OCTMNIST.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "id": "zsgDSAR0c45X"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score\n",
        "\n",
        "import torch, torchvision\n",
        "from torchvision.transforms import Compose, Normalize\n",
        "from torchmetrics.classification import MulticlassAccuracy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "IGvR-cepc45Z"
      },
      "outputs": [],
      "source": [
        "data = {}\n",
        "with np.load('data/octmnist.npz') as temp_data:\n",
        "    for file_name in temp_data.files:\n",
        "        if 'images' in file_name:\n",
        "            if 'train' in file_name:\n",
        "                data[file_name] = torch.from_numpy(temp_data[file_name][:20000]).float()\n",
        "            elif 'test' in file_name:\n",
        "                data[file_name] = torch.from_numpy(temp_data[file_name][:2000]).float()\n",
        "            else:\n",
        "                data[file_name] = torch.from_numpy(temp_data[file_name]).float()\n",
        "        else:\n",
        "            data[file_name] = torch.from_numpy(temp_data[file_name])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GC5ezZXic45a",
        "outputId": "9ffedd99-43fd-4dc8-de57-234d335c9a9e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The Mean we use to normalize the data:48.08446502685547\n",
            "The Standard Deviation we use to normalize the data:43.16010665893555\n"
          ]
        }
      ],
      "source": [
        "# Calculating Mean and Standard deviation\n",
        "mean_set = data['train_images'].view([len(data['train_images']),-1]).mean(1).sum(0)/len(data['train_images'])\n",
        "std_set = data['train_images'].view([len(data['train_images']),-1]).std(1).sum(0)/len(data['train_images'])\n",
        "\n",
        "print('The Mean we use to normalize the data:{0}'.format(mean_set))\n",
        "print('The Standard Deviation we use to normalize the data:{0}'.format(std_set))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "brUHNEUGc45b"
      },
      "source": [
        "### Data Loading"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "YD4XEBNyc45f"
      },
      "outputs": [],
      "source": [
        "transform = Compose([\n",
        "    Normalize(mean=[mean_set], std=[std_set])\n",
        "])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "OeBST9NLc45f"
      },
      "outputs": [],
      "source": [
        "# Standardization of images\n",
        "data['train_images'] = transform(data['train_images'])\n",
        "data['val_images'] = transform(data['val_images'])\n",
        "data['test_images'] = transform(data['test_images'])\n",
        "\n",
        "\n",
        "data['train_images'] = data['train_images'].unsqueeze(1)\n",
        "data['val_images'] = data['val_images'].unsqueeze(1)\n",
        "data['test_images'] = data['test_images'].unsqueeze(1)\n",
        "\n",
        "data['train_labels'] = data['train_labels'].squeeze()\n",
        "data['val_labels'] = data['val_labels'].squeeze()\n",
        "data['test_labels'] = data['test_labels'].squeeze()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 228
        },
        "id": "A1jcwhLwTb_b",
        "outputId": "15b73aa9-7790-4e48-f10b-549779a477ec"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The encoded labels of the images are tensor([0, 3, 3, 3], dtype=torch.uint8):\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def matplotlib_imshow(img):\n",
        "    npimg = img.numpy()\n",
        "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
        "\n",
        "images = data['train_images'][:4]\n",
        "img_grid = torchvision.utils.make_grid(images)\n",
        "matplotlib_imshow(img_grid)\n",
        "print('The encoded labels of the images are {0}:'.format(data['train_labels'][:4]))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "acViTscqc45g"
      },
      "outputs": [],
      "source": [
        "class Image_Dataset(torch.utils.data.Dataset):\n",
        "    def __init__(self: 'Image_Dataset', images: torch.Tensor, labels: torch.Tensor) -> None:\n",
        "        \"\"\"To initialize the Dataset\n",
        "\n",
        "        Args:\n",
        "            images (torch.Tensor): Image Tensor\n",
        "            labels (torch.Tensor): Label Tensor\n",
        "        \"\"\"\n",
        "        self.images = images\n",
        "        self.labels = labels\n",
        "    \n",
        "    def __len__(self: 'Image_Dataset') -> int:\n",
        "        \"\"\" Count number of images in the dataset.\n",
        "        \n",
        "        Returns:\n",
        "            int: Returns the count of the images\n",
        "        \"\"\"\n",
        "        return len(self.images)\n",
        "    \n",
        "    def __getitem__(self: 'Image_Dataset', index: int) -> tuple[torch.Tensor, torch.Tensor]:\n",
        "        \"\"\"Function to get image and its lablel given index\n",
        "\n",
        "        Args:\n",
        "            index (int): index of the image we need to get\n",
        "\n",
        "        Returns:\n",
        "            tuple[torch.Tensor, torch.Tensor]: Returns single image and its label as tuple\n",
        "        \"\"\"\n",
        "        return self.images[index], self.labels[index] "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "Fa-aTeJmc45g"
      },
      "outputs": [],
      "source": [
        "train_dataset = Image_Dataset(data['train_images'], data['train_labels'])\n",
        "val_dataset = Image_Dataset(data['val_images'], data['val_labels'])\n",
        "test_dataset = Image_Dataset(data['test_images'], data['test_labels'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "jX-ovS3Fc45h"
      },
      "outputs": [],
      "source": [
        "from torch.utils.data import DataLoader\n",
        "\n",
        "train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
        "val_dataloader = DataLoader(val_dataset, batch_size=32)\n",
        "test_dataloader = DataLoader(test_dataset, batch_size=32)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "Y5IExmMxc45h"
      },
      "outputs": [],
      "source": [
        "if torch.backends.mps.is_available():\n",
        "    DEVICE = torch.device(device='mps')\n",
        "elif torch.cuda.is_available():\n",
        "    DEVICE = torch.device(device='cuda')\n",
        "else:\n",
        "    DEVICE = torch.device(device='cpu')\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "sTAX27Vlc45h"
      },
      "source": [
        "### Learning Loops"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "eqbxG5Xac45h"
      },
      "outputs": [],
      "source": [
        "loss_criteria = torch.nn.CrossEntropyLoss()\n",
        "multiclass_accuracy  = MulticlassAccuracy(num_classes=len(data['train_labels'].unique())).to(device=DEVICE)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "NPDCr3nHc45i"
      },
      "outputs": [],
      "source": [
        "def one_epoch_train(model: torch.nn.Module, data_loader_train: torch.utils.data.DataLoader, \n",
        "                    loss_criterion: torch.nn, optim_alog: torch.optim) -> tuple:\n",
        "    \"\"\"Function that trains the model for one epoch.\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): Pytorch model we want to train.\n",
        "        data_loader_train (torch.utils.data.DataLoader): Pytorch dataloader that carries training data.\n",
        "        loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.\n",
        "        optim_alog (torch.optim): Opimiztion algoritham that we use to update model weights.\n",
        "\n",
        "    Returns:\n",
        "        tuple: Tuple carrying Train loss and accuracy\n",
        "    \"\"\"\n",
        "    batch_loss_train = []\n",
        "    batch_accuracy_train = []\n",
        "    batch_counter = 0\n",
        "    for inputs, labels in data_loader_train:\n",
        "        inputs = inputs.to(device=DEVICE)\n",
        "        labels = labels.to(device=DEVICE)\n",
        "        \n",
        "        \n",
        "        # Enabling model training.\n",
        "        model.train(True)\n",
        "        \n",
        "        \n",
        "        #Setting gradients to zero to prevent gradient accumulation.\n",
        "        optim_alog.zero_grad()\n",
        "        \n",
        "        # Forward pass.\n",
        "        y_pred_prob = model(inputs)\n",
        "        loss = loss_criterion(y_pred_prob, labels)\n",
        "        \n",
        "        batch_loss_train.append(loss.item())\n",
        "        \n",
        "        # Back Propagation\n",
        "        loss.backward()\n",
        "        \n",
        "        # Updating weights\n",
        "        optim_alog.step()\n",
        "        \n",
        "        # Calculating training accuracy.\n",
        "        with torch.inference_mode():\n",
        "            accuracy = multiclass_accuracy(y_pred_prob, labels)\n",
        "            batch_accuracy_train.append(accuracy.item())\n",
        "        batch_counter += 1\n",
        "        \n",
        "        del(inputs)\n",
        "        del(labels)\n",
        "        \n",
        "    return sum(batch_loss_train)/batch_counter, sum(batch_accuracy_train)/batch_counter"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "2LA963zYc45i"
      },
      "outputs": [],
      "source": [
        "def inference(model: torch.nn.Module, data_loader_val: torch.utils.data.DataLoader, loss_criterion: torch.nn) -> tuple:\n",
        "    \"\"\"Function that calculates test accuracy\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): Pytorch model we want to make inference on.\n",
        "        data_loader_val (torch.utils.data.DataLoader): Pytorch dataloader that carries validation data.\n",
        "        loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.\n",
        "\n",
        "    Returns:\n",
        "        tuple: Tuple carrying Test loss and accuracy\n",
        "    \"\"\"\n",
        "    \n",
        "    batch_loss_train = []\n",
        "    batch_accuracy_train = []\n",
        "    batch_counter = 0\n",
        "    \n",
        "    for inputs, labels in data_loader_val:\n",
        "        inputs = inputs.to(device=DEVICE)\n",
        "        labels = labels.to(device=DEVICE)\n",
        "        \n",
        "        # Disabiling model training.\n",
        "        model.train(False)\n",
        "        \n",
        "        with torch.inference_mode():\n",
        "            # Forward Pass\n",
        "            y_pred_prob = model(inputs)\n",
        "            \n",
        "            # Calculating Loss\n",
        "            loss = loss_criterion(y_pred_prob, labels)\n",
        "            batch_loss_train.append(loss.item())\n",
        "            \n",
        "            # Calculating Accuracy\n",
        "            accuracy = multiclass_accuracy(y_pred_prob, labels)\n",
        "            batch_accuracy_train.append(accuracy.item())\n",
        "            \n",
        "        batch_counter += 1\n",
        "        \n",
        "        del inputs\n",
        "        del labels\n",
        "    \n",
        "    return sum(batch_loss_train)/batch_counter, sum(batch_accuracy_train)/batch_counter\n",
        "        "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "vfQrTDaTc45i"
      },
      "outputs": [],
      "source": [
        "def training_loop(model: torch.nn.Module, data_loader_train: torch.utils.data.DataLoader, data_loader_val: torch.utils.data.DataLoader, \n",
        "                  epochs:int, loss_criterion: torch.nn, optim_alog: torch.optim)-> dict:\n",
        "    \"\"\"Function that trains the model for the given number of epochs\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): Pytorch model we want to train.\n",
        "        data_loader_train (torch.utils.data.DataLoader): Pytorch dataloader that carries training data.\n",
        "        data_loader_val (torch.utils.data.DataLoader): Pytorch dataloader that carries validation data.\n",
        "        epochs (int): Count of EPOCHS\n",
        "        loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.\n",
        "        optim_alog (torch.optim): Opimiztion algoritham that we use to update model weights.\n",
        "\n",
        "    Returns:\n",
        "        dict: A dictionary that carries the output metrics.\n",
        "    \"\"\"\n",
        "    \n",
        "    loss_train = []\n",
        "    loss_val = []\n",
        "    \n",
        "    accuracy_train = []\n",
        "    accuracy_val = []\n",
        "    \n",
        "    # Loop that iterates over each EPOCH\n",
        "    for epoch in range(epochs):\n",
        "        \n",
        "        #Train the model for one EPOCH\n",
        "        epoch_loss, epoch_accuracy = one_epoch_train(model, data_loader_train, loss_criterion, optim_alog)\n",
        "        loss_train.append(epoch_loss)\n",
        "        accuracy_train.append(epoch_accuracy)\n",
        "        \n",
        "        # Caluclating Testing results\n",
        "        val_loss, val_accuracy = inference(model, data_loader_val, loss_criterion)\n",
        "        loss_val.append(val_loss)\n",
        "        accuracy_val.append(val_accuracy)\n",
        "        \n",
        "        if (epoch+1)%5 == 0:\n",
        "            print('For Epoch {} We Train Loss:{}, Val Loss:{}, Train Accuracy:{}, Val Accuracy:{}'.format(epoch+1, epoch_loss,\n",
        "                                                                                                        val_loss,\n",
        "                                                                                                        epoch_accuracy,\n",
        "                                                                                                        val_accuracy))\n",
        "    return {'training_loss':loss_train, 'val_loss':loss_val, 'training_accuracy':accuracy_train, 'val_accuracy':accuracy_val}\n",
        "            "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "XDldW2HDC6oR"
      },
      "outputs": [],
      "source": [
        "def plot_metrics(epochs: int,metrics: dict) -> None:\n",
        "    \"\"\"Plot the graphs of Training and Testing Accuracy and Loss across Epoches\n",
        "\n",
        "    Args:\n",
        "        epochs (int): Number of Epochs\n",
        "        metrics (dict): A dictionary containing Test and Training datasets' Loss and accuracy\n",
        "    \"\"\"\n",
        "    \n",
        "    plt.figure(figsize=(15,5))\n",
        "    plt.subplot(1,2,1)\n",
        "    plt.plot(list(range(epochs)), metrics['training_loss'])\n",
        "    plt.plot(list(range(epochs)), metrics['val_loss'])\n",
        "    plt.grid()\n",
        "    plt.legend(['Train', 'Test'])\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('Loss')\n",
        "    plt.title('Train and Validation loss across epochs')\n",
        "    \n",
        "    plt.subplot(1,2,2)\n",
        "    plt.plot(list(range(epochs)), metrics['training_accuracy'])\n",
        "    plt.plot(list(range(epochs)), metrics['val_accuracy'])\n",
        "    plt.grid()\n",
        "    plt.legend(['Train', 'Test'])\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('Accuracy')\n",
        "    plt.title('Train and Validation accuracy across epochs')\n",
        "    \n",
        "    plt.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "lWyrDp2Yc45i"
      },
      "source": [
        "### Model Building"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "Y58GeCZec45j"
      },
      "outputs": [],
      "source": [
        "class ModifiedAlexNet(torch.nn.Module):\n",
        "    \n",
        "    def __init__(self: 'ModifiedAlexNet', input_size: int)-> None:\n",
        "        \"\"\"Function to initate the model layers\n",
        "\n",
        "        Args:\n",
        "            input_size (int): Input size of the image\n",
        "        \"\"\"\n",
        "        super(ModifiedAlexNet,self).__init__()\n",
        "    \n",
        "        self.max_pool = torch.nn.MaxPool2d(kernel_size=3,stride=1)\n",
        "        \n",
        "        self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=96, kernel_size=11)\n",
        "        conv1_size = self._get_conv_output_size(input_size, self.conv1.padding[0], self.conv1.stride[0], self.conv1.kernel_size[0])\n",
        "        pool1_size = self._get_conv_output_size(conv1_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)\n",
        "        \n",
        "        self.conv2 = torch.nn.Conv2d(in_channels=96, out_channels=256, kernel_size=5, padding=2)\n",
        "        conv2_size = self._get_conv_output_size(pool1_size, self.conv2.padding[0], self.conv2.stride[0], self.conv2.kernel_size[0])\n",
        "        pool2_size = self._get_conv_output_size(conv2_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)\n",
        "        \n",
        "        self.conv3 = torch.nn.Conv2d(in_channels=256, out_channels=384, kernel_size=3, padding=1)\n",
        "        conv3_size = self._get_conv_output_size(pool2_size, self.conv3.padding[0], self.conv3.stride[0], self.conv3.kernel_size[0])\n",
        "        \n",
        "        self.conv4 = torch.nn.Conv2d(in_channels=384, out_channels=384, kernel_size=3, padding=1)\n",
        "        conv4_size = self._get_conv_output_size(conv3_size, self.conv4.padding[0], self.conv4.stride[0], self.conv4.kernel_size[0])\n",
        "        \n",
        "        self.conv5 = torch.nn.Conv2d(in_channels=384, out_channels=256, kernel_size=3, padding=1)\n",
        "        conv5_size = self._get_conv_output_size(conv4_size, self.conv5.padding[0], self.conv5.stride[0], self.conv5.kernel_size[0])\n",
        "        pool3_size = self._get_conv_output_size(conv5_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)\n",
        "        \n",
        "        self.linear1 = torch.nn.Linear(in_features=self.conv5.out_channels*pool3_size*pool3_size, out_features=4096)\n",
        "        self.linear2 = torch.nn.Linear(in_features=4096, out_features=4096)\n",
        "        self.linear3 = torch.nn.Linear(in_features=4096, out_features=4)\n",
        "        \n",
        "        self.softmax = torch.nn.Softmax(dim=1)\n",
        "        \n",
        "    \n",
        "    def _get_conv_output_size(self: 'ModifiedAlexNet', input_size: int, padding: int, stride: int, kernel_size: int) -> int:\n",
        "        \"\"\"Funtion that calculate the output convolution size\n",
        "\n",
        "        Args:\n",
        "            input_size (int): Size of the input\n",
        "            padding (int): Padding size\n",
        "            stride (int): Stride count\n",
        "            kernel_size (int): Size of the Kernel\n",
        "\n",
        "        Returns:\n",
        "            int: Output convolution size.\n",
        "        \"\"\"\n",
        "        return ((input_size+ (2* padding) - kernel_size)//stride)+1\n",
        "        \n",
        "    \n",
        "    def forward(self: 'ModifiedAlexNet', x: torch.Tensor) -> torch.Tensor:\n",
        "        \"\"\"Function that performs the forward pass of the Neural Network\n",
        "\n",
        "        Args:\n",
        "            x (torch.Tensor): Input Tensor that carries that information about a batch of images\n",
        "\n",
        "        Returns:\n",
        "            torch.Tensor: Output tensor that carries the predicted probability of each class.\n",
        "        \"\"\"\n",
        "        x = self.conv1(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.max_pool(x)\n",
        "        \n",
        "        x = self.conv2(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.max_pool(x)\n",
        "        \n",
        "        x = self.conv3(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        \n",
        "        x = self.conv4(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        \n",
        "        x = self.conv5(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.max_pool(x)\n",
        "        \n",
        "        x = torch.flatten(x, start_dim=1)\n",
        "        x = self.linear1(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        \n",
        "        x = self.linear2(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        \n",
        "        x = self.linear3(x)\n",
        "        x = self.softmax(x)\n",
        "        \n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yhVVce2tc45j",
        "outputId": "49f0e2f3-fa1d-49b6-90c6-eae98985093c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ModifiedAlexNet(\n",
              "  (max_pool): MaxPool2d(kernel_size=3, stride=1, padding=0, dilation=1, ceil_mode=False)\n",
              "  (conv1): Conv2d(1, 96, kernel_size=(11, 11), stride=(1, 1))\n",
              "  (conv2): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
              "  (conv3): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv4): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv5): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (linear1): Linear(in_features=36864, out_features=4096, bias=True)\n",
              "  (linear2): Linear(in_features=4096, out_features=4096, bias=True)\n",
              "  (linear3): Linear(in_features=4096, out_features=4, bias=True)\n",
              "  (softmax): Softmax(dim=1)\n",
              ")"
            ]
          },
          "execution_count": 51,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.manual_seed(69)\n",
        "alex_net = ModifiedAlexNet(input_size=28).to(device=DEVICE)\n",
        "alex_net"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "05qMGDbIc45j"
      },
      "outputs": [],
      "source": [
        "EPOCHS = 100\n",
        "optimizer = torch.optim.Adam(alex_net.parameters(), lr=3e-5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KcHwNZxMc45k",
        "outputId": "d6f64a89-864a-4c9b-8553-a991cf607ab9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "For Epoch 5 We Train Loss:0.9685391364767909, Val Loss:0.9621608164106499, Train Accuracy:0.4713736732546895, Val Accuracy:0.47735030953511376\n",
            "For Epoch 10 We Train Loss:0.9188753692105937, Val Loss:0.9098014052638613, Train Accuracy:0.5964826647275553, Val Accuracy:0.6220779338944978\n",
            "For Epoch 15 We Train Loss:0.9040830403852006, Val Loss:0.9002468673880473, Train Accuracy:0.6187248021459427, Val Accuracy:0.6303431854135519\n",
            "For Epoch 20 We Train Loss:0.8924077549300635, Val Loss:0.909443156381624, Train Accuracy:0.6511692286680301, Val Accuracy:0.6361662456243791\n",
            "For Epoch 25 We Train Loss:0.8829945169698697, Val Loss:0.9265741169628492, Train Accuracy:0.6822122973375047, Val Accuracy:0.6588330544904973\n",
            "For Epoch 30 We Train Loss:0.8761350697221847, Val Loss:0.8899281793287722, Train Accuracy:0.6982761406289122, Val Accuracy:0.6950978269267575\n",
            "For Epoch 35 We Train Loss:0.8641722546979642, Val Loss:0.8856873329410159, Train Accuracy:0.7254360405781779, Val Accuracy:0.6641784623309223\n",
            "For Epoch 40 We Train Loss:0.8589123458908008, Val Loss:0.8849197395783258, Train Accuracy:0.7325244680189857, Val Accuracy:0.6917025765134873\n",
            "For Epoch 45 We Train Loss:0.852453557827983, Val Loss:0.878127946087041, Train Accuracy:0.748190544283809, Val Accuracy:0.7023037284348919\n",
            "For Epoch 50 We Train Loss:0.8417561728352556, Val Loss:0.8750094544571058, Train Accuracy:0.7738611713385048, Val Accuracy:0.7090360255895463\n",
            "For Epoch 55 We Train Loss:0.8326221279823742, Val Loss:0.8799325776311149, Train Accuracy:0.795330036943332, Val Accuracy:0.7068510934666546\n",
            "For Epoch 60 We Train Loss:0.8327306638510463, Val Loss:0.8886454901864044, Train Accuracy:0.7942086067824318, Val Accuracy:0.6954511184256337\n",
            "For Epoch 65 We Train Loss:0.8301141189690977, Val Loss:0.886413085249673, Train Accuracy:0.7971256413398841, Val Accuracy:0.6896137334955829\n",
            "For Epoch 70 We Train Loss:0.8239449251193208, Val Loss:0.8768591928271066, Train Accuracy:0.8075959811957119, Val Accuracy:0.7222153704426634\n",
            "For Epoch 75 We Train Loss:0.8187489964710638, Val Loss:0.8721569329939761, Train Accuracy:0.8241084103767102, Val Accuracy:0.7274901432625313\n",
            "For Epoch 80 We Train Loss:0.8164044869974398, Val Loss:0.8790240832837986, Train Accuracy:0.8299962245999053, Val Accuracy:0.719510797729886\n",
            "For Epoch 85 We Train Loss:0.8129162620812559, Val Loss:0.8757913583851142, Train Accuracy:0.8377243192812887, Val Accuracy:0.7014092201680209\n",
            "For Epoch 90 We Train Loss:0.8103788738814406, Val Loss:0.8714293304797822, Train Accuracy:0.8376005015815028, Val Accuracy:0.7141671294132165\n",
            "For Epoch 95 We Train Loss:0.8117158826166829, Val Loss:0.87325718497808, Train Accuracy:0.8392409360446869, Val Accuracy:0.7317205807276531\n",
            "For Epoch 100 We Train Loss:0.8043501413287446, Val Loss:0.8719794595487701, Train Accuracy:0.8514192330951508, Val Accuracy:0.741497116454583\n"
          ]
        }
      ],
      "source": [
        "output_metrics = training_loop(model = alex_net, data_loader_train = train_dataloader, data_loader_val = val_dataloader,\n",
        "                               epochs = EPOCHS, loss_criterion = loss_criteria, optim_alog = optimizer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "Z_EyK3S2c45k",
        "outputId": "0789b955-d844-4214-ade7-8ddaf732f480"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_metrics(epochs = EPOCHS,metrics = output_metrics)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "id": "VacM21hbE52i"
      },
      "outputs": [],
      "source": [
        "test_loss, test_accuracy = inference(alex_net, test_dataloader, loss_criteria)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MVA9V6dNFabO",
        "outputId": "44d08b9e-b70b-484f-97ae-9b9b80e657f4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy is: 0.7020116224884987\n"
          ]
        }
      ],
      "source": [
        "print('Test Accuracy is: {0}'.format(test_accuracy))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "2LYCuEQ7qyzl"
      },
      "outputs": [],
      "source": [
        "del(alex_net)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "4CbDcmsFql_l"
      },
      "source": [
        "#### Early Stopping\n",
        "\n",
        "* The Learning curve started getting flat after 60 EPOCHS. So we will stop learning at 60 EPOCHS."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "prhGYUj5Q_dY",
        "outputId": "8de7fd99-f9cb-4a5a-c787-ed190a57b50b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ModifiedAlexNet(\n",
              "  (max_pool): MaxPool2d(kernel_size=3, stride=1, padding=0, dilation=1, ceil_mode=False)\n",
              "  (conv1): Conv2d(1, 96, kernel_size=(11, 11), stride=(1, 1))\n",
              "  (conv2): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
              "  (conv3): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv4): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv5): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (linear1): Linear(in_features=36864, out_features=4096, bias=True)\n",
              "  (linear2): Linear(in_features=4096, out_features=4096, bias=True)\n",
              "  (linear3): Linear(in_features=4096, out_features=4, bias=True)\n",
              "  (softmax): Softmax(dim=1)\n",
              ")"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.manual_seed(69)\n",
        "alex_net_es = ModifiedAlexNet(input_size=28).to(device=DEVICE)\n",
        "alex_net_es"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "Jku-_iiUq5Bt"
      },
      "outputs": [],
      "source": [
        "EPOCHS = 60\n",
        "optimizer = torch.optim.Adam(alex_net_es.parameters(), lr=3e-5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fZF_B469q8Mt",
        "outputId": "77f1d221-3ebe-4da1-d409-bac4f5c69640"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "For Epoch 5 We Train Loss:0.9666234152004741, Val Loss:0.9670591755250914, Train Accuracy:0.4727709620905379, Val Accuracy:0.47632217073159233\n",
            "For Epoch 10 We Train Loss:0.9212748882488702, Val Loss:0.9196225181441743, Train Accuracy:0.5941480453402851, Val Accuracy:0.6047734554889983\n",
            "For Epoch 15 We Train Loss:0.9028140266482442, Val Loss:0.9086907027745317, Train Accuracy:0.6163469918619711, Val Accuracy:0.6426751711199769\n",
            "For Epoch 20 We Train Loss:0.891529742521219, Val Loss:0.8949808205826796, Train Accuracy:0.6542937502312584, Val Accuracy:0.646048227066839\n",
            "For Epoch 25 We Train Loss:0.8877629154025556, Val Loss:0.8946263556283484, Train Accuracy:0.6686859456494975, Val Accuracy:0.6444252430513545\n",
            "For Epoch 30 We Train Loss:0.8732974180779137, Val Loss:0.8880266199069741, Train Accuracy:0.6984093441559484, Val Accuracy:0.696318390798428\n",
            "For Epoch 35 We Train Loss:0.8712855882157152, Val Loss:0.8822672080501343, Train Accuracy:0.705504835794528, Val Accuracy:0.6901014437541849\n",
            "For Epoch 40 We Train Loss:0.8597836056456398, Val Loss:0.8824730837239628, Train Accuracy:0.7381988681924229, Val Accuracy:0.6735460345899813\n",
            "For Epoch 45 We Train Loss:0.8493436673959605, Val Loss:0.8877339565296792, Train Accuracy:0.7576845021674428, Val Accuracy:0.6582528121527669\n",
            "For Epoch 50 We Train Loss:0.8425320276437095, Val Loss:0.881586799579384, Train Accuracy:0.7716533716875144, Val Accuracy:0.6892345218004379\n",
            "For Epoch 55 We Train Loss:0.842852210846191, Val Loss:0.8788998868964766, Train Accuracy:0.7719886114422124, Val Accuracy:0.6967686318014927\n",
            "For Epoch 60 We Train Loss:0.8356019972612302, Val Loss:0.8903795438530171, Train Accuracy:0.791825037794753, Val Accuracy:0.6899318972871719\n"
          ]
        }
      ],
      "source": [
        "output_metrics = training_loop(model = alex_net_es, data_loader_train = train_dataloader, data_loader_val = val_dataloader,\n",
        "                               epochs = EPOCHS, loss_criterion = loss_criteria, optim_alog = optimizer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "aY1gwIAHrBu7",
        "outputId": "943a8e1d-423c-4aef-d7d4-a2022a58ba7a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_metrics(epochs = EPOCHS,metrics = output_metrics)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "AfMEDBDtrFQu"
      },
      "outputs": [],
      "source": [
        "test_loss, test_accuracy = inference(alex_net_es, test_dataloader, loss_criteria)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pd6_P_QDyWn3",
        "outputId": "097ae69b-8b57-48d2-e67d-5d63d622c2e8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy is: 0.6764559168368578\n"
          ]
        }
      ],
      "source": [
        "print('Test Accuracy is: {0}'.format(test_accuracy))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "Yyn0_K6izvig"
      },
      "outputs": [],
      "source": [
        "del(alex_net_es)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "p_TE4R6xJbNi"
      },
      "source": [
        "#### L2 Regularization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yh1P3ROpJqMg",
        "outputId": "fb1cd09d-6573-4fb6-f94e-3f66377cabbf"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ModifiedAlexNet(\n",
              "  (max_pool): MaxPool2d(kernel_size=3, stride=1, padding=0, dilation=1, ceil_mode=False)\n",
              "  (conv1): Conv2d(1, 96, kernel_size=(11, 11), stride=(1, 1))\n",
              "  (conv2): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
              "  (conv3): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv4): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv5): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (linear1): Linear(in_features=36864, out_features=4096, bias=True)\n",
              "  (linear2): Linear(in_features=4096, out_features=4096, bias=True)\n",
              "  (linear3): Linear(in_features=4096, out_features=4, bias=True)\n",
              "  (softmax): Softmax(dim=1)\n",
              ")"
            ]
          },
          "execution_count": 36,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.manual_seed(69)\n",
        "alex_net_l2 = ModifiedAlexNet(input_size=28).to(device=DEVICE)\n",
        "alex_net_l2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "83Cl1VEHJ0zs"
      },
      "outputs": [],
      "source": [
        "EPOCHS = 60\n",
        "optimizer = torch.optim.Adam(alex_net_l2.parameters(), lr=3e-5, weight_decay=1e-5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jhdkIV9DKZr2",
        "outputId": "b1ab7d9b-4ba4-4ac1-e7f1-d86976acf190"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "For Epoch 5 We Train Loss:0.9681158381909989, Val Loss:0.980509695753587, Train Accuracy:0.4713567329671817, Val Accuracy:0.4691347735645497\n",
            "For Epoch 10 We Train Loss:0.9222659512449758, Val Loss:0.9193466659140798, Train Accuracy:0.5912028331154833, Val Accuracy:0.6016342962561807\n",
            "For Epoch 15 We Train Loss:0.9029907089071914, Val Loss:0.913582018343045, Train Accuracy:0.6205398845025145, Val Accuracy:0.622436288711244\n",
            "For Epoch 20 We Train Loss:0.8941925192793337, Val Loss:0.8934171588371637, Train Accuracy:0.6539799093057553, Val Accuracy:0.6673905202421115\n",
            "For Epoch 25 We Train Loss:0.8871945961595724, Val Loss:0.8895160248145945, Train Accuracy:0.6732646953374052, Val Accuracy:0.6752157430205725\n",
            "For Epoch 30 We Train Loss:0.8823292617218944, Val Loss:0.8930192631957805, Train Accuracy:0.683623815972965, Val Accuracy:0.6487210173170826\n",
            "For Epoch 35 We Train Loss:0.8684864198437895, Val Loss:0.8853949028833777, Train Accuracy:0.7176219385843308, Val Accuracy:0.6801399867267384\n",
            "For Epoch 40 We Train Loss:0.858688617285829, Val Loss:0.8873711437602311, Train Accuracy:0.736528888106727, Val Accuracy:0.6538434841815701\n",
            "For Epoch 45 We Train Loss:0.8501169016947762, Val Loss:0.890394139254691, Train Accuracy:0.760844183425172, Val Accuracy:0.7115497250648375\n",
            "For Epoch 50 We Train Loss:0.8407055981242999, Val Loss:0.87851218364935, Train Accuracy:0.7776614937919397, Val Accuracy:0.6905179021105302\n",
            "For Epoch 55 We Train Loss:0.8403583403212574, Val Loss:0.8788318452933545, Train Accuracy:0.7772098503554591, Val Accuracy:0.713960693737047\n",
            "For Epoch 60 We Train Loss:0.82976492944236, Val Loss:0.8869065668730609, Train Accuracy:0.8026288816342338, Val Accuracy:0.7354124879415056\n"
          ]
        }
      ],
      "source": [
        "output_metrics = training_loop(model = alex_net_l2, data_loader_train = train_dataloader, data_loader_val = val_dataloader,\n",
        "                               epochs = EPOCHS, loss_criterion = loss_criteria, optim_alog = optimizer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "J6yiQeQGKfoX",
        "outputId": "91d97641-8d86-4a71-f26a-1de2d58bc5ea"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_metrics(epochs = EPOCHS,metrics = output_metrics)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "dmNngU3mUvaJ"
      },
      "outputs": [],
      "source": [
        "test_loss, test_accuracy = inference(alex_net_l2, test_dataloader, loss_criteria)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bE32E6ohUz-w",
        "outputId": "a99b80b2-69ff-4986-b8b6-1821a56af66a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy is: 0.6985473390668631\n"
          ]
        }
      ],
      "source": [
        "print('Test Accuracy is: {0}'.format(test_accuracy))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "s0h8M_K5V_Q0"
      },
      "outputs": [],
      "source": [
        "del(alex_net_l2)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "XudI40fCVBGW"
      },
      "source": [
        "#### Dropout"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "Fmi06gBlU3L9"
      },
      "outputs": [],
      "source": [
        "class ModifiedAlexNet(torch.nn.Module):\n",
        "    \n",
        "    def __init__(self: 'ModifiedAlexNet', input_size: int)-> None:\n",
        "        \"\"\"Function to initate the model layers\n",
        "\n",
        "        Args:\n",
        "            input_size (int): Input size of the image\n",
        "        \"\"\"\n",
        "        super(ModifiedAlexNet,self).__init__()\n",
        "    \n",
        "        self.max_pool = torch.nn.MaxPool2d(kernel_size=3,stride=1)\n",
        "        \n",
        "        self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=96, kernel_size=11)\n",
        "        conv1_size = self._get_conv_output_size(input_size, self.conv1.padding[0], self.conv1.stride[0], self.conv1.kernel_size[0])\n",
        "        pool1_size = self._get_conv_output_size(conv1_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)\n",
        "        \n",
        "        self.conv2 = torch.nn.Conv2d(in_channels=96, out_channels=256, kernel_size=5, padding=2)\n",
        "        conv2_size = self._get_conv_output_size(pool1_size, self.conv2.padding[0], self.conv2.stride[0], self.conv2.kernel_size[0])\n",
        "        pool2_size = self._get_conv_output_size(conv2_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)\n",
        "        \n",
        "        self.conv3 = torch.nn.Conv2d(in_channels=256, out_channels=384, kernel_size=3, padding=1)\n",
        "        conv3_size = self._get_conv_output_size(pool2_size, self.conv3.padding[0], self.conv3.stride[0], self.conv3.kernel_size[0])\n",
        "        \n",
        "        self.conv4 = torch.nn.Conv2d(in_channels=384, out_channels=384, kernel_size=3, padding=1)\n",
        "        conv4_size = self._get_conv_output_size(conv3_size, self.conv4.padding[0], self.conv4.stride[0], self.conv4.kernel_size[0])\n",
        "        \n",
        "        self.conv5 = torch.nn.Conv2d(in_channels=384, out_channels=256, kernel_size=3, padding=1)\n",
        "        conv5_size = self._get_conv_output_size(conv4_size, self.conv5.padding[0], self.conv5.stride[0], self.conv5.kernel_size[0])\n",
        "        pool3_size = self._get_conv_output_size(conv5_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)\n",
        "        \n",
        "        self.linear1 = torch.nn.Linear(in_features=self.conv5.out_channels*pool3_size*pool3_size, out_features=4096)\n",
        "        self.linear2 = torch.nn.Linear(in_features=4096, out_features=4096)\n",
        "        self.linear3 = torch.nn.Linear(in_features=4096, out_features=4)\n",
        "\n",
        "        self.dropout = torch.nn.Dropout(p=0.4)\n",
        "        \n",
        "        self.softmax = torch.nn.Softmax(dim=1)\n",
        "        \n",
        "    \n",
        "    def _get_conv_output_size(self: 'ModifiedAlexNet', input_size: int, padding: int, stride: int, kernel_size: int) -> int:\n",
        "        \"\"\"Funtion that calculate the output convolution size\n",
        "\n",
        "        Args:\n",
        "            input_size (int): Size of the input\n",
        "            padding (int): Padding size\n",
        "            stride (int): Stride count\n",
        "            kernel_size (int): Size of the Kernel\n",
        "\n",
        "        Returns:\n",
        "            int: Output convolution size.\n",
        "        \"\"\"\n",
        "        return ((input_size+ (2* padding) - kernel_size)//stride)+1\n",
        "        \n",
        "    \n",
        "    def forward(self: 'ModifiedAlexNet', x: torch.Tensor) -> torch.Tensor:\n",
        "        \"\"\"Function that performs the forward pass of the Neural Network\n",
        "\n",
        "        Args:\n",
        "            x (torch.Tensor): Input Tensor that carries that information about a batch of images\n",
        "\n",
        "        Returns:\n",
        "            torch.Tensor: Output tensor that carries the predicted probability of each class.\n",
        "        \"\"\"\n",
        "        x = self.conv1(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.max_pool(x)\n",
        "        \n",
        "        x = self.conv2(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.max_pool(x)\n",
        "        \n",
        "        x = self.conv3(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        \n",
        "        x = self.conv4(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        \n",
        "        x = self.conv5(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.max_pool(x)\n",
        "        \n",
        "        x = torch.flatten(x, start_dim=1)\n",
        "        x = self.linear1(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.dropout(x)\n",
        "        \n",
        "        x = self.linear2(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.dropout(x)\n",
        "        \n",
        "        x = self.linear3(x)\n",
        "        x = self.softmax(x)\n",
        "        \n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KE2683y5Vr9s",
        "outputId": "eed65104-9010-4f35-ea42-bee3940c6487"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ModifiedAlexNet(\n",
              "  (max_pool): MaxPool2d(kernel_size=3, stride=1, padding=0, dilation=1, ceil_mode=False)\n",
              "  (conv1): Conv2d(1, 96, kernel_size=(11, 11), stride=(1, 1))\n",
              "  (conv2): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
              "  (conv3): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv4): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv5): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (linear1): Linear(in_features=36864, out_features=4096, bias=True)\n",
              "  (linear2): Linear(in_features=4096, out_features=4096, bias=True)\n",
              "  (linear3): Linear(in_features=4096, out_features=4, bias=True)\n",
              "  (dropout): Dropout(p=0.4, inplace=False)\n",
              "  (softmax): Softmax(dim=1)\n",
              ")"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.manual_seed(69)\n",
        "alex_net_do = ModifiedAlexNet(input_size=28).to(device=DEVICE)\n",
        "alex_net_do"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "bfonN406Vxsi"
      },
      "outputs": [],
      "source": [
        "EPOCHS = 60\n",
        "optimizer = torch.optim.Adam(alex_net_do.parameters(), lr=3e-5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0GQOoynfV4Kz",
        "outputId": "a6f71148-c688-4179-b088-e4fdeff47de0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "For Epoch 5 We Train Loss:0.9727609487006459, Val Loss:0.9794523763445626, Train Accuracy:0.4685018502485257, Val Accuracy:0.46988183857768684\n",
            "For Epoch 10 We Train Loss:0.9194194385038016, Val Loss:0.9158666369485996, Train Accuracy:0.5988009176886501, Val Accuracy:0.5985643992030163\n",
            "For Epoch 15 We Train Loss:0.9022716959825339, Val Loss:0.9046489744059807, Train Accuracy:0.619078841262732, Val Accuracy:0.626187977801382\n",
            "For Epoch 20 We Train Loss:0.8941793679810179, Val Loss:0.8994006716747903, Train Accuracy:0.6420834491999385, Val Accuracy:0.6364288017109784\n",
            "For Epoch 25 We Train Loss:0.890588496439754, Val Loss:0.9025197127575719, Train Accuracy:0.6594738846008008, Val Accuracy:0.6464855920600329\n",
            "For Epoch 30 We Train Loss:0.8810656674372883, Val Loss:0.9119883868898262, Train Accuracy:0.6753526575649127, Val Accuracy:0.630882460898706\n",
            "For Epoch 35 We Train Loss:0.870940159875364, Val Loss:0.9157895213734787, Train Accuracy:0.7046474464023456, Val Accuracy:0.7006476999735762\n",
            "For Epoch 40 We Train Loss:0.8619544694598872, Val Loss:0.8844208847456625, Train Accuracy:0.7221309586454885, Val Accuracy:0.6991245365072493\n",
            "For Epoch 45 We Train Loss:0.8555098636843526, Val Loss:0.8811037447248589, Train Accuracy:0.746930974169661, Val Accuracy:0.7094114829832825\n",
            "For Epoch 50 We Train Loss:0.849511044093976, Val Loss:0.8833921551704407, Train Accuracy:0.7540515042341556, Val Accuracy:0.7171210127945846\n",
            "For Epoch 55 We Train Loss:0.8373917345040903, Val Loss:0.8802269742903808, Train Accuracy:0.778838566126534, Val Accuracy:0.7154810534993455\n",
            "For Epoch 60 We Train Loss:0.8346144760759494, Val Loss:0.8782412001868617, Train Accuracy:0.7870964794494093, Val Accuracy:0.7055645475169551\n"
          ]
        }
      ],
      "source": [
        "output_metrics = training_loop(model = alex_net_do, data_loader_train = train_dataloader, data_loader_val = val_dataloader,\n",
        "                               epochs = EPOCHS, loss_criterion = loss_criteria, optim_alog = optimizer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "Tw_8vu95WGCL",
        "outputId": "c8523c1f-8a2f-473b-ed1c-921b14f87a49"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABNoAAAHWCAYAAAChceSWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gUVdvA4d/upveEVCCQEHqHIL0qEIogIIqAUmxYeC1Y8VWahe+1IIoiSrfSbAgIBBAp0qv0llBTCKTXTXa+Pya7sKRtkk02wHNfV66dzJ45c+ZkN5k8e855NIqiKAghhBBCCCGEEEIIIcpFa+sGCCGEEEIIIYQQQghxJ5BAmxBCCCGEEEIIIYQQViCBNiGEEEIIIYQQQgghrEACbUIIIYQQQgghhBBCWIEE2oQQQgghhBBCCCGEsAIJtAkhhBBCCCGEEEIIYQUSaBNCCCGEEEIIIYQQwgok0CaEEEIIIYQQQgghhBVIoE0IIYQQQgghhBBCCCuQQJsQhRgzZgwhISG2bkaZdO/ene7du1f6eQvrM41Gw5QpU0o8dsqUKWg0Gqu2Z/PmzWg0GjZv3mzVei1hq5+BuD10796dpk2b2roZQghxW5B7stKTezIh7izR0dFoNBo+/vhjWzdFWEgCbeK2otFoLPqSP+RF279/PxqNhrfffrvIMqdPn0aj0TBhwoRKbFnZzJ49m0WLFtm6GUIIIcRdRe7Jyk/uyYQQ4s5kZ+sGCFEa3333ndn33377LZGRkQX2N2rUqFznmTt3LgaDoVx1VFWtW7emYcOG/PTTT7z33nuFlvnxxx8BePTRR8t1rszMTOzsKvbXzOzZs/H19WXMmDFm+7t27UpmZiYODg4Ven4hhBDibiT3ZOUn92RCCHFnkkCbuK3cepOxc+dOIiMjS7z5yMjIwMXFxeLz2Nvbl6l9t4uRI0fyzjvvsHPnTtq3b1/g+Z9++omGDRvSunXrcp3HycmpXMeXh1arten57za5ubkYDAa5iRZCiLuE3JNZh9yTCSODwUBOTs5d1Vfp6em4urrauhlCWJ1MHRV3HOP6R/v27aNr1664uLjw1ltvAfD777/Tv39/qlevjqOjI2FhYbz77rvk5eWZ1XHr2hY3z4v/5ptvCAsLw9HRkXvuuYc9e/aU2Kbr16/z6quv0qxZM9zc3PDw8KBv374cOnTIrJxxDYtly5bx/vvvU7NmTZycnLjvvvs4c+ZMgXqNbXF2dqZt27Zs3brVoj4aOXIkcONT0pvt27ePkydPmspY2meFKWw9kG3btnHPPffg5OREWFgYX3/9daHHLly4kHvvvRd/f38cHR1p3LgxX331lVmZkJAQjh49yt9//22aomJcC6Wo9UCWL19OeHg4zs7O+Pr68uijj3L58mWzMmPGjMHNzY3Lly8zaNAg3Nzc8PPz49VXX7XougsTHx/PE088QUBAAE5OTrRo0YLFixcXKLdkyRLCw8Nxd3fHw8ODZs2a8dlnn5me1+v1TJ06lXr16uHk5ES1atXo3LkzkZGRxZ7f0tcgQFZWFlOmTKF+/fo4OTkRFBTEkCFDOHv2LGD+fpg5c6bp/XDs2DEANm3aRJcuXXB1dcXLy4sHHniA48ePm50jNTWVl156iZCQEBwdHfH396dXr17s37/fVOb06dM8+OCDBAYG4uTkRM2aNXnkkUdITk4usb937dpFnz598PT0xMXFhW7durF9+3azMsZ1aE6cOMHDDz+Mh4cH1apV48UXXyQrK8usbG5uLu+++67pWkNCQnjrrbfIzs4ucO4///yTbt26mX6G99xzT6HvtWPHjtGjRw9cXFyoUaMGH374YYEys2bNokmTJri4uODt7U2bNm0KrUsIIaoiuScrmdyTVew9WWn6bNeuXfTr1w9vb29cXV1p3ry52T0YYLpn8PPzw9nZmQYNGvDf//7XrL2FrSlY2Np3Go2G8ePH88MPP9CkSRMcHR1Zu3YtAB9//DEdO3akWrVqODs7Ex4ezooVKwq9xu+//562bdua7hW6du3K+vXrARg9ejS+vr7o9foCx/Xu3ZsGDRoU239bt27loYceolatWjg6OhIcHMzLL79MZmZmgbIl9Y2xD44dO8aIESPw9vamc+fOgOX3WXv37iUiIgJfX1+cnZ0JDQ3l8ccfNytT0r10UQwGAzNnzqRJkyY4OTkREBDAuHHjSExMNCsXEhLC/fffz/r162nZsiVOTk40btyYX375pUCd586d46GHHsLHxwcXFxfat2/P6tWrC5Qr6d77ZiX93ouNjWXs2LHUrFkTR0dHgoKCeOCBB4iOji6xD4T1yIg2cUe6du0affv25ZFHHuHRRx8lICAAgEWLFuHm5saECRNwc3Nj06ZNTJo0iZSUFD766KMS6/3xxx9JTU1l3LhxaDQaPvzwQ4YMGcK5c+eK/cT13Llz/Pbbbzz00EOEhoYSFxfH119/Tbdu3Th27BjVq1c3K/9///d/aLVaXn31VZKTk/nwww8ZOXIku3btMpWZP38+48aNo2PHjrz00kucO3eOgQMH4uPjQ3BwcLHXERoaSseOHVm2bBmffvopOp3O7BoBRowYYZU+u9m///5L79698fPzY8qUKeTm5jJ58mTTz+dmX331FU2aNGHgwIHY2dnxxx9/8Nxzz2EwGHj++ecBmDlzJv/5z39wc3Mz/SEvrC6jRYsWMXbsWO655x6mT59OXFwcn332Gdu3b+fAgQN4eXmZyubl5REREUG7du34+OOP2bBhA5988glhYWE8++yzpbruzMxMunfvzpkzZxg/fjyhoaEsX76cMWPGkJSUxIsvvghAZGQkw4cP57777uN///sfAMePH2f79u2mMlOmTGH69Ok8+eSTtG3blpSUFPbu3cv+/fvp1atXkW2w9DWYl5fH/fffz8aNG3nkkUd48cUXSU1NJTIykiNHjhAWFmaqc+HChWRlZfH000/j6OiIj48PGzZsoG/fvtSpU4cpU6aQmZnJrFmz6NSpE/v37zfdfD7zzDOsWLGC8ePH07hxY65du8a2bds4fvw4rVu3Jicnh4iICLKzs/nPf/5DYGAgly9fZtWqVSQlJeHp6VnktW7atIm+ffsSHh7O5MmT0Wq1pn8Stm7dStu2bc3KP/zww4SEhDB9+nR27tzJ559/TmJiIt9++62pzJNPPsnixYsZOnQor7zyCrt27WL69OkcP36cX3/91VRu0aJFPP744zRp0oSJEyfi5eXFgQMHWLt2rek9BZCYmEifPn0YMmQIDz/8MCtWrOCNN96gWbNm9O3bF1CnS73wwgsMHTrUFPw7fPgwu3btMqtLCCGqMrknk3uywlTWPZmlfRYZGcn9999PUFAQL774IoGBgRw/fpxVq1aZ7sEOHz5Mly5dsLe35+mnnyYkJISzZ8/yxx9/8P7771vc9zfbtGkTy5YtY/z48fj6+prukz777DMGDhzIyJEjycnJYcmSJTz00EOsWrWK/v37m46fOnUqU6ZMoWPHjkybNg0HBwd27drFpk2b6N27N4899hjffvst69at4/777zcdFxsby6ZNm5g8eXKx7Vu+fDkZGRk8++yzVKtWjd27dzNr1iwuXbrE8uXLTeVK0zcPPfQQ9erV44MPPkBRFMCy+6z4+HjTa/bNN9/Ey8uL6OhoswCXJffSRRk3bpzpdfnCCy8QFRXFF198wYEDB9i+fbvZ75XTp08zbNgwnnnmGUaPHs3ChQt56KGHWLt2rel+PC4ujo4dO5KRkcELL7xAtWrVWLx4MQMHDmTFihUMHjwYKN29tyW/9x588EGOHj3Kf/7zH0JCQoiPjycyMpILFy7ctollbkuKELex559/Xrn1ZdytWzcFUObMmVOgfEZGRoF948aNU1xcXJSsrCzTvtGjRyu1a9c2fR8VFaUASrVq1ZTr16+b9v/+++8KoPzxxx/FtjMrK0vJy8sz2xcVFaU4Ojoq06ZNM+3766+/FEBp1KiRkp2dbdr/2WefKYDy77//KoqiKDk5OYq/v7/SsmVLs3LffPONAijdunUrtj2KoihffvmlAijr1q0z7cvLy1Nq1KihdOjQwbSvrH2mKIoCKJMnTzZ9P2jQIMXJyUk5f/68ad+xY8cUnU5X4OdY2HkjIiKUOnXqmO1r0qRJoddr7Mu//vpLUZQbfda0aVMlMzPTVG7VqlUKoEyaNMnsWgCzn42iKEqrVq2U8PDwAue6Vbdu3czaNHPmTAVQvv/+e9O+nJwcpUOHDoqbm5uSkpKiKIqivPjii4qHh4eSm5tbZN0tWrRQ+vfvX2IbbmXpa3DBggUKoMyYMaNAHQaDwXQcoHh4eCjx8fFmZVq2bKn4+/sr165dM+07dOiQotVqlVGjRpn2eXp6Ks8//3yR7T1w4IACKMuXLy/VdRoMBqVevXpKRESEqb2Kor6eQkNDlV69epn2TZ48WQGUgQMHmtXx3HPPKYBy6NAhRVEU5eDBgwqgPPnkk2blXn31VQVQNm3apCiKoiQlJSnu7u5Ku3btzF5jxnYZGX9Hffvtt6Z92dnZSmBgoPLggw+a9j3wwANKkyZNSnX9QghhK3JPJvdkVfGezJI+y83NVUJDQ5XatWsriYmJZmVv/vvdtWtXxd3d3azPbi1TWN8ryo17jpsBilarVY4ePVpiu3NycpSmTZsq9957r2nf6dOnFa1WqwwePLjAa9rYpry8PKVmzZrKsGHDzJ6fMWOGotFolHPnzhU4d3HtUBRFmT59uqLRaMz6wZK+MfbB8OHDzcpYep/166+/KoCyZ8+eIttryb10YbZu3aoAyg8//GC2f+3atQX2165dWwGUn3/+2bQvOTlZCQoKUlq1amXa99JLLymAsnXrVtO+1NRUJTQ0VAkJCTH9zEpz713S773ExEQFUD766KNSXb+wPpk6Ku5Ijo6OjB07tsB+Z2dn03ZqaioJCQl06dKFjIwMTpw4UWK9w4YNw9vb2/R9ly5dAPXT0ZLao9Wqb7e8vDyuXbuGm5sbDRo0MJsqZzR27Fizta5uPc/evXuJj4/nmWeeMSs3ZsyYYkf63Hot9vb2ZlMV/v77by5fvmyaogDl7zOjvLw81q1bx6BBg6hVq5Zpf6NGjYiIiChQ/ubzJicnk5CQQLdu3Th37pxFUwdvZeyz5557zmzti/79+9OwYcNCh3E/88wzZt936dKlxJ91YdasWUNgYCDDhw837bO3t+eFF14gLS2Nv//+GwAvLy/S09OLnQbq5eXF0aNHOX36dKnaYOlr8Oeff8bX15f//Oc/Beq4dcrDgw8+iJ+fn+n7mJgYDh48yJgxY/Dx8THtb968Ob169WLNmjVm17Fr1y6uXLlSaHuNr+N169aRkZFh8XUePHiQ06dPM2LECK5du0ZCQgIJCQmkp6dz3333sWXLlgKLahs/jTcyXruxvcbHWzO+vfLKKwCm105kZCSpqam8+eabBdZXubXv3NzczNYxcnBwoG3btmavLy8vLy5dumTRVCghhKiq5J6sZHJPpqqIezJL+uzAgQNERUXx0ksvmY2kgxt/v69evcqWLVt4/PHHzfrs5jJl0a1bNxo3blxsuxMTE0lOTqZLly5mr9HffvsNg8HApEmTTK/pW9uk1WoZOXIkK1euJDU11fT8Dz/8QMeOHQkNDS22fTe3Iz09nYSEBDp27IiiKBw4cAAofd/c+rO09D7L+LNZtWpVoVNhjWVKupcuzPLly/H09KRXr16me8eEhATCw8Nxc3Pjr7/+MitfvXp104g0AA8PD0aNGsWBAweIjY01XVfbtm1N02NBvf97+umniY6ONi25Upp775J+7zk7O+Pg4MDmzZsLTHkVlUsCbeKOVKNGjUIXZT969CiDBw/G09MTDw8P/Pz8TP/sWnKjcOsfD+MvupJ+kRkMBj799FPq1auHo6Mjvr6++Pn5cfjw4ULPW9J5zp8/D0C9evXMytnb21OnTp0SrwOgWrVqRERE8Ouvv5rWo/rxxx+xs7Pj4YcfNpUrb58ZXb16lczMzAJtBgpdH2L79u307NnTtM6Xn5+faV2XstzUGfussHM1bNjQ9LyRk5OTWRAJ1J9DWf5onT9/nnr16hW4CTJmYjOe+7nnnqN+/fr07duXmjVr8vjjj5vW6jCaNm0aSUlJ1K9fn2bNmvHaa69x+PDhEttg6Wvw7NmzNGjQwKLMZLfenBXXx40aNTIFvAA+/PBDjhw5QnBwMG3btmXKlClmN8yhoaFMmDCBefPm4evrS0REBF9++WWJP3tjAHL06NH4+fmZfc2bN4/s7OwCddz6mgwLC0Or1ZrWsjh//jxarZa6deualQsMDMTLy8t03cZ1NJo2bVpsGwFq1qxZ4Obp1tfXG2+8gZubG23btqVevXo8//zzBdaZE0KIqk7uyUom92Q3WPuezJI+s+Tvt/EexZK/8aVRVKBr1apVtG/fHicnJ3x8fPDz8+Orr74qcM+m1WoLDdTdbNSoUWRmZpqmYJ48eZJ9+/bx2GOPldi+CxcumD5ANa6P161bN+BG/5W2bwq7f7TkPqtbt248+OCDTJ06FV9fXx544AEWLlxoto6bJffShTl9+jTJycn4+/sXuH9MS0sjPj7erHzdunUL3MfVr18fwOz+sah7YuPzULp775J+Hzk6OvK///2PP//8k4CAALp27cqHH35oCv6JyiOBNnFHuvnTF6OkpCS6devGoUOHmDZtGn/88QeRkZGm+fuWpI6/ed2Mmyn56wsU5YMPPmDChAl07dqV77//nnXr1hEZGUmTJk0KPW9Zz1Najz76KCkpKaxatYqcnBx+/vln09oHYJ0+K4uzZ89y3333kZCQwIwZM1i9ejWRkZG8/PLLFXremxX1M6hI/v7+HDx4kJUrVzJw4ED++usv+vbty+jRo01lunbtytmzZ1mwYAFNmzZl3rx5tG7dmnnz5hVbd2lfg5Yo7H1mqYcffphz584xa9YsqlevzkcffUSTJk34888/TWU++eQTDh8+zFtvvUVmZiYvvPACTZo04dKlS0XWa7yWjz76iMjIyEK/3Nzcim1bUZ9Ml+cT61tZ8h5v1KgRJ0+eZMmSJXTu3Jmff/6Zzp07l7ieihBCVCVyT2YZuScrWlnvyWzRZ0XdKxSVuKGw98fWrVsZOHAgTk5OzJ49mzVr1hAZGcmIESPK9Lpr3Lgx4eHhfP/994CaPMHBwcEsiFtUm3v16sXq1at54403+O2334iMjGTRokVA2fuvqPvHku6zNBoNK1asYMeOHYwfP57Lly/z+OOPEx4eTlpaGmDZvXRhDAYD/v7+Rd47Tps2rUzXam2W/D566aWXOHXqFNOnT8fJyYl33nmHRo0amUYgisohyRDEXWPz5s1cu3aNX375ha5du5r2R0VFVfi5V6xYQY8ePZg/f77Z/qSkJHx9fUtdX+3atQH105d7773XtF+v1xMVFUWLFi0sqmfgwIG4u7vz448/Ym9vT2JiotkUBWv2mTEDUWFTHk+ePGn2/R9//EF2djYrV640++Tm1mHbYHnww9hnJ0+eNOsz4z7j8xWhdu3aHD58GIPBYDaqzThl4eZzOzg4MGDAAAYMGIDBYOC5557j66+/5p133jF90ufj48PYsWMZO3YsaWlpdO3alSlTpvDkk08W2QZLX4NhYWHs2rULvV5f7GLSRV0nFPx5Gq/V19fXLIV7UFAQzz33HM899xzx8fG0bt2a999/35QMAKBZs2Y0a9aMt99+m3/++YdOnToxZ84c3nvvvULbYFww1sPDg549e1rU7tOnT5t9unrmzBkMBoNpwdjatWtjMBg4ffq06VNIUBe5TUpKMl238dxHjhwp8KlsWbm6ujJs2DCGDRtGTk4OQ4YM4f3332fixIkFpqcKIcTtQu7JCpJ7shvnt9Y9maV9dvPf76LuHYyjE48cOVLsOb29vUlKSiqw/9ZResX5+eefcXJyYt26dTg6Opr2L1y4sEC7DQYDx44do2XLlsXWOWrUKCZMmEBMTAw//vgj/fv3N5uCWJh///2XU6dOsXjxYkaNGmXaf+u0TEv7piiW3mcZtW/fnvbt2/P+++/z448/MnLkSJYsWWK6D7bkXvpWYWFhbNiwgU6dOln0QfKZM2dQFMXsNX/q1CkAs/vHou6Jjc8bz13We++ihIWF8corr/DKK69w+vRpWrZsySeffGIKtoqKJyPaxF3D+AnAzRH/nJwcZs+eXSnnvvUTqOXLlxdIYW6pNm3a4Ofnx5w5c8jJyTHtX7RoUaF/3Ivi7OzM4MGDWbNmDV999RWurq488MADZu0G6/SZTqcjIiKC3377jQsXLpj2Hz9+nHXr1hUoe+t5k5OTC9xggBqIsOSa27Rpg7+/P3PmzDEbYv7nn39y/PhxswxO1tavXz9iY2NZunSpaV9ubi6zZs3Czc3NNAT/2rVrZsdptVqaN28OYGrzrWXc3NyoW7dugfTnt7L0Nfjggw+SkJDAF198UaCOkj5FDQoKomXLlixevNjsZ3LkyBHWr19Pv379APUT0lunmvj7+1O9enXTdaSkpJCbm2tWplmzZmi12mKvNTw8nLCwMD7++GPTp5s3u3r1aoF9X375pdn3s2bNAjAF/Iztnjlzplm5GTNmAJheO71798bd3Z3p06ebpv4YleUT6Ft/1g4ODjRu3BhFUYpcm0QIIW4Hck9WkNyTWf+ezNI+a926NaGhocycObNA+43H+vn50bVrVxYsWGDWZ7fWHxYWRnJystmyHjExMWYZyi1pt0ajMRsFFx0dzW+//WZWbtCgQWi1WqZNm1ZgdNmtr/Hhw4ej0Wh48cUXOXfunNk6scW149a6FEXhs88+Mytnad8UxdL7rMTExAL1GQOMRd0nF3YvXZiHH36YvLw83n333QLP5ebmFnhdXLlyxexnmpKSwrfffkvLli0JDAw0Xdfu3bvZsWOHqVx6ejrffPMNISEhpim/5bn3vlVGRkaBe9CwsDDc3d1L/F9BWJeMaBN3jY4dO+Lt7c3o0aN54YUX0Gg0fPfdd1Yf+l+Y+++/n2nTpjF27Fg6duzIv//+yw8//GDx2h23sre357333mPcuHHce++9DBs2jKioKBYuXFjqOh999FFT2u+RI0eajTiydp9NnTqVtWvX0qVLF5577jlTsKlJkyZmNyS9e/c2fRo1btw40tLSmDt3Lv7+/sTExJjVGR4ezldffcV7771H3bp18ff3L/DpKKh99r///Y+xY8fSrVs3hg8fbkolHxISYpoCURGefvppvv76a8aMGcO+ffsICQlhxYoVbN++nZkzZ+Lu7g6oqc2vX7/OvffeS82aNTl//jyzZs2iZcuWpk/4GjduTPfu3QkPD8fHx4e9e/eyYsUKxo8fX2wbLH0Njho1im+//ZYJEyawe/duunTpQnp6Ohs2bOC5554zu+kvzEcffUTfvn3p0KEDTzzxBJmZmcyaNQtPT0+mTJkCqIsR16xZk6FDh9KiRQvc3NzYsGEDe/bs4ZNPPgHUdPfjx4/noYceon79+uTm5vLdd9+h0+l48MEHizy/Vqtl3rx59O3blyZNmjB27Fhq1KjB5cuX+euvv/Dw8OCPP/4wOyYqKoqBAwfSp08fduzYwffff8+IESNMoxBatGjB6NGj+eabb0zTUHbv3s3ixYsZNGgQPXr0ANRRdJ9++ilPPvkk99xzDyNGjMDb25tDhw6RkZHB4sWLi+27W/Xu3ZvAwEA6depEQEAAx48f54svvqB///6m14wQQtyO5J6scHJPZt17Mkv7TKvV8tVXXzFgwABatmzJ2LFjCQoK4sSJExw9etQUfPz888/p3LkzrVu35umnnyY0NJTo6GhWr17NwYMHAXjkkUd44403GDx4MC+88AIZGRl89dVX1K9fv9BkG4Xp378/M2bMoE+fPowYMYL4+Hi+/PJL6tata/azqVu3Lv/9739599136dKlC0OGDMHR0ZE9e/ZQvXp1pk+fbirr5+dHnz59WL58OV5eXhYFMxs2bEhYWBivvvoqly9fxsPDg59//rnQtfEs6ZuiWHqftXjxYmbPns3gwYMJCwsjNTWVuXPn4uHhYQrWWXIvXZhu3boxbtw4pk+fzsGDB+nduzf29vacPn2a5cuX89lnnzF06FBT+fr16/PEE0+wZ88eAgICWLBgAXFxcWYB6DfffJOffvqJvn378sILL+Dj48PixYuJiori559/Ns1yKe+9981OnTrFfffdx8MPP0zjxo2xs7Pj119/JS4ujkceecTieoQVVHBWUyEqVFGp5Js0aVJo+e3btyvt27dXnJ2dlerVqyuvv/66sm7dOrOU44pSdCr5wlIlc0u69MJkZWUpr7zyihIUFKQ4OzsrnTp1Unbs2KF069bNLA26Mf358uXLzY43nn/hwoVm+2fPnq2EhoYqjo6OSps2bZQtW7YUqLMkubm5SlBQkAIoa9asKfB8WftMUQrvm7///lsJDw9XHBwclDp16ihz5swpNOX5ypUrlebNmytOTk5KSEiI8r///c+U/joqKspULjY2Vunfv7/i7u6uAKZrvzWVvNHSpUuVVq1aKY6OjoqPj48ycuRI5dKlS2ZlRo8erbi6uhboi8LaWZjCfgZxcXHK2LFjFV9fX8XBwUFp1qxZgZ/nihUrlN69eyv+/v6Kg4ODUqtWLWXcuHFKTEyMqcx7772ntG3bVvHy8lKcnZ2Vhg0bKu+//76Sk5NTbJssfQ0qiprK/b///a8SGhqq2NvbK4GBgcrQoUOVs2fPKopS/PtBURRlw4YNSqdOnRRnZ2fFw8NDGTBggHLs2DHT89nZ2cprr72mtGjRQnF3d1dcXV2VFi1aKLNnzzaVOXfunPL4448rYWFhipOTk+Lj46P06NFD2bBhQ7HXaXTgwAFlyJAhSrVq1RRHR0eldu3aysMPP6xs3LjRVMb48zx27JgydOhQxd3dXfH29lbGjx+vZGZmmtWn1+uVqVOnmvokODhYmThxopKVlVXg3CtXrlQ6duxouv62bdsqP/30k+n5on5H3foe+vrrr5WuXbuariEsLEx57bXXlOTkZIv6QAghKpPck8k9WVW8J7O0zxRFUbZt26b06tXLdG/SvHlzZdasWWZljhw5ogwePFjx8vJSnJyclAYNGijvvPOOWZn169crTZs2VRwcHJQGDRoo33//faHtBZTnn3++0HbPnz9fqVevnuLo6Kg0bNhQWbhwYZHXvGDBAlM/ent7K926dVMiIyMLlFu2bJkCKE8//XSJ/WZ07NgxpWfPnoqbm5vi6+urPPXUU8qhQ4cKfQ+U1DfG9l+9erXAeSy5z9q/f78yfPhwpVatWoqjo6Pi7++v3H///crevXtNZSy5ly7ON998o4SHhyvOzs6Ku7u70qxZM+X1119Xrly5YipTu3ZtpX///sq6deuU5s2bm35Gt/6uUBRFOXv2rDJ06FBTn7Rt21ZZtWpVgXLlufe++b2dkJCgPP/880rDhg0VV1dXxdPTU2nXrp2ybNkyi65fWI9GUSrhoyMhhBCiipkyZQpTp07l6tWrZVqXRwghhBDidvH7778zaNAgtmzZQpcuXWzdnNtWSEgITZs2ZdWqVbZuiqjCZI02IYQQQgghhBDiDjZ37lzq1KlD586dbd0UIe54skabEEIIIYQQQghxB1qyZAmHDx9m9erVfPbZZxZnhxVClJ0E2oQQQgghhBBCiDvQ8OHDcXNz44knnuC5556zdXOEuCvIGm1CCCGEEEIIIYQQQliBrNEmhBBCCCGEEEIIIYQVSKBNCCGEEEIIIYQQQggrkDXaCmEwGLhy5Qru7u6yWKQQQgghLKIoCqmpqVSvXh2tVj7LrKrkPk8IIYQQZWHpvZ4E2gpx5coVgoODbd0MIYQQQtyGLl68SM2aNW3dDFEEuc8TQgghRHmUdK8ngbZCuLu7A2rneXh4WL1+vV7P+vXr6d27N/b29lav/24gfWgd0o/lJ31oHdKP5Sd9aB3l6ceUlBSCg4NN9xGiapL7vNuD9GP5SR+Wn/ShdUg/lp/0oXWUtx8tvdeTQFshjNMIPDw8KuwGzMXFBQ8PD3mTlJH0oXVIP5af9KF1SD+Wn/ShdVijH2U6orkvv/ySjz76iNjYWFq0aMGsWbNo27ZtkeVnzpzJV199xYULF/D19WXo0KFMnz4dJyenMtd5M7nPuz1IP5af9GH5SR9ah/Rj+UkfWoe1+rGkez1ZQEQIIYQQQlSIpUuXMmHCBCZPnsz+/ftp0aIFERERxMfHF1r+xx9/5M0332Ty5MkcP36c+fPns3TpUt56660y1ymEEEIIUZkk0CaEEEIIISrEjBkzeOqppxg7diyNGzdmzpw5uLi4sGDBgkLL//PPP3Tq1IkRI0YQEhJC7969GT58OLt37y5znUIIIYQQlUmmjgohhBBCCKvLyclh3759TJw40bRPq9XSs2dPduzYUegxHTt25Pvvv2f37t20bduWc+fOsWbNGh577LEy15mdnU12drbp+5SUFECdPqLX68t9nbcy1lkRdd9NpB/LT/qw/KQPrUP6sfykD62jvP1o6XESaBNCCCHuEoqikJubS15enq2bUmXp9Xrs7OzIysoqtJ/s7e3R6XQ2aNntJyEhgby8PAICAsz2BwQEcOLEiUKPGTFiBAkJCXTu3Nn0en3mmWdMU0fLUuf06dOZOnVqgf3r16/HxcWlyPZrtVq02rJN/rCzs+Ovv/4q07F3CoPBgMFgKHc9kZGRVmjN3U36sPykD61D+rH8pA+to6z9mJGRYVE5CbQJIYQQd4GcnBxiYmIsvkG4WymKQmBgIBcvXix0oVuNRkPNmjVxc3OzQevufJs3b+aDDz5g9uzZtGvXjjNnzvDiiy/y7rvv8s4775SpzokTJzJhwgTT98aMYb179y40GYJerycuLo7MzMwynU9RFLKysnBycrrrE2M4OzsTEBBQpgWn9Xo9kZGR9OrVSxb+LiPpw/KTPrQO6cfykz60jvL2o3FUfEkk0CaEEELc4QwGA1FRUeh0OqpXr46Dg8NdHwAoisFgIC0tDTc3twKjmRRF4erVq1y6dIl69erJyLYS+Pr6otPpiIuLM9sfFxdHYGBgoce88847PPbYYzz55JMANGvWjPT0dJ5++mn++9//lqlOR0dHHB0dC+y3t7cvcJNtMBg4d+4cOp2OGjVqlOm9Utxr6G6hKAo5OTlcvXqVixcvUq9evTL3RWE/J1E60oflJ31oHdKP5Sd9aB1l7UdLj5FAmxBCCHGHy8nJwWAwEBwcXOxUOaEGSXJycnBycio0MODn50d0dDR6vV4CbSVwcHAgPDycjRs3MmjQIEDt340bNzJ+/PhCj8nIyCjQ78Z+VhSlTHWWhjXeKyW9hu4Wzs7O2Nvbc/78eVN/CCGEEHcDCbQJIYQQd4m7+Z9+a5GRgKUzYcIERo8eTZs2bWjbti0zZ84kPT2dsWPHAjBq1Chq1KjB9OnTARgwYAAzZsygVatWpqmj77zzDgMGDDAF3Eqq0xrkvWId0o9CCCHuRhJoE0IIIYQQFWLYsGFcvXqVSZMmERsbS8uWLVm7dq0pmcGFCxfMgjFvv/02Go2Gt99+m8uXL+Pn58eAAQN4//33La5TCCGEEMKWJNAmhBBCCCEqzPjx44uc1rl582az7+3s7Jg8eTKTJ08uc51CCCGEELYk47mFEEIIcdcICQlh5syZtm6GELcFeb8IIYQQpSeBNiGEEEJUORqNptivKVOmlKnePXv28PTTT1u3sULYmLxfhBBCiKpDpo4KIYQQosqJiYkxbS9dupRJkyZx8uRJ0z43NzfTtqIo5OXlYWdX8m2Nn5+fdRsqRBUg7xchhBCi6pARbZUsS5/Hg1/v5N39OrL0ebZujhBCiLuUoihk5ORW+peiKBa1LzAw0PTl6emJRqMxfX/ixAnc3d35888/CQ8Px9HRkW3btnH27FkeeOABAgICcHNz45577mHDhg1m9d46FU6j0TBv3jwGDx6Mi4sLDRo0YM2aNdbsanGbK8t7JTMnr9LeK2C790u9evVYuXKltbpaCCHEXSo+NYspK4/y6Lxd/HUyvlR/A40URWHXuWskZeRUQAtLR0a0VTJHOy3HrqSSa9CQmKHH3cXJ1k0SQghxF8rU59F40rpKP++xaRG4OFjn9uPNN9/k448/pk6dOnh7e3Px4kX69evH+++/j6OjI99++y0DBgzg5MmT1KpVq8h6pk6dyocffshHH33E559/zrhx4+jduze+vr5Waae4vd0J7xWomPfLrFmzGDlyJOfPn8fHx8dqbRVCCHF3SM7U8/XfZ1m4PZrM/IFI284kcE+IN69FNKRtaMl/W3JyDaz+9wrzt0Vx5HIKr0U04PkedSu66cWSEW2VTKPR4OlsD0BSht7GrRFCCCFuX9OmTaNXr16EhYXh4+NDixYtGDduHE2bNqVevXq8++67hIWFlTjiZsyYMQwfPpy6devy/vvvk5aWxu7duyvpKoSoHBXxfvnggw/k/SKEEKLUMnPymL35DF3+t4nZm8+Sqc+jZbAXYzqG4GinZU90Ig9/vYMxC3dz5HJyoXUkpufw5V9n6PLhJl5eeogjl1NwtNNWiZmDMqLNBrxc7LmWnkNSpu2HNAohhLg7OdvrODYtwibntZY2bdqYfZ+WlsaUKVNYvXo1MTEx5ObmkpmZyYULF4qtp3nz5qZtV1dX3N3diY+Pt1o7xe2ttO8Vg8FAakoq7h7uaLVl/0zbmu8VqLj3i4eHh7xfhBBCWCQn18DSvRf5fONprqZmA1A/wI1XezegV+MANBoNz3QLY9am0yzdc5HNJ6+y+eRV+jcL4uVe9anr78aZ+DQWbI/il/2XyNIbAPB3d2RUh9qMaFcbH1cHW14iIIE2m/B2kRFtQgghbEuj0Vh1WpotuLq6mn3/6quvEhkZyccff0zdunVxdnZm6NCh5OQU/8GWvb292fcajQaDwWD19orbU2nfKwaDgVwHHS4OduUKtFmbvF+EEELY0vqjsby3+jgXrmcAUNPbmQm96vNAyxrotBpTuUBPJ94f3IynutRh5oZT/H7oCqv/jeHPIzE0q+HJoUs3Rrg1qe7BE51Dub95dRzsqs7f3Nv7Dvs25ZU/dTRRAm1CCCGE1Wzfvp0xY8YwePBgQB2xEx0dbdtGCVFFyftFCCFEZfn94GVeWnoQRQFfN0f+c29dhretVWxwLMTXlZmPtOKZ7mF8sv4UkcfiOHQpGY0GejYK4InOobQL9UGj0RRZh61IoM0GvFzUoYwyok0IIYSwnnr16vHLL78wYMAANBoN77zzjoy0EaII8n4RQghRGTYci+OVZYdQFBjWJpjJAxuXaqR4w0AP5o5qw4ELiRy+lEy3+n6E+LqWfKANVZ2xdXcRL+PU0UwJtAkhhBDWMmPGDLy9venYsSMDBgwgIiKC1q1b27pZQlRJ8n4RQghR0f45k8BzP+4n16AwuFUNpg9pVualS1rV8mZ0x5AqH2QDGdFmE16mrKOSDEEIIYQoyZgxYxgzZozp++7du6MoSoFyISEhbNq0yWzf888/b/b9rVPjCqvn/PnzeHh4lL3BQthQZb9fkpKSytxWIYQQtweDQWHhP9H4uTtyf7MgtNqSp2seuJDIk9/uJSfXQK/GAXw0tLlFx90JJNBmA8ZkCLJGmxBCCCGEEEIIIaqyPw5f4d1VxwBYsC2KyQMa06qWd5Hlj8ekMGbhHjJy8uhc15dZw1thp7t7JlTePVdahRinjibL1FEhhBBCCCGEEEJUYUt2XzRtH7yYxODZ//DKskPEp2QVKBuVkM5j83eTnKmndS0vvhkVjpO9rjKba3MSaLMBT9PUUQm0CSGEEEIIIYQQomqKTkhnx7lraDTw2/OdGBpeE4Cf91+ix8ebmb35DFn6PAAuJ2Xy6LxdJKRl0zjIg4Vj25Z5Tbbb2d13xVWAtyRDEEIIIYQQQgghRBW3dK86mq1bfT9aBnvRMtiLR9vXZsrKoxy8mMSHa0+yZPdFXupZj1mbznA5KZM6fq58+0Rb0yCju42MaLMBLxcHQJ06ajAUXFRWCCGEEEIIIYQQwpb0eQaW770EwCP31DLtbxnsxS/PduTTYS0I8HDkwvUMJiw7RFRCOjW8nPn+iXb4ujnaqtk2J4E2GzBmHTUokJIlo9qEEEIIIYQQQghRtWw8Hk9CWja+bo7c18jf7DmtVsPgVjXZ9Ep3nu8RhoOdlgAPR354sh3VvZxt1OKqQaaO2oCDnRZHrUK2QUNiht40wk0IIYQQQgghhBCiKliy5wIAQ8NrYl9E1lBXRztei2jI013CsNNpcHWUMJOMaLMR1/ypyokZObZtiBBCCCGEEEIIIcRNLidl8vepqwA8ck9wieU9XewlyJZPAm024pL/+kuSQJsQQgghhBBCCCGqkOV7L6Io0KFONUJ8XW3dnNuKBNpsxNVOTYKQmC5rtAkhhBBCCCGEEKJqyDMoLNujZht9pG3Jo9mEOQm02YircURbpgTahBBCiFtpNJpiv6ZMmVKuun/77TertVUIW5P3ixBCCGvacvoqV5Kz8HKxJ6JJoK2bc9uRCbQ24ipTR4UQQogixcTEmLaXLl3KpEmTOHnypGmfm5ubLZolRJUk7xchhLCdxPQcxizaw5WkTLQa0Go0aDB+CKJ+r9XAvQ0DeLt/I7Raja2bXKIlu9UkCINb1cDJXmfj1tx+ZESbjbhIMgQhhBC2pCiQk175X4piUfMCAwNNX56enmg0GrN9S5YsoVGjRjg5OdGwYUNmz55tOjYnJ4fx48cTFBSEk5MTtWvXZvr06QCEhIQAMHjwYDQajel7IYpUlveKPqPS3isg7xchhLClRf9Ec+hiEldTs4lLySYmOYsryVlcTsrkUmImF65nEH0tgwXbo5i9+Yytm1ui+NQsNh6PB+CRe2rZuDW3JxnRZiMuxjXaMmTqqBBCCBvQZ8AH1Sv/vG9dAYfyLaj7ww8/MGnSJL744gtatWrFgQMHeOqpp3B1dWX06NF8/vnnrFy5kmXLllGrVi0uXrzIxYvqOiN79uzB39+fhQsX0qdPH3Q6+ZRWlKCU7xUt4GWN81rhvQLyfhFCiIqUpc/j+53nAZg8oDFtQ31QFDAoCgYFlPzHfeev88GaE8yIPEWbEB/a16lmtTbkGRQWbIti86l4WtT0om/TIJrW8ECjKdvIuZ/3XSbXoNCqlhcNAt2t1s67iQTabESmjgohhBBlM3nyZD755BOGDBkCQGhoKMeOHePrr79m9OjRXLhwgXr16tG5c2c0Gg21a9c2Hevn5weAl5cXgYGy5oi488n7RQghKs6vBy5zLT2HGl7OPNa+Nna6wicNhtf25mRsGj/vv8QLPx1gzYtd8HVzLPf5z8Sn8dqKQxy4kATA9jPXmL35LDW9nenTJJC+zQJpFext8XRVRVFYukedNjpcRrOVmU0DbVu2bOGjjz5i3759xMTE8OuvvzJo0KBij9m8eTMTJkzg6NGjBAcH8/bbbzNmzBjT81OmTGHq1KlmxzRo0IATJ05UwBWUnTHQJllHhRBC2IS9izpixhbnLYf09HTOnj3LE088wVNPPWXan5ubi6enJwBjxoyhV69eNGjQgD59+nD//ffTu3fvcp1X3MVK+V4xGAykpKbi4e6OVluOVVrK+V4Beb8IIURFMhgU5m09B8DYTiFFBtmM3h3UhMOXkjgdn8bLSw+yeGzbMq/XZhzF9tH6k+TkGnB3tOPJLnU4EZvCXyfjuZSYybxtUczbFkWAhyMRTQLp2zSIdqE+xZ5zx7lrRF/LwM3Rjv7Ng8rUNmHjQFt6ejotWrTg8ccfN33KVpyoqCj69+/PM888ww8//MDGjRt58sknCQoKIiIiwlSuSZMmbNiwwfS9nV3VG7jnmj91VEa0CSGEsAmNxirT0ipbWloaAHPnzqVdu3ZmzxmntbVu3ZqoqCj+/PNPNmzYwMMPP0zPnj1ZsWJFpbdX3AFK+14xGMA+Tz2mPIE2K5D3ixBCVJy/T13l7NV03B3tGHZPcInlXRzsmD2yNQO/2M7W0wnM3nyG8ffWK/V5z11N47UVh9l3PhGArvX9+L8hzaju5QxAZk4ef5+K588jsWw8Hk9cSjbf7jjPtzvO06S6B69GNKB7fb9Cp5Yu3aMuHTCgRXVcHateHOV2YdOe69u3L3379rW4/Jw5cwgNDeWTTz4BoFGjRmzbto1PP/3ULNBmZ2dX5Ye3u5qSIciINiGEEMJSAQEBVK9enXPnzjFy5Mgiy3l4eDBs2DCGDRvG0KFD6dOnD9evX8fHxwd7e3vy8vIqsdVC2Ia8X4QQouLMzR/N9kjbYNyd7C06pl6AO+8Oasqryw+Ver02gwIL/znPJ5Gnyc414OZox9v9GzHsnmCzoJmzg44+TYPo0zSI7Nw8tp9J4M9/Y1nzbwxHr6QwduEe7gnx5rWIhrQN9TEdl5SRw59HYgEY3rbkwKEo2m0VotyxYwc9e/Y02xcREcFLL71ktu/06dNUr14dJycnOnTowPTp06lVq+j5xdnZ2WRnZ5u+T0lJAUCv16PXWz8Qptfrccnv+Ux9HmkZWThKytxSMf5cKuLnczeRfiw/6UPrkH4sv+L6UK/Xq4vxGgwYDIbKblq5GdtsfJw8eTIvvfQSHh4eREREkJ2dzd69e0lKSuLll1/m008/JTAwkFatWqHValm2bBmBgYF4eHhgMBgICQlhw4YNdOjQAUdHR7y9vU3nUvIzPRr7q7C2KIqCXq8vsDC8vH5FVTR16lReeOEFPD096dOnj+n9kpiYyIQJE5gxYwZBQUGm98vy5csJDAzEy8sLUDOPbty4kU6dOhV4vwghxN3q6JVk/jl7DZ1Ww5hOoaU6dmh4TXaeu8aKfZav13YqLpVZR3WcSz0JQOe6vvxvaHNq5I9iK4qjnY57GwZwb8MAJvZrxJy/z7L4n2j2RCfy8Nc76N7Aj1d7N6BpDU9+2X+ZnFwDjYM8aFbDs1TXJMzdVoG22NhYAgICzPYFBASQkpJCZmYmzs7OtGvXjkWLFtGgQQNiYmKYOnUqXbp04ciRI7i7F54xY/r06QXWdQNYv349Li7lXx+jMM460KJgQMPPq9bhVf51EO9KkZGRtm7CHUH6sfykD61D+rH8CutD40jvtLQ0cnJuvyULsrKyUBTF9EHYww8/jEajYdasWbz++uu4uLjQuHFjnn32WVJSUrCzs+N///sf586dQ6vV0rp1a5YuXWqaRjd16lTefvtt5s2bR1BQEIcPHy5wztTU1ELbkpOTQ2ZmJlu2bCE3N9fsuYyMDCtfuRDl9+STT+Li4sJHH33Ea6+9hqurK82aNTN9UO3u7s6HH37I6dOn0el03HPPPaxZs8a0vtwnn3zChAkTmDt3LjVq1CA6Otp2FyOEEFXE/K1RAPRrFlRisKsw0x5owqGLxa/Xps8zsP5oHN/tjGbnueuABlcHHf/t35jhbYNLnVXUx9WBt/o14vFOoXy+6TTL9lxk88mrbD55lf7Ngjgeq95nPVKGuoU5jWL86NbGNBpNickQ6tevz9ixY5k4caJp35o1a+jfvz8ZGRk4Oxd8gSclJVG7dm1mzJjBE088UWi9hY1oCw4OJiEhAQ8Pj7JfVBH0ej2RkZFMPeTM9Qw9q57vIGlzS8nYh7169cLe3rJhuqIg6cfykz60DunH8iuuD7Oysrh48SIhISE4OTnZqIW3B0VRSE1Nxd3dvdCbzKysLKKjowkODi7QlykpKfj6+pKcnFwh9w/COlJSUvD09Cz055SVlUVUVBShoaFlfq8YDAZSUlLw8PAoXzKEO0B5+lOv17NmzRr69esnfxfKSPqw/KQPreNO68fY5Cw6/28TuQaF35/vRItgrzLVczoulYFfbCdTn8erveub1muLTc7ip90X+Gn3BeJT1TiFVgPNvA3MHNONUH/r3GNEJ6Qzc8Mpfj90BWNUyMley663euLpfPv/nApT3tdicfcQN7utRrQFBgYSFxdnti8uLg4PD49Cg2ygpiOvX78+Z86cKbJeR0dHHB0LDimzt7ev0F8EXi4OXM/Qk5qj3BG/cGyhon9Gdwvpx/KTPrQO6cfyK6wP8/Ly0Gg0aLXau/4f/5IYp4sa++tWWq0WjUZTaD/La1cIIYS48y3eEU2uQaFtiE+Zg2xQcL02dyd7dp67xvpjceQZ1MiXr5sjI9oGM7R1dQ5s30RN79KPnitKiK8rMx9pxTPdw/hk/Skij8Uxsl3tOzbIVpluq0Bbhw4dWLNmjdm+yMhIOnToUOQxaWlpnD17lscee6yim1dq3i7qC1gyjwohhBBCCCGEEFVbenYuP+w8D8CTXUq3Nlthbl6vbfLKo6b9bUN9eKx9bSKaBOJgp0Wv13Og3GcrXMNAD+aOakNKlh43h9sqRFRl2fRj7bS0NA4ePMjBgwcBiIqK4uDBg1y4cAGAiRMnMmrUKFP5Z555hnPnzvH6669z4sQJZs+ezbJly3j55ZdNZV599VX+/vtvoqOj+eeffxg8eDA6nY7hw4dX6rVZwhgplsyjQgghhLhTffnll6Zpy+3atWP37t1Flu3evTsajabAV//+/U1lxowZU+D5Pn36VMalCCGEuMut2HeJlKxcQqq5cF+jgJIPsMC0B5rQvKYnrg46Hm1fi7UvdWHZuA4MaFEdB7vKC9l4ONkXWCdOlI1Nw5V79+6lR48epu8nTJgAwOjRo1m0aBExMTGmoBtAaGgoq1ev5uWXX+azzz6jZs2azJs3j4iICFOZS5cuMXz4cK5du4afnx+dO3dm586d+Pn5Vd6FWcjLxRhokxFtQgghhLjzLF26lAkTJjBnzhzatWvHzJkziYiI4OTJk/j7+xco/8svv5gl7Lh27RotWrTgoYceMivXp08fFi5caPq+sCVAhBBCCGvKMyjM36YmQXiicyg6KwWlXBzs+PW5TgBWq1PYlk0Dbd27d6e4XAyLFi0q9JgDB4oeNLlkyRJrNK1SyNRRIYQQlamK5D+6rUkfls6MGTN46qmnGDt2LABz5sxh9erVLFiwgDfffLNAeR8fH7PvlyxZgouLS4FAm6OjI4GBgRXWbvk5W4f0oxDiThJ5LI4L1zPwdLbnwfCaVq1bAmx3FpmAa0NeMnVUCCFEJTAu0l9Uhm5hOeNoK51OZ+OWVH05OTns27fPLFu8VqulZ8+e7Nixw6I65s+fzyOPPIKrq6vZ/s2bN+Pv74+3tzf33nsv7733HtWqVSu0jsKyy4OaeUyvL3gPpigKaWlpZR4lZwwuKYpiSq5xt0pLSzP1R2F9XRxj+dIeJ26QPiw/6UPruFP6ce6WswCMuKcm9hqlUq/nTulDWytvP1p6nATabMjLxQGQEW1CCCEqlk6nw8vLi/j4eABcXFzQaOST08IYDAZycnLIysoqkHXUYDBw9epVXFxcsLOTW6iSJCQkkJeXR0CA+Ro2AQEBnDhxosTjd+/ezZEjR5g/f77Z/j59+jBkyBBCQ0M5e/Ysb731Fn379mXHjh2FBkCnT5/O1KlTC+xfv349Li4uBfa7u7uTnZ1NVlYWDg4OZX6vXLt2rUzH3QkURSEnJ4eEhAQSExM5ffp0meuKjIy0YsvuTtKH5Sd9aB23cz9Gp8K+C3boNApB6adZs6bsv9fK43buw6qkrP2YkZFhUTm5S7ShG2u0SVRaCCFExTJOszMG20ThFEUhMzMTZ2fnQgMsWq2WWrVqSaCyEsyfP59mzZrRtm1bs/2PPPKIabtZs2Y0b96csLAwNm/ezH333VegnokTJ5rWAQZ1RFtwcDC9e/fGw8OjQHlFUYiPjzeNfCstRVHIysrCycnprn+d+Pn50aRJkzL1g16vJzIykl69eplG5YrSkT4sP+lD67B1P15NzWb98Xh6NfLH371so5VfXHoIiGNgyxoMH9TUug20gK378E5R3n609N5AAm025C3JEIQQQlQSjUZDUFAQ/v7+Mu2gGHq9ni1bttC1a9dCb8AcHBwKjHQThfP19UWn0xEXF2e2Py4ursT11dLT01myZAnTpk0r8Tx16tTB19eXM2fOFBpoc3R0LHQaqL29fZE32TVr1iQvL69M75WSXkN3C3t7e6tMsS7u5yQsI31YftKH1mGrfnxp+V52R11n+p8nGdWhNs90C6Oam2UBt9w8A+uPxbH2qPq37OmuYTZ9Lchr0TrK2o+WHiOBNhsyrtGWLCPahBBCVBKdTifrixVDp9ORm5uLk5OT3MiWk4ODA+Hh4WzcuJFBgwYB6vTbjRs3Mn78+GKPXb58OdnZ2Tz66KMlnufSpUtcu3aNoKAgazTbpKzvFXkNCSFE1bEn+jq7o64DkJ1rYO7WKH7YdYExHUN4umsd03JOt4pPzWLJ7ov8uOsCsSlZAHSr70ejoIIjoYW4lQTabMg4dTQpU4+iKHf99AIhhBBC3FkmTJjA6NGjadOmDW3btmXmzJmkp6ebspCOGjWKGjVqMH36dLPj5s+fz6BBgwokOEhLS2Pq1Kk8+OCDBAYGcvbsWV5//XXq1q1LREREpV2XEEKI28Psv84AMLxtML2bBDJj/Sn+vZzM7M1n+W7HeR7vHMoTXULxcLJHURR2R13nu53nWXskllyDmsylmqsDw+4JZlzXMFteiriNSKDNhowj2vIMCilZuXg6y6eeQgghhLhzDBs2jKtXrzJp0iRiY2Np2bIla9euNSVIuHDhQoGpuCdPnmTbtm2sX7++QH06nY7Dhw+zePFikpKSqF69Or179+bdd98tc5ZQIYQQd6ajV5L56+RVtBoY1zWMEF9Xutf3I/JYHDMiT3EiNpXPNp5m0T/RDGldg3/OXONkXKrp+PDa3jzWvjZ9mwXiaCezAYTlJNBmQ472OpztdWTq80jKyJFAmxBCCCHuOOPHjy9yqujmzZsL7GvQoAGKohRa3tnZmXXr1lmzeUIIIe5QX20+C8D9zasT4usKqGvW9m4SSM9GAfx5JJZPN5ziTHwaC7dHA+Bsr2NQq+o82r42Tap72qrp4jYngTYb83axJzM5j8QMPbWrlVxeCCGEEEIIIYQQRTt3NY3V/8YA8Gz3glM+tVoN/ZsH0adpIH8cusKG43GE1/ZmSOuaMgBGlJsE2mzMy8WBK8lZknlUCCGEEEIIIYSwgq//PoeiwH0N/YtNYKDTahjUqgaDWtWoxNaJO53kp7cxb9f8hAgSaBNCCCGEEEIIIcolJjmTXw5cAuC5HnVt3BpxN5JAm40Z0wknputt3BIhhBBCCCGEEOL2NndLFPo8hfZ1fAiv7W3r5oi7kATabMzbRUa0CSGEEEIIIYQQ5XUtLZufdl8A4LnuMppN2IYE2mzM2ziiLUNGtAkhhBBCCCGEEGW16J9oMvV5NKvhSZd6vrZujrhLSaDNxoxTR5MyJdAmhBBCCCGEEOLukpGTS3ZuXrnrSc3Ss+ifaACe7xGGRqMpd51ClIVkHbUxmToqhBBCCCGEEOJuoCgKlxIz2Xc+kb3nr7PvfBInY1NwsNPSrb4fEU0Cua9hAJ75/yeXxvc7L5CalUuYnyu9GwdWQOuFsIwE2mzsxtRRCbQJIYQQQgghhLiznI5L468rGtb8dJADF5OJT80uUCZLb2Dd0TjWHY3DTquhfZ1q9G4SQO/GgQR6OpV4jix9HvO3RQHwbPe6aLUymk3YjgTabMwYqZeso0IIIYQQQggh7iTL917k9Z8Poyg6IB4Ae52GJtU9aVPbm/Da3rSu7c3V1GzWH41l3dE4Tsalsu1MAtvOJDDp96O0CPaid+MAOtf1pWkNT3SFBNGW771IQlo2NbyceaBl9Uq+SiHMSaDNxowj2mTqqBBCCCGEEEKIO8XvBy/nB9mgnoeBB9o1oG0dX5rX9MTJXmdWNsDDiaY1PJnQuwHRCemsOxrL+mNx7L+QyKGLSRy6mMRH607i4WRHxzBfOtXzpXNdX0KquZBrUJjz9zkAxnWrg71OlqIXtiWBNhszrtGWnpNHTq4BBzv5pSCEEEIIIYQQ4vb1578xTFh2CEWB4ffUpJ0umv5dQ7G3L3nttRBfV8Z1C2NctzDiU7KIPB7H3yevsuPcNVKycll7NJa1R2MBqOHlTB0/Vy4nZeLr5sDDbYIr+tKEKJEE2mzMw8kerQYMijqqzd+j5PnnQgghhBBCCCFEVRR5LI7//HSAPIPCQ+E1mXJ/I9aujS5TXf4eToxsV5uR7WqTm2fg38vJbM+fVrrvfCKXkzK5nJQJwOOdQwuMlBPCFiTQZmNarQZPZ3sSM/QkZugl0CaEEEIIIYQQ4ra0+WQ8z/+wn1yDwgMtq/N/DzbHkJdrlbrtdFpa1fKmVS1vxt9bj4ycXPZEJ7Lt9FWycw2M7RhqlfMIUV4SaKsCvF0c8gNtsk6bEEIIIYQQQojbz/YzCTz93T5y8gz0axbIJw+1QKfVYMirmPO5ONjRrb4f3er7VcwJhCgjWRCsCvDKX6dNEiIIIYQQQgghhLjd7Dp3jScW7yEn10DPRgF89kgr7CQpgbhLyYi2KuBG5lG9jVsihBBCCCGEEELccDI2lezcPFwcdLg42JkejYn89p1P5PFFe8jSG+hW348vR7aSzJ/iriaBtirAKz/QliiBNiGEEEIIIYQQVYCiKLz92xF+2HWh0OfttBpcHHRk6Q3k5BnoVLcaXz8WjqOdJCQQdzcJtFUB3jJ1VAghhBBCCCFEFTJ781l+2HUBjQaCPJzI0OeRkZ1HTp4BgFyDQkqWmuigXagPc0e1kayfomIpCmg0tm5FiSTQVgV4uxpHtEmgTQghhBBCCCGEbf164BIfrTsJwNSBTRjVIcT0nD7PQEZOHhk5uaRn55FnUKgf4IbmNgiAiNvYP7Pg749g2HdQp5utW1MsmThdBXg6qyPaZOqoEEIIIYQQQghb+udMAq+vOAzAuK51zIJsAPY6LZ7O9gR5OlPX340Gge53d5DNkAd/vglHfrZ1S+5cBgPsmA3ZyfDHC6DPtHWLiiWBtirgRjIEGdEmhBBCCCGEEMI2TsamMu67fejzFO5vHsQbfRrauklVX/Q22PUV/PosJF8uWx2pcZBwxrrtupNc3gupV9TtxGjYOsOmzSmJBNqqAOMabTKiTQghhBBCCCGELcQmZzFm4W5Ss3NpG+LDxw+1QKu9i0eqWSr5ovqYlw1bPy798ZlJ8HVX+CIcfnsO0hOs2rw7wrHf1UfvEPVx+8wqHZiUNdqqAC8Z0SaEEEIIIYQQwkZSs/SMXbSHmOQswvxc+WZUuCQ2sNTNo9j2fwudXrwRELLE1o8hLVbdPvgDnFwDvaZBy0dBW0ljo9KuwuqXIeM6KIbCvwDq9oSur4O9U+W0C9QECMZAW+/3YN9iOBMJqyfAqN+rZHIEGdFWBXi7GrOO6lEUxcatEUIIIYQQQghxt9DnGXjuh/0cj0nB182RRWPbmgaD3PGMQZzlYyDuaNnqSLl0Y9uQC39/aPmx18/Bzjnq9n2TIaAZZCbCyv/Awr4Qd6xsbSqtPfPg+B9wfjtc2AEXd8GlPXB5H1w5ADGH1K+tn8DceyuvXQBX9qujBu1d1UBfv4/Azgmi/q6y6+JJoK0KMK7RlmtQSM3OtXFrhBBCCCGEEELcDRRFYeIv/7L1dALO9joWjGlDsI+LrZtVOS7shPm9YNkoOPqrGmwqC+OItvCx6uOhnyyf1hg5CQx6CLsXOr8MT2+GiA/UoNLFnfB1F7VMTnrZ2mapE6vVxw7j4eHvYNgP8MhPMHwpjFgOI3+GB74EF1+IPwrfdIedX6lJCiqacTRb/QiwdwafUOjyqrpv3VuQlVzxbSglCbRVAU72Opzs1R9FsqzTJoQQQgghhBCigmXm5PHWr0dYse8SWg18ObIVzWt62bpZFS/hNCwZCQsi1FFbRkkXylZfSn6grfFAqN9XnWa5eXrJx0VvU0eRabTQ+311CqTODjo8D+N3Q6MB6gi57Z9h93UnApIPlK19JUk8D3H/qu3o8op6HY3uh4b9oEEfqN8b6vWEVo/CczugXm91Pbq1b8L3QyAlpmLaBebTRhs/cGN/pxegWj1Ii4NN71Xc+ctIAm1VhHFUW6Ks0yaEEEIIIYQQogL9eymZ/rO28tNuNbj03qBm3NswwMatqmBp8bBqAnzZDk6sUgNLrUfD4K/V55Mulq1e44g2j5rQ4y11+8jPxU9FNRjU0VgA4WMgoLH58541Ydj36ogyz1poUi7R7txMNJf3l62NxTm5Rn2s1RFcfIov6+YPI5ZBv4/V6Zvn/oKvOsCxldZvF0DsYTXLqJ0z1Ot1Y7+dI/T/RN3eM0+d3lqFSKCtivAyBdpkRJsQQgghhBBCCOvLzTPwxabTDJ69nXNX0/F3d+Tbx9syol0tWzet4ugz1XXTPm8Fe+eDkqeOPHt2Bwz8HGq0UcslX1JHUJVGVjLkpKrbHtUhqDk0HgQo8NcHRR93eIm65pmjB/T4b9HlGvSB53diCOuJBgXN0QpYk8w4bbRhf8vKazTQ9ikYtwWCWqhryi17DH5/HrJTrds242i2ej3BwdX8uTrdoNlD6gjCVS+DIc+65y4HCbRVEd4uxoQIMqJNCCGEEEIIIYR1XbiWwbBvdvLx+lPkGhT6NQtk3Utd6Vrfz9ZNq1i/PA1/vQ85aVC9NYxZDSOWgH9D9XnPGuqjPl0NGpVGyhX10ckTHN3U7R5vqaPlTqwqfKRVTjpsnKZud30VXH2LP4eDK4bWowHQnlxV+mBgcTKuqwkQQJ0qWhp+DeCJDeracmjgwPfwdVeIPWKdtikKHP1N3W48qPAyvd9Xg5VXDsDeBdY5rxVIoK2K8MoPtCWmS6BNCCGEEEIIIYR1KIrCsj0X6fvZFvadT8TN0Y5PHmrBlyNa4+16h2cXPf4HHF8JWjsYMg+e3Aghnc3L2DuDa36wMbmU00dvnjZq5NcAmj2sbm96v+Ax2z+D1BjwDoF2z1h0GiW0O7laRzQpl607TfLUOnVEWEBTtT2lZecAPafAmFVqH1w/B/N6wqEl5W9b/DG4fhZ0juq6cIVxD4B731G3N74LqXHlP68VSKCtipCpo0IIIYQQQgghrOl6eg7jvtvH6z8fJj0nj7YhPvz5YhceDK+JRqOxdfMqVlYKrHld3e70IjR/CLRFhEA8g9XH0q7TlnIp//ga5vu7vwEaHZyJhAu7buxPvgzbP1e3e01T1xqzhL0zcR4t1O3jf5SujcU5sUp9tHTaaFFCOqtTScPuhdxM+HWcOp0zN7vsdRqnjda9D5w8ii53zxMQ1BKyk2H922U/nxVJoK2KkKmjQgghhBBCCCGsJTfPwJiFu1l/LA57nYY3+jTkp6fbE+zjYuumVY5N70LqFfCpA11fK76sZ/6ItORLpTuHaUTbLYE2nzrQaqS6/ddNWTE3TlUDUbU6QqOBpTrVFa/8teSOr7TO9NGcDDizUd0ub6ANwLUajFwB3d5Qv9+7ABb0KXuSicKyjRZGq4P7PwU08O8yOPd32c5nRRJoqyK8ZUSbEEIIIYQQQgggz6Cw8tAVBs/ezrPf70OfZyh1HYt3nOfwpWQ8nOz49blOPNs9DJ32Dh/FZnRpL+yeq27f/6k6PbQ4XvnJIEo7dTQlP9B264g2gK6vg84BoraowZ9L++DwUvW5iPfVpAKlEO/RAkXnANfOwNWTpWtnYc5tVoN+nsEQ2Lz89YEa9OrxFoxYDk5ecGW/um7bmQ2lqyf+BFw9AVp7qN+n5PI1Wqsj2wB2fFHqZlubBNqqiBtTR2VEmxBCCCHuHF9++SUhISE4OTnRrl07du/eXWTZ7t27o9FoCnz173/jk3ZFUZg0aRJBQUE4OzvTs2dPTp8+XRmXIoQQFU6fZ2DZ3ov0mvE3L/x0gAMXkvjzSCxf/nWmVPVcScrkk/VqMGZiv0Y0reFZEc2tmvL0sPIFQIEWw6FO95KPMY1oK+0abfkj4G5eo83IKxjCx6jbf70P695St1sMVwNDpZSrc0YJ7a5+Y43poyfzs4026FfqoF+J6vfOz0raEjKvw/dDYfP/wGBhwPj4SvUxrAc4e1l2zL3vqF8Pf1uWFluVBNqqiBtTR2VEmxBCCCHuDEuXLmXChAlMnjyZ/fv306JFCyIiIoiPjy+0/C+//EJMTIzp68iRI+h0Oh566CFTmQ8//JDPP/+cOXPmsGvXLlxdXYmIiCArK6uyLksIIawuS5/Hdzui6f7RZl5fcZhzCel4udgzuJU6UmrWpjMcvJhkcX1TVh4lIyePNrW9GdYmuIJaXUXt+ALij4Kzj5qV0hJlXqMtP+uoR/XCn+/yCtg5wcVdcHEn2LvAfZNKd46bGBrer24YA1FlrigPTv6pbltj2mhhvGvD4+vyg40KbP4AfnoE9JklH2vptNGbOXupWVxLGr1YCSTQVkUYR7QlZcqINiGEEELcGWbMmMFTTz3F2LFjady4MXPmzMHFxYUFCxYUWt7Hx4fAwEDTV2RkJC4uLqZAm6IozJw5k7fffpsHHniA5s2b8+2333LlyhV+++23SrwyIYSwjvTsXL7ZcpYuH/7FO78f5XJSJr5ujrzVryHb3riXTyOqMbKJI3kGhQlLD5KZk1dineuOxrL+WBx2Wg0fDGmG9m6ZLgpq1svN/6duR3ygrhtmCa/8QFtp1mhTlJumjhYyog3APRDaPnXj+04vFh2Us+SU9SLUJAuxh+F6VJnr4eIuyLimTu+s3bHs9ZTE3gkGfAYPzFYDjqfXwbJRkFtM3OPaWYg7omaKbdCv4tpWgexs3QChMo1oS5cRbUIIIYS4/eXk5LBv3z4mTpxo2qfVaunZsyc7duywqI758+fzyCOP4OrqCkBUVBSxsbH07NnTVMbT05N27dqxY8cOHnnkkQJ1ZGdnk519I+tZSkoKAHq9Hr3e+vddxjorou67ifRj+Ukfll9F9+G6o3FM+uMY1/P/BwzydOLpLiEMbV0DJ3sdxBxA+XYA0xzc2eo+k3MJ6by/+iiT729UZJ1p2blM/v0IAE92DiHUx8nmr4FKey0qCro/Xkabm4UhpCt5jR8ES8/pEog9QHo8+sxUNShUksxE7PUZAOid/Yo+V7vx2B1aCo7u5N7zjOVtuompD+090NXuiDZ6K3lHf8fQ/vlS1wWgPbYSHWCo15s8A2Co4J9N04fReNRE99MwNKfXY1jxBHmDv1GDabe27civattCupBn716m/ipKeV+Llh4ngbYqwpgMITU7F32eAXudDDYUQgghxO0rISGBvLw8AgICzPYHBARw4sSJEo/fvXs3R44cYf78+aZ9sbGxpjpurdP43K2mT5/O1KlTC+xfv349Li4Vl3kvMjKywuq+m0g/lp/0YflZuw8zc+HnaC17rqr/8/k6KfSqYaCNbxp2146wKfIIDvoUup2cjH1uJrrcTN7w3czzqd35ftdF3JKjaeRdeNbJX6O1xKZoqeaoEJZ1mjVrKnYNS9esWFpdmEuySwgnAweRY+deZNmKfi3WvP4P4ec3k6ex5y+XAaT/+aflBysK/bWO2Bmy+XvlD6Q7BZV4iEfGBXoA2XburI38q9iyurD3UDRaDBvKlxEzMjKS0NxQmrOVpJ3fs+16aOkrURTuO/YzbsDetABi1qwpV5tKw6/287Q7NxPdiZVc+voaB2o9BRrz2Ee3E9/hBRzWh3C+gtpW1tdiRkaGReUk0FZFeDjbo9Goo0+TMvT4uTvauklCCCGEEDYzf/58mjVrRtu2bctVz8SJE5kwYYLp+5SUFIKDg+nduzceHh7lbWYBer2eyMhIevXqhb29vdXrv1tIP5af9GH5VUQf7oq6zus/H+FKchZaDTzdJZT/9AjDwe6mYIMhF92PQ9Hqr6FodGiUPPo6HWJU+1F8u/MCv1x2YdXgDqbBGkZHr6SwZedOAD4cFk7Xer5WaXORFAXdTw+hTT9NtfTThKbuxtD5FQxtnlSzbearlNdixnXsvn5Z3e72Ot06jS11FbpLtSHhFN1b1UUJ7VZiec3pdXASHKqF0K9fxU5xNOvDzFYw61uqpZ+mX5fW6vTU0og/jv3BeBSdI62GvkIrB7eKaXSh+qGcbI7y81hqXd9OjZD6GPp8eCMZQ9J57A9Eo2i0NHnwDZq4Wvc1XN7XonFUfEkk0FZF6LQaPJzsSc7Uk5SRI4E2IYQQQtzWfH190el0xMXFme2Pi4sjMLD4fwrS09NZsmQJ06ZNM9tvPC4uLo6goBujDeLi4mjZsmWhdTk6OuLoWPC+yt7evkKDDxVd/91C+rH8pA/Lzxp9mKXP4+N1J5m3TV1Xq5aPCzMebkGbEJ+ChddOhvPbwMENzSM/wHdD0F7axX/7adl+1pWzV9OZsuoEX45ojSY/QJFnUJj0x3EMCtzfPIj7Gpc8IqvcTq2HqM1qUM23Ppq4I+g2TEK3fxH0elddZP+mbJYV+lr8a5q65phfI3SdX0JnV4bzeNWChFPYpV0BS9qZro6k1ngFV9p7zN7eHnuXWlDzHri0B/uz6+CeJ0tXyZl1AGjCemDv6l0BrSxB0wfA8DX88hS6/QvRObmprxeNBk6pI9g0IZ2x96q413BZX4uWHiPzE6sQ4zptiZJ5VAghhBC3OQcHB8LDw9m4caNpn8FgYOPGjXTo0KHYY5cvX052djaPPvqo2f7Q0FACAwPN6kxJSWHXrl0l1imEELZy5HIyA7/YZgqyDW8bzJ8vdik8yHZ4Gez8Ut0e9BXU6Q71+wDgePgHZg5rhZ1Ww5p/Y/nt4GXTYd/tiObwpWTcneyYdH/jir4kyNPD+v+q2+3GwbgtMHAWuPqrCQmWjoTFAyDmcMW3JWoLHPwe0MDAz8HOocRDCmVMaGBpQoTk/P73qFG285VHowHq4/E/Sn/siVXqY0VlG7VE84fUJAkA/8yCvz9Ut8uSbbQKkkBbFWLMPJqYIZlHhRBCCHH7mzBhAnPnzmXx4sUcP36cZ599lvT0dMaOVaf0jBo1yixZgtH8+fMZNGgQ1aqZZ4vTaDS89NJLvPfee6xcuZJ///2XUaNGUb16dQYNGlQZlySEEBbLMyh8+dcZBs/ezqm4NHzdHJk/ug3ThzTH1bGQyWUxh2DlC+p2l1eh8UB1O3y0+njoJ5oFOvFSz3oATMrPUhqbnMXH608B8Hqfhvh7WLCQf3ntWwQJp8ClGnR9DbQ6aD0KXtgPXV4BnSNEb4Wvu6Jb9SIOesum3JVaVgqs/I+63eZxCC7HcgOe+ZlHky5aVj7lSv5xNgy0RW2FjOuWH5d8CWIOAhpTANdmwkdDxHR1e/MHsO6/cHkvoIGGA2zatPKSqaNViCnzqATahBBCCHEHGDZsGFevXmXSpEnExsbSsmVL1q5da0pmcOHCBbRa8899T548ybZt21i/fn2hdb7++uukp6fz9NNPk5SUROfOnVm7di1OTpXwj6UQQlgoJjmTl5YcZFeUGgSJaBLAB4ObUc2tiCWC0q/BkkchNxPq9oIeb914rm5PddRUymU4/gfPdBvCxhPxHLiQxKvLDuHpbE9adi4tg70Y2bZWxV9cZiL89YG63eMtcPK88ZyjO9w3CVqPhg1T4OgvaA/9QDuXnUDBzNDltuY1SIwGz1rQc3L56jIG2pItDbTZcESbTx0IaAZx/8KptdByhGXHncxPEBHcDtz8K659lurwHOjTYdN7sOMLdV/tjuAeUPxxVZyMaKtCvE0j2mTqqBBCCCHuDOPHj+f8+fNkZ2eza9cu2rVrZ3pu8+bNLFq0yKx8gwYNUBSFXr16FVqfRqNh2rRpxMbGkpWVxYYNG6hfv35FXoIQQhROUeDKQcjLNdu9/mgsfT/byq6o67g66PhoaHPmPBpedJAtLxdWjIXkC+AdCg/OVUeIGWl10Cp/Kv3+xdjptHz6cEuc7XXsOHeNtUdj0Wk1TB/SDK1WU/g5rGnLx5B5HfwaQusxhZfxrg0PLYTH16Fo7fHJOAtXT1q3HYeXweElatbKB+eaB/zKwquUgTbjFFNbBNqgbNNHq8K00Vt1eRU6v3zj+9t82ihIoK1KkamjQgghhBBCCHGb2DUHvukG22cCasKDyb8f4env9pGUoadZDU9WvdCFh9oEm5IWFGrjVIj6G+xd4JEfwLmQBepbPQpo1PXIrp8jxNeVd25ai+3JzqE0CrJ+JuUCrp2FXV+r273fB10Jk+RqtUep0x0A7fHfrNeO61GwKj+jdLc3oFb78tdpWqPtMhgMxZdVFNtOHYUbgbYzGyE7reTymYkQvU3drkqBNo0G7psM3d6EkC7Q/GFbt6jcJNBWhRinjibLiDYhhBBCCCGEqNr2LVYfT63lTHwqg77czuId5wF4qksoPz/bkVBf1+LrOPIz/PO5uv3AlxDQpPByXrWg7n3q9v5vATWpwqgOtbmvoT8v5q/bVuEiJ4FBr05nrdfTokMMjQYBoD3+uxqgKq88Pfz8JOSkQq0O6ogoa3Cvro6OM+ghLa74sukJkJcNaNTjbMG/EfiEqe04E1ly+dORYMhVRyJWC6v49pWGRgM9JsKYVYUHmm8zEmirQrxcZUSbEEIIIYQQQlR5cUfh6nEA8i4f4MFZmzgRm4qvmwOLxt7Df/s3xsGuhH+3U2Ph9/HqdqcXoemQ4su3zk+KcOAHyNOrU+kfaMr8Mffg4lAJy69HbVWnHmp00Ps9iw9T6vclT2OHJuEUxB8rfzv+/p+6aL6jJwz5puRRdZbS2d0ImpWUeTQl/3k3/7JnOS0vjebGqLZjK0suf2K1+liVRrPdoSTQVoUYR7TJGm1CCCGEEEIIUXXlHV5h2tYpudTLPUOXer6sebEL3RtYuMj86UjQZ6iL2t87qeTyDfqCqz+kx6sL4FcmQx6sy0/QED5GHU1lKScP4j2aq9tHfy1fO6K3qWvEAQyYqY70sybTOm0Xii9nnDZqq/XZjBrlZ6Y9vR70WUWX02fBmQ3qtgTaKpwE2qoQYzIEyToqhBBCCCGEEFVHlj6Pneeu8fnG0zw6dyeXt/0AQIriAsCrjZJYPLYt/u6lyIB8frv6WL+3ZaOydPY3skvuW1SK1lvBoZ8g9jA4ephnRLXQZa+26saRX8o+fTQzEX55GlCg5aMljwAsC2Pm0aQSEiIk52cctdX6bEbVW6nBvpw0OLe58DI56bD7G7WMe3UIalWpTbwbVcL4UmEpT2cZ0SaEEEIIIYQQVUFCWjarL2j5bt5uDl9KISdPXSC/heYMtRzjyMCRv3we5oHERbS3Ow2lzfhpDLTV7mj5Ma1HqckXzmyEpAvWH9FVmOw02Piuut31VXD1LXUVcZ6tUOyc0Fw/C7H/QlDz0lWgKPDHi5ByWV2XrO//St0Gi5gSIlg4ddTWI9q0Wmh4P+z+Ws0+2qCPuj8nXR3ldvRXOLUecjPV/Q37q8eICiU9XIV4u94Y0aZYY5FIIYQQQgghhBCllpiew4h5e1h/Wcve80nk5Bnwc3fk/uZB/F/9UwA4Nx3AA0MeVQ+4uKt0I7WSLqqBMo0OgttZfly1MDUzIwoc+N7y48pj+2eQFgveIdDumTJVkatzRgnLT55w9JfSV7D/Wzj2O2jtYeh8cHQrUztKZJo6auGINlsH2uDGOm0nV6uBtWWj4aO6sHyM2me5meBVGzq9VKbRiKL0ZERbFWJco02fp5Cek4ebo/x4hBBCCCGEEKIyZenzePLbvURdy8DbQeG1fk3oUNefkGouaBQDzFDXutI0fRCCWoCdE2Reh4TT4FffspMYR7NVbwmO7qVrYPgYiN6qBtq6vQFaXemOv9m1s7BvoboGm0arfml1+ds6dcH9f2apZXtNAzvHMp/K0HgQ2pOr1GDQfZPVui1x9RSsfVPdvu8ddbpkRTFOHS1xRFsVmToKauZVl2qQcU0Nrhl51YYmg6HJIAhqaXl/i3KTSI4tKAZcsgumC3a21+FgpyUn10Bieo4E2oQQQgghhBCiEuUZFF5eepB95xPxcLLjmQZZPBReE3t7dVAE0f+oo7ucPKHufWrGyeqt4cI/6qi20gbaancqfSMb3g/OPmqw58wGqB9R+jqM1rwGZzeWXK5WxxsL75eRUrcX2LtAYjRcOQA1Wpd8kCEPfnlKTRoR2g06/KdcbShRaddo86hZse2xhM4OWj2qjjyU4FqVIJGcypZ8GbtvutMjMxkldwQYf2EDGo0Gbxd74lKyScrQE+xjw3YKIYQQQgghxF3m/dXH+fNILA46LbNHtOTa8Z3mBY78rD42GnBjdFetdvmBtp3Q+jHLThRdjkCbvRO0GA47v4R9i8seaEu/dmMB/fbPgdYOFMONL0Oe+qizh/bPlj9o4+CqtvXor+r0UUsCbfsWQsxBNbA5+OuKX1/MuEZbdjJkJavnvZUhD1Lzs45WhRFtoI4QbPcsuAdKcK0KkEBbZfOoDhoNdoZsci/uhPo9zZ72dnEgLiWbRMk8KoQQQgghhBCVZt7WcyzYHgXAxw+3oF2oD2uO31QgT6+ueQXQdOiN/cY11i7ssuxEqbFw/SyggVrty9bY8NFqoO3UWrU+98DS13FiFSh5ENgM+kwvWztKq8mQ/EDbb9Dr3eKDQhnXYdN76naPt8EjqOLb5+gGzt5qhtPkS4UH2tKvgiFXnV7rVoZ+rwhaXeX0j7CITZMhbNmyhQEDBlC9enU0Gg2//fZbicds3ryZ1q1b4+joSN26dVm0aFGBMl9++SUhISE4OTnRrl07du/ebf3Gl5VGg1LnPnXzTGSBp73y12lLypTMo0IIIYQQQghRGdb8G8P7+VG1iX0bMrBF9YKFzm1W12Jz9ctPSJDPGGi7dlodJVaS6G3qY2AzcPYqW4P9GkBwezVQVtakCEd/VR8bDyrb8WVRrxc4uKnJBi7tLb7spvfUgJd/E2jzeOW0D0rOPGqcNuoepE7bFOIWNg20paen06JFC7788kuLykdFRdG/f3969OjBwYMHeemll3jyySdZt26dqczSpUuZMGECkydPZv/+/bRo0YKIiAji4+Mr6jJKzVBXDbRpC5kL7+1yI/OoEEIIIYQQQoiKtSf6Oi8tPYiiwKgOtXm6a53CCxqnjTYeZB5gcfEB3/y12S5ZMMjj/D/qY1mmjd4sfLT6uP9bMBhKd2z6NYjaom43GVy+dpSGvTM06KtuGwN9hYk5rE4bBej3YeUGtDxrqY9JFwp/PiU/AOdRSDBWCGw8dbRv37707dvX4vJz5swhNDSUTz75BIBGjRqxbds2Pv30UyIi1HnpM2bM4KmnnmLs2LGmY1avXs2CBQt48803C603Ozub7Oxs0/cpKSkA6PV69HrrjyzT1+yEFi3aa6fRXz0LXrVMz3k4qT+ShNSsCjn3ncLYN9JH5SP9WH7Sh9Yh/Vh+0ofWUZ5+lL4XQoiqQ1EUXl1+mP0XEmlS3YOWwV60DPaiSXVPnB1uZOk8E5/Gk4v3kpNroFfjACYPaIKmsOmM+kw4vkrdbja04PPB7SDhFFzYeSOQVBRjIoSQcgbaGg+CP9+EpPNwbhPU7VniISYn/sifNtocqoWVrx2l1WQw/LtcDbT1fq/gumuKAn++oa4P12QIhHSu3PaZRrQVkRDBlAihiqzPJqqc22qc444dO+jZ0/yXR0REBC+99BIAOTk57Nu3j4kTJ5qe12q19OzZkx07dhRZ7/Tp05k6dWqB/evXr8fFxcU6jb9FJ9d6+Kaf5NjvnxHtd59p/7UYLaDl4LHTrMk8WSHnvpNERhacfitKT/qx/KQPrUP6sfykD62jLP2YkZFRAS0RQog7VE4G/PW+GiwKvsfq1X+/6wLpB3+htyaOrxPuZ9XhGAB0Wg0NAtxpEexFsxqezN58huRMPS2Dvfj8kVbotEWsGXY6EnJS1SyTNdsWfL5WezjwnZp5tDjpCXD1RP4xHctxhYCDC7QcDrvmwO55pQu0GUeTNRlUvjaURd2e4OihJhS4tLvgOnX/rlCTS9i7QO93K799XvmZR4uaOpqSH2jzrAIZR0WVdFsF2mJjYwkICDDbFxAQQEpKCpmZmSQmJpKXl1domRMnThRZ78SJE5kwYYLp+5SUFIKDg+nduzceHh7WvQjUT7yjY//AN/0kzZxjadyvn+m5mO3RbLh8Ci//GvTr18zq575T6PV6IiMj6dWr141U26LUpB/LT/rQOqQfy0/60DrK04/GEfFCCCEssHcB7PgCzmyE53eWXL4ULlzLYPqaY+y0/xoPTSah7QeyMdGfgxeTuJqazbGYFI7FpPBTfvmQai7MH93GbKRbAUdWqI9NhxSe+dK4Ttvl/ZCbfSMj6a2M00b9G4NrtTJdn5l7nlQDbafWQmI0eIeUfEx6wo1po5W5PpuRnSM07A+HfoIjv5gH2rLTIPIddbvLBNsEszzzA21JRY1oM04dlRFtonC3VaCtojg6OuLoWPAXob29fYX9sxLn0ZzGMcvRRm9FS56aohnwcVMfk7Ny5R8lC1Tkz+huIv1YftKH1iH9WH7Sh9ZRln6UfhdCiFI4+af6ePU4JJwG33pWqdZgUHhtxSFcc67h4ZQJwCPVr/LIgH4oikJsShaHLiZx8GIyBy8mkqU3MHNYS6q5FREYA8hOhVP564I3fbDwMtXqgks1yLimri9W1Cg947TR2uUczWbkWw/q9IBzf6nBy17TSj7m+B/qtMygFpU/bdSoyWA10HbsdzXjqTY/yLn1Y0iNUQOGHf5jm7Z5ljSi7Up+OQm0icLZNBlCaQUGBhIXF2e2Ly4uDg8PD5ydnfH19UWn0xVaJjCwiqTdzZfiXAvFLQD0Geqw2HySDEEIIYQQQghxR8u4DhduWtrn2O9Wq3rRP9HsirpOQ4erN3bGHARAo9EQ5OlMn6ZBvNm3IUue7sBvz3cixNe12Do1p9dCbhb4hKnBqUILaW6MartYzAi9aGOgrZzrs92s7dPq4/5v1bXkSmKLbKO3qtMDnDwhLfbGa+HaWdiRnygxYrppMEqlM04dTY2B3EL+LzdOHfWQqaOicLdVoK1Dhw5s3GieqTMyMpIOHToA4ODgQHh4uFkZg8HAxo0bTWWqDI0GpU7+2mynN5h2e7uon4YnZsiCykIIIYQQQog70OlIdSF+8tdDs1Kg7dzVND5cpy4Z9Ezzm6aBxhwqV73ao7+oG82GqgG1ohgDbReKCLRlJkLcEXXbmoG2+hFqpszMRHUqZnHSrkL0VnXbFuuzGdk5QMMB6raxzWsnQl6OuoZbSQklKpKLL+gcAUVdR+5meblqAA5kRJsokk0DbWlpaRw8eJCDBw8CEBUVxcGDB7lwQU2jO3HiREaNGmUq/8wzz3Du3Dlef/11Tpw4wezZs1m2bBkvv/yyqcyECROYO3cuixcv5vjx4zz77LOkp6ebspBWJQbjYpVnbiy47JU/oi1RRrQJIYQQQggh7kQn16iP4WNAo4PYw3A9qlxV5hkUXl1+iCy9gc51fenonXzjydgjkFe2gQz2uWlozv2lflPUtFEj41pjF3epmTNvdWEnoKjTTN0DCj5fVlodtMn/f3f3N4Wf2+iEcdpoS/CpY702lEXTwerj8ZVwYg2cXgdae+jzf8UHNCuaVntjbbhb12lLi1X7T2sHrv6V3zZxW7BpoG3v3r20atWKVq1aAWqQrFWrVkyaNAmAmJgYU9ANIDQ0lNWrVxMZGUmLFi345JNPmDdvHhEREaYyw4YN4+OPP2bSpEm0bNmSgwcPsnbt2gIJEqoCJbSb+ocl4ZS6cCU3RrSlZuWSm2ewYeuEEEIIIYQQwspyc9QECACtHoWQzur28ZXlqnbe1nPsv5CEu6Md/xvaHM31czeezMu+kemzlKon7UFjyIWAZuDXoPjCQS1B5wDpVyGxkMBh9Db10Zqj2Yxaj1JHYcUchMv7ii5nyjY62PptKK3QbuDso/bXL/nTX9s/a7X1+srFGGi7dZ225Pxpo+7VC0+KIQQ2DrR1794dRVEKfC1atAiARYsWsXnz5gLHHDhwgOzsbM6ePcuYMWMK1Dt+/HjOnz9PdnY2u3btol27dhV/MWXh5HljePFpdVSbp/ONhZSTM2X6qBBCCCGEEOIOcn4b5KSqo4Gqt4bGD6j7yzF99HRcKp9EngLgnfsbU8PLGYyBNm1+/r8rB8tUd43EXepG0yElF7Z3UoNtABd2FXzemAjBGFy0JlffG23cPbfwMmlXbwT7bDlt1EhnD43yp4/mpIJbAHR9zbZtMjKu05Z8y4i2lPzAm0wbFcWQEKyt1TNOH1XXabPTafFwUv8YyDptQgghhBBCiDuKMdtogz7qiKBGAwCNOgor6UKxhxYmN8/AK8sPkZNroEcDPx5qU1OdOmmcilqnu/qYnxChVFJj8U07rm5bEmgDqFVEQoTs1BtrxVkr4+it7nlKfTz6C6QnFHz++Ep12mP1VmpWz6rg5n7tNQ2cPGzXlpt5FhFoM45o85BAmyiaBNpsrV5v9TFqC+izAAjwULOrrDp8paijhBBCCCGEEOL2oig3Bdr6qY9u/jcCT8f/yC+mEJucxeaT8eyNvk5qVtEDEL7afJbDl5LxcLLj/x5sjkajUZMCZOev0WbMrFmGEW3aEyvRoGCo0cbywFRw/jptt45ou7BLDXJ51b4xLdHaaoarowTzcmD/4oLPV6Vpo0YhXaDpUGj1GDQfZuvW3GAMtN26RltK/v/oMqJNFMPO1g246wU0BfcgNXPJhX8g7F6e7R7GhGWH+HzjadqFVqNDWDVbt1IIIYQQQgghyifuqDpCyM5JXZ8LNYnBteAI/M9v5+L2JUw82oZjMSlcTzdPDhfs40zDQA8aBbrTKMiDhkEepGfn8vmm0wBMfaCJacCCadqoe3Wo1SH/3EfUjJE6y/8F1pxeB4DS6AHLrzG4rfp49ThkJoGzl/r9+fwpmxUxbfRmbZ+C356FvQuh44s3rjct/sbU1caluJ6KptXB0Pm2bkVBpjXaipg66lFBwVJxR5BAm61pNFD3PjjwvbpOW9i9DGldk3/OXmPFvku8uOQAa17sgq+bo61bKoQQQgghhBBllz+aTanTnT9PJrNw+0H+vZyMp96HXU4QnHaY0wmnuI4PWg2E+rqSnp1HbEoWF69ncvF6JpHH4gpU27txAINa3jTCyBho86mjfjm4q2uAJZyEgCaWtTU3G83F3QAY6vRAZ+k1uvmr57x+Di7tgXq91P3R+UGuikiEcLMmQ2Ddf9UA0am10Oh+db9p2mjrqjNttCozrdF2SR2JacyCapw6KiPaRDEk0FYV1O11I9DWZzoA0x5owsGLSZyJT2PCskMsGnMPWq0NUxwLIYQQQgghRDkoJ9egAWZerMtnh/eb9msd/Dhh35iG+mN82foy9h0G0CDQHSd7NbyVmJ7DidhUjsekcCI2hROxqZyMTSU714CvmyPvD26mThk1MgXaQtV14IKaq6O5rhy0PNB2eR+a3Eyy7DzQ+ZaQbfRWwe3VNlzYqQbacjLgSv71VtT6bEb2TmoG0u0zYc/cG4G2o7+pj1Vp2mhVZlyDLTdLXe/OzU/9PkXWaBMlk0BbVRDWAzQ6uHYaEqPBOwQXBzu+HNGaB77cxpZTV5mz5SzPda9r65YKIYQQQgghRKkYDAqb9x7i3vxg04+JjXF3suOJzqEMbFGdkGquaHeegfX/pU3GNgh+0+x4b1cHOoSZL6mTZ1A4fy0dbxcHvF0dzE9oTITgU0d9DGqpBtpiDkKrkZY1OmorANfcGuKvKeWAh1rt4NCPcDF/nbZLu8GQqwZnKmM0WZvHYftncG4zXD0FTp5Vc9poVWbnCG6BkBarjg5084PcHHUKLkigTRRLkiFUBU6eUCt/0czTkabdDQLdmTpQ/cTlk/Wn2BN93RatE0IIIYQQQohSMxgU/vw3hn6fb2X9798BcEipx4j77mHbG/fyUs/61PFzU2fuNB6oHnR++41gRjF0Wg11/NwKBtnAfEQbQPWW6mNpEiJEq4G2BLdGlh9jZEyIcHkf5OnNp42WNmhXFt61oX4fdXvPvBvTRmuEq88Jy3jdknk09QqggM4RXH1t1ixR9Umgraqo21N9PLPBbPfDbYJ5oGV18gwKL/x0gMRbFgUVQgghhBBCiEqXnQbR28BgKPBUapaen3ZfoN/nW3n2h/2ciE2lj506mq1B14d4uVd9PJ3tzQ/yqqWuH6YY4MSq8rXt5jXaQB3RBhD7r5oQoST6LMhfny3BvQyBNt/66mAKfYZ6zvP/qPsretrozdo+pT4e+gkO/qhuy7TR0jElRMhPgGDMOOpRvXICpuK2JYG2qsK4SOa5v9Vf7Pk0Gg3vD25GHV9XYpKzeHX5IRRFsVEjhRBCCCGEEHe9pIswtwcs6g+R7wDq6LUdZ68xYdlB7nl/AxN/+ZcTsam4OdoxoVsNutkfA8Cp6f1F12sc1XZsZdnblpUCGQnqtnf+iLZqdcHBDXIz1eV6SnJpN+Rlo7j6k+YYVPo2aLUQ3E7djtqiJkWAis84erM6PcAnDLJTbqwPJ9NGS8czf0RbUv6INlMiBMk4KoongbaqIqApuAepv/yN8+fzuTnaMWtEKxzstGw8Ec+8rVE2aqQQQgghhBDirhZ/HOb3hoRT6vc7vuC3Fd/T/ePNDJ+7k1/2XyZLb6CuvxsT+zZk2xs9eCH0MprcLHXUmn/joutulB9oi9oCGWVcNicx/38lVz9w8lC3tVoIbK5uWzJ9NH99NiWkc9lHLhkDbbvnQl42uPqrAb/KotXeGNUGUKON2v/Ccp63TB1NyR/ZJuuziRJIoK2q0GiKnD4K0KS6J+/cr/5R+t/aExy4kFiZrRNCCCGEEELc7S7shAURkHqFdI8w/nHpAUD7f98m5Xocbo52DG9bi1+f60jky10Z1y0MLxcHOPmnenyDfsUHrqqFQWAzUPLgxOqytdE4bdQ4ms0oqIX6GHOw5Dry12cz1C7HCDTjGtzG4ExIJa3PdrMWw8HeRd2WaaOld+sabaYRbRJoE8WTQFtVYpw+elNChJs92q4W/ZsFkWtQGP/jAZIz9JXYOCGEEEIIIcRd6+SfKN8+AFnJnLBvRMf4N3j8+ijOGoII1CSyOnQ5e966j+lDmtGqljcaY1DJYIBTa9Vt4wL9xWmUP73x2O9la+et67MZWZoQIScDLu0FQClPoK16a9Da3fi+dqey11VWzl4Q8T7Ui7A826q4ocAabfmBNhnRJkoggbaqpE539ZfxtdM3UlLfRKPRMP3BZtTyceFyUibv/H6k8tsohBBCCCGEuLvs/w5lyUg0uVlszGvFoNTXybLzYGTnhrgMXwhaO2rEbMD56E8Fj728D9KvgqOHZcEm4zpi5zZDZlLp21pUoM2UEOEwGPKKPv7iTjDo1WDKraPiSsPB5cZ0VbBNoA2gzeMwchk4e9vm/Lcz49TRjGuQk34j4CZrtIkSSKCtKnHyvDGXv5DpowAeTvZ89khLdFoNKw9d4feDlyuxgUIIIYQQpfPll18SEhKCk5MT7dq1Y/fu3cWWT0pK4vnnnycoKAhHR0fq16/PmjVrTM9PmTIFjUZj9tWwYcOKvgwh7k6KwuU/3oOV49EoeSzP7cp/DK8wrEN9trzeg3fub0xQow5w79tq+T/fgGtnzes4mf/+rdsT7BxKPqdfffBrpAa7jCPhSsM4YOHWQJtvPbB3VTOBXjtT9PH567MR0qX8Uz2N00edfcBPfk/ddpw8wcFd3U6+dNOItuq2a5O4LUigraopYfooQKta3ozvoS6k+c5vR4hJzqyMlgkhhBBClMrSpUuZMGECkydPZv/+/bRo0YKIiAji4+MLLZ+Tk0OvXr2Ijo5mxYoVnDx5krlz51Kjhvk0nSZNmhATE2P62rZtW2VcjhB3lTNxyUTOGEONfR8B8HXeQA60fp8Nr/Vk6gNNCfBwulG44wtQuzPo0+GXpyDvpiVujMGyBv0sP3njckwfLSrQptWp679B8dNH89dnI7RL6c99K+M1NxqgJicQtxeN5sY6bdfOqCPbQKaOihLJu72qqZsfaIvaAvqsIouNv7cuLWp6kpKVy6vLD2EwKJXUQCGEEEIIy8yYMYOnnnqKsWPH0rhxY+bMmYOLiwsLFiwotPyCBQu4fv06v/32G506dSIkJIRu3brRokULs3J2dnYEBgaavnx9fSvjcoS4axy5nMyOr56lV+pvAPweOJ5+L3/NB0OaU93LueABWh0MngOOnupU0b8/VPdfj4L4Y6DRQb2eljegcX720TMbITvV8uNyMiD1irrtU8i0T+M6bUUlRMhOhcv71e0QKwTaQrvACweh74flr0vYhnGa6MVd6qO9i0zDFSWyK7mIqFQBTdQIecpl2P8ttHu60GL2Oi0zhrWk/+db2X7mGot3RDO2UznWEBBCCCGEsKKcnBz27dvHxIkTTfu0Wi09e/Zkx44dhR6zcuVKOnTowPPPP8/vv/+On58fI0aM4I033kCn05nKnT59murVq+Pk5ESHDh2YPn06tWrVKrTO7OxssrOzTd+npKQAoNfr0eutn1jKWGdF1H03kX4sv7L24dErKUxYuIG1ylrQQGyPGfTrOKrkulwD0fT7GLtfn0LZ+jF5Id3QxBxEBxhqtSfPzg0sbYt3Pex8wtBcP0vu8TUoTYZYdtzVM9gDipMnuYWcT+PfFDvAcHk/eYW0RXNuG3ZKHopnLXLdqlvndeieH6i5i1/Lt/P7WeteQ30Nn9+BFlA8qpObm1vp7bid+7AqKW8/WnqcBNqqGo0GukyA1a/AxmnqMGOPoEKLhvm58d/+jXnntyP8358n6FzXl3oB7pXcYCGEEEKIghISEsjLyyMgIMBsf0BAACdOnCj0mHPnzrFp0yZGjhzJmjVrOHPmDM899xx6vZ7JkycD0K5dOxYtWkSDBg2IiYlh6tSpdOnShSNHjuDuXvA+aPr06UydOrXA/vXr1+Pi4mKFKy1cZGTRy4AIy0k/ll9p+vBiGsw+puNJ1uNgn0eCcxi7knzhpnUSi+dIa+9OBCduJ3vJaLLtPPEBjubW5pzFdaga2TemPmeJ3zyXPeedSj4ACEzaRzsgSevDlj//LPC8e2YK9wKGywdZs3oVaMwneDW+vIR6wAVdbQ7e1F55HVrH7diP9WLTaAwo+SMdr+Y4sqOUr2Vruh37sCoqaz9mZGRYVE4CbVVR+ONw8Ce4vBfWTYSHFhVZ9NF2tdhwLI6/T13lpaUH+fW5TjjYyYxgIYQQQtx+DAYD/v7+fPPNN+h0OsLDw7l8+TIfffSRKdDWt29fU/nmzZvTrl07ateuzbJly3jiiScK1Dlx4kQmTJhg+j4lJYXg4GB69+6Nh4eH1a9Br9cTGRlJr169sLe3t3r9dwvpx/IrbR8euZzCO4v2os/LYqzLRjCAV8Tr9GtSirXVALK7oMzthmvyBVxzEgBo+MDLNCxlBk/NlSBY+AdBGcfp1ydCnZ5aAu3OKIgCz5CW9OtXSLsNuSgfvYtdbib92jVQEyTcRLdgBgA1Og+nerN+8jq0ktu5HzVHM+G35egUdRSbb2iLwl9bFex27sOqpLz9aBwVXxIJtFVFWi3c/yl80x2O/gotHy1yTQONRsNHQ5vTe+YWjl5J4bONp3gtQjLaCCGEEMK2fH190el0xMXFme2Pi4sjMDCw0GOCgoKwt7c3mybaqFEjYmNjycnJwcGhYMZCLy8v6tevz5kzhWcRdHR0xNHRscB+e3v7Cv1npaLrv1tIP5afJX3476VkRi/aS0pWLi/6H8E7JRHcArBrOgTsStn/9j7w4FxY2BcUA/g2wN6/fukbHhwOjp5ospOxv3Ycqrcq+Zjk8wBoq4WhLfSa7dWECJd2Y3/1KAQ1vvFUVjLEHgbALqw73HS8vA6t47bsx1vW+tN6Bxfx2qoct2UfVkFl7UdLj5GhT1VVUHNo/6y6vXqCurBnEfw9nJg+WM2g89Xms+yNvl4ZLRRCCCGEKJKDgwPh4eFs3LjRtM9gMLBx40Y6dOhQ6DGdOnXizJkzGAwG075Tp04RFBRUaJANIC0tjbNnzxIUVPhSG0KI4v17KZmR83aSkpVLeG1vXnDbpD7R5gmwK/x9V6Ja7aF7/vqMLR4pWx1anVoPwPl/LDvm+jn18daMozcrKiHC+X/UwKBPHfCUrJIinzEZgpFHddu0Q9xWJNBWlXWfCB41Iek8bPmo2KJ9mwXxYOuaGBSYsOwQadmVv0CjEEIIIcTNJkyYwNy5c1m8eDHHjx/n2WefJT09nbFjxwIwatQos2QJzz77LNevX+fFF1/k1KlTrF69mg8++IDnn3/eVObVV1/l77//Jjo6mn/++YfBgwej0+kYPnx4pV+fEFWaoqiBo2LcGmT7ro8O3ZW9oLWHNmPLd/5ur8NL/0Knl8peR0gn9TF6u2XlLQm0BbVUH68cNN8fvS3/nFbINiruHO6BoL1pIqBHzaLLCpFPAm1VmaMb9MtPBf3P5xB/vNjikwc2poaXMxeuZ/DuH8eKLnj+H5h7HxxfZcXGCiGEEEKYGzZsGB9//DGTJk2iZcuWHDx4kLVr15oSJFy4cIGYmBhT+eDgYNatW8eePXto3rw5L7zwAi+++CJvvvmmqcylS5cYPnw4DRo04OGHH6ZatWrs3LkTPz+/Sr8+Iaqsi3uw+6ot3U5OgZy0QovcGmRb/HhbXA7MV59s+iC4+Ze/HV611GVxyqp2fqDtwj9gKD5oSG4OJF9St4sNtLVQH2MOmdcZtUV9DO1atraKO5NWZz6KTUY7CgvIGm1VXcP+0KAfnFwDqybAmNVF/rHycLLnk4dbMHzuTpbuvUiX+r7c3/yWoa3nd8D3Q0GfDnvnQ6P7K+EihBBCCHG3Gj9+POPHjy/0uc2bNxfY16FDB3bu3FlkfUuWLLFW04S4bcWlZDHxl38J83Pl9T4Nsdfl/3+gKLBnHqydiMagxwvI2zQNBnxqdvzOc9d4avFeUrNvBNnccq7BkV/UAu2ertTrKVJQC7B3hcxEuHoCAhoXXTbpgjqCz961+CChX0Owc4KcVHUEnG9dyLgOsf+qz4d0tu41iNufZy319QXgIYE2UTIZ0XY76Puh+gfjwj9w8Idii7avU42nu6qf4ExYdoid567dePLibvghP8gGcPVURbVYCCGEEEIIUQHiU7IYPncnm07EM3drFGMW7iY5U6+u6fzrM7DmVTDoMeSPBtPtWwDnNpuOX380llELdpOanUvbUB81yOZoB/sWgUEPNe+BGuG2ubhb6ewhuK26fb6E6aOmaaOhoNEUU6cdBDRVt43rtJ3/B1DAt746VVCImxnXaXP0ACfrZ6sWdx4JtN0OvIKhR/76JZHvQHpCscVfj2hI78YB5OQaeGrxXo7HpMClvfDdEHXoeHD+oqIplyC78KHkQgghhBBCiKrlamo2I+bt4tzVdAI9nHB10LH9zDXGf/kzOd/0hMNLQKOD3u+RN/I3onzvVQ/8fTxkpbBsz0We+X4fObkGejYK4FtjkC03B/YuUMu2e8Z2F1gY4/TR0gTaSnJrQoToreqjrM8mCuMVrD7KaDZhIQm03S7aPQsBzdRh05GTii2q02r4fHgr2ob4kJqdy//N+xHDt4PV4dEhXeCxX8E1fx2TBBnVJoQQQgghRFV3LS2bkfN2ciY+jSBPJ5aOa8+yZzowxO0IX6S+jEPCUfROvjDqd+j4H9BoOFr9ERSv2pB8keOLX+D1nw9jUOCh8JrMebQ1TvY6tfLjKyEtFtwCoNFA217orW5OiKAoRZezJBGC0a0JEaLyA22hEmgThTC+piwJ4gqBBNpuHzo7uP9TQKNOHzVmxSmCk72OuaPb0M83ns9yp6HNSUFfox0MXwIOLuqwaJBAmxBCCCGEEFXc9fQcRs7bxam4NAI8HPnpqfbU9namycnZzMj9AE9NBvsNdbkvbSp/ptU1HZenc0Lf/zMAGsX8SjftIcZ1q8OHQ5tjp7vpX8Fdc9THNk+AnUNlXlrJqrcGnSOkx8O1s0WXS4xSHy0JtJlGtB2GtKsQf1T9Xka0icI0HgT3TYL7Jtu6JeI2IYG220nwPTfSbK96Wc2Uk5dbZHHP5BN8kTsVL006+wz1eCzrNTI0TuqTEmgTQgghhBCiykvKyOHRebs4EZuKn7saZAvxsoefHoG//w8AfevHmRP6ORdyvXn2h/18/fdZFEUhzwBv7PdiQW4fAL50X8jE7kFobl7D7PI+uLQHtPY3/teoSuydoGYbdft8MYMNjCPavC0YdeTXUA3eZSfDwe/Vff6NwdW3fG0VdyYHF+jyCvg3tHVLxG1CAm23m/smq9M+E07B113h/2rBovthw1Q4+Sek5yc/iDsG3z6ANiuRrIBWvKB7m52Xc3juh/3o8wzg10Atd/Wk7a5FCCGEEEIIUaTkDD2Pzt/FsZgUfN3UIFsdPzfYOx9Or1OzZw6ag/3AT/lqdEfGdAwBYPqfJ3hn5THmn9Ly64ErfGJ4hFTX2rhlx8PaieYn2fWN+tj0weKzddqSaZ22fwp/Pi8XEs+r25aMaNPZQ0ATdXvX1+qjjGYTQliJBNpuN85eMHwphN2nZj3Rp6uLd26boX6q9VEd+Lw1LOoPGdegeiucxvzGrLHdcLLXsvnkVd78+V8UGdEmhBBCCCFElZWSpWfUgl0cuZxCNVcHfnqqHXX93SA7FbZ8pBbqMx1aDgfUdZqnDGzC5AGN0Wpg6d7LHE3U4min5bNHO+I+bC6ggUM/qh/QA6TFw5Gf1e12T1f+RVqqdkf1sahAW8olNWOqztHyBeuN00dTY9RHWZ9NCGElEmi7HdUMh8d+gTfOw3M7YcDn0PLRG9NBr5+FzOsQ2Bwe/QWcvWhdy5vZI1uj02r4ef8lvjqSv/Dp9XOQp7fdtQghhBBCCCHMpGTpGb1gN4cuJePj6sCPT7WnXoC7+uQ/X6gfqPuEQavHChw7tlMo3zzWBheH/2fvvuObLLcAjv+SNN17D7ooo+xN2YiylelAVEBUnFwH14UDFAeuizhQXIiCKE5ciAxF2btsCm0ppXvRTdu0yf3jbVpKBx1p09Lz/Xz6SfLmfZ88eSjQnJ7nHA02GgMr7+zDyM5eEBAGg+YqJ/36CORnwIGVSoCqTT/w69N0b7Cu/PuD2gKyzpdnrl0qo7Q+m0sQqGv5EdfYEAEAVXnWnBBCNJCFuScgGkCtBs9OylefWcqx/AylzkLGWeh+M9i4lJ1+bagXr03txhPfH+GN3bnMsbNBW3JROdejg5nehBBCCCGEEMIoNaeQWSv2ciIxG2dbLavvDqOjd2mQLTcVdr2v3L/ueWULZBVGdvZi63+HsmXzZvoGln8eYMSzcPpPZVfL7/Pg3C7leNj9jfiOTMDSDnx7KbXkzu0El8CKz9el46iRMaMNwKsr2Lo2eJpCCAGS0Xb1sXWF9qOU1O9LgmxGN/f15/HRHQAVp0t8lINpUqdNCCGEEEIIczufkc/Ny3eW1WRbc88AOvs6lp/w75tQlKsEnTpPrnEsF1tLbC9Pq9DawOTloFLD8Z8gNwnsvaDTRJO/F5Mr2z5aRUOEskBbLRohGHl0Ak1ph1XZNiqEMCEJtLVC9w8PIcTDjogSX+WANEQQQgghhBDCZHILi9l8IpmLRSW1viYiKYcbP9xJTHo+/q42/PDAwIpBtoyzsH+Fcn/kC3Bp59C6aNMHBj9a/rjv3WBhWb+xmlLgEOW2qjptxq2jdclos7BUtswCtBvZsLkJIcQlZOtoK2ShUTNvVEeOr/UFDRQmncLK3JMSQgghhBDiKpBbWMytH+/iWHw2Hg5WPHxtO6b1C8DSovochwPnMpj9+T6yC4rp6OXAl3f3x8vRuuJJWxcr9dTajoC21zRsktc8rTRUu3AO+s5u2FhNJSBMycTLiIbsRHD0KX+uPhltAFOWQ8pJaHed6eYphGj1JKOtlRrX1RudSzsAMmKOmnk2QgghhBBCtHxFxXoeWH2AY/HZgFJv7fmfjzNyyT/8dCiOEr2h0jV/R6Rw+6d7yC4opk+gC9/eN7BykC3pGBz5Vrk/cmHDJ2phBbM3wLwTYO/Z8PGagrUTeHdT7p/bUX5cr4cLMcr9umS0ATgHQIcxJpmeEEIYSaCtlVKrVYwcptQicMw7S1LmRTPPSAghhBBCiGbiQgzEH6zTJXq9gSe+P8y2M2nYWmr44YGBLJrUBXd7K2Iz8nls7WHGv7ONTSeSMRiUgNvP4fHM+WI/BTo913T0YNXd/XGyraLBwZYXAQN0maLUZzMFjUW1zRSaLWNn0Eu3j+YmQfFFUGnAyd888xJCiEtIoK0V69+7L8VosFMV8uWfO658gRBCCCGuakFBQSxatIjY2FhzT0UI8zAY4MBKWBYGn46E9KhaX7r4j5P8HJ6AhVrFB7f3pk+gKzMHBvHvk9fwxJiOOFhbEJGcw5wv93Pjhzt5fcMpHl0bTrHewKSevnwysy+2llVU9onZAWc2gtoCrn3edO+1JSpriHDJZxfjtlHngJYXOBRCXJUk0NaKqSws0TkFAXDiyH5i0/PNOyEhhBBCmNWjjz7Kjz/+SNu2bRk1ahTffPMNhYWF5p6WEE2jMBd+ug9+fQSKC8BQAid/qdWln/wbzSfblIL8b9zUnWs6lm/HtLW04KER7dj+5LU8cE0I1lo1B2Mz+XBrFAYDzBoYyNu39ESrqeKjmcEAm19Q7veeCW4hDX2XLVtAaaAt9RTkpSn3y+qz1XHbqBBCNBIJtLVyNj6dAAgmjqWbT5t5NkIIIYQwp0cffZTw8HD27t1Lp06d+M9//oOPjw9z587l4MG6baMTokVJOQmfjIAja5UtiEFKiRVOrb/ipesOxfPK+pMAzB8XytTebao8z8lWy1NjQ/n3iRHMGBCIs62Wx0d34IWJXVCrq+kgGrEe4vaChQ0Mf6peb+2qYucGHsrnl7Lto/XpOCqEEI1IAm2tnXsHAEJUCfwUHs/p5BwzT0gIIYQQ5ta7d2/effddEhISWLhwIZ9++in9+vWjZ8+erFixoqy+lBBXhfA18PEISDsNDj5w528w5SPlubh9kJtS7aX/nk7l8e8OA3DX4GDuHXblYI+nozUvTe5K+ILRzL22PSpVNUE2fQlsWaTcH/AAOHjX6W1dtYIuq9MmGW1CiGZGAm2tnUdHAPrbp2EwwP82Rph5QkIIIYQwN51Ox7fffsvEiRP573//S9++ffn000+58cYbeeaZZ7j99tvNPUUhGq4oH35+CNY9oBTTD7kW7tum1AFz8gOfnoABIv6o8vKjcVk8sPoAxXoDE3r48tz1naoPmtXH4a+VLZLWzjD4EdON29JdXqetLNAWbJ75CCHEZaqotilaldKMtraqeFQq+PN4MofPZ9LD39m88xJCCCFEkzt48CCff/45X3/9NWq1mpkzZ/L2228TGhpads6UKVPo16+fGWcphAmknYFvZ0LKCVCp4ZpnYOh/QX1JHkLo9ZAYjiFiPdmdbyO3sJicAh25BcWk5xXx7E9HySsqYXA7N966uXv12z/rQ1cAfy9W7g/9L9g4m27sls7YeTTpKFzMlK2jQohmRwJtrV1poM3iYhq3d3dg9eEc3toYwaq7w8w8MSGEEEI0tX79+jFq1Cg+/PBDJk+ejFZbuYNfcHAwt956qxlmJ4QJFObAtiWwaxmUFIKdJ9z0GQQPKzvlYOwFPvk3mpwYN1YDhRFbGPDiL1zEutJwXXwdWX5HH6wsNKad5/EfITsOHP2g/xzTjt3SOXiDawhkRMGp36EoB1CBc6C5ZyaEEIAE2oSVvfIfeHY8c7vq+eaoim1n0tgVlc7AEDdzz04IIYQQTSg6OprAwJo/rNrZ2fH555830YyEMBF9CRxaBX+9DHmpyrG2I5RabA5eGAwGtkak8uE/Uew9m1F6kRfnLT3wV6cyVH2UraowHKwtcLC2wN7agrbu9jx3QyccrCsHpBvs5G/Kbe+ZoLUx/fgtXeAgJdB2aJXy2KkNaCsHQoUQwhwk0CaUrLbseLx1sdzavxerd8fy1sYIvr9/oGnrTAghhBCiWUtJSSEpKYmwsIqZ7Xv27EGj0dC3b18zzUyIBoj6G/58FlKOK49dQ2D0S9BxPDq9gd8OxfHRP9GcSlKagmk1Kib39GNaP3+cDk2Cw5/yYd8kNFPHNc18i/IgaotyP/SGpnnNliZoiBJki92lPHYJMut0hBDiUtIMQZQ1RCA1gv9c2x4rCzUHzl1ga0SqeeclhBBCiCb10EMPcf78+UrH4+Pjeeihh8wwIyEaIDUCvroFVk1WgmzWzjD2NXhwN/ltx7ByZwzXvLmVx9Ye5lRSDnaWGuYMDebfJ0fw5s096BvkimPPSQBoIjcqWXFNIeovKC5QtkJ6dWma12xpjA0RjKQ+mxCiGZGMNlFWp42003g5WjNrUBAf/xvNh1ujGBHqad65CSGEEKLJnDhxgt69e1c63qtXL06cOGGGGQlRD3o9bHoedn8IhhJQW0C/OVwc9Dj/nNex/rvjbDmZTF6REjhzt7dk9uBg7ggLxMn2sm2gAQOVAF1+OpzfUznA0xiM20ZDbwDZXVI15wBw8oes0l8MSKBNCNGMSKBNlAfaUiMAmDEgkI//jeZA7AVyCnSNU3dCCCGEEM2OlZUVycnJtG1b8UNrYmIiFhbyY6NoISLWw673AShuP5Z/Ah/mh3PW/P3Wfi7qyrPSAlxtuXdYW27q0wZrbTXNDDRaaD8ajn6rFN5v7EBbiQ5Ob1Dud5JtozUKHAxHvlHuS6BNCNGMyE9MonzraGYs6C7i72pLgKstsRn57D2bwXWdvMw7PyGEEEI0idGjRzN//nx+/vlnnJycAMjMzOSZZ55h1KhRZp6dEOUy84tIzSmkQKenoLiEAl2Jcl9XQt/ty/EBNjndyEMnb6boaGbZdW1cbBjfzYexXb3p2cYZtboWGWOh45VAW8R6GP1y42aZndsJBZlg6wb+YVc8vVULHCSBNiFEsySBNgF2HkpKfEEmpEeCdzcGt3Mjdm8+OyLTJdAmhBBCtBJvvfUWw4YNIzAwkF69egEQHh6Ol5cXq1atMvPshACDwcBn28/y2h+nKNYbKj3vSxrbrbaDCl5JGUSRQU+Qmy3ju/kwrqsPXf0c697sq91I0FhCRjSknS7/JXVjOFW6bbTjOFBXk2UnFEFDlFuVWpohCCGaFQm0CeW3ch4dlboTqRHg3Y1BIe58vfc8O6PSzD07IYQQQjQRPz8/jhw5wldffcXhw4exsbFh9uzZTJ8+Ha1WSkkI89KV6Fnw83G+3hsLgJONFhutBmutGmutBiuthhkXf0eda+CUdU8mDh7GuK7ehHo71D24dikrBwgeBpGble2jjRVoMxiU8QFCJzTOa1xN3EJgzGKwtAUre3PPRgghykigTSjcOyiBtrTTAAwKcQPgVFIOabmFuNtbmXN2QgghhGgidnZ23HvvveaehhAVZF3U8dBXB9kemYZKBc+O78TdQ4IrBtBKimHpPQCEXv8fQrt1MN0EOo5XAm0R62HoPNONe6mEQ5AdD1o7aHtN47zG1Wbgg+aegRBCVCKBNqG4rCGCm70Vod4OnErKYVdUOhN6+JpxckIIIYRoSidOnCA2NpaioqIKxydOnGimGYlW5ew2NJtfxMN6ODCec+l53LVyH1Gpedhaanjn1l6M6lxFaZPITZCTADau0MnEGWEdx8Pv8yBuP+Qkg0MjlFYxZrO1Hwlaa9OPL4QQoknUK9B2/vx5VCoVbdq0AWDv3r2sWbOGzp07y29AWypjCnzambJDg0LcOZWUw86oNAm0CSGEEK1AdHQ0U6ZM4ejRo6hUKgwGpQaWMWuopKSkpsuFaLi4/bBmGmpdHj21URyMmsUD30WQkVeEt6M1n87qS1c/p6qvPfCFctvzNrAw8W4MRx/w7Q0JB+H0H9DnzprPTzoGJ9bBgAfB1rV2r1G2bVS6jQohREumrs9Ft912G3///TcASUlJjBo1ir179/Lss8+yaNEik05QNBFjRlt6JOiVH6IHt1O2j+6ITDfXrIQQQgjRhB555BGCg4NJSUnB1taW48eP8++//9K3b1+2bt1q7umJq13yCVh9I+jyALDVZfDvV6+QkVdENz8nfp47uPogW1Y8nPlTud97VuPML3S8cntqfc3nJR2DlePh3zfht8dqN3Z6FKSeBLUFtJcOv0II0ZLVK9B27Ngx+vfvD8C3335L165d2blzJ1999RUrV6405fxEU3EOAAtrKCmECzEA9A92RaNWEZuRz/mMfPPOTwghhBCNbteuXSxatAh3d3fUajVqtZohQ4awePFiHn74YXNPT7QU+RkQvRX0+tpfkxENqyZDQSYGv35sDH4KgPvVP3NjqBVr7xuAl2MN2ykPrQaDHgIHg4cJa7NdqmNpoC16KxTlVX1OehSsmgIFWcrjE+sgZvuVxzZ2Gw0aCjYuDZ2pEEIIM6pXoE2n02FlpaRjb968uaxeR2hoKImJiaabnWg6ag24tVPulzZEcLDW0qON8lvDXVGS1SaEEEJc7UpKSnBwcADA3d2dhIQEAAIDA4mIiDDn1ERLcfECfHItfDkJVoyBlFNXviY7Ab6cDLnJFLiGcmfRE9x3shtH9UE4qC7ylscGbC1rqHijL4GDXyr3r7SlsyE8O4NzoPKL6ai/Kj+fFa+8j7wU8O4G3acpxzc8XbZjpFonSwNtodebdMpCCCGaXr0CbV26dGH58uVs27aNTZs2MXbsWAASEhJwc3Mz6QRFEzJuHy0NtAEMbucOwI6oNHPMSAghhBBNqGvXrhw+fBiAsLAw3njjDXbs2MGiRYto27ZtvcZctmwZQUFBWFtbExYWxt69e2s8PzMzk4ceeggfHx+srKzo0KED69dX3KpX1zFFE9GXwA/3wIWzyuO4vbB8CGx9DYoLq74mP0PJAMs8R7qlH8MSH+af88XYWGrZ7TkdANWBzyvUEa4k6i/IjgNrZ+jUiA07VKryQNjl20fz0pSMvKxY5ZfXd/wEY14FaydIOgqHVlU/bk4SxO1T7kugTQghWrx6Bdpef/11PvroI6655hqmT59Ojx49APjll1/KtpSKFsjYECG1PNA2KEQJtO2MSi8riCyEEEKIq9Nzzz2HvnS736JFizh79ixDhw5l/fr1vPvuu3Ueb+3atcybN4+FCxdy8OBBevTowZgxY0hJSany/KKiIkaNGkVMTAzff/89ERERfPLJJ/j5+dV7TNGE/noZIjeDhQ1MXwsdxoJeB1sXw0fD4PxlAdGCbAyrp0LqKZJxZVLOk6QYnLmhuw8bHh6Mp38n9O1Gg74YNr9Q/eseWKnc9ryt8bt1GrePnt4AJcXK/YIsWD1V+WW1YxuYsQ7sPcDOHa6Zr5yz5aXy7aSXi/gDMIBfH3CUBmRCCNHS1avr6DXXXENaWhrZ2dm4uJTXELj33nuxtbU12eREEyvLaCvfGtI70BkrCzWpOYWcScmlg5eDmSYnhBBCiMY2ZsyYsvvt2rXj1KlTZGRk4OLiUtZ5tC6WLFnCnDlzmD17NgDLly/n999/Z8WKFTz99NOVzl+xYgUZGRns3LkTrVYLQFBQUIPGFE3k+DrYvkS5P+l96DgWOoyB4z/C+ich9RR8Nhr6z4HrFoDagtyVN2OfdIgMgz23Fc3HxiOYNZO6MCjEHZ1OxyGg5NqFqKM2KzXMzu2EwEEVXzc7sTRQReM1QbhUwEClhtrFDDi/B/x6w9fTIfEw2LrDzHXg7F9+fr97YP8KJQj3zxsw5pXKY56SbaNCCHE1qVeg7eLFixgMhrIg27lz5/jpp5/o1KlThR/QRAtzaUabwQAqFVYWGvoFubI9Mo0dkWkSaBNCCCGuUjqdDhsbG8LDw+natWvZcVdX13qNV1RUxIEDB5g/f37ZMbVazciRI9m1a1eV1/zyyy8MHDiQhx56iJ9//hkPDw9uu+02nnrqKTQaTb3GLCwspLCwfNtidnZ22fvV6XT1em81MY7ZGGM3WyknsVj3ICqgJOxB9KGTwPj+O04E/yFotixEfeRr2PsxJSd/45zek7Z54eQYbLjf8Aw3jxnBzAEBaDXqCn82Oue2qHvOQHPoC/R/PkvJnX8qWzhLqQ98icZQgr5NGCUuIeWv24g07UahPvotJcd+QrVtCepzOzBYOVA8/VtwCqo0B9XIl7D4ZhqGPcsp7nE7uLUvf7IwB4vof1ABunbjTDr/Vvm9aGKyhqYh69hwsoam0dB1rO119Qq0TZo0ialTp3L//feTmZlJWFgYWq2WtLQ0lixZwgMPPFDrsZYtW8abb75JUlISPXr04L333qt2+6lOp2Px4sV88cUXxMfH07FjR15//fWyGnEAL7zwAi+++GKF6zp27MipU7UoxNrauYaASg2FWZCbDA7eAAxq58b2yDR2RqUze3CwmScphBBCiMag1WoJCAigpOQKRdtrKS0tjZKSEry8vCoc9/LyqvbnsujoaP766y9uv/121q9fT2RkJA8++CA6nY6FCxfWa8zFixdX+tkQYOPGjY26E2PTpk2NNnZzoi3OY1jEQrS6PFLtO7OrsB+Gy2rqAaAZh0eIP91jP8c+J4G2JFBg0PKG7TxuaNsGp6wTbPrzRKXLNm3ahJWuDyPV32CRcJADaxaS4DJAedKgZ+SJj7EDwtU9OF/V6zYCn1wv+gOa/Z8AUKyyZFfAw2QcjAPiqrwmzLEH3tmHSV9zP3tC/lt23O/CbvrqdeRY+fDX3jNADbXo6qm1fC82JllD05B1bDhZQ9Oo7zrm5+fX6rx6BdoOHjzI22+/DcD333+Pl5cXhw4d4ocffmDBggW1DrQZa2wsX76csLAwli5dypgxY4iIiMDT07PS+c899xyrV6/mk08+ITQ0lD///JMpU6awc+dOevXqVXZely5d2Lx5c/mbtKjX22x9tNZKJ6ULZ5X09tJA2+AQdyCC3dHpFJfosdDUq7SfEEIIIZq5Z599lmeeeYZVq1bVO5OtIfR6PZ6ennz88cdoNBr69OlDfHw8b775JgsXLqzXmPPnz2fevHllj7Ozs/H392f06NE4OjqaaupldDodmzZtYtSoUWXbX69a+hI0396OuigFg5M/znf9xDjb6hujXSwaw31fDGBowgpGWxzi4jULWTBkapXnXr6OKtcE+Pc1+l74jeJpz4KFFarov7EIT8Ng7US3W5+nm9amsd5pRUXDMCz5GFVJIQa1Bdz8JQPajaz5mvQOGD4egnf2Ya7vaIUh5DoAND/9CIBtn1sYP2K8SafZqr4XG4msoWnIOjacrKFpNHQdjVnxV1KvCFR+fn5Z6/eNGzcydepU1Go1AwYM4Ny5c7Uep641NlatWsWzzz7L+PHKf0IPPPAAmzdv5n//+x+rV68uf1MWFnh7e9fnrQmPjkqgLTUCgocB0NXPCUdrC7ILijmWkE1Pf2fzzlEIIYQQjeL9998nMjISX19fAgMDsbOzq/D8wYMHaz2Wu7s7Go2G5OTkCseTk5Or/TnNx8cHrVaLRqMpO9apUyeSkpIoKiqq15hWVlZYWVlVOq7Vahv1w0pjj98sbFkMUUrzA9Wta9A6Vf/zd1Gxnv+sPcSO2AKOWM9kyJwP6OrndMWXKFvHIQ/DwZWosmLRHloJg+ZCuNLJU9V9Glpb0wdNq5+UC3SdCsd+QDVlORadxl35Gu9OEHY/7Hofi83PQ/vrwKCHyC0AaDpPRNNI3y+t4nuxkckamoasY8PJGppGfdexttfUK9DWrl071q1bx5QpU/jzzz957LHHAEhJSan1bwbrW2PD2rpiJyEbGxu2b99e4diZM2fw9fXF2tqagQMHsnjxYgICAqqdi9TuKKd2bYcGKEk5hf6S+YUFu7LpZArbIpLp4m1X/QBNpDmvYUsi69hwsoamIevYcLKGptGQdbwa1n7y5MkmG8vS0pI+ffqwZcuWsnH1ej1btmxh7ty5VV4zePBg1qxZg16vR61WMuhPnz6Nj48PlpaWAHUeUzSSEz/Dtv8p9ye+Bz7dqz21RG/gsbXh/HM6FRuths/v7FerIFsFlnZw7XPwy1z49w1oPwoiSreK9rmzfu+hISZ9AONeB+s6vI/hT8Lhb5SdI/s+Bbd2UJQD9t7g27vx5iqEEKJJ1SvQtmDBAm677TYee+wxrr32WgYOHAgo2W2XbuGsSX1qbIwZM4YlS5YwbNgwQkJC2LJlCz/++GOFWiJhYWGsXLmSjh07kpiYyIsvvsjQoUM5duxYWRbe5aR2R7mA9Iv0AjJO7WRnSXmdC8eLKkDDr/tOE5DXfOrdNcc1bIlkHRtO1tA0ZB0bTtbQNOqzjrWt29Gc1Xd7ZnXmzZvHrFmz6Nu3L/3792fp0qXk5eWV7WaYOXMmfn5+LF68GFB2K7z//vs88sgj/Oc//+HMmTO8+uqrPPzww7UeUzSBlJPwU2mpmIFzofvN1Z6q1xuY/+MRfj+aiKVGzUcz+tA3qJ7bknveBrs/hJTj8OVk0BdDm37g1aV+4zWEWl23IBso51/3PPz6CGxdXLZ7hNDrlfGEEEJcFeoVaLvpppsYMmQIiYmJ9OjRo+z4ddddx5QpU0w2ucu98847zJkzh9DQUFQqFSEhIcyePZsVK1aUnTNuXHnqdvfu3QkLCyMwMJBvv/2Wu+++u8pxpXZHOVWcB3zxGe6qC2VbdAHap+Tyw3s7OZdnwXWjRmCl1dQwSuNrzmvYksg6NpysoWnIOjacrKFpNGQda1u3ozWZNm0aqampLFiwgKSkJHr27MmGDRvKftEaGxtblrkG4O/vX7Zbonv37vj5+fHII4/w1FNP1XpM0QR+vBd0eUqgaGTlX1YbGQwGXv79JN/uj0Otgnen92RYB4/6v65aA6MXweobISdBOWaObLaG6DVDyWZLOgonf1WOhV5v3jkJIYQwqXp3CfD29sbb25u4OKWzTps2bartFlqV+tTY8PDwYN26dRQUFJCeno6vry9PP/00bdu2rfZ1nJ2d6dChA5GRkdWeI7U7LuHdGQBVTiLakotgrQQaO/k64+lgRUpOIUcScxkU4m7OWZZplmvYAsk6NpysoWnIOjacrKFp1Gcdr4Z1V6vVqFSqap+vT0fSuXPnVrutc+vWrZWODRw4kN27d9d7TNHIMs9D0hFQaeDGz0BT/ceJpZvPsGLHWQDeuKkHY7v6NPz1242EtiMg+m+wcoQujfdL/kah1sDY12Fl6S+0rZwgaKh55ySEEMKk6pWjrNfrWbRoEU5OTgQGBhIYGIizszMvvfQSer2+VmNcWrfj0nG3bNlSthW1OtbW1vj5+VFcXMwPP/zApEmTqj03NzeXqKgofHxM8B97a2DjDPalvxFOK28vrlKpGBSidJHaGZluhokJIYQQorH99NNP/Pjjj2Vfa9eu5emnn8bHx4ePP/7Y3NMTzcHZf5Rbv95g71ntaZ9ui+adLcrPki9O7MJNfdqYbg7jXgePUBj+lFK7raUJGgydJyv3O4wBC0uzTkcIIYRp1Suj7dlnn+Wzzz7jtddeY/DgwQBs376dF154gYKCAl555ZVajVPXuh179uwhPj6enj17Eh8fzwsvvIBer+fJJ58sG/Pxxx9nwoQJBAYGkpCQwMKFC9FoNEyfPr0+b7V1cu8AucmQFgFt+pQdHtTOnXXhCeyISuNxOppxgkIIIYRoDFX98vKmm26iS5curF27ttoyHKIViS4NtAUPr/aU7/af5+XfTwLw+OgOzBoUZNo5eHSEh/aYdsymNuEd8O0FPW4190yEEEKYWL0CbV988QWffvopEydOLDtmrKPx4IMP1jrQVte6HQUFBTz33HNER0djb2/P+PHjWbVqFc7OzmXnxMXFMX36dNLT0/Hw8GDIkCHs3r0bD48G1INobdw7QMw2SI0A3UW4cA4yohmdfZoCi+0EJSWjfzcPdYexMPZVc89WCCGEEI1swIAB3HvvveaehjA3g6E8o61t1YG2Y/FZPPvTMQDuG9aWh0a0a6rZtSw2zjDkUXPPQgghRCOoV6AtIyOD0NDQSsdDQ0PJyMio01h1qdsxfPhwTpw4UeN433zzTZ1eX1TBozRbbdcy2LG07LAzMNP4HZMB7P4Ahj0OtvXsHCWEEEKIZu/ixYu8++67+Pn5mXsqwtxSI5RdDxbW0KZybebsAh0PrTlIUYmekZ28eHpcaI01/4QQQoirUb0CbT169OD999/n3XffrXD8/fffp3v37iaZmDAj/zDlVq9Tbq0cwTUYXIL5O9WBPxKsedp+Pa6F8XBuJ3S6wXxzFUIIIYTJuLi4VAiMGAwGcnJysLW1ZfXq1WacmWgWjNlsAQNAa13hKYPBwPwfjnIuPR8/Zxveurm7BNmEEEK0SvUKtL3xxhtcf/31bN68uaxxwa5duzh//jzr16836QSFGfj2hHv/gRKdEmCzdYPSH5TyjiTw7ZpDDDXEM4F4ZYupBNqEEEKIq8Lbb79dITiiVqvx8PAgLCwMFxcXM85MNAs11Gdbvfscvx9NxEKt4v3beuFsKwX+hRBCtE71CrQNHz6c06dPs2zZMk6dOgXA1KlTuffee3n55ZcZOlRaVLd4vj2rPDywrdJ59I/cdkywBGK2N92chBBCCNGo7rzzTnNPQTRXJcXlP/ddVp/tWHwWL/2mND94elwovQIkKCuEEKL1qlegDcDX17dS04PDhw/z2WefSfv3q5ibvRWdfBzZk9hJOZB8DPLSwc7NvBMTQgghRIN9/vnn2Nvbc/PNN1c4/t1335Gfn8+sWbPMNDNhdomHoTALrJ3Ap2fZ4ewCHQ9+VV6X7e4hweaboxBCCNEMqK98ihAVDQ5xIx0nkqxKf5A6t8O8ExJCCCGESSxevBh3d/dKxz09PXn1Vek03qqd3arcBg0FtQZQ6rI9/cMRYjOkLpsQQghhJIE2UWeD2yk/gG8vLs1qi9lmxtkIIYQQwlRiY2MJDq6ckRQYGEhsbKwZZiSajSrqs63afY71R5OkLpsQQghxCQm0iToLa+uKk42WzRc7KAekTpsQQghxVfD09OTIkSOVjh8+fBg3NykT0WrpCuD8HuV+aX22o3FZvCx12YQQQohK6lSjberUqTU+n5mZ2ZC5iBbC1tKCuwYHs3JzunIg5QTkpYFd5a0mQgghhGg5pk+fzsMPP4yDgwPDhg0D4J9//uGRRx7h1ltvNfPshNmc3wPFBWDvDe4dyC7Q8dAaqcsmhBBCVKVOgTYnJ6crPj9z5swGTUi0DHcODuLTbdGc1AfQSR2rZLV1mWzuaQkhhBCiAV566SViYmK47rrrsLBQfkzU6/XMnDlTarS1ZmdLt422HQ4qFc+vOyZ12YQQQohq1CnQ9vnnnzfWPEQL42Sj5c7BQez+txOd1LEYzm5DJYE2IYQQokWztLRk7dq1vPzyy4SHh2NjY0O3bt0IDAw099SEOV1Sn+1sWh4/hyegUsF7UpdNCCGEqKROgTYhLnXX4GAWbO/GbP4k7/Tf2Jt7QkIIIYQwifbt29O+fXtzT0M0BwVZkHBQud92OKu3nQPgmg4e9Ja6bEIIIUQl0gxB1JuLnSVt+41Cb1Bhnx2FISfZ3FMqZzBA3AEoyjf3TIQQQogW48Ybb+T111+vdPyNN97g5ptvNsOMhNnF7ACDHlxDyLfx5tv95wGYOSjIvPMSQgghmikJtIkGmTGiF6dQtpOc3P2HmWdziaPfw6fXwt+vmHsmQgghRIvx77//Mn78+ErHx40bx7///muGGQmzu6Q+28/hCeQUFBPoZsvw9h7mnZcQQgjRTEmgTTSIu70V2V5hAJw/+CcGg8HMMyp15k/lNma7eechhBBCtCC5ublYWlauuaXVasnOzjbDjITZldZnMwQP54udMQDMGBCIWi0NEIQQQoiqSKBNNFjoQOU33+3yDrErOt3Msyl1fo9ymxoB+hLzzkUIIYRoIbp168batWsrHf/mm2/o3LmzGWYkzConGVJPAioOabpxKikHa62am/v4m3tmQgghRLMlzRBEgzmHDkf/s4oQdSJvbdzDoAeuN++EshMhM1a5X3wRLsSAW4hZpySEEEK0BM8//zxTp04lKiqKa6+9FoAtW7awZs0avv/+ezPPTphMehTYuoGNc83nnS3dLuzdjc8PKRmNk3r44WSrbdz5CSGEEC2YZLSJhrNxodizGwDa8zvZF5Nh3vnE7a34OOWkeeYhhBBCtDATJkxg3bp1REZG8uCDD/Lf//6X+Ph4/vrrL9q1a2fu6QlTyE6AZf3hgwGQeb7mc89uBSDPbwh/HE0EYMbAwEaeoBBCCNGySaBNmIRlyDAABqiP8+6WM+adzHkJtAkhhBD1df3117Njxw7y8vKIjo7mlltu4fHHH6dHjx7mnpowhdRToC+GnET46ia4eKHq8wwGiFYy2jYVhFKsN9An0IWufk5NOFkhhBCi5ZFAmzCNoKEADNScZNuZNMLPZ5pvLsb6bF5dlduUE+abixBCCNEC/fvvv8yaNQtfX1/+97//ce2117J7925zT0uYQm5q+f3UU/DNHVBcWPm8C2chKxaDWsuSCDcAZko2mxBCCHFFEmgTphE4EFRqglVJeJHBe+bKatMVQEK4cr/PncqtZLQJIYQQV5SUlMRrr71G+/btufnmm3F0dKSwsJB169bx2muv0a9fP3NPUZhCXopy69sLLB3g3HZY9wDo9RXPK+02muHSg9hcFe72Vozr6tPEkxVCCCFaHgm0CdOwdgIfZUvJIM0JtpxK4Vh8VtPPIzEc9Dqw84CO45Rj6WeguKjp5yKEEEK0EBMmTKBjx44cOXKEpUuXkpCQwHvvvWfuaYnGkFsaaAsYBNNWgdoCjv0AmxdUPO+sEmj7qzAUgNv6+2NpIR8dhBBCiCuR/y2F6ZRuH73FPQbAPLXajNtG/cPA0Q+snJQ6JOlmrhsnhBBCNGN//PEHd999Ny+++CLXX389Go3G3FMSjSWvdOuovQeEjIBJy5THO9+D3cuV+3p9WcfRtelt0ahV3BYm20aFEEKI2pBAmzCd0kBbH8NxVCrYeCKZt/6MwGAwNN0cjI0Q/MNApQLPTspj2T4qhBBCVGv79u3k5OTQp08fwsLCeP/990lLSzP3tERjMGa02Xkqtz1uhetKs9k2PA0nfoGU45CfTqHahsOGdozu7IW3k7V55iuEEEK0MBJoE6YTMABUGiyzz7HoGmcA3v87kvk/HqW4RF/ztaZgMFTMaINLAm3SEEEIIYSozoABA/jkk09ITEzkvvvu45tvvsHX1xe9Xs+mTZvIyckx9xSFqRhrtNl7lh8bMg/63gUY4Mc5sP1tAPaUdESHBTMHBjX5NIUQQoiWSgJtwnSsHcG3JwAzvGJZPLUbahV8s+88D351kAJdSeO+/oWzynYIjWVZvTg8Oyu3ktEmhBBCXJGdnR133XUX27dv5+jRo/z3v//ltddew9PTk4kTJ5p7esIUjF1H7TzKj6lUMO5N6DAOiguUmm3Av8Vd6OBlz4C2rmaYqBBCCNEySaBNmFbp9lFitjO9fwAf3tEHSws1G08kM3PFXrIu6hrvtY3bRn16grZ0e4NktAkhhBD10rFjR9544w3i4uL4+uuvzT0dYQp6/SU12jwrPqexgJs+A78+ZYd26rswY2AQKpWqCScphBBCtGwSaBOmFWwMtCkFdMd08ebLu/rjYGXB3rMZTPtoFynZBY3z2rG7lVv//uXHjIG2CzFQlNc4ryuEEEJcxTQaDZMnT+aXX34x91REQ128AIbSHQaXZrQZWdrB9LXkuHZht74T5y3bMqWXX9POUQghhGjhJNAmTMt/gNImPjMWLpwDYEBbN9beNxAPBytOJeUw9cOdnE1rhKDXpY0QjOzcy4v9pp4y/WsKIYQQQrQUxvpsNi6g0VZ9jr0H85ze4dai57mxTwD2VhZNNz8hhBDiKiCBNmFaVvbg21u5H7O97HBnX0d+fGAQQW62xF24yE0f7uRoXJbpXrcgq3x76KUZbSCdR4UQQgghoHLH0apOKSxmyynlvDsGBDbFrIQQQoirigTahOkFDVFuLwm0Afi72vL9A4Po6udIel4Rt368i0OxF0zzmnH7AQM4B4KDd8XnpCGCEEIIIUT19dkucT4jH70BXGy1tPO0b6KJCSGEEFcPCbQJ0yur07YNDIYKT7nbW/HNvQMZ2NaNvKIS7vx8H6eTcxr+mlVtGzVqrg0R9HqpGyeEEOKqt2zZMoKCgrC2tiYsLIy9e/dWe+7KlStRqVQVvqytrSucc+edd1Y6Z+zYsY39Nq4OZRltVdRnKxV34SIAbVxsm2JGQgghxFVHAm3C9PzDQGMFWefhZOXCyfZWFnw6qy+9ApzJuqhjxmd7OJ+R37DXPL9HuQ2oKtDWTDPa/pwPrwXCuV3mnokQQgjRKNauXcu8efNYuHAhBw8epEePHowZM4aUlJRqr3F0dCQxMbHs69y5c5XOGTt2bIVzpCtqLeUmK7c1ZLTFX1B+JmvjYtMUMxJCCCGuOhJoE6ZnaQeDH1bur38CLmZWOsXOyoLP7+xHRy8HkrMLueOzPaTk1LMbqb6kdOsoVWe0eXRUbnMSIT+jfq9havkZsP9z0Otg2//MPRshhBCiUSxZsoQ5c+Ywe/ZsOnfuzPLly7G1tWXFihXVXqNSqfD29i778vLyqnSOlZVVhXNcXFwa821cPYxbR2uV0SaBNiGEEKI+pI2QaBxDH4fj6yD9DGx6Hia+V+kUZ1tLVt3dnxuX7+Rcej4zP9vL2nsH4mRbTRes6qSchKIcsLQvz167lLUjOAVAVqzSeTRwUP3ekykd/Q5KCpX7kZsgLRLc25l3TkIIIYQJFRUVceDAAebPn192TK1WM3LkSHbtqj6bOzc3l8DAQPR6Pb179+bVV1+lS5cuFc7ZunUrnp6euLi4cO211/Lyyy/j5uZW5XiFhYUUFhaWPc7OzgZAp9Oh0+ka8harZByzMcZuKE1OMmqg2MYNQzXzi81Qylp4O1qZ9T0053VsKWQNG07W0DRkHRtO1tA0GrqOtb1OAm2icWitYeK78Pk4OPgldLsZgodVOs3T0ZrVd4dx0/JdnErK4a4v9rHq7v7YWtbhW9O4bbRNX1Brqj7Hs5MSaEs5Yf5Am8EAB1cp97V2oMuDvR/B+DfNOy8hhBDChNLS0igpKamUkebl5cWpU6eqvKZjx46sWLGC7t27k5WVxVtvvcWgQYM4fvw4bdq0AZRto1OnTiU4OJioqCieeeYZxo0bx65du9BoKv8csHjxYl588cVKxzdu3IitbePVIdu0aVOjjV1fwxMicQb2nzxHcsL6Ks85cU4DqEiKPM76jGNNOb0qNcd1bGlkDRtO1tA0ZB0bTtbQNOq7jvn5tSt5JYE20XgCB0Hfu2D/Cvj1EXhgJ2grb0MIdLNj1d39uWX5Lg6cu8D9qw/y6cy+WFrUcmdzTY0QjDw7wZk/m0edtsRwSD6q1LGb9D58PxvC18C1z4G1k7lnJ4QQQpjNwIEDGThwYNnjQYMG0alTJz766CNeeuklAG699day57t160b37t0JCQlh69atXHfddZXGnD9/PvPmzSt7nJ2djb+/P6NHj8bR0dHk70Gn07Fp0yZGjRqFVlvHLP1GZhH5FAB9h4/D4Nu7ynMWhv8N6Jg0cggdvR2acHYVNed1bClkDRtO1tA0ZB0bTtbQNBq6jsas+CuRQJtoXCNfgIg/ICMa/nldeVyFUG9HPp/dnzs+3cO/p1N57Ntw3r21Fxq16sqvYcxo8+9f/TlepVtOkptB51FjNlunG6DLFPjnDUg9CYdWw8CHzDs3IYQQwkTc3d3RaDQkJydXOJ6cnIy3t3etxtBqtfTq1YvIyMhqz2nbti3u7u5ERkZWGWizsrLCysqqyrEb88NKY49fZwYD5KUBYOHkC1XMLadAR+ZFZVtMoIdDs5h/s1vHFkjWsOFkDU1D1rHhZA1No77rWNtrpBmCaFzWTnD9EuX+jnch8Ui1p/YJdGH5jD5oNSp+P5LIc+uOUaI31Dx+bgpcOAuowK9v9ed5dlJuU04oP2iaS1G+Up8NoNcMUKkg7D7l8Z6PlMYOQgghxFXA0tKSPn36sGXLlrJjer2eLVu2VMhaq0lJSQlHjx7Fx8en2nPi4uJIT0+v8RwBXLygNGGCapshxGcqjRCcbbU4WMsHOSGEEKI+JNAmGl/oeOg8GQwl8Mt/oKS42lOHd/Bg6bReqFTw9d5YrvvfVtbsiaVAV3UAShVf2m3UsxPYOFc/B7f2oNJAQSbkJNX7rTTYyV+gMBucAyB4uHKs+zSwcYHMc3D6T/PNTQghhDCxefPm8cknn/DFF19w8uRJHnjgAfLy8pg9ezYAM2fOrNAsYdGiRWzcuJHo6GgOHjzIHXfcwblz57jnnnsApVHCE088we7du4mJiWHLli1MmjSJdu3aMWbMGLO8xxbD2HHUykmppVuFeOk4KoQQQjSYBNpE0xj3hpLdlhgOez6s8dTru/uw5JYeONtqiUnP55mfjjL0jb9Z/k8UOQUVu3yo4oz12WrYNgrKD5RuIcr9FDNuHzVuG+01A9Slf/0sbaH3LOX+FdZGCCGEaEmmTZvGW2+9xYIFC+jZsyfh4eFs2LChrEFCbGwsiYmJZedfuHCBOXPm0KlTJ8aPH092djY7d+6kc2elq7hGo+HIkSNMnDiRDh06cPfdd9OnTx+2bdtW5fZQcYncFOXWvupsNoA4Y6DNufGaRAghhBBXO6nRJpqGgxeMfgV+mQt/vQKhN4BrcLWnT+nVhtGdvVm77zyfbIsmMauA1/44xbK/I5kxIJAZYUrnMVXcPuWCmhohGHl2grTTSkOEdpVruDS69Cg4tx1QQc/bKj7X7x7Y+R6c/ReSj5fXlBNCCCFauLlz5zJ37twqn9u6dWuFx2+//TZvv/12tWPZ2Njw55+S/V0veaWBNjvPak+Ju6B0U/OTjDYhhBCi3iSjTTSdXndA8DAovgi/PXrFWml2VhbcNSSYf54YwVs396Cdpz05BcV8sDWK4f/bxo9RJagSw5WTaxVoU34bbrbOo4dKs9najQSnNhWfc/ZXmiMA7FnetPMSQgghxNUvt3TraG0y2iTQJoQQQtSbBNpE01Gp4IalYGEN0VshfE315xoMZYE4Sws1N/Vpw8ZHh/HxjD70CnCmqFhPTuo5VCWFGGzdwbXtlV//0oYITa2kGMK/Vu73nlH1OWEPKLdHvoX8jKaZlxDCNLIT4LvZkHjY3DMRQoiq1SqjzRhok62jQgghRH3J1lHRtNxC4Jr5sHkh/Pow/Dkf9HqlUYJBr3TdNN63coQBD8Lgh8HSDrVaxegu3ozq7MXWU8ns/uo3AOLsu+GvUl35tY0ZbamnlNdUN2GcOXIT5CaBrTt0GFf1OQEDwKeH8kH9wEoYOq/p5idaruJC+PpW8OkJIxeaezat1+4P4fiPyr9ft3xp7tkIIURlZTXarrx1VDLahBBCiPqTjDbR9AbOBb++oC+GgiwoygFdPhQXKG3nDXrlvMJs+Oc1eK8PHFqtBOEAlUrFkHZujLc7DcA3ST5EpeZe+XVdgkFjpbxW5rnGendVMzZB6HErWFhWfY5KVZ7Vtu9TKNFVfZ4Ql4rbD1F/wa73a+zoKxpZwiHl1lxb04UQ4kqMXUftqt46mldYzIV85WcPqdEmhBBC1J9ktImmp7GA2evhQgyo1OVfag2oNOW357bDpoVKUOznh5TaZaNfgbbDwWCgY8kZAPbo2rFtbTg/PDAIraaG2LHGAjw6QNJR5cNwDc0YTConCU5vUO73qmbbqFHXqbBpAWTHw8lflcdC1CQtQrktKYILZ8G9vXnn0xrp9eVbRtOjlCxDC+l+KIRoZq6Q0RafqWwbdbLR4mitbapZCSGEEFcdyWgT5mFhBR4dlaCAW4gS9HIOACc/cPBWCvV2mQJz98Hol8HKSQmQfTkR1tyKKvovrIuzMKi1xFp14EhcFu9uOXPl1y1riNCEddoOf61sJ2vTHzxDaz7Xwgr63qXcl6YIojZST5ffl2wq88iIUjJwQfm7nlaLf4uEEKKplWW0VR1ok22jQgghhGlIoE00bxZWMOg/8PAh6H8fqC3g9B9YfDMNAIN3dxZO7QvAsr8j2R9zhSYCZQ0RmiggYTAo216h+iYIl+t7F6i1cH4PxB9svLmJq4Mxow2U+oOi6Rm3jRpJwFMI0dwYDJdktFW9ddTYCMHPWQJtQgghRENIoE20DHZuMP4NeHA3dBxfdtjgH8b13X2Y2tsPvQEe+zacnIIaapuVZbQ10Qfh2F2QHgmW9tCllttAHbzKt4zu+ajx5iZqpygf8tLNPYvqpV4SaJMAj3lcHhBPlT8HIUQzU5gNJYXK/Woz2qTjqBBCCGEKEmgTLYt7e5j+NcW3/8RprxvQD3oUgBcndqGNiw3nMy6y6NcatoUaM9rSTjdNs4GDpd0Hu0wBK/vaXxd2v3J77AfISTb9vETtfX0rvNMDsuLMPZPKCnOUen5GktFmHsaMNj8lu1YCnkKIZie3dNuopT1YVh1Ik62jQgghhGlIoE20SIagoZz0vQVsXQFwsNay5JaeqFXw3YE4/jiaWPWFTv7KD5l6nVK0vDEVZMHxdcr93jPrdq1fb/APU+b5z+smn5qopYIsOPuP0hk3equ5Z1NZWml9Nk1pJ9u0M9KttqmVFEPSEeV+z+nKbVPWgBRCiNrIK902Wk3HUYD4sow2CbQJIYQQDSGBNnHV6B/syv3DQwCY/9NRkrMLKp+kUl1Sp62RPwwf+wGKL4JHKLTpV/frRzyj3O7/DM5sMu3cWpO4/fUPql5ae+v8XtPMx5SMjRDa9AetnRKYzYg275xam7QI0OWDpQN0mqgcu3AOivLMOy8hhLjUFTqOgmwdFUIIIUxFAm3iqvLoyA509XMkM1/H498dRq83UFyi50JeEecz8jmekEWydVsAIo7s4XxGfuNMJDcFdr6n3O81Qwnw1VXba8q3kP78EOSlmWx6rUbKKfhsNKyarBSCrqv4A+X3m2OgzdgIwaOj8gWybbGpGYOxvj2VD7C27oChYu08IYQwt7KOo1VntOUXFZOeVwSAn2S0CSGEEA1iYe4JCGFKlhZqlk7rxQ3vbWPbmTQ6LdhAYbG+wjmzNZYs1ELMyf08eGwrk3r68tCIdoR4XFJDrSgPdr4PTn7Q8/a6BcqyE+CLiUpmkYMP9Lyt/m9o5AvKlsXUU/DrIzBtdf2Cdq3Vse/BUAKZscqfh1tI3a6PuyTQlnpK2Upq7WTaOTaEMaPNoyMUF0DCQanT1tSMjRB8eyq3np0gZpsS8PTrbbZpCSFEBVfIaDNuG3W0tsDJRttUsxJCCCGuSpLRJq467Tztef4GpbvopUE2G60GDwcrsh3bA9BNm0CJ3sCPB+MZueQfHv76EKeTc5TMpQ8Hw9ZXlUyy7++CwtzavXhmLHw+DtLPgGMbuPP3sjpy9aK1gamfgFoLp36DQ6vrP1ZrYzDA8Z/KH5/fU/fr4/cr91UawKBsQ21OjBlt7h2ULcogGW1NrSyjrTSoZuxsLJ1HhRDNSVmNtpo7jvrJtlEhhBCiwSSjTVyVbg8LZFh7DwwGcLC2wN7aAq2mNK6c2x3eWoCvPpFf7+/NO//Es/lkMn8cjqXD8bdpZ/EravRg7wX56XD8RyV4MW01uLer/kXTo+DLSZB1HlyCYOYv4BLY8Dfj0x2ufQ42L4Q/noKgweDatuHjXu2Sj0F6ZPnj2N11yy7MToDcZCXI1nGcEuiM2wftrjP9XOujuLC8HptHR9AXK/clo63pFBcp32cAvr2UW08JeAohmiFj11H7qreOSsdRIYQQwnQko01ctfxdbQlws8XFzrI8yAZKfRJbN8BAN8skPp3Vly13ePCX0yLmWvyMGj0/lAzhP64fc/aGtUrALfUkfHwNnPy16hdLPQ2fj1eCbG7tYPYfpgmyGQ36DwQOBl0e/Hif0ulQ1MyYzWbjotzWtcaaMZvNqzMED6/fGI0pPQoMerByVLYoGzPa0iOl82hTSTkOJUXK95hLkHLMmNEmgTYhRHNSy4w2CbQJIYQQDSeBNtH6qFTlH4aTjsGOdwn56Xr8CyMpsXbhM98Xebz4QX49nceYH3T8NnAtBAyCohxYewdsWlgx0JV8HFaOh9wk8OgEd64HR1/TzlmtgSnLlaBK3F7YvsS0419tLt02Ovxp5Tb1JFy8UPsxjI0Q/PqAf2nX2Lj9oNdXf01TunTbqEoFTm2Uzpf64vp3WRV1U7ZttFd57URjwDM7XqnpJ4QQzcEVarTFZUrHUSGEEMJUJNAmWifPTsrtH0/BpueVrJT2Y9A8tIe7732UzfOGc12oJ0Uleub+msCr7q+jD3tQuWbHUlg9RekCmhAOK69Xunl5d1Nqsjl4Nc6cnQNg/FvK/a2vVSzULypKOqpsq7Swhl53lG+1Pb+v9mMYi9z79QGvrmBhA4VZkHba9POtj0sbIYAS6DHel/pgTaOsEUKv8mM2zuBQGmhPkW28Qohmwth1tLpAm2S0CSGEECYjgTbROhkz2nR5YGkPE96F29aWBclCPOz5ZGZfHr5OaZzw8c7z3Jk4hfwJH4PWFs7+Cx8NU7qLXrygBGNm/Qp2bo077+63QJcpSifNH+co3VFFZcZstvajwcoe/Acoj2vbEEFfUp6t5NcHNNryDpJxzWT76KUZbUZl9cEkwNMkEsKV20sDbVAeyJeApxCiOSjMBZ1Sg626raPxUqNNCCGEMBkJtInWqe01yjbMwCFw/3boM6t861cptVrFvFEdWHZbb2y0Gv49ncr1f3sRe+NvSh227HglwylgIMxYV14LrFRhcQk5BSaulaVSwfVLlIyZjCj481nTjn81uHTbaJcpym1AmHJb20BbagQU5YLWrnwrYJvS7aPNpU7b5RltoGxdBgnwNIWifEg5odw3dhw1MgbapE6bEKI5MNZn09oqv3y6zMWiEtJyiwDZOiqEEEKYgnQdFa2TazA8eRY0V/4rcH13H4Lcbbn3ywOcTcvj+q8LWXbTtwyLeVep1Tb+DbC0AyAlu4C/I1LYcjKF7ZFp6A0GFk/txpRebeo8xRMJ2fx+NIE7BgTi43TJb5htXWHKh0qH0wOfQ9AQ6HZTnce/aiUehgtnla2eHcYox/xLA23xB5RGARptzWMY67P59lLq4wH491du4+qw/bSx6Esg/Yxy/9KMNg/JaGsyyceUzFI7z8o1GcsCbSeafl5CCHE5Y8dRu6o7jsZnKtlsDlYWONlc4f9HIYQQQlyRBNpE61WLIJtRF18nfp47mAdXH2RvTAaz1pziqbEPc+/QthxLyOKvU6f561QKR+IqFz9/bO1hTibm8NTYUDRqVRWjV2QwGFi9J5aXfj1BUYme9UeT+O7+gbjbW5Wf1PYaGPAQ7F4GP9ytfOgf8Vyd3lOzoSsArbXpxjNms3UYXRYAxb0jWDspxemTjpZvA61OWSOES85rUxpoSz0FFzOVWlzmknkOigtAY1Xe7RLKt45mREFxEVhYmmV6rULZ1uLelbJhywNtEvAUQjQDeTU3QjhfWp/NT7aNCiGEECYhW0eFqCV3eytW3xPG9P4BGAzw2h+n6LFoIxPf38HSzWfKgmw92jjx2MgO/Dp3CA+NCAHg43+jmb1yH1n5NW8lzSnQMffrQzy/7hhFJXosLdScTctj9uf7yC0srnjyqBch7AHl/va3YdXk8q5izV1JMRz7ET4dBa94w5aXlC2fDVXVtlEAtbo8UFabrZ+Xdhw1svcoD2rF72/wVBvEuG3UvX15xh2Ao5+yJVpfDOmR5plba1FVIwQjY2ZhXorSNEUIIczJ+LNBtfXZpOOoEEIIYUpmD7QtW7aMoKAgrK2tCQsLY+/e6j8E63Q6Fi1aREhICNbW1vTo0YMNGzY0aEwh6sLSQs2rU7ry0qQuaNQqcgqKsbPUMLaLN2/c1J29z17Hz3OH8MjI9nRr48QTY0J5b3ovrLVq/j2dyqRl24lMyaly7GPxWdzw3nZ+P5KIhVrFc9d34o9HhuJmZ8nR+CzuW7WfwuKS8gs0Whj3Gty0QqklFrNNadAQu7uJVgOlGUN6lLKVsTbyM2D7UninB3w/u7SxgAG2vaU0dygubNh8Eg4p2V5aW6URwqXK6rRdYX2K8iH5uHK/Td+Kz5UF68y8fbSqRgggnUebkjGjrapAm6UdOAcq96VOmxDC3Mo6jla9dVQ6jgohhBCmZdZA29q1a5k3bx4LFy7k4MGD9OjRgzFjxpCSUnVWznPPPcdHH33Ee++9x4kTJ7j//vuZMmUKhw4dqveYQtSVSqVixsAgfn94CGvuCePgglEsn9GHW/r64+lQeQvkhB6+/PDAIPycbYhJz2fysp1sOZlc9rzBYGDV7nNM/WAn59Lz8XO24dv7B3LP0LaEeNizcnZ/7Cw17IhM57G14ZToL8v86noj3Pu3sj0yJxFWXg+7lpkmQ6w6JTrYvRze7gLv9YbF/rBinNKc4ej3kBFd8fVTT8Nv85TzNy+E7DiwdYfhT8G4N0BtAUe/g1VTlS6u9XVinXLbYUz5tlEjY522K2W0JR1Ram/ZeykZYhXGMNZpM3PwvqpGCEZSp63xFeZAWumfQVWBNijvbJwqfw5CCDO7QkZbnHQcFUIIIUzKrIG2JUuWMGfOHGbPnk3nzp1Zvnw5tra2rFixosrzV61axTPPPMP48eNp27YtDzzwAOPHj+d///tfvccUor5CvR0Z1M4dKwvNFc811njrH+RKbmEx93y5n2V/R5J92VbRkZ08+f3hIfQOKO9g2q2NEx/P7IulRs36o0ks+PkYhsuDaB4dYc5f0PUmZdvgn8/Ad7OUgIApGQwQ8Qd8MAA2PKUExVQa0OVB7E7Y9b5SM+7dXvB6EHw5Wfla1g/2fwa6fPDqBpM+gMeOw4hnIOw+uP07sHSAc9vhs9FwIaZ+c6tq26iRXx9lrtnxkHm++nEu3TZ6ee0tY+fRuAOg19d9jqZSXUYblNcHk4y2xpN4GDCAY5tqax5JQwQhRLNxhRptcbJ1VAghhDAps1VOLyoq4sCBA8yfP7/smFqtZuTIkezatavKawoLC7G2rpgxZGNjw/bt2+s9pnHcwsLyLWvZ2dmAslVVp6u5plZ9GMdsjLFbi5a4hk5Waj6f1ZtX/jjFmr1xvPlnBB9sjSSvsAQLtYonRrdn9qBAVCpVpffVP9CJt27qyiPfHuGrPbG42lrw8LXtKr6A2gomfojaty/qzc+jOvEzhuTjFE/+GLy7VzmnOq1j8nE0m59HHfMvAAZbd/TDn0bf4zbIiEaVcAhVYjiqxEOoko+hKsiE6L+Vc1Fh6DAOff97MQQMLg9gGV83YCjM+h2Lb25FlXYaw6cjKbnlKwy+V2hacAlVwkEsMmMxaO0oDrqmfOyyEyzReHdDnRhOccxODF2mVjmO5vw+1ECJTy/0l4/h1hELrS2qwix0ScfBI7TpvxcNBixSI1ABOpeQSu9T5doeC8CQcpLiFvT3oyX9nVaf348G0Pv0pKSa+arclD8HffKJas8xtZa0hs1ZQ9ZR1l40S1foOipbR4UQQgjTMlugLS0tjZKSEry8vCoc9/Ly4tSpqrfajBkzhiVLljBs2DBCQkLYsmULP/74IyUlJfUeE2Dx4sW8+OKLlY5v3LgRW9vG++3epk2bGm3s1qIlrmGYBorbqvj+rJq8whJcLA3c2aEY76wT/PFHzdkvNwWp+O6shvf+jiYx5gxDvavaHuqLS7v59Dv7PjbpkWg/u5Y45wGc8plCnrVPlePWtI5WukxCE38gMP1fVBgoUVkQ7TGG094TKU6ygaTNpWc6AcPBazgqj2IcC+Jwzo/GsjiPeJcw8q084Xg2HP+j2teyDniSAdFLcMqLhS9u4GDQgyQ51S7Y1jn+a9oD8XbdOLBpa5XndC32JASI3f4tR89V3el0ZOR27IA953Wkrl9f6flBVoF46E5y7I8VxLpfU3a8qb4XrXSZjC3MxoCKDXvPoFfHVHjeuiiDMYAhPZoNv/2MXq1tknmZSkv4O93n7HraAKeybThTxfcIgGN+OiOA4oSj/PH775WzIxtRS1jDlqA+65ifn98IMxGigWrIaCvQlZCWq/yyWQJtQgghhGmYLdBWH++88w5z5swhNDQUlUpFSEgIs2fPbvC20Pnz5zNv3ryyx9nZ2fj7+zN69GgcHR0bOu1KdDodmzZtYtSoUWi1LetDcHPR0tdwPHBLXBY7ItO5rb8/zra1ew/jAZ+/o3j3ryh+iNEwpF93ru/mXfXJebeh3zgf9YmfaJO5G7+sfRi630rJ0CfAqQ1Qwzoa9KgSD6OK+B318U9QFeUBoO80Cf21CwhyDiSoDu+3fR3OpXAS+h/vwSJ6C/3Pvot+1Kvo+91T8zUGAxbvPwOA93UPMD50fJWnqU4UwU8bCdYk4z++inPy0tAeUn7z32/yfWDtVOkU9d8HYedJergW0nX8+Cb/XlSd/ReOAS5BjL1hUuUTDAYMkQtQF2Yztl878OrS6HMyhZb0d9rig4UAdLhmGu3bXlP1ScUFGN5YgGVJHuOH9QaHqoPcptSS1rA5a8g6GjPihWhWyjLaKgfajNls9lYWONnIvxtCCCGEKZgt0Obu7o5GoyE5ObnC8eTkZLy9qw4ceHh4sG7dOgoKCkhPT8fX15enn36atm3b1ntMACsrK6ysrCod12q1jfphpbHHbw1a8hr2DXanb7B7na97bFRHMi8W8+Wuczzxw1FUajUTe/iiujxjxtkHblkJifPg71dQnd6A6vBXqI99B33vhqHzwEqpBafVatEaiiDqbzi9Ac5shNxL/h759oaxi1EHDGj8wo5aV7h9Lfz+X1QHv0Cz8Wk06REw5lWwrCbDNG6/0mDB0h6L0DFQ3fdE0CAAVCnH0eoLwcq+4vMpR5Vbt/ZoHar5swkcADtBHb8f9SWv02TfixeiAFB5hFb/ep6d4PwetBcioU3Pxp+TCTXaOsYfhKzz0LmK4GRd5GfAhbMAWAT0rf57TasF1xBIP4M24wy4BjTsdeugJf+72JzUZx1l3UWzU5QPRaX1WqvoOhqfWb5ttNLPEUIIIYSoF7M1Q7C0tKRPnz5s2bKl7Jher2fLli0MHDiwxmutra3x8/OjuLiYH374gUmTJjV4TCFaCpVKxcIJXbi+uw+6EgOPfBPO7JX7OJ9RzZYln+5w21q4exMEDYWSItjzIbzTA/XfrxCcuhnN19Pg9WBYezscWqUE2SztodMEuHkl3LMFAgY03ZvUaGHCO3DdAuXxgc/hkxGQdKzq841NEDqMBW0NW1+c/MDJHwx6iN9f+XljI4Q2fasfw9gQIS2iYR1S68vYCKGqjqNGxuek46XiwjlYeQN8O/PKXWevJDFcuXUJBhuXGk8tb0whfw5CCDMxbhvVWIFV5V0a0nFUCCGEMD2zdh2dN28en3zyCV988QUnT57kgQceIC8vj9mzZwMwc+bMCo0N9uzZw48//kh0dDTbtm1j7Nix6PV6nnzyyVqPKcTVQKNW8fYtPXn4uvZYatRsjUhl1Nv/8MHWSHQl1XTD9O8Ps36FGeuUDDVdPpqdb9M97kvU0VugpBCcAyHsfpjxEzwZDdNWKx081Wb4p0KlgqH/VeZi76UEKz65FnYvVzqMGhkMcHydcr+qbqOX8++v3FYVcDEG3/z6VH+9nTu4Klm0xB248uuZWmptAm3GjpfSeRSDAX75j9IZF+DYDw0bL+GQcutXi9qB0nlUCGFuxm2j9p5V1oqUjqNCCCGE6Zm1Rtu0adNITU1lwYIFJCUl0bNnTzZs2FDWzCA2Nhb1JR/wCwoKeO6554iOjsbe3p7x48ezatUqnJ2daz2mEFcLSws180Z1YFJPX5796Si7ozN4Y0ME6w7F8+qUbvQNcq18kUoFISOg7TVw6nf0O98j48IFXPpPQxN6vRK8aW5bR0KuhQd2wroH4cyfsOEpiPoLJn+gBL0u2TZKu5FXHs9/gBJsid1d8bjBUJ7RdqUgSpv+kBENcXshaHj93ld9pZ1Wbt1rCLR5hiq3kkkFB1bC2X/KH5/4GcYsrn/wOP6gcuvb68rnlgXa5M9BCGEmxow26TgqhBBCNBmzN0OYO3cuc+fOrfK5rVu3Vng8fPhwTpy4cmZATWMKcbUJ8bDn6zkD+PFgPK+sP8np5FxuWr6LW/v58/S4UJxtLStfpFJBpxsoaTeGHevXM37geDTNubaQnbuy/XXvx7DxeSXg9uEgmPwhRJZuFe84HrRVdxKtwJjRFrcP9PrygMuFs8pWUI0leHW9whj94Mg39d+GaDBATpKyDTT1NOQkQO9Z4Bpc83UXM8tr57nX0GLCmNGWEQ26gtqty9Uo87zy/QIw8gXYtgRyEuH8HgisZzmBhHDltlaBts7Kbeqpit9rQgjRVHKr7zgKsnVUCCGEaAxmD7QJIRpOpVJxY582XBvqyWt/nGLt/vN8s+88m04kMzDEDYMBSvQG9AbjF+gNBopL9KSlqvkh7QAatRq1SoVKpYynVoEKFYHuttwRFoi/q5m3lahUEHYfBA6GH+5Wgherp4JF6YeD2mwbBSWIprWDwmxIPVneldOYqeTdHSwqN0epoE1psC7+gFLvrSb6EiUYmHJcCaqlRUDaGeX1LxV/EGb9UvNYxmw2B1+wrqEjsoO30jG1IAvSz4B3t5rHvRoZDPDrw0oRcP8wGPSwkll25Bs4sa5+gbbcFCV7EhX49Ljy+a5tQa2FolylEYNLYN1fUwghGiLP2HG05ow2P2fZOiqEEEKYivx6XYiriIudJa/f1J1v7xtIe0970vOK+O1IIr8fTWTD8SQ2nkhm88kU/jqVwtaIVLZHpnMqS82/Z9L5OyKVLadS2HwyhU0nkvnzeDIbjifx0T/RXPPWVuauOciRuExzv0Xw7gpz/oa+dymPiy8qBZ5Drq3d9RqL8mYH5/eUH4+rRX02I8/OlwTrIqo/T18Ca2fAmpth8wtweI0SnCvMBpUG3NopmXgqtbK9MfV0za9r3Arq0aHm81SqS+q0tdJti4dWKVuMLaxh0jJQa8qDsSd+VjLM6spYn829A1g5XPl8jVY5F2Qbr2jVli1bRlBQENbW1oSFhbF3b/XZwCtXrkSlUlX4sraumJVrMBhYsGABPj4+2NjYMHLkSM6cOdPYb6NlqiGjrUBXQmpOISAZbUIIIYQpSUabEFeh/sGu/P7wUNYfTeRCfhEataosS02jUqFWqVCrVRj0JRw+fJju3XugUqsxGMBAecZbid7AphPJbDuTxm9HEvntSCJhwa7MGdqWa0M9UavNVM/N0hZueBtCroNNz0PP2+q2PdI/TAlsxe4pD9iV1WerRaBNY6HUcYvZhip+H+Be9XmbFkDE70q3t04TlBp47h2UW9e25ZlzX9+mnLfvUxj/RvWvawzq1VSfzcgzFM7vVrL2WpusePjzWeX+iGfLt9mGjFCCsvXdPmoMtNVm26iRZyclmzHlBHQYU7fXE+IqsHbtWubNm8fy5csJCwtj6dKljBkzhoiICDw9q97O6OjoSERE+S8xVJfVDn3jjTd49913+eKLLwgODub5559nzJgxnDhxolJQrtUrq9FWea0TMpVsNjtLDc62zbh8hBBCCNHCSKBNiKuUpYWayb38ajxHp9NhmRDO+F6+aKup0TZzYBAnErL5dFs0vxxOYM/ZDPaczaCthx1zhrZlSi8/rLWaxngLV9bpBuWrrgLClFtjRluJDhIPK/drE2gDpdZbzDbUcftBM7by8/s/h13vK/enfAhdb6x+rP5zlEBb+Bq47vnqs6WMW0dr6jhq1Foz2gwG+PURJWvQry8MfKj8OQsrCL0eDn8Nx3+qe6DNuL24Nh1HjYyNKaQDrGillixZwpw5c8q6vy9fvpzff/+dFStW8PTTT1d5jUqlwtvbu8rnDAYDS5cu5bnnnmPSpEkAfPnll3h5ebFu3TpuvfXWxnkjLVVZ19HKW0cv7Th6eTBTCCGEEPUngTYhxBV19nVkybSePDG2Iyt3xrBmdyzRqXnM//EoSzad5sWJXRjX1bvl/KDeph+gUhog5KZAdjyUFCp1zdxCajmGUqdNFb8PAi4LtEX9Db//V7k/4tmag2ygdIF1a6/UUzv8jRJ4q4oxo602gbayzqOtLMBz+GuI3KRkEU7+QNkyeqnOk5VzTvwMY1+rfYMCg6GeGW2lDREk0CZaoaKiIg4cOMD8+fPLjqnVakaOHMmuXbuqvS43N5fAwED0ej29e/fm1VdfpUsXpZ7m2bNnSUpKYuTI8i7TTk5OhIWFsWvXrioDbYWFhRQWFpY9zs5WamTqdDp0Ol2D3+fljGM2xth1ZZGbjAootnbFcNl8zqXlAuDrbNUs5nq55rSOLZWsYcPJGpqGrGPDyRqaRkPXsbbXSaBNCFFrPk42zB/Xibkj2rF233k+3xFDfOZFHvzqIGO6ePHSpK54OtZ+205+UTFnknPp3sapaYN01k5KACTlOMTuLt9a49dHqW9WG236AaBKP4PWN7f8eGoEfDsLDCXQfRoMe+LKY6lUSnDtjyeV7aP97qk8D91FyIxV7tdm62hZ59GzyrXaVlB/JzsRNpRmyFzzdNUByZARYOUEuUnK1trAQbUcO175PlFp6tZcwrP0zyE1QqnZd3ngT4irWFpaGiUlJXh5eVU47uXlxalTVWfbduzYkRUrVtC9e3eysrJ46623GDRoEMePH6dNmzYkJSWVjXH5mMbnLrd48WJefPHFSsc3btyIrW3jNQHYtGlTo41dW+OzEtEC/xw4Se7xik14/olVA2qKs1JYv369WeZXG81hHVs6WcOGkzU0DVnHhpM1NI36rmN+fn6tzpNAmxCizhystdwztC0zBgay7K9IPtgaxZ/Hk9kVlc5zN3Tm5j5tagycJWZd5Mtd51izJ5asizpuCwvglcldmzbY5t9fCbSd3wMXLyjHarttFMDODVxDICMKl7wo5VheGnx1MxRmQcBAmPhe7QN3PabDlkVK0fyYbRA8rOLzaWcAA9i4gF01NeEuZe+pnHvxgrLltDZdMuvLYICMaKXunLmyGg0G+O1RpdOqby+ly2hVLKwgdHzp9tF1tQ+0GbPZPDvXLWjpHKR0xi2+qAQ93dvV/lohWqGBAwcycGD5tu5BgwbRqVMnPvroI1566aV6jTl//nzmzZtX9jg7Oxt/f39Gjx6No2MNHZzrSafTsWnTJkaNGlVtWYYmUVyA9pDygWDYuJuU/xMusenbIxCfxOCeoYwfHGSGCdas2axjCyZr2HCyhqYh69hwsoam0dB1NGbFX4kE2oQQ9WZloWHe6I6M7erDUz8c4Wh8Fk9+f4RfwhNYPLUb/q4VMwXCz2eyYvtZ1h9NpFhvKDu+Zk8sHTztuXNwcNNNPmAAHPhcCbQV5ijH/PrWbQz//pARhWveGSguhG9uh8xz4BIE074qb3ZQG9aOSgbc/s9g78dVBNpK67O5d6xdMEulAo9QiN2l1GlrzEDbL3Ph0GroebsSXDRH1taRb+H0BlBrYdIHSsOK6nSZUvfto7G7lVvfnnWbl1qtZNYlhivbeCXQJloRd3d3NBoNycnJFY4nJydXW4Ptclqtll69ehEZGQlQdl1ycjI+Pj4VxuzZs2eVY1hZWWFlVfnfY61W26gfVhp7/CvKK83wU2vROnhU+r8jMVvZThvgZt+sP7SZfR2vArKGDSdraBqyjg0na2ga9V3H2l5Ty+I0QghRvc6+jvz04CDmjwvFykLN9sg0Rr/9Lyu2n6WoWM/6o4nc+OFOJi/bwS+HEyjWGwgLduXjGX14aqxSS2zRbyf493Rq003aX6mxRkJ4ee2zuhS5h7Lto655kWh+f0TZimjlBLd9p2S81ZWxNtup9ZAVV/G51NJtVh4daj+eRxPUaTvxixJkAwj/Cn55GPT6xnu9qpzZVF4T75qnwKtzzee3vWz76JVciIF9nyn3211X9/kZt49KnTbRylhaWtKnTx+2bNlSdkyv17Nly5YKWWs1KSkp4ejRo2VBteDgYLy9vSuMmZ2dzZ49e2o9ZqtR1nG0cpANIO6Cku3WxqUVlBYQQgghmpBktAkhTMJCo+a+4SGM7uLNUz8cYe/ZDBb9doI3/4zgoq4EAK1GxYQevtw1OJiufk6A0kEuMiWXHw7G8dCag6x7aDAhHvaNP2GXYLDzLP8g4hSgbLesi9JgnUfuCTh2QqnfdcsXdQuGXcqzEwQNVbaO7v9c6UBqZAwG1qY+26XjXXqtqeWmKNs1AUKug+itEL4aVMCE92rfaKC+DAals+umBWDQK2s3+NErX2dhWdp9dE1p99Eato8aDPDbPGXrZ9BQpZlCXUmgTbRi8+bNY9asWfTt25f+/fuzdOlS8vLyyrqQzpw5Ez8/PxYvXgzAokWLGDBgAO3atSMzM5M333yTc+fOcc899wBKR9JHH32Ul19+mfbt2xMcHMzzzz+Pr68vkydPNtfbbJ5q6DhaWFxCcmlGWxuXxqtTJ4QQQrRGktEmhDCpYHc7vpkzgJcnd8XeyoKLuhJc7Sx5+Np27HjqWpbc0rMsyAbKh6ZXp3alT6ALOQXF3PPFfrLym6CbjkoFAWHlj+uazQbg2RmDpV354xuWKMX2G8KY1XZgpbId1ci4ddSYpVYbxnMbI8BjMCjZa/np4NUNpn8DN34CKrWS4fZrI2e26Qpg3YOw8TklyNZrBtzxI2hqmQLeZYpye+JnpUlBdY5+B1FblC6mNyytXw066TwqWrFp06bx1ltvsWDBAnr27El4eDgbNmwoa2YQGxtLYmJi2fkXLlxgzpw5dOrUifHjx5Odnc3OnTvp3Lk8U/XJJ5/kP//5D/feey/9+vUjNzeXDRs2YG1d+2Y8rUJZRlvlXyIlZBYAYGupwcVWtiAJIYQQpiQZbUIIk1OrVdwxIJBRnb04fD6TYR08sNZWX7fLykLDRzP6MOn9HZxNy+OhNQf5fHY/tJpG/l2Afxic/FW536aO9dkA1BoMAYNRRW6kJOxBNH3ubPicOl4Pjn5Kl8sTP0P3W6CkGNJLGy7UJVvOmEl1IQaK8sHShFkL4V/B6T9AYwlTlitZYl1vVAJwP86BQ6uUoNQN71w5s60oD9WZv3C8GFu7185JhrW3Q9w+JbA3ZjGE3Ve3IFjba5Tus7nJSv21oMGVz8nPKO9iOvyJ+tdXMwY8089AcZGyVkK0InPnzmXu3LlVPrd169YKj99++23efvvtGsdTqVQsWrSIRYsWmWqKV6fc0kBbFdnal24bbdJGREIIIUQrIBltQohG4+Vozegu3jUG2Yzc7a34ZGZfbC01bI9M46XfTjT+BP0HlN+vS8fRS5Rcv5RdIY+jv+4F08xJYwF9lC1V7P1Yub1wFvQ60NqCY5vaj2XnATaugKE8I84UMmPhj9IA1IhnwLtr+XPdboKppZltB79UtpZWl9mWfALWPwH/C8XiuzsYceo5LD4eCtuWKK9RlYRw+GSEEmSzdoI7foAB99c908zCEkJvUO4f/6nqczY+p2TseXaGQY/UbfxLObUBSwfQF0NGVOXnS3QQuQU2PAO7lkFhbv1fSwghjPJKt47aVd46GnfhIiDbRoUQQojGIIE2IUSz0dnXkben9QTgy13nWLX7XOO+oE93JXvM3qv+XTntPUlx7K4Elkylzyyle2bcPkg4dEl9tvZ1q3umUl1Sp+2Uaeam1ytbNotylIzAQQ9XPqfbTTDl49Jg2xfw+2PlwTZdgdIhdMVY+HCgEkwszMbg4EuJygJV6knY8iIs7QYrxsH+FUpmGcCxH5XrsuPBrT3c8xeEXFv/92Kst3byl8rbR6P/UbL2UMGEdxqWhXbpn0NKaQBZV6A0vfjpAXizHayeCruXwZ/PwDs9YMe7ShaiEELUVy0z2oQQQghhWrJ1VAjRrIzp4s0TYzry5p8RvPDLcULc7RjUzr3Gawp0JcRduMj5C/mczzB+KY8TMi8yMMSNN2/qgZ3VZf/kWVjBvf8oNb4urbVmbvaeSg2xo9/C3k/Bra1yvC6NEIw8QuHcjurrg12IUZoY6Iuh2y1g7VjzeHuWK80atLYw+UNQV5Ot2P1mwAA/3afUmyspBlsXOPQVXCwNnKk0EDoe+t5Fsf9gNv36A6P9C7A48SPEbIfYncrX+ieVrb2xu5Tr2o2Em1YoGW0NUWH76C4IGqIc110sb/LQ757yDrUN4RkKcXvhyHdw8jc4sxGKLslcs/OA9mPg3Hblz2TT87DzPRjyKPS9C7TyYVgIUUdlGW2VA23xpRltfs7yb4sQQghhahJoE0I0Ow9eE8KZ5BzWhSfwwFcHubW/P3mFxeQWFJNbWEJuoY7cwmLyCkvIKdCRlltU43jrjyaRnF3I57P74Wh9WdHnKrqxNQv95yiBtmPfK90uoX7dTC/PaLuYqQTKov6GqL+UbalGf70Mg/4D/e8Dqyo6v6ZGKNlmAKNfBreQml+7+y1KzbZ19yvdSI0c/aDPnUoDA0cf5ZhOh87CDkOvm6H/XZAVr7z3I99B8tHyINvAuTBqUfUBvrowbh8N/wqOrysPtP37JmREg4MvXLeg4a8D5Q0RTv9RfszRDzpNgE4TIWCA8p5KdHD4G2UOmeeUDLcd78CQecqaaaXYuxCilsoy2mTrqBBCCNGUJNAmhGh2VCoVr93YnbPp+Rw+n8lH/0Rf8Ro7Sw3+rra0cbElwNUWf1cb/Es/QMz7NpwD5y4w49M9fHFXf5xtW0Ax+jb9lO2siYchcpNyrL4ZbaAU/P90FMQfAMMl2yRVGiVjKy9NKda/ZZFSJ2zwo0o2l7GBQolOyU4rLoCQ65Qsq9roMU3ZOvnHk8p76nsXtBul1KKriZMfDH5E+Uo5CSd+UYKGnSfWeQlq1GWKEmg78TOMe10JSO54R3lu/JtXzvCrrQ5jYOtrYOOivIdOE8G3d+WtwBot9J4BPW6F8DXw71uQFQsbnoIdS5X18+sDPj3Bzs00c6uNzPPKuhz/UVmz6xY0PKNQCNG4aug6Wh5ok4w2IYQQwtQk0CaEaJastRo+v7MfK3fGkF9YjJ2VBQ7WFthZKV8OVsb7GrwdrXG1s6y2c9qaOQOY8dkeDsdlMf2TPay+uz9u9lZN/I7qSKWCfnPgl0s69RmDZnVhzGgryFS2LgK4tVNqm7UdoWRxWTsqNcqOfg//vKZkcxm3Lg6dpzRn2LFUqRdn7QST3q9b84Hutyhf9eXZqfx9mFrwcOU95aUo21W3LFK20YbeAJ1uMN3ruLaFp2KU+7VZO41WqdXXY7oSCNz2P8g6D3+/Un6Ok78SjPXpCb49wb1z1WMZDMqfr6FECaxeKch5qfQo2P42HP5aWReAfZ/Cqd+VQGSnCbUfSwjRdEp0cPGCcv+yGm2FxSUk5xQAEmgTQgghGoME2oQQzZarnSXzRtVju+Rluvo5sfa+gdz2yR5OJmZz68e7+eqeMDwdm/k2vG43KQGvixdAbQGuwXUfw84dRr4AyccheJgSXHP2r3yeWqNkn3W9EY58A/+8rnT+3PC0kslkrPUz/n/g6Nugt9WsWFhC6ARla+vPDynBLCtHJYhkanXtjGqcX9/Z0PM2OLJWqaeXEK50L806r3yd+g0ALXC92grNUbVSd9BQUtrkwVA+nloLfr0hcDAEDVY671a1TTjllBLcO/a9MhYoQcmuNypB14xoWHuHEpAc94aSgSiEaD6M/2arNKXdp8vFpudjMICNVoOrXQvI8BZCCCFaGAm0CSFahQ5eDnx73wBu+2QPZ1JymVYabPO9QiHoEr0BtYpqs+UaldZGqWO2811wDVGynOpjyGO1P1djAb3uUBojhH+lbF3MjlOe6zxZCf5dbbpMUQJtWeeVxyMXNr9gooUV9J6pfAEUZEHSUSXolngYEsMxpJ3BQl8I+hrG0evg/B7la/sS5UO4b8/SwNsQ5QP5znfh5K+UBejaj4Fhj5c3heh+i/J9sWOpEuSL/kdZs753VV07rzAHYvcojR7O7wVLe2UbcZu+StBPtqAKYXrG+mx27pW2qH/0r1KOoXegs3n+bxNCCCGuchJoE0K0Gm097Pn2voHc9uluzqblcctHu/h6zgD8XcuLQRcV6zkan8XesxnsPZvO/pgLWFqoeWlyV8Z382n6SQ/6j5KN1tQBrkszqQ6tUjKcrn22fllZzV3b4WDtrGyv9Q+DPrWsP2dO1k5KYMzYwAEozs3gn/XfM3zEtWi1VkrQS6UpvVUrt/npcG4nxOxQAl+ZsUrdvvgDSoDtUp0mwNDHlUDcpbQ2cN3zSnbbrw9D3D5Y/7iScTfhHSVIGbtb2Yp7bqcSCLy0LiDAmT9L76iULdFt+irBN//+4BxQmpFn/DJufdWXZ9epLZT3o7ZQAtBqC+Xravz+FKI+quk4eiw+ix8OKr88eWJMPcoRCCGEEOKKJNAmhGhVAtxsWXvfQG7/ZDcx6fnc8tEuFk7oQkRSDntj0jl4LpOLusuCAoXw4FcHuWtwME+PC8XSQl314I3B3hNm/Nh0r3c5CyulKcLVTKOFYU8oGXwT36vcoKClsHIgz8oLnANBW032o7WTUi+u1x3K48zY8qBbzA4lq6/LFBj63yvXxfPqDHf9CftXwOYXlYDb8qGlwTBDxXOdA5WgYMBA0OUrmW1x+5TOqqknla9Dqxq8BKjUSsOJLlOU9+jTU4JvonUq6zhaHmgzGAy88vtJDAaY1NOXnv7O5pmbEEIIcZWTQJsQotXxc7Yprdm2m6jUPO5ffaDC8y62WvoHu9I/2I3+Qa78diSBj/6NZsWOs4Sfv8Cy23vj4yQFpK8qg+YqX62NcwD0DICe05XHBkPdAlNqDfSfAx3Hw/onIOJ35bhbu/LtqIGDwKlNxevC7lNuc1Mgbr8SdIvbB/EHQZdX9Wup1MqXwVA5Q87IoFey9vZ9qnx5dS3fCt2UXVqFMLe8yoG2LSdT2BWdjqWFmifG1KOLtRBCCCFqRQJtQohWycvRmrX3DeS+VQdIyLxI3yBX+ge7MiDYlRAPe9Tq8mBDtzZO9A504fHvDnMwNpPr393OO7f2ZGh7DzO+AyEaQX2zv5z8YPoaSItUmis4eNfuOntPCB2vfIGyRVR3sXy7q8p4q6o4N4NBCaqV6JRuqPpi5Vp9MaQch0NfKXXmko8pDT02Pg8dxyk1D0OurVvnVSFaolzj1lHl/yldiZ5X158E4J4hwbRxsa3uSiGEEEI0kPykKYRotdztrfjhgUG1OndMF29CvR14YPVBTiRmM3PFXh69rgP3Dw1s5FkK0YK4t2vY9WpN1V1QL6dSldefu5yDlxJMu3gBjn4Ph1ZDYjic/EX5cvCB4U8pNQiFuFpdltG2Zk8s0Wl5uNtb8sA1IWacmBBCCHH1a6GFaIQQoukFutnx44ODmN7fH4MB3t58mntWHSRXZ+6ZCSEqsXFRtrXe9w/cvwMGPKh0Vc1JrH7rqRBXi7Kuo55kXdSxdPNpAB4d2QEH63p2sBZCCCFErUhGmxBC1IG1VsPiqd3pE+jKc+uOsi0yncNaDUc4Tp8gN3oHuNDW3a7C1lMhhJl5d4Wxi2Hki3D6Dwgebu4ZCdG4jF1H7T1Y9nckF/J1tPe059Z+/uadlxBCCNEKSKBNCCHq4aY+beji68gDqw8Qk57P2v3xrN0fD4CTjZZeAc70DnChd4ALPfydJINAiObAwhI6TzL3LIRofKUZbYnFjqzcEQPAM9d3wkIjm1mEEEKIxiaBNiGEqKdOPo788uBAlq7diNozhMNxWRyJyyLroo6tEalsjVAyCjRqFaM7e3HXkGD6Brqgqm/B+XpIzLrII9+Eo9cbeHd6L3ydpVuqEEJc1UqKle67wDu7Mykq0TO0vTvXdJAGPkIIIURTkECbEEI0gI2lhh5uBsaP6YBWq0VXoudkYjYHz13gYGwmB2MvEHfhIn8cS+KPY0l09XNk9qBgbujhg5VFFYXcTehYfBZ3f7GP5OxCAKZ+sJOVd/Uj1NuxUV9XCCGEGeWnAwYMKjXfnryIWqXm2es7NekveYQQQojWTAJtQghhQlqNmu5tnOnexpk7ByvHTiVls3JHDD8diudYfDb//e4wi/84xe1hAdw+IABPB2uTz2PziWQe/uYQ+UUldPCyx2CAMym53PzhLj6a0YdB7dxN/ppCCCFMrLgQCnOhKAeK8srv6y6Cpb3S9MP4ZeWgdOQt7TiahSN61Nza119+wSKEEEI0IQm0CSFEIwv1duS1G7vz5NhQvt4by5e7YkjOLuSdLWf4cGsUN3T3YUxXb/oFueJqZ9ng11u54yyLfjuB3gBD27uz7PbeGPRw76r97DmbwazP9/LWzT2Y1NPPBO9OCCGEyRQXwj+vw8Ev4WIm6OvQ1lqlUQJuFlYAJJY4YGupYd7oDo0zVyGEEEJUSQJtQgjRRFztLHloRDvuHdaWP44l8fmOsxyKzeTHQ/H8eEhppNDO055+QS70C3KlX5ArbVxsar3dp0Rv4KXfTrByZwwAt/bz56XJXdGWFr/+8u7+zPv2ML8fSeSRb8JJyCzg/uFtZTuREEI0B/EHYd2DkHqy8nMWNmBpB1b2YOkAWmslu60gE/IzoKQQDCWQn1Z2yWmDPw9cE9IoWdNCCCGEqJ4E2oQQoolpNWom9vBlYg9fDsVe4LsDcew9m0FkSm7Z19d7zwPg7WhNv2BXevo709XXkS5+TthbVf6nO6+wmEe+OcTmk8qWoafGhlYKollZaHjv1l74OFrz6fazvL7hFIlZF1k4oQsatQTbhBDCLIqL4N83YNsSJVhm6w7jXoeAgUpwzdIeNFf4kV13kbSUJH7ceZRtRyLRlORz3r4Hvw1t2zTvQQghhBBlJNAmhBBm1CvAhV4BLgBk5BWxPyaDfTEZ7Iu5wLH4LJKyC/j1cAK/Hk4ou6atux1d/Jzo6utIVz8nvByteOSbcI4nZGNpoebtW3pyfXefKl9PrVbx3A2d8XG24eXfT/DlrnMkZRXw7vReWGsbtzmDEEKIyySEK1lsKceVx12mwPi3wK72dTTjLuTz0T/RrN1/nqJiDdCRrn6OLJncDRtL+XddCCGEaGoSaBNCiGbC1c6S0V28Gd3FG4D8omLCYzOVoFtCFsfjs0jIKiA6LY/otLwKwTcANztLPp7Zlz6BLld8rbuHBOPtaM1j34az8UQy0z/ZzYe398HbSbYYCSFEoysugm1vwbb/gb4YbN3g+v8pgbZaOpuWx4dbI/nxYDzFegMAvQOc+c917bmmg4eUBRBCCCHMRAJtQgjRTNlaWjConXuFDqHpuYUcS8jmWHwWxxOyOBafTWxGPqHeDnw8oy8Bbra1Hv/67j54OFhxzxf7OBSbyfh3t/G/W3owoqNnY7wdIYQQAKkR8P3dkHxUedx5Eoz/H9h71OryiKQcPtgaya+HEyiNrzEoxI2517ZjYFs3CbAJIYQQZiaBNiGEaEHc7K0Y3sGD4R3KP5BdLCrBWquu14er/sGu/Dx3CA99dZATidnM/nwf9w1vy+OjO5Y1URBCCGEiuouw5ha4EAM2rkoWW9eptbr0SFwm7/8VycYTyWXHRnT0YO617egT6NpIExZCCCFEXUmgTQghWriG1uAJdrfjxwcH8er6k3y56xwf/RPN3rMZvDe9F21cap8hJ4QQ4gq2L1WCbA6+cN8/YH/lDOI90em8/3ck284oHUVVKhjbxZuHRrSjq59T485XCCGEEHUmgTYhhBBYazUsmtSVgW3dePKHI8pW0ne28ebNPRhTWjNOCCFEA2REw/a3lftjX60xyGYwGNh6OpUP/o5kX8wFADRqFZN6+PLgiBDaeTo0xYyFEEIIUQ8SaBNCCFFmXDcfuvo5MffrQxw+n8l9qw4we3AQT48LxcpCutcJIUS9GAzwx1NQUghtR0DnyVWeVlyiZ8PxJJb/E8Wx+GwALDVqbu7bhvuGhdSpDqcQQgghzEMCbUIIISrwd7Xlu/sG8uafp/hk21k+3xHD/pgLfDarL56O0pVUCCHqLGI9nNkIai2Mf1PZ/3mJ7AId3+47z+c7YojPvAiAjVbD7WEBzBnWFi/5t1cIIYRoMSTQJoQQohJLCzXPXt+ZAW3d+O93hzkan8Vtn+7h6zkD8HCwMvf0hBCi5SjKhz+eVu4P+g+4ty976nxGPit3xrB233lyC4sBcLOz5I4BgcwaFISrnaU5ZiyEEEKIBpBAmxBCiGpd18mLXx4awrSPdxGZkssdn+7h63sHyIc/IYSorW3/g6xYcPKHYY8DcCj2Ap9uO8sfxxLRG5TT2nvac8/QYCb19MNaK1v1hRBCiJZKAm1CCCFqFOBmy9dzBjDt411EJOdw+6d7+HpOGM62EmwTQogapUXCzneV+2MXg6Udr284xYdbo8pOGdrenbuHBDO8gweqy7aUCiGEEKLlUZt7AkIIIZq/IHc71swZgLu9FScTs5nx2V6yLurMPS0hhGi+DAb44wkoKYJ2oyD0BgDWH00E4PruPmx4dCir7g7jmo6eEmQTQgghrhISaBNCCFErIR72fD0nDDc7S47GZzFzxV6yCyTYJoQQVVGd+hWi/gKNJYx7HVQq8ouKic3IB2DRxC6EejuaeZZCCCGEMDUJtAkhhKi19l4OfDUnDBdbLYfPZ3Lnir1lBbyFEKIqy5YtIygoCGtra8LCwti7d2+trvvmm29QqVRMnjy5wvE777wTlUpV4Wvs2LGNMPP605QUoNn0nPJg8KPgFgLAmeRcDAZwt7fCzV4aywghhBBXIwm0CSGEqJNQb0dW3xOGk42Wg7GZ3PX5PvKLKgbbikv0nEvP45/TqXyxM4bFf5zki50x7I5O50JekZlmLoRoamvXrmXevHksXLiQgwcP0qNHD8aMGUNKSkqN18XExPD4448zdOjQKp8fO3YsiYmJZV9ff/11Y0y/3jom/YwqJwGcA2DovLLjEck5yvPe9uaamhBCCCEamTRDEEIIUWddfJ1YfXcYt326m70xGcxasZcuvk6cS88jJj2f8xn5FBtb6VXB08GKjt4OdPRyoKO3AyHuNpRUf3qNtkak8OafEaTnFjEwxI0h7dwZ0t4dL0frer47IYSpLFmyhDlz5jB79mwAli9fzu+//86KFSt4+umnq7ympKSE22+/nRdffJFt27aRmZlZ6RwrKyu8vb1rNYfCwkIKCwvLHmdnZwOg0+nQ6Uy//b046TghKRuU+6NexYAFlL7OqYQsANp52DXKa19NjOsj61R/soYNJ2toGrKODSdraBoNXcfaXieBNiGEEPXSrY0TX97Vnxmf7WVfzAX2xVyo8LyVhZpAN1uC3OzwcbIm7sJFIpJziLtwkZScQlJyCtl2Jq3sfDcrDbme55nWPxArC80VX/9ceh4v/XaSzSeTy479dCienw7FA9De054h7d0Z2t6d/sFu2FvJf3lCNKWioiIOHDjA/Pnzy46p1WpGjhzJrl27qr1u0aJFeHp6cvfdd7Nt27Yqz9m6dSuenp64uLhw7bXX8vLLL+Pm5lbluYsXL+bFF1+sdHzjxo3Y2trW8V1dgcHAoMjXsaGERMde7I3UQ+T6sqd3nlADagqTz7J+fbRpX/sqtWnTJnNPocWTNWw4WUPTkHVsOFlD06jvOubn59fqPPnUIYQQot56Bbiw+p4wVu44i5ejNYFudgS5K8E1b0dr1OrKXfRyCnScScklIimn7OtYQhbpBcUs+OUky7ZGc++wEG7rH4CNZeWAW35RMcv+juSTf89SVKLHQq1i9uAghnfwZGdUGtsj0zgan8WZlFzOpOTy+Y4YLNQqhrR357Wp3fF2kkw3IZpCWloaJSUleHl5gbVFQQAAJk1JREFUVTju5eXFqVOnqrxm+/btfPbZZ4SHh1c77tixY5k6dSrBwcFERUXxzDPPMG7cOHbt2oVGU/nfjPnz5zNvXvn2zezsbPz9/Rk9ejSOjiZuRpCThOZsLiUqLc63Lme8R0iFp1899g9QyNSRA+nl72za177K6HQ6Nm3axKhRo9BqteaeToska9hwsoamIevYcLKGptHQdTRmxV+JBNqEEEI0SE9/Z5be2qvW5ztYa+kd4ELvAJeyY9l5BbywaiM7MmxJzi7kpd9O8MHfkdw1JJiZAwNxsNZiMBj49Ugir/5+kqTsAgCGtndn4YQutPNU6h0Nae/Ok0BmfhE7o9LZHpnG9jNpxGbkszUilUnLtvPpzH50a+Nk0jUQQjRcTk4OM2bM4JNPPsHd3b3a82699day+926daN79+6EhISwdetWrrvuukrnW1lZYWVVufGAVqs1/YcVV3909+1gz48fEOYRUmH8zPwiknOULayd/VzQauXH8NpolD+nVkbWsOFkDU1D1rHhZA1No77rWNtr5H94IYQQZmdjqWG4j4FFs4by69FkPtwaRWxGPm/+GcFH/0Rxx4BA9p+7wN6zGQD4u9rw/PWdGdXZC5Wqctacs60l47v5ML6bDwCnk3N46KuDnEnJ5ZaPdvH2tJ6M7Vq7+k5CiPpxd3dHo9GQnJxc4XhycnKV9dWioqKIiYlhwoQJZcf0ej0AFhYWREREEBISUum6tm3b4u7uTmRkZJWBtiantSHdoVOlwxFJSiOENi42spVdCCGEuIpJ11EhhBDNhpWFmun9A/jrv8N5e1oP2nnak11QzAdbo9h7NgNrrZr/jurApseGM7qLd5VBtqp08HLghwcHMayDBxd1Jdy/+gAfbo3CYKhnBwYhxBVZWlrSp08ftmzZUnZMr9ezZcsWBg4cWOn80NBQjh49Snh4eNnXxIkTGTFiBOHh4fj7+1f5OnFxcaSnp+Pj49No78UUThs7jno5mHkmQgghhGhM8us0IYQQzY6FRs2UXm2Y1MOPP48nsWLHWdq42PLEmI74OtvUa0xHay0rZvVl0W8n+HLXOV7fcIqo1FxendINSwv5vZMQjWHevHnMmjWLvn370r9/f5YuXUpeXl5ZF9KZM2fi5+fH4sWLsba2pmvXrhWud3Z2Big7npuby4svvsiNN96It7c3UVFRPPnkk7Rr144xY8Y06Xurq4jSQFsHbwm0CSGEEFczCbQJIYRottRqFeO6+TCum2kyVSw0ahZN6kqIhz0v/nqc7w/EEZuRz/I7+uBqZ2mS1xBClJs2bRqpqaksWLCApKQkevbsyYYNG8oaJMTGxqJW1z7QrdFoOHLkCF988QWZmZn4+voyevRoXnrppSrrsDUnp5NyAcloE0IIIa52EmgTQgjR6swaFESgmy3/WXOIvWczmPLBDj6b1a+sqYIQwnTmzp3L3Llzq3xu69atNV67cuXKCo9tbGz4888/TTSzpmMwGMoz2iTQJoQQQlzVJNAmhBCiVbqmoyc/PDiIu1bu41x6PhPe2063Nk508LKno5cDHbwc6OjtgLOtZLoJIRomObuQrIs6NGoVIZ525p6OEEIIIRqRBNqEEEK0Wh28HFj30GAeWH2AfTFKV1NjZ1MjTwcrOno7EOrtwMhOXvQLckWtrl0TBiGEgPL6bMHudlhZaMw8GyGEEEI0Jgm0CSGEaNXc7a1Ye+9ATiRmcyYlh4ikXE4n5xCRlEN85kVScgpJySlk25k0Ptl2Fh8na27o7sPEHn509XOsdedTIUTrdTpJOo4KIYQQrYUE2oQQQrR6arWKrn5OdPVzqnA8t7CYM8k5nE7OYV/MBf48nkRiVgGfbDvLJ9vO0tbdjgk9fJnY05cQD6nvJoSomtRnE0IIIVoPCbQJIYQQ1bC3sqBXgAu9AlyY1i+Alyd35Z/TqfwSnsDmk8lEp+XxzpYzvLPlDF18HXl5cld6BbiYe9pCiGbmdGmgraO3BOSFEEKIq13t+6k3kmXLlhEUFIS1tTVhYWHs3bu3xvOXLl1Kx44dsbGxwd/fn8cee4yCgoKy51944QVUKlWFr9DQ0MZ+G0IIIVoBa62GMV28WXZ7bw48P4q3p/VgREcPLNQqjidkM+fLA6TkFFx5ICFEq6HXG8oCbZLRJoQQQlz9zBpoW7t2LfPmzWPhwoUcPHiQHj16MGbMGFJSUqo8f82aNTz99NMsXLiQkydP8tlnn7F27VqeeeaZCud16dKFxMTEsq/t27c3xdsRQgjRithbWTClVxs+n92fvc+OJNTbgbTcQh75OpwSvcHc0xNCNBOxGfkU6PRYWqgJdJOOo0IIIcTVzqyBtiVLljBnzhxmz55N586dWb58Oba2tqxYsaLK83fu3MngwYO57bbbCAoKYvTo0UyfPr1SFpyFhQXe3t5lX+7u7k3xdoQQQrRSrnaWLLu9N7aWGnZFp/PeX2fMPSUhRDNhrM/W3tMejXQsFkIIIa56ZqvRVlRUxIEDB5g/f37ZMbVazciRI9m1a1eV1wwaNIjVq1ezd+9e+vfvT3R0NOvXr2fGjBkVzjtz5gy+vr5YW1szcOBAFi9eTEBAQLVzKSwspLCwsOxxdnY2ADqdDp1O15C3WSXjmI0xdmsha2gaso4NJ2toGlfDOgY4W7FoQice/+EY72w5Q29/Rwa2dWuy178a1rA5aMg6ytqLqpR1HPWWbaNCCCFEa2C2QFtaWholJSV4eXlVOO7l5cWpU6eqvOa2224jLS2NIUOGYDAYKC4u5v7776+wdTQsLIyVK1fSsWNHEhMTefHFFxk6dCjHjh3DwaHqH3AWL17Miy++WOn4xo0bsbW1bcC7rNmmTZsabezWQtbQNGQdG07W0DRa+jpqgQGeananqJm7ej9PdC/B0bLh457MVLEuRk2JAYZ46xngYcC6mv/BW/oaNhf1Wcf8/PxGmIlo6YwZbR2lPpsQQgjRKrSorqNbt27l1Vdf5YMPPiAsLIzIyEgeeeQRXnrpJZ5//nkAxo0bV3Z+9+7dCQsLIzAwkG+//Za77767ynHnz5/PvHnzyh5nZ2fj7+/P6NGjcXR0NPn70Ol0bNq0iVGjRqHVak0+fmsga2gaso4NJ2toGlfTOo4oKuGmj/ZwOiWXPzI9WTGzT723i8VnXuSV9RFsOlleu/SnGA0bEzXc1NuPGQMCCHRVfiF0Na2hOTVkHY0Z8UJcqqwRgmS0CSGEEK2C2QJt7u7uaDQakpOTKxxPTk7G29u7ymuef/55ZsyYwT333ANAt27dyMvL49577+XZZ59Fra5ccs7Z2ZkOHToQGRlZ7VysrKywsrKqdFyr1Tbqh5XGHr81kDU0DVnHhpM1NI2rYR21Wi0f3NGbCe/tYGdUBp9sP8d/rmtfpzEKdCV88m80y7ZGUqDTo1GrmDUwiGAPO1buOEtUah5f7Irly92xjOzkxV2Dg+nj71D2+g1ZQ73eQNZFHel5RVzILyI9V7nNyCviYlEJt/b3p41L42V7Nxf1WceW/r0rTK+oWE90ah4gGW1CCCFEa2G2QJulpSV9+vRhy5YtTJ48GQC9Xs+WLVuYO3duldfk5+dXCqZpNBoADIaqO7zl5uYSFRVVqY6bEEII0VjaeTrw8uSu/Pe7w7y9+TT9gl0ZUMt6bX+fSuHFX48Tk65sQ+wf7MqiSV0I9VYyrG/vH8C2yDRWbD/LP6dT2XQimU0nkgn1sqeLjQq3sxl08HHCw94KlarmTLqkrALCz2dyOC6TI3GZRCTlkJFXRE1NU/fFZPDNvQOuOLYQAqLTcinWG3CwssDHydrc0xFCCCFEEzDr1tF58+Yxa9Ys+vbtS//+/Vm6dCl5eXnMnj0bgJkzZ+Ln58fixYsBmDBhAkuWLKFXr15lW0eff/55JkyYUBZwe/zxx5kwYQKBgYEkJCSwcOFCNBoN06dPN9v7FEII0frc2KcNu6LT+f5AHA9/fYj1jwzF3b5y9jQovyyKSc/nld9Psvmkkunt6WDFs9d3YmIP3wpBLbVaxfAOHgzv4EFkSi4rd57lhwPxnErO5RQaflixHwAHKwvaetjR1sOetu52hHjaY2dlwbH4LA6XBteSswurnA+Ag7UFbnaWuNhZ4mqr3P4SnsCesxlsj0xjaHsPE66WEFeniKTybaMSnBZCCCFaB7MG2qZNm0ZqaioLFiwgKSmJnj17smHDhrIGCbGxsRUy2J577jlUKhXPPfcc8fHxeHh4MGHCBF555ZWyc+Li4pg+fTrp6el4eHgwZMgQdu/ejYeHfCAQQgjRtBZN6sLh85mcScnlsbXhfH5nPxKzCohMzSUqJZfIlFzOlN5mXVQ6VlqoVcweHMTD17XHwbrmrYjtPO15eXI3Hh/dkTV7Yvh1TwS5KjviMy+SU1jM4bgsDsdlVXu9WgUdvBzo6e9MD39nuvo64eVohbOtJZYWlcsx2FtZsHJnDG/9GcGQdu4SOBDiCoz12aTjqBBCCNF6mL0Zwty5c6vdKrp169YKjy0sLFi4cCELFy6sdrxvvvnGlNMTQggh6s3W0oJlt/dm4vvb2XYmjc4L/qSoRF/luSoVDGnnzoIbOtO+jrWcnG0tmTMkGL/sk4wfP5QS1JxLzyc6NZfotDyiUnOJTs0ju0BHZx/HssBaF19HbC1r/6PAQyPasXbfeQ7HZbHpRDKju1RdU/X/7d17dNT1ue/xzySZTC6QC4TcIECAGG4GlUCMwK5KAGkXgqJid7Qp7SkFgwXR3cqqXE81HNtSiocGsSq2egzC3lC8gKZcorK4BiIoEAKGSw1JQISEBEKafM8fyKxOA5JkfmEm5P1aa9bK/G555rOSNQ8P38wPwGWFpecl8flsAAC0JR4ftAEAcDO7Jaq9/vfY/vqvVXt1qa5edl+buncMVkJUO/Xq1E49I9upV2Q79ezUTgF2X0u+Z4DdV4nR7S1fRdOpvUMTh3TXnzYf0e8/OqS0PlHyaeYdVYG2wHnHUQZtAAC0GQzaAABoYQ8nx+nWLqGy+/qoa4cg2X0b/llma/Hz/+ipv247psKySr27t0Rjb+vs6ZIAr1RV808dP3P5pia3RLXzcDUAAOBGab2dPgAArUjv6BD17NSuVQ/ZJCk0yK5Jw3pIkv6Qe0i11/hTWKCtO3yqSpIU0c6hjte4EQoAALj5tO5uHwAA3HATh8arY7C/jn5drf/O/4enywG80qGybz+fLZrVbAAAtCUM2gAAQJO0c/hpyt09JUmLNxTpYm2dhysCvE9R+eVBG5/PBgBA28KgDQAANNljd3ZTdEiASs5d1P/bftzT5QBe58qKtt4W35QEAAB4NwZtAACgyQLsvnpyeC9J0p82H1b1pX96uCLAu7CiDQCAtolBGwAAaJZHkuPUtUOQTp+/pNe3HP3OY40x+qLknE58exdG4GZWVSuVV9ZIkhIYtAEA0Kb4eboAAADQOtl9ffTUiAQ9teIzvZx3RI/d2U2hgXaXYyov1mr1nq/0163HnCt8hvTqqB8O7qoRfaPk8PP1ROlAizr57Ty5S3ig2jlotwEAaEt45wcAAM12/4DO+tOmIyoqP69XPv5Sz4xKlCQdKqvUX7ce0//s/oeqLl2+WUKA3Uc1/6zXlsNfa8vhr9Uh2F8PDeyiCYPi1LMTd2bEzePkBZskKZHVbAAAtDkM2gAAQLP5+tj09MhETX4zX69tKVa3jkFalf8PbS8+4zymZ6dgPX5nNz04sIvOVdfqnV0n9M6uEyqrqNGyj7/Uso+/VEp8B/1wcFfd1z9aAXZWuaF1O1l9edB2CzdCAACgzWHQBgAA3DKqX5SSuoRq7z/O6b9W7ZV0eQA3ok+UHk/tprt6dpTNdnnwEBJg19MjEzVteII2FZ5Szo7j2lRYru3FZ7S9+Iwi3vfXz/+jp9Lv7Kogf9oUtE5XBm2saAMAoO2hgwUAAG6x2Wx6dnRv/ejVHQoL8tcPB8fpP1O6KiY08Jrn+Pn6aETfKI3oG6WSsxcur3LbeUIl5y7q+Q8OaGneEf38ez302J3dGLihVTHGOD+jLZEVbQAAtDl0rgAAwG139YzQzl+nKdjhJ3+/pt3UPDYsUNPTblHmPb20evdXemlTkU6cuaAXPjiol/O+ZOCGVqW0okYX6mzy9bGpR6dgT5cDAABusKZ1wgAAANcQHuzf5CHbv7L7+uiRQXHa+PTdevGhJHXtEKSvqy7phQ8Oatj/2aSX846o+tI/LawYsN6Vu+t27xjEXXUBAGiD+K9hAADgVey+PnokOU4P3N5Za/Z8pZc2HtbxM9XKWndQL208rNSeHTUsIUJDe0UoPiLY+flv11JWcVE7is9oR/EZ7Tx6Rr+8L1H39o66Qa8Gbc2hssuDtlsiuZMuAABtEYM2AADgley+Pno4OU7jvh24/d9Nh3Xs62rl7i9T7v4ySVLnsEAN7RWhoQkRGtIrQuFBdh39ulo7i89ox9HLw7XjZ6pdrrv9yzMM2tBiDn27oi0hikEbAABtEYM2AADg1a4M3B68o4u+KDmnT4pO69Oi08o/9o2+OntBK3ad0IpdJ2SzSaGBdp2trnU538cm9YkJ0aDuHTQ4/vIDaClFrGgDAKBN4zPaAABAq+DrY1NSlzBl3tNLb0+6UwVzRmj5xEH6X0Pj1Tu6vYyRzlbXyt/XR4O6h+uJu3tq+cRBKpgzUu//Ypjm3t9P3781RhHtHJ5+KW3KkiVL1L17dwUEBCglJUU7duxo1Hk5OTmy2WwaN26cy3ZjjGbPnq2YmBgFBgYqLS1NRUVFLVB509XVGx0+dXnQlhjNoA0AgLaIFW0AAKBVCvL3092Jkbo7MVKSVF55USfPXlRidHsF2PkQem+wYsUKzZgxQ0uXLlVKSooWLVqkUaNGqbCwUJGRkdc87+jRo3rmmWc0bNiwBvtefPFFLV68WG+88Ybi4+M1a9YsjRo1Svv371dAQEBLvpzrskn6n5/fqRUffqK48CCP1gIAADyDFW0AAOCmENk+QAPiwhiyeZGFCxfqZz/7mSZOnKi+fftq6dKlCgoK0muvvXbNc+rq6pSenq558+apR48eLvuMMVq0aJGee+45jR07VklJSfrLX/6ikpISrVmzpoVfzfX5+NiUENVOd0QY+fp89006AADAzYkVbQAAALDcpUuXlJ+fr5kzZzq3+fj4KC0tTVu3br3mefPnz1dkZKR++tOf6pNPPnHZV1xcrNLSUqWlpTm3hYaGKiUlRVu3btWjjz7a4Ho1NTWqqalxPq+oqJAk1dbWqra2tsHx7rpyzZa4dltCju4jQ/eRoTXI0X1kaA13c2zseQzaAAAAYLnTp0+rrq5OUVGud3iNiorSwYMHr3rOp59+qldffVUFBQVX3V9aWuq8xr9f88q+f5eVlaV58+Y12P7RRx8pKKjl/rwzNze3xa7dlpCj+8jQfWRoDXJ0Hxlao7k5VldXX/8gMWgDAACAF6isrNTjjz+uV155RREREZZdd+bMmZoxY4bzeUVFheLi4jRy5EiFhIRY9n2uqK2tVW5urkaMGCG73W759dsKcnQfGbqPDK1Bju4jQ2u4m+OVVfHXw6ANAAAAlouIiJCvr6/KyspctpeVlSk6OrrB8UeOHNHRo0c1ZswY57b6+npJkp+fnwoLC53nlZWVKSYmxuWat91221XrcDgccjga3mnWbre36D9WWvr6bQU5uo8M3UeG1iBH95GhNZqbY2PP4WYIAAAAsJy/v78GDhyoDRs2OLfV19drw4YNSk1NbXB87969tW/fPhUUFDgf999/v+655x4VFBQoLi5O8fHxio6OdrlmRUWFtm/fftVrAgAA3GisaAMAAECLmDFjhjIyMpScnKzBgwdr0aJFqqqq0sSJEyVJP/rRj9S5c2dlZWUpICBA/fv3dzk/LCxMkly2T58+Xb/5zW+UkJCg+Ph4zZo1S7GxsRo3btyNelkAAADXxKANAAAALWLChAk6deqUZs+erdLSUt12221av36982YGx48fl49P0/7A4pe//KWqqqo0adIknT17VkOHDtX69esVEBDQEi8BAACgSRi0AQAAoMVMnTpVU6dOveq+zZs3f+e5y5cvb7DNZrNp/vz5mj9/vgXVAQAAWIvPaAMAAAAAAAAswKANAAAAAAAAsACDNgAAAAAAAMACDNoAAAAAAAAACzBoAwAAAAAAACzAoA0AAAAAAACwgJ+nC/BGxhhJUkVFRYtcv7a2VtXV1aqoqJDdbm+R73GzI0NrkKP7yNAa5Og+MrSGOzle6Ruu9BHwTvR5rQM5uo8M3UeG1iBH95GhNdzNsbG9HoO2q6isrJQkxcXFebgSAADQ2lRWVio0NNTTZeAa6PMAAIA7rtfr2Qz/7dpAfX29SkpK1L59e9lsNsuvX1FRobi4OJ04cUIhISGWX78tIENrkKP7yNAa5Og+MrSGOzkaY1RZWanY2Fj5+PDpHN6KPq91IEf3kaH7yNAa5Og+MrSGuzk2ttdjRdtV+Pj4qEuXLi3+fUJCQvglcRMZWoMc3UeG1iBH95GhNZqbIyvZvB99XutCju4jQ/eRoTXI0X1kaA13cmxMr8d/twIAAAAAAAAWYNAGAAAAAAAAWIBBmwc4HA7NmTNHDofD06W0WmRoDXJ0HxlagxzdR4bWIEe4i58ha5Cj+8jQfWRoDXJ0Hxla40blyM0QAAAAAAAAAAuwog0AAAAAAACwAIM2AAAAAAAAwAIM2gAAAAAAAAALMGgDAAAAAAAALMCgzQOWLFmi7t27KyAgQCkpKdqxY4enS/JaH3/8scaMGaPY2FjZbDatWbPGZb8xRrNnz1ZMTIwCAwOVlpamoqIizxTrpbKysjRo0CC1b99ekZGRGjdunAoLC12OuXjxojIzM9WxY0e1a9dO48ePV1lZmYcq9k7Z2dlKSkpSSEiIQkJClJqaqnXr1jn3k2HTLViwQDabTdOnT3duI8fvNnfuXNlsNpdH7969nfvJr/G++uorPfbYY+rYsaMCAwN16623ateuXc79vL+guejzGo8+z330edagz7MefV7z0OtZw9N9HoO2G2zFihWaMWOG5syZo927d2vAgAEaNWqUysvLPV2aV6qqqtKAAQO0ZMmSq+5/8cUXtXjxYi1dulTbt29XcHCwRo0apYsXL97gSr1XXl6eMjMztW3bNuXm5qq2tlYjR45UVVWV85innnpK7777rlauXKm8vDyVlJTowQcf9GDV3qdLly5asGCB8vPztWvXLt17770aO3asvvjiC0lk2FQ7d+7Uyy+/rKSkJJft5Hh9/fr108mTJ52PTz/91LmP/Brnm2++0ZAhQ2S327Vu3Trt379fv//97xUeHu48hvcXNAd9XtPQ57mPPs8a9HnWos9zD72ee7yizzO4oQYPHmwyMzOdz+vq6kxsbKzJysryYFWtgySzevVq5/P6+noTHR1tfvvb3zq3nT171jgcDvP22297oMLWoby83EgyeXl5xpjLmdntdrNy5UrnMQcOHDCSzNatWz1VZqsQHh5u/vznP5NhE1VWVpqEhASTm5trvve975lp06YZY/hZbIw5c+aYAQMGXHUf+TXer371KzN06NBr7uf9Bc1Fn9d89HnWoM+zDn1e89DnuYdez33e0Oexou0GunTpkvLz85WWlubc5uPjo7S0NG3dutWDlbVOxcXFKi0tdckzNDRUKSkp5Pkdzp07J0nq0KGDJCk/P1+1tbUuOfbu3Vtdu3Ylx2uoq6tTTk6OqqqqlJqaSoZNlJmZqR/84AcueUn8LDZWUVGRYmNj1aNHD6Wnp+v48eOSyK8p1q5dq+TkZD388MOKjIzU7bffrldeecW5n/cXNAd9nrX4PWwe+jz30ee5hz7PffR67vGGPo9B2w10+vRp1dXVKSoqymV7VFSUSktLPVRV63UlM/JsvPr6ek2fPl1DhgxR//79JV3O0d/fX2FhYS7HkmND+/btU7t27eRwODR58mStXr1affv2JcMmyMnJ0e7du5WVldVgHzleX0pKipYvX67169crOztbxcXFGjZsmCorK8mvCb788ktlZ2crISFBH374oaZMmaJf/OIXeuONNyTx/oLmoc+zFr+HTUef5x76PPfR57mPXs993tDn+VlyFQCtQmZmpj7//HOXv/NH4yUmJqqgoEDnzp3TqlWrlJGRoby8PE+X1WqcOHFC06ZNU25urgICAjxdTqs0evRo59dJSUlKSUlRt27d9M477ygwMNCDlbUu9fX1Sk5O1gsvvCBJuv322/X5559r6dKlysjI8HB1ANA89Hnuoc9zD32eNej13OcNfR4r2m6giIgI+fr6NrgrSFlZmaKjoz1UVet1JTPybJypU6fqvffe06ZNm9SlSxfn9ujoaF26dElnz551OZ4cG/L391evXr00cOBAZWVlacCAAfrjH/9Iho2Un5+v8vJy3XHHHfLz85Ofn5/y8vK0ePFi+fn5KSoqihybKCwsTLfccosOHz7Mz2ETxMTEqG/fvi7b+vTp4/zTDN5f0Bz0edbi97Bp6PPcR5/nHvq8lkGv13Te0OcxaLuB/P39NXDgQG3YsMG5rb6+Xhs2bFBqaqoHK2ud4uPjFR0d7ZJnRUWFtm/fTp7/whijqVOnavXq1dq4caPi4+Nd9g8cOFB2u90lx8LCQh0/fpwcr6O+vl41NTVk2EjDhw/Xvn37VFBQ4HwkJycrPT3d+TU5Ns358+d15MgRxcTE8HPYBEOGDFFhYaHLtkOHDqlbt26SeH9B89DnWYvfw8ahz2s59HlNQ5/XMuj1ms4r+jxLbqmARsvJyTEOh8MsX77c7N+/30yaNMmEhYWZ0tJST5fmlSorK82ePXvMnj17jCSzcOFCs2fPHnPs2DFjjDELFiwwYWFh5m9/+5vZu3evGTt2rImPjzcXLlzwcOXeY8qUKSY0NNRs3rzZnDx50vmorq52HjN58mTTtWtXs3HjRrNr1y6TmppqUlNTPVi193n22WdNXl6eKS4uNnv37jXPPvussdls5qOPPjLGkGFz/evdqIwhx+t5+umnzebNm01xcbHZsmWLSUtLMxEREaa8vNwYQ36NtWPHDuPn52eef/55U1RUZN566y0TFBRk3nzzTecxvL+gOejzmoY+z330edagz2sZ9HlNR6/nPm/o8xi0ecBLL71kunbtavz9/c3gwYPNtm3bPF2S19q0aZOR1OCRkZFhjLl8a95Zs2aZqKgo43A4zPDhw01hYaFni/YyV8tPknn99dedx1y4cME88cQTJjw83AQFBZkHHnjAnDx50nNFe6Gf/OQnplu3bsbf39906tTJDB8+3Nl8GUOGzfXvDRg5frcJEyaYmJgY4+/vbzp37mwmTJhgDh8+7NxPfo337rvvmv79+xuHw2F69+5tli1b5rKf9xc0F31e49HnuY8+zxr0eS2DPq/p6PWs4ek+z2aMMdasjQMAAAAAAADaLj6jDQAAAAAAALAAgzYAAAAAAADAAgzaAAAAAAAAAAswaAMAAAAAAAAswKANAAAAAAAAsACDNgAAAAAAAMACDNoAAAAAAAAACzBoAwAAAAAAACzAoA0AWojNZtOaNWs8XQYAAAAsRp8H4FoYtAG4Kf34xz+WzWZr8Ljvvvs8XRoAAADcQJ8HwJv5eboAAGgp9913n15//XWXbQ6Hw0PVAAAAwCr0eQC8FSvaANy0HA6HoqOjXR7h4eGSLi/3z87O1ujRoxUYGKgePXpo1apVLufv27dP9957rwIDA9WxY0dNmjRJ58+fdznmtddeU79+/eRwOBQTE6OpU6e67D99+rQeeOABBQUFKSEhQWvXrnXu++abb5Senq5OnTopMDBQCQkJDRpGAAAANESfB8BbMWgD0GbNmjVL48eP12effab09HQ9+uijOnDggCSpqqpKo0aNUnh4uHbu3KmVK1fq73//u0uDlZ2drczMTE2aNEn79u3T2rVr1atXL5fvMW/ePD3yyCPau3evvv/97ys9PV1nzpxxfv/9+/dr3bp1OnDggLKzsxUREXHjAgAAALhJ0ecB8BgDADehjIwM4+vra4KDg10ezz//vDHGGElm8uTJLuekpKSYKVOmGGOMWbZsmQkPDzfnz5937n///feNj4+PKS0tNcYYExsba379619fswZJ5rnnnnM+P3/+vJFk1q1bZ4wxZsyYMWbixInWvGAAAIA2gj4PgDfjM9oA3LTuueceZWdnu2zr0KGD8+vU1FSXfampqSooKJAkHThwQAMGDFBwcLBz/5AhQ1RfX6/CwkLZbDaVlJRo+PDh31lDUlKS8+vg4GCFhISovLxckjRlyhSNHz9eu3fv1siRIzVu3DjdddddzXqtAAAAbQl9HgBvxaANwE0rODi4wRJ/qwQGBjbqOLvd7vLcZrOpvr5ekjR69GgdO3ZMH3zwgXJzczV8+HBlZmbqd7/7neX1AgAA3Ezo8wB4Kz6jDUCbtW3btgbP+/TpI0nq06ePPvvsM1VVVTn3b9myRT4+PkpMTFT79u3VvXt3bdiwwa0aOnXqpIyMDL355ptatGiRli1b5tb1AAAAQJ8HwHNY0QbgplVTU6PS0lKXbX5+fs4Pol25cqWSk5M1dOhQvfXWW9qxY4deffVVSVJ6errmzJmjjIwMzZ07V6dOndKTTz6pxx9/XFFRUZKkuXPnavLkyYqMjNTo0aNVWVmpLVu26Mknn2xUfbNnz9bAgQPVr18/1dTU6L333nM2gAAAALg2+jwA3opBG4Cb1vr16xUTE+OyLTExUQcPHpR0+U5ROTk5euKJJxQTE6O3335bffv2lSQFBQXpww8/1LRp0zRo0CAFBQVp/PjxWrhwofNaGRkZunjxov7whz/omWeeUUREhB566KFG1+fv76+ZM2fq6NGjCgwM1LBhw5STk2PBKwcAALi50ecB8FY2Y4zxdBEAcKPZbDatXr1a48aN83QpAAAAsBB9HgBP4jPaAAAAAAAAAAswaAMAAAAAAAAswJ+OAgAAAAAAABZgRRsAAAAAAABgAQZtAAAAAAAAgAUYtAEAAAAAAAAWYNAGAAAAAAAAWIBBGwAAAAAAAGABBm0AAAAAAACABRi0AQAAAAAAABZg0AYAAAAAAABY4P8DQ2ByjdduA8cAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 1500x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_metrics(epochs = EPOCHS,metrics = output_metrics)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "vmGSPEs3pJge"
      },
      "outputs": [],
      "source": [
        "test_loss, test_accuracy = inference(alex_net_do, test_dataloader, loss_criteria)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aqs6lJTxpQOu",
        "outputId": "3fff3546-f90d-495d-b443-fcadb5a7a47e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy is: 0.7138761524111032\n"
          ]
        }
      ],
      "source": [
        "print('Test Accuracy is: {0}'.format(test_accuracy))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "WkS9ouKNpT6n"
      },
      "outputs": [],
      "source": [
        "torch.save(alex_net_do.state_dict(), 'sadapala_assignment1_part_4.pickle')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "C7J2UWEIpkfd"
      },
      "outputs": [],
      "source": [
        "del(alex_net_do)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "execution_count": 33,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "alex_net_do.load_state_dict(torch.load('models/sadapala_assignment1_part_4.pickle', map_location=DEVICE))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {},
      "outputs": [],
      "source": [
        "test_dataloader = DataLoader(test_dataset, batch_size=len(test_dataset))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {},
      "outputs": [],
      "source": [
        "for images, labels in test_dataloader:\n",
        "    images = images.to(DEVICE)\n",
        "    labels = labels.to(DEVICE)\n",
        "    alex_net_do.train(False)\n",
        "    with torch.inference_mode():\n",
        "        y_hat = alex_net_do(images)\n",
        "    break"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Confusion Matrix, Precision, Recall and F1 Score."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[236,  10,   2,   2],\n",
              "       [ 19, 212,   6,  13],\n",
              "       [115,   8,  27, 100],\n",
              "       [ 12,   2,   5, 231]])"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "confusion_matrix(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Precision (Micro): 0.706\n",
            "Precision (Macro): 0.7185560520930407\n",
            "Precision (Weighted): 0.7185560520930407\n"
          ]
        }
      ],
      "source": [
        "print(\"Precision (Micro):\", precision_score(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy(), average='micro'))\n",
        "print(\"Precision (Macro):\", precision_score(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy(), average='macro'))\n",
        "print(\"Precision (Weighted):\", precision_score(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy(), average='weighted'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Recall (Micro): 0.706\n",
            "Recall (Macro): 0.706\n",
            "Recall (Weighted): 0.706\n"
          ]
        }
      ],
      "source": [
        "print(\"Recall (Micro):\", recall_score(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy(), average='micro'))\n",
        "print(\"Recall (Macro):\", recall_score(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy(), average='macro'))\n",
        "print(\"Recall (Weighted):\", recall_score(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy(), average='weighted'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "F1 Score (Micro): 0.706\n",
            "F1 Score (Macro): 0.6469695436542823\n",
            "F1 Score (Weighted): 0.6469695436542824\n"
          ]
        }
      ],
      "source": [
        "print(\"F1 Score (Micro):\", f1_score(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy(), average='micro'))\n",
        "print(\"F1 Score (Macro):\", f1_score(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy(), average='macro'))\n",
        "print(\"F1 Score (Weighted):\", f1_score(labels.to(device='cpu').numpy(),torch.argmax(y_hat, axis=1).to(device='cpu').numpy(), average='weighted'))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### References:\n",
        "\n",
        "* Part 4 and Part 5 Architecture and Helper Functions are based CSE 574 Machine Learning Assignment 2 by Shri Harsha Adapala Thirumala.\n",
        "* Numpy: https://numpy.org/doc/stable/\n",
        "* Pandas: https://pandas.pydata.org/docs/reference/index.html\n",
        "* Matplotlib: https://matplotlib.org/stable/api/index.html\n",
        "* Seaborn: https://seaborn.pydata.org/api.html\n",
        "* PyTorch: https://pytorch.org/docs/stable/index.html\n",
        "* TorchVision: https://pytorch.org/vision/stable/index.html\n",
        "* TorchMetrics: https://torchmetrics.readthedocs.io/en/stable/\n",
        "* AlexNet: https://proceedings.neurips.cc/paper/2012/file/c399862d3b9d6b76c8436e924a68c45b-Paper.pdf\n",
        "* Earlystopping: https://www.educative.io/answers/what-is-early-stopping\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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"
    },
    "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 0
}