pytorch-lightning_ipynb/mlp/mlp-basic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cc648582",
   "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": "13354529",
   "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": "0f0b986d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext pycodestyle_magic\n",
    "%flake8_on --ignore W291,W293,E703,E402 --max_line_length=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "782b20a0",
   "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": "441f19f3",
   "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",
    "# Multilayer Perceptron trained on MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a135998",
   "metadata": {},
   "source": [
    "A simple multilayer perceptron [1][2]  trained on MNIST [3].\n",
    "\n",
    "### References\n",
    "\n",
    "- [1] https://en.wikipedia.org/wiki/Multilayer_perceptron\n",
    "- [2] L9.1 Multilayer Perceptron Architecture (24:24): https://www.youtube.com/watch?v=IUylp47hNA0\n",
    "- [3] https://en.wikipedia.org/wiki/MNIST_database"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "274b586f",
   "metadata": {},
   "source": [
    "## General settings and hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "294fccb3",
   "metadata": {},
   "source": [
    "- Here, we specify some general hyperparameter values and general settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c53a8658",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 4;\n",
       "                var nbb_unformatted_code = \"HIDDEN_UNITS = (128, 256)\\nBATCH_SIZE = 256\\nNUM_EPOCHS = 10\\nLEARNING_RATE = 0.005\\nNUM_WORKERS = 4\";\n",
       "                var nbb_formatted_code = \"HIDDEN_UNITS = (128, 256)\\nBATCH_SIZE = 256\\nNUM_EPOCHS = 10\\nLEARNING_RATE = 0.005\\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": [
    "HIDDEN_UNITS = (128, 256)\n",
    "BATCH_SIZE = 256\n",
    "NUM_EPOCHS = 10\n",
    "LEARNING_RATE = 0.005\n",
    "NUM_WORKERS = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "681a7147",
   "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": "43552cd7",
   "metadata": {},
   "source": [
    "## Implementing a Neural Network using PyTorch Lightning's `LightningModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "036000c8",
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "73206ea6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 5;\n",
       "                var nbb_unformatted_code = \"import torch\\nimport torch.nn.functional as F\\n\\n\\n# Regular PyTorch Module\\nclass PyTorchModel(torch.nn.Module):\\n    def __init__(self, input_size, hidden_units, num_classes):\\n        super().__init__()\\n\\n        # Initialize MLP layers\\n        all_layers = []\\n        for hidden_unit in hidden_units:\\n            layer = torch.nn.Linear(input_size, hidden_unit, bias=False)\\n            all_layers.append(layer)\\n            all_layers.append(torch.nn.ReLU())\\n            input_size = hidden_unit\\n\\n        output_layer = torch.nn.Linear(\\n            in_features=hidden_units[-1],\\n            out_features=num_classes)\\n\\n        all_layers.append(output_layer)\\n        self.layers = torch.nn.Sequential(*all_layers)\\n\\n    def forward(self, x):\\n        x = torch.flatten(x, start_dim=1)  # to make it work for image inputs\\n        x = self.layers(x)\\n        return x  # x are the model's logits\";\n",
       "                var nbb_formatted_code = \"import torch\\nimport torch.nn.functional as F\\n\\n\\n# Regular PyTorch Module\\nclass PyTorchModel(torch.nn.Module):\\n    def __init__(self, input_size, hidden_units, num_classes):\\n        super().__init__()\\n\\n        # Initialize MLP layers\\n        all_layers = []\\n        for hidden_unit in hidden_units:\\n            layer = torch.nn.Linear(input_size, hidden_unit, bias=False)\\n            all_layers.append(layer)\\n            all_layers.append(torch.nn.ReLU())\\n            input_size = hidden_unit\\n\\n        output_layer = torch.nn.Linear(\\n            in_features=hidden_units[-1], out_features=num_classes\\n        )\\n\\n        all_layers.append(output_layer)\\n        self.layers = torch.nn.Sequential(*all_layers)\\n\\n    def forward(self, x):\\n        x = torch.flatten(x, start_dim=1)  # to make it work for image inputs\\n        x = self.layers(x)\\n        return x  # x are the model's logits\";\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",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "# Regular PyTorch Module\n",
    "class PyTorchModel(torch.nn.Module):\n",
    "    def __init__(self, input_size, hidden_units, num_classes):\n",
    "        super().__init__()\n",
    "\n",
    "        # Initialize MLP layers\n",
    "        all_layers = []\n",
    "        for hidden_unit in hidden_units:\n",
    "            layer = torch.nn.Linear(input_size, hidden_unit, bias=False)\n",
    "            all_layers.append(layer)\n",
    "            all_layers.append(torch.nn.ReLU())\n",
    "            input_size = hidden_unit\n",
    "\n",
    "        output_layer = torch.nn.Linear(\n",
    "            in_features=hidden_units[-1],\n",
    "            out_features=num_classes)\n",
    "\n",
    "        all_layers.append(output_layer)\n",
    "        self.layers = torch.nn.Sequential(*all_layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = torch.flatten(x, start_dim=1)  # to make it work for image inputs\n",
    "        x = self.layers(x)\n",
    "        return x  # x are the model's logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0456bb7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 6;\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": "612f27ca",
   "metadata": {},
   "source": [
    "## Setting up the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8370dc4c",
   "metadata": {},
   "source": [
    "- In this section, we are going to set up our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "398a98c9",
   "metadata": {},
   "source": [
    "### Inspecting the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e790d2fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training label distribution:\n",
      "\n",
      "Test label distribution:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(0, 980),\n",
       " (1, 1135),\n",
       " (2, 1032),\n",
       " (3, 1010),\n",
       " (4, 982),\n",
       " (5, 892),\n",
       " (6, 958),\n",
       " (7, 1028),\n",
       " (8, 974),\n",
       " (9, 1009)]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 7;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/dataset_mnist_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.MNIST(\\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.MNIST(\\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_mnist_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.MNIST(\\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.MNIST(\\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_mnist_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.MNIST(\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.MNIST(\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": "7614c2a1",
   "metadata": {},
   "source": [
    "### Performance baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06421076",
   "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": 8,
   "id": "281ba33f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Majority class: 1\n",
      "Accuracy when always predicting the majority class:\n",
      "0.11 (11.35%)\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 8;\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": "de7f0c76",
   "metadata": {},
   "source": [
    "## A quick visual check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bf9a896e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcEAAAHRCAYAAAASbQJzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9d3Rk53ngCf9u5YxKKFShCjmHBjqgc2ISoyhKopJtBVrSeBxmPOs03+63M6s9XnvG6/0cR5bslWWbtiyNJYqUGUyyGZtkNzuigUZo5ByqgEJG5fT90byvgE5MDaBA1u8cHBKNW1XvrXvv++TnkTKZDDly5MiRI8fHEcVWLyBHjhw5cuTYKnJCMEeOHDlyfGzJCcEcOXLkyPGxJScEc+TIkSPHx5acEMyRI0eOHB9bckIwR44cOXJ8bMkJwRw51iBJ0vOSJH3tdh/7PtdwVJKk3tv9vjly5LgeKVcnmGO7I0nS6ppfDUAMSL3z+7/PZDL/vPmrypEjx3YgJwRzfKSQJGkE+GYmk3n5Bn9TZTKZ5OavKkeOHNlKzh2a4yOLJEl3SJI0IUnS/0eSJD/w95Ik2SRJelaSpFlJkhbe+X/fmte8LknSN9/5/8ckSXpLkqT/3zvHDkuS9MAHPLZMkqQ3JElakSTpZUmS/kqSpB/cat1rfh+RJOn3JEm6LElSSJKk70uSVPCOO1Z+P9ua438iSZJfkqSldz6zYc3fHJIkPSNJ0rIkSeclSfoDSZLeWvP3WkmSXpIkaV6SpF5Jkr6w5m8PSpLU/c5nTkqS9Lsf4vLkyJEV5IRgjo86bsAOlAC/wtV7/u/f+b0YiADfvsXr9wO9gBP4Y+D7kiRJH+DYHwLnAAfwfwJfeZ/n8SjwCaAaeBh4Hvj/vvNZCuA31xz7PFAFuIBWYK07+K+AEFe/l6+98wOAJElG4KV31uoCfgH4zhoh+n2uupfNQCPw6vs8hxw5sg7VVi8gR44NJg18K5PJxN75PQL8VP6jJEl/CLx2i9ePZjKZ771z7OPAd4ACwP9ej5UkSQPsBe7OZDJx4C1Jkp5+n+fxPzKZTOCd934TmMlkMpfe+f0p4G75wEwm83drzu//BBYkScoDVrkqTBszmUwY6H5nnXe8c/gngZFMJvP37/zeKknST4HPAV1AAqiXJKk9k8ksAAvv8xxy5Mg6cpZgjo86s5lMJir/IkmSQZKkv5EkaVSSpGXgDcAqSZLyJq8Xwu4dwQFgep/HFgLza/4NYPx9nkdgzf9HbvC7CUCSJKUkSX8kSdLgO+c38s4xTiCfq4rv2s9e+/8lwH5JkhblH+CXuGo1wlUB+iAwKknSSUmSDr7Pc8iRI+vICcEcH3Wuzfz6HaAG2J/JZCzAsXf+/WYuztvBNGCXJMmw5t+KNuizfhF4BLgHyANK3/l3CZgFkoBvzfFr1zEOnMxkMtY1P6ZMJvNrAJlM5nwmk3mEq67SnwE/3qBzyJFj08gJwRwfN8xctZwWJUmyA9/a6A/MZDKjwAXg/5QkSfOOBfXwBn2cmaslInNcLRf5b2vWkQKefGcdBkmSaoGvrnnts0C1JElfkSRJ/c7PXkmS6t5Z9y9JkpSXyWQSwDI/L0PJkWPbkhOCOT5u/DmgB4LAGeCFTfrcXwIOclU4/QHwL1wVVrebfwRGgUmgm6vnuJb/wFUL0Q/8E/AjeR2ZTGYFuBf4EjD1zjH/N6B957VfAUbecbP+KvDlDVh/jhybSq5OMEeOLUCSpH8BejKZzIZbou+yjv8bcGcymdve+SZHju1AzhLMkWMTeMetWCFJkkKSpPu5Grf72Raso1aSpCbpKvuAbwBPbfY6cuTIFnIlEjlybA5ursbjHMAE8GtyicMmY+aqC7QQmAH+BPjXLVhHjhxZQc4dmiNHjhw5Prbk3KE5cuTIkeNjS04I5siRI0eOjy23jAlKkpTzlebIkSNHjm1NJpO5aTOMnCWYI0eOHDk+tuSEYI4cOXLk+NiSE4I5cuTIkeNjS04I5siRI0eOjy05IZgjR44cOT625IRgjhw5cuT42JITgjly5MiR42NLVvUOlSQJpVKJVqtFr9ej0+lQqVSkUikSiQRzc3OkUinS6fRWLzVHjhw5cnwEyBohqFKp0Gq12O12WlpaOH78OC0tLRQVFeH3+xkZGeFb3/oWMzMzzM/Pb/Vyc+TIkSPHR4AtF4IqlQqDwUBdXR0WiwWXy0VDQwN1dXWUlpbidrvRarUolUr27NnD0NAQra2tJJNJUqnsHGwtSRJmsxmTyUR1dTXBYJDOzs6tXlaOWyB7IKxWKxqNBo1Gg8PhwGAwABCLxRgeHiYUCrG4uLi1i81xUxQKBXa7HaPRiNvtRqVSoVKpGB0dJRgMEg6Ht60nSalUYrfbqaioIB6PE4/HGRsbY3l5eauXtq3ZUiEoSRIWi4XS0lL+n//n/8Hn8+HxeFAoFEiShEJxNWTpdDqxWCz8l//yXzh16hQjIyOsrKywurq6lcu/KUqlkqqqKpqamviTP/kTnnvuOb761a+Sm9iRnUiShE6nw+v1cvjwYVwuF263m3vuuYeqqioAJicn+aM/+iN6enp48803t3jFOW6GXq9n//791NfX88UvfhGLxUJeXh5/+qd/ynPPPcfQ0BDhcHirl/m+USgUGI1GDh06xO///u8zMzPD9PQ0/+N//A/Onz+/1cvb1myZENTpdOh0Onbv3k1lZSVutxur1YparQYgk8mQSCRIp9OoVCqh4RUWFlJTU8Po6GjWCkGNRsO9997Ljh07MBgMWCwWvF4vS0tLrKysbPXyPjAKhQKHw4FSqUSSft6Kb+3/30zQZzIZ0uk0CwsLJBKJDV/re0GhUFBcXIzdbqe+vp7CwkKam5uxWCxYLBby8/PRaDRkMhmsVitHjx7F6/Wi1+sZHBxkcHBwq0/htqFQKFCpVDQ1NVFZWUkkEiEUCnH69OmsFRpqtRqdTkdBQQFWq1Vcyz179uD1enG73eh0OvR6PQ6HA5fLxfj4+FYv+wOh1WqprKyktLSU/Px8wuEwKpVq3bO31SgUCrxeLzabjT179mAwGIQhA5BIJEgmkwQCAVZXV5mZmSEUCjE7O0sikSAej2/JurdMCBqNRmw2G3fccYfYgHQ6HXB1w0ylUsRiMRKJBAaDAZVKhcPhoLi4mD179pBMJhkeHt6q5d8SnU7HL/7iL9LY2AiAyWSisrKSoaGhbS0EVSoVRUVFwj29FkmSbmnpyg9AOBzOKiHY2NhIVVUVn/vc5ygoKKC0tPSGQt1sNvOpT32KqakpSktLefrppz9SQlCpVGIwGLjnnnv4/Oc/LyyNzs7OrBWCOp0Ou93Ozp07qa6u5p577sHn81FcXCyUafm+dDqd+Hy+bRuW0Ov1NDU1UVdXh9PpJBgMbvWS1iF77mpqaqitreX3fu/3KCgoENcBIBQKEQqFuHDhApOTk1y4cAG/38+lS5dYXV396AtBhUKBRqPB7XZTXFzM7t27KS8vZ9++fbhcLhQKBaFQiGAwyNDQEN3d3QwNDbG8vMyXvvQlSkpKKCsrw263c+zYMZaWlmhvbycSiZBMJjfrND4QZrOZmpoalpaWGBsb2+rlvCeUSiVqtZqqqiqKiopwOBxYLBYOHDiAwWC4oTV4KyEoxzAuXbrExMQEL7/8Mqurq0Sj0c04nesoKSnB4/Hw6KOPUllZSXl5OXq9/qbHh0IhXn/9dYaHh3n77bfp7e3dxNVuPDabjaqqKioqKvB6vfT09DA8PJw1CstanE4n+/fvp7q6ml27dlFQUIDNZsPr9WI0Gq9T0D4KaLVa6uvrKS4uzirrTxZ+O3fupKGhgXvuuYfy8nJsNtt110Gj0aBQKNixYwfl5eXU1dWxurrK1NQUPT09nDp1ivHxcWZmZkgmk5sWPto0IahSqbBYLPh8Pnbs2MHx48eFBajRaIjFYiwvLzM5OUl7ezuvvfYa7e3tBINBmpqa0Gq1FBcXYzKZqKuro7W1Fb1eLyyMbCOdTpNOp5EkCb1ej8fjwWQybfWy3hMKhQKtViss2KamJoqKinA6nRw9elRsNDd6GOUb91prKh6PE4vFcDqdDAwMcOnSJVKp1JYJwfz8fCoqKti3bx8VFRWoVCrS6TTxeFy4bteyuLhIe3s7g4ODtLa2Zn2Gsnx9FAoF6XT6XZ8Rs9lMeXk5hYWF2O12lpeX8fv9WfNsSZKEJEmo1WqcTid79+6lpaWFu+66SyS/3Aj5OUylUpu6sd5OJEkS+5/L5QIQ13Srz0ehUKBWq6msrOTo0aMcO3aMoqKiGx6rVqtRq9Xr/p5MJlldXeXs2bMsLi6SSCRYWVkhHA5v2r234UJQvoCNjY38L//L/0JhYSE+nw+LxYJOp8Pv9xMMBnn++ecZGxujtbWVlZUVFhcXCYVCpNNpXnvtNYLBIM3NzRiNRgoLC3E4HBiNxqx01aRSKXp7e1Gr1VRXV2/1ct4XBoOB0tJSDh06xBe+8AWcTidWqxWtVotarX5XTftGglHevOQM3/LyciKRCB0dHfzgBz/Ykixfr9dLXV0dJpMJhUJBLBajt7eXn/zkJ0xMTDA6Orru+EQiwdTUFJFIhOXl5awRDjdCo9Fw11134XK5KC0tpaOjg6eeeuqGxyoUCgwGA7t37+Z3fud3cLvdZDIZOjs7OXPmzJYpKdfidDopKCjg137t1yguLqa+vh6LxYJGo7mlZTQ5OUl/fz+vv/46J0+eZGlpaRNX/eGR49Z1dXXs27cPh8MBQH9/P88//zx+v39L1+dwOKiurubOO+/koYcewmq1vq/XK5VKzGYz+/bto7y8nLa2Nnp6evjBD37A0NDQpmTyboolqFQqsdls7Nq1C6fTicPhEJrZ7Owso6OjtLe3Mzo6SkdHxzrtRqlUMjc3x8zMDOl0GqVSiV6vR6PR3NQa2WrS6TRzc3PMz8+TTqfRaDTYbDYR88xmZKUlPz+fhoYGzGazKBOQyWQyInEpkUjcMjFGpVKhVquRJAmVSoXVakWlUlFSUsLs7OyWXT+tVivcunBVI11YWKC9vZ3h4eHr4n2ZTCYrNO93Q6vVCve71+ulvLz8lhu/bPU7HA4qKyuRJIloNMrc3Byzs7NbLuzlcpWioiJKSkpoaWmhsLCQgoICFArFusSLtcjWXzAYpKenh/HxcZGAsZ2QJAmr1YrT6RSlHwCrq6v4/f4tV1J0Oh1ut5uCggIKCgre9+vlBik2mw2bzUY8Hkej0eDz+VhcXBR76EayKZagWq3GZDJRUlKCRqMBrm46oVCIp59+msuXL3Pq1CnC4XDWbzLvhWQySU9PD2q1mj179lBWVsYv//IvMz4+zksvvbTVy7slsViMkZERBgYG6O7upqqq6johmEqliEQiBAIBRkZGgJvHBD0eD+Xl5ajV6pu6rLaCcDjM4uKiqDcNhUIEAgHa29tZXl7esiD9h0GSJJHd+c1vfhOXy0U4HL5lHFqlUuF0OsnLy0Or1TI1NcX09DQTExMEg8Etr8Wtrq6moqKCX/3VX6W6uhqPx4NKpXrXuF8sFmNmZoYTJ07wF3/xF9v2miqVSmpra6mtrRVZ8rIrNBKJbPn1sVqt1NXVCQtVJpPJfCAFt7q6mpKSElZWVujq6uJ73/seCwsLt2u5N2RTd6W1m6TcCk322Uej0RtqaXLhucViyUqr72bIVhL83BcuKwDZjHwtpqenaW1tFXGlhYUFsYnIWZ7T09MMDAzc8v2amprw+XxZl6wwMzPD0NAQ4+Pjok7QaDRSUFBAOp3edlm8CoUCpVJJaWkpDQ0NOJ1OVCoVg4ODt3SZabVaSktLcblcSJJEMpkkGo1ueTMKvV6P2WymsrKShoYGioqKcLlcIrni3ZA9FeFwmPn5+S23aD8oCoWC/Px8kTwoXx8503Krz0uOCd4oWxzevzBUq9UoFAp8Ph+hUAibzSZaZSYSCWKx2G1dP2ySEJRPQN5Y9Ho98XicaDSK0+nE4/HcdJNUKBSUlZVRWVmZVZbER5V0Ok0kEqG1tZXBwUEeeeQRDhw4wJtvvsnMzAxwVYF5r0Lwy1/+Mrt27UKpVGaVEnD+/Hk6OzspLS2lqamJBx98kIqKCu6//35Onz7N9PT0Vi/xfaFWq9Hr9XziE5/gjjvuwGq1Mjo6yre//e1blnLY7XYefvhhGhsbkSRJlCalUqkt9cq43W527twp7j+fz3fL7N1rkcustrL+7HagUqloaGigoaEBhUIhnrvJyUmmpqa23B36bnwQw0WhUFBVVYXRaKS2tha/308sFmN+fn5DnssNlyqZTIZYLMbExARPPvkkFosFs9lMIBBgYWGBM2fOMD09fVNffSaTIRQKsbq6um1cpel0Gr/fj8vlWufPzsvLw+fzEQwGs/7mjcfjrKys0NbWxuLiIoODg6I5gazULC8vv6u1kK0tqmRLob+/X7ickskkBw4cwGQykZ+fT1tbG5OTk0Sj0aw9DxmHwyEKxOX09EQigd/vv2WbN71eT0NDAz6fD4DZ2Vn6+/sJhUKbtPIb4/P5uPvuu6mpqcFut4u48rXczNJQKBTo9XosFgtOp3NLy3E+KDqdDrPZLOKBcrx2amqK+fn5rHCHbhRmsxm3282nP/1plpeXSSQSQgguLS2xurpKV1cXi4uLH1rJ2TQhODAwwN/8zd9gtVqx2+2Mjo4yOzvL7OzsLU8ik8mwuLjI4uIi6XR6WwjCVCrF+Pg4Nptt3ebpcDioqKggEolk/QMppy6fOXOGM2fO3Jb3/KBxgo0ilUrR3d3N6uoqtbW1lJSUcPfdd1NfX8/Bgwf5zne+w8rKinDbZzMej4fm5mZ8Ph82mw24qshMTU3dMqZiNBrZs2cPRqORTCbD1NQUHR0dW+4OLi8v57Of/SwWi+WGiVnX/n7tfaVUKjEajaLL1MTERNY/c9ciNxRxu93k5+cLS1DeO7MxM/52ILfTtFgsfOMb3xBW/cLCAtPT0wwPDzM5Ocny8jKxWIxkMvmhns9N8y9Go1EmJiaYmZlBq9UKzezdfNpKpZJdu3axc+dO1Gq1qC2TY4jZuDmlUimGh4exWCzr1ud0OkXLt7m5uS1c4cYjt07auXOnKLGQN6pkMsnExAR+v39LlZpMJsPExASLi4t8//vfp66ujkQigd1up7q6mkceeYTKykr+5//8n0xPT2f1JqrRaET5SjKZpLOzk8uXL7O6unrDOIpCocDpdJKfny8sDDkZ4c0339zwZISbIWe2VlVVYTKZ1nUckZHd8eFwmJWVFVwuF3l5edcds7q6SjAYZHx8fMst2w9CQ0MD9fX15Ofno9PpiMfjotHE0NDQVi9vU1EoFJjNZpRKJVarlYqKCs6ePUs0GqWvr297CEE5Bf39IKfVy91iVCoVyWSS5eVlUUyZjZZhJpMhGAwSDAbXXRzZxNdqtVu4uvfGB7HY1hbKWywWmpqaKC0txWg0iuxROeYkj8TaaiG4sLDA4uIiMzMzLC8vs3PnTpqamigoKGD37t04nU5ef/11kV2YjUoXrBeCqVSK0dFRRkdHb6poykJQdrMlEgmWlpZEXd1WJVzo9XqqqqrweDzodLp1STBrmy4sLi6ytLTE3NwcRqPxpkJweXl5ywT6h8Xn81FbW4vZbEatVhOJRJifn6ezs1PE57caOTQi/yiVyndNXHq/HiG5UYLcb9put5NIJPB4PIyNjQnX/wclqzNN3G43brdbtLhSKpX09/fz/e9/n9bW1qyoY/qooVKpMJlMIlvy/SC3O7LZbNTV1fGpT30Kn88nbvh0Os3p06fp6+vjX//1XwkEAlkhVOTNdXJykueffx6lUkldXR1erxen08lv//Zv09PTw7e//W2Wlpay0iKsr6/nkUcewePxkEqlROLEzRJcDAYDX//612loaECtVjM3N0dPT494prZKOSkoKOBLX/oSFRUV1yXLLS0t8b3vfY+pqSlGR0dFMtBjjz1GYWHhumNnZ2d57rnntm2vUEmSKCkpobGxEYPBQDqdJhQKMTc3x+DgYNYk+wwODvJP//RPBINB/H4/R44cwePx3PI1tyskUlBQgNfr/dAJk1ktBK1WK4WFheTl5YnMsNXVVfr6+vD7/VlzI3wUkCQJo9GIXq/H7XZjMplEbOm9vDaTyYj2dx6Ph9LSUnw+H1arFUmSRG3T+Pg4g4ODIsCdLcgJWGNjY4yPjzM5OUl+fj5ms5na2lokSSIvL09kNWcb8qQSnU4nrO1YLHZDYabX67FarVRVVYmG4SsrK4yMjLC0tLSl1rlOpxPTIODn95ZcutPb28vo6ChDQ0M4HA58Pt8NrYBYLMbU1NS2nLUnT/TIy8vDbrcL6162frOpnjocDjMxMcHg4CAFBQU0NzdTUFAgrLebcTvyA+SmHR+WrBaC+/bt4+jRoxQWFqLX65EkiVgsxvT09La8ubMZnU7HnXfeSVlZGXfffTdut5vS0tL3/Pp0Os2pU6dYWlqiqqoKu92O1+tFqVSSyWREzOmtt97i4sWLoiVeNrG0tCQ62re1tfHYY4+xd+9eysrK0Gq1NDc3MzAwkJXuNdnVLkkS4XAYrVaLVqsVsznXuqpbWlqora1l586duFwuotEoly5d4k//9E+3/NzkaTHX9tldWVkhGAzS19fH6Ogo09PTVFZW8vDDD1NcXHzd+yQSCebm5rZlLNBisQgBX1hYiFqtZmFhgRdeeIELFy5kjQCEn3dSunDhAsPDw+zfv19MmrmVkLsdArC7u5vW1tYPXTuYlULQaDRiNptFqyRZu52ZmcHv97OysrItrUC5NdX7dTNuFFqtFo1GQ1VVFS6Xi/3791NYWCimdVzbBeJmyJZeeXk5oVBIdPNfO+9Mrtmam5vLik4kN0IumwgGgwwODjI5OUl5eTkmkwmj0Sgyey9fvpw1mcpri5Xl9SiVSkpKSkgkEuzatYvV1VVR3iKPj6qtrRUxRDnDLhaLiaxKeRbcwsLCh86+ez/Irum1YY5MJsPS0hLBYJClpSVisRhGoxGn0yma6q89Vo5T3awBRzajUChwuVzU1NTgdDrRarVEo1EWFhbo6urK2ik04XAYSZKERVhTU7NhbSJXVlZYWlpicXGRlZWVD31vZqUQ9Hq9NDU1cfDgQVpaWjAYDIRCIU6ePMnFixdF8eR2Y8eOHdTV1fGTn/yE1tbWrV4ONpuNgoIC/st/+S/s2bOH/Px8Ibjeb+BaqVTS1NR0UzeH3OZpYmIiax9kmZmZGWZnZ7l8+TI2mw2Xy4XZbOb+++/HZDLxyiuvZM30Eo1Gg9VqRalUEolEhGLz4IMPsrCwQHl5OX6/XzQ1UCgUPPLII1RUVGA2m0Wykux+g6vXs6ysDI1Gw5kzZ1heXiYSiWzK+chKiEajEevJZDIMDw9z5coVpqamSCQSVFdX09DQwJ49e9YV0ctCVG50no2u65shN5TYtWsXjz76KDU1NRgMBiYmJujv7+enP/1pVoUQ1hKNRonH4zz33HOMjIzwO7/zOxsmBEdHR+nv7xeZ3dtOCBoMBkwmE3q9Hq1Wi8/nQ61Ws7S0hFqtJi8vj8rKShobGykpKUGtVhMMBpmenub1119nYGCAeDyelZbEtSQSCSYnJ0kmkzgcDtHaKltq5Zqbmzl8+DDl5eVYLBbRmxB+brmFQqHrNhJZ6BkMBrGRyud0s3PTaDSYTCaam5tJpVJ0dXXdNGaVDWQyGS5fvkwikaCoqAiPx4PX66W+vp5PfOIT9Pb2ZsVMQbkHb1tbG0899RR79+7F4/EIa66qqgq3201RUZG4TrKlLl9rnU5HXV0dX//618X7OhwOMTlD/tmMa7W6uiqa6Hu9XuDqPZWfn08sFuPhhx8mnU7j8/loaGhAp9MJK1j2SMhW49jY2Ja7d98PcoG/2+2muroai8VCMpmkvb2dzs5OMeYrW8lkMszNzYl8jVQq9Z7aJa5tsbYW2fsXjUZFrfjMzAxXrlxhZGRENFn5sN/JpgtBk8mEz+fD4XCQl5fHkSNHMJvNDA8PYzAYKC8vp6ysTJjTCoUCv99Pb28vzz//PHNzc9vGFRqLxRgeHgZ4z67FzeTAgQP88i//Mna7XbQ0k28oWQD6/f7rZucplUoxaUJ2Rcmvu9kNqdVqycvLEx1ZhoaGSCQSWa3MnD9/nt7eXvbu3SsGh6pUKpaWlnj66aezRgiurKyIVm9ycpOcTi4n9dwKnU4nanHXMj8/z8mTJ4nH40xPT2/KBryyssL58+cxmUzs27dPCDePx4PFYuErX/kKcDVu5nK5rrM20uk08/PzBAIBcY9tF1QqlRgV19jYSCaTIRwOc/bsWTo6OrLC83Ar5NIwk8lELBYTU39uxa3uTbnpyNzcnJjs0traysDAAFNTU7dt3RsmBCVJEkWsu3btIp1OMzMzQ3NzM4cOHRIjelwuFyqVSmwwJpNJpOjLX6Db7UatVvOf//N/ZnJykra2NsbHxxkZGcnq2q1YLEZ/f7+YCp1tyFmCa1OMV1ZWRAZeV1cXIyMjBAIB8Xd5lFVhYSFHjhy54QDNtY3R5Qn1CoUCjUbDkSNHKC0tZXJykqGhIS5evJi12m0ikSASiTA4OIjRaKSxsRGr1cru3bu5ePHiVi9vHcFgkEgkwne/+13cbjdNTU04nU5qa2uxWq2i7u5mNaqy5R8IBAgGg3R1dTExMcGlS5fEGLPNQLYEy8rKCIfDaDQaIRy0Wi11dXXA1V6pN3K3KRQKHA4HO3bs4D/+x/8o1j08PIzf76e7u3vLu+FciyRJaDQa6urq+NKXvsSBAwcA8Pv9+P1+Ll++TG9vb9YLQUmScDgcohb6vViBspKzdg/IZDKMjo4yNTXFd77zHWZmZlhZWWFlZYX5+fnbnhS5oULQbrfj8XjYv38/6XSa4eFh9uzZI6aTyx3hZffazXoDygN477vvPkZHR8lkMiiVStE/Lx6PZ6WrIJlMMjMzk7V+fLnOCn6ebixv+p2dnbz55psMDQ2JprWSJGEwGMjLy6O6upry8vJ17yfHl1ZXV0kmkyQSCXQ6HSaTSUz/rqiowGazCU23ra0tax9uedJ8IBAgEAiQSqXQ6XQUFRVdV5y91cjJL/Pz8+j1emZnZ/F6vWQyGbFe2YKXr/XanqjydAI5Znvq1ClGRkYYHx/f1PZccp/hmZkZVldXRZcQjUaDVqt916QyhUKB0WjE5/Nxzz33iPO7dOkSAwMDjI2NZV1msuwG9fl83HXXXaLObn5+nsnJScbHx/H7/Vm15hshlxE5HA6h+L4XbtQGb35+nvHxcU6ePLnhXogNEYKyZvPJT36SxsZGjh49ilKpFE1P//zP/xybzYbZbKa8vByHw0Fzc/NNpwzIwX6tVovL5aK6uprZ2Vn8fj/j4+PMzMzwj//4j0xOTm4r90e2IQ85/rd/+zeGhobo6upaFw80mUx8/etfp7KykiNHjuB0OtcpLouLiwQCAb797W8zNTXF5OQke/bs4b777qOpqYmysjLgqgUqK0KnTp1ieXlZZC9mG6lUis7OTlGnZTabt3pJt0SOEZ49exaNRsPJkye58847+U//6T+JuGw6nWZhYYHf+73fY2xsjHA4LLJdo9EosVhM9GXc7MQSWelob2/nqaeeYvfu3ZSXl5OXl3fDFmrXIkkSer1ezDCVqa+vF/MjOzs76e7uzpq9wmQycc8993DgwAGqqqrQaDRkMhlefvll3njjDdHEPZuRFZWjR4+KkMeHwWw2Y7VahSdgI6/VhgjBvLw8bDYblZWVVFVVUVBQQCqVIh6Ps7CwQEdHB1arFbPZjEKhIJFICMtA7mMo/ySTSTEBXKVSodPpRBGpx+PB6XTi9/upqqpCpVKJoGw2xA2TySTz8/NZ5365FbL1I6fFa7Xadd34d+zYQWVlJfX19cLdkUqlSKVSopPH5cuXGR8fZ2JiApVKRVFREQ6HA5vNhslkQqlUim5ANptNNOveCuRsWNk6ulGMMplMiu8j27wN1yKfw9LSEgqFglAoxOLiovC4wFVlZWpqira2NoaGhrJKAZGzO2dmZujq6hKbqcvlEu57pVJ5U8+R7FWSrV75PU0mE3a7nbKyMhYXF+nt7c0KISgnmJWXl+P1ejEYDGLs3MTEBMPDw9tiiok8/9Hr9VJUVPSuXVxuVSwvt0iTQ2N6vX77CcGHHnqIY8eOcd999+FyuQDo6+vj29/+NleuXKGtrU3UN83OzlJXV8exY8eEa25wcJALFy5w6dIlpqenOXr0qBgsmZ+fT0NDg8h+y8/PJ5lMUldXx9jYGH/2Z3/G2NgYV65c2YhTe1/Mz8/zgx/8gGg0yte+9rWsyQq9GWq1moKCAj71qU/R09OD1WpFr9djMBj4/Oc/T0VFBcXFxaIIW2ZlZYXFxUW++93v0tbWRkdHB9FoVGRYDg0NMTIywoEDB7j//vtxu92UlZURjUY5ePAgHR0dW9ILUZIk3G43Go1GxP+CweC6Y+TSjx07dogEos0qF/iwGI1Gdu/eza5du6iqqkKhUJBKpXjqqae4ePFiVjeW7unpYXh4mOeffx6bzUZtbS1FRUV89atfJT8/X3SUgVtvqLLSolKpMBgM3HvvvRQVFXH69Oktt67kkFFxcbFYlyRJjI2N0dPTQ1dXF6Ojo1mh0L8bNTU1NDc3s3Pnzhu2vLuWd9sLCwsL0Wg07N27F5PJxLlz5zZMEdgQIejxeETj13Q6TVdXF52dnfT19REIBEgmk+Tn52Oz2aioqBDNsSORCLOzs/T09HDx4kV6e3sJBoMYDAZsNhsOh0N0UJA3Z1lTKCgoQKFQcODAAQoLCzEYDCwsLDA3N0c4HN4SrS+dThMOhwkGg/T39+N0OrFarXi9XioqKhgfH9/SG1xOhljb9Fav11NWVoZarUatVqPVatHpdFRUVFBYWChS69cWME9MTBAIBBgYGBCuG9mikge0ylM1Dh06RH5+vugG39TUJOJACwsLmxp/UiqVNDY2YrfbxZy2ubk5sXEajUYsFsu6e/TaIH42o9VqKS8vx+PxCM1cTjufmJjIyji6jGx9yyODlEqlmKi+Nh67NrEiHA4Tj8eZm5tDp9Ph9XrXbbZy0ow8lmirUSqV1NTUUFtbS0FBgciqHB0d5ezZswQCAZFlme3IiUqy+1LmZgrKu7VNkxPqLBYLJpNpQw2IDRGC1dXVHD58mFQqhd/v57vf/S69vb2cPXsWlUqFXq/n4MGDNDc386UvfQmfz4dOp2NiYoKXXnqJV155haefflqk0F++fFnEGSsrK5mYmMDn81FSUkJ9fT0FBQXk5eVhNpv57d/+bQKBAG1tbZw5c4Y33niDoaGh69L8N5OxsTH+5V/+hTvvvJPDhw9z5MgRjEYj//AP/3Cd5bGZxONxVldXMZlMYlMwm83s37+f/fv3r9sgr+3mn0wmGRgY4NVXX+XixYv09fUxPDx8nWtNdq9eunSJ0dFRHnzwQSFMPR4Pv/RLv4TP5yOZTHLu3LlbTkG/3Wg0Gn75l3+Zuro6VlZWePPNNzl37pw4b4/HQ3FxMffccw/V1dVoNBoh3LNVeKzFYrFw1113UV1dLf4tk8kwPj5OX1/ftrAw5KzAQCAgiqPtdrvYRNfWmPn9fmZnZ3njjTfweDz84i/+4jqLRKFQ4PF4WF1d/dBNl28HGo2GL37xizQ3N1NRUSFitSdPnuQv//Iv1ymT25VbuTzf7TVKpRK73f6eexh/UDY0O1S+Uc1mMx6Phz179qzLGJVbiC0uLvLWW28xNjbGuXPn6O/vF6UPa5ukykHzN954A6/XS3FxMel0mlgsJtxaWq0Wu91ObW0tY2Njon3XViK3cpK/D7nI91/+5V+2dF2tra38+Mc/Fi2aqqqqbtnzTx5sKcdUOjo6eOONN5iYmCAYDN6yi08kEmFxcZFXX32VYDDIfffdJ+rZ8vPzqampoa+vb6NO9YaszXaVs/NqampExvHRo0fZsWMHbrdb9K5dWlqiu7t7XdlINqLVarFYLJSWlpKfnw9c7Y26sLDA7Ozsbem0sZnI+8DNlI90Ok1nZycTExO3vA/fbzekjUJukm0wGNDpdGLG5ksvvcTly5e3jQUoI0+4uN2K1bs14bgdbKh0yGQyKBQKbDYbSqWS4uJiKioqaGhooKamBpfLxfLyMuPj4zz++OOMjo4yMDAgEi2uRXblvPrqq6ILhpxcszaTyGq1YrVa6erqygohuBZJkmhubsbr9X7oDKoPy9mzZxkdHeXee++lurqa4uLim2bowtXvPxAIMDIywjPPPENXVxdvv/32e/osua3Sv/3bvzEwMMCBAwdE1q/L5aKhoYE333zzdp3ae0IWghaLBYVCQXFxMY2NjSwtLbG8vMw999zDsWPHcDqdIjNxcXGRCxcuMDExsalrfT/IGZJ5eXmUlZUJTXphYUHUfc7Pz2+rTfbdSKfTXLp0iaGhITEZI5uRhaCsCCYSCTGWaGpqKmvLhm7G6uoqMzMz61zs2X4NZDZUOsgC6TOf+YyIyZlMJqxWK4FAgJ6eHp599lmGh4fFFOz3OstscXGRRCLBT37yE1577TVcLhc2m42DBw+K+rxz587R3t6ela2TNBoN99xzD263mzfffHNLbnq5zvLZZ5/F5XIRCoXIz88X0wiuZXV1lZ/85CdMT08zMDDA4uLi+/q8dDrN2NgYi4uL/G//2/+GXq9HoVCwvLxMMBjc9A4scqwyLy+P2tpaqqqq+I3f+A3i8TiJREIUmqtUKlKpFMvLy4yOjvL2229ndf9TjUbD8ePHaWpqwmw2o9FokCSJvr4+Tp48uanF75uFUqnkM5/5jHDvWyyW6+7hVCpFf38/V65c2fLM0JKSEoqLi0XLwrfffptz584xPDy8qXHx20UwGCQej3PhwgXRpF2v19+WkUkbzYa6Q+Ui0KamJvHvqVSKdDpNd3c3XV1dvPDCCyIN+P0gl1DI6d9qtRq73Y5CoSAejzMyMiImAWw1ctr6WuGuUqmoqakhFotx6tSpLVlXJBIRbsrR0VHcbjcej4eKioobJg4sLS3x2muvEQwGP3BavexOnZ2dFWn7coLOZsc/5DiS3++nrq6O/Px88vPz1z20sgsumUwyNzfH9PQ0g4ODWxpjfjdUKhVVVVVUVlau69wh913cTiU77xWlUklzc/MN/yY/d+l0mqmpKcbHx7c01iZnJZeXl+N0OtHpdAwPDzM6Osr8/Py2iDdfy+rqKtFolMHBQWw227uGVm7F2uslewW3ZbH8zZDTf//5n/+Zt99+W2RAfVBkoSq7Sn/0ox+RyWTEUNFsYHFxkba2Nnbs2LHVS7kh8tTqF1544abtqODn7tAPa7XKRdnX/ttmP/zJZJI33niDYDDIzp07sVqt1527nAU7MTHBX/zFXzA4OEh/f/+WWxLvhuxqXhuPXlpa2rYTWG7Fe7E2otEoq6urvPLKK1y6dGnLylx0Oh1Go5FHHnmEe+65B5fLtS0tv2uRFcUTJ07Q29tLbW2tGI78QQShrJzLpTLbTghOT0/T09NzQ5eL3Imkv79ftED7sMgbqJw4k21Eo1ECgQCTk5OMjo6K7vDhcHjLa5VkUqkUc3Nzm/Z52eCOky0Dg8HA2NgY0WgUp9OJRqNBo9GICRqTk5MMDw/T1dXF9PR01m9akiSJOlpJksSsQHkO23aLN8nIbf1uNNXkZsgKgNxhSu5JuVWWoDxJZm2510eFTCYj9l85y9tgMKBWq9fNFr0V8vWSE7iCwSCLi4vbTwj+8R//MX/5l395w7+lUinRp3A7mv0fhIWFBdra2giHw7zxxht8+tOfprCwUATyt3sa9HYlnU7T09PD5OQkmUyGqqoq7r77bsrKyqisrOT8+fP09PTw6quvMjk5yeXLl7dFWYFKpaKhoYG6ujoUCgXz8/MMDAzQ09NDf39/ViggH4RYLCYGGq8t+7gV8nDdH/zgB7zwwgt0dXWxvLy8Zc/c2hFly8vLWd+G7/2ysLBAKBTiD//wD6mvr+c//+f/jMvlEv1Q341EIkEsFuO1116ju7tb5HRsOyG4dpJ1jvUTyxUKBWfPniU/P5/R0VGCweDHRhnIRmSLfHh4mHg8jlarZXBwkJ6eHi5dusTY2BhDQ0Mi/Xu7CBB5igdcdcd3dnaKJuDblUQiQVdXF6urq6KJ/nt5TSwWo729nYmJCcLh8JZ+B3LdbEdHB2q1GofDQTQapaOjg/Hx8W2/F8h7XSAQQKvVcvLkSQoKCiguLsZqtYq2iSqVCofDITL35RKL6elpZmdnaW1tZWhoiEgksuHXS7rVly5J0va+IlmKXKu0FXGwHDdnbQ3Z2uuz3a5RXl4ef/EXf0F9fT3Nzc28+uqr/Pf//t8ZGhrK6tKO94J8jd5PnCkbr+O15/Bu8zi3I3KDk4KCAqqqqti1axe1tbWi09fx48dFmVhfXx+nTp3itdde4+LFi0xMTBAKhW7b95HJZG56w+SEYI4cHzF0Oh2f/OQnhRtqcHCQ1157jYWFhds+iy1HjluhUCgwmUw4nU4KCwvJz89HrVaj0WgoLy8X5Tuzs7OMjo6KjP7l5eXbmnyWE4I5cuTIkeNjy62E4NZ3kc2RI0eOHDm2iJwQzJEjR44cH1tyQjBHjhw5cnxsyQnBHDly5MjxsSUnBHPkyJEjx8eWnBDMkSNHjhwfW3JCMEeOHDlyfGzJCcEcOXLkyPGxJScEc+TIkSPHx5acEMyRI0eOHB9bckIwR44cOXJ8bMkJwRw5cuTI8bElJwRz5MiRI8fHlpwQzJEjR44cH1s2ZLL8rZCHSSoUChQKBRaLBa1Wi8lkIhKJ4Pf7SafTpFKpj9SAyRzbF5VKhUqlwmq1YrFY8Pl86HQ69Hq9uEfD4TCRSITh4WFWV1eZn5/f4lXnyJHjvbDpQlChUKBUKtFqtWi1Wurr63E6nVRXVzM1NcVzzz1HLBYjFouRSqVIp9ObvcQcOdah1+sxm800NzfT0NDA5z//eQoLC/F4PACkUikmJiYYGxvjb//2bxkYGODs2bNbvOocOXK8FzZFCCqVSmw2G3V1ddhsNpxOJwUFBeTl5eFyuTAYDDgcDlZWVqivr2dubo5AIEBXVxeTk5PMzc3d1inDOXLcCEmSUCqV5OXlYbPZKCwsxG63U1NTg81mw+v14nK58Hq9mM1mJOnqnE75/k6n0xw/fhyj0cilS5dIJpNZp8RJksSxY8coLCwkkUgwPz/PyZMnSaVSW720HDm2hA0XgpIkoVaryc/P59ixY5SUlFBRUUFNTY3QpK9lZGSEvr4+nnzySTKZDCsrKzkhuA2QhYLMdnNnKxQK1Go1TqeT8vJyWlpaKC8v5+6778bhcKDVatcdv/b8LBYLOp2O48ePk0gk0Gg0ZDKZrBSCd9xxBy0tLYTDYfr7+zl16tS2F4LX3nu3Yrvdlx81bnattuq6bJgQlCQJj8eD0+nkwQcfpLS0lIMHD2I0GjGZTJjNZnHS134p+fn56PV69Ho9x48f52//9m8ZGhpicnJy2z+sHyUUCgUqlYqSkhIKCgqoqanBbrdTWFjIwsICp06dYmpqipGREeLxeFZfO7VaTUlJCffeey/19fU0NTVhs9kwGo3Y7XbUajUA8Xic5eVlotEosVgMjUYjBKdKpcLtduNwOFCpVFmnuMlhiOrqahobG3nzzTdZXl7eFkJBr9ejUqlQq9Viv7Db7Xg8HhwOBxaLZd3xTqeT/fv3I0mSOL9UKsWlS5cYGxvj6aefJhwOb/p5fBxRqVQi9FVeXk5hYSF5eXlUVVUBMDs7y/T0NL29vXR0dDA4OLi569uQN33nZi0oKKC4uJjDhw9TXFxMfX29uCnT6TTJZPKGr9fpdBgMBnQ6HUVFRbz88susrKwwPT2d1RvpWuQEIPn/lUolCoVCJAVJkoRKpRLHyN+JHAfNdqEBoNFoMJlMFBUVUVFRwd69e/F4PFRWVhIIBFhcXEShUBAIBMS5ZRuyIJcTXvbu3cuOHTvYtWvXuuPka7K6ukogEGB1dZVQKCTuU4vFgl6vx2g0otfrxTXOJlQqFTqdDofDgcvlIpFIEIvFtnpZt0TOIbDZbOh0OnQ6HQrF1aR2j8dDWVkZPp8Pu90uhF0mk8Hn8/HQQw+hVCrFe6VSKcxmM11dXbz44otEIpFNUQDkc1Cr1SiVSlQqlVinnAB47b4o7wPbQUG5GfIeZzAYsNlsVFVV0dzcTGVlJfn5+ezatYtMJsPY2BjDw8MYDAYWFhYIBAJEIpFN2y82RAg2NzdTVVXFZz/7WUpLSykvL0en0yFJEpFIhFAohN/vZ3l5ed3rZE3V5XJRWFiIyWRCrVZz11134XK56O3tzTrt+lqUSiVKpRK73S4eQLvdTllZGU6nE4fDgdvtxmq1Ul9fj06nAyAUChEMBhkeHmZ0dJQXX3yRkZERotFoVj4IkiSxe/duPvvZz7Jr1y4qKiowGo1C6/N6vZSXl/PSSy8Ri8Xo7+9nenp6q5e9DoVCQUlJCT6fj69+9auUlpbS3NyMXq8HEJsTwOrqKm+99RZXrlzh2WefZWVlheXlZfLz83E6nfwf/8f/QXl5OXl5eVt5SrekqKiI8vJyrFYrmUyGSCSyaYLgg1JaWorX6+VrX/saFRUV654rtVqNVqtFrVajUCgIhUIkEgmi0SiSJNHf34/NZqOgoAC4er0PHTqE2+3m8ccfJ51Os7S0tKHr12g0FBUVUVJSwtGjR6mtraW+vh6AZDJJd3c34XAYtVpNJBJhdnaWzs5O2tvbmZ6eZnV1dUPXt5GYzWZ2797NwYMH+dKXvoTJZMJgMKDVapEkibm5OSKRCMFgkMLCQnbv3s3Ro0cZGhriT//0T+nu7t6UdW6IEHQ4HJSWllJZWUlRUREWiwVJkkgmkywvLxMIBBgYGGBmZmbd69RqNSaTCUmS8Hq9KJVKNBoNXq+XxcVFNBoNCoUiK+IsCoUCvV6PVqtd54pRq9Wo1WoKCwuFC+1GQjAvL++GQtBoNGI2m7l48SIzMzNZZREqFAry8vLQ6XTYbDYaGhpobGwU1/laTCYTTqcTg8EgtN9sQd5AKyoqqKiooLGxkYKCAux2+zoLXiaVSjE7O8vExAS9vb3CElQqlZhMpqy4J98N2XJXKpWkUimWl5dZWVnZ6mXdENlCLy4upqGhgYaGBsrKyrDZbEIIxmIxoSRmMhnC4TChUIiVlRXi8TihUIiysjKsVisqlQqlUonFYsFqtaLRaNZZiRuBvJ/V1NRQXl7Ojh07qK2tpa6uDrh6TymVSiKRCGq1mnA4TDAYRJIk0uk0eXl5LC4usri4SCwWIxQKiXPNdvR6PXa7ncbGRhobG6mvrycWixGPx1laWiIUCjE6OkooFGJhYYGioiLcbjcejwe9Xk9BQQETExOsrq5u+LO1ITtTeXk5+/fvx+v1YrVakSSJeDzO4uIiFy9e5OTJk7z++uv09PSse53JZMLn8/FLv/RL7Ny5E7j6MDQ1NYkvVXZJbTV6vZ6dO3dSXV3NXXfdJTZMvV6PTqejqakJg8EA/Nwdcm2N5NqH0GAw4PP5KCgoYPfu3bS1tbGyskIoFMoKIahQKDAajdx7773U1tby6KOPYrfbcTqdG76ZbAQulwuPx8Pv/u7vUldXh8vluuV5JJNJAoEAgUCAYDAorsmxY8c4fPgwZWVl5OXlZZ0L9Eak02mi0SgXLlzgypUrWXF/XYvJZCI/P5+vfOUrfO5zn0Or1V7nYp6cnKSjowO4en2ef/55JiYmmJycJB6PE4vFePTRR/n1X/918vPz1ymrGy1IJEnC5XJRWVnJt771LdxuN/n5+cIYkI+pra0V/y+7Q++8806i0SjT09MEg0GeeOIJhoeHOXPmDNFoNOu9YWq1murqanbu3Mn//r//75jNZhQKBSMjIwwMDPDUU08xMDDAwMAAsViMdDpNU1MTDz74IEeOHKGhoYHDhw+j0+k4efLkhsduN8wSLC4uXue/X15e5uLFi7S1tdHZ2Ynf7ycUCq17XSqVQq1WMzMzQyAQEBl3er2evLw8KisrUSqV9Pb2bsSy3xW73Y7JZKKkpAS73U59fT1FRUVUV1eLYzQaDRqNRsQwbkY6nWZ1dRVJkjAajSJuKKNWq7PGepIkiZKSEtxuN/v376esrAy3243BYECtVhOPx4lEIszNzZFKpSgqKhJWsKwNy79nCw6Hg6KiIvLz84WlIN+ra0mlUvT19TE+Pk5PT49IzpJjO06nE7fbLbJBV1dXCYfDWR3PSaVSJBIJ5ubmWFxczMp1yjHYaDRKKBRifHyccDhMIBAQQntiYoL+/n7g6jn19vYSDAaZn5/HZDJRV1eHz+cTnoh0Os309DRjY2OEQiHi8fiGrV92tVdWVmK320mlUnR0dBCNRoW7VrZ25f/q9XocDgdqtRqNRkN+fj5Go5EDBw5QVFSEVqslEAjQ398v3icbUSgUOBwOnE6n8OwtLi7S1dXF2bNn6e3tZWpqioWFBZLJJJlMBr/fT1dXF/X19SiVSnbs2IFer2dpaYlAIMDQ0NCG3acbssuWlpaKoKfM5OQkf//3f09fXx+dnZ03fF0sFhMn3NnZSX19PW63G51Oh9Pp5K677qKtrY2+vr4teXCrqqqoqKjgy1/+Ml6vV6xNtvjeD+l0mkAggCRJlJaWrhOAa63FbLAsFAoFR48epbm5ma997WtYrVbxN0mSWF1dZXFxkbfffptYLMbnP/95kfRjMBhwuVwizpYtlJaWsnv3brHR3Ix4PM7TTz9NZ2cnL730klDcNBoNRqORwsJCSktL0Wg0JBIJpqenmZ2dJZFIZK2LNB6PEw6HmZiYyLo4rUwsFmNxcZGRkRG6u7s5e/YsExMTvPLKK0QiEQBx38ms3ROKior41V/9VaqqqnC73cBVa/HixYt0dnYyOzu7oR4llUrFwYMH2bFjB2azmcHBQR5//HFmZ2cJBoNC+On1etRqNUajEa/Xy759+/B4PCLr1ePxUFFRQTgcprOzkwsXLvB3f/d3TE9PZ60QVCqVlJSUUFRUhEqlYnV1ldHRUZ555hl+9KMf3VBBnJyc5OWXX2bfvn1kMhkeeeQRIpEIdrudtrY2vv/97980kfLDsiFC8MyZMyJjLpVK0dPTw9jYGFeuXCEYDN70dXK2lKypptNpIQQUCoUIgq9Ne94sJEmioaGB/fv3U1pais1mWxfrktckZ3alUilRh5VIJEgmk8zOzjI3N8fq6irJZBKz2Yzb7aaoqEgIwWQyKdrHTUxMbLnro6CggPz8fA4dOiTc0vI1CYfDLC0t8eabb9LZ2UlfXx9qtZr9+/eLUoHi4mIeeOABAoEAk5OT4ty3mvn5eSYmJojH4zesb0yn07S3tzM0NMSpU6cYGRlZZz24XC7Ky8spKioSJRHLy8ucOXOG7u5uEolE1rkZr1WsstEClEmlUsRiMd566y2mpqaYnJxkeXmZYDAonol4PL7uHJRKJWazmbvuuouGhgbq6upEjHd+fp75+XneeOMNurq6NlSArK03tVqtzM/PMzo6yoULFwiFQoTD4XUZ4nLm6NDQEIODg+Tl5WG1WvF6vdjtdpqamjCZTHg8Hvbu3YtSqWRsbIyxsTHa2tpEkmG23G+SJGGxWERDicXFRbq7u9eFEa5FqVSKrGp5f9BqtezYsYNoNHpDL83tYkOE4Llz5/D7/fh8PhKJBM8884woeH837VhOEb6224ZcdL+VLsLa2loOHjxIUVHRda5Oea3xeFykngeDQc6cOSP6Svb29tLf308gECCRSHDo0CF27NjBww8/LN4nkUgQiUQIBAJMTU1t6vndiIKCAqqrq9m/fz87duwQwj6TyYgs39dff50XX3yR+fl5bDYb4+PjaLVa7HY7RUVFFBYWcvr0aVpbW4lGo1klBGOx2LqNdG2pyqVLl3j77bc5d+4cs7Oz4hg53rNjxw6Rng9XlYLz58/T09Ozoa62D4rsdoPsFoDwc3fo22+/zdtvv/2eXqNWq7HZbDzyyCNUV1dTXV0t7te5uTnGxsY4deoU3d3dG3p9ZKFms9kwm83Mzc0xOjpKW1vbe/IOyElb5eXloqFIWVkZe/bswe12s2PHDoaGhkRMTU4CyhYhKPeEXusKvXLlCnNzczc8Xt7bDQaDEIKZTAa1Wk1dXR3z8/PbTwiOjo4yOztLd3e3SEOWTyzbH76bkclkePPNN1laWuK+++7DbrejUCiIRqPMz8/j9/uF9ba0tMTc3ByhUEjEMFKpFCsrK6yurhKLxdDr9UJjXSvYOzs7uXjx4pa7qcxmM06nk/vvv5+77roLn88nbsT5+XnOnz9Pa2srr7zyCrOzs2QyGe655x7Ky8upra0VSQDyT21tLceOHeOFF17ICjfOxMQE4XCYS5cuEYvF8Pl8LC8v09vbS09PD52dnVy5coXp6el1afQajQaLxcLBgwd57LHHKCkpETGNoaEhLl68mBXKy40oLCxk586dIit0q70Mt4u8vDwsFgv33HMPVVVVHDhwQCgmc3NzTE9P8+STT3L27FmGh4c3vOwomUwSDod55plnsNlsJBIJJiYm3vNnygbAyMgIfr+fYDCI2+3mvvvuo6ysjP3795Ofn4/dbken0zEyMsJ3vvMdsfdk2x47OzvL22+/vW5PkzPNnU4nBw4coKKigl27dlFTU0NeXh4KhYKVlRWeeOIJ2traNlRx3hAhuLy8fF0N4EeBkZER0uk0FRUV5Ofno1QqRfH00NAQw8PDDA8PC6F4s01GLv2oqKigrKwMhUIhLJCpqSkuX7685anrOp0Ol8tFdXU1u3btWpdZFw6H6enpob29nTNnzuB0OrHZbNTX11NTU0N+fj4mk2nd+8lW4a2ShTaTlZUVkskkQ0NDIvNwbm6Ojo4Ozp8/z1tvvcXS0tI6gS1JEhqNBqvVSnFxMc3NzeK6LS0tEQwGmZqaytoJEmazmYKCApFunw0W+YdFkiRsNhsej4c9e/ZQU1OD1+sVJQezs7MMDw/T1tbGmTNnWFlZ2XCLKZPJkEgk6OnpQavVitKN9yqc5LCQvI/OzMxgs9mw2WxEIhGqq6ux2WzY7XZ27txJYWEhTz31lKhd3WohuDasBT+P72YyGVFLrFKpcLlcokFFbW0tBw4cQKvVolKpiEQirKys0N7eTk9Pz4aeU3akH24T+vv7GRkZob29XSR+pNNpEokE8Xhc/MgxzZtRU1NDWVkZlZWVFBYWolAoiEQiLC4u0tbWxokTJ9a537YCj8fD0aNHqaqqElavzMLCAq+99homk4nf+I3fYNeuXVRWVuJ2u0XHlGuR3dxb/YDKyMXif/VXf4VOp0Or1QoNXm7osHazlONNRUVFHDlyRLR8kiSJVCrF4OAgfX19LC0ticSNbEWupcvWxJ33ik6nw2g08thjj/Hggw/i9XoxGo1oNBpGR0f58Y9/TG9vL+3t7UxOTm6KAJRJp9OMj4+LPeLDftfLy8s8++yztLe3MzAwQEtLC3v27BGF+Pfffz8+n48f/vCHW94FKJVKMTo6itVqJZ1O09DQwH/6T/+JxcVFQqEQ9fX12Gw2TCYTer2e/Px8UQUgGwSXL1+mr6+PEydObHinsKwSgnKgWM64XOsmlDWj96NR3W7ktOQPY6XJjQAqKysxm82iKXM8Hmd+fp65uTnm5+e33FWlVqsxm83odLrr6uc0Gg0ulwuXyyWKf0tLS4WWt5ZwOMzKygqBQEAU/2cLmUyGQCDwno5VqVT4fD7Kysqoq6sjPz9fCFK58HdsbIxEIpE1gv5a5JjgWi19OyInycltGWtra6moqACuWh3j4+MMDAzQ0dHB0NAQIyMjhMPhTT/n23mvp1IpFhcXUSqVXLlyBavVSn5+vshu9nq9zM/Pi3rkrbwH0+m0KHNbWFhApVJRXV3N6uoq0WiUuro6rFar2FvkbmKAMCgGBwdFHPHaUrrbTVYJQa1Wi8PhoKSkhNra2nUtqCKRCGfOnGFwcDBrN5l3Q64FvP/++7nzzjtFoXkmk2F+fp729nYmJiY2/KJ/WCorK/nTP/1TUfC/ti/qtfT19fH666/z3HPPceHChaxodPBBsNlsfPWrX6Wuro4777xTCPuBgQGGh4f5wQ9+wODg4JZr4bdCHlm2sLCw1Uv5UBgMBsrLy3nwwQd57LHHhCC4ePEiQ0ND/NVf/RXT09P4/X4h8LfrnnEt8/PznDlzhlAoxOzsLHa7HaPRSGNjIwqFAoPBQCKR2FIlOh6Pc+rUKWZmZti9ezeVlZW0tLQAVxXPtY1DrmVhYYGZmRkef/xxzp07tyn7RVYJQTnmIrs5VCoVmUyGWCzG6uoqc3Nz2zrWmJeXh91uF90jVCoVyWSSpaUlhoeHOXXqFBMTE1u9TOBqDdbY2Ni6GMPa+XnXxvyuRU5xn5qaorW1lampKVFEvp2QJAm73Y7X66WmpkY0gZDd4ENDQ7S3tzM7O7ulXor3gkajwWAwbMtnSN4b5PZa+/fvZ+fOnTidTlZWVvD7/Vy4cIHBwUEmJydFq7GPGnIZVjgcZmFhgVQqJeLUVqtVNOneSiEo79nBYJBTp04xOTnJ/Py8aDY/Pz9PKpXC4/GQl5dHaWkpcNWCnJiYoKenh9nZ2U3bL7JKCMqmsdFoFIkYmUxGJB1MTk7ess4w2/H5fDQ0NFBRUSEKeMPhMCMjI5w+fZrvfe97WbOJzszMcObMGe64444P9Hp5YGtnZyc/+9nPiMViW+7i/SAoFAqqqqpobGzk0KFDwjuRTCaJRqOcOnWKl19+Gb/fnxVZr7dCr9djtVpvmqqezahUKsxmM/fccw+NjY186UtfQqfTodFouHz5Mp2dnfzwhz9keHiYYDC47ZSt90s4HBbX0WAwYDAYmJ+fR6fTZUWnqVQqxdTUFH/3d38nBlIXFRXhcrm4dOkS4XCY+++/X3T1kfvZtrW18cILLzA9Pb1piVub/m1ptVoMBoNoqbMWu91OQ0ODqO+Bq1/m5OTkprQ62ijkQtdDhw5x9OhR3G63OL9IJCLacWWLAAREreLFixdxOBzs3bsXh8MBIPrA6vV6UQt0LTMzMzzxxBOcO3eOWCyWNTEouc2Zy+XCYrFQUFAg4rIrKyuMjY2J6Qpw1Xr69Kc/TVVVlUj4SSQSdHZ20trayuXLl2+ZCZwNyHF22RMxPj6+1Ut6z5jNZkwmk2gddvfdd4smy3JS0tzcHBMTE6jVaqxWq/BCbFfX+3vBYrHg9XrR6/WkUimGhobo7e3Nqj1SzpKVPQ/Ly8uMjIyIRiH79u2jvLwcpVLJwsICY2NjdHZ20tnZuanXblOFoNxGy+FwUFVVhcvlWvf3goICDhw4QGVlpfi3TCbD9PQ0k5OTotB6O3S8WIvZbKayspJ9+/Zx7733ioHCcmKF3Esvm5CTgNra2lCpVKIbP1xNPpidnRUZXjJr57nNzMzws5/9jPHx8awQEHIMIj8/n4aGBurr6/H5fDQ2NopzmJ6e5syZMywsLAgtW6fT8dBDD1FcXIxWqxVF3N3d3fzsZz+jq6vrumko2YZKpcJkMpGXl4fNZkOtVm+bZ8diseB2u7n//vupr69n165dosxGbqqxsLCA3+9Hp9OJuYJyD9ftXJt8K8xm8zohODAwQH9/vxgnlS2kUilCoRChUIjp6WkkSaK6uhqr1cqePXvwer0oFApRUN/d3X3dYIWNZtOEoMvl4uDBgzQ2NtLS0iICumvRarVimreMUqmkubkZp9NJX18fy8vLJBIJZmZm8Pv9IhaTzciFrnV1dZjNZlQqFfF4nLfeeou+vj5efPHFrN1I+/r6WFhYIBgMigLkVCpFNBrl6NGj/MIv/II4VpIkwuEwp0+f5tKlS/T392+5Nq7T6dixYwfFxcUcOXJEuGUsFgsGg0FcD7jaVNvr9YquP3DVHerz+UQG29LSEleuXOHSpUu0trZu+Dy624HBYBATXTQaDalU6rqWY9nK4cOHOXbsGIcOHaKgoEA0YpcTLBQKBXfffTc7d+4kGo2KLOtAICBihFeuXBFNKrY7sqDft28fn/70pykoKCAcDvPKK6/Q2dmZ1ddVr9djMBj44he/yO7du3E4HKRSKWZmZjh16hT/7//7/zI8PLzp69pQIShnD5rNZnw+H83NzbS0tHDs2LFb+q7XutfkFlWyMFxZWSEWizExMYFWqyWTyYgZgze7+FvpjlOpVNhsNqqrq8nPz0ej0QCI2rKenh6Gh4c3fFzIB0XudRqJRIQ7UK1Wk5eXJ8bAwM8LZCORCFeuXKG3t5eFhYUt0Uplq092AVZVVVFXV8fdd9+N0+lc181mLWazmfz8/Bu+p3xvra6uMjg4yNjYWNYqLtciT/LQarUolUoxnSFbN8u15Ofni0nkFotFuNjkrirpdFpcU6VSKaazTE9Pi/OT2+N9VISgy+WiuLiYmpoaNBoNoVBIlIJkS9jhRshewB07drBr1y70ej3RaJRAIMDw8DCXLl3akv1iw4SgJEm43W5KSkr4b//tv4lBsrI2IBdfy70b5a7qN+oRJ4+s+cVf/EWR7iwXpre1tTE+Ps709PQNb/JMJsOJEyfo6+vbqFO9KXq9ntraWvbs2cPhw4eFAISrrpzW1la6urqypqn0jZCtopGREXFtGhoa+K3f+i3Ky8vFcZlMRnTM+du//VsmJye3rGZOHkz8mc98hurqau6//37RWktucnAta6fI3+jf5Iy3zs5O/vAP/zBru8K8G5lMhv7+ftrb27M+kQegtbWVWCyGRqOhuLgYuJpG39HRwdzcHIFAAI/HIybI5+XlsWPHDqqrq0Vf12AwyOXLl7fcK/FhkLNjq6ur+epXv0pLSws2m41AIMD09LRQzLIxIUiuTz127JiYRlNQUCBCXT/4wQ+4fPnydX18N4sNE4IKhQK3201ZWRk1NTU4nU4UCoVo9hqJRIhGo6LvZGFhIQaDQcSd1vry5WkSa6d+y3+PRqPk5eXhcDiuCwjLNULvtQHv7Uar1VJWVobX6xVxp0wmw8rKiniA5Rl82aqVy99zPB5HoVAIrbu0tFQkyiSTSRKJBJOTkwwPD+P3+1lYWNiSc1IoFHi9XrxeL42NjVRUVIhZbIAobVheXhZz3WQl69qmADcSlkqlUkwzkT0Q2Y58jmtne8r3XbYTDAbFaLX5+XmRLd7V1cX8/DwzMzMEg0GsVisul0sMerZarTidTjGTdDsOfl6LSqWioKAAn89HdXW1uF/lpKBsSoi5lrWjouT6b6VSyczMDFNTUwwMDBAIBLZsD9wQISh3BX/ggQdobm4Wk4XhajPVwcFB2traGB4e5sSJE2QyGf7Df/gP1NbWcuedd4rNRx5LFIvFkCRJjOZY+zm1tbVUV1ffcDNaXV1leXmZF198kYsXL27Eqd4Sm83GF7/4RSorK9cljVy4cEH03pyamtoWGylctbAeffRRduzYgdfrFQkKS0tLzM/P8+yzzwqNe0s0OpUKjUbDL/3SL/Hggw9SXl5+XechuSfhiRMn6O3tFcNLH3vssVvOFZTdqzt27OBb3/oWzzzzDE8++WRWZb7eDNl9LYcP/H6/6G6T7QwODjI8PMzbb78t9hDZ9S73bZUbNUiSRF5eHl/4whfYuXMnX/nKV7JiHuftIC8vj0ceeYTdu3dz9OhRJEkikUjw+uuvc+bMmXVzFbONvLw8qqurOXjwIHfffTdKpZJwOMzzzz/P5cuXee2117bUK7EhQlClUqHVaikuLqasrGydC8rv93P+/Hm6urqYnJwUcRt5yvda5C7qMzMzZDIZCgoKxHvZ7fbrsktl5Eyk6elpJiYmNjXzUqVSoVarKSkpoaqqiqKiIpFQIrcEkt1R2TT+5N3QarVYLBZ27NghYhGydi1rc4ODg0xMTGyZa1cuefB6vRQUFKDX60VDgmg0ytzcHMPDw/T29tLZ2UkgEKC4uBir1Xqd0JYzd+XxX3KDAKPRSGVlJc3Nzfj9frq7u5mZmcladzb8PI4kD38Oh8MsLy9vC+VLjvu91+9XrVazuLgoWhvKFshmZxzeTuRnr6KiQjQHn5iYYGxsjK6uLjFSKduQJAmtVovP5+PgwYP4fD5UKhWhUIj5+XkuX75MT08PsVhsS+/FDRGCsvnb1NTErl271v2tp6eHH/7wh4yPj7O8vMynPvUpGhsbOX78+LpJBQCnT5/mrbfeorW1lXg8Tn19vegy3tLSwpEjR274+aOjo5w4cYK2tjYuXry4qRuUPEz4gQceoK6ujvr6emExRaNRFhcXeeONNzh58mRWjj25GWazGY/Hw3333SduZrh6o3d0dPDqq69y7ty5LR0B5fF4aGlpoaqqSsxhk2N5crbgCy+8wE9/+lMRm5bd9DeyGBYXF1laWiKRSIipH3l5eTQ3N6PX6ykrK+Ov//qvWVlZIRQKZa1QsVgsVFdXC2VscXFxWzeduBXyRA/ZG5Gfn8/OnTu5dOnSVi/tAyF7wFwuF3v37qWwsBCAS5cu8fTTT/Paa68xMjKytYu8CSqVSjwv3/zmN3E6ncBVF/fo6CjPP/884+PjW24IbIgQlN0Ucn2IwWAQm4zH4+HgwYMUFxcTCoV44IEHqKqqWtdEVfb1d3V10dXVJYbQyhq5QqEQ7bhuxPLyMsPDwwQCgeuG8240craqHJdaG4uR46Fyskk2C0C5z2lJSQlut5vdu3dTWloq/PlwVaiHQiEGBwfp6OjY8lIVvV6Py+Vady/F43EmJiYYHBzk9OnTxONxDhw4QHV1tZivtzb1Hq4W+k9PT/P666/T399PLBbDbDZz7733ilijXG9477334vF4OHPmjJhenq3XNRqNCqH+UWatQqPX63E6nVkzwuv9IFtS99xzD7W1tbjdblZWVvjZz37GyZMnuXDhQlYnaOn1ejExx+FwoNPpSCaTvPXWW1y+fJnFxcWsuBc3TAjKRZKrq6vrRuu43W5aWlrw+XxEIhHuvPNOiouLxQiNTCbDwsICAwMD9PX10dvby+rqqugMIdPZ2bkRS//QyMLD4/Hg8XjWCUG5i4UcR8rWzRJ+PvOwrKyMHTt28MlPfpKSkpJ1cdloNEowGGRkZER0q9hK9Ho9DodDJMHA1biy3+9nZGSES5cu4fV6aWlp4fjx49TU1ODxeMTxsvImD4R+9tlnOXv2LJFIRDzEO3fuFF3wbTYbx44dw+v1EggExBTtrdZsb4QkSUIIZrPr9nYgSZJ45uTa47X3xHZBqVSi1+s5evQoDQ0NOBwO/H4/L7zwAhcvXqSjo2Orl3hLdDodlZWVFBcXY7PZSKfTxGIxzp07x6lTp1heXs6KZ2VDhGA8Hmd1dZU333yT5eVlHnnkEZF0UFxcjNlsFoKgoKBgXdba0NAQr7/+Os8++6zogJCtbqa1yA/eQw89xM6dO9mzZw8ulwuFQkEikSASiXDixAmeeeYZ2tvbWV1dzerzKi4uZu/evdx3333s27cPl8uFXq8XUy/k8pQnn3yS1tbWrG2OLbsxXS4X9fX1GAwGLBYLDocDk8kkuqfEYjGGh4d5/vnn6e3tpbu7m8HBQaLRqHCxPfXUU1y8eJGenh6OHj3KHXfcQVVVFW63G61WS19fH3/+538uMk+zBb1ej9vtJhaLMTQ0lLU1qbcDrVZLU1MTVVVVornB4ODgtmwaLu8lx44dQ6/X8+qrr9La2spLL72U1YkwCoUCj8dDfX09X//614ULd3h4mJGRETo7OxkaGsoKKxA2SAiu7bCv0+mYm5sjnU5jMBhEDResb7MVi8VYWFhgcHCQ7u5uWltbiUQi20ZrlZOBampq2LNnD263W5RFhEIhZmZm6O3t5ezZs1tWRP5+WFtkXl9fv+5v8XiclZUVxsfHuXDhAn6/Pyuuk5xAsVYYK5VKMZVbTtJa23VELu+Ym5tjZGREjOuS3aCyphqPxxkYGGBpaQlJkigoKGDnzp0itlhTU0M6nUaj0dyw1nUrUavVWCwWEolE1rigNgKNRiMSYeQkO3m6fDYpJe+GWq1Gq9VSX1/Pvn37KCwsJBaL0dfXR19fH6Ojo1u9xFuiVCpxOp1iYIDBYCCTyTA7O0t/fz8zMzNZ1Wlpw+oEk8kkr776KhcuXKC7u5umpia++c1vioa4MnLd3AsvvEBXVxc//elPmZ+fz3pL6VqqqqpoaGjgjjvuYM+ePetcwG1tbfzJn/wJfX19BIPBrHABvBtGoxGfz3fDsoFAIMBPfvITzpw5w+XLl7OmPmlxcZHBwcF1Q4/lfrVrf5dJp9NcuXKFkZER/uZv/oapqSmGh4dFI4Zr3dXpdJr5+XnOnTtHMBjk5MmTfOUrX6GxsZG3336bnp4eFhcXs26yvMlkory8nPHxcTHG5qOEUqlErVZz5MgRampquPfee3E4HEiShN/v59y5c8zOzm71Mt8ze/fu5dixYzzyyCPU1dWRSqWYmJjgRz/60ZYmnr0X5JmGDz74II2NjaK36crKCi+99BL/8i//wtjY2FYvcx0b2jZNbnHW29uLQqGgra0Nk8m0Tgim02lWVla4fPkyfX19osVRtgtAuRZSr9eLtmgNDQ24XC4hOOLxOH6/n6GhISEAs8Fiei/odDry8/PXCfO1XeH7+/uZmprKqg0/HA7j9/tZXl4mHA6LNmHypG1JkkSyljwpQnbNyG3e1grQG5FMJlldXWVqaopkMsnly5dJpVL09PQwMjKSlQlPcoF/IpHYdokx8riktdaEvDfo9XrMZjM6nQ6DwSAm0NhsNpRKJVNTU+Jnu7iAZS9DY2OjKPPp7+9nZGSEQCCQ9W5dh8OBy+USTSoUCgXhcJhAIIDf779pZ6+tZEOF4NpekoODg7zxxhtiEvm1x8kDIrfLA6pSqUSc6dOf/jQNDQ3U1dWtE/AzMzN8+9vfprOzk4GBgazbHG9FQUEBhw4dEq5r+LklNDw8zEsvvZR1mWmTk5PMzc1x/PhxSkpKKC0tXWcFwtVJ8OfOnaO7u5uJiQkuXrzIwsLCe/Y8yElfMzMzzM7O8sd//MdoNBrC4TDJZDLrHvC1TE1N0d7envUb6VpKSkooKiqivr6eTCbDP/zDPwhFpby8nMOHD+PxeHA4HDz44IN4PB40Gg0jIyP8+Mc/5vTp05w5cybrlWq4akWp1WoaGxv53Oc+JwTIP//zP9PR0cHCwkJW318KhYI777yTpqYmHnroIRwOB0qlksnJSU6cOMGVK1eyMpa5KVMk5PEzy8vLN2xcLMcEt4uQkJti33XXXVRWVlJfX09hYSFGo1E08V1ZWRE+8O3UFUZGjuuubUwej8fp6emhv78/65I/4OeDbi9cuEAymcTlcq3r1wpXa0gHBgaYmJhgfn6ehYWFD5TUI2cyy1ZlMpnM+vtXTljbTu7Q+vp6Dhw4gN1uJxwOU1paSiKRoLCwkLq6Ovbt20deXp6wCOXRZP39/Vy8eJHR0dFtc75yQbzH40GtVjM2Nsb09LTwMmwHL1JhYSHl5eXCg7S8vMz4+DgXL14kEAhs8epuzKaNUkqn01m3aX5QtFotRUVF/OZv/iZut5uCgoJ1f0+lUsINev78+azUft6NtYNzjUYj6XSacDjMq6++SldXl7DcswlZ2XriiSd44oknNuUzt4vnAq62jNtu7tB77rmHX/mVX2FiYgK/38/ly5cxGo3cd999lJaWUlNTA1y99sFgkKmpKZ555hm6urr413/916y7R2+F2+3moYceEufU1tbGpUuXOH36NH6/f4tX9+7IswJ37twp3O/yNXvqqaey9r7b9Mny2x25GbFWq8Vutwt3oRx3SiaThEIh3nzzTbq6urJuyOV7ZWpqildffZXjx49jt9vp7e1ldHSU06dPMz4+vu0s248znZ2d/Pf//t/p7+9neHh4y+s53w9tbW08/fTTNDU14fP5ePTRR1Gr1ZSVlWEymcSA4/Hxcdrb2wkEAnR0dKyLHW4XTCYTlZWVojF9IBBgZGSETCaDWq3eFvuI3Je2qKhI1OjK2fDZqpDkhOAHQC4klwezws/dY7FYjJWVFS5cuMCVK1eIRCJZe/FvRSAQ4PTp01RWVlJXV8fAwABdXV20tbVlXSwwx60ZGBhgYGBgq5fxgeju7kalUlFTU4PP5+POO+8Uf0smk4TDYbq7uzl//jwvv/wy09PT26od4Vr0er0Y+JxOp5mbmxPZoNtBCGYyGWZmZhgfHycajZJMJgkEAiwsLGS1K1e61c0iSdL2u5M2GEmSMJlM1NXV8f3vf1+MbwkGg8zMzPDkk0/S0dEhpo4vLi5u2wfSarXi9XpxOp3Mzs6ysrLC8PBw1j+MOT462Gw2zGYzJSUl15XryM21Z2dnRT/UWCyW1RvuraisrOThhx+moaGBhoYGYeH+8Ic/ZHp6esums7wfiouLycvLE/MC5+fnCQaDjI+Pb+m6MpnMTceJ5CzB94ns8oxEIoyPj4s+oFNTU0xMTHDu3DkuXrzI/Pz8tn0YAVFCkO11STk+2iwsLLCwsJB1tWUbwerqKr29vaKhQyKRWDeAfDsgX6dsb+m2lpwl+AGQpzzn5+ejUqlQKpUkk0mSySSLi4tEo9Ft6QLNkSPH1qFUKtHpdGi1WrRarbB05X6v2y3GmU3cyhLMCcEcOXLkyPGR5lZCcPvY2Tly5MiRI8dtJicEc+TIkSPHx5acEMyRI0eOHB9bckIwR44cOXJ8bMkJwRw5cuTI8bElJwRz5MiRI8fHlpwQzJEjR44cH1tyQjBHjhw5cnxsybVNy5HjY4JCoUCpVKJWq0UrLnn8lNydJEeOjxs5IZgjx8cEeTaky+USQ09jsRiTk5NEo9FtNWIpR47bRU4I5sjxMUG2Ag8dOkRJSQkA4XCYoaEhhoeHuXDhQs4izPGxIycEc+T4mKBQKNBqtXzhC18Qc/lWV1fp7OzkxRdfpLOzk1gslhOCOT5W5ITgJmI0GtcN4V1ZWSGVSm2rkUtyp3u3243dbsftdlNdXY3P5xODhQHm5uY4e/Ys4+Pj9Pf3o9FoUKlURCKR3Ca7yWg0GkwmE5/4xCc4evQo5eXlwNVpKMlkkrm5OZaWlojFYrnpJzk+duSE4AYhSVeblssJCJIkYTabcTgcAKRSKVKp1LYaAqpQKNBoNFgsFsrKyigpKaGuro67776b5ubmdUJweHgYhUKBSqVieHgYg8GAVqslmUwSj8ezZjiofH0UCoW4Zu+FTCZDOp1ed87ZikajIS8vj/379/MLv/ALmEwmca6pVIrl5WVCoVBuWHKO244kSev2QkmSxHMjs9VKcU4I3mYkSUKtVlNeXo7D4WDHjh1YrVYKCgrwer14PB4A4vE4586dY2BggH/6p38iHo9v8cpvjdfrJT8/n4cffhifz0dTUxMGgwGTyYTD4bhOGBQUFPDlL3+Z4uJiMpkMlZWV5Ofnc/LkSSYnJxkeHt5S4S9PLK+rq8PlctHS0iKuk/zg3krAXbp0ifPnz9PW1sbU1BSxWCxrhaFSqcRgMKBSqa7bgAwGA01NTUxMTGCz2QiHw8RisS1cbY6PChaLhZ07d2I2m7Hb7ezZs4fq6mpefPFFJiYmyGQyLC0t0d7eTiQS2bLErJwQvE2o1Wo0Gg16vR6dTkdFRQVut5vdu3fjcDgoLCzE7XbjcrlQKBRiSKZOp8NisRAOh0VSQjqdJpVKZcWmKltzhYWFFBcXs3fvXoqKimhoaFg38TqTyZBIJMhkMqjVagwGA5WVlUxOTlJWVkZVVRVut5ve3l7C4TCjo6Obdg5qtRpJkkRMTK/Xk5+fj81mo76+Hq/Xy+HDh3E6nfh8vvckBPV6PbFYjNnZWSKRCMFgMCstKYVCgdFoxOPxYDabr7N4FQoFBoMBnU6HUqncNlPMlUolGo0GrVYrXO1r45ny32VSqdS650r+kYdhJxKJLbdIrj0npVL5rt6JaDRKMplkdXV1y9cPPy/DsVgs5OfnU1tbi81mw+VycfjwYZqbmwkGg9hsNjKZDPPz8ywsLLCwsEAwGBTXSC7b2QxyQvA2UVtbS1NTE/v27aOkpISGhgaMRiM6nY5EIsHq6iozMzP09PTg8XgwmUzs2rWLgoICurq6xI2wuLjI8vIyU1NThMPhrT4tXC4XLpeL3/zN36SpqYmioiK0Wu26h1N27Y6MjBCPx6murkaj0ZDJZCgoKGD//v1otVoAHA4Hq6urKJXKTVm/Vquluroao9GIzWbj4MGD3HXXXeh0OtRqNQ6HA61Wi8FgEAJAFny3UkJ2795NXV0dtbW1dHV18bd/+7dMT09vyjm9V9RqNXa7nfvuu49vfetb5OXlYTKZ1gm61dVVLly4QE9PDwsLC1mxkb4bOp0Ol8tFY2Mjhw4doqWlhZKSEs6fP8/CwgIATqeTlpYWIUimpqaYn5/H7/cTDoeJRqOsrq4yOTnJwMAAnZ2dhMPhLfPIqFQqPB4PLS0t7Nmzh7179+J2uzGZTDd9TSaT4bXXXqO3t5fHH3+c2dnZTVzxjcnPz6egoIDf+Z3foaSkhJKSEjQajTAQJEni4YcfFgpjLBZjZmaG/v5+zp49SyAQYH5+nvPnzzM3N7cpa940IahSqTCZTJhMJiwWCwaDQWhq6XRaBOZXV1dv+HqlUonD4UCj0aDT6YT2Nj8/TygUYnFxcVPda5IkiYQDt9tNU1MTO3fupKamRty8CoWCYDDI0tIS09PTwsKQrUCNRoPNZqO5uZnl5WWWlpZYXFxkaWkJnU5HMBhkYWGBZDK5ZQkLstVXXl5OYWEhGo2GVCrF7Ows4XCYpaUlcS2Gh4dJJBIkEgmsVis+nw+DwUBRUZGwFOPxOKurq5tm5arVakpKSnA4HBQVFdHY2EhlZSUqlUpYSbJ1lEqliEajqFQqVKr1j0Y8HicQCBCNRgmHw1itVmw2GwaDQVhY2YBs8cox6KamJurq6tZZuHB1A02lUoRCIQYHB/H7/VmdFKNWq1Gr1RQWFmK1WikrK6OmpobGxkaqqqrw+XysrKywsLDAysqKuD7yd7G8vEw0GsVisaDRaEgkEkJBnZmZeU9W10ag1+vR6/WUlJRQVFTE7t27xTnl5+djMBjWeYUkSRL3ZiaTwe/3o1AosNlsrK6uEolENv0cJEnCZrNhsVioqKjA6/VSU1ODx+MhPz9feBjk79dsNovXJpNJUbMqe1RkY0Cv1xMIBEgmkxu6X2yaEJT9w83NzRw8eJD6+noKCwsBCIVCnDp1iomJCVpbW294wnl5eXzyk5+koKCA8vJyFhcXCQaDPP/881y+fJnXXntNaIGbgUqlIj8/n5aWFr7+9a9TVlZGaWkpiUSCWCzGwMAAgUCAt956i7GxMS5fvswXv/hFPvOZz2A0GlGpVCSTSaxWK9/85jeBqzd1NBolEonw4x//mI6ODl599VUWFhZYWlratHNbyyc/+Um+/vWvY7PZUKlUzM/PMz8/T3t7O11dXZw6dYpoNEosFsPv95PJZGhpaaG5uZnf/M3fFK7gcDjM8vIyf/mXf0l7e/umadwmk4kHHniAmpoaDhw4IATc2ntMfjhl92ZeXh5Wq3Xd+ywtLfGjH/2I8fFxurq6uPPOO7n33nuZnp5maWkpawSIVqtFpVKh0Wiora3l93//9yksLLxug89kMqyurjIxMcG//uu/MjU1tUUrfm/k5eVRUFDAr/3ar1FRUcGBAwfQaDSi+40kSezatYtIJMKFCxeIxWJcunRJvH58fJy5uTmUSqXIcNZqtbjdbsbHx7dECCoUCnw+HxUVFfzu7/4uXq+X0tLSdUJDvk6yIqzVasnLyxNrbWlpoaKigueeew5Jkujv799Ua14Ol+zfv59Dhw5x5MgRvF4vXq9XhCFuhVKpJC8vj8bGRurr64VyVl1dTVdXF//wD/8gDIGNYkOFoFarRa1WU1BQQHFxMZ/4xCdEfCg/Px+j0Xh1ESoVVVVVOJ1O4Su+Fr1eT1lZGRaLBaPRKBJQWlpahMbk9/u5cuWKsAw3AkmSsFqt2O12jhw5Qn19PWVlZej1ehYXF7ly5Qp+v5/u7m7m5+fp6+sjFAqta1N17tw5lpaWqKysFFqpXMjscrmw2+00NDRgtVpJp9OMj4/zxhtvbGrMyWq1UlhYiNfrxWKxoFaricViXLhwgYmJCfHfsbExEokEyWSS5eVlAIaGhrBaraysrKBSqda5GmOxGJFIZFPjnSqVSsRs5XWsrKwQCoUYHh4W2vPq6ipTU1OUlpZSWVmJ2+0WWmsymWRhYYGZmRnGx8c5f/48kUiEqakp5ubmssJ1DVBSUoLT6aSwsJCysjLcbjcWi0X8PZPJsLy8zMrKCufPn6e3t5dAIMDKysoWrvrmmEwmjEYjx48fp7S0lMbGRgoKCsQ9JUkSY2NjzM7OMjo6ysLCAv39/dcpWbLHSBYwarVabLjyPbCRioycWe1yucR9ZTAYqKurE/F2nU7H3Nwci4uLLC4uEgqFiEajzMzMiCxyo9Eoji8uLhaeMZ/Px+LiIkNDQ5smBBUKBU6nk/Lycvbs2cOePXvw+XxYrVbhaYGr4RI55ppKpejt7WVlZUXs5UVFRcLSl7NHa2tr0el0XLp0ifHxcfr6+jZsz9hQIWgwGMjLy2Pv3r00NzfzzW9+U6TKX3tcc3Pz+3pvi8WCxWLB4/GQSqXYv38/IyMj/PVf/zUTExMbJgQVCgVer5eqqir+3b/7d3g8HkpKShgfH2doaIgnnniCtrY2Ojo6xOZqt9spLy9Ho9GQTCbFMXfffTdarRa/349Go8FsNnP33Xdz5MgRDh06hFKppLy8nLa2Ns6ePbvhboG1FBYWcvz4ccrLy4WyEolEePrpp7ly5Qpvv/32TR+2K1euYDQamZubE+n5csJPJBIhGo1uyjncipmZGSYnJ3nyyScJBALAVWtvZGSEgwcPcuedd3LkyBEhBFOpFMFgkOnpaYaHhxkeHubf/u3ftvIUrkOSJJqbm2loaGD//v0UFBTg8/nWuaIymQyBQICJiQn+7u/+juHhYcbHx7M2FuhwOPB6vXzjG9+gqakJp9O5TqFMJpO0tbVx4cIFfvaznzExMcHKykpWJJWtRQ4HNTU1ceTIEcrKysjPzxfZk3LopLOzk56eHrq7u5mcnBSCTY5jOhwOampqePjhh/nkJz+J0+lEo9FQU1NDPB7n1KlTm3I+slu2uLiYBx98kLvuuosDBw7c8NhEIkEoFCIejxOLxXj66acZGhqioqKCoqIiHnjgAcxmM2q1Gri6x7a0tFBTUyO8aIODgxtmDW6IENTr9RgMBj772c9SXl7Ojh07cLlcIk37drkdMpmMiIH4fD5MJhNf+cpX6OrqIhaLCd/y7UK+kT/1qU9RW1tLSUkJKysr/Nu//RudnZ3iJxAIrLPaQqEQY2NjnD59mpWVFYaGhlhYWODMmTOoVCrC4bDQFOV42yc/+UmKi4tFYfMDDzzAwMDAOhfPRmK1Wqmvr8dut5PJZHjllVfo6+vj4sWLwu15LUajEbPZzPHjx2lsbKSoqEjUpMXjcUKhUNZstnKW6MzMDENDQ6ysrBCNRllZWcHv92dNYtJ7RZIkkZXndDpFHHRtHFCOyV64cIHu7m76+/sJBoNZJzDgqptMpVKxZ88e9u/fj9frRalUMjw8zPLyMoODg8zMzDAxMUFvby8TExP4/X6i0WhWno/NZqOlpYWjR49y1113YbFY0Ol0LCwsMDU1RV9fHyMjI7z11lvMz88zNzdHKBQiFouJuHsqlRKWrpxJCVevvWwxb5ZL12q1cvjwYXbu3Mm9996Lz+e77hjZO9TZ2cmJEyeEB+LKlSssLS0xMDCA0+lkenqaPXv28MADD6x7vUKhoKCgAKfTuaHntSFCUKfTkZeXxx133EFzczOVlZVCyl9bZCxfyLXCce0JX1tUKb9OfrhlISi7UuV4zqlTp0ilUrdVCOp0OnHx6+rqcDqdzM7OcurUKc6dO8eFCxeIRCLXaSxyBlRXVxfz8/NMTk6yurpKT0/PDT9nZWWFvXv34vV6cbvdSJLEwYMHkSRpU4SgJEmiID4vL49MJkNrayvnz58X7t0bvcZgMJCfn88999wjXN6y1h6JRFheXt6S2kA5DX7tvaNWq9HpdKyurjI3N8f09LRIWJLTtbdTvZwcm5FrstxuN3l5eeuOkZOSrly5woULF5icnLzuWspW442SaDZTuCiVSrRaLTU1NRw5cgSbzSZCA5OTk5w+fZqBgQE6OjpYXl7ekoSQ94PFYqGhoYHm5mZ2794trNjOzk6mp6d544036Onp4cSJEzdVFJVKpXCPXnvd5NKKzRKCRqORffv2sXPnTvbs2XPDz02lUqyurtLf388zzzzD7Ozsdfux2WxmdXUVvV5/nRBUKpXY7XasVuv2E4IlJSVUV1dTU1NDcXHxunT4paUl5ubmuHLlChMTE1y+fBm1Ws2v/MqvkJ+fT35+/nXvJ8dvrly5QjAYpK+vD6/XS3l5OR6PR2SCqVQqkTl299138+abbzI2NnZbzkmSJL7+9a9z5MgRdu7cSTqd5oknnqC9vZ2f/vSnLC4uilq/mzE7O8vy8vItLYzR0VGCwSCRSISysjJ+/dd/HYvFwpEjRzYlOUar1VJQUEBlZSWNjY0iRnurDVBuB3fHHXdQWVnJ0aNHhfYmxwAff/xxnn32WQYGBjb8HNayuLjI97//fVpaWnC73TidTvLz83E4HJhMJv7gD/4Av9/Pq6++Sk9Pj3BxrhUC8u/ZjNvtxuv1cuzYMfbv3y9c2Gt5/fXXee2113j11VcZGxtb55aW42Q7d+6ktraWiooKEUucnp7mqaeeYn5+nmAwuCnn43A4qKiooLGxkerqan72s58xMDDAG2+8wfLyMouLi0QiEZE0ku0UFhby6KOP4vV6ATh79ix9fX088cQTonzjZp4Sg8GA1Wrl+PHj+Hw+kUTidrvRaDREIhHa29vp6OjYtO/CYDBQX19PUVHRdc+JHNeTcxweeOABGhsbicfjJJPJdcqVUqnEaDReZ+3JSp3b7cbj8WC324UcuN3cdiEoSRJOp5Pi4mKsVqt4GGWrb3V1Fb/fT29vL/39/Zw7dw6DwcDS0pJ46OT4kewOkAPFPT09TE9Pc/nyZaGpy5agnLwhx6AqKyvp7u6+LeckJ63U1dWxb98+rFYrwWCQ7u5urly5wsjIyHvSkmOx2LtaF6FQiHA4TFtbG4FAgM997nMii83pdGI0GonH4xuWJCOXfuh0OpHFCletYIPBILLo1p6v2WzG6XRSWVlJTU0NBQUFmEwmcb0DgQDd3d1cuHBhQ9Z8K+LxOH19fZjNZoaGhojH46KDitFopLm5mbKyMhYXF1EoFFy6dAmHwyHup2xHpVKh1+txu91UVFTg8/lwu90AQnlJJBJEo1GGh4dpbW1lbGyM+fl5kUUqWxFGo5HKykqam5upr6/HZrMBVxWzixcvAmyaEDQYDLjdbmw2GzqdjqGhIS5dusSlS5eyIqb8fjEYDJSWloq6v9nZWUZGRujo6GBqaop0Oi1CIrI1LjcBkIvNm5qaKCsro6WlRXwvspU+Ozu76a5teR9IpVLrPAjy3xQKBTqdjsLCQlEJAD9vVfhuyrVCocBsNmOz2YRHLOuFoEqlQqvVsm/fPh588EHRJxOuxiOWlpa4fPkyr776Km+88Qb9/f1otVqKi4tRq9Viw5XrfZ588klaW1tZXl4W7sNYLEY8HhcP8Ne+9jUOHTqEw+FAp9MBV7XiT33qU7fN6igsLKSkpITS0lKcTifRaJSJiQmeeuopAoHAbb/xMpkMMzMzRKNR3njjDerr67nvvvuoq6vjU5/6FJcuXbqpK/XDEovFGB0dZWRkhJGREYqKinA4HOzfvx+bzcbZs2eFcJO58847ueuuuzh69CgFBQUYjUYSiQSLi4u8/PLL/OAHP7htCsn7RVamLl68yG//9m9TXl5OTU0Nn//859m1axcajQaj0cj999/P4cOHRQmLxWLBbreL98nGOJNSqaSiokJ89wcOHMDlcom/y+6owcFB3njjDV588UXOnj1LLBZDqVTi8/lwOBzs2rWL4uJimpqaKC8vx+fzrcukle/75557jj/5kz/ZlHMrKCjgwIEDKBQKhoaGePvtt2ltbd1WLuq1KJVKTCbTdYqVfK8lk0nMZjNerxej0YjJZGLHjh14vV527NiBzWYTdbparXZdtnUoFCIQCDA7O7tpMXe/3893vvMdjh49Sn5+PmazWSi+1yrJ1/Jej1EoFJSUlGAwGPjd3/1dXn75Zf7hH/7htp/LbRWCDoeD4uJiSkpKKCgoQKPRiIzA+fl5urq66OjooL+/X6Rly3U+ct0OwMLCAr29veJHzowKBoPXpTGvrq5eN/5Fjo2sbZv0YXC73TQ3N+NwOFAoFIyOjjI4OCiC1xuB3Fx7cnISu92OQqEgLy+P8vJyhoeHN+Qz4eftzwKBAG1tbeh0OhwOB06nk0gkQl1dHRaLhcnJSfR6PXl5edTX11NZWYnT6RTZlLL7uq+vj6GhIVE+sRVkMhlRzgCING2LxYLL5RL3nqzEyena12YxZxNyXNPhcNDc3ExFRYV45mTtXB6T1N/fz+XLl5mamiISiQgrf+fOnbjdbhobGyksLKSqqgqXy3VdjWQmk8Hn81FYWEh+fv6mFGUnk0nREiydTovMwmxURt4L8jWRFX2Hw0FJSQktLS2iDs5oNOJ2u0V4obq6GpfLRUFBATqdTkxgWZs/ISdzya7Czfp+4vG4KF24dOkSFotFWLlKpZKCgoJ1NZw3+j6WlpZEspZcSaDX69c9d2q1Gr1ej8vlWldkfzu5rUKwpaWFb3zjGzQ3N1NcXCyyAkdHR7lw4QJ/9Ed/JIqt1ybEyCcpu18uX77M448/LmpE3ksbq43k0KFD/NZv/RYOh4NEIsEPfvADOjo6WFxc3NDavUQiwcWLF8V3VVhYyN13301/fz9nzpzZsM8FuHjxIoODg/z+7/8+dXV1omPMb/3WbzE2NsYrr7xCdXU1hw8fpqKiAo/Hs+5mHx8f58/+7M8YHBxkcHBwyzcvuTvKwMAAQ0NDpFIpWltbue+++/B4PPh8PiHwr40HZiNKpRKz2UxDQwOPPfbYur6fmUyGcDjMwMAA/9f/9X8xPj7OwMCAUCALCwspLS3lD/7gDyguLhYJFTfasDKZDBqNBq/XS11dHceOHaO9vX3DY7vBYJDW1lbKy8upqqpCp9Oh0WiyagLJ+yGZTIqQj8lk4uDBg+zfv5/Pfe5zIuFPjoMpFIp1NXaDg4MEAgF6e3txOp3s2rWLvLw88vLymJmZYWRkhImJCVHqsxlEo1H6+/uZmZmhra0Ng8EgOr+YTCa+/OUvi/DNtci5AqdPn2ZhYYFAIEBVVRWHDx+msrLyukxTOXyxUUrpbRWCciwuLy9PXMREIsHg4CDDw8PCclprzUWjUTF7rqysjLq6OtRqNXl5eaLr/ftlfn6e3t7e25YUI2e7JhIJlpeXGR4eZnR0dFNcD3IzXbjqOvH5fBumEa0lHo+zvLzM6OgoV65cEYW5ciu0TCaD2+2mqKgIi8WCQqEQrpmzZ8+KWOn8/HxWbVqyRj4+Pk4ikSCVSuF0OqmpqcHr9bJ79+5133m2YjabOXbsGDt27BBFxrJ2HQqF6OjooK+vj7GxMebm5kgmk8K63bdvHw0NDdjtdtE4+9qMbLl4XNbmVSoVeXl5FBcXMzQ0tOHnl0wmCYfDouyjrq6OaDRKa2vrtowJzs3NcerUKRwOBw6HA7vdjtFoFN8vXN0L5TKPSCRCIBBgaWmJoaEhQqEQKysr1NXVcfDgQZRKJalUio6ODi5durQlzQ7kDlezs7Oiew9c3bNeeuklTCYTGo3mhgplMplkYGBAdJLS6/U3zKyX2TbZoQ6Hg4aGhnX/FovFaGtro7Ozc50FKLOyssLU1BQ//elP2bNnDxUVFRgMBrxerxhA+36Znp7mySefpKur6wOfy1pkITg1NUUgEKCrq4u+vr7b8t63Qq7/kfuQyn0qZYt5I5E701+5coU333yThx56CK/XS1lZGWVlZezZs2fdOuFqGYTf7+e73/0uw8PD66yPbGNgYICBgQHeeustke4tN2K22WxZLwQdDge/8Au/QEVFxbp/n52dZWpqiieeeEJY4fLGIruvH3roIQ4fPozD4bhpu7Dl5WVisZgIKxiNRux2O3V1dVy+fHnDz08usNZoNDgcDo4cOYLVaqWnp2dTJwzcLiYnJ/nxj3+Mz+cTGZ6FhYWi2B2uXruOjg4CgQB+v5/z588zNjbG2NiYcEnLe4JSqSSZTPL666/z4osvblhzkHcjGo3eUCnp7e19X+9jsVgIhUJbkul7W4XgtSNoJEkiGo3y9ttvMzQ0dEOLIJ1OEw6HOXfunAjsykWwt4q3ycXBckssSZJELGtgYEDMebudxONxotHopjyAarUas9nMkSNHaGhoQKlUMjs7y8DAAJOTkxv++TKXLl0iGAxiNpupr6+nrq7uOgExPT1NMBjktddeY2hoiCtXrrC4uCjG12Q7sViMvr4+Ubj8yU9+ks9//vNbvawbolaraWpqor6+ntraWpxOJ/Dz7OvW1lY6OjpobW1lZmZGxKH0ej133HEHhw4doqmpScS3ZQEYj8cJh8O89dZbtLa2CgH0xS9+UbQpk5+5zWgWHgqFmJqa4sKFCxgMBsrKyigoKGBqaorBwUHefvvtTe2g9GFZWlqira2N/v5+TCYTJ0+eFFNm1lqCcgu+cDjMzMyMKAExGAyiQYdGo2F8fJzR0VGGhoaYnZ3dFmUiN0LO33C5XCIp6FpCoRCdnZ0btu9tWNs0WRjG43F6e3uZnJy86Q0rb0Jzc3MkEgnx2pvV08kte+SSCFkIJpNJ/H4/4+PjDA4O3lbtSE4Y2azgvFqtxmg00tjYSE1NDZIksbCwQEdHx6aOTBkcHGR0dJQDBw6g1+tFv9O1zM3NMTQ0xCuvvEJPTw/j4+Pb6qFMJpNMTk4yOTlJe3s7Pp+PL3zhC9c12VapVEIIbIVwl1Po6+rqREceOQ6TTqdJJBL09/fT2trKwMCAyOCVFaqdO3fy8MMPi04+8HP3cCQSEV2MnnrqKdLpNDabjfvuu094HuRZcZsRL5UFQm9vLyaTic9//vPk5eVx6NAhTCYTbW1tRKPRrB9GLRMOhz+UG1mr1VJaWorb7UapVIoWa9PT01uadPZhkZO7nE4nTqdT3M8yqVRKfHcbte9taO/Q9/uwLC0treuIciNL0GQyUVxcTEVFBXV1dTzwwAPU19djMpmYmZnhr//6r0X26e1OWgkGgyKWtJFIkiQKluvq6vB4PKysrNDe3s73vvc9JiYmNvTz1yLHg+RWeDe6ppOTk3R0dDA0NMTU1FTWukDfDYvFQmlp6bokH1kQ2u12fuVXfoVz584xMzNDMBjctHlnMtXV1ZSUlPCNb3xDNG2XG1FcvHiR1tZWTpw4QXd397rszdLSUh544AEOHjwoEmFk5ufnOXnyJENDQ7S2thKJRETWYnFxMVVVVaJjh1arveFGtRHIMzhPnjxJe3s7sViM6upqjh8/zt69e9mzZw8nT57kySefJBKJbBth+EGQ60A/97nP4fP5SKVSdHV18dRTT2X99I+boVAocLlcVFVV8Ru/8RuUlZXh8/nW9Q+NxWK0trbS3t7OT37ykw2bEnRbheCNLCS5kF0ueL8Vcqf+a5G1cLPZLDpJ1NfXiyxUh8MhSjH6+/uv64Zxu5CHx26kJShbt/IGZLPZ0Gq1zMzMEAgE6O/v39RaKb1ej9lsFh3fb+QKkydBy80AtouL6lq0Wq2YwH6jv1VWVrK4uEh5eTnpdHrThKDshiwsLKSyspLKykrReURuvzU1NUVnZycTExPMz8+ve63VaqWhoYHCwsLr3E3JZJJgMMjMzAzT09NiKGpdXR0lJSUiJphKpUgmk8Tj8U1RcuSp77Ozs6K8KpPJiFrIffv2sbCwQGtrK3Nzc6ysrBAOh7eNC/69Is+FdDgclJaWkpeXRygUElmhG1WitZEolUqRcVxZWcnu3bux2+3rlCu5RGZ4eJjBwcENNT5ue0zwWiwWC1/5yldoa2vjRz/60Qe6QU0mEx6Ph3//7/89xcXFNDY2YjabMZvNaLVaMpkMc3NzzM7Oii4zG0FRURGAKMrfCORRU7/+67/O7t27sVgsLC0tcfHiRdG3czMf8sOHD7N//34+8YlPUFpaesOEkbq6OkwmE2fOnGFpaWnbTCi/FrvdzqFDhygpKbmum4UkSRiNRlpaWvizP/szvvvd7/IXf/EXm7IuuaD6s5/9LEeOHFlXxC8nlp09e5YXXniBmZmZdWvWarWUl5fzmc985oYWnNFoZNeuXezYsYNPfepT2O128vLyxPBZtVpNPB5ndnaWtrY2nnzyyU1vfZdKpXjuuec4deoUfr+fpqYmHnvsMb761a/yyCOPcPLkSTo6Ojhx4gTT09Pb9v67EVqtlk984hM0NjbidDpZXFzk4sWLXL58mYmJiW3pdcnPz8fj8fBf/+t/FRbg2taacrOQyclJ/vEf/5GhoaHtM09wbUNsWSCqVCpKS0tZXV2lqqqKhYWFdZrqjZBrllwuFxaLBavVitvtpra2lsLCQjwej2j3JE+SHhoaYmhoiNXV1dvuGpG1YDm7Tp6ifDtGtsjtkda2rZI7ReTl5RGJRJibm6O7u5uJiYlNf7g9Hg+NjY3Y7XbUajWzs7NiArTD4cDn82E0GnG5XDidTux2O0tLS9tuE1Kr1VgsFtHuL5PJiHlu09PTZDIZPB4ParUat9stJnzIzYw30vqVeysWFBRQUFAghgLL450uXLjA8PAwCwsLQltWKBQYjUaqq6spLy/HbDbfUElVqVSis5PsbTEYDIRCIUKhkChrmp6eprOzk5GRkS0Z8Cz35e3t7UWr1TI2NobJZMJqtVJeXo4kSaysrDAxMUF7ezurq6vbOlYGiL2vrq6O6upqFAoFq6urDA0NibKX7YYkSVRVVVFVVUVpaakoqr+2RKevr4/+/n4mJyc3vMzqtgpBucvJ2undOp2OlpYWvF4vVquV06dPc+LEiVu+j9y78nOf+5zok2exWESbq7VfWGtrK11dXZw4cYLJyUlGRkZuu9kcj8dZWVnBZDKhUqloampCkiQuXrz4oW9Eucmsx+Ohvr6eu+++m8OHD5Ofn08qlWJsbIzOzk4ef/zxTY9BAezcuZNPf/rTKBQKwuGwaHf37LPPct999/Ef/+N/FA/rjh07RJeb7fSAytOti4uLOXbsmOiYMjY2xujoKI8//jjJZJJf/uVfpri4mPr6elpaWnjsscdEKc5GZirKHYtKSkpEWzTZ/X/+/Hn+63/9rywuLopNX5IkdDodZWVl/K//6/9KRUXFOje2nLkNP0+4kJGT0mSB9/LLLzMzM8Po6ChLS0vMzMxsmbs7Go3y1ltvMT4+jk6no76+nr1791JfX8/Bgwd59NFHCQQC/P7v/z59fX2cPXt227rm4WoMuKqqii984QsUFxcTi8UYGxvjxIkTm26N3y6USiWPPfYYx48fp7Cw8Lo2crIb/O///u958803mZyc3PAcjNsqBAcHB/nZz34mHli5x53ZbCaTybBz506hbd9yUe8I0T179lBcXIzBYECn062bVizHoEZGRuju7mZ8fPyGbdVuB729vTz77LMcPHiQ/Px8Dh06hNvtxmAwiI4HkUhETEyXM0ll1mbVKRQKMe27sLBQfB92u13EAY1Go9h03nrrLQYHB1lYWNjUcTE2mw2v1yvGIY2Pj+P3///Ze+/gRq/z3v+L3jsBEAAJggTY+y63d2mlVZdlOZJcYrnF99pJHOcmk7l/JDM3kztzk4kzmSTX5caxHDu2pdiKZUkrWVZbaRu55C57byBBEATRey+/P/Z3jshdbpOWACjhM7Mje1n2vHjf9zznad/HibNnz8Jms8HhcGBychJvv/02du/eDZPJhLq6OkQiEbz33nsFW+fdgMFgQCAQ0HmIpHAkGo3StgmiOENE2/V6Pfbs2YPe3l4sLCxsqzdI8iNEc3HjuomnkEgkkEwm6btiMBhQVVWF+vp62kax1agy0tZEhA6IEPOZM2dgtVoxNTWFUCgEn89XsPagm0Fm6l2+fBlOpxNLS0vo7OyEyWSCyWSCQqHAvffeC4VCgcHBQaTT6R1nCEkOuKqqCg0NDTSP6/V6sb6+TveGnQSDwUBlZSW0Wi2d/LOx0piMO3O73bTXlbRZbTd31QgODw8jEAjgm9/8JhQKBQ2hKRQKyOVy1NTU4OjRox/692/M05DpEtPT0xgYGIDVat22IagDAwNwOp1QKpXQaDR49NFH4fP5oNPpYLVacenSJbhcLtqvk8vlNiXoiTYqi8UCi8VCe3s7TCYTjh07hsrKSjQ0NNApDaT4YHx8HJOTk/jFL34Bt9td8Idep9PhyJEj0Ov1yOfzmJqawtTUFF566SV4PB46EiUajUIsFtPhyTweD//+7/++o15SEjqUSCSQyWQ0PxEOh+F2u2Gz2ahoOMk319bWwmQy4eWXX6bl+ttlIBKJxHWzGMlGWVlZiePHj9O/12q1kMvl2LNnD5XoulGV9kbjQBRKLl++jPHxcbz66qtYWloquUKnfD4Pn8+Hd999l+pKPvLII9i7dy+dQv/MM89Ao9Hgueeeo4VDOwlSOGKxWNDd3Q2BQIB0Og2n04nl5WXMzMyU1D25FeRZtVgs6OrqoimHjWQyGUSjUUxPT1OnplACAHfVCBJJsdOnT8Nms+GJJ56AwWCgiicbwzB3SiaTgdfrhc/nw+zsLJaXlzE/P4++vj7Y7fZtLZEOBALIZDLo6+tDPp/Hvn37oFarcfToUXR3d+PQoUNU6igajVKxZrImiUQCvV4PHo9H5/VJJBLodDo60ieZTMJut1N1nf7+ftjtdjpNotBcK0K+vr6OlZUVJJNJejrz+/2YmJjA9PQ06uvrkc1mIRAIaD/dTknai8VinDx5kg4HJXPz3nnnHfT19SEQCNAxX8WgqqoKPT09mzYOIqBdVVWFU6dO0b8nAsRyufymo6BITyEpeCGjfdbX1+HxeOB0OkveiyL9jQMDA3A4HGhtbaU5zo2FFjsN0hp14MABdHR0gM/nw+124z//8z8xPj5e0vdkK0i18alTp2gU7VoWFhZw5swZDA0NYWZmpqA6qHfVCJKQ4JUrV7C+vo6enh6IxWKq0E8M4e2y0ZtKpVJwuVxYWVlBX18fJiYmMDw8DL/fv20eIIEoOExPT0MoFKKzsxNSqRT19fX0lEMIBAKIRqOYm5ujxkupVFI5OD6fT+clEohqjsPhwMDAAG06L5YUEvCBsDlRrA+Hw9eFJyKRCCKRCOx2OxwOB+RyOZ2BxmQyd4wR5PP56OjooBJkkUgEq6urGB0dRX9/PxKJBKRS6ZbzzzaKHW8XJIoiEAhoSJS0DZEmY2CzZ0dEmTd6QWT9RPORaPqePn0aa2trVGJtp9w38h4tLCzA4XBgdXUVBoMBSqWy5AXQb4ZOp0NPTw8aGxtRU1NDNYvPnz9fULWouwGLxUJFRQU6OjqwZ88eHDx4cNPXyfO4traG999/H6Ojo1hYWCjoGrelWZ5MSv7ud7+LqqoqHD58GFVVVdizZ89tPZwkJPjOO+9QDbp4PI6JiQn4fD4sLy8jGo0WfKr0uXPnMDo6iuHhYWi1WnR1daG6uhrd3d1URV0sFkMoFNLZWsAHVbNOp5M2vRP1g3g8jvn5efj9fio/5vP5Cpr/2woy2UMgEIDBYOCBBx5AS0sLVldXqRdONl2Xy4W5uTns2rWL9hWSQck7DaLMs7CwsCkPlkwmMTk5CT6fj4MHD1JD1NDQgH379uHdd9/dtkPLlStX4HK5wOFwEIvFYDabb9imk0wmEY/HMTg4SJ8pcp/8fj8CgQDNKRGJLo/Hg1QqtWMnNJCQJ8klsdlsrK+v77ieQaLss2vXLnzmM5+BTqdDOp3G+fPnMT4+juXl5R1V8apSqXDy5En09PTg8ccfp1XI5NBIiruWl5cxNDSEc+fObZpTWii2xQiSJP3U1BS8Xi/kcjkikQgqKipu69RMil7Gx8cxNjZGf+fU1BQikUhRqiSBq4oxpAepoqKCekgKhQISiWRL3Tvgg+pSEs4dGxuD0+kEcLX4YnJyEqFQCB6Ph57gi002m6Xz3ICrFYpsNhsWi4WWapMNhni3wAeFFjvlJE4mKwgEAhr6JVXOwFWPOJvNUlm+a70kUsm8nd6gz+dDKpXC3NwcpFIpzR9fC5EaJLMcPR7PprYacsBaWFhAMBikRq8Unre7RS6Xo7P1SuVdul14PB5UKhWdzpLNZhEKhTA3N0dl8HaKMg6fz4dCoUBraysdxbYREo0IBoO0Gd7j8RRlrdsmm5bP57G8vAy73Y7JyUk6sPROfj4Wi9EqS6JDWsyHmoSXbDYb7HY7pqamIBKJoFKpIBAIbng6T6fTiMfjSCaTSKVSCAaDdJMlmo/XhkiLzezsLP793/8dWq0WnZ2dEAgE0Ol0+LM/+zP4/X7Mzc3R9VZXV6OiogLZbBZerxder3dHnFjJ5GrizZH2A4lEQivzSJ+gSqVCT08P6uvrAXwQepyenkZvb++2nmDj8TgSiQS+973vQSQSoamp6YbPGhl4u7S0hEQiscloE8+I5Pp2koG4GWw2G3w+H01NTWhsbMTU1BTW19d3lMA2cHXO4xNPPIGOjg7weDxcvHgR09PT+Nd//VfYbLaCKkV9FLhcLnbt2oX29nY8++yz1+XTyZDkK1euYHJyEt///vc3iTwUmm3VDiVlrzvl5t0uxDsiUyXi8Tht3r/R96dSKepJbCwuKVXi8ThcLhdsNhsWFhag0+nA5/OhVquphigxggqFAiKRiHrJpWbQbwZ5RlOpFD1wkQnfLS0t4PF4cDgckMlkqK6upmotREAhHo/TRu7tghisQCCASCRy02eN6Gju1GbqDwNpQSIH0Wg0ilgstqMMIJvNhlwuR2NjI9RqNRgMBpVGI9XhO+V6WCwWamtrUVdXB7lcDj6fT4siiSNBhj7Pzc3B4XAUVf5tW43gJ4F0Or0jc1+3ghQ5nTlzBtFoFF/84hdRV1cHkUgEkUgEtVpNv5c83MWI538Ucrkc3G43BAIBZmZmkE6nIZfLodPpoNPp0NjYiHg8Dp/PByaTCbPZDDb76isTj8cRDofpINBCbFCk/9Rqtd7y+z5JEE9QIBCAw+HA6XQWLbT2YSAtOiaTCQ899BBEIhHy+Tymp6epFOFOOtDw+Xw88MADaG5upqmCjemRSCQCp9OJl19+GfPz81vOmS0kZSNY5qYsLy+DwWCgpqYGNpsNlZWVtOWD5MGWlpboENDt7NfcDlKpFOLxOFVcSaVStMVjY7sHqcYkhmhqagpXrlyB1WpFIpEoqOH5pBk5AJsqYsk9YLFY4HA42L9/P1paWqBSqZBIJDA6OorZ2dkd8zkJBALs2rULjY2NEAqFYLFYSKfTtCJ7JxlA4Oq9kkqlVKpvY0M8KfSZnZ2F1WqFx+Mp+n0qG8EyN2Vubg5WqxUMBgMmkwn79+9HdXU1dDodfXinpqZw6dIlvPzyy7DZbDvKIyT5WqKFmkgkqLABj8ejU9UJpDft0qVLeO6552Cz2Xakkv9Og7Si8Pl8ZLNZpNNpcDgciMViPPDAA3j88ceh1Wrhcrlw8eJFKnCwExCLxTh+/Dg6OzshFAqRTqdp0YjP5yv51Mm1MJlMyGQyOo2F7BPpdBrRaBSvvvoq+vr6MD8/XxKFPmUjWOamEKHmiYkJ2Gw2TE9PQyQS4Re/+AU94ZGm/tXVVcTj8R2z+RBCoRD+67/+CwaDAWNjY1AqlTT3R061ZMQVaS6/cuUK7Hb7jvJ6dzJsNhsymYzq2K6srECv18NsNmP//v0Qi8V4/vnnMTU1hbW1taK3GN0JPB4PTU1NqK6uBoPBwMLCAsbGxjA7O0vVmXYSmUwG09PTYDAYUCqV8Pl8mJ+fx8zMDBYXF3HlyhU4HI6Sua6yESxzS3K5HB3kOzU1VeTV3H3i8Tj6+/uhVCrhcrmoviFw9VSrVqvB5/MhEomogPHa2totp6GUuXswmUwIhULs27cPXC4XVqsVZrMZ3d3dkEqlYDAYOHfuHC5fvrzjQogcDgd6vZ720TmdTgwNDcHhcOyoqAohk8lgaWkJQqEQ7e3tWF9fx8TEBC5evIjR0VEsLi4iHA4Xe5mUshEsU+b/JxQKYWxsDNPT05vaeTgcDq1ATCQSm0YWlSkMRCu4t7cXzc3N+NznPkcFKk6fPo3+/n709fVhbW1tx4UPr8Xv99OxcDuReDyOn//85xAKhfj+97+PZDKJUCiEUChEx5OVEmUjWKbM/08mk9kR/Y2fRIhqz8rKCuRyOTKZDC0cmZ6extDQELxe744KgxLS6TQcDgct+LHb7XC73Tu2tSybzWJlZaXYy7htGDerzGEwGDujvKpMmTIfexgMBng8Hi2IIZARV8UW0/iwsFgsOlqIxWLR9iQiolHmo5PP528oYVU2gmXKlClT5mPNzYzg9srflylTpkyZMiVM2QiWKVOmTJlPLGUjWKZMmTJlPrGUjWCZMmXKlPnEUjaCZcqUKVPmE0vZCJYpU6ZMmU8s5Wb5MmXKlCkhiDqRVCoFn88Hl8tFNpuFx+NBOp0uqxXdZcpGsEyZMmVKCKlUCpVKhc9//vPYvXs3Wlpa4PF48Fd/9Vew2WyYnZ0t9hI/VuwYI8hkMsHj8SCXy2E2m+k08KWlpbKQcZkyZXY8bDYbQqEQtbW1sFgsaG5uRl1dHbRaLbLZLJ3fWebusiOMIBmmqdVqsX//fvzVX/0VgsEg3G43/vEf/xHvvfdesZdYpkyZMh8JsViMuro6PPzww3jsscdQU1MDuVyOeDyOaDSKYDBYHt21DZS8EWQymbBYLKisrMTx48dRU1ODfD4Pt9uNiYkJBAKBYi+xTJkyZT4SLBYLarUahw4dQktLC7RaLQQCAdLpNM6cOYOpqSmsr6+X1AiijwslbwRZLBY6OjrQ3t6OP/mTP0E+n8fS0hJsNht6e3vh8XiKvcQyZcqU+dCQSJder8f9998Pi8VC51lGIhH85je/wdjYGOx2+46ak7hTKGkjKBaLIZfLcejQIbS2toLJZMJqteL555/HxMQERkZGyvnAuwSTyYRKpYJUKkVdXR2EQiEkEsmm7+HxeOjs7ASfzweb/cGjMzs7C7vdjkAggFAohMuXLyMej+9IRf+PI2w2GzweD6lUqlxZCEAoFOLAgQOoqanBoUOHwGBc1VZ+7rnncP78+YKvRyaT4ZFHHkFXVxfa29shEAgQi8XQ19eHubk5DA0NwW637/g5iRvh8Xg4evQoqqurcfDgQVy4cAE//vGPi7KWkjeCKpUKFosFdXV1SKVScDqd6O3thc1mo9POS5mtktmlNh6FyWSCw+FArVZDq9Wiq6sLcrmcTromCIVCPPDAA5BIJOBwOPTvL168iImJCTidTrjdbszNzQEAUqkUcrlc0a6XyWSCwWDQPxvvBfk7Qj6fRy6XQyaTQT6fL3kDTq6HlNPncjnk83l6zRvh8XgQiUSIRqOIxWL0fnycNtU7gcfjob29HV1dXfjc5z5Hn4v333+/4EaQyWRCIpFg3759aG5uhl6vRywWowOeBwcHYbPZ4Pf7C7qu7YbL5aKjowMdHR347Gc/i3w+XzaCGyEb1LFjx7Bv3z5UVVUhEongBz/4AWZnZzEyMlLyAyc5HA4EAgFqa2vBYrHo3+fzeSwuLiIYDBZxdR/AYDBQV1eH6upq/MVf/AUqKyshk8nAYrHAZrM3bahMJhNSqfQ6w97e3g6LxYJUKoVYLIb9+/djdXUVly5dwsLCAsbGxgp6TWw2GxwOB/X19ZDJZFAqlVAqlaivr6fXI5FIIBAIIJVKkcvlYLfbsby8jPPnz8PlcsHpdCKbzZacMWQwGJBIJJBIJKivr4fJZMLevXthtVqxsrKChoYGKBQKcDgceq0CgQByuRwjIyOYnp6Gz+dDOBzG8PBwyU353m5EIhG0Wi0eeOABmEwm+hkV4z6zWCx0dnaiqakJx48fh0qlojnA119/HQMDA7Db7R/LQc8CgQCf/vSnUV9fv2l/LAYlaQT5fD7EYjFqa2vR0NCAfD4Pv9+PsbEx2Gy2kn8oGAwG5HI5FAoFmpqaNoUO8/k8otEocrkc/W+xIB6g0WhEY2Mj2traoFarwWKxrvMmAGzykDbmJsRiMQ2dkpBbRUUFIpEIMpkMlpeX6ZDQ7YDFYoHH44HP50MgEEAkEkEgEKCpqQlyuRwVFRVQqVRobGykPyOTySAQCKBQKJDL5aBSqSCTyeD1eunX3G43vYZiQoweh8MBm82GTCaDVCpFS0sLzGYzuru7IZVKIZPJ0NzcDJVKBS6XS+8hn8+HTCZDPp8Hm82Gx+NBIBDA2toa/H5/yb9PdwsGgwGlUonKykro9Xoa6chms8hmswV9FxkMBjgcDsxmMxoaGqDRaMBms+F2u2G1WjE6OoqVlRV4vd6CralQSCQSqFQq6PV6qNVqAFcPrqQQqNDvW0kawdbWVpw4cQKPPvooWltb8fLLL2NiYgL9/f07ojqKx+PhscceQ0tLC5566inweDz6tXw+j+eeew5XrlzBm2++WdQNiIQ8v/71r2Pv3r2oqKigp7J8Pr+lIUwmk8hms0gmk9QgisVi8Pl8AFc94IaGBtTV1aGnpwfnzp2DTCZDf38/DZNux3V0dXWhs7MTe/fuRVNTEyorK8Fms2nIkIQ6SdiQhBMFAgEYDAYUCgW6u7vxxBNPwO/3w+Px4J/+6Z/w/vvvw+12FyWXRtb4wAMP4PHHH4fJZIJcLt9kDEm+r62tDZlMhl7zxntHfo9Go8E999yDbDaLaDSKX/ziF5icnMQLL7zwicgVstlsfOpTn0JnZyeqq6shEokAAOFwGF6vF9FotGBrEQgEUKlU+Na3voX29naIRCJMTU3hhRdewMWLFzE4OFj0w9d2wGQycerUKXR0dGyqOVCpVOju7obVasXa2lpB11RSRpDJZILP58NgMKCzsxNMJhMOhwNzc3NYWFhAPB4v2QeDz+dDKBSioaEBOp0OPT09qKmpgUql2pQ/y+fzMBqN8Pv9EIvF2+oh3QoSdhaJRJBIJFvmk4jRWFlZQTgchtvtRiKRQCgUokbQYDCgoqICBoMBIpEIbDabhiRramqwZ88e2O122Gw2pFKpux56kkql2L17N6qrqyEWi5FIJODxeBCNRmneK5lMwufz0VM/uX4S+k0mk5BIJKipqQGXy0V1dTWamprg9XrR19dXlHtEQndmsxn19fXQ6XQQi8U0D8jn8+n92viM3QjiMQNXD2r19fVIJBIQCoWIxWIlbwhZLBa0Wi3EYjH0ej38fj8cDgfC4fAtw7p6vR5arRYtLS2wWCzgcrk0rO/z+TA9PV2QFAWLxQKLxUJDQwNqa2uh1WrB5/OxtrYGq9WKyclJOJ3Okr8XHwWyV25Mq6TTaYTDYaRSqYKvp6SMII/Hg1arxZ49e/D000/jnXfewdmzZ/Haa69hZWWlKB/Q7aJWq1FTU4O//uu/xtGjR+nfX2tUGAwGOjo6IJPJ8PbbbyORSMDv9xclJ5HNZpFOp6mh24pMJoNkMonXX38dk5OTuHLlCrxeL2w2G/2ZQ4cOoaOjA88++yzMZjPEYjEYDAbNebS3t2N1dRWzs7Pwer13/T4ajUZ84xvfgMvlwvLyMs6cOYP19XUsLCzQ5uJgMIi5uTmkUin67zOZTJhMJnA4HASDQVgsFjz99NPo7u7G3r178cgjj6CxsRELCwtF8dj1ej0efPBBHDt2DN3d3Vt65jfiRp48gcfj4fDhw5BKpfj5z38Or9db8sUXAoEAR48eRWtrK5555hmcP38ev/zlLzE+Po6VlZWb/uzx48dx9OhRPPLII9BqtZu+Njs7i1/+8pewWq3buXwAVz93sViMp59+GsePH0dlZSUikQjOnDmD/v5+/Pa3vy3Zg/524vP5MD4+XpR9sCSMIIfDgclkQlVVFQ4ePIju7m7kcjnMzc3h0qVLcLlciMViJVekAFytmFSr1di7dy/27NkDg8EAJpNJPY54PA42m73p1E5UIORyOcRiMQKBQFGuTSaTwWAwUKHerTbN5eVlLC8v03Dm6urqdR65zWZDOp2GSCSCyWTCsWPHIJfLoVaraSjObDZj//79OHfu3F3v7VxZWcG//uu/IhwOw+/3w+v10hAXMXiJRALxeHyTJ5jL5eD1esFisRCPx2Gz2fDWW28hkUhAJBKBwWBAp9OBz+eDxWIVvJqyoqICBw8eRHV19R1LZt3MAJKvCYVCqFQqdHR0YH5+vqSNIKlcPnr0KOrq6qBUKmGxWHD8+HFEIhH4fD7E4/Hr8npisRgymQwNDQ1obW2lnnQ+n0cqlUIwGITdbsfc3FxBDjparZZWu+t0OqRSKbjdbvT392NqaoqG7D+uMBgMtLa2Ys+ePeDxeEgmk3C5XPD5fEXb30vCCPJ4PLS2tqK7uxtf/vKXIRQKkU6nMTExgffffx/BYLBkT0disZi+jI8//jgUCgXy+Tyy2SxSqRT8fj/4fD44HA4NN8rlcuTzeSgUiut68QqJQqGA0WiEXC6HQCDY8nvm5uZw8eJFnD9/HktLS1t+z9LSEpaWlrC4uAiDwQC1Wo26ujpUVFTQDbexsRHJZBJjY2N33QguLi7i//yf/3PHP5fP5zf1mUYiESwtLSGdTkOpVKKjowN6vR4CgaAoRlCj0eDEiRMQCoXXrZtwbZvHjbj2+xgMBoRCISoqKtDT04N8Po/R0dG7uPq7B5PJRGVlJerr63Hq1ClotVoIhUI0NTVBIpFgenqaevnXGhCpVIra2lq0tLSgo6MDQqGQfhbJZHJTGHK7K2WZTCaqqqqwb98+NDQ0QK/Xw+VyYW1tDefOncPa2trHvm2FyWSiu7ubRsuCwSCsVivcbnfR1lQSRpDL5dJiCrlcjgsXLuD111/HhQsXEIlESvLB4PF4qKmpQWdnJz772c/CbDZDKpWCzWYjnU6jr68PS0tLeP3119HR0YGvfvWrtGpxfn4eVqsVc3NzsNvtRTsB+Xw+LC0tIRwOI51Ob5lXCofDWF9fRz6fB5fLvWkoMxgMgsViYXh4GOl0Gq2trQCubsAGgwGZTAZyufyWv6eYEEWid999F5WVlZDL5bTS1+12F7yCcCuPLpPJIJ1OIxAIwOl0YmJiApFIBJFIBMvLy9Sj4XK50Gg0qKiogMlkQnNzM8xm86bWF6VSiUceeQQymYz23q6vrxfsGm+FVquFWq3GF7/4RTQ3N0OpVILD4SCfz2NhYQG/+93vMDU1hUAgsGmfYDKZtBftySefRHNzM3g8HhgMBnK5HJLJJFZXV/HKK69gZGQEiURiW/cZpVKJpqYmnDx5Eo8++iiqqqqQTCbx4x//GOPj47Db7QUtzCkV4vE4ZmZmCl4Ms5GiG0EOhwOhUEg9CBaLBavVildffRUej6fk+gEZDAa4XC4kEgmMRiNaWlpw5MgR8Pl8qsoRjUYxPT2NyclJvPHGG0in0/jc5z4HHo9HdU9XVlbgdruL2i8YjUbh8XhoUcRWRpBM6yDSTul0+oZGO5FIIBwOw+l0orKyctP3SaVS6HQ66lUxGIySCm9v7Bfzer2YmZlBOBwGk8mEUCjc5EEUikwmg1gsBjabDS6XS9cXi8UQj8fhdDqpp+7z+eD3+zE6Oko9bT6fD5PJBKPRiF27dkEmk8FoNG7qyxIIBHRUj9lsRiQSKQkjSKp61Wo1TCYT9u/fj+bmZhqmzuVycLlcGBoawtra2nVeHIvFgkgkQk1NDfbv3w+dTkdblXK5HGKxGP15m8227ZEmkUgEi8WClpYWtLe3I5PJIBgMore3FyMjIwgEAh/qgEXepY19oYRcLodsNksFIEqRdDoNt9td1Kr/ohpBNpuNJ554Ai0tLXj44YeRSCTw8ssvo7e3Fw6Ho+RCoCS/8Oyzz9IQi0ql2pRn+Md//EdcuHABy8vLYLFYePDBB7Fv3z5UVFTcVgVfIQkGg0gkEpifn4darUZTU9Omdg4ANCdls9luq2eJnL4bGxu3LNMnlaOlBIvFQkVFBQ1fB4NBLC0tIZFIgMvlQiwW0823kFy5cgV/9Ed/hPvvvx/33nsvrWJ9+eWXaZ42Go0iFAohk8kgm81umjKQTCaxtLSEaDSKVCoFvV4Pk8kEnU53XYjVYrHgK1/5Cn74wx9iZmamoNe5FUajER0dHTh16hR2794Ni8VCC64ymQwikQhsNhuGh4e3fC71ej2efPJJHDx4kBY/EUKhEF544QWMjY3h3LlziMfj2349SqUShw4dgtFoBAC89957GB8fx/T0NFwu14eOMLS1tcFoNOLhhx+GXC7f9LWZmRnMzMzg7NmzO0Jdq1gUbTciJd5msxmNjY2QSqWIRCKYnJyEw+EoyXCZSCSCUqlES0sL6uvrUVdXBx6PRzenWCyG2dlZDA8PIxKJQKVSoba2FgaDYVNJNpFFKnaYlxwyiEIKKR0HsClcxmQyodPp4HA4wOfz6QvL5XLB5/M3tVYolUraiLzRuyJqMsVO/BMlHJFIBB6PR/9otVokk0m43W7a3kG8Vi6XSz+XQhIIBDA6OoqqqipUVVWBxWIhkUhgfHwcS0tLmJiYuO4ZIqIBYrGYrl2hUEAul9MDzlZeAYnGiMXiglzbVnA4HHA4HJrHa2trQ1NTE+rr62nrDQAaylxfX0cgENi0VzAYDAgEAlRUVKC5uRlVVVU0353P55FIJBAIBDAzM4OFhYVtr8wmsmhqtRoGg4G2o5D7FwwG76gdYmN/q1AoRH19Perr69He3g6ZTIZEIkEL8UgdwujoaMnmG8nBrZgRv6IZwYqKCmg0Ghw7dgyNjY1UZutHP/pRyTbE19fXo6mpCXv27EF1dfUmZRUi5zY9PQ23200f/HvvvZd+L3D1Rbx8+TLOnj2LSCRSzMsBcDVk0tvbi0AggO7u7us8BLFYDB6Ph09/+tPo6emB1+ulL1NtbS06OzshFAppqJfNZkOn010XnrFarRgfH8f6+npRK32VSiV0Oh2OHz+OpqYmNDc3QyaTQS6XI51OIxQKIRaLIRKJoLm5GSwWC2KxmHohhSQej8Nut+OFF17A66+/TsNbgUAA6XR6y02tsbERVVVVOHnyJDQaDYxGI6RSKSoqKmhOmhzGbtVGUUhYLBZ0Oh1qa2vx6U9/Gs3NzbSC8Fr5vuXlZXznO9/B1NQUgsHgpmeJz+ejp6cHPT09ePjhhzcZ9Vwuh/HxcczOzuK1116D2+3e9udQKpXisccew65du3DgwAF4PB6MjIzg1VdfxZkzZ+64GIfD4UAikWDv3r3Yt28fHnroIVgsFpqKmJ2dhUajQUNDA2QyGVpaWjAyMoL19XXaJ1tKRKNRjIyM3LLFZTspmhHUaDQwm81U4mlhYQFWqxXBYLAkvUAGgwGLxYLdu3dDJpPR8EokEsHa2hpGR0fR399P8zFKpRJarRZarRYymQwMBoMOx3Q6nVhbWyuJcG8+n4fD4QCHw8Ho6CiMRiMsFgvddIi0mslkgkQi2eTB6nQ6GI1G8Hg8cLlcuqkS73AjNpsNg4ODCIfDRc1P6HQ67N27Fx0dHTCbzaipqYFIJIJIJEI2m4VMJkM8Hkc8HodUKgWHw0FbWxst547H47S0nngh27WxkCrjSCRC/x3iVW/1GTIYDNoKQIpIyFw6ovm6MR9YCgaQ5P1kMhl27dqFmpoatLS0oLq6GlKpdMvrJIo3yWSSqgHl83maB9y7dy/a29uvE3rP5XIYHR3F6OgoAoFAQXRTiSyhXq+n70UqlaItO3eKVCpFa2sr2tvb0d7eDqFQiGg0iuHhYbjdbszMzMBkMtEmfIVCAaFQuElGr5RIp9NYX18vam1E0YxgR0cHjhw5AoPBgHw+j9/+9reYnp4u6RE8Dz74IJ588slNf7e6uoqXXnoJ7777Lt5//33kcjlwuVw0Nzejo6MDtbW11LvyeDxYXl6mJd2lQD6fx8TEBKxWK/h8Prq6uvDnf/7nm8KiLBYLu3fvvuHGezsixOfPn8ePfvSjot/bnp4e/Mmf/An0ej09nBCIOPW1a/zyl7+MYDCInp4eBAIBuN1uDA0N4fLly/B6vds+7TudTt9WyIzJZOKRRx7BqVOnIJfLafiwFDc/ADRHvHfvXjQ2NuLZZ5+FWq3eFErfqoCKhAQ5HA6tNM5ms+ByudBqtfjWt74FnU533XWn02n89Kc/RW9vb8FC8gKBAN3d3TCbzZtSIh/2PTCZTHj22WfR2dmJtrY2jI2NYXp6Gt/5znewtLQEt9uNXbt2gclkYvfu3fQwIBKJ7rjXtBDEYjFMTk4WtTK24EbwWnHsSCSCQCAAm82GWCyGhoYGSCQSKBQKAKAK/8TjKmY+aWpqChcvXoTZbKZamaurqxgcHITD4UAul0N1dTW0Wi1OnDiB+vp6sNlsOk7IZrNhYGCgJJuS0+k0ZmZmkM/ncebMGahUKmg0GiiVShoKvNVmeu3XN77ozc3NOHnyJCYnJxEIBIoWEiWl8ywWi24KmUwGfr+fntDJH1IJq1KpwGKx0NTURKt/TSYTdu3ahdXVVXi9Xly6dAl+vx+RSKQo16VQKKBSqejJ/0Yi6DeCx+NBoVDQauepqSn4/f5tDZ8ZDAbodDrcc889aGhogFqtvq4AaavPUqPR4IknnoDNZsP8/Dwt/FEoFNDr9XTD3/izoVAIXq8XyWSy4HvIxneH7GN34oUSeb9jx45RD5DH48Fms+Gdd97B6Ogo7HY7wuEwstksGAwGeDwe9ZJvpghVChR7bQU3gkKhEBqNBhaLBc3NzXA4HLDZbFheXqZqAtXV1TCbzcjn88hkMujt7cXq6upHqqL6qOTzeYyMjAC4umEolUoAoIaNuPO1tbVoamrCqVOnYDAYqBFMpVKwWq20nL3USKfTmJ6eRigUgsFggNlsRmdnJ9hs9h0VS9yokbujowMMBoP2fW53X9aNIN7HRg8jk8nA6XRS5ZFgMAi/349YLIZsNovW1lao1Wrs2rWLhtdIr97CwgLsdjt9NqPRaFFe6oqKClgsFigUCtoPt5FbtaTweDyqHkOk/CKRyLZuoDU1Nejq6sKpU6fQ0NBw3ddv9O9qtVo888wzcDqdWFpagt/vRzweh8FggEwmg0gk2vSzZAqNw+EoestVKBTCysrKHUUPmEwmlEol7Ufu7OykfcavvfYaLly4sOldYrFY9CBEpmOUmgoNuT/FNoBAEYygVCqFyWRCRUUFHRFjMBjwjW98A0KhEI2NjVTQmeRE6urqMD8/j4mJiaIKyw4MDNC+LBIudLlc8Hq9SKfTNG+4a9cuKBQK6i2Sgguv1wu32130F/FGEBmxN998E/v27YPJZKI9gjd7WMlL5vf7qXwa6f8Erm7Azc3N0Ol0UKvVWFxcxD//8z/D5/MV/H5euHABf/3Xf42WlhZawBMOh/Hmm28iEolQQfONOTiZTEarJ3U6Hbq7u1FXVweLxQK9Xg+lUok//uM/xtLSEl555RWsra0VPNy9traGWCyGoaEh8Pl8tLS00OfvdkLWpC+PqOR0dnZibW0NP//5z7G6uoqlpaW7vmHV1tZi3759kEqlH+rn5XI5nWOZzWYhEAiol38tg4OD6OvrK9oBlEgozs7O4q233rrt5nAOh4P7778fTU1N6O7uhkAgwNraGt5//3288cYbWFhYuM7AcblcyOVyRKNRzM3NYWVlBevr60WvQdBqtdBoNFTk/v333y+JaRkFNYKkXFin00EqldJyboVCgcOHD0MikWwqygCubrBisRgCgaDofXZ2ux12ux3j4+PXfY2U1FdWVqK6uhpCoZCul4weSqVS1ADeapDkjV5m8vtIE+zdPOGRRuzZ2VlUV1dTcW3gA09iq2nxpEdtfX0dyWQSCoUCAoEAbDabquZrNBqo1WqIxWIYDAb8x3/8R1EmFywtLcHr9cLr9dKinlAohLfeemvT1IlrYbPZkEqlqKuroxPcNRoNhEIh5HI5Dh48iJqaGkxNTSGfzxfcCEYiEcRiMdhsNhgMBtTV1W3KQQHYNDOP5HoJxFBWVlZCq9WioaEBPp8Ply9fpqH8u+25KxQKVFdXU2MNXH0GydirjcIMJA9IwrxEQKCiouKm/wapqLXZbBgdHS1o7mnjmkl7xvr6OhViuJ2f53K5aGtrQ1tbGwwGA5LJJGw2G2ZnZ6lRvzb6wuFwIBaLkUqlEAqFEAgESqISXSqVQq/Xg8fjIZPJ0DaVYnuDBTOCAoEAWq0Wx48fx5e+9CUYjUYwGAyo1Wr6oBZ7wvCHgfTkHD58GAcPHsTRo0dhMpk2vdh8Ph9arRZtbW3wer1QqVQ31c9kMpl45plnUF9fv+UDMjExgbm5Obz11lvb1gQrkUhoRShwdXOKRCL4zW9+A6fTicXFRbqhEs+JjLsipfkPPvggLBYLOjo6kMvlwGAw6CDT3/u938P4+DhefvnlgoZqSHXn+fPnadiQVBvebJMnCh+Tk5NYXV3Ff/7nf0IsFqO7uxu1tbX44he/iOrqahw/fhw8Hg/nz58v+Mudz+cxPj6OdDpNFXrIUOpUKoXl5WWsrq7SGYRdXV2beug2/pfMK/zCF76A4eFhTE9P0yrV7SQej2NlZQUXLlzAr3/9awCg+4RMJkN7ezsqKipQX19Pq19vxtraGhYXF9HX14eBgYGCGQMGgwGNRoPq6mo0NDSAy+Vibm4ONpsNbrf7trwfjUYDnU6Hhx9+GE1NTeByubDb7XjvvfcwOTl53e/hcDj036ytrcXMzAyWlpa2vXDrdiEj8oqpl7wVBTOCpHyZyCCRYaZcLpdq+aXTaTrJO51OU2+q1HpbNkKuq7q6Gp2dndTL3XgCJ96QWq2GxWJBNpu9aZMuk8lEZ2cnGhsbN01zJ5BN7NKlS9t6bdeG0MiU+OXlZYyPj28ygplMhqqsuFwuBINBVFdXI5fLQSaT0QIb0qhOBLXVajUikUjBTujEi/0wJdmksXfjpkLynD6fj06wl8lkd3PJt00+n4fL5QKPx6N6mgDo+2W1WrGyskIPbmKxGFKpFAKBAHw+n25OxCtks9kwGo0IBAJQKpXUmN4tkskkwuEwPB4PLUQKhUKYmZnB6OgohoaG6Ho0Gg39XNVqNTKZDIxGI/h8Pg2DEsjBhkhyTU9PY21tDaFQqKAHLi6XC4FAALFYjEwmA4/HQ3V6bwVpHTEajdDpdFAoFEgmk/D7/Zifn79u0DMphjGZTLQdIxaL0akvpQAZI1VqilEFWw05WUqlUkil0k0hz1Qqhbm5ObhcLkxNTWF1dRXLy8s4fPgw6uvrodfrC7XMO4ZMkejp6cG9995LVRq2orOzEy0tLbTY4GYvpFAopEU116JSqbB//3787ne/w+Tk5F27lo2Ew2FYrVZIpVKo1WoAV43d7OwsZmdnMTo6uulwQq6HaKP6/X4sLCxAr9dTSa6TJ0+Cw+FAJBLh8ccfR2trK7LZLK5cuYL33ntvW65juxkbG8Pi4iJaW1tRV1eHqqqq6wQHCr2eyclJnD9/nqqvAKD9hvF4nIbMLBYLtFot9u7di7a2Ntx33300hA1cPbxVVVUhlUrh3nvvxfj4OC5cuHDX1rq4uIgLFy6gt7cX2WwWDocDLpcL/f39SCaTmyooPR4PGAwGrly5Qq/r6NGjeOKJJ9Dd3Y2amhoAHxzcEokEVlZW8NZbb+FHP/pRwYvqyCGCw+GAz+fD7XZTsYhbQQ65J0+exMGDB6FSqZBOp7G4uIj+/n688MIL13l3HA4HVVVV+Iu/+AtUV1eDwWBgYmICv/71r+FwOLbrMj8WFMwI8vl8VFdXQ6lUgsFg0JlvLpcLoVAIk5OTdKqBx+PB+vo6LBYLNBrNLUMexYQU72QyGWQyGWoEt3rhiCwUMZI3eyk9Hg9SqRTt9+JyufTfWVlZgd1u39YGU5LPuLZcnTSS32xCfC6Xo6d6Uok5MzMDg8EAk8lEJcuEQiFEIhGd11fqpdxbkclkkEgksLq6Ch6PR72UYq6H/GGxWHSzJBXKxHtgs9m09YjD4SAWi4HH49HGbiIZx2KxIJVKsXv3bkSj0btqBJ1OJyYnJ+k75PV6EQgEtpyvuTHqQDwK8nlvTD0Qr9fj8WB4eBjz8/Pwer0FaYy/lo0FSaT69nYOSAKBADKZDNXV1TCZTOByuUgmkzScSqJlBDabjV27dqGxsZF6x0RWjuwjZW5MwYygQqHAkSNHUFdXBwCYnJzE1NQU3n77bdjtdkxNTdGQKKGlpQV6vR61tbWFWuYdQ0baeL1euFwuWnF4bZ8SYeOLcaPvIbkdl8uFvXv3QiaTgcvl0rzUK6+8gldffRWzs7Pbdl0kub6xGGnjBINbQTY2t9sNt9uNN954Ay6XC5/73OdQW1tL+8HIaZlM4Ch2pdiHIZvNYnp6GrFYDNXV1SUxEocUT91oA8xkMlhdXcXq6iomJyehVCrxu9/9Ds888wwefPBBVFVV0dYYjUaDL33pSwCAn/3sZ3dtjWNjY5uKzG73AMTlcqHT6dDY2IiDBw9u+hoxppOTk/jJT34Cq9VaEn25crkcPT09tM3qZigUCtTV1aGjowPd3d1gMBjweDx444036D65EYFAgD/6oz+iWqs2mw1nz57F5ORkSUwEKXUKHg4liXiPx4OlpSUsLy/D6XTSvjHSnKzT6dDa2orGxkaq7l9qvS4A6Kmzv78fTCYTFRUVEAqFtzXg9GaeVH9/P3w+H6xWKyQSCWQyGZLJJCKRCPr6+mCz2bY11k8UOa4N7ZJK0DvF5XJhfn4eyWRy02Tz2tpaLC4ubpn73CkwGAxIpdLrFGiKuR6BQACVSoXDhw/THMzExARmZ2cRj8evC2WTfBORIrtWSed2xBI+DB/mnms0Gnz605+mBmIj4XAYv/rVrzYJZBcLkn/OZrNUpJ3MdVxdXb3hJHudToddu3bRXmTSLx0MBukBiwjBt7e3w2Qy0XmmU1NTmJqawpkzZ244BLvMZgpqBKVSKQ1deDweWK1WLC8vX1cpqdVq0d3djY6ODrS0tGBychJer7ckjWAqlYLH40Fvby/m5uaoWv9HMYL5fB6Tk5MIBoMYHh6mYUMyX25tbW3bJzETL22jESQv44cxgmQwbyKRoDkngUAAi8WCkZERegDaiTAYDDp8txTmJBL5N5PJhC996Uv04Pn888/TfrFr7yGJaKTT6ZKU19pIZWUlnnnmmU2jg8hnHg6H8bOf/Qw2m63oohTEAGazWXA4HGi1WtTV1aG9vZ2OwLoWJpMJg8GAPXv2XGcEidISyekKBALs378fPT09MJvNAK7KEw4MDOCtt94qmarQUqdgRtDlcuGll17C8ePHodPpsH//fhiNRtjtdqqMz+PxoNFocPz4cXzhC18Ak8nE4uIifvGLX9ATbKkSDoeRSqXgdrs/cqsHaUfI5XJwOBx0Bh95qQrxOSwuLuKXv/wlPvOZz0Cv19Om8f/xP/4HhoaG8A//8A+0sfx2MBgMaGhoAJvNRjweB4/HQzQaxdjYGOx2e9FHLH1Y2Gw2hEIhOjs7odFoMDExgcXFxaKth8FgQCgU4qmnnkJzczNaWlqoePKXv/xl3HfffVhcXITT6aSTKVpaWiCVSmnBVWVl5aY8W6kgFovxyCOPoKurC0qlctPsy1wuh+HhYczMzMDtdhe9Ly6Xy9Fo15kzZ2A2m9HV1YX29nYIBAKIRCI6dYYYK/Is1dXVYf/+/VCpVMjn81TBKBQKQSaT4eGHH0ZDQwMaGxvR2toKuVyOl19+Gaurq+jr68Pa2hqVUCsltFotHYxcShTMCIbDYYyOjqKmpgZ+vx8GgwF6vR5Go5Ge2IRCIaqqqtDY2Iienh6MjY3BZrNhaGgIc3NzRVWLuRWpVGpbEtDFGivl9XoxPDyM48ePAwCdDnH48GGa5A+Hw9QQbmXESGMz6fMiw03Jy5lMJqmC/E40gMDV/JRQKIRer4dcLseZM2fgcrmK5g0ymUzweDx0d3ejpaUFGo2GFiepVCrs2rULU1NTWFlZwfT0NLLZLHbv3g2FQgG1Wo3a2tqizhS8EaQVqaenBy0tLRAKhZsKzDKZDBYXFzEzM1OQfsbbIRaLwefzYXJyEkwmE01NTaioqIBMJsP09DSi0SjW19fBYDCQTqfps0RmcpKaAbK3kDFKXV1d2L17N3bt2kWb4kkv5/j4OGKxWElc/7WQ3lVyeCFecrEpmBGMRCKYnp4Gh8NBIBDA008/jV27duF//s//iVAohFQqBTabDYlEAiaTiYmJCbz22msYGhqC3W4v6ekSH0disRgcDgc9UZPPXiQSob29Hf/4j/9I5+799re/xcDAwCZJOJFIRAtgpFIpvvCFL+D48eOQy+UlO9blw2A2m6kMYDqdxrlz524qhLDdCAQCKBQKdHR0oL6+flPxFfmvyWSiqjIA6ABeEmIrNZhMJrq7u1FfX4+HH34YlZWVm+ZzkuKr//zP/8TIyEhJFCYR/H4/nnvuObS1tSGdTqO1tRWtra347Gc/i0ceeQQjIyNwOp3o7+9HMBiE1+sFm82Gw+GASqWiuV2BQIDvfOc74HK5VHAin8/j9OnTmJ2dpYVn8Xi8ZA+URI6Pz+fTjoC5ubmir7dgRjCXyyEWi8HpdGJqago2m402gup0OiSTSdprRrQK5+bmYLVaEYvFiv5BfdJIp9OIRqPweDxwOBxUmJlI37W2tiKRSCAajWJlZQXRaBQul4uWopP+SWIEzWYzDAYDgKvPApkeUgqhqw8DqWolMnnpdJqGrUrheq4tNNr4vwUCAZ0xeKvfkclkkEql4PP54PV6t229t0IsFkMul0OlUl23br/fTyUNnU5nSXgXBCLOLhaLMT4+TnPtAOg6N040IfKD4+Pjm1oqSItLNpuFz+dDNBpFJBLBxMQEDQGX6jByAmltAT4IF18r+1YMCt66T6ZB8Pl8TExM4Pd+7/egVqtpi8H4+DguXbqEd999l/aj7cSy+Z1OIpFAMpnEa6+9hrW1NXzlK1+B2WymaiNGo5FutGazmQ4JJS828eqJh7Exf5NIJNDf348rV67g5z//eUmd3G8XErK699570draipGRESwtLRX9JB6LxeD1etHb24tQKIRDhw59aIUOslFZrVb85Cc/2TZhhjuBPHMbC5AuX76M999/n0aMShGr1Yrvfve7tKqTQPRcSTohl8thbGwM//Zv/3ZdgRK5bgLpxyUKWzuJdDqNqampLQXAC03BjSC56cvLywBAq+q8Xi+CwSCsVisWFxcRDAZ3dMXgxwEydZ7H42FkZASJRILqom4c1yORSCAUCjcJbpPcFBEQJi+62+2Gx+NBX18fpqamEIlESv4FJuOXyKw+lUqF6upq1NTUQKPRIJfLYX5+HlarteheCPEY5ubmwGKxUF9fv0lSDLjqVZGQ9FZhaVKMEYlEMDo6SnNtxew5IwoyZP8gE9rj8TgcDgesVmtRGuJvFyK5dztkMpmSNeYfBplMBp1OR6tdgY9WaX63KbgRJCe5kZERjIyM4NVXX93ye8qUBrOzs1hYWACLxUJjYyN+//d/HxqNBhqNhm6gpHr1Rq0hG8Nqly9fxvT0NL7//e/D5/OVZAL/WkhBwq5du2AymbB//340NjaiqakJw8PDWFhYwHvvvVcyfVmJRAJvv/02lpaWUFtbSw8sxJNoamqCQqG4oYeYz+extLQEm82G//iP/8Dy8jJtYykG+XweoVAIPp+PaozyeDyEw2Gsra1hfHwcV65cKbcElCi1tbV47LHH0NjYWOylbEnRlUzLBq/0yeVymJubo4LMSqUSVVVVVBdUpVLRWP+1ngUpniEyTmQGWjgcLpkwN4fDoQOQSRWlWq2mHmBNTQ3kcjlMJhMd/2W322G1WnH58mVYrVb62ZQCuVwObrcb2WwWv/jFL2iVLjGCtbW1kMlkN5w+T0ZBud1uKsRd7JBVMplEPB6nknAMBgOLi4s4c+YMrFZrUSbGl7k9IpEIbDYbQqEQFXm32+0lEwEquhEsU/qQTXFhYQHT09OQSqWora1FT08P9QKvneZNiEajcDqdGB0dxczMDF5//XWsrKwU4SquZ6OuY11dHdUwra+vR0tLC/VuDxw4QEOhRJJraGgIAwMDGBgYwMrKSsm80MDV++XxeODxeLaU1tPr9bQi9Easrq7ecrxUISE553Q6TcPuc3NzOH36NBYXF3dEROGTSiQSoQfFbDaLtbU1LC8vl8whmHELZZOym1ZmE1wuF2w2G2KxGAqFApWVlRCLxTdsriZ5m0AggHA4vO1yb7fLqVOn0N7ejvr6eprPJJ4SmaTgdDoRiUTA5/ORyWToadbpdMLn89E/xS6GuVP4fD71em8EKXIqlUgNaTDfvXs3De+ura1hYWEBkUjkOj3NMqUDGdNlNptRVVVF881DQ0MFy+Pm8/kbPuxlI1jmE8nXvvY1HD16FHv27AGfz4fVaqUn03A4jFAoROe2hUIhhEIh2oNW6Ll0ZcqU+WiUjWCZMtegUqkgEonoNIuNo6GIPF0ymaQVbLlcjnp8pRIiLFOmzO1RNoJlypQpU+YTy82MYGnLxZcpU6ZMmTLbSNkIlilTpkyZTyxlI1imTJkyZT6xlI1gmTJlypT5xFI2gmXKlClT5hNL2QiWKVOmTJlPLGUjWKZMmTJlPrGUjWCZMmXKlPnEUjaCZcqUKVPmE0vZCJYpU6ZMmU8sJTNKicFggMfjQSaTobq6GmazGcD18wZ9Ph8mJiYQiUQQDoeLsdQyZcqUKfMxoWSMIJvNhlwuR1tbGz7zmc/gD/7gD+gU+o1cvnwZf/M3f4P5+fmyESxTpkyZMh+JohtBNpsNqVSK++67D1VVVejq6kJzczMAUAV/JpNJ57wxmUxwudybDgQtJA0NDXjkkUfo/yfDSldXVxEKhbC0tASPxwOr1YpcLlcy89nKlClTpkwJGEEOhwOFQoFHH30U9fX16O7uBoPBQC6XQzKZRDqdpsaPxWKBwWCAw+GUjBE0m8345je/SQeUajQacLlcXLlyBQ6HA2fPnsXs7CxWV1eRyWSQyWTKhrDMjoHJ/KBsYKvITJnS4tr7tfG/pcTGgc43G+5ciGeuaEaQw+GAz+fjqaeeQlNTE/bt2weFQgEGgwGbzYbZ2VlcuXIFKysr0Gg0qKysxBe+8AXweDxotVrY7fZiLX0TkUgE8/PzqKmpQVVVFTgcDvL5PIxGI7RaLSwWCwKBAD7/+c/D4/HA4/Hg5Zdfxvz8PJLJZEk+oGXKyGQyqFQqfPWrX0VlZSWUSiXeffddfO973ytHNEoMBoMBmUwGg8GAL3/5y1AoFFAqlRgeHsbIyAguXbqEtbW1gq+LRPnYbDa4XC51AGpqaqBQKFBTUwOxWAytVgu5XA6NRgPgquHz+XwIBAJ4//334Xa7YbVaEYvFtiUFVhQjyGAwIBKJIJfL0dXVhba2Nuj1erDZbCSTSTidTkxMTKCvrw9zc3MwGo2oq6tDIpFAPp8vqXBoMpmEx+OBXq+HUCik3h4A8Hg8aDQapNNpmM1muFwuuFwu9PX1YXl5edMg150Og8EAk8mk4eobne7IyW7jtefz+aJMamcwGPRZ4vF4yGaziMfjdIjunf4uJpMJgUBAryedTtNnoRAwGAwaLfmoEQelUomqqiocP34cNTU1UKlU8Hg8YDAYYDAYJfPckntINtprPaFsNot0Oo1UKoVsNlsy62axWGAymRAKhWAwGEgkEnStdwqDwYBQKIRGo8GJEydQWVmJyspK8Pl8RCIRjI+Pb8MV3BwulwuBQIDKykpwuVzw+Xyk02lks1k0NDRAo9GgpaUFCoUCRqMRarUa1dXV9OfX1tbgdrvh9/uxsrKCZDIJv9+PTCZD7+XdouBGkMPhgMvl4lOf+hT27duHkydPQqPRgMPhYH19HefOncOZM2dw+vRpRCIRpNNpJBIJpNNpzM3NYXV1FWNjY3A6nYVe+paEQiFMTk6isrISLS0tiMVi8Hq9+Ju/+RtEo1Hce++9EAgE4PF4MJlMaGtrg8FggFKpRCKRKMrmf7cRCoUQCARQq9VQKBS49957IRQKt/zeVCqFcDiMd955B/F4HMDVz9Dn8yGdThfs8xAKhRAKhTh8+DBqa2vx+OOPY35+Hv/6r/+K1dVVrK6u3tHvIy/8s88+i2w2i9XVVQwNDWFwcHCbrmAz5L2yWCwQiUSYmJhALBb7UJsqi8XCV7/6VRw8eBDNzc3IZrPo7+/H3NxcSXmBJJp09OhRtLe347777oNWqwWDwUA2m0UqlcLk5CT6+/vR19dHi+nu5gb6YTGZTKiqqsI3vvEN8Pl8/OpXv8LS0hIGBwfv+PDEYDCgVquh1+tRXV0NqVQKoHhhUB6PhyNHjqC+vh7PPPMMBAIB9QRzuRyUSiX4fD74fD5YLNaW6a2KigrI5XL84R/+IeLxOLxeLyYmJnD27FlcunQJU1NTd+36Cm4E+Xw+lEolamtr0dzcDJVKRU8sTqcTY2NjmJ+fp+47g8FAOByG1+vF2NgYXC4X3G43IpFIoZe+JbFYDEtLS3QTz2azyGQyWFlZgdfrhUajgUAggEAgQDabBYPBQDQaLalT6YeFz+dDJBLRcJlOp4NKpUJ7ezsEAsGWP5NOp+n9JEbQ7XZjZWUFLpcLoVBoWz8XLpcLHo+H6upqqNVqdHR0oLq6GpWVlfB6vXccZWCxWGCz2TAajTAajWhra0MsFkMul8Pc3Ny2Xce1CIVCSKVSNDY2Qi6X00jDnRpBNpsNPp+P6upq1NbWQigUIhgMwuFwwO/3l0RekNQRkBBaR0cH2tra0NraSkNquVwOqVSKelnxeBxCoRBWqxXhcBjBYLAo18FkMsFms1FTU4Pm5ma0traCz+djdnYWDAYDY2Njd2ykmUwmtFotdDod+Hw+OBwO/VqxrrGyshJGoxH19fV0TSTCIhKJwGQyEY1Gae1HLpejRjKfz0MkEoHD4UCj0VDDmcvlEAgE4HA44HA4EIlE7kqkpeBG0Gg0Yu/evThy5Aj27dsHNpuNWCyGgYEBXLp0Cd/73vfo5ghcvYl+vx/BYBB/9md/RkNppeJB2e12vPjiizAajTh69Oim+Pfa2hqee+45+r1VVVWorKzE9PQ0vF5v0TeTj4rRaMT+/ftx/PhxdHZ2wmAwQCgUgs2+8WNFQmlPPPEEvf7p6WlcunQJL774Ii5duoR0Or1tn01lZSUsFgt+//d/H/v374dWq0UikcA777yDiYkJeDwexGKx2/59EokECoUCX//619HU1IRDhw7BbrfD5XLd8CCwHdTU1KCtrQ3f/OY3UV1djYmJCSSTSZpCuF2USiW0Wi0MBgO0Wi3YbDbC4TD6+/uxsLBQEs+sVqvFY489hj179uDee++FRCK5bvMnfcft7e1oaWnBk08+iUgkgh/84AcYHx/HW2+9hUQiUfC1kzTQ5z//eZw6dQoqlQosFgvf/OY38eabb+K9996je9ztwuVycerUKbS3t2/6DIoFm81GQ0MDGhsboVAotlxTMpnElStXEIvFkM/nEY1G4ff7adRv9+7d9F3lcDiQSCTo7u5Ge3s72Gw2GAwGBgYG4PV6P/p6P/JvuE14PB7UajUaGxuxZ88eaLVasFgs2Gw2uN1uDAwMYGpqinpJGyGx/TvZnAoFOXF6PB4sLi5Cr9fT3FI8Ht/0onm9XmQyGXrjdyIcDgdSqRTNzc1oaGjAnj170NDQAK1WC6lUCi6Xe1u/Z+P36XQ6tLa2Yn19HTKZDBcvXoTP57ur6xYIBNBoNOjq6sL+/fvR2NgIlUqFeDxOn7/FxUUEg0Ekk8lb/j5y2Ons7ITZbEZzczOMRiN4PB5SqRRWVlYQDAbv6jVsBZPJBIfDQVVVFTo6OqBWqyEQCGhu8HYhOc2qqio0NzdDLpeDyWTC7/djfX0di4uLcLlc23glt4Z43PX19di3bx/q6+uhVCrptXo8HiQSCboxks1TLpeDx+OBy+Wip6cHcrkcgUAATqcT8/PzBX0XSZW7WCyGTCajle8CgQAVFRVoa2vD4uIijSbcam2kgKmqqgparXZTTrSYkLw4ySEDH7S8jYyMYG1tDQMDA9ThSSQSNP2VzWYRCASg0WgQj8ehUqlgMBjAZDLB4/HQ3NyMWCyGTCYDm80Gq9X6ocL+hIIZQZlMhl27duHkyZN4+umnaXiwv78f09PT+K//+i94PJ6CFhLcTWw2Gy5evIgjR45ALBYjFApdV8nk9/vh9/uLtMKPDoPBgEAggMViwbe+9S3U1taiqamJxvTvZNPdiF6vh16vR0NDA5xOJ77+9a/fdSMol8uxf/9+PProo3jmmWcAXH0ph4aGMDU1heeff54m3m8HgUAAuVyOz3zmMzh+/Dhqa2vB5/MBXFU1unTpUkEqmMmhpLOzE4888gi0Wu0deREEFosFLpeLrq4uPPjgg9DpdMjn81heXsbU1BT6+/sLYtRvhkAgwNGjR9Hd3Y2nn36aehjJZBLxeByzs7NYX1/HwMAA8vk8ZDIZLBYL2tvbodPpIJPJ8PjjjyMYDEKpVOLKlSsF925J8RKPx7suUqDT6fDYY4/hrbfegt1uRzKZvGVo1GAwwGQyoampCbW1tSVRMJjP55FIJK47TKbTaUSjUfz4xz9Gb28vZmdnb3jg5HK5kMvl+NrXvobW1lY89thjNFVx9OhRHDhwAAqFAiMjI/iP//iP0jaCJCxRWVmJEydOoKmpCXw+H6lUioZBx8fH4XK5EI1Gt3s528rGl2mnenpbwWAw0NXVBZ1Oh127dqGqqgqtra2Qy+XgcDhgMpnI5/Ow2+3wer04c+bMDb120udpNBqpISFEo1GEQqFN4fCPikAgwO7du2GxWHDfffehpaUFABCPxxGNRvH+++/TIpI7ycWQ0CfJQ3E4HMTjcUxNTWFsbIyKJWw3CoUCHR0dMJvNUKvVyGazCIfDSCaTd3SgFAgEtKWntbUVEokEqVQKAwMDGBsbQyQS+VDG9W4hl8uhVqvR2dmJ+vr6TV7qwMAA5ubmsLKyglAohLW1NeTzefD5fAwPD6O3txenTp1CR0cHVCoVBAIBdu3ahWw2C4PBgGAwWJB7BVw9tIhEIhrSu/Yau7q6EAgEEAwG6b64FaSgRKlU0rqDa6MwFRUVaGxshFgs3rbr2YpUKoWLFy8iEongxIkTkEgkEAgEYLPZEAgEUKlU0Gg0mJ+fv+HvyGQyiEQiOHPmDObm5uDz+dDW1oYjR47QvOqePXsgk8nw4osvfqT7VxAjyOfzodVqcfDgQeh0OnC5XEQiEQQCAYyMjGBkZAQ+n69k8nwfFvJQf9wMIIvFQkdHB9rb2/HEE09AoVBAIpEA+KDlIZfLwW63Y35+Hj/60Y9uGKsn3uS+ffugUqlQXV29aTNIpVJ3NVcjFAqxb98+tLW14f7776en73g8Dr/fj76+PoyNjd1x7sxiseDBBx+kYVXgakhndHQUU1NTWF9f/0in09tFJpOhtbUVRqMRKpUKPp9vU1jpdq9JKBRCp9PBZDKhoaEBAOj7OTk5eceHhLsJ6YPTarVoaWmB0WgEg8GA3+/HzMwMXnnlFZw7dw6BQOC6z1woFEIikdBeY6lUCpFIhNbWVkQiEVRWViKXyxXMCHK5XGoEr0UikaC5uRkejwdut5vmlreCVMYqlUoaAr8296ZUKlFXVweRSLQt13Ij0uk0Ll++jHQ6DZ/PBxaLRdfHYDCgUqmgVqtvWjuQy+UQi8XQ29sLmUwGp9OJRCKBI0eOALgaGm9vb4dCoQCPx/tI6912I8jj8dDV1YWuri5abQYAExMTGB8fh91uRygU2vEG0GAw0HxDITa/7Yactjo7O9HY2IhnnnkGFouFej0MBgMrKyuYmJjAwsICVldXMTIygvX1ddjt9pt6DeFwGOfPn6e9RBvJ5XJ3JffEYDAgl8tRVVWFe+65hzbmkpfrV7/6FS5evIjBwUF4vd7bfv5ImEav18NoNNLnOZlMwu1244033sDCwkJB2z024nA4sLCwAL/ff1s59I15ls9//vNobW0FABqpWV9fh8fjKerBjslkYvfu3WhpaUFjYyP4fD4WFxfx7rvv4oUXXqC53I2eL5FZNBqN6OjoQEdHBw1Zp9NprKyswG63w+/339XIw43g8/moqKjAyZMn8dBDD6GxsfG67/H5fBgeHsbbb7+N06dPY319/Ya/z2g0oqmpCU8//TQ6OjqgVCqv+x6Hw4HBwUEEAoG7eSm3hIRD19fX8dZbb6GjowPHjx8HcNWDffzxx9He3o5z587dVvN7LBbDzMwMpqenMTU1RavRSeToo75n22oEyQtmMplgNBohlUrBYDCQTqdht9sxMzODYDBY1DDL3UIsFtMG1Z1uBEkIWyKRwGKxoLu7mxZ+5HK5TcVAs7OzGBwcxPz8PCYnJ2/7RF2IjUcqlUKtVsNkMqGyshIcDgexWAyhUAgTExO4ePEi1tfXb6sQhsDj8aBSqWiJPpfLRT6fRyQSgc/no+09xTCApMouFAohlUrdVjiUxWJBLpfDYDCgo6MDFRUVAD4oVAgGg4hEIkUzgkR8oaamBhaLBUqlEtlsFl6vF1arFVeuXKHyitf+HJ/Ph0ajQWNjI/UCybO7uroKp9OJWCxWkP2Hz+dDp9OhsbERPT09NHqwEaI+NT8/j8XFxZv+PqlUCoPBgMbGRhriJ5B7FQwGYbfbC/KuXUs2m0UkEsHMzAwUCgXi8Tg4HA7YbDb1TuVyObxe75aRHyImQH4G+KDHWKFQIJvNIhQKwe/3l64RJG6vyWTCN77xDVRVVYHFYsHpdGJ5eRmvv/463n333R1dKLIRLpcLsVj8oYtDSgWyeezbtw9PPvkkurq6UF9fv2kDCQaDmJiYwNDQEN555x3Mzc3B4XDckTHZbthsNg4fPoy2tjZotVqaF5mamsKFCxcwODgIu91+R3kzDoeDmpoaPPXUU1Tmj8lkIpVK4c0338T4+DisVmvRctsk9SASiaiKyq2uT6PR4Etf+hK6u7vR2tpKZf96e3sxNTWFmZkZuFyuohlBg8EAvV6PBx54AB0dHRAIBHC5XFhYWMDa2hqtorwWiUSCtrY2PPTQQ/jSl74EiURC5bhWVlbwt3/7t1heXobL5SrIgcViseBP//RP0dTUBJ1Ot2UocHl5Gc8999xHFgIhQgGrq6sYHx8vWKj3WgKBAN544w2sr68jn8+jp6eHGmyBQICnn34a4+Pj+M1vfrOpLYrBYKC6uhoVFRXYv38/dDodurq6YDAYYDabEY1GsbKyghdffBETExMf+fq21RPkcDg04U7c9UAgQE/LXq+3JNQb7gYkL8blcsHlcqFUKiGTyba9+ftuQ7x3lUqF+vp6qm4DgHrw6+vrGB4exszMDFZXVxEIBIpy2rwZDAYDSqUSFRUVmxQpkskkAoEAGAwGxGLxpp5TInXG4/FopSeBxWJBJpOhrq4OjY2NtMUnGo0iGAxiZmYGc3NzSCQSRa1wFovFUCgUqKiooF7hRik/Avl8DAYDmpubUV1dDT6fT9VWbDYbpqenaX6xWAiFQsjlcigUCshkMiQSCfj9fiwsLGxpwIiMmlKpREtLC+rq6qBWqwFcNQ4ejwd2ux1LS0twOp3beq/IXqBQKGAymWCxWKBWq68rYMnlckgkEgiFQnC5XLclBCKRSGAwGLbsRU2n0wgEAvD5fHC73UWLtGUyGXi9XjgcDszPz8NsNtO2CTabjaamJmQyGWi1WmSzWbDZbCo+0djYSIUQtFotrUIPh8NYWlrC6uoqTcV81Hu47eFQUsVETj7T09N4/vnnMT8//7ExgMDV8J7P54PRaIRGo8GRI0egUCjw9ttv76jwKJvNprqRra2tVIKJ9O78+7//O6ampvDWW2/RkFspGnkGg0GLITaWjbNYLPD5fLS2tkKtVsPhcNBwTDQahdPpRG1tLS0OIYhEIuzatQsWiwUnT56kz/PExARmZmbwwgsvYHl5uej3ura2FhUVFbjvvvswNzeHwcFBBINBeDyeTd/H5/Nx3333ob29HQ899NCmzTSXy+Gtt97C22+/XXRlJqlUCp1OR6MsVqsVAwMD+H//7/9t6QGwWCzo9Xrs2bMHf/7nf04PcCSKcfbsWVq9u53XxmQyodPpaNtDc3Mz2tvb6bOYz+dp1CiVSsFqtWJ1dRXxePy2nqFdu3bhq1/9Kn0/N+L3+3HlyhVa1FSsegtSqby0tIT33nsPTU1N2LNnD60Sfeyxx9DW1ga3201lB+VyOSQSCVpbW6FUKmm0JZfLYWZmBr29vTh9+jR6e3sRj8dp7+FHYduMIJPJhNlsRmNjI5XMicfjCAaD8Pl8yGQydCPhcrkwGo203D4Wi9EHNJ/PIxgM0mo38nelRjgcxtraGrRaLWQyGbq7u6FSqSCVSrc8qWSzWaytrSESiWBtbQ2JRKIkxABEIhHa29tRW1u7qYrN6/VibW0N09PTm5p5S5V8Po9wOHxd4ryiogKtra3QarUIhUKbTsqk0ZoUvWyEx+Ohrq6OjsoiyjfxeJy2JBTDAKZSKXi9Xno/SDh7165d0Ol00Ov18Pv9cDqdCIVCiEaj1Ks6ePAgTCYT9XpjsRhWV1extraG9fX1ktC2JQcyHo9Hi6ZcLhf9zDciFAohk8lw9OhRWixCjHswGITf78fk5CSmpqa2XbyeyWTCZDKhtrYW7e3tqKqq2tQWsTFtQoq1iHj7zdZFPEC9Xg+xWEzfTxKJisVisNlsOHfuHJaWlop+/4Crz5XT6YTdbsfy8jL0ej2VRVMqlThw4AAtOBOJRODz+bTqMxwOIxAIYGxsDFarFaOjo1haWrqrGrDbYgRJL9jRo0fR1dUFgUCAVCqF9fV1qv2ZzWbpyyeXy3Hq1ClIJBLweDzY7XaaGM7lcrTggmjMlaIRdLlcmJiYoBvlpz71qU3qMNeuOZlM4s0334TVasVbb70Ft9sNm81WpNV/gEqlwqOPPorm5maaR8vn81haWsLMzAzOnTsHt9td5FXemnw+j7W1NVRUVGx6WcxmM8xmM4APwlDk69lsFolEAiKRaMveqq3yvSQcWqyoRiQSweLiInw+H9Wm5fF4+NSnPoVcLkdbQVZWVjA7O4ulpSXa89nS0kLVZWKxGHw+H9599128//77WFxcLImCNaKEIxaLkU6nMT8/j6WlJWowCKQGoba2Fn/4h3+IqqoqKBQK+nWn04mFhQW88847mJyc3PZ1s1gs9PT0oLOzEydOnLguvL6RXC6HcDh8W5rCWq0W999/P+233mhUM5kMXC4Xrly5gh/84Aclcf+Aqw5COBzGyMgI9Ho97rnnHtq2oVar8bnPfe66n4lGo4jH41hYWMDExAS+853vwOv13hWZtGvZFiNIKgubmprQ0tICDoeD1dVVvPbaa7BardBoNHjkkUdQW1tLv7+xsZEqAmwUuM3n8/B4PIhEIlhaWqLVffF4nIpXe73ekp7NR6qaiJA2cDVf2tPTg4aGBpjNZqytrdFChMXFRUSj0aJ4FtFoFBMTE5BKpdizZw99yaqrqyEQCPCnf/qntGJwenoafX19d9yYXQhI+CSXy8Fms0Gj0UClUtFxT/l8nlYektMyGdMFfFC9SowKk8nc1AeaSqWQTCbhcDiwtLRUtKIg8l6cPXsWTCYTx48fpyNpSH5MJpOByWRCIpGgvr4eGo0GIpGIXlcul8Pa2hr6+vrQ39+P0dHRohVTXEsymaTGgcViQaPRoL6+Hvfff/8mL4fJZKKrqwvV1dXQ6/W0jzUSicDv9+Pdd99Ff39/QQ5wp06dQltbG06ePElHxN2sYI7L5dKDWSKRwOzsLKanp7G6urqphYDFYkGr1eLYsWMwmUzX/c5MJkPHD93tcUMfBi6XC7VaDaPRiM7OThw4cAAdHR303hAYDAaSySRisRjm5+exsrKC5eVlBAIB2Gw2rK+vw+12b1vdwbYZQbFYDLPZjPr6egBXw2nvvvsustkslEolHn74YZw8efKGv+PaGxyNRtHf3081/0jilzRXb5X8LyQkHJHNZukfsiYyXmmjmCyTyURzczNYLBb27NkDu92OoaEh/O53v6MPcTGMYDwex8zMDEwm0ybtP51OB41GA71ej1gsBpfLhTfeeAMTExMAQFsnSoVcLofFxUVkMhnY7XYwmUzIZDKakyFrJUaRwOVyEYvFEI1G6bWTMP1GUqkUDWWvrKwU7dQdj8dht9vR39+PSCSCxsZG6PV6+v6QEUukpP5ayDO7vr6Ovr4+DA8PY3p6utCXcUNSqRQ1gkwmExUVFcjn8zh27NimQy+LxcKxY8foc8pisWgT/MrKCi5evIg333yzIMb96NGjeOSRR2AymSAQCG6p50laQBQKBXQ6Hd59913kcjlEIhFEo1GaP2SxWKioqMDevXtpu9lGMpkMPB4P7ZksllNA3hs+n0/7p5966ik6rWUrabdUKoVAIIDh4WEMDAxgZGQEbrcbq6ur276vF3yKBDEQJNZLSrI39iKRD1Emk1HPiSjCZzIZavRSqRROnDgBp9OJH/3oR1haWoLb7S7KZry+vo6RkRE4HA4IBAIEg0GaY0mn00gmk+BwONQIstlsKrlFmuyPHDkCgUAAk8mE3/72t7BarQWvoA2HwxgYGEAqlUIqlcLu3bvR0NAApVJJvQoi/iuXy3HgwAGMjIxgbm4Or732GhwOR8HWejNILnlhYQH/63/9L+h0OnR0dGwq0roRbreblqnz+Xz86Z/+KUwmE0QiER398s477+D06dMYHBykBQ3FxOFwIBaL4Sc/+QkuXLiAlpYWOirqZtcbDAbR29uL3t5evP766yXXskQqJgOBAMRiMZqammCxWNDR0bFpkyfhUB6PRzVPf/vb32JmZgajo6MFnSVIxlptdXi61c9VVVVReT+ihToyMgK/3w+Xy0XDvFtNZojH4xgZGYHVai24ASRVnaSR/cSJEzAYDNi9ezdUKhV0Oh2VTrs2L5rP5+kh7MyZM7h48SLtdS3E/Sq4ESRGzOfzYW1tDXw+H/l8fpNqB1G0T6VSVGmdlKgTSHhKq9XC6/Xi7bffRjQavSP1j7tJOByGw+GA3W5HLpeDz+dDNBqFzWbbcj1sNhterxdVVVWQSCRobGxEe3s7zGYz8vk8hoeH4fV64ff7C2oE0+k07cPq7++HSCSi45EkEgltYOXxeFSgmBjFS5cuwev1bnvRwZ1cSzAYxMDAAFQqFaLRKNhs9i3HzTidTqyurlKjHwqFaK4mk8kgGo1icXERFy5cwNra2m2pXmw3RNtzdHSUjukyGAyorKwEj8ejcwKJxBS5P4lEAvPz81hYWMDy8nIxL2FLIpEIPB4PHU2lVqshEolQUVFB9wnggw01l8shGo3C5XLh8uXLmJqawvDw8KbCuu2GeG0bJyjcDuQd43A4UKvVUKlUcLvdyOfzcLlcdHYnCWMTyJQdotJSSIUYUv1P9omamhpUVlZi//79MBqN2LVrF5hMJo2MbUzzkEklwNWwN7EJKysrBVs/UAQj6Ha7sbCwAJ/Ph5/+9KeQy+XI5XKYn5+nHw4JUXV0dNB4skqlgtFopKdaqVQKhUIBsVhMGy8nJyfxD//wD0WRYSP9c8AHodGbhQgzmQzGx8cxMzODvr4+mj9QKpU4fvw4xsfHkcvl4HQ6ixIWXVlZgdvtxtmzZyESifCVr3wFTU1NqKurg1gspv1OXC6XCjhbrVbodDqcPXu26J7RtQQCAfT29t7WxkTC2AcOHEBTUxP1MBgMBrxeL3p7ezE8PIylpaWSyYWSUvGhoSGMjY3h7NmztN9Tr9ejra0NDzzwAI4ePUp/Jp1Ow+/3o7e3t6ADgO+EK1euYHJyEiMjI9DpdDh58iQt6iFjklgsFg2xxeNxXLx4EVeuXMHLL7+MeDxe8HoBv98Ph8MBmUx226PFNsLlcsHhcGi9QEdHB7LZLNLpNAQCwXXPL8np2u12uN3uguVzSZqko6MDhw4dwu7du1FVVQWpVAqpVEq9Pr/fj7W1NczMzGBpaQmDg4PI5/P4h3/4B1RWVgK4Ktpw4MABDAwMgMfjFVR2sOBGMJ1OIx6P00nVUqmUVh+Skxo54ZESWQaDAYVCAY/HQ+dvER1AsVhMm2M3zhYrxnXdqbFKJBJIJBIIh8Ow2+1YWFhAU1MTtFot7XG7VehuuyDXEw6HwWKxMD4+jkQigUAgALlcDpPJRMMcPB4PHA4H9fX1SCQSGBoaoqoVpcKHmUepVCppEzmTyaRGY2JiAg6Ho6SuDwBt2QBA75vP50M6nYZOp9t0MMlms1hZWYHVaoXD4Si4vuTtQmZyLi0tIRQKQavVwu12I5PJoKamhkYn8vk8HdUzOzuLhYWFolXtklTNxkNwMpmkubqN+xxpFRCJRPSARvY/YthvJYCdy+XgdruxtrYGj8ez7ZEJ0mtbWVmJ2tpadHV1obW1FQ0NDVTMm/RlkinwMzMzmJ+fh81mw9TUFJhMJpxOJ/h8PmQyGfh8PlQqFZUkJPUehWDbd9iNTaEbCYfDNNQBYJPVJ+799PQ0ZmZmcPbsWfpgsNlsCIVCPPXUU/jqV7+KqqoqiMViWgCwsYpvJzE/P49/+7d/w+///u+jtrYWbW1t4HA4OH36dNE3qGw2ixdffJF66CqVCgcPHsSJEyfw2c9+lobbnnjiCezduxeDg4OwWq2w2+0lERb9sLS3t+Oee+6BUqkEg8GAz+fDyMgI/uVf/qUkejpvBdFvzGQy9B0hxGIx/OhHP8Lk5CTNAZcq+XweDoeDehPEw33mmWfw53/+5/S59Pv9WFpawk9/+lOsrKwUrTqSFBttPBivrKzg7bffRiAQoO8zm83G7t27odVq0dXVRfevO93DMpkMLly4gLGxMfT19d3VKSzXQpSWamtr8d//+39HY2Mj9u7dS71x0j8biUTgcDjwyiuvYHBwEK+99ho9FGSzWchkMrzzzjtoaWnBfffdB7FYDJFIhM7OTtjtdly4cKFgQ5y3xQim02kan15fX4darQaLxaJ9gISt+uc2QgwjeZjZbDbkcjk6OztRV1cHmUxGC2t8Ph+8Xu8mDbqdBBETIOG1YDBIJ9GXAhu93EAggLm5OWi1WgwPD8NsNlPxcFIUUOjxLXcTsVhMlUq0Wi04HA4ymQwt1S5W+8qdQipbVSoVHflEPKZ4PE6b4ktV9WcjZK8gBr2mpoaG5EmPHBmQ7PF4ijqbdGxsDLlcDmNjY7Q/0OPxYGxsDNFolB6gWCwWgsEgZDIZJicnIRAINo190mg0m3p1b2QYyWdDnIftDCMymUwolUoqBm4wGGiqgOzDoVAIvb29WF1dxcDAAKxW63XpkUQigYGBASSTSezZs4c2yQsEAkil0oIOB94WI5hMJhEOhzE7O0vVwknPyIcd8EiUMMxmM77yla+gsbERVVVVAK6W19psNlit1tuaxlyKEN1KsnabzYaZmZmSPKFHIhEa8iQeICl9Jqd0t9tNX4ydRkVFBRoaGtDQ0EB7WUOhEObm5mCz2Uqm8OdWMJlMajBOnDhBJ0QQ5aalpSVayLVTYLPZUKvVuPfee9HW1gaRSEQPkC+99BIGBgbgcDiKekg5ffo0Tp8+fcc/J5PJYDQacfDgQRw+fBiHDh2i++XNPEOixVmI1AmLxUJ1dTUaGhqwZ8+eTQ37+XweNpsNCwsL+N//+3/fVJqO3K+lpSU8+uij0Gq19BCtUqluWbx2N9mWTy2XyyGTyWB1dRUVFRXYs2cP1Go1HnjgATCZTCwtLSEQCNxWSIkoiqvVapw4cQJ1dXVoa2ujmoDxeByhUAijo6MYGxsrGc/pTtFqtTh+/DiMRiNtxr7TQa+FhsfjbRpqSe57OBymSjk7CWLEOzo68Oijj26STotEInjvvfcwNTVVxBXeGTKZDPfddx/27t1LhcRjsRh+8YtfYGRkhM7h2yn3icPhwGQyob29HSdOnIBer0cul8P09DSsVisVdN+Jh2AA1Dvv6+vD6uoqBgcHodPpcOrUKWg0GlRUVFxXFUrEAMgw5+2+di6Xi/3791MdVGIA3W43vF4vXnnlFUxMTMDtdt9SQIK0y21UAdNqtWhsbCxoJGlbjCAJW6yvr8PhcCCbzUKhUODw4cNYW1vD+fPnkUqlbllBSE44VVVVsFgseOqpp6DVaqHX6wF8UA7t8/kwMzOD2dnZHWkESRPw3r176bUlk8mCaTeSZPytwtPXfj9pkyAVcMQIxmKxbc1LbBck2tDQ0ID7778fCoWCfibRaBQDAwM7Ks8pkUhw6NAhtLa2Qi6XU33a119/He+8886O8WgJHA4HRqMRDQ0N2Lt3L5hMJjKZDBYWFnD58mXaJ7xTITM6vV4vJiYmMDAwAI1GA4vFQnU2iREk9y0SicDr9dJioO02gmw2Gx0dHWhpadkUsgwEAlheXsb777+PwcFBRKPRW+5dpIp+475DpO+2mo6xXWyb/5zL5TA+Pk4rpUg+sLu7G1/72tdw5cqVG/YlkdMFifvv3bsXWq0WdXV1NMZOhrieP38ec3NzVF+0UC81i8WCVCpFOp3+UGr0pDKMtET09PTQnhqfz4fFxUXMzs5ueziUyWTi1KlTUKvVmJqaog8zOaURSBWuWCyGUqlEd3c3Ojo6cOzYMapQQrzX2x3oWmqQimSxWExDMtlslqrxr6yslFwz+VaQ4iWj0UjnsAFXVZc8Hg9isdiOyp0zGAxUVVWhurqaChewWCysrq5iZmYGv/nNb3D+/PmCFVJsNyS3Rw7/ZrMZBoNhk9GJRCIIh8O4dOkS5ubmsLy8DJ/Pt+33lAjTX7vnkbqP2tpauN1uzM/P3/betbF5/k57K+8G22YESQM8KdslZcAVFRVob2+nQsVbQT4EIgHV3d1N+06y2Sx8Ph9sNhvGx8cxMDCA6elpBAKBgm68bDYbFRUVSKfTdF2koZoUH2w84ZDqVlKsQBpiycDIhoYGKBQKuN1u+oeIIm8nDAaDqt0T7cFoNLpJto3BYECtVlOVflLN1tDQAL1eD6FQuEkFqFgTFT4qpPSb/AGuns5dLhecTicikUhJDQ6+EUwmk0ZMtFotJBIJstksgsEgnE5nSUyHuF1IRbhOp0NdXR26urpQUVGBXC4Hr9dL5zguLCwUe6l3DdIeodFoYDQaaT/0RuLxOLxeLz0skwED2w353L1eL+LxOG2PEggEUCgU0Ov1qKqqgtfrpSLYxOO7lo0Gj/w3k8nQQQmFYluNoMfjQTwex7e//W10dXXhm9/8Ji2DbWxsvOFGuVH3kChdJBIJDA4OYn5+Hm+88QbtcQqHw5smARQKtVqNP/7jPwaPx0Mmk4HNZoPdbqcSaePj41T7j8zPImXA3d3dqK6uxr333ouKigpotVo6JuaXv/wlXn31VUxMTNCRU9sJg8GA2Wymk+RjsRiGh4fpQFbg6kt5+PBhqNVq+oIKBAJwuVzw+Xyal/31r3+NiYkJTE1N7bhhwsDVfqyGhgZaQAJ8IL8WCAR2zPUIhUJ8+9vfRktLC6qqquiU8V/96ld4+eWXMTs7W+wl3jYajQZarRbf+ta30N7eDqVSiXQ6jfX1dbzzzjv4l3/5l22ZLFBMyOH4mWeeweHDhzc9jwTSOvbqq69iZmamYHMfo9Eovve978FisSCTycBsNqOzsxMcDgdSqRRf//rX8ZnPfAZnz56F1WrFq6++ilAoRHs2N6qCkcPmxjyn1WpFX18fgsFgQa4H2OY+QZIfWlhYgEgkgtVqhcFgoCXoNyqDJWG1RCKBSCRCR42MjIxgYWEB09PT8Hg88Hg8txw9sl2QvKdSqURlZSWkUimUSiXV3ORwOIhEIohEImCz2RCJRJBIJHRen16vR01NDUQiEVKpFPx+P53mvbCwgHA4XDDPlvQzEcNmNpuRSCRozpbJZKKuro4WIxGI90tkrWZnZzE/P49YLLYjw6EikQh1dXVQqVQAPuj3cjqdWFtb2xEFFyTSQNo7iCA4mfC9vLxccmo+W0EOW3q9HhaLBSaTCTqdDplMBsFgkM613O7p8MWARM1UKhXUavWmSknSKuH1ejE3N4f19fWCTvwgjfk8Hg9jY2Ngs9l0EACpbRCJRGhpaYFYLIbT6aS6pxv7JplMJhQKBZqamiAUCsFgMBAOh+HxeOBwOAoacdlWI0jEhpeWlpBOp/Gzn/0MBw8exP33308HKG6F2+2G1WrFwsICXC4XTf6++OKLVCPxdos4totQKITXXnsNR44cwaOPPkpPM0T0NZ1OI5PJIBKJgMPhQCgUQiAQgM/ng8Vi0di6x+PBuXPnMD09jTNnztDerUJdWz6fx+zsLNhsNh24SnKvQqGQft9WB5ZkMolQKIT33nsP/f39+O1vf0sLoXYiVVVV+PznP09bb4jKzFtvvYWRkZGSbFe5Fi6XC4FAAJlMRkfW+Hw+DA8P0/dpJ3i0PB4PUqkUp06dwqlTp9Dc3AyRSAS73Y7x8XH88z//M5aXl3fEPblTyH5B/myERMlmZ2dx+vTpgnmAG0mn01hZWcF3v/tdPPbYY9i7dy8kEgmEQiH17o4fP45cLodnnnkGHo+HRu1I/yZRmCLTTbxeL6anpzE0NIT+/v6CGvaCaHKRUt7p6WlkMhn4fD46z2wrfD4f3G43XC4XQqEQ9QhJTqYUXuJUKgW73Y6xsTG8/vrrtE+HVLTW1tZCKBTSsmYGg4FIJEIHC4fDYSwvL8Pv92NmZoYav43TNAoBmbsXCoWwvLwMqVSK2tpa8Hg8CIVCaLVaKBQKem35fJ4KIQSDQXg8Hly+fJn+jp1oANlsNjQaDRWcJvmX2dlZWK1WehArhefuVhgMBtTU1EAqldJQvdfrxfj4OBVj3gnIZDLU1dWhpqaGSvNlMhksLi5icXERa2trJTPz8G5D5AlJ7o3oo6bTafh8PszPz2NxcbGoud1sNotoNIqZmRm8+OKLMJlMMBgM0Gq1VAqOzOuUSqWoqqpCIpGgHh7JeTIYDKyurmJhYQEDAwOYmZmhIvyFomDClETAuLe3t1D/5LaSTCap8ZqengaPxwOPx4NIJIJMJsPnP/95mEwmVFVV0QfGarViamoKvb29WF5exuXLl4uqbAFcPaBcvHiR/n8ejwedTgcOhwM+n4/Dhw+jvb19U+ze7XbTajy73Q6/31+UE+ndgsfjobW1FS0tLTAajVSL8vz58zh79iyWl5d3xPUxGAy0tbWhvb2dajjGYjHYbDa8/fbbdDzUTkCr1WL//v1oaWmByWQCk8lEIBDA5cuXMTExgZWVlR1RpPRhIBNpbDYbbDYbhEIheDweHbj705/+FCMjIwUVmb4Wchju7+/H2NgYDh8+jD179uDIkSM05UUMoEgkglQq3fTzxKP1+XwYHR1Fb28vXnzxRbjd7oLmA4EiCGh/3EgkEnA6nVQ7j2iYJpNJSKVSOgQ0nU7D4/HQcSGFqua6U4jnQK7nwoULmJ6e3jQHjAigx2IxhMPhkryOOyGTycDhcFAdW0I4HC4p6bqbQcZbtbW1Ye/eveDxeHC73XjllVdw+fJlOJ3Ooh+4bgcWiwWRSISmpiY89NBDqKmpAYPBoIVn58+fx/Ly8o5VhrodkskkAoEAfve732F+fh4HDhwAl8uF1WrF0tISLl26BI/Hs6nJvFjkcjkkEglMTU3B5/NhfHwcEomEzoKtqKigw4LJ1PuNEKETMgGjGPnqshH8iKRSqS2r0+bn54uwmo8OaXUgfNwq77aCtIb4/X5kMhlq8KPRKAKBwI7YbEkFck1NDerr6wFc9djfeOMNLC4u7pj7yGKxIBaLYTQaceDAASoF5nA4MDc3RyeO78QWnNuFFJD09fVhcnIS8XgcXC4XQ0NDcLvdWFpaKvYSKUQUe2lpia6LFL0IhULodDoYDAa0tLRQ2cGNRKNRLCwsfKgpPHeLshEs84knl8shEAhgfHwc3//+97Fnzx4cOHCg2Mu6I5LJJDKZDP7pn/4JP/3pT8HlcunA3J1QDUpgs9mQyWRUNIJMXfje976HyclJKpL/SSAWiyGZTOLNN98Ek8lEKBTaEdeey+UQCoUQjUapRu3w8PCWSlJkGHAxPdqyESzziYdotXo8HgwODkIqlaKmpgbhcLioeZc7gZzIJycni72UjwwpIrPZbHC73XQCw8zMzI4wAncLMtzZ4XAUeyl3DPHsEolEyRcwMW5mgRkMxs4oJStT5i5AQooCgQBCoZCKvO8kibGdDulzJGOFSC9qIBD4WLZDlCkM+Xz+hlpsZSNYpkyZMmU+1tzMCDJv9IUyZcqUKVPm407ZCJYpU6ZMmU8sZSNYpkyZMmU+sZSNYJkyZcqU+cRSNoJlypQpU+YTS9kIlilTpkyZTyxlI1imTJkyZT6xlI1gmTJlypT5xFI2gmXKlClT5hNL2QiWKVOmTJlPLGUjWKZMmTJlPrGUjWCZMmXKlPnEUh6ltA0wGAxIJBLI5XLs27cPlZWVaGhowOrqKlZXVzE4OAin04lgMLgjppaX2VmQ549Mm1er1WhoaIBUKoVYLIbX60U8HqdDg4eGhnbMyKhPEp2dnaiursaBAwcglUo3fW1lZQU2mw0XLlzAyspKkVb48aDoRpDD4YDBYIDBYCCfz9M/ADb976241deLAZPJBJvNhlwuR1VVFU6cOIHm5mYcO3YMo6OjGB8fRyQSQTabRTKZRDKZ/ETNSCtlrn0OWSwWmEwm/Xvgg2eOzO8rpeePwWCAxWKBxWJBoVCAz+dDLBbDYrHg6NGj0Ol0qKiowPLyMgKBAHw+H+x2O2ZmZugA1zLFg8FggMlkgslkgsVioampCV1dXXj22WdRWVlJvy+fz2NoaAiDg4OYnZ3dcUaQvE9s9lXzQ96nbDZblPUUzQgKhUJIJBL8xV/8Berr68FisRAMBjE7O4tUKoVUKoXl5WV4vd4tfz6RSCAWi2F5eRl+v7/Aq78xHR0dMJlMePbZZ2EwGFBZWQmhUIh8Po/a2lqo1Wq0tbUhEAjg4sWLsFqteOmllxCNRnfUBPCPEywWi3pJGo0Gbrcba2tr+NSnPoWuri60tbVBLBbTYa+rq6sYGBjAxYsX4XA4SmJoqFwuh1wux4MPPgiLxQKLxQKRSASxWAyhUAi5XA4ejwcOhwOLxYJMJoN0Oo319XVoNBoMDw/jt7/9bUkeLD8pGI1GnDhxAm1tbWhvb4dGo4FUKoVCobjunlRWVqKrqwtyubw4i/2QMBgMWCwWVFVV4Wtf+xoEAgEcDgcuXLiA559/vihrKpoRlEqlqKysxN69e9He3g4WiwW/3w+ZTEY9JKlUCpfLteXPh0IhBAIBeDyekjGCDAYDVVVVaGlpwZ49e6BWqxGNRpHL5eB2u8FiscDn81FfX49cLodkMgmJRIKBgQG68ZY3ocJC7onRaKTeu0QiAYvFQltbG3p6etDZ2QmxWIxcLodoNAqDwYBEIoH19XXEYjEkEomiDd4lA2grKyuh0+nQ1dWF1tZWWCwW8Hg8MJlX0/4b1yYSicBgMCAUCiGVStHV1QW/3w8mk1m00/iHgcVigc1mg8PhgM1mg8fjUU84n8/TgbyZTAaJRAKpVArZbLbk3i8mkwmxWAydTofOzk709PRgz549NAqRSqUQiUQQjUbpNYVCISQSiR11v8i9MhqNaGhowIEDByAQCDA3N4fl5eXirasY/yiDwcADDzyAY8eOwWw2QywWAwB4PB6USiU1BOl0+oY3eWVlBQsLC/D7/bDb7YVc/g1hMBh49NFH8dBDD0Eul8PtduOll16Cx+PB2toaPa0fPXoU1dXV9ADQ1NSEc+fO4Xvf+17ZIywgDAYDWq0WZrMZf/d3fwe1Wg2JRIJwOIxQKISKigrweDzMzMwgGAwiEAhAoVCgubkZDz30EO677z783//7f3HhwgXMz88X5b7V1tbivvvuw/79+9HT04OKigoIhUIwmUz4/X6cOXPmupA7l8uFSCTC/fffD7lcjgceeACBQAAcDgcAdkyeWqVSwWg0orW1FTU1Ndi7dy/UajXUajWSySQcDgdcLhfsdjvee+89TE5OwuFwlFzYV6FQ4JlnnkFXVxc+9alPQSAQ0FBhJpPB4OAglpaW8NJLL8Hn88HpdCKbzSKXy8HpdBZ59bdPdXU1jEYjvv3tb6O9vR1sNhs+nw9WqxVut7to6yq4ESSnN71eD4vFAqFQSPMtLBYLPB6Pxow3Jurz+Tw90Xk8Hng8HjidzpIxGEKhEGKxGCqVCkqlEkwmk544M5kMQqEQ0uk0otEoJiYm4Pf7sXv3bnC5XNTU1GB9fR1dXV1YXFyE3W4vmmcBgHoP5B6U2sn5bsBiscDlctHY2IimpiYYDAbIZDLqWZHDWCqVwuTkJNbW1hAKhaBUKpFKpaDRaKDValFTUwOfz4fV1VUkEomCfVYCgQA1NTVobm5GZ2cn6uvrodfrEQqF4Pf74XA44Ha7MTg4iFQqtcmw8Xg8SKVS9PT0gM1mU49QoVCUfLEWj8cDn8+HRqNBTU0NGhsb6bVbLBYolUooFAqkUinw+XzIZDJIpVJ4PB4wGAwEg8GSMoLkXtTX16OmpgYymYy+f3a7HR6PB4ODg7DZbJibm6PRL/KcpVKpYi7/ljAYDAgEAsjlcjQ1NdF3TSKRYGhoCOvr65iYmIDD4bjh72CxWBAIBBCLxVAoFHC73QgEAnfNqy+4EeTz+ZBKpWhtbcX+/fvpDQeAbDaLVCoFFosFDodDwxfka6FQCFarFadPn8bs7CwmJiawvr5e6EvYkurqajQ1NUGr1YLD4SCbzYLP56O1tRVisRh+vx9+vx9ra2vo6+sDi8XCX/7lX8JsNsNisUAqlcJkMuHnP/85fv3rXyMQCBTlZWUymeByuTRBn06nP5aVg0KhEAqFAv/tv/03tLa2gs/nIx6Pw+v1UoOwtraGtbU1fP/738fk5CSAq8+vUqnE/fffj4ceegh79+7F7t27MTk5iWg0WpB7xmKxoNfr8ed//udoaGjAvn376KHrtddew/DwMH72s5/B4/Fsed+4XC5UKhV27dqFhoYG1NfXQ6FQoKurC1NTU7Bardt+DR8GFouFiooKmM1mPPXUU2htbaXXTv4AV/cKFotFQ8TkkGC327G8vAyfz1fkK7kKk8mEWq1GbW0t7rnnHmi12k3h6xdffBFnz55Ff38/Nd47KV1CCrVMJhOOHj2KBx98EAcPHgSLxYLX68Xf/u3fYmFhAaurqzc9ePH5fJjNZnR1deHkyZN48cUX8f777yMSidyVA1vBjSCXy4VUKqXxewBIJpOwWq1wuVwYHx+nRTNerxfRaBTA1YciHo/D4/FgdHQULpcLfr+/ZE5CMpkMRqORerZMJhN8Ph8GgwECgQB8Ph/RaBSxWAxra2tIJBKwWq2IxWKQy+VgMBgwGAzYvXs34vE4zp8/XzDvgsvlgsfjoampCTKZDFVVVeDxeBAIBFhcXITD4cDi4iLC4fDHppKVx+NBLBajoqICfD4f586dQzweRyqVgkAggFAohM1mg9PphNvtpi9bIpFAIBCgOVytVguZTIba2lp6T7c7T0NO1/X19TAYV2BYRgAAlFhJREFUDGCz2YjFYohGoxgfH8eVK1cQDAZv+G4wGAxaGEPWyufzUVFRAYFAsK1r/7AQL+Cxxx6DyWRCR0cH9Ho9uFwufD4fIpEI0uk0kskkFhcXwWKxoFKpIBaLIZfLkc1mIRAINh26iw2bzcb+/fvR2toKhUJBP/toNIpQKITl5WVYrVaEw2Ekk8kddxAVi8Xo6upCS0sLjh8/jrq6OvD5fLzzzjuYmZmBzWa76R7O4XBQX18PnU6HAwcO0PtI7vPd+jwKbgQFAgHdeICrxi2RSKC/vx9DQ0P48Y9/DKVSCZ1Oh/n5+aLGiu+EiooKNDU1QSqVbipztlgsyOfz2Lt3L4Cr1+twOLC+vo4f/vCHmJmZQW1tLTQaDaqrq3HfffehpaUFXq8XoVBokze8XZDw38MPPwyz2Uz7kpRKJd544w309vbiN7/5DdLpNDKZzI45id4MgUAAmUwGjUYDDoeDF154AcFgcNO1zc/Pw+PxIBaL0b8joW2n0wmr1Yr9+/ejpqYGHR0dAACbzVYQIygUCtHZ2QmJRAIACIfDcDqduHDhAt5///2b/vzGknSyVoFAAJ1OB5FItK1r/zAwGAwolUrU1dXh29/+NvR6Pd0/AMDhcMBmsyESicDv9+P06dPg8Xjo7OyEwWBAXV0drY4lqZdSgMPh4PHHH0dnZyc0Gg3NA/r9fiwtLWFmZgYzMzNFTY18FJRKJb2+EydOALj6/jz//PM4c+YMvF7vTd8VHo+HI0eOoLW1FU8++SRWVlYwNDSEWCx2V9NgBTeC5NQsFouRz+cRjUbhdDrx2muvYWFhAYlEgjbzhsPhQi/vtmGxWJBIJKisrERnZyeOHDmCQ4cOQaVS0e8hL9y1L55MJgOXy8WTTz6JVCqFRCIBu90Oh8MBpVKJmpoaHD58GBKJBGfOnEEwGNy0Ed9NGAwGGhsbUVdXh2PHjkGn00GlUoHL5QIAWltboVKpUFVVhbW1NVy6dAlerxcrKytIpVJIJpPX5Zx2KuFweFOR1cYQ1I3Y2ENYKLLZLNxuN37+859DqVRCLpdjZWUFdrsda2trt/x5o9EIo9EIs9kMg8FAeyNLsXKSXN+nPvUpNDU10Zys1WqlEYrh4WEsLy/T59Fms4HFYsFut0OtVsNgMEAkEoHFYpXMoVoikdBrk0gkm56hhYUFvPPOOzRMWGr35FZwOBy0trbS/uiKigokEglcuHABg4ODmJycRDgcvmGonsfj4bHHHkN9fT3dB71eLwYHB/H8889jYWHhrq634EZQLBajqqoKIpEI+XweyWQSfr8fly9fhtPppD2CpWwAgatGUCaTwWQy4dixY9i9ezdaWloAXN2kNhpAUtRDTuBcLhdcLhcHDhxAOBzG2NgYwuEw/H4/enp6YLFY0NraCiaTiZGREaRSKcTj8W15GZhMJoxGI5qbm9HW1gaFQrHp69XV1aiurkZVVRXcbjey2Sw1gLFYjJZuk3LtfD5Pr53JZNKmcvJZbEUxX3JixFgsFlKp1IeqNN5Yjl8IcrkcgsEg3n33XVRUVMBgMGBpaYmGlzay8TMnEQq9Xo+6ujro9Xp6aCtFI8hgMKBQKGAwGHD48GG0trZCKBQiGAxicXER4+PjuHTpEjWC17K0tISKigqsrq6Cz+eDxWIhEonQ57KYiEQiKBQKSCSSTcWBAOByuTA6OopgMFhSnuvtwmaz6R7W2tqKfD6PSCSCwcFB/OY3v4HNZruhJ8fj8SCTyXDPPfdgz549MJvNiMfjGB8fx9zcHM6dO3f313vXf+MNIP1YHR0d+OxnP4uqqioAoPHdeDyObDZLq6OuLZjJZDKIRqMl8ZIyGAxIpVLce++96OrqwiOPPAKpVAoGg4GlpSUEg0Gw2WxawTc9PY2XXnoJNpsNq6ur6OnpgdFoxKlTpxAKhfDrX/8aHo8HLpcLPB4P7e3t2Lt3L8xmM1ZWVjA9PY133333rntbPB4PQqEQR48exb59+2hT/8biDg6HQ/MrUqkUX/7yl5FMJhGJRBAIBOByueBwOODxeHDhwgV4vV5IJBJIJBJ67X19ffSF53A41+VlSI6tGOTzeYhEItxzzz20Yu1OnrF4PI5AIIDLly9jfHy8YB5xKBTC2bNnaX9cIpGg94XA4/Gg1+vp+2Q2m1FTU4MHH3wQZrMZSqWSfm8gEKAndJFIVPQeNIVCAb1ejwceeAB79uzBrl27IJVKMTExgYmJCfzgBz+Az+eDx+OhdQMbEYlEqKqqwsmTJ/F7v/d74HA4yOVy+MlPfoKZmRlcunSpqPUEnZ2d6OzsRFVVFWQy2SZjV1VVRaNKa2tr6O3tLXmngCAQCKBSqWhqJRgMYnx8HKdPn0Z/fz+mpqa2vF+Eo0eP4vDhw9i3bx+0Wi1GRkZgtVrx4osv3nUPkFAwI8hkMukHVFNTsykBz2azoVQqweVyoVAoaMMrgRjK1dVVGj4sFgwGg7ZCNDQ00BN1MplEKBSCzWaDy+UCi8WCWCwGn8+Hw+GA1WrF+Pg4pqenAVzddBoaGhCJRGjuye12w+Fw0ApFHo+H6upqBAKBu5rQJ56PXC6HSqVCdXU1DAYD9YY8Hg/tQ5JIJBCJRNR7JY3W5BpcLhdWV1fhcrng9Xrhcrkgk8kgk8lQV1eHdDqNxcVF6HQ6KBSKTQ3chOXl5YIbwY3eG6lgW1lZoZ77reBwOBAKhUin0wiFQvB4PPD5fAXzMDKZzJafmUAgoIVYIpEIZrMZbDYbTCYTTU1NsFgsaGtrQ3V1Nc1BAaCtEhUVFbSVIJFIIBQKFcVrkkgktKm6ubkZMpkM+Xwei4uLmJmZwcTEBG2A3woOhwOVSoXa2lrs2rULbDYbmUwGdXV1CIfDm/aXYqDVamlaiPRnEuRyOUwmE3K5HGQyGX0/QqFQyXnr1yKRSFBRUYGamhpotVpEIhHY7XYMDQ3BZrPdUF2JFKqZzWZ0dHRAKpUil8vR+z05ObltVb0FM4ICgQC1tbWorKykElTA1Rve2NiIv//7vwePx4PRaASHw6E5KVI4s76+jn/7t3/D/Pw8zp8/X7QHgcvl4qGHHkJbWxu++MUv0sKEoaEh9PX14ZVXXsHs7CxyuRzEYjF6enqgUqnQ2NiIlZUVxONxnD17Fr29vfiv//ov5PN5+nDncjm88cYb8Pv9+OIXv4i6ujq0tbUhm82Cy+Uik8nclQ2JVEU+8sgjOHr0KG2yzmQysFqt+OEPfwi/3w+fz4dDhw6ho6MDXV1d9KBCIFJjRqMR2WwW9957L7LZLA03pVIpHDx4EKdOnUJtbS20Wi0EAsF1G9Bzzz2Hv/zLv/zI13UnEPHoQCCATCaDAwcOIBAI3DL8tLHs+/Dhw/D5fFhcXEQgECiqZ0HWdejQIZjNZhw6dAharRaNjY3U++ZwOOBwOODz+ZsMIABapUgOM1NTU1hZWcEPf/hDeL3egr9vLS0t+IM/+ANqsN1uN2w2G/7u7/4OdrsdkUjkpu+CSCRCY2MjDAbDpopti8WCeDwODodT1B7jtrY2HDt2jO4fG7FYLKipqUEsFkMsFsOxY8cwPz+P7373uwgEAiUh07cVTCYTx48fR0dHB5qbm8FgMHDx4kUMDg7i0qVLN4ySMJlMdHd348knn8Thw4fR1taGsbExWK1W/P3f/z0cDgftC9wOCmoEq6qqoFAoNvXCkEbIuro6cLlcVFZWUnkd8j3JZBI8Hg8tLS3IZDLo7+9HJpMpSriGyWRCo9GgsrISMpmMVql5PB7MzMxgdXWV5s7C4TBtcM3lcggEAtSoJxKJLUMcLpcLs7Oz8Hq90Ol0NLFvMBjg8XhuqKV6J4hEIlRXV6O2thZ1dXX0RbTZbJifn8fMzAwCgQCCwSCkUimSySSy2SyUSiVtVlar1VQggGyoGysLM5kMzWMymUzodDr689cawa02gu0mnU4jFovB5XLB4/Ggrq4OMpkMer0ewWDwhhuNQCCARqOBXq+HVquF2+2muexiIpVKIZfL0draiqamJjQ2NtIqaxaLtUkAPJvNUtGJXC4HgUCwKQpDitbIFBS73Y75+XmkUqltb5Fhs9mQyWSorKxETU0N5HI52Gw2VldXsbCwAKfTCb/ff8vDIJPJpBEM4t2Td/B2fn67ID3Q5N3ZKsLD5XKpIyAUCmE2m8HhcNDT00MPp263Gx6P564djO8WSqUSlZWV4PF4iEajWFhYuKlKDwnZWywWtLS0QKVSgcFgYHl5GVNTU3A6nQgEAtv63BXECDKZTFRUVODEiROor6/fvAA2G2w2m/79VidxMg7mySefhFarxdtvv41wOPz/tffewZFd55n30znniAa6ERo5Y3IiZ0hOZCYtybJIWbK0qnWtVSut17Whap0/r+zylu1dy7tSWSvLlm2JIlfM1DBOxORBzmg0gI7onHP6/pg6R8AMZjgBaPSI/aua4nCA7r63773nPW963jX5j3JBCkmMRuOaG9hiseCDDz6gBhC4kS8aGRlZVwHndhDR8BMnTtC2C4VCgaeeegqjo6P4+OOPH/gcDAYDDh8+jD179qC3txcMBgOxWAyvv/46JiYmcOrUKXrTzc/Pg8lk0lE8XC4XRqMRL7zwAsxmM3p6etb9DLKYktxMpSX4SV/ZxYsXkUwmUVdXB61Wi+PHj2N4eBjXrl1b93V6vR5PP/00Dhw4gI6ODpw/fx4TExNbrlzU2tqK7du34zd/8zfR09OzRvWHQNoiiCzcu+++i2w2i/r6ehgMBnR0dIDP50MikaCurg6FQgE7d+7E+Pg4fv/3fx8+n++2Wr4bBVGy2b59Oz2PfD6Pjz76CENDQ3fdG8xmsyGVSukmlRj+wcFBXL9+fctUY4RCIWQy2RoDfTvI2ki0YFtaWmh7zjvvvIN33nkHoVBoS9NDq2EwGDAYDGhsbASHw0EwGMQbb7xxx2IztVqNX/u1X8OePXtw5MgRxONx+P1+vPvuu7hy5QqCweDmb7w29d1x44shu8yenh7U1NSs+XkqlUI6naYVQ/F4HKlUCqlUCg0NDdBoNDAYDOBwOJDJZKitrcXOnTsxNzdH82vlgsStdTodtFotmEwmUqkUgsEggsEgEonELS7/vSo8EA8lEAjA5/PBaDRCLBZjYGAA8XgcZ8+epaHT+2X1yBYGg0EXCNIYvjrvQPJmPp+P5lJisRg1hlNTU1AoFHRaAYvFQjqdhlAoRH19Pd3VrvewJ5NJrKyswO/33/e5PAiFQgHT09NgsVh4/vnnoVAosGfPHoTDYYyNja3ZZZNJEyaTCbt27YJEIsHi4iJmZ2cxMzOz5VJcPp8P09PTmJubg0AgoP2qAOj9FAwGEQ6H4XK5aMFCoVDAxMQE5HI5VVjRaDTo6OigWrdarRa1tbXI5/ObbgT5fD7q6+uhUqno/Ul6a5eXlz+18IjNZsNoNKKzsxPbt2+H0WgEAJrfJB7UVhX9yGQy1NfX0+b41RtpcozAL4vvSG8jyXGKRCKIRCLs3r0bxWIR58+fh81mK6tk33qQMHtNTQ3q6upoIVIsFlvXSJM2CrPZjH379sFkMiGdTuP69esYHx/H/Pw8gsFgWa5TWYwgj8eDVqvF3r1714Q5Sems3+/HqVOn4Pf7YbfbEQgE4PF48PTTT2NgYAByuRwKhQIKhQJNTU04duwYGAxG2Y0gabA2mUyora0Fk8lEPB6nYZqNkPEhKh5utxsOhwO9vb2QSCR45JFHEAwGwePxNlw9IpfLIZVKwWazweVyrfswrV78FhcXMTQ0RPsHOzo6YDKZoNfrqYKHTqejPVCr84ir3zsej2N8fBxOp3PDzuVeKBQKuHbtGvUKdTodjh8/Drvdjvfffx+pVIp+z2w2G3q9Hu3t7Th69CjsdjtGR0dx7do1DA0Nbcnxr4Zcu4GBAeRyOboBAQC3242JiQnMzs5icXER09PTt528MjAwgO7ubrz88stob2+HXq+nIuPJZBKzs7Obeh5CoRBtbW3Q6/VrQrhLS0uwWCyf6hWQ6uodO3bg8OHD4PF4AG7kgIPBIFwu15aKTqtUKiqvSAYHAL9UxLLZbDS/y2az6TUkFdqlUgm1tbWQSqXo6OigGxsiZLFVEJ3WxsZGGtUjUpfrRUl4PB7NHz755JPI5XIIh8P44IMP8Nprr1FVrXKw6UaQ5MDcbjdOnz6NxsZGNDc305DMP/3TP2FhYQEzMzPUE0yn00ilUvjkk0+wsLAAs9lMK94kEgl6enowOTm5ocUid0NnZyfa2troDcxgMODxePDBBx9gfn5+w5QdSqUS5ubmwOFw8Pjjj1PJKDLi50FDi3q9HocOHUJNTQ0ymQyGh4exsLCA+fl5uN3uu/4+SeVXPB7H9PQ0Vb9nMBhob2/H/v37bzGA4XAYyWSS5pleeeUVWK3WBzqf+4WINQSDQYyNjaGuro4KactkMpp3NplMMBgMeO6551BfX49IJIKhoSG8//77FTPQtFgs0rDhyMgIxGIxzb0mk0kEg0FEIhHEYrE7lqgT5RUiy/bVr34VUqkUhw4dAgBcu3btjtNdHpRwOIyzZ89CIBBgz549YLPZYLFYeO6559Da2oqLFy/C5/NhaWmJPmt6vR5KpRJmsxl6vR4nTpyg0n/kO3C73Zibm9vysPV6ZLNZOJ1OTExM4Kc//SmN1DQ0NECtVqO/vx9qtRqtra00/05ype3t7QgGg7h27dqWGkESas9kMkin03TzsR5msxlGoxFHjx5FfX09AGB6ehq/+MUvcOXKFfj9/rLKM5bFCOZyOYRCIYyOjoLNZqOhoQGRSAQejwcff/wxxsfH1y0vHx8fh9vtht/vR21tLdWzNJlMUKvV4HK5a5qxNxMGg0HHthAJpmKxiGAwiOHhYbhcrg1bGEqlEm3wzWQyYDAYEIlE4PP5NET0IBBFdxaLhUwmA4vFQpXcw+HwXb8Pmfu4uliHyWRCpVJBKBQik8mseTBLpRJisRiCwSCmp6cxPj5OR/1sFUSYYXFxETweD83NzRCLxZDJZHQWZF1dHZqbm3Hw4EHw+XyEw2HMz8/j4sWLFSPGDNxYiCYmJh7oPUjYlM/nw+fz4Qtf+AKUSiW6urpgtVrpfb9ZRjCRSGBqagodHR1IpVIQCATgcDjYtWsXDAYDQqEQBAIBPB4Pfe51Oh2MRiN2796N+vp6HDx4kBZskXBqMBiEw+HY8rD1euRyOaysrGBqagrvvfcegBvPUX19PU27NDU1oampiT7/IpEIAoEABoMBtbW1GB0d3dJzIPcEUe0hET8Wi7Um5MtisVBXV4fW1lb09vZCrVbTAeofffQRFhYWyt4TWZbCmGKxCIfDgR/96EcYHx+nag/Ly8uYnJyk1ZM3Q8qgr1y5gkwmg4MHD4LL5UKr1aKtrQ379+/H+Pj4HcdwbAQcDgc8Hg979+7FkSNHIJVKkU6nsbCwgPHxcYyMjGz4hXM4HMjn81QM+OZc6oOQSCTgcrmo4surr76K0dHRDSk0EovF+I3f+A309PRQwVxCqVTC4uIi5ufn8f3vfx8ejwfpdHpLq9uKxSLi8TjOnz+PbDaLPXv2oKOjA1/84hdpWfbhw4chl8sRj8cxPDyMN998E0tLS2uEtcsNKTwi+dyN3AySfjxSxUzGfdXW1tIp55tVDZvJZOBwODAyMoJ3330X/f39aGxsRGNjI4xGI5qbm5FMJtfkkaVSKYRCIeRyOY0W3Vx1OT8/j8HBwYpsOk8kEhgcHMTY2BiSySRVXbJYLLDZbHC73WhqaoJaraY5t0qDpGisVitqa2vR1dUFiUSC/fv3Y2ZmBleuXIFSqYRSqcRLL72E7du3QyqVwmaz4Yc//CEmJiYwOjq6JUU+ZWuRSCaTWFpaoqru4+PjsNvtiEajt11IyM6CzA8sFou0kV4qlUKj0dzR7d4oSI+VSqWiRTqpVIpOt9+MEt5kMoloNEqH7G5k0jsWi8FqtSIej1MvaCPycnw+H3K5HB0dHTCbzVSvEQANcTudTiwtLWFhYQGRSOSBP3MjyOVysNvtMJlMSKVSkEqlaGtrowtSe3s72Gw2Ll26BJvNhrGxMcRisbK3RZAwmVAopEUI8XgcLpdrw+8/MsmASADy+XzweLx1FX82kmKxiFQqBa/Xi6mpKSiVSojFYmi12jUTIW5XCEImZJCcWj6fRz6fRyAQgMvl2vJWFrKmkTQOqRonz/nqojSikkW811AoBKlUupWHf1tIOJ7MOySj5BobGxEKhcBisaBQKGhUpbGxkd67w8PDWFpa2rL+x7IZwWKxiHQ6jdHRUUxPT9O8wqftpEkoIxAIrNnpcjgciESiW5p+NwOy+AgEAqqYsrrf79NElu8Hooxz81TwjeDChQuYmppa0zv1oDCZTOzatQttbW04duwYNBrNmn7Q8fFxzMzM4J//+Z9hsVjumJcqN8lkEoODgygWi3jssceoXBf5fiKRCOx2O1555RUsLS2tCcWVE6FQCJFIRMfSPPfccxgcHMRf/MVf0KrqzYDkepLJJO0Z3WzGx8dhsVgwOjqKnp4evPTSSzR/BKwtsJqamoLD4UAikQCLxUJnZycVovf7/XTjMjExseXtBIFAALOzs/B6vYjH4zSs2d/ff9tIDKmVCIfDUKvVZT7iu6dUKsFisUAkEmHnzp1QqVT4/Oc/D7FYjMuXL+PIkSN44okn0NbWBgaDgX/+53/GxMQEBgcHt/S6lFVAm4RR7mU3RqpIbzYyZEp7OcJRqwWhV++CN3PApUQigUKhoKEe8nkbQTqdhs/nW9MG8SCw2Wzw+Xx0dHSgt7eXiggwGAwqebe8vExD16FQaEt1KdeDNJGTHKxQKKS79snJSRqaWt0HWm7UajW0Wi16e3thNBppjngzhh7L5XJoNBqw2WwUCgWqVJJKpcryzJFhzmQixPnz52+rHWm1WuHxeJBMJiEUCtHQ0EA9JiLakEqlKmImH5PJpMU+q0X2uVzubTf0ZDNWLBYrWjKtVCrB4XBAJBIhEAhArVZDpVKhpaUFhw4dQl9fHxoaGqhGcSgUQjweh1AoXFNAdzMcDgcSiQTpdBrxeBzJZHJDPfqyT5G4V0i58M0qI5FIBIuLi1vSMF+OG9FsNsNsNqO1tRW1tbX0Qdio6tONXMgkEglUKhVeeukl7NmzZ821isVicLvd+Oijj/DOO+8gEAhseUjqZphMJq2+XT0aKZvNIhQK4W/+5m8wNja2pQaQwWCgv78f/f39+OpXvwoul4vz589jeXn5ljmIG/FZRHlGJBIhm83CYrFsicbr1NQUpqencfLkyTtOISHnbzAY8Pjjj9PfzefzdNGshI2XWCyGXq+HRCKhG8VfFUqlEs6fP4/p6WkcPnwY7e3t6OzsxFNPPYXjx4+v6U0Oh8M0P9vX13fH+1cmk6Gvrw8OhwMTExNYXFy8q5Fhd0vZjCCbzYZYLKYTI+4GHo8HiUSCtrY2tLW1gc1mUw+Q9BKWw40mDxmZxr2ZIVhi9Nva2tDX1wcul4tQKITLly9jeHi4bOGou4FIQA0MDKC3txdarZYawFwuRxuyyYMRi8Uq5tgJQqEQCoUCJ06coP2OMpkMwC/HLK1u2t4KSL8YGU8jEAgQDofx4YcfYnJyckOOi3godXV10Ov1OHLkCFpbWyESiWg/51a0g5Bn7248OCIdt3pDEwqFMDs7WzH551AoRPuKg8EglEol2Gw2NBoNtFottFotHU/2MEL6Hc+fPw+v10uFUrRa7Zrf4/F4OHjwIKLR6G0rdolkJslJEzGPjQ77l80IkqrOUCh01ychEomgVCrpIsvhcOjQ3ZWVFTgcjrL0k6w2gtlsdlMV6MliNDAwgAMHDoDH48HpdOJf//VfK67Pic1mQyQS4eDBg3juuedQU1NDF+RMJgO3243BwUF873vf29TBwPcLg8GgI5++9rWv0T5B4JfePpPJpBM0tgoulwuJRIKuri7s2rULPB4PPp8PP/3pTzdscScavuQzPve5z6GpqQlsNhtutxuXLl2CxWLZkM/aDMj0edLcL5fLAdwQeRgaGtoQzd2NwOv1wuv10twyGS9mMBjo3E6Xy/XQGkHgRrrlvffew8zMDDQaDZqbm6HRaAD8MrUkEAjw4osv3rKBW+0ZkzB8KBTC1NQUxsfH4XA4NjySVDbFmI6ODvzO7/wOBgcH8fbbbyMajX6qF8fn8yGVSum0ApL/CIfDSCQSm5ILWQ8SUhkeHoZYLMb+/fvB4/FQW1sLk8mEhoYGhEKhByowIXm1Xbt2YWBgAPv374fRaMT4+DhmZ2cr6kEm9Pf34/nnn8f+/ftpHydw4+Z1uVx45ZVXMDw8vOkCuPdDXV0dNBoNjh8/jvr6erBYLMzNzeHNN9+kAtlNTU0QCARUPszpdG5JTomMsFIoFNRzIBXS2Wz2gRZMsViM7u5uNDQ0YPv27WhpaUF9fT30ej2KxSKmp6cxNTWFhYWFipnKvh5kXmJHRweV78vn8/B4PBgbG6uofk7gxtQZNptN87wymQy9vb345je/iTNnzuCTTz6B3+9HMpmkBXlktmelUywWac0BUV4aGBigEozketyuurdUKsHr9SIWi8FisSASicDhcNDq3o1+BsumHWowGPD0008jnU7j/PnzVFngTggEAjp5mfSb5fN56lWUK7RGLt7i4iKUSiW2bdsGoVAIpVIJrVZLxYbv1wgymUzweDxIpVJ0d3fj6NGjMJvNEAqFVJ9yeXm5Yhp9iZZhU1MTnnrqKTohArjxAGQyGfj9fly8ePGOU6S3CgaDAa1WC7PZTJVzYrEY7HY7PvzwQzpzj+RuRCLRLdO/ywmLxaITBYRCIYrFIp22kEqlaCvH3bA6vEtmSnZ0dKC/v5+KtpM2hFQqhaWlJVp4UqkjfIAb50V66IgwdSaTQTgcht1urzjPanFxERwOB88++yydyEJ0giORCNWjLRQKkEqlVH6wHNXwDwoRxSiVSpienobZbAZwI8eeSqUwOzsLu91+RyNotVoRCAQwOjpKBTY2i7J8owwGg4bOWltbcezYMXz44Ye3DeWQHMjjjz+O/fv3U1cauCEU/P7772Nubq4ch76G69evw+v14oknnqA6ort378Yf/dEf4ac//SleffVV6qHeLUKhEB0dHWhtbcXBgwfR09ODtrY22iT7L//yL1haWqooT8poNOJLX/oSdu7cicbGRnC5XNrgm0wm8dZbb2F0dJQ2/1YSZFf9uc99DocPH0ZtbS1CoRC+973vYWlpCVNTUygWizAajRVTwJPNZhGPx2mrkFwuh9FoxB/+4R/i4sWL+Md//Me7apEgcnBEE3Tfvn3QarVobm6mfbccDoe2tCwuLuJ//s//CYfDAa/Xu6WyXHeChKy7u7uxbds2cLlcxGIxTE1NYXFxsSJz0bOzs1T+jYjy83g8qFQqnDhxAp2dnRgdHYXf70dfXx80Gg16e3vXDCOvdEizfHNzMzKZDN577z2cPXsWly9f/tSoQjqdpvUfm33tyratIDtPMmB2cnISbrf7lhuU5GnUajWtjuTz+SgWizQUurCwsCWhwUAgACaTCb/fD41GA7FYTCWlWlpaYDKZaBM12cWtt5ASKSgmkwmpVIr29nbaXqDVasFgMOBwODA/P4/FxUWsrKxseWk3gYTh+vr60NjYuKZ9gyzW8/PzsFqtiEQiFbf4SCQSOr+spaUFwWAQKysrmJmZgdPpRCAQoILapBq3XNJ8t4O0boTDYQSDQdo209PTg2g0ioaGBiqkvB4sFgs8Ho+WrHd1dcFgMNBeLq1WS3PesViMCmVbLBbMzMxQoYpKhawtpLiExWIhm80iEAggFotVpPEmVe2BQACRSITKo3G5XNTU1NAZm8FgEP39/ZDL5VAqlZsqVLDRkHMhOrx2ux3Dw8OwWCwb0pu8UZTdt+7o6EBTUxOkUim6urrw6quv0nJX8rA+9thj+OIXv4j+/n4YjUZwOBxks1nMzc1haGgIH3744ZY0VxIFjU8++QQ+nw+/9mu/Bh6PB6VSiRdeeAHbtm2jfXFED3VhYeEWI3/gwAEYjUZIJBJIJBKqSMJisTA1NYXTp0/jpz/9KWZmZuDxeCrmIWYymbQJ+dFHH12jXkGU/peWlvCLX/wCDoej4gwgAOzduxcvv/wytm/fDjabjb/8y7/E8PAwJiYm6IZl9fzHXC5HZ1duVXUo6XG7cOECMpkMvvSlL0GlUqG+vh4SiQStra10w7QeWq0WHR0d0Gq1UKlU4HK5YLFYtM+QxWLBZrNhaGgIZ8+exbVr12Cz2RCNRhGLxSraAAI3+sgEAgHMZjOtIs9ms1hZWanoEG4+n8fIyAiKxSLq6+tpywQZFrB//34Ui0W6YX7Y2imEQiG6u7uh0+mQTCZhtVqpAHslURYB7Xw+j2g0irm5OWi1Wmg0GjQ1NVHhWDI9mKiydHZ2wmw2Q6lUgsvlolAoIJlMYmFhAXa7vaz5wJvPJZvNYn5+Hmw2G3a7HQqFAiqVCgqFAgDWqOBEIhGo1eo1iwiDwUB3dze0Wi1VvCG7fCIyPjExQUdK5fP5immQZbPZqK+vh8lkgkgkooUwpBl5YmICc3NzdPZgJUFKtY1GI5qammjxjs1mg9PpRCaTAZPJhEwmg0ajofPzAoEAQqHQlhoD4o06nU6IxWJYLBakUikYDAZIJBIYjUYwGIw1o3lWo1Qq0dDQALlcDqlUSvMuyWQS6XQaHo8HCwsLuHLlCqamprC0tIRAILDl6ip3i0QioXk1ItycyWTg8Xgq7j5cTaFQoEOr+/r6aJEM2YSRWYLAraIhpE4hHo8jGo1W1EaFCHzL5XKo1WqwWCy43W5EIpGKSTGspixGkBiwf/zHf8TBgwfx1FNPYdeuXdixYweefPJJRCIRXL58GcViESKRCC0tLeju7qY3QCqVgs/nw7vvvou5ubktveDZbBYnT57ExMQEtFoturq68Pjjj9MKQnLOra2t9O83s7ohOxgM4uTJk1heXsbo6CgmJycxNze3qWo094tAIMDx48fR3d0NgUBAK9W8Xi+cTif+/u//nuYxKs0LVCqV2Lt3L3bu3Im+vj5cvHgRU1NTmJ+fp+FmqVSKlpYW7NixA48//jgWFxcxOjqK+fl52Gy2LT3+UqmE4eFhLC4ugsvlorOzE1/+8pchEAhQW1sLg8Fw2/tl9f1GIEbVZrPh9ddfx8zMDC5cuEAX14eJhoYGdHR0rNkERKNRXL9+vWJGXa1HLpfD22+/jStXrtDw9okTJ9YVBwFAw/OkFy+ZTMJut8NqtVZM0RxwI6JnMplgNpvR1NQEu92O8+fPb/qgg/ulLOHQUqlEZ7CJRCJotVo0NjZCpVLRkSddXV0olUrgcrlQq9VUCDeXy2F0dBRWqxXT09Nwu91bbhzIaKjTp0/TCfd6vR56vR6tra00dk8WHqKaQrRGY7EYUqkUlRAjJcMul6ti8y9kZEt/fz+amprAYDCQSqUQi8Vw8eJFDA8PY3l5mU7+qDRWS1ORnrKGhgY8++yz1GNQKBRob29Hb28v7Y+bnZ2tmOpWchzXr1+Hx+OhOZfm5mYolUq6CSMkk0ksLi5SsWbi+RHdSofDAb/fj+HhYXi93g2bh1luiCdIvEDghqe0Wny6UiHT1wcHB2G1WjE3N4eenh5aBMNgMGh+fXl5meqIElm54eFhBAKBitu4kI0Xg8FANBrF7OxsxbWpEMqWEwyHw7hw4QJKpRL4fD6efPJJqNVqCAQCCAQCGk5cTS6XQzwex8WLFzE5OYmRkZGKWJAKhQICgQDefffdNf19O3fuhEQigVwuX7PzDofDGB8fp6E1m82GQCCAixcvIhKJbGm+6W5gMplobGxEW1sb9uzZQ8WxyUL64Ycf4p133kEkEqm4eD+BiBCQwgLS/mAwGJBMJuF2u6FQKNDV1UU3MDabDePj4xVxzwGgm6jz589DJBLBYrGgr68Pzz//PNra2qjSDSGRSODq1au00s7n89Gyc4/HQyXsKq2C916Ry+WoqalZI2hAQoWVGH67mXg8jg8//JD+/1e+8hXIZDIolUqwWCycO3cOi4uLOHXqFILB4IZKhpWDYDCI8fHxNeOvKomyTpHI5XKYmZlBLBbD7OwsjEYjtm/fDqVSCZlMBrFYjJqaGqoIQ8I/586dw8rKSsXd0GTsCRlmurKygvHx8VuMYCKRgN/vp0NoyQ41GAw+FLtvBoMBo9EIs9kMHo9HDYnf78fQ0BAcDkdFlqGvhpTM19bWwmg0UjFlo9EInU4HrVaLfD4Pt9uN8fFxXL9+HdeuXaPebaWRyWSwtLSESCSCpaUlyGSyW8bspNNpWqBEpriQ+44U21TyNbtbDAYDOjs7IRKJtvpQNoTBwUH4fD7a70ier5WVlYr3bIEb66LT6YRcLsf09DQWFxc3Re5soyhrdWixWKSFME6nEyqVik7u1mg0UKlUEAgEcDqdsFgsOH/+PC22qLRmV+CXkwdIkYXL5cLY2NhWH9amQJLcq72pWCyG5eVlBIPBin840+k0XC4XFhYWMDk5CeBG7kKn00EkEkEikSAcDmNxcRFDQ0N4++23aQtPJZLP5+mczfn5+a0+nC1FJpNBr9fTflUy5bzSpy7cDovFUtESdZ9GqVRCOByG1+vF4uIiXC4XotFoxTkxhC2THyD9Mf/4j/9Ih3Wy2WwIBAKqJhMOh5FMJit2B/FZgcx09Hq9D63nkMvlEAwGcfr0aQwPDwMAragk7SlEJYX041VqaLfKWsLhMFwuF4xGI9hsNtWZtNvtFbuJ+Sxgt9vxx3/8xzQSVimtXjezZUaQJHY3YqJ5lc0nFAphZWUFVquV5p4cDgdCoVDFe4HADUOey+UQCAQqToO1yoPh9/uxuLgIlUoFoVCI6elpWK1WJBKJivU+Pguk0+mHIkrBuFO4gMFgPHyxhCqbAhl8KZVKafk2mTa+0UMuq1S5FwQCAZ30QQY5E8mthzEcWmXjKZVKt1UaqBrBKncFGYi5un9pdf6luthUqVKlUqkawSpVqlSp8pnlTkbw4VFjrVKlSpUqVTaYqhGsUqVKlSqfWapGsEqVKlWqfGapGsEqVapUqfKZpWoEq1SpUqXKZ5aqEaxSpUqVKp9ZqkawSpUqVap8ZqkawSpVqlSp8pmlagSrVKlSpcpnlqoRrFKlSpUqn1mqRrBKlSpVqnxm2bJRSlV+dWCxWGCz2aivr4dMJkN9fT04HA4AwOPxYHl5GYFAoGKnz4vFYhw4cAANDQ3Yt28fZmZmMDY2huHh4eqorwqEy+VCpVJBrVbDYDCgvr4eWq0WJpMJAoEADMYNmchSqQSfzweXy4V4PI5kMomlpSWEQiFYLBZks9mKvB+rlJeqEaxyXzAYDDAYDDCZTPD5fPD5fJhMJuj1evT29oLL5QIAFhcXUSqVkM/nkU6n6eSJSoLH46G9vR3btm3Dl770JZw/fx7AjWOvGsHKgs1mQygUQq/Xw2Qyoa2tDb29vWhoaEBXVxeddQncMII2mw0zMzMIhUKIRqMQiURwu93w+XyIx+OIx+NbeDa/urBYLDCZTLDZbDqB5k6QaTTkTznXiKoRrHLPcDgcKJVKyOVy6HQ67NmzBx0dHejq6oJcLodQKASTyUSpVEImk0EqlcI//dM/4eOPP8bs7GxFT/sulUrQ6/XYvn07zp07t9WHU2UVfD4fu3btQldXF77yla9ALBZDLBZDKBSCx+NBIBDcMtJLp9NBJpMhn8+jWCzi6NGjiMfjGB8fx9DQEP7mb/6m6g1uMBwOB729vairq8OhQ4dQU1MDs9l8y++t9tiXl5cxOjqKsbExWCwWLC0tIZFIlOV4y2oEyTw6FosFoVBIQ2YMBoOG1MiNXCwWkU6nkclkEA6HkcvlHoqZdQKBABwOBywWi15kFosFHo+HfD5PH8ZSqUQ9pIdlN8pkMiGXyyEWi2EymaBSqWAwGNDd3Y3Ozk6YzWZIJJJbXlcqldDa2gqbzYaVlRVkMpmKGsJbKpWQzWaRz+cB3BggrNVqIRQKwWKxqotkBcBgMMDn89HW1obOzk50dHSAx+PRNYSsDcVikV5H8jqBQEA9EwD03otGoxAIBEin02teU+XeIWu7UqmERCJBe3s7TCYT+vr6YDAY0NzcvOb3SSQJuHHNlEolXQ+ZTCaKxSKCwSCCweCme4ZlM4IsFgsCgQAKhQJqtRq7d+9GU1MT/ZlMJoNer8fOnTuRzWaRSqUwNDQEi8WCf/iHf4DD4UAmkynX4d43ZAekUCjAZt/4etVqNVpbW+HxeOD1epFKpZDL5ZBKpeD3+/HBBx88FA+hSCTCF7/4RbS0tODxxx+HVCqFTCYDh8MBm81eM3D3Zo4fP47t27cjn89jdHQUVqu1Ys45l8vB6XSivr4epVIJSqUSfD4fNTU1kMvliEQiFXOsn1WEQiFqamrw7W9/G3V1dRAKhXQRJeTzeeRyOfh8vls2LiqVCmKxGEwmExwOB2azGX6/H21tbXC73XC5XOU8nV85xGIxZDIZfvu3fxt9fX1oa2uDSCSCTCZbd10gmxby37q6Ouh0Ouzbtw/RaBSjo6NYXl7G97//fXi93k11FDbdCHI4HDQ2NkIikUCn00GlUkGr1aKjowM1NTUAbuwixGIxlEol1Go1crkcMpkMmpubaQhErVZjamoK6XQauVxusw/7ruHz+VAqlTRRPzAwAL1eD6lUSi++TCaD0WiEWq1GbW0tMpkM8vk8MpkM3G435ufnEQwGEQgE6PtKpVJwuVywWCzkcjmEQqEt9YQ1Gg10Oh16e3vR2NgIvV4PgUCwphABuLGrSyQSyGQyiEQiNB/A5/Oh0WhgNBoRCARgs9kqxrDk83n4fD4Eg0Fks1nqdYhEIohEoooL3/J4PHC5XKjVaqRSqTX3zd2gVqshEAjA5XLptSM7c5VKBblcDgA0nB2NRjE9PY1MJoN0Or3Rp3NXEA/P5/PR8Cc5xkAggGg0Cr/fj0QiAbvdfsu91dnZCaPRCL1eDx6PRyM1JDJTCXA4HIjFYnA4HHptWCwWWlpaIBAIPvX1uVwOHo8HiUQCgUAAiUQCqVRq046XwWBALBZDo9GgtrYWer0e7e3taGhogEqlApfLBZvNRqlUumXNLhaLiEajAG7cz+l0GrFYjOZuiRPR29tLQ6WbdZ023QhKJBJ8/vOfR1NTE3bs2EGN4M27OOCXMWI2mw02m43+/n50d3dDp9Nhbm4O3/nOd+D1ehEMBjf7sO8atVqNPXv24NFHH8UjjzyCmpoaeiOvPkeSI1ttyAqFAmw2G0KhECYnJ3HmzBn6s4aGBqjVavB4PESjUVy6dGnLwnJMJhP9/f3o7OzE888/D5VKRX+2+hxJOMNms8Hr9WJ8fJyGuPfu3Quz2Yxt27aBzWbj2rVrW7ag3kw2m8Xs7Cxqa2sRjUYhFoshEomgVCqh1Wrh9/srJnxLQtIajQaPPPIInE4nzp8/f9cbJCaTib1796Kurg5qtZpGK0g469FHH8W2bdsA3Lg/PR4PJiYm8Pu///vweDxYWVmh4fxyks1mEQqF8P7776OjowNPPfUUGAwGisUiLl++jPHxcVy9ehUrKyuYnJy85Xq9/PLLOHjwIE6cOAGtVotisYhsNotgMIhkMlnWc7kdYrEYLS0tUCqV1AiIRCL8p//0n1BXV7fmd29+7hgMBkKhEE6ePIn5+XmcO3cOi4uLWF5e3rTjZTKZMJlMeOKJJ7Bt2zZ0dXWhqakJUqmUHhepwL15U5LNZjE6OgoAMBgMcLlcmJychN1uRyAQwDe+8Q20t7eDzWZjZGRk3Wu6UWyaEWSxWDh48CDMZjP2798PrVa7Js+ymlKpRL+oZDKJdDqNZDIJrVYLsViM2tpa5HI5mEwmlEqlLTOCxDhrtVrI5XJ0d3ejrq4OfX19aGxshE6nA5fLRaFQQCgUokYrmUwiEAjQHKfJZIJMJoNEIkGhUFiT26ipqYFOp8OxY8dQX1+PQqGA5eVlXLt2bcuMIIPBQG1tLRoaGtZ4D8CNa5dIJJBIJHD27Fm4XC44nU5Eo1E4nU4IhULIZDLU1dWhtrYWCoUCOp3ujqHTclMsFpFMJhGNRuH1esFgMCASiZDNZpFMJivGUwBu3IPbt29HQ0MDDh8+jHg8jp07d97TezQ2Nq4pYAJ+6QkaDAawWCy6sMpkMjQ3N+NrX/sarl69irfffps+o+WEXKPBwUFaOMFgMFAqlTA3NweXywWHw4FYLIZcLkevmVAohFQqRUNDA40skc1oLpdDPB7f9DQLi8WCWq1GT08PjZ6sh1wuR1NTE+RyORQKBRgMBrhcLuRy+brPCzl/glAoRHd3N7RaLdRqNQYHB2mbyEZ7hFwuFzqdDp2dnThy5AgMBgN0Oh34fD4KhQJtRZmZmUE4HIbP51vz+kKhgJWVFQA3HKVYLAaPxwPgxj1eLBbBZDKRzWaRzWY3ddO1qUbwxIkT2LZtG/bs2QM+nw8At3hD5N/y+TwN7YRCIfj9fvD5fEgkEhgMBjCZTDQ0NCCVSmFubm5LQoMcDgd8Ph+NjY1obGzEl7/8ZRgMBrS0tNDzSKVSyGQycLlc9OHyer30ZojFYnj00UfR0NAAo9GIbDZLc2oAUFtbi/7+fjz77LPo6OhALBbD8PAw/s//+T9blhNlMBioq6tDU1MTPU5yvsCNAgOPx4N/+Zd/wejoKC1kSqfTkMvl0Gq12L17N/r6+qBUKqHX6yvKCJLrFolE4PF4aGFMJpOpOCPI4XCwa9cu9PT04MSJE7QVZSMh15XBYEAikUAikaC5uRkajQbnz59HoVAouxEslUpIJpM4e/Ys2Gw2PvzwQ/rvqVTqtl6CRCJBbW0tmpub0d7eDqFQCOCGUc3lcojFYpsalmcwGGCz2TAYDHjyySehUqnWRFJWI5VKYTKZaK7907h5DRQIBOjr60M6nUZ/fz8YDAY8Hg+SyeSmGMG6ujr09PTg+PHja36WTqcxNzeHhYUFvPPOO7Db7Zibm7ur9yXrItnwp1KpTb/XNsUIkt1/Q0MDGhoablk4i8Uipqam4HA4MD8/j1gshlQqhWg0iuXlZRqnf/HFF7Fjxw60trZCJBLhiSeegFQqxdWrV5HL5crmGZHK1UOHDqGtrQ0HDx6ETqdDQ0MD3dWlUimkUimcO3cOVqsVg4ODNOZN8iq5XA65XA5jY2OQSqXo7++HUqnEjh07AABXr17Frl278Oyzz6K+vh48Hq8iKkdJv5VMJsPAwACAG9fYarXi+vXruHz5MqanpzExMYFwOIxsNgsWiwW5XI4DBw7Q6ygWi+F0OrGwsFAx+cA7IZPJoNVq4fP5KiYcWiqVEI1GEYvF7mojSDy6B/k88nrilWx1jrRQKKwpn19vHdBqtdi3bx/a29sxMDCAvr4+SCQSsFgspFIpDA4OYmRkZNM200wmE62trVCr1ejr60NLSwuOHj1K87nrweFwIBKJaFTofuFwOJBIJJDJZJDL5Q/8fncDCU1fv34dy8vL+MlPfgK3243l5eV7CjcLhULI5XJaRf6zn/0MS0tLm7rWb4oR5HK5EAgEkMvlkMvltOS1WCzS5LrVasXMzAyuXLlC4/LhcBgLCwtgs9ngcrloaWmBQqGAyWSCSCRCW1sb/H4/hEIhkslk2Ywgl8uFSCRCR0cHdu7ciQMHDkChUAAA3RVHIhGEw2FMTExgbGwMp06dQiQSWff9FhYWwOFwkMlk0NraioMHD8Ln80Gn08FsNqOnpwdyuRxsNvuBFrCNgoRUnE4nfD4fmEwmBAIBgsEgJicncf78eVy/fp02z7NYLHC5XCiVSrS2tuKxxx6DUqkEl8tFIBDAysrKQ9F2QEJplea1kibv1bm5290nD3r/rH796sKNSoCEcEmRy+o/Op2OGr+9e/dCLBaDy+XSEOjs7CyWl5c3xQgymUxwuVwYjUbU19dj//79qK+vR2tr67rXY73o2Oprm8lkaDRidTsZuS9vfk/ifbLZ7FtqEzYT0u9H8rP3k0snDfZ+vx+xWAxjY2Pwer0A1vYVbiSbYgRJ5SPJFYnFYiQSCczOzuLs2bN455134PP5EI1GkUgkaB8IWRiJJ/jzn/8cFy5cQH19Pbq6umA2m5HJZPC5z30Ow8PDuHr16mYc/i3s27cPhw8fxmOPPXZLL9zCwgLeffddjI+PY3JyEh6P566UKJhMJq0WNZvNqK+vx6OPPgqVSgWFQkHzMpVAsVjE4OAghoeHcfnyZezYsQN//ud/Di6XC6lUSh+0mpoayGQydHR0QKvVoqurC11dXTQHmM/nce7cOVy6dGlTq9Y2ipqaGrS0tGBsbIx69VtNNpvFqVOn4Pf78dRTT0GhUEAsFpflsxUKBXp6ehAOh7dMSYfJZFIvj8/ng8fjQa1WQyKRQCwWQyAQwGAw0PyaUCiEWCymlaCffPIJ5ubm8IMf/AA+n29TQt1msxl1dXX4nd/5HZjNZuh0OlrNuh75fJ72w91cOJdMJvEP//APNH+mVqvR3t6O/v5+9Pf3r+lHJpCI2sjICK5du4ZwOLzh57gepVIJ169fx+DgIE2J3CsWiwUOhwNOpxN8Ph/hcBhMJhMajYaGsJPJ5IZGZjbFCBYKBZoTIlJZ+XwesVgMDocDY2NjSCaTn/olpdNpRKNR5PN5WrYuFAohFAo3JRdyO1QqFdra2mAwGKBQKGgjv9frxfz8PMbGxjA1NYWpqam71iMkSW/iNfP5fGi1WvoQFAoFZLNZuFwueDyeLc9LRaNRxONx5PN52sbC4XCgUqlQW1uL+vp6NDY2QqlUoru7GxqNBu3t7TAYDPRa5XI52stVKQb+TpCIRCV444RisYhAIACXy4XFxUVks1kIBIK7kqa6W1aHQG/++80LdTlhs9m0zaa7u5vK9anVakilUkgkEvD5fNTW1kIoFNLiEnLsxWIRXq8XDocDbrd70zY2QqEQSqUSJpMJJpNpTQESOZZEIkHXChIZuznFQ4qBxsbGqBHU6XTgcDioq6tDLpdb95qnUik4nU54vd77Nkb3C1mjidd9r59NigdJuJ9EkIxGI424ud3uDS2O3BQjmEqlUCqV4PV64fP5UFdXt0Y/MhqN3vFBIn0yO3bsoF4FWYyi0ShGRkbK2tyq1+vR19dH+6cymQwWFxfxZ3/2Z1hcXMTY2BhVg7lXbg7jADceklgsBp/Ph//xP/4H5ubmKiInRSrqSAGTUqnEsWPH0NLSAp/Ph66uLigUCroor1bpAG7s4klO8e233y6bLNL9kkwmEYlEKip0WyqVEAqFMD09jf/v//v/cODAAfy7f/fvIBKJaNHH/b7v6p5Bwuq/u91unD59mlbxlRPSGvJv/s2/QWdnJ44fP74mDMpkMtf9O4G0RJAq0lKptGGbhpshNRESiQQikWjd37l+/ToWFhZoRfJrr72GRCJxSxEIKfwhm2CPx4N0Oo26ujoMDAysWznqdrtx8uRJTE5OIhKJlG3TwmKxaCvKH/3RH2FpaQlOp/OeP5/BYKCrqwsNDQ1QKpUwGAw4duwYbDYbhoaG8Morr+D06dMbdtybVh1aKBTgcrmg0+nQ09MDDocDtVoNrVaLmpoahMPhdROmTCYTKpWKXuSuri5IJBJaDpzNZhGJRMoaTiNx6tXHkEgksLS0BJfLdV/VS8ViET6fD36/f10vjxQKuVwueL3eLfcECblcDtFoFHNzczAYDDCZTDAYDJBIJNBqtRCJRGsKoVbDZDJRU1MDn89XUXm220EasCtJnAG4sTCm02nYbDZMTEzgww8/hFAopBXYdwPRdxSLxeDz+bfNVRHtV4fDAavVinA4vCVVylKpFBqNBh0dHTCbzVT95W4gBp7NZqO5uRksFguZTAZOpxPXr1/f8GdrtQEmRTxkk+z1erGysoKrV6/CbrcjHo/TFgKiJLUeJA8vFouh1Wohk8nA4/Fo/3GxWEQqlcLS0hImJycxNzeHQCCwaQaQ3BuknY00xiuVSuTzeTQ0NKBQKCAWi91RZIHBYIDD4UCj0dBCQ6FQiN27d0Ov10Mmk0GtVkOpVCIcDm9I4dDNbJoRLBaLGB4eRiaToRJbnZ2dsNlsmJ6eplVEqyE3akdHB44fP47jx4+js7NzzQ1FwpBb5UWQnRnpgbld8cunkc/nMTExATabvSbERJLkpFzfZrPB7XZv5CncN6RM3eFw4O2338ajjz6Kzs7ONTmpO4UOGQwGOjo6aOFApeN0OjEzM1MxTf2ryWQyNH8yODhICyHuFrlcjr/+67+G2WyGwWBY97oVi0VEIhHYbDa8+uqrGBsbW1eSbLNhMBgwGo20yEqj0dzz64lq0YsvvohsNounn34a586dw+jo6KaF50khIKmQjEQi+Oijj/CLX/wCPp+P9jSuVxhzM2w2mxbO7d27F83NzTQyBdy4H1ZWVvDP//zPmJiYwKlTpzb1OhEDFwqF4PV6oVQqIZVKIZfLweVyaW94PB6H3++/7RrGYrEglUqxb98+fP3rX4fRaIROp1uj97rZ6YhNNYIWiwX5fB6Tk5Ooq6tDXV0dWltb8dxzzyESicDn8yGdTtOdmEKhQG9vL/bt24d9+/ZBq9XS3V4mk4HNZqO7p63UEWWxWLSc+X6kpGQyGaRSKY4dO4aOjg66eJFwYzabxfj4OCYmJiqqgITL5WJgYABms5kWCQH3VoF4c5iqkjEYDGhra4PP56tY3VpS7UgW+jtBvvuenh40NDRAq9XSKMtqyIKcy+UwNTWFubk5XL58GS6Xa0vUYoBfhjM9Hs8taYd4PI5UKgWPx3PLdVKpVKipqaHFM6s9j7a2Njz//POYm5vDxMTEhuU7SeHQuXPnIBKJMDg4SPuHFxYW4PP5qHd4t16oRCLB0aNHYTabsWfPHtTV1dHrls1mcenSJSwsLNDrtNm523w+j0AggImJCbz66qvYu3cvBgYGwOfzweFwsG3bNtTV1UGlUmFychKnT59GMplEJpOBQCCASCTCnj17aC63s7MTTU1NkMlkVNCARNwSiQQcDgfm5uZw5cqVDS/K2jQjWCqVaMx7fHwc+XweJpMJLS0tqK+vp1JHq9UdlEol9u/fjwMHDmDv3r0AQH+WzWaxsLCA5eVlxGKxLQkPkpuKGEGJRHJfzZxyuRy1tbV49tln0dTUtMa9z2aziMfjGB0dxdWrVyvKCPL5fOzduxfd3d04cuQIeDzeLeoxq/m08v1Kp7a2Fm1tbbh27dp9e/ybzc09c3eClNc3NTVhYGAAWq2WSlzdDFmESMvP5cuXNz0sfLMCympWa+3e/EysrKwgGAxifHz8luvU1taGbdu2gcfj0YgFUXBpa2vD5z73OZw8eRJzc3PIZDIb4j2RisYzZ84gn8/j9ddff+BogkQiwfHjx9HY2Iiurq41z1Qul8PFixcxPj6OS5culaV+gFS0TkxMIBKJQCgUorm5GWw2GzweD9u2bUM2m0VXVxdOnz4Ni8WCQCCASCQClUoFjUaD3/iN36Ben1KpRG1tLYBfRpwymQy8Xi+8Xi8uXLhAjeDN6jMPyqZrh8bjcbz66qvo7e2FUqmERqOBVqvFF77wBfT19eGdd95BMBik5ejPPfccxGIxXC4X3n//fUxNTdEdXDKZxMLCQtl3oul0GqFQiI5JEolEaGpqwre+9S2MjIzg5z//Oa3sWm8sC5fLhUQioX2TBw4cgNlsRmdnJ5RK5Zod/OXLl3H+/HmcOnUKi4uLFRGKYzAYMJlMMBqNeO6552AymcDn82/J6+XzeYTDYfzoRz/CysoK3G43Ghsb0dfXh+3bt6OpqQkNDQ0oFosV02u2HsRjcrvdsFgsFesF3i2kb7OzsxNtbW144YUX0N7eftvWilKphKtXr8JqteLnP//5uoLUGwGPxwOPx0NraytUKhW6u7vh9/vx7rvvIplM0pqBUqkEl8uFcDiM73znO7fcO+l0mtYK3Gyox8bGcPbsWXzjG9/AY489BoFAQCMvcrkcu3btwvLyMnQ6HR20+6AEg0EkEgla4fggRomo9sjlcohEonXzvoVCATMzM5idnS17qDoej2N5eRlvvfUWFhcX8fLLL6O1tZV+zyqVCo8++igMBgMcDgc8Hg/MZjOtuCdi5mw2G7lcDlevXsX09DRCoRBisRjGx8cRjUapSHowGNzw53HTjWAmk8H4+DiAG5O6SZ9Pd3c3TCYTnTHX0tKCxsZGtLS0IBQKwel04uLFixgcHKSjbaRSKW2cLCeJRAI+nw9yuRwCgQA8Hg8KhQIHDhwAi8XChQsX6Iy8SCRyy0USiUTQ6XTQ6XTQarXo7+9Hc3Mz1VJdjc1mw8WLF2G1Wjd0x7N6wjNR5L8Xb1qhUMBgMKC9vR06ne6W15Kyb6/Xi1OnTsFqtWJhYYFWgzY0NMBsNtO8wWZV5j0IN4dqo9EofD5fxRXG3CtE6cVsNmP79u1U6Hg1N7fmWK1WGpLfLK1eIovY3NwMk8mERx55BHa7HZcvX0YgEFhTOBeLxdboS94tTqcTFosFx48fRzKZXNOvx+PxUFdXB41GA7FYvGH9dKQ1bKOiByKRCBKJhG7Cb6ZYLMLv99+2yG4zyeVyiEQimJqaQigUwiOPPAKtVkulIIVCIVUOW1pawsrKCtrb29dMKiEpoHA4jNnZWVy8eBF+vx/RaBRXr159OGXTVkNGZkxMTOAv//Iv8fjjj+OFF15AXV0dampq8Nu//dvI5/N0nIbFYsF7772Hn/zkJ3Rn5nA4aCgnn8+X3RN89913cenSJXz729/GgQMH0NTUBB6PR0Wz9+/fj2AwSKdB+P3+Na9vbGzEoUOH6I1B+pnW29UFAgFYrdYNLfzh8XjYvXs3VCoV6uvrsby8jCtXriASidzVzpfBYFAvnlSjrYZUiH3ve9/D6Ogorl+/jng8Tsv5Z2Zm8Oijj6JYLMJms2FhYaHiDAsJcZPxVeTY3W53xR3rvcBisdDT04OXXnoJvb29aG9vp7qUN0uqlUoljI6OYnp6Gm+99RYsFsumFqANDAxg27ZtePHFF2EymSAWi+Hz+VAqlTA4OIjXX3+d9pbeLyRC43Q6YbVa0dXVRYuySPN1Nptdk5apJNhsNrq7u9Hd3Y2Wlpbbhq+3GmK0/vqv/xpNTU343d/9XRgMBiiVSvo7BoMBGo2GrntMJhPhcBhXr17FzMwMLly4gNnZWTpmrVAolCUKU5ahuoVCAfF4HIuLizQJTTTi9Ho99Qr8fj8WFhbgdDoxOzu7RjZoKyEGbn5+HjqdjurySaVSCAQCqNVqhEIhmgu4eb5bQ0MDOjo66KQMMsX8ZmNCVC1W9wVtBCwWi7YykGGXwWAQVqv1rgWiiewdqWQjHgMZDEwk1GZmZqjAAYfDgUAgoLMRS6USwuEwAoFARS04ROdUJpNBLBZTb4Fcq4ehsX89+Hw+FXgnfVdarXbd3yWei9VqxdjYGJaXl9ctQtlISJhWq9XSfFChUIDZbMbc3BydpfkgkHt1dUEP+W86nYbL5YLf70c6na6oflACaRlTqVS3iIQQL4rkMrfymSItIETAIRgMQi6XrzGCRBwEwJqK/1gshpWVFczMzMDpdJZ9SlDZJstns1l4vV784he/wNmzZ/Hf/tt/g0AgoOM3gBs3pcPhQDgcrriFp1Qq4bXXXsO5c+fw67/+62htbaWCuAwGA3K5HFKpFAaD4ZZjJ6W+oVAIwWAQS0tLyGQyeOSRR6gE22ZWTfL5fDz++ONoa2tDd3c3gsEgnnjiCfzgBz/Am2+++akLQKlUgsfjoaOfiGLOwsIChoeHMTg4SHuTotEoCoUCVcDZu3cvfvM3fxNmsxmlUgnz8/OYmpqqKO9KJBLhsccew549e9DV1XVPrQaVCtn4/MEf/AHMZjOV2FrN6vvNarXi/fffx/vvv4/BwUHqGW3mwjo/P49UKoUXX3yR/huZ0qJWqzf0s9RqNRWlB25s6hYWFvDd734X4+PjsNlsFbfmkEpWk8mE+vp66iys9uC9Xi9cLhfi8XhFCGoQ4Wur1Qoej0dHc90M2UwzGAwIhUI6WmkrZjuW9WknPXa5XA6jo6OQSCR4/PHHodFoqHyY0WhEc3Mzurq64Ha7K0qxIxqNolgsYmhoCF6vF4VCARqNBvX19QBurY7M5XJ0jmAsFkM4HEY0GkU0GgWbzcbu3bvLcty5XA5zc3Ngs9loa2uDQCCg8/1qamrgcrnuePORvkWXy4UzZ85AJpPRZu3JyUnMzs7C6XSuETUn4gg6nQ4GgwFCoRDFYhFLS0uYn5+vKCNYKBQQiUSQSCRuUbl52ODxeODz+ejq6kJLSwuam5up1NZ6m6xUKkWb7q9fvw673V62imQSTVhtaEm6QCQSUemtB/FGyegunU5HZ5kWCgUEg0G43W7Mzs5WhCzhehBPuaGhAfX19WsEs0kYlzx/oVCoIqIWIpGIOgQ31zsQw0e8cg6HAw6HQ/sfd+zYgZmZGSwvL5dVnq/sW17S7/P666/j3LlzMBgM4PP5UCgUUCqVOHjwIPh8PrhcLt577z1MTEys6SXcSogBe/XVV8HhcPCTn/wE/f39ePnll9ct745GoxgcHITb7cb09DR9oA0GA2pra/HCCy/Q2WKbecGTySR++tOfoqenBwMDA1Cr1WhsbERnZyeWlpYQi8U+dQfmcrng8/nwp3/6p2Cz2chkMohEIvB6veseu0AgQHNzM8xmMxoaGgDcCGuTYqdKqHolZDIZTE1NUXm/hxmZTAadTodvfvObaGlpQW9v77oiy8AvJdjeeustXL16FW+88caWP2ccDgdarRYqlQpSqZSG++6X1tZWHD9+HF1dXZDJZGAwGEin01Tz99KlSxU71otUou/btw/d3d1rfpZKpRAOh/Hzn/8cZ86cgc1m2/K0EZk7Wl9fj4aGBtTU1NyScyZRpGKxCBaLBZFIhN7eXqjVaphMJvzoRz+i6jnlqv/YsrgPGWJ685Rq8kUePHgQHo+Hlv9Wks4kSahHIhHMzs7itddeW/f3SIN/LBZDJBKh4aX1PFvysJPQ5EZe/GKxSCtur169ira2NqjVanR3d4PD4UCv18Nms+Gjjz664/dcKBTg8/nAYDBoO8jNx8lms1FXV4eWlhY8/fTTaG9vBwDMzMxgcXGR9nlVmrG5G9WOSofBYKCzsxOtra1obm5GTU3NbRU3stksRkdHYbFYcPr0adhsti1rhF8NOVaVSoXe3l6MjY3d1/xCHo8HlUqF1tZW7Ny5ExqNhr43kS8LBoNbfr53YseOHejs7KTGezV+vx9WqxVOpxOBQKBiDHlTUxM6OztpDnP1cWezWaTTaXz88cfwer1oa2uDUqmE2WwGj8eD2WzGr/3ar6G7uxuDg4O0NmSzw7xbagQB0KbI1TcjUZdZWFhAIpGA3W5HMpmsmBuWJNvj8TgsFgssFss9vX49I0imbGyGEVwdzrx8+TI4HA527tyJrq4utLW1oaGhARaLBZcvX17Tm3UzpBT7TnA4HNqM/cwzz9B878zMDM6fP4+VlZWKNIIPk5LN7WAymejs7MSuXbtgNpvXyGoBa69pJpPBlStXMD4+jjNnztzyDJabm4UViBF0Op1YWlq65/fj8/kwGo1ob2+nA51XF2NUuhFkMBjYuXMnDh48uGbKPDlev9+PmZkZuFyusheS3A4Gg4HGxkZ0d3dDoVDcIh6ezWYRi8Vw8uRJTE9P49ChQ2hqaqItKg0NDWhsbEShUIBAIKDSmps9dWZLKwCKxSLsdjs0Gg1qa2tprJs0Tx48eBDt7e04fPgw7HY7fvSjHyEQCFTMRd9IfD4frly5QlV2NmNnF4vFcPnyZTrDsaOjAw0NDWhqaoLBYMB3v/tdOBwOnD17FouLixgfH7+r4ghyvRoaGmA0GvGtb30LJpMJAoGAjoOxWq0YGRm564no5YTH46GzsxMNDQ0PrSHs6+tDd3c3Tpw4gc7OznUnSqRSKaRSKVy8eBGLi4t47bXX4Ha7b8nLlYtQKIR8Po/5+XkoFArU19dToXqTyYRjx45hZWUFoVDorjZPpA+Wz+ejo6MD/+E//Ac0NzdDIpGsKXYiDeyV4j3dTE1NDerq6tDd3Y3W1tY1vY3BYBCzs7P48MMP8cEHH8But2/hka6FFL5xuVwcOXLklp97vV4sLS3B4XBgeXkZb7zxBqRSKU6dOkXFwZ9//nkcOHAAR48excDAAM0T/sM//MOmXa8tNYKl0o2J5SQxTUp+c7kcHdJKhs7abDZ8/PHHYDAYtLimUm/i+4EIU5ME92aQyWRgt9vB5XIhk8kgEAigUCig0+mgUqmg0+ngcDgQi8XAYDCwtLSEVCp120WSjEsSCoUQCARoaGhAS0sL9uzZA4VCgXw+j2QyiXA4jJWVFbhcri3PW6wHi8WCQqFYMyz5YYFohtbW1mLbtm1obW2FyWRaV84unU4jHA5jYmICk5OTdNTOVuUBSTidqAvV1taCzWajVCpBJpOhubkZTU1NWFhYoF7EnYrkyGZMLpejsbER+/btW9OeQwpxksnkumOLKgWlUomWlhbU1tZCpVLR7wS4odBitVoxMzOD8fHxijuHYDB4S2sNSQEFAgHYbDYEg0FEIhGsrKyAzWZjcXERPB4PIpEIPT092LVrFxobG1FXVwe5XA6JRIKf/OQnSKVSm1IkuaVGMJ/P4+TJk1heXsaxY8fAZDIRj8cxNDSEwcFBPPnkk+ju7oZUKkVzczN+93d/F06nE8PDw3TKeZW7h8iaTUxMwGq1YmpqCm1tbfjCF76A5uZmOrD0a1/7GmZmZtDT04PBwUGMj48jGAxS40wGAut0OjQ1NWHv3r3o7OxEV1cXlEolRCIRwuEw5ubmMDg4iLfeegtLS0vwer0VUcZ9M+l0GsPDw7RI6WGCqBHt3r0bJ06cgE6nu8WbJYvQ5OQkRkZG8NZbb2F2dnbLNHhXH1c2m6VrQHt7O2054vF44HA4+OpXv4oXX3wRQ0NDCIVCdwzbEmHmnp4eyOVyKu4AAJFIBNFoFGfOnMHCwgJef/31LVFYuRseffRRfPvb34ZGo4FIJKLiDZlMBg6HAx9++CFmZ2c3vJ94swgEAlhaWsKrr75KvVfi1edyOQSDQSpWMTg4CD6fj0ceeYRW3ieTSRw8eBBWqxXT09MbfnwV4QnK5XIkEglwuVwwmUzaeE16Y7RaLdhsNurr6yEWi5HL5eDz+TA2NnbXk9wrka0IvRUKBarLuLy8jGKxSHt6+Hw+BAIBtFotHRcVCoVoDw/ZdZLS7bq6Otp72NHRAaPRCD6fD7/fT6/PxMQEpqent3zyx50g/VikBJ00/hK1kUoL3wK/HDumVCrR2dmJ+vp6aDSaNaLm5LgTiQRWVlZgsVgwPT0Nt9u9YRJhD0qxWITL5YJQKEQmk6FVg6SgR6fTQaPR0Gb+O7UBCAQCCAQCdHR0gMPhoFAoIJVKIZlMwm63w+v1Ynx8HEtLS3C73RVTbEfuPx6PB4lEAqPRCJPJRKUOAdBzCYfDsNvtCIVCFWkAc7kcnQ6fzWbB4XCQSCSwvLxMpwDdXN9Beo9JemxiYgK9vb1QqVRUWk+tVm+4cDZhy41gIBCASCTCwsICGhoaYDKZEIlEMDg4iKGhIQgEAuzcuRMtLS34nd/5HdTX16OrqwulUglzc3Ow2+0V80A/CDdPly8HJD5PilmeffZZ1NbWorOzE0ajETU1NdizZw+dKZdIJKh8HZ/Ph16vR2NjI31Yg8EgVlZW8M4772B6ehpvvPEGfRgq0ZAQhEIhHn30UfT394PBYCASiVAVnEQiUZGLDZkvd+jQIfyX//JfoFarIZfL1x2LND4+jr//+7/H2NgYZmZmKqpHkzzHiUQC4XCYqvYAv9wkkjmUn1bBS54fIq8Yj8cxMzOD69ev4/Tp05iamoLb7UY6nd70Yot7gcPhwGAwoKmpCY8//jj27NlDc6OEXC4Hu92OmZkZXLx4sSJTQaVSCV6vFxwOB3a7HWw2G7W1tbDZbHjrrbcwNTVF5RTXe20+n8fZs2dx5coV9Pf3Q6lUQq1WQyQS0X7mzWDLpTFISMTlckEsFqO+vh4GgwG7d++G1WpFMBiExWJBoVCAzWaDTqeDWq2G0WjEwMAAfXgedrZqRlsul4PD4UAul8PZs2eh1+vh9/tpkzGbzabl5cSTI0NxRSIRmEwmbTQfHx+Hy+XC0NAQnftYiQbkZsikdhKqzeVyNGdUSYvlasikcYlEAo1GA4FAsEZRBLgR5l1aWsLMzAzm5ubg9Xor0hsnldYff/wxWltbsWfPHqqtSwzb7VR8iOoI6UHL5/Nwu90IhUKwWCxYWFig4X+fz4dkMllxBkQkEuHgwYNoaGhAb28v9Hr9LZuZdDqN8fFxWK3Wir0ngRu1DdFolK4JpVIJIpEIdXV19PtfDY/Hg0ajoV6uwWCAXq+na4/X64XdbqdzGDeDLTeCREVmbGwMTCYT27Ztw44dOyCXy/F3f/d3OH36NEZGRmC327Fnzx50dnbi8OHD6OnpAZ/Ph8PhgNVq3erTuC/Wm79X7pu7VCrRMSwXLlyATCajTfXHjh1Da2sr6urqoFAoAGBNqI0UvczOzmJpaQk/+clPYLFY4HQ6K26huRO5XI5qSBKDGAqFkEgkKtJoADdC0mTEDrk2NxMKhfDuu+/i6tWrFZ8/D4VC+MM//ENs27YNf/VXfwWdTge9Xv+pr1ttLEib0eXLlzEzM4Of//zn8Hq9t51qXiloNBr83u/9Hmpqam5payGEw2H8v//3/2C1WivWAAKgDonH44FKpUKpVEJNTQ2eeOIJSKXSNXJ4DAYDKpUKBw8ehNPpxOjoKJ599lk88sgjEAgEyOVyuH79OoaHh3Hy5MlNUzLaciMI3NjljI6OgsfjIRqNgs/no6mpCYcPH4ZWq8WlS5eQy+UwPj4ONpuNRx99tGJzNfeLXC5HT08PZmdnMTs7i2AwWNbKL1I9l0gkYLVakUql4PP50NzcjLq6Oip9tpqVlRVYrVZYrVa43W4sLCwgHA4/FN7favL5PBwOB9xuN2KxWMUavtVwuVzU1tZSgeKbq0Gj0SgcDgdOnTp1X3125WZ14cdPf/pTNDc3o7+/HyaT6bai3+R1brcbgUAACwsL8Hg8OH36NK043QotyruBTFQ/cuQI2traaP4L+OVw4evXr8PhcMDpdNLZlg9DexgZq0ZyrhKJBE1NTeDz+VQ8g9yvQqEQJpMJdXV1dORSPp+H1WpFIBDAe++9R2d6bta6UhFGkEywlslkCIfDkMvlqK+vx2OPPYbm5mbEYjE4HA7MzMxQKSUyauNhN4Tk+GUyGbq7uzE8PIza2tpblHTKQbFYRCqVwvLyMux2O4aGhtDY2Ija2lps3759jSI8AFgsFly7dg0Oh+OWyRkPE8QTJFq1pOquku8tDoeDmpqadb1AMq3D6XTi7NmzFWsIbiabzcLpdOLVV1/Ftm3bqBD7p1XtOp1OLCws4MyZM1heXsaZM2cqrnXgZmQyGQwGA15++WW0tbVBoVDcIjRNKuCvXr1KxfcfhghLsVhEPB6n4VCJRAKJRILGxsbb/j4hFovRjfji4iLef/99eDyeTa0qrwgjWCgUEAqFMDQ0hD/5kz/BoUOH8Mwzz0CtVkOpVOJb3/oW1ZuTy+XgcrlYWFjAm2++WVHNondLoVCgsmuxWAwSiYQOPu3s7EQwGEQwGNzSXCfJr5DRJqS/cDXxeBzhcLhsgsubRbFYRCKRwOXLl/Hbv/3bVMJubm5uqw/ttmQyGVpMdjO5XA5DQ0MYHR196CqnybSZS5cuYWFhAa+99tqn9m+Gw2EkEgn4/X4kk8mKbMO5me7ubvT19cFkMkGhUNxSCEPSRKRIKxwOV+zMw5vJZDJ4//334fP5cPz48XUHARMCgQDOnDlDeze9Xi8CgQCmpqbg9/vpVIrNpCKMIMnDuN1unDt3DhqNBrt374ZWq4VMJoNarQaDwaD9TplMBh6PB9PT0xs2vbmc5PN5pNNp+Hw+SCQSqghRKBQgFAqhVqtvMThbAdnRxePxTUtKVwq5XA5ut7vi80eEfD5P85Y3UygU4PF4bituXskQhaFkMrlp1YBbCZPJXKOvS0QrgF8W+ZC5o8lkknpUle7Zriafz2NhYQFSqRR+v5+e380wGAy4XC6Mjo7S4QRutxs+nw8Wi+W+NGPvh4owggQyT/DNN9/E9PQ0nnnmGfT396OzsxM8Hg9+vx8ejwfDw8P46KOPMDw8/FDkb27G6XTC5/NRWaff/d3fRSQSwfT0NK5cuYLR0VGsrKxs9WFWqVJlgzGZTGhubsbhw4exZ8+eNZPiiSdIqiEHBwdx5cqVhyacTSgWiwgEAjh//jwVQbkdJCJGHBzSo1tOb76ijCBRECBVeo2NjbQ0nzRhk4ZX0nT5MEKk4RYXF1EoFDA2NoZIJIKZmRlaZPIwGvcq5YPkb6PRKLxeL8RiMYRCIbLZLFKpFBKJREUKlX/WIQ3xUqkUUql03YGzoVAIVqsVfr//U6XiKhXSpzk7O7vVh/KpVJQRJBCJox/84AdgsVj0RiEtBKQo5mEnnU7DYrHgv/7X/0qrM8mfKlXuBMkJSiQSvPLKK9i3bx+2b99OC3wmJiZgsVgeihxSlbWQ9g6bzVZdC8pARRpBYuw+C94QyYFUqXIvkM0gmT4SjUYxPz8Pr9eLUCiEhYWFhzIn+KsOaV05ffo0nE4nlYpczeDgIBwOR3VdKBOMT5Ehqj5BVapUqVLloaZUKt1Wj/L2GcsqVapUqVLlV5yqEaxSpUqVKp9ZqkawSpUqVap8ZqkawSpVqlSp8pmlagSrVKlSpcpnlqoRrFKlSpUqn1mqRrBKlSpVqnxmqchm+YcBHo8Ho9EIhUIBk8kEv98Pv98Pm81WNuHXKlXWg8lkQq1WQ6FQYGBggCoujY+PY3Z29qGZRlClSjmoGsH7RCwW49ChQ+jv78cLL7yAy5cv4/Lly3j99derRrDKlsJisdDe3o7+/n789//+3yEQCMBgMPAnf/In+O53v4toNPpQjBuqUqUcVLQRrKmpgVqtxrFjx6BWq1EqleDz+TA0NASbzQar1bplxyaRSHDo0CE0NjZCIpGgra0NAoEAw8PDWFlZQTwer+62q5QdgUAAmUyGRx99FO3t7cjn8wgEAvD5fPD7/b8Sg6irVNlIKtYIMhgM6PV6tLS04Bvf+AZaWlpQKpUwOzuLH//4xwCwpUZQJBJh9+7d0Gg0EAqFaGhogE6ng8FggEQiQTKZ/JUzgquHfq7+O+FhPF9yHgwG45ahpqv/Tma9VboBEQqFUCgU2LVrF5qampDP5+H3+zE7O1s1glU2nJufm5shz04lU5FG0GAwoKGhAZ///Oexa9cu6PV6+mUKBAI0NTVt2YgOJpMJk8mExsZGCIVCOvzW5XLBarVieXkZgUDgV0b9XaVSQSqVQiKRQCAQoKamBiKRCDqdjt78iUQCyWQSH3/8MVZWVh6ac2ez2di5cye0Wi06Ojqg0WjQ0tICi8WC6elpADdGwoyMjCCVSkEulyMej2N5eZnOPcvn8xXzkDOZTJw4cQIDAwPo7u4Gh8PB1atXMTQ0hJ///Odwu91IJpMPzfWpUrkwGAxwuVx0dnbixIkTAG4YPL/fj0wmA5FIhGQyicnJSaTTafonk8kgEolUVDi+4owgg8GAQqGA2WxGd3c3+vr6wOPx6ELDYrHWGJ+tOD65XA65XA4ul0uLDsLhMBYXFxEOhx+qKdCrYbFYYDKZ4HA4YLPZYLPZqKmpgUajgUKhgEgkQkNDA2QyGYxGIzWCsVgM0WgUMzMzyGaziEajFT/uisFggM1mo6mpCU1NTdixYwdqa2vR19eH8fFxiEQiOt+STPdWq9UIh8PIZDLIZDLIZrPIZrPI5/PIZDIoFovI5XJbcj4sFgscDgctLS3o7++HSqVCIpHA0tISZmZmcP369S05rs2EwWCAyWTSDfLdbEb4fD6YTCaKxSKKxWJFLcYPEwwGAxwOB3q9Hrt376aTMFwuF1KpFKRSKaLRKHK5HJLJJH2Gkskk2Gw2kskkstksCoXCll+DijKCbDYbIpEIO3fuxNe//nU0NTWBy+WucbfJ9PlwOLwlx8hkMqHX62EwGNYYwdHRUfzrv/4r7Hb7lhzXg8Jms2EymaDRaLBt2zaYTCZ0dXVBq9VCoVDQc+VwOPS/BDIVevfu3bDb7fj+978Ph8OB+fn5ivGSbobD4UAikeDll19Gf38/+Hw+PafW1laYTCa6sD7zzDMoFotgs9mIx+Nwu92IxWKIx+NIJpNIJpP48MMP4XQ6MTExgXw+X/bz0ev1qKurw+7du7Fz506w2Wz4fD68+uqrsNlsZT+eciAWi6FSqZBOp9dsvm4Hm83G0aNHodFoEI1G4Xa7MTg4WLH3aCXDYrEglUphMBjQ09MDoVAIPp+PXC6HUqkEFouFQqGAF154AcViEaVSiT4vS0tL8Pv9uHr1Kux2O86cObOlG+aKMoJcLhcajQY1NTWora2FWCwGg8GgOza73Y6lpSV4vV4kEomyHx/xHvR6PfR6PVgsFnK5HBKJBLxeL5xOJ1Kp1D29J5PJBJ/Ph1AohFwup94YmRfndruRzWY31cOQSCQQi8Xo6upCTU0Nent7UVdXh/b2dkilUgiFQpoPi8ViyGazSKfTYDKZdOPC4/HQ2NgIkUiE/v5+uhOMx+OIx+ObduwPAvEkANBwzXqVvTwej/5dKBRCrVZDqVSiUCggnU4jmUzC7XZDIpHA6/UiHo8jGo2W9Tz0ej26u7uh0WggEAhoMYzL5UIoFCrbsZQDEg2qqalBY2MjXRPuBIPBAIvFQmNjI2pqajA1NQU2u6KWv4cOkl8mm2Iulwu3241EIgGlUgkOh0MjKsViETweDzKZDBwOBzqdDtlsFgqFAl6vF8lkEolEgoZMs9ls2WoMKuouUKlUtO2grq6OeoCZTAZOpxN//Md/jGAwiGQyCYfDUfbjIwv+kSNHaM7F7/djZGQEExMTWFxcvOcLx+Px0NLSgq6uLjz55JMQi8UQCoXIZrOIRCL4q7/6K9jtdvh8vk3ZsTIYDPT29qKlpQXf+ta3oNPpIJfLwWQywWQykUgkEIvFkEqlEI/HcfHiRcTjcWQyGYjFYigUCvT29qKxsREKhQJKpRJ/8Ad/gPn5efzf//t/MTo6iosXL274cT8oxWIR6XSaDjBdze0KZIAbGzWJRAKz2YzOzk76gLe2tsLpdEIqlWJ2dhZnzpwpy3mQxf3xxx/Hv/23/5YuLleuXMHY2BhsNts9b8wqHYlEgt7eXuzevRvHjx/HX/3VX2Fubu6OzweLxYJAIMDhw4dhMBjwySefwOVylfGof7XI5XLwer3weDzw+XxIJpPgcrn4wz/8Q4yNjeGpp56CwWBAR0cH8vk8TScolUo0NDRAIpFg9+7diEQiePLJJ7G4uIjR0VHMzc3BZrOVdahwRRhBBoMBPp8PtVqNnp4e1NTU0B16Pp/HpUuXMD8/D4vFglgshnw+vyW9eCwWC1wuF2q1GiqVCkwmE+FwGCMjI3C73XdtAEk8nYQbd+7cCZPJhNbWVggEAnC5XHrjPPHEE5ifn8fJkydp3mmj6OjogNlsxvbt22E0GqHVaiEQCBCLxRAMBuF0OuHz+RAOhxGPx5FKpTA3N4d0Oo1cLgc+nw+xWAy/34/GxkY0NTVBJpNBq9VCq9Vix44diEajuHz5csVVjpL83fDwMJaXl9f87E5GkMPhQCgUYnp6GrW1tWhpaYFGo4FYLIZarUZDQwPC4XDZKkmJESRVoRwOB7lcDk6nE06ns6IKdzYKPp+P+vp61NTUQCqVgsPhfOo5ajQa6PV6ADcKufx+PyKRSNm/GzabDS6Xi97eXuh0OrhcLiQSCfh8PvD5fKhUKurFk7zlasim63bHTao1V+c9NwuSLiDPUqFQQDgchtfrxcjICOx2O7xeL82rS6VSiMViNDc3QyaTQSQS0ffR6XTYt28fTCYTvF4vZmdn4fV6MTY2hkwms2nnAFSIEWSxWFAoFGhsbMQTTzwBtVpNf5bL5fDjH/8Y169fx+zs7JbkWwgcDgcCgQC1tbWoqakBAKysrOC99967ZSG9E0wmE0KhEC+++CK6u7tx4sQJmo9avQAXCgXU1NRgZGQEg4ODKBaLG3pDHDt2DF/84hdhNpshlUrBYrEQj8extLSE4eFhnDx5EgsLC3C5XDTJvR7Nzc2oq6vD008/jZaWFjz22GPQ6XR4/vnnEQqF8OqrrwKorBaKYrGIVCqFt99++55eRxYYEgL6xje+gX379uGxxx6DRqNBb29vWfPVq42gTCYDAKRSKUxPT2Nubq6ivvONQiKRoL+/Hw0NDRAKhXcV1iSeezabhdvtplXc5YbP50MqleIrX/kKHn30UXz44Yew2Wy4dOkS1Go1du7ciWvXruHSpUvIZDK3rHerDc5615bFYtF7M5fLIZvNlsXQk2ONx+MIBoP4+OOPwWazIZPJkMlkaEqEwWDAbDZDqVSivr4eer0e+/fvh9lsRn9/Pz3mixcvYnZ2FouLi58NIyiVSvHyyy+js7OT9t0BN/oA7XY7rFYrVlZWtvyBZrFYtzxw93ODtbe3w2QyYdeuXWhoaACLxUIwGMTy8jJN8pMqzYaGBtTX1+PrX/86Jicncfr0afo7D0o+n0c2m4Xf70coFKLf84ULF+BwODA3N4dwOIxEInHHxDUpi/7ggw8wPz+Prq4uqNVqCAQCqNVqNDc3Y2Vl5VciN7V6J14qlTA8PIx0Oo0dO3ZAoVCU/XjUajW6urpQW1sLALQaz2azwel0bvkzs5GQ4q3u7m7s3r0b0WgUFy9e/NR8IHBjA0sqQ7fKM2YymaitrUVnZyfq6+uh0Wiwb98+9PT0YGBgAAKBAHq9Hp2dnTh8+DA1dGRjTHLyLpcLgUAAgUAACwsL9LmSSqXYs2cPdDodmpub8cknn+DMmTNIpVJb4jwUCoVb1g7SRhGPxxGJRLCwsIClpSXo9Xo0NzfTojSDwQClUolvfvObsFgsOHnyJC1C22gqwghKJBI8++yzMJlMUCqVAG7seJaWljA+Pg673b4lu7abIaGMOzWHfhpkJ9TT04Oenh5otVoAN1osxsfHaTEJSSqTsM/nPvc5KBQKXL9+fcNKu/P5PFKpFHw+H7LZLAYHB2G1WukNd7e5pHA4jHA4jGAwCJvNht/6rd+CWCyGWCymOYB4PP4rYQSBtWGgubk5Wv4tl8vLvsAqFAr09/dDp9MBALLZLC3U8Xg8v1KhUDabjfr6erS0tKC3txeXL1/G8PAw/H7/p752tRHcCojHXlNTg76+PrrIK5XKT71Gq42g1+vF5OQklpaWsLy8vMbT0+l0OHz4MNra2vDII48gnU7jypUrtI2n3JRKpXXbxUikZGVlBQAwNDQEmUyGmpoanDhxAvv27cO+ffvo9zMyMoLr16/T3ONGs6VGkMFgQK1Ww2AwwGAwQKVSAQCtanvjjTdw7tw5+Hy+rTxMADeO9cSJE9i1axc9znuFx+OBz+dj//79OHDgACQSCdLpNJaXl3Hp0iX88Ic/pL00TCYTAoEAwWAQZrMZTzzxBOrr66HVammM/UF57733MDQ0RHfHgUAAyWQS0Wj0vkqW0+k0gsEgzp49i0AggCNHjkChUKC9vR1Op/OhbR9ZD6FQCLFYjC996UvYvn07MpkMZmdnMTU1VdbzJAIGYrEYALC0tASr1Qqfz4d4PP4rZQR5PB62b9+OxsZGWCwWXL16Fb/4xS/uan0wm83YvXs3JBLJlhQKkX66xx9/HEePHqWbFgA0l1YoFNZ97lYbwWw2C41GA6lUivb2djz++OPU2+dyuTAajfReeJhIJBKw2+145513cOXKFcRiMXR2dsJsNmPXrl34zne+g5MnT+J73/vehn/2lhtBhUIBjUZDy+wBUO/EarViZmZmS/OA5DhZLBaamprQ19cHgUBAWxhyudxdq/KLRCJaPNHY2AgOh4NkMgmn0wmr1YrJyUmkUikaA+fz+RgZGaG9alKpFHK5/K52vneDzWbb0B4y0jKwuLgImUxGFX7UajX4fP6GfU654fF4YDKZtFeS9EjJ5XIayvJ6vfD7/XA6nQgEAmUzPlwuF0qlEnw+n4bLQqEQLV76VYHk0urr66FQKOimymazfeqGjcFgQCaT0crZcuXJVkOkFZuamtDc3AzghlEjz4zL5bptK9RqI0hgs9kQCARoa2uDVCoFm82mv0fek/Tsbda5ktw4i8V64M8g6ktLS0twu92YmpoCl8tFbW0tRCIR9u3bB7vdDqVSSdfIjQr1b6kRZLPZePLJJ9Hf3w+BQED/PZvNIhaLVcyDLBaLIZPJ0NTUBLPZDB6PRxf7mZkZTE9P31Xy9vjx4/j85z+P7du3Q6lUIpfLwW6344c//CEsFgui0eiamymTyeCTTz5BMBjEV7/6VYjFYuzduxfJZLJivap0Ok1bIorFIs1zkDzvwwabzcaePXtQW1uLnTt3QqPRoLGxEVwuF1wul1YJ//znP8fMzAzef//9svawKpVK7Nq1i4bVfxVhsVg4cuQIOjs78eSTT8LlcuFv/uZvMDc396kbZFIkQpq5r127BovFUnaVEg6HA7lcTjeDJJxus9lgsVjwp3/6pwiFQncd7uPz+eDz+fj3//7fY+/evaivrwePxwODwYDH48HQ0BDm5uY+NZ//IOejVquh0+mg0+kQjUYRiUQe+H1zuRzy+Tx++MMfQi6X03a0r33tazhy5AiUSiXeeOMNnD9/HoFAYEOu45YZQZFIBKlUiqamJjQ0NIDNZtPKJ5LwLWfD8Z3gcrkQiUQQiUQQCoVgMpnIZrNYWlqiMkF3utGIF6HX69Ha2gqpVAomk0nDvqTZd71y6Gg0ilgshkKhQAtZKrnYoVQqIZVKIZ1Oo1Qq0Yb6rcrF3A4iSkAUf4g3TzYhxPsnCjlkfqRWq4XJZEIqlaKyZLFYDHNzc1hcXEQoFCrLxo2ILEgkEkilUhpFIdGJu92ZEwEIUvRF8keVdI8xGAxoNBrodDqwWCyk02ksLS3dVZ0AaV0hBog8b+WOLqXTaaysrNCIgUQiAYvFQjKZRCQSwfLyMoLB4F1LLgqFQohEojW/XywWaT54bGwMbrd7064luf8EAgH4fP6G5upKpRKCwSASiQRmZ2fBZrNhtVrBYDDQ0dGB0dFRWK1WxOPxh9sItrW1obW1FY899hhaW1vBZrORTqfh9Xpx/vx5fO9739uwsN+DQkJ6MpkMEokEwI3k7muvvXZXbRtCoRB6vR5NTU1obW0Fg8FAOp3GmTNnMD4+jrGxsdvmKYjxI2OkLl++XPFNvkR39EEKiDYboVAIgUAAuVwO4EaSfrUSDovFglgsBp/Px8rKCrhcLu1tIgUH58+fx6VLl2Cz2RCPx2+b09kMeDwempqaUFdXB5lMRo1gIpFAOBy+64WPzWZDrVZDJBJBLpfD4/EgEAggnU5XjCEkijg6nQ7z8/MYGxvDxMTEXS2Azc3NeOKJJzAwMACtVovBwUFcvny57EbQ6XTipz/9Ke0h3b17N2pqahCNRhEKhRCPx+9Jc5jH40EqlUKpVEKlUtH1c2pqCqdPn8Zf//VfI5VKbZrHS1IC5M9mRD+y2SyuXr2K5eVlxGIxPPbYY3jppZfwyCOPgMPhIBAIbEi/+JYZQbVajfr6egiFQrobj8fjmJubg91uRzgc3nJhVQJpQF09NiSXy9FS5U9Do9HgkUcegclkAovFQrFYRD6fh91uh8PhuOPOnYTdiCdV6aNw2Gw2amtrKzY8RyIQPT09qK2tpT2pNpsNmUyGCvyy2WxIpVIIBAIoFAoa+slkMhgeHsbo6CgmJyexsrJCBRzKeV2YTCaNTHA4HHp/eDwe2Gy2T/VGmUwmNBoN1Go19u7dC4lEQo2gz+eDx+NBLBbD0tIS9ey3AolEAplMhsbGRtTV1dGc0d0+B3K5HM3NzYjFYpiamvpUfdHNolAoIJlM0lqHrq4uAL+sNL4Xz53FYsFgMKCzsxNarRY8Hg+5XA7hcBjDw8OYn59HMpnc1PMkhXur16aNhhQCRSIRzMzMwGg0wuFwQKFQYGBgAOfPn6d9iQ+yYdsyI2g0GtHd3U1zRcQFPnv2LKanpzckvrzRrPZsstksFhYW7qpHqampCb/1W7+FhoYGAKAtDjMzM3dsaGYwGBAKhXSjUGkhxfUg41Wam5sr8nhVKhWam5vx8ssvY+/evVT0YH5+noY42Ww2OBwOlEolRCIRNBoN2Gw28vk8hoeH8cYbb2BiYgJjY2Nbdh4sFgtyuRwSiYR6gcViERaLBSMjI59qtNhsNtra2tDV1YX/+B//IxQKBWQyGTWCRPHjZz/7GbxeLzKZzJZsvnQ6HUwmE3bs2AGj0Uh7Ue920dNqtdi2bRtGRkbW9NSVG/LMO51ODA8P48CBA/f1PiS10t3djWeeeQZmsxkikQjhcBhutxvvvPMOlpeXN73BnERKVtdybAa5XA7BYBBXrlyBTCbDtm3b0NPTg+3bt+PcuXNIpVKIxWIPdL5lN4Kk147c3GRMUqFQQDQahcVioWFQMsNOpVLR0UlEsDoSiZRNmUOn06Gnp4cqcgB31yRP5OBIYQ0517m5OSwvL2N+fv62Dc0sFgsikQif+9zn0N3dDYlEsmZyw8MCaYitlE2NyWTCY489hubmZiiVSip+UFNTQ/NpJBzK4/HAYrEQDocRCATw7rvvwmKxYGhoaMtD9ZlMBvPz8zCbzQiHw3RX3tbWhkQigenp6XXzNEwmkzbXP//886ivr6dix5lMhlabbtu2DWazGfl8HrOzs3jttdcgk8nQ0NBA5bA2Ew6HAx6Ph/3792P//v3weDxYXl7GhQsXYLfb6ZBj4hGTghOyjsjlcvT19aGzsxM8Hg/Ly8u4evXqlom5E/GLpqYmHDx4EFqtlm78A4HAXRl1Ihbw6KOPYt++fRgYGIBcLkc2m8VHH32EmZkZzM/Pl8XQCwQCdHZ2oq6uDsCNKJ7H49lU47u0tIQ333wTHA4HKpUKEokEarWaRhLvl7IbQQ6HQ5PVer2e6v4RrUy32414PE4ld+RyOZqamqjHmE6n4ff7wWAwyqb9p1Qq0dLScs/9NyRkQHrKyLkuLS1hYmICNpvttj1ObDYbYrEYR44cQVtbGwQCwYaUIpcDIr4N3Hg4SM5sq2EwGDAYDNi1axeMRiOkUin92ereTxL2JpuzlZUVWK1W/Ou//istbthqMpkMbDYbXC4XIpEI9RDq6+uRTqfXTL4gEKPR1taGnp4enDhxAmq1GlwuF9lsFolEAgwGAwKBABqNho7IkslkeOONNyCXy9HW1oZ4PF4WIygWizEwMIBjx45hcHAQFosFk5OTCIfDtDSfzWZDoVDQXD0pHtNoNNi7dy+amprAZDLhcrkwOTlZNlHmm2EymeDxeKirq6PV4aVSiQpN3E3DPJvNhsFgwNGjR9HV1YXW1lY6oujixYuYmJigA583Gz6fj6amJmrME4kEgsHgphaFud1unD59Gtu3b8fAwAAkEgmUSuUDR5zKbgS7urrwxBNPYOfOnaipqaEeXj6fh16vx0svvUR34aQwgexUgRsDXO12Oy5fvozTp0/T/OFmIpfLqU7hvUCSxwqFAlqtlp7r7Owsrl69esemXbVajbq6OrS2tqKurg6hUAherxcOh2NLxMPvBnKtDh06hMbGRmSzWbhcLqr2sJWQ4iQSAiQFMclkErlcjnpBpHKXPFi5XA6vvvoqxsfHYbPZtmwRXY9CoQC/349r166hu7ubChTL5XLweDwawiXIZDIoFAo888wz2Lt3L82HulwuXLt2DT/72c/oYvu1r30Nra2tqK2tRSAQgEajQSwWw6lTp8pStd3a2orDhw9jYGCAhqW1Wi2+/e1vAwA9Pw6Hg9raWqo0RdIUQqEQ7e3tcLlc+PDDDzE7O7vpi/SdkMlk6OrqQk9PD1pbWyEUCpHL5TA+Po7R0dFPNVzE462rq8OBAwfoBm5sbAxWqxVXrlzB0tLSlszlYzAYyGQym55vTaVS8Hq98Pl8CIVC6Ovrg1KpxPvvv/9Am+yyG0GlUom2trY1GqEkFCAWi9HZ2UmrnkhzskgkAovFAoPBQDweh0KhQCAQwOzsLPx+/6YbQaFQCJVKte7u+k4QoWxSiUhmIwaDQXg8nnVvGLK71el0MBqNUCqV4PF4cDgc8Hq9dJ5fuVldFLR6Dt9qRCIRZDIZ6urqoNVqactLOp2mY6iIh0VaEspV6EO8cjabvWbAZygUQiaTQSKRgEAgQC6Xo947UeL3+/00L7bVwg2rIe0oKysraGxsBPBLJRvy7Kw+XolEAr1eTyd+EO/P4XBgenoa586do2G7I0eOQK/XQy6XQy6XQyqVwuv1wu12l+XclEoluru7odVqaU8cOX6SUiEtLLW1tVS3NZ/PQ6PRgMPhQKvVIhqNIhwOb/gElnuFz+ejtrYWGo0GMpmMTlT3eDzrtkfdDJnBR2aZkmfIZrNhZmYGbrcboVBoyyJF91rgcz+Q6msyc1Cj0aBUKlExi/u9vluSEySLEYHscgQCAXVvWSwWTXjmcjmw2WzI5XI6iiMYDCIcDmNlZWXTH0yDwYDt27dTT+5u4fF4aG1thcFgWPPvkUgEPp9v3QXVaDTCZDLhm9/8JrZt2watVouFhQX83u/9Hmw22y0N9eVCJBKBy+XS4ZkKhWJNoRCDwYDRaITRaIRer4dMJkM+n0d7eztefvllBINBxONxWsk2OjqKUCh0R6WMjSSRSGB+fh6vvPIKxsfH6fSBpaUlRKNR+Hw+KBQKdHZ2YteuXThw4ADq6+shlUrxjW98A3Nzc/ijP/ojWjhSKRDFIRIdaGxspOkG0kxM7pft27fj6NGjqKurQy6Xw8jICGZnZ/G9730PHo8HHo+HbnAuX76MXC6H5557DlqtFh0dHXRafTmora3FoUOH6HpAcriTk5MIhUKw2Ww0L7i6D1UqleLFF1+EUqmEVCql0yZItSRpIC83SqUSe/bsgdFoBAA4HA44nU5MTU1hYWHhjpsrHo8Hs9mMv/3bv4XRaASDwUAwGITf78crr7yCM2fOIBAIbJmXWyqVoFAoUF9fv+mFMqvR6XQQCASor69HsViE2+2+r7WxrEaQlPeuV1a7+v9jsRhisRicTifNdwiFQvT394PP51NjVK7dHRmhdK+QvCaZm0UgvX+rIT1rzc3NaG9vR1NTE/R6PTKZDEKhEJaXl+mMsc2CzDlUKBQQCAQQiUS0kZoU5nC5XPB4PCiVyluMIFGP4PP5tBVEqVSivb0d0WgUqVQKXC4XuVwOHA4HoVAIDocDqVQKyWQSLpdr07x6Um7t8/kwNzdHj9HpdNJ8Bsk1EW9KIBBAIBBAq9UimUxCr9fT96gUstksgsEgUqkUGAwGuFwunboeDofXeAcKhYKG9Yk3TETPV+vFMplMek0YDAZ4PB60Wi08Hk/ZzisSicBqtcLtdoPD4WBlZQWRSARzc3P0vrl5wSNaxIVCAblcDh6PB8lkErFYDAwGgzaolxvSWE7kA4lS1OzsLCKRyB2LSZhMJnQ6Herq6tDQ0EBz18lkEn6/Hz6fb0sNIIA19105v9+b29bul7IZQbLACgSCdSsdSWjH5XJhdHQUly9fxrlz52CxWMDhcFBfX4//9b/+F53l53K5cPny5S2v0rsTpFDhbnrmjEYjjh07hkceeQS7d++GSqUCi8XC9PQ0ZmZm4PV6N724hM1mQ6vV4vjx4zCbzRgYGKBGnM/n0/45DocDiUSyJjxKINcZuHH+LS0taGpqWvM5RDKKFDmFQiF4PB783d/9HT744INNPUe/37+mt3N1CCcSidA+q5MnT+L3f//3aYsEycWMjo5ifn6+YgqUIpEIJicnack9CQ8dO3YMBoNhjUSYwWBAf38/pFIpisUiEokEbda+U0uFSCQq+5zE8+fPY2FhAUwmk3o+6XQasVjstsNi2Ww26urq8PWvfx3RaBTXr1+Hx+OB0+lEKpWCQqG4q9mDGwmpECd1BQKBAKFQCG+++SY+/vhj2vN4O7hcLo4ePYqenh46ngwAvF4vxsfHtzTPCfzy2SfaruX8fonYfyQSQSKRuO9nsmxHLJfL0dvbi+7ubhgMhjVFJvl8HuFwGHa7HadPn4bVasXs7CzcbjdSqRTa2trQ0tICuVwOJpMJt9sNl8tFJcs2G1L+K5PJaCk2l8uFyWSiP18P0hu0+iYlO1KNRkNzGs3NzWhsbMSePXvQ3NwMqVQKj8eDcDiMkydPYm5ubtO9XjLtuqGhAQcOHIBer6d6hEQ6bHXFZCAQoO0fxFsE1ooCk7wn8XrJrpbL5SKTyaBQKEAsFtObuBwP86flLYhxLpVKuHr1KhgMBo4ePUp7s9LpNJRK5T2NmtpMiMoSmftICkba29vBZrOxf/9+uN1uWK1Wep1WCzLfTR6HhEjL2fdJiiDIZyYSCVr5ud7xMhgMNDY20gHR0WgUc3NzcLvdcDgcNPqy2f1zN8PhcOiUHFJJGYlEqBd3pzAoGaO2c+dOtLS0gMPhIB6Pw+VyYXh4GIODg1vmBJDqZL1eT/9tI7yyO0HWSz6fT+sknE7nA8unlc0I1tTU4Nd//dfR19eHtra2NT/L5XJYXFzEpUuX8Jd/+Ze0aAG4EQ9/7LHH0NfXh7q6OiQSCYyPj2Nubu5TY+kbRTAYhMViQXt7OzWCQqEQfX19VNduPYrFIpVDWn2DaLVaNDQ0oKGhAXq9Hl/60peg1WppvL9UKuHChQuYnJzE3/7t35alJJ/P5+Opp55CV1cXnnvuOWrUiBEn06yTySQtpiCqP6RwCQBtdwkGg7h69Sr9feCGEXzkkUegUCjg9/upnmoqlYLNZtuSXM16kEkDb7/9Nq5cuYKWlha0t7fj0KFD4HK5OHnyJN2gbTWJRALLy8vweDyIRCK0kIpsqIrFIq5cuYKVlZWHqs80lUrd0/fLYrGwd+9e9Pb2Qq/XIxwO4/r163A4HBs6KeVe4fF4aG9vp4O03W43VlZW6J87MTAwgG3btuGZZ56hxTBOpxPnz5/Hu+++i3feeadMZ3EryWQSo6Oj0Ol0ZYuKkLYZsVgMoVCIs2fPYmZmBoFA4IGexbIZQZlMht27d0On063ZiTIYDCSTSXz88ccYHx+nPYIajQY9PT1oaGjAoUOHoNVqMTo6iqWlJZw8eRJTU1NlE/pdWFjARx99BIVCQWPyUqkUzzzzDFpbWyESibCysgKPx4NoNEq9nFKpBIvFAqPRuOZGOXToEDo7OwHcMKZGo5GGOex2O5xOJz7++GNMTU2hVCpBq9WitbUVkUgENpuNVkdtJBwOB2azGSaTCdlsFhaLBRcvXkQwGKQ5WmIMyTxDMg36iSeeQF9fH4AbXvHPfvYzLC8vY2hoiP4+cGOnePHiRfD5fKRSKZp/CwaDWFlZwfLy8oae04MSi8VogVYqlYJYLIZGo6EKJOXMkd0OElo+d+4cMpkMnnrqKTQ3N0Or1UIikVCNSpPJhJ6eHtpY/2lenVKphFarBYvFQjwex8jISMVdHwKZErFr1y60tbXh5MmTmJmZoeLmW0kmk8Hc3BxYLBZ+8pOfwGKxYGZmBrOzs3d8HelpbW5uBpfLRaFQQDwex/LyMs6cOYOlpaXynMBtSKVSmJubQ1NTE83PKpVK1NTUwGAwwOv1briDYjabcejQIfT19UEulyMWi8Hv9z+wDSibERSJRGhtbaWqKcAv48npdBrXrl3DwsICMpkMhEIhNBoNdu7ciW3btmFgYABMJhNvvvkmRkdHcfLkSSQSibKVPJM+KjLAksFgQCQSYf/+/bR4ZXp6moZwiZYkh8OBx+O5RcFhYGDgtp/l9XoxPT2N0dFRzMzMgM1mQ6lUYmBgAE6nE8FgEIVCYcONINEj1Gq1yOfzWFhYwBtvvAGXywW/349gMHhLyMFoNKK9vR2tra3o6+ujeab3338f8/PzmJiYqJjc2f1ACkMSiQSy2Swdh9PS0lJRo6yKxSJGR0exuLgIo9EIoVBIi5s6OjpgMpnQ3t6OVCpFhb5JWHT1TDgCqcQmY6KSySS9tysRMuWlo6MDTU1NeO211zA9PY2VlZUtFwEnRTCFQgFCoRBTU1MYHR391NeRyRlGoxEcDgf5fB6RSISGQre6OCubzVLtY4/HA5VKBalUCq1WC51Oh0AgsGFGkBRUGo1GPPHEEzCbzRAIBLSg7UF7I8tmBBcWFvBnf/Zn2Lt3L44cOXLLEEiv1ws2m43jx4+jr68Pe/bsodVQxJi89957sFqtiEQiZW0KJbuN6elpaDQaNDQ00NyL0WjECy+8gKNHjyKZTNIZiKur7Wpra+/6s5RKJZqbm/Gf//N/RrFYpALaSqUS58+fx9LS0oZNlr+Z1SFbImEXDocRj8fX5Ou4XC40Gg0OHjyIL3/5y2hvb0epVML58+cxMzODkZEReL3eh9oA3o5kMklHJlUSyWQS2WwW3//+9/HWW2/hK1/5CpqamrB7927w+XzodDpaUEKGQtfX14PFYuFrX/savb5EQ/To0aPQ6/WYmZnB+Pg4JicnK2a02c1s376dhkEBYHFxEU6nsyLuv1KphEwmA5fLhVOnTt3Vc6vX61FbW4vu7m46YcfpdOLP//zPYbFYYLPZKma4gM/nw8WLF7F3717U1tbi6aefhtlsxl/8xV88sKFmMBgQi8UwmUz49V//dXR1dWHv3r2YnZ3F+fPn8cknn2B2dvaBHYKyGcFIJIIrV65Aq9Vi//79EAqFtNWByWRCIpFAIpGgq6sL/f392LlzJxUHDgQCCAQCWFxchNvtLns1VDqdpmXZS0tLVKaJz+fTOYOrE8LFYpFOwUin02tEwkkImHBzIplUkqnVajoIlDxICoWCFqlsJkwmk7YUkD/kWHk8HiQSCYxGI5qbm9HT00PHC1mtVszMzMDv92+pTBop4iDf04M8JDcn+/P5/AML9m4GpJF4bm4OLpcLO3bsQKFQQEtLC535tvo7yefztJezr6+PbtjUajWUSiUMBgP4fD7sdjuWlpaoqEAlQTyEuro6dHZ2olgsIhQKIRQKIRaLVYQRBG6sB/eS45TJZDCZTFCr1ZBKpUin0wgGgxgaGoLL5aqY3DkAWtFP2p+IaINKpUIymUQymbyn60CiExwOBxwOB3V1dWhpaaFhfaFQCK/Xi8nJSTgcjrua4vNplM0IhsNhXLx4kXo6vb29VHxVr9fjBz/4AQDQPjSSt8jlcvjwww8xMTEBq9W6JTH+TCaDbDaLH/3oR3jnnXfw0ksvUVknMs15NQwGAzKZjBo9kn8hNwXZAKxXTiyRSOhsMOLqh0Ihqg24srKyqQ8BUVapra3F7t27MTIyQg0aj8fDwYMH0dbWhi984QvQ6/VQqVSw2+1wuVx49dVXMTY2tuUPKWmUrq2tRbFYxLVr15DL5ahiz92Kn3O5XKrZWsmzEVdDirF++MMf0jx6e3s7Hn30UWi1WprTZrFYqK2thV6vR0tLC/1OyLSSlZUVzM/P43//7/+NxcXFivE8VkOqrA8fPoynn34a3//+9zE+Po6pqaktvwcfhJ6eHnzpS19CU1MTSqUSrly5gsnJyS1b/+4EyVPGYjEwmUw0NTVBpVLhy1/+Mqanp/Hmm2/S6NjdIJVKIZFI0NraCqPRiG9961vQ6XSQSqVYWFjAz372M3zwwQe4evXqhhUMls0Ikt1QLBZDMBhcs6tks9l0pA0AWlYfDocRiUQwNTWF2dlZpNPpLdHGI8aMDBsdHx9HMpmk0m9E1onkO0kbBIPBQD6fRzKZRDAYRCgUQiQSoR4u2e1IJBIa4iSz20iBTS6XQyQSwejoKK2g3AxPuFAowOl0QiwWQ6fTQaFQoLu7G5lMhuaMRCIR+vv7YTabUV9fDzabjWAwiPn5eczNzcHpdCIUCm1ZHoZ4Og0NDTCZTDAajSgUCmtyerlcjnrouVyO7lSJitHqfkilUkmHlvL5fNryEo/HK84rWg3xiEgIP5vNQigUQqfTQa1W03yhTCYDm81e0/Pp8Xjg9/thsVjgcDjobrtSvKrViMViGAwGqi3qdDphsVi2bJ14UIj6jVwuh8FggEAgQLFYxOLiIhYWFiryvIhsn9PphMPhoNeivb0dDAYDIyMj8Pv9t62EJd48abcibSHNzc0wGAyora0Fn8+Hx+OB1WrF6OgolpeXN7Q/suyyabFYDA6H4447tVQqhUgkgtOnT2NiYgKvvPIKXC7Xlt8A6XQa6XQaP/nJTyASiXDy5EkolUrU1tbCaDRSz5bD4WBgYAA8Hg/hcBhTU1N49913qeo/WYR4PB6tmvV6vRgdHaXtIcTgkv7A1X82g2Qyiddffx19fX1obW2lqjWk4EIikUAsFmPXrl1UQm1hYQHXr1/Hz372M5w7d45WkG4VPB4PIpEIL730Ep566iloNBpks1mcOnUKxWIRMpkMkUgEwWAQy8vLtAgpn8/DbDZDqVRSqTSpVIqdO3fSwoRSqYR0Or1Gs7aSIYbwk08+wfnz5/Hqq69CoVBALpfj8OHDtNKO/Bvhgw8+wFtvvYWpqSkEg0EEg8GK0ktdTV1dHR577DFotVqk02lMTExgZGRky4th7hculwuZTIaamho0NjZCJBIhk8ngvffew9jYWEV64z6fD36/H2KxGNFoFC+88AIaGxvx9NNPY2BggLbovPXWW+u+nsViQSaTob6+Hv39/Th+/Dj27NlDN2jJZBIWiwU/+9nPMDIygo8//njD18GyG0Gv14vr169Do9Egk8mgpaUFIpEIHA6HNv4uLi5ibm4O169fx+LiYtkLYT4N4t0RmS+igTk3NwfgxoWdn5+nF5H8jHiDxCths9lUwioajcJut9PQK/FeyrUAkYpQBoOBU6dOQa/Xw2g0QqvVQigUgsfj0T/JZBKTk5OYnp7GhQsXsLS0RJuZtxIyTohM7hAIBOBwODTcJxAI6ODcmpoaxGIxtLe3o1AoQKvVQiQSQaVSUbk04gECN/rxxsbGMDs7i3A4vGWT1u8VUklMFo5UKoXr16/DbrfD7XZTgXfiCV64cAHz8/Pw+/1IJBIV9dwRSJVuU1MTtm/fTodxb2UUYiOQSqXo7u6m3o/P54PX64XX6y3b2Lh7hUTJlpaWwOVyUVdXh2g0is7OTshkMjo2ihQtra6JKJVKtE1KpVJR3WQWiwWv14tkMomxsTHY7XYMDQ3BZrNtyhpTdiO4uLhIF/ulpSW89NJLMBqNYLPZiMVimJiYwNmzZ/Hee+9tqpbkg0IU3O+Hm+P6k5OTG3FID0Qul8PY2BicTicKhQJ27tyJp59+GgaDgeaRVle6/eIXv8Dw8DBOnz5NKxO3GhLOlEgkkMvlNLzU29t7T++zXv4vHo/jo48+wtjYGHw+X0UuSLejWCwik8lQHVqn07nVh/RACAQCNDQ0YGBgAEePHsWPfvQjfPzxxxXRt/kgqNVqHDx4kI5aGhoawtTUFE0zVDJTU1OYmZkBj8ejouVKpRJHjx5d83s3Fwbe/LNwOIxoNIrp6WnY7Xb8+Mc/htvtpoLpm0HZjSAZrzM5OQmPx4OlpSUqvUU8QZfLhZWVlYqa3fZZgXg8KysrGB8fh9lsplMwiFwamWHn8/moOn8lQKp4L1y4AOCXSfa+vj5wudy7lnUiOWmLxQKPx4OZmRmsrKzg1KlTv7KtHw8TIpEIXV1d0Gg0SKVSVBbuYfHOb4dcLse2bdtofUQ8Hkc4HK5Ib3w9isUiVelJJBLQarVoamqC0WhEd3f3muemWCwiEAggkUjQXmS73Q6Px4NAIEAdoMXFxXuuML1Xym4Eifu8vLyM5eVlXL9+vdyHUOUOpNNpLC4uYnFxEZcvX6ZyT8AN40DG9tzv2JLNJJfL0WhCPp+HTqejD+JqabdPI5vNIpPJ0IKfTz75BC6XCxaLpWIM/mcZPp+P+vp6yGQymqd1u90VEY14ECQSCZqbm2nkJZ1OU3GDhwWLxYKlpSUEg0Ho9Xrs378f6XR6TQUycGNDTSZgTE5OYnFxESMjI3A4HPD5fIhGo2WrLyi7EazycGGz2WgpMgmH5vP5ijOAAGj7w/Xr1zEzM0PnH/74xz++p95KIkUWDofXDN6t1PP+rEH6yKLRKGZmZmgF61YWZT0IpBKZ5KOJxqvX662oxvi7pVAoYHl5GSsrK1hcXMQbb7yB7373uwB+GQ4lhWakKp5MCCE1EeU0/FUjWOWOkN7Gh4VSqUQbpgmfptNY5eGCCBZ4PB4UCoV1Jf0eJsj4MTIcmBiJWCyGQCDwUHmCwI1nkKwblZ7LBKpGsEqVKg8ZTqcT3//+92lfaKU1kN8r+Xye9hCTiAMAzM3N4cqVKw914//DQNUIVqlS5aGCCGn8KpHL5RAKhTA1NUVz2aFQqKyDAj6rMO6U42AwGNUESJUqVaqUAZVKhY6ODrS1taG9vR3/8i//gtHR0WoeegMolUq3LQuveoJVqlSpUgGkUik4HA7kcjk6eb5qADefqidYpUqVKlV+pbmTJ3jn8dJVqlSpUqXKrzBVI1ilSpUqVT6zVI1glSpVqlT5zFI1glWqVKlS5TPLHQtjqlSpUqVKlV9lqp5glSpVqlT5zFI1glWqVKlS5TNL1QhWqVKlSpXPLFUjWKVKlSpVPrNUjWCVKlWqVPnMUjWCVapUqVLlM8v/D/UrFxj3KGkSAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1: E999 SyntaxError: invalid syntax\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 9;\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": "53db5ac7",
   "metadata": {},
   "source": [
    "### Setting up a `DataModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45817f7f",
   "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": 10,
   "id": "4a896220",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 10;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/datamodule_mnist_basic.py\\nfrom torch.utils.data.dataset import random_split\\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.MNIST(root=self.data_path, download=True)\\n        return\\n\\n    def setup(self, stage=None):\\n        # Note transforms.ToTensor() scales input images\\n        # to 0-1 range\\n        train = datasets.MNIST(\\n            root=self.data_path,\\n            train=True,\\n            transform=transforms.ToTensor(),\\n            download=False,\\n        )\\n\\n        self.test = datasets.MNIST(\\n            root=self.data_path,\\n            train=False,\\n            transform=transforms.ToTensor(),\\n            download=False,\\n        )\\n\\n        self.train, self.valid = random_split(train, lengths=[55000, 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 = \"# %load ../code_lightningmodule/datamodule_mnist_basic.py\\nfrom torch.utils.data.dataset import random_split\\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.MNIST(root=self.data_path, download=True)\\n        return\\n\\n    def setup(self, stage=None):\\n        # Note transforms.ToTensor() scales input images\\n        # to 0-1 range\\n        train = datasets.MNIST(\\n            root=self.data_path,\\n            train=True,\\n            transform=transforms.ToTensor(),\\n            download=False,\\n        )\\n\\n        self.test = datasets.MNIST(\\n            root=self.data_path,\\n            train=False,\\n            transform=transforms.ToTensor(),\\n            download=False,\\n        )\\n\\n        self.train, self.valid = random_split(train, lengths=[55000, 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": [
    "# %load ../code_lightningmodule/datamodule_mnist_basic.py\n",
    "from torch.utils.data.dataset import random_split\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.MNIST(root=self.data_path, download=True)\n",
    "        return\n",
    "\n",
    "    def setup(self, stage=None):\n",
    "        # Note transforms.ToTensor() scales input images\n",
    "        # to 0-1 range\n",
    "        train = datasets.MNIST(\n",
    "            root=self.data_path,\n",
    "            train=True,\n",
    "            transform=transforms.ToTensor(),\n",
    "            download=False,\n",
    "        )\n",
    "\n",
    "        self.test = datasets.MNIST(\n",
    "            root=self.data_path,\n",
    "            train=False,\n",
    "            transform=transforms.ToTensor(),\n",
    "            download=False,\n",
    "        )\n",
    "\n",
    "        self.train, self.valid = random_split(train, lengths=[55000, 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"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84e0c986",
   "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": 11,
   "id": "5bef4a20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 11;\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": "98be3b90",
   "metadata": {},
   "source": [
    "## Training the model using the PyTorch Lightning Trainer class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70e8032c",
   "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": 12,
   "id": "ab895891",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 12;\n",
       "                var nbb_unformatted_code = \"pytorch_model = PyTorchModel(\\n    input_size=28*28,\\n    hidden_units=HIDDEN_UNITS,\\n    num_classes=10\\n)\";\n",
       "                var nbb_formatted_code = \"pytorch_model = PyTorchModel(\\n    input_size=28 * 28, hidden_units=HIDDEN_UNITS, num_classes=10\\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": [
    "pytorch_model = PyTorchModel(\n",
    "    input_size=28*28,\n",
    "    hidden_units=HIDDEN_UNITS,\n",
    "    num_classes=10\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e1f1e0b2",
   "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": "bd23ba0b",
   "metadata": {},
   "source": [
    "- Now it's time to train our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "895c30e5",
   "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",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name      | Type         | Params\n",
      "-------------------------------------------\n",
      "0 | model     | PyTorchModel | 135 K \n",
      "1 | train_acc | Accuracy     | 0     \n",
      "2 | valid_acc | Accuracy     | 0     \n",
      "3 | test_acc  | Accuracy     | 0     \n",
      "-------------------------------------------\n",
      "135 K     Trainable params\n",
      "0         Non-trainable params\n",
      "135 K     Total params\n",
      "0.543     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "632418f2dc854242b9ed931df6cb7fbd",
       "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": "3b3fa3d40a6b4363a52ee5dd1eeb65f8",
       "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training took 1.49 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=True,\\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=True,\\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=True,\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": "9a51c407",
   "metadata": {},
   "source": [
    "## Evaluating the model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37158f6b",
   "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": "c45bdb30",
   "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": "fdf88243",
   "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": "754de266",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Restoring states from the checkpoint path at logs/my-model/version_28/checkpoints/epoch=5-step=1283.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from checkpoint at logs/my-model/version_28/checkpoints/epoch=5-step=1283.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "001b40c7001b4c0cab6065218773519f",
       "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.9732000231742859}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'test_acc': 0.9732000231742859}]"
      ]
     },
     "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": "58194874",
   "metadata": {},
   "source": [
    "## Predicting labels of new data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4628738b",
   "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": "01989054",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logs/my-model/version_28/checkpoints/epoch=5-step=1283.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": "af8beaa2",
   "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": "22b5fe2a",
   "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": "ae01649e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3, 4, 5])"
      ]
     },
     "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": "5dd0d4c5",
   "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": "95a755b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.9732 (97.32%)\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": "3ba5a7ab",
   "metadata": {},
   "source": [
    "## Inspecting Failure Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4a4ae96",
   "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": "00a63e89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 21;\n",
       "                var nbb_unformatted_code = \"# In the case of MNIST, the class label mapping\\n# is relatively trivial\\nclass_dict = {0: 'digit 0',\\n              1: 'digit 1',\\n              2: 'digit 2',\\n              3: 'digit 3',\\n              4: 'digit 4',\\n              5: 'digit 5',\\n              6: 'digit 6',\\n              7: 'digit 7',\\n              8: 'digit 8',\\n              9: 'digit 9'}\";\n",
       "                var nbb_formatted_code = \"# In the case of MNIST, the class label mapping\\n# is relatively trivial\\nclass_dict = {\\n    0: \\\"digit 0\\\",\\n    1: \\\"digit 1\\\",\\n    2: \\\"digit 2\\\",\\n    3: \\\"digit 3\\\",\\n    4: \\\"digit 4\\\",\\n    5: \\\"digit 5\\\",\\n    6: \\\"digit 6\\\",\\n    7: \\\"digit 7\\\",\\n    8: \\\"digit 8\\\",\\n    9: \\\"digit 9\\\",\\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": [
    "# In the case of MNIST, the class label mapping\n",
    "# is relatively trivial\n",
    "class_dict = {0: 'digit 0',\n",
    "              1: 'digit 1',\n",
    "              2: 'digit 2',\n",
    "              3: 'digit 3',\n",
    "              4: 'digit 4',\n",
    "              5: 'digit 5',\n",
    "              6: 'digit 6',\n",
    "              7: 'digit 7',\n",
    "              8: 'digit 8',\n",
    "              9: 'digit 9'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e85d1736",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\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": "f4c169e3",
   "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": "b4e18658",
   "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": {
      "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": "561c80ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matplotlib       : 3.3.4\n",
      "numpy            : 1.22.0\n",
      "torchmetrics     : 0.6.2\n",
      "torchvision      : 0.11.2\n",
      "pytorch_lightning: 1.5.1\n",
      "torch            : 1.10.1\n",
      "pandas           : 1.4.1\n",
      "sys              : 3.8.12 | packaged by conda-forge | (default, Oct 12 2021, 21:59:51) \n",
      "[GCC 9.4.0]\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
}