{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "769229ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch            : 1.10.1\n",
      "pytorch_lightning: 1.5.1\n",
      "torchmetrics     : 0.6.2\n",
      "matplotlib       : 3.3.4\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -p torch,pytorch_lightning,torchmetrics,matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24cee7ef",
   "metadata": {},
   "source": [
    "The three extensions below are optional, for more information, see\n",
    "- `watermark`:  https://github.com/rasbt/watermark\n",
    "- `pycodestyle_magic`: https://github.com/mattijn/pycodestyle_magic\n",
    "- `nb_black`: https://github.com/dnanhkhoa/nb_black"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6aae6f76",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext pycodestyle_magic\n",
    "%flake8_on --ignore W291,W293,E703,E402,E999 --max_line_length=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6604cf12",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 3;\n",
       "                var nbb_unformatted_code = \"%load_ext nb_black\";\n",
       "                var nbb_formatted_code = \"%load_ext nb_black\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%load_ext nb_black"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5a2daee",
   "metadata": {},
   "source": [
    "<a href=\"https://pytorch.org\"><img src=\"https://raw.githubusercontent.com/pytorch/pytorch/master/docs/source/_static/img/pytorch-logo-dark.svg\" width=\"90\"/></a> &nbsp; &nbsp;&nbsp;&nbsp;<a href=\"https://www.pytorchlightning.ai\"><img src=\"https://raw.githubusercontent.com/PyTorchLightning/pytorch-lightning/master/docs/source/_static/images/logo.svg\" width=\"150\"/></a>\n",
    "\n",
    "# MobileNetV3 (Large) Trained on CIFAR-10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9ad59f4",
   "metadata": {},
   "source": [
    "MobileNetV3 [1] trained on CIFAR-10 [2].\n",
    "\n",
    "### References\n",
    "\n",
    "- [1] Searching for MobileNetV3, https://arxiv.org/abs/1905.02244.pdf\n",
    "- [2] https://en.wikipedia.org/wiki/CIFAR-10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "791cf670",
   "metadata": {},
   "source": [
    "## General settings and hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62b088bb",
   "metadata": {},
   "source": [
    "- Here, we specify some general hyperparameter values and general settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d3a7f40f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 4;\n",
       "                var nbb_unformatted_code = \"BATCH_SIZE = 256\\nNUM_EPOCHS = 150\\nLEARNING_RATE = 0.001\\nNUM_WORKERS = 4\";\n",
       "                var nbb_formatted_code = \"BATCH_SIZE = 256\\nNUM_EPOCHS = 150\\nLEARNING_RATE = 0.001\\nNUM_WORKERS = 4\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "BATCH_SIZE = 256\n",
    "NUM_EPOCHS = 150\n",
    "LEARNING_RATE = 0.001\n",
    "NUM_WORKERS = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bb03d6c",
   "metadata": {},
   "source": [
    "- Note that using multiple workers can sometimes cause issues with too many open files in PyTorch for small datasets. If we have problems with the data loader later, try setting `NUM_WORKERS = 0` and reload the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7a2d6b1",
   "metadata": {},
   "source": [
    "## Implementing a Neural Network using PyTorch Lightning's `LightningModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6145ca8b",
   "metadata": {},
   "source": [
    "- In this section, we set up the main model architecture using the `LightningModule` from PyTorch Lightning.\n",
    "- In essence, `LightningModule` is a wrapper around a PyTorch module.\n",
    "- We start with defining our neural network model in pure PyTorch, and then we use it in the `LightningModule` to get all the extra benefits that PyTorch Lightning provides.\n",
    "- Here, for the PyTorch model, we are using an implementation from the Torchvision hub:\n",
    "\n",
    "In this case, since Torchvision already offers a nice and efficient PyTorch implementation of MobileNet-v2, let's load it from the Torchvision hub:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "af36f155",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using cache found in /home/jovyan/.cache/torch/hub/pytorch_vision_v0.11.0\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 5;\n",
       "                var nbb_unformatted_code = \"import torch\\n\\n\\npytorch_model = torch.hub.load(\\n    'pytorch/vision:v0.11.0',\\n    'mobilenet_v3_large',\\n    pretrained=False)\";\n",
       "                var nbb_formatted_code = \"import torch\\n\\n\\npytorch_model = torch.hub.load(\\n    \\\"pytorch/vision:v0.11.0\\\", \\\"mobilenet_v3_large\\\", pretrained=False\\n)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "\n",
    "pytorch_model = torch.hub.load(\n",
    "    'pytorch/vision:v0.11.0',\n",
    "    'mobilenet_v3_large',\n",
    "    pretrained=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1404890",
   "metadata": {},
   "source": [
    "- Since the Torchvision model above was implemented for ImageNet, which has a different number of classes than CIFAR-10, we define our own output layer below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7669c141",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 6;\n",
       "                var nbb_unformatted_code = \"pytorch_model.classifier[-1] = torch.nn.Linear(\\n        in_features=1280,  # as in the original output layer\\n        out_features=10)  # number of class labels in CIFAR-10)\";\n",
       "                var nbb_formatted_code = \"pytorch_model.classifier[-1] = torch.nn.Linear(\\n    in_features=1280, out_features=10  # as in the original output layer\\n)  # number of class labels in CIFAR-10)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pytorch_model.classifier[-1] = torch.nn.Linear(\n",
    "        in_features=1280,  # as in the original output layer\n",
    "        out_features=10)  # number of class labels in CIFAR-10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "056a50a5",
   "metadata": {},
   "source": [
    "- Next, we can define our LightningModule as a wrapper around our PyTorch model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "230660b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 7;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\\nimport pytorch_lightning as pl\\nimport torchmetrics\\n\\n\\n# LightningModule that receives a PyTorch model as input\\nclass LightningModel(pl.LightningModule):\\n    def __init__(self, model, learning_rate):\\n        super().__init__()\\n\\n        self.learning_rate = learning_rate\\n        # The inherited PyTorch module\\n        self.model = model\\n        if hasattr(model, \\\"dropout_proba\\\"):\\n            self.dropout_proba = model.dropout_proba\\n\\n        # Save settings and hyperparameters to the log directory\\n        # but skip the model parameters\\n        self.save_hyperparameters(ignore=[\\\"model\\\"])\\n\\n        # Set up attributes for computing the accuracy\\n        self.train_acc = torchmetrics.Accuracy()\\n        self.valid_acc = torchmetrics.Accuracy()\\n        self.test_acc = torchmetrics.Accuracy()\\n\\n    # Defining the forward method is only necessary\\n    # if you want to use a Trainer's .predict() method (optional)\\n    def forward(self, x):\\n        return self.model(x)\\n\\n    # A common forward step to compute the loss and labels\\n    # this is used for training, validation, and testing below\\n    def _shared_step(self, batch):\\n        features, true_labels = batch\\n        logits = self(features)\\n        loss = torch.nn.functional.cross_entropy(logits, true_labels)\\n        predicted_labels = torch.argmax(logits, dim=1)\\n\\n        return loss, true_labels, predicted_labels\\n\\n    def training_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.log(\\\"train_loss\\\", loss)\\n\\n        # Do another forward pass in .eval() mode to compute accuracy\\n        # while accountingfor Dropout, BatchNorm etc. behavior\\n        # during evaluation (inference)\\n        self.model.eval()\\n        with torch.no_grad():\\n            _, true_labels, predicted_labels = self._shared_step(batch)\\n        self.train_acc(predicted_labels, true_labels)\\n        self.log(\\\"train_acc\\\", self.train_acc, on_epoch=True, on_step=False)\\n        self.model.train()\\n\\n        return loss  # this is passed to the optimzer for training\\n\\n    def validation_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.log(\\\"valid_loss\\\", loss)\\n        self.valid_acc(predicted_labels, true_labels)\\n        self.log(\\n            \\\"valid_acc\\\",\\n            self.valid_acc,\\n            on_epoch=True,\\n            on_step=False,\\n            prog_bar=True,\\n        )\\n\\n    def test_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.test_acc(predicted_labels, true_labels)\\n        self.log(\\\"test_acc\\\", self.test_acc, on_epoch=True, on_step=False)\\n\\n    def configure_optimizers(self):\\n        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\\n        return optimizer\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\\nimport pytorch_lightning as pl\\nimport torchmetrics\\n\\n\\n# LightningModule that receives a PyTorch model as input\\nclass LightningModel(pl.LightningModule):\\n    def __init__(self, model, learning_rate):\\n        super().__init__()\\n\\n        self.learning_rate = learning_rate\\n        # The inherited PyTorch module\\n        self.model = model\\n        if hasattr(model, \\\"dropout_proba\\\"):\\n            self.dropout_proba = model.dropout_proba\\n\\n        # Save settings and hyperparameters to the log directory\\n        # but skip the model parameters\\n        self.save_hyperparameters(ignore=[\\\"model\\\"])\\n\\n        # Set up attributes for computing the accuracy\\n        self.train_acc = torchmetrics.Accuracy()\\n        self.valid_acc = torchmetrics.Accuracy()\\n        self.test_acc = torchmetrics.Accuracy()\\n\\n    # Defining the forward method is only necessary\\n    # if you want to use a Trainer's .predict() method (optional)\\n    def forward(self, x):\\n        return self.model(x)\\n\\n    # A common forward step to compute the loss and labels\\n    # this is used for training, validation, and testing below\\n    def _shared_step(self, batch):\\n        features, true_labels = batch\\n        logits = self(features)\\n        loss = torch.nn.functional.cross_entropy(logits, true_labels)\\n        predicted_labels = torch.argmax(logits, dim=1)\\n\\n        return loss, true_labels, predicted_labels\\n\\n    def training_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.log(\\\"train_loss\\\", loss)\\n\\n        # Do another forward pass in .eval() mode to compute accuracy\\n        # while accountingfor Dropout, BatchNorm etc. behavior\\n        # during evaluation (inference)\\n        self.model.eval()\\n        with torch.no_grad():\\n            _, true_labels, predicted_labels = self._shared_step(batch)\\n        self.train_acc(predicted_labels, true_labels)\\n        self.log(\\\"train_acc\\\", self.train_acc, on_epoch=True, on_step=False)\\n        self.model.train()\\n\\n        return loss  # this is passed to the optimzer for training\\n\\n    def validation_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.log(\\\"valid_loss\\\", loss)\\n        self.valid_acc(predicted_labels, true_labels)\\n        self.log(\\n            \\\"valid_acc\\\",\\n            self.valid_acc,\\n            on_epoch=True,\\n            on_step=False,\\n            prog_bar=True,\\n        )\\n\\n    def test_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.test_acc(predicted_labels, true_labels)\\n        self.log(\\\"test_acc\\\", self.test_acc, on_epoch=True, on_step=False)\\n\\n    def configure_optimizers(self):\\n        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\\n        return optimizer\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\n",
    "import pytorch_lightning as pl\n",
    "import torchmetrics\n",
    "\n",
    "\n",
    "# LightningModule that receives a PyTorch model as input\n",
    "class LightningModel(pl.LightningModule):\n",
    "    def __init__(self, model, learning_rate):\n",
    "        super().__init__()\n",
    "\n",
    "        self.learning_rate = learning_rate\n",
    "        # The inherited PyTorch module\n",
    "        self.model = model\n",
    "        if hasattr(model, \"dropout_proba\"):\n",
    "            self.dropout_proba = model.dropout_proba\n",
    "\n",
    "        # Save settings and hyperparameters to the log directory\n",
    "        # but skip the model parameters\n",
    "        self.save_hyperparameters(ignore=[\"model\"])\n",
    "\n",
    "        # Set up attributes for computing the accuracy\n",
    "        self.train_acc = torchmetrics.Accuracy()\n",
    "        self.valid_acc = torchmetrics.Accuracy()\n",
    "        self.test_acc = torchmetrics.Accuracy()\n",
    "\n",
    "    # Defining the forward method is only necessary\n",
    "    # if you want to use a Trainer's .predict() method (optional)\n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "\n",
    "    # A common forward step to compute the loss and labels\n",
    "    # this is used for training, validation, and testing below\n",
    "    def _shared_step(self, batch):\n",
    "        features, true_labels = batch\n",
    "        logits = self(features)\n",
    "        loss = torch.nn.functional.cross_entropy(logits, true_labels)\n",
    "        predicted_labels = torch.argmax(logits, dim=1)\n",
    "\n",
    "        return loss, true_labels, predicted_labels\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        loss, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.log(\"train_loss\", loss)\n",
    "\n",
    "        # Do another forward pass in .eval() mode to compute accuracy\n",
    "        # while accountingfor Dropout, BatchNorm etc. behavior\n",
    "        # during evaluation (inference)\n",
    "        self.model.eval()\n",
    "        with torch.no_grad():\n",
    "            _, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.train_acc(predicted_labels, true_labels)\n",
    "        self.log(\"train_acc\", self.train_acc, on_epoch=True, on_step=False)\n",
    "        self.model.train()\n",
    "\n",
    "        return loss  # this is passed to the optimzer for training\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        loss, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.log(\"valid_loss\", loss)\n",
    "        self.valid_acc(predicted_labels, true_labels)\n",
    "        self.log(\n",
    "            \"valid_acc\",\n",
    "            self.valid_acc,\n",
    "            on_epoch=True,\n",
    "            on_step=False,\n",
    "            prog_bar=True,\n",
    "        )\n",
    "\n",
    "    def test_step(self, batch, batch_idx):\n",
    "        loss, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.test_acc(predicted_labels, true_labels)\n",
    "        self.log(\"test_acc\", self.test_acc, on_epoch=True, on_step=False)\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n",
    "        return optimizer\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51424191",
   "metadata": {},
   "source": [
    "## Setting up the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7aac5a4",
   "metadata": {},
   "source": [
    "- In this section, we are going to set up our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63292b0e",
   "metadata": {},
   "source": [
    "### Inspecting the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b204d78e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "\n",
      "Training label distribution:\n",
      "\n",
      "Test label distribution:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(0, 1000),\n",
       " (1, 1000),\n",
       " (2, 1000),\n",
       " (3, 1000),\n",
       " (4, 1000),\n",
       " (5, 1000),\n",
       " (6, 1000),\n",
       " (7, 1000),\n",
       " (8, 1000),\n",
       " (9, 1000)]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 8;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/dataset_cifar10_check.py\\nfrom collections import Counter\\nfrom torchvision import datasets\\nfrom torchvision import transforms\\nfrom torch.utils.data import DataLoader\\n\\n\\ntrain_dataset = datasets.CIFAR10(\\n    root=\\\"./data\\\", train=True, transform=transforms.ToTensor(), download=True\\n)\\n\\ntrain_loader = DataLoader(\\n    dataset=train_dataset,\\n    batch_size=BATCH_SIZE,\\n    num_workers=NUM_WORKERS,\\n    drop_last=True,\\n    shuffle=True,\\n)\\n\\ntest_dataset = datasets.CIFAR10(\\n    root=\\\"./data\\\", train=False, transform=transforms.ToTensor()\\n)\\n\\ntest_loader = DataLoader(\\n    dataset=test_dataset,\\n    batch_size=BATCH_SIZE,\\n    num_workers=NUM_WORKERS,\\n    drop_last=False,\\n    shuffle=False,\\n)\\n\\ntrain_counter = Counter()\\nfor images, labels in train_loader:\\n    train_counter.update(labels.tolist())\\n\\ntest_counter = Counter()\\nfor images, labels in test_loader:\\n    test_counter.update(labels.tolist())\\n\\nprint(\\\"\\\\nTraining label distribution:\\\")\\nsorted(train_counter.items())\\n\\nprint(\\\"\\\\nTest label distribution:\\\")\\nsorted(test_counter.items())\";\n",
       "                var nbb_formatted_code = \"# %load ../code_dataset/dataset_cifar10_check.py\\nfrom collections import Counter\\nfrom torchvision import datasets\\nfrom torchvision import transforms\\nfrom torch.utils.data import DataLoader\\n\\n\\ntrain_dataset = datasets.CIFAR10(\\n    root=\\\"./data\\\", train=True, transform=transforms.ToTensor(), download=True\\n)\\n\\ntrain_loader = DataLoader(\\n    dataset=train_dataset,\\n    batch_size=BATCH_SIZE,\\n    num_workers=NUM_WORKERS,\\n    drop_last=True,\\n    shuffle=True,\\n)\\n\\ntest_dataset = datasets.CIFAR10(\\n    root=\\\"./data\\\", train=False, transform=transforms.ToTensor()\\n)\\n\\ntest_loader = DataLoader(\\n    dataset=test_dataset,\\n    batch_size=BATCH_SIZE,\\n    num_workers=NUM_WORKERS,\\n    drop_last=False,\\n    shuffle=False,\\n)\\n\\ntrain_counter = Counter()\\nfor images, labels in train_loader:\\n    train_counter.update(labels.tolist())\\n\\ntest_counter = Counter()\\nfor images, labels in test_loader:\\n    test_counter.update(labels.tolist())\\n\\nprint(\\\"\\\\nTraining label distribution:\\\")\\nsorted(train_counter.items())\\n\\nprint(\\\"\\\\nTest label distribution:\\\")\\nsorted(test_counter.items())\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_dataset/dataset_cifar10_check.py\n",
    "from collections import Counter\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "\n",
    "train_dataset = datasets.CIFAR10(\n",
    "    root=\"./data\", train=True, transform=transforms.ToTensor(), download=True\n",
    ")\n",
    "\n",
    "train_loader = DataLoader(\n",
    "    dataset=train_dataset,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    num_workers=NUM_WORKERS,\n",
    "    drop_last=True,\n",
    "    shuffle=True,\n",
    ")\n",
    "\n",
    "test_dataset = datasets.CIFAR10(\n",
    "    root=\"./data\", train=False, transform=transforms.ToTensor()\n",
    ")\n",
    "\n",
    "test_loader = DataLoader(\n",
    "    dataset=test_dataset,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    num_workers=NUM_WORKERS,\n",
    "    drop_last=False,\n",
    "    shuffle=False,\n",
    ")\n",
    "\n",
    "train_counter = Counter()\n",
    "for images, labels in train_loader:\n",
    "    train_counter.update(labels.tolist())\n",
    "\n",
    "test_counter = Counter()\n",
    "for images, labels in test_loader:\n",
    "    test_counter.update(labels.tolist())\n",
    "\n",
    "print(\"\\nTraining label distribution:\")\n",
    "sorted(train_counter.items())\n",
    "\n",
    "print(\"\\nTest label distribution:\")\n",
    "sorted(test_counter.items())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94612edb",
   "metadata": {},
   "source": [
    "### Performance baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9122146",
   "metadata": {},
   "source": [
    "- Especially for imbalanced datasets, it's pretty helpful to compute a performance baseline.\n",
    "- In classification contexts, a useful baseline is to compute the accuracy for a scenario where the model always predicts the majority class -- we want our model to be better than that!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "73c408db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Majority class: 3\n",
      "Accuracy when always predicting the majority class:\n",
      "0.10 (10.00%)\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 9;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/performance_baseline.py\\nmajority_class = test_counter.most_common(1)[0]\\nprint(\\\"Majority class:\\\", majority_class[0])\\n\\nbaseline_acc = majority_class[1] / sum(test_counter.values())\\nprint(\\\"Accuracy when always predicting the majority class:\\\")\\nprint(f\\\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\\\")\";\n",
       "                var nbb_formatted_code = \"# %load ../code_dataset/performance_baseline.py\\nmajority_class = test_counter.most_common(1)[0]\\nprint(\\\"Majority class:\\\", majority_class[0])\\n\\nbaseline_acc = majority_class[1] / sum(test_counter.values())\\nprint(\\\"Accuracy when always predicting the majority class:\\\")\\nprint(f\\\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_dataset/performance_baseline.py\n",
    "majority_class = test_counter.most_common(1)[0]\n",
    "print(\"Majority class:\", majority_class[0])\n",
    "\n",
    "baseline_acc = majority_class[1] / sum(test_counter.values())\n",
    "print(\"Accuracy when always predicting the majority class:\")\n",
    "print(f\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9e20607",
   "metadata": {},
   "source": [
    "## A quick visual check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a3984318",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcEAAAHRCAYAAAASbQJzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9eay1a5reB/2e6Z3WsNeevvk7p05Vna7qobrTbTvGFoPBYEOUEDEIAcYJEhEQKeIfiCJFSDEoIIJAQoJEQshYCY5RjJI4g2wgIY27jds9267q6u7TVafO9M17WsM7PhN/PO9ae+3vnKo6p11VXe3ad9X+zt5rvWu90/M+93Nf93Vft4gxcmu3dmu3dmu39qNo8g/6AG7t1m7t1m7t1v6g7NYJ3tqt3dqt3dqPrN06wVu7tVu7tVv7kbVbJ3hrt3Zrt3ZrP7J26wRv7dZu7dZu7UfWbp3grd3ard3arf3I2q0TvLVb2zMhxN8QQvzT3+ttP+Mx/GeEEL/7vf7eW7u1W/u4ids6wVv7w25CiM3enxXQA378+38UY/w3f/BHdWu3dmt/GOzWCd7aP1QmhHgP+GdijP/xJ7ynY4zuB39Ut3Zrt/bDardw6K39Q2tCiD8lhPhICPEvCCGeA39JCHEohPgPhRCvhBCX4++P9j7z/xVC/DPj7/99IcTfEkL878ZtvyWE+K/8Prd9SwjxC0KItRDiPxZC/KtCiL/8nY577+/3hBD/vBDi7wshaiHEXxRC3B3h2O33He5t//8QQjwXQizHff7k3nvHQoj/QAixEkL8qhDiXxZC/K29978shPiPhBAXQojfFUL8t/be+8eEEF8f9/lECPE/+we4Pbd2az8UdusEb+0fdrsHHAFvAv9D0pj/S+PfbwAt8H/6Dp//48DvAifA/xb4i0II8fvY9q8AvwIcA38B+POf8Tz+G8B/Cfgx4J8A/gbwL477ksD/ZG/bvwG8DdwBfgPYh4P/VaAmXZd/evwBQAgxAf6j8VjvAP8d4F/bc6J/kQQvz4CfAv6Tz3gOt3ZrP3Sm/6AP4NZu7ftsAfiXYoz9+HcL/NvbN4UQ/yvg57/D59+PMf5fxm3/deBfA+4Czz/ttkKIDPhjwJ+OMQ7A3xJC/Puf8Tz+jzHGF+N3/yLwMsb4m+Pf/y7wp7cbxhj/r3vn9xeASyHEAbAhOdOfijE2wNfH4/xT4+b/OPBejPEvjX//hhDi3wb+m8BvARb4CSHE34sxXgKXn/Ecbu3WfujsNhK8tX/Y7VWMsdv+IYSohBD/ZyHE+0KIFfALwEIIob7N53fObnQcANPPuO0D4GLvNYAPP+N5vNj7vf2Ev6cAQgglhPjfCCG+OZ7fe+M2J8ApaeG7v+/9398E/rgQ4mr7A/w5UtQIyYH+Y8D7Qoi/KYT4E5/xHG7t1n7o7NYJ3to/7PY68+t/CnwJ+OMxxjnwnx1f/3YQ5/fCngFHQohq77XH36d9/XeBfxL4LwIHwOfG1wXwCnDAo73t94/jQ+BvxhgXez/TGOM/CxBj/NUY4z9Jgkr/GvBXv0/ncGu39gOzWyd4az9qNiNFTldCiCPgX/p+7zDG+D7wa8BfEEJkYwT1T3yfdjcjlYick8pF/td7x+GBf2c8jkoI8WXgn9r77H8I/JgQ4s8LIcz488eEED8+HvefE0IcxBgtsOK6DOXWbu0Prd06wVv7UbP/A1ACZ8DfAf6fP6D9/jngT5Cc078M/FskZ/W9tn8DeB94AnyddI779s+RIsTnwP8N+L9vjyPGuAb+DPDfBp6O2/wrQD5+9s8D740w6/8Y+O99H47/1m7tB2q3dYK3dmt/ACaE+LeA34kxft8j0e9yHP8KcC/G+D1Xvrm1W/vDYLeR4K3d2g/ARljxC0IIKYT4L5Pydn/tD+A4viyE+GmR7B8F/gfAv/uDPo5bu7UfFrstkbi1W/vB2D1SPu4Y+Aj4Z7clDj9gm5Eg0AfAS+B/D/x7fwDHcWu39kNht3Dord3ard3arf3I2i0cemu3dmu3dms/snbrBG/t1m7t1m7tR9a+Y05QCHGLld7ard3ard3aH2qLMX5bMYzbSPDWbu3Wbu3WfmTtM7FDt3r4cffP9o29379b7Cg+xTbfCxN7u/oO+1Pq20lG/uGxGOPuZ2tSbtc3n3zBv30jhB8CixD3jjmEcP2ekLszEteb/wPbZxnC3xuL8BlIadv7dX3f4vb/r33n9Wsfv8di91x8l72x/Zbt8xM/vrPrTXcb8rE//jA9X/vPzyc9H9777/j+9Rel6/VJ22z38YmfF+KTx4QQH7tn30tC4+/7u77bQ/ODf6h+X/apneBXfubzVFVBiIHgAyEEQgwIKZBSIIQghIjzjhgiEEFIII7XQozbKrz3+BCwzqabHq+nvBhBSIkUAqMlEoFA4H36/hAiQsT0MAuZJn8gxoAQIKTAGI1WCq00IXiC9/RDh0DiXOQb7zzD+4DWmr/8l/8yX/ziF3cT7Xd3DhEIeO8JISCEQEiJUmp3piDS6W83/zYmdv989jEiEOm82o5f+9Vf5be+/jX+jb/yVxiGAaU0/8I//y/y8OFjynKCdT3WWjabmjzLybOC2Xw63rOwdyw3z/0HO27T3qSIOO9p6hapJBcX5/wv/pf/c/q+RyjNV/7sP0cxOybE7dWO47wxTtLbsfTaf9ODHkGEceyINF4QCCER4xjeLSZiJGydSrzpEJJ9goMBEFvn9pqTE2LnSGKM9JsL3vn5v0T0DoRg8fAhJs/JjcYoSfSe1WpJkecURcHDBw84vXPCo0cPUBLwDtc0uM0G37Q0V5dcND2vmo4eRSYVh0ajpUbqnPz0MeXimPLgkGk1RSoFWiFNjlASpSRSgJRgjMZ7z2AHXp1dcrVc8/6HH/H86QtWqzXBRlRWoPMSOT0kRoHtHYVriN0VL7/xixADVVXxV//qX+XevXv8sJkf73OIkfV6xXq14rd+66tMp1MOF4d88QtfJM9yZAQhFd/85rv8uX/qz+GcwyjFf+2P/REmeY4U4BFEIQlKc950rPqei37g8PiA+/dPWSxmtF3PB+99xOXlmhgib3/p8yiVrnc5qTBZRl5UrFcNXW+p6x6pDdoYFofHzGdzjg8PsX3D5dkrfuNv/y1O84wDoylNmsZjBO8dIJBKprls9Ksh7M3ZQiClRErJ+XrDv/d3foU4Pk+HVYGQaZjrXCIVSA1GG5SSCAkyl6hCYiaKCLguYJtI8AKlFEJHhAKTGSQgiXSbHm890W6fWrDWIiJIZHovpGfVB7+b67fPqjYaKRVSKbz1BB9wgxvdRyTKOJ6XACFwPnC16j7x3r9un8oJCgGTScF0VhJCTA4gBmIIuwdoO6Fa54ghpJX6uLKJMe4uulQK5xzeBwanxm2vo5jkBAVKSDKj2LpB5wTBR3yICHHtfMLOiV47wSwzaKXJjCF4h/ce04MUCmvD9XwlBD/+4z/OV77ylRtOMMZPXsWl49s6wfS9QqTzV1p/ohPcZlVvrLbGyXf7+3ZQfLv9bY8lxrjbXiLxztOsN1ycnXF+9mq3nZSCL37xx3j77R9jcbDg/PKMzWbN2atzptMZs9mcx48foZRKD8XusK7P+Qe/cNsO+IiznvW6ZrPZ8GGeI4TcHd/0+BHlwd200oZrB7ddYcfkFOPohHYPCSFtJ7f3eesIBTA+PNffeH1UMRJ9uPFq2vN3yiSEa0e4/217x6NMjkDsItqyKimKgsIoyixDBI/xA1VVUpUV9xYz7hzMuHcwReHBO6KK+OjwItL5CUZKbIRa5WTKcFAWGF2ishJxeJdsusBUB+iiQGmNNIZiOsVkGdUkp8g0WabQRuG8YxgGpodLlss1upiidcnZqwsuL9bovCKrZojZET4KYj+QdStidLurqJTiK1/5Cm+88cY/2ND4HluMERcCIaYF16uXLzg/O+Ply+ccHx7x4O49vvKlH6csJ5jMgFRkWX79fAnB6XzOvCxRQmCBKCUxL9BNR94NxLbh7t0T3njzEfODCW3b4VykmmwIIXLv/j0iHh8ss4M5WV5QlBNceIWnJQuS2XzBdH7Aw4ePWSwWnBwdcfnqOVoKJmXJ8XTCSZFTbZ0g4J1LzkCphAYJCDESxsBju3CXUiJkmrd3cb8AYyRSCqIAkwukFqhMkpkMrRTIgColZiIxM02MYNtALwN+YHSCyXHqzKCkxAjQAvzg8X2aoyPgnEJEgYgC21q8Dyk4iWleT3Nyema0TscllUTEQBACESQxpPsZZEwOekTAvkMK8GP2qSPBdFDXByYYI7YxCtpe2O0g20762+3VeFOklAgUUgJSJ68fw+4zgvQjZUjbjxPOFlW5hhPSKkoiiHGcTMS4GhApooCAVGlyzVAooZEy8N0uz3ePBsd9RjH+LrnpzcbrI7aYbCRGvwsMpFBch4rAdzii/WMR22iC62vhvMeNA3zfTo6PefTwAQ8e3eXXfv0l680ZHz75Jvfu3aeaaN783D3Ksvz+9k74fZpzgc265Vd++dd48fwlMd48t+3iCq4PPzm161dCGN1L3K6EBUG85pS4hpET0pXum5ICrSRKyvSQ+9GJjnuMKG4e0Xex0SEmZ82NRd/2fA7LjLLQGBE5mWRkwOAqZpOKSVkwDR35xXNsfc4wdAjv0M6h24HMeUqlqZuBoutoq5yoDUM5QU7v4XXFqwaa85e03UcIazFaUuQZd+/f5WAx53Nv3iM/WVBUFUSHwIF03D2ecGdR8fl7x3xzMeGjD5/yS7/yNXRmKKoSqyIDgQGHbhuia77tZfihspAcw9B3nL14yZMnH/HBe+9DZzk2FcOTS7JFwNw7YgxnXjOJICEIaRKWyCJnmueoELHrFad3T3jw8D7gyPKMz3/eYO2IZhm4Wl5xta6RWcHgBd0Av/O73+D8/AqlDV/+iZ/k8eEhn3vrLWbTKdOq4qP33+Xi4pKmaYiTEq0VcpwjQoy7uVhrnaJ9kVAyLwXKB3wI13NojOxTHwWgDUidUDtlQGqJLjJMliGlIjKgc4kpFMqMS8YgGGSAGPCdQ2oFRjG4AWM0WZGRZTlBBGz0CCWQSiBVSfDgbSTQEwZHqC1KSbQQBHwKNpxL0Z/woPwuahxXzWynWbj2PSF8+if0UznBGMHZAWsl3qfJ/Ho1ISAGtnGEVnLEtlNYK2WakFJ4Pk4hEqSQSKWxAVyA4NwuQtq+r4Rg+z8lNUJ4BOBDREqBGlc6EAlRIsU2agqEAN4nRwgBpdLkFvYd1mv2afJkKVJM5+ScB/x1tLbF7kVakQXvidHtIpUo0iIgyzKsS5Fk23YopVHakOf5bqHw3Q9kPO/gx5/wsfeFvF5BDbbn61//LZ48ecL7771H02yYTCcJanv4kPl8zvHx8V50lL7kB586FOMCR7Berzk/v7jhMEII4xhM5xv3naGIY2zFbgwyQl5bBxe5Rn23UdkWKoI0RgQCL/b3565doJDEncf9dhfnevFz87zSEcgxNbC3NV+cTZgXGdpbKhExRGRVYGREux6zHtBKoLUEPCJGVPBkMS0GfYRpkXGnqIjVglhMyA8OcWrBEDLOL5e0jWXoekTbQvCI6Dl7dcZ0WtCvH1L8zE9wfPCIy/UFzlmsc3SDJ1iP7x1Frnhw/4S3v/CIFy/PefHBO3gRkGVOdnSMAIL8QyJCJcC5gcvzc4o85+H9h/wX/tSf5qicclzOePG732J1OOd+lZMtJrweWPjxhwhDCGm8eMfk+JjDyZRD75jOKrRWfPjRE7q2w9lIUU5QSlPXLdbalDOVhogmRMlkekAUhmoy5eHDhzx4cJ+DgwOi97x69ZLnz59zcXGBMRlCpIjpxijbgzrlOMb8Nsy78Wxv7SZkL7VM0KNWCO1BCTyR1g7jd3uCk2A9eTQIBFpKMpWgU+8guoCzAYcn5AYjBCLs7zEdc17keB+x0kM/gBdjlBjxMWDpR2iQvfRGQMhxrvZbxCd9q4gCKa7RlU9rn3rE+nHy8d4Ro7ieLHcwZkyT1whTCpGufppb4p63jiTkSaCkIvpAEAECu8+n/EQKk7eRoEClSStEQvS7iXLrdSThJmmAFFoLGXfbSiWQ/pOv0MeJB59sadIVeJ+c4HYSllLtrokUadHg7EDwdvxeQJkEQQaFcxbnHE1To02GMQGl1I5IcON4bkQ+NyHLEK6j6NeOdHSEyal473n56iXrzYb1eoXSiqqqKMuKYRg4PT0lMxl5kZMZk1aRn3k4/YPY9vi3kC50XZdWvHunFmMgxvAxpx/ZOsBrZ7V9PV2L7fviNfj9JqkoBWtpoeNDJIa4yx/F8bhuHu/Hbb+y6JNIB1sodv/vU6NTDk8EDAEVI1mmGJfKyOCRAoS6vqcyRpSQSCHxRPJMM8unrMopoZhiZgsGV9H1gnrw9NbjrEf0lmAt3vasQk+9MhzNFV3zBkTPMHQMdsB5R9sMOOvxvSXXOdNpxeNHd6nXSz5Yn+NdjZ5MKaYFREP8Q+IEYwzp+asbMpNRFhUnJ6foIaAaywdPX1B1HYu330TOio/d7RBTXpEocCHiRQQhyCcV8+ND5lKgVLpP69WapmkQKEyWFrpd1+KdT4t9qcdFvmY2X5AXE+YHc05OTjg8PCTPc+rNhuVySV3XDMOAMSZN+OOqTqTI5IajE1zPjzcWtzfm7ZvnteV4KCUROhIleBlTBBkimoj0ER8g+IAUKsXEYuuAIs7HND9Gj0BgjUNLuUNBtuiMlDI9tyoQ5ZjXUymoigQCHqQgUUC255ICIGKKvQTxxjlsgxD5GeatTz1i9xe+aSICkIlUQBxfSw5QjznC68klELxnnF7ItEohr1EI61FOYklhvZKSLDOASAFmSFiEFGa3ko74dKO0RI/hf/KiacLbklZiDKNTHh2rlAjx+uT52fNfIUDfD9R1QwgeYzLKkp3zliJydXFB02wwKpJlhizPMYUkBMEw9Djnx5xiSmaHkK6V1posy3bwsdL6GlrdHvNuAAeGYRgjo9fOQkbAE0KfHEaQZLoiBknT9Pze772Lc462bfjlX/5Vjo6O+Lmf/Vm+8pWf4q233mJxuNhd73EEfMar9Fltf18jlO4Dzt5sWbcfte0+uXvotzB9epDjNgcXdkHhJ9o+pK+U2g12533CEYQmEHYPL3GLMHzCWYwPaoLA96CnvfwjY2ph95kIB5tLjlxGTkSRJrRoFAFHiB6dkK0EwUUJQuKNpAO8ACsVcT5jdniHUlT4fEqxOOH8Zcey67EhjbVMa1SeEZXEKUkYPJmSGBHwtqPra1RmMFoivENFQVAOh2DZNIgo+BN/8mcpjGNz/gFnT1/hmo7+iYD5GwSRfZqb/QdufdvRNS1D33NyeMx0OqXrBn7rt36Tr/2dXyM/bzh+fJ/q7CX3j6Y3GidGYAD6CMoHbIiITDM/PGJysKCaTYkxPd/O2XHBnOZAZwdEjKwvLpBSY0zGQTUjKyqkznn48C3yImc2m3J4eMhsPqPvey6vLnny9CmHh4cUWkG9xog0x2ml9hAPrqGO7aJcxh1aJaXcEYLSJuLGmbkQIHiCF2TZOMcWGmtT2iVYRwwSEQ2uFUgiykV851POz475uCgQUeGHwGZZY4wafYLYIYmwSa8JcKEjiIApFT4m6NNoSRgg9BEVx3leRCTJoXp8ehaiIFo7RgXjHPAZxsKnc4ICtNYYY9IiYnyAtdEordBa4d0+FrvNzaWJLeX8fILWJWg5Qp4xoGIY3x9DeSERQqXISiUyTPL41yzUXcQlBVqr0WFsh2dMTmWcaKS6npgS/HVz8vLO4p3dRXLbeThuJ7Pr8TGeS8TawDBYhn4Y85gSpy3BbScqjx06vO1RCEKQiUQk0uLAh8Sq1VIzmUwTvBrTuSQoNBJDSJGIDzvYOYR0Lb0PFEU+wrIBZx3OuhuzvCA5ga7refHiFU+fPsNah4oJJmnbBu/TZ9u24eIi8tWvfpWua3nx8iV/5I/8HNPplKqqdjktxoUNfOfI+dtRruOeJ3o9v7k7brH//seTMZnRZEbjvE/HMzqVFN2JHaTuR8h664z2LswYTW+P/+YtHglp47YjN1lKZIy74/3EoTH+djN2jrtFt9iDbRCvO9GIkQEjfHomRiTFjaQlKQVBpOhWocacpMQJzSBJzqwsabVm0w/E2SHC5HgEPniitxAsEo8UATFG0xCQEvJMc+/uKVmRMziHHUkjcUxZCC1wwuFEyrVnheLho7v83M/9FL/SrVitW9qmBV1/DJ77YbHXI//1apUitM2GYRho246vfu3rPH/+HCsEh3dPMEcHNMHhPuGcHJHee3AOJwUagTIZ/WAJqw2bzTKRQozm4OCQIq/oug4hBM4O+KZBZQVGGUwUqCCIPpJnGVVVsVgsKMsCieDqasl6taLrOubVBE1MC+XgkCQEiRgRW+c2zsPC+3HeuB5r1+S5j0Op20VeCJHgfHI+QaB12j4TGucCeEHowfUuPTAD+NbibSC4xJSNQhFDIqsItX3sI94FBCll5m0KXKIIZJlCZAqNBCVBR2SpadeWdtkjBpX2NR4nkNJho8OV27lpGxF/hkH46dihgDGGLDPpgRwvqjEGrVLklybtxBjdwZ/b/FkMxJBuiBQSpQRaCmLw6BDG8HfcVxQIFFJojNG4wREIu/l9R20XoEQqhzBaoY3mphMcL7xIjs97m1ZjMd64QHZIsGWWFdfJ1TEoiftXfPzuECLWJgfY98NIwgGnVAoRYwActu/wbiAoSQw6DVJSPtIHv3PeZZ7hQ4IXhLiOS1P0Bs77XVQ4eJecnvdkmUmLjtGR2cHezA0gCSE5wadPn/PhR0+w1gIar+T4e9qdHSzWWs5enXF+fs77H3zAvXv3uHfvHkVRXH/pa85N7DnF7d83bC+IjNvo5/XVKjfZr0rtOz0J7NWZCciNJtM63UeZKNopEhYknrFMjm+MGLdIxJYFp8SYE95fLm6dU0y38Dolul1sQWALOQF7jNodS3V/XMWR4LV1gLvLEq73d2PBQsr9yYAIfoTRBC6EMShVeBERQiGEIUZFEAorNL2WWK0Q0zlrD2ddT36UI0yecu3BEYNFRJsmTBHxwZFYnB4pI0VuuH//PkVRYJ3DBk8cna7UBhlEcqiCBCuryMOHdzmcZHzzm+8yuFds1iuCXhM+y+zzA7L9MZpIUJ7V1ZLVckVXN/Rdh/OBX//N3wQbyKuC6ek98sWMJnjcJyzXHDB4j+97yLJUSqEUbd+z6XtePn9CURTMZjMWB0f4aSp5GfqOfujxXYcUCpODCiBDxBFQSpLnGbPZNJVdhcjV5SWr5YqhH6hOjsiVIMsytE3EFjVi9CJG8H6XJgkh7OaxfZZ5ggwFwQfg5jObviISvMNFj/SSzAjKokBpReg8eIHrI4N1ROcJnSfuShwEQpqRK5K+XkS5S5EnCFigpMBbDyIQpaOoDEoJjJTIAmQmyWYVS9PgbdwFBNHH8ZkbiZgx7Sf5pfE8P+P4+NRwqDGaPM/QWu0GldYaJa8jPuk9zobtcgKtJSpIZFQoLckzzbTMEcERR2hgXpVk2nB2taJ3gb63DIMgyyNFURJUWtU0dX3tmKInTZABoxLLbTKdYIwaYa0UkvuYoi7vHE2zoet6vJN782+kXZ3TXL3C51MyUyCVJiQPC1LsckBCRJxzWOtYrWo264TPTwpDb1v69RIlFCF6+n6NyUBpECInBBgGcHXEy0gboSojOYGJcCAVQinUWP8YEdi6w3cD/WrFpm5p+54+eqrphMXxEW3b0rUdz1+84tWrCy4vlnsPe4qQnA80TcvV1SXr9YrjkyMYoeurq6sdyamqygTD5oaXr17w6uwlTVPzxS9+kZ/+6Z/m7bffZjqdkud5Yp19GuJOOgwAmiYxBlO0Dc45rq6uKMuSLMt2Y0lrffODCIg396WjR8cETvkQU24mXNdtbkshUmTod04w3UOBFnpEG8RuN/sTxNblighImVycSGSZHdCyCwWv4779fLSI42LutZlzOxlBRO0RYyLgRMRriVYZfUhJfqUzbAxYAd4YnJQ4pXE6wyuNM4ZQFnij6YKgRmCFoiqneKFZrtZEO5AJz6zQ2LbH9gMuDBAc4ClyzXw24fEbjyATRBFTikFKlJYk7plAi4gqMrQUNF3HyfyAxw8e8Wf/q5FvvvNN/vbP/y3OVi1dW3973PkP0LYRoLWWvu958eIFwVoe3LvPRx8+4Xy5wgnJ3Tcecv/BA548e4qi5zBYbHzNtQuByDKkUkTv8UKyrhue/t2/z8mD+8wOF0wmc+rNhpcvvsXJyR1MZhBA3w64buC4qshNTi4E/XqD8ZDND7B9T1PXbDZrlFSEELm4uKCu69GBp/FdTSawsrh+uEZFYrzGF8ZytG05QhyjezmuzOKYTxZ6X8xgj+HvI0JoQOCayBAcRke0VAy9pd40iZyFIJOJLBZExO3NQeOaiQCooNMic3ApMlSAFmOkGJlMU67Udsmx+ugY6Ik2olWGFwMxSgjgffIxeku2FCTET6Z5X+sMoQKsv4d1guN9HxOScgf6JMan3JFhZIxjCQS7/IoZV+1KRDJjyLOcvnF454khUOYZk6qi6XpiZxlsYqVJqYjhmp3s3JDoMVKgZaoVHF0/wAg9mF2NYBxhSDvi8iGkaKHvr1c/EXBDj+1aRJD43iGEJIjEkpJaIcdcotSSvuvou4F6tWKzWlFvaoLNx+AgoHVGjIGubylRZEh8kEib4N315RWtEyyHyOGRYloJjiYBJTVSGqQoiEg8Ct+0xK7DrpesNg1N32MmJVEkiGEYepqm4Wq1pLOW8AnLnxgi1rpd5J5lBmstznmstbuaIecckCJ75xzOOZ48ebKbOLqu4+DgYPdTVRVVVe0i1N3+9ggmWxZnYsC26R4pRQiBtm354IMPmEwmlGWJ3N27jJOT4x2phShuTj4RXN8RnMXIjC3Kk+DzrW9KcGNCAdJCKY6hfYyR5NZCekTj9ReL1+h/KZeYxnncOcxrB3gDGt0/QNhL4ivgdYew/fumcxcjbuSFSkiEFASpsQKsFPg8xynFoBRWGYJSBJ1htcYiuap7gs4hK7AuYKOj6ztE9BgpyLTCS5FgUJF2L2Mgz3OKMqOsCvowMAQ3sgpTFJFA6YBJIQdayhHm0pis5PHjx8goWJ2f860PnnN29oqPrn4o/SAAfd9zdXWFsxZ8wA2W5WrFcr3i4PiYbDbFGsWFH8gCzGS6/68/XlHE9LpWKGUIQHR+zIcBQtD3A5eXVwghKcuS2WyK1gZTCjJSZC+F2aU5pBDE4PCuZ+gbpNRpDEZP8I5h6Lm8uIQR6XLWMfR9GtNjvjkKxpy4JCMio9ylebZLti0Q4V7Pr+8hUemZkBAE0UGw6Ri1TkQYEZOjZGTpB5XGcAyMHkkhlSAxER0iSlQEJQNZFtDGI0wkCI8THkJi9A994nwgPLKDoYv4Poz1gGnKD35LhgmJGyJSWUcMCcrVJqULPq19aicoJbuJJsaE6SYWaPpdyrRqUHELWQryPAM1sqSAMsuo8or6cs3QWRSR2aTi5PiQwTlY1jSdw/UOgcT3FikT7OmHLuUTjUKZ8dEMPmHXNtUaKpWKWidFlSaUIBi820F/UmZ4L2/Adq7r6Osa3zmGIRDc6DDyNCmLLEMZQ1ZULFdrmrrh4sUrLi4uWG82FJMqRQxCkBdVinR8Sx812aAQwQKWQM/X3m05WwaenEs+93nDySm89eCKQhsylQOPcTGn8wbjVyhbw+Y5ddsz+MDju4eUk4IsU9SbmqvlJc/OXtIFh8hz9vG97aox9ImGnec5zjm6rqNtEz17S8Tp+x7n3A3SydnZGWdnZ3zta1/jzTff5PDwkIcPH/KlL32J+/fv8/nPf56yLMnzfHctwx4E6b2nrmuaptldfyEEXddxeXnJL/3SL3FwcMBkkso0sjEX8kf/6M9SlZPrgfeaF2yWS0x2QHU8JQwBQkQpkyj/waEZEnlExL0vSBByCBE/RnDX6OU+LCl2H0k55S3fVCBlGGsRxm33aw73oHogOU0EUb42de7lFaO4fvRSLtyAMNiQHrSoJM5oXJalKLAscVpjlcJGiEIiVMZmsNSd5aMXl8wWJyymUzZ1R+8DTd1QSENuJC7TDI1I4ghKIWRioFaTgtmsIityurpj6Dt0kRE9OB8IHoR3lKMih1ISicJ7gXWCL7z5mEf3Tnn784/4O7/y93nnd9/hybd+k+hvEpp+WGy9XvP+++9DSJD52cuXnJ2fU1vLj/3RP8Zq6HmyWfFBu+JATXlkzA5K31piQDqCVkijyMsJmdaApCwnKGmwQ82mXvPq1QvW6yXzgzmfy9/i8GBBmeVUMdC1A2034IVAkXJnIQw4G2mbFVIqiILMSIiO9WrJ+fOXyBiolKRtWob1inPrUhCiUn2e1ooiz6jyHKM0Wl7XaG+jQO/TQrgb7I3rE/Hsaq1jKkjHpijPh0CmVSLimIzB92zL15RJpBcVBQGdnGAOkQHvOmRwZBEOish0FshLQY+gdYGNjdi6w3rFZgPe9YTgEL5LSmH+mhPhXNhFw9Y7jJFEkyDbECLRgykMUX2P6wS3l0fEQAxujDslCJNgPJlCau9EygmOy0CjNVpLQm6wXY8EbGdZr1qGrqUwUBYlJydH1P2A9bDa9EQpUEojQ0ALQZSS+bSiMoIqk+S5oRsClyuLHRwh9GA2OJ/gVFt4EJJIYhr54LE2KSlsj3V3Vt7jB4snsLxa0fcDRgqMMZgsw6sMh6KPkqYd0gqybeg7i/eQTw6RmSEqTZAKHwPeGdSkIs8z0iJH4IJAl4LMQtlrhE5qH5s20NGiQkc9TFh2mhdLwWnlmBrPnaJg0AorA2erjmVtefbiitPDQwgqwQtxuwjZO68YaZqGi8vnnJ2dc3V1RV03aK0oy5LFYrFzSNvc3jYi3FoIiUb+wQcf8Pz5c95//32+8Y1vsFgsePToEcfHx5ycnDCZTHZO7OjoaAebbmHGbV5xG3VOJhN+5md+hhcvXnB2dsYHH3yQHGVMOaxHjx7z4P4bHyPYxBhZn71A64rpwREaSRRgI2zDm4BhB0nu5PVS9KdkQOH2zs/vnGHcyceNq2mRcoARrll3wbMl4lzjCSMZZ8x/p4BxrJXdRYTb4xN7TnAvggaa3GCKHK8zgjEEpQl5hlMKLzUhLxBaI7Sh0galNNoUiPUGIRpmRYeJArfesOou6K2l6QaczhFI6tpirUcJgSwzZEzIzcnpEYeHc5ZXFwgZmeY5ZVlytbrixfPn6TkKEAfLfDpnUlQ8OD1hNpkxqyqkcBRZSZHd5U/+iT/CndMF/69//98c2eA/PLYde3Vdc352xht372Hbnm+98w0WR0eczGZYIVgOPc/rFc9XV6hMMy1LcqW4OWuMalWkvO18OiWfTDmeLVBZhpCwvOo4PjkiLzTz2YyyrDg6OibPCow2lEpjekvWWbyQSK1BgpCBGB1ts+Hy4orVakPddFxeLnnx/BVvPHiD48UhX3z8mJfv/S7LF0/ZvHiF9Q7rPauuJgTPmogRYyF9ZCdssi2tkFISvGe9Xt9YBmZFcvqJ6MhuLhcxEXe6pt2RDomCGBQuGIARY2GUWouU80CuBZUuuZdrDrLI41nHtPTkWaC2GbUzLAfFh2eRi/XAZhjYsrolBoVI+VYAIygqifdq5EZYjFEYY8iLNP8FH1Pa5TPIWXx6J5jwoZEUIHbP9w4KlZKoFMJJYvQQ46hFmATy4mARjN7ceqz1ZEqR5TmTaZpEjVZoJclFyjuJmJhEUgqqImdaKOa5IssNqrFcrVKOzoaI7JMMUIyR6JIeZEQSZWJM+Z2m6SefV/CRvu/o2hYnBC4zqZZPB4YgWTvoe0f0gdwFYpRIlZFXM2SWEbVmAIgBaTWqqFB5hnRjraSPTCZggUFoJhNPllkiJcFbgvd01tEMsOoFlZFoKfCqImKJwdNYEL1D+IHSTOiaAdsNgERpc4Pp2Pc9m82aFy9esNls6Ecm63Q6ZbE44PDwkKurK/q+p+/7PRLJXkQzsszquqaua1arFXVdU1UVFxcXnJyccHp6uovojo+PUUoxn8+pqmoHictRnkmpNGDLsuTBgwe0bctyueTy8pLNZkPXdrz33ntorbl752E6kZtLcGy3wbUbXN8idIEUCTJKDksQ2BfYjtduZ3RKMgFXjFjfDhoaS++vs5EJ0x+dZFKM2R7DtnJ6B4nGFPVt95tMJnhpf8h9B4hwMIahyPEmx+mMqBQhy/FSEaWCrEBpk1AJkycnqDOKweM9HMzmSJWhtKalT4uaGMBaQhDYbmAn6StGDUgU8/mE2azCDh15bjBSI5zHNh2bqyu0TuU6uTRUecHBZMpiOqMsCjKjIHqUlChVcPfeKfVmzY2B+AdorxNitmgH42LYxUhT19x7+JByseAseGo7sOo6Nn2P854qy9FSfoJgTMrjywimyMmrknw+JxDxMZHZZtMp02mCQY1OyFIiExqEVMlJmXxLHiCIiNaJ9e6dZbNec352jgvQdz0xRKaTKYeLI05OThmuXhGbGtYNw9DTO0tju1Tm4D2eSIgCFxIZRYjk+OSoqyx4rb5YMGp0CqSKeOdTxslHtqtFZ0cCXhSA2s2zjKiHiAGlIyYLTCeBSS5Z5IaHE81hHnhjPjDJHZkKbPpA4yUHTuIGi/Sel9rSOomNIzN7pAUIBcoITKV28m9975MiTabJyoRIpVIzgbDu9Tv2be1TO8HoHNE6GBlMclz96q14tEyRIMFhe0eMgeAdRmmMUniVsntKJiZnCBlFlTM9OGR2cIRz7xNDwEgosgStsqsH1EwmRxxPc45nBSF4pNzw0YsNddMnOryEYfA0pkOENdvZU2Uq3VQJIGnb4QbXSyqdavFkQGlABuqhx8gCoxVZWaTLZCVBOoLz+F5RFFMmmeH04RtEpbCAFXKcaCJmTNjqPEELAsGPz8BFsAhgSAuK/n4K//1AcSg5EIZTWVF6gwmQhY7oOwgDw+AQ0SNC4Ld/9ynN6opXTy9QGOaTxe6cY4x8+OGHnJ294uu//Xc5OztDKcnnP/8lfu7nUi3g8fEx77zzDn/9r/913nnnHTabTboeW6bZXk3R9jWlFF3X0XUdz58/3zm2xWLB6ekpX/7yl/He8+DBAx4/fpweeK1pmoYsy5hOp7sI0RjDbDbj0aNHbDYbnjx5wpMnT/jNv/t3WW9q3v7iT+C930lCpYOCjA7fX/Ly6bssHn6OrJzRtm7kiwn8yA694YDi7uMJdmL7dspvhxh2pJcE+Ue2DNA4QvuB9HDFPV7MrtAekiLGFgYdFZRSjeuNw2eXyY97kZIQ2IMF/cEMZzL6mKIMITRSG5Q2FOUUbQzaZCMlXmB9oJocMJke8vDe55LykDJ0g6Pre66uVrw8u2S1bugbS9sPiRgypBqsqlA8uH+HR/fvkOkUGbp+4MN3v8Xl1SUX52ccH58wPVjwuTfe4s3Hb3B0dMhkUuK8xdqOSGKFW+uI3iHG0f3DZiEE1us1VVXxkz/xEzx95xusL69QQlCUJVlZ8uLZU54vL3m1WdN1AypK7kzn5Ep/TF5MmpJyPmdalmSTCcJoonD0Q491A0WRM50umB/MCMHTtR0vX55xMF9gsoyrpmM+P+Dg8JCjoxMi0A89ITq8d3TtgHfQdw6hDEeHJ7zx6C2+8OYXqIqSzXqD73q0D9yZzYkhIV53FvMEeY9jOkTonE3EMX+tG6pN0lY2RXG9aBSCalaijYKYxCrs4Og2dowVxvIukfKAUiuU1qhckWUqpQJ9S2E8VR5460HOYpJzUk05yTWlHCjFChMDwltkPzAzmsWB4c5Mc7GGSmvefeZ5tXQ0RESmUMagjcLkiuksLfaD92w2Am1yjMlRWZYWtVuoN34fIkEz0vnzLD2UUiqGAFGkKt7E2AlI4qjbmaDGxNgQlGWO0Tl5XvHi+SuIgSzPaduO84tL1qsVwXtmkxLv0ipdKYWNkRAcWqXk8nw24+Ligrbpubxc0TiBUIoylKmOSuqdrFYkggsEkdI5MaYVx40V+VjjIKQkr3JQkNkcnRWYokJWE2SQ9EKkIk4dMUWVol+droEQSVkyxBSEb+vVPEk1YSuo7HxSmRiiB+xYY1MQo04Uf9sDDiU6rHf4ANH3OBw+gmNbOxepbaD3gqw6SPmJpt2twGOEi4tLZrMJWmt+6qd+kul0xuc//wU+97k3efToIWVZ8vDhQ77yla/w4sULuu4mk2obGd6UUWP8/ms2pfeevu+p65qLiwtWqxXz+TyVkQzDjoiQ5znWWn7nd36HpmmSWv/hIVVVcf/+fbIsYz6fs1ov6cYI0bmU69iaAOZVhlKB5eqM6ekdVJ5jRsJNDKMqzOil9oURxJgbFOPxh7GMYguHJsboyKUZkYzANpoQu3zh6/FeqmfcXRhSMe82dz4Kb2+v35Z3IEa0hOuXe6ExaFyQBJlW2EZnSKWRUieY1ke88CM6IsmzIjlGZch0YjYrpaliyp3M5gsWR6e07cCDqw3rumbT1GzaNcYo5rOCB/dOOVrMqZsVrbU4a1FScHJ8zOnpKXfu3WU2m3Hn+A7z6QxjFMPQ4b1NXWDGiYcYsLZnGLqPwdi/L/sMX7FDw0cTr783LlaGriN4h5CC88tLurphvjjExkDX1myGjrrvqNuWTEpKY5jmeapd2z8eIRA6o5zOOT45wRESOzJ6Xr56wcXlBb5vuXfvDm/ox3RdGs/f+L13efPNz7FYHKK1RozkOyFTmdJyeYW1w9ilJ4VARTEhIMbFj6EfLNFHQtvQ9QN+VHERY821ETEt1KLasZuV1h9DeqSUaJ2Ii9cXK9INAxkjEqcEykh0lvKAUggyWV7nF8X4oxxSezIN82nkZKY5nkkeH2sKLcjEQBgiDYFOaOYllLkidA0Ch7CBSkXINW/fn9B2NkXTQhMzBUXKayopkCYCHmRAZpGAZ3D2Wjh8FNn+LNWqn9oJZsZQFQXz2QQ96tat6w4bIy6myV2M9VE7wargR3WBQJEX5HlJVU1HluKANoa6aTk/u6Te1AgE07Kga9OEnOWadW9TvZRMRJvJZMKrF2e0bc9yucFJkxQwwligr1RinsZUCuB92NVrxSBwznJjREsBKqne5GWONArjAtoUqKwk5gXBCbRLEbBQApXlY82jwEYQPhV9hpB4h9sII7FGfaLqhwQt+BDo/QAxOWPhMthS9n2bYLcYcX4YVzWOIBL6EERa2YUYaX3EITHVHNoafyPXGak3NXlumEwmfPnLP86DBw/4whe+wHw+ZzabAnDnzh2+9KUv8eu//utcXV0xDMPuG26oze/Bo9cycddi6VvCzXK53EGmqXXThtVqxdnZGWVZEmMqyL+8vOTg4ICf+Zmf4cGDB8znc7TWzGYzfuvrX6Pve1arVXKCrzngWZURFLy4vMINDcZPMLrE2YjHpTKTHZ0l3kzLjVHblvnpw3ZSSP8kAkSK4raTJ3sB5cdQvr1FR3K6IAhokYrKk7SWJC0NR/h0C6++pnpjhWEQBk8inkipMEojZCpXENtjdiMjTiqyrCDPcrTJyLOSbasZObKjDyIc24C1ns2mZblaslqvOF+ekWeaw8WMu3dOmJY5q9U5fddih4GyyJnN5xwdH3Pv/j2qsqIq0v2LIdD13aiE4lKZwDgOkhPsv80Msh2Z38X2ovb9jfcd3eulJ1tYO713c/pL1zyOohIW5x0+BlabNd46Tk7v0sVA09bUdqDuO9quJVeKyhiqLEMJ8bEDlyYnr2Ysju+wbtZYbxmi4+LinA8/+oB2syESOD45YrVe8urVGd967z2mszkmLzg8XCQHqFJZymB7lldL2rYlhEiWlQgURTlhcB4pDVFIhsEShMc2Lc65cZyGEfpPdaBpUZfygAi5qyO8UUzOqJQkb+amB+tAkhRetEAKhc6SBrGWMrVHGgmRqUQpPXdSRoyG47ng4bHm4aHh7gxEiNh+oB7AhoiTmnyiKAtD1EnDNjpHJgTGKN66N+HlcqDxniA1PpfEUiKiQsaADAMxJiEAacC7gHOWfghJrUwr8lx/P5yg4O6dO7z15n0e3b87MiA9Hz55wabrqLue4PrE1JOkvhmRlOuKkkjCmdum5vzVOfVmydD3bHB8452WDzOFJDKdVMyrAh0sSipmiznh8opNN9Bs1tjDOUIo1nXLpm7prSdqhfABbx0iglESMp1W4dEnUsQI3QYvUHqvMSZQziaU80lSXZGCYC1N42i9InSB4Hra3nFxWXN+tQapePjFL2CEQktBsY0eBJjtt0pJECnPFAMQNRBwQeKso2tdiklEQKk2FZmGiLGRGASEgI8dAYeLjpAU+3bF8sEHQiaJMWOwlnq4YtM0NxzUV376p3j7i19gvigpivRz9+7dXTF6jJH5fM5P/uRP8rM/+7OUZcnf+3t/b8cOlXJL657t6qvW6/UNBujWSW7LHl68eMHTp093ecFnz57x/PlzXr16xXw+59GjR7z//vs8f/6c1WrFe++9x+npKR988AFFUTCfz7m6uiSEyEcffUTb3uxIIAQsigJhcjZtR3/xijA47j5+GxscNjii8GyVB7dFnpJtTkfg4lZDNOxm0xTdpagwlSAJYtR7MlTjPzt41ScYEJPyhohUjC4CVeY4LSQTI2itYDnAeU+ibI8knUhS1Ng/MTM7pFwsUl7bjzn1GMbVz8h6ywx5WVJVM5TJUCrVXnkX6YVDqYiKUOXF2GYssQ2JsJgXLOY5QpxgsreZTSfcvXNELqFpNvRdx5tvPObO3TsczedoY1JxdIzYYeDF848SNC1SXsiHQIieoqwAifeBul5T15tPNaN8uynqded37d24jqRfe30vTcsoVTxuHrFA39TYrqPQmievXvCN99/l4OEddF4gZgtebdacbda8rDdcbtZs1ivePl1wclBR5BlS3IS1EYJqdsBkfkg5P2DVt2lREAP9MNA0HXXTUbc9TTfw9PlLLs4v6PqBgESbnIPFMUWeE4Gm7bi8WvLhR095/uwl3gcePP4c84NDjk6OeHl2Rucc9dWa05P7TCZTquNj6lLRX2Z0Tzui84gQR8GICMjUqxIxzjVbcf9rpqv3Hr+XOxMIsqIkKwzGSKpJSfCBy3iZ8sVGURTpXjvn8Z1P857UyNhi8Lx5XPLmoef+QaBdrQlIjCpoWkvjJM5U3FWCySTAZIMkYpSkXztMmfPFtz9PszDMzyW/82pNF3ssHeurFhEhLwtCSKxRj4RQQMwpnUps175FSo2S349IMDPkeUZRJOVw7wOTqtiq1uDcgJPgRVJUjyE5m6RPmeAZN1japhslnAJSBLwbcCgWB3OmVcWkKhE+tdOYFDmZUqiYVhN919E0Lf1gEwxgEitTS4kSyQFrJdMktp32xFbdI6lepJXPdklJUm7RGus9USqCgM4FOufpXUAWGmsDHkFdNyAlRitwHtu3fOuDb+G9JUSPkjlFOeHOw8fI3LDr/wSIcC0Em+oYR+hMJWFwQqrpiQG0h6Qqn86j7x39MFA39c75KCkRWhNH2jP+ZmRRliXT6ZSDg2mC1oxB661+31gsq5KI9uc+9zn6vucb3/jGrnyiqqobnSXatqVtW4Yde2tPgWL875ZEc3Z2xm//9m9zeXnJ5eUlL1++ZL1e76LHoih2EeJmFAbOsoy2bVktVwghR9LO8HFoTSRoflEVXNmOoV4TbIfGorXDh25U+Fe767cLHUSCNre457Xg9nWIFxGjCMV2Gt2+ek2GiUKydZ/p3yR7lqnANINJFploQBiaIGAYc4V7+3g9rBRjgfr2eooYGWmqCJH6uZmxIbJSBikSZLqtD5NC7mjySd5QYr1DjvCYyRTGKDKjmExLppOKo4M50XUQc05Pjzk8PGA+m6bSIJHYs8MwPnf1ZjzkVHsaR7lD5wJt2/Hs+XOUVDT15nsCh968K6+99m2+fgzId/vf5nuHrqff1MSup29TidD05BSZ56yCZW17VkNP3bW0fYezA8fzOYfTKdd9JvfuFYI8L5BaY10YafspwtJKU+SJATqbHVAUFVpnmKxgOjvAmJwYBZcXKUWQ5xmLxSHWeZwPRKGQ2lBO5kxmB5STKVd1Q+h6vB+4Wq3wzqMWc7wQBK1x4+iUYuv9t4SuvSuzvXhxi1FxEyUZ/1ajaMV2rmCcp6IY5yujU0ujkJSDBJI8yyilZ5o5cgIZYKKg9h4fAzEM9NZjnUHoHLwkWoGMikwLikLje4+pDPM7R0xaReEi4XzDqNSNGNNKIUaU0SijCBGMmqHVlOATX0Gux3p2bpZ+fCf71LJp2mi00YnsISVKCuazMiVHjSY4i7USK8ErOdLrLV2fCB0Qid4TnEVER6YihU5CYkoITg4XzCYTZtOKTCZlg+mkpNSKmkjT9WzWGy4uL2n6RIYpqzKtrJRCC0GmJLneqnywmyi2Z+FsRL9Wu5X0T3UaZBgsik0/sGwG1q2lmMkEM2mTVGuEYJIbur5lfXnBL/0n/x/qzZp+6CgnB5zeu89/+s/8GUp1gNZFWtH7OPYzGVfqxhCEToNQjfmGGAk65bWCD6godw9z11zQrNdcvHqJkCKJ7h6fokwGI0NN+5t9EjOTkeU5eZ4TQti1VdnalvCilOInf/InKcuS3/iN3+DVq1dYazk4OODOnTs8fPgQrTVXV1e8ePFiV2S//Y5rHdf0XatR4/DrX//6zlk+e/aM2SwJAVdVxenpKdZazs/Pqet6VI0RvHz5ir5PmqZnZ2d0HR9j9PoY0Vpx52DO8sWKrrcMzZJpKSjywNCt8FEzxJIBTRjJAUFuIz+dsKIoUlT2Gny2Det3TTlHCGkHZ5JgaUjkFBEDEkepAqWJHJUwM5FcCZzK0C6CCNuvSV8pxPVEtN3ttqDZu5RTHCcriUAJRVlUZHlBXk6II70n5QbVOD7VbgLb1m6GzicgVkSKXDKd5EyqksPFnCLPKMsMO3iUrHj7i5+nLCuyPMfbAeccgx3oum5kGi93CEASnxhbT6mOp8+e8Td/4Rf48R//8the7PdvW9hznK/3sezx2sHH3ON2rmbPETLC987S1zX1ckVoe7q6wVlHPp9iteb5qzPO+5Zl37JsNjRNjRs6Ht055e7xUVJVeX2XAoqyREpN3XT0vcO5gM4kZV5xMFswnc25d+8+i8Uxs9k5MUiImqqcETy8960PKIqcqqoo8grnIghFWc0wWcGdew+ZHizIioKL9YYoG3wUfPjsGWWWIeUbCOuJQmIZRddlOjghSKSsG1D+vkscaWTi463SUumNwWSKEDzOu4SrRIcHpNaJleACQku00kyqCQstmJuezNdIK8FKnI8MPjD4jraT2OApyzlxkPgGpNVkRjKtcqzryQ8yDh7eodgEZNPTBYuzPcE3iGAJBAYfmE8mGJ1hjGRanVKVhxAU9WaD1pFmDBY+rX26foIk+LNpa548bZmUJZkxlGWBDSmZaoeUD7B2QEtBZhTz+ZTzqzXNsKarG3KjmE8q7h7OybRiUlapNUg/sLq8wHYNQ1uSZZq8KJhNKu4cHaKVwbpz2qbh2fPnrJsWGyNlVSEQGK2YVyXHB3MOjw54dXmG9S6xSFWKmrTOqP0wMvfGByrC1cWKi7Mrut5hRUFv4fxqzcvzS86vVty9/4BJWXFQzTAiUZmjkDRNx/nZOV/7td+g3awR0SOrGVefW/PT/6k/iSonaCMIHsIQiH1qDpkebLErIwvRjYn7sR5tZA9ed8YTfPStd3nnt77KV3/tb2OynIOjE/5z//h/nfnhEaLMGUKg7W5GTUkZJuXUZrM5xtxU91d7UerR0RFN0/Dw4UPatqVpGsqyxDnHq1evdoXvr3er2DKx9mHR5XIJpGJ7rfWOUaqUYrlcMpvNKIpi1ybGWsuLFy92kWZCDlpevnxJcCVdv59jEmSTknxSELqBaSaIw8DzJ+/w5uMjjg/mSN/Ru4zB5YRocMLgRALGYmpAllbKewmmG8/LLrq9Tp9sHaLYuyeRiIyWTAZK5TipoDQw045MaaKQ1IOjc3u5x+3TFOEGOzRCt1lTaIEZu1gkJSZDlhdkWUFZVgmilAqhU05eyrG92JiX9SGpI11eulS2ICQHswlFkXN6ckCZG/JMpxwXEW97hr7FOosU0HU1bbtJuUFrGfqevutGRmlHGKXprnO1khcvn/Lhh094/733ybRJ8OSnYOa9HuWNl+HGf3fOcPxzK14mX5+5x+/bbTu+7ZynvVoSmg5fd3zt7/599LTkjcdvYVGs+oGrvuey2XC53rC6usQPPZU2fO7BI+6f3Nl9775JITk8XDCdTgk+MpvOCcEBjnun96nKGYcnp8znU4pyxsOHb3J6OuBsQAiFGyzrZY2IkqqUKJ1TFJL54oSjO5PUSunwFJRkCIFqcYgsCnRe8Oz5C86sJRKZyUAeHcJFREhVddezW5K8SyBTuF7E3Zh/Xg8FIQabeGE+ER4VkSrLEhdCKIypkDIghKeTLgmhGJjkkpmWuN7RdoaVkQSRE4jYIIlSIFVGWRqCiHQ+pgBFG7KsQJkWIQ2DlSzrNZf1mqwKFHONMSW2lfgANkqKrEIKjRCCzrZ0vUWMPIzZYUFUjrYd+LT2mYrlfUjF6Goc6JM8SYalPFUif6gRiJRiLFoUKTKLMU28VVkwLUyqETQK20uCFQTvCGOjWSlzpBAElx7m3BiKLFFjh2HYdVHXWiWNRZlmrGvXkdhSxICWBm00eZYz9CFNInsP0WAd1vqkTCAT3t10Pet6w3K9ZHF0SGHMzYchJJi373tW6xVDW1NohW8auqbBDw58QIQ45ivHgvxRnUHIVFcTGQu2xzZKARBKIMbC2e2j3dYNl+evePbBu5i8GKnLfRrMWuJCSIo7+yYYu2zo3c8n9R3cqsbkeVqVbvU79/OAw5Aigq0+5+u2zRNaa8f+f5G2bXf7TS1lknPrum6MTCWTyQQpJavVimFI0UeIEescV1dLlIj03TXbUAg4ODpgMVvgNg1HNiLbgQvXY1SkLBWKEjpFU6cGyiFK/DYPt6sivL6Zicn78VXjDcE28dqvMU0oWgQy5alMoDJQqIgRASlStGh96gQiiDt9Xba51Nf2GX3S00UmByhgrKtMXbm1SczPLSkhMUzHaCdEgghJ+i0GghdoaSjyjNlsQlWVHMynGD3WntpEmbduoB/61EDX+p1kXt81O5H4oe/x3uG83d1/7/wI3UquLq5Yr1bEENlsNmwLnb+dvRbYXZ//XqT3+sf3o7uE9t3cYosCbr8/bZ+QJ9d2+GEgWEdbt0yrinIy48yFpLbjUulI13f0XUMhFAfTKcfzBbNq8klDA4BMG4xSY3RTjcsiy/FJYDI74OD4mKLIyYuMQ0QSD4iCrhvo2pbZbM5sPmM+n2OyHB8UOptQTBYUxQSdF/joicGlyCwErI+orEik8hDofBJHz4QmqFFFy193ttmC+rvru32OII2fG1tsN0xNEIJPreGEFGRGE0jjNowIhRjhdyHYkWKMEkQXsR56J4jSJHJNVORFah5cVQVSW1wMqRGvVqhMI3VGFJqu83RdTz90SAM6E2SFRqpAiAITM5TISDptaVEeQqpd3LbXUyb93FhBfQf71E5QKYU2Cg3YEQ4xRUk/9PR9R/QWIwJlqbHO4bxLE6h1CKkpJ1MOZhV3Tg9RvsPbgavLs7G1BpR5yaQqmM+mTKqK4D3Pnj7D+ggBjhbznR6lbnqUS3qkxEBwkdV6g8nSvvuxfklImJSJFFJVUyQZbtgNAwBCVCAyTG7wTuPCwNVmzUV9xUV7zj1/DxtLnAh4mYQC5GAJw4DzFlEZJrMFd+8cs1kOTKuS3AWKwVMMnr4d8G2PqztcP6SbNd58hNjBiyGmbsrSaExVIItUhhLG8m4XQqKmh0Bdb8YuCgKhSEWyfX9j8imLgslkwmw2I4xOO/jt1L6NhOMNmbOyLFFK4b3fTWjee5qm2U2Qn+QEY4z0fc8wDIn6LVKnkWEYdozTYRhYLpdYazHG7NRljo+Pubq62sFuSsPQ97z//geU+TF22G9cLPnZf/Qf4fTomPrsgjuXDRfrht/94APu3jnkzukJOr/Pi/OOi3eXuBCw0eNCmlmFVJ8QgezDoREIKR/HxyOA3bMwZh2nxjLN4LCESgxo4VGkSCEIRe+SxmOmEldsO5N7KfD65nU0MjkoCSipUEqTFyVlNaEoKpTJU02WzlKaZFRBgm0JSxi1GiWTasZ8NuP+nTtMZzPy3JDpgLMD1vY0dYNzqYSlrpcMtqftUzlLcn5j1Od9Qi9GEozzIykqMKYZEoTdtj2PH7/JMPSs1+tvc9W+u11P2K9HhTfvR9jdszEXtn+vYpLS897hhp5hs2HYNLh+4Pj0DubggKhLXq4veNXVnNUNV03Nqt7Qr1c8evCIn/jc53nzzj1OZgff1gkK75ExkToOjg7J8gylBW8ohZAKlWVJWWXs1JDS0IK+S8/J40ePqaqcapLjyAjLDoxnkDOELPAyQwqLiTE1L9QaaUreePsniMGTyUh7/oz1euCgmqNiZIgR267BOzQeJTyCrcZyuo4JHpfbkY57bZSndEzqnGG0RilBrjW9tbjgWW/W6YpHmeZiLdDCYJRAa0mMii4KhIXZfE6mDIacmUpiD9P5FLorgrUUU005MxTTDNXOGGLOi1fL5De6No1npfAyIsqCTBnycoZtA0Pj6YaW3FSURUFnW1xwWNcjM4kpzKced586J7jNBRZG421SYOyH9GAIAdMqI5eGw0rTdJZmcHx40eJcGPsIKoLzbJZLomvxPpE9CAGFQOnJrr2Qkiq1CNGGZmjohwEXwZiMPMs5Xcyp2gEZO1abjsF5Ogf+YsOyGdAqMK0KDhczpsWMPM9RwjCpJgzzeBNO8RB6zzBYVuuBVd2SNS2PipIHd+5RNR1u/Yz3v/EhT7/5HtF63rlqqJsN9XrJQ1OAhHLwyBDJ64ZnX/0q9UcfUVQVSo4CuS6xOhECaRR61CS03u0guCAAKbG1TsW3UtB7yIjcP7nDW5/7Al1vcWhC0+BXS/zQYLuG3g3sO7d3v/UthISnz2bosa4zhJj0VoPfEWS2Tm21Wu3KJKSUO+e1D3d+Uu/A7f52l3OUy9rv37aVrGqaZgeNZllG13VUVbUrq9j2UkxqED2SHmvDjf2cnz2DMNBuarL5IfePFtx763MsDkrm07R4WBx1lNMVZ1eOpnNs6o5hCFjnGPzW1Y3u72PppZRD2zrClFu+xgFSCUTESFiUklx5CjUgw1h/qjJsjIloFRwKSa4VeqzyhFTv6WS4GWGKVBohhE71fiajqKrUiVwnCT+ExI8d0bdNmLc5b5NpJlXJdDrh7p1jJlXFwWyStHZlQm6cT3m+dhQ8qJuaul5iXZID3ELozo21at4TRwg8xJGVPCpyQIoW2q6naTu6thtV/L/DRALfdWW+RXP2HaL3fmzBM6Ioo/AGYitxcN2xY0T7aJqaoe3QWcbF1RNevTzDTOZYrWm7juUwsO4tm7ZnvdrQrNZkIfBgcchPf+ELVCZLOsgfY48kU0rT9x1n5xcILZnNZxxUB5g8S7WbeU4MqS1RYhunvJqUSfZxUuREkcSlhz7S9oF1k8QcglaU0wO0HBDC4rVmcIJikFSzsSSguaLv6tRDEEHd9azalrI8QARL328otUGLmGqjQyqgV6OYQdJAeg3sHbkJ+4tjIRJi58XYxkiPnBClCRYyLahyRWRg8AHhBcIL8BLhJBqFlmpEKUb+XhRIFHlVkE9ysmlBZacQKzZOYJ3HuyEp1shAVAJpND4KurrGdxHXBfqhR0lDbjIWxwu6vuXy6nJk5n/63PRnFNBOidDoGaXI0gpDSkVVZFQGTqaGpUoDxzqbOkEIgUTinaOtB7xrU9I1bhO6SRptNzFvVcKVwnnPYAdciBil0CpjPinQUuEstG1PP0R6HxnqHtkOTEtFbjIKk1NmBUZnBARFVlBVNyefoe5pljXtpuXyYsN608JyxaLKmJQV64sNq1XN8+fnnL//EfSWjy7WBBGx0XNE6jouOof2AdM2nH3zG2yqCVleMJnMdtBRwg7EqIBgEFLiwlb8dhT0kqPwspL4CLV10LYc5AV3j++wWm9Yblrc1RW9VvS2ZWibMYE9juVIYuspyaszQ1lWKKVxbtvp2t2o8wNo23aX94MUOe47yW/nAF+3/aLc67GT9uW937FLpZRsNpudnqG1dtwuTbrWW7S0qTXX9ryAi6sLooBu6DmaHTI5mPLGgzfJjMAogSg05WQgK6bMztZs6o6rc0FdQ9cJVoPHhYj1cedI9m0Hp8ttr5RRGnCccCWRQkUKHZnnAi0COrqUb0SCVLiQes3FsZu7Fgo11nKNVymN+xv7FWw7SQiZlF+yPEdnZowAdVrEeD8uZEZ5KJEcYZEZptOK48MFJ0eHFHlOkZkEL8a0+PF+hDuH5AjXmw11U+PcANsu6M7jQor+Ygiph1sMbPtBJqKSHNGFwNBb+m6g7Xry3PC6x3gdgt+Xor7x+h4PSbK/feIjeGuJIqEoSmW7/NZegL03TlLnk6HvkEKwrmvOLy+4f3SKU5KrfkhQ6JAErNu6od+0lBFOZzPeunefQukdQen13JkQqfWXc57LywtmizlSS6bzCYbUS0+rxDTfLlRiDAw2KWCJsWygG2q6fqDtFG3n6PqINmC8RGclRimkkBRRopxEZQbjRJJ37BuiLgjZQNCGIUjazmKKDOEHBtdhMo2U4IJEBI/wfpeLFltS27fDOwQ70pvONDpagpBEnSK+zCi8DORKkGep48/gE0qAF0QvwAnMiITI4NFRMliP8KCjRJlU463KnNxNsbZg8EmPNUQ/jr9I9KkzhB9rVGMPfkiLgTASd8qqIAifes/yyQ27v5196s7ymTZopbCDgwhKJlaQyTKKskAMmkpHTqYKG65oeoskNc+VUdI1DeBopcOYtA633iW6q5ZYb7lcXnF+cUFhiiTrU2S44HExsFytWG82aG24d+8BJ0eHPHzwCPm77/PifMnmcpNgEKDtLYP1Y5fwdJOdcxSTKTOuc4IhBP5/f+3/ze9UMzZnZ3T1gB0cXnac3jni5GTBsw9fsVw3vLhc03c90nk++uY3UEYjtaYo8sTOEwok+HjFB9/8FkIkSOvg8AihUmuRLfFFqOT0ohA47xA6FTmHOCqZxMBgLYMduLw8o5pOyYuCee8xraWsG979D/4dpDG0RcFwuCCIfXgtcvbqPCk85DCdzjDG0PfDjryklEo9BLNsB3VulSCEEDs90ZSj3VNtEeJjjmPf4t5KcruPo6Mjsiwjz3OWyyVd17Fer7HWIoQYo06RdGbFiGiNDTK3epfb7/695w3lRtLWS6pnK44PDzmZVlAWkBmkyJkWhuO37vD25+7gfaRrPatVw6buePryguW65mq54vJqTT9Y2sHhPYQoENvGZKMAe1oxB5S3aBGoTGReSiaZQMcWERxEm1iESTkY1/cMvSX6QIgai6cPY/w5qgUNtr0RNilSbitGUFmOKSvyoiIvSrQxdGPfuH32pQ+BqpoymUx4/PAei/mMxcGMMs8SJJ2Gwq50JYzOra431JuaerOh6xq8t0TvRmktn/rTxTDWr25VdcbFgUhSeYO1qRaubmialrZrmUyrGwo/n8l2ib/9XGz63Q+WvmmI3mGynEmejQuK6yl8O0zciDCtupZmU7O5uODSdvRFRlNmXFjL09WaZ+sly6bm8uyK1dkVvl7zxmLBo/mCz5/eJZeJdf2JJgSTxSFN09I5z7vvfQv1oSJ/J2M6mzCZVJyc3sHaRNA4Pj5BSpEY5asrurZls25Zr5ds6jUHhw9xscD3GdXsgEwp2nZg5Wqca1HlFB80gze8eH7GcnnF04/eJ/gWpSKLLz5GTlvkfErXrQkOnJgxOzxGaMPm1TnS9Wg3IDuPCS61WSKQvZb71pkky1Pjg7wwZJmmrHKiSg12dZmjx04SwQqMFOhCM7SawSl8C5kNmM6SdT0yDihXIwgorZjMZhxMDLPScFFvMFPBkczJZgu0zXFrjcg0KtMoZ3HR44Yw4ihxx6GASF4opAo433G1PEuyc2FAqRytvw+tlLTW6cS9Z0vYkCJFhunhKDAqINSW3ZhW1UpKFIIhRrQSlLlBm+Tp++DIMkOR5+Rljh1S26O2b9HeIEyCPpQ2+BCxzjIMjuVqRVWl/n1lYZhNC8q2x4VELgnR4bxP+UrbEwj01iOzDLtfTxcjL5+/oM9WbJZLjE8yQscPTpkfHpAfzJlbiTzoifOGoe8R1jJd18mRiiSfJKVCo4ij7h8x7HrdDW07skDHxzQyvpfWuzb4dM1UksXaOhDrbaq9rK/o2hpnMrqo8EOP6BvaZkk0mm5+QHV6zLSavhatXU9adkuEsO4GXLkltGwJD1rrXV+/LYFlP7Lb1xXdzw3eXNGn1WNRFEyn01Gwe5Fg7tEpNk3DMAw3yi2M0RiT4XyPd2Hn+G6cUYSrwdAPGdZl+NahVM2Lly+Yz6ZUVUUZZ2TBo8RYAiIkRamQakI1KcgLTd20bNZzzq9WNG3P1bqhbgf6wdH1Dh+S3J3fnVcgk4FMRSa5JFcRJTyMzkIgEUojZGqnk2UaZSTTo4o+apqgeXm2pB9cSh8gdnKC23NUQmCURGSp52aW5ShjErvOuRSl7YSDhx1T83AxZzZN0GdV5hiVoMoYBSEK3v/gA87Oz3j/vW9xcnzI8dEhbV0z9C1uSLn5JC5/7QTD2GyZuBXITz9bEDlEh7U9bdMQRURpSVbk6CwD953rsz6+gBqZ0cTrbgFjCB6jSIxX6xh6iwgBIT3Bcw2Fbktaxo/ZEFh3HVYI2uB578VzGu+JVck6elbeceV61l3PpmmpVxvCYMml5q2Hj7izOEpR4GsqSfuMV4GgmkxROuNgseDDD9+jaWq8t8wPZsxmM5wd6PqezbrG9S0mM4TosXbA9i0fffAeq9WSTb1hGCRRljRDzuRghowFPgYGF+hthOgYbKDrHE+fXbC8uuTiokbISJ4pPBlReYI2XLYteE+ZVzy7uMIPlnq15qAqWJQFYRi7u0Q/Nn9+DbVRqbxZaZHyfTrp6UqV5nGhIlF4fExd4b0Q9EGgROoqNHjF4CJSOFTXpdKwzmG0RGnFshNYN8GHnINS0Q0K7zUeGLxj2bRYAtIolB7B8XF1mFrpjQQ/CTFqjDQJFRyjwtTkPd4oCflu9umL5bXGjAlSGBECkbr7SmkQqkDLpOkWxmJNIeJ4UJJORDItmU0ylHa44GhdT1EYqqpkMq1o6sQe7PoeHT3G50ilMXkSFB6cw1lHvLhg2luMzihyzcGsYtZ0dIOnd57gUpTZ9l2SeAqebnBgDP1wDc/ECC+ev2Cjc+qu5aScc5QveOOtL5AdTlDzEnVyj/ngmDdd0h7sB9TlJX50KDEIFBItFKHvCNaS5VlSoPGewaVaG+9tkjTykaFNnwsRbAwEGQgiouzoBGPERUuMDh1abFvTAQMGokd4x+Da1FFcS46KAn14dMMJqrFuT2s5wmDsJOS2DNDX83xblmhRFDRNs3OYr0uo7ef7tu/v9js6u9lsxt27dzk9PaWqqt12k8lk15FiS6jZQqJVVdK2KZeWGveJG9S/iOByyOlshQye0NcIOt7/6CNOjg5ZHMw5EgJnDcH2ZMYgjUaXFZNZzkwZTo+mqQaut5xfbVjXLS/OLnl1sWS9aTm7WNEOHj/467wIEa0jhRHMC4kSFokbjxNSU98MRiJTUWRkueT+wwf0QbMeJE3dEnzADgnyjPFmcx4jITcKXeSURUlWFCitExQ46nSGsWnoZrNOav4xovUj5vMp8/mUTEvUmLsJSGyQfO3rv83Xv/51fvlv/xL/yM/8FD/z0z/FdJLjnbt2gsEldnbwO6HlNNVLhDbpnmpFxBGjp+t7ur5lMxbQ68yg8wyTZ7syhtdt5/z2395BoIkYlhobi0QRHRfy3gWGwdG1PUZIpI44nxrQyoRV75oeR6BznsumwYlUrP07Tz5itjiinM25DI4LN3BlB9Zdy6Zu2CxX6MEzKXJ+4gtf5MHJaRLMHg82qT7FG2NcCMFkNqOoAienp/zmb/4az54+YbW8ZLE4YHE4J9PQNC2Xl1cE16cazHHBH9zAh++/y9XyiqZpAI3QJYPLuHv/BBkmxOhT+ZmDvhvoWlivA+9/8ILV8oq+aTB5RlllDCFD4PHKcLaukcD92SHfevcDlmeviN7z1uOHHCwO8K0mxJCU/F9zggJQMqJURGvQJv0ICVKl8YAIqV1cCCP/VNL6SCYkQhlaZwg2sXFjsITBE5qeskgdUNwq4KMhiIyjStF2GjdorPK01nK2WiY95kxhBglxXJCNAVWW69SV3oPMJEpoBJLVuobgk2LYa5D6d7NP31l+jPyEUBTjA5ryB0mPb+hq4tDyrLlKLDylmE0qZtWMSVlynmtkGMjUwOmdI3SmuePC2A8wkmVm11mga1NtmNQGZVIH8cOjjtVqxXq1SfJDfpUuttAEFCeLKcumQ7Q9G5vyJpGA1AIhI13XpsTqcB3ZRCLvby7RJqeRkrXvWdmW47pHGZNIClpjo6CFXfunt7/8pSQdZS0hxl2blKHr8N7hg7t+wsVY/hEs8/kMHyXrxnO+amgHy+At0Q9EZ9H9KN0VAzqDItc8Pj0cIblIO+ZsgrX4oaN1nueDJTs8onvtVmZZRlGUTCYGN2qpJuUYjTH6hjPLsmxHYNFac3h4yDvvvLMradjWB+6TZIwxuwJ5Y9K9K4piVwc4m82YTqe7DvT7gtt1XbNcLnn16tWu5mz7k4rXr5VaXreNBecERuQEAT5EfvvphsOVYzFZ8+aqYVoVzKYVVZmiE110yCy1HzJjmYFSitOTBccnCx49vkfb9/SD5Wq5Zr1pWa0bXpxd0XYdbd1QqkgmAir24HpCsChxnceTpiKgaIaAH1p0Fzi9axF+IOst7vxDXOsx2SFBGBA375fctkbKCyZVhclTD8ZtxL7NQW0XEqkkKaCkxI+SXYMLOAJSKJarNe+8+x4///M/z9d/++u8evaSttnw3rvf5M/+mf88RZGlqMTaHVlqG+1kWepUoZXB+3TfN+sNw5Dyhz4E1suGel1j8hyVFQilUSaH4ZMJCbvF1l4JxE5LVaYXg0+TsmTsEi4iQUiGEGmsZT6bEYyhj1DqJFZQb1pqb6m947KuefbqJb/zzW9wtVqy2qx5/8MPiE+eIrOMO198G6s0dYRlvaZtksNIzQEKHty7z3w6R7C30Buf4f2q8hgjzfIqRbB9l6LfscQrjNByphXV0QFHixnLq3NePv+I1WrF3Xt3ybOcvITTbAbMmEwF1rd0/RWF2TApOrS0FGWOyEv82jOsWs7PG1ZLS7MBQkFRzjF6Sr1WFEVJXmi+8PbPYvuOdrPh4uySV0+eomTgaFayOZyjkSihcHhEeE1oSoDJBHmR0AxwiaQSElsUmdRatguVSEwpAJMT3EiWMhPsIFKDcj8gvEMLsEgGB7UNLHyGFVP6YFg3hhdnA2IuabueV1cv2fgJNmYUhSYXEqShbnqCS6IERZb8TyRJc3oPenTSCo218WMR7neyz+QEt3I8qX+gwjs70qgtbdvjupZhXTOdTZBSMymLFKVNpuAHcB06thwfLSiqgqBzrq5WNHU7Ro0JC9Y69YhL3bM1PiR1mL7vaXSLdx4LdB0IpYlSo7NE0zVj+J6IDHG3Ytw+6K9T/J0x6MmE6WxOGDxt9Ly8uqIykjzPUEJivaceLM1mTRYiTZ6nuj+XGIHeaEKWMdghsehi2EVNqZtzGBW7VFpZL7Kk9tIPdJslrveEYNEmsa50nmEKRZEbqsPFjgNexMSS89YR7UAzWDbLNV4bonudjKJ2Udm24SuMzYJNKmLfJ75sneC2dq8oihQxDcONbcqyJMsyyrLcFcNvm+huIdAsy3Y5wC0Eukuyj3WD25rE/fysHTUpP7Hv42g+gosSgWIQhhg9l10gkIqRp1ox9APeOexQpPOtHHpkWeYmHxsmG1RmUFKOPckkPuRMSkPT9NRNz7TKadqOer1B+gG8xTUhRYluS3RJhKcoJD5KeuvobQA855ct0TuGrsMNQ5KaGiWoXq91S/JuEikUSkiUEHjYyeNBKp3IDFiTUAg3JEaw8wl1iDL1SxTAar3hm998l7OzV0mcXgjWqzXRJ2FzQYo2Us4vjJytVFslx7rbdP8t1iZmr7UNwVuEUiObdECpDK10ctpSobqU333dbogsiP3mwlxTOncfEzst0KgkTkBPpA2Bzvasli5FHj7SXq25HDquho5XqxUvzs/45kcfcrG8om5bruoGj0AaQ9a2xCzDCkk/9Ax22IlWxBhp+x7r/ZjOuV6MiY85wcDZs6dIKWnXK8o8Zzad0ncdZVGSZzl91yLLgizL6IeWul5zeXnOfD5Da8nB4QzG6FebDOs8QXiMdkh6gu+Rqky10DLlq/sh4HzSYk5anhOkKmmaNC/YzKNEaiodY48xFUUxwQ41AYlHEJUiBo+LKQ/9+pOmtUQriVYiFdmHtO+wVVki5c2lkESRnKDUMvkGFUHpRKARgqw0qKgx3qPzHI+i79M4d0HQBc1mgMt6YF4mKUrlA2IkY0khkFohlaQTA/hI9AGh44gCyFGIPuzkAeM4fj8tkQ8+ixMcQXfnkwKGjAHvB7yzODuwXK/p25phU5OVFWWpOT1acHp4yOF8xslBRbQt0W74/BceMT9cMD2+ywfvfcDzZy/48MOPkFpSZJrpZAKIEUqMOO9ZHMzwLtUwXV6uUlcGlRincZw8jIRJrhgyRWYkUkS0TBdFjiUeZk8+TAjB9M4D7jx4xOe//CU+/OpXWb18yW//3u/wyH+eh5MKL6DtO86Xlzz/4D1YbeDrhmgteD/KVqXIYiwSSwXv20lfpTY4MsKr2QFifoB84xG10dQi8O77Z9SrJd1mQ2YyZgdz7h4/JC9LolIs6x6jU0uTvKpSPlX71LS3H5gOsA4CPww3RrQcyTepYD7Jku1HXUkfUuygzi30OZ1OKYqCoijo+37nuLb5wdPTU05OTrh///6NQvwtqUaNbY22dYbDMOyixu3A3Eb8xphdzqXrOoahTzSUcJNFuG9RKAIaRyLN9FFRD57GOlb1kHK2heFgkjOrspTYn6TIymQZVTVNkG9ZoE16gE2WSFilMRzPDlLrIqHobSqdaeqaq4szmvWaV8+e0NQbural79oR+k9MXusDdTuwrD299azql6kcqN/Q+kjUmmgiDo8TN8UN0veMbL2xAF4IKPMCrTXDMJDnBdV0Sl039F3HZrMihEDXtTRdR2b0GBn2PH3xgl/4xV9ktV4zmVRMq4r18orz83POL86JwVMWGT4kkfm0MJK7HHLXdzR1y2ZTYweLHQbApXKo6QTvLHboUdWEvJywODqi6x1D726y7nc5tWuJusSSv3Z6aViM+afts8m2jk0yaEUtYNPWNMues+UlbtPi2p7m+TlPNiueNWteLq9oho7N0LFsNvgQUCpDao0GZl2L8A4vBHW9wQ0dhRL4IbDpW77+zW+mru2ff4tAguFCHGUW9s7JWcdv/uLfpChLbAzcPznhcD4jzzMOFnPKquDps6ccHMw5Pj5MHSqaNev1Ch8ceZHzpcdfTGztwePskMa9CFSFx7sVbX2JmpAWakoBEjtEIDGGF8cztMoQQnF21hJDC6GmyAKZkUzKCY8f/xjHB0d89NG7mHJBUBVRJVTJds2IYuzN8QJyY8hN0mNuRwheCMV+A12jFXmmEGosYQG2jcmlEonLkUnuPFqQa0kWIqrMcAGyc4fOBP0wcGklrrF055YvV5IswB1dMjhB7zxCp/KKJPLQQ4x4G4kyEk3AZAVIT5QepN3pi6YesYrt+uq72WcokZBJxWWMKBCCGAJ2GOi6loAgKyrmk5LJpEBrBS4w9Bs2yy4VrM8r5tWck6MjqtmM6XxGfPCAaVHS1TV9P2CHgSzLxklVM7h0YnHMqRWZYVrlKXLZlVVAvVmSlRWTsiDLjsiMJNOStl6nvKJSVGVJZvZXCYLpyV2OH7zB47e+wOXTJ7T1BjU4Do+PeOONx/hM0wwd5XxKt1rRK4MWBdElYsSWDRdiTBTkkGqr/I5QYlP4EgKu8RgnWDyCrm6pm4bmxQUiRipVcrVa4UJA5hnVdIF1nvd+75tImdo4Hd09xVlLUzd09YYB6IoSdfqATsqbq+1xIo1xS78Xo4JPgnratt1FqlvizFZUO8ZIVVW7vOB+tLat8dt2jt8Sa7YlFduffbZp27Y3IuNUZKt3XefdqHYTtnTG7Rgb/7xBYAsOEV2CiIUc67gkXUxqP0/rSDVYVr3n1HmqQuMF6L5DKsVms97Vm5aTkiwzSYP2coSMURRFRVlWlFWBUYrj+ZR5qbD2kLunixEm7lmvlvRdT9P2bDpL3Vq0DpSFTvmPKPCiwBtJUJ4gBD6mR24frgkx8s13v8Wmbnjw4CE6y5kqTVFVVFVFXhRIKcmynLwsWa1W9H1HCJ4801RlidiSr3zk7PySl6/OODs/52AUQe82DdFZghtYL1fkRpFni/RshZSb9aPIRRJKHxVjBosUqaPIwXxCWaYF0tB/yNP+FVH1IDVd14PQI1Huk+ePnfIP147PAz54rLecbxr6wbLpeqJSeAIvl1c8ffGcj54+ZdN1bLqWs+UFqveUUvOlu29w3jR8+OqMy67BRo8VkUGnLiABTZ4VyKxg0zRJ9cqOmpTB0jjL0KxYWcsv/sovJ3g0M5wcHVCVZSr4lttWzLuHi/7yHNGVOCkoD4+oipyHDx8SRSRET9cPzGIkL3Lu3rvDbD6jqqYcLA7R2nBxtcLbNKnnmUIbSZ5Jmrqm7SO9mDMVmkJnGFmm7vZCpvIZAXk1TRFaiDgrIRhEKHF1jZKWru0p80MmJ1MOxQQ5KdiEnKNCQAhEsUTImwSSGEmKYAqCCbsyCUZWJkSkA69iEgz3KZdrg0MHiYgRk4PRBeIgZ3Y4Y1rkLKqCgUDTW5abS4QRBBVoRcQPA9264UFdkGnDSTnjwqaUlouCtFaMKBQ605g8S/WVY3egLYLggyWE5BOMNBjzfegsn1CDa1wf2OkIJsgMtFJkeSr2TdJQgegHvHWYScmkzDg+nDGtJuRF6oV2MJuhIxxMp6yoca5JfW5lWhXLEMbO7IHcaKaTMq12Q4oYuhGucbannFRURQYqtdIwMqR+foBRWdJljPJGlGHKCVk1JStKpDYEORbhKonWBrTERENeFug8xxUFIpshfEwwZ+rCmlbug0V4T9z+N6QkMiJx/q0Y6yGNYahrurrF1i1FmajwF6vUOaFuamw2RQyO85fnRJJGH1Iy9APr1ZrV1SVOCjg+ZlLO8FnGvrd4fQW+b9sIbUt33yrBbKNCSF0otpHa9jPAzpHty7BtP7t1hPvbw1jsPJZa7HeW3zrCrRMcj46tVuc1Nf/6PRkdMlxHG9uGtS5KQhQsB8fg07FkBgLJKcWoUCHR/61NkY0PLuVDQ6Dr+hHiC0yqKdPpjKPjA8oyJ9MlVVlAlVNVBf1g6XvLdDmhbVs26xq93KB0y6bpyHLJ4AWrxuIBFyDq0Z+PSf59Jxhj5MXLV8QIWZYzHVsZVfM5xhjKPB9bG6WoO/jEQtZKkWWGLDMQkzpJIHJ1teRqLEW5e/cO02oCLpBlGVpr2q6l68pdHnArij0MA4MdqOtmJFP5BM+qxAOYTKZUVepbCNB3PVH1CG3wPqB1ak59k9Ebd4pIW6JR4Hpc9t4zWEtnBy6Xa+q249VyQ9QSR+TJqxc8e/mCpy+ec1VvqLuWi/WSMggW+YTHR/fZ9D3LtmVte7wcIVSZqBEiKtAGoQ1dlxRxuq4jjN3WnR/o3UDsO957+oRHH37AwwcPaLtjDhcLTJ6TeufdLEGKXZe6XCmF8A5jCg4WBzsyXhw7gEilmEymGJOhVE6eF3gfWW42aS6KeqxDFZg8iVREJ6Bek03nGDdBiwIlrslukdRR3frEe3BBIKJCkRFCPz6PjiKfovWMfKYJytP4kEglugclduTGfbMuYMeelWOnsPGUwxjJJ8QilTBttWRt6juIwGQCrbI0NouCvCqYzqd0eGLbo7MN0kjQMIiYFkC9pe2TaMrEFBgxIKLHxySCIH2C6pVUFFmBC32CagU7iHIrfCHlFgH7PpRIhLFbe2aycVUXaNuapqlpmg1NnxQmrs77pOhSZpR5itoOpzmLxYzZpGI+m1Dk6SJF5zFSURUl90/vUOYrjE4FtyEEbEgkkET5zTg+PGQySYSLfnBcrTb8zu/+HheXV1TecbyYcXRyjAsx9dLyPUeLBVIa2i5gu57VurtBdx6s5ezsnF/95V/lgw8+ZHl5QWga+q/+Pd57+QIzLVM9X/CJSSYkw+kxRqUJPCtylEx1M2Ksc4ouSVhto9Q0gEEXBlkUqMUh7/36Ky6Xl6jCsLh3wtG9ewxFZPCWIAPVvSMOspIq14RoiTiEMRhr0W1Lvjqmt46N90gd8dxsZrqt/XOOsUB9HCAjHFzXSWl9vzbQGLOL9u7cucMwDJydndE0zS4vuO0Yv3Vc+87RGHODBLMfQW5/30Z/BwcHHBwcsNlsdl3tryP0+Np/r60MLVmoR+mstAoMYtRNRLIJgtZaNqHFuprjWcGdu4ccHh4wnZSp/GGk3G/WCbK9PLukaRr6bmC9blDakGU5Dx/epSpzyknO8Z1jJpMJ88MF5bRkeqA4vXNKdI7gBjZ1Q9t2nF+s6N1A0/f81jfe58mLJR88qxFmhkCjg4JgsfaaHRpC4IMPPuDs7IyPnjzh1fkFDx484Gf+6B+hKtOir1mvGZyjt5am3qCl4P79B/z/2fuTX1vTPb8T+jzd26xmN2efLtrbxc2brdN2tUhlCwqoGkCpBpTEhAH8FQyQQPwFjBggSoBUTJEYAAWCQlSZAtvlcqWd9s2b9m0i4saN0+9mNW/ztAx+z1p77RORmZGFLYHkN7TjnLP32u9ab/f8um9zcXZG37WkeSAXsTj72c9+xq+//DXr1Yq+k2RmGEeU1iyXC/b7HYvO4c9X1SA3EoLQkw6Sh9Y6FosVz559QNu0GKUYhh0vX73h9as3fPnlb3jx8hX2LHFZFJ980uNjquTl+6s3zDNv7+643Wy4ubtj8p4heoZ5YpwmXr16KeLpw4jtl2yHiZ/+8nOiEuT09bCr/pAiTpEURF14tjgnuJZffPUVN/MATUPRiZATYxazXwnWLRhhxV2/u6VU4EoumZgTo59xixbbNfg58PnNW8wf/xH67+745MOP+Jv/xt/gyaPHXN/dHq+XQnG57GjbljElwn6LzpHV+fPjQtyYZ/RtyzQESoHWLbn65AO++s1vuL6+4asXX/PkyTOePXnO3c0WpTNuUzg7f4ptHLvNDcoK7uLsvGfl4GzlWJ91pAKuMyQvZzmlTKMVrWs4e/QMCIx+w5A00cPNtIA8Y9XMDy4vaFqF7W8oYaC8R4ZMWSznilJoI7QEY5CZJdC2DqXz/Tw55xogRQ1rfdHTtDJ3n3eeYRi5U4nl1RUr13H+2KOQCjS6TEITs+XGK4o2rF1LiYEw7/F2AcVhi8ZZK3KEZExrMSrja/Ezp0DTtaii0FnjY6GUbwdofdv2nYNgStI2aayGVJUl4iwE3FJIIUAu2EocN8rRtwvWq56Li57LR2f0TYNtrHBMUsSVLFltlIeubTqWfWL24iavUSidUQbWyyWPHl1x9egxZxeXhBC5udswjyPnqwW3d3dcXJ5ztpagRY6o5HhydUkpmq9f30j7cffQ78wZQ0mRd6/umOdZMh1j2E0T6d1bzL6pD3Qhz9Ia+vWLr9BK32cdhwrvgHbL+ThfARGidcbQ9R2maVBv3rHfbCg5yHwIUekgJdI0MoaBr37za27bnrLfAYmiEmUWp4YUIkkVgi6EnOqE7OHmrDuCYARVWI7BTimZywHHavAwzztUZ6vVirOzMy4uLo5B70CfaJr22LI+ZPSHYz28xykA6fTvh9/RWrOo7b7DJkmDkjmmaWhcAyROGxCPForFUtpApRrhymg8V9skgRmKc5Io1Ly7vkUrIVL3/QJtLIuFo23cUfxdkUQAOEdQGqUL47DD+5G7rWKz3YtgwfkFfS8L4NlqgbMyI1n1KxbtgkW7wMfA7D0hFLrmLaoYrrci1B7lQI+Gv4ctpsQ8z2y3O7744gs2mw3KWcZxIPiPjy7iRSnW6xXOWdq2IaXINA6VsiFzydevXrHbbrm8uDzqwA57aW0bY8m1Gp79VNugQotQiE3XYrk6WjRtNztu4y13d3dsNxuGYc/NzS03txt2w8jVhWbZdzx5fMWrN29I6V69P6XE3/mH/4Buvebl9Q03w8AUA0Ocq06ptGbJAmD74MNPmVDsM+xjYM6RXQYO82Rljvc97QJMy+12YkoiC5YR+mVW1VkdharKLSJlF0XUHhEaSDkfkexaKXANse+ZrGV7d0c2hp/+8hecv3jJy19/dbJuVNAdYs0WstB6SklCCTOa7XYnXYLdnsY52q7DmJbN3Zbb27uj6Ig1Bh+icOAaR4qFlGfe7W/xIeHnwHn3jFZZ1j0seoNPVRxfF7IqNLZgdZGg5cRqrF2tScHgfWGYpGr3ITCOEUfBKcvB2OB001ZEs7MWp3qUxtpqzEsmVVR0qW3Sw3nQlcLQLcSMWWlFLoGQZkY/wuQo2uF6AXgprQgmUJImYdiHglOJViW00bSdhUUnsmtFo/NhMpIwVi6wRqTZVJSuncpQQi1EvoOTyWH77kGwSkw5q0hpJgZf++p1nhMkQDRNi1YWrRxdI1qG5xdLLi7WwimsaLYM9DlKC8qLgknbtCy6Qox7KbW1RquE0bBeLHj86IoPn3/AxaMnhBhZr24J48D5quf1m5bFakG/6LFWo0io7Pjg8SUhypwkhZFp3LwXBDUqZ27fXRNDQhsLbcucItN2A3tVW8HglDws+/1w0mo8Jd9XI5NDhVVRZdYaGifapdY6tO0EzZcTUSV88sx+onhPGAa223d8WRRt09EhCzL14aZ+FpMSpSR8iTTE2kI8Oa5Kem8aSykeyEf7JKU4es4dgC+HivAQDJum4ezsjMvLS66vrwFYLpf0fX8MhqcIrNMgCBxnjN/Wkj289ptBkLoPQ9N0ONMc76/Dz696WC+V8CwP7hv1S7RYDrwuDVFmle9ubtBKWn6PtaXvOrq+RauOkhPBz1hd8I1G60xKskDOfiAOmdlHCtcYbVmt1qxX4nv57NljlosFq/WSy4sznDVcnJ2RorT4lHb0TY8uij/91Uu2JRBTEXrEN9o1+TiP+/LLL3n9+jVz9JgqwaW1xjqRUru8ekTTNlhrCMHjp4grYjTtY+bNq1fs9gOXF5dsdluG/Z5hGLAGWmdJtYU1z5OMMpI42Nsq57dan8usKSbevbtmc7fhiy+/YHO3YRhGhnGUxKrAM6NZ9B1Xjy54d30IgnKtY0r8p//53yc1ji/fXXMXI3NODHESelFKlJBYtB1nqxWr5x8LJUIbdtkzxIw3Ii+olcIWoU0knVHNgqId2/2OWUWKSmRdW636/n5RVt/PHXPGlIzlIM1VUMainUMbgWDnvsO3DW93e3zOrH71K2wqvHvxqgpe3F8vRZV9zEKNyCmitCRxm822osQVq+WK5TLSNj2buy3bzU5AJOjjOEBrjaIRjnOeeffmDd4HAbw9+wENPetenN2J8h5GgVOZ3Ihrj9Li8df0lvX6jDAb5imzuZuII/gpMA6B1iSWGO7t2u43bQ3KarLKGCUmBNYqksRAYvJCCdLm2E41FAwZoxVt5yhakykkBFE9eU8aHcq1mF7RWNGHTimSlKEUy+ALtiQWJqKtousbzKpHJ4WJoLLo14bsUcYdrZ1MNOiYhUSfSrWry/98gqBrZSaW4sww7Jnn6iwQAjEGri7WMmtLmXG3J04zq9aQg7RSrBZ7o0PGC4jVic+EkKsjRCKFmThN+BgJpdA2jrbp+ejpY87PlnSmoNNM8TN+uKNv4dFFT9c9IaRELonFssXqBqc7ut7RofnJZx/x5OkZj59c8L//v/4JPtQKQyu6xYLv/+hHpFxPYD70v4WzV4oAW8hSEaacjgDqw2KfcybHIHPAGI7ZSI7i/TWXQhj2aGXQemJ9fkHXNjTzxO3tHddv3+G3W1IKOByb2w2KnSgx1Ac6K+p+BZ2rtdiMuNmj9Xs3tDrM1Q4VoNAvDmjv05neKXLzwAdsmoblcsnz589lQa6GuG3b0jTuQavzNOAdkKAHtCnwADRz+l4iJtweEaUgM5S2abl69JjoW0oeHtyHvVUsWkcyLdqIg7pSAgA/KJocv1JA5YjLEwzX7KZbhrtbdNXibA8q+aYqPxd5iKAqpQDWQmMcOWVSjuzvXrO5EZumf/rzhrPzNU+ePuEP//APOTs/w1qNsZbONHz26YKPPviQP/j93+Xv/Bf/mC+/esUf/aOfM8YE+b59rZTi6uqSUhS7YcZPM3635xc//wWLxYIQQrXccdim4cXrF5KkrMQeSZfMfP2KEBKjT7z6zW9IRXN+dikUppQkEbOV/3WYz+WEswbthFOaUiHEzBdffMXNzS2vXr3m+vqGaZoEVJJSFWGn4pcUb16/RmvNPzpfgS4suvuZe4qR//hv/SewXDK5hrlpiFpEwFWWINJZB7bFdku++NUXkkDsB5L3lJRJWihZRYv+JQqUVagQUFZJNyAGUvYkEyha8ovOKGy95+faybAIIKnEiPIBAzJP9ZKUjzGxabYsbEPImaKkwvjTn/6Urz//vMLxZRNUZCGUwos3r5mB3g+cP7rCNR0hzjgrbilPnz2haVoKhYvLc9quQRvDarkkp8ByIVSKy4sLeQ58ZGU6+qSw48zti18SzYqSz9HZQWyYdhpdErYEbJ8xOmFt5urcsegVFytF8IW5TcRHmT4FtmEib3Zk47F2wiXROz69D/uVpV9ZrFNoFbFK4Zz0RENRBD/Xalu8L42z9K0ljRMlZcZpIhtLUoph3tOaSN8XBr+jZC9ty6pEw5iFyma0+KH6QEoze50oTtEZLTNvbdnu7yBHEWSp+AhrGpqiyaphGkZULhh1T4/7rtt3DoJt19K0HVOJFJRknSEcdQZbJw9XSNIWSDEz7LYM+5ZxaAmrJQAhRHyY5S7K9xm9DOIr98hqnLLkmHBaWomts2gyOcxMw5bJz/h5ICZPLhHbGEgQs2KYqhVMDGjd07ct5+sepQtziKeUH7S2WNdgjK6D+6qZWE9iOtFQPASgYxAs9yLMpbZ2T4Mg9QGVO0zUcxQapaw4UxvD2dk5fpoI80RrKllcCQ1FWGjqWODlQ7u1imtqrWhaQ9N2tQq93w7o0PtW5H2Qe/glA+4jp7E+DKnK4zknYIpQFUpO0aBw8BIsR4DF4fdPW6DhqDL0cFZ4INrfg2UsKUestfR9z5gleB8WVQUCVGkdu6gYvVgVSTaaUWS0PshpFUgRlQI5TccHZy6eooVWIxmppnXyp1T8B2eCml2re6sipTLGHC5GwfuJcTDstlt2uy3WGbpFR6v1sYJTRuMax6cfPUOhePv2hpfvNoybe/tTpeDi4kL+pQdKoQqiF6ZxZFONiouSNp5rG/q+Iz55zKLvcFozbG7xPjHOkXmciEWxvdsQggeFWP3U5ECpg9G0qWL1hWmcRAt0nHj58i23d3e8e/eO3bYmuyWiOIgjVLSkktZfLol5GlisOhp3P+tUSvHh02fo5ZKt0szOEZWSSjR4cow4pVk2DUvXEnc7kvdoP2FDxOVM1hVsozU6yznRCZgGio2UOJPiLE4YJpKNVDNON7giQhUqJ1ROWGoymyofDbAx16td0CmjfCSOEwpFTplhJ3KJMbxHaUFa01kXRj8zpETcblmdndPXascajVViTKtyZPYzKouPXtM0mFJI84QpGVOKqCBFUYRaWkuvFW3JjLfvmBi5SzP73QVTFLSIVTIKaeyA1TNtnGmGFpcbFEt0UmifaNOGhdpTzExbAi4HdKoydA+q24IyBW0VpjGCducAO3motAWVhqXkORE5z1xnh4ZiNMY4jAWtZbyVY0alSDaCorda/D5Llm6ZVoqZTFSFpBSdFilBZzVFRzIBlKy9qlSD88MTe1jU61//EjTB7xoEFYvVGcv1OakktG3IGPbjDEXQm01jKCkRpiCLR8m8e/eKdZ/pXWbRdhWCK8gepRTBpaOl0DRPjJMI8a5WZxQUZpgRkJLCUsh+YogTeXfDHCL7Yc8wbJljwLYttnVoFL/84itu77bc3NzxV39X8cGTKz775Bl9L4utVvetKOsaXCsQ9AN67bR9dzhB6SQIipTdNxGX9zfLwVxYEKRGy0V2zYGioEhR5llnZ+eE4EnJizyRFirD8TMUahC+/1wSeA66lQmtFNM0PEC9pixybSHcA18OQf4gj3W8a+pifAC1yGvvaQ6HOeHBH9DP/kixON3HgfB++IyHIBtDkBZrW6kt9XMegl3TtGgteqPDuMPVKjT68ABpiFJcXJzhlkvevht4cb1lmCXAGi1xzuqqdagLxBGbPUtGrpY9y65j1uBDZk5RyLha14Ag2ri9Vcf2jj4Amqw+3ueLRYvRLSjHbi+zuGnY8O7tS1KcePT4CtN1MvuOCGTbKH7yo095/OicRiv+zt//x+zefX08NqU0H3/8IUpp+sUd1hrmeZakIEVu724JMbAfBq5vbzHOsF6vCD/6EU8eX7HoWra3N8xzYJwi8zQy+sSv469Zna9wjeNsfYafBmI4WFk58WGbPNM08/bNDS9fveHtu1tevnon2q5RRPC1EeEI27QY42jb7pg0dX1L3zUoMl3nSKk9Xi7nHP/uv/VvYxYLfn19w65AqPfV3e0Nw26HnyYW/ZLzbsHN3R2zn+jmvSTAudAZqQKLURUGn1ExUqwl2Qb8hJ9nRu/xKoIz2LZhYRcYBftxlGexFFoQV4wQ0V6c9GyWGZUAxjTNHMjbPRZFmj2vv36BzoVF2z14VkQOAaLW7ENg5yfmO8UHHzxn0TguF33t2CTKPOGnwm6/F7yAUvRtS5on/JCqyw6k/Z4YIirDZevoGoPThduXX3M9GV7sO27KDwjqEu0WNDrQqMileodVtyz0De1gME1L6B9J1Z0zbn/DKo10buTcwIKASzO6JNSpMIUCpaPwKhtHmquIRQyEOkPlmBRKEmUoqOiFJ5gL05wkidSWxeIMZya03RMmRSCTdKDF4IDeNSSVCRlWXYfVij0eTyFqaLWmsQrnFMkEIjMQobjqgiG89RAL2hipAGO+J7V/x+07+wleXD7i6vFTlFG1vSUKFIooveOSaBrL+fMnLLoOjWLYbWj6ju2Y+c/+6E/ws3iPnZ+fHedKrpGe/+1mxzhINrr2UgNNo8cZTessfdfSNhbXGMZpEpTcPLPZjfgYYPQMc2A3TvzxT3/OZjtyt5tZLy8Jc+KskWpWVb7LYTugJQ8tPXgY4I6BpypJPJy8ffM8CXdFZp+qSPXXNI62bWiag9ivPnL4QFeocToimgRFfxKMazA8QsxrECxkqNlxzA9JylJxmpPgl2qgj6ScxAaL+19RWlUZMKmDcgmCWHMabUSUfJ6CeKKZgjEKY03lLqnj58u1nXygzeQsw/RcIqh7lKiQvAe8n7BWkKWrVY8PY4WMG5SKVbj5cK00f/Wv/VVMt2T6B3/Ci9evGfcDdGeUqKtrCKAyRcti58g8to6nz59x+fgKs1yznz23u4Evf/OSafL4DNo4tDEsLDidaFTGGoU1itZZFLJ4LbpA30Q62xyDbUmeF1/9irt3PbvbRzx6dMV6vWaxXGKd0BqG7Z40Dzxa93z45ILdzcWDFvTb169Zr1Y8uVjz9OpC5rONpetEocfHJFVl27JaLlmtVjx9/ITFosdZw/rxM9R+ZL7biZB8ybjGslovaduW3d2eg9i0s5oYZl6/esmLV+/YbPe8enPLbjeK8lM1d+5bS981uMaxXPcslsJZXK1Wkjw6R9vJ/lfrNbYxDBXpCwL6+Bv/6r/C1fPnbObAXKSFWFLBzxMhzAQfeHd9y2++fsF/8fprStfw2e98xpMPPmC5PiOqamGsCjf7O2IIMAf8fiT5wDRObGJiGzObEgm5+iZeb/D7kTEGjDOYKgD9Wz/4AX/9936fddOK80fhiGo+jAsKmdvrt4z7HXfvbvjBv/5f4e7dNX/3//EfSfIKRERP2bYNTz/4gIsU6JY9S21gP7A6PK8p4d+9EwpVDAIc1JoSC1YpGi0zcJ1ncoiE2sUyVpPaBusamtBiJk3cKYLyRDOhzIgPGZ0LTZpYmIHO7ehzRBtH2U4ic0ZmnUZpD7pCpwsWWQPIEmxON60NRhk0mqIMaCXmRBoMio5Y8RailqWt+CM6rcRizzi0bTC2hTCSKcQCORsKTsBLRlOcrvKNiRIV3bJDG80+FkyWeWfOYqmW8GQCRaVK8HeU4sgJ4bOOs7RsodrQWZljfMftL+Ui0bQty+WK/W7LPE90/QJVgijqF5GyWfSdcP+MwWpBRoYMr97csh8G9rs9ISv6PuKGWU5yKWz305F/NSV5WP0caIyhbSxd29D3jq4VuPccA+PsGYYZHyNJwXY/crcbuLnZstl7dkPk+mbHqm24u+s4V2cP+vqyPWwTHrbTgHhEQCIB6kCtOV3E7mdR9fs1U7nX17QigVQrQYltwoUsGJlH5cNsLb8XAB9WgdKS1fV1IlqgzUNBZskta9A9AHaOntzvOW4pjqjRyjo4/o7WShYQowmhHmNdKBS6ziLv23paHZBkp22J2kZO90Gt5EKInhBlnilox/ah5NHhM51cqa5r0Y1FpZESR0qcyUXa4KkogWsDWUOO0CpRHFHNkm55zvnVBc1+JOaC95I0TVGRTUFpzd5CoxNOJ6xWOK1pmyg0F6WYkmIZFH1TaK3BGKHPxLvANA5Smde5V1GatmvogBhmyIll1/D48oybR/dBEAr7YRBUX9uyWixp2pamap8aY5mqxu4yF1bLFYu+o20bVG2RYh1F+wo5r1k7hbZt6Bc9foqkIK3DnDPjODHut7x6JVZh7272gl7NEjyttTTOsFgu6NqG9cWC1XJJ13es1mtc0+Bcg2sWwl90TgzH3wNLPXvymI8++JC5VNASQK6aj1mcTX71+Zfsrm9YNQ2N6/jtH/2AT7/3A84vL0kYYp29vdq8JXmPGj2b6xsRqN7tWBY4K4pV8AzTxHa3ZcOGECMEj1IWoyzLpuXjx4/567/7O1z0S6wSUJx1Dmssxtgjcf/65orN3R2vuhf8zm/9hOvXrx8AwVLORKAYw+rsjEymax0NwDzTAblUQGGS7kiTMwaNUQUTI9ZoDObYMSJltPeCbi4FpWXObVKHjhqCqqS5iNKRXDQJjQ8GrzQxa2k55kCJe5HQUwmrAqaqRxlNfUYySSGAl9NV4+DKkQUtXOqzLjy8TGsPS10BJTNa4ww6W0oShR+FaL+WquASS0HktIwsnkaD1WhnoBiyNdjWoapZsk4GTW05p0QpsZL1qYAyS8GQUjmaP0skEzGXfESvfrftOwXBAmx3W+Z55urRFeN+T4qRDz/8GFUCKgdeff3VUXmkbRsWXSeuEzEz+sDGw83W8+7NhtXVB0QN1y9f8+rNW+52W8leilRJ1rVyQElmja2zfP36HetVz2rVk4rYy0zDJEjTIpzC7V4qycadseoTSkXevdmifOSyg4+xZO0eVHIy6P/22u5UW/M456rtvG86KsiZOvxb12Ch4Nhuc41IqB06kaXe+6VALhmjD3qeinzguaiHAfoIKqnB5nDOjgKj9Ze0kiZyTgltBE0m7Q5NKRrsfZBX9VgOajGlFFJMFRhiWC6XlFIqKEYoI9M0EU/apKUG/aMcW6l+gs4Sk9wXKaejgLWy+ug2b52lX3Ssz5Zc34jckWAgMkof2huy8Pzdv/f30Ap++cd/nzIretWyV5qsDKloHF5mNUqhG6nWbN9gmg7XtPzu959zc3tLX0b+2G/J4whuRYiRgGYbDnl+QuciFkda01Y/zdZ6Gh2xesTpQuc0y85wtnD0rWOIic2cWd1uefRo4PxszeXlOTEnjNGcrRf8we/9hLNVd5zBlgLb/cQ0B169fsfTp084Oz/j+YfPWK5WrNZn9Mu1VCvaVLJ8YpoGQvCV5zez349s7vbMfq56n1u6ruPRo0csmhW315a7m8zN9S373Y7rN+/Y7GdCAkyDazrpuqwamqaj7RZcnF/SdS3rVUfbNLh6rQ6eizFSja8LpnHE9LC0yEHASZ2ytFodsGhgxckuNJnf5MT+3Ru+/9Fznj97yr/1b/6brM/OadseMEQgkPn65hVpmnH7mfxpYj9P/NEXvyS2C2LT8fL6HS9fvmJ7/Y6FFT3TjNCVWmv5ve9/j3/5J7/Fv/EHf0CnzdHD8QgiO/kK3/8eIUbmYWLV9/yTn/2M+5QFtuNIdJaiFVePr6QqjJ643ZHHgRWIj2g1xpW1QN0/a0o9CKr1UWfd91Vbdpb2XvaUonBF02BpTME2mdUlRNWQS0cYP+RdXDCmJb7bsdSeMwZcDJiccKVaJyGqQjJdK6A0Qen3PoMhhUz0XjpXuhCJ5BIwFK4uRQ1Ma83dNiIhUleenkVHzTDPTLs9Rm8xJhCJoA1WO7TL6L5FLzuMdhirxBB7vRREaTyICCBtUT/j40AsollrbEdKjpQM0ziLWLkBTSJnCLEQsyQf33X7zpXgOAzstnfkKGrezlhWyxU5elKciKkwz54Y3tE2LXEVaZoWpTXGKh49ekzbLVitz3j2/AOBd2d4t9mTdyM5qdrfDaipZvOZY0vK+4nFXUvfN4QsCMY4B1Yraak2reX87Iz16pzHV5YQq5Nz9vSNwufCZpwI2T+o+JT6JmDj6GZQysPv5XwMduKocR8EcxVylSRJ0K5GKdrG0bTSOrJHikLdvyDTyVkQjsJ7EwRlTHXfRfhPmnvSufy+VGLiRF5Am5NuaCGlQ+vSYG1BG401TjQqM8QoJN5je1cdWqjyb5mVGaw1rJbnKMT9fb28YNGvadyiLsoKXyQbyyWLfqWxOGsqqAW0aoXnqBLWtPdUDC3zta5d0jQLrGlYLpYoZQWBqkeqMqEcVSn86ZevaNqOHZ0sQjTHhEGhKdSuRClQM9LtFPni1Q3T7GlNYHN3y9cvXzGOUkVqpYVoW1Ql3tuaTdbZT1bEADpmhgqs0hXw0BhFN2gWe0PnDOf7yOUuc7Yc2E+e7X5gGEdWiwWNdSzaltY0nK8XD6pc49qjMPXN7Y79ODP7ifXZHcvVisUhCFotoB/upaxq/5xxnJmnWbLjIio+i0Uv4s77G7QxGOt4dbthHAYmXzC2wTiNa3vavqNpO84fXdB0LU3XslgucNaJfJc96FhaRExfzrFSVViZBl0eLilK1y6DPhkjlPtuilbw6OKcn/z4M9qF4/zinMX6HGUbUt03CnTRGC10nzQlbje3bMeRkDND1U59/fY1b9++5vrtG1pfxNVhGvjgow/54NlT/vW/8lf40Ucf0QK2dnZAVff4Onuv979VSpw9KvDoQagohWmeCVvFOI60XYfqWmwK2DpW0UclFlXRioc/pcLSB6Wp46tO1x/kuZYzhNUirN00gZJHSrJYIs4mioIhdMxpxZwyZlKcOY9ZNizVDpVmSpoFPlIOtA7ISkvn5L1NUWSerhSusaAyKWQaY7Cm2lepQlZZBNuVxbqeEqWjF3Mil0g+qFzVma5ShaIzMXnGSdTEFmfC4Y5Ks/VenjdtCDkTUsY6sWeyukOVVIXXReAk+kjKHEW2lUoUVdCqgn3KPwfZtHkaGfZ7oheNQasNje2JRuMpFAw+zEzDyNl6CyguLxqEbGk5v7hguVxycXHB1dUVKBgmT9/f4JpRIneOlaOVKvdLqgGtJCPYNSONs/hUW4Ypoa1hbW2Vj+pxrsOZpVRXObPb3lJKIKrEbp6Zw8O2p7Qr9UnAkxZcroNecwLnP53PcXLTHgJXdR+jFJkJmloZNXV+YsxhX6LsId07JQGwmqAeFjQhshZKvp8TnlalSotWn3QbyzdkgnIR4IwxFmN1nU12UmUKOEtU4Klq8eXwWaqcEgWjHc429P0KhSHGzGKxZtEvaVxb6QmKUiZSghgzpdOAeWBKKq0QaidVxBRkIbAY3dA2C5wVMeCu71DKYp1FaySoHY8Jvnh1Q7c6Q6sFyVoyIu4ty7EkIlBk4K/kwdzHxIvrO3b7PV0e2O82vH37lmkOFGxdwOs1RZGVVNa5noecC2LoXijUWaySma9V4JSidYIIXI2ZzRg57wVVuR8mhnHigyePWS16uup2Yu3D9rW2jVTpIbPZD6h9YZ52bDY7+sWSxWKJseLr5xpdAVQVVacNzljmKQj5vbbVUVU0oalC2Vo4oZvdnnmcSFnRtm2t7hZ0ixVtv+TRk+c0naPpHK6p1lPFSSavxNXgkKAd2mdKKTRiP3a6iSEvcr5Q72EWZIRyfr7mhz/8Po+eXtH2Ha5fSFafQWk5/ynLYhzmRNqP3Ly7427a401hl0buvOftuzdcX79ju7kD5VC5UILnydkZn33yCb//4x/z0dMnOHJ1jT8JAoXaluFYqRkts2qV35O5A3yMlHHkNiWuLh/hSqEvWRCm5RDlq4AGx2ITdfhS94jLQzAuJ0FfYQ/fQeuEtZGmNTDOlNKgSsSpiDYwKcNUWqa0hOSJynJhW9xhnJFljgfqmBwadEV0vleNVhS7sZa2tZSSCKHQGEvjDkmy/Ke0QRtH43pCrpZcJZFJoMQsXBlJ0kXiLBNzxHuEEnehoWhigX0UTEPWhpg9PmbaolHaYRWoEkhk6QKGSAhyjsSv1hxbapkswf6fPU9QZMjCPDJsA85UMW2lQBlcs+TT733GPA0Muw1zCLy9vmMcZ87O1iwXPWe9hc4AHU4FQPHBk0uWiwW/NXqGyTNNnmGc2Q8TISam4Jn9QM6Rs0VfOSCKmBTWGRZ9y/lZR9ca+l7jjDyoOUgbddl1TI8Mcwps/I4xBW4r0Z16i67Pzrm4vKTkdDSb3Ww2hJAfzA9zvrdHOviNvU8AP2gqKgUqJ7RCADFtS9u290Eyy4U7tEPzybzvsC9rK+0iSz+85IxS1WdR6+PvpGpIGisUvn4a+kXLctmzXHTENIEqtJ1Uc6EEUPNxMQphJiZx8HbWoo1h9sJziqlhsTB03RJjDMvlAucswe9lLpISN7c3hIom9GEr0nrG4OcZ70VBRGDxQYImYm01TzMpB9pek4vn9m6iFNDKiClxDKQUHyCRtskx5w5VumM+Uio9Qu7UhwtbRjGjCXPmbp7ZDluZiRTL3DpSfQgTQsQ+jHfVyT7qKT3+9d7EVRGAWAqzB+UTt+PA27uBRsMvX7yjbxuWfcejswV923C+khnazds3R3ASwDAIcCWGINw9pRiHGYoh+sTmZiMBsHX0y46mERPilJLYfanAOEhLlFJorOV8vebzzz/nq998zeZuz2ohSjchRrIuLC5anj25lOfzrKdpznDNmsX6Ga61uE4xhB0AXdPRNwussWLoe5hNx8MgWQn/Uovs4fG5UVpa0/e35jEnOmwXF+esz87IWl47oQgl4UPk3Y24r292O158+Wv83Y705pZsFLmxhOdn3G03vLp9x6tXL/DDxMXZiuHtLTplnqzP+Gu//dv8K3/tr7EwGlfyYXx0iEYnn+T0g52W6TIXP/5EKVbnZ8y5kDYb3r5+TWhbusWCpmQMhWIOM3bFoUN0EhJl/VCnt1j9SanmtRgObBxjA91Cc75QLDeKIRf2mwGrR1RRxDFBzJgoIDSfYRsXJG1o9ZJlMnRlpCsTNke5VkrLfPLkmBXQtI7zizXnFyuc08zzwDzc0Rvh1VqdSSqTVKJddLR2wXpdVaVCIG3uaIxGZ4NuRHKttR0pS1JpjHRD+rahKPAlM+Yk94eCOWaGKTDNEWcjxooSjo8SYBMQQqEUw3q1xBYksJfIPIv+r6lE/++6fXeyvDE4Y0iqEp8RxX1TCZPm/IK56zBGMw07UpRyNVZB1hiDtGlyQiGmiM6Y44O5mDMxCXF+nAMhJnz0jNOeVIPgoTJS+iDqa6BMkuWUWANKlpkXBaMNRmdsKThnJEs4QRui4NHVFc8/eI7Thf1+xzgIYjElyUAfgl8Oz859EHwQCEt9waH1UFtBQrzWFWxyv5qq+r/6Kw/amVBqRSbvd3ixAExE4f0IyKlgmtNgIehKGUanJPPMYT/XwJqJMR9BNuMkPChflXukHRuxJuDngK8B1hVEVFkbfEjC64xBuGaIwWyKhUBEpXyUaztoqJYixPmUxX1EhLvleh7ORc4GhSaGQmWBPJjhSru5+r2Vw3dOfl5OT8L9j3O9Z7ehhkkloIKiJEe+J7io967Fw30eF6x6re+xS0KdyfVzeQWxRBqf2UyRzTiL0WonnNTd7fUDBZIUJUGI3kOSIOjM/XkL3hOTFlSfUuRUsLZBhyTrbIFxmEUeLabjDHuzuRNrGd2Kqk5OGOfQVglop2/olw3rs762O8HqWdpPydLaDq0Nbdcdg7NIssidGU7OwRHUdJqHnLSVFUXAYOp+2c8UYs6EFHl9fcd+9tyME9vdwDBNvHlX5Q6HgdsXr9BzYOmhP1+jlWLYjWy3O3abDTlGrFbYtiUYgyrQGoPJhTTP/PzzX5E+/R7PLi6xbYtS5jgKOL1lDtHpfcOA0007R6Ogjz2tc7j6fvf3SXm4j8M9ViQUFoq8z8k9enq/CRdOwFjyF+Hw2YWhyRbbdFLpxkxOQlWzZBY20RJJ48zeGrzROLfApkSOM9T9Hm/j9yrBfBg1xQSIT6FWB4svRUkHr8f6vUOnzChU0WgrHRGHFveWih5NWc51Mpq2PYw7am+lJLKSZyrEWMc0wifNIUEMZA6C2bKeSov1/jgy0imSc5xrwfHdtu/ME2ybhq5tKUUy+pyzKIU7R9v3uPUa72fatuHm2uCnCUoiZBh9ZJ5mgp/x08iTqys6pTDOsOgb0JaSLcaI0nqqwSzkyDDuSSmy7Hti9S5su0ZI0Trw6uUXjMNI9KlmnAqlLM5IsM5JiOutFWRS4+zxwikUH33yMT/87DPOF4Z/+qc/4+W0Y9htUNphbPPgLKSUjrf0gbf3oEVZo1mhcgSN5gQiKYoz5QSVWVuvqpR60Q60haqEUe7v1sNCI0Cee3ujQpbkIj4UjFUYKJYUFWEWAdxhv8U5g3WGeY5Hd4fdbsR7zzxP9Tgk6z1Kv9W/uyaitSMlhfeRefZV/UdjdINWTnr8QexkpDoWjVKjJDv2fsT7yDj6WuEWQKpw65w4VCvNXAopaUp5D/VaSm115MOpOf3jfjtpux3WmVxgkjz9/tyqwzJ1aHPXBbqc7LO8v0ohC9ODxeT+Rz6Lg8GQMnrOaDwVxlQ1FiHsN+Rjy6aQY0BRSH4mVp1Xs1whc1pR4Mkx4n2sM8qCNfI8HpSJxnFitxvF+09BCJ5hv0Npy/c++QGQmWZP1/WgRFmpWzT0y5bzi4XMRomEcEMODTl1rM6fiVZsb+s9KYNsrQWko8j1nsziL/y+IDOKxEGIgDoXO5xWaXZPYWaz2/IP//RPeXl9wxcv3/Li1WtuNhve3dwRfCD6ANsd503PZ48/4GnlYr5+d8O723fc3t1gagW8bCyhdRSlaI0hDAPvXr3ib/1H/3fGf/lf5rd++ANWztYRxsN7R518Hb/x3qYUGCf367k1nNuWhVKYTG3JnSRJJzs5JK2l1GVBH5719wJmgUSSoEJdUXQhu4xdWVrdsegvCGMkToF8twEy1mYunKdRI3lzy669QjU9y/NznI/EONAcPgPU/snDA4xBKqrdTqq4nAJGa1m7EqQABV3RTUDJpBJktGLANroiUTVjhMZZVssFqTqcZHMYETm0BUKWIHhIHn1AIT6sKSZymUl5wjVC01BGTH9LqSC+eu+FnIk5E3MNqt9gAfzZ23fmCZ6t15yt1/gYBQSRizhB5IyfJ1QRR+O+XxDXEd/2VaBWk7Ui6URUhUAgKUdWDqMt4zwRU6Zxa1olWpemUglWVnG2lPneou8JYcb7iZgnvN+z290Qpj3Rj5QiXnjWWKzJFJ3wpJpsFXSK6BjRKd6vWAr6ZYcx8ObVC15+/RUvXrxku9nQ9kt6404QfA8abd8A0RxPVC0PBDwhF1NXP7JTEvxpKDwVtj4Cb2rrJMExMN0LVt8HXa0MqiiMPg0WhbvbO4xuCNGLnVT9PV3RauLcIFXaPCdiguB1nSclnHXS369QVm1Et3DaD1grLU5BJYpuJ/WYjK7Vs1LSDUhZdBmLJA7DWIhREZMjJU1OQrC3NtO0tWJPmdvxmtkPjMP48F5Upc5Q7ykrp+fr9CqV4085yX7v3T4OWfExEVG1klPHNexBq+rBVk7f50HXVDoTx09wIKXkur8iQSyflriKZd+igVnBPHtSKmx2A+PscdbSNOLVZ60hBxjCxOZ2e5zDpDgTQyLERCrQLToeP37MFCKu7fj9P/h9vvz8c7744gvOLp5graHvuuqx2VDKgqaR2WbXdcRo8N6y7JcVtKPY7XdM80wMVf5OZ3LygsB1Dm2kIni4HULK/R2fH/wMdruBr776DX/6j3/Kq3c3vN7uudvuGeZZkruc0RRW/YKn55d8+oPvY1YdM5nrN29oDHx69YRPP/iQcbPl1Zdf0T1+ikqZlW3YXt/wi3Hk9uaWsVogHZLKbwa5b4l671/6AsM4kqaRd/sti4sruqbFmEaqs4PiVH2W30eBPrhxjsXmITEXJKnIBUvCkUshlownUrqCaQ2LRyvG20TSnlFZVPa4kmkbxUoXVkRu8pYQPcovUCnUeV59Tg6J93uzM6UMIRTidsBZEZ5omhaykda3l0AZJk+7cGAihZlQIrFkTHvQWs60TSOoWe1obKSQCSRSmhjzBLoKcuuMn4baTantn1yI80QunkJANVr4lLZBaUtOCj9NlCS+rklbUioUbUCZ99rcf/72l+IJmjozO2TJB8V+UiEXCVwi3NzKYlTtN1KBoi2m6ei1olusaBp3bA+IEoGu4rOGo1u7vV/cxR1dSt00C6HUz5P0oWON/EWhyGgjs7KUJcMQ5wURuD0s6vc3Ysb7ibdv37DZCGouxIA7qfAe3CRQi4aHyNH7n95ndQJgOYVdcP/6croslBOUqjwZp5QIaSE9dGA4vJ+uRHXzHjBGGwhh4uWrV5SSarWij2AWcQqXzxeTuAjEdEhw8tFW6aAso7U5gigOKvA5izzeEViDKMkfAnSM1UfQVAvqUpjmqRoOi1B1TiKhZazBzTOusSJXNYQjUf/983/aBjlUZIWHSUo9i7W1chIITwYxR75nDaiqiCo/Jy+Tl56EuYP7+/EdOP6snPwGFYl3//v3n7EA6b3qUiuRoDLGYowgbVPMlBBqa6qQjdBnVG1lz9NEKpK0pOiPdB9tRcLQGM3l8oJ+uRLBc2NIOdP3S5xr6Nqetu1oGotWbX1/cK6tyF9L19kqjSYSfqoIoKkUAViVJJ6axlRps/fuQ3WyvL+/LB0Kb60UVhnOlytSzBjXsV4smWLEF2ol6DF3e85WK7q+ZUyROXkM8PjsgqvLMz64eszLKfCr2zsenZ1jlSGNIyUmSso8e/aMi4sLWce0OgaFb25/8QIaYxT+YgiyBmkDtXMkc+9vSZze2/ux8VCD4ekZOhKeThLMUjJaZzAZ44popxpFqtKCKsvxaA2dLixiIFCwUWMIteY8JIsHwbH3P2cVpk9JKjKrUFac7eURFi5eSgWqXGLKMzEnUn2OdD0H1sjY6r6tK3KbUqmV6kKUpANyQKsfXyv2fYd18QCoOiS/xzW3SBIeq8HvQWJPvXcf/nnbdzfV1bIwz34+AjWmaapyYA5Ki7FixRO8HJAPIzEJokebhrP1mqvLMx5dXFJK4c2rVzgHaOEoWVfNQ425RyHVymkcp6p2ktkPI8Mwst97hjHh51QNUsFlKDX4uKZaPoXIMOwJWcxT7xc0BD2aE3/0X/wR0zgwz/5b5328d+IP2ym3TtdKMJd7krwsChXO/n5bjXsVmNP3OKVmnFaip24PKcXj+xujsc1Jm1cpnn1wwTzP/MM//tvMfpY54mGWUw6tmdPhPQ+P7VuOtV4UDsv6g4f58JKTvx+q2vvW7bfsn9M6QZo0h/P549/6jMt19+Djmapsc0A/HuLaMbOn3H/k0/PKfcg6efGDNmY5/r8cD+TIAz1m9hIIqI0q6vsfZAjkFQl90t5+/6pn1DfMr3xMWKNBi+wVppC0VOIxJTbbrQRu9Mks9NBGLzWjr61spQg+sN/t+O3f+X0ePX7K1y9fMs+zUCDOH+FcT+N6Ls6WNK3FWUEpx1jwXtO0jrNVy2IlxzkOmUXraIxFNytmn5gmEbfQRtN1C4pCLG1OjsvUM3W6PbxfFJfrC1Y/WvB7P/kdUs7sppkhRuaUmHJmv9+z3Wz54//kb+PHkZAmXrx5yZQjn3z6If/qH/4Vfu+zz/j1z3/Jiz/+GX/0t/5f/Hv/nX+Ps9WKv//3/h4fPXnK9z/5Hv/Of/u/xZOnT1isVmjjOI4j3vt8f1EILKUIOMjIQj+OI03KJNdgkbadrhXd+9vBQLfu6B58d5I8HjAAKt3fj6okLAnHTGGAeENOlpRB5tuGUjJDNPTa0DjNYzVDmdBxolEZQyIpfbzpxYHzhIKEjFsOo56UxOKq0FDqiKSoXFuRTQ0+ntEH8XAtCpUtykg3zzorKNSQ0LU404fAWzLDsIPKc04xQhHA4MI1YBX70VeXD4tSkZwKIU5oK2OWvutIQUwcBERW18Omwbl7S6+/aPvOQdD7QAjhaLsCSmDXRVBMSmvRjpsE4WesZblcMs2BuaICXdPQ9QuMdZRccE1PwqBiwrkOYx0osE7OWMm5AlQEUOP9zOxHQsgo1bBcXnF7s2fyM9M40bSJthGLl1IkcIfqPD/sJ0LJ7Pb+fuErhS9+9SuWqzP2u61kdynXwKMeVEIPKrB8HyAPc0FxTj/cTAWNIWlpCR6fhfJ+dXkfbE/nBYf9nn6dBstTsM5BnDqdzASVUvzO7/yE5XJJ2zohtkeBSMsi/t7C/G0p+p8R4e4r4X/W2yHY3J+jTz75GO89/+F/+H88CnYbRCMUfdL+rHOYKhhTuZcHRN57VZqqCN1D4Dy2oOUAizptZdVP9iCYHi5QBTkp3ksU5HeF26k4bTadVh33dWL9NVuhdEQosqApo6unpgjNUwSqf0xgAJRk6OSDEpGAacZx5DdffUW3+Mesz7/mbrsFYLla4JqGxhnaRmEdmNo5KVm6NmnKTNEzVSSxNRqdFUYXioGUKtBIi+i5uIDI9w6yYodNZ9D5PtKcVtiilFLQ2mCbVk6lLrilZVUyqYgP4LxaMZ5fMH3vK+5u79iMe377J5/Rrhb88Ld+xKdPn/P04oJpfcZPvv8D/u3/6r/JT37wQ2IQSa31csWHH3zIhx9+xGK1OFYJh3v52x+A9+7w9x3Yg8fZjvV6xdI4WmPFHUPJPXrMU4By8txLNVU7AodkTItyzSH5VRW9WQ5diSzIz4WKhLwneYVOX2HnFU1wNMzEChwJbklwmuAmWn+LLR5TRMeFk8r3XpHqvdlZvQ+kG3TgJOsjECWUQFIWbCfvmRPMXgRAisGpBmMc1jhCtSQrARwaVGaMA6HImEf4fXJu5f5T6GJojMZqy2Si4Cq0Fhm3FIjzgGkM2hnOL85xWihOP//8S4KfKdWIPdV18bts31kx5t31HV3ruLndViqW2M5YZ2laR6jf896fZMSaYZqZ/IxSiVKgbUaCl5N8u53EMyslZq8xxmOMpeur6kgqYrAbIykm5nlkmkZimmuUU2z2ic0miFJME2kaz9JnmtbRzhE/eUIQn7aYM7sxHFF5hcJvvvyCxXLN5vZG8uoCIagKEqiVWF3oDoCRQz/4sFimLK4K+jD+UBCtIVrLtrkXoD7OoU7Sz3th7Fx5Oxw/2+E9SpZS/0DWLyVXZGU+gmQkq7p/UJvGcX5+xg9/+APGcTy6Qsh1OanM/kts3xYf/7zXfrf3OSQVmYM48+PHj9ntdg8y5zQPJCvz5/uCrxzbsTJqqwPzk3e+b0nm+/MquzzCkeTrHqxS3/LBEcjCqeRL3beWDsJ0RR04ZeXBnsr9bwOQ5oezzpr0C6JaRiL1DWvior551u85ZVCqiV6pyZufZ969u8Z8/gX98h2+2jGtz87EWaIkVImMtuCDzILV8RwILN3azGKyNFbTGUNKIhwwJ4dPEJJCZ7lW3ntSKey29/dhKYXXr1/hnL2/37mXP1BwNLlVKFHHgAook9fGem5KihgylMA07nh0seR8veTx+gyTM8PtHeNuR6MN3/voY1pjmfcDw34nBscxMk6iM3y7uaVC6PhmnXp/x5xub9++uf9JKTJbtAbbiB5myJntNGKV6F6e3viHe08fr+VhP/V91D3S8VApCg+43hNBM2tDMJasIkmPpF0mlHNy6ijTILqdWTF5y47ARiWW00iTBgyKojRF6WqDJcGvlMww3Vt6UQrTEMhJVS1j4aGmEMURRRdimslagenwKaB1wOpR5oXF0OmevEikXjNkj0qFxoNvJAhuwihaokrcVZSRJG+eEyXL/YAT4fBxChRjKNZii6DRh3FCO03bas5bcK1Da8u8T/gpUKIn+8C48+9dwT97U++3/B78UN2nP4u+E53Ik9fXOHR47bfu4xQNKUAOfYR0529573s6wOk+4FB+PJjPUB3vy30WdXif0/2UutodFizv77Mf17Qc1GB4sOdvyhr9udth+PTesRwoGd9lT3/hRSv3f/nGa0vB+/sber1eH2Hyf941/v/l7TAD3e12999zzXGm+m3bP48jfa8Y/g7v9+d9inrzl3JvswUPZmnvB94H+/0LDvA+AQVqMnFAXB1toQ6I2JM/v9GqPzw+h2fp296nvP9iqVoOfqEA5+fn35gT/rkf/v1n/+QvKcY6f34o9aeQ9SfVeXZO6XjvzN7TOIepiej9I/2XeLYRZPhmszn+21bktzoJavfTz3/224GWcOx+HBv8qgLT5HUSREttOx5kHh9W4O93OeZ4r65i3Qn14L3jetD1+Jak7PjaA8iv/vjhW2cefOdbdvNnJ+m1eq3n/dCxU4pq6XcsvUVP+GSdL+9zQU4/83cNgv9i+xfbv9j+xfYvtn+x/f/j9ucFwe8OjPmWquib6Eh4kALImz/48/+bTdVs6FuP5lBevvc2D3l59987bMdM+c/avu1j/5n9wPLeC95/0aF39Rfs+L9MKllODXRlQPytGf4/x+1wff5Lb+UhtPyQ+Z4el6iN3Vf896887gKoM6uKljtUPw8/53234C/ziU8BU/d/fuNVf4k9ymas/TM+xz+PuuL97c+7yf/s155eq1NO6ylFyxxJzd9sA55c5j/3sTi9zt/9OL5ZlZVve9lfuJ/6nfc6V8fRyJ/z+39RP+DwmtOu1bed9SM96y/qTH1b5fbtH+3Bvk+frwdL+Xs7+Ms0xr770ER941/lwY/UybP9Z8WS9/99KqbxF2/fOQj+lT/8l1gsV8QkkFZnDR89f8qjp0+5evqUs4tLIc47J9wvH3j7+g3X19fc3t7y7u1bgXEnjw+TGOuemLg6I8hSZx0cCJA+4FxFWKrIarHgbLHkw6dP0Tkz7fZi+uos60cXhHEkTTMWzRwj29nzi69fcLcbuL4bcF1LKoV/+A//qAJZNP/d/97/gMdPnn7zfqlXPKUo86WSpdVQNRu/eUHE1qNwOkdE3KTrQnxwWBB02cHXLx0Rn87ae5i5rjOL6nh+elN9SwOC3XbDf/Dv/y/wfsZay//of/w/5dmzZzJPrW2ilMSO50jSru3lWN0/fDXElTGFOprKusrb1IojxeKe2yif21pzdKHXh4VPHagdVd/SGoy1onuJBOiSC372+GHHuL3lzVc/Z9pv2e+3KNexGWb+1/+7/zMhRhqn+Pf/hz/koycNOYPpO7S1ZGOwRaMLzH7g868n/rM/3vP//GPLXTjj4vt/wOWHH7O8eISxikVnWPeW7z1/xHrRcrluWbXQmoJVQexYcmGcBjGMdo5xCIyj5+Wrt7x48Yo3r9/y+S++Yrfds9nsCaGIbU4pUAKUXDE4Coqqeor3i2NKkev9C6DQdh3/s//l/4onz59TkqAL76/3w0TzWzvBf0bLUu7P49/u75cKbJOOWjx8ImbviSHRNH0lwwsVogBKF/ENzZH95h3TsGUaduyHWzabN3z165+Sp1tub7b8H/5PvyDnQtc4/if//X+Hj59d8ejRGauLK1IxvHyzZb/dMA17KF7QzcYRotyHwde5vVK41tH1Hf2iZT9tiCmSSsAXT8z5KExQikI1E6o6y7dlRas7LrsLsi0kXdiPe/zeM99NqFlQitoW2qbFaCOuND4SQ6wgocyc5dl5c7fjP/i//V1yKRjr+MP/2r+LbTpiSoRYZeSycJBLKcSUSDESYkSRUTlD9Gglep59vyTERAiZy6tn9H3Par3GtFl4l1pT5okyT4Tr14K4bJeYtkUZC01Lt9KYBsZpoG0Ny97Sdz1913NxdkHTynHlE57wHLxIJMbI5CMvvnrB//Z//r8RIIzR/M3f+b4IiwCt1TTGsO47lt2Sppoqi5s81QtR6FhHXZACAg1SQplQ8iVToVzt1ERNy7megqFkTesatLVo1zP5mVQK7foR2jRo06ByYhr33Lz+muuXv2He78glHZPSmHggN/J2mPi//OzL75SOfjeyvFK03YJ+sSRmcUrvGsdHH33MB598wgeffMKjJ09pm5auceSY8D7w9vVrXr54yevXbzDGME8DYdozeUuh0PT9MSvUBSEFOydAkJRJMbFYtDTOYl3hbLHgfLHkw6vHmAJpHMXXrG04f3rFvN3h9wM2wzDP3OxFbeZ6scfoO0zb4tO9sSsoHl1d8fTZs28EmkMQFAPhUrVDD0FQf2sQjPFALNfHudVc53Raqer/pkQcOHh54GO49xy0Dm10nV2YGkTuZ5On6hLvDX/EMFjfH9ezZ8/56OOPjvZWBwSrgGnuaQgHhGlK6Yg0PRzDIQi2TgKXQgKaaJva4+duKq2laUQo/JT8L3MbW10sbDXireyxLPqs037PsLlh+w7MeM7Ua8alg6an3U7H49cKPvuo4QcfduSiMMsF2jmKttii0Bmu7yL7faQ1mq5fkhePePbJD3jyyfc4v3rMcmFY94bLleWT5xesFi0Xq5alUzS6YFWs5yqz22/EbDkX3r7ZkMuekjUlaXLSKCxaN9iqTqQrqk4VcaJXh2FMVmSVOFAvygGWevJ8ff9Hn/Hhx5+QU77nlh4q60OQey/OnVYR9+AhjgmYPFqnkgH1LqogGrm/AoVEigO77Y5pmlguL2ibBV235CBRRw6keU+c91yzJ3SZsFQMQXO2Bl2eE6eGtrEPQB4//OgJP/z4GU+eXLA8vyJmzbK9ZXvXMu4XlDRVv0p7vEe991XmDrQz9IuOftkxhkZoUgTGOOJzwhdNynUuZi3Kyu+s9CN6s+Bx/wivIp7IbmiI+0BahmMQLCbRNS1aG4btIO4EIVNyIZWCr7QsfZgnFjnX3eoc2/aEmNCV70aOR8SniRJoiAGdE6pkTO5Fscla2rYjCs+by6fP6RcLVusVthE6gVWaMu7Jo5xzVRTaOpRrKNaRrKPvW9zC4pbiQr/qLKt+waJf8PjRY/rVEusqH7tSH8YKEvIhMIwz03RPJVBKsWxa+ka6Ep3VtM5wseg5Wy3p2x5rW3FuUIrGCFJbGzGXluCoUBhQWsx4VUHrfAyCMVRzbV0wpqUURc6avjkEwY79pIkps7xcYm2LNQ2KzDQoVnFJO/QMOlYwoQT3EGXaeLBMj3+JDth3Q4cWmELAeMmS+9bhmpanT5/zySef8r0ffcbTDz+iaRqsMUK4jpFPv/cJX37xa37966/YDzvubt5x6wcO5NqLi4uaeSWmcSSlgieSY0RRsFpzvl6yXi+4PGvpnWPhGhZEemNYXa5YX5zTLnr6J48YblqmOwfTzGabYEz8+MkFd6sekyEow86HoxQYFFKYif5+oX1w6gonRreFfCBhKl1bI/ftMOHVyEJnslSvCo4IxULBp3jsUPp0CIJRKqukquecPCQHq6bDzXkcuquH4KTDFvx8kvYXtrsNd3erY+A7HMP7AfH4uevPD1UeiuoYf9BJPSy2p0bBTsQRjs7clRxbA/fByNNae/xezvmIhCSJgME43HF3/ZI3v/klm7u3ki06J8gw/XDxP7iKYK3whSqZXtdr8PLNyK++3POPfraj2OdcXD3lRz/5Ic+fP+HRozM+fdxzudRcrQ3NSkvCQpZrVhSqOBSRkuWBvdtsefn6mj/+h7/gxW/e8E9++nM2mw37YeA4i8+1PCtw4DmqwgNA1mmX93C/PLjVknwdRTwUYlJ77LqVWsEdb837c3JoKR56SScjgFMR+MJpH6EKS5RCSZ5h+5pXL37D3d0NT558j8vLZyz7pQTtmIjjlpuvfs7tm9/w5Z/85zSNousbynKBBp48+pA4L0i+5SD6oBSs1x3rdUvfWyieFAspjuQUKCXVToU4JRwc3p1zYgxcMqOfSCoSise2oKzA50sqFBJaK2IRIXc/D6gItliWiwS2EHRgO+wZppFx9DQ4+rZDG3FamYsnGoUqhSnH6nzgIIEphbZaQ/X7mUN2UYBpnNBJEWIk5YlSxIPycB+IuHwUgY6qado0LeuLS5q2I6RCaxzWtpxfXuIah2scxgaUysfrSE7Y/UTZ70n7Ed8vCFozpEL3/BHuYoW50ASjCEaR9I7YLWinQnwacasFtm1QMVNixnsBBo5TYLefGfb3IKZSYJqkajVG1JxSgt4EUhfIzlKUI4t7MjGKPqhOoFSlh2glIidGVeRnOQCcJfHTFawXM36cqhxgJrUWbQTFut3tREN03tLV7qLVCrzHhA0UL/SRAzCp7l7VBOQEJ/Sdtu/WDlVUg1TJ8rvGSfmqxFPNqiRuxkmTcmEcR3LO9H3H0w+e0/QdL1++wBhFCCMpB3IRsn30olbSuLZqw4H3M1pB5xyLpuG87XjSLSgxkPYDGz+zL4WNVny67mmaJbq1xBIZ5oEyDOz2Gzaba5r1BZduwQ94xrv9TLrbfMsBngSA04y7BqzD+nYfPAUQX916jtSIg9IfSjIkpRXONpKxVDmyw9p3+LnQvxI5Uv2yZKenF/kg46UPnDC4n01VhN/Bcumw+dlXfuA98uuU03g6Bzig905nu6dQbWMs1uoa8BqMEfWYQ9CzVRTAGHNE7enaTtXqMAuSB7ocgkPOTMMd87Dl7cuvGDa3TPNAMQZlNMY1NP0C0bU5uVI5iRC6EVV6KFjliakwDol/9LM9v/oqMqaG3/3rP+b593/CH/xLP+b8bMly0fJkqehspDeRQqqwfFM1CCH6REyeGGd8mLnbbPn5Lz/nH/3xz3j94i3D9ZaSA72CaJHfU1lExAuUQzRSCo7KaIdq7qBgc0K3qT+PGCKWTKUqFCDfy7odX3moCgsPz8z9oPMQfQ+39vGvClmoDrQ9VSCHiTBuuP7N5wzXrwj7LdG1TMmz8RNx9sz7DTe//gVvf/2nbN+9YLr5mm7RUtZL8uNn2MWa84srZpdYLIbj5yrAPAxM+x1To+jWThbPIIax1hq0ao/J2yGB0lrTWtGnXJs1rrU0rQWTQGWySkQbYIbb/YSvcnGBUbiZ0bKbt4QUicmLQbNWLBdLGhwdDXGciBnxP1SikmKclQQkK6nk0TglnE1zan1VCsHP6Fy97eJIypFYJqjoVbIonuSUsUqjXUNRFp9EhNooS9Mu6JcLXOdkVOAqLSJncqx6wAmsXZBbSy4LUgshBoaba2adMeOePvV4A7MqhK1nVzT79lecf/9j+seXLD9+LvSWUMjZElPGz5F5lnbs6S207jv65rDOG1pnWPeNVOoly9qsNUYZrOvQymCNAzKoTGBmDp7sI5na/UDUi6xW9NaidYsuDUV3IiqhMrFACZk5eeaoycUwz4EYIpOaaFqIKRLSRFHSldPWHqtBRZYcpPqw/rMPgoCqdiIyt5MZUMmJkiIqBUrwxFzIWTMMA1BYrnpWZ2uMtTx6fMU8D9zdvmW/t5TgRRm/th66RStBR+Xjc6uUxmpNozQtmjlkwjjh56kuXomr4OlypiswxcgwTZR5lMxvHjEref/z1ZIhZlF7P1lVgvf4Cuk+VCunnCyhYMjKrQ4gGnVvf6T0CTD6CB9GXJAxaGuqvJz0ww8VgDhqiPDxoUWpSqYYAznXRfK+LaY4zOPkDSSI3QfBGMKDCx+jiBvEWmketkMQPCXmfvO4Tyu+OvNzEviaOvdrmuaoiKPVwd9OH1uhh1OlgQPgJZciGXwRwehp2Eob9PYN8yhyddR92qah7VvamB5EgeMxnggTKCI+JHZD4KuvA9d3Ctsu+d73P+B7P/6QH3z8iL5r6Jxh3SRsKdgSha9UxIMsp0zKBR8CKXli9KQs7ephGLm9vePu5g49e5wRgE7UVQYqinhvVpAOGilFPYClSyv7NFY97G3mcv9Vb6F7s9fj75T7FmnhyN8+JkbqUKvkYyC8rz5rs6hkUm23agVx3DHv7thfv8ZvrknTntAsGf2MGgb8fs94d8ObX/5jbl/8kunuDTpsib5njity21Yy8yNpa74XLGJ9vubJoZuZkBRh9veatCegpdMgaBqLdgbbWWwjHopZSeISibjgMHkm5jrjSpmshWtGKkxhFDnGnLC6w+iWVrc0WByO5D1KZSzmOJIxxtwr/2TJbJU6/fP9rUCRgJVSJJZAzlGcboqqLciMs608ydogPE7E7cI6mrarUoTVsLa2LXNtw1MA04IzQEvRIznOxHkm7TQ6BWyXKUaswNS7HTFmotJgNd7PlEVPzIqQwNolORW8FzH24E9ENlB0bUPfiLdl31pxhGhslUmUhN0UiQcg61QBipLne86RECdCFCm1g06y1VpcSPqGxjis1kjvuoDKRx9ZHwOpWEARQiapgjTsxQElJNFaUkZhrKmfqQbA94qW77p9ZwFtZxSt07TO0TlLoxXT9o7x5g3jmw6XAj4W3lwPJKVpFz0Xj85xTYNtGn7yu79N3zcM+zumccd+XyvGKE7LzfkZWRXmlLFtw0HTIfnMPATe7W/YDXt2w0C7XuJTYbMfSC9uuIqaj0zHq5c3vPv6LSYEZj+zK4bbtzdo23C+uuQgtXW8hUvhi1/9ktub6wdzt2/MYjgsIvk45zpk5Mc5XA1u4rbg6Lqepmlou070MWNkv9tV0elw7GUfxa25358xRhzgj8GpBpYHwawcAxVKyPJHrmMpjIMQhWPKD+Z3D1QptJZZB6eHID93ztA0jr5rWC/EQ7BpnGhbVsd5CXhVN5L7GWDdW3V7qItxzjIDDIEQZja317x7/Rs2t+/w+5uqAA9tv6RtW87O1wJWmB/q3GsjLcyDMLposniubwe+/HLkT/5JRK+e8Ff/td/ib/yN3+OjTz7lfKkoyAKqqihBzI6ctNg6pcgURkIKhOilH1mtsNZnS3784x/y4lev6RKML75i0Ru6zpLaBj97hv3Abh/wUTFnSV4K+j4IHiTN7s8MD0naBeIEcZBkq55LEYOsj3Q5kO9LddIQKa2jr2SdXUtilo9zoMP9kKIn+oEYRqIS9SPnLMOb18x3N9x99U+FwB9m3r58IdE4FobbG8J+h795Ra8D5zrjrGKeR/bzTLQN+2nPzu+wjWa723K6BMWQmPczdyny+vUtUyhcbyKlHqM1ojfcdh1NI9qb3nuatsH1De1aWpdKF7R1hBSIU0RZQBeGeU/KkmCYRkmlSGAz3qKVZW56zrpHLJuWznWoCCmIhZdRiq7rRf82ZUwLySdSSJRqfO2/VZFJc3n1CONa/DRzt9ngw4yKhhQGcgkUFNpIW3DZ97RNy6JrMc5gdEFPA83Zkr51dLaRezkHckwCYAtiUUbRZNeCaaBXmLtbrB9wJaJ2O/RgsClirEZbSPtB1q9Fw83Ll2w3d9zuR1LTkpuOx88+JhfFsJ/ZDDvubjf3DXKteHRxQd8K8EwrCdZFKVIRlSOZ+GksCpJnThND9ngysSTG2TOOM9M0yxpWJBXLIeE0PFlZnlw84Xyp0MYdHe4jilQUmR5jO6BIwMuZUhJTkqR0nBNJa1TjUI2WIWCEcrD4K9X95n3R4T9n+86VoFYFrWTREefeRAmeeXvL3WvN3ZvX7KfIq+sBu1izfnTJpz/8lHaxwDYNi+WS5WrFcrk8tlVLVYvQCmL05NoG1EZDlmxlnDy2aPbzyDDNjPNMb1qmELi+nTjbRtq1omkviOUFuzETtntBbRXFEDzaJIzpmIO4GpwWy6/fvGY/DFWwWxZ2qXKkwjkgJ4MXZCtFgEH3qi8ShI5tTmNYLBesV2v6vidM03H2d3d7yzzPol5zUo3pigQ9tDcP7ZkaGY/V5yFAaa2J8SDFJAFynucHLc4wS8VcUCKurUXN8tiq45A5HUoPeQ+jLcZoFn0jWWHf0XUt1kjgM8aI63at2ATNqo4f8zBDpCRpEeZ6MxehLMz7iTBPjMNExmGbFfM4YnTGaFgtFzjXYLRFmu3vCTIbjbLSb1YAuRBi4c3rwOdfeGJZcHX5hM9++zMeXVywaDssiaJE03WeQ511ZEhyD4YcCNkTcxTVfepMj0LTWC4vlvzg0+d0KfLFzVdcXS25vDpj/ew519c3fP6rL5h9IGUBeOVjq1LqssP5vk+oTtrY8g3i+I6wb09g+IWMIIhzSdXIVrLhkmIVrg9HJaEDslLQxvdlolKHICjAlhQGsNLRaV3D8OY1frth/+YFhIhKCR0DpIRKAfYDNnisKSwbS2MVummJPotrhfcw7vEu0S4aZn+vhFOAiGbKkObIMEZCVii3OILHVPbo2lI/tNxiEonEYgptkVacbQy78Y7Jj+z2WyY/SedAFXIR8ErJnkwSMeckS7VRMOsJWxp8njFZoROSuNXKSxXQ5eC2Li3MkuRZ69uWXDLOPlwqVRGx+KZxNI20A40uzCkSVaFoQ+Ma+ral1eCUpkkeG+WiTNsN5WIt4vIgQW/YiItCTjCNqMnDPJPv3hK9J4SJsHtHnGbUMNcUUAnZvT4Tuqp49W2DHz06ZFR4gep6VN8x7Dw+w36IeD9zd/PuvoNVOyNUV5qCqPWErI5dHWs1BwXQvfdM0fNu3BOq67sAmyLepyNVRgG6ZJQRcRMZDUU510WRsgJj0RqcsTXOAAhYL3kPiKi8KroGuYzWsqakWl3L+qswWuG+u372XyYISiBUJaNyQiUF0TPv7rhj4u5uz93e8+J6ZHn1jEfjyG67Q1mLdo6u7+kXC/rF4giUyLlUt3hBS2I0WFNLbDFeHSZPSTDtdsw+MMfI0kbGOfDmduLJPnM+G5rukqJ6Jq+4vRslfjSWuyGgdaRxI1MQ36njuKQU3r19y267w1hN04qA93K5wNW277Db4edZPAvnAUrEmTqbUweHuCoLW8A5x8XlOaRMjpHkPTGJYe3t9VuGYRTn+hjJpWovalGzkDZlHQfFfGwlHHpfqSRBWVqH92I+iapw5Lq/wxb8JIAf7SjOcQBLPGzrnPK76tzXGpyzLBc9Xdey6DsBLNTWqCDDODpJKKWrLxpAlvZEzqQUKggCxnmW9y6aYSPBeZw9hRbbGpQZKjCisFosMEYCYEJmA6ebABc0GJmflFSYhsKrV5HPvwjgHnNx9YzPfuszzs8u6FyDJnF4rIKf8UEeVJ2lMo4lkJGHMqZQ6zQFpuCc5vJ8wfc/fkofZ97+rPD4asFHnz7lk9/+bb789W+4fveGzWYghIjOJ7NBtAQjVTgOdkFABA+OqhD2b5l3urqhVD9NvFSnKeCnScTgYyT6mZICOYhJcimlzqYiMQaRIFVUZJ7MqWP05GlH9kOdQTm6pmV8+5a42+Pf7jCJ+jWhckAnj47i+t00hmVnaRtDaZfsCcQwE3wkq0QyA1l3zAeaTd2iMviiiSmxnxMZQ3OxRlu5b8pwVxHRGmUMpCJzbF/IOrEsC7R2OGeZbkb2457dfsecZ2KKaI20SFMgp0AsER89OWmMtjijmRkxyTGnEacsjTKi+IKMJaqcLEZpQoFSkyRnHYuuI8SIO23zUsgpokrGWY01imIMjoasLJkItqVfLDhbr9HziE2RNs7oihIOu2tyeIbWAkDJ80zY3OGUlg7Kfo+aJpgn8u07/Lhlv78jjQM5FnIwtQ2pCMNI1qrKmRncoiGvF6gQUCWQrne4RY9Z9Ny+vmFMiv0o6rXjfvugdXhIpOVcSK8lFqBIOmqKyG5npdjNgc008fXtlqSkU2GUBLoUMyXVAKgVrZbPShF1rpwjSkdSNqQsWqBGG4zSNQgKlSuViRwSCovUorqq9YAyEgTF6FmSTGsUzoD7zpHtL2OlVL90gRQ8oURsSmjvYUyMmw3zGCEWNm/fEPzMn/yDf8T3f/xjPvzkE0F05cx+u2PaDcz7mTAn0d9zFUlkDRh3nBOCZoqJkD2301zBB4ppO1AKtP2aR4+ecX75hM1+pl9d8NH3f0TrOjbbLe/u7phiAZ25niYGn9hN04OLbrToFisDq7Mli+WCru1onBOF+P0OKDit6Jc9RhWMUcwhyDC+tmIy4JqGftHz5Oljnj55zNlqTdM4Zu/FvT0FlFYM03CswqyzVVvUYrKtAI3CfUkhg+OCoM2MBdcoATVkaQ+WDD5zX1mAAFqsxTVtrbxlNnngCN4L9Upv3VSrpMWip+86zlY9zkkicKg2zSHo1RmJVCaZ0c/4EBjnie3dnnGa2W53tfrLjJsbcjYU1WObS2zTslg+J4wTaZ5RpeBspOsOYuUH3IfmG7MYo6Ua1KBTZp4zv/488oufw69+5fi9v/H7/OSv/AE//vHv0vUXFGXwJZCDl5Zh8pQURYy3phgZxFoHhYqalDIxR1QDlIQioMMdOt5h9MRy5bh89ojf+6t/wOLigpdvbvjNy1tCmoVDiqZkyZhP0DHHTZwe7lPVnDNf/upvs9uekbKITlMySUViDqQcSbMnh0wOkbAfyTGQ/ITSFmMd68tz1n1Lt27oDq7dqpCZSTFyc/OOMO+JuxF9I7MzXxRhO5LmCPsoM8hcmMeBml/T9p3cH40SOH7TkJsWNWdyAj9WP8k2iQ9d8KcHyrhYoz74iCfPP+D5rDC2pXv6nP1+y7DfcP2n/wBdMqaIO0wqBdU4jJNncxz27PZbUomMfiCXTNv06GJwtKjGcL15y+12kMCYI3OOyNw8EbxiSg4VFWd2hdMtxmpMkVnuNMwoZRCJZnkOtDEM+5HiEsvW0WpoD5UjkHPi61/8CU3XYY1ht9uRUsIoRyiBouHq4pKrR094evWU21//grIfsJtrojEko+kXS4yCuL9l88Xn2HFmPcs+VCmYaUfxnhI86MyoFXut2SWhDwSkE5hKZo5TTZUV2jSYEGjmibbvsdZCLrRzot175mZFMgZlLI22ZONOL5eMuowUIY2R2Zwk0LpiIQxDSOx84Mvra/bTxGbw1XpLYTWVL0utsAslRWwLrTH0bc+cPDfDlq5TKNWh6LHW0a7WXHzwCehCSYHp9a8Aj/eSoDfGceZ6SrGgEsqINFowCZflWTOmsGgUhfBwQfwLYtt32up4GEqN9MgqbACnpPRvs6HP4HNBpcDNm9dcPX7MePmIrm9oraN1FqcNVimBpCsRqzZGhsYxJoKPqCLmnrYVyHVCyJc5i32HIBSldzyOIz//5a9oVaJbLWiXS9Q0M4VIVjJni0oR+SZ/RPYsyv1aFSmlneWgO+iDUDhiKlKhGI1yFq0iWsuQOB8yJWcxTSPk3krwlWE7xCwkW2MlIGlzmDPeK//Dw6HuN7zOTlqZWnoM6Koeb95z9BZfOnckp8sNcVCeoA7iNdYYqXqdpe97Fr1UgE3TyLxQ3weilBHIdy6E4MVcMyaGWYLgMI3sdxPj5Lm+3qKqVUvavSPEzBQM3VnGtStWcYkfPMlHWtUSkL6+MRpbD/Xo6PDgFBwAQ5kcYR4TX309c7MFT8fTjz7g0ZMrrGtIuRBzJCVPCjM5RvncKZJKOpLSD76P5UAiL5BTwaRM9CPj9oa71y/YvH1Fjp67uw2vXrzm9m4LSvP8ww9Zn/2ccUqMc/3MDxQH5Wk8dLffn01DwU93+DFL+7ouHkbJnMikiB9GmAN5DOTdTjoM80xRYl2j/YQ6W+DSirIQzqgyYFSBHNHBo+aZMk743QgxQSzMYyD7TJ5zBQxBiTNaS2tJHvPMNEf6ztI46d4cmtUlFogKXTQl5Qd+nQVI2qC6FYvHH7JQPc61NBcXmM0NqnFs2x4TPVD5qqVIhl+EZhB8JNYK3YdIUcKjlNGrom0aQVYaharuFiEkKb51kSpVC7ewaKFNKFtIIUn7OwV57pUIOVjn6FH4ycs8LIurjD65YKXAOOwIwaO1ws8eBdhW0/cdrms4Pz9jvVrS9z366gq6BuvgZrsnp8zFxSWNMeRhj91uaH2ip+HArQnHL8hNTzKClg1R472YYKecSDkxB7m7xOkmoeqIIOWELZK0HtrMBuH6Ns7RGEcK/kGsOKC5S87HtuRh36Ua/M4pMoWJ7Tgx+nrNagLFURAd7AlOwCiFQot59xTAJ7SRa+dMKyMVY4nduTDwc2Cx+Jo870lDAl0wKFpla1fSim+sSQSr0UVRyCiVWTSKRfPPYSao0MJTUmLCqqrxokOzbFouzx1NKJg+M80TsRTe/PpLzs8uWK/O+P5n32O96LlYrzjrOoJrGZhrANS0jWMOiXmcGUdP27ScXT2ia1oJELdbcvQy+whRFBZWHfM88OpV4Gc//yf84e//Fr/1g0/pz9aw2bIdZ8zSYFtDbhqBCL8XWFQO0g5RBrKHHHHOstvu2W527HajmPbGjHYL0C3a9ShbMCVLrl/Ez9DojO06uuWCftXTLVtyApMLOha0bY9fVh14elk8vMp9FZRzkYCTDy3M2sZUwmXLOaOUvD/ZY7Sm6AMIpV5Y1x6rwMM8UR9AMVrU4Y2WANi1LW3TcHZ2Rt8LQEEdAqe6t38JITIME9M0c3NzwzROTNMk5qcxMU6elMH7xNdf72lMoNWePr1jP+x5fbtlcTXR9Jf0i0fMcyFFxfnZOd3k6Xcj1i7oW42zquJTHgYTha0LbiRMis1t5B/8dM+ru5ayPON7P/4Rjz98RiqF4Ic6j53I3kt7OkUxWlbQaHv0gLyf69a2ZYbiPePdDb/55c/4/Kd/zLuvX+Pnic9/8QVfff2Oy49+xPnVY37rd3+Xn/7jX+ID7F9eV4TzfTojsyeOvoOH2cv9kRWS31GCXBeHKIYslBUwUUnspz3zfmK82xNvNqR5Jo8TPot74b51zI/OKU8fUc4WWCfoStc20pLaB8p2Jt0O7N+8I86BOAVClI5CjuBKwSnFwmlxsrcNZAgpsRt2tFbjjGXZZhoKfSnsEuSkaHCk6EknkHuQmaDuz1l9+BlP1le0rgUDbrHEtR3bs0vKsIFJxg6pgOsMsX6upIy0qXNm9kKtymRwBe04tnatNphiKT4yjwEoOGOItiGpSFKB7BI0CdUU5uDxOTBHj1EZaxyd6YUCtDSiWhWF46ff762VwjDsUXqEXLB1/tc0lsfPnnB2ecnZ5RO6dkHfdXxw9SNs9Ojba372D/6EtNnzycefMs4zw80NZ5sdCywXyzWztngKo2rYAIPRmGVPNBmrA0HfME9eKBTzSA4zqVoIFTKpKhOJDlDGqow2jmAUVhUeOYtrW9xiUYn0D6lVQhEulJLRJVUwnggH5KJIqrCfJ252O252I6lknGuOAK2SA43WOKNxgtxDaeH56aIZJ9j5CZ8TbWNZ9Ya+XWB1oWjLRp9RXI9Vie+ff04XN7RjwGfpWrW2obEN1hScub9GmyZV6legbRTXg/2uheB3D4JSVTQoLFHLAHqOkXGeGPbgIxjtuFgvSQtLTIndHFBhYB42aDKrRcsnz55wd3GGnSbKOJGN0AxW1uKKorhMnAMlB243dzjrUEo4aot+gXOO5MMxlN3dCbppHKvR7jQSKBRn0IuOGU+ICZdzRV7et6EU0LWWvm/QznF+tmK5WtE2jl3OzNPIsl/QuJb1ck0oLTFrBg++SiKJjXJBqQw5ME2Gr1/uGIcs+1UaHxOzT9xuRsYxkrDHqjbFigAsRSTijFhTKdOA0oQoruEpBrTKUKujnJLYp6RQ5dgeXi9tbP0yRwk0VUTLURtdhQ1Eoafv+opobdBK1PjL0XlJEYKoTAzDyOwD3su1SVnmG+cXa1KBYfSEnBmnSHmRePvmhnHzhsdn8iA0/SXRR7SeWT1qKTmyj4kvXr1m3n2F3/yC8td/xNOrC54/uarUkYe1oKFBF0eKgRcvIr/6cuaP/8mG7vGnPPv+R/TrM9CGzW57n2TEANVdPKYo5GoKpWlF2xJVK2mF1eLYrdCMmw2b16948fOf47cbCJ7oI3PKpH3kb/1H/zGf/d7v8a/9zb/Jf/2/+d/g1cu3/Kf/77/H17+55uZ2T0gVCIOWHuexz/v+pjjrOi76DmvA5IiOEbUdCdsdfrfH374jDBNhO1L2MzYVWqWZksbnzOZuYPSJXUyUTUeMidvNVtRUMoyTF/WSGOi0dGGctkzR42MmRUUCslK05r7bELIc7yZk7G5kyomLlJjnjNUJlwSmrpOiJIPK5uSoFL2VRPDl2w3FnrFSjjMjgKjFKtOtLog5QhhZ9J1Mby3MfiLnRKOsME6QwHhoVecQUTbTGk0MWVCUAcIQGW5GFssFqnNiH6QyySRZt1yL6g2rZk0O0C8ToQYVnwQUZbRitVoQfcAPgySgpx0kBU3TslgsWS1WXJyf0y161peX2Ea6L1YbGmPpG8cPP/sBrSrMb17zxedfsx1numXL5Af8tMeePWLWjrt2AQYimckvGFVhmBNNyuQUyIysLhb0ao3WLWF7x7zfMe42lJRRFfSjKGDAFoXDYNoWbYSulYwSdRcto5RsTipcYAoJrVI9z1IZWiVVeUZk5PZ+ZOdHirIUMr56vqqccTmCE3WdOSQaa1n1DeuupbMGpQ0uiim7SQGXZzo10JslsQTebrZkO9HYzPkSVh6Wc2ZMllw0GUPnMlYXjM4UW8hJkYomRogRtD5VBfuLt+8OjKn6j6UouchKUyhVbsujlcM4S7teEoOpC2dAl0iOXvglWtG3loUzLBvDujEElckaGiRriNYyWiHdT9NEMFF0DG3LcrVivVoRfSB4zzQM1em+thBiYJwmkoJiLbptid6jcq7KDg+RoSgwVhQqdEV5NU3NvrMQqft2wWqx4urRYwZvmKOS8jxElBHituT3CbImZdiPCaM9IWSMMYSUJRDGTCrSt9faCPzXudpCyIKQq3M803QUNOPkmScxVdUqH7M0iDJoVoA2lY5wyH0OgBWhQOiqd2o5ONHL/O8QBNu2kbapUhI0Uj7JDxWTP7Q+Yx1Iq6OlXgFcY7FogUQHDz6RkmYYI3ebkcatpbJoHTlZTBJqRU6ZGDw3tzeM23dMd2+4uXvMsncUrqQge799XTRkRYzw9jrw4rXn3Tbz8UcLLp9eYaq/2+wDqsqv5BhQFfGXUiKVimQzgtDVqEpKF1CCVkXMY/3MPOzZX98Q51n2deBxlcTLr7/m6vkHxJz58OOP6Rdr/ukvPufubmK3n4mHouiUM3joiZ5yMqnIO6QlabI8zWE/4Dc7/HZH2e8p4wzjhPJJgpiR+VBMheIDZQ6UyVO0Is6e/ZtbfCiEVOReJGNVoV1W6asj2VKEAhKS6Vfvb4oqxCI8LW80Q8kQIy7UY9MCvlEFiEUQiu+J9TulKCGy2exYXMzgGlorpPGQDGiH0qKZa43sr1hQUUn1XEolZKt7HcwMWWVKyugg9721DkZFiRDnDL0E5JQKyWSZq5LIOqOsGHzTyHsOSkkgnEWlJuck/nk2Ew/jgJPDUiha17JarHlydcX55QVt37O6OOdI7bMNbdPQNS2Xlxc0GnbziGma+tzWWVvOsFyRlGXQVqobFLFYotFEVTApUkqA7GlWK7J1KN1R/Ej0tuqWiaKQVtVSrlD/rWmaVnSaraEoSBRMDWoP1sMCIWVClPtcngUBtMQSSDkx4BnDzHy0AVNHjp9IwxVCqntOGWs0jVYsG0PvLFkZUrJYVeg0tCbTmkBnErOKUtUqQGeaRlFaUC2oBLEofFJYU7Ba2AqHx8maCrop+niNvuv23YNgrSxCTJydn7Fo5IJRMskHzp48oj+74PKDj7i7flt5a5HOKuEzRU+aR+J+S5MmVipSFpYhRkLJNDHSWsfqrCenxH6euRtHchY+ydOnaz748DmffvIp3ntu3r3j5//050edwfVqSQiedzfX9MtzTN/TX1xw+2ZP8BM5yrDce/8AvWbbDtv1KGOwTYPWmtuba+I80hnNs4sVjy6u+PSjj7ibYIqKfTSELHO+/TQxzRPDMAjSqiRShpAbTJZWTVKJSKDoiGkd63bJqu9oG8eicxyYZSl6IYpbh7YdIWZevX7DBseQhmNbkpJRpsW5IkoaJLyf7h9UhRDanUgxCfBG02h7FDto2nvawyFrClVsO5Xq9Fx5N+M0obVmfXFO13cSCK1iP+wZxxG0tIUbp3l3u+HuZs9+l9hPmX20vJ4ucamjjR3LfoHOLZt94fbmjruba958/TmKDa3NvLt9S99pvv+9j4+V4IP7sCSiN2w28Ed/suOnv5yY7Yonn3zCb//BT8gqMwePyQ5z6GvGCnvPmVQfXq11fXiLDDsr9SPHANagnSLOe/x2y3yzIR24nWiWXY9xLW/mie12w+u373jy2x/wyFqef/Cc27uR2WfmN5tK5tWHsMKB7Xf6kJZS2G1u2NoJpwpdTpQ58ParG8JuT55mLtuAMpliQbe2zi+1tHhzwjlD3znO+paVc/hU8LZlN3vmkLCxYl5VAZ9FfswoFtZhlWGgQBJScjGGqBUzhUFnZqeJixVjq0lOkUzVRa1E8qIy8zQL3D89XHzalEjbO9588QvMesWYM+OU2d9ume42TPtEE2ChLYpJ2vzOsXRLQe6mQtt3dIsObQuTn9jutwQtwKHJTzRNR9u17LcTJjtsabGlQ0XDsPGUTlE6iOdegGFWo12LVQ63akArRqOZ40BKnjF4Fk7wBraiQk89EZVSPD6/5KMPP+KHP/gBwQgq03Q9Sgm1arla0zUdi67n4vISnQJ7JKAkFHe7GZ/AtC3t0yeEkLi52XJmHRotcnIVEZ7jiEozOk7Y1YJIYdzvGfd75qEG1oqstdYgcu1BrjeO8/PHgqjWMO/2QvsqI5BJfrq/D4FhihXUdY/cx8AQJqYUuJ1GQoiEkA6YvaOgiKoAwtvBs50Dj9ct69Zx1Rg+WjmWraO4htk7Uoo8PlP0nWGxzLTtyGAHWiaavmW5bHC9Jo+K7BQ0mpAVec4olZBQLijqlCsqUEshJYba3337zkEwVTV1azTLrmPdOfri6ayiaTTnl5esrh5z9eEHaKdodz3FtizOz+n7vma7hUYrzhYdeu7RJcGYGUOm+FmyYWMETts0uK4H3WBcw7Nnz3n8+AkXl5fcvHtXwSVG4NBV8ihXqLgOgZgzKF2HucIRk9Hp6elRKOtQxgqPLIv6e/DSFmmdwZRM9iO727ckZbGm4fGjS7RrQVt2Y8s4deyGhtevPfM0EfxESBodM0llQohMsyeEQOMcFxfnfPDsCevVimXXiJxYjtzeXDNPM9MoigshZDGGLBqtG1K+x8YY1+Eay+WjMyAxTXu0+qlIigFt4+jaVjQJq6GoM+5E5UWASKm6Shwl1XKqTvZCxM65HAED1ll8rfDn4EEr2kULRhFDYhwn4VNWeHSOUunthpGuE5J9SoZpDHzxxRds794w7O7I85arq46PPrzibC3yfD54kWY6aV9DIeY9w+D5+kXg8xeel3eaD374fZ5+/AGXjx9Jd6K6pCutKjle5iVFFYoW5KwzBmNFrD34wObujjDP+Hli9eic1aOzI8Vl3k+iXpGRtm7j6NoG3zYixdV0fPHrL7i9vuVP/8mfkLPl6vElt5sJ7xP3ps/ShjrOHk+Oa54nplGAB9nPpDGwuRvotBZqUTPjtSgshaLICUKiAorAWUXrFF2jsXXm2TlD6RyNMfhYF9RcxUmz0Cc6K6pMISVCFYsuzpKsYlYKbw3RanJjCY1BOUVqDIQMIdN2PRlF0JFQ4gOZPkXBxpkmDCycYbx7wxQCr9Ke29c3DLe3XO52XKjIyphKdxDAmDIKozRN51BakdJMQRwImkYTk7gxrNZrco7E6PFThGw4W1xgSwOhEGJi3ToWboGm+skXzTwHPAlTAhhF2zeE3QgVmN04h3aavulEAnJ7z39USrHuetaLJcv1Ct13aNdg/z+0/cezJFmW5on9LlNmZo86DZKRkVl0qrobmO5ZQLCACGaNPxUiwBYriIwINmgMunu6qyoyKzMymNPHjKrqpVica/aeRzWJEkFbikd4ejx3f2aqes853/lINxAmT4pJ9pFxZrMZWd/f4JC0lhyF7PPuxzcslz1Xz675H//NvySlwvt3H7l7d8t+t0cZj3VOjPF9OC6UyVMCl+i0YwyJOHustRRja8WSxk/nIiiQMZiiKamQY2YeJ7kXzUya98zj/hOE/ohKCBdACswYPNt5ZIqBOUQMMBhD31QCYZImWFNwKnOImThFGmdprEaXTGciy1ZjFwqKRWG4WFiMVWincC4x5wPb25+47qDtl1jbEpXl6DhVcq68ISFmalWIUYIWctGVlyP7y/TPqIK/uAjGJGLF1jbi6dk2dDHRWGFTrs7POLu64uL5C1KJ2LYlqYZ2dU7X9agixAynFMuuxQwdJXp8kjE7x1gvWMYBylnOVheYdsB1PS9evuLq2TWrszPWDw+nNAfRkmScaSgg8SoxPhbBOmfJUfNP2YbaCLuOcnRwKdVNAoyzwhBLgcNuDU2D6XpWiwuawWKbju6gGCdD1yt2e0vKME6zFMEa7zH7wDzPpJRoG8dyueD5ixdcXVyw6BpyiqQwE4Inp8x2s5VDKRwnIYPR7iTCVlrhWnHXv7x6ASpxOGw+gdiaxtE2YnDtbHV6MceYI4F4SoFYIcJcjp6i8nPqgZlKZmgbIVoYzXgYmaYJH2a0NeKNmmVPM02juHHETE7qlASSQkTbTCqGFCHkmdvbn5j2d4R5i8Gz6ld8+fnn6LzHOUcIAdvourN7eh+O7A6BN+8Sb28SD4eGf/Gvv+TZqxesLlYk5PqJJknX2aucmKbFqJMxgjOaVApzCDzc3rLfbJjGAy90ol91lCTuIfPoiUUTCyhthc7dOBbaMvQ9ret4+/Yn3rx5w5/+9Ec+++w3XFxc0ba35OyJUaDWUqrNVDmCONT7EkII+FlMIuJ+JB48h72nP18wLFp6JxpNP0emLD45ISZxsdWKxh4dnTQmFoE9rUI1hmg0NmYpmgkRYxcR9veuIRbFGEtlHBZK3R1FikBy1lCcITlDdJrUOlCRQmRoG4rSkBRz8KQUn9Kb0Sng0gRJc9jfM/nEw95z+9NHDvf3GDfSdxE11Nm4XidTHY7arqmekZ5cIkKDV6gsxWgYFvh5IkVJf7DKcrZYEEISA+tZ4VRL3wzoUsl9RRFCEjJJ9vSuxbUOU60gVZaJyhknz11O9F13umYKWLYdy2FgsVzSLJdo12Dann3Z4vNESZF5GpnGA+v7G3pjRMubMtFHbt6/p+u+4Ozigr/9m7+EAj9enPMf9oF5CihrcI0jl5aUD5QoRLE4RVQ2DMuedc4kHzHaiDG10RJLUcRnWFkjMGiirjkiYZqlmGhFUJl5Hj/Zd2pqLJJWpCy7wMM8sZ9nphBQRdFaw9JZLloHKOYkbjCqrsc+7gOpSDyeVoqcI04nepvpB4XVBqsVy95RtHg5WQdq8hzWN1xdn2GTQ9sWpW0lknFyRMp16pR1nKAFIv/iVADTL2HE1NcvLoIheWIOrExD8SOpzDQ644zo6ZZXV6yev2D58hWpbejHieWLIO4QriXMAT/OxGlm0ba0qyW21ejW0R4mpr2naI1KERMD3bLnV7/+LS+//Iqzq2tWVxc01mG04acffxRvu6FnmjylRBF2LxcsVgM+CsW9JGhNi7YFjThp5Jw+acIH27JqB5Q1rBZnNE1D9CIQtsrw6vlLnLbokrnZrPGbNQdVaPsB61omH5h94DDN7NY3HA4HpulAY0Ww2Tiw2mPVhNFFurKwZ7f5SEkHttYSY8TPM99++we22y0P6y1n589xTc/q+hp9mJjGGTV7mQK14vx8yWo18PnrCyCx2Tw1+IZhGFgsFtWP8THaSKaSTKy4/9HloZRMSr5S+wspHaUDQtZJOXF3d8Nut2WchITU9R1m6NnudkzjzH6cOXjFGDSj95L1ZnpevHhF4xY4PfBw945pvGez+R5VIpqMceAaJ/IM6+hac5LkPFUalFK43+64nRX/r//Vs4kXLF+85F//H/9HXrx4jrENJUcMRfZfRymClR2NMtIRa2rqhJ8ZHzb84R9+xzf/8e+4+fCBGCK//es/Z9wfGDLEqLnfRwJVJExb7ewiVhmGpuHy7JJv//QH1usH7u4+8urVF7StoetaQjgqEc2TQliq3vIJT0ZRzec94f5APEjxvLy45NefP2eR1+y2exQNQUWULWAyqBETPcuF5bxvOO8syQvdU+uENknsHIrImbLSJF8z7RrD2dkKZSztIvLhfs16N3KI1WFHPTWHl4QTZcxp15kVJCf3U0ih5rt92oJb43HWoxvLLorXZ5gzeb+FzS1lmPEF1krjk0JbQ9/0J/emHHJ1cIGwl8zL2c/ietNomuKYDwfiJvDVsy+xxtG2Az/99I5pnDH9BVfLC1bdksY0EA2H3UjbLVBaMfuZpITvsDpb4vcTfj/i0wSqiHnGcsXyYjz1mEopnl8944uXr/nt57/idn9gN468efuO7XrNYbfl8P4D82HPPI1c6pGry3O6psP7A9O0Zbve8OrVBYtFz29+8ysa67hYnfHDH9+y3u5wqiNrDbblfhSD7pwUDzd39Kslf/0Xv2W6v2deb5j8XvZoUZG8mJO7xtK3lrY17Nf31U0oorOwRxUZ7z1xfpxwtYLnK8OqFzLigw/kOTGvAwtrOG8sq8axbDRnjeHZohU1Q0qsOnGK+od3O3540IQED4dI8pF5l/jtteVq1dAvVkxeM0XxO26NFMd0+Vvy1GA+3sG0oewypfszUrsh2J/wUySmQgzVjrGkE3KXUgatSaW6qNVV1S99/eIieOokgodOulJbq38uSZxhGoduGpp+QVGWkDzYBqUt027NYbdj3O5Qs2i2SiniAVlZm6oSQxqraYymtYbrywuuX75kcXVOyRJGa2wd852lXwgO//qzz1ie9XSD4/Z+h1a+mnVIG5FKEtGvNZ/sY3LR5KxRWcBvpS3aOJwxNM7S9r2YbudC40VoTaGG4kKMMsWqnGkbB7nDKMVquaTve9nLWYtRCnLGOUfOmd12R/BBnGKqn+g4eYKMG6gq4ndOU1qDUQ6nSzXojbQ209pMYzLaKGJrPmGIfhprBFANrHOpBe8IgVKhz0oGquhjTulkiTbPYka83W7Z7/fM84wPkZw1Bcs0wjQZJt8wzjDNAkO75pxhYbG2E9H8fM94uGWe1pQ815BeToXhGJBsjDinHB1QngwW3N/DPMKbj4XF2TPOXn/O8+fPWS6WGOPkAc+ZEj2TD+Sc8DnSDb2QIXLBe08YJ/b3DzzcPfDTt99y8/Y9D3f3pJT58OY93dDz8vyS3cGzm7M4iSgwpj54uaCUQ6OwxnJ1ccH2+orVakkhMU4H8YjNwiA57gRPHdjP2Gu5KJnKx4ifk9iSlVLXEBFVr2nTdGgzQUrS3BkhAzTO0rZCchpTkHvoxOco1aWjyk4qccpaw7BoMdYxa093aDjMkTmLZKBZNLhFC1bjbJGoH2dxWtciqQg5iG60av1OmlSOb1VTlCYVg1MtrWroomdZRlp1oCsJkmLymqwSpsjTqYtGZS2enVmhs8biyBRilmBvXRRpSuikaVVL1zRoI9KOi2FFbAbaui90WEiaHCGEiFIzpYCfvKwttKHJhqIKylSNqhJY2cdQA6cfr1dKEULEzYk0zoz7PXc3H8V4PXnmzZp5v8dPI2G7ZW40pEDwB3KcUTFilKJ1krGJUsQ5UkKkxFRJWEnOl1RQWeO0w8URPY6Md7cwHXA5krIQ1oqCkqNk/eVCkxImBubJQz0HTDnKspJYtYWn8DUMraJmGTCmhNeZwWmGxtBazXlnGRrNstFcLQ1Oy7m5bGQ3eNY3tM6ilCHnwhwzGxIHnxh9YvaK+z1sxkJKI2eD5sWFY7F4STP0PH+u6ZyiFEtpLijtOblZEvYPBJ/qBC/6mXSUZdTrkurEmOpU+Etfv7wI5kSKgfFQYNFgjcYZ2XPEFMGYapHW4IYl2bQw70AbcoHdZs327p71zS2NP0AKzMTqvi9+ofIgtwyNq3qpzPXlBZ+9fkV3dcE8Tex3e4yVG8c1jrOLc/p+4C/+8q9xrQKd2e3/hNGj+NVlSa6MKdB2Nbn+yStGhQ+Ct8esaIqRIlh9M5tFL352BRYlY0MkFOnacwqylC0FazTnyyWx64k5s1yu6LoOo7W46Lfto6FxLjw8SKTTKWMvJXzIoAxt29NYQ2MUrSs0yjI0Cu8K85yYDp5GBxodMGWmsw25eYR9QfxCj+G/Ar+Ju0uq8S7HtGlxSToyTtOpaMYU0BhUUeLVOE3c3NwzHmaCTxQ0flZ4b5i8YfaG/eTY7gyHQ6Kolm7oafuEVZlp3rB5eMNh+44UDxgdhESg9WlndwzrNVrCjMkwe38al0pRvH2n2O0U371X/Iu/+JJf/9Vf8OrlK9lxFrC5kPxM9CP7uwexvJs9Z1eXDMsFqsB+vebh4y0//emP3N/c8cOffuT+Zs148OQMb9RPTIcJ/vwvubnfczcKWQhV6Fxm0SaRP6hWZCcYgXJV4eXLF1Aym8090zQSgzD0IFPKMY2goE4wvby5nCH4zLjzhCmTvBTA2U+M446hiaAUru1RJoDJYtZnxPeybRu6rqPveyZfKCcihwiZcyzkVPWnRSKymtawXHXYpsErxWbfcZgyN9GzsB2LqzO6ZSOej6SadydHhliLWdaHSYgSMZ7yIz85N5QhF0dIjt4scLojpT292pPNlkXRQmBBo12kMcc4ITEvSNVAXStLp3u0MpWBKc9d2AVsMjR2gbWVsV4Kz88v0dpytrzg4Efm6PEhEQWjJYS9NAajGDJbbVi1Q23olaQyaKFf+HFkf9g/vidgPJoOPOyZtlu22wfev/mRxfmAs5q035F2O/I4Enc7fKPw8x4/bkl+xBZFqzV9Y8kKwhxY327w+5E8zxTEaH6aR3JI2KLoTUuICXY7br/9lrRe08QZYhAHJV2gRAyatjhstbBb7z1t2+LaBooQqVKMop31j0HaSsGyhVUnn+/BR5JJXHaWi8GxaA3nvaF1Ar0/X1paq+Ss0rK+udp0DN2MNgK7+pwJJbGeIptDot8VfrrLvN0kbu82vHre8xd2yW/Pf8XQrfh1bBjXW1CKNDwjDdfk4RL/4R4/B/EkTZLUEatjlqk+tLmey3KP/zKNIPwziqDEhcgNMwfP7BVp2RBr45crlVYOI02Kme12XYXkgbc//JH54wfi/kCa9sQY2CbPIWW8gM9C2gAWXYPtHFYlnM44C8Y5svfMJTGFmZACaHjx+jWXV8/46rd/wTTt2O3X4t5uM9ZFhsHiXEPMWvYLleZ/fO2miHKZYTGgdYt1HecXlqFrGYaOl68/o+9auq7h480t+8PIbi+TUS7iAjMMC87OL0Bppmnihx9/En1fFo9KpS39cMaz6+doo/EhcHNzw36/Z7+Th0tpRdct6fqes+o2oZViv9/jxwnvZwSmlMMwK82cCh/WO+JdZLfdPDHQlgP0GJkkU14N+cwCHxwnhCfprwgmJ47x282BeQ5MPuDaBTFl7h8S3htytrh2gKkjpJaUesa5sN4EHjaKaYygAloL2ejh9g3zeMe4ewtpxBRxrlBFvBtjOvDwcMePb37k1fWSvpFus3Ut3geOt3PJhf/4dxn0kuH6c/6Hf/kv+fO/+XN6t5CFeE5MU2DcrdndvOfdH79je7/m/ZsbuuVA07XoAtN+z369Jsw7QRZiwhYwRRF9Yne3xU+BnCwP2z2HYohRdowpR66w2MYK/OI9+4ctn3/9muVywf/+X//vePvmhpubNTF6SnEY05yuzc/hwtPzVRQ+ZLbbmXgIlJjQJHaHPQ9rKGqkFENMkq5Ovb4xybRQkEmxa5xoVpHsvSO8fZwKj1amRmva1tL2Fts47BhwTUPTZc76gdX1kqtnF6AroUilk3tQyQVs3dnFXA+gXBPinxCZCuRoybOlRIvt9rTWs+IWt9pg3EwKhqQdwTTY5SB2b2kmxwLFoOLxHi44pTG2QbcFvbCoRpGtTDTFR46mSUUrXjw7p2k7um7J3cMtm/2WPO/RSiLOcpKsPp0qqqwLU5lPMHxSumpqjUyjT/dmSvH5sxesup71es00j0IIK6B8waSC6zuGQVLaU8qsb9dstzvG+y1qlmbT5oJTYm6+vt3w+3/397z9w594WN/jnnf0OWO05vnVl6gY0fNIP+6I85708MB5SpxZy5S70/NuajrIcrUgdy1BKXaMqDyTk3igmqiwSaOzAZ7qOqF1gjCVAr0DjaE1LWedyNrOF0aQOqdZdDIJOiOOO2jNxSJzuey5XBZM3giBK2a+eT9yty+82r9Bt0tWTUu77LG54e1N4otg6PoGbRdMaSLGjM+K7AbU4jlj/JZ5kkkwBOErZDTOKRwaqyqprEaE/hces//s65eL5a3AJ8YacvWxLKoROnnToK1IKECJKDlEpnGPjzPej6wf7ki7ncCJ9eH1QZwgjjT1VDP2rNYYhZgER/lx1OqUSs2WKBjH+fk5l1dXDIsFPkzVfUUcxpvGsFx0xGQJSZxg5nk+waGFKgso0HYdbdvRtR3OaoyRgm6dyAn6ocfYdZ3cYv17CkY1tG3D+dkKYx37/YE35i3zPDHPnmkKaGNxtqHrB9HjzdMp0WCz24t/pzEYbemUpusX9MsVALtxIitxi1fWoqwFY/FZ4knm/URMkf1h/oT0k3M55RQK2UUK6DHHsLLbq5auagvrNk1qohPMPWS0sRJMyoDWgNJo00uHHxzeG6G9HwrzLJN1IZPSTIwj02FNmLbkMKJJQtM/WcXJIbDfb/n48T3LFtTQ0ZqWrIWoczpTC9w8ZIZVy7PXn/H81Quury7QqMfuNkXiPDPu1uzvb9ne3rO7uWHatRhnUQXiPOIPe7SSEDKHEKCsUYy54GdJC99u1oyjl30DRyJR5RcrfdLITuNBoMWh5+rqinGM+AD9sGOeVN0LCvZ7nP0+mZeKPLixFGafxEAhiaYv1gSSuYjuMQvmJdKklIlV5lGourNT5Feu7h+5UoOEGHY0ZtCKKpGRe53j/WAUbd/SdA7bWHKNuy9Papu8FYmKslaTi8YEddof/uytyXWOYP1MS2BptzTtiFEiG4jaEZxFN6K4DXMQFqdSFC0FK9V7VoPk0TUNqtXQQGQm5hldRMqgrGGxWNK2Pf2wYpxHJu/R81gbgWrZWEz9DKzodo/fsVLChjZCKEs6fSKR0FrzxZefcTmckefK/q1ynhQiKYkZxWJouThbkLWRbD0sy4tLUI4QE03biAn5PDOPI/vthsO4w/uJi+YSWxxJR1zsQEeK1qS2x6fAYd5hlanBsoqQIyRwSpxyjNInCzNTCpSaWpMKKoGOBVMU+mcXzOmC03KStLbqDK1m0Sp6qxkajbMa54S5LfrN45690LWGoW1YtIk8KmIu+Ji5HROpRJI+cHHuWC4MZ51DWVkVSHNeSBjRkMbCNAvbt9ieOcIcMjEKEUamPUFC5HoeyTOcFg+/9PWLi+ByNXB2saQxFo147mWg6QaWF5d0qwtct+CoxRsPe9b3H1mv79hu19z89BNmnumiYNZZadHapQrThYhWGqcFHycX/GHPYbNm3GwYXryuxcLSth3DYgkFPv/iC66un4MuTPOe9eaeGCesVVxcLLDPzimIvqiUwm63f5IBCNM8caEyr1++4OWzZ6yWC5aLlof7O9brB8ZxFF9NejabDXe3d9zd3clBphSL5Yq2cUKbUIWUPHc3H3l4WHM4jIxzpO16hsWKL7+Sgwet2e72fLy95c2bN1hraJqGwzQSSuH82TOS7Sgo1rOYRCefWQwLdNHgEw9TIk0RD2hrCPMnzSo5SfzO40RYG5cKyYrUolTNjUIpKYBKtSjtWCwWNA30XaEgrFdjE7GIKD4WgW/9XLh/CGwPMzebAzFQswP3HPYfOexvOGzeQZoxJXEMKU2pFkOV8P7Axw87duu39OZvKM+fcbl6TS6FmPInO8E3D5lfPzvnf/o//Rt+/ZvPub46w48j07hn9COmzMTDlsPtew53bwnrLV3xhN0onraqYFRmYTKtFtRiThbfiT3X3TZRQkEnmA73lATLzjKFjC8FnQIhOUJS7Kc9290DD/fvOBxeUDQslwt++9vf8tlnidk3vH93x9u39yhthK1aqpuFflpVkGisnDnMheQzKhc6KwLhVERbRk6kOIu0KGfmKTB5kW4kDCEkpv0e8oxWEWvB60xRiaw4SV6O179pDM5ptFXEkglkoip0iwbXWfHpFMqmmBtUqro5xv8UaKyw96Kp+88ncV4o0CaiVcSkSJc3rFThy+Ud2mwoZs9NXBCbgTgsmG0UFnrIdK7D6oacEvM8M88zU9Wrdk0rxLS+oVl17B82jHlH6xpcI9mEtm1p2o6Lq2dM84z3ke1uS5FsICyaxjjOFzXezToOs8QzxZxYLJZYLDYbNIq2bU9vyznH//x/+Z9hyvzDv/07XJzQFIKP7LzHq8Kz8zOev3rG6y9e88cff6IUxbPXv+b1X/0tqhTWNzc0NvNw95GHD3fs1lsSI6MaiU3m9auvMEmBz+y/e0+ymtwa5tUlQUFMB7RdoE2H7mZUmihxrBwNOEwCq8cCjS8kLdyNcpggKpQ3AqU/uQeVgtbA4OrTNhhSqZIiXXAahtaI36cVa0OjxIiDktGlcD40XK/gxZniw0Ei3/Y+8mafuZsT7+c9XybL50Xxm1dn9J2i6QsqbBkPDfvZMM6SIPThw4ZWZaw542EqzFPG5Cz5kaUWwVRQueYN5Me94H8XneDF5RnX1xdiwDodsFn2AKppGS6uaVcX2H4gAfM8cdhtebj9wP39Ldv1A/M00jtHd7FiUa3P/Nu3TNsd3stuzVRotAAxz4Ryz/r2htXFFc9ipDWW1bDg619/zX6747Df8+zZc4blghg9+3HDw/qGcd5TasxK01iUBusQ+CjMn5DTjY7keODh7h3LRmJk/E4LC/JwwBSwSmO1ZblYkGI8wSTGSMd5dnFB33fkjCy7G8fQdyilcG2maTv6xYKub2maFmMVL14+xzotFmlKusuu6zg7X9G2DmvEuNgQyWHEj3t0GkkpYonEEqtziTjJh+A/6X5SEp9MgUCPy/BcEVDBxMTxpaCUpSgLqiOXhpwNcyykJEyrECQ5fUqpUpIVc4RxgnGE9S4zBdn/QCSnwLS5Y9zfMh/uKHkEalyR9PjIriqiSqBv4WzRc3254NnlBWdLaaZk0fGkU1WK5fPnPPviNV//2a8wOrPf3LO7vxG7LV0YBkduLUNjaQ0kC7qzwoZN8jXWFPl85yhSlHnGaEXXOYZFT/CZlAqmRIy1XJ0PbKeDsOvqnmhOGYxm8gc+fviBH35Y0g495+crVqtrCQbVPd988y0hfsPD/UHSUbSqw4Y6rQQLMPtMjInDGFFZNHKxZA4+sTl4+oWYIoQkyIJooxU7n5lj5hCRxJXoMVp0g9ZWrWT1f40F5gyFhM9F/v88Q0z4EJlDZI6BxoAyBaVlUj521qVOmqn6npY6VRoFrROrRGc+NS4uJEKa2U2J9DAyT4VrvadLon/96f2ag45MbWH14pymaWm7gcbKPv1w2KCsxqkWjK4wbsvZs+c0Q0dSmXk7o/KB1nbi4ek6fEjs48Tk37PebJlnD1lyBK2yNDVKarU6ZxiERR1iwigj/qRTJOmCs2IoYT/JEyzVUeo4fkjxLynx4tVznl+d8/piiWsbdGNZP2wJsaDo+Ou//R+4vr5iXH/g5v1P3N9+ZDuOzH6mtRln6qG8m2iXK9x5y2x+JBx27MY982ZH3I/o9YjqWmgcumtpGo1pLGqeyD4w7w6EoskoUnVTUVlRRg/FgLEop1E/E9S1VtE5dSI45SKrGquU3FdK4pKOGSlKSZGkhnz3jWbhNAsrXp+5KKaYaaMo602Ch9Fj9IE/Osur654vrwYWncY3qjbYcr48bGeWNtIjz8HsEw3lk2a/KAn9zYJpiSb8iBj+wtcvLoKLRc9yNaBSJicJawwpg3G4YYnrB1TTkigE75mnkd1uw36zZr9ZCx22bbDLBd2wIM8ec3dP3u0JSeA6SRevjJ9UKHHHbr1mv34gR4+1jr5refXyFeNq5LA/sDo7Q1vNNO2Zpj2Hw5YQZnEvMOIur43G2EKMkpj+9KV1JueZ3fqOcTXQKPHlDCFATmLMq6UbbBrJCANxZLHW0dfUBQUVuit0bUOMnVhBxUzT9uJ4YRTaSCbXarUARK9DpfJbe5zAHKZ2V9YoycNLnvkwAtUIu4iFmiqyd0spfvK+BF6I5KoBLJUZKudufXCPOxSlQVnQjpgNMRlCzOLFlwSGCLnIwRkyMSkOk+IwwX4sTF6000orFImSZuZxg5+2RL+jlFmgPFG1SRFUYEpEqcSic1yeDby4vuRsuaBr2+Oo+okHoEJxdn3F1YvnvHh5TU4Tu3HD+vYdrm1oupZmaemcksRuZ0hOY5IiKsiS7YI14Jxi8pJcHUJCOYEG29ZRciDniCFjLDRtR+MmJs/JlQJj6VqH0oX97oH72w8s0znL8yueP7+mH87xQTNNM+/evWe/m2UXK1jqP4ENQ0ykkJl9xiglyeZoppDZzZGrRYMiE4vcM0rLhDilwiGI4cQcIyEo+fb0MfpKPsdqtIevkFHIsmebZ09RER8iIUVCzmgrCRSl5reBOhGsHolW0qSp+pFYI+xk+/MiqCCVyMF7xlCYx8RLO7NUARUTb282bEtg7xSfdQOrpaNZdKDF+D0WcYgwzqKskZ1X0zAsVzRDz+hHgS21pbEtVsvPk5f3M+8PHMaxJtNIYJJVBldXFK7taFqJRLLGUZSsBw7jXialRuwHrXMnQm8Bog+ocEKRhXmp4OJ8xetXL/ji+QVzjOzGkcNuZJojzgw03YLL5y84XxkO+w0fP3xgnCQRhBiE7FQyaX9ALVfYrsW4Qs6ew37DdDgQxhE9eZSKoBKq7+o5p8TggUDwgZghoyi9hWyEAe+jFAhXL9zPqoXVksdnzKPJCEqJbrp6EGtqwLrihOyA/DdnlPzQACJgj7kQskxxMRcOc8CieNeM9EvHF8biLJL6UUoN8oXDIWCbgNUJHxMh5Tp1Hs9uyTsUYX+dDvnvCIc6o3C2Nj9a6NGHBGPWzMqSbUvRlpgkgmgaR/a7DeN0wIdZfERDw4MPFCcFJlhLMIaglEQcZRlvdSkV+vHcvPkRoxVf/MWfMVw9ozu/5MsvP687x5n73YbduOX27j273QOzP4B6JH6E6DFFYwxolSVapl53pWTKSz7w/t1bzoYelSLBz7z+7HM+/+Jznj1/hmvbmjlnQBtCkeBPlTLbw4i6f0CbdzSNCGqfv3jFsD8wzTNzSGjnMK7h5vaGnDPzLPRs2zq++NXn1dZMdoLWWpqmxTlLzprPXlyzdLBtFN/+4R8Aqt9nS2sMnRZvUqPiJ+dqCF7E90dCRv1nPt0mR589i1I9JTumGXzIhFjwXg7mOUZissRsmKIiTELf3+8tU4YRRbdoxfw8zTxs74iHO9J8gyp7rE3CJi0nR8o6fQb6Dhad4S+//prLi3Our65o2/7UdUuCtDm9L601/+Jf/xv++q//kovzFf/4v/2Ou3c/sn77LS9fveDFy+fQZXpTeP3yGeOHaxqlePjwUO2VEiVmstNkpYlZEVJhmgOQyUrjFAIdkWiU+B0uzhZ8WI+Ukpl84Oz6ii++fsnXv/4cpQ0hKmLYkKPl5cvfslq1NK3hN19/hlKFpnGM4//C7c09u63Y933ibVhgnAJlTmz3scKUEjHzMAV89Cx7RWekEUuzFLFDggOWvVK8225w2jAow8X5eQ0/rp+fkiSIfSxsY8Jaw4hhCoWP72+JuXA3WQ4hk62hX3XYVvwiVbZ1Wn2SRfnke1fUgttI4mjffRoAptWAj5abzQNvPtySpgPflDsuW2h05t/9cc+u9Iz2nl/vAleXZ/zq2TWXq4620Yzznq7rGIaBbuihFElZjwnlA2n0DG1Pe/UCpw0xRXbrHcUYSi7sdwe8n4kx0TetrACyFLExK+7NjqIMfdPSuoYSMyVFdqPHdpphGHBNw2r9hB2aMh9//x2LfsWwHDhLZ/iSeX52xtUwcNn1XF9dstlsOax3xO2B+5t7fvzH7zm/uGC73nB1NTAFRdOesb2d2L2/5Yf/9Ef2d1umEPjh+3/kqjOcrTr0q3NC2nP7fsfH3QfK4cCl8GCFn+EaskkkFQgkksokC6RjRmSGWVGiQqdMNiJQDyURS/rZtSx1lwyNrS4sqfZ+T2/YkgG5N8gZo4QcOYXCbo5spij+w0piqEJ1EmqsY/aZkcSbh0QzWK7WmeV+gmZPmbxYxJWAH3eMhweIHyFGifCyxyKoKlgkQ0SKlSgWJSUm5V8OiP6iIqhA/CatI5PIxlJMoVuu6JYr2sVSyBMoYghstzvWmzXjPBOz7CNCypRpotyvmSePKpkxBjyQrCHFQlTgc6ap9H6tNX4aOWzXPNy+R7WOdrXE2I5SxBg6hJnxsOdh/cA4jaQkTC7pQBIKLY7lNS1APdnFlAI+RJqmYbVc4poGZQ26iHN9yJH7zQPKGIrS3K/vOYwj2922uqtUWzEjVl9nZxc419ANndhPaUVSXpzsKUyHPSEEDgcJBVZKydRXi6A1T/5tG+myUqAojes72n5AIYdqQnzzcqwBxCl+shTMNWusPLkZyif/k0NL0ZGiJWXNOEMIhRBh9mK8PEeqLk7MKJyR3LTJC7suJwh+R/Yb5v1b9puPzIcNOe7JaSInf5o6Zb2U0CrjbOZs2XF51nF1sWK5GCTGxtRrb05x9Rx/orTi5WefcXl9RZhHbt+/5ebND+TtHYdWsdGJ1hZaZ2mtoesaRmeJ1QA8hioPSYqUlLzHWDVFKYtXY8wVASgYoNGaRWe5vlhStOHH9zcMqyUvP/uM3/7FnwEwHmaygXZoMKZQSiTngLGG84sFX/7qFV999RnOGb6b3xIDfFIpEMINSb6XEI8HkwjIyYW7nWfRaJZOk0MR9ETB+fU5S+tYNjO2jXII5nySQ8RU8CFzmAO7KbGeEl0HZykTi8Iqi1Ly93Zdh2karDOSqlGekIehGm7XdqrU3LgatGy0wIhG/4xBUwwhFHbjzP1hZh4941x4mydInh83Aa8U0R1w72/Y7A+Mu5GLs4GudaACwxBZLgrDmAQdz5loy53BPwABAABJREFUHmhbh8oRXXdCVJJdKbqS7hJaWax2whhXkhmqkYQEVTQ5K3xIqBIqkUTen7VyvsQUsFjKJ64NkA6RrOR+aq1l0bZcLRZ0SguTEy3hyLHSFbPItN6/+QmlCvtX16RxQmVL3CfiPpLmJGknMRGmkTB7go8SSVQyzDOkRKbgAbTCGGHrSnsrpEOVcyXD1KkoJ0o1JJerUigxkiq565+8jhD40UWr1L9DiWxEZbGI1UnOuFLhAIEy5V72ccYnIT5WP285k1MiJkVM4KOWgWmaiOMOlQ0qJVoChQDjlpg2eL8WK01naBtDSXKeFFWH2brrTikLolLETu2Xvn7ZJKikCLauIREJVgre8vKa5cUli9UZ2jlKgWn23D88cHt3z2GehBWlFT4npnFkNwc2rhGoJgW8KiRnxeYMxLLIaLSSYNjgJw7bB+4+/ES7WnL2/DnWtvXBTUzTgd1uy/39HYfDXsgfCPSXUqFkYbA5Z6tnpv6kk53nyNBrzi+uaPoO0zjRRenC6Cf2Hz/IBUSx2W+Z55n9Yc80z4QQUAhLtes6mq7DWEvX1yKoqDeCeK/uDwemaWKz2dQ9nTi+H4vgMTZKROMd1lgWQyfMxbanX52hlXia7g4HUghi7JwR1u2TV86ip8nlsTM/sgSzAjniHYqeOWhChP2YiUkiSeZZINA5QYgBChg0wyD7qF2c0LOmZMV0uGfev2dz8w1+vyGFmZK9REAlf9pDyhosYVSmc5mr854Xz864PD+jaboTS09Xy6yfx6EopXj12RdcXF0x7tZ8ePMDH3/4E+d6ZqciKhzQOXBxcc7y+RVt2+Aai/fi4Rmr+0hQoDzM0Yi7UJbuPlGIPkApWA2mgNOKZWd48ewM1TR8//4jy4szXv/qC/78r/8KSma/2fCwW0u4rcrkHEhxAtVxdtZj7Wv+/C++wljN+/e3jCWingSwH+2fSi5CggmxHmCGkMTf9WY94XuLXjYQInMqZK24enVFe35GM9/RpD0x74mlyPuMhTkUgVTHwGZMrKdMMpoxFUJWDG0rTSOeYTlglgsaZ8CIJZt6Apd96joke0GtxLjCuYYYA1qbp2+MUpPQt/uR+9GzP0TuD5Zx45kPO7zWaKsx7cj87gNt4/jw8Y7zs+UpmHq58KyWgUXfSk6ds2wPntZpFo2laxoa11RLAimC0+xJOWGMk3RzbXBanIR0yRK4XY0yvE/krHB11aApuNahjGYOM7a1pyn49HyNNZ0iJuEqtB3XyxUtGuYg7NMMKiR0roChgbdvfmS7W7PbfsZZt+C8XxK3nrgP5FCq3UkiqZlYi6At0uSaeUYXSQAclZLIL6tkH5kzJUdUSpijb9jRNjAmiq7GJMoIgzhGktb/ZGKSgicF5si2zFVCcixk9UBE5YwusissGMkbRNcQZAk1DzlVRrnc5yFFCdaNEFzEB0ENw36LzRoTNV3xaDzl8EDy9/j5nt6CMgbXWHKosplam0p5LIBimQk+/GeK+3/h9cuKYIESxadumjxtt2DoF/yr/+n/wPWLF1w+f0HbtuzHmXdv3/H3f/8NP373LbvxXhBEXdCNE5f6BPvDxDEFuOQMWlGckx1HKdhSKEoxWEvbWNpGk/yOMO/w8wHrBmY/c3t3y4cPb/l4d8Pd7S373VZSDfLRo08iUZyzGNNirWh2jlICpRTnV+ecXZxhWksiEXKg6SxznLlb32OalqI0BUWIM7kEtJGYD2stXdszDAOr1Rmr1RLnHEpHmkY+3ilaSTEIhcVioG1b+r7ncBBHkWmapEgVSdauP0XNHq00h72RhHEyRRtSyYwhMYUgXZxWdF2DsZqnLiQpSdBvOXKGqdIR6zC6IeYVITrm2XCYs0x/QRFiIsaC9wmfNHPUtDbx7MLxb/7mFc+eLSnK8n/9f75l927PdL/l9k//H8btd+y3v0MXi9aOfriAYyCTnKagEq0JDL3mV59f8eLFFRcXK5pugTEWpc0p8cJUoX8un8a9GKuYpz0//OEb9vc35HGP7cBvN6zHA+Nmz/bynDju2W82zNMkDjG+CL06VNs8DWMohKSISdG2FqcVs01VdpApURhvrVX8i7/9M/bZsAnwmz/7LV9+/WvOrq8hBZw1KCeWZH3XY6xFKYWPAath6C3/6l/9JVfXlwRf+N033/E+PLr3KxTWiUtOIqBSkqggL3B2LIq7fUQbx5Xt0HnGqERTFP0ShnM4Mxc0aaBN54Q5MKWZhwS3HrZeMduexWXLwrU0LXRWcT8mVqsV1hrauGV1tWK4PEMNNbOyFEwRf8iC7GOUgpT8idgTta38kGPqyJMiqOR6xZCYx4OwL5Xm+edf4RZnHHZbmHenvVNImTR5fIjsYqZpZrq+o+9mhm6kb2w16dCSh6eURPW4BuvEJ1fXPXKMHqUKQ2u4WA4sh57z1QKrMpaImyfmmNiPI03fs+h7+q4hThPzNFKMFJDoPduHyPbh4fEu1Br7m1+hug5/+5Hy8IABVn2PVlpIMMqilcVoy/JsiVsM/O1nr/nxxx/YrB/4/d/f8uvPfsXq86/44Zv/L/u7j9ze/kCYozhcpUzwB4I/MORAEwOLeWZRNJOyeMKRSkBrtIQrF6Ayh02GUsQk31a/WvHP1Wjb0A8rGCwlBbi/Ox7zYtAeZGWST/s+kVyVJzFbGUVOCVPPRqoTUe8Mn104/vJVw/fvQ9UuKo4RcCEEvKbqIzXzNLFdP+DvP6D8jPINTR5RJXDYrsn+HhVuGZqC0aYGiMvkF0ohFiUqgyiozhil+ZvCI+fhv/X65SkSVZMUc6ZpB9phyerqGYvzS9rFgoJinj33t/fc39+z2W4pyFJbaYW2YgWmFOQkzhypkmDIYiyV6wfsc5Klp9FCJtEy6ZQYRDA/z+z3ex4e7ths1uy3G/wkJro8mXwUlbhVdYsUqvD18X0tl0KRNlZMla2VrD1t5PsNSW62VARWUIqqkRGyQN+19F1D1zohsagCJVUbsFKxdHkwhVouv89aS865GlrXDWbJtfMqqCyuH0qJdstojWs7ShHjX20lNSMFj8lHPd3xjcmUnJKE3qqKZylAa4d1PfPBEoJmmgvzfIQ+NSGILCHUHLqU4PJ64NWLjl9/sUK7lt0Ec7DMsydM92R/iy4b+iYRfGXK5VghUEUhiW5NJfrOsBwaLlZLFn1H17SnrMpHj1OB1ErmRMI4vrQupDizub8hzSMqJ3Sx5JAJ0eP9BlUKbWMJ00xM6bQolwdYC8STCzGLaXRMhbaYeqiaKryXB00imCJX1xdc9ef8y3+V+eqrr7i6usY2DSUqSeqexUi6cQ5jJSMvl0your3VWc/V1Ypnz674/rt3n/i8whO26FHXV+SeV2TZ7xmLbZoaZVVAR2yJGCtWbk3rsAlISjxOM5S+RwWDdYXVwuC6nqbtpUnLER09qbJ1j1122zqUO8JooIutRKZCvSykmiWaFfgCCSE8pPJPjYtzvTdziszzRCgGrMV1A12BqEULmVOS667kzwgpU2Ki+CSs4hKEsVuL4OmvURrrCtYmnE21UCt5RlShmzxzhP0s00PvNL0FathwTpEUAykGSrbVVSlX4+ZSnXEez4/j85W8J7kWXIPpe0wpNStQJjWZjHRN6TL0bcuLVy/5cPOBvC7M44HZT/jo2YwH9tt7DtNeEIuiMMVJDmvylBAoMQhxplSnoMrUzblIjJNpsHZBLEWmOTtTsq5sSUXRQgrLSc4A03Z0y54U50+uV0zy/D8yfuTkOPkP5UJCPH1zKSR1dEIS6Y8mM1jFRW9POHpjjFj2IZZ3IWmJn6La+UXR9lo3o5LC5AnyjEkBWyacilirT6Sc9HgZ6kpK7pl4eqbl+f2lr19UBAuSpD6HSMigu4H2/JL++hnu/BzVL/Ahstls+f5P3/Hx5obtbsvZmdCcbWVoKur2VCm8D8RZGHElZ+yRAFHgEDzZKPqmkQJgFCoEyuyJ48R2uuP2/p5vv/uWjx/fstttmccDJUecVigktDFhyUlm+ungsS4xT08uuoLnz685O1+RwszQdywXPavV4rQ7vH1Y1xT5TNc5nDX0pq2HtaLve6xtaKyGHE5QkTj1J7Fuo+5P6u95+uMp9fqo55OpTfB45yxd14rUA8hZHtqiYTzs2ey2xOiJITyyPRFP0xhjLYIJBWIu3CzoFtfcPszsD4XtLuNjISSYYzoVvjRXOETBX//VZ/z5Vyv+9q/O+I+/2/DT25F3N4b7uwcOm29o7EeWZ4HF8Ir37x84HI5woAVlUDqiVcKZyLOLC64ulrx8dk3XC6VdK/EafFoMj/Bg/hmF22rJQLt79yNpPGByRmNOjka7w5pxL+79q1VPCBG0laWRUmgrSSOSTMApcDYlgzHQNVK8fJKU6uAjfj7w8uVzXvz6z/nbf/N/5uzcsVg6JOVFoV2HdcIG7rueth3QxqHURB5HxmmmGxznl0s+/+IV//AP38rO8+mrUtJLdXvJRd5n21qaxrBYtVxdrLi+uiDtHeM8s9Yjgj4m3HFFoADXQbfAuYHzq8KyaNp+ybLrWbQd83wg7vbMN3f4nJnnCNZgGkvbNbi+kWYsFgzi4nQkEhYKIbeElPApcgh72fsj/rz+qUKrlOozK4YX+82aOWv8s4mmawTBaC3TPAmCU58RrRRKWwqaOSHaDi32iiYXbBb2YCqKUCRh3BgxyD82E8aAKpkSJywPNCpzvXBcrnqeny+4PhsExguBabelBE+pHr7eB9qmQ+VM8rM0Qv6JaUPK7P/wPebVa9zFEvWsQ80jat6RQiBoTSyiJZ28NMRt3/Di9Su6P/0RbiX2aE6ezbSB/YZxd896t2E3ebG163uy30M8kMaROI6EeaSkgMoJQy0eMeCcpNsMzSXbwx1pvxUvVy9Fb0af3H7IAWVb7PKMxYtrbBhR6u9PcheBFCVvkiK62mNiw4mYmQWhiSS0UnRW2KRaFwyRwcL10ABCmFk0DVNI+JSZcsQmhYqCKhyHhjgHovOQDU3coOKeBLTW0zfCEZA80FiDjwshg48ZHyUdxWfwAUIQuPWXvv4ZKRJCUQ2poIyTZIh6Ixal2e9H1us1Hz58oJRM0zZYK56JMRZZTmuFqeJckzU2GfE1rAfdMeLmol+xbB2vVj0XQ8OicxAD827L5vaGH9cTdw8PvH/3hmncEedJ0gMUkqElhCGKrWN6EYrxP0kbLjAdDrRWi8doZXxKarxBVz/QUqAoLYSBWpSP7CStLVppjBboQyuNMY6cKrlc6Wpjxekht9YK263rPllMC9mmOrxkeaBdI1CPslYS4ovFNI7ZTxR1YLvfVmNe/2jJVSAFT/KTdIvRY7Ricf6CkgyHg2K9C6LzmzVzkIlI9vKKmBXRw9lS8/za8WdfdLy6Nuz3e/74ZsvffXdgN82M8y1++pHXlz0XqwtevXzBcvGGu7s1P729EWG6LlBm+lZzsep48fyCi7MVXdfLw2us7H+1TLuys5BkC/1kKjy+jCqU4Nlv7onzSImBEDvCHPHes9se6GLENYaubUTXeFzYFylsR3/BgjnRhGIUwo5ETh3tv1QlqgSJB3OG1199gdIemPE5UZRB2YamG9BK0zbdaZ859APWObq+ZzdOaJUZxz35Z/tbuY8Ap2g6MZJvlGQDLnvLMDiuX5xxteppnWaXIillgeOblr5tsdrIBJ9gKklo6c5iGjGgGLqGRhe0nrEuQlsovWFc78m50F6sUFYTcibOInxPIdNqjVUybYYse0LddPgS2YWZXZgpGlzbCglliBWWP2oJxQxa5Swkt1hY79acLVb0bU+3WKKdQ1sncp7qb3vMwlNapr6YEtmL0b61R+lHwSKG6dRnlErbT0lS1GPSWAxBQdkFtqPnw+2aRavpnOG8b3j9quHcWVzSshNPUKZASYnsZ7SS9PTTsVEK680Onz6w+eEd6mqJz4Hb97e0fUO/6JnJzDnjYyInSLEweY8vRdjwKH56+5Z3799xdXaOmyea1pJ3O0IIBCL+40dm28Bmx3z7UN1yZIgQz2Jhh5qzHrvs0UMLoSes7xgPG2IeZU9Yv+eSZUIu88Th4YG00Ezp0Tu0IM9IKkJ+OSlEM7UYQixaAptTYU6BxmrOBxicwmlhaYYpkHzAKBHTq4qEaSU4h88JnSCWVFkKijhPJNuC6bEqo01kWRROFVoFRR8RgsQcMj4Vplyb2Fzw1XGpaENSScwlfuHrn5EnmCu0pEWsa109TAQ22u92bDdbdruN3JxO2FWp1Hy+In+VOsKjdTok11SHUtBWbMoWi4GzoeXyfMnSQWM0hkL0M/vtho8f7njYbDnstuQ0C65dBFo0+piaIForVV06YlCPTjFPz5+UUUl2P8cfqsKUGuicQ1IdDMrUi3m0map4QY3qFEaYMvXfoklSJ0yhnKBapURnKLCoObHvnoraSxYo+elhoI2BuvhH62q9NpPDTPTzJxB4SZEcg2jewowyph6UijlmxjlXSYSSIpjBRzERFyJPpmkMzy4Vl0vF4Ar7Q+Djvefd7czsR2LYUsIDi6Hh8uKcV68+Y5oioHnz5j2KWD+vTNdYzlcdq+XAYtFjXQ34VWK6rKsVnjo2MKWA1v/0mtU0Ez+PlCJpAinJYTP7SIgJGxM5plNyfC5CLolJ4JJjhFSp9yNa1f0jVRSssEefTES/WopMGquzXvYPIVayj6nidXeCtoVJl0W7VnMY5xiwRmEt1ars0+Ku6zPRtGJj1ihF22i6VjN0lvOzgaFzaCVTfsoidXDW4uoOUh2dmCrzMxtd9ayWxiksMmVqndE6gynEHMkF+q6hKIVPsbKKhSmrnRbLNJUIKRErOuFzxKdAKEkaRCPMa2U/PVKOzkRaQYoBPycO40EKYAu2aU46rxhCZSJ7IYjVg1NcUHLVvEJRovUUq64jclKfx0qbz0W8JWNRleQhlnizj2yzZ60zvTP45UC/9OgmYhth1eaiKCnVZyhViPzJLYhiVoYSErvtXrgEJTLuZ7QztAhEnIqsj3K1CBSynKx5ioLNbsd82GPbnkUprIyhlESOnugVcb8nrjfo3UieA+bJZ6LFZVygcyN/Js5glaM4V8+vygMAStGV9CISkDAeyFvHVOInK4dcQ8iFHCxnVqlu1BmYU2FOhSkW5phoXaFrLI2RuK4UjskX6TEl5hgcUP8hn0s19DuSb4InB49SCVUSGlEJWApGCQRLRcdSllVNLJJ5KHDokSijK//gv0MR3O0PLMaZvl/RdQN9NxBjYppmUIrf/e73/PjDDzw83GOsYrAdihlSrjfk41h93C84Z8CaeuqJ0LZxlovVguvVgs+fX9OpgNUF2zXs48zth7d8/8cfmGNEGQXVTFjE4zJ5ycdR2Q9aypDTthafx8NHKcWL5TlXqzNimOgx2FRoTuVL1x2deET6lKt11KOEw1qHtSK8NWKfgMY+uimga/6VFLaUc43HOfp6PgqQj+JTozXWNQLJVmpVUQJpiE+hBPVO0yzwbg7/ZNepwgGmhhJGFBHjZFq433k+7jZs91IAveexCCZFSNJx9a3n8jLxF19lTHxgd9/xftvy3Xv44WPhsHtLmj5i4ppF9zkX5xe8fv05pWjatuMf/uEfKHg0kYtVw/XVGV98/pLLyzO6tqNpmtNn2NQIHGPEdeSobbRGDvmnE7yfAmWeSXFm6BqMM/g5MHqJTmraVnRlbYcuuh6qinESH1fQp0asDntYEYwKESCD00J0saagbMGTyXhQIznfnuzDGttRdCZrS5gmUopst9vjzSVkn3rdFtbx4vKcv/mrr/jD7//Ex4/dqeADdI3GtY4XVx2ttjRKs8qFxdCwGBqePTvH5MR8GFlvd4SS6Z9f0zZWrAYzGNPQ9Q1xSugskTOtczijMTFUgbO45sQS2B32ZAWmsQxnA2MOrDcz+1kCrp1tKLalUWDxzEXE9OngCQW8Kignga4hS25heOL1qpCCabVi1XeUnJjnkYftA23TYV31021aBtcISSwEQpbdn9Vg1dH39NgcyfNYqNT88jjJHA++nERqlYuiGPHXxBiUG05kq12c2UyRtw9r3u8yl2f3/M2f/4pV37BojEh7cgFjRXP41ATAGtLf/iuytpQ333P33e+J4yRWb6ampZcAVGG6UShrsLahW5wxLM+J93eiGY6R5vwSlwNl3qJEV4GP4P1E9DOLoaOkJc3+nDLek8sxWqugdWR9+w61VShXUOOBst+TP97LWZYKrtSzoSgC4owzHXbc/7BlfKIThONuTXZvx7VMSlL8QirsvFixiSdoYUiF8w48haQKh0PkMCdSqmL2Uhh9IFanIag1ioJVBlWEyVmmA8qok944lYwhc0y9iJq651MkrIRnk2XfqaRQ1hBYQBKJfunrF3/lerOj63dYN1QWn6sp4zM5J/70x2+5vflISgnntKQTI/lcZI3WYq6dC0KjtmK8WmqunTVH5pdMg1opWViriDHQNo6DL/h5hpr83rYNvkjkjqoTZ4mpLvDrtFYLrCqiV3lMWgAKLItmkRWHkJk2ktiQYkJZTTGKVGGdVApZaSly9Xs12qBKRhf5qmKo/z6ubzNFHYkOiWPoaK5pDo8m1+W0S1RAVIpQWUSqCp61NthGYqAUMrk6Y1kMK3KOxNmDeji1W9mPZN9QUsBaOfh3Y2SzD6y3isNYCEHhg2GOYlUUs3gFouB8YRha6Rx/fLdlP+353Q+e736EzXpm3n6AaY0uM13bYoyYk0PNBbQykTureXZ9zuX5iuWiFyaftacC+DT3UGBrIYWYOgE/NS6mQI4RnTONtXSloEJktx9lb1OkCTLGnJiCVPp0Fkwbe3o4pMPVyD5DHWEbJPnaKINSUVKwlcXvR/b3D2zuPmJdjzYt2hixijMG2y5QMdQ9ijodyJKJmGTaSYG+M5yf95yfDydClAKG1rJsDX25pDMWlQrhdkPTWJrK/s1zZPIBpSX1fLEccE52xTEk0bhah3Eic0lJMv4UIvfQleAQ6k4ll4JpLK512NagQqUPtY0c/s4RnKMYIcBMWaDhMcxgNMo8ZuHpatj8qS4VfPA4bVguF7TOoRkZxwPjNNJ2A8Y1cq2rE4w2YmRtihRVZ/TJEksZA8qc9qm5QnzyqB8jq47Qnzx3xFyNEgy+FGkslUbpFpyDrNgGiJuR33/3piYgdFwsuvqMV8RKf9o8X728wBlL8A+EHzRRKy7PzhjOO/pViw+BUBMwKjCMNUo8N41o3ZxrWZ47rl5+jvUT826DcR3G+JODVkgZteiED2HUKRHGZo3DYXVLb3r8uGe6e6BMI8p7dKxrcDmFT1ckKJFuJVXISXSST69XjOkkbKfuAEVvepy6yolxblAYNDqLxCoWGH1mCgUfZMozWtFbcTYKCUJWnLeOs9YyOPl8hYwUScGT8xZVjT8iUYhvuZ7HKLBOQri1rI9UqlmkSqFzkbWW1rij4v8X8GN+ITFGMPC237E6vz4dzPv9gWkS8fh3f/oTh/1edgBO112YTEUy+R2JHRmltUxNWlG0iNubpsVqLZq4KlRNMRCJWBSNsygfiN6jlcJVxlX2E+LBIQU15yJM1DoW5zpv6zpp5Z+xDbsEXSiMc2S/n0hk5hgEYtAQEINptMY4mVhc04qJrNGCX5PIqpANaLI8mAhcIe7tsbI6xaYrp/BpwsOTxIejvdnJzqgonJNpU2VJR1dKicrPWJbLc4EH7VyZmPL+sh/JoRHIzrZQNLtDZLuLbHaaac41SzEzRUMsRroqJE3hrDe0RqQS396s+XgX+Ld//8CH7ZLNoeB3HzHzGounaWS3Jw2RUOmtlU6+awzPrs45Wy0ZasiwNeaTAmjqwXc0H1BKNKJG60/MDaAWwZJpjKGpRKuU9sL0K0iTUv/siqDIPifL4eWs4xQqeiwQ1Q5K1cNUYCctsJs2WGWYtnu2t3c8fHjH8uwZ/aLStZUGo3DNgNaBFKZK7lHEFEkxMU8TSgtLuWsVF+c9l5fLxzelYGgdF6sG1TlaY8lz5ON6WxmbjRhDlCJF0Dhs41gsBkqF02OMkr6iNcYqsd6qbGNVqIkBIiuQJqzIFFyLoHFGSFwFlHUoY8nO4q0jKkgBphzxUbEbPa5p6DqZmo/FJwnl+5Pr5X3AdobFcknnHEZpxnFinCa6aaLrZCI+psKciGJRDDWs0aecuMe1gK5RZsJJOO6cjp4m1ZOoNsAC96U6Gerjztc2wjpXltGPTF5MN56dL9hdLDGfv6JvDZ0RicHTIqi14urZSky3dyuiNQSlcUNPMwy4vmGq0HypTFpUEe/NShQsKeGalrZtOX/2GYx7pvdv0Y2EHIfgiTnhU4KmozQTyYpUhZwxxdAoh9MNnR3Y7naMNw+kaUaXjFPH1RPorDiaAKDyKSy4JFPPqtNBL4SnUE9ULS2U6CkhZXUyYD/yHYzSGJSQ6bLoUucgJhulKJzRXLSarS9MKjNnzUXX8GLRMjQGo8X9KEZB25KPKGtQWsm6Iydpemu9UMZiG0VJkEJlpaZM1gYdkxDLtJIi+Atfv1gnuNkdcN2W1dmWaRRX9/fv3vHmzU98//13fP/d9+ScaZsW6xTGKrrOnHwO3VNMNwiJuHEWox1GaymC1tBYy+ryimXnRLQ77YjIDSUFzvD1b36DT4lx3PPh/Rv2ux1aO8HF605AaY0yTmjWNUS2bVu69snbKplv/vEfGJzh4bDnkDxRgVsOAn8Yja2u9MvViuXZQNNajPZktLDTlKm+fI6SG6J15NKTiuzWYpzF0idmUjzu+1IVtz75UcSU9zgN+TlUa7hJYl2srXooS+OEw74cliy/lsil8XDgD3/3zWnSzbHuSk3DZu+ZM6zThn0yTGng6qIjJsV+VMS9JmeD1q3sEFRhd8j843cTv//2wDfffMP9/ZYPNxNu8RJjW8ruLY61UNPbDtd2p+iptnWcn69Y9o6zoeP51RV939O3Hc65kyvM0S5O4qlKFTfr04Go9afGBoXC+u6GnhlXoMyJNCXClCoRSdIuQsz4GCRdfhZqu2sajJEU+JwjlMTRgcnUv0KduvZaEAvoVFCh8If/8Hf8+O2f+OPvfsfXf/aXfPHVb3j11V+j2wXKDbhuiS0JYiM7wZIxpcHYBts0BH9Am8hKN/zt3/6WprH83/7v4tihUDw7H3h23pJDwGSIThEul3SLBc3Q40thypkxg+0GXNdibF8jnqR58MEQKEw5EXJG6QafoOSMRmMKmKzomgHdK1gFog9o7WjaDqctxiRSMMwhMY0HiY7KYu4dw0zJiaYxrNoW1wzkMJJKRGlNDIEwhdOOqZTC5nCoBhItzy4u2U+JN/cT436kcXv6rkUVYRE2zSBhv1aT6udoqqBbpyq3UjV53hgwkKqelNN1kz16MbI6SLHu0VEiL8jyeVtr6qpEUbqOkhtGP/HD2vPj+obv7keenfX85tUZz84HfHwC8yp4fSXh10yX/Puh4d3H93z7v/w/ePnFF1y+eM6vv/wSpx3nr1/TfPgJnGEzT2KyMQfRqzqLVi3THFAJGM4wTY+xe6YwcfCBcphYRUWxA+7iJU0YUXZPnD2xMdWgoaHBMWDxlQVtGosdDNpAHCdySKRYEavaLyhl0fHTyX3ymdYgq5d8vLdqwDYaU6roXiu6tqFvDP0gVmglZpxzxCmx8xFrFVfDwL/+7Irff9xwf5hhP/Obl5d8/eyM7ZQJMXB/CNwdvBhAFDDOVHKaqsHohaIL2iq0s2IWnmV1ERGnJx81pRKyxD7tdEv8N1+/XCeYywnK7HoRiN/fr9lutnz8+JH9bkcuBT8HjBUGpZ8dqhJgrK3fVSmif1LgjaFtXF3sS+U2xqKMRRkHRlG0jOwpZ7QRK6zV5TMO3gsNGF11KkLpLZSTLOKYvyaFN2K0FWjqyetht2Y0mr2fhVUHqJLAWmHptZ0wYpVMtK235CgFurEaWku2RhbppWBzRhlDxkjkR37C+KyT6iMLNH/68xhPxSDMgRhj9f9MxGiEDh0cqWno+0F2ka6pB/in3FelxMEh+MB+yowhcnu44ZATMx6rz0nZCjt0NoRkKFoMt0tJfAx7UhyZpx0f3t2w3+0JYwLdUFyLCiNFRzDQVMcOKhnIGMNi6FgNLWfLnq5taZw9TYBHPeAREj3SsxXy8Jn664+P5vGnhc3DA9kEiBK/lUKozUUlRxwbXqVOn60+stS0wLsy/cmutiCT4CPxoTINBQiSoho8282GcR6JaWbRNrQGzi+uaVfXWOsehcXaCBRexL/EYCg4SnFC8lGKq6tznj2//GR5b5WQcYqR+0wbuY+UNhRtydXgXNkG2QAYQn3wMxCSRDUdCQwUjS6GVNdBWgnBrDEGq+tEZK1IlOqaIhWxN0g5VxlJrhO2zBHaaDBIyonT4iJSm7YUpVCGn02CsRJtlNYsh57l0MPtnhgCfp6FDFPh6xN0WwlTpe6AZKVwjPzidP/InrDU6yXPuRCsFCCfh1aPuZWq7uzVE4IaxghhRGtpYmMgxML99kBOgU5Livl6O35yL6os5vZ932MbR8qRt29/ZEqBh92OxrVcna+4PF8ynJ8LWaemoqgK0wvlP1GCyB7E4JgTkScCXitCKyuEBlCbt5Q0kYpCWyE/5ZqUrLU8U0UrsrPQWMnMHSceHw0hm2ln5HPLP79esvvTBY6BzKUK5UUij5DZas6gs49kNqkPAl/HItDvonFcLTsW65GDTzQ20JwIXXU9pCMxZmadSIi3ty0FraykzqhCqkbux2sn4KhQEnP9LHNlfYvk6xdWQP4ZRbCg0NrQdj1X19c8f/6C29sHNtst79+947A/yEGU9Yn96ZyE8Or6QVUJjzDJlLyR1XJB33XMk6cfetCGpLQEURphZUqETMa6ntViydUXX7Le7bhfP2CddNtaWVJJsh9LSboCU9DGkbNiHD0pFeZpPpERCnCze6AxWjK6gKwUYS+Qk7aWNlVTaV8Yp4mmMQyDJAi0jWXZdzSNpWtkGexckbBhLYysFIto2I7TYM7EGE8HdIzh9P9DCKeuO6VYiTTiOXhkolrraJuWs7MLhmGgbbrTDuTpoapsQyqah+2O3ZjYT4UfP2w5lBtmloy7l6A6YmoZk3xtSsj3kwIfw455llQO1h8geTrjyP6WGA02jQLzZlXlHj1KSTNjteHyfMH5YuB8OdB37YmleGRQHgug1rpOr+XkAKKNwehjcsGn1PSP797gXSH7QJ5mwuQJPpBKNVuoUIoyWpJIqp/lEV2ONQ5JYLZc65YWx/16oOdTIfQQFYepgJ9Aweb+HTrsCbuPXF9dcvHKczZ0KNNKMVHIIVQPcGUMVim06kk5omPgxYuB3WH+RDAvARdaiqkpYApZG5IyonfVHcppbJfwe09OBjPW50MpppBrhy4FXgMGi69eiqPKnA0Ntm0QhqjstlGJhGaOmTkl5hRFI5kKJSlcpWFmpTHKYnRh6CzCLwsUJburwyz38PyJQKvUe1vu38vzJdtxRn3/njBPjAfLNC0lob5ta8akSIhUFcTnVMS0trZ4Rxbs4+dWTsXwGBZttH7yde60bz5Kbx7TL6RBF+akeAArbynKs94+sN9t2d1/YH94ye4wns4NSmGeAv2gWCwWdE1HSZnvvv9Hfnr/jn5xTkbz26+/4vx8xdXLV3JfWJGCGGPQRRjGiQk9j2gtxA5hTBYyBm8ttBa/WmK1Y1hdws0fSXFPMhrTGrJVpBLJKgsPUCuyMUTncK0DVSrTVRi/wmZ2uL5D5fHE3DweiKK7E6MPAdaqe0xJwBN+grW0zuCMqrmf4siklOzJA5rOWZad43LRMrSWzmv6IKYUOYO2hoaCrec7PhKAtoArRbIqlQZtiEpX1q6gBkceTK5s/hTF4GMOhYPPHMKnxf2/9vrFRbDRitZZlsPA2eqMYbFgs92w3W05jKMUnjqN5JRJSXLoUJPg0KXuiupDK0e6Yr8POCti5uVqwcXVJV9+9hmLXmNcR9YHEYiXgm0b2tWK5WrJGEONXsqkkupeosDJ5Fe6W3G7EHalj4nJe552dF5rMEY6KhQJ2a8UoZjhY6o6QFnIay1aJVe7oL611Ve1hnk2Dd2wwtgGtGH0ElMzhSA3fU6VLBFrB51ObNEUJVKqlGMa+LFjlRvPuUZSBDph5Tau5fxMop1iSI/QYYGHzR6FIsXM9fmSy5VmHu/5/uYt67uZ/c0PFNWQSoekdBkotasqyK4tz+Q0cqZ3aB2JWjOqSMaA9qTimf3Mw/qOpmm4PB9qzEimby1D37IYhhoNVa2uarfq3OPhJIeXqhCI7IPlPoqfaOpKESmObQphntBFfAmdUxjEDUaRMVYzLBewFyNdRayTn4IaE2OMImk5VK0xqCh6o0iquweFch2u71heXbBYXKKAzd1PHA4zb3/6iW/+07/j5W7Hr2yLPXtB1o7JB0K1tMvl6Dgj45nWCtdYQoQUFU971Tg3xNCd9ms5efbzPdFoolHYaCXGKlg2m50YEPQJtEBcPnkxidYK5ywFRQqZMQXmFJljIhlFcYaoZDyMzmKWFm01SYPrFAtl6C7aCisXUrWfUijazmKMIsSREGa8nxm6BU2jUDZSSsb7Srmtz6DVyO68sbx+dkXKcN5/R8iB6bBnnmecc1Wk7k8uSkZX4hmPxevYQBljTkVNMjIf4Vfgk699+nuODdex2SyU0z13vBePD1BZLCF5fJz47sOazXZzgspTKvy7//QD51cTOSVu7tfs5wndt6ALIR344x//AZ1nBqt48/EtRStWlxdcnp9x1rbc/v4byfczBjUdSIgPctZAaynBUawl17MJI4CkmifU/oBOM9qPcu3iDfmwgblqG0smJcd4yOgSSeMkpUxpgQ+rDMs4jXtic1eAmDUhycRlkrjuuNqYaiXo1nESPE7Z05yFY5AKrTvySqtfCApjDa5xNE2DmzOpaKZYaJxcY+saSin4lJmFvUhO4EKU66M0MWRpjFEy+RZpkGKMzD4y+cIYMrspczeOrMdHW8L/1usXF8G+a1h0zYnYQIH1ZsM4TqSShfFZ332ssF9RClSCowtGUtKxnEqgIsaCNr5SzTWu79mPM4u2xTeNLPXRFK0x1uLaFuscutpb5doJWmtIRYvDfM4neKSiJU+0YOWTw6cZFrSNI2uBH3IpEEItBnJ4Cck0E2KdtgJVS6aYZy2sVmtpmhnrGtpDRNsGpY3kYMUoxq514otJ/l1yXdjXvWA+udMKBo6q0IN+8pAXAFX/HCE+SHf26aUMMVatn+Ns0YMynC/WuI8j4XDPxIGCJauWgkCZp2WBKCSFzEPAETBK6N4iG7GAkH1SiqzXD3Rtz3K4ZJ5Ggp9oG0fbuCcF8HgoqUfiys9ex/+uKrZ/Igk9uWIhRiIyTbdavCldYyoco+q9qLDO0bQtKWbpaEvNMURxVJ4cXTSskQBbWfZbTGNoGku77BlWK65evmC5fE5Jhd3+wBR2+PXI+/cfMP0FZy/WtCxJynG/PTBPo7ik5FwbQiE6WWtZLFtShIf17tPrFRQhPH4uMWnmCCSBukMSzkkqitlHqE2dMgq02Fcdd2bZSHEIORJKIhRx6jjEgAsBpUXTVbRCN0L/l1Bi+Sxcq0m5YIL4M5IlcqxrLMZq9nkkVsaztQZdNE0W5qK19ji0yQFjLY2TaKjF0LIaWhatZTtnfPSnhvAYg3OEsbWSz+EpYnCc7o4Q+rF5enr/HJ+T8rPCePx9INKbWKHwo4n98YcxMuUka2Uqy4mD9+ymR0emXAq3d3t8aokpcpg9EZFxqSJI2OGwY7154PbmIx8/fCBTOIwHvvj8c5wWGNtYi2laSFEQrBDq410LiarQqCpVESjBvSUKFVOXiEqByJ40zZIfCuLxqY5koEzWCGxuFAlFqiz5EyT85JWq5k4XWcsc4WVDXWMcP4QjC5pSNeSlcqKOZ7v4yeacK+NceBqPNpFCXjGAKQJJZ8RQLAkQQspU2V+p64660lC62rZVK8/69/sokpPRB+YQf+lK8BdGKSnFV5+/5PVnL+kbyzxP3N/f8bvf/46b+1uMc5z1AyUV5sPEZpoIMaKbBue0ZKO5Vox0p0DVtwIaH6NcXp3BNTSHme/fvGe/3RHOVzwbLKu+wXQLbL/Atb1EG1H3DSWhtOLy+lKs3bzHb7ccbcdilEW9duIkY6M7PaNKKX7zV3/LcrlgCjM+BmJOzH6W3VhO5CNduBRx5y8itK4xjqJRFHAdXyI+ZsaDOIkUHu2/SuEkBxErs8clvjKP+XlK10JhkYlEVzcaY2kakRgccwu9D2w2O7qu/ye7Tq01i0XPy+fXnC0HKIXxcODt+1tM3BHLg3S2Gkqu+ySQiVAZ0C9QNGgsDo9RkaSyxM+QSSpUxmvmm2++4eHuHlLh/uY9Ocy8fHHOaiH7wCNbUlXt3FHCcDz8jt/vUx9VaRLEd/PpK6dMVELSWC0HrHEoIw9iSoX9GE976KvrK6Zh5OHmnuCrHZyWHZPSGddUqQaSEZm0ou8HlufnrC4v+fy3v+Xi+Utef/VnGHPOdn3gx1vN7ds/sL1/S7APbMJHvHuDO4eDL3zzj9/x8HDP/nAQE/OUiUFMybuu4fnLC7TSPNzfn957KbDZzzX1oiGlxDhNrINnUToR3vsJFXPN8UwUEl0ItE4kEUppiikUUxjxzDnw4A9ErYlWEYvhYZ7Zec+zRYtTEqblKgEhJ9HuKg0lzMQUxdpwjKiisKYFkylZk8KMptA2DmukaSpofAgc50B5vuB8ueRiuURby+4wc9ZZnp8PhPs98xhkN1jjdIQgJde7tIoGyU+Uz+jTovfoxXs0mXicDI9/xtOvfXqWWWvhaMxeVwnqyFi2YmnmvUcZOc61adDtcSUhv2faR0Lccr++Yy4RMziW11foojGI89V+3vOP3/+Rt2/fMs8zKSXef/VrFsPAevacX55xef0CgOg9837CRIXKmjwHVDW7iH5i1hEVIj5nYtYUL/pqlTz7eSbkmUDEdA2qsdjOknRNAnl+TlISqjxHeQ5ikISZpy4AhcIcEq1NWJvZT9KUUKOoxP+rSEBBzkgoVd3B5SzcjVoADZkYApMP7KbAWF1elJZpcdlZWiu64DkWbEUbTAXyM5qijDC4izw/keoAVCf3FBJzTMwx47PYPh6mif04MfpPPVH/a69fPAmuzs64uLzg4vIcYxQxBlkcNw5zccbQ1CiT5UDfNczekwDjNNbp06/t1IF5juLMkI8KoCI05FSYR8+Hj7fEcWJhNM+vXrO4uuTq9Qt0v0R1SxnrU2KcRkKQndo4T2LtFgR+TEUmUW2qjknr4xzwyQOxOr/g/OKckMJpiX8ko+SUqrGuuFU82vzIA350szh2VFpXbZ+2HMukDzLhxSSWQicN05NdxmlxX6ne6gjHKYU6JttraSSscbIHNXKA5yJpEemJSBkFz64veXZ9yWJoUVrWKu2wYHl+zsXVJXf7HSEFUpxJ1TWkZI5sAYzdoFSHpiNVaItiUaWgCRQ8OSUoivXdPdl7iIGL1ZLV0LFayIR9jIZ66pX6FM4qp46yPoj1c8lZRvBP4pSUol8u6U0kNY52aGmsRutM8JEQEnOoXrPGcv3iOdF7Pr67Ybc5ME8BbY4u+Altq/uRblh0C5au4/rLX/H81ec8f/0Fq1efg+2YVcsP3z/w/t09v/tx4vBgCIcF5aawSRtu5m/J9p4xZN6+u+FwODB7f5ruc5K9mbbw07sPqAKHw+5EN4fCNk00weAIcggTmF1Gq0DOI2nKWMRxJjjZv9yPewbb02hL1jVPMmVxMImJQwhEJF3Ap1wPGcXUaJLKmBRIJUleXpI9rFi8Z0ooZF9dY4ogOilFCpoSJRnAGndaPmiFsAX7p/Rr8H5mv98RUyT6RGMUL59dspkz+3kv3XwUyztjzBPpELVJUJ9Mdk+nweP9crxHjnDnsbn4+f7wk6lQqYpU1XVJKadiqpAJNingJPJ+ojtTisVgKDpTwg4LNKah61cnbZ6zUMhsD1vRYmpI08z724/oO8V+mlhqTTsshMiTCzFEXLtEa0ebLHQDGE2IHl0LclyekVGY0gghCpjiJE5PRdMPPcpZdNPgw3SChqVtUgQKsWTmEsR5JX9q4ReLrAVKAp/l8/Op0OQsbkWVaGZ1QWtBokKNIctIISqlYLWmb4XhvZ0jU5SCfDk0rHrH0NkqvRArTq3NyV+rsYIcaE3dm+tTlFMq4udb6qgcMvLeiqzFUj4Kn/7/LZEAur5jsViwXC0xRsvOjEzbWIbO0BqLURqrDNbUsMQQxCfUaoahx82uMvlGIul0w4HAfqRCmAPrhw26ZA7XF+huwXD5jLPnn5GNIyhLLAKLee9P8OI0zzWwUX6I1E5BJQkoJc7nx3H9+OoXS1ZnF6dCIkzMQM4iaI8hkFOFbIoYUovmp042+lMo5Vi4pMkqzCHXmI98Es/myiQ95mAVHgWoAmnBY6rCo2jcGidLaSNBvHIQVPj0cbxGoTg/X3F+thS6eRaxeNN2LFZLLi7P2aVC9hMhJ0oW31FhFQp7SSOYelaKWENxS1FQUnWwFx2XKuK/WuIMeeZi8WcM3RlD150m23+6m/kvFMHjr3HcKH0KaChgsVzRm8DYOmznaJxGq4jRYiXlrOwWtbFcXF2RU+bs4kIo/imi0DX3DEwrRAVne1x/Rrc859d//he8+vI3vPz8NzCcsRkDN+/W/OGHe3744QPff5jJk4E4kB8yD9OBd5u3zPmOORQ2m4N4jdZrTG22U6nHkJ4pORP8+AjZAfs400SDVWLTFYh4U1AqkJIi5khjLJ11eCOdd5wmSmeIFrIWM4aMhMmmnE6kGCH8SI2MgE+VMJEjusKdBtlaKKWwWX5eUiWmyJ0gRV1wqHof2vokFZSSPW9bDR2O78sHzzjCNE4U43BGcX15xpu7HXYjn0Gqezpj7KmIlYJE9ehjruTPCDE/K4YgrNKfh8R+WgjrXaU4NZyno6CIk8zxlrPVojCneDL9f3ofdp0RB5M0Vc2uo+tX0m2WjLWJ6APTPGOcFXZyjDxsNsQgaRDi1tPIxFeEEKfbAdMO9KYjDWKBlnIiqkRQjtgvyNrQtCty8MQqA0oVdmyXrSBL1pLLTCwiak+V7yAQYsFXE4/Ek89L1vliLUh1jtFHZUCpJumi46W6DxUqoQwpRqGevUZp2kbOq4OXbFIUnPUti87ROsuU5IaUe/TUj0g8ljXoo+dyqQ1OEcs1H4W1rZTlGJ2Yc5aBgCJwxn+PIrjerNnut7z+3NJ3DU3bcn11Jh6OOZC9eCMOjaNtz0U4mUJ9IDO27gWsswxDV1MOMn6aCV4osiWKLdSzi3POL6558cWvuP78Ky5ev2Z48Tnb/YH9bsc4bdjt91DKafq632zxIRBjwjbVcgwtUUqqVNcE9UgeOX4A1mGbBlOsOM7kTHLu9PPYyIGWYpB8vgrRyUMkzMKj/6UUwaPjeXXkMOL6YFLGVp3g0Tqt5Iw+FsTTd1c1jrhqxn10V3kUlkuyRI9zsmxumoacP40r75zBWSWGs/XztQZevzjHugbXXrMdE5tRCvTxoDxSov00EvLMHEd2ZcSQKVEOc01Cq0jrCn0DV5fPOTtb8vrVC754+YrVYkFjbU0d4LQDfJwCwXv/hIjw+DpCXnUrWPtLeSmt+fp/+Gs6NbPbvCWYiFaZ87MerxUzmdg3DEOLXfQsXn+Ja1q+Dgr3+2+w794yjzNFW5RrOXv9km51xtnFS55//jWryxc8++xrQrZsPPyH//fv+e6Hd/z7/+33fPiw47D3zIeIoUUby+0cULOCzQhGfHULmqKcJFdkESarAhYLZEqx5Eo1P74K8NHPTJPChHAS9B+0YZwj2gspwCjxHD3oQrYKRWCeRmwK+OQJKRJSENYnQI44XXBac7YcxMUkRDSFvnNcLpeSVakMuu2rVVhk0TmcMVAMOYLSinY5nIr60K1OXq9aU6N6xGTBPDU8L4XNZost4o6z6Hv6XjIr399s2O1nppxJMTArXQ9YBSWLdMo5UvY0TVtt9uR7Ei9M6faP+8FTQHWFSE+b/5JPjZhSP2usTpOhfvJL0i1oBVZrsE4m6J/tsGVfJ/dnzhltGq5efsl2e8c0bvHjnuQj0QdCGE/P/dFkIxz2BD+zP+xwaWI3bdn6PRevv+bs4oqvr1+zPTxwmHaCBhmLMw5vFcW0XHz9G27e/cj67iPv7285eoTuU8E5S9M0IjPQWlY2SqYqYzRNY1DaopUh+Mhm87ifjkUxR5HKCAtU0zZGwgOsFrhTUclr6XReUT+PMReyMljXsWwHWmcJGIamZaDw6qxn2TYYA6aIi07nLNFL8RSyTMJqVVHCSobh2J/I9xDrvRiirBsEzRL0LwGftkL/9dc/QyIhHYC1Qhro2oaz1YKdSsxjQDsjAYsnezAwVqOLGKXqysKSzD4tuqKUmJzBz55pDJXpKb+eUj459CvXorQjxMxud+Aw7gg+sFwu2S4W5JIZZ08+8kaO2sCS0EXXA0fIOz8/drWRG6wUOXyLzpCoD5e4D2gte0eTJJX5SNtXPN3jPbLMtKranZLRWTzwbAXhcs6omp2WdT5NRXCE/qSoHuUGsg80n4jLnXO0bVt1gu6UyP70ZC3U4MmUThZZioTVmdYmOhvwJtMYKtxbXSSy/F6DJ5UZw0hhos6JWJPRGvrOsBoazpYd19cXrJZLnl9dy8Tvqibu9MA8urgchd05P70StVqWYxcnn0WpxgKnr1KK88vnLFt4+eVvcWnEZo+bd4S5UHTANh2uG7D9At0vaIYlz774FfM0op1lu95h24F2ec7Vl1/QL89Znr9guHiJa5fc7SJ392s+3m75T3//Le8/3HLz8Z7xIKkK0gUfobjjjqRyto8+l/U+zJ++Q+qGqf7KpwnsU8xoL7mLVfqJzzVDrShKRUAoENCgZVpJCnKR3chxGlCq0pu0OHY0VhITtCpYDX3n6DtpFlSu37POkjupClrIiAJ5OiG6ZPUIJ7bWnb7xlJOQ1ow93nU/e8A0ut63WgljuzGaRedYDS1+zpLZZxLJV2Z0CuTckLKj8xLJgyqiRUV2WqCqF+qnHf+xEMrOKtd7sE4vT3Z6p7uvPP6+J8BpnUrkHi78HJMQF6JSamE5Sga6nmlq8LMVToCWJviYQFFKvTgV8g0hMM+eaESCgtE8rO8JMWBNS0oBnUD+oQTy1gJqY6oeEOoEKywScdWxAnxrQdqKyifSic5KvEwr0lSK+uR9HVmkKNH5Ne7xhzWSsKGeoDjUBsHU6dGHKKkOSWwdrRWp2WroBDK3QpSjKErVcwNYK65Nxug6cYoOU8h61ZS+qMdGk3KaXFNF/VR1G1Pqn5GjxD+jCB6rv7WGtrH0fcPV5Tk5TczTlqZzqFyIITB7IaPYrsU60fzIHyI3Vj90lTWXGFvHNM0Yc2CcAuMkobnTPBNSJisDtgE04zRz/7Bmv98Q/Mz11RWH/Y4CHPy9TFBFtmup6u0ed4EF557SoOUlKQ3yAKsshe9oVJ2z4AHZZHQ+CuIfHV7kczkWQP0JAURliY/RRmjGph6SORe0FiugnzMfj2JeXWHQ/1wRtFa6vLZtT9OV/LdPO9WUMyELo/UUXlwiungsE63e0+nEpOS/xyyHuQy6BZ122DxSygFUAKQ7biy0znB9ueDZ1QUvnl1yeXVN3/esFiusMadU+OMhctQWaW2qBjLxyWWoK8fTjUbtAnMWg/THT4irZ695dr4gjRNq3pGnLdv33zKOkbT32N7RDCvaxTm6P8OdXfBqOEdpzXBxzsf3twxnV1y++IyXX31NtzinW1wyRcd+jPzx777l2z/9xB+//ZHf/+5PHPYz0xTRqkUpLabaBaBappVy0iBSHtnHpf7v6RuVvqhu5p5OH8AYMtlLw+IS9R406FKF/qoRUlZMJCTSq+lc7ZCPxtXijemMxigps4MzNM7QNRZnFalolouO5dCyWLTkKCxWn4P02EXoDloVjFG49ti+HXf44BpbNayRGCLKaFzbVFnIk+ulwDiHbVrayvQmJRoFZ13L5XLBw7gnEolR0i9SjkQ/klJLSg1dJw4/ubJ+DccDGHEosu4TJuhT9qgcOJ/eaAX+yRlwxOKeFkJzbILVUZT/6W+JIdUJs7LWc6ZTcLBtJWs16CJiblBPSFAVOkyR4APzOBGXPUVbjHO8e/sjqij8fuZsWLLoOrJV0AjL3mjZZZYsdpNHCFEjZguNazHOoqk7NWSdkZHdptLCtre6PmXp6X1YGQ4VcWgbQ99oukbTVp/P2Qu4egz0VbVwuSJG1tFHppgZfcKZ5hQyfd33WAW21DT6AjlK860Upx2gsYZUCj4lrK0JPihJ9CiCwQmul0+rhihwkzDFrcboGaV+dsH+K69fXAS11YQcePfhDRdXZ1xeXPL61TNiGtkeHsjVoBqrccpRz9STrk5CF2Ui8N6TtVyQbmExDSgLbvSYveaw3/HuXeLf//t/z4sXz1mulrx8/pwUAvNhz2G3xlnDyxcvSDnSLwZ8hv3hIP6V8dFMmfJ4xh4bpk/eV42FopR68BRxEilZLHtO05+rmiShvR97Sa0eUwm00qeHCC2wilMZnQumXrBScu0i889IIY/ygJNptjJP4NBPDaePtmK2xuh8YjSNECFiKohzhuTP7ceRmER78/y6o+8ntB3R5cDsA94/HuC2meVGU2B0Wx8Ky/lyyXIx8KsvPmM59CwWPW3bnYozTw+kE9FHOIMpZUKIJ+3cUzYopU5JGVlI4clpIsXHiCiloG3PuHr2Gcv+DJ08cd7x/vuX3L9/y+b+jsYtWVxecf35FwznL3HDAqUUz752rF5+wfM/DzTDGf3qGmMGQij89H7iT999z7t3d/zb//U/cXu75u5+yzQFclZo5eoi/qhJqx328WSsh3IBftZYyzf9ZPf9n3s0FUIqaZqGIPb7chBV/aNRYjxRCpKKoFxNYdGnDrpziWFoWS17eqtEUEzB1aZEqyPxI7NcNDSuEj00QIZUvUeVw+DIumBdxinROxoNTd/KvqbXUDQ5a5QXFxTtNNqI5dXTd9Z1HV3XYY3hsN2RU2axWPDsuhB0w/c3ElodU2KuMgk/j+Tk8d7VxvuAtQ2Xl4nGtTRNh1KCprRN+YRsdSLJGMVRBP/0h1ySn1+kx9fTAvlzYs3Tr/HTiHMtrW3onCTIWGdJixUmF/YxUqywO703p4Y8VYMMbU2FZxUvvvgN+8OOB++5efeOw3bLvB9ZtAN90+K6DtdauoXDTyNow4cff2L7cMthv6uuWAqS4rATd5iUMn0rBB3dFomV0/W+qOcVFEz4FJiPdffXKGitFL+uURzDd4SvdnSJEd+W44CrKMw+MM6RnY/SwyZFDoG+b8QGM8kZmf9/7P1Xj2xZmqaJPUtsZcrlEXFCpazKLNXT3YUadg9AEsRcce4avCb4B/gzeDe/gAAxAMHrJi8JAgQFpokBpzkzXdXVlZUyMiLOiaNcmNpqKV58a5uZe0RkRvawLwasDfhxP+bmZraX+tT7vW/MfNLRkwjMa6FKi0cSX3ovgQRRMokqZxKSMiSlcWFkiJEhJIielBSVNcyrknlZHnBMv+/67unQJOilzWbDzfv3ovAbhApN6czOMaUdckR2HFoOeBTxXFIurGYjaaWNIsYio8J6vHfc3t5wd3fLer0WLzsKNH6zXksfV1VIrxzknq/sNcgKznlrlfNTU93raMDkaZmkOWWnMUVBueaFlRSH6E+pyXBljGjipK9NnTCAJOkXSoKgyidmrmVMqKpjOmFKvRzpxBQHsV7zkGXlMdvKt2/Uw3md6YRyFJoBDLOmIqbIfLQ4J7Dj0uT+zgjSKjHJTxVYa5g1NZfnZywXC66vLqnKkqrMKY/c4HwKUZf5PvJ/HpB/aeoVPaacxAuf0hwBhSdlcNJxKUtUWZY1pTGo5AnjnL7foGxFtbygLpc0yxWr66dU9QpbVKA19VJRVHOKkFC2QRVzNuuR7bbj1ct3/OrXr3jz+oavXt6w3XXsu5ETK3FYx4eNdXKoPhx4Hqyv0/3z4G8eZYOtMVSFqDL4lEBBZYwIkyI9qUBO+UgtzhYIEEjDvKyzEayZZcM41cyVOtL3pSRkAnrS3MvOmCCdyftH/iMtA6BTwurMAJVLGuIsZukbNaWj9NecscP7JyFJTjFiaqFLbOpSwA+5DBJydigEz+gEmdP1FdZ4jPE0zRzQGCNpUa0MwYQHfaeH8VUTlkUdHn88X4/3zamxnO5jQpI+fq73AaMFOWuVJmkh926qhugDvm9JcSBFk2vtgi0g1zytsVnlJFLUDTaXSCZHsU0dyQfcMFAMA2Vl8aOIQKM0vUu0+x1D3xNCFL8xJQbEaXRBSkGxVJRZykmyMeIQKS1k3Eo/HJM4OXnT+Tyt6TShtrPCvJ4qduqAj0Ahvc9JjOnhLE7yejov+im5bI1oF/qoxKEzwpiUk1GCps9EE7WZQICR6ZV8EvJtl7sMFJIBKYxkQ77r9d2V5UfHfr+n7wfcMDBrGpRR7PsWlISnh43O0SMWcISAL7SKRKNFdPFwuOXBtprG1DT1DGsLxnHk9u6GL774LWfLOX/1T/4JwXuGruU3v/41icjZ+TndODA6QWE57wiZOkkULGTTkiJ+HImZqfzBAaQlhy6GSxalsFTE/JhhUh1Icer5k+d+zficuPs6j4UtJEWm08NUzIQIPURMUyR5SK8WJ1GmPqRqTht7p+sbN3huehcWD2ExEVRpSa2kjUOZgohm1syl4dRJLVYchXAwzlWOUs6WK64vL1nM58xmzWG+T+HqB5h5ro2eUqM96AtU+uReJP0rOLaezJpIjE4otx4YjCR4fF0CBbooufr0J1y8+D4pOOpijrElpqihFBKAECPWLIh1REfNrnPc3w/827/+jK9evuNnf/dL3r2+Zbvt6HYu15aLfE+QmCD36RDZxdMx/5Zo4fA9HvfGYYE8qp3VpWUxq7Flwbbdk2Jk2ZQiLaYUYy8qIVZrZrNS0j5GxGWtUZwtL7BWHYAGSpFFaKd1Zk64VKWONDoRWIUkacXcyqGUxLpKKyprc4rVHIwv2etPKVE1gpIco8+H4cMjJZH7eUfhwVVJnKHCKmaloVBBmFmc8EOGjPIbBocbp3qykbaBqibGRFnUOfqIhxLEqbFNOe33eK88Ro7C0RCe9hgKhZrNzoAQLxQP9OkkILAqCGm0lnonCvTqgqaao1IkhoEYemK6hwGcc5K90Rpmc6mx+ZGYWxj6YSBEhTQoGsaY8KOD0VG0kW6bMEZSgl0URq7go4jRJtAJIv1B0SZFRekVKCGOMMpQlEaYyHTKxBIPx2NKrxslskQxJIbBEKysfx9cxkEIe4zJgMBw6OHURDRRST1bdDs1KTgCIntnc2bQWunnVcZm5i2pRY4h4Xxg17qMalbMKglyQgoQEyEoXBKdw94FFBGrFaWVFovyUXnod11/UCSYoihLd+2e4ByqtNI3oi3aioGYSKIlBZRyr92kypfPkBBQShjirSmwBgojDeAgNDvDMApBbHS07Y5uv8aoyGq1xFrLvm158+79gTUmZuFIraaQXVaFFrdF+v4yg8fjTSBozART9JemCZ0ek52fkjC5HDCmakIxwiHvmv8vhjLlGsukoHxMx6TTJ+e0yFQzFVVt82ATT4byAUycY43zAQcgct4GL4dJSuoQzU0tJKApbMlysWSeZO4mAyjeYDikTeq6oiorzlcr5o3QoMkHOEXVPWx3mFohJuDPMUKUGz5NhRpjcu0koZJHMaKUyBB5fzpfiZQCEWGDODRDF/UhOrCmRhsrnLEqt6qESN9Hut7z25fvePPuji9fv+fvf/Zb7u82vH1zw9D6jFDLkVA6dVTye6uj4sTjwT54yuo4z1MNDaUecFwKc9HDl1DRUShPU5boJKnwq/OFsGoocL2V8Y1yEFoL86YStXoD89pkIx1JOYWstSZOHLQhYGxBVZcHIvHoPSbT1xXWSI0mJmkcT0JinE6yG2LHZZ7SxLWaBK4+BtnXbnjIHdp1HbWB5HMZIUY26zWDDxAdq0XNGCO7sZUG6SStCil4Aom268R5M5GhH7BGHOSDVJtyxxRoPtEnDlGJZh+yzkwtGI8j1ofTmXCZvSWko4E83Vvj6NFIb/GRui1RlSVlVWNKTXQ9wXWHfse+62Q9aMnGxBTp+h1ffPkZbbtnt90Sg0ORybDVJPGlIFOexbwu5T0FNKWScJEq0iHjFlXAhUQahSEpOPAmYEsnmbdKE5XwGT9Yh3lv6gxQmZhapMNBosBJXnFi5jJ6ArvFXHaKeOdze8WkByn76hBhKiUgO6XQykrmAuEPTrmvehgdPghLUlPJ37iocU70C4dhxDkvZZ+UhHAFsQO/I+P9tes7G8Gu7dht94Bi7AbpESqLXL9Q6LxYDpFEkmgqZGjwIQrKkZZWSnpBcoguB6p4XiE3rYfoWW/WvH37ms8++zW73S7zle6Fsm0YDsz8xugjJ2dIB2NSZl66br8jxkjXHvuzAPb7HdvNOjv46bAJcw7gEOFKmvDIozhFSTJ1U0HoGLQcXouTw++QDlAnf3sMIOGYHtTTLp4MI1NEKM/TGcE1GevddnOINBKJ9WaP0YauG/Ki05RVkckEHNt9d6BVeoCwU1Py8jRSy0gypO8rZBo4aSBWOV0s/I6J3Ko6GUFlDgeP9/5gKAtbHt6vKDJoIiUUOxQOjWO97Vlv2gdR1Zu3b6jqQg75PAb506KUojRddiCMpFUiBBfZtz27tudnv/gtr756x2+//IrPfvuadt/R7XvEdVYc0Ghw5HFNE49rEp3JfOildJz0mI3ERKYgtxOPDlOOBKe9EfwJo0WCvu3pKoPBELwjC62RtAApks/pzBDxKYjygspUWBpUyPXqdNSDs9Yc+GqD85R1TVU3oMhMNu4oa2WEECLGiDE+f9xTrGfmz821pOnQE9WJJEbQB+7uuqMzmOBmLX1xSRrQBBDnfe5XlHGV3jVHSAY/qazkfrshDXgTsUWk7VpQmqKoIXNXjnYUhHSREdLTvCgOJZcJPDb16IoRnHp6p/V+TNmH3NaVklDxAbRtewjkU0qs727oy4qx3RxLLCliqgZdFHLkTxFzDMTg8G5kEnpOMeBdjw+ON6+/ZBh6unYj5BxJUsHpuJuI5LRfXnPSYiUAk4MEWEoHyjQ4AuJ0D1EnvI5o57FWUwYDJjGOJ9y8QDc6icgQ0YDCaJyPmBwJDkM4lLA6l9soVGAIkdFHtv3IrhvYdwPaSEK0KQxKWcrMOlOYrBtrxKjHpHBB6s7aaNox0o+Bza7DhQx8QerDIWlaZxg97IaBwWfNxSiOTWGE0KF3ju96qW+sa0y/PIHYTAAMefzwjN/x0t9QGXns/T7485P0Xj5YEinnsLWQAucF7h8oNnOoOT2IrvJLHn53cpB6f5z4oiwPqcZvH4lv/vy///qD/yBf3zKuv3O4E+M4Hv4rbC2K0+mVNBdMKevf/fEeDOIhFXv8IN/8x4+N+ulz06NHv/l/x5ThdBCPJ8oE8/nsaLTVtw3JN6cnUzqtSx696eMe+MYw7xvf4btcD171sDSPr5fSMT1nbSYWkGPz0Xh/83X6628awYcfJmUH59FeOfz9N89p+tpzTn/39efHKELM01Xl1Ozpi53+VTg4zKePp8O6nSJp+fb1UsDhU/0ez/9Qn/rW+Xz0IR9dXz83RAx4OqcefJqTfQYcMiAPszXH1SGZIR6gzh9/qq/9Jz2em2+/O/Xwn6+N12m7ktTSpp7Kx3/PcV6+8YNNGa/jnjr2Zx5f8NumanqfQ+YlnY7Sw1NnOr9O18zpq6ckqf3Dbx/3gpy+73c1gv9w/cP1D9c/XP9w/cP1P8TrdxnB794iodS3eyUcrbj+Lm7Zf7DrO9jsBOOJ4KKROP/o4jz2LU49GnjgjkxxKA88QU68mZMo4zREyj+fevuPf/3oQxz9HMnD8pjlYkr1HD7Hgyjh6P2rb3DHpiggBwvHxx5NY5q83keR9gEYc/JcrfThc51G7dO3ryHzfkcUH048ukmC6X/o11R3mq5vuqUpQvj2sP3r3vXpvJ06uN/k6z5+z+Nzvh6JTWCzh2P/mPeVXBI55bH9BoDCN07ff+g5/Zaz4Q9x89Pp/vpdn/fbMiWPH//D7vn0aFU5rfNN8d/jvfu7Ah3gQb3z/x+v76YiAfzP/+ITruYVSqfca0KuJ0j96qp2PD2v+JNPzzlblZSlIISmOoukhBKHeBn4Wpz5ILWQUwmSKHjwWU7/bsqRT43nR1sm9TwVPUyHcUi82478L/63P2PTS13gf/m//t9wefWEbvOW4PbEMODHFu8H/Njz9vVXVGXF0ydP+fCDK5rKMPb3RFUTqLkdG3y/J7Q3PDs31KXAtdt+pO8db16uGdse33WYvHEiibm1zKqa7330I3qgi5GZtaSUpai8I0XPGEZu1+/ZtFuK1Yrlsw+4/MEP+ejH/5iyXuB95LNf/r/54lf/lv/T/+7/gBtHlIJ/+oMn1EWBD4qyrlBa040dTVnSVAXnsxkKRQiwXC5RKrG9f8OqKVlUBU8uzjNvo0YVJWOE29bx+et33G93hBS5PD/n6dU1//F/8p+izYybux7nPFVZ8Wd/8hO++OKXfPHlL/nlb/6GfStkCOPgKYzh6fXZoVbTDz1+FDWBoe1QSlMvllxdfoAP8F/8y/8jznuqquJf/st/yaeffiIGX02pp6MLMYGFHmz8xOH3D5ImerIW8cE58jjt9l36yh73oJ2iDh//XinF559/zr/4F/9C1BO04kc/eYatLElrFI7CKM5nNTGI2PH9ps/1VA6Ar6Ky1HUtepwBVosVF6tzzlZz+m7PF1/8NiMuYd8Nh3pkXZYZlKaxRSn13gT7fUvb9qzvN7m2D0ZbZrOGjz/9kL/4i5/y4YfPKQtBA4YQWK5WFIWlKCx3d3d88cUr/vP//L8QVRNdov/R/wpVrUh6IqyGdOgFO3iC+fuU5v4mj+D08ce/T1+3OdPBnnNqKn9PhxzbyfcpHZhOnMTTt04J2nfEv/7fQ4oYY/jpT/4RWkvN1Vgr42lNJosQSa8JtT4xOhW2PJxTgmg1ByYtyKnhPEfSFyfvL03vGqMU82ZGXdWcnZ0Jp7HzvL+7kfo+cHV2zqxuOF8sBQTnA3fb7aEEkIK0gBXakAzcbe74v/zf/89M7VqLZpUd7HQ4edNhjk6DhYeTo/JzplQmZPLraT/kPajT8TkPnLSDeO8RgT/Vdr82JyfO92Gv6qlVQ7588Gy3N9/wWb9+fbdIUMF5U3K9EEUCM1ErWZ0FZxVXleGDVcWnlzOeXjc0jSUapJVgSpJPSAUy68Y3pMgPYIOTwTkeXOlBfYU05cKPRnBa9FOhmuik+T2KEXzVmMPZp5Ti4tknPPngY8b9NSr2EEf8uMePLW5oUaqgKgqePrnmxYsrZrVh2Bd4Klyq0eMKP+yJbckHl4qmUGij2HUjXeeIYcaw2dKvN5gJVJBgYQyLuuHF9TWDMvRAY6xQncVIHAdi9Lg4omxE1wo9r5gtLVWjuLi+ZH72hKKc049v2e9ucgOsXE1ZMCsLRg9VadFGU9iaedaFfHZ+hlGGFDWriwsg8k4PzAzMCs3lssk9igZtK4aQSKpnu6ghBlwIrOYN56s5P/j0E4pywdm7PX3XU5UlP/7e9wnDhu36DfO6gCgSVqU2FNZytmgODf9jZTN1nqaLDqUNs1nD+WLG6I/GSGvNj370I3784x8JyldxaMEhHaOmiadRIlFkbUxEpvnAnc7cw/mb18Nj3bppnXzb9e9rBMtci87bi7KywgBjpO+vNJqzVYN34FyiGx0pTX21AkyoZxVlUQrZc1DMZhV1U3J1eY4ba7xr2bUD/egIKR4OuqaWpvfCGIpSmHCCz+Al5ykKizHy3LKoOD9f8eknL/j0kw948eIZioTzwkO6OltRVTWzeUNVGfb79jheSqFm19BcSO9w1rVTB4OoJimWE6N4PDgfXN9kBNP0cIaPpHzEZIR3HvgD6OrAq5iOjvjh5wSc9K+ezHAet9PfKepmhtEGYxzWllhrqEtBYButhBJyHNBa+miNyUYwv5/W5kC3aLM03Cl5uDGashCjWpaWQhtKY1nOF9RVzWq1ImYg4KyucSEQUuRsvqQuK5bNjME5RucYw+QmCqhLkL8Kb6F3RxyBUqBza9aEGxA9w7wH1TdFlbl1S6uT8Xm4F2CyA/L94Z6YYtlMRRmF3ebUkX28/0735wME/cnX74t+T68/iDZNPVqveQxAgXPQdYn7deBspSkrg7H+YXr01PJNn3FamId98/W02OHH6c8VZFgU05OVyb87iQSJSTZZUoeH7Ak0PwGOilie08wumZUGqxOEHj/scP0G7y0qeZp5RVHWGCvK1yl4QuiIaYEyBUWzxBYj2orYaCKRtKG5ekLCMPb9YbpV9kgnBG1RlEK1BAfUXUoelRBFv7mQ+O55z+7ujre73zK7uObJix/z4ad/ii3mmGLF6Qb2gMtRJaPDWhFFrY2hMYbr83NKU6IpWV1d41Og7fYM+zX9vsM0A4UNGFNgiIwusN3twQdKY3Be+sx2vaOoS2ZNyartwI0YPISW3fqWt199xe37W/pxyAw2GlJg37YUmelDKZHmGoaBtmvF8JYV2+2G0X3LxtP6MJ5wbLAVtYiQFUaEKSe4IL0LnLLyHKHexmgKKyjlsizzOvz9UeD0+9PWkMd/802//6YrBUFORhKFlt6/srSE4IjR4cNIQmG1pc40ZIvZTNqS8h7a7zuG3vHk8pKqmvHBBx/zm8+/YNz19L07sA0JmZcgaCcH1fvI0I107YCQ1oizslzNuH5yyR//0Q+5PF9iVWK729D1PV030Hcds/kc1BM2mz3b7e7BfEUFB53m04NjelyR+z6PUaA6blmOT54M3+nYynerwWZ9RJ80fcw9stNhkBvJM1vFMfI/NX7ZQXjYzzlNDt8oSiC2cWqDgqoQfUWdU5VWGYrcF6izEKykKk+k3RLgQzbiCe+kt1NHzayuOVvMOFstmZUVy3rGcjansMWBsCCGwOV8Ru8cvRtJQdZDu9uzbVv6cWTdtkK2b0s0skdG5xk07NruwTgrZbN3mA6pcHPqgBwyL4e/kO/6hC2Lh/HN4c+zlyrHd+IA3FMJlUW5Hra5PDRmp3vy8dfDeUkPPuPvu76zETwmnRLHtzh6UVFZ+lHx9qanaSzOF1xcmbwoyIv3JFqTT/twMZ681+Hf9PD/6uDZZxaXTGlw7Os79TDSIQ1ymhI7vdquZbffUVjLOGaCamNQagn1jKvvVSg8lY3oOhLVSBEtrt2C6/DtPcGPJN8x1NLvVhSiyoZK2KrEFIXQszUN2lhpVF/fCUw9OAqqjL6VZmFCQKmSpCK6tDTqjLoY2bctgxsZh47f/Oxfs37/mthu2bx9iW+PLRIgqswoQ93Uwu5vNLOmpMhN+R88e0Fwifev7yBoZvWMP/rxn/Ly81/z/t1r3t5usWVBUdWYKMdmWdcslEYXI3e7d3S9QKEJgTgOdNt7ZrOSum6I0dH3LbvtFoWiKkqaxtJk9YtZXR5aWvb7vUSHZ2fMm1LIhZMCpp7Fr1+T7xST9BNt9i37tmOz3eWm8HRYF9aUFLrEGisEu4e14VE5q+HcACmxXC4piuJAUj7xs37TZpMl/PVI79TofVuk+LVLaZKSlFhdSxT88Ycv6HY9+12P9wJf7/1IUc4pKzlwXfBCK6WsGLK+49effc5i1nB5vsIaEWFW9GhdUNgCsBI5R5XTnol929J2Pf0wHvpsY4zMZg1nqzmXFytRj7Ga68uL7GMm3t/cMQ49tzc3GGNoMk3d4TKKlL2NqZ4tRi971HoKx5V03HDibT8coGM0f1JbU0pRWkVjFaUxdAH6YSK5zyeWTkenGCDpR2dPZiM5ocU7mWH5uwcqEomhHzHaElwgJpF0k8hQGJIkUnYMLiDw/okNL6dCOWoYeiYFDEszqykLy8VyyeVqyWo2o64qSisitCaLAAyZeMJ7z74fhIoxQlMv5PfjSOp6XHZuVNLiXBUlIXnG0R/a1x6MshJn8BB4KE56RQ8z8ehvvtkYPXjOyZnMg0AnW5Mc4Ui240h397XXOdlf35SpOc2ufNfrD1CRmP5Nx6iNA+UqJIMPsG89292AtZHlqhJnzxyhGTkMemDcDgsvPX6/b/hf9tyETif3bynxLyYP4/Da6WG16PGrAoyZ8DvGREhgTCJYUXI3qqRYSSRklSPoEcWArjzKKdSoRPQ0HxghamI6YXchHTe3UtiyRhcltqwJ+y3RjSKvko6UakpJtJqUBQ1FU9GkJTMzcOfeg5d+o9u3L/HDyLxu2G13jN32wf2JkVAYa3nYoGooi4q6mjFGR4pK1ONtzWK+5H5+w3az4W57h4pQJGGIL6zlbNZQovBJNMB8FjGOPhC1xw098+WMuq7wbmQcesahR6GwxlJUJU1TSw3J2kONahxHjDaUZUFdimDyth3y0vh60X7aTiLIGdjs9tzcrbnfbLIRzIeZEjaLWT2jLueUBVgf8mEn1GzSz5UYho4UwyFVWRTCFVsUQgxg7bdvlT8k9fJtV1TH+yrLktms4frigq7sacqe9baH/Y7eD5mLd6Jmli2ltXjVzgfubu9xw0BdFpmqLAdCmYbPGovREhXHGLOKfG48doGUsnRNSjIndUWdDWBhNEVZkFAHDbgQIuMwYquKqqofjs2Uc56ivcdp0MNjPEw3wUl2bfpBH7fx5PTmOS6tprQWpxI4f3K+KI7pz1Pne4oSTx87cdQfn00npYaUhIhCmaMhC0rhvCfEKbMRpLYfE0c7EzFKmter3PIVoxgBEc0uaeqGpqy4ujjjfD5nXjcUeb6s0UJykESb1AcvbDzZ6UtJargoTSjIDreWDEP+opRUdERlyrxHRjCzwRwf+H0r99gz/buzHTGf0CfSaGpqB0oI75s6gKtknL95X31b6eHBz78n83J6/UGR4MH74rhWNQmDylEMtGPi/c0GN2gW9ZzlasZsXvMIzcLR6J16Xr/jMEkcojqVUxope3dJSQT/TX9+iARP3vb08jHhQiQhPJVaa1zm9ZtU0bU2GDujZ4nVUM+eEe2OYt7yZHGH77eM3S3G9qAjRkWMTqjk6NsN49ATY6Aoa8rZgtnZOZv1TZaMiZK7p6PvW4qiZDU/o7IFprQ012cUcc7ZeE3nttzHO8YusHn/hu3tO27e/IaiqhiH8QHKy3m5ryImhmEPyRNczdkHL3j+7ANu3q1JQVGWC5p6RWVrxrbj6vwps7rh3/78b9kPI5tNS6E185nisqootMKmKE3jSkEUUd2pWbuuZ5RVzZv3b1mv7xn6Vjxkq6mKghQDwUPKnrXO7BlKg/OO5byiSML2ItI7345c6wfHZrvlv/nrf8vb9zfcrTdUVZUPdmn8tsZyfnbB9cVT5rOlzEUYiXGkMqJCbw2kJDRxMcYDu0hVVdS11F8WiwVlWX5NV+7BWvuWTfn70qEJ8CkKzZxSrLIs1fc//lCEpnsPyvLFmzds+j0xCr9mQKHSpGOZVQOMZb3dsl7f8/r1a5yXZnafoK4a6mrG2dkSoyDFwHpzT9+P7HatyPr46TDSaB1pZjXNXAirCyNRVwiOu/sNN3drTFFii4rZfEHdzNjvJs7V/M0YpNM6h0ITKObk+yFClAE7fDts1dPay7SHDzm2iXtYH0sfpkAdaCrCMYKcltJpJirmGZjSpIcZOYkUdZJ7OLl8FOYVW5gDZ6qYMxm/mAkWtFYiZZQS0UVmtmJR1Xz6wVNA5sbUM6wtRTexaigLy7y0cnbF6TUl6gnZ6Dk/ZvHwyLwsGV1gcP4AxJlVFRdn5xRFwf39hhgCfd8dhlIbTXTpIPM0XboQIdwH6/M7OHm/b30rpQ73c2pZpwzeAYxzCBLTw4Dm0QtOj+jHBlByuFLX/I7Xv5cRPF7HiEcxyY4kgk/4MTDsPXXtiU3EHPim4vG1Tj20RynRw71NXmB8lMePWWonF2RT4AE5s84e18FoZk/p8ftM8+JjAqUxEZKKJCWHwCFL4hUhisc9BoVOM5QpUbMKXZ5TNhcUpscoTzIOzS1G7Yi7HZOen3cjxo2iYD+lkaOIYaINY4qQ1e27/R7tLM2TM6qiZK5nlGZGoTu0KkFJKqPrWlwcGQf39fmJwit4PqtYNGf86Ic/ZLU4Y17Pef3Fawpbc7a6ZvSe5EbK0lLaGfPa8qPv/YDXNzd8/uatyJo4iRa896QQKK1hPqs4O5uxWC5ZzJeYosL7kbvblvu7O+7vb9jvt3g1YoNBNPAKrE2Utjwg6Yya5XSQYhgHIc+NEFPAu/C1+5oaYd+9v+Hd+xtevnotacSqoqzKjMrrsVoKxfv9HqPv6XpB3BKF3Z+mkFqgMpm0XJ2wHaUD32nf9wfV8qZpvub1ftMB8Dgd+nuvFLFa0zQ1pa6wWFQMsrwLSdlaow/isikqxhAobInR4vHrELMh1ESVFbcRaJn3gbYVNpcYnNiLGNju9/TDQNuNjC7rEYIcxIuGJ0+ecHlxASnJWhshJY0PkbJquLx8SllVVHVNCP6gNnC4JiOoRf/uYPxy7e9BdHjwVtURkXgc0eNZ8OAcVWgrihtpCvyUyO2I16uPf6NPz5tHj6XpuY/Oo+l3jwyDPEVlcIvJ0bk9zPnDeU8U1jCvGj64POdiMefF1YWkwNFQzQkJnPcSoZMOzDI8ygzbokAbQ1JQFDl9GBPWBKwJxExVaFDidM5mPH/+jL7rGYaBEMIhlRjiRKF4MsrZ6eekDvttJYnTqXmcbTv8xRTVTeP6Nd7B9OD+JrV6qZ8e7/9ha9a0Th58Q6LS6ZP8B+AOzbb55DhShxuYusSyEZbUooOx9YSlCKMmY/LvZVEd0JtMdbuT9gbFccFPNz9Rlp0uTvLzUja+mYVeKfEKJzUvcSZOYLcndzH9L+b0jtwAoPPnkQKJCAXHJOg2ZbGmxOiGsp6j8RTJodWAwhNVh0oVhnuSGnNq0xK9JwSHj54wEXUH4d9DG1xe0CEGdvsdejRcp4g1hlpXcjiqCqMKScOmxOBGvBoZs4bj6ewoEkTP5eKCD64v+ad/9qekoBmGwC/uf0Ezg2dPG0bn8ClS1TNqW0n97KNPiErz+vaeXd8y+sAwjML/GCJNLbI95+cLmvmc+eqMspnz289+xf3dLfe396zXd+y7HdhIiBa0IhUyXyHEA3N8XTZMJOW7diBESBRCEfZYe5BsBL3n7fv3vHz1mjdv3rE6W7FcLSlKKzyxwYtcDXJ4p2Roi5FCK0gBlRyVbdC6IKWs2qE1p6mYqedtGIYD72RRFAd9R3ho7P779C8qEtZo5s2MQpeoJOArZUTUGSLaaMqyQmdOVO8jhRFRV7TO9iTJIYloQyYVSEh6ru16nHOMYy9rLwXa3jE6T9u7LBEmtqcoLMvlnOuray7Oz4kx0nY9KgVQJeiCqmy4uLzOtVPNdnsPj1Q/RF/JnESBHEAw6TQifGQEj5HewxV9OBembynJGBVKeDA1Apc/6V1NUzTxwOnmxNBNLTLp+DU9dzoDzEkqluPLwKTqYo5ivg/2Ya6nW8vFasGHT6+5Xi25WsxBW9AGX8zpR8/9ZoNKoghxwPOlY4STSOI4TtmI6cD3AWsi1kTGPIFaKYpMfv7s6VPu7+65X68ZxhGlFcWBR/VU/1GyX0oLeGpKT06G6WTYHy/ekx9kzCbDddryJnRu3+Aw5qFUeQ4mOzJl7g5G8HDFo41+dDhMotWPxZZ/1/UHEGhPn3R6s6nAK1p5hnDgb9Q5TRMHRRgifvSYMi/sKCZn8lFVPFlwhzc7+T7xOR5k4zn2ADGlmyD6iBsFaGGMIRktqhBImi7FSAopk3kfr2VtWNaGkJSQ5ZLw0xJI4OMUYSeRHVGQksN5D0rg7CJ+W1IXM1HkVhG1eEaaOZ7M7ojtlrRbM+7e4l3PsG8JMWIA7wZM9FilDlBqgD73Ce7XWzbDnu3QgbPUas7KRhpb49LIkPa4NOIfc+VpTVHVXK5W/NVf/RXfe/GCyhZ8+eUrvnr1hqurK4qqpvc9L9++IcTA86fXaD9gkmd1dcHl6pz/0V/+FX/3i5/Ttnver3eURUFd1/yP/5P/CcvFkuViyf3twKuXn/PZ55/zq1/8He1uy9OnT1nvelxSLJoZWgTuCNGjQmIYpP/NGsWsttR1QVXNSUrhXCB4gymkT+6xcen6gZev3/E3//bvePnyK7p+xBqNUhGlpAndjwN9VjbwUTG4iDY9VxcrkcAhYbNidlUVFEV5gFxPYJipj3GKAodB6pRN03wtNfrfzwDCalWzWs1YLmbEkBh7TwjgvWN0I23niFHTNHNSrnkqJSKkxlrJLsQgz/dOWh6yoHIIEe8jfTcQvMfmqFcbhfMpR93qcOAYo7i8POPHP/4+H7x4wnxWsdncYXXAqERRCvclKvDy1ed479lu1gzdnldfvX0YBVkrXw+MYD7BJkP3uI5zePzRKB0ONjl3lEoYFagqzazUOEZmReTFIqCqApcMb3uF8wYfDN3IISujcuozTRFgIp8xE29wfqvpbHpUEz4KsmXDkflqp3UQgpBJW2N4dn7O5WrJ91884YOLc2ZlSd/1+OQIUTOqgX3fc7O+5XK1oKwrCtuQkjmqlaREiJ44jgc77YKovhD8wT+YzReSKVCasd1BCpwvFpTGsJg1vPzqVSYziNIL7ccH9yVizJOFMYIZ+loG8Dss6PxnIkWXjhbt0WsppqiPR/P96L/ZAMnSynP0SK9PnfzNH7If/4BI8ORD5y998nUgjFUSymuUyAll5YaUYbcpRTTx6GU9SIWeWr/8LWWS2GyB04HkOHvsMR2g8RN5t9EaosCHU1bSFQWJJC0DJ5dLGp8kJWMn+RUtYpExs6c/VIB4OA5ZfDqDBDL7u9aiRE5JqjRaz6E4o6jmGNdhhx1F1Oh+j21qTFk/nLR8CKSUGPuBtu/Z9y1jPxJcEIFeLWAKlZSUPR5HS4C2BfPlOUW9JOiK1+/f8+72jtv1muX8jMGNtHe33N3fg4LryzPSOJL8SFpvKOdzZsslF8sziIm3t29wMZGMRSVDWcyYNee0feR+N3Cz6fC6xjSGojkDU+ODEhmtCBAxJuKDRqlEETTBZrX2LMlitQIjRNIanXsr8z2lxOgDu33H67fvePP2PW/fvceNjhAGfBhyW0HAjSMp2oMRTCqhTMKHWd48IqtlDcRYZICAzgTS5kEP0rR5UxJB1HEUQVSt60f199P//AEHhxK19qKQQ3R0I/1gcF5qPqOPB2OllCamgCLlfj6JAEcXsurGyWJQR65UpeRANkod9ypyWMuWUAd7NIn1GqPouj0x9LTbO84WFU0toCEfya0ovaB8w0iInlM+VCD3oOhDdiZNRvDU8D34+eT76QApIIu5CghADkGlEtYaytLgo6U0nlUVaGYRrxKmT4ze4IJmOxpGrxgcjKMiRnUkgVGyPvNCe3QUpWMLx2F6J8V5dZI5PRKkG2OprGFWlVyvFpwvZsyLEhUTwXkG50mmIFlDWTXousTMSi7PljR1Qz1f5rNnUtUQ1Y/Yj1ntI+K6jhgHUJkYPEaK0pNMImktEmreURiL1Yp5U9OUFf0g8nPOjcJadFwuSOvM8WT/mnH61iX+eL3n6DWlHLynh2M8PSt9w3Q/CjslSkyH74f2FxWPT3v8Wf6D1ARPDLlOoJPCJA5yH1rJR9OIN2FVxCQPIZBcJBnRHCR6OApriOMVT98mHR84vOdEDztFhSY/JxCIhJQYnROjF3NzbK4PpiBCnj6kDKd/yA6yd4aZN1QFLEpNmZuVx6AYgtQBA1muKXCI/rTSskSSpDxiioQxS+dMeoDaYkyNakDPwF58gk2OMrSkp6/Q/YZmfysTfGBJEKuqjSWlQN+27LuOTd+z2+0JboTgUDqglRj5mGQMTq8ImLJkdfmEgZr3W8fP/v5XbO7v6HZbTFHTO8/7u3u2+5a6FikrHxJuCGzad5xfBp7OFjw7v0Il+PkXv6bwgSEp1nd7losnlOU573eB263nvofl0+9RlSVniwbz1SsGr1DtiCKQCJjcAOz9SFUKSpQUcD4QXBCtMWtI2pKC/loJYd8PxLt7fvGr3/LFl694/dVrunbH1e6Mi4sVZ2crALz3lOXUdgJBeZTxDOOCqBNGRfZtS4yOstCoXGdJMR0ivMkxEcMoNHDOjfmwC5Rlichsydo8SNlw6pQc5yUl+Mb6IUg0WsoeabsBnRLd4ElERpfohyigx6QzHF9R1yVFISKpzkla02UFiexzMglCG60oylpQrilmNQVP1w8SWRLJWVWq0mIMBD/w9vUrtEr07Zry4xcsZg2z2Yx+GBn9gCiYJapK0NRVXT68OSt6cZKr5ZGh++ZoUARfeXT4qjyaRy9UhFqln7KuC/YkimLkch55chbRJnLlHWNQjEHz3tdse8Pd3nJ/rxidJqYpmk+g/RS65IemyYyPWiR48PvJAIasUBFToqoqzuczrldLPr46Z1GVNFrjupEhJbrosfOSYt5wcf2Usqlp5g1nyxVFWRFVIQodea350eH6gX6zww8jwzAwqve41qMQ5pi+7TG6QFtL1Jq23TM6cWrnszmLuuZsNoMQ2ey2dF3PMPQPUo2iwGI5DW+OffAnEcAxf5n9hIe1vcN8nu6Dk75uTh9+NNXTr2Me4pN3ye911KKVaTjddBJUpd8hlfX4+u5G8DSDkUQ6SR8yx9koZPVgo0Xssyzk9zGAiwZlDaoUa67ChHjSk2jX8cYOEeLJqGTF8xiQTvAUSSowhkSICefSwaAOWddKkQjB5wUqCLl2jKdTgFeaAYMPiXGQSKQwUBqoSzifW0KEwSV2DlyAgCGm3HKcN7JSGQKscowcQ6Y9K0kkoiJTzBVYdYZdVNiFRz+FMg3Y2LG4f4kNDhMCxdBhk2d1fo46W9K4kRBbdl3Hbn9H3w24GBlSwMWAGx564NYYUkxsdzv+63/z1xAiY7vGdTt839GNn9MNAzebNcZYVnFFu29lRmxF8p71/Ybdfs/lxSWrpuYf/eSn7Htper+9uWW+uGR51XH+/FOuvvcJf/TP/jFJFaQIfrvh9buXvPryM0xoKUvDbNEwXy1BwW6zYb9bsxl36KsVwSfc4FksGkGF5gbidNKlHGPi3/y7XzJfXfLmfsBTom1Fu3tFYSIperQSKa6+bVkuZ5RlSV3PSGkkpkjbdtQZ9bnrWnyI1HWJKixBRWKuK2l3ZKXQGmL0h8hQsg4jxkBZVtR1g5o4MhOS5mdKnR83z7enaBRWF6hkGJ1n9EHEbQvL0Pfsup5d19EOI33wNHVNXVhmC1ExD97ndR6lXqiAGAkEmlmNUQZrC9kcKQEOhUapghAiXedEH08ljNHM5yV1aSEl7m7uxWGNHqsb6mrFbtux3m6536zR1sp9RkG3Dv14eltksdBvMHr5CY8ZY+BAr/bghR4NXcqGUishykg6sU2GbjAMTjOb1SxUpAwbSq1INpHUHRdFwSfLmuFJw25QfHWnuN9r+gF8mLAKDw9pElITPLkkTZ5RoVGc0BQD1ljKsuTq/JxlWbCsCmor/dJoBbaiqGquP/4Ys1hiZgtMNQelcEpxbywqaVBFlk4TakrqhFnC7Fz6QomJZ8mhowffM/Z7+v2W0LXstztevvxKygLOEYzGDwMBuD47p7QFYxh5t37/tXUYzQylKw5n8wRSmp5xsoYfpL2PSMZvWeOng/noeScez0MqtaMfcsCRAMd1fGq+s5FNUhJBfV1A+duuf690qHxXEsrmFKJEg0o2Ul7bU+NoiiKMqFEYW5K85KSnmxMjd4zQJlFTFBMPkqAmQxLPU5RLSUSiz0DRqf0rqtxML4dRzBFWiIIAHf3DEqvSBpUbUH1ShCiTrg0UCpQxWC0foyKitQg7Tn5PVCLIK4g0uV/h5HSQglAAKUXSipCE/NkrTaFLgrYUhfTsFDERZzOiH/HOYxYLjErMLi6JfiS5nvOLM1TpcWZPdzNIo2uS+qtKj9M1EH2g71p2rcO7gE0jeIdKiaHd0Q0D7dDT1AJMCT5iyxJtNWrshcVl7FnNZ9iq5OnFBZu9cIB225H1+p63b9/wvScfsVjNePLphwzO0PeOt33HbL7g8uKKRp/R1CWLswWL83MScHd7y83NG/a7DdpITcv5AWsNWkdiMJS2Pom0ZIN89eYdiwH2vceWNc18QVWJgrwPQYQ4nRALlFZYOqqykkheJYa+x5oCVIHzCaUC/eiwzonXGRLeG7zxWDN5nIoYs0AzWqJ2AsPQo5TKjD/5wECcrwdotscn+Ddc1gg0fRymRn+pESvjQOdWEQWFNSLcWkhKVuqAHuecNEznFNoUdZZlKX1mRk+b6YDxUAqqyuB9wDlx0qxR1FVJXVc0TU3fdqSYsKagLGuKoubu/Vtu7+65ubvFlkWODBKFKdjt2oeHY64FKqVJk8c8OYvfGBHm0+X0sP2mYcxC2KJeLlFhwOJjIDrovaa2CpUk06BiZGESEUdSkXmlmJcVSkkteG0V+zYSUjwgt/Oig1wu4cHb69xGdWQ3MUpTFpa6qlg2DTOrqSYGGbJxL0pi1eDKOaMqSR686xG5xZCPRQXaYo3JdIdCe2iNxWqN0ZrCFDRlQ2EUlkDtOxZjS2jXlHf33K7X7LueGEJOF8ohWZcNPlQsZjOaqqIsipzDyB17uiKZmgeFrkME93Vn5Ji6VMe057deJ1m+kyl94HMc7GR68HZTSewAbNTyXaWjKVQp5hRpAv2w1vm7ru9Om8YBbIx6aEZyPUecJQtYBYVRVGUJ2hCiIoyRwlaUdQ3KSH57HFE6omOEQDZ2EZJ4oQTwfiR5CfkJmhQMRMvBL4gagpLF5HONI8iBmUiHcNpHcCGx69ODeWrqilnT5OfLhoxAnyT62wZFaRSLAi4rGYfOaToPg5fnxQjBG2yuWWiVSEMLvkWlEW0bdLk48FymODLGHh17hniDUpLa1MlRWsNi3jC//GMWTcP1iw+w719iN+949uyfsO/23G7u+K/+9f+TzeaeOmh88ugic7Tm9eP7gd7uWBuNUwUhJjb7Hcu6ZFbX7Nf3eCLlvGI+nzGbN1hjmM0WlFXNMI5orzAhsNveMQ8zPnrxgracsR9GfrZ+yS9//nf89b/57/jPmjmrueV7z/+Et2vHu6Hn5z//GbO64T/+y7/iT773CbOmoaxr7GxB0obeOV69+g3v377kl7/6N9zdvOP+/T3rzR6lDNY0XJ7PCCdGMKbIL371G86uB5JZcPnsQ66fPuN8VdN1LeM40I2RsXfs9j2FMYQg6NqQxNlwTlLVZ+dXjFETx8D9tiWkSF0JqwyJA9+otYaikLSqHIZH+Ptut8O7gMIwm1nRBDx4b7/rMHi0t5Ri3iwwhWa32wpa1RTMlueYqkQXhrrRVE1DM1tIHdN7drtNhr6PbHc9IUida/QeYzRNU7GYz7DWMPQtVWmoq5L5QlLtwzCw38uijjFSFoqqslyeLXnx/Ck/+sEPePP6LcEHZk3N1dVTmtmSn/39/4uv3rzm7bt3VE0jSMyYqIqSfTueGEElRtDaE0M3fT1MgX7jY992EJ2gSYsUKJWmVIa6WLAPittuw93eo5OmLOZ07T3B93z89Irbds3L+zdczRuu5kv+7Ccz/v5G83Kt+eVvFa0LdCFMOc7jlzlYcAlwsyB4SuCcQxvNcrbk+vyC88WC87qmJFIQic7jgGhKdH2Gqxb89S9ec3u/5f5+Q7/f52g+l3OY+mcN1hqauqaqKpqm4eLigqZpODs/Y7VaMZvNuDy7YLU45+LqCU/ONf1uw+x8xS/+5u+5e3tDdCOl0RRIGWBRl3z89Cn7YU9Mnr89LFdFKs5Itsk5vpNUcZ63BxTjj+fod7ZSnERxJ/+bdsvpaxzTq8f3OmhOTkbwpOl7ekylhEIcVx2++/77w7hD4ZD+nGp6Klt/rYS/r9SRUmtKo7FlgS4tFFbSgUqBLsBWoDQqOQldw4TWyurdIWUAjCb4RHSJwuaI04jrl+CEGlTC4OmawCwhTr1S4ELEx8TgHkaCpUk0BQLAUBLhJWWkZWJK9ypJIKWQa59WMS9gTmIIUQysV/iMsosJKBo5MNvtgTUi1Q1JGyEhT3tQA97v0LEjhIEUB0alGGzJzhruy4puXBPHFvzAZdWwWK5Yrc55/foV72/ecXdzx+A7jD5BhyrpKTPSDEZZSIS7H3tGlTAkOufpvad1HmM9TS01oZgCwY9YI+Mvzxbnott39C4wjo6q0NQGogr4bsM4tOJsdHt2t2/523/9X7GwcDmrCB8+Z0DRtj3DzRZlS86urnjx/FOeP/2Ai/NzXn75Gb/+1c/5+c//jmFsqevEahlRuniwDtu2Ra3XdL5jOFtSl4bZ2RPqVSBEqaGyXWP6gTEoGDx61+K9JySgCFRVg7/yoC0hJTa7jhA8VWGoyoqqGKmrCp2kPjkMmhj9Ieoip0mrqqIse/btwPNnhrppKMucdjz0nH23qzDi+Lm+x/WBrS14+3bLxcWMJ9cNf/T9DwkhoVXJm7fv2W33vH93J+jPCD7Kek0KmpkYvrouCGEkRVjOS5aLhsW8RhEYxhE3SIbAjZ4YE0pZoQLzgd16w6svv+Dp1ZVQp52vCHHk9duvWG+3JDSr1SVFVeNDpN3v2bYD+33/8LatFpDAVBOEYwr0NCKEHNLJj8c6Dye/l+ervK4VkSJFrNXYsgRvwBZgam62LQTNJx9ccd9u2Hcjs/s1trB8//pjvnjzBevNjt1uzQdP/5hPP3zCWdT86r7nN/fdESQ60e2cpEMTEEMkKC++egZT1VVNbQ2N0TxZ1lgFJgNDoi1x9Rm3vWLbDry83dK1Lf3g6LtBan7OTSGPpFutIJNHHykGx74b2GxbjDWiIFIUVGXFi2fP+ejDp3z/ex9QljVaGa5ffMD2bo3Vijef/Ta3VRsUFm0Ms6rm2fkVfdcdXDalFKZcou2MB6f9QXGAo1k6MYgaSHGUWFKVD4yjOvnhNBkq7xlP7Wse2+lZER2GbAg1IZVCDBEjqJBLTBNaVBxTdQBdRsnEfUdn9A9LhyoeOGuHN1AKoxJWSRRojUDfbWlQhUVZI/x4QMKAKYCEsuoY+oacy81pJJXEqw1BZSh9TrEqRcrSLyQEHMJE33a84Si2VWp4KWU0mzAqnY5LYRRVoSi0QhkNShOwuWViQqZCQB2Mbm0UlU1Yk6hCxOXX7bwcRmPURGpQ0iMZ00hKhlQjtaOpCShFUnIE34HbEXxHSokeQ6sjxlh2Q0ttFLUxzOeWsqo4X5zx5OoZMcB+0xNSQD/SbTNaagmJdJjk4EZchsf3PtKOnu0wMp9FxiA8rDF4fDpRNleSDgkx0vcDQwZfFEZRW0U0EP1A8AMRGLo929v3fP6Ln3G9mmOuzunbPc6MdL1nMwRMWVM1S548uWCxqKnLgsJU9K3jZz/7OX3vIQ3ElDCnKK8Ebhxo25Z115GUYj6raS4XFIXNTtY9ISa6tiP6gVG4/HBuFDi5TaxWLd45lLbEXBOL3tEbTVM5xrLCj57SFJl2TjhmR+cYcuO8sZbVcklRCOn06uwCYwvKTCmW85F526jT/37b1hLE3zgyDoHeDtze7bm4WHK2WvHxi2uGzjMOka++dPS7ls16L+wo2hAzYi5pMsTeYAuDGwZUCixmM1aLmtVyRt91BO9JATGCPuR2WGHa8M6z224heL734XOuL8+4fnrNF199xdv374RIHU3TLLBFzehG9vQMY083jA+PHa3AaAEqnBrBfG48hFvn4/CbxknCIxlNrTMALmFVFG5ca0lGk7QFU7Fu77GI0+2TcIrebbY8ubjgyfKKX33xW/atqJz89PmnfHJVknxNmxJf7kZclAhD5e+ntGlALrHEg1q81pqqLKmMoTKK86aUtZugj4HRVLhyzu0eboaR220ncmm5fcW5wNCPU0CGNloyMUb69tzUpxu3AsxSAR2FYGF/t0Ylx+XlgsXKMK8s59dXXD29Jg4Db3/z63ysJpIOQjNXllwuV2x3K47GQmGKOaqY52N5cjr0w3k5OC6CHjUpEqKBFNFmJs5Mfs3TqDEpiJNzmEDSf+RWtpzSJOWUZkS5hM5k74ElOimsjyQtgDHUseyQojhFOncDaHdKDP67rz9AVPf4Na3dKWC2CkoFlYaZgarQlKXG1AWqslBowtCSrEFHLdByNLh1zlV7acLNIVx0RwPYe0MIUE3itygBxuTFokxEEbB5waoAmIQKSVKkKFTIlDwkBLpzvJq6ZN7Uwqlosz4iOfSOMCRDTJrAJFOBpPPyWqjLyEJHKp0YQ8IHaJ2kTEdX4vw1KThSjFBkj9LUaHuFCjntoN+TlKVQKVMiBVzbkaJnd3+P0uIgfPFK01QNy/mSruvxKqGaihQGgrI8OD20JiQl/WV7qRc5F9E6EvDsekc3etrB40LCx0Q7dsL1GRNuHHHR46KnLApSMrSDpxsGxuCxRrGYz5hVFfPzM4r5jBH4xS9/xd//7d+iQqDd73gTBv7Lf/VfUpUVZVkRTQWm4OWXn3NxccZqseD68pyL+SX/03/+P2N3e8cXLz/ny9dfHubs8TokRcYxcHu/5n63493dLYv5nPl8xpPLSxZnF3zw4mPefPkZ67sbvvjiN0Q/QoqYcqBslpxd3PLsow/RqWaz37G7uSeMPUYnSltQlyUvXjzHGktMibfv3rFvW/q+Zz6919NnVGVFXVWcnW+JUWNsgbFZrYKH58a3XVLrvAGdgTvlXPT5bu4Ynp9h0oqrswte7d/xm19/yW9/+4pdO2CKBmVEgzAEd+hpTFEOzP225+qiYrWoef68geQZxjWbbc9m3fPu3ZbNuqPrPUppIeAePLc3a+5SgOR4cnWOc47FasVvf/slv/7Nb3n58jVlWdE0M5r5HBTUs4KQLMX4iHfSGpIV5/JYT3noTT+gm1PfRsacDjykRmv8OKCSp9KS7la2xOEINkEzZ3srpO6//vIlq/NLXiyf8Ld/83+lHXoqU/CnP/hTbjbv+a//+l+R9juu0sB/9qffxxYl79rArzcDPkaM0oSYSMXDozKkmHsVFYt5Q1PVFEazrAsuZxWzqsDFxN4lhmpBqyre9QV37Ug7BmbNDGKBCiWltvT7NiN7w2HopNUMQbpLnUVYdwCSot23uK5n++4dxo48ebHg6fMVdtlwdXVG+sHArCl596tfEvoegpRNtJXXvVidsW13JzZQwfIaVS5IKqEzKiUe2HJOHBatUNrkPvFI9BsgYKonRGVJD5xyBRNokniI3qZw+0CRdhonpoDukqhv6AJln6CSEXGB5FCCtuAAmIk5Ys8SavE/DDDmSJatcppwEtQ1TLXARGGgyJx6FBZVWFKhcX0PY8C3AV1YabFwCRMUOupjm4CPtJ3HuUA/Rtpe0J1NkzHfRIhHGZ2U4+mpGRulhN0lCUrVaFkwISV0zGiykymdVZZlU1JUVRZmBEM8sNj0IdcTUxJi2UMkKq9idZSEoYqURsiwiyJROYPzic7PcGOHH4VXFJNIhUGbBqJGpZaYOlLqIXYoHDp5otakqLNMTm4HCUGY6YeeECPOeZRJ2LKgrKoHNtCFiIuJwmrGLL45BhlfS6ZtI2FUIgaHcwNd31EgyF83joSUpAVFG9zoaVXPvuukGVuB1ZaqqCmqGeiSXeu5udlwv95zfvWEMOzpx4Hdfo93jhg8g9/hYmLwke39Oavlgv3mnKuLc55cX3F1fk7f7Xl/+x6jjUjxnFxaKaFay+jAEBIDHtUL+q2wlqowNIXGlDPqmaNenBHGnug9g4t0/chu3/EUgy1K5stLbAI/dqgUsVqhch1RKy3po/kKU9bMQ8wGd87F5aWkT8sKbUpihH4YKaKRlJXNgIpp00/e7qMDPgHD6ChKQzOfsZqfMa8b3DjS7lq26y3BR/p+ZL3ZMoyeiCBTxf9NB4OrUhQCBq2YNyXLRc1iUUAS/T83etr9yH4/sN32OCdAHGunwzVJlIwQjGstUe1ms+X+bs3d3ZrgI9HK/cToM3PRQN/3mVDgxHExWtoLlD4GepOxk8E4fleTNt0ky6NORogDlZrWYoRUCiJVlFGaAU9QilgWRG1wLnL3/pZUzqkWKzAz2iHy6t0tH318zqK55nsv/hhdLtm4gHZblB5Z1gq7NyQ0VksvYjSaB8eqFuBSZUtmVUVTlVTWSBUtRWJZgqmwFKyHyM4p1r1j9CFrBgZxjr306vngxVGe4P9KGH/QiiFFpj7L42hEXD8QvMPoiVPUS6tRlLNqvlwQhgtW52cMG4XrOjFeSRiXlDUPXUylULM5ql5IwJPPuIl9B7JzcmgjNGgixnuCH4BIOV8SlSVyJLlQ+T0FOhhympmDARNiv3CoS07oetRW1oQ2pHoOykjGMEprmE5HFrCUYu4gECk7/Izvev1BwJg8TnL/KhtAJXpTlhwNGkVZaGxpJQqsSrCacR/xvSdphyktRinKEcqksBhUUKQQiD6x2Y60XWSzl149bTRny5KkZbBkco4LIqlJJ04czhhlQGNMRK0O+n1RJ/SBnkBuZlVbLhYV9bwRZChiBE0K6OTpnMMF6ELEFJJ6SkoRc6o0RCQHnQK1CRgVKVSUGqG3bFjS7SNd6sF6UhGhskABsQI6AgMhjUTfoxko1EDyJaAOSLWUEj4MDMPAJmyY9L6UhqouacbZMV+fYPCBIkRsaXHBMbhI7xOegImSntMKSg3RjwxDx6bd0RhDoTRj38uLG2kdSMETXct2v6MfR3yKLJfnNLMzbDknUnK/Hnn3bsP9fcuzF59w8+Yl65s3dIPQbVkVWW+27LuO93drLs7PWS0WvF/O+PCDF5j4Pa7Ozgh+5ItXX2CsOZD8T5fJCMbSapxSwpEZhUVmGB1uGJlV0qdoy4ZmpbkYBsa+xQ0duzfCIbrZ7QloqmrGRVUxlBVh7IVbNAWhrzIV2pbUdU3ZLAFFWRbMZnNmsxmLxZyyKKnKEqOlJrdve+q6oIgWbaoTjN205L4hJEwiB1VWlvPzc67Or6lsiRsd6/WGplQ0TcF+33N3v8WFgNKaumkYvcN5aZ4Xjlxww4CtSy7PL7g8r2kajXN7+m6k60a228BmM7C+73BOPHMheZDF44OT8oYR4Jg2mpubG96/v+X+bg1Mz1fEGHDesd/v2e12UhM8PTeMBmsOB+kU4UxjoSbDpvTJYwfyq5NXioczUikYo4PgqGpNoYXcwANOK4IpSLbEDXDz5h3j7JrKLrH1Fft+y2++esPV0x+zWjzlP/qjS3STeDME9pt3DD6wqhOlFfCd1VJyCY+MoNaSUlzOlsxKS1VYZtZgkL6+sarRc+EU3r+65X7ouWl7XMictOOIH3uC6xmHATcMpOAOfdRTa4BPMB4OepjAJynTT2oSpilQSlo0nJcvFCzPVhRELp5csSPRxUhAAoJxHNGqIJySGyiFWi7RzRlJK0wWwk0nNVwtMvcS2BuJ2NQ4YMYRVKQ5XxGVJWBysC/pVJ0jZ538dGgL0QCRSCDmx1UyKAzEiGMHSso0erUgaouPQIjomLN909hMItpRvgj3xwj391z/HpGgOmwAozVWSytBqSKlhspq6rqkmpWYpoLZjFTW1Moyqjlj8ZR3d1v80NGMA8aN6BCoFdjME3LXWd7fdvz9b25AaZqm4PL8KasyCRVhNgwhpQx8EW81TZ5AiLleAEFF0PJ4VJFCn3IbJurhnvl4x2Ku0U2BmrxWFArDWTCMLrAbPCEOKK1ZzOssyGrwURg3YoAYlUxuTOjCQwxcVpquKdhVJTud+/wb8TJTssT5h0R3Thw+wO/eEn1HdC1q/Ro37qHvCL4l+V7qi3hhyHHu0IOmlCacpnmV4my1YlbXgjRUAoLux5EiSY0wBuktsZrMVAJ3m3t8VdAUVkiyqxnNbE5V1Wg0McvDJDSb+1siWzyWL1/fMlSX6Ks9XR/oe8ebzz9ne/eOfr9mZpYCYig1bb9n3+7Z79akMNDt7wnuHI2X4rpSdH3H+fk5dV0TXXiwBsehR9sBnTSFtkKzlvkWVYyMMRDGgb5tqauCwlrOn30iUVmMFPNXVPUMW81pB48qI4vFnOvFGZXR1KWhKDSF1VSlOTh7B6SamphtjAC/cppK5YMixETXH/XaysJSFsLY8W19gkoplrOai7MFZ+dnpAB933H39o5uv+Ht6xn/+D/6E+bzOR9//JTB9/iQOF81lNUloPjs17/BO9G1u1g1rFYNz56eQRzo9wNuGOk6R9cG1ncdu53DhYAtbOYk1aJ8ogN1obm6OufjD5/x8SfPMdbw68++wIeBuilZXiypqpKyLLjfbBlHB2hWy0usdcDmsMdKq6XlRhseACtk6R7qS48lcB4A6VWuLhk5TAs/UHQ3WN8yW1xSmoC2Cm8UUWcKs/k5SSW6YUvfdqjbNVXxHFM8wajAvxstq1bxweyCX91+wX644fPtS8a4YkyXJP09ceRTOMzxIRuoFGfzBav5imUzww89yTmoSwYX2LaO/ZfvKM8T5VXFuyFxPyR2vRi84Bxj6wiuJ/qe4B0pBqmW5frblOlSpJy1OWa6JiDIpKCjjYC0Fos5ymhG77m531BrBdHw7Ec/5vqjjwh9x92b96zvtrz56j0hOCFVz5fWmifPLikWFyQNBSesSYcMtmTktE6URlLOw3pA6RpjNReXC/n8GUyhmOY2k1FQTnlEUhJHI5CIeMglLYuBGOjKJePYMfqR2dOGVNT0GJL4qRlAmaPJIOY0pqyPae55/R2t4B8EjJm8tkNNUB3ZYowS2rHCKEFrFQZVllDOSPUcG0uSWUBxDbskvYKmoe88oRvpYkQngTXfbT23W8fbu05SUWNgvffgIRVQJCFVdj7nypGaeQoBYiamngwE2UvOiaMHg5KAbgP7e2JpKMwCYyrRkFNi0LAGa2RbjuKGUDFmja/AmAKegI8eY7NSNxqVdCbDLahVKcK50RCtQtXi18akiKog+Rmptow2ENyAH1t0cox9Ra/W+CHhlaSeUtJyzycilFMq6eTMkF4ya+n7kZhTJSmLaKoQHsDYUxJqpsGN1BYKk0Q9xmjquqaqGhnJ0TE4h/XSFDx6j99tud9sqfcSVRhTUJTl4fVTEsFWkkebJKnUmJd9cAxjYnQ9bdey3qzFqIWAzarz2p/CAwUYo2zH2INthI1EZVowIPekalJmy49oSkxm0lA0i/MsWVMTkxJ0ZTIoU2HKkrIpqEojihrFgUYYPa0XODkYTL7HfEjnJMNEnTUMsrG1QkoAfEskiKg2FFbAPb1z9N3Irm3xvmcYOtp+wBSWZ8+uuLm7Y3Se5aymbmaAzl62DNWsKZg1JXVp6Fvh1O27QN9F+i6IkXaBmGA1bygr6VfVRIxKXJ3Pefbsio8/ecFsXmW5nUhZWpq6kr7XGPAuU7E1lvm8wJqK3X5AqV8f5t9mjlLZTvp0KmXMdF6xJzUKQWg/3KYC0BBHRyeP8QOFH6mUfObM3gER4fitKohzYrMkKCtUY0UlZ5SOrF0i4Jgpx7Yb2A4tb/f3kn7XJclGwGRgnHrAwiVYgIqysJknOWZwuugDOh9Jbc9o95hyy3rTsd31tJs1bhCj5/pICiMxjMLDmhI6JpJ62EfH1LN4WHPi8B/ExQGd+wmN1rhhoNWaewVzazAp0pydYc6WmBSxVY0u33N/v2Pfd+IMn9zXclZSzkuSVhToI8OdOk6Q0hGtIkVweDWSQktdRKqy4Hpmc69qrtFlxyepnPSMgZhEqstqK6UlJae0IqGjdBeolNh3hj2Jretp6CT7UcyJhRbKuwxaOtVlDEmchjSrvnGffdP1BxhB0Y875OVzGnRK+RdGU1qoC0VVacraopo5af4EmivsQlOUK1TzjIEFrr1j7jVf/eZz7m5H2rsd4+AZO0/bw/2m59VNh7aaWV3wy1d7LmaWs8pQxkT0gXEcUVZkTGqrkHgo0lTlQTRUDJEghiYi2pMVxvDuJbtZRXf3hssPP2Z+ccFicX2yWTUxKeaVZt/3QlTd7zHRYK1maHv84Oi6gefPnogUTl3LQZ8ilVaMfUG3KNg7SKagaJI09eYDGyyJgn6scD7Q9yPd+YKh23B/84p2W9G3a5TSuXjuMUVHjB4fAkoltFWcnq/zRrT/Nnd7uv2WfhglFRyygoWeRkAx+IB2jiEIKi4kEfmsqpLzs3NsUUGCsRvE8UhwfnnB25s73rx/xez1G+zlC35sClYX5zx5+hS3fsu9DqxxfPX6t5SF4exsiS0KkjHU80acFQ2j97RDh94KhRta0cznaKWx2hwNXIL9bkc3eO7WPZfPPqRsZhAzmbTK9QSdSNoyuMgYHK3bYm2JtZb54oL5bMZysUCZAh8VvQtYnVW2jeCugoKohCKv0OpAiAxHcFjIIrw2182MIjelCwdp2/a4UePdyGo5F1b/bzGCTV1hlGK33bHZdLTtwO1mSwyOwmp+8PYdH37whD//i5+iiOz3HcY0VNWcEARwoAwYW3B+NmOxKLE64MaBbt+zXTu6ztP2nu12ZPQJlOajj59zfr6gMFKjMhr+/Kc/4smTK54/e0rb7um6nqurS7o+olXBF198icvOzPd/8APOzy948uQ51la8v1nzf/t//OtJfIVSC/EECoI+CrrmI0XmVZ3gug+Pne5Sqf5bEjp6tOupnKcOiaXWFDqRlEfrSaA1wHwOlbRojV7hIow+Yk2iROP2PQMd8faWulpTWs/lsmE7wH7soBhB6wz/lwjz+BEV85no/vmhhxjQAj7IXK0Bup7W37Lf7vni1YbtrmV/f0/wIzEFUEWWe1NH5yr/o6bUo5o0KHIkXWT6ORI6BIIS4gtbSsN/DJ6bd+9ZG8u6qJiXlllV8MGHV5yfL1ktF3w09Lz+7AuGfuTz33wm6dc0rWvF04WhXkpLW4HKAXB6MA8aASOG2xv6zR3duy+5fDrnrF7y4VzGevCaGCcFmATaE6Jj79b0ncd7OD97ijYVypTCg0yiwLOoNVZHNg7e9Htc+wb9XlMtL1g++YRYNiRlM9HYFA1ORJoS6tht+V2zoX9In6A6TNoh+sstQFZDYZV8lQpdFqSyIVWXMHuGWj7HmAJlZ+jijMungdQ3lGNLGFuqKtGvCsZ+ZGgHtuvAYl5ijCaSMEZqD/s24DvF8/M5utQYFN3gwSWqVSWLn4CPon5OEBaUGKUFwAWZoNORUQyosCN1Paq3mL6nHIUAV9jYBbTQZUj6vu1Y39zhXU9wA9vdnhCFvPbdB885v7jk0+/9UIxh1v4q6lq8ta7NbB49TSXIPunFkx0/emG8HxqDWzzFuzOuLs7Y79Z03Y77+9sMlNEkRkIYGfo9zo3c395yKh8ydntMYWkKg13N8aGm90EQXVoTEwzjyH7f0e07/DDQ2MRZXYryvBaVcJslsEKMOO+I0UOKlEaAH4WBvtvTtS3OJc7PLjFDj3//W4qwp4gtd18l3DCwXUea2UxEUI3BZCaTECJ935NS5N39BmMtT8vqwMN4MllUhSapxNhvCeOeaKQ+mwMx0ULTBulEkW0QvaTMXa6hKJ3Ek51VKKMIoWL0DhSYURERRGiiwBhFMIKCVoev3JirpOAfoyLmrIjNGoBSo1E4Fwk+oJWlqiKzpsrMMw+v0Xn0oBlGz27XCWn60AllW7L85uUrlFFcXqz40z/5M4zSJA9d17PZ7nh2vWIMDgxUtUWR6HY7+i7XSmOm1wtBdAjLksvVOT/8/oc8vV7RVFCXlrosuDpf4UPgzVcvScoQIhgjkP9Caa7OzgGpCS2rmsYYap0orPTcns6XMpkLNLO6TGfJZOSCdBEQ1TFRKjbgCIaRw1cRvcP5kdBuiSGikmJIStqgHJRIK0bSGhsjCofpNoS+J7kRwoiJDuLI6Fp08niV+It/+lM++fhHsPpTfns/8ss7x19vDH1MUtuKiWSPc5ZAmFhMwiohAzAafHCcX644vzjnR3/+JwRb0WN48cVb1ts9d7e39N3A6DzDGDJ/a8S7RAyiXRn9kMmww0mvvlD5JThGP86Bc9koNQx9x837G/rO01Q1Hz1/hvYKnSzezXBDyVAUtG3PGKC5OEO/tEcWn2yslOtRY6ZPzKw4xuY1j5z1rm8Z2g1vfv7XtOs79vd3mP6MeH3J9z75Y4ypsUYYmaa+v3HsGfsd669+y3q9o+9H1IvvcXZ+zdX18wykiVg8lUqoMNLdv8Pv76Df8ubn7ylnK8J2x9NPf0izvCBoIcMIuQ4akpz7IUHpH6nq/I7rD2qWnxbo9KWZyLKTIPaMwlgDRQFFRapWqPoC3VyjixKlK7RpmC0HVBXQ7Zzl+RyTWsYiMHaWca+ptGNWWwpjcEkiqkJJ57v3UZpIM5KzHaJ4ncocXCmfYqa2ioSQUxQBXG4qPr1icsQ0oH1PHO6IfSD1BbqssFbAKW4c8Ps13XrLbtfy/u072t2art1xv97IQjQKN2xpd084X63QFxeY+fxA92OMkRaIGAg+UtQV1k5pTHH/KmNwVtS7Yz0nxhmz2Yz5YknXtdhqTkoKYwpInhBG2vaeruuJqXxgBEkBowxNZakrkWSpvUcbizYW7yNtZ/Cjpxv8gXoLJtRbRWELtBKE6qRmHTI/3QHwkRJ9u6fvOpyPVGVFms+ZVRY/K4lDQ1UWjC5mtQEHylKaIovqGmJwjMNICJ7Nfk9RlFz5jHl8VEKqCpsPTE8Ko3ylQhCSSg6IicAu5dRRQhGCjI1TkXFM9CoxDL3Uw+oaHzUqwOjNlP9BW0uRQZ1JH8tCR+Z7ORhi7nPS+f1NdhQTSvQiU6DoRQKnKr85GvQ+MI6evh/ph4FhGHHBH+qet3cbVosFd/c7nv3wGctmRonmfn1PYeDJ1YpuHHDJS/0zRfphEDo1L3XVCU9mrWY+b3j29IoPnl7y9HrFvIZZXVGXBVrBer1lfb/GVg1KW5SSdG1VlqyWCzkcjaYpS0qjMUg0qh+pSExgNU4yoUqlw2dJuZd1MnZHQ5gOB82hHpsiMTr82JMSFNoQlBanN0jkghKDq6PwnaZhg9lvMH0LbkCFAXxH6NYEIro0fFz9OX/+5BnLp084b3YkveHnvWNwkJIS4615eF85A2szwYbRClsWLK/OuX7xAT/8kz8CUzJERbVYsNntub2/ZL8bGAZH28ncOOcZBxE9HsYR37eErPAQYszSTzEXdHK7RowEq3FG1l3T1Bhj8M6z3+7Bi3CASNtpUgyM40C7N9yvd3SDo5zNMKUVcMvhzEAi7SDGlWgyCEZh8vouU8KPO9zmPevXn9Nu7hnalsqMFAbC2KEqafQPmeAfItG1uG5Lt75hd3tP23asqoLGgrlYYXSFJmGVvH9wPfvtPf1+Q+j3bN6+oajuqUzJs6dPqJczkqmygEJk8B6fBIDvo8I+Egv+Xdd3N4IpCqtLyodAktaIQikqpagNVKXBzBtYXBKXz4irH2BWH6GWz7BFKTshKnS1h1QSiSxmMFeaVCpwBoYKf1HhR+h7URAPSWRE/DDih5FVI5/JO0NTLXAejE4ZlAKDT/jcIB+jIkZ9aJjvJiRuvjah4z4Iz6Rff8ldr9l3r1ktliznC5qywPUD4+097t0Gt++J+x39esN2veXVq9coBUVdsn7/klfzOZt3b/j4k+9zmQVHq7KgqkuGrgMURVHjhg5dlszmS0yOzgplpa3DRrzUvSlsw6ypCfGSq+vnMobKoo2k47p+z2a7p5p9foQyK3j2wRNW84p+6A90Qy44qYeVJd4pgdyvW+7X94TgmNWKpm4oy4ZZtcTaAu89g3MM48B6cy9pMO9x3tG2O3b7Le0Xn1GdPWO93hC2O4bNhs3NKwoNz6/PUX/yU/btnm27ox1a8XS9QyU5sKIbiSoQCNxttjTNDJUUddM8aJZXSvH0+gJtLaNrwSJgGqdyLUfSLipotHLYICrsqhRDlJLOIBpN8gbeB+rZnIAnrZYkVaOdwO9DFONpjfBBVtYcekinEonmyJoU4NAHpQ5tOLk+rDT3m56mFJKB2aJ5sLcSgm71MTAMjj6n3WdVQd1UlFXJOHh+8+uvePX5e371gy/55MUz/tlf/jmXVwsuL2rc8Ke8v73l/c0d+2Gk7XvWuxHvBO+8WJSUdmRWOj798AnPnz3jJ3/8x1yuKqpCU5hEu9+zft9xd7/Gx0RICuOR2qdSXFwtubpasd3t6dqOrutYrGYURUlIkd3dHTc3tyf1ZtA6onQgZa5PMshIa0lfmZwK1XkcDw52/tlMjyvFGAZcGPFEdFVJC1bTkIoKdMGFyYoISolw9bCjf/Nz3PsvMbsbdFKoFFAx4J2jahqefvQxH11e8OmTD6hmF2yWc+76GWfv3uKTpwvCQhLM8Z4UUNuC2lhsTAx+oJkv+Iu//Et++pf/mA9/+H3OL65AWWLSfPKTPyWQRKElc7z2fhSn0Hv6IeFdZBhGxm7AO0ffdXjv8N7hRn/o8x2GQQjcx0DbtnjnuTxf8OLFEz766BnvXr+nsoaPn1/y4oML5vOKYfS8f7vh5t2XfPb5S5qm4uOPnzA7P2e2OjvZXzAvCypr5H1dTyBBVNhCQJCMHbv3X/Lqs1+wuf2Soe8YncffBboY+PVnf898dUE9WzC6jhAd3g/c3ryjb/d02w1x2IPr+PUv/g2bu9cM+zsur55RlhW20PRDy77d8vPffEa/3TDutrhuy9i3fDEMrC6WEDuunn1AqQswGqO8ZHpCpEBTcax1/r7rD+QOTVkA8SQlilS0rAZjNbqu0Isz1PKKVF+SihXJzIjaHiC98oInLHQ5dYlPKB+xPqEls4k/SAUJWXUwFu2FJBifGzWVgGJiDMK6EQRa7JLCR1F79lHUJoYHRjCRosO7Duc8wSv8qCmAMA4M7Y5Ci7Bp13ZYNTKvAvpMMy9qzmbQ93u0NcyXDYX2VKWlth3J3TG2ieRqgjW4VuiKlNKMfiB2a4EO7xvIgpzlYimpoxQZ+xHnIy7IEZGUOhzMwtZRZVomT2RgjjvxtBXnV0suz+aMB72wJBFJUVLYEucS3gWeXDn23SUhOFRyXC9XnM3mNLoGDKMb2Wy39H3PZr/Lkk+Rrh9o+4Hejeh+T7tfs12/ww47fOgIwWGVkeNNg0+BTdey6/akmGiKkoiW+QsjPgVcCvTjiLElMReVHkdN81mDrUrOVgu60TBmyDk6p4mCRBoS8EudSCudW01kLYSo5P3cQBFKhIJL1nYM0hvpk8cbk8EuEZVEYNdOB7WSlKhWklpFicxqPKwsqZ8cMidhJAXPfq++LjeURO1EOenRS1mdvbSW0gr83hpD8IF17/js85fsd1vqMvHh8yvOFg2LeQPpnEJrXr2/xQeHUlBVJVppqqLALOdYY3n25CmLxZzKRpJ3hCSbWSgzLWU1R0chUIgZDVs3TQbDeDbbtUSXCuqmPmRMtDVoY0+DdybivVPag4M8jkJ0Hg+HkfQSnrZmqzyKKQrjkXeOFHJmpbAUxhKUghipcsekVokhRTkUjcGUFaaaoZg4TBU2gWoq9mfn/Mq1FOs3fJQUm9YJLWAMzFOkyPPjSOxO7ktEISIheZ68eMbVB8/45Cd/RnP5HKcbbnYh16v0gXJNBMAFGW60RhfSU1wUAqbyLhBW8ZgazULJIYgWagwCckpRSL5FJDmwbCouzmdcXS6YlwVWw/mixjnP7e3A69c33N5sub/b0nYdRSGncDeMtP1wPOOV4mLZ0CxmeCc0bomEtlCXBqsS+7stfmjZb9dEMvJeJYxVFIWhKjVVAaUJ7NZrhrGn71v261tpA3EjOgVMSgz7Pfe8RYVIu98yXyy5uL7Gx4jPqc3Be7qxz7rqibbvWN/fUc3mnJ1doJQgk103EpNkgKqiorHfpRo4rbvveE20ZEftwBMDiPRvGWvECC7P0atraK5I5ZJoGkRoKBLxgubKXjRRoK64BEOEPqLHCC5ROFB5wk2EFDVJWfwo7RAxc46qfIj4II2iY9L4pBgTjFELgXcI0lj92EGII8F1tN2e6CyhtKgUGdo9O2NIYRTgiY5CptxoVrMSt5zRjRXbXUdRlZxdrrCqzf1VDh3uce1INDNcrhctzi5Q2hBCYuxbCAFTFkQ0URmWzwWOrnWiu9syDCPD6NHaClXURBeHol4tsYWlNJYQR2ape3D4nF8uuX5yRgwRsrthlHBUWmMZXciKG9I3JPJDe2a2oDYF2osaxHbXc7++p+s69p2gdUmKbduxzzRqeujo2jWb29fMGEm+k3qezmhNIp0bud1u2batHG5LuRerNd6PuBgYYlZ0KDw+xrwxT9aggvl8TtVUnK2W+HsB6qQYstGZHJwp15aN4FQwDIloYuaU1QTvicFLoiln3+SAyXVl63MUrUVSTiuSyaK0COhKq4jVAbSgkCfO2ZREOUWlJFRO40CwUNnI6mzxtf3lvRg+5xwxSrq5LMQAVtagjaFzjrbr+aLdcnf3Dj+u6X7yQz764CnXZ0tKa5jXFduuZXADxipBMVqp9a2WK85WKz756CNijOw2G/zgiUqjtSUkjTYVs2WDyxmA0TmMtSyXC/b7HX3fcXN7S1FIv2RV1zljECnKkqIqOM1hmxSxuYVlAnVM8yNp5XTQIq2QBu0DN5PKgIcEPkb24wijUI2ZStKzhRXULSFSIk3lGknDJUCVDaZZUqCIpiLpAqwoa6jasr6o+XfDlt3Nl6Roudkrui5SZ5FaWb+J/oSbWOUSkEKM4PNPP+TFD37ARz/5M4It2HlNt+klC5Wkqc5olevgKusMZykmoylzHTWVZPkkdSxtTEOZByJNouBG40dPDAK+q0tFU8HVqkYlj02R9+9uubvb8LO/+4zNdk+771mdN4TYEEJks+/Y7NsHwJir1Yz5cpEjQUdKEWUSdWXRKTLcBaIb6Lt9NgIaDJR1wWxesVxUzBpBVr/td/T7Hdvdhm6zIXiPURodhWDEdS3rvmO/WdO2W84vrwQwV9Z5nkRTcXCO0mhSVAzjyGazpZ7d47pO0r0JXD+itMIWhnlZMHvkZ/6u6zsbQZPFTgUNqjL6ctIQzIxnKKKW1ghdltKoroTZW0UD0YFrieMaNd7DuCW6QdolIqikkeqCwLUjoi6RIgcS6pi0sEIo6QtJ0qAn1EISHNL7xBgTQ1IMQWCzzovR3LmpfUKKztvtDmst95sdZ8sZdVWw3eS2Au+AhLWWZlZip5aQKGCZfnTc3GywZckwjIRxhzFwvmpYm23mdCzR2mJtwdO+pygqUJa+3xPdyDZ5/Ch1m+dxS1UXFBXsNy3dMLLddXmcDYkSENHL7a1hNpvxyScf01jHvPQHMIEC5gbOCo2qxOhppcAHrJY6XCoLqXUlhakqklb4eIlNSu5v7xne3nG3vueLl1/S5eZ5bUuS0txttnTjSNSGSgVCd8+73/47Gh1Jw567u7eiK6lV7t8Z6YeO7V76kqqyJBpPoRXeD3hgRNH5gPWeMUap7UysK4BSmk8+/piyrtjsdtzev80iw1FaR9IEsJAUpM9Okk4B5UHpiLNJaLwSlEGU2JMXAoYCi9Wl1JCdJxGwVlMWBV51gtOb6t9KfiYFUnQURVYV0Da3XSS88/ihx7V72vu3NKXBvXjCxcWZOH4nV4JD2poU0QpmdcnZcs5sVnFzd0NKDls5Pv34U1aLBWfzOa9vWu43X/AXP/0RF6s5z6+uGJXnbD2jmomxtsZydXHN9dUTLi+uIMC7d+/57WdfoFRFVc149sFHrC4umS8XKGPY7bfc3b3HjB3ESLtteX+zZrPdYW2DtSVKl7x9f3tQN1idn5FM+QA/sAwjpR/RymRCC5VTn5LmNJnkQqPQyR8i50Nu1Bg679gNI75r8cMAIWJSolCJGQrnA4aBIgS0jhQEbhLEcob94I+JT76PCh6XpDiplcYqTyhGXs+3XLgec/ue6l3HdrTcDQXXfs5lUhADPsE2ej7jkFTBpMR8VlNfX/Dip3/O8skLfvlyI4ZeKXHOyDXFDDARzVW5d6MEeKczx6/cspypkxGcuJSVnhbHRNWmMdYKEEvDclFQaCH32G/3bDc7vnr5lrdv3rLd7NhstgyDIwTP8w8u6LuW//a/+W/567/5Gz777NeHGF0pOJ9XrJYNMZY5cwXaRFHGSZFV/WPOlnOeXF/y//nX/4qh77iqS/75P/vn/OAH3+fP/vRPUEqQoefnM969e88Xn3/Bq97R+T1jL/XOcXQYbanriuVqxfe+9ykX10/48JNPwc4IKOpqxlef/4YvP/sFt2/fUdmSp5++4Ic/+imXl0+wtskOcORsJb2ry0Uj/ZLj+gTw8/8jI3jM1svPCWEzkVpbEtSZk3RJHAb02KH8HkKFigUqFeAH8C34nXy5lhR6UhiQDkgRBk0pSNNjiiTigS0hqeNnSEp6aibeuUO/SEq59UDoznxO67icDnXxIRvlrh0oygHnE6MTiqRxdLhhYBykOb4sAyFqigQ6JWxMjF5UGIbe4YPCmIGu7UVM2BaE5IgkRi8oyKIoqMqaqqwxtqTv9sTgiBrGfpAUzN0tdW1pGkPXDgyjl+bwvFmk8iSp0zEAydPuNzJO4SF7f2EMpZX064G7eGpryR42GZFXFNLnEhTgAmkMtF3Lvt2z2+/ph0yHpQ3RSWp63w0EElpZdAzEvmXz/hUdEcaOrtsxqwtsVbFcneFTYPG2YbPv8V4QXWg5GApjpthK1lM6UqI/hpCcnZ9jiwJrC1II+HEk+ESyQnIw0dmhotSh4pR1SPI5yVBqrQQYoxV3N+8pdYEOitVZI2CmBKNzxKiwKlJajVEKFcVgTtp7MUWJYt20HkWiaHQjQ7tn7Fr6/Y7u/oZ5U7JqCrq2Yxwf6p1N7WACrBEqsFlTY63OrCwDSUXKxjBb1ixXCy7Prxl3O6lxRUXSBlMUzGYVPjRcny+IEYy2nC0XzGcNVVmy33UHcMZiuaSo58xXF8yWZ8IFqqF3ozg92jAlLGUdV8xmiwNPKXCow4UoavWHZZjAhogNQQxeUgeUOdkQ6iiH/2nAA8eIKBEIo2MchPZu4oicdEuVUqIBmaH+KQkaPA57onNyD0WNseDHkandQFkB2M0KjQmR2Dredju6ULEPiahKQUMFmW8VjpEgSnQd67pmuTpjCJqwG7hvv6KZz6iqSrgzlUC0JsOmtdBBK0RwQOuAUiYz9cgIHJ+bnYMMTCGzogjoKpGSoipkTWqigMv8wPpO0p7v395L+rNtBWTlvPSvkhjHgXfv37PZ7mj7hww/E/MKE8BLK7ThkG3RtmCxOuPZi4/45Ps/wruBWdPwve99nw9ffMRqeUYiErzn+voahaLvBrabPSEk2v0dg4siZt3MOTs/4+mzpzx99gGL1QXWlMI9mhTz2Yqz82u6J3tS0Fhbc/HkBfP5BbacEYJUjVEaU5SUlQhcN82Muq6/qw387kZwkicSiaJEQPgphyR1uV0XoRiYbVvKu/cobTHzZyjtUcphmIvBG+5Q/Tvo38FwRxrvSW4LoTtQ3sQk0HhPJPOFZ+qe3LocZeMFdTzUYkoZTUU2hEoK0dkQuih6gsMJD1dKibc3OwIVdV0xetnwbnS0u56+7SiKgrpM4ErMGDBB0jZBiVJ93wawDhd77u9bkTAyC/pRDNuudwdwhUlysFXVBFiJnK3mtM7TdiPt5y+Z1QXny5rgBZzhAKV9boaVzZKSwg0e7/a8fhWpmpK+XR+nXEFVFVRlQUrk+kI8ROwcDIMcNsZEdKGxKIZBuEm/fPkF796vubm7ZXQjPkdN+76l94HeJcqqoK4rbHC47R2vf/V3Qv0URujvWC6ecnW95I9//COuXr9jt92z3w/s9j3ee3RlRXW7qOijIoaES4ijorXU105AFkopnj59htLSaOvGkb7b46PFUGN0mdeGloMjgypIUepMSuFjhmGYxG6zZru55+1XLxm3LU+un3O2OMcoocbbth2lTTS6YF5Yqqzjp1JEBWjKkhHFNig2vXC1xpi4e/+G3eaO7fuv6NqWdrfHdR3nqwW1gY8+fs7o+gcAkmMNMVFXBXVVcXl5nkECO7qxpagLFuczmmXF6nLFD77/Q7a394x9R9IFHo1DUVUFZ2pGXVwRgjAfzWYriqIgOM92u2O7b+nGwEfXz3ny9AM+/v6PMYXUPX0YMdutaCUqLZkfY1idnVM3C/q+ZxxHnBup6pKyLEkpcH9/x83NDadWUPuAcUEa2PXUGC2LVDHRRXPwr6casPSHSs9X2/Vs2x3BOSHEgEOPcsLQh8DWRay2qBjA9ezvv2L0I9HWmKJGa4PbrYXvsihIuqfWgacWrvtEGQOf3zu8EUILmGR8gKRFjeTwURXzesbZ6oKzJy94+dWanb/n3c0NH3/6CddPn9A0K1AWFGhL5s/kQJiQiKh4kvacFkFep1orUQKxWb0+IfV4Y8VJComyUjSFaCz4vqdvd3z+m6+4u93y7t0dw9gSwojLAJyYJMOx2+356qvXbNu9tAYdMmOJfugpOlGziSSs1ZgEzo344IXeb7bkw9U5V0+fYRTM65IPnlyxmDcoZWRdG8XzDz5ksTynnp3RDYmkXvHq9Q39IKWpZ0+f8fEnn/DHP/0JV9fPUMqw3Q2MfiQEMLrh4vIDmnrJ1cWHaFMyP7vG2IaQhM9Y9D41uigxRU1RzambJVU9/13m7MH1nY3gFFkpEmNCKLeSQpkEKVFZgx0D3XpP+f4rku+ojIHzD0mr55jqmcCT3R30b7MRvEcPe9LYk5wnOdEO9D4XgUMihJR7YyaeOUWI4kkEH/Fe4NEhTNx6p2klDhFiCEFqX6cOnYJZrVg0UJcBnVqilxSItYG6lr7Hskho63JqV2HKmpRy4+42kfSR2ZwEMTj8MOLGERUDhS2YFdLMOg493g/COVk1XJw/obR7jN6T/IDFUlHT+y7fX5ImY50wZiRGaRNJQYAjm8zVeH+/zsweMgabds9sJ8WGmOtrOhMTq/yY0mC09HiZUdKkClCloWwqMIrBDWijhEIqamI74EZpJFbaoE0SVhmrSa7j+vqMxfyKi8VHXFwsOT+bM5sXnC1nfPTsKZ9//hZ85Mmza1ZVwaywVE3NdnD4XY9CGGy0TkS3J3kOhlApRdM0xJgYB0e727Fbr+mHQDWfU84aimqG0tJ/GT3CwKHzwZNTTMErwHN394ahb+l2O3Zv3/Hk+jmzesbq4opmec44jqSQcEWiOqtZlGJ4VRIE6KqZMSaNDpr2vqPtO968fcv7rz5ne/sOt33P0A90/UBTzxlHz/39hru7e5w/AhJkbqTlwFqd6d4M6+09Xd8yuJ5y1lDNaqrZDO8d+/2Wt29esWxmnD254KMXT5nPauazEq0cY1diSRhdUdiK1dk1xkgqvhvhRTHn7OoDnr/4lPlsRVlairJAa8Wbt+/p+5aUIjZLSYUQpHbrBrpun0EbCa2mvscT2ZzpSrDbbhkombQCVQba6JzuFOYTiT6MsWglEaZDnNse2Lie7dgLwYRQJFFpTY1ibDv2+55NO2CMJbqO0N3R3v2aED1p+URSt8pAN2LKgtLW/GAxoyki+B279YbbLrD3c6LWBKOOtXQFyUe6m/fHdagVF0+uWZxfoG3FerNh3Y90+zVjt6Hban7z7/67jGwHWxQYbf+/7P3Jr2VZlt6J/XZ3mtu9zszc3dw9PNpMZmaRYmWVSlUqaKAqaCwQHGggaKCBJhoKGulf0EwCBEET/QGqiVAQUIViCRQooggys7LIzCQzo83wcHMzt+Y1tzvN7jRY+5x7n7lHpAeLHAjIE3jhz967797T7rXWt771fVhXz27xdV3jrLRJmmaJc5WIsbcN1jmWdcthf8fD4cBut8doPQu1L9qa7zy/Yd00rFqBn8fOczjsOfYd/djjvYxghBAYp3EBpbi/e2D0PW2z5ObymjgOj2DD49GjzEAMgWaMOGdpFw6UmclIKcsavVhcSB88Be62Hcfes1kvcJXGOVcKE0tKjouLZ8TgOHSJcfSknHj+0UdsLi7IuuWrtztSzIyDVMegRec0KrSuWV/cgJI1J0QRW0tF2MPnhN8N7A6e29s9Vxc7Xr5481gX5Tdsv0UlKFluQJwHgoKgMr7Aaz4LDj72I+Nui1YRu1iCEZUDk2vII8o/gN+B34PvUN6TfSSNkTRCHDPRZ+ZWX+kJ5lwqPpKwpQoxZnbQmCDT0ng//axApDnPvZrzc2NUwqgo5JryXjEWSEAnlBIdgpS8fL4SjcWQEiORmAMERVCQUkBljR9H0XEMouigsRiFzMKFIO+5EHgpRtmvFBPBBywwDp6x9wK5ejnXSSm0majSwu7JWSSaYow8POweVRZjCAx+FGhPsFAUeW5qxBTRSaFNgmCxOeFMxmgLVuOaSpxAyEV5HlF2LU3+qnUslg3L1ZJlXWOMJaeR1arm5nrNs5sVy2XFoq2wTlHVlvVqSeUMtbNcXqxZGE1ttDjZJ42zAYVARtYonEmTbPK81XVdVHJkBi+GIEPUw6RpKIFZWz2fo8TUYylKOVGy6sPDPcfDjuP2HhMTcRx59+YlpqpoV2tiFCHtcSxSaJyIOhOsZ5TCJlApkPxAd9ixe7hne3dHOt4TQiTEjFtdoLVhGEaOx15MlN+rckVsuAyXk+gG0U2MObFoWqpaJP1yFqur3e6BxhmUkoXTugrjaqp6IcP8KWKNBMHFYk1GbMmMrViuGjY3DRcXVzhXkWIqxsGZoe9IMVLXNbYISQfGs/6VKE7oqV2bcxn8jiXhkuPKZPx+j3AsJeJppbBFHk5Nc5yp+G5aqUSTccXBRHE0hj4HxhhmyBilsUphUmY4Huh3B7p9JzOn/oA/vsUfH6TaqldiIaQNOgScibRZ8UF9QWUSD53i/jhwOIyMwRSloDTDugpIPjBst2d3osJWFcoYxhjZH44cOmmf+LFj7A1ffv4TRu+JOWGtMLLFf9GJn19TYUp/vm1XVFXNol2wutiIQ8n6A26PW27fvubduzsq51gtVqAs47LloyuHuTBU1uJ95Ljf8/r1a/aHvYzYBFkrYiEWkiVJ6bqelAJVVbNsFyya07hOzjCOATsEQvAyohWEa2ALSgBi1RVjQrmqkIMSh84zjIIctG1FygrvM+OYGcaEMTV1u+Ly6ik+yPp1ef2MumnIOLp+apMUFxctiA5ZyYxqJY4XgdNan7JwRQhCnFI5oGIkRrh7OHzb0Pbtg2CIzAro07CrUUIVVUoxJIUZM4ftgMWTDjt08rhxII8HbOxRBAgPcHwFwwMcDoSdZzxmDg8JP2b8kDFoNBqjII+yYCWKYDaZFIrNSNIipJoLW7SQZ05u24hSTMoMUex7+pBOsEOG/nBk70whXxV9g3Sy+LDGYrRh7xxJTVNie7Gl8Z67uwdhUEHx61OkcJxXy8paclT4UfPlq4MMc6tURhUsn//qC8ZxZBhGrFZU1tI2VVlQMmNMoodXHr6YpDoGOc5+8ISYOByOc8UHJ13XEIMYw5ah5MgpMKQMKmZckmF/5ZwI+GbF1QdPOHQjm9fv6IaeGESb8mK15PJizUc/eMaTZ9c8eXrD3e2R3fbA69evuXrS8uFHF2w2C0gBn0airlBOUy8bKmdYNI7nH9wQR0/0nkMvuqNWWSosra24vGz55MO1wEkTUU4p1usNAE+ub9isV3THI3qj2e53HO7fMhx3VM2SxeoKUy1E8SREGZlQCm0M2Yv1y/27V/huj0oj+ztPGLb82b+44XdTZLnayKLgI+/uD6xcYt86se1BGI1jCqQYCcNAejiijj0ujMR+4HjsCfue5WrJ1ZNLPvn4M2HCdh3HY0cIj00/hXUt1/XQHcgktFEslgtWiw3LzQJbWfkympgCdw9vOe4e+Kqq6Y4Hnj59wrMPnrKoN7TtJc2z7+BHLy7oCba7I7v9kf3B0yyXXF8+wXshLKVyDwnU6VkuF3z00XPxrQyeYegYFguGoZNKrVQZWitiDOz3I33fczjsT8EiJfIvf0qqlmXeTMSojXNEYwueOfEAAr74BWqt8WiCteyfPGesaqKr5CQVXrrLCj0MvP3yc263Ox72R6oYgY7MA+7qCbppSbqmdRWVVqTjLVde8XxwfFp/zKAUP38jrZz+6OnffUXykngLfCjJNimJcklJWnLO3N7v2Xs4JsWrtz2dB20c+4cthD0//hf/hHEYCjwPi8WCj59/QlVVaCPyh9vtlt12S/BZWKJ1xXc++y6ffudTfvD3/h5vPv9L/vmf/Stut0eW7YIn11fsD55l26C7W9bV73G5fMbd7S1/9Ef/hP/qH/xDnl5/Qu0WVKYVtnzZ5xCjPAfBU9eW9WpD7kTIftpyzhyPAaWlfbLf7WUNtBQN4Yr1eiPjHDEyDnu0FmeVvhelm7f3B5ZNzaKpCV7uqbdvH8S2K2TWm6clmZJqWGtLTBZtWmHc6iQ9W+neivRa0PjoRWDBiEwnWfRGfcrEIEWCsLgT23cH3r7b8+06gr9NJTiNJKgsbuJKdNoi0nMbY5Seksr0XUITqfcDerHHNHfkSpPxEA7k4wO5PxD3A4dtoD9EHh4C45jxPlMpjdWKhTPogPhf5UikVHKxVHoRSQdyFoZgKnTqCGOEPiS6KQiGhA8ZH/N5DOThMJC0O/1sglHL/7QK5aKNpWNTspBSvflQGGAw2yt14xSMlEgkBUU3ZnwpNZVWGJPR2lN1oWRtUYgrWlMdRiZ19JhO2ngloZuDdcriSJ2iqIOcX/KqslSVBXJxpxbFiakYdFpLMEwJa5x8WcnYU864ylHVAtGQdWHLBrTVNK3j4+dPuXl6xfWTSy42G47HnuubJVdXK1ytRYlCW7nFjPRhXFOjrSYV8pHVYJ1h+3bHGBUhWawWF5LLyw1XlxeknB7RYyQQrvn93/99jLFsHx4wxvLixRd8+epLcTsYenbxlmYZMbZGV7XULllstlIYRfMxeoxKNJXG2IzBc/vuFbdvv+Lu7i1qcUlOmX53z8N4S3BK5u20sBq9NeToCf2RY+8ZPSjvWLQLLq+fEhYtbVuxXi/IOTMOI4fdnr7rSNk/fkZTkj52CjI7pzVVW1G1Na6usE4k5rRSZyQFTcqiBvLVm9doa1isViyaG5JSHPqR7nDEe5kh3W73bHcH7ndH8v0dL1+9nmfBKlcxjp4YxXl8t9vx7t27eWRDIVZeKfpHRLRYxNhjqQQnUedp81mWs6SQxU1Jf98mj4niAhO1JuqqPF9A1CSrSdrhrXgDquIkr7SiqmS4X6XIMchIVNKGrD3aWEx1iXEtYNG+J2Qv7GdlCa7CNwu81kQytcqQNT5a+kjR/kxkVZxedAYS6cwkNufM/W5PnTSjrbi43HChK6q65eayxVmZ0QwhMI5eIMQkdkFKlSo4R8LYczzs6Lt+TmCvrzeM/RVhOJDGERUy67pls1hws1xwUQuzWieFihDGxItfveCLX73gyy+/xKol62XGrupTcZCTJMXOoAuZMITJhPkUAjJw7CPKxsKQFmKiMglPoE8KT1egcY/TUtW32ZGSJSYl/pe7iNYdMQbGceR4HBijCLZrJeQt6xy2qmXEobj2yLyccAPyRHBMovoVspYgmBVWC8NXW4MKqRgDTIRII1ZReRI6/OsD4bcLgpkypiAFTtLM81BTn22M0iMcUIyDDMj6w4g7HmDhyJUIP+dwJB62pH7A70eOu8h+n7jbRglSAWqdqK3G5BMjM+ZUJHKyVIBJSRBkjgxQ9tFHGGNmiFL5jUXZXarZxyrtu+NIVANTZ36Gd0ogVIWMo5Q6VYhJyn5RvignO8vClTMM/jzMZnQAMxaslYkGnQoLzJ9BtqVnoh/r3uUpck3BsPxs8tFKxWB3BsEVVJWjriv5/GLPEqfsKjNj9iEEbOlNWONm6MRVp/dQSOUdY6SuNK62PHt6zfXTCy6v1sQLg/eBm5s1daPEoLUselprsjIoY3FNVUYeMsM4YNsGYy2H4wGfDFk3aKOoK8fFZsVqvSKU5GDalIL1es3v/M7vcHV1xTAMVM7x47/8C3760x/z5vVbHnZHjvudwChNonF2OosyDB9G/Fg8DjUsGidEGh3ZPrzl/u4td3dvuV5cQkoMux37hy1RBRZNLeQnrRg0ZD8QhwNdBK8qdPWEtm3Jpib4FU2lWbSWFAJ+HIStN44oFTkH5nOekrgoGuBGU7UNrnbYSuyOtNJloF90JZWDHEVk4Pb2lsViyc2TAWUqWdC6A9vtgXHscUaxPxw4HPbsdnsOx567B0E0tNKsN5tyfhWLxYIYRaA+JVlAq8oBAaWkBzzBt1PQmAPge2uOV0bGe3ThRSqIJmJ8QAdPwBAxDLqaDZRzFhJcNk4qQAqLNCaM0zRGUemIyUlMr9Fka4VtXFW4RQVZRoDwvcyFakVUFm9qeregS8LkdQpy0oRoGLIiZzHxZpJhzACJZE6iqDlntocjjapIjeHmwzXNYkXbrtisDDl2NHXLUDwujTEYq2cPPmOEHZpTIPih6P96xnEk+h6VA8H3qJSptGXZtlyuVzzdrFHKSH+xqG+FMfLVq9e8ef2W+7t7rjZ7rKrYLC+LsIX4G1prsMaQk3RbffAlGTelUSLXrhskCGYE2ZKB+ETQEZcUY5J+oR89rbNUlUCXWltiVOwPkdF7UbXJQZj+yRc4VuG0RtkKW9XYqiJnNTtAiMdgLhW4FBgzqqeKzEoWQXG0sMqVYi4WYoZQRqVC1u/fir92+9aV4LRQGwVZSWYXcpYB5JSxWYEGm0FrqdzsYUTvDjinQHlSFFile9gRupF+N7DfK4497DuFTxofFceccRrGAEsLtYbCv4E0+UZBKCSZVIJkyKIb14+SIe59pEvC4gzxNDpxvilToW1NQcuY7vyJszUFwbMzAVmV8QI1LwaPhU1ON9XZj2advskSJSuI5YKi9CzJNfXt5j+cPvbRslm2VGyPojkLFoqLzQVPbm4KI0wg08EHyZhKsDSIFY4rIwdGu2I6nFm3a44Pe1bLlvVKNEt3sWeMnjGMrNatDNAq6V3FENEEwphJUYavtbHorEhBdBCbtmK5XtIPA+/u71mvP+Jis8Y1Ff3BczgcsVpEsq2REYZ+GE7BvWyLRctn3/0On37nk/nh+t73v8O/9/YP+c53v8df/vin/NM//hO+en1Ld7xn7HfUyyWubrDayDH4gcrWtFXLp8+fkIj4GHj5es/bt1/gfrGguX4GIXIcEnUSyAWti1KSzEDmbIi5YXQ1wdboeoPJAyaN9Mc9PifGnLE5QQq0tWa9XIDOMxMSBL6eNDZNbXGVxVSWSKIPPQypGFgrcbnQGh29zJshTiRoQ7tYc/P0GWPf8erF5+x2d/ixE0lDnbnYOHKu6I9bXr/6FdvdgNaO73znM9abNU3TSi9UQdM4EW+YGJumxlrDzc31vCYMRZ+073t2ux3b/YlyPydsslLJHLDKNDrxO9XIh27gjW54lzxfRdHPtGTWOeGjxYeK195jE7iYqHKkzYZLl/jAWTSZuzigs6dSiYv1EmMzmEjveyFNTEpCIaNTz0N/z8PrwMPbL6jrFtdesr8/crw/onqYlL21UiXvlGqKs1ZDBt7sd6ztgkVzxebyCVdXV1xdXtFWMqz/9//+/5L98YH94YG+OxAL2hO8ICrRBy4uLrDO4kvvXivFf/qf/if88Ic/5OLigt/90Xd5enXFzfUFi6Zi2VS8fXtL148cB48fO7pjRRg8T6+f8od/59/jeBAW9xA9wY/FKimyWlywWa959eqFVP5VRWNFJP+0lGTebo+0sSr3pswo6lqTosYrTVdUuVKQNdX6QO87qmI/N6SKPulS+enSgNEYncSRxWhMvcA2DVlrsfnqB3zvySmhdQaV0CZTO0fKog2LjyJCoQxlNqY43gjhzVjpEy+1JhMIjf43PyIx1zZKzYVXTLJgogX2MEXV3UVQAfox0Q5eVNx7Q4qB0I2Mh8DYJ/ouM4wwelVGGBS++ET5BBnJeKOBVgk5gyRefBFFKMEvZZktEzms01hEKEEvFZg0FnLP16ITJwf3U1Nf/n9WvufMz2tWdJCKZ3rFN8XK8z4CaaJHn72GErvU2T7lXP6ZT/Dr6VflZ2n+Y620QJ1nR2SMiB6n4MlZz7s24fnGmJmtN8G7J+KBMEmtFUjVWvGINM6IQIFSNHVL5WqMsqTQEcZA8LH0sgx1I/spMI9UMW3T0LYNrqroh1EcQkqGnFJiGDzGiPySMVoo2X782o2stS6VSTnejFg+WcPv/d7fom5aYoY///N/xd39Pdv9kVFDikEe+iiunNZamrbl8voJKXuGceTdg7B3H+7fcTzsUGj6BLukGRXEZIUMo8BO4g1ZMyRLCJohj2z3e47HoxC/iiZsih5ywlWG5Wop9kJnN4xA7gL36bPESkiUIqWXCmnfmknNuyjTkAl+pO8H+n4gjJEcEZEELVJkfd+d3UCBymY2S8fd3ZY+DLy9vZufaedMoZ6b+e/JeTYY9uNQ9iujs8eqSGMh1YZl81g2jaLVqZSSZE1lXI6o5MlppMqKNZGoEqNKGAUXWpEbg68cPgpsrHPExEilNLWHhmUZg5GEVSsEHQqZHDMxxLI2iJSaUgpnRHw9ZHjYd7guUHWa4dCTRk+OhTt9nvjmab04C4I5s+87VH9E9T0PD1vxSkQzNo7Kai6un7G8uOA69Fg85BIAYyG3jSPjODKOA6mcH2Mtf/Dv/D4fffQRF5sLrHbcXF+x2Sxm1xZjDftDx9t3O0CcYLq+x1rLzfUN43hLItOPAzGK44uzIrw9jIHDsSv3lUbj8eNj1CmUtVQpcM5ijMJWWpSi5sq/oCooYhZ0TdtiuO4cWnplJXGQc2orgzOKpjIYV6OMw1gLygKG2ga0AlcVv0KdMa4mFi5KN6SZ55GiQKDeh5l1TCG/aa2xxlG5bz8C/1uZ6k6+X2mKggKnA4qxwINWgY6i3VgNgfY4sKgyyVliiIyHkX4bGYZEf9T0vlgIRRgTDFERk4KcOIyBkGBwoktos8aUGcWgMiMTjChV4JgleI7lyyfpWUbyab7xTP4IQIb+1cwePZnBphKIouDP03BwgRa18O5LjMuF8PL4nU8VzNTXmyrAc/mo9CgAnpuzUnot0yxkLj9LKZGLGaY2Budqzkh5ACjlyFlzPI7znFEISR684GmaZh7MDVGytZhk4FtlwGWs0TSNw1mwVqSRhuBRyrBabsS30UD0W8ZBxJ/F5SOzWZtCaAooJTJVy2XFZrVku93x5t0DKUd5BhT4GDh2PXVjqSuLtRrvR7q+e3xgZdMTWyYDKrNYLmnaln/3D1d857vf5Qc//AHrZctPfvpT/uiP/1u6sQdtsVfXorCfhP24XG94+uEnpDjQDx3vHnaMsef23Svu795iXcshKbpkscAxVlTWUCmNnu+9SOfBp0Q/brl/8xX9YcuTlUW7JY2rOAwyHF83Ddc3ErDPCneZAzUiIzctwYqMKdT06ThRYKyoACnryBFSEO/C3W7H/d0d+4c9VovixtA0pDRyt7udFw9Fpq0Vn350yRdfvubucOD4ReTY91z1V1xdXkiyUjuSKnyUlBBmYGZ7f4tWCaMzzkh1Whmol4Z+6WZEQuWMih4dC7OUiM0ykzeMIw+hR5mRC1txVdUclcZow0XjcKuW5BaosWfImZFESAEXNG7w1CzEMgv5OI0iDBOdDXzpwaU8oIxDmYqmbUla44HD2zfEcSCNnQzCR0pLSmDVlNMcB1XRhp2f0Zy5P+4JtiGaBfnzX9G+veX66orNasl62fK9z55z2Va0reOTp0tqZ6SAObG8mGplVXSXq6riYnMhVRXAJ9O9Xp77mFhfXLJ9OBDiF6Ch6zt2ux1aa548fcq7+z39GNl1R7l/tKJulvRjZBj33N5usVajlGEMR/aH/YwvZaTgiFa4CW4hRLbKnZjWox/LGnmyKg8IqmS0Ei9VBkIWDoYgNRVtK8jRqjXzGuuaBTVgVplKiWjHclWhTMQYaJuG0cu6cuwzo090fWC3H+h7j4/H0qMr0KeSBKauLHX9b8FUN2lR6o8FHjA5ywA7YlkzFAeHaRg0qUwdoOsD3S5T6yMhZMYuMnTQD4puNPQhMqTAmBWeXIJbqSJyBp/pE+ioqBVUGI5pZCTTc8701PQx04dMH2Es7KHJEWBiWL4XK2ayyXSRJ3FaNVdp8kBM5BRVTnpSkzXoWeRTqpTgqlzoTAy+/L105Cifr42VzMXY2YgzJgFEMwpVfPvISYTD0YRU5LMVxOGAIuOcZRx6/Dg+upmH3jP2MnJAyXArU1MvG9CUm0QyZmtqrHZUriEp6RlYY2jahs3lJU1bM8aEaVyxOrKsmqVYuFjFkxuBslKSG94ay/qiRZeCxWo308EXTcOiafj04yXf/ewznj275h/9f/+Y0UuP4vpqwwfPnvDx849YLh3V3cMj2PBr25wFijxV27Z88OwZ6/WayjlevHjBJ59+wp/+2b/k8y9ecH/3Zn4ILy4uaNoKYy2rZcMqLbm7v+fN3Y53uy13717jmjUhW+LYQ050g0i9WSXqMamQtvog2rXDMHC4f0ccDlzVFxz2meR7Xrx4Qdu2/OhHP6Bdrqjes1RSRpQ5tFKiiWkslamEjTrpTMrTJlBUgcGDD0QfOXYjD9sDb96+4y9/8jNIkXdvvsJYj9IRqoXoo2awBIw1KOX57OMrLlaOYxdpzRE9JPLRk3MNeoFrrMjEAS4Y0X7Eo3TC5IQrLGSjNMEHqrBDnT9heXrqwOCxZKqcSEYzqIaqamgXNZfrBZcfPqFZtKyXF1wsllSu4t/Xmj4m+lDaMVpROY0xFb0PhOHAYfD0Y6QPkZCTLMBDTwgjh4MiDwGVj6QyBE6K5C6QsiFihWSSMxSN3glHOx2F5pG1PJBHT+w7gnvgPnj2rqY7PnDXNDR1zbt3t6zWLReXS/rtmkVtMEgSZKzM2slcqOHpsxsW7ZLr6+uSHE0BUpV7e9qfjH+z59gN7HdHcRhpHKvlBeMQCDGzaJZoE1FVRVNJotsfD+y2b9nu7rh98yWr5ZLFwtDqs2SyfJqtHNoKWz6mxOgz0QeckRbFuq0IMYoCTZZqexwDY/Rl1tUw+oBPYWa0g6bvpQJWys2VeTIRqxRWZarWYRvH6mIFWe6vtq1R3UCIgcXCYb2MKfmYQSm6wRMRpbEUBfUbInQpcnv8N22lpM4AgQkekP0gZlBZyuKAVGM2gU6luvMJP8LYB2JhM3kvBBgfhOLqS5CKmVK5KaneyPSl9D6oTFQQFBxCZsyJjjTdJhgFfYI+5VIFFpfhjDRf86lH8ehmnplucmy5VLmPAiUS+HUWoozSaf47rc4yu4Il5rP3DWEsFPA0N6ElkInx6wRPykjECWbOoUflhDGKrCUj977ITykI3qNyJOcAWYkXYJ6BWZFNczL8nAsjNqvi9GEmyatMshlnGoyyOFsRsiITRJXCWuq6wViHtQFrWwY/zr5ybV1jnBF2axIPR6MbjHEsFm7WmLWmKsetsMZQu4rNxSVPbm64vrqkpE4Yo1gtF1ysV1xebmgbyzB6HuPMPAoe86xdSUBsmTWzzvGdz77DYrlgdxB5qJjiPJISQhCoxxYbK+cgGyECKXEs6A57YtZgFoyj9CxyTOLeARBjcTiJDN4LfFuUO7LvOB4tYezpDprt7oA2lnaxpG6q4kD/+JhUgaeNkoRBF3RFZYXKmmmmLqpE1hPDMOJ9ZAxRzJ/7kd3xSPKe24cti6XB1ZqmaUU3Vil0HtFGEVPP9eUSqzNbfcCajLOBVZWobaJWIyZ6TFY4rXDJiPBzgS21yThToPZCuDDvP2FSqiKkB09WiQQMxfEhJo1JmiFrojJEZRmVZkzC/nR6EnrI0jcvvqUxB3QKrGuNVZbaaEwPIUtLZQyGMRrGbE6Mby8jLSlGUWnMWVwQpkx4Qtamf8/3ln7UrQAgJVGnSZ5ufwfaEGOPbxf0dSN+eRcrRr/hqvb0tcUqaJdLrHOFhSvP2HK5kGfPi/D3FEymADgtuSlnDseOw+HIMHqOxx4fQmFTSoLjnJ01nEFaALvdlvuHdzzcv+FwfMCYzOh7KuvIZ71OFEKgsUYQg0JQSCGgtMVqw7KtGEYx155ZnCU4pFw857PM985+oBl8lBW9GwrcrDVJexH1J2GLO/sQspxbEijPMAY5RkwhYZ6YEWoeVJU1WoTxE94rhvAY8ftN27dmh6YyFDnfUOoMIVAy45TVya2ACH2AboS9ThgTiQmGMXMcM4OXYNanzJgzA4JF+yxSYROMSVL4DDklXCEkdD7hU6IrF0ppMaQdQ2YImYNHHKcRDFl6amoeLTjfvI/4Mchw5jSVPx10CY4xibWJKlYvKGZCQFVVBYsWp4qJtSkzi4kYJEPSWrNYLLDaYJVhUTm0q9h2XaGXJ7Jy+ODpuz394R6VE+vNBa5g8mkUkkjWmTDI0GvfSQUWvH8UED589oTPPvmITKLvBKac9hMFh/0Bay2LxQKnGwnuWTHGIz71xCy+h1W7QZuWqlJsrq4hSfDYLBrWmyV127BY2OJ9FjC6xWgJks5ZYZ4aN4tSV9ZxsVzw7/7tv8UPfvA9FosFi3bNsY9kM/Lh0ys++egp3/n4I7QSAYHfWAl+wzYNsj998oSry0s++uhDvvf97/GTn/6U/8d/9p/x5ZcvePnyJcYkgXoN6AlSKVBz9AO7+7fUPlAvReggpUQYgCR9rlgSnJTifPxDd8D3e7Lv+cX+naQ8WbFYLPlgseaz73+f9WbNOJzmBMtaI8mcNlhjsdqhUpkLJYJRxBAJw1jgeYNzotkbQuTYj3Q+MMREthafItthQC0W4gxxccNysaCtG4bunuG4JenIJ88Hhouad03CaUflKj55/kRY4MGz392TfaSuihEyBmcrXFVR1Q1VXeF94GG3w5afPVo4/F6e5gxjf8DnSDRmNnc2JmN2Hnc34r46FCd6ZpHyxsria4zBNg5tpn6lyIdpq7FKs9KKykaZX0ueY+4ZcxDxgXpNNpZ9P+JVYCSQ4iBQWjGQzYCKUBwMp+Z7uT4RFR7bz4hsW8KawOuXf8U4DDTtgsvLpzTtin0/cnl1wXH/lEV6zrJtqCrLar3COSdM0Cjr6W7XsV6vePXqHRcXS5q25vLyQpR1SssixcQ4jPz857/k9t0DXefZ/XKP956vXr7GOktTVzS1CJX3Ee7fvWG/e+CXv/xL+n7L6A+FLwDb7QM0Ld1wIjIpFIvG0DSGFKXipoxhLaqK9bLmg6cXPBwOpDtPHiJRTciWQxW5QTFK1mSV58RNFMBkfCxpTdYanQU10CTquqGtK97tRlQcUTmItqqWpD2rkRCFvRq9J4Yk719m1mMuPqAZcZr/Bi7Br9t+O8WYLNn+FH1TLnYoKRG1EG3FByqL3lxU9CFz9DJInxOMvgyuJ4E5x6zw2RQTT+avick5ySclJrPSjE/iE+iTlg5AEtukGBUhaXyRKwpQVGDyI+3Ts0dU1Mytx5ipqpigvWLEWoJZKK7s0h4RU85Y5IimLP58fmr+jCzzlTllaUKrgImJXd8Tgfuhw7ka6yoSosfoux1pPEqvzItEm9I9YTieCdxOfmVpDrbnm1KiYNOXQfScwLmmLKAKq424r6ckfcAJ3FUCyXkvZanVikpbdN3ywdOnRD+Qs1DlU4wioZaksrWm0JfLPGKKkUDCaMM4jmK6GwacU3zy/Cm104z9kcZqbi5WPKsrri+XrFqHzlGEk3J8DK/9mm0KlNKbVTPMo5RitVrx/e9/l83FmuNhz7/403/BP/ujfyZEA61YLhdYJSw9pk5HjvTHHVkZtGsJo8zLhTMZo8rq+fXdccc49IzdgeR7SAFXWxFNrxc8e/aM588/5uNPPqZt20dBMGcI44DGzOSvcokRZCHTDSPRB8I4slgsAC2KIKEMQSdROfFh5Or6kqqquLza4CqFsZq2XUiFiSJ3e7K2GFehqxodPK5uRMrP1WSlCX5k6DoZkdCaqqrlnCqNT5BCJqqEJ4tdkFtimxa3KFliOa503BKM9N2UP6JyIhiDaRZQtTTLlpwjw7Cn6zOnPF82o9UcMFXTopxDNw2qKLZo69gsFqwWDZtNRRpHtoc9d0T6DAMZpzXOOtZPN/R9R9pu8V4SSlWIdfM9pLLcv4+2PF2M+R4bfYcbxezY2QWKSp4BK5J3/f6WN8M92/svuXvxCyrncM7SNM2MVkiA0zTNAucsVVXxve99xmq1mA13Y0pYoyW4jyNvXj2glOP5B5/SH48ibA80dcXFxYrdcctu/8Bf/VI8J/u+Y+i3pDiW/qkieM/d/T1xIea906a14vmHay6vrqQXaJ3MyfY9F8uWRVPRNi22sqCtqOz4zDBGxiBrbYyCllVaE3MsPdokEwV5Kkpklm1ZleZPllGtjsx2m6mtoraay/VCtFON4XbvGX2QkbZQBBZA7Neipy/tmJm/lP4tOMtP0mMKmdtLpe+V89S6yiTNo0AmQ/SSlbhiYeRjqfamr6TwWZ/6dvlUYqdCbEnwqE8osyVKTjpy46Zy3CkJJBLzaZ/z9D0TueR0bwcvMy/Jiu2TQJixsLiKgWWSi2SsnNgU/DwXJWSZ0wJcvjmx+iZoNUsgJWd0kAvqY2Q39ixWaxaLFQlP8gNxPJDCiFJqrja00qKLWKBTM83IlGBzrhYDBZQtxrGpqK0bJQ1vUxaFqdcwLVuSlcE0umq0oipuFM5Ybi6v2O/uCWGQyj9FYijSRph5ZIDy97nYW2UnbLj9bkeKgcoZnj65FEZo19E6Q9MsWV9uuFi1NJWFFET3swyG/7rt/eD3/s9V8bn84NkzNps1Q9+Rc+DVqy/Z7/dFq7OGBDGIZJsGkUvrD2hTEdteAk1MQjkXlQaaalmOVRHGnrE/4ocDKkYEGJJKuG1brq5vuHl6w5MnN2V+8/EWQyBNRnpZiRrFPDcFfT+SCrV+sZDFcxI7SCmSs9yzIXgWy5aLiwuePLsmplFIHmhSSCQfEEMejTIWbeXLOIetKpFQy+JvOIyj3A8FXs5ljZltzSJEzyxKbasW6/wZep3JY0/SHkJExyM6J6LRYDXKWqwTNCaEnqGXajunXMy0S9vFWrR1sFhDXRfDbUUxMiXUCq0qrlYb6Hv6wfNAR5/BZ7FbUkazvLpA7TR9f0QdzpCfMziUrOS+OwuEubjZnG+Tjuo4eIyuUFZmUbUStCiMR7rjwP1d4P516YnP40iGqq5FjcqYs+mLzH6/Z7NZcXt7S9d1jMOIdUbmNr1HUbNZX3F98ZTD8cgwiN6uc5amrVAqMAw7Xr36JUPfS3IsArwYpefZzuPxiFFmDqIgQfDmsuXpszWrtsZZgZL7fsGqramtJaUCeSaFYmAYIuDxUZLEFEsVb1RZr6VlNc2VC9oZUUpIVVYLq3OMsv6E4GmsKDNdrBbSIzWK273Hh8Sx98QkVbm1WnrAKeKTF45hEiUz9d71+k3bt2eHlmBS+IwUOB1SUZGJkkTlXFRksmKwmi7IgpQLkSSmRB+TDLOnjI+m4PhTpSajDtMhyOUDcXeTE5mSmvt8SeYQGGPp5ZV+YJh6jFN1BrP+6dlBMQx9KefP7Uu0aCEWo9OpKhwnV+fgi0eYJqYTOWfqLUi1NmMp8h+lOB5D6SsVbb6iR5lTQKtA5cTQty8N1wwkP5Kjl5GQ8RQE29VSxGTDCYaeNukJWhpXwWKBsw2qUJGdFfWR68trYhJFB3EGL9qmg4Ksud6sWFYtK9fyq+sLUJrvfvoBfXfL/rjDWoVzGucMKbvSK7UE8XiiqW2BlhPJj3SHHe9ef8WicSwWDU+fbHjz+i3DYcenHz2lWbZcf3BNDp5FayVYpZHjYff1Ru5v2GTk45TZT+MF1liW7ZK/8+/8bS4vLvjud77Lf/lf/heklFm0C3IUSHTRttTWYFRkOG4BRV3L73NKhHEkI73am6tnhbmZGPa32DySjCwWwsDT1HVLXTue3Fzw7Mk1T26uqKqvB0GtNNbYuWoxZW5TjJVH7u4esM6yWDS4Vub1/OhRQfw6cxgZjzsO9+/o9vcsW8fyYoX34qsYgqAeY9/jgyemCcWYiIpZtFhVwPe9qAMBbdXIqIRSDH4kpogxjRCnarEFM9ZS11XRow2n66UUNBuUceToyaMjpiAzxBmx/xk6SBGdRlTYo/xI9gMMPcRACgFT1eimpamf09pLrq5a1ldXaOfYH4+0bWJZRa6ebKg6RxeO3L0+MB535GNHXV2xqSwfP1nz4DJxONDf35FSgCAEtDw11aYqViRuJNlQmRxHzrPnlEeGbkvse5QpAt3a8rDbcuiPtMs1dV4VuzG5D6fRl4RiCJkhBFQWY9xpRALlgIrdfmR7/8DxsJcendIkpbm63hBQ/PyXvyz6uppFu2IcE7fv9nzxxQtevnrB/d0rmlqss6xZMclsKC0CH8a6YoMXHz1ftV2wrBZctBUaSWjWyxpdMp7eZyqt2SxlPjF7z8PQEcaMAGOWHBLBR8bgZT0nS78X4W2kmLAqcXX9jCeXS55drxn6Hg0sK8OyMSxqx9On1/Q+su88v/zqwOAjD8deuo1asTAOrME1lQTbJAikylCd+E1/7fZbjUjABJVPMmFCg07F22/KYtM0TF8Ckk8iVwaSRYZJNHoixKTyb/KsglZ6wQUKlX5hUlNvr8CMZWZwGuTPJSjH83+fBSipWh+flhg9IWh0BGUkU7LWlMAn1Y5kOJFYvs8xCqxkSjZZzkchKp4YZvLJ8+dPElO5kH4ykn0t2obLiw3tomW/P9B1vThCZGl0Ty0KP80olr6e9Ce/uV8mjEyHUR6jHFpbBKZMAu3pwDQIHIp0lmRoYmNTWYtykJrIsnakJP3Y2hlCZUVQPFqiRqo/ZdAJYcEq5v5pBvw44ocBPw4sly3LZUsoAXgcPZcXl7Srhov1mtH3uMrR9SMpDnT9ifX6m7b3g9/7v1O5eBe6iifXT0k/TPzFX/wlDw9b0UhMJQnwnhQDOUX82KGNY+wPqCKJRwpIIWOkWsdAzlROEyvDMErylCOgRSIrWMPlxZLrqzVtW3+NFAPIQLmWioVyfVNOjN7TdwMxRKrKCqnGqpN4tTopBwUv1lJDf8SPPTm2YskVxY0kxCDOCpN3Z2EgqwILSrKVyNaI311VUdWVOB9ojXMiWlFVQn4qu1zMhSU5fB+Wn9jOKAO2kX5qjiQ0IcJhf5TkNQYxos3lGTe2nBNDtpaoFOPQow579u/eEPsebQzHoaOvaw5Nje92Mnpx98Dw9iti18HY0xPY+o4vrKHrBg7bPcmLwwtZWLblzpk5ARP3YX6w31s3pjnhnCMpSv8pZ0XOMrMno1By/FrLSFVWJ29B6fdJFWRKT1przcPDjnEMMmpkappWyCqFKlJIXZHDdi9i9JXj+Ycfi3ye1zxsdxyPnZBrrME4IbzlckwKyiyqPpGAypZS5u3bLXW9pFJLFrXCWFAp45RGW4WuRPIVpVjUBrJjDAuiHmFIjKNUZilEhigM0aQL2TErej/JuGXujwO2srRtTfYBZxTaiITlGCJv73fsjiN3+46393u2hx4fKWLeYvsm63NE51SgVYrE3vtzAL9++61MddV5UFECRyol/bocKYP00hiNSub0fBIdTxsluqWYJDONhc2T0twPnCrBVG6ohFSAqVR1clgTVEoJnKcKjAlKZQqo07B5LsPg+RuDoCrlpioq+Ypqfr2wNk9Qk+goKmGrQemZlOA0sfvKCjVRnSdZqRgLdkwJm6XqXK0WPHv6hM3FJbd3d9zePeCHQCZTN/W8H0qbwlA9kVFTSUreD4bGOKyuUHlEY9GIJY73Hh88OU9EGS3BncykflMVir6ugMaxrB0+RIiB2mlStqQ4EoISDUycBAMsSmWMUUzjICojvbKhx48D6/WS5WpBN3R0Raz55uYJzbJmfbGgGx2uchy6geB79sf+a/fy++4L3+benbISoy1XV9dcXFzyu7/zU375+ef87Kd/BRli8Ax9T/AjOXh8PgKaod5iVal2ybhSsY39Hi0rApXT5MowxHGumLSpySnirOLJkw1Pn1yybMVO55v2MSuFshqMImmxqBmGnuNRXB2M0SwXdTm/eRYWzzDLnB2PB7rDnqFbE/0KP8roho+JEDwx+TkAJh8gRglMxJLoKahERs/VNVXdlAU/U1lREhE7KwrlXZK1FDLBDwR/ZhacpXrOBpQ2oOxJBCJ5fAj4e1H7L+PGZAzoCio7X9+MoJ+x6xhHT384YrT050PwBVrV/OJnlTSmRqlmRS0lcDhsObyrePfqK8TEVkM2qNmAueyBovTYc3lMC9w1PWhn22R0rTL40Is2aAyEscgiuhqUKUFucl8xpR9oxBneCFzutGViT795/RZjCrGsamnalUCmOeFjZLvb0ncdu4ctdWVZLFo2mwucEwb2/f2Ww6HDuUquoauoivWbJPbTc1O+zo4ppcTnv3qDUg2tVVRXrbDfc8bVlspqGqexY0TpSFoaqkpj65qgDqAH+nEQ/8IxMOQgrhyoUhQpjr7YYWn48v7IkKS4aQi0lWWxqEmDJGe7dw/cbo+8udvz8u2BIWR8KomghuPuIJyBHNEqo1JGTxT7fxs9wak3IXBoibg5E0uOErX01GJW5XtpoA8F651ILbkExalKHJPg9mGq1LL0E6ehV4E1xTB3yipTqehiPqscpyBYLuZcHU4V5tnPzje5eeVBU1mRk8LPdXQmxTDf4CmWzNHIMGbdNFKpTT0wyoODsPykl1JYbFoXI1JP13UcDwdCDDhncVVNVddSqWjLum7o1B4fAt3Qk6NkVjGMc3Y6jCKHlLIwBUX8+rT5ITD2AT9GcvSIVmkWz7HuQOWcKMLUNf3Yo4DFaklla5xxhNHj+4HhcORisxIh8P5YemKJ4+FASh5XOYxpiVHJwLzvyTlSOSPkiZDY78WdIMZA3daYyvLyzVtCgnZ9wceLmnrhWF406Opk15Riw7Ibf221+9ttE8wlGq/Waj777HsMQ+C/+2//DKsNMQa22we6riNGLwbDvac/jBhlmR2/xcyaF1/oGRkheEge5TtpG2jN8mLBZ599wv/g7/wB/+H/8A95/vwjGZj+hgzVOoutnCjoWKRiD4kQRX9xvVqwWrQ0jVRgUzIXQiz+bJnBe3aHA1++fIFSsFy0s3JSCIHoe+LY4/sjcexJ3tP3I+Pgydpgi6O9KJtrMIZjYcXGMGB1xmgYeisnQCmcqzDWiRKPBn1+GyqFqZdo15T+W/lKUeYVs4EyGJ4LuWA+NwpZM6ZrrxRJyecmY4roMlCLrqoyZcZWJZLJqLpG54qYk4wjKY0hk5XA9TO9Pst7yfsZ6SmlLM2lObFO4q5ydi8ZLcmMIuOAGHUxCC7Ao/dICi8z0xN5TishF03tFK2UlEplzVNanlOtNMoUhKV8dsoUQl4iRk/bLEhpAwpiDoQY6P2AjxGjG1R25KhKW6fs2YSy5VLRnW05Z/bHPcdhzxhaFqtLVosWZ2qcFgs9VKJpM6uUeXKjGD08dJFjiAxxJNx2Mt6mZW32OdH7KPdgFHWwqDRZK15tB26PI796t6WxmrZ2XN8N2Cx9977rGXxkHCPH3ksbDCDJNW1tRQojOQpJzViwWuH9yG8hGPPbyaadYCl1ukEocGhZDGYx6KJRKeKnah70zpnCIC0EmqmyOwtoE8lHErA8f82IfGIm0JyKwHy6yPPv8gyXPvp6fOWZWKECbyhSoUNLQI0nZfnyuol9aIwppqMS5PQEV3LSFNUFvjxpjKpHQRvAj57DoSOETN/16FzqqCyM0pwiOZboV2S1MoWAog3aVjLsW0JxpjhBBz8fl2TzaT7mGXCeepiUX5fGtx9l7qwfBpSVCjTGOAfcaazDJrn+AnMX/7JJVNlHgo8lACbquqZatlRNVfplFuUMmpqqdTQLh62c8EKiB1dRN/W3ioHn1eE3bYUmIw4Ncka4urzk+uqKpm3YPWw5HvccDsciHJ2LUHUmBZndm/z+SgZYoEh5ME2hmzgVqauapmn57LPv8KMf/ZDf//3f49mzp6xXq288lgmCd4UEMJV4JomYODHRNI6qkoRqvnrTc5ayzF3ljA+B3XbLfrNmHDtJSkuVG/1ADAPRj4VmLgPWCY1rFlRG46bErYiqx7H0DrUWyrrKpOjFEUIbgdBTsbyZIemza6GFSajyxLaW8ycgyQkxKL2KRxdsGkeioCYKU/gFJ51crYuKk55Kmwg6yhxASkWvdEJlEmQhbKgpiKpp7On0PMo1EZZSJpVn6/x6UQTn7UzAmKplzteYqeotP0fJeqdUhKiKYLiSMndavwoLvpx0KGvLFLgmvkHOGa81Q2+5u3+H0ooQgohmpIxWsj7k0oN7TBqYJCD52s+dE5eOunZUTu5Ja0QjWCHHYEQDH5SWmcOsaWtDUxmaWot2eVZUGfoQyaMn+SiyeUX3MykxXxiCmKcP1tDFzKiP2BTRORJ6eQ5jPLXTDAK7Z5JA8Vp2qKkslTO0tcF7R79r+bZdwd+qEswzSJ7nt594VBN/anJ+R4FJiVFNVPWi75cFJg1ljs9nodFPLNAJ+54epUnvM5dMaaoU50DLaQE8v0FSKf/Pg2BK6WuVoMqTQRLzDRzm90nEdBpFEAjxDEdQk2yZo6kbmrqdXbPFbiRwPB4I3s8VoPeefuiLaG7Ce82bd7fsj714rQEuZqwSYYD+eJT9RAk0pU1Jt6Uc0cZRNSth7qqfl/iWORy29L0M5ta1xZqKlCCngDV5hmJF7UOw1eRh8NIoH8aeruvY70R3MzpNTpFmsaBRTREkV2REPT4mWbyrxkova+hn4fKcNHVTs9osWayXWFfRNA2VFWNRojwcxmnQEHNkJFHVFcvVdDP/99wKND2JG+Scef78Od57vv/9z/j//MN/yF/91S+IYaAfBkLIhTQRQQsb+lSVnDPP1NwDVlpjKsPTZ8/46KOP+J//vb/P7/3e7/IHf/B7tHU1u3l8UyRsGkdTSwJAoc7b2rKsa6IXUQRbmfKJyPUqMmg5Z2H7IizTt2/f0DSO4+EjJoKV954wDgQ/4EvP0PeDWB25lqvrp9RGYzUQRiprqSuHGSTTNjToNEAKjN6LQLp1TOSRNI0lxcfzdGWlmiHFXPqdInc1BZDy2jly5KILytkv1BwP5z9SSoKsErar/Dugs5wXlEIjKjNaKdI0VlT+XFPmjHMiJS02VgnICp2rQqwShuTjYXlFu1jhrINUBLFjwI+OFE7GwvO6wWk9U0yGUROH4kSsU1DEyk+oBUSIqbQ/8hyQFRCGjr0f+ed/8k/ndyWBQmN1hS4VZsxiB6e0Jmv5DGNKwmVODBKtFB/crHj+7IKPP7yhdgZFJKeRqErQnuugDDmgAKdh3Vr8uiaFVQmchj4bjn3g3a7ndtvPFWFSqkjbBaaUdMwwjJHdwwGXEzZnGjE/lciihJNgiDKHqxWNk8BX1ZbLzYL1qubmegFEFvbh28bA3yYIprkfpsqlLC3vR8ErUeDMLPisVH+63HRy9cZUDG8T+IxUhSmJhidCeJlvnDKiMI9GINWlVI/pFLzKTTNZcTwKhjMengtd/LSFGOZMbZ5RKhUmnL9exh200SyXK66ursVgMscyR+i578WcNIYg81sxMoz9HBBH70tlWWxnlEC3Qz8QQ2GIqaLO4SzGGgiZlMv5rhYobUE7MgalDEo7lGuFvXVaIVi0LYu2RU3vpUWeTYb7Ez4McnyFYk8hjpAhq0xVO3JuSCljaxG0XizXYr5LYvT70zCvNljtWLqWRJQg1ltykAc4h6UMNVdW6O5G7JZC7KWR3g1FrLvCNRUYhbGiNvOIY/TofsyPyDDn85nzeIR6fyHN87cZuZbXN9f8x//x/5hh6Li+vuIXP/+ZEAeMEaFjL5qmwfuZGDVtpowO1HXNBx884/Lyku9+9hmfffYZH374Ib/3e7/P5dUllavKQj3VoF/f2saxaCuRfirknJBEkaV2FTlJr1CpotBRdESdK67tOUpCYxQ3T2+4fnJNu2rFFNd7YhiJcZSKsLQWlKm4uLqgamqeXF9hkkelgO/3GAXWKJSzElBiwuTiWH9mFrtcref7YAyBunpP4Sd5SFZWhnSqqiTATGpLp4JPLs/5ylUS73K8KJhoZTLUDiQhPgkTJQpZIqaSuJYgq5VojeYJkZL1ShdiETnN7T8JJsOslTxVhPOmQBmLMkKAMdqgkxMWrMBUj9agqTqeguD8ftPtGM4VqFQB2t67n0uyehJXP+cdyFgTShWrMl2SvRJMdS4yj4IY5KI4PgWj6Wwbo/nRDz/mO588Y7VsRfSkrAfqbG2RNy2RIGe0SmyWDcYabm4uRGhdKw5D5tgHLvcjtXtg141s+zhLWFa4GUVLUcRYQhqxSWNzEoF6JLkyRhIaHU/kKWU1m/WC63XLZ8+fsFk5LjYObUCNr79tDPz2QfAwRJwJcxCc8hWtxDuw0iKe7ZQ6aUYGGVS1WlOZiTUos4Ihi/NEKPpzYZopY4ILpbpkDmzTz6YBeEpVl2doaGJ0JVJ5j3SaOyxyO4M/NYcBmQUs80JTlTjBqtN7TTddTjKvpznN20UfCN4zjD19ceH240gMElx88IVwkIpQdcl0y40alMgPBR8K2ikuAcuqEDEKbATSCxWs8JRVTnONOYWzC565fdjz1e0DGajcgFauBOuREEfGsSs9U1VmhRTLRYRs5JEyYgja9yMo6V1SBVy5Ze4ejrIQaY3SNdZW1I0nIixaPw6osujpSYy4FyUgpTTO1aUy8QxdjzWWuqqp2xZtNarKWOv46u39fF1SSrx48QLn3NcC3vsiBe8Hwm8SMQBh2xkjmqPL1RJVKvtJgHccRTB4UFnEGOKp4W6NoaocbVNzsdlwc33N8+fP+eijj3j69Ck5J7YPD+x3u7PiT6D0Fy9ePNqfcYzY3hMydP1AjAmNwKGVtQVuzGQtRVRKmbEXybQUpNemlPSmhjFz7Dxvb7cc9nthFI4j0Y+CSvRC5MgxstxUNGTaPpNDFEJQN6IKg0+StkwOCVuG+YdBoPCUEhe5nZGFcfTcb98bJRiP81zlyW9wIpGdXnqer5yCBWf/n4Wkok6vAGYhe8UkWJHI2ZfZyYIgGYM2BmXMKTCVIKG1IWf5fvInndaZaV8Bku/OD0vIZWQR3y77N9d8E2N3+s17xzYtL/ORlbVtWsemF81Vq5wx+a9STD3F6e+996X1IubCSmmiOgXZKcMQRFjmFVO0JA3DOJxFikz2B/r9He/iUdw/QOZAC6v1tEniEVOm95Fd1zPGRFXVxSIOfCeyfrkP5O6edBwIxyBM/yxz5bpIqMn9FAlBlHzE63QiRSaMU+icMQXaNVqBdyz1Cu9W5LEi9JbBKozR+H7Lt93Ub+qlKHUCAYz+5gz2dEre/+Y9uPnsX48/8dsQ4B9vf03759f91fz/7/nq/tbbeX/vtD+nKvJrn/rX7rD65l4R75+r91+kHv0onzGi2rqaIaXH5z4/uulLKP3a6+ZXTFUHjyurRwFn+rvzVe2vP+S5Inv0Pu/tQi5BYdoWi8Uj0d//vtu0KMZ46v1+02t+03Z+P4iIweP745sYrNPA8rRZezacPf/fFBy+Oaf9dbtlyqiPuIc8rn6/9sfzvvLeffH421PYOXuffHZs5e9TzoW0VbbJnPbf0vbr3vrxqvL4zn4UG77h57/mDTlXjVF6kpT45r86v4Z//fbbLGjffMTqr3/Jr3lBfnTP100rfbb33uQ3veUcvKdXzjfKqTc6jazlR3/19X35bU6FJFJyFfTEuyi/S0m4CPM75/xrD+FbB8G/2f5m+5vtb7a/2f5m+//H7TcFwW8Nh079WsHTz352/prpA8/+q77h+0nJ46//0LPvvyEcv//+32rL0n/8xo9TkjNOmbRSQvIRuOJUDakCW6pCKMnFrimVHsRvSE+/4UN/m53/bbZvqi7/9VPyr2fN37Dj712MrxUxv+56niWP37SH4ex6TeQSrU/9QMlk1fuF8dc+YIKVpjrhMYvvm3bsX3dTZwd//p55hrQyoik7/8Xp4fjGYzhVk5mz4u6bt19X6ny7PZ8f9kcQ5QzRvf8hp7+cqsnzykLb6hsr/LmYLM3FaW71xKCW9sWvreG+6cfn7YyzFzwis/1rbsISPs1AOme/dnV/w1//63/wv5Ht1x/41E6ZNls1325t/nZv/7XPeiQuch5U/g1vOSfCOPz1L+S3CII/+L1WPJ2oGQeR+lnUGaMzVmeWVmxyqrriEBNDTDz0R2G6aZGuctqwsBXPb56zqJc41c5Y92RjIjOFJdgYw9QPmwNRTsQ4EhL0QVG5GlDsD4NIpJFxtli+mBMTMKaEHz37Q8c/+Ef/nQx/A4vrDcZqTMzctBVP1wv+Z//h3+WH3/uUT59/wH/xz/6cL293fHF3AG1pKscPP7jgDz77iM8+uGbc7vnFr17yx3/+Y/6bn/yCu64nWTs3wwU2AZTolOYCuenCItVGz4P5ZWdnzUSUuINPEGaS1eLU3yqQl1ZC2tm93c4LwZObj3CuFn1IUwmr1FimXostM0oiDjDdlLo03GVGTFMa8blcmwy5eKslZZgo3dPohTpNPENWmNIvNvjyX2EEppwYk8dksCiWVtFWmkWtWFQZpxQ1Yie06wf+7//4j8S9Wmv+zt/5Qz549oTvffqc+4ctu92eH//iBa5e4Zrl7ISuygiDMZqmqaitpraGj68u8MFz6Hr+6qs3dP3AOPq5MTOJxKecGYcBpZSo71i5XnnKchSooskon2XIKAKKqm5F6qu+IuaIjyMpvMWZkc0ycH29IIXIP/jP/7QMnMNn31+LgXHlsHWLtYa2sUImAZ5crEg50YfIfecZQ2YME7FB5LNCyASfGAchSRljhNGnCoGmHKM42JdnbuotxTTPs7bNkuX6gsurG7JVjDFw/7DjcOwYhhE/HEk+krxQ/Y0RVvDmoiYOI3/0X/8xOWVs1fKf/K//TywvnmKnAIcCrcg+EseR21efs3/1mu3nX/Lse7/D+uoJH37yGW+/+oL+uONm85QQB/x4JA0HtFbUbU21vkTbimFMhMOAPw74hyMpdsS4ZUg1SRtSq7n48AMW15eYi3UR4zbSSwTiGeFlytcyiHSrnBkAHl7/Ff/V//V/S46Btqn4P/zv/1dsNgtSCkyqxLnonoqo/6lSSEWZRnroRW1LGvzlMT9LzCaroHKfzaMMZcdOBc17/53zrq+XHTM8zwRzqvm3X756x//5//b/JKVMs7rkf/N//H+xvHjy68LAN29nbGl9lmxkYBqH0RmGQ8cv/uIvqI2hqSo+/v4P0bYoA512bf7KU4wsC+jcRy7v/phBLH+mlYhIfPHjP+X/8r/7Xzy2ivo127cOgq5S1I3GKYtWQs9um4TTCaczq0lLsrVkH1EBBnTRqtNYY2hdxUW94OnlmtotUbTYstOqUHeFIlwWVSMkDVDCGC3q48NoSVkRlcVYR84K51yZJVTFHaDYBpVeSEgJP4zS2zxLca01LBcNN6sVn11f8OHlmk+eXPL8es2H12v+7u//Lp92ge8fIllbamf57Kbls+slzxaOd+PAYVHz8dWGy1XLkBO7EAuLUhdFkXLZchkriMgFLDJZRj/uO+kzEoc2p77OtAi/zxzTWpMfNToV1jisrdBGLJuUFjabmn5fgqDRJ9FoaVKXO82UHhcTCwxkWsmKjiGGaSgGleeZnekRMxnxnSNTaYvVGadFeDikQBcSlbE4Y1ioyOXC8XTTcNUqKqWoohzvu70p98R0H9Yslyue3NzIrJZ1NF++wzaLOQhqXUbtVEYbRVVblrVjWVd88OwD+qHHbrcsdgfQBmODsBZLsiQKQYVZiBK9VWsLzT6XBUchFPGMOI+LjYzNCte0klE3C0IKqKBR1YK2rrm51qzXlqHrH61jTWNpFg5XVZjKFmucSZRZsVqLgHUdI8kZep85DEXIHqislnkqD8oEci5BsFxPa80cBI0tiaaR8Q6lIMc8k73quqFe1FSLGtU4TAz0ORGNAmdQJosQt4/kIGLJdWtpVy3B6bnSRSkWlx+yuvoINwVBrVHGEYcB3x053O9I1QBmz9pdsG6uWK2esr27J4yR9foGUiCFgXDcilN6W1Ovr1C2pvfgdYfXR/ywJYQGnywm1kRtyI1lufqA1cUN9uYSXXRZp1GZOIe6LCS8OYd7XKHE4FFT8NCajz58wuXlUgg4FCZqmhipUxCTazuRdCRhkjdNUwVcru8pBz4hT1OlJIQfmGPjHCmY/zsVDvNac/bb8wp7LirK34RYUBSyuNN//H3WVx/yrbdZRkyei/NndUrAlAIdI/u7e/JPfompHPViwZPn38VUtcx0TodUJNmUKijNVBDJgRSvgvwoOM67MsUSlen2949+95u2bx0EQ5ShRWdAqPmyQ7IcCpNNRGRhJDHkoq4SwaXE5WLJRbvi6eYKp5fkWNNHjXIRreVGsFaC5eyNl9KskzmxPMmZvk9oa1msm5mlVrkSScviPp2rqYrSMDs5n8M8lTY82VzwH/zB7/KHv/N9PrhYEe9f4bs9d+8U/5P/4D+iWj9Br57KUapEY3qOL3/J4eWvePuzXxAOHR8uGp5eLOiS5+1X76iruswRnaj8MuR+UrRR6TRYDzxiYM0jHWmapSpybOWWm3RIT699nPGoEtpO95bMGCk1+URINmyynp0jTAZIZDNZG4M5ew/JtESIexJGyDkWR3RRG7EqY0nUjFgyRsFyllwy7HY9/ThgGVguljSNQQ0dzy8sf+v5ik9XFTUZhp4cEl86zXnC5/1IjBFnHYvFgtEHmX9iOlelQi7YXEqJvgssKpGoWq9XUGC2KYGo66o8x/J67z0pjXO1rYw+KYyks8HjWYDgRFcX5/UMOZJDR4qeFAfaSrNsa57eXOL9Hj+c5OAUSnwXrZgbRmRQX41ZhuiNYggjVimcUiydQZE4DKe5t0woHoMa78WZICtJolCqeIGe5vKm53daXJQV5EVpzZgCuT8S7jXNZinKTSmW1sAEaU07L5VLysIKPheUJ4vCSfDjrJCijMW4ljEc6Icj3cMt7HdsxpFqd4tycLxdc/f2cw77Wz66XNDaispaxkLzr5PG9j3oTMwO5Ud06Kj6LUMaCIzkCFEZ6CJxEHas8h6UFmf3szpv+golWM3BWp1Zcp0hmgpxYHdVTYyCBsh1SKd7cDoF5eePRATKujQnsuX5ntisX+sVzO/13qI+lUpMybA6+8yzS1SOQ00G4Gfv6ermUaiQ0Rh+u+1rwagA/1PMJZODZzg88Isf/xkXiwXXlxf86G//bUxligFt+UOtJjGi07pTEKby60eHcK4qJPc1p2D6LbdvHQT9oBhsRleeECQ18SFgrbhMYw1JazyaWosk17KyYsVjLE8vrmnqlrZecLsNjAGUrXFVxtgoF6nAnhPdWRmRpRJkQZcMHZLWNLXl+rJm7GWwuS6ZcEqilThBjVPgTGSiTkR/3odRfP/jj/jBZx/z7//B30Id97x7+ZKFTdTLS64/+pTl6grtGpKPxNCTSPhGQbXBXj7n4vEfDWUAAQAASURBVJPvcXz5ksMvf8lN3TAsPF/ZLRkZmFdKYGJnnVSkOpbB9tPNO23nFd55xfeNGd5Z7ySVWcpHD486e0CyBEBNOs0FaVnAJVaUTBCNIqCzhzTMlSJF81TU7q0kO1FgnpgCrjKYytHWCyqdMERs6IrlVGCMhmQU0SgOux0hRlzlqCpwjSJEj7WRhct8sGqoVOKojoRhoNL9o4d0Nhktwcr7UI5B6PwoRQoJH9Ks75pJ+LEipZb1ek0GtofDfP5iFChLoEI9qwFNC1dC7kWtDeQ460bqCQ4uNlnTyE4MQtGP3hNiJCRPaww6V1hV41NPio9XGmPc7FcZcyJHUeKQMZbErvNYJRU8WVMrw5PNkuPoGUMgM55sw8o1VkpRF++6MUR8Ehk2bWReLhVhFVE1QpSBjCr6vp6u78QvkEzXdQy9nO8QktwTCurW4pyhXVRoa0j9mXYoGd8d2XFLfzhQ1zVts+TZh0t293fsvvqS8eVLnvWe760bmmqEPDDce75jLwnrmmepZRkrFtqgLluMy9jW4o8jcQyMviV1A/k4EP2WLsO9kfGWLieO45HxsENvK7xVuHYhFZvWZdyqVP8xcuy6kwOMVlRVxWq9LnZHj/t6M9ogYmylepN77oTqnILapGg8aafKrLA85xOED+cV4XuBMMtjeuJj6Efl3pTUTRX4BIdK4ioIj1Kgsn70tueQopqO69sVUGfv83hNPdvledvdv+XuzUuO91+h+xoT9jzcvWalblhUF6cTOokpUCZipn+WYHe+b2qaIVan5U5pZK7x30YQTFERozqpt0zQ0ZR1lHmPjMIpgy2BsXWOpqpY1kucq8Uexvd0oyeNI8umKBioUqSnogauwKiMT3L1tRZ3cpT02YzVLFqLzh6vEkZpQohFoSQWVQQKhFCUy0Eq2bPjutqsuNmsWTcVu4eB0B1xN5fUyw3N5gpbtQLfxEgOg7xXVZO1I7sW3S5RrkIpuF4tiUrxdHtk24/0XvwDMZPUmQhvn1d83zTP9mg7A8LfV7uZ/u6bRaRPEIgkR/mkjqMTmVg0EyVrm0KoUhFFgDyWelFgz5xkhiwpJ+Bp0jKbmALKOHRKWOWwWipBpSIxiucakWLkC11/IGVwTkv1kAM+BUIS1Q2jpb9lKk3OGuMeH9sMY8VYlDrinAVPUEhKsoiLTnUuM0ei/eqKZqo2Zoa3pkDDWcIxj2FMD5fRRXiZWRdWl3s2Z3FqUNOAdIrSmA+SJKQUIDVF4UH0ab+W1c/oRS79I0Uo/UCyYvBluHluHxiayuGLhq730meKk1B8SSTF203slOR435uXLALG07FoVdSfUpS5wrLw+tGLgHyMQuiRRxFjNbYyVHWZQ43ptPhl8ENPiHt2D/csmhZ8Il0ODA9b+tt3pIc9jYJntWPheqLq2PYjla5IWnMZNKusWBlFfVVhFwq7qehed4QUGPqRHKMIq2g4YDC6ZlAirNznRBpH/LEj1aLzq60lGyNanEXcPsRIf+xmVCWRiU1DU9fkIhN4vokSzFTlnQ74m7+XG2nu/c1w6emroOzM0eP8JJ5ui9N7Tn24PN2jxbygvH4SxJ/kTFRSjyzXTqS+x2uKLDdfX2d+43YemIodlSryhNPW7bcctreEbseYRwYLx+OWetVCXpXep8zBTp+v0mn5m/brnCCm5uB/lvMXp3l+i2P49nDoaIiVgVajtCh2x6QYivlnpUXRoCm+V2iFbSzr9ZrVYll6SJoQEt5HtruBX778isXfesrTxQXV9ODFhFMRo8EBuwAxGZrNiphEeSWkQNNYNusWRXFeDmLwGoJITCllcM5KZpyyKGaUReFUSsPlxRKnAr/48/+OpXWsFyt+8KPf5+LDj2gun6GaJSkhCvljhyLj1JIuwL4LvNnvCRo+/OAJn7ULugSffu+H/JM//Vf87MVL+igD6WIdJeo0tsBOcMoEzdkgbwgBdRb8JjKNH8VoVzzsCuxX/nait0wPgdEGW6x8NAqdEbsRNan4hPL+hTwBJKXRekDhIRyw1lLrmpwCIY8M3Z6EVIJKWXIWB3ZbNZiUUFHNFjtBZQ5+4LDfMwz9rGYyCVg7pdiRMAdLHg/UGdba8nSxYLOqMes1ZrXEUc3nAURoWinFMA70gwiSa62oakfVtEWgYCDEVJSHskhaeS9C05Ojh/dzBk3O4lY9wdQTDFZgMWMt1rlSEaTZAueUYIijAiGIldA0qJ0kIJIjadSE3tIdepHlS+dLhAw8G5MxVklygiLmQIwiWm1NS1Igpj0ebaGpASOiz+O+w4csCUUhEU2J0ERwskaDsudwQhFgyGVRteVUZ7wf6f2AHmsmXUyRHUyzgH3OGWUMpmieHvYdu92B08KdOdzeklTHw+0tY9syNjuWQXH7sx9z/+JzVncPrFp4Vik+aiPa7dmOzwjakJSl2R65cIbL2nD96Yb6owXt967Y/4sv6L/csf/xTp6lasHw7DnHqLgbLVeq510O/NhXdEOgv71DBY/vBU6PWggZCYX3YpLtSxsmkRmDkP+aukGpnuN+Pz9bmUw/dgyDEXWYor07MVrnOvC93r0xhlDuMz1DqI+RnglNfV/Y4f0gKH3Cx4F2ctwAqYamhW7u0ykRB9AUSyctxz6/hQKjT+4kv3bL57dQPgedSjCXtckqOVekwO2rz3n7xS9I/R0x1ww28PDuJXXruLjeYKolGElkpiXangXA6ZjVuZURPIJOp/xB2mt/zTGcbb9FEEwEDzpbtA4l89AlmxKB7ApwxpCxKDS1ddTWYFWmG0ecdbRNQ20UTeW4ur5GaUvXjSSr5AGLkajEGiNYOHpxnk/jAZIsNofDjpwGvnqt6Y+DKOQXh4cJPlVZJK+UFnJBzqFkSqfeWc7wcL/lqnZcfnhFoxRt40g5cOiODLf3/PyLNzhXsV6vWS9qrNHs9jt+9eILXn35JbfbB/zhwNgdxECzqvnRxx8yjoHry0v+9Ge/pPcjQwhMNMtJx2+C9U6wnLTptTFz/8+HcHbDnVV9Z5XjN1WCAtkZQRg4QaKuVNraiMeZNZm+H4qdEmAjWidMDpissERGPxDHkeRHKicQacrCistKvPQqCzoFclIkrfA5EUB84HJGo7Doog8qPao0jOA9aRy4zZrPleZi2XI9LHn6dE2rFF16/ETGIInQ0A9iDVQqQan2RbJNZOr86WFWJ+TCez/fL9NCPo/MTIvI+zC0Erk+xSTIDoqEmqS3ULM8XxGflHNc7rGcMtGHU6AtX48eRCPixdYafFYilTdD4+B9JkwPu5bgm4bAWM4Hear8NDlPrEJJOqNKDF0vC+NE9Z00PSe0YHIqONffTQmdCnIw9QKTJMC5WNYIJC7aoTnGRwStnDO7uzuUGYl9z6EfGM0OtT+we/2ScbdFx4zTkbqOPPkoYZseu93T5ZbBa7YvfgU6YyvF1eE5JlxR1TUtd5jxFvtwh6pa1EWLf3LNou+pb9+A7mmj5qvjFWM3cOwHUDIeFXNiUFpIUZXo1yog+iKhOKEmWRLQGCUBfYTvlbVYLtFZ+nlWbZ2fh+m/WmtygfXy9D5nmzKlQptZolNwLZ83v/sJkZsS4nKrP9pFgThV2S+B9Cd1GW20JK1nf1P0qL95m47j0Q4z9yJRj3+plPSEh+OB3e0b9vdv0GkkRQijpT9uGY47fHfA1XXpX5eebNmXuW897Z8uz1RBLSYodA6CakK0vrY7v3b79kEwZOmnpeK5pyAECYIxlXk6wBWBZ60MtbU4o1A5EkaPVZpKaaxW1JXl6voSrQf63pNdMahMkUhAqYz2cIwwKk0eLDprcoKu70jJc3tn8UOBaFKU/dJinCoVQJx7rpkyh/TeBd7v9gyXKy42G0wcqawhJs/heMR7+Olf/YrFcsX3v/99NpsFxjnevXnHFy9e8Fc//xnq8EAaDoTuSEyJpVI8v9qQ8qdcbja8fHvL292O4+FQxkAm6O4Eic4V4NRDtKLiDzBOJKGzheqbgp567/s5CKpcDCfB5IwlY3OkUgqjRVzYh6MQGHLGVpAdaKIQZ0hiV+IHVPSYqsJq8FGYoZpMZZU003MoLF6Fj4FIImlVxNGFOGWcE9yeWHpnmTR4tgle5sxiecc2RcxmwYU19Ek9upFDjATvGceRGMTmSs5hIsYgaEHxfjSF4aoLESKleAqC7y320/Y++5bSZ5kCXM55hi1ngEvpE3ELZn1MIy8TmbMQSEFg0m8OguCsxjlLirIIavIs6DyGSXkUlJX+efTicxljnJOribQ03RE+CqN6HHq00WgzrSp6Xigeqx+lx4sr0o7ITJVtFjm8KEFRDKflawqQ87kkc9ztME6RY6LvB/oYGW/fEbd3qO6AVi1aZ0zl2TyFqg1406OiI3WKh+NLyB7nEmGvyX3CqA3W30H/FrP9CvPkAr25JH76Kc1+oA7v0KbDxppNfMbt7og/ShKgUmJMkSOgrKVplzRti9aGWMylAbIpq23Kpff82Cx4etLOH8XpXBZwoWwnosx8nufzfVY+zeesIEQpn92Ljz/z/fs0vxd45pKoJPxaT0RGXVCck7qRNe49OPM39ARLVDmvHJXiUeWopiBV4rKPgX6/43D/jm57i8qeHDPBW4Zux9jt8d0BtdlgEDH0aa70URAsHzrB9VOQnINgqTpVgUP1twp/sv0WPcGMHxO7baBpkOzfRVCTW4MEv7ppqEyLUopxHOjGnkOEF29HnB24WI682QV0veZHv/M7hLvPGfdviHFArFYCOXXElOiD4t14ZMiRq82CRte0puHpk2sWTcPFesUwCAOPHDCuwhiHqxuEyOE59uLETFKsVktcMzEkp4tmcVXL+uYZ7776Fftuz5Ps2d7fcrt/zT/6x/+Upx98yOryCR88/wSy41cvX/Mn//zP+Od/8sdcOli3FTfrBa9vX6N4zYsXX/LxZ9/lRx9c4/6n/xH/8he/5E9+/FO+ut+KPJc6BTKx7UmnBVSfel7zPr7Xp8o5Fwsn+XlKMqx/vmklzMzKKGrjsFrRWs1SZ1Ymc7VuSCS6EBjeHkndkaZx1Fiq0gkkeMaU0ClSaY1rG1xdiQbjKArwQmaKxdQ10m8HfAziaWYN1hnqtkJrQ1XVXF2tsUbh+x1jNxKHQDQOZyuiq/nlbstdGPAp8Acff4ymno9JKqJREgNycUyP+BAY05E8jCitpAd3tvBoIBe46/5hS9d3c+DIxfFCzYt+WWSmD8xZtFD9iI4nxuAkHK5LVl2wVc53ViUlfY0IOkkgGIeBpDwpP+4xudpSNRXWNRyP4vAuQUug0e7gZ9Hq9XqBsw2LZsOx25JDpG7FSSFlCNHKuERI5OL/6LSsJHJWNCoX7vBsDZBISRXzWxEQt5VBFaqgjqBSghjJftIBzZLcGlBYnAVnTydBoXDtFcurj1lcXXG4v6PfPrD9+V9ixoDLQO3w1ZKdq3h1r6n8gn214FBdcFg67p98Rhh3pLzn5uU7hvHAcLxn+FcvCS+3hLdblteaxaZl88MFdfcOt3yJNT15t2bxTmGHkbzb0x2PxGpLrB1HIFuLbZfU6zWmcvRjX5KVgKpqlpsN9XLNoe/Zd/2j46qqhqpumSb9pueyvGD+GaWCluokz+eXUs1k3neo0Keqr1SEJ4SCU1lUYNvpnpWPPEmHTc0RSr98Eqqero5Ug4Zm0T66D81vCoJnh3X+b4n7p+eNCQbNMB62vPzlT7l//SuOD69xOpKzIoaR48Mdh+WK/eaC9WaD1Qpn7czwLNMSM9w6J21l+dZnv2M6fjKqjGN92+23UIwRosIwJrG9UZqmLtVbln6C1jKbVjmZadodD8SYiUFEVlOGYdCMPmNtxlWOXGjhKkuTGRWxTkEykDTOOMgKTZRZM6tYtq3Aqs6R00hSUpXkAnulKIE5hsjxMDCGSAygtAwZP2oGKw22wizWbJ5+hCLSrC+JNUQb+cEPf8Tl9RMurm7ox8gwBrIybC4u+PCjj6hjT+sMtnEstQw35+wJYST6jquF44OLJR9fX7DfH+i8kImmIHceAAG5uc+qhHMdyq9VKe+95vQDuHCJdZNZVJpVZWmMobWWVkGjwTWG4ziwG4+kOEKOGBwWhS0PUo6J0QdqV6Fd6StaJwSoac7QqFk9Q2uFDyMxIr1CbXGVJSP+a4u25XKzxmjFLo+oqAjZYBtLs2hYrBeMsWNI8HAc8JECZ6uvHWvOIqw7OTukLGw7Y/U8YD6HszJfmlJiDAEfIqFUNUwQ5lkQlAJggv+UmBoryKmcZy1izHXTSHaNIleWFJDGfnnPFCYReBBpey3JiuFriETMYhqrqwY9ajQJbUtQQpM7WW61kmH8uqqL4IL4+lW1OBrkrBjHRDQZazQmy2JioyFrRdJwKAxpBXOgrSvEP670EkNS+ARJGwmRAVRQIn5f7BbEwDsVd5UySmIer5IJeb7sYkM1VZLFi3AyyO1VzX1Y89VtTdVXDI1i50YOKTG4DZUxjNqxoycNivS2JwRLciv8RY2ur7H5QvwrY8arhoAmqhajHUZpDAJ3+hQZg2ckk4zBx8yYE7qyxCQ93RQCJskY1m6/p+uPdEPHObjmXIV11RwC8/Tb82T2DAY9DX6f3Zn5G4LguftDOv/E6fY8r9jzXHFN7NATGW4ijEyeppNYQQmaJXmrqprz7TdWgvNdw9kjWcQi5r8/BeVh6Dnutrz76ksO23vG7oBKkaQUOUXGrmPsjvj+yNgdMdbRtMs58CmmIHgiek3HKrPJpao+2zWFmi3pvu32rYOgNlKq9kPEaDH3dNaSoidEj1IVWtdUVUtdC5vqOPaMQeGDYogZiAyhZxgN2Qqd3TqLrh1EUDGRVGSxcMSkCariorLE7DFuYFEbVrVjs1pRVxWVVeSoiUoy2tFHxpgYg7gpj0PPu9s9wxhJ2dAPCX82XwfykONq9PKS5x9+RFs7FouGVdJcR83HP/g9qmbJ+uqGt2/f0ncdtmr5/g9/xPXlhv3bl8RxJPuR5WJJToHDw2u8H9hvb1leXvHhpsE/f8qbV2+4C4F96UOdj0A8bo6fAqPWWtiMWktP6QzCO2eWnv+9Ap63iafrxOXS8GRRsXSOha7QxXvtIY4M44GH7R0+jmRk1MVqjVVC0hnDyNAPbJ6uqesaVxh1KWeqmmIEa4mpuGMoqbgMQPI0lRUneatp6obLzQXPbq5L/2VAp55gApebDYv1kuVmxVfvXhPDyO1hZMiaxp5uUaVAF2ZnIhNSJBRrqkktSBczVF16BipnsapJFTlGhhAZYpphQpUi4gl+dk+ksriHBAZyGEnJnBYxY9DZsmqvpceTMpqaGAw5WqYlMfhA7DOkgDKWrA0xZbTlayvNmBRBWUy7wvqBbJLETWsFbzpGdFY4Y1mu1lSukh60NhhjWS6aWY2kO3aklFHKUmuL05qmWOcEBV8+dHgvFY+zDlcZlitHaxW1FnZ3TIoxKwkWKROjZptGugQEiou6kjndnOU5thr1nhB4TIgjfLOkMRaVFc7WYHpUCiSrOdDycrwmfrHGNQquBu70liOaZD+gqpaMTc9tdcsxeg5vElZdwMYyfmeBXq2xYUl7N+AD7IcbjjrS+QXKNBhTYYwhDh7vI71K9AQJ8KMn90eyNZhaEaMnBU+VsgzSvzOMYaTf706wo1K4uqFu2kdQZObE4D6ptHBiIZxJ/cGpcpwqt9LwPQt0p9+eqnhmaHoi5Mhc9GMDb1NQiikITt9PnAhd1KHq9uTXOUGMMlqk5k97vE1BdH4qOUXx07FnoDvsuXv7ml/9/Cds371mPDzQ2OIhHD39YU+/3zMc9hweHlDasLy8KhXz2Xp2Zt6g55nBaYD+cXGqFGWU6DdG8kfbtw6CF8uaunaMIfLksuViVfGd52uOXcd2f8APHhaai/W6UMQzzrU0zQJrWq4uZLDeEbntOhIGRaaualReMhwOOGfQZsGiVowxo/vIplljraGqM6u2YdU07IcdQ6cAQ4xBKoEQiVnm0u73D8WDz7A7CovVGMX+OND3w6NG9YvXX7G5XPN2t2d9uSHbmn/145/RtEsWqws+/eF38Enz8u0d//i/+Sfc397ywfUFy8rSrjYcd1v6MbDbH7m8uaGtHKul47C9p+sO7F68wIfEldX83e99wuvdnr/46g37fsCnJP3L0vjWuiiSpDQ/OUopac6Xr2nfJ/uUybXgvMekFfyPnqz5eNNiTUCrHnJPHOEQ4DBmfnJ7y23fcdsdGFQkqMh2uyOFAG3DzZMrGS3wgbqusc5S1zWmBGTZTanCWttgjMFVFU1VMY4DKW9QlUM5gx0HKitO1YftFu8D727vMYVZ6HXm6AfCrkDVyrAbel7d3VFpy+PKXaorXzwaQ5RkymhhrGol+xW8L5WbPPCpuEREhBY/+sBYrJwer2Rq/vdU5WmQURClhJTRtjRNIyMKPtB1RzGTzVk8ICn9iZxRZVjdNRWL1ZKbJ9foaqDa69PTqxRVe0GzuKBt1jTVhVRaKjOkwBAi601Eo6ispaq0sPhyxhkFWZN8pqkr2qZmgZiaLlcLHJIV25jwOQtJqd4weM849jy5WtFUFkzm2bLhqqkwIXLsRh72Ha6RAFIZw/3xyH4c2fae3icGn0BrXOVYty0NCj1EZppISuy+/AXD7sjD2xeYHMlDTxqPLNqKZl0REjykgS+Od2z9SN57dl+9oU8DPmfwG5zpqc2Rq2aktbB2htY0OGpcuuLabbmoG5aHiDYO0nfZ2YaH5Dg0LWG9EV9LtQUiVidsOBCCZzze40KFa2qunzwB14CFrBrhEMQ9Yz+Q+5Pjh1KK5eqK1eZKKlt1GjGanuVzKv/jEPH+789uvQnzO90YnIXI01/nEkAL7Dp7NGZOFZ8u1SCTKMI0TJ9n2FQrQ7u4f7QP6hSDH2/T2EIJyI/2P6tH1aAuLbJXv/wFL37+Y776xU/wxx05eHofGOnJeqDb3dNv1ozHPbv7dyituPngGdbUaCxZTSbmp1A8BWrFN8/DKybfxW+Ph37rIHi5sjS14ziIi/B6UXG5bLBK+g6HLlIZodgOPhBCxGhDW1e0TVsWl4TKgcqNJCWzRxaw1pKsRRWtR2tEVsiaSG1l1KGpLYumoW1rtod7xpBJqSo3QnGZT5GUAtFHkjJltkvOmHManQVSPd8OxyPb3Y777QNdf4VRmdu7W6pjz3KMfBgih2Hk1Vev+fFPfsrbt6/pPv6QD2+uuVwtuNvt6PYH+r4XlqECYwQCDCGx3+3Q2mBNxZPNCmUM74rFx3Eojs2U7K6svzLjcyrtASbG4rR9bZ7wve3KKm6MzF9GMiEnDjEx9p7t0XO3fWAXPGP0hfae0UmqJ2sMdV2jlCLVSYKVsVTlZ0o97llaKzJfVVWxXC5p6opEIBk1y3ZpJT2xXXdkHEaGYWCxXOAqh5amEjGFMu6RycYwhiCD4/PywZwBn3/BOWx8Oj8zMHNuspwKe7RUkJOu4wmiKgtFVvPCIUxdYfbVVUVb1zRNg7WmKPecHN7fX9xyubZaaxkqX9bYWhPzeLa0QVU1OFuhs9w/SmmSyqQgYwyNq9BKiGcCWMr9Yo2BJBWWykrIY1mq+cZVOCa1oCCzmkqx1pbaWrxVPLvc0NaWIQRu1guu2xo1BCrVQcw0ixZnC5ReObrgue9H+pDoQ8LZGucsdVNxbBwu5EeLaBqOBL0lIdqxOniIHtM02NqSRs9AZBs6gtKkOPJw3BJiR4qBHI5o3WN0x+AirVbsnWFhGpyuaFTEmx2ddVREXHNF1WzoFxv2usI7TW4XaB+pAUPE6QB9ZOyzkDJ8xhjFwmnMskK3lpyd9EuTYjwe6eM5MUZR1QvqZjmbY8/XOk8EjTND3tLQm28tpkBzhvnN98vcXeMUAEvggVlnOMV4CgzlvtNIL1fP0OdpDRFizFQ9nYKgq5pH9+vcg3t/U9PeTQH8tJdSmU0qTGVO1nvu33zF9u1rht0dBF9aEkEKFA3B94RRvnwv0Gh/2EPOuLqWtlg5iqz0vH/SK8yCOOVTKThXi2fff5vtWwVBpeB3njdslo6395HVyrJcWK5XhlVdc9FCt8/UtSL2Dzxse/ox4bS85mZjpM+kLFlVvHrb8dDDm7f3fLD0tLXGrZp5UXImoVViVUecHbE6sXQVy9qyaCp8GBjHTMZSVSK0rHQghkwIictNBdqijKOupNezqA21NnTdGaUXOB4PvLt9y09/9pc0JnC5WvL29SsOg2eMGr284WHf8yd/9pf8g//6H/Dm9Ut+9N3v8MPvfZcPnjzhz//0n1MZxfV6wUfbW6JvMH5k6EbGMfLudktdVayW8HSz4fJizdWza/7lL37Fq7sHXj3si+BAntUrYow4Y4uWo8wE5gJ/TlDpRM6YyTKPMjOg36NtokajK0dQln3wvLu/5+dv73g7HBkURKNJPqIzrJqG64sLLi82rFaLUmWK1JwEQsPxeKTve3a7nQTGqsIWrVZy4smTG5w19L5jTAEfA21T0x87dvdbXnzxknEcqdcNN0+vuLm5YvK9E/TASRBsHK6yhCE8Oi7vRxkJgFnpQ36XOalKyIC4MUZQx5RKXyHRDx3D2OH9INBXiqdCcBpgL67ZxmhcZWjban6/zWbDYtFKP1AbcpIkYRgGGRYP0/4qcoIYJEHTJlHVis1FzWLdUlWnYKGAq6ah1YZhf8C6iDZWPj9ldNY4W8+u6DZElM5gHY2rScaRU0SFzHDo6Y+9KPLUC4JW6JwIxyOrzYrNcknqIrkyWCy/+9EHtE3N24cHrtdrNm3LcOxRboGuFtRNjTOahbHcKIH7Dr7H50xUiudPP6QyFnJm8D2fv/iK/1z9v2dh6kqByRHCgCWjQiCmgDIKU1l8GjnEkYMfabRU3H0M6O4IvieFOzABZQI8BI4pc8wJh8GiccrxWgcak4gvFjSXH3P53NF85xl+saKvgCtFu1ixMB+Ssifknv32K/b3d4TdLYwBRWTpFO26pb5e0dgGi6FSlj89HuniY7LVcn3BanNVBDzkQr7vRZkzM0yPAnUm3jHNy6JP+sIyo1gS3Pck0aS1LQzo4AM+dATvSTEVyT1hXjflvhSXlbLIn5niTr57IDODdbt6HPR02c/5Lp4C8DScMfUA5/AnrYcSAK1WHPc9x7t7Pv+Lf8nrv/oJcXeL1jKaJYLxIqyfxiO+PzActzSLJUet+OJnP+X66VPWFxuun1zKmsckiSmfaAorfcJcpr2cqkaUVKPfdvvWlWCOHZVJfPKsxuiEouP1yyM+RnyILOuMTpHDbstx13PoIw97zXE7cLc+sG41zioqq/D9AWILaOra0LSBty/vGYsEFBsni1b09KPcWMH3bLcWpTVfvHxLiAqlW5rKCr1cJfrhyOgH1ssldeVoTUU/HhnHyP1OURmE2HLGpBQWq+fLl1/x3Y+fc7He8NHHn8qArU/cvn3L29sHbl+9RHU9zgeG7ZavXrzg+PDAbrflcr2kWTT4WKCx3Y6h6xmHnqHvpadnLcpo2qrm0+aKdnnBQzfyk1evefX2Ha9v33E4HiElITNkqXpCgeEEBlCg9awbOg1+Q+lhzccEq9qxrhw6GQ7A1kd+fHfLLx+2fHk4MhSRQNHNFF3Hm9UFm9WKtq3xfmRCCpumLn3JelbUkIdJBABEzzMUwkoQDdiqEFRSInlPjjL72TSOqtZcPLnkgw+ecPPkCSmmMqwsvTmVE9oKS24MZ0GwHJxUVTLfNJOFSIW9qMp7BarKiZNIGaOIMbDdPjAMI33flcpNzteUrTNBUkoYuHXlWC2XtIsGV0ZXpB9tUdowTnNXJZDHGAU+NlbGimJg9Iq6MTStZbmqqOp0luVK3/d7zz9kvV4w+hG0k66mkswepYTinyKkQF05WTh1NQvFW0UhAEVu7+9keD8nwuAZY6A7HmiXjYwtaU9TVTy9XPPs+pK6qtDOUllD1ppgNNFosI4+JYYkaEhV5le1cdQamfcMIyFHYR87w6p6TLnXxqG0IQVxFFcploSqjAoZTURm90YTQUUCEZM9Kg0oFbGVxbUt8Xgkh0D2AZM9BkWtR5KKhJwYOkPTjBA8l9aQ6wrlLDpljFIsFxbFSM6GxqxpdGTcXjH2EZSm95nYjfS7Dm8CJoEeAuHYoR6xtaGqmyLOcLZGTlEnZw7HI0qVObyCdKAnG6ESOgrM1x33+HGk63v8OJJCKqIfEkBTSjIWNIwc9nv6fmC/fZCedQZXifB63dR88OwZ682GZx9+gHMCZRvtSsJ8YjJPyIm11aPHS9ihaj5OYB4thTkOPUrgTIYUR4ah5/MvP+fVi1e8evGSr158zu7+jhgDzlqZS7TgKhGfyDkSw8A4dMTQ0x9FzvDtm6+o6poPP/6Ap8+e8fSDD+TeVjJHqPNZz3/aQc6VYyTIftvtWwfBGEcUhs2ylovkI28eOkKUPsvCOXLKDH1mHHr6LnJ3lwljou8941rTOMWi1gQ/IhNrGWPAWjh0R/p+YBwDm6bFaCVKH+NYtAwjIsqRubvfEbPCmsDoDNYoGgPH7sDgBxqnqHSFSZE8doQ+cBwyoxXyTD47QVqLyszt3T3DKASG66fPGH2iHyL3uyOH7QPD/oEqZ1qlycPA9vaW437HOA6wWdI0NSlHBu/p99JH8IP0nFJKRbtPUTvLxWbD5ZMFXVLo5QZX1YQUGccB5bM8WAVmSVlslyZLpgn/nx64KQjm97RDa2uonCEFQxcD997z+X7Hq+7I3ThSLRrRNHUOkmSL69WStq1xztGHvlRaSQKJgio7KFDtbFNFKrN6qfQJg0BLui22RDJErXLCGsNiWaM0XF9fcH1zyfX1JcMgmpTj4PHjSI4BFQPj6OmG4VFvXvodk1PBmbB6AR5TlGwzxjir6TAHukTXdWVW0M/XX8nw0RQCBXIpzifOOZqmZr1a4pwTRSMnmXdW+ut2LkrmPKuqQqmID6Kt2TSWtrXUjcG4x6ocSimeP73h6mLFMPbEbEgoYla4SmycxkOBB6OnbZ3MfuHmfamNIadAiiMrlzgOnv0xsA8ZHwNDGObkSZNoa8PTqw0X6yXOVUStpcpIkaQVWWswBp/CPF/ZGkdlLEtXF7KrYvQDKWqUNThX4d6btJ56yImCZqQsFXoRSpY+OCQNyWRZGAmo7NHZowkYY3FVzeh7QoYUMiYHGSbQGoXInPU+kELC5cTCWnTlUM6iKovKkaZxKBIqamgs/P9o+88e2bIsTQ98tjrKlMt7b+iMrBQlu7u6h8RMEyTAPzHgT+PX+Q0EhiRmMCDA5oCcIbu7ujqrKitlqKtcmjxiq/mwtpn7jSw2o4BpSzgi4woPNzvn7LXWu17ha2aLOcYGYlb4pIlTRh88SQXU5EnbPeOhJ/vnkhaFczXO1cTTY/dEcssp4ccNyhicstS2QhlNUpFnmzohdgXPdr3jsN+z2W4YDz0hBHxxN5LGKjCNE0Pf8/j4SN/3bB/XpTgpXF1R1RVN0zL2PVdX18zmc5Yri6sqrHVPyBHPiyDyfDzDE4/aPE6/elzNPPu1Y5+I1B+tYBx79psHvvr1L/nqd1/z3Vff8nh7w7TfCUqhBNlS2tK2LVVdFdb+RJgGseiLicddzzB5slIMwwaj4fryElMVwpl6soE8/ZzPfl5VYNv//0+CGW72imAyN7ue2mmc1dhucSqIj+NEk+Fs1mFrS0WkWQWqtsI1jilnCipCUJqQM/32kV2tcD7SjxCiIWvwSRMQt5iUK7LKhCR0cF0ZZgtDygalWjKRpBJeJVSjcVVHHy3ToNjFzH2v8MGBcWDAJ/900ZGcNW00/TBhm4752RXXF5dCzc+a9+9uaLRhuL0jff4F2+WKkDyb8cCw3XJ1dcHVYsFy1lFbA1NgOBzYPW4Y+oGgi84sBDmUtaYCFm3HVTfni5/8nPXhwP16zX/z3/23fPf6Ld9891r2WEcAvFzpk3PE8bKUAvCk/xHoIgM7Avc5cEiJ32w2vN7v+duHR8aQCXVFV3ZaSilms5bKWtquxlgFKtHNOoIPjONITAEd5b9Q1Q5TRN3HqayuKoEtci4avcQ4HhhLZ9u1HW3XUp2f8fLVNa52XH/0kvPzC9puxuP9lkGN5Diy344Cm/7+N7TZM47+maOLHKo5Z/b7PeM4iqNOzif2WyoepCEErLU0dVU0k7LbO7r+O2dp25oQpDuNMZJSxhqHCIpN2Y1WNLWjck4+r+PDVyQUMchnNE0TWmsWC2HSGmPw0462tczmKz77/AXnlzOsk8YhP0sb0Erx8y8/5+X1imk8ELICNNZV1JXEOIViCpFjom2cQPqx2DLnzOQls9HqzPT5Kw7DxPv7LY/bLZvdnl9+k1gfRtZfv6VrLfN5RzOfY+oaZQ3GayICoWmnMYjTU44QghCxfApkIiZrss+EmNgfDhgFnTMs2pa79fpELFJKsVy0GNcKBBpkWjdZjPV1ylRGS/KGAa0CMffk6YGYduQ8kHPAeEMaarGay6KbFBRSGJyDqvGqItBiXENuZ9hFjZ5b0iTTJXh2D4/E4YFp/55p3DKGBMZgzhYo2xBn52RnyUnz+vXv2d/d8vj111SLM8j7D5ox54QJf1LZlInNWEPwgW++/kb+3Tn++J/+M5p2Vp5hIfFtHh95//Ytb1+/5v/z//5X3N/ecnd3i58mifGKT/e8nP1SPqdpPJFxrBXIXBUGuXWO3/zdL5ktFnz6o8/5z/7z/4IvvvySq6sVx9zQoxPVca9nzYclwCj40K63aO84yiuOf7cUHS273n/z7/81v/77v+V/+O//74R+Ik0R4wOkCVQmxCDNTvJipTlbcHf/iO/39NsH/GpJ1pZhu+XNu/ds9zt+9+t/z7BbczZr+eyLL3GmBjRZPcW3ffAzHt1mVP7h0x0/sAhmYNNnskk4o+hqRe3Eu3AKSaybyGCUxJdYh82athV7NGuLdZlSZG2E5xoNMUx4r5mqjLW1wCY5ivA+ZWKyJb9NoU2FNhZrLF2WFbfAcx5IGBWI0RFTOkFEKAR2UhmlJc4H9eFbVlou7Th59v3Ifhi5QIk1VIzM5zPG1YLz1ZKzxRztPVOcSCSMgYvFkkXbYoFhvyeOA34SS6+UIk3XirygEpd9Lbb9su8xhqYWXeWia/nLP/szzuYLog/c3t0x+gmsIatctJDlgctPLhEy4TyfhuTVa81jirzZ7nm933PTD6SyNK8QJqcpJtDWGKw1JJWIRFRW1K4phaJhGAdxlygpAzlZQmFBKlQJTc4n1x6tDa6SlIXKGLq2oW4autmcqmuomprl5QXWOnJSTGNgt+15eFjz9s079psN64c93fmMpq1RPJweOlMKvj9O2PlIPSmnkVIYY6nr5jQpWqNp6pq6kvglHwLjMKAUpFyDSozjQAwRYxw5l9V6VhgLKcqUnpI5xXRpJe41sXwdJ/OjQbewXBN1belmTYFBNTmLNdcHvCYFbWWY1eLVGpKYrhl7LIJGsvEyqKyoKodCSaJDCsJM9aG8XzBWSAXW9aANWRucqxmmxOQjIQeabc/t5oCrZ7S1orY1OquiEzWkSsywpyAOO6MVwwWjFKYktmgSkw2okhY+BQn9ff7WjBbTequNbAlT4dtqgbt1ccZxWuGammgycTYXux1fi0DRzclmgUoWskdFh2ZEU3ajpibpiphrgrNMBHzu0akhBiWGAdEzHTbkaY/yk8iArMOaGjO/gGpGrGbSfMbI5MEHJUFxxanq6XqpEs5rIeUTIQZScWfJDMPAbrul73suXr5ktlyilKI/HOgPB958/Q3v3rzh3es3fP3b37Hbbtntdidv0Zyfdlxa6UIYtOLMU4hWYhWYT/mjuUyj0zjw/u07vv7970sjckFVVzj75BZzKmTPIAmFfOya4776+T7wmSF2IcHIgRRJYeDdd1/x9W/+nsfbtxKfl3UJYQsolQhhKggLpTmtRRhPxo8DKYxom6ksEEd8v2Pq4eHmHe9ff8snH3+McbY8lkUOdfwReZoCj1//UbxDHw+ZMSeMhlmraavMUhW3jjDhskJZxYSY6VplmXdGqPHGEiICsRQLH5UMKUxMwTAFRVU3InjOkYR05SlLthpK41wrnbF1KCcaF+csMXhyCsAkUFgqly0LlNjUlmhzEYZajAkfMPhUsbw6jCPr3Z7HzY6XLzM5eKKPnK8WpGni6vKMu8UcphEfHEpnGm+5Ojtj1taYlNmuN4ThgB/EzzSTmc1mtDMhGBgnTMgja9UYCZCdz1psdca//Bf/guvzcw77PfvNmuFwELjoOOLrp8KTjk9lLmDQ9xxjDlaip351f8/bfpSg36rGIhN1XdVSQFMoxU0TcigKaITxV9fUdc39/X0hrdjTTZdzdWJqTn4qrMuAtUJoaVtHWzlyiDRVTdt1LM7PuHhxTd21uLZjuz2w2x7Y7wfu7ta8fv2O3//2K8bDAe1Hvnz1kmbWgfqWY4G3RRLii9PO8XUsKuKHKGnyGYgporWl7Vrms47FYi7EHgV1U6E11I1lt9swTR6txW1FTB4kUzFGzzhkgjG0TSOTpZF09KNMBGSik+68QEwq0rQNF1cLZvOKutbFRP3IQi33IFAbmaaSqQlRkbJk71XWYo0haYNC9jvGVmK4oCYhjyQISXapkYypHFmJLjFkTcgaV9WMYcJHz2boUXbP8maDqxacLwwvlw1BKeKxSZWHg2EaiSHgZwGrBUwb/cgUMr5A9zlFDIkQM5P/kByiSTglfrgeQQuyzgXuBR0TVmeUUbRdJ4zvOOKrjuQLNK5mZD1DM4CaUHmP8QMme6wJZFeRrSOpFu8sAxNj2mOCI/qaHCdUGBn2a0zscSlRVQ3WOAbdYa9eQbtkjJrQD4R+TwiKlC2mnpG1JaXvFQttMdpyDH8VyYJcM5Uy4zBy8/6Gt29ec/nqJYvVCqUVN+/f83j/wN//9S+4efuO2/c3bDaPxc82nXIOnxcrMde3GG0KvC/F8Zj/qI1GWyMwfJFc3d2851e//CV9P/DjP/q5yFyq6kQgUWUy1Pp78LXK2O/r/o5F8IOCI+87RY8f97z+6jd89fd/w/7hhlo7jK1lz6UzKPFxBqhrgWfruikoDUxjTwoj1mq62qCzJ0094+S5f/+Wb373G/7pX/wFpm1QGeKzJeUTBHqcloulGj/89cNt08hiwGsk72yKmWHUxbA4U5kCxaXiHxnFmT+U9jQEVViEmRAzKMPZ2QpnR1KYChGkNPPFINjqYhJLEgcNBFM/2uVoKZeceMeIJiaJbYfoRY7GDcdP5vtOHcCUMnEYeH97z/n7O774MmKUFPX92DPkiFnNCOctgQ4LXKsVRmWcMYzTwON3NwzbLTlMmDRQ1xWzpuPqxRVN21G3LXXd4OoW03bo2mKswrmMUuJYv2w0P//iI64X/yUvFzN++/U3/Jtf/oqgJO7mSVyrsadOUFxNnrffGXjYjegc+f16yzYrvFJY5yBmVIz40ZNzJPgJSLjaYiolcVQp0A+9vIdZxzAOTzZjCORQVzXTJHCk95Ih55xYf1XOUtWWxnTUxtK4mqptmK0WKKPZH3re/O5bbm7ueLhf8+b1LY8PW+7u1uy3B5xSXC2WnJ+/pFvMZKriCR7SRmGdwViNiZqqcljbYG2FdRZUkmYqRyrnuL6+YtbVMlWZo2dm5pNPP8FZzRQOOKcYx7FM2mXHmhTOVHR1xzFD0FaO5WpB07T87qtvcKYXFq+r0Foz9D3kskfNE03dcX424/JyhaukCA7TVBK9n16dTiwsWF3ho3iFbg8DxIiuXGngEsY8TZKmyowKvFbYpDHK4JSmaWeknLlatLS24q11vL65ETjZGZyqGbznq+++4+Hulo8uz/iT/+I/RSsnb95YKG7+0yRs3H4YpLPPmWmyoC1ox77fl52wCJxd8aYEeUbnGpbO0bkZIRmCVuy7iNYNOivM3e/JcU/KPW37Kbqe017+iBQtOZf9T7ao7KSxjJMknPgRkzx12pFUIKpEny11t6A9f4HKFWkMjIcdqd+ipp5ZFbHUODUjuAblahazJWl2RbQN/XrD1O/p13dMMRKMhcWSZCxpGk7QJFAmQfMMjQCUJsREP4zcrx94XN+zWT/wt3/1b1FasdlseLh/oD/0+GFkHEZppjjGID3JY55Pa6fGShlJIMklBxQtf7+kw0QdMbU+BSa//e5bdus1Vy9e8vM/+RN+/JOfPhsAjmL+D0cmpyhsjafT5PkkeJRBHF+Hw443X/2ad9/8lrt3X2PyiFVglZGpOmWJSyu65qpyJyh3tpjjfWCYZN9tVGbR1axmDcOs4dF7Nne3/OaXf8vj3X9G7SyzxfIJCVP6yIl5HkNYfs7/CMSYE+REMc7NSui/p5TpfNqT5PyUOp6zlj+TpRqdumBtaLsWw9EF5ahrOb4ZdVq+ZqUQ27ajm4rmeaTG6e2q5x9D+R5an+CagnB9+K7K90wpsz/07A/7Uk+l0o7e42Mga8X8bCmWVzmSvKQqHLZbpr6n325JkxSeyhnarmE2K7uwkjIvxthlEjRKDnMNlB2RSoHGKC4Xc774+BUpRb55/571OHIoMIk6wiTHd3ii9X9wqdiNHpUTY5aIJKU0TmnQ0tEd46dCFDhNR0l2MEqfzKZDCPgS63QkkKRY9HmmHHxKCbkGcZCxBXLNWeHqmlnbUZkKNOz7nvGw5zCMfP3NW25vH1g/7ri73bDf9Rz2AklK3p9l8gH68YM3p0xC2YSqMtqJJ6cpMO2TA75E5NRVTdPIl1KFaIXEOVnrWM6XKA3jY4/RjsrJdTfaYJTBTxGrHU01l/vSaGzjaNu5yCSMxWmxGktZumtyQueEVYrVrOV8MedytWLZLlAm008HcvayS3p2yYRmXlRiuRw62UvCUcwi9sYgW7CSTak0VifQWaQQCJxllYjYbVOx6hr2hwZT7gFpEBLBT+x3iVYl8C2tVSfnkXxkbmpFpRzeKFQxAyDJ1KatFsZzsqQkB7E2hq6yT09fzsxzYJkjMwXeKEYNo0pYZ9CmwrSW7DUpRJxKaKVw1QzMHKWr4qRpIBt8kpg04oANGZMiVdyBmkgq4BK4umY+m2OzMJJrNaLVSNQT7awqCQaKqBxJ15iqk+iqGEWvNvb4aZCzTSuyc5I8/L0Q5JMRNk9BtkorpmFgv9+x224Z+p4YPLvNmpQSDw8PrNcbpmmkMrLXdZXDOieT/ZQ4yhiOhhSnYlVkDanIK4QLkIWgpKQJPrLFVSr3egjEEPnmq99zff2CTz77HNO0xS1GnUguH7yv70Ofz4tgLkdsEeqrnPFDz83r79hvHvFjL8OKyiidTnvSkHxZlWiO0UtH44kEjMEXFFAsOY+mD1u9w/uJ3WbDdrNhuVwxmy9Ohe+4/iCXVRtil5i06Cl/6OuHSyQK3hxTLLExT4GN+hjwSJSlf9aFrxWf+ocjC0+JzZmxFWfn56T9SBqeCo8+0pOydPwqH2M/LAmY4pN4utyNoDQ5m2MpPg3xKHlQs0qnzuH7Vz2mCCGTQmK9WfP4+Fg6MYEd9ocdQy+dypc/+pycE+Ow47tvvuLd6we+/v3vSNOIiZFFXVM3FWfLGZfXlyyWC7r5HG1c0dQJm0/pjLWaymlqJ8XI+4Df7wnjRPaeP/nx57y8PqePE7/47e/5/Zu3hFhcTI6waHk4jvuA59fq/W7AGY2qGhoteYMVYJ3GWImQ6fvM/hAErzeZEB1GVxhjiSlzGAbSw72w+crXOE0E7/HTWFiQjtms46hhPBo1+JCo2znn1y/QwN3DPb/5ze94e3PDervl9esb+sPEOEb8CCkpUjxmK8oY8s2bd3JHPXfDqT26nVAzhc4CS9pgyT4Wg4YnA4Xryxd0XUvb1Ox3W8ZxEHG3dczbBRerK6Zp4vd332KcQDhV5VjM5yy6Gfe3a1LUGNUSoydnhWla6m7JrGuZm4beVHTaMWa5Fy1QqcTMaj765BM+/ugVX3z6KbaxjGEkTBkYT7DX8ycspsgUA1MQVq7TEzpP5KDw0Yj/6PHaay17XQCVcRhiCExxwuhM5SxdXXM9b4k+0NQtB38g54kYBnyIDDHzk6slL5ctiyoDkhWISqcdcNQGr0F7R4oTkQBqKnC+gSqLxMV7nM505lnDAnw0bblwDV3lOGjDLmceD3uqpqHqWmxuYBzIo8H5HQaDUXOqboZplmiCTCtKM7niO4nGMReCTfJYPaG1J9LjVKBRntjfE2PgZWvo6YkucP3iBXcPPd++3TCoDpzGuYY0jSJReLyh3+/E+CKLtyhIERQ7vGev0phT0mlAjq3N+pG3r7/j3Zs3HHYbIDMOwvg8FkUFtG1z2u9PwXM4aGL0HNFoY7QI45Mc6EfUMqd82kNba1EZXLEWTDHS9wdyTmVnnhn6kX/3r/8N5+eXfPr5F7Qff4o2rsgg0h9MgipHdCkm5dYqO8CnEF+FkrVJjuwe7/mbf/tvWN++J00DRmW0TqCjwPTRM/lRVjknFxe5nu18TlKK/TAU9n9EA/NZh5+WrB83pBDZ7na8ff2apm65vLpGYQoqVdCxfBzRyjlokNCEHzgN/uAiWNfNSS9mtUwwWSUUEUVCW0fSFX1wJBwJqcgeRYpSpFK0kAxTSDhjqFxFj2WKmpDF20JlU7oCmGImKAvaEHN9CpdNuRyUSsuBkU5Naol2KqVQZcJRclAcIkf/IcPy6KFHjuy2W+7u73l8XItpNIrD7oCfRlTKTOOBaRxY39+wvrlh/3iPjh5nFW3TsJp1dE3D+fmStmnKQSJ6sidBuOjlnAFrMtNhx35/YL8/0O978aFUoFJgVin++Z/+hKoyzNuGv/3tN4TS4Xw/sPN7tzLGOWZdw8fdXODemAjDQWjpVtHNqqJdE6JOJpO80NNDyRqLKXE4HLDOUVUVbdeip0GahpTQujrdEyklxjGSSyFruw5Xt2Rj+ftf/5r3Nzd88+23cshPU/kp9TOYRXZqWkPWioP3+PUGn56Su5WCsyvH2aWjbgy6XeK9xs0su4ee/VZiuawTAoydXWPaloFErzKTrnDdCtfNmM0XxOaapD2zyx5TWbSzmLohGsdGWe5VTcgRFaAyHUYrRm/w95G7hz3v7z2bvWJSAnEbZ2kai8aTLNTNkrqaYXVD9okYIEbRNGb1fJ+Z+fZujVeKIURJbNeKeW05tna7wRNSJmSonMBjlXNYY9HaEHxmmiYmP9EEcyJdvb5d8/Z+zcN2wzCOpDiR4yBNpra0TUtVNTzuD9jiMKSVIluLouLQT0w+chgHtI6AZDb2hz1j3ONTQJOoVMR76PsNT21oxppE0iNr1hzqmp5M3K2xaklbiR2fmmp037BgxKoNWScm7wmpYTw8QLYoXCE8KJQy1LqmtparTqPqGdl0eJ1JoScdbgibt4Q0kboGvx+ZpsiD0mwHmLImVi3YGnxk3D4w9jtyvyWHICxZIyzErDTKOUiO5w10PvEXEscw8ClMvP72a7767W/JUXxZrbGywy1nlNZiPF9Vx8DvxNnZivl8xvnZUuDnKA1djCL5yVkVj1hzaghjFL2lLQJ5MWrwJ3mQPGMKpRIPd3fc3crXannBOmy4u73jo49fMJZnkeMzmBL6uYF/uY4fRhPJNLfb7rh/f8Nv/+7v6DdbaUqdAiNogk+eiCQNoWSP+IGkSBtMVdPOFyTAR1ludfM5SltC0iXlp2KaPLvdjsO+ByUB7Ucu4MlKrvwvmcyhH/9D5eyD1w8ugkfNlDGOUyQZoUACCaUdGYNPmqyK87yyp+J0LN06Sv6gyRqjLSkrfESSB5Tsa2KSgyFEiMYAlpjFqDlGSEcWW4ApUAJIn4JNT0WwLOuPK8OUwX+vQXiOvff9wG67Y7ffk5tMZSsxIkbhjJGLNE1MB2GB4r3IRYxhVlfMZjJ1tG0rD7d+0uMciTpHGEOpjMqRYb/jsN2y2+zwPhVyhQGks351sWTz4hI/er769h39FAg83w8e4zy/h+1bOQStrel9YAqBfRhRSvYJxkmhtJU40sSU2O/3UlxTOhXtY6jv0aOU4387ZxFpH3VgJxG9TJqL5ZKmbVDGcHN/z83dPY/rLcaaIuQusPjxi6eE6kxm8J7R5w8nfwXd3NDOLaayqKqjijXGdoS4Y/AHer9FmxrdrFD1EqoGHzzRQiZgZldU8wX18oxUrUAF2tWErh3aWqhbQtKMAUYHIU3kNAqqACSfGYaIDoFNn+mDIeoWUy/QVYXtKgg9SQXQNVlVkCWhICUl3T35g8uVM9xu9pKo4BNGK2Ey51YOn5S43x/wITHFRF05rBEdaOUaYQ0mxeQnRj8yeC3XfwrcrtfcPK7ZHXb4KN66KYxobaldRV05jDFs+oHaKKxRWKVxSVLbDv3I5AO9H7FWUJ8xRHb9xLYXlrTVMC/OTOM0fNh/G0U0iYOa6I1iUhmlJqwZcW6SXaevcbblPCoMgZh3bLMhT5Zp95qcK6DBZH1KRHBW01aaq3lNMtdEoxi0YgoDQ1iTpwdSmIg0hINnmmDrtgypJtKQTSXkIR/w/Z5w2JL9SC5FJx/D6lCScmM+hEOfJ7qM48g0jjyuH3n/5g3v374RJyFtxPnHlkT5zOk8MKYc4krRdWUqTIndbi9mDgyogqXFeLTje4JGT2kRWlCyTHFRKkUwxlxcYxL9cGC33bJ+fOTu7p7dbs/Xv/+KurL0hw/TMQT2/HCCOrJFVUEDUQqV4bDbsnl84Pbde8I0Yo7nRCHzCY+EE1vzQ79RClLnCimSkkmbqSqJXjsPsnu1rsL7wOHQs93uUMqCMn+w28oIczSZzDBO/NDXD98J5gRZNFbHGiPi0FzsTUZyisQobMWUFT7EMpAplI1iCTYGQqyx2aCUYxgnttsdJgW00Vgnptg5i11OUoDKDD6JI31UKAypFD2fCk1YiQYs5VgmPzloinHGKam5Hz8Eoo74tDaa3X7L7e0t79+945OPPuVsdcFq1kL0pHHPg8n0BsywoE2ey9oxXJ6JTVfRzlmjUU7o4LGI/HNIpBywOWKdoW0qoh/Zjj23b28Y+4FxmMBUGOeomgrFKHmI/cBnZ0teLM65ud/xzftbvn5/cypK2hjRj30QvwTLGlaNYjQGimVYSNK9ZiJ5l3HWUdc1Z+cXaK24uxM3GoWirmu890xTxGeZ1g4H0ebFGGmKfs0YI/BRkQksVgvOzlf8xT/5C6YpsNsfGPqBHDOr+ZmQQvzENGamMTJNSRIayg445kAImSF5rLV8H9RoWqg7TdINTXeF1itWLz+mPQ8sHifevnmDqyqWyyWpWzBZC41mcV5hq4rzs0vquqGuWyYnbLnLxSekwsCMtmWaMoyJc7cm9XvS7o5hu2GcRh73B/wwEMcJk2akqkW1CboZOEduK1IYyGni7X7CHRLLUZIjppQJRJTJPJdnpZz5xVe3nG0mshL5TGUMt/NeJsGcWW/3+JjxMT07BDXWuhNcnXOAFKisPonaf/nNa97cP/D+/p2I7VNEx8jZYsHnVwtmtSamid+9vcFqg9Wa2hjqpmLWNjxueibvGcIoVm86s9t63t1veH23xhrNvLF8dNZirebxMJwuWFaKTbfAdwuCzUxKDqmrM8dsHmi7A7OzhpluOeOSy8mjQqLvAzf7gW0/YodvGNOcgRWjatA6UduB1qy5dIE/e9Uy8Sl9/oi7qeagdmzUI9GKyH+93jAOCj8Z1sOW0FiYzdC2IaIYdo+Mu0d8v0MnTY5yZiiBJgCDMkVn/Pw4VFaafAxff/X3fPf11/wv/+P/xHbzwDj0zGcNrpHMQbTsxXwI5fBXhBgKEqJx1p32gOPgiSFhtUUZEX2H4PEh4o82geW8k+Y6iV7Wi8BeoEdFXVXiLpUSw77n5u6O3/72t/xv/+tf8ebtO/7mF3/Df/Vf/V+fSCblyNRZmvPnTTbmSaCeySdE7re/+hW/+/Wv2N7fY5Sia1t0K4hbJKEKEVIrg9YWre1pnygHr+SNKmMJKeGLvMZVFVWl0botg414PKd375lCwppGcmNtjTG6GFtYVInzCibx8PD4A8HQf0yeoBYBseyAywWQMJdna1RdGPbHQqlO+zWjHbqEeSrlRIxuNJcvP2V5dsb27g3T1DON/ekhUqqIwI8mykkO+wxy+2iNSkF+X1EKYISjq1x6CuSSvdkzeld5Cd6eMdoQYqQfB+7u7nlx9ZKua2mMIk4DQxqpm5ocW/yiI2WPcYpZXJ6uqS3SB63VKeYkFNJNTBllC5Mrw3AQI+ndbkv0odDxpRCkaAAhpux3O6pKoXTNjz9+Rc6Zh/WGvtikJQVJfwivKeD6fM6ya3i7m1CICNY6mbxB9m9TDsSYWS7F0UGgGnkPIXhyTqKxayW/rqlrcoxEa1nO58zL1+Pjo0Bx08Rs1jHrOoah5/Fxzd39I+MwyMObwA+esR+ZxkAIiRjSaRJEgzGy7DdO09SOmBXq/jjtCoRndI3Sc5RZkVmw3yvGSRGTxtUzsWjSNTFpiAqVxYIsKdj3AZ/kq05iq+Zsiym6pbrpUD6QR8807Rh9ZDfueXf7jumwZ+P3TDEQcqTKsuZQRhMVGG9JwUH26BzRfqSya6w2zOcGzERUSfwZeRoGc4bDFKhGjzIGEzPeZNTu6HyRGab4hKhQJEAqoadJaPTHJjVFonWMStOrgbvHNY+bjcQ6JQnYbcv7XCwvxFN2Sgyb8SlyJ0u2YF1bhlEy+iIRYwIQ2ex67rYHHg4jxmgOXtLtndXcPh6eTe6K2XLF+cUFzapmM21AR67PrshdBU1FM5+zqhteNC3LqScOIw8Pa1Z2R+UCV5Pi9hB5fxjxImIDlyWEuIJKRZT2wMjcVdjaYesV2VnsGAltoh4U06QhzZmqGVNVkVQip0gaduTgZdeWhNSnkpwdCkT3p/QH3rwpJx5vX9M4j1aKND6Sp0fG3Q3T0BN8JDJDxUyeJjLi+JLL+aWgmCuIzEJkNpwgTSGrxTIICBoTYiTEKFmuWpApcj751aYUT0hTSgK7By+B4sPoeffuhuZXv2b9uOfx8ZH9fs9XX399ItmUO5Fw2JOKsD9GIePFHAlBtM/b7ZZhGDkcDvz1X/1vfPu73yC8EIXSRghYhdh1nApl8nUYbbFWoeKIH7eQpuKaE0TDOFXsTCpSMM2hP2pOFVXTMO5rpn6NpirnlZixKpUxVmOtxlWWqjHs3v/+h64E/5FFUBuUEr2acFdSKYLSyR+dHMQiSeAu+WEtRleorNFZY4q7gXWOs4vPcFbzNYH1wy37w/40Oh+F0QUrEFZqFLNb0KWoilg3w+kmO0J5onDVZWo9tnffM7mNwqQzWmC6cRy5vbvFe0/XtnSVYRpgGjRVXZFzgw8dmIRrHVY5EcymVJiJmYh8n1D8Eo+iapdc8dPM9PuD6AF3W0B2kzoaklbSsSPamt1uT9doqjrz5ccvmKaJb16/Zdr3TCW1ApXI+pmtk1K8vFwyqyzvNrdojCzbrUUXNxLvJ1KITDngfThNF0ez7BD86d9nXUdd17RtA1lIG6vlksVyyWKxYCoHcUqJruto2ob15pG3797x7u17xmEg+ggpM/UjYz8RfCKFY0J5PLHOKiem1d3MMe9aQlKobx9ON7RWFq1q0DNQC2Kcs9kmpj7hfca5puj0NNI0F7QiJVQIZHrclKm9os2WqqrJ1tHaFlfXnM87Gj9SVQq/TezVyPvDI7c3r/GbR3bhwGCF6diYqhgNWHwc0VrjjSRja5UJiA/kNExcX7bUbaZeRLDwlPEt98zoI4OP4ldpQMdMCLI/RmWijxhVpDFKCOA+PSXHmzBCiqgUya6FDFOM3D+u2Wx3hMLqzSlh25qmmTFbXuCzw4+Z1E8cP2TvA0aLzCtne2I+KjWRcmC93bI+TKxHj1YaNwT6fsIZxXp9eLbDVSxXK168fMHlJytuHr5F68AfffmCbZ7oc8I2C65mKz45u6KdtoyHHYPyZH1gZhNzbUm3mdthIkngJVQGW1e4ymCUlx2L8SwaRUNDlx3JzXBjIg+JaVBMoyKOFb1uydYRVCDGkdhLfFhKR9SosCCL1aEu0oTn2qqcEg83X9GaHVWlyeMdhDX4BwiZnDQpa3xM+DSQY2AcxtP5lMmMY8bZDPbodBTFO9l7IcqFgNIyYIQYGceJfhxpakvlLLUzcv7msiIq64gjRCvFb2IKnnHwvHv3ntEHhn5iHCf85Pnmm2+I4WnqyzkzbTf4WiD2aRjwwTP4nt1hx6Hf8+7dW9ZrkXr8zS/+PduHu1ITpPm3GOGI5ETtJCwdrXDWFXhYQxwJ/ZbY7wgxME5eiELOsg49uqzTdn3kaJPYNA3aWnaPtnBLdHGo8qTksZWiriyzrmI1b9jfvOOHVsEfHqqrHcbUGA1GiZZF64jRSh5MRLzsQ4mWyeKgnxXkEtKYk+z+fvKTv+TjTz7lv/iXf87XX33Lu3fvmMZRLghHN/bMFAr+bDRNce6IwQspBwnU1YU4EHJCCtzzHVImRWFJxSimzzn5Dz6cnMpBrMWEehhGvv7ma37+058SoyfmzBQ9u75nmEZSzszOr5mdXctkHxHfu/FA8AdimIj9QYTxxgj1I0/EELBaloOH/YF16cbGcZRdq7MUMxkMYoMVJ49OmWnoSSGyunzJjz66IuQ/5V/91S+43+2YfECr/MGhqpXipz/7Mcu2Yovl9zdrhm1PPJld+5JKIXZLh8OBaTKM40R3tqJrG+5ub3DO0nWdTAWVOO6YriMD1lWEENntdhzTH4wxTJPn7bv3/Ltf/DXrhzX77R6dDDmKj6zvBxyKLz/9mMfHDbvdgXEcWSw6Lq9X/PjLj7i8WPDFJ9dcnp+xOUz8q1/+3+hHsbvTeUkYZ6z3oKw0GJv7wHDYMPZ7QB7IgxHDXmEWmxND19YNVdNQtx39bIF1Nbads5h1zOqKs4NB7+9odzdc3X3L7v0N4fdfcf7mG8bdFpv3TE6xdYqpmlMZMWo/TnY9IphGCYPtfc7oHFk2icXC8snnc64/maGeia+hLPVPIsXMcUGaoqRQHPY9RimRoKiEylmYk0kmmskPhJDwIdHUAp2t+z3rw57RT7KLNhZdGVYX13SrC7Jt2Y2emCLHtADZxacn2DyVTEXN6dAdJ0jZ0tSGmAVy2/gAY2K9D6enS2vNi599xOc/+pTPPl1x9u0WYyN/8c9+zLfrB+72e3KacX1+xSevvmDu4LDfMboOpzI+e1Z5wdu1hmTJ0QlhxSjSQpHPEubTmqQWKM6Yrz6T61tXXG5hdwh8/f6eh/stm02P3SRMjmg1Eg5rwjhCvyElUSD7rEk5oUjUzokY3TrsfEU0I/vTmeG5/fV/w/SmoR8yu14muD/9caIfMqNPPPa3xJRJOeKMx1ceup5394HDlJnPWtk9ZvUslkzRj5G+9wxDOO5q8EkRs3AjnK2oK0vXiewnI0Sz4xkXQiL4QN+PjJMnlD1yYs0wBtq2AxRt1/L27VuGEusGkGLgm9/8ex7fL0k5891337Hb73jYrLl7eGC337Pb78VCz0/sNlty9FT1ka0OBl0QMRHeG6UwysrqRGuMsaTxwOZepkCOp/FkGZRikzJZaZLShCx5o85afNuezAJi0ISQ6IeeaeoJYWC+qLi6Ouflxae4vEWH7Q8tbf8IiUTpIovrLapgvCcDYqXJOh05tfLgWAqdVToj5ypm846PXl7w6npJ6xKkgXHYczgMjD6QEC/BjEySmZKRduQRquO0yQkvPmqu8vGfhUF5JKTIr8sEpNT3FtxwKpopy1J5s9mw3mxYbx8hd4zjIEUpS+irq9vT+4rjJO+diA8HYk7lUJEfIAvLp5QoRQyB7XZ7iiQ6sr0kigiZXkMkDiNxHMiTB6tAWSoNy67hk+sLLhYzpmnibr8jaz5oejJZBOytY7Va0WwG9GEqeshYHrqMUZTF/sDktRhYe0+qHCkGkubkyJNiKGbg8iGLQD6f6NhH2vZ2t2OcJh7u1/T7A9PkmdcVIQbiNNHWDucqLs6WxGkk+ZFZ0/Hy1SVffPkxP/vpp1yeL/j4+oLlfMbN4+60UFeA0TUkx3gIGFe8LJ+OcI476xwDKhXyQNAYE2XvlwWO1M7iogetSUNPnxNqNOyniN29x23e0q1fo9b3sL3BDhuc32NyL4eP0iRrUDphS1yRopC0kiNhmBLkEMkhEvsRP2rqemSxsqT83JD56fLJyqS8n5jw04j3E5v1WjR01mL1EX8R7Z40nREfpXH0ecCnxG4YCCGedvjH+99WNcZWT8hNOrqB5Kf1Qfm9Y2E+JgZlVFlvyEpkillkjIX4lr53H+5DYjNM3G/2HPoRawL39/cMhTzUdZpuZmlnFU3lyErTdmds9YIp7XkYBg7JQLEcNFahnCK5ieAiO51RtgM7Y3Z+TtV2tG2LbiJ6O9Du9mw2+xM7MadIiiNh6gnTJAhRSXM/Qe6AqWqyNmRjcXWLju3xA4CcCLv3rHvL29vAw16+98vzSFcp5jUYFU/RaJWKTC5ACKy3ntE/cREoRJmYMpMPDMNIP0gBO0q6Qll9aC1ciBAz0xQKnp7xPp4IMSHIFNgPEyGkknQvcovgI95KrqRSmr4f6Pv+9L7lLHjEGDkH9tsb1psNb9++4+5xw/7QM42j5I8m0Zo+t1g7En7kSxW5RdGuFunTUdQuTRyn/aAu8jhligxIGTz6xLAn51OgQoyKFOVs0jpT146LizMuL865OD/DEtmu/yMUwRgmQtAoLMZU8iDYWuQFWpdE4lzuJ8HRjz6LAGGaWM7P+fzzL/jZjz/m4qzD9zcMhzv2+wceHnbE6FHaiScfiOAyQ9aquMBYlJYLGwGflbjel1tXHNfLgVluruN+UChKpnjlfcgqgifmZoiB+4cH3r57wzfffY2/viIGz2HoMYAzjqpZnAy2+7gBEpqKcReYgpgpO2XRSuN9IMck3vFZ7JQeH+85HA7EGAsTShiV0R9d4zN+s2XqD8T9AdNprMtUOnM5b1gsZvz6d5fk4Lm9uyMZ+/SAAmR49+YtFddcvbjm28c91WE4FcCUksDZOROjZ7cTc9vgI01lMcikkUJg7HumYUAjE+/RMHicvKSrNw3DMDCOI72ENTJOE/v9CElTu4bFfE6/27Ob1rx6ec1iseDy6pI47lBhz/WLC372xz/mn/+LP+OnP/2MedcwcxYKtP3c5cK5GYqKfrulaUeMrZnXLSlWhFSVvU5+SpdICU0gx0DSGp8Tyhmq3KBMluZlOLDvD3gS7/KOcf0a//gd7fiefr2mf3yDmna4OOGY0EmkPJoJZzSzpsIi0oaYwCfFlDK7IQrk6yN+2jLsEn584OKio6rtEyGhvLdjoKoqe7kUPPvtht1uy/v370GJuLq2GqvBKEFMhMjU4DOMEcIo8OcwjOUAPc6pEhYnRdB9wHAUE3KR52ijiTkTk5aUhNN3UGglbMdU9lEpT5LAUUKAj5o5eabgq9st+2j47m3C9rc4PfCwucW9nFNfzLh+ecFspegWmsq2pGxYzi95wwvWPdzcWB4nQ+4sTmVMlXEtxHrgYCOvfWZRn7GYn3H26hXtbEE7n+Eed+j7Nc07hdaJlLygTMHjx8i07wsR4wlezuVA11pTdwuSNowo3GyJpj+9r5wzcX/PwwH+6m96vrmbqCrN/+lPO/7oE8uLleKilnshZUFwJ59ZNZ7HjccHjXW2mDzI5BTGie12y2a749BPwmIvGuhjBJJ1Dh+TIDqjx1iB+sdJVhrT5AnxKBM7TvCaqm7QxpEz9H1/ysbMIwz985SWRAiPjMOBw+GAD/eMwyNvvvsNm/3IMIYTSvE8bkl0ywUOdZaqKikrfpI1RMlHPa6prBZpR9acdq3OuZLY0mArYZWPMRfEUXM4CGK02+/J6SnndDZbMpu3/Plf/IzzsxXXVxcQBa04DkH/R68fzg5V4s9JjkSfybFH50rMk7VCWRE4HxlPKSNZeBiMqfjis59ycb7i5cszljMP8YFf/eqWX/3693z7+r3sqFKU3Z9xp4UqSkNxoJEORAguKhsitcS+IFBNzJGk5JBX+TiVypXSxc0jfc+u6pg+AMdYERiGnt/+7jcYA//iL/8p1hjGw5779++ZxhFjLU3TUNU1XV1RW01TKXbbPX44CLEiJ1SW/Z7KYJSSeKUwsd484kuUjzHmNEVN00QOESbP4f6OaegZ+wESZQF/wNQNrav4+RcfU1eOdzePbMeJwT/l7mVg8IF+CqQqYaylqqvygCtx44dTQZzNZhhjyTX4aeLhYcKozHw24+xsJfl15Y6aRlm2ZzWilKJtW/EPnSbW6zWHYWIYPf0h0lYWVzmi91TW8PLlBV9+8RGzrkUBn75ccXVW8ed//nM++eyaH326Qucd+92Ou31k+7jhq+9uT9NyJrPbbmlnmlnjWC0qjLVsDhPtrEF3LdqWJLFcTLZjJPuJHMSaLioIOTLFCVs5rHGywz2MeO9Zq4wOFZoFYX/Ddh/4ZhhYx8wOQzAtxlU0zglLGcWUvXS5iHm3Mg06W9S0RxXwpLYVlY6YEEhD5HsWmycfh5QlQcDHwP3tOx7Xj2x3W3bbHdZZmtyIcTwKcjzdz9lUIiRXMAziQxkLKStFMYMwGow2uCKWDuUzSTGTchBzBVMKbNaELIYVZa2DOT6TORGzJLu4KCbWWYl5utFPjW9OmZs3j4zbwJ321PGeyowsdxPX1RVullBpRw5r/OEW2wSiH/H+hjEdGIjsqpZkNQ2WSim0VdgKfGw5jPC4r+iWl9TzM+rOUrUa0yiqFqomQeohTQXNgBwzxCy7ZSOm5EdTRtHiWbRxVGdnaFexqFua1RXTY/yAVhd8pLXw6TUcpiIJmyLZa3I0GC3OLikk7vZyjZa15o8+NpyvFK/3Fm1qrG1o7UBrPVXck8fIxmTuNoGu1tSVpu9hijDEYztSJiklbVOKsew0zYk8Zaw5Wf3pcq7FKByClI4GFPopoQVpvuadZTar6VrN1eWMzfaCFCNff/ueu/s1m/VG3KRKoznvZnz88Uc0TUXbtnz2+ScnqRjBMx56tg+P3N7cEGNguVrRNC2ucgSVabsZq7MVq9VKdure048TPkSmzKkJfv36Nf2hp6krzs6vmc8WXF1fsVjMmM9brl+ci22js2LOcb+RB+oH7AX/EbZpZd+WKckNkRRliUxGzLFLAvARRkkxUVVzmqZmPpsxm7XM2ooYe4ZDz7ev33J3e8d2s0FxtFfLhSyoBebTBpVPkcxlvD/6PGuxPOIInZZdIUWTk6N8ELnsXJ6ZHT+/8E9eh/LPEAN393e4rzSffvKKtm5I3nN3/0B/2JNSOE1B1+fndG2NzjV+nPDe44psQ+WnVkTCe0fGaWToB2KWpa/AGBKiGbwnTROpHwjjSJwmCSP1E34cGPsDLiVsipzPGg5nC65WC/zDlml6Dq9lBh85TJ5UINfjZHw0z5VOXnZqR6q9tVamvegFmtAG66piQSSfZS4L+Fj2tsfEeRDG2263ZxiDZGAqI8twpXBNRbNoOT+b09YVwzCwmNXMWssnH11yfT6nrRTDuGccA5t1YP2wFqrzsZ3LMPYjdRWZtzNW8xZtKraHnaAPWghXHK+nMeQYSUoTi7VWShPR9wyHQAqXwurVhiHJdRi0Yq8qjGnZp4ptdtygGaxjMJCMQhcRtNjLwRQi9vgMKJmqZDMtpBatwCmNVQmdIPnIc//F59cNhMQVQ2C327Lb7zj0B3zwJfEki6VXOk7ywoBuUiJreR6OetmnFaP8TMISLjsbdbyWx+cqlltVYbUiJnV6tgpLvjSM5TkpyKkpTbAp7NvnWuicM8N+RCfLyEirJmo7YW3P1A+EccCPO6Z+y1CtUUkx9COH/p5+3NGHgaEcuLFMmeJdInrkISj6UBOowFmx1DMRpRNaB1CBXCy7UrFzlEui0Frs3ZSV/2+1RVmh3htXYRcLdNXg2hnVfIkaZ6f7CgSqdlaxmilmjSIm8TpWCPoAskIKIbE9RLRSdJVm1Qnkdxus8CxsRaP3gKddBLyHympC4PS9H1RiM2T6KZHLOkeV5/cpPQJy1ick4VQAi9XMB/eBgiM1K31QBGE+a5nPZ4JS1RXz+Zz9dgQsTd1QWY2fJnzw9P1AXTtWqyWzWcd8PueLL75guZSzXoXIsNvzcHMrqNI4cn15RdO2uLrC58RyteL65QvOzs4AmVQfN1sOw8AQUjlfNPv9nqZpWPgFL158xGK54uXLF8xmLV3X0HZVAcMyGo2t6n/g+fqHX/+IZPnypTiNsZGIzrKYt1l2gTobpjCJJEB1fPrxZ3zyyc/Yru9IoceqGb/81bfc3t3xt7/4e47Bkc6V6A0FOcshmiaxV8NatKvkgsWidTPhtKNURxgpyyOiskxiuXRJUpAjpISfpg9m5KoS0+UT1bh4ob67ecfd/Xu6tuNssWI5m7Fdrxn7A9NhIyGx2mC//DFh1sHY4fsBUsBWWtKPsxji5ixd2HqzYRwGhmEgkIr1lUcxkj34w5bkR7IfsLVC25pQ9nvTWkxoK+eoake7WvFqZvlP/vSP+F//9jeM48DJIyHD3X5A3T2yf79lM8iuISEtvVL25IwxRYgYtKu5OL8Upm2KbLdrsq7wPnPYbxHT7Ip2VlHPKnyYaGeWbl6T8rLQuDPj4PFToK4ko7CyluWyYrWc8er6nLYWk+YYNLO2RmtYtBWEkfXNgfuHO/oxsO9NIVI9b1oyh/sdZ+05n3/2MS9efkJMhq+/e83uMLEdI3UjU621FmslLkpS4DXZBba7B3YPN2y371jlLcvVS1YXf0SvIRjN3jomvWRdOfbDloMy3E3jCT4meVyOkCKjnwhD5PEwcTjF1BjQE1lpfIjYpHAKXPLUBBok6NmnD7EalQOKgHTnE5PveVw/cighwKpATU3TFEMI0c3mKEBqCAFlLVhNVVWnZPIYn2jmWimsga6y1FajcsSqTNTSDB2zCY2pnu1ugLK/EXeoDBJ2RkJiknRWZA0x/2Gid/SeoD0QqI2sNEx2+P3E/u6R1yoyLffE84mmmXHY9/z297/j2zeP3LwfuLlXTAl8AmOTZJXOWxoqWluxyIkdFX12jHGNjZ4qJvywZuo3DONBTAJyBiW+vcZKrqdFk3RFNVuimo7m7AXKOJSxxEqhrMXVHVlVpMPN89sQlRK10VzOFeczRcqKV+eaxkkEFVkxTLA5wHd3FJavZ95aLuYVyzAH1aK1YzasWcwOXH+q+XRn2fXw/s7y6sxwPtP87k3g168n/vWvA5aM1YrawmESs5BYNDfqeM2eGXCf7oEsJgCQi3tZlok+PDXPWhs+//QLzs/PAXF+Shl+8uWf8PAgUO1XX3/NZrPh8XHN3//932Os4+rqgtVqxWq15IsvPuPi4ozVao6OmThOjPseay3b7ZbLy0vJ23SOqOHs7IyXH73ClpzQEILUlpxZ7x9omoa2bfjJT/6IqqpYLBbMZsvix3x0F0snE39VIrqm8D2o5T/w+sFF0FVzXNWePANVWXSKVXFCaSlOk49Yt2LRzfnxj/8MP2XevXvNNPZEf8DkkfdvvmO726FMg1JF2xQR9/MiGj1qYHIWModNkZiTJFkUx4CczfGeRHzwxPdOQjTz6YLnkvnF8Xs/ex2NViWuJEOUYNacM4HM119/y+N8zdX5OTmOaBKzthGaa4bNekP0Ezl4amOxVmN1IHtP9IHdbmTykWkKHIbhBFNlJUV7GkdMTCgzYZVAl7rqZAcXMxWGWluUMScCUPCefrfDo5g3huWsZtk1bHc9R0cH17RgLNuHDdvRM/jIbD6TwzMmDvs9OYN1hRHoI0M/FvgBTN0RM6x3A5vHNeREWzd8/Nk1TdeQdGC737LvR3abkcf1htu7B1LKuMown1ey2+tqlouauraMcWDcHogh0e8CJI81ivVmT0o1887S1gvqSrFYNhhlsPXm2U5QYLrG1lycnbOYzxh9xmpQ0ZOmkUgma0s2lmSswPNZyFbkyLhfY9PI+dxwMXN0tUElIexUTUPTNugc0HGkH++JaWC8r1EiHiNogbgSEg8ku295Ho5AYE6ZrBLOaJzRVFnTqEylI64OKOOI+sNioRGhckI8FEM85q8VhxRtTgGoKcpePPGEXsSUMDmfElaOuy2tNSYnklY0teRWdk1NfTS6LmYXLoskSeDMdPqZju5QxyBhIUPJ9Ch/NUm2ps4nu7cP3tcRYkQstbSNRCzDZNG9oT5EIRvFOxRr+n3Pzbsb1o97DntP8DUxKWJW5DSRtUbHiLI1yo2MeeJxN1DdbFm2GT9bkMaBh5sHHu62HMaIT5pkKpRr5BpljS5MS9cuMIsVupnhFpclHcMwmcLO1BZ47nspL+8jycnHdzGT6tM5gUCnEWLU3G0y390nbteZuoKLCeqKwvIVxMIQcaqnMhONg+uVTJfLrmLVatpKcd/DcpeZd4GLuaOtNatZ5tt3E7ePgfuDID325EKTZG/9vVVPLuk6KquCuqknlAWQvV6DMa3cx4XsVVVwdmboZjO6mRAF+76na2tShvMLkW4dCXlHraMqhahqaj765GMWu50YcAQPMWDb+rRbjjGeft7lconShtvHx9P9dn5+JoXPueKEE8SMheOarBRzJc+GDx8Sz/5Drx9um2ZbXNXJjW1MYfOYss5PKApEmiaa5pyz1RU/+clf8Ktf/ZJvv/sdzjpSGEjjjvW7dwyTR6mZjLBKDE8NRVyvzbMxP58EmzHLG9RGPxXBUhizkg5VPTf0zrI4Tlq65dPp8Ox11NYY8+TvKRp7gYvevXvPfrsnTp6usbS1pZ0vyD6QQ+Sw35NCQOXMq4uF+DrmiE8SU7R9fKAfPP3oiYhPqbJCn9c5E6aJqWiCqrbBVgbXNOSEJG+jca7GGMuh7wukG0WArg1d3bFoa5Zdzetnw4WrG5RW7Hc79oPHZ8VsuSRlcbGZhkEKVoFJYgiM/Yi2VrLJqobgPUM/cne/JsXIrGm5vD4jryCR2G43kgS/8+x3Bx7WWxbzltpZmtbSzSpmXS37OhUZpoGhHwmTaLc0icpq1hvJTWwqR+3maGuxzQyrDWMyPCfGGGWoXc1qsaBtGjJeXCmIqDSRPAKhB8nTIytSUjhTAjyHHW0TWMwbLhYNrnbsY6CqanA17XwmBsC5wWxW0G/xxpGzSGsimqBExCz3Kqd76riLzIU1a5wTCzJlqbTC6YStAtlWZOIH9+IxRSKDOB+lIHvxUshOKeJZCl46LurKfz6mJG4fCEHtyVZLkbPGGkNbVcxbyXFzxpKOxMgE2SiMKXu/0+xYiiAKo4/w21GCJPZaKicpcEqaWPO9qDKlRTJiFCVPM5HQTEGhBtgfEjn0xPGB4DPjYeDh7pH9dmDoEzFqUtLkpIh6Aq/EFlEnMIYpH9geegw7HuY1aRxQU+Dhbs3j44F+SkzZkLSFqjA8UWhVY6oGu7rELs8wzQzdrcTyUWsyw1NQQNLfOzeyGD1E4SusWqmRTmdylP2d95mHTeTb28h2r5i1ijFASOXzNBaVpQgaNWGUxxpH3UhjczY3VFaSUeZzy2yWmM8sLy4qljPNizM4HDzbveiJhfFpOOLXiXRq+J83kUL+EWmGQv8D66EapQRKTFEcwoxRdDNHB5yfn5HLGTIOA9MUaGcr3r57I8UveHwJYs4hYVFU1nJ5fU3Ttbx5/UZM+GNgVokV5tO6Rn7OruvENKI05JCZz+dUleRoHpmiT+8o86SRFIQi/seYBEPaEaLHqgJ5K8kmkwcuQ1LM5is+/uhnfPrJj3DO8Yt//z/y9u07NusN/+Sf/EuG/Zo33/wK53fkIKbAlAKWc0ZHEa1PJbZEojUMmpJNGCMxRHTKGBPROj9RsjWkJJE2OSKQaYFacypSiiQX7/uvlBLDMJw6+aquykGT6AfP5Ncc9geW85bz5ZzPXl1jalAps+9HQko8rDe8uFgJxp9lt3XY7Hl8eBDaelJEVaGtprYlIiYnKTxOYytLcjNUN6NencthGhOmHWibhso61MMDOYkhbd11JKXZh8zHL0cCmr//+t0pncDmDFPg8LBmu5+gqvnyZ38sEEdMjI9bXALlHNYaFJFhf8+UFVkbzl+8QhuHbYSlNewHNpueoDPd64be9/SHkX4/YmxT6N5GNFw6McYdm8PAECy7XpieKU7kbNGqoqmv0Bqihl99c8PLPpB1w2rZQIT9+oF+GPju/cMHD+qsmzHrOpq6IkwDYz+gibSVIs0qKtfIYYAubhiKlMoOJUes1rx68ZI//vnH/PSLP6cfNf/2796x3e8IGObTGV1b0zWW67MVDFve1hXrxx3TNBBTKD6g4q/1ZC5cCmF+VoBikGRyTLF5MkTl6OmIPOnpFOAAodqALzu4ozuI0VLErNZiS1FckrQ2BSnJ+BSFnJMrVAm/Vs6W9AFL6xZcXpxxeX5GWzmUNsQoxTenjE2qsLzVkbUu7+O5okilEuCsi1xFjCFy8Q+NSoKin7+igmQ0uIbsNNlqkjtjyoE0BvLtLTvVs9aP4rQyBvqHHdPBk6ZMnjJQoXDo2KGVhl6TB012QBuZ6Nn5ie+++poHN2NeP7DeGbaDZjPOGE1NaC1eOaLVUGtcNUNXLW5xTq5rsquIT5QeQRCO8GKhOxxfOSt2vqWKBmszzom70v4gZLwMPBwyX733/N1XExp4cabROFKYCGhs8sSs8TmzDRkTFNFruW46Y4HoxWpvYQMfrxSHzxsS0NTw0Znj5rJjPxi+evcooeUpCVpQztOj/vBovH3M9Dt5jmpNCE+EOhB4dQrH91m4GDELz4J06rJTSmhrqYxldbZks31kGCDEiRCEG6FRBBQxekzt0N6x6Q88PD7QHw5c+AlXVafvd3x+YllfzeYtoFBaPGmP6SZyhY4DDKe/d9xpGyXT9g99/SN0gp6cNFmrJ0fx4jGXFTSzC2azM+bzC3b7PcGP3Ny853DYk1Jiv98yHfYlkSGWLMLwxHYqFV9cYfJTd50FA1TIKjeBOC+ofGI5SgdeGKRFz5iz8JOPVPnTP4/Q6PF9nX69xIooyKn0wqepFHwQ1wbR75jygORidyR+e6Kl0hhTy3yckpB7pE2mH700sFUjsG1KJO9RqhIR82xJNV/QLM4xxQs1pAcimjFEInLYheAxXYc2hlprzlcLDlM4dVI5Zx5vbphbTWsd+qwF1+CHSX6umLDalQOueAFmYQhmpJGYpkkOnJw5Gt0qC6NPxN3IZn9gHDzTGLi6Pi8xURqtPTEnSSRPYvWUI2X/kE6p7LY2srdKga3fl4SEzLxrgEw/Dhz6A+/vtyfIWinFxfk5Z6sV1hh8yuQsKSZOQ2MVdW0Qp0NdHPiPButa9sxNw9lyycura5aLORlPThNTPzFESER87xhrQx62DMPhRP3OVOhkMEkOlRwjKgsT+fl9dLwGKcp97nOmTwqfNJMxNPuJRODDG1FQDKMVqbAsRTpjsZmTI4cugamUIimIxdO9DEnibCQuRA5VpThbrFjMZjR1I4U6yZ/RCrJWnI7CYz3PxZ8UjovBU8dNPk6L0sipAsMeu/TnLx8jvjBIvRXHqJqaGCCPAb/Z4hip8HifiFNkfBzYbzzjkOl9RcQRqdA0aG8I2lBvxYbRV2KJpp1mHdYMZqK3if04p48NngXRtCRVkZJAggqNqjqUa8iuJmtHPiWapBLf9uxNqA/R0AxsB8dsMaNbtDzs7gjBM+sEqksZ1oc9iYqzZc1wGFCADwofjiG6gBa4ftcbbI6MHtGwGgjh+PlmLInOwcUMhhDpak1XK1aLjrPzBmM2stNNmagKrMiT7vE4aR2foeP/P8KQz18xHz2Gn66loBapFEHKGf3kwfykPxbewtHGDVW03VmLETjiKRqzGG4e79nnUKgggJCL65bsqCWMWq7fk9H+sfH84JWfzL5/6OuHJ8tHL5FIGNAlbyoXf5asWSxfsjy7Zja/4je//mseHt6x2d4WQb3j/fs3ZN8Tw8iELPXRQgQACZmVIih0X6UkKVv2K/kEVWpVdnYpQipFtGCqudDBjwn1pPTEVC0TYU4ffjinwlng1/Jco4o41zkjRTVEBu8ZSkSJPBmCPeck9lYpQy6msCgj5m6VQUWFSobdZofWGdckdIrkGBn7iWQcqnO41RXN2RmL80ucMYRpYrfv6YeeMI2MURK+d/sddragtRVN0/DySqMKnAtisPvdb7/ixbLjYn5Ge35NdjXfPG6YpkgICacbjLOk4Bl9T8yBbArEp0QmQmHWamOo2oa6qiWHbh+4uxtKEYMvl5fM5x1ta3hYv2Mc94yHQYTdxkIWa7ngS/CuM7hsGfqRcTiw3z7w/mHDt+9uqCyoLLquvu952D8ZCiil+OTjj3n14gWVs0RfYryIVEbaqa42pXiLqDhnyEoTkyYlQ62XXF9c8vGrV6zmHdO0I4eeod+xHyb2+7UkKWjQcWAcdmgNbddSx+pkqJBiLJZlwhg7yk1CCIWIIFKHWBqx4LPs0ZMhP+yls35eMHJEI8GjGEUwwqytXPGvzOJ4pA1YUzL1rJgVJ/Xsvs5CnJDdvSNEYe++uLqibWqaphIyhBGvW2WORVSddG3Hz7roIU6FUYTm8USYyaUBOMK4OsfCyC4/CjCEgPaeoCRtBaVoU0OeItknDjc3mLjDZUnJCD4xbQL9ITBNiSEaYj4WwRrjLHZyaNsRp4pG1eRay4SnBgwNhoFJKbyxTN2CYOck1ciki5wtuBZlKpKpC6tXkVPEFPZ04VSe4MPnRTFlxd2+YnV9wSeXn3H3u18w9AMfzZY4a0k5c7f9CmsbfvzJkm++u8HqQD9C4yyJcjbYCm0bHnYOQmQ/iOmA0jCOEWvAqowlMndwPVccpkhdZbpacXW1oleWqnpNHOKpoD1nhQIfPD/Hr+eRTM+vV0geH6cPf/1oa/isqIYQZCDJhbg3jYzjyDAMJ7lbOp6TiIFIyIkIYLTEljmLUgip69nPhpapdrvbiHWg1qfnK8YgQnwt4dd/UAgzfBgK/H/8+uHeoUUAj5LIxZzBZIfWHdZ07DZ7Drsdb17/HdM4EEKQQOYYiCGwXr87Vefsj9ithEXKl3xgOUMMAaXETTxlIYiMU5ACmaM41BQ2WkKXzrTsSpI8SEdCzRHHSFmRYiz6vO+RErTGuSfx8FHDJ78pGL4cFpHoA8Mw0FQVWinuNxvImdoaJn80G9bgKnTTkd2WBISsQFckoB96jryI5BoGXaOywy2uqBYrTLtg6g/sDz1v3t+KldQgtmcpBkIIvHn7jrqpWS6WRBTjMJw6N6UU//TPfsbL5YwhwNuHHXe3t/z+67ds+8AwJa4urmjriq5tOPQ7xjhBrbCVwbrMNOwLzdowX8xFdFvVONeSE0zTtxwOPcMwcPv+ns16jasS43QgpoBRisopKmdQUZbxKRiUimT2vH73K/p+zzQOxDBIwHBluL5YMu8qrhY1H10v2Y2J//bf3UGSw+j68pKLszOUM4zeQw6o7InTjjBNVDPZnyo0U2E8Zm3QiBNF1604Xy5ZtB3DYcd+/cCweyD7EZ2k200h43MkDFti6FHZUxnIWiMJJrZM/8WqrzhoAE8NVS5TU9KQlOy1yCSVsa4mhuGDe9DqjFECr1oFtTNcnJ2zHwbGyaOIAvNoaNuqZNK50uDBOCZpMLSRibwID9umpXI1i65DaUghyG49GnQFOspzFWMgHo0lsi7PjzybBSApr0SBY8r0Gk+oi7iAfPhspaSZkiKETOUCORlszLg+oUMkvN/hw5ohbjmE4oM5GnzQhAiD9/i0FykP8uzrnSFNcw6zmrjtaCoJp26yguRIocZXG/T8U2Y/+TnJLlF2hnPFoiwEht7LhtdmTOPQtmRoKiEcZWuKkLs0599rnvtY4RYf89mf/F/4n//qHf2wYfbqJ3SLM3LWDL/a8tlnn/Gnf/Zn/L/+h/+Zsd+QrGfUDp8tt5uBl6/OuL4649d/bVkHy/ttQ+MdOSfevd/w8rLiYuE4HHpiTFgHH83lmTK25qNPPqW+WnL2v/yO9LBltzsU6c0TTPh0fqsPClm50DxPYM8pcfvwyOZwYL1Z8+rVK5x1+GkqjVJ+JrnIzBYXaKVo65r7+0fu7m6ZL2YEL3KbXDydEwh7PEeamcgjyHB9ccVivkBpSeiIKTH5iWEc2B/2bDe701ksyUJCh5YpGbKxJybsyRUpQ8zizPVDX/8InSAFWsql+xZsXCvJBQyhJ+cRH7Y8N63OKUkeVjjCK6rAU8Dz6i9XStiJsaQ1lz//1JXqIkU8stSObjEUUs1xGvLFTq1cgsxpJ5i/f3fACSN/grPUiRoOAoUYpcHLrx1lF2hNP04lM/IpHjZlhJShLVlJxIdGY4yEXk4+nKKQpijwS6Utpm7RToTQh2Fgu9vxuF5zKB6julCbFZn9YY8PXlLglWYYxqcdk1JcXJxztZqx3o7crneoFNA5oGIghYgfR5xSZGeLv59mSgkVgzDIYha4xkiGpDWGuq6pXE1OitpV0IiDjtWGFCL78YCPEylLFEwKkeQDyctnRJLLmHLi4Ae8H4mlWTJWUzcVV9dXnC87Pr7oWC5mbA4TWv87jsbnlXNUzpE05fCeGIc9fjwQg6ethUWZkxIZSMoklU7QTNd0tHVD7WrG3Y5p6JmGXRFQK+A4xUVSmEhhguhP+weBuXl2HxWSSJmgT+btlD+TFCkqiEd4qqSFfK9XFR3ecfKQIlZXFb5MlloJkUiRsdagtcLZIvbOAskbI8JoZ215pgx1VVPVTemajzBXYQYeo7WORVzpJ+jz+Pzkpx0hR4js+Hfy0cwwSXP6B+/q6a/EhPhaqoAPA5YBHUaM94RxYgojvY+kZDDJoXSD1RaTR2IY5b7MUYAOInGYCAoGZ8guEW2ZuqPEJoV2hs0Lmqwl8shUcp2yTFqpEMxiHEjEQgazRwe1p2XgEdKLz88NBdrh2gXLi4/RbgbW0ywu6ZaXoAzadsxXl3zy+RfMV79Eaai6hG3FueVwkAT4tpEc1pAcY2zQyRFi4vGwZbWqiaph03sgYS3lyxCyZTY/Q80vmXVtYYY/WyH9B+BAuT2fprrjK+XM7f0G4wybzRrjGpx1omuO4rFsCilSaUXlLM5anM3sDwO73QFfkKacji7OuRAaRahfN01pKDSuasloccgJYtV2OBzo+wOHXiLYJHJKNN6qyNcokOnR+QpV6knZCR4JlD/09cN3gln2NyGB0VHuDyzGDFiXyOyBiLMUk+ZUtEzCRMq5QdbwkgEBMs6qAkXE4lhRVTVK2eJqUIyZraOuj/qoDHiBoeJIKDs+ay1V5UBZQupJ0ZODZN/lYjJMPoHJp9cHzKnywZkjq6o4vhutJQlaJYzVklRhZF+z60d5+LUFLW4TYkqhCRgCIr6dty3bbaIfRvZDT7eYg9a8vbvlummZVw11N0eZiv1h4LvvvuPu/Vu+/fZb8S2NWUSmRlNZLZCjHVDacPCJx/34QYE/uzjnbNXh4yNni04KmzM87j2bvefxdkOMEzF5LmYdQbe879f4oWdMntY6yVFzFSlJYazdEnIg+kRt4PzqnMViiXOazfaR3391y+S9mBAri2YQGy519BFSYs1lwNQwn0mawWLRcXFxzstX1/yX//m/5NXVBR+ddRgN37y5xfzX/w84bq0Eg0EDfhrYbde8ef0VpEjlLK+uljhbMY2BRyKT9/gcGWIkZctyNmM1l6+Hd3f0+w2bxxt0O6dytSAMIRNDxORAihNx2om2MybSMR2+NHHHpIEju9jaI5tV7qsYlPydVLoAHVFJYfKHnao1IvXwqaCPSlFVBjuCVYnKWbl/c6Qy+pTQHYtBRVULe9SWIqhLoPN8PqOq6jKdJ4HXFKATqTBeM5JTp21xVlICsUYSIic4ojTSHJAjMVMmRSmqPo4o7f5wF5O8yIkwxCER/IBPW5buwFztaExgS2A3TexHAMeivmS+eoGrO5pxz9BvGPoNhHT6/o2pcdkSB80wbJjyBh8HvI8cxkCYO2rVsSpoUFaGmANKGSprmHRkChP9YUvaIyb98w7jLNoZmYmPyFeG9Jxyr6DuZsxWl5xdf8ZsuSKmxMXlJyzOrkhZM5ufcXH9MZ98+XNWl/8OUzdcvZrR1Y5xGFn/2/+J9MklswaqqkHhyHZFdBWBwG7aMulzUrXk67seZzJnS0vVWcZkiL3jx6uPOFt8wtXlGdvtgfu8fbov/4EacEQoOP6RzAeTYAiRv/rF73B1TQgT375dk1Nmt90zDZM8E2VFVFWOjz/5iEUhC94/7tnsBvo+MA6RaUiYSnaMPo1oZXHOcX5+wVhi1Eav2R16+sM9t7e37PY7bm/vCH4kpYC1ghQ6p2X1QMToXJCKYi5PfOJCAKAJWeG/5wz2H3r98J1g1iTECVwVK5uEYwriM2htVxYFUbpZA3Vdycoki/HxcRHvp1H2Cc98PI+RNMZYmsadGJspy6ERo+hCfAgQA1olKp3lUFRZurpUiDPZopS4nRgTSckzDTshGmh4XghTgVBPouIsRU9n+VOBVO4pSapIStEtl6zOzqhcRdvNMEqzXC5xri4GsFny65CMu1ww32yNtHKpZjd4phC5X+84f/kx3fyMjGUYJjZ3t7x7957H21uGYZCdXFXhKmH++RDFYSaBHiZuNwfut4cPbujtYWDZWIy1fPbpR3yiFFPOHAbP4TDx7W++wWSY1S31csZI4rd3bxn8SEiBi4tLfIgc+pH3t48ctiP9YaBrZlSu4pOPzqlcQ1XVTONIZWDZVUzhSGE3WCWU+7oSO6O2rpjPW7qu5ur6jIvLcxbLOauzJW3XMJ91vLha4ZzibrOjP+z56rv3Tw8uApFrpdnudtzd3HB/dyvXNGdUirx//R3GOlLMDMPEFCK7ccBHg9I1Ob18dlBncgqMw06mDFORVE30keg9edqTYk8OE6lMrX4sEpqMwGXiJ3YqfIqjf2ZhUwgzSqBCDc7KAf4B7VKJv6RG9ojKSDEJ00BlFKatMdYKHB88tRPHl5QhZI1B4DG5fxNKyT1cNzXOajFKT+E05RhjSGSxNSyMj5REAC+2evI8+BDBWNAaw5G0kMsEKYiO1Uc0p3yiH3TgGRUnbBywSvNiPuN85vjxq5a5cbjs+Hq8xjuHxmB1JGXHZCw5BvQ4MPkoMK3rZFxGrNx041BOgctEb4nekIJmHCObPqBbgatD8mQ/kJEzJSKaQ1sZ0BVZZcbStPe7vbBjjabqJLrHWCdMlRieXS6FPgUIWHHW0QZtpIFXWcnu0jmMq3F1RZNmrC5e0jU1Y99T17JmuLx6QTtfoFVifnFF2zWMk6dq72iXK7qLK6r2jqrSzM/n6NYRUuL+rudHekY7X7KYdbR1hVH5xOA5kmJO2tWc/6Dhj/FDZCylzNt3NxjrmKZBkkOyxHjJ/l/uYWMk+Hl72FI7S9dUvH77jqE/8Nvff8V2u+PNm7d084aqqehmDSkpYswMQ8DZGpTi97/7Bfvdju1uh58mkUm1HdfXH9E2NeOwYbfbsD9s5fkmFyRJfq7gw+n8Bini4+SZAtze3f2DqN8/9PpHTIKGjC2ZgvbEG45JHgZ5cCkUfulknetIRg4No2SMNiVwNiWp4Echu9YiSM2IGF/65lKcMmgjyczT5CEErAZri2WaVkJYSEGmz2yBknShQvn5OfFZPnxf+QP2FAUa1BQxcPkLsi3KYDSz+Zz5YkHlapyrxRasqqQAKg0q8gQUSddCRrICjSYZy6Ef6MeR/TCBMjTtjJgyfhhZr9esH9dst1u8D7TW4SqBJGMUdw9fYFSmwHp34GGze4LhgPV+z6LWqJg5vziXKbKtJats9CzjhIrQVTXVYk6fItFMHPyEz4kXr16xP/TcPax5fNzgx4nDMGIVVAauLs/RRUgcxj1OZxZdTchWJhljcUZhrWLWVDRNxWLecXG+ZLGY8eknL7m6vmS5WrFYLUQDpyV1Y5wGdpsDDw8PfPv25oPibrVFoQiTZ+wHwjQx7zpUDGgy/WGPUlpMyH1g8oH1bktIBmMa/DTIviADORVn+oOQrbQl5qoUwQhhhDxC9gKN+kCYEikJ/JLLbjpHdURpZAou/irHIGqtRSfnrMZpx7ypUbgPDiWhdR+X+nKvxRiwRlHZSlxMokgjKivPUsy5BAYf7e0iMQhT0xhN7ayQZFQuuZmKo7H98b435mmLdyxmp5SAGMpze6SfPzfc5kRKO5pcpH/gzDE54gi0RnM1N7xc1fzkZYXDkLzh/fyCKmjsqKiUyAZyrpgoRLesQdcoK7pgpUBbhaq1hFSbQA4VOVfkGJliog8KlxUuI+HQfiBni1CPFEkptLFYZUg4MeEv/rfHeSKTMM6K3tbYopl7eh335UobjpkeWjtEWJ9FS22taF6tpaobutkZXdugdYVzlrbrWCxX1G2L1jBbrGhmHWYccXVNM1vSLc9xTUfdVHTLM4yrGEfPbvJk01A1HV3blGst5obHs79sM0/X9kMI/+nse34WrtdblDZM01A4FWLQnst6SKl8CkvYHbYS8Ks1j49rYpAYtf3+wN3dHfPljPl8xvnlheSHJggB5vMF1jq++fprNtsNu+0W5xxd17FYLjg7P2O1mLN+zExTz3Z3zMKU4Yqci5tUPH3lnJkmz/7Q04+R7Xb3hzfj/87rhzvGmAZnWrQR2YBWmqp2HNd1xxQGEAE7IFBSLAa+5QE0WuMLu44chbGlFN5H8lTU//FIbEkl9BHarhProZzx0yi2TUaRnQMjrLvDODCME+nk7VbCMHMmhql8UB+y8mT6NM/ilzLK6NOOR5bHCT9MzJuWi/Nzfvzlj6mOTEnv2e/23N7e89PPP2He1vjkCTERs0a5jsEHhs2OrR+ZgmcYJ9bbLcM4UdU189mC1WLFu9dvGQ5b7m/fsd1tGacJ5yxN29K2LaOPhHjMBzPEBOvHPe8f9zxsnxK9c0r8f//67/hNY8k+8sVnH3FxvuT66oKr1ZyrxYxX//Sn6KwwGA4p0cdId9nhtcErTe8Dm63EGC3mcyYf2O0Hhv6ASonrc0cKCj8lNtOWziZefPmSy+sVs0XL4mxJ3dRUdcVsVtPUjnnb0DUt1liMMrIHCBPvX3/N/tCz2e64vXuk7yc224n9fs/t4/4DplrwEY3hfHHOn/+sI4TA//mf/CUxiufpw2bNerPh3c0t3755zeNmw+s379jvR1JWdA7Ozxzxz3/Kvu/ZHTbsd7eMXpCGw5BIUWQipsC3RoWTGXWIpQACKkugrdJBdpDFxuy4G872aeftXMVyvuTnP/6c/+Sf/VO0gv/uv/9/Cj0ccFrROGEkhwT4hFOJpm6oq4qAZpoUKQSauiqZbZqQxPzZ1S3TNDGOiboYCXe12AGmU5yXLQxTfUJojrZ04sQhLd84jkWTm0jaElXG5Cejd2GnC7wtKIkqz86HrESF4qyteXE54+MXFf/kpxdcLhqWON7d9Nw9NGySQ7Wea+dZpRGfEvuYCNFKVqFPMsXGSBQuLEpFMEGi22zANQ3GnBN1T9Ajld5DdU1ILQ83N+jWo+oduepI2pKMI7uKrIRt27YVlbPY3jBNkgKzne5FDmYMVdsxbNZP1QVQugLtUEqa3IySomdkVHGVhIZLoLjGGUvbdFjXoF1G1R3tYsXq4pq67XDOcv7qU7rZnL4/0Mx+w8X1p7z69I9YXbylm9VcffwK6xr2+563N3vqrqOZzVit5iyXLbOuZjuU800u0h+c48/h0OeyhPK7jJOkU2QArQpkemTNlrUYctb3w4gwNQz9KATINzf3vH1/K4gESpIh2o4YEpWr+ejVJ1xcXNC2DTc3b8kp0DaWy6tzlosFr15d4Eyk7zc8rh/wwVPXDcM44no5q8malCg8Cf3k9kUR6ZNB/UeBQz0pm7KTkb1BCMfdAyeRtjBiZYGpUMQoOxRK+rxGyxiby6JTa9CKkDgt22M8yhnkQFdK4Y77gKN5sxI3hxg1kNElTFIo6sUnL5ViVnoiyff6XrtaOtmj3RjlvYiTQaZpa+aLOS+ur7harbi+uOBstWKz23P/+Mh2v+dwOKBzFgZUihgKYUcZ6m7OsNux3+0ZJgnXJSWayuGMQRsJqw3DwJQjw2FPfzgQJg8pM+s6cUY/TdDy3sYQGENiM3j2g2cM+fSMZmB9mApbz7DzkdoHVj4z+Ew/ZSzFnQfNJgT23nO379lNid5HDuMkMF3dsrroSCmJZ+A9+HGkrQ1RCy1+tWhpWscnn15y+WJJ1zW4tiZrSTWATIiezWZi+7gpZAtTdISJfd8zDBP7w8B6MzJNHj96Usgf7DZkeBMmolaKtqqhqshtKyxFEvPFgsvLnovLS84vz3lcb1gtz7m7vafvB3SK+HFgv92yWT+y325JfpKvEAljECZnNgJxKciFWIOSQzEXXNG5Cq0TWgkME0MqrLSjfk9+Tm00H796wccvX/Fnf/zHfPLRxwxD/8Ek6IymtlbMvCdfSBMVTe2onGUIWcToWpW9n0yDKIkZc0aBNZBsISwYMbfOUqJiejbBpadEFqUFvrVWINIjEecYbH1EdY4s1JTLu9PHfXphx8ZYoqk+eLSYzzTzTlE5BPYaBt4MhocNbPZwyA1ZV9gqYHOFz9I0+yi7neTkcySJUF8coSJGB4xOVDbhosdET64nmjBhw8BUX6HqFWEYMapH52IqbQUyPOrYdHnmldGoui7Br4Y0iUuV94GUhw/CZzMQUi6mIeoUTaStETg1c9oRG2148fIVIUbOLq7EXuywF7KZrXFVjbEyydftjKrpiClT1Q1NO6ebneGaVia+xTnaVJLeUVcn0/u2rZnNOhbLGQe/IYX8BxSlD8ha5aC2VnST4zg9PV/l5M5Kc3r4ymf0/FsKgUvOoggCGevMk++RgpTIkyelPSlmYp0I0bM/iPHK5599QlUZ2q6ma1vqumax6LCF2HV1dUkIK1KSyLkjYUxpW0wZnoT/QEkAsfiU2Ww2/NDXDy+CaRQMuUA1moxXJQhR2A+nxaS0wyJ6lyIIObln3XJ5wEgosUhgTE9L21DkVymqAqFqqloOwJTEH1RpMf71Uaa+o94keKHQ5vL9jC7+jkYy0OIfcIfLRTZP3LZYDoMQAovzJS9fvuQ//ef/nE9fvGQ1m7FazHh/e8fbd2953GwYhxGnFT6WCBsVCyRo6OYz1v3Ifhjpx0lcYFJm1rZoLbu+yij6wwbvA8NwoO97gveoDPPZTD4jxDXnGCXVj4H9OHGz3nPwmSl++L62Y0QbR1059lnRliiW3ZjBxEJHBLTmYfBs+4HvbtfcrvdsdiP9NHF5seLTT17y4qOP0Ara+xqVRvodzBqD1xmVEhdnMy4uFvzpn37J+cWMqpEbcT+O7IeBzU50g4fNnsP6IGxhLZMHSjH4iPeJySemqRwuUWG1pTLue/ehMI6VVjjrhAxiDdaKl+11kc74GLnfPLLZbvn41dd8+8233N3eSZM0jWwe1zzc3rN5fCT5iewniaSZJimAypKyLVlzGWNlNyYQmKwFuq4SyzYVyXnHlD0T/tlEnou5BPzoR5/zkx99yV/+s3/G2XzB+5sbeF4EtaFxFl01xewhMutqaldhjSUmL0VQSbBuVQg4OWRiVrjCQNbIwXh0mIllgVnQrNLZy+4xp3xKfjDWSFpJCGLbVvYHR1KTKuv3WIqqQeQa0riKVhb9fQsuWC4UXQdKJd6+fyT6zMOjYkgzQm6wrqXWmc5ErKpwCMNzTIqQFBl7WiccoWKjE0YJ0ae2UOWMk7EWT2CeJ7apwasGP4wo9qJnrOpS+CwhhVPqhhL6N85UOOeoQkVQQZrWaWDyA8Oh/6DAh5hLyDYl+FXgT6UVKnJKVzHa8ulnX5DJXL18we37d5DBWId1Fa5uhGxSOZpuTt00xJikCM4WtPMVVd1Sd3O6xQUog4/ix2mdpJm0s4bFasbZ+Yrbxx0hlPSc772eF8KcM03TAJyKIDwVQUnsKEo/ozlyPY/fVjxYhfSYkgYj5gUYCUFXOZGVkBKFA3Jcc0UOhx0hDPzlX/6M5aJjvugI3nPUc+uSoXh2tjhpHuvanaY+ybOVkPbn+sKcYb5YEhJsN9vvTbn/+69/xCQoNFeVODlWjP6o81MYp07d8hGONIUJmo5dhM7ywR1t0kCw4pzIVhXGpSGlEuuSj/u4xOGwK4w4Jey2LLZN2cjezlnH5COoQIjyB7RKZS+D+GWGyPA9OLT3I5ZUJAunu4WkMmiRAhgU/f7At998w7c5st3c8fXr17x+f8P6sOUY3WFqh21qLJp6Btl5JtOgNlvGpBhHRQ7gUkKliHOauq7ZHXZ8+/prLs7PMSrROodrOgge5RPjNDJFz/22J2ZNyobbzcB+nNgOiWRMuVFLt6oULz/+nLN5K2zeectgHb9+uyaGO2KMNLMaW9e4tuPd3ZrN/sDb21tilj1m23bskuXuENj8+luCH3m4u+HjF+d88uULfvLZp9zdrHnz+pab+zVRwet399zcPxJT4s27DXfrRx62W7a7A8SMyYrzxZK2azm/amWflRW7PjJMkX7wjKNMZHHyaAW7Yfrg8BHtkezdhLFc7qkSJqqMyHYaZ3l5cc3V2SWfXH/E4c/+nP7Qc39/D8Dd27fcvn3L7uGR2jppOmISRnAZQGVXLPdvUgmVNcqW4FmthPBkJBi1ahVZD+yHUQ6LLDrBytbM5jN+/vM/5ssvfsTF1RUqHQUfzx5EY6ishJEeVMKSaCtNWxmcsThjGZ2jcY6u0lgjQJRzhqzEWzQEMDmDkbQIZyRcNSMOMSDQFsfDBmFCayW6qnEYGaZRSDqluW0qh9GGGDzq+YFSKmrwnhwCBokgi+HZgZoz+8OayXv6PhJDC6rCuoXoUW2mtl5E4TbjUNgkk61SmUkphnScRxRaj2glRnTCcs1YNMY4tHbUrqFRiVaNmFExRc2QFDFMpD6RbY1uMkY5VNmFJq1JRzKlKrFKzrKoLmhjZOaDyKDG24Inldcp7DlR1wbvRbpjtCGphCsFShvFX/zFX2CMoW4rhv2GO53FyLybUzULIZi5hrqSVAmtPW0zo647XN1iqkqKYjMjhIQ1NfPZispVGKNZLhe8eHFNCIpvXt8zTYkPZ/I/fMWYuLo6xxjNZvO0P8toVDGEj88i1I5nsVyKEqKOFl5CNLRtK387SUOUUyBMHqUjxmYuLs5ZzOe8fLWUXbc1/PjHn9A0FVpzSj2Rj9YUaP7JN/h5sRPN+hPh5+nvlUkRcXj6oa9/BDHm+JU/1NKUj+70+ainBjc/+1Lf+3cok0gReIhZcEZpmfLU0x88gpmy59NKunOV/0GbpuPPAJTptCxRi+TiD/98gUO0+sB1A6XQVjMFz2a347vXr3EaUgysNw+8v7/nfr0hJNnBNCWBoKor8hiYQuAwTgwkRu/JKHzMotELnpAzVYZq8qcHKsWISsWPsjxMPgUOk+fgR7bDRMqajKX3gSlIThpZf9D3KRTL+ZzlvOMwebIS27Xdtpd9jw/MYodrInVU3O97truezWGUfa+1VECIiX6KDCnip5Fd70FXVO3s/8fenzRJlmX5ndjvTm/QwUafwmPIiMzKrKpsdGMgAIpQiOai0QObwgU/BDfkhptetnDDBVfcccEFN9xyQXyAbhFSABJVBIhio6pQVYmMjNHD3c1t0uHpG+7ExbmqZubhkelZA4Qtghti4ebqOjx977577jnnP6BdTciK3eBZbQcG72m/uwSED/by1Zrr9ZrVdks/DBKYjEPlGh8VqhIV/QR0nWf0QQQRDtdIrFViNg+u1uQ9k/cHDUEQofEiYYJKCrH1UzjjcAYaVzNvGsKRZ9409H1P13UcLRZM4wnPn33AdrdlGCfW2wEfEj6KGlDMAhDJlPJhLIJhOTNNlmQMSTupdpQ2AVlUjshy82pl8F7Ufm5Wa5w27Ibhwfzel88OcCqVqY2mMorKlhu/IDQrJ4n8XroepcQQN4s2J1o8A0U5JqNTLoon5dyWW88aQY5K5aqQ3g/3sJSZbFmQcplXCslGdYHhxxAKbSKRuXuP/QIwjuBDZtMlEY/WmpkyNIYDqpdSfpNfRTTAkMUEmD3FSpDdBWtbjqEcU+lFSraeUCpRx9KOKYCKlBJh6IUnmLW0bKwVDMDelebQzlRY68QlRFuSMkx182Ae7jcPOYuCj7OlSlDI28ZawU8oVWTsEiqFUkpWxerLlQBu2bttqJKZWluhrUMbiypGv9ZVxOilguTq8nnyXovFnPNHiVnbMAwjk/flWt4Fi4cjc7SYYYtqi/xzmQz7ErEqZdFDy7CUx3W+W+ezZH57nL/amxkojW1qmtqwXDQ8++AZi/mc5XLJttuQUqCuHVVlIUvbYF9G3Qcz9uIN3OOS79s47wiCcmxIReQtt6BfN94/XBZxDIrCizHckbcVcpEPfZPSe4gSySRWGSmHZspJzgVVVnp9DkSgN6KscMtMuen0fjegs7y32qM15bUZQYZmpFdoXblxyAdpr2KqXE7u3XDG4qwrIINwcFqW+r7mer3i+vaGX37xSyqjC49KM0YJajEbmnbGk0fnnJ2dsVguuel3XN6suLi+YTV4doNHGyuZ6DiyG3rq4rXX+8D5yQm1rUmTyE7FMJKUImhDN3quthO3fc+qmw5N+MnLsWqVUPfEmCmn98nJMSeLlqv1Fh9GOj/y3eUNfhKT0VMLVcxUSbMdRnrvmZIIL1sUKYvlya6fpKcUINGg3AzsjFXvubjZ8vWra75+dUPKga9fXxK86B6ubzODHxnDSEZ4bvNWk1VP3U28Xt2IGlCCye/7EIrlckFd1cyahYAwQsdht5Uz6+2W1WYrG46csTmTtcaV5+j9NktJyV4rhdWaum5QTcPJcsnQD2y3Wypr2Gw3/OTmUzbdln7oub7dsu12bLsdN+s1u37H7XrFrh/xMUgZzZcybj9K5mAqtMnCp5QD5W7lkLn4+Rdfslqtef3qgsdn52w2m3s3ryqZgyaGCZWicAPritoqnM6FlKyxVlEVZZmUsvTSFTSVLRXujDIGazS11fgYSFoMrvdbJVX6WJUWgeSY0sG01zqLIZd+lggka6XJeKwSuo8p/SJBVHpy9Fik/FWEYg9nYbutUbah84GkK3R2mKhxoSx6LpGUJRRaiMoBw4CBgkROiN6nKahtg04yR3WmeHYaEXwwCbQQqBsn5yJ6TwxZyvNTJNst2W6w86VUQpZLdD1DW4UIfRUAn1JorJT3XE2cLw67a6VEo9Y6WaRdZaiCVAS0URirqOpKaC0Zbi6/gxxpGxF9N1pjXYW1FdY1gqzXDlOUU7QyuLrF2hptxHjXuArraqYxorWlbueY0juzruLk5ITF4ojHj44IYeT6Nrwj8O1vI3n8yZMz6rriLkWRTUrZRaKK84pwrPctrFzWbjkdOoORvEjWcXX32rPTEx4/PuN3fucTPv30E6rKcXV9yRdf7Li9WZGShyyB3Gh9uM0lgMkcy/ut1z1K0f0guP8+e81RKBSav4kguIcBZwr3LZcAVlLUFIvXXzlRGSCLQ7XgWIoSy72UJSVkB6gyKXCYZHlfn0iZQ/FLGfZ1KmVltxHT3c7jTvdQtrni6i5w5f2P9AZ5UC7fm4eK7NP+1EuwNNbKTrd8n6DyXfKKXLgnZws+/fgj/t5/+HMenT/CasVm8Hzz+pKvvn3B7a4Xke2spN+CuGRjxDrppz/7Kc8fP+XJ+Rm7zYrV6prX1zd03cDkA2PObPqBbvL0o3icGaWlOmGlnBpCKH2Au/F45nh6MuN07tj6jm50hKH0KpXh/MkJKEVIiRSkfHi8POP8/Jjj4wVnZ4+obEtl52zWO9brDV988RVfffGCr7/8huQ911drLt/csln3pJwwBkFWJkXwxfAShasMxmmwiWg82SnmR3Pa2RF1PcO6BcM4sd3t2GzXbLqR25uRaZjY9v0hu0gp8d/96Z/x4tUbmrYpCjaO+WzGrK1p6roAiSqauqFpxHizdrbs1OXCG6tZHi2oqo/xwfPJ+BHDJMr3235gGEeGcWTTdXS7ntv1LRdvrthsOy6vbxmL/dU4is5tTBDjBErcFA6KMkX7dhonPv/l53zXfsd8NuPk+IRpFIHxcnOJtF7RZHRGi61OJUGw0hqf9159Bosi54iPvsxzhc4VTme0lUV53z+pEygVxaswQ86RygixXlsjtABRgafSYkCcY8CUzKTSRcnGQrQGg8OozBQDPnjZfEZxcEdXgvo+DMUQLDpbxikRdUIbjzETzjiMsUxhD67JRFN6TVHvPQswWfh+igRGdvkGK7t9Vcq+VkxmKxtK5U6RjPRic5T1QUUYvWeaRC1pGjqwDtPNcbMlpm5R8yPJDo0tWAUDap+lqXvfCmato3JG6F9G+M0UykGIib1IdsqRyzffEfzEfD5jHAIUOoUqAtrKlB8h5slmpKpQxQpMMl0B0e0TNeMqUPowz45PTjhaLvnpTz7C6MzN7bocw8NAuAdKaa2Zz5oSBO+th8YUqte+GidVMUkOy/quS0ugPGbLxsMazfF8xvHxESdHSz744DGL5ZzT0yPatibnhHM1oIgxYbTBGoe5r7J0KI+oQ/WBQyJUyrJ3fasHx36oNhYlpPcd7x0EvU+MY8QETSiIUK3v/MvumHT7lBFAlwCw36GX8kU5uaWSR1YUFZlChiwAmhgK5jRLpilyPRld+jJm3wPS8SBHNoW9bp28Tio1smtWShXX57vvlWIiefn0vaxaKhlE3gf3QsgUDy65GAfpH22onaOpatabjhg8ry9vDj+bvkdRJrG+88+KOZHIuKrGVhXGOnbjyGq74/J2zabr8THhUfQ+MBbO2x4opLQcozkg9x52mbrdjq62DGSGaWKYPFOMKC2oQR/lBh2nkX4YCTFgK4t1hrquqCvpaahyDScf6XYjm+2tyBp1O/rdSLebiH5fksjivYaG7KS0XWy2JFoEzDQRDVShwWbhzWkn9kmRkc1uEmHtTvqDu2E8VLBTznzx1ddc3dxSNzV1Mdmcz1vmbUvb1CwWC5qqpm1aZm2Ds5amErNjU3Y8e9SeTC1BAseUD721GtkR51LWQmWGYQRg2+0KGCThVUCshZL0nWIQSb1DaVERCYxp5PXFhaA6nWOxWNxJ75VjuLjZ4n0g+JGcgshsjZm6iHmHbPERxpDRCEBsGkdxY0Ez6/fu4VE4q1p6O73fq3MUCbkEs3aS8qsxjONYHFI8xkpvORXRYmsscUpF4ELmUIgiFj96zzCNdP2OFD0qepQOrLf+DqWcM7thi9KRfppIWuhVpB4VHdFb8mQO1Rhj5IyRp6ILDDqrIkuIUPAOQVDQsdZCXX4qrw9BcPQioD76TO8zQ0zsRphiZopFf0hb1KbFzSUImsUR2jmUdWgjoJmoK9CGcfXdoZWSc2a77bi8vOKLL7/i8uqWYeh58eIVSikmP3F1teLlqwu++OIrPv/8V4RpZDafMwbLdjeyWne8enXJl19+zfXNmroe+e6714CIhFzfbHj58gJjaq6ubgghsVy+YrtZ0+96Lq9XvHjxim3Xc3l1y3KxwLlaTL2tuUMCv5UM3heeGMfp4b/nTBh3B5ee4klHLnQHtV+j9b76J+t6zlHcSoyBWY0zirZ2NHWNUYZxmATxHjyr7S3r2w2b9ZaL129omxajDfs+erq3ON8dqS6Z4D4I7p+Q7j3vLhNMSnF5+ea9QDEA6tc9UUl0K7/vD4h9G+29x74n+Ov+Ib/9YH746IN3+A2fn3/wL/LAu9qC33v+4fv++hMp6hFF87TsUFLaO1N8X8j2wWvV3euUoggH5IOAwOHyvt+1fDAqax4c/b6Pdf+zD5/w1uOy6VLs92EHs8p8hzTc/++9j+1wze7eX07xPduXXD6r/M7+s++9zf3zrO5NhP3v+/csH/nw9/cY98/H4eYqx7UHlBye+44vf//YOXy/hydiv5G9T1R2tgCz8r3b4jcc9P2PP/Th872N8uH7vOPF795Mv+N5e4JR/t5zHz4mR53JhRK1f/m+9HLvZr93/96/hu873vX0t8/X2987v+OxcoDveIM9//HeyJkUxsNfRb9VNrd7g9e3nRvk/jYSVLh3z5WMcQ8ACcUw4E6cGnJOh7l+ZzVUSoRlPu6l8YRHu6/IxQP95TcNUxyQ91xRQDYpv3F8/70PZ07t+3fq4E354JUlqObMoa//vlPxtxnibuHv//0HZ9l7B8F/P/79+Pfj349/P/79+O/j+HVB8L3LoU3T/FbNxr/KOBgr7gm+3Mvr7++s7/1+343iftP0Xe/d9/3h73VdfQ8s83ZCfvfH27v8fa7Evd3tb97WvntncZf1Hdwuyvvvs7Pv7Zr3WYOS143jvZ2quV87//Xjt9yI/zUN9c5f3x45Z0J4f/WH/38bb6ty/NCm01U1vDUP/11dlwfFj7/ka+8eEF7Yfmhzd4/cfU7p9ij18J66V7q4O18/cIwP7v0frmy875f4XvZdHjgYvebCXz18prr38u9nyf99HUJKl9/zg6rHu559/xrld1Ym3vmS7/2b4vvp4A/WD7/37++sUuSHknC/brxXJmiM4Z/8k3/Cz3/+88Mbvy8R8V2zY9+vu+9QnXIipIQPiet1x3q749vXb7i4uGC7WTMN64NKf1M3RW5sQeU0lTOcLmecnp5wtDyiqWcY63CuINuU9L+0Vly+ueR/+l/8z1iv1lhj+D/+H/73/PjTH6GUJoW9NFYsfaKESuJ8PE0Tt9s1UxC6Q6XFu60t/bOm/Kn3AatA3rWxpZSIOHjHJKT5QxmmlDDKeb28uuLP/+3nbIceFJwcH3F6dMTxYsHT0zOcM2gnFk4+RMYpcLJYsN1u+V//b/4rdn2P1or/xX/5E06OG/YriyIXMvN+8ux/BGogiKvyJxqTTTEpFjI0pd+0b9Bkk/cvP3yPQxUV5H3yHtm1V+25JzRdFvz7wf37xRNYbQb+L//XfyFizu853t4E3V/I4K6kuj/n+7KMiArH771WCPmCxBvH8VAeltdqrHU0jSwe4zQeyrDOWY5OTjk7f8RqvaHbbHnz6vX3jtdVNf/L//r/xPGjp+UY1WFBvv9NDpug8pO5e9L+YfJeLeTtc1nELFRG61I+ixav9zzegElKgDZvD6ml3/vrvRLxvhdTDvj61bf8n/93/yti8BgDf/d/csK8bqjzjN3Yk1JA28jpYsmsaRm8+MiFlHDWkFJi1/esVx27bmK9GfFe4f1eKUR61m2jqJ1iXifOjo84Plqi3YLdOHCzXpFNvCsxiqgNaZowBqzTiBeXIHfHfiSFSF3ZggoF3w+0bc3jp6dcdbdc3u74gz+4JGd5zw9//Aki9+jZbrf4yTONYyl9HoTk2Ad7ORYFKh8W6ANa/q267Q/Gj7sdwMM95H4d3Rfu8sMXHMr6919W1uAMBwjHfD7jv/7f/lfM5zO892zWa3wQkWrv/eHeyDkfcBLee7quo+93+EnskKTHaw/3c6FcA5BSKHQ4ha5E2MFVlWBDEDzIOAVCTMWmT5DOh5pkFppUTAltHWEKohE8FkqI1kw+srq95V/84R/enbu/jkzw+fPnfPbZZ+/dbLwbh2r84aY9YDiyEl+vGBkGEZTe7kZWfUCZgNIVVT1jljKLRV3UAvQBENG2MxEldpp2XtPOFzTzBYv5MXVd07YtVVVjjGgEGq2Zt/MDKAKlOD095fz8nOAj0+SJQdTzYwqEGAWdhoL5HFc7ecxZamOojKGta5yz1FVV5M2Ky8b+x1j5ziimENj2PduLN6JGUer+BxmrmNj5QNQarCMrCCgCiJyUUsTiUDBMgXGa2PUjbdNKkC2nVQGLueNo6XiwD98reiglN8ieM5WNBD7jSg+nOKCnXAJ08djL8QCNTjoJ/kUXjqeigDE43GkGseFRxe7nICytFGDKDv4uaL0zg39HQvuuDdi7At/33uoHtqe/aU7LonU3j+W9Hjyj9G2kl7MPQzEmpnGk6zrGvsf76Z0NEKU0x4+ecfbkQx5exf0m4a3voLi3idr/cX/ZvfcZh8/bp1mJob+BpNDUqPkCrCHjMVnJFHmr2nAIgvcyhH0QvEPzyf9i8HfnWSlmjWXRVjSpFQOVHDEuMm8a2qoi5yx81xRFaQSF047G1lBrstdMBiYDGUG8VpWmdorawbx1LOc1R4sGnzUhCmK0aiuhK2iNSgpSJjqF0Rlj94pUEHzGVBqcoqmdBMuYCFpQktpaZosZ87cUmbRVqOKmYKMhmYhVumwac5GXlJ/DHD+kruV/94PaW7+9PVPzOx5UD+bAPsqoey+4/+R3PKgePqS05snjRyyWc7z3tG3NNE2EEJimqXhOymv2zjshBGazhu22ZhxHxmEUlSEl8n4KhUr5MI+zyocgaJzoq7q6EtNyFDEjSOIk4hTGCFdVZQrAMZYgmEUibQp477FuD8hSaBPYVT3vO34rU1344YXkvV6L5CQYdUAu+SCi1m8ub7m+XXFxec0XX3/H7XrLxfUtOUesVTx5dCTBrCgZpMnjwxZIaA23t4qL6zVt03J+9pjFYsHx8Sknx0c0TcViXqOVQXG/8ZvpdhPXt3vz2l4CYUqEMBGDxwJt3XByfEKKCaM0i6ahcYbaarFP0iIuu9dp0EqoJCkrMWstouPrvuO712/4g3/1r7hcrej9hHOOvVj3OIyMk2c3TA9W2XlbMa9rnpye4YygHF9fXB5Epz/58EPhmN3LYvJh4boHLEmSFe8FnlVSKK/JXtBfprbieoESZ4QEOeliuQI5K7TZf1cJhElnTFH70U6Tdck57mcqFGzZIUJ+/1b/q8yrd433CWz7cVc2ye8o40gAjPFOCeUB8CRnQggS4LgXwspzdrue16/f8CBWoMjfW5DK+XnXYd8vvd07h/t1bQ9auyuX5wfr4v6DVc4QI6vvviJFMHbO8uPfwbpa3ijfyybuXnTIbPffVxUEj2QWD0+YvnesCrDBYIPDUaOMeHJqm8ErhhG228QwBobRi0izfEl0amlzjasT3kQmEwnFmFWR0EGAJ5Vqscqgs2Zzu6Hre/rtjqZaUhtbiPXFocRkMhFSYBwD0UeGncc5h7OGyohw/K733HSJKkRSNTI7bbG1vqsokJnSgLYaXMbOFdQGVRlRwIqZOGXhSaf7M/6uInHX3bk/mXgQGx/GqHdNjPzWZNRCL7t/6Q8xUaJy5q1L/PBqo4pMmdYa59xhfu9bYdrIRmUPPFH6TpJyL2Q9jbKOzZpWuKn7+0uJPJ8kB/puziNKPShJkFylMLJfKwFVC10uS9BNWaoasWw49o49sQTmKYgm8fuO3zoI/rajdPcQ4npinALrrehHauO4vr5hdbvii8+/ZLXesFpv2e4GpiC0B7HzULiqPvC8DhdLxAuBjE8JvxNVk20fqeuW2fyW5XzBcjHj00+ecbxYPJCryhm+e/mCGCaur29QSmOM5fjkmLaZ45xi5mraqmY5n4sEmxZqiFGiblPoySSlycaRUPRT4JvvvuPq5oZNt5MdpXFcvrlitd3w7Zs3jCkRyeQ8HnaJqew2s67Eu7Bopcbe04+JzfbV/tNKOTQxTpkvX74h+ulhDVwBSpCrRldo5dCqJqGJRYQ2jh6/3TGsO1L0VHUWv0OtIeZiRpwK+rWgyfbrZAKdRK0yTIGoI8pB1Tq0kwVDl4VZP8gAFVIW1Yf793s9nf3F4fuL7L+bcYfgNMbQNA2LxQKtFev1uvDCJJP1XnbJvpgJ36kO3Xu3eyWuHyzKPEw0f3js4Z8l8zckCW56bz+m0O94mVIK320Y11f86g/+7wQfcPNjfm8xp6o+JGvzoOT5vS/xjvfTeX9nPzy8+68e00iVHUZ5ohb5uRBHfO8JU2A3JELMhJhxxhVuXxSuZKU5mc3xPjNOidW2F+6sn8iTx0wKUzcENbDuExeXN0JvshofMzaLWpCOQEz0PqOtwdiKaqZh9GyHLc61JGu42fV0u4HdbiTHoss6bJm5c3T7UMM2MGK0QTsxiNZoXHTkqMkx4ftIHDN+SKQxH5SQ9pvJHzq3b28PH24pHtZKhb8uUTZrUFrRnjeyTqbM2HmiT5Du/FHfnmb3912yby5iISUIglgWaa2FC2ztIQNURu7sGCN126CtEW3mIpzfj2NRJjKHNVuWJQ1aREasdVhnEapSFk3bskZISVWG95O4oZRJtlcBSjFCEs6hKklHivGA2H2f8TceBEFujJjFpmO16Xj1+pJxCmhbc3tzy+p2zYuXr9lud3S7vgQVWURjaUjv+zh3F1FOVFbC+4sZOYE5EfPAFDI+wuQTIUae9GfM2+/3lXIMpBjIKWKdqPO3bUNTW+rKMq9qGlcxr8VkUympa2clbgEhCn/Nx0QgEmJm3e14fXnNxZs3XNzcoI3FOMfN5Q27cWTbD2RrRRUmyMXaQ6D3xFgpkapiq5OJKjIlL6IDORHKeQlZselHpqF/2JhmX4Io76s1Wjly6QGKOoUipJEwCEk7JY1yGWXtPh8EJJM1RuPKZAWhCuz1KGOIch18whpR2rC19NAelOnupSf7wH/3eHls3yN5q9z39vjLZo4/LCN1/9jkb9ZaZrMZ5+fnPHv2FOccFxcXVJUo+KckvmVXV1fS4wkA8a7Xsv/ed+/84N/eNe5b3dw/pvKPd6/dZ2h7InneK/9///vtv3MME9Nuy3T9hsmP+GFHGjt09CQlC9R9FRv5mPuUmHedrrttyjvPaeFmChdYylxjCIQo7YZAIqpMVGBVLu4rCe1Km2NmMR4wCTtOhBSJUxKh+qQYfcaMgVgECqw1NLNarKYUOGOKNJxm0uX+UpYQRVc1RkXMGrJmNwSGSTIJCccJUsBppEVxbyQlfMmsNVrsS2X7ISUSrNF4I7ZTU5CMJeWMSMDdv64Pblr2Gf27ZveD/qECW4kAhLFaVLYcPHq+EJ5gguuXG/r1xNilgzdqelCledeHlLdX6pDZOeckg0ziLJ/2wEUKOzyL9jIKXOUO19ZPoWSexahc64NRsZgO11hrSmANMo8PM0rdrQcl6MkG8/5jQtkiZ/ShupJlY/BbtO3+HQRBuZzeJy6vb/nFL7/kX/7RH3O72qKskJk1itvrovAfE+1shjNiWBl3XjKSew7YMUn5LsbCqztstXVxhrZkbYhohingRk/Xj5yE9ODiKwU/+eQjPv3kI7bdgHGl8d62WKNEEzALId0e9teZYJQYdObMlBL95Nn2E0NIbLuez7/4iu2up9v1/Oqbb9HWUdUNKhQVDNugnCWjCFPPftE3VgKTZFulGRyLVqoupVwNWUn/MJXvHWLEZ/1wYusExdIpxQliROsMRSfR5UyVIlYZ1j4yjZ4xZywZp2E5a6krIZrXVSV2L9ayKyXbYdcRJk+YJsLkxZw2juTJ08wqZo+PKG5WUopRIop8qPlw50d3Pwd8e7f67zoTvB+QHz16xMcff8w/+Ad/n3/4D/8hx8fHvHjxgrbYvtzc3PDnf/7n/NN/+s/46quv6LodbwsXyFbtbsn7YXjPwz3623y/h8/cn6sMeUJIzVFWQeMOZ/juveT5YZrwfccHi5ppDExmwMUeFQa0qR/mdHt0ZvnfX+YqKGDZLli0c2xo2HUbBj/STyOLds78uKIJXubTMIqSDQqDZTFz1JWlbRTWZLTKDI2UEnd9Ku4PimlMWBWx2vC7P/kxs1nFbF6zXl+RYmBmYV41OGW5JeNjZkzw6s01fT8xjJ4YRfJstR5QKlNZh8mBymQaq3Bk/AMxikzSkVS0jrW9k0uz2kncnyumPjFuA9s04ofIOMR9QfLXnrMH5dMHd4dUZlCgnOL0+ZKjs5blSUU90zQLzX/0Dz9jPmsgGv7wv/2cL//iDV/+yRsEMPV2ifUHjqEEwL3qUNM0YncXo5QxUySkyOin0grw1LUEtKqV5xprZI0qailV0+CqimbWUtcNzokDjFb7MrPo14p8v8zZGMROLqdECh5yxipZd1WKmH3Ao/CxUyTHgFXg/ka0Q/nNu+937QT3+M9+8Fxfb/jq65d8+dVLbtYd2s04OzlmPmukn6Ygq4yPnpA8MSa8H8UE9B7EXOxhKLXmUnRnTz41B7udnBJV2+Ksw/vIdjfQdf0DwnPjDPOmwhaFkKz2nm2S/ehSokw5H0oHMWfGnBlj4ptXF1zfrnh5cUU3eqYpsN3uxC3aVQSQjCklzH5LnCEHCeAiEFx6LblsnPPDx/Y7IkXx51P73l7R6Mnf3/hoZTBGBHrrqsVahzO1iOv2I2HTETrPeD3gtx05g20r4jjhh5F+vaZ2VlRY5g2Vc2LzUgx72lmLampIibEbmcaR3Q6mXST6EW17qnmFa6sSBTJidKnvMtR80N+5V+Lbw0refyf3248ffu+cM8vlkpOTE/7xP/7H/OQnP+Zv/+2/zaeffkrbtnz66We4sllarzecnp4ePB5fX7zm6uqqOFHcK4Fxt/j8+m+W2SvNfP947zK8PfpQqcjQb0nTgK3booFpiwrZW5sKpXDtnMX5UxYffwZphLZifnKKdg3TAUmYvv/Rv+YsPgyc33+OyqLuYpXCIj6WTlXMmhmL2Yx+GrBqgJAxiOl2ZTTOOqzWhJAPvR9lFM4p5jODnwSItJhrzk7mnJ4s+fTT5xitSGFit4KM4rwgq5u6om4st9uO/nZDygPaJI6WFcbKZuzxyZLZvGW2mKFUwOnMzCkenT9hs/PvCF25yC3udUzvENKmVlRKo5QlTBFlFT4mkr+bF4ddTskMH5Dp71IyMQ03CldZXO1wjeX48YKf/90f8dGPHrGYV2TtSXri/IMZrpLnf/r7RyjtefH5FXGIBJ8PpgLvGgpEO9aYQ4Vqj2RVWvRU0WCdo21bKbGHIP9WrL1mizm2cri6pm4a9otT5Sq0MWWzLy2XmBKh2L+IYbOUNyV+aXzwxfJLtAlzYRAQglhjUaQEtcFneZ24Toqq0vuOv3Qm+NuiRIdhYrXqePnyilcXN9yuO0ztRerHOTFgTSKKHeJESrn4UGWcdhIUShkupX2DN7OXaRMIshEVhbujxBXn+GkKbLqezbq7d+yivt84K1Y0KRUZqoe7JglIqVAdMn3w9MXd4dvXF7x8/YYvv/mO7SDu5ZWreVrJJIjlDVSRWVNQbgKZ5hpdKAjihqC1qOPHUj5RpX52oBbAoYa4PycPcwgZEgQtlauYty2Vq6lshQqeGCf8ZovfTAyrgeijWAIp8D7ivacfOpw19HVNmmbUdU0MEeOaktk6jFYYDQ7LoC1hjPTTjuADuhrBGGxV9HjLccuh38nP7a+VnOt8AB/cL6P+9Y63z9S92VLmxXw+58MPn/OP/tH/mJ/+9Kf87u/9LsvlEmdFZ/EO9LKjrmVj8e23L8g503U7vBeH61iUQu6Hil9bCr33TClNls/K914rEx9Z4hN+6Bh3G1oyzlhMPTsklXuHT8o5tXVLpc5YPv+YSkeq45bu6JjRVQz+Yeb5oJya74fhfbB8+J0OL33wBRVSqJIF1CqFVRqrDI1raJsGlPSBvBH/TKP3AVDoTTEG9nteYxTOGWZtxaSFijKfaY6Pa87PFzw+PyaGyHYd0AXAczSfcXK8oG1qkbDLHtYRdMBYWMxrFMV+q244Pj3h6PQETEDliImes7NHYIaHF+OuBiz3tr4r5Sul0FYmu9KaerBkYOh18Yq8n9+pw/lTWaFUFjcLxQFwp2tNXRvmC0e7NLSLmg9+9Ji//Q8+4yc/fU7jHKPf0fstyQ4om6jqyPPP5sQQWBxX9MrjSXem4vfQvveH9LrVgat8CIJKQImJVAJeXTYmd8LXKEVdVWhrsc6j57ODdLMpmdl4j+oU9+jzEA7lTjFR1yglMos5JnKMUpxOqWSHAt8z6h4KP4nNX9QQlWA23nf8jZZDYxQB5RDh6nLNm8sVl5crvFdo01LVR2jbgLG0dcNuG+g33UF7MQZftDX3wt35IBTtnGO+WLDdrEkxcrSoefToESdHJ6w3Pd4Lf8RoCN7z5VffiLr65ZsHYtMSSMrtbaUT0I8T0zQyhURbjBtJmcubG1abNb/6+ms2w0A3jnz94iX96BmmAFqCqXEGbStsVRMQuxmfYe7afRgsfMK7zFCCezwYnJpUeggHTVYpFKhDCfGuZ6fYW+WUoRBOlXY4XZGmzDiO7IYtfdcx7Hq01SzPjnn65CMuNj2bceSyW3NyfMRZ23J7vWbXbbm+XpOnibp28jojFjO21tS1pakr5vWCyjmaZsa66xkmz3a3I5tIzCOn5/OyOckcaBI8LIPeHw8pEH+9YfB99m6ffPIj/tE/+o/5T//T/5zHjx9h7UMpqf17NM2Mzz77jNPTM46OTvjl55/z3/w3/y2/+MUvePXqFSHfyTb9OpajBBRPxpdnmhI81L3FKkmFAH0IcJYJhhvy9hLo0Tph65ZAXZ6TChJQEYolUK4aTj77OY+PWz756Al/ttO8GTK31+LcIBZJ7wrZDxtJ+3CQ9tdHZSnh30NfZwr9QWlm8xZdK0YfuFmLYfV2s5FAkzNtQSLeIZIsyjqcnokAcIg4N5O5rmEcdqQYUFrQnrtuw5/86R+RYsSPE7WraZsanyIX12/IOTKVjcnJ8THTGMgJFu2C46Nj5rM552fn4u7gLMZ6rFa0RlPPjjHq9q2ZmA/tJ7HYSmSzP2WSbSmtMJVmdlJjG0vG0K1GfB9IYy7i5wKI22+W3FxRt5aTZzNOHrcsz1oePVuwPHacnVdUC0VTz3i6/JjH1Tmz7YzXX27pPHSpYvmpoVp6VNXx6SenPDs5Yk7Dy287Xn3b8a//5VcMu4n8A7zb+6Ij0p6S5+3ttMbJHzap2micchhjRBM5F6Nho7HKkYLIvRmtiV4MwffMEfbrrtJobaUCojNWKVIMkDPzypR+isUW4FYM4lmZc8JofaiCBQzRKGZWM0weP1Y8mMq/ZvxWQfB7iuT3JsPdc4T8mlJi8p6UwYfE7XrFerOmH/rDTkgryCkQvSekiTCNxGlgTyQ87DyzKh2k4mptDVXlaJqGvtuhEszqGecnZzx5/IicL+m6Hu99gfZKELi9ueb1q1cPUJRZSe/Q58wwikjwd68v2OwGumGisXfuxZc3N2y6jhcXrxiKqPW6nwgxEbM6HOt+IhhrpPyQpISbihBtziIGTnEdvwtnqUwSXRrtglDLai/qnUs2dfcKAUZ8vx6acyKmyORHQg5ysw2BKXmiEVcLrTXBacy8pnKaGo+tKqy1LJcLrBEvtFljqKyhskKREP6VEmeCEBhSh0KT0GgrN0alGiDhp0j0JR+w+jBxDmXQe+Od3L7fZoL+hvH96oVirwx4/5/atuXs7PTA+3zYqbzrNSgFVVVzcnLCT3/2M2bzOdttd+ilvPj2W/EiTO9YcPLbf5WQgkpw8FDcK6rkh+cqCybZqUStAkp7jqqMMRGTPRFb7pl94OQQDJXWmOMTquM5s+MTar/Djr44NZS7LO+/670aw35+l3vwLpuRc6hzQmWDuqfer1DF1HrvqCD3wTh5qfToAoYp7QLpp4JPoTgmGBpX4VTxlysO9il6dBanAJUyYZoYsjjO78FMi/kxVVUR2dssWU6Xx4SoOJoSBoP3nhwzTW1pW8fp8ZG0GpCsU+dECoHV7Yqbm9vvbdcOZygXk4C8//s9EAcZ7RQ2a+qFwU+GnJMYgGfZdFRzg60MTWs5etwwO6p4/NGSo/OG+XHF6ZMZ88L7da3D6ZZFPCZ1mm03cv16yxAzo1KcPJ9Tp0hrEmZRM7OaT35cszzpePTBlu9eXHBzkdhcx3v32903O/Tx3v6upayvi+PDnipzXyt0/z7q4I+650wKdSEl4TrLIiY/d/Z7pvT+oliCaUVbVwezBYUkIlEros7FuDcd2kEHJLzVpCQl9fcdv3UmeKd8/+DRw4WPSRTmfYj0wyi8De+5uLzg+uaarusEdq/AqEgKk8CI845x1xGGnag2GINxddkNK1Q2sswqaBpL09TM2paNtkQNR7Mlzx494aOPnouzQUxsttuDiGvwgYuLN3zzzYsHFzlpS8AwBM/NZsftes0f/cmfcXGz5nrVCWy7CGTfbDcM00Q3DYeildJ7Q04hhIPU/pUWxwBxI0hF1DbJhSeRD04QAiiTMmlErEmV+EkqRS6wcpQqllL5sGCK03cqfaR0/3KQUiCEkZAnUig3ZZS1LFXC54sqk7RHLWqqVLGsFK6oupycHrOYNxwvaxwRo3JxHDeFnmJLth7YDBtQGutqVDXDOcu8tky+x48DYYpoJYi5/VBKJvb7Fy3+Jsa7P71tG05OTgjBM40DrqoeCHffH845nHP8/Pd/n08+/pizs3NRwXCO6+tr+n7HNMXfHMzzw+t4yJXz/SJpKaAVr8RaReYmUNvI47khVeCVxycriEdZzmXDmfIBRm9OTrEnc6rFkupmpGJE5VxatxJw7wfC/QYt73l8HMJzCY4JrTw6G8y97Bdkw4rS+Cj0qH6c6HY9VieMTtSagtg0hCz9v3HyKCXZcNvOcRZqYyB7/BTZ9j3RD6QYscbgdwNRDbSto60bHj16wtHxY7QybLcbXGVpa8eHzz8AFMEnlu2c7XbD1dUb6kpTV5rj4wUhiEeiUZkwDWw3W17fbPjm5fVbm6i7SkVOpaCzByuCiIirUtqzYhA8w0oVSiXGvijaGMXRk4bFccXZ0xkffXbGyaMZH3x6Qj3XVDPN/KiiKv6j1sxQviG/OmZ3taO73PHddzdEKpSbU08nzHNm7sDNFrBw6PSET35nxxA2/Nmffk7Ogc3V+FYdW0aIoQSsO5u8g8KNEgJ8yg+VlfazZH9G9vdK8IGcEiEI+jznDFoAj/uWDqpszJQhx0gYByqrqIzmaNaybx8d3HyiJppMjIppkHmrsrRcBECoyMn8DQbBffJR/ovxTjUgRWlaTj5ys1qz6wc2Xceu39Htdvz5X3zO64trtv1ASJmEJqTIbhwJcSIOK0gewfpqktIkDDpqYgQVPFZHrIFaZ9LUcfmyY9z1oihAImVPCBMZT8KTlAcdUUpTVZZpHFiv13eBPGd+8fV3XO4mvn7xkteXb1htttxstoQs9IMw9YddUMgFbWkbCkxzX81kb/6YEC80ZRTWGpw2BC07InESk58cAzkrtDVYpTFG6Bw5R6ZRVGk0AtBJxSA46TLN9nJmKR28s9I9M1OQhXJPUDPVXRlNEhlFGDNhjOzWW6zLaOs4WSzBJ4gZnzxZJ0xtcYBTUDtZUKW5XRFiwofIZCYSmUCAPJJzJLOXIjN03SggJTtjn1j99ff6/upDKcVs1uCngZfffcs//af/Dz549oyf/M5PODo6EaNUUx12vg92xFoxX8z5+c9/j6ap+Q/+g5/z7bff8uLFt1y+uXjYcHvXyLb8yKbvcCWVJlP8I8tMqwjo2DNuX+F3a1QceXSyILsarzN5u2XIhpGGUIKJIeL7jjDuWLuOpVkwnmR2tzeMq4kqWpRKKC0gH/k4dfjcrPa2NXcyaTlnNIE0dey6C9SU6S/vWQ4h5bOt2gk9areSUnmXaSqhQCQU83nL0dEJ/bBjGkemKeDHgRwDjsxi1tLOWqbRM0wd29s3LOdz5osln3z0I8lfs2KxmJMwjFHzx3/ygtWq4+Zmxe/+9DN+/KOPePbkZxitiGHi9OSMbbfm9cWSYZxIOfPm5oo3F7e8fn1FP2wJfsSPHd0UuFmP78RBlEQHlFRtlZdgKMpKUu1RVkxoTatojzWurmiONGePljx6esQnP3vC/KhicVIxP3JUtaGdVYXE7zhaHOFMRaUq0rYmbB3ddY2KFXW74IOPG5JxKFexfLykPgoE3ROxKG1YPhY6Vu0Vn3z6nH4F3/xizZ1WbTxcr1TW9HjP6kspRY6JmKMEmdK62eMnUKCNRZUW1r7HJ9UHoZoYVbiAOZHFPJYcSzacZb1JIRD9yLKdc9zWGKQnmFIiJKleRaVxTSv9w6gIk1Ra9P4b6IwnoPLfIE9wj04T8ntgHCfxJPOBKQT6YeTi8ppNtxMVlt2OXb/j6vqGbdcXJ+zi1YUipAwC/kFnMRNF6/IcoRHECH7yGJtQOhImyfT6YSJMEZxj9CJPdbtesxt6pjCRKPw1pTBGypBCorwLgl+/uuB6N/L1y1dcXd+wGwZClqCgjGUs/n+yi1Fldguv6PsLWwlW+3KuFldzozQ+RyIyMayScmUq3/lOT7MsrHsTRiUNZVXKLYcccF8ILyWpXIyF3x7333dfrLifzcSQ6PtIlQMVBjOzkpEUvpY2oAyYKBmo1vd6VArQWv7dVfLNtUKZkhXvpddyJgbZDcZY7GHk5H///N3bmR76gn+N0fJ++edBZkW5VsawWMyJMXB1+YY/+zd/yur2mspZPvkRLI+OqZvCf9wbmpb3VQioYDGf88GzZ0zTxGKxoK7q9zu4rGROPejHSUDag6D2j1udsARUHFApoHIWfqZVOAONnkjJMOJIyOJjVSJMPcN2xbDeMbiRfqUY1rdM24Q2J/cSzwINK5uvTC7cWDkmbcQeKQM6BwgDYXeLniKxv4V7ZzfEyOQDcZR2wzgFYtTEpDFJ+HdZWZStcE6o/sK59BADYeoJVhGdJviBHD3OwPFixsnxMU8fPSlSZxlXWUafmWJiGCK7PuCDxpgZdXNM0xxhjSLFUVRrFNysruiniXHy9FdXvHpzzctXl4x+IMWJFAYmoBsfLqoylfaboZIFlnVMGhq6+L+qIjgB2mZmC4taaOrG8ejZEU8+OObDz85o5o564XAVGKtwxlHbltq2zN0JOhkYNdNaEzoDyeFag2syzBxYg64d7YnDzCBYR95LIFZFGjFa6qamqty9438wCeW/feaX872fgrhHFV3lKNnZ4W1KuVQpIhK47nmso0ow3KvN7Oke+2UrFtK7M5raiiylylECb4xoiqJMsZ/KSoj7KeRS9r/3YTkVE/f3G79dT5A9GlPSn3EYuF2tub65Zbvr2fUDN7drvv3uJbe3K16/uRSkXAxEHD4oMJWkFWiCMnjtwBiol5AjEElaiL9JOVIIpJi5XW9wDozNpI0nhsA0eUDhKsfr64qgE69vr1ltNvgQ8DEIkVNrjDMCODn0eCQI/rN/9UfUswXdFEGJvNls1sjzjUGnQI5Sf9Z7oeUy4fcpjcSau8AUM6CkdDuvJGMaosg+7YWjcxTjylyMRu8QkwU64yV4t1WFTxFfSqUpZYELpySwbCPaom/TYtRbEnEPGEcZ/Jjp+8R6G2mjJybNbC6itLrWNFrgGSYnwq6TBSkF0REll6zBgnPUrhY5rxIEUUif1DpSzIzjumizTlh750aS3w6E7wx4f/M5Ywacs7Rtw4cfPSf4kb/4s3/DP7++5smTJ3z95Zf8Z//5f8GPPv2Ux08r9ovfHjF3cFcpEbUuCjPL5YK6qdn7wP3wEA1XlbQEIZVQKqFVImNIBSgjky7QukRlEtoEsimk7+Cp60DbJHbbHTlqNsmSMCSlUESG7orVm6/ZjIrVquZqveTmhWcdW/jwVLyPDxvEu5OTYqQft1JtUIrZ4kgWtaxRIZDHnri+Qo0TbK7uvViI4iYH1BBEWSgm0KKsFLNG2waPo/cwb5csFoon52esri7ouw153LELI363IYYe5zQfPj3jd378Geenj3j65GP6fqLfjVzdXDD5TIyGo6Mj6vaIqpnze7//e/z4Rx9T1XOMBlJF1oluHNhNE6uuY7Xe8PU3r7i+6bi52dEuZoUrrMnakO33N7x3JWsl2WAoa6Qu3Yw9Wi0nsBnTwPnTY45PFvzk9z/i6KxlcdJiq+qw8VcqYLRiVi04qh+xsCfM4jHDxnP7esPF1xtyVJw+WbB81NAsLN4rTK2xM4096Yg608eWHIW8nxJMfabfQPLqTl+0rOPvvCdyLgIa6fCTs0jCee+Z/CRVgkKP8MEDhVifU8n4KE5A5dOULpQwyTJFAUYW0OhFNu/k6JhZU1FZTfbFWCAGtHNobdG2kjUognMNaYJAEi40US5Cig/m4G8av1UQDCGwWt+y6zqGfmC9WvHm6po3b664WW/p+5F117FabxnGkX6vgakNxtREFDqWyZMhaIMzFdk6jLGoHEk5UDnps0VtSZMnZuhoMBFUToz9hPeBoe/JSdQKtl5xtRpp57f7/QBkiPESZwxpmh66N5ThQ8SkjNbCYRGenqReWaVDWMqoQ91Dpv6+f6PuPkzlA18oBdkpVc7hpgmdZXeblCZrTd02GK2ZvL+T2lLmbTedYngpxcUcPEZrrDMCHtCK2XyGNZpxaPhzrUVGSO1L7nd9CxBwgQ/gfWa1mRi6zOQVrpbgqpTCWYO1Dp3BaoXTioQlRV/0MxO5lD+0tRjj2CPh9hDqva5gVJ6YPT5Fso+MXaKphP+1/6JvK5TcH3/deqLvGkoJCOLpk3POzs74yY8/leNLia7b0nVb/uRP/pjHT56w2Wz4e82cfRBs2/agoKG1OJ1rozHW0jQNp2dnzGaz9ziKTN4T3jP40JHiSJg6qvoIVy3IqkGphCGyaDR1NoSdIrQt0Vn6KdC0kcoqWpMYVcKFrigTgcqeSgdmLmA2W/pN4NtvI505I7bnGBPKLCnbjrK7D1PPNG65uviGkEQ+q6p+gjWt6D3GRBonxvWaRTtjWVf3rqWiaWY0xkGAfppQMZAiTHEk6ISxCu9ht0vgG9q6YracUdU1MUzsNjvIBqczTx6dMm8bjo8XLOfHGNvSDQnXLDman7KetoRuwIwTP/3oCU17xPkHH/LkyROOT45JRPwwMO62vLz4mk23ZhoDMexpV5G2seizOe1c9FSjDwxCZXt75rAPgIf9QoaclMSYlIpYd+L86ZzlUc2TpwvOH52yXM45f3pG1VRUtUNbIetrY4VCoh2L6pQ2H1OFBf5Ssbv2bF4FTDa0xw2f/fwpehahSqjsihycJijwyUIQYGLwkaGf6NYj6+sNF99dcXu9QQpbsmu7V2TAe884jvS9AAv3GaGgPxMpB3yMwg80EmRj3HeIFTF6qRrse9ulVRDvVbdkqRSecE6lRBoSxjlmswXWFdETFAZNQKNsBcahTIWKAa0KwKERnMKwy6SYH1TJ3nf8VkEwxsBms+bNxQWb1ZrVasXl5TWv31xxcyugkV0/MvogOnBKi0SOEa1KvSeMachZiOkYh3I1RtXoHFHZY5xDadHbzEYWhmAXotCQI32aGH1kO2Sin1BKMWXDdojU65G6qdFKJIWmaSXKL0R8jEImvjfEBT6z17LUJRCyL0ven+GHomKZOvdjTJbAqNTdxc1JuFtW6cJbAqsUzjnqusEYUbTZ9xwPFg1mvwYJCkohO0uxkrI0VcWQIkZrTuYzmqZmHKqHcWSfod4V/ABbbKEyuz4zTRBzyTLKZDXGYI1Fp4zTmsoYUqWI0ZKDBp0PQdBYsUzZf5bWe15XIMcg4BcVMTmRYyZMgv5KRm7Y/S24z1H/JkZ+x2+SxZWeltY0jeXJk3M++OAZH334gfDWpomrqzcMw8ibNxd88avPMdrwk5/+nvQ/itKFLZJS1kIuggtaaayrmM/nVMUp4TfG83zHd52mLeO4oVu/4ej4GYviKqJVwqhE7Qx1UkSV0daSEa3MjPhI1lbRmIjLEzlNRWLPo9OIyyN5t2Uce666jvC4QbXHVNV+jgh9Z39NuzCS4pZuc0FICW0cMXxYtGgruZ7eE4aeaj6jcQ81Nq1zWOPIJiMOJRGF9JTIAa0CZI/3ijGCyZm8mKO1VG5iitgMWluOlwuWizlnpyfU9RytHcOUqOY1zXJBc7skRUXsA09Pjjg+fcSHn31Ms1ji6opp1zGOA+v1La9evWI3dATEtidn0cZtWkddO9q2IqXEMMA4vItO8NAGSaHEGknkTshktFXUreH8yZKz8znPPzrj7NEJ83nLbL4sIDOLtkIjsMZSmwanaxb2EXaYo6eacTPh15pxBXbumM0bHn+wZLI9QXusrlAYlDL0vfAqtW9JA4Qx028y26uJ2zc7bi43bDf3HBbeaqPsMR57rutdEAxFrcuLdF26U6kVKbbSzkEdgDWkEuzQd3ZxmcKVTPhxkt+jBEhlNU3dCvhPZbSVwzMJsnWgLdlYmT+IhrOrHFpr/DSQsybHe2IE7zl+qyA4DAPffPMV//L//S/49uuvST4wDBN9P4l2p5LdjNGl7FhuJtIeNiKTJibJyLWraBZHLJZLZk1NZcBpGMcBpQ1Vu8DUC7RraNpjycdyYtmvWd1esf3mc7ZXF8RpJO4MuynjXGDWOsiiPrDrLoHAYqFYzGc8+fDjh+bAykj/McvNbzRUVou3oU8E799RMSjoubxX+JDc05hS1sJShD2ZuYad3mFT5PnTJxwvj3j65Cm32y1d37PtJqYgN6Kxd31GAU5lrEK4VMrw/INnLBcLjo+PeHNxgdWK58+e0lQV282G/5s2ePz3jnW/80jR0HUTt+ue7RABRzVvmB+1zGcVdV1R2QprKlIeDx6PSoGyBqPqolMoHnq2OFo4o8v5npiKfJrvbkTZIQaWdUXMGZ8i29UG4yzHp0eFRf/+KK6/8lAP/6JQLOctv/u7z/lP/pP/IT/58WcsZ0ci0jxMPH26ZLPZcHN9y+e//AtevvyOR0+fcfboEUdHx2z7LU3TMF8sqKuSGSmDcRasxdW1oCPvNzt/YGgd0TqSM3z38nNevfoVf/En/5yf/94/4Mc/+Vs8++jv4LTGKSkvBt9xdXPNMBmycpzWS1TdoirH+ckJdT3hY8/F9oZxiFzddoxvvsRffYMlU6Gp1Yzl2VMWz5/z4aePcVYhoh6xlLsTn//qBd9Nb0jT51RNi6vm9LvvyPUjVJWJ44Zp2pBCh3Nn1I1+8E1DHBmSZ+onxrAlqkSzaKidoB1PjmcoHDk5trcdfugh3gGsTOVoZg3LxYLZfMlieczJ2RNiMsSkGMaJWcpo2/Cz3//7jJuOzas3TLuJNASyDyIZmDOzuubi1YY/+7d/xpfffklIkeXJkm4Y8Snz4fPnRB9E7MFJD7vvK7we2A1vK+m8dU2zbFX3/bOqUTz7+JzPfvYBP/35h8wWNc4ZmqbGuYpZs8CawuW1Bumiw9ye4pjhxhOmtWJagdrNsDFTV4Hl48zx4wbXamKyUvmLljApwgDdWjPsDKuVYbXSDDvo1omXLzpefHPJV79YsV4NP1ii36NCq0KV2nup5iy6o32/E7eGlECropscSt86E4n7/RyEUgpNihgiMQT6bc/QD0zDSN/tIAt96oOnz6gfV8zbBclPhCQVQWsqTB2JWROzJmR12HD60VPVNWZmGcdeREB8IHhpl/3aDsS98d5B8Or2ktllw8XFa26ur1ivbgWwEaTorLKAJ9S+OqgSd/L5Suq0SUuZMcuusK4dR8dHnJyd0dYNVmUskcvLN5IdKEPdznHtAlMdHUqVrmqIWTG7vmS7XQvRXFt8VsSQSP0kuU/KjD4Kt62acfbkA6xKD4Lgw/xg3zvLh6auKozLOwCFpq7rA8BDeGCJFEOxehIwjDOiufns8WNmixnHZ8ecLJYYbRm6jm67ZdcPgJRbdWmgl5Sq0EgyVisaW9M6x/NHj2iamqp2jG2NVoqZsxzNGmx6CMO/T0ffy66FkPGTGFBqKxnfvKlpZxV148Qmxex9EOXsZAVGlYVcZVThPmoSKt3p/KUUCGOPnwZCmLBEjAFtDJKHQ0iw8yNxiuy2O+pZi632mqdvLyr8prjxa8dvnP8ZjpdzPnh6zt/6+e9ydrxEE7m+fMM4TUzeM5s5KndEW1fsugEfPP/mT/+YH332Gc8//JCnzXNiCvR9R98PKGUwtqGdtYQYqZu6aCraO3DVO48lM/SXDH2F1Zbt+oLV9Stur15x8fpr2nbB0enHNM6RVOKb7SVpWHF7eYVrT6lnM0xVE9HSgvBCRtdhpLu64ma143YzMl1fEm+3zM4ekeoW1S7ocVQxc9JaZq3FOri5fs22W7HeXPH6xb/lzcVLrq6+pJ0fUdVzhhFm7S3z2RNmeqQ2kWdPz2kby9Df4+DmzHrTUWkNU5aevDHYqqJyEWdK3ykI2M37CY2i7xWVYD1YzObUlSMrWQBjVqSsC+w+MQ2RaegJ4wDtDONqqnaBViNVVVE3FXWlsQb63Y7NdsPV7S1DjNjaMT87Q7c10zQydp2IfKNoZnOstRyfO8yqI5sVSn39AFl+HxiF2idVIjh//uSIp8/Pef6RlGLrpsIYi3NWgp8RJHAMARXEfST5QFINLmtq70mdI08WjME1c5anmsUR1I1l18EwJqYpMPYDfRfZbT23lxt2u57b6xXrzZZ+N3B7veLN6zdcXLyh246EKd21Gt6ak/e/036dtMU4QGtNXTUHMXAJggk9TQejJkP5LmkPphEe3zj2jP3A7dUt0zAyjRPDToKgQjFv58zaGeMUSUE0QIc4icWVk7bLni6XfChOERHnxN7JB/FXHUeh5eV3cB1/aLxnEMy8fPOSbBPfvfqOm5trttstlTbi/ouITEsXvaCJlJZACKWfFg9iqCRQRtM0FScnRzx+/JjKlXJonLi8uiKEhMtg65p6NifbWfE/UFSzBSkn5stj6pUo+GMtIWVyjEw+opXCKSkTOWup5sc8fv4x89oeAC5yteV/6lA+pBCHD/CHB5PFKM18vhAKgzH4cSSGQPBTkTzL6JypbMWsbnh8dIzPkTF58JHtdss3337HarNlmHzhSEkJLe6DIAgRWIGxlkXbcDKf89HTx2gNU5gYG4dG0VrNUdtg872JLbMYCeny/jkrohdl92nymNrRNJblsmG2qKmdLb6HUrJWdn9qsujzFUknbfau7F56jjmTs0Cbx91GoO0pUlkt/UVtAVHLCBhG75m8Z7vp0M5h60pun6wO5/jwLX7YDPq95uzDcR8MIMd9dnrEJx99wN/923+L2immfse3X78UYeAU+clPPqVazjg7PeH6esXV9S3/+l//ETEHXGV59vwDUgrsdhPD4AFN1SxISspKTd1Q1w1VVTEMw6891m7zinamaOsZ3eoV69uXbFeXXLz6GmMqPvz4Z6S6odLw8sVfMO3W5GnH+fMFjbPoqiakzHY3YIJnGiey71lffMvVxTU3XSKsV6TdlsWjT8izM9TpI3xUuMFzXCmOl46qUly/uuH2zVd88cVf8M2rr3hz/YbL11+wOD6hbhb4sGIxf8Lx0S0fni1Z1oqnHz5BhcDt7X3+WOZ2taGxltpb2qXDVgZb11Q2YFRk2o1MQ2Lciamu0ZqhTzhdY51lOT8SOF6GkBQ+gg+I+7gP8vrdjqnfkY7OUMbh2hnOOqq6op5VVLXB6MRVt2K1uuHNzQ2ThqptOXn6hGboGfqel92X+AQ+Kc7mRyyWc45PTqhu1iTTcL8dcp8eczffZNNvjOLZ83Oef/yY5588YblcSuXEysZVaTAa4uQJPhCiIvnItJsYgsPlzDwtsNFikkFZR2UrzGLO/Fhj6szm1tNvA0M/cnu1YnW74/Zmx8WrK7ptx9XVJV23ZbfruXh9yep2w3q9YdiND4j8+cEsvBsH/0Atus1GawlqB3YAov8ZI1oPRdcKMqnQLBKRQAqZSGIcJjabjqvLaxHd9xK8983WRbtg1s7p+wmyJ8VAv92wmLXYsnnQBSUdx3TI9gRcpxmnsZj6DoeN+fuO9wqCKWf++R/+c87PTrl6dcFus8EqwR7qdK9rXHyilM5QEvwY9py2gZQ0REUKcsr82LFZ30jJKBly9OQwsllv8CGy2vase49r5iTdHAQ1ZgZS2GHjyKOjFj9TTEma2DFkdJZqtcnSu6qahmZ+hK5a0kMFLOqqpq4rJh+4I5yrsvNRQv7ZP6ok/d92nUisGbFbMlVNVTUCg84ZFT3L2YyTxZyT5YKoYEqBP/h//jM26w0xQp5GVIxCFC2ZYFBFADYXbTwyyidOZud8+Oico6aWxrNPNAXSfzxrOV3MqdSdB16ZxuzltzJS7vX9SOo9aogYPEqN5KpHtxZtjQAzGFE6CsBHGUzhBWkNtbVCeFcwdiOkiRgnnEq4HLE24LMiZ1MUICI5enxIAoPXNW1lUCpzs9qA3jAGz+J4fgBL3ZVH/7r7hMLrJIvoblNp/uP/0T/gp7/zIz79+GP+8A/+kK+++oqLl1c8fnbO8w+fsly0NHWDVprf/73PuL5e8yd//kturl7xq18qfvbTn1DVjaB/u56EIqTEZrths+14+fIl2+1GeuJ7ysc7Rs6J7Zs/Za4vaY8f87RJmPNj0o9+Qjs/wjEx3H6BblpwFdv1JXHsqZ0hxB274ZZvvv2Cs/mMR8s55EC/67i4viL2t5jhmu2ra7Z9ovdw9c01/psV2/EXHLnApx8+4h/8D36M9wvq2nB19YbXr1/z7Xffsd7sUMnwybNPBM2MQqUBPV6SNgPN4mMqVREjbNcrrl5f3GUTKE6W5yybljktkYGUE36EcZhQ2TPsBoJPhAk+ePKYeduyaGe0taNylqNFIz2mGFjM5hjjWO9GatdQNQ3WtKis2G22NIstRmkRxLYWXWl2oWPa9UTv+YM//H/xi89/xZ//4hd88vPfpVkec/zsA060IgSPco43ry+5fnPN8tFzzh+d8sEHT5mvt2S7/EGg1r5/n/LEcj7j+PGC3/sPP+X8yYJ2rmmrGmcqjHZMvieME5thU7h0iqPmFKMdxjZM24ZxqmjdEbpaYpsZAXFs2PU7bl6Jx+g4dKyuXrO5vearr37Fer3idr1i010zTgNDP7Bdjwz9xHY7FBWvu0D9rlKJgoN7xENU6B7/oGncrBgNwDiOIqbfuANwJiIOG1GLYtXgB7ptx3q1pdv2KGXl+uCk6l10lLfdwM3NmlevLnj8+JTZfI4fOmKM7HYdc61Ba0ICP4pzjUL6kSElMdItykx7YYH3He/3zAzr1RqjFbtuRwweVRZpSvnwrqTFncKSvkNP5QKZJSGIMmAaRrrVWl6WNBRARb8rdWcmIgqz2xGUg+J2PlmNVZ5KT9g0keOED14EqMnUVQUpkbwXhGeemMaezWZFr+KDxUhQWQYd91yTuymxb2neR0+RM8GLxYcyEQpAxaoCp1bgkDKm1YowTZja0dY1y8UCo4qf32ZDPw4Mk7/bWRXZtIgoTFilqI1mVjvmbY0zQgq2SrGcS5noaDmnrSumceT7gWOPYJOdUfChlBoyOURyCMRpInlP0pqklNBmUxKEpAayuHIIdkZuEK0gWUPyCCcyB1Hz0QrtZEopbYhRvAanHEpTPEPWQr3QihQ80wBp0RRZrP3u9J5Q+F917N+oINIyibpyHC9bHp0tOZo3jH1/uKazdsa8nTFrG8I44FWmqmrmbUU6nnF+uqSyimnccXP9ButqQsyMo6ictAmubze8ubzi5XffsVqtHqhrvHtkdBowscfEHUeNhaMl4fmHuLqlamfMbKRSEyYnGgcRQ1VpUJ4Yd/ipgnlD5Sr6wZNQQsquLLXRhHFg8po+OvxuoveR69WK0Q0s7MTlxUuce4rRC5ypWMyXPDp/Ql23+DARQs8UR3zwvHnTo6LHDxvGbsMYWmLT4MdI8A83jfO2Yt5UtMkJoCInbNZyr2VNmkQmqzKK5WLOvG2Yty2zRvqGs6aCLDSl2rkCvsroxuFsRTZZSosYchKZNmss1hlsbbH1DJUzYYpcXt1ye7th6CeapqWdLVDOoYygetujJfMxMEVFMz/CVHMSFrQVOtAPXr194SUxW9acni84Pp4znzVUVihERjmIoGJmbwKbS9vFuRqnGoytGaYGbEulZlTNnMrN0ExEBWqamIaBafL03cQ0KnKqqaolVZOopoBfXzIMI+v1hm49iWXWGAoqXhVFoLeP/m7sKT/7QAgCZNlr/u41RFO5fnuusip3rTq0m8Q3chw9220vKNyYBQhUOIO2EtxGjpEQIsM40fU9Z+kYpURIPSfPOHiqqkJpQ0IV/9d0p+KkZB3fY1FkjdI/GOzfHu8dLsdhYuhHicAxolOSMhkguMhS9jRagp/WUtRPFpJB5AGjGLCGRAqa3c2a2HtuqkowEgeE0T60arpuQ1aaCchRQTTsnGVZa54cGdTmhjx2hLEvclUV58sz/BTY7jaiOBAN168DcVqTw/RgURJUliZZR/SllIuQoU3h7ql8Z+8jgrmid5pyps8SK6xC9DWdLWoHUh+/vHjF0dkpZ8+e8nf+zt8Rx4YQ+fLbr7m6vuLFdy8JUbI/o4pLBpnKiF7ncdNwMp9xPG9xSnqSjbWcPX7EbNZyenyMJtPturcm911PUMjOmWEcRC8xRLKORDyT6hkqBzGhcyJO8upZMyMbQ9Zl55I1wlcVJNt8NiP0mSl60jSiFFK7ryshkgM+anzIDFNPih4fRsCi0BzNLb33TN1EXMzIzqKMKyhJQZTp/H6T+H3GnXB34njZ8tknzzg9qlFp4Ktf/VsqY/jo+YfMf3rEbOZoW8f1mwtcZTk9PaGyNafLlt//2Wdsup5h9Pziz/4UlAA0rKup6oaj04E//bNf8PnnX/Lf/dH/l+1mzTiMD+y7vn9siqXTLAzU0fN0ueTR8ogff/wxunIYa6m0KeLQA/X5nJxrkopMasD7iFZzZq3j/PyMb150GOt4+uw5480NftdL6TDVTMoxDRPdrmN7+RKt11yz4pd/9q9pqr/N0WLO4/OnHB+d8KNPfsxqtWIad4zDLbthy3a35Y+6P6fbdnTdiotQ4WdHzB8/JUUN+Q4dqhScHtUsKofqU6kSOYyd40xEqcBNtYKsMNry9PEZdV3htObk6Ji2rg8aqVZlfAFHTAmqekbdzCGDRizUbG5wVDSuZn6yoGob6tMFfprw4ZY3lwObTUBny+NHTzg9O2dKmZCF/F2dHHNeLzh69CGzxZKs4eJmw2bXse52DybjnX5vuccKmvHRsyWf/PgxR8cN83lLW89Y1CeopBj7DSokLIrZ0RkpiZ7m0eKMmT1iaR/jFzVpqoj9nKpaYG2LTyOmr4lJtEKnMTKMgdnROafnT/ngk5+w2a24Xl/yL/8w8eq7F3Tra4ZdIAYJYJKtloN/MBcfzktjityjUg+yQVP0WzWS9cUQyLFowu7BjghgRRupIG2319xcb3j18lKqf0ljXE2KArpqjCN4jx8nphjpp4n1dss4TZBb2rZhtxnZbFYYo7BG1ojkJ3JMmKoWzIHRYtsUJpgcFh4aCvyG8d5BMCZISRbWqm6plMJB6fNlkRcxRnZWTtRWsJasKlJ29JNi0w2EboX3kYTGuQqVIiqGOyCHEqK8AGOEqBuJhAwqGeGkJ6lFj8PA9eVrht0atMItj6idw3db/DQR+o71tiMqhRsniBM5hQdNUxGGtoQYSEUcNiQOQfkwVQ6BUMJ9bTTWGNqqonaOpnJUxcXakDia1ywXLWHsmaaJl69f8aOPfiTPy4njZcN6veLDJ+eMk2fyQXy2lNTVK2eprON0saQpSLoYJpq64dH5qVj7OIuzBpUTxu15FffG/b/nQgWh1Puz6P8JJ2gnkHWEc2mt6IMCZTcoqgwppcL/A4voo9bNjFC0LI3VuErI4VPwqKzR2lBVNTlPBfUrN6XF0FqhFKjiSabtvYJ03ofCv8JQ937JotM6ayp+9NFj/v7f+11MHum3I7th4MMPPmJxdISravw44KeBtjmVvZwFozNJJZpakZLDGFjdXLLbjWILZivqtuXxs494/fIlN9fX+HEqhODfPGbzinZucS6JXJ1SuLYiI1SCcSeWV8F7UB50AhvRukKbmqpKpDSy2a4JPlBVNR88fc7NixfcNDe08xP6UNOnmtvbFaHf0MYNj2eZExe4fvUt/Y8/JXlPpazobVZzxo2n77d8/cuv0C6Lz+cgGUm/67jYBvr6ltR3hDhxebu6q7RkpB1iM5XWVK04ilf1DI0nxUkMUJ1j1syYNzVWa/wonpc6a44WC3KcmPwoSkTa4KoGlEOpiuXiDK1sASVVVHXDcn7E8miJcYYU4eZmw+tXr3n15oKu73C1Iw8jw/UN07BjM/b4HFkcH1O3S2bHp1RNK2LgYSAMt0zd8DBc7DdoSvqVVhuOjuc8enzC02cnLNqGo+aIo/aU0+YJyWdWAJUm6oCqrDg5hEjwjphaSKfkoEhBk5RkoNo65q7G1TNcOycZw27XUW1qmqrGGMs4TDAOBJ9Z327Y3G4Z+1EUXfY0jrs24K8d9yXT9kLwzjmsrjHKkrxoI09jFFUtpAVU1RZlNNkodruebtvx5uKa7aYjJcnS0BDTnSCKVUKzss4x9SNZabZdh5+mIrNo8FZjNYRxBJfELLf09A8JU05Ya0hVhWpaaq1o+um97jv4bSgSSkEJTtoI50/nItelRCxPUIVGeH7WolyF0g2oikjCDJMstkkUzJ2W0p5RcJDjegshmAsSKZVyls4Fjp8S3k/0u46+20q6PBNX4Rw8KXhS9IIcy5Btw2C19B0POyF1EMfWRosZVUrls8puT90hRAEBAhmY1Y62chzNZ7R1zWLWUhmDIhOmkUVb01RiSrudJrqugwI9PqosRgWO51LyETRiwFVVSeBSQZgaFu1MnNu9J0dom5rjoyOatjmUHch3jeyH14zDDlAmS0G5lpp+ygkfBKiitMIFQYFqfafufkcFkbJIzHtekNA3jHXo6KQcarRIqOlS7kqSEWoltkDCD5LzisqCOtW67LD2feV9b/Cv21NeNgDzWcX52REff/QENXXEGCQ7PJnz6NE5tqroNhu264yrK8iRmIrUXso4A1WlSdnQdT3D0NNtN6AMbhhQtub25prtWoJRiuk3LjwoME6hXQYT7kQZdEHBhUC/2xyQlNpEEWUWEVrZ4MQR7weGsUcbQ13VzOcLqqpGWwfGkrP8jH2Pmnpa5TmqDYsK4jiQ/EQKoXB6pazoTAVJs7ndYKtMIpCD9Ohi8OzGCcJIrUVNajd0b305LVUVa5B9sZhVpyBecjlljFI0dUVlZJ7EvTZuSBhdie6ukuNShVestEVpR1XNMVrURERKq8LWlWywtWLot9xeX/Pm9Ss22w1T8FhniOPItO2Iuy3rXYfPCa0M1s4wCytzPCWyl+/7Nlv+Lpkq64IW3dnlsuVo2dJUNa1rWbhjZuaIECPb3GF1QllPNqps6DMhQEianBsRPSmWWQWnjjEVVhkqFM1sRgJ89KUMrEgEvI/0u4FuvaPvdkQfOGhE5VKufY+qyn2pNKX0oaBntUMrR/KRHBUxCNp3Xx6tm0ZkzDT0nfQiu65nHCep6ijZpKf9t8oU/1cpa8Ygalr9MDKOQnWo6z1/UvAKOcnar7irGu7XCF2ep53DKcka37ce+t5B0FUzTNWS1I4hiiZgpZUsYDEy+gGUxlQeFzOmqqiUo24NztXshoGDR6A12MpxerJAWQfa4GMkFhcKXUSDE1ICzUlg0XvXgYiIufrk8TkQcsQkEanOOVPX9QG5Jem8gqjwvRf9wbtLDlnkzeqqIoaIT3vneqEHWGPASEaktaZyjsdnRzx/dMKT0yVPzs5YzGacLBbMyudud1uqqsYay9Onj+H2ltXlNf/6T/6E8+Mj/s7PfsLRrOFs0fL0/FSmRQk6+0ryNPSMw8jV1TWaiLaa5x9/hHNSHpOMLOIqK5uTt4Lgvhh6CH7FwBI4lKxDSoQpYL0DreRPI3kaeq/skw/7kljcnBWZ7dhTWU1lhcCvNKAV1XyOsZbsHNPtRD+IYsU0hdIIFwFd74MIKViHdTXYQqSVGX6Yu3+lQHgvmGYiylg+/vgDPv3RB3z68VPW1xdAZrZoefRozvLIcn7+iN22ZbtuUTrhw8i2W7Pb9aQUsUZTGchOc352zGK+4Pj4lO2upx9HXnz7FV9//YLXry4Zp4EYw3vchplR7xi1A+3pmQgx4m9hHEamYWJ1c1uoSFDXGlcZFkeVAI5wvNhBHiMzN+fDDz+hbWblmmWmELi8veU6NKxig+9WLM3Ih8eOp8cNT06P+PD5U+rKMg47tHYo7dAmFwf4Oc5Zri6+o+tW6GypNDQ1+LDFK82OgHOGVA3cXTxFO5uzXM5ZqJptf81uN5K2W1a31+y2G0wKuDMn9I8pSKm9nWFtJQuvranaFmtPiarAlk1LXS1wriUri3ES9JIawURGv2UYMtM08stf/gV/9Mf/H/7tF7+gm27Q2uBcw+rmiqnfYjXF6iqzigE1RWyCftwRx4HQbTg9OeNsPv/eXLxLrgLWGR49nXN6OuN4OeNsfsLJ7DFn7TOqcE7vPfS9zEczolyA5ImMbHa3ZN2ybABmKK1JMTBMCR9HIuKRt971bHcR7xXKzLhd37LbdQzdhm+/+hW/+ot/w3dff8N2vZLjywV1zb1A+JuGEa5yTgqrZD2Q9pAlZ4UPPd5nogddO4y2aGc5Pj6hbhoUcPtmxe3lLVM/oRK0VV32kCIDCKBKVVFhMNrQtKLtfL1a8+ryGmM1nz47w1UVx0dH+EnmVU4RZS1GaWxVFQqWQADRilw5dEp3knXvMd47CKo92hPF2PckP+Fyaf8BXdeJyLPW2LrBupp2saRqdljXsu0ju10PZOrKUjWW2orCQlZZUEXScBMKgxL1llCMQVURpj3QLnIUjl4p803jRLftUCisdUzTJLD0LJmIRePHiaHfPaiJxxggB1pbcf74VIJe9GL1pBXz+bwgpgzGaJy1nBzNOT+ecTxvWM7m1JXQIZpKnMcrpw+qCSEmWmc5P15ys9rRdTt+8cVX/OzHH3NyNCf0O+mDFed5HwN+GhiHnhiEatA2M1Fx0eV7e9k1ZQWDD2x3Pa+ub9/qO+Wya1KQNSoXrcccRVw2S8+TsuM3xojlU4qEWMimak98zofMURUUqimqKaCL7mEmaQHWHBzCnQCCVA4orcR1wiuyEpUIH5O4VXQ7KoXwwapa+mxKoXIiv0cI+aEZuz8NB1EnrZjN51hjmUZPM5vhnGZ53NA0BmcTlYVUG9K8EmNln8XNOnuMzlRNjdKRrCJxLF0AWxzAi+ycyoEYRlHZ4Dd/h5yh63rq2lBpRz8OEgRDJvgou/q9T5/KTCGRCOgukrIsJKmeQU60sxalMzGJHN9iOef80bn0TDqF9555bXk0d3z6tOFkaTl/fM5HP/qUdjbDB09VWSASk6efenbTjp0f2HZrus2axfE588ZhqpZQJ4yBqnESRHU6nHqFBGxjIYwTMWaCT2y2O26utnTbLceLiuBj2RTJ4lbXDdpUGGuLKk9F3dQkbYQwnQwhAzGSEDNrYxNGgTUJrSO7fkPf79h0a7JKNG3N8ekRWkvJXluNsZq2qVhWDoymT4lGZdS4I2xv6dYrrl++ZDhfs16PD1ppuVy4nDLGQVVbjo4XNPUxTp9i4xk2HmHCHEKDihbHElJR0yrlVHFL3zGZHVMasbolo0VcIo6kaWTdbej6gdVmLZZEBYQ2TTuGYcOLb3/JN199zjdffk4/CBL0L6vCpJCKn1IKrZz0E40hxIz3gTeX15IZZ0G2Wm2p23lBxxvWNzdsVxv67Y7aieqOQhVT3dJLLJ+li0qX0kWEPCeyStxuNhijeHKyoLEKV9WQk5iqx4jSNcpYrKsOZt26JC2YInL5W0gu/hblUClr5Ay7YWDsd+goqt9Wa9brNT5GQswYV2NdxaIfsdUO7Wp81ISYUKoEwcpiS58lQVmYheSoTPGr1qaU1ZKICyugaHamHO7tsuXm3vU9GVgslozjxDCMgCzIWmmGYWLodg/QoTlFdI4sKs1HT05ZtDP8sEMrsEbz6PEj6qqmKrsOazSLWcOssTSVSB0ZpbHaUjkJDG1d0RWJphQ9jTOcL5d025F+GPn8q294/tEzjm1FVp3YKkVRC5nGke12XdCeMJ/PaWcz6rou1lUiKG6rmphhO45c3Nzy8vLmToMUKZIcFv+spSSBRiHqGcLllNK2K0EQMilHUhLIONoeeE3C1RJVnawUxrgig1d2QUqsnmICVZw7nLWkukIpD0qsomIWuxaM6BqmEMhdjzKGetagXCPi6VAYDX+5IPg2Am5fQpnN5xhb4X3k6HhO21qOThy101iTcRpyZcjZ4f0kN18IKALWKGZtRSYIAdhHkYbTHJSDamelfxq97HwL0Oc3jX430FWGSY/04yhBsKANxJpHbm6yCBCHkBmGkRRl82Ryj1KIVmmOhDCSk2dxNOfs8RnNbIbaDQTvOWssj05afvThOVWlOXt0zgcffkxUihAmqkYE0VMO7KaO7djRTz3b3YZ+t+bk9BzrHJUV8rrSWSTHmorh8H2lglBVGmMy3k+yKQyJ9Wrk9nbHbrtj3lghvnvpyUvLoEbpCm2cVJdMhWvmZOMIEeIURZApSaBG2aJUVcyqiXRdx3a7Zddv0UaJYMXJESjZJGsnBtB1W7FYLLDOstp22Jxg6InbFbubS15/+xW+H9j1e2Wo/ZRSpdqUcZWhmVUcnSxpm2OsOkWHE5Rfgm/JsYYSBFPuIXkyCZVFFMPHgYken0cRwteaSGbynmnybLcdm+2G65trMbQ2mqau6fs1/e6WF9/+ihff/IrvXnzFNI4Hk9l9O+ft8Zs4dArhLWtlBXSkHJMfGcfA5eUVVhtmVU0umstN02KdyAOub1Zs1xuGXU/tqjurvSS9xljc5veaovvfdbHwymjWmx0xBLqPn2JnNbO2JudI9oE0hbKBcdiqlnph8uiy2RQsQ/6byQTbumLetoTFnDDuZEczTSgjnDDlKlKa6KeeSlmykhr1uN7hA9h2RtU0zOcLgh+Yxh2XFy9p2jlV3WBcKwTKacQbAdZo65gG2RHHXKGMeHMFpbA2Q5U4WhyJU8PkD6COcRxIKVDXFcZkUlZM/ZbdesV2c3s3CZTiZDHn46dP+Olnn/D05IRFU1NbIysP+SAf5Ao8W7QmK5GVIkt/VGlROC8w6hgjrqpJwNX1LU0753S5ZBgjt+sN33Zbvv7uFT56fu9HH9Jv1myL7VQIkRASR0fHWGuL1qk6AGdSSkwx8Od/8Rfcrjdc3Nzy5nbF6zdXhAdGl3eOH6rYj1SNk0AaoojflkxOHJ0DUSmsEZuVVJzpEwpdOC/ZICIIxuCaBqstVhvqypJzxE89m8GT40SYBrIfIESsNdR1zZFyDBdrYtifH09GvOOqyYJvUbXsBmUR3lNw/wpj3wfV4Jzm6dNznn/0nI8//YzjowprIqidUFpM6VuhcTicU9SVZtlacq4w1nB8dszRlBmmxItXt8S4pd+tuLq8IoRMOzuirmtms1bane+BcFXATB+zMEus0sxmgBI3Aq321RZ1AGMcNiWISAMZTo8/4vT0DGstm+2qbIgMpjIsT5Y8enrO690b8s2O4+OGp49O+fGnn+BRtMfHeGXpp54QPcfnZ8SUGMYdX3z7Ba8uXnDbr+h9xxQG/NQxn82Znx6RqgWJyBQ9zhlcSA9ifsxeOiYpoJQmZbi93RBDonIVdSVKKikpZu2cxXzO8dEZrm7RxuGjAipyrmiaE1JWaF0ksXKk29yg4g4VaprW4SfPdrPji199yTCOzJYLFkdHUBlevHlFyhGVPP3YM4wdry9fUrsaax3OtdLjto6Q1qRpx3JW4VRCpTsrpQzkpFEabJP4+X/0Kc8/fsrf+g9+j5PZZzQ8YXN5QqwbfJs5mhvIhro+YttdMnaZ4+UcT2AygcncEtVE77dU5ilWW5wzDOOO0W+5vH7F7fUbLl5/y3Z3LT6HfqDrenbbHV/+4pesb9f03Vbm0wMC/29zq2SGbsesarCmEWUs5YhRcf3qFa9fX/Dll1/itKGtG8bgOXv0iOXZKeMwMowDX3/zDd1uR13XB2Sp956hKLncOdHftZj2bvUgFaaUI/3k+eLrF3z60TPOT5+jjEWNE0PsRETbVFRNAR56EX/fu34Qwdn3h9S9VxBUSrGctRwv5qSxZ7e5JQwa7UQxBq0Pngqyc7OHcplY8OVDeVNr6Psd4zjR7XYEL5yd+aJw17zHT1OpnVumKeFDxicrfB4LaspEA9lk0tCTgsf7sewoFNM0HU4+FLWUpEnRo7mfLcGybTlZzDlbLlm0DbO6oq0K100JZHgPEhF9zMQ0Hggh2EqcHkKIIu2jBREZixHkdrfDR8jKUDlH2zY0TUPf96xXm7IA5IM+nzFWbsi6kexMqUOvdNf19P3Aervl6xcvWG22rLqey1uxs3qQ4R5+CgtRg3VaPAJ1xjojO6+87/2p8nfKj9S6TSnDCujJFkCCiJsrLZJOWIcq/UK0I8WAzuI6EtKIH8eSGOgidyS8pRQF8OSsxWolkks5oMSjRSq6f4lEcJ893l8KamuZtzXPHp9ycrwQ4evCf6yqStCtRpRwcqlKKBVRiMCzNVA5w3zeYiuwY6JtB6rdgGgqRKEqTCMUhQ3eIwA+OO5Cjzlk2Oqu/LwHPqksUnQZSMqWDBGqWkTj92CcGCM+eFRMdMNATEHKsznSzgVYZbRmN07EruPF69eHjA7ETWCzXnF5+YbbmxtAUJzUjnEcqUNNEeso/R6pAj3YiOVM3/foGFEe+nFk14m0FTkd1Ifkvi0oROOgZCLGWKq6xTUzqqrFmVp6XJUrG7cJHyZSgOAzk46s11teffeab799QUyZT+YzQY4ad7jPxuRRRch7HEfWoS9gOId1Fa6uqJoJlQNV7QQAYt7iemYR3J7NDY+fHfPB8zM+ePKUWp3hOEGNM3Jy+GCIUXDOSjvCZBiDxvdy8qxy0uaInmHYMNM9ylQiVKFkfU1xZJq2dN01m/UF09QzTSPbzcCu69ms1tKiSgkOeOq/XAVl7Hv8bMI0UvnSusy1nEopUhFzYvRCs7Gbiuvra7KGYRwP6M79UEpE+R8YUN/72c+T/Z97e7WYFKtNx3Y3MvgkmsZZUVWBbESjN2d1t/ZqjcLglND1zLuAgj8w3jsTfHx6wrPH51Qq0t1eMu00GCduv1nhi0acto6qrsvuqkJbJR9iK6wzaAXbzZqu27Ldbhl3M9q2pbFKyj4+MA2TIMRQTCETYqb3GW1AW0WvhahfA7qUEqfQH8xs7/vVVVXR+VRSWnXmIerw/OiIJycnBdjiityXxexJ9FoTYmQYBnwJrjGEUjNXtPMZXd9zc7vCVTWuqpktRCYpxsDlzQprhKrx7PknHC0WnJ8MjN2O2xxRGLyPdF1P24rrQN02h3Q+xCwWMDHw6s0Vl9fXfPfqNb/81Rf044S2Nde3a25u3xUEM0mJ9x8aXG0wg0IZKeHkrAgB6e0VsnqKYmKcAW2N9JIOk9kWXo4RaxNtyMaQjEMrcK7CKGlwT7sd25CZ+p7daovVirZqSH4ijh7vYSqgu6NFS1M5nE4ShMgo7USK6R1R8KFc1cPH74/7QbBtK85PFvzs0w94fH5Ezoluu6NpNEfLJWQvOLupP6ATySOkgRg6GtfQ1JaT4yWjV/RjYrke2e1GqsqBQvq52y0hRLQ2xQj5NxdDMxBSYIqiguG0cO3i5KXXqKW0rMq3sshGSxkn/WoFxlaklBn7EWU0KYlE3zBM3Nys2ezWDNNATJHl6THtYkYIEzc3N4w3N1wbxaOzU85OT8gh0W87Xr18xbdffcNmu6JtLYvFHG8zm/UO0zqasUW5SMyeaRJZuKHv73YuOXN7syI2DbV3xVhbWgK1FfRzLj175xzO1QL6CgETE9ZpHj16gnY1ytSgHDkbKqOJYcST6fxI8oloIt008Prla/7kj/8N3377iqpueP7xxySlyFkTQi78xltiOkUbzTQlbm42bLcDq5uRdtYwW7Q8fVaxXDQ8PlkKSOctAe2MoqotJ+c1H/3ojE8/e8ZnH39K6p+QxiOG3KCVIiVNiCIHh3ZMg6PfGZqbCVpF1cg9k+LItrugjs9IlaNu5lgjgvakCT9t6DYXrG9fMU0DIUTWq57dZmS32RF8KKc93QODvXu8Tf06/J4yu/WGoZlRFd9PYwupv7h6LOYLpiIVud5umWJkCJ6ECGlv1mtCcaDYf1ZVVbKOlsf21Iv9uK+rGwsmJKG4Xnecrjtutj3PHp9S2ZoZhjFAQhNiZvKBaZyK+w1UKhEVh83c+4z3DoI5elQKNM4ya2uGtmbXdaQkAFEfI6Hw7xaLJfNWfNeyNmRt8EAMgV23Zdh1+GmUPoxKmORJU09d1SyWLUPtCFGkcDKamDKbXS8gAyUu2gZDjUEZK7QLHUsQzDhXHS7w0dERVV0xmzXklBl3Pf/2TzUxygX62Wef8OOPP6QyCsJEiCJxZmyxCioL+6xpSJWTDHPyRRg2s+12rNYb3lxe008TPkR2UyhZT+DFV1+QomiZ/pf/5f+c5dExj05P+OLzS7Y31/zyl5+jc6KuW25Xa6yzzOOS2WIOSrMdBjYbMf38F//qj+h2O/ppoo+ZMSn69ZauH5mm+GDS7zPzlO+CYNUabK/QVrzTlLbiZ6aF3uJcEfi1kmGIN57BWilZVVXD3kJIm5IC5MgwTFJ+Sxlb9GQVFtvMaWJge/sdOYkdVG0dyWX6GATGrEVI3VmFSR4Vp9IPdn/pTPBu3IXB02XDh4/nPD9O5HDDq28vpdcQW/LZXLwsCfTTrijeR/ywwo8dwXfMHp1ydHLKbHGK8QrlEidnCuwS05xiqhPW6y3X1yuur9f4+yr2vwGpnXPm5dV3bKZa8HJFsDiTSvVEzvfeHsy5uigdiUKH0Zq+G6WsWrWcnj0mpczqdo33id1uoNsId1YpiFbRxZHXN1u+fvWCzTgy3HzL73z2GT+KH7Ne/4jVasXt1Yr1essUPE+fnUCb8UPNevUCUDjbcH5yDkoxTgJCq+MtSv0rRPcI+mlAJeh3mYuLgd0wkRRknclWQFghBUKKDCEQ+pHbzUDbTLSzicXpE3QEdKKdaUIc6boN29UN07gj+R1KtSgalN67zw88f3bGbDZnVhludyPdZsfN1YbttqMfBqq6lz5WsmxWgdVqYreTCpRzmjAZkpeSshh8v72VCTjnWC5qGtNS5Tl2OqPfWcZuYn2zRSE0ljT1VFVFVbXEmEle099AmxpmdoYymUllxgDd+g2D7rH2iNubG25vr/jyiz+m6y4xpmc2r0HBanXDzdWa7aqT9ejejfKXR1RnckxFY7hoc2KYfOLo6AgyvHl1IVSpJJnhOI3ormM3SHbabwuVp/Bj90LcrlhsDcMg5HsjLZL9v+/d7FNKhFx6mQpu1h1fv3jNcjGnqSupkDWWlOS9pmnEe8+iqrAq4QhM+2rKe473DoL7aK2L75UpC+VBMDtJY1MpRVO3gjTzAaWFC6bJDDGUbCqKvFldU1kj9VvxBCkkCOm3GU0pCUKKmlSkcIw2aJSIy2bxJkvKC6gjJ9kFlN2QdZaqcsxnrZQw1B1WWAGnyyUnywUpTKS41w+V1Ve+l1iGCECkyPTYfPAh1CFgrfgDjjHhh4lXF2+EF5MFvDD0O6ZxZLNeSY+xbvDjxK7ruHxzxdFyzqyuub65ARTtruep+QBjHVc3t9zcrrm5XfPi1YWY8GqFD4kpJvpBAm/cpx138/nw11zQUsYZbGWEVlEmmim9wf3323MmpedUOnIlSGp9VxpW94hHhwkcRINfF1CMUgptLTGK9xc5Y4vIAMGXu7UYFmdKIBWB2L1u0F9lyNsLzWM5r3h02nJUR3ZenAeaSlRYwhTIeRTvvTAKxzQEpnFL+P+x92c/lm15fh/2WdMezhRjZt6pbg1dXT03u8VJFClIlE2ZMmzhqHSoAAEAAElEQVRIhgG/GAb84kdDgAXrr/BfYMDPBvwoPwgU4QfLtEA2m2qym91kNdk13ps3hxjPsKc1+eG39omIzHurbjXJBwO9b0VlZMTJiLP3Xnv9pu/gB5RK1E1Ns1jiqkWRmIP1iUFXHtuc4qOVqifKmpWsd27LKoRt8mijmjmYcgHppwMMvqCbbekEzJxNju0jow1V9BIAtXRHjBIgxWZ5Sj/uOc0XxBDZ7w8En+n2HVM/kqKIsk/RcxgnbtOBbX/PfhzpzcC+P2cYzxingXEcBUg2ToQkPFLlDCZaWVE5kVPEULoDTtq/tR2frMFx8mSvUDvYHwLjlDC1KaMNSbKUFgiXj4mUo8h8Ycna0fUD2mW0TVRtTUwT07Sn6++YxoFKU577KBKAYcLoxKJd0LQNwY8EPxG9XFutZdyQM8QgrbRpTPhJpMycnUF7Dq0MOULQgvJ+vK6MUVTOsmgadHTk0TDuYdhNDIeRbnuQJMYkSBN13dC2a6bitNJvR4yuccaiaTEhoxP0w44UB7Tqub6+5u72iu3dGya/J2fZ40IKdN1A3w8M/XiUNzte9p+TOf7M78vkSvK2MhaJKVHXNavliqqqGKep8LclEE7TyNj3jOPINE2SRMZ4nPfBgxzbvFdIl646fn2uTmOMzI1n6wzD6Lnf7Tl0A1opmsodW52Pg61zThyCEigVviYfpPyer/tCHxNTyiSlScaBbVBOiMYqJVQ2GIQzttmcsF6vubu7Q8rzgAZ8mghjT20Mi2rJs/MTqSiUYgyRbuzZ9V2RKNLU7YKTtaGpKpbVAltJz14bJxnuYWAGwDdRuHM+iDOyLgaxw9gBkZONUB2ssw+ZkoJNU3O2XJBSJdt+geVnKWwIU3mo58BZNiKjBS27Pj3lA2P4rjbsh5HPv3jFDz7771guF7RNy0fPLnj18nM++8mP+OEP/ozddssHH35Mfziw3x34sx/+mO/+0nc4Ob3gn/zBH3F3f08k8bf/p/8TFssVv/dP/oD77Z7doeOnr96Ka/mipeslAxqHiRTSe87XIvdWAlYu88vastossdaxvT5IomGLfZLSiFWSxjjD4CdRc9GGmGVgLd6C0iJeNCJ1p43CVW0hdAtxPAXPomkgBVIMjD6SSIzW42pD0pnbPuAzJJXZ9YqcBeEXtSpZdxZwiPpFgDHqyWczjQRl+OTDU37zl57xYjFyPygOdWbVNlhjub+7p+9vCaHDMIr8UpgYQo+2lmaxZH1+web8Obo6oakbqmXF6rIlJk2Iim984wvevn1DVf1T/uRf/ClDPxxh8D8vNc+Az/74MGYlMlXGGHHdztJ9mOcrU+7LnN0XiLiC4Y62aXl+eckUXnDoDnzx+UvG3rPddezv9qTJUFnHq7cv6WtP7/YMcSC3itPnS6p2JOQt49QXAYfEoRsYY8fN/g4TDuSpRxmYfMfd9gpdZVxViViFUky+O55Xypnr6z14zfTWMHqB3zeVzGFXy5qzszMWi5ZcHF9iFiujIURiP/D561fUzYJ6scQ1hpw8IfVM/kAII8vVBlfJ3O7q6jXDuGdz0rBZL8koPvv8z8A1aGX4+MPn+HhCzCP9sKfvJ3Z3O/wwYdB8/PEFZ+drzs5WrBYGrcT9YOwmtvf9sSuhlGKzWHG+PufF6cfkXcM2BX68e0V/mBgHz3DoiGkipZG6dVRVxXKxYX/YM44jKSTaxZLFcslivcAYhzU1L1/9kN1hyzBMbG9v2G3vGYcrqZYJXN2+5W675+XrN/iD8PX+TY5346HWkoTJzFgSyBwiy6alsRUn6w3DMDD6CZwR0YMuMQ4j3k/46cGM1xhzxFTMLVBjzFG2MqWEc46maY4o0uA9Y5GkbE5P6MeJ67stn33+kvPTNR8/vwQtdImp79Bk2qZmuVxACvjhQFJGCqaveXztIBhikuojJCYvdkUxCfdr8oEQIgqFK1BZcRiPOCtttpilbZNSoqoc1pjj7A2tiEoRi7i2dU60RslMfoIc0dHTNDUn6zV1u2S3O3BzeyfSQOLgiDaapqlZLpdHQMF2u5Wstu9xTrTqHlcYOScUooOaciGKKtm5chay/Kxa87i8Etsk/UTWa140u+2W/W7PYrHgr/2dv803P/mI737rU3a7HW9fv+Llyy9o2yXnF+e0yxXKOEYfuLq55ebuhpAin718yXK15vbunrvdgd2hJ2srVi+HQTKuKA7PuSi6PDkkhvCgZg5ZSdCrG4erLTnrIxhCmwdz4RCCyBDlWKDNIpiejDhA5KwZenmNcwZTO2H4i+EjUskHIIq1lDZ4H7jbHqhqgd8v2pbOK6YAd9uREGWerER3DpUEJUr+8iD4xMutHBIOZu9DWRdGaRaV44PLDZ9+cs7mvGa8n1D3Ayllok+M0dPvt3i/x+kIYST7gc531Ks1q4sPqVcf4FYfoqszUIKaQ9fopFABnGuoqoambo5KHvO7KrXgsfqbs+MQ57mJ8OyqtoIs/m2zkpHcW00sSF+0mJuqnIsI88MsV2mLqxvu7m958+aaH//0x9y8vWO/7UUlRtU4Y/DRM6WAN4mqqdCNoV0bdBVIDIQ00g0Hbu5uGP1ERISvYwiiKGM1IXsO4z1h12MrQU8r4GbXP6k0YszoKKCo05MW4zS2CawWNcu25dnlc5bLFavlErI++tBZV2Gsw4eADh7tJ3b7LdPQ8eb153T7LSpnFvWS4CPBJEKYmPxAP3RoKx2GbuowJNCOzUlLTIL03R+Eg5uDOMnEAOcXG05P15yerVk0mpwC09CjY6ZzcW4qYIzht3/tt3j24pRnpyuWnGGmln5XJL9CoLLF5geD1WByIvuR1ioaUyEEdEXyI7dvPK5esDlpSdGQk8GojNWZ2oJ2a+nGWAu1pl03xOC5+umB3Tgd5+bvFT+PN4XHz8mTFz4lIc37nEZRGYtSlqATpnRs2qaVhMcUUkJKYmQbfAG9pQcqV0pHCbY5GBpjBNRUzHsF0S/rJ+WMLqApivv8/DOur6/JYWRdGeqmBaXJccJYETAxTrSfQ9ZkbSiGqF/r+AW0Q6X0DTEd0YoJJQTYIPJOM6E8xiCKJjFSOyPOyVEVwe2MtcKpc7bQK7TCo1CpIKasJRalkhCCODWkCaOUKMyv13gfJPMIgubTOtPalrquWC5XckNT5P7+Dh8ifd+LALGfngaMAodUBb2amYE16riPpbmET6nAowvSdR6+lhaCRkFK9IcD/TAyLJd845NP0DnRffwh//j3fo/X92/5yWdf8Cu/+mucNKdkRIuvnzyHYeDQC5Lv5vaWYfQcuo79QVBSuXgOTn6Sa56Lau2MAH1Y14/eVzmJQjmQys3iakuM8j2ZL0lbNOciZ2VUWayRFKOAC1IEnSHLvBYKsu3Jry3RN0eEOi8ZYZjgMIxkLfe8qit8zoSYuO8H0Ja6VTSNwqQs7XE90zx+1lEufi7VbC58uuJ1qDVsFjUvLtZ8+MEp7dph+oEUB3IKQp+JA0O3x087klXgB5If6P0BXS9w9RrbnmObC5ReknEoJaoqWSl0lkBvtJEZsrYU8mR5j49trgQJiUIc1Mthneh1zpvsnMTJqSihtDy+j4oS8EVdSc18Oldxt73j7fVbrq7e8MXnbzjsBrRqRVJKJ2IeCSSSzdTLCtcaqoVCmUDMAyFOjGPP/rAj5kDWwr+KGWLKKKOJCCBiGHbooHDOkYH7fnqyFlOSNaiVZr1qqBqDrkYWtaOpK05OzlivNqxWa7qux/tATF7UhApyWpzMw1Gi7ubmhrE7YLTm8jQQY/GwC5EQPFMY0ZPgwMfQYzVoG1ksKmTLcyg1yBgmaxaNAFhWqwWb9ZLVciEasdFjckKFTOUeSi6tDb/06Xc4v1jTtIYmrzDRib5l8ugc0Va0hjWlElKgU6B2Bl1s2MYpMI6B3b2nbjXtIovdXDaFp6zEOUY32KqlWq6wWpwqvB/obiOHewGlPDx/Eqnfaz6805F4Ao55cr8kqVaA1SJ35sr4KUEpXOScRKEriZlAiMUy7+Ejxni0ZpoTP2OMCHHwqMVfAuGxhYqgUVOMpCQuNofDnlon+m6JQp43gheZvALWIwqgJisjKhZf8/j6lWCQwOa9p2kaTk5O2G63omsZQjnJTN93fP75ZwXtZdFqjXNG5lZz/9ZaKueoG0dVtCanfXe023HWYbIEWVUqMo1kiZMP6EHcEIxRTJMox5AT69Wa1XLF6ckp3nsOhwM5JsZ+4O34BvIDafe4ADSksh5msrkpc5h50ZjSAs35IehZW6G1lUBUEHxJg0mBYb/l6vqGXVWT/Mj52SkfXZ6zWS757POX/IP/4R/x45/8hD/6F/+CbTfyO7/7O/zmb/0mn3z723z8zW/QNhWL1YopxLIByEbQjaJaoYAcZ2simDmNT453SsMjolKBsrA8afA+Mw4ZVIRcYOnaoIscXlIeP5baSknjWZf5oqtcoTYYDru9QPKnUdRilGYaBnIS/dbN6Rl9XbO9M/z0i7fklLg4P6OuF9SV4+3Wc9Nntm96PnWWVmUql2QulL9eW0OpR9dAGB+krNkslvzVv/wr/O5f/R6/9jufch9f8cX1FT/+s5f8+q+cYKxjv73j0L3Fh56pWpT4WTHmSGvWuMVzdHVB1ivGQdCfKWfqZg1oYlZ03TXDcI+zisppqkr4oynPouUc53t1XYFSTNPD/GwcR+wo825RiBEFDKONzJfTLAEYRSMRgzE1KWqMsnz00Sdcnn2AMRX/4s/+KTfXdyzOWl7wnLELTF2iC5kuebKesLWmPWsxLoNNTHGgGwwmGfbdDp8GbBU5OW2pGsenn3yL3c1rDrs7pimRbYA6EI0lIka3RhveFYmrKocJluwMqzWs1prVyYI8aUwGaxsWyxMunn3Aahzp+4GrqytA2uLNoqWqK1ztaNsacstqteDV558xDRPPTp+zaFaYRUVKoI1jebIBq5hCYMyeacroMLFZn4ptUbXg9KwlBM/9/YFun5jGjJ8849BzNfXUtWJRVZytljgf6eqHIKiAi3bJeb2iMprKLTHaYq1B6xrIDENf1qUqlb1GG0e7WFBVNVXT0h0O7Hd77q9fEifouh0hyLNY6ZpRVajsOOzvOb884ZOPfonm9HuMac/zF3+EP/whQ/8Zt692gqxXD4mX7J68ty/M8+kvOzKIm8MwstvtuDz7gMo6spU2NjFzfXPN3faefhhQoYyWUiJMEzEEpmk6/s55/idUtYfAe9QWLq+Z+YPWGprakYJB50jf7TGqpa0ML54942zVsmgsvt8VcXAFlUYh/OeERlWC/cD8OwiCjw0W5z5uCIEcMykWbcqUSstAhJlVqeSmyeNDLDcYlFZoowrSrXAKEZ/CoR8ZC9JRWdHFNAoCiUPXo29vsYeOQ9eJrNU0EmJA5czQ93TOojJMk+fQHZhGcTGOhePnp/EpQEEX2a9S5b27Pt6D4hceSy6ctlyMKrNSqJSotOZ8s0blTFXXmKJNGIOnqhybzZpvfvNTMQFWioNPjD5wvzuIi4FVrJfNg7NEybpm8es5uL2fx331sPvJIHwO7E4JN0oXTy+FqPGXIkopiuebvHeQlobRkgk2pi4CwElaQDljjSFFQ0oSEFOcSMmjjcZWNc1qjb3bMY0jXTfQJI3SkdEnhhAJBC7OK6xJVLWo6H8drJs6/t/cBgXQOGM52Sz5jd/8mBcvFlQu8P3vv+bN51fE/p5p+znROPbbnimNRIobi0+MY8SnhDux1ItTlJqtjLay5kJgGvaScSrLOGzx054QeoyBppZOR4yRTKauncjuOVM6FYr7+93DvUmipJPj7NEoll7SoX8QNZ65eTlmfPYoHNZqzk/PMcpwd3PD9d0Vh7GnWdY01YIwJF59doXJkyCx8YAhZHl+lcroCQY1YqJUgFMYcI3COXBWUbua0C7JMXJlbkkqyMpLD+sx2/e719OYMSGRhkQKIpzcVBXaNFR6weX5C05OL1itTkDtCXEWbpaOkAgzi7zWOA54P5W5koBaBKRVQFulMk5Z0fcjPnrp7JiZu1yqkqKdpACVE84aSDB2IzGX++UqtFJUzpGUoSqI8/kIw0iaPNo0wnHVCrL4KaYUmYax7HMG42yxpdFFNcmTTY33opTjvfBoJz+IwH/0DOMBknijbjZLlsuFiAuYFuccHz3/Bh9+cM399cTdq73ci/ywgx1JEnnuBJVJxaPH6cEs99HXyELXmUbh81oZY4Ugz3nfdUeXB5Ls0znOai3gnD2u6Tn4gewTx34yM2f8wQ9wfpO6CJ7kZEhkrLG0TcPJ5oTVsqGqHV0ZB9XNgpBhCpk0yL1OGCJiufV1j68VBDMUZ+KHIDifgDUWZx11VR2rxb7vyyxJiOvWGMZJgqG0GxXGCHHeVUJDUIhj8O5+y+ADShmqpiEZI9wzBPK933cFHRk49B3jMAjqDdhvd8TJs7X3YjzZ92UzFnmudzMVBGqKsprs89xJkAdZl2nOLL+TJbjDfC8fnIxVlCpVhUhtDJ988JzzsxOqpqaymhgmDtNAjJnlYsGv/Mr3mJKo6EymImnN7W7HyekJq7bmbLPgiy9eldnIA1KQeWGndERwoWZXB3h3Rb+LApPqojhjuNLGM8g1SRanGwHHIHu7VvK7/DQW/zBR+XDWoRrR80shM40jWmvqtiXFQIhKCNpxIKWJZrnG1g1L29CuDmR27Pc7go9o7Tj0kfshsh0jn1xW1CaybCuwNfzcAbcqlyY/ktWTr4nt1Cl//a9/hw8/rCHv+cPf+zHD/h7l9wzXHrDc7Q1quSC7mjEobreR292IUoHFpaVdXaKVIYWRqb8uYg8DIWmUtlhXM/TXjOOeadpiTWLROurK4YOopSwW8vemrTk9PQMUP/npFw/gmQS5vDamQtREEVWS1g8P7SMRH04Mw0hllmijeX7xjLEfePnyM97evCah+ODZhvPlM7LXXL+9wfiICQNoke0avcakjE6z9BukUXF7d0NMmbpVWCcwf6ccy8UaozRJf45XMm4wRSBGq5KOxadt+b5P6AnSQTENkRgylalYNmes2nM+/vg7LFYrmkUj+IJJbLWMdbiqYrFoBfkZA7vdnuAncR0Q3X60MgW1bIpik8H7xN1uj08BW1lqV4xti8QhCWKOhMkTvMcoC0YLqCNFQXVumjK2qVAGmmp8FFgy/f7AtGhYuBqjBP0cY2DoxTptHEehFzmHrSsoakt9P5LyxCpZpn6g70eGoUPZiBsOpDiS/Mj+/o66EoGHzbKlXa6prHgmGtOy/uC7vPzGjm4b+cE//zEp+scTnPePnIux7tPA954socriCD+KxF6yEaMdg58Y+oHDQQoLhST38/hEKY6UKuBYFD0mws9fl2AsbdBZMKEs92NrlCyI3KaYkZ9fXLJsKyqTGOMN/Riol46QNckn0jRIAK3q4jv585Pn+fjalaB+xPCfq5O6rkXwtqpo61qyY+/pu05078ZRiNPTxDSWShB1bAvF6JnGgRgiqVSJRkuWllJi6Hq8lv64CgX2qhTKimrBFL3M+FLGoMkxMnRdqUAj4zSh5gy6uBGnOJNK5Zi5gOgkQ/mUSYXjpRTFBVlmbqZsRseFo2R+mBNHLuDzy0v+1//5f06kDH7J+FHIrYd+ZPSJfoqYpmV9es4nTugkVV0TQmIcJ7qDIDtrV7FcLKl2XdHECxKIU3pY7FpAB+px/7YsuvfI40rJZqsQeL1W1LXDjxOxZJ91VYNzqCTcKHlusqiNxESOkeQCk6+PFkk6JnRSMCXClAg+o0xFmAamYWLyO7StsK6mbhuRfut7fMyEyXN9t2c7JA4TXF07bG45XVUol1Bfw49PoY9tYmWQ6iRF/vKvP+N3f+s5v/UtzfWPf8gPX75leH1N7Xo2q4GrLwaG0HCfLti+HTjEgdc3b7i533N/GPhP/2f/MRcffo+L59/EmoocPCpkVAQVYHt7zzgFhtGz7w9FBeiOtrG8eHbGOIhqS0yBX/u173JycsLZ2RmbzZr9oed//IPvk1IAJTq1zoi/YirzP6XNEaauZ34mEgBTFjrBYtFystkwxZE3t6/40Y9/gKfHaMM43mFPT3FVQ7s2JGdw3sJSoZ0E3KwVOoH2mSF6olLcbe9o2wUn6xXGyOz9zesfs2ylVTyOI0Pq8aZnUzuc0WKLFSaSf2jxKq24vDwhD5pDH9kfAtpOXFxonn94zgeX32BRbXC6Lq7wGUwgqB6Uhzxyu4WpH+m7jvvtHYdDz+3tlqvXd2gUN7d3LBYNbaup2hYzDkwjbG/3hBQ5f3aBocbqhhRgKoCtftiLh2g2TOPENES2uy2r1ZqTkzMuz05YLmoWiwVjytTt8M6iEyWYYfQsk1AmUtnYnXNHMIipKkIU6zJnDFkpYoy8fPmFiKz7iaw1MUXub6/RaSL6gX6/JdUVuWn4xjc+ZXNyyen5C+63PXEK2KHhYvkB3/ww8hu/8Ybb2zvu7+847PsCRpmxME9Kv7J/vfel+W+E6Bmnnhg8+26HUZZFXRNSYvTx6LCjswhqp7IWBVOhqUxNU9c4V9H3UjUO43isvGGGMajjrNgYEUDPCkgRV7dUhZLx/NklH374Al2vCLr4j65f4NpI8+y5uOpow26/FxcqbRhVYMLxdY+vL6A93/vHVAFjwJUL2yRsEGAMOWGsqFYopUildRFCJIYSbLKkv7E4QeRi+Gq0oXIiFeYLsiimTJrCcdajkyKRREA3hOJTp8ULUMtwNRYfthn4MoMQHotMQwE0KkpbJR/XjFaFG1hqLl0KjkzJfGbxV4RTJ9QKQfZdnJ+TVS4JwCiu3t7TjxNjSPQBAppsLE0rMw9rDCp7uVZTKJwlgVYb/RCIj/12OL7X/DT+leP99mguACBKtSvEbIO1UgbkFAvnSpNLa0mAF7LwUwyEEhgnP0oyhBKEqkKSmWJphdakmAlTJIcRbTMxqaNllqgBJUaf6afA6BOTh673dKMjJLBpLsu/xrpk5htmnNG0lea7n675zscLrN9zuLrl5osrbBoxUnJxv4Pt6LmaBm7GxG5KvL3tiDmjXc0HH3+TZx98QtUsSdNUPPQSyWdiyPgxMg6efhgF0BFlXrpcLrm4OMMHQUOjMt/+1jc5OdlwsjmhaVtu7+6ftNq1kpZaVgV7hPDoYpTnZQbfGjUbiQrHs6ocVeU4dHv23Y7DuEeb4jWYJhS+zKIc2Rh00NBA1glURKkHM+aEUBR89NQpYpRCqUhMI/vulspqaYdrSdJSysfnS5GPVmaPj7apSCgGB8M4YQ7QDwEw4g5AJkVPnBLDeGAcD/gwknIgREOOiv7Q0e323NzesNt3XF3fc9gOVNax23ccugP90JQKsnSWsiLHJOuvUWhVkl0SKfsCJhIgk58mMlGqxqZmuVjSNgsqJ0lvKuTwx0+WL2IezofS9svHxPfIfdP6+Fjmck9Brtt+vyeGiRQlSKQMeQq0TtxTtBZJsHmUFLNUWuMkDiPG1RjlWNQtH374grYVoenr69ujeUCMhfL11ZOSubY9/k2XrlNKkWHoqW1LW83gpAfQCwVFnsp/WmvyjCfUMt9z1pJTwngvfHJglsgDju48IqatUamIdlQOqxVnZ6dsTk5YLFcoV5GNWMZVyxNshmqxEdyJNlQJWY9KYYJHV83X2jfgF1GMeedCHhn5hVCn6orkLNaJvM7cDw6TWP8Mg6efRvphYLFwVE6BMng/kpMgEY3SYlC7bogpsT90+CkUJGgsFxgwRoJMsXtJPqKCImnhoSwWrVwMpYRcHoWE/9gc93jbY4TwAOcVRKEq868i61TmE2lWSQgB4+yjylAWwrzoUgyk4mA/xsQwSQDsJ88YM/uouRsDnc/U1lFZR20thIhOmTgGalujW8ui6TFGk3MkpwAooRHAI+rGgyP7V92vR2c8R/MCrjCsNwuCTxz2AyFPJJ8wVYMu7tY5ThIgo/iu5RTZ9Tu0Ldw+nzGY8l5kvigosER/GIgZsh7ItuN+e2CaAiFqtoeR3eDZ+cgYMyFlbruJuqvokmLB10GHgthrWcia7CObk4rvfLTh7/zND/jOxwte/8s/4c0Prrl7s+N0MzCNmZtrzU+uLa/uE3/y8hVX+55u8uQU+c3f+mX+8l/5Lf7Tv/s/58MPP8SYmikcmIaevpvoe88wRPykyclhlKaxFqM8eW35xieas9NzvvNLUFU1bdvy8ccfiUIGCh88KT5V+HdW4awSP11Ke6j4WEIsNkGWyhbuIAZdV6yWLbWz/PSnP+S+vydYT+MsTmssnhwPZJ05f7agmQKdD0QmQsqMPmNdITIbCFpWc0RmuTkEYCKkPTe7nsZpFvWak/USNUVSmKSTm48d3Sepl1KKZdsQVOZQBe63Hf2oOL1a8umHIwnP5G9JPjLFnlevf8rusGO/vSclS84GP+7oD3sOux2v375muztwdb0leUVbt3z04rroeypW6zV12/Ds2SU3t2/Z7rfstzsWzQq90lxcXJCJhDiK9VfKolWatyg18NHHH7BabtisTlgtaxSCKr/vB+53u4fpe4b7fsA2A0lrzPaeqigtyXjHCqo9Z2KIWJsLYDqSQiJMnru7G6ZJFE92u12ZqVs+eHZOU1dsNifsDh33h54f/OQlH0yKennG66vXxBh5ll/gJ48xmt/4jV8tnOGRn/7kM25ubvnxjz9ju9szjtMjCbMv3w4ef9rWDU1dkULm9u6G4DOrxflRe3YGR06TZxwHYpGCmkVUkhGUrtf+CTfQp1DoQcIWMMbQtIsiDGFQJqFzxiRLWxkWbc2n3/qUdrGkbhfYpi3tU8PF+vyJaIvWmmqxOkpaTss1N7v+5+8b5fh6Ato8kCidc0fuh1R5kVhEr4UaMQ+1DTknxt4zMKFUT06JEOQihqCBisl7ok8ED77M8VIvmVEIUVyGp4dsK6uMSpRKcCqzqozNhrauadsFm82anDM+BNG5ixJApCD0BWgiD7wovwhRU6DBYlUiEN18rAaVlhZtLlkPM5WAMvTNmRBkxtD3/VH3coyJbpjYDyNjzEwJ9iHTh4AnYRDQT8iRGCYskkktrGx4J+sVp6slu+WCcRhJuYCLyuo1iiOM/Muqvy+/n4+fhlxkjQyLZY33UkGP04FsK5RqHpWd0spJMeBvPMVED4Xc88oYqpywZFqjWGiIVc2b2zumlPEoujEVF+yJfT8yTIFF22JdxoWEj4HBj/gUReL450Kds2htl0q8cfCND1r+47/2ghNzYLrZ8upHr9jvB5Lx3BzgfgdvbxV//NmBq0Pi1X1kygnTVPzqL33Kf/Qf/fv87b/9N/ngxXPapsb7kXHsGceeYZoYvRd9S2dRxmIqVWYgmbryOLdkPJ1Q1uJshasqQojsd2LvI7ynmydVk1HFz/Q4rlZSiBv5wxklKvmaY8ajtdTpKidinFA5IsWLZP9JBW63t1h1wIdMzgGrZ7/yTLYyy9I6o40gWcmIkXCX6A5bOt8zxgk/Kg5jjzEVF+dnxDvP7vaOYCgUCgng7wISjHYCmLCxuL0nun7kzds31M4yhRFXSRA+bHfCpf3iCh8UMWuUqlAklFWcnq+oWwk0/T6gsubm7o7Lw4rRb1gpQd46d8JHH3/I4r7li7dvRGUleGIMwiurGlLMRXHlTiqxmGiahqatWK0XaJ2IPpXN3uPHRy4SOfHqzRu6/kBT1zw7Wwthu21ZLAS44ifh76WcqYIYSLvgGQZxVEhhou9lPXzx+jWVq7i8vOCnLz8vibgEieVyJWMSL9Za3XAg+MByuWK7u+fu/gZSL4o0zYJvf/vbvHjxIZeXz7m5uWW33/Py5Uv6Xky645FTqI5l4OO5oGIGGmV88ELHSh4fAyFKRTonPVVdMwv0i22YKGRlgRJINZsE4KVmLpXSaGuKFVIlM0GtSX4S4WtrOL844+xkw2K9EgH1utBDXEVV3GtM2ZdjEmCfNgpbaGtm9NSrzRMgzs86vr6prnrQgPNetOqstQI40dICfRxclFI0TUOOihgytrTdhCs4l+mSKU0+EqM+IkmnUAaqSjNNBd1ZUHYZ4eslCsoqpbJJ62N7qG5qFFDFKJ52BZ2Zc8ZP5klGNM/OjrSJ0loUjhwoawpc8uG1uljZPEbszUExBLGDSihihj5E9qNn10+MCaaUOYTEFAsBGRnSx6yJWWZ9OWtsIbCvFwtOVkt2qxWH/eGoxiBoOGlfhBDF6uVLU713jrLo50A4c4KUFkHglKX9FuNIUBkdNBpT2qUyG5SqcAbqKFxtC9BJYed7b2q8MUyVCB/ElPBZqn+0eNVpZXBGcbZc47O0mGr60uKQ1pb5GjPBDEXgILOoFc9OK7736RIXDgzdwM2be7zOeODmoLm6h8+vMz+9mbjvI7sx42rNqq353i9/m9/8jV/lL/32b7BZLclKMQ490zgwjgNTCIJ0jknab3q+PjIbNiaBsjSNx9XVEbTx5s0bDocDt7d3xBgLMvTR88W8zGYqi1xfU9pLRpfPyZhSzOuZf6Zk5i2iDxwNqhOKbjig8ogxLVpn7KO5sNHqOA6YcVUp5eMcM04Tox8ZY4CY6aeRpgpsTjZsu3t0Eud6CYLl30eOuZgCKleRkqJyibpuQAViShz6jrv7O9pFTdtWNE1VJJoSQz8wTpmYwVYNlTNUlWFd1zStaM3eu4FpDOwPew59z+gnoe44i7U15+fnaKO522/FnDsEhnGkoiqVWmQcR/b7vYDaVFm/Vou4fAjH52T+7/GesT8ciElswsiBRdsINzplmqaW4iA9jAeMDaScGQYBzcQ44aeRYejZ7XbUTc1qWnJ3e1OC3JIXdSNYgW4i5SRJvR8J3jP5UT6mgTAe0EqxKAXAohh9r1ZLdrsdwU/c39+z0zuGwR8D1gOb8MmUsADupMAJ0ZfZaSoAPCkI0CKALiWu7GEinZgenB2skdHX4yBYPpdAKNKbef6tZcS2Wq84OTuhqmtcXWPrGte0uLoR6UJtiui4IFY9HpQgSyvniMpiqvqdVu9XH79wEJx5L0cVgPK9aRxRau6JG6yV3rdeGZq2pm5rhmFgf+hI2aM1eJ8JSZBeQ4iMQUw3+74XLtYjRGpKj+ZhaXbrFqk2VdqkkcgUR4axx5aLvKxbmbeUFHscB/70Xz+thOBRexcIMQoAJedyoyBlL7OEEuwhPwyfs4RnaxTZGlxVMRblhMMU6EJiyJqbQ8foA32QGYQiE4LGG7BGkLKNMayrisvzM0HcpsSydnz87JKXz5/Rj+LbZa3FWUu7WHLY77m5veVP/vifl5blVx/zg53zPNuVBph8rmlaS91ogSH7iUO3x+RGZiw5EeNITgEbobU1y6rhrLU4lTEpsGwa6sqxWq9RzhFqy0dtQzYW61oyhhgy3banLmRgtz6V9mvdMO2ucDpytqmpli23++F9msr7J0VOEih++ZMTvnVuOPE3vP5Xt/jRM02KO++4HzV/+MORVzcjn1337IOY/CoUH11u+M63PuR/+7/5z/jlX/01XnzwISl5xmHg/v6O2+u3DEPPNCZyUiSc6LWWRCSLLonMiqbMNEWGoaM79Gx3e7549RLvJ5TO7Pcd19d3TypBaTMJZ2rmlVFI8cZorEKMp2NCaY5GzoumYdk0XGcPyUO5l5nEGCNpmrC64pPLF4TY4MPAze0VKisqLSod0WeGLjCMogLVrQI5BobuwO3uIBJ6WVHrA4qWb3z6Hba7joor7g97MgljJMnsdv648Sit+danL8iTpfUHxrQh4kmqZ3VywmJ1ymbzEWcnJ1yen5Jjz93dNTl6+tAT8KhGjJ3FKKeiqdacbS74/Ce3vH1zx//4B/+C6+uW8/OWb3/zmywWC6rK4ZqKy2fP2Jyf8+rVW+7uttzfHahqR9PU3N1di++nq7B2JnMnxqlnt7vDEGmrmo8++piTMaLs1fG5V0qxXq/ICu63W3bdAWcNq8WCi7MzNqsVq0UjdyEnbCjaq3tdulGB/f6OECaMgeV6waEf+KPvf5/r6yvImW9+8gmbzYZn5pzn5yfUlWF/d02OE4pIij2b9YrKat6+GjkcOrbbA6pQmNq65sMPLvnWNz/iN37tV3j79orXb97yZ//6z9judtzd3TNMoeyrDzth9OHokhMR4YLR92CgamrWJyfF61Os2YzRGKtZLpZoY9je7497tvdBwMIlEVRZbOd0McQ1rhIsQYxQXCqWi5rN2Smbs1OydlTLBcv1Ka5dU9Uty/WG1lYoxPFCmQrtQmnNKnyCkBQpq6/ZF/uFgDEPG9FjH6j540EqSqGUSKallIvyvaZtwVi5YOM0lO8XxZkoqMhp8oQos6fZqVsdf+f8HjKq8BcMoArkX2sJkjFKtpSyxeaEViLxM6vwx2SfbKqpBFiZqcrXU4rFB7H8PUeiD0eVFnVUA5kDyfweJJNs24Y0ToQcjkNybXSRE4qQIm3tJGgGL1SFnKhtTVtXrNqG5aKlrsQDTeUzlk3DZrlkCp4peAnsRlyd94c9b96sylD70f0qqyA/+lJJ3I5tt8dIV0U6goPqxqGUVLbdoYMkEnLaJKw1nJysaY2lMY6TRYXJGYIixECYCojGGtxyydlqXfr+Fo0VTtxmjdVJqpt2gXI1umrQm0uszjSVwVSOMZn3guD73M25khEwxNQHtjcj0TtGb7jqI1/cRd5uPT9503PXeTovavWgsAY++fhDvvfL3+Wb3/yU05MTaW97IU/vtlsO+06Eg5NB8iMBLsjnqUjMZVnDpVrv+4H77ZabmzsOhw5I1I2j6zp2u92TVo1Uy7IOBW9SACdFvD0/nGq5CEIjkMpNqD8+lgpOXHdROZc5dVn/WFR0HDovVUwlKi8xZYY+MEWKKpGAnIbiihKSPHPD5Dn0PcM4kZLCmpoYd+IhqES4/nHhrpXi8nJDrVesVGbKI2Poubr9gskH3lxdk6Nld7pj7Duena2orOPFxSVXuyv2YyQkLyTorDAWamvYLBrua0dfV5xtVkTvefv6LX/8z79PXTeFXF9cUJxYJCscu+0d7UKoD0M/ElOkrsXdwVVW1n7OjNMo7jZKMYwjIjf3wBPMObPd7kAr+mEQIJXWjFMQD9F+pK0dRovJ62LZltmYBEEB1mlGH9gdDqWK0ceqKEYRP7+9v2e5WPLs4hmx23PoO6IfRL0nhCL0HmmamuAFQCPrz3PwIxCoqpqmbqnrmmfPLtEKDl3H3f09d/db9oeeN6+v5i3g0R6Y5PmPnmHsUVYAfKv1Rkxyh54YpUOnPFSuxiGUuaiKn2UZm6EfKR5lkUe0rkI7h7WW1hpOLy6oKsd6vWC9aTG2QhlHVTXUTYttWqq6pWparDaolMW2zxisq4rAuXQPjcnFX/DfciXIo/bfzFc68kAyx+xVaV1K6ZL16FhIoxpXWeracThoGeSOY2m9xaMCeShtS/V4c1bqYVbCA1VjlpZSKqOMwHRTIXqmJIHUGlGOV0oCsE1PZ0ypSMDFmI6VbkoJZaTVlZE2oPf+kaRQKpD1x/OPzKx6YJzDJ2l5zg/CPGfMKWJyFgd7Z+j2AatAp0zjHIu6ZrNcsmwbaicu74u6Ip6c8PGLF6LcXloPWmuqquJwOHCyXDwxknyMSnv0Fp8EQKBw60qFXTiCSkHT1JA8o4r0XUeKmbZpaFpxoTh/fkalNFWGtXOYGIlD5mroGIOn9y3KWmxds1mtpFWeMk4JV6vWBvBkIt5oMBXKWpb1GVYJTSYrxWHi5x+5nIhS+DHQ7TQ3bzWmbRmS4ot9zw9ed7y8GvjJm44pQ9CqICzBWcM3P/2E3/j1X+Ebn35C1SyOIgBD37O9v2d/6Ag+YkwzSxuSYi6ygVGCV5JkTiGfd13Hdrvl5kZAEMZqGlXRdz37/f7JLCZmiFkyWJUF65MRjK4qeqEaaUNJBakxtiKmzDh6EbxOnpADEVt+soAUhKgNUk9Z9jsBNFSNtKZiSvRdJCmNLuAcHxL9OBKO6FTNME3s+4591xNiwtqaEETFKSPenY8NDZRSPHt+ytnyko9O10zZs+/35D/z3Ly64fZ+y/b2wNnJhv39Be33vkPbWJ5fPqMLB3rf0fsRnUWrqNUWpzRLV7FwjlVd8fz8lBA8b15dcfX6gHWOuq45u1izXq/46Bsfo3BYXbPfD6AUy1Vb0JPCb1utFqJ9Wh6MaZpIRp6F/f5Au6yPiEaQxPnm5hZtDSFFJi/tuG6Y6KdAUx8wCurK0tSOi3gqClqlg5ZzJmvLOHnudwequjry47QR38Pdfs/1zS3OSlclxsDhsKdpW+qqIfqJaRzw00jbVASrMZMnjCKs33vPMMj1ONmc0bZLLs7PuLg4Y5wm9oc9X3zxirdX17x9c3XcJ2QPnOXThJ/Zjx0L1+IaAewMfc92u5X9Okowrl0lalEFTJjIRzED66wIBkjvC1tVxXu1omlbFsslZ+fntIuW05M1ftwJPsI2VHVL3QgwxtUtVbPAlqHjDIpRSjFO/ohatTYf+Ypf5/jaZPkQwrFVU9c1xoimmxDRYxFPjUK8zpl5jDwHrBkpZIvFjvceaw0xClrQakhWkZNB63wMrvOM8V0bmoePMtMwomygjcGWrMuZmebw9MHkyd8fbDyecOtKNj7PPx//XgkmMnR98tBrTc6J4MWJwCSPzR6TPCZMPNu0pNygc+bTjz9i2TbcXl0xdEL6tz6grScHkRtLRuGMpSoi40IqFYujUsSglKLarBiHkyfnlh+1PB+9w+N0Q8ORWjG7Nuj5FQn6/cTd7Y63r2/RSK992VqsU2gS129fkUOEGFl8+7sYa+iBQ85MKaJ3e7S2aG0J3STQdesYS9VmjRF0qTXgNComtPfspyBVf6HM7Lf7n5vOzY3ylDM/fdsTp0SKhsn0HKbID97cc7/3dENixJS2gkIRWC1avvfdb/Ef/M3/gH//r/8udb0i58w4Dmzv79lud3SHgeAzMYiggyxJRQi5gLlGur6TDSFFXFWJdNw0klJAa1itF8QYuL+/FR5WCk/OIWlDUIaQEj5IZ8EZzaxBqlXxtUPhY8AALZZDP5HjxBSTtGKztDRTFsBKComsAtv7HamAxfowCuRd5+NcZrGqsXWDqxtsnRjDiFcHmqWiwhZ1oI4uTHxx9QOGfmSKB5Qb0FrE0myjHoTmEUj/r/7ab/LNj7/NWn/ElBT92PHbn3+PP/lnf8iPf/ADrl695XB4w7+8/ikvf/pDTk9P+eVf+SVQS9oGpv4OkzMOcW5YVC3eQ9MuOLuw/HK1YHfo2HUDt7seXTkWmyXPLs+onOHNy59yfvmMs9OPePnmDd0U+fHnN1xdbYHAeqpJObHsW07XJ7SLinrRsO+2HHYHPtvecHK+Z7sbjoEip8TnX7xCW4Mq3E6lNdZNTDFSDQN9dxCqA1nalnVF2zTHPcRVNYf9gX03cLi6ZvITwzgUukSmnybe3t4yes/t9r5UqZ4Xzz+idg2vX1+z3+3xfuLsbE3lHJVznJ+fyv4bA6OX+Ws/dPRDLwA2Y6jbhvPzM55dXvD27RX/9A/+mNnRvXYVTVUTcyj8xsSh3+MWG6ypMM6hjCRZzopo+ug993dbdnqPMdJiz0DbtizXay5ePOPZBy+o60ZoVIVK9NEnH9O0DU3bsj45KYVUZntzzTh0uKqRys9UVNZRWUtlDMoLinvR1CVYJ07Wy1JkJKZxoHFfv777mq98AI/MwfBpIFLH7x+rpUczxAc1fFlF1sqvjTFS19KX9lPEeZGaCoU7KOT19IQKACXovRMEhRtlSrAVdwpnrbgcPBJxfTcIzo9snltQzErqojxyDHxziVSGu/I6Jeoej44ZpptTROWE1VBpRWMNthJhZasUm6amrSpC02BTwuWMMwZDGUh7j9FaSv/5HBVHSMtjiVw1e/Q9DvfzAzsX1I/PWz2ASbKaCfGiIKOiiHLrmMEn4ugxTqFzQuUoGpYRxn5CZRENn6/AWIS2Ke04siAXU4ilsptlkhSz+o54GRp5QJUWX0rk3ivEheBnxcCHBoEghzsfue48P7oemdREHxJXO88wJXzMEupLYmSMZrVc8u1vf8rHn3zMs+fP0cbiC4J5vz/QdT3BJ2LIhJgJ0wSoMtvJjAUq3vcdIcUjzypqfeTAzshqSIU7y5PWdc4whYTyEe9jQWxKp2G29SJndDHZ9UF+Tj95dIrkmAkpCdAq5XLNHhwZEzBOk2TnKYjDQlJCSCwf2ii0BaUTw3Qg5gFXJVRVsKRBwrHV4NOeiAczslhrYpIOROWENTu3oRRglKG2jnXTMEWN03B5uuHydMXhdMm4u6MX11y6qcd0lu3hQDZKDFRHg0NRaUPlWpR2DFOQNWcN9aJlyuDRVDFRVZZmUXFyuqSymnHakfEkJhbLmt1hYN8N+CTzVrQSY4AQCjJS0kTvI9MUGUcRCwjxsSYmDOOITQ5X1ygj+984jWijBF09DkKVCgEfAs5J8TDvQ1XVMI6jgHMOHSGIGUAsiPMQI8M4glKM04TWyJig3eOsyEsOwyB7sdM0VUVTVayaWgCCdS3OCkkQm6kouIyTOLfHkFiuWtqmheMdkz9krxGt0FR4oyEEtE0slks2mw19f07ygrj143DcO7Wx5QdoNmenrE42XL54wbMPnlNVNcEHgpcd49nz58KRriraxaLEiUizWAqVwtVYV2GNPTr26Jyg6KIqa4hR5ozWalKEUDpkT0dDP/v4ekGwtHpCCMd5R1VV1HV9tMXoB5HZeawXBzwJgLN9xlFQtgSstl3Q1O2xRTovhuPvi+lBSqqc29MgqDBGguvMS5mrzofAKH++b0BZBEbgyftMCZJWGGMLUXlW8Uc28STBcvIPiugAKQrCNYWATpHGaEztaKoKVYnNTm0trXOYlNlUFQuliXUjoBaViT4I1DjlY1Vr9OP53TvVbeaJpVO5ZV+ODlbi4ZfVw88yRRdHB8hjgJBoVU2TwaUkCy9F/NhDFD3L0U80TUu7EICAT5E+TKX9Ia0frYUMK4WstJErVx2TEeOcuAW45qiIEkIQGPfxXnzNtobJoCJdzAy7kVdb0QLN80kr0W6cr5RoWNY8f37J3/gbf5Vf/pXv8uLDDyFHwjgyjCNX19cM/YT3QuvwPtD3PbOAQgi5KPx0HLo9OWeatmHyBRhQHE7EIULsXYxRgmCuKx5vPoduZEwK78Wx3BpNSOJbabQSRcQyFkhZ+qW9vxOXgizoPJ8yU9HxnRM2cazQHKaeRCTmSLuuiUX3UemMUgmtI4mRKUy8ve2oKlifKszCkDKMXaJtapyzqLhDJel0fHhZoXQlSZ82bG9mlLIE7+5mR7/eEk/2+BGiH6mj53LhCBcr4rjCxwU+wevXOxKJl9eveP7BBYu2Yd9rKl3R2oaqXZNS4nbfi7g8QOWwWdHYilUFbWU42bR88o0LKqsI8Z5+2rLr7zl7tsarzNv7LRiNdZZ22Qo9hIS20srzPtAdRvwYhEurM0Y/3TdG79HOUTcNaKEOdcVLc7RinyQWbgO7w4FZD1XUtrTQRcqesd/vyLlwcMt6TTmS+56+6HQao6mdBbMAFDfX16DEBm3IidrKvvLs7ITVYsHZ6QmrRYvWht1uX+yOIje3O7puQKkdbdU8JRjnfNxvxRM8lT1uZJgGsA0fvPiQ1XLF2fk5YRwgSbUrLjvC6hXgi+PFxx+z3KzYnJ+xWEtgG4aRHMUa4eTsFJQqvNd5e9esVqfkVtxnSrtLgnNM4CdJtLSsbY/M5bUWN54YJlQBk33d4+sFwYL4nOdlY+k7T+NUpMgiYZqOVeC7kl2P54fvvkZoDQZyTYyWpnFHG6b5z5nHd7xX8JC1HYPgTMx8UGswjxbdrEoQCvLp4c1JG9NaWwJHJoQZQDLPE+c5pGR84q0oi8qXIKjnVmVMeJ/J2ZTKJ6F1Qhc5NgVUdUWOEzFDVYkCR7KlmlMKNLhahsbaCTpVTlQACnpeGKUli1KYor/Kk6v0/jHLS6f5GhYbjegTh9sDTAEV4WxdUyvHqmmJRZzg0A84A1YrrFYkH/HTxKs3b4qeY5SsDamYrBWLkxDBZouy81xKwq5VEasMmhmIpMFqdJmPGWOoWxFi/8qlyQyKkQpSlx5vnlFA5TxLDxOZrklP9tmzF3z7W5/yu//e73B2diYPpM9MU2Doh7L2UrnvmpwVIUwlSRK4+zR6+n5Aa4U2wqOdr7/WivVmTdMsqBuL9xO3d9e8fvWWunmDUv/84W7JmEMEpIkSyLIi6ll+TwsYqpwBOqOyRyFJZ4wDMUUxPi5BUqGKjEPmdtgen7mQ54omo6N0AwIicKy0JqvEojasNxbXWGLK3IdAW2sqpyGHAqBKnJ83OKvROTJ6SMNDjyLGwD/8R7/HZz/6KS/WH+KjxoeJ+91n5Gkkh4nGOdpKo63jfHVOztLKba1BxYidIt73jGFgf7Mjxkg/9OI9qQw5ixfn5APTdMC1Dhzsrm+oK0utDYfpwNSNoCpalXi2ajEnS6zRLFsnRHetGbZ73nY9u65nRGNNxbJZMiQY3kmeFVLpd91BWqKznGGWsUJVV6ScmMLMFyz2Qike5QZnfl3Mc7omllVKKYydQTLlPgYYU+Dq6oYMDOMgTi7a0A+eSQc6oBt62rrm7HBgs97gnBPecnF7n0LEUpSbmEchT4+cEbqPNUUZSNzjjZ24uHzB+fkZWn2T7D1aQWXNUcloDIKnUEYTFdja0axWco2QmaEp1d1isSwYEhnNzHSz7CM5PngOajXbhylMftjbckpFyFsSzrlLidZPJGx/3vE1K8HM/d2dmOPOiB/EbXx+I6morcyB5OGflgevVJCPg+BMUM9FrUVUW9LxtcK7iccW4/Fnlj/1I4CMBD9zLIUlcM0tUAB5wMfxwUUiZ/j81Wusc0/eb/D+iDiUgfncJpF/40uLw4cizVYCcS43JkxeNEuBmEQmLGYB4FhrWS1a2fHIWG2OPlzz70KLZJYuvMcjl+sIbtDHwCAxUHF1cyPuA+X63G/Hh4v1qHJ8mAPOE0KNjhLQuusD+CiydLGiGzz9BF7HIqc1YbUEwdoanFNUI+wGabEYI2oZRglK01iDLSRsay1NUxfx9Yds2FqHtpUkKtoQ8hyqpAq/vT+8V9E+SbDkzj75GjM8unSxZ8/FRy+QBEwLeGu/7/jJTz/n6voGP3q6w5b97o4vXr1hmgIxqKNy0aG7P5oZj/3I5APjMFJVNcZa6vpBqSLlxHKxJGOIKeLDxDAGppAI8fEzAsMhYLxi9EH4mVphC9hr3gg0SgSsyQVxF5gH5ylNQhwum7CsdwUF8auVp4zZHxql+ZEQu04oY8pcO2ByorVyf0PMHLYeRi0WVzkUME5g2UYqm9AkhjHT7R7MlGJMfP9Pf8TNm3vOF29JGHzw7PavWVSO2ooBsjEG6yKVW5CzYhwnEYZIkdubA36M+ElkCGMMYjtV1ShtIDt8FEnGKfSEocKSpTKqLCGMXN/t2Hc9mJphjPgxoCoBFfU5EJ209Yduz+12x+1uB/WSqmoJK0MwgUPXvbMIIQbRRT5iCoqvYVIiLC8Ad1VGOhROswS/QCjBURKeo6Th3I9Ms5uI6GvORsrBy/uQMYxEj74bmFO/PYnKiVdh100455jGAhRMiZw01jl8EGTsYX94Mga6ur6lHwbQkJQ0t0OEZp9o2o6UxEGorSsoesmpjJwUirGAYVCwHzqU0bj7RrirSfiD1lqsFbTuDKRkDoJJrmNO+UjV0FqRkhQQeiaklo8wFyPBl6JkAm14/cUXX94J+5JDvav19+Sb6gFHeLT0efz9h/XwFb23X+z4We/l3+bxuCXq7OzS8PiNvPMP3k2W8pd++tUvevxX9fQHqne/9e7xNVvb0sZ5aEUbrb72v33vPb7zg7+0q/rOeVD+qt79wlf+26/+/rtvSYTX/+0fc3Ax1j46n4cqifyoBT2/n0eZ6PwGj136r7iBj5Pteb6XyUd/TeDnm2X83Gv1Fb3vnzlRff/1pZFZ9qWHG5rzo3M8jo/y+zP2TBFSkOOYkD56/w9Nv3d//aNf9vis3tkXHj8vX7421ZP3evwZSj1az4/e0XEje5zEq+OaUGWDfsyp+7nHk83x3+GhnpzJz//645eU6x0fcYtln/+KXwTMiPif1Z2Zj+Nz8VVf+6of8gtds/wln0FOouB1/Pv7KMHj8bWD4F8cf3H8xfEXx18cf3H8/+Pxs4Lg18aR1nVd7Hy+Mr//0k+/4hVf+5gT76+TeXytn5czff/QsvqyCvch1f2KKqjM5B6/pfcqBJ5WEY8akseZ5vs/+CETzvP7yI9+6lclLPM/e5Sp6ncqkPnHPX79/KV53qlLz1W9f2Lv/Yj5xrz3jh694P1L8hXV8buHevrt9OfsEDw+DaUeMvv3K9Z3/8WX1eaP79u755YfVXgPGfa79+1nncXjiurpfSswnMe+lo8XxaOS593L9G6lNL/06Vp9/HsfrdJ3ENlPjvzAFZ5/nrTu3n9pVVXvXsYnn37Ftx69p/e/8WXdqPe+9+jZVeUHvdtGf/gsH3/Zu9Xu/DOPY5JyLJfLJypTv+gRU/zSPWM+HgPxjnflSzoo753/l/zML0XE53x0fZmm8fi65XL53utnfeWnI4f8gF5O+eiqo7V5uj6Pv7PsZUe8yOxY8SXnfhxn/fk3/Rgj3bst7K84vlYQ1FrzX/6f/ms++fRT6cs+oj4oLdB2bdTD18oJ6Mc9nrLxyMhLHb+gHr7NEeyhBNgQU2YYB1IKLGqHM1bcy2fFluM1ehosZlm1nPI7G5Li9vaG/+q//D9yOOxRSvE3/tZ/yGK5ZBgHtGhTMcWOECdCmmSGliFHTZykHbBsRZvPWSsw4ih8rHneGVJgSiMhB1KWQbjV4l49iwNYVfQxjUMVNwZljSzOmNh3B6Z52OsjyUfGfpQ3U+zfc7GFsZWDnHnzoy+OllS/tfmA1lRzB6i032JxdFYonYkqM2lo1iuaxYJnl89Zr5a0dSMalFEklNLxgS180RAZJ08M8fgxbznBPzhyzKalKRagR5oBHxQJJbk+wCzPKpuqljlDIDPEyL+6fXPckBsezWfLnVU5Y8pWMWkhlbsscH1xB7ecnJ+wXC2o2gZnLZV1AmbKcl1m4q3YAclMwhh9nFVOs2+lEX3VmASgkZIM8Xe3d/jJk0LC1g3aOXyeebSB8TDgY2RIAnTIwPBopzg/Oz3aIhmrMUpk4GpXUVcVlxcXgGxc97stIUaxkDFicD2GwOA9w+RxZTZujRHPtxTRGtrKUVeG+8NB1EVixmKLJB5cnJ+y2SyFz7jd8frqlikJYMY6hS+OBNEHTjcbzs9OQSsOfcfLV68Zpkmc1QtYrKoq/nf/h/89y9Wy6E/KPUtZdB9zykKPKfvFVAyFU0jl/DWLtikzc1knKWehNBTQxKZuj8/3EEMR8Q8Ms9m2AlsMdXvvZTZFplYyu7ZwtElqGkdVV9R1xTgMsqa1APJvr274b/7v/w9SSqzXa/7ef/vf8vzFiyN/F9RRjQkEyKGyrM1k5iCrURl88PzpZ3/G/X7Hvt/TNvVRkMMoTWUdz86fUdmiqNI4mbdbJ/sFmpT0kdf7OPuZbeoEzCKI+tVqIRQYI7iIoffc3u35x//kn/Mnf/zH/N/+r/8XUkqcnJzw9//+3+fy8hkgs8xpmri+vuYH//rPuLq6wmpFmCamceT0/JJh9Lz84i1nF5dsTk75zi//mghvT+JEInu+ou8H+n7g9es3AvZRmo8+/BCF+FqqLHxaV1mePbvg9HTDBy8ugUzKMvtWimJP9SihPUaPpwHzn/2zP+S/+C/+V++xAb7s+NqV4MnpKRcXlxLEZgRToR0opcuG8U4QnCvHRwAWdQyGT7MZ9fB/oPSRfnB3f4/3E6ena9qqoq5qEhIkn85aHi+E9N7XZjKovOeHf+icEzV0pTBOgqDyES1KUCXTVeSoCsxfU7cVbVNTOQchk2MmenGdSDkTc0QHjU8TIYUj348yLwk+4IwrGqsObS3KuqLJJw71rq4o3AI0hkgsSvYlgpgMaLRCXpvnvFrOuTaO1grQ5gEVKAFQa0XWiaQl61o2DcvlkmcX55xsNizbBdYUUE8QI99csrgZwBSKUG6KYi81UxqO3/ceP0z4cWQcRPQ3TBN+nASpFiJRQUyFvJ+les26BEEj8Od3xzAzQESwAxkBDszOh4qZBGHmDwWVUrSVY9GKqW/lHHWhaszvWQA7+oln2twlUGgmIwmKtVbucYpoJUCNFCLeGUwS5RhXOXRVYXIieeG0RS3cPMM7VWJ5FtqmPn7Yco800DYNbdNweXbKDGFXJHxxQ1k2CxEh8BP7vmfXdThTHc1dvRdLL6MVy7ZmUUugFQm0CZ0NWokw/otn55yebsSYOme6bmBImaSER6iQwBRQNE3NcrmkaWqqynFzf0coqNk0F0wK1pslq826eM/B7GExJ43k4rmnNHWKQniOSahB2lA9UllRCJw+hMBUKFNNVctzlTMpiOyishGMI6ckcnFa1Er63DNvplo7CbRKuGeKTLNoaduGtqlpqqoAkETNRxLQsga15qOPPuKjjz8ucmBl5lnex8PUMaMzJF1aWUoC5TCNvBlvSbUmHRTLtoWcBYGJxllHe7I4Jv117bAlCC6aFc7W1K4t3LkZsPdU0F+eQdkHl6uFCNwbAQt2/Ui72HH547dsTl4yBxCtNZ988gkvnr+QajFlxmHAWYsfJ9arNbUzxBAI3nN6/oxhmFiuThmmiDEVJydn+GIiEB4JjRjT4ipPpiocYM3J6bkk6SmgVCTnIHqqtsLamhcvPsQ6LYYFc7L8pEqca+QnpRQAr1+/+dqV5C8kmza3XGbJrgcZtQdKxEyUh4fXfdlP+rIvqkd9zxRFe/Hq6pqh72mdkSzJ1cdF9mU/58tmnMcSfC7HH31vmjxu8nJjCoE4pVLdJeT9ZCGIC2Q3k7IHZdBGQ9F71DpDMapVygp/KxlyFEHhXEBNc5tpRn6l8gCSEz5IhRGKgj2KY3WpQFBTCIeHjFDfzCxJ9DgEPhUymAOhQLPnayIbkrGGqna0i4bzi1NOT05ZLZdYq95pieUnWZXSQgHJ5V4dH8DyOj+MTP3A1A/c39zRdx2H/Z79/b1YunR9SWBVCVqlc6CEn6mUImb1Hv9R8WB2nI/b6kMAnCtKDSXTFzqHs0aElStH5SrqujmuzZyF96q1YZqmYyA/rl3xeAEoVJpMyoYQrZDoc8SJnQPZKqrKYGonFkcKQk6Ckk1ClZFK4el5LduW1aJls2hFLBsgR5aLBYvlkovNGrKAn1KYmPxESpGL0xXLtmUcB263GZ0Gcd8wIh+WojyzRmtOli2rRcNq0bDveq7VjhgE5X16uuHjD59xcX7K1du3xOjZdx1VFEpFyBGSiACoLFVeU9c8v7igqSveXF8xebHbeXyISXMkEUu7sfxnZN8I3h8rRJAkQRehC601McRjmw2l0EmhVCoG0JnDIDZIMSa6aTpqrzI/h9oxBaE0Xd/uBBVtDI0NGK2oDKgsfo1z9Vxbh0olKSvPXQrvOXaWYPqIx5qkC5VyRhn1QPCe19n8kCrFbjhw3++47e4JKkJKTON0TDQ6PxTnEBGZN9rgtOP5xQvWyw3PzquSDKqy8jM5P3RsjDFoZY/FyuzyQnlW5BnWxxHXOw+ZPEcSXQnes1mvWTT1UfVGK81qc8owepabU/6Hf/j73L96w8ff/A4hJibvGYbpaKgOUiw1zckxgB26UK4hGKOYpsDrV6+4urrm5GTNp9/8ButlS9NUZY2U7p6RPbnchX/jUdkv7CwP7/eY56+9L0n2/usyHInRc6uOGR786PUxJYZhYBoF+qqU6H8qhbRv/jwn/s7vkPcoiiUYWfI5FbmxrCFpIc2nGcmXCs9F4xpD1RiyScQpieKHVpAUOs8cOi9mkhVoq6U1Vna/mIUaYkqbMudMNwwPNBIl12CaRtIYSb6Ib6v5WstuL5ZDpnDDnp7qu/dCm9LDLy2hXFZg07Ys10vWJ0uW65Z2UaONYeYxzcFPwdHY0lauROHiGSalYpldKYiROHriOLHfbhn6gW635/b6hsN+z5tXb9htdwz9ILBo5hnT/EhLdfguNKsQREr2K1+Tqm/eXuOxKnSA0+JzuGxq1ssFdtFircNZJ4GwzINjoessFovjWp55R8FH0USct+rSzjitT8XWZhxRIQs1JmVUVZONJQzdUcR5siIzqAMPO8wsmqOgdpZlXXHStjTWYo20Q5fLBcvlgovz86ITKnqNw9gzTj3rtmKzali/OOV+t+R609KNSSTdfMDW0kprm4bNomW1qDk/WbHd7dEp042Bqq755V/+Fi+eX7BZL4hjT/Cerh+47UbGEEg+UTlxp7dai45sXfPh8+esl0uub2+L4Lbnsdyr2PakRzND9YjaRFGvkUTSKBmtuFlHU2m8DscuhC7ZjTGaKlsxdC3Pq0KTsz+Stuf1XhmH1ZHKaj68OJVKMiVpOxtDVQnRn5SI3rM/dPRdTz+IZ+QweWxVs9vunyTPsawNbYsmZhaO8NQX263DjhSCGOlWFlNV1EVIfkqBxeqUVUoEFKYkwxqIIn/JGEFFETJwEVRKqORp6h5rGrRx5NKF0SofxUXkEdJFh/Rhr5A2tGTOsSAnU5zIpdX4ZcdQzqUyhgEJbLtpwlqHdY63P/wh2jrWmxP+0u/8NvfbPd///vePich+PzJNgXGaRLA8xPKspdISLVZMJKzJGCPG0lpHKqe5u73he9/7JX79V3+FFx9cYq0R1uvRAednBYEvP6cvO/5cQfD4a76k6nofMv3ACZzfmrW2ENltuWkP0TzPM7zSj5asnBIAH2aBD1XP+8dc+Xzp9957rfALZZBeKgtVnrasiz6qzGK0QdqlhgcBEqPK51nId8X0NGeZE4YcUVGRkjiCkx+9ibIBp8K19NN4rLykNToTbFMx8C3/uAScubL8KsDMVy+RuZ0svl7NomGxbGkWDVXjRN2kbPoKhU4SdiRDd8L/q6R9K+9/rgIfWt0aSFUg1RVKZarKYa3IIlln6If+aNSZptLqkAh/fO/vd/qffn1eAzMA/+FDFSNajTMaWzJ85yyuqmT92QrrZsui8rNSFspMaeVrrQt8PJBNOq6peb2asnaUUqTlilgFcogkY0gonDGl6hflF/1onb8LxZINQFNby6KReXPlDKvViuVywXq5ZPKSRFlTlJCUBBSrNadrkQmrrGZ78PTDxHa3P4q3t5WlrR2LusIW7ul+36HtRNO2vHjxjPPTNW3jaGpHXTnqqsKOHh9LJ0EUDQBXqk0jXQOjOT854fXNFYfD+1vKw5mq927okRdb5rdGFdGL48hFH9eXUgqdkaBhFCoJKVppLTqdSotYv1VHdZa6cpBFsm7ZVvgYmIIYQs++dikWxShErixEMbGdfKAbPS6LQ8TDCeXjMyvn96jLVOyrdm/fMPY9w9CTFw2uXbB8FtDGCWc4ZkganQzFVJTsxX5Oem7SdVKqENpTRqXMOAamIjuWJbKJRmyZw8/jjoeR1Lzm5r2DI1e4rh11Nbv/8OhcJIoFPxEKIT7HSIpeAle5o7v9jqpuOL+85PLyAltV/NEff59DPzAM/hgEh0l4nzFIlewnwRWoUkUrlYuQvWbRVmiTMDpze/MWP3lq58Qncdmi/y1XgfBvGAThIRB+VdCZM5Srqyt8QSMtlkuqqmK9WovtiTUP96GUvSEEDocD3kuJPztBfN3j8SzsZ9FArHVY68RDUElwMKYiFuWOOAVCDPjgqWorm6yeZao8RhuUU5goG1+OxREgiUv66EcyqVSCAoqw2oqyStlAvQ9M3guaScmcMjK3XzlWbtoYmc+RywOYyT7iB/2kMpIL8PQeHa9DeQC0Mdi6ol4uefHhC5598IyzixOcNUe5ooy4Gszyc1VdU9c11hhy0Vz0hYszqwHFYoNltRFt1awwVmErQx0dpxcnLFcN7aKiqiuunWN7fS8pcJLAIg9pJivRWeWd01JP/q6eBD6FzA2dMSyquoiPi6pFZS1tW2NcjbXVk5/buoUQf+dUHFgsFsSUsNWDXq5z7niu3dgX5/iWRb0m+kC/34uGZ44knYiTJ4wTXTHF/bJzAPGTrK1m4Syblcza1qsFm80Jq+WKdnPK/XbH3e7A4APDFBhDYpikNXqyWvLs/ARtPma7D9zd7fjRj37EOI1kIq1NLGvFeuE4Oztns1ygUex9YLFa8eu//j00iRDGYkwrfpU5yTPsgxdtW2OwxpZKTXF+uoG8ZhpHbm5vGbuBe3V/XIuzWSpaZnxzqzom0Tl9ArAr3xN1uzJLUhpd1q4uzh/Ky92OajahziSlWDY1tXOslovjjDcVyTGjNav1ktFPHPqem+09/Thx6AfG0oFZL1sxA8iZumlwNbgGphikZzc/TzwAwGaQE0r0Xp2CEDyf/fEf8ebVK16/fo26OKU5P+PyO99B1wuytuy6A+MwMo0TtXJSRQ6RMUQimVwG2korLBqjNE5rDm2gqQLjFLAF/BWTuD2EGLDKYhTFqOChQ3fU7EUq6aat+eSTF9xef/A0kBRQTQqBaejx4wgpMA4Hxr7jo0++AdoQE0xF29QYzenZBrTi9u6aP/yjP+FP//TPmKYkLitJHEbmfWUafTEmkFa8tQ7KefipZ7NuaGqLH/f84R/+Ef/k93+f//N//V/x6aefcHa2/pmo2j/P8W8cBOFLAmB+mNNkNEYZYhQh10N34ND1WGfZ7falrVKxXi+PoJr77ZbDoWN/2BOil4rxKJsiZqPwfjUogAWxsBGNUoMz8rA+0Afykw2oyGISQgJdmoWlBSqzrlTORz38jhgJKWLm1ikKZaVnnyLEwZNJxBQYp0EU2YlYLS2erJEWrBIRtJji0SlalQokFN2+lKLo5FmRLhMFiiJgjrRJcvgyuPVDVfVY/HweLGcjlfhiuaBZNNRNJRm0VWjNUend6lm/UheAj8ZZI3llTg/uFlnqaF+g1LpcN7F+TJAjOQVy9CiV2ayX+OeX1FWDVZapHwjdUGxzpEUiA/R3yST5GPRyWWtGqWI6K61RS8aQ0dGjlbS8mqqmXSyomsVxZnYcQSstYBQKwu9RwqCSIqZUOr9iC0OWdeDKuaqsSHmCDLaqUCmgksJFmS2R8rGyUXkWQn98pxTr5ZLNesXJyZr1yYp20fLs8pL1ekNTt7y+ueP19Q0//eI1N7sdUxBR50XtaSrP3f2WqhLFnhQqKmN5dn5GSmJXBQmNZ+z3pM2aRVPxyScf4o2jXS25fHFJt9+x304MfmL0E754wvkiuWWUxihJxgSk4yGJxdY3P/6EH3/2GYfDgc8+f31ci7MOL4hkIfkB/q/QMr9LMhPPSpSCSImkyr3XSr6Xc2l5Zng0wyPlYnumWJ8uaaqKZVsfOyyzRdsYI8M0ksjSEi1yjCkGmrrCaMNy2Qqga5pEDStr6ihrOk6HJ/tNKF56D/tQATNZI88qmXGa2O12JA2t0tT7nio7lIHDvqN2FRebU16cXRKmyO3tjt0wMHpP7yfxggyIn56Rin8YJrbbLW/fvuFsvWHRtKQg6jMzOAeYcTilmnw0KskKawyrVcsnH3/AzdWrpyOiYvcWo2eaBmnt9gMqRZyR+boPgWGcqCrLoq1ZLhtSln3h8uKCthZ/w3mso42ibgoIUBtAAGTeB7QRJSltK2II7ELAuoa6rtmslwxD4E/+5b/iH/yDf8hv/dav87f+1l9/iDelUn6Qz3x3D/x6x79xO/TLA+DDRdWquAegiCHSdT3DMKKNoe96lm1L0zRHpX1jNHf39xy6jmEciAWqnsvpPfy2x5/J7wsp4X1g13VYI3MLZ+xxI5WN++nbTUmcCmKIIhqr8oPR7sPE/kmbd0YQyp8RhSDQnCk6n5Mv8zTJoAUWkGgq8SWbofZKabLhqI0agpjwRivzDrm2+djiSUresJ5vPgVrlzm2Zubj3Rnr3MJRyBxQZVBFbb6qnHh+WV3mCEAoWbqS4bwuLc4ZnUnR4EwUSWqlSLq0R6FoKJb3Ty4OFLLxqJyom5qTkxOcbRj7ic7s6YI4p6eUMRmiSl8CjOFYTTzMBAu4RsmCtgoMGZUE5VtpRV25cq412hQB9yMXS8umqsBqXWZUD4mDMVJ5KPQxm9U541x1bEv7kDApiwRfBCJYbcHmEgQFxTqPA59YfipYtC2r1ZL1eslqs2KxXHD27IK2XqC15e5Hn3F1e8fbm1t240hIkZQD/Sitz13X0QRL7axcj5xZNg3W1SiVmPwgayyOpOipFzXrszV6uaZZLdmcbpimnpgi4zThQxC5v5SOz8N8wZVSR6pCjAFnDS8uL3l+fsHNzd3DOCKXZDLLScc4z+uyVIVaHZHHinwEacSyh6iy1uRniQEzx8+LJrDNhAQWxcl6RVM5msqKuXOIRA99FGm7KWW0lRltOj5ficpJBdnUNZNWJJWpjC3jEIUjMXRPOwfx0Xz/uC7nDVnLs+pjoBsGojGkesE4BkwjrxvHiWXdcrLe8PGLD/FjwFJh9nu6YSTuD0U7OVPbVoBdTkESesLd/S2rpkG17XGfOtLB3gmEj4+MJGRNU1NZy/n52dOiIMt+JAjQCT+NTEOPyglnFEbDGAPj0FM5Q9NIS3Xysk+fn53SFGMFaemW5NGCc1I1TpPGBI6OKa4yuHpB8J7DYYcxDlfVnJwsub19y9u3b/lnf/hH1HXFX/krv4tzpkippTLOenye+Z0/f/7xb6USlIv3WELpIVyJq7rl+fNLXFMxpSD2NEGg5WMRH767u6VuauqmYbvbMk4T/TCU4aliu9sCYn9irTlGf/ltmSlEbm/v2O62dH3PerUSgdZjk+zLL4qfPH7yAu5IiUxkChM+TMQQyuZlHvh1ZZYgjtuREDJGGayqMG0NChIRU2mq1uHGAqkPgVCyoBwzKWRBKVbVcbYjwUwoFDEnUGCdQykHyhCDWBOpnLFaNn1XaA7Bh1IdzRuVLsKzDxuX1uphjlcqzaxmgjdYZ8TpPYtLhNYGbQvsOyXGEMgh4K2R35SiVKVlhlM7cUdIhfMUNUSFVA8qA5E0jYKgAxZtTdsuscaxvb7jxlbs7u7x0yRmsBneRUAdNTQRxKPKGYcsZANYI221KmdMihiVWWrFqmlYr9bo5epoiDw7OcQYSUE4TctFcwRiTOPINClinEq1Iq9ztsK6iraVymEcR7L3KCzWLZkmqT6mUIyPnaNxjkkLZETNtAAe7s3ZyYZnFxd8+OwZlx++YLlZcXp2wWeffcHLlz/m9//gD9kdOg7jxH4a8dEzTR0OD9nzzXxJpTRJa/a393SHjtubt3zyyTPOzjf8yvd+he3hwN1uz93tLafW8o1vf5uPvvtdqsWCXbdne7fli5ev6A8HUojUxrJwlpwC0yTix1oLrzBMni4feP36CwyZF9/6Dr/9q7/Ksl3w3//e7x/NCWKUaksAVJI4Bh/KTFPDIy1hayxGm+OoIKPEsDdGSAFTN8KNdIa6iDBbW0kwTpmm1qQ4cr+9K/8eBLKdiCox+BGbLZWBtqlk9m0UjREOsilzvpgTQwiQxWDYVeapK0EWoNwTKlbJETo/sZ1G9s5xcBWdrkjJUKuG080HrDbnKKPZ7e442ax49uycjz56RoqwXK04PRzYHQbcyzccdh3TMPHi7JKTzZKzizUhHvBh4LC/E37d3GJXggJ9EH1HWriKgrMo3OssSWpCgzOoR7rJlOvlx5Hd/R1xGgnjwP3NFW1d0bY1NoMfenZ3tzTLmrYykMRDtrKJ73zzE/75s3OWbc1h7GQG6yfC3YDWhroWU2qtEuSBGGAYLHW9LG7wimnyDIPBPLvg7OI5i+WK//c/+Edc397znV/6Nr/1W7/GxfkpKWSMeTfu/OLH1w6C88bwGHTykHk8zAVzzuSiWxlywo8Tkw/sDx2HrhMItVJHkv0cnnwI5IHi0CB9+XkGmFNiu9sdfbrqqqKqHE0rcN0YE/f3W3a7HV3X07btsQrkGCjlN717mWYvsRhDaYeKo/jc7nCzrmTJ8ISzUpwiyBKYtFge2WlEJwmslL5827SFYB5EZb6cu9GC/ssxotE4W9HWS+mxWyPK8gqq2pGLoWqM6WibZNRMLZAgmJmeDJqEqJvEYYjyIFhLJBHIBETodxa5tsZQ2aogWAWMZLTGmiLqLf8TyHPKEP0xCCZjyNZKcLKyYahs8aXVpUGqwGks/y4Rg/AflVHUTUW7almNq6MvX5qkvajeCYLSYJ9ngXNFDDrnY7pjlaLWChtz4YKpY6VnlEKbYvFUaA9KKbJWQmwuFAZpfcoGEZPYywAYW2F02aQVYhacEqmqiaYIC5QM2MdECp4YpuPvf38aKEdlHU1Vs2gX0jFAc3Vzw2cvX/LjH39G1/XEELFKoXJA5Yi1wtNFKZSx2KqmaVsaZ1j0PcpIi7EfRvb7AyFlXF0zxXu6sed2e0dzc4U91FxdXfHmi1fcX99iMNTaEI3m+arlUGnIE0lWG07ZIubsud9uWS4aumHPoq052azeKz+etJeVRhkRkw9JnosH4kQu1y6JoHeZF6JBJY0uAvMxJ0IuSViUtpvwiidSCvgYhPunBDldVY6EOA0oU8g18372SGPXaKFm1CRSUgWL8H6bLQPT4BmHib73R4EFlSL3d/fc3twyhsgQE12MEBMhgzWV0BYeTbKB0pkRLuaM3dZO3DxCEof41bKidpa6apmmzO4+Mg4Dh/0BP81c3nwcHWVgjJmYFUMohGcUU8gzDgeU4qp/f0+MMQgydBqZppFx6Giq4hSRI8GPjH3HyemSurKoHDBKURnN6cmazWrJctFwmA5C20hij5ZNIidXhMVlVit7inBftZK9TJx4ggBfjMNWLUntub7b8g//0T/mgxfPWK9WBahV5sSK45+/6PEL8gSfVnyP26HHP5ENNyvpm9/vd2x3e27vt4Qgau9aFePbMiinVBrT5BknX4YmCqNNmc1Fbm9uODgh+rZty2q14rKofkze8+bNW/p+IMbAxx98wKJtqYp571zxMP+uR2cVfJBKMHqMFSdlUV0XNZPK2RKwAQFNitNFabfkrOTrzpBTj47AMKIQLtVyuRTOXOqJ5cG01uCcwRlNChGjDE3VYlQNyCYdswTSqjUyx1CycSgURhl0VjO6uCDIZuLAfLsSKhVtnRLEjbZMORBSwONJOuMqW9zrHY1rGeJACKI2r5WjqtrjXJQUyUHUOuLYyzA1J4LRROekKlsuSiCUe5tTMS+NgTj25DAK3yxn5qlx1VQsckvihLu7e6YyNBd/FR7vP0KbOM4FH7eFC2E+KyqtaY2IE1hlSjsXDNJKNkYcLEyxrjJIEM0pMQ5DQRbKa4SfNgswKKqqAaRC8NHLv22a0u4P+GkU5Ki1MoWbBqYh8LP0zBWK2jraqpZ1axxxivzo88/4/p/+a374o59CEIeH2loMiaQzdVULMd84lKlw9ZLlesPZ6Rl+mlisG67fvGK767Cvr2nWS9yixefIrtvz8ouXTDmhtOHVyy94+/qK7d2OSjmUTVjjOT9b0/uazMhuUExBUauKGCdC8lzf3VDXhrvtLYvFis168f55Pgo4usyVhkHAEWM/CQfOWrQtSVshRhtl0NZilMz1ta0EXeg9KSZ0jCjvj2s85VBm8RGVpHXtmopWVThn8NNEMXY4OoHMYBGQFm2tJZGTRBxyVsQkvpCPz6fvRg77EW0HItIlUGHk6s0brt6+oZ8CnQ/sg0ebijFltLborMmFT5xSUb+JUXAIJCY/MYWJbMRpYkwj99tbVkuHVc+omhqtIilEDrsDOTzQNVJKbDYnQplSit5nupC52gdmM+neJ0JWBGSP/mwf3rlVGR8C3eFAGHvGvqPv9myWLVpncvT4caA/7Gjqj2hqi8oeqyw4xcXpCWcnGzarJW/v3pJSEH6zKs9sec5yTLjy/KUYICehNVktajfeE7NCaYtyimqx4vb+wN/77/5f/Hu/85f48IMPWK2Xxz3vGAi/4hn7Wcefqx36uBKcQRcPpGwYxsA4eb54/Ybdbs+h6xnGSWxDcmSzWovaSjmBOeObYfaZTFagitXK3OQep4lhnLi6vqNdtOz7AWssIQTeXt1wdnrKs8tnnKw30r7ID3voV3WKY4JYQDAUjzStFBjxvFNFEs5WRkAjRqGdE6X8lFBZo61k4dMQUT5RJUF4OqvQTY1feJxfkY0M8V1lqXSFURoVCuXCCJJyzpYTjqySZPPlYdTIPErBQxsplalc/whhS2mbko/qKhkIJAmAObC52HB2ccLpWUEf1gs0ljAlhm5CK4c1Fc7W+GkgR/FLSzEIXSOKB6DRWiorpUoFmbBA1dQoI0o41a7G7BUhDISpJ+eM0wrvB4gBZSNKZ5pVw+byFGUNQzeSU3gqvQdocpkBPgRCS8YCDhHSqVKmNgpTVVTOsqgdq7ZhvVqilkuUkcBhrS0yTBztrODBmxIUNidc5coSFH9JmZuACmOxwpE2mtLi3xdJZJ+wzkDWEDXGPAEYPn2eyHTBc9cdeHn1lp+8fk3X9/zLH/6Qu7st0zhxujwTeLiGb6w+QmmDUhYVPHqKfPavPuNuccV62fDsxQWL1YLT83M2mxOiD9zf3RGjIg+RF88/Ehugg+fzH3wuVdQ0MnSTmAenTJomUgh8+5e+hakNz/cX/PCn11zf9dhgGaN4x/mQ2R4GPn/1lkXbcX13/9BvUVLhWmOPKGIUKK1wzqKVwSh5DqzWtM7inKFuHDF6Qgz03VAeWoU1FShNUorKCpjJlQioNTgnsCgURT5QkVOQKtxozjcrxiAITB+jdA2MpnGO2jnWzYKYZcwxxVD2BkhJ09X1k3tmtcGEhN73qIKgVHkivLlifPOWVTZsXMN6seDqsGd3uKMbdqhKo4wh6sD1/prDtOUw7qWV2o3c7fcMk6cPgWQSaqO4O9yibjzqxxOXF2d473n19or7uwPOWKZBzHuHYeB3/9LvYLXBakPfd9wcRn706l72CGU4TJnBR7bDhDc1L390+wRVnnxgioH9bsd42DH1B4buwNgvmZxBJZj6PXHqqVSkUpEcBkIUyyWV4Px0xbe/8Qn/+kc/II6Ro4dokpFOOqpN5VKpa1wRF1i2DYe+IwSPTzKvrZqWk6piOGz57LOf8N//f/6/9H3H//J/8XcfdSYL/uDfbSX4fvB73B6dPwSRNdH1A7vdgX4YxdW4ZCo5x9I+mMc9j+qXY9uhNAuUQmrn2YCyIL4mTwLs/U60RAsgRildlD8Kp/AJaOcrcgRVQoXWZET+S5vSqi1adsZqXG3QJosqyDwbLNvwzG9KKRyvibEW7TQYg60bqpTIJklAdQaLlWouJmnRGI6aqFIAZbJKZBWk2swKne1xlpRLdppSKAP893fY49wpy88LKR2loJbLlsWildayKwa+FOJySlhLqV7yEYxATsLHKiAGEUkphsuFlzVzlIyxWDRZKVwlTtPGaJlBlrQt50SOQVqLWYK1q+wRqJN8LFWsnMb86RzcQSpDo7LMCPP8kdAp4rTBKaiMoXIOV1VQVQUY4x78G4GgIipGVF2XVqkumJcEWQyXKclIzsJXy0a6FDEGSQRyRs3Rbr4OWgsSVwuo4GHZPUpbM3TjyPZwwKjMME4cuoHbu3vGQeaIs+JN1TgwBrIieqkeVEqkyUNl0TmTwkT0lhQ8YETdBxF+yF6Ug0KM+GEkxHmEIfZbVeWIkxijamc4PVnRLGvsQtMdAjoblDf0wdIHIbWnlOn6Hu8j2+3uaeVeUMVJa1KZTymtUU5jNQK2QGGVZllbrNVUlWWcZL1p9QCuybO7uxIT25TnZ5ej+okuyXii+JwGoTmlGDGugix8XIPQhLAlCFqHNQqdC0hKK2LO+AQ5ybz7YQCHGPHmDIc9eneQNr8OhN0OfziAsVilaOoK64cCbAv4NEogt4kJQWG+3V2TE4yTpw8TIUeiVZhKYzFMEaIO7Mc9VW+L5GAGI1WroC7F7HkYeg77Pfe3t0xDhJBorexzMx2rGzu2V7f4asV+t+fxQkwp4kOi7zv6wx4/9GVc5AUNnHvhM8dQVB0z5EAMGe8z45hoqorLi3MZZaSCC1HzDBhylA+lTHmNgOiMETk+4RAXxLtSaGuprCVMIzFnfvTDH7FeLvhP/vZ/SNM2xcj6FwfEzMfXDoKPCavvBr/58xgFsXZ3d8vu0LHf78owtC5oskAIM5z+gVz9tONVkJxPIuPDnEYZjbKW0Udevb5Ca9loKmdLQFP4ELFGCMjvlYLvXiRlSzsJYhJOn61rnNNYZ2lqaaVUjSURiSkyTBPWRJKRrMagcGjivE0bha0crqmo2yXWOnkAdSiQ5YQuhafBCDS8BONUWm2UQBizBDlKIJSkwAPSso1xICPB8tEz+kCSzUrmmznSRw+VAEKeXV6wOT2lKYLBdeUKalGqSKsyKgXS1KOil9ZnilgS2kDdLo5JD1quVdU2xSjXShJQaWyGxWbFNHa06xX9OJBCBGdIPpGiJyuByoeYCx/RsVi2JB/Q09PbpXMqEmuqzAEzdeYIjiFlDBETEy4rapNZOENdV7i6gXYpgIoypAfEiBNF0pZqUT3QSMqsZ6bkpAzTFAo4SlHrhuAnhqHHTwGd5f0ro1HJoHSUqtIZaqsFtKNnk9SHI+fMm+trhqHjylnGyTP5wKEf0Ij6R+0M52cnvPjgOXd3O/rDwPZui1MCXT9tKl6cn/DRR5foSpzDr774jJBNmaJaaUvnXPhfE0M/YIwTzmhjOFktWK0WdIee7B2EihfPz1hvFjyLS5yuuD7bEwY4+Im9H9l1IwpFf+i46W+5ur17ghi3Wt4/itICB4rUn9EGjQhZO6VZNZUIt6eIBSatwWhJokOkLYEozElZzKAlobHHn6cKD1Fahn7ouXp7Tdf1fPTpp/SHA7e3t1w8f07d1tRNTWXkPTDP0LWmcRUxQx+SUBOWD21epRSb9YpWJeLrLzAv34KfSAvD+OY13faeXC1QKbFZLQitYX2xRtWRLu0EINR6lBZd0Tf9myMC1zZizrysa6k2lSZvDCplhjjxavsWpRTt2YoPLz/ifHWKTrC9v+f2+oZ+f+DlvuP15y85e/GC5cmG3/3OJcYIPeunL6/5Yf+WH738PnH1nLR9e9wScxbaQhgHbm5u2N9ek4IYaYvub89hOtDv9yQ/YY3CGYUiMY09h37i+qpn0dZ859vfxmmHyhqjHM6IcTZJDLdzVLRtK10VX/YW7dicrNnut4xexEGUMZhiWE0KbDan/P4/+QM+/+yn/N3/7O/wjW98xOXl+VF6789RCP5iM8F36RBKzRWauKmHEIvKy4SzcHG+llZjSuSsicmRki3zGBkQPzRyH0LiMeue7wyzhqUEGecqlI5Mkz++N601h64j58Q49rRNzXLZUle1tDcfzSwfnQHPP3xBu1hxf/tWOHcokvEoq1FWYWuLdQZdGXFzKO9TG4t1iqRlphJTYh5jeTLJTxiVWDZLjK1omyVKB3KOxDBROWlZ1KZFtOwtKAfHalDKhjRXwLnojZIk84oDMXr81JGJ6Glf/q04TgvEXATIEqL/6FOicTXtckFdyaDdWZlNaijEWOnVO6MwKpGjp7YShFNIczzAKMUURFUjpIh1llwqcKVE5UMX0E27XDL2SxarJX3f4X3A1RUpFhWJILMaUpE90xnnNMZq0Ql8dKxWC1prsFo2Lp0T1TjilMIqRbVoqKxmYTRNilRVxenZGYvVhnqxIjcNVhvcEeQkSiWutOetsSJ1pmWumbOAE7yPqJRotDmCKkKaoMwY27YmuFKVWJFcC9YQx0TIPcpIhe9TOiJyH54s8MNEcFLlLZsFi0bhqgV+EMFxrWQeM/Ud3fYOP3qWNQWI0PCtb1xysllwsmlJRu73JqzoxsjoI7u98L38OJLDWNrZgWG/I+WMqaUqQmtSEGf2xaJi7O7RqSPqRGMzFycLVi9O2HvPduh58/aGFIJwyJKnr95pXxewiXVWZl9Z1jNFKFvpAoDTmljARpFENhqNxSpBjWoUq6ZFKUXIkRCl62KsLWLRkaqyGKWplQILCcWoPb7vubu5ISrDFDz92Isu5WpJ3VRY/UDhmpOUAAJu8cX5/REFKcXED370E/qmpb56y/rNLcTAYeO4Hffc5oEYM9vUscs9tBrVZKIaGELEp8CBPU0rgunZaamIlCbPXQQTJWFGYxqDVZbKVDSuxmpL7Wo2ixOqqkHHxIoVSmVe/fRzDrsdt9e3fDtNPIsvWC9b0DKjNn5gbTLfuFixV5leP9hDKUo3oG14dnnJuN/STyP9OLI7dKScGUZPN00EbbndJcYUwYKPFp81yiROzi7QZsl6vaIfR2LMhfMrox1NkXAsqFKA++09th8wVcU0BUgK300smkyjK5mZKseiXbG7veH12xv+m//n3+Ov/bW/wm//9m/y7PIUa5XsfwopNb/m8QuhQ+XPp5DUGTXqvZTL4zhCTkLuXNaEMINIrPTXsz7qAsqg9GcABo69MFA8IJxkcwKtQwFHyEwxBE/XZ1F0SUHmd0qQj3qGET4K5ErByekJzWJJ192ik5OAo3MhjmtMZdFlM85BZpUU2odFk0yC0ho1RuYVOZV2RU6SZVuHqxqU8qTopcLRFmME7aWyQ2XJaEVo1pQgKElCzLl8RGTLjARfC5gnVWQViU4/ui8cZ7Tzic6FpHGWqqllYyo6kEYJYs5PIspMLm0+MjpnGlujtCImVbQNS0JR6ByDn7Axol0lrRkzE91Fa7Qq1JeqrnF1DUoqx0lPshmW5EOEB1IBlsz2XDy5X6tNw6qqqaxIi5mc0X1HpS2VsSzONtRW0Wpw3lM5x+rZJcvNhrptyXUls6Tyg1NGKAvGokrLZpY3q2pRh/FJo7QX/diioBKi8B2F86ZQTtrCMRmUqbHO4lUiMKKCyLVVdSWtYVXcQib/0MRJGZWEhrBoWllfVaZTe6ERKUjBM3QdYRpQKbFoa85PF5yfrfjgwzOWraNtLF5LAPj/0fafXbZkaX4f9tsm3LFpri9fbaZ7BgREkCAlGIIGWAS1yBcUvyA/AfVSXAK5KIqChiCpGaBngGlb3V1V16U/Ltx2evHsOJl5a2bUzSVEr+yble5EnNixH/c3QVnK3tMPTqqn6IlBqC9EiDYytGJ1ZVMpsn8oSlvQVIbFrMKPHX0aiVrOr7KGk9WcOgbqsSIM4hZgiBgih+6hf6A6Pps6O3KEKIO2e7m/cNwEAkFsllKU1qkWjo21msJYmkqswULSjF4SQ22sVC9OABjiA64oFJCDq0mJ6Bzb7VaslFKkzF2eqiiyIDt4hEOnM1dUh3AcxzzcN2KKfP36HaGuOdltUNs9ishdUbCNAzstziG71LNPA1oXeO0YY48LHhc9Y+opkiap4th5MMaIWkx+xiekqDJFBmoVVFWT708jFbbOVlBWUdQFPjm6oeV2c8OL9pDXSpAgmyIFkUVpeXG24rqH2w+TFgV1VXFysuZ2sYAY6aJwRofRse9aRi+ONNuDpw+OpAPKqJxsK5rZnKKYM5vPKLdb2m4Q3EgS3IfOnNmU7UaSgrZr0aPDuhLvBRg39h1+mEOW3FSZX+0DDLuW//VPfsLq5Iynz15werLGmNyl/G777689fu9K8N4WSTbDGJwQbIdBLtCqI6z+2FICFvMZziW6QdTSU5SFP53w5Jow6QXqqY2Sv+uDQOZTBD+CsQmtChLyphaVpa4qyrLEGM0wjlxeX9PNOuqqYr1cZejwwzdGcfp0xXy5pB9vGL0RhQ0TMqnWZFBExIWRaKVVUhYWlUTkKSbQaIyyeV6UCFH4hdYaVqfnmLJGlzXRKbwP7LqBMUBRgC4jKh1IwWfBXAXaSItWGVQGw8irZA1PZTC6IGIoSqmqbWgeTlePm49SMjOzSVNWhtlywWq9oiwKytxrT1k82KeRdr+na1u6tqWuKpaLBWXxBKO1iDe7CSkn6hVt27HZ7TCFxWXHgjpEorFUWlNZQ13XDI0EwaauhQ9WVPi2JyCIzIgmaoPWCLG2FCh90unRNX3/j17w5OyE+fyM09MzqrIgjB2r5TOWy6c8f/US4ohrb0l9j1KKYrZEzWdQlbKZp4hKIcPfNVqVlPUKY8XX7bDb0O43VFVCFxW6OSF6RXCe7e01LkSpwrOPZNAjnduiUmRRF2BKEpqxj8QZhHmBCnC671i+2KGU5jCMXP3kp0f/x0Uz52x9wvPzU9brU2xRMaK5en/B5u6GMnna3Zart2/4+JPnrFYLzs8bnpwvWS4bmnWgmRfM5wUjDZgCUzR8NFtibEnXOxF37npKGxjaPXc3l7z+7TuCD7x8+Yp26Bm95+T0CTEE3NAxtnv2fc9+6NnvB2JIVLpgcXbCx0+fcr5oSCFIABxHTt9coJXimIdn6S+UiGHoFNHa4QPElGlHuWU8+Gy9kwUsfAgcho66KFG1ph9HmVNryfa1VuhCUyZNERT+diOC833P05O1SKgB33/xnGerBX/x7o5oC8xsDrZiTCL9VWgjfOCUCPkcBh9xQQZYhTUU9j5YOOf5b//p/8RHywWfVZo/WMwpGsu7UfGmjtxag4+OG7/nwl2ht5Ez3XK2OaGp5xhr0M7TH/YMXYuOEgCLshIaSKZPheMc3DKaElc4YkiUtsCNjoMCUuSw2eHHkTCOxCoxf7bk81XFq89f8TTz7LILH8+t5fz8lE8+ecVXF3vGsbtPNJXMns9OT1kvl3zy0Su6w4HLt2/Y3N2x2+642bxl8OCS5atvb0nqwK4bUdZjDKwXDZ99/Ckvnp3x7MUTdocd2/1OkGQYSTST0GC0cRkjEPFjD0pjRnukI128H2gP79ncrFgsl1KtO48Pmt0+8N/9939MP8BmN/DJJ6+wdsbUPyP+G6oEpwpAUIBZXiuDXARNl4+86Ce0KEBRaFCifl+VIj2lFUfosbH3GaPNNipGm6ycEgnB4J340BW5/VhEiw8uz6YC3gnh2Tay0dpCoNdGi3vCdyvORO/2lFFTNIo0KkLU6NJgS3usAlMS9X8TTD5vgzUlRhdSkeiCWpdYPc0sxFrHak3drEi6IGoDweO948lsmYf6sgn0zjGknoiTIIdBJeFkpahQUaGSCFnr7HqRcpIaU8KmkpD6x3nPEUUyVYGKumloZg3NbCbzqUwdmKycSIlx6DkcDtze3LFcLambGfu2J8XA5vYGkrT/TnXB6GR2dXt7hzKaMYvixgSmqjHOYZzFxCCLd3QCPMp4sckHUKWsgxpFUstoqQRNFn8+XpJSzJY1J+drnj77mNVqnV0AHOuTV6xWT1ks57hxT2tbVCPVWbNYkgoLxmTVPU/0Ea3lYVTKMZsbirJBqYLd5prrywuevTxnVtcslwvG3uE0+NrgvMYFTZU0fkyMwTGmHlJAGVElQUEYRrSJ2Mrw9MVT1i5y9kKATrfbPX/8Zz/PFkOgrEUVBaaqMKXISMUxCEpaKWZ1BaVlUVeAph8CdzvP4LaUNwdev4WXr57z6WdLTDMDLM5putsDMe7pOtGp9G5kMZP3eHF2ystYEHxkNlsw7g+Mw0AoaqKW7L9alZRJJOJUIdqgfd+iDpZUynNISlJhKU0yU9I2tddMBkzJsyqNFOHFCVVGNheVEj5O1AgJitpqxjgKH1JNhL08HsjPs2WasSq+/fYbwjhiicxLS6qqDL8P1IW0mXulcSjG4NFOJBiTFZ5vqaXfFFLEZWL/BMR6KHgeY+Ld+yvC/sBYKoqXT6ipuF1Yrm1gpyIhOvaxpU0dOgWaWOPSSJksRIv3w71lV+6OVaHBxgptNNEo4ewG4SwWtqQuG5wbKW1JU9aMoyi6XL6/IDrpMFWmEOpUiLzwPesU0IXNGqyA0pQpUaeKk1GzXC6O94sEXd/TD4MYVVtLPZvx5JkE0pPTFkrD3a7ldtvx7v07fNR4LLd37+iHAxqP/3f/fWZ/9Df46NVL9rsDl5c3xCgydCkZYhIhjBC0AP8IJJMNFqI+Cnz0oyPuewa3pxsWaFXIexcV2tZYnfBBcWiHPBPMZCml8xz8dzt+70rwaKujVHZ3kM+tLe5BLscu5v3SqaqKEDtIQeZ0GV0Y80NU1gKosNZSlmWuJLXIjsVADJahHxjSQFGWJEQmrR9UFvj1uIwebeoKaw2zphFbFp2RopNN/IPjMGwovaKoISgJOEUtoBZbFyTDMQhOaAajCupyRlU0rJoFja1Ymhl11aC0JpAoVcrizwUuKMaAzNhS1jftxAX8rtvRhj0dPS51kjHrLGCdFCGADqAj2KizfqPNYE35mVJVuNg/urb7RrIESjTU8xnNQtoUYlqqjg/4VJG7ceCw33N9e4cyhvMnsN0fGPued2/fSvVYldT1HOfExfvm5pZIElfzUtqd1WyGLTMNIXmCczJzDOnoBGDyNFQfZ74T2hSs1Vj7OAgCNIuG9fkJH336KXUjQsnGKk5OP2K5fkqMI93B040GUws8v1k18s4ogcR7F3EktJmU+gOzxlDPKrQRA9j3799yer7EasV6OWcfd+gAsTKMRuOCQamEA/Tg6OlRBIxRR/HiLg3SkasM6/WpEO2LihAT7y5vpEIK04lJCayKAsoCtMF3LkvdJTF6LSyVLbi63XBoPZ0fCGEkBocfO348VqzPP2dWNYDGj47N7R1929G2raj4RM/5ucwOnz05YVafEDy0vSMNkdFBmzQxGYKynCwWlIVlaS2Jgr2+pdvv8UYxqIg1wpskBTwK9wFuYHJz0NpkuyoETZyTLh+n1mgW1CY7ahQiQehiQaEz6jivUulKJ6FFJJHNiwle//a3BO+YNxVPTlaQAkPX0dTS9Vg2C1II9FFm2TrLtoFsD0VVEBLin5j9Ch/LZufPUuTy6oZuV7CxkXJmmdsZvavY2ECLJ6SRfTjQ5SDYxw7HiIuWiMeNHcM44MZRxDKKkpgcZWqkUjSa0Umr2fmItSV1NaOzBwpTMm9m7LZb9vs9X//2twIuSZGTxUpmqEnxqtux9r14mSp5/wota1NrxWrULBfz+xiYEm1eKzbrBFtbcHZ+zunpGd4HZicL3r6/In37nl/8+pd0Q6SaLfjFz3/G1fU7tndXnC6XfPHZp3z26Scc9i1fffU1PlhiVISgBagXvYAjUyLh0UaQgjF4OV/AhRHfd3S9oR0OGF1j0gKlKrFBKwq0rRldJCSRcIxKiGQTtuJ3OX6PSnACuAgIZVrgU9stxgxpTZGH9XWOhdn4MuD9SFOXIn1UFtKG0JqybnJgzBBqJXD9Mos1GwNXF5fcHfbMTmua2Zzlas2hPTCOI13Xieahc2zu7mit5VBXPDk7xdS1nEcSbsrDOOjDDhcNSQW08UQV6J3DW4/1Rbb7SEQt8ziZ/VlSbtUpH7ExUtvISVWglTii0/XEcaTrdwwh0YcovMA8/PZeSPeuC3inCL7AFEo2TTgGhaIoUYXUTpPbttWaYegyObvHqYFetd9p9U61r+gXa07OTjk5PWG9XmKSCFl7NwrHjamFKjZJz1+9YrU6oZot+dUvf8HNzTVvv/2WpiqZNQ3WVNRVjdWWzd2Gfdvy7Zu33N7dcXZ+zo/0jzHW0DQ1vh8YDx397iAZptJidou0ferCSjBBEVXm5xWaZlYzcz7TCYRs/eLV53z86ff46OPvC4yaJIlDJQAkHT3WKqwBojhd3FzfYWwhJsge9psttzc3rNaW+bziyZNTYhCtxMoqUtLEaGhma2xR0x06/uIn/5LusOP7X35MU1lm2kLqccpQeA2LAh8E1IAeiGmktg4y9cPahDYBcGgNxj7Ch9KFwME7dm4kti1KababPcMgDgd3dxtOFgvWZ3Nm9YzQ9by93IjajzUs5qf42HC3Cfzqza/xUQAn7X7H0HXc3VwzDB0+On7wB5+xPSw4dJHd9Y6+Hdnse377/oKL2zuCFhSrNYqXT85Zzuc8OT9l2G0Jw0AVLbfXO/ZvL+lc7vaohClLbjf7ezswEMWobsSYKH5yKYnghBOuXpIsWniUKYc57/HEHFs9o/f4NGLqucwVQVqwUbGoCm6uL7h8847Ly2vqpuTs/IQxBULXcvX+PU/PTlktVpyfnKHGgaE/UBUiv6Zi5onGQO9k5h+1IiiONBebnTMeHt73HJKjiw579Y6VWvD8+XNU8BTaM457om9B5ecsDdzubtnrPaTE9e4S7x0heJpS5OD03j6g2CRccEKmJ2FtQV3NmJU1ZVGxapZcXd5yd7fl11/9GpJUs+enpyi0SP7FxFdf/5af/6ufs6jnLOoZZyenLOZzTk/XGNVQl/dG2zFFrm9uRGFJK26vriis5bNPP6Gpa6q64uMvPuf85Ud8/oMObVe8u7jh9btLqlJhdWS7ueHq6j3X15f8w//gH/CjP/hDvvjyh9zc9fR9YN8GRi+qPmMYRKc0BnTWgkXd60GR1NH7c1J5KoylKCtMYambhpOTBU/OVlzedChjeXbWZPzE7xrZ/ncAYx5ac9zPnVTmeiWZi+lJ1TurxasMkLAFTVNjs7RWkf81xlDkwfkUAGU2BpLnSRA0YmxFikLUbuoKSMIBM4YhazZ2/XDcOCXJlCH8JJ12v/Ukgh8JbszC2hMBW6C8BAVRetYxI9sEvxhxOFJQ7GNC6ZHaOBamxNhCyMaHltj1bPctrQ8cchsXNElboqmIWqOTptQljZ0R1chU1IcsBaNVrpUELUJSiqDkIQ0qEXQUoe70AZfgeI35vmmVOXiWoirQo5jPhhBylSw/p3P2V85mVHVDRHG3O3Bzt2WzbxlHhw+R3W6P0ZZmUVNUJbQHtrutgElI7A8HTvyJABlCIDrha5VFVnDJmqc60yvyWRKzPa4tLGVdUg0PhYsVzXxFM1thi5qkRbJKaSNBzmqI0loqikrAPV6qm9ubO/q+x/eRvuto9wf63nJ2tuL585eMg8eFDm09s9mcFy9esViuIRku3l0IutB10ra3GcGXRC6uKArquhL0I/ZopVUWmf+IEdFzMkJOqUyGub9HMU5SYpMyUCR4seuJiJSg93I9s6YiKjCbnXDjjBgjG2PwzhFcJKIwhcUWDSlq6rpHK4UPA8bW9EPi27fXbC5u6duBfoxc32y52ezpg6coLLOq4umpJipLVIZkSpKOdENPOybaPtJ7jq7fRYoMLh5XnTxLKgOtIjL2z/dcxcyD1eiYiIPH9z0pCzGY0ohYhpUBgfBmZWauUCQvSfWmu+Hq/SUX7y9FwSmLG/kgdlb7fcvZcolWilld02uo4yi0J2vR+V7FlHAhHgFk0uYVHuqH+6n0TEQtKikYvHREDJoqWxn1iSOFZ1KxGVyPT5J0HrrdUWTaaIVSBtwoQTCfg4sOnzyOgAmWMfYMTkBhIY5s2y37ds+hE4cLawx1X6FQjMPAxc0Fw2Hk8jcXzMsZi6rh7PSM9WrFy+dPOX31JdH7RxfmnGN0DqOg6zpGrdnt9sfOkjYWoxVNXfPF55+xWp8yXyyoSs+L5yfUpeL586c0s4qnT85R2vLJzYZm3tN1gX0nOs8uRlwcj+wBlYqMLDdM/OuUwGQAoUhWSmJmrBGSfV1TlZqI5fp2R1Ubzk4bzIMC4Hc5fi+y/BScpL2hj63QScn7WH6qe2CGfhDUjLYUtsC5EZWHsEVhH80TFVnfUYth6fQ6WklVKJyVnhQaqsJizUw4jIsFzosb9HZ3OGZZGqliU+azpYl/kQ/X9bi+E8X/vGFZVWCSRQcNY8gQ7Cx+jMJZwxgDKbZs9oGV0nhbUMRAUTQcRkXcbvCHA29vrtmMI3ejp8iqDZGCxelT6vmC1dkKUy6Zq5rDuD8a6UY1EYOVzFuApIxIlnmXvRkFhZqCYwzjo+uaMqqU8j0yGlsK6b+qDERxkoiTUDWyERttqMua5dk5SRkGF7i62XB5sxVAj/OMPnB5fc1sNmM2n3H+5IzB9Xz95ht8cLRDz8e3n3H+/ByUyEMFH4ijx5aC6kRzRN/a0mKjIFETBm+zuHdSDCE+AGMp5osz6tkJQVmUFRFxY0tsWQo3kZIUGmbzFX6MjGOg3ff89F//Bb/+6jccth1VUTKbzViuDZ98mvgbf+OEi03LEEZ0ccLT5y84Pz1ntpjz7t1bfvKnf8bh7pKmNlSVJWVxZyixZU1VzyCJDm1ICG3EO2ZNLRtl1LkdK4oWScUsKJ6PlAnhWZ1ksueaNslEZAjQD4Hu0PPi1TnL0HB72IuLhzWcnS5pak3wHYtmhipqbLMUvccYGZ6cMw4HvOtZnZ9zcX3Dn/2rn7N5f4kfHFU1ZzuO9IPn9rBjPptR2Yb16VPOz05Zrho6U9OZlnc3r3FO41Mjlh2ZI2xVBcrd7wNwdEsJ4V6Np7QFOimqLPDsBkG9bi6vGLLySTlvKJua9UdPRdj9qN4gbfTkPMPuwJuv3/DuzXsuL66y2ITBD4FxkGC6ud0Sz59Qm4JqOccPmj2OuqqEA6wN3Sjruh/HIxXJhXC05gpF+UEgFPSmMYbKFtLej4o5laAkbaRjT4/BoHAx4MPIMHYkJ8/vod1Kq9gaBi/JMRkoNI2RHE6k01QLHvSgUUnwCLt+xbB39N3AOHSAxhvLoe1EUD+MvLl4y5v+He/+4i02GUpVsJgvOD874csvPuUf/Wf/JcPh8BD4miUhw71lnHO8f/eO6M5xizlpG0jGoGzJ3/7bf4uEZn9oud1ccLe54Sc/+VNevviIj1695PzJKcpYXrx4QVV7uiHROcsYFT5B0gKOSlGhQiFIgakiBLwLuV2a0ymV0Fpa+omIKSzed+zaka9++w504qOPzqmMAWX4XY//3bJpMcZjW1RumboPflOVeMQkSTZXGo2dWWKsUaQMzsjQ/kmFJf8+uWpLMbdFlKhHlNZSlgZjRKZrqvIUiBK8NuiVyaK6UThwOkuo5aru0eGSPLdWiVSYLlitnxxhvH2/YXSJ1JO1PxWmlLleihDGDqciYwSlzikKw6JcCpAnKZYHEYqtyoIiKVIyuFhwtpixXK948eo50YDXgevtTuyNmprWtbRDy7vLN6TkiCmgrZVF6gMpecimor4PuNY9WswJgckfAU0p4sNAwqNUxBox+XXB0/e92NgoIVbb7AZx6AZu7nZs9i2HfiSgiWgR845SgSYVefXqJdoobja3NPMZq/WasyenVLlimWyIVFQYsruFTuhCY2JBXVT4ENHOo63QVKqmYdY4mZM94EnU9Zq6WVNUDSG1RCIYTdTCL4vOEwMYXaKrhPcDNze3XF5c8f7dJfttKyCEuuQT+4zBJ3QxQxdRULSZzqJnsNluubq645tv3vDq+ZInT9ZUTU1QlqAMVi+I5QxrKmzV44Nw8pRzmOCwdUf0Hj96hk6konxyRALjMDxuX09WRZkmoVGQBdOFjwsuJnrvOXQHdGH45NUL9sPAMDourq4JMYjoeQ22SuhC1DS00Zim4WS9wJaGTdfjo8LHxPpkjQqJEMRySCtYzRueP3vO97/8kr/zt/82Z6cn2EJze3PH3c0dVxc3YCJWKWwjerdTS2uMj8OFmEtHRuePLe0YHQWJIkZ829Pdbri8uOLy4krEvrueUSt0WfDJ4UuePT3j+dMziiKik/hnvv/6W+4urvn262/YH3q6YcTWDWNI7HpHsW8J3nOza9nsD5y3LWeVoVcFjS/wo6MLkUFlv8CUlaIAcbRVE/JMzF7DPZ+OBM47ZnXFyWrJ3/zh93n67IxXr15y7e7YuD21nVNbR2V6EQnPaz9GIYpXqUEni0kFRWywpsg2XzkAeJkjDqknKCcvmvFrgUDvOkbnxZw2V62AONQkCbT1sqaez5l9f0m3aek2Hd0QuLzeMIy/5A9++Csxxn2wDo21lKXYLHWHA+PQs98fSDFS3t6ybe+wZU09W9DUp9T1nFlTUNXnPHmy5NnzU6qipiprEiVVWzCbNdxtD4ToabuBMWpcUkSjj4IUKnZHmzulpRqM07xcwWQ+JtFGRiCalO9VwfvLDbNZxfuLLS+ezrNzxu92/H4C2pnu8Eg5Br4rf3YMfBx5gFPVqHXueWfTTD19U+ffesBvm/6+fJ7bE3CcHaajDcv9a2itKRAZnXvOSA6ApEeBAsjc85RJ8AldKObVMlvyJGhb8A7nxOFagCsqm60Kwk2pIMjPscVpSzAFBIdKnkJFaiMyYzYK0CX5gI3y0ShB1QVlGW2FKUpm8wW2VeADavTonPkUymKTDKxD0rkNmnA+Ed3j4H7kdU7vQIp5bhsyt024UClEhnGQNoct83xGBItd5lb1w8jowxHRKu9UynZMkeVqyehHnj9/RjOfsVgtmS/m2KzezwMS/X0LUODB2orDvfK5NVYUJBQmJrSy1P1DdwyFLSqsFWmzkGSNaX2fMAXnpeqMosofiez3MjeeQF0ueEIvyj8yl5J2qlViXVXYAqs049UNh7bj7m7LRy/WGbCls4OEiDuTEtqOmAhJi7uDRpDNWkVcAqU8MTqRlgoQVTak/SBpuUdg3z8/1hg0BcMoXNHBe4ZxpDYV69UK1RWYvufiYkffD3T9gIkthY+gC+x8gS6EE9rM5jTzmovtt3LtzrOoK6zS9L1jFmtSITPhj1+94LNPP+Hs5IR50zC6gZT1VZW2mJKsNFPnaj/m97x4dE0+CvglhEBC2otBRQoSOkbiocXt9nS3dxzuNhy6gU3XcwiRWFjK1YpCa5ZVSeWDyMKNju3VDbeXV9zc3okWaEyCmAyJdnSYQ4d3I7t+oO0HhnGkLCxF8kLh8Pfehk5SqePmq1WWu4uSfIcU8R/4dfogCk1NXfLRi5e8fPGU09NTDtcDm3YPI+AUKmiSBzyoAIXKvqN1gVAGLEZXFLqkKWYSe1NkSCIRFlOiUHVuvyZ8ksTfRScuHEkcJBQ50c+o2xgjtiiY1TNOnjdszRYbt+ImEgKb7Y7N9TXhL1mHIQSGGI/dpGEYUCQGrdnudxTViI+Jrj2glRYecGVpjGW1npOigCaHIVEUQl3TupPtNpF9KvNsN1feOjkR1wZ0up8NgspOMgqpls3995KS95BE27Zsdy03d3vOT5p/M+3QlE1mtfAamCLP9MgeSaUC68ibpX6APAryYE/o0hzhH1IbNWKmKkgOJWphTKax4EfP2I0slqKHKHDmezWH6V6mdP8fifumfsptp/uLAoIijFFIyAHKsmH55ZxVs2BelHx9s6XwARvyo6IUZagISYndCoo6jdS+5/1XrwnhLbuxYGkTtUqQHIUuKIxGRdh3PVdv79htDtSzOduLt9hKtDWX6xPsrKHQmnhzQ9hvMJuDwMxtwdPT57KRLZbcHXbs+wOXm0tcGIiOR4v5aAp8JCiLRcqExi2K4uj7t7nb0g+O5XKF0tKiHp3j9vaW3/72t+wPYvCpjoEvZWsaTz/0nD05Z3225sXHr2hmDbYsKZuGom7wIVKWJbaqMFVFVHnOGnN/QMkMzxaaspaZQ1JSpZBaTPF4iWorprggUktKRUprUSHi+55xv8ONB4Z+Q1FVtN2e65sLlus5P/jBl2htubu74+Lqkm7o2B8O9M4xmy0wZc3qZI1GE0OiHUZ2uz2b6xsOmzXdshapsTKhbCGI17FnHFvcMEj23nsmew+RVNvT7jb0hxbnAv0YxUB07B9dV8yBwmeBcq0NVVHQLGsKq/n223e4ELg5tNQz0KXmyWrOfLWm94HNbk9UhsPg2V18K/OUouKzzz7j5GRNU1fossA0M3759de8ffOGm9sbnn/2MYumwVYjr774hMX6lI8//pjzs3NePH/Gr3/5S376/oKf/eznbHd7nA+cP3tOPZtRzWa0E29UawY/0vuHFVOi70dsKa4PR6RvTMS+x/c9/cUlfrtHdz3BeUbv2A8jm9EzxMT+z3/O1Zv3vD8/4awp0TEShp79zUaCfkh0TkSxg3UMKDoFrzcbnBvZ7va8OrQ8GQaqxRyzTbhRtHElgfY5CMrnJotPF8YQlcYjwJzBjQ/2l0TftcTlgqap+fGP/oBPPvkIXWu+vX7H9mrD+/fv6EPPSM84OIqxIJ7D0/PnrOdrzlevOOwG9rsONwgJvC5ndH3HMPa43S0y4jasmppIwEdHG3YE7fBhxEWHi56opUJGxbz3iqF3WZWs1id8/vH36O96Drd73rx5y36/5e7uit31BWPfHTsSCRjHkTfv3vHu9WtePHuGUYq2H1BKU5WW+XwhOssxcPHuLXV9x2xWsVjXVLWlqCvpKClB+S8WNU+enHBx3dON0HgNXqECDJlTPT3HSgloLmVlrPv5oH7wnChEXUuEyCFAUriguL7d8xc//YrnTxeE+Gg7/GuP3wsdKllGlItM6Vi+pokrIafJBCyOSjgw0tV9CAP4IEqnh4DWlH8/Zamce5pFWdUsVmuqusHY4uj+/aGc20OTy+kFcoJ9RK5Nx2EvSLyQIsFDrBVu8MxOZjw/e0L37pKtsoICLUwG7hhizna0KrC+p3ApD9IVlbaisUm2Y4li1pu8cB7rWSNOFAr6YaCInuhHeq2JbiAFh28PFCHy8uQJSWmUKVjXK2azJYvVmrvNhn7fcvX+im44MA73M8GEIL1CTGDSUZB7GHr86GQOmNuMIhR9D8KYKpD2cOBwOHA4tBk9Ku1nre9pLLbIEmMZHNIsFhRliTIal6T6VcZKZVRVlLMGUtYEVPrIBb0HQsnCToj/H0rlCv3BvQ1eBBq8lsRKg1VSpafgSWGAOKJU4HBo2WwO3G12dO2AHzzWJnEj6QdWJ3OMLUBZUTaKA5vNhuAjbnTc3d1Jtkvi+uISFQeePFuyXJ8wmy/BiLfaOBykAg1RpOXy+++zkom4dA9i2zV4lDZSCf5Vz9r0vxRpmgWLRcPtXRYxOBwwZUkzm3OyWnEYA3FwnD95Ql1XLOZzgpd5jlaaqjTUVcHJ2QloxWa/Y7PZopTmi8+/4LPPP2IxaxhcYHV6zmyxYOwHLi/ecX3xjjev37DZbGW9jZ4EDN4RhwGH0AlQQngXx5UHsxhFlgF7UKUABRobwUbFyXIhzgRDIN5uGEKkd+5ITwg+stm2JBfZWIUhoaM4xXvv6bwIPvsovLIxJboYGJxU/qmo0IslarHi28tb3t1teX95y4sX51RVIe1jpXPVmqutGLJ7iQhTTICch9dltIC36qammc1omoZgAoW2FFjcbqQbOg6upQ8D1ln21x3FuCEsNS8XM+rZCWe1YRgCCoMxBWMzMrqeUlVcbt/T7gd8pzBFSV3OcFk4P+QuTCAQEaeGlNWXULklGjKvuihZP1tTPPkIkuLqytIethSmIJh7QF1KkZubW+5ub/mXf/on/Ad/7++zXi5JGTCTUsQWSPcrJnbbLUPXM/YlIVbUs5KVPkHbSvRzVaQoNKvVnKapqNoArX9gIq5yBSt4DCn8HqyflL1ikgAmIftLZs7oEZOCQamSEBK3tztub3bstoeHAeCvPX6PSjDLW2XLI5XUd4LP8WeP0TGr3P8VpamUvhnxFXIcVYo0meTlIk7aeQlbVsxXa8q6OWoGHh0suA+tHwbBYwDX3z3n9jC512eRgWgZ+5G6rHh69oTD2TMRxx4dVV1mebY06UlTmAAYkfZRAiqNWlMqjwFSzAE9hWzcq2gWM6LJXLDgUQR01IxaiwOAd8ToKYzm5PSMhAVtqesFs9mS5WJNGD3t7sDN1TVRefHge3Bdk/L+sYWNyKJ5L9yzhGhmigRdrvBCyFW9uBp0XccwiJXNtAdonQ14y0kiTcjQRVXSzOeYQhwXfNehjCD8tNKYsqSoa+LYk1LILScjNlJM8+BMjVHZwUF9qPAjCkUxjMQgGFqNiAwTxZFC9AgdisBu23N7s+X2docfxBi3KmEYHOMwYqw4k2tt8c7hx0C42zAOYk2z2dzRtS06Je5ubvDuwNNvT3juxW7LFODDgHOdzGJCygRwaZXLOkm5yvMZiezwRU34UNFiulcTojm3wsqqYrFYUs/mDKOjdx5TiKH0crHAH3pcVJyendLUDfP5DDc63CgoxLqy1HXJ+mTNpmvZ7fcMw0BVVXz60Ud89MkL5k2N84Hl6oSiqvnVz3/B5u6O27tbbm/v6LqBzf4ASmzDBu/xamCMEWWMtEUz1UF94Bcl3qL5YxppJDARbBI3dQK0rSeiGEOgD4GU25IxJA7twNAO3BEwKlEYlYFTCR9i1iJV8gzGSHKObhhRWrFcL7CLJWq+5PXVLRd3G66ut5ydrykKc5QOTGrS582Jdc7KhbZzbwBO3me0VhTWUNcVdV1RlSVDGrE5CIaDx7WjIJJVYEye9qYnHu5wOwgvFfPFkvnihHGMea/ShBgY3QA+sd+13PU7Yg+2LqnMjC7t8IjmZswBMCHJNWrCPMgz473HeY9KcHp2ypPlOXebDd6PXFxkIJm+DzoxJu7uNnz99Tf86Z/+C/7oRz+mtAUqRVxOkgUBKb6obdgzGosfCxIF3okusVUGqwUlbq1hsZzRNBVlOUBGsYtEIYhpgLkPhJPHbE7HRYULCXQawUEY7oMg2c3GFIKY3XXcbfbsdoe/NOb8ZcfvHgThGGyOwJi/Yvg4+QvqDx4I8sVNN0nldih5EUcFIVuhi0+cWOOkFGkPOxKacjajnjUopYVYyf0s5UHh92gzgfvAGPNsYjqcS4zD1KLVeBW4eneJ/+wHrE/P+T/9h/8R3WHP5eU7NluB2R/2nRjxOof1W3QwKC9KCDElHAnCCNGjRrHdMcDoNAHLaBe4qEU2CjBFg7I1AdlEolXMZmvKuubk9JRmPqesGlrnsFVJ0RTc7G64uH3PtrtDm4Qfh8eZz7SRkkQSMme1RglciYQ4IVSiTmILeSh8iPjgxKA4Z5G26I8z06IoKMtS1PfrUtzXjWxygXS0WarnM0xVo8sKlRJ2PqNar+g3Eqxk5qpINmILK3OC4HObXUNuy1ZV9SiJ8t0trltgixWmkCAak1TS0Y/ENBCT6Hz+r//rT/j1V6/5V//y51htKYuKL7/8DK0Ny9WSjz76iJcvX1A3Ne3o6Yae1+/eS3bb9Vy8fcvt1SXej6TSMgyBn/zkp/xgCCRd8PGnr7CxRmFIwYkYeIyycpOS+VgypKCIQ0AzkuKAbVaUH1SC8kylIzqPGBnGke1uS1KBiLhsdL1js+9YLgcwluVqTb1IYA0vXr7g088/5fbmjsN+x/XFO5arFfWsRJcGPSoKrflH/+E/pCoqlssVrtsxDD03N3d8++1buq7n5uqadug5dC03ux2HruPmdsNisRJdyHGUma2PGC3qTkUhCZQb/INrgt73lEHELxpxpOb2dks1OpqYeHX2Ehctaj9yCInWRQIT4C4ntkn6S12Qlrx2E3o4b5UZSa6mF81jj7qq+OyLzzl/8YJqteL12wt27fDAlGVSJJYvGKWwakKoG8TFJVAVJVVZPrpfZWGo65Jm3ohggzHYoCmVpVIFM1Oja828WuCUgPu2l3t+c/010Sduvznw6uWnvHzxCS9efootRGpv0gc+XZ1yerLmb8Y/4uu372n7lkN34BBrnOlJWec1I3nkfUkJHRGLJW3p+5G7dMfPdz9n9qOaj85f8PLFC1L03N1cMDrP/tA+WoO7w4HtbsfdZstXX/2avus5O1mznM+pq4pxFMGDFGFWlRATnR8wpiQlR7PbsjQF9UyKFGMNs3nFbF5QlIp2v2EIBp8s1XxOoTXJatyQhRTUtGcnjMmes0kCeiSrPDF1HYrcLNVi6psCRMVu27HZdn9J7PnLj98dGPMgmNwHlvtv35sb3n/+sOr6zvcfzOqAI2tKgQirhkAYB6J3Qpg97IhFQypnxKYW/k2cxJM4gh6Y/kr68FzT8WuPDqVzCS6Q/BihbXtZDPs9i6dPmBUrnpaa+cmKcRxpD71UVaNDjTfge/AdzosAtYv+eN64EZMSBslaBQAzw0dDTFkZ1M5QRQPWSlZd2izoLMr6drZgtlwQ+x6M+NMNbmTIvl6QPrh+mJpqIYVMjzAsF3Oausn+gYYYNCEmAYNkT8EQx1xB3jsAaG0wOqJtkW2STEaT6qMu5HH2q1TWPjRSCZqsd1qU2LpG7S1pElaYmq/HW6KOJecxkXqoGJMgBEcIIyE4lM16j8ETvCM4MeIdx5Hd7sDlxTVXl7cMg2ck4MbAfnfI2bMYHCtjjl50SmnGUdCc3jnGXu4zJOq6oSg0h+4gLdbbLZ989mkW+i4yX1HEoCcum8Jk3pfKBGhN0gafDO6D+6Xy+yaJpXAF+3Fg37UkLa3tow9n1tZs+5Fi6ooEkTQyWrFYLTBW4V1LVVUUpclJqfCsfIy0+z2b61u6dosbZS11bU/fD9ze3tGOA/ux52q7oe17tl2LV4o+BspmRlU1VJVQb1QSsIsi804fHFql7DsJhdEQA/u2E/WaBF3X0w0D7TgyhoiLApsXn7opEMp1T52NqB53f3TOhEMG0qkIhbU0TcPZ2RlVXZE06LKgQpGKgsnE24WUtSyzkwM8XpMxZXDfw4Rfxggqu5CE4I+tx5Rn7jFGNJrSGNTEE+ykonWj4/LyvXgIDiNl3TCbLygraXcqElYZzs5OWMxnKFVwdX3N2A6EPuB1IFS5CtLm3owgm8yQOysxBMZ+4Lq/4vr6ipvTK/a7jcwzYyClmCFB94f3XlxFjOHQttze3tK3B1aLBbNZw2q9EElKWwj3M0YiHu8U0Ytoisi9hbw/SMepaSrms4aytLg+kryj3W0xhaBirZ0GZekBFW8yBVDYgADnrKB4lTbiOj/9TsyC9rGk6wbaw7+BIPhQMg3IKjHpyAP8qzwGp2Pa1O6X0f0EEATerrNaCn4gDi3DzTWp3RGHnq5vCfMz4uop1Wwu4toxIHCa+3Oc/nr+4/ft0jy7eAiaAVCmQGXJt+hls9kfDlxe3fDt27eszlYsF3OePTkRzlVKuNxO887hDpcENxBcT9+1eD8yjr20NEMQxwgSlphtYgyDrqQFgKZQGmwDRUO9WFCWJfWsZrs7cDh0vHl7wVmzoDk9J/YHUaB3jn4c6cch35NE8h+013JGNfpAURfU85onT56wXq+YzWZUaLwP+BipypKiFPHx0fnskp71DCuRoIspie9bUVLY8kHrMr/X6kEwzG1WkQGRQGDqinI2py3uSN4JaEcS5OOcdhJKmMyTtcoO78dlk4jR4f0oXFMrwcs5hx/FtV7jOLQtFxdXvH1zwdXlLWBEQSONXF5dU1SGosqcyyQ1rjEFxnip5vJmOg4d3gmEfLlaU5YFN9/suLndUVRX/FvK5ksspMMwQaGNbPxoBVZEDaJRRKPwVuO85jDqh8vw2Fa2eTcIIbDvDkTt6FxFaRb5vAQR50LidrPjxJYUpWXsW4buwNi3VPMlttAoRmISq6+kRTKusobLm1vev7vgl7/4Cud6lBE1oRQEmn9xdcN+7Nm5nvebWwY3Mo6B/TBSHg4YW7FeRowpsMrkjkbW+HX3laBSUGqhRmmlaIzBO892u0M7T5sSV2XF9b7jdr+ndwEfc4ssCpdySoEmC6Zjv0fdB6rJd4Eo77vRirquWa2WvHr1QmgtRObrJU2cnGyEvhFCzOawYJXCJHVcyiRBTxMND2OFUiLrpxX44BjGkWEYGN1wDITeOZltmxKwpDgwHkbC4Ahu5Obmgv1+z7v375ivlpw/ecaTp88YRlEIil7z6acv+fyTj1kvT/i1Lbh6+45h19PSExqRnysKcbnXQYB3+ARGksfgHH1sObzf8c1sxUwXXN/cst3eMfQtMYm/6cPDe1FoqpuGtm258J79dst6uWS5XPC973/OcrFisSjwTlx8iAN+VARv5Nq9ZxxGcYzJI+HlasFpF1kuZrjQ0Q8919dCqTo5l0RFK8EdWFscuehTkE/J3j9b1maNYqn+VYIwRFQSO7X97sDmbvsBmuCvPn4vU92YIcVTQDRKYPZSpk7qMPfOEX+dhKkESp0T/4gJIxwOxMOW9tuvGDY3HN6/hrFDxYhZzKk+/yPq85f5TUFQhlOj7mHFd4R33L/WUfz7A55g1cxp5kuUEiknjcLakkPf8ebiAirNYjFjvZqzWiwoi5K6qjFVSV3XzJYzAUJEsh5iREVpjYUo0OrJtSCpSFQaZ0pAXJVtlPZPwGT0r8hgebMjFR0rZ2jWT6gWJ8xOz9lut7y/eM/uruVw26MHLd57jy4rt9ZUYIyeZbNivV6ymC+oywqrs9Nzks23qirKupHhfvZF9IzM5jPOzs7Y9yPDMKJILBYzlosZi8WC2XxGXdciY2QFJIO6R/se144CU5Usz04Z9ztGpQj7w5G3GaPPWaPGFCIA7KM/GibfHwp0Ix9Iq5GoUQjcHKVQSdMeer7+7Vu6dhTx4aIkBfFxvLh8h7aaorJ8f/8FwziAVpKR1onZbM71bsfVu3dcvHlD3x2om5KqbiirmvXJU0LU3G729ONIVZrMcw4kPKjJ3kuqTG0rVDknlkkUfpRmDGsG3fIYIKaOwBJjjFQ2AFl7czmvwTv6eUVZ1yhdsGs7ormjrCrmywVVXUsAHQe0hbNnK8qmwhYVVXPOfiubw69/9Q2HrmO727NYztBGc3VzxzA4htGxPew4uJ6Na2n9gE+RaBRKSQb/7uKdzLrGkZfPX1GUBWVZCCzf2kfXNC9q5qYSioRLjJ3nbtNiYqRUcLvfsT20dIedPDsZxKXyUzxVbOlBFPpwc5PZcXZwSSKBdvZkyenpKavVElOIqH1dV8QohHCyju/0eymjEWOSDpNRWeslkYXiH7evrRVgVtse2GzuaMoyz9sDRVWiSp1pGJ7ZbIkxmv1+x+nJGq0U6+UJXTfS9y1vvvktfhxompLdYc84Dox9y/NnJ7x4fkb0He3uhnff/Ibruyv6oqU8LSgqI0E7KSyW2lQ8P3uOKQx9cvStZ+x7trdb/uIv/px3v/0WrS1KJ4yWsYcLD5MWxXKxol22rFZrlDaUdcOXT59xe3PDxeU1377+lpP1CU/On/Llp1+ymM9YLGoSmt2+40/+b/8dQVlsOeO/+C//c1ark8w7NpSVJsSOxIDWntm8QunEfndHSjVlUTBrZoxuzzh4uq4XMJlzOCdcaR9GGd0Yi7YNVVFTlhXzpqQuLXVTMrqOYfTfXSh/xfF7o0O/02LMI77vGO4+WKzy+f1Y+R4nGiF4UnTEdkPabQibG9rXv8Ftbhiv3qKdk0AZT6EXkAJp8p7LWWCaWrPpvu3JPaLrYZD88I3RVvhxYmApJGVblDLPGAZuNxv6sWcYO4ZhEATebJn97AQhiZaqZ8p4C2L2TkyZyyZBEBWJWuN1MQ0lsCHgE/ik8Cn7ZmmFKSuKALN5oLCVKEVoSwqJdt/SHXqGbhQPOmNElf/hppof5pRinq2VlKU9bioxZ89K6wwQETf4oiwpY8L6SFVVzBeR1WopVlkxMJ/Pmc0a6rqSFqqZPPgeCBKQjrOZaR0oYyibmnrWgPeM/UD0AsbxzuWWocEUFQmVK1z1+JoUJFWQjrZVINqcBmMspAKCwfvIYd9lUYGcFGUTgmEcUUERkMpN6SzVp9NRMk6MmXv2uy0xOOq6whbFEUjjvGjVjqPDmBzI80finrOltAFlSaoCO6FgK3RYoMvi0bXdc2Ql+4063m/QKVFYRWFFIs2FyJAVTgrnsWXB6uSEZjYDpejbFlsqyqagagrKqqKsStq2P3Y62r4Xl4Tc1m67nq4f6EfHYRzo/MDgxmOlLKAyqdD7vqcrWtqywjlHYQUEcV9CPbhlSaOSoHdjSDgf6HuHToGgFS6jha2aZPRk7R5lGbOow4PmzgfPcA6XuW1GkkTXWpldl2UpCvTZ/HiqHEBQ0yo9kIHU6jiDnK5jsl/7cIpip65F8HR9x6E9SOcnCRhEZ//REIK09rTItJmiwFrNbFYTfKDvBrabG8qyYHt3xu4gM9rDfsfV1SXXN0/pty13t9fc3V3THQ64xlH6EooMRorivFGaktPlCbYq6dPIrd8S2pYQPJvNhm7TUTcNdV2yXNT040A/3qNDJQguGdYdZydnx/W5Wq0JQbxRb28c/TByc3PLvL6gXSzwYYWpNCF5fvbzX9EOHkzB3/uHf5+iqFmYWvZAFVE6oHVEm0RZiZCDLQxWJ1Loubvd0bYHwV4cxNVkHMdjsRSjJwQZXZmioSxn1HXDi+fPScsFs/pUkN7+d60Df68gGPOHOqrFhBhFC0TrvwIMo1DHZoW0/1QSErFSkUggHC7x+xvaX/+c4eaO/vKGeP01Zuyo3IBJ0v/1BsbdFn04UJ+R++D3xG2QanUaqk6vLud+vIr7dko+tC6lJRqDzMZMwWyxoqwblNFst1u228i7d4GqKsSkdbakrsS1vmiE4G7LmsVsRllYZmUpHBdtMKbEaisCvBmgcuTuZb6cTwofwSedUbgeqyW7qZ7MhKy/2RF2cPP6LV///JfcXV7T7Q5UlUZb80HtO120VO51ZZg1IloOkXF0DNHJ+RUlRSVef8ZaZvM5ZV3jk8KWFc1cHOHH0dF3LfOmYlZXLOcLEfNVhWSjIUH2gENHEeJWEqCTUujCUi1mrM7PqIuSQ0z4ds84JLabu6PkGMqgjLiQCxzs8f1KuiZQMrqEsYh5c1FTFAoVLcPeQzIMgyDjvHcEJ8ABU2h0yAMqrVgs1yyWK5nBDrLRFoXJii2wub2hLC0vXz6V1g6G0UUObUvCsdvviKkUfzw/ijJ+imJ9pSwxlvigcNFimhUlDYk1tSoYef9oPKCn6jwnJVPS5kfPoAbU2kPypOR5f3XNruvAGubrFbPlkh/+0Y9kJuc83/7qK4oq8XF5TjU3FBjGsefq6pKvfv01P/3FL9ntDpi6FvNd79keWg7DQO8ch+GASw6fub1aKRFKSEi7KwSGruVgDJvdBh89S7XEWvv4bqVEP3gqJ/vE6DyH3rNrR3ADlU7w6RNmuuZZjMwvrmkHeapl7mTRhSWq3D7PQeshtgCy9ZK2KLIhb5CZlsy6MwJSSWKmIHsYyvMogEdJ4qySe2+0xucuhcJIp+tBhauApqqorEWlxN3dnaCFlSjnFGWBLixhGGn7kVnVYLTmZLGgWVTYwhBCYigtZal5//YNh+0O13cMY4dzI3ebDXWh2dzeMB5avv7tN3z7zW842FaSrHEhQVBrYgRrCub1gs8/+oL5YoFXiV+lr7kcr9gVB9rNgbv9hmbWsFzMKMoz3l3fCPAqv59aaz7/9FOenJ4ytD0/+9nPOLQD9XzB3/7+D1guFuw2d/z2q1/zi5/9nP/3P//nFGXB8xfP+YMf/wHaav7Z//wvuLy6ph9H/sP/+D/G/Sjy5ffnDOMBHw5UTaB0oh1qq4b1yQkvnj9ld/uW199+zX//3/7fubu75nDY03V7gh+JwfPy5XNmTc1i1vDrr37DZrsnYNG6oizn/Hv/x7/Pp599wbz5t1AE+g/EQ/664/eeCd67RsRjW/KhhNpRveD+N+X/VW5bqoQadqShZbi94nB3S7fbs9kOuKHA2TPKZaIcDuj2BuVHQRwaURLxIUg7Q8cspDONUx/MH6eHJM8Bp/NXfEiRUFRVTVnVuKGXh1xpqqahbhqqpmEY90IyD54QA/0w0g+jqIoYS1EWGSZeiKuCFaFw0b+buHAam81DRRo5q7WkhI6KEJKYiHpP9B43DmKS6TxuGIl9TxoHQgq8u7rgF9/8mu3uBud7TFkRlIhgP96A5GG1huzYYdEaQvTZmkpjC0VTWakGtEFbMestEsxdwAwjDAMndi6tXTfLbtxWWsLKEMfAqAa0NWgfpOKx0mqV4V4OZiqB1hR1jfIBX9eksUcNijDKjHNwDl0KUjUZCYaPAD8paxs6ASIoHUkqUYcBqwWIEKImxAng1HFoW0pboonH6lhrqaoXqzWL1ZqyqmHX493A4bDjcNhyaPeZ9tHkn6lyBurJ/kdYLe4CiYQ2FVCQbILcno1JzmVwMCIKGR6HspDi4zaUuIZXzJpZRsQCSnHoerr2QFNYhn7Excju7paqbynnFa8++5hmPseags3dHe/fv+df/fRnNI2laiKFKVBBMV+tGPsD29tr2sMON3qKouF2d5COx25Pf1T3Fxmxh1WXQlFq8ehcLmpWiyXr9Qmr5SrPje3x+X/45O+7AV10ErB8pHeehMJ5AfgPSTNrZjyr5zS/eS10hQS2KCmLEmOFmO0VohKFzAwfr/Z7hR2NtEfLqqQoS7wP+UxS3i/kw6cJbBOzwo9CF3LWEaFBSTdJBDnCA5ENpTXPzs95kj+UUbjgiXqC8ytMEsGFcRw57PcifFAVKMT7tPcDQQd0pXH7ln7QtIeNXJl3dIcDv/n1b9jcbVE+stlscMERVUA5CK0Xek+pWTQrlsWSVbNm7Bw69iSt0aOmSCWFranqhE6axWJO3dRoW7Lvenb79tG7WFjLYr7g2bNn/PSnP2W32/H1t9+yPxxYLJY8Ozvj8y++x/e++B6/+Oor7u7ueH95weXVDQkYRk9ZNdSzOW9ev+Xp02f84R/W1HVNU/fMmorNtmcYWgYnqjulUSzqklndkKIkWN1hJ9Sj6Ekx0Hd7CA78iCJSFRqfFHVTM58vWC3nlGVB3/eQIkP/b8RU934WCOS2WiQlffy+/DtVZhKg7jsLEXGAiIT2lrC7o3v9DXe3LdvWcZs0UZVQzphpSygOlCFi2IikjhGVAGltTv18jq/Dcak/OF/uG06PZ4bHJ5uyEm+qFAMxJLQRt/bJC6/tRcUjeI+PIbfUBmkBZvd4hbSUiqIQJKWx3Ldp0jEQGm3yzOw+CKqkiE5kz9wojhZD3zO2LcE5xr6Tlkbf44LnanfHNzfvGMcOdMwFtvqwC5UvT2G0VDeFFf+7kOWtQrBiAGtsDuIyjyqKQuDsuUUZYjgmODHdO3aU1mZllYgfHCqErJpP9mnLnKUYxR0+t85tUaCqCluWQqxOZEsoIbAXbUtRRWxdH//+w/1uUlaJfpQgSKQbDhRaY1XKru/iOdcPAlgojM3c1XhstRljmM0W1DMhzCdECqvr9rTdgbY7UDUVzWxG1cwEgZmcBMGUcutOnLIhonSZ5ZvF0DMlRXJBKq2kGbxoz3oGEfV7EARBhKanQChqPgGlNcPocEPHrCplnpVg33X03nG73TIET1Ia5zx3my3ffvuGX/32G5bzko9frFgtpHW/WEWiH3FjJ+ssCPF5e2g5tC3brsfHkDVhY/YEFfNbhcbogqasqYuS89Wa9WrNyckJ84VUgNroY+vvftOAYXR0QzbTjQnnpQUrikuJzifmTcl6PhMkcv5VbSy2KKV1NqEfH/3t+2HL1EoWwqBUrmVGOzsvc/qURCpw+tkY5PkLMWCUJip1tHFDq9xOE0RtSFESoOnclOL89JTzszPOTk/z9UQmIzytDKUpsy8oeOcolKaY1TLrjYExjqL0Ukob0fmBrttTWUvwnqHveP/uPTc3G0plxBwgBBEg8YrYB1KdwBiaas6smFOXM4bDSBxAWUtyoKOlsBWpTGjEbaSspFPV9i1t90C5SAnYpqo0q9WKGCNt2/Lu3XsOh5blYsGimfHxy1d8/OoVuix5/foNVzc3HA4do5dWZVVVVHXN1eUVtzd3hCDIYWMMVVWgVCJ6zzgmuoNmawzL5oSyKASkZy3WaIwqSFFUYQTHIEn1rBFN3JgM88Wa5eqM1WpJVYo5Q/CRYfirxSg+PH53YEz6S2D4GQTz0F8wpUx2Z1IqgRShcgfY3xEu37L77c/pdxvuNnu+sZ9xZZ+xqU9YLyNPTz39eMrQDeztmuebX7Byd8wWS+r1iupkmbtk+TX47jzy4fHwexIYH2R0wPmzJ5w+eYIbe6IPKKUpZwVDGLjZXtMP+zw0V+IHqKXt4ZHqK7h7r0RRQJ/sj6bq2R8H7+JmIRv5OHpBZ3pxXY8uMHQ9bhhEwm3sRXzZOXzbEwaHKQui1aRS8eKzjwTQYS1NVeGdk7bV/cWilaIqSuqypixL3ChVdAhRqjVrZZOva+qmYTabyYamNdoWdE1PVZX0fX+UW7O5XTg5f0REYUNFMCQqY+QBTNKaizGirWaCMesUhWhcCJDCOXEdmLa3cRhISmHrWmgK4wOBXwWVAR1H9vtbbq9bEUn/5mtMbiXOm4arzQGHPTqQZw0XFFBUViq8uqaq5xTFjOCFrJui5vZuy9XtHdd3O15+8gVVUTAOHpVGoRJ0PSppSlsxDhptNQlDWTYUdUldLwhI4nRzc4mpDPWyYL/pGYaeroembhj77Xda8yrP1KSqqjk5ORGJq92e0Xnm8znr9SlnswbnHb9++5biX/yEN2/f89mrF7x7+57f/PZrfvbr37Ce16wKi3IJvx9ZnzzjbL3gh9//jD/7l/+Kd+9veP32DdebHd3o6N2YZZsURgmB3BotjuZ1w9Mnz3n29Anr5Yr1Ysl8Nmc+n2FKqYS993RdRwqPUeCy3hJGK7wTvc7VcobVCudGvnl/C4jpsPcp/6xY5Wgr5rsTzYKceD+UPlTKZLUaqepE4L6gns8o6pLt/pDn5VAUxTE5m0YnMcU80wbdqqO60pGLpgX41HbdMfBqY/jxj37M2dmpbNpFeZy1V0WFnin+4Mvvcbffc7vdEUcHMaJVZO/29G5k1A5TWeq6RpeK0Y9c3dxgszh9N450PqLanhIroJDoSDUYo3GbQKEjRVSc1ufYYBh2I7+++I0EsqaR99MlVvMFvqoI3qNVIobA7c0NfXtgv9s93j8fjGzaruPq5prLq0tevnzFer3m7es3nJ2c8PzpM7748kuev3jOP372j/nm9WveXbwXHnFVMZ/NePfmDf+6rGiqhtliTVKGWVlzslgSRk3VSTu63R94/U0PRP6Tf/SP6doDzg2kIK3QGAXFqpXK61JEOpQpaWZLqmYOusKHxOBGtnc3bG4vgL86Ljw8fi+e4GNwTBQ1FP1d0Mz9CG5Si0m4zTXp+h3hm1+RLt8Sh5EhNAxlg6sWnD874XQVeHYycnkxMIwa7IgzFTGVUDWossKUZZ5/Z2WHB+3O+1NN3/nag8t4dJR1Sd3UGAspBEChCy1K/37MlkYJpZFWBBPQRoKa92K1FEM8znSsEcUbObOAVCDTg0fme4X8vZClzQTwo4yoLWgPMXiMMxSVJflA1cxRlSVVBd7kW6ykhTG03XdBCTlIGiPVqijsAEpTlZWgQsvySPY1mRYh/l0mSxvJ3ui8x7lRKj2FSKbla1RGS1CtCkxVUpQFthANUFIiOhHHVTGA9yQv3MapO1U3NUkrUtZrTFFk3EJIGWp+f183t5eo1LHd3uCDI5Eoy4aqbqiqhsGW9C7QDS4LEEuFN3lXxuDEbT63UaqqwblEShptJEDOFgtWp2ecPX2OioF+v2W/3dF1HYd9e2z7/OKXv6WsLUkJrNvagma24uT8lGbeUFYr6jQyppFFAFsklPJoFYQL+8G9urccM+hCsV6tuWlm3NmStndEetB7TFkQomdwnoura5nxHoTTdXF1lYEzkYurDZeXd1RVzdOrK1EOOVlydrJis93jRklyTFlShRptpBKqCqHFFNYyny1omhlPzp9yslozaxrqQpDRZVGBlkAiMUrf64MeLwxEyUT2A62gLguIEWc1+65nc+jYth0uA3XmixnWyhxP3OjTsbswVWcxKzHdB1xJdgpraWYNVVNhywIX/H0TNOpjN+vY2UoJowTBrLLWblIwaSEr5VFG3NDvL0mxWMxZzOYYkwNl3hiMko/z01PKqqaqG1zmm3bdnugREWydwErXxJQGlyazWcE2hIRECDgiH0BhVSEfoUA7g+p1NotWRBcZe0dCUL7eR6IXRO4RJGdNTo4LzHwmfNsHdDatNeM4st/viZnucHt7Q0yJzWbDvG6yIpE8l/P5nMVqeRSo10qxXCw4PzsjhcTN1TV//pM/Y3ARF6B3cLcd2LceF0omabS6lJa0MerYbbEmd5CS8FFJieCTrKOoIHq6m1t8vGG/7xl9YBw9+/2W25u339nr/6rjf3c7VGwfsjboB98TT6xpIUn2Nly9I775NeGX/wr6FqUqhuUzXLmC2ZpPPznlfBU4Xwy8v9nRofF6ZLQ1QVXEqoGqRhdVlmDKr6fUo03yYQD8MBjKzX5M+CmqgnJWosd4n+kpRVSRMYo2pdIyyzxWuBPRNEbiMBxbm9ZY8SHUojghbbcc+OIUPGVBWyvi0cqonOkaaBRFLKh8JeaiKRKdAy+zw8XyBFOV6LrEZW1Q78Uz8bDdPW4XIeChsizlb6NlASEbXdMIJaKu62MQnFy0i7KgVNKWMFqy5GEY2GflfK2gqCT7VVqRCuEC6rKgbGoRxLaGGENuXWa7l+AhBJJ3xypIGS2OE1WFHUf2bSuqO7ll58Z7lfuUEhfvXtPtKra7W7SRtmZdz1HrMwojgJlu8GwPAy5Ia290TgAv1jD2KbdCZ6yWa5p6Lt5zSaG1ZTZbcHp6jkLz7OVL+v2e/e0tm5sb9vs9m81W8J/G8i/+5b+WSlBnJztT0MzX/Ohv/BEff/oxp+szsANBdWBhGAKlHWnbFnis3j/ZjwGix6ot56dnXF1eUld3XLV3jF7mKPPVAhSMPvDu8orr61uu31/Q9z1t25LKGh/h3eUtz95dYYzm7PVrzp895fx0xdOnZ1zf3hH9yGp9hikqAhlMYizz2Zwiu2mcnZ4za+acnp5lqzIhYVtr0UoLGCgngZIwPQ6CQh2dOjBS0c2qAms0oyt483bD7W7P9WbP6APaGNbzuSQwMQrtIE1YhAmhOrX/p38fBLTCMl8vqeYzTFWIbFieJ+pkmHQ3J0UpuQfHh1OSV63yM56pXtHg/GP+43w2YzZrHu6Q8r2oRfTi9Iz5fGS5WtG3HW275/3VSOrBEYThb0EZMJXBhyidGico2pAHsgqZz4qQgnQgClNSpRo7ZoFpjcj2eXCDxwfPGEbcGETL1ucRgNYUTYPNsntGz8So/OGeYS2ubbm9uxX9W++5uLxks93S1A2fffwp4+hoDwdubm9ZLpe8/OgVIQbZi7RhvV7z6tUrNjc3XF/d8Pbte379m2/Ytz2BAp8KYiqwxQqtC4wpqEpJUsuqoCoLSmtZLOpjYCyLPE/1HsgcZW24ur7h6kZew/tACAkXBpzb8+gB+2uO31s2DXgUgOBxkJGUaGofKnk4nMe9/RYu36H6LSYmClNQEpnriCkTX758ScRx1+35ZjfS7UfOvZM2hbV05YwQoN8fWMxLIQCnXJE9OIfpfD4MgMcq9Tt+ZwEfA56sOIDM+bRWOZjLk5LI/nlEUsqZVQyENEpwTAmCJ0aDVkJ7kJQyazSh7ivBmI7fsxl/BprKyIJWVgn5OiaiDflHNc16KURRW2Cmqk7KYlLSj4OgmhDrOgcTz+QVWGYUaFVVpJQYBhEjduOI8z4DNBppH1pLWRQ5C8uAFAQcVdYVRVNjZ5V4+inZBLVSFMaK/2JK4ATwk7yTTS3raCYlxNeyLKhiYhbFzHRwDtcPKG2PLmLTPXzz9hvOTpZUVcF8Jty4xWLNYnVKUTX88T//U375q9/wL/7ln9MfWulgkKiTOFj4KI4BIrWlCNGz2d6y297RHvYkP7CcN8zrirpqGPYHur7j5u6O7XbLzWbH6fkTTs6f8oMf/6FUHIXCOU+MCR80i+UZhV3SVCdoNZBiiS0CoUmcLCNDP8fqMVtAySEmpp5xGGjbVgjQCZ4/eU5ZNFRv3tF1LV0nXL8syU6fIopE33cs5nPOX7zA2Ao3jry5uWHx7oohJk7PVwTnODvv+PzjF8ybGU+fvODk6XNMWdG1fRb7FnJ9yBJuRVljbUFVWLk+L1VAiPIsaJsBKcfENDxag2VhKUpBu2olXnhD8LT7PYeuRxclnY+8vbnDA7PlnE++/yWHrqftOr79zSEnUz6v9xxMc+Wc0kSLEBBLWVecPjmjntcCWiPlBIPsAgPKqKNQgzrWiYhIxANqxtQuzQ/Yo33DaEEmo3Iyq5C9JeY5+ISUVYpSKTSRu7rCVFaCcRnAQtKJkydrdCqozRwdLDFAN/T5XEQgXqSmZUxBvpZx6PHtyOX1FcEHgosyE0uRgMvXqKhMxbNnT3n27CmffPSRIFurguA9r9+84Z/+D/89k8DJcrnMYtmJvu8ZxxGtND/60Y/54osv+Lf/1v+Bzd2Wy/cX3NzcsDsc4N37PDOPPHv2nNVyjTElwUdO16d8/uUXfPHFD7jdbPnFr37L7aZldxjxQ4uAGgz98TYIor20ls8//4RPPv6YTz/9hLospT2f1a1Er7jit19/zdfffENd13gv7is+RPbba/789pf8LoHw926HTptR/tIRGTr9O2VkomWnyf0oGHpwAypvoiZFqtBThT3R7xnbA6MPbA8DqR+wY8/MHbB4lAZvCkBDkApIZ8GfRHoUAB+f34fnfE/kJz9PMT6oYPOim9qt0oFIDx6CdLxJU59QGVAxg4DyBhv8A2WaKEAJqYg5BkGVsxml7udhBhnKKxQ6Sf4c0OIbaTIVwk4/Iw+GUZIMGHvv4/bhexGiSLalUUjcsZAW6SSeHUI4vk8h5OotB2GVNy+jFNbobFt1rwo0LUZM9gdzIScEGZ0SpAWK96RR5ORitguafp/c7zdaFnnIgtPyNcWDOJh5RVZmmPMFdZacqqr6+B5Ya1gs5pwsVxijqcuSxazBWk0YBowxhBDY7bfsdhtQQtht9zuGrpVOrdJs7m7ZbDcM4yAehClR1DXLkxPOnz3j6YvnVHUh69ON+XIVZVUQo6c9HBjdyNh3x+CbIhgdKczjDDwGyaSdy+LXxqJioqka0trQjpG23bPfl3T9ARccfQh4N5JioEuRejbLPDQRBD84x/XuQFFabq7vxNjZKFQKrOYNX3z6McvzJyhj2dxu6dqBcRAARojgTcr0gXtAUgh5TJCnraUqjojxI/jrwWGsxlote0KClOd33juGocfWc2JKbA8HkoKqqjg5PaFseqq2Ynd3y9DLrDwEIdNPfE6lFH0vvog+A26KsmA2nx2lAVUOjhMPkJwYTo4pZhJrTwlPEpWi7HByTJzz2n94aKWOaNPJE1WwCqKipLXMrwpjULY4AnWstZjCkDJ2LqZwpG/EKLJ3Bk1ZVPL38u4xbUMqtwdJiTj6LN8YRJzDx6P2KEbQsEYrysKyXi54/vQJz56cU1UlhTEE79jttsdrUkq0hK0xGbcwMjqH0ornz5/z/R/8gH/rb/5Nbq5veb0+4Ze//AVd19F2nciYKcVstmCxWLJaLrm9LCiKklkz4+wsoW3B5dUdPmhS6vHeIoKSIo59hDimSFkYloslT87P+eiVBO6ikITc2KwmYzWH9sBuv2e1Wsq5ohhHz9j/5fvhX3b8XsCYo+rKJIGm7hUdYlYamcibSkFQQXiqwWO9l00xk9xNcJwP7xgOhpgGfvpnBh8Mro+c7DfU45ZX/WuW5oCx0JUNSReoKNn8tCQnMm+uuR5Vp98NhunRUB1S3vCl/2+swSi5FfK1KIFOpfwxgRcMeeVjTQkhEn1g7EeBRYeQOYAQvSKlbAYp8BDkwZHBu+hwynxMZfQaZCcFLa1X6bUpokqoJALUU0tAa5O9+bIb9vHS0jHAey+6mUMKAvXOD/k0C3gIeJr+243jfWYfAwpxo09TjHMjMYowclGWYDQqRbwLRJ998fwoQW8YiU7+9W4QoXEC2ihsXTB0HVNeXlc1Ck2KvSAEjT1elVKKpy+e8+LZOU09Y7laC1ezaDLCU/Pl559xfnrO5599wWw2pywK6qpEERn6nv/X//A/4ryoUfzylz+jHfZ8/vlnXLx9ze7ujm63Q2lBIv/iF79i6DqSHwkkiqbm5ekTvvfDP+DzL77H93/4PZRODK7Nz4SmLBup2Porrt/tBdgUPFFLcysiCj1u3D+qLiZ7p7ZtBUVnC0o0s6phPluxOHnCOA703Z6bm0t27Z73Nzfsdlv6ITCEwBgjAdA+4EJgFwLfXN+w71ueL2v82OG6LYcxslyf8+Mffo+imTH6gN/v8dGLSMDhIDPhoiIgFBfnPT7I/HsYpYo1xrBM8yOq1WhN09THa1JAkSvBMIkfBNGddONA1+558uQpQ9fz/vqGlIXXnz17go+R0XvmdcV+t2O/3TH0PdoYmqZhvV4Dim++ec3t7R277V5MZGcNZ2enzGaNmCCnJKhCRTYp0A8oXorS2KPt0KENlNbITHSyPkQ25r6pHydjanIx4HGVmDsw2mgsCF1DySy6KUvqqqJRDaEUjdthGOjbEdcF+v17ZuWa0lZURY2o2kT8OGRtUo/RpXge2oK+PzC6nuAimXaMyhZPs6qhMAZrDafLFZ9+9Ioffvkl69Uyu3N4YqxEm/R46iI3Z4sCHwLb/Z794YA2hu//4Af8vb/39/hP/9N/Qrtvuby45J/+03/Kb37zG/78z/+cvpfk8ovPP+ejlx/x8ccfc3d1Kwj7tqMsS9arJS9fvKBpVuwPAyFakhKHHJv1XI0SEF1ZWn74/e/z/e9/jz/44Q9ZzOcUhYxZfPB47zm0e27v7ri7u+P87IS2ben6TtSMwr8J7dD4kCeYN+qkH1EmiCJuO/HlY8oCSApcBltYpbAY2TCC40l7ydwd6HVH0CURS9FuqcYDq+EaFpZYzBisVILWS5smRmkH+eBJJKw2kkWpTNngcSCczvPRTBBk6JomiLXM/qS7mX0Kdbb9VQFjRRAYna1LiEfBXLSgtiKJ5POKPFaaeb6b26IyS7MoZYiIh1TSgjqbLIXIgr6qAG01xoqj/fTMpemJm1qixycyL+ipXRRlmOycGOBOeq/jMKKUwnt/zFDLspRqNgTGlHl1KYpbR27zHGEIUQL/sUWqpMIOYw56/Si2R9GThlFmgc5JMEyBONmhaKFh3MvyCXJ0lm1VysEzXZhSiqdPnvP8+VPquhKCv7YYZdFGSNE/+sGXhBhxIWJKaZuURUHKgX29muWuheGjzz9muVqyWs4wL59yspqxubmWSjRGvveDTyEpyrLKMyFFPZtzevaE9cma4Ft8GOmHA+M45JafIXoR9O72Owlc/cDoM1CHhDUFt3ePUXmi3KLuW/tKiRydLiQgaUNTFSxnFbOmou97VqtTNpsNfd+ijKYqS5q6orQFRdngkmZze831XcvPvn7PGCQ4LpcrxmFgc3eD2m+QHFBx6Aeu7zYc+oGyrpkVVU7OVG5xG6JWxGiPc7YJ36RRFFVFUzf3y1BBaQtKW+CiR6ExKRFnM8qpzVrJtRzajrPzM05OT1gs5wzeU4TA7IvP8E4cW8ZxlDZ8RhwO48hmu2e/b0kpMWtq1qslT5+c0TS16E8+5C0ajjQIaX2C1SJGjoZZXVIVFXVRYfXkIhFx3mGPTuc82EcejoGma84gNw0qCV8QnSiMmCTXZUmfSgYNfmw57PYkN41IAsPQ4gfHqMc8S42EMOb9KGDN1PJzjK7PUm3QNHPm8yXL5TLL2FmRm9Sas/WS9XKJzXqi5PuptWht3p87UggYkTAcslqLMYZfffUrqv9nxTffvib4yNiPvH33lpubG/px5Ob2Bq00n3/2Gc6JC01RiaLQm7fvmM0XdH3Pv/6Lf03bOsYxUDcnxCwUkjKVrCxK6TwZzfbumq9+9XP+P//b/yIjGRIxeUY3HtHIm82GzXbL5dWVJGlJCqSu2x7vz/+v43cKgh8GlNxZ/G5lyIQQPa4U+V2lcIUIVSdjREYJsNEzd3uq0NFtPLGoSEXFbNhh3UDl93TqBGcKRm0xSWXItQQOn5Jo36VEtIkCgTNr1F9yzg/+Pb43EgCZgmC6b4OmY+8yf20KjjpBuJcGm7RIFVM7VTa6B9MectP2OMNLWedSehzm3m9tatcceX8KFTXGCupONh25toh6pG7/ASbm2NqVzmTAu8DYO2k5lpZ+GGTRZ6qDUqIENLW9hGshM44Y4/GhP75OzO1fL0ICSglUPnpPGB2+60nRE1NAOyddAB8E8EMEo46SZShNTGJKq7Obg8YQEaDOg7vFcrVifXJKVRe5mlbolDU3tWV5vhZ0qzXyGhnmL6LGnroqcytXU84qyqKgaSoKvWY+qzFaNj0fPPVshrUlzXwpm73Wgooshct3aLfZ8cQR/UAMQcyEczs4ho7gB7zrGfqOEAMhCnig3R+O4KCHz9nR0y5lU2KtcutHOIlKFRTWMNYzrK1oypph6DOwSdZBYQuqKqBsRbdvOQyOd9c76qqgLA22qMG0JHWNj4GYNEk17LuOfT/gY8RMIJG8jnQGYGgMwcbjJE0QwrIKrZbK4z5YyP2z1gjBMSWijdmey6KtzRqcidE56lnDfDGnqgqSVphoaJa19E+SiDtrpXLSVtIeOqq6Prb1q6pkNmtYLxfZAFtlPd/8yJv75yrrs6EzcjUhqNWyKKhsidFCyA8xQIofaNgyZbW5IyTdouO+96A9qpN8bpQWjq21WG9wyhBCZBxGLDmpMMIt9XHar+SZC2kyzJZ1m1J4MCeVSl1c5FecnZ5ibf57KWK15vRkTVOLAEOMoo+sJpWpD8F0Wh+1aJtZQ1VXKKW4uLxEqZ/y9TevM29T7lvXdQzjSNt2WQA75iJF2tPOe5GUQ9F1PVdXV7TdiHOJkxNDiALwGr0k5VVZYnICf335jjevK5q6zqpFgdEPODfifWAcB3wQmlnf9/I+W0tTVzg38rsev0c7ND4Idjrr790rxYQQ0LmtJ2tDiaizkgpQPXnJmEZ27QXzoacMgXmAKgaqoFh3A8kbojfEzgsxGM1QzOirFQM1BAX9SGE7Cawp4aNUgsZrKmspjXxMN3eCQ0+V4HesXrJIsz6SqfPXp7aGzoEkpewankjJyc+qRMpqLSSZ6zDJMGmZGJhsABpztZOfCcCL7ZBK6CRZo/aiz2e1ZmK3qZQwMc8g8sBy8mA8cheNprSGh8s5ASEm0ujp9l0mkPbE3Ep4/+49s7lwA9frdYZGD6QUMN5k4vIDEr4idwBEF1MroT6MbYvdl+iJMN12uK7HHw4CIEqyoeqUhNefHcijgcIYjC1QyjIOI13XM6n6RC/0E/WBU/nZ2TnPnj2jqoRQPikBWVtS2IKmnmWbFQ1GUHUmz5OV0jx5+pTJ0X4yGA659Z1S5PmLZwKASgGtS4ytKKqlvO8pMnYHeQjdSFNpQnB4v5K2lHfCc/SO4D2VUUfx365rca6n67akBK6/T5Qm0rbzjn4c0K2W1pcyVEVJUYh339SON0rTVDVN1fD87AlAnqWGY4KojBjgLuoZb9++5de/+Yp2eM+7yztudgGtFcMwcnFxgQ+J8xcfU2fO1bNnzzNVxshcOAc5Y+x9yyoHv7qqj4mUdw43OB70KahsyaysSSTcIGLcvhC5PlOWIkQRHSFFzs5XnJ2vpFukM8CqFOPbwmhCdkoRUIxmdJJEBcThfrmccXqy4Mn5Emse+gum46gmxInTKwmHj3K+RmnqqqEwBVYXR29LrRR1UdKU1Xeer4dJwsOviyGwIakIk22X1jRVQ20qSjoOY480gRR1XWGw6JnFHRLRQRwn2zAPKRyT45gmgJAGAlpDWZacnCx49uwcayzee3Z3G1bLBXVdcX56Sl2WBDdiVJEdbMzxbz48jLV8+tln/JN/8k84HA78/Oc/50/+5E949+4d3377Lc55tBY6EClhrWXWNDjvKYuCzXYLSrFYLGi7ns12x93mDowA9OaLGZvdjrvNjqqekZKo7VxeX4gzTMoz1hxIdA7UMYZcjMRj40u6apPUnaGuaxaNoHb7/v/fsmnpflb0GATzWDJtQoyqXOWkSS4LhV6focMA/Z7u6i1+aNGppy4shTYUVonLQhrxslvijcUVFaNtSKYmKotPicH7+0owvzkmBuH52BxU1IQeu6dvTJvNwzJ5yp4TUxDMm1M250o52OXZdQaS5MqQB/8+qDqlrSXoTaXJShZyX6fqRdrEQpFQD6rKI40jI8KMkQd+QpOqnIUpJR4l0/nzeC0f7YiSB9eP4hiBIoyBgZ67uw0hRsqyuv+dGEhJHg6d4fAmg2FSikJ1yJm1yaIIYRxw+4PIpmmN7zvCKEFCFqwM9pPORH5ljskFSqONgiyKHbI+ZQyREEc8Ps+SprdPHCGszco81kpLxxTYoqKwBWXZHC1YJgdqraYqSmUup1RXIZQSBH2YhjuEWBGjl4xZFyhdoM09GdokBPlqC5wtCMHh3EhZWELw+LzZBOcIPmCM8C6NVoyjIcWREPx3+HQpr09ZPvcZ+lQJlmWRqRN5thwT3t8Duqqq4tiJQVrrZVXy/S++5Pz0jLKw9Ictw9DyzbtbuR4SFAuqxqJtnVvKWuZ7mTLjvZfXyrKBR06ZytPrUWcLKKm8vPeP6tuyKKjLCkVijJHBew5err8qK2Z1zaGsKI3lyfqEp+tTVnVD5QIxwawR3U1rpKpIR0UbmUmabAZtsu1XXZXURXGvDpPPVZ4JaW/G3OpMKaICmCxuUdpSgqCxeC86pCkHwqp8DLSYCsFjlck0GlTTlnn8XkhibG20pVCWUhXi+lDWhPkSm7sZRhlUIebUIaO/Y0wYVNY7zc99fhZU9tsry4IUPd1hK2OFEBiHAVdZXGkkaSutzOAojh0Hxb3E5PEZU4rZbMbLly/5+3//7/P555/z/PlzvvrqK96/v+Dt2/fHbtxRMCOPWEye4Y/9wOZuw+HQcrvZ8ObtW/btAZSSDhRkI+2csOkkfoLSvjvyj01uQStA6zI3h30Ww5fWaVZ4yKqMKleJ5XeFXf6a4/eYCcZHgXBSP0F/EAiDyGyJvYnM1JJSqNWZVFdBlFHGmNCux1YFVSXw1+QHghvAFiSlibZkLGoG24BtiMoSQIIg5AwwD4+RAJhixOS5m/4gCMr5PX5zJIBM0O7IxGnSKeZAOPGDJpcE8D4jREkCaskP1BRA0xTI8g2dguVEIZnmPzBxksjUjRz8YsSo+w1QCKUCrlFKZ+AGOdjmzfKD+xXJJqwu4PsRHSVjDFl54u5ug9KKk5P1sY0j4KY847VSpRXZtzFGT1AyC1FJHKy9FwPakcxtM4bQ9yIxFxw5ThOPbV6pkJlABVpExrWFlH3pJoJudF5kxtLjyn0ipYvqjGx+dSOtQflelYEDVuYyPEgexAX1OM9KNnc4cvUEkJKTDDx6FEVuXdu8vhMWRTCWGBy+KIQyYAuCL0TVw5eSGIwDQ+9kZmksZWEoCo33HePYfwdtKPNzuRFaS3t3uv8mBzRrBR5OEiWWoR/yGhatzIdr3hhL3dQsFgv6YaAwmt9+8zWvX3/L68st2hjquuLly5fMZ3NpCVuRbqvr+pjspiiKQN67R0nesd1OFklH9HIfkspRirqUKsoosD6gtCP6QGEsTV0zb2Ycshzb05NTnp2csm5mDFYcGebNXJIWpXDa4WMQ/0hF1u4VrVljC6q6oq4qKlvcCznAEbk4zYyinhJi2cBUIddjlfAkTQZjPSSQV8VjZ/mJbhUfjAimMZH8372a1eTYYoyl1CWVKrEYmqLBaIUbO4gqB0GNQQQeYhAvygmtOiUm5K6Qzl8vioIUPPvdhnEcZd/RGudK/GgZhl5oSJUkvIk8g1R8ABSUY+IQ/92/+3fZbDZ89tln/PEf/zE//dnP6AfH/nCga/uchBpJuvL5WWPp+57rq2v2h5a7uw2v37zh+vZakpZM8SjLgpREoUsbKEsRqyAn6yrPoCej47KsSCrh05CTaE1Tz4VTGRLBSadtHHrquv4u9uOvOX5v2bSHaFDZsPNG94BjQ86+nAKSy58bfLkmnRWoUBB3N9xefkVqLKkpOXn5EePuiv7qW0y5BFXQRcu4fIKfnWCLRmxVSKIsgXCEpmxNkUT1PiZGVK5izKO55ZEOcL+UBaQRJ4pAruxSIGStU51ERSbleWQMMXPCgrT7CMeAWGTkmTaSDKQ8pJ3ClHrwmihp18jMQb4fkSBDiGDisQ0VMxCoSFFQZ4ocFFX+4zpr7N0fk71RTJEwjPiQKJUFI0nDYbc/IvmMyUofamrnCK1Cxen80wfvmVRP4zCKzFvXiiWTfsxVPM6THjy85J9RWos2pLH0g0Nrg7YF0bncQVBZ0/TxdUkwk79X5NmcAEjssQUtWfP0exIExZzT5Hsl74FCFEy0FjGBlIOLteLPplUl9z0DpUiiHGSsJmqL1QmvQKWAi1kU2o3ZUSJQ1zOMcRg3EiMYE0lhQdcim6q6f5+KQgTYF4sFJ+sTZk3Derli1szzHLI8rmPvPSYkTFEcq1pBZ2bVnxzwtdH4GDBa89lnn1HPZpw/eUrbdVhjmc1nfPGFeMIRPYUVL8vlciVUiHFku90xDAMtnSQnMR6ViGz2orRFQV1VgKI+7B5MBKGpSuZVhY6R+XzBAcVbpTk7PWN9ds5qvcT3I7frE07Xp6xXK2ZVhTVeqFAyizjO2VVKhODASrXXzBYs1mvWfc/Z2RmL2Vz2glHamUbr7PU4geMeVNlJkOyFEdh9aSdZtUlsO6/4/Nw/2g9zNfRw39M6awLn5/oIxpObLK3Deobznpt2S8KiTUVSuXpOSqRrsoMF5HGNsRhrKDItZCK+23wPinzeMXqsESGHuqooywKlFX3fi+3ZRNEwhmgEl+A+8EmMaapCE2VV8eTpE/7u2d/lBz/8AVdX1/w//sf/iX/9Fz/lJ3/257z59jX9YS+dlJiYz2YM48C3r1/z7bev2fUD3TgyesfmYkNKifliwXp9ysnpKWBzoqdYrsTCLMV0HP0YZaYtB6PFzcOngdGPjOPA1cU7kZ90gRTzGCVF/uBHP8AY+OWvfnKfuP01x+8YBB/Loh2DYZQI+OHrSLkN6LzokPlUQBNMRWxOiRiC63FlYqwMfrZmHHt6U1I1K7yucLEk1gsoG2lvTecyLayU8gvlE8jZmfD1uG/dcI8O/dBUN0NW7v87Sbl3j/68/3rw6QHhPQphOPn72eGD7P44gEdaqepBgJHv5OuYstHjO/WgnZK/H7N/4qRPEO+ZJlJhoSaFpeMxWbuoPL9NMRKcY+LpC0pOHbPLx5zFewWOEAIqRpj88kK8lzXLyFAAFSNqkmjLrSqtOW7S0wxpqsiEA2jQ2mJMFNubB5uGsRYb7AfO8hwTg+kzJemszEpiQlmxS0pmqu4eX5ckL4GU3CN+KJliIpvavbnrfatLABKTqn0KgRREUFvlhEkE4uX7AqawwgcjMY7d8ZrtVGE/XIPpcTdhShqmezC6aX4ZxL08r2uDtPacd0QtfpX3GF6Zt/ggZq9NXXF2ciJGs9pQliWzppJWX9IUVtqaAqyQ98JYg/GyCUcSDx3Wk7rfNEcnyi7DMDxqh8aMNlZRCNB1UVLVErCTlg1c9CZLlBWQmA/T7E+SjwmPkJQSke8UZU0iguxlVVM3M5qmkTabz7NRpPsSQzyep1KTtNuEnI5oJYluUOG4kU6iGvfr4PEmN4HI9DHxy+MXWSyPnyl1X9HXVY3zjkoXQiXyCRW0BPpA3r8mJD4YLapPxsicfqrCHwbBsig56qEigV/UnszxPk4cT+/91LdF5Rnph2HivgJWKGUxpeHpk6c0zYy/9bf+lohwlxU/m83YbXfsdzv86IQO0bXMZ3Oqqia2B7wfGd0oI4Oy5ONPPuKLL77k+fOXhDwT1RrQeUyVEeKP/ydrOSEiAMM4sN1u+ed//L/g3ZZx7CHPB4ui4JNPP8J8wMP9647fqx06VVP3noF5nvWI+K2Og7YAiFntRNhOjAnC/BSqJapZ4+npVGBfzejNgR01oX6CK+b0ekasFqhC5gKolPvC0gOWaMBxsU6lzIf94EcB/ANXAqn+pMKY2j8S/EKW+uIY9CaU5FQxeB8I0WGMtOaOWaaS9iCIXqZK8r6Eh/Ax6bccpYaMtkcVk2M1NbVscpUXszrGMY5PlUQSTvp9MqIwSHtnMgpVMTF2PaoWiTOBUZfZ+SKjLB/MomKKInOWA6AQkXwmukcBOTgBgBxJ79y3ReRzqQSnTefDTUECoDnOoER31RzJusIXetyGkrdFTWNYUkr4sWcyWVbVDIwohZD/pjH3M1rvekIYCWE4BnC5/oKjBVim+dwrIEmbNEWRgIvek4LHuz4HrkhKIymOiOefdAGMzdwno3FOINtGK0pbUhb18fEmIcTkcRQgjfd4JzyyECJdL69z3MSQc3uY2etB3xO4pXQV9KF3uAy6KYuCJ2dr5vO5vG/Ogx8ZWi8qSao8zgHvqU8iNyeCCPpeTAF5/gbnIAdo50aub28e5KSJvuvo644CWCwW6LpmtV4TM1Lcd70kBU1NVIgoQRgoC5mBCiLQ4byT14+RMYpUYAyRoqppZgvmy5HFakVRlnS9OCNMLUOXhepdnmOV2e0lhMgwyHtsjMeHvB1OVRj3HYUPg+D0Ptyv5dzqz8Fomv1Pifj0c8vFAmMM8+tr/OBoD1520YC09Jwi+ETwAZWF5mdNk+euDzwNlToGurqqHr0WcGxN6ryveS/rqSgKorXYrJPq3WM3k+lvP/xbIUbqpqZpGv7j/+gf8jf+6A/59/+9f49//j//z7x/955vvvmG7WZD27ZcX19zcnbCx599zNXdlYDB2j0xRVbrc/7xP/pP+Af/4B/wh3/4Rzj3INnJEj7HMiLPQ1W+hxOWQ2no+57Xr1/z/u07fvWrX7Hd3gJQVXPOzk74O3/nb6MU/Nf/9YfWeX/58XvLpk2b5KTAIptyegAVzt3Q48/kH5u4cmQ6gC1QesWo5iQVuSLhyjO69WcM1SnR1rhiAUWNMWVO1BVKmWNFNXFn5I3UIl6rH9MjHrVDeZTIPri4+xafIBodMUjV40cQWoJC5OASSglkWpcFTIPqB6oPgXScY0znQow5CCrQYmQaU6Ifxty6NFR1TUpGNnRt8p/OVIIsgB0TogWobW55mRwsH95sgemracg8lY0p4p0gWhu1zJWYPmaKxtis7CEbaJL8Rsj5MRCDI3hHDIEw6YEiD5zOAeeIjJ1gtaRjgBJAhbwHKkR8ENRcVPeKKT4EnPf0fY9zPiM3Oa6jshJvMqXJwuByvSYjBgVwE6VlhsD/1TTLVIoQR6kaiXnAzvGeHtdszv5V9g2UdSRIV6VBmVwbhNx1yHJ6SkNZFVKl+4jGkJJGRWkfhpBRq3nNPTwkCTDHqjXxoHUfxW0jHttv8iy44NBjFljIcxKjNYWS+XUIgd6N2SJJkIRFYQlB1nc/9BQxA3dsc9zUJwWhmEEoUkWF7OWZq6xjtRCOm2aI6dFsUwA7JcYa/DhiCivanqslXQiMIWLLAlNY0Jqh6+nLgtomRu+OfzPkroRYFQnQqjAFqUzU1QxbVDJP0sK3jccpgYBHiCI96GMQNZcU0Unm5tqIH2jSmiGLbecNA6MNVU5u+ZAiIReYV9/9/jiNNj7ItI/7ZlEUNCnx4uwZBkUcPbf7bdbYTcQg978shD4i/o2LY7IzlR0pJWxOOKtyCoIZ6JJf2prHohghhKMk2jTA9P5xO3RSbgKyOUF6dCkpRtbrFU1d8+TslK7r2O12HNoD11fX/F//m/+Gw2HPn/zp/8br12+4vb0lBs8f/tGP+fGP/5D/4j//P/Ppp5/x9OnT41zyfoL6qOkzTdXkqykdpz8hBk7WJ/xX/5f/in/2z/4Zf/Inf4L3no8//ph/59/5d/k7f+ff5ubm5rv36684fucgeHtznWc+99XKsc2l8vCZaWaTr0bdw4dDTPiYGGI6tvcUYFTCqMid8vh+h9uPmHFHMgNj4cCUOSCY49+cNoZJZFoBhdGyKDI4QOWWnzyr08MJh/3hUUv07vr6eHNDbm+l5GQOEBN+4L73qDOoQss8CSUbX8rt00lsWqt4BCmo3FpJMWW7M3mgYt4w+n4Kgpqqkrmn0hN1IJPmJ4XRKK2ulNSDICj/HvaPydeHIItbHdvIuaWbEjEqOLSY7Zb55RXbtqMsbQaaiJyatuXxHhNC9lsUyHaKgejCURBAtFYFrVlkKyaVs+KJk3c8h4dPVF4oSU8cRWn1OefY7faE4LjZ3Dtfp5T45v/L3n/8WJbleZ7Y56grnjLpKsIjIjMiMytFZVV1VU1PFwhwujmiQU7XcMMN/wDOhgMQ4IrgllwQILkjOHsCXPWQGKBnesFFD7qb06JqSmRVpYiMyBDu4cK02RNXHcXFufe9Z+bmHhaZkdXVRB/A3c2f3Xflueenvr/v94vnPUoxveRCgiSsCYa1zvtovEfPSplYZ3pUqnPdup47nJTsnSv63qfhrU+SWEOtIaU4RV97CcHjurZvffFb+01M9t5HBPn6u8vlGbZrsHVN17Qcn15de151VbPMFmRaE3xImmx53r9Pgq6z6zSdGAA/4vqisTaCstdpDCkSdN4TCIzyIklI9e0UbduuF9eiHKVnqCR5XqR3JgRWdd0TLaQoNQky972vfVZoqPE6aznbWnxCCBwfH1OvKlzXYtvUAnNydk5lLZ3zKB+5vDhntVzw4sULqsUVhd4YDd9rBEYB6KQn6mMgMwXWC64uLlktrqirBednZwRb49oKgWCQEutcagtqWpvSir1mZozgXUxZm55Hdn1PfVgDkgSCk+Pj9dwNIfD86IiqZ7BJZOJbaHSGNSHdI+d7HdWhD9c5ruYLlosVq2XNcrFK0WoIif0pppyENgrt1VoJZjCCw7NRvcPZmK4vNfQOW2+4hvlQ1fVaMSbrsy5D/+3Rycn6eXnv+fDDDzk9PWV7bM/TIRDaNqwQe0c4AaPOL845PT3l6uoq9QhGT2YyjNHUdc3R0Uvm8yt+lVFV1Trtm2VprcqyjKLIOT8/52Trur5siDeFiyKhCICeEWadf7v2z1carzuagGTtt/Y7yCTdddxl60jfz9ePAa1If/y/MUO89j+3jwjb5MVf9o0hbbtOX9/tKH9tY20s+8V8GFoPC0E/7nTS1/zLr3AWG9P92nEztf6mrXuHrP/nevvH8Ay25vz2z4Mz96Vne/OdiRu342Zj9Bv386ajbf/ixq2NXKfhG1Ljt+13eNcHY7HdGnLXEftjDnW49Zz+mkckXgPH3HZdt3/vdb8Y5sHNROvtQ6z/2trxKx/eZR/Xt79Jm2jM3Tk3b47tVrTh/+tjD7XMG0C3X2XcPB5serRjX2ra2va1N+rORvDfjX83/t34d+PfjX83/m0cbzKCd06HSrXJLcNWrrb/eUjPDGCFjQ90y7G3vLXBG9r2UMT2v0O6dV2LfNXD6C9y/Z03RZsRkkZdP0aj0Rros46H7uBc/aq+5i/tXawDpOt7CCH0OnVpDCz7Q8/YunC/HcYPkcm6ftojXnsoeUJ2bmpVbxrbTuktFZH09xt2Mdz77VgqPevAarVcb2fykqFh+N/mEWPAthuS32I03aoX/hs6qfXYzsd8le+kedjWm+eV9alHIL3LpJLJdec7Xn+n1/W3FOG9KUFzM1W3fS7rXaxn1bU8EwzpfrYyRPF6yg+xqfVt99RNxgVrBqUBCJEAEiTkQV8TEpu3IQG6wpfc3njtXkV4Rf5tewzr7hBRbvrjxI1MwrAmXw8nfYg07SaDtBbLFkNPb1pjh1LYl60Dt9FUbgMKb/bvbbbbuiaRcBC6Z/4SW8/prsN7z3K5/PIN+QpG8Dd+99tko4y6qnqeRsV4lKNUYjWZTqZ9IdtzcXFB07YEUjOl2Gr0FCJBexMiMjUbp4L8BnGqRUIJjsqc0TinKDIOD2dY52g7y+KqJSTVybURq+qK9IBlz6aRZGmGmoVSKX/cth3/+B/+Y7ou1Qf+L/+n/zPvf/P9NRuHWNOoiTVx8BrVKDfo12tOALx2hV8/201hbmP41x9tJswmRdK/eFsCoNH3tc0Q131I3iVliJOTE/6L/83/mqqukFLyd/8nf0g5GrOqlvzwh3/Ao0ff4N13310bNCVU0kO0HfP5KcvVnBcvPuXzJx9xcvIcrTLu33uLd9/5Nt/51g8ZjSZ9HWFjpoYrkCIBU3LdN7hKgYvgAri+NqG1JMs1gzKSoGfDkYlaTkqFlgrnI9ZH6i7JLb18+Yz//H/1v6BpKpQ2/OF//n9gdvCQNfrq39KxOD/iv/6//+/xriPLS/63/9d/xP6Dx+mXX8EIxs2a+dqUaeT687plL9cWoY0xEWyAHq9ud9v3T59/wv/tf/c/x9kOYzT/y//sP2UynhKiIi/GZFnBbLqb5JFsR1ZIOltT1QuazqKNYW//IBE7x0DVN4DbzpLlBSHEHiSUQDvOJx1H7z1NtcLZFteTEUQibVfTNDVd1+EIiEwjioyurTBFxr13HhJzjQ2eLz76lPq8orls2L23hxkZ9CyjOq+p5g1PPkn4gcm44P/1X/4X3HvrbcTkIUoXECxx+QJXPyXaC5SZgCmJ2ZiYOYIXtCuFPbskNDV55pHGII3GRkskJJq1ziIi5EWGVBkRycXpcq2X6F3i4RUhorMMZTRSqZ65qOHy6owYQ6r/ZWOkMAkZamucbUDInoFHsWg6Pvnikv/jf/mvUx9yZvi7/9EfcHBwyP7ePR4+esxkPGF3Z8Z7776b+jDHU7QxaLVJmw4pbecci0XqK227FmtbFos5R8fPOT8/paqXXF6dJ85PZ5FC0XWWumr63uuEgN/fO2Bv/4A/+Dt/wHQ6Yzye8tbDt1Lf4x3T5T/60Y/4wz/8wzsxx9zNCAowmSLLFM6pngpKJTYYAj6CzhVSSKKNKKPQwRDERhXBmAGuLhmNxgneLU2anFuQbCEEuSkwWpMXGUVhyHNDPsqRXZIwatvUUwOg+xuTx6L3NHpIslIJGAG9V5H6bAbKp+FY+/v73Lt3b1N4Fmlxlj0AaAP+2fwZvnvbAxFrz09cX3TWZcdX8+W3eU+3/Ql+6NOM60Zd51wvgOqvnU9ejDBZTqjn6fp1Yt8vihFZnlMtl0Qv0BLatma1uqKqV1jXEWLAupa6XbFYXeCDJzM5e7sHRBIYKV1hsmiJFceDt9CjKBkK90Izmc7IM01eXDeCWifaNCk34BQfwIVI55L36F3LWnxWCEbTPSY7B69kD/5tG952m9MXgtneffYO3/qKZek3R0lbW90wgtcjgtujKbjWjHrzd9v73/q8rRZsnEPBqCyYjEYgDOV4h6IYsbd3j7ZtsLZFZ5G6WaI0mK7DmIzdnZ21Ecxk7NtHLMbkxN4Irue/92s+UE3AtoImBpRMPaE2hl7SKJ1fiJHoEh+n6Gn9lE7v+Gx3gnIC5SDLFCY3FGUJpSe0fu1oCKDQikIJgvAo0SJlB9ridMRHAQoiHu8ahPCIIBBeYRSQacpME0QkeLd+jiEKhO2jZZe+H0XS80wN9HHtIEfR0yz6DZm2d4EYEro8OEFQAaQjBNu3uIEQvRKkYM1rOwwhBLOdGaPxqH8vBUJEQrC0XUXb5ezszMhzQ1GMICay9vF4vG4hW61WvQ5hx6paIo8kL4+eU9UrlstE25eQ2hGtBTEqQq7J86yfN5rdvV0ODw547733mM12GI+nHB4cYnqmqLuMZ8+e3dlg3r1Fou+HSkrNSRmtrmtCSKwps50ZQsikUO3SDY8x9NK3Ai0jScdOM51kFFmOEoq2A2sFTVOT1BxgOksyK0rrxKwuoG5abOdo246uc70RFDhfM/Qn+r4pNsaB0WFDlqu1IjiPbdtrUdhtxi39+3qQwpePrQix/2EbnLDdarK5v/FGuvnVRUpIkZjVxOa8pZQ956i8FhmFEOlsx3xxzvnFC/I89RsdHN5Dql1evHhCcJZMCn720z/j9OwF5/NzlotL6npF51rm1RVn8yNms0OsdezNDghxYMvpEbhSgpI9u8gFdT2nsw2tbVGqwOiS9979JoocrRLkf2jZkFEjoiSpC/atiEhinyxXkrRobN/ZPpuwvhH/lo7tHsRfYS/cGt/dyPq9epjXHffrz8MOwIUBlZnnOaPpBF0YnC+AFhc7WMk1B+jA7yqiQGvTGx6JlIYg+tYdJEKERLvnEyG41Rpne1WKzuKcpVpViSTCe1wMWFqsiDjhcASWyyWZCEhjmM12UE6ivSAq0esNZgSTYY3duqbIyYsLug5afYExDoXFuDlts8C6Fi9rrAt01iE1hCCwrSATOUYoxrmmaipWdYVD4qPAOYG0HhmhGLFWnm9rkmCutXgRCCLiSdyaElK7VUiBQdv6tX9osgVSRXxwfe9hBJFaZZSEs3nFs6PVej0UQjAejQG4uLxASt1TWsLJ6XOm0ynf/tZ32dnZZTbdhSgZjyeUZQmktaAoCozJKHqCh7btePr0CT/7+U9YLC6J2DWbTVmMGCTUinyEUgalMkZlIvY/2D9gOp0xGk+QfWT/60j/3JlAu14ugMSkbqTBZJqDvQlET4gOW9VJ0qKyBB8Rqc98zR+ZZ4a8MIxGGQ/v7zEZjSgzkxrOvU8M4mIg481S3YBUi5Qikcc667HW0c3CmrYI0sMz2mBdgtiHHlaNGPLp6Y+UkbriGnP69VYPsalvsjGKNw3WNQPFV3ssr/Omtw3gzeNcEy7eqpGufy8EN8tkdVVRjEbMZgfM5xd0bcPRi2d861vf5Z13v8mHP/tTurZBCMHTF5+wXF2wrOYpMo8Ok2tCtMyX5/z8kz9jVV8xme6ws7NHUZQQBa1t6eqKpl7QNEuurk75yc9+xOn5Ma2tmYz32Z0doLVmb2+fndlO4kTt73BT2xRtpw/TPRAbyL1SCv9KL2/cODH/VkWD15/t9br51zzEa35en8fr7tlrjOqvMuLm/dNaJ5me2QRRS+hEnwLvGJUF1gak1AzsSDKC1nmixAoCKXTvgEuIySCIgU0mxNT6QIESEdsNkjuWaBLDT9t1KAJKRPYe7pNPS0b7E1SRJ4q+GVyJHBycnZ5RNQ3LVY1bNTSrbst3jjS2ImtyahkpC0FuJJPRAVGUhKbh7OyKrulo2wYXWoSU5PmYnQdvMR1NEV1N00WCb2hrh3MRa0NfRgrkre6jMUmMBm89trVYPJ6IJaCFRAmRKBr7FiwhNuWgULckpR9FDJIYBIMwAATmK0fVbNFI9inNSKRta84vTtBakRnJxcUxWmsuL+ccHtzn8PABmc7Z3dlFK83e3t6a9CLtKjAelUynY/b29njw4AGTyQhEajUKIWDbrg+WwEqX+oZ79RyTGYqyIC8SNaKSN1DhXzK+StDyFRhjksK4UimlpaVgZzLpU4eB87M53gVC5wCV5PeCR2mJ1JJiK7U5KjPG45xRlq0bgL3P1gTLA3NHpIe89gYxKIkzEp/FdSowXXAKy51TffQX11HK0DcTg0fIiBL2+hrxSrS3ZQxvAevcHDc/vzWS+5J7e9MAboN9rv8utcpGbkSwIr4yQWTfH5eRYW2XepMuLsjzDOc6Xjz/nK5riDGlQyGilcBJ1qTgQ4rj/OqYPC85vzolL0dkRZnEZLuGuq64uDiirpcslxccnb7g5PSI1jXM6hZrPVfLed/kPk7eqxhqrf1zUnKjoSh9D1hITfbe3S3l9/8P47oT9Msa9y8LA29Pg65/ew1oNnz/y9OgrxtDD+w6c6Fkn+FJPZxSJUFsLRXoQWy6Z15ZR4AKJSNqiAqFx/tIImKUibyhJ00XBHr+MYBEQOF82iaQ0p8KZjs75JMSU+QIY5IiA5CXBaPJmMvLK1zbUS8qaC3+BrOK1CA0yNiDRYREyAwhHYhA10Sa2tHUHY2tEw5ClZgspxiNcTGx9BgtaaAn5rB01uIJhC6u1z4p+yyWC1gS6UbXp0qDSP2OyQgGlGS95iUD01M99nSPm8ef+oXDDdCk9753qIc1wK9JuZVSVFVFO0ksO1VXo5VhPp8znU4TicUwf4ggAlLSP5cthRjn8N7RtXZtvG2XuKhDFBy2LaHv0xyYpIY+SNb/fn3jzkYw05rcmF6tOckVvXXvPjvTMeOy4Md/+TMu7JzWNwiZ5ENWTYMe5WQq0TVpI0B4ikJT5JrcCIiJVSNunUrsIzwlRM8EkvqyRZbIk2OPwgpBb9X3YFB6GFBcm+bVSIyeKDxXhX1FQ+v2tOfr7/Rt6cxbtnrjPr5sm2vL4ZBCvYGeHH43oNi2vsHBwQFFMeL0tAUHnW85PnnG559+hG0tRoe+mO353ne/y+HBQzwrTs9PuZzPqVZVYtdQitOzF/gQuPfkI8bTGcWo5OziBW1bUdcrPvz5j2jaCiECi+qSziXaqs62LKorjs9PQeeY0YxMZWiZ9OEYDHkcCBfAx9R8K4VEK6gbd/Nu9A/715Ma+fWN24zJ133+N+/J17H/X+2cszxLChe9HNV6rz0aWfikSKLpwXNKo1WGty3Rp+tRUiMzxWg0A0j8pLEX2VUy0bo5g+0kwaW5JYVAG4MssiTy3Fk8kjLTmFHB4b376CLDyQAycbTWXUdRjsjfymiblvnFnNMXZxjSere+AxImByW7uxNav4MQDknAdSGRSDiLa1uaqmExX7KolmRFQTneJcsMo3FOa2E8TnR9yaAHqsYhcIgY8B3YXkrI6HS/erK6VCrwIFXP8GJUiuDcwGUsyDKFlGMgUtdd/93Q0wH25BwaMr3VSwd0tkPpgjzP2T/YBSKXF6dkWUZZjLh3eJ+3336H9979gM8/e0LdJE3Kw8PDRIsnFSF2WNeyXF1S1Sk9fHx8wvHxCcvlMpXQYmAyGidCEpfo65zzdNZRFhP2dvdJhAfpXK/Px6/3vbkzMCYVuEukEhih0ELxxS8+56IcMS5K2osG0XhyIEqPFJEik2gZEKHD2QUhCHx0XF6e42yLHZWpoBsSKfMAyxUxsbirnuw22Zu+Ii36RTBuwarXBmkoHPeb3ogEo3A07SYHnr56HfQi1rvbQsi98r/10fqlLV5bKwY2il55+A2RzIZw95Zbfqv/vZ0KXdcvEddY7yFydnbEuFdEn032yLKMg70ZoWuwbc0vfvFzmtYSXOAbj7/B+9/8Bt94/y1evHzO8ckJP/nJzzi/uuD04oy2axKjx8tPefedbzCdTFguLjk5fcbR8VOeP/+MzrZEEhWXEIroI1JolDK0bUPb1ljbUuZF8gy3FCfWyFsBio2BixLCa9mqvtxZ+ZsyrqEt7ziGKf36udNDk25kCn7VcS26W78Hw8l8xZ0J1vymEbHx7IXAKE1QmnZxSb1YUl3OycfTXg1EEaUmAgqZWHl86Im9k7HsbFKnMcYg3QCuCkSjicZgjMY6h/AdvnN4a3E+4GKg6Swnp2dgJF4EytEIk2cIJQkkEoPxeIJrPEbOMfgtUsv+0pQnUGNbx2y2h1EZou1ovKNtKoiJslBrDUHjmsD8YsnR8y/o6iuiq6irJVW1oKoDdWOpexmyQXbAh/TzcN9DTNGRGEojIeB6xqJEVB56zmIIPiZGJSEQwvZLZs/wk7ZgKPxsP/vVcom1bcJzRAsRVss5h4f3KYoR7737Te7de8h4NGEgIx/3tG4xgveO+dUlZ+fHnJw94/nzZ5yeHvPs2XNOTs6IUZBlmizTSGmQSqAUKJnhvEdbS1nmZLnpkb/hK83q24CHXzbuZAQFUBY543GBkJFCGkSAi6MLWl1RZSW+8UTn0ZGUtRaQ6URerGUkxq5HNTrqeoXo0xK2D40HI6iUTgrk20aw54McTkbIIe9880wTndNQX5KxTx7GJKYZo8P6lu0eu5sGhSGqEnfAF2zvactqRTbpya0ywq1r1PC1Nz20NU+rSMb2ZuQqNpZ7fV+WqzlSSjJTplredMZ4dA/frWirOZ99+nOidwQf2d/Z473H7/EHv//7vHj5gpcvXxI6+OL5M7zznC3OCM5xdXXGanVJXe2zXF5yevaSZ88/5eLyGOss3gdEzBG9KUv/Stq2oesagrcIJZAmLYRs1V/XxOH9dYSYVOFvLj5f17irP/l1+p1frw/7dWQivo7jvOmbYo0kDzFB8wcVcKM0QSpWTUNbVbTViqwYJ3HUHkgQhUILmerCoSfzVgohDaauiPQE6yLpe0oBxIAwBqUlyjm6LqGOhZSozGBtR9t1tPM5KAgqJkFordDGEGIiMNfakGmDEkmnw/faHOu3VAZCaOmaCrO3T56ZHuSRtBeHtiytE/grOGiWNZfnp3i3QqlAVdXUdYXtIm3rEjXegJJHYHve1m2WlUHhQ4oNqf8APtpwlw4rUwKR9ctZ/yeVITbl9K3nGxPhufcdEU+q30FT1+zvRYzOuHfvATs7e+R5keSZjEptar1sXaI8nHN6eszZ+THn56dcXV5weXnF/GpBlpc9zZxGyETwjRKpzSr4VDstcrJMv8IG89rxK5ZL7pgOFTx8tMv9hzNMJhibEhkEL7KSZuVoV4H5xRznHVGScr0KRrMJu3tTZrtjxrsyEQ/LQF4YjAEhAlqxbsTc9jiTCkAEmXLf9CzjArHWpFNr4zX08MX+haBPtbE1KQIxSLrO3mJEtiISsbnm9L0+tbqVitz8vL0l1+fTq7fwlx7bbReITTr2de0aQkBZ5kymI8rRhPfff5v3Hj/m93/nO3zy0Yf8/Kc/hhixtsN2nqPjlxwdPSBGw+O3v8njx+/z3e/+Jienxzz94nP+6b/455xeXLJqI6enz2i7OV88/5Sr+RVV3dJ1Kb/ftB3T0YjMlOQjQ/COenHO6fETRpkhvv0uRkkyowgxrHswtd4S2h00xProMC82Ke9f9T5eu6df83Z/vfu6i4H7GqLCYS93tqevrkaZyTBKYz1olaKA6Ww38frajlAt8Ks5rloSZ3vImGrTQhoESbOxbWIiepYRlWnKssRGR2dTX2HWWWxnca5FkISuRbUktA3RBRpvqZuOq7ajaitWTYWOgmycsXN/xu7bu0ymM1wlOLpa8fKLU0TbUS8rnLNJB/Ka6wx4Q710HL04Z2/vbTKTVBZMr1AxHo8RIilyTEYa5zzYlsvjC5aXC7ooaDpP03piqCBEZF+3i5DUStgQ/steOmm7FSqEeM1ISCHWqiuDasRNarEk/zQk01Iadv30YqSqFhQxw2SCGBQhRJqm7tOVkel0l/F4QpHnfOc3PkBrze5uAsV47zk5PubZF5/x5MkvKEpFU1W8ePGCosg5ODygHE3WxN62x3SkCDW1p+WZYTYt2dsdkyROh+u7mfV78/gqdcM71wTHk5zZTklWREpl0FFTfvNtfKtxjeJHzY9ZLJfUbU0QiWG/WdbYUUHwkbIYY3KBygTaJI8uN6ZnPY9bdbokKyJEUoQYmP4jDoaiqEjekOqf5tCvJsSWEew/WxvBmHT78sbecnXb0dUmEhzu5Mb4DX/3n/YZ2jicw7Ud3vXOvmlsx6Gv2UKkaPfmQ0+IVwjBonUgywVFZqgWc54//QJnbRIlLTSr5ZLz8wuuLi6ZTCYURc6oGHHv4B6ZyWhay+n5Oc+Pj4kK6uaKplnhnUUKeoaZZNSSCGhqxu28JQbXOyu9UoS3aJ/ENFNUP6R42TgubAy7vHFha67TX9r7+zeFsrntuL/sufz1pIBvc+6u/f4aiOb2DbXSaKUZtBITUX3EdpaubejqBV2zpGurnvs2opVKacEtAewhIyRkBBkxRYYwGxUU4RyBlGlybcd8taLt2kRKjUBohcw0Khi0NxSFohhnjHdKsrEGEzg/n3N6fMbJs1NyFXFtQpdmUiLW73/6KzQtPsJy1XF1OSe6QKsUVd1ibVhD/2OMmCLH4JHKo3QAYYmtQcRUVorSIlVSkHe27+eTCQ+BEAxsKwPzSuq7NklOakgX9tmvbc3BbdHfIZpMIuKpqdGPFgABAABJREFUT28jHbcZwzGSbA9opZjNZozHY8qiYNBQLIoMpXeQSvYq8QNaP7WrKCm5uLjg4vycxWKOc6m/uO1aun7d3HhYaZ4MhN9SDNJ0r5uQN8f1a7C2oW2bVz5/3bhbOlTAdFayu1eSlR4TFZnIOHjwNhk7SD/m6dMjOue5Wi5BRIIINO2S0ahgPB4xysaMJoZiohAyycFola218cSWjl5P5r6B/guI2PWDTm0Css9/b5mfPi1yzSLE4SVNf9rieiR4/TpvS3i+mhK9me68mVW4bXyVHPX1o79+XK9jXj8B2UdUztVI6dDKQ3CcHB3x0YcfrhlzRmXJcrng9PSE0+NTRIhJizAz7Ez3ONi/x/3DB5xfnvOTn/+Yj598zMvTS5xtITi0FCRB2VSD0Er2LEISQSB6R2YMWkq8c9iuS+z8WbY5797p2G6EHdKj21c1+CXpfn91Q3ArrdZfw7jtVL8uWt6b8+rVvd79OBE2J/um+XojMnzVGG4+N0r3JBV+vVB2ztG0DXW1ol5d0VQLmrbqVRwimVHUXUhOVkz3ymjVy2SltcUUBhU1IYK0lijAek/TNqyqJZdXF1jnktSYSCLNJs8S8lJ4JpOMcpox2xuhS4mLlhcvXvL86UtePjliZ2IQMSS9PWOuP8MY8VWNC4LlynJxdk5X1+RSUVUr2s7h/WBQIB8VKBPIJhZnu6SU4gyZ1qioicIlmSttaGqfZMykRJrEvlTXqcY4SFtJISnyHIcgDCTRQiCURPcE2FKm3t3hOQwoy6atGdQfUir1xvzZasqHiDaa3d0ddnZ2GI9GqZWNSFEWjFUJfVrWOYuzdv2sssxw/OkxR0fHXF3OsZ3F+kDd2rUw93bm7bpwcKJve+W9ibe9S9sRejrnuq5omurOqPK7c4f2aatyJBAWsI75xRk7pWJSFOSFQGcpYsuUAqFoG8eLL854+fKC5XLFW+8e8J3vP2Y8U0n5N8Y18EHK1BghhEDLDBEl0UPwlhgDUudpYdTQqV6FWIQtEygYaoL6Fi8i9LI/r5KY38788jd9vNJYf+ManK+wnUYi2JtM2ZtM+PgnP+bFF89Yrmreffsd2s4yX62ou466bQjOYZuaVgmiGCevMQbKcsRbRcHh4QHf/c53ubg65xef/oIvnj3hyZNPuTg9xvqAkgXOW6L1hLAiuL6PE4v3S+rmCO9zpIzs7I4gSmIUuJ74AAQbOzjwL16nPRoM/y/jVPyy37vr+LKs4d2rdF9PKvPa/68d/FesF36Fr6aaoEHFRIJgnWO5XHB+dsrFyUueHb1ASCj3dzHjEp3nfT9hhhQRegFdoRSQeuKausatUd+Rulmwquacnh3TtjV1UwEhYREQJH1QR3A1vquxVcVlM6deaBAdp+KEpnU8+fHnVBcrpHWELiayBklPU7i5pxGwXURoxWSU47qWpeu4qLtUEoqRoiiY7cw4vHeIjw2RligX2E7jHexkE4wao2XByfmzXkw5afUplaMyjc5Tr+CTp096qjGHUhvasyjTPY0hSboRk46pkBIVN6ryZVmuRZvbpk6yYICU5pW1Uum0QFpryX2OFKkhvrMd55fnPHv+OVmu2T/Yo2laVtWSo+MvCC4ZtuAdz18848WLF/zxH/0ZJ6dnnJ9f0bYW18vpDf7fIAUlpSIEMFqje11NrXTq+R5ufK9DentrcF8u68fTLz7n8yef3nmO3tkIQtIxM0asOWJDtDhX07VLrGvwwSJkROtUjDVSU7Udbd1xcnSByRWH92doPaUoDVoOLRDD4pd6BDUaAnibyCdDSMwzQgNKwFgiTdK/i/T5+jgsmqC12DrrCDF5QiGEXuV8M177PvfRyesaNG+2SfzSi2vc+DJvolQbtr12iq8xCDFG2rpiMhqxv3+fUZEjgufp559zeXmJjwmF6UNqzq2ammW9YrlaMi4yikyjfJ76uGJMk1VrykmJ1JLZbIrWijLP0AJevDxlsapwXhJl8galFJTjMWVe8vidt7h37z737++xuzuiKDTeVQgSO0iWFX2D9FZ83ae3U+T36r29XrvtXxC+xAj9mhsOrwULt5zLl9uOm3HvsKet/X7Fa1hvfe3gt8yZVw/1y40bFzlElxHZp/RSLbqqVsznl8yXSyY7Myb7B2SjMTLLNuAQKYkh/SuHNSKmXrPeBCb19UxRjDLiqcP7juBbBq744BM/russrq3wbYNvG4LviF5RnUkaH2gai1tWSOd6Dtwk0j0c83raUIDSia1GgO06HBHbWlzP55jnGUpK8iwjMggTp6Z8FwNBCZQMCOkB16+lnkwHhBjqdn3NTgyZrEFzU675VINz6AEF71Pkmnoe04NIPM9yXUuUSq1bkpx/NQAIPb1aJFyLFL2ztG3DxcUph4eHtG1D3VZcXJ7xyWcfQUjp4txkLBaX1HXN2dkFV5cLbOd6LcW+DhmHdbXP6PUk/VKpNdm/WKeBN33CYm0IN89iA+7pKSVjpK5r6rrmruMrKMs7hPRkmUnxlhCQeZr2kvpywdXlCU09x2RQ5BKJIgSFs9A0nudPz2ia1LT9w996n8ODKXs7aUHUun+IQRCDRFhN6CJ2ZbGdwznLarVIlEkS9t+5R75bsLO/j40tIXY4v0L0KuKqJ3pOQqjDzU6E0Vmm7pRJE2zqfL+2SHGTX711cbvOJfrVdn12eszB3i6/+7f+FrvTMfVyzr/6l/+a06s5Iss4m18yX644vbgiaEM2Knjy/CmZEemZ+ALZC+RGSVLpNor9wwMOxCHvvPsOH7z/Ab/x7e9iO8nL42NOzs9YNpc432FUxuO33uOdt9/jf/qf/n32D/bZmc0gQrVa8eFPf0ZRjCiKMfff3qWzkVVl1+nx9MxerXXefhvE1t9/M8aNZPnf4DFUu4YRX/Pz3fe3PUJMwrgBUmt7BNu1XF6e8fLoBSdXl4zv3+etb30PqUoIgrpuEIS+3p0iBm0MAy1SCgySE5rlhulsHyl3OTt7jvcVru1ZSbynbSuauqFtO6qrFW3d0lYt3lrsUhC7hlWTqBjzzlMqiZpoTJHScTEE2tbhrb92iaosU6uC96yWiYpRIHDWEQmMygLvHcE7skxCzLEuMd0IHCu3pHEtzkZW1SVdZ2m7JKprTI6JBaH1uODwviHxb4F1Cb3aNA04jwR2ZjuEEOi8pfV2zbaU9VH1wNmstWI6nUKPIZgvmmtp7xgjbduC0GiTGue9c7RNh9LJID55+imTyYQH9x9SNUuePP2E/+9//0+QIvWSP7j3CG8jbdtxcTFnvlilZ6g0Sgk8vUMRBUYnod08z1AqtdKMRqmFisiaTaY/ufTcX/s6ydSA3zW0bQLr3XXcvVk+j2RZRKmQmtaVZJyXiCrDzRVGG5SSSGVxQSKjQqPIpCBXEisy2pXni09PMV5xsDfhnUf7HByOmExypFRYC7YV2GpF11iWi2WfC/fMFwu6rsV6y+Ky4+G7j3n88HtMDkrQjpPTT7G2wrkWrYY6k+iNoEQIDVFQ5L+cqOMrcOKt8StFGF+H933LPg72D3j30Vv89vvv88knH/LFF1/wk08+oeksnfecL64IMTCeFvjYcjU/5c9/9heMxzm7uzPCfEFkiQ8w29tlPB2xPzkk9t5pJDCezXjHZPyD/9k/4Gp+xcnFCbWtCTFSFCX7uwfs7e3z7nvvURZJ2frzj37Bk88+5x//o/+WcjJmPJ3yre9+n9nOPrOdA1arJtV5ZE7nKp4/f3KtbnFXk/JVzM9t23495uur7mEDMPn1Rq3XDZ0QqdzRY1e+8pS8KYu0/XnTdmS5I5DUYaQQBNfStUndYdUGLleBoyvHuIwYETHOImNAEFC96kxmTCKKD5HgHFKrPkLsGWlImSPbOOpVi7ctPjha3xJ9QMZIaRQ5OROt8F2iB4s2AeZKpVHTnMxkZJnBM9A5OrRUCOkQc7eeF1J7oo84H8A7ok99ekNrRETgfKDuLCvn0gI/OSCsjnGxQ+qAay1VnTIneWEoR4b51YpltUTXGVlh0JmmLLIU9fmWEGNfE8xA675nMCnmtF1L6FOMRhsEIkWHMoFkYuzbT0Sq+Xmf6o83hyAB3IwxmCzD9IjTED2nZ6nt4fLqgvnigpOTo0SmYTsyY5hOxuA11gYykzEqx30PZqpvRiF67mCJknoNokMIssywvzejLEqEEJyengCaLB9jzBCU3MzADT9Jmqbl+PiYZ1+85Pjo9M7v0J2NoDESk6WmVEj0R4XOEKLAeZ10qKTYQgnR9wQleZ1IosBaXNac6AvcsmWEQEcPNvXldG3i9mxWjq6xLBYLpBSEEFksV4l5vu0QwTAu9wi1YJLvYUaSrllSVRc0LJDKIURPPthHgskQgtF3iwRjnx/aFP2v/z999tcLsHjj8rT1q0SEO2I6GjExmpOXL/n00084Ob9YR/FN16K0YlQWIAJNV/H0xRe8PHmX+wf7qPmCzjrqtuNB+4gDf8DBo3vrOkwgYvKcLC/4zncK6qbi4uqMNjgignJUMirHjEYjxuOy54CVLOcLjp6/4Cd/9VeUkzGj6YSm63j78Xu8901omhbrItZJlvUlL14+5aYGWX+Vb7xTr/ttgoZ/+ba//vjt66ke/vLH3lS4YvDUbYNWBikN61ziL+Oh3fiKG+S/BiIMKfCuW7OGIDMar7hYhtSDrED3upbE0NfFVI8w9UQR1qhhIQQEcDYQo6VrHV3rsI3DWZsyQUKgpUYqTR4hak80GqdSX2vnbAJ3ycSJnBc5eZ7TdA3WWkRfTHU3p6CMaxDJWovTub6mJhM6NIIn0gaHiYpSaYJkneIcegpTw7jGZDmXF0ts1+GDQ8iC1E+t8QMAjiRgYHQCwoiYjMjQWO586rVTPWjGk5bAV9VBhnaMGw+sB8RIEq2d6Nf0QdKt6xrmyyuu5pdcXJxyeXlGtVrQtTVZlhFCEjfoOo9ShiyHoiwRemjc73UJSexfA6I8hEhmMsbjCSYzRODq6oosG1GWY8oiCSoYk/X7gG1d0dSj6KmqhqqqaZr2zlP2zkZwtjNhZ2eKyTwhSETUZPkIo3cR+YxsPIOrBXVnyZBoIZgUhryIeAH45H1IBM1yxWXX8sR7FlcLxpMckyVk1HLZUdce1xNkD4wv3ntkqixweXZC6htU/D3z93n8zW/ww/f/Q07OP+P86gtW9jkIi5SOEB0xgA8ghCbLDF+2wMR4Pf8c4RWo/r+RcdsK/poxyjSrizP+2f/nH/Onf/kXPD0+ogsWtEIoyWSSGlxNZtBZUqD49MnH2Kbiz/7sT3E+MF8sObu85Hd++3f47d/6Ld7/1vtJIqav36a3C7IiJx8V7N8/JMqhnrdNWdcjzgRczC84OjvmsxfP1t78P/vv/yU//OFv8x/83b/HB998yHI155//0b/i6OyU07OzNUdsugWbOujNNPXdnJKvn3vwlxlvyiy8fvwanK7Qsbg651/88/+Ob37wGzx6+z0mswPuLlz8pnMSmLwgL0YgNSYvEBKWy0uMUewf7GPKfVq1wyfPWgJT9kaSWalpbUcMjlGZr2HzuTEIKZkaTecc1jsWyxWX8zmXV5c8/fyIrq4IjWNcjsmKjOnejFFpyI1E+opmtWA1v+DyfIH3IOXO+p2SKtUXtZacXdQgE1+xkhoXNxmkCASV2gLQAiM1UQqiT/JMIViqqkPmJZPpFCsaXFxxsXSYrkWHJAcnSK0Augf9SaGYjEsykyIp33SsqjaVJEg+faZJ2bhYMSpnFMWEvYP7XM4XiLMzTk9OEM4jhEmcqfSKGD32omk6IPZZO4XS5toT894SgiBGibMtdR2wvqVzCfAzGY95cfw5xc81Ry+fcX5+jG2XxBBRsmC2e8DJ8SXHF+eozJBrTd5rvvaFqTXeAgTE5MBEF9C5YX9nj0wXOBd4+uQJJ0fHfP7JR+ztzZju7PLorXfWaiOjcpz6CxE0lYUg2Zntce/wAfv7B3d9A+5uBLVOOWWlBpJrDVJRtZbqYo4jonPNdGdKM+/onO2RUgEpWPeKaSnRIiJixHaOqkpMMlJZus7T1I7OJS9qu9Fz09jZS4bUFRfHRxw9e0ZZjji8/4jZ5BCpIuF8hY81iIYYJVGEHhWaagvXKiDimk+8/jzE1BKfuC1j3wv4ZcvQ7R7865a6W/c1LORDPXD9J/a59BvbbrV/bH9+Nb/iuYBqueCyXhGloCwyghREKWiDJ0aPc6D6e+K958XRS06OT4mQ6ih1y6effcpkOuHzzz7j3qP7TKZjvB/OE7Ya/WiqOgklB0dRluR5sTFOETprqduWpuvIyVA6pWqWqxUvj0/4ze9/gFARkzkELYT21Tu11TrxOnj+beM6mGZ98jd++vWPLz/X18ax/CqGUGxd9wBPf/b0CUcvn/HkyWfce/gWQq1XqLvvtd/8lesSCfGnpCLEiOvSswy+Y5RniJ1dzCinkjsoda/PJgUkHqMkUSbWkG4QXA3J+xfa0XYtrbVcLRdcLZbM5zXOS7xXvaaeRpChVEGeF4wKjUGjYsA1K8bjCUSJMeOerANcSNp7zqfadEpAbAi8t2+/t4khy1ubQCF9w3eMgRgSB2fbNlR1TXFgCEFQVSvwAhkSWUjTBqyt+wyaWPfSSSkoiixJw4WYWg8QSKUpS4NUIIRLxPixYicbMz4cY3YOycoyKfpUTRImsJYYBso6uSUy6zdLx/Yjk5toLUWqAd+z6IQY0Cpyfv4yiSZcnFCt5vjgyLIRo9GEUTkihguq1SoJZsvU3ymVRAlJphIiVSqJ1AalQRuoFy2jcsz+/j5SKtrGslxVLOZXnETH6UnJdGeX5apitrvLeDKhLAq8iwQf+OzzT6mqirqpuJqf07arO8/gOxtBpURShJCsUX1RSJZ1y8nZEotHF4bdbIeXyxOstbjMMggoSpEYXjKl0DFpZjkXqHsZESJ4H7DOE9iwx6zZDvon5gn4AG1Tc3l2wtGzZ4zHU773W7/HuNwlyw0XV88RrkeMCogyPfgoey6/m2CL/v+pOjBMjLiJvK71Hb5mERKvLh63Yf2G/8UbRuv6CW0M4baJWwNktuzPbSMCF/Mrmq7hOQlzi5KUucGJRG7eEpMYafRkMU36GDwnF5dUq3otaRMjPH32BdPJhI9//jHFuGA8GQ0ntLEe/SNaLZZU1YqqXnF47z7Zfqon0EO4rXV0NjlJxhg0CdJdtw0np6eU5YS8UIzGktxEtPDXL24wgF9LOCdu+elN49drKm+vdVw//p2j3207vzU25AbpFn7x9DOefPYLXrx4Rl1XCT39lS7x9fdEkPrzpJR467BNQyQg6CiznFxnKCZkchel7pGpFUrUyOgwWqZoxHl8iHTC42x6F4VU1G1N07VczhcsVjWrVUfojZ8Ptv9ZQcxQKsfkGSMtCbahNhmTcYaUhqKYkmnTz8GKql7hqwVEBTEk46Z6I7g1fOeI1qV/Y3rHEvhuWLMsddsg6hWP8hE+wIWviW6E8obCGKDGWovWBkiN/kOGI897GjbvWbmuV4VRlGWBUuB9zWLV4lqPlRnjnR0OJhPKXLK8OOfkixc0fVtFDH1WJqqNEYyvMs5A36omRd+24IkuQp82jiHSSjg/91TVguXqCu8tMXqKsmQymTEqRwigaxtMpkBItFFobTBKM8lG5HnK/Km8ICsV5UQzP1tS5CUHBwcoqWmbjmpVUa8uqVYXGK2YTGcsq5qHbz/m4PCQhw8eED20dccvPvmY5WqR0rWLc6p6cecZ/JXQoTE6gtdImfL882bBZ8/O+flPTqlDxfRwxDfefQ9bt5w8P2NVrxLPp1SJRxTIBGRa9Y3RDttFnJU9w3xEEFOk2L9YWiaWCeeH3kDovCDYllB1XC6/4Gye8+LiQzIzJnrBj//kMzo3xxQt3/zgIeWoSC9GjOsFYHNdN69zy+HbMoBf5oPftgy8dnnoU4N38evXUSB91BriugC/Ro/esp+66YikWscA71Yxya34kIiEpRRkRhN9SjcTA5nRMMqTY9JfWVdXPP30U/6r/8f/kye/+AO+9d3v8Lu/93vkPfos9MAKpeDi5ITPPvmE//c/+q/523/77/D7v/e3+e5vfDfROUnBKBsxLadMyjIpjbTJo6/rhtV8ju8gL8a8c+89mkVDU63eiM69q1m623ZfttXXaQB/mX3d/Ts355YAmnpBWy+IocPZjqpq+OM//ZecnB3z+L132T+4R1lOb/n2L3dOMUJX17RS0jU1olcIISZWGKUzZodTxuU+e6P7xKMPMXYB8QqpJwQ0F/MVPqYWi9YOnJcpe+CDp+0EQuRkuWI86VjFK5bLJdX5BUIInp9fMpkaJhPDB+8dYNDM9h6iZA5IfCrSQRTMyhnFqGU0aVB6lhr6mxofPEHUm/sSI25ZJT5TH7E2QkzADu9SxGpZ4VaWjo7ZVQZSEZnw6bOGbtXyg/d3ETKjKIqEuA8JzZrnOUDPPxqRKjKeZGiVkWVjTKZIquyRi8uaq+WKn/3Fn/L4m9/kg9/4Dj/4nR9SLRZ8mP0Vz589Z36V7ofsEaMDgXmvufTKo1TSIIWBmNosJGmtFz71HLZNlzJ4qxobkx6oyXPef++bvPfoMe9Mxkw++Abv7+xy4cAhiEqjdYYxGXuTHUbFhCwvCdJgcsjLCJ2HkAjTj05OuZrPqZsGpSS7OzOWiwuuLs+4XNXMV0seLN7incfvcvTiJc+efsEf/8m/oKqWWNcScRwdndxx/n4FI5iKmQM6B4alWaiALgJ7ByU7sxEPH+5y72CGXdRcnq56jcAUJSlAibjugQn02n+IJJrYZ9VSRmYwPhFEJEbHkEyO0EtweJyrsG5B1ZxiXUNwmqpqWFYLOnfJzm7Jjh9TjBSpX+c2kMX1cdtS+KYU1iuN65svrfe3tfG1NUZs/b1RoxjqaX007D3WOc5Oz1IdQRtm02mijHrNOeUqI1cZiEBUaT8qBghpUqOS2GaRGVTfZ9TFDlxAhIB33fr4PnrqpubZ8+d8/PHHRCX4wW/+JlprjDbQgwKc7bg4P+fo5Us++ugjptMdRqMp33j3G+t7NL+as5jPCTGuwQNJ0snSNDXOOso8Z1aMybS+oY6xfTfj1p3b3Noher49Kt9+Nls/iO3v3NWkvvn3tzs/w1m8rvv0Vx+vCQARCELw2K7h7OQ5q2rFfLHk/OIMZy0P7z9gPJ4ihSLc1f596Yg42+KsJvgOgksE2UohgkKkkhoSj/QN1rVgWzrZEX2Hj4Fl1SbXWKhksPr0q7UO7z3OJd3Joc9MSEkUAh9T+SC0FhcaqiYyG0umec40K8h1jpDpHKLv3w9lEqmzyuisQ2c5yhi8s3RhUw6J9EYqiH4eJ2o251M/YOxLBCmV6ahXro+Ic5xvaDpH3SSh3SQ0m5rvg/Pr5nXXWQanXxnd6ybpZJBSpS9xpApPvThjcVZyfjRib5p6pyd7O+w2HUIZ6i7RF3qf1CSQEhE2BNyvzqCUnqXPBAUEHoGPol8/PD76Xv5WIYNkYgpmOidrGg60Zrq3y345wUmNVwohE33ebDwly0YYk+OiRIoOJWrsckGwnoAm2BTB1k3DOBeURU6wOXVnuVotuby8QpuCo6Mjnj37gi++eMLV5SVNW+O9RepEy3fXcXcjiEpUXDIVf4VIHKCzvYK33psh1Yzd6ZhvvHXI6XsPUZ1nfrxAi0SnFXuvQomASOQPOBLEOIZIJnWKJqRc71/2/WmRgI8OGPQE0wQLzuFdjbVz5s0zRBzhOoULlouLKz5/8gvyUvLw0T7vfXCPQCAG90uVVb5MgPR1talrkWXaYP2LNN02yvbpZYprAziU26xzLJZL/vxHPyLPcg729vnOd75DYQyuhz7fPL2dYsa4LED0zbNCILxPqDoEC+tQSlPmZTKmMVA3K5ZBUPlIHRP5bpQi/a5reX7yEv9XkvPlnP/4P/lPKPIckQMhYtuWxeWcZ0++4NNPP+Xnv/iYxnpOz6/4H/37f4CISbX6888/47PPP0/9SDKl1COJoWK5WtI2DdPSsF/OyFDEWyDc27HvppczpiKOGO7dYNDE+itbIls9TDu1eiA8cU3grvoo/fWTZODBfN0Q2+cXbxpWwcbg/hpHjDeuQBJDoOtafvyXP+L0/Izjq3Muzs/Yme7wnfe/w97OPolG4RXMYDpj8cbLvnW0TYU1EoLD2w4hIDeJXFoCyjt8vcTXAVEv8LZmQYcNKzonuZivQKkeGVimKCZC21mstemJbhHwD3JsUau+5UNwcbnAuhXR1zzcP+Dd+w8pcoWShkyr9YKfMAM5RZku1tqOzjZY2xKU2bzIMWK7DoHEhZDYa2LE20TJKAChNCAJLrI4b8lLST6aoNQSRM355SWH+yUHh/tUqyUr5+jqDt07ye2qSVhCAaOdxDNqo8LZFiEsRlmUDmSZZ3F1xOnTFd3iGEPDeGeX3YeHZONddq5WzFcVTXWF7ZYkm5f68Kx1idh7PWfoe7UFRJmcoRCxCCySICM+prdL+pQlU4DqJJOgmHlQxyfsjadMd2esHn8Dl+c4bXB9b2CmDUIlBLLtPL5qsPNLrj78C7qmg9EuNZrOJYe5OJgwHk3ITeRyseTl+Qmnp2e0neev/urHvHz2BS+ePWN+tSQEn9C0AcIrcN7Xj68AjMkwJkfqFinSAwbBwf0Rk1kGRIyQQEuZa3YnEx4/ekjnPF0ItC4hO1NBPkFcwlB8DkOvkkQJhVQJLi11RGcZSIPXAWtD4gN0WZr8TmBbh207fEiTKyjJ4/dnlLNHZONAVmap5we/bhjdXn/+OpCCQ2p1HcPEmCJfKZFIruZXXF5e8ezZM4o85979++zv72OyDB88P//oYz76+GP+6I/+iHcfv8Pv/97vcTWf09quT2/IG9ckeO/x2+zv7iK0wIc+BSV6T8575ssVUQiUNiiTpzRz13BpTrhSF5wtawYqIucDIXRYF1DzC9Rxxh/9yR/z7Q++zbe++T5aS54/fcJ/90/+CX/2F3/Os+fP2ZlOyJTCtS113ZCbDG87Li7OOL88p7EebUDKlPIJ0dG2NU1b03Wa4Cx75YQHs70bcdNtyd/1XUZsKrtbhnCTao+ERKqAQpJUwINIUPp0tXLtab/2WX7pEOvjXf8s/ftKVPrXMAKB8WRKkWuKUYG/jJytKg7uP+Lth2/z8L1vU5RTBvDZ7QnRr37OSkVMJtEqR6sRxhimu4e08xpbd8RqRbU44+x8yf39EcoIWjni4qxiWVuCUIkomoD3DaLPklhr8T2ZM70TGkJCk0uliEESBSgMmc4JwXN6tgSnUMGQ52MKoZBRoKRBqOTk+z7rIpQmU5J8lGO7lpUdMlHprniAEGi9TQjLmLT0RN+KFX1ARBAB5ucNo4lmOsl4++0J9S5cPnvBqvCUZaQcZQTvMUaSOCkjRWHwQRKiQsiMqAzorM/cOFRcUDSGziYxgbZtuTw750d/8ieM9/Z48P63UGpK5wOdD/iY+JrLsiQ1lveAwxuRoHNJcR5UIjAXAi9SZBi9AGcxUpBrSVlMEFEQm8DnP/2I5rOnrLTg/v4B3cE9XDkjTmcwGqd3S0gsiflHCJnaTOgIdsnF849oVjXZ/tt0k0NszDg5PUOLjlkJMnYE58jzEUaPEORUyxYlDbs7u+BiooazDVoLVjq78xz9aulQKZCqT+ZE0Td5yj6nDcIH6Fyfs1bs7c6YVzWhaeh8H4H1Oc8hsSlj8tYEoqdGEinMVxGhBdLIRE/kNARLcBHnN0rPzoZU/I1dWuIEjGcZPo6w/gCTBXSmGLjneAX6/dVe7NdVjd6I+BvSu1tAFx8DzgbapuHFyyNevnzJ06dP2d3dZTKb4WNEhsDVfM4Xz57x0ce/4OjoiNl0Stu2rOqKKGA8Gq2BPZtnJXj8zts8uHcfaTS2c6kPR6sUPVvHYrlInp6SKFOCEDjbYvq+IPHyqF9c6HuEwONY1hXZ5SU/+/mHjIoRDw7vMx5lXF5e8JOf/phPP/+cy6srdmc7ZCbpt52eniYibaVo2obOdrgQkEH0qfKeHk0IYkjaklJKdqa7HO4evrEmeC3/d2PlHkzRZrth7g4/pachSWAssWUs3xQJAoQ3nJPYAjZdM3jrJMBd0653G693Ca5/knT6VI9cbGnalsmjx+wd3GM03U1gt7idyt3UhdejTzlfH+LWHyGhyo1RGKMp8pwszyknE4QF6aHuOtr5JfOXL9jJ3kKXGbUWrBpLVXeYouwLLwG5LhewaZ/qI8PYp9evaYWS5pRSGqkMdVOx1C3zYkVrHcYkKkjRt0FIoXqwSL/eCYE2ycE0JrslMZ9KC2qYuz4ycN6G0Dv9pFSnbQPORibjnNx4Fi8lwQe6ziWGJqMZT0aE2BBCMogyKEJUBETqOYwBqTRagoxJp1Grno7OeaLvqE/PqDqHnOxSjCIxJJmWJFScaMmGfj0l3SutMMHHnpxCpCClFyQQQSCRmCgohWasNJnMCCFSuZbF5RXZaslhoRgJyKVA1A0yK1FFIJKa9IOIyH6Oyb7fDxHxsSPEDoEjBk8IjlVVsVxJlsuMXAWCF+RZiTEFWueEINA6YzwaExpLZxqaBpSG0vw6jKBMhKHeReSAtowWH3wP5RUpv45g1TW0wfHg8UPEyRnducfVXUo29ekKImREghBEGdYCvFJFgrKgQWQZQUgiClROEGBjoG08MkQMgapOOnZEiws1NrQoM2bn0LB78IhBWknI1Pbg786mc/t9+ArbXosDekM49BvOF0uurub8D3/8J/zsww/5+Be/IMsM3//e9/neb/4mQkqWqxX/9J//c/7VH/1rfvbhh+zOdrDOcXJ6gskydnZ3GE/G9Ov6eigp+fv/2R/y7Q++jVCaZlXjvSPLMqxtsbals11Kv3pPVBkgwXv+9Ed/zE9++mP+4tNP8O2AJItEkSbu5cUFV5eX/MN/+A9ZXM7Zne7w8OEhT5495Y/+7I+5nNcYk/G3fvt3uby8ZLm45L/5b/8bvvHeu/zwe9/DO79Ov6ZlIqHiMmM43N3H9Kmvcuce391/xMG9b6DUfwX2y3L8vUkTeuvmD4uS2npyvZGLHoGFaIk0DLVnACkiQtyeThkqMm9S+x1US/56Y703R6kSwXJ+ydXZCz78+U85OT2FVctbBw9559F7GFMSe2WBta/6yj63CtmvPdjmqoWA8ahgOhljspzJdIbWhiAls50dYj7mk08+4er0iOeffkjXXCHKglVWEEMGaHQm8DHgfWKPGRbw4VipYd0ng9QrrCeDmJRNpEpiubkQVNWSVWM5vZyzrBpMllOMxhTlGK2z1B8nW1wEb3sFhgjKZOgsv3aNSqZIU+tB4Ds5Gek8BvStRGuDD5quCxy9POfxOzvM9sfI9wJNtWJxVRG8YDIe8xu/+TYvT55SVQvUakWMkuAlZ6uG6BwqOEbZFKklIhikKJDC0dQRpTVZUdIGS3W54uTPfsZotkNRFOxMRgQj8K0hRMi0YTYbEUXNohncweQ+eB8IfpC8culBK0GOwqA4LAr2i4LDUclJ3bLwlqsITkBQSaOx8TWnlyeMVzV5OcWQyh4pEBAoDFpkRK0I+QSmM/Z/41vEtmU8eciTS8/ZRc2yWnFy0iDtkoPdMaaYMp3eZzQ+pCgmjEa7xCwnjkp2RwXONnRtTYwdwf0amuVZE7lKUm1OrPtbooDQ1/qkkox2MpraEVuPMKAzlYhlY0SgkTFpBWoFXvZenLbEJChNOU3sAFFmnJ81rFYO16c3QGF9hwwJ6bhctSyXDdY6LBYbWkIEIQxKOEQC4WP752mt/cp1jdeNO/WmSYnzidaoqmq6rmW1WvH50y84Ojnlr/7qJ5ycnnC1XHD/3n1aZ3lxdMTp6Rnz+RV//uc/4vj4FCEkDx484OGjRzx4+JD79+8zGo96h+L6qhSB86sjrlZ77O7cp7FLbNcSKZgvzlgsz3vVao/3lp2dh+RZmYAoWQemIc80Mfie93GIXwdQVGC5WnJ6dsaz588wCi7OLrlapP6r6WSCFor5YsHT58+pWsdnTz/li+dP+fCTjzk5O0tQ/JjSRpnJ2Znu8Oj+AyTgrKWLHUJEnLyb1xKF6A1UX7PYrrzFsDFJW8CC4BoQHcQmUTeh8P128TYjtw5Etjru4vUNhuhjHWlu1SKvVwZv2f0vMy8TGujG098cIw61ZwlnF2d88tknrJylnEx46+Hb5EbiugrbzlG6QGmd6kZxcCCun/QQ5W6m3LbRu3lVAqMyjMpQKhkZ6wI2esYyRxtD5zzLpuFiOUevxugYCMKgZNIQDM4y0PShTK86sLlW78OaEcU7n/54j+26VGsxqSUoJCZunPesmiSsW3QFMynTAt2r1msgB+omSTv51pLlOkWcW7e8GJV4n8BlxNQLp7VerwlSJqk3JTXWB3zomF81LHfGKAp2du8hRUKTXlxUNK1AqDFCzShHGUZKXOewNlCEgigVwqjUg9sF2uWSuq1o2g6jc4QxCJ3AcAFB8KYHHQWMkXhvwPoefJachaaxWNutZ48giQ/kmWJU5iTirwhCUxpBqSXfyhT3jObQGLTvKLUh5jmH+7vsFBlWJe5UqzSmZ65xPhDE0KYmcU6DUIlFRuXoYp+9934AzpPpMXH1lLabQ4isqo6X3tE5yXRnxP1ZjlZZIjCwAe8EwWtCTPeITIOvQP0aIsFEXRURQrERPE2N6EnfrwezqEg5yxhXnuWpB0mqS0VP9OmhOBFJwpAJ+xeAqIZtYbw7Q+kM5w3VsyXnlyt81ORlRl4YHAERA8JDVXWsVi1d6/DK4en7dkQgyogUSZYpuSq9QvUdKzuba9/UDrcXqvV7cVvpZ2t0XaKAOzs7Z7lacnZ2yk8+/IgXL4/4xaefYl1KAUYpqNuOZ8+f01Q15+fn/Pyjj7DOkecFDx894uHDR9y7dy+xbRiz7h28uRgvVucsq0t2dg7obEXbVigVWFZnnF+9wAlBiA7nW8rJGCMkQoHQFplZRkVG9IGm61tLhhhIpoW961quri55efSSaZEzv7yi7RwPH0zZ390FBIvVihcnx5ycnfP85TNenhxxen5KVdVJPQQgCiajMXuzHe4fHCAiOG9xJDFeh+N2mMaNZ8RgCIfncb2uF9loT4qYUjI+tCA6pLRIPIjQx443SaW3jzOw4MftD+lzrMn4iY0BYr09679+9QjxdUn5V4cYjGQMnF+d89kXn9MFz+50yvvffJ+yyIje0tZzipFEKr1l6HtLt3242+b8bbnofhhlejo23TORJMKEUdHzBftI1VkumxVlU5ErhconaJMcGW9tH+kFhBFEpdZI4xgjPiRgWIipjSqRPnussxA9QkZclEkKSYALnrp11F2ban8ylVsSil1vFkQpCT7tX3PdCIIgy4ukNTjQgAnRCwH0121Mf+8FXgRc56mqluXCkinYu7eL6wJN1bE6ndPZFpO1jCYFOsvQoqUTyUkryQlSgZYElzhH51crOp+km7TJkdogtUZlOrmBNrVCKBJRSJSJP9laD6Qor2vjNTYmgMwoitwkI+iScyGiYTxSTHPBYyN4ICSHUjI3AoXCZxP2Du4xKQtse4XzSf5qIgQ6RqzzKYASpIyhTEZQSkkUGpVNmdx/HxFTiYRPj3HOIRF0NtB2FqRDZJGHIkNKjegFiL0H5xUh5CnAUirNF3GdCedN485GMERHiB6jUlpgyMETFVJotHFIGRDK8eDxLkVe8JPjJzR2Rd3W6eSEgCiT4riArDToTCCNJhvl7O7PuPdgn/c/eIRShuUiELVCfnrEydmC0U7BbHdEPQ/42mGvLItly/nZkovTJcVMYsZjtDLQn1/rGojJYIsIPnbXrite82Zf9dVjvCk38uYFOUGKI6p/WRfLig9//nN+9KO/5Kcffch8MedqsaCxNkk7mT7qDYEnL1/y9Oglf/KjP0uEvMHjOssPvvd9vvPtb/Mf/r2/x2w6ZVSWqSbS1y9uEsmA4GDvIQd7DyjLkulkl8yUFMWIAyEpyt1ErOsdrW3Znz4iM4amXjKb7fD4nXf57d/pePLkOR//4vN0HGLvzaXFUQvD1fkFH//sp1wev2C5qvit732f3/nBDxiPRvzFT39C1TQ471FScTm/4nJxtRb3LMuCcVEynYz5H//tP+BwZ4+D2S62a5FtZHowSxRO4uaVvW5szJLAI2IHzqZ3T+WATh5/3wAtCJRZRCvICo3vF7xVAI/C9ana9MTj2rgRE6OJ7E3lmhJuC/jkgycET9cjCIVQlOV4q83otqjplx1vmo/pGN45lqdf8OnP/4q/+os/4f7BIb/xnR/wH/3H/4C2aWibms8/+YjxZIdyNGEyPcRkOdrk27v50uPctqFSqVldyByp8t6JaFO0hoC8oFWSs65j6j0xBMYhUK0WCTQX/Zr+1xRjlDZkmemVYgTOOXzwOO+pVssk1FtXtE1NDC6R8geBDdA5h8ARpMNkGePJlPv3HyJE4gJ0LrUMRCEYjSf4UBBjjziU+trlBikJJHaabJx0/0JIigveBQoh1qlR58H7iJSR45MXLFdz9g/+Fnpynx29w9J7urbm9OIMcQlaCXanmkxPKUeSctJHOUrRNC2NqlkUDdIqVHDMpkXSGVQCZ+uU7dCR1nfEFpqFxbUS20JmCmIMRLrN3F0/K8k3Hj9kZzZmPBqheq5tbKDIPaVwFFfnKB8hSiaZRhQ55d4B+XSGlJpFXeNcUqeXiwUjoWiJ5JlB9q1abdsilSbLy8RQAwihiT5guw6pc8bTGffvH9J2HucjB4cP2N3ZoyjH6zndxbQ+x6hwqc05qRDFAhe209dvHl8BGPOq9tRgPwSpDpWcQUFWGspZZLxXcna1oHXtmkInkxqBIy8ke/cmjHYLinFGPtbMdibsHeywd3+S4PsTePu9A1zwNF3DdJaxu1dw796Idt5y/uQKQcQ2SSYlKybosSH6vr8lDFFS0iNUQAz+lWvbwjHAsNjRX9yNbd60IqSvpwWzaRrqpuGjjz/h449/wS8++ZSXx8fUTUNrbZIm6hnfEyE1BOeI3tOFJJGilebw3j3effddPvjgA/Z2d8myLNXUEn550zB/Yy3M8hLTL2K6N7JG654Z3hB9RAZFVKJXADGpyDzeYW/vkEdvLVkuG/KnL7FNnV6c2Cs+SrFplA+eo+OXdM6RZQl84HzHfDEnxshoNKIoklPinU/3V0qyPOPg3i4P793j29/8gNl4yqgoUGWBzAUoj/MdNja3zsVXc4d9yrEXYg22IbY1AkGW0yPRNOs6YfCE2OBCC7FhUHqX+IReI0WM17oOI9AbQBUDRL9uck5p9oRSTOm31P4jpe5TrVsx4K9s/4aoS2z93N+FNUpqSF8LgnccHT2nbRpG5YjvfOf7vPfetyhHO2hTIJWB05ccH73AO8/3f/jvJRaTW4O7W0PB144QUj0vYNEqsTXJvkQQokdnCp1plNFUbUMQEo8m+J4mrZdUElKSB4HJDMQiKY8jsM7inMW6jqZZ0XUVnW16ysaUfbIuibk675Ai9Ch1hZQao7PEStMrKqTaXlJQkD5pXIZ4IyUfk1EL/Xox6O8573sWpvQnOahxzcwiRMS5mqaFVV1hdE5WjNjZ3aNrC7qmYVVVWO+oGo/TEa0iUjmUASVUAq5EEv2jSu1jWZazntcxoTq9s2lboGkktgHbJerEtOYoIp5tcnqBYFxklJnGyEhm1Pp9LzMoSLVHGzxLF7A9gCbTEqMV0hiK6Yym1nRdS912UNc9OE+tybiVVInQPG/W9zPERBHne0Yp0a8TRWFQOmd//4DJeLLOAoSYsoGpl1EwTJi07vckCHccX0FZPqkAhAGWvPVCJwOZPLMYI6YUjBAcvL3Ds+MTGluhZEGmJKPcELGMJpq3vnHI/XcO2Dmckk80RZ4xKnPKUTIO02D41vIR5Tjj4uKc6e6Ig3tj3nnvPouzio+7SFetsHXL8mTObFqS7WbU1hJiAsIEkTx57y2IpEx9LZP1yru8YaX48nFbhJj6/q4WC46Pj/mn//Sf8cWzF3zx7DmN64hSoPIk16J6gJAPPdSib/RNtQTBqBzxwbc+4Hvf+y7f/973Ei9f7Nld0jfWxmk7fScE6KxAmSRQqrVECIMxGuUkygmCBIIkUxlSJ9RYno+Y7ezjJbTvReZXFaPyM1ZdS/Bb1TIhGU/GjMqCzGg++fwzIpHxZMbz42d47zi7PENI2NvbYzyVxBBxraOqLDEK8iLj8eOHfPv9b/CD736PIi+RSlMHS0dDo05pWFGH5Y10qNhc5I1HkQxZIHpLaFb4eoEEcp0EUlPtSKToIlhstyCGFTEsKIuIMiDVCCV1SvPDOsoLQ845epRMrEYhOIKz+LajXq3W74bvKQWjVCnlb2TPyTjMlK8jCtzaR9z+4fq+hUjp5c8++wXOWt568DZ/5+/8B+zs3QeRk5c5CIXJc57+9Me8fPaMb3/nhxTlqP/+V5F1enU7Zz1t1+Gkw0jVz21F6zqCdZhSkY8y8jJnvlqxrBvyqul5O0XPVZzqdSMfE6NKDASf0o3WdlhX09mGur6kbRqatiKEBAIIEaxLhPzWWZQUJO6qZASV1LQ+qa6HvvdNSokxSRrO2tSPfE3oGrAu9GjQVPOKPqHUU98zfdP8VqaAiJAh1eA6z+XVBbs7h5TTXQ7vPcC5lq5rePbFC6pqxaKyKNFjJ7RLqNqRSArtPmDynFwl4m2tNd47bNdCNNgYaW2NDeCjoPXQNhHbRooiQymJwCQAyVaLhBAwKTLKTCHxZFKiZTJypYJcgCxKWt/RNC2VT6hVI1MaVRUJaCTmc/ximdh2SAZO9HD+GHxiC5KKPMt7Jyk5kSEmXui6GpzuyGhUMNs54NGjhxhtEminBz4J0eMKQkQGn+q+IYkFu3D3d+xuRlCQ2LqFWEOTRW9cpEwLdogRkEiRk400eQ7f+FbBxcWK5aKhvZLIKNBIgrDs7I353m9+m8nhiGJq8KJL0UKwtHYg6Rbs7k8gKN566z4+BNqqZTzOmZY5E2P48C9+SlNVvHx6wXi2y2QKrbf4PkpSeeoLdF1CsLa1vwEjGLy04WUXfTdDHwGI2xQLbq/JxBhpmoaXR0f8+Y9+xKeffsrPfvYhbdthtMIU49S4rvV6QfQuKT6jFJnqo8KQUqH4wGqx4Ocffsj84pLJeEJmDFmWMZ3OKMuCvb29hHrYuqYQIn/1yR8RsiXvP/4eXzz/mLpecrh7wKcvPuLJy1/QuiTY6ZzlB9/8PXbGeygJP/3sRzx5+RmyMVRuyeG9e9jgadsG11PPSSkp8pzDg0Pe/8Y3adszqnpB565wNkHSf/j9D7j38BF7+3t89tlfcH52yYsXFxzZCusDJlNE5fHKMt7dZTyaoLTh5POPuaxOOGl+zuXigqOXJ7ewWrxuRCQp5SWEI4i0kGS0gCIAy9rTVEvqxSWxewFhBXHO3m5kMo7sHuyB8kQZ6GxS767rGtslQvjOdrR9iFTXVdJxa1siqQ60u7vPqChReUnURa8+3vdy/prGJmAb2j4GdyXNSZPl/OD3/v0eFm/YO3jU81WmjWxnefHsOQcH93n44G0me4eYrPgKR98e12ulrW3pnAVjCD2uNsZAVdd0bcPObMo7bz/iN7//PX76s59TVTVt22FdWmfyPEerxEyUZQVSRGoCtn+HUiRYY21N0yxpmkRavb4jgj7S6+WApIAI1apmuVgxn89p25YQAnmeI3rUjXWpXpZ+Z/E3amfBS6y11E2NIU/GXZUomYA6g9CAUqrnBE2Yihh7Adks4kNH3bQ8fPg2QkVcsIhsQrVa4doqVab770kp0DL17Eol0ToRXCPSPbJOEoisuo7OQ+MFaEVAsljEhIqPSQdWaYmWGq2aa/NSCMF0XDAe5ak+J2IPgFQEKbExckagQ9FFkdofTIEIgaquiJ1l1XqatqPtLM6eoI0hKwqca1MfZ0gKH2VeUBTlGsQ09Hxm+Yim6eisxXYdNkv0eNYldHj0IeFSZI/KTbeH6N066nYR3M2+sTeMXzIdulE6lzJFLrGPTgbGBoSgHOdMZyN2didctZZoIzKAkElCZDwekRcGbWRKKaxZ00NaPKRDG0U5ypjtjKmqFtslAUuTG+49mPJ8NyfElqqytHXAtikd5RPVdo+Oj0n1IAiCF7dmcjaGbri2raXlFm/4mqHc2odzjsViQVVVdF3HeDxiPJ6kGqHRqRCv5Tq6uE7v03s5PhWutVIUWUbXtFxeXNLWDcYYiqJYb7+7u5PO4AZQoaovWdUXtN2Si8Upi+UFgZbTqxeczl/SunQM5y2XixNkDGgNy9UZq9UZBRO0CezujFkuRmgpsF4SREAqRVkUjEcl0/GYyShDoJBtQCmFMYrD/TEP7884ONxjflHi25p5kZGZjhA9ApEADJ1NtZMYCM5yeXXO5fKUys9pqyW2qW+fkJvAO/2zfhYJHap6aj4RI9F1CKEREerViuX8iuXlGblcImkQscG2Nc5UZFiILvGt+o7oWmiW+KbFuWQQfUioxFW1St6/TZ66KApEmKFkD503WQJOvMlQvPL5V4sSB3aXrTxAv6ch8kzqBrv798lM4m9MzUmsQVWQ1Mwn4zHjyRRjkjG4jQpw8x6IO2VGIxEpSNkG2fcBx82XiiJnd3eXx2+/zYsXR8QYWa1qrO367EMk9iWAJLsTrhkV6yzOtzjbpWfhXA9+Y33uvgfMpIBM4EmRx0C9Nmw3pNkHjuHYH29ovbh2Xb38TIzp/mqd6pRDu8ZGdScReseYkO9SCpTWaNO3BzlHluWoTOFx7OwdkBVjbNtAsETvsF1DDJboLVrrnuQ8o22TYsuaWxiBDwIfZaJYQ+BDMuhSaEzeqzf0maak73jdOTNGJxadIIjRIUi910EIXBR4aWhloNGBMisQOqFRU3sN6dmFgAv0jryArsXaJj234DEqkWk759JaF8K69WWI8pxLawR9UGCtpQdcJBWN2AMhUnqHGH3fSxn7LOBdsxdfpUWiT3sqpda9OImQVaO17ul3IkoNhiQipGe2O+LRW4dUFy+xvR7KIOPivaepA22M+JjYIGRMiCAhBMYEYtQoE3nwcJ+LsxVXFxWXpxX7ByWPH894/O0DyhPD5TGsVpJ6qQg64nF4usRHKASg+gK45vqSsQ1U2F5O0s+3coKybTQ33xpaIdq25dFbjzg4POD3tUmRgFTrpvbYB24JptxcS5uEEHqot1sDY2LP+NK2LV3XUdd1n65RCaatNiCOYeTaIVmxXL7g+OJTTi+PeXGlqZoVAY/UyRlR2tDU58xDQ6agEJYH09R6MdYZMzMF61jVNY1fonKJMZrd/IC92ZRJkbE3MxR5Sr2OyzFZnjOaKoy8olrWaNFQ5oKd6YiLS0uMFm9hOW84P52zmF+wWlxR1xU//cv/gdbOOXxk2CHDm9E1s7Cpzd02RWNfn1ZonWGRRNfSLC7JCksUmqMnn3N1cc7V+SnvPZ5S5inV7+sVnVBk/orQJS9U+EBsWrrLK+qqpm5azi4uWdUNVdNS1c36ndg7OEDOZkQ3gzBNL6nY0HmlOfMmCMnrP33zSPP21vJdPzGl1EzGe31qF7ZbH0KEPC/5wW/+LkVZkmU5UahbygQ3jnpbWfaWU8uMpiwLismEKNN+gw2M8oLCGKbjCVmes7e/h3OeL754zk9/9iFt0+BsEt+VUqDystfES5Fk23YpQrAt3nf4sDGC1qZ3B+jfEd/X0FPpKNHHJeHaPM/XpNXe+/4da1KIETxKgPUO7+z1pHxMadosz5hOZmR5gTGGrksZk9EoR/d1dhtcmidGUZQFWiuiFwQLIXS90yYQWnH44G1ClPggcF2Fa1fMT55Sr+Ys62XS7swzZrMZR0fPuZpf0nQ11no667EeIoasMCyrJU1rsZ1gb2/M/v4OhelQIjmJOteobKOTKIQgMxlamz61mkB+PrievEPilKYrBa02jHdmSKMJvXPjvOdqfoXQBpXljCdjpOoJKNboYEUxKsjLkjwrGUgyRuMxIKirhsWixtqWoiyQUtC1LavlEtMrkmht+lS2XyNwhUzn6mJMSOA7cEQP4yu0SGwW6u2ocCCyHjwl51xfMwQhPUUhGU+TblzUovdIBHlRJHQkSRRRKgUhkd5KqftoEhAOpeH+g31G+YydsSWKjhgULsL9tx8x2d2nzDrKssTbSJYXaCkIIhLkYMwURZbjypuiqnF9fa+rA25HgW+qFWqlGY/GvPeNb6QXr0+vSiGue9PDAhJjX8DfusehpzLqi+khho2CddjUqfI8J8uy5H3eOEeI1EenXChB8/SY7uIY09ZEAYVzZD5gQ1inD2x3xkpeURMJTUXWRZAdWVTMigz17jtczFd88uwJ98YFu5Mxjx99wMFshm8qZGtRjQfv8b7F1o7VsqNSfTG8qShay6GJzAuNDoKlhSJmFF6zPL+iaTtOz885OTol+IpxMGRGIpftK6v7LY9v/bMQEu8FzsLp2ZyuXqLwTMYTtDbUV6d01YLoGxQzMp0xHo0IPmLbivOz5xACwXlWjWVV1ZycX1FbR2c98+WSruuw1iJFyn6EELG2pW5qlssFMZ8R9YgsH4Arg6MF9CnBN4ZPdx6vxoCv7nWT3YhbEVj6MZ2blJrRZDchuOXr07avZEO2zuL13wkEb/Fd1/NpCkQIZMYgZd6rSSRj8tu/9Vs8uH+fEAIfffQRp6enSWE+JCRuUlYAITTeJ427ulr1CjF2jRQdlFKGc07AmoGbF+gji+D7FKhI5ZxqtaIP73pe4o6urenaGttdB2il5SmJUgu5ufM+JAdWUGB0TlFOmOYFUkuU7hUcBITgiBaElyjhkD1/qfWWIAz5aJdIwDvLeFRgVMBkAusTxV/dddgQCVHivEitBkZTFoqucyljYSMiSPb3JuzujJiOC2LwCEJS6FWCraZLYozUbYOUiURjmF5rPmMRUJlKRlT0LW1KoLK8d8IT/iCI1HTfthbZ8xb7LXLxxbKlqiKCFQNw0RiTdEUXS87OL6mrhqwYY4TqewItMYQ1KlhKksA3gBDMJjNCiDRdh6u7WwGQrxt3M4J98THVquKa8HkIXbfZyAdwQOKHC+hMUJQGrQXolCMvyoyiyNevo+iZVGLP5p/qjzIBHXpB3NnOmFxLxgWcnZ/0aQ3BbH+X0TTiqgVZbvAuIIVGyEBUNsH6hSDGBAwxmb95aa9eLPCmKPA1t6jPaecc5vmatDr0oJdXIDSDUx5T28F6aUpzKR03DgZz6IkK63u9YcbogTHbC1SE7nLOSsLSv8S5xLDjQ0D30YjyqRHex4it5/h+cUpF5kgUHmMMZQ76YJ8sG/Hy7ILdsuDeZMJ7bz1CAcF1YB2ic+ACwXc4KXG06/OWCnSITFRkWmhClFgkY1MwVgWutTSrivnlnGpZEV1FqzNMmUHz6mR+89OQxCjoPFytWtqqxuCQQpIbg7cteJsWAiGR0pCZgtqu6HzL/PKc3lZxtaxZrGrOLy5pPbgQqZsW710focj1swsh4IKntR25dfihMe21c+erGsHbUqV3ixy/PKoTmKxcL3avHPbuh7p55LQ++CQ+KxKLBSLGpCVpkkqIVIpMKx6//TZFnnN8dMLpyTGr5YKqWjHQ23lv1ylF39ez27YlREuILj2XgRNzSPWKzXo13IwI6+hwaGW6SXUXQyD0YBNnu74muLk3UgiiSgCagc80bKVOUyJAoVXGqJygs3S9zqco1YcOhCfJZfo0V7xMFIcykI0lkdR3mGcGJQuUhvlyhfWe0HX4AAhF7Hu0FalW6B14l+afkorpuKAsMjKjsLZPQwnSs7gxP1M0rSCmNPY67T2Uv0ziO5axp7fsy2ED2lfIZACd67DLqgeEpfaROKSao4Oo+uBpALkkZY7lfMFiscS5wFtvj9fltTCkrRF4GQCfOE3TBEb3PdMhBtqm/fVEgl3X0TQNznl0H5amiZmKztvN5Fr3skjBImVgVGqmsxKfCwwZ+4czpntlkg0RaeKkfpHUmCJQ/cMJqbYiBRrN7nSfXO3y47/sQDugIB9llCIS3oGugratMY3GFJEs1+gsNcImuQMPwt2wSNvAmPTRUO/76r1cm4VqeGjXPo2vW0u2EFrbCr+9UUwtHtdHapPYeLvbzzxGaI5WVA2EaFlLoriYWs/j4LAkGH8bQzq3uGkIEDFSi4q5Oufbv/0Obz18yLuPH3Px4hfgGj54/xuslgvOT49p65q2Tm0GNsbkHaoESIoiYl1M7TF5wYP7Y6ZOMa0Lvv/Nd3n/rUc8fvweXddxsH/A02e/YFl5qtxQ7IyhMHdcgAemGEGUGmEKRDFGISkzTTmbUOQZD7xmtVywWFzRRc1V7ansimq1wLuOi8sluc7ItOH4/JL5suLk7JKoDLGHdmemIDcapXWaLEJSTmcU5Yhiskc2mmL6Hqivb3yd+9qsa4P7FdZR4pvC7q84Iljb0bZ16tltU62uyAoYlQigFU0ir9ZJxHUyGvHv/f7vIkXkYG+Xn/zkJ2htECLQNBWdVWuleu89bdcklG50NHWDC/56+jOKvm63uSBBMoJd17JcLtenOzSOayWJMmJjkhRLElDbrQTp4oxWjMajlIZsPbQttgeANG1LjBXepfLRaDxidrjPyjV412JDiwgBFSO2XRFscg6fvXhG4xwHDy6wXYu3Hbtleqe0zFkcHdE0LUppQlDk+YzpNMc5R9d1rJanNE1H2zpm0ylZrjFGAS1V1fWAKJX4eVWO0i3bVk4yBCRi7SBENpzRqUyVULtZZpAiYrua1lmazrKoKs4vKy4ua54fn9NZh/P+mn0IIZ17ajMJPZK3BwARyUzGqBxx7947xEKipeoN78Dv269nsWeziom8I89z9nZ3aaqWG+3FbxxfQVT3BjmtiP1ks/iQgARCJMYJIZIsUgwSrQxlKdnZnYHXlHrK7v4OxcSk2pjwCOEhpvqWs45MaLRUibS2L37aAChHVC1CeSIO79rUS6RA54mo1neeZW0phUCXIj3WAQElZA+P3r6uISIbhHwT1ECIAWd3PY67iRpd349huwGowbYHfq2a0O/ndfeZDTUVrFMIN7300HtVw5+ByWT9exJZbRgssBBgeo8VkVKuSqB0cmaCGO5BGts6ftLAZDrirXcf8pmoWC0vyIuSzraoQsFYg+qZ+JVAKIFQclMDDYCSCJWRWRKTfz5hVBYoY3A9CEHLhJZ1PhCMgTJLsls3VuLbY6JNck5IidIZu/v3ca4j14q8KFBaMd6NqGKEGY3JM5UQcNHR2IgNFZW1WO/RNlJ1ntbHJKOjTOptKkeU5YiiyJPenNYok1GMxmR5wXi2Q1aOUSZLZ3VL7ezrSITedVxP5UPcQs29elfffGavbZfYnuxbO00RckoPEjtsmxbcTBmC9wTnEUoxBBwDn21Z5Dx8cJ/gHYv5FdYl0MOqbrE24IQFREo99vv3wfWyYr0WSG/1Yo9BgL6Xub+OIUtTV9U6Wk/OZOrVTd8DozX0CjTb15Ug/am2GGJK0WmtCdEjewq1LM8YjUZolaSk2mpBU60Sgbxy4D0iRJbLtNCDpF7MqVoLUSUlHRlxxZhE8+fQ2pDnJA7WPkPnvcUHi3NtOmejGY1KTKZI2cMUaETSuyhlSjFmWpCZ7loafeglHu7hgDdO2T3Rt6VYXAhY6/pUMnQh0LmItVBVjqt5xfnlFV0PPhJys47GqCEmCSshUmSfF2YNBBwVI8ajEWVZpn5NOchk9X9IGZbtmdi1DUbrVCLSuq9F3m18JWBMmkB9PrzPa/tg8b7FuVTLywYKIiHxMWKMQI5g/3AXTcmkPGS2u4vMIq08Bdklcu6o8C7lkRPYRmJ0lqjZokicebKji0uQlojtG0J9QpLmkViDF5HVckUQmnI26lMKqZ8ueTbXgTHDrI5sf5y8H7G+8O3UaP+VG5Hi2kG4Fu3Fa/9c244Uu6xvbtz8fn0uceDP36R3NgCaZPx8CD0a6voleZX+9Fakz4EqBub76BMtkZIKoVM/5TaiSvUSNTFEMDCaFHzvu79BV59wdqpS3dVm6FITp5pY5AiTIVQSURZ6iM2GW6hAG0zr0U4xKSYURUYUgrZLIqrRJ2+2c45gDKLMkDoibjyu1wUnw3ZCSnSWs3//Uf9A+hc4RkZCk9uOiWsxShCDx7Y1VRfpgqZZXtH5iIye2oFFI7MSoRNgYDTdZTqbMRqPyYqSLC8oyhE6L9E6wcGFKpJm2vpsb6+l/XrH69Kn8fp/19ty8zS/fAzpjT7teNtIQC+HdwHbdgkBmPcpUu+RfTbDA13TEkUkL3IePnxAUeRUqxXz5ZLlasWqOcFZm77Xk7CH4HtAWrdGeibezpTSc70xk7KPbGCdYosxUlXV2kk02vRG0KbamYAsz0hGcCBhTzXDzlqkd6lFwoySwLTRRDwhpGb7siiZTidE3yCCo1pcUq0qOtcRS1LdzXmuXIMWiZS7Xsyp6sQzXI4NxSjDUSBCQp4XRUGWZ2uiCu8d8/mq7zPskEqQ56Y/lw5I+q8+pDXDh8QsM/QqZ9l1JG2WZeSml6oTPXFeD4IccBrpeXq6aIkk3UEboXOCrpO9Eay5mi/pXA/s69OiCIFEI9BImdRFjDZMJiOKvGA6njCbzBiPxozH455+bkhn98xfgyFkU6pqmoY8z1OaXav+ed1t3N0IBkjySSmMtdanCUQAAXlW9OhLiD72UZ7EZIbMaL75rRlalOR6JxVz6Wh9CrOVloiYqKuMDmgjkUokCH9MwINVXSFpkTFLjcwx0VK1bUBFhffJMgsFnatZ1Qp95Rm7HK0VxhicV7Rdd801H0Jq2YfYg1e6PeKN/2wvyrctNa//8pfc4m1j2SMZhqbb4bPt6HJgmlkTBA9DgDgYIw9nyJg83hBTZBj7lhG8T0ZqmJj9hYve4zNagY+JP1S2LJorzk6PccKjxjkyV4l72gR8IbAyYqVLaW0pyAfuxP5FCkJgZUAqQUbGwWyXal7zdFmjx7vgO+xqzsXlgkWzRB8bpruaKPy1Wyh7j/B6RLIFdhK9fLMQIHRKmyRmUBARVe6gy6SVPVT0RAyMdh/gbEdXLRDRQ/DMFyusc7TOkeUl2mSUoxF5McLkfQ+gUkiVgUp8hqlnc4tM4jXj10Wbtklzipu86r/G8fqD+L7tSSnBaDxCSYXJDVGA9Z7YJQJnHwLnVxdIKdnb3yczGXu7+/zg+z9gVVcsVit8/AsuLi+5OL/A+qE2npRsXO8Y5plhMip5/OghSmkuLi6uRX4DmvfhvUMO9nYoy4y2bTd8tTKl+qom1biQMkWrW4tqJPUnSgWBDiFN37QOSmcIAUWR0dmKl8dPiKFFScWoGDO/quicZyJzbGdpm4ovLq6SHJyPmGxGXo6499ZD9g8m7OyUGOH69G+G2ynprGN+eUldV9R1w/nZGUrphMoeTVKb1nLRoyk1UuVINQJZcHV+jvc9cCZquu46jWRuMoq8WBvAIUMw4EHatqPrbMJeaINQGVqPCC5C6FjVK5aVZ1V1+NgvlvoGGFEElAw8uH/I7s4OBwf7jMcjjMkosxFFPiLLMsqy7CPQG+ohQ1DZI/ojqayzXFa8fPmStmnX6fC7jK9EoB1D6OWIEldf0zi0TgrzkMLb0PdQxdin3ERITOaZxkhNbjStDdA3r4Ye3LHu89oC3FhnE1K5J75WIlV9Us+QZCDQFT03XyRBZYVMaZimaTFGEGPfnC4D1l+HOkd64wIgeiMT19TB11I9og/z0rPdxImvv2l3+9U2OnT47bbhg+tR4ID0W5/7lqEchioyVJmnOl8IyJhiStnfH+9lL7G4SSTKwQj2nnRUEXygC5a6S8jH1rbYYGm7hs6mxWOggEOIdQo0iC19yNgL2g6USaRWmLquqSubmqldR9s2tF1L03ZUVUPXOYSO12/WOiNxS0J0iNKFIIFShi8MzRMxGSuSmsnwgksBmTDozGN0BtGnP9koMY14T5YVKKUTp2aWJSHVfrIJkbTarinab2UHvz6Dd9t4Nbq7s+1be3DiFefv7iwxX3KIrbkp+wby2GcdYt9HtqbB6r+Tat3JWE2n08SWUpbcv3eAFNA1NW3bYG3iaE2OYvq20Ybd2ZS3Hz6kyHN2JmOc9wSfEKFSSrTR7O3sJIknkyi+EuVYTKUcJUGKvs4eexDt9TSyzjKUApMZtFHr5vjIUKcP67VQEIhR4kMk9oA/idysbYGUUhWCLM8pioKiKJKIuTB0TZ2MYHodsTbQtg5rezyG7NlvlE59270h1ypFl8hkrIRMFHmDTFIiy3DruSJI7UWmrwUOLEmhL3clvUaJkBppQJkSoTKiKtNaL1PJI8SEYh36LDdWK70yRZExLkoePjhkZ2eHvd098jxDKUOmCzKTo1TSSxyANYINyn6zt615HpONqKoqXdOdCTa+ghEcFJe9g2rV0HUJmTUal2SmwNk04b33ECVSeqL3SBwSjSL11aAswXpc6LDOImxHxAKJtV3IRPPkvQVSzS+GVLQWSqYblWepqCrb3kA62i4SQmJEyHOJD5bVqkVr8MEQokNIRds127eub4pNU1cOUV6M/Rq6zRbzpkXhej0OvvrCtzF2Nw0gN4zcsE1Yn/uAutocG4pJST4tsdaiewNKcOtAxTqxNviQgkMRt+jxBtZiKVh2FYI5Z6enXFydU7slp+dH1PUVTbVEC4Xp038DH8/gKAgEyvdJXhmRJFWPpqm5ODtnPq/5roj46Fi1K6qmTryKV5q66dCFunHvxVDcuv7ZOtG8pTW39c10NYIoVJJbGiLnmBCySuqEPNQFSUswYGabZ7AtPhrjRmUi9jFlDH1UzUZF4m/SeHU+3khp/FpGXEPjpUqptCjAhk0U7jq/Rm+OR5M+YhtQz5GyGDGZTJFKYF3L0fERSkbOTk9ZLJfMFwtilOtrmYxHfOPxY/7Wb/6AndmMummZz+esqoqqqjDGkOc5D+8/YDweUeSGtmWdSlVak+eGqtV4m6jWgiRlUIZ7KSW7uwcoDU1InJ5CKJSU6wb8pkkpRK01WZ8li8iUQo+gFb3RMuzsHqCUIc9GFEUiNMizEtvCZduwvLjsa/8SF8A6R7VqSLY6Y2e2v56nQ5uI1hqjU1O89YrgE9I0yzIsCcVtrb0RCaYM0KCAMfRddq3te+9AZQWZBpULzGiXgKHuFEEGojKU4x2keYnzluhcIoCVfXmpZ9C5d7DPwwf3+eEPfkBRlIkOLUBiHEvixkPKersOKNZ9t0Om5fp6mXpEl4BKrTV3HF9NWX69EKjk6XhF18IKRyQ1ywsSOa3WKfII/YqoY9sjgyLep5NUUq3ZAILfXGRTpzx9ZrLe20kvk0SjBskmmRY55yzRB+rao4RBCcNonOO9xlmHUqbvzenTgTdqF9u9j5uIcLPIbmjTXr0nb/KW3+xJJxf8VozB68AHsI4A1z9vf7j1nRiHCWGxnV1TI633G8FZR+IuEKlTU4hELKwgyrh2amKETDtQgtn+Hlf2CF+3dF1F21V0XY2Pib5JS0lGn5ZGrhGuvvPJdslERtzYwMVxx+nVBU3tMEbju0hVV0kXsvPUVUdVWbLhmWzfI1K0t/1INrH6ECrGPgJl7Z1f214k5pLEEjIYNno5poF8YFC8v3YQhBhu/mBa1/mZdPy4tfHXPr4kAT9kCBjO9bUV1Fv29aXJ/V9iJIctsbj06gJ9xkBE0L23r1RCgfP/Y+9Pfm3L7jw/7LO63Zzmdq+PCDLITLJYWSkLECRLKlgyIBsS3Aoe+T/wxFN7YBgeWRNPZAGeGDBgD+yBBp4ZMGBPBcgGLAslqSpTWVkkk8EgI15/m9PtvVfnwW+tfc6970XwRVamjAJqkzfee/eee85u1vq139/3K6+SqgwgPKGyDi/Oz7FG46zl/bv3XN/cME5/xmZ3IBRqwvVqyfPnz4TBR2ustZyfn7M+O5sBHzlnurbFGFPW28Q4Sv8s5lRmdwOoJM+aIlFwcrTtipgm9ruJ87M1zjka18x9uhjjfO+t6UobKaGUjHMMQ8BozdnZGmtalDYY7ebk4u7ut5TaFq7tJBGIsWS8mr47w5iIMTKbF6NwcO73e5FQMkZGnRJMUwQ7omymaR3OKVqn8XE3g4XqktC68PwW4g8ZiXNkLewz271nsx/Y7A48+WxB07WYds26d3Tec7u5xTYabRLL5Wq2qU3T0PUdL1684IvPX/D0ySOuLi6lR4yAKAXwYub9NDvAEyeotWTMss0K8AzmXpKwzvyw3fcDh+UpmZlCmn6GEDLkUEptUvuX+rEq5cVUou1ADhBDRtFKNF7q9DkFYlQYbSVymTwy36MK718uytIBq6P0HpWgOEMIJKLoZFmhBHKumf3YKeJTnHL6oBSZCwDluPFK1lBN699oxJxP/vgwg/yu+55PDOt8viel0Gq06yEbsdBCFQ5ATsq+QlcEuQQfmkzWudhAUamQEggkk1Ba0S16acpPhpR8gaZLfxYSWmlsWbDptGQby0iGViQS0SduN3u2hz0xKNq2YTpoxsIhKNB3cYbaqgcr+ujuPrhXDx7TMVc7GrC5XAnUHaTm79dXH++TOnkfKTXm4jyPjrBmgHNZcf70fHLGf1PHqUf+hHX5kVLyd3/jbz4zlK1T54nLPSrs//VLXiLE1lkBaYZUSYUjSZ7ftQ1KrQHompau7/nq69/hY2ScRqzRtI1jvVpjjC3BsjhCbQyr1UrmOQsFl0IywFhnoHMEP8n5VgklIyoR94E/SgB2ORBCKd3q0+yl6grK9Wol4I6IByI5B2L0NI2AraQHJ+0k6bcFDrtNEQJWrKyUGENIKDTGaNq2Q6kJrSNt50iFwHscx1qGKfSLqTBOyWydtRaVxalZOwqA6MFxnEkuADxlJAONmd1h4m6z4/p2y+JiJOsly66l7XpsE9DWCKixMTTOzTZguVyyWi350Rdf8OL5Ux5dXhRwj/SN7/fSS3XqtLIyO0JOuw0PV9tJTejTd90nO8FxChwOI+MQ8JOwfTvb4n1gexgxRtE0lqZpSaV8mYlS29WWnAJT9PhxhzW9CFmaLNlKHMk5SM/FOIbxACRCnIRuLMPhMJCjgmQwdg1BxDmDH4g5krJBp4DWFA5SQZyFDDlKVuL9xDAcHmRNBQGppaSoq/E6KYfWB3JaWvsbOU6e0/eVQO/3Ah84QJjRo6eHHwf8KKzrMl8jEzZJIeWdkNBZenMmV2LjgKC9FCYL+zs5YXA4G+kWHX3bMw0dRika51h0PXkayWlCd20JThQkKwYuKXQQlN4YEou+wY+Z682G3TRhTcvzZ89IceAQRqYUGGPA7w6Mw4h1H1vMf2iBnzrKktGd/OT4naMjmfuJIBtSKaq8EtVog9xtlUs/9XgqH18T31NG/6cOrL779+dr/UNV/A+Ov/lMUBvp00sAKiwkOvpCZh0JU91foAsAxTjp10q5vqCjS3WrsY7L8wsuzs558vgxwU/8xV/+Jb/56iuSj7TW0DiByjvXlPGKTC6ZWd3HuWQORmecteS25TAID6y0XhTOGVarJbtdKsoL9TYJvynEYtsU3kfGwRc5so5p8oVW0kmmk+UexOwJaWTyBV+RFEp5yL7QvUkycX7WkMtayy5IsJoSjZOh9/W6ZThMhBAxtsc1mjYLteKQM4dhYNhOpAjdcolpLbqxmFx69Ti6fpKMmWNVaTiMNLYh64ZsWqYcudntudvtOAwD25sNw37PuD/wrv2G+BjOLj9ndXZGSp4Q96yWjs9fPMbaRamTKD777DMuLs758Y9/hDYyQjdNoTwDc6+gpWrQzslyrL5xTlxlF+cqplrjd8Vxk3/i8ek9wRCl3hx9iXgKMW1prmrlyFlquiGMQETpWu+XLEwZcK1GVOgBndBZY7Al8ghMhW0BBNxiCvOKVqqoRwcwkagDvnDapZxFyDEFYUUxdh4EV7GRYcts7yEtj+v5OHKgSjZ0WpKc+UHLw6m9rg9GJB6878e4Rj/8ey2JfuoTK+d/smByydg+AMYojVFaxk8KXZRGYYpzb604RoORhn3OVOXvHGH0QmLrfSSkkdUyQFZFyVmBbnFObszhkNgPnu0WYoSYMuMQpGKQBLTkQ+QwBf74yzWt7bhYXzL5DRmLtob9MPLNm3dEnVictTz//IrHjxcYc99fnDq2hwb71ObPDCBzllZfo+bXzn/e+8W6CU8/74OPmt1s+f8xo4GSGeYP/36SLeY/4ASP6+4Pr43vWoenyUt+8NqPv+8fdoA/5LwAUkFxai26b6J2o2bgwjR5BLEpZAo1UCs3lQpwmp9XLjOsWtE2DU8fP+Hm+j2H7YZplNLkYtFjrJl7UFXr8XA4HM9dPGwRu5VssXENdSRJdCIpQruQH5QZsgoI0bonxiBFhSQMKtY6lHZF6NaQkP59iFO5VodzWoR6lWEYPJVeThuDqATWgXAgBDKSYTWNxRUFjRBlKP9Igi3Oz08yb5lLeVmoy0R2aPIjWimsMTStpeuaef1LQK0ZQmLwI7ebA/tx4v1uz1hYc2xM6JRwKZKGLXHckuKERrLPEMZS8tY0ztI2HYvlgqdPH7Ner7HOIgBKkCdZMQQPq3HHHTqXPDkGrzVAolQKyHUcqzrFv4VMMAYhds45oIq8vQ9pHlbNtpGLUjLvl3PA2IIOUlmofbTGOlM2kJTQLIJewo8z+EZWvcz2KcWMCso5E1JE2UBQkZCjLNhcFqvOqKho2jzXtU0WQ+ywZfE/ZIMXJ6o4abLmYqruW9VaZfjAAX7n8ZHA+uPOkA+y04++5uR791ChOT+8LHRxgpLhynMwpdxgKHRHSHARycQIPoIuwcBhDExTYBg8ITrOVp6cFNOUGabMuW6wSqMcbLeRm40s/nESx7nd7CWBKoZvCpH94Hn+6I/oznvO147NCFOUbbDZC8NEUpnluuXLnz7i6mrxQGWj3tR5mpLTgPH0dqt75av7g7MPzNn8zfr76sHzeBik5PlF3HN+J7ni6R4++ctpz/Kvk3GdpJ8z+vXkp6cO8OO/9V/5EVMstFiy7xMJnWJprSTGYZidkHMONKLTp+oePA5Hq3x0YFppnLE8vrri+tEVu80tw2Hk4nwt0PoSPRljZq7XYRiO826ZwpAkNsYYQ9O4MnubmeJEVbSp4Lz5/ilQWjQpU65OsM6wCbLaNk1Bamoh+c7CaoMWPUWthUwhZ8U4HqQHmT2NalBaEXNluwGIBfHpsNYKixYCkKktBAmME4f94ciYU8aV5vGOlJmmsRCRW1xjaLvm5GmJUsR+jNxsDnz75prtMHK938s9UnDVOEwuwLJpTxr3Qp2I2PkQvQQ9yKzkctXz6NEjHj2+KiMPihgEG1LZaETp/jR9O+5vcc7HucCcH+IbqkOcf3X+/qceP2BYPmGMKAsrhBF8GA8YG2l7WK0a2sbRNBrbtoDFmFTANGmGvEq/TgGJmEZMVNhkSY0lRUUMmmmcyCSMzWSkJ5izJaUiIqsOhDCVQfGi7B0EYGGNxTUChlF0uNaVsoTCWk3XP2SMKVmQKn2InDEfmBCYzcoPqRh95HXfB3yR9y9Zw0fLoaffK19lIz18x+0m0japkNl6yJHeKYmYEtzdDow+cRgT724PDINnOnjaRogK9kGy6hQTV+cJGw9MU+Qv/vJ3fPW7r/m3/62fcHe75eXLb/iP/1+/ZrPb0HXdnLnnwjErm1eULpa9Q+VA9J40BZb9gt44/vwv/pxffvVLXm/eMIQRFxTDzjMNRQft3tM42SB/o2b9U94r3/ubPN6EMAkfrWRVd0xl+97XeKi57F/n3E88699s1fJv58gIp2c6gkx0mdGpyihtUUOxzhXBW7k0UWMXB5WVSP4oCmijjDpUlO/5askXL57SdUvOzi5omoZpErWSFMI8H1hZZASHUEYiEMcQU8BYhYjtynhAmgLDMCIZ4/1AqumkJaQ1hbtU0bYdMY2k0dN0HQKw0jRNQ4yVIUWCIW3bGQU7ZiVVNIRtS2lDY9p6CwUQkzJ+Sqgc8SajTcRPkJMlBj3373dbkaASuaZGRp0QDEAOSQbljTrKEalj9BxT4le/f8d+v+er333DGCNoS7NcCSCpzG47o2j7BkUsEk8TfhpJCrR1NF1Pv1zz4sVzzs/PefLkSQElSdlYZJrU3N6BahfrFT8I2bJMctdK2Clxyf084kPb+SnHJztBo9Vc39dKQ1Z0XXVMjsWiLfBjoQ4S5E48RnLIULwr9f6Uk0SFuUR9Shfx0SLjkhPaJrynUBEdG8911o1acdZaygtWHrAtmlkSYZoibimRmqis3y8fpVx05zJSg6/nlHnQLMon9bPvLwk9zBZPy0g1m5xLY3/gfe7//dgLnB1gfrgY4M3bLT4AKuFcwjlobUeKmRgS+3Fi8onBR1AJaxW6NTgLxkDnDIILlwFkcub9zVsOw15UrENgmEb2ww7rlGg+nvW0nQwOVydojKJxHEtOXSSbgWQCOmtQkd9/8xvG4ZZnj5aMXiDqxoqBiQ+N/UlV4GEy9dfyC+rBX79379Q5SH2vMgBpRprWaswxLBH0Wyprtf7snwUf9jdx1Pz3XiCX0mwXjBG1ef3wYZ68fi6HKcl2SIk0o7mF6aXvelbrFX3fyXuVWmJOx1GiGGPZvmrWo8uUalZMZc5PnpBWRpDkOQgj00eGr3PW5GSIQfZx8GI/lEokJgnEtWLRN+SkCKGijRXoVBCdpf2TxQEHn1FFHk3p6vyrzFMgeil/akNBziPBRpKWkPepUKPpI6CnzOxJ9iVWJ2nNNCX8dMJxnDN3u4ndfmRzGIQ/1GksUEdArLM4o2msJmlRAHHOlvsryU6/WOCM5urqkuVyRds2s8OTx3KsXH18zvljm/Do4E6WyMn3j/b1b80JWqdwjXhoawSqap1Ba1FRdnZRxCUNMUoEKMCWMneWhFi7acRJxqQIMaB0QufCyq4NmEZq5STQcV4oQtrtMKZBOwXKlOjOYNC0rZ1LYNbpUjaoCLHiHLWlcfcvWfqEMsohrDEyhK8elJtOje7DfuHp9+rxh0Ydyt8+/vsPfu9hBphSlgSklGlqueb09b/89WsW/S3WJB497jk7azk/X+GDZ/CR3TQRUiSZzNWjDmcMTgnHYSZB2wjSVmvSeE7rFL/+6p8Q0oHFwjKOA8O0Y0w7Xny+RtsVz19cslz1WKuF/q4M7S5aW5w9hfZqJKkIoyJNin/8j79lvWz4V/70RwzpQMiJkBVNp0gP3MUMn/5BKfkPOP7AW1YjKv8Q0VddMhZVnGJ1hJryvIqmYFbiEgGU/gOb9J8yyf3r/voPMR4ffMjDf6sjxSLVCKZEVBFrLMYKFZlIHckb5JwKX3BxljXzL1mLZJAlmwCElUrksNbLBU3jEDRw/dBC8hEFm1kzQj0HpUdVlhDyfBnGiDpESpHgg4hynxwhiFqD9w0kSzSa5DPaKNCZuN/PgbB9vCJnxWHv56F6peQzYxnkrzOsh4NQQorKhhPdT2xpMRzIeQBESsjYMipmpR3kp4gvQCPnCnI/hhLNl6ANEeXNybDbjGy30/zccobrzSjI7KQwjQVjAeHidU1Dv2xpiTQpMsVI2y1YLpbkLEh9ax2Xl5e0VvP5F5+VMThhGEtRnJ/YrCP5//21d1rbLMuojjHV9aFOGGiKQ61D+T9o/Zbjk52gaxRta4qgYYPWpbZOQilZaAp5KEprUjZldCMVolmR0hBYsEXFzJiNcIKW+rtkHpa27eXCFSwWjpgM5IaUlMCstSgTkClRkaLthAcyZ8lkrNW0rZtvmix8g9btveuqBNSqRhD1f1nGPGZtxDld/7Cd8119u4/1DU+dWf3zYz3AhyVQAa6cgIbyqXSLcDHOBTcFl48WrNYdisjVkyVn645+1WCDxnUa060lAFDQOIfVGqeNjD2kCNZKjwPDYePx6R1/9e0dO78n6Mif//r/TcaT7MDP/85jtMpSjnaSads6L6ilmZBLBm2cQmeDToY2KVTWGHpaa+gaSxOFc9ZrjWoVYXxYDxWDKEHgp7NC/PWPB2wqsxgkKBWQUfmALdmdrqXpjAzR4+aAKmVV5lSrgf+nPU5LR9/vvb/fNHzH739ynPEdHccM0U8k71GqkbfSiqRzKRULp2cpL5V9WDLHgvo7RUPXzzCIWklUmmw6TLOgKVI+MU4kryELOtlQNVoyyU+SWRlDPFrRsq8SuVQ+MgVJqjPOaVCWxh3bKDEm/uJXr/GT56u/eomzrhD+tyIPpTUhjfO5f/Nyg5QCfelJinxU7W8WX09OmWHYkVIQgEyxsdY6Ykz4KcwgtpyT0LQZhbGGFMRZb3cHFNB23YyGVToRy75WiIqEQjN5z7ubzf0nZzSmaegWK1xRSmmajr5f0HcdzWrFonEsW0dWmn51QbNcE7PB5syTq3M6Z1i0VrLFnIvEVZ7nkh8i4R8umvslT1X+rAvypIp22ne/l0P8LWWC3/5+g52FIa2kx1acIERSkIhBZvgywu15XAjTGHCuYdEfBCGUErvdFh8OIooZIxI7G/puWVjHC/t5zkBDEt1WkhJl6bvbrXCPFidYWSaaZpLSbNNyyiqvUWxuj7xyOWe+/u1XItY4N6yLw+QYNZ7Oq9QHIt96UCq9d3xP36aUBcpf7/0J9/lCa2+klm0FCQohinCoD5Itv3//7iS6QuamBiBHNhsjKD2kJBRCoaRDnKA1k5Q6ZieYQJtSwNPsN54QUtFCk3N59eYG10h1oG1KWTcNM1JNZn/kHqlTiKeuzXDpvRoU1lis1lity9wnhNLU32wO9zbNu5df4afDXAr5p0yY/uCh6n+PNpP6yVr5D51gOhZCI4aMIeOIygjiT8l+uHv/el6bOSW+/eq/5LC7Pdb9To4fcpXfXUj68LvfZSc+6fNKZH5EAInTevfqt8e1mxOv3r3ncJhQqhEHIUi3wpZi5r6xkuYaIMjmOfjjCJmod1aR8RgihoDBDxvCuEPrKIQN1kG2CPRLKk4CFomFFvA4mA8ZX2i29EySXc6nBCshed7f3s13MqXMr796jR893758jzMWow3WNmUmURPTNF+Dc3eAYtZa1cfgGua4jhwz47gTKkh9JA+xVhCVOeUTJLdQVlaKNCEqjxyGCYWiaQ7M3L1atBFjdYJZ2igxRba7YTY+OWe22y0pJ/wkIrY6RGISy5xCwObE2LaMnZAR7IMm2m8IKRPCxM37a7rGMDSWrGSIf/KhgGGYK23HrO/4HHJJmh46QbmO4xC9lNKBWm3LlBlU5uu4vn73h9dwOdT3eUx1ArETRNEnvSXfH3eevkk++e/HX/HwyN/1j4/80sfeJwPppLRxT3Dzn+FDyqTH+r66l758mL3+dT/j4fFfxa077ceoIu/yz/qRH2SDRwP8z/iR8711eK/Xd+/y/oavVWp93/H++d4fH3z0R79/YsdyKdKdbAB1kkl+/DP/usenWsOPnfTH7O4fsMf5wRWcjsDULOzhO6qH3/3Yvfj/7/EwG8wPZ1xOjk92gv/8+OfHPz/++fHPj39+/LN4fJ8T/ORyaNs0M1KJe3Xah9nGx3/2wVEqTDFEocoKYU5970X+H7xP7QeVv3/gpuv3Tvsl9Sflz5NfWqzPMPrTtae+61p+6EvqfbwXT/3QQPIkGEwpcXt7e9Kv+tvIKr4rt/7hx8fi5/vP8uPv62zloHjwinIv00l29Yfi4ntxrpqrtyevVeX7ZaS3/GLNRlMtU5fPVEpY+3XZJ6mUfB4CoUTLDhFPLcf52QVG63/qWPq7w92Tv39XRvTg+K6W4Pe1CmOM3N7dzv9eLldlTOo0Ms9z1beCZshlzZZxiO877b+942g7cqr0ijLmMgvwlmOxXnz/HvvgxL/jpn9novZ9Relj5nU/BztZ0R9734+cboqJw/Yw/7vp7l/Xh2et7n3/+57K97XlPjyV492ef16u4eF6++i+fpDFV53QTzk+yQkqpfgf/ff/Bzx98gTbSm1f5lDszIpQv0TUULj6rLXFKBznY6ijDUr49v7JX/wFX3/1FX/+D/8Rfb/k8uKKt6/fF5kUWCx7nBPkZ+2PjZMIaAZfSV6F2zLEQIiewzCQobDMHBvJOcvw7tuba+lJWcv/4n/3f+ZHf/R37l9wLoTP5HlDflfGXMmpT3dzLphGYWjR85eVdghagStSJ61zWKOxRmMUsxSKzO9IbzVlIXUmU2SIRPGCUgHKCr799hv+3f/uv8VuuwXg8uqqoO9OSgO1wqG+e4HOz+mDHtiD788rNN9Tszh93zz3jR6WvQvwoazwoxM8Oo2cjwPAwzjIvdaK/9a/+Ix179BY9uNEzAnbWrq+w1rHy5evZyWTGKtDrEhCUQmoBrnyPWal6TpHYzV9IywWKieWTgRGV13P9nAQGL3SXJxfslys+PbNO263t7y9fgsK+q7nyxef89mjS876jnfX79lPE7txQqsMBcj0+ZPHHHzm3/sP/yN8SPRdz//tP/x/8MWLL0gxMROv1h4vwuRBdRJ1bap8clePDhtdPXr9iZqh8arc81zWTe0L3/uF+ow45V2VFV3vZX3lQ/3uX//Vr/jv/Y//baZppOt6/tf/q3+fi4srQgjsxztCmgh6JNpINrBY9aTR43cj5+fPaRfnLJ68mBl1mlrm1BCrwngq5/O9XvH7XeY95qFyH0LyDOOBYdhzd/uGFDw5RBpreP3NS/6Df+9/Q4yRbtnxP//f/89YX66JqcoF1RsiSFdRopdriCkWZqcyN60URp30yU/KrblIOuUcZ2ty/5psOXuNTl60L3MSKS9tUQXVatTJnocTkMwx6NNa8/tf/Z7/4H/6vyXFRNMt+Hf/J/9LukJ87YMQkeQTRK1SWlAgSTEGwWtoRP1HIr9yHSkzhSKVl2u7V2E0WF2ZqwTiror4Qs6KmCuuRHq3GWYykxpMpAI+S4XkUilobeUYlc+5fvlb/qP/8N//fk9cjk/OBPu+Z7Va4ppGtLScDLhWFd/6ZyWFlQFYO0fGMyRZy5kqpbBa9MIWiwWNc3RNQ9919H2P0YGUhNfPGkFtaSWITVsUomUOKJLKwxVEp77XdJ7ps4rRvh+BKNYXl1w8fnJ/nYkEqyy12QnWt7ifaWl1lHEp/D3FeIjDcro4QW3ECQJGQ2MNVmu6RgIJq0XYVpd5zHkGokj+5kI2rCmST9V5ZDFmPhzVIur5zVyJ9xrNHK/n/kVTQ/OZLae+P8W4nnxznssBUHU8/EhDffSex987nY+UBvjpZx+fiareOt83AQqRoGmsxhYx26TA9Q2Nc2itWXRleDgLvVsuH2z0Ua2gQtOrVllWGqNlvssohTUKaxxd0xZtNYH6ZzLGaaJKDHFiP+0ZpkGYiWzRiTPH8aAQpwKQCCW4AWM1fcM956+U4uryMU8ePxeOy3rR6TiAn5T+QKpJqzQnGbncX60UxcLI86i/wwM3p2a2qXtZxHE91Od5GqHXCOpDlpz6l9u72yOADFg0DUvXMCXIpiFag14sSDaTbcY5xX64Y7fZkZoDpltycbYiawF77N9dY5zFmobV+ZnsxwRkfbodHy6hj6yr02s7dYJy3xKJw2EDOhHSyHK1Eim4nDFKsVneHd9eKVbnK1YXa6GOLAP5MUTZ4Fp4lKvDC+XnKcWCUNfYIj0GxyC1vkbsGPfAcPUh53njC/mAKuTYgnoF3cg8tDE1o5Iqhi4zhzJqJs5Ma83ybHm8Lq1ZnF3QL8/IOTP5JLSUHLVBtZaxpZgVtmArTAnIMqJ3KJRzGSpva84lnxb7ZpU4QXGARycIipQ1FCkltJmdKCWJydWpIqC96gSNPSYYGY3tlt+dZD84foCUUkErVXTTCWO61g+/VHmNRBCmghmUKorzx6ikvk4GQ+XfzjmJCkIqUkvFGdTFEqPM/qQ4oxVJVb0i3cva6r9TEmqe+FFo+oe3ah5ozvn+XMr8c7knldJNosmTMYpMich0QV5qDMcs0JnyPa0w9X3q+9agp0bvqoTCiqL5x6z/hxKuxTnCq9edhZf1OKrxwP2r48aa+fuOgekHCR/leipStS5IkJChDu3Los5l0dbMsDz/+pFz1ijxXL37Hw7M5vtRNjIQHGPCGkXTNihraBdtecZRqgZaBoaTLpGqNTTWYY3MKwbvmXIgmVx4Kg2Dn1BTRkdD17cY58jGMiWReBr9SEQ+d7O7I97d8c3r1wzDwDQNMhBsJm6HPTkHrrXm5u6GKQR8SnTW0TjDsjOM44FhvK9mUqPlDGW/lD1XFoI63tl549enmss6rcPZSp9kajWIS3XO9bhe1fGR3L/tqLLujz+trmMuEZ+wFJ12W06BMDlnpu0dQ1YcdgeG5MFplv2ZzAWTCJsdt9++5eu//CWHxxsef7bl6Y+/AK0Jk+e3v/zHNP2C5dk5LxY92jlRNRfTe3LyJ1cxX9fHTOAxWJvvkQFyZL+7Y7O55m5zg6EG8EaQleG+Pl1KRYnFR8ZhIkyB4TCIk9LQLboyDiG0bTKHGARJagxtc5yTizHOf4YgSPkYppP5xSD7KGeylnGjrDM6JlRKqBjR1qKtw3UdxhpMqcYpJaoo2shge9t1pWpny7q4bw+1kffJKaNSLIlGnsOhukZBtAc1YBWgZNZ6DJL5RiQ5keBMRlVUyT6PgbKef65LxUFTxbmPWGCyCArXoCDEY7pxuhd0CVYh4mP66NP/2PGDnKB+6LyKw5t/fiqCeC+FVoWNgXkHH18vX0YpSAnvJ+Hai7nM0lQnFk4ipliYFsqADSezfbPRZ86CKm0SPECrUVPyh7frNBKuD+04L6Y5li2N1rOzSicGXpXXuVoORRaL1pIdusKmYsrr6qD18byKg6pBvTp5TXGEdRdLcn3/Gmqsflrfr8tszsxKdl2TB2eP2WjXdejCsxh9JITENIZ5zkeb+qw1hykQQmT0ocxqlrmrlIvRtlVa8Ojo/kC0Xjf9h09FlfgRmsahrWhTDuOBaZxwrcMWh6yDJyEl0JrVpSkwIeTI3khkHXPE+xGVoT9/RL/o6PqW7fYgenOjp1+2OGuIRrPdHNjuBvZ7j1aWdX9Bt2zQVvP69paNMVitCH4qzEgZ17RghGDCWIU+GX9MOfP1t6/RbkHfNqyWC6mAqPL8Mmz3e6YQmXwoHJUKq48GtGk7rJUWhG3LHgTiOAhaMyPtCWsYJy/jNTFR6+MKcNbirEjgaHWf1iorhN2JyuRYpIg4thzgKE5bn9h2d4vSMATPYrXGtS2N7gmTZMvj7sDdm2te/e63vPmrX7NcrXj7+1/h2pYQE3/+n/8Fz370E378iz/h6WfPMVrK3D5OUEraNfhW86fWBfYgcr13ZpVUXhN9IISRw/4WP24hDthmKXssJ0KQsaLTQxUmhOgDm3d3bDd73r1+S0iBRKJf9LMT9cEXqaZM4+QZtK1wduacZ/WInEXmKcVInMraSUe0rcrIKLVSKKNgCOATJoGxBttYbCfv77oG7azMbGuwzmKbhvOrK9quo1uuas3l3hFjLOMk4GMiJkkcdKkyWC0Xr0rGVaiZZ2fkTGkDaY0T71hsbslk5wpRuY8lGDOFtjKjmGurSoi2Yy7D9rkIYBtdXqfmz21NscdK3uXg7N9GJlhufjH4R4t9dHryOnXvC3X/56dOUHHfYcqdTUWtIheqtLIRhT0XMZAlg5h7TfloYE/Klffem+KgHgJeMycl05PrffDFHHmrOaPTSmrc1eGI4ZBs6ZgJyusl25M/a+ZXwf7VoEgWqAqxL5zq2dWHXVMB9eBkH2aq9QX3s6uTgIWM0QpnHIuuwVnDojUoLd9fLJYSMVpD8JHgk0i3FKNbh35Bs9kPouC9icXAVkdYHoeS+ShjTYlujxv7NM84Pd+cayZ+/6Jy/crMlYmQ5bxCDDjXzgGJwUjpuJSXU4aYgjyfk4xJlcBJk0tlAsiJYRxFRSMmOiArRQyByXv86CGX+9f2uMaRVWI/7ki6BHX5qOVojaV1jr61hV813Lvml2/f4rolq0XPFANt09CawpeZM++ubximiWH0UtJSGquZneBiuRSyAmsxUzUImmkYSCGgULjGYRvH3WbL5APDFOaSHRkWXUvXNqyXS1EYN0aypLLuUi4Rd+nT1VJbzRAokfrxusD7gRB7slEi5eOs1MxCIAdP8hFSRJMI45aRic2rrzHW4ENk/+4l09UlyU/CAxok4Eqi+kzWkm0ZrY9qCSe74zuNoJITjEmoyLw/EP0EKZZqcqlmVPLsjxSQUpZMcLfds7m5492r9/g4kXOi7du5FeRDoJb2XVOcVHsU+PU+FCBOJpWZxRz8vYqLmFIhxM8gDDibiTQGGoSJq2kd7dJiGoPrG0zjwGiiAtc6XNuyWC6wxkgG+BAPmCkVtmM5turBzpUHdczjpFcnxseU1VBMwrxXKbauLotTspDMkcZNqxOG3dkJlueUMkELoYku+/7od+T3nCk8xYV0wc492T/sBj/dCXJSEpz/VMUAHzPE+wPm9WdH1pX6u8e3kA1rixij0opxHAoPnTnSDGVNUqmAHY4ZYHWOtZ6einK1OslKT0sO94+a5B+/f+p05sx3ziLlki2FqaFkg0cHVKPnYnwBy7EkbHSpiRt17AHmI46hZn7z/SmnpdXJen3g7DKyZrRWH/zsg9eRMSSMyjQa+q7hYr3kJz/6jPOzFVfnC4rQDcvlcu7zpqSIKbMfPNMkUa0tzPQpw5u373n3/oZf/dVXvH4n8iup3kWlyTnQtj2XFxccDgfGcWK7Pcw/pz6F+fkcHeHDI6UZLzKXTEKKIlejcyF0kQjWWmmsh+DZDQdSCFCJva0YeFXOwbQNNoNKgTAkwnRgc3srvQ/XCgl0iOx3e8I+wBRZup5lt+BidQYuMYSR6/EGTy1vR5xRNNZwtlxwuep5fN5g0sRml06uKfGf/tmf87u315yvlzx9csVy0bPqenHoKfPr33zF7jCwP4z0fY+zlsZaQhBn+ujqqpTANMpKtNw1Lfu7DXHyOGtp+w7bNvzmt1+z3R242+7RthFHmxKX52dcrFd88eI55+sVVxfnrFYLrC295izlN52ZQVz5ZKFWQMTpqpv8nqTPaNcX2EWLUpqw2xCmAylMaAKLvuXps0ekZcbpzMocOGyuSYcDj1eOxxc9l1fn+Gki5szkJ3IRGJztDIquW4jSQtOWPK+uwfsbQ2LpVDKukWF3yzTuyX7EKoV2DSkce3NicB9CgERZ57AfePvqHW9fvuU3v/xKGHJioHFmTgJqS0VrDU6jrAQE1TP48gyVKpUhpbDkOcM1ugAPC6greM/N2zuuv7lhuBs47xasVx3r9YL1VYvrDG7t0I1FGYNXGde1NH3H2XpNYyw5JrJ7eEWCscghiOB2KjZDQVPsndGaWKSQQhS8gjKKxkiWKBlduV+q2lCxiScpi1ToytKpiQDUhEMf7WCWFxmjJViFAmir7VdxpE2tBihxgrXc+ynHD1CROMncuP/3+y9T9/5+ryxXnGAu7wcUleSWH/3oC87OhHH84vwRh8NQVOWlTr7Z3uH9VL4f5oglROkLxlS076JQu88l2NOmc3GG949j87+WkHSNTjg69hoEaAWOjK0LtNTda8aaM1JPr06wlEPn8qlSWCWMNPWrPtwakVOIb+u5SCYp5zcXf+8leB/2LFNhwRGgjTjh3mmu1gsu1wuuzlesFh1XZyu++OwZq2VP37fkLMFCVeIAhdKF/QHDMI5ieLM4l2maWDpYt5o0bslh5L3K3B18Qc7Blz/+jM9evOBnP/tj/uzP/pzXr99wc3MtwsoaKsbwntO7l/WfXquUQqYQYRrRSaMsdH1H17Xs9kPRvkx0ui33TyKNZE1B7knGNGUIUXrMzhparTlbtFKyMpq72x1TkDJVZy3WKcZDnoMZpwwhBq5vb2iXjkTEGUcK4gxq39wqjYkRFTx5ykzTwHg4ijtnYB8CN4cD+2ngdn+Hc4a+bclZNvXN7YYQEyFlNnEqUllqXs9v99vyXplIxBTmFKc0OgvbhzKarBXvb++YfGScEugJEEj5zf5A9+49L99dc7Fe8+TqkhfPn9J3rWSm1uCMZuGckCvnXAKPEiSWbOz4CDPD3Vv8sqdZXRImT8yZPO0Ifk+ME8oZ2s6yPl9x8aSjdYpVb7l9kzjsHRdccPHkim7RM/kJlaJkSbNfliA4ZzDakRstYJHTxmiG2veu5xX8RPQTYdgy7O+Ypj3eD7MdCD6UgFZK7/GBnEmmMLiEyLg/MOwOTPuBFGsmV3riSFZSQVlEwIAKtb+qCMGXKFXhjJmdjbLiRJxSQmtoDClmwhi4fbVl8+7AsBnITWDYHthtdmR9zvKso+0tXWsxxjLliFEapzSNNlhtZlv38MhFmSfnXIB2pf2ljnlVzBQdVyV2Klc7n1EFVJhSJpZARPq/USpj+ph2xHhMPyqWSxK/+yCYmEXVvvoN2VuqrPWqA4u0hJQE7IP/dFrCT3eCcDxLTv6UWzf/8RCFWDPF43vcR6pZY+jalufPn/Ho0WM+++wzrG2lxLDZMk0T0zRK/2AcmPwoIpmFPigEyf5ijKUklsS4FieYCtQ+lbmfD4Ex8kjqY1SlbHmkTSuOYC5hglVZYL6Fsqj+rHJ7JrkRqIyAX1RZ1ProSOevk3sxt8tmKYLy+jmzoKD5pNl93NYfzwKVVjROdNJaZ7hYNHz26Jznj854/uQR60XH5dmKZ0+u6HvhPYwlm66zkzlllHFgHNp1HIaByU+EEBjHgcMB8tRC7NldnXFzc0uMIqBbn/fnz5/x05/8mD/5xc959fJbtpuNUEgpxan8+cec4MO+oGTbEsx479EYrBUlAaM1293hiLJLCbSUOWWTKEzpixnrCJMg03JMQu5e+Ev7tsFZS+cc5EBA0LzOCorXalEqUYix3I8eXI82CqsMgSIka4Sqz6BQKaJigCAG+KFO4pQSh2linzybQ0QraJqmKBiUqLv0z1U1yCeUemq/FcOTpSyslKIxllXb47RhGgdiTkQyBx+ISYkCTEWYxsjuMGAU3N5tOV9t2Oz2xAzL5YLVomfZtXTOoZfQGAPWzJmgVF4e9NxzZtzc4M8uIASSEibPFCdCHElpwii5b66xnF109I1m0SjS0GFVIrg1i2UnqNwYRMcuBioaJ1XtvCwclSpaTMoow/yaGfg1rzPpvcVpYBr3TMOOaRL6xkrlFguyUSldnsHD4FneL8Uk/c1pIvpALhWnnIqOZ0qoxs499DoydLQ1mhwCJeEp5yjjE1L+E3Sq1YpGa0IEFRXDZmLcTUwHzxglclY6M3lPFx0GRaMtzgh3rdJGgrETAGPtB9+7prm/m2dmuTrnCXXcIUumWO1mMT9CeilJCYXWMaNR2oLScy+7XKpQwM226tj6icX5yT2sTleepDT7j9kk85Otf4oTnMLfAjAGnY8osDnCqh77lA/uI2WsE693fIsMaeLxxZKle8Hjq0uurh7x5Okz/t6f/F2mybM/HOTP/Y7/7D/7B/zDf/iPePX6W3a7fdEYZFaWzznO2V46Ld2eOGbU/XEBOGZjFRAiIJ1j6fMU7KO19PeaFDHFEFprZhSs9LpkY9Q0vymbqjZsaw3bUBfNxw+pk5eZmoIsrUeFtsu9hjpTeHp0fcP5esHzqyU/fnbF1dmSHz+95OnFGY/OV1xenOOckNyWEr7cz6RIaEzhK4xRMQWFyoauXRRVj8jmcMN+u2G32TAdBloT+ckXVywXlnc3W/7TP/8VIWtc0/M//Hf+2zx+/IjVcsGfXZzxbtlLsJBBpwz5AUn2yfHQMQbvmYxcr84e4zVttpAS2VqsPDTQBUUs0FVBNVtNt+hAKVJWHPYDfvLEYYRVj3GWtnEsup6+bXl0fsZ+nDj4wGrV4xrDYToUo515/XLDMEwchpFm6Wi1FcLmLNFp6xxOJ0xO2DBhgsJEI9nrgyfvk2dMRWFjkn6XOgzUHqg2Fm1kPlfFk3ZAMQBCOiFE6qpo5Q0pM+x3GCBOY5GxViTbkUt2n3MJx+Xho3Lm4CO3+4Fv377jN9++om0bVosFF+slZ4sFP/nsOVcXax5dnLFYNhIIaubKyfFxJd5//U9w0WPsmkeff4lpGw7akrQhZk0Mge1uy9u3r0nbQO8UZ4uGOA7ElNne3aHXt7SbW+zqnKwt0ce58jJnaMVxYSIqRukH1z1yUogTsvnAtN8yjVt2m3ccdrcEP+GatsjFaYYCapISpSalB2u0tHlMQXnbAnYLtS9qtWxLldGNjJC5xpKy9KS1EsCWNQacnatatQphT9DjrdE01tI1joDG24hTDmcMuTE8ffGEs8slZ4+WnD9q6fuG1bqnbzuRL9MtuTGothHdRmvmytTDKm9IioYj8DGjpYUbZZ2FHItjkvKnZIiRTiVaIut0zWZ7w91mwzQpUrNCLZ+g2qVUlE6qHz7mY2MrV6xoxsc0BzZ5dq/lYWpBn0owXLNPjkLNSNA4xQ9t4ncdn+wEZ8OruAeJho8E6x/73uwIS+kvJZL3NNZg+oa2MWiVCNNI37n5QaaYOAxr3r57wTcvv2G5WrDZ7ks9Wkl5pSgT1+won3z+QyP64WkdRzmqw5N/V8eo54hNV/BETrOjnAfcZ6epSJg5EzQFIWvUcWD7FAhzivLMpeZQo+kaLc6ZYtVh07X4cO+OH69JKc5XS549vuDnXz7hJ88uuVoveX6xYr3oWS1aFn2DLfOdddhd1KhlMRpryFkyj3GKJDLeJ7SyGOsYxpFhHJkmkcvqWsti0aO0o+t7rncDxvV0izWPLs9YNI7ovTj+2vjO5aZ932J9uNYKwCWliIkWlHDBhimSo6B5pckuc1s5S2lGaYU2GWV8iUKFrYiYsVmClcZatDKC1gtSFtJa0TSGYRwYvSokDkaMQyF0z6mi6uQ5YxVkTesMjTG0JtM5i1Oa7MFPIpB6ui5TnIhhFBR01b9LcS6Z5ZzJMZKiL+uCGZkNkFNE5YQhYbX0uw7jCFqCnDSNBVUrw8g5yWhNbQbUkZs5dyrRdzrssNPI3k/sx4HbbktIgavNmuvtOc+fXtL3Lcu+R6OYTtsNORP2d0yb9+xvv+X80RXGrNHaobSDLK2LjCKExHgY0EGTGiMtggw5jIRhy7S9ph0eoWxDCqDtEeJfs7eKpI0xolUk6WMGU1dPToEYJ/x0YBr2jPstfjyQosgAKaOKALgmx0QKHlWytXvLUlFQ8npuNxitRUs1ycxpRdBZU5RtTHEmuZQJKf0/K87BxFhk6tQc/FptjrZHKZzVtI2hXzQctpocFReXax49u+DxswtMm3BO0zROqiNW5mOzNahC9F21WWtb69SCCOhM8At1HfjEXHlL8ljJyJyquMnEmQ0sGPB3rxiv37G9vmaIimSXsN/TPv4S2y2lGlAy3lwKPYlMyNUUCEm4qNPX6ULZ1xnZa8dp7yp0wAxurLqeDybGvvf4QU6wzveX5fQg+ys38oH3U8XxyWNnvuk5i8NzRrIWqzLRj+y2t1w9eiQPsW3LnI3n/fXnfPXb33J2vubbl2+L81NlmHM+oznmq8dDt/fQ3Ori4Mw8rlGGmku5U506SIqDyKVkqvLsDHV1TLkY+cqIX5xsrYXP9+XEEc4AntI31brcrVpmKOWTXJ14LVPU+/uR4/J8xefPH/Gnf+dLvnxyweWy47xrC8PPCcuPtQIaShlU4WBQYmRyNihtSXlP9BmGiGos1rYMg2csQJllv6BpGhZ9R79YcjauCcqyXF+wWl9yuRYGit1uD0kWdqaWyb9/tX7YuYhlViigoty3FDM+B0IQFGYugZYvWpQ+gDYKrdNcOYg5I4LnmSYrWitZoNaacfL4UQAOSkkpdHfYE5MIm+bUkqImRUVOsiqCDzLI30kErxS0jaGz0ovtnMVpQ5xgGhPjeJTFykD0AzF0Ul2BoqAejiCvlAgKmJiBUNaekG4XGLtRmVaJMsJmEKSqApIfpGKjDM52JA2RCk6QZ1JHmmI+8sSMozg1Mw7c7bY01nK33RTgzBmBwMX5GrRBoxgmf7LJMumwYdq8Zff+9/gXn2MbizYLtG6ktGkgI5pz4zRhoiavOgGMAfiRsN9wuH3H4tFTdNOTsp3vSypCrnaWdsuzvNjcfSrzjkplUYGPE37cMx12DPs7gh/IKdG0QhlmjS0IyjgDj1KY7q9LdQyej4xZkjUJAj3N2ZQ4wIzRMkQekSF3GSlUNE4QKi7n2S4Is4oRp6XUzD6lrGinrs4atreaFBRXj9Y8e/aIFz96ysFvICecNkXWSUSLszVgZUbRKDPbnIfUbymXPmAubZdc+nHVY1GcUBlp0ApszlzaA8u845u7b9i/f83dm3f4nElmQWqusYsLjHUk1R59RMlWcsqEk/Oo41X6pHJWnWYdbJHkIB/nq1WuUAqMMh8wGX3f8QN6gqcnefz6WKPwdBh6VjOujWwgTBOH/Z5vv/4NF8ueZdcQfeLduxv2+4H1ek3f95xfXND3PVprVm3HZ8+e84uf/4KvfvsSH3bEWBxIiUxUeTg5H8uhcw36gbOmvN5YXcQpmWG6tgBKjFIlalLzYjQkHBKxGS1D77XXl6tkaioRaD6CW5ScjHxuLg+vIJtqFqlKjbTiY07Lx5ItJJSpEVy93x9mUUopfvr5E/7ul5/xiy8/46p39M7QOlc+6OjY0VoyjOJg6wyodY6M6P5Z15SJeIXTDdZYHl08YqM0JsPl1SParmW56BiGgRgjT59/Rrc8p+1XjIcwz/nUmbIaifKgL/gHV6FVaFumN5U47qwh5CRjNRUwlQI+BJHeCmouTaUC/MlkFs6xXLQ8XT0WsdDOsuodwSi8ykx+RGUxWsMwMk6eaYpinJRluVxgtGTS0zhidOTq8mLuGXZtQ2MUjVYchpExDSQPSSvut6YzadyjplaG/VGgwdlI0zis00zjVCSBAjnKfQuTKvexrK2cCDlx2N0xTZ7d6LFth9ZGxhGioB3tYs1cX4hSP9HzqE8Nco//ltLjxBQNMWlCHLjdb3h1/Z7X17cs+gUXZ2ucNrx8+fVxTCKDyZE03LF981fcvnqK9xPN2ReFpECyQY3GakfOIsg9TQmTAjkGwmHD9Op33N1uSNrSn13Rnz/lbrORcrpzKLXGNc0M2Veq7MOcEao6L2VfUunHHhgPO6bhQPQC8pJ5voQOGW0yje1QSeHzSA5BRjlO1ujpWqZmdiVzExqAOPf9T0cuKtGHLqxXSklFQoTJHbbYBaL05WsPT1oioh3Y9w0vXlyxv9sQ/MS79+9YrFseTeczKh40ZBEr08aQjUWZBoVI3tUH9DBJSFoRFVJJiYmYwIcCBlN1DKxUBuOESxOPzJZ8d8tu3PD27Vuchs+fXPLq9Ss2mze82/4e1bQsHv+Isy/+lKyqhquUjFWpShy3g/wjUUrLVTc1S/tL1eqaVkdbrxHdTvQ8hvWpxyc7wRgC3gdUobTJ+X6UboyeVeC1llr67AizZE91EYWQ8D4wjp7U92hdUEzjlrdv37Hdblktl1IvTxHnZI5tuVhwcXGOKxRZsdBKiW+5z2n4XQ7iYZ32ONTPvUVrSi/gtBRqtELn2rCeqx2lYq3kQebC6KCOmW9NeGYTMzvAMqumpI2l5qn5Y4anyR+2/GbV+48/aKXgcr3k0fmS82VHbwuE2UrxgppdnN6rElFJn+DYD6CSBWQh263zRV3XEaaeFDyL5YK2bWlaJ1lHTpi2x7U9xjnCJEwvcvuLEzx+bL0pH/aSP7gweb0xGqObGbmb0tEgxXnOKXPqZ+Ymeok+U4q0fctq0fD06hzTarRVtM5isjDHOKPIMRPnoeXKZCbzphWwpEsJYAYUaFMAU8fzDgkIIoyqnSU+vNYUyMmTQjqWwHOg1oBiHAR0UUri8uvH8RK5yAQpMuzv8CGSs0E4KOWZpiD9XFJE6YTRkrFkkfqWCL86Q3XUakMp0QDNSXrGOQoAJyX0RjhcD+OI0YZ3768/6LkTA+GwZdjdYro1dh1BS2CZspe9ZSxZGyKZKWVMiGQ/kfyE9xB94vD+rQRi3UpmVnOmWfRY77ChgRCw2mJOM5wks3cxiiOMYRIQS5iIUQbTtTlSLaacSs+psEzV0asT0erTNVUD/SPX7UlVrLDepViJBQqBRMrzsD1JAjOFZIvVbM3OVer5MwqWXOZ4lz2LRceudex2e/b7gWGYcJ3MzuZUE5CMLr2ssvRPkpSP7LH6s1qunJdwnu0cSka7VIooHaQ3rxLKKPrWznZ0c9cw+YAlEHbvmZqeMO5RtrnXH6yfezQKdauqcj6Foaeck8plrWZdkp7qAE+u7RODavgBTvBwGGRGykeCF/HIULhDZYNkrK3OD6wFraWBWdNrXRCSwXv8FABD0y1Yrs9Z9T1v3r7nm2++JQTP5cU5Z+s1Kie6rmN9dsbZasWjR4/pu46dO+DDdOIA07z61Gwk6v39MAusR63ny/C4ZGZOCSDFqiMtnCklLrKCKFGe0cxxleKUOTTP/dN6ftXW11l9NWd/WsqvSkpZWZdE8uT1xz/VcVVWez6/8lgAUChePL7gxaMzLhYOm2PhLC3NCXUcSajk4xUObYyW0qE1YkSVKeXHREqDzKA5zXq1xGnoneXs4lJ6DyrT2MLz6lpilmfdFqj/MIyl33U09PPN+EMO8ORwztJ3XeEoTBxCKNONlSEoi+HJApM3WtDBiowzZhYIPustTy9X/OzLFwxpIqaAIuE1jDnRO0fOnsPoUVmjlZWQIImCRAyenCLWlCCGzDiOZVBX44MHrVBJC4tNygzTiCXhH47q6EBMA6E6wbJgEpoQNfvdbl6vkp2pglzMMzNPjoEcPbu7d2QUdnku1Q0Nzjli8DLMHUbJPIwjFCMfwjCjxLS1YpxTIsaANYZ+ccY4CQVcTJpES9aK7XhgP43c7jYA3Lx//aETDIG427G9fku2HYsXf4SxDdoY/EGG09u2ZfCOSUX2MaOGkTzs8cOeEA/EtOPu918RhpGmX3O3vcPnxCJfko1kML0Wvs6+WxwDt5QIw8Q0HkhZHF8II2EciF5GGpxtMdaRtSLmQAoHiJEwTUJjFkZCHO/FnHXvhBDmrxjjrKAusYPUdEOKJC2cwHOWLMwNJELJqoRLeK7+5ETMCWUKf6bSJGPnoP3sbMXFxTnjfuLt62tWZ3c8vtlx9eQMhSYGEXyW/qTsZ1VQxjpJH/xjh8oRlWtlSM7HGbFN0iaMAkhRChMDKge8yjSrJb1u+fFnIyl6UpgYp3NsYwkZhs0b9iHQPPqS/uwpru8JeSyONnMkBqmGESHKzgJiS/nolGuwKRiGgsdI1U0XdMgPsCef5ARzzvz6V7/m7Zu3JSuzR4LsohbhGpm9ahqHc+Iku67FWScoRFeb17owTyiapqNfrFkszzFasVyf8+zFZ5ATZ+sV67MzVouetqnO1uDKZ+rqlErYcCwPlqDiE+1qhR8LfZncUKeNgEZ07T2oAu+VerUPUQiNS9Ss0CVfOqKdVI1QToAfp9RodcjemGN/8RjTn2TYSKM/+ch+GHCto7X96Us+PBRcnq24WC9wqihaKC0K71rPc111bkfXoatifJVSaGNISUNWhOjxkyeEjOsUWjcsuobWZJatMFWgIKWANsJyH7RhHCKHyROCL+QHR/CRPLNjYfdjj2qGlM8LEVSSLLzRVujzgOClnKWMkXJh1qSsiZXUV0PbL7FOE8KEc4rOysyUjpFht8MroTeLwTMdRsbDyDCMTCHOXJVWG6IyRJ9lxixIdmG0lLYEvZ8Lu4iGnFDKYlzDoukgRox1YtzieO9ac/akPM09qOoFvRenN46+GEBTqgaqcF7WWyNgDK0SjRWjoVKgbwxN28pg+wiRiCPQGVj0LV5DCDCWU0ZB45T0UlPAqkijNWuncWimkBlCxOAxWaGiAFOss9LHySfXpZhHKHJKDPsder8lxkEi+KRl1CUkDj6xHSIqeVIM6MMGPe1xOWBtQ6Mt+7t3RDJuvUQvOunhqgH8hrSPbDc3TLYldEu0EeamaTgwjRIwRx0JKTDFkeB3pOgJYUKZDo1lOiRCqgFKJKaAnwaIns1wfW+VymXJqE5McYb7S/vEHAO9EhxppWlcI8/udK8nShnV4XRX2iMFFGOEKF7skcVq6ccb47Cu5+pqJEyKV9++ZZoC05RYrR/TOMs07GduYW0d2jqMbXCmxegTs/9BehshCTm3NZZcqx0UtYrM3N/Rpiepjq1as3MZZwPPniam/R2H3YaL1ZKmaVidrdnuPFN2jHe/I1stvWojc7w5C2NM3fP1pFKuQC4tQCPEF9X2kdG1Hwh1rlsS7A/npr/v+ORM8O279+x2B5wThQhTaLCqgoR1ZnaIjWsw1tB1nQzZNg3LRTfTbGkjckurRV/AFRHXt/SLJY+fPkXlxKLvabuOpm1wjTCfGyMs6LY44To8Lovy/lVX4ug/FBFUGrMZ4EIBxSh9ZIThBJGp1InxLn+r5ZcsC7464Jrt1WOu/FFLj+UL5kbvaSn0qBSRZ5Z6Y82xEqo+vO76OYu+o29bTN0Jc831/kk9zMjUvderUkapM0+yEbQC5wxWNzS2lE5TIuaSqShNSJqYheJqGKayMI8ZzKceH1xfcYQqljJPUtikMcpgshWIeroPmtIaOifr6FDALlobTJYS4WE/kKyUsb33TGNgGANTGbqXCqQp60MRUhTkaZIAQ3oTsvlScYBa24Lka+jalsViVaCkmdEPqOE+2rCW4Ws7GXJ5v1oGK3djrgwcZ81mlgyt0Mqy6FtxYllQqV3XoIHgDMEonIHWalZdQ1CZGDSD8ZSWCs45QghMKqOSoW0c667Fas1kAjkOKCKaIMPXRtM6mcnduwfPq5Y+cp2PHEhxAjJRCa9mTJGEYvQyCE+MNNOIi55GgdVgrWY3Dvhhw7B9T9teYFyHCpDHRIwj0y4QlCGaBnQipYA/HAhhIuZIduCJ+ByITJIxkEBN6GAYxokpeCbvySqQciQkDzkyTJuPL9DSD6yBI6XXnSsiWWsyEgA2rsVZwRukdKRSM8YIA5BbFGyClsC/2Fmr5B47Y6TFYBvabsXZ2cB0CPR9T9v2ONezXF5KH9l2MreYMsoajHPYpsHZBq3t/arSB9cjbKAasRkK2We10jJXtbQlKcWIZiAz6lL1mQxBQ9cYtNW0i47WjQwe3k93MN6SXIfqH0mlTR3R9cfoPs92l9NkotpV8gxGrPugLjcJ+j/dC36yE3zz5i22MKCfDsRXJ6h0qcemXEqMoi24Xi1Zr1f85MdfoLUmRIHahxAY9nt+8/lnfPb8Gf/mf/O/wePnz/nyZ38k1EPBE6YDXddijWbywpm4XC44v7hgtx/YbA9ip6kSHKdpcMk2ToAxSh1zxnq0WtMZg+Y49mA1aJ3RqkYdai5/ogx2sZwH5Su/KScPQucTFo2TzzoJckovUB2d4HzOnDxYeb3MEyraIlNV+4wPAeAnn8RqtWSx6AGByYtunjl586MBPfYfKCwu0jPUiHNp2oaUMl6DdWBMxjlQVqOSFU5HhE5LG03CSP8MTQDevX+P0ZbFYiFVA+dmu/4DAja5sgDxENkNW5wWpNtKd2gMKsr6ktJJIpSydDYKl8D4RBPBNQ1d15L9xP5u5Jv9a9xqgXIW7wPDNDFOE/tJ5iZjyljn0BqGMJK8lFudPZaVxymIwkUAo1sWizN+9MUXtI2jcY7HZxeEceD1y6+5vX2LHf188Qo47xacrwTYkGb9OYX3hSvTNcyIRCvBSiYWBKCgU1tn6ZqGxdNH7A8HfvftGx6vFyxXS5xWrFRkaxSLVc96veTJ40tM7ZEySeZcQAsxRIL3dE1D27Rcnp2x3e/Z7fd88/JbQkyQPU/Xl/SLJev1GVjFy+44EF3XudagkyBg/bRjmG6IMRNjYpxGYoiszla8fhk5bLbc7N/zYq3oO4XT0DZKnKxKJA5M777CcofuW5KxDFkxJMVwu8MPE9P+wHi4I4cJFQJNY7HO0VwsoLXk3jE0lqQ1WVl8EKKNaRBEcEpByqIaYgFibYfx3j7TWWEwWNPQNj1dv2J9FjHaYZSsf+ccbdvig2TxbdOw6HshYvehMBeZIuulhdqu7WiahrOz8yNBRkoyh2gdxnXYpuPs7JK+/RXn6ytc43jy5Dk/+vKP+OLHP8c2DUMI7Dd7wiTOvlk4mpXFrS3JJiY1Sqb+wHrMacUxYr93SHwm3MgxCaLdo3h3EEDTOt4JmOmwxeRIqxROG9aP1oSYce+23Oy+Yrd7g3v+L0GzRLseRZw/ruoWijsWHMaxypfm8zQfcXSmBov60wPtH8Qdevz7h3/LVf9qJnZk7s1ppTlbrdHGEGLkMHhCiFhj2B1GXr55y/XthqQUIcNhJ6gnP+65OFvTNQ3TNHG32bHZ7Eiln6LnsYPi7OZBRjjqEZUzVVXq5/5DN0p6gIL8LPBkVcuTqRQ6qzyQOB9bNObmTvNcXoQKMKm1/zlKmX1zPhq/k6xLked7XBd+DJHD3YZxPzINE1MI9MsFZ+oS2wo5rqLyN94/XBm4nc+izgVVB1gHFIsTlDK/QMCEh7S4Xm1o+l6Iit0koslaF4RICTpqdqfljiWEyYMyuxZTAIUAAFSZb1MPWVvhY5n7w0TeaSeDwsrQKiuUdMrOTBbBV9KEVJaD3PuYkpSqUyDlzJTA5FSYKDJMGawpcjCeKUr/qw7rhlFKun6cCi1amted0TLrpZSQCyjtsKajbXoa53DWErPM0O2HA6P3Qu9XDq00P3n2GVdXj4AjKbYopeTSb7flswo1mUJKV6UykXKaUamvvvktOiseXVywbBt6Y+gbg1p0uJxYrldcXl7wxbOn2FK2HePA4Ed8DCwXCyhRv1WSzT66vOLtu7dcm/e8+t04l0GfrNacnV1weXUlUeI4PnCCEs0blfEpEqaR7eamONuE956agiY/kvyICgGjLEarso8TOXkao0k6ktKA3t3AZKXHXZIXcxjJ3pP9xDhuSMFjQkTRoAnkfUKlBk1DGxuysWAUtshzNUEAUDlmRsQWTVoxRWmB3CuHlszPuZauX7NaKvTVAqubwm2pcE6CrcMwlPWiWC5lnAgUbdvStmLblFJFhNxgrWN1dja3DqbJY42UtVsnTvLybE1nf8Lnz674u7/4I5puSbc4wy0v0K5h0Tj65YAvfU3bKUyvoIsEPaFVmMuIp0etcQm6MiLwTT1nrXn+U8yHIEVTUdCJ5BSJwRP8BH4iZUVQprAZgdOZjlGU3/evyOmKpJ2IEKuauhwDZGnZHAFgczZ6YndPz16Xc/pbyQTrPF1tXB699lEwN2V15JHLSCqOIL/W6xXWStRlzChAi8WSzWbD+7stN5s9WRt8StzevMdPo5ROsqLvO8Zh4Ppmw+3t3cwdOjuR8uhOAUbzXZQGXTnb/MH8iFXyZco1Siott1ypXEy6uvc/bY5zgOVtj8wLxajWT6ylq/kf5UX3U3/uPVBVmr5+8ty8e89us2M4jEwhcHZxge1alnbFLKD68FCUEQ5FShUpd1LAlVpGcURVCaCMgxSjVe+WUoZm0YG1KKuLULIS6qpjB3ROWzNSEsyh9BYKkYEw+oT52u89Fo4O8P7c0ocb1ClHqxscmkaLE0RpfIGfV1malMo4iRIkWyzyTloV5+ITEY3O0v8KQyx9Cs2UIj5HUT5QEkz4aSL4iJ+iEAvn4tS1OGFrhOoqJVAYtHZYI1/GGCYfOIwTu8Oe0cu4wxx0K8WPn33GsydPCnNIKny4VYxX03X93FOVmVV1ZPwvVQ6FlKxfff0bVMpcnV3QNy2N0SycQXUNjsxqueTR2RkvHj+m0cL2tB/23O02DNPIs8dPpN2gFTkKaOXp4yfonMBPmDChU8Iqx6PFkquzCx5fPSIrxWFzd/+56poNKnISyaLd9hZlM2jJOBUWjSX5iew9NgvJ++zriaTksdZBcZ76EFCDmgPhnDM2JnSMqBzQsahnxISJChshjbKfjc6YpFAGVGNxIRUxWAnmU1IYNBOyzQ+hOsH761Vrg3MdfXdGXjV0OmNNU4btDY1raNuW/WEvTEfTxGK1pm1b6RMvevq+Zxylj2qMkGxorVmUpEEpDYcB4xxttxDn1jguz3qeXS1wJnFxsWIYE9tD5PYQyc7SnZ/RLSeC94zjAVwCl/B2X5iaxuLgHpqOYrtzJhIkeK4EJzVvrPlFzkfChbK/yFmEzmMAL2CimA0+IuLVKtGpiGLibveKmDXBnaN1S6Vnq062DsLLOiqZ4Um5tm6guUB7UlmpvMcfr/neP37AnGD58DmjKZ9YQgJdPr7MXB/5a0tklWKUDCF4nDOcnZ/x05/9gu1+IMTI8vIxPiXeXO95/3ZDJrNcLNmGhu0m8J//g3/I65cvefPyFe/evOOw388Ppp5UlTLSpbeWM/dG0LJS92+fEhSo0wqdhQ90VnYX73VkgjGyOFSGFJklmXQBtqAgxzynLnq+UfdynQ/vqXpo6OU3xsOBzc0tv/nlr0W0M4hw5jhNDH7isy+/oF8taRf9x6oW1FmhRAX8CG9mvS60nZ3g3FjW9tigLs18lGZ1tibExDS05HGQMlP0KCPl3MRRU85PvjgZjwUWjeHy4kzKi/s9N7fX3N7dfXgrPno8yBUVXC4WXPZd0WgUx3mYPN57Bj+xmw6EmIlJFYetMWXwVqMEiBRVEYU1hCxsJT6mokSh8Ckw5SgSTEqhsi46bxlSlUJSjF6CuRAzMWvhZ6Tl7m6DVvD4coVzBqMy79+/YTjs2G+ucUbdC8a0Vvz4s8/57NkLqaSUICHVfaxUATMocqKwFuVZ3y/nRIgD3h8Yhg3aB9qseXHxGGMFRn7Yb5iGET9NWCImTuTDhtz2ZDQ5gR8C42Gk0YboPfvDFq0bnNYsV2cslwuWy4arsx5SLLOQGcWB7d1blNaMu5v7S14rCUZKO5oQSdsRWsBmQhwIIRMGGPYHgk90rp1ZgBqnS1DgcYij6IyVwLL2f2q2aYwAohoNOTJNnnEYsZ3Ftg1u0QKKNEXy4UDWntwlmla0HkOy+FxGGZBqQvCRKQxMw3DvurISFK1rOy6untC3kXjQpCDntVqtZvzCai3o0WEYcYuF9Oa6TqoqztGs9VxF8+MkzDCLcxlLSxHdGVzb0q5WdFazbA2PHy15fCkk+ClF3t8ODH5HNp6kLdE62rOeLiu6KDOqUzoQ8kRMhiOv6gO7UQ1ezrW8VwJtdXx1NY+6Jjym0EhaurZHxZ4UDjRG6MvyFNlME1PM+CDqQAtnGA/fCn/rfsS9+Bk0fUHTij0Rya4MKmJMrlZJiLurs5z/RmHoqiDnGt7/4eOTneDRpOd7gJTjXTzB+tX/5GOUVpWZY1F5MNayXq9pF0vJ9hZLUopY77i4ksh20fdYZxnHgZu7Le/eX/PmzVumaZKBU2SgMqvSH8vV+OdjqlFLo/W0HtQOj8OsiAhqisTo50adKf0xY0TDjQxxkt0ntes4z4Xd93v1wZyGxXJOMzZFnd6v+y9LUaKpHKPMPVlLnqmhjsjK7/YlujS1RViTSl5bwiulNblm8VUuRssdPdVXVKqw36NIRhEos4IpInp+qjwHyUKEaioS/EglPnLWEIJAvcfJM/npo2f8kL3iA/YhKMwZalZfr1FrzkVxJEVCgpB0mfHLWDKGjEGQv9WxpeJUKkFvnUOqPcVUIqWcEjkKUKWybWgt4KCqHykzYYkUA8Nhz84o9vsdXWtwBqZxh58OBTVoPyjXCDDCEasAtIKo6nIV/HFOufRea+xbZr0yeC8E88NwEEHWCDlGbNugNNz5gPeeEEJ55onhcEAbJ1nJckXMma7vMFoTUmQaBrqFk97xPLRtcFZKkE1R1hAmrJop3R9qVUZYTnRWMzmDKqH+THcYI+MUmbwgcYPRMnZgMkVZuDyHKAY4mXkfVU1OQXEXhiaj6dsknJ9lDlAZSi9aSPd9DIQY8QgSFGsJqQSlTYM1ipAjxIEQIfgHZfr6bLSS67OZZAS4NINIypdxDUobQsxY12BdS9MuhMPTCHYip4wPHpeFaNq5DqUmVAw4nWhaQ+dgvXCcdQ1nq55F39K2lv1BZkFRwg6DMdQZX7nfDlM4bJW3HCOSD61HLTmemPUS0B/FjipOQsxhAYMpDdpgnSM2DU3Toq1Ge09IA8aXWcmUUGiUNIkhbSG+Q/kXKGPIuqPOMKa6uDNAvG8f1DEbPZ45s4LPRwUgv+P4QSoS4lcq5dXpR1e/Vw3p8WQlwolM3mOykMRaJ/M8Xd9z3vWyMAplVeXg00oW83635/27d2w2e96+u+blq1eSLSURas1l0FQdzQK130R+MDrB8VHWQyjPZDPtNjsO+x23t+8lsrRqpkSyVrj4QDEOYQYE+bDCuYamaYR7sg5L1GdQNmuuT03VUoqaH2qlSjq5k8XRZBrrsK1Da8MQgvQF2pbGCXqM4vg/oD9SBrTFmqZcpwzRqjLJqowDJY5QnawXlR5mX5JFosEifJbEQE6hbDBTfi+Rw0QKkegj07CX2SZlsKYVQJVSjJNnGP38tOau7kdRvA/OBU5aqgI+SlkCMymBBmJBqYashUEmJ5ISaqcEtE4Xl2KOfcQsTBS5fgDSc4hBFLZTlCxZdN0atEkonejbFgFjJQ6jl/nDMLLbBWIY2dydkxaOvjOkdAA81pRStbH3AsgaGc3PsgRmeQ6ois7bOM00gSDgmZgSt7d3HMYN+/0tw35PTopht5eMxFnGcWQcJ3wIhd4rsrm7xTQti6bl6vFjLq+uyDGw396wD5HxcGC5OhNuS5idobEiD9a1DtsajBMnU0c3TpeycQbTCA+t1hZcofEq6hVKQ0iJYZw4TIHoE84YhinTkqDV6KyxKAipcJ5Gqczo6liZjaIuowWrpWFqgqjIFEh/0ziqgvsheQ4xsBkT49QQrCPbhn6xYrlc0bU9KUyo7Q3B75nGjzhBDVln0JGsAjFHUpbJ4dGHObjq+04CaO1lTMF1tN1itgNt25dRC9H9c8bStUuitaQ40thI4xR9E3l20XK+XPD4ao2zGkWexZ9jFhSoMhLyxVQJMQzaNDRaoZOTPfvAftcj5qOdr87u9HWCXq2qOPO4I7k6wbYB36HikkbBOB5I0bMPWVidEoV4oJRM0waTRvTwGcoakluSKaLcpLntlHIu9JYZpcyph6H2KyELJzVIQP4Ri/Kx49N7gqYIkRYQRLW5xsh8llK6SAeZmbrHGI0ywlZ/GD0miBNc2B5lHG3T0rctTdNI1GCqPl9B3aVM17VcXV3y9//+32fRNoTDgXfv3hLJWG0g5mK45QnlLBFjnntUNZKQftVDEMmMAcmJ3X7Du7dv+Md/8WcyTOxk5AOEsqzre7TSHEaJqmNMnJ+dsVwtubi45I9/8kcsF0ta28oGqc5NicEXiSUp2Uq/jTmaKP6R8nKcsbSuoW8acuHzc8aw7Bc8urqi7zqZzZqzhftHUoakLMpI1jZHfoVLUBtb7pE4RkEjfigXI72paQaCGCXGJ4ZAQbOjtC2kt9IU994zHHaELEB63RsZyE6ZMQid2Qws+s6SRT4Gq+W0coZ3d1ti8DRNM/cQ/BRISqje2pRQIROnMiSM6DXMbP/WzhlkHWqeF0K5+VZZnLb4EGTwXnOElhtDTMK6eXF+Ribip4m+66n5eZg8SgkacjhMiIKSlFpz6TkOwd+zQLXXl1JFOMsNkiAhocNEnkYY9mx3W5TRnF89KoCERPQT02HksBkYx5HGtZydrTk7O8NYIVSeoieSuXr0iK7pUdmyXC1Zn6+5vLwQkveceB0nYvCk4GnbHmMMMQQqfeB+N4BKeN8QUZjGsVyekbOi6fpjhIwiaUfUWtRIUoIc6WxC2Swo11iDRBinCX8YsckwGUUwmugFjYwWoJpSSvhnTZ5na2f2Ey2BjcpI1cQYbCO8nEqrma7QGSOzkChMiMScGFNkHwLT5PF6wkyJkCKDB617nLufWdSASRsIeWBKI2P0aHo0DZMfmYKAhHJBrR+GHRgZJWm6Zt64rsztOW3QaEGX+5FGB1wDF0vDotWcLQwXa1VK0AJCSSkzjh6fFBhH2yzIxoBThFGo8nKu3LAWg8VgCOiT7P3+fs/pFLNQ7FM+ShNlimpQUlJBSZnJZwbAezC2oV/2kBIueXoSax3RJnNwmt2YmaKiX19gY8JOnmZ8TdaBaHq0acTXzGegjsGyKuTkJeqpwtqckKXEJOQen3r8MFFdpQrcvkSsUFhgNEJ8WTOOMjdjxSGmDIdhFCh3ynQrPVOlWWNmEIfSSprhUvEjqqPe4IsXL/jmyRPOz8+5vn5PjHWI8zQmEKeTyrl9aFw/Uj6so3PyY2KKvHr17UyebK0oQIcYWS4XkpFNUt8PIXB+cc7Z+ozdbsPjy0u5J71CFa5R1PGTH7o7pepZn5xdOXGhcivM9CUgUkqGZ9ummcERJ4/n3pFQZGVKVFjuT71fpRyiaiaYFeijE8w5nyBvC11agUXXm1Xp8EgZbWSMIBWZpVnbMYFg8yQYCTExhTizpRwLLMxl8+ORjz2Hk+d7GD1OK6bInE2nmErfVoaKYxLqvmOCVajvJIw9llDr555GH6ryqsqGSyoTtTDNyPiHsPpIZmFJWYuCQ2EXssYQnJkRbDEGKZMi75VUCSwelGtOtdbq1QKoUjb0gxA+j9tbtps7jLMsly0pirLFtN/h9wemwt2anTDryOXmeU+iag9NQwLrrFQxmkZQeIXX0lhH41oa1+CMlcqLKkGqsTJoHgtorBCx51Rm5U6OmLWAH3LGF1q3kAsxOKXsXFoQOUVBGEZI0RKTkh5SBmvVEXxWqivzOqnPsdy2OlqJKmATmNsI9bDG4GLClHUXySSt8DkzhVLWz0K4boydq0D3Sr2c7uGy3lDIsHxBXScZps85y3xpCvJ1ojtIjnOlhhil3xsTrYHOwqpRLBpYukyrE1bJvG5KyJiJD4Ro52xsHnNC5lJlvUu0rGrUnNSHJdESUKWcuLcSs+zf2h5A13tc2VwgpCxtCITM3DkrlRjjMNZhdcLpTGM0OyQgNtahtNAF6rAlTxYTNhh7AcbNQuKaCryRlkW11bl89uyw6yL4Abyh8ENFdR8c2hjRODNSAsggZegCHDBWHswUI9++ekNGIofzR89wTUfTtDKOkALOqEKoWixMNdJGoZXj+YtnfP7FZ3z7xed88/vfSWRKRaPm+SFCleoRIzYrXdT+ZLlfx/xevhSKy0cXTP7AX/3m17z65ve8f/cWa2UOyxjDsjS7fZKme0yRq6srzs7OePz4MVZrnj95zvMnn7Ner+i6bv59jCnDp6qU6u9vZPky878UJUtNeQ5yqlPQyJA3KqGc5sTXzkfMWjJBq1AqyHB1HdpS0g+rJWQpa8rPc5YhXq2FzXtWkU75ZFjElPm5KAjJICKbISTGKcrMXKoaZNI7U1PgMI5sdwf2hwGt7peq7x/ycCr/5njSQtwOvjg9ocxTWiSL+rahbRxdI33akDwoU/pGWcrspaebc56FOz/YL0pQf1ZrUtVNUdLXVFozhglnFbZxMjdaoubGirZk3zY0bl3maQMhjvhpJFqhOBN1AwpZ1vGoBBDeH8V2a9CUYuDVN19z++4171/9nhRGuq4FvyFG8D7y9u0N0xQYJk/yHloJDG7vboTRJJYSU0q8v75m0U10zUKut8jtQClvxSw6jGjO1ue0XU+OEWcty8WSp0+fs9tvGMcBbR1KmVKWvh945gz7UdQ2QkrslAelMOMGpyzGafx0YH/Ys7m7o9Gl7GcpgKfIbZoITpFbLYQbxmCcnZlXZExE1moqnk8QnnEeLZm5hosAd8qZrmnRyrAbfQk0Mov1EpU0IXiGOBTdSMfSaOJo7tkNMRtlftg0OKdQrUWzQNGishGmpTCC0YKcNJCs9NaHGEjBk0Lg8nyFs/JecXOHiRNrBeeLjvWiZdVqrFGYAH6vySFi3IKYNWPIvN8MeNURbU8gohI0wUrlwmpBZuYgavcBclBCKm/vB9IgjEkpBrlfxcGnXEcmZH8orWc9yLqHgjZMBkazpsPTMTCYlpA0aZVQ4T0mTyzbzHZMqCmgcsSqjHaKMN2Q08jKGXT3c1S7FKab4qtDKMChlKAMsxXTKElD3Ss5kZSQinzq8elSSkmUgkmV21AQPDElVIzMhXkFOkpPLxR14SmINI2xjqbtWZ9dcn75SAh0/cQ0TmSVir6dQ7tmNtbCDaVwzrFcLLm8vJpnpnKqUhp1jkXNTi6DIADVzOZ57K+c7tRS3gON6zr65ZKLqyu+/u1v+d0331IllJTSNM5J1lOzNwWvXr+i63pW6xVv3l5zef6I549e8PzZMy4vLnj25CnLxZLVcsny/IymbegWPRg574qqrSW6Gq1WDswQoxCT50xQCP1TkuwiHyll7kW5ZDhMnjEEjJM8TFXi5bLodb2/SjLOOp4QswAV5KLNSbRYJXY0SWkhwU0aojCryLlmKYEqA8ZR5whTTIzjxGazYypl5DnrOT1vdcwGpeig7/eYMoQMPmWhaNNFdkopjI3oUEEzCme0aJRxpFdCHfldU5kRlOhSzWUV771kAcYQYz0XcfgqJyDSNA1tV/TwCoNO33eSLapchFkV0xgISQAY2pmiCmAg5SNZ8snFV17ImqUqagQPw+jZDyPbw4HkB4ZxIH4l3Lwpwt3tDq0dyjqaRugLRdtSssAnj68YJo8PkfVyKfRZSuYf95sdL8O34iyUYhxGvA/EkIk+EUwgpj0piL5h03alVAzOOKy2c4Zxz6hm2GwngpMAObQCVtrst3Q0uGQJo2caJuIw0RmDykp6zyEyJRhypLF2Hl/RRW9PNDwFeZrVsbtcn23IoQQowmaUchbC7Cz9JaU1SSmycjTtmrPVGZ/94r/GYbNhe31NM+2lEuSMqDvkPYq/vF9dKpmKVAEsSjmMbjG6AwyGhpaWrETaSaoAmhgtKjcQA2kauXn7FUZFVB5x04QD+r6lNStau8CdX9E6R2MdU5RedwiZ7TCwGzzvbnckm1CtwTRLpHglVYmkFbtxDzqCOY7lpIQMoT/opQjr0LFKc+9hkpE+j/QS6tPWKpX9r9hGx9I40S6UUiFBt6hmQaMsZ86zOUzsD4HtdiOsSlYzTQN+GJi2Ayu1ptMN3dUzeaIpoVQstkpJxouahQzKRoFcW0nSF/54NfDD49OdYC6GtD5/Vee6hKnlWGJT85CnTuIkTdCMeaTremyzYLU+Z312jtaGNAWyHyFOYCymaeVeG0PShiyqtQKN7nvOzs6OTpB8bx4kzSn7ySKlZsj56GgeHuU9rHO0/YLLx4/IWvHu+kYWQ3n+1ZCikei5DKNba2nahpev37FarHl69Zyf/OjHPHvylF/88c+4PD/n8uKCR9GzWC5Lc7lDZVuryJARVfRywjJWIjNjMQbpqZEJcSo9qbrlP2SDz0j5eZgCSi9Qutb+jw5NqaMTlEH6YhgoCK5Agc6W6BrpoeTKPGOauQYbpiAMILNDMQK8KQKxwgzi2e52JYNO1IK1nP+H2WAFDZwKx8o6LKWXGNFZi+KD0YQQCVo09ip6NBb2/mOpsZZ1ihNMpZimoA4Eex/IushWlcAAnecSkdYZ50REOCOE21op2kImH8M493pjmfkLKdGUCNoqRY4C6vrwqd3/5wyXKmWfmGWAW8pgnvD+ujhN2O9G2n5J3xTovTUSFSd5jovFAtdIQNU1LRoLSRMmz2G353azoyuwfe8DMWVAi/6dj5K1lIFvYxqMcRgbpMxcKjISxaiTS8gcxgBR9kpqJH+agscmJ9yjmFlSpy1UiKaU5YW4XdZVrsFqBZOp2pYx9RbVm1ayvVhqK6Zci+ARUrmvKicioGzLcvUYc/WMn/70T7l5+5o36nf0ww5IaKNZ9D2GDaepYNlFx3MByDIfakxDRnQEje04DHdUqbKUlEhhRUXygTgNbIb36Dxg8p6lsWjjCPqM6A05Cu9yHZSf9l7kpnxkux+5243c7QZoFE419K4jY0qGWtDsKaJUPGInCi7hYT5A2St1XrquyqOFLc6xlEerpqAq6hghKnbBMRkL2mLK/cu6QbkWoxRNzDQadA5sd3u61tEuW/w0MUye7f4au/4M159jn3xWqja1CFrOZr7fecYWnHimmc3rU48f0BPkuADnYWoK2COXHuFpC7Mu4igZZIys1mc8/+wFLz77gsePn0kEbwwqGWzI6OCJIQroRGkmFG65QrctpnEsVkseP3nMYrlkHAbGYZBNkJFoIYMqqKCjmEY1twVSrcpGqhmXqtADQFu61Yp/9d/8N/jqm9/yD/7sHzDtB5kPi2keJagll4yAJmKMTOPA4f1r3OaW9/stQQUGf+Dp5Tn7m/e8/CtQztAvep48e8LzFy9Yrla4tiFMnhgjX37xZek9JKb9geFw4OBHSBM5B3xIhGlJiCMxe8iaY/v45MiZb1+95snVmh89v4LsqVwuSknPoJKZz4oFGZLRZGMJJglzBxGtAh5HUoasLFE7koagE0o7lEnEgycSiRrolxg0zo34/Q4/DNzuR95db/jm5RvuNnsOB3+sY5BL2ZH5XIzRdI2lbwWef3t8XEXGRxdnFiFrppRQkydHkUcil6pzuS1aUkxShCn7oo4QhSC8lKhNaUZPYWJKUj5vm6aoLRiUSlirWS56utZirRi/GErAkhIhCMw9KYOx0C5X+H1it9mgncM5oIgYhxDuWaDJC6AoHWHF8xbVTvPjn/2Cp599zhc//Sn7zYacBEU5TQcmP7LbjaxXZ6zXF7z///7HjNPE11//lnYhQJXru7dEHyEp/vQX/wJd22NUQ5o8Y8z85ptvWCwWLJZLnj95zrJfYi4KoMkHtBUw1DR5IRafAsEnNrcbdDa0lz3Fpd03MAaUVUwY1hdPWFye8eyPv6Bfrum6BZfLc95+8y1f/cVf8vqr34CfWHeOrpSbx+21lMtQ7MeIS0glolQTtIpzRcQ2AmLLWYKsrDSHrNkPI1PwtGU8QyVNPhyw7YLHL37C3/nX/zs8/aO/x/qzLzgMd+x31wzjToJso3HO8duvvub/8n/6vx8ZsThWa1ISIu1xTJBGUtUa1Y7WNWxux0LEHcDvSHFiN7znsHnHsH1Hr3ecLS3Pnix5fPmI1WLN1dULrh6dc3ax4uxsLUKx2bCb9gxj4M2b97zfjGwGTzQtWjckBLHbdS2rRS/zlyHSdQ3GZbRNhJ3Mxs4jOqeFmBLMOWtnVi4ojqZWKPJ88ahCzp9K79Nn+PZOsbzsuVxZ1uEVOmXCwvJmdIwpwiStJD9OvN0E1n1DZxJpGonjxLA7sH3zNTnD8umXZC0qFGMoAUzWhS3meB45UwKdyvilC2ju03LBT6dNm61KjX7Kn1ITmAEIR2fI/D1jNKvVgqdPn/DTn/yEy4tz+q4t4ApAaVy3KIZLkysrf0wF5FJLhGK8dHFmQt9VonuVS+Q+n/HRcpasgpzvizeWhyzlU3mtNobHjx/z5PETHj96zKvxJTkKtVO9NlNLojnTODf3mXPRIgvBM04jwzgQYsApjVGKu5t3bDea8bBh3G1YLJciXlsiNBNTYZpXjOPEcDhI5ucHkSdBF9ReYHt7i20bFmdrtG3uzfZl4Pbmjvfvb7i+2dAoj9W5ZEkFlCRT9Md8rETbuTq7PAhKjczgk6DJjCFOE9FPbG9u6JqGvm3RWsA3IVXgSxDEZlZo45iSxnYLnjx7wY9+vKFfXvP+3TtSnAqopARRWpUxBE3rHJ2rPLUnEXiNUufIurCrZPA5EYKgXpWCWFhZQs7zaFRORdy3aA7mmr0YM5fRqzyRLQrXOSb6psE4y2q9xJiKUGMuicUQBFjhgyAflSCjUXW4V5yxMwZ0+ID3MFcKunvXq+byg2u60mc3dP2anEUay/sDwY8sDwPONjKu03Yo4zi/ekzbd6ScuLl9N1+La1q6bkljO5nHGycOuy0U2qvDckWwDmesoAXJKJ3xYeQw7PHTwH63Ybvd8vrVS1KInJ9fSqnqxAkqpehaARTto8ItFqwvH/HlT/8Y1/W4pmXdL8g5sb295d3LbxjDxBACyhqs0jL4nTM+ZKyI2KG1jOdopcr4Rpk3JM1AlYBhSpnrYWIfAiFmzhqNiQkTAkkHrAnoENgednSbG/JNz/XNG969f8lhvAWVywB+5tvfv7oH3JJHlef1V9sJRoEhsb29YZMjKQeub96ItJFOrJe9BHgWepc4u+p4dvGIi/WCF48uuLy4ousXLFfnLFcdXS8D/jEJ09HkI8MYuNkc2E4wJIVulzRtR9sv6LqWtggOaA3aSHUEJeMiFcAjYyrVWtyz9HVRi6Mra1Bw2FJePz7fukqPEecYYOst15NmaTuMHWjtgNUwKcWYdAliIfjAZOAwaDSJhTO48wXORWzaMt69IbkVyfZCYXi6JbKigiXkOdRWipzfabDyh45Pd4LVkcxcF9UJHtGg0sc5OkmthMvQOcuz50/46U9/zL/4L/w9nlxd0nct47Avcyma5WolYqklhc8xor0nGz2nuiEExnFAZWF3kaHQ0uwuEP4jhdsRdZkVR+Tbw6zpmAcC0od6/OgxL55/xheffcG7l2+lB5coc4wCkpiicFAu2pakkvAiZlClBzZNkzjBFFFW07qWb765ZhoPvHulePfqG9q2xRauQOscu5sbmQEs6M+cM5M/MA5ChOuaVgb6/cTt3Y0wTzhD2z+4qpx5/+49r1+vefnqirPe0jWavmuwGKxKGCNkA7O2YCklJ2VIOh+z65TY7iNTUiRjhNh8HHn5zUsuz895cnmJNcI+Q/IcDqPMexXFC+M6/AiL9QV//Isrkut59eo1/+i/+C/ww47ox5lZX2vpu5qCLrNanvnsAtUxw6sMNRlF1EKWrQDvQpGMUqIFl5LMRhlZnylHap1AkrGy4Y2AhsQJyiYKhZAhhExnWmznOL88J/iB4AWFWXeC954MjDFgWnBKo6wFLU18Xco0nXNF/LVSKpW7X2mn6poswV91idq2WOfoFsuZhCBjUHEkp0n6KePIcDjQtj390vHZj35C23V4P/H21TeQhNRgsTxjtb5g0a3Zbjbs9zvG/ZacAjF4brs6h+pkvo3C8xlGhnHPcNhxe/Oet2/foFImhsCPvvyJBBIPjmVviUoTRnCrNWdPnvLzX/wpOA0GnBao/rC745f/pWPaZsbdiEfROgH0qyQUfEZROGF9CWw1ra70cRHlsxh+rRnR7ELm6+uBSami52ewPgl5uYso7ZkOB37/6nfsgPNhw29/9xW/+e0v2Y1vgYSzlv1h5Prd5iRLl0dU9QSlqlAkpYzCkrh+/S13t9fc3L5jtxeH2nWOZ096zlYOt3I8fvKUF0+e8/f++O9xub7g8cVjFose4wzZCm0jKnHY70kBYlAcBs92P/L2ZsNoeqLp6Po13WLBerlgteyLqomU3A0aZw0++dITjcW5a2lvPLSHqrY8xC5KO+FoIU9CnDkgldaY/GRKcDNZmoPixcUSkzO93dEYxag1Q7ISUCtNip5xjNztEpedo+8cq2WPV+DZsn/7NWnxBJZPBGegFFqfjmqkGo1Ia2MGQUob7tM6gj94ROI4uSHu78M+4L2eoNYsFwtWqyU//6Of8vmLZ7ROsb27Zru55W6zwTmDayzdcokrEHOlZMbH6COUXyHq9uM4FLi2orFGOB6j7D9d4O81bqlGMlPqykrNDBPz7VH59F9oDatuxc+//Dl//1/+N/jlP/wVUwrkHHGuxTpD2ynyQSD/P/rRCw7DwNt37/CHkZAD+6h4/eY1fhr5R+cXvHj6lM+ePePJ58+J08D29oZh2LHf3gmNVKnN//ab3+Gco2u70sMRFvr9bs84TCz6nsF7Qpx4f32NsYbrt6/40R//HeI0HjNfpE85DhO/+tVXXKxaFq1jseho2hbXdpydrXHOybxduUc+JQG25IxNkmWnkLnZ7tkMI7f7PWd9T6OFicMPA8Nux2Lh8KPn3ftrvnn9nmGKXFxe0fYLXGMJQLNacnX5iC/++Gdstxs+++IJX//qL3n38lsc0ls+6jbKE9JaGGbUyQOryh6A9FaKZwwloduHjE4BdGZ9vkYbKyjA3Y5hHGYSb6UUIcZjBqwNSteIUlZ421iUhawTrreYTjOlCZTwkuYgwCarpIIQszjWMXjyNDBGKXP3bc+qEVLjs8bQZ0fo/D3zM2/g7zmqoUkISjeliMsKFeHd73/P69cvefXyG3zMPPnsOb/403+J1XJJ8CNxvyXECWUU//K//q/RtitSNPyjf/CfMAw7nIo4HTDKMxxuGfa5lG1lXCCEyM3NO+62N/z261+z3d6x329Z9R3TdCWweZWJ6v41xJqnRfj2m99zvbnhm7df4/VEUiUY8Im8D7zd3LE7jOxu9rjtKPSKjaFJgTZFvny+LmQamZ0HnwXvISQF8ch9qzTvdzvuDoHfvB84e3zB+cWS1cUKM+1hF8hNC+0SvTpDOY3WiYtVx0sN42EkjR5rpSLRdI7UPyyuHRtqQpwhQdTN25fsb+74s//k/8PN7Ttubq/J2WOsYrFocMMT+hdX/Mmf/it8+eOf8qMf/YTLs8c424LVjDnA5JnKLGYmsdnsGIfAYee53o4cQpKMyjqwC2gWmLan6TrIiRRkHMMYVwbagyBV0zRX0Sj1ulPmokwljchHO35aAi2vUty38/kEPKdVZu8VLzfwZnXBWhtW/UDnBiYbJUhoOlwbCOmWMAZCTKxaS0PGhyD+wEYW8RviNBD0Ad9eEnWDp2fKiZgl+KmsJDMWRFXMQPpEF/iDVSQqM4meb6LMHp3MDlandTKXBBDCxH6/5e3bN2y3AyjNOHnOzs9YmiUhF8gx5SGV4eE5Eq6RcXGA82uUmtUCJAg4Qv/F+VEqngVN9tFyaL73T2MsF+dXfPHZj2maDq0NMVbwjy55RKWEk68Uc5ktgqBG9ocdSmW+fvl7fPIEFXmyXqBTxJOZQiCFgC0EzjFlIgdsCMQsc0t2cnQhigE/jBymgSlOReU6Y53l7etXPH7+GfcmexT0/YK27Qg+MY5RmuFMTCHjplTIfxvatvCP5MLyj8CeFyrKBkCT0Ewxc7PZQkx01ojBUYoUIyEYvI+Mw0TOdfDbkrMiJFUUKFq6xZKz8zNWZ0u+/OmPGe/eEfd34AujfR0EmzdinrOtecFag1WKUBhH6jMgIwZYG7RVWKdZrdZoa/EhweFASPlINq2kjyAKGuoI1snMqENjNcYqstXYxmCsJmRRQlfGoHREZYVxRqoSJdCKOYmqfFGe11pmO1tnsAqyFrmue6swH8nM59GV+b8Pd6IqOzBjlSxAf9ixu7vm+t1rbLeGnFkUiaPoJ1rXluFq6bk7FyVA0FLaTWkiJU1OBj8dmKaR/X7P4TASfCB4z83Ne3a7O7abG0KYsEYJirFt7+3102NmIMmQfWAaBm5u3hN0IOtEaxucMjTGkpQMcR98YswRG0XFIheLQ0bARVbTNEuMbtDNgphkLTRNSwiRwzCwuf6Wm31gPyY6nwmRwnZjMK3Brs5x60uWn/+Eq6cvOLt4xNn6jEePnvDi+RcEf4YpoBiUoXHv+aDHVOyOtZZkIlMMbG7ec/3yFe/ffMtme8dut0HrhLFCXzYNK5IPLLqeZd+z7FpJoFUk5IkQJIsbhwMxeWIM3N5uORwC+93EboKgLKZfo1xDtnZOTlKGafLiCMkzirLWEI+KL3zEDlbzV9sOFT/BnAZmsoykldZFVYMR2SP5LK2SKMkHuPYO7TrW7RrXbmkmj8qp8DMLmkFQuwmfMlPK6AhaWYxu6BsDLpPMyKT2eCL7BDE7aQ3NuILaDZzTn49f3HccP3xYnhqtF0dYIgJOnKAuKC+lhAUiBM9f/Jd/wddf/ZZfrv8JyrQ0Tcfl46f88c9/TtMvCAlMzKU1I8apPietKOrvCpOFZ9FZQ/KJpItJ0IVbcQavFC7IKHS4urzRrKI+H4nTcqgchidPn/F3/+RfYLU+5+b2Dh+jCLbGSBwla0o58+3Lt3jv2e2k9AmQ8sDt3cTt7pa32xvW6zUXl5f80WcvOF8ueXx2jvIJqzSPz86F6itlkrEFodoxeS9oqcmz3W7ZH/YcDhuMhq7R/P3/+r+KsZavvvorXnz5JU2/PHlUiheffc7zp49JfkQj5cLdmDDThNaecYolE2znAdkpBKaC/3my7mhbYfVpFmvUlHl/t2d7t6Ozhj969hTnLAnFbpjYH0YOo+fR1WOsa1Gu5eAT+ymiuxW27bFtR9O3tL3jT/7k54zXr0n7O/bXN3MpMBfHJHRXEOLpblUslyscGe+3pBSlJ5wSsfQ6XN+xWnacrZecXV6Rleb99Yab2w2+DHdLyaRo9smnEqKUyrWW/q0zms45TKPRrabrW1xj8SmIQKkxxBCxVgx4pJRC40QsDC7jOOKMoXOW1XJBbxUqDOgU0Tneu66Kus1ZFeFmOa+HUHUFMlulMtaAS4mkA8rv8LsbdjdvyM3ExaMnEAOtlR7Mfrfl5atvubm5RukFj5884/PPv8DZSN8rfn+4IekVWUVCOHB9fc0333zD2zfvGEcptU7TgZQiq3XLer3i/PyMn/3s5zx++nkpqyse2h8fpUXRoFl1Pe1qxerRBaZpsU3D+fJC5KaM5c3v92w2kTHuxM5khWs11mnWTphfjDZ0izUXX/w97NkTmvWj0gtbcPX4Me/eveOXv/wn/NnL/yfvpwPZOkYf2e8GxqmhcYnluuXZlz/j0Rc/4xf/+r9D06+xTUtjDY+e/pg//Rf/NWIcSwakMLrhr379V/wf/w//17nXlJGgzRjLotcoP3Kzv+F3v/knfP3LX/H21e9JKc0yQGSKNqQiRoNKDXFMDJsd2Xu01ShniUmCs+kgScNhv+f121sOQ2B3iLRnT2iX51xcPcHrlqQckEmTZ58yG79Hq4zrHCbKOWrr0Dh0dhBOGFYKUfjD9VUdYG2yZH0kxsAoKp+wXJsmUshSyi+nlBhj5te3jvHsjMcXK5YXXoLbb19jiDRG0zhDDDL+cPARrxxbHGeLNav2nMvHX9A76GxmGK85RM1N6LjhnD0dUxYCg4pPmcdmvsfJf+z4AcPyJw5Q61IKPekPlk9WxSFSmGRSikQfePv2HXfujuv3N2jb0PcrlHVM41h6gJlkJKOay12l4ZwVaOUwqkDgAV2a0pVMGC3GQ2vJkFOZITFa4NspppP4+niUkZd7VxkztMslV8+f8vxHn7Mddux+tyEkj8plcDOLidrc7MsMpSoLQer4ojCbyDbjdWCfDnx7d8vd5NlOiVXT0bmGfBhojJP5SO0IaIYpk7MBJeUd1y/orSaokRhGtn7Hb1//nvXqnG61plssadrFvWdluw63WEBs50FSlUItpOGzIoaEz37eqAlDxVhNMaMCaKdYnF3ypF3zd1TD7dvXTLstb263NFq0GI3RUjrLAhBKSja8zwJsSCQmP7HZ3JGTR6nEuDugUXRtS2z+f+29Z48lWXau92wX7pyTtlxXV4+lmSFFipIAfREg/UwBgv6OAEn38oqCyKvhOE7b6jJZaY4Js50+rB1xMrtnBt28GkC6zNXIzK7KrDwnIvbey73vuwo4SM3qNEViTmV8hLkeqhRsNic4hHcIo/Rj5nQ8U2YXKpqmZjjsGSbPmzcf6PterjEJ6CXluZFegt1UHIsVpyXgAukl101NU9e4yi3T4p0x7Ld7UFCVgcFVTowq0Q8D0zQyTROua2m6VoQTSIz97g+UPWcHcnQkumR5C02nfPvu5go/7Jm2N5gcyWHi9votOY5s1i19UsQwcfv+DZZAjIF+OPD+/Vs++/wzbrYHnjx5wo9/9CPitONw2PLFl58WIQShiuwPB25vbghBhIubpub0/Al17ehWNd2qY7PecHZ2wapbo9ClXPtwh4WQsEb6Uy8un3L58iN++l//NaZyaGupi2ByiIFff/wr4uTZvrkmIKCqJx+95MQETvVETjtCzkTjaE9PaC7OUe2ajKJPE9e7a/bTjmwTuraYxkL2KGfRVYV2DVWdWFeOadjx/s2X7P/9v2N9+Yx2tWGzqrm5u+Hq+oq7uxvG0TP0Eylq3r59/y1kaC69W6M1OUau3n7N1bs3XH94fyy1p4S2wlcmJaYwMoaByQ/4qcdPPdH3JJWlQuQjPgT2dzuGYWAcJw4jRBy4GrPaYFYnRO1K1SvhiNTaUjvDYSruLUMKgQUUiEJpU4QxlBzdi7TO8eyzRVQiIaJqc89PUbjFOT9ofQllSXrNKEgqLUC/OHqGQ+LmJlClCuU2NJtLRrVnyj2b9UoqddbRXLzENGt0cwbdCb7uuDJntEbR2YTNO5Qfaf2eEEZMqgjqjGhakm6whT8q0n95Edj/Ljnh9yyHSgY4Z4JqVomZw4d7jlCp2QlKibAvAr7DMGBsLRJakxxizAdT+cglzc1SZ5QHiQgPOytSUGohbB4PslxeP5WRTzmV95WOrLRvkUBLKe3+36YsQrbr0xMunl6yebeGLyVbEuSEKgGAZuyn47Ubjj1GJUg1pZNE19mzHXp8KrddWbIy2MnTVZbGKCwKlWBKcSknm6zR1mKVQ1kBivS+5/3tB5IxXD5/RdN2GFMtERGAcRZTVSJrVp4eyUMKkAIhJ1SCkCPOlmhq1gMDQgSTMj4m3KphXVs+si0qwRbD1N/hfUCnUJxoXnoK5MQUIWhN1qLk4YPncDiQU8CoTBomKekaGTczb5yk4hE1rMGa+4VeRdu2OFIZUzMBIpqgyqMJQTiVkBmGgf1hYHt3J72tzFItiIsCRin7ZFkMRhuqytE2FTkHjDNUzol8mLMYq3Guwhpz7yDM1E2FBWo/MI5DWffiQJwT8W2V56HT396as+7B3I+8T/9W87or3+93d+xuP3Dz9eeYLILmt7dX+KnHWkUaAkO/593b18Q4kXNkt73jw/UH3rx9w+3djrvbD6g04WxkHHvev3/L6OOiuej9xDCMZfBrzWrdcnZ+Ste1NG1F27Z07YpVt6aumnIWPHSAGbnerCWwbaqaTbfiycVTlBPuoI5KKEZ+4ux0w/50w4euoQ8JjGO9WdOZQE1P3u0IJDwiqRhVIviB0Qe8D2wPlmHoGaeerFUBSHkJkLWIuWutcVbhh4G9/8BX/a+4OIxszs4JF2vevvua119/ybv37+j7gd1dT/Bwe/v7g5e54pVSZLe9Zb/b0u/3EsCXJ5iyxMQi0BAIaSLGkWkaRGM3eHyKDCHQTxN+8hx2e2IQnmd2a5SzuHqF6zboumNK84mcMSrjNNRGM2pdpMXU0heztrSV7qdHs5rWN67HFO3nWYhaKg+U8Ejda0+xrNJZfWk+93T5vo4TaYz0+yhUB91h2zPqqGgTrNYbAg6qlur8FbrZoJpzVNWSbM1eN8TSa+4MkBRa7XDpQAwDDhkvhrLYSniIujjm784S/J5OUC/9QLM4QTX35HRZEFqj9Cw1pnHWSWLYdYjCRiyllFNePL+kqyxELwivGPEaYhqRKvPRCVZac7Ja8fTiAqe1EPdjKAjHkvmV17dFLzNnabSipIF+H0J777GXj7Q4w4xI+dSbilc/fsnV9Vf88z+X95MVSlVl1FZGq3ILM+QYmRsYKgm93IWROlo6IrUCV5YOMZCixnvDmCGHQK0dCultquJYBQk5EmLP7uYt2/6Om90NrmnYXD7lv/3v/nueXjzj5sPNg6uKWpOMRZlCXlcKoi2OUDh1sfDlQiF8V6Zkn0oIzSF5Bh+p60jVrfn41SueXD7HDwdurl6z296wu7tmv9sKdWIaudnvQfWY9hQ0ZK0JcWLqvWRIVSV1+/HA2EsPsaobCX5yLocHC+Tcx/suELquxeaIqwxKSzA1jrHMEEzstneE6cBwuAVl8CExjv3Su5WpCyXgIsocNOeonHC7VE6supqnl+doq2W5W2jbFu2MDOstpT+JiOXhN7Uja00zOA5GYxSs2hZrFNMwsN1tqXV+EE0fLeOIVERRGS3Znzg/+cgFIp5zZn/9nrdffcY//v3/Ri59x5gnAolA4u2tx73+ii/ffsXl5SVaa379y1/w+s3XvL/6wIvnz9ntFF+/Vgzjnn7oRdYwy/45OztjtVrx5MkTLi4vWa3XPHn6hLZtFkpC5WqauqVp1jjXsChGPXCESlRZNEDid5/+ms/ffsHf//ofiSYSiYTxQF3VrNs1ry6e8PMfPeEH9qd88f6W28NEGLf4KhNswptMThNhe8Vnf/+/sI+Kr97dMU6BKSRWXSfAsqrm7vqW6DMpKIYhopXn7m6ii4oR2O5vuZvu+HT3lp9OiY9eBZ6d1+xurvji099w9f6aaQxMQyRnw/4wPDw2luifpc+63+0Zi6bwwlJToqiiNVgLlU04HRinHV+/S7z/cMXV9Q37vuemzHxUGc7WJ3z88Q94/vwjTp//CNOcQHvGoDsOPvP1h1vWbUtX12Wuowhst25FSFJe3E0DPkRSZVA2okxmChM+yHtcKij3ntesanRMEqU3b4uq1KwfmjP3nJ9C5Qhl7a5c5tQlnk9fUg2RKVpeqxMmdU4+e0a3vmbjt2ybnzKphug2qO4CZSuycjJvUwvlapcU+0lRmacYc4ptVkT/lpC2mO2/EMyabDe45z/EuBptbKHR/UkEtGdy9X0B7ZIBFdd/dIIzMKaURpUorEgfJnB+ccHzZ8/48z/7CaebU5xRBD8hk9+EjaLJaJXw44BKidpIyWHdtay6jr6pCeNQiPt5eQC5zCuU96yYVQ00LPyx+6aVKSCOYyiuSAz9jru7D1y/ec1wd83KSJVTlagoK5YMBEoCWML5UnxAoWhQtMA6Q6ugUrAmc6qhUdCqTFVKGu4eiVFltfyunEWndNSgK4c9WfOzv/wZP/3zn3FydoGt6oWLNts0ecZpWsaPaCUyQ/IWS56htESEJYqPpayRS0RHFOesvcdEKY64uuihWsX69IxxeMZhvyNME34cls2VbUPWlqxF0FoIxRmVInEa2W93TOMoUlxKLUOLsy7Ao8JRMkU2j/KUh6GnmscdKY3RIq6cC0nCFQ3OlAW+HmIS5Q4jGpfB5yLdFpcze5ZUNQbIicoaVl1D3YqavXKapEVRp2lFHT+FKPQWLXP1FKVfPE0yhLZuMKVqoZGyqrUaZxDi9P2FmGHa3zJuG2JMpChZZPSeXLh7MYgQsw+Bm6t39PudqMIglZOEJfqJw+TBKJJK7Pst8Z0n58xh7GU+noWQJqZpoO8P+CT3bbU5oa5q6rrh/PycpmnoupbTs3ParuP07Lzom2piSjjrqFyz3NdvO8CSRViHsYWg7SzaOYyt0FbhNChXiRziyRkvn7zABc8+eFzbcjd6DlXNurGcVJrDlx5FpFl3XD77Mbna8PTViI8CkV91XZlM0/D551/w7t0V//SLXxJDYhhGtts9bVSsApxdvuK8u+DV2Q958uoHnFxc8OTJKTkb2tUJ/WEgBnGiWjvevH3HP/xfv1ik9GYohio9sBgj0zRJtWh+tvNXrVFW4WqDrRuUq3l3e4A8EiPsDwPD2LM93BHGicpazjZPMK7F1itc1aKrFqoOokUbAT1ZI3vF+5HgNTE4KelrTeM00yQ6u8PQo2wEK0Lls6D377MZU6mUxmrJ/qwufNx5E6ojKBBkHqvWgtvYVIrLKnLuIqvKUNmKarXi5hqIidYprO7IxsJKoXAYU5PLPlckclZFm5hFYzgkTcyWoNfkOpFUB6lBZY3GSsCYAllTdGO/PSHjD9n3Lofq4twkEzyWQGdgzIwaXNjJ8/eMhSxcj4vLSz7++CU//9lf4IdA8BE/jbLhyegsDBajM4fdjuAnVArgA23TsF51HJqGfruVw1OenkiM5aPclYxPKem7ln6Q+sZGFd2yezoXKqPxHHZ3vPvqc9598Tv2H96zsQJFV1lS/axL2TaIF9Qgr6cpo6XkNVulWSnNWilWSlFpxVrDiYbGKGqThbdHPPY3KZngvNJykLKSNXSu49R1/Fd/+3f88Cc/Y7U5RWe9oPDEMtMowAzhLpUJAArmCesSZsjNyUq4mDN6MheXkrJwMBvvcVFQq9ZW6KpmdbJmrjmPfU/wk6j4jCMhBsaQpPuYpVwZQmSaAuPujn6aOOy2TIM4zbmMsbz7extUm4cZU98fSLoIURcQlsnH9900NXaOJEeZ/G6dFk6mdQy9kIbHcRRJOKNQRqGtUAVzTDhn6Nqa9WaFrR22rdkedmTg4vyCqR8YDwcqa3FaUVdOSp0h4oeRSmvqrqWuakLwwvG0lqoyVAg/6v46zGSGuysOrgyTLYLXQ9/LcOWSaXjvGYeB7faGYTjQtq2Q9FNE4+lTYgg9tm7R1hQqzXYZIps1mNoQc8DHiXEawFqMq7m4WHN6csJmveH84py6rmnblvXmhKpqaLo1s5OLMUoZ21RoXYEypFS8/Tf2l0xPF+K661rq1Zrq5BzrHMYYKhc5PTnh8uIpn5w9wUwD22nH6vSEQ0xc64pN13Da1ny+e09OnvXJhh/+7G9YXbxkHy2pnDdds6KuKrqm5hf/9E/89re/5Ve/+R39FOjDyO0d1B46r/jxn7/g2Sd/wSd/9z+g2zW6qmmaxPnFM370k7+Q4clotHJYW/Ob3/yG//F/+p8FgMVxr2mUBFwxMk6jyOsZwSHkORy2WsrqTU3VrlFVx9ubnn6Iop6kwPuRw2FPmia6pkG5DlN12HqFsjXa1mAqmdShYXOyIfuJnALTNDA5jfcOVwQxrLNM1hJD4G5/INsINhGSFx3TAjx7mBXMWAc5u6zWIr+myjSzJOIlS+u6nFdWKSoDjYFXJ4ZndeTSZeLUYNuG7uyCL3ZXjMHT6YqgG0bTkVoHuQiHZyCLPm/KM19XLXirmIQXi+5QTU12AfQa5Qf0XElMEaI4wT8NWb4oEHD/vs0OrtwUVSYjLPBZzZIZZlXU3cmcnZ3y/NlTPnr+lMPuQN/37PcHsp9IcaBZrcvQ0czQ99x8uOIf/+E/UBtNrTUxeVxl6bp2eaDZJ+EkFUkqGa4p8GFTHpzSmWzuRQg588XnX9G0J2UYMJATcbjhP/7D/84//R//K/3XX3FO5JOPX6D8BEkiFV2CAFGD0VglRFlhUeSCVNLUlWPVdqy7jnXdUVlHXVd0bSMHgbYLvHxWas/cd4YaS4WiZtAWe7am+eiSP3vxCV294ertLVoZPtzsHzoPJQFAjhFf4P+aLI4256JHKiRto01Z9MdgRsR+KdMhhESdEfizToo0lSBDGXS1wlUdts00hTg8lSnmIUSGYYJxZPIHEREYevp+x9AfGIZemtpLEKXLdc8jjfSDc9VWGoOII6Qovb1xCjx9/oyLywsMgXHs2W9vuOzOQGsikLOWaespk7IjpIpsItZputbRVZbKaipTobXn9vaKftjRdC0nlxekmNDGUhWpOFMlPnnxEmuURN3eo2LipG6XKSrTNFErTdu2Mv5KZcZhj9Ey36/k+aQY+Y//53/gq9WKYRh4+vQpbdPIvimP1JpSirCK19st4zTSrk/JhRxjuxq3vYWba6q2o6or1qtWxLBDwMfEfjjQjz0XJyecrk94fvEM16wKVcKKo7aWrluJWIErE8K1Q5tqWZUp5aLsY9HGov5IB0ZnhdWG2ll+/vP/gucf/4CXP/0rOX9zQqmtvL6pGG7uOOzv2E1bslLUteXlsxd0dU1rDbuLJ6gwsV63bBpHVys6VwulKCdiuIFgCIPjdGN5crnh4vyUN1fX7A8HJq+xpy2XTzakcM3d9b/wu1+26O4MU7es146cPSl5GjdjH2RSzt2HLx40UpYBw07L/kEywmwU1IaqbticXHB+8Yy6bamaivVJxyc/+oTTs1MwNZ1pMKbh6cWGMGy5efcpX37+GSkl3OlLgt2wmxTpdk+bKk4aOGkcSWuysxz2mXGIjIeJwTv6IIN8nYa2EtBapRWVtXgiPsoenhV2ZjDZfQvRE1IopX5zFAkrKPx5Qg8KjEkLsPCj04pna8Nfv9BsVues2prr/R3jJDiQlb7Fhz1f/nZk376kry7Zh3l2poifKEUpswr5PiEOVvSjAVWSMKtQ1pHsE2zw6BBJzNiSuFCmvqt9j0yQpbS5gMDKnxdqxL2Da8nE9Mwp0SVLcjR1RVML0s45TfCK6AfIWYajrlc4K+jTtm0Z2wY/jvTDQBgHDoe98LDKg1G5DPdNCZGzWtAFx7RdHdUN5jM1Z3j79j3t+mtMGbaaY+Dw4XM+/82vePPpb3HRU1vDRVujvUWltDSexQmKYLOdH5CS5NKgC6Hf0lrH2jpOnRFosFa0ZcirtpIxC4CkRI/qeM81oLNsMmfBVDW1q4n9xEHvONzKeKqv37xdwCWgsNbhrCsqF/ILNbn0KjNKiR7mAkbKpd9ZYMZZz2OTVJGGkuxEqCbFUaVZIah8aJZyq9byLNQ9DuYsMyUlvxK85CQcy9n53p9SUspM9xe0nsvNap7XBjknmqbi9GRDjh6tYBoOuNqitCKQiFE204ltsK4nkfF5FM5Z7XBOlOebymAM4vQrJ+85xjJlPjMcDqiUMEqx2mykHKshxS1BKdqqkiHFWdB1uoC5UkqELDqcrvAsj5tLgXOiK6qUlAxnObpyTllnMSlj6ki7OcFMk+iklrVedQ3UNaZtUUbAPZv1imkSJ3joB5q2Zgwrnpyes1mfcHn+FFevFkEBIaJL1iyzPq1MKlearASEIP1qkRMzxkrwqGfgGXzr9Jknz+jENPQctluu377DKlHQWXde5Pi0x08jwU+E6GUd5kzsd/TTQCg9NWM0lVVM+xtpSVStCJWnSAhjAb44fD+h4sCqsThd3ocCYy1VW4tikppQ6YBVLVZbDIoQR3IYZC8WDIRSGj9uH1zbctDeu9ycBZFhnOXsySXPX3zCx69+jLGifdx2DU9evKTbbDiMWYTIbU2z3pCrBsLAbj8SY6Jan5NtIwCYKaCniWkaUY3GKod2ilRZVHaCADcGH7P05nTGIvvYOVkLMU6CwCctsoFaHxWWv2mzc8rlEJ1HJuXl7KOgU2Vqw8VJy/Ozistz0Ud2VcUhBRKKcZpYdy0xRK6v9/hpoI89yayW81kj6O9MkWleMtICFsvS8hK9XxbMBMpAqQzNx/7x9Pxu9r1k0+YMMM9P/x4YZlYiMGX4KCWCn52gqy2VhtrUrDrRt1M5YHTCmMy4vyZFIWhXz5/S1BZlHB999JzNquWrz37H775+zae//S3TIA5zRjJpNFobQs6EnDAFsIPS5bDNhRgglfylqp8zv/jlb7jZy6RyoxRx6vn6n/8d7z79v7n+/Fc8aVec1A3PVh0mCdkzzcsjzxTR+SHN90rkimSquaIl06XImUrUOuFypEXhtBFpLWPK1AwZIbXosuYZHCT4CLQ0o6ftnjeffoG3N1z5it048ebd2wfE8q5t6bru+Hdzk7tIojzoY8RYBuLmBdDEgvwVIrkPMkHdOiezEa0snfn3z0gzKc8lfMkEZ7FoySbjkn2mlMqiLQ4jfrtPYbRhGifunzSGVHoQmnlYrdKZtq05O9sQJhnY6scBXSGjtJIva9Ty/OlLbm/vMO80d4c7tIa2raiNbOauE0pJzp62dlTWQIyEIoH3fvJsuo5N2/L04kJKOdFLRhsCJ+vVcbDwOOCcpa5rxnEkxUCaPMaKiPkS7CjF5Q9/xPl6Q3235ez5c9qmkai4aHeaRfRc8ZFr8N6jtSq9j4xrKi5lIXI43KG1Zr3qllLq23fvCUk4s5fnT1m1a04252jTLC2MmWellZEsQJulHD1r5S7cOWNkmosxBQ0+F/8ePsMcA4SMzoHP/vkXfP6b3+Hz39PUDW1b8Zc/usA1NaZpads1edqRwog1krW//90dPsqMu49OHHVtqGzg3Ve/ZkpKUIdlcG0kSIm1qoGacTdx1hrea8UuCRLZNTXNZkXdaLpWcbZRdJc1VdfhrOGwG9hPI9rLHo9l/uDU3z50eDOiPRZ92Vw0Vo3GtTV/9rOf8xd/+Tf81V//NwxTKSdqxeb8Eu0q3lztRIAjQ1A1tjKcnAdeqJqUYfPsE8iRQwoyasrs0dUNnYZKZyrtMG1FWzmmtiME2aMxiBhHVAN129K6hrWOxH5i6Gc6VyDFMAMOvrHn5NzKpYc/06p9kPsgP6MwaGIUxP6qsfzwo3N+/HzN0/MKjCWjqPqBGBKVG3n24iO69UGQyds98RDg9MdkjAyYjrOMo4xLm1uvWmWcHIZSIk2CmFUFFyCZX5HNK2fv/PFd7XsO1Z3LZfphzw/KNOMZFCP8tlyconOOH756ycXJmucXp/zZjz7h6cUZyY+kMJHDJHJYGoyy5DARJ4t2icZZ3OmGv/r5zyB4Dnd3vHn9NcEHWUQFxpRTmXdIuUFKQB4+ixMMyKL1KT64HOMatGvAOmKZbfjhzVf43TVVnjC5gqTwwRbIu2SrsuSPr02OROYZf5IZGjSNrsjGYGwmrCvqpqPrLlivL6nqDtW0YA3ZWKJuQFuUsegs42vG3Q1KRZKK9OMVoTR+T0o/cho9b96+47Mvv3hQB48xLx/3LvfYiyqqPtYpkpESZo4BkIGzpLxMxfEhYr1nmqZlIc7ozfuw628KCh9V9kv5cpkiLqCVPHOOyItW6vHfpeXrffPjJDPlStqptaarJbBady2ryzPpp718xW8+/QXbwx1DmNA46WM5S9NIqTBrjzGa05M1pIBWsNpsUGGCGDhZd1RNg61bMuLQa2dwOpDCgf2dDI7WxsqAYRIQRfBBKZwV4I5WUrIlJ6ytsLbC2GNFQinF5fOPef7kKZfDyKptBdxT5nHOmpWqVAmemFp0XZeyVlqi4Rg9s+aoMVVRhKnYbHypiMCqXdM0ncgAmop5HNF9xae5DlGmJ81wiYd4njwfjCXEzMd8cDZdKcw8Qmk4EPNE7w2+bQhTw+2NYX12wqbraFrHlDW73Zauc9jKsTnt2G4ju75nOHhMqmiqCqxFKUPWBqsspoREc9XJWhmG+/Grp7y73nK33QkiOkSmEDlEBUHhpkSFwRmLB/qY2Xmh8cQowVyMgZvd/mHWVJwgCfwonNCYE02zoqlW/OgHf8mTi1cYvcI5yXqV02hTodDUGpRRsj4YGcct2w8fqBpRekqmwhiF0pn+sGM8HNj5kbPgca4mvRMUt9aGzeZE0pKUGYcBj0y3CWSUNYx+IsWMUWYhEaYcZQ9943mp5T/ZhwuV6F6LBuRs7xrL+abmZ6/O+dFH51yetmBLgpwS1rU0jeBEEppuPZJTQH32DvVuz970BCo8Ru5HjgQ/YtEFIGdwWipnCqE2TVH8hGSNehG7j4UHLqCNY2vpu9h3doLHzF/d2yxHFZmZF7g4x3t/Z4yhaxo26xUX56c0dYXRqkxE8JDiMoDRaC3ePQrKzboaaxyXlxecnZ6w6jqZ+q1Kf6fox6WYikD2XALNZJUKN0emDMj/P0QNicO2Ra0jE0JgGA7EGIRfozKRxJg8JhdCqFaLgLMc1omcI2kZ4AtOiUSWMqLsMVlFqAyprbEnJ7j1Oa5eo9qWbCzZWoxpUcqCsagUiNPIMHmUjWgdCPmWqBTKWqxxoB2KzOQDwzg9WM5zmTOlY43gXuFSPqvSs4XCr5kP3FLYkgppmYsnGd3cO/32GnjoBI+O8GHJNeVZLHrWJ1yKK9IHWAIZdf/NLhZ8wNxX/dGKuqloakEFnp9dIoi5DZ9+9ZuykdNcp5Xep7PUtWNKlZRAm5ocDUYrNpsNaeqJY09VWyonivy1c6QyAFSnJL3WUZNTha3yEZGWYwkUl24Bszi2ImOsK1lgOK5BpWhXG9YnZ8Q24IyU5lO57ykdo3DItKaCLBSKWUQ45SAgnGCwVUPOCbQt0bWhqkT8UitdnJ8rPT2DwgD5wX5eKA+lBHbMWh9+Xc6HnL/1dyiwtcFWMjNQhhhnjM0ok0FnxuhpkkioZR2J2XPoD9iqQ1UG2zhUL0ONJ59wVuMzJCcOMBl9771lUJmoZKazVpr1aUfdOYxTZOQs8DkzpIwKETf21NMAviGT2E8D+2kAJWXwafKE4NmN/cPrLQGwmieEKE3VNKyTwirHxflzVt0pWldYLcNtlVWlvB4wKlBZQ1Vpgt/jfc+h7+lOz2lWa7RxZRAzRHWQcVn9nrpdyfBqf6SDtXUrKHnxPuR5VmIM4sxiKr5Bo+UWLVfxrarh0i5SLFGTmgMwKYXOfO2zdcPzs5YfPNtwum5oaifao3P1wjiykxNxlis8vzjj/HrHbt+jnWfKijFDpQM5TiS/FZyE1qAdTlmsNosASooJg1QXEwLICknOO1Vac+Q/XOb9ffb9nGDRjcscs0FVHJcpg26B5eDVBX2UyKIXOO7p766Y9jc8uzznpJOeRkqJqmmk/KdF7SJZTa0qyHOZLEu5qrK0zqCjImTZNCkVRCjSh5lFoENO4MPyUOYI5cEzR5qcOcHkA5MPBNegNmfo1jDEyJQTuzihoujyRaVKiXVeRwqlDcbK9AKlM7WtqIxFuRZVN+i64c46bNOiLp/A6gm5WuOt8MvQhrpak4smXpgGgo70ylAbg7GOZGuatuP8/JKLix8w5Zrd9cCLILD/+wNowyx+nJe1XZbFUSs03/um9CIL73P+ByUanHxETZ5hHGVIcsnu7/d/Z5sV9R+WQCMxzn+WDLBuatLoyMEV55FLv0ktGaLWGhfuPa+c2e8PxFleKme0sZydXnJ+/ozLJy949fEP8WHk7u6KupZ5gPgicmwsOSes0axXDZEJozVNXdE2G7q24c9+8kOG3S3722us0gXdGeg2HdYadBrx/YE4juSoZYKIisQgCNkYArMDEV68VAmcVlhjaGonAV96GIxZW+NsiyFiykEktIz0jUxaOGeqIPMEGBaX6B0SWjeSlRrJFFTO2Fr2iFZQVQ3WurL+9XLPj1nBUTRh3iWyJJZuOiiNNvZ4Vv4eU0qxutjQNRYfMs3mDNu0uPUpmCKYnjy+g4MZGfdf09+85+2Hd6T6kq7RmFYRek2uNfuxJ2rIyTPVDbE28ueyTsVnS0bodC89w3ONPrPYs4pQZSYHo1Vcp57bPvLV65GzuKNZr8lk+n5Pf9iDoXCXEzF43u5uHhyrSkW0lnvcrVZcPIWf/81/SRwzVjmePP+Y1eYc17RYW5HIjMGz398QfI/OI5vTcy7ON/zql5/S7+6AnmdPzjg9fUI/SW9aq0zoD9weDly9e8fzJy+o24rauEVdqd/tsNbiXMWmW6FUJgcR8cgZGuvIOZCYcAgXOCq9ZFT3bR6MrdWc8sjn+dlXRnFx2vHsfM1f/eCCi03D88sVmkgMQapYSvrEUpaGKXhub98T/IQxFc+eXtI2NdvRsxtHbvtE9HuGYcf27Rc0taNyjvV6gzMtjoaDD4QYsT5JEqUMU1JsfcUUKgIdWouaGCVA+a72vXiCKElTZ/6f0lqEUMvXOWpYUKPaMM9Tu9vuGQ5SQnJaFtirj/fUTS1NdlehEDiudbb0IgRlOE3S07i+ueVwOBTiqZRYFLaUIzMhSG1ZUmPRGbXKgirw2aKS8sDyPB1ZYbSlahouX35CmjbksGXc3RD9SBh7VBJSfdbiMERiSvQDratxzolAQGWotMVpjcNSNS1V16E3LaxOyN2a1K2Jbk00lmzECWJbhGFOcUyZXDUkk0AllG5w1YqmPcXaBh8tKY1YW1HVLfcPLulTlEd37/DKpTd4vPxc1kzhDi6R/6xXIg5Vh8A0jUjQIstmdlT3id9zb2/uB84fS3ZYMo66qkl1g0qRaeyXftP9TPD4vu/t1LJzY4o0Tct6fcJf//Xf8fTyCUZXfLi6Yn+44937r9jvd8soprap2aw2fPLqJf3hwM2NlkGxRVR6HHpyDFxdXWFyKLMXLU1VU3cbieJTwO97AedYOcRTTqSpByJGJ5lrWQAV1spYKGsMzkWMlvWtvrVJCwADzX0/M2dncn+l0pHLABx5xoJUljUzZ29aeHhzabAIUDvXSNmZXBDJRn6+ZKzHuY3ls0IAMUiQl/V8XarsGSXDplUqvcmHwdBsthX5shQiZq0wrUKdJhKBSIaUGKsidr/bMfV3krVVllBZdmrCVwnW0n/MNYwuckBmbYbEktrMXRok7iFnGGIiKA824eoW11TYpkK1lmhhUiM3wxUmbYk5MU2DUEfKHhANTZj08GDf6EKHSmSyztja8ezlC5JX6OzIVuOzR4U9MQ7ElBmmiaG/I4YRpwL7nQREr798TQgTXV0x9iMHdyBkJzohJGKcmMae7faWw2FL27RcXl6ULDUUwID8XIgKcmQaelSpOmhrSVHUoqwu1IN8v7p3z0p1YdGLKcmis4bKGj6+WPPi8oRXz075+Mma1s3tDFvwH0YC3RQXCc2cxSmnMGK1OFhjNOvG4UykMpGbG0/ME5WGqe8ZD3umw57VumO97lBJBinnKeCDJihFiBCDBNKRNdgK1bYCPsyHb63FP2TfAx16BJscv84Q4hntpo5Da7U4yflg3e4HdA7cEehqh7WW292BE22oawvWlbIcKDNnJDJK59APvJmdYC8RnjIak8vw3TzrxEmDnLwwdJC+vi4TA/g9EUIub1f6l1QNF89f4sOG4O/w7zRh2OE1qByYx+gobaV0mS3a1bi6papqnDV0jZRADAoTM65pqbsVpjGobk1qV6RmRXIdwTgWnVXdLP2YRT3FNUX+OqBMi3Er6uYErRtUFIkga0UI+/4RNGd6D3t2x6c5H3pzNjjHfcdCwpEPFKOAK6ZJZMqcYzmcdSl3z6+5DLmdHWDpAT4cPiqK/6lpSh9gEuen0lJeWt7pg4P1KMCQMnQlK/6LP/95mReZubm54cP1O7786jP6w144dErRNg2npyc8f/6M7d0tIQygYZxG+v2OcQr4ceDqvWHT1qzbCmssbdtx8fQpw9QzjT3TVn4fBRkpBPaxZAZyCM/KStbowoWzNFVEkQSQ8PtKNXkO6lhKkDnPZSjJZMmhaKpSyl7lJFvKl7IfjXFLCVMpOfCsqxcVJqMFDVp++zdsif2ZBTEWkYmlFnp8j1KGyr/XAaJA1xrTaGLI6E6hugyrQMyemCMqGbJOhOzpD+9JwwFXWagdsbbs8OAyZmXQypArja8SPQOT6DlIzK1VKfXppSQWc2aIgYgHk3GVxdUOW1fQarJG+JLjLXlShT8p5c95Hl9VJPKC8g8uTReYclbSOze15eLpJTkKHzoZ8EykKFTiEBP9MDL1Mlk+WzgcDpAjb9++x2rF6vkzhnFEHw5gqpKNZVFc8j2Hfsthv2Wz2bBatVirmbwW0Ykk7QrvIaVAP+4xsUIbi81OqmvJC/aCfIRf5m8+MqkmzKhyef4GZw3rtuIHz8949eyMH3x0zkkrlbpxPEjFYXF6ogF8DGSztLfihMoWSAJms4baalqnGe8iXiVaZ7kbBoZxYEgBQk/FAKaWwH70TGXtp5gJwZCiJeY9qm5R+hRbaVzaf3s9/gH77pmg1kWLT7QsBTlmlwMpZpYeyAySEf5RQYoai1FQW8Wkam77yK8/+5q2u5UxM1bT1o5VW+NjLKi6hu1h5OZuxz/++l+4evOe694ToyVnKUW52izaj2PuGdJAmEvZyqDLQVGFGhU9yXtge7yuIsI91+0xhmp9SfY1Yarx9R1Ri8K7s0fypnNNIQu3iOqnpW66Uuc32NJpwQdMXaPaBlUpcrUiqpqgW7Lu8KZeFHecrUBpYlZMJhJsIrgGTcQQcSpiqhNQHVnVpeTQsdKG9Xr3oLYRYxCQhLonYPANu4/GVEqBNcIBLKXe+YxNIZLzxPb2VhCnVU2uqyX4UfdUXVJZoDHMTjAQ40SMvpS2ISuLbtasbEW3PmUMgTANRD9i9JwRsvzOb61DbdAGXrx4yYsXHwGabrWmbWpspenHW3wYRPC6tqw2Jzx/+oKTzSlff/UF+/2W7d012jrhRpLw00CKkQ/Zk0/WWDa0p8eZjjEHUhRwibN1UbLRpCTSVOWtyageLU8/+DJVpAyenekirqpxzR/Za8XJSGBwzIhVaTukEJazS1C5ghDVWmExoN0DcFHOGafuCUIUZ2mNXe7xAxk3NfeBOB5sc0RPvndwzqr9v+c5FYs2EyvAKoKJRDwqKEIW0YJknPSrfBbpQGu5ePkR6XxFaB2oiKpA4ajMWtoudY1Tcm0mlVJwVohyVyJH5Hn5jA7gchblJm1Y2YpN3XJwGa8iUw6YHFEZ4ZqRS0DsCgLWlXUUHlzXjJ5NVqEaoYCQA0YJJtxojzIBzCBeMEZUDqxbi9UdTS1Bf4ie9qylrRueffIR1aoi6Im73TU5yxxTlT1e9zQnmt+9/hUf9u/RjWa92lBVFcFOjMPIOPSoSXp3mQjBQNCkQyTEkZAmlPUk7ckm8fv4nVaXzDeKcpY1hk3t+POPL3j59IS//ekLVl1N29TiIJPCVlVBeAeGYSAGTwyBum6kpWEMTdswqSglz7trbrcHTs+e0LQtp+ct2mqCD6gM1zd33O12/O7zL5nGntdvb+feGrPEZU6ZYZzwMeOjYkpXeGMJ1zVjrdnd3HznvuD3KIdSNuScCarlRdIM5Z9rK6VqAsx/S0YLqlIpBh+5Owx89e5KhImtpakMXePYdA0nq4a2bTg/N9zcbXn/4YYPt1u2g2fMVpCeiLRUyEbi2ZgYMXhlieYYIc+UiFi4W5iHN2ZWlDEljM8YsnIIMFe07BJWmrCFIJ9ixBhDNg6la5lwoWtcJVJG84GkUbIRMMSoEGCxQWUBIyhlUcpJ70JB1EI8TkoRlSEqQY1mdHH6jowl4chFv9UYh8lJ5KuWY+7IxzsCGY4PRakjwnO5DzOSQ+sir5aPvaICaAjeMw6jgJCyTFwwVqgsMxhqPnRlRqJkgTGK9FdOaQmObNVgrCPHirpdgRJwB0VQ/X7ScX8NWmtxlaPKCVeJIx7GgcoJ79GHkZhENFohGVTXdQth/cPVDUN/wE8jlTbF05eyY+nF6QLYiTEwDiM3t7cCfIqJqmpwtsIZJ5qskyWkwDTuChVt3iMaVBCQQswkkzFaAhJXt1TNw76bQhALaq5TLWG6AIaOyNlU9lf5vpr7YaXEqpbq4DI8NSM0kmN5/CGMfBZnWJzt7NjufUXNYLDjplbzfv99wcq8Ep0SrcBUpOeIUErmGcimXFcUDqtGUVUVvVKEnCR4CrFA+oXUr41DJQ9E5skV8+DtY69bsldrNFbbInEn3FxrDNqUM0srVEF5Ki3E/qwKh3fueaMejByV51X0k1XGOMnEZw6dVmBKP1fpBDahoiB4rckYnbAuQEE1nlw2NHVNvVaYJklmGSHGRE6ib9sox5k+IYYMLnKz/8CUR+qqAqUIyTMxlevIooKk5T6EFInKk9SEUoGk4vGRfePRaYUE8k6zaWva2nGxXvHJ8zOeX6xZt6JKo8rKQYFeSqCJ4Ce8n4gxFqEFTVXVWGsJWhP9JKVSEqMfMdYQU01dOSpri0gKVJVlnCZub2+5uYWbu+3CGa4rwZ+EEJh8wgdAS79fCu1KpAm/Y1vwe80TvB+VZqRcJzxB5FBettMxpRaJLrnbAZkRdtdPHEbP9jAsZZe20nRNxcmq5tnFCRfnZ1RNx5v37/n6zXvefrhjmiJe10xKJkXEHArILhc1EE3SbinTLIL9Zd2UtVIAAAnGSURBVNNmIw67NEHKuxKun1FaSkTKkLIlJUeKDqUqMhM+aihQ8uBD+b0KoyzaNdTVhrrqMEqBn8RBaYU20oucxohpKmy26KjR2SEiWpXIPmlIqvRQlSZqQ1CGZJyUXEhE3xOwRMRJZ6WwrkKndBTyRi5NypGh/Pmbgs3cO1SPo1FmpRNUyWKXQ0/klMIkEZ7A98NxMr0THU9htsrPxxgJcQbECMw8JwkedFVJ/R4RQV+dnqONIiVPGGVgcIZvHTwAddNKFOoQsFDObLe3xDjSDJZh3DEMe2b+nNaazWpN17RUznHYbel7IexKBFscupYeX105UUuxVqTnJgnATs421JWjW51SuwZnG1RVM/RbEol+OBSlIhEtnxGvKUVizlTOoJVGu4p2fUKbp4egBCU0g8QcuGS0ntG099C1M7CrQMEL5JLZIUrfu8DZ7+1XSZLKfVVzBn8sh7Nsk1kYfHbkD9ETiyNdKj9qCZa+lREqUK3oaeWYiKrQKHxY3lvKiBOKEZ0yGo2pHDEnmQ4RRrIP4CPZOjSWStXS+shJ9CW1OKG5hZJzRBXxCl2VCSDWYbWW3pYzOJPxKqOTiPGLTKMIXBitsXNbAlBJFaLfvUtTpa+qAq7SWKewzVyWVhiTUSoCU8nqIQUJjCR2KIFHgmc/XOOMpVoHjJMXaiuH94kYMrWDTm04zx19L2T6q91brnuDMYaTzUbQoQZyTsterlwtZ5oO5CDTY7LyoEtPU327HK6Uoq0tJ+uKn3x0yfm64+nZhifnK9ZdTW3kvec0D1qitIWEyzmNA9M0EWKgLUj+tl1xsBVeKeI0YJSgfPf9gUyWySxWxBpETg9WXcV63fD6zRVZGT5//Z7+cCCFiYvzDXVVEWJk8pFpytS1cNVzSvgR/DR9+/D4A/b9eoJH/1+izlweukRU8zDQZQEW+L1kFWUUR1ZMGXxKTHEq5Fw4THDX93y4U/RDz64faboN765uuLrZshu8kDcz+FzmWMFCk8gzoUmZkinlMlIpl8M8k7MmpqMUFVluWgqBMPmiPSrO1CRDlRwn9QneWCbrcKYChXBZjMNoh8k1KhrilAhKpnW3rqEqkwRUnjAkXFFxMCmjY8LEjI75qDOYBJVVchGUKmVGbRcnmHRNwDF4cDYRkRK11jPM/WiL2sr8qFTim2fU/Z9Vpac2j3ACFjqEzvcOq3LfpmEkTJ5pGNFuWkBS8xpJhbeZUhT1lSgqK5V1Am2PUfpgWnN2+Zz1yQln4yU3V+8Z9gd2N3d8s2ulteZv/vbvsErxz7/5XcncFZuTNf3hltubW3a7G8ZxoG0rQpLy5e3tLWEK1E6oOXVt0api1bXkDIZcVFwUyY9UzgllJIkTm4qOpyJzdv4E59Zo23AYJ6aoCckQgoyfsmiGYVrQlqog+KcYiWQihjrIJO377kfuV1w4gXOrL2UZMBxTZCbgSHaelnKZFK9LGZp7IsgceX1JKUHloEToQGtZb3ouY+f7uaeIXyx8rOKA7xWYskJet6xNCXuFm3bfokkEF/E6lUld5SxQoiMcvCeHSJ48J1q0Rk9ON2z9Hh8CYwhYpYRcbxoq69AoDoeB26mXQNtodBGTzpR7lQJEcH3NGEa0UbRrIejXznATDvjsGf1AhcEYRVSZmEXwwaf5HBNZtJS+6QUz6CyCJVrOmBmZoFTkKOwvgaHJkN0R+JQ4IqLXRrAA2Uai6kFpqbLUQDalOiD3tWva0nMrQgo5EUwv90Dr8vTEZ4/Jl+A0k53QJLJaRuUes/xiRiteXTb85MdP+MmrZzw729BUjrqy0t8u6lACJgtLVVBrLXslZnIsFRgtQxGE9qZwVtG1NerJJf79B3aj58P799xow1U1C6g41qtmOa9B07UVTy5P+PjlM+5ud3z4cI33iRB6Dv1ATKJPrHXG+7kqkOj7PwEwJvhRnv393VH+rJQml/4TUHpFBWhSSibzDEIZJSOblpyWnoIq07I1Cd/v2G33kBVv319zfbfj7vZm6RP5okoyow6XMhHF4RWnmIvWT6Z8zZmU7gMTMu++/oIUE7bqGKIX+aXJC5HfD4zTFSFO+DBgTanjBy+lEmVQ7KREox21ldJuVzuclvCA4DEqYTX0jaarWt6vD7SrLbpaMblGeIcajJsjb40fBoIfmXY3MkmczPXYU1U1m3ZD12xIaK6nwGGaeP/+7T1ieeb169ciEs1c/rr3MNVD57Lw/bRenOD9TEKQoxzBRRw5ZfPkaqX1g97jPB0+5SSCCLk8g5kEH+MSoIhA+CSDYK9lmvb2eotVmX6YlqM3Z7jtPTpnPux6vL5mP3nqtma3/cBud81+f1coMYl9L6jTmz7RVHucsWgVBUUXJrZBaALj0AsfUCmmcaA9BNrdRIriCH3MNHcHmrrmdg/W7dG6ZjcMTOOefn/N3c2WGDzWOGYB3yX7VqXioDXGVax7xXYISzCWUuYXv/4lH24+SFB271GJ1qnIzM3I3TwHdikULVtxQTMPM8W5R3ksVd4nDxtrOQrhszyv2QmKOs0cXBXpvDwroxzXECDDcYvwAkrz+s3rRb4vZ3j/bk+9t4SUy9SSgiovwJyQolybDwzZ0LuInba8Hvfc+pG7MOCUoTaWSoGzFqqBr7e33PmBREYbtTgdWXNSfieCGytur3v6w8TdduTt1Y62/sC7fOCQPDdxpCrSh34uJaciL1j66UYbbj/0y7GRUuKzX37G6nR1jyc8l2DnihnMFbElopnrA+rIlb0fM0h5+Qg4nP/VzAWds+2ylRZ1JmvtPZR2uffkY+uKmT4zhzjldbXizWdvHlzXhzefs6kia/YMH1psobLM71XkDKU8PfPAtTb4aSD4if3uTjizZKqqKS0AxbS/IvoBHybefrjm6mbL66+vyIA1lq6dnWB9vBfacuhHtvsD+92Bw6HncBgYlNzzoR+lV43CjiOUJEuR6PtvjL76I6b+0EgNAKV+X0HqT2+ygB6mLX/sff6nvdY3i+N/ukteruiPAAn+tSbn4vH4/GNghT+ZffM18/Lp+9s3ynTHl1DH75d1oh78zL2f/saB/Z9m6g/+qnzv83f7TfMomuO/+Wa5+v+3llmyWfjXLvWHT/Rf8RYe/qZ8/P/jp+//++8fQXMG/Z+D5XsB0jdVoP4Eryaf/1WPN/8r/x3knP/gRf1/0gk+2qM92qM92qP9v2V/zAn+ZxJ+PtqjPdqjPdqjfX/7o5ngoz3aoz3aoz3af872mAk+2qM92qM92r9Ze3SCj/Zoj/Zoj/Zv1h6d4KM92qM92qP9m7VHJ/hoj/Zoj/Zo/2bt0Qk+2qM92qM92r9Ze3SCj/Zoj/Zoj/Zv1v4fbrItkfYxTG4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 10;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/plot_visual-check_basic.py\\n%matplotlib inline\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport torchvision\\n\\n\\nfor images, labels in train_loader:  \\n    break\\n\\nplt.figure(figsize=(8, 8))\\nplt.axis(\\\"off\\\")\\nplt.title(\\\"Training images\\\")\\nplt.imshow(np.transpose(torchvision.utils.make_grid(\\n    images[:64], \\n    padding=2,\\n    normalize=True),\\n    (1, 2, 0)))\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_dataset/plot_visual-check_basic.py\\n%matplotlib inline\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport torchvision\\n\\n\\nfor images, labels in train_loader:\\n    break\\n\\nplt.figure(figsize=(8, 8))\\nplt.axis(\\\"off\\\")\\nplt.title(\\\"Training images\\\")\\nplt.imshow(\\n    np.transpose(\\n        torchvision.utils.make_grid(images[:64], padding=2, normalize=True), (1, 2, 0)\\n    )\\n)\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_dataset/plot_visual-check_basic.py\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torchvision\n",
    "\n",
    "\n",
    "for images, labels in train_loader:  \n",
    "    break\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Training images\")\n",
    "plt.imshow(np.transpose(torchvision.utils.make_grid(\n",
    "    images[:64], \n",
    "    padding=2,\n",
    "    normalize=True),\n",
    "    (1, 2, 0)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80b11784",
   "metadata": {},
   "source": [
    "### Setting up a `DataModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41995793",
   "metadata": {},
   "source": [
    "- There are three main ways we can prepare the dataset for Lightning. We can\n",
    "  1. make the dataset part of the model;\n",
    "  2. set up the data loaders as usual and feed them to the fit method of a Lightning Trainer -- the Trainer is introduced in the following subsection;\n",
    "  3. create a LightningDataModule.\n",
    "- Here, we will use approach 3, which is the most organized approach. The `LightningDataModule` consists of several self-explanatory methods, as we can see below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "409ec35d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 11;\n",
       "                var nbb_unformatted_code = \"import os\\n\\nfrom torch.utils.data.dataset import random_split\\nfrom torch.utils.data import DataLoader\\nfrom torchvision import transforms\\n\\n\\nclass DataModule(pl.LightningDataModule):\\n    def __init__(self, data_path=\\\"./\\\"):\\n        super().__init__()\\n        self.data_path = data_path\\n\\n    def prepare_data(self):\\n        datasets.CIFAR10(root=self.data_path, download=True)\\n\\n        self.train_transform = transforms.Compose(\\n            [\\n                transforms.Resize((70, 70)),\\n                transforms.RandomCrop((64, 64)),\\n                transforms.ToTensor(),\\n            ]\\n        )\\n\\n        self.test_transform = transforms.Compose(\\n            [\\n                transforms.Resize((70, 70)),\\n                transforms.CenterCrop((64, 64)),\\n                transforms.ToTensor(),\\n            ]\\n        )\\n        return\\n\\n    def setup(self, stage=None):\\n        train = datasets.CIFAR10(\\n            root=self.data_path,\\n            train=True,\\n            transform=self.train_transform,\\n            download=False,\\n        )\\n\\n        self.test = datasets.CIFAR10(\\n            root=self.data_path,\\n            train=False,\\n            transform=self.test_transform,\\n            download=False,\\n        )\\n\\n        self.train, self.valid = random_split(train, lengths=[45000, 5000])\\n\\n    def train_dataloader(self):\\n        train_loader = DataLoader(\\n            dataset=self.train,\\n            batch_size=BATCH_SIZE,\\n            drop_last=True,\\n            shuffle=True,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return train_loader\\n\\n    def val_dataloader(self):\\n        valid_loader = DataLoader(\\n            dataset=self.valid,\\n            batch_size=BATCH_SIZE,\\n            drop_last=False,\\n            shuffle=False,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return valid_loader\\n\\n    def test_dataloader(self):\\n        test_loader = DataLoader(\\n            dataset=self.test,\\n            batch_size=BATCH_SIZE,\\n            drop_last=False,\\n            shuffle=False,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return test_loader\";\n",
       "                var nbb_formatted_code = \"import os\\n\\nfrom torch.utils.data.dataset import random_split\\nfrom torch.utils.data import DataLoader\\nfrom torchvision import transforms\\n\\n\\nclass DataModule(pl.LightningDataModule):\\n    def __init__(self, data_path=\\\"./\\\"):\\n        super().__init__()\\n        self.data_path = data_path\\n\\n    def prepare_data(self):\\n        datasets.CIFAR10(root=self.data_path, download=True)\\n\\n        self.train_transform = transforms.Compose(\\n            [\\n                transforms.Resize((70, 70)),\\n                transforms.RandomCrop((64, 64)),\\n                transforms.ToTensor(),\\n            ]\\n        )\\n\\n        self.test_transform = transforms.Compose(\\n            [\\n                transforms.Resize((70, 70)),\\n                transforms.CenterCrop((64, 64)),\\n                transforms.ToTensor(),\\n            ]\\n        )\\n        return\\n\\n    def setup(self, stage=None):\\n        train = datasets.CIFAR10(\\n            root=self.data_path,\\n            train=True,\\n            transform=self.train_transform,\\n            download=False,\\n        )\\n\\n        self.test = datasets.CIFAR10(\\n            root=self.data_path,\\n            train=False,\\n            transform=self.test_transform,\\n            download=False,\\n        )\\n\\n        self.train, self.valid = random_split(train, lengths=[45000, 5000])\\n\\n    def train_dataloader(self):\\n        train_loader = DataLoader(\\n            dataset=self.train,\\n            batch_size=BATCH_SIZE,\\n            drop_last=True,\\n            shuffle=True,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return train_loader\\n\\n    def val_dataloader(self):\\n        valid_loader = DataLoader(\\n            dataset=self.valid,\\n            batch_size=BATCH_SIZE,\\n            drop_last=False,\\n            shuffle=False,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return valid_loader\\n\\n    def test_dataloader(self):\\n        test_loader = DataLoader(\\n            dataset=self.test,\\n            batch_size=BATCH_SIZE,\\n            drop_last=False,\\n            shuffle=False,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return test_loader\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "from torch.utils.data.dataset import random_split\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import transforms\n",
    "\n",
    "\n",
    "class DataModule(pl.LightningDataModule):\n",
    "    def __init__(self, data_path=\"./\"):\n",
    "        super().__init__()\n",
    "        self.data_path = data_path\n",
    "\n",
    "    def prepare_data(self):\n",
    "        datasets.CIFAR10(root=self.data_path, download=True)\n",
    "\n",
    "        self.train_transform = transforms.Compose(\n",
    "            [\n",
    "                transforms.Resize((70, 70)),\n",
    "                transforms.RandomCrop((64, 64)),\n",
    "                transforms.ToTensor(),\n",
    "            ]\n",
    "        )\n",
    "\n",
    "        self.test_transform = transforms.Compose(\n",
    "            [\n",
    "                transforms.Resize((70, 70)),\n",
    "                transforms.CenterCrop((64, 64)),\n",
    "                transforms.ToTensor(),\n",
    "            ]\n",
    "        )\n",
    "        return\n",
    "\n",
    "    def setup(self, stage=None):\n",
    "        train = datasets.CIFAR10(\n",
    "            root=self.data_path,\n",
    "            train=True,\n",
    "            transform=self.train_transform,\n",
    "            download=False,\n",
    "        )\n",
    "\n",
    "        self.test = datasets.CIFAR10(\n",
    "            root=self.data_path,\n",
    "            train=False,\n",
    "            transform=self.test_transform,\n",
    "            download=False,\n",
    "        )\n",
    "\n",
    "        self.train, self.valid = random_split(train, lengths=[45000, 5000])\n",
    "\n",
    "    def train_dataloader(self):\n",
    "        train_loader = DataLoader(\n",
    "            dataset=self.train,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            drop_last=True,\n",
    "            shuffle=True,\n",
    "            num_workers=NUM_WORKERS,\n",
    "        )\n",
    "        return train_loader\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        valid_loader = DataLoader(\n",
    "            dataset=self.valid,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            drop_last=False,\n",
    "            shuffle=False,\n",
    "            num_workers=NUM_WORKERS,\n",
    "        )\n",
    "        return valid_loader\n",
    "\n",
    "    def test_dataloader(self):\n",
    "        test_loader = DataLoader(\n",
    "            dataset=self.test,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            drop_last=False,\n",
    "            shuffle=False,\n",
    "            num_workers=NUM_WORKERS,\n",
    "        )\n",
    "        return test_loader"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "480b16c5",
   "metadata": {},
   "source": [
    "- Note that the `prepare_data` method is usually used for steps that only need to be executed once, for example, downloading the dataset; the `setup` method defines the dataset loading -- if we run our code in a distributed setting, this will be called on each node / GPU. \n",
    "- Next, let's initialize the `DataModule`; we use a random seed for reproducibility (so that the data set is shuffled the same way when we re-execute this code):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "639adb2f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 12;\n",
       "                var nbb_unformatted_code = \"torch.manual_seed(1) \\ndata_module = DataModule(data_path='./data')\";\n",
       "                var nbb_formatted_code = \"torch.manual_seed(1)\\ndata_module = DataModule(data_path=\\\"./data\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "torch.manual_seed(1) \n",
    "data_module = DataModule(data_path='./data')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0072aee",
   "metadata": {},
   "source": [
    "## Training the model using the PyTorch Lightning Trainer class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d87af38",
   "metadata": {},
   "source": [
    "- Next, we initialize our model.\n",
    "- Also, we define a call back to obtain the model with the best validation set performance after training.\n",
    "- PyTorch Lightning offers [many advanced logging services](https://pytorch-lightning.readthedocs.io/en/latest/extensions/logging.html) like Weights & Biases. However, here, we will keep things simple and use the `CSVLogger`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "43c816f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 13;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/logger_csv_acc_basic.py\\nfrom pytorch_lightning.callbacks import ModelCheckpoint\\nfrom pytorch_lightning.loggers import CSVLogger\\n\\n\\nlightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\\n\\ncallbacks = [\\n    ModelCheckpoint(\\n        save_top_k=1, mode=\\\"max\\\", monitor=\\\"valid_acc\\\"\\n    )  # save top 1 model\\n]\\nlogger = CSVLogger(save_dir=\\\"logs/\\\", name=\\\"my-model\\\")\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/logger_csv_acc_basic.py\\nfrom pytorch_lightning.callbacks import ModelCheckpoint\\nfrom pytorch_lightning.loggers import CSVLogger\\n\\n\\nlightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\\n\\ncallbacks = [\\n    ModelCheckpoint(save_top_k=1, mode=\\\"max\\\", monitor=\\\"valid_acc\\\")  # save top 1 model\\n]\\nlogger = CSVLogger(save_dir=\\\"logs/\\\", name=\\\"my-model\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/logger_csv_acc_basic.py\n",
    "from pytorch_lightning.callbacks import ModelCheckpoint\n",
    "from pytorch_lightning.loggers import CSVLogger\n",
    "\n",
    "\n",
    "lightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\n",
    "\n",
    "callbacks = [\n",
    "    ModelCheckpoint(\n",
    "        save_top_k=1, mode=\"max\", monitor=\"valid_acc\"\n",
    "    )  # save top 1 model\n",
    "]\n",
    "logger = CSVLogger(save_dir=\"logs/\", name=\"my-model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8bfbfb6",
   "metadata": {},
   "source": [
    "- Now it's time to train our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c544d03f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jovyan/conda/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/callback_connector.py:90: LightningDeprecationWarning: Setting `Trainer(progress_bar_refresh_rate=50)` is deprecated in v1.5 and will be removed in v1.7. Please pass `pytorch_lightning.callbacks.progress.TQDMProgressBar` with `refresh_rate` directly to the Trainer's `callbacks` argument instead. Or, to disable the progress bar pass `enable_progress_bar = False` to the Trainer.\n",
      "  rank_zero_deprecation(\n",
      "GPU available: True, used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name      | Type        | Params\n",
      "------------------------------------------\n",
      "0 | model     | MobileNetV3 | 4.2 M \n",
      "1 | train_acc | Accuracy    | 0     \n",
      "2 | valid_acc | Accuracy    | 0     \n",
      "3 | test_acc  | Accuracy    | 0     \n",
      "------------------------------------------\n",
      "4.2 M     Trainable params\n",
      "0         Non-trainable params\n",
      "4.2 M     Total params\n",
      "16.859    Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a99321ea1c29471d99f43362c2b3b6f3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation sanity check: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1222d6354a5046c8a6f90d9176bfc793",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training took 50.26 min in total.\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 14;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/trainer_nb_basic.py\\nimport time\\n\\n\\ntrainer = pl.Trainer(\\n    max_epochs=NUM_EPOCHS,\\n    callbacks=callbacks,\\n    progress_bar_refresh_rate=50,  # recommended for notebooks\\n    accelerator=\\\"auto\\\",  # Uses GPUs or TPUs if available\\n    devices=\\\"auto\\\",  # Uses all available GPUs/TPUs if applicable\\n    logger=logger,\\n    deterministic=False,\\n    log_every_n_steps=10,\\n)\\n\\nstart_time = time.time()\\ntrainer.fit(model=lightning_model, datamodule=data_module)\\n\\nruntime = (time.time() - start_time) / 60\\nprint(f\\\"Training took {runtime:.2f} min in total.\\\")\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/trainer_nb_basic.py\\nimport time\\n\\n\\ntrainer = pl.Trainer(\\n    max_epochs=NUM_EPOCHS,\\n    callbacks=callbacks,\\n    progress_bar_refresh_rate=50,  # recommended for notebooks\\n    accelerator=\\\"auto\\\",  # Uses GPUs or TPUs if available\\n    devices=\\\"auto\\\",  # Uses all available GPUs/TPUs if applicable\\n    logger=logger,\\n    deterministic=False,\\n    log_every_n_steps=10,\\n)\\n\\nstart_time = time.time()\\ntrainer.fit(model=lightning_model, datamodule=data_module)\\n\\nruntime = (time.time() - start_time) / 60\\nprint(f\\\"Training took {runtime:.2f} min in total.\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/trainer_nb_basic.py\n",
    "import time\n",
    "\n",
    "\n",
    "trainer = pl.Trainer(\n",
    "    max_epochs=NUM_EPOCHS,\n",
    "    callbacks=callbacks,\n",
    "    progress_bar_refresh_rate=50,  # recommended for notebooks\n",
    "    accelerator=\"auto\",  # Uses GPUs or TPUs if available\n",
    "    devices=\"auto\",  # Uses all available GPUs/TPUs if applicable\n",
    "    logger=logger,\n",
    "    deterministic=False,\n",
    "    log_every_n_steps=10,\n",
    ")\n",
    "\n",
    "start_time = time.time()\n",
    "trainer.fit(model=lightning_model, datamodule=data_module)\n",
    "\n",
    "runtime = (time.time() - start_time) / 60\n",
    "print(f\"Training took {runtime:.2f} min in total.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5e3365f",
   "metadata": {},
   "source": [
    "## Evaluating the model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3daab48c",
   "metadata": {},
   "source": [
    "- After training, let's plot our training ACC and validation ACC using pandas, which, in turn, uses matplotlib for plotting (PS: you may want to check out [more advanced logger](https://pytorch-lightning.readthedocs.io/en/latest/extensions/logging.html) later on, which take care of it for us):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "00bc9400",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 15;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/logger_csv_plot_basic.py\\nimport pandas as pd\\nimport matplotlib.pyplot as plt\\n\\n\\nmetrics = pd.read_csv(f\\\"{trainer.logger.log_dir}/metrics.csv\\\")\\n\\naggreg_metrics = []\\nagg_col = \\\"epoch\\\"\\nfor i, dfg in metrics.groupby(agg_col):\\n    agg = dict(dfg.mean())\\n    agg[agg_col] = i\\n    aggreg_metrics.append(agg)\\n\\ndf_metrics = pd.DataFrame(aggreg_metrics)\\ndf_metrics[[\\\"train_loss\\\", \\\"valid_loss\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"Loss\\\"\\n)\\ndf_metrics[[\\\"train_acc\\\", \\\"valid_acc\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"ACC\\\"\\n)\\n\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/logger_csv_plot_basic.py\\nimport pandas as pd\\nimport matplotlib.pyplot as plt\\n\\n\\nmetrics = pd.read_csv(f\\\"{trainer.logger.log_dir}/metrics.csv\\\")\\n\\naggreg_metrics = []\\nagg_col = \\\"epoch\\\"\\nfor i, dfg in metrics.groupby(agg_col):\\n    agg = dict(dfg.mean())\\n    agg[agg_col] = i\\n    aggreg_metrics.append(agg)\\n\\ndf_metrics = pd.DataFrame(aggreg_metrics)\\ndf_metrics[[\\\"train_loss\\\", \\\"valid_loss\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"Loss\\\"\\n)\\ndf_metrics[[\\\"train_acc\\\", \\\"valid_acc\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"ACC\\\"\\n)\\n\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/logger_csv_plot_basic.py\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "metrics = pd.read_csv(f\"{trainer.logger.log_dir}/metrics.csv\")\n",
    "\n",
    "aggreg_metrics = []\n",
    "agg_col = \"epoch\"\n",
    "for i, dfg in metrics.groupby(agg_col):\n",
    "    agg = dict(dfg.mean())\n",
    "    agg[agg_col] = i\n",
    "    aggreg_metrics.append(agg)\n",
    "\n",
    "df_metrics = pd.DataFrame(aggreg_metrics)\n",
    "df_metrics[[\"train_loss\", \"valid_loss\"]].plot(\n",
    "    grid=True, legend=True, xlabel=\"Epoch\", ylabel=\"Loss\"\n",
    ")\n",
    "df_metrics[[\"train_acc\", \"valid_acc\"]].plot(\n",
    "    grid=True, legend=True, xlabel=\"Epoch\", ylabel=\"ACC\"\n",
    ")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aeace471",
   "metadata": {},
   "source": [
    "- The `trainer` automatically saves the model with the best validation accuracy automatically for us, we which we can load from the checkpoint via the `ckpt_path='best'` argument; below we use the `trainer` instance to evaluate the best model on the test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1b007a6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Restoring states from the checkpoint path at logs/my-model/version_10/checkpoints/epoch=110-step=19424.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from checkpoint at logs/my-model/version_10/checkpoints/epoch=110-step=19424.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2e7c8b561f21492e99794b3c9eaa7cc7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{'test_acc': 0.807200014591217}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'test_acc': 0.807200014591217}]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 16;\n",
       "                var nbb_unformatted_code = \"trainer.test(model=lightning_model, datamodule=data_module, ckpt_path='best')\";\n",
       "                var nbb_formatted_code = \"trainer.test(model=lightning_model, datamodule=data_module, ckpt_path=\\\"best\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainer.test(model=lightning_model, datamodule=data_module, ckpt_path='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee72af7b",
   "metadata": {},
   "source": [
    "## Predicting labels of new data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd4ed5db",
   "metadata": {},
   "source": [
    "- We can use the `trainer.predict` method either on a new `DataLoader` (`trainer.predict(dataloaders=...)`) or `DataModule` (`trainer.predict(datamodule=...)`) to apply the model to new data.\n",
    "- Alternatively, we can also manually load the best model from a checkpoint as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bcc7b22a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logs/my-model/version_10/checkpoints/epoch=110-step=19424.ckpt\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 17;\n",
       "                var nbb_unformatted_code = \"path = trainer.checkpoint_callback.best_model_path\\nprint(path)\";\n",
       "                var nbb_formatted_code = \"path = trainer.checkpoint_callback.best_model_path\\nprint(path)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "path = trainer.checkpoint_callback.best_model_path\n",
    "print(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ef01b578",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 18;\n",
       "                var nbb_unformatted_code = \"lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\\nlightning_model.eval();\";\n",
       "                var nbb_formatted_code = \"lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\\nlightning_model.eval()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\n",
    "lightning_model.eval();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd4ecccd",
   "metadata": {},
   "source": [
    "- For simplicity, we reused our existing `pytorch_model` above. However, we could also reinitialize the `pytorch_model`, and the `.load_from_checkpoint` method would load the corresponding model weights for us from the checkpoint file.\n",
    "- Now, below is an example applying the model manually. Here, pretend that the `test_dataloader` is a new data loader."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "19fc6c11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([7, 3, 8, 0, 8])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 19;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/datamodule_testloader.py\\ntest_dataloader = data_module.test_dataloader()\\nacc = torchmetrics.Accuracy()\\n\\nfor batch in test_dataloader:\\n    features, true_labels = batch\\n\\n    with torch.no_grad():\\n        logits = lightning_model(features)\\n\\n    predicted_labels = torch.argmax(logits, dim=1)\\n    acc(predicted_labels, true_labels)\\n\\npredicted_labels[:5]\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/datamodule_testloader.py\\ntest_dataloader = data_module.test_dataloader()\\nacc = torchmetrics.Accuracy()\\n\\nfor batch in test_dataloader:\\n    features, true_labels = batch\\n\\n    with torch.no_grad():\\n        logits = lightning_model(features)\\n\\n    predicted_labels = torch.argmax(logits, dim=1)\\n    acc(predicted_labels, true_labels)\\n\\npredicted_labels[:5]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/datamodule_testloader.py\n",
    "test_dataloader = data_module.test_dataloader()\n",
    "acc = torchmetrics.Accuracy()\n",
    "\n",
    "for batch in test_dataloader:\n",
    "    features, true_labels = batch\n",
    "\n",
    "    with torch.no_grad():\n",
    "        logits = lightning_model(features)\n",
    "\n",
    "    predicted_labels = torch.argmax(logits, dim=1)\n",
    "    acc(predicted_labels, true_labels)\n",
    "\n",
    "predicted_labels[:5]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aad979b1",
   "metadata": {},
   "source": [
    "- As an internal check, if the model was loaded correctly, the test accuracy below should be identical to the test accuracy we saw earlier in the previous section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "28e3c503",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.8072 (80.72%)\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 20;\n",
       "                var nbb_unformatted_code = \"test_acc = acc.compute()\\nprint(f'Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)')\";\n",
       "                var nbb_formatted_code = \"test_acc = acc.compute()\\nprint(f\\\"Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_acc = acc.compute()\n",
    "print(f'Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06ec5a85",
   "metadata": {},
   "source": [
    "## Inspecting Failure Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac9773b1",
   "metadata": {},
   "source": [
    "- In practice, it is often informative to look at failure cases like wrong predictions for particular training instances as it can give us some insights into the model behavior and dataset.\n",
    "- Inspecting failure cases can sometimes reveal interesting patterns and even highlight dataset and labeling issues."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "483028cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 21;\n",
       "                var nbb_unformatted_code = \"class_dict = {0: 'airplane',\\n              1: 'automobile',\\n              2: 'bird',\\n              3: 'cat',\\n              4: 'deer',\\n              5: 'dog',\\n              6: 'frog',\\n              7: 'horse',\\n              8: 'ship',\\n              9: 'truck'}\";\n",
       "                var nbb_formatted_code = \"class_dict = {\\n    0: \\\"airplane\\\",\\n    1: \\\"automobile\\\",\\n    2: \\\"bird\\\",\\n    3: \\\"cat\\\",\\n    4: \\\"deer\\\",\\n    5: \\\"dog\\\",\\n    6: \\\"frog\\\",\\n    7: \\\"horse\\\",\\n    8: \\\"ship\\\",\\n    9: \\\"truck\\\",\\n}\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class_dict = {0: 'airplane',\n",
    "              1: 'automobile',\n",
    "              2: 'bird',\n",
    "              3: 'cat',\n",
    "              4: 'deer',\n",
    "              5: 'dog',\n",
    "              6: 'frog',\n",
    "              7: 'horse',\n",
    "              8: 'ship',\n",
    "              9: 'truck'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "06a81b4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEbCAYAAACP7BAbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9ebR1+5rXhX2eXzfnXM1u3ubcc2/VLapBWhVHAAkqRpCgYUijf0giQjQyHENDlIgiYZBQKAoaTUYYgBhxSLBAkEQxFBIRGKAyEIwgXQWoKm91t+65p3nfd++91prNr8sfz2+td99Tp7nvuefsfapqP3fse/a7VzfXb875e7rv8/1KrZUHe7AHe7AHe7BPm5n7PoAHe7AHe7AHe7D3sgcH9WAP9mAP9mCfSntwUA/2YA/2YA/2qbQHB/VgD/ZgD/Zgn0p7cFAP9mAP9mAP9qm0Bwf1YA/2YA/2YJ9Ke3BQP0pNRL5VRL7tAx7/ayLy993dEf3wtof1/HATkV8qIn/sa3j9PyEi/83HeUw/Ek1EfryI/EURuRGRf+6+j+drsU/cQYnI94jIKCI7EfmyiPwHIrK5g8/8uZ/kZ9yl3cca1lp/cq31T32Sn3Ff9rCeH2yf1PrUWn9vrfXnfRzH+CPdvsZz8GuAP1Vr3dZaf+sneZyftN1VBvULaq0b4H8C/HTg19/R5/5Isoc1/HjtYT0/2O50fUTEfZLv/8PUPuo5+DHAX3u/B0XEfgzHdid2pyW+WusXgT8K/K1fzfNF5PMi8p+IyFsi8o6I/Lb2928RkT/Z/va2iPxeEbloj/2HwDcAf7hFH7/mE/o692IfYQ3/ZRH5Ykv3/4aI/P23Hg4i8nvaY39NRH7ardedstBWvvp/isgfaM/9CyLyUz7WL3ZP9rCeH2wfYX1+rYh8d/te3yEi//Ctx76iRCciVUT+tyLyncB33vrbPyci/2O7t//PIvKe+5SI/N9E5PtF5FpE/nsR+Vm3HvtWEfmPP+B8fE5E/l9tb/nCp7kU9irnQET+JPCzgd/W9r8fJyK/W0T+HRH5z0VkD/xsEfmJIvKnRORFW5tfeOs9HovIH27r+t+JyG+Seyqt3qmDEpHPAz8f+Ivt379WRL79fZ5rgW8Hvhf4RuDrgN9/fBj4zcDngJ8IfB74VoBa6y8Dvo8WfdRa/81P6Ovci73iGv544FcCP73WugX+AeB7bj3lF6JregH8v4Hf9gEf/YuAPwg8An4f8IdExH8t3+XTYA/r+cH2KuvT7LuBnwWcA78R+DYR+ewHPP8XAz8D+Em3/vYPAz8NzRx+EfC/eZ/X/nfA38HLNfyDItLfevw9z0dzeH8Y+EvovvL3A79KRP6BDzjOe7NXOQe11p8D/NfAr2z7399sD/1jwL8GbIE/h37/Pwa8BvzvgN/brm+A3w7sgdeB/3X7uR+rtX6iP+gNvANeoM7mdwDDV/G6nwm8Bbiv4rm/GPiL7/rMn/tJf7e7+vka1vDHAm8CPxfw73rsW4E/fuvfPwkY32sN23P/21uPGeBLwM+677V5WM9Pz/q8z3v9D8Avar//E8B/c+uxCvycdz2/Av/grX//s8CfeK/Xv8dnPQd+yoedD9Qhft+7Xvt/AP6D+177j+McAH8K+BW3/v27gd9z698/C3gDMLf+9h+1NbNABH78rcd+0wet+yf5c1d1319ca/3jr/iazwPfW2tN735ARF4Dfiu60Fv0Bn/+NR/lp9teeQ1rrd8lIr8KvfB+soj8F8C/UGv9wfaUN249/QD0IuLea82B77/1vkVEfgDNYH+42sN6frB9lHsWEfnlwL+AVj0ANsCTD3jJ93/I376X91kXEfnVwK9oj1fg7F2f9Z7nA+3RfE5EXtx63KKZx6fJPtI5eB+7vaafA76/1lpu/e170WzyKeDe9fz3Okd3Yp9mmPn3A98g7908/c3oBfm311rPgH8cLfsd7YGivVmt9ffVWv8e9KaswL/xEd/q88dfWonk64EffP+n/8i0h/V8fxORHwP8e2gZ9HGt9QL4q3zlvflue6979fO3fv8G3mNdWr/pXwb+UeCyfdbVh3zW0b4f+EKt9eLWz7bW+vO/itf+cLXb6/yDwOff1dv7BuCLaNUqodfj0W6fjzu1T7OD+vNo2eO3iMhaRHoR+bvbY1ta+isiXwf8S+967ZeBb767Q/10mug8xM8RkQ6YgBHIH/HtfqqI/CMtYPhVwAz8tx/Pkf7wsIf1/FBboxvhWwAi8k/yVYIr3mX/kohctt7LPw/8gfd4zhbdSN8CnIj8n9AM6quxPw9ciwJeBhGxIvK3ishP/wjH+sPR/hzaY/o1IuJF5/N+AfD7a60Z+E+AbxWRlYj8BOCX39eB3quDEpFfJyJ/9L0eawv1C9C6//cBPwD8kvbwb0QbqFfAH0EX9Lb9ZuDXN4TKv/hJHPunxT5oDYEO+C3A22i54zXg133Ej/rP0PV/Dvwy4B+ptcaP+F6fWntYzw+2D7lnvwP4t4E/iwaJfxvwZz7Cx/xnwH+P9q/+CPDvv8dz/gsU2fY30fLUxFdZirq1t/wdwBfQ8/m7UGDHp94+5Br9UKu1LiiA5H+BfvffAfzyWutfb0/5lehavAH8h2h/av6aDvojmrQm2IM92PuaiHwr8GNrrf/4fR/LjwR7WM/3NxGpwN9Sa/2u+z6WB1MTkX8DeL3Weudovk9zie/BHuzBHuzB7thE5CeIyN8uan8n8E8B/+l9HMvD9PaDPdiDPdiD3bYtWtb7HDpW8W+jZdc7t4cS34M92IM92IN9Ku2hxPdgD/ZgD/Zgn0p7cFA/Cq1xc/2mD3h8JyI/6mH6X609rOeHW0Oe/a6v4fUfKGfyYGoi8neLyHe2a+4X3/fxfK32iTqotkjHnyIv6eN3IvJLP6HPrCLyYz+J974Pu481rMrh9T9+Eu993/awnh9sn9T61Fr/9Vrrr/g4j/VHqn2N5+BfAX5bu+b+0B0c7idqnyhIoipVPKBszig/1MdF3fGjwh7W8OO1h/X8YLuP9fkAOqgflfY1noP3ldoQEUFxB+W9Hv802qe2xCciP1lE/ksReSYq2PXr2t//ThH5s20I90si8ttEJLTH/qv28r/Uoo1f8r4f8CPcGkT0/yoib4rIlYj8ZRG5PdV/KSJ/RFSK4M+JyLfceu0pC23lq9/ZzsWNiPxpUUqbH1X2sJ4fbvLh8hff1n7/xrYm/5SIfB/wJ2/97Z8WkR9s9/av/oDP+oMi8kY7F/+ViPzkW4/9bhH57R9wPn7Crb3lb4jIP/oJLcmdmoh8N8qgc5Qa6kQlNf41EfkzKB/hN4vI3yUqo3HV/vt33XqPb2rreSMif7yt472VVu/NQYnI7xCR3/E+j22BPw78f1Co448F/kR7OAP/e5QU8meiVPn/LECt9e9tz/kpLcV9L4qUHzH2QWsI/Dzg7wV+HCo38EuAd249/r9CGTkuge9Cqfjfz34p8K+ia/4/AL/3aznuT6s9rOcH24esD3y4/MW77X+GyuXclrn42cDfgq73r5X3V8b+o+15rwF/gR+6hu95PkRkDfyX7fhea8/7Hbcd3KfZPugc1Fq/ha+UGjqyP/wy4J9G4eM3KDvHbwUeA/8X4I+IyOP23N+HUkE9RkmRf9kn9FW+Orsr2nReQQIDvWj+4lf53F8F/Ke3/l3RKf07p4b/lK3hz0FpYP6n3KLVb4/9buB33fr3zwf++nutYXvu77/12AYNEj5/3+vxsJ6fnvV5n9e/W/7i29rv39jW5JtvPff4t59w62//JvDvv/v17/E5F+215x92PtDA4r9+1+v/XeA33Pd6fxzn4N3PR6U3/pVb//5lwJ9/12v+LCpl8g0ov+Hq1mPf9n7rfhc/n9YS3+dR4bMfYqIKkd/e0vtr4F/ng+n8f1RarfVPogJtvx34soj830XkNpnmu6UINry/3ZaG2AHP+HRJQ3zi9rCeH24i8qtF5P/XSkcvUD63j11qQ5Tc9beIKvde81I08oOkNo7n48cAP0O0RfCiHecvRcX5fqTau6U2vvddjx+lNj4HPKu1Ht7ntXdun1YH9f3At7zPY/8O8NdRvq4zlKzzq6HY/1FntdbfWmv9qcBPRktT72Z9/2rttjTEBi3h/LCWhvgo9rCe72/y0eQvPpLUBqoO+4tQ4chzXmpPfbVSG3+6fqXUxqbW+s98Fa/94Wrvltp4d8/zKLXxJeCRiKxuPXZvUhvw6XVQ3w68LiK/qjX6tiLyM9pjW+Aa2IlSwb/7wnqQ2gBE5KeLyM8QlRHfo2zPH1Ua4ueLyN8jCkb5V4E/V2u918jqru1hPT/Uvhb5i9v2fxSVefjJwD/J+0ttzGgPcIVWUb5a+3bgx4nILxOVmvDt3P7Ej3CsPxztP0e//z8mIk4USPaTgG+vtX4v8P9FpTaCiPxMlPX93uw+QRK/U0R+53s9Vmu9Af7n6OK8AXwn2jwF+BfRCOoGFUd79wX8rcD/o6XvPyLQOe9nH7SG6Obw76F9gO9Fb+Z/6yN+1O8DfgNaivqpaEnkR5w9rOcH24esz0eWv3iX/WkU1PAngH+r1vrH3uM5v6d9xheB7+AVdLTa3vLzgP8lmk28gYpOdh/hWO/cPuQcfKjVWt8B/iHgV6PX8K8B/qFa69vtKb8UBZ+9g0q9/wHuSWoDHrj4HuxDTER+N/ADtdZff9/H8iPBHtbzvU1EvhHVZvL1YSbqU2Mi8gdQgMlvuI/P/7SW+B7swR7swR7sjq2VO79FRIyI/INor+8P3dfxPMhtPNiDPdiDPdjRXkcVyh+jKub/TK31L97XwTyU+B7swR7swR7sU2kPJb4He7AHe7AH+1TaK5X4/t1//idUayzOWLwEqEItmVIz1RREwBj1ebW0zEwgl0zJmYKAWEz1mOoRA9ZknF0wJiEVqBlq5shnmCvEYkhYEo6MI4slF0vKhpSFkoFSgYKpBaHijOAMUCuVClQqmZqTfoZUSi3kUogFliL8xm/7wp3PU7311ltfUwor8gqHXCtChVpBoCJtckTaCgm1CtLGSfShenr01qfeesuvPPx3H8+TJ0/udE3/4z/zhbrf3TDu90zjgRACjx4/5vzsjGE1EJzFCKd1cNZgjcFb/REBSianhVoyITi64LBWsCKIgIjBGCHnzDiOlFLwzmGtxViLsw7vLIJ+TkwLMS4AOCdYa7HGUrGUCsuykEvGGn0P7z0ViMtCjpHa3r/ve9br7k7X8/d++1+o1nqCDQwhYKwll8o0jxxuXrBMBygLhoyVdl2VijEOa4J+J+cwVjCm6l5QE8YYaoUUI6VkQDDGYK0FoJRCrZXT5VT12hKjzxPR19daKOXW42IwxuC9p+87utDhQ8A6i0gFqVSpYC1iLT/tJ33+TtfzF/6KX1wP1zv219e8uLoixgXvLavtwOpig3jPmAq5AAh6sVrm3cR0tePmrWeMNzeEwbN5tOXR0y0XjzbYaqnFMI2FJUZyXgi95exyzbDusM4gCCVVas6UUnDeY72nVkucC/vrHfubHRhD3/f8uG/5Oj732UtyWvjyl97ir/yl7+TNLz8jDAN9FwjeY8RABdv1+PWGP/kf/fGPdT1frQdVk25upQIGqqGWBFTEoDdv28jEAChdhRUQaxAMtVp9HaLOo1SKqHNRB1WRKvr+Ri84cJRqSdUxJWFKsORKzIUYISegHB0TzTlVnAjOGpwRrFWHV6UA5bQxizEYwH4cq3kP9tWUaEV0rY/nQ97L2VShHOlN2o0u6LkWqe+agHz/z9RN5f7mpo0UrBSsqfojBScFa/S/zhiMALVSSkSKwYjFisMaoBZqzUgtQIYi1CxUEaoYKhVjCmIcIhUjxwCoAG3NaqFW0QAoJeZ5Ii4z3hosgeOaG6M3jWnvYKRiperxAUV0pXO7ts09LGtBP7tIpUjGGLAWghhKHXBBkOiwacGXRM2ZWgrVCjiLdAHxXr+7re0+LYjoVZhSouSi970xOG81QKqVd1/a6oAEYwREKKXqZ7WYC/RxawzOOUIIOOew1mCkIlKolFPAeh/z/dYafPCELuC9w5jCsO4YNj1d35GNwZREOX5fY0EMUtWxUPU6sM7gvEFMuz6qo2Yhx0RaIjHPGOMoedD1zYWcCssYKUXXv1tBZx3GgDHN2aeMcbqG1lqcte0eEUoupFhwrlCDwbmOrgsY5xDvwYWPfb1eESShF5JG4AYpRi84A7S4u+37AKcLTEQwIgiWikNsQKoHMlKhEsnNZwim3bAGqYYshoInVcsYhUOEw1KZsyEWwxIhxUotgtSCN7x0TgaCE4KDzgvWCFJN23yLHrPoyflRUetstHBHdrh668+1QkqZJWXdKFoGQKlYA8ZoZnWPvuerMkNpG706qpPDkoKVjBWDNZr50xyRoWIRrLSbtCaEBLVASVoNyJZqjpm4oeWf7VL/ipWkolH9vMxM48g0HsgxMvQdwbXAy4g6ndN9U5F2wxhpQd6t9/uhgcXdmLrd9p0oVBGM080rmA7vwU4VN0X8YaHMCym2QNY5vd+xOBF8y5JOSVGtFBGKMdRSkVadMca0faG+9COtMiPoXgKQTaEUgVL0edYh1iJWszZv23sJ0NZXRN/3uLJ3bWKb8+wCoXOUgjqndY/rnO5jRq9JY6xmii1YrClDyRgRnNHMv5ZKilmv1QwpJtKykHMkOyBXpLSrNBXiFCm1ItZicyUc11c0OC25Yp3e79YK1hooFmuMHo+xGOsJvmMYVvSrAdt5CkIsH/96vpKDMlRMI/BzUpqHh9ruVDEawRxLRKUWyjGjEgPGYlygC2cEN5BSJMWRec6kpGm/wVL1kyjVkIolVsd+rryzm5mSJUmn5T5xRGtJCClGclyoccGUhDdgTcXUiLeFzWBYBXVY3rnT5nW8cO2nfOP9OKwK6phqbdtr1Xu7VnKB3WFkt99jnaPvO0wrg3Uh0HmPs+YU+X5aTWrCkBGyOh6pWDK2JkxJmCpYDEhBTMGKOiYjWsKrkqmSkZq0zJxFS0Lt+sglU1uELtwKvo6BW62UoqXjq+sbnr3zNtPhgFB5dHHBqu9xDo7RvtrL1x5Lj3oXtcysFmotX1W2/HFbxVCNUAxkdQ+YKoDFS8XYTHAGGyd49gbpZk+eI/5sS7i4wEw9WA/GgxicCJZCypmUM1IrjoqpBnEW0wXECpI1cxOgOku2rWRa0M+vkEwmSUZSxKaCbM6RYUsOXp2j8HL/ASxWM5FqELEgdw9iTikiVvDB0/WBKpZhM2D7jiqWUipGDGK0FIwYSq16GeSEULFGr7maK3FMUGYcIMUQp1n3wZqR6nFi6VzAGUcyiZoNqRSKCM4HxBmOCytSTyVU25y7FYNYSwgd6/Wa88vCer1le7Zle7YhDB3FG+Z5Yd4fPuzrv7K90hkSY9F71bQbs91XcoxGbkXY7WaSk4dWBxZC4Ozyks36kvEwsrt5zlIWPXHVIliojpQNMVemCFMq7ObKiwNk47H9mmo6MAERp1mRXagykpaZWmdizUjKSBF8zhSppFpZIfQiBKNprGZS5RS93rV9lHLYR9qomnNqddhW0oNUKjlpuXS/H7m6vsGHQKkFby1WBG8L1bUTeSoXfjrNSj05JiMZU21zWKk5L8HiWlaSdTmKwZxyd3VuQkFK1k0uQ231tZwi1Rhqce3cqVNR9uUC1ZBrIZbKzeHAs6trlnHEWcNqtSZlDQpK1axdeOmU9PXNISHUUl7eRz+kD3g3pp+o5c6CI5dKbWVxEaM9JrHYUqnjiDkcYC4Y73DBYcYDNUNBsymsIFKpObXek5b0bdX+Hb3XQLdUpGhfu3gL3kIRpFVeqYAv4ArMEzUVbDGIGSidUMVSqz6xSHP4VTCna/hlIH2XZgAfPN5apnigkPB9QLxjSVBKRbAtYHLtXtVrouR8uvdLLqQ5IkBJlSRgxFBKUcdiHM75U4kQa7X82WVqbnqFYvStpV13rVVjWpanPVGHM8JqteLs8pxYLcN6zWq9YtgMuM6TrZDIMH786/VqDkp6pN2o5VZJr0ppGIWMiEY6pdQW9bXFqNrvC8Fz+eQxj1/7PFfvvCDVwn4ZSdNCrYZSHbU6pqVyc5i52c/cHCJTErLt6dYDIVwgfqBajzUeVw2xWzDdjF8WcpxY5gMpzlr3lsS+zKQ5kWohFVh5Q+fAGmmbdfxYF/artTvt2citqL0KNRdSqcwps8yJ3TizO4x0peC8w/QGb61GVWJaVH8sav2QBoH+526+yfuaPWbOVO0jVY06TS1ITUjR6FRaKa/mSilC9dKi6qKvK1nLe6L9J6qlFkjLAkbwXgENLQWl1kyhUowh18oUE9OyMM6RFDMihlIgl0ouFZMrxrZeTHNOpSg4oJQGECqJWgqmZWn3ERhIrUjrPdfiKMYiLQKXatRpSUDQsn21A9JbinGkOcE0UQ4TpRiqOIoVsq1EyUTR0pwrYIvTzdQZigjkcirJZWfJ3kIVTKpI1uss9UIKlTpNyJyptce6DXQrcJ7a+oNazK9U0XC0UhvY5e6FZXtnGYYBRJjTnrnM2GApaI+nZjDtf7Zq+FLQXn0uhVIqpVbSksDMlFzIvmBswTmP99p7894SVoHiDFMt2Jo1zHBW48zSQGJLBCPNaRXEVqy3uODx1uFNwDpYbwuXTy8pzmOcw3ce0xkIDbiyCN5//Hf/KzmoufaYCrZFJU7yqV6uOSgNANGivVO/ivbvTCmJlCLLEnVjzDBly5gsc6zMMRNjZZoLuzGyPyR2Y6KIw68Cwa4wYY0LPbhANo6CYFPAOk+yM8lZrdtar2WqMjMumSlGllSJuVKrRsCDsYgk5CPzft6vac/vK1F1xx7T8aHjv3PVizuXQi6VJRWWJTMviWnWzXRJBUmJJWdC0Zv6h8TvwntHn58CJ2WNZlEihVoytQi0jEh7Trn1MEr7W1HH3TKnI4pUw3QFO9SSmwOppLS0MozgnCW1qLbWinMO550CI6aJm92eF1fXUAvWWl1/1EmZUnDN4dTm4GrN5FSxFqhQcqLUouAiPmLm/DXaMcCUY/+5FLKRU89WgbJCFQe+R4aAcQPiC1kSdYlUEbIVPTlOy4WpFo6xazGG3Dr11Tt9XqZlkpXqLdV7KJUiBTHaAy9BqEF0m6Hoc6w2lNUBHTMlWg/8uBVJC9buejVbr7sBlqwzuKyBjwJqjr10RcbVUlr7pAUw+WXAX6sCRETAOAWXuM4R+o7Qe7y32KDrkUolZUVKVqDUSomJNBWWWuh6h/MW6yw+tN+tadmTJ3SWValszjaMRXNpYw3VaXLmnKXrAgyr9/3eH9VeyUHtlp5aMkYyva90FoLRBrOpLUqp+dhzO0WGUgVqIZfINO14580vsdup83mx23N9iFxPcLOPXO8Tu0NiWioZSyqQq8O6nhB6bOhxocOFgFiPMxp9OKO17SlnSrb0w4radZQcmWcYxwNxroxkllQxWLy19MFhxGDr3UdTcLxh3mvjkQ/d6Y89kHf/9SsawKIN/VIrS0xMMTLHxBIVEBFTIS6ZeYlMMVHEkqshxsziM8FVUtVN1doPLzLdewYluZX5jg4KzexrbsFTUucqBSNaAtIelP47k1G06ku0V6lQqnZgYozEGEkpKlT61mkKfSD0gZQj4zhy9eIFb7/9NsF7+tCRSiFTSRSkJFyxCthogVstCsowJiMilBwpWSHbx77WXZvew60bVKGW1kyXghWwZMzR6fcDpne44QxsotaZ6iy112Cydj3ZqjNhmjBLRKHU2mPKoYOhQ7xDimaWhYo4i+0CNWVKzApaMUJDRGFiQmLBnJ1j1muks2ChigEMrlX1jkjdAlSxmjHfscWcyIe9Bhu5YCrkOZIKlOSoVXt8NRdSilRt+Dd0ZG79STBWcMHSrwP9tsd1HaHv8F3AeY+xAi2wyaXomlVBKqQ5sxwm4jRRYmRzsWZ7scF3jiodzjrNVsXinKMLHbFWwtDjpwWpueUiglhD8IEgjhX+Y1+vV3JQ13Ngd9iR08h2BWeDcDHAYLW2K0Lr5bRIWo4/rW5aCynOXF89p94kxkXYz4XDUlmKZ0yV/VK4mmBOggRF5VQDJvRU6zHe41qD0VhPqZWYErVGTI1YyeqsnIfqmOdKXSxZPEsJLCmTc8HbTOcs685gTL2XixVazfldu7puoPVlOe3YPzo9fvzluM4v3yCXojfgERHWXqgZU+YwLezGmWmJLDGTSyWmQkpZN96Y9T1qJeVCSklhrCutTWvjtgUj3D6uW1/iHqF+0pyRlEKJkVIL5KTjEKfESDDNiYk0B4UCI7S093IzAGmlIr0pU1oYx5FaFSZunM5EAeSacT4wz5FlnJiniWmadF5qntmNI1e7G5bF450hlzXBe1JOOh+UIlXA2oJB9N+tV1isoeS751DVMr1pyLcGWqiaTRVTkRSRcUT2O+p+h3Q92LXCzIuBEAADPkDXU63OQtkla9nVKHgK58EHajeAdzScNRjTeiKWYhJIohioDbCjyFKPCfrcmicYC5SOGjqwrlUBIMvx+FsuVe/+Oh1TYjmMlBSx3iBW7/WK9nuldUNLycR5UQdVLSUlKEVHYpyjGwLD2cDm0ZrV+YDrAi4ErHeIGO0rL5k0JUXmicG7QOh6conEcWHcjaRloes7DdKDRYxpSGcwzuJDIPiOrlZC6AidR4ql6lnFWU/f9VQi8yfA8ftKDurF5PnBt0b2++c8vnB85jIQXEewBm/0hj+mr2KkoWU0Wi3t4s61MI8jS66M0TJlSzIO/AoTgqJ48oLNgu0CYiw5Z8RYihGwQugc/eDxzrMsCyVGlnggLwumFILVgchaYZk0ehAbqDbp83OmO0QGK5wNHudRZNc9WM5JYe+3egwips2VyQmX8JUmp//K6f81ayq1srR5CTEGZzSDyqUQU2oOauIwRWJqdencnFGMpGWh1oIdR/bOsusD8UKbsdZZXHA6kKkf+EPsFJ7Iez/+SZvkBSkJcqTEhVwsNUVIC5iCZDBZAT62ZP0vgq0JyYqUqjkpiqGVh6TNztVaSHlhWSZiTCByGkKtIsw5E6tuDNN+JC76PjEmrvd7/DvPyDkSvKUPlovzCzbrtSJISyaniDO1lSnVQZUC1Sh0vt7DJXqsgtSqaK9Km0+qDcSwTNgXL7BvvUl+84uU9UB1leq8XripULPOnlUiRYoGC4cJs18UGOEs+ApZy1vVOr0XrMF3oZ2fGdGZEkyw1OAgVWQpiv5zlno4EMkY75HVhnpxSR1WILbNVDYUcjWYUtvYwN3afp65ef6CZTywOVvTD52iip3BOgdYaoKlleFyq0qlJVGzAiDCENhcbjh7bcPq0ZrhvMdaoxBwY0ixEJfItD+wf3GgxEIfBs62hmEVKBLJU2E5JFJK1ALOB6wXjK2UYhBXscFgu4D1AZcL3nu6EHCtm2MqeN+xCisO0479zcePknglB3XIgatJuNoVcJV+qDxNhlQN1ehRH0tL0mC0IgoXLxVShaUK05KZ4kKsHVkCxq3wpsOnSMgLHQuSUQclQk65pfuahUHBW2EVHKYmkhSmEilRZUuMMQ2dW6kltcYzFJ13p2bhMGd2PrGfM06E4RNo8H01lqs2wNuIJ1BPTudUM+flL/KuqO/2c7SMF5nm+SUSx+qulhusV9N9tAZvbJvoKZgqbQDVUnMlp8zcmtSHaWboZ1ZloAitYd/Otdw6itabul32umszJSNZfzjCcnPGl4LPBZczJiYd0M9Z5z1EsDkjpiIpQVJnZY7D4kUUiVa1j2VMxVgdFF1iJM2ZOWZyuaYizNPCuJ95851nPH9xQ6ZytT/w/PkLVoPX+TwrPH70mMePLrk827Ieeh0UdoZk1RnkuJBzodQZkz2F+8igWo+nKAODtGakyRVXM3ackOsbzPU1ctiBZMruiuo7ivFQdF5SovZL8FVh/DlRq96bkhWYIqVgYgajSEixBuk7pFZMztR5hhSRziG91w0lgvQ90nek8YYUJ4xzmCVhQg+u45gtVSmn71KMAlXu2qZlYT8eiNNIfzY0RguHM/YUiVaBjK51zZmUI2mO5JTpgme1GTh/suX89S3dtsOv3KmKUmIhHxYO1zfcvH3D7sVBeQk2hTwMWCM44zBWEXrUgrNenaRXpHZF8MGAryQpVCPKkOIdwfvW19XhYecCznrSUrh+sf/Y1+uVHFSUjmxWZLNmqZYle2IJpIoiomptTV0FN+mQnGtlCmEulX0SxhnmIhgXcN2asD4DOxDrzFInZmZsrkiLwrJJ5JQoKZJiJM4TrAeCFbCWxQqmVkVdAVTDkiI56SR/beWTnDJgqGKZYmI3FW7GRHCWcE8OqojRCE9Ea/NyRBi1Csfx9wpwbOy+PNbbR11rZZkn9vsdfd9r1Fr0FJesPQ5nhC4oEic3Z5dzYYmJ5CzJe619ZwUWWKdg6Fhqa/KLIjiPO9WtozgCMu7TSZljZF8ythZsNfgKvgihCi4VpMS2pkVZB9AIX2qGGCFmnbURw9H51qiUXk6g7wJ9b5lj5no/crOfeXG95+p6x4vrG/b7A+Nh4jDOTPNCLJl6q9dV84yphdceP+Kzn/kM3/JN38jnXn+N7WaFDAFrrAIJlkhadK5FukDH3SNNhSPKsNJQ9JpNl4pfIvYww+EAy4IzFsmVuj+QfaG6otDyYtr1lLGDhc5QbCX3oAFZwuaCmxLCgsY9ykZRRqvZTsqUZabEBekcpg9aeqwKiijeEMeRuN8hzuGqJWwnTB81qDM6+1ZF6dNAkal3bUuMChCxgh06wmZFZzzS+k61KFhLSQasDtzOC3lRBgjXOTaP1py9tuXstQ3ihWpq61kW0hgZb3a8eOMdrt68YR5nvPes+kCpUYfQnRBWKwVhRMeq7/DWIbY5o87Sry3ZZcYy0dceBJxVB6UEDQaq9keVYily9fz6Y1+vV4OZ+w4bVoQhcna55ewi4PuKMROlRm0wS7uCjaOKp9IhPmCrJ06Rw5JYioANhNU5/eoS368pePwsWFewJiGtzHLKx1rDc5lmXjx7TjCGvg3vOWsJ3mGNYY5JT2qp5KyNZRGdiPbOUIulZMOcKvspcT1G+g7Ww8dP0/HVWLEejNV5D8XYnJCRL13AbdYCvsJJnZBdor/nnEhxoXjfXq3f31lDcJbkHGDoEBCdPUk5E2Mm5QZjLYpu0/EJoesCQ99hQ0cV0+ZK4Csc5ck53crq7sFDjfsDyzgS54WSkmaV08joDGU50hmps3DOElxDLXkQU4kpk1KmYvW8tGym1EoqOlBeK2CEXCqHceHq5sCzqz0vrvZcXR+Ypom4JJYEGUfBaJmMiimVZcrkeWyZWaXznpoTjy7POd+sWPUdViDOI3GeSMvIaughLzy94/U0R9YVxWo3wJOe4QJE76jbDVleI8Qt2QrRObJxZOdAHBXRjLYWTO+QzpL6Xkv3aKnIZeWBtKVRIJnWhDdKwVVyJs0dKS5IsNjOt2vRYjZrzNAjJeOO99NqQ/GeYvS8annveEcc7e4zqBMHXu/ZXJxzdnlJbwM1VZZxZB5nUoxAoescVA8lsgRL6T3rs4HN5ZrVWU/oFUqfWlJQU+VwNXLzzo798z1pjHTBsT5bc/54w7AJLHkm54z30G8HettzdrGmHzx0Be8qtjP4wSM+s+SJOU7UqFVXI7bRwx0DFyGnwjxF9rt7HtS1vsOHntVGeO0zn+PpZcfK77D1GTWO5Br14I0B6yl0VHpcOMOYgTLvGeOeIpbebxnWj9meP6JKIOaKcwkjM+RKWTLFFIWLi5bspArTOBH3O5xUeq8zBbY185zzjNPM4TA25BV6PCIE79pEdmZahCVWdiXS7WA1GC7vqwelO2Pr1yo8ukibAWn9PFOP7akj/8NLa8Hg6fdS2kBfURofqQUjluBtQwlXTIPpWudwodP+VMyU1qBF0El2Z7BOz6cx4J2liGnITE5Aw+Ps71c4UrmPMUi4ubpmnmamcdKZJWvZ7/ZQMsFaqOpkvDWshp6u84TgtWwn5QQQwTjEOo0QRTnjYk5EgSwGijAuCzf7kefXB55fj9wcFqYoZAnYEAhOex6+nTtnwdTMQSxjzixL4urqmi996Q1yikyHA4ezDeu+x5mqva55JE4HtpsVlMw33/F6miMn4zFaqjQaIohGSEPP8tpT3ONHJNSRLFHpdIptYAYjyulYKsY7cJZYMqkoWtEh5KJAf4tQjJCsaDQPxFpxpZAWHei3RrDeUa0hO4MNHdZ7fDfg56yowC6QVgPVG7D6Pk7he+Rb98tdW62Vru8Zho6LywsuHz9iCAN5jly9MCwxEfOeWguhV5i3q4EyeER6tpcrto/WdOuAcUbv50YvWmbYvzNy/eaO8WpCEM7ONjx6/RGPP/cY5z37nfakvIGLs47LTU93tkZWnrqq0FlMAOcd4jIxTYzTgZotKVeO3fojo0wpmulP08x+f889qLPzR0xLJi4Ll4+fcnER2IrDL5Fad5S0AJVcLVIDq/VjNmevs9o8xffnrK4ObJ9dsTtM5Aqr4Zw+nDGnrI3s0gbUmpOraL0410xKkbgsmJrwFFJMp81ExOJdoB8GYsqnn5oLiJZvgnMa4bdZjpIWcspc72eGYNgM96Pd+Ff+6ndgjdVeiDOEYBm6wHrVsx16emdPXGI6WnasU78cdDreaEWqIny6Ti+wRkYqorVl7w19BecqVaySQTpHqRCPwYCxbaCxDfK1DSflBr1uvZ16dJ7W4NscRN91dN6dZk7uw37wS29qGThGxvGAiDBOI31o/bhaqSXjnWXV93S9JzjNrF7O9IFpvG7GaKSeUiSWoqwG1lONYz9FrnYjh0nnxwoG44KWm6VqUzvlUxasUUbBWkffrbjYDpytB/o+UFs/axwn8jJTUmR/2DGNIzEurG9GdlPmp93xelqrpTFOI646G6azyxbTdYgN5FKYSyHOM1OuSnRr6kugnIjS6RWhxja6UJUf04oOpToRnFiqMQqIakwdbVBI+8dGZ9BsNdQi5GKwFQIWMwR838rl1pKdo4pFsazHJu7L73YfDsqIIve8CwTX03U9fT9QfKCiZb55PzLNIyVHbCl0znK23TBsBs4fXXC+2dKFDoulUIg1Mu1nxmcj++d75sOC85bVeuDy9Udcvv6IzcVGg4qUwFWcMaxWPf1mwK866B3Fa28uzZE0ZVbrHtPpPFvJx2oMHPntSoGUM+MUOez3jPdNdXR2fkkqkHLi4vIJ2zPLulY4HFjmQE5W4afVUcSxXV1y+dlv4eLR17PaPuFyN3H59jt8+a23ubq6IQwrgluxLCM5LVAEK0oY6awSIZ42yXlhmka8VGywbeNtxK/G4EJg1aDRMWfqNJ8yutpKXDR6I4AUF6a8sDuMBAur/uPH8H819pf+6l/FisM5gw+W9Xrg4nzLa48f4Z8+JtgB0+ZBzCldagQ58pX5VEUjn24Y8N5jrWsZka6TbxxwvnByRsaq5IMxbdJedKA058QSI/MyMc8z8zyT4kKcmwREzlSpOGcZhp6z7ZpHlxd4a1H6+hMo8U7ti298mVr0molxoVB4dqPUMeZI0CrgvWXoOjqvQ40Owd3iIjPWqpMyOo0YcyFXMF1QyLQ4xiVx3RxUSg0q7OXkiDIJ8hHZKoDO8FhjCMPA48ePuTzfUFLEGM1+Y1zIS2EeDzx78Zzd/kDMla6feHZY7nw9NYBRxQJu9R0rgLFUYzHeKC/csjDFxAEty0mVNhzecvMq5MYuc3Tb1lqcVGxV5KK1zR+K9jG1tVzIuWjAWRWBaWptbZCMM47sKl3X6bDw8X+WE3DniIg9zhF95YjE3Zk1FikVKxbvPN4HpYQKAes9KWaunt1QdiPLPOMFBmvYbAZs59henLNZr3HuCFYomCyM+5H5+cR8PVNipl93bJ+ccfn6I86fXtANXsukSTk2u+AZ1h1u6NtAr0VI5FxZ9pE4R87NGhN0jUvV4N5otEstrcRbItM0Mo4HpvGeM6hUYXt2gfeO7fk5XZ9xaaTMGmXWNqEdkzJBnOUOv35COPsM3eYJyIE4C7ubhWlMeNfjXcDZ2EoJYI1hGBQtlsZJ+boaAeeyLBhvcX5gtdlwdn5B13U61+QL1jmmeVFwRttknPdgjE78oyUuay3Od1jbE2VhXOD5zd3f/ADPn73AGp3cdt4wjQM1ZVY+EM/PyF1HIzuh1Ko1YGlUA7yckVLfJTrA3LIj66zOhsgRZScYC2Ibj3ZDYgiAqcQYmeLIuCyM88w4jkzTyLwsLMuiJZYlkmMiJwUNeGdZb1bknFitVgx9R7XqQO+DVvbNZ9eNlaGQ0kIVtOZ/ZLYGqBlnhTAuKsdiDd5YleIAZSJosF2V1XCUKlRjsV1FnIpQzEvkZj8yTgspaTZfWwm01EyMidjAOlAJRuis0PUdnQt0wSuVT47UXIhR+zOrdY+zwouba1JRQNE8Zfbp40dJfZiF4IjJUmtVB98cxxHMo51hzZZUkkN/FOGp14AO7TeNo5YYuQb4sUcU5RH12zKmko8d2UaUa9oUVm3v28p/VZRjT7Jy0hdjTw7IcEQd3pKLeRfTyl2bvVUqVTBIkwix2ttZbVZsL85YpomraSEuMwuVzcWKzbrDrgLiFHhiC9hicTEwRcdQPdtuRTCe/qzn7PEZq+1aWdJF7/thE7De4DuH814rAk7nnuKY2N+M3FzvWabIa6tL3JkqBORj9oxoX1EMpWoVK+eFnBZyuec5qGmOnJ2fc77dMKx7vJ2xEpTmvvUvhErOlXGMHMbMYRFWyRJKoJAxxuNs0Nqq9SdkSOeDapAYQ98Fci0cZnUaqpsDMUZ67xhWK87OL3n86DHGWsZxJOcCxmKdewnUFoN1HtMa3UpXoxQe3ndEn7A+kmpiN97PFaukjOqgDGgtORWF1ueqyJyaWj+psXNbbSDXI9xbaKo92jux/kjT37Kt25O+xpxuinqk0Gk/c1y43u/Z7Q/sx5FxHJnn+cSeUFOhpFZejYklznivznK9GogxKQcj93b/83x3aJ+eSSVinGGwToUJ0aw8pwJLwUg8yRYEFwjOt0BAeyNYg7EeYzxiNNCxpYJRuP6yLEzTQmwDwUeHXFAHlXIiZUWPSq2YvmPVD6w7x6qzdJ3T+aaSSDUTl4laOzabFWXoeH71nKvDTJmVLzEvdx9EheBALLko4lGMnMrLt4rLWoYzuglaZ5oDa3S4Va9jGtrsKDhoRHDWnsYsbiMGc33JRI5r0hK1tAy0iZEqxAJjlbUbGmGZcOrhKt3eLSDR6ajvR75EjhpWuZxYOYBTdadf9ZxdnjONE7vrHfM8cogzTjrWK0vpDckUSGCi4IvBJstcA9Gu4BKyqfSXa1bnK8Kma/NVSUuLfWhce06Rg2iv3pZCnBb21yOH65mUcgvmBYyOplQKpap8ShFlZdH5i+OA+8fPdPJqMPOUdQbCKlOucxVHh/EB77xqsUjFm4zkwtWz53zX3/wuDlPgM5/rsTmyTDOl5Ma4qyix1dCBqRymnTaZo27CXecoKAMCaL3TesfZ2TmPHj3i0eMnKtmRErksSgeTiyKxbiHSxBq811mBUgXvIXeQU22bR6SY+6E6+pZv/ObTvJIAnXesho7Lsw3eeSWDTJGaFUZjxGKtV3SZ1QHESuPZQ7m8qII0ORTdDDR+NGIw9iUHWaWV9RoBZWzDvKmxeDvvdTDQeXLIyvadYZkW5mlCRsFZYegH+n7AGt0kStUSzH3YlPWmErFUW7Eh0A1rQtB5mBQjKRVi1D6P954QLNZ7sh90Xiwt6uyrwYnDuR5nO8R2RBwlo7Mp2VBQDrnThshR4FHwTQozU7EiXJyt+MyjR1xsVmzXHSIafe6CMB72zPPI/mBBnjAMHevNimE/cT1PxFxI6e7X1HlLqRZTlN1exFJFnXhORxRpm6nzhiCCWMdLOunGHVeOooyaLZmmfGsbiOmY4RzpO4/imYVCNbQhZd3Ujej4hTo1HWUx1mGcIbfhW5GX5+MlFvgljOcI7rlrKyk3IJMGoaWp2+pgveC7wObiTB3UiytSWchjwgwOu3GUAHON1AR+ElzxhGwYiiUPazbbM+yqY3W+wq091VWyFBIzVRLYiq2CnRVvX3Oh2kgik6cERfB9R+cs3WaF7bxSdBUlls5VB9uV+/+ot9ZEaT+B9Xy1El9KJwVMERWuMsUjVvVGxFoMhWQKncncvHiHt67/OkseELdhsEKZrpnjqHNT4jAW1kOPHxw3+2sO856YNUoauk7LLHPCWq1vhhA4uzjn7PyC9WarjXCrEd7SeOZio+dRqHk+OSjnBZcrKUMIllJ0doCyYOV+yGK/+Zu+Ce8cvukLaTRvCN7indLbxCWS4kxOSSlJjMMGpX2qopIZc6v/lwrUpicjWuZU0IlgjcU5BWQc+0+2gUeOQ7dHrRrj9DKUqtT+tRScKEfaNM6Mhz03O48YeHTxiPOzM4JXtdhS6suB3ju2ajziTOMNtPiuox/WBN+3jUCYJZJrJGVVJrW+ww1r/LBGUibHVlo2BnyH6VaIGxATlHUjZZacyUUdoZgGy9fqUztHcqKGKs4QrOXRxZbXX3vE48szLjYrSkksceKqs7x4VnnnrT3jYU+KC0PnGYaBvuuoeadzgPdAzeOsUJ2hZNv6t026MCeWedGMxjq8UzSk857Q9cAxO9Cf44C5afRERhSqbI8B1MlDoWW4k4PSa6k0sUgapFoqTTql7YxiqEaBQtp3uoV+lZfOERQNrFnb3Vte2rxo0tlOrUZkslWhUBscw3bFdj7j/OoMbMaPlvX5im7dIQ5KjkgCG8FnIVRLh5B9oDvfMpxtWJ2vMMESc9T5UgyxLuQaMbFi5wqxUlOlGgVCSMx0YgnrDr8eGDYDJjjqvJBLZsmVlC2YoqAiqwrmVl7Oa37c9moZ1LIQl3QaeAVLzqJyBaJ0+bYWOgtDgP1+Ynf9NtfP3+b66hnRQZqu2d28YJonTLhk7VYM645eera7FYdlz5J1mA1rdfPwmWWJdKGjHwa22zNC0DJgKoWUC3OMjNPMctyk23RryoUasw6WNjohawzVG7qKDsYVi5W7n9IH6HzAO0dwR3CIbRIXaOknawY5TTOH/Z5aBWcd/XpFN/QsKXOzO/Dlt9/mnWdXxFIUodfKhr7JNjvnlIrfO7z3+BBYr1ecn5/RN9Rf33lgTR7Ky/o4TQagZKyoJs+yjkxTz3rdYwxcXJ6z3a7xNqikRNaJTmfvfgsY1mu801LzEg+UFqRko8q4JVeKzh/gu4F+s2Zzfs6w2tANK3IphLhqyMUMxlPwmGqpRXRmLKWWucfGVKIIR5GqkujGqvqodkUI1rEKjs16xWY1sO4CQ+cwxlNKIBjBlMJ0s6OWxLQ/EKwlWEvnHGmeWaYF+QQktT/MRHS4OxVRdFfS2ZhpPjAdDtRS6PzAZrVhcGd4FxCrlY/S+qYnNeCqYoNHkUdzAjodc5oWKLWe1dHBabZTX/afOAYCtzSdjvMNtZ5K2NpbffkZR/ViqpzAMHdtMUagkpJnmRfmw6xy6qUwrMCGgPGW1dmKx597yua8J84j3drTdwp0ICf6WtkaQ18Fn+XEoJIOBxanFIiBjlAqrhoMTqH6pSJzxo1FGT6KIZbIUisrDMF4qmkyRkUoqWXAKDhuihlH1T3LFBo1pxZbP4H1fCUHlWM6iaiZ1t+Yl0SeMikLrqp0hbeVlQdbI/M4c9i/4Ob6GYuHPF+z39+QcmJd1hgv9KsO6wOb3ZbdeOAwzaRSsdXgsPgA07zQ9z19v2JYb7DOE5NmSykX5iVxmGZibIOUDemWc6ESNdJtqDdrTZtxsagwncHI/ehBTeNMdoniLJ3zYD3itUSXSeSiG+VhiVwfRiiC857qPeIDu8PEl99+xnd+9/fyPd/3ReZUtJnvTHN2juDUMR0HbldDz3q94snjxyoR4bQfMgRP5xxH13R06Dlmcs46eV8h58AyeNarDhFYrdeEoOXIOEey1d7aS/7ou7NhWDeNr0SMEyUr+OOIVlbHU0BU86Yb1nSrLd2wwnc9XgSfC3aemeelgfAU6Qg655NT0oHonE6SGEg9RfRacgpKQlwyvRM2Q2CzGlh1geB19KHzHmMCXoSyLNys1oyHHeNhbE5OKXDSPBHnhZdi6XdnBpUjMRXmZWE8jByWGw6HGw67K2ou9H6A8wt6C3ZY43xo8uCaKdUGsT8KE5ujAzn9AA00odRKSkl0fG5trz2lWfJS1+yop3VyZLXykkS2jVg0BOeRF4Sq85F3psN2y0rRayUXJWeep5mjcrDzVpncnaVfD1h5BMsa4qJaZjWR4wIZuloZjBDQe9JRkBRJYwHJeFcxORLwuFZ2lyrYYjBLxc21ZbGOORUkWTprMEF0uLwIdi6UOZ0G33KOxFjIkhEbdKTEmlOZ1/mPf1Tnld7RCfTBsx4G+hDIac9bz3fMz25wU2IFiDfaJ3E6eOtMJsWRw+GK6ATyhA2O3g90qwHThkV91zOsN6zWB1bjTCnCklTAqxzhzKuBvu9xVmd1jiSn2jdIpKQb6VGaIB/F37JKdXtncT7gradiyVbVVaUU7D2IlwF8x1//TqypOGvorCc4TwiBbgj0q46uszhbwXiG9RZrPV030K97XPDUcWGcMy+uDrz51hVjTGQRrNUZEycGbw3BO1ZDz9l2y+OLc1bdgLeOwQd65wlGS3pFmgx8a+aWUshHEtlWthGjN34IOvy7LDPTNLLMC6UWrLN0fcdqGICLO11PFQY8spHrhjDPC8scic3R5qwblCmGcc7IzYF5KXR9bH03Lf8qC0Ih5/qypyeqA1Wra1mupaIAAdMYNpxzeBcwUnFkhmA5WwXWfYdzQsmZOE1KfGoMOSWsGDbrDbUU9vuZFAur1YactLyaloUY774MbY3hKNyUYmKaJw6HPfvDDeP+mmUaeR4Tz94MvP3GOdvtBZvNGcPmjGG1wfd9U3Y9Rte3YPdVbjkTXiIEaYCh1nI7US0drz/4Cgd3C/hObfhRjk6vPVTzCYNG65rdg7uHzXatatVdwAga8GSdLZ33OrfYrQacddh+0BkxDHUaqVOEZDAEjBScKLoRV+kGxzao8plIxRwm4py0utXua1rW6HG4xv8n7cdZjzUV63TfXfYFEyKZmRIMUioOg3fSSujaA69GyBVcFzi7PP/Y1+vVHJQxDMGzGjqCd4xL5cVuYn89EVIiOfDW0DWKfGuUgDSmA/v9lc6bmMpmu2Z7dk6/WrdygBLOigSs7+m6gbQUEOWOilm9fRc6vNcSQq2QWj8g5QbxhUbPb08S7kfm5ZzLrVKXQrGLEywRcrwnHgn4ru/+HiBjKASnukGr9Zrt2Zrzyy2b9cBq0PKc71b0/cCwXqtzAoo4Yq7MS2GcE4d5IdPgu0ZwxtAFRVnWUDEYvPUMXc86dHROIyxSbkwTTXqjOfuUE/M0M08zucG3XVOTFaMqscuSmOeFaZz15gue1Watpb47thMZaG5owgJxyc1RRZU3sQ4n7brLlWlJVCIVQ1cNPiiDhPO2MaDX9n2tXtfF4pw58U62UTOO0u3OGrx12kCmsO4s2yEwdAEnUHNkyYWS7EkpVyoMw4p5jjx7/ozd/sCSYH8YlcUizhzuASQhxij7d2PcPzLvW6OKAXNZOOyvuZ4jz9/5Mpv1GWdnl1xcPuH84gnrs3OG1RrvgzKXA0f/cTvDOf1+dCHHEp20jKo0gvnyEvAgxySfY/7ES6dWTp3Vl89vJUJNhsu9ZFDDZqAUDeKMMSeEY1oSUx0xRghdp4S33uNLxcdKiRP5UDBVATcnjS6pVFsJ1uKwp3UquZDjTE616V9JA5Io+761ih7GaK/biiM41dXzOeJywo2AJEqnTDe2Ct42Da4mslVQ4Jn1gfXZ9mNfr1dyUH2nddDOO2wbSYjVsssOmQ0lGXpfkGCVTsdGimSmZeRmf00/9GyGgX7YsL14jHUdGcezFwdi3vP8xQ37XQQ0SxDjKHViPx0U5ny7dFd5idhLKsfR9z256EV4GCcKC86LNh+NDmeG0BFC0Mg1NpRkzZDnj31xvxp7481n1LIAGWcNm82apwaVU95VlmVk3Ds2q4Hz83Odb/KeKtoPKYBvwJHXX/8M47SQS8FZwXvP2WbNxdmWy4sLLrYbzrdrzjdrzrZrtqsVDmE5zEw5aQlnWRiniXFSePmyLMzzrLpGTVnWuga+sJaKUeh50rkfjEJZz6fz0zDmXVqMSnKrQb9t4wXmxH4gpmohzjisDXTdmmFYEbpAFwKh00a/GKed32NhqJWEFBqsWbuI0j8ZaxQ1JrVJtBecAEXLMr2FdbB4K1A1u6tohq+1fdXdkrZhHKaF6+sb3nx2zWEcORwO5BRP/YC7NGO1cNl1HRcXHavVmkdly7I8Yp6uuXnxjGdvvsnzd97m5uqKd9458OL5O7zzzltst5ecXz7l4tFjzs4u2Gy2+E57rsaY08/Lct0P/XxpvazcaMoojZFcjhlYKwtydFSntOtd76MO6jQTaAS5BzZz1+mWq/LsXnvFxlJzYUkLVoRhvQbnVL0haZktT4k8LqSshNgiYIzC9K3T/U2MYJwHDDlXcmzjKkX7eaVAiZGcElhHNhpk1nY/YDyu8zgZ6GtBXCOSvp5IZKzzdMFR2jk79v9BAVn+E+g5v5KDGvqOLnicPYpDCOJ6shmYskeq46xYAhlnDNVmjLdUKcS84ItmP8N6y/nlU6xTDr5nz695cXXDzW5kWRak5AY31bReh3V10zVSqXkhx4XURNxOkzenwdOXEw6mZU3OCt5ZvLMtuwBjMolIlQWR+xnUvb6+xkhWWP0QKFIokpnjRLoaOQgMzlLOzuisZlLSBnBzKdSa6XvP0yeXiAhx0SzBO0vfdVxcnHNxfsb5dstq6Oi9Nt+tVfqeq6uJuCj8f5wmdvPE/jCybyU7nYFa9H2PhKdWdZB0o3FtvXV3sc4RqYR+YY73wL5tlDRY0EiRopLpgjAMjfJGlHmk6weG1ZrVakUIXrNU5zS6dUoVJdadBpqB1st66aCC1xEBc2RZqBlKhBLJSyEvKiNRUmaZIyarwqsztfVA5VQFqKLifbHA9WFmnpVNoFaFeN8HjOcY5Rtv8MYrLY90lLIiLhs2qxW971o/TbkQx8OOZVnY7XbsDwfGw4H5yUSKkc1mg2xWBBNO6NJTJlPrrZCmgSWO/atWGjzNDR0rJGg2oaPQau/2c1pEOYoVHsuLnKosd2mmEeAaZ06lci1D6shLilGFNlNomnpAFYILyLBmnkbGeWZJync4dIHBBLwxitK1ClarDnBtD81aqk8xMbf9oZZEoSDVag/VVLJ3YCwhBO0n1UxMC3OOuJzxVMRVsuh651RZlsQyzSzzxDJNH/t6vZKDWg9rgvMK7cwFg6EfNvhhy83Ncw4lMWGYpVIkUr0Q+oIdAqEzOK/9ptXmgkePXyMMa2IqPH9x4PpmzzRFnUHJEznNWpeNEUrGO1j3hmAiZb4hTY4oOiTmrJYB5mlkPOzZ7w9My0yMmYCi3o7lPaVJSdhSIB8waYcpB4K7H5BEmkdWq471euDy8Rln5xuGdSClmZsX10haWDsPs9I8pTgRDjucD4iz1JRZ94HPvf6Yxxdn2gwVoQuBoe/ZbtZ0XaBW1Rda5pHdMpNjUuczR6UymiLjMjPOC4dpYpwnYoytTKdRq7ENeWUE5xwhBEIA74NGg87hg8eFgO961Zu5Y+uHFd4arKmUoogpg1VZ6rDCuTZw23qfIXT4EHQMwSks3Fh5yWNoFAF2VGU1SCuDRmopyoLQAh5tegm5KnhiGfdM+xtMTUxOGJxhcYa+c/TBa2/mSKNU9EircYj1FDGMs0a7Qx8ICOEeSqYiLXsEVVoFjDiqk1Yu71j1G87Pz7l8dMGbb3yJL7/xBrvdyP5wQ0xZM/B5Yp4nHj96gkjByJbgXcs85SucTyWf+k58RUbU0IByOrj2X056arfh5LU5vFPm1JzTS0rjewBJ5HICaZRjZnNEHrZrTqHnEeudrn0IbLuBTYWrqyuWd97mZqcD9WebDY/EUntLL0KqGuw67wid3peCzv/Ny4ydptOokLYBiyppLwvGQhgCvV/TbTZIyvi4KOp1OVCTDo2XYMEaJQaeFm5eXHP1zjOunr39sa/Xq5X4hjXOBo7a9t46tpsNV+st79iBORcm6ZhEqGaBYBk2kC3kNEJdYaxTmpioQP4lKpfTNO6ZplkHKPN8GsBdUqaUhJPC4DKDWfDlAIsjmazqj02i4tgDOJKalpzI2VGyChZSKjWnNhw3I3FHyAe8LKzuh4qP+XDD5fmKp48v+NznX2e97lnSwu56Ii8jdVlIIZGmwHLYMTklHumGFV0/0FlLvxk436wbuglElLy16zq60FFKZbffcTMt3Oxv2B8OChpYotLxxEyKmdh4DJdcybWNDthyKsUc6+ZKbKsZmpJddoSuOzkpMVpKvYcKCiH0CqV3ioQ06FyS9z3DsD71MK3TuT1rvQYu1miGbpuEe2vYHyWhjtRNAgqgqJmCXmM118a8rddeXmbiNDIedtxcv8DWTO+bCmznEUJDt6kzzMf+CgLG4bue1Xqj5VRTuTzfUBHG5T70oJQs9gihB2kaZiDWELxnFTrWQ89mMxBCQMTwpR/8MtP0jMNhp4FOiuSo13SKB84vLkhnZ/TDgPfdiV0C4ORpam3oSZoD46j00XpVcupnvTzer0T4aW/6dk3lpVO7h8uzAUFqcw5NBNJq9mMbslRlczLiLJlCpGBDz7rrAWGcI289u+YwLXgXmYdCCAYR/3I+TNypzySiJMkiqoqdc1Y2Fa2S4ubIHFWIM6eFJS34lAjWE6xjYwRGQ9q3OdhYyKZSUmWZI7vdnsPhwPIJMJ28koPq+jViPLUqUq8LgYvtluubDc71pALRbJmNocoCwTNshd1ux+76bZxbUSvcXO/54g98kVorc1x4/uxN0rJjHHcsizJN5FJZkhJN1pqVlkZmVjawsROuCPEwkQjUqo2+9SqQG/Q3ZUX11QbntNY20tWMqyMl7/HlQF9mVqGy9ncPiQYYr5+z/qbP8fWffco3f+Pn8cHy5Te/TDwIQ+cRC+vQMXSeYA3eKJqyc5ZV1xF6nWHSTdbqfS3y0lmIUcqiZWQ37rg57DkclJmgFFRWogv4vrEAiCG3nkhpZRHdtHXjPv5YqxlU13V0R+dkFVJ8RFKO48ef8n+YWRfwQfXBQjCnhrIzyj1mvfaYjFUKH2Mbb6McWeVeNp/hVvNd2uBo1SHVXCMxzaRpoubcmA2UiirFiWXas9/tOex2WKnI0BGcUPHkCrFUyBrt5waBV+0iQ79a8+ix8OTJJeuh4zOPL0g5c3Wzu/P1lCMNkaktCBTKqZSOZgPO48yaronZmWpZ5szNzZ5l3jPGhZoX4rJn3D/n+Ysv8+jyMZePHnP56BHb7TnDaoVzoXEfvuwb0uahjkRStYHtjxntD7VWwqNRf91G9B0Fodp/7oNKIvhO5XSs6O7rBRscwQUdorcGsaYBQspJIftMLNl51sOKJ5ePefudK549u1IcQNGg1Pu+sfNoJaAWGMf5xKPovWO7UidX60twyhIT07Iwz5GYEuPuhhgT5+ePWK+3rLuAdZZpPrBMkRwLkUjNyi40LQupVlzoPvb1eiUHFfoV4gIFe5JrGIbKMKwJnUpdTMnRlw7fDzjvMK5yGCdi1An5eVp49uwZV9fX5BRZ0sw8jUzTgWm8YYk6s5QxzKlQalOXtIZhCARbidOO/X7HPoKEDa4/A/SkCFWpj2IixUhNiZyVcLYGS2cKhojNC0YSfTAMndCH+3FQ1giPLy/4/Nd9ls+9/hmMFdIyIyWz7XpMyaxDx2YYONvqMKnrO4b1lmG1JvQd3reMwAipJoV9NjbzUrUPZ7zD+oAfVgQcJmnPwzqPEW3OW2txxrUk9FY56QiZOvYDRHsTtvWyFOHWmKubPEdsBLN3bc6FRpR7dDraw1xKJBUItSrjiZNGCNv0y4zhyE0InPofpbG2l9bvKznqT9KySJxHas5YUQSUWNP6XropGGsbYCUoQXEIiPHkqs7QNNkCVaytIEYHp51qeG1XHY8uNsSUMObuS6Y6DKvO6XiHaIbShAyrqOaY8eAcZ2eX1FJ59uyKt958m/FwYJlnprxQ88gy3bDbPeewu+Lm5jm73RMuLh6xPbtgWK0IQQmkxXiOXH4vw4Rj6a4dR8uWjqXBrwSO16/MkI5xRsuc7sE3AeC7AEZ7es7rdWi93nvHgyqltgCxQIrkEtnNE9dYzroVq/WGR5eP2R1GRFTp1hqHEas91FYFyK33dCqdKsxZP6upSB/L2OZIOTUvyj4xVpbVhpASxWiGH0ygk8i0ZAVvKAIJ4w3WO1z4+AfJX7HEN2Ab+iOLVRVlF/BdR9f3jOOBcVoYgufy/AxvHMkVfD/hx0zKcHN9w243aoO/KCN2KZrxzKMKDfrgqFhirqqIGyw2KOqslpm3nl3z/HrP8/3E5vwpl0/Ah4GYCvvdjhfPnnGYJqYlARrtp26m5oAfLMZVvDF0LjD0QvDa/LsPe/r0KV/3dV/P13/95zk/uwCpfOa1z3K2PafmhEXonaPvAkPX40PAeI/znQ5EOtuarZodxlhYUiSIwUkbMLWO1eYMsR3DJjJNC/OSQAQfOs2a6jFatu2/nIAqOWdy0fQ+J0Wg1VqIqTAtCzEtynCe9fGcklK55Luf2zGNL66UyhhnLVksWkcXsQzDijNgJUo/JI3Y7Tg7UxsvYaGQS9ZB6Zra/FSk5JlatC9aU1KpjKLD39Z4umDBC87pAganDmoVAkPfGMxRrjkw5Ea3VdqsUam1gXp05oRa2O1uTmwed21KS/SStdxIy6CAE5U+cnKwzns22zPOzy84Oz/n5uaaw37XWK8zpUSWeGCaD1xfP+fZO2+xPTvn/PySs/Nztttz1uutIitDr/B0peCnVJpcx7GEp9nGS8SenNzS8f9P7FDajGrgiHvyTqDVht5hg6O2+UdrhFpUUggE1ytAgpoRlOfuehqph0jewtn6jKevvYbvO8bxQJwnBaWVghGDs65luE0KviiEJOfK4TC2aohri/Sy1Ge9ZfA9bs6kWMnLxO4GUoqUlBA0S6vLgVgjxRqchc35RlGmn0CP9NVKfEPf+oyGJAYrgFU129Vq4LAPxDkxx0JFOdGcKXSrhWGBWiy73Y551v7SUc20op7eilFWg2GFKYabZSSlii2ik8tDoEbD4TAxpcqSlGF9vz9gxsi8RK6vr9nv94zzwhKzNup9oZoF4xY66VgHw2Bh5Q2roIgquadB3W/4xm/myWc+w7DeUqvKGoSwwboBY5U2xxuLP87WtHmcIpYlW73npKLs3YlpjsxxwSeDtUr+uqRGzxMLMQq16vxNFaFWQ4yapmsBR8+BUzK7pqsUWaLCzZc5UhtUOmel/FkaT2CtRbOHUrmvLUAbzAu1JlKc1GnmptzqAi6oBEYqCV8ytFJSOpaSSiG3oCmXTK6JXFILphLUiNSMOWYVzuhsilEpE0X0mRM7fWio0e5IM2W1OV5KaVLwrf9UOfVJVIEWHTxPifEQG7z97lfVHElX67HPq329224Ajug4nRfr+4FhtWK1WmmTXgC0GkLRHkZcVN9tPOzZ7a64fvGMzXbLZnPGZrNls9kwDJuTo3K+R4uoL8lhfZDmvI5qBUc870vQ+QkJeDzeKl/hrO7afAgMq57QeXLJWi4XSDEy7feUKoSiJcCaF90Pg+eQM3lecMZjbGC1WvHZ1Yqb6xdcv3hBTdpTDj5grH5XEa0oSKvF5qLAqFIazVNj7CgU7YV5leipVZCaqXlhSZlxXnQMQuCQZq4OO25qpHqV3OjXgRRXCl//mO0VHVQgpkKpSmtfq95Mzns2mzX73Z6b+ZolZqakTNLOn9FvIFfH7nrP7mrPzc2OlBJPnz5mGM7IWel8uuBxXc+wveCwVF6MhWkpGmViML7HGKFbZ87tQNgUchXGceZwuOJmt+cwTm12JxJToe8dTiqdLAxm5swlLnvPOkDnlHm91qRR8T3Yj/tJfxvb86eMEcZ50oylVDA67W1Fh5inBBJBVz43SpijPHulimY58zwRY8LaTEHYHQ5M83JiUahR5xacObJxZHaHPVc3N9pzMpau6wld0GNJiXnRQd1xPDBPc6O7yqe+DOR2Mzjlj7Meb7Weftd2c3PDsoykOFNK0tp7CAz9QOh7Qqd1cs2Ikmaftaqce4yNOis2CiOdqRKUN9aY2mr89hT5eqNZTkmplUx0DYNzL+Uk4KQ7pfxzWgJMzSHWVjI7siyUUhqAZSYtEylOiqI0d1+GVj2n1iSrWUtl5pYDuG210ec4aQjPDucaTP+HOINCLYm4FHKaGXfXPH/H4Xyg73tWKy1lbdZnrDdnrNfnON/jXCB0K4Z+jRODcV4d+kuk+mloP7c/vBsNKFWgmJeq1Hdo3nm60NMPPSQdnym1Mi8z435HzqpMYJxQS6TvNStPppLJvH24IZfK51/7LI8vHmGolLiwu7pimmecDxRUCt55w6oPKutijO4Py6KD1tbpec2ZKU7MaaER8+ueHiwpFfKSKDEyThPX44EX04Hn88QkGdcZbLB4L6zOej4JtoNXclDeaRqfis7D1DZL4Kxh6AeGvmdn9sRclELGaApYa4frzhlWjrTAze7QONH0Zs5RsfndMLDenHF2fkkXC1eHyBITaZmZJuX9CyJY39ObHtMJ+3HmMO643h24ut41qY1KLoqI6voV65Vl64TzLnHRG86DMHhwRm+6IyjjPuzs0VOWbHnn2aEBPCoZRUiZI0VMlSYdwAndpKwPHCcQQbTslpLqD6lIY2G33zFOU3vvArkpuvqgw3Ypsdvvub650RvDWpwfG5pIwRJxmVnmhWWaiVEpj0SOah8q5e2MIEVILYsQD/Ye5kx2u2tyVnh513mddRoGVsOK1XqFDzocWWtlWRZi0sBkyYmYYyM3LQ3wcIuRw5pGH3UU2WvDkoJmV5JPwYVIVbjFcSM44sjq8TerDfucTllbadloipFpmlgm1eJSRWNl8nf27qGmreuDyma0C+6Ygdx+XoOjU3VYOabIsuhs3ThO1BJxTsuFtdbWv7Qvr10gS+tdTiOHww3u+rmiMrsVXRgwNuhwdb9msznj/EzLiMOqo+sUFKRjAo31Q1RF27RMVU65lbxsRt2xua6V5sWQlpmYFpJUpnliiSpuWfZyUl+g9XWtNZjBcdgt5OsX9L7DGYetsF6vSUsDQziPcUF7ok5Rqces0hhL1w0nQdec0mnEIWcU8m+PmJIjJ6IiOEvJ3Ox3vDjsOVBJBmKOmAgSDNYHLp48+vjX65WebDPZqJCVVNv2xoozopDjoHDRlCuHKZJLxZiKdwZv16w2AWs8Nzc7bnZ7lcMolSUmci5stoHVasPF+SV9KlztZvb7kRf7HYf9wmHvkU6HQ731UC2HuTDFwn5a2B2WBks1FLFYH+jXZ2w3nktreNTNnPeOMy940yDBCSha9roPc92Km0Pk2dWoqqxF+xEZoR41q6uoaujpVY2b7CvE2GorWxyHmyGmxGHcMU8juahqK+h4QB+600U6jRP7w6J9EWsQkxBryCVrNtHmMkpKlFK0+e8UrSXHTVsMkpseFJkklSbic6e2213jnKMfes7OLzk7O2O13tD1PSF4Pb6cyCkyz1PjbWyCgbVgrOBb07prg90nRnhraGdEARO1tKHd1Bjcv7JUfKTWobStPdPYLEwru6RTqXRZZqZx4nA4nOSz52VmasrGIoK/BzZzc4RC16Z1VV9+v5eFXEV2gihvY0rM06To3d2Om5sbSonKutGE+YL3BF8xtsH9jW3ovUpKC3McSTtl3y5ZyU5LEUCDzs32nCdPnvD06WMeXZ5xcbFltVozDAOhG/Bh0PJW492EdnuU2iD95l6QEr5XAcFa4HAYmacDycKcF1LNjWbsQOl1bk8Qcsr4PuA7x81+5ubmGlKhLomnjy7ZbtakuCDG4MOADz0hBKyp1Bzb9QneOYa+V/YIEcZclHcvVkrSGUeyUNqAcGl7yVEw9rAs7OeFHDoKotnVHCm2cP6k4/Lp4499vV6Ri6+SpFCkQMmtXKFRkbP2JONQM1jnGVZr+qFjnnbs9zeUZWSZRpYCuMCcCteHGaqjGzrWZ0/Ynj9hGNaYmDjbbrnYHYjTSFkOXF/dMCqJAksxTFm43o08v9pzMybGhEYgtWJ8R2cCSzHMRUghULyQnGV2QqJQsrCUTK7mZeP3ju0L3/3dLDErZ1a79xXGa9pNpGptUo2m36dZJ068aMgR/m1ODf9aFcWTF4MUh6kCosLNFcOiXFHK2dX6ilJVMTfXovQyDbxSU2oKoOUUgdasRRSVs4BsGrGos4pKEttKQXdrZxcXKkLYBYbVWqGvRkETMaYWDRbNmtusXMkJcUaHZ33ja7QGb6WpPDcQSs7kkikpk+JCjAtLXLQUlxacc6zXK/qu03vjmPU2LMFReoL2+eN84DAdtIQ6z8zTxDxNjNPENM8s88yyLKSYMCKkexgsU6CMQLEtf1LgQT2xa8gpq4fKNI5cvXjO9YtnTIcdJS0IlbiofpQO93o0rzFaNqyA00z1yATThOQboKS8nNfLlX0jq53GK3a7t3nnrRWb7eqkdrBebxlWW0UXB3VW3ncE73HmFo3VPcSkFWEcJ/KycNjtiGmm9o5SK1kgUygx4ZzOL8WoUjvLkuhDp7pYveP5tGN5Y2GKE595fIkxhvVmA+LaEL3HWqEkQ0pGQUuFE5BCgRKWapTmSPvdSlmkncbSKgJaXaoCoe/pgeQCWWARdJYvWPphg+uHj329XtFBCc5UCknrS6Jf0oiWdVyjv6lW6PuOs4sLnjx+xJtvvsH11TX7/ch8OBCr4LoVCcthzqzXG9Znl5xdvsb2/JKuD2AiZ+sth/OJaZrZXSVubq4pZaHkzD5WdnPmsGSmJbMsmaU6YtNQGoLH254xC7sIq95zcJ7eNin0msjVMFX0xN1DfR/gO/7aX4JiqSj6TNNv/V2MUweFXqxG2iCppZVIjpBS26DVVuU6jNXsRusmWDxODNVYiqiLyrWclD1TO5elOajUSGJzi+6lHBFkuoEUlDU554oxBUPGiRIFS3V48XCksrtje/z0tQbtVsoWjFVUYc5t2LRF+81J1MYvGKyjCwEXvPaNWj0emq5RLo2FfGaZpjYaMTJOI8syk3NiGHotfYpoD44j+KEBII4gjJyJUYemd4cbDq23Fxt0fV4W1QqaZ3LO2DZ7lD8BSe0Ps1oU3HSkITp1c45Y7VYqq6jjPewPvPXmm1xfvSAtM94Yhi4Ql4Vxio1d22DFYkRVr6tTeXhrlGbKGgWYOBRRaZeo81elKqoyTeT9rCoJ+yveDpYQLM4ph+fZ2SXn55dstuds1lvW6y2r9ZbNsKHv1rjQY7wgd5/gk0th3u2Z93viuAdTccGekHQZBenkqmMgMWZ2+z1hnFkaWtpte26mK549f8GSF3JJfObxI9abszaWY3X0xBqy6AD00mRMcsxIW38QjDiMbT3kVgkpDUxSi5Js6/4g9MOKjQ8sxrCUoryWBobNimG7xd43zFysRyRyZGuQWpEiKgeQst5gKeKsp+sDTx4/4pu+6cdwcbHlbLvmjTe+yDtvv0XYnFErBB8YVgNn23MuLy45e/yEfrNSpmRZGDaVzZLZThqpz1LZ72/YjTuup8huLiwZUjXgVlhvkV4IYug61fepzjFby01DRh0WQ1dU5yYlbRrmqhvufdhf/2t/GWMc1niM9VjTOODEIrg2C2IapFYaE7Fy4TmrWk62MSNY5xHXtRq0x4o7lWZMKwFWqyWb2hzUERaeUtYSXpN8fzkGUJB2rmk1/dqGCZ0Fb1vtuvUXnNQmAV3aHNLdWhiGxvFmGhGmopRA2ZhPMzRyCzJ9hNI1cctcCqU5qGO/rWblSdtdX7G7vmZ/c8M4HloGtVBr4exsw3qlUjQlBGqD+NaWqaYjvVQr3R2mA+O8V4e0LKQYTwS9qqIcUaCsPUky3LXlUpECFKMlYKm32BwUYn5siOaUlNboMCII280GK4bzs3OevXjBsxfXyjgQI0vKR4B6I+nt6Vcbzi/O6IaBagwxJ6Zp5vr6mpSe03cdwzDoPSENnFIKy7IwTRljLH2/0HcrVYBu/cNaEnmZWIzXfhRgKRi5+57e3KTc58OOvneNnNgRSz7B+Dny6bV4xFqrdERxwQTLar3BbXvisrBLC29fvWC9XrPZVLounAA6HEdHrCd0lpISS1pIZcFE7XlKTZgWsOasHH3VHscGGtFsyUDFeoMXw5ILxlSG9UA39Gwvz7GDp9qPP8N/JQdVTKDIQhWF2gIaPeUGZ44LOS8E79huBl57esmP+YbP8dnXn/D660/5wvec870/8APsdwdyqXgf6PqeswYtdcOKbCwohSvV9kjYYIcZN0eN+pfKIc8cMoylksSCczjf6SS1C40pIGCMo4oQreVaHGM2uInWM4FSmlPNlXhPsxHf/z1/Ux2UDfjQqZNR2TulFqgvm7oi0pyUymy7ljVZq2m9dQHxA9YNWNthjTZjVb206Tg5OUlDlHJLgO+kpZU1vaeeNqHjLIaI1eFWa3HeYoNmfN4KwQrBCd6CtaqvZeUe5qCczniYW+lb20ZbRaqV2aq6rlr1ey/zrFlWQzFZa7DenKiPainEZeZmd8OL58+5fvGCcRwVgl5fMptP08S8NKn2qk5JHY/2mebpyEs3s6RFIfotY73NHp8bwsuJaeXJyOFwuPP1LKUgBaTcpgTWVS1SkZpbGa6hRBsAYrs9o/MBAVLOvPP8BW+8+RZffvPLPHv2TAOr5mRs6OjXWy4eP+Vzn/scZ2dn4AzzsnB9fY3zb7IsCWMtq2Gg67SPE+PCOI6MB81kRYSuU6DV+fklFxePGIZVUzNw0EpWkhdqrph7AEbNuz2Hm2viNLLePGJY9VjvkFgJRijGkJtagKoSGFarFYfDnmWZiCWDMwzbtepE7Sb2y8QhTiw5sgorQgjUlNXhoFUD5zuSGB0XWdqoSM2Kjijassm1kGrBFGlzWJUjS79IwdmKKYWaFjDqKNcXZ5w9viCbzCF9/Ewnr+SgZjqSiVRpcNNaKEdKEpRdoOsCF+dbXv/ME54+uWC76YGBfugoxkAY+NKX3+L5i2tSgZotskDcRV4cbpqQvA6F7seFF7uJt68X9odCnA2H2pP8GUjFBu3RiFFONesC1ndY70F8K1tBMYaIQ6rBFmWTtgi1ZpYaSRXSPTmoZboBMVjrMXaLMb32nwqkJZGjMl3neuRrVtSTOp2XmYKxVp2yX2HtCuM6xASQVh40NA4914ZKNbspLbqvOR/dErWl7loO096SMwbvHB5H7wyDM6x7lS7vPDgrWKk4KU0xNZ9IO+/axDT0Ui0nFVcNKLVUF1Mk50huHHGxcdwd50WM0RL1sB7o+oA0RKOWRI8bcTlB67U0Kyees3EcVewxJ0WrHjOj9vsSIzHF03yZCm421viYiHGh5NK4GjKpaH9qvAcHpT0zbpX0WkbZZpt04VpGag2bzZb6+mdJ8YmS6RpDLZUXNzc8/szbPPryl3jn7XdQZLj26bq+4+LsjCdPnvD6659he3aGWMsSI7v9jmFzwbA6wxjDMKhoqfeenJWIdt+AJaBVmadPP8Ojy8dsz87oQn9C8llpMh+tAnAfMPM4T5QUEYqiRJ3gnQahnRdyNtTY+m4547qe1dBhg2OeFdg0zzPBeDbbNdU43JwRa0hViQ8qCvYR6kkfUgQFQFlPbWwvJUVqisBt4chGCC00Em6DlEISVe31JSvdmnf0qxVhNVB9JdXIUu+Zi+9qESQ7jATlF6MgYqiiUWvfdZydbXn69JKv++xTHl1uVXrYWMQMXF4+5mquvHkzsX/rmnmaKWXC7SLWOJVnLwWLllnGWLgZZ15cK5EsqZBSIHUXSOfwWGwrI2nab8F5snUgDjA6syUqCUhVdgXXhoyrFCJOH5f76UF5qygyI2B9oRsEZz01FRYic0nkvFBS1AZ9TpqG11uZQANViHE4v8G6FcavwHXk2uh7Gs+bM16VhW0TMWzKs9Sq/GBWUOajJhnvDN7rYKSxQu8dZ71nu+rYrAf6zrZBZ2UJENEbT9Fad98zKTnpjVjl1Lg/4vNLqaS4aGnu2DtqTuOk2loLzlm2241Gnk4dcy0qKmiMJThP13Vts5MmGQEhBFJOKjOx358Ij2OD/mtf76WjW2JkmeemBq0OKzU5+VqqbhS5UJYGoJjvXrNMS7zSeCwL5ricoAEqWuIFvb5W6zV9P5yQ6Ea0NHg2jZw/ecrFkyc8f/5cAwcBqcobueoHttstFxdKeSTWknJmtZnphnPW28dQwQevCMAQtB+aM9M8M89Tm8PSyH7oV3Sdqvkq+a/B1KMcouqo3cdkSclJ9fQ6YdUHhuCwXlGxpXiKVDI6g5eKOp5utSIMPUNcmMYD02HC9ULXr3A4uh5C54FCypGcFX1KVWLaVGvL9NFsrThymlXmJSbt13qvopSonpmAUoJJhZKIphBqIpTC4C216whDB8EwlpmljMRPYJb0lRzUF770nI2HjYMORzA6U+NcZRgG4Jztuuf1zzzl8ZNLtmslL4wpsh8XvvT223z3932RL3zfG/zAl95imRZSLogoN1TJtQ3S6QUUq2XOhXGJ5CRIsQpvlEAWSzFeEWwNKlUxFCyU43S5Pf2dCrUINStnHMcBxKJ8aPWeNHWDF2IWMBkhYR1sNj1eLGkOqtM0NmTXMutgY6SV5FKjzDkGuEqA6lxgvfKEYc2YM3NOLFl55GLJpGgw2SrtZm2TOdJYyjE4YwlOJd2HEBiGjtVq4Gy94mzo2XaOwVmcE4RCysrcIBRM29C9N4Rw99xxKU5YCjjLUfunjedQS2Y6HLi+eqElk3lSdOJRXVUU/u2zYxiS6pCVihQtBxmEzgfSMFBrYYnLqU9Xa2JZFp1FaTQzpbaRgTY6oOCT3PoJqsEVl9jq/NoTVdRU1pGAogPAZZlJzXndtS3LginKllGkII114AhBrrfm8jRgQhGLWptumkaVmDNYq5RbzmtfqwJtaNxZh7Ed8wKxRAqprVml1J7V6jGlVKwVpbKqqvFlLHT9gPPtDasgxjJHw5Jyg8mjKFgxbT6tgBOqv/t7vu886+1jztY9T54+pls5Yp04xAN+ENhBNoV5KWQisRbVV7Oe3ljSElnyzGE/IjFzEdas1ysljraWEiMJnT01iFJy5UIshnyL95FaNWB1ro1ROGhjE4IiVzGQKxSrnOrWZHonGNdTup7qhURU7TriJ4KKeqUd5G/+wFu8frbiybbj3BvE29a8r8ox5YRgt3zmtac8utgyDAGhMM4zz1/s+N4f+BLf8Z3fw/d8/xu8885zbQQ3Vu1aWue1VK2PilBtoBjVxlF+OKcINAxFVJHLiM7hCEc0kagjOsGvbZOrrop6zi3tVY/VnFP77Hsw3xqSWQq5RJDManCsugGJgWUK7HvL/mDYHSqzKSwkljbToQqjbQZHAeR0LvP4YsX28hGHlNjPM/t5YlpiI5Bsa4wyVesgqg6jBm/ovWPoPKtOSWrXmzXbzYbz7YqzoWNtBVuzzqsskbRMZGIrHQacN3RBgTJ3bTlOxFoo+Sgv3urpbf5pnEaudzfsb25YpgkRDbKsa1miUZqiUio1V0rKlKjzSjUpKaw/RfAQl7kFC4oKPBLkmtMlVU9jrrEx60/zRJxn4riQl3gqQR4RfqXq56YUKctCTouWYO8Bxbe7vsFotwNTG/MB6nBLqe1aevcPzWkf0y1R+HSbe3S+40g5pPN9OlIxL4Vxnih1ao7p2OS3GNNTqaTcPmN5SVqs/ebGRF8q83LkjVQCgKPekqWJlVoQb5Du7h3UZrXis08u+cyTS548fYQNsJtecD15/CjUkIkSYZ+IsVBqJpZCMII1HicOKcI8z9Q5cnbZ03WBvusI1lFT1tmx46By0eH/lAupqlpBw7po9cl5vHME53RequQm1yFkdCwlm0QuESHjxeN8IHWe0VWWGpniRLUV5z7+KtQrOajv/uJbvHgReHrW8/WXW55uV2zFU1Nkd3ONl8zZozM2Q8A7D+JYsvDld/Z85/e+wXd//1t86a0brveRpViyCNVUnd05zltUjdJajtnmeo4Envqc3Eox6vFPgj2tz9DqqOYorNdgq/Jufjg5RX35NPR697ZME0stSmBUNUofjIV+RRCBVDAx4krCU0mmtnmoI+C3nP5bSeSyUOvC5fmKb/rGzzGst5QKu8Oe/eGgDqUN3B4rYCq6pzdvsMLgLIP3rLrAcIReewsscDiwS3OjAio6i9uGW13wbaAwEPqgdC53bCkuWmIUDwJGbzc990bLlV0I5L5TlJdV4T1rHcYr4CQ4RVfllNjd3HC4vibOcxucnZiXRRk7Sms0U089KSNHpVQlOi45seTEfOxBtaHemrMqoAZlPz8CJXLKTb+s9QarZgUnSPcd21/5q38ZJ05hO0WzylLLyzGFFiDVI6/bkb6pUfgc5/JyVbLSo0OjZUAiBme9yk1Yj3UesE0jq+EEpc34vct0JtCcWCOUCqohJ9tA7jG7o2owptU+RZ1KuPv1/LrPfZbPPrnk6aNzzs63GF/pZ0uYLHYECWCCYbeLzFOTtjHKM7rESo6RzgeC6/DWUJ3jkCLrrCMVpugwdY2ZYmsLbCql2lYhMMp5KkYzrVLxzrMaBkU1I5SSWFJiTpEpRxYKKUGcKzEvzGlPlEJa9SQjkLPyT34CbZJXclA/8PY11zfCbtfpQugOgKSF3W7Ppjf0nWfoe5WozpX9nPnBt674G9/zJb7wxXd4+/me/VSIxQJWXy+NJrPo1Ik6KC3PiLTyATrIqknQsRRYqMhJukBqa/aZI3DCNuJTQ1NKau9lVF+myst09x4apgBxWYi1kqnElJBS6QHpR1Y+YCrazIwLkiPSNsXauNHqbfBELeS8kPPEEODp+Yqvf/11Vl3PuN9zOOwZJxUky7mVkVp0eWQwd6Joos4q27ezlkIh1cihDZaO84FUEuIctgt0oVfexd7h+0DoAqHv6IaPf3Dvw6ykRLUKh0ea6CBQT0Plgncq6OgaWs87p9RSTTrEGUPNicOo8ts5Rp19mmfmpE7miHK0BsRKK5NK4z5S1FNs/aepKcouJ4b343B7wFurhLQ1UVJurPBtKLpt8q0gzX1cod/zhS/gjapon8Q+W/kyn8qb9XQd1lLb35vTbo4lt2xLHZSW3I7SD84G+tA3WqMOEfeyHHWrVAicmvk60HsMSC1GbOt1mwbOeTmjdRrcKujeQqFa4R5Q5pxfnLPdblivB7ohYL3gAtgAhILxYIOh6yfGQyYlQ62RZY4sY8RkizOe0DW2CGeJwilgsEWvSwUAwbxE5lKJ4pVrz+n66FykIdeKs44udFixbVQgMafEEjW4yqADv3NliokbSSw1YtYFjG+VKPOJsMS/koPKYjgsiWc3I4N70dLHM3qjw7HGBrphTT+sEOvYTQtfeuuaL/zAG3zX93yRN9++YVqyzhyJPUGn9Up7WSI4RT7SaElONW69IG2bohSFmqme0SmaEqxx+OBOUu/GCKbdQLkhBiqKPtQIQgfb7sNqq/sqr15hKRM3pZL9gdl6HZwr2jCdWi9Jm+5NL6Z9r+OlUUtkWQ68eOcNnn/pkm/oOh6fPyJQyd6xCKSs/T4lfS2tD1NJbUAw5UiKOjYwHqOoHJlKItasN3fn8L0lDAE/eGznscFhg8f1KsHySejDfOh6nli/pWXF+aQHVqoSa1oB35CPCgWP1EUz0NJmP+RYomrQe44yHMeExrRBT4POlZWqA9+xZRnlJfAh50TKud3IxwtZi9VF6v+fvT8Psm3P8ruwz/oNe+9zTg733jfUq/dq6m51Sy1hCEwIMckhLOEwGIHsYLCZPIDDJowdCgMyyNjIWBiIMGELyyCHw4GMsBnCIDAyCoYgFBgkGxtLTI3Q0JK6urqq3nDvzcxzzh5+w/If67dPZr2u4d3q+zJfVeW6kXFv3nPy5D77/H6/NX3X99tY4fMJJHGr4dPKg2JoqodwUE4c6y92mAMQDDThpGXhcnutWm+zqTtoilM/7tZhtKDyNOzfRNtrAbe647Y2WUuBK3pQTufFqQwors0POlYhvlVZF7V9VlNGG6y6OmtV37dd31zjZGapey7KJdvtQN95hn7D0/DURAtbT66LMykZEvxQK3nJxrKvQuwiZxcX9DHQO2N2WUpmaKCU4zyTcuYwTcxVqRLpuoGzzcbWf/SIdGRnnKkrYERwhnRdDGmKVnrfAcKcF8Yx8XyZWFJgd+FPoqDAiUrtddqrncoutDed+fDqgFTD0V9uPINzuLihG84I/ZaK52q/5+e/8T4///X3+foHz7naZ1Jtg6d3ma7Xxcba8G8HzBr5aIOkCm0BWoZkJcBgVB3uVo7c+TaR3kTA6urgWFtQAk03KIo184f+/g9TMLQcreSDCKUujDlT/ER25qBszqSyaGVpzqq0MsYJ6gvteUpaJq4+ep8PNxum0BGPI098IFQlt6b9qU9QK7kWUskca2asNsw3Lta3OqaJWQsLinYB6TyhG4ibSNz2xKHDD9HojfpI6CNxMOfk4/3f02kaEdVbclwtzWk1QtZSrPfZkHWmR1bRmih1sZ+rufX2dE3k8evwdCs7r4dkruboS25sE7mV53TVx2oyJNBYwWnXZT2BKmKN77Q0NJ8BIdb+jVWnmjTKQwB52ryYleQ4OQBVbEj/1GezDF6da/+WO/9va9OxBqPt/YG9djV2mlQTtXpj92oZWi75lOVbue8WkGHlRD19HCfqr9N1nn6dlbpSQpvKdhEh+/sv8T1/+ZLjpFztI0+nA0+eXPLs8px+E+lCz1l/dkfXyTOlxJwyJQslCzMVSkIlW6nS2+D8kheOOQEeV5RlnjmME1eHA0up+Dhwtt3ROYzSy/tTfw+RBvg5IVdg7VBrY6WplZyUcVy4Oe5ZaiAsl4RajX8159O4xuu0V3JQzgc0B1KtXB/NtZclMV0MfO7pDtftCP0ZEjYsRXhxfeDPfO3rfPDiBce0GHMuNjeyMkob31O9c+DCaTnfWT9OVii5u4WUOwcuGMtxG1h1zmZ8VNayQrlTJ1dyBTxECdZcHIwJuX+gDKrrI6kY15hljUKmoKWgzgY1LbY055Jb/d82/ikc/RartXBz9RHPBa4yHC8+5NJ3VoOvDX21vibKrJlRC1clcVUS1yVxUxJHKskp9B1+29PvOrqzLXEz4IcBHztcWGdLjGqm6zq6vjdhRX//Ier1i+eM0VitS26Dx8XKoiup6+q8ar2N/EUKkO0YbP3K28OuBUzUBsLhdKhaplRISyZnA1Y4B96fjsb2odzSJdWG2lsjzjV7sp7WGqS1v1uJD1kJWe/XUpoaGtaK5AJNx2p1EOaM61p6PrGe11aWX9kIrKdEy3pOpb52b+sKq3eCDVOv9zafAgyLV5uTV73dA7IWQW9LumsJkHXaoBaTt2j3P3tPegCU6YurK/TFkRArV4cb3preoMrbPOGMrrdS5W7Y3Q7Yu5FKZXNm+nq+S6SxsNQbrq4yQ7+lix1LziylshQHc2K/P/Dy5oYXVzekqmyGLW8+ecpZDES3o+t6XIh4MfXewzRZTquKC45hGHApsaRiPdQlMS2JcZkZp5kc25mNnbPLNDEdDq/9fr0a1ZGY1HvBMZfMzWjUOKiyHTYcs2MhsqhHU+Xl/sg3n7/kehwND+IEVrQetwcAGIJpTZjMGd3Ora+EqNKaoLR0HmcZVBv/X0V7wPlT/T4Xo2Ap1bpbim30znfWN+l6RPhUxLY+ifXbgWlOtyW6UyZZSbVQMCFHVZveKA0wctqwzVqS3YBjlWU8clA4amS6PlJ8B1gkBJAEJoGDVG4o3FB4qZlrLRxEGR3kLsAQ6fqAP9vQn+/oz3cmWx5Du/9iZVbfhA5jJIRgjsvf/wHw8vkHlkWLkFufbVUALqtjUBPPEzhl3cbTd8vVJ7I24QWpTdRt1eACKlbGqzUbW0S2Q9iJqZlq+xy0ZVjanFPJpZV17f+rapt9ao6rZRx3ET3rQfsQDmp//YLobmcHoUFyVBqSz9CntQEooIJrDkpXwEdzUFVO4oxrGfDk/FVPAan1g6uVs1qJtbRSn9a138q3lBDXv++WFu/uKV171u0e12FA++2neu++nY3jzPHwklIm9ocjx8kc0JKecXGxYdMbyWsfe85UwTnUCSEkQpdwHkZfSceZZUlUFlLtyBjZwFKt/3RYRl4sEy+WmVQKCzBMPXNZOKvDaU1ZNtz6hmL8uSuVlfMBKbDME/tx5OXxwH6eySgEy8AMNZmYx4npOL72+/VKJ4iqoM6jEikIixbcUrk6Ft5/eeTNq5HrsXA5F1wuXI0zV8eJOSsuBHwEza7BTY07y3mHU4erri3Ctshak9OtvFurE2qlDmeMqRScoaUy5KrW1PcNVFGqwStLm8MQh48DodvQDVti16Mqpr8z3rz2m/tJbLPdst9PwHTnPq+YvIrDSFyVFcmo3BZDb00/9l0tmbwsLOORTKSGAuqhlQiPorxE+ZDCC1d4KcohwOSFMkTctsNvN3RnOza7M/qzHf12Q+g7tGVG2qJYaZGv0SAZSGVluLhvu/rom6dAR1eHvfaLuM1M1r5FCCbfYv/XnnPqedbT37W2qP8UkqtN7bcBSBFP1/UMjdG51nyCoJtMSUPlVStprYftKoV+F6Z9V1hlZeOwmsL9d6E++PCr5qCcs/kyLNCjjWecsqiWQTnBZuS1nsqndx0UtKSnZTornoFWwoc1MGh7uBEarzN/33J/xCDq7Zv22t+agd7+1T4zB7ULdBcbNs+efqr37tuZq8J8XNjfXHF9dWB/M5KmxPF44O13nnJ5uaPverouMmzO8HGgCwOHZc9+PqAUcBXvE3kq1HJk1onqPMUZKWyNlWkjlGooWl0WFoHZFYoYRZWqNobzCs6YyrUWSl5IjVNRcXZWzDMvDwfev7riahnR84HNxRkhBOqSLABeEvFTQJm+WgbVtgniWdFzixYOCZ7fTHzzoz1f++Alvo9sNoEXh5Gr48SY7KhtU3KscsvSIm+nitdWcLLmiP3C0yEjd5yULcoTiSrtQC9t47f0fy0D1CYdoWK9qdD1xH6DhGipaZ6Z99ccrp+/7nv7iazr+0atz7d4mdYibkUlWlN9/fOdTdvGLqse1LKwdzOHas3tOSf2JfGcykdU3nfKdRQOXSDHCJuOcDYQzrf0Z1uG3RlDU6MNMSLeW9N+lUZw1k907rY5fXvg3H/EPx2ub0EGYhmShDsN9JNkiQVbIgXnmpCE3n4IJ8BOrSeHZWUlWTukBlDRjLAqiwY2mw21FOYpG39f09EyQEpb221dl1M/8NY5Ybeu/dV2XOvzoPfPbXjYX5kasDgcBVFtou+ArJL1K6q0nngMV+i5OamGwDXaCWBlil8zVb0tp7oV4NCIfk9ZWpOKqWumtaJ2W+CKuzPfuDqpNdFq6zV4ZIh0ZwPD00u2Ty/v81ba+0MpS2Hcz8z5wHE/skwL8zKBZKomzs7OOHPn7OKGbdcxuGiCoNLQzes9C2qD+yVTXSWJMx02HLhIjJHNpiPMCVkS0keKQK42NF5LIZWC70zJWAVqMQq4nDNZlXFZuD7c8PKw5/o4MrrK2dbOgzIvaM7IUtjFjt3Z+Wu/X69Yg2kLyXkbhnVCVcdSC9dT5msfvmT7J36O4zzx9uee8MHLPS+uD+zHiSlDqa45Ktt6Jh3hCSJNQdYb1LbpD609AtwKkvCtTt1UIhvM3DkDj6KWOViv77Zs4J3Dx0DoBobtzogTU2JMlmGMNy+Zrh7GQfloSq3OW7q8Vi+sOQ5CRZs2Tov97Qf1F7spbaUlBbIqkyova+b9mhg00qtyVSae54kPNfPSw03w1H6LP9/Sn+8YLrYM5xv61msKvSl3uiYRr2Cfn/dN5iPivUe8P0GBbzOB+zepycqYa5iOoKUdYM44DldYvdYM6o0+yn76BGhYncUtIsydIMy3RWrLgpzTpmDq8MGzEtDmxeQzaq0Ns2bnS2nIycqd4Va+9ffRnu/a+q3F2Kzv25w2YcoGN1jZOe5GVKJWPNf1/jTHhWJOZF0L0u6CwDp4+ItdSQOEtNcoDW+hrmW1dzXGGnhkLWufotVTWiaGsvSCxEjY9QyXO7ZvXNKvWmH3bWrku1qUeVwYjzPjwfSh+l5wwdDL3gei69nFnm3YGM+lA+EO92l0hGwVIoqaLI5XpBP6bUdfOrYFylyoU2KjngLMKdGps15cLagD8c5UJLwxzGitHCcTi/3o+gUvDzcsVHzf0+92OBe4/uiKPjjefvKUt99+k7feefu1365XA0nIqUd5ymBUCllhyoWPrg64r36dcZl4eTzwzQ8+4vowcpgWlgK1OrTe6heJ6kl11HuDsNYGa60YszSKQcpbObBNqcKK6mn/Er071V5PiB7vgw2adhu6YUPsN6g4g/am1MTiJqbp9ddPP5kZfUuM7tS4X/sjJ4fAuku/tWzxrXZb9qgCGThS+bAmvlpmSjE12Je68NJlrr0y9oG66ekvNmwuzthdnLO72DHstsTtgIsRCb6VcloG3Q5M5701WX3At76TD+bI5ERi+wAuqrEdaLVoXqtl3oqJPq7n45rhaS32t7TqwB1bnYVlh3ezG6M/anW/9nvbWm5lKePga6g81bZfzKGtgomn4fM7zun0u1nLeuDUouQ03/8aldrGPVZxq+agtLFc68lp6WnNrqW4U9ap1h5oB8dpHZkHu13Osn4Guva5bl/nNts61Wpv/VADSpw+PTWwhDkmj/Q9cTcwXOzYXOzYnm8BoY63ZfX7MnUKXnDB46MjTQs3VzPBC2eXPaGzqlIMHV3o6L3DhcAmbFqQGBAX8eHAlCdSrqRcG3u5ScJQ2yBNqbjc4CoqxGS99qU6pmr3VAGpFVfacHO22acpJ4555mYZ2aeJuRYk2hiJCNQlMd8c6LYdF7vIm2+c8fZbF6/9fr2Sg/LStHVqtcG41mBTqVTxHJZE+uZH3Oxv+OZHHzHOE/sxMc6JMRVqVlQdIVj6GatSTwdbi76CHcTqbyfNDQpppLR1zTBsTbabj8GCm+Kp1koIgRAjm75js93Sb8+IcaCKJ1WleEcOnhS8zcM8kGBhyQs+CN0QyOlOU7lFkpVTy+P2606p5GRr385Z9Jm1chT4Rk3UPPJSKt47jl6Zu4hue8JuYHO+5fJ8x+XZGbvtlu1mRxh6pOuo3pHar6uy4iEs0w0xmmPyERfiCRwRTs7KUJX3bWtpCWpzTg0Krc2h3M2AxOQN1uFuw9fcikOehr5Fbu/3ClCpBS0ZTRlxQnGhsZabttOq76SltIO3OaZcWglaT83ob2unzMBKe2WZmcbXj5L6XlZKBrHSpvWZsCxArK9nDqrN4omBwaUN3N+WSDn1rBy+zS3SnFODNp+SnhaS1bUcWleQHickY/s3sg7Y26bwYmW/qkp1AsEhm4H49JLNkwvOnpzTBY8uM+PNNfsXV/d+P7UXZPDEXcfZIISjZ//iyPEw8fWf/wjxjm4wmrA4eGIndMHTxw27bouPW2K/pZuu2I83TCmz+EqJNhiuHC04KjOaR/KYkLHik0NzZ6AcB1OteN/hfKSqo+TKUhPLPHI9jVyniX3NjB5y9MgmssFBDOTjRJWCLonuoufyScfZuRDC63f4r+agoNEMFTuoWJ2FbeBcxRBz+8yUZlOPTKZ7n5qsOafGM5RSSd6yKeNAayqwaiWRFVHlfGu4r9DyFdVW1QYgc2ZFaq0bP3rH0AW2Q8duu2F7tiPEjlSVacnkRZrEeQaF0D3AWDmAV0Lv2JSOlHKbo1kHQqVN7dOgtrb5P056YcdfyyWbg7LSECwhsg8e3wW6GNHY6Ih2A/1uYHfWc74dONv0bPqeoQ9Wal0jYVn9or22tAz2lFl4465z7XP0jY1h/Uzv3+506VqNbC3RsaJBuVO6cys1UcvSnb8FJtwpt90CJszR1ZLRbEwT5sA8qUvEbIO5d/tOqq0xXfSEQtPT1d658lMP6vYatRaWZWaZRtJy/xE/TejS0pM1k2/Xu+ai4jmV/0990hadO4dHGtPDGoiuJet6clDrelpHRGrVNoN+O/e0OnPLQO9Eaw3xW8ECNBeQvqffbYhnZ/RPLum2GxzCcpxYrq6Zrm+Yb+4fGDU3xeRUCt024qOjJKUsmcN+5qP3rxh2ncmB+LX/DDuFTbTS+q7bIgKdi0wpMabUqIlmBDWhy4pVtwrkZaZMC8dpIaeFOW7YDhtY0h0kpaIlk/LCVBKTVtj0bDaByy4Q58XOIdfQ2A6cO+fpm1uGswGCkB+azTyIUiigBa8WaapwGiS09Duw1EQ6TC2oV2qBWrRxiwlgkVhqMgeuob58o9aJzp1kt+0wrHZwBIcPkRAiipJzZZpng7iWClKb6Ks5p03fsRsGO4B3Ay50LMkOjckpWjNpnlEt9P0D1KMxPZhuExCJxGw9uFqsqdx4bU8DiTTJh1sHdXuQruS4K9zeOayxGj2l68j9hqHfsBm2DMOGYdszDJF+E+h7z9AZUawPdpBXNY7CAtRVRdcZSm+lEQJrarvgm/R8+xzD7b/v21ZqoBXAsWZEuFsn5Vby4RP7QHs/fuV8u82W1vGHdY6uVIVSECMnM7LXBrX3qbsVf1z7YFhwUdYM7o5H+jjgxXqmBpFfnVSthXkamafpQXpQvk0T4DF1WpU2KnLnPhmuz6xlRbfzZMbz2HUdXexPjOK1VhuaaAhVJ3KrU9ZEGteqwF1pmaKFlPKJcQNtDk2ELEr2ggwd3fmOzdOn7C4uGbZbROHw8prjiyvGF88p4wT59R+o38vG48RhPzJNM9unF/TbjpKUaT+Tl8zL50fwH1AoRsUkShE1PrxaGLoNMUTO+ws2cce8zDZUn44ckwXdxUe8eKRTclg46g0vD88Zpwk9wqY/Z+eEvGSWcSKnRM2NVcYJvg/4bc/2bMt2O7BZkjnVnClkY0HvIpvthu1lpNs5qlhv63Wb3E50P9qjPdqjPdqjfXbsYUSQHu3RHu3RHu3Rvoc9OqhHe7RHe7RH+0zao4N6tEd7tEd7tM+kPTqoR3u0R3u0R/tM2qODerRHe7RHe7TPpH3mHJSI/HIR+cMiciMi/6OHvp5H++4mIn9ARP627/DYl0RkLzYo812f+4Nij+vz0X7U7T73/KfioETkT4vI2C70myLyT4rI2Sf88d8C/AFVPVfVf+zTuL5Py36J7/uX8ns/kwe/qv6cqp6pPgDL6XexH9X1eR/2EHug/c7f8Gn+ju/xux/3fLPXvec/zQzqN6rqGfCfB3418Pd9wp/7MvCffKcHV8/8Gbbv930/2v3aj+r6vA/7UdsDP2rv997sUy/xqerXgN8P/Fnf67ki8m8BfynwO1tE8lMi8rtF5J8QkX9VRA7AXyoiP90iiJci8p+IyF915zXeEJF/RUSuReT/IyK/XUT+nU/tDX4He5X3DSAif4+I/MlWOvoZEfmv3nnst4nIP33n+6+IiIpIEJF/EPi13N6z39me8xe193/V/v6L7vz8H2j35Q+2n/lX2n37v9y5b1+58/zv+FrNfkJE/r32+L8sIs8+fp3f4T3/d0TkPxWRFyLyr4nIlz/JvXqd9qO6Pu/Dvo898EUR+RdF5AMR+ejOWv4JEfm32v992Nbpk/bY7wG+BPwr7TP5LZ/S2/me9rjnP4U9f1eL5nV9AX8a+A3t31/EIs7/Zfv+7wF+33f52T8A/G13vv/dwBXwF2MO9Rz4E8BvBTrgvwjcAL+8Pf+fbV9b4FcCXwX+nU/jfb7m9/3XAu+29/jXAwfg8+2x3wb803ee+xWMCCZ8h3v2DHgB/M0YndV/o33/xp3n/wngJ4BL4GeAPwb8hvb8fwr4J1/htb6Gbcod8C+s1/rdrhP4Te0afrq97t8H/MEfgM/pB3Z9fpbvLUb1+R8A/5u2jgbgL2mP/TLgLwN64C3g3wb+t9/ud/6gvN/2+OOe/x57/tP80PbAS+DPAP84sPmEP/vxG/+7gX/qzve/FvgG4O783z/TPlAPJNph0B777dyvg/q+3ve3ea0/AvzV3+di/ZuBf+9jr/eHgP/Wnef/T+889o8Cv//O978R+COv8Fr/8J3HfiWwtM/iuy3W3w/8rXd+zgFH4Muf5c/pB3l93sfX93tvgb8Q+GBdK9/jub8J+MMf+50P6aAe9/yntOc/TT2E36Sq/+Zreq2v3vn3u8BXdVWWM/szwHtYdBU+9vy7/74P+77et4j8LcD/GPuAAc6AN7/Pa3gXuyd3bb1Hq33zzr/Hb/P92uj9JK/11Y89Fvne1/5l4HeIyD965/+kve7Hf9+nYT+q6/M+7Pu5t18E/oyq5o8/ICJvA/8Y5vzPsYPtxS/5Kl+fPe75T2nPf+Zg5t/B7jLa/gLwRTkplwFWg/4aFoFl4At3Hvvip395vzRrddj/I/B3YGn0E+A/5pYu+oCVhFZ752Mv8XHG31/AFsNdW+/Rq9onea0vfuyxBHz4PV73q8B/T1Wf3PnaqOof/D6u8aHth3p93pN9FfjSd+hd/EPYPf6zVfUC+Jv4ViWtj6//z7w97vlPtud/UBzUXft/Yx/ebxGRKCK/DktP/1k1aOO/CPw2EdmKyK8A/pYHu9JPbjtswX0AICL/bb610fpHgP+C2IzBJfD3fuznvwn8+J3v/1Xgp0Tkb2hN1b8eS8N/3/dxbZ/ktf4mEfmVIrIF/gHg/6bfG2b6u4C/V0R+FYCIXIrIX/t9XN9nzX4Y1+d92L8HfB34h0VkJyKDiPzF7bFzWhlNRN4D/u6P/ezH1/8Pgj3u+U+w5+/dQYnIbxWR3//9/ryqLsBfBfzlmMf+x4G/RVX/aHvK34E1Ab8B/B6s/j//ki76Ndh3e9+q+jNYTfgPYQvvPwf8u3ce/zeAfw74D4F/n1+86H4H8Nc0ZMw/pqofAX8l8HcCH2GzO3+lqn6vCOfbXdsnea3fg/VivoE1t7/nAKuq/l7gHwH+WRG5xqLHv/xVr+9124/q+rwP+x57oGCO/JcBPwf8PAYcAPhfYBDuK+D/gTn5u/YPAX+fGGry7/o0rv37scc9/4te95X3/A+9HpSI/CPAO6r633zoa3m0R/u4Pa7PR3u072w/iCW+72oi8itE5M8Wsz8f+FuB3/vQ1/VojwaP6/PRHu1V7NNE8T2UnWNlk3eB97E0+l9+0Ct6tEe7tcf1+WiP9gnth77E92iP9miP9mg/mPZDV+J7tEd7tEd7tB8O+8w5KBH5i0Xkjze+qN/00NfzaN/d5LswSYvIrxWR/+yTPPcHxR7X56P9KNt97/dPS25jf+eryi0d/V5E/sbv8eP/APA71Sjb/6VP4/o+Lfslvu9fyu/9TB78qvr/VNVf/tDX8XH7UV2f92EPsQfEyEl/2afx2t/j9z7u9zv2aez3TwUkoUY9D9jNxLiYPikVyJf5DnIGIiJY36x+u8cf2n6J7/vR7sl+VNfnfdiP0h74UXqvD2WfqRKfiPxJbDp6pc7vxWji/0ER+XcxYsEfl+9OK/9jIvJvi1HY/5si8r+XO7T1n1UTkd8hIl8Vo77/90Xk19557HeLyG+/8/2vE5Gfb//+tnIDIvJXiUk9vGz38Kfv/PyfFpG/W0T+QxE5iMj/SUQ+JyK//859e3rn+d/xtZr9ajG5gBdigm3Dx6/z27xfJ7dyAx+JyD8vjbL/s2o/yuvzPkxEfpWI/Bsi8lxM/O+3tv//80XkD7X193UR+Z0i0rXH/u324/9B+0z++u/4Cz5D9rjfP+F+/35ZfF+BofdPc4dpGJus/8df4fl/AJss/1VYxvc5vjsV/B8C/teY1MFfAlxzhxX4vr6+j/f9NwFvtPf0d9ImtNtjvxv47Xee++uAn/8uv+unMLqdvwwjcfwtGM19d+f5/692L9/D4M7/P+DPxSQN/i3g73+F1/qPMW6uZ9g0/G//XtcJ/OZ2DV9ov/P/APwzPwCf0w/F+vys3VsMfv/1tvaH9v2vaY/9ecBf0O7nV4D/FPjNd35WgV/2g/Je2+OP+/0T7Pd7/+C+jw/6DwD/wJ3vvyMVPBZZZGB757F/+iEOgFd939/m518Af873uWD/Z8A/f+d7hxE9/ro7z/8b7zz+LwD/xJ3v/4fAv/QKr/Xfv/P4XwH8yU+wYP9T4NffeezzGOHk95RbeFyfPxhfr3JvMUf+hz/hc38z8HvvfP+Zc1Dfx88/7vdv8/WZKvF9F/u4nMF3ooJ/F3iuqsfv8LOfWRORv1NMafJKRF5ifG2vhXpfrSfyVV4D9f53eK2PU++/+wmu8cvA721lhJfYAi5YlPeDZj/06/Me7IvAn/x2D4gpF/8+EfmGGIfb/4rvf298Juxxv3+y/f6D4qDuThN/Nyr4rwPPxBh2V/vMyxm0+vP/BPjrgKdq1PtXvCbqfRER7D78kqn3v8NrfZx6/xc+wet+FfjL9Vup9wc12ewfNPuhXp/3ZF/F1F6/nf0TwB8FflJNbuO38q1yGz9Q9rjfP/l+/0FxUHftO1LBq+qfAf6/mJxBJyJ/IcaQ/Fm3c6z08wEQROR/DlzcefyPAH+FiDwTkXewEsdd+zj1/j8P/FdE5NeLSMRq3DPw/WgtfZLX+h+IyBda0/O3YizM38t+F/APiuniICJvichf/X1c32fNfhjX533Y7wPeEZHfLAY+OReRX9MeO8d6dXsxiZK//WM/+4Mmt/G43z/hfn8IuY3fJSK/6/v9ef3eVPB/IyYf/REmp/3P8RmQM/ge7/tfw+SQ/xiWMk98axr9e4D/AKvp/uv84gXxLXIDqvqfYU3Y/x0m+fAbgd+oJgXxSvYJX+v/2q7rZ9vXb//463wb+x3A/x3410XkBmug/prv/iOfvv2ors/7sO92b1X1BmvM/0YMMPDHgb+0Pfx3AX8DcIOJ/H18/f824P/c1v9f9ylc+ivb437/RfZ97fcfei4+EfnngD+qqn//Q1/Loz3ax+1xfT7ao31n+0Es8X1XE5FfLSI/0XD3/2Xgrwb+pQe+rEd7NOBxfT7ao72K/TDKbbyDKW6+galy/u2q+ocf9pIe7dFO9rg+H+3RPqH90Jf4Hu3RHu3RHu0H037oSnyP9miP9miP9sNhr1Ti+53/3V+v/TAQu4iIIjVDzuiSyVNBsyIu4EIkdgG0oGXBO0GAXAqlFGqtqFY0V2rOVIValVwhVSVXBedwoSMhHFLielq4GieOc2FeKl4CQ+yIzhG9Q0QQEZD2u3Km1IoTwTtH8B7vHM45vPM45yiqzDmz5EKphX/qD/7he5+tOPyXBq1eyVSOqZIyqDo8EJ3gUGqtlFJJBVQFcJQKpcJcYWl/JwVVqAriBJygQFZlKcpSlVyErFBEyeoppeOI40YVXMG5QqiKqJAUFoUiQnaBQ7zkpdvxvgrvL4kPjkfSMnOB8qbAe054JoWhJpRC0srv+jDf6z39r/3Nf41qGxNZ15q0dRB8++wloKqUkkEKzheQgriC8xkXKt57gveoClqEJRXSUsipUIp9RlodtQilghalVKWWAiiIUmuhlEwtlVIUrdr+XcjrHqjV9kNtH54KIHgBcR5UqXeqHD/zM3/8Xu/nW2++q0LFizI45Qufe8af96t+kp/+8ff4sffeYLcNzGlmSjAtnqVGFo1UAXUVyoSrM8FB5x1djMTojU1AFdUKIqgP4AMudIgLiAZyqhyPC9/44Dlf+/r7fPPDj7i6uma36fn822/ykz/xJX7Zj32Bs21kCILUjCv5FHUrFaWgoqgosjLn1ArF9tWf+1//rfd6P7/29T+lSvtTFVCkCl4CPgTyktnvr3n5/Dkfvv8+c1rIrtJ3HZ0f0BKoxeNF8EEI0RFiAPH44NkMHcOmpxt6XAyIU7z3dF3AiVBrpVLAFUQqilJzoeRMyYVaFO88wQdC6HDiSaXaOtZCqYlUjpSagErKhfGYoDic8/wFv/o3vNb7+UoOarfdsTvb0PeRkhfKImStLKrUmlEE5wBn+0zaIhQE7z0iNolWBbSCOlDvybkgKAg4JwRnh7CI4rWSpRIpUDMlZ5ZUCQ68OFwIeCcE58wBeY8TIXo7hIJ3BGcODG6pnWq1w4tacSjIw8z9aTEHnYFcIBWhquCAlBW02uFXaM7LHFBVoTQHsqg5qbQ+ht1HRFBR8vp4FXK1nysCpQq1KkUropXqC7kdhk6ljQMKGWEUz40Xrhy8nArXS+a4ZGoqZGmfXXAEqQSU9tHf//1szsk+Z9ohqO3/7eiqtZBzZp5HnFdiJ4RYQSpKptaCcxVQvA9IAJWKaqFqomqF6lDxgEPUmROptDetdjjWgtaM1opU0KqIKkLFY4eDOnC0jaEehwVargVTgpzekzzEGpXb6dFUK1PK7MeJ4zSTcqFUTy5KzpVcHAWPugEJHjxo9uQEtWa7PcEBEedo54EiImjwiA+ID3gXCS7SRUcMG+alcDhM7PcHjocDsQv0m55hu6HfboiDR0RxVXDeIUo7YCqCo1IQ2hZXhXbvhfsnne/ipn2e2m6sBYNO7IAXcYS5R1ykVM+chKSKFqWGQslCzhCjp1MhlYrMCdWM8w4tgqqnVI94W4chenQjeCfkVFCXIWacKxZIlUIp9eSg8ODFgiNxEIMnBIdqJReBtKA5kUsClKHrcESci6/9fr2ag9rt6PtACA4nAdGK5mwbSUAcBO9wXoBqi8aB944YAhZcKtUB6nABqJWUEjkVqtqyEeepFYtwa6GjECm4miklsaRCceb4zJW1je89Dos8V4fVBYsc1qOraqXUypIWcrYPxjm7voew/QzVO7IIcxUy7eCrSk0LtQhasMwnm2OqmJOpKiSEpMKiesdBCV4EETVHpJBVLENVoahSxZ6r1e5LALLaV1JBqkNxqDiK8ywS2Cvc5MSyZJgzQ1ZEHRupDGIMnx3g12RAH3bYf82o9e73KLlUpnnkcLih7x2xH/BB8FEseFFzUrkWOldxPhA726y4irhCyQVyQotDVajFvm7fswU/0pw/K6+YA+/sZ6RFbLaOHSIOhx1WIq0qQHO28DAeH1hdVKkwp8L+OLE/jkxLYliEtCTSoqQsaBBCGJCuQ6NDa6CmQJ6PzDnhaiBIxIdADA4nIL45Fucs0BGPx9n6lEp0MATH2SaynG05vzjjybMnnF2c0++2hCB4KUhxULKt6VpBC6ggavfRvhScBSzuIRxUNwDtNGrBjNAqPwK1Qux6xA3MqWMciwWWwTN7YZoSaVkYhp5+6E/BVq4J5+D8kBiG2Zydtyxrs+m4uNgRvCeniu8y3baAX0CSOaYkUB0OT2gpaNWKaEbE/kO1oJqpmil1JucZcPR9R3AdzvWv/X690qkcY4cIFhFCu/C2sZxtshhXB2UptcOZ02pZEerXj8SWfbVIFdS8N4LzVgIorBmXMETH0AXiUoFKVSXVSqiFUu1ArmIHN1JxIVp5D/Br9gRUHCrt+lURFIcQvX8d9/OV7aYEkEB1rjkPoeKopZJSpialVqEUy7CKWomutvuS1TKcpLcZlKpFSw4r5RVaWa85qopYMKC3h59rJRCqUCVA6BDXgY9kYEGZCyxlgZTpcwFVggjnzrN1Su8giOBw1AquPMgtPZkIaHNKLUU5BT45J1Ka8DFgpM0OtNrmKwulVkp1oJGgoQVgig+Jqq2Mp6BecGXN0D2CP2Xj3gneeVQc6tZVb+VXaZmStINJsKDPiZwc1hph12rloIeQmbJ9LrZWEFKu7I8zN4eJcZoZOmFZFlJScgLnIYaI6wakj6hGaghUFXI5slRBkpXcEMF7IahDxFsrYL0XSiuBFhyV4GHoI2fnWy6enHPx5JLN+Rlh6PEBPAWKQ6tHs5V1qeUUJKC2voXmvNppcN/m3e2Rq1RLpE7VHbueWpV5ztzczFxdz8ypEgJ4D+O4sCyFYVCGjSPnZPc/z4gUdttKjBOq1bKfXthtey4vZ0sScqEbKpsLJQyJEC3D1+Lw2hH9QO8FRwuStSCulWFraZWnRCmJXBaceJxXfLDk5HXbKzkoRUjJ+gvOYb0RVVTMqQTniMHhgwOx2qrUFiWhdmjGcHo1tFBLxQXBqwMK1cJ6vAgxRmJwSKkkEUY8o3oOC6QC9W59XuywtWiioqEgMRJUcSEgzkqGArhWSvReUDXn6R4ILnIlG4JEnDgy1ofLVUkpkxZHSRWtUIqYg8LKgScH1ZxPbpmRuVzw1UpH1QkFpTTnXRBqu2W1fcn6UypWpw492p/jhh0SB8o8M48TOU2wzAxZCVSiKAG48I7z4OikWKAiASmW1d63fRyVuronWi9PUFQzqqVlLwoUcslUErnMlDKhZERgWRwhekLwOC8oFeftgFsPU9SRiyAVUG/uxQnOeZxTnJ3ulhlh5bs1c2opUnNKwcp9d2jmVK1vVdV6V/dt0py7AiqOXOEwLtwcRg7jxKYXclpIGVISuq7gxRFih+8HRHpKFykVcqosKZGWmSVm5uDpgqfvAr2CdJ7g7Q7U1q/OOVFqBlFiH9k64ezygrMnF/RnG1wfcR7LGDRCLdRc0VzMQZUCVZFqQa3WauVaqdQHcFDr565Y9cGSpxY8FSvBjceJ6+trPvzoI168mBhnRwgDzvdM88ySEn1X6QcouZDSQs5HVDNdZxWhWjIihdgLm03P2e5ovb+6sNnB7jJwfinsLhTvLajsnMMHIHqCi5SaKWr7YF2WqtWcUzYnhauUuhCIiH/9VahXesWKGKCgLHQxICqoWGruGwghhHbYi5hjWuvm7V2e0mygVgEVvHeoOkqxjV+1ImLOLjqPlkIJnhSERQNzdoxLoWZlEwObLtJ7b4d8ypSltuzMNrdKi6CcnJql3jsgWOYg7pRl3bfdSIevHleEkott4lLJqZKTolmgWiM+V3NOSVq5UrBy3Vry47bEVNs2WB1ZZXVO0sobLWpbPx5aL4QIwxnl4hlle0byPdPhwFhAayHKQnUV7xUv0DvHZRc4D8IAhNZcOEWx92wfd1Drd7X1HbVawxeUEBziINdETQXKQq0zpS5AtkzcSevVeXxo7k6bg3LWmEYDWiPVOZxEhIA4y2Jt86/ZeusvtfLdWuYxgASWfSG0wPoEoLBU8BczhN6HrfvX/naUqhzn5VTm224EqcXKmzW33o/ixdGHHhcdtUTyUpjHmXnKLNPCPIF3EL1j6APbNDAMBqBw4tCipCVznBaWXFDn6TYb3BZ2l+cMuy0SA0lLO+gtuHLOIU7BWQalxYISUUXW0l8pUB5mfZ7u653e4vo/2taCOeaFZT6y3x+5vgEfK6ETUjLATcrKkjK1NsdWrGeUM4D1BFULPigxVq77NcNZ6AfYvnBcPvM8ecNzdhbYbXq63oIo7w1IVLVCgWqRF+qUkhfykkkpsSwJcQnnLAHw8fVXoV7NQQlMSyalBfHePK73uBCadsftJhTRb0HWIe4EmrB3rdajEgcOa5q6Si2ZUioqlvnYAeChCto7qo+o8xyOiWXObGLkvO+JISBgi18E7wJBvEVjtZzKK9rq/sF5vHhqu6fr4/dt1zUgWdGSyXMiL4VUKrVUu0dqTrzW1iNCyVgfT9dWr5hjUuR0it0ezG0jiLRyl0X9ayaprYzkVBE8Gjv82QX5jTc5bHZcq+NGhTFZ3tZpJTNSiuJVOAue8y5yHoQeIVqqAIvVxu/bzPmsB6pYxNwi51RW1JwhmLou4FwhpRlksS8yKhZ9rj0CBHK2HoylSRVRNeSV7y1j8B6pPd5tESIi3gI0d6dH2jKpdV+UFcFXqn0QajvIgjSltHJULZnSEIH3bc5u5grToKgwzQv7ceTmOHK2DQxxLW+qBZM5IUAIgdhFqnrmecbHgapHximhJUHNeFH6GNidbdhserquwzsHFZZUGOfZHFSMdF3H0EW25xeEoacAx3mhBMjqid4RnLdqSfBW7vNq2Wx7LyuKUhpA6jNhDV1nZVwags4TolLqws1+IXSBoWxQFzAO1w5Vb/mteEIMBipzsWW7rQyXCzkp86SIZISKD5XworK/EY4Hz+c+v2XTbQgh0vWGJhTxOOeheHJVimZKTixpJi2JZcqM0wJSqdXOFh8eGCSRSovu69orajXfYIeAU7UdCaeN6JxlWev/ixZDNGHQX3GWXgqOkiulKlmzZQfOFpdXoXcOJIAYVPjQzcxjonOeIXaEYB/WqAUt9oqndnW1kLTWBr9uJUkRKz/e5nT3by+ngi4FTZmSst2DUlE9ZdW41nPKqi0Twnrw6xMa2u6um9V21AGnAMGJmkNSy5ZUxNCWFJyCeI/GntpvmIcNVxL5cMlclcqhwuAjsR+AQsjQCZw7z65zDA662g40tWu1w/x+rd45dJxzJ2BBrQboKdnKE0pBfMFLRYs1jJUFkYKjsIJ8VOzQyLXitLbAC7xgEbtknFid3gmt8R8Q6U4owtWhoRWpt4GbZFrZ9Rb/YChNPZW4SsmUmqk5P0yJT/XUU1sP0iUVjkviuGQWhU3XE1yA5PDRSvWCGhTaBRyOGHu62OOcp6qwLJm8THiUFL2NfKSM9xPetfOgVKY5oU4gRoZhy+Z8x9nFJcNmi/NCLus5ohZwuogXZyMW0m6qdyuED9GKK8UyvfoAu15XuNad/2pl3LRkSiqAI8aB7facGCdqWawVESKxGwgh0neREIKtlzXLFkdoTiKXTE7Way2ptD6mAUeqFnIuHA4F5yvbrfLkQqnn4KPDBbGkQT3qA5INSZzSwrJMdp1TYRkzlUKt1ltbASCv017JQU3zTCoVcDgf8N5Dqah3qHprsrcTc51vcN5RXYPjYoctmu0AFWedPydUUbSzs7a0qH6pFpE5ca2cJLg+MsTAFD1Tn6C0De9a1BmUxZtXr2pNV1XD+leqOU0fCAjO30FSPVCJ7/nVaKF5sUWKVouAtDlSDPKtGFwcLAs8ReN3Gu6Ia+UMTo5XVqfUGtC3e6NlXg5EnUX5IVKGnilErrLy/nLk6zdHDvs9aR55Gj2x6wma6J1yBpw72IoSVXFFcbXYZ5IzWtO9309VC5YEQyEB0LKUPGfmcWJeRpSEj0q3Fboo4O5kTmJlIWd4ZbtlNVNV8b6hUr0niLPMUzLIQvAzMc54H3Bu7Rtqq3rZNYnHmvW6tp/0NEZQVA2FWQqlVrTkNkeVW3nygXpQagXjiprjUKXgWFygdgPx/Jw+RPyiqESDca4VlPY60Xu6rqPrO2KMLJNYSd85chXmpTDnkVoq4oQYIqqwpIyPkb4dgJcXTzk/v2TY9CCZUhfr62nE0ePpG1SftgkE8a5FTgXU5t2EO473gc2cU2IaLTuhCl235fz8Lba7SoiFYbPl/OKczXbHZujZDB0xegvoc6EUoeCJfYc4dwpucjZHVZLByEsreXpfESZyGTkchKvrwsV5Ri9tdqxKNXSl2DxrXSyoWKZMTZWaQJMFbloTIcz0/esn5X8lB7U/jiBCFzpzLi3ss7PR2YG5VkXE4bzDBaurK3YIBrV6nq6lv7UwKEr0gRqrNfW1otKcDDYjEMXq+p139CgbgXnOpJTtUkRwruL8Cidvh0BRUk5UVUP2KQ0aL+BaW/qBFutxXFoIjfXJWmQOK4ABPOawSis3rf0jAZuhcHI6DBr+6zRPU7/FQdnoov2slUJwdvS4IpQ+kvueA8LzeeaDm5EPnl8xjyOSF853Az56NirscJxR2FYlammD19agllKRWhC9/wNVWw9kfZftP9FSKYuVUZdpprLgS4UouBpAF1QWi7C14mhZqGCRuFY8agPkCB5nmD0BKKguKEeqGgLNop52j9umOIFRcqW2gMS+rB9bK7drX8tpmBW0zeo9BCxabAC5VusrdYHLy3Munz3j4o032D17g83lliCCjgu5OqoWbA5sRR4qPniGoWe325GWmVqthGpL0HqkOWWmaQaUvrM+dKmFKJ6uKMEHNv2GTb+hix25joYWFU/wkT7u6LqNIQBblLaeM1ULuUwWtIjDu5Zh37vdZk8izuYQc2aZF8ZxJKdsZ6XrCOGcGPZ43zEMPReXW55cnnN+tmW76eiiRxVSKeyPlWlRqngbM9FKqZFQKrUUtDmnnG0NWVK5xbsFZOZwyLx4OTEM1+g5uJ03xKEaqtCCPWl910jUSlcymrDRn3Hh6I/f4T1///ZKDupw2HN2dk7X96DYDFErn0lr+4FF9cF5fDAntZbXDIRrB6c6A0ZUaAtZCc6hPlBqJbWFVMVKJoo3yDo0NJYNhualMpWFqtIaWQoOKpXSGqilKkvOqKrVt52z13DOWAacexDEGcCyVCuvQXM+rTgpt01Um0daoQ16QgI5zOGu5UzX/t+g9c42vtgwKM6ypSKGuhTnEG/DoIriaiANPXOMXGvho/2Bj15e8/LFC8o80dUMmuiHjidSONfCUDJeMyrtUM0VKYprB9NDDEKe+kY0B6MCJ5j2+pCitZDTgkuCzxlcokrCYZ+Ht2XUQqtb5CfqsAags8y+lRGTTjaNXxZKSG3wtwfpEO9uh1K1knOyqDZDzYJW3+q1rC0vM6GVwM21PQSQ5/y8Z5pmUqo4L1xebnjvi+/w5R//Mu9++cu8+bknbDuhpNkClEUp1VCRpRZ8McRv8I7NZqCWC6QFmocuotVYXErO5KmSG8ODuIJNfrRPQS0Y8zi8WHBQFKgVHx1dHNhuztgO5+b8UPBWws61sqSReTFUoPW73QM5KFui1iIVVCspFaZpYTxOlFIIMbZxiECtNrYwDIHLy44339zy9PKM3dDRdQZMK1V5/8XIhy8XDodMyrdoXtTQpHHjqbWSc6FiQJ3NcM5mcOR8wzi94P0PDpS8J79V8BLoY48TT04LtVZCjEgUakmE4vGd4EfhcCikKbNPh9d+r17JQYXYEdrga8mlDbq1AcQ7MasdtusOt3KUazXfWguuVKQ11hRH0dKoYKwHZdRHrj0uFCpBhFit9i+oZVMhkGIglYgGa4wW54hVWar1c9Zmjm+DuN57wgl2Lg+WOa2mK2ODtLLPnQxJG5zB3e2RNXSkZUl6ckSuRYorxREhIiEQ1EomEh3VCbnRm7gWXVa5DRKqjyziOC6Z/dQiumVC8kKgMKSFnYNzKZxTCDWDFrJA0dpGBFbn8DDAk1OQtCK6xFBd0VuvMm8iw+gZJ2FMCaVaK6LNNtnh6Yni8Suwh0poqLzobCxB1UpyrpWNxdlQo6paFpHBuQFxg+Va0vogqojLiC9IwXqDzthPRMGptnGB1Zvq6Z09xCzEr/qzfpLr6xvGcSL4wJNnz/jSV77MF7/4Hm+89YzNbsBTyClRqjIvC/OU8eGcbhhxToh9sGH4GNlst3aPBYa+J6WZZZmZpolaoe+t9+ZbC0FEbL+KsXXkbGwypboWBNlajtETuoAPFnTWquC00fMsLOnINB/IeSYEj7iOGB9mOH91TtbJ0AaQqLdlUbFs2qpDbRBEhVqUaUpcy8w8FfrOszvr6LvQSsWloev0dL4pli2BELw5q1KVXBTxjhB7kEKtM8s8c3M1cz4sTLsR7bSVWg2wFn1EqeQ8M88w64xmtZJf/nhn7fXYqzFJbHbEEKEquUFKZYWUt8209nRqA03cHleK5kQx3hMrvTlvw7UFUi6t9m48Zd86UFoJVGrwdE4IDuPWC4Gh68giSB9wMVD8zFQVl5U6WzPUiSN20aDw3t9GTg3y+5DmGqVTu42WTcn62Pol3D3r1zLe2tlza1nQWfe+hoBse1zX4Ys5dx886oSFitKGF7ESalbIohSJzFWY5sJ4XEjLAloIrtKhbLVwnhfOyGy0Ilooog3Gro1Axj7tivW27ttOUO519MEbb1n0wYaxc+Z4GHh5DeXqSGWBWk49Pe8DXejofEf0wRyumoNqt9doocpCrtUAE76BfVQpWqg6kVPG+RkfJrxEEAMLgENCxdnIDuL1NCTtW9++FLVZHVdbL3fdZ/d/P//8X/Pn8MEHH3J9fUMIkSdPn/HFL3+JZ8/eYLsbCB40GW1YSplxnLm5yYjb0fXnhBgI0eGis0a6GngiBs92OzCNBw6Hg42stHgy52z+WBp3pg92aJfCsizMy4J0Ql1HAYLgO4f49Z4VqmS0FpaSmOYjx/GG43hNKQsxRnzYgbz+pv4nsY/TrqG2jtyaaTtPLpXjcWKaF7RCbpx3OY88lwVxwtAHPvf2jqdPtkzTwjwvTNPCkhTnfRvfsUVbRHBBiAE0GQ9lKYGiEfGR0O3QeWI5zkyHwniY0QzaVVy0ubau7xCUeXakKVGmynJMpDHZcz8F5phXclDeOUMTiRGZemfT37bBxOr3AtTW5E02CmcHqVpPSiJSrd2aCSR1LA6KE6o6qngkgFeLUmuu5CWT21Dvmik5Z6MOIp4QrMHvukgoSlgKeszGRNGckPP+9NUC2dY8a/2eB4KcWu9IrL/RkHfWW1qvsV2myp2ZpVsmDhs4tkFSCYHaCTUGZNNDDEbCVwz+v87bVF356aDiyc6RnGchMlfDsHnfsRl2iHPEmtiR6Z1Bp2uFVA13XbkFQxkAW08lqW/xqvdk282GEAIhBLpoDfkQPH2MDF1HmkdefARTusEfvDmWFVCC4PF46ejihiHGFunqiZbHem0LOSnUBGuPr/1tji4jGNhCSVSNiEZEjNRTgrdebDUaHpdtRgewiBqsJKvOPGJtCNgHSPbffe9ttruB8TgSQmC7O+fpsydstwMxBhyVuvZzVU+N+SUtLMvMsiw26MyKmLXyWowRwdCKOWWWmJBptp5MrXgfWAn7tAWquVZSaUPVa4kpdDY/1cc2SF0QpzinNohbE6mMzPlILhOlJJRMWBxh7u7/hkLrkTYwWQvhqxr35jRbNvr85ZH9YSEttqMQ3walm3NptFOx89QqXN8sTFNugAlYEVFOjNS4URMifs3csD5oNXJY7weK21JqomqHaiDEgX6zIXS2n3wM9iIq5L7QdSObvuKlx6mn86//fr7aHFSxzYdA33en6NSJGjoGo2asagidqtoGeaWx79pCrVUbN5xnqY7khOK9lVlaOc6JgRuyLAaTzJVSC2iwQUcnWHvLGftxI5p0QZFYKHIktxKYtrKXQcxBpRGqwgql+kUDnvdlaza0FvXuwuNXR9UqApyYB1YHJZzmFXzX4fuO0jly76l9h3rfuLMa40dtrXr1FHGoBPAdBKM0qmpMAaijG+As9PTDgKsLQ5kI2AG9VGP4ZgFKsfmS9mdFYWrjQLtvO9+d0Q8DfdfRdz1d39F1kaHv6GPkcLhhmg7E63DqR7r1JgM0CIT3ka4brMzUCDMNmZfJizcgQKmoNMSTRRH2MjW3j6lQdQGNiHYIEe8iQmfEmlVOiEtJt/Rbdrj4tjL4lr7afdvTp08YNgM5Z0KIBhfvbWbGNY8j2vqdDUGpWqk1k0si5YWUAuBOYB6wHik+EIPN3ThvvZZUCimX9r1rQCmFqkZoWqxfVWsgOkc/ePpNR9eHBmhp2ch633ym6GzOSReKZmopzMnjl9c/t/O9TFvv2y5PT1yYtSrjWLjeTxwOiY8+2rM/2gzYmk2KWL84VSU35YOXV46SlXEujHO2Ad2qWBvOBtFVlFIFVz2hyqlyrGroVnERkZ7qtiiFgqcS8WFDP+wIfWxlUQtyBUfOynabEAJaKjHYnNrrtldyUNfX12yHjm7oCT6cGsRgiJi1qSwNwYR4nAt4p60MZf2lJBbYjzgmAhoCOJCgBO/pht7Kbzmh45FUCqVmlpKRXHHOSiC+TayUNlOSXWXJlTlXplQYU2FwghdvGR0KZT3o20Q/awntYXpR9vtpqLFb17Q6rI8/VxtCqa69KTFgSXWB6j0LsJh6hEmKSDCeLHFICEgfLbgYOsKwoxsukH5D7Qe6w8h0dcNxKqS5EKeZaTyQDleUnJg7z9ELVSOhRMTNuGUh5orUzC15TMvxHsBBvfXmW/R9Rxc7uq4jdpEYg0Xx3rHkycYRil2pya8Iig2I56osJdOHQu0MUu69s96rN3CJakWyAXfWcYq7ZRtEjb+M0taVcZghGchWhhJFvcd58Gpr2VeTWbGhXT29njFO8CBcfF1ne7FkxYdA8JHQda1ULqi2fhB2yIoYeWjXRUI0p64taF3HktbcweRIbKA7Zcu8anPQpyY/txl/rUb0nLMxGYQSELFeVYw2XGolXtoohiBFEA/OWw1VqzF455qYl/He7+eprHdnzdRaORxnPvjwJS+ej0xz4cWLmeMxkZZWPs2ZeVlwXqm5jc1UZU8lzQspG8CktCBUSjHKo+Dw6tAqaCnUDLkoS674xVvmiq1xlQ5kw1yUmyMMQ6XrK72rOBfszI/Wx9qIR8Rzdv6klcZtWPh12yu94tXLK4a3ntGFYBGQ2kCYFwyx1+YOnPjW4GxOyuhKKVSqKAvC4h3JRzI9Ug0Z5UqFEHC7rfWJ8kQRmNNMSgslJRaF0HggA4ZIKyJossNlPy0cxpnDlJiWTOg8Ue0xKbeNPCtP3rKfPxRYwnOLvkPvFMbuXI4dUG3D3kmvqggijiye6jwqnglImExB7Ddo58AF6CJ+GIjnW/rzM/rzMzbnT9junuE3O+gH6kcfcfPN9ymHhX7KXN/suXn+ES/Twv76in3w+OjpvSfWQCeBXiLKTMhQapOZuFOCvG9789kzYtc1HsfWaPc280ZDb+ViyKlasc3pfBt+blpkuZC6Qs7VysfizGe0sQSClelWRJ8NPEsr3TQXbalUA7/YuivFXLhTNZgvsXH2GXNAp4ZOkwacWQl9S4u06wM4fO8DoVrgaaWgYH8Hj/dNXyi1oFyNPWK7DWy2A/0aebfLVl0RqKYNl1IyUMU8M08TS8oojVevSU/A7Z5df0duRMoxQS32HOdXUIzHwPrWInCNpd5FwSUQg/5RNbPk1z+3871MW3vD3WEFqqUyH2euXux58fxAzo7jIRst1JLIaWGajhz2NwZqwAKGWpSaFyax/l1FQOwemPSRw5c27uNuUakVI522z9Sqdl2M9vMaGaeFl9eJ4GdwjgvsMwmxaxUFz+ADfbc5zffZr37gHtThMMKb9mZKzqRsNy96h9t2Vmpy3npSgBJQ9Y2qJVmE7aCEDo0DXX+JD+fUDGUuLMfRDgp1dOIhdvi+J3QdEgN1CVQ8xUdwAVXXIjFjNh9L4uX+wIfXew7jTMpKjkrRNbPjtpTXaqmuWibi766YezR3KuvdyeJauQhOqOjG/tyCa1qpToQMDUZtr1aGDf7sjN3b77B79gZ9P9D1A67vCcNAPNsQNhvC0NP1O7p4joZI9gbVfdpv2FQhq+f6xUs++Pmf52f3N1z9ws/zksIhC10M7ELkjeGMGCvqDtTxgC6NukfMoa4R833a2W7XDs+AXyUcnFipg7X231BRVVrWElvZxRClqJxKVdp6S0vOxjXlm+NwAt6f5nxUVqzlSqS3fpxtA69l1jb7UxFcNbqo0FB+XrzRc+ntaEZpTqpi5Mv3bcZMIFa1UGmoyEaG678FY3grjOd6tpuBYWNIObcCk7T1QtUkdqZpYjweOR6PHMeRJSXrGYdA7DrLAGoxR+OsD0PrpeZsTmqZnUGnq1rRZlVNsAjOWgGtjLjKeSiVool6/8xRxhQRG18gNCorG8nogmc7RHL2jKPNyS3LwjQd0JeZlEaGjc16iQRE3clpW1ImiLekQGkI1tTAn+1J9ZTxO3LqKMvMMAx0XdccWaUsC/NxpiTrD4qIlcmV02iOOGeCmnftU1ier+Sglmzwzy4GxmVhSYmSMiLBombv8f62n7Jy6KViLMZVKsSA8wG32dKdPUE2z0jTwrSfGOeFPCfSlIg+453ViwuCOt9Qf54aOouwsEG+UjNTKRzmhavrkZdXe6YmU5ELZG839NbBG+uEaLVZLK0P0i+BW5SeiPGc3Wk4NTu51tNUkdreM2STMzoSjR0y7PCXT+nffIuzL36Zi3c+T7/bEfoNhIDEgOs7m95HSDgONZIWZaoLB3XE80uenF+y3Z2xf3nNeR+5/vov8HXx7OeJeUrE0HG53bEZztj2oTVhlZoTpdqAqY0W3P/97PveYPUnhKacNrENOjucN3E1rdaPEwLRBYILZDG4uff+FJU7L8xLJpeMCw6kUcu4VbRQQUJzRCYSo+vQNXr6DFUruR3SXozCy8bXPdZzig3VacPrTlZEpJUNH6ILFcJKVlmpuZHknrCagBrSUESIwXj0vB/oe3NOIbReUnPOousMWjZE3jwzzwamKKXgQqTreobNBicm5WFQadeqMqv+ljYmb8t0c23rTdYwQVBnJVkfIiF2OB8MfFIN6fcQYxB5ye1wtw+35EJaFkSVs01EFFJ2jKOtn5wX5mnPkm4Yx5ecnT1lu3tC123wrgNcG5No6yPndr9dO0MaglqNe7BqxXlv8PGyUBbPsoxGnRQjITjQiZEJqQkvlfOL4UTkbcwid2q1n7K9koOS2BO6nqHv0ZKJQRDZ0fUdu+1A8GLKuitVi1qvZFJhLhZxetfRxy3dcEa32SJ9jy5GMSNSSHnker8npURJC6KJIDYNvVRO0u0xBHCemoSlVKYCY1KWArn4RsQJU7aac+8c0cspY1Ex+PkpAnkIXi5WoMNduiLa/IIgRlrYykucSnwKqHNU7/HDBn9+QXj6lO7ZU/zTZ8Rnb8DlmxzCjutFyPPIkq3HUhv56FIyKRVzTikz5Uy37Tm/vOArP3HG5TtPON9skbzwwRff4xt/6h2+9tE3eHF9hMVUgHfdhm4XCJutzcalZAu55gZjf4j76W7nyKohubTxFrYJMPphwzBsGlDBuBu9eELfG6eeg34IBqzoIyEGSk2Niqgxdouemvim5dQ1JNuagWGAolbwXDkKaxtgVimE1pulaexUIoq/nYWR2+i4VJNUuf8bWo2dpapJuLdASWqFTAMsVLzzDMPQ2LQ9ijbOQ4dIPQEcpAE+ykrbJNbTCCGCeEI3MAwbtrvt6XEUQgx0fY84K18Z1+v6d/us16Bopf/C43xHjD19t6HvRkpJpDxbpv8AazTNRs2kbSB5PI4cbw4s40iQwqYTgvcMvTdtPWeEsUZ35Vm6gb4/Q0NtvbWOIJFcFuPdy4sxR9wZ8bGBdaOrck7wrqMLAZEEOpHmQl6UEL0J0nrFd4qPjthDjHLS+LsLJrMg7NNdk6/ooDaEaE1n7SPaR/phQ+yHNixWWeaZxELVQsVmmuYqTMXhXGDwG1y3JXYbYqNMmtSkDpxkalk4Ho5cXR847A94D0/Ot8Y7JQFxnuQ8LpgqZwGWJTFXZcqQqmvNa6FoYWocfASLvKKjlWOaTPdamCkP56DWhs1tFrdKNDhjgmi9tlPTGEACxAF3do5/9ibdm2/SvfEm/skTZHfB5AfmMXMzjdwcDtzc7FmOI2meyfNMSjPTvHCcFqY5MZXC2+98jh/78R/jvXe/yLbfEM/P0ZJ574tf5Otf+CLP5z3l6jnzPFMrbLoDfezY7s5weOZ4oExLywlu+zH3adr47ESs+VzVnNTKJiU4NsOW7eaMLg6UOpEXoRsMJht7MQn4ztF1gdgFQgzk6snqSCXZsHkbqtRWknMu4DB0n00stMiiiWM2MLGV62rFSYVgeRPOCGuL2hc+nPpeq6RKqYWUH8Lp5wb60BP7d23jCkWbTPiSEYShH8gOlgylFOZ5xmWFRvyac27zfgJtgHydc+q6noAQu4HNdst2t6VqJdeCQ1pf0XjmajXhSVXbx6rS1KHvlPBbL8b7SIwDfV/oh8mId2sBzQ+B4WEZZ0SFmgspZY77A/uXN4yHPVpyQx07QlBCkJNQoZaGmJRVHNPCnuB7fNjgsp15eRnJaWql0bXWbHOSwXu8RLro2PShMZ4vpLQ3lGO2HpTbBJzr8GEgRGP1qDWR84xzVnU6UcWtnyfwcVDX67BXclDOe5alcBwXtJjWfWgN6XWotoozuDeOVGHJiVSUgifEgTjsiHHAiyfPM3XM5MM1Oh+IZHZDhIsLRKL1VUTZnJ3T97FRHLXyTQwm85EzGWXJhSVncjE2CkNktYakg1Trqnfa5h2t7JCLQaMfohwFa+Md1nxZMHLYu5/50pyUZVYGOQnbM8KTp8jTN8gXTxl9x7KfKNNHZH9FCT2zCh9dXfPy+oqrly9ZjkekZDwV74SUM4fjxJwrC8LubNvAGo5clCiBYXPOG+98kS//1K/gm/tr3n/+klKuSbnw8nA0ZI+PnItQJSK+I5RMR6F7AOBJzuXkEGqprLCN1hpHqjJ0Pee7M56cX3J9o4w3RwS1+37WmWSD90j1NoNUsaHdLqJzplTjGqQaZ59zxlF26pGojS1b07qNMLdqAjQJDSnIijEPpve15IxWTxBzULlAKspSKksuzOn+myZN9MPeU6M1821oNs0jaV7QpeAksOkHZldZamJJC3lKlKZlVqtlkn3f03ed9eRqa9b7wLAJhBAZhg1x6I3GrGRC11goOusT5pyarpswaJtvxNkgUc2n/p1VIgwa3QWBXhoZs2kqIYlVyvw+7bg/UlLBO8dxmtnv9+yvrjncHFimhaJCITIdFtAD223H595+l0oA6emHHX2/NQYZZ729EALOnePcxhL46sg6oVKst+kjXRfb2MXAZrezAKAeycsV47jANIJmkyNJhZyVcdpzfePpukrKR3Y3A33fE0NP38qwKwHCabb0NdurOSjnGeeFq5sjXYBtMCfhQqCUYs1jbL5GvIJY5GpOKxJ7w9XHrjckzzixzIl0vEHnkSjge4uUfBgsMqJy/uScoe+oag3FUgvR28LVZaGgZDUEVqm1iffRmstt7epaImvEqq1UZsScK7rnAWzNnuBbYLiru1L09H782ovzHWzPkcun5N0Fc+y5SYX94YY5G+u5hshUK++/eMFHz59z9eI5y3gk1MIQPduho6qyH0cyJrMhogybLT52pwg1xi3P3vo8X/yJAz/39W/wC1//JvOSOI4HDvOEPwZ8t2EMEadCkECPZ9Omo+7blpxP97GuWlB3ih1OhU3Xc3F2wRtPn1FzYhkn8lhJruJdRaSiuqrItnxW1CaTtOlJ6cpBaTM91lewnpcQWTMo1dx+913iXOvDGAijUr2gXm0IXh2xRgTHUsSE6ZpzWpYHYIdfM/jmpKQauKOmzHxzZDmOaFY2w45h2yHOSu2pyZosqZKy0Ul574ldNO6dArX1TxTjNOy7gd12R+wjmUKRgotW0vddsOH1soYcvjmhRvasyirLudbETU7HEIeuBaSlVI7HGZFkyt/3bMu4mMYKcHOz53q/53C953g4Mh0no3pz0frwbuJ8Fzk/25HqllI3eB9NCbxaabU2AU7nBgOouQ7Ti0oGyBGPc5HgB0LcNLmOAec6VJPVOipN4sfYN2ilu+BGUEfJmeNhZLPpGfqBoR/Ybnc8eaLszrb0w4rgfv32Sg4qiuP6+oAuM0/Ot4TYUbJS/FpjNup34xvzJmvR9Wy8R0XYnZ2x2WzwPhhv1DQx7w/k+YjmROwHfIxsujM2W8f2/Ax1sNv1ONfk5tvNKzmT5sXoQVyDUnp/4qDywUODV3qPqZsGo1gJ3lFKi7J1LRc8UM+Epoclxja+Rn+KwciLCrlBSFUcrtsgZ+eUs3NSN7CfZ672R/ZzYkoZ5yO+66l9R0Jscl5LQ6MZRVWqSvUdOI+rkd3mjN3lU9798pd49ytf4uLZMxBPWSpk4fzsCZ9/78t86Ss/wQcffsg4z6RkvZh5Xnh+/ZKjD8RS6GthK2LQ9wdo689pwa21mxbSrTBY37iKfB95cnmO6Lv0IdCHyJImSskcriZu9pnQC/0msDuLbHYB5wsqmZwXtJX4nMiJcNf7daGJTSo7bdFsG8aUcnJoNLBALplFUtMvsnKkFIjVxP9yEZakLEuxSsQDCECuqbzQWC9UcOohQTkuzNcjmisdHdFF8J7tToixMmwry3LroJz3bIct/TCQU6bqRMUxz00LrSjb1s80LSmQNjNWa6ILHT6aWrEpd7tGm2bqzjZJYFUTrYafXp2UBKHWwhxnumgHfejuf1DXOd/AHYn9/objfs+yzJS8UNJsg7YuE6RyuVWSego9+2PPYYxYHcgCdRuCnkEOONej1THPe5Y0Wv9PC5lCbuXVcZoM0eg9PgZqmSj5QF4OdrbSeA1DpesLh5vMzfXCzZVjt4PNptLHheD3nJ0dePvtzFtvV954K9D3nw6v4atlULlwXGbq7Bi6nlwsddcWampL5bUVhFXEGA7ocCGw2W7p+wFBKDURUDpdCXIMyBC6QNgMVN+xOd+hDmL0KNUkhjGJ+GmcOFYlNqXNGDMhpoa+8ninK/rhxHMVY2Az9ATnDP1TKjm3kstDMUk0uqVVLmNFbakzHa0q60dkmWndnMHFJVMcGEvlOiWux5l5Tmip9JstIUa0ZjJQaqGK4oIzp43Hd4G4GeiGgc1Tz+Wzt3jr8+/x4z/1k7zzhffYXpxDY0l2KnT9hrMnT3j65lu88fbnePLB+0zHI3k2/Z7xeGTxns57qvd03Q7V0kAC92u55BNsf+13rMKZ3jdSXS84NninBC/0XeDm5pr9/oYXhyuLsEclLQEvEL0YuauYZLxgczfeW5nFx4CLhqZ0OKQIxRkTUsmmr9MSrlO2bLRAhYVE9AFBTJCy8VCKVkpxpGw8laWUBwmibn/jitRx5qSqQFJ0KuQ5U/qCI9B3PRsXiF0lF+hTtbJ7e/PRR0NGOt/g3xEXgjmsXKg5Qy24aJ9NCDRJkgUJgaEfGkrTdkpajOR0mSe81xOyTeS283critqYvWNHwOiR7tuCE9K8MB32XD1/ztXNDbkUSspoyhbsREfXB4ZN5Lg4ro/GzLEsHnEJ7xIpHZjnYwNQVJzvrK9ebaSntEyoqvWf3GmuzCoJCNSSUV2op76qtM/FE0JmPBYO+8z+emGz6dhsBrro8QJnu5llEZDA7mzbBto/hfv1Kk8u02yy06XDEqWGtRfXBg4bT1PJlJSMMy+sk/yRrh9sQSIEETq1wd3xCCktxK7Dxw4fPTUGvApF1kIXuL6zdN55as6kGOiHge2usOTKcV4aOWUwlMy6qdVkNrq+Z7vb0ofAPGeO08ySJ/IDUh01BPGJv05FqaLGTRgC2g90/cacVRHydkveXfC8VF7sD0wNmee80IVG6TNEDgI1t6Y7Ns8igyI1MAwd28snPHn2jMs33uDdL36FL/3YT/D5L3yZN95+m37YGFxXV8ZzoUYj5O13G54+fUo6HjlePWeajswlk9WAKJvNwHBxwdY5NmW5/9upxt4g7ZDyTu6wQazRZ0Giw9ETwxMuL3a8fPGCj55/SHo/Mc5Hi+gXxRVPdAPoYmtEbctY78m36fqA61a6KE4wd6P+yZTGo6grYlMM21dqQUk46XB4sjSy5Kxoyah6tDhQY/8OD1CSWtWo7VCzuSLLpByBgKuOulRqUkSdaRfFnpQroVRKpLFnNz2iZJWTVZBzs7W+5+w8DqXkmZSELka6IPTBs9SFvBRc39PHJnBa7YwZy8w+QHAV0Qvj3aSpFbgVnl/J1QZzS8lW8vNijDX3bJ1XljQyXr/kww++yYcvrkiqRBc463rOz844e3pJ3/cowjc+2vPBi5dMY2KaEsqM1j3T9ILj8ZqcRgvK2gzqiQzb6DQaM0fTv2s4l7U0WGs5oRlFMDh+y7Ccd6Q5MB0j+2i0X8Owo+8Gog8ctkrOgegH3nzjkq4L+M0DS75HNeg2hSaypieIp7aBQlUr881pwWtH30Vc1xG73hyQj1a/rx4fO4OdFpMcd86kPILJ7bSSiJ4QKa5lGQ6TT+i7jjqYCJc/TqYQi22mUgupZEPGBFP27WJkGAY2XUeIhSqOw5SMiPaByGJ/EZRIpA0ze1LfIbszwvkFEnpqVpbYceh6DilxrJXU1ImjOIL3SO+t6d5YC7qu4/JJJMZIHzxdcOx2O56+8ZRnb77Fm597h3fe+yKff+8LbM8u6IbtqS7tVNBc2B+u+eDDb/Dio/cZb64ZnOfJsEEOHapH6/15pR8Gzp4+49k7n+dJCGzm6d5vp2+yGF7EdIMaka5r+j9aG09cXsglEaNjd3ZmwZUrzGWmamFZZkInbPsdm7BBMW2e1FpJTWbTHM4617Ie3qgNqHt3YklRG1xrApnWVCxaqbngXbEsy1Ujp6AxKiBN/tw+ixU+f59Wm3RFLQbXl6oU8UgVgkSCRNCFmpSSTNQwdibhoJoo1SokNnQLSjK2cmxQOsaI2wqdCGmZmeeRqgvit4TeM0SPJljyQmmlMB+8zVItC3OamKc9Ny+fs3/jKU+fPmV7fka/3RG6iMMkN1JOTPNESgviIERP193/cH6ejizjkelw4OrlNR+9uCJXZTsMDJfmHDbDQL8ZrNynMI4T41hIS0aZEQ5oGXHMOMl4MdXlXNf+p62UUnIrXTfg0F3KqFIw0dI2v9e0ftZqw0oB5nygixv64ZyznbIZhC5WqI4YJ66vJg77ibPzgWF4YAe16zqEYuWnanQxKRVCKCfHVBoNyTQtBAFXegYgrINg3lMWW/C+OSUhImSjnilN2lqzDeWXtaHcSnbOYJheYNOZ9Me8WCkppcWaySkzTjb850SJzqbSDSIf6fuerndUPFeHEV0WYwp4IFsb8lbGg+o8S+hY+gF2O/rLJ9APpKocMrzMlWXY0m3PyNOBZdxTqKgHpJCozJpREc7Pzzm/fMK7777LW2++wcX5GRcX51xePuHi8gnnl0/Y7mxDV7Wham1zPFor4zzx/je/yh/7mf+Yn/2Z/4Rv/umfY1OFc3UUdSzqmCoE3/Hk8hnvfP49vviVH+PSR8L4+hU2v5fF2GaavCc4+7IJeRvQTLWyLDPH4555PLLdDXTDJf0ucsEZuLc5320Zp5FaC5tNZNMFqiRqjcwz5qTU+H0qrGGpSWS0Zvxtw4nbZr60A9FZP5Cs2DBGAcw5Edvcj4MogaABV5ouVXmAEp8qS1ooS0GTUKrNabmqRNcT/QanMyXDNCdcVsI2mPCgQs7JFK+R0x/E1HNrtcy+6yKdc4yaeXlzYDwmxCfO2DIMPcULh7Qwj0eOztMNA+IgzRPH/TWH/UuW+cgbb77BG2+/yTvvvsfTN9/i7PyM0EcUZU4z03gk5dmQf2JKDPdtL5+/ZDqOHKeFw5Q4TjOpVLxzpFJalm0quzf7kev9xM0hsySDevtQ6bwwhHNkt0OctQTGMTHPuUlsVEpdKPmGebphGvcWYOiqLWWZ+jCcMfRniHfUkpmWA/M8NnFOex3vArvdMy4ulKG7QLt1NM1GDJY5cTwmliV/Km2SV3RQEcFISaMPjcrdqIZsM7pW6zQIc00OX7Kp4gZTiRyXmWUcKfPCEAND45BDIiVXConijpAWkmL8Y22QtmhjfHYWv9aqzNPMcRo5jEf2hyPH8cg4jYyTMV1EJwzRn5rkJ1im7xiKEvsexonlATY/cBodsDaeUMQ4Cicf2TtPwRFMs902KnBQhRghOPJy5FgyWjNTdYyihFKYloL4yOc+9yZf/spX+Omf/mnee+89zs/PONtu2W539MOGrh8Q8RRVlpRsPkShlsI4Hrh6/5v8wp/8E/zsf/Qf8f7P/ikO73/IMJwT8WwkcNZvkaEnPjnn8+98nnfffY+333mPMxfwx9evsPm9rPMrzZHRBq0OymhgzHHEaH2Q1AhuY+fpNmdstgObzYbz7c6od5bFGAek0MWISIej4lJlpcZdmba1FIOZn5gMGnawOSZxNrOzTt7KiuTL9aQgi/e4IGg1FowojlgdUk12pqYHQPFhPbB5niGJAThEiMUYOfp+w7BZcCGypELMhdB6Pd4HXFPGXemOpJWfalms7+FcQ0Fa+TClmbSMxE7oorAdOoIIUgslzSxzNKBTH3EKJSWO+z3XL54zTyPHw4GclWXJzG88od9uQCDlhePxQKXYwK9G/APMQaVsbOH4DnUBJeAkn7SvVNUYNg5Hvv7+R3zzgyOHw0jKESdKH2A7OKLvLODue5wP3NwcOR4XTEY+Mc97RBeWKaIhoKGJcQbXsqjM2dklFxdv4IMnpYnra8f1TbYeqzOnJc4x9B2boedsO3C2G+j6yKZvwAhRpmlimpZPpQr1Sg5qE6NJuIeO3bChi90d1VKHRLsJ07IYvDsXZF4oatQx8zhy/fKK4/WemhIX5xew3VHVoxLJZWRZZuo0Up3N/DhnczYo5vQaoCHXypIzV4eRD69u+OCDD3nx8iXX+5H9ZDT1pSoSXFOsXMXBaEALIz/sNxv8YSTr/rXf3E9iq+qlwfGF7IOV8Xzkwyocx5mqV9AvuC7iugG6wQ6OJXE4jlztD+SScF4Mou8885zYbs74iYsLvvilr/BTv/yX88677xK8b1LlxvycU4Oqtnq0VBNPrClx/cGHfO2P/wm+9jP/Gd/8o3+M+flLwnGE5JE4MMQNfrfjctOzffMp733pK3zunfe4vHjC0AAy920hhBMRcGiS7L45rRACw2bDZjPgoyNrYthuGM62bDcDwTtuXl5z1eTJl2nh+uaacTyy6U16xLuKmyvHlEzsEJruUIVSbEanOSddATCu0RhJm3VVI4wVMTJZo9oyxmgJVg70OKswaKWmQh5nlvH+S6bixMAcs5Xxcg2ocwgdfYj0ux3n4qmthJdSJuZshKKbgRA7Y5poDmqaZsZxNBj9Yr0TwbLJNf7OJXM87Ok7z8XZFlerORO1QMA7YYgdUhJzFxhixxwj82HkwzmTs3LYH3l2/QZn52f4aCMPS07WfxKh5g55gJjUb86IndJXx7A9Z7OdkVrYbmw+TFW52e95//kL/tjP/ile3BSO84YYzxiGwHYj7DamINz1PcPunK7f0A8D43HG+0DJicPR08VK56GUp/RdPEnPFFVySTx5+ibPnr5F7ALLMvHRR+/z0UcfABXvHbUUILAZnrHbvcnl5ZtsNmeE6Og6z6YPxM4zjRPjcSKn8r3e/ivbKzmorsHF1Te4dvC4EJAQLVJshz/iKLWS5sKEcnHZ5KDnxOFmz3Q4Wk20gvhAFZPJuN4fGecj6rTNLynORfpuABzTsrCkzJwScy5MKXF1OPL8as/z51fcXO+Z5mTT7SvEuEmiw+qY3Ik8MnSYg+o6ygPU96GV99SYIqr3aD/gLi8hdMwVbhSmKaN5IhalJ9IFSMvMOBpDxPE4kktBvKfrHTHaMOIwCNvdOU+ePuPi8hnb7XlrwldSajNlZYWXWdQkGAecVKXMC8vhSDlOyNwEC4cNm82WYXeBO9vhznb48y27p5e88c7bXFw8IYaId9YTu2+LwZRwg/d0IRJjR9f1razb4ZpG1vn1GSF6m9D2jth3bLcDqoVaEpuhsEwL02zDlCaM2dHrQNGJuXpSmwpYiWVFa9NzssP21J/CCJSrGLVR1VbGbkPaNtJbb3WptM1EZUFnKMfMMk5M0wP09IJVHyp6GlAuotZf85HOG7Apo+ToKWq8m7GTxu0W2rDorex7jJHgI9NkjCS1ZIpWfPDEPjIvjnmeOR4PLNM5Jde7BcI2e2ZfQRzbvkd3O47jzJIzNy9vqNWUeceLA91gYoa1FkIXEaD3gdTdP0jCdz0lm2oD3p8qTsHbfVGU/eHI+x9+yM997ascZ4cPzzg/74nBE4PgXKbqwpIqzKZmrZqIHfR9oBahlA7hnIvdji56trveCGGDSb6XWri4fMLTy2eE6FnSzMXlOU+fPQOs32/ECI6+u6DvzRE658klA4VUKsdj5fnzzNl5zzQ+ee3365UVdTVbhFJrQXyDkcfeCF2LIaSKCjlX9vPMtB+5uDjyxtNMmhN5STiUoe9PzcA0J8Z55qPnz9kfD4QhWuo4zgie7WaHimNcEjfjxPU4Mi6ZaUnc7I/c3BwZj5MR0jpHcP40nNnHaCSWNm9ukccQIQaCOPrNltgZYuYhbG2tVUBjhzs7Z/v2O0zdQBhn6nEmjZmSxPpMLqF+Zn9zzfXLFxwPe9K8GJw0OlxvTU1PZBh2DMMO7zumuXJ9MzKnxJKsUV1LNZaEECzCipZlmICnTf2fX1zwxhtv8s7nPk+aJiiV3eVTdk+eMbzxBv3FBf3Zljj0dF20ckHOiPdGrHrP1sf+JFa4GWygcLc7N6e62TTWZuXq5gXbsx3Prz7kZv+CpRa23tH1HdvdBgaY+8RHL14YSKDBpF3w+BpxySPFtYHwW6n7EyGVAGLgHFNDNX9UmvOHijStA2OaaKzoVSlLIY9KnRY4VsqYSctCeoASn28I3BADmjLSxhRc6BDf4fHEBviYxPpoc5rBizHNhM6yV2/UZF3XMwxbYuyJh4mUEsuykIDYd2zOzljSxHE/Mx5HDvujzVQ2tg7ToKuUkqg541TZ9Rt679kMM+M8G3XXfuTGeeqSGbY93juKZkIX0VzwKsYO8u5931BnskHZ9uGSM06N0MCFgIpwGCdeXF3x4YvnpBw4OwuoPsN5OxeXPDPPe+ZlBhdxYaCLHZt+wAdz5orNlL357ClPnpyz2fU4LyxLoRj1uQ3dDhvEwVAGhs3As2dvnqiLtJo47dDvcC6QcuFwHDle7RnH2WQ6guew79ntBt597/UHUK/koHItzMtCFmPZtRkbQX0ACWibPXLBoqrp+sDXn9+w3b3g8vwpvlb6bkB8ME0pZwO38zIzzxM5F4ILXJw/wXvPwd+QpoU8L0ypcD0vvDhOvNgfmVJhKYXxODGNCQpE1wb5gmeumaJK5yOdC40v2gToQmckq9rBpmB9qAdyUGg1+ZDdju3nPs/w+XeJX/gSVYXu/Q/R/Jx03JMXkx0QnxDvmUart8/HIyUvQGv84uniAFHYnRsqDwnWwD5MzNmy0FKsn+edR6ria0VzItVMEJM0GM7PePu9L7CMM84HxuOBlDLD+Tn9+SXx7Jyw3bSI2DV2+ErRwpLLg/AbvvXm24bU7DdN8mHHZrM1rrcW0TsPPnqD9LvK/njDvMzsj4LmBfGYJLlzxD6gTlhSYpwrPhqk3wXfuBNveSrgdlxBGryXlUW/6e5QFc2WbSG1sWubDEKpFVImT4l6rOSjIpOic21Ev/d/P70PdH1nysol4TTYuEg0VWDB4xu5ey+VRZSlJiSZs46hEHxHDRXfqMpUIYbIZmPsEk7sMAx9z/b83IbLa8apDZd2XU+MPT6YCKUqLNPMPE42rI/ShYDGJk1SbDzCq8NVEzNFtQ23zhwaNYumwk/+ivu9n0aJZbxAqxBhzYluMoWIUBzHcWSeE7W6xt1YSGlimg5Nw2xufZ/RFLDlxoKyoed4PBBCR83K+dk5m90Zw2ZHqZVxWtgfRuracumUcdLGsJEoJVNzPnH9lVrwXlrWJtZS2O/56KOP2N8cceIYuoGazjjsZ6bp9QPNXslBzSkzzTMZJaXZ3pRWinOI7xE1ddDQG+fTNBd+4ZvP2WzOeHL+jLee7NjtLvA1IdVURqfxyDQemOcJj2NzdsG7n/sCQ99zc/WCl89f8Pz5S6bjxH6cuTpMPD+MzNkogHIC1NGFYNlSF/HesV8mlpLpWrkniMF/vSghBLrtBkdgLELXD/AAiB4wBoscA/Hykic//hM8+fGfJL73JdJxZEiKvDyS64GlMTc473DBkeaZZZpI84TmjPMBiZEgji50hKFnd/GErt+YkOGSUT9b9lQLWpXgAzEaK/za09OSCd4RY8fm4oJ+c0YYtmzfeMb1zZ5xnvDDgHQd1QeDQ9upgOZsMugYLPg4378g3LvvfpHdppUhm86N9x1gEg04xXllu9nhgrAfb/jG+7/AOE/MeSS2gfE+dgQJBlUOwpRmyqjsVgHE4HDVGUuH3nVO1tg46Xyt5J5qMHTXsifVYp9l04kqtSAlw+LIUyYfC3KsuAVclpad3X/J1PtA3w9ogVlnXA10w0AIPdL03rTS5vAcNSfmNFqkviwE3xNCT2jkzka9Y6J3sYtNEsWQgrHvjVNOrCu7jAfmecG7wGZ7RtcPhBCpNTONI9PxwDJNBO/o2ihB9JGhM9aVTRwYos3t0MZV8pI5TkeWaWG8uX8QT2jzeM67EwBlPM6ICJeHIyE4DuNEKooPBvAQhTSP7G9e4EPABpQz85RIxRQEvLdB9Bh7hmHD2e6c7XaH8zYacfVyz8uXV7x4eYWijfdwS9dtbTg8Ly0waHIxWEm06yK1BLbbDYf9kecfXfHNX3ifm5u9VVjOLgi+Y5ozy/LADip4myMqwmn6/UTl0jTCtJU2RBxLKrx8uefPfPXrqMIX3nmLzz27YAjeYLRLRRT21yPH/UyeC52rMBdiFM7ihjrMjPFoQ7tzIk8zZVpaTyDiOyOn7cTRe09oyr4hQSqVmhM1eWq1tyriCD7Qdx3edZydKduzLf1meO0395NY9Z7u6RucffnHeftX/tlcfOXHmXbnhA+fE3cXhGGLi1et1owxXjc10rTMRmlSsukO5ZnjeEAOPRtxJv/sPOocWSvujqy2NKmRnAs319fsr15wffOS8bjHe89ut+PZ02c8OX+C9j2Xn3+PcHlknCZDG2Lch7kWKJmaQWuhZJNZONxc8/KjD+/9fr75xtv0nfWeDK3nbZZkGrm5uSalGQmKeEUlM8575jxxnG+odaF3jhyiybWUStIJiYWiC1orvUZEG9KpzVqtdlvouytEuVb7XOPeuxMIrU+vCqVlVsVmnvwd9vpbOZb7z6Cc98QYKbFSQkWLa3scmp5766EZ2tY5pQvegoFqyrW5CFULkl1jHIe+De2DUfN1MeDcBtkNbDc9Qx85Xl8xHW7oeush+mACkWlZmMaReZqNEIBIbQzwMTjERcQFNsNA9LENqFZyahkLtanRPsD9bKCdEA1pWopyHCdKWeiiMeiP40wp0MUtqemTzfPBFJ67nuCjCQ8630YPTMCxFJqDSQhHrq6ueP/9j9hud0xTZp6h1nBScZgmy8xqreSSTCqpFsMTNP5JpXB1dWAcE+M4ctjPLMlo7UrjAbSv0jSjXq+9Gkii69AGlOiiTb+vuiZW3lFjLyg2YJZSZn8YOU4z1/sDN/sDh/c+x8XZhiFGOnG4CvP1geVmQqeFUD3T1Z5eHcHD4Dt6H6zslDK6JHTJuM5ZWSl6BAgqBLH5EcvkFFcLNUEOjpq7xuPnTgwAoYskhLOzrfUdHsJcYHjjbS5+7Jfx7Kd+ms3nv8A8J8r1RNzs6DY7QtfhwoRJVVdKUzJOy9KGHk3ioebEfjySXaT6jjkVi+edNORjaeS4an26qkzLyPtf/wZ/+mf/BN98/+u8fPkc74WLJ094770v8KUvfJmnz95id3HJbtgSl4VlWVjSDClBEWOREJrTyszzxIsXz/naz//cvd/OJ0/faBRHFqhUVUpZ2B+u+fo3vsb+cAW+4jsh9MLzqw84zNccxxtSmhm8J4eOaRoppTCWPdqbzk4hs9RifG+qiO2AFphZqFvFpvJF5c6ALUCTAWlSUmvGpasaclU0K664BtN2VI9lfGv0x/0fqF4CIVRCUFzIlDaMX7U2jTKhNNohtIA0+XBXDOQhoBRyKaYQO1t5ebvd0g8bY44HYvB00eDjnG3ZbQb2Q8/LD21YuYtGFp1TYpknk4hfjObHB+OqlMbu3beeV9dF4+2shZwLuYkbgqK+8BDsMSJtHrOzjFKBaVmYpgJaGPpoUkFVrVRPMv22+UCtB2K/ox92hBBPIzO0bMfeTqQWYZpGXrx4joiw210SwhZVhw9964FqIyJebhklaraxCueNFqxVHa6v94g4UkocxwXU3oN3DUCjxYAu+aFRfF1HXZIR8JdKTZmajHIEmalVWaaR4/HI4XA0lE4pTMtiyA+B4zxxvtuw6fqTk5I5IdMC88x8nHEI4/5AP0TmkrgZR6acKZiIQa2lZUZNdthJY/wWCJ7oxZgmmsyzd5YtlKLkZANm1IoToY+efjCeqYew2m3wF0/5/7P351G27e1eF/Z5fs2cczVVtWvvffbp3pZ7EaU30gQjCohgSJArDAVCJBdDHBmQEJKAIAEDhmhCQEcygOAABOEqnaRRkQRBQ5OIMZggcIF7ufftTrfbqlrdbH5d/nh+a1WdfU//nl113vfWM8bau6pWN9dvzfl7uu/z/Zrju6yLZbsdeNr37MYR4zxt1+Eq+ECKTofHaWDsd4QwknOs1CbmkC0VoyUOKoqMSrujUY4qiYotDH3P08eP+IHv+7v87b/5N3n69BHb3RpjDPPlgiePHvHsyTO+9CO+ky986TvwbYdrWlIuECIpDkzTSAg65R+nnt3qnGePHvH2G1/jza999drX07vLaXYRAykQU2SzXfHWO1/nybOHxKJZVNMZNsOKpxdPiWlQcs1imYyWhGKc2IwrJrYkmZCS6INqGqWgoo2YPQeZZjxmn+UUUYBgEWS/oSdVf95HmwoqUlJZE8EkwRVFmdIU9f9ZiX4lF24ggaoDrU4dlHVKdJoiYFVw0dS+yp7l3ahDwRqKUU7JVKgAqZGh7wlTqBD7TDFOab4yYJ0GF9bSth15viAeDZWcF5U/3+3o+x3jNFIoiHVQbyI6YmCcSkAU0cwthMAUIqFKwxtTaYDSTZT15YBqVNKAhrbpCFPPMEzElLDGkVJVdU6JFDMxVtXhHMhlqj05JTnwzgKqled9VYqIW3a7NSkF1us1XXeMczr2sWeSSJUlZM9Un3NCKCqJ0nbkUgglsV7pjJMxmqV2XUc3mylS1luosPWUPn0Qz8cs8VmMBJVYniJxnFTCeAqUIoQUGXZbNpsNq9WaaRzx1tRUsHB2vqLve9pWm52zpmXuG2ZiaHPBjCO9McQYWW3WuM4RKaz6nouhZ6QQBCKZkAJlzFpmEMEWaMRA0eatdYYZKm/uvUMEYlKQxzhMxCnQNAkr0HhL9wJ4pD6K5WZGbufssHz1nUeEZyt2MbIaegpC0+7r91ZZM4bAuNswDLsK91R4uG1amm5ONz9ivjxWYt6uqzVrPSlFFNKOaON1vTrnqz/w9/i+v/29/N2//TfZ7TbkGgW7xvPs6ROePnnCOE1Y33Lv/kssF8dVpjrQDwN9vyOFQZnp+w1njx/yxle/wjtvfJ1Hb71x7et5YI6qWUrKmTFMrLcrHj99hzff/hpD7CmijOUhD/Rhhxit449JMBlSnghpZMo9Ux51uDZDGhISdXBWpGCbKi1fKi3XPiovKM1RZeQoKWlwkSKppCuZE0jSm0ngiqFxHmkFkyBIIAwBUsF8+gHqh5pgMaaoD7COIEmz9mxprIKaFDCSNQNEcLJn7zBkI4ScSEFJSdM0MI4jrlE+PDEWK5ZcBMmZaFD0Zyl1bm1OmgZSDBr8blfaB09JYelNi/WNOijjMdbVXpfUfUd14qawp13SrI8iN0JvlkqhIBixh1bDYj6nF8hpIsZCMomUpdJz1TnJnIhp0AShjIRQlYK7Y9pmiXMt3je07YycI5vNQN+v6fsV1noWizs6nN+05JxVr6sSZlP5IXPR4NU7bedQEmEa2ayeMk4TbTtnvjjh6OgOTbvXjkvkNBLDi2Hb/3iKuhXdlWNCDMQpEMaR4p3SyKTIUDOo3XaL5MTJouMIg1TNqJgi/W6k70d6N7D1jqVzzI2lyZniHD5OTEMhjJk+BVb9wDYExlTYxMggmVihrfvIVXLBlsreTcZXx8RhHkeYQmKz2dHNN8wWRxjnKd5gJdP5G3JQznMxTDx+5yGPvvEOo7H42QzbtUjT6pCpUxJIVWtNjONQo5VasnQNi+UJx3fvs7xzl+XxCd1swZ07d2jb9uCYDiWNkhmHiWdPHvGVH/x+3nzja2zXFzon4q1eENPIapqYxlHh2W1HmCbu34+qBLrr2VRHmeJEv11z9ughj978Ot/42g9y8eQxu836+tcTdKCzFFIqDOPAZrNhvdmy63uGcdSyhqjsSEgD/dRXcbesJJMpkPJELCMZPZ+kOCRZylDIYyFNEeegWzpUvUmHorLkg1NS7SSlWCpZB8ephUFnONT6cylItpjqHJ0YJaCdUYdKEzGnG+lBAXWwW9nw94O7EOoGL4qMRLTkw549Wx0UBmzhIBZqUFBNzpGUJlJxqr+VK4uCaCYpWUuC1hhSBWX1/Y7tdkNISXtjtjnwexrj4LmqgfbA6p5QZXqU+vOymnDdVg6qD1SG+oL3FiktIi0hRsZpn7GYCtFvsHbAWKFwCWhQEMMM5y2zrmU+X3J8ckLOAegZxxW73RprDLOuoWvn3L+noIhdLwxDYJpSZf2wpKLToHdPl9y7d5fGG8Zxxzieset7dMphznzeslguFKgxai9wnEbCTYMktE5Zb0nIIRGGkWwVzRSSkmyGaSROE623PDg9xvgG5zy7fmSz29EPEyFqaXAqiSEnbE3LszUEY5hy5HzsOe93nG97hpQoxjKlzFiKDptRKFkO1DySVSI65sRR1+mMlij3VylFe2KbLU3TslwsNdKaeWxOdM2L0TP5MEvGsFqvePSNb/D3Hp3RI9x7cJ+7Dx5w58GDK9RMlhyVoT2ES5oYsR7fzFienHLvwcuc3L3P0cmpksSe3GE2m9U6tZq1lhQD/W7Ls6ePeeNrX+XsyWOkZEVBtp6CNpOHcWR1ccab3/i6ip4ZhxRVSB2niX7o1VnGntXZGW+98Q3e+vrXePTWW4R+g8nXvwFMKeiGnvRC3242nJ8/ZbVeE0LGiMe6gsFhTCaEQJyKauukkZx6ch7IMlGISgArRiUYkyHuCmGXCX3A+kIsma5kTLKIB0x1UDWDMln2XlMdkvF1Ti8jNmIkViYKzZgka7bincFJowiuQXst+QbkNkrNvO1BXoTKMGBUOh3qJmqhKDdmyUX7cJVVw5SEpVI3WUuyVq/LPWfhnhwqF2IoVWW+KO0W+SAfPww9/dADQmMtzqkKr6sACRD2SPy9zMrVm4ISKsAoTIzj9bPt51xJDBJMkx5HThHnLPPZrM4oZqJEJX8Wde05T8Q8KMgpp8qUX4hpAhLGQtM6jo7n5BJZrxtECtM0VALlxNHC88rLp+SSWa0dfT8xjglrVSQ2poiUzEsvnfLgwX2Wi4Zh2PHw0Rs8O3tCjAMpDTiX8V4pmWJQuPs4jKoF+Cnbx9qVQ9Vj8s7pZDhCmgLZGrCoxHopOGdZLGZ4Zzk9UvmAkDJNzrR5RnQNqRTVaTHgjaExlnnj8daRBbbTyNPNlqfbHRf9wBAVXaJ9KHVKe/YKQDVnUiJRmLJq0Ewh0jnDzHuc6UgpMwwTm/WG1bNzrBHmLHHAsrt+Wh6AKUfWuw0XMSmBqXH0ux3jpBfPXu/KGEOYAmGaSEnJN633WN/RzOZ0swXtbIF1OifinNN5oNnsALcWUT2kPk70uw3r1QWbzYoQJ7xzYIQYw4H6iMozt1mtePjWG9y9c1dniro5e1LUnCO73U7lKp485uLsGXEasFJob8Dpn12cs9tt2e12bDZbNus1m82K1fkzUjI0foErDVkiSCJKxuSR0Pds+oFUtmR6ikxgC9Y4rHg6KxjxeNtSbGLMkXE7MMUJPxiahcO2Ai5jK4rVicOJw4pFTIPR9IFStBlta6BXIhCzZg4V5iZFg4niXYX6KtHtdVu5UqVwzqgKrShkOx0UiwURp70do+eMXpiFnCLkooOxxjHzLQbBNF6HgMWiQhtFeTcrCpiSa99Og4hhGKpgKVinjBR7aYh9AAq5snEry432xRQ1d5XJW3swN+PwQzTEVAhTZpwi2+2Oi4tneOdoGh2Un81muAbENORcVOJIEiH2VX9Ps/WUE32/4VwMw7BlnHaolH1htb5gGAZySVg0IKISZotAGwKIw/mC8x3eN4QQyCnQtN2h+pSAVEdQcgqs1uc8fPQW5xfnDEPPNKqOl/b3Pv3B/I83BzUOWON1zsY7MoYYIsWAOMg1s+7aFnt8DDliyGzXO1arLd5pqimo2q6q4Cq/lhGhbVoKsB1HdlNgtdPB3NUwMcRUIzNRlgKj0ZzW/4WQUabqkOhDIKTEGAJH3iJdR9d4cs4M46jH6D3Wgm8sNmcWN0B7AjClyK7v2VW2YSNK0ZLqmuDsgfNwChNTmLRWvGfr7ma0sznNbIb3bYWOR0SM9vlmM2azWeVMrKKIJbPbbdlsVoxjT8kZ37TknJjCeFkSQVVNh92Ox/EdXrr/gKPjE+7cU82ofelwt91ycf6M82dP2W5WSIr6Xd+AYunDxw85vzjn/OKci/MV2+1GJd1DoMSCtx0ZR1FyHhwRVzryZBm2gSmPZDOAjdp7sYXGGtpGcL7BNnMkJnYyME09u2nEjJlZcriZ8lE6a/DOUSzaA7QOY3WeSqRoOSsGcskVaRopoSBRSWQxGUzGOM0SmrapPYjrZ9xXIluAS5FGMSryWYryYiqtkwKWDKiTqnNHlARRP5vNQmNV0YDGYrzyu2jSqf0rzF4XraIFs2Y84zhq70vkADBwVntNpcLIFYBgD1DunC0mXTqoq33YvTL3dVuIRtUexswwBrb9jmfnZ7TesVjMWCyOmc3mzMRj3Kw6KL0ud7sLQgwVzKCQ8r7fME0DzjVsNhdMk46JrFfa7885U6yyu2jmqHpYIubQ2/Ze9w5rR2JUwdeUM7t+UJaeIVblikCsahXWOkKYMGKZtUtSSmRu2EFN08SstTS+xbct2QgpTYRxIknCtg1d09J0M+zJCWncEYY1sd9g0kgrwqzxGCqhp1XtnmSUFb2kzJQTRFVFbZqWecyE4hATq7gWtWZfG53o77EI2dgDncyYCzZGZs6Ctcr5V1Bo9hQqWWdROpauZXZDJb7dFIgzrTcvF3OSa7Hes+co2Jf4rDE1a1SNFmsdvu1o5kfMj07wbaeQ35jINtG1LUdHR/jaW7ustxemcWK3035MEaliki1QcI1XSG5UOqQYgmZVKbM6P2N1/pT5cknTtbrWKbLbbNis1oRRiS+9NbTW4G9g+Pl7//b3HkpBwzASp0BOiRwzJcYKh1UtqJQnQpww2dK5OUfdKdsR+oii+iRjnMc0Hi9e2U8AycJ82VBkxhgFXKwib1JZKvYCiQ3W6aCwsV4bMKLoUREt6cWg81gpa6aRSyYwsRdcFDG0bVPHC25AbiPXwSWdwquAiTqjZVQteE/ebHJNgPasGjlW9dgd/cWKadtjvcN3SmhsndNmjNZDayevAhmK0qbtRylyUvl271W2x1RkrqJTc2VG0WtEAzQtTwIHR7QP/Ky1NE2Dy9d/zY+TwrvHqTBNmWlKtaw38uTZU0IsHB3dZXl0zGJxhzEENus1Tauaei6MFWyzb7lMpKgzkWEaCKHHiCHEve6WOubVas0bb7zJ0Adm85nKHzmHb5qq61fptkpm1+8IYeDiYsXTp894+uSMaQrKEpMCfb89OHrvOuigYEnphh1UrgOhzmoNOApIyMQUCXnEU5h3GrHPG0ceLIMNbC8cja3wUdtiituzvGgTGCWjnHIm5YItBW8s86ZlykLG4k0g1tKdDptymBdIRYk4S73wsUJMiSllpWIyhoQwpcIwTJSk0tICOO9YnBzhZ/NPfXE/iu1CZIo6vd21Lcm1ZFMnZ0qpGnfa+C1FWRrEOlzb0S2WzJYnLI6P6br5odckUMt7HcYYjW7SJYHuOE0q3jYpLFQHB3WuoUF7deM0QB6IJegoARPr1Tnnz55wcu8+3WJBLppVbzYbNusV0zAo27RVIs/rZ+KDr3zlB3VwsJagyDWYyYUS02GGLCYtlULCiqXzc6TbR+1AcpCjakvlyiphjc5ANZlu7sg0MGUSBuP2svJKp2WsUYVS3+jsidHeHiXWUmvBuAI+Ea2lGB3I1NJZIBQlOXbO4xtHLs0LqfF/mOW6aamGUKTUfocGS1lBJFVfKNfSZClZnVSOjLue7fma1ZNnjJst86MFR+YEv2hVG66obAm1p1L2GU7S7yqEiRimQ/ZjrhCsgmYXGlAlRHQoW2VSFDqdKrR8D63egw9EbgbFN06ZEAshAqhSg7WelEb6YaRtJ46PDbNuzvHxHXZDzzD09TxocWNDjAGJQYFAOR0c8TT19LvtgaTYWmXsSDmx3qyZRkX33b1/j5ce3Fd289bTtl5L/JRKr1QYxolHj57yzttvs1qtVOhRIGchhlBLqQ5nWx0zwPAiqCI/nh7UrKXxgkVnYBI642EqY0PIhV60ZOZQnfpmuWRxd+IYVeBsXUueMlM/6W2KWrO3RvH8xZA95Emnbp01NFbovWVKiTEkhqjCeqkUiHUKH2WSthicKKLIWQHriAh91Ai170cdJs6FYrdEYzkaA4ujmxEs3MXMmPJB4K3AoRyRUqKIIdesMeUKUXUO387oFkcsj084OjllsTii62YYEZqm0TKrsYzjUNGXCic1RghR6VHeVZoxtiKiLMYGfc9Q8DYRjUJI+92W8/NnnK7OcE1DLrC6uGB1cc52vVaplBSV+RqFF1+3bberClLQizenXLOnRA6VRVwpXhGKsq4bcM2Mznmc88zaOf24JcUBZwqtEzwOUiSi9F7GJlwjeAwGi7GlZlCKeDPW4pqGpp3hfIcYT8qxyrnnKkEjuMbRLTpiFmKJlKEyMKRImDQfaVplHmhn11+GLtU55RIrckxLn8VCkUQmKrq0ZOUmzNqXpGRKnNis1zx79Jinbz1k3Gy5++Auvmlwy5am+MP8TUlRWSaorA8xMo0D0zgesv8CVTYn1wHsfCjv7R1YLIlhGJRhpcqa79kO8pWMan99XbcNoZASiHju3LnPK6/0ON8QwkDjHLPZHO+7CvpQzbAQIiKWppnTtuEwrqBBp4oc7me4NQOV2qNS9GRIuToxYS4LTu+e8CN/1Hdw//49lkcLvGugGMIYGMeJQmaaJjabDc+ePYYSSXEEUSYMIwZrfYW1z2maGSKO+AKYOT7moK7HWgH0AiqissANlhR1oGza7tjkTAqB+czTzhrcfEkXc5XDtoqQikIcYaLQWUfjPMYIHqVEEVujJVGHs7OWMSUGH/HREHIiJuWyijESkl4kzlUaEQRvlPcqkxljgJQJKVV6FkPIQj8l8qZnuAHaE4ChQEiFFLOqBysmV8smMWENGg25Bte0tGSwcHR8h+PTu5yevsTJ6T2Olkd0bYcVwXnHyckJbS3D5QpnNUb7dQdq7eqcdAhHpbq7boZvImY/QJkSsfIuDkPPxcU5F2fPdGgzF87PnrG6OGe33TBNE8RErG0UFQi85vXc7RRmjn7unFVWvSSdRdoz9FhRWRGrpC4HmHRxHaYILhktLZeASYk8ZqY8UewlO4f14Pb8XuYSuSbWHAT7nG9omk6HSSOkYki1lIcUzbhaC9FTpkIJSbOQnEhRX886ByL4G+jp7Vkjck61RKZZlA7BTqQSqkR91gxGykFOJKXA2PdsVxs25yvNoOYz4jiRK2+jyopMOvSfymHmJ0yBcdwPggdiHW5OKWPTHuyQlMsy6t8r8xI5Z8aRqsR9yRQPl+W+w0zgNVuMqsTcNC337j/AWMtsvmQYtodevLMNyjRSZ+diBAzed7RtOIybpBQ0qy35cgBQCqXouU257LelnCgo+etyOePll1/iwcsvcXSkTOUpqnrE0OsA9DiOLBYdzgulREIY6/nqcK7BG+1dtW11qPU1Pm37eEVYMWQxxDoEKUZoG49D8MkzpMAQAuvxgovzc47vHHHvwV0ihmQcw64nDrqJETIhR4oRXNvStTO8FVKJmBGVfEC/TAN4axlzok2JLnpiKSSUSy7UIbGUEs5qJqA8aYI1BSma4VEyjXd4p1xzR4sli6MlMUUuzi8+9cX9KBbR7OZS6h4KpsplJ8RbrG/pFksWJ6fMyjGu9dy5e4/Te/e5d+8l7t19iZOjY+azTj+3MywWC7p5JUvdOyb9EvFOgS7eeUSsslBgcE3LYnmECMzmc1bWkmMkpImYI1MYWa/POXv2mIwOX1+cn7NenbHbbQkhIFll/JTL6/rXc9xuyTUD3Zc+TAWHKemI1HOjKMltKQf4fkqRFCMlRlwoEIUYkg7suoz4gukMpqkgHyc4hJIKyeS6xKIEqnUNjNGms1hDyrom2WQisTJXaEYiDmxjKVMtR6Za7qslSeNcLaVcr+0znP2GGJOWR0tWIIPLLblE7SHVdc5WUXglRw0KknIMSh1KJmdK1CwpBJ2lzCFqxlPnlMKkzAla4gvqpPaCpZUnMUuuoKBEilpaFimHOacYgqIlK0Gr9/5diL6r4xfXtp55Umi8b3jJv8xyecTR8Snr9YrNek2YBiAquwORUjRTEoyCoGbKhKHjJqOWPyuqV02rJDmrPJKIPt5IpZLyoiCXyiwTgpa5Y0i6h9ZeVIx1qLx+5yGMlJIVWGF07sz7Du9nWOcRMTcv+Z7FoHuo1pi9sbTGKsOEM5SgsuFhGNmNAwh0sxkhFyiGaUzsNjskZXxR4kgRpXZpWo83KndNVhXOZBPR6ZCtc5kuZ2ZZ4bZ6nhc9yWtDMKV0gGWrUm0hJ22Sl1x0QNJr0/loPmOxmLNYzNlud0zD9TNvg/beJCVM1bbJdZOjQIoqBV0oGGdpuxlFoOk6uvmSttPoZS8GdxiQFCGEibLLTMNQ2bT3YyfCZrWi3/U6WKd8PbWksAdm2MPs1aGvZ0SpfzYbnj55zDiOpJTZrDdsVueM01AlEhSwYmql4bptGgZFlu2dk5Erpbfa+wHdJKt+WU6BFHSzTPVcUX7HQo6ZEBIxRHIoOJQXsqmvY6CKEBZIaBa850x0yp5tTECK8hSm2q+JWXs6pkQdYJWic6Z7Rd7ab0xJgT22FIy//gXNtcexd1I5R3KeSFmF8lyaSFlnuZwAlcMtJd1irTW0TctyMac1hvlspgjHomWkaRgI00iKQbPcAikq48tUNbCmaWIcx0MZb6/+nFKqa1TZLTQMIdTvMobxMPYCzcEhHRCtN4DiMyYd1J2bRo9J8YuWFLWEGevaiex7f6k+1+F9q4F2M+B9wzC8u9Mrdf9Q4VEdonZW4fiz+ZymaUgxc3G+hmLYdDs953IdIi6mqkwMlZZqqKMn8dC/K4VaIVDmDiVCVqf4advHclCpWMYQDqWnGYamLRirYw8WHcRzYpEM027i4tkK11TUTlEnRtRoUzA4o9Gs1Bq2KdCKJYplKIIToXUWh0pNay9GZ672tdgYrdbAUb5A75t6vIpGSzlWB6VZlXeeWefpvKLNJqvHfRMmUpAccSliBYoVJiOYHMnTyBQDQ98zjYOyDQvEENhutlrK6HtW58+YtR1to0q2xhicdyoJUU/W/exEKTD1PRdnz1idnRHqvJWtei8XFxcKrIiRzWZN32+VFiVFhbiPmSePHrI6P9f5iHGk325IcUQolelcCEUo5fo3gGkcDk7aGnVKihYtCIoYyylRQiRPE6lG52ncCwJqKbSpGlfFKhN+iso9mcaCmEKmYIyWm0rlM9MLNJOMbpx9HChB8GPEtp5EzUZD1Ow4ZSSVCgwCkwuSazkyAgjFZGLRhri5AY+vhLbpwLywBySknDEUglFG/eS09Cw1gk81nfJtw/LOMR5DDoHlyYLZcq4Ch/2OceyJ03go98VUFHRVqyIhRIZhYNfvdAbT+7oHXCJ6c53H0p5SrghUDVr3QKNYmfyNMYcA1t5ABuW8rZleJsbEFCZSzVz2HPil9lDF5IOTuiS6dhijDmfv6JxTcEiBCiDRzN07rwKR7YxZN6ObzZm1M4Zd4M1vPOTp4xXetTjvDsrT3jcUCkO/Y7Pe0O92pEphtEeVWrtnCVHnmEs53D719fo4D04IQ8hMU8AbrdnnlDGmosRi1IHDAh4DITFuBnKnpI45JEw2qmRrlcXYGqMOioQUgylFS4bG6gBvLcsUY7VHkNVBpZSIIiQD2VXmaKusx02zP4kTIborcz3aazhE0zkSxx5ioL2BkxU0wldIbYQ4UcJIyZmpL2yNfunb3Zbtdku/3WnpyDnsZqWZp3d4pwPO3jmMmKoZpXxoexmEAwIDlRMf+x2rizP6req6SM02xxR0jWNkmkaltspJL6IY6jCfslikfWQdtSkOSlKbUag/NxChkpUjT8UbwVIwJVcgTW0sTxNpUqeU9sPPIWiZyAjifdV8anDGkK1TPrmclJ08ouerZCSpIqopWdOpqt2USmZ0yt3nuoDrPMUWsqSa0XMgAC8RldqICan/k1AWgZI1MCm6+V/7ctbezx5sklOuhLd7oIcGrPkwsMvhey8ItvF0xwsa75CUaVqHbSxjGhmngWkciGGCWtI89JRDVAcVA+OkAn1+r+xbNCjIUuewKn3E5TBuOvSnrg7nXgVJGGO4FDS5PhPjlLc0JqYpMI0T6QobhLFCiXXvmqYKaIqH9dVD3jsKpShytkpoiJbyxJjK9ecPbBu+UTYfiqHfTTx+dIZ3G5xrVFl3tmC+yMw6/Q7HMTL2CppI+xkzI4fsU0vZisDcr/OLWM2PtSuXAiHqBDTOHCDfe9SH8jFNECONsYhxmALjtiekRAqJ1joWTcvMN3rh5Ygzla+solGMKMChc55iErF6aysKxog14vDq4RBjDizKTaNILFUoNURn9eSs3r2g5Z+UIqGfGDdbCobZDTkoXxnXpxQZthsdxnWOvLWszg1TCGx2O4bdjnEYaoPeHKCkxhhlcK69FRF7uE+MqfM01FKeplClZErS2Ymh33FycgrlBIvS/4dav3fGMJ93hLBTBFfSEk+YdIg314xkj6DUMqFOrBcpqrB87eupGk2alesAbAp6nqUc1BGNqtKcpqASLlFpskxBpRC8EsAaU5VZxeKxSNZgwAIy6rweMSJ1IL2IwB7dJkKWRLATphtwM6/9RKcbgEGQbLUsGCJxKDAmZEqYmDFRDowUZc/gfwNksSnEAxpSCW6rk4qRXDLWRAX5VBSqNqI0UClikMZjFwXXWkjKAzMV7WeOowpuphTVWdeh1BT0Gtc9pe4rIWCrKKGIVNSgRvCXwIc980U5bJp6B5fXg8glUvYGQBIpO6a6h01VMielCZGEb4QmCNNUmKbAapXZbHZMIVQKJzmAQ0CwxuFdQ2qaw6DyPoPSLMqQcyEE1XKKMeN9IkQIodA0LY3PUCwiEWcT1mgfn+zIWWnN9utkamama7gPVCKgw9xGbnoOKicoOmjonTtoCqW4z560bOHQ+Q1xOkHfp5EQIg6h9Q3zpmXWNOQoxFiqREE+fAlGqJPOjvaKeJso8yMpRVydBFf2Ys1ErLH4KgRWilGl0pIrPLscED4hRcak6rEpZJxvmLU3owflvKeIwYDKOseJwRimUogoXdPe8acaqWauSIvXTeyyRSqHTWIfcwuwrwHsh/EEJTDNOdE2nn67hlmhabyi24wgRcg1w0t1gr3k/YV/iW09kJhKqcNt2ksx9gZq/KBlsjroWZJStKQc9DOEvZPS+S5SRnKuh67il6ZIvUGu0Hxna1QqgqRCGSN5ikiMWqpDWUCyUVSPiNFsSVA6sHHCNg4ah9sHGKWCIUIhD4k8qIOyoUDSgCPXjCRlbmRQdxoncqn8b3kvqb5vooMhVJ0ldVLAZb9TVHZDGoc4naBXHbPIVGecNCOPSCVRTSkdSnvTNNH3Vffp4Gy0XJ1izWDrRmzM1c2xBmPCgYPPXHFOKen3kvP1O6hp2pf2FH0YYz70bnSOTskGxiEwDn0laQ1Qr/N9qVVLfpWPMDU1YyzVgVw6KahURSGQi5BzJatNpc5HVnYe9srPWZ1eTuTaa9IB6ndfyxrka28K0bK4sZ9+kP/xSnxhwltoZg3LuYoOiqBIhNfYtQAAimpJREFUnQLOWIzfT5kb5YqrEuzOKm+eN5bWW3xlfJD9Diq5skJUgTcRrLO4DJSsgmchKzNAiApvbzzOqx7PfpjVW4u15nAih5RJcumgklEnG0U0Q2h0pmg+uxkHZZ2jiCWiX/oYA9uYGbKS7yYKYhRh13ZGqfJjYK/jsufXu0Qk7DeJqh9U6ievmRN5X9Oum3jO9P2GJ08ecnISuXNyh6bp8Nay63cHqG+MqrYplEMJR/ZOqvYbxMjlzRmMv/6sVGqpOQfVH4phIoWJkjUDJO3JjlUTTA6lz73zLpoN1vXbMyM4I9rMzkX7V2OkTBFJBZMVEVhQfL0Yo1ISFBCdwSohUlzSm9Hsgj2Yo97PkCghkaOyVSSjwVrBkEjcxKRe3/d1tqbUgEOvq5gi05SQskfb1b6aytxpSVL0XCgGhdaj4JCQVMBw3xcqKWEw5Ayh/k1h5pNG/rWkbCqKUcuL+eB8rgIerv6/d0x73j4RudREuyEH1fejkgvkTEyGlC0lW1Kx1LouglZOtpt1zR7TpXxJVnHAUvZzjYoITHEPYrAHp83e6VAzxpRIBML+uq0Q/H2GHtPINCryV4FambYqKlCDYt0zilIwxUguEWMr24379PlMP94clBWayh4861qlwo+qsmlqelnqSVQOU98qCmhEG5PeGFoxuCJ7KScS9QsrGqWRRC9e2W+qWoIpRWcdjK21UFun96tuihg5bNjG2JrzJwyJXEtSJYOVrFRBCBZL4zzNDYEkslHofhHlOFP2AaEBbMlglTPLOZ0Jm6YJ2akWVC66GVq5rAuLVD63nA40MqXW38t+cy6JUhTWm2r5c9cPGKvKmU2jQPG+37DerBnHUTepWirZb9t7N3WZtNXSorUHXZ7rtnGzJU0TOUzEaSLHQElRz4Pah5RyqWa7t71OVslVCyEmijXsJXAtyhGnvHmREjLE6piSvqZKbtSsVZRtX2rGSwCxgN0DScwB5k6uw+6hKDgiK3BCihzG1hKig+nXbH3fq2SGFZyoeus+WwkhQhrofU/nB7pmrr0/2dMjyWEQXEymJJhipB96dtsN/XZHmiatyhgLRdSBhUveuBATSME55aNUtKRm8Vch489z7D2P2CtFEb8KcpPnMq7rsykEPY9qNqoXj6vsHIKxEcQRY2bX6+hGrvtUEVvRdLHOeCUNyp3uZCln7MFB1Y67wN5R7RWH961hpYnSGSdBSYxTmgjRY8SQS3oXKe8+ON0Hobb2/JfLY2aL5UEQ8dO0j7WDzNp9U15r8bnAmBMlVw0W9gBHhU/XiUMai+LnRQESvmgZRjJ1sE8brkOMTHVgVYrgnGZTuTJrG4HitCdgpaJIjBx6UGL29W91jjoxrs1aqZuHyvBoaizGkovBW8MNVKMACBiSGLJxiNOBZVxDZx0Yi22UL8tWqqPtZksy50jQkp+xytx8CZ2tDfwUIe8b8vnAdbgv65UcODBSZ+07bXY7ZfawHiiM48A4bglhqA3YelGXWnLdn+lSLhvP5rJ5a19Ayv9htj2/UHG8MFGiroFQqox6LeNVETgdlii1IFQOgJCSIiVZStRypakzPqUIKSTSFCElzZxq78RUB2dQjyLKdkotC9Teqmo6Kdl3JVlFe66iyZaer0k3Wn17fd2E3EjPZDf0lT3cIdYcwEiqUxUZ8sDO7uh8z7ILZCPqjGpJWaqWFNYikyJFN5stm4s1u826zvioGKoYPV9izkypVhBSUq7IplHJmaxgF9A1tth67gkx5sNA+p4wdm97miNKwRzABdcflIakaONckXqg5Le5OEQ8ZspgGlKGYRyIcVIeR91U6zWrxMFK5CtY04JkPR/FIGJrP/rSCYtQZ/KqEkXdH8veSdU2i7JuaPZVcsRa1aTaZ1FX19Y7x2w+5+TOKYvlMe4FEG7LTUxT39qt3dqt3dqtfZjdTJ57a7d2a7d2a7f2IXbroG7t1m7t1m7tM2m3DurWbu3Wbu3WPpN266Bu7dZu7dZu7TNptw7q1m7t1m7t1j6TdmMOSkR+mYj8uW/i+d8tIn/l0zymW/toJiJFRL7zpo/js2Ii8odF5Lff9HF8K5iIfFVEfvZNH8etfXS7yev9Qx1UPaF6EdmIyEMR+UMisvxm37iU8u+UUn7ON/s63672zaz77Sbw4faizusfDna7dp++3V7v720fNYP6+aWUJfBfA34y8Jtf3CGBiNwMc+tnz17Iut+u78Gu9bz+NrMbXbtv03P49np/zj5Wia+U8ibwZ4Ef+1EeLyK/UUR+QETWIvK9IvJPX7nvXSW6mkb+ahH5fuD7r/zt14jID4rIExH534m8N2WuiPzvReQbIrISkb8mIj/9yn2/VUT+pIj8kXosf0tEftKV+18TkT8tIo9F5Csi8ms+zrq8aPs46y4ifxT4AvAf1GjsXxSRL9W1/O+LyNeB/0REfoaIvPHccw+RmIhYEflNV76/vyYin3+P9/tH6rr/zE/lw96AfYLz+h8Ukf+yrsufALrn7v8fiMjfE5FnIvLvi8hrV+77OSLyd0XkQkR+r4j8RRH5lZ/qB7pG+7hrV+0nish/VdfgT4jIYf0+ZO3etUeI2r8hIo/qa/1XIvJj62NbEfmdIvL1mpH8PhG5GcLNj2m31/ulfSwHVQ/45wH/3/r7bxSR//ADnvIDwE8HToDfBnyPiLz6AY//LuCnAj/6yt/+aeAnoVHFLwD++fd57n8B/ETgLvDvAn/q6okP/FPAHwfuAP8+8LvrZzDAfwD8deB14B8Hfq2I/NwPOM5rtY+z7qWUfw74OjUaK6X8jit3/2PAPwB8lM/2PwN+aX3fY3Tdd88d188F/hjwi0op/+nH+lCfIfs46ysiDfB/Af4oeq79KeAXXbn/ZwH/GvDPAq8CX0PPO0TkPvDvAf8ScA/4u8A//CI+03XZJ9gTQNfmnwS+DPx44Lvrc9937a7Yd3G5R/wc4B8F/j70uv7FwNP6uP9t/ftPBL4Tvbb/5U/wEa/dbq/3K7YnWHy/G/BVYAOcoyfM7wVmH/a893mt/x/wC+rP3w38lSv3FeBnPff4AvyTV37/VcBfeK/nv8d7nQE/of78W4E/f+W+Hw309eefCnz9uef+S8Af+iSf8dO6fTPrXp/7s6/8/qW6lj/iyt9+BvDG+z0P3Tx/wfu8fqlr9DXgx93kOl33+qIb4ltUmrD6t/8X8Nvrz38Q+B1X7lsCoX4Hvxz4z67cJ8A3gF950+txzefmf/fK778D+H0ftnZXzrufdeX+nwV8H/BfB8xz67oFvuPK334a8JWbXrsXuKbfltf7R61Nflcp5c9/xMceTER+OeqZv1T/tATuf8BTvvEhf/sa8Np7PAYR+Z8Dv7LeX9Ao4Op7vXPl5x3QidZmvwi8JiLnV+63wF/+gOO8LvtE6/4B9l7r+372eTQDfj/7tcAfKaX8jW/qiG7WPsn6vga8WeqVW+1rz93/X+5/KaVsROQpGsG/xpXvoJRSni+7fAvZN3NuPn8t7q/pD1q7r9Y/X12//0REfjfwe4AviMj/Gfh1aMl1Dvw1uVR1FvS6/izb7fX+nL0wmLmIfBH4/cD/CLhXSrkD/E34QN3q92KuvVoH/QIavT7/Xj8d+A1oaeC0vtfFh7zX3r6BRlZ3rtyOSik/7yM897Nq78cAfPXvW/QiBrQGDbx05f5vAN/xAe/xzwDfJSK/9hMe47eqvQ28Lld2PvS83NtbaNADgIgs0HLem/W5n7tyn1z9/dY+cO329q5zu5Tyfyil/EPAj0FLer8eeAL0wI+5ck2fFAUgfDvat+31/iLnoBboAj0GEJFfwcdrpO7t14vIaa3L/k+AP/EejzkCYn0vJyL/MppBfRT7fwMrEfkNIjKrzcIfKyI/+RMc62fFHgI/4kMe831oFvnfEhGPIoau8uX/AeB/JSI/sjajf7yI3Lty/1tov+7XiMiv+jQP/jNu/xl6rv0aEXEi8guBn3Ll/n8X+BUi8hNFpAX+VeA/L6V8FfgzwI8Tke+q2fuvBl653sP/TNsHrd0PMRH5ySLyU+v5uwUGIBXVff/9wL8hIg/qY1//LPWVP2X7tr3evykHVVEff/a97iulfC/wu9AL+iHw44D/5yd4m/8r8NfQ/tWfQevUz9v/HUW9fB9abhn4iOltKSUBPx9tpn4Fjb7+AArs+EzaB617tX8N+M0ici4iv+69HlBKuUB7en8AjVC3wNVy078O/EngzwErdN1nz73G19GT9jfItzAS7Xn7kPN6An4h2gM9Qxvz/6cr9/8F4LcAfxrNmL4D+CX1vidoJPo70Gb+jwb+P8D4gj7KtdtHODff1z5o7d7HjlFHdIZe90+B31nv+w3A3wP+qoisgD8P/KhPclw3bT+cr/fPtB6UiBTgR5ZS/t5NH8ut3dqnbRVB+gbwy8q3MAry1m7tRdktF9+t3do1moj8XBG5U0tYvwntk/7VGz6sW7u1z6TdOqhbu7XrtZ+GoqWeoKXl7yql9Dd7SLd2a59N+0yX+G7t1m7t1m7th6/dZlC3dmu3dmu39pm0m5Tb+E0i8ge+ief/VhH5nk/zmG7tg00uOb6+ZcknX4SJyP/j2wnF+KJMbmVavuXspq/5jyK3sblyy3JJCb8RkV/2Sd+4lPKvllJuL+r3sG9mzW83gY9mL+q8/na323V7MXZ7zb+3fahXvDp9LSJfRXnDPk06jh9iIuJKKfFFvsdn2V7kmv9wX9u93cR5/e1gn4V1+3Y8h2+v+fe2F1rikw+XwPie+vN70cPv//YviMhbIvK2KN/e+73XnxKRd0Rp9/+SiPyYK/f9YRH5PSLyZ0Sp5P9zEfmOK/f//SLyH4tS/P9dEflnX9CSvFATkb9Uf/zrNfL6xVJp9kWZMt4B/pC8hxrx1ShMlFHjd4nI1+p6/hV5D6kCEflFopT9n4Qh5FvWROSfEJG/U9fmd3OFUktEjIj85rp2j0QlXk6u3P/L631PReS3yLex2Nz72M8Wke8XkbN6TQp88Lq9z/7Qicj31HU8F5H/QkRero8/EZE/WPeMN0Xkt4tS+3zb2bf7Nf/NMkn8XhH5vR/wkA+TwHje3ose/mcCPxKl1v+NH3Ax/9n6uAco4eS/89z9vxSV/DhFJ8z/1/UzLID/uB7fg/q433vVwX2W7IPWvJTyj9Yff0JR6v09LdQr6HfwReBf+Ahv8zuBfwiVgrgL/ItAfu44fgUqafCzSyl/82N/kM+wfdAai0pm/GmUKuY+Chn/b1x5yHfX289E6WeWXEq7/GiUpfqXoXISJygR6reFfYT9AOC/jYrx/QSUO3N/rX8377NuV+zq/vDfQ9fv8yhf3/8Q5d8D+LdROqrvBP5BdO/4lm0n/LC+5j8O9TnP0bp/3Bs/VALje8r708Pv//b3X/nb7wD+4PPPf4/3uVOfe1J//8PAH7hy/88D/k79+RcDf/m55/+bwP/yk37OT/P2cde8fu7vvPL7zwAmoLvyt+/mOamS/fPQoKXff0/PPWb/nfw64HuBz930+lz3GqOSGX/1yu+CskH8yvr7XwB+1ZX7fxQqGeFQPaI/duW+ef1uPvE19a2yblfOsX/kyu9/EviNH2Hd3mt/+OdRmZMf/9x7vIxSR82u/O2XAv/pTa/XC17Xb8tr/oUiM+TDJTCet48it/Hj3uN9LJoR/TMoQ+/e899HWc3hh1L872u+XwR+qrxbbsOhgnTfLva4lDJ8xMfeR+UKPoh6/9cD/0op5VtVKuKbsfeSzPjGc/dfld/4Gno+vfwez92Jykn8cLL3uw4/aN32dnWd/yiaPf1xEbkDfA/wv0CvZw+8LZeE84aPJz3x7WDfFtf8C3NQcimB8Y8Df6uUkkXkjE8mt/F36s/vKbcB/HdQtd2fjUYfJ2i29lHlNv5iKeWf+AiP/Va159f1eer9q4zaT1Cy3e9AVYbfy34O8H8TkXdKKX/60zzQbwF7mysSMLWHclUS5l2SEeg5G1HC5Le5Qlhaa/xXGaN/ONsHrdtekuRwHpdSAlqy/20i8iXgP0JF9/4jNIO6X75FgQGfkn1bXPMvEiTxzUhgXLXfIiLz2hP6Fby/3MaIshnPUZr+j2r/IfD3icg/JyK+3n6yiPwDn+BYPwv2Uaj3/zrwY0RlDTq0XApAUamCfwv410XkNVH5kZ8myh23t7+FSnb/HhH5pz7dw//M259B1+4Xis6G/BreLZnxx4D/qYh8WUSW6Ln4J+pm+e8BP19E/mFR6fjfxkcLon442Aet2w8xEfmZIvLjavVkhZYDUynlbZSR+3eJyHEFX3yHiPxj1/VBbsC+ba/5bxYk8ftE5Pe9z92fWALjOfuLKKjhLwC/s5Ty597jMX+kvsebaJ30I5NvllLWaHTwS9Ao7h20Edh+0PNuyj5kzUFPvH+7IpveE41YSvk+4F9BJQi+H/grzz3k1wF/AwW5PEPXwzz3Gn8dbXj/fhH5b36Cj/KZtQ9a43IpmfG/QQOiH8m7ZWT+LbT89JdQ+ZYB+B/X5/6t+vMfR7OpNfCIbxO5jY9wbn6Qve+6vY+9gjr8FfC30X1iP7j/y4EG3QvO6uNe/YTHdeP2w/ma/8xy8dW0/SuA/2Geqt/at6nVTOEclZT5yg0fzq3d2mfObrn4bu3WrtFE5OfXkvUChfb+DbRvemu3dmvP2a2DurVbu177BWgp+S20PPhLyme1jHFrt3bD9pkt8d3ard3ard3aD2+7zaBu7dZu7dZu7TNpH2sO6pf/1n+z7GffriZeIsKVoTgQQQAjghUwAiKXT5CKrC2lgIBUyP7hJeTKowSgIIClYDBYjN4vQhJIFHJ9PSlgKFgyVjJWEo0T2sbSdS2zbo6xjphg2488u1ixGyMhFf6Pv/lXXzvkd705K48fPmK72bJYLlkeLVkcHWGtIYaJ86dPefsbb7G5uCDnzINXX+HzX/4ybdch1iAi+rkBKVD2IYdQvwc5/EqBQrnyy5XvAf0eC6JfhOhDqK99+SIgubB6esYP/p3v582vfZ1nz55xdHrCT/hpP4XXv/h5vG8wxkApONtd65r+wp/+naU7usP8zj3uvfQKRyfHzLsGITH1W4Z+w26zYZgiIReSOLJ4UshMQ+Txk2c8eviYs7ML1tsdhUK5si5GLEYMYgRjDM45rLU46ygUUk7kkoFMyYWcCiUnrBQWi4bjo5auMzQGpnEiTBErgrEGZy0YIadECIGhHwljJE6Zbjbj6OiIv/w3vnat6/na5+6Wo6MlXddQSqbrWk7vnOKMYxonNusdq9WKcRzIOZPqsceYiDGRc6EUSCnpeSqGtm05PT1lPp8zTiPTNDGFSMqZmDMpRlIMlJwxInStZzFrmXUdXdNgxGDq9S/GULKQU2GaJsYxEKZATJFEJpMpUkg5k5MeX4xJ968irMfpWtfzL3/PTyvWtVAcu20ijglJBeoOJwUomRyFEA1TyIwhQnuCtHfJ/h7Zn2KbO7Tzexzd+xzLe68ehp6stZQCMQX6cWS17tmOEzFByZCL6B5QhJDy5S0myBPkkRwnLIUvvfYyX3r9Zb7w+ivcOTnGiCGX/bFe2tUq3NFx86mu56czqFsKhb2DEfVedeMsQJZ3p2qlLmehQC6XjqlceQ2q49tvnpT6PllpIkRfMQNFcqXGEN13iwFTEArOQOcNR/OGxbxjPp8Dlk0/MvQZyXp7N+vU9VlOmakf6TcbnBjaxlMWcxKJzWbN2dOnPHv4DpuLC0QM89mMYbtFBFzTIM6CCHkKlJh043RGnZdVRw5w8EtXrJRMzunSERmLWLf3W+wDg1zKISKR+iWJM7Stp+saWu+wQAoTYZrwzh/823WbbxoW8xknRwtOli3LzuNsgRwRkxAD0licFKZUSMUQgCFkchxJ00BJAe8My8UMMQJGL3oMOCdYI+9yUMboOueciRFCKEwBMII3hhwLkDBkyIk0JUbJjP1IDhk3a3BSSGEil4wxgjOFWePwCEESs9Yyn12/JE8IgWEYKCXXz2wZpwkciFjm8zlt22KM4L1nHCe22y3n5+esVuvqrDKwp84ppJSYpglrLSkpQNcaDbastSQjTCWT2MdZAmJIpTDFhDMFayzOWox1YARjoYhBjMf5BALOW7BCypEpTGw3W/p+pHqB+r1drxljsNYixjIHgoc8RuJUSLGQs16XuoVmmrbgW9hi2ZWW7dgQJk+bhLYEnsZz8tMaoO/XkUIuiSlEtsPIOEVSFnLdH3Mu5FyIKROzOu+YMjlHyAEribkT7t+ZmGIil0KhkEuu36Ecgt8X3SL6FM/4H+pZr/71vT5Gee5/0HPnio+iIOrc6iJBIR/c3X7RUv1VDimEAZwRWm+ZtZ7lvGW5aOm6RrOnXaKkSMkJnVO7mXnJUiCGibEfaJxn6lrCOJJS4PzJY56+8w7PHr5Dv9nim4bt8TGr83NiSjSzlmY2w3rH2PdM2x3OO5quxXct1hoK5TJj3W8SNZpIKTKNIzklSi40XUdjrJ54V1Yk50yOSZ0ZBe8dUBArWAMmR9I4sFtd0G/u0DYtUjOo67a261jMZixnDXMnNGWCkMhxwkw9No14EkjGGIilYChMJZDjRE4TpUQaL/i2xViHsRZjLdYarCsYo0HVfuMU0S8yZUOKwtBnSkoIghVDLBrhS8rkEIm5ICRSiJSUsdJgRTTqTxGsxRiDtxbXGrw1tJ2nba6fkNsYUx1KwBitiuy2O3KTcdbjnWc2m9F1LU3TMAwjzjmmKbDb9cSYavVEdwGttkCMgXG8DESds4dKTEiWkjVi1P+FIkJMhZwD2da1MBbrHGCgCK6p9RVr8Y1nVgOMYehZbVaAIdVYNOd8I1d8Rg/XON18RSAUDQI1ViwULQNhTMFYEAvr0XIxOc4nx1gM8wxdmlg9O2M1bUhF18iKYKRQSKSUGGMkxELJQilaCdhnujkX0uGWSTlTSmbmCndmlvP1jvVGb13b4L3HGEHEIPtM7AXbN+2g3lXa+yF36u3qB/nwjyRXbvq7nqK1zFL/30djpQRKmWqGYDDisQLOQOsdi7nneNGymLd47wkhsOsn1ust292upvvv7Vyvw8SAiG7m0ziwW68wAv12zTe+8hUev/km6ydnlJwwywWbizPefuMNuvmMbj7jzoP7zBcLzh4/4eLxU+bzOcendzi5e0rbtmQph8w050KKsfonYRwGLi4umIaRFBN3Tu9y936HwWgkX7PhaQzsdlvGcSSXzPJ4yTSO7Potm/UFm4szjAiPvj6j8Y6um9PVzcZfc9C/XB4x71p8KUyrMyKZnAIlBlKcSCGQcyQXgxiHtR4xDTYFyBNCwFnNFqyzGOfwvmGxXDKbdeQykUtEKMSUGIeJXBLGWFoxiHicEUpKlFzPqlQIMRGnxFgiTWvwzuCsw1hw1mOMwZgEsTAOCWMSXdPQOIdtWoy1pJiudzGBk5OTQ6YdQiDFHdMYaJuGWTNjNtNbzondbsc4jux2O1KKOKcZ5t7UETm89+ScmaZJzxHv6ZoG3zSICDEGhIwRCFNExFCQWjLM0Ai+aTRo8A2CIGI5Ojrh+PiE09O7HJ+ccHxyTEqBdx495K233wJxiPU0ux1TmIghXPt6jv2EGKFIIsVMSplsCtZrsFeSISW9Zo3RQDHmzHYyPF5bzoZCILJMA90YeHRReHgBRSzFCI6CkQRo5pNyIeZCrg7KGN07U8qaSZVLBxWz5mFHswZHy+MnZyw9kBPDMHD//h2WiznO+tpPuPxcH+gHvgn7BNvHPuq58pcPOLj3ypLe/XLP1TP371Aue1UGyNU5qaPSv5AzKY3kuENKwYrF+RmNN8zbRp3TsmM5b2lbB6XQjxPrTc+mH+jHoF/eexzHtVktr8UQ6bc71ucXzJ89Y9iuefLGG6weP2bYaEmvlKQR5hRouo5uOa9RLexWKy6ePiWHQNM0LI+ONIMphX1+GEOk321JKWGNYRxHtqs1Yz8QQ6JrZ5SUEZMPZVtyJowT/XZHv+tJKWEQpqHn4uwZq7NnjJsVphQu3nqLWddxdHpKLhnfdHTXzMdhjCXHRNjtmEKPSREjGXK84qASRSzGNRTfUmyCMFLyiJGE92ARrDc4b2lbz/HRjPl8zjAKKVkQsCGQQiLEDLlQRB2bd4b5rKEk7UNJMpDMlb6swRnL/ptJSSsBORtKMcQYtaRWImSh9YaU1cFdt4kYcta+TQixZtsjg3OMzcQ4jozjiLXm0N+ZpolpmvaVfq6W7K01GGPqJqmfx3tP1zbMZjNEhGEUxnFgqkGORv16PEWEUh1WQRBjaZqW2WzOg5de5qUHL/PgpZc5vXuX5fER0zTgfAvG4nzL8ckdttsN52dnPHn65NrXM+VCzomUYZoSKe5L5waRpKUzo1UPYzW4lwR9yjzbBJ7uRiK1bNkYHj8NvPU0INZpH5OMlAQl1g6c1L6TATEYo1l4zrn2pLTcl0pRByXgBPrG8uxshcsT4zCw2azZja/w0v27HB8dM+u6uhvvk4YXE+K/0AxKExNtkn5wQvgudATmXQ+8rK8WbY1yyLByIkw9YbhAcsQ7T2uhazqOFi0nR0uOli1d4xAKwziy3oxcbAe2Y2SMhbTPyG6KEq02b4ddz6OHDxn7Ha0VSCNhsyL2G9LQE1KmHwaGbc/u7ALXtsyOFiwWM7pZSxx78jSQppYcptpozmTRk1Av/JHzZ8+YhkGj2JiZdgPTOBKnQJwmcohkMVoCESGnTJgmpmFkGvRxO2PYri94+vY7XDx+iAw9Btg9ecRZ17C8d5dUMsvjOxwf373W5RzGCaaJkQzjDk9h0TUYKeSpJ4aJECZAsL6j+InsRvKUMDngbKHxQhaDdYL3hraxeG8wRnuGMWTtIxSPtZk4FaZpJKaECHhnOFp2+tgpIkVDKmugaSzeGayBECIxJvphqhuUkLMhZyHEzDSNOBNofUMRiOn6G6WbzebgoHJO5JQVkDAEBjOy3W7x3mGMkHPtLV+RS9BS0mUZfV/52O8buXqetm1ZzGf1b4lSy1BaltafvXc457HOaUZVM4D5fMFLD17m9dc/x8uvvMrd07ssl0e03Zx+6Dk+3fIKcO/+S/S7Hev1ih/4gb/H+er82tfTOG3I55IJUyKGfAi4S8qYIhrEWO1zFgRjCiEFVv2O83Uh5glbWvLMsV4PnJ+POO9xzqmDypGcIrkkMkIxFqxHrK6diAImSq4xLLqOsV7zKSdSTlxstoRxw9NnT3n4+BFnqwu++IXX+eIXP899Z2mcU4dXlTteRMHvYzmo553R/vf9/+/ZMDs4qXL49blX/SG/1erzu9zWAY0mBq05Z32xnCAp+gQmHHNmXjiaNxwtZ8y6FiMwTRO7PrLeTaz7wBAKoUgFWdyQcwIePz1jvVqx26w5f/yY7eqCzgqdLXgSTVY0UsyRaYjkKZJ2I7ZtSNPI2cNHeO/Yna8YLlaQMlb0c222u0t0I7Dbrnn2SJ1g03gEIaVMCIk4BZwItoBzjpwLYgyZwm6zYX1xQb8bSOPE7ryh36zYPn1M2m2YC3gRZOoZz5/x9I2vE2NkvDfw8itfuNb1vLhYscsZXxI2Tiy8oTWCd0JJmRwCcRz1wkxFHbIZyAVMyTQmEZ2QRBAreO9oGg8lE0KobTVDyaZmOUZr8uIwIohoj242a0kxMxZ0E/JgrdA0FmtroTpp/3SaIjkXrNXeXsqFVCCFxERmCnrVxBvo6R1KwykTYz70KymFWAoxBkKwh9KRroXBmMty0h7JB+XQ/9BIXmqSr5/LWgUQNKPDoOjHnGsalhLGOZwYjHX4tmVxdMTpnTvcf+llXnrwCvfuv8TJySmuaenHibOLNZvthouLFdZ6Xn7wMtZZttsVKSct+12zGVsRY4JmSlKgJHLRTDpVB5WwRABjKGKImerAspbxKJSctSeXAsWiWXwp1blnzY72oDVTkFIoSUFRJZfak7q0nPV4cs6knBhjosRInyPDOBBSZJgCIWf6ceT05JjFfIF3XpGtL2Ab/cQZ1PPOaf/zezmpD/at+/uklpXk6q8HgIWgqf3eXVl0M7AGrBNyzLiSaW1m0RkWc89i3mKtI06Jvg+st+qctmNiykLCHTK7m3JRP/CDX6V/9pTtxQW7s2dMmxVN5zGtp2sMOIt4C1kb7ykmQpx0QxXh2dsPCeNI3PaMm57txZrN+QWPHz7GdXNyBUYIhaHfsDp/RhgHvLV4Z3HWk5KiozbPnvH07XdwxmiJ1VnEGqZpou93TNueME44K6SpJ6zOaInMvKexRpvP/Zazb3yNYbtjs1rzo3/CT7nW9Xzy9AybEg2FuRWYt8xnuW6WcnBMKSWtEstEKoViDc4aWiA7GLNmUc46rHVa3hqTghecq9mBRvfWWLrOIqIbUNMYusYd4NPGWsQVRVVaQxaFoVMBAyFEQkw4lzQToULbjZAShFraE3P9Z+liMWO3GzQbT4GUch092I+WVLi3aIapDkpLeSKCMRmIh31hD/G2ttRgU9cwTCMxtLR+QeMrMrLC07WCIojV3lzbWeaLJa+8+iqvv/45Tk7ucHJyyvLkBOs9237g6dNnfO2rX+X8/BzvHa+++irf+R3fwf379xjGHbvdljfe/Pq1r2eRDKgT943BCBX9mSnRkjLEAjlDDpr5GO8ptHTGc9J1GDdjPvMYW2i9o2sTzun1LAhksNmRSi2JGoNYSxHtLWspNh8c1B6cUkrWZCJHBZ6JIMaDCOOUeOudZ6y3AxebDU/OzvgRX/g8r7z8MndOjmm8R15A/PSpZ1DPP0YDpw8BHe+bTlfxfof/NHdShKQcFkGxfAXvLEYa8jhhcsSbjDcJb9GNNBf6oJnTajeyHRNjFLIIyB52sa+iXr995WtvYIctebPCTANtCrRZaLLBlVr2sZZsE9FoGSDmiviZ4PzZGbvdjhIieYxY7zCbDa5dY3xD0h0ZyKQwMPQ7cpzwRvDW0jhPzIUxZnabDedn55iK9LONx3WtVlNjZHN2wbDZYMjYEjFppJGCEUW12QJpGhmfPiMGjbau2zabDTZlPIXiHY0RxilgxdaIc98HyFCCljdyQrzD40kYIkLImZgSwUbEBFKN5L3XjFxLVwqWMFawxlS0n2A1OdCIOGbyfgZDIJWC1DkpMVTQgAWKjgcYQYpAytogLwoBtgLWXT8sWlDo8h5KX/JlV/kQWsp+HszgvT/MwWlZryeE9C749H4mSoEhiiYdx4FxbJm1rY5QVCSjfk+AGGwGsY7F8oiXHjzgtdc/x+c+/3lmszltO2N5dEzjG3b9wGq14p13HvLs7Iyj5ZI7d04RMSyWS45Plrz62uu8/vrn3usjv1AbdxERi2sMsXSEAiFDyIapeGKxpGJJ2ZLxWBq8bRDbsOw8i/kS38wx3jCmxHLpOI0Ray3G6Iweeyg5RYN6o7Ohpeic3hQ0a59CIsYIRUuqJUXE6HaRkyNbRxaLNY6UYBgmxrhmjJF+DJQEKSk6oG0acs7cO5l/6Bp8HPt4Dgq+CTDB+z2vXDqHqw8pV3/R6Fd/LAgRiFgptI2nKQuSJHIYtNeQR3KJxJzox8hq23O27rnYBsYICW0UWik4yQcndRP2tbfe4aRMLMLA3BZc5+i8oTFy8NvOWLx1dL6QyAwlAYZUInG3xfa9wnEL2OhxKeOT4BodVSwl6RxQSXrhuw5XV8GQFEiRMiGPTCFRopZx3KylI9N2LcZbxmlgdX6OyZHWwqK1GG+JUcsxenFkJEyEIoz5+lc1xUgOesENKdE7wzAMWPEYMqnU0kfZ93PqvFxRiG0qgstAyISYiQmGKWKcx3kH1BJMSoc+nTX7bKKCUlIh5MI0BYZxIlVnoxDnDCUiRFrrFbxDR0z5MHi9z2jLCKlECllHJprrd1A6gEt1Juj1X4E9uRSwHObBFJyz5PjoGKQQpgicM02RwqQDtbmOiuT9TI2iE4dxZNf3tN5TSsFag3P7hn6BWgKdzebcv/8Sn//CF/nc5z7HSw8eYI1FjOPo6BjvPBcXq0NvC4RcClMIbCoS9d69U+7du8err77ynp/5Rdr6PJClwRfHdpizCw1DdEypIaaOkBpicRQcIp7WtszFY5rIyTLRzebM5jP6kDjvE3dOG5jpeYlcZrX73lIRMCXhS4Cs5+wQMv2U2O16+t2aYRgIU08KI1mgtIkcHdEK1lisdRixOAwxJ85XAzE9wQAlJ1pn8d6zGya+84ufrqrJx3JQ71cK+8BhrQLvyox+iGkmoz9WREuRywvhXe9TI08yzmQaU2ico6Eh5ZaEZgrTNDBNo4IitoHzzcCqH9lNkZj1tQ2ZxhrmrcfK9WD638seP32KeKExiYVA6wzWWXCG5ByIQlItggcakxmdwzQe6xtlNjAGwdS5EI9vW7r5grZt65rm6kB0wNEa7bdISUgpTDHTVsBIxpCDIiRt29DMO5quwVJwzROg6PxYKdAYkgihCKYYvBh93ZTI48hkt9e+no3zlFQwRTOjGALjNOJswVmdASkVdy/1NKPoOVdywZWCy4LJhRLVaZdUcE11bkkBEka0x7Jv/O+Rd6VknDN47w6AgD1SyhjBVOBAyRFJhVxLY95Y7TfUjcXkrE7BCpLr3Iy/9uUkTpGUINWgZW/7snsGckUcFwHnHfPlDEGYmsB212OsVbh5gZhSzaDUQRkA0UrHFAO7UVXKc0XoiXFIEZxtmM+WnJ7c58FLr/DKg1e5d/cBx8sTLSsay/HREc462qbRUmnJxDgxDMJqteLx4yfcvXvK6d07zOZzTk+vX8w4jonVCuLO8mzXsZ4W9KkhZk/Ck7IjFYu1rWaF0lJcw5h3JBmx3uMbR58UyOC9cOSaAymCHHZo3dMKBVMyPoHkQi6GWeNYzh1DZxm6zHo1sjqfWE8XhGkit0CcUawj24ayB2xY7U2HWDBDVDT0Zku/3bLOhXeengM/6VNdr2uYUrnsIr2/leeBfLqvitRMau+sMoak9EWm1EyjYIsB6yhZF3AYBnZ9TzZbzlcj56uR7RiZUgFjcOgQ77xxnB7NcdaSb8Y/cbFacTzzxMYgRYEJyQjRe2Q206wkBAgBawwdAsZgmw7fzfBNi3MtYh3iHMarg1oeHbNYLLQXYISStY9hRDMAIWvJK6VDUz7XQT5S0SaqFbA6+JfjyOrpM/rzM0pfcCSwwiSGSRwYR2sNjQSc0RKspOuHRR8tFhRnKdMEcaLkoMg9D4iOGhTRfo6xpo58FyRrpG5zwWYtV5pS+wMpkAPqoFyi8Q2zrsNaS846xDqOIyFMxBiYzTqa5khRVc4Tg86Z4bSkVXJmmiIhjpgCs1mL856cdNPWgVTtB+y/LyM6uHndlmMmjEGpiGr/aR+tg/6acmYKEYwQc6JI0RklnPbdjGCdV8ceI9M0EVOk5IzU/ohxFZAzjpRSCCmDWKxt8NbTtnNO79zn1Zdf55UHr3Hv9AHL+Qmdn2Odo/Geo8USYwxd2+KMIadA3/dMYcQ/c7z99lvcvXuH1157FSOWxfKTCHx/c2ak8HQNT3rDOyvHxeAJ0tSwe6KUiYIw6zKnJ1peF5tZTZnNmKBJZB9ZDwPrYUuxmcbtmXT2qLxLN6X0bxFTRqBgxNK1M5aug6UjB8dZE3DTGeP5hmF9Rp57JJwifg61b5uBBBRjMM7jm4amaXEV2LPebPjaG+986ut1TWOUH+ycrkK85V0/7//fA80T3opGAJ1j0QikXlFZAgYhpkQZR9brDUM0bHaJYUykVOvpkmmdZdG1HC9mnJ4syRl24/QCPveH29njpxwfd5zMG45dwTTKOIjzmG6G8a1mJXXyPRnH3NbsyTdY1yh01FiwFjEG6xyzoyNmiwXe68awzxb2DVGBOoBZKtLqSsKaNSAoAkmUAmjarZnNZsy7lhwHTE5Yijp2aynGUYyBepwmRyRcv1DsS/dOsVnLjMN2gyHSzjyu0R4JGUrxSFFAgl596ZDllGIqLFwzJGsM2dgDtZF3Du/dlb4rFQxgsNZVgIA7QK73YAHYQ69/aLdTYdRRkVql1ECBiurT78JK0R3imk0qKqzU73U/NHs4drQkaR0aXKXMdrfDiP48jCO5FKx3dG1HzgnnPX2/I4RQ+3YGjCEXiBW5F1KiiKHrOhbLO9y9+xKfe/1zfO71L3D/7gMW8yXzbs58tqBpGtpWg4YYI0Pfs91smMZJqy3W0XUty+WCxWKufTLnaZsbEM22lvUaHl9MXGzP6eMOMU7nomIkRCjisNzD3T3C2EIomUghCyQpRMkkyYhkrA04P12B9u95Iy97haKNV3KEEAvkSCk9rRdsYymhY9ouWT1r2EqCFMjTRG40a84ZDmhy0aFoEYexrmZ0DYhhegF76PWTez1ntahXf3vekSmcUpc8YUjMvedk3nK8bDmaOcZtYj1mUtGJphCT8kddrLBDZoiWEBUWbMXQSGbROO4fzzk5PuLo+IjdMNLfQEMf4OnDRxyHJadxxt1FC7ZThKLz2HaOXSywzuKdw7kGXEtyLQqZsu9qVOtoWKxoMlsjU1edlKslI8MPBbLo5nxAZyEIhiKFWDJjv4Ew0jaeznuSE2TKSBFSKRgxFFNh1ggm1ZLiDcCiH9y/z7xx2JS4OHtKmHZ4JzilZVO6JoGSama/d05JobmpokVFDNYKzjhKXUfnPV3X6QxZJR4F7cH4Ooey79XkWu8Xo4Sme0ezL4cbEaxz2Oq4QojElEm56PdmHN467a9kAzlR4vXPQcke1FGyIvUOV2QtItUMqgDOeUKMXFysAMhJ+xw5FbrOM5vPoEDTBmJKxJT1PK2Q81yACmkPUVGO3XzGgwcv8cUvfgevv/Y5Xnn5Ve7eucOsndG1LfPZnNmsO1AthWlitTrn7Owp4zhgrTCfd9w9vcOrr7zMgwcPmM9nTONI45trX89iPOsRzrY9IZ7hSqJBlBevT6TRkmSOLIRF+yptU5S5xGSsr0UAW8AVXCM4n2maeODJO+yYUr8lqaW9KEwIIQhlGom5x9Ye6GLZcufOCc+WC87PdKRiChMmRGxKWpHYE0uzJ0oQzXCdo511NG3Di6A2vHEHtcfQHeyAl9ClNqZggcYYWm+5czTj7smSxczRWViPwq4knZ7OiRwjY8qkssNEIdFSpMEZS+MdR13DneWMeydLulkDOSkr83Z3Ex+evh84Wxce2cLxvKWdzTk6vU97ehd7fIp0ncKLRUjVEeRKXrpHRSl6MusMQx0WTUXpS0KMxKjlmf2Guo+2xCj1jDW2NucTKYQ6xCdko0gg0kTqt4zDSIiRHDOSC85oH8uWSZ1bNkCk1AFDyvWH/IvZjKPFHF9LeOOw0Tm5EtR5l1RnUC6htUUgG83krfd0fk4qnpQEk2p9wwimbqIpaUZhjKFpmgNfndL2OECJN/tdT4z5AMnOOVNiqXBenuuxXs4KavaVlYtNlJmCVA7EyddpV5nujbEHFofDHAiK4FTHrCiyksFYQ9M2fO5z91guj7l37z53754e1urhw4c8evSY8/Nz+n5HSoFSSl1Pi/fgfcudk3u8/vrn+NIXv8iDB69w7/Quy8WC5XxO13W0bUPXdczmHaVkxnHg4vyci4szxrEn1ZJi3/es12vWqxV932sbYHf91/xmA1PQfnHXCY3LdA1MkwbZCb3G57OO+WKO9Z5dP1BKwVlTGWUKSEWNGlNnqUrthtQS/tW5JKNVKIn6fRlbcL5wfNzw0ukRcQjYFHhn1iIUYo5K+pzjYa84AC/yvqwLMUGIEJLO7r2INv4Lc1CHGuhHfvTlMwwKXTbonFNjYN5YjucNd08WvHR6TOuBNDIYRaJJVj75lCLTlIilxyTBeNHo1wnzruH0eM694zknRzNEjIIndrsbc1BTCKyGwtPRc18sd+ZHnNx7QHN6D7c4ojhfiRw1Is8FpdApeyRUrgN22qfQjVOIOStiZxiZxpH1eq1cevXvOeeKiupoW40+x3Gg3+4OsOA9sWXnBZ+V1TrESMkFWyq3l2RcnXNRno8EtrYO8/VH/F3jmHUzmsZTRGj6hjhsiNOOMGZSRTkhBiOFZIwea51RahZz7PwEa1psEFbDRBkVji7GHJCVIpo1LRZLvHfkuu7OOUqJpKQZ+TQlfKNlqxgDuUQtLYpR6PhhNEOHJEuure0aeBgB56jlyOsni907U2uNlnIr4ep+fuaqg7LWKn+hCE3bsVgs+PznPs8Xv/hlXnvtde7fv09T4chvvvkmX/3q1/j+7/9+3nrrTVarC0rJNG2LMZamKSzmR7z88qt8/nOv8/nPf47T03scLZbMO82e2rbDOUvbKU3SngtwvV5VCZBRIezDwGp1wZMnj7l37y737t1ls1mz3W6ufT1XGwjR4KynmzlmXWbeFcZRGCbIeIqbM18eMVssSVkIcXsA3+wZOwRBnFO5EeFANrAPvEQMRnR8gQzFKJs/kjG24BvDycmc114+JfYTuR+YzzxQ99AYaKp0zIGme888oaBKppgZQ2acqoTJC0DtvliyWKhR1gc8H96dNUmp8G9Ux8lZZq3jeNZyZ9Fx52jOyaKFEphiQnKEHIF0GUmkSGKCYrGmpWmg6xzH85bjecuscUhJjJOSxm42O6XIuRErWN/hFifI8pS8PCV1R6RmhhhPyUKIpdLhJ4w1ylK+P1GqswE9SffRTgammDh7+oynTx7z6NEjtttdHY7UssxsNuP+vfucnJxwdHTE6uKcp08eMwyTNuoLWGe5ezznzrwBY5gt5kDGponGGcQZJqNzZaaALRmHUrmYcv0OiqzaNmIdxrU0M5VcCaYcAphSoccicuB2s62jaWcc33/A4vRlouvYBjhbb7nY9pSKwnNu39MT2rbl6EiHFGOKpBgJUSf7U1YQv3cdJye5DlgHYpwIYSBOo4JIUlQNpZjIBNgPchqDNfV6MBnvldX8us0YQ+PV2YtrSUUYp3iFDbwoB5zT+af5bE7Xtdy7f58HD17iS1/8Ml/84pd48OBlTk+VwNgay2uvvcaXv/xlvvzlL/Pmm2/w8OE77Hbby3krYN4tuXfvAS8/eIXj42OOjpYcL4+YdTO6tsE5W9/XV0i6ovamSQErpcQKYtEA7eHDd1gs5sxmLcMwcnZ2du3rGbKQcZWxXoEvYrSaYa2laVvsbMlsvsB5TxwD4zipDp7Tkv5h2LnyOpoKZEg6B3Rg87jEp+W6VyiCVAyIsXSN52i5IFqVqGkr8W4pFRB0YADR19G8Xn/JtS0QY2YMiRDyldGNT8++qUHdD/v73q7C0N816vSuv9WMCfBSaBzMGsui9RwtOu4s59xdzlnMGmatZxoDU9EhM0P9sozUsog6KSTgyHQOlo3nqHPMvcWKcqdtdyOr9ZZNP2jN+wbMGsPi6Jjjuy/RnNxD5idE3xGwlKSbqnK2BXLJuKIlOT1jlIy0ZK3XX072qOMaxpG3336bb3z96zx8+JChH2jaDqlce8vlEdY0eN8ymy0YhomL1YZd36tDLNpXaB0sWo/rOvydO0jbYmPAW6EYEDRDkJgw04BlIFdgx3VbSpm+chfq8KjHNx2WXPsb2qMkClkxzogt+PmC2ckpd199ndMHr1N8x3bKzC7WzNcbyLXc5htcBaU0TcNyucRZRwiBvt+xXq2IyVBwzLoFcqoNZaWVCozTQL/bMfTbA+3SOA4Mw4AbBkKIV64RxXYJGe8Ms/b6K/I6fGsxzmN8x5QyKQ/EqJmgs5am9cznc2azeWUUP+KLX/giX/rSl/jC5z/PK6++xunpKcvlkq7raHzDy6+8zJe+9CW+/OUv8+jRI956600uLs6ZplBh6DoUvZgvmc2WzDp1fN28Yz7TDEoQnJPqqPSa0N5fqmwIlYR3mthu1EEJhRQDOWfOz8+vfT2TKENJpmY+JZMSh1kz13Z08yO62Vwd0hAIMdE6BehkkpbZS1bnhGCKso+YcrUSRc178mH8Iaes8ie2BmXO0jYtLlka31SQjyWLOWTwB3QgsCdcUNKE+uqlKJFw7Z9+2vapnfEfBCS/qvr6nvejMZOl4A20Tpg3wqJzHM08R3PPycyznCnxqzNCrCwQ1lratqGUhAlCDJHkE7GKxLUm01nobKERBVvEkBlCYL0bVbhwiiSuPzoFaJqGk9O73HvwMovjE1zTklGOPGPyobFeKvtByBMxTocSH9T+gOwViLVfFYJqPb319ts8fPSIUgrHx8cslkeYuqHua/dt19LNOpbHR9yb7rGcJopov8WK4Wg5wy9mSOuR2RwTJkxlRM8UbEkQJuh3Sh9U1io3cQPkpkUK292WUnoWsxnzxtM4h2/mWLGI8WRpGcOoQQwZ6xPzk7scv/QyJ/df5/j+KxTjcVOgWI9rG80OjTBr5/imRaoWUdN6RAxhCjr7lDIhBsQU2rZjNpvjXKNrVSHr4zgyDr1Gx0PPZrNis1mzWV8wDj3ESKmqsiEExhApMRElXvt6No3K1BjnwbZIiIwuYIyog17MOTo+YrFYMOvmLJYLlosF9+/d59VXXuP+/QfcuXOHo6Ojg7ihr8O42kNqOTo64t69e+x2u0s13pAOkhBgMWJpGl81uWztncphoFfLpirUt59pNCjII8XEbrthHHvWF+c8fvQI56zC5q/ZAsqpmKpoYK4ce2TlGGxMRzdb0nZzbC0DOyM0Xs+1IWRiiogIzlhsRSbo7Kj2mPazdPqv9oEruRYxF0z92IKCXhJGxQxVRY9SzBX9qCuOat8nLZU5xulN6sxqfgHr+U05qHfx8H3AY65SID3/OEHlIqwozXvnhEVrWbSGeWuZeWiIWEl4qz0pLQXqhtE0Dd1spgtm9/QqmTBlCkJjC14StgRIEzFoA387TGzq8G7IpSJTrt/aruP4zh1O791lPp+rZHMl1LyqpVNQloQYAyGGw2Be470iaCoH2r4z2vc9q4sLHj16yHq15sGDB9y7e5/FcgHAru81O2o93juss8wWC05KrugzU6MmpaQpRsjGgvNIq6uVZD/pHylhABx5GLX1FNMBlHGdZpxh2u0IY8CXTMcCaxuc6zC2AdtR/AI3DYQwKW2TgeP7L3Hy0mssT1+mW9whFYhmYB4jYgrWCN5YlrMlTdMp7taoanEphegbDEIJymAi1rBYLFguj7TxL+ZwgSsCMCrTxG7HanXOxcUzVhdP6dcr0m5LGnumwdD3hRyjskvcBOhkMa/aS56MIu66oKXm5XLB6ekdTk9P6Todzm3blq6bsVwec3Jyl6OjY2az2aHPqaJ3l6CSrutwzrFcLmvmpBpQwzCy2/Vst1tCSKRUNJMzVRlOCtbayqSus345J9U7K/lyrKJmVdM0MU4jTx4/5o1vfONwnNdtUxKmVCqcXuVVctL9x7gW6xe0syVNM6vig4J3Vq9z7xmj0m7ZOvagciQcNtbLalVVMa4Zz57iIGUOVZdUSWVjVG2qnNVJaahb/y8aqEq+Qvqr46Q4B94bnNNn5JvPoN6dJx0mmK4e13t4qverAO6dkxOVxm69YdlZ7ixaZk3BpJE0brhYj6RhwcxbrFlgvKKFrHX4pqWbLfR1jPLvdY2vPFOqqSJxJA0bpqqVko1jNyT6UFTtVOyNEHECWvJoldRWdW/KoW+3d+xad46KPup7hmF3mL9ZLBYaabVGZxSKpufr9YrHj56wXm2JMdN1c5xvWK03XKzWrM4vaLtOnYk4iliGaWK92yq/1v7EP0RjdW6qFCxa2mn3CEBTcMVgXUO2nj4XSkwK87nu9Ww8wTtCLnTW6KxWhiiFZBy2azlanLAgk+KkmYAzLO7cZXl6n26+BAwxBtIUlJ+sZKxYvDVYQEpGFBpVJREMHoGuQ45PVIXHGtquo+tmB065UsEsvvF0pqNpIo1vadqG2axlPmvYtA27c2FYZ0ydP4pFmOJeUO567d69+6paK4ZhSlivOl+z+Yz79+9ycnJC27ZMU2S9WgNC285wrmE+nzOfL5nN5jRNo8HXAdxzKclhxOB9g7X7NTKHx6WUsFb7dN41OKdBaAhTpZjyFTiQGMeB7W5LCGOloaIqwFZWkahVhRAj3jlms+t3ULvJVBSoIRdPKkIQwDbY9hjbndDMlrimAbG172nUIYm9JOitwZFAnT2s/XcOCJYDa/plv7ogaAAapsS427FZb8mT8k4WymH2r3UGZwVr1COlvO9J7WdSwXtL0xoar/IgLyIe/QQO6nnT1FKZH65IZNSG3fMe610TT5VupnVC5xyL1nGyaDg9mdGaxLgd2Gy3XJw/ZeoXHB0d4b3D+1llAtA+QJ7NsFJ0iLc0lJwJFV0yTUp3E4YVMUxMMZJtxy4KY4RYa8HcmIOa4ZxXaYt3ccRd2l5XZxwGttstw3ajjsJ5vHOkWUfJ2niVeiKuLjY8ffyM3XZARCG7ucCTp894+623efrkKcvFklk3w/qGbKyKOe62FZFTh3BrM1Sp+xWI4a2j9Z5F2zJvnLJPW8HahmQd21xUX+kGHNSs8TBrCcYy9x5njLIgRCE5aOYdy5M7OlxYeztN42gXS9r5kowQQmDqd4z9ljgNlBQwVlGSMU66ibqM9Tr8a40Fa7CdwWvNA3E6MG2d1cwgXQr0OesqoarDWU/bNXRdQ9taWie4HJGYkLpZ23ZOHxNDuP4S3/379w/n5mY3EZKedyd37vDaa68wn8+ZpsCzp8/o+56cYbEoOsfl21rG6/Qcl0v9p0suvn2gKzrcS1HZduNwztG2TYXoW0UJWkPOitRV2HWr6MeS2O22XFyc0/eDgmH2vZe9HlV1emEK5Jg+FMD1IqwfLCnruSR0FGOI1oHpMM0Rvj3V7Mk69lIlB4eD1CH6Wnq7Qh++zxYFZcKXypsotZ+0dzBGF58UMrvtjouLC0yW6tQjVCflrcFrkYBc+1BpX12hasyZOgZktde1F1/8NO1jOShTEUaHw6isBFqeU3ZxnV1CKXr2xIWoIzIila0ZREol2jTMGs+88Sw6z3LecLJokTJRBqFkhYmWlFmtzuk6T9ep5LCtTVrvG6wBOl9Lf8okPU2J7aZns95xcbFm268ZeUZxM+zilOw79kJxNzFjAjCbK51RjhnxOmtircNaLZ9d1n9RiiPvcXNVs/TW0rSXzU3QW8mRWOl39ho9+wzs4mLFxcUFu+1OhfBS1spzRQfqYwPTFAgxkirKLOWMWN0kuralsUJjGxaNpWuVNbwE2InjbCqkMdHdQImvc4KfzygtNNbTh8j5as1qCgQMRycJt7xD183VMTSepnGYmiVM/bb2g1b0u42CPYzQVmj4MA26X1hPM5+z8BbrvQ42G2V+1hlGHYq2xhwYpp/PHgSpukiFpu045g6WgkwRU8C7hllK2E5Zr4cbcPj37t3TEmbO2EaVW4+OTji5c4fT02NAlJy17OVH0B5GURXcvN9Q6/171Om7S/+VFxHVyqIIzmaS83iv6zVNob5GJEyBkrL2BOcdIQSQwpMnT3j77be4uDhnHLWEG6bANAyEacJIoWs9jVf0X9d1176eqbQYsXjb4No5LBZM3TGZFjMZHB05CmGcWMXEarPlbL0jF4t3LSEGpmnEFsHYpGVmo7IlljqIX/t0RgxFhGlMjGOAWvlwoiW77abn0aOHmKLfYd9viXECH0klE3LBJB3ULogOZB9aKIbtZstmvWaz3bIbBsb46ZMdfAI2833Usy/RKYy3MQVf2cHVaWi9urCHPKozssYcPL2p0/rzpmHeep1haR3z1pICDAbImTiNxBhYrc5ZLGYsjxYHCQDnHCU34C1GWrzV1LQUiCHhrSfHxMX5Of1uzUUfSX7OkWnxxiE4dVKf9sp+RFvMFzhnDyASc7W2vB+SLLUUalXd1YmrPRFD1+jnVfh41XmoWVTOlwJyWmse2aw3bNcbxr4nLhaVBf3yO805M04T2+2uSncHYlJk1Z7WJOdI5wSTPY1p6azgrCFkR8CyiUIIhXgjDsoitqn1c8M2Bs52Gx5vdoxZuGc8pzFxx7e0iyWzrqNtvc7LTAN9v2N19ozN6oxx2CmKrWnJjSeJYdjtiDEizpMlMz+a135ADRBUOLYySNTvMl+ug6LfzGF4V6x+59YZurbBOwshHghScynMTo7AWMINxFDLoyOFwaeEbaHt5ty7/xLHx8d0XcM4qqruYZCzcAkVv+KUc9ZNNMZAjPHAugEc6LdUJwmwgvOlRu5angshoNm8lvdiCDSN19dLlpQiz5495eHDh6zXK4ZxIAYd0h3HkRgC1umwvq2Vl5ugOpryjIwB25DkiCx3GN19KA3eBO1FFUMOiSlGxjESk2pEpVIOPaNMwTgozmkZTlRg0zpTWU90fVMBiZBL1LnFqmGQM2x3EUkX2FLYrDcMw46cdYQgZQ0oUkUSZ+QyuKAwDoGL8zVPOsfxfMbTsy278dOnNvt4bOZ7pBiX6aQVdUytSXQWZs4wm3kW8wXWezBeGbdrNGkPMhKVMEOgsQZnpDJsR9IYmKaeFKIiRoxmAOvVBYvlnJM7x8y6Fmt1ilFKgWIPzWyxUmXjM12XmS8mlkdH9FNiZGIyXmk5SkYplKry5A3YyR2t4cs+LYdDaULEav9HCo0B4womJwyTRtoigIPSUYU10N1R6GYzlsslTduqE0KHeGNFhqU9tU/S+ZxxGBmHkX43sLpYc36xYhwn4oGJImG80uqP8w4bJ+64QnDCRCI7zxQzIUHKegHchINqXcP+Auynic3Y82y35ulmQygGvzhiO42MUaf2s1XdmylM9EPPZn3B5uIZw2ZFDiOm0RJTGgamlBl3G5V29x7fNZSUatauzNtk2c8BH2ilHA7vlAopxT1pr62Bker1iFHgj7cWYsIUzcZyTsyPl/hZh72BDbWUQpgCqRSWyxOO76hUxWw+o9S+zgF6L1qmc85XKXDRvk8IVT1Wla3V2YD3/uCc9kGsFIPYomuoR0AI+xnFchhE1SAsMYUJOxlSCmw2ay4uztlVWY0UIzEEUj1/CwVrDK6yf1xKclyfrcIxKQslqP6YnQTZZZom0xlH2zoa2+GNQXLkZL5g0c50ja0KjDrTknJmHCzRCMbuhVuV7NhUSRM5VJIgBGEKhnHSfWPKlmIKyWRs3LHb9UxBs6ycNMBsU+VhRIUOdRYTEGHbJ/LDHcN6x9mzDeOYOL/49NULPoGD2rMxFUVApYSkQAkB21pmbcdJZzg+amnaGWI9xrhD/fgAh0b7VjVgQkomxaC3HKuoWzmcwClntv2W3W5L32+1geebKntgoAhiymVTsJ7h1jd08wXHJ4FYLNHt2EUtZykVT91QbgjFd3S8ZDZr8Y2tyY+m0AdYJwUkYwk0ZaRJG/x4jimJLIZohMnPyK4lVfRSKXvWiUuHpcJwSoWkWkY6MzRME8Mw0Aw9u35itxvYbLasLlaMk2oZ5UqVJM7ivIU4MTeFft7QN5acI9Y3hGwYoh6XUuJc/wbgXKPliJQZUmQTRjZxYBt7QjJsxx27vmecRoX6CtoHqPxj49AzDVtK6LElYbNgkieNo0K9h56U8yGgUpZxLamIOC25HByUHM7fvUBfsqkCJsAadwjeDpmUNZSQSFNmHCamccRg8dYzXyyufT13fU8MEVe1nk5P73B8fIS1lrFKY9gr4oIpKZIup3z4PYaIrf2MfUZjagXk3Uhg7c0oXY9FavZkjVEAQFF0qRFdJ1DxwxACIYz0vdIXDcPANE7qoFIkpKhBxZ7R39qD/Ml128U4JyZLLgYzWmajcJQFj6FpHa1t6HyLd0LKWrJz3iuAKmXCbE4Ihe0Y6aeKwMsZbwvOZqwvGF+wHm1ZlcI4FfpeGCelJTLGg+nIzlKawpQSY9C9om0asnMUlHjaGJXU0S6TkChQ5enH3cRus2O16kEM4aZBEkVELywpNNZgcyCPa+K0JYcBv2gx3X06B/PW0XYeY32VzdYPrEza1SnUn23ROmcMlhit0sSUWAlO9TGq7RIYx4HddkfjPU5Mhf5XdEmGfMCcqb5PEUvTzTm957HtktJtONsFhgghF7Ic3MCN2GIxZ7Gc0806Ta9LqkqY+7mDrMPIaaQZVjSrR/j1QyQnUpUJkWZJ9h3JOCiGlAPrzYaz8xXDOKlia80sQcEPuQhTymzHnk2/w+06dpX2abcb2PUD0zTpbEPtm0hOlGwZTWEYnPKbNY7dOCK+IduGXQzkvYRCvP4NwNpG5SxzYJsS2xQIppBsIaTAGAZ2vZYz0l7XqqLGUk6V5DbhLDSiekwmJ0qYCFMkTRNihcYKbaMlI+fUyWivqTLHV3YAI+bdCNHLBq5eF8ZhnNXvpg4O+zbgmh0FRwg70mpLoeDb6yc3ffLsjKZpuDOfc3R8XFF7viLRdMLU1MA1pcAw9my2a/qxJ+ag/HI5kpIiVEPQ3ujeqemtOp+KDRdUCh1ryLWXsnd4mKrw2yiTBKUc+PbUUcWqFqulxJjSQR1ZwVOJcYo1G7l+6qhV3zEmR8wGmyOnWbh/7Fm4jpmztL7RgWRvKDlivVJq5QIpFqxYzaDOei62Pefric0u4yThTNJys7UYlyk21VSiIoKTXsO2NTSLBYuTOcuFZaCwsc/w7Yyj4yVTmUGVirHeaSqSgaJSKpq9qgMNE4RxwDmLvADBso/loKyoqmfrHEtvMCkT9+ikUphb6Cw4KZgckBQUxycZI9rIN7J3VNrcMygUWIo5ACxy0k22qSzcttarS4EQArvdVof20DmBHBNwCYdMFYGmsEg5DMQlcRTjQbQclmHfWPvUF/ajWte1qh/UtQzjnvsqH6bgC1oDlhwxoceMK8zmKeSE8Q0yP4U0USpSqWSNKvuhr32koNFmJU+1Xlm5w6Q7ZQyRcZoYpoFhnBgqDLdUNKE1VThuH1TUICOXwhASm36sDbIIPmm9Pyvd0Y3kpMaSSmH6/7f3Hs2RZVl+5++qJ1wAiIiU3Wy5IGk2i9nN99+Ojc12jDPkGFmdVZUiAsLdn7xyFuc+BzJZ3c1sVgI1ZnHSkKEQCMfz9+5Rf0FhypGZRGk1Olg0kURk9RPLMhODr2TictWSa9uGvOsxEWxO1/snxEjKQE4Ya+kaJ2CRmqDY9koviq+tu1f6eZ8IXA/i7d9UxohvkioUU9C2QdkGpS0xZsIykVOA1z9P+fHTJ7744gveG0vX97SdjKPJqT7bqnbttYAMAf14z/3DJx4fH9jve9rGYq3soNZ1/e9EWhWgjK1SgwIL337USgR9vRfAg1aKpnH0fUvbOqyVzm1dPcu8sMxr3Z2K7FTKz11GTqLXGVPCWQfNGzz3qZCTImeLNZbG7ti3La1W+GVhUoF9WyAqYlxonKV0nYxaA+QQMWT61rLvdzyc4TzWVUiRqZbWgEmgFUUXjC44k2l0pFGRosG0Lc1uT793xOEESpClh75nKQ3JOJrW0jQOrTQ6IfJMWcZ8WQFJtPvIMhrcSMN/zvhVCarVibu+527fctNbbLKsdqZ4OaOaxrHftehSWOaZGBPGOrEsdxbrGqxt0MZKhV0s6Be7LaWlqjGKGGVm75yjbRp8aMT+IUamaZKZd5aDhfSMjPKVeR9jJsYs7OkkB+rsE6dpZfKFrC1F2+uB8lYtVNu0QmJsG0JcX9iTbirCdZ5cRBmD5ClpkRFoVqKRkgoqS+st34uw50MIYgxXGhmlOkfX93S7HTkqnBU3YVIlMoaVNQSKytjG4qxUuEYbjNLEnClKFKexHUtS6DXJ5ssWsUmfF1bvUSm+SYIqGELxzCkyxsBKRjeWZteglMY6RYieZRUju1ihtcYYum5HubmlI6LWERVW/OpZ11R188T8zWorAqVdh3Wivp03Jr96Fn9FqWvFuY1st02h3Habbtp2UFagizYo4wSIUWCeJ9YwEtLr+2v99NNHDocjyhhsHdHHEKrYsKm7J/n+YoyM08w8L3z3+3/iiy+/oOsb+l2Dc5KgxnHkdDpVxYh43VvRFCzP+ogKfb3/ow9Mw8g4yY7j3d0dNzcHuq7HGMOyzMzTxDAMnC8X5nnFB1+LilxH2nl7SwAR9e3a19/pHbXHFEjWcLi55f2HIzfHHtLC/cdPnHSk+B3WZKZxpO1abo5HUsmVqJ8oGHb79/zVl0cuS+GnJ88SMiGK8SbKyL1XSc3WJFrjyTaiXMahSEaD0xhnpFtNGYumaxp0aUjOCHCtc0SlCQVcFgWMlAs5KJLNqKAwuXbD5s8vxfWrvuJN7/jqrufDzY6dyeADy2rJVtjgxjmMFRkTv/rK/k7gHEYhCcFs/k5CGiulnsmlXJf5ugonGmNw1uEah/OOmGVhP44iKqkrYihHmXuHIA/IMC+SoLLsqdCWjMxIJ58JpSKslKAM/5SJ3GuFtRprrPji1ANtA0ls2ELhPMiupBhLseIMi3Uy2K95TNVPLoXriHBD6Ckt3cH7D+8JITO0A61z9G0LBbEfGGemacSv69V4UORWZIelqvRMTgm/Bk7MzLMXHovRaKdRYa2WH5Uf9MoRKMwxMPiFKXuCSqhGY3FyKVRhjYskKO9JQdTZnXWo/Q6r3pEaQ57OpGmgqImYFpkIEK8VqjUGY2W/urU2JRcUUZSl605G5gIbGq1cYf9KZlVS5b7o4K98M61qVwUhelQIqPL6nmXjNBErcXuzb8l1XGaN+JSZunfLJbP6hTBN/Pjjj/zud/+N29sDt7fHip7TzPNcLTbE8kIuXKHkjtJkslJX+5dtTL+uK6fTifP5TM6Z1jn48kNVpVAsy8Lj4yMPDw/Xrx2C+E2l8pycYGO+yF5Qv8GIzxCxKKxu2O8a9rsOazXrsjJeLlAW9u2KUpHT04ndbocuBR898zoTVo+1jm+7jvc373h/bDjuHWHITKtomeoChiAglmIpuUAS8IRWBVftMcRJRsSQUlHErEnZYJyh6a1YGvUOX5QkJ+pZnQvZKYorqKTQ2co9/RuIGf+qBPXNbc9ffzjw7tiSpkGWuNVfxxiLMpaMERQXgAZbNEpvxnkyXtJ1HyWNQq43fKmunQVjpXpSFX7rnMjxJJ8qAi0JxFzLIjWsnnmW5f7j6cLTaSDmArrh+O49/eEG7VqKNpIsET8WWeS/WfMESH4RteE61oBn6vf1lYnMUDIduT3A/r0ceLYhu56s1RVQsVXnMj6SJauugp/H4x6lvmW/23N5ulBSYX/oSRTmeWG8DIznizidVhvNZBKxVvgpyE4qOUewjtmY6+Ekl9bQqcweReMcyrw+im9Jgcs6cVoG5rgSlFjTaysJNKXMEhemdWJdF1IIEAuuaWkaR24aUtfj247VNAQcJmssM4kESagVKIEKpaLRWXazFNlhKaUodXSXixyOucKtt45BqW2sV9+7+vdT3ZvknChKvOe1LpAyOr4+UReeyZ7zvNA0E6Y6C9vKU7LGyvcEVeE68nB/z+9+9zs+vL/jiw/v2VVTwWEYub+/F2v2rruCKm5ujvRtK7JbWtBqVG+peZ65v7/n6fGJUjLHw54QwlWhZhgG/vjHP/LDDz9y/+meZV7IqQopP38bz9D++hffAsUXshKpopKxuqBJBC8jyhhWtPLEaCELf6uzDp0LcVm5nE+M44g1jvd37/ni3Ze838E37xpmnxjnjFOFnQ7s9EICLunAWhxJWzxgYsT7QvSJECJrVPhc8EUzRVh9YdcaDr1jv3P0vWWJCZ82apF0t6ooMf3MBnK80mP+3PGrEtTtvmXfGhoS5/nCcH7ich4oaHa6lSrUNBRV+TjGgm2El2Jkrq5f8B+oxK+S0rPEj9rGIRuqR18rqpLLVYfOGhk7pSDt/3AZOJ0G7h/PPJ0v+ATa9XyjG941exqj0cZRtGxHxJqicjV4uyTlTEarLPI5ZSM65qoGvj1IhYyhuB159560oZqMJXQ3JCvX/PoAalF4bltXPxratuWw39O1LX3Xs+v6Wo3J6M5GRwyRHAPJK3mAjK3XTBSORQU6idWzsbJo1rpy34qoMhgtEkN+Jkyvf1WHdeY0D5zngTmvBDJZF5meabEqGOaR83DiPJy4m95xe4w0bSMisK4hW5m7lyLWCEUblLWUCfyawBgympghRiAUGbXmhM6RzVpUCSnoOn6GZ86P3sznasd81edbF/w8E5aZHD2ahLMi69m+AepsUzRYV88wjFjr2PX9VRuulCKcm1o9l7rrGYaBjx/F5uXh4Z53d7ekFPn06SP/9E//hIjFtsyz6O198f4dN8ej3KtNS9O0QnpGcbkM3N/f8/DwAKXw4cN7lmWtSUozjiNPT08MwyCeZXUEefUyKiCIYKoKQ+UTvYEyR7870BmLazoOO4NWmWGKzJOMmxuTQRWcNez7jl3f0TeOcSqEZWWdZqIN+GUkhhkqaE1sMsTNwahMy0IsCkOPUg5lDGgZMZNBxyhdeRQUdeMstmkI3mKdoWsNh53heNQsgavbg0KEFkrRlCQKH1T05b9qvfRviF+3g3KWFDyXeZEb7+MnTqcB43rudM/BGdq2x7m2kg8NylmKcxTbUExD0VbsiHMCZGlJHfmhnyuc5+/1+ZCOMV47KKsFwTcNAw/3D5yfLlzOA0/nifM4s4SM6fbs33/F/r201MqIUnh+MdLbdtcvl9ivGa0uWFI93DZuUkbr5+4j50zCktwBrRymu6umjopiWordgXEYLR4zSQtfqW07drvAfr9j1/fsdrua3C3kUmHCGefElfTLd0fOpwN5HdApYE2Dth3YnmQbYgkyejQGZyx94+isoleRRonoalSGKTseHz5x/8fl1a/neRo4jRdOy8iiI0nlKtEk44wQRIi00R2fHu65Pb7j/bv3dKmrkG8x3NvMIZVp0G2LalqKNaSL7ExT0YQIPmSyEjSbyuLsrE3l69ROeCOrbsRyZSqyT0FGui6R45pZpollHFmHM3meMCnSW4PR4o322uFcQwiBYRh4enrCGktbdfVc4yiUuofSL3t4fPCM48DT04mHhwe+/OIDIXh+//s/8J/+03+ilEzbttw/PHD/cM9fffMNX7x/z6GqoffdHte0aKU5n8/c3z/w8HBPKYVvTiemaWSaJrQ2Aiv3/grl33Qktx3WVUuSZ+JwVJH1NzhQ/7X44usv2e3bqoZjhD90XhiHlZgLfSfTjkPfcHvcs+96bnY942ArxRY0Qom4DAOni+Z0TiyLUEGyEnBVLJmUldybNosCvDGYnLCq0JRIlzxdkC7dHxrK0tGola7TNLaw7+HuoEhJk2LdCRY5j2JMBC+oY71NcH6DM/RXJajLuLCMgewnPj1cOF0WxiXjikItEJdCpwouJaxWWAM2FJqo8EkTi6LLBaeLcEhI0jVs+oNb652konxZeQpEtC4Jq0eSKmLj/PT0xOU0MA4z07SyLCJro9Fk7chaWtyi7HXGL3HNTm+WoLpWVDeK0ixGXxGIMeeaSDePG8jKgtWo0qJrRaiUgcoZUTFU4cwsle5+h9aKm5sjx5sjNzdHtFbs+562cczLTIyeruu4OR6J/gY/vSONZ1hGAbO4nuh6VtMwrzNr8IBI/e8bR2ugI2BzRJfCWsBHWULbN5CSeZwuXNaZOXm8KiRVKh9MyLGoRMqJy3jh+59+YL/bc3O8qSoZLU1jUcqiTYtuEhYZ1yVtyMaQayevbU/GiNJ29pV4LkabRYOpD3JO6Srp8zPeT9035pxJweOXiel0Yh4urONImCd0WOiUEpfZXHBv0EG1bUuMict5wNmGrum5vb29TjesteIo0LWVcK5ZV+luSik8PDxIAXm+UAqcTid++ukjyzIDcH//wMefPvLT9z/w4f07bm9vOB6O7Po9bduhlOG//Jf/l++++47L5Ywxmo+fPvLx40eapmG/FwuPb775hn/4h39gHEc+fvzI0/nMOI348GxEKuerpKuUEusbPPOHQ8vtTceutcxeEstliUxrEkNKLaK3VkWctoieQGJeF4qS9YfShmH25IcL92fHNGv2raZvGzoHrhhshDUWXGooWmOcWMOr+vXSshJGRdQWwops6SM5zszjTI4Lungujx+rokS+jppyrkCf8nKt8NsgzX5Vgvrx/gxpIa0Tl/PCshRCbgjFQTSsU8algLMJp4uoPxtN20a6LrLGlkNr6ayi0QWrCwZR9t32LyUXUqnOpC90y7YFrdhQmCrJszKNE8Mg1dTqq+pBLrimoe32uKZHuUYg5kWTrjpoFfV2rXLfxrBwG8NlLKM1hCTLy5KEdLvJi0j1UuWJq+SErJGlk1QxoLTs5nIqOGfZ7/e0bcvd7Q03Nzfc3BxpGkuKkf2hY5pm5mWi73ve3d3ikK+Tzo/Ey5NUom3HZFouyvJ4OpOHgZyyVMzGkBT4GImxiAZgSPiQ0Smy371BghovjHHBlyhK9WyVtIw9kzV4BdM88scf/kjf9tzc3tL2Pfv9oSpC6AroadCNyBg5Y0S1RFtSiBi3E55STFDHzkaLSKwqmoISl92qpmGMcHaepwPVTC8nQlyYp4HL0z3z6USYRnSMNBXWT9PJCPg3sDP416Jre7yPnM8XtLbsdwdSTFf0oXhitfS7Hfv9Hq010yRq+z5EHh6lQ7oMF9q2YVkWLpcL9/f3TNPIfr/n5njk9vaWu5sj797JqG+329M2HVrbag//X1lXT9s2fPjwE99//z1t2wJfsN/v+cd//EfWdcU5x3/+z/+Z3333T8QU8DFAfu6htiuYqjXHa0fTag6dpm9V5ZJFpjUyx0LTWlCecRoIi3CenHVYY5jXlVRyBaEZzmPkyQ88jC2zb/nyfc+7Yyuyabmw+p7LklhXBanIHrbkSrJNLOPEYhILFvJCSZ7kJ+bhRAhC0P/p+9+jVLl6c21ntFKgnawOlDbElCtZ/Y13UOclQErkAF515NahnKY0PWuxpFAwJYiIq8pVo0zhlkizeIZp5dAZbjrHsTXsm/pN1YVzyVQvpECKiVzRJssamZbI4sUjqev39G0jYqmmoWs75tmz+MT5snKZAjQtzf6Ww+0trunk4OYZe1Cq5MT112+0hMrGsESRjFm8Z1781RfHVq7YdeypRWYf/Uxyrm3Uc0VTkWJiDW/E6XVZeXh4QgG7nUhEhZhQWtM0DZZEGU+cp4XxMjKdLyxV0icpxZg1Yyqch5FxmiRBIUg2pzVWFRwCEzZId2w7zf74+glqCitrSSTNz97vLayztF1LILKEhfvTPX/4/vfsuj03h5vqmuvkr2gjNg1FEYsiKQuuQ6lAQjyNyroCsSYoTckGkwM6adEwjAlttTiXXv29pNpU9R6MIbDOE8P5zHw+YWKgUeAaucdBtBp5gwSllCaESE4TzrWM08Q8LyzLSt+11Zpe6CF2Q/QhiL6Ukti+fPzIw/0DfddRSsY5R0qJaRIqyrqsjMPA+WnP5XJhvxOTR1DEkHh8fOLjx0/kLHur3/3udxgDHz9+5Jtvvub9e/FSCyHSti1ffvUlPgZ88PgQWdYNWSrX/hl69Prxux9GHp88jTMsIXKaElNAxIebTlDPyTMME8MwE4NwPJu2pdu1NMaBafDFMC8wBUhKc3No+Ouvezor99S6au4HT3pK5AV8QXbuFZQjYytxJA9+ZLqceLx/4NNPHwFxoxbvuciySMISWoG8z/1+T7frxRttjRijsM0bw8wnX6v40qCcxVgERmssUVvxA8npKoOkq5aRMR47WzpnGBtDPDTom57GtDTO/AywkHMmBpFHyQVSgnkNjEtgCZlD07Hb33B3PLDvOtL7D3z11dd4n5nXzP1p4uE8kbVDtR2H23ci9lnh2C9vzpeeNG814gtKEdeAnyPTvDCMM/M4UVKSBGBshfCL4oC2pqpyCEhkk37RdXRUqjw+FWwhBEfPD1qxLhM3twexy1Ybi1+Bn/HDyKcfPvH77x94GCYua2BdAz6szGtiDoF19azBX5FpSkkSbJyjbSytNRys4sYUvvj6lt3XX7369VxyJCqxHKhZu5IYK8nYKdSuBRRLWrhMJ37//XfcHu/44sMXuMZdC4GiBHEVoti2+JCqCoeWsWtcySVQqtW2VgpvjXiQaYQomiJN01D20tWWUrk3pZLMESV7vyxMw8AyDnRaPM2cMbSuQtiR6cLrh8J7DwXadhGVkWlinmf2ux7nRINPlCHMlXysq5ngsqzcf7rn/v6em5vjFRyxmRau60qM4liwLgsxBi5tI1I6SxB7mcUTQsQ5h/ctKUVOpwe+++47vv32G/7+7/+eb7/9lsfHB7xfubm5IcbI0+mJ82Vg9YFcogAJKgjrraj5//X7CacMVikwhaQ0oVj2jcM1BWsCOSqGaeGP339kGCZiiHzx5Qe++uZLmtuOpu3woWEJGp+ks++7hnc3DQdXMERCEGTt05wZvKAH86bUoRG6j4koU0hpZhwunB4febh/oG0tu710zsu6Mk4zISaapqnjXEWvNbvDDbvdnnVeMUakmv7c8au+YiwKhamYdxmbSEUi2lJs3CYKGTkUCgihNidCTKSo6ZzmGLOoMytdR1bVpKxI9SVKxoqUZX8VsiHRYpoD+8Mdt3e33B32QCJ4j48wrQX7OKKfBnwuZGWwrQA2chFUVa0fnndbV+Tcn/W6/g9HLrp2T4Fxmnl8eOD+hx9Z5xmrDFYbrLMYJ0gy60R+xLlGoL4VTbV9aCt7ttPjIw8Pj4zDWNWzZT9itMDFVQFnLW3fksJKGi/MD/c8/vA9n6bAJSkZmdYqVNj4FQW0Vf8VgJC0JgRQOeOzEPhyjlfx29eMQCZVxX3FViWrZ5ixUSinafpSzQAjD6dH7p8+8fh0T991OCsAAMqGrPOMw1g5YrOYGVZidCmKkuu4ZrsuWhxfg5cEtTvsef/uPVrrulcRCSWQcSBZzN6CDyzLijaaWDlQ2pprt/wWt2gIoVbxVFWGyLwszIvoGSq9AUrEKdg5x/F4pN/t2R8OUIukx8dHbm6OeO8FoWc2dKMoE4SS8V6zzHO1us8sy8o4TNfx0sYlCyEwzyPjODIvM23Xsd/veXx85PHxiaaVAkRcczuGYdow0nBF9V1JHa8a7447RNBCkKWGhIortgRUjIS4sk4L4zCzTAvrvBJ9YLiM9Lsdx/2e5tBgixzdpUAMhfvTzO9+SOxtwapEKYnHKTMuhZgURWmMLjQonK70yZKq1iFimLnfsdvtUFqMMo3RNM4R24Qxzx2UsXImOWdkZ1sySoOzb4ziY/O1Uc/T3PLiGNiibNV8fagKIEA18YxaUyZkER+kckLkawinShKIJKdYNKk4surkYOmO7A53HG/vuD3u0UpkaJZQsEthVh0TDhMiIQmXR+7NF+6/L5LTi2/uV166P09s1yjnwjovnB4e+f4Pf2Q8nVBZfLW0VihrRKzVOowzVwWKtu3o+o5d39P3XdXtKvz4w0/c39+zzCvOtagi+omt0+gkSg/FNSiOmOgpy0qcBvzliXUurDSEXKpflNidO6uvNhJXPsnG69GKSnsWdCEQ8+vzoJKS+7PmiY2ZSUUY10Nf0SiHVop1rmiz8yOPT/fc3hw5HHbC3yuFEiNxXZkuFx5PT1ymi4yMckKVeg0y4uC80SXqu7qpJdzc3uDXFeesHABK41SVn8JgtMMoJ4VeBo9YLSQEpr7JJb2Atr5aLMsqvENjoAi4YJlnpnFiOS4oYF1F1NZ7EYE93tzw1dff8OVXX/L0+MBwOXM6nfn06RPruspYedPZfKGkkYs8y1CEaBvjC3j+huQV+xcfxFiyAN988w3DMHC5DAzDwC7Lbm9Dp5r62q+YKGrx8gbX8z/83QeWkPFRKDbBzyzjCZ1XXAmUuJJCQhfNru2wRRGbiNMav3hSyFUeDnSJqCx2Iz98ilzGmcaI/REKfFacV81aLMWJun6jNU5lcZqOkeAj1miONwfef/GOdRlZ5okYPG3jaKsMW6iC0VprmsZVgrbC6gJOocho9eff6f3KnkxaZKA+7deyZPvNn38uzwcwqMpYLoJOU7WC3LS8qNW5yCCQCvhcCEWDbXHdDlxLtz/S9nuaZodrOpQqZDwlJkLxhCys6I2EC8+OkH+qSyr87N599dCaOtcVTxuRJ0qCVowbRyzLE2p0NYYTiwNpuZ1427QNrj74hczT44nz5SKeWE3LOs/ksNDrRJ/3grYskbIYUq6q5eIwJyMxxGASY6uYZ32gtdrWXlzn+ZVknSgEFLHTBK2Yy9skqCzz29p51PT04jZVWtQxALwPpBKZ1pHT5Yl5FhFZuWEyJWVyiPhlYbxcuD/dc5kGQgxQ904KqrSWIARRCqOU+PbExLSMhOirFNgOhcJoEdbUaJq2Y7ffc7g54peJ7GfWUvBkYkVuXfeMrxze+zoKllFjiIFhGDmdT3Rdw9J1zKvndDozjqPYb1jL3d0d33zzLeTMPEq38/j4SM5F7lUnItLb+7KN3DddzxgFySt/uCnCb+NrGcnPc8aczzw+PnI6nbHWcPfujq7t8MFznEZOl514072oo5US477Wvb747v/2v3zLHKO4fYfIOg/MI4TZkMNCCoZ40xHe3eG/WQjrSvSeJSdBJhvDuq74daH4jEkdLgf82pGyyHkBz+oQBYoBZ8Vq1pDRJULKpJDwOqIcuMZwOO65eX9HeRCrnLbrRZuyFLwXHlxMqXJTFUYJidyaSt9Vf36g2a9OUM8/fZmc1D/3Wc+/c81n253yc85TKUJWFXMsSBnWIJ1WMS2uA0um7XYY16CsBe0oJFLRrMEzzCvTurCEUO3TZUy4kfV+OXl+q6T0MgoRYzXW1sW5gqZpiF1H9IHguSo5q1JYloVhGEQKygpZ9mpdoGtSQeRhfAjkrLCuEYHOuHLbavbljqbRpNARYiEosTrxuVCURikBQegKwijlGapdcq4w/e2gkMpWDCghW0dpHMEZljdIUFk969nDs3rA9pIlr9bfs9JNKQ0+rozTWLuj/Ew9KIWSBMUUQmCYRh4vjyx+EeHYDTpeNp2yBJVcXnKmpMISJkJc6LuG42GP0YbGdKim6hxaS7Pr2R1vmeaJ4RyZcmaMCZcyphH1iuuB/YqxAQ9MJRwH7xmGAedMNf5zzPPC/f0nhmGQTrGV7v7meOC869FGs64Lw2UQLciuo2lbrHNXhOqWfp8NDhOFzBUHVM+Q6xECxBSZl4nz+czT0xM3FQVora1jyIXH0wnr7M+OKqU0rmnY7Xavfj3/1//wBWtMLD6yLAvL7Fgmw+XkeHw4sa7iAKFRmJzJMRCD57J4LiFUqSGwOrBrItYoAo7seoppiUUTkybmIohluCYtUToJ5OKJRCIZr8qVEtR2LYfjgblKnrVty+GwR2vFPC+siyfG7T1R1dFckZR0wr/BhO/XJqiX8StfTbkiuuusnpp1lVgK1+RUciYVWerNsTAHiFTYrypXl95NDSJnhU8wr5FpXmUhWt+cTJWg2caG//Zv9jeLaTmhomH1Aa0yrbN0XUvyoZIfr6kCYww5FZSaJCnUUalSoo2Wqz8RCG8h16RcVJRD5OnCf/v9j1xOFw5WY11D7Hb0jeHgFKfzwhALS8ysaZXqq8juIdf3reSqsl7y9Q1VgHOWw75nd+g5fLihObSEN/CD+iXLrY765dfXgjzLvYco9BvzrIgdK4JyGzPnUshKYZuGbtfT9g3OW9m1pUJW6eqIq1HYIqAfmUmJkHHygXE58/HjD/SupURQybA7HHFNS4yecV5ZMwTlWIsjhhXGQGAmaSUP/xtI8whMXrpRATV4LnqkKEnGoq+38NPHj1wuF0KMNDkxzwPzPF4tW3J1fO66HcYY+n6Hc21VfUgygq+WMJKMxHIGXWotXK41LnqbzAiNYFlXLpcLh71A040xpAx9v6PruquZ4tXOQytc49gdX99fq2sMxtSkgKbRjn13IIWZP/x+5OlpqCotltZorNFYZ/j67kv+9ig+XCVnVh+YQyQmSywNgYZYHLFoQlL4pFh8YZgDlzUyBI9fPRc/4fF0OuCURnWmylRtiUqk6Hgxgdo4b/IhxZgG2kZGqEHQcZi/rAT1L4X673/6J7KDqpn4mqCy2E2kolizYg6ZKWRC0SRlMCpTlBZ0H0rkd0rBR5h9ZJxXfEi1cnghSVv+9Et4aav+VrH4CzoaYipYA10rlV1OpYJHDEYngT9bS0wZa4d6cNTZfZbRSIzxumtTFXyitBB5Uy6ch5mYP/HTT4ZWg7EWuo7jvufu2FNiIGAJJeH9yhoyMWdJULnUa1kNFatuIhV8stt12Nsd/b7jcHdE7RQzr6++zTVB/UItZMtWbDJDcli5ikLU6KsCviSmmpxqyd60LbvDgd20ow8doXh8kIPVGE3TWEwtITNCPRHytGIpAT9O3N//BBFIBlUajneept/h/co0jpxHz3nNnINiXQtDmJlCJCtxqtZvkfCv+1qx05hniCkQghgPlpKZ55lP9/eM01jtwhPzNDIOgyDzUq6axoqu29H1PX1/oGk6SfKCYJKJgLMyMs1RVtJ6ew3PlXtRG2pSUK2+dnUpJulIjcXZQt/v2HU7rLG1c5bnQmmNca6CKV77esqIzRKxSlyqdb/j6dGxzAuPj09QNNYautbS9x27Xc/X72/527/7O3b7HqMQVZ2USEWRi2H1kRAysaiq96c5jYkfHxa++zTw3ceVp3VlGRe8WigususcxrRYo3FaEYzGVlQwUO3lIxgtGpO1rCtZRhFt29D3HcoHkWb7Da7Xb5SgXsS/cP5vCuYlRlKKtfOBkGFJhdln1likg1JalHcLxAypaBKGJSUGHxgWz+SjLB/rfkuQP3Iz5+dtxM9e1Db+eatE9a7pME1DMIU0BNJ+h86KzrU8mTOLXcX9UymM0qx+vY7dUko/e/0b2ktv4BNtMK7BukZg6soQfCQSmJW4k6ppJYWAKZkvP9zx7Tff8ONP94zf/ZFlGoQgmGWUp+sBstv3tK3c2ClGpmEkRjmw5nVhXlacsWjz+tdUX8tssSAR3KkVXZEqoPvSQLNVDRbHzu5pnUC7FVQ+nqCcQPYm+7Rj3+4YbUcwKyZK5jNK4ZTFXAuGfN2llKRoEBX/HDJP9ycIv+f0FGgPd+imFyfYeWaZZ9Z1wftAThGjEvtecz6P3O07bvrX55WlFGsiKngfcM7goqvPq6hkzIsok6cU66Wv2+e6W45RCPTN2Mpuo2nY7/ccDoerdJlz4vO0WWDIqI/KCSzXFUFRBdBoa2hcw77tBcafMikmUkg419H1lrvyjnd3J/a73fVzZAqQmaeJ+zeYqUzDmZI8OQR8CChjaJodNzc3fPM3fwWuYZoCMQhAZAmFcJkZRrnGu77BdQ5tLDaLGWvb9sTgRbWkTl1yzjxdVjqXWLzmxwcZN8dssMqQcqj+fpa72wO7rsE9XRjGGW00OYuAdAyhunEn1uArwTkRU6zPkyWllZDib3KG/vYJ6p+JzDOZryQRKc1ZkxKsMbP4xOwTaywCekAsxGMR2+I1ZpaQGZfAZfYMS2AJUVTMEZCEJKhnpOFzy/qXE3euw6gGXzKTtYS2pTENRjuRc1IarUVgVwPTND53ftcHVs6EzTBPugNZbDvb4FoR3wRFCJ4YPUv2ItmDR1PorOabr7/i3YcPDNNCzollGZnGWRKUkrGIVjsad+Bw6Gmsk05rnljXlWEccU+Wft9yw57d/vWX0AqFrtdGBsGqupCKwO3GK7NWjDCDDjgcje7oXCsK+QpyTqQYrgekq0v13rb0piPoFVvBI1qBxaCrMklOiRQrnDkXkU7Soho9LQvLfM/HhxXVPJJ0yzSvLMtK3MAZSktJVRJ9C+fLxBd3O766ff0OKud8FV9VStQ4XHDVvdZTSmZZV9a6u5N7c1Pnf95bei9oyQ100fc9+8OeYbgQo79adzjnrlqIKWb8WqWKSrkKv2xGhl3Xcjwc6bsOo/QVrGONwTTidXY8HOjbjtZaQon1/cz4dX0Tsdgff/gjOidIUaYhbYM2Mmb+8OEOlOZ8npnnleCjGJFWhXxVIoqIUQalCxjF8dBxPB7JcZWdaO0WS4nsO5hmww/30Ooso9INa1tkZ9xYzX7XcTzsWH3AOlPl0grLMjOlJAjSUqTbLbIPl/12kWuekpzfv4Eaz2+SoH6J7Xv5exuXIadETpGU9VXNPBbwqTCtgXENrDETN5kSpYQzlAqzD5zHiZASwzjzeBoYF0+s6MBtd1OuBn7buG97JVyX4FeS7ht1ULe2oyRQKWDTilMR13f42NYldEO/29M2DVrBeDljKjptS1LXLqomKJDkZLRYkbeN43A84JqGnBNzVfP2q0cXUDmTfGQaZx6fTpwHOUi2h3njipE1ioTTiqbCylWWcZ9fPPfTwjyMhGnlH/7xb/h3779+9eups8z2BQJrsNrhdIMzDXYT1DWiIWeNIaqGBodRDbu2ExfnKvQqluZyQKSUSSGgE7Q49qancbqOYgs6C9xcDhSFjYg5YSnoYtEWdCuuo8uqGObAOo2secVXx9frU6I2SoRiTUmKtaUwjK9/oG67p02yyXuFWVeMNVd0XEwidmuqv1KpiibUxN40Dr+uLNPMNI4s84yzluP+wFPT4te17kFEKVtrResakkssSguA6gUBHblK9G3L3c2RQ79n1/dXdGDbNgLAiAFDHeNqQ1Gpvj6uKM3Xjv/jf/8/6RpDU5GZTdtxuLsVvUWleX9sueksOR8oKFzT0DUd7+4OvLvZ42yBMELJKGNRuafklpIClEzSRhIKNZmkCEme2c4ZTGmwea1anhmNFGMhiLmjTGJAazGdXZflCirSdbqQS8GvK8NloG8sJnk6FUH//yRB/TJ+efRvHlAxCTSXaiMci3RP0xKYFo+PaVsbsCH/YspMy0oumXGaGZeVyzizBEHzXRFaGx7+JTy3vPix3qTXJPVbX4R/JhyGkAIlekhiSleyJUdPWMV4UdelrlUiwqq2B6zGNry8bl8qN0lXYp1zVubFux5rDE1r8GElhwhRpHamaeHTpwd8DDw8PjFNCymm+s/UfysLd8IvC4sV7tq6rCQfrtVriTLKalXD+8OHV72WABYrB5KqFbl2WN1glcCaVV30mvqfUkrEXbUTEmJ1IRXH4nztpIL3rPMklttF0WmHMUoM8ao1yqaXWLKpenxCWI+aCj3TJBTRR6YQmZJnjuFagAmytd7w9TAOCdYgTtHz8voJSlfjxasrbX2pSlN5TPJ523OkavdDKWiladuWvusYzgPzOHJ5euJyPKKV4rg/sOt61nkCquVIiGgsVmuayrUpWotKf0X4lSIO084Y+q6jbRqcNddnumsarLNczoFlmsk+oLKY+YkwwKtfxmv8P//3f2G/a+k6MSltmob2046+72m7HuecMEqswTqHVZa+M+gSWceBpXhy9qDANo0owRSgcg5NI8rlkIgxkGNEZXEb2LtCEb1kTCo4I0i8kjMhBmKsbgUaGgfRJ6IOoKWwsq5Uk1dFYzIpzCTf0tiCESPoP3u8yYhv4zNIkjKoLNgrnwpLSIxLYF6FrV/YqqYCSjTkxmlhWVc0ktDWmK/cpw3FvvUS24/X4zy/gA//sot6g/Ah4P3Ksq6kkgjBMw4LD5/OPD7ck7LCGAcFnDXXccv2ML40YNNssHqAIonNWYw1UoUq6PoWpWEcBsKysqyTWKMvK8M8YX+0rF4MIH3ML/CWsjRdZ8/j/ROX00Xem6ps3LaOw+EdH96/46uvv+Tbv/lr7j68f/Xr6XRHaxyttTTGyTgkK0kYUUaiRQEpUzS1M0ooWzv5FMkxVmksqUCD90zjWEdUq5CXlcYqc6UwCIRdoxG0KcpStCAAKUKbSCmzxsQaYckFXxJJq2uCknexap3Ue1gmAZY5iqrFa8fLrmhLUkoryrZjq/fVRri9Sh0phbOOfb/jsNvzqXxkuFy4//SJXdex2+24ORw47HqmwbGuC2ENtWN1dG0nqDItqjXaaLGjKRDkAJEdYymiDxoD6zKxLjNNI2or4zjycP+J4TIQvBd4uRG9QHl8Xr+DejwNzH6haYwYimqZ+uSiiFEKa63BNVJUHg8Hbo9H9ruOfdsIAtAWmrah3+8YJ89xXLBa4ayh6XuatsEaRQkrOQZ0inQlcGMDrZGxYQ6FXSvWHijqyDZQiqhGdB1YbTnspBC7mp9qXUWDLV0TcMazax1NY7G/AYzvbXZQNSHkbRRAJebGzOwj8xrwIVZ+Tf0rAArR6CrhOrDbhDzZGOnXbovreO85Q/28U3pb/J7EGhJriPi0JYNCXBfiOkHw5FhYxjMlBZTWjJfheXEMP0uuv8yx285Aa00InmXRokCshGvlnGNRyHK5JHyK12tYkOq5VC7ZVifEmJjGGRkhJKzR7A97bm+P/O3f/Q3ffvs1X3zxga+/+Zr+8Po8k9btaK2jMRarTDVXK1Ulf1veK7ICpcXKJPgIGYIVzkmMYuRIEX7YskwMlzPD5YJffd21aLSpUw2VAV0JjHbD5pN1tdTOmRwSa/ZMITPHjC9iob2pW8B1Y/NclCktVImiBbTxBlp8Lx0Frl1S3a3FFCkVqLPpF9qanEoF9uz6ntvjkdY5ol85n5647zsa9w1dVw352o7oxWgwZkUArBZVbrupbVgtyjJyCKBKIYVIWBaaIojesFQCa92TzOPINI7klLBGbEFc3T++FYK3IK4MmYSsdjI+RuY5cBmCGGJWZKhrHbu+Zd/37PuOfdfQNBrXGrquFaDJ8Ybj8UjrDF3r6Hc7ur6jbRzjHPj0w8Dl8YwfzqhlxbYRVTypeGwRFGpOWaxfUoKScKbQt6A7i1Y72kZjrLyvMpVp6NsDt4eGXWfou+qW/taW7/9a/HPSIc8bkme4wrXOV5t1dmEJntkH1hh/tnt6PnlljBXzpgVXVSNefNVN3maTW6oj/SsketvbyM/VMzfrrTqoBD4JIlHbhsYFOhe56VrWmx3j7InrzHkaWX3g6fEkaKkXr1fQVNTxZnU2VVuCkqXzNE/M60KM8aqq7ZoGUx9WozVd29G8YI4vy3L19hFUWkVE1vFpLqCcYdf3fP31l/zH//jv+Zu//Xfs9iK7ZN7AYK9vjgI1VrLoLUnGyZINKnFYKZm/V8HSGNN1wb/MM8F7GmspORH8yjxcOJ0euVwugMIYS+MarHZgLSWDUgZrLNY2kp9SIlHE18uvrGFmConLEphjIhRF+kViehnPQBixSMio6lT9urH5Or2UHNKqCo9ebWAKG4Iho0gI5SGnyGF/5It377g9HvjBGJHzenzk7uaGrm3Y9z3Hw45luhC9dEQ5RsIiFAWrDUVTO7NCY8DHILqA68p0vmD30Cp7HcXO04i2Fu9XlIL9focqhXYbBzonKM5Xv5qwPzTVF0wQkimVTUGOlBOrFx3CzXNJrjc4q3FWfJ2EG2VpGlclznr6xtF3jST8vqXvWmJSnAbPw3nl8WkixcDaKKwV2aO1s/i5w7lNGzJhVKZxm3FiS+Ng13UVIGWxxomElNux3x1omw5rtez9y5//iv5PJ6hfJqU/laS2ZCQq53LB9XaY1vY2lMLiA8u6yoFR8gskXnn+Kkqkkq6dlbqq7NX+409JQF6z0ItXVH72x2/VTsWsSGgyBmMcjWvZ94mS9uhSOI8Tw7QyzDM+e5wpHA89OW521tU0LG9qD0b024x5bs2r2kHOIsCpreidFQSd13Ydx8Oe4/EoHKycmOeZaZoZp6mqVy/EkCipvJjhywjxeHPgyy8/8O23X/P1119ijL5CtV87rO6kgi9UIE4hJ+R1X9/+ugiuXlupKmGU6s+06b3FFK/KHZfLRTyNuk6cbW3d8RlJ2kZbrG1xrqEURYyZNYt0lV8Do88Mq+yefIRYZBdSfpak6j5RPUv7SOMvN+hb3KJbgpKXUV/HFVgkr+26piyQi/BllkkUHm4OR96/u+OrL7/k448/Mowj0zAwDQOH3Y79fkf0t4yXEzEIotRsCv3VgVhXSw8lCqf44Ikx0lqLKbJbuu5SgmeeJ5SRBJWLoPratqVr2+vkYOukXju6TlOyIifhGMYKkMk5yzOM7NlCrMCclMQqRP5EULtKdn9Ga/lenKNrLF3j6Nrm+qG0IcSCD4llFRDF7AxNK/Joh31H8J4YWoQkUbBWTFRVdjSNomkMfd/RuBZTgUbONrSupXPirLwdrb+F9Oaf5R36lzun7XNKZe5TfaKEh5KVIWSBjY+rZ/aCta+je/nQsnDeEpAMTp5ZTT/fNtVe7SXwocoEyRfbKlP1i8T0NptTVYVAjdFY6+i6jNWKxkl1dLMsjNPMMM2M48Q07QWCGqLAmSvCTLgmiSjjeUrRaGcxGhpnce2t7EFKrofmyjIvxBS5uTnyzbff8u79HYf9npQjyyzd0zQt3N/f8+nTA8NlZJ6Xal0hVVjXd7x7f8u7uxusgeRXohJ491uoRZOkui8lVxLodr6ra32ipL2ULjsXVNE4Y2S5bjSQiSmwrJ5hmjiPI8M8MXuP67pqe6JRRqOLQlVjOTn4nBRQKeNXCGtkXAJPw8J59sxhc0quCSi/6PRRPwP51F4YUY0XyMVrxy8TlFaQlbomdFWe3QHKtesrPD4+8ofv/sCHu3d8+Ku/5t/99V8xnE5894ffc3o6ibXI4cCHDx/oXcN4OVPqv2Wtpu06bOWqNc7RNK0UWZUwnGIUkETbse/37PueopCOd5rAGFbvCSHITtWvFCWqKD4EnJND+rVDK0lMPsRqZxMJMRPWSClJTFwbTeOqxFhyVfpJYOk+RkLln8WU8DGh15VRC8DHGCvjwU0CbbuvSu1CraFtG7q+5XZZJEFG2akaoG8Mdt8Qmx3aFrTV2OqSYKxQNcTVt5CUJ6dISYpcP/7c8asS1IbS+bWha5tqlKpzV/HYWbzwfEISPtO0+CpVlNjkfUSqBzlgrknq+ujW+Plruo6//jso+S+/n5cfb5OgjNYyxjAG5RxOQXGW3DXEfcL7nmXZMS8Ly7ywrL56PMUK/5XEJEvOSIiJkMrVmRcjyDBlGzSQ1kCMK/OyCAIv1THNC/LvZr7XVejrMs9M/VQ9ewCy/HnXcDzsuLs5sOtbSgws01hhqhrzBiMpkbaqd0rt0rWyoDebhWfxYkVBa43Thr531T7cATLiHOeJZVnwMYKxNF1P03Y0TSuj08o5UUqY/8YAlW+iioxsFh8YpsBl9MxLJqZaZKmtSFJcoXDbqLq+TrGrKXUnmEnqDbQNX+yggOvYSVGeDRS3gm8bVubM5XTmh++/58v37+mswy8LXdtw2O1IPuCMwWrN+7s7dPUqc1oxDAMlJ1pbx3AKGmtpraNQSFkI49TE1TeybzFayy5nHPn08SNZK07nE9OyMK8r0zITY8RYgU3byrl67bC6kEiokpC5s0i8idRQEWVwuwnjys49RYjJiIVRrvvgXM+5LJ8T9TalioCcs0ZrnBGYvXNiNKiqKexWYJQsPFRlRJm8bxSdachlJ0WRKigj3CgtnBSKSrKzKgqVNSlq0l9Cgvq3hJDqpHOySg7LEBLDvJBTZHILMRdmn5jmtULLfzbwALgmp/pF/8V/82cjiRcfdSLx82nfG4fV8j+DFS9IV6WfsiPlTEotMfbEEGoyipU1nuufC0clxEDwz4lqXQPD7Hm8rAxepCFD0cSQCSHhFzEyLDkzDhM/fP8Dp4dHGX0YWUqbOgKJUST5rVEYLRevdYbbQ8+H2wM3u47GFNbpIjIudXzizOsnKFWTLXC1b9e5jn+LzMlz3TlqBGrbWLg5dtzd7tj1PQqxmRiGkTVEtHXc3L5DKcW+cqW26n7bhSqFWN4nfzU19OvKOM6Mg2eaMiFAFrCzbFPL8/VRL5KTrMqKdHryTQmnSr9+gvo5CEfGwnqzFNn2UuV5klGdHljnmU8//cT/VQo//fGPVUcy0bcth7/6lsN+x7u7G7784j191wlhtGv5p9/9jsv5DHX0KoTdRPSxjl8TSkmX5ZRCNwJIiUhx61PiMk/4nDkPA5dxYJhlTC3FtfAwBXH4+kWp1YpsNDihkRstEmdGSxcTYxZ/sCyKObl6lsWSSCVSVBYpIi1AlM36Rm8WOC/WH1qrq5Zf01ja6n7Qdx27XUdnLWSx7NBFYXTCNQpoAE3MohiRt/Fi8uQcSKWKBxhLyYaUBcDyW4gd/fYJagNHFFGOiLmwKBlXrKvBWiWGZSmzBFkabpTFf0v8fF7+6//ea0drwClF0Uaq/6zY4LuiYp5IyZJbJz/PkRRbNsKziMSK/EiI4kQcQ2BZAuO04OyIGwKXkChedismBxylWmcodBaORV4mjDJVXd1WVrkmxYAlcmgN7qZHKyUkybsD7447ds5gSqJETwkKpRq0Fin+1w5r9HVsqpQS3xzk8MxF1wdfrpum0DlN1xj2XUffthgUcfEs08wyTqiU2TUd1jWSdJUWJ2N4MYYu5FQNYyoUOuXMMosb6bx6YirksiFNS82hQihX16+nruOyLbQW7UCjTDW4et345XOxpSKtFbbuieTXuh6Ios4ut5diGkc+RlFE76q4qDOGFCPzNDFPE33X8cWHD+QYGc8XcpTpQAyh7l+oz0dtHbj2mrJ38p41r5yniWFZSEoJTWDbvxpRMYyVorEVwP+GYdD/dEgylt1TFyOxKkpIUSlq4SlBiJllTXW8q5C5uUYnEchWdS9/JdHqbTT8XOwYpWmc6ER2naPvWrquoW8FRLHrNVYHVJopIYAKlBIrj9KKOop2glLdiqRSKHWvu4nrJ2nkfpMt6W+aoBQFXW00yraELpmcFWuIMvLT11tN3pwiI7zy4uH/HzVo/mW19/L3Xo74XiL33poH1Wnh48gcx1CyLHtLViQjN6PwTxQla6lWrH6RweW2yBWtllImhsrdqQaGbTOiH0fKupJyIJZAbxWtMlC0jADjSo7VPFErklZEozB1RGg13O4s5iB7ll3XcdjvuL3paQ3oFDEpYrLFkrBKi631K0djTQWISHK1Sl1VllMWmSyf5B7UFNrGsOsauq6hNRaCKHYvlxE/zOgMx7anbeVaknLl0lUX2SKVfsnPmnElQ0yZZfGMo2jryXhcrEw3OxNRjK6eaPw8QW0WFFpD66wI3OrXtyj+JRxbIfYkm9uqrVbv1sgIqWkb2ratB1km+hXvPQpwWpGiISjFPEd8CNze3tI0DV99+ID66isePn5iXRfGcZRxc86gxZZERouVY2UE1p9TxsfAsng+nZ44DQNJa5q+5/b9O9q+xXUtelmEd/liN63e4Jk/dEcK8n3FqmcoTsXCh/QxEWJmXiJqWCm6gLJoq8QZN4PKopz/LJwrJFkBPNf9pTaYOgbtGsdu79jtWkH4tY6+sXStplEeUiJtYLQinVzRcs85rbFWKBW5ZNl7rdJIRCtms7nKGP8WV1O9tZr35/gcn+NzfI7P8afi9Uuyz/E5Psfn+Byf438gPieoz/E5Psfn+Bx/kfE5QX2Oz/E5Psfn+IuMzwnqc3yOz/E5PsdfZHxOUJ/jc3yOz/E5/iLjc4L6HJ/jc3yOz/EXGf8fEf1qqXeJGYMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 22;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/plot_failurecases_basic.py\\n# Append the folder that contains the\\n# helper_data.py, helper_plotting.py, and helper_evaluate.py\\n# files so we can import from them\\n\\nimport sys\\n\\nsys.path.append(\\\"../../pytorch_ipynb\\\")\\n\\nfrom helper_plotting import show_examples\\n\\n\\nshow_examples(\\n    model=lightning_model, data_loader=test_dataloader, class_dict=class_dict\\n)\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/plot_failurecases_basic.py\\n# Append the folder that contains the\\n# helper_data.py, helper_plotting.py, and helper_evaluate.py\\n# files so we can import from them\\n\\nimport sys\\n\\nsys.path.append(\\\"../../pytorch_ipynb\\\")\\n\\nfrom helper_plotting import show_examples\\n\\n\\nshow_examples(model=lightning_model, data_loader=test_dataloader, class_dict=class_dict)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/plot_failurecases_basic.py\n",
    "# Append the folder that contains the\n",
    "# helper_data.py, helper_plotting.py, and helper_evaluate.py\n",
    "# files so we can import from them\n",
    "\n",
    "import sys\n",
    "\n",
    "sys.path.append(\"../../pytorch_ipynb\")\n",
    "\n",
    "from helper_plotting import show_examples\n",
    "\n",
    "\n",
    "show_examples(\n",
    "    model=lightning_model, data_loader=test_dataloader, class_dict=class_dict\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08ca97ed",
   "metadata": {},
   "source": [
    "- In addition to inspecting failure cases visually, it is also informative to look at which classes the model confuses the most via a confusion matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f0b7e651",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATQAAAErCAYAAABQAX/RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAB2eElEQVR4nO2dd3gUVReH35tNISQhBUIJLfTeCb0joNKR+oEIqIBIU5SuKNIUURFUxIYISpMmvffeexHpNUAIJASS7N7vjzsJS0jZ3WwQw32fZ5+deubO7OyZc8ucn5BSotFoNOkBl3+7ABqNRuMstEPTaDTpBu3QNBpNukE7NI1Gk27QDk2j0aQbtEPTaDTpBtd/uwDpDeHqKYVHJqfbzZ0nm9NtAtyJjHG6Td+MaXNbCSHSxK6nKW2e6zGWtBkSZcH5diOjLU63CZDBNW1+s4snj9yUUgYmXK4dmpMRHpnwKNbB6XaHTu7vdJsA8/dec7rNl0unjfPN4JY2f45iAc5/AAFcv/8gTexGxZqdbnPnhXtOtwlQLJtnmtjtUyP/+cSW6yqnRqNJN2iHptFo0g3aoWk0mnSDdmgajSbdoDsF0pA+/6tNl+ZVkMDRv6/S/ePfGdHzZV6uVYLoGDNnL92k+8d/EB4RBcB7XV6gS/PKmC2SAePns2bHiRSPMX3UQA5vW4ePf2Y+nLnysXWrZk5l/uSxfL58L95+AXaVPeb+PY7+PpaIq2cQCEp0HMbNY9u4cWgzQrjg7uNPiU7DyeD3REdTkvw+biDHtq3H2z8zg39dEb9805+/snn+dEwmV4pXrUuztwbbVda0ugbW3Lsbzvjh/Th76jgIwaAxkyhZLsRuO99+9C77Nq3BNyALE+atAyAiPIwvB71F6JWLBAbl5p3PpuCdyc8uuz+OfI8DW9aSyT8zY2avAWDWxNEc2LwGk5sbWXPl5Y0PP8fLx9cuu7HRD1n4QWfMMdFYzGYKVG1Ipfa9eXDvDqu+eI97Ny7jkzUnDQdMIIO37bZnjhnIkW3r8fHPzNDf1L2w7Kev2PbX7PjfqWmP9yhRta5d5f1PRWhCiGVCCD8795kmhGidRkVKkqBAX3q1q0X1zl9Qsd2nmFwEbRqWZ+3Ok1Ro9ymVOnzG6QuhvN/1BQCK5stGm4blKN92HM36TGHi4Na4uKTcq1e18Sv0+XLaE8tvX7/Cid1bCMge5FD5T8z7kizFq1Djg9lUHfIbXtmDCa7fiWpDZ1B1yHSylKzOP8t/tstm5Rdb02P8L48tO71vO0e2rGbQL8sYPH0lddu/YXdZ0+oaWDNp9BAq1azPbyt28vOiTeQtUNghO3WatmXoNzMfW7bwl28oVakGXy/eSqlKNVj4yzd2263RpA3vfT39sWUlKtdk9KzVjP5jFdnz5GPJNPvtmtzcaf7Rz7T7YgFtJ/zJhQNbuHbqIPsW/EiuUpXp+M1ycpWqzP4FP9plt/LLrek14Zcnltdt243B05YyeNpSu50Z/MccmpTyZSnlHetlQvFMnoeryQVPDzdMJhc8M7hzNTSctTtPYjarMT+7Dp8jZ1b1VGtSuxRzV+0nOsbM+Su3OXPxJiEl8qZ4jELlKpMxkaf53Imf0OrtwYD9Qx1ioyIJO3OAnFWbAuDi6oZbRh9cPb3itzE/jAI7x4UVKFvpibJuXTST+h174uruAYCPfxa7y5sW18CayIi7HNy9ncatOwHg5u6OTyb7Ip04ileogrev32PLdm9YSe2mbQCo3bQNu9evSGTP5ClavjJeCa5BqSq1MLmqSliBkuUJu27/EB0hBG7G724xx2KJjUUgOLd7PUXqtgCgSN0WnN21zi67BRO5F5zBM1vlFEIsBHIDGYCJUsqpQohzQEXAG1gOrAeqAi2EEEeB74G6QBjQXkoZmsDmh0BTwBPYBvSQUkohxAZgp7GvH/C6lHKzEMIEjAPqAB7AN1LK720p/5XQcL6asZ5TS0YQ9TCGtTtOsHbnyce26dysMvNW7wcgZ1Zfdh4+F7/u8o07BGV17E9zcPNq/AKzk6tQcYf2v3/rMu7efhydMYp7l0+TKXdRirR+B1cPT04vnsKVXctx9fQmpO9kh+xbc+PiWf45tJulP0zAzd2D5r2GkKdYmVTbTe01sObKxfP4BWRm3JDe/H3iKEVKlKHPsDF4ZvRKeWcbCL91E/9ANXbPPzAbd2/fcopdazYvnk2lBk0d2tdiNjN3YBvCr12g1IsdyFa4NPfv3MLLXzU3ePkHEhV+2ynl3DR/OrtWzidPkVK07D2MjHY+OJ7JyMagm5SyAsqB9RVCZE6wvggwXUpZTkp5HvAC9kkpywMbgRGJ2JwspQyRUpZEObUmVutcpZSVgP5W+74OhEspQ4AQ4E0hRL6ERoUQ3YUQe4QQe2Ssag/z8/GkSe2SFGs2kvwvfoiXpwftX6oQv8/Abg0wmy3MWr43yQvgSPLN6AdRLJ/2Dc3efMfufeOPazZz7+IpctVsRdXB0zF5eHJutarOFGrWk9qjFpGjYkMubJrn8DHisJjN3L93l3emzKfZW0OYNqKPQ+dtjTOugTXm2FhOHztE8w5d+WnhBjJ4ZuT3qROdYvtpsPjnSbi4ulLtpZYO7e9iMtFuwnxem7qO66cPc+vCaSeXUFGjZUdGzN7AoF+WkilzVhZMHm23jWfZofUVQhwEdqAitUIJ1p+XUu6wmrcAs43pGUCNRGzWFULsFEIcBuoBJazWzTe+9wLBxnRDoLMQ4gAqgsucSDmQUk6VUlaUUlYUrmpkdL1KhTl35TY370QSa7awcP0hqpRWvrBj4xBerlGCLsN/i7dx+UY4ubL5x8/nzOrH1dC7iZxC8oReOs+tq5f45NWXGdqyBndCrzG6S1PCb4WmvLNBBv+sePgF4hesLk+2snW5e/HUY9vkCGnI9QMb7C5fQvwCs1O6ViOEEOQtXgbh4kJkKp/2zrgG1gRmDyIwexDFy1QEoPaLzTh17FCqymiNb+YshIVeByAs9DqZAhI+ux1ny5K5HNiylp6ffJ3qV8c8vDKRs2QlLuzfQka/zESGqesZGRaKp6/jHS5xZAoIxMVkwsXFhWrN2nP+uP3X+Jl0aEKIOsALQFUpZRlgP6rqaU1kCmYee8wLITIA3wKtpZSlgB8S2HxofJt5VBUXQB8pZVnjk09KucqWc7h47Q6VSubF08MNgLohhTh57joNqhZlwGv1af3uD0Q9fPQe5dJNR2jTsBzubibyBgVQMHcWdh9N9O2OZMlZsCjjl+1hzIItjFmwBb/A7Ayb9he+mW3vjfTIlJkM/tmIvK6Of+vkHryyBxN542L8NqGHtuCVLeU2vpQoVbMBp/dtB+DGxX8wx8Tglco/hzOugTWZA7MRmD0nF/5Rkcm+7ZsILlAkVWW0pmLthmz8ay4AG/+aS0idRk6xe2jbBpZO/47+E37CI4NjryBFhd/mYaR6sMY+fMClQ9vxz5mP4Ip1Obl+IQAn1y8kOMT+BvyEhN+8ET99cNNKcuS3v+PlWW1D8wXCpJT3hRBFgSo27OMCtAZmAf8DtiRYH+e8bgohvI1tU6ozrQTeEkKsk1LGCCEKA5ellCk5U3YfPc+CtQfZPvM9Ys0WDp68xE/zt7FvzmA83FxZ8k0vAHYdOUffsXM5/s81/lxzgP1zhxBrttD/sz+x2PBy848f9uXUvh1E3AljcLOqNH2jP9WbtUtxv5Qo2uZdDk/7CIs5Bs8sOSnZaRhHZ44l8sYFhBBkCMhO8fYD7bL568d9ObN/JxHhYYx4pRovde1H5Zfb8Me4QYx77UVcXd3439DxdkcSaXUNrOn3wThGvdeDmJgYgnLnZfBYx9oPvxrci2N7t3Pvzm16NqpA257v0aLr23w5qCfrFv5Blhw5efczm5ppH+PbYb05sXc7EXfC6N+4Ei27v8uSad8QGx3N+Lc7AlCgVDm6DBlrl93IsFDWTR6KxWwBaaFAtUYEV6xD9iJlWTnhXY6vnY93YA4aDfjCLru/jOjL3wd2EnEnjA9aVuPl1/txev9OLp0+hhCCgOy5aP++/VVO8SyKpAghPICFQE7gJBAIfARM41GnwBKjLSxunwjgS+BlIBxoJ6UMFUJMM7adJ4QYBbQHzgEXUdXWj4xOgfeklHuEEFmAPVLKYKP3dBSqI0EAoUALKWV4UmV38com0+Ll9K/0y+n65XQD/XI69KmRf6+UsmLC5c9khCalfAi8lMiqYOP7JlAy4Uop5QfABwmWdbGaHg4MT2S/OlbTN+OOI6W0AEONj0ajecZ5JtvQNBqNxhHSjUOTUnr/22XQaDT/LunGoWk0Go12aBqNJt2gHZpGo0k3PJO9nP9lgvNmY9TU95xu9/XXxzndJsCptRPSxG5aEPkwNk3sht93vlAMwJV7D1PeyAFalUh99pCEnL2dNkNMtvx9J03sJoWO0DQaTbpBOzSNRpNu0A5No9GkG7RD02g06Qbt0DQaTbpBOzSNRpNu0MM2nhJTPx7A/s1ryRSQmU/nrAVg5+ol/Dn1S66cPc3I6X+Rv7htqaf7dKxLl5bVkFJy9O8rdB8xg8LB2Zg0rD1enh6cv3KLrsN+5V7kAyqWyMvkD1T2DyFg9JRlLF5ve+K8K5cv8k6v1wm9fh3h4sL/Xnud13v0tv8CPCW7Dx884NVWjYiOfkhsbCyNGregz/tP5CNwiBa1S+Pl5Y2LyYTJ5Mq0hevttpFWylfWOPPaht+4yoLxA4kIC0UIFyq83I4qLV/j6KblbPhtEqEXz/Dm1/PIWbiU3bYtFjOrP+qEp38gtd75miMLpvDPxgV4+KhEp6Va9yaoTGJ5WpPmmXFoQogWwCkp5bE0PEYwCdIOWa37EfhCSnksTrvAyLzhFGo2bUODtl2YMqJ//LJcBYvQf/xUfh5j+80bFOhLrw61KffKaB48jGHGp91o06gCPdvVYvCXC9iy9286N6/CO6/VZ+S3Szl65grVO36G2Wwhe5ZM7Jw9hKWbjsQLtaSEyeTK8JGfUqpMOSLu3aNx/arUrF2fwkWL2XsJnopddw8Pfpm7FC8vb2JiYujUogE16zWkbIVKqbIbxzcz/sIvFRllK7/YmpotOzNzzKOxitbKV67uHtwLS91t58xr62Iy0bD7YIIKleDh/Qi+792K/OWrkzW4EO0+nMxfX3/ocDlPr/qDTEH5iImKiF9WuFFHir7U2WGbz1KVswWQekULB5FSvpGWzrRY+SfVfnLmK0RQcAG7bbmaTE+oSRXKm5Ute/8GYN2OE7SoXxaAqAcx8c7Lw93N7nz92bLnoFSZcgB4+/hQsFBRrl29bHeZn5ZdIQReXipPQWxMDDExMalOPe1M0kr5yhpnXlufzFkJKqRSsXtk9CYwdwHu3bxOYJ6CZMmd3+Ey3r99nSsHN5O/VguHbSRGmjo0IcRCIcReIcRRIUR3Y1mE1frWhm5mNaAZMF4IcUAIUUAIUVYIsUMIcUgIsUAI4W/ss0EI8aUQYpMQ4rgQIkQIMV8IcdpI4Bhn+10hxBHj09+qWK5CiF8Nu/OEEBmt7D6RME4I0UkIscso1/eGEtS/xpXQcL6avpZTyz/h7OrR3I2IYu2OExw7c5UmdVTY36pB+cf0CUJK5mXvvGHsmTuUvqNn2RydJeTihXMcPXyAck6KdtLKrtlspuULValROh/VatWjTHn7BYETQwhB3y6teK15HRbOmuYUm/BI+eqLHi2Z1Kc9F44fdJptZ17bsGuXuHrmGDmLpl6Va//vn1OmXT8SKlCeXjObFcPbsuunj4iOtF9TI60jtJSUmwCQUm4DFgPvG7n7zwDTgUFSytLAYR5XcYqWUtYCpgCLgLdRCR+7CCEyCyEqAF2Byqj03W8KIcoZ+xYBphp27wK9kiq8EKIY0A6oLqUsi9Ib6JjIdvGqT/fCnCPnlRR+Pp40qVOKYk1GkL/hMLw83Wn/cgg9PppJj7a12DpzIN4ZPYiOeZTVdPeR81RoPZoanT7j/W4N8XC3v6UhMiKCHl06MGL05/hkcl6G17SwazKZWLBmO+v3nuTwgT2cOnHUKXanzl7B9MUb+fLnucyb8SP7d211it20UL4C517bh1GRzPmkDy/2HEoGr9Rl6rpyYBMemQIICH68QlawXhsaj19Mo5GzyOCbhQOz7EvrDWnv0FJSbkoUIYQv4Cel3Ggs+hWoZbXJYuP7MHBUSnnVyHL7j3GcGsACKWWklDICpehU09jnopQy7k5MSh0qjvpABWC3ofxUH3gizrZWffLxT736TXLUq1yUc1ducTMsgthYCwvXHaRKmXycOnedpr2+oXrHz5izYi9nLz2pcHTy7HUio6IpUdC+dwFjYmLo0aU9LVu356WmLZx0JmlnN45Mvn5UqlqTLevXOMVeYLYcAARkDqR2gyYcO7TPKXbTQvnKmdfWHBvDnE/6UKpeU4rXSL2Ay83TB7myfyN/DWjM9u+GcOP4HnZ8P4wMvplxcTEhXFwoULsVt/6x/0GUZg4tGeUm60dPQiUnW4l769diNR0370ryUtkJH33JPQoF8KuV6lMRKeVH9hbWmVy8dptKpfLhmcFQk6pUhJNnrxPor56aQggGv9mIH+YpjZi8QZkxmdTPnCeHP4WDs3H+iu1CtlJK3u/bg4KFi/Jmr35OO4+0snv7Vih3w+8A8CAqiu2b15OvoP3qQQmJuh9JZMS9+OldW9aRv1DqOjDicLbylTOvrZSSRV8MJUvuAlR7pVuqbMVRuk0fmn25gqYTllL1rbFkLVaRKj1GE3Xn0UP40r51+OZ0oH3ZKSVMnKSUm64bVbmTQEsgTp3hHuADIKUMF0KECSFqSik3A6+ixINtZRMwTQgxDuWUWho2APIIIapKKbcDHXhSHcqatcAiIcSXUsobQogAwMcQNraLyUPf5vieHdy7c5veL4XQuscAvDL58uv4D7kXdpvx/bqQt3BxBn8zM1k7u4+cZ8Ga/Wz/fZBSkzpxiZ/+3MqbrWvQo50KYhetO8D0RUqytFq5/LzXtSExsWYsFkm/MbO5dSdF0apHx9u5jflzfqdo8ZK8WFu1wwwcPpJ6DV609xI8Fbuh168zpF93zBYzFouFF5u2om6DxOQp7OP2zVAG9eoEgDnWTMNmr1C19gt220kr5StrnHltLxzdy6G1i8iarwjfvdUMgPpd38UcE82ybz/hfvhtfv+gO9kLFOPVMT87XGaAg7MncsfQf/XKEkTFLsPstpFmqk/JKDdlAT5FqS4dAbyllF2EENVRWpkPURJzPqg2soyoqmRXKWVYAoWmOsZ0E+OY1uveBeIeKT9KKb8yhm0sQzm8asBp4FXD6Vrvew5j2IYQoh0wBBXNxgBvJxA4foz8xUvLUTOWpeLKJY5OH/TfSx+040pYmthNi/RBP++54HSbAMevRqS8kQPM7lL+6ao+JaPcBInoYRrtWgmHbTyhx5lAoWkDsCGJdV8Aj7UqSinPJXKMxPYNtpqezSNFdo1G8wzzLI1D02g0mlShHZpGo0k3aIem0WjSDdqhaTSadIN2aBqNJt3wzGTbSC9ERlvYdfFeyhvaSVoNryj8knNS61jz4pvtnG4TwMfTLU3shkVGp4ndtCrvvYfmlDeyk2q5/ZxuE6BusOOZSZIjqWEHOkLTaDTpBu3QNBpNukE7NI1Gk27QDk2j0aQbtEPTaDTpBu3QNBpNukEP23hK3Au9yqqJQ4i8cxMhBCUbtqVc01cJ/ec466Z8TGz0Q1xMrtTt8QHZC5d26BipUfsplCeQ30Z3ip/PlzOAT6auZPIslV2pf8fajO3bhFwNR3Ar/D7tG5Wjf6c68duXKpidqp0ncuj0lWSPs3JwM9wyZAThgovJlTrDp3Nk7kSuHdqMi8kNr8BclOv6Ie4ZfWw+b3P0Q1aO6oYlNgaLOZa8lV6gzCu9uH3+JDt/GU3sg/t4BQZR460xuGe0Pdvq2qHNcfXIiHBxQbiYqDlsOgBn183m3Ia5CBcTWUtVp/grfW22GYfFYmblhx3J6J+V2gO+5tC8b7i0fyNCCDJkCqDymx+T0T+rzfbCb1zlz8/e597tUISLCyEvt6Nqqy7cv3uHOaP7EXbtMv7Zc9Ju+Nd4+vjaXV6Ai2f/ZvS7b8bPX7t0ns59BtGqcw+H7MVx724444f34+yp4yAEg8ZMomQ5x9KmP1cOLSnVJ2vFpxT274JKK2S3JpiLyZWaXQeStUBxoqMi+WNAa/KUrcqWXydQuV0vgivU4uyejWz5dQKtR/9qr3kgdWo/py+EUuXVL1VZXQRnlnzA4g1HAMiV1Zd6lQpx4eqjdDizVu5n1sr9AJQokJ2547uk6MziqD5gCh4+fvHzWYtXpnirt3ExuXJ03iROL5tGidZ9bD1tXNzcaTD0B9wyZMQSG8OKT7oSVKYGu38dR4X/vUu2YhX5e+NCji39lbJt3rbZLkDVAd/h7v2orDdP7uH6wU3U+uB3TG7uPLzrWGbZUyt/xzcoHzFRKjddscavUbq1KtvJVb9zdOFUQrraPkbQxWTixR5D4tWZvuvVkgIVqrN/1Xzyl6tGrfY92DTrezbN+p5Gbw50qMy58xVkygIl3Wc2m/lfndJUr/+yQ7asmTR6CJVq1mfk19OIiY7mwYMoh23pKidJKz45UxDFKyCQrAVU5iJ3Ty8CcuUn4tYNEIJo46aOvh+BV4DtT+WEOEvtp25IIc5eusWFa3cA+OydZgybvDTJPPdtG5ZlzqoDjhabrCWq4GJSz1b//CWJCrtu1/5CCBX1ARZzLDI2FhDcvXqerEUrAJCjZBUu7F7rcBnjOL/xTwq8+BomN3cAPDLZn1lWKR5tIX+dlvHL3DwfRY6xD6OUiKodPKHOlKcAd29e5/i2tZRroI5TrkFLjm9zTjry/Ts2kSNPMNly5k6VnciIuxzcvZ3GrVXtwM3dHZ9MjkWQ8JxFaAauQohfgXLAKaAzKuljXHLHCFQetUbAACFEIVSCx6vG9g8TN2s7d69f5sY/x8leuDS1Xx/Mgo/fZPMv45HSQttxyWestZXUqP20aVCGOatU9NW4ZnGuhIZz+PTVJLdv/UJZ2rz/i022BYJtX/UGBPlqtyS4VqvH1p/fuphcIQ3sLrPFYmbZ8A7cu36RIg3aEViwFH65C3Bp3wZyV6jL+Z2ribx9zW67O77qgxCCPDVbkrdWSyKvX+D26QOcXPgdLm7uFG/dD79g+9QX980cT9l2/Yh5cP+x5QfnTubc1iW4eXpTb8hUu8saR9i1S1z9+xi5ipYhMuwmPpnVQ9Inc1Yi79iefj05Ni5bSN2XW6W8YQpcuXgev4DMjBvSm79PHKVIiTL0GTYGz4xeDtl7HiO0lFSfvIAjUsrKwBngY6A60IAkkkNaqz5FpVAFiY6KZOmn/aj9+hA8MnpzaMUsanUbzOs/raNWt0GsmfxBKk8vdWo/bq4mGtcswfx1h/D0cGNQl/qM/H5VktuHlMjN/QfRHPvHtqiq5uAfqfvBDKr1m8g/6+dx89QjoZGTS3/GxcWVXJXtT5nt4mKiyZg5vPL1Sm6eOULYxb+p+ubHnFw9m6XDOxDzIBIXV/teRao+8EdqDf+NSn2+4tzGudw6tQ9pMRNz/y7VB/9MsVf6snfqELsUmi7v34SHTwAB+Z68lcq06U3zr1aQt9pLnF7jWE7Rh1GRzBrZm5feGkYGL9vbIe0hJjqa7etXUqtR01TbMsfGcvrYIZp36MpPCzeQwTMjv0+d6LC959GhpaT6ZAb+NKYrAxuklKFSymiSeIXMWvXJM5kqiDk2hqWf9qdI7SYUrKqikOPrF8VPF6r+ItdPH3b0vIDUq/00qlaUAycvc+N2BPlzZSZvUAC7ZrzDiQVDyJnVl+3T+5Mt4NEfpU0D+6qbnn6BgKqq5ShXh7CzStnnwrYlXDu0hQpvfJKqfPruXpnIVqwiVw5txTcoHy8MnkLjUX+Qr+pL+GTNZZetDFZlzV62DnfOHSODX1ayl6uLEAL/fCUQwoXoiDs22ww9fYDL+zey+N2X2fbtYK4f3822KY/nzg+u+hIXHagem2NjmPVxb0rXa0aJmkqdycs/C/du3QDg3q0bePml/t3K3ZvXUrB4KfyzON48Ekdg9iACswdRvIzKpl37xWacOnbIYXvPo0NLSfXpgZTSnMx6xw4qJWsmf0BArvyUb94lfrlXQFYuH9kNwMVDO/DLkTdVx0it2o9qD1PVzaNnrpH3pY8p2nIsRVuO5fKNcKp2/orrt9XL90IIWtUvzdzVB2yyHfswipgHkfHTocd2kClnAa4f2cbpFdOp0nsCrh72C4E9uHs7XpQ2NvoB147sxDcoH1GGFJy0WDi86AcK129js83Yh1HEWpX15rGd+AQVIHvZ2tw6uQeAiOvnsZhjHus0SImybfvSYuJKmn2xjGq9xpGtWAjVeo7m3rVHujuX920kU1CwzTZB/fYLJgwlME8Bqrd+pM5UtGo99q9eAMD+1QsoVq2+XXYTY/2yBU6pbgJkDsxGYPacXPjnNAD7tm8iuEARh+09j21oiak+JRU77wQmGgLJd4E2gEOy1leO7+PEhsVkzluYmf1VI221Tv2p3+tjNv04FovFjMnNnXq9PnbEPJB6tR9PDzfqVSpE77F/prwxUKNcPi7fCOfcFdt6+h7evcXOb1UPmzTHkqvyi2QrWY3VQ1tiiY1m6xeqly8gfynKvjrEJpsAUXdusvX7D5AWC1JaCK7ckFzlanF8xUxOGlW3PBXrU6BWc5ttPrx7mz1T3jfKaiZnpUZkLVkVS2wMB3/9hI0ft0eY3CjbZUSqIso4Dsz5mntXz4OLC16ZcxBip+LRhaN7ObhmIdnyFeGbHup2btBtALXa92D2J/3Yu3wuflmDaPfB16kq54Oo++zbtpH+H32eKjvW9PtgHKPe60FMTAxBufMyeOxkh22lmerTs0hSqk8k6BSQUnpb7dOVR50CBwBTcsM2shUsKTtMmOv0sg+o+YS+sVPQ6YP+e+mDiudInXJ5YlTO6XjPYnJ4mJw2UOAxahfJ/HRVn55FklF9qmO1zWN3i5TyF8C2LjyNRvOv8jy2oWk0mnSKdmgajSbdoB2aRqNJN2iHptFo0g3PVafA08Db3UT1vM7vMQrM5OF0mwC1Or/idJsrpv/ldJsAHXq1ThO7h4/Z9+6orZQslvqBp4lxMSzVb989wWvl7XujxFauhDn+orkj6AhNo9GkG7RD02g06Qbt0DQaTbpBOzSNRpNu0A5No9GkG7RD02g06QY9bOMp8e1H77Jv0xp8A7IwYd46ACLCw/hy0FuEXrlIYFBu3vlsCt6Z/Bw+Ro83urF82RICs2Zl74EjqSpvzP17HP19LBFXzyAQlOg4jJvHtnHj0GaEcMHdx58SnYbH5wxLDl/vDHw3sBnF82VFAj3HLaR5reK8XK0w0bFmzl4Oo/u4hYRHPKBisZxMfk9lixBCMPqX9SzefCJZ+7HRD1k+sivmmGik2Uxw5RcoZ2gHHFvxO8dX/aESR5arSUjHd5O0c3P1RKLO7saU0ZegTt8AELrsU2LCVBpzy8NIXDy8COqoMlaE755LxNHVIFwIqNMdz7zlU7wWAOuGtsA1wyPxlRpDf2XfD8OIvK5SCMXcj8Atozc1h8+wyV7cNfhrxGuYY9U1yFelARXb9mb3rEmc37MOIVzI4BtAnV6jHU7znhoRnpRoUbs0Xl7euJhMmEyuTFu43iE7z1W2DUcRQtQBoqWU21LatkDxMnLc78ufWH5s7w4yZPTimw/6xTu0GV+NwjuTHy269Wbhz5OJuBdOp36Jp41pWjIoxXJu2bwJLy9v3ujW2WaH1vz7HYkuPzx9JP4Fy5KrWjMssTGYox8ghAuunio18vkNc4i8epbiHQY9se+m2Y+f/w9DW7L14HmmLd2Hm6uJjBncqFgsJxv2ncVstjCqp0pwOXzKajw93IiONWM2W8ie2ZudP79F/lYTMJstSY5Dk1IS+zAqXiRl6UevUfm1QZijH3Jw4Q80GPgNJjd3osJv4en7ZILDdTuUI3lw+QjCLQO3Vn0Z79Csub3pJ1w8MuJXuQPRty5wc8V4crT7gtjIW9xY8AFBnacgXB5ll0hqHNq6oS2oMXRaknnUjs2biJunF4Uav5Ho+pwBT6anTngNFn3YmWpdBuOfq0C80tWRZTMIu3SGmt1HPLH/8PoFEz2WNdevXeXG9WuPifD8MH1usiI8to5Da1G7NNMWrMcvwLYElFUK+ieabUNXOW2jDirdkMMUr1AFb1+/x5bt3rCS2k1V0sHaTduwe/2K1ByCGjVrERBgv2hHQmKjIgk7c4CcVVWk5OLqhltGn3hnBmC2UcjDJ6MHNcrkZdpSlWo7JtZMeMQD1u4+g9lsAWDX0YvkDFQDO6MexsQv93B3xZbnbUKRFIs5FiEEJ1bPoXSz1+MFTRJzZtZkyFkSU4bE01ZLKbl/egtehWurcv6zE6/CtRCubrj5ZsfVNwfR10+nXNgUkFJyde8agio2tGu/pK6BtWxfjAPiK9Y4S4QnLXmuq5xCiM7Ae6istIeAOcBwwB24BXQEPIGegFkI0QnoI6Xc7Izjh9+6iX9gNgD8A7Nx97ZzBCxSy/1bl3H39uPojFHcu3yaTLmLUqT1O7h6eHJ68RSu7FqOq6c3IX1TTsSXL8ifm3cimTqkBaUKZGf/qSu89/Vy7j+Iid+m88vlmbfuUUQZUiwnUwa3IE82X14fPT/ewSWHxWLmr6HtuXvtAkUbtiewYGnuXjvP9RN72Tv7a0xuHoR0GkBggZIp2kqMh1eOYsroh5u/ipTNEbdwz/Eos6rJOwuxEbew6X0OATsn9gUBeWu2JE/NR+pPt/8+gIdPAF7Z8thdRovFzIJBbQm/doESjTqQtZDSd931x0ROb1qMe0Yfmoz42W67iZEaEZ7EEELQt0srhBC07NCFFu27OGTnuY3QhBAlgGFAPSllGaAfKnttFSllOWAWMNDIoTYF+FJKWdZZzuxZRprN3Lt4ilw1W1F18HRMHp6cW61Edgs160ntUYvIUbEhFzbNS9GWq8mFsoVy8MPC3VR9Ywr3H8TwXsea8esHvloLs9nCrNWP8sjvPn6ZCq99Q40eU3m/U0083FN+7rq4mGg+bi5tv1ltiKScxmKO5WHkPZp8MpOQju+yYeJ7dgmaWBN5chNeRWrFz8tUZGav9v4P1Bw2nUq9v+LchnncOr0/ft2V3asICrEvOovDxcXEK+P/pOOUtdw4c5jbF1TEWKlDPzp+t5aCNRpzdMXvDpc7jtSI8CTF1NkrmL54I1/+PJd5M35k/66tKe+UCM+tQwPqAfOklDcBpJS3gVzASiHEYeB9oIQthqxVn+7aIRPmmzkLYaHqPcKw0OtksrH9IK3J4J8VD79A/ILV6WcrW5e7F089tk2OkIZcP7AhRVuXQ+9yOfQuu4+rqsmCDUcpWzgHAB1fLMPLVQvT5ZPEU36fPH+TyKgYSuSzvRHbwysT2YtV5NLBrXgFZCNvpfoIIQgsWAohXHh4LyxlIwmQFjP3/95OxkKPHLGrdxbM927Gz5sjbuLqbdvv94T4iiEUYzHHcm3/enJUfMHuMlrj4ZWJoOIhXDyw5bHlBWs05uzO1OlyplaEJykCs6l7IiBzILUbNOHYoX0p7JE4z7NDEzwpgDIJmCylLAX0AGxS7LBWfcpkh6pOxdoN2fiXSte98a+5hNRpZPO+aYlHpsxk8M8W3+t26+QevLIHE3njYvw2oYe24JUtZUGX67cjuHTjLoVyq+tSp0J+TpwLpUGlggz4Xw1aD/mdqIePqp95c/hhMqnbMk82Xwrnycx5Q/A4KR7cvc1DK5GUq0d24BeUjzwV63H16C4Awq+ewxwbg4ePv+0XIs7+hQO4BeTE1SdL/DLP/JWIPLUJGRtDTPg1Yu9cwT1boRRtJRRfCT2+E5+cBQC4eWI33tmD8fTPZncZoxJcg8uHd+CXMx/hVx+Jr5zfsx6/oHx2247DGSI8iRF1P5LIiHvx07u2rCN/oaQ7GpLjeW5DWwssEEJ8KaW8JYQIAHyBuFbO16y2vQekKrb+anAvju3dzr07t+nZqAJte75Hi65v8+Wgnqxb+AdZcuTk3c++T80h6NypA5s3buDmzZsUCM7FBx9+TJdurztkq2ibdzk87SMs5hg8s+SkZKdhHJ05lsgbFxBCkCEgO8XbD7TJ1rsTl/HLB6/g7mbi3JUwuo9dyJap3fFwd2XJF50B2HXsEn0nLKFaqTy817EmMbFmLFLS74ul3Aq/n6z9+2E32fzdcKTFjJQW8lVpRO7ytTHHxrBlyocseL8lLq5u1HxrVLKCJqHLx/Pw0mHMD+5y6acu+Fb+Hz4lGxJ5alN8Z0Ac7pnz4lWoBldm9AJhIqBuz8d6OJMi+u5t9kwxhGIsZoJCGpG1RFUAru5e7XB1835YKBu+GWZcA0n+qo3IW6EOqz7vT/jVcwgh8M4SRM3uHzpkH1IvwpMUt2+GMqiXUk43x5pp2OwVqtZ2LEp9rodtCCFeQ1UtzcB+YAHwJcqp7QBCpJR1hBCFgXmAhRQ6BZIatpFabBm24QhJDdtIDQmHbTiLtEofFDdsw9mkVfqgxIZtpBZbhm04QlqlD0pq2MbzHKEhpfwV+DXB4kWJbHcKKP1UCqXRaBzmeW5D02g06Qzt0DQaTbpBOzSNRpNu0A5No9GkG7RD02g06YbnupczLZBIYiwpv3v4rODm6vxnWuc+bZ1uE2D6eOe8h5iQJm91TBO7GdxSHpfmCDE2vNv6rFAmr99TPV6SDk0IcY9HI+njRiNKY1pKKdNG90qj0WgcJEmHJqVMPI+KRqPRPKPYVN8QQtQQQnQ1prMIIRx/IUyj0WjSiBQdmhBiBDAIGGIscgdszw2s0Wg0TwlbIrSWQDMgEkBKeQXQ1VGNRvPMYYtDi5bqDXYJIIRw/puxGo1G4wRsGbYxRwjxPeAnhHgT6Ab8kLbFSn9M/XgA+zevJVNAZj6dsxaAnauX8OfUL7ly9jQjp/9F/uJlUnUMZ6o+JaZMFH7xFEd+H4clJhrhYqJkh4H45bMpBybgPGWiQnkC+W3Mq/Hz+YIy88nUFVQuFUyhvCp5op+3J3cioqjS6QsA3nutHl2aVcZssTBgwkLW7DhpU5mlxczaka+SwS+QGv0nsuO7wdy7FqfOdA+3jD40+PgPm69BHBaLmeUf/o+M/lmpO2AS53eu4tCCKYRfOctLH80gc37brys4T/kqOdJK9cmZ922KDk1K+bkQogFwFygMfCilXJ2qo/5LCCE+AiKklJ8/7WPXbNqGBm27MGVE//hluQoWof/4qfw8ZrBTjvHqa13o2as3b3Tr7BR7Vd799jFlohPzJ1Go8RtkLVmNG4e3cnz+ZKoO+M5meyY3d5qM+PkxZaLcZWtSpllXQtr3AZQy0b553yWqTBTH6Quh8Y7KxUVwZumHLN5whMmzHmV1GtevKeERDwAomi8bbRqWo3z7z8gR6MuyyT0o1XocFkvKqbNOr/4DnxzBxESppIxV3hoXv+7grC9wsxIhsYcTK3/HNyhfvF2/XAWp1e8Ldv78iUP2TG7uvDj8x8eUr3KWrYE5+iEX9q6nxad/xitfOYrJ5MrwkZ8+pvpUs3b9ZFWfbMGZ962toyoPA5uBTcb0c4sQwqHByMXKP6n6lDNfIYKCCzijWIDzVJ+SRIj4bKsxDyLI4JclhR0S7u58ZaK6IYU4e+kWF649nlr7lRfKMmeVytXfpFYJ5q7aT3SMmfNXbnPm0i1CSqQsQnL/9nWuHtpCvlotnlgnpeTS7jXkrmx/csPI29e5cmAzBWu3il/mmzM/vjmC7bYVh7OUr5IjrVSfnHnfpvjnFEK8AXwIrEMNqp0khBgppUybYdtORggxDOgMXARCgb1CiALAN0AgcB94U0p5QggRiBJEibvb+0sptxqRXRAQDNwE/vdUT+LfIBFlouJt3mHX1/04/ufXSIuk2kD7Wx6crUzUpkG5eMcVR/Vy+bl++x5nLqqc/zkDfdl55FESx8s37hAU6Jui7YN/TKB0m37EGE7cmpun9pMhUwA+Dqgz7Z0xnnLt+ydqNzWktfKVNc5WfXIWtkRo7wPlpJRdpJSvARVQwzieeYQQFYD2QDmgFRBirJqKyjxbASVj962xfCJK3SkEeAX40cpcBaC5lPIJZ2YtknIv7HbanMxTJjFlogub5lO8TX/qj/2L4m36c+i30XbbdaYykZurica1SjB/7cHHlrdtWI65K62cXCIRX0qZmq8c2IRHJn/8gxOvTl3cuYLcle3XgLi0fxMZMvmTOV9xu/dNibRWvoojLVSfnIUtDu0SKqd+HPdQ0c5/gZrAAinlfSnlXWAxSvikGjBXCHEA+B7IYWz/AjDZWL4YyCSEiBuislhKmWg+YWuRFB//NKzyPUUSUya6tH0p2cvVBSBHhfqEnzvqsH1nKBM1qlaUAycuceN2RPwyk8mF5nVKMW/Ngfhll2/cIVc2v/j5nFn9uHrzbrK2b/19kKsHNrHs/SbsnDKU0BO72TV1OKCqdJf3rSdXJfvz/4eeOsClfRtZ8M5LbPlmMNeO7WbLd0PttpMcaaF8FUdaqT45i+Te5YzrCrkM7BRCLEIN3WgO7HoKZXMWCR9HLsAdKWXZRLZ1AaomdFyGsIZz6wfPMLEPo0BacM3gFa9MVKjx63j4BXL71D4yF6nArZN7yJg1t112o+7exsXkiodXpnhlojLNuxF+9Ty+OZSClD3KRG0bPlndrBdSiFPnb3D5Rnj8sqWbjzLtk058/ftGcgT6UjB3FnYfvZCs7VKt+1CqteqouHFiD6dW/Eal7qPU/LFd+GQPJmOA/epM5dr1pVy7vgBcO76b48umU+OtMXbbSciDu7cRVtf26pEdlGrWDTePjFw9uoscxUNSpXwFaaf65EySa0OLi0zOGJ84nsi5/wyzCZgmhBiHOtemqIjsrBCijZRyrlDeqrSU8iCwCugNjAcQQpSVUh5wRkEmD32b43t2cO/ObXq/FELrHgPwyuTLr+M/5F7Ybcb360LewsUZ/M1Mh4/hLNWnpJSJXD08OTrnC6TZjMnNg9Idh6Rg6XGcqUzk6eFGvcqF6T32cbHjNok4ueP/XOfPNQfYP3sgsWYL/T+bb1MPZ1Jc3LXSoepmclzYs44908fx4F4Y6yf0wT9vEeoPtL0H2VnKV8mRVqpPzlQrS/eqT1adAudR1edjwJ/Ad6iqphswS0o5UgiRBdVZUAzlADdJKXvaM9wjf/HSctSMZU4/j1alczndJkDrn5wfbKeFKhHo9EFxpEXKp48bFna6TYDATB5pYtfTTTim+mT0/A1EqYjHC+9KKes5tYRphJRyNJBY6/UTjxVDRb1dIss/cn7JNBqNs7HF1c8ETgD5gI+Bc8DuNCyTRqPROIQtDi2zlPInIEZKuVFK2Q2oksbl0mg0GruxZdR7jPF9VQjRGLgCpE2Djkaj0aQCWxzaKCGELzAAmARkAt5J01JpNBqNA9jycvoSYzIcqJu2xdFoNBrHSW5g7SSeHJQaj5Syb5qU6D+Ou4sLubwzOt1u6N2HTrcJkNXX0+k2txxI/QvLifHawG5pYvfXz39NE7v9P3RsLFVK3H1gdrrNtBpekVb3bVIkF6HteWql0Gg0GieQnOpT2jy2NBqNJo3QyukajSbdoB2aRqNJN2iHptFo0g226HIWFkKsFUIcMeZLCyGGp33RNBqNxj5sGVj7Aypr7fcAUspDQojfgVFpWbD0zr274Ywf3o+zp46DEAwaM4mS5UJS3jEZnKXK40wFoStLJnDv7524ZvSjQPepAFxf+wP3Tu9AmNxw989BUJMBmDJ4I82xXFn2JQ+u/Y20mPEr9QJZqrW3qbyLP3xcTSqkXW+2T/+cC3s34uLqSqZsuanz9ig8vJLOsFooTyC/jXqUeSNfzgA+mbqKAN+MNKlVAotFEhoWQfdP5nD15l3cXE1MHtyK8kVzYZGS975czOZ9/yRb1ruhV1kyYRCRYTcRLi6UebEtIc0fiYPs/PMn1v88nr6/byejr+15y2KjH7Lwg86YY6KxmM0UqNqQSu178+DeHVZ98R73blzGJ2tOGg6YQAbvlNOPJ4Yz1ZnicLaSlC0OLaOUcleCHEqxDh/xGeLfVIGaNHoIlWrWZ+TX04iJjubBg0ST4dqFs1R5nKkg5Fu6If4Vm3Fl8fj4ZV75ypO1bjeEi4nr637k5rZZZKv3BndPbELGxlDgze+xxDzgzNTuZCpeB3e/7CmWt+mIn3HzzIg5NobFH3QmT7ma5CpTlcod++NicmXHjC/Yv+BHqnRK2gGfvhBKlc5fAYaa1F/DWbzxCGF3oxg5dRUAvdpWZ0i3F+j72Xy6NVc5wUI6fUmgvxcLv3ydGl0nJZvi2sVkot4bg8hesAQP70cwrd8r5CtXjSx5CnI39CrnDmwjU2BQitc1sWvQ/KOfcfP0whwbw4Lhr5KnfE3+2bGaXKUqU77Vm+yb/wP7F/xI1VcH2G0fnK8qBs5XkrKlDe2mISoSJzTcGrjq0NE0AERG3OXg7u00bt0JADd3d3wyOfbUtMZZqjzOVBDyylMKUwafx5Z556+AcFG5wjxzFiPm3s24I2OJeYC0mJX2p8kVk0fKg5SFELh5Pl5ehCB3meq4mNQzO1uh0kTeum7T+QPUrViQs5dvceHaHe7dfzQ4NGMGd6Qx3rxovmys3/M3AKFhkYTfi6JCseRfc/YOyEr2gkpz0yOjN5lzF+CeUa61P4ylTtf3lRSRnahroPLQWcyxWGJjEQjO7V5PkbotAChStwVnd62z37hBWqiKOVtJypYI7W2UqEhRIcRl4CzQyeEj/sskoQJVFqX2lBGVnbeblDJMCBEC/IRKv70FeElKmWrJnCsXz+MXkJlxQ3rz94mjFClRhj7DxuCZ0XmJEVOryvO0FITuHFxJpuK1AchUtCb3Tm3n1MQOWGIfkP2Fnpg8bRPhsJjNzI9Tk3qxA9kMNak4TqxfQIFqtmdWbdOgLHNWHYif/6hnIzq+VIHwiAe8+Pb3ABw+fZWmNUswd/VBcmX1pVzRXOTK5sueY7ZJbty5fokb/xwnqEgZTu9Yh3fmbGTLX9TmMibEYjYzd2Abwq9doNSLHchWuDT379zCy1/pQ3j5BxIV/uyK+DhDSSrFCE1K+Y+U8gWU5FtRKWUNKeU5h4/4L5KMCtR0YJCUsjRKdzRO5fYXoKeUsiqQ5Psm1qpPd8JSroaZY2M5fewQzTt05aeFG8jgmZHfp050/MQS4AxVnqehIBS69XeEiwnfEipXaNSVk+DiQuG+v1Oo13Ru7fyT6DDbKgMuJhOtP/+TTt+vJfTvR2pSAPv+/B4XFxOFajaxyZabq4nGNYszf92h+GUfTVlJoeZjmLVyPz1bVwPg1yW7uXwjnK2/9GX8O83Ycfg8sbEWm44RHRXJgtF9qf/mEFxcTGybPYWanVL3NqGLyUS7CfN5beo6rp8+zC2ra/Cs4ywlKVt6OT8UQnyIyrbxjtX8f5HEVKC8AD8p5UZjm1+BWkIIP8BHSrnNWJ6ktpq16pOff8rVsMDsQQRmD6J4GZVBuPaLzTh17FAKe9mGs1V50kpB6M6h1UT8vYuczQfF57gPP7oe7/wVESZXXL38yJirOFFXT9ld3hwlHqlJndywiPN7N1Gv36c259JvVLUIB05efkxNKo45q/bTom4pAMxmCwMn/kWVzl/RduCv+Hln4O+LN5/YJyHm2BgWjOlLibpNKVK9IWHXLhB+/RI/927Ot13rce/mdab1a0XE7VA7zvwRHl6ZyFmyEhf2byGjX2Yiw5SdyLBQPH2fPVUyZ96ztrShRVp9zMBLKMHd/yq2hhSOKUnYQObAbARmz8mFf9QTdN/2TQQXKJJqu85S5Xlw9zYPI5XMW5yCkF9QPvJUrMfVo0qDIDUKQhFndnNz+xxyt/4IF7f4rO64+QYSef4AUkos0Q+4f/kEHllSVpaKCrcq78MHXD60A7+c+biwfwsHFv7Ei4Mm4eZh+0v4bRs+Xt0skPuRQnzjmsU5df4GoIRaMmZwA6BepULEmi2cOHcjWdtSSpZNHE7m3AWo1LIrAFmDi9D39230+mUdvX5Zh0+WbHSZOB/vgECby5zwGlw6tB3/nPkIrliXk+sXAnBy/UKCQ56thDnOVpKyJX3QBOt5IcTnqMjmv0hSKlBhQoiaUsrNwKvARqMN7Z4QooqUcgeqquo0+n0wjlHv9SAmJoag3HkZPHZyqm06S5XHmQpClxaO5f75Q8RGhXNqUkcCa77Kze2zkLExnP9DqUZlzFmUHC/1I6BCMy4vmcA/P3RHSvAr05AMWfOnXN47oayf/EhNqoChJvVH75cwx0az9JM3AchauDS1uo9I1panhxv1KhWi97j58ctG9XqJQnkCsUjJhWth9P1UrQsM8Oavr97AIi1cCb3L6x/PSrGsl47t4+i6RQQGF+bn3i0AqP3aOxQIqZ3ivskRGRbKuslDsZgtIC0UqNaI4Ip1yF6kLCsnvMvxtfPxDsxBowFfOHwMZ6ozxeFsJSm7VZ+EEP7ALillIYeO+C+ThArUGh51CvwDdDUcWmXUOLxIYANQS0pZPTn7RUuWlVPnO96TlBT5sqSNktKIVfZV6Wxh5+G06QSvWS5nmtjV6YNgQjPnK7lD2qUPypM5g8OqT4d5VE0zoToHRjq3eE+PZFSgEtNJOGp0FCCEGIxOqaTRPNPYMmzDumsoFrgupUwXA2ttoLEQYgjqOp0Huvy7xdFoNMmRrEMTQrgAS50x9uq/iJRyNjD73y6HRqOxjWR7OaWUFuCgECLPUyqPRqPROIwtVc4cwFEhxC5U4zgAUspmaVYqjUajcQBbHNrHaV4KjUajcQK2OLSXpZSDrBcIIT4FNiaxveY/RICXm9NtptXwinK50mboSvCYHmli9+MBX6aJ3W0Lxzjd5rnQyJQ3coDgwLT5zZLCljcFGiSy7CVnF0Sj0WhSS3K6nG8BvYD8QgjrFw19gK1pXTCNRqOxl+SqnL8Dy4GxwGCr5feklM9uDhKNRvPckpwuZzgQDnR4esXRaDQax9GqTxqNJt2gHZpGo0k32DJsQ5MGPMuqT3dDr7Liq8FKmUgISjdqS/lmShhj35IZHFg6ExcXE/kq1qZ21/dttussdaaETB81kMPb1uHjn5kPZ658bN2qmVOZP3ksny/fi7effckN540fzIkd6/D2y0z/n5YDcPXMcRZ8+QHRD+7jny0n7YZ+QQYvnxQsQZ+OdenSshpSSo7+fYXuI2ZQODgbk4a1x8vTg/NXbtF12K/ci3xAxRJ5mfyBaukRAkZPWcbi9fYnADWbzXRqWpvA7EF8/fMcu/dPyMMHD3i1VSOiox8SGxtLo8Yt6PN+6hUtnakm9Vw5NCFEX+AtYJ+UsmNK26clz7Lqk4vJRO1uA8lWoATR9yOZ8e4r5C1bjcg7tzizcy2dv16Eq5s79++knG78sfI5SZ0pIVUbv0KdNp2ZNvJxNaPb169wYvcWArLbr6IEUKFRK6o278TcTx857T8nDOXlHoPJX6Yye5bPZdOcH2nY9Z1k7QQF+tKrQ23KvTKaBw9jmPFpN9o0qkDPdrUY/OUCtuz9m87Nq/DOa/UZ+e1Sjp65QvWOn2E2W8ieJRM7Zw9h6aYjmM22pfeO449fviNfwSJERNxz6PwT4u7hwS9zl+Ll5U1MTAydWjSgZr2GlE2FBgA4V03qeaty9kINFI53ZkKIp+7Un3XVJ++ArGQroJSJ3DN6EZBLKRMdXD6LSq+8iauh+pTRL+V049akhToTQKFylcmYye+J5XMnfkKrtwfjaPLhfKUrPWH35sV/yFda/YELVqjO0U0rbLLlajLh6eGGyeSCZwZ3roaGUyhvVrbsVapR63acoEX9sgBEPYiJd14e7m4O6TZcv3qZzetW0qK98yTnhBB4eXkDEBsTQ0xMjM1pzZPDmWpSz41DE0JMAfIDi4UQ4UKIqUKIVcB0IUReQx3+kPGdx9ingBBihxBitxBipBDiySTzDmCt+vR6izp8NqwfUfedO1LbGQo6AOHXL3Pjn+PkKFKGsCvnuHRsLzPfa8fsIa9y7fRhu+1ZzGbmvfcK01+vRc7SVRNVZ8pdrkaqygxwcPNq/AKzk6uQcxMXZgsuzPFtawA4vHE5d0KvpbjPldBwvpq+llPLP+Hs6tHcjYhi7Y4THDtzlSZ1lD5BqwblyZXtUTrzkJJ52TtvGHvmDqXv6Fl2R2efjxxMvyEjcRHO/YubzWZavlCVGqXzUa1WPcqUT10zibN5bhyalLIncAWoC3wJVACaSyn/B0wGphvJHGcCXxu7TQQmSilDjH0TJT2qPoFSJlo8ri913xiMR0ZvpfoUcZf/jZ9Fra7v89en79gdPThTnSnJcj+IYvm0b2j2ZvJVQUd45f1xbF80g0k9m/MwKhKTa8qvjvn5eNKkTimKNRlB/obD8PJ0p/3LIfT4aCY92tZi68yBeGf0IDrmUSba3UfOU6H1aGp0+oz3uzXEw932isSmtSsIyBxI8VLlHDrH5DCZTCxYs531e09y+MAeTp046vRjpIbnxqElwmIpZVzDVVUeqTr9BtSwWj7XmH6uVJ/MsTEsHtePYrWbUqhaQwB8MmenUNUGCCHIUbg0wsWFqLuOqT45Q50pKUIvnefW1Ut88urLDG1Zgzuh1xjdpSnhtxxTUbIma54CvP7Zr/SZsogydZuSOSjlzFr1Khfl3JVb3AyLIDbWwsJ1B6lSJh+nzl2naa9vqN7xM+as2MvZS0+W7+TZ60RGRVOioO3tgAf37GDjmuU0rl6KIX26sWfbJob1f9Ou80yJTL5+VKpaky3r1zjVbmp5nh1acnU8x8UmbeBZV32SUrJq0nAy58pPxRZd4pcXrFKfC4d2AHD78lnMsTF4ZrJd9cnZ6kxJkbNgUcYv28OYBVsYs2ALfoHZGTbtL3wz266ilBQRRgRusVhYP/MbKjdNedz5xWu3qVQqH56GQlTdSkU4efY6gf6qPUoIweA3G/HDPOXc8wZlxmRSf808OfwpHJyN81ds74DpM+gjVuw4ztKthxk76WcqVqvF6K9+sOs8E+P2rVDuht8B4EFUFNs3rydfwcKptutMnqtezmTYhlJ1+g3oiFJJB9gBvILKWvvcqD5dPr6PY+sXkyVvYab3awlAjVf7U/KFVqz8ejjTejfF5OrGS/3G2hVNOVOdyZofP+zLqX07iLgTxuBmVWn6Rn+qN2tn1zknxh+j+nP24E4iw8MY2646L7zWj+io+2xfNAOAkjUbUuHF1ina2X3kPAvW7Gf774OINVs4eOISP/25lTdb16BHu1oALFp3gOmL1MOiWrn8vNe1ITGxZiwWSb8xs7l1J22yYdhD6PXrDOnXHbPFjMVi4cWmrajbIPV5KpypJmW36tN/GSHEOaAi0BuIkFJ+biwPBn4GsgChKNWnC0KIQsAMVDfZUqC7lDLZ3Dj/NdWniVvPOt1mxEPnqxJB2qUPCrufNuX9L6UP8nQ3Od0mpF36IE834ZjqU3pCShlsTH6UYPk5oF4iu1wGqkgppRCiPVr1SaN5pnmuHJoDVAAmC1WvugN0+3eLo9FokkM7tGQwlNTL/Nvl0Gg0tvE893JqNJp0hnZoGo0m3aAdmkajSTfoNjQnE22xcCnivtPtVsrvnJd3ExKUyd3pNg9cck52h4Tsu5g2Y7FuhKc+00lipMXwCoBqrT5wus2ovc579c6a/efvpondpNARmkajSTdoh6bRaNIN2qFpNJp0g3ZoGo0m3aAdmkajSTfoXs6nxNSPB7B/81oyBWTm0zlrAdi5egl/Tv2SK2dPM3L6X+QvnrqXEpwlNjHr00Ec367EQd6fplJMT/+4D6EX1IvsURF38fTOxICflthl1xz9kJWjumGJjcFijiVvpRco80ovbp8/yc5fRhP74D5egUHUeGsM7hm9bbYbG/2Qv0Y8Lr5SsW1vds+axPk96xDChQy+AdTpNRqvgKw22105uBluGTKCcMHF5Eqd4dO5vGcNJxZP5d61c9QeOg3/4NRnxHVUzKTP/+rQpUUVpEQJr3z8Ow+jYwHo/2pdxvZvQa76Q+MzdbzX9QW6NK+C2WxhwOfzWbP9hN1lXbFiBf369cNsNvPGG28wePDglHeyAWcJuqSbCE0IESyESJ1kTBpSs2kbBk767bFluQoWof/4qRQtX9kpx3j1tS4sWmJbjvvkCHnxFd787JfHlnUeMYkBPy1hwE9LKF37RUrVamS3XRc3dxoM/YEmY+bQZPRsLh/aRujfh9jx48eUb9eXpuPmkadiPY4t/dUuuyY3d5qM+JnW4+fzymfzuHhgK9dPHaRMs660/nwBr4z/k7zla7Nv3nd2l7n6gCnUG/E7dYZPByBTzgJU6vUZmQs5LxtsnJiJPQQF+tKrfS2qvzqBiu3GYTK50KZReQByZfOjXuUiXLh6O377ovmy0aZhecq3GUuzPlOYOLgNLi72JdI0m828/fbbLF++nGPHjvHHH39w7Ngxu2wkhSPXIDHSjUNLDU9DKKVY+Sp4+/o9tixnvkIEBRdw2jGcJTZRoEwlMvr4JbpOSsmB9UspV9/+NNlCCBXxoERSZGwsILh79TxZi1YAIEfJKlzYvTZVdi3mWIQQj0V5MQ+jlCZcKvHJkQ+f7MGpthNHasRMXE0uTwivAHz2bkuGTVz8WHr0JnVKMXfVPqJjzJy/cpszF0MJKZHXruPt2rWLggULkj9/ftzd3Wnfvj2LFi2yu9wJcaagS3qrcpqEED8A1VCpf5oDRYApQEbgDNBNShkmhNiASuxYHSWccgEYAZiBcCllLSGECRgH1AE8gG+klN8/3VN6tvjn0G58/LMQmCufQ/tbLGaWDe/AvesXKdKgHYEFS+GXuwCX9m0gd4W6nN+5msjbKQuPJGZ3waC2hF+7QIlGHchqiK/s+mMipzctxj2jD01G/GyXTYFg21e9AUG+2i0JrtXK7nKlRJyYyf0I+/R3roSG89WM9Zxa+hFRD2NYu+MEa3ecpHGtklwJDefw6cclMHIG+rLz8Pn4+cvXwwnKap/S2OXLl8mdO3f8fK5cudi5c6ddNhLD0WuQGOktQiuEcjolUOl+XgGmA4MMAZTDKKcVh5+UsraUcgLwIdBISlkGaGasfx3l3EKAEOBNIYRj/+R0wv61f1GuflOH93dxMdFkzBxe+XolN88cIezi31R982NOrp7N0uEdiHkQiYsNwiOJ2X1l/J90nLKWG2ceia9U6tCPjt+tpWCNxhxdkaQsRKLUHPwjdT+YQbV+E/ln/Txuntpnd7mSIzViJn4+njSpXZJiTT8m/4sf4OXpzv8ahzDo9QaMnLLsyR0SiU7tze2aWDLY1Oo/OFvQJb05tLNSygPG9F6gAMppbTSW/QrUstp+ttX0VmCaEOJNIC59Z0OgsxDiALATyIxymo9hrfp0L+x2wtXpBnNsLIc3r6Rs3captuXulYlsxSpy5dBWfIPy8cLgKTQe9Qf5qr6ET9ZcDtv18MpEUPFH4itxFKzRmLM77RP08PRTGgQemQLIUa4OYWedq3CUGjGTepWLcO7ybW7eiTSEVw7RuVll8gZlZtcfAznx14fkzOrH9pnvky2zD5dv3CFXdr/4/XNm842votpKrly5uHjxYvz8pUuXCApyTMQ5DmcLuqQ3h/bQatoM+KWwffzLgYbM3XAgN3BACJEZlXq7j5SyrPHJJ6VcldCIteqTj3/avHP5LHB671ay5imAX9YcDu3/4O5touNEUqIfcO3ITnyD8hEVrh4C0mLh8KIfKFy/jV12o+5aia9EP+DyYSW+En71URXr/J71+AXZHlzHPowi5kFk/HTosR1kyum89k5InZjJxWthVCqV10p4pTCL1h0kb4PhFG06kqJNR3L5xh2qdhzP9Vv3WLrxCG0alsfdzUTeoAAK5g5k99HzKRzlcUJCQjh9+jRnz54lOjqaWbNm0axZs5R3TAZnC7qktza0hIQDYUKImkayxleBjYltKIQoIKXcCewUQjRFObaVwFtCiHVSyhghRGHgspTS7rekJw99m+N7dnDvzm16vxRC6x4D8Mrky6/jP+Re2G3G9+tC3sLFGfzNTIdP1lliE7+N7MeZA0ocZGTr6jTq2o/Kjduyf90SytVzvLoZdecmW7//AGmxIKWF4MoNyVWuFsdXzOTkGhUs56lYnwK1mttl935YKBu+eSS+kt8QX1n1eX/Cr55DCIF3liBqdv/QZpsP795i57cDAZDmWHJVfpFsJatxZd96Dv3xOdERYez4+h18cxem2juT7CqvM9h95DwL1h5k+8z3iY21cPDkJX6avy3J7Y//c40/V+9n/7yhxMaa6f/pPCwW++qcrq6uTJ48mUaNGmE2m+nWrRslSpRI7ak4lXQjkmIInSyRUpY05t8DvIGFPOoU+AclgBLXKfCelHKPsf18VHVSAGuB/sb0KKCpMR0KtJBSJhmr5y9eWo6akUgbRippVdrxalhyfLv1H6fbTKtsG552iO3aQ1pl2/iwQdpIvOlsG1A+2Dd9i6QYQiclreY/t1pdJZHt6ySYT6wLSwJDjY9Go3nGSW9taBqN5jlGOzSNRpNu0A5No9GkG7RD02g06Qbt0DQaTboh3fRyPivcuR/LgoM3nG73npEWxtl4eTj/mfZCkbQZXFzE3ydN7Lq7ps1zPTrWkiZ2V/4xIuWN7MSzfB+n2wToM7J3mthNCh2haTSadIN2aBqNJt2gHZpGo0k3aIem0WjSDdqhaTSadIN2aBqNJt2gh208RaTFzNqRr5LBL5Aa/Sdy58JJ9k0fgzkmGhcXE+VeHUxA/pIpG7Ji+qiBHN62Dh//zHw4c+Vj61bNnMr8yWP5fPlevP1sH0qRFjYBfhz5Hge2rCWTf2bGzFbJFmdNHM2BzWswubmRNVde3vjwc7x87EsNnZAWtUvj5eWNi8mEyeTKtIXrU2UvDmcpE1mTVmW9dzec8cP7cfbUcRCCQWMmUbJciE379ulYly4tqiKl5OjfV+n+0QweRsfyVrta9GxXi1izhRVbjjJs4iLav1SR/p3rx+9bqlAQVf/3GYdOXU7S/t3Qqyz7chCRYTcRwoUyL7alQrPObP19EodWzsXTV91XtTq/Q/6Kte067+fWoQkhzgEVpZQ3EyxvBhSXUo5z9jFPr/4DnxzBxESpdGqH5k6kWLPu5ChdnauHtnBo7tfUGTTVLptVG79CnTadmTZywGPLb1+/wondWwjIbn9G0bSwCVCjSRteaPsaU0e8E7+sROWatHl7ECZXV2ZPGsOSad/Qrk/qk5t8M+Mv/AIyp9qONXHKRBERzk2PlBZlnTR6CJVq1mfk19OIiY7mwQPbUiQpNanalGs9mgcPY5gxrittGlXgwtXbNKlTmpB244iOiSXQXwnQzFq+h1nL9wBQomAO5n7RPVlnBuBiMlG32yCyFSxB9P0Ipr/zCnnLVgOgQvPXqNTK/hx+8bYd3jOdIqVcnBbO7P7t61w9tIV8tVrELxMIYo2sqDH3I/D0y2K33ULlKpMxk98Ty+dO/IRWbw9GpXH7920CFC1fGa8EdktVqYXJVT1XC5QsT9h1+wVSngbOVCZKayIj7nJw93Yat+4EgJu7Oz6ZbI96H1OT8lRqUt1b1+DzX1YTHaMGeIeGPSlo0vbFisxZuTdF+94BWclWUCWGdM/oTebcBYi4dd3m8iXHc+HQhBBeQoilQoiDQogjQoh2xqo+Qoh9QojDQoiixrZdhBCTjelpQogpQojNQohTQgj7tdsMDv4xgdJt+oF4dMnLdHiPQ3O+YumAlzk05ytKvuKc0doHN6/GLzA7uQqlXgQ3LW0mZPPi2ZSqVifVdoQQ9O3Sitea12HhrGmptgePlIlchHP/MmlR1isXz+MXkJlxQ3rzeos6fDasH1H3bUuyfCU0nK9+W8upZSM5u2oUd+9FsXbHCQrmzUr18gXY9OsAVv3QlwrF8zyxb+sG5ZizImWHZk349UtcP3OcHEWUyPb+pTP5pU8zlk8cyoMI+zQP4DlxaMCLwBUpZRkjo22cGu9NKWV54DvgvST2DQZqA42BKUKIDAk3sBZJeRgR9oSBKwc24ZHJH//gYo8t/2f9XMq0H0DjCcso0/5d9v4y0tHziyf6QRTLp31DszffSXnjf9FmQhb/PAkXV1eqvdQy1bamzl7B9MUb+fLnucyb8SP7d21NlT1nKxNZ4+yyghKzOX3sEM07dOWnhRvI4JmR36falpHWz8eTJnVKU6zJR+RvNBwvTw/av1wRV5ML/j6e1HptAkO/WsSMT7s9tl9IybzcfxDDsTNXbS5ndFQki8b2pd6bQ/DI6E3Zlzrw5tTVdJm4EG//QNb/9Kld5w3Pj0M7DLwghPjU0BeIc/3zje+9KMeVGHOklBYp5WlUCu+iCTewFknx8PZ/wsCtvw9y9cAmlr3fhJ1ThhJ6Yje7pg7n3LYl5KxQD4BcIQ247QRVodBL57l19RKfvPoyQ1vW4E7oNUZ3aUr4rdBnyqY1W5bM5cCWtfT85OtUy6IBBGZTIi4BmQOp3aAJxw6lTn7O2cpE1ji7rACB2YMIzB5E8TIqQ3XtF5tx6tghm/ZValK3uHknwlCTOkiV0vm5fOMOC9cdBGDP0fNYLBay+D0Scm7TqIJN1c04zLExLBrbl2J1mlK4WkMAvPyz4GIyIVxcKN2oDddOHbbZXhzPhUOTUp4CKqAc21ghRJxaRpxKlJmkO0gSii7YLcJQqnUfGk9Yzsvjl1C55xgCi4ZQqfsoPP0CCT2pboIbx3fjnS13CpZSJmfBooxftocxC7YwZsEW/AKzM2zaX/hmDnymbMZxaNsGlk7/jv4TfsIjg2eq7UXdjyTSaLSPuh/Jri3ryF+oWAp7JY+zlYnSsqwAmQOzEZg9Jxf+Udqk+7ZvIrhAEZv2VWpSwY+pSZ08e42/1h+iTojSSCiYJxB3N1du3lHtaEIIWr1Qlrk2OjQpJSu+Hk7m3AUIadE1fnnE7UdJHU5vX0OWvE8oRqbIc9HLKYQIAm5LKWcIISKALnbs3kYI8SuQD8gPnHRWuSq8NpwDf3yONJtxcXOnwmvD7bbx44d9ObVvBxF3whjcrCpN3+hP9WbtUt7xKdsE+HZYb07s3U7EnTD6N65Ey+7vsmTaN8RGRzP+7Y4AFChVji5Dxjp8jNs3QxnUSzWGm2PNNGz2ClVrv5DqsqcFaVnWfh+MY9R7PYiJiSEod14Gj51s035KTeoA22cOItZsjleTklLy/Ucd2TNnCNExZt4YMSN+nxrlC3D5xh3OXb5l0zEuH9vHsfWLyBJcmGl9WwBqiMbxjUu5cVYNM/HNmpOGb39s93mnG9Wn5BBCNALGAxYgBngLmIcxbEMIURH4XEpZRwjRxVjeWwgxDQgDKgLZgHellEuSO1ZAcHFZ3+rHdhYvFPvv6H16uppS3sgBdPogxUOz8+02au/8lESQdumDxjctmr5Vn5JDSrkSpbFpTbDV+j1AHWN6GjDNarutUsq0aw3XaDRO47loQ9NoNM8Hz0WE5ihSyi7/dhk0Go3t6AhNo9GkG7RD02g06Qbt0DQaTbpBt6E5GQ83Fwpn9055QzvZ9s9dp9sEaFTU+cNBMqbRsI0yef3SxO5fR66kiV0/D7c0sethcv71HT/pXafbBHi/94Q0sZsUOkLTaDTpBu3QNBpNukE7NI1Gk27QDk2j0aQbtEPTaDTpBu3QNBpNukEP23hK3A29yuIJA+OVbsq+2JZKLV5j4/SvOLVjLcLFBS/fzDR5dyw+mbPZZNMc/ZAVn3TFEhuDxRxL3koNKNu6F7fPnWDHz6OUmpTJROWuQ8lSoJTNZZ368QD2b15LpoDMfDpnLQA7Vy/hz6lfcuXsaUZO/4v8xcs4dB2s+Wvmj6z+cyZISYNXOtK0U+qTJvZ4oxvLly0hMGtW9h44kipb3370Lvs2rcE3IAsT5q0DICI8jC8HvUXolYsEBuXmnc+m4J2I/oItXDz7N6PffXTO1y6dp3OfQbTq3CNV5YbUqT5ZM3PMQI5sW4+Pf2aG/qYSPS/76Su2/TU7XvWraY/3KFG1boq2+nSsS5eW1Qw1qSt0HzGDIsHZmDSsPR4ebsSaLfQfM5s9R88D8F63hnRpXhWzxcKAz+axZvvxFI+R7iI0IYSfEKKXk2zVEUIkmy7IVlxMJl54YzA9vl/Oa1/MZt+S3wm98DdVWr/Bm9/+xRuTF1GwUh22/P6N7Tbd3Gk47Eeajp1L0zFzuHJoK6GnD7H3jy8p06onTcfOoUzrXuz94yu7ylqzaRsGTvrtsWW5Chah//ipFC1f2S5bSXH+9AlW/zmT8TOX8uXcNezZtJor5/9Jtd1XX+vCoiUrUt7QBuo0bcvQb2Y+tmzhL99QqlINvl68lVKVarDwF9t/r4TkzleQKQvWM2XBer6ZtwaPDJ5Ur/9yaosNPFJ9+m3FTn5etIm8BQo7ZKfyy63pNeGXJ5bXbduNwdOWMnjaUpucWVCgL7061KZ6x8+o2GYMJhcX2jSqwOj+LRg9dTlV2o/jk++WMLp/CwCK5s9Om0blKd96NM3e/paJQ9ri4pJyNuN059AAP+AJhyaESJvRnjbiHZCV7IbSjUdGbzLnyU/Ezet4ZHw0CDfmQRTYkYJaCIFbhowAWMyxWMyxSpBJCKKjVDZRpSZlX2bZYuWr4O3r99iynPkKERRcwC47yXHp7GmKlC6Ph2dGTK6ulKhQlZ3rlqfabo2atQgIcM5g4eIVnrwOuzespHbTNgDUbtqG3eud4zz379hEjjzBZMuZ+qzFqVV9sqZg2UqJKoA5gqvJ9EhNKoNSk5ISMnkpmQ5fb0+uhqrs+E3qlGbuyn1Ex8Ry/sotzly8SUjJ4JSP4ZSSPluMAwoIIQ6gkjlGAFeBskKIl4ElhlAKQoj3AG8p5UdCiILAFCAQlZK7jbVRIUQIMBV4RUqZqlDijqF0E1RUVds2/Polh9cuxMPLh47jpttly2Ixs3RYB+5dv0CRBu0ILFiakFcHsubTt9j7+xdIaeGlEfbZfBrkKViUmZM+5e6d23h4ZGDvlnUULF763y5WioTfuol/oGoS8A/Mxt3btmVpTYmNyxZS9+VWTrFlrfr094mjFClRhj7DxuCZ0csp9gE2zZ/OrpXzyVOkFC17DyNjCg7zSmg4X01fy6nlnxD1MJq120+wdscJLl0P469v3mbsOy1xcRHU7aLeLMgZ6MvOw+fi9798I4ygrCk75fQYoQ0GzkgpywLvA5WAYVLKlPTXZgLfSCnLANVQThAAIUQ1lLNrnpgzs1Z9un/3SdUna6KjIpk/ui8vdB8aH53Vee0d+kzfSMk6Tdn7l33Zbl1cTDQdO4fWk1Zx88wRwi6e5tSaOYR0ep/Wk1YR0ul9tv3wkV02nwa58xeiVddefNyjPSN7dSS4cPF4fc7njZjoaLavX0mtRk2dYi81qk+2UKNlR0bM3sCgX5aSKXNWFkweneI+Sk2qFMWajCB/w2F4ebrT/uUQurepycAJ8yn00gcM/PxPvhuhUrEnVlOxJbl2enRoCdklpTyb3AZCCB8gp5RyAYCU8oGU8r6xuhgqMmsqpbyQ2P7Wqk8ZMz2p+hSHOTaGP0f3pUSdphSt3vCJ9SXqNOHE1lW2nVUC3L0ykb1YCFcObePM5r/IE1IfgLyVG3LrTOoax9OKF1r9jwmzVzH6lwX4+PqRI0++f7tIKeKbOQthoUoUNyz0OpmcoHi+e/NaChYvhX+WrKm2BalTfbKFTAGBuJhMuLi4UK1Ze84fT9l2vcpFOXflFjfDrNSkyuSjY5PKLFx7AIA/V++nYom8AFy+cYdc2R/9l3Jm9Y+vjibH8+DQrBVWY3n8nOM0NpNruLoKPABSJcoopWTpV8PIkjs/lVs9Urq5fflc/PSpnevInCu/zTYf3L1NdKR6aT02+gFXj+7AN0cwGf0DuX58DwDXju7CJ/uTorDPAndu3QQg9OoldqxdRs2XWvy7BbKBirUbsvGvuQBs/GsuIXUapdrm+mULnFbdhNSpPtlC+M1H6kwHN60kR/6UOxwuXrtNpVL5rNSkinDy7HWuhoZTs4JSd6pTqTB/X1DSiEs3HKJNo/K4u7mSNygzBfMEsvvIuRSPkx5j/HtAUmoa14GsQojMqLa1JsAKKeVdIcQlIUQLKeVCIYQHENeJcAd4HVglhIiUUm5wpFCXju3lyLpFBAYX5sfezQGo89q7HFw5j1uXzyIMpZuXetuudBN15yZbpgxHWiwgLeSt3JBc5Wvj5uXD7umfIS1mTG7uVH3jw5SNWTF56Nsc37ODe3du0/ulEFr3GIBXJl9+Hf8h98JuM75fF/IWLs7gBD2A9vLZgDe4Fx6Gq6sb3YeOcXj4gzWdO3Vg88YN3Lx5kwLBufjgw4/p0u11h2x9NbgXx/Zu596d2/RsVIG2Pd+jRde3+XJQT9Yt/IMsOXLy7mffp6q8D6Lus2/bRvp/9Hmq7CTEUdWnhPwyoi9/H9hJxJ0wPmhZjZdf78fp/Tu5dPoYQggCsuei/fspVzl3HznPgjX72f77IGLNFg6euMRPf27l4ImLjH+/Na6uLjx8GEvvUX8AcPyfa/y5aj/7/xymhnOMm4PFknKdM12qPgkhfgdKA1HAdSllE6t1fYG+wFngMnDO6BQoBHwPZEF1JrQB8gDvSSmbCCHyAMuBblLKnUkdO0ehkrLb1/OTWu0wl8IeON0m/LfSB71YPEea2NXpg+CQDdU5R0ir9EEPDnzz/Kg+SSn/l8y6r4GvE1l+GqiXYPE/wAZj/QWghPNKqdFonM3z0Iam0WieE7RD02g06Qbt0DQaTbpBOzSNRpNu0A5No9GkG9LlsI1/EyFEKHDexs2zADfToBj/Jbv/pbL+1+z+l8pqr928Usonsi5oh/YvIoTYk9hYmufJ7n+prP81u/+lsjrLrq5yajSadIN2aBqNJt2gHdq/y1Rt9z9V1v+a3f9SWZ1iV7ehaTSadIOO0DQaTbpBOzSNRpNu0A5NkyJCiP/MfSKEHSozmnTHf+ZG1diHs/7YQoiiwAghhHeKG9tn12Q1nVRCTnttCmk0CgshUpVhOKXjPMv2/iskPG9nPDi1Q0snJLw5pBN6e4wbLBdKCesdIUTG1No07JqAFwzd077Aa0KIVOfms3JmrwIfCyEc025LAiFEvrjjOMMJWdlwNeZTnbnRulzOjKzj7AohfIUQSQtn2Ef8Q1II0QUYmFqD2qE9ZaxujMJCiBAj3XeqbVr9mTsKIT4QQrwihHBYSFMI4SKltEgp1wAHgJJAbyc5NQFkAsajsgcvk1LGOuMPKISoArQA+kspw1PrJKx+r0LAMiHEMEi9U4v7zYQQlYDjQohsUkpzasqb4D7oDAwWQnQQQqQ6LbFR1mbAKmClcY85bFcIkRf4w5CHBHBDJVRNFdqhPWWsboy5QE/UzVEhtTYhPr34m6j04sOBF1Jh02LY7I9yEBKoBQwUQqRK4FFKGQvsAqKBbUBRIYRn3DHtIUFE4gHUAQoBrYw/uDk1jsf4vZoAHxllbiuE+MhqnUO2jX3rAy+hru0GIUR2o7wO/S+t7oM3gR5GeX8EUq2PJ4Qogrq3egBdgBASEfS2gyhgMzBUCFEadQ1S3/QgpdSfp/gB8gErAH+gJXAYCHDQVn6raV9gEir66Q6sRAm9uAMZ7bAprKazAWsBL2O+IfAtSu/UZpuJHCOb8e0BdDBsdjCWFQeyO1DWPICfMd0T+Aqlo/rEtnaW1Q/YDdRABQClga3AkFTeB0WAc0BVVJV+PHDB6tq4OGDTBQhADVDNBbwKrAZMjvxGKMclDFsLUdFZRmN9MHAaaGdvGa2mswD9gQXAbOMaVEQ5y5fjroU9Hx2hPX3CUX+It1BtBs2llLeFEPXsaUcSQniiqkAfGYvuom6+rYbNRlJKM+qmLmujTRcZ9+8XohHqRs6B+jMDrDPK3x5V/bQ7OhFC9AZmCCHGA22llH8Ae4BqQohZwB+op3WKWJW1P/ATMEsI8RXwO3ARqCmEaGu9rQOYURkgzkkVQR417L8uhOjnoE1Q8orrpJTbgZtSyveBg8B6IUSglNJiy/W13kaqJoLbwN/AD0BHoKFUUd9AIURdO8pXEBU9B0gpLwFxyj+NhBABUspzqOjP01aDRsQcF/l3AHICc4D1QAWUMFEjYBDqv+FuR3kVqXnK6I9NT6S4tzE8jB/IHfgF2A8UN9bVQv1RitloM5fxXRj1JxhuzLdAibq8Ysx3Muzmt7PMVYE1KAfZFRVBVbOy+SmQ1YFr0QXlcIONG/kgMNBYVw0YCpSw02YLVOTgAnwOrDeWZzLsjQW8bf2trH6vIMDDmB4B7AA8jfmXjGuwOO43tOM+cDe+fYzz72a1TTtURLwcyGDndegDjDOme6Gqm1WM+dbGsQrbadMHmIIRjaLkHH81rnNz4AxQ34H7oCdwJO6+REWoPYBF9t6rT9hOzc76Y/MP2AwVsn+PUo4qbdy0Y4w/y1GgiQ12BCpM/wHwN5blB46hqoE+xo29zrg5DtjiIFCO0deYbgrc4JFTLIlquD9pHPdve/8Yhp2KwCuoqnZvVLW7tuEoHK6+odrMGgGDDcfmZlVuNxyozgMvAtuB6cBMIC/wIXDcuM5/A9WN61HSDruNUNWrKaiqdl6UVuwwVDPBZqAmMBn7mgneRT0oSlrdJx8B04zrvA0oZeP9ZV2Nd0VV/b5FdbKAivq2oqr0LxjLbKoeG/ZzApvi7iEef4AMRUXonrbafOIYjt5I+mPzzVYEFTW1s3IMxVBtaV1RoXVN6x/XBpsZjBu/lzFfwPiz9TPmA4xjBNpwg3kAEzEcpLF8J7Ddat6EUo5/GcjnwDV4y/gjF0Q9jRcCWYx184G/4uZTKm8i5a8DXAIWWy1/A/gTo+3PBrtZgf8BGY0/3Cnj+hY2fp+tqIdFe1QVvgQqit0H5LHxGFVQD56WqLbIc8Z1yYmKIr8FSqE6cnaRjCNO4HQyG/tmRT3cuqEccQlUc0FxbIimMaJRY7qucZ51rea/B/oa811QzryxrdfY2M8F8AKWYUTNPIpYg4xzcag9Of4YqdlZf1L8AUsbf9aPrJa9DpwAqttpyyXBfBNUFNHNmC8AHALG2GHTZHy7AZVQkUFchLMHWOSEa9DMKFdeYz4HKoKsZvxpZtjizBLY7A1MMP5UmVFR0zFUBDTEOJ7NVVdU1PET0NlwKt9ZX3PgG6Cj1fYhqMiyjI3X199waJ9arQtEVbvKWC2rgWpoTzLqS+DMOqOqb4tQjf+LUe1Ps4Gf7Th/f1QUV8xwhOdR2rULeVTdrIOqbg4w5oeiOqFsrc7X4NED+HdgntW6LqgHm13V7ESPk1oD+pPsj+iNCqGXoBrY48LrnqgerQDs7IEy/ky5UdFJeWAj8IaxrrDh5Ox1EEEoh7jR+EPEObVNqIbr1FyDnsBQYzrO7gDjumxLySlYlS+ud+1tVPteflS70JdWNkehopWiDpTzXeA7VK/bFaCr1bqRcX9kYz4vyfTEotoIg43p+oajeRPYmWC7r3jUNmkyfk+b2pBQVfi5VvPNedRD2hAVEdvkbIx9hqEeBJ8B9Yxl5VHOcrDVuZS22sc/GXtx97qLcW7dUVFeO1QkPNe4v8YDe63tpup+c4YR/XniRywJlDF+SA9UFDIJyGm1bS4bbVbgUcTQBfVUXwj8hooAy6Iakt82tnGzwWY1oL0x/bbhGCYYTmYnqpoV53xW2VrWJI71Eqq9sIjVsibGuXjasH9O49r1QEWS76GimwHAUlT122RVXkeGOzREDXPZjIoevkL1kg4FWqHaIuvYaCsYFYGXBIoCP8f9Wa2ubwlU1fIIUMnee8y4tw6i2ve8E6zvZ6xLsc3M2N7V+PazOu+4qN/VuL9WAx9Y7WPzQxijSo5yYq+hIr//Gctaojp1CjrtP+gsQ8/7h0fOrBnqifML6olUnkc9mz/Z6xxQkd0WVK/gz8aNlw/V5rMYNV6oIapq62ujzcaowbcfo6oR+Q0bfVDRzzrgS0ecQyLHyoSKnMYYjqwTalyXTTex8QfugnK43VAPh43ALKs/Y29Ue5QLNrZDWtnPalzfYsb826iI7GOUcxuFDR02VmVtjWqTLAPcQXUgWEd7E437YC3Q2J57K8GyV1FtezV5VDU2AZ9gY2+5la0WqPbAIFQP6TGMKjuPIscK9pbVsHceeMmY9+LRGMnOcb+fMz9ONfY8fowfKa6BsxwqjM6C6gA4jRrkWAkVqf2OncMSDLs5UaH/CatlWVFtOy3jymGnzQaoCGGmMe+BakOZgIpKZuDA0IwkjpUDVfVchopSbKpe8Ogh0RlVbV9hOJqbPGqP6WL8AQs5WDZ/VDW9ljHvhmqbW4WqJgrrsthgzw+4hnpgtERFlJ8Dta22cQN87LFrbNsR1XvZC/Wg6ICKnmpgQ2SehM2yqAi0qNWymSgnb1c1MIEzexfVq90RNUSpodW6dcZ95ueM+8v6owfWpgLj5edxQBNjoGsEqg2mLCq87oRyFGOAyqiG5aM22HWxmnaXUl5G3cR3hRA/AEgpb/Co+gFw356ySylXo9pNXhZCtJNSPpRSHkf1RN6RUnYyjpFqpJRXpZRTUJHAa1LKQzbuJ4UQHVGR41BUtGNG9eL1F0J8h3I6raWUpx0sWxiqPaeOEKKklDIG1ah+C9gkjX9g3LcN3EX9gV1REeMfqNd8Ggkh6hm2YqSU9+yxK4R4G3UdwlA95yuNT9y4MEfVkh6iHFptIcSHQoh1gAXlmOcIOzKhxJ2LEKIBqhNkt5RyJqqd7AshRGPjNbK7wOdSyjsOljnZQuhPKj6oNoufUE/jDMayITxqJ3gL1d5lVzXA2LcbqudxJKr3LTcqctiIilo24kADeIJjNEG9FPwxqiq6Hyjwb19Xq/KNBN43pt1RD4w5qDa0LNhYzU7hGLlQVbWVwGjUuMA6qbSZF6O6CWRHNbaPJ5mG9AT7x1Uj4yLEKVi1t6Ec/I/G9NvYOHwkkeN4o6rsW1GReUnUw7OerTZRtYW4KmoXVMT8V4JtWqMi4XU4qQMg0bL82zfsf/XD4++k9TCcVitUdaIr6hWhbqinXzUH7HdEVQkboNrfPkM1sOc0/nBrSEVjfYJjtUBFPrMweueelY9RtoVYVdVRvaNjgExOPI4Pqh3xXayqh6m0WQ41PrA7qtrtyIDkwsY9tQTjrQpjeWnsGJphw3HixoNVNBxSPTv2LYR60P6Keo3pVVQ7ct8E2/liZ9OI3eeRlsbT68fqqZnLalkbVNtDXJvWG6hOgZfttY1qiP0UY+wTqp3nXR71dgYBQU4+p9oYY8WepQ+q6jMa1ThfDxVFLsbGF9j/7Q+ql/qsrQ8fHu+B7oOK8sYb1+ASj3ogO6KiHT/s7AhJ4rgmo6w7sXqp3479P0dVJd8y5l8yHkR9nub1TnVSvecRKaUUQrwIfC6E2AfEoG6+WKClEMIN1SM5Tao8X/F5qhLDer3xbRZCXACaCyE2SSkvGm1nS4UQeaSUF9LgnDY626YzkFLeEUJ8g4p+h6Ou8QAp5bV/t2S2IaXcK4QoLY02MxvwB8YKlSk4F2qwcENUJ8AaYJRQ2XjrojJd3HFSOc1CiBMoZ3o2pXs2Eaaghou8K4S4LaWcLYS4AXwrhLgpVRKCNEc7NAcw8pe9hGq7uIFqN1iIao/KjBrkuFFKeR1SbviNWy+EeAVVxZiJCuFzorK5zkM11gvA1j9GukFKeQWYLIT4BRWNRPzbZbITm8srpVwqhIgGvgB2SCnPCCF+RvUYgupBnYp6++SWMwsppYxERZMp3rOJ7Ps38LcQ4g4w2vjOgMp5t8OZ5UwOrctpI1YZRv1RWQaOSilrGhlGJaqrf7mUcp6tUVSCDKOdUANat6FC//6oBtsqqKrWQ1QbygHnn53mWUMI0Rx1T/WVUs4yer67oB5snzkrMksLjNrLeFSKpNelDT37Tju2dmgpY+XMXkL16JxBjYnqJ6X8ydjmM+C6lHKCPTaN6eyoKsRuKeXfRn6vBqh3/zYZTtQspbzr9JPTPLMIIRqjXlwfY+XUvOyovv5rCCGyogK90Kd5XF3ltAHDmVVC9bjNklJuMZ5Ca4UQJVGj9Bug3oNMkQTOrDfwDvAA1SDbTUr5lRDCDIwXQrwvpdzk/LPSPOsY1U8LMFUIESulnMd/pMlBOmkMo73oCC0JhBD5UV3XPxq56uegkvkVstqmGmqk9jqgu5TyqhDCJFWmWFuOUQM1AHcsaoxZd+BvKeUIY30PVDXW6Z0Amv8OxkDVM1LKVIuIpHe0Q0sCIUROlJP5R0p5QwiRB/X60Q4p5VtW21VEvSQ9WEr5iy29Q0bVIT8qI8Jx1CBZC6rt7G3gqlQpmTUajR3oV58SwYiyLqNeot4ghBhnRElNgQJCiIlx20op9wBtUWK8fsnYTJj7/W/UaPccqG75GFSVcyrgL4TI4vwz02jSNzpCS4BVB0AB1Gj/jKghGX9KKUcLIXKh3vU7KKXsJYRwNcaaZZBSPrDB/muoEeQ3eJTe+RNUdotFqKEZ7rbY0mg0j6M7BRJgOLOmqJHp51A9mkOBL4UQZinlOCFEe1RkhVQak6CGVSSLEKIn6nWo71DV2b9Qbxh8jMo+ECOlXIrqINBoNHaiHVoChFLe/hDVa9kAVQWMQvVETjUislGoRHjxJNZulkgHQV5gkJRyvbH+IjBKStlGCDEa9e6mRqNxEN2G9iSXUNkGyqIyaZRBDW591ZjfbIsRY+xYcWP6ZSFEECqq62i12XrgoVFdnSelPO+sk9Bonke0Q0uAlPKSlHI36mXtmUbj/TRUDqq9UsqN1g38yZAL6CSEmA58Zby+0x8oK4T43NimKipq83LyaWg0zyW6ypk0h4EeQqmZN0VlDbgAyb/nFtepIKU8bLzP1helGRn3onUzYKEQ4jdUbvlXnf1OnkbzvKJ7OZNACJEJlbSxGfCTlHKZnfvXQL3jmQ2lZ7kJWGGMafND5R9zlSpjqkajcQLaoaWA1bAMm9OpCCECUVlrM6Da3V5ApeNeiFICyoJKgROblA2NRmM/2qGlgAN5oeL2C0Hl8MqIcm61UY6tCkrg46BTC6rRaLRDcyZCiK4oebZhxnx5VK9mLDBaSnlXCOH9H8znpdH8J9C9nKkgkd7ODaiOhCEAUsp9qPz/DYBhxrg07cw0mjRC93I6SCIpgEqiekYbA0uEEBYp5aeodC/rgS9tzcKh0WgcQ1c5U4kQohfQDlW1PIQSRtmFkp/bAFQHGkkpT/5bZdRonhd0hJYKjKEd5YH2qHcyd6MGymZFpQS6j3rV6dK/VkiN5jlCR2ipxEj+WBT1NkBdI9fZLVT2jHFSyuh/tYAazXOEjtBSiZTyoRDiPuAqhIhTN1+KkrDTzkyjeYroCM0JGFFaf9Q4s2xAWynliX+1UBrNc4h2aE5CKHHh7IDFyHar0WieMtqhaTSadIMeWKvRaNIN2qFpNJp0g3ZoGo0m3aAdmkajSTdoh6b5TyOEqCOEWGJMNxNCDE5mWz/jVTV7j/GREOI9W5cn2GaaEKK1HccKFkJosRwH0Q5N80wihDDZu4+UcrGUclwym/ihBHA06RTt0DRPFSMCOSGE+FUIcUgIMU8IkdFYd04I8aEQYgvQRgjRUAixXQixTwgxVwjhbWz3omFjCyqJZpztLkKIycZ0NiHEAiHEQeNTDRiHUr4/IIQYb2z3vhBit1GWj61sDRNCnBRCrEEJ5KR0Xm8adg4KIf6MOyeDF4QQm4UQp4QQTYztTUKI8VbH7pHaa6vRDk3z71AEmCqlLA3c5fGo6YGUsgawBhgOvCClLA/sAd4VQmQAfkAJ19REDWZOjK+BjVLKMqgEAkdRYjVnpJRlpZTvCyEaAoWASijZwgpCiFpCiAqohAPlUA4zxIZzmi+lDDGOdxx43WpdMCpjcWNginEOrwPhUsoQw/6bQoh8NhxHkwz6XU7Nv8FFKeVWY3oGShkrTtpvtvFdBaVrutXIo+kObEclAjgrpTwNIISYAXRP5Bj1UBlPMPLQhRtaqdY0ND77jXlvlIPzARZIKe8bx1hswzmVFEKMQlVrvYGVVuvmSCktwGkhxD/GOTQESlu1r/kaxz5lw7E0SaAdmubfIOHrKdbzkca3AFZLKTtYbyiEKJvI/o4igLFSyu8THKO/A8eYBrSQUh4UQnQB6litS+x8BUoa0drxIYQItvO4Git0lVPzb5BHCFHVmO4AbElkmx1AdSFEQQAhREYhRGHgBJBPCFHAav/EWAu8ZexrMnLX3UNFX3GsBLpZtc3lFEJkRUkOthRCeAohfFDV25TwAa4a7/R2TLCujRDCxShzfuCkcey3jO0RQhQWQmjB6VSiHZrm3+A48JoQ4hAQAHyXcAMpZSjQBfjD2G4HUFRK+QBVxVxqdAqcT+IY/YC6QojDwF6ghCHovFUIcUQIMV5KuQr4HdhubDcP8DG0IGYDB4A/gc02nNMHwE5gNcrpWnMS2AgsB3oa5/AjcAzYZwzT+B5dY0o1+uV0zVPFqFItkVKW/LfLokl/6AhNo9GkG3SEptFo0g06QtNoNOkG7dA0Gk26QTs0jUaTbtAOTaPRpBu0Q9NoNOkG7dA0Gk264f/4IyyLcckKdwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 23;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\\nfrom torchmetrics import ConfusionMatrix\\nimport matplotlib\\nfrom mlxtend.plotting import plot_confusion_matrix\\n\\n\\ncmat = ConfusionMatrix(num_classes=len(class_dict))\\n\\nfor x, y in test_dataloader:\\n\\n    with torch.no_grad():\\n        pred = lightning_model(x)\\n    cmat(pred, y)\\n\\ncmat_tensor = cmat.compute()\\ncmat = cmat_tensor.numpy()\\n\\nfig, ax = plot_confusion_matrix(\\n    conf_mat=cmat,\\n    class_names=class_dict.values(),\\n    norm_colormap=matplotlib.colors.LogNorm()  \\n    # normed colormaps highlight the off-diagonals \\n    # for high-accuracy models better\\n)\\n\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\\nfrom torchmetrics import ConfusionMatrix\\nimport matplotlib\\nfrom mlxtend.plotting import plot_confusion_matrix\\n\\n\\ncmat = ConfusionMatrix(num_classes=len(class_dict))\\n\\nfor x, y in test_dataloader:\\n\\n    with torch.no_grad():\\n        pred = lightning_model(x)\\n    cmat(pred, y)\\n\\ncmat_tensor = cmat.compute()\\ncmat = cmat_tensor.numpy()\\n\\nfig, ax = plot_confusion_matrix(\\n    conf_mat=cmat,\\n    class_names=class_dict.values(),\\n    norm_colormap=matplotlib.colors.LogNorm()\\n    # normed colormaps highlight the off-diagonals\\n    # for high-accuracy models better\\n)\\n\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\n",
    "from torchmetrics import ConfusionMatrix\n",
    "import matplotlib\n",
    "from mlxtend.plotting import plot_confusion_matrix\n",
    "\n",
    "\n",
    "cmat = ConfusionMatrix(num_classes=len(class_dict))\n",
    "\n",
    "for x, y in test_dataloader:\n",
    "\n",
    "    with torch.no_grad():\n",
    "        pred = lightning_model(x)\n",
    "    cmat(pred, y)\n",
    "\n",
    "cmat_tensor = cmat.compute()\n",
    "cmat = cmat_tensor.numpy()\n",
    "\n",
    "fig, ax = plot_confusion_matrix(\n",
    "    conf_mat=cmat,\n",
    "    class_names=class_dict.values(),\n",
    "    norm_colormap=matplotlib.colors.LogNorm()  \n",
    "    # normed colormaps highlight the off-diagonals \n",
    "    # for high-accuracy models better\n",
    ")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "93b88252",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torchvision      : 0.11.2\n",
      "torch            : 1.10.1\n",
      "sys              : 3.8.12 | packaged by conda-forge | (default, Oct 12 2021, 21:59:51) \n",
      "[GCC 9.4.0]\n",
      "numpy            : 1.22.0\n",
      "torchmetrics     : 0.6.2\n",
      "pytorch_lightning: 1.5.1\n",
      "matplotlib       : 3.3.4\n",
      "pandas           : 1.4.1\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 24;\n",
       "                var nbb_unformatted_code = \"%watermark --iversions\";\n",
       "                var nbb_formatted_code = \"%watermark --iversions\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%watermark --iversions"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}