{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Training and testing" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Imports\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import pandas as pd\n", "import torch\n", "from torch import nn\n", "from torch.nn import functional as F\n", "from torch.utils.data import DataLoader, random_split\n", "from torchvision import datasets, transforms\n", "import torchmetrics\n", "from lightning.pytorch import LightningModule, LightningDataModule, Trainer, callbacks\n", "from lightning.pytorch.callbacks.progress.rich_progress import RichProgressBarTheme\n", "from lightning.pytorch.loggers import CSVLogger\n", "import onnxruntime" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Lightning module. Model with its usage\n", "class MNISTModel(LightningModule):\n", " def __init__(self, in_dims, num_classes, learning_rate=1e-3, hidden_size=64):\n", " super().__init__()\n", "\n", " # Set our init args as class attributes\n", " self.loss_fn = F.cross_entropy\n", " self.metric = torchmetrics.Accuracy(task=\"multiclass\", num_classes=num_classes)\n", " self.learning_rate = learning_rate\n", " self.save_hyperparameters()\n", "\n", " # Define PyTorch model\n", " channels, width, height = in_dims\n", " self.model = nn.Sequential(\n", " nn.Flatten(),\n", " nn.Linear(channels * width * height, hidden_size),\n", " nn.Hardswish(),\n", " nn.Dropout(0.1),\n", " nn.Linear(hidden_size, hidden_size),\n", " nn.Hardswish(),\n", " nn.Dropout(0.1),\n", " nn.Linear(hidden_size, num_classes),\n", " )\n", "\n", " def forward(self, x):\n", " logits = self.model(x)\n", " return torch.softmax(logits, dim=1)\n", "\n", " def training_step(self, batch, batch_idx):\n", " x, y = batch\n", " logits = self.model(x)\n", " loss = self.loss_fn(logits, y)\n", " preds = torch.argmax(logits, dim=1)\n", " metric = self.metric(preds, y)\n", "\n", " self.log(\"train_loss\", loss, prog_bar=False, on_step=False, on_epoch=True)\n", " self.log(\"train_metric\", metric, prog_bar=False, on_step=False, on_epoch=True)\n", "\n", " return loss\n", "\n", " def validation_step(self, batch, batch_idx):\n", " x, y = batch\n", " logits = self.model(x)\n", " loss = self.loss_fn(logits, y)\n", " preds = torch.argmax(logits, dim=1)\n", " metric = self.metric(preds, y)\n", "\n", " self.log(\"val_loss\", loss, prog_bar=True)\n", " self.log(\"val_metric\", metric, prog_bar=True)\n", "\n", " def test_step(self, batch, batch_idx):\n", " x, y = batch\n", " logits = self.model(x)\n", " loss = self.loss_fn(logits, y)\n", " preds = torch.argmax(logits, dim=1)\n", " metric = self.metric(preds, y)\n", "\n", " self.log(\"test_loss\", loss, prog_bar=True)\n", " self.log(\"test_metric\", metric, prog_bar=True)\n", "\n", " def predict_step(self, batch, batch_idx: int, dataloader_idx: int = 0):\n", " x, y = batch\n", " logits = self.model(x)\n", " return torch.softmax(logits, dim=1)\n", "\n", " def configure_optimizers(self):\n", " optimizer = torch.optim.AdamW(self.parameters(), lr=self.learning_rate)\n", " return optimizer\n", "\n", "\n", "# LightningDataModule. Data management\n", "class MNISTData(LightningDataModule):\n", " def __init__(self, data_dir=\"./\", batch_size=64, num_workers=4):\n", " super().__init__()\n", " self.data_dir = data_dir\n", " self.batch_size = batch_size\n", " self.dims = (1, 28, 28)\n", " self.num_classes = 10\n", " self.num_workers = num_workers\n", " self.transform = transforms.Compose(\n", " [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]\n", " )\n", "\n", " def prepare_data(self):\n", " # download\n", " datasets.FashionMNIST(self.data_dir, train=True, download=True)\n", " datasets.FashionMNIST(self.data_dir, train=False, download=True)\n", "\n", " def setup(self, stage=None):\n", " # Assign train/val datasets for use in dataloaders\n", " if stage == \"fit\" or stage is None:\n", " mnist_full = datasets.FashionMNIST(\n", " self.data_dir, train=True, transform=self.transform\n", " )\n", " self.mnist_train, self.mnist_val = random_split(mnist_full, [55000, 5000])\n", "\n", " # Assign test dataset for use in dataloader(s)\n", " if stage == \"test\" or stage == \"predict\" or stage is None:\n", " self.mnist_test = datasets.FashionMNIST(\n", " self.data_dir, train=False, transform=self.transform\n", " )\n", "\n", " def train_dataloader(self):\n", " return DataLoader(\n", " self.mnist_train,\n", " batch_size=self.batch_size,\n", " shuffle=True,\n", " num_workers=self.num_workers,\n", " )\n", "\n", " def val_dataloader(self):\n", " return DataLoader(\n", " self.mnist_val, batch_size=self.batch_size, num_workers=self.num_workers\n", " )\n", "\n", " def test_dataloader(self):\n", " return DataLoader(\n", " self.mnist_test, batch_size=self.batch_size, num_workers=self.num_workers\n", " )\n", "\n", " def predict_dataloader(self):\n", " return DataLoader(\n", " self.mnist_test, batch_size=self.batch_size, num_workers=self.num_workers\n", " )\n", "\n", "\n", "# Plot loss and metrics after training and validation\n", "def plot_training(trainer: Trainer):\n", " metrics = pd.read_csv(\n", " f\"{trainer.logger.log_dir}/metrics.csv\",\n", " usecols=[\"epoch\", \"val_loss\", \"val_metric\", \"train_loss\", \"train_metric\"],\n", " )\n", " metrics.set_index(\"epoch\", inplace=True)\n", " val_metrics = metrics[[\"val_loss\", \"val_metric\"]].dropna(axis=0)\n", " train_metrics = metrics[[\"train_loss\", \"train_metric\"]].dropna(axis=0)\n", " metrics = train_metrics.join(val_metrics)\n", " metrics.plot(\n", " subplots=[(\"val_loss\", \"train_loss\"), (\"val_metric\", \"train_metric\")],\n", " figsize=(8, 6),\n", " title=\"Training results\",\n", " ylabel=\"Value\",\n", " )" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "/home/nirogu/.local/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: UserWarning: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", " warning_cache.warn(\n", "Running in `fast_dev_run` mode: will run the requested loop using 3 batch(es). Logging and checkpointing is suppressed.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "----------------------------------------------\n", "0 | metric | MulticlassAccuracy | 0 \n", "1 | model | Sequential | 55.1 K\n", "----------------------------------------------\n", "55.1 K Trainable params\n", "0 Non-trainable params\n", "55.1 K Total params\n", "0.220 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8343f81a58114187b2f0b23668fbfbfc", "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": "c2c455b641b643078a6b0ec4b47176f9", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_steps=3` reached.\n" ] } ], "source": [ "PATH_DATASETS = \"data\"\n", "BATCH_SIZE = 256 if torch.cuda.is_available() else 64\n", "\n", "# Instanciate lightning objects\n", "fashion_mnist = MNISTData(PATH_DATASETS, BATCH_SIZE)\n", "model = MNISTModel(fashion_mnist.dims, fashion_mnist.num_classes)\n", "# model = torch.compile(model, mode=\"reduce-overhead\")\n", "\n", "# Tune hyperparameters (find batch size and learning rate). Doesnt seem to work well atm\n", "# trainer = Trainer(accelerator='auto', auto_lr_find=True, auto_scale_batch_size='binsearch')\n", "# trainer.tune(model, fashion_mnist, lr_find_kwargs={'early_stop_threshold': None})\n", "\n", "# Check everything works (fast run to check nothing crashes)\n", "debugging_epochs = 3\n", "trainer = Trainer(\n", " fast_dev_run=debugging_epochs,\n", " accelerator=\"auto\",\n", " log_every_n_steps=debugging_epochs,\n", ") # profiler='simple', callbacks=callbacks.DeviceStatsMonitor()\n", "trainer.fit(model, fashion_mnist)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Using 16bit Automatic Mixed Precision (AMP)\n", "Trainer already configured with model summary callbacks: []. Skipping setting a default `ModelSummary` callback.\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "Missing logger folder: ./lightning_logs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" ] }, { "data": { "text/html": [ "
┏━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┓\n",
       "┃   ┃ Name    ┃ Type               ┃ Params ┃\n",
       "┡━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━┩\n",
       "│ 0 │ metric  │ MulticlassAccuracy │      0 │\n",
       "│ 1 │ model   │ Sequential         │ 55.1 K │\n",
       "│ 2 │ model.0 │ Flatten            │      0 │\n",
       "│ 3 │ model.1 │ Linear             │ 50.2 K │\n",
       "│ 4 │ model.2 │ Hardswish          │      0 │\n",
       "│ 5 │ model.3 │ Dropout            │      0 │\n",
       "│ 6 │ model.4 │ Linear             │  4.2 K │\n",
       "│ 7 │ model.5 │ Hardswish          │      0 │\n",
       "│ 8 │ model.6 │ Dropout            │      0 │\n",
       "│ 9 │ model.7 │ Linear             │    650 │\n",
       "└───┴─────────┴────────────────────┴────────┘\n",
       "
\n" ], "text/plain": [ "┏━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┓\n", "┃\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mName \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mType \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m┃\n", "┡━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━┩\n", "│\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m│ metric │ MulticlassAccuracy │ 0 │\n", "│\u001b[2m \u001b[0m\u001b[2m1\u001b[0m\u001b[2m \u001b[0m│ model │ Sequential │ 55.1 K │\n", "│\u001b[2m \u001b[0m\u001b[2m2\u001b[0m\u001b[2m \u001b[0m│ model.0 │ Flatten │ 0 │\n", "│\u001b[2m \u001b[0m\u001b[2m3\u001b[0m\u001b[2m \u001b[0m│ model.1 │ Linear │ 50.2 K │\n", "│\u001b[2m \u001b[0m\u001b[2m4\u001b[0m\u001b[2m \u001b[0m│ model.2 │ Hardswish │ 0 │\n", "│\u001b[2m \u001b[0m\u001b[2m5\u001b[0m\u001b[2m \u001b[0m│ model.3 │ Dropout │ 0 │\n", "│\u001b[2m \u001b[0m\u001b[2m6\u001b[0m\u001b[2m \u001b[0m│ model.4 │ Linear │ 4.2 K │\n", "│\u001b[2m \u001b[0m\u001b[2m7\u001b[0m\u001b[2m \u001b[0m│ model.5 │ Hardswish │ 0 │\n", "│\u001b[2m \u001b[0m\u001b[2m8\u001b[0m\u001b[2m \u001b[0m│ model.6 │ Dropout │ 0 │\n", "│\u001b[2m \u001b[0m\u001b[2m9\u001b[0m\u001b[2m \u001b[0m│ model.7 │ Linear │ 650 │\n", "└───┴─────────┴────────────────────┴────────┘\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Trainable params: 55.1 K                                                                                           \n",
       "Non-trainable params: 0                                                                                            \n",
       "Total params: 55.1 K                                                                                               \n",
       "Total estimated model params size (MB): 0                                                                          \n",
       "
\n" ], "text/plain": [ "\u001b[1mTrainable params\u001b[0m: 55.1 K \n", "\u001b[1mNon-trainable params\u001b[0m: 0 \n", "\u001b[1mTotal params\u001b[0m: 55.1 K \n", "\u001b[1mTotal estimated model params size (MB)\u001b[0m: 0 \n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1222340643384bdfb9911fc8707337e1", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Output()" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=5` reached.\n" ] }, { "data": { "text/html": [ "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n",
       "
\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "
"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "DIRECTORY = \"./\"\n",
    "EPOCHS = 5\n",
    "PATIENCE_EPOCHS = 3\n",
    "\n",
    "progressbar_theme = RichProgressBarTheme(\n",
    "    description=\"black\",\n",
    "    progress_bar=\"bright_blue\",\n",
    "    progress_bar_finished=\"bright_blue\",\n",
    "    progress_bar_pulse=\"bright_blue\",\n",
    "    batch_progress=\"bright_blue\",\n",
    "    time=\"red\",\n",
    "    processing_speed=\"red\",\n",
    "    metrics=\"green\",\n",
    ")\n",
    "progressbar_callback = callbacks.RichProgressBar(theme=progressbar_theme)\n",
    "model_summary_callback = callbacks.RichModelSummary(max_depth=2)\n",
    "checkpoint_callback = callbacks.ModelCheckpoint(\n",
    "    filename=\"best_weights\", save_top_k=1, monitor=\"val_loss\", mode=\"min\"\n",
    ")\n",
    "early_stopping_callback = callbacks.EarlyStopping(\n",
    "    monitor=\"val_loss\", mode=\"min\", patience=PATIENCE_EPOCHS\n",
    ")\n",
    "swa_callback = callbacks.StochasticWeightAveraging(1e-2)\n",
    "\n",
    "# Create trainer\n",
    "trainer = Trainer(\n",
    "    default_root_dir=DIRECTORY,\n",
    "    accelerator=\"auto\",\n",
    "    devices=\"auto\",\n",
    "    max_epochs=EPOCHS,\n",
    "    callbacks=[\n",
    "        progressbar_callback,\n",
    "        model_summary_callback,\n",
    "        checkpoint_callback,\n",
    "        early_stopping_callback,\n",
    "        swa_callback,\n",
    "    ],\n",
    "    logger=CSVLogger(save_dir=DIRECTORY),\n",
    "    precision=\"16-mixed\",\n",
    ")\n",
    "\n",
    "# Train model\n",
    "trainer.fit(model, fashion_mnist)\n",
    "plot_training(trainer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ca61c473eabf4f1381c3413db7501265",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃   Runningstage.testing    ┃                           ┃\n",
       "┃          metric           ┃       DataLoader 0        ┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│         test_loss         │    0.3557029664516449     │\n",
       "│        test_metric        │     0.871999979019165     │\n",
       "└───────────────────────────┴───────────────────────────┘\n",
       "
\n"
      ],
      "text/plain": [
       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
       "┃\u001b[1m \u001b[0m\u001b[1m  Runningstage.testing   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m                           \u001b[0m┃\n",
       "┃\u001b[1m \u001b[0m\u001b[1m         metric          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
       "│\u001b[36m \u001b[0m\u001b[36m        test_loss        \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.3557029664516449    \u001b[0m\u001b[35m \u001b[0m│\n",
       "│\u001b[36m \u001b[0m\u001b[36m       test_metric       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m    0.871999979019165    \u001b[0m\u001b[35m \u001b[0m│\n",
       "└───────────────────────────┴───────────────────────────┘\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n",
       "
\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test model (with trainer)\n",
    "checkpoint = checkpoint_callback.best_model_path\n",
    "model = MNISTModel.load_from_checkpoint(checkpoint)\n",
    "test_results = trainer.test(model, fashion_mnist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fccb8696c5754735b4ccbd3926a0a7dd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n",
       "
\n"
      ],
      "text/plain": [
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.871999979019165\n",
      "Balanced accuracy: 0.871999979019165\n",
      "Confusion matrix:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmsAAAHtCAYAAABGTTm8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADKeElEQVR4nOzdd3yN1x/A8c/NJpEhCUFCJEEEEbEqRsxSm6BU7dEaRVGjrVas0KJ2a+/ae1bNmkWNECkROyIyJFZk3fv7I3W5MgjJvTf5fd+v1/N6eZ57nnO/x3nOvd97nhGFSqVSIYQQQggh9JKBrgMQQgghhBAZk2RNCCGEEEKPSbImhBBCCKHHJFkTQgghhNBjkqwJIYQQQugxSdaEEEIIIfSYJGtCCCGEEHpMkjUhhBBCCD0myZoQQgghhB4z0nUAInscNyml6xA+WM3EtboOIXsok3UdQfZIeqLrCD6cibWuI8geCoWuI/hwcdd1HUH2sHLTdQTZQ5Wi6wg+nMJQ1xFkk8pvLSEza0IIIYQQekySNSGEEEIIPSbJmhBCCCGEHpNkTQghhBBCj0myJoQQQgihxyRZE0IIIYTQY5KsCSGEEELoMUnWhBBCCCH0mCRrQgghhBB6TJI1IYQQQgg9lieTtbFjx+Ll5ZVpmbp16zJkyBCtxCOEEEII8b70IllTKBSZLmPHjs3299y8eTPjx4/PtMytW7dQKBRcuHAh3df9/f35/PPPgdQ2bN26NZujzAEGBhQfO4TKVw/yUdwlvIMP4PjtAPXLCiMjSkz6Bq9zO/no0UWq3jpGqSU/YVKk0Du/RbFv+lIzMYSSU7/LiRZkavXqfdSvP4gKFbrRvv0YAgMz/3uEe/acokmTYVSo0I0WLUZy5Mh5LUWavjNn/uXLftOpVWcQZcp2Zf/+f95533/OXcOjfHdatfk+ByPMugWL91HGcwATp2zMtNyylQdp3MIfz6pD8G30HZN+2khCQpKWosxY6jE1mAqe3Wnf4QcCA0MzLLt58xHKuHfWWCp4dtdesBnIyrgICbnHV1/9Qv36gyhT5jOWLdujxUhTnTl3iy+HrqJW058pU+0H9h8O1nhdpVIxc/4Ban3yE561x9F9wDJu3Yl+a72rN/xN/VbTqVBrHO17zCcw6F5ONSHzOHL55xTA6tV/Ur/+11Tw7En7Dj9mOi4Ali3fS+Mm3+BZsSe+dQczKWAVCQmJWoo2Y7mlL/QiWQsPD1cvM2bMwNLSUmPb8OHDs/09CxYsSIECBTJ8PTHx7QfRtm3baNmyZXaGleMcv+mLQ99O3BgyjvOeTbj93c84DutNkQFdATDIb4aFVznuTprLxeqtCe4wkHylXSi7+bd3qt+icgUcenfkWWDw2wtns927TxIQsIoBA9qyZctE3N2L06vXZKKj49Itf+7cNYYNm0O7dnXZunUSDRpUZsCA6Vy7dlfLkb/yPD6BMmWK8+OYrlna7/HjZ4wctYAaH3nkUGTvJ/DybdZuOEaZ0sUyLbdj1xmmzdzGwC+bsnvrGCb6f87uP84xfdZ2LUWavt27TxIweXXqMbV5Au5litOrd8bHFICFRT6OHZ2rXg4dnKnFiNPK6riIj0/A0bEQw4Z1xN7eWrvB/uf5i0TKlHLgx2+apfv6whXHWLnub8aOasH6JX3Jl8+EXoNWZJrc7/7zEgEz9jKgd122rPgS91IO9Bq0guiYpznVjPTjyAOfU7t3nyJg8u8MGNCGLZvH/zcufsqwDTt2nGDatPUMHNCG3bumMHFCb3bv/pvp0zdoOXJNuakv9CJZc3BwUC9WVlYoFAqNbRYWFmn2OXz4MNWqVcPc3Bxra2tq1qzJ7du3NcqsXLkSZ2dnrKys6NixI0+ePFG/9uZpUGdnZ8aPH0/Xrl2xtLSkb9++lCxZEoBKlSqhUCioW7euuvzdu3cJCgqiSZMmODs7A9CmTRsUCoV6HeDXX3/F1dUVExMTypQpw8qVKzViVCgU/Prrr3zyySfky5cPFxcXNm7MfAbiQxT4yJuYHQd4tOcwCbfDiN68l0f7j2NR1ROAlMdPCWraneiNe4i/dpOnpy9wY7A/FpUrYOJUJNO6DczzU3rFNK73+57kR49zrA0ZWbp0Nx061MPPry5ubo74+/fCzMyUTZuOpFt+xYq91K5dkd69W+DqWowhQzrg4VGSVav2aTnyV3zrVOTrIe1o1KhKlvb7cewymjf7CC8vtxyKLOuePX/BN6OXMWHsZ1hZ5s+07PmLN/D2cqFFs6o4FrOllk9Zmn9SmcDLt7QTbAaWLttDh/b18PPz/e+Y6pnpMQWpY9re3lq92NlZaTHitLI6Ljw9XRk5sjPNmvlgYmKk5WhT+fqU5ut+DWlUL+2PD5VKxYq1J+nXsw4NfcviXsqBn8a25WHUE/Yf+TfDOpf+foIOrSvj18IbN5dC+I9qgZmZMZt2nMvJpqSNIw98TqWOi7r4+dXBza0Y/v49/mvDX+mWP38+BG/vUrRo4YOjoz21alWgebMaBF66oeXINeWmvtCLZC2rkpOTad26Nb6+vgQGBnLy5En69u2LQqFQlwkNDWXr1q3s3LmTnTt3cuTIESZPnpxpvVOnTqVixYqcP3+eMWPGcPr0aQD2799PeHg4mzdvVpfdvn07devWxdLSkjNnzgCwdOlSwsPD1etbtmxh8ODBDBs2jMuXL/PFF1/Qo0cPDh06pPG+Y8aMwc/Pj4sXL9K5c2c6duxIcHDOzEw9OXUOq3o1MCvlDEB+T3csfSoT+0f6gwzA0KoAKqWSlNgnGZYBcJ31I492Hybu4InsDPmdJCYmExR0Ex+f8uptBgYG+PiU5/z5kHT3uXAhhBo1ymtsq1XLkwsX0i+vrzZt/ou79yIZOKCNrkPRMG7ienxrl8PnI/e3lq1U0YWg4LsEXroFwN17URw5GoRvrXI5HGXGMjymapTnfCbHyPPnL6hXfxC+db+iX/9phITo5lQbvN+40Hf37j8iMvopPtVc1dsKWJhRsVwxzl9Kf4YjMSmZoH/D8an6ah8DAwN8qrpy/pL2+icvfE6ltuEWPj6vxmbquCjH+Qvpn0KsVKkUQUG31KdK7959yJG/LuJbp6JWYk5PbusL3fxs+kCPHz8mLi6O5s2b4+qaOvjKli2rUUapVLJs2TL1qc4uXbpw4MABJk6cmGG99evXZ9iwYep1Q0NDAGxtbXFwcNAou23bNlq1agWAvb09ANbW1hrlpk6dSvfu3enfvz8AQ4cO5dSpU0ydOpV69eqpy7Vv357evXsDMH78eP78809mz57NvHnzsvC/8m7u/TQfQ0sLvC/9gSolBYWhIbd/mE7kmvRPNylMTXCe9A1R63aS8iTj0wV2HZphXqkcF2u0zfaY38WjR09ISVFia6s5i2Fra8WNG/fT3ScqKjbNrIetrRVRUbE5FWa2u3XrAdOmr2f1yu8wMjLUdThqu/ac5UrwXTauGfFO5Vs0q8qj2Kd81m06KlQkJyvp2L4WX/ZpksORZizDY8rOkhs30z+mSpYsyqSJfSlTxoknT+JZsmQXHTuNZdfOKTg42GojbA3vMy70XWR06ueQbUHNMy62BS2Iik7/M+pR7PPU/4eC5m/sY86N25E5E2h6ceSBz6n3GRctWvjw6NETPus8HpUKkpNT6NixPl9+qbvLiHJbX+j9zNqdO3ewsLBQL5MmTaJgwYJ0796dxo0b06JFC2bOnEl4eLjGfs7OzhrXpBUpUoSHDx9m+l5VqrzbqafHjx9z5MiRt16vFhwcTM2aNTW21axZM82sWY0aNdKsZzazlpCQwOPHjzWWRJXqnWK3a98U+44tudZ1KBertyak1wiKfd0L+y5pZ2UURka4r5kFCgWhA3/MsE4TRwdKTvuea92GodKDC0b/X6SkKBn2za98NbAtJUtmfopam8IfPGLilI38PLk7pqbG77TP32euMX/RH/z43adsXjuKOb/04cjRIObO1/7F7R+iUqVStG5dm7JlnalWrSyzZw+hYEFL1q47qOvQhNCZv/8OZv6CHfz4Q3c2bxrPnNmDOXLkInPnbdV1aLmG3s+sFS1aVONuzIIFCwKppxwHDRrE3r17WbduHd9//z1//vknH330EQDGxppfEgqFAqVSmel7mZubZ/r6S3v27MHDwwMnJ6cstCT7BAQE4O/vr7Gth4ENvQzf/svdOWAk936eT9T6XQA8v3wN0+LFcBzxBZErt6jLKYyMKLNmJqbFi3L5466ZzqpZeJfHpLAdXn9v1djfsnZVivT/nBMW5eAt//cfysamAIaGBmkuDI2OjsPOzjrdfezsrImKevfy+ubZs3guX75JcPBtxk9YAYBSqUKlUuFRvjuLF43QyQ0HQVfuEB3zhLafvrrsICVFyZl/rrN67REunZ2JoaHm78SZc3bSsnk12vul/rgpU7oYz+MT+WHc7/Tr0xgDA+3/rszwmIp6/M7XoRkbG1G2bAnu3I7IiRDf6n3Ghb6zt02dUYuOeUohu1c/yKNjnuJeOv0fLTbW+VP/H2KeaWyPjnmGnW3GN5plt7zwOZX5uEg/ppmzNtKyZU3at68LQJkyTjyPT+CHH5bQ78uW+jW+9bQv9H5mzcjICDc3N/XyMlmD1Av/R48ezYkTJyhfvjy///57tr63iYkJACkpKRrbXz8F+pKxsXGacmXLluX48eMa244fP46Hh+YX6KlTp9Ksv3la93WjR48mLi5OY+liUDDD8q8zyG8GSs1ZOFVKCorXBsvLRM3MzZnLTbqTHBObaZ1xB09yvlJTLlRtqV6enA0kcs12LlRtmeOJGoCJiRHlypXk5Mkg9TalUsnJk0FUqlQq3X28vEpx6tRljW0nTlzCyyv98vrGwiIfO7ZNYuvmCeql46f1KFmyCFs3T6Cip+vbK8kBH1Uvw45N37F1/Wj1Ur5ccVo0q8LW9aPTJGoAL14kpvnANvxv/R0njbNdhsfUqctUesdjJCVFybVrd3V2V+X7jAt951jUBntbC06eeXVx+tOnL7gYFEalCun/gDYxNqKcexGNfZRKJSfP3qBSBcccj1kdRx74nEptgzMnT15Rb0sdF0FUyuAGpxfxiRgYKDS26e341tO+0PuZtfTcvHmTBQsW0LJlS4oWLcrVq1cJCQmha9esPe7gbQoVKkS+fPnYu3cvjo6OmJmZYW5uzp49e9I8TsTZ2ZkDBw5Qs2ZNTE1NsbGx4ZtvvqFDhw5UqlSJhg0bsmPHDjZv3sz+/fs19t2wYQNVqlShVq1arF69mtOnT7N48eIM4zI1NcXU1FRjm4lCkUFpTTG7DuE4qh8Jd+/z/EoI5l4eFBvck4jlqXegKoyMKLNuNhZe5bjSpi8KQwOMC9sBkBwThyop9db4cnuXE73tTx78uoqUp894HqR5gaXyWTzJ0bFptuekHj2aMnLkb5Qv74KnpyvLl+8hPv4Fbdv6AjBixDwKFy7IsGEdAejatQlduoxnyZJd+Pp6sXv3SS5fvsG4cb21FvObnj17wZ07r2Zh7t2LJDj4NlZW5hQtase06euJiHjET1O+wMDAgNKlNb9obG0tMTU1TrNdmyzMzShdqqjGtvz5TLG2slBvH/HtcgoXtmbY4NQfPfV8K7B05UE83B3xrODMnbuRzJy7g3q+FdJN7rSlR/dPGDlqPuXLl/zvmNpLfHzCq2Nq5K8ULmSjPqbmzN2MV0U3SpRw4PHjZyxevIv796PUMwo6aUMWx0ViYjKhoffU/46IiCE4+Bb585tRooRDhu+TnZ49T+DOvRj1+r37jwi+Fo6VZT6KOljTtWMNfl1yhBJOtjgWtWHmbwcoZFeAhr6vbmbp1n8pjep68HmH6qn/D5/5MNJ/C+XLFsWznCPL154kPj6Rts29tdKml/LC51TquFjw37hwYfnyP/4bF3VS2zDyt//GxacA1KtXiaXL9uBRtgSeFV25czuCmbM2Uq9eJd2O71zUF7kyWcufPz///vsvy5cvJzo6miJFijBgwAC++OKLbH0fIyMjZs2axbhx4/jhhx+oXbs2Y8aMwcLCAm9vzQE+bdo0hg4dysKFCylWrBi3bt2idevWzJw5k6lTpzJ48GBKlizJ0qVLNR4BAqkP1127di39+/enSJEirFmzJs3sW3a5OWQcxccOwWXWWIwL2ZJ4/yEPFq3l7oQ5AJgUK4xti4YAVDq7Q2PfSw078/iv1DtkzVyKY2xnkyMxvq+mTWsQE/OYWbM2EhkZS9myJVi0aJT6lFV4eLTG7I23d2mmTh3AjBkbmD59Hc7ODsydO5TSpXVzehvgctBNunYLUK8HTEmdLW7TuhaTA/oSGRlLePjbH/6p78IfPNL4pd2vbxMUCpgxZwcRD+MoaGNBPd8KfP1VCx1G+fKYesKs2RuJjIxLPaYWjnx1TN2PxuC1H0qPHz9jzA+LiIyMw8rKnHLlSrJ2zVjc3HSXPGd1XDx8+IjWrb9Vry9ZsoslS3ZRrVpZVq4co5WYLwffp2u/per1gBl7AWjTzIvJP7alT9daxL9I5IdJ23n89AWVKxZn0cwuGtdI3g17xKPYV6c9mzaqQMyj58xacJDI6KeULe3AopldsLNN+2ionJQXPqeaNv3ov3Gx6b9xUZxFC7/JcFz069cqdXzP3EhExCMKFrSkXj0vvh7SXldNAHJXXyhUKl1NQuZOgwYNIjk5Odvu1FQoFGzZsoXWrVt/UD3HTXLnKY3X1Uxcq+sQsocyWdcRZI+kzB/VkiuYWOs6guzxjjPnei0u8yfD5xpW+vMsww+iSnl7GX2n0J874D9M5beWyJUza7pUvnz5NHdvCiGEEELkFEnWsqhv3766DkEIIYQQ/0ckWdMxOQsthBBCiMzo/aM7hBBCCCH+n0myJoQQQgihxyRZE0IIIYTQY5KsCSGEEELoMUnWhBBCCCH0mCRrQgghhBB6TJI1IYQQQgg9JsmaEEIIIYQek2RNCCGEEEKPSbImhBBCCKHHJFkTQgghhNBjCpX8ccq8QXVW1xF8sACDzroOIVuMVv2u6xCyR8oLXUfw4QxMdR1B9lAodB3Bh8srXzV5oS+Enqn81hIysyaEEEIIocckWRNCCCGE0GOSrAkhhBBC6DFJ1oQQQggh9Jgka0IIIYQQekySNSGEEEIIPSbJmhBCCCGEHpNkTQghhBBCj0myJoQQQgihxyRZE0IIIYTQY5KsCSGEEELoMSNdB5ATFG/5220//vgjY8eO1U4wucjq1ftYvHgXkVFxuLsXZ8z33fD0dE237ObNRxj97QKNbSYmxlwKXKaFSP97Pwtz6owfTOk2DclfyJaI81fYP3gS4WcvAdBsaQCe3dtq7HNj71HWfdI7wzr73TyAtbNjmu3/zF3NvoHjsrcBmUjti51ERv7XF2O64enplm7ZkJB7zJq1gaCgm4SFRTF6dBe6d/9Ea7G+af6CXezb/w83boRjZmZCJS83hg9rh0vJIpnu9/jxc36ZuYk//zxHbNwzihW15dtRnfD19dRS5OnLbeMiI1k5pgD27DnFzJkbCAuLwtnZgeHDO+LrW0mLEaeVlb543a5dJxk6bA4NGlRm3tyhWog0c3mnL96tDevXH2Tr1qOEhNwFoFy5kgwd+mmmbdaW3NIXeXJmLTw8XL3MmDEDS0tLjW3Dhw9Xl1WpVCQnJ+sw2owlJiZq7b127z5JwOTVDBjQli2bJ+Bepji9ek8mOjouw30sLPJx7Ohc9XLo4EytxQvwyaIJODfyYUeXESyu0IKb+47Tcf9SLIoWUpcJ3fMXsxxqqpdtnTL/oF5WtZ1G+TUNuwPw74a9OdkUDbt3nyQgYFVqX2yZiLt7cXr1yrgv4uMTcHQsxLBhHbG3t9ZanBk5ffYqnTvVZ/2a71m6aBjJySn06j2d588TMtwnMTGZHr2nEhYWzcwZ/dm7exLjx3WncGFr7QWejtw4LtKT1WPq3LlrDBs2h3bt6rJ16yQaNKjMgAHTuXbtrpYjf+V9+gLg3r1Ipvy0mipVymgp0szlmb7IQhv+/vsKzZr5sGLF96xd60+RIrb07DmZiIgYLUeuKTf1RZ5M1hwcHNSLlZUVCoVCvf7vv/9SoEAB9uzZQ+XKlTE1NeXYsWMkJCQwaNAgChUqhJmZGbVq1eLMmTPqOpctW4a1tbXG+2zdulVjFu/ixYvUq1ePAgUKYGlpSeXKlTl79qz69WPHjlG7dm3y5cuHk5MTgwYN4tmzZ+rXnZ2dGT9+PF27dsXS0pK+ffvm3H/SG5Yu20OH9vXw8/PFzc0Rf/+emJmZsmnTkQz3USgU2Ntbqxc7OyutxWtkZoq738ccGvEzd4+e5VHoHY75z+HR9dt49/tMXS4lIZFnEVHq5UXs40zrjY96pFHerXk9Hl2/zZ0jp3O6SWpLl+6mQ4d6+PnV/a8vemXaF56erowc2ZlmzXwwMdH9ZPniBUNp26YWpUoVw929OJMn9eR+eDRBV25luM+mzUeJi3vG3NkDqexdCsdidlSrWgZ39+LaCzwduW1cZCSrx9SKFXupXbsivXu3wNW1GEOGdMDDoySrVu3TcuSvvE9fpKQoGf7NXL76qh1OjoUyLKdNeaIvstiGadMG0rlzI8qWdcbVtRgTJvRFqVRx8uRlLUeuKTf1RZ5M1t7FqFGjmDx5MsHBwXh6ejJixAg2bdrE8uXLOXfuHG5ubjRu3JiYmHfP/Dt37oyjoyNnzpzhn3/+YdSoURgbGwMQGhpKkyZN8PPzIzAwkHXr1nHs2DEGDhyoUcfUqVOpWLEi58+fZ8yYMdna5owkJiYTFHQTH5/y6m0GBgb41CjP+QshGe73/PkL6tUfhG/dr+jXfxohIfe0EW5qfEZGGBgZkfxCc7YmOT4Bx1re6vXidasxKOIEff/dS+N5Y8lX0Prd38PYmHKft+Tikk3ZFfZbZdgXPuU5fz7jvtBnT57EA2BlZZ5hmYOHLuBV0ZVxE1bhU3sIzVuO4bf5O0lJUWorzDRy47hIz/scUxcuhFCjRnmNbbVqeXIhk3bnpPfti7lzN2Nra0X7dnW1EOXb5em+yMJnVHx8AsnJyVhZWeRUmG+V2/ri/zZZGzduHI0aNcLV1RVTU1N+/fVXfv75Zz755BM8PDxYuHAh+fLlY/Hixe9c5507d2jYsCHu7u6UKlWK9u3bU7FiRQACAgLo3LkzQ4YMoVSpUvj4+DBr1ixWrFjBixcv1HXUr1+fYcOG4erqiqvr26/FyA6PHj0hJUWJra3mDICtnSVRUelPB5csWZRJE/syb+5Qfv6pPyqlio6dxvLgQbQ2Qibx6TPunThHzTH9sShSCIWBAeU6t6RYDS8siqT+gr6x9yg7uo5kTYPuHBr5M8V9q9Jhz0IUBu922Jdu3RAz6wJcWrYlJ5uiIcO+sLUiKipWa3FkF6VSyaTJa/D2dqN0qbTXAr50914kf+w7S0qKkgW/DaF/vxYsXfYHv/62Q4vRasqN4yI973NMRUXFppkR1OUx+D59cfafq2zcdJjx4zO+RlXb8nRfZCGmqVPXUKiQjUaipG25rS90f85ER6pUqaL+d2hoKElJSdSsWVO9zdjYmGrVqhEcHPzOdQ4dOpTevXuzcuVKGjZsSPv27dUJ18WLFwkMDGT16tXq8iqVCqVSyc2bNylbtmyauDKSkJBAQoLmjJKpSSKmpibvHOuHqlSpFJUqldJYb9psBGvXHWTI4PZaiWFHlxE0WzKJr+4fRZmczINzV7iyZhcOlcsBELxut7ps5OVrRAZepd+NAxSvW43bB0+9tf6KvfwI3fMXT8Mf5lgb8jr/8asICQnj91WjMy2nUqqwLWjJeP/uGBoaUL6cMxERj1i8ZC8DB7TSUrQfTh/GhYCnT+MZMeJXxo/vTUGbAroOR7xmwYLt7N59khUrxmj1Oyu3+7+dWTM3z/iUTHoMDAxQqVQa25KSkjTWx44dS1BQEM2aNePgwYN4eHiwZUvqrMzTp0/54osvuHDhgnq5ePEiISEhGjNo7xJXQEAAVlZWGktAwLIsted1NjYFMDQ0SHNRZXTU43e+3sbY2IiyZUtw53bEe8eRVbE37rK6bhemmnsxx6kuy6u3x8DYiNgb6V/sGXvzHs8jY7BxK/HWui2LF8W5oQ8XF23M7rAzlWFfRMdhZ2et1Vg+1LgJqzh85CLLl43AwaFgpmXt7a1wdi6MoeGrjyQXlyJERsWRmKibG4By67h40/scU3Z21mlmrHR5DGa1L+7ejSAsLJJ+/abhUa4LHuW6sHXbMQ4ePIdHuS7cuaOb/sjTffEOMS1evJMFC7azePFonV+Pmtv64v82WXudq6srJiYmHD9+XL0tKSmJM2fO4OHhAYC9vT1PnjzRuCHgwoULaeoqXbo0X3/9Nfv27aNt27YsXboUAG9vb65cuYKbm1uaxcQka78uRo8eTVxcnMYyenT3rDf8PyYmRpQrV5KTJ4PU25RKJSdPXaaSV6lM9nwlJUXJtWt3dXI3YtLzeJ49iMTM2hKXxrUI2XYg3XIFihUmn601T8Mj31qnZ4+2PH8YzfVdh7M52sxl2BcngzRmbPSZSqVi3IRV/Ln/HMuXjMDJ0f6t+3hXKsWdOw9RKl9do3brdgT29lY6u2kit4+Ll97nmPLyKsWpU5oXf584cQmvd2x3dstqX7i4FGXH9sls3TJJvdSv70316h5s3TIJBwdbbYavlqf74i2fUQsX7mDevC0sWjSSChVctBFqpnJbX0iyRupsVr9+/fjmm2/Yu3cvV65coU+fPjx//pxevXoBUL16dfLnz8+3335LaGgov//+O8uWLVPXER8fz8CBAzl8+DC3b9/m+PHjnDlzRn16c+TIkZw4cYKBAwdy4cIFQkJC2LZtW5obDN6FqakplpaWGsuHTif36P4J6zccYsuWvwgNDWPs2KXExyfQtq0vACNG/sq0aWvV5efM3cyxY4HcvfuQoKCbfPPNPO7fj6J9+7ofFEdWlPy4Fi6Na2Pl7IhzQx8+O7SC6H9vELh0M8bm+an30wiKVq+IVYlilKj/EX7b5vHo+m1u/nFUXUen/cuoPKCzZsUKBZ492nJp+VZUKSlaa89LPXo0Zf361/tiCfHxL171xYh5Gn2RmJhMcPAtgoNvkZiYTEREDMHBt7h9+4HWY4fUU5/bd5xk2s9fYG5uRmRkHJGRcbx48epRNCNGLWTa9Fezlp061iM27hkTJ63h5q0HHD5ykfkLdtG5U31dNEEtN46L9GT1mOratQlHjwayZMkuQkPDmD17I5cv3+Dzzz/WVROy1BempiaULu2ksVgWyI+5uRmlSzvp9K7pPNEXWWzDggXbmTlzA5MmfUGxYvZERsYSGRnLs2cvMnoLrchNffF/e83amyZPnoxSqaRLly48efKEKlWq8Mcff2BjYwNAwYIFWbVqFd988w0LFy6kQYMGjB07Vv14DUNDQ6Kjo+natSsRERHY2dnRtm1b/P39AfD09OTIkSN899131K5dG5VKhaurK59++qnO2vy6pk1rEBPzhFmzNxIZGUfZsiVYtHCk+hRD+P1oDF57TMnjx88Y88MiIiPjsLIyp1y5kqxdMxY3t4wvIs9uplYFqBswlAKODryIieXqpn0c+e4XlMnJGBgZUsizNBW6tcbMugBP7j/k5r7j/DVmJimJr05fW7s6kc/ORqPekg19sCpRjEAt3gX6utS+eMysWRuJjIxN7YtFo171RXg0Bq/dJPHw4SNat/5Wvb5kyS6WLNlFtWplWblSO3cUv27N2kMAdOk2RWN7wMSetG1TC4Dw8BiNNhQpUpDFC4cSMHktLVv/QOHCNnT9vCF9ejfVXuDpyI3jIj1ZPaa8vUszdeoAZszYwPTp63B2dmDu3KGULu2kqyZkuS/0Vd7pi3dvw9q1+0lKSmbQoBka9Qwc2JavvmqnzdA15Ka+UKjevBBL5E6qs28vo+cCDDq/vVAuMFr1u65DyB4puv3Vmy0MTHUdQfbIBUnIW+WVr5q80BdCz1R+awk5DSqEEEIIocckWRNCCCGE0GOSrAkhhBBC6DFJ1oQQQggh9Jgka0IIIYQQekySNSGEEEIIPSbJmhBCCCGEHpNkTQghhBBCj0myJoQQQgihxyRZE0IIIYTQY5KsCSGEEELoMUnWhBBCCCH0mCRrQgghhBB6TJI1IYQQQgg9plCpVCpdByGygeq0riP4cApDXUeQLa7Z+ek6hGxROuJ3XYfw4eKu6zqC7FGwnK4j+HBP7+o6guxh4aTrCLJHXvjqVyh0HUE2qfzWEjKzJoQQQgihxyRZE0IIIYTQY5KsCSGEEELoMUnWhBBCCCH0mCRrQgghhBB6TJI1IYQQQgg9JsmaEEIIIYQek2RNCCGEEEKPSbImhBBCCKHHJFkTQgghhNBjkqz9x9nZmRkzZqjXFQoFW7du1Vk8QgghhBCQh5K17t27o1AoUCgUmJiY4Obmxrhx40hOTtZ1aHrvzJl/+fLLadSq/RVl3Luwf//ZTMs/fBjLsGHzaNz4G9zLdmXipFVaivTtVq/eR/36g6hQoRvt248hMDDjvw0ZEnKPr776hfr1B1GmzGcsW7ZHi5FCyXPHKB11K81SaMo4dRmzKt44bvkdt9tXcL15Cccd61CYmWZYZ74a1Si6ehEul/+mdNQtzD/5WBtNSePM2at82X8GtXy/poxHD/bvP/fWfVb/foBPmn+LZ6W+NG46mq3bjmsh0lfOnL/Dl8PXUavFTMrUmMj+I1fVryUlp/Dz3IO06LwAr3o/UavFTEb4byci8sl716ltWRkbAHv2nKJJk2FUqNCNFi1GcuTIeS1FmlZKipIZ8/6gfovJePp8R8OWU5i7cD+Z/Wnrh5GPGfbtGhq3+Rn3KqOYOHW7FiPOXG7ui5dS2zCYCp7dad/hBwIDQzMt//jxM/zHLaVW7QGUr9CNxo2HceTIBe0Em4nc0hd5JlkDaNKkCeHh4YSEhDBs2DDGjh3Lzz//rOuw3ltiYqJW3ud5fAJl3Ivz4w/d3ql8YmISNgUL0K9fK9zdi+dwdO9u9+6TBASsYsCAtmzZMhF39+L06jWZ6Oi4dMvHxyfg6FiIYcM6Ym9vrd1ggTuNWhLqUVW93GvbGYAn23cDqYlasfXLeHboKHc+bsWdRq2IXbQClBl/QSny5yfhcjAPR/yglTZk5PnzBMqUceLHMZ+/U/nf1x5k2i8b+WpAK3Ztn8Cgga3xH7+Kg4cu5Gygr3n+IpEypQrz47DGaV578SKJK1cf0K9HLTYv68WcgHbcvBNNvxHr37tObcrq2Dh37hrDhs2hXbu6bN06iQYNKjNgwHSuXdPNH2NfuPwwazae4ocRrdi9cRjDB33CohVHWLn2RIb7JCYlY2NjTr9e9XEvXUSL0WYut/cF/NeGyatT27B5Au5litOrd8ZtSExMpkfPyYSFRTFz5iD27pnK+PG9KVzYRsuRa8pNfZGnkjVTU1McHBwoUaIE/fr1o2HDhmzfvp26desyZMgQjbKtW7eme/fu71z3pUuXqF+/Pvny5cPW1pa+ffvy9OlTAPbt24eZmRmxsbEa+wwePJj69eur148dO0bt2rXJly8fTk5ODBo0iGfPnqlfd3Z2Zvz48XTt2hVLS0v69u2b5f+D9+FbpyJfD2lPo0ZV3qm8o6M933/Xhdata1HAIl8OR/fuli7dTYcO9fDzq4ubmyP+/r0wMzNl06Yj6Zb39HRl5MjONGvmg4mJkZajhZToGFIeRqoX848bkHjjFvHHTwFgP2EMsQuW8WjWryReDSHp+g2ebtuFKpMk/vmBw0QHTOPp7j+01Yx0+dbx5OvBfjRqWPmdym/ffoJPO9Sl6SfVcXIqRLOm1fm0vS8LF+/O4Uhf8a3hxtdf1KVRXfc0rxWwMGPprM9o2tADlxK2eJUvxphhjQn69wH3H6T/wf62OrUpq2NjxYq91K5dkd69W+DqWowhQzrg4VGSVav2aTnyVOcv3qZBXQ/q1i6LY9GCNGnoSa2PShMYlPGXpGPRgnz/TUtaN69MAQszLUabudzeFwBLl+2hQ/t6+Pn5/teGnpm2YdPmw8TFPWXunK+p7F0GR0d7qlUri7t7CS1Hrik39UWeStbelC9fvmyZnXr27BmNGzfGxsaGM2fOsGHDBvbv38/AgQMBaNCgAdbW1mzatEm9T0pKCuvWraNz59TZktDQUJo0aYKfnx+BgYGsW7eOY8eOqet4aerUqVSsWJHz588zZsyYD479/0ViYjJBQTfx8Smv3mZgYICPT3nOnw/RYWTvyNgYy/atefx76kyNoZ0t+apUIiUqGqfdm3C5cgbH7eswq/5uCXVuk5iYjKmpscY2UzNjLgXeIClJPy9lePo0AYUCLAvoTyKQnvcZGxcuhFCjRnmNbbVqeXLhgm7GUqWKJTh1OpSbtyMB+Pfaff65cIs6PmV0Es/7ygt9kWEbapTnfAYxHTx4Di+vUowbtwyfmv1o3mIkv/22jZQUpbbCTiO39UWeTNZUKhX79+/njz/+0JjZel+///47L168YMWKFZQvX5769eszZ84cVq5cSUREBIaGhnTs2JHff/9dvc+BAweIjY3Fz88PgICAADp37syQIUMoVaoUPj4+zJo1ixUrVvDixQv1fvXr12fYsGG4urri6ur6wbH/v3j06AkpKUpsba00ttvaWhEVFauboLLAounHGFhZErd2IwDGJVJPL9uOGELcyrWEfdqdhMDLOG5ejbGLsw4jzRm1apZn48a/uBx0C5VKxaXLN9m48S+SklN4FPtU1+GlkZCQzNR5B2nWqBwW5hlfQ6gP3mdsREXFYmenP2Opb/e6NP24Ip/4TaNctdG0/mwW3TrVomXTSjqJ533lhb7IsA12lkRFpT/LfPfuQ/744zQpSiUL5o+gf7/WLF26m19/3aKNkNOV2/pC++d+ctDOnTuxsLAgKSkJpVLJZ599xtixY2nWrNkH1RscHEzFihUxNzdXb6tZsyZKpZKrV69SuHBhOnfuzEcffcT9+/cpWrQoq1evplmzZlhbWwNw8eJFAgMDWb16tboOlUqFUqnk5s2blC1bFoAqVd4+c5KQkEBCQoLGNlOTRExNTT6onUJ3rDp/yrMDh0l58DB1g4ECgNjlv/N4zQYAIi8Fkb+2D1afdSBqwk+6CjVH9O/XksioOD7tNAGVSoWtrSWtW9dk0eI9GCgUug5PQ1JyCoO/34xKpcJ/xCe6Duf/wp4/A9mx9zzTJnbEzaUwwdfCCZi2g0L2lrRp8W6n2oXuqJSpY3r8uN4YGhpQvnxJIiIesXjJLgYO9NN1eLlCnppZq1evHhcuXCAkJIT4+HiWL1+Oubk5BgYGae4aSkpKytb3rlq1Kq6urqxdu5b4+Hi2bNmiPgUK8PTpU7744gsuXLigXi5evEhISIjGDNrrCWFGAgICsLKy0lgCApZna3tyGxubAhgaGqS5MDQ6Og47O2vdBPWOjByLkd+3JnGr1qm3JUekJm2J1zSn1xNDQjFyLKrV+LTBzMyEgIm9uPDPbxz882cOH5hGsWJ2mJubUbBgAV2Hp5aUnMKQ7zZz/0EcS2Z9pvezavB+Y8POzjrNLIkux9JPM3fTt3tdmjX2okypIrRu5k23z2oxf+khncTzvvJCX2TYhqjHaWadXrK3t8bZ2QFDw1cph4trUSIjY0lM1M1lDrmtL/JUsmZubo6bmxvFixfHyOjVpKG9vT3h4eHq9ZSUFC5fvvzO9ZYtW5aLFy9q3Axw/PhxDAwMKFPm1TUTnTt3ZvXq1ezYsQMDAwONGT1vb2+uXLmCm5tbmsXEJGszYqNHjyYuLk5jGT363e7kzKtMTIwoV64kJ08GqbcplUpOngyiUqVSOozs7aw+a09KVDTP9h1Ub0u+c4/k8AeYuLpolDV2KUnS3TBth6g1xsZGODgUxNDQgN27T1OvbkUMDPTjY+plonb73iOWzfoMG6v8ug7pnbzP2PDyKsWpU5qfkSdOXMLLSzdj6cWLJBRvzLAapvMjXN/lhb7IsA2nLlMpg5i8vUtz53YESuWra9Ru3XqAvb21Tm7ugtzXF/rxKZjD6tevz65du9i1axf//vsv/fr1S3PnZmY6d+6MmZkZ3bp14/Llyxw6dIivvvqKLl26ULhwYY1y586dY+LEibRr1w5T01e/ukeOHMmJEycYOHCgevZv27ZtaW4weBempqZYWlpqLB9yCvTZsxcEB98mOPg2APfuRRIcfJv796MAmDZtHSNG/qaxz8vyz54nEBPzmODg21y/rtskokePpqxff4gtW/4iNDSMsWOXEB//grZtfQEYMWIe06atVZdPTEwmOPgWwcG3SExMJiIihuDgW9y+/UB7QSsUWHZqx+O1myAlReOlmDkLsO7bHYsWn2BcsgS2o4ZiUsqVx6tfzcA5bl6Nda+ur6ozz49peQ9My3sAYFzCCdPyHhgV0+5sXOoxdYfg4DsA3AuLJDj4DvfvRwMwbfoGRoxaqC5/89YDtm0/wa1bDwgMvMHXw34lJOQeXw9pp72YnycSfO0BwddS+//e/ViCr6Xe7ZmUnMKgbzdx+d9wpo5tRYpSRWT0UyKjn5KY9Krfug1czaoNZ96pTm3K6tjo2rUJR48GsmTJLkJDw5g9eyOXL9/g889189y+erXL8tuSgxw+Gsy9+zH8efAyS1cfpWG9cuoy02bvYcQP6zT2C756n+Cr91M/px49I/jqfa7fiNB2+Bpye18A9Oj+Ces3vN6GpcTHJ7xqw8hfNdrQqVNDYuOeMnHiSm7eDOfw4fPMn7+Nzp0b6aoJQO7qizx1zVpGevbsycWLF+natStGRkZ8/fXX1KtX7533z58/P3/88QeDBw+matWq5M+fHz8/P6ZPn65Rzs3NjWrVqnH69GmNv4YA4OnpyZEjR/juu++oXbs2KpUKV1dXPv300+xo4ge5fPkmXbtNUq8HTE69UaJN61pMnvwFkZGxhP/3JftS6zbfq/8dFHSTnTtPUqyoHQcP/qKdoNPRtGkNYmIeM2vWRiIjYylbtgSLFo1ST82Hh0drzNI8fPiI1q2/Va8vWbKLJUt2Ua1aWVau1M6duPl9a2Hs5Ejc72mf1xU7fwkKU1PsJ4zB0NqahKBg7rX7nKRbd9RljJ1LYGhbUL1u5uWJ07ZXHy6FJqS2I27NRiK+Gp6DLdF0OegWXbtPUa8HTEmNqU3rmkye1JvIqDjCw18dU8oUJUuX/cHNWw8wMjKkejV31vz+HY7F7LQX87/hdB3w6gHPAbP2p8bc1JOBvWtz8GjqKelWXRdp7Ldi7udU9059BMHdsEc8iot/pzonj2mRMw1JR1bHhrd3aaZOHcCMGRuYPn0dzs4OzJ07lNKlnbQW8+u+H9GKmb/+gf/krUQ/ekohO0s+9avOgD4N1GUio54Q/iBWY7/Wn81U/zsoOIydey9QrIgNB3eO0lboaeT2voCXbXjCrNkbiYyMS23DwpGv2nA/WuNa0yJFbFm8aBQBk1fSstVoChe2oWuXJvTpo70xkJ7c1BcKVW6bRxbpU53WdQQfTmGo6wiyxTW7vHHBbOmI399eSN/FZf408lyjYLm3l9F3T3X3ENdsZaG7JClb5YWvfj27+ej9vf0mmf+L06BCCCGEELmVJGtCCCGEEHpMkjUhhBBCCD0myZoQQgghhB6TZE0IIYQQQo9JsiaEEEIIocckWRNCCCGE0GOSrAkhhBBC6DFJ1oQQQggh9Jgka0IIIYQQekySNSGEEEIIPSbJmhBCCCGEHpNkTQghhBBCj0myJoQQQgihxxQqlUql6yBENkg5oesIPpyBia4jEK9ZYNBZ1yF8sL7JS3UdQvYwNNV1BB8u5YWuI8gehma6jkDkOZXfWkJm1oQQQggh9Jgka0IIIYQQekySNSGEEEIIPSbJmhBCCCGEHpNkTQghhBBCj0myJoQQQgihxyRZE0IIIYTQY5KsCSGEEELoMUnWhBBCCCH0mCRrQgghhBB6TJI1IYQQQgg9ZqTrAPRF9+7dWb58OQBGRkYULFgQT09POnXqRPfu3TEwyLt57fwFO9m3/x9u3HiAmZkxlbzcGD6sPS4li2S63569Z5g5ezNhYVE4lyjM8KHt8fWtqKWo07d69T4WL95FZFQc7u7FGfN9Nzw9XTMs//jxM36ZsZ4//zxLbOxTihW149tvu+Dr66W9oNORlXZ06TKB02eC02z39fViwfxvcjpUAIwtzKkyfjDObRqSr5AtUeevcHLwJCLPXkJhZETVCUMo3rQOBVycSIx7Stj+E5weNY3n4Q8zrNOhdhUqftMLu8rlMS9aiD9a9+f2tgNaaQ/krXEBL4+pnURG/ndMjemGp6dbhuX37DnFzJkbUtvh7MDw4R3x9a2kxYhfmb9g1399EY6Zmcl/fdHurX3x0q7dfzN0+Hwa1K/EvDlf5XC0b5eb++KlrLRh/fqDbN16lJCQuwCUK1eSoUM/zbTN2pJb+iLvZiDvoUmTJoSHh3Pr1i327NlDvXr1GDx4MM2bNyc5OTndfZKSkrQcZfY7ffYqnTs1YP2a71m6aDjJySn06j2N588TMtzn3PkQhn3zG+3a1mHrJn8aNPBmwFezuRZyT4uRa9q9+yQBk1czYEBbtmyegHuZ4vTqPZno6Lh0yycmJtOj52TCwqKYOXMQe/dMZfz43hQubKPlyDVltR2zZw/h2NG56mXnjikYGhrQpHE1rcVcZ9EEijXy4VCXEWys0IKwfcdptn8p+YsWwii/GXbeHpwb/yubvdvyZ9uBWJcpSePtv2Zap7F5fqIvXuX4AH8ttUJTXhkX8N8xFbAq9ZjaMhF39+L06pXxMXXu3DWGDZtDu3Z12bp1Eg0aVGbAgOlcu3ZXy5GnSu2L+v/1xbD/+mJ6pn3x0r2wKKb8vJ4qlUtrIdK3y+19AVlvw99/X6FZMx9WrPietWv9KVLElp49JxMREaPlyDXlpr6QZO01pqamODg4UKxYMby9vfn222/Ztm0be/bsYdmyZQAoFAp+/fVXWrZsibm5ORMnTgRg27ZteHt7Y2ZmhouLC/7+/uoET6VSMXbsWIoXL46pqSlFixZl0KBB6vedN28epUqVwszMjMKFC9OuXTuttnvxgmG0bVOLUqWK4e5enMmTenE/PJqgK7cy3GfFyj+pXasCvXt9gqtrUYYMaouHRwlWrdbezMebli7bQ4f29fDz88XNzRF//56YmZmyadORdMtv2nyYuLinzJ3zNZW9y+DoaE+1amVxdy+h5cg1ZbUd1tYW2Ntbq5fjJy5hZmZCkybVtRKvoZkpJf0+5u8RP/Pg6Fkeh97hH/85xF2/jUe/z0h6/JTdH/fkxoY9xF27ycO/L3J84Hjsq5TH3CnjmZG7e//i7JgZ3Nq6XyvteFNeGRcAS5fupkOHevj51f3vmOqV6TG1YsVeateuSO/eLXB1LcaQIR3w8CjJqlX7tBx5qsULhr7RFz3f2hcAKSlKho9YwFcDW+HkZK+dYN8it/cFZL0N06YNpHPnRpQt64yrazEmTOiLUqni5MnLWo5cU27qC0nW3qJ+/fpUrFiRzZs3q7eNHTuWNm3acOnSJXr27MnRo0fp2rUrgwcP5sqVK8yfP59ly5apE7lNmzbxyy+/MH/+fEJCQti6dSsVKlQA4OzZswwaNIhx48Zx9epV9u7dS506dXTS1peePIkHwMrKPMMyFy6EUqOGh8a2WjXLc+FiaI7GlpHExGSCgm7i41Nevc3AwACfGuU5fyEk3X0OHjyHl1cpxo1bhk/NfjRvMZLffttGSopSW2Gn8T7teNOmjYdp1rQG+fOb5VSYGgyMjDAwMiLlheYsR0p8Ag61vNPdx8TKApVSSWLsY22EmC1y47iATI4pn/KcP5/+MXXhQgg1apTX2FarlicX3vEYzGnv0hcAc+dtx7ZgAdr76fYz9aW80Bfv04Y3xccnkJycjJWVRU6F+Va5rS/kmrV34O7uTmBgoHr9s88+o0ePHur1nj17MmrUKLp16waAi4sL48ePZ8SIEfz444/cuXMHBwcHGjZsiLGxMcWLF6datdRTVHfu3MHc3JzmzZtToEABSpQoQaVKursWQalUMmnyGry9S1G6lGOG5aKi4rCztdTYZmtnRVRU+tPHOe3RoyekpCixtbV6IyZLbty8n+4+d+8+5NSpK7Ro4cOC+SO4c+cB/v7LSE5OZuBAP22Encb7tON1gYGhXAu5x8SJfXMqxDSSnj7jwYlzeI/pT2zwDeIjonDt1JxCNbx4fP1OmvKGpiZUmzKc62t2kfTkmdbi/BC5dVxAJseUrRU3bqR/TEVFxWJnl7Z8VFRsToX5zl71hVumfXH2n2ts3HyUrZvHai+4t8gLffE+bXjT1KlrKFTIRiNR0rbc1hcys/YOVCoVCoVCvV6lShWN1y9evMi4ceOwsLBQL3369CE8PJznz5/Tvn174uPjcXFxoU+fPmzZskV9irRRo0aUKFECFxcXunTpwurVq3n+/Hmm8SQkJPD48WONJSEhMVva6j9+FSEh9/hl6pfZUp8+UylV2NpaMn5cb8qXL0nTpjX48stWrF13UNehvbeNGw9TurRTpjdV5IRDXUaAQsHn94/SK+ES5Qd1IXTNLlRKzVlKhZERDdfPRKFQcKzfj1qN8UP8P40LfZfaF2GZ9sXTZ/GMGLWI8f7dKGhTQIvRibdZsGA7u3efZM6coZiamug6nFxDkrV3EBwcTMmSJdXr5uaaU+9Pnz7F39+fCxcuqJdLly4REhKCmZkZTk5OXL16lXnz5pEvXz769+9PnTp1SEpKokCBApw7d441a9ZQpEgRfvjhBypWrEhsbGyG8QQEBGBlZaWxBExe+cHtHDdhJYePXGD5spE4OBTMtKydnRVR0ZqnsKKj4tL86tAWG5sCGBoapLkwNDrqcYYx2dtb4+zsgKHhq2Hg4lqUyMhYEhPTv6Ekp71PO156/vwFu3afpF27ujkYYfqe3LjLzrpdWGLuxWqnumyt3h4DYyOe3Hh14W1qojYDixJF2dWoZ66ZVcvN4wIyOaai47Czs053Hzs76zSzgZmV15ZxE1Zx+MhFli8bkWlf3L0TSVhYFP0GzMKjQm88KvRm67YTHDx0AY8KvblzJ+O7kHNSXuiL92nDS4sX72TBgu0sXjwad/fiORjl2+W2vpBk7S0OHjzIpUuX8PPL+LSYt7c3V69exc3NLc3y8pEf+fLlo0WLFsyaNYvDhw9z8uRJLl26BKQ+KqRhw4b89NNPBAYGcuvWLQ4ezHh2Z/To0cTFxWkso0d1ee82qlQqxk1YyZ/7z7F8yQicHN9+Ia6XlyunTl3R2HbiZBBeFbU7o/OSiYkR5cqV5OTJIPU2pVLJyVOXqeRVKt19vL1Lc+d2BMrXZn9u3XqAvb01Jia6uULgfdrx0t69f5OYmEzLFjVzOswMJT+PJ/5BJCbWljg2rsWt/x618TJRsypVgl0Nu5MQE6uzGN9VXhgXkMkxdTKISpXSP6a8vEpx6pTmxd8nTlzC6y3HYE5J7YtV79wXLi5F2LFtHFs3j1Uv9et5Ub2aO1s3j31r0p1T8kJfvE8bABYu3MG8eVtYtGgkFSq4aCPUTOW2vpBr1l6TkJDAgwcPSElJISIigr179xIQEEDz5s3p2rVrhvv98MMPNG/enOLFi9OuXTsMDAy4ePEily9fZsKECSxbtoyUlBSqV69O/vz5WbVqFfny5aNEiRLs3LmTGzduUKdOHWxsbNi9ezdKpZIyZcpk+H6mpqaYmppqbkx5/+lk//Er2bnrFPPmDMLcPB+Rkam/HAoUyIeZWWq9I0YtpHAha4YNbQ9A1y6N6NJtCkuW7sXXtyK7d//N5cu3GOff/b3j+FA9un/CyFHzKV++JJ6erixfvpf4+ATatvVNbcPIXylcyIZhwzoC0KlTQ1at3sfEiSv5/POPuX37AfPnb6NLl8Y6awNkvR0vbdx0hIYNK2Ojg9M+jh/XAoWCuKs3sXQrTvWfRxD77w2uLt2MwsiIRhtnYeftwd7mX6AwNCRfYTsAEmLiUP73+Jtm+5dxa8ufBM1dDYCReX6s3F79+rYs6YhtRXdexMTx7G54jrcpr4wLgB49mjJy5G+UL+/y3zG1h/j4F6+OqRHzKFy4oPqY6tq1CV26jGfJkl34+nqxe/dJLl++wbhxvXUSv//4Va/1hVkmfWHDsKHtMDU1TnM9m6VlfoBMr3PThtzeF+/ThgULtjNr1kamTRtIsWL2REbGApA/vxnm5tq5ESo9uakvJFl7zd69eylSpAhGRkbY2NhQsWJFZs2aRbdu3TJ9KG7jxo3ZuXMn48aNY8qUKRgbG+Pu7k7v3qkdaG1tzeTJkxk6dCgpKSlUqFCBHTt2YGtri7W1NZs3b2bs2LG8ePGCUqVKsWbNGsqVK6etZrNm7SEAunSborE9YGIv2rapBUB4eDQGBq+u2/OuVIqpP33BjFmbmT5jE84lCjN39lc6/SBs2rQGMTFPmDV7I5GRcZQtW4JFC0eqT0GF34/G4LVrD4sUsWXxolEETF5Jy1ajKVzYhq5dmtCnTwtdNQHIejsAbty4zz//XGXJ4lG6CBkTqwJUCxiKuaMDCTGx3Ny0j9Pf/YIqORmLEsVwbtUAgHYXt2vst6NuF8KPnAbA0tUJM7tXz7izr1KeFodfnd6v8cu3AFxdtpkjPUbndJPyzLiAl8fUY2bN2khkZGzqMbVo1KtjKjxa4zPO27s0U6cOYMaMDUyfvg5nZwfmzh1K6dJOOok/477o+VpfxOSKh5fn9r6ArLdh7dr9JCUlM2jQDI16Bg5sy1dfafdRVa/LTX2hUKlUqhx/F5HzUk7oOoIPZyAXm+qTBQaddR3CB+ubvFTXIWQPQ9O3l9F3KS90HUH2MNTdTJDIqyq/tYT+/wwRQgghhPg/JsmaEEIIIYQek2RNCCGEEEKPSbImhBBCCKHHJFkTQgghhNBjkqwJIYQQQugxSdaEEEIIIfSYJGtCCCGEEHpMkjUhhBBCCD0myZoQQgghhB6TZE0IIYQQQo9JsiaEEEIIocckWRNCCCGE0GMKlUql0nUQIjv8o+sAxEtP7+o6guxhZKbrCD7YxUL9dR1Ctqj4eIOuQ/hwz8N1HUH2yF9E1xGIPKfyW0vIzJoQQgghhB6TZE0IIYQQQo9JsiaEEEIIocckWRNCCCGE0GOSrAkhhBBC6DFJ1oQQQggh9Jgka0IIIYQQekySNSGEEEIIPSbJmhBCCCGEHpNkTQghhBBCj0myJoQQQgihxyRZE0IIIYTQY0a6DiC3ePDgARMnTmTXrl2EhYVRqFAhvLy8GDJkCA0aNMiW93B2dmbIkCEMGTIkW+rLqtWr97F48U4iI+Nwdy/OmDHd8PR0y7D8nj2nmDlzA2FhUTg7OzB8eEd8fStpMeK0stKGkJB7zJq1gaCgm4SFRTF6dBe6d/9EyxFrSklRMnv+n2zfc56o6CcUsrOkTYvK9O/dAIVCkeF+f58NZfL0nYTciKBIYWv69apP25ZVtBi5ptm/7mHOb3s1tpV0LsTebd+lW75Lr9mcPns9zXbf2h4smPNFjsT4prKX/sKkhGOa7VELVxI27EeMCtlRZMJoCtSrhYGFOQkhN3g4dR5x2/emU9t/DAxw+HYw1h1aY1zYnqQHEcSs3sTDn+bkYEvSl5vHd/2mEwgLf5Rm+2cdfPhxtF+a7SGhD5g1by9BwfcIC3/E6OGt6N65jjZCfSe5uS9eykob9u07zW+/bePOnQiSk1MoUcKBHj2a0rp1bS1HnVZu6QtJ1t7BrVu3qFmzJtbW1vz8889UqFCBpKQk/vjjDwYMGMC///6r6xA/2O7dJwkIWIW/f08qVnRj+fI99Oo1mb17p2Fra5Wm/Llz1xg2bA5Dh35KvXre7NhxnAEDprN58yRKl3bSQQuy3ob4+AQcHQvRpEl1AgJW6SDitBYuP8yajaeY4t8BN9fCXL5yj9H+GyhgkY+unWqmu8/dsBi+GLyUjn4fMXViR06eDuX7CZuwtytAbZ8yWm7BK6VcHVi6YIB63dAw44n82dN7kpSUol6PjX1Gqw4/0aSRV06GqOFa3dYoXovRzKMMrttXErtlNwDFF0zD0MqSmx37kBL9COv2LSmxfDYhvq2ID7ySbp2Fvv4S216dufPlN7wIvkb+Sp44zZuC8vETon5brpV2Qe4f3xtXDSFFqVSvh1x/QI9+82nSqGK65eNfJOLoaEuTRhUJmLZNW2G+k9zeF5D1NlhZWdCvX2tcXIpibGzEoUPn+Pbb+djaWlK7dvp9qA25qS/kNOg76N+/PwqFgtOnT+Pn50fp0qUpV64cQ4cO5dSpUwDcuXOHVq1aYWFhgaWlJR06dCAiIkJdR2hoKK1ataJw4cJYWFhQtWpV9u/fr369bt263L59m6+//hqFQpHpLEpOWLp0Nx061MPPry5ubo74+/fCzMyUTZuOpFt+xYq91K5dkd69W+DqWowhQzrg4VGSVav2aTXu12W1DZ6erowc2ZlmzXwwMdGP3y3nL96mQV0P6tYui2PRgjRp6Emtj0oTGHQ3w33WbjqFY7GCjBraHNeShfn8Ux8aNyjPst+PaTHytAyNDLG3s1QvBW0sMixrbWWuUfb4qauYmRlrNVlLiY4h+WGUerFsUp+EG7d4duxvAPJX8yZq/nLi/wkk8dZdHv48l5S4x+TzKp9hnebVvYnbtZ8nfxwi6U4Ycdv28OTgMfJX1u4XVG4f3wULWmgcH4eOXqG4ky3VKrumW96zXHFGft2CZk0qYWKsH2P7pdzeF5D1NlSv7kGjRlVxdS1G8eKF6dbtE8qUKc4//1zVcuSaclNfSLL2FjExMezdu5cBAwZgbm6e5nVra2uUSiWtWrUiJiaGI0eO8Oeff3Ljxg0+/fRTdbmnT5/StGlTDhw4wPnz52nSpAktWrTgzp07AGzevBlHR0fGjRtHeHg44eHhWmtjYmIyQUE38fF59aVjYGCAj095zp8PSXefCxdCqFFD80uqVi1PLlxIv3xOe5826KNKFUtw6nQoN29HAvDvtfv8c+EWdTKZIbsQeIca1TSn7WvVKM2FwNs5Guvb3L4dSa2GY2jQdBzDRq/gfnjMO++7acspmjXxJn9+0xyMMGMKY2NsPm1FzMqN6m3PT5/Dum1zDG2sQKHA2q85ClNTnv6XzKXn2d/nKODrg4lbSQDMyrtjXqMKj/9M/8sgJ+SF8f26xKRktu/+B79W1bT+o/ZD5YW++NDPWpVKxcmTl7l5M5yqVcvmZKiZym19oV8/OfTQ9evXUalUuLu7Z1jmwIEDXLp0iZs3b+LklDoVumLFCsqVK8eZM2eoWrUqFStWpGLFV7+mx48fz5YtW9i+fTsDBw6kYMGCGBoaUqBAARwcHHK8Xa979OgJKSnKNNO+trZW3LhxP919oqJisbNLWz4qKjanwszU+7RBH/XtXpenTxP4xG8ahgYKUpQqvu7fmJZNM74mIir6CXYFC2hssytYgKfPEnjxIgkzM+OcDjsNzwolCBj/GSWdCxEZ+Zi58/fSuccsdmwahYW5Wab7Bl66zbXr4Uwc20lL0aZl2bwRhlaWxKx+lazd6jYQ52WzKX/7PKqkJJTPX3Cr85ck3sg4KX44/VcMC1jgfvZPSEkBQ0MejJtG7HrtnZrLC+P7dfsPXebJkxe0aVFV16FkWV7oi/f9rH3y5Dl16gwgMTEZAwMDfvyxBzVrVsjpcDOU2/pCkrW3UKlUby0THByMk5OTOlED8PDwwNramuDgYKpWrcrTp08ZO3Ysu3btIjw8nOTkZOLj49Uza1mRkJBAQkKCxjZT00RMTU2yXJfQL3v+DGTH3vNMm9gRN5fCBF8LJ2DaDgrZp95okFv41vJQ/9u9dDEqVihBvU/82fPHedq3rZHpvhu3nKJ0qSJ4ViiR02FmyLZrBx7/eYTkBw/V24p8PxQDK0tCW3xOcnQMVs0/xnnZHK43+ZQXV9I/nWPdthnWHVpyp9cQXgSHkM+zLEUnjyHpQQSPft+srebkKZu2/k2dmu4ULpT2miKhv8zNzdi6NYDnz19w8mQQkyevwsmpENWre7x9ZyHJ2tuUKlUKhULxwTcRDB8+nD///JOpU6fi5uZGvnz5aNeuHYmJiVmuKyAgAH9/f41tP/7Yh7Fj3++uORubAhgaGhAdHaexPTo6Djs763T3sbOzJirq3cvntPdpgz76aeZu+navS7PGXgCUKVWE++GPmL/0UIbJmp1tAaJinmhsi4p5goW5qU5m1dJjaZkf5xL23LkblWm5588T2PXHOQb1191ducZORbGoW5Nbnfupt5mULI7dF934t1pjEv5NPeXx4vK/mNeoim2fLoR9/X26dRUZP4qHv8wndtPO1H2uXMXYqRiFhvbTWrKWF8b3S2H3Yzjxdwizp3bXaRzvKy/0xft+1hoYGFCiROpZo7JlnQkNDWPBgm06S9ZyW1/INWtvUbBgQRo3bszcuXN59uxZmtdjY2MpW7Ysd+/e5e7dVxeBX7lyhdjYWDw8Ug/E48eP0717d9q0aUOFChVwcHDg1q1bGnWZmJiQkpLC24wePZq4uDiNZfToHu/dRhMTI8qVK8nJk0HqbUqlkpMng6hUqVS6+3h5leLUqcsa206cuISXV/rlc9r7tEEfvXiRlOY6HEMDg0xneL08i3PqdKjGthOnruPlqbuZqTc9e57A3bvR2NtZZlpu758XSExMpmUz3Z3iKvh5e5Ijo3n8xyH1NoN8+VL/8dodianrKSgMMr5uyiB/vrT7pChRGGjvozcvjO+XNm8/g21BC+rW1t21Th8iL/RFdn3WKpUqEhOTcyLEd5Lb+kKStXcwd+5cUlJSqFatGps2bSIkJITg4GBmzZpFjRo1aNiwIRUqVKBz586cO3eO06dP07VrV3x9falSJfVZV6VKlWLz5s1cuHCBixcv8tlnn6F840Pc2dmZv/76i7CwMKKiMp6BMDU1xdLSUmP50FOgPXo0Zf36Q2zZ8hehoWGMHbuE+PgXtG3rC8CIEfOYNm2tunzXrk04ejSQJUt2ERoaxuzZG7l8+Qaff/7xB8XxIbLahsTEZIKDbxEcfIvExGQiImIIDr7F7dsPdNUE6tUuy29LDnL4aDD37sfw58HLLF19lIb1yqnLTJu9hxE/rFOvd/T7iLth0fw0czehNx+yev1J9uwPpPtntXTRBACmTNvK6bPXuRcWzbkLNxn49SIMDBU0/yR1dnDEd6uYNnNHmv02bjlFw3oVsLFOezOPVigUFOzcLnXW67UfTi+uhZIQegvHmRPJV9kTk5LFsR/YC4t6tYjb9ae6nMv2Vdj27aJef7znAIWG96dA43oYFy+GZfOPsR/Yk7gd2r2TLy+Mb6VSyeZtZ2jdvApGRoYar434/nemzdqlXk9MSib4ahjBV8NITEoh4mEcwVfDuH0n85ldbcgLfZHVNsyfv43jxy9x924EoaFhLFmyi+3bj9Gype4+oyB39YWcBn0HLi4unDt3jokTJzJs2DDCw8Oxt7encuXK/PrrrygUCrZt28ZXX31FnTp1MDAwoEmTJsyePVtdx/Tp0+nZsyc+Pj7Y2dkxcuRIHj9+rPE+48aN44svvsDV1ZWEhIR3ul4uuzRtWoOYmMfMmrWRyMhYypYtwaJFo9QXU4aHR2Pw2myAt3dppk4dwIwZG5g+fR3Ozg7MnTtUZ8/9gay34eHDR7Ru/a16fcmSXSxZsotq1cqycuUYrccP8P2IVsz89Q/8J28l+tFTCtlZ8qlfdQb0efXg5cioJ4Q/iFWvOxUryPyZPQiYvpMVa47hUMiKCd/76fQZaw8iYhk6ajmxsc8oaGNB5UourF85lIIFUx/fEf7gEQZvzEjduBXBP+dvsOS3fulVqRUW9WpiUrwY0as2aL6QnMyNdj0pMnYEJdctwsA8P4k3bnP3y+E82XdYXcy0ZHGMbAuq18O+8cfh+6E4ThuHkb0tSQ8iiF66hojJs9GmvDC+T/wdwv0Hj/BrXT3Na+EPYjWOp4eRj2ndcbp6fcmKwyxZcZhqlV1Zuai/VuLNSF7oi6y24fnzBPz9l/DgQQxmZia4uBTl55/707Rp5tev5rTc1BcKlTYzApGD/tF1AOKlpxk/Ey1XMcr8rs3c4GIh3X4xZ5eKjze8vZC+e669xxHlqPxFdB2ByHPefvOYnAYVQgghhNBj75WsHT16lM8//5waNWoQFhYGwMqVKzl2TLdPTBdCCCGEyGuynKxt2rSJxo0bky9fPs6fP69+3ldcXByTJk3K9gCFEEIIIf6fZTlZmzBhAr/99hsLFy7E2PjVM5xq1qzJuXPnsjU4IYQQQoj/d1lO1q5evUqdOnXSbLeysiI2NjY7YhJCCCGEEP/JcrLm4ODA9evX02w/duwYLi4u2RKUEEIIIYRIleVkrU+fPgwePJi///4bhULB/fv3Wb16NcOHD6dfP909H0kIIYQQIi/K8kNxR40ahVKppEGDBjx//pw6depgamrK8OHD+eqrr3IiRiGEEEKI/1vv/VDcxMRErl+/ztOnT/Hw8MDCwiK7YxNZIg/F1RvyUFy9IQ/F1SPyUFwhMvD2h+K+95+bMjExUf+RciGEEEIIkTOynKzVq1cPhUKR4esHDx78oICEEEIIIcQrWU7WvLy8NNaTkpK4cOECly9fplu3btkVlxBCCCGE4D2StV9++SXd7WPHjuXp06cfHJAQQgghhHjlvW8weNP169epVq0aMTEx2VGdyDK5wUCIvCpA8ZmuQ/hgo1W/6zqE7JGSoOsIsoehqa4j+HDKRF1HkD0Mary9SHa918mTJzEzy/13jwkhhBBC6JMsnwZt27atxrpKpSI8PJyzZ88yZsyYbAtMCCGEEEK8R7JmZWWlsW5gYECZMmUYN24cH3/8cbYFJoQQQgghspispaSk0KNHDypUqICNjU1OxSSEEEIIIf6TpWvWDA0N+fjjj4mNjc2hcIQQQgghxOuyfINB+fLluXHjRk7EIoQQQggh3pDlZG3ChAkMHz6cnTt3Eh4ezuPHjzUWIYQQQgiRfd75mrVx48YxbNgwmjZtCkDLli01/uyUSqVCoVCQkpKS/VEKIYQQQvyfeudkzd/fny+//JJDhw7lZDxCCCGEEOI175ysvfxDB76+vjkWjBBCCCGE0JSla9ZeP+0phBBCCCFyXpaes1a6dOm3Jmzyt0E1de/endjYWLZu3fpO5W/dukXJkiU5f/48Xl5eORqbEEIIIfRflpI1f3//NH/BILeIjIzkhx9+YNeuXURERGBjY0PFihX54YcfqFmzpq7D0wurV+9j8eKdREbG4e5enDFjuuHp6ZZh+T17TjFz5gbCwqJwdnZg+PCO+PpW0mLEaeWFNkDeaEdW2hASco9ZszYQFHSTsLAoRo/uQvfun2g54vTltr4wsTCnzvjBlG7TkPyFbIk4f4X9gycRfvYSAM2WBuDZXfPPBt7Ye5R1n/R+7zq1Jbf1xZvmL9jJvv3/cOPGA8zMjKnk5cbwYe1xKVkkw33WbzjC1m3HCbkeBkA5D2eGDvHD09NFW2GnKy+M7zNnrrJ4yW4uB90mMjKWubO/omHDyhmWHzV6IVu2Hk+z3c21KLt2TsrJULN2GrRjx45069Yt00Vf+fn5cf78eZYvX861a9fYvn07devWJTo6Wteh6YXdu08SELCKAQPasmXLRNzdi9Or12Sio+PSLX/u3DWGDZtDu3Z12bp1Eg0aVGbAgOlcu3ZXy5G/khfaAHmjHVltQ3x8Ao6OhRg2rCP29tbaDTYTubEvPlk0AedGPuzoMoLFFVpwc99xOu5fikXRQuoyoXv+YpZDTfWyrdPQD64zp+XGvnjT6bNX6dypAevXfM/SRcNJTk6hV+9pPH+ekOE+f5/+l2bNPmLF0pGs/f17ijgUpGefqUREPNJi5Jryyvh+Hp9AmTLF+XFMl3cq/923nTn21wz1cuTQdKytzGnSpGoOR5qFZC03X68WGxvL0aNHmTJlCvXq1aNEiRJUq1aN0aNH07JlSwCmT59OhQoVMDc3x8nJif79+/P06VN1HcuWLcPa2po//viDsmXLYmFhQZMmTQgPD1eXSUlJYejQoVhbW2Nra8uIESPUN2a8tHfvXmrVqqUu07x5c0JDQ7XzH5GJpUt306FDPfz86uLm5oi/fy/MzEzZtOlIuuVXrNhL7doV6d27Ba6uxRgypAMeHiVZtWqfliN/JS+0AfJGO7LaBk9PV0aO7EyzZj6YmGT5TxbnmNzWF0Zmprj7fcyhET9z9+hZHoXe4Zj/HB5dv413v8/U5VISEnkWEaVeXsRm/IzMd60zp+W2vkjP4gXDaNumFqVKFcPdvTiTJ/Xifng0QVduZbjPtJ+/oHOn+pQtWxxXlyJMGN8DpVLFyVNXtBf4G/LK+Pat48nXQ/xo1Cjj2bTXFSiQH3t7a/Vy+fJN4h4/p22b2jkcaRaStTeTjtzEwsICCwsLtm7dSkJC+r9gDAwMmDVrFkFBQSxfvpyDBw8yYsQIjTLPnz9n6tSprFy5kr/++os7d+4wfPhw9evTpk1j2bJlLFmyhGPHjhETE8OWLVs06nj27BlDhw7l7NmzHDhwAAMDA9q0aYNSqcz+hr+jxMRkgoJu4uNTXr3NwMAAH5/ynD8fku4+Fy6EUKNGeY1ttWp5cuFC+uVzWl5oA+SNdrxPG/RRbuwLAyMjDIyMSH6h+TmXHJ+AYy1v9XrxutUYFHGCvv/upfG8seQraP3Bdeak3NgX7+LJk3gArKzM33mf+BcJJCenZGmf7JRXxnd22LjpL3xqeFCsmF2Ov9c7J2tKpZJChbQ35Z2djIyMWLZsGcuXL8fa2pqaNWvy7bffEhgYqC4zZMgQ6tWrh7OzM/Xr12fChAmsX79eo56kpCR+++03qlSpgre3NwMHDuTAgQPq12fMmMHo0aNp27YtZcuW5bfffktzjZ+fnx9t27bFzc0NLy8vlixZwqVLl7hyRXe/kh49ekJKihJbW81YbW2tiIqKTXefqKhY7OzevXxOywttgLzRjvdpgz7KjX2R+PQZ906co+aY/lgUKYTCwIBynVtSrIYXFkVSP79v7D3Kjq4jWdOgO4dG/kxx36p02LMQhUH6XwfvUmdOy4198TZKpZJJk9fg7V2K0qUc33m/qdM2UKiQNT41yuVgdBnLK+P7Q0U8fMRfRy/Rrp12HmeW5T83lVv5+flx//59tm/fTpMmTTh8+DDe3t4sW7YMgP3799OgQQOKFStGgQIF6NKlC9HR0Tx//lxdR/78+XF1dVWvFylShIcPHwIQFxdHeHg41atXV79uZGRElSpVNOIICQmhU6dOuLi4YGlpibOzMwB37tx557YkJCSk+TNfCQmJWf0vEULkQTu6jEChUPDV/aOMSLhElUFduLJmF6r/Zu+D1+3m+o6DRF6+Rsi2A2xo/gVFq3lSvG61965TZJ3/+FWEhNzjl6lfvvM+CxbuYvfu08yZ9RWmpsY5GJ14m61bj1OgQH4aNtDO7PL/TbIGYGZmRqNGjRgzZgwnTpyge/fu/Pjjj9y6dYvmzZvj6enJpk2b+Oeff5g7dy4AiYmvkiBjY83BoVAosnx6uEWLFsTExLBw4UL+/vtv/v777zTv8zYBAQFYWVlpLAEBS7MUx+tsbApgaGiQ5uLQ6Og47Oys093Hzs6aqKh3L5/T8kIbIG+0433aoI9ya1/E3rjL6rpdmGruxRynuiyv3h4DYyNib6R/YX3szXs8j4zBxq1EttWZ3XJrX2Rk3ISVHD5ygeXLRuLgUPCd9lm8ZA8LFu1i8aJhuJdxyuEIM5ZXxveHUKlUbNp0lFYttXcN3v9VsvYmDw8Pnj17xj///INSqWTatGl89NFHlC5dmvv372epLisrK4oUKaJOvgCSk5P5559/1OvR0dFcvXqV77//ngYNGlC2bFkePcr6HT2jR48mLi5OYxk9ukeW63nJxMSIcuVKcvJkkHqbUqnk5MkgKlUqle4+Xl6lOHXqssa2Eycu4eWVfvmclhfaAHmjHe/TBn2U2/si6Xk8zx5EYmZtiUvjWoRsO5BuuQLFCpPP1pqn4ZHZVmd2y+198ZJKpWLchJX8uf8cy5eMwMnR/p32W7h4N/N+28GiBcOoUL5kDkeZubwyvj/E6TP/cvtOBO386mjtPf8vkrXo6Gjq16/PqlWrCAwM5ObNm2zYsIGffvqJVq1a4ebmRlJSErNnz+bGjRusXLmS3377LcvvM3jwYCZPnszWrVv5999/6d+/P7GxserXbWxssLW1ZcGCBVy/fp2DBw8ydGjmt8ynx9TUFEtLS43F1NQky/W8rkePpqxff4gtW/4iNDSMsWOXEB//grZtU8/Hjxgxj2nT1qrLd+3ahKNHA1myZBehoWHMnr2Ry5dv8PnnH39QHB8iL7QB8kY7stqGxMRkgoNvERx8i8TEZCIiYggOvsXt2w901QQgd/ZFyY9r4dK4NlbOjjg39OGzQyuI/vcGgUs3Y2yen3o/jaBo9YpYlShGifof4bdtHo+u3+bmH0fVdXTav4zKAzq/U53akhv74k3+41eyfcdJpv38Bebm+YiMjCMyMo4XL16dWRkxaiHTpm9Qry9YtIuZs7YwaUJPihW1U+/z7NkLXTQByDvj+9mzFwQH3yY4+DYA9+5FERx8m/v3Ux/pNW36BkaMXJBmv40b/6KipwulS7/7tYYfSn/uoc1BFhYWVK9enV9++YXQ0FCSkpJwcnKiT58+fPvtt+TLl4/p06czZcoURo8eTZ06dQgICKBr165Zep9hw4YRHh5Ot27dMDAwoGfPnrRp04a4uNTpYgMDA9auXcugQYMoX748ZcqUYdasWdStWzcHWp01TZvWICbmMbNmbSQyMpayZUuwaNEo9QW64eHRGLx2AbK3d2mmTh3AjBkbmD59Hc7ODsydO5TSpXU3PZ8X2gB5ox1ZbcPDh49o3fpb9fqSJbtYsmQX1aqVZeXKMVqP/6Xc2BemVgWoGzCUAo4OvIiJ5eqmfRz57heUyckYGBlSyLM0Fbq1xsy6AE/uP+TmvuP8NWYmKYlJ6jqsXZ3IZ2fzTnVqS27sizetWXsIgC7dpmhsD5jYi7ZtagEv2/HqUVlr1x4iKSmZQUPmauwzsH8rvhrYOmcDzkBeGd+Xg27S9bW+CJiyBoA2rWsyOaAPkZGxhIdrPov1yZPn7PvzH74brb3H1gAoVLn5mRziNf+8vYgQIlcKUGj3iyEnjFb9rusQskdKxg+wzVUMTXUdwYdT5pEb6wxqvL2IFsIQQgghhBDvSZI1IYQQQgg9JsmaEEIIIYQek2RNCCGEEEKPSbImhBBCCKHHJFkTQgghhNBjkqwJIYQQQugxSdaEEEIIIfSYJGtCCCGEEHpMkjUhhBBCCD0myZoQQgghhB6TZE0IIYQQQo9JsiaEEEIIoccUKpVKpesgRDaIXKTrCD6cfSVdR5A9nt3TdQTZw9hS1xF8uORnuo4ge+QvousIPtjjGh11HUK2sDy5VtchZA9loq4j+HAGJrqOIJtUfmsJmVkTQgghhNBjkqwJIYQQQugxSdaEEEIIIfSYJGtCCCGEEHpMkjUhhBBCCD0myZoQQgghhB6TZE0IIYQQQo9JsiaEEEIIocckWRNCCCGE0GOSrAkhhBBC6DFJ1oQQQggh9Jgka9lAoVCwdevWDF8/fPgwCoWC2NhYrcUkhBBCiLzBSNcB5AaRkZH88MMP7Nq1i4iICGxsbKhYsSI//PADNWvWfOv+Pj4+hIeHY2VllWm57t27Exsbm2nilx3OXLjL4t/PcPnqAyKjnzF3Umsa1imlfn324uPsOvAvDx4+wdjIgHJlCvN139pULFc0wzqfPk9k5sJj7P8rhOhHz/EoXYhvB9fHs6x2/wD16tX7WLx4J5GRcbi7F2fMmG54erqlWzYk5B6zZm0gKOgmYWFRjB7dhe7dP9FqvG+q3yyAsPBHabZ/1r4GP45uk2Z7UlIK85ceZOvOf4h4+JiSJewZPqgpdWqW0Ua46fp93RHWrPuLsPvRAJRyLUL/L5vhW7t8hvssW3mANev/Ijw8BhtrCxo3qsSwIW0wNTXWVtjpingYx88zd3L0+L/Ev0ikhJMdk8Z2pEI5pwz3Wb3uGKvWHSfsfgxFHGzo16shrVtU0WLUGcSVhbEBsGfPKWbO3EBYWBTOzg4MH94RX99KWotXYV8Y0/7fYFSjDgqzfCjv3SZ+wiiU/14GwOz7KZg0a6uxT/Kpv3j+da+MKzUwwLT3IIwbt0Rha48q8iGJuzeTuHRuTjYljdzWF286c+Yqi5fs5nLQbSIjY5k7+ysaNsz8j5EnJiYxd942tm8/SWRUHIXsrejfvxXt/OpoKer05Za+kGTtHfj5+ZGYmMjy5ctxcXEhIiKCAwcOEB0d/U77m5iY4ODgkOHrKSkpKBSK7Ar3rZ7HJ1HGzR6/ZuUZ+N22NK87O9nww9cNcCpqzYuEZJatP0vPoRv4c20fCtrkT7fO7yfvJeRGFD+NaUohOwu2/3GFHkPWs3tVTwrbF8jpJgGwe/dJAgJW4e/fk4oV3Vi+fA+9ek1m795p2NqmTZTj4xNwdCxEkybVCQhYpZUY32bjqq9ISVGp10NCH9Cj30KaNPJMt/yMeX+wffc5Jozxw8W5EEdPXmPg8OWsXToAD/di2gpbg0NhG4YPaU2JEoVQqWDr9pMMGPQrWzZ8Rym3tAn/jl2nmTZjC5PGdaWSlwu3bj9k1PfLUSgUjB7RXgctSBX3+Dmdus+melU3Fs7pg42NObfvRGFlmS/DfX5ff4Jps3czYUx7KpQrTuDlO3w/fgOWlvmo71tOi9FryurYOHfuGsOGzWHo0E+pV8+bHTuOM2DAdDZvnkTp0hknqtmmgCXm89eS/M/fPB/aG9WjGAycnFE9eaxRLPnkEeInjFKvq5ISM63WpEtfjNt04sX4kaTcCMGwbAXyfRcAT5+QuGFFjjTlTbmuL9LxPD6BMmWK49e2DgMHzX6nfQZ/PY/oqDgmTuhJ8RKFiHwYh1KlevuOOSg39YWcBn2L2NhYjh49ypQpU6hXrx4lSpSgWrVqjB49mpYtW6rLRUVF0aZNG/Lnz0+pUqXYvn27+rU3T4MuW7YMa2trtm/fjoeHB6ampvTs2ZPly5ezbds2FAoFCoWCw4cP50ibfGu48HXf2jTyLZ3u6y0+9sCnqjNOxawp5WLH6K/q8fRZIldDI9Mt/yIhiX1HrvFNf1+qejlRwtGGr3rVpEQxG37fciFH2pCepUt306FDPfz86uLm5oi/fy/MzEzZtOlIuuU9PV0ZObIzzZr5YGKiH79bCtpYYG9XQL0c+iuY4o62VKvskm75bbv+4cue9fGtVRYnR1s+a18D35ruLFn5l5Yjf6V+XU9861TAuURhSjoX5utBrcmf35QLgTfTLX/+QijelVxp0awajsXsqOXjQfNPqhJ4+ZZ2A3/DwqUHcXCwJsC/I57li+NUzJZaNcpQ3Mkuw3227zrLp341aNq4Ek6OtjRrUolP237EwmUHtRh5WlkdGytW7KV27Yr07t0CV9diDBnSAQ+PkqxatU8r8Zp+3hdlRDgvJo5CeSUQVfg9Uk4fQxV2R6OcKjERVUyUeuGNZO5NhhW8ST56gOQTh1E9CCP50F6STx/HwCP9H0M5Ibf1RXp863jy9RA/GjXKfDbtpb+OBnLmzL8smD8UH59yOBazp1IlNyp7l3r7zjkoN/WFJGtvYWFhgYWFBVu3biUhISHDcv7+/nTo0IHAwECaNm1K586diYmJybD88+fPmTJlCosWLSIoKIhZs2bRoUMHmjRpQnh4OOHh4fj4+OREk7IkMSmFddsuUsDClDJu9umWSU5RkZKiwvSNhMfU1IhzgWHaCJPExGSCgm7i4/PqVJuBgQE+PuU5fz5EKzFkt8SkZLbvOYdfq6oZzrwmJaVgYvrm/7sx5y7c0kKEb5eSomTXnjM8j0+kUsWS6Zap5OVK0JU7BF5KTebu3o3kyNHLmZ421YaDR65Q3sOJQd8sp0b9H2ndcRrrN5/KdJ/EpJS048DMmEuX75KUlJKT4WYc03uMjQsXQqhRQ/P/v1YtTy5c0M5YMqrdgJR/L5Nv4iwsdp3CfPk2jFt2SFvOu3rq62v/wOwbfxSW1pnWm3LpHEZVamDg5AyAgZs7hhUrk3xSOz9ucmNfZIeDBy9QvlxJFi3eTW3fITRuMpIpP63lxYvMZ0JzUm7rC/2YTtBjRkZGLFu2jD59+vDbb7/h7e2Nr68vHTt2xNPz1a+x7t2706lTJwAmTZrErFmzOH36NE2aNEm33qSkJObNm0fFihXV2/Lly0dCQkKmp0y15dDxUIaO3UH8iyTsbS1Y8kt7ClqnfwrUIr8JlcoXZd6yk7g422Jnk5+d+4O5EHSf4sWstRLvo0dPSElRppm6trW14saN+1qJIbvtPxTEkycvaNMy41+vtWqUZtmqo1T1LklxR1tOnr7On4cuk5Ki1GKkaV29FkbHz38iITGJ/PlNmTvjC9xc07/msUWzajyKfcpnXaeiQkVyspKOHerwZR/dXj94NyyaNRtO0ONzX77s1YBLQXeZ8NMWjI0MadOyarr71KpRho1b/6ZhvfKUK+vI5Sv32Ljlb5KSU3gU+4xC9pZabsX7jY2oqFjs7NKWj4qKzakwNRgUdcKkzWckrl1CwvLfMCxbAbOhYyA5iaTdW4DU69OSD/+BMvweBsWKY/rlMPL/sohnfTqAMv3jP3HFfBT5LTBf+wcoU8DAkIT500netz3d8tktN/ZFdrh77yH/nLuGqakxc2cP4tGjJ/iPW0Fs7FMCJvXWSUy5rS8kWXsHfn5+NGvWjKNHj3Lq1Cn27NnDTz/9xKJFi+jevTuARuJmbm6OpaUlDx8+zLBOExMTjX2yIiEhIc0sn2lCUrZejF3d24mtS7vxKDae9TsCGfLDDjYs6IytjXm65X8a05RvA/ZSp/WvGBoq8ChdmGYN3Qm6GpFtMf2/2bT1DHV8ylDYPuMbU777piXfj9/EJ22nolAocHIsSNsWVdi0/YwWI02rZMnCbN34HU+exPPHn+cY+f1yVi0dmm7C9veZq8xfuJcfv++EZ4WS3Ln7kImT1zP3t10M+LKZDqJPpVKqKO/hyNCvmgLg4e5IyPUHrN14MsNkrX+fRkRGP+bTbrNQqcC2oAWtW1Rh0bJDGBho77rUXM9AQcq/l0n4bToAymtXMHApjXHrTq+Stf271MWVoddIuX6VApsOYuhdnZSzJ9Ot1qhBU4wbtyT+x6Eob4ZgWKospkO+QxX1UF2vyH4qpQqFQsHUn7+gQIHUH/2jRnZi0JC5/PhDV8zMTHQcof6T06DvyMzMjEaNGjFmzBhOnDhB9+7d+fHHH9WvGxtrJkoKhQJlBr/uIHUW7X1vKggICMDKykpjCZi5573qykj+fCaUcLTBq3xRJo1ugpGhgo07L2VYvngxG1bN6cT5PwdzeNOXbFzYheRkJU5FrbM1rozY2BTA0NCA6Og4je3R0XHY2WknhuwUdv8RJ06H0K5NtUzLFbSxYN70blw4PoFDu0azd/M35M9vilMxWy1Fmj4TYyNKFC9E+XIlGDakDe6lHVmx6lC6ZWfO2UHLFtVp71eLMqWL0ahBJb4e1JoFi/dmOoZymr2dJa4uhTW2uZQszP0Hae/WfcnMzJiAsR25cGIyB3d9x+E9YyhWpCDm5qYUzOCHTk57n7FhZ2dNVJTuxpIqKhLlzesa25S3QjFwyPjuctX9uygfxWDgWCLDMmYDR5Kwcj7J+3ehDL1G0t5tJK5dhknXL7It9szkxr7IDvb21hQubKNO1ABcXYuiUql48CDjy4VyUm7rC0nW3pOHhwfPnj3L1jpNTExISXn7dS2jR48mLi5OYxk9OGdPGSmVKhIT3x5b/nwmFLKzIO7xC46dvkWDWhnfAp2dTEyMKFeuJCdPBqm3KZVKTp4MolIl3V7E+j42bz+DbUEL6tZyf6fypqbGFC5kRXKykn0HLtHA1yOHI8wapUpFYmJSuq+9iE/E4I0fLoaGqR9NurxZzNvLmZu3NW+quXUnkmJFbN66r7GxIQ6FrTE0NGD3H+epV9sDAwPdfNy+z9jw8irFqVOXNbadOHEJLy/tjKWUS+cwKK55jaNBcWeUDzK+pEFh74DCyhpVVMZnNDAzA+UbB5UyBRTa6Zvc2BfZwdu7FA8fxvLs2Qv1tpu3HmBgoMDBoaBOYsptfSHJ2ltER0dTv359Vq1aRWBgIDdv3mTDhg389NNPtGrVKlvfy9nZmcDAQK5evUpUVBRJSel/uZmammJpaamxZOUU6LPniQSHRBAcknqK8l54HMEhEdx/8Jjn8YlMn/8XFy7fJ+xBHJf/fcDoSXuIiHpKk3qvnt3VbfA6Vm06p14/+vdN/jp1k7v3Yzl+5hZdB63FpXhB2jbT3kXiPXo0Zf36Q2zZ8hehoWGMHbuE+PgXtG3rC8CIEfOYNm2tunxiYjLBwbcIDr5FYmIyERExBAff4vbtB1qLOT1KpZLN28/SunlljIwMNV4bMWYt02a/mkW9eOkO+w5c4u69aM6eu0nvgYtRqlT07l5Xy1G/Mm3GFs6cDeFeWBRXr4UxbcYWTp+5RotmqbOEI75dyrQZr0451atbgTXr/2LXnjPcvRfF8RNXmDlnO/V8PdVJmy50+7wOFy/d5rfF+7l9J4ode86xftMpPvv01bMVp83axYjvf1ev37wdybZd/3DrdiSBl+/w9ciVhIQ+4Ov/TqXqSlbHRteuTTh6NJAlS3YRGhrG7NkbuXz5Bp9//rFW4k1YuxTD8l6YdPsShWNxjD5ugUmrT0ncuDq1QL78mA4ciWE5LxQOxTCsUoP8P/2K8t5tkv8+pq4n/+zlGLf7XL2efOwQpt37YeRTF4VDMYx8G2HSsSfJR/7USrsg9/VFep49e0Fw8G2Cg28DcO9eFMHBt7n/37MVp03fwIiRC9Tlmzf7CGtrC0Z/t4jr18M4c+YqP/+8Dr+2tXV6CjQ39YVcs/YWFhYWVK9enV9++YXQ0FCSkpJwcnKiT58+fPvtt9n6Xn369OHw4cNUqVKFp0+fcujQIerWrZut7wFw+d8HdB20Tr0eMDv19FSbT8rhP/xjbtyOYcuebTyKi8fa0owKZYuwem4nSrm8emTB3bBYHsXGq9efPE1g+vy/eBD5FGtLMz72Lc3XfWtj/EaykZOaNq1BTMxjZs3aSGRkLGXLlmDRolHqC0LDw6M1ZjcePnxE69av+nDJkl0sWbKLatXKsnLlGK3F/aYTf1/n/oNY/FqlvS4q/EGsxrVPCYlJzJj3B3fDYsif3wTfmu78NOFTLAtk/CywnBYd84SR3y3lYeRjChTIR5lSxVj821fU9Emd7QsPj9GYSevXtykKhYIZs7cT8TCWgjYW1PP15OtB2ftjKKs8yxVnzrQeTJ+9i7kL/sSxWEG+/aYVLZu+uuEjMuox4Q9i1evKFCVLVx7m5u1IjIwMqV7FlTXLvsKxqG5mD17K6tjw9i7N1KkDmDFjA9Onr8PZ2YG5c4dq7bleyuBLxI8agGm/YZj2GIgy/B4vZkx8dSOAMgVD1zIYf9IGRYECqKIekvz3MRIWzIDXnrVmUKw4BlavZkJfTB+Had8hmA0fi6KgLarIhyRtXUvCkjlaaRfkvr5Iz+Wgm3TtNkW9HjBlDQBtWtdkckAfIiNjCQ9/9RxSc3MzliwezoQJq/Fr74+1tQWfNKnKkMF+Wo/9dbmpLxQqlY6fSieyR+QiXUfw4ex190TubPXsnq4jyB7G2r9zMdslZ++lCjqTX7t/CSQnPK7RUdchZAvLk2vfXig3UOrusRnZxiCv3Jjw9ufVyWlQIYQQQgg9JsmaEEIIIYQek2RNCCGEEEKPSbImhBBCCKHHJFkTQgghhNBjkqwJIYQQQugxSdaEEEIIIfSYJGtCCCGEEHpMkjUhhBBCCD0myZoQQgghhB6TZE0IIYQQQo9JsiaEEEIIocckWRNCCCGE0GMKlUql0nUQIjv8o+sAhBA5JempriP4cMYWuo4gW8xTfKbrELJFf9Xvug7hw+WFcQFg7PvWIjKzJoQQQgihxyRZE0IIIYTQY5KsCSGEEELoMUnWhBBCCCH0mCRrQgghhBB6TJI1IYQQQgg9JsmaEEIIIYQek2RNCCGEEEKPSbImhBBCCKHHJFkTQgghhNBjkqwJIYQQQugxSdayya1bt1AoFFy4cEHXoQghhBAiD8kTyVpkZCT9+vWjePHimJqa4uDgQOPGjTl+/LiuQ8tVVq/eR/36g6hQoRvt248hMPB6puX37DlFkybDqFChGy1ajOTIkfNaijRjeaENkDfakRfaALm/Hb+vPUyLNv54Vx+Ed/VBfNp5MkeOXsp0n8ePn+M/4Xdq1R1O+Ur9adzse478lfk+2pDb+sLYwpyav3xLl1sH6fv8Im2Pr6FQlQoAGBgZ8dHk4XwauJ0+T8/TLewoDZZPIX+RQu9dpzbltr54U1bHxeatJyhTvq/GUsG7v9bizRPJmp+fH+fPn2f58uVcu3aN7du3U7duXaKjo3Ud2gdJSkrS2nvt3n2SgIBVDBjQli1bJuLuXpxevSYTHR2Xbvlz564xbNgc2rWry9atk2jQoDIDBkzn2rW7Wov5TXmhDZA32pEX2gB5ox0ODjYM/7otm9d/x6Z13/FRtTIM+GoeIdfvp1s+MSmZHn1+ISwsipnTv2TvznGMH9uFwoWstRv4G3JjX9RbNAGnRj7s7zKCtRVacHffcVrsX4p50UIY5TfD3tuDs+N/ZYN3W/a2HYh1mZI03f7re9epLbmxL96U1XEBYGFhxrHDP6uXQ/smay3eXJ+sxcbGcvToUaZMmUK9evUoUaIE1apVY/To0bRs2RIAhULBokWLaNOmDfnz56dUqVJs375do57Lly/zySefYGFhQeHChenSpQtRUVHq1/fu3UutWrWwtrbG1taW5s2bExoammFcKSkp9OzZE3d3d+7cuQPAtm3b8Pb2xszMDBcXF/z9/UlOTlbvo1Ao+PXXX2nZsiXm5uZMnDgxO/+rMrV06W46dKiHn19d3Nwc8ffvhZmZKZs2HUm3/IoVe6lduyK9e7fA1bUYQ4Z0wMOjJKtW7dNazG/KC22AvNGOvNAGyBvtqF+3Ir51KuBcojAlnQvz9eA25M9vyoWLN9Itv2nzceLinjF3Vn8qe7vhWMyOalXL4O7upOXINeW2vjA0M8XF72NOjviZ8KNneRx6hzP+c4i7fpty/T4j8fFTdnzck9ANe4i9dpOIvy9ydOB4ClUpj4VTkfeqU1tyW1+kJ6vjAlK/o+3trNSLnZ2l1uLN9cmahYUFFhYWbN26lYSEhAzL+fv706FDBwIDA2natCmdO3cmJiYGSE346tevT6VKlTh79ix79+4lIiKCDh06qPd/9uwZQ4cO5ezZsxw4cAADAwPatGmDUqlM814JCQm0b9+eCxcucPToUYoXL87Ro0fp2rUrgwcP5sqVK8yfP59ly5alScjGjh1LmzZtuHTpEj179sym/6XMJSYmExR0Ex+f8uptBgYG+PiU5/z5kHT3uXAhhBo1ymtsq1XLkwsX0i+f0/JCGyBvtCMvtAHyTjtel5KiZNfu0zyPT6SSl0u6ZQ4evohXRVfGTVyDT51hNG89lt8W7CYlJe1nnbbkxr4wMDLCwMiI5Bea30sp8QkUqeWd7j4mVhaolEoSYh9nW53ZLTf2xdu8y7gAeP48gXqNRuHbYCT9vpqb6SxcdjPS2jvlECMjI5YtW0afPn347bff8Pb2xtfXl44dO+Lp6aku1717dzp16gTApEmTmDVrFqdPn6ZJkybMmTOHSpUqMWnSJHX5JUuW4OTkxLVr1yhdujR+fn4a77tkyRLs7e25cuUK5cu/OgifPn1Ks2bNSEhI4NChQ1hZWQGpyeKoUaPo1q0bAC4uLowfP54RI0bw448/qvf/7LPP6NGjR/b/R2Xi0aMnpKQosbW10thua2vFjRvpH4xRUbHY2aUtHxUVm1NhZiovtAHyRjvyQhsg77QD4Oq1e3TsPIWExCTy5zdl7sx+uLkWTbfs3XuRnAr7lxbNqrPg10HcufMQ/wm/k5ycwsD+LbQcearc2BdJT5/x4MQ5qozpz6PgG8RHRFGqU3MK1/Ai7vqdNOUNTU34aMpwQtbsIunJs2ypMyfkxr7ISFbGRUnnwkwa140yZRx58uQ5S5b9ScfPJ7Nrqz8ODjY5Hmuun1mD1GvW7t+/z/bt22nSpAmHDx/G29ubZcuWqcu8nriZm5tjaWnJw4cPAbh48SKHDh1Sz9JZWFjg7u4OoD7VGRISQqdOnXBxccHS0hJnZ2cA9SnOlzp16sSzZ8/Yt2+fOlF7+R7jxo3TeI8+ffoQHh7O8+fP1eWqVKny1vYmJCTw+PFjjSUhITFr/2lCiP8bJUs6sHXTGNb/PppOHXwZ+d1Sroem/8WqUqqwLViA8WO7UL5cCZp+UpUv+zZl7fr0T3GJjO3vMgIUCrrfP8oXCZeoMKgL19fsgjfOyBgYGfHx+pkoFAqO9Psxg9qyVqd4u6yMi0perrRuVYOy7k5Uq1qG2TO+pKBNAdZu+Esrseb6mbWXzMzMaNSoEY0aNWLMmDH07t2bH3/8ke7duwNgbGysUV6hUKhPYT59+pQWLVowZcqUNPUWKZJ67UCLFi0oUaIECxcupGjRoiiVSsqXL09iomaS1LRpU1atWsXJkyepX7++evvTp0/x9/enbdu26cb+krm5+VvbGhAQgL+/v8a2H3/sw9ixX7x13/TY2BTA0NAgzcWh0dFx2NlZp7uPnZ01UVHvXj6n5YU2QN5oR15oA+SddgCYGBtRonjqBejly5XgUtAtVqw6wLgfu6Qpa29vhZGRIYaGr37Lu7g4EBn1mMSkZEyMtf+1kVv74vGNu2yr2wWj/PkwsbTg+YNIPl77C49vvLqwPjVRm0GBEkXZVr9bhrNqWakzJ+XWvkhPVsbFm4yNjShb1ok7dx7mdJhAHplZS4+HhwfPnmV+0L/k7e1NUFAQzs7OuLm5aSzm5uZER0dz9epVvv/+exo0aEDZsmV59OhRunX169ePyZMn07JlS44cOaLxHlevXk1Tv5ubGwYGWeuG0aNHExcXp7GMHv3+p05NTIwoV64kJ08GqbcplUpOngyiUqVS6e7j5VWKU6cua2w7ceISXl7pl89peaENkDfakRfaAHmnHelRKlUkJian+5q3lxt37kRqXI9769ZD7O2tdJKoQe7vi+Tn8Tx/EImptSVOjWtxc9sB4FWiZlWqBNsbdichJvaD68xpub0vMpPZuHhTSoqSayFh2Ntbvb1wNsj1yVp0dDT169dn1apVBAYGcvPmTTZs2MBPP/1Eq1at3qmOAQMGEBMTQ6dOnThz5gyhoaH88ccf9OjRg5SUFGxsbLC1tWXBggVcv36dgwcPMnTo0Azr++qrr5gwYQLNmzfn2LFjAPzwww+sWLECf39/goKCCA4OZu3atXz//fdZbrOpqSmWlpYai6mpSZbreV2PHk1Zv/4QW7b8RWhoGGPHLiE+/gVt2/oCMGLEPKZNW6su37VrE44eDWTJkl2EhoYxe/ZGLl++weeff/xBcXyIvNAGyBvtyAttgLzRjmm/bObM2WvcC4vi6rV7TPtlM6fPXKNFs+oAjBi9hGm/bFaX7/SpL7Fxz5g4eR03b0Vw+Egg8xfupnPHujpqQarc2BdOH9fCqXFtCjg74tjQh1aHVvDo3xv8u3QzBkZGNN44i0JVyrO/83AUhobkK2xHvsJ2GLx2Jqjl/mWUH9D5nerUltzYF2/K6riY8+tOjh0P4u7dSIKu3OabUYu5fz+G9n61tBJvrj8NamFhQfXq1fnll18IDQ0lKSkJJycn+vTpw7fffvtOdRQtWpTjx48zcuRIPv74YxISEihRogRNmjTBwMAAhULB2rVrGTRoEOXLl6dMmTLMmjWLunXrZljnkCFDUCqVNG3alL1799K4cWN27tzJuHHjmDJlCsbGxri7u9O7d+9s+p/4ME2b1iAm5jGzZm0kMjKWsmVLsGjRKPVFoeHh0RozgN7epZk6dQAzZmxg+vR1ODs7MHfuUEqX1t3t/XmhDZA32pEX2gB5ox3RMU8Y+e1SHkbGUaBAPsqULsbi+YOp6eMBQHh4DAYGCnX5IkUKsnj+YAJ+Wk/Ltv4ULmRN188b0KdXE101AcidfWFiVYCPAoZi4ejAi5hYbmzax9/f/YIyOZkCJYpRslUDAD69qPkoqa11u3D/yGkALF2dyGdn8051aktu7Is3ZXVcPH78jDFjVxIZ9Rgry/yU8yjO2lUjM7whIbspVCqVSivvJHLYP7oOQAiRU5Ke6jqCD2dsoesIssU8hfaeZ5aT+qt+13UIHy4vjAsAY9+3Fsn1p0GFEEIIIfIySdaEEEIIIfSYJGtCCCGEEHpMkjUhhBBCCD0myZoQQgghhB6TZE0IIYQQQo9JsiaEEEIIocckWRNCCCGE0GOSrAkhhBBC6DFJ1oQQQggh9Jgka0IIIYQQekySNSGEEEIIPSbJmhBCCCGEHlOoVCqVroMQ2eEfXQcg8pq88NGgUOg6guyRF/oir8gjx5S/4jNdh/DBflT9rusQsknlt5aQmTUhhBBCCD0myZoQQgghhB6TZE0IIYQQQo9JsiaEEEIIocckWRNCCCGE0GOSrAkhhBBC6DFJ1oQQQggh9Jgka0IIIYQQekySNSGEEEIIPSbJmhBCCCGEHpNkTQghhBBCj0myJoQQQgihx4x0HUBu1b17d5YvX65eL1iwIFWrVuWnn37C09NTh5G9v9Wr97F48U4iI+Nwdy/OmDHd8PR0S7fsvn2n+e23bdy5E0FycgolSjjQo0dTWreureWoNWWlDSEh95g1awNBQTcJC4ti9OgudO/+iZYjTl9W2rF+/UG2bj1KSMhdAMqVK8nQoZ9mWF5bUtuwi8io/9rwfTc8PV3TLdulywROnwlOs93X14sF87/J6VAzlRf6ArLWH5s3H2H0tws0tpmYGHMpcJkWIs1YXmgD5L7PWhMLc+qNH4x7m4aYF7Llwfkr7B08iftnLwHwo+pquvv9+c1PnJi6ON3Xao3qi3vbj7FzdyE5/gV3T5xn/8ipRF+7mWPtSE9W+gJgz55TzJy5gbCwKJydHRg+vCO+vpVyPE6ZWfsATZo0ITw8nPDwcA4cOICRkRHNmzfXdVjvZffukwQErGLAgLZs2TIRd/fi9Oo1mejouHTLW1lZ0K9fa9at82f79sm0bVuHb7+dz9GjF7Uc+StZbUN8fAKOjoUYNqwj9vbW2g02E1ltx99/X6FZMx9WrPietWv9KVLElp49JxMREaPlyF/ZvfskAZNXp7Zh8wTcyxSnV++M2zB79hCOHZ2rXnbumIKhoQFNGlfTcuSa8kJfQNb7A8DCIp9Gnxw6OFOLEaeVF9oAufOztsWiCbg08mFLlxH8WqEFofuO02X/UgoULQTAVIeaGsu2HqNRKZVc2fRHhnWW8K3GmbmrWfxRB1Y26oGBsRGf71uMcf582mpWlvvi3LlrDBs2h3bt6rJ16yQaNKjMgAHTuXbtbo7HKsnaBzA1NcXBwQEHBwe8vLwYNWoUd+/eJTIyEoCRI0dSunRp8ufPj4uLC2PGjCEpKUmjjgkTJlCoUCEKFChA7969GTVqFF5eXlpvy9Klu+nQoR5+fnVxc3PE378XZmambNp0JN3y1at70KhRVVxdi1G8eGG6dfuEMmWK888/6f/C0oastsHT05WRIzvTrJkPJib6M8mc1XZMmzaQzp0bUbasM66uxZgwoS9KpYqTJy9rOfJXli7bQ4f29fDz8/2vDT0zbYO1tQX29tbq5fiJS5iZmdCkSXUtR64pL/QFZL0/ABQKhUaf2NlZaTHitPJCGyD3fdYamZni4fcx+0f8zJ2jZ3kUeocj/nOIuX6bKv0+A+BZRJTGUqZVA24e+pvYm/cyrHf1J725uHwLkVeuExF49X/t3XlcTfn/B/DXve17kSiiEhKJZI/KFiLJjPmaLKkxY81OxtBC9n0ZzCiKGctYirINRpIME7K0oEIILUp73dv5/dHPGXe6cSt17r3ez8fjPh7dc8699/XpdG/v+zmf8zkI9/CBbqvmMOzaoUHaBdR8X4SGnkXfvtb47rsRaN26OWbPHgNLS1McOHC+3rNSsfaZFBQU4MCBAzA3N0fjxo0BAFpaWti3bx8SEhKwZcsW/Prrr9i0aRP7mN9++w2BgYFYs2YN4uLi0LJlS+zcubPBs5eVCfDgQRp69+7ILuPz+ejduyNu3370ycczTOU/o7S0DHTr1r4+o1arrm2QFp+jHcXFpRAIBNDR0ayvmB9VbRt6dcTtO5K14djRy3Ae1gvq6qr1FfOT5GFfALXfH0VFJXDs7w17h5mYOm0DHj2q/h9vfZOHNgCy+VnLV1QEX1ERgpJSkeWC4lK0tLOpsr2GQWO0cbbH7aCjNXodFR0tAEBxTvU9pZ9TbfbFnTuP0KtXR5FldnadcEfCz7W6kJ7uBBkUEREBTc3KD+HCwkIYGhoiIiICfH5lDfzTTz+x25qYmGD+/Pk4dOgQFi5cCADYtm0bvLy8MGnSJADAsmXLcP78eRQUFDRoO96+zYdQWIHGjUW/dTZurIPU1JfVPi4/vwj9+k1HWZkAfD4fvr6T0KePVX3HFau2bZA2n6Md69cfhIGBnsiHUEOqtg362khN+3Qb7t5NwcNHzxEY+H19RZSIPOwLoHb7w9TUCCsDv0e7dsbIzy9GcHAk/jfWD5ERa9CsWeOGiC1CHtoAyOZnbVlBIdKv3UK/pdOQmZiKwtdZ6Dh2OFr06oycx8+qbG89cRTK8guReLwGvU08HoZs/hHPrsYh80HDfLmuzb7Iysqt0jvbuLEOsrJy6ysmi4q1OnB0dGR7wt6+fYuff/4ZQ4cOxY0bN9CqVSscPnwYW7duRUpKCgoKCiAQCKCtrc0+Pjk5GdOmTRN5zu7du+PSpUsffd3S0lKUlop+y1FRKYOKivJnaplkNDRUERa2CkVFJYiNfYDVqw/A2NgAPXpYNmgO8q9ffjmJ06djERq6tMH/Hj6Xo0cvo21b42oHjssKWd4XXbq0QZcubUTuD3NeiEOHL2H2rK85TCY5eWjDe1x/1p4YvxAuwSsx72U0KgQCZNxKwP2DkWIPWXbxHI17v52CsLRM4ud33uELg45tEGz37eeMLVfoMGgdaGhowNzcHObm5ujWrRv27NmDwsJC/Prrr4iNjYW7uzuGDRuGiIgI3L59G0uWLEFZmeR/wNVZtWoVdHR0RG6rVu2t9fPp6WlBQYFfZVBldnYe9PV1q30cn89Hq1bN0L69CTw9neHk1B2//BJe6xx1Uds2SJu6tCMoKAK//HISQUGLYWHRsh5Tfly1bch698kxQ0VFJYg8HYuvvnKox4SSkYd9AdRtf7ynpKSI9u1b4dnT1/UR8ZPkoQ2A7H7Wvk1NR4jDeKzU6IxNxg7Y0+Nr8JUU8TZVdGB9S7uu0Lcww609f0j83EO3LUWb4Q4IcZyI/BcNt29qsy/09XWRlcXN/xgq1j4jHo8HPp+P4uJiXLt2Da1atcKSJUtga2uLNm3a4OnTpyLbt2vXDjdv3hRZ9t/74ixevBh5eXkit8WLJ9U6t7KyIjp0MEVs7AN2WUVFBWJjH4h8M/2UigoGZWWCWueoi8/VBq7Vth2//noKP/98Anv2LIKVlVlDRK1WtW24fh9dOn98X5w9+zfKygRwGdGnvmN+kjzsC6Bu++M9obACDx+mc3bWtDy0AZD9z9ryomIUvMqEqq42zJ3skBx+UWR9F6+v8PKf+3h9V7KTH4ZuWwqLUYMQ2n8icp807HjC2uyLzp3b4Pp10ZOFrl27h84S/g3WBR0GrYPS0lK8evUKQOVh0O3bt6OgoAAjRozAu3fv8OzZMxw6dAjdunVDZGQkTpw4IfL4mTNnYvLkybC1tUXv3r1x+PBh3L17F2ZmH/+AV1FRgYqKyn+W1u0wy6RJw7Bo0S507GiGTp1aIyTkDIqLS+DmZg8AWLjwZzRt2gjz5v0PALB7dzg6djRDy5YGKCsTICrqDk6evAo/P8865WjINpSVCZCS8pz9+fXrHCQmPoG6uipatWomM+345ZeT2Lr1KDZsmIHmzZsgMzMXAKCurgoNDW4G6E/yGIpFPrvRsaPp/7fhLIqLS/9tw6KdaGqgx7bhvaPHojBwYFfo6WlxEbsKedgXQM33x/Ydx9HZ2hytWjXDu3eFCAqKxMuXWfj6awdqQx3J4mdt68F2AI+H7OQ0NDJviUHrFiIrKRV39h5nt1HW0oDl10Nwft4asc8x/sI+JJ34Ezd3/AYAGLbDF1bfDsehkdNQml8Ijab6AIDSvPwqJzPUl5ruiwkThmD8+OUIDo6EvX1nnD4di/v3UxEQ8F29Z6VirQ7Onj0LQ0NDAJVnflpYWOCPP/6Ag4MDAGDOnDmYMWMGSktL4ezsjKVLl8LPz499vLu7O1JTUzF//nyUlJRgzJgx8PDwwI0bNxq8LcOG9UJOzjts3XoUmZm5aN++Ffbs8WEPMWRkZLMnTgBAUVEp/P2D8epVDlRVlWFmZoR166Zh2LBeDZ79vZq24c2bt3B1/ZG9HxwcieDgSHTv3h779y9t8Pzv1bQdhw5dQHm5AN7em0WeZ8YMN8yc+VVDRmdVtiEfW7cdRWZmXmUbfl30bxteZoPP44k8JjX1JeLikhEc5MNFZLHkYV8ANd8f794VYumyPcjMzIOOjgY6dDDFoYN+MDdvwVUT5KINgGx+1qroaGHAqrnQbtEMxTm5SDx2HpeWbEKF4N/evY7/cwaPx8P9gxFin6NRa2Oo6+ux97tNqxyf5hF1QGS7MA8fxIeIdmzUl5ruCxubtli/fjo2b/4DGzceholJM+zYMRdt2xrXe1YewzBMvb8KkdigQYPQrFkz7N+/v4aPjKuXPOQLJg8fDf8pCGWWPOwLeSEnf1P+PNkfzO/L/M51hM+k6ye3oJ41DhUVFWHXrl1wcnKCgoICDh48iAsXLuDPP//kOhohhBBCpAQVaxzi8Xg4ffo0AgMDUVJSgnbt2uHYsWMYOHAg19EIIYQQIiWoWOOQmpoaLly4wHUMQgghhEgxmrqDEEIIIUSKUbFGCCGEECLFqFgjhBBCCJFiVKwRQgghhEgxKtYIIYQQQqQYFWuEEEIIIVKMijVCCCGEEClGxRohhBBCiBSjYo0QQgghRIpRsUYIIYQQIsV4DMMwXIcgn0Mc1wEIIfWFEXKdoO54Clwn+DzKC7hO8HkoaXKdoM7W8b7lOsJnsYBJ/uQ21LNGCCGEECLFqFgjhBBCCJFiVKwRQgghhEgxKtYIIYQQQqQYFWuEEEIIIVKMijVCCCGEEClGxRohhBBCiBSjYo0QQgghRIpRsUYIIYQQIsWoWCOEEEIIkWJUrBFCCCGESDG5KNb8/PzQuXPnatfv27cPurq6dXoNDw8PuLq61uk5CCGEEEJqSiqKtdjYWCgoKMDZ2ZnrKJxzcHDA7NmzOXnt3347j/79vWFlNRFff70Ud+8+/uj2Z85cx5Ah82BlNREjRixCVNTtBkpaPXloAyAf7ZCHNgCy346bN5MwZcoG2PWdiXYW43Hhwj8f3f7Nm1zMm/cznJwWwKL9BASuPNBAST+tJvvi0aPnmDlzE/r390a7dt9i374zDZhUvN8PXcaIUf6w6eENmx7e+MZ9NaKi71W7/XiP9WjX8fsqt++nbm3A1OLJ2vtCSVMDjpt+xPdPLmF2UTy+jTmIZrZW7Pqhe1dhAZMscvvqzJ6PPmeLvrYYdXInpr6IxgImGeYjB9Rbfqko1oKCgjBz5kxcuXIFL1++5DrOF+n06VisWnUA06e74cSJQFhYtISX12pkZ+eJ3f7WrYeYN287vvrKAWFhKzFgQFdMn74RDx+mN3Dyf8lDGwD5aIc8tAGQj3YUFZeinUVL+C6bKNH2ZWXl0GukhalTR8LComU9p5NcTfdFcXEpWrQwwLx5/0OTJroNG7YazZrpYf4cNxw/sgTHDi9Bz+7tMH3mz3j0WPz/vW1bpuLq5XXsLSLMDwoKfAxxsm3g5KJk8X0xZM8KmAzqjdPjF2Kf1Qg8OR+DMRf2QtPIgN0m9cwV/NysD3s7NXbuR59TSUMdmfHJuDDdv77jc1+sFRQU4PDhw5g6dSqcnZ2xb98+kfWXL18Gj8fDxYsXYWtrC3V1dfTu3RvJycnVPmdKSgrMzMwwY8YMMAwjdpvw8HDY2NhAVVUVZmZm8Pf3h0Ag+GRef39/NGnSBNra2pgyZQrKysrYdaWlpfD29oaBgQFUVVVhZ2eHmzdvijw+KioK3bt3h4qKCgwNDeHj48O+roeHB6KiorBlyxbweDzweDw8efLkk5k+h717T2PMGEeMHu0Ac/MW8Pf3gqqqCo4dixK7fWjoWfTta43vvhuB1q2bY/bsMbC0NMWBA+cbJK848tAGQD7aIQ9tAOSjHfb9rDFn9tcYNEiyf/AtWjTBT0vGw9XVDlqaavWcTnI13RedOrXGokXucHbuDWVlxQZOK15/B2vY97OCSaumMDVpijmzRkFdXQV34lPFbq+ro4Em+jrsLSY2AaqqyhgyuGsDJxcla+8LRVUVtB09GFEL1+F59D/ITXmGa/7b8fbxU3Se+i27nbC0DIWvs9hbae67jz5v2tkruLp0Mx6FXajvJnBfrB05cgQWFhZo164dxo0bh+DgYLEF1pIlS7Bhwwb8888/UFRUhKenp9jnu3v3Luzs7PDtt99i+/bt4PF4VbaJjo7GhAkTMGvWLCQkJGD37t3Yt28fAgMDP5r14sWLSExMxOXLl3Hw4EEcP34c/v7/VtQLFy7EsWPHEBISglu3bsHc3BxOTk7IyckBALx48QLDhg1Dt27dEB8fj507dyIoKAgrVqwAAGzZsgW9evXC5MmTkZGRgYyMDBgbG0v8u6ytsjIBHjxIQ+/eHdllfD4fvXt3xO3bj8Q+5s6dR+jVq6PIMju7TrhzR/z29U0e2gDIRzvkoQ2A/LRDHtRmX0g7obACkadvoKi4DF06m0n0mGPHr8J5aDeoq6vUc7rqyeL7gqeoCL6iIgQlpSLLBcWlaG5nw943duiOaa+vwSvpLAb97AfVRroNkk8SnBdrQUFBGDduHABgyJAhyMvLQ1RU1eo8MDAQ9vb2sLS0hI+PD65du4aSkhKRba5duwYHBwfMnz+fLYDE8ff3h4+PDyZOnAgzMzMMGjQIy5cvx+7duz+aVVlZGcHBwejQoQOcnZ0REBCArVu3oqKiAoWFhdi5cyfWrVuHoUOHwtLSEr/++ivU1NQQFBQEAPj5559hbGyM7du3w8LCAq6urvD398eGDRtQUVEBHR0dKCsrQ11dHc2aNUOzZs2goKBQ019pjb19mw+hsAKNG+uILG/cWAdZWbliH5OVlQt9fcm3r2/y0AZAPtohD20A5Kcd8qA2+0JaJT98ji7dZsLKZhp8l/+GHVumwry10Scfd/deGh4+eomvR9s1QMrqyeL7orygEC+u3UKvpdOgYWgAHp8PS3cXGPXqDE3DysOgaWejcXrCIhwZ4IGoRevQwr4bvjrzK3h8zsskAACnfcPJycm4ceMGTpw4URlGURHffPMNgoKC4ODgILJtp06d2J8NDQ0BAG/evEHLlpVjKp49e4ZBgwYhMDDwkwP04+PjERMTI9KTJhQKUVJSgqKiIqirq4t9nLW1tci6Xr16oaCgAOnp6cjLy0N5eTn69OnDrldSUkL37t2RmJgIAEhMTESvXr1Eevv69OmDgoICPH/+nG3Lp5SWlqK0VPQbgopKGVRUlCV6PCGEEG6YmjZD2LGlyM8vxrnzcVi0ZC8O7Jv/yYLt6PGraNumOTpZmTZQUvlyevxCDAleiWkvo1EhEOD1rQQkHYxE064dAABJh0+z22bdf4jMu8n4PvUijB2649ml61zFZnFaMgYFBUEgEMDIyAiKiopQVFTEzp07cezYMeTliQ5UVFJSYn9+X+xUVFSwy5o0aYLu3bvj4MGDePfu48eZCwoK4O/vjzt37rC3e/fu4dGjR1BVVf2MLawfq1atgo6Ojsht1aq9tX4+PT0tKCjwqwwOzc7Og76+rtjH6OvrIitL8u3rmzy0AZCPdshDGwD5aYc8qM2+kFbKSopo1dIAHTu0wrw5brBo1wKhBy5+9DFFRaWIPHMTX7lx26sGyO77Ijc1HYccxmOzRmfsMnbAgR5fg6+kiNxU8Sc55KU9R1FmDvTMWzVYxo/hrFgTCAQIDQ3Fhg0bRIqm+Ph4GBkZ4eDBgzV6PjU1NUREREBVVRVOTk7Iz8+vdlsbGxskJyfD3Ny8yo3/kS7P+Ph4FBcXs/evX78OTU1NGBsbo3Xr1lBWVkZMTAy7vry8HDdv3oSlpSUAoH379oiNjRUZkxcTEwMtLS20aNECQOWhVqFQ+NG2Ll68GHl5eSK3xYsnffwX9BHKyoro0MEUsbEP2GUVFRWIjX2ALl3aiH1M585tcP36fZFl167dQ+fO4revb/LQBkA+2iEPbQDkpx3yoDb7QlZUVDAoK/v4yW1nz8ehrEwAlxE9GihV9WT9fVFeVIzCV5lQ0dWGiZMdHoeLL5Q1mzeFWmNdFGRkNnBC8Tgr1iIiIvD27Vt4eXmhY8eOIrfRo0ez47xqQkNDA5GRkVBUVMTQoUNRUFAgdrtly5YhNDQU/v7+ePDgARITE3Ho0CH89NNPH33+srIyeHl5ISEhAadPn4avry9mzJgBPp8PDQ0NTJ06FQsWLMDZs2eRkJCAyZMno6ioCF5eXgCAadOmIT09HTNnzkRSUhLCw8Ph6+uLuXPnskWiiYkJ/v77bzx58gRZWVkivYfvqaioQFtbW+RW10OgkyYNw5Ejf+HEiStISXkBP79gFBeXwM3NHgCwcOHP2LDhELv9hAlDEB19F8HBkUhJeYFt247i/v1UjBs3uE456kIe2gDIRzvkoQ2AfLSjsLAEiYlPkZj4FADw/HkmEhOf4uXLLADAhg2HsXDRLpHHvN++sKgUOTnvkJj4FI8fv2jw7B+q6b4oKxMgMfEJEhOfoKxMgNevc5CY+ARPn77iqgnYsOk4bv7zEM9fZCH54XNs2HQcN24+xAjnyiJs4eJgbNh0vMrjjh6/ioH9O0NPV7OhI4sli+8Lk8F2MHHqCx2TFmg1sDf+91cocpJScX/vcShpqMN+7UIY9rCGdqvmaNm/J0aF/4y3j5/iyblo9jnGXNiHLtPd2ftKGuowsLaAgbUFAEDHtAUMrC2gZWz42fNzNmYtKCgIAwcOhI6OTpV1o0ePxtq1a3H37t0aP6+mpibOnDkDJycnODs74/Tp01W2cXJyQkREBAICArBmzRooKSnBwsIC33333Uefe8CAAWjTpg369euH0tJSjB07Fn5+fuz61atXo6KiAuPHj0d+fj5sbW1x7tw56OnpAQCaN2+O06dPY8GCBbC2tkajRo3g5eUlUiTOnz8fEydOhKWlJYqLi5GWlgYTE5Ma/x5qatiwXsjJeYetW48iMzMX7du3wp49Puyg0IyMbJFeRxubtli/fjo2b/4DGzceholJM+zYMRdt29b/2avVkYc2APLRDnloAyAf7bh/Pw0TJq5k769a/TsAYJSrHVav/gGZmbnIeJkt8hjXUf9+Jj14kIaIiFg0N9LHpUubGia0GDXdF2/evIWr64/s/eDgSAQHR6J79/bYv39pg+cHgOycfCz6cS/eZOZBS0sN7do2R9DuWejTu/LoS0ZGDvh80RkMUtNeIe7WYwT/MpuDxOLJ4vtCRUcL/VbNhWaLZijJycXDY+cRvWQTKgQC8BUV0KRTW3SY6ApVXS0UvHyDJ+djcHXpFgjLytnn0G1tDDV9PfZ+M9uO+N/l/ez9/psq/97u7zuOM5MWf9b8PKa6iciIjInjOgAhpL4wHx8aIRN49X9me4MoF3/ERuYoSUcvXV2s43376Y1kwAKm+nlj35OOc1IJIYQQQohYVKwRQgghhEgxKtYIIYQQQqQYFWuEEEIIIVKMijVCCCGEEClGxRohhBBCiBSjYo0QQgghRIpRsUYIIYQQIsWoWCOEEEIIkWJUrBFCCCGESDEq1gghhBBCpBgVa4QQQgghUoyKNUIIIYQQacYQIoGSkhLG19eXKSkp4TpKrclDGxhGPtohD21gGGqHNJGHNjCMfLRDHtrAMNLVDh7DMAzXBSORfu/evYOOjg7y8vKgra3NdZxakYc2APLRDnloA0DtkCby0AZAPtohD20ApKsddBiUEEIIIUSKUbFGCCGEECLFqFgjhBBCCJFiVKwRiaioqMDX1xcqKipcR6k1eWgDIB/tkIc2ANQOaSIPbQDkox3y0AZAutpBJxgQQgghhEgx6lkjhBBCCJFiVKwRQgghhEgxKtYIIYQQQqQYFWuEEEIIIVKMijUil8rLy+Hp6Ym0tDSuoxBCCJEBz549g7hzLhmGwbNnzzhI9C8q1ki1kpOTMWPGDAwYMAADBgzAjBkzkJyczHUsiSgpKeHYsWNcxyCE1KMrV65AIBBUWS4QCHDlyhUOEtWcQCBAQEAAnj9/znWUL56pqSkyMzOrLM/JyYGpqSkHif5FxRoR69ixY+jYsSPi4uJgbW0Na2tr3Lp1Cx07dpSZIsjV1RVhYWFcx6gzee4lfPfuHcLCwpCYmMh1FIkpKCjgzZs3VZZnZ2dDQUGBg0SSuXv3rsQ3WeHo6IicnJwqy/Py8uDo6MhBoppTVFTEunXrxBadpGExDAMej1dleUFBAVRVVTlI9C9FTl+dSK2FCxdi8eLFCAgIEFnu6+uLhQsXYvTo0Rwlk1ybNm0QEBCAmJgYdO3aFRoaGiLrvb29OUpWM+97CZcuXcp1lDobM2YM+vXrhxkzZqC4uBi2trZ48uQJGIbBoUOHZOLvqrqpKUtLS6GsrNzAaSTXuXNn8Hi8avO/X8fj8SAUChs4Xe1U9881Ozu7yvtdmvXv3x9RUVEwMTHhOkqddOnSRez+4PF4UFVVhbm5OTw8PKSukJ47dy6AypxLly6Furo6u04oFOLvv/9G586dOUpXiYo1IlZGRgYmTJhQZfm4ceOwbt06DhLVXFBQEHR1dREXF4e4uDiRdTweT2aKNeDfXsI5c+ZwHaVOrly5giVLlgAATpw4AYZhkJubi5CQEKxYsUKqi7WtW7cCqPzb2bNnDzQ1Ndl1QqEQV65cgYWFBVfxPkmeembd3NwAVO4LDw8PkRnmhUIh7t69i969e3MVr8aGDh0KHx8f3Lt3T+wXSxcXF46S1cyQIUOwc+dOWFlZoXv37gCAmzdv4u7du/Dw8EBCQgIGDhyI48ePY+TIkRyn/dft27cBVBb/9+7dE/nSpaysDGtra8yfP5+reACoWCPVcHBwQHR0NMzNzUWWX716FX379uUoVc3I0z8neeklzMvLQ6NGjQAAZ8+exejRo6Gurg5nZ2csWLCA43Qft2nTJgCVH+i7du0SOeSprKwMExMT7Nq1i6t4n9SqVSuuI3w2Ojo6ACr3hZaWFtTU1Nh1ysrK6NmzJyZPnsxVvBqbNm0aAGDjxo1V1slST2dWVhbmzZtX5SjAihUr8PTpU5w/fx6+vr5Yvny5VBVrf/31FwBg0qRJ2LJlC7S1tTlOVBVdboqItWvXLixbtgxjxoxBz549AQDXr1/HH3/8AX9/fxgZGbHbSvu3vrKyMqSlpaF169ZQVJTN7ycfG9zK4/GQmpragGlqr23btlixYgWcnZ1hamqKQ4cOoX///oiPj8eAAQOQlZXFdcRPcnR0xPHjx6Gnp8d1lDpLSEjAs2fPUFZWJrJc2t/TQGWh5unpiW3bton0chLu6OjoIC4ursqX/MePH6Nr167Iy8tDUlISunXrhvz8fI5SSub9CR8tWrTgOMn/YwgRg8fjSXTj8/lcR61WYWEh4+npySgoKDAKCgpMSkoKwzAMM2PGDGbVqlUcp/sy7dixg1FUVGR0dXUZa2trRigUMgzDMFu3bmUcHBw4TvflSElJYTp16sS+hz98P0vze/pDQqGQUVJSYh4+fMh1lM+quLiY6wi1ZmBgwISEhFRZHhISwhgYGDAMwzAPHjxg9PX1GzqaRIRCIePv789oa2uz7wUdHR0mICCA/aziimx2M5B6V1FRwXWEOlu8eDHi4+Nx+fJlDBkyhF0+cOBA+Pn5wcfHh8N0tSPrvYTTpk1D9+7dkZ6ejkGDBoHPrzwh3czMDCtWrOA4neSeP3+OkydPiu2VEncoS9rMmjULpqamuHjxIkxNTXHjxg1kZ2dj3rx5WL9+PdfxJMLn89GmTRtkZ2ejTZs2XMepE6FQiJUrV2LXrl14/fo1Hj58CDMzMyxduhQmJibw8vLiOqJEZs6ciSlTpiAuLg7dunUDUDlmbc+ePfjxxx8BAOfOneN8sH51lixZgqCgIKxevRp9+vQBUDn0x8/PDyUlJQgMDOQuHKelIiH1qGXLlkxsbCzDMAyjqanJ9qw9evSI0dLS4jJajclrL6FAIGBu377N5OTkcB1FYhcuXGDU1dWZjh07MoqKikznzp0ZXV1dRkdHh3F0dOQ6nkQaN27MxMfHMwzDMNra2kxSUhLDMAxz8eJFpnPnzlxGq5GTJ08ydnZ2zL1797iOUif+/v6MmZkZc+DAAUZNTY19fx86dIjp2bMnx+lq5sCBA0zPnj0ZPT09Rk9Pj+nZsyfz22+/seuLioqktvfQ0NCQCQ8Pr7I8LCyMMTIy4iDRv2ieNVKtqKgojBgxAubm5jA3N4eLiwuio6O5jiWxzMxMGBgYVFleWFgo9vRyafZhL+GH8/0MHDgQhw8f5jBZzcyePRtBQUEAKnsT7O3tYWNjA2NjY1y+fJnbcBJavHgx5s+fj3v37kFVVRXHjh1Deno67O3t8fXXX3MdTyJCoRBaWloAAH19fbx8+RJA5UkIsjLxNQBMmDABN27cgLW1NdTU1NCoUSORm6wIDQ3FL7/8And3d5ETV6ytrZGUlMRhsppzd3dHbGwscnJykJOTg9jYWHz77bfsejU1Nc7nLKtOTk6O2DO6LSwsxM7n15Bk7zgKaRAHDhzApEmT4Obmxp5pGBMTgwEDBmDfvn0ibz5pZWtri8jISMycORMA2AJtz5496NWrF5fRaiwsLAyHDx9Gz549RQrNDh06ICUlhcNkNXP06FGMGzcOAHDq1CmkpaUhKSkJ+/fvx5IlSxATE8Nxwk9LTEzEwYMHAVROaFpcXAxNTU0EBARg5MiRmDp1KscJP61jx46Ij4+HqakpevTogbVr10JZWRm//PILzMzMuI4nsc2bN3Md4bN48eJFlUH5QOVwlPLycg4SfZmsra2xfft2dpqe97Zv3w5ra2uOUlWiYo2IFRgYiLVr14rM6+Xt7Y2NGzdi+fLlMlGsrVy5EkOHDkVCQgIEAgG2bNmChIQEXLt2DVFRUVzHqxF56SXMyspCs2bNAACnT5/G119/jbZt28LT0xNbtmzhOJ1kNDQ02HFqhoaGSElJQYcOHQBAJs5mBYCffvoJhYWFAICAgAAMHz4cffv2RePGjWWqp3bixIlcR/gsLC0tER0dXWV6laNHj6JLly4cpao5oVCITZs24ciRI2LHc3LdO/Upa9euhbOzMy5cuMB+oY+NjUV6ejpOnz7NaTY6DErESk1NxYgRI6osd3FxkZn5y+zs7HDnzh0IBAJYWVnh/PnzMDAwQGxsLLp27cp1vBp530v4nqz2EjZt2hQJCQkQCoU4e/YsBg0aBAAoKiqS6ks1fahnz564evUqAGDYsGGYN28eAgMD4enpyU5zI+2cnJzYiWXNzc2RlJSErKwsvHnzBv379+c43ce9e/dO5OeP3WTFsmXLMGPGDKxZswYVFRU4fvw4Jk+ejMDAQCxbtozreBLz9/fHxo0b8c033yAvLw9z586Fm5sb+Hw+/Pz8uI73Sfb29nj48CFGjRqF3Nxc5Obmws3NDcnJydzPL8rpiDkitVq3bs3s2rWryvKdO3cy5ubmHCT6skVHRzOamprMlClTGFVVVWbWrFnMoEGDGA0NDeaff/7hOp7EfH19GR0dHcbCwoJp2bIlU1JSwjAMwwQFBcnMQOqUlBR2cH5BQQHzww8/MFZWVoybmxvz5MkTjtPJPz6fz7x+/ZphGEZkupEPb9I+rZA4V65cYQYOHMg0adKEUVNTY/r06cOcO3eO61g1YmZmxkRERDAMU3lS1+PHjxmGYZgtW7YwY8eO5TKazKNJcYlYO3fuxOzZs+Hp6cletiUmJgb79u3Dli1b8MMPP3Cc8NNu3boFJSUlWFlZAQDCw8Oxd+9eWFpaws/PT6qv4yhOSkoKVq9ejfj4eBQUFMDGxgaLFi1i2ycrjh49ivT0dHz99dfshJMhISHQ1dWVqlnN5c37njRJHD9+vB6T1E1UVBT69OkDRUXFTw5nsLe3b6BUdfP8+fNqJ1+9fv26zPTYamhoIDExES1btoShoSEiIyNhY2OD1NRUdOnSBXl5eVxH/KTc3FwEBQUhMTERQOW4YE9PT/aqGVyhYo1U68SJE9iwYQP7R9u+fXssWLBAZv6hduvWDT4+Phg9ejRSU1NhaWkJNzc33Lx5E87OznIzOFlWlZSUSO1ZYZKIi4sT+UCX9rFFkyZNYn9mGAYnTpyAjo4ObG1tAVS25/1hn71793IV84tkaWmJq1evVjmDNSYmBs7OzsjNzeUmWA21a9cOoaGh6NGjB+zs7DB8+HD4+Pjg8OHDmDlzJt68ecN1xI/6559/4OTkBDU1NZFrmxYXF+P8+fOwsbHhLhyn/XqE1CNtbW22G3716tXM4MGDGYZhmKtXrzItWrTgMlqNDRgwgNm7dy+Tl5fHdZQ6EQgETEBAAGNkZCQyX9xPP/3E7Nmzh+N0knn9+jXj6OjI8Hg8di4pHo/H9O/fn3nz5g3X8SSycOFC5rvvvmMEAgG7TCAQMN9//z0zf/58DpPV3Nu3b5lz584x+/fvZ0JCQkRusmLSpElM165dmXfv3rHLoqKiGG1tbWbjxo0cJquZRYsWMYGBgQzDVM4Rp6ioyJibmzPKysrMokWLOE73aXZ2doyHhwdTXl7OLisvL2cmTpzI9O3bl8NkDEPFGhHL1NSUycrKqrL87du3jKmpKQeJak5LS4u9FM3AgQOZzZs3MwzDME+fPmVUVVW5jFZj3t7eTLNmzRg1NTXmq6++YsLCwpiysjKuY9WYPEz+OWbMGMbW1pZJSEhglz148ICxtbVl/ve//3GYTHL6+vrsRLgfSkpKYho1asRBoto5efIko6WlxfB4PEZHR4fR1dVlb3p6elzHk5hQKGRGjRrF2NvbMyUlJcylS5cYTU1N9jNLVsXGxjIbNmxgTp48yXUUiaiqqjKJiYlVlj948IBRU1PjING/6GxQItaTJ08gFAqrLC8tLcWLFy84SFRztra2WLFiBfbv34+oqCg4OzsDANLS0tC0aVOO09XMli1b8OLFC4SFhUFDQwMTJkxA06ZN8f3338vUNCTyMPnn2bNn8fPPP6N9+/bsMktLS+zYsQNnzpzhMJnkBAKB2N93UlKSTF1qbt68efD09ERBQQFyc3Px9u1b9ibt00R8iM/n49ChQ1BSUkL//v3h4uKCVatWYdasWVxHq5Hs7Gz25/fTXWRkZHA+3ktS2traePbsWZXl6enp7CTSXKF51oiIkydPsj+fO3dO5E0mFApx8eJFmJiYcJCs5jZv3gx3d3eEhYVhyZIl7KSTR48eZU+akCV8Ph+DBw/G4MGDsWvXLpw6dQqBgYEICgoSW1hLI3mY/LOiogJKSkpVlispKclMoTNp0iR4eXkhJSWFHZvz999/Y/Xq1SJj26Tdixcv4O3tDXV1da6j1Njdu3erLPPz88PYsWMxbtw49OvXj92mU6dODR2vRu7du4cRI0YgPT0dbdq0waFDhzBkyBAUFhaCz+dj06ZNOHr0KFxdXbmO+lHffPMNvLy8sH79epET6xYsWICxY8dyG47Tfj0idXg8Hnva+/uf39+UlZWZtm3bMqdOneI6Zp0UFxfL5CHE9zIyMphNmzYxXbt2ZXg8HtOjRw+uI0nMxsaG2b9/P8Mwotdr9ff3Z+zs7LiMJjEXFxemX79+zIsXL9hlz58/Z+zt7RlXV1cOk0lOKBQya9asYYyMjNj3t5GREbNmzRqRcWzSbtSoUczhw4e5jlEr4j5nP7wvS1OQDBkyhBk+fDhz9epV5ocffmCaN2/OeHp6MkKhkBEKhcy0adNk4nOqtLSU8fb2ZpSVldlpYFRUVJjZs2ez0wxxhc4GJWKZmpri5s2b0NfX5zoKQeXkn8eOHcPvv/+Oy5cvw8zMDO7u7nB3d0fr1q25jiex8PBwTJw4EYsXL0ZAQAD8/f2RnJyM0NBQREREsJPkSrP09HS4uLjgwYMHMDY2Zpd17NgRJ0+erHYKBmn1fvJYbW1tjpNI5sPe/8zMTAQEBGDSpEmwsrKq0uPp4uLS0PEk9vTpU4m3/e+VDaSNvr4+Ll26hE6dOqGgoADa2tq4efMmO/l4UlISevbsKTNntRYVFbGX8WvdurVU9NxSsUZETJgwASNHjoSTkxM0NTW5jlMnfD7/o5dikpVDh0DlxY/19PTwzTffwN3dnZ1uQRZFR0cjICBAZL64ZcuWYfDgwVxHkxjDMLhw4QI77qt9+/YYOHAgx6m+DHy+ZEOteTyeTL3HZRmfz8erV6/YS+JpaWkhPj6evc7s69evYWRkJFP7Iz09HQDYL2RcozFrRIS5uTlWrlyJcePGwcHBAS4uLnBxcUHz5s25jlZjJ06cELlfXl6O27dvIyQkBP7+/hylqp2TJ09iwIABEv+jkkYCgQArV66Ep6cn/vzzT67j1NilS5cwY8YMXL9+Hdra2hg0aBDbE5iXl4cOHTpg165d3F+WRgKvX7/G/PnzcfHiRbx58wb//c4uzf9UZWVcYG0kJCSIvaamNPcQvvffL8aydM3i9wQCAfz9/bF161YUFBQAADQ1NTFz5kz4+vqKHavaUKhnjYiVnp6OU6dOITw8HFFRUejQoQNGjhwJFxcXdO7cmet4dfL777/j8OHDCA8P5zpKjWVmZiI5ORlA5QSUTZo04ThRzWhqauL+/fsyc5LKh1xcXODo6Ig5c+aIXb9161b89ddfVb4kSKOhQ4fi2bNnmDFjBgwNDav8Y5X2ia9jY2ORnZ2N4cOHs8tCQ0Ph6+uLwsJCuLq6Ytu2bVBRUeEwpeRSU1MxatQo3Lt3Dzwejy2e3+8XaS6egcqetaFDh7K/71OnTqF///7Q0NAAUDmLwNmzZ6W+HVOnTsXx48cREBAgciF3Pz8/uLq6YufOnZxlo2KNfFJ+fj7OnDmD8PBwnDlzBlpaWhgxYgSmTp2KDh06cB2vxlJTU9mxFbKiqKgIM2bMQGhoKNuzoKCggAkTJmDbtm1SMaZCEiNHjoSbmxsmTpzIdZQaa9WqFc6ePSsyZceHkpKSMHjwYLGn/ksbLS0tREdHy+wXryFDhsDR0RGLFi0CUHk2oo2NDTw8PNC+fXusW7cOP/zwg0xcPBwARowYAQUFBezZswempqa4ceMGsrOzMW/ePKxfv17qe2slPYNY2q+MoaOjg0OHDmHo0KEiy0+fPo2xY8dyerksOgxKPklLSwtjxozBmDFjIBQKERUVhfDwcMTGxspcsVZcXIytW7fK3GHdOXPmICoqCqdOnUKfPn0AAFevXoW3tzfmzZvH6Te+mhg6dCh8fHxw7949dO3alf3m/Z40H+55/fr1Rw+DKCoqIjMzswET1Z6xsXGVQ5+yJD4+HitWrGDvHzp0CD169MCvv/4KoLJ9vr6+MlOsxcbG4tKlS9DX1wefzwefz4ednR1WrVoFb29v3L59m+uIHyXtRZikVFRUxPb6m5qacn8taW5OQiXSztHRkXn79m2V5Xl5eYyjo2PDB6qF97OYv7/p6uoyCgoKjJaWFhMeHs51vBpp3Lgx89dff1VZfunSJUZfX7/hA9XSf6eD+e+0BdLMzMyMOXHiRLXrjx07JjNX9zh37hwzePBgJi0tjesotaKiosI8e/aMvd+nTx9mxYoV7P20tDRGU1OTi2i1oqury6SmpjIMU/l3dunSJYZhGObx48ecz5z/JfH392fGjh0rMk1HSUkJ4+7uzvj5+XGYjGGoZ42Idfny5SqDXIHKi29HR0dzkKjm/nuhdj6fjyZNmqBHjx7Q09PjJlQtFRUVib3qgoGBAYqKijhIVDuyPDh82LBhWLp0KYYMGVLlAvTFxcXw9fUVGUMlzb755hsUFRWx0xL8t8dQ2mf/b9q0KdLS0mBsbIyysjLcunVL5KSh/Px8TgeD11THjh0RHx8PU1NT9OjRA2vXroWysjJ++eUX9oxKUj/c3NxE7l+4cAEtWrSAtbU1gMpe3LKyMgwYMICLeCwq1oiID2fVTkhIwKtXr9j7QqEQZ8+elZlDiLI4Lqo6vXr1gq+vL0JDQ9lCobi4GP7+/uxAWGlXUVGBffv24fjx43jy5Al4PB7MzMwwevRojB8/XurPHvvpp59w/PhxtG3bFjNmzEC7du0AVI5V27FjB4RCIZYsWcJxSsn894uMrBk2bBh8fHywZs0ahIWFQV1dXWRc1927d2Vq/sGffvoJhYWFAICAgAAMHz4cffv2RePGjXH48GGO08m3/14Ka/To0SL3pWXqDjrBgIj4cG4ycX8aampq2LZtGzw9PRs6Wq3k5uYiKCgIiYmJAIAOHTrA09NTZq5V9979+/fh5OSE0tJSkW98qqqqOHfunNSPHWQYBiNGjMDp06dhbW0NCwsLMAyDxMRE3Lt3Dy4uLggLC+M65ic9ffoUU6dOxblz50TO2HNycsKOHTtgamrKccIvQ1ZWFtzc3HD16lVoamoiJCQEo0aNYtcPGDAAPXv2RGBgIIcp6yYnJwd6enpS/yWGNAwq1oiIp0+fgmEYmJmZ4caNGyJTQygrK8PAwEDkAtzS7J9//oGTkxPU1NTY6x/evHkTxcXFOH/+PGxsbDhOWDNFRUX47bffRCZidXd3h5qaGsfJPm3v3r2YNWsWwsPD4ejoKLLu0qVLcHV1xfbt2zFhwgSOEtbM27dv8fjxYzAMgzZt2sjcYfUPlZSUVBnyICtXM8jLy4OmpmaVz6ScnBxoampyPyi8hh4/foyUlBT069cPampqYBiGijUCgIo1IkZ5eTm+//57LFu2TKZ7Cvr27Qtzc3P8+uuvUFSsPOIvEAjw3XffITU1FVeuXOE44Zdj8ODB6N+/P3x8fMSuX7lyJaKionDu3LkGTvZlKiwsxKJFi3DkyBFkZ2dXWS/t82HJm+zsbIwZMwZ//fUXeDweHj16BDMzM3h6ekJPTw8bNmzgOiLhGBVrRCxdXV3cvn1bpos1NTU13L59GxYWFiLLExISYGtrK/UD8z+8BuKnSPOUFwDQrFkznD17ttp5vW7fvo2hQ4eKjJEk9Wf69On466+/sHz5cowfPx47duzAixcvsHv3bqxevRru7u5cR/yiTJgwAW/evMGePXvQvn179lJN586dw9y5c/HgwQOuIxKO0QkGRKyRI0ciLCys2tnaZYG2tjaePXtWpVhLT0+HlpYWR6kk5+rqKtF2snANxJycHLFns77XtGlTvH37tgETfdlOnTqF0NBQODg4YNKkSWwvdKtWrfDbb79RsdbAzp8/j3PnzqFFixYiy9u0aVOjC74T+UXFGhGrTZs2CAgIQExMjNjJS729vTlKJrlvvvkGXl5eWL9+PXr37g0AiImJwYIFCzB27FiO032aLE9z8V9CoZA9FC2OgoICBAJBAyb6suXk5LBTQmhra7NTddjZ2WHq1KlcRvsiFRYWir0KSU5OjsxcMkvelJSUVJmih0tUrBGxgoKCoKuri7i4OMTFxYms4/F4MlGsrV+/HjweDxMmTGALASUlJUydOhWrV6/mON2XhWEYeHh4VPuPp7S0tIETfdnMzMyQlpaGli1bwsLCAkeOHEH37t1x6tQp6Orqch3vi9O3b1+EhoZi+fLlACo/YysqKrB27doqJ+SQ+lNRUYHAwEDs2rULr1+/xsOHD2FmZoalS5fCxMQEXl5enGWjMWtELgmFQsTExMDKygoqKipISUkBAHYSUFmwdetWibeV9uJZXq4dKC82bdoEBQUFeHt748KFCxgxYgQYhkF5eTk2btyIWbNmcR3xi3L//n0MGDAANjY2uHTpElxcXPDgwQPk5OQgJiZGpuaMk2UBAQEICQlBQEAAJk+ejPv378PMzAyHDx/G5s2bERsby1k2KtaI3FJVVUViYqLMniQhaW4ej4fU1NR6TkPk2dOnTxEXFwdzc3N06tSJ6zhfpLy8PGzfvh3x8fEoKCiAjY0Npk+fDkNDQ66jfTHMzc2xe/duDBgwAFpaWuyJHklJSejVqxen42rpMChhzZ07F8uXL4eGhgbmzp370W03btzYQKlqr2PHjkhNTZXZYi0tLY3rCETOxMbGIjs7W+SyWKGhofD19UVhYSFcXV2xbds2GifFAR0dHZm5Aoa8evHiBczNzassr6ioQHl5OQeJ/kXFGmHdvn2b/YO8fft2tdvJyiSNK1aswPz587F8+XKxJ0nIysSfhHwuAQEBcHBwYIu1e/fuwcvLCx4eHrC0tMTatWthZGQEPz8/boN+gXJzc3Hjxg28efOmyslFsjJZtKyztLREdHQ0WrVqJbL86NGj6NKlC0epKtFhUCJ3AgICMG/ePJHpOT4sMN/PCi7t01186FOX9woODm6gJESWGRoa4tSpU7C1tQUALFmyBFFRUbh69SoA4I8//oCvry8SEhK4jPnFOXXqFNzd3VFQUABtbW2Rzysej8eerUvqV3h4OCZOnIjFixcjICAA/v7+SE5ORmhoKCIiIjBo0CDOslGxRuSOgoICMjIy2OuBVsfe3r6BEtXdh9c9BCqvMnH//n3k5uaif//+OH78OEfJiCxRVVXFo0eP2ItT29nZYejQoezhtydPnsDKygr5+flcxvzitG3bFsOGDcPKlStl5gQoeRUdHY2AgACRsYPLli3D4MGDOc1Fh0GJWIWFhVi9ejUuXrwotltemge0v//+IUvF2KecOHGiyrKKigpMnTqVzhQjEmvatCnS0tJgbGyMsrIy3Lp1C/7+/uz6/Px8KCkpcZjwy/TixQt4e3tToSYF+vbtiz///JPrGFVQsUbE+u677xAVFYXx48fD0NBQZsapvSdreWuDz+dj7ty5cHBwwMKFC7mOQ2TAsGHD4OPjgzVr1iAsLAzq6uro27cvu/7u3btU/HPAyckJ//zzDztRMSH/RcUaEevMmTOIjIxEnz59uI5SK23btv1kwSYP40BSUlJo5n8iseXLl8PNzQ329vbQ1NRESEgIlJWV2fXBwcGcH+75Ejk7O2PBggVISEiAlZVVld5Nab/2ryzT09OT+Ms9l/8zqFgjYunp6aFRo0Zcx6g1f39/6OjocB3js/nvVCoMwyAjIwORkZGYOHEiR6mIrNHX18eVK1eQl5cHTU1NKCgoiKz/448/oKmpyVG6L9fkyZMBVJ4c9V+ydjKUrNm8eTPXESRCJxgQsQ4cOIDw8HCEhITI3DgKPp+PV69ewcDAgOson42joyN4PB47Ho/P56NJkybo378/PD09P3rdTUIIIXVTXFwMNTU1zl6fPuEJq0uXLiLdwY8fP0bTpk1hYmJSpVv+1q1bDR1PYvI0Xq2iogLr1q1DaWkpysvL0b9/f/j5+XH6oUEI+TxokmLp4u3tLfYyf4WFhRg+fDj++usvDlJVomKNsFxdXbmO8FnIU2dxYGAg/Pz8MHDgQKipqWHr1q3IzMykedUIkQMfm6S4ffv2WLduHU1S3IAiIyOhp6cncoZ0YWEhhgwZwmGqSnQYlBAp1qZNG8yfPx8//PADAODChQtwdnZGcXEx+Hw+x+kIIXVBkxRLl5SUFPTt2xcLFy7E7NmzkZ+fDycnJygqKuLMmTNVroLTkKhnjYiVnp4OHo+HFi1aAABu3LiB33//HZaWlvj+++85TvflePbsGYYNG8beHzhwIHg8Hl6+fMnuG0KIbHr79i2aNm3K3o+KisLQoUPZ+926dUN6ejoX0b5IrVu3xtmzZ+Ho6Ag+n4+DBw9CRUUFkZGRnBZqAEBfzYlY3377LXt8/tWrVxg4cCBu3LiBJUuWiD1jidQPgUAAVVVVkWVKSkqcX1SYEFJ37ycpBsBOUtyzZ092PU1S3PA6deqEiIgI/Pjjj1BXV+e8R+096lkjYt2/fx/du3cHABw5cgRWVlaIiYnB+fPnMWXKFCxbtozjhF8GhmHg4eEhMsC4pKQEU6ZMEfkAoctNESJ7aJJi7v33xLr3VFRU8PLlS5G5Rrk8sY6KNSJWeXk5WyBcuHCBnZTRwsICGRkZXEb7ooibQ23cuHEcJCGEfG40STH3ZOXEOjrBgIjVo0cPODo6wtnZGYMHD8b169dhbW2N69ev46uvvsLz58+5jkgIIXKhukmKc3JyoKmpKVLAkS8TFWtErMuXL2PUqFF49+4dJk6cyE4V8eOPPyIpKYkOuxFCCJFLZWVlePPmDSoqKkSWt2zZkqNEVKyRjxAKhXj37h309PTYZU+ePIG6urpcXR2AEEIIefjwIby8vHDt2jWR5QzDcH7ZLxqzRqqloKAAPT09rF69GlOmTIGuri5MTEy4jkUIIYR8dpMmTYKioiIiIiJgaGgoVVfDoZ418kna2tq4c+cOzMzMuI5CCCGE1AsNDQ3ExcXBwsKC6yhV0Dxr5JOonieEECLvLC0tkZWVxXUMsahYIyICAgJQVFTEdQxCCCGkQa1ZswYLFy7E5cuXkZ2djXfv3oncuESHQYkIBQUFZGRkiJxAkJ6eDiMjoyqnlRNCCCHy4v31lv87Vo1OMCBSR1ztbmxszEESQgghpOG8v8SiNKJijVQhTWfAEEIIIQ3B3t6+2nX3799vwCRV0WFQIoLP50NHR+eTBVtOTk4DJSKEEEIaXn5+Pg4ePIg9e/YgLi6ODoMS6eLv7w8dHR2uYxBCCCEN7sqVKwgKCsKxY8dgZGQENzc37Nixg9NMVKyRKv73v//RFQoIIYR8MV69eoV9+/YhKCgI7969w5gxY1BaWoqwsDBYWlpyHY+m7iCiaLwaIYSQL8mIESPQrl073L17F5s3b8bLly+xbds2rmOJoJ41IoKGMBJCCPmSnDlzBt7e3pg6dSratGnDdRyxqGeNiKioqKBDoIQQQr4YV69eRX5+Prp27YoePXpg+/btUnclAzoblBBCCCFfvMLCQhw+fBjBwcG4ceMGhEIhNm7cCE9PT2hpaXGajYo1QgghhJAPJCcnIygoCPv370dubi4GDRqEkydPcpaHijVCCCGEEDGEQiFOnTqF4OBgKtYIIYQQQoh4dIIBIYQQQogUo2KNEEIIIUSKUbFGCCGEECLFqFgjhBAp4eHhAVdXV/a+g4MDZs+e3eA5Ll++DB6Ph9zc3AZ/bUJIVVSsEULIJ3h4eIDH44HH40FZWRnm5uYICAiAQCCo19c9fvw4li9fLtG2VGARIr/oclOEECKBIUOGYO/evSgtLcXp06cxffp0KCkpYfHixSLblZWVQVlZ+bO8ZqNGjT7L8xBCZBv1rBFCiARUVFTQrFkztGrVClOnTsXAgQNx8uRJ9tBlYGAgjIyM0K5dOwBAeno6xowZA11dXTRq1AgjR47EkydP2OcTCoWYO3cudHV10bhxYyxcuLDKtXn/exi0tLQUixYtgrGxMVRUVGBubo6goCA8efIEjo6OAAA9PT3weDx4eHgAqLyE3KpVq2Bqago1NTVYW1vj6NGjIq9z+vRptG3bFmpqanB0dBTJSQjhHhVrhBBSC2pqaigrKwMAXLx4EcnJyfjzzz8RERGB8vJyODk5QUtLC9HR0YiJiYGmpiaGDBnCPmbDhg3Yt28fgoODcfXqVeTk5ODEiRMffc0JEybg4MGD2Lp1KxITE7F7925oamrC2NgYx44dA1A583pGRga2bNkCAFi1ahVCQ0Oxa9cuPHjwAHPmzMG4ceMQFRUFoLKodHNzw4gRI3Dnzh1899138PHxqa9fGyGkFugwKCGE1ADDMLh48SLOnTuHmTNnIjMzExoaGtizZw97+PPAgQOoqKjAnj17wOPxAAB79+6Frq4uLl++jMGDB2Pz5s1YvHgx3NzcAAC7du3CuXPnqn3dhw8f4siRI/jzzz8xcOBAAICZmRm7/v0hUwMDA+jq6gKo7IlbuXIlLly4gF69erGPuXr1Knbv3g17e3vs3LkTrVu3xoYNGwAA7dq1w71797BmzZrP+FsjhNQFFWuEECKBiIgIaGpqory8HBUVFfj222/h5+eH6dOnw8rKSmScWnx8PB4/flzl4s8lJSVISUlBXl4eMjIy0KNHD3adoqIibG1tqxwKfe/OnTtQUFCAvb29xJkfP36MoqIiDBo0SGR5WVkZunTpAgBITEwUyQGALewIIdKBijVCCJGAo6Mjdu7cCWVlZRgZGUFR8d+PTw0NDZFtCwoK0LVrV/z2229VnqdJkya1en01NbUaP6agoAAAEBkZiebNm4usU1FRqVUOQkjDo2KNEEIkoKGhAXNzc4m2tbGxweHDh2FgYABtbW2x2xgaGuLvv/9Gv379AAACgQBxcXGwsbERu72VlRUqKioQFRXFHgb90PuePaFQyC6ztLSEiooKnj17Vm2PXPv27atcoPr69eufbiQhpMHQCQaEEPKZubu7Q19fHyNHjkR0dDTS0tJw+fJleHt74/nz5wCAWbNmYfXq1QgLC0NSUhKmTZv20TnSTExMMHHiRHh6eiIsLIx9ziNHjgAAWrVqBR6Ph4iICGRmZqKgoABaWlqYP38+5syZg5CQEKSkpODWrVvYtm0bQkJCAABTpkzBo0ePsGDBAiQnJ+P333/Hvn376vtXRAipASrWCCHkM1NXV8eVK1fQsmVLuLm5oX379vDy8kJJSQnb0zZv3jyMHz8eEydORK9evaClpYVRo0Z99Hl37tyJr776CtOmTYOFhQUmT56MwsJCAEDz5s3h7+8PHx8fNG3aFDNmzAAALF++HEuXLsWqVavQvn17DBkyBJGRkTA1NQUAtGzZEseOHUNYWBisra2xa9curFy5sh5/O4SQmuIx1Y1mJYQQQgghnKOeNUIIIYQQKUbFGiGEEEKIFKNijRBCCCFEilGxRgghhBAixahYI4QQQgiRYlSsEUIIIYRIMSrWCCGEEEKkGBVrhBBCCCFSjIo1QgghhBApRsUaIYQQQogUo2KNEEIIIUSKUbFGCCGEECLF/g9Osqs4OTzQBAAAAABJRU5ErkJggg==",
      "text/plain": [
       "
"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test model (without trainer)\n",
    "checkpoint = checkpoint_callback.best_model_path\n",
    "model = MNISTModel.load_from_checkpoint(checkpoint)\n",
    "\n",
    "classes = [\n",
    "    \"T-shirt/top\",\n",
    "    \"Trouser\",\n",
    "    \"Pullover\",\n",
    "    \"Dress\",\n",
    "    \"Coat\",\n",
    "    \"Sandal\",\n",
    "    \"Shirt\",\n",
    "    \"Sneaker\",\n",
    "    \"Bag\",\n",
    "    \"Ankle boot\",\n",
    "]\n",
    "preds = torch.cat(trainer.predict(model, fashion_mnist))\n",
    "y = fashion_mnist.mnist_test.targets\n",
    "\n",
    "print(\n",
    "    \"Accuracy:\",\n",
    "    torchmetrics.functional.accuracy(\n",
    "        preds, y, task=\"multiclass\", num_classes=fashion_mnist.num_classes\n",
    "    ).item(),\n",
    ")\n",
    "print(\n",
    "    \"Balanced accuracy:\",\n",
    "    torchmetrics.functional.accuracy(\n",
    "        preds,\n",
    "        y,\n",
    "        task=\"multiclass\",\n",
    "        average=\"macro\",\n",
    "        num_classes=fashion_mnist.num_classes,\n",
    "    ).item(),\n",
    ")\n",
    "print(\"Confusion matrix:\")\n",
    "cm = sns.heatmap(\n",
    "    torchmetrics.functional.confusion_matrix(\n",
    "        preds,\n",
    "        y,\n",
    "        task=\"multiclass\",\n",
    "        normalize=\"true\",\n",
    "        num_classes=fashion_mnist.num_classes,\n",
    "    )\n",
    "    * 100,\n",
    "    annot=True,\n",
    "    fmt=\".1f\",\n",
    "    cmap=\"YlOrRd\",\n",
    "    cbar=False,\n",
    "    xticklabels=classes,\n",
    "    yticklabels=classes,\n",
    ")\n",
    "cm.set(xlabel=\"Predicted\", ylabel=\"True\");"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Production: Lightning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "
"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted: \"Ankle boot\", Actual: \"Ankle boot\"\n"
     ]
    }
   ],
   "source": [
    "checkpoint = checkpoint_callback.best_model_path\n",
    "model = MNISTModel.load_from_checkpoint(checkpoint)\n",
    "\n",
    "classes = [\n",
    "    \"T-shirt/top\",\n",
    "    \"Trouser\",\n",
    "    \"Pullover\",\n",
    "    \"Dress\",\n",
    "    \"Coat\",\n",
    "    \"Sandal\",\n",
    "    \"Shirt\",\n",
    "    \"Sneaker\",\n",
    "    \"Bag\",\n",
    "    \"Ankle boot\",\n",
    "]\n",
    "test_data = datasets.FashionMNIST(\n",
    "    root=\"data\", train=False, download=True, transform=transforms.ToTensor()\n",
    ")\n",
    "x, y = test_data[0][0], test_data[0][1]\n",
    "plt.imshow(x.numpy()[0], cmap=\"gray\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "\n",
    "model.eval()\n",
    "with torch.inference_mode():\n",
    "    pred = model(x.to(\"cuda\"))\n",
    "    predicted, actual = classes[pred[0].argmax(0)], classes[y]\n",
    "    print(f'Predicted: \"{predicted}\", Actual: \"{actual}\"')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Production: TorchScript\n",
    "## Save model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint = checkpoint_callback.best_model_path\n",
    "model = MNISTModel.load_from_checkpoint(checkpoint)\n",
    "script = model.to_torchscript()\n",
    "torch.jit.save(script, \"model.pt\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "
"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted: \"Ankle boot\", Actual: \"Ankle boot\"\n"
     ]
    }
   ],
   "source": [
    "model = torch.jit.load(\"model.pt\")\n",
    "\n",
    "\n",
    "@torch.inference_mode()\n",
    "def predict(x: torch.Tensor) -> torch.Tensor:\n",
    "    return model(x)\n",
    "\n",
    "\n",
    "classes = [\n",
    "    \"T-shirt/top\",\n",
    "    \"Trouser\",\n",
    "    \"Pullover\",\n",
    "    \"Dress\",\n",
    "    \"Coat\",\n",
    "    \"Sandal\",\n",
    "    \"Shirt\",\n",
    "    \"Sneaker\",\n",
    "    \"Bag\",\n",
    "    \"Ankle boot\",\n",
    "]\n",
    "test_data = datasets.FashionMNIST(\n",
    "    root=\"data\", train=False, download=True, transform=transforms.ToTensor()\n",
    ")\n",
    "x, y = test_data[0][0], test_data[0][1]\n",
    "plt.imshow(x.numpy()[0], cmap=\"gray\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "\n",
    "pred = predict(x.to(\"cuda\"))\n",
    "predicted, actual = classes[pred[0].argmax(0)], classes[y]\n",
    "print(f'Predicted: \"{predicted}\", Actual: \"{actual}\"')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Production: ONNX\n",
    "## Save model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============= Diagnostic Run torch.onnx.export version 2.0.1+cu117 =============\n",
      "verbose: False, log level: Level.ERROR\n",
      "======================= 0 NONE 0 NOTE 0 WARNING 0 ERROR ========================\n",
      "\n"
     ]
    }
   ],
   "source": [
    "checkpoint = checkpoint_callback.best_model_path\n",
    "model = MNISTModel.load_from_checkpoint(checkpoint)\n",
    "input_sample = datasets.FashionMNIST(\n",
    "    root=\"data\", train=False, download=True, transform=transforms.ToTensor()\n",
    ")\n",
    "input_sample = input_sample[0][0]\n",
    "model.to_onnx(\"model.onnx\", input_sample, export_params=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "
"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted: \"Ankle boot\", Actual: \"Ankle boot\"\n"
     ]
    }
   ],
   "source": [
    "ort_session = onnxruntime.InferenceSession(\"model.onnx\")\n",
    "\n",
    "classes = [\n",
    "    \"T-shirt/top\",\n",
    "    \"Trouser\",\n",
    "    \"Pullover\",\n",
    "    \"Dress\",\n",
    "    \"Coat\",\n",
    "    \"Sandal\",\n",
    "    \"Shirt\",\n",
    "    \"Sneaker\",\n",
    "    \"Bag\",\n",
    "    \"Ankle boot\",\n",
    "]\n",
    "test_data = datasets.FashionMNIST(\n",
    "    root=\"data\", train=False, download=True, transform=transforms.ToTensor()\n",
    ")\n",
    "x, y = test_data[0][0], test_data[0][1]\n",
    "plt.imshow(x.numpy()[0], cmap=\"gray\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "\n",
    "input_name = ort_session.get_inputs()[0].name\n",
    "ort_inputs = {input_name: x.numpy()}\n",
    "ort_outs = ort_session.run(None, ort_inputs)[0]\n",
    "predicted, actual = classes[ort_outs[0].argmax(0)], classes[y]\n",
    "print(f'Predicted: \"{predicted}\", Actual: \"{actual}\"')"
   ]
  }
 ],
 "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.11.3"
  },
  "vscode": {
   "interpreter": {
    "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}