MLP_CNN_Nikolaos_Evangelidis_10571.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyMsQLXQbcIa4cTXuQXJc1el",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "f0850e4ba881459da7089010152ed54f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_c93c0686ca884d7899905bb1f6738d18",
              "IPY_MODEL_2b748e1170d84e0e98ac8ef48c175269",
              "IPY_MODEL_f76c3c30799b427e9f97782ddeeaf229"
            ],
            "layout": "IPY_MODEL_07280a8ca74a4274a926e34822559f29"
          }
        },
        "c93c0686ca884d7899905bb1f6738d18": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_a2144ce3ce854a4989496aa98acba76d",
            "placeholder": "​",
            "style": "IPY_MODEL_4fced3fe9c794c62a34a5adb5748ff55",
            "value": "100%"
          }
        },
        "2b748e1170d84e0e98ac8ef48c175269": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_30e92f95d9de4f5ca7f46355030173c7",
            "max": 10,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_6f62000e9b6543b3b5732608b54216e1",
            "value": 10
          }
        },
        "f76c3c30799b427e9f97782ddeeaf229": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_3e8a1cbfad7243f993ecec03c6f7478b",
            "placeholder": "​",
            "style": "IPY_MODEL_73d145d56ca045beb43bd109df92b10c",
            "value": " 10/10 [02:21&lt;00:00, 13.17s/it]"
          }
        },
        "07280a8ca74a4274a926e34822559f29": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a2144ce3ce854a4989496aa98acba76d": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "4fced3fe9c794c62a34a5adb5748ff55": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "30e92f95d9de4f5ca7f46355030173c7": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "6f62000e9b6543b3b5732608b54216e1": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "3e8a1cbfad7243f993ecec03c6f7478b": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "73d145d56ca045beb43bd109df92b10c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Nickevang/Tetris_project/blob/master/MLP_CNN_Nikolaos_Evangelidis_10571.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Νευρωνικά Δίκτυα - Βαθιά Μάθηση\n",
        "## 1η Εργασία\n",
        "### Νικόλαος Ευαγγελίδης 10571\n",
        "\n",
        "Να γραφεί πρόγραμμα σε οποιαδήποτε γλώσσα προγραμματισμού το οποίο να υλοποιεί ένα νευρωνικό δίκτυο πολυστρωματικού perceptron (το δίκτυο μπορεί να είναι πλήρως συνδεδεμένο ή συνελικτικό ή συνδυασμός) που θα εκπαιδεύεται με τον αλγόριθμο back-propagation. Το ΝΝ αυτό θα εκπαιδευτεί για να επιλύει οποιοδήποτε πρόβλημα κατηγοριοποίησης πολλών κλάσεων ΕΚΤΟΣ MNIST.\n",
        "Σε αυτή την εργασία δημιουργείται ένα μοντέλο CNN που λειτουργεί με τον αλγόριθμο Back-Probagation για την κατηγοριοποίηση του cifar-10 dataset. Χρησιμοποιήθηκε το Framework PyTorch"
      ],
      "metadata": {
        "id": "JT1CcJMT5FYt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Imports***\n"
      ],
      "metadata": {
        "id": "zypOaoer6YPt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision\n",
        "from torch import device\n",
        "from timeit import default_timer as timer\n",
        "from torchvision import datasets\n",
        "import torchvision.transforms as transforms\n",
        "from torchvision.transforms import ToTensor\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import pandas as pd\n",
        "from sklearn.decomposition import PCA\n",
        "import requests\n",
        "from pathlib import Path\n",
        "from tqdm.auto import tqdm\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.metrics import make_scorer, accuracy_score, precision_score, recall_score, f1_score\n",
        "from skorch import NeuralNetClassifier\n",
        "from skorch.callbacks import EpochScoring\n",
        "from pyexpat import model\n",
        "\n"
      ],
      "metadata": {
        "id": "Y_eSDJht5KIT"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Helper Functions###"
      ],
      "metadata": {
        "id": "4XIIsVa-6ecf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "A series of helper functions used throughout the course.\n",
        "\n",
        "If a function gets defined once and could be used over and over, it'll go in here.\n",
        "\"\"\"\n",
        "\n",
        "# Walk through an image classification directory and find out how many files (images)\n",
        "# are in each subdirectory.\n",
        "import os\n",
        "\n",
        "def walk_through_dir(dir_path):\n",
        "    \"\"\"\n",
        "    Walks through dir_path returning its contents.\n",
        "    Args:\n",
        "    dir_path (str): target directory\n",
        "\n",
        "    Returns:\n",
        "    A print out of:\n",
        "      number of subdiretories in dir_path\n",
        "      number of images (files) in each subdirectory\n",
        "      name of each subdirectory\n",
        "    \"\"\"\n",
        "    for dirpath, dirnames, filenames in os.walk(dir_path):\n",
        "        print(f\"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'.\")\n",
        "\n",
        "def plot_decision_boundary(model: torch.nn.Module, X: torch.Tensor, y: torch.Tensor):\n",
        "    \"\"\"Plots decision boundaries of model predicting on X in comparison to y.\n",
        "\n",
        "    Source - https://madewithml.com/courses/foundations/neural-networks/ (with modifications)\n",
        "    \"\"\"\n",
        "    # Put everything to CPU (works better with NumPy + Matplotlib)\n",
        "    model.to(\"cpu\")\n",
        "    X, y = X.to(\"cpu\"), y.to(\"cpu\")\n",
        "\n",
        "    # Setup prediction boundaries and grid\n",
        "    x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1\n",
        "    y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1\n",
        "    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101), np.linspace(y_min, y_max, 101))\n",
        "\n",
        "    # Make features\n",
        "    X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()\n",
        "\n",
        "    # Make predictions\n",
        "    model.eval()\n",
        "    with torch.inference_mode():\n",
        "        y_logits = model(X_to_pred_on)\n",
        "\n",
        "    # Test for multi-class or binary and adjust logits to prediction labels\n",
        "    if len(torch.unique(y)) > 2:\n",
        "        y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1)  # mutli-class\n",
        "    else:\n",
        "        y_pred = torch.round(torch.sigmoid(y_logits))  # binary\n",
        "\n",
        "    # Reshape preds and plot\n",
        "    y_pred = y_pred.reshape(xx.shape).detach().numpy()\n",
        "    plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)\n",
        "    plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n",
        "    plt.xlim(xx.min(), xx.max())\n",
        "    plt.ylim(yy.min(), yy.max())\n",
        "\n",
        "\n",
        "# Plot linear data or training and test and predictions (optional)\n",
        "def plot_predictions(\n",
        "    train_data, train_labels, test_data, test_labels, predictions=None\n",
        "):\n",
        "    \"\"\"\n",
        "  Plots linear training data and test data and compares predictions.\n",
        "  \"\"\"\n",
        "    plt.figure(figsize=(10, 7))\n",
        "\n",
        "    # Plot training data in blue\n",
        "    plt.scatter(train_data, train_labels, c=\"b\", s=4, label=\"Training data\")\n",
        "\n",
        "    # Plot test data in green\n",
        "    plt.scatter(test_data, test_labels, c=\"g\", s=4, label=\"Testing data\")\n",
        "\n",
        "    if predictions is not None:\n",
        "        # Plot the predictions in red (predictions were made on the test data)\n",
        "        plt.scatter(test_data, predictions, c=\"r\", s=4, label=\"Predictions\")\n",
        "\n",
        "    # Show the legend\n",
        "    plt.legend(prop={\"size\": 14})\n",
        "\n",
        "\n",
        "# Calculate accuracy (a classification metric)\n",
        "def accuracy_fn(y_true, y_pred):\n",
        "    \"\"\"Calculates accuracy between truth labels and predictions.\n",
        "\n",
        "    Args:\n",
        "        y_true (torch.Tensor): Truth labels for predictions.\n",
        "        y_pred (torch.Tensor): Predictions to be compared to predictions.\n",
        "\n",
        "    Returns:\n",
        "        [torch.float]: Accuracy value between y_true and y_pred, e.g. 78.45\n",
        "    \"\"\"\n",
        "    correct = torch.eq(y_true, y_pred).sum().item()\n",
        "    acc = (correct / len(y_pred)) * 100\n",
        "    return acc\n",
        "\n",
        "\n",
        "def print_train_time(start, end, device=None):\n",
        "    \"\"\"Prints difference between start and end time.\n",
        "\n",
        "    Args:\n",
        "        start (float): Start time of computation (preferred in timeit format).\n",
        "        end (float): End time of computation.\n",
        "        device ([type], optional): Device that compute is running on. Defaults to None.\n",
        "\n",
        "    Returns:\n",
        "        float: time between start and end in seconds (higher is longer).\n",
        "    \"\"\"\n",
        "    total_time = end - start\n",
        "    print(f\"\\nTrain time on {device}: {total_time:.3f} seconds\")\n",
        "    return total_time\n",
        "\n",
        "\n",
        "# Plot loss curves of a model\n",
        "def plot_loss_curves(results):\n",
        "    \"\"\"Plots training curves of a results dictionary.\n",
        "\n",
        "    Args:\n",
        "        results (dict): dictionary containing list of values, e.g.\n",
        "            {\"train_loss\": [...],\n",
        "             \"train_acc\": [...],\n",
        "             \"test_loss\": [...],\n",
        "             \"test_acc\": [...]}\n",
        "    \"\"\"\n",
        "    loss = results[\"train_loss\"]\n",
        "    test_loss = results[\"test_loss\"]\n",
        "\n",
        "    accuracy = results[\"train_acc\"]\n",
        "    test_accuracy = results[\"test_acc\"]\n",
        "\n",
        "    epochs = range(len(results[\"train_loss\"]))\n",
        "\n",
        "    plt.figure(figsize=(15, 7))\n",
        "\n",
        "    # Plot loss\n",
        "    plt.subplot(1, 2, 1)\n",
        "    plt.plot(epochs, loss, label=\"train_loss\")\n",
        "    plt.plot(epochs, test_loss, label=\"test_loss\")\n",
        "    plt.title(\"Loss\")\n",
        "    plt.xlabel(\"Epochs\")\n",
        "    plt.legend()\n",
        "\n",
        "    # Plot accuracy\n",
        "    plt.subplot(1, 2, 2)\n",
        "    plt.plot(epochs, accuracy, label=\"train_accuracy\")\n",
        "    plt.plot(epochs, test_accuracy, label=\"test_accuracy\")\n",
        "    plt.title(\"Accuracy\")\n",
        "    plt.xlabel(\"Epochs\")\n",
        "    plt.legend()\n",
        "\n",
        "\n",
        "# Pred and plot image function from notebook 04\n",
        "# See creation: https://www.learnpytorch.io/04_pytorch_custom_datasets/#113-putting-custom-image-prediction-together-building-a-function\n",
        "from typing import List\n",
        "import torchvision\n",
        "\n",
        "\n",
        "def pred_and_plot_image(\n",
        "    model: torch.nn.Module,\n",
        "    image_path: str,\n",
        "    class_names: List[str] = None,\n",
        "    transform=None,\n",
        "    device: torch.device = \"cuda\" if torch.cuda.is_available() else \"cpu\",\n",
        "):\n",
        "    \"\"\"Makes a prediction on a target image with a trained model and plots the image.\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): trained PyTorch image classification model.\n",
        "        image_path (str): filepath to target image.\n",
        "        class_names (List[str], optional): different class names for target image. Defaults to None.\n",
        "        transform (_type_, optional): transform of target image. Defaults to None.\n",
        "        device (torch.device, optional): target device to compute on. Defaults to \"cuda\" if torch.cuda.is_available() else \"cpu\".\n",
        "\n",
        "    Returns:\n",
        "        Matplotlib plot of target image and model prediction as title.\n",
        "\n",
        "    Example usage:\n",
        "        pred_and_plot_image(model=model,\n",
        "                            image=\"some_image.jpeg\",\n",
        "                            class_names=[\"class_1\", \"class_2\", \"class_3\"],\n",
        "                            transform=torchvision.transforms.ToTensor(),\n",
        "                            device=device)\n",
        "    \"\"\"\n",
        "\n",
        "    # 1. Load in image and convert the tensor values to float32\n",
        "    target_image = torchvision.io.read_image(str(image_path)).type(torch.float32)\n",
        "\n",
        "    # 2. Divide the image pixel values by 255 to get them between [0, 1]\n",
        "    target_image = target_image / 255.0\n",
        "\n",
        "    # 3. Transform if necessary\n",
        "    if transform:\n",
        "        target_image = transform(target_image)\n",
        "\n",
        "    # 4. Make sure the model is on the target device\n",
        "    model.to(device)\n",
        "\n",
        "    # 5. Turn on model evaluation mode and inference mode\n",
        "    model.eval()\n",
        "    with torch.inference_mode():\n",
        "        # Add an extra dimension to the image\n",
        "        target_image = target_image.unsqueeze(dim=0)\n",
        "\n",
        "        # Make a prediction on image with an extra dimension and send it to the target device\n",
        "        target_image_pred = model(target_image.to(device))\n",
        "\n",
        "    # 6. Convert logits -> prediction probabilities (using torch.softmax() for multi-class classification)\n",
        "    target_image_pred_probs = torch.softmax(target_image_pred, dim=1)\n",
        "\n",
        "    # 7. Convert prediction probabilities -> prediction labels\n",
        "    target_image_pred_label = torch.argmax(target_image_pred_probs, dim=1)\n",
        "\n",
        "    # 8. Plot the image alongside the prediction and prediction probability\n",
        "    plt.imshow(\n",
        "        target_image.squeeze().permute(1, 2, 0)\n",
        "    )  # make sure it's the right size for matplotlib\n",
        "    if class_names:\n",
        "        title = f\"Pred: {class_names[target_image_pred_label.cpu()]} | Prob: {target_image_pred_probs.max().cpu():.3f}\"\n",
        "    else:\n",
        "        title = f\"Pred: {target_image_pred_label} | Prob: {target_image_pred_probs.max().cpu():.3f}\"\n",
        "    plt.title(title)\n",
        "    plt.axis(False)\n",
        "\n",
        "def set_seeds(seed: int=42):\n",
        "    \"\"\"Sets random sets for torch operations.\n",
        "\n",
        "    Args:\n",
        "        seed (int, optional): Random seed to set. Defaults to 42.\n",
        "    \"\"\"\n",
        "    # Set the seed for general torch operations\n",
        "    torch.manual_seed(seed)\n",
        "    # Set the seed for CUDA torch operations (ones that happen on the GPU)\n",
        "    torch.cuda.manual_seed(seed)\n",
        "\n",
        "def download_data(source: str,\n",
        "                  destination: str,\n",
        "                  remove_source: bool = True) -> Path:\n",
        "    \"\"\"Downloads a zipped dataset from source and unzips to destination.\n",
        "\n",
        "    Args:\n",
        "        source (str): A link to a zipped file containing data.\n",
        "        destination (str): A target directory to unzip data to.\n",
        "        remove_source (bool): Whether to remove the source after downloading and extracting.\n",
        "\n",
        "    Returns:\n",
        "        pathlib.Path to downloaded data.\n",
        "\n",
        "    Example usage:\n",
        "        download_data(source=\"https://github.com/mrdbourke/pytorch-deep-learning/raw/main/data/pizza_steak_sushi.zip\",\n",
        "                      destination=\"pizza_steak_sushi\")\n",
        "    \"\"\"\n",
        "    # Setup path to data folder\n",
        "    data_path = Path(\"data/\")\n",
        "    image_path = data_path / destination\n",
        "\n",
        "    # If the image folder doesn't exist, download it and prepare it...\n",
        "    if image_path.is_dir():\n",
        "        print(f\"[INFO] {image_path} directory exists, skipping download.\")\n",
        "    else:\n",
        "        print(f\"[INFO] Did not find {image_path} directory, creating one...\")\n",
        "        image_path.mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "        # Download pizza, steak, sushi data\n",
        "        target_file = Path(source).name\n",
        "        with open(data_path / target_file, \"wb\") as f:\n",
        "            request = requests.get(source)\n",
        "            print(f\"[INFO] Downloading {target_file} from {source}...\")\n",
        "            f.write(request.content)\n",
        "\n",
        "        # Unzip pizza, steak, sushi data\n",
        "        with zipfile.ZipFile(data_path / target_file, \"r\") as zip_ref:\n",
        "            print(f\"[INFO] Unzipping {target_file} data...\")\n",
        "            zip_ref.extractall(image_path)\n",
        "\n",
        "        # Remove .zip file\n",
        "        if remove_source:\n",
        "            os.remove(data_path / target_file)\n",
        "\n",
        "    return image_path"
      ],
      "metadata": {
        "id": "2kPpF0pz6W1T"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from timeit import default_timer as timer\n",
        "def print_train_time(start: float, end: float, device: torch.device = None):\n",
        "    \"\"\"Prints difference between start and end time.\n",
        "\n",
        "    Args:\n",
        "        start (float): Start time of computation (preferred in timeit format).\n",
        "        end (float): End time of computation.\n",
        "        device ([type], optional): Device that compute is running on. Defaults to None.\n",
        "\n",
        "    Returns:\n",
        "        float: time between start and end in seconds (higher is longer).\n",
        "    \"\"\"\n",
        "    total_time = end - start\n",
        "    print(f\"Train time on {device}: {total_time:.3f} seconds\")\n",
        "    return total_time"
      ],
      "metadata": {
        "id": "2zQ3BTCm7m_k"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import requests\n",
        "from pathlib import Path\n",
        "\n",
        "# Download helper functions from Learn PyTorch repo (if not already downloaded)\n",
        "if Path(\"helper_functions.py\").is_file():\n",
        "  print(\"helper_functions.py already exists, skipping download\")\n",
        "else:\n",
        "  print(\"Downloading helper_functions.py\")\n",
        "  # Note: you need the \"raw\" GitHub URL for this to work\n",
        "  request = requests.get(\"https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/helper_functions.py\")\n",
        "  with open(\"helper_functions.py\", \"wb\") as f:\n",
        "    f.write(request.content)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fQsKzh6G7rRU",
        "outputId": "6f77bb11-01fd-4a7b-eb66-a8e3576e7b4c"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading helper_functions.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from torch.utils.data import DataLoader\n",
        "\n",
        "# Setup the batch size hyperparameter\n",
        "BATCH_SIZE = 32\n",
        "\n",
        "# Turn datasets into iterables (batches)\n",
        "train_dataloader = DataLoader(train_data, # dataset to turn into iterable\n",
        "    batch_size=BATCH_SIZE, # how many samples per batch?\n",
        "    shuffle=True # shuffle data every epoch?\n",
        ")\n",
        "\n",
        "test_dataloader = DataLoader(test_data,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    shuffle=False # don't necessarily have to shuffle the testing data\n",
        ")\n",
        "\n",
        "# Let's check out what we've created\n",
        "print(f\"Dataloaders: {train_dataloader, test_dataloader}\")\n",
        "print(f\"Length of train dataloader: {len(train_dataloader)} batches of {BATCH_SIZE}\")\n",
        "print(f\"Length of test dataloader: {len(test_dataloader)} batches of {BATCH_SIZE}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "teTKMPfr72xa",
        "outputId": "b439d9ec-2ba9-4785-c1e5-16e19c4acd0f"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataloaders: (<torch.utils.data.dataloader.DataLoader object at 0x7faab327a860>, <torch.utils.data.dataloader.DataLoader object at 0x7faab327a0e0>)\n",
            "Length of train dataloader: 1563 batches of 32\n",
            "Length of test dataloader: 313 batches of 32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def train_step(model: torch.nn.Module,\n",
        "               data_loader: torch.utils.data.DataLoader,\n",
        "               loss_fn: torch.nn.Module,\n",
        "               optimizer: torch.optim.Optimizer,\n",
        "               accuracy_fn,\n",
        "               device: torch.device = device):\n",
        "    train_loss, train_acc = 0, 0\n",
        "    model.to(device)\n",
        "    for batch, (X, y) in enumerate(data_loader):\n",
        "        # Send data to GPU\n",
        "        X, y = X.to(device), y.to(device)\n",
        "\n",
        "        # 1. Forward pass\n",
        "        y_pred = model(X)\n",
        "\n",
        "        # 2. Calculate loss\n",
        "        loss = loss_fn(y_pred, y)\n",
        "        train_loss += loss\n",
        "        train_acc += accuracy_fn(y_true=y,\n",
        "                                 y_pred=y_pred.argmax(dim=1)) # Go from logits -> pred labels\n",
        "\n",
        "        # 3. Optimizer zero grad\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # 4. Loss backward\n",
        "        loss.backward()\n",
        "\n",
        "        # 5. Optimizer step\n",
        "        optimizer.step()\n",
        "\n",
        "    # Calculate loss and accuracy per epoch and print out what's happening\n",
        "    train_loss /= len(data_loader)\n",
        "    train_acc /= len(data_loader)\n",
        "    print(f\"Train loss: {train_loss:.5f} | Train accuracy: {train_acc:.2f}%\")\n",
        "\n",
        "def test_step(data_loader: torch.utils.data.DataLoader,\n",
        "              model: torch.nn.Module,\n",
        "              loss_fn: torch.nn.Module,\n",
        "              accuracy_fn,\n",
        "              device: torch.device = device):\n",
        "    test_loss, test_acc = 0, 0\n",
        "    model.to(device)\n",
        "    model.eval() # put model in eval mode\n",
        "    # Turn on inference context manager\n",
        "    with torch.inference_mode():\n",
        "        for X, y in data_loader:\n",
        "            # Send data to GPU\n",
        "            X, y = X.to(device), y.to(device)\n",
        "\n",
        "            # 1. Forward pass\n",
        "            test_pred = model(X)\n",
        "\n",
        "            # 2. Calculate loss and accuracy\n",
        "            test_loss += loss_fn(test_pred, y)\n",
        "            test_acc += accuracy_fn(y_true=y,\n",
        "                y_pred=test_pred.argmax(dim=1) # Go from logits -> pred labels\n",
        "            )\n",
        "\n",
        "        # Adjust metrics and print out\n",
        "        test_loss /= len(data_loader)\n",
        "        test_acc /= len(data_loader)\n",
        "        print(f\"Test loss: {test_loss:.5f} | Test accuracy: {test_acc:.2f}%\\n\")"
      ],
      "metadata": {
        "id": "i1CxJnxq75e3"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "from helper_functions import accuracy_fn\n",
        "def eval_model(model: torch.nn.Module,\n",
        "               data_loader: torch.utils.data.DataLoader,\n",
        "               loss_fn: torch.nn.Module,\n",
        "               accuracy_fn):\n",
        "    \"\"\"Returns a dictionary containing the results of model predicting on data_loader.\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): A PyTorch model capable of making predictions on data_loader.\n",
        "        data_loader (torch.utils.data.DataLoader): The target dataset to predict on.\n",
        "        loss_fn (torch.nn.Module): The loss function of model.\n",
        "        accuracy_fn: An accuracy function to compare the models predictions to the truth labels.\n",
        "\n",
        "    Returns:\n",
        "        (dict): Results of model making predictions on data_loader.\n",
        "    \"\"\"\n",
        "    loss, acc = 0, 0\n",
        "    model_instance.eval()\n",
        "    with torch.inference_mode():\n",
        "        for X, y in data_loader:\n",
        "            # Make predictions with the model\n",
        "            y_pred = model_instance(X)\n",
        "\n",
        "            # Accumulate the loss and accuracy values per batch\n",
        "            loss += loss_fn(y_pred, y)\n",
        "            acc += accuracy_fn(y_true=y,\n",
        "                                y_pred=y_pred.argmax(dim=1)) # For accuracy, need the prediction labels (logits -> pred_prob -> pred_labels)\n",
        "\n",
        "        # Scale loss and acc to find the average loss/acc per batch\n",
        "        loss /= len(data_loader)\n",
        "        acc /= len(data_loader)\n",
        "\n",
        "    return {\"model_name\": model.__class__.__name__, # only works when model was created with a class\n",
        "            \"model_loss\": loss.item(),\n",
        "            \"model_acc\": acc}\n",
        "\n",
        "# Calculate model 0 results on test dataset\n",
        "model_results = eval_model(model=model, data_loader=test_dataloader,\n",
        "    loss_fn=loss_fn, accuracy_fn=accuracy_fn\n",
        ")\n",
        "model_results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9n5S4kLV78pu",
        "outputId": "968931d0-d595-4a0f-ba9a-eaa0f13a0222"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'model_name': 'module',\n",
              " 'model_loss': 2.3025572299957275,\n",
              " 'model_acc': 10.553115015974441}"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Load Data**"
      ],
      "metadata": {
        "id": "VsIPWTAL646B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup training data\n",
        "train_data = datasets.CIFAR10(\n",
        "    root=\"data\", # where to download data to?\n",
        "    train=True, # get training data\n",
        "    download=True, # download data if it doesn't exist on disk\n",
        "    transform=ToTensor(), # images come as PIL format, we want to turn into Torch tensors\n",
        "    target_transform=None # you can transform labels as well\n",
        ")\n",
        "\n",
        "# Setup testing data\n",
        "test_data = datasets.CIFAR10(\n",
        "    root=\"data\",\n",
        "    train=False, # get test data\n",
        "    download=True,\n",
        "    transform=ToTensor()\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F1uo732J61Gr",
        "outputId": "27dddac0-dbe1-402f-dcb3-86ce2e1b9bca"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data/cifar-10-python.tar.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 170498071/170498071 [00:03<00:00, 43359850.20it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/cifar-10-python.tar.gz to data\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# See classes\n",
        "class_names = train_data.classes\n",
        "class_names"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pUokDrS17NfC",
        "outputId": "c2408ba6-2a74-420a-f116-9df07b484cbf"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['airplane',\n",
              " 'automobile',\n",
              " 'bird',\n",
              " 'cat',\n",
              " 'deer',\n",
              " 'dog',\n",
              " 'frog',\n",
              " 'horse',\n",
              " 'ship',\n",
              " 'truck']"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "image, label = train_data[0]\n",
        "print(f\"Image shape: {image.shape}\")\n",
        "plt.imshow(image.T.squeeze()) # image shape is [1, 28, 28] (colour channels, height, width)\n",
        "plt.title(label);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 524
        },
        "id": "pXHVY0uo7N12",
        "outputId": "d6b9eac6-6cc9-4e1e-a899-19c0c06ad834"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image shape: torch.Size([3, 32, 32])\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-22-7e463d96025b>:3: UserWarning: The use of `x.T` on tensors of dimension other than 2 to reverse their shape is deprecated and it will throw an error in a future release. Consider `x.mT` to transpose batches of matrices or `x.permute(*torch.arange(x.ndim - 1, -1, -1))` to reverse the dimensions of a tensor. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3614.)\n",
            "  plt.imshow(image.T.squeeze()) # image shape is [1, 28, 28] (colour channels, height, width)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot more images\n",
        "torch.manual_seed(42)\n",
        "fig = plt.figure(figsize=(9, 9))\n",
        "rows, cols = 4, 4\n",
        "for i in range(1, rows * cols + 1):\n",
        "    random_idx = torch.randint(0, len(train_data), size=[1]).item()\n",
        "    img, label = train_data[random_idx]\n",
        "    fig.add_subplot(rows, cols, i)\n",
        "    plt.imshow(img.T.squeeze(), cmap=\"gray\")\n",
        "    plt.title(class_names[label])\n",
        "    plt.axis(False);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 752
        },
        "id": "go4yt9mI9BcH",
        "outputId": "276fa481-0096-4e4a-eae0-40e291081737"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 900x900 with 16 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAswAAALfCAYAAAB1k5QvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eZhlVXn2/ex95qGqTo3dXT1U9UwzNTI02AzNICKDBBVQM9CNEkAEQoLmNXpFBg1EMOIbjVFMBDQkn4CCGqBBQiODCs1MN/Q8Vw81nhrOfPbe3x+Gel3rfjgcWuhq4f5dl1eynl5nn7XXtFcdnnvfThAEgRBCCCGEEEJU3IluACGEEEIIIfszPDATQgghhBBSAx6YCSGEEEIIqQEPzIQQQgghhNSAB2ZCCCGEEEJqwAMzIYQQQgghNeCBmRBCCCGEkBrwwEwIIYQQQkgNeGAmhBBCCCGkBjww12DlypWyePFiSaVS4jiOvPjiixPdJELq4tprrxXHcaS/v3+im0LIhHPiiSfKwQcf/Kb1tmzZIo7jyO233/7ON4oQ8kdFeKIbsL9SqVTkvPPOk3g8Lrfccoskk0np6uqa6GYRQgghhOw1O3fulFtvvVXOOeccOeywwya6OX808MD8BmzcuFG2bt0q3//+9+Wiiy6a6OYQQgh5h+nq6pJCoSCRSGSim0LIO8bOnTvluuuuk+7ubh6Y3wJMyXgDent7RUQkk8nUrJfL5fZBawjZvwiCQAqFwkQ3g5C3FcdxJB6PSygUmuimEEL2M3hgVli2bJksWbJERETOO+88cRxHTjzxRFm2bJmk02nZuHGjnHHGGdLQ0CB/9md/JiK/OzhfffXVMn36dInFYjJ//nz5+te/LkEQGNcuFApy5ZVXSltbmzQ0NMjZZ58tPT094jiOXHvttfv6Vsm7nGw2K8uWLZNMJiNNTU1y4YUXSj6fH//3arUqX/nKV2T27NkSi8Wku7tbvvjFL0qpVDKu093dLWeddZY89NBDcuSRR0oikZDvfe97IiLyy1/+Uo477jjJZDKSTqdl/vz58sUvftH4fKlUkmuuuUbmzJkjsVhMpk+fLn/7t38L30PI3jA6OipXXXWVdHd3SywWk46ODjn11FPl+eefN+q9+uqrctJJJ0kymZSpU6fKTTfdZPy7lsP8+r6/adMmOe200ySVSklnZ6dcf/31sL8T8k7T09Mjn/70p6Wzs1NisZjMnDlTPvOZz0i5XJbBwUH53Oc+J4cccoik02lpbGyU008/XV566aXxzz/22GNy1FFHiYjIhRdeKI7jMG+/TpiSoXDJJZfI1KlT5YYbbpArr7xSjjrqKJk0aZLceeedUq1W5bTTTpPjjjtOvv71r0symZQgCOTss8+WFStWyKc//Wk57LDD5KGHHpLPf/7z0tPTI7fccsv4tZctWyZ33XWX/MVf/IUcc8wx8qtf/UrOPPPMCbxb8m7m/PPPl5kzZ8qNN94ozz//vPzbv/2bdHR0yNe+9jUREbnooovkjjvukHPPPVeuvvpqefrpp+XGG2+U1157Te69917jWmvXrpVPfvKTcskll8hf/uVfyvz582X16tVy1llnyaGHHirXX3+9xGIx2bBhgzz11FPjn/N9X84++2x58skn5eKLL5YFCxbIK6+8IrfccousW7dO7rvvvn3ZJeRdyKWXXir33HOPXH755XLggQfKwMCAPPnkk/Laa6/J4YcfLiIiQ0ND8qEPfUg++tGPyvnnny/33HOP/J//83/kkEMOkdNPP73m9T3Pkw996ENyzDHHyE033STLly+Xa665RqrVqlx//fX74hYJkZ07d8qiRYskm83KxRdfLAcccID09PTIPffcI/l8XjZt2iT33XefnHfeeTJz5kzZs2ePfO9735MlS5bIq6++Kp2dnbJgwQK5/vrr5ctf/rJcfPHFcvzxx4uIyOLFiyf47v4ICIjKihUrAhEJ7r777vHY0qVLAxEJvvCFLxh177vvvkBEgq9+9atG/Nxzzw0cxwk2bNgQBEEQPPfcc4GIBFdddZVRb9myZYGIBNdcc807czPkPcc111wTiEjwqU99yoh/5CMfCVpbW4MgCIIXX3wxEJHgoosuMup87nOfC0QkePTRR8djXV1dgYgEy5cvN+recsstgYgEfX19b9iWH/3oR4HrusETTzxhxL/73e8GIhI89dRTe3WPhLxOU1NT8NnPfvYN/33JkiWBiAQ//OEPx2OlUimYPHly8LGPfWw8tnnz5kBEgttuu2089vq+f8UVV4zHfN8PzjzzzCAajdac+4S8nVxwwQWB67rBypUr4d983w+KxWLgeZ4R37x5cxCLxYLrr79+PLZy5UqY5+TNYUrGXvCZz3zGKD/wwAMSCoXkyiuvNOJXX321BEEgDz74oIiILF++XERELrvsMqPeFVdc8Q62lryXufTSS43y8ccfLwMDAzIyMiIPPPCAiIj8zd/8jVHn6quvFhGR+++/34jPnDlTTjvtNCP2eo7/z372M/F9X23D3XffLQsWLJADDjhA+vv7x/938skni4jIihUr9u7mCPlfMpmMPP3007Jz5843rJNOp+XP//zPx8vRaFQWLVokmzZtqus7Lr/88vH/33Ecufzyy6VcLssjjzyy9w0npE5835f77rtPPvzhD8uRRx4J/+44jsRiMXHd3x3rPM+TgYGB8TQ5Oz2JvHV4YH6LhMNhmTZtmhHbunWrdHZ2SkNDgxFfsGDB+L+//n9d15WZM2ca9ebMmfMOtpi8l5kxY4ZRbm5uFpHf/efp1+ejPf8mT54smUxmfN6+jj1vRUQ+/vGPy7HHHisXXXSRTJo0ST7xiU/IXXfdZRye169fL6tXr5b29nbjf/PmzROR/yewJWRvuemmm2TVqlUyffp0WbRokVx77bVwEJ42bZo4jmPEmpubZWho6E2v77quzJo1y4i9Pn+3bNnyhzWekDro6+uTkZGRmu8T931fbrnlFpk7d67EYjFpa2uT9vZ2efnll2V4eHgftvbdCXOY3yK//xccIfs7b6T2D35PrGQfIt6IRCKhxh5//HFZsWKF3H///bJ8+XL58Y9/LCeffLI8/PDDEgqFxPd9OeSQQ+Qb3/iGet3p06fX9f2EvBHnn3++HH/88XLvvffKww8/LDfffLN87Wtfk5/+9Kfj+cn1rAVC/pi54YYb5O///u/lU5/6lHzlK1+RlpYWcV1Xrrrqqjf8L4Ckfnhgfhvo6uqSRx55REZHR41fmdesWTP+76//X9/3ZfPmzTJ37tzxehs2bNi3DSZE/t98XL9+/fh/DRER2bNnj2Sz2bqNelzXlVNOOUVOOeUU+cY3viE33HCDfOlLX5IVK1bIBz7wAZk9e7a89NJLcsopp9R9OCfkrTJlyhS57LLL5LLLLpPe3l45/PDD5R/+4R/eVNBXD77vy6ZNm8Z/VRYRWbdunYj87g0yhLzTtLe3S2Njo6xateoN69xzzz1y0kknyb//+78b8Ww2K21tbeNl7sN7B38qfRs444wzxPM8+fa3v23Eb7nlFnEcZ3zDfj3/8zvf+Y5R71vf+ta+aSghv8cZZ5whIiLf/OY3jfjrvwTX8/aWwcFBiL3+IvzXXxl3/vnnS09Pj3z/+9+HuoVCge8yJ38QnufBf27u6OiQzs7Ot/W1hb+/vwdBIN/+9rclEonIKaec8rZ9ByFvhOu6cs4558gvfvELefbZZ+HfgyCQUCgE/8Xk7rvvlp6eHiOWSqVE5HcHaVI//IX5beDDH/6wnHTSSfKlL31JtmzZIgsXLpSHH35Yfvazn8lVV10ls2fPFhGRI444Qj72sY/JN7/5TRkYGBh/rdzrv1Twrz6yL1m4cKEsXbpUbr31Vslms7JkyRJ55pln5I477pBzzjlHTjrppDe9xvXXXy+PP/64nHnmmdLV1SW9vb3yne98R6ZNmybHHXeciIj8xV/8hdx1111y6aWXyooVK+TYY48Vz/NkzZo1ctddd42/25mQvWF0dFSmTZsm5557rixcuFDS6bQ88sgjsnLlSvmnf/qnt+U74vG4LF++XJYuXSpHH320PPjgg3L//ffLF7/4RWlvb39bvoOQN+OGG26Qhx9+WJYsWTL+is5du3bJ3XffLU8++aScddZZcv3118uFF14oixcvlldeeUXuvPNOyL+fPXu2ZDIZ+e53vysNDQ2SSqXk6KOPVnUq5PeYyFd07M+80WvlUqmUWn90dDT467/+66CzszOIRCLB3Llzg5tvvjnwfd+ol8vlgs9+9rNBS0tLkE6ng3POOSdYu3ZtICLBP/7jP76j90TeO7z+Wjn7lVe33XZbICLB5s2bgyAIgkqlElx33XXBzJkzg0gkEkyfPj34u7/7u6BYLBqf6+rqCs4880z4nv/5n/8J/uRP/iTo7OwMotFo0NnZGXzyk58M1q1bZ9Qrl8vB1772teCggw4KYrFY0NzcHBxxxBHBddddFwwPD7+9N0/eU5RKpeDzn/98sHDhwqChoSFIpVLBwoULg+985zvjdZYsWRIcdNBB8NmlS5cGXV1d4+U3eq1cKpUKNm7cGHzwgx8MkslkMGnSpOCaa66BV3gR8k6zdevW4IILLgja29uDWCwWzJo1K/jsZz8blEqloFgsBldffXUwZcqUIJFIBMcee2zwm9/8JliyZEmwZMkS4zo/+9nPggMPPDAIh8N8xVydOEFAxcNE8+KLL8r73vc++Y//+I9x50BCCCETz7Jly+See+6RsbGxiW4KIWQCYQ7zPqZQKEDsm9/8priuKyeccMIEtIgQQgghhNSCOcz7mJtuukmee+45OemkkyQcDsuDDz4oDz74oFx88cV8vRYhhBBCyH4ID8z7mMWLF8svf/lL+cpXviJjY2MyY8YMufbaa+VLX/rSRDeNEEIIIYQoMIeZEEIIIYSQGjCHmRBCCCGEkBrwwEwIIYQQQkgNeGAmhBBCCCGkBnWL/k5Y/H6IHXXkMUZ50+ZXoU40FoLYpPYuiA2OmBa7Y4UBqJMvjELMq1aMcjyegDrDw3mI9fbjtfJFzyiHXfx7IhrG+/E9sw0hFx37QhEISUSplxaz/VUfv68/j+8DLeXxHv1S2ShXlEaEQlGIVSu+US5WPKhTDmHfBCFsa7hs2h7PaG6EOmu3bYbYvuLMyy+G2GCfOTfKxSrUiYRx6UQjZYglG8wxbulIQR1HcOxSMfP6i45CJ7x40oeYWHNRRCQsaTNQRdlCyUcL4d1ju4xyu4f3HCvjmI/GsR8KYbOtY2Xs02oV59noGK7Tqmd+tlrFe44qvwVMyrQY5Zgbhzqug2uknMO+CXlmHwaCbf/cZ/4VYvuKO/7zHojZTqJ/iLOo75vjqUlh6okpM1hKFZw/VV/Zg6rWPPBwToWVdRoLm2NcKeH3ucrer/UX3I+Pd6T1Q7WKbfXFvH6gfF+lgnO9njZoaNeCNilT5KYvfr6u678TPP2DSyAWjZj367g4V0LKfbgBBu1pVvKwLwtV3A/8stmXrofXHhvFebBtD16rZ8ice/15nMP5Ml6rWCga5bLyClvHU9ZkRdmLi+aacHxF6qaEqsq1SlY7KkV83rnqc8scjGQU+6El0wSxwQJev3/UPIeUKzg+K/O9EIN2vmkNQgghhBBC3sPwwEwIIYQQQkgNeGAmhBBCCCGkBjwwE0IIIYQQUoO6RX/JCFatFMyE9ZFsFur4Dia1b926FWL5YVPc0zypAepMntcOsUSbKeRp62iDOiODKJLLProaYtu3m8JDVxHlacSipnAupIjfElH82yQTwz4dtoSNlbAiylOEh6FkEmK2MC0WQgFDRBEBJEKm8NCLYj/szmchNupjsn3U7otqfYKUfUVLB4oQwxGzzUVFUOkqwpKmZpyzybQ1fop4abhfEf055ng6mqApiGEb0rhG8iOmoGIsh4LasovCp0jJbGtIEX74cZyfoTS2yw1MQUqlgN/nKUKZqDL/KyVTwBEoIpxYAsc14ppir7CL66hcLkLMDSsCMOuzjtL2iSQSUVTGFpoYTRO71fPZekV/nmfOqaoiPNP2T1cTGVtdHigqJL+OdmlivnoFkXZ/2fcnUr8IL2Tt6xVFBFtPWzVBYb33aN+Pu5/5mkWVtWht1+I62GZNiK9UE8/a4yrKeDplnLPVohnzKtjOkVEcl6FBFDWPjZo3VC3jflquYOMrVrtKZdxj7TObiIivzJfAnnvK3u8G2nkC+ysu5vVTERyLeBT3q4R1PI0o3xfL5SBm94OISNlqVk4TMdYBf2EmhBBCCCGkBjwwE0IIIYQQUgMemAkhhBBCCKlB3TnMMSVXMTtq5vwO5fqhzgGHTsUvVfJ5h3aYsVQGc3JnHIL5mU0zM0a5rLw4O9mWgdjUjR0Q27oma5S1/LdoDM0OAuvvjhElTyjpoqHK5BTmWZbD5mfX7tkJdUZ8zLNMJDDv78jOyUZ5YQr7VARzh17ZZY7rDsWUoRzDNpSVdknFzL8qlOqecvsER8ltSzaYfdLYnIY6MUwrE0eZ13Zu/qSGFqiz4NBZEJvcbL6Qfd6MOVBHy4nr68G8tZeff8Eo+8EeqHPg4dMgFrcSvwopvL9EEmOuj+0Sx8w/CylzKpVEUxcJcH4G3ohRrlSxTjyK+5XjmGvEV0wJwkqurK+4HvienTe6f+Xm15uLbFNv7m49OcxaPm893+eKYhCi3I5r6QG076sqsYjz5nnH9eZk27niWv51QTGQKCv5pXFr/jvKGGptsNnb/Gst5tcxhvuSeBqfv+Gw2UZHlBxuJY/cV/Q7dv5zSDEOc8rKniRmvZKPfTugmDDtHsRn5u5+c24M57CdoyXM061Y5h+lEp5DSkWMaTqCwMoX1vQertKnccWKKGOZyTXHcQyTylxMWHPPUdZRWDHASij5yQlrrKuKaU098BdmQgghhBBCasADMyGEEEIIITXggZkQQgghhJAa8MBMCCGEEEJIDepWYFWUl8L39O0yykXBl0hPn48ip1AcE7W9immmEG9QkrIbMWE9Hxk2rx3GhPxYgEnmLS1oMuE61kv1NaGAIlayhSVVJfF9eHQIr5XEax0xr8soz2pTRCsB9sPcFhQQzmlpNcr9Yyg02TCGCf+DgTk+u3L4OXFQxNigCBurTsUq718vwt+zaxhilbIpLmhqRoVfVRF1FPvQIKfVM5fYKYcfjnXaJ0PstTXrjfKvH34e6uzuz0Js255ebFfZnHvvPxoFhBFF/OhZApuig/Mg7ONctE09RESkasYScZwrpTKKOoqKkYjYL7kvK+LcsCZwNccipJgg+IoJiqOIGP2qLXpTvm6/wxI0herb/usRmmnUIzx0NGMIZS4WyzguYonbtO8L7a1xiWp0oawRW5ikXGtoCPf+Xbt2QWzqjBlGubEpg22ow4DE0USTyvO7HlzFJGsicVOKmNc1nzG2YO1/gxjCR5941vOpqhiQeC4+D0pW//YMoMDvlY24N2/YhC9KGMya+02+hG0vVXBfdCxjMtfBtmsiWO3lBvZeUSgpZwDlc3llfhatc1RZMUqpKntRixVLh7DfI8r3pZSj40jFfDZXlH2+HvgLMyGEEEIIITXggZkQQgghhJAa8MBMCCGEEEJIDXhgJoQQQgghpAb1i/4UAdzQoOkIVxrEROqeNZjUnu5EEV7OEtakk5jcHzjYBs/LG+WIkpAfSTRBbMZsdFdrblpllAeHMXHfq2quOObfHRFF2BYoIpKq0v1tYibXHz8D3c8yjRmI7RrB6z/40lajvHIIhQLDtoBKRAYtp0JXUPiRDlC0FXiK0101a5QTjTiuE0lOcV+yRUG5MexbxRxJworDUFen6XT58jMvQJ1dvYMQ69ltimDzFRRrVBTBXVoRy85fON0oZ2ag4LUYx+vnLHGG5pblKn9zj40p4r3AnHu+q4hPqoqoUBFwlItm5+ey+H2T0jjPqpa7muak5nuKS5gmmLLEM5oj2MSCY+VYIiBNk6eJyjRNkG/N9WpVc8vDz9khVxOxKW550QjuUyV7fmqugcq1bHGgp7RdG3LNxa+eOlHFdTKXQ4H8yIjpYJlu1ITpijuf5USpVFFkgCLKdmXrKPdaLPhOUY1hX/q2g6evHGuUyei7ynnCOmMUFa3bruE8xF58cYNRfuXVzVBnTy+KwotlZU455hlGE+dGHG29mfuiqy5AjJW1M401DzzlZQeBcs6JKE6plimqjCji7rKyGeXD5n23O9gPnXEUd7c34LopeOZA7qng+qsH/sJMCCGEEEJIDXhgJoQQQgghpAY8MBNCCCGEEFIDHpgJIYQQQgipQd2iv8DDBPlyzhQdNUSboU5hEBPDq4JJ3wMl8/pOCb8vnMV2JRvNWyg0orwhrGg6Jk9qg1gmkzbKkSgKCPMFvNjAoNkwTXShiUFGcijaGh40hQFNHeiUmFPcz+5auRFi67JmQ1oaUUAYTaIA042ZscGBEagzUlWS5iN44zErmT9Sp7vYviIWV5yjLJGjr8z9UhHn9WgR54Y70xy/yc0oSMgH2yCWtabG2O4eqJNGc0c5bDG6+M1cYDqIOcoYlKooZAksMVSD4s4XVraQiOKyV7HEJqGwIhgRFHZ5Vez7sbw598qjKNQLNHNKx6ynaFRVoZrn4PVtUZ2rCccmEEX/BiI/rY6qdlNitpuap4glA8UZzxaaacJLVVyniT+t79Sc/qoVZSJY819rg+3g90btsmPa55qaUHR+zDHHQMyNmNcKlAHSrm+Pj/b8sUWaIiIhRaDlW8LecHj/2q+9KO6fYt2HV1EcepV9RBM0VkLmnNrYg46Myx98CWKrXjZFf4o+WhwH548mlo1YbYjFcAxiYc0p1Q6gmC+qCPi1lxTYe6Mm7naVqRHx8Ttda52WlWuNKut0xDfnv6eI/pqVNdkZpCGWtvbrxujeibT5CzMhhBBCCCE14IGZEEIIIYSQGvDATAghhBBCSA3qTlBylDzOwHpxfNNkzLfNtGJes19Co4ZJI9ZL9YeHoU5+A5pM+PPMfJXUSV1Qx0lgLlg6puWwmPfolzGvJhXFnN+CZf6RUHKFUynMq8kpxigv7thjlKdlsJVzu1shdtwRaMQyq89sf3sM/z56bicay2THzH5IxjAnteTj+FQdzMlORMz+KpWxzkRi5+yJiCQSZu56RZkHpSLmauWzmNcdVM37XXjIUVCnoQnz0VzX/E6/hOPUOb8dYl0HTodYxcrBjQeKuU+A66ElaeYLxhVToJCPaysZU3JXrTy2qmD/laqYmw9vvReRxnTGKMcCTOaOx7BPHWu787V8u7CiNahgfq5nzZtMBNf8uwXNEMQOaXU87Zlh5zBrZiNaTnHw5tfS1rKWIypR8zs1U5RiCfcp7fq2KYlteiQikkzi/qklkPtWTm1Jy79W0Nplo7VLy08uFs01qH1uIsnlNLMhs42uspfFI/j8rZZwXb/0vJmfvPyBJ6DOxnW92LDAyotXcu4dJVc4HscxCLtm+13FYMVX9t2I1QY7t1tEJBLBvikrz2R7f4sqa7Lk4fy0dQUiIq7VVtfF9VZV9A7Vsrk/ZwWvPRzGvqkopk12nvaMNjyr1gN/YSaEEEIIIaQGPDATQgghhBBSAx6YCSGEEEIIqQEPzIQQQgghhNSgbtGfB2/FFomHTcFDZhKKkEKKoGKajy8fP8Ax640MopHCQB5FOrs37jDKpQQKk5o+OAViyTTWs8UZ/T19UKdzEiaLt8w0hY1FRdA0WMTE+hHFD8HPm8npa4fQ5KV7Hvbp8Ud0QqxUNBP812/aA3XcHhSTpaxk+9aGDNSJB3iPfRUUAhbyZvtDETQKmUiaMxmIuZb4pi+Lxi3ioXgiphh2eBVTdNTYiAK1uXMX4LViZj81N+KaGfWyECuN4biEU+bfxSMFHKdoBEUXCUvIFlLuWVwUsjjK/I9Hza1mpILzuhBgzAkUM5yIuXZbmlHgF3HxfkKW2KSimDlUHRSJVaq4UKtlM1YJvbnwaqLRBHZ7Sz1aME28B6K/Ok1DPEW8ZwvSNIGar1zLFsn5itNHRHluacC16hDgiag+LDA+mlGKdn37c7oA8837QQTve38T/W3eis+rXTt2G+WI4DOmIa4YRg3jfvPEY8+a196ahTrtLZMhVraEwWO5MaijjXlTE7YrmTT3s7hiGFVSzFmK1p4UKOObG1Papez9jrU3lgrYV5qxTtXFOWvPIVepE1cEqBXrMVJWRMQjVXzWFBXRHz669m6/5i/MhBBCCCGE1IAHZkIIIYQQQmrAAzMhhBBCCCE14IGZEEIIIYSQGtQt+osoidrNloApnWmCOskUfsUU5VqzLJe4Zyvomjbq4+dmR0wR3qbVQ1BHjlPUdVFMWI/FTbFAa3MG6rQqoq3te0wx3e5RdDIc87ENviKi6q+YCfIv46XEW4uirdLLuyFWqJjX3zOAzoLlIoo6OtPWuCoCqqYEOidFFRehPQVTvOkr/TCRJKMoqBjszxrliChiPkXBEYoork2WS2JTSwfUSWmuTbborwnFptt3boFYb/8OiEVC5j1qzlGRMIqcIpYQ11FkK54i/qzYag0RKXq2aERxblNEHa7tXiUikZDZN8mI4pSoiJWKJXMuVhRxYt5DcW6pjA6ECUt4WKrsXw6WGvWIw95OkVc911e/TW2DEqtDw6jdj7uX4kdNxFiPkFJrgxZzwpbbrSqaVISNdQgNtXbWI/orKy6nE0n7lGkQGxsx1/HubShu39aHsR2bdkKskjf7vCWN+7UoItFYwtyTJrXifl1RnBsryr4RVMz9pqI43M06cD7GFhxglHMFfHHCzp14zz3b8Jkx2mcePFIFvOexURQQesp5wnYuTCgCv5IiSq1YToVRR3HyVPbw/gred97qQz+EL32oB/7CTAghhBBCSA14YCaEEEIIIaQGPDATQgghhBBSg7pzmMMxrJpOmcYGrTHM721JYP5nNYSJuV6jmWOyYBjzdiYrObIFK32xry0OdaJRfJF5GVNfJLDyaLQc5vY2zE3asr3HKHuY8ihuqL4X4VesPJ2dBeyH3FbMRe4dyEKsKlbukPKC8ilxpb+sHCM3jLlDiQBjU8OKKYmVv9SXVXLMJ5DtO9GcZmzYzIGqKjm5eg4ujtWQdb8jY2iC4ir9FljzINmAebpTWjG/Lqy0wS9auXMpHHMvwBwy8c2/pzUTCE/JK6so17L9QOz8aBERt6xsR0qefzhitj9XxZfqJ1J4/ZClW4hGsB+qecwzLCr32JA29z6n+PaZgrxT7G1+8t5+zlf2CDvPP6zkzhfKmNdZVtagbWbiKLmlYcUoyTZL8eswRfnd9RUzHMtcpN4cYzWvuY6k7LCS/4nGENgPWhvqaZd2rYmkUXkmzz3AzN3t3YHPmG2beyDmF5Q9z9o+EzE8vwRKn5StXORkIgV13CTu4Tt7sV0pa69vndQKdXI+5g+HM+ZcfN+i90GdI9zDIVbMYc7vUM8uo7x59Rqo89LKFyAW2Y3zOu6bazCu7P0lxYDEc825ngjhtTsUo7rpB8yCWL9l2PL8qxugTj3sX6uBEEIIIYSQ/QwemAkhhBBCCKkBD8yEEEIIIYTUgAdmQgghhBBCalC36M8N49k61WgmpycV8VKxhAKO4Wb82s2NU4xyZ2MG6rRXsA2bG02F3YzFk7GdGfy+kS1ZrJcwk+ZbWzDZ3qmiKCgZMz+XSaFQIFtGMVZZEV24rpn8HgorQhNFdBBTxCAJS5AS8TGxPlrBdoWsl9dXY4qIRNOnFHCsfduMwql7yu0TxsYUwwlLZxYOofAsphieeGUUn+WKpqDCVQwYmhQxSMoSlZUreO2mNBoFtWeaIVbMm0LDvqFdUKd3N77YPxQ3x8pJ4tj5MZzDZcE+DYVNgY2nCLsSylx3FZMj2/zGD+H8HBhGYWwsYtZLuor4JIeK3ZCydisl8/qVyttn+PF2UI+hRr2fq8t4Q/mcp5gK2LU8RahXDZT+9lGgFbIEg76yt3glzSjJbIUt3HsjtH7wFCGsTb3COfsetWtror9q1bxH1axFaYN233a9t9PI5m1BeRZVrXlQruBcHNmDYutWxXyraBsXJXCPaO6YArG+PaZ4fFdvP9RpaMR9fvoBMyF2ykdOMcrts1DcvXkLigWzQ+ae5MVw7mfa8ZkxNZWBWOII8x4PWYT3PGkGnnN+c/9zECv0mntqTDGgqxZx33VcM9aknBsPPLgbYu87+SiIlS2Bd+XeFVCnHvgLMyGEEEIIITXggZkQQgghhJAa8MBMCCGEEEJIDXhgJoQQQgghpAZ1K7AiikAmHDU/XhIUJpV9dJHx0WBL1kwzk9EHjpgHdaZFMcm8MWk6uAStmlAC256toNvgzFmmYHDJkSdAnVeeXQ2xLZs2GuWq4nAVT6Egsn8I+yaaNoUBviLW8JRYMqG4lpVMgWJjHEUH7UrfJDzzcxW8HRlUHOV2Ki5pWUtDUVXm0UTSlMF+q1gCu0oVO0DRKkk4ivc2kB02yn0DKAZpy6B7ZMgSKYQjinOdosfJD2chtqNnp1nesRXqFHIokvMtwU/rlElQJ9qITkv+mNI5aXOvCFxsfFpxZQs5itNfyKxX9fFaERfHNRQ2rzWmOFyN5XBed6TxvuOWYGrAz0KdiUQTedmCPs3pTUMTAoI4rIr9pn3Occ1YoIhgtXapwjnr+lXFvlVz6XQc8zmi/Wrk1dmGekRx9Tr9ac6I9WBfq17RXz3tsgWFE42jCHzzJVMctmbNOqiTG0ZnvHSAxx/H2s4aGnHfnT4DHY3nHthplPco+3xMOQMcesSBEJs0xTwLdbZnoE678kKCZ1542SiHo7j+GjLoQOh7uA+6MfO+p86aCnU+mPwAxBJVPKM98cCTRrk6iueERFRxny2b9WKK47Dj4LVCabzv6bNnGOVjxxZDnXrgL8yEEEIIIYTUgAdmQgghhBBCasADMyGEEEIIITXggZkQQgghhJAa1C36C2sqJ98WCKDgrupgrFDCRO2GpJnQXU1gInqlGcU3yaQpvrFd6kREvBLGinkURhwwb4FRPvSg9+H3+Q0Q27HJdN1ZvR6FgU1pRelYQkFKNm+54rSgIMwWkomIhIoozpjWbgoDGkI4FklF7DU9afZX0IxiwcF+/NywIvorWl/55r5Y+5YFB0+HWHZwyCgPDGB/aw6BxQKO51jYrLd7cADqTJ2CfVn1TZFKqYTroW/ndojt2rIZYnt27zDblEPXq5FRbMNQ1mzDxs07oI7mPDaay0IsFDOFGOk0ik+aGtF5KxHHtdvaYopi0g0oNGlvQMfDnOUm5RVQHNLV3A6xKR0oeBkYMYWUaWz6hKIK7t5G9796rqU5ydmfCxShmyaj0wRqEUtkGwrhXCwpjpKeJWSzxaBvRER5ttjtqtcZT3UI3LvhwcvU6dZYUlx4Ewlzr9/bOfNOofXbqLV39fb2QR1tjD1FuB623CJjika9MYmfm3uouUecOv9EqDNpOu4jDWl8tm57bZVRXvfr30IdP4nCw2FLaHjEkYdCnSHl+aNs4ZK2XiKQTOP3NXSja+BJZ58IMft5s3LFM9gGHzs6nTKvH1ecC+MRPFdFHWWdlsx5M6I4wdYDf2EmhBBCCCGkBjwwE0IIIYQQUgMemAkhhBBCCKlB3TnMISWVyamaeVFOCc/flSLmTo0WFNOQ+WZ+T1T5wt4cvgy8PW7m1rg5zMuSAPOEyh7muUTK5ovFe7ZiO7N7ihBLhTJGORYopgllzL+ZksG8oGLVzIMt+fi5kmLUEPMxt6tUMPNeG1L4uVmTMfny/VPNXPHdSm76rhLmFA47Sn531uzDYSVneiKJxhXTC2v4Ms1agqqSE4cpzFK0zBSG83j/DU3KPLDywXODu6BOYagXY8OYv+cXzRyy0eweqNM7iHnNOWvOFj1cW6lmzB9umo2xStU0gylWclAnEsIX+2umOaXRrFFOB9iuaBGvH4qY2100gdvfnr4eiL3y6qsQa+008+uaJ2PbJ5J6cmnrzU/VrmXHXFe5VvjNf4+pevUZhGixvGU8k1e0MVrOq2PpcVwX17Kqx6nTnKWez2nY13KUpGYtlxs+V2cOsxaz8841jcJEUirh87ds7bHlMs6DiHKvFWVckpY52tROzDtuVPJ5t6w3tSOvrF0PdWYdMBdi73vfwRCLWvvUAQcvgDolJU93p/WsLebRrGU0j/t8StGA2F5dnrJGfBfXSNusKRA7+oPHGeWtm3GP7V2HsVTSfO66gg/YoIz9UOrF58GrLz1llB964Amo86kvQgjgL8yEEEIIIYTUgAdmQgghhBBCasADMyGEEEIIITXggZkQQgghhJAa1J3Rn1OS7V0rOT1ULkAdX3k5+MgYXmv3DvOzs6dPgzoVwev358xYJFBelh+gyKkYQiOItWu2GeU1z++EOuEAE/5HHDM5PUig+C0ZxQT5kINtndxomo1sHMxCnUoFk9/bXRSDLJqRMcq+jwn/s6agwUO00RRJ/vaZVVCnL4IvLc80oclKrmyKryL1eQTsMwayQxAbHTbbHBYUFriKGNNRhEKjY+Y8GxpD4aooL9WvWmo3RxF1hhVxTzqJAo6QY45LVDEDmdyJ8ydvif427UajlIw1x0REug7FtTs8aooRyzkU5nRkUGATclFA61kCnlIRxS2uYn+Rz5vjWiyiOKSvjOMz5OG6aY6YxivF6v5l8KCJwzThXD2fq0dEpgnUbHGdiIhnzeN6v08zQRnKmnPqxZdeqetarQ3mfu0kUBSutUsT79l9+ocI7qQO8Z4mYrTbUO/Ya30K47qfGZe4ypxqsMazva0NP+jh8z6tGd1YZi57+nDtF6vYhh3bzL2xUEDR8aonX4bYzuM2QeyDH/2AUW6Ygvcz1IOCb/sZMZLFlxZM7cK9ORRXBMuWyK/qvblAVETEVx7w7V2mOVjH9BlQp3cTGqrs3m0ahuWHcG/euQXF8D2b8Lw3MmqeEwc3YJ164C/MhBBCCCGE1IAHZkIIIYQQQmrAAzMhhBBCCCE14IGZEEIIIYSQGtQt+hscRYeyIGwKAmINKJ7wfM2dBYUEu7ebAo5pB6G7WrIJE8rLviV4UIR0kQgKjOYeho40UjST6197XHHFaVTEiA2mUC9VQNeag6eiSG73FhQVlspm4n5EETmMllGsFItBSBY0mcn8lRFM7k9XMJl/S6+ZgN+nCD/cOE6d5nIWYo1xU4DSH1EaOoE0JVMQK2VNUaqn2M25imanUkQxayRqCuz2DOyGOtu2oStUKGeum9FBFHkEiktaJoMizqYmcy1NlklQp1RCUYztUugFuI4qqMmTqmC7SoE5r0MRFB4qujERTeQUmNfXBH6ixMKWSMVR3OniCZyfHR0ZbIOYa9Dx96/fHjSRly3g0oRnmqhMFfdYwjKtL4NAEwKa+0Y4hO0MFCfTkZFhiPXsMAU/riLiyuVQfLVnwBT6Tp6EczGk3E9ImVMha147Sp9qZnmaILJiCat85Vr1iPC0OppjnyYOtEVvrjL2E0l1BPegHWtM4VwygvcaaUaxvlNUrFmt6T/Wi2eAPVvQTXVs2KzXNQPPCSPZLMQe/+8nIVYqmOLSpskZqDOgrIdUk/mygUxGET8qwxlWtuLA2usrZXw+ROIoMA8UU8udlrPfjo1bsQ0uNsKznF8rFeX8N4prpLwDhfz2rp4Ja+69b87+tcsTQgghhBCyn8EDMyGEEEIIITXggZkQQgghhJAa1J3DnM9jDksqZSYwarluxSLmxGnJiqW8eXbPYeqQxBuVPBfPzLUJtDtSXjSeTGHFzgM7jfJ2pQ3VajfEhreaOaiNTRmos/CQeRALVTEXeWvPFqMcdrH/PCWXbkTp0+1DZk7tJMEc5sECjuuuovnC86kZqCILujFXdqaSDFW15sR/PbcBLzaBxGM4Z+NJsy9zytyPN2H+34y0lhdlXn+ghDnM991/N8SOnXWwUU4rOb/JOGoGiiXM2SzkzTVSzmOdXD4LsWjUzPxqDOP8Ga5g3raXV3Kdi2ZyWzKBOYURZf54JeznirVuXCXf1K/guvEtw59AMZqJKW0IKfmmVSvXt1LFe55ItDzWenKY6/mciJbDrOQi12HOof1mEyi5tY0NqAGZNtXMEx1R8pUdRdMStgQfvjK+ESUPVvN9ccTOp1fMRqqYK6ulIts534FyrWgU16BtqKIZrGhoee72uGp5zhPJjvWbIeZaBkQHzJkJdTasQoOQYWW+eNZ5JYXbm4gyr5vTZv5wtYxjXiphrFLF/l3/rPmMdBRjq/i0Vogdd+bhRrmgpGiHFH1AoOzhqbi1RgLcKwf60Ehk46otEHvsnl8a5T2bd0Cdhiiu77JlehcoiyaimIo1KvO6ohjo7Q38hZkQQgghhJAa8MBMCCGEEEJIDXhgJoQQQgghpAY8MBNCCCGEEFKDukV/lTKKWspWTBN5VCqYeR5SXjAfCcyk+fwQJnhnOvB87zlm0nygaRRcdFcoK4YdI54pAii3tkOdoIRGFwMvmaYu4bLyQnhN5RFDAYed6K4JRsJRvJ/hKibu7xkzxWqzJjdAnUIUlY3pmWa9+QceAHUWzJoDsf5X12Eb1maNcll1p5hA4lkINXeafZ5SjEs8H0UEikePVDzzfsseCj237EYhy+FTZxvlxhiOuaetN0Xwk8uZ82BkCF/sXqqOQSyZMK81OpyFOsOCn2ucgYK+lpQZi4UUxxMF30GxSRAy7zuiiI01w4qqtRdpoqeQIvby1XpWOYlr+Y+RegxPNDShXqAI7nzfHE9PESFpv+NoQrZdu00BbUER52rzYEePaaQQjaNZTeCgoFbxWJFIyLHKStt9nMNaj4YsU6dCXhHUKsYyEUsQrAn1NEG+/fwWwfF3tZueQHwH+6Slw3wmJxUXL0953r9WQAF632jWKJc87CPb1ENEpDxstisyjPtIPIl7nma2MzRsnidiiplSSwxNQ8qW2Do3gGZz5TE0PPEDfCZZ01p6d6JYfdULqyH26vNrIFbtN9dlOsB+GCthW/M589niKIe7sKsc+JR6vmpu9dbZv1YDIYQQQggh+xk8MBNCCCGEEFIDHpgJIYQQQgipAQ/MhBBCCCGE1KBu0Z/tbCUi4llOWZowQ4vFFAFT1DVFQaMD+LlyEZO54xnzWp6DCfK+p4gAqnjrDQ2WMCmFieJRBxP+G8RMmt+8dRvUeei3mFi/e0sPxEYs3Yoj2Paw4vwTslVIIjJoJbrnD0ER4/xjjoSYGzP7Jr8T2/4/v1gJsb5NeN/lstmueBxFkxPJUHYXxFzHvP9yGefBoCKoiChj4IRN9URcEXmkw/h3a8wWkWnuRYUCxMZGsF2DA6ZzY1FxdwwUcV2pZApC9wz04uea8H7CYSVmCZNCikOTpv/yVK2GY5WUdRpVtjZLyFJVnDY1t8EoLjfor7EijsVEogn1NEGfjSYYq8ftzVVEZVVFfGOL1oqK+5mnfF1v7x6I5S3HSm3eiTI3BrOm6LUpiyJYRa8o0QgG3ZC5Tn1FpO0r/aC5U4rVz5pQrx5RZr2f0wDh/tujlXrbmLcAXfwCyy0v4uD5YtbcWRAbVUSiazZvsa6t7M3aPLCqlRUXUa+MZxptWCrWfPEDnCubXkaBfWnQ3K+bGhWheAVF2mMjWaWeOY+Hs/hygOFRvFZVWbxJ60wWdXCdFlQXRDMWd/DaEQcnqKvE7IjSpXXBX5gJIYQQQgipAQ/MhBBCCCGE1IAHZkIIIYQQQmrAAzMhhBBCCCE1qN/pT3Hss4/bjnL8dpSs9ngcXZRiYdNdbmwIxUvDg9iGjlbT8cYXRTHiK2IsH13vMgkzNimJbYhFsA3uAVON8s4tmHT+7LoXIRbkURjQ2Gz2TaOP/RdWlFBOHgVMQ2EzljxiLtSZ+r7DIfaL2/7bKK99Yi3U8YZRwCAeZtK3TsoY5aYGHPuJRJvW2UFTTJQfxfuqlBVxWBjrReOmQCTdiKLHRERxSSubzlFjOXS4qlQUEYmHNxSPmm11RHFaGsX50zfUZ5SHi7geuuaj46MbRde7qiXgiCriOsfBWKA5p1m3XSpj24sVFOfC3hDg+gv7OIa2YFFEpGitwcZ0K9SZSDTRny3o0sR8mlurFoPvU2La52xhXlRR37z6Gu4369ZvVL7UnBuay6X2/BkZM+fxbkVQGFaUnk1pTbBs9mFYma8hTeCntCuoQ2Gnj49Z1twAdfG9IpC35sTb5ZD2dtGQwedHImaOleY6mc7gGv7AnxwNsdGyOTcee+xZqDM0hntsImq2S3N8zCt7UkxxFg0XzfkyNJSFOrYwUERkqyVYTCmnu4SL4xlXxLJx68UMMUWsnwm34BeEcZ6FrXNBMpaGOpViFmMVc1/XTg4RRQiomVN6ljC0nrWmwV+YCSGEEEIIqQEPzIQQQgghhNSAB2ZCCCGEEEJqUHcOs6fkTrmW4YLyPmo1pzhQzukx18ynGhnAl2JvW4Ox1unNZjsjmOup5dfF40mIxVwz92sypjmL52C+ZPMJZg5zy+yTlA+iScnoEN5PpWC2ITeML1fP9uOL9qt5zDEKNZh9vzuExhNbt2O71ry02yjvyEIVGVRyXkdGsV2JrJkTFlbMPSaSQg5jw0NmrlmlhPNV83KoljB3MB7PGGVXyadPhnCG+pYRhvZC+KKSl6it6HiDmY+WH8KxGyih8cau/LBRDhox5zHd0Qwx7aX9EctMwVNyrctFXLuxOOZbY/qn8ne/Yu5j52e6Sl9FVA0E3k+5YLZfSX2eULQcZvv+tXxY7XP1oGUE1tMGzcCjq2s6xEZG0Tghnzfny9BwFttVxbzRwJoaylSBvH8RkZCSHGnfo2aeoqUwQ+KxiPiWc4/naUYX2l5kfwFeO6TsMdr4V63+iiomYxNJEOA+VbXGwHew3/wo9tuMebh3nXb2+42ylt/+wkrMpy9ZGo2yoo1R/KmkVFZMUKzx05ZkQdFfiDXGY4qBR2sSx9NXjG5KllmX6yn514o5VErJkbadiEJxxVRJmZ9itT+kiORcpXMc5XlQsZ5J2tqqB/7CTAghhBBCSA14YCaEEEIIIaQGPDATQgghhBBSAx6YCSGEEEIIqUHdoj9NwBGyBAjaC8PLZcVAQEm4DomZlF0eQQHQcw+shljOEkct+uACqBNVxHuROAruHMc0XKgo5iaJBuVl76EtZp2gH+oEgkKryHRMtnfEbINfVkQXlTa8lmJGkUiYsZY0Ch3Xv7oZYsMlU6i3a2gA6sTiTRCbP/sgiKXC5rgOKC9hn0gKoyieiIXMfounFbFBGOd6ozI3bFFCTFANMqN1BsTSKfOl8IUcztdqGRWLY4qJx+CQKd4rKmsyUMR1jmUyM3lmO9SJNeKc0oiGzHmdK+P6Hsnh/bQrwhI/MPePvIf37IVQfGILlzWhWuCi2MtXZMMFq5+3bsa9aSKpR9CnCci0fV4zvbDr6eYmWhusGsqzIK6Yhhxy4DyI9faaIuaBZ3dAnUwaTXR8S2DUqpgJpWI47xIxvFbEMp6ot0810xgJbEEkVolEsG/s8XEUsZfWBk1MFthtUK41kYTLKP70LTFYWRHuOgGOp6OIk6d1mHveUQd3Q509G3ZDbHjY3NcdRdzuKSY9hbIiULTOQq4iSnUdDEYCsx8KiuA1q6zTsTwKKaOWWVMSH21SUa4fSSgvdLCMrBLKmkz5+PwJD1rXKivz2lbwiohXVYyzrP06UETn9cBfmAkhhBBCCKkBD8yEEEIIIYTUgAdmQgghhBBCasADMyGEEEIIITWoW/RXj5jB8zCJPpPJQKw5gw471aqZlD2wZxDq7FqPTnKjIy8Z5bFhFA4tOulQiIWn4q3bRmNDu1qhTjmP14+3WAnkLgqhQgEmoscUQUXIdvmJKA6LijAp6qBwJSiY9/jab1EU8+L/vAixqiWEs9skItKaQgHDzFZsV8YSe3mtaagzkYSUvkxYQp5CCQVqin5DSorTX6loOjW2t+LcmNI+CWLlqrnedu7EuT+cH4XYWAXbWrAmtq+IXUJxFE+kIqYAprWxBerEozivQ4owybX+NncVkWHcU4RJiqjDsbYtXxFgVpW9aDBrCobGRtBFM51EoW/aEj+KiDiWbVdLewbq7O/U6+qn7et2LKTZ5WnXssRumvgtpDiPpVK4v7W1meLnpiYUItt1RETKlktaUyN+Lp1Q9nClXdGwuX9ofao66gV437YoVXvmathf6SmuoLpDoLJuLAGhKk6cQBoUS82gYo5nVXC+uo4mBMRYgzXN3n/4XKizZT2K/p555jWj7Cu/Rfq+ItgMUPRX9s3zhL13iojElPVmv3QhUMTKQ4qwOhbBs1DamuvFHD5rMooSsDmJ6zQRNff6mLKOmpRrxe05q7gNKuZ/trGgiIhUPXteU/RHCCGEEELI2w4PzIQQQgghhNSAB2ZCCCGEEEJqwAMzIYQQQgghNahb9BeJoDgqHDY/Xiyh41ZYc7xRhAS9lgNcz+5eqBNWBECNlsBu9+o9UOf+Lb+C2KwDZ0PskMMOM8qxitLODZgsnmo0hUJuYhbU8Qvo1LbphVcgtn3rBqPc1oJJ9LksipUGevH6o8PmeIwOoCAs7uHfTOmkKXIaKaOIIq64A40MYxtilmNWXnH2mkhyozhnx7KWwEFRFgQhTVmgzP+YJXJqxzk8OIqCvlLFFDhkR3HMd/ejo6QmIkmmzPHs6EDHvuamDMSKXqfZhiy204vheoi3ae5qZjmsCD80p1DfV5zGLLFsVXFtGlHW22jJcghUnKMkUFyvFJercNj8bLmCYz+R6M57b15Hi+mudJZrojJOTki1kjOK9QrbNOGhLQQ85phj3rSOiEipas4XTSCqCfw0x0Ox7ttxFVGa1jfa1KtDYKf1g92HWtu1MdTG2r7W/ib685Xp4lrrP6aI/kRx//MUUZz9OGzpwL3s/YvmQ2x4wHTD3bAJhYFeoIj3FIF04JkxX3PfVJaW75v3HdGEuGHFbVDZP/OjWaOcUMTdQR77Oaoo7hJWp7oV/Fw1QEFfwjo6eoH2OYxpc8Szxj8S3rvfivkLMyGEEEIIITXggZkQQgghhJAa8MBMCCGEEEJIDerOYY7FMIfFDZnn7WoF81CU1CHJjWF+4cCwmaM5ODwCdeJxTCZ0KlYu4RDm44Ty2PbnfrkKYmufe9UoH3HkQqjT2NQNsW0bzJxX38Vu7du9HWIvPPk8xIoF07BlxnQ0i9BytHI7MZ+1JW7mVkdj2H+7ijhmuwpWHqeHuVDeIH6uFb0oZGDMvNaO/j6sNIEUMDVYClZuViSGf1dGlZz+chnzWGNJs+9KSo7sxh2bIDYj0W2UK1XMNywpueXFMuap21lr+YhiNqI4sdjv9S+NYg5n/66dEGubgWYRLVNNsyIngn0aCSl7DHazFDzzHkuKsYxfUXL1imZ/aWm+iRiu3cY0rpuilS8YVfbHiUTLT63HqETLkVWvZee6anWUHFG7DVqbtLzZegxBkkk0G9Hux86fDyl51NrnQkobIKLl/GrmLNr9WJogrQ3lMu67tpZIywuvVPC5qNWLWc+IenLh9yXVAO8jZt1bRDVkwc8VKoppSNgy2lLGYHoL7gfHHmrplgr4LFi/DZ/RiieY+Nasqig58FXFeMPOxQ8UY5aQkmOvrhGrXkl5tnllZU6V8DtTIXN+xkJ4P57gc9FxzXaVBL+vqJyFysqhs+KbY92uaHbqgb8wE0IIIYQQUgMemAkhhBBCCKkBD8yEEEIIIYTUgAdmQgghhBBCalC36C9uv0VaMDFcEzKEQ3gm117anh8xhYCVEoobQoogZ3DUrJfbnYU6za14ra4ZkyHWt8d82fjyu1ZAnZbmSRBzHdMYIpFogDoDg4MQCwWYSN+YNj+bHR6FOp0N2A8XnXo0xDLW5X/6ymaokyvmsA3WMCaVMaxWsU+3DKOgr2wJCjzNiGICKVVRIBBNmXM9k8Hx1N4JP6SIXiPWGikrL3bfkcO50RK3xJ7K96XSaYiVh1HI0pc1BbTDeZxTsUgCYlVLaFhSxjyvzB9HaWxHZopZRxGfhMNKG3xUZXpl8x5T0Uao4yuCnrao2a6WFhzXlgbNpQQFKeW8ed/F4v5lyLM/4Clz3RaRacKzes1MbHFgvaYrrvU7kSaF1J5RWgwMXFQVl2IQo9RzreenZlhRj9mMds9aTDM4sQWEJcWMbCJpLKDwq7zLfO6UhpX1Wsb7HxjFeokpU41yKo57ki0gExHptPaNw+d2QZ24g6r4HX3KCxBylqhZmVIFRdDnWAZbEQfH11HmQUR5SUHUfuYr3xcoKyfnYWP7Rs17TGOXSvcsPFcd0HGAUS4N4/Onby2Kzj3FcM5uqq+YtdQDf2EmhBBCCCGkBjwwE0IIIYQQUgMemAkhhBBCCKkBD8yEEEIIIYTUoG7RXyqOCeu2JkFzY4pGtc+hgLC/f8goF4soNtDczgLfFl1gGwYGhyAWj2G9rmlmwv/QUBav1Y9uPY5jOdlE0H1GPBRHeYp7Ts5ymQtcJbnfduITkZERjMUCM+m/KYzXuuigqRCbnjLr7VGEJit3Y9L8pgEIyWRLV9WU3r8c0aIxVCC4jik0a+3AZRIogs0ghIIxW3YRKH+iliPYv9EW07UsX0ahSbY3C7FIqgm/wDM/m83j50JRvJ+45ZwWTmDj0wkcz1192zD2qCnOcBQBzIEHHgqxoxYdAbGh4T1GeaSCE68DdYBSjplra2CwF+qMloYhlmjDcc0VTAGKozglTiT1OLTV4573RvUiltNlpYrz0/eVfdAW32jOeHVit1VruyYgtO+nHiHdG8X29nNan3pWX9TreGg7tWnfpzoXKqI/+zv3Vhz1TuF7irjWN0XT5VF81vZuxz7ZM4yxxrJ5Vpg6C/s7EcK9Mu2a/TQ5js8Mr7UZYmnBvaUvbV6/X7Gj7RvDWNEWu9Wx/kREAk0kas0hRXMusTDu/bEQ3nekaIoYvVEUOiYaUCS58KRFRrk1gf332B0/h9jYll0QC1nOsmV3714+wF+YCSGEEEIIqQEPzIQQQgghhNSAB2ZCCCGEEEJqUHcOczKO+Sr2u61DEcxNjigv/h4dxRyg/iEzd9BXXrrtKjFfzDwdx9XqYI5OXz/mNTdaRhCdU6dDnXQD5tHs2G7mzPjK3yHRBOZsRqKYh1SyXvzd0tYOdRoE85VfemU1xI7pMPNZzzsA235AJxq4bBrMGuVVvZgj2pbEsT60sQ1iFWva5Hx8+fhEEoliTly1Yo5B3x40+vCUXDpXyQlsTpvjbpsTiIhUlRfhi5XrPfPwWVAlaEpCrJTDuZEqWmsw6MBrBUWIRcP2y+uxnYU85qN5gntFqt2ce0XFMGbHyCaIZXbgPbZmzGuFKkpinpK/51hGGk0pTHQORfD7IincJvutfk6n9z4X952g3rzZej5Xj5GIav6hfd9epnrXkz+stVPLA95bow8tZudya2j5w1rf2PNTo54x1KgnX1kE+yYSrvuIsE8Y9fH+403mHhup4r1GC0purYP7WSRtjmfVxf3UVTQniZilF1JymHNRjI1Fsa1ByNyvI8qztkkzrSqb86xQxXNWSdEaFPN4DrGNnxoimGudiuFemVDWQ3NgPg86MlhnVvc0iE2bY56/gqJivpPE+eA7uN5sE6D+Mcxzrwf+wkwIIYQQQkgNeGAmhBBCCCGkBjwwE0IIIYQQUgMemAkhhBBCCKlB3Rn9tv5HRCQSsQw7Yihs83xMkN/Wgy+WLpTNF3+HIigc8n1sBPgFOEpCfhKT049efADEmlvN648Mj0Cd/AjGRqpZo5yJtECduGLg4mYhJAmxEuKrKMbKpPEeD+pEQd+HjphnlNOov5TnX94BsV05U1AQ9SdBnYYwtstPoXjAq5pzxKsoL1OfQMqKBrFs6QHKypyqlhRTAVGEgJYYrEl5+Xo8hoKKsm8KNrw4ik+6D0HxXnEUx6WaN28yUG46V0Rho2O93F3bAySColE3oQihUmax5OP95JQX2u+uohDQNhzwq4rIo4ximlDVXINNsQaoUx7BOTycQ/OGRNK8VkozVNjPqddkoy4xnSJG0wSue2cXUJ+IsV4jlnrqaLF6jUTqQW2Xda16TFc0tM9VKjiHtXrRqPXcDfav/To7jOss7pv7Z8jBs0NUMR9qa8DxdJNmPxVLiuGYtt9Yw2IbZYiIxJR9MRxSxtMSnUfsM4GINEfw6OaGzc9VfOyHchXnQd7BtpZz5j7YqJzt0jHlJQ8B9mnKikUK+Izy9uBLGGS3+SKIgiJoL+XwmVFVdpmqdY+FvTyH8BdmQgghhBBCasADMyGEEEIIITXggZkQQgghhJAa8MBMCCGEEEJIDeoW/flKsni1bCasB4pT0ajiBLZjBwrNqpYDjas4DPmKAMEWT7igAhRRjJYknEDxwPz3meK2QgGdwMbG0Hmvc4cp5CqUMOm8uQFd8FLNmJS/Y9Meo9ynCCTDCXT5+eBJSyDWUDGFXFt2DEKdLSUc1+1jZgJ+1MN2ukkUAWRdxSUtZo5jdqAX6kwkihmSBJZgLKa4NIZi+LdmUXGwrBZMYYTj4LViSUUsaPVb1cU5lasqQr0UhCRuuQa6BUUQ5+B6C1majrBi0zY2hus7rLiClsLmIqyUsf9CcRTmeBXcUwpFU/xRFRQxVpTfAvKWQGRHP87FuCLGijdgu4LA7K/gj0D0ZwvGNBGbRj1iN1Vwp1zet4J/iODOrlevYNGup7Vdc/Czn1FvZxtEVL06UM9YaHW0NtQj5nS0QZxARgZwzyta7r6OIsoLtI1ecfoLLNc7x8H798o4X6rWeGrurY7mLBhWxLLWPHCqmiuk4h5pnY9CivgtqpyPwjF8G4AfmHMjrEyDhHKuSitnwIT14gdXWUcbH30RYrtf2WyUq8pcHB3ClzAELt5P2bPWiPK8qwf+wkwIIYQQQkgNeGAmhBBCCCGkBjwwE0IIIYQQUgMemAkhhBBCCKlB3ZnPpRJmeJesRPpkUhEmKW55IR+FZk2NprAmX8Y6mioisJLYHeVvgGIBRUG/few1iA3s7jPK3XPR4W76HHRXW3DUNKMcakTRUzKNrmLpyKEQW/3MdqO8/pkNUOeIGdMhNtiEAsXA6ouq4ip02FR0npuyvd/8XAk/t2MQRRS7+tHBJxsyBRljBXRSm0jCruJKFzHFBeEE3r+viCcSLirupkzqNMpTp6P4s390I8QcS5Cj6bM0PU40goI+e5GHFJeosCZCEvMLfEVoUizimEcVl6tSxVyDniL8EMVxShRxRtlyaYopQspqGTunagt/QoojWhj7oa0RRbZiraWio8yjCUQTstUjDqtXtGajCuL2zgRvv0DrG00IaPdXvULKesSO9QoibbQ2hEK4L2hzxB7rqmaFOpHk0HmvGjLF5p5tuyci4qFLXNjDvStiidYCRejsK/tUOGY+8xMpxW1OcR9tzOP1s5YTXtFT2qCsSS8w12BVFMGi5rWpnKucmNVWD+sozZKyq+wpllNhJMDzUayM1x/bZoq0ixXFITCq7OFR5TlVtdYpRX+EEEIIIYS8/fDATAghhBBCSA14YCaEEEIIIaQGdSdyjOYw99QNm7kpyRzmmOTzmDvU1NQEsbiVkBku4udcR8nDsl5aHlJyUtta0WwkIvhy6/we86Xo28qYL1Uc3Qax9tlmDtW0BZj7nExiXk0yg92/4P3zjHKg5EY2pFsgNtSICUUNk2cY5UoOX/qeV4xRmiwDiVQV21l6dTvEslk0ghixXroei2G+6UQSUeaL55l5e66P9x9T8l8DJXd3JGvm8I9lMR82EclAbFKDOXYLug6COq6LeaPl4hDESrms2c4Y6gNKSg6qnQrpK/mTDZMxBz7v4fV7c+bcyJVxPYTsvDkRJQtPRKx8zHIRv88P8FqRmLlOSxVsQ9nBWKGCeZx+yYwVlc9NJFrasWPlKgZK72oxLSXUngkVRZeipH9Cbj5eScduu/ZZJSVXPC33EkxmlHxTZT2EtDUPQgIt77i+vGbXar/ydRJWdCiwLLXx8hUzD63vrXVTb072vkLx+ZDAzilW+s11MW82FFbMk6z54vmKuYtmoGbl0kYb8bmSFFwj6SLeUNo6ahWVsSt4Su6uZTbiKfPOV8Zck464jp2bj58rKXtFWZvrlvlL2Me9Oan0c9y6lBfFMYRcaxGpKOYprmP2fTqG16oH/sJMCCGEEEJIDXhgJoQQQgghpAY8MBNCCCGEEFIDHpgJIYQQQgipgRPU8yZ0QgghhBBC3qPwF2ZCCCGEEEJqwAMzIYQQQgghNeCBmRBCCCGEkBrwwEwIIYQQQkgNeGAmhBBCCCGkBjwwE0IIIYQQUgMemAkhhBBCCKnBe/7AfO2114rjONLf3z/RTSFkn1DvnO/u7pZly5b9Qd914oknyoknnvgHXYMQEe7VhNiceOKJcvDBB79pvS1btojjOHL77be/8416F/OePzATQgghhBBSi/BEN4AQsn+ydu1acV3+TU0IIX/MdHV1SaFQkEgkMtFN+aOGT8N3mCAIpFAoTHQzCHnLxGKxN91gc7ncPmoNIe8s3KvJuxXHcSQej0soFJropvxRwwPz/5LNZmXZsmWSyWSkqalJLrzwQsnn8+P/Xq1W5Stf+YrMnj1bYrGYdHd3yxe/+EUplUrGdbq7u+Wss86Shx56SI488khJJBLyve99T0REfvnLX8pxxx0nmUxG0um0zJ8/X774xS8any+VSnLNNdfInDlzJBaLyfTp0+Vv//Zv4XsI+UPp7++X888/XxobG6W1tVX+6q/+SorF4vi/2znMt99+uziOI7/61a/ksssuk46ODpk2bdr4v996660ye/ZsSSQSsmjRInniiSf25e2Q9wjcq8l7hdHRUbnqqquku7tbYrGYdHR0yKmnnirPP/+8Ue/VV1+Vk046SZLJpEydOlVuuukm49+1HOZly5ZJOp2WTZs2yWmnnSapVEo6Ozvl+uuvlyAI9sXt/dHBlIz/5fzzz5eZM2fKjTfeKM8//7z827/9m3R0dMjXvvY1ERG56KKL5I477pBzzz1Xrr76ann66aflxhtvlNdee03uvfde41pr166VT37yk3LJJZfIX/7lX8r8+fNl9erVctZZZ8mhhx4q119/vcRiMdmwYYM89dRT45/zfV/OPvtsefLJJ+Xiiy+WBQsWyCuvvCK33HKLrFu3Tu6777592SXkXc75558v3d3dcuONN8pvf/tb+ed//mcZGhqSH/7whzU/d9lll0l7e7t8+ctfHv+F+d///d/lkksukcWLF8tVV10lmzZtkrPPPltaWlpk+vTp++J2yHsE7tXkvcKll14q99xzj1x++eVy4IEHysDAgDz55JPy2muvyeGHHy4iIkNDQ/KhD31IPvrRj8r5558v99xzj/yf//N/5JBDDpHTTz+95vU9z5MPfehDcswxx8hNN90ky5cvl2uuuUaq1apcf/31++IW/7gI3uNcc801gYgEn/rUp4z4Rz7ykaC1tTUIgiB48cUXAxEJLrroIqPO5z73uUBEgkcffXQ81tXVFYhIsHz5cqPuLbfcEohI0NfX94Zt+dGPfhS4rhs88cQTRvy73/1uICLBU089tVf3SMjv8/qcP/vss434ZZddFohI8NJLLwVB8Lu5vHTp0vF/v+222wIRCY477rigWq2Ox8vlctDR0REcdthhQalUGo/feuutgYgES5YseUfvh7w34F5N3ms0NTUFn/3sZ9/w35csWRKISPDDH/5wPFYqlYLJkycHH/vYx8ZjmzdvDkQkuO2228ZjS5cuDUQkuOKKK8Zjvu8HZ555ZhCNRmvO//cqTMn4Xy699FKjfPzxx8vAwICMjIzIAw88ICIif/M3f2PUufrqq0VE5P777zfiM2fOlNNOO82IZTIZERH52c9+Jr7vq224++67ZcGCBXLAAQdIf3//+P9OPvlkERFZsWLF3t0cIQqf/exnjfIVV1whIjI+39+Iv/zLvzRy4Z599lnp7e2VSy+9VKLR6Hh82bJl0tTU9Da2mBDu1eS9QyaTkaefflp27tz5hnXS6bT8+Z//+Xg5Go3KokWLZNOmTXV9x+WXXz7+/zuOI5dffrmUy2V55JFH9r7h71J4YP5fZsyYYZSbm5tF5Hf/uWPr1q3iuq7MmTPHqDN58mTJZDKydetWIz5z5ky4/sc//nE59thj5aKLLpJJkybJJz7xCbnrrruMDXn9+vWyevVqaW9vN/43b948ERHp7e19W+6VEBGRuXPnGuXZs2eL67qyZcuWmp+z5/fr89++XiQSkVmzZv3hDSXk9+BeTd4r3HTTTbJq1SqZPn26LFq0SK699lo4CE+bNk0cxzFizc3NMjQ09KbXd10X9ujX5/CbPQfeizCH+X95I/Vo8HvJ7/akfCMSiYQae/zxx2XFihVy//33y/Lly+XHP/6xnHzyyfLwww9LKBQS3/flkEMOkW984xvqdZkLSt5J/pD5Tci+gns1ea9w/vnny/HHHy/33nuvPPzww3LzzTfL1772NfnpT386np9cz3ogbw88MNdBV1eX+L4v69evlwULFozH9+zZI9lsVrq6uuq6juu6csopp8gpp5wi3/jGN+SGG26QL33pS7JixQr5wAc+ILNnz5aXXnpJTjnllLo3fEL2lvXr1xu/sG3YsEF835fu7u63dJ3X5//69evH/5O0iEilUpHNmzfLwoUL35b2EvJmcK8m7zamTJkil112mVx22WXS29srhx9+uPzDP/zDmwr66sH3fdm0adP4r8oiIuvWrRMRecvPgfcCTMmogzPOOENERL75zW8a8dd/XTjzzDPf9BqDg4MQO+yww0RExl9DdP7550tPT498//vfh7qFQoHvvCVvK//yL/9ilL/1rW+JiLzljfjII4+U9vZ2+e53vyvlcnk8fvvtt0s2m/2D20lIvXCvJu8WPM+T4eFhI9bR0SGdnZ1v66sLv/3tb4///0EQyLe//W2JRCJyyimnvG3f8W6BvzDXwcKFC2Xp0qVy6623SjablSVLlsgzzzwjd9xxh5xzzjly0kknvek1rr/+enn88cflzDPPlK6uLunt7ZXvfOc7Mm3aNDnuuONEROQv/uIv5K677pJLL71UVqxYIccee6x4nidr1qyRu+66a/x9oYS8HWzevFnOPvts+dCHPiS/+c1v5D/+4z/kT//0T9/yL8KRSES++tWvyiWXXCInn3yyfPzjH5fNmzfLbbfdxhxmsk/hXk3eLYyOjsq0adPk3HPPlYULF0o6nZZHHnlEVq5cKf/0T//0tnxHPB6X5cuXy9KlS+Xoo4+WBx98UO6//3754he/KO3t7W/Ld7yb4IG5Tv7t3/5NZs2aJbfffrvce++9MnnyZPm7v/s7ueaaa+r6/Nlnny1btmyRH/zgB9Lf3y9tbW2yZMkSue6668bfJOC6rtx3331yyy23yA9/+EO59957JZlMyqxZs+Sv/uqvjP9sQsgfyo9//GP58pe/LF/4whckHA7L5ZdfLjfffPNeXeviiy8Wz/Pk5ptvls9//vNyyCGHyM9//nP5+7//+7e51YTUhns1eTeQTCblsssuk4cfflh++tOfiu/7MmfOHPnOd74jn/nMZ96W7wiFQrJ8+XL5zGc+I5///OeloaFBrrnmGvnyl7/8tlz/3YYTMDOcEEIIIeQ9w7Jly+See+6RsbGxiW7KHw3MYSaEEEIIIaQGPDATQgghhBBSAx6YCSGEEEIIqQFzmAkhhBBCCKkBf2EmhBBCCCGkBjwwE0IIIYQQUgMemAkhhBBCCKlB3cYlRx3aBbFq1Ux/DlUj+AUevuPvlIXTILZoTrdRbjvgCKgz74PnYRsKVaNczI5CnTWvvQyx+QcdBLHWyZ3m5557AuqM7NkNseaOyUb5saeehDq33fZfEBvqR/vUwLXLPn5fcwPEIhHs++yQ2ffVCqarz+5KQ+zPPnGMUe6YgnV6BrCfn165HmLzO1qM8qID0fnttKuxb/YVS87ohpjj2GX8u9KxK71RTMxY4OAY+IKfc/2QUZ7UPBXqTFViBWVcKoW8UU7H8H4iUoVYPGLWcyo4F8v5MsRKFYyNlcw25MsFqJMrVSDmJydBbMFhpoPaAUeghevs5maIzY3sMsrtB82HOtsH8hB74de/gtjmdeaesnvHdqjzj3f9GmL7il88sxpiXjlhlHcqbd4z2Asx38fxjErRKDcmcU4lQkWIrV1j7qmxBI55Fb9O5s9ZBLGmBnO/zhY8qKOtyaiYX+B7aDPshPB+fA/nfyDmenYVSZDrhCAmTgJCvph7eCjWCHWqfhQ/Z3VYSLAf2ppwD+9owGdGk1WvKYbjM+nAYyC2r/jxyyshFgrM+3UdvH+7j0REnADrVUvmnC0oFuevrVoDsU3rzbXU2tQBdaZ1tEEsncB5NjZsrsFiHs9Q2zZvg9iq16x2uTj3Z3Xj2WvuzE6ILTnWXG+HH47nsUw7ngnDkSTEAuv55gjOOz1mB+qT2/k+rlPfWpchV9srUm96bf7CTAghhBBCSA14YCaEEEIIIaQGPDATQgghhBBSg7pzmKNKLpidNhuP4eVSbhxisyZhnsusdjN/JN2cgTrtbZjPGBTN3JR8pB/qDO7C/K2mOOaVbVm9yig/dO/Poc7aV1ZBLG/ldm7s2YltGMLcUsdRuj8w+zmk1CkVMEdndASv71XNvNSIkoPXFsFYd7v5nVM6cQy9CuagTm+JQWxGm5lz1z0Jx2Ii0d5CruU91oOdr6xeS7m09jm7YiyGfdvS3AqxfAXrZavmmigUMS8vX8V807w19eKOolGwk+5FJB3HPMt0yvzs7kGcd8NKPrQbwfuRiHn9IIRrOVDyzqtW2lqxgN832NcHsdzoMMTsnMhkDO95IqmWcYxf/rWprdiy8TGoU6pmIdbaOhlio8NmP0VczIF3Hcx/bWk19ReBh+Pb2DgDYvHEFIjl8tacVfZK38cFbucdBz7mM5aKmMvuKfsnLm8lhzmE7XIUbYrjmnnNVWcE6gyN4j6fHzXHOqzsJ727MLbewTa0t5uakxOOOhDqTCSui/uUnbNqj6+IiIQw5ilaC8835/HIMM7hbZuzENvVM2CUs4qWZGDnEMTKyl48nDW1FoU8zoNiDp+/hYI1r5XxXb16K8TWr8N86F//1tRAnHIKfu7Tn/5LiHV04PPdXoPhsPKcVNaD+rCsA0fJ3Va6Yq/gL8yEEEIIIYTUgAdmQgghhBBCasADMyGEEEIIITWoO4c5UN5tl0iaeYmJMJ6/G5W85sZWfN9d1XrvZa6k5Bwp+W525pwTwVzCgT58d/LP77kLYr/+7YtGefdWzNspKe+iDaJxq4ztDELYrmoF8/7sHLgAU6ikpHwuGsW+72jLGOWFC/C9iccfjfmCXda7Gquu8mLUEOazShjHOp40xzocf/N3He5btHc7vnnuVKAkP2vvWHatv0kDNYf5zWPa96UTqAVon4w5ZJMbzbzR7DC+a3c4i7FqxcwXjCQwVzis9J9TxUlbKZuxkRzmIpYF303bpOUG++ZnPSUHtexjrw5a72yPVfHa8QTOT+0drmErT07Z+iaU3p7fQmzD+oeM8qwZqE2IRRW9gpeFWCJk5l46IdwXW5tbIBZYfd6HaZ0yfcEBECt72MH2O49dJZddW13Vkpn/GVTwPcyizGFHyYe2c5i1PaAqSgKlMj/DEXP/1N7f3NqG72buaDP72ako73VXNp6q8v7pEStfdtMO1ONMn8C0Zns/FRHxAjsnHT+n6YWcAGOVornW17yyC+ps24R5xyPD5t7SW94DdXYJXkt7wPuB5Z+g6EtKRdyT/LI5xq7g/KmEcB6UPIyVrfes/+zBR6FOUzPqCj594achFrXOQ9oTN1DWCGp76ttkdS2RNUfUz705+9k2TwghhBBCyP4FD8yEEEIIIYTUgAdmQgghhBBCasADMyGEEEIIITWo37gkgUI2J2yKbXwHE9FDcUzmbmxFsVLIEq2N5TCx3lfEPRHLPWWshG34nxWPQeyBe34GMU9MQUpY6Z6IIm6ZMt0UyaUzTVDn1TWrIRaOY5r5nNmmOUtzBkVcySQKc6Z3tUFs2nQzdtD8aVAnHcb7CTlmPzuK+UwqhQKtlDJHYpbxhKuIYiYSRzG4cF3XqlPfC9S1ar4tNlCMPrS3qrshU0TiaKIIRcgT+CgIFd8UOaUUvWbDJJw/ubwtPsGX5bvK93lFjPklc05Fwyi4iynKuYYGrJewhGnxCopiGkLYhuZppug12dwOdYJhVKG5ikQkanW9V/9Wuk8Y2rURYg1pc0+NxzJQJ6ysz7ERNHPxqma9RAzFkskEXr+YN+fxggPmQx1HEQ+XiyhQi1hiL+35oInVHbuep6wZD68lyrV8a27Y611EJHBxXjua2Y7drgDb4FW1NW+VFdGftlc4igAsEjefzbmSIoicQNwA51lQNduoeJS8wXjic237TlP8PNKPc2N6B4pSiw3m/pkd3gJ1knF8ZpZKeM7p2bXJKIeU56/v415cqphmKSEX64QUIakoz0C/bPZXQTFCuusnP4HYgGLY8md/9udGee6cWVCn4uH1w9a6CSntVE1q6jpi7J0pCn9hJoQQQgghpAY8MBNCCCGEEFIDHpgJIYQQQgipAQ/MhBBCCCGE1KBupUpYESkUCmayvRdDNVFUcSNrbMTE/ZjlhDeiCB6CCrriuA3m9Ve99CLU+c0T6HoV1VyhLEGW7yliLMVxbU/PdqPcO4CuafNnTILYvCnYhg988CCj3DINhUkVFxPWQxH82ydsicma4iiOkiL2achy8fNdRaASoKAgpYgYPUtsUfX3r7/RdD3f3gkClKkBXxAo7ku2u+Pv6plik6gihEomGyDmOoqDXsG8flMjrsmGFApLsiPmPNjVi3NlaBjFGuVRFAr5nnWPyjRoTOA9dk3tgNiMDlNgMylAoV5iZAxiyfbZRjkaQ5GqYuYmviIKcyyxY1URhE0kIWWepZMhq4z93TfQD7FIEq/lW+Ih18E51TeA86Ah02mWW1GIPDyGwu3AVZxfrf068BRHUkWUGvjmPNbFs8qaVIfYWt9qO/FTblURy1ruauGIss9rosLAHAtHaYM4+Dx1XJz/Yasv4qkMXmsCcXw8Y4Sts4Kfz0MdL4/7QTyuiOny5rVKIyhi80q4x6bjZl82d86FOqkYPsv7BwYh1rfDbEMsieelaArHuKXbnNe+gy6Nm7dsgli5jM9yr2pO9pByXhoaGoDY0yufhVgyZTpRnnPOWVCnqxvPR7C26lPz1V1vb9i/Ti+EEEIIIYTsZ/DATAghhBBCSA14YCaEEEIIIaQGPDATQgghhBBSg7cg+kPFg+3E4ioKqrjiJhRSRBZlK0+7rAgsbDGaiMjAdlNw98hP7oI6jpKcPiWKt247elWVvyeiSpf15kyRweAIiqNyimiroR1FAJmK2YbmELahFEf3s4IiOnIDs79CDjoNSRjbGrWc1HxFzeb6eD+pmOLQVTGFOEEIhRYTiqoPsIOKS1ad7n++Ndc1UZmriDgdS7QVV5zU4nEUWpUKKEjxrLkRUm46JCgKaoyb82dYERlu6clCLKeItlKWO2UlQNGTLfwVEUmk0YEw1mjGnBgKUqoBzmtbvFpSXNNKBRTA+BUUrzmWAkwTY00kkTCu9XLZ7BM3jOOUTKKzaEURqBU8s5/6s1moE0+0Qmza9KlGuZRXXMaquI+EFPs23xbvacJLD+eBWI56qvuo8lNSoKj+NLkuXEpxINSw51m1hPPTVUTTtkGmqzmiKdtVEELRX6Vq7h/VYP9ysNTEiyHfbHOT4i482LcHY704/+PWvt636xWo078bRcaZhoxRnj/3QKgzNNwDsd078QUBUcfs83JOOXtFGiHW1TXFKJ/zsWVQ59H/eQhi/30fOvYV8lkzoDinDldRsBjrw/v51a+eMsojIygU/+zln4LYpHbTMTlQVfX1YgkItWvV8UjnL8yEEEIIIYTUgAdmQgghhBBCasADMyGEEEIIITWoP4c5gjksaSv3KxnDOjObMS+xLaXkXpbNfKqggrlKXnEEYj/9wb8Y5Rce/gXUmZHENkzJYD6mnZPdl8Xvi8cxx6+xwcwX3DmCOY/BMOaW7nxtF8Qes3Iom2buhjotc/Fl/w1TMhALx837CSnD3ZRUXt5u5cCFldy9diWfdTSOeZNeycwTc3zFPGUC8TU3Aivkuvh3pe53ov39acZiMW3u40v17Vxnx8E8Xc/HVkSiOJ4J6wX91fIw1CmO4sv+7RxRt4S5Z42KFsCLY2ysZF6/WMG9IpLCOSVKzmYQz5iBDjQ3cUO4Bot5s/3BttegTq4f11upiH0DubGKQcZE4gquxb495v23NaMpQ3YQ51lvP+Yqxq0xLuYxJ3DqlOkQm9RixgaHcJyiYcyt9ZR9w7UWqq8Yl3hl/FxQNetVPGyDp+Q+a0ZW0CZFc+Io+0egGHP51v0oKfYSUn7jCkfM9e0p+ZnlqqJtiOB9t2TM51trOz7vJhQXNQaumOuzKY59VHHwWd6nrPXnXt5glHPZ9VBnbKwPYk0p0xTp/I9eAXVmzsT18NKqlyF2738/bJRXrdoMdaoe5jC3ts03yun0FKhzyEFHQ6wp0QSxRx78uVHevWcb1CkrOpTRMXy2xCJZo/zcs3jPzz77EsT+5IwPGGVtD9CoR17kqM/qN4e/MBNCCCGEEFIDHpgJIYQQQgipAQ/MhBBCCCGE1IAHZkIIIYQQQmpQt+gvUEQ66aRpbDCtGYUmC6a2QKwjjSYMvaPm2b00jMn9a557BmIv/c8DRnlSHAUjbhkFFuUxRQxii6MEjVJe60XxQM4SP2oij+YEXmvWDDRlOLjbFCiOFFCYsGXFFogVHRSThWKmYKNhMgoFDj1qAcTmLZhhlMNRRWjhoFDNq6KIpJQ3502lgsKciSRQhHOeFQp0dxNEMU6IuOaaaG1Es5qhIfxcMWcKsjxlDrs+CpMaEzj/E02mmK6Sw3GSMs5r28xkSiuK8prTGNu+G7eVrdYL+kvKNAgcXCMhRRwV8i0haQj3nUQjzvWmwFxL7ugGqOPk+7FdHu59tgbTUcxnJpKRLHbwuldNA6fOti6os2kDCvw2bsF+OvDgbqOcaUKB0ZyZuLeUC9bcU8SS8QjO4XxJEVJ7tnEJXstVDHl8S6zkaWJBzfBExbFKinFJHZ/TvrNaVtoQVsTw1vOmuRkNY6Z34VjHEtiy1lbzGRjezwx5qgHuEY51jIkq7lBBDxqXlF9bC7HOvLkX9wcogu0TPDucdupRRrk7iuOU/e0jEFswaSrEVs2ZaZSfewYFce87fC7E/LjZrmdeeR7qNCTx7HXcqWdBbPeAKaTc/POfQh2vgoZwldGdEItFM0bZdXB+Ln/oCYgddIAppJw9cwbUqXjK2UQxy0NBvmIKhJ/aqzqEEEIIIYS8Z+GBmRBCCCGEkBrwwEwIIYQQQkgNeGAmhBBCCCGkBnWL/qqjmMReqpriiXgrJpS3KU5yUVcR8li59VXFoWn9K+gQU+k1XXcSJRRKZBqwXdEI3npf3hR/DBXwWqMlFGjlxOyHoiJUGrKVZCKS7sW/V2Zbie4LF8yHOnPyKFLZswfFSlXrO3tH8X4e+P8ehdj6w8zvnHkQCkZa2tG1qGMyCjy3jJpOScXym7tl7UsCH0UdvmuKRhQNiYAdoIhEfZxT01omGeXJLZOhzpQUCtT6e01BRUi59nA/jnlfP7pQlQpDRrmjDQWiySi6YY6OmcLOkIuiqlgUBVpNMZzXbZbbZlWZBppLWl5xVxvLm0KP1rLSrhjORdc3hY1lxZHTq6CrX6CIyaqWwLOirPmJZNXq1RALAnPc17yGQqjhUdxb2ibhnI2nTEHx5CkzoU7nVIwNDprzemoLCoCKZRwDRXMuviXY9ZQh8BXXO8+q6CniWU0U5AjuFY5rzoNAcQ6tVrANvjKnfN9sV8kWSIpIVBE5Hbb4AKM8d+4sqDM6NgSxoZEdEFu/zpwTY8MoBj7rw8dAbF/hKmMQcs29MT+Ee+Cm51A4F2zdArH2hDmvpzXg2B06C8Wsh5bMeb3hvv+EOmvX4vf1NaAI/NW8KWyc1NYNdQ4+7Ai8Vtkc43QjCrIzTbjetvZgf/X0maLzSBxfUODncS5WqvhMyo6Y13cF2/DCCy9A7D/+0xRzX3XFZ6BOKo3PRV8R+tqr2dnL34r5CzMhhBBCCCE14IGZEEIIIYSQGvDATAghhBBCSA3qzmHO9mNe2bBjxial8HL53CSI+cpL4Qt5M2d5eBDztypKzkyybMbmdaahTjiCeU8be/AF/X1DZhsKWt6x8jdG1Hq5+7CSZ5V3MfZsTxZiGx58zSjPnDYMdZKKMcrIEN5PYBk8TFbyyZMxzF19+Xnzhe7Pv7QF6pz8gdMhdtj7FkKsYhuX7F8pzKopie+ZMVdps5bX3N6KeV4LZ5r530N7MF+sKYVz9tBFi812hjEP31Ve4j9axNzIphbz+u3NOA/CDuZ9xVJmrlmpMAp13ADXaVwxTwlb0z8axrUVwtsRXzGDKdi5nUreaNQWRYhINTD3Jy+CfVrWJqiSB2ujtXMiyZVwPzjgoDlGuW835jAnG7DfmttxfpbL5hgcdPChUOfwI46GWKFozqFduzCP9lnFoKpYRKMksdqg5Q8H6thZRlOKOUegGFZoeofA0q9obahUcG0FSp5lsWTmCxcKmE9+wmEnQay729RArHltBdTp68exDiUV8xQrj9pX7mciibo4VqVhc64/dN89UCc9gPc/qwmfo5G0eQbIKnteVxHPL7P7Nhvl9S/vgjq79+CYN56K66a1x7x+MYLft203moY0NJgbaEta0RRt2AaxZ55Bg5PXVptmRfE4XqtawjNhvoQ573nHPMPEItg3rrIX//bpp43ymg9+AOocvQj7r6roSeyRDjTNSR3eU/yFmRBCCCGEkBrwwEwIIYQQQkgNeGAmhBBCCCGkBjwwE0IIIYQQUoO6RX8DwzmIxcJm4vTOPVhn+wAakBxawuzq/j4zMXzntizUaU2gqOqwOR1GOZzHF2dv2Y2J6MM5TPq23y/vKmKQiKIAi1h/d2idGlZEHiMB9sPuAbMP+wbWQx3t+k1xFFodevg8o3zwQnyh/byZmMzfmjFFYZvWboQ6W196BGK71/8WYm7cFMUcdfxhUGci0UQt9kvNHR/HKezj35odTShwTVovwh9zUYyVUtQG1eGsUS4Krq3ZB6LgYUonrhHHeql+KoRiosZGNE+J26K/Eq5lqWK7+npQ1DFWfc4ob1+3GepENX1WCGd70WpHbiQLdUZHUahWsUwfcqMoWMwpxkeaMNRxbNOM/UscVSjintfR1mSUp07rgDpDAygmakmiIKdSNftu1vQpUKc4igLXHdu3GuWNm3B/K+fQZCOoKGM1bLa1kEcRUjiM88eOBSHFpEQx13JdnBue1a6K0k7Pw/VWreJaClnK2NNPR5FTmzWGIiLPPfcr8/sCFMe7UdyvXEVlW66YbXUVgflEElGas3PnTqPcv7MH6sztwOdc2kFBX1PK7JNDirj2G9oSEAslTPH8lGY0DUmP4Ji/opixFarmvtsyrRvqjGWzEDv68BOM8sBOXMu/fOB/ILZ9Ry+2wbrvmGJsFQrj/uE4+JKCXM7cB6IR3BcSuMXIwKC5Lp959jmoc+hhB0AsGtFMh8z92alD4Kexf60GQgghhBBC9jN4YCaEEEIIIaQGPDATQgghhBBSAx6YCSGEEEIIqUHdoj9XyZKOxkxhzWAOE+RXbUUBx5EHY/J72dJF+A4KEmLpDMR6c6YQY3Qnfp+Say+eIuSKhcy/H3xFyGOLfUREXOvvjpji9KcJP6K2/ZmINFuub6kmdGVr7kYBw2FHz4PYMUeZsSmtGagjviJIqZhiiKndh0CdBQunQeylZ1+FWOCY9+iGFYedCURzaLPnuib6c5UxDpS/P6uuucRaJ6M4qjSEc7ZSNidt1cVxGlZEVa4icioNmW5q7WmlTgUXiZs3+8YeSxGRmOK81TZ9BsQ+Om++Ue58cTXUeWbVWoiVFJe0uCWW9ZU1WfXxcyXLwXHTNnT/yudRxKjNkWLJHI9qBQVhE0k+h+O5dq3p3jV9SifUcQKcw4Uc3luxaN6/X8U6a9a8ArHdu0yBUamEArWIsi8Wciimsx0YNWFSXU51Aa6HQkGZBwH2qe0SWFJEo+GIskY6ULx3zNGmi9/YCIrSNm94CdsVMsWO4QTeT1lxrRVP2YutpmqiyYnE99DJdIo9jw97H9R54ic/htiMSSjMO+ucjxjlzmYUkuYyOJ7NC03xWWjKJqiTfPDXEPN3ZiHmNZlz46C5XVBnTBF2xi3h/89/8iDU6dm8G2JVD8c48M1zR6mMazLsNEMslZiN16+aa3BkBJ93sRi2IRI2xZVP/Br776ST3w+xQw6YA7GqZ+4f2jmunp+P+QszIYQQQgghNeCBmRBCCCGEkBrwwEwIIYQQQkgNeGAmhBBCCCGkBnVn9MejWDUaNRPDs4o45KX16CKzfQ+6wSQSZgJ+XBEmTZqNri6//vk9RtkbgyoScvDvAk3M0GC5GrmKkCVQxBNBYCbEB0q3Oj4KRhbMxGT+8041BQuJDky2n6wI/BIt6PQX5EzRSKWIIhJHcXKqWEKZaoAih+RkTPg//LiFEBseMp3tKv7+JY5ylfF0HEsopOgDCsp49g7jXJ+WbTfKTdEk1AnCOHa29VGmBYWebkgRHo6hw5s3bC6KQhkFtcMezo1dw9vM73NxXndNwXb57eiE5Yt530e/H4Wkcw/G+fPU0+sglq9YItsGFO80N2MbNjxnCnFWv7wK6rRkFAFYGQVnY5YgsmqrlieYYkETeZltXr9uB1RJJFFkPDiM9x+OmHNozxDOn5CL86xgrbdygHM4p3RlEMbxbJ5kiqMCRZxZVfbwsiXMGxtFgd/QEDrG+g7Wi8fMdrW1oeA1m8V9QdGkSipl7hX/3x13Q52jjkLRcOu0jFEeUhwP3Sj2XyqG4+NZQkC7PNFohpqRtOlSOu2gw/Bzo3jmGOnZDrHlL5ixVwewLwtVnOuL86bgtDmTgTqpg/G5PTuZhVjQbe6DRWV+JpK4btavMUW9u7egwC/uoKVeoKzTqiX+9RVhrO+gyDYayUAsFjLX24gyFkVFpOw1mIO9YSO6wz7zzDMQmzMLxcxuYM5j++xaL/yFmRBCCCGEkBrwwEwIIYQQQkgNeGAmhBBCCCGkBnXnMJeLisFF2cxFyXt4/h6OYa5IdhQTjRszZi6kE8VkpXlHHAGxzoPMXMi1j2PeTkMY22XntIiIVAPzpeiBg7m7BcXEomTleeWURCsltVrKimlIb9bMK2xM4hDNjOOLuaMhbJfnmLmxoQjmKoWUXG6/ZOZHVT3MA/RFMXWJ4vWdhNmGQrkOI4F9iDLE8FLzQMnhhjf8i8iuXjTCWOOaRjSTGtugTiqKOcxOyMwbTeUwb24si8YlYwMY8wrmZ4cDnHdOCPPR4mkzTz2VwjxITzE8EQ/ngW/lAeeUHNHJk2ZB7KSTj4bY6rU9ZmDPTmyCiysuVTXzEdtaMZ+vWMCcxfwYmiWUy9b+Yee9TzCaiYet5Sjl0fygKrgvFksYm9Y81bxWGXPz9/ThGI8Mmzn25TK2oVDAsVPS9aV/yKyn5ZHn83gt39qvw4r5Tr6E8zqF00Uq1vw/5ZQPQZ3nX1wBsR4lf7ZYNOeQG8E5FU3guIqVBx5WclJdRYgRVrQ9Ees54vk49ycST7mPiph9kpqC2qAZJ5wKsY3PPwexFU+9YJR3VJRnWl4x0Vm53igWBOei14P7VDGH4zk9Pdcoj+3EPX3W/G6IbX3B1HsERZzXERfPY2UlPznkmu3STLnKihzJdSZBLBmzdAtlvJ9CHmN79pixsKKj++3TT0Psw2ecDLHmRnN/0gxwQnWchvkLMyGEEEIIITXggZkQQgghhJAa8MBMCCGEEEJIDXhgJoQQQgghpAZ1i/4qJRQguGImTkfjKPxIKkKweBxFTvGUGfMcFN+kWzIQa+0yE/x95U+AREIRtlVRyBKNmwnx2ov3Kznsh4Gs2dZhRShRdVGssKUXRTHPrjdvYPGkBVDHqeD9xBUDgJIlXnMj2DnRGIoOXEv4US7hWHiKAclYFe+xaokKi3lFJDaRKP4OtsjPFgG+UayimCRs3LnFKA8pgtdUGNdNJmauhxZlDrtVHJc4TllwSYjHccyDAOe1XzGv39yAgg7N6MJRXBlCniVAKeHL+AtDPRBraEKR5OxpppDSG9bMKdDApWPyZKPcnsM6L6z8LcT6B3CdptOmAizkKqq0CcQN4XgG9jxIYJvdKMaKOZyzC+ZZwqQxnIs7enZBLGKp9zTRXyiMbahUUERVrpj3WCzgPOjty0JswQHzjXKmEedwoZCGWMjBfiiMmbFYBD8XiSriOkXAZGvwGlqwH0LRN9+LFA2jhJXnj6OImb2K2YduSBM8TyAO9ptnGT8VFQFzdGo3xOa2ZSC2y3pxwWs/fhTqzJ47E2IfO/9jRrm6cxDqPPDwgxDrbcSzUGnQHKtoBPfAXAk3+t0bTIOciKNcu4LzwFX6y7U+q+hDJajg3CgWUBgeDZn7bjyK5julyhDECkXzrBAN8H6efe4FiL3yymqInXDsUUbZV0yO6tnB+QszIYQQQgghNeCBmRBCCCGEkBrwwEwIIYQQQkgNeGAmhBBCCCGkBnWL/gLNKcgSjKXbMCm7vQMFTe2trRArV82mFPIo4BhQRCTbNm4zyooWTapKcnolwKT5wGpDWBE0zZiEdk+JpCke6s0OQ53RPAoBC2X8e2VK23SjPH82up/lyiiYSioJ/hErmd/3MK09rFhouYHZicWC4lqkiMS02VR1TFFPsap5Hu5foLOfJrRRPqjESr45VjuzOEFDgSKWdcz52RJTHB87miAWVcREtk3asLK2mhobIea45rU8xfHRVYSxI1kU01XypttgTFlb5SIKxxo9FIm2NpqikVJTM9QJRRRHNN8c1/zaLVBFEzFOntwCsZLlfpfL719Of52dnRAbHsoa5bwiQK2MKRtoAZ3NmtLmZPc9FO3Mmz8VYo0JSxTnKAJRRX3jK0LSctkcz8Eh3HfXrkcRUtUSSCeTuI4SMXxmDGexH0aGzTnrVXH9BT7OxbBiK1a19saGBpyLnuIia29GmpBbU215VeW5WDH7OeLsX2LWqNJvvpjj4iourIH202AU58b7jj7SKK9+dhXU+fi550KsfcrhRnltfy/UWfo374fYLx/8b4i99pApMo6EcczXZwcg5gfmuarq4pppUvay6fPxxQLrN5tOlNt7UJCt6ZxLgvuH45vfGXYPgTrlAF1yq2XTtdlRBJ+79uDz4TfProfY+xcvNsohV3FrrAP+wkwIIYQQQkgNeGAmhBBCCCGkBjwwE0IIIYQQUoO6c5hFyQsS66XmYSXvK5nGr0jEMXdorGDm+I4OZKHOQz/9KcRWWy+ujnraG7axDekw1tszaOZeDu7EvLxQBHM2I5ZbREZ5IfykOCb85ALMMXr1uZfN74tj/vDBp2IOUOOkDohFQ2b+cLWC+T6+j4m3gWVIo70svqqk0hXy2KfVvPlZR8t93u8w+0RrcqD+ramsEat7PbtvRaTkYc5v2TKBySTRNCSUwLxjP4JjVcibedTJWAPUCZStIGzlJ/slzPuKCOZLlhTjHvu18PlRzMNP2OYmIjIWVvL1o2Y+dP/QbqgTnjIPYoVR83ODezZBHdfBtrtqvqnZF5j3PrHE4pj/2tRk5upmB9BcYbKSD/6hcz4EsYWHH2iUMzPmQJ1wDPMlHWuMGxowf7/qKbnCWWzrwK6dRjkqeC2vexrEXlr1mlEuDGPuc/cM1NloGpAd2/uMci6HRiwiuIFUqjjPojHzuahNKU06YZswOEotX9mbPHz8SDRitsHdz35SC2laKsupJaT0d0i5/4qy3zQ0m/N/8UmYd5zJoI7pP+/6L6P80GOY+/zJT5wNsVIO78crmfPMUUx7vAqukYpvjp0fQl1TqgnPCSM5zDvuHzTz6R0H95NA0bT4Sg5zyVo3UWcy1HFDqHcoF+28ZuWe4/gMfOh/noTYB0873igfcShqw+phP1sOhBBCCCGE7F/wwEwIIYQQQkgNeGAmhBBCCCGkBjwwE0IIIYQQUoO6RX9hRSQXCpsJ6+GIYvCgHMk9D4Vzm9ZvNcorn/gt1Hk+eA6vbwl5AsFr50uobpiUxnqNk00x1NZBFMkNFxXxRN5Mym+I4k2ftLAbYslGFH5sGzRfhL/mhQ1QZ1S5n2lT8PpTppiCLCekqEgUkaRftQxPlJfxP/30yxB78rGXINbSZvbz0cd3YRv2c3xVp6j0pab7skwFAqc+JY/jWmsrjGNQVN69XqngeEZDpjCiHOC8CyvNqlht9RzsiGoFRR6xGIp6PUtgk8+jkKWiGCnklLk+mjPXfFgRfuxcuwZiWzdtNsrFLL4sP/AU0Z8iei2XzfarRjYTSO8evLeGlGka0tmJQpsrlv05xJpiOFaJJnOPmNaJ4rp4Cs1TwoHZUY6rCeJw3y1ksxDL9W4xymPDipBUEaXOnm4KaNet3wF1Nm9G8d6kdhQ+HbjAFGDHYsoDz8H+CylCUq9i9k2xgHM/UDcZk7IiEguFFbF6WDG7skTtFUUoPpE4ykJzLQcNV1mLgSKw17Z1WwfYNWs21Ek14jyoeqaBWq6Az8KXX+mG2DzLqExEJJ4xx684goJX7bltP6h8RTXa04MC6YKgCUqpZF7fERQ6BoqplPYbbMUWgbv4fHBCeC6IRM0zoR9gOysVNLvatGkjxJ588mmjfNjBKAoP1fHzMX9hJoQQQgghpAY8MBNCCCGEEFIDHpgJIYQQQgipAQ/MhBBCCCGE1KBu0V8m0wSxSNzMrm9Io9NSPIGxHX0oznjuFVOQ0z+A7ksJF4ULTSGzDZ6PfwOMljG9v394DGKZhCkQmd2GYqJioDkE9hrl9gQ6QklpFEK+kjO/cKrpMNUSx0q/Wb0eYvf/4D6ILT75cKPc2pKBOqEAr79uvZk0v2rNZqjzwqtbIVZUHIMaU6arTzKK82Ei0RzadJGf/bn6YhLYoj9NHaa4LVoOjIkEii46J6PQqm8PulOWy6Y6MJLCZR9Po5Al02HO/6gi6i1WUEwTi+G1+gbMNWK7k4mIoBREJKH8SV8YMwVZo72KC1wfXj9iifdCPq7TgQEUlgQO1rPHOhZDAdVEUiqheLFaMve8liZ04nvu+RcgVhrrg9ipH/6oUW5I4bWqviKQtlXgSp1KFedU3yCO8dbd/WYbGnG/Tiuusu2TTdFfvoBzZdu2bRCLKsL3qvVsWbHiUajjCe79jq8IY8vm/plO4Zr3lf6Cayt7jBYLhTBWsQWDitB3QlG2T9dS+bnKmwY0V8NAcfUsWc/DqDIGZQ/7ZGqnOae6p6NjphNGIemugZ0Qa7JePlAq4H7tlJQzRtW6b2W/LitC0qJyDPQDcw/3lb3SVV6w4CjzxbdiZR8/F42gk20kMNdzvoDiXClj2yuKI+dDD68wyqedcgLUOWj+oXh9C/7CTAghhBBCSA14YCaEEEIIIaQGPDATQgghhBBSAx6YCSGEEEIIqUHdor9KRXH5CsyYM4KuK8NxdFp6+MnnIfbMy6aQrRgojj6K4CHnm0nsMUUTMaIoBUKKY184ZAoepkXxfmZOboXYoQtmGeVMEwrbNry2C2KPP9cPscmTzO88ctGB2IYAnZyCEbzW6CuvGuWV21BgEG9GcYJr2b6lYjj2Jxx/AMTmzJkDsca0ea1QdP+yRNPEZyDeU4SemotSoOljrGqe5kKlCHLsy2tuc1MmtUPMLaGwpL8/a5RbmzqgTrmEcz3imEKuWByFbUEZP1dV+rRUMQU2FcUhUBOJhTShVdW8VnYE18ORiz4AsYE9pnDsycfXQZ3RURTBxhIoYoTx2c9+eigU8D5ClkhnyyAK27asfxViuTEUYKcmm/vSEceeCXUCZQ93rN9oHBfndSKRhtj7jliMbUia9VIp3HeHFYfAAUtA2DkVBUelKq6j3Tuwv6RqzuO80u+pBk2oh/c9VjQ/WyjhvE6lcM37lqItGsVnrrbHeIoSrlIxBcLK8EworrLQHBD5aXu6Iu4OcA8S17x/J4J73sgoigVfeaXHKJdz+LkFc9D5MqK46Loj5vgN9+L+U87hGEetWyxW8f6ckCJOdpR9XczvDIWwDX5JsZpVzia24FRzopw5E53+5nedYpRXrEAHv4Li9FdSBJHr1m8yys88i07FFP0RQgghhBDyB8IDMyGEEEIIITXggZkQQgghhJAa1J2h5PmY79SSNnNf4hF8IfX2TXsg9koWTS+yY2ZeUFg5y2vvbPfsPGqsIqK8tDwSxjyXKZPMF4YfOBVfxn/AvLkQCzWb16oqL+/evhONUkZdzA0cHTTz2Ba3Yc7agbMxB7VHMReYYeUFtc7GXL3MlCkQa2nNGGUlzUp2j6JBRiyCeU5SME1qSlXM/9rfgNxLzaSkjnxlEZyPrnotDLpWGxxXeXF8BGPpNOa2DfWbc6q9Cccpkcbc/D2WicfwKK7J1ibMN02HsQ2JuFlvaBBz+p0Q5tyFlWt5Vu6hI1gnEsZ7tHMdo4rZSFoxcNHyJotW/mdEMYGYSMJhpT2W4YKrTMaKkrR66KJjIfahsz5slCOKWY0oJlL2Xuyp6wHbHk+gcdbBhx5tlLV85ZbWGRBLN5omOv3DaKSVyTRArFpUzCis52IkioYkbgRzPWNKvW3bTWOGSkUxn1FMXRJW31frzOGt+nh9z9IfuIp+YyLRTElstHtV7aKUuedam7jv4J4UhHGNtLTNNsq/fQrNvnat64HY1X/11xDbvW23Ud70kmKGoxh2hCyjkpCPucLi4BlNXC2H2axX1h7bAX4urDynArtPBdfbrJlTIXbKEnPfWfva/VBnw44NECtXUUcwPGaaBw1l8TxWD/vXaiCEEEIIIWQ/gwdmQgghhBBCasADMyGEEEIIITXggZkQQgghhJAa1C36iyfxbN3WbAoXQoq5wuDQAMRKecwgj4mZLB4STB6PKKqqmCVSiSl3lFFik6J4/da4eT/JNAqadm9B84/SOvNF+A1tKBbctRmNRUYKKM4oRMx+3pbFF3NPnYtClp2hLMQGpphJ+XOaJ0Md5R3iEkTNDgsUhZvv4BiO5DCRPulboglv/xL9aeYKYsUUDckbfE4zKAjevI4mILTQtC5FxfwjmkSx0uTOaUa5XERThkwjiramtptCq8FBFGvs2JKFmKMImqKW+UdBkeFEg1GIpdIoSo1G24zyls0oIKxqxh2WyqfqYZ2K8iL8SEjZQCzBVFQTvE4giSQKcrySOdF8Zf4EVRyXCy64AGLdM8w59cQjD0Gdvj29EFt05FFGedpsNDuqKGvECxSDB2vvj8bRuGRsDOfs5KnTjfLhIVxcu3dh2ytl7JvmRlMImIxhG8JRnGeuIr4a7s0a5bgieNWMliqWQUVF2a/DiiA/pAi04paAMBDF3GMCsU0wtJgmotZUfyEf+9d+PlVd3A/cFF6sa565Hrq6F0CdnlX4sP3FD5+F2EHvsw1OcOwc5XxkCzRDiiGJLSYXEfEVN62qtVdqBkOaGLpcVs4K1hmgIYlzasE8HIuuaebamjtrPtRZuwWNllwf+2Z0bMQor351DdSpB/7CTAghhBBCSA14YCaEEEIIIaQGPDATQgghhBBSAx6YCSGEEEIIqUHdor9kChOpxTOTt0cHRqBKSPmKcIDCL8d2FFK1WIrjlpV4XhG8dkgRVVUDFOn0DJif3di/Beq0hVFQcPQ8UxzVoritNbWhECpZQNemqiXY2KUIZ2Qd9oMTwWuNFM3xGVEsD3OKKKY1bY5ZRBHFNERwXAuK2MQpmd8ZVND1aiLRBA+25kgT+OlOf5qflCW0UgRN2rV8awEMD+Pa2rVrN8RaG1H0F042mtfKoRDX6UdRakPKFJs0RlC0UgmjKOaF9ehyNWjpDBtTKEhpTmD/pVN4/SmTUka5pakR6lSLKEAdHDTdMDVxlBvCfc5RNiPbES0SUQREE0hYcTL1LEFOWHEs++RHzoFYKY9izC98znQoe+nZ56COryiKZ3SZguWPfuKTUOecj2MspIyLvZIaGlNQJ57CexwZMfe8SASFer6H49nejmLrBkvM6pbxnmOKqrdS1Fz8zJjj4H7texgLQ98ov4Mpe7irzWvr8prIbkKpQ/QnihjNryr7rqcI2TzzOe26uO9WA0VI2mXOvYVHoOgvuR3nT/9GbIM337zW3Ll4rZEduMd6lm1m2MF5rQn4GzO4biKWW/FwFoWrjiIq1OZe13RTxHjc4iOgzuRJ6FTcYDlJH3nEMVDnV8/+EmK5KoraHcvNcMOmjVCnHvgLMyGEEEIIITXggZkQQgghhJAa8MBMCCGEEEJIDXhgJoQQQgghpAZ1i/4iCawasbQGbYrwpRLGJPOcIkCoWiKaQHH1w7Rzkapnu3fh9w0pxj/hlOLulDMr7ugfhjoHKOK9xQ2mI01KETQdNBsT65tbsK0lSzPi51H0N/QMirZGoyhi3BM22zUt2QZ1fMXpL5czezoaQqGFq/RpVBEaub45b5yyIh6dQGyhhIhixqeJ/lT3Pww6gamiqVf0F7KELMUizv58DsUnTUmcn7mCOchDI+i0tHsYhV3tGXNOtaHxpTQkUYR00FQUm2zpMa+/oxfn8EgUBYsSRgGHBKZAcXYnOlgOD+K6GR0dMsqhqCL6CRR3LGWO2BMAhVcTy9AQih6rlsg4Eca58vLLr0Ds3p/fC7HhIXM8oxG8VthFh7LVGzcZ5U3fuAXqjI7hXD/ttNMg1jdgil6LRRRoTZ48FWJTp842ypUk7p2zZndDrLurC2K9veY8692yCeoEozh/knEU/eUtoWp2ANdkNYeLMNHebl7HdlcVkYoiPAwrwu1K1RJpB7i+J5Kqthc75tpzlDqu4ownLj78PNfsu0BwP3CU7aApYwanzML+3tGvzE+ZBLHKiCmMP/T4eXitTSiS61tvzik3hPtw2ccxT2dwnXZ1mf216rdQRfIFFPC3dOA+cOTiWUa5+0BsV7olA7GdY6aYe+r8w6HO5El4ptm6bRvE3Li5xncpz4d64C/MhBBCCCGE1IAHZkIIIYQQQmrAAzMhhBBCCCE1qDuHueApya4h8+NtEcyF6VWMKpT3ikOuZ1RJFNLyZqu+ma/U0t4BdQ4++GCIHbHwUIi1NZoGJK8p+XyxkZ0Q6/Wtl9ePYb5yejLmni2elIXY4K4dRnlnAXOh/GHM0Rruw1zPV37ypFHOrdsAdeYeMhtiXfPnGuVIk5LX6SovXC9h7lzfHjPf1K3sXy/CV3wAJPDNiabl8dWbwxwouYM2Ws5dxDKVaEhg3ped5ywi4tsGQCJS8s1YNYQ5m5Uy3mNpwMyR7h/AvMuEr5gQVXHNe0VLD+DhfM3ZCfwiUvIyEBuw5n9DGq81uRXNTALLCMJV2q7l4ZcrmFPrVe18wbq30n1CJIR7sYTNeZAdwRzZlc+9ALFYArUpoYg5h0pVnOd5D/eDkGvWqyjGSf/yL9+G2M/u+QnEnKJpapNQjG+aMhmIzZl7iFFeePzJUOfII98HsVQK9/Vp080caecwfK786sEHIfbiM09B7LAjzHZJGuddOIzr1LUMvfwq1nFczaQEx8zew4Jg/8rN93zFzMWKaS3WTFocR3m2uua69j28mq/kATuWYdqUGZjL6+XwOZpYj+u0am2Dk2bitabMxNzd/g3mevYV7VGg6AqyY5hbffrhVt60cqZZ+TRqvMoFvP5DDz5jlB/7Fa75VBzvJxQ15/WypWh4MnfWCRDr2fJTiNlrZHRY0cbUAX9hJoQQQgghpAY8MBNCCCGEEFIDHpgJIYQQQgipAQ/MhBBCCCGE1KBupcrsQ46EWKzHfEF0YmwI6iyYjGYEkSFM+u7PmgKRqO2KIiLiYKzim7FTTz0b6nzgY38CsXQGRUFx1xS3LDoaE8ojMRQmxS2B4tgoijX6x/ohFolisn3b0EajPNK7A+pEtuO1YhF8kXmnpWkKF1Dks3PVeoj17TBf6p3pRCFl86QWiLV2YL1I2BQ7Fkp7l2z/TuFVNeMSy0RHE/MpMV9xILE0qYodj0jYVwSuluAhqoh2AsVQo1hBIRuIe5S2hxTjDa9sfq5/LA91SiX8PtVkJW+uG+1zUWVtqftA1JxTm3sVg4cIilRKlggtUNoQjih9WkXxGugtNSXzBHLc4mMh9uijjxvlWArFRJVRFFVVy5pQ1+ynkrqucT1ULHFUKo5tGCvg82Hjts0QS8TN/botjmMeCuFc/M9f/JdR/umjK6DOTTd9A2LzD5gPscaUKcaNJrENH7vgAoidcMoSiIljzrNXVmO7+ntfhphniZI1Y42QZvhhb06C+2E61YoXm0DcANesfcOu0gGO1il7rT/XzKfMWCqN4re5h+Dc2LIV72fI2j+dBM7hafM6IfbiU+ZZoejjvhgoZi2K5k9Gsma7TjplJtRZ9yqa9AwNYt94vnlWKI7imXAkwPOEHzaNfP6//8SzSiaGIttoFAW1rmPuKaHK3u3X+9cuTwghhBBCyH4GD8yEEEIIIYTUgAdmQgghhBBCasADMyGEEEIIITWoW/SXTLVDbPIUq6wk0be0oKvY1FFMDF+zwUxYt917RESKVRQA7Rw0xSaRNCbWH7DwQIjZzi8iIju3m6LFUCM6XE2Z3QWxZMqst3v7bqizbQ0mrIcPOApirY3HG+W+l38FdfqGH4DY8Ey876nt5gAdPBkT60M5dGUb3Jk1ylteWAN1ntozBrHmrm6IzZplfmc0rog2JhDN7cq3RXiqg58mBMTr21cPFPFJVRHkFCzXxGwOBXddiiDOUdzrSpYjmibKc0Pa/ZjtKnrYzoqDa6SoOCOOWlqTquKgJQEKZUJRvH5jxhSNZEexb7btQhFswnLjKzvonhj2UeBX9vH6VWuwfVEsIyeQKZMmQSyXM4UvFWW+lsq4HqJhfEyEQmY9VxE9+soasR0RS4qgslpGYZIXRZc0z56zVRwnv4pzNj3VdHR18ljn1VdQXDfUvwdi9957n1Fe+pcXQZ0pk1AMnXBwvmzvMYWNKx5/FOoccjBeK7DUa44iIg58HFdHEfqGLAfXhhQ6sE0kfgXFpSFr7bnaWtSEgKoE+83xNHtYz14PeO1IA4rwSkmc62t3mM/WuSP4goK2LnyWJzvNzxV2KA6lmuNjEa+1a7sl+jsBxbkHLMRnza8fy0IsEjav7ylzsaI8W8plc+9f+xo+C1IuxmJx3Pvc0FqjPKkJnZfrgb8wE0IIIYQQUgMemAkhhBBCCKkBD8yEEEIIIYTUoO4c5tXPYD5V0GjmnUQwNUWmdx0CsRMWvA9izY8+ZJSzm9ZBnfW9+EL7VVa+5PMvPgN1dqx9HmKei/mSVc/MFYqm8AXbvQOYxxYdNN/8PTqMuUN+FTunVFFyoazcwDCmgEvZwdyhShJzjDYOmzlTzbMwD31SezPEZnVPNcozF+D3bVyDhiqr1uyC2PNPmEYsC4+aBXUmEk9JqYYcZgUHnCsw51dDy2H2lTfo5y0DkkElh7lYwfzPRiV/2KuYeeojI/imeq1dYWsuiqtsF0pfVaqKeYqVt+YrCd+JJOYUNyi5Zk7Y/Ds/pphFjI3hGhwdNvePIIpzv1gehlhOyeutWP28v+Uwq2Y7Vlkz2olEldxyJWfTvnxzcxPUCUXx95jegQEzoORUhuOYr1xQ8u6jYu7hrS04nh0d2K5S2jLJqmSgzugY5ptm1+Lc+J9HzefiUYvfD3XuuO1WiLU14pydNt00o+jtRS1MJDYNYoE1F+3y72K4diMx7OeKb+XUhjBHdCLxSjgu9vap6UscxURH8xqyc/GVdFs9X9/KSXcVk7XAwTk8A303ZOPyDUZ51cuYk3vEYWhM1DTDPAMUtuMZxxOMhd3JENu8IWuUB0fw2X60kte8YW0WYoO77UOM8nwND2DMquZ5eH4pepjTf/aHz4fYke8zn3nzulHXVg/8hZkQQgghhJAa8MBMCCGEEEJIDXhgJoQQQgghpAY8MBNCCCGEEFKDukV/MeVoXXTNRPdXC/gS7pEtOyF2aBKFPNMXzDfKicZWqLN9NQoBJ4f7zXZWUZjx4E9+BLFKCAUPhy460yg3tqHAYtvOtRCr5M1YKokvAi+VOyG2Zzf2TVgsAeHQdvy+CgrAsmMotBoZM1/yntmKgsX0rCkQK0RMkVhTBoUfBx+N4r15B3VDrN96GX+iZe9eGP5OESjCJ1uGpEkAA00YqGj+bHGgqwgDNa2gZ6mqxor4wv7BIRRKpBxFpWKJtnxF6Vio4NoNh802hJQbrJZQeBhSBDZxy2QlV8b7SSZQkNLYiPMlHDbno1NFkVMkjp/LjZltzRVQROwU0cinVMH+CoXNvtCERhNJoYr3YY9KBLtbIgnsy1JeMRKxuiSuCDbjCdxjd9hmCsrcj8WwYW1TUPDT2GyKjjpn4F4mihhz1HLRKeXRhGnXwCDEfAfbFbXmWVkx19o+gCY6FUVkGxoy56OnCYshIlLyzD4tBzhfXaXtvot940TN7/QVQ6OJpJzD53vIMmCJRvBY4yriUr03rc8pY+Apk9a31IGaMZp4uFe2deFeeeQS89xRyaNYsBRgPyQnW+JPpR98RfQngs/34WFTlLplG+6VB83H9bb4/bhOH/qF2dYqbifiK6ZVjjWPA1FMuQJcb24Ez1pLL/hzo9yU3DsDNf7CTAghhBBCSA14YCaEEEIIIaQGPDATQgghhBBSAx6YCSGEEEIIqUHdor+pbdPxw67purOr3At1/EoWYiMrn4RYLGmK/Nq6F0Kdc69GB5e+TWuMckJJ0u8bRle617ZhrFIxhUie5mKGefsylLXFdJqYAN16xsbQca1aMWPxMAozknElQX4ExQO+ZybEF4ZQLOgUFLeviPl3lOsq19ZcwlKYSN892xzXiqtYF+5n1CXgenNTv/Gr/T4RRaQQKBfzLPFe4KGISxThXCqCoouWTMYoRxUHtsHhLF7fEvyUSoqAqojzwKvi/VQq5rXKVexjxQxTRHHkdMOmmCweU0Q4isDGs2LNregCN9qHYpqqIqhtSJiCs0hk/3JEGxpFQagnptqmtQnvv5BTnNQC5XcVa36OjmK/lYp4reaU2W+2A6SI7lLYnGiEmF8w5+O6FzZAnVgcH3FexZwvfb3Y9knT5kOspQ1FTp419UpVnHfFCq7dsQKu3WHbXTCMbS8rYrK8b/ZDVXkGuooQN1xGIVe1bLW1jM+MCcVX9kHrGKNsseLX+dsgiLQVV7+wMi6OZ8Y0jaGjNKwSoKCva7bpMJxw0cFycHQzxPK+OZ5OGPetaklxAA3jPCj75nO6fxD7YWgAr981E8W/XfNMx8qeXfi5YATXt3jWnHVwbfnKeWLDRjxX2WLjzIK9O4fwF2ZCCCGEEEJqwAMzIYQQQgghNeCBmRBCCCGEkBrwwEwIIYQQQkgN6hb9nXzU0RAbGDSFc9nNmGzthVH4sW43Wr3sWW8K56Kb0OEuMxWd905bfLpRjldRpLCt5yWIDSv2amXLHSufx2uVSyieyOfMz0XC6BwVjWLCejaLfVNoN5PTvari2qRp0iooyPLL5mfzHtYZUy5WDVviBEVoUlFEK7FYAmJuxBRoRRWHxYnEUUQd4P6niJA01FqWo5fydWowsEQ64TDO11QShWaZNPZvJmOOSybZBnX24NBJXzZrlPtzuG4rJZwH5bLiTGU5CZaU+Vos49oqKiJby9hLPOX7AsW5sH/AFJ9ofdoAERFF8yoxa424mvPjBBJOofjGFjEXC9hvToCPBE3k5FnjnkzhvGtrQSFPqsuM7dmD4sS+XnTZ69vdDzGxBINNGWzDrNnoSGrv18NZRUimiLZ8ZYWHo+YajMSxDQ0ZFFdGFBdE13JmK43i3q+J19yQKYx1lf3KVRzeHM3ltGJeX9GNTShhxcnUcSyHu0DZNJR57dgbiYi4Vv96nuLIqG3i1hpxfKXjlP4OOSmIVb0ho1z20V04nuyG2NDIVqPcO4Dni1AMz1ChBPZDrmyu05278QExqUkRhIZ3Q+j8T002yqtX4efuvxdjxSFzjQQOni/jaey/AUWM+PJLprD34AOUnb4OIT9/YSaEEEIIIaQGPDATQgghhBBSAx6YCSGEEEIIqUHdOczJBOaKeE2mKUXSxbyQgYEsxPoHMcco8MwXSUd8zPHa0dMHsVU7zNznqZk01Jk67yiINcw4EGLDY2aO0c5ezEWePKUDYjM6TzUDitnCNuVl3XkP60VSpkFMg49/0zS1Kvl8vZjzXbZcViol5UX4ZcxfKlh/RwWKuUDZx4SfxkDJk7P6QjWnmEjCyt+MVt6aZiyio+QO2jnMWq6r0gQ7T85VXsYfiWF/l6qYjzkyZK6ReATvJ6m8FD4dMb80H8XvCzt4P7ppiDnwFful9CJSUPKa8xXFIMcy84kpucjJRtw/AsskYKuyn0xWcn8VnxcJWUGvHrObfciixSdCbOOru8zya6ugTqmCJga+ksdpp3F2TkHDnIjiDdDfb/b5SAm/L5zED9omTCIi+dGsUZ7eirn5eeV+hsbMfT2sGEEVFLORaAlzvu2cZdfWf4hIUcmnTyfxeQqmJ8peofhYSdQyxAhpe4xiZhJysJ+jUfMZPr29C681gbgB9mVUzPtwNCMo5VqB0k9RK/9bS+HWjK3s7lUkUqBL+V1QMSZLmnOqUkRjnZDshNiiQ829a8MLW6DOli2oGSgXJkPMi5lnu55teO45bB6e93YNvgixSMI0AWrBLVakMoQh38y3jsVRsxNLYP/Fm3EN9uw2dRHFsU78nCZgseAvzIQQQgghhNSAB2ZCCCGEEEJqwAMzIYQQQgghNeCBmRBCCCGEkBo4QVCnKwMhhBBCCCHvQfgLMyGEEEIIITXggZkQQgghhJAa8MBMCCGEEEJIDXhgJoQQQgghpAY8MBNCCCGEEFIDHpgJIYQQQgipAQ/MhBBCCCGE1IAHZkIIIYQQQmrAAzMh7zFWrlwpixcvllQqJY7jyIsvvjjRTSLkj57u7m4566yz3rTeY489Jo7jyGOPPTYeW7ZsmXR3d79zjSPkTbj22mvFcRzp7++f6Kbst/DAvI/ZuXOnXHvttTykkAmhUqnIeeedJ4ODg3LLLbfIj370I+nq6proZhGi8p3vfEduv/32iW4GIe84v/71r+Xaa6+VbDY70U0hb0B4ohvwXmPnzp1y3XXXSXd3txx22GET3RzyHmPjxo2ydetW+f73vy8XXXTRRDeHkJp85zvfkba2Nlm2bNlEN+Vt44QTTpBCoSDRaHSim0L2I37961/LddddJ8uWLZNMJjPRzSEK/IWZkPcQvb29IiJvuiHncrl90BpC3nu4rivxeFxcl49f8tbxfV+KxeJEN+M9CVfsW6Cnp0c+/elPS2dnp8RiMZk5c6Z85jOfkXK5LIODg/K5z31ODjnkEEmn09LY2Cinn366vPTSS+Off+yxx+Soo44SEZELL7xQHMcRx3H4nxzJPmHZsmWyZMkSERE577zzxHEcOfHEE2XZsmWSTqdl48aNcsYZZ0hDQ4P82Z/9mYj87uB89dVXy/Tp0yUWi8n8+fPl61//ugRBYFy7UCjIlVdeKW1tbdLQ0CBnn3229PT0iOM4cu211+7rWyUTwNatW+Wyyy6T+fPnSyKRkNbWVjnvvPNky5YtRr3XcyVtbr/9dnEcZ7x+d3e3rF69Wn71q1+N75UnnnjieP1NmzbJeeedJy0tLZJMJuWYY46R+++/37jm6/nCd911l1x33XUydepUaWhokHPPPVeGh4elVCrJVVddJR0dHZJOp+XCCy+UUqlkXKNarcpXvvIVmT17tsRiMenu7pYvfvGLUO91Hn74YTnssMMkHo/LgQceKD/96U/VNv1+DrOG7/vyzW9+Uw466CCJx+MyadIkueSSS2RoaKjm58gfH9dee618/vOfFxGRmTNnjs/3LVu2iOM4cvnll8udd94pBx10kMRiMVm+fPkbzqPXP2OfK9asWSPnn3++tLe3SyKRkPnz58uXvvSlmu3aunWrzJkzRw4++GDZs2fP23nLf5QwJaNOdu7cKYsWLZJsNisXX3yxHHDAAdLT0yP33HOP5PN52bRpk9x3331y3nnnycyZM2XPnj3yve99T5YsWSKvvvqqdHZ2yoIFC+T666+XL3/5y3LxxRfL8ccfLyIiixcvnuC7I+8FLrnkEpk6darccMMNcuWVV8pRRx0lkyZNkjvvvFOq1aqcdtppctxxx8nXv/51SSaTEgSBnH322bJixQr59Kc/LYcddpg89NBD8vnPf156enrklltuGb/2smXL5K677pK/+Iu/kGOOOUZ+9atfyZlnnjmBd0v2NStXrpRf//rX8olPfEKmTZsmW7ZskX/913+VE088UV599VVJJpNv6Xrf/OY35YorrpB0Oj3+YJ80aZKIiOzZs0cWL14s+XxerrzySmltbZU77rhDzj77bLnnnnvkIx/5iHGtG2+8URKJhHzhC1+QDRs2yLe+9S2JRCLiuq4MDQ3JtddeK7/97W/l9ttvl5kzZ8qXv/zl8c9edNFFcscdd8i5554rV199tTz99NNy4403ymuvvSb33nuv8T3r16+Xj3/843LppZfK0qVL5bbbbpPzzjtPli9fLqeeeupbuv9LLrlEbr/9drnwwgvlyiuvlM2bN8u3v/1teeGFF+Spp56SSCTylq5H9l8++tGPyrp16+S//uu/5JZbbpG2tjYREWlvbxcRkUcffVTuuusuufzyy6WtrU26u7vfUq7zyy+/LMcff7xEIhG5+OKLpbu7WzZu3Ci/+MUv5B/+4R/Uz2zcuFFOPvlkaWlpkV/+8pfjbXpPE5C6uOCCCwLXdYOVK1fCv/m+HxSLxcDzPCO+efPmIBaLBddff/14bOXKlYGIBLfddts73WRCgBUrVgQiEtx9993jsaVLlwYiEnzhC18w6t53332BiARf/epXjfi5554bOI4TbNiwIQiCIHjuuecCEQmuuuoqo96yZcsCEQmuueaad+ZmyH5FPp+H2G9+85tARIIf/vCH47Frrrkm0B49t912WyAiwebNm8djBx10ULBkyRKoe9VVVwUiEjzxxBPjsdHR0WDmzJlBd3f3+F78+nw/+OCDg3K5PF73k5/8ZOA4TnD66acb133/+98fdHV1jZdffPHFQESCiy66yKj3uc99LhCR4NFHHx2PdXV1BSIS/OQnPxmPDQ8PB1OmTAne9773jcdeb9OKFSvGY0uXLjW+94knnghEJLjzzjuN712+fLkaJ3/83HzzzTD/gyAIRCRwXTdYvXq1EdfmURD87txhnzFOOOGEoKGhIdi6datR1/f98f//9XXZ19cXvPbaa0FnZ2dw1FFHBYODg2/L/b0bYEpGHfi+L/fdd598+MMfliOPPBL+3XEcicVi4zlpnufJwMCApNNpmT9/vjz//PP7usmEvGU+85nPGOUHHnhAQqGQXHnllUb86quvliAI5MEHHxQRkeXLl4uIyGWXXWbUu+KKK97B1pL9jUQiMf7/VyoVGRgYkDlz5kgmk3nb98AHHnhAFi1aJMcdd9x4LJ1Oy8UXXyxbtmyRV1991ah/wQUXGL/IHn300RIEgXzqU58y6h199NGyfft2qVar498jIvI3f/M3Rr2rr75aRARSQDo7O41ftxsbG+WCCy6QF154QXbv3l33/d19993S1NQkp556qvT394//74gjjpB0Oi0rVqyo+1rkj58lS5bIgQceuFef7evrk8cff1w+9alPyYwZM4x/01KjVq1aJUuWLJHu7m555JFHpLm5ea++990ID8x10NfXJyMjI3LwwQe/YR3f9+WWW26RuXPnSiwWk7a2Nmlvb5eXX35ZhoeH92FrCXnrhMNhmTZtmhHbunWrdHZ2SkNDgxFfsGDB+L+//n9d15WZM2ca9ebMmfMOtpjsbxQKBfnyl788nu/++h6YzWbf9j1w69atMn/+fIjbc/N17INCU1OTiIhMnz4d4r7vj7f39bltz+XJkydLJpOB75kzZw4cQubNmyciArnctVi/fr0MDw9LR0eHtLe3G/8bGxsbF++S9wb23vpW2LRpk4hIzfPL7/PhD39YGhoa5KGHHpLGxsa9/t53I8xhfpu44YYb5O///u/lU5/6lHzlK1+RlpYWcV1XrrrqKvF9f6KbR0hNfv+/kBCyN1xxxRVy2223yVVXXSXvf//7pampSRzHkU984hPGHqj9qiXyu/8y904RCoXeUjywRK1v1OZ3Ct/3paOjQ+68807131/PbSXvDX7/v968zju1jj72sY/JHXfcIXfeeadccsklf9C13m3wwFwH7e3t0tjYKKtWrXrDOvfcc4+cdNJJ8u///u9GPJvNGsny+3rjJWRv6erqkkceeURGR0eNX5nXrFkz/u+v/1/f92Xz5s0yd+7c8XobNmzYtw0mE8o999wjS5culX/6p38ajxWLRRAnvf6feLPZrPF6Q/vXWpE33i+7urpk7dq1ELfn5h/K63N7/fr1479ei/xOdJjNZuF7NmzYIEEQGO1et26diMhbcvKbPXu2PPLII3LssceqhyXy7uOtng1+fx39PvY6mjVrlohIzfPL73PzzTdLOByWyy67TBoaGuRP//RP31K73s3wJ6U6cF1XzjnnHPnFL34hzz77LPx7EAQSCoXgV4m7775benp6jFgqlRIRnOSE7G+cccYZ4nmefPvb3zbit9xyiziOI6effrqIiJx22mki8juTid/nW9/61r5pKNkv0PbAb33rW/CL1+zZs0VE5PHHHx+P5XI5ueOOO+CaqVRK3SvPOOMMeeaZZ+Q3v/mNcY1bb71Vuru79zrfU/sekd+9seP3+cY3viEiAm+C2blzp/HmjJGREfnhD38ohx12mEyePLnu7z3//PPF8zz5yle+Av9WrVb5/HgX8lbPBl1dXRIKhYx1JIL7cHt7u5xwwgnygx/8QLZt22b8m71eRX53cL/11lvl3HPPlaVLl8rPf/7zt3AX7274C3Od3HDDDfLwww/LkiVL5OKLL5YFCxbIrl275O6775Ynn3xSzjrrLLn++uvlwgsvlMWLF8srr7wid9555/hfd68ze/ZsyWQy8t3vflcaGhoklUrJ0Ucf/QflKBHyTvDhD39YTjrpJPnSl74kW7ZskYULF8rDDz8sP/vZz+Sqq64aP/gcccQR8rGPfUy++c1vysDAwPhr5V7/ZY3/VeW9wVlnnSU/+tGPpKmpSQ488ED5zW9+I4888oi0trYa9T74wQ/KjBkz5NOf/rR8/vOfl1AoJD/4wQ+kvb0dHuhHHHGE/Ou//qt89atflTlz5khHR4ecfPLJ8oUvfEH+67/+S04//XS58sorpaWlRe644w7ZvHmz/OQnP3nb0osWLlwoS5culVtvvVWy2awsWbJEnnnmGbnjjjvknHPOkZNOOsmoP2/ePPn0pz8tK1eulEmTJskPfvAD2bNnj9x2221v6XuXLFkil1xyidx4443y4osvygc/+EGJRCKyfv16ufvuu+X//t//K+eee+7bco9k/+CII44QEZEvfelL8olPfEIikYh8+MMffsP6TU1Nct5558m3vvUtcRxHZs+eLf/93/+t5rf/8z//sxx33HFy+OGHy8UXXywzZ86ULVu2yP333y8vvvgi1HddV/7jP/5DzjnnHDn//PPlgQcekJNPPvltu9c/WibuBR1/fGzdujW44IILgvb29iAWiwWzZs0KPvvZzwalUikoFovB1VdfHUyZMiVIJBLBscceG/zmN78JlixZAq9F+tnPfhYceOCBQTgc5ivmyD7ljV4rl0ql1Pqjo6PBX//1XwednZ1BJBIJ5s6dG9x8883G64iCIAhyuVzw2c9+NmhpaQnS6XRwzjnnBGvXrg1EJPjHf/zHd/SeyP7B0NBQcOGFFwZtbW1BOp0OTjvttGDNmjVBV1dXsHTpUqPuc889Fxx99NFBNBoNZsyYEXzjG99QXyu3e/fu4MwzzwwaGhoCETH20o0bNwbnnntukMlkgng8HixatCj47//+b+N7tPkeBP/vFXb2a0J//9Var1OpVILrrrsumDlzZhCJRILp06cHf/d3fxcUi0Xjs13/f3t/Gi3ZUZ754rGnnPOcPFOdoaZTs6pK84xAKoRsJCZfYYb27bYN7vaSacB/9/XQvWwujQDbvRquhzYs23DbGNvQtG26zWCQBBgEyEhCU0lVqlLNc9WZT56Tc+Ye/h980eo3nlepREjKwv38PineitwZO3ZE7Dip94ln48bkDW94Q3Lfffcll19+eZJOp5NLLrkEvruXY+V+wCc/+cnkmmuuSbLZbFIsFpPLLrss+ff//t8n58+fh7rkx58Pf/jDydq1axPXdZ+dC8aY5D3veY9af35+PnnLW96S5HK5ZGhoKPmlX/qlZP/+/eq+Yv/+/cmb3/zmZ+fLjh07kve///3P/rs29uv1erJnz56kUCgkDz300Etyzz9OOEmi/CZPCCE/Inv37jVXXXWV+cxnPvOscyAhhBDy4whzmAkhPzKNRgNif/iHf2hc1zW33HJLH1pECCGEvHgwh5kQ8iPzkY98xDz22GPm1ltvNb7vm3vuucfcc8895q677oKzbgkhhJAfN5iSQQj5kfn6179uPvjBD5oDBw6YarVqNmzYYH7u537OvO997zO+z7/LCSGE/HjDDTMhhBBCCCFdYA4zIYQQQgghXeCGmRBCCCGEkC5ww0wIIYQQQkgXelbjdNp1iNluSq6Ljl69Zki/UDewF5qC7Rrlc0n8vJ+L4whi//1z/12UP/vZz0KdhaVliEVK28NOKMqdTgfrRCHENGerIAiet067jdf3PDks6vWW0k7sh1Q6hdfvtEW5VqtCnYWFRYi9XLzh/3gjxFoN2cawXYM6roP377nKmHLlmApjD6oMDIxDLFcYFuVOhN+Xy2cgllb+BB4uDohyHGI7Uy4+O8+R42B1pQJ1EmXO5wt5iC0tSveptI/9UBooQmxhbhZilbo8wi6Txe9LZwKI2drDZguf62plBWLVFs43J5WWARfXji/8j/sg9nLxp3/2PyHmuLLPoxjb3FbWG0202W7JNaHRwHnteTg2qqtyHdyxcQzqzMzMQOyvv/odiFVDeT9e3IQ6G9fg2BguynFWW8W12TjYN7lsGmKZQLbBMTiuy+VViIUhzmdjvZNsS3FjjKnV8PhGe15q67yvzLdUCp/P+Lh0ZRwbHYE6H//Uf4fYy8Xj+45D7P5vPyTKsfJe/Zl/8X9AbM1YDmJx1LYi2G+xh2vLY0/Iderh75+GOlu3b4HYhk245hlXtsF1cf55yn7JN3KdGi7i50YHcZ0POzjWGy15/WbT7hdj5uYWIOb6eP1DzxwW5YOHDkGdXDYLseHhkijvvGQH1Fm7Fu3mww7uV8rLco5nle/bsXUSYjb8hZkQQgghhJAucMNMCCGEEEJIF7hhJoQQQgghpAs95zBr+VR2/nCkpAA7psfcZCsnp9eMZrsNveY0uwYb61if1XLBKquYx3n4sMzRaTYxly7w8FqukkPop+QjyaYwXyqTxdxV7b7DWOY0aTnTxsFY28rZ9DCNyzQaeI9xjHlOdhJ7Tslz7ieOMmgDx75h7ABfzdfH/E9j5ZXl0kouoTILfevykZZyr+RBprJ4/erqvPycMpfbnpInZ5VdJW/O9Ur4fSuYz1pblbGgiDlknsFc4VxWyce0Ql6AY9H1lbxjKxfXUXL3ogT7RsuHDq31I1Kfff/QcmntNUJZ3oyj5O5q8z9lDdpKDT/XVManY61nOWUcnHviDMYunIVYYXSDbFOAz6kT48RpWTqRtqLHcO0JaIzxfLy+69nvLWWdV9YK7d1iTy/Nbr5WxbnVyztQfSsq89nTHvZFxP/44nchduSozGsOlNzsG195HmLDo5hTnNjjRVkPjINrZSEvx0agrOntJj7PKMQ8asez1hL1eeL4ia33/UoZc3lPHcX84fPnz0GsMChz19et2wB1HGX96LTwHht1a88U4VrpGJxbraYc69UKag2a9QGIedp8s3aUKWUu9wJ/YSaEEEIIIaQL3DATQgghhBDSBW6YCSGEEEII6ULPOcy90Gu+snbm8gs9h7mX60BekjHGURJwXCuf19FymCuYwzw7K89g1HLI0kouclPJUfOt5KdcDnOcQuWs1I5yNnOzKc/OjpRzpmMlj9o+TzmbwzzDTAbPJA3bmMOcTct6nnKmaz9pN/GMVN+z8q4xZdwkiZIjq+TFBxk5hhwtl125lmud9z2YL+D3KblaUQfvx0tkjq+n5K07ytiwp1JayT+PIoytKufOpjwrlzuDn8tkcPwUCjj20r5sfzqDYypM8KFV6rLvz16AKibwSxCLlDWlYeXX2Wcc9xvtLFp7edbWpFgZi50Qn4s9XLQznUNFH5Cxcp+jSMmzPINn2MbK+AytM3Pbyj2XVzG/3YSWtqOF95dWcsC1XFL7jNw4xrHSxi41YYT17Oeh5Uyrc95a+x3ttd6jXUFgrc9arnU/WV7C8bJ2apuss4xntz/2/f0Q27VtI8QK1lnbdt8aY1TdTy4n17N0CsePdi0f9DLGpDy5dnnKOczLypn43/72t0W5uoLnJHeaZYi1muixMTm1TpSPHDkJdarKmfUtJU+7bnkvNJU6JsHzvlOBjLU1bZgtaDHGRB3s50zKej4vUEt1cc0GQgghhBBCLjK4YSaEEEIIIaQL3DATQgghhBDSBW6YCSGEEEII6ULvCixNk2fFEkVZoIr5lFDSg+avhyaYRBUvKWKNXgSKSpW5BRQUrKwsiXLgKYIO5VD9wNVEeLLcaWGie1sR12liuoIlFOsohhVhiALCIJAJ8YkiZEkpB9xHASbS22YXjUYN6vQVF/vXt4R5vmLmoB1ob5sYGKOIwRxFLJjCNniW1i1QRAqdFj67VUWUWsjL+8ln8VqeUe7HEoDFMbYzl0Oxxvp14xArL8/INhTwb/V0BvsmncK5O1CQophSaRDqVOo4PuuW2CRJsI5jUCwYRTjfYkvQlmjOMn1EE/3Zer7IV8TJ2jirKQYadSkU6rRRjBUpYutsXoqY52fnoM65C7jGZtPKbzvtsii6SttTviKattbBfAHruMp80MwiWqGMxcqY6rh5iG3YvBVi8+el2LHZQqMGTdwNokzlZer5miENvpN85T11MeEq7znXl33eUQyJnnwSDTsu24XP4BU3XCbK2vZFWyuzlsjPFs4bY0xHEcF2lPfv8rwU09lrjTHGLFeXINZqy/XZTeFaFnfQ6GN2qQyxR/Z+S5SrFayTzSpGPsp7MbBMgDTh6vq16yF24w3y3VIs4jzyNIMmZR+assxsXqiWlb8wE0IIIYQQ0gVumAkhhBBCCOkCN8yEEEIIIYR0gRtmQgghhBBCuvBDiP4U4VMv5nyKo562TU8gu14RUPXgXqU1U0MTcNgfdZSLLa9isn29JpP0cym8dlZzSVNcahpNKZ6pNVBolc1gMn8mi45osdU5oSLCSZQk/TY45SjtbKDIp9lAQUrLEi3mCheX058baK53tjoK+8gLsE+cQBGkuPK5OGnsoyiForKWJ4VWURuFV5Ei/uwoc7JhPfdAEQWlFRGnZ81JV5t/CfaDMqRMLiuFVQPFItRxDY6pluLutGrktapN/ML5RXShujAvHQjbEYpWIg+vpbnRWToj0wmVm+4jnVBzopTPM1Lc5rTlWosllvBJq2OPH2OM8S03uyNHTkGdVcsZzBjd0csxUkDstHCOeJojqbW+VZR5VBosQSytCFwdX67rLUWIOziCLp233HobxJ589GFR/vrRZ6BOU7l+qyPb72jucYki0FKUT3ZMc63tJ+UKutflYilkcxSXvboiSv3Gd74PseHRIVHeuW0SG6E4X+YsB8tCHsfdUgUdUO//NjoQfusb0rGvUsFxbbtc/lNM3qPj4rPbuHEdxDJpbOvcguznC+fPQZ2UIhD1lDGVsoSamkvw7GwZYqMjw6J8w7VXQR1NbOy6Srus93WiHATRC/yFmRBCCCGEkC5ww0wIIYQQQkgXuGEmhBBCCCGkC9wwE0IIIYQQ0oWXQYGlCYWUaj0kYSeqENDa8ytOS9r3xYrbTGS1wbNd2owxoSKUiSNbVKW4RKkueygqTFsJ+EOWCMEYY1wf26D1Xr0m3bgUUyHjeOhyFccykX55Fd3jqnUUItQVRzDb/G58bI3S0v6RUvqykJLPwFfGSksRgrkpFBvYTnitBEVstbbizjcsP7d5wy6os7qELmnz8/iQ41C2tRMrrn7KCHLt1UGZo47iVqlda3hQCnPGRhQBldI3YYhjqhnKeTm7UIc6F+YUcW7HEqoppmaRh/3nKs/fs9aZVhvb0E8CRZDTi4BL+5xp4r3Z7qm+IsrzPHy9tC2B2pETJ6GOq4iQUorQ2XZg1OZpklFUsJFsa6uBz3xkdApiExMomKpZotQwRLFpq4XupvMzKKK6ZPsOUf7m11DIXS8vQiyyBJ6erwiLbQtZY4yvCH3t568JA/vJHbfvgdjsghTTHTp8AuqEHRTdz5dxXD/+5BFRXj85BnVKBRxTgSfnQy6LdeodnA9z8/geOXL8oCgvLaII1iTK1s2a37kczve1U+iWd5kiptu27bWi/IX/+RVs5yHsZ9/Dedqoy7HX7mAdD45cMGZm5rwox7G2NuM9hoooM2UdiqCt6b1wcc0GQgghhBBCLjK4YSaEEEIIIaQL3DATQgghhBDShZ5zmLX8txfzUPPEMldQvBV04wQrr1lLuXISzc0E81yMldvpGsy1yacwrywTyJw7p6Pli2k5otj9g6VBUQ6UfL6mclh3vYG5nrWGzNFKlLyn+ir2w8yszJMLQ/y+bAHbNa4c0D81NirKo8PYf/0kpYwzxzJl0MZiKoe5npkBvH87775Rw/zC4gjmS5ZGN4lyxyjXDpTcNh/b1WrKep02tiFWzHbsHPtAyfvykzLEChnMk4si2YbKCo67qQnMa05iHGdJVX52aADzE40ZhMhyRc6HqmICUVXyTduKIU/YsvJnnYvLuCSbxX7rRPJ5Kr4iJlGMaCLFDSeJZT3NLCMIFA2IJaRYv3Eb1Nm+83KIaW09efKoKJ8/dxbqpDzNOEteLIlwXZzasAFiA4OoJ6lekHmWjjZHlNg/fO2reK1Vmf9cb+D81t65kaWhiRWDqkjR1QSKmZZvmS95tgilz4wO4Dv59An53OM2zuvAx/eOb7sPGWOOHJ8V5YOHT0Odm66bxmsFcm6l0njtlQq+R0+cRq1FmMjnkspg2x3lpeRZa9DgILYhk8bPNWrzEBsoSm3TxvWjUGd+ZhZi6TQaUi0uLotys4W541lln5PLW/oqbY11FT1OD4Y8LxT+wkwIIYQQQkgXuGEmhBBCCCGkC9wwE0IIIYQQ0gVumAkhhBBCCOnCD2FcgsniLzSR2nE0ZZ5sinawtGNQfGMsswPbdMMYY0LFVKC+gMn8hw8cEuWnnsY6T+07CrGUJd4bXYMiLj/Atg8ODUAstgwRFhbR1CIKlUPR6yg0rFlincVlPFS/uoxiwbgj2zpYwGGyVREBbBhHU5KcZebhKsYQ/SRQDBeMJRINQxQWOAH2yWpDeVZGjk9XEWNt2LwJYsPDW0Q562N/txUR0srqDMQaDXmwv206YYwxsXJwfNs6AN5P4z0HAZqNjIyg6M/3pJAlq+j0shns53od527a+s5YMQWKs4p5Q0vWa1Zx7A+mFAHYpvUQcywBysIiGkr0E21ch5ZgLOwoJjeRJu7G63uWq43f47wuDQ2L8mAR18BiHoVdvsFn3F4ti/L86TNQJ1SecSZnmRikFbMWzaxIET/bPzmFylgMUjjny+UyxJ568jFRnlDW03QKJ07bMpaJI5zLiWImlM5iPw8NyzWl3cL+6ycdRQjZttbdjDKHQ2Vcd5ooPF5qy7Vlr7UnMMaYLdvQzCRjCZ0dRdBfaygC+7kyxFaX5P1kFaFeroDPLm29kxyD47W2jOtp3MC1opnItnoJzpF8FgV+45O4VuYLco67ihB34+RaiI0MybFYq6xCnVYB149UgAJ5z9qravOhF/gLMyGEEEIIIV3ghpkQQgghhJAucMNMCCGEEEJIF7hhJoQQQgghpAs9i/4cxQGqVrFETooTSypQ3IQ8JSnf0ui0FcetJMKEdRPLNizOo1DvzIkjENv3/acgtv8pmeB/8NhJqDOqJLXf9e5fFuV1G1HEVa2hIOzoscMQO3jgGVFO5zCpvdrA5Pf5Zbz+zNyCKGueTUNFFA+MlmTS/OYNKD7ZuA6FD0mEQqtzZ6ULU1FxauonkSJAdWJbNKO4n7UUEVIbY5EnxRIjpWGos7KITkuLC/8oypMTu6DOmpF1EMsXUBxYLUtHpnwKn9OoIuwcGZKiDtv9yRhjSjkU+I3kMTYxLJ33mlWc39UGCsdCxVkz8aVgw0spTpSKcCyJ5X2HbRThbN2+GWKX7EA3ukZdXuvwsfNQp5+kFJe9tiVeDTK4NieR9gwUwbe1hnttFLYZRVzqu7JdflYR3CmCnJbyrDxPXqtQQLFPp4NjPbFEvemsIlJVXOB8RazkW/c4cwHHwVAJxbkbN2+B2MhISZRrFRRpnzp5AmK2DWIE65cxrqu5vuEcyVpCQFd5hv1kcsM4xLLHZZ9Uz6PjY+Dj2uW7OPZcy7Hy4DMoJP3L2rcgls/K9/TCoiJWVgRq6yYwdnJIjrOx0RLUqSjOvs2mXAeLyvMdyeL7Iakqe7uqFD9GTVwX8jl8Z0xOoMPqTTddKcrTG6ahTrOC4vG5CydFefbCOWyD8n6YmEIxomvNkfgFulTzF2ZCCCGEEEK6wA0zIYQQQgghXeCGmRBCCCGEkC70nMP85CN/D7GVVZl72WxiXmKg5DAHPsbqdZmX22xgTsvQAOZ/mkju+Z94FHOTn9y7D2IrK5jzu3PndlH+2VfdDHXGJychZhujzJ7FHKqp6a0Q27oN86ouXJDteuyxx6HO0aPHIdZuY47RhJUTN1jAPMOhAWzD2okRUR4bxpyg0WHMVSqv4KHy2aLMK6xUsU4/cWPMO/atvyPjCHM4O23MjfQ0AwTfyidUTAXyPuaxrVbl8zx74hmoszhzCmJhA41L1o3Kdm0ex3k0UcJ8t/Gxkgw4ygH6acwhc5Rc9tWyNPYIlfGay5cglh1Uru/InNBmA9edjpJPnnZl32/ZiDmv40oOnonRlKRhGWJkU/hc+0lKycHNWjnLgWK+o3lz+AGuEYmVA1itac8An3FkGXsMDOAzsPOCjTFmpozPYGVVrpW1GuZ1dmxxjDEmsYbxgKfku0PEGE8RgZw9Lefg6dM4J4eHRyA2MYn6A7NG5pcuzGLO5vmzqNGxc7ITJYc5UIw01Odv5bmnlTzYfvKX/+3TEDt7Vmp1kgTfc1oOcyGHY69YkPO/pZibHN6Ha3G9Jsf6SgXH4tU3XQWx0Qls65bL5D5kcADfD0vLqHvpWCZPOzaiHmP35h0QqywvQcx+/9j7LGOMKc/h504Y1GUtnrfy+q/Gvd16Rfdlm7PMLuC7bXQMtVTr0tjW2JX38wJTmPkLMyGEEEIIId3ghpkQQgghhJAucMNMCCGEEEJIF7hhJoQQQgghpAs9i/72PngfxGIjBRVBWhPzaQfHoyBlzRopjCgN4GHvywuYZP7E3oOi/MgjKPpLKYdbb999CcQ2bNkoA8ph70efQRMUY2ksxsfwcPWohWqadUoC/mte/RpRrq6ieGB1CQWLKUWRMjwkxV6uh20YG0Hhw0BRDotmGw/Qb7bx+/wAY2vXSpFkRRFb9pOcYvDgW9Oi46CIJvFR4Bcq9x+58vnVaziGsx4eJm/aloFAgkKJKJyDWCmH4+WK7WtFeUoRcVYWZiGWC+S8GRmbwGa2sF3zsyjOqFjaGdfFtWK1vAyxQh5FN2tKcq1IRSicqUc4zorjUtAzNIT9oAmXF1fRhCBvmWQ4irlHPwkyuLS7Gfn7SCaliKMcFEd1QnwGNcs4oROiwE/T1aQy8jvbHRw/LUUYW2/ie8RxZVsn16EZiKbUa1smKItLOCeXllBkWFPm/IkT0tgCW2nMwAiKbEfGUTzeXJHitbYiiAxSiqApln3vONjOlPI531fWK6vvM5mLS/T3xFN7IdasSqFiysN+y2ZROLfilSE2MSHH4+WX4pjavAHXQc/q87K94BljWh6+ax7ci/uJC3NyHSyXcU0qKKYhl+6Ue5odG6ehTj7A53n2dBli52bluK42sI4f4GjPpDGWS8nx2axegDqri9g3SSyfRaOKK0pK09n72u/ATtdir/AXZkIIIYQQQrrADTMhhBBCCCFd4IaZEEIIIYSQLnDDTAghhBBCSBd6Fv2dURLDV+vSta3VwaTsw8cwwdvz8hDbvkW60pw6/k38vhUUYmzfsV6Ud+5cC3VGRtG9a3wNOi1ls7JdlTK60i3OYxvSlnjCiVAkVKng5zQxzZZd0g3ol951F9SZGMH7efqJ72O7AltphYn1mvtfLisz6esNFAuuVFchFrgorpw5L4Usxrm4/kbLl3AsJparUdxBEZKj/K2ZyuH9m44UbESK+9nC/DGIjZamRHnL9Haos33rNoiNDeOUjluWmEgZi46DophOIkVV1ZYiOGoozzNBMV29JcUgNcWdL1AEWjlFc9RsScGZ4yrOZmkc68WibFcUoWKksorPp6bETCCFRqH3Aq2jXiJcV3Fxs8V0ijjMT+Hnmh1F9FeXz8B2mzPGGF8ROfmeHC+tJopUNReujOLKtmmbFE3HShvyRZyTqyty7fr+ww9DnXYbxYiNKq6DpZIU741OTkMdTeB6+hTO+bgl50R1FUWwdcV5LratCxVHzrQiyPdcTUAo+zCfx37vJ5kstieXkvfmxvhOGy6tgVhWGVOFgpwTaxVX1F07piDmxHLQ1ts47vYdXYCYCfFwg0JaisBrK+jqt3kC72fUckI+eewk1Mln8X333YcfgdhJy1FyaATbuWHzToiNj2G9fFquKRXFBbFeQ4dA13LnKxTwZdCo4D7Et+eDMcaxtrraWtELF9fuhRBCCCGEkIsMbpgJIYQQQgjpAjfMhBBCCCGEdIEbZkIIIYQQQrrQs+jv0f2YlN3sSOGL8THRfa6M4okNG1CYV+/IBO+MkuA9NLIBYjlLaLVmuAR1Clls19GDhyCWCqQIoJBHIVSzjsKPKC0T/gtDKDpYVYRWhw7sxXp12V/TW9EN8MZXXAWxnIciqvnZk7JdRexTVxHhVapS7DhQRJFhSnEJq1fxWXuW8OfMORSB9hXUwhjPs8ZUCZ0bF6oo7AwV+6C4LGPZLIoNtm/BcX315deI8tTIVqhTyqP4pDiCTm21uhx7M6fRXaqJw9o023JcBy1UY3UUJ89yBUVy6bx0x8qVcPxUyucgVm8pLntZS/iUYBs0B8J0Rs7vfB4FPYqhnJmdR/HVmklbMKQIA/tINoPjoLIs53Wlhm6IhTxOiGYDn0HLWq/Djub6hdfyLUFarR1BnVhR/YUxxmJLtNbu4DOIlbY3O3KwT61ThOJDODZ8xSWtUBp+3jrtNrahXsEx1W7I5zEzi2KvTqi481nOubHiYpbN43hwFdFfx+rD0VHFhbSPXLrraojFHXn/A8q8vvaa6yC2sIAivIU56XBnXByfc4voZBp4cqyvVnBuNZsY274V3y3T07L9p07g3mt8BPcmhUEZO3AQ1/lz5/ZBbGYV9w4DE/J9k86WoM5qSxFNn8HB59pOuYkiNnawnwctAWZGEV8/8gTu43ZffhNeyxI7Rtok6QH+wkwIIYQQQkgXuGEmhBBCCCGkC9wwE0IIIYQQ0oWec5ibmGJiElfmRQUe5qZs24A5UBvXYm7b2omSKKd3jEGdxSXM6Voqr4hyK8HD8k8cPgOx08eOQ2zDlMxlW03hodjnL2D+UnFY5g4NjimHpGfxQG/HYH8lbZlftzx7FuoMltAYYnJ6PcRKa2RfaAegNyuY65lLyc8lIeYOJb7yt5aD9XJ5eY+OMkb6SRJj8m7Hl/lO2UHMict28P7nLsxCbNCTOY3XXX4F1Lnpphsgtm5cjsVGFSdgRzFBaUUYKwxJc4XxGOdIp7MCMadjGZ4oxkErNZwjXg4Px8/m5XxWvHDM8dN7IbZxHeZe7p6Q+dCr85gX77RxnNVX5YH52Rw+w5Zi+tB2MD83sMZ1tYJ5qv3E95XkfDs3WMkVdowyNkIlsdv6aDaLOel5JRZb5impAF9BHSUfOuVjPVu/0lrBtcxx8XmWRuV81nJZB0uo27jpxhshdujIUVH+3oNoIHXkMOZZri4ra8WAzIuvKUYpAyVcizyrb5r1MtQpFnBOep5iXGIZOiwvY651P7nh6mshdvCANIGJIhzXlSrm6bbaOM4a1rp+5GQZ6iSKwVIqJef/yTP4rq21FQ1RBnOR58tynT11Dq9VVd7b+/bJfvjHf3wQ6hQUPdLaDWiAFcZybtVr2FfpFLZdW3da1v4hMajj8RSjpXZD3mOmg++achPX+bayrY2sdT1R1vle4C/MhBBCCCGEdIEbZkIIIYQQQrrADTMhhBBCCCFd4IaZEEIIIYSQLvQs+kuURPrllSVRdpVEancEBWoDRfvQf2PyWRk7fuwY1FmplCHWDqWJweICHg6+uIjJ4lPjKCosWUIeTexWTKMoJuPKzzUrmCCfoObCrF8/CbFsRgoDmlVse30VRQCucvB3Liv/HsoOlqDOUhMFL3bafl1RaF04g6KVVoTPP52RIgNXSe7vJ16CfzM2LCHbhVNHoY7roLhh95YtEHvF5TeL8khpBOqkAhwcjnVQfDqriKNqbYhFyv0kLdnWpfkq1JmdnYOYiaTA1RZhGGNMSjEFSpS/wxdWpfD2xEkcdweewoP2O000ldgwJoVPrjJPcwVcYxIjRWinz6FRylP78Vn7aZxb52ZPifKRY+ehztsh8vKhmX/YRgCNBt5XWhPzKtfyfbkODg3gGE4UQ5mGtV4HAX6f5+BYDzQxkSUgrFTLWKepiDEtI4X5BVzLdm1Do6C1ltjUGGOefPwxUf72178KdaII+2FYMdiy73vDRvy+mTlc++sNOZ9zWRTK2gJJY4xx8VUGba3XLy4xay6DjQ58+TwXF1GcfPAgjnVHET1GHbnGDQ+iqKyYRjGrb7VhWFl/WvP4feVZfGcuLDStMr5/F2bwuZw/Iw1OlpewH4bHcD3NZvFghvlFKZJsd7CdA4N4j5ootdWSc74T4rPI5vFalbIUczdaDaizYdMuiGXyJYjFlqnYC9T88RdmQgghhBBCusENMyGEEEIIIV3ghpkQQgghhJAucMNMCCGEEEJIF3pWYMWK21NkCTgyRRT4VWqYsP7tBx6H2FrLHc910A2mUlVchxKZQB746KYzOYJCq1IexQNeIu+nUETxxPjIBogtrcp7jFuKCGlEEQoEmHkepOTfMGVFsJhWPqe555y2nOemFZFh4KOoIWrLfnBsWy9jTLuJ93jyHIoMBoblZ2NFlNZPXOVvxow1K4qolzG+4oi2bgjdHAcs8V5OcXwcHsZYrSaFH0EGG6G5d3UUd7Azxy3B3bGTUOf0GRSt1euyXjpA4VUqg3N+YQXdMM9ckGLc+QV03koUh7f5BRS3VOpy7A3lcW6VK3j9MJJ9s+/gaeVz2H9X7rwEYktLcm6tKkLffhJqQsi85WCZw35rNlFY4ypTNpOS4zGbw7XSxNiGdkv2byaNY8pJ4frmK2MvbthtxTUw7KAwtm0J2aqLS1CnpLzLxsZQ0LS8JMWyc7PoOjmkrAstRUDbSsu+WVxEYaz2Xkz5co0dX4MiLttF0BhjkkSx77WIouev83Lyxb//O4glkRygnTa2ud1GJ1NXGS9TkyVRvnTnTqgzvW4Kr+XKa6XTOIZrTRwbZ86fgti8NYZKAyWoo4nVZ84+I9sU4PwrL6G4e7CI7+18Wo6XRHGQrVRQLNto4X4lscSsjoPvznYNxazDRbk3ufGVr4I6N994HcRSihOjYz1riv4IIYQQQgh5CeCGmRBCCCGEkC5ww0wIIYQQQkgXes5hDpS8k0xG5pVpuVorZcxpuXAB82i8RCaVrFEMT4aHByGWCWS7YuVQ7Lij5PIso8FJwTIuGR7FNgwNYd5obJmZeCnMo968cQ3E2i3Mz4zbMtdmZAT79MhhNHi4cAHzRjPpnFXnANRJ+ZjjNzgg8xNXVjEftNrA/C+jmHksLpZlG2bLUKefOAkmM1nD2rgR5huaDt5/EGGsZJnFFEslqFNWDtr3LCOayMPxOjeDOY5nz2IucrEocxoDH+dyOo05qJ2OHP9KirE5fRTbfmYGc0IboeybjHJQfazkZ84v4T3ue/qgKF97xSaok8ng9WfPyTy5mXm89sAYahTaIfbX6TPyHuNYyeHtI7UqzmvPyu1LZ/H3Ekf5CSUIUOcQx/JZhYrGJVBMUFJWznKiJBMGHn5fp41ruLG0FY5yrYE8PpfzJ2Xuetrg56bGcb2uKMZZu3buEOUbb7gW6hw5jCZc1QqaB9nLR6RoR5oNXIvHSvIet21aD3V8Ja+zoxhNxbG17iimK/2k3VLMkyxTG9fgHqBVw31ILovv6dDI9/tXHzgOdVYWn4DYxFhJlLNZ7NuZBdz3zC5gu6LI2tNADWOGSrg3yQ8MiPJyGTUKjXoZYieO74VYNif3HYX8ANRJEmxZXXlXTk6Ni3JpAPc0YRPH9W03v1KUf+LWm6DO6BBqexxFO+HZ+1ecWj3BX5gJIYQQQgjpAjfMhBBCCCGEdIEbZkIIIYQQQrrADTMhhBBCCCFd6Fn0V62iSGGoJBPBx4YwMby6ip+LPfzapZoUwA2PoLiumMcE77xl9LGyXIY6oSLGCnxMiLf/fmiHykH4DgoKNk7LpHYvwHZ6BpPa8xkUt8zMStFWcRAPoc9msZ9Pn90HscUFKUyaWIOfu/xyFDmtnZYHs68eROFDpYLJ/W30fDDlujQXKCuf6yeDijlN4sobcR0UEbiOYkSjiOlsUeHsGTzsvbKKIrmwLfvt+JHDUGd+Hg97j3x8xiPj8lqZFJpTFLLYD2vHtovyoQNPQ50LF/Aw/tDFvgkscW7UxjZEitlGW3HN2H9EClxnF3FujY+PQWy1Is0L2orYa3RNCWIXzqNY59QpKRjMprHf+0ldET+PFeQz9lwUdLXbisRIMa+wxdUVZZ3P51FUlVjim7YiKksSHAcdZXEJI6ncSRQB7+oKGla0GrKt27Zuhjob1m+E2KkTZyBmi9p/8vbXQ53pzSj6Wy2jCdf5sydF+fhJ/L6WInob375WlHO285IxxsT4XF3FvMFJrD5VPtdP0mnFgMUaB03FOCwdKGMxwfd0J5J9d+LMSahz9gyajXSSLaKsGQd5Hr4fhkYmILZsmVatVFDAqz2XfEGu15OTuCZ12mWMRcrcAkEfDpaUp4yNDl5/KC33cmMFfBaecpjCJdvl3qRQxEMFlC5Vhct26xOK/gghhBBCCHnx4YaZEEIIIYSQLnDDTAghhBBCSBe4YSaEEEIIIaQLPYv+MjlMyh6ynGUqSyheMjEKRoIMioJWmzKxvd7GrOyojQIRPyWFc7YQ0RhjVutKUruiPYst8UCrhUntDeVaqZR0YUsFWGdhHsUnxdI4xM7Nyj6sH0dR1dZtOyC2ZfNWiGXT0tEq7KBb3DOHjkKsFcpnoegXTFpxM2yV8R6XLFGMoylN+ojnomrAsxzKghT+XakJ1GYW0YHxu9/5G1EO2/h9ro/iz5YlOM0X0eVyIIXCtkoT61VDOc1PnUfRSspFx74rdkkx0WVX7oY6Xhbn8onT6Da4vCKFVu1QcR7zsJ/jBGONjuzD2UWcb4ur5yAWRlJoOLYGHaeMg2vMguLQ5XjW+uSiMKefhAYFMoUB6Q4WuNhvq6t4H4GmrInl/Qe+9irBZ+xYsXRKEYgq48BRRDqO9c5wFSVPaXAYYpvWSUFfq4X3/MQ+dEXNpvEeW9Y7qayIH3N5TcCuuLBV5drvKk5qxRyuu6Mj8p3nKkJZxQSxp1/LNDe3fuL42Jf2OyVI49gP0ijwGxxGQf1QaUSUJ0dw7psWrrFhS75bO7HW4ejOZ4sMjTGmUJRtnZhAYX6rjvuqxFq6Msp4zeYmIZZSRKJhLGOJIgZOKevHaGkdxCpLci2eUd4/197waohNTMq2usq7WsPVVH8WtlNpr/AXZkIIIYQQQrrADTMhhBBCCCFd4IaZEEIIIYSQLnDDTAghhBBCSBd6Fv0NDmpiOimiWV5G0Vfi4lekA4w16x2rrLhLKXnadmp9Ko1/A6QiFIPMzmJbU54UX01vwgT5rCIomJ8ry3Y6KOI6dHwBYl5qBmIlS7RYraBQLz6G4rJEEVdec/1lojxzAQUM3/3uYxDb9/RTolwoKs48KUV0ABFjhkpSpKG5MPWTlOLKGKSt56cIwaqVMsQqlVWIrRg5zjxF+NFQuqTakiO7o4i4UrkSxAYHsd7yvBR/zs+dhDqtBorkzsxKd8HtW1B8Ml5A8dLOaRTTzC3Jfp5dqkOdpSqKr8JYcU+0yhlFROy4OD5tgdZAEde0SHG1W1rBuZtYLnmhc3GJ/pZX0EmxWpNOf0NFXCt9ReDnK6LUyBKleorLpSY+y6XkOAiUd4Fm1eUoMW+1LMoToyWoc92110Fs39MHRfn87AmoM7V+GmKplCaOkuVIcZV1tJUxwkm/aq0f7Q6KqsbH1kAM3EoV0aRqf5Yoa7glnKzXcZ72k1A5DCC2+lxz8S0NoPjT97Ce7Y6by+H74corL4VY2hobscH5cPgoiqH3PrEXYp4vV7ihUgnqaMK2OJFzvtEsY51YGcMR3mMYyuunPKxz7DQ6AJ/18TSFoQHZz56DfVMq4fMpWGLZVArXIc2xL1HmW6cj1+tWE+dWqYSCUhv+wkwIIYQQQkgXuGEmhBBCCCGkC9wwE0IIIYQQ0oWec5i1XNqalY8aKnk7vpLHls9gLkrYkXknicFcMC2/0HVlfox2gL6j5MzUWpiXGli5YL5yrXYTcxUHBmTO5sHjmA966MQZiMVKfubundtFWeurVr0GMdfB/nr88SdEOVccgTq5ATS/2HdonygHWWznmkk8vF3LIXRaMleooOSE9ZNqFfsyG8kx5Ss5ce2mksu+gOYfsSPniOPhPHL8HMRc64D+fAHzbR0Xn/n583shVq/LHNwowvx9z8OcykpVXv/pgyehztwgPs+BAsba1vyutTDXLYxwTjou9rPryHkZhrguRLFiMBTIa+Xy2O/NJraro2ggbJ2CplvoJ4ovDOTbei62uaOlYiuuF56Ve5zNos5Bi0WWKZKrXLvZwbHYaOHzNJapRkqZD5vXT0Fs5rzMJU02YW7+q2++EWJPPrkXYh3rnRSGOIZTSp52XTHAqlSl6YmWdjw1gfqAXFaOa01LosU0I4jYSgrVcj37ScrD9SC0cpjjGO/WVX4b9JSxN7ewLMrLVVzTNZ1UYOUdJwle+8jhkxArL6A+wm7qnGL04Xs4zmq1sig3lb3Khg2XQCyjGOs4gezTjGJuslGZN7b5jjHGVCqyT/M5fIYDQyWIpTKynqvoKzptXK9bTVwHPE8+D01f0Qv8hZkQQgghhJAucMNMCCGEEEJIF7hhJoQQQgghpAvcMBNCCCGEENKFnkV/uawi5ElkEnaomFJ4Hn5FysOEeNcSR3U6eGB6GKL4qmZptsIY21mtoiio2VFkEJYIYm4WjT4yAbZ9cE1Bfp9iujKqCOI0AdzaiSFR3rJhI9RZmJmF2PIiJtufWpCdc+Is1hlWDsLfftm09Tk8cH25jon17qIioLOEOIGHfdNPyitoNtJuS4FdOq2YmwQoenRcvP/Fyrwou7YpijEmnVJEfx1Zr64Yi8ShIkYLUQRhjBSIaPPPz6CgotVyrTIKTWbKigFJE+vZ5gLtDtZxfW1dwHq+YwtsUJjU6WA/DA7KedpuoShmaRlFPkmCa5hnmR7EycX124NmnGCbUmRSWCfIoCDHj7CfvEg+g1xeEf0phjJJLMd1o43PrtVA05WW8qzyOTlPhybRaGq1UoVY1hLhrVuDQjpbJGSMMU1FqBpbBiSJYgaSzmKflufxvqursq0DtiGJMWZyEg0eQDjpKO82zehCMVnBz2lywf6xZnQCYtmMnNea0Y6nmLnkCzhmB4bkmDpzDt99F2bRcKxlyyqV5SCbQ9OqoVHcM7mWODml3Y8ikD5+7IBsUxOvnclj/42vuwZidWu+FVJ4Q9dcuh1ic+dOQuxr931JlPPFEtSZnEJxbiot1w9Fo6kal1SUOT84IPs+pQj5e+HiWuUJIYQQQgi5yOCGmRBCCCGEkC5ww0wIIYQQQkgXuGEmhBBCCCGkCz2L/poNTCDPp2TitKdaDCmuO4oLjuvKptQVh6HyqiIqS8mE+GaCQobjitit1UZxht3S5TKKT0ZHShB76BHpjNeKsVt3bd8MsbCF97M8LwV9q8NDUKfSQPHJwiomuvtpKWoYSKPIYaU8D7GBvBQd7L5kG9Q5fOIsxE5fQDHE+LAUZEyO4P30k8jgWGxYgodWiGM/V8BnXBpFcU/iS8GgH6DYIFDcq5pWGzptFD05iltRgjouFK1pLnC2DZwxpm255XmKSCxbKEAsifFaYdsSfwZ4z4EiLEkS7HsTyXnpKH/3ZzKKG1cg27+6gnOmuorrjqMI6CLL0S2dQresfqK5lDqWasZTxs+Q5rilCFXjWN5/oAiTNJGOHQxSOA5ssY8xxng1XIsDX7ZfczY7fPQoxA7sl+v12qm1UKdWxbFRV1xBbWdI7X7aytxdXESHt47lgjg5gS6sg4OK46clzEtUAaoiEFbmqS0MfaGOaC8VbUUkav/uFyvOnJpzsHFKGLM+6itiwcECijEjS+wZKc67hQF0xitV8H0Y+nJu5dL4fUsz+N7uWM7BcaJ8rox9kzmF+wl72T2viM7PHTsEsUF8HZjQEmCPDJagzsgIill9X96PNhI1p1ANW/TpKs+1Fy6u2UAIIYQQQshFBjfMhBBCCCGEdIEbZkIIIYQQQrrADTMhhBBCCCFd6Fn0t7yyArGCJfhJK2KNTgdFO6HiMORaYqh6FRPRV5so1NsyNC7K5+fQqevcYhliw4OYbD+3sCzbOYAZ7LGPooNlSzwUKqLG+RkUDvkG7ydlucodPXIY6hQGsO11RQzhWi572zeshzqVCt7jiZNnRFnRZ5nJERSfnKyha14qJe+nOIAOef1EG7OeK2/YFjgZY0xDcSNzXKw3WJQOQxnFNdAWvBpjTLks55sT4TzShHNGEfy0LYGapsZqKc57niuFXJqDlvo3tzL+U5YYylOEjsbB+RApa4UXWAIO9e9+bENiuZ1p9xwowthWWxEexlI8Mz65TmlD/3CU+7efgSboskXUxhiTU5zqQmtdhzFmjCmvViBmC83aLZxHUaStizhP0yDcUYTcytCILGGb9o566B+/B7F77r0XL+bIdX1EcU5dWUSBVkURFebzUqQ1WEJnOM2xLrZc3xxHcXnUNG/KOmD3vfYs+km7g+85W7tYq6H7qO8r/RajGLNSle+wpSU8MMDE2CeeJ/u8rfT3ch3HWZLC9SZdlHMwjrHtnofz1Lfmbn5QcVlWxNCuj/2Vt5w70zlcAxYX0QVxXnFKbXbkWO8k+H0ZzRXUKq8oe1DlsZpsBvvUHuu9igVt+AszIYQQQgghXeCGmRBCCCGEkC5ww0wIIYQQQkgXes5hjpWUj2ZH5gBlC3h4v6MkT3UU442WbVTi4F7eNoEwxphyXeZvnZvFHBrXxZwuNYPFytmMXMzbOXX2AsTsvLyBHObQ5FPY1YW80l9g4IK5gbFipLF+7STElq18ouryHNQZVQ4ML+7aKsrHTuM9ryqGEoNZzEMatQ4p77SUfNCLDDvfScv1aylmBEqapRkoWofHK+Y+milJzspHS3nKVFVyhTtKzqFjxeIe/062c5hdRzFlaOH3KSl+0FbH4D0nBseGH2CH+ZaRhma6ongymKgpr6+dXW/PP2OMiWJcd0qlUVHOZEbwYn3ENqAwxpjlilxjUwGui2GE5hxjw6hzsNO/G8o4qFQxP9lYeoAoUXLnVdMVfKCPPvaYKK8q+aaJoj+Yn5Hr2dhrboM6O3dcDrFt209BzM5xnTmPeZ0z5xWTp5N4rVZD5nru2rEJ6sTKizi2ErV9xbwojhUzD+XdjEvdC8v1fKkoFnEsutY2Rhv7nqfdh7JIWAYkaWWOJIoxir1BciJlbuG2xywuYk52ZL1ufeWl4Sh7gOaqbMP66Y1Q54qrrsU2LKHWYG5WGpU4Lr7c8sXtEFs7hWtlqy5NeqbWYbtyOdQ22e9F7bnmssoeSlkrYBwzh5kQQgghhJAXH26YCSGEEEII6QI3zIQQQgghhHSBG2ZCCCGEEEK60LPoL6ck27eaMot9qbwMdYJAMTtQtuluIhO8C9Yh7sYYk04rh2cvye+MQxQTDRdQhDeQw3bFVjL/ShlFJNpB2aMlmXheymM7sz4mrLeaeIB3GMp6oSLySKcwAd9XhDJLi1L057rYhqEhNEHJ5eT9DJawzmobr9VRTCaKRdnWSLnnfqIdzN9pS7FSqJiGaBq8bBbHWcp6LrFi8OAog8pJ5Occg58LO4pRgyLGtGORchB+YhRjHV+O4yBAQYcmpgEBrzEmbMt6zZYidlGMBNLKQfu2IFgzfmkrz8y11Ijq2hTiuB4b2waxzVuvFuWTp47gtfqIZnCxVJN9Ummh2Mcoz6CtrEGu9dwjxfxDE1CODElxT7mCZgSJo6yVbVRMPfXkXlE+e/Qo1GmsoAg8soSAl+68BOq84c0/DbGJ/U9D7N57pJlJEuE8zSpi6HVrN0AstgweCjl8ByaK0NeOharZiCJUU2K2gN1RnkU/qZSV8WKJHpvK+pNK4fqmrTdNy/REG9ehoxgeWWtJUTGoclyMLVdQiD+3KO8xUOayHyuGP5YQUNu/zM/OQKzRwPHSrsnrd5S+yuLwNEmEfb9+nRRI3/GmO6BOLo/vzrApBcjaIQlpxfDENvIxxhjHMmnSROG9wF+YCSGEEEII6QI3zIQQQgghhHSBG2ZCCCGEEEK6wA0zIYQQQgghXehZ9Oe7uLduWbF6WxFHKS5cnuKykrHEUXklSb/TQMGYY9nn5AJFJBfgbeYyGJtfkEnytujJGGNGh9CRxo9lonvSQYFKW0msdwK8vq3D0FwK6028/umzmMzfsUSMWUWIcH4ehZptS0w2t4ziIC+DGf/DI+h2ZgteyhUU4fSThuYIZzlgFQrYb0NFHD9DRRSR+db4byQ4j2qxJiyRn3MV+y5XEaQYZQ66lihIE8n5HoonAl+KLHwH60QxjkXf14Sqsv1egB1fXkaxRruJfToyKOegqwhqOx0UBxlrLoUJzr9SaS3Etu+4Ea8fynusVKtQp59oRlYta2yEkSaoxFC5jmtXwRJj5tL4nNqKI1psichixRZSE8FmFQFcJivnperoqjiUpbNy/Nz/j49CnUbyXyHWaaMLYj4jv9NRRHkjI/jOyCpiJfudpLy2VJGyLdTzFAGv5laq9b3iKYeN6COzc+iQ6HtSMNZSXCdTilBeEyx3rHdf4uC4dhXXXltQrwns/RSuecpr1BSs9mc8xboxxLUrlZbtChVh4LmZgxALgiLE/Ky8vnI7JkpwjT17Dl2BpzdI18zpjWNQxzH4zFxXPh/tYANtfDqaS7TlEqhM057gL8yEEEIIIYR0gRtmQgghhBBCusANMyGEEEIIIV3oOYfZC5XcSCtnLFYSXRLl0PuUj3lBeSsfLY7woGyjxNLW6dmpLB5urR2+nih/K6Qysg3ZDB6mHSeYh5RYuc4tF++50VAOUw+VA8mtPONKHfM6nzqwD2KasczkxBpRdjy8n7mlVYhFVp5tqJyDX57DA9ezSt55krWetauYRfSRrK/ktln5mPk8Pqd8RsnNT/AZe1bebxDg92njOpOTU9M23TDGmLaSf51E2L9OYuVZOoo+AC9lXOuA/lhZA5otRVeg5BQ71pxIZ3CODI8oB9Mr+XW2QczyMubFhx28ftSR910YwFy6DRuvhVijiX1/8vR+Ua7UUEPQV9Q8PjlgImUN1HJday0caE4i+2RkANefUgE1DQ1Lh9JQTCZyedQMpBS9R2LNiYayni7FwxBzOvJaM0dRx/HQk38Fsd3bcLzs2jZhtRPnXyatvGaV+WzLhCLFCEp5/UBCZqy8c7U0WO1ZGzvXU/3C/lGr4/vKMVJH0VbGa0ozXVJ0Ia2OpR1J4bhzlReiZ63hGRfHdRLgHBkZHoBYLi+fy2CxBHXOncJcYdd6t06sQT3GxBQa5hgl5z209AcDg2heNjkxjm1Q3iSX79oqyjkfn0WkGM7Zucj2O8SY58iwV4Kh9cy0HHNjlHezBX9hJoQQQgghpAvcMBNCCCGEENIFbpgJIYQQQgjpAjfMhBBCCCGEdKF30Z8inIutxPA4VA7rVq+FSfmupUpwFHGYYxQRhJUYHiknUjdqaCoQx5iU71tiRE0UocU860BtR8k6TzzFsELpr8qKPAz87AUU1zU6KAQcyaOgwPVku5bLKG7xFAFmoy4PPK/W8QD0dBrFEOMjeAp73pP93PK0ZPv+sX4MhUlLFSksCRIURXjKyE4ifO5NIwVqriKMHAyUg/YtY48kwmfe8BTxiSJm8GyDCkVwpDgWgAFPqLShqYi2/Iwyd0H0h3VyijmF5+I4q9WlkU6ljuYpxkWxYCY3JcpXXXUb1MkX1kDs6afR2KJSk6KbWmMW29BHPE3Yaa/h2lhRfkLRhM5ta040mijaGSng8wxbUhQUBFgn6uD3RW28ftG6/qAioMqUlPWtJg1IyvP4fgh8/L7GCgqtzp6S9zNQGoU6w6M4hjOaEVEiRUeONimV9zC+bpT3pGKYZJR1DY1RlLWij9Rr+Fx8a+8Qx4qYVTEbCTt4b6FlBpVS3GM6DXwfOpH8nJfCcRco78xagm1YXpLrbLk8D3UWls5DbM1aKaZ74xtfAXW2b96NnxudgJht1hUrwsCOYkqXUe5xZKgkym6iiMIVoZ5v9b2rCJkdxVAvVkSZrZb1LlPqjI6i6NyGvzATQgghhBDSBW6YCSGEEEII6QI3zIQQQgghhHSBG2ZCCCGEEEK60LPoz0lQ8NOuy0R318GEb8dRHI2U68eWckETznlKgrftzNNSXH4aNWx7oCTzpwJ5/WYTxUSRYonWbsq2+j5eO8igKG+1VoHYyqoUnKXTiitiAZPTfc25xhLrZBTnQttNxxhjGp68SU3YVSoNQizlKU45oez7tKd68/SNdhufQWwJR8ME+7sdKc5RiitUJm/3E44pP8Lx4kRSoJm4KLqIFdfAMI0DNOpYY6OpiL0cHBu5omx7LUSxS92gYCpsa6JCORY1MU2kCJoqtRWINSzhWKwsY47B+9m562pRLo2g4PP4yZMQqzXRXSyOpfio3cFx1Fd6ENa42hqrrAfatTqWC53nKc9AWZJcaw1PKXOmvLwAsbmZcxC74aZXivKVV10NdTzFHezooUOifM+XvgF1WprLXr0GscaiXN+0F2rYwejoCDoQFnJyPmuOfYnyLHqpE8eaEPD5PxvHF5dIe3QE3esSS5Bmu9QZY4ynrJ915TAA+30YtvDd50SKa29Kfi6dwe9LK46PYxkUJ6etvcLAIL5rR0ZR0FcqyTVp9671UGfbhm14rQEUqtriz0Yb3yt1pW9cT3PylfWaHbxWxldcjy3hpOb0p7n6JcrCYwsu/eCFjWv+wkwIIYQQQkgXuGEmhBBCCCGkC9wwE0IIIYQQ0gVumAkhhBBCCOlCz6K/dKCIjkKZzO2lcP+dCTCWzWDMNh2KNNGK0q5WW4ouIsW9xw8UsZsikrNd/FKKW09OcbJxrWslisCi0ahDrNNGAVjOEvkFeRSXZbN4P7aYxhhjWi0p0nJTKBKLlLba/TBQRMGiJgRcclBcmbeS67W8/X7SClGA4PjyfsMYn0E7HoJY2sPY4NhGUY47KGiKq9iGjuVGFkfocJUoLlwdxY2vbTlDNpr4uUpNUbOWSqKYL0xBlTDBcV2plfFaiSWSw9sx9Tq2oaHEbB2S4+N8mN60HWKD1v38wze/BnWqTRR2rZ9CJ6xWSw7kSHNP7CMZxdmsYQmkHcW9y1Ec4TTHuY4l3Hn44Yehzg2Xb4HYmolJUS6voqBydAwFcaNjOLccS9wTKc5jmgC7ZeQ62AzQyXEBp5Fxlbdl0XLDbDbQTbUdoQNhu4UOrmvG5JcWCyWoY7vrGqMJ83CRVTRvKvba34vI8OVEWa5Ny9qHNBUxmvZO9pR+alviNm2fkEspDsDWi63ewnXEzaCr5atedSPExqfkHMlkUXSeH8BrdaKyKK8sozNls66s/Y4iRPetgwwUUW82jWuFp+wxlstSEF0ul6HOxqlxiIGrsjIUtf2LuqexJkDYxjHSC/yFmRBCCCGEkC5ww0wIIYQQQkgXuGEmhBBCCCGkCz3nMJsAc3ezGZmIWG+hsUErxj15zcU8Fy+Q+SqespVPZ5TD8a08tlaEOTpazq+v5HSl7YOysYoJlLxmu6lzs5ifpp0SXxrCA8ndQF4/bGIynWYSMKfkBS2UrTwq5TD+rGKM4qVkfw0MYg5eEYeDGS3ic42N/M5qVUle7SNpgzcSd2R+k6OYc7QbmEy3oOS/zlXleMznlMPe2zheCpbBi+dhO5tK/nCto+Qwh3K8+MrkSmOatllty3zrmvJ9xcFJiLlZxVAllH3YbKDRh+tgI6688jKInTpzRpQbLZzzE+ObIHbimDS/qJQxd8/OHzTGmCjG57qwIvMDk4vst4dMBp9BG/KslVxMbdVTQoEv142z585DnZkTByB2622vEeWmkkuoGSz5yoIdxnKstxVdRbOB76Tjx46JsuvhtQMl37Rj51QaYxqWydHSwhLUyefx+mvGShCz3xu1Ct7P8DCa7YAjTaLkdSprv6v0qZ2zfJGlMJt8EfPbG0u2LgSfkzZ+AuV5+raxllInrWi1EkujESv7kE4TTZjOndwHsbAxI8qlYczfdxPUVQRZuX7mMlreP77vQ0X3YvdhLq3ophSPEkdJ9E+BaYi2j1NMlKx5qem0tBx7Tfdia8gyihatFy6uVZ4QQgghhJCLDG6YCSGEEEII6QI3zIQQQgghhHSBG2ZCCCGEEEK64CQX28nkhBBCCCGEXETwF2ZCCCGEEEK6wA0zIYQQQgghXeCGmRBCCCGEkC5ww0wIIYQQQkgXuGEmhBBCCCGkC9wwE0IIIYQQ0gVumAkhhBBCCOkCN8wvkFe/+tXm0ksvfd56J0+eNI7jmE9/+tMvfaMI+RG5++67jeM4/W4GIRctP5gjCwsL/W4KIeRlhBtmQgghPzZ873vfM3fffbcpl8v9bgohP5acP3/e3H333Wbv3r39bsqPFdwwv8Rs3LjRNBoN83M/93P9bgohhPzY873vfc988IMf5IaZkBfI+fPnzQc/+EFumH9IuGF+iXEcx2QyGeN5Xr+bQggh/9sQx7FpNpv9bgYh5J8J3DA/B5VKxfy7f/fvzPT0tEmn02bNmjXmJ3/yJ83jjz8u6h04cMDceuutJpfLmbVr15qPfOQj4t+1HOZ3vvOdplAomOPHj5vbb7/d5PN5MzU1ZT70oQ+ZJElejtsjxDzwwAPmuuuuM5lMxmzZssV84hOfgDphGJoPf/jDZsuWLSadTpvp6WnzW7/1W6bVaol6cRybu+++20xNTZlcLmduvfVWc+DAATM9PW3e+c53vkx3RP65c/fdd5vf+I3fMMYYs2nTJuM4jnEc59l19r3vfa/57Gc/a3bv3m3S6bS59957zf33328cxzH333+/uNZz6UueeeYZ8/a3v92MjY2ZbDZrduzYYd73vvd1bdepU6fM1q1bzaWXXmpmZ2dfzFsmRHDu3Dnzb/7NvzFTU1MmnU6bTZs2mX/7b/+tabfbZmlpyfz6r/+6ueyyy0yhUDADAwPmda97nXnyySef/fz9999vrrvuOmOMMb/wC7/w7Byizur58fvdgIuVd73rXebzn/+8ee9732t27dplFhcXzQMPPGAOHjxorr76amOMMcvLy+aOO+4wP/3TP23e/va3m89//vPmP/yH/2Auu+wy87rXva7r9aMoMnfccYe58cYbzUc+8hFz7733mg984AMmDEPzoQ996OW4RfK/Mfv27TOvfe1rzdjYmLn77rtNGIbmAx/4gBkfHxf1fvEXf9H8xV/8hXnrW99qfu3Xfs08/PDD5j/9p/9kDh48aP7u7/7u2Xq/+Zu/aT7ykY+YN73pTeb22283Tz75pLn99tv5Cx95Ufnpn/5pc/jwYfO5z33O/MEf/IEZHR01xhgzNjZmjDHmm9/8pvmbv/kb8973vteMjo6a6enpHyp146mnnjI333yzCYLA3HXXXWZ6etocO3bMfPnLXza/8zu/o37m2LFj5jWveY0ZHh42X//6159tEyEvNufPnzfXX3+9KZfL5q677jKXXHKJOXfunPn85z9v6vW6OX78uPnCF75g3va2t5lNmzaZ2dlZ84lPfMLs2bPHHDhwwExNTZmdO3eaD33oQ+Y//sf/aO666y5z8803G2OMuemmm/p8dz8GJERlcHAwec973vOc/75nz57EGJP85V/+5bOxVquVTExMJG95y1uejZ04cSIxxiR//ud//mzsHe94R2KMSX75l3/52Vgcx8kb3vCGJJVKJfPz8y/uzRBiceeddyaZTCY5derUs7EDBw4knuclP1gW9u7dmxhjkl/8xV8Un/31X//1xBiTfPOb30ySJElmZmYS3/eTO++8U9S7++67E2NM8o53vOOlvRnyvxUf/ehHE2NMcuLECRE3xiSu6yZPP/20iH/rW99KjDHJt771LRHX1uZbbrklKRaLYl4kyT+tzz/gAx/4QGKMSebn55ODBw8mU1NTyXXXXZcsLS29KPdHyHPx8z//84nruskjjzwC/xbHcdJsNpMoikT8xIkTSTqdTj70oQ89G3vkkUdg7JPnhykZz0GpVDIPP/ywOX/+/HPWKRQK5md/9mefLadSKXP99deb48eP9/Qd733ve5/97x/878R2u22+8Y1vvPCGE/I8RFFk7rvvPnPnnXeaDRs2PBvfuXOnuf32258tf/WrXzXGGPOrv/qr4vO/9mu/Zowx5itf+Yoxxph/+Id/MGEYmne/+92i3i//8i+/JO0n5LnYs2eP2bVr1wv67Pz8vPnOd75j/vW//tdiXhhj1KMW9+/fb/bs2WOmp6fNN77xDTM0NPSCvpeQXojj2HzhC18wb3rTm8y1114L/+44jkmn08Z1/2lbF0WRWVxcNIVCwezYsQPSSckPDzfMz8FHPvIRs3//frN+/Xpz/fXXm7vvvhs2wuvWrYOFdGhoyCwvLz/v9V3XNZs3bxax7du3G2P+KbeOkJeK+fl502g0zLZt2+DfduzY8ex/nzp1yriua7Zu3SrqTExMmFKpZE6dOvVsPWMM1BseHuYmgrysbNq06QV/9gfrey/n6xtjzJve9CZTLBbNfffdZwYGBl7w9xLSC/Pz82Z1dbXr+Izj2PzBH/yB2bZtm0mn02Z0dNSMjY2Zp556yqysrLyMrf3nCTfMz8Hb3/52c/z4cfOxj33MTE1NmY9+9KNm9+7d5p577nm2znOdfJFQuEf+GUEjE/LjQjabhdhzjd8oin6k73rLW95ijh07Zj772c/+SNch5MXid3/3d82v/uqvmltuucV85jOfMffdd5/5+te/bnbv3m3iOO53837soeivC5OTk+bd7363efe7323m5ubM1VdfbX7nd37neQV9vRDHsTl+/PizvyobY8zhw4eNMcZMT0//yNcn5Ln4gfr/yJEj8G+HDh169r83btxo4jg2R44cMTt37nw2Pjs7a8rlstm4ceOz9Ywx5ujRo+IXvsXFxZ7+bwshPww/7B9wP/i/HLb47wf/Z+QH/OD/+O3fv7+n6370ox81vu+bd7/73aZYLJp/+S//5Q/VLkJ+GMbGxszAwEDX8fn5z3/e3HrrrebP/uzPRLxcLgsxKn8EeWHwF2aFKIrgf1+sWbPGTE1NwXFaPwof//jHn/3vJEnMxz/+cRMEgbnttttetO8gxMbzPHP77bebL3zhC+b06dPPxg8ePGjuu+++Z8uvf/3rjTHG/OEf/qH4/O///u8bY4x5wxveYIwx5rbbbjO+75s/+ZM/EfX+1/FNyItFPp83xuAG+LnYuHGj8TzPfOc73xHxP/7jPxblsbExc8stt5hPfepTYl4Yo/9fQ8dxzCc/+Unz1re+1bzjHe8wX/rSl36IuyDkh8N1XXPnnXeaL3/5y+bRRx+Ff0+SxHieB2P1b//2b825c+dE7IedQ+Sf4C/MCpVKxaxbt8689a1vNVdccYUpFArmG9/4hnnkkUfM7/3e770o35HJZMy9995r3vGOd5gbbrjB3HPPPeYrX/mK+a3f+q1nj0gi5KXigx/8oLn33nvNzTffbN797nebMAzNxz72MbN7927z1FNPGWOMueKKK8w73vEO88lPftKUy2WzZ88e8/3vf9/8xV/8hbnzzjvNrbfeaowxZnx83PzKr/yK+b3f+z3zUz/1U+aOO+4wTz75pLnnnnvM6Ogof80gLyrXXHONMcaY973vfeZnfuZnTBAE5k1vetNz1h8cHDRve9vbzMc+9jHjOI7ZsmWL+fu//3szNzcHdf/oj/7IvOpVrzJXX321ueuuu8ymTZvMyZMnzVe+8hXVFc11XfOZz3zG3Hnnnebtb3+7+epXv2pe85rXvGj3Ssj/yu/+7u+ar33ta2bPnj3mrrvuMjt37jQXLlwwf/u3f2seeOAB88Y3vtF86EMfMr/wC79gbrrpJrNv3z7z2c9+FvRSW7ZsMaVSyfzpn/6pKRaLJp/PmxtuuOFH0gD8b0Ffz+i4SGm1Wslv/MZvJFdccUVSLBaTfD6fXHHFFckf//EfP1tnz549ye7du+Gz73jHO5KNGzc+W36uY+Xy+Xxy7Nix5LWvfW2Sy+WS8fHx5AMf+AAcCUPIS8W3v/3t5JprrklSqVSyefPm5E//9E+fPTLrB3Q6neSDH/xgsmnTpiQIgmT9+vXJb/7mbybNZlNcKwzD5P3vf38yMTGRZLPZ5DWveU1y8ODBZGRkJHnXu971ct8a+WfOhz/84WTt2rWJ67rPHjFnjHnOo0Dn5+eTt7zlLUkul0uGhoaSX/qlX0r279+vHq21f//+5M1vfnNSKpWSTCaT7NixI3n/+9//7L//r8fK/YB6vZ7s2bMnKRQKyUMPPfSS3DMhSZIkp06dSn7+538+GRsbS9LpdLJ58+bkPe95T9JqtZJms5n82q/9WjI5OZlks9nkla98ZfLggw8me/bsSfbs2SOu88UvfjHZtWtX4vs+j5jrESdJqFB7uXnnO99pPv/5z5tqtdrvphDyklEul83Q0JD57d/+7ed1SiOEEEIuZpjDTAj5kWk0GhD7Qe7zq1/96pe3MYQQQsiLDHOYCSE/Mn/9139tPv3pT5vXv/71plAomAceeMB87nOfM6997WvNK1/5yn43jxBCCPmR4IaZEPIjc/nllxvf981HPvIRs7q6+qwQ8Ld/+7f73TRCCCHkR4Y5zIQQQgghhHSBOcyEEEIIIYR0gRtmQgghhBBCusANMyGEEEIIIV3oWfT38T/+GMQymbQoB0EK6gwODkIsm80+7/c1wybEVldWIdZqR6KcOMotpTMQypSGIOak5f0kSRuv1cF21RaXRPnCyeNQJ2risVvFYg5iiROLsuvi/XhKLI4iiIVhKK+tpKtrVt/tdkeUoxD7IYrx+9rW9xljTLVeE+V6E/vvr//88xB7ufiVt+E4SBdk/6ayG6BOkNkCsV2XXw0xPyWf52OP7YU6TzxxCGLFvBwbu7eh+2PGnYdYuqCM9YERUS6kPKgzMjSAn8sVRbkZoWNfy+A4SGVxHZg7I+fu+skdUGd5tQKx7+//vlJvQZQ3TqA7lZ8Zh1jdkc86PbAG6mRy2H/TG9dBbGxIfrY0OAx1Lt24HmIvF3t+5YsQC1w5rx0f7zXxcb12PKw3mJJz3W+cgDp3vGIzxF73yp2i7ClrbKWC59Pba5kxxoyMjDxvHc1lshfnyZda2uN5OAc/97nPifLx4/ge6Sj36Frv3Xq9DnV27tgGsTOnTkLMt9p1/7e+A3W+/+gjEHu5uGVXHmKdlnye7QTfjys17JM12RhiG8fkulup4jjIpfEdtnZEXsvJ49gfv+xWiB1dmIHYwrxc171Yed8r43PIcgg+fgKvfew4uluulJchdvlOObduunYC6jgxrtfGwXG9uCLLfukyqLPlKjxJyfPk77kJDn0TZPD7lpaXIOYYOUa0Pehv/Ot34RdY8BdmQgghhBBCusANMyGEEEIIIV3ghpkQQgghhJAucMNMCCGEEEJIF3oW/ZVKJYgNDEihkO/j5YIggFikCNTsehkHhUNNX7lWSybbVxsorossEZsxxmSLKG5JWYIHx8G/J2LUCZhqJIUry0uYdH70MAq7BkvYhrUbpMBodBTFS6lUGmKmg+IZ3xa3KEK9sIU35BlL0JPCfm9hl5pmFcU65eWyKKeyStv7yOWXTkFsuWUJFWMUPW3b/QqIpUoo9Dhw7BlR/v4JFEqcXsDOzC0tinJ54RTUedXVODY2rsW2ziw8JcpBcRLqdHIFiLXachwUSyiSK+Tx+87OXIBYNic/WxhCEYmbQ+Hh+pWNEGsfk8/HiXAMD2aVpa0l1wY/qUGVuINzvtNBgU2nLZ9jdQXXHWP6J/ozCQrbIksQ7Snrm2dwHckpws5sKOd63FyAOvkUPru0vZYozy6jCHI0mZ4tzHNdvJ9eRH+awM/18HNJgm2FjyoNTZSXhquI/q6+9ipRrtRQ5J7Loejt0NGTolwu4+cipZ817Hdzo4liuX7y+jfeCbGVshyLs9Y7xxhjFldWIDYa4JwdDKw1oayMnwyuU828HAiRwTqtWXwuJoXC/+27r5VNWMJ3huvi87RFsKfOLEIdk+Bc9gyOf3tNdWKljhZztQkg6yXK55Qm4FRS5rI2511lXbPraXvVXuAvzIQQQgghhHSBG2ZCCCGEEEK6wA0zIYQQQgghXeg5kWPLFjRqsPOOtQPTq0peq5Yzls3KXEjPw1xXLecusg5y1/JqXCWfT7tWxjoAXv0+TAEynab8zsqKdhg/fnBheRZiM4uyD0dH0ZxiahJzScdHRyBWtPKFU0peXsbHWLMh8+uWK5jrqZkLLC/jAeg2nY6S/NxHVmvYHj8nc4PDBvbtdx58EmJPHESziEMnj4pypJh/pAPMS6xYuWa1Gh6Wf30ax0FuDPNmWwsyVy+XRiOWpr8Wr2XlFNcV0565kychFrYwN7DZluNlKY9GH802zpvFs+ch5nWs/M8UPp9UEa/fqcrc6nSC/R6GmK/fUPo+MzEqyo6rLAwXGZEj703L9QsUI5GRFNZLKtIUIWzhOnXswGMQ2zQm85O3bJqGOp6Sl5jJYK784cOHRfmZZ56BOnfccQfEIK9ZSbucm8P7GRwqQSxlvQNjJV9ZS9lsKrqagUF5/auuQiOk4ydOQuyyS68Q5XNnz0KddArzwptNfNYL8/KdtLqKub/95OZX74FY2cpPPjeLz26+cdif2wAAPFNJREFUjPfhtDC2dE6OqVSCueYXatiXJ2dknvHCAq5bmTy+R9duwDV85275PK+/DvdebWUtzll7qP37j0IdRcak5g/bRmiOloev7OMcLR/ams6ukuesxex86F73ceq1rDnvB8xhJoQQQggh5EWHG2ZCCCGEEEK6wA0zIYQQQgghXeCGmRBCCCGEkC70nPlcqWHCuufKj9cbmIher6MAaGAATRLqTfnZqNPC7/Nwfz9QLIpyJsTk9KZyaLsmgAvs5HSooR+EbxuE2Mn3xhhTLBQh5ne0DHwpIjl1AsUDRw5iMv+G9SjaWjM6JMpOjCIPJ8Jn1mpIgVa5gs9wcRkFE802PrMgZRnQaAeb95HVBh4cf+607Kejp89BneUGxlZaMxArpuS1fK8EdeptFJZElug1P4lmI87EZRBrDqBZxKU33yLKmQKatVSqODZqDSmeadaPQZ12HEJsZGwdxIaK8jszJRyvi+dRrLPSHoLY4LgUwUxf9Uqo02mjKNUslUWxHeI9d9ooXJ6bmYNY0Vp3pqbw+fQTzWDJWGMqUp7d0CAaRm2bQHHkoCM/+9B3H4E6/+Wjn4RY1Pz/ifL/9e/+L6gTK+ZTGrZRw6WXXgp1ejEu0URPjzy2F2KlEo5F22QlDLFPNZF7U7nHcrks26mIH7/97e9BbHFJrsWeYopy1eW7IeYob7iVFWmu0Wzi+6Gf+BncssTW1qSpzOuK8g6rLKMhSHVRijHTKezLwMHrN9vyGWeyuMfZugXF1jfccB3ERi2TuOESmqCcOIEC+wuWQDrCoWgcR9vy4ThoW0ZoLWU/5rsYcxSToyiS3xkoWwDNKMgW7zmq6K83IaCx59IL3IfwF2ZCCCGEEEK6wA0zIYQQQgghXeCGmRBCCCGEkC5ww0wIIYQQQkgXehb9Veso+rM/riWZez4K4FIZdMpxPalScWJ0+ova+AXtpkzS14SHkeIg5jmKI6CxXAMV16tCDp3Atmy2BEwdFBislBchdmF+FWK+L0U3bhYT/jsu9k2riUnsp85IEdWRg09BncoSCtVGS1Lk46fwGUaKUAYsfYwxri9FE64i3OwncYAucQ8+JV38ZpZQ+DE4iAKgsRJeayAvRYWzC4oItjQKsetvfrUoX3vj9VBn6xYUzo0MYbtKg/L6tQYKMzKKc+PcnBQ21gN0z3PzKJyJsigSm9guBVl+BuvkJlBEcsmVKOizxR/NCJexM2eOQGx8nVwbZs6dhjrGoANbs4pzN2zKPs1nUGzZTxzNpdSynEsFOK59RXxTVtaIV9y0XZS3TL0Z6ux/6h8h9t8/999E+fbX3g51duzYATHNIbRkiaPssjHGRIo1K4rw8J7rDUV0nlJEopHsw1B5CYZKGyKlnqUbM40qvnPnLeGqMcYcO35clMcU19e2JkZUBFO2+5/v4/uunzz5FM7rhSUpyl2YR0Fcq6WoYJXDABIrVlvBd3QhPwGxjevHRHl5cQG/TxH5NxQX3eaAFB6vlvF+NKe/lRVZLwq1gxPwmWvjoGW1tabMh8DDOak5nnY6liASajyHOBec/nrbO+jXsj9L0R8hhBBCCCEvOtwwE0IIIYQQ0gVumAkhhBBCCOkCN8yEEEIIIYR0oWfRn+ejQKTTlgnynoeXKxbR8SaXQ9Gf51uKByUhf7VZxjaEMvFcc1XSrJyaTRRfZQele5cfoOBBdZaxnJXqDXQL04QfvtKnxrp+Oo/iqIziGqg9n9hy53EcrBN2sJ8DS3ioPVfVTUcR9NmJ+57f85B7WVipY5sXKrLfQhdlCrPzsxDrNHCsh0Py+kMjKBh51U+8DmKvu/MtojyuOMll0vg8nUQRt1ixYh6fge2qZIwxYTQuyp0YP+co43q4iOOznQxaH8Q1IFEERgsLKLpZmjsryufOovNltYKugZmMXAearTLUmRjF51NZRWFj4Mh1p5hDh7x+EimOW0FsCYU6+MyrIT6XE4pI9FtPnxTl26+bhjq/9u9+FWIf+p3/JMr/z+/9HtT5yH/+zxDTxHuxZWdouy8ao7ve2aIg+zrGGOMkSv8pa5djrQ2h4ogWxsraryz9GUvLHSjr7tQUCvpGJuS6s37DeqiTS+MaVl5FMVmzJcWBnrL29ZOvfeMBiKWsZSNs4jNQho8J2yi4iypSrOcq7nK+j+Jnuy9nz6NQtqwIAReV98imzdOifPvr8f1glPk9NCwPCEiltfGKe6FEeZfbhsmtUOlA5eAET3GnTKz9l11+LlxrnmpiPnu/ZIwxjiLos99v9rV7hb8wE0IIIYQQ0gVumAkhhBBCCOkCN8yEEEIIIYR0oeeE0nQKzTLaLZkHHCv5w1reSV7Jy63VVuS1lIPWAyWn2PdlvY5yOLiW06IdyF4oyHZ5jpLHpuTfzF+4IMpP7t0LdWYuYE5TcWgcYh3rcO5IyQkyLibAaXlIjisfr+fhM/QcJZ81kdfXTBAcJTcwSGMeZyotv9MPLq4c5of3HofYxs3SlGFwZArqHHoaD9AfU4wTdl2yW5RfdetroU5hBMdB08rD03KTHSX30ldy2zxrzDrK+PEyyhwZlrmRecXDIKXkRvrpHMTKNWmIcGYWzUDKyxhL2qgHWJyR+clnzxyGOp6L60fclvm568Yx1zPtK4ZJSq54Pl8SZT/Az/UTR1uLrZC2NlcbaM4xlMfc/IplcNGJcY246ZWvgtjtd9whyp/+y89AnSsuvwxi09ObIJbNyud54403Qp1UCtck11pTtfeWUXKMIyVnMwjktYIYJ0lKmZNJE8d1Y1nm62eyOI9eeeV1EMtk5HeuVfQO+/cfhNhsC9vlWkuKrRHqNw889CTEBrPy/tU3jLJWZnzFDMdaNwJln+AUlc8NybzmZoR1FuaXsFnlFYhtsMbjQhl1HI79oIwxw6PSTMlPKwu2ojNS5CvGWG3wlc8FSiJ+YCeUG2Maofyspt3yVbOR7m0yxhjFh8W4yjyFz2panx7gL8yEEEIIIYR0gRtmQgghhBBCusANMyGEEEIIIV3ghpkQQgghhJAu9KzA2rQJRReLCzJhvVLBg8C1BO+lJRT3VKvyWoMFFJp0OihIiSxRQqeNh5ZXa9iutpLp3j4lE8GHh7ANGSXLfGFBHkherVWhjtYPmbQiwrMEdy1FsKgJ/IxSzxYGaKYhqUARxVgH5ruqyBC/TzMXSKzk+nTm4joIf24V23zt9ZeIcpzg/buaAYsi/GqEUmxQqTehzvYrUHxWsgQcgY/9rWjR1IP2A0ugGSmaiJQypry8FB2llfHqKuJPo/SNa4mG6y2cy5pZRNJGIw0/kXN+5zZcm0rFAYgZS5im9dW5M6cgVqmewTakpElGpHXqxYZ9vwk+pyjCcVBThICttLzf2FXWliw+u7f/i38hyvd/+7tQ57/+1z+D2H/5L/8FYldeeaUo+8q400xJbDQzqkD5mKeYadmC2kQR+M2eOQmxvQ/cD7EkkYKzq171SqhTUdqQWOt8vY6mXKfPnYVYrYX1WrGcW66y7vSTZlu5/7ZcUwczylhUlql2G+ds2xKla2/a+tIcxAqWgHD3ZhRyL4wPQSwdYMO2XSZFr6F22EGCokL7nawdbKAJ9TQTD8ca156yX/KVmHZGgS0ELCqHPqSU90hsifeU5VptuzafHe/5hYe9wF+YCSGEEEII6QI3zIQQQgghhHSBG2ZCCCGEEEK6wA0zIYQQQgghXehZ9Dc6NAox37JDqpRRzLdkCeKM0RPDl5elC044hKKdpIPuXZ2mLfrDOkmEopVOB8VXaSNFTp0Ir5VRRHKBpSjYunkj1FlerkBsaRnFiI4vhTLpDH6f5kzlxkrMlbG05syjugHJoiZk0f7WSpR2+ZaoQRMd9JMrrrsFYrf95O2iPDeLIo9Dh9Dpr9HGcba4Il2aak1FuKroxULL6dLV3MgUkWWsCCOa1jDuhPi5puaQaQm5NKGjLQ4xxhg/xrmVsUQdU6M4v1t5FIR6Mc7B1KYJUc4OoCOa6+K8qVui5ONH0SFwroJuXE0H76dt9WGzhWLjftKDeZeJY8Xx0cd+ixTh3EpVOtWdPHMO6kwNroPYxg1ybfyld70L6nzyE5+A2Je+9CWIXXvttaLsKcIhzc3QjmnrVloRRBaUvklZLnvVOrqyVWZQNLp44hDWq8t3xLgiHIuGByGW+FKcvlDFtt/zrXshtnHzVojVIzmOvfTF5cxqC9L/CTk+s4pQMe+hSK6uLJaVUMbaioNlvICuvYVgWZSntqHg1U2NQSxTxJhvCaQ7yjqvGPSayForfUWsn/bwfe8pGzLHeX6xrCqoVd4tviUoL+ZQ9JfPYH+1jXxm2i5EE+9pQnQ7pq0VvcBfmAkhhBBCCOkCN8yEEEIIIYR0gRtmQgghhBBCutBzgpKjZMXlcjLvJKPk2yYG8xJHRoYhVirJ3CztUOy6YkASpmTezmgW8xljD/8uyA5iDmV2QMY0E5SMcoj4fEbm5Pg+GjyEYRliMzOYC9W2EnV8Ja8zn8e25zN433buUCrAfrDzr40xJrHzUpX02UTJq0qlnt+UpFrFXO5+8tRD90OsPDcryoNDmGfWbOBYXDeJ9XZuk3mcAwUcP9/7x+9AbHzttCi/4qaboE4rwOnrKzlqlneKqTcwLzhUToUvDsrn6WGamTY0TLuNY6rZfn6DoWIBx08hoxgYWXly5Tpea3FlGWKzs3K+HT/yDNRpLM9DbDCLfZry5Bx3k4vLkMc42qS15r9iyBMpOZuukjDZieR4yQ2UoM7ZC7i+bd80LcrXX3c91Ckv47P7q7/6K4h9/etfF+W3vOUtUKet5JbbPeMppit+gM9zqbwCsUwkx3W4iJqdzAJqIHYpj2dh1TK8euIJrLQGtURmQMaqGcwRHaphP8wfwDxqO+81bmHub19RctITe+1ScmsHskrOqvIOW7G8XBJHyfk12JeukWtqs1qGOst1bMPqGdRMVCtSM7H18sugTlp519q3rZl6pJX9i5bDbIccxdhKy/1PlL73rM9qOrCsYooVuLKtkf0iM8Yo20Q1P9nOYXY1IV0P8BdmQgghhBBCusANMyGEEEIIIV3ghpkQQgghhJAucMNMCCGEEEJIF3oW/c3PoXBheGRIlEulIahjVjRZEGKLClstxaRESfoOrAOv/Swmj1+YRfFJa+Y8xCJLBLBv71NQRxOIpNKyDdUatr2p+Bpk0ijUsyuuLqEoYGUBDWJ8RZiTS8vk+moVD9Vvd7BhFUsgkkphn6pP1VfEAy2ZbN8JsW/6yZWXrIHY95+UYpulKopDMmnFGGMFBWNz56Whw4MPPQx1tl1+A8TSBSmMfegRFABpYo0zJ09AbNkaQ8UBnKeFwSLExiZlvcl1I1Cn3mhA7NhhNLFYnJdiqGwGxSc3XncNxDZPr4fYyooURz1z5DTUmS/jvJm3DAfOHEfjkguKmUleMWzZvOEKGVh3cRk8aJo/W7et6DzVeR0pzjqe9fymJqegTskrQ+ysNR/WTa2FOm964xshtncvjv9PffpTonzlNVdBnQ2WUYoxxsSWaFQTKt1y26shVlGMrOw56ClC7qeUtm9ShNuNvBQSx03s98HhSYjlB+U8PbEPTZVudFEI+KgiRmynLaGvNkj6ieKVESXyuVRDFH3N1HGtbCmj3RaapTVhmxKzxfqLKygKb0a4xjZraGS1b+9eUT50DNf0IeXghMsscWCsPDvXwXeZJpyLbVMXWzBsjHFshzNjjKPsQ1xX7h88ZT11PcUAyzIl0d53sWJKF2j7EMvwJlDEnL3AX5gJIYQQQgjpAjfMhBBCCCGEdIEbZkIIIYQQQrrADTMhhBBCCCFd6FmpcvLUKQxaypJ8HkVsrTaKgkJFPAGJ9EqSuac46BnL7azWwSTw+77+NYg9rQgxNkxKQUVjpQ51SkPjEMtbTnBBFt3JioPo0NRqoovScEn2w3RmHdSpVlFQUF3FWGVVOlM16lWoYwsmjDHGce1kfkUcobj1JPHzCyQymYvLEe2W11wNsXoon8tDj6Aj1tQEipw8D8en7Qi4WkHh5f59eyF27JQURzmK2LSlOF8eP4JC1eqKFNwVijgWR8dxnA0OSZGfq+gk5hVRarODKpLrb5CObm96/eugztgYCjBTKRxn83NSXPntb34d6jx9YB/EOh3ZX9UVbPvyHAo3C4pz2uy8dIPcEe+AOv1EnYueJfBVlIGJwTHsOrhG2AahWR+vNTU6CLFDlgPa3AI6420axzX2X70VXfx+63c/KMrv/88fhDp/9LGPQ6zoyjXIx1eGmTt9HGLO+gmIDVsue/kWCmMvvRrFiBfOoJDLycp584zS760ERdrtgoytifFz6y+UIfaM8jo9YQ31Tu3i+k0tVgSakaUEXFXqdDqKKF7Z/gzk5WAYH8RrKbo5U0jJa3Uq+JxWW7gXakUonOtYrqhzp85AnVMncD9WLst3SzGH61YnUu5HcQS0D0DQ+l3R/BlQFivYrnv/FFNEhVa9RPvCGPdQmsOh7f6nuQH2wsU1GwghhBBCCLnI4IaZEEIIIYSQLnDDTAghhBBCSBe4YSaEEEIIIaQLPYv+fMUOxrcSp5Vca5MoCfJhB4O+LxVFjqu46TRQzOAHsg3ZFIrKbrrpJoitm0QBx2BeivWeeBiFgeWVCsQyAyVRjpsoxiqXyxBrNVFUaHeY4ykCwiK6RBUKGBsZlQKUdAYT3VdW0e0pFcgH2en0YBtmjHGUMRLH8n7SKcXdsI8ECT7PW2/cLMojBcVR7wI+u0oDBQhz89L5y1Xuv11GMWY7kqIOV3E56tSw7VEHx57t7lRdRafITgdFHUuLy6LsBNiGTdu2Qey6V9wMsVfdLGPbtkxDncVFbNdXvvxFiH3fcks8sA8Fforhp1k7KedDuILCHCfGtWlyCt0GB0tS0NZuN/EL+4jmRmbHHMU2LVFinQ6O6+3btoty1nI7/afvwzmycaN03jt9+CTUKc8pQsAxXK/fetsdovzHf/VpqPOFz/0txH72X/28KHcUweLpc+ge6cWoDnQn5JyozqJo9PzMBYitrqL4d21B9uHiEn5uWRF7mYpcP5RXpykPoXg2auG6k2rLOVHVbOD6iDau7RYGIFo3JufjfQy4OGcHA3n/0yPYb2PDeK3BAbmVOrmCdZ45XoZYtY3zJmXtq3I+1omV92/DcujVTHWbIa5v2rUiSxxoiwCNMSb2FQGhIg5MLHGxJjLURpkD7zx8rp6Dz0cTisfWd3o+RX+EEEIIIYS86HDDTAghhBBCSBe4YSaEEEIIIaQLPecwb9iAeXyFvDwY+/hxPOx9dnYWYuk0JhjmLNOTjnIgdeIqOTOWqUatgnmdjpIhMzKGh+PbB4a7WcwdClcwR7TZkrl6UR3bUF7GvDxXadfwqDwIf2AID8I3Dv6doxoVWHlHtRrmzbXaeD++ldPnKaMk1HKhlPxPaFOiHIDeR1JtfFbbJ+W4vnwzmps8/vR5iJ1fwmdg50odOIZ5iYmSX+f7Mg8rl8aHsH4j5g/PzM5AbMXKbRuf3Ah1LrviWoht2b5Vfm4KjUV2X345xFIZNKzwrIPpH3/scajzxb/7HxB75OEHIRa2ZS6pF+FasXasCDGnKXUSnVoZ6jRrmNfpKTlxjnU/kbJe9RMt19MkjlVH+yCuLa6HjjW2SUIYahfDMetZ6/XGDRugzonH9+KlapgP/ZPXvEKUj+w7AHU+8dE/gNhVV14jypdcdinUaShr2XgG9QdhQ47FWEnGrKYwuNTB/Pncilwb3QDfP2fLKxCrNWVbL9TRIMMNcZ37F1sugdj+FZmD/ek5fKf3E18xuPCMHJ9+jHWCBHNW84oDSc6XYzZq4rUmSzgOJidkwnBFMQTL5VBfVY+U+7Hyxm2tmDHGVJVnvGSZABVLQ1AnSnAsJj2Yjdhrx3PFtDUltoJqHrqi0QFzEQf7wVHWpnweDVsS67Oer7hw9QB/YSaEEEIIIaQL3DATQgghhBDSBW6YCSGEEEII6QI3zIQQQgghhHShZ9FfoYAGGvW6FGJo5hyhcnq2JvprW0KeyCgJ+VlMmm9aye9zc2jE4SkiuQHlfp555pAoX7iAAq2wje1qtaSAQxU1ZlEooBkC2P2lGVY4ysHsxsME/FBV9Ug0EV4MAsLe/q6KlUPLbe2MZm7TTzIpvLdaXQq/QkVQ+cobroDYUhnHxvQ6KWo6O4ciy/0HjkGsWpPzQTOdec1t10EslUUDm7ll+VyG10xDnU3bUbw3MiGFsUEGl4tsFgUWgYvjv1qVJihf+fsvQJ1vffM+iKnHy1tzZHAQ14UoRoHrM0ekULPTxme/edNWjE2jMM1e6xpNFHH1k8QoIuDnDRjjaFpBRcl29owUl1Yrm/CDAyiscSxjpkwGx8r6zdMQO/X0QYhlLdOCn/2pt0CdA//5dyH2J3/0cVH+8B/8P1AnUsRlgSI6Slmv0BnFkGRFEfW6QyWILZ6Ufbrk4XqSTI1CLLN1WpQHWvhemVTWsNuH8ZnlluX79K8vrmFtXG3QWu+nunKvYRPfTUNFXM/WrpXXKsTK/kUxvfAc2VEppZ0Dihit7ShGVg05hhJXMXpLK+MzLduVz+L8azfxflwH+8G1jT4U5b+jzAftQAJ46Wt7AE0IaIXUvZDShkARabuWiF4TC/YCf2EmhBBCCCGkC9wwE0IIIYQQ0gVumAkhhBBCCOkCN8yEEEIIIYR0oWfRny3wM8aYVUvgoCVlZzIoyNGcXuzY4vw81JmfR0FfcUCKnFZWylBHEyMWCugElnRkQvya0TGo47mYLN4JpchiZUVxY6qh2MsWCxpjTMZ2F1T6KooUtzylXmjdT6eDCf8atnivV3M+38fh5AdyTDQvMnFUdRnHWXpAuit6aXTcqlZQWLN8AcenqZdF8drtKCC7cstNEFtYls5ciyvomFlIYWxkGB+WH8s+v//+f4Q6X/7S30KskUhhbKpYgjq33/46iL35jW+A2OyFc6J88OmnoE7YwjUmVmR/I0PSweqqq9CxbMNGnN8PP/yIKDdruDa98Q1vhtitt+2B2GJFCkMryvrYV1SnPyumVkFFjuPivLbFz5UK3r+TDEPMtVTAkYuNKEziujvaxPVz+cRZUZ6anII6v/ivfh5iv/8XnxLlL/w1jv0N69dCLFLEdBlLCDsyMQl1xqdeDbGjh45CrHFGCmMTR3Gw3LYDY9deKcqDq+hWuWkaP3f6mVMQ+/7Tsp/DFyiOeqmIHcXt1xqytrOcMca0lMF+vo3X2tGW683aQZwPZaV/fcvNcVAR3Cm6bZNVDgjoWO6CseIims/jO2nbji2iHGRQZLj8+NMQc1xNhSdjQaC82xW3PEdxJQwtIaCrHFqgC/rsFilrk3aKgPL87T1NoAhxe4G/MBNCCCGEENIFbpgJIYQQQgjpAjfMhBBCCCGEdKHnHOaUdhi0lXei5Tk3mw2ILS+XIWbnQw8Pl7ANAbah1WiKcjaNB4FHBcxV0nJyrrhSmlFMTGAe29P78QD9TiRzjLRcXg0tlxvqKHk7UYQHmaumIZZJQCdsQx2tDa6V06SkNRpfOcg8ncacJt+XYyRI9TzkXhaGEuwT38jnmXKxb08dPYzXKk1AbMe6XaJcU/LmLtl8GcS++50HRfnIM0egTmUVTUpGijg2tk7JnLFTY4tQJ62YjcSZQVF+4tAJqHP8GPZDGL0aYokj+/mVr8K87ekNmN+9NIdGEJNrZJ7owjzmYp49g/01P78kymkfc2UffeQJiNUauK5t2SlzQtM5zJ/tJzgKjLF/H/EUcYKToM7BUYwNGh352dVqE+qoq5u13mgGK6FiwjQ2vR5inab8ztYCakduuOFGiL360DOi/Bd/8gmo89af/T8htkXJAw4CueZppj2JEnMHMMc+KMic0xy+7syS8j5tH5Hjv67oRPb7+KxLV6NxycFTUr/Reho1Hv0k8XC8+NYzSBRDME8xG2m62MEPHJZzvTWNvynuVPK6MwvyuayZRmO0UhHzjltN3K9MTVmGUUqe85yi59piGdi0FcmSq2gGPGW+2bnBWr5yEGhfgGuFrUPR9io6z59nrF1L2x+5lsGJmvvcA/yFmRBCCCGEkC5ww0wIIYQQQkgXuGEmhBBCCCGkC9wwE0IIIYQQ0oUfSfRnm3GEISaBp1KYsJ7LKcI8K1F7eAgPvfcUoVm9KcVEoWLq4WUw2T6VRhHAriukQKs4cBbqPProIxBbWJDCCE1I5yuig0xaEVJaie5RjMnpiSLCcT1MdG+15AHrnQjFIJEiD/Ksg8U91ZAGn2tauR9bXJnLoVlEP6nMo/lHdV6K4kY34LiOWygW7DTw/osZKRwtDuC4PvT0GYjVVqXIYusmFMmFCQqAZs5XIDa9XorkXnUtGn0srioGIRukYGrj/iWoM7gGxW6lQRS8ZCxB6OjoKNT5ydteC7G1a1DslU/LMXT+FAr8vv3dL0Hsnnu+LMpRRzEzOI9zvlxF4VOQl/czvfniEv11lDWiY5ku5Q2O4VSimMckinGPkWN9SRGzthSRcdaaIpr8R9HYmlSA683Ups2ifGB1H9Qp5tG84a1ve4v83O8+A3W++D+/ALE3v/VnIJZZI4WxpoJrZdJWRNr5QYjVLLF4ekD5PesMCm8f+5Ic667yDuw0Mbbluusg1mpagucCPvt+You3/r+oKGm+XpGyXheHRyBWb8tx9t0jKK5rNnBuBRtkbDLAtWVyDIVzaXcjxG66+dXycxMlqDMzO4PtaksR7IFn0BzHcZQxpRiJGM8SCAf4Oe1sA0eZ0bF1aoCrCO408V5imRwZTZD8HPJmG98yVPG0fugB/sJMCCGEEEJIF7hhJoQQQgghpAvcMBNCCCGEENIFbpgJIYQQQgjpQs+iv3K5DDFb9Ke6zSmx8XF0RNtguXxFIbr1NJXEfWOJFKIYk+3bbbyW4ylJ5lbC+urqMtZREs9BE5fg3yGej4IwzUErSEuRhasIHTU035qO7XjkYN9oosxeEul150dsRSYjBVrDIyh66yfpARSgprOyzctlFII1G4rA1UER3lHLKWu1gcIPx0Nh2+VX3CzKW3ZdCXX2HnwaYq0WCtQWK7JdlQrOo4EstuvM4b2inI5RzOd01kDs/Dlsw9KiFKB+/WtfhzqPPPggxG64Hp3axoakYHDbxnVQ57LLdkLswYe/KcrZAJ3+Xv/6n4JYYQDnSGZgSNYp4jjqK4rwGMXIihefJr5R5nVk/dayVEaxaaeDoqpMChZLqOMoq1msKLmyWdnnm7dvgzrnzqCgds2kfP/8zP+Jrn4f+6s/h9j/++lPQWzPq14jyk4d14CgXYVYZwVj+Ya8x5xBkfauHIrwfiovHT/TlRrUWRnAuVtW3j/3zl2Q11LeGf0kVt7vtqAvjrBOHOEeoLJShli+WBLllo+OjI+eUdwWrVdmbp0ilM/jGrHBci01xpgtW7eIchThWFm/Hte8ZkeOlxOnzkEd1V1YEeGh0x8KAwMlFil9b6xnprns9SL685Txqhn2OcohBbYr9Qv9pZi/MBNCCCGEENIFbpgJIYQQQgjpAjfMhBBCCCGEdIEbZkIIIYQQQrrQs+ivWsXEc89yT7EFXsYYU6mgGKRWw2sliUyIdzRBipavbglEkh6Fh80migDalnhgfuY81FlZREFTLmu5SbmKo08GRRehpq3zrM8qCeyOlriviR0t0V+kCGe0BHzfEhqm0/hcs1kUnyhNhTER+Ng3/WTtlW+CWCqQQo+z59AJrLZyGmKtWhliy/MytmYtCvzS6QWIOfF+ee0GOpZdfsUGiJ08gwK1r33ZcrirorvhQE4RVKTld84r8zYs4/Nseyjee/yJh0W5WkVHuWOHDkDske89ALFsWq4V4+Mo3hufRLHO/JIUQ2mildkldDNct+UqiKVSclzHnd4cp14uHGU9sAU/mpxL+ZhJFBFzYmTfaaK/VgfXm3xsX0tZr5V26bJm2dihoSGo0WigQGvZesa33PpqqHN0BoW+/3DvfRB7251vE+VdW7ZCnUyMbZhTbueZxw6K8mAe5/LaqXGIje17TH6uoQgKFbfGJMJGtGvyHegq7/R+or3LbZdg9Z2mvHdabRQ/R2Up9Pft97ExpmbwuTx5Xr5rmw/iM7jiRuUFGaMo9bTl5jg9jQK/WDkUwU/JNXxwEN0ktb7RhYAyFgTKnkY5MMA25zPGmLAt2+UqLnu2KM8YY2J7zvfYdi1mi4Zj5dCHXuAvzIQQQgghhHSBG2ZCCCGEEEK6wA0zIYQQQgghXeg5h1kjn5c5jrkcHsyt5b7YOUfGoMmGlsPsuJhzaNfqdNBQQkvRSSntqlr51oMFvJ+rLt8NsQtzi6KspEeblJ3nbIzpxMoB3lZuoJZTqN1QaJuUGGOazaYoa/3uKX8yBZYpycDAANZRcsJ8Xzms3cqBa7XwMP5+Uk9dCbHpLdIAYdU+ld4YU2uWIbZ4Ae/t/LzMI9t66S6oU0idgFhUf1yUT+3DfPqxTVdDbOYU5idXKzLfupTGsdhsKGY7rhz/S2XM73USzM8sjWAuqW1q01Fy8LTcthhyXo2JQpl/dmEBdQVNZY7kixtFOQyxzhe++m2IfePbj0HszjfeLsqFG3GO9BPNbwJiau6i0t+aGYGlX1mtYE56pDw7z17D1YYqRgpYC9dG5Vrja9EYohPLd4Rm3vTW178RYsefOQaxv/5vnxXl9/3f74M62SJePz2BBk6tvOyb2TYaZzUX8R5dT+brJ5vWQp0Tyhr+SIDr2mxGbgmaF5dviWpcYo8OTzH7UnNdlUEVhXJsOBHuJxzlg52U1CgdnlGe0zNoJLJpOz6XkyePivL0ZtS92O9oY4yJE7kuZjOYt66ZAmm6L6ijfM5xcD/mKXsAJ5T1tH7X1h2lES8YO3fb6eX7FPgLMyGEEEIIIV3ghpkQQgghhJAucMNMCCGEEEJIF7hhJoQQQgghpAs9i/58RSSXscwrPEVBFionWa+urECsWZOCqVgx/3AVkZwtdksiFF55Cbah3cBYsyGzyqc37YA6p06i+KpSlbHIYDK8m8KM9XoLD07PFaQIIFH+ptHNWfB+wrYU/SWK6M/1lSFgJfPb4kFjjPHz2C7tcHjHlffdauO1+smhR9GMoD4vhV+Hj6J5RkfRLlZX0Sxjzdi0KOdTKPKoV/F51lflwffVOhqlzCzi4fgLNXyeA3n5ncUciv4KhRLEllpyvlVnFqHO8X1PQmx2FsWBy8tSmBcr42BkTDFlGEMBU2wZaaysoNAxk0ZRTNYS3oaKc9DqKvZppboKsfMLZVFerqM4qK8oa56JbcGd8jHlUprYOrJEVJU6TohKDYWA4yV7/CuCI0X0p3hsgJAnUtZF21zLGGOGx9eI8sw5FGP5Shve+tNvhtif/MVfifJv/d+/BXV++T2/ALHNRZyDWesd66/i+yFM4Tg7Pi3fU3+5hPezEuOzCNr4tK+f2iTK88tlqNNPNGOMyBIC6iI2xcwiwXq+ZaARKMK5SDlYIEpkLFIEcSfPoblPnLkAsfRgSZSX5uegztDwKMSCwDIcC1Bs6iqKu0TpB1skqQmkW8p+z3Hx/RNaexgwJDG6WZFjfc7VPtejENBeK2wReq/wF2ZCCCGEEEK6wA0zIYQQQgghXeCGmRBCCCGEkC5ww0wIIYQQQkgXfgjRH1a1neMWl1EUVK3W8HNKUn5oxUItDTzBZPtOLMUmKdSdgYjNGGPqDRSpHDsinZyiBrqYHT6MrmzNlmxXJo8Oga4iPjEG3c58S4RnCxqM0V2vwo4iELGEVY4iBHIc7LDEcsGxE+aNMSaldLQqPAxlu7LZDNTpJysXHobYzAmr33wUkKUyKKgYX4v9tHmbJeIMUPDaUkQXK1U5Dk4cKUMdz8f+Tg+gGGS9JZyLQxwr42MTENu1+QpRfmbxfqhz/vvfhNjsCRRJNltSTOcp42dozRTEYg/7fnREira2bp2GOosLKAQ8fPiwKNdquDZ5Lv6GoLlqrdTk/aw2sE/7iaOMKddaYxPl55JYdVvU3Pis9VoRUC6WsX+nJ6Qw1nXwc4my3rjKc2lbgm/teWoupWnLfXRkbAzq7H/8CYhNb56G2GvuuE2UP/2p/xe/L0TR6Ad+7p0QcyvyfTNQU953ZXS1jP2SKJ+ZwToLbRzD68bxvofScl4Or10DdfqJ5uRrv59iZe+gjR8tZovdtLGvucTF9txSti/2eDXGmNVVHBvHjh4R5YceegjqvOa2n4RYoSDdBoMAn3mi3I8as0V/yoEBUYQ3qe0xEktwGShrv+byCsakUENHWT6UTRNFf4QQQgghhLzocMNMCCGEEEJIF7hhJoQQQgghpAvcMBNCCCGEENKFnkV/rRaK5GwHuGYD3btiJVlcE5HZocBTXOkUd5bimmFRHgInKWPqNXTY2ffkUxA7aiXbryxiQn67rVgNWdgCAGN0UYyWNG87U2kCBmPwWo0mOjnZrnqOh2nzqZQiRrT+jNKcgDQcRURhj4ler/VyEQT4jF1HijNaDRRrDPjoAOW30eFu7xOPivK1N98BdcY2XAWxZmdGlNMzZ6HOwgy6Tm4ZQ6HH1rWD8nMLKAoayBUgtnG9dCPbs+cmqPPMkZMQu3B0P8Q8X469TozinXoFBZFjQ+iI9tY3/5QoX3P1lVBHE6A++ZQUcj300INQ5/z5M9iuBs6tbEYunZ4yJ/uJqwmKramnCX47ikup5+CzyrhS5Bh28P5nV3G9iSwH1zhSxJLK+0Fzml2akw5oDzyAYtPXve51eC1LWJ0v4NgvjaIgzlXW65+48ydEeWUZx89TX/kaxH5fmYP2KtDM4+u5bAnTjTHmdndBlHcqz+LRBj6Lh8q49j1hifRfcdOtUOfHEVt4ZowxmtmbpXUzrRbuaTTHOfvNF0WK412ouIEqSjZb2Lh/H66nk5PrIHblVVKkrYkaNa2btl+xG2aLAJ8zph5SIL9UcwTW2mobO2syPVUIqAgIbaEmnf4IIYQQQgh5CeCGmRBCCCGEkC5ww0wIIYQQQkgXes5h7iiHbtsxrU6vZNLSCCJIYdOySq6ZnVampRi3OpivMj4+CbGcdaD2k3ufhjpz85inauc1N9uYi+kqRinpXBHrWbk2kZLrGSnGE81mFWKdjsy/0kwCPB/7JpOzzEVCzHHS8q+1/OTYitVrmA/aT7JpzEXecpm8f89gXvBqGcfnzLxyrR2vl+VdPw118hk0XFg7dUGU08G3oM6Z4zjORkfQbKdSOSjKvmJ40m7j384njn9blLdvuRnqXHnlToidPow5d/bf5rkc5iZv3rQZYj/39rdD7OZbZF5lQ8kN3LcfNQpnzth54DheM2nFkCfEvklZc6m6jDmp/UTLLzR2XrerLP/Kx9RcRavcjrDOSg3XvI61bmQ8zTwC1yQtz3J0VJr0vOENb4A6KcV0JrLGi6sYPCwpri7lFVy7RopyHP/cT74F6txzrAyxf7jvHogVN2+VbfAxfzbKYY55w8oJ9RS90fpxNCZ60sV5E1jPMXmBuZ4vHZqhmWyjZoKh3oUy1l3bBEUZ+5qJh299LgjxGyNle6Rpw2yNV72Oa/ojjz4GsckpuafRDDy0d7RtQGcMLhXa+76j6ETU32At47hUoJhDKcZ4ifXUnBjrxMqeM1b0JIE1Jjxt7esB/sJMCCGEEEJIF7hhJoQQQgghpAvcMBNCCCGEENIFbpgJIYQQQgjpQs+Zz/UGJp6321J8FinCDN9HkULg49emLMFdNpODOsWhYYidOS8Pr19cWoY6nRaKNfxIMUHJS9OT4SE0QVlYWoRYvijb6gYo/koUk4BUFkWM9rnfWpJ+J0ShgGZc4jjyYtmc0i7l+oWibFfSQXGIfog4CiQCy3Agm81AnX4yN4d/Mw7mpWigVML7j5VxPbH9UoiNb9styqGL4yBycJzNLTwjvy9Bk4Hdu9ZA7PhpNDjZe1iKA8eHBqHODZvXQqzSkJ978J4vQ53F8yhYzGZxnC0tyWvt3LUD6rzj538RYldfcSPEVlfk+D86cxLqfPLTfwaxb33tXlHOKKtfoIiKhgZRnDsxIgVnYRP7oZ8o/gHoyqAZFriamBcvFlu/tbSU9bRcQ9GaLfrLKwKgUBUUYxtskyfN/ECL2deKFdFoXvGY2HHNlRCrnjgtyvf+/VehTpzCtq/30xDrZGUfrq8rwsMaNuyEKwXfsSIKTzL4fVXFlKNYkmuDbmrRR1QBqoxpYjc9hkF7bKgma74iKrSFqopwVdMrVldQrN8als8gm8f1dObCLMSeeEIaM23dsh3qaIYdsTLf7Fd5RzFe85SYUYyPbEFfLosi25TyPg2tNaWtzCOng2O4dArNg/wpWW4XcD70An9hJoQQQgghpAvcMBNCCCGEENIFbpgJIYQQQgjpAjfMhBBCCCGEdKFn0d/iagVi7bYU32QUtxZHEZ+kPKw3ZologhQmuqey6A42vUkmb49NoDCwrbjghU28n5UF6a6WuCiu8xSXtMSzYpi/btIZ5X4UYaNtmKW51tgOfsYY09REf1aCf6GA4iU/jcnvgeV81Y5RRDIyVMLPKa5aK+WyKOeL+Az7SXFsE8TaiRwv586j0DOjuE5W5tF578ShvxHlsY2PQp2xzVuwYSnpYDSyCZ0p6+dPQcxP49hYu1HOie0b0VFvcmoE21CWY+r0oYegyt6HzkOsHaOwsWgJY8+cRmHGyVOnIRa+EheQTE5ef2INtn37FrzHBy33UC9BAdXAAD7XXbvRzXDj9EYZuOgc0XRZrqyhiOuUmCb8iq3rh4qoebWOLlyNplxTBzPKYqmgOhf2QC+iNU3Y1eigyPaZQ09CzD0hx/9T30FHzoyyXo8qIqe11poyHmOdzgC+D5rWPZZdXIcHLFdEY4w5+zTOwdzGDaLsK06M/cRXDgyw0YSeLxRt1DnK3LLf2y3F+TJsK+LxCr63y/NlUU6n8L3tKXuoI0eOyIDiVukpz7OXOaK6fWqugYozse/Ler7S9lhRKduRjPJeSRw8RKA6NgSxbEbuO9wQr9ULF9dsIIQQQggh5CKDG2ZCCCGEEEK6wA0zIYQQQgghXeg5h7lWx1ybOJL5KlEHc11zWcyRLeQxd3doSOadpJV85cRRDE+sQ7cHh9GUwUSYixy30WjgdCLbX6tijk6zirk21dqCKHciPFR8YHgMYoVBzL1MZWXfeCn8m0bLYe60MZa1zWCUA8MHlVxkzzIbMUrukKfk4MUx5tflrEPXbSOTfjO1HXP7Wqsy97JWx3utLGG+sqskr+ccOf6Xjh+COks1HIt73ni7KE+OboQ6TyyhScnEJM6tddZcSruY91UuL0FsZWFelK/fjX117AjmQe4/WYZYkJL5mfPLmCN67z1fg9jOS6+F2G233SrKQw7qA3KKuYCx1qdOhHPGGFyvioOY1+xb+fowZ/qMZlwCeYhKDqJqZuJjzmZoVfM9vP9yHddd2wArLio6DtV1BdFyj18QSv75tqvRhGj2BGoGpnZsE+X3v/9uqPMPX/oixE4cfhpi3qQ0D3r4wl6s01DMRvJyfq96+AwrTfxcmML3qZ+xxvWL1ccvEtkMrl1hJN87Wk5uFOG7ScuHtvOfQ8XURu8SufZHym+RcYQ5/W4bx/rKony35IuYkzusmJDZRnJHjx2DOqFqNvL8ZjBa/2nXUqqBcY/2fLR8aNieaj/vKs8irQRd6/qh8ix6gb8wE0IIIYQQ0gVumAkhhBBCCOkCN8yEEEIIIYR0gRtmQgghhBBCutCz6C+jJNvH1iHVSYiJ1JowI5PGa6VSUmyjJYYHaeUgd6uelo/fURL3PaVioTgg25QrYRuyKFaKVywTlBDFj06nAbFWDa+Vzsq+iZS211bLEDNKEns+I8VKQwN4APpQCUWS9pnreUUs6CuiqtVVvB9biPAC/QdeMiamUOTVKI2Lcm5wAOoszuPzXFJiTUsd5fkojvIraNixePhhUS6G01BnfOpqiD29//sQu3BAXn8gh+Y+GzZgrFmXBi7Toyg0uePm3RCbXUGDh6UVKQDLF3DcPXPoMMT+66f+DGJHj8t6R/c/BXW+c/8/QKxZtYSaLipUVlZxgHYinM/VunzWpVEU9fYV1Wggeb4qJkmwT1SDEzukCKiqdey3OsRQ3O0obldOTz/t9Pj7j9V438X3ysJRFNR+5tOfgdhAINfrWHmxPLjvcYilFAOJ3LgU1Z4q4hw5f3oGYpePyLm74zKckweW5iFW7aAoc8STfRFfZD+pJYr5h24vItH2Ib0IAT0Px4ZuoiNjrmI4ZhJFPBthrFKX93j2OAqrA2X/klknDxFoKventT022KeRVa/RVExXFJOSUNm3gQedYiyjPR/HulbkKCJDg/uegiLIj1JynQnzL8xA7SKbDoQQQgghhFxccMNMCCGEEEJIF7hhJoQQQgghpAvcMBNCCCGEENKFnkV/g4rwqdmUwpckxMsNFNElK6c4/aXTlvhKU3koCfjGSljvKG6DS8vLEEs5mCyesxLBxzethzoLlhDKGGNcX37n3DkUjLiKM54P2fDGREYK7OrVRaizsoyxtCK6yWfl9bNpFJwlSuJ+1nIb1IQJmrpyYADHSF1xiLyYSDuY/D+2XrrqnfGU/i5gX+64fBxiKxUpQJg/fxDqODUUdSwevSDK5Qt47bWX3Ayx4TU7IOYnUgySCXDcrZtE0V91Vc7BTh3dAG+4Eh0IFzvYNw8/fl6Ut+3Gth85iYKmIyeOQ+ypfVJUGK7g/NaM9wLL+TKy1a0Gx74xxhSLOEbalmDKD3peSl8WHGWCRpYbWaLUcRQBlRsrYm7bHS/BDm8qLma1mhTyKOagJnY0YRe2NUlkn7uO8tBVtaAlRHZRqHR67iTEPv/3n4dY1JT3mE/j3Nq1Fedke7EMscfu+6YoDwXY9qCE75G5jOybqXVr8PtcfC9mV3Csd1rSETC8uAwsVYGmrRfThIqa2E3bK+iOc5IowvGZ2O6UirBNExA6ing+ZQn/NYfelYULEGs3peNwfhAdAk2Ijo/aHiCOZVvbHZyomuivbVuAGmMGh+Q9uh6ularoz1pjvFhZAzr4XMM2rldxS7ZVmQ49wV+YCSGEEEII6QI3zIQQQgghhHSBG2ZCCCGEEEK6wA0zIYQQQgghXehZqeIEiuCuYyVle5ic7ihitEjZp7uWA1oug+KJVgeTzB3LMUkVqHmoXIjtJH2FPTddj9+nuH7tfVSKjkprUHRRGkYnMDdAMVFiiRg3bxiFOpPDuyC2tIhOThNr5GeLigAzZYstDSbleyE+L83sKFTcjQYH5PUdRbTRT2Zn0J1vbFSO46iFwsXYoMBxZHIaYvmSFImGNRRrVBoo+qusSoFdJsHndGg/Oupt2HIpxIa3bRDlpx59COpUV9Blb2JcOkNm8iNQp6AISV938zaITa/bKcqT218NdXJjKGw8cRYFtH/+iU+L8pG9KMpM4hrEokSKQQIXHUezHq47nuKiaSLp7tluoctlP9FETnZEWwK12am5p6JrIF6srYhvVlblc4kTXCtBxWWM6XTwWmlr7HWU7/NcTQho1VGEgakQ32WBwbERZ+R3hjhNzeAUrvP5LLrspY6dFOXXjON8GC6hOPehJbk+HfvHvVCnrri5jXso+htMyZijvHP7iauI6VqWeC/SnP8090gHBWq+Jc5PKw7HthugMcZkrf1KvoDPvFhEp91sFseUHUspe69OHd3sZk4cEeVqhHXiUHH6UxwII6teq4lzK/Iw1tauH8l+ThQ3QGXKG9cOKo81VoKaO3JsCTUjTW3cA/yFmRBCCCGEkC5ww0wIIYQQQkgXuGEmhBBCCCGkCz3nMBcGMf81NjIXpVapQJ35JTQ7SCv5yY51qLevmZQo+UuBlR9TaeLB3EpajfFd7dZlXsvUWAlq/MSeGyE2e+6kKKcUw5Orrr0WYlqOn51YmMvgPVcraNSwtISxdEYm1AWKm0Os5BMtLcpnViwOQp0wws9FEeYFRdZB8M9/LPzLi5YfBh4UsXLAvZKvff+3vg2x2fOzorxjYwnqlEY2QaxZlfMtN4D5jOcWsA3Lc5jPmx+XeYlRC8fKzCLG3EDmPl+1/ZVQZ2hkLcTSaWzrlktkp55bXoA6jn8KYuvyaBS0ZViO49ErpqGOccoQOnr0hCh7Dj77McVUqRBgHuNgQdbrNLGd/UTNYYaYkm+orAexlu9nrcVanrO2Rswvy7zKyMVcYdtYxBhjEsVkJmfpL6pt/JyvJEdG0FpcYzWDDC2/27P6QTO1OHr0CMR2D6GpxNiI1Ah4Wcx5bTcV0wzLkKc0PgF14irm2KdzmHCdKsjvDBUjin6SyeFcTLtyP5HW5vAA9mUhr2gYLNOQfAH3PRlF9+NZec2OalyCew57/Px/HxZF7QkEo5jLbhujnD83B3U62txSxr+dd9xWcphNClumaZtsg6REyZnWVhDQFih91VHmtzeMfdNKyXWm+gIN1fgLMyGEEEIIIV3ghpkQQgghhJAucMNMCCGEEEJIF7hhJoQQQgghpAtOoqlDCCGEEEIIIcYY/sJMCCGEEEJIV7hhJoQQQgghpAvcMBNCCCGEENIFbpgJIYQQQgjpAjfMhBBCCCGEdIEbZkIIIYQQQrrADTMhhBBCCCFd4IaZEEIIIYSQLnDDTAghhBBCSBf+/0bbeQjhCoZRAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check out what's inside the training dataloader\n",
        "train_features_batch, train_labels_batch = next(iter(train_dataloader))\n",
        "train_features_batch.shape, train_labels_batch.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hxE3t1wZ7QGI",
        "outputId": "d6dbca1c-dff8-4049-9c89-e9d54c80fb67"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.Size([32, 3, 32, 32]), torch.Size([32]))"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Show a sample\n",
        "torch.manual_seed(42)\n",
        "random_idx = torch.randint(0, len(train_features_batch), size=[1]).item()\n",
        "img, label = train_features_batch[random_idx], train_labels_batch[random_idx]\n",
        "plt.imshow(img.T.squeeze(), cmap=\"gray\")\n",
        "plt.title(class_names[label])\n",
        "plt.axis(\"Off\");\n",
        "print(f\"Image size: {img.shape}\")\n",
        "print(f\"Label: {label}, label size: {label.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 463
        },
        "id": "7N5Vl8wQ9lBR",
        "outputId": "194579d5-805b-4377-997e-418f966c8c6f"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image size: torch.Size([3, 32, 32])\n",
            "Label: 8, label size: torch.Size([])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a flatten layer\n",
        "flatten_model = nn.Flatten() # all nn modules function as a model (can do a forward pass)\n",
        "\n",
        "# Get a single sample\n",
        "x = train_features_batch[0]\n",
        "\n",
        "# Flatten the sample\n",
        "output = flatten_model(x) # perform forward pass\n",
        "\n",
        "# Print out what happened\n",
        "print(f\"Shape before flattening: {x.shape} -> [color_channels, height, width]\")\n",
        "print(f\"Shape after flattening: {output.shape} -> [color_channels, height*width]\")\n",
        "\n",
        "# Try uncommenting below and see what happens\n",
        "print(x)\n",
        "print(output)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FgRfQlpI-nu2",
        "outputId": "bd64af1c-8d83-4c6b-9a48-b98e92f0d47a"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape before flattening: torch.Size([3, 32, 32]) -> [color_channels, height, width]\n",
            "Shape after flattening: torch.Size([3, 1024]) -> [color_channels, height*width]\n",
            "tensor([[[0.6627, 0.6745, 0.6745,  ..., 0.6549, 0.6353, 0.6157],\n",
            "         [0.6706, 0.6706, 0.6706,  ..., 0.6588, 0.6510, 0.6353],\n",
            "         [0.6510, 0.6353, 0.6157,  ..., 0.6471, 0.6471, 0.6314],\n",
            "         ...,\n",
            "         [0.4039, 0.4157, 0.3529,  ..., 0.3137, 0.3294, 0.3412],\n",
            "         [0.3843, 0.4157, 0.3647,  ..., 0.3216, 0.3176, 0.3255],\n",
            "         [0.3647, 0.3922, 0.3686,  ..., 0.3137, 0.3059, 0.3059]],\n",
            "\n",
            "        [[0.6431, 0.6549, 0.6549,  ..., 0.6392, 0.6157, 0.5961],\n",
            "         [0.6510, 0.6510, 0.6510,  ..., 0.6392, 0.6314, 0.6157],\n",
            "         [0.6314, 0.6157, 0.5961,  ..., 0.6275, 0.6275, 0.6118],\n",
            "         ...,\n",
            "         [0.4431, 0.4588, 0.4196,  ..., 0.3725, 0.3843, 0.3961],\n",
            "         [0.4196, 0.4549, 0.4275,  ..., 0.3765, 0.3725, 0.3804],\n",
            "         [0.4000, 0.4314, 0.4314,  ..., 0.3686, 0.3608, 0.3608]],\n",
            "\n",
            "        [[0.5686, 0.5804, 0.5804,  ..., 0.5647, 0.5412, 0.5255],\n",
            "         [0.5765, 0.5765, 0.5725,  ..., 0.5608, 0.5569, 0.5412],\n",
            "         [0.5569, 0.5412, 0.5216,  ..., 0.5529, 0.5529, 0.5373],\n",
            "         ...,\n",
            "         [0.3569, 0.3647, 0.3333,  ..., 0.2824, 0.2941, 0.3059],\n",
            "         [0.3373, 0.3647, 0.3451,  ..., 0.2863, 0.2824, 0.2902],\n",
            "         [0.3176, 0.3412, 0.3490,  ..., 0.2824, 0.2706, 0.2706]]])\n",
            "tensor([[0.6627, 0.6745, 0.6745,  ..., 0.3137, 0.3059, 0.3059],\n",
            "        [0.6431, 0.6549, 0.6549,  ..., 0.3686, 0.3608, 0.3608],\n",
            "        [0.5686, 0.5804, 0.5804,  ..., 0.2824, 0.2706, 0.2706]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup device agnostic code\n",
        "import torch\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "-Z3aGkDU-qvt",
        "outputId": "bcc8952b-4536-4c01-be17-a6bed5dd26ec"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cuda'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Επιλέγω ένα έτοιμο μοντέλο συνελικτικού Δικτύου, έτσι ώστε να επικεντρωθώ στα πειράματα για την βελτιστοποίησή του**"
      ],
      "metadata": {
        "id": "JPZY9jVX81Cq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Cifar10Model(nn.Module):\n",
        "    def __init__(self, input_channels: int, hidden_units: int, output_classes: int, learning_rate: float = 0.001, momentum: float = 0.9):\n",
        "        super(Cifar10Model, self).__init__()\n",
        "        self.block_1 = nn.Sequential(\n",
        "            nn.Conv2d(in_channels=input_channels,\n",
        "                      out_channels=hidden_units,\n",
        "                      kernel_size=3,\n",
        "                      stride=1,\n",
        "                      padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.Conv2d(in_channels=hidden_units,\n",
        "                      out_channels=hidden_units,\n",
        "                      kernel_size=3,\n",
        "                      stride=1,\n",
        "                      padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2)\n",
        "        )\n",
        "        self.block_2 = nn.Sequential(\n",
        "            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool2d(2)\n",
        "        )\n",
        "        self.classifier = nn.Sequential(\n",
        "            nn.Flatten(),\n",
        "            nn.Linear(in_features=hidden_units * 8 * 8,  # Adjusted for the downsample from max pooling\n",
        "                      out_features=output_classes)\n",
        "        )\n",
        "\n",
        "        self.learning_rate = learning_rate\n",
        "        self.momentum = momentum\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.block_1(x)\n",
        "        x = self.block_2(x)\n",
        "        x = self.classifier(x)\n",
        "        return x\n",
        "    def to(self, *args, **kwargs):\n",
        "        self = super().to(*args, **kwargs)\n",
        "        return self\n",
        "\n",
        "\n",
        "model_instance = Cifar10Model(input_channels=3, hidden_units=64, output_classes=10)\n"
      ],
      "metadata": {
        "id": "zLLDxpq28678"
      },
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# Create sample batch of random numbers with same size as image batch\n",
        "images = torch.randn(size=(32, 3, 64, 64)) # [batch_size, color_channels, height, width]\n",
        "test_image = images[0] # get a single image for testing\n",
        "print(f\"Image batch shape: {images.shape} -> [batch_size, color_channels, height, width]\")\n",
        "print(f\"Single image shape: {test_image.shape} -> [color_channels, height, width]\")\n",
        "print(f\"Single image pixel values:\\n{test_image}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dxiK9BT3-vro",
        "outputId": "e84cad39-7ba6-45a9-f218-b1ef9a148c7b"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image batch shape: torch.Size([32, 3, 64, 64]) -> [batch_size, color_channels, height, width]\n",
            "Single image shape: torch.Size([3, 64, 64]) -> [color_channels, height, width]\n",
            "Single image pixel values:\n",
            "tensor([[[ 1.9269,  1.4873,  0.9007,  ...,  1.8446, -1.1845,  1.3835],\n",
            "         [ 1.4451,  0.8564,  2.2181,  ...,  0.3399,  0.7200,  0.4114],\n",
            "         [ 1.9312,  1.0119, -1.4364,  ..., -0.5558,  0.7043,  0.7099],\n",
            "         ...,\n",
            "         [-0.5610, -0.4830,  0.4770,  ..., -0.2713, -0.9537, -0.6737],\n",
            "         [ 0.3076, -0.1277,  0.0366,  ..., -2.0060,  0.2824, -0.8111],\n",
            "         [-1.5486,  0.0485, -0.7712,  ..., -0.1403,  0.9416, -0.0118]],\n",
            "\n",
            "        [[-0.5197,  1.8524,  1.8365,  ...,  0.8935, -1.5114, -0.8515],\n",
            "         [ 2.0818,  1.0677, -1.4277,  ...,  1.6612, -2.6223, -0.4319],\n",
            "         [-0.1010, -0.4388, -1.9775,  ...,  0.2106,  0.2536, -0.7318],\n",
            "         ...,\n",
            "         [ 0.2779,  0.7342, -0.3736,  ..., -0.4601,  0.1815,  0.1850],\n",
            "         [ 0.7205, -0.2833,  0.0937,  ..., -0.1002, -2.3609,  2.2465],\n",
            "         [-1.3242, -0.1973,  0.2920,  ...,  0.5409,  0.6940,  1.8563]],\n",
            "\n",
            "        [[-0.7978,  1.0261,  1.1465,  ...,  1.2134,  0.9354, -0.0780],\n",
            "         [-1.4647, -1.9571,  0.1017,  ..., -1.9986, -0.7409,  0.7011],\n",
            "         [-1.3938,  0.8466, -1.7191,  ..., -1.1867,  0.1320,  0.3407],\n",
            "         ...,\n",
            "         [ 0.8206, -0.3745,  1.2499,  ..., -0.0676,  0.0385,  0.6335],\n",
            "         [-0.5589, -0.3393,  0.2347,  ...,  2.1181,  2.4569,  1.3083],\n",
            "         [-0.4092,  1.5199,  0.2401,  ..., -0.2558,  0.7870,  0.9924]]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# Create a convolutional layer with same dimensions as TinyVGG\n",
        "# (try changing any of the parameters and see what happens)\n",
        "conv_layer = nn.Conv2d(in_channels=3,\n",
        "                       out_channels=10,\n",
        "                       kernel_size=3,\n",
        "                       stride=1,\n",
        "                       padding=0) # also try using \"valid\" or \"same\" here\n",
        "\n",
        "# Pass the data through the convolutional layer\n",
        "conv_layer(test_image) # Note: If running PyTorch <1.11.0, this will error because of shape issues (nn.Conv.2d() expects a 4d tensor as input)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G-TCCGtY-0Je",
        "outputId": "c8bb1c67-af95-4834-9a1d-cd90dae116bf"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[ 1.5396,  0.0516,  0.6454,  ..., -0.3673,  0.8711,  0.4256],\n",
              "         [ 0.3662,  1.0114, -0.5997,  ...,  0.8983,  0.2809, -0.2741],\n",
              "         [ 1.2664, -1.4054,  0.3727,  ..., -0.3409,  1.2191, -0.0463],\n",
              "         ...,\n",
              "         [-0.1541,  0.5132, -0.3624,  ..., -0.2360, -0.4609, -0.0035],\n",
              "         [ 0.2981, -0.2432,  1.5012,  ..., -0.6289, -0.7283, -0.5767],\n",
              "         [-0.0386, -0.0781, -0.0388,  ...,  0.2842,  0.4228, -0.1802]],\n",
              "\n",
              "        [[-0.2840, -0.0319, -0.4455,  ..., -0.7956,  1.5599, -1.2449],\n",
              "         [ 0.2753, -0.1262, -0.6541,  ..., -0.2211,  0.1999, -0.8856],\n",
              "         [-0.5404, -1.5489,  0.0249,  ..., -0.5932, -1.0913, -0.3849],\n",
              "         ...,\n",
              "         [ 0.3870, -0.4064, -0.8236,  ...,  0.1734, -0.4330, -0.4951],\n",
              "         [-0.1984, -0.6386,  1.0263,  ..., -0.9401, -0.0585, -0.7833],\n",
              "         [-0.6306, -0.2052, -0.3694,  ..., -1.3248,  0.2456, -0.7134]],\n",
              "\n",
              "        [[ 0.4414,  0.5100,  0.4846,  ..., -0.8484,  0.2638,  1.1258],\n",
              "         [ 0.8117,  0.3191, -0.0157,  ...,  1.2686,  0.2319,  0.5003],\n",
              "         [ 0.3212,  0.0485, -0.2581,  ...,  0.2258,  0.2587, -0.8804],\n",
              "         ...,\n",
              "         [-0.1144, -0.1869,  0.0160,  ..., -0.8346,  0.0974,  0.8421],\n",
              "         [ 0.2941,  0.4417,  0.5866,  ..., -0.1224,  0.4814, -0.4799],\n",
              "         [ 0.6059, -0.0415, -0.2028,  ...,  0.1170,  0.2521, -0.4372]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[-0.2560, -0.0477,  0.6380,  ...,  0.6436,  0.7553, -0.7055],\n",
              "         [ 1.5595, -0.2209, -0.9486,  ..., -0.4876,  0.7754,  0.0750],\n",
              "         [-0.0797,  0.2471,  1.1300,  ...,  0.1505,  0.2354,  0.9576],\n",
              "         ...,\n",
              "         [ 1.1065,  0.6839,  1.2183,  ...,  0.3015, -0.1910, -0.1902],\n",
              "         [-0.3486, -0.7173, -0.3582,  ...,  0.4917,  0.7219,  0.1513],\n",
              "         [ 0.0119,  0.1017,  0.7839,  ..., -0.3752, -0.8127, -0.1257]],\n",
              "\n",
              "        [[ 0.3841,  1.1322,  0.1620,  ...,  0.7010,  0.0109,  0.6058],\n",
              "         [ 0.1664,  0.1873,  1.5924,  ...,  0.3733,  0.9096, -0.5399],\n",
              "         [ 0.4094, -0.0861, -0.7935,  ..., -0.1285, -0.9932, -0.3013],\n",
              "         ...,\n",
              "         [ 0.2688, -0.5630, -1.1902,  ...,  0.4493,  0.5404, -0.0103],\n",
              "         [ 0.0535,  0.4411,  0.5313,  ...,  0.0148, -1.0056,  0.3759],\n",
              "         [ 0.3031, -0.1590, -0.1316,  ..., -0.5384, -0.4271, -0.4876]],\n",
              "\n",
              "        [[-1.1865, -0.7280, -1.2331,  ..., -0.9013, -0.0542, -1.5949],\n",
              "         [-0.6345, -0.5920,  0.5326,  ..., -1.0395, -0.7963, -0.0647],\n",
              "         [-0.1132,  0.5166,  0.2569,  ...,  0.5595, -1.6881,  0.9485],\n",
              "         ...,\n",
              "         [-0.0254, -0.2669,  0.1927,  ..., -0.2917,  0.1088, -0.4807],\n",
              "         [-0.2609, -0.2328,  0.1404,  ..., -0.1325, -0.8436, -0.7524],\n",
              "         [-1.1399, -0.1751, -0.8705,  ...,  0.1589,  0.3377,  0.3493]]],\n",
              "       grad_fn=<SqueezeBackward1>)"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Add extra dimension to test image\n",
        "test_image.unsqueeze(dim=0).shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1vRZFNfG_dJR",
        "outputId": "66d89300-5883-473c-c6b2-8fb79215b625"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 3, 64, 64])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Pass test image with extra dimension through conv_layer\n",
        "conv_layer(test_image.unsqueeze(dim=0)).shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "prndUy11_h94",
        "outputId": "da925407-0ac4-44c8-83c0-fce7fc27e361"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 10, 62, 62])"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "# Create a new conv_layer with different values (try setting these to whatever you like)\n",
        "conv_layer_2 = nn.Conv2d(in_channels=3, # same number of color channels as our input image\n",
        "                         out_channels=10,\n",
        "                         kernel_size=(5, 5), # kernel is usually a square so a tuple also works\n",
        "                         stride=2,\n",
        "                         padding=0)\n",
        "\n",
        "# Pass single image through new conv_layer_2 (this calls nn.Conv2d()'s forward() method on the input)\n",
        "conv_layer_2(test_image.unsqueeze(dim=0)).shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YP9T_PaX_kM2",
        "outputId": "c493fa9c-e927-4189-be1c-3f55c0273271"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 10, 30, 30])"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check out the conv_layer_2 internal parameters\n",
        "print(conv_layer_2.state_dict())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mmuOV4m8_nF-",
        "outputId": "b218ac80-ea6c-40d1-8e99-4b1f39047220"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OrderedDict([('weight', tensor([[[[ 0.0883,  0.0958, -0.0271,  0.1061, -0.0253],\n",
            "          [ 0.0233, -0.0562,  0.0678,  0.1018, -0.0847],\n",
            "          [ 0.1004,  0.0216,  0.0853,  0.0156,  0.0557],\n",
            "          [-0.0163,  0.0890,  0.0171, -0.0539,  0.0294],\n",
            "          [-0.0532, -0.0135, -0.0469,  0.0766, -0.0911]],\n",
            "\n",
            "         [[-0.0532, -0.0326, -0.0694,  0.0109, -0.1140],\n",
            "          [ 0.1043, -0.0981,  0.0891,  0.0192, -0.0375],\n",
            "          [ 0.0714,  0.0180,  0.0933,  0.0126, -0.0364],\n",
            "          [ 0.0310, -0.0313,  0.0486,  0.1031,  0.0667],\n",
            "          [-0.0505,  0.0667,  0.0207,  0.0586, -0.0704]],\n",
            "\n",
            "         [[-0.1143, -0.0446, -0.0886,  0.0947,  0.0333],\n",
            "          [ 0.0478,  0.0365, -0.0020,  0.0904, -0.0820],\n",
            "          [ 0.0073, -0.0788,  0.0356, -0.0398,  0.0354],\n",
            "          [-0.0241,  0.0958, -0.0684, -0.0689, -0.0689],\n",
            "          [ 0.1039,  0.0385,  0.1111, -0.0953, -0.1145]]],\n",
            "\n",
            "\n",
            "        [[[-0.0903, -0.0777,  0.0468,  0.0413,  0.0959],\n",
            "          [-0.0596, -0.0787,  0.0613, -0.0467,  0.0701],\n",
            "          [-0.0274,  0.0661, -0.0897, -0.0583,  0.0352],\n",
            "          [ 0.0244, -0.0294,  0.0688,  0.0785, -0.0837],\n",
            "          [-0.0616,  0.1057, -0.0390, -0.0409, -0.1117]],\n",
            "\n",
            "         [[-0.0661,  0.0288, -0.0152, -0.0838,  0.0027],\n",
            "          [-0.0789, -0.0980, -0.0636, -0.1011, -0.0735],\n",
            "          [ 0.1154,  0.0218,  0.0356, -0.1077, -0.0758],\n",
            "          [-0.0384,  0.0181, -0.1016, -0.0498, -0.0691],\n",
            "          [ 0.0003, -0.0430, -0.0080, -0.0782, -0.0793]],\n",
            "\n",
            "         [[-0.0674, -0.0395, -0.0911,  0.0968, -0.0229],\n",
            "          [ 0.0994,  0.0360, -0.0978,  0.0799, -0.0318],\n",
            "          [-0.0443, -0.0958, -0.1148,  0.0330, -0.0252],\n",
            "          [ 0.0450, -0.0948,  0.0857, -0.0848, -0.0199],\n",
            "          [ 0.0241,  0.0596,  0.0932,  0.1052, -0.0916]]],\n",
            "\n",
            "\n",
            "        [[[ 0.0291, -0.0497, -0.0127, -0.0864,  0.1052],\n",
            "          [-0.0847,  0.0617,  0.0406,  0.0375, -0.0624],\n",
            "          [ 0.1050,  0.0254,  0.0149, -0.1018,  0.0485],\n",
            "          [-0.0173, -0.0529,  0.0992,  0.0257, -0.0639],\n",
            "          [-0.0584, -0.0055,  0.0645, -0.0295, -0.0659]],\n",
            "\n",
            "         [[-0.0395, -0.0863,  0.0412,  0.0894, -0.1087],\n",
            "          [ 0.0268,  0.0597,  0.0209, -0.0411,  0.0603],\n",
            "          [ 0.0607,  0.0432, -0.0203, -0.0306,  0.0124],\n",
            "          [-0.0204, -0.0344,  0.0738,  0.0992, -0.0114],\n",
            "          [-0.0259,  0.0017, -0.0069,  0.0278,  0.0324]],\n",
            "\n",
            "         [[-0.1049, -0.0426,  0.0972,  0.0450, -0.0057],\n",
            "          [-0.0696, -0.0706, -0.1034, -0.0376,  0.0390],\n",
            "          [ 0.0736,  0.0533, -0.1021, -0.0694, -0.0182],\n",
            "          [ 0.1117,  0.0167, -0.0299,  0.0478, -0.0440],\n",
            "          [-0.0747,  0.0843, -0.0525, -0.0231, -0.1149]]],\n",
            "\n",
            "\n",
            "        [[[ 0.0773,  0.0875,  0.0421, -0.0805, -0.1140],\n",
            "          [-0.0938,  0.0861,  0.0554,  0.0972,  0.0605],\n",
            "          [ 0.0292, -0.0011, -0.0878, -0.0989, -0.1080],\n",
            "          [ 0.0473, -0.0567, -0.0232, -0.0665, -0.0210],\n",
            "          [-0.0813, -0.0754,  0.0383, -0.0343,  0.0713]],\n",
            "\n",
            "         [[-0.0370, -0.0847, -0.0204, -0.0560, -0.0353],\n",
            "          [-0.1099,  0.0646, -0.0804,  0.0580,  0.0524],\n",
            "          [ 0.0825, -0.0886,  0.0830, -0.0546,  0.0428],\n",
            "          [ 0.1084, -0.0163, -0.0009, -0.0266, -0.0964],\n",
            "          [ 0.0554, -0.1146,  0.0717,  0.0864,  0.1092]],\n",
            "\n",
            "         [[-0.0272, -0.0949,  0.0260,  0.0638, -0.1149],\n",
            "          [-0.0262, -0.0692, -0.0101, -0.0568, -0.0472],\n",
            "          [-0.0367, -0.1097,  0.0947,  0.0968, -0.0181],\n",
            "          [-0.0131, -0.0471, -0.1043, -0.1124,  0.0429],\n",
            "          [-0.0634, -0.0742, -0.0090, -0.0385, -0.0374]]],\n",
            "\n",
            "\n",
            "        [[[ 0.0037, -0.0245, -0.0398, -0.0553, -0.0940],\n",
            "          [ 0.0968, -0.0462,  0.0306, -0.0401,  0.0094],\n",
            "          [ 0.1077,  0.0532, -0.1001,  0.0458,  0.1096],\n",
            "          [ 0.0304,  0.0774,  0.1138, -0.0177,  0.0240],\n",
            "          [-0.0803, -0.0238,  0.0855,  0.0592, -0.0731]],\n",
            "\n",
            "         [[-0.0926, -0.0789, -0.1140, -0.0891, -0.0286],\n",
            "          [ 0.0779,  0.0193, -0.0878, -0.0926,  0.0574],\n",
            "          [-0.0859, -0.0142,  0.0554, -0.0534, -0.0126],\n",
            "          [-0.0101, -0.0273, -0.0585, -0.1029, -0.0933],\n",
            "          [-0.0618,  0.1115, -0.0558, -0.0775,  0.0280]],\n",
            "\n",
            "         [[ 0.0318,  0.0633,  0.0878,  0.0643, -0.1145],\n",
            "          [ 0.0102,  0.0699, -0.0107, -0.0680,  0.1101],\n",
            "          [-0.0432, -0.0657, -0.1041,  0.0052,  0.0512],\n",
            "          [ 0.0256,  0.0228, -0.0876, -0.1078,  0.0020],\n",
            "          [ 0.1053,  0.0666, -0.0672, -0.0150, -0.0851]]],\n",
            "\n",
            "\n",
            "        [[[-0.0557,  0.0209,  0.0629,  0.0957, -0.1060],\n",
            "          [ 0.0772, -0.0814,  0.0432,  0.0977,  0.0016],\n",
            "          [ 0.1051, -0.0984, -0.0441,  0.0673, -0.0252],\n",
            "          [-0.0236, -0.0481,  0.0796,  0.0566,  0.0370],\n",
            "          [-0.0649, -0.0937,  0.0125,  0.0342, -0.0533]],\n",
            "\n",
            "         [[-0.0323,  0.0780,  0.0092,  0.0052, -0.0284],\n",
            "          [-0.1046, -0.1086, -0.0552, -0.0587,  0.0360],\n",
            "          [-0.0336, -0.0452,  0.1101,  0.0402,  0.0823],\n",
            "          [-0.0559, -0.0472,  0.0424, -0.0769, -0.0755],\n",
            "          [-0.0056, -0.0422, -0.0866,  0.0685,  0.0929]],\n",
            "\n",
            "         [[ 0.0187, -0.0201, -0.1070, -0.0421,  0.0294],\n",
            "          [ 0.0544, -0.0146, -0.0457,  0.0643, -0.0920],\n",
            "          [ 0.0730, -0.0448,  0.0018, -0.0228,  0.0140],\n",
            "          [-0.0349,  0.0840, -0.0030,  0.0901,  0.1110],\n",
            "          [-0.0563, -0.0842,  0.0926,  0.0905, -0.0882]]],\n",
            "\n",
            "\n",
            "        [[[-0.0089, -0.1139, -0.0945,  0.0223,  0.0307],\n",
            "          [ 0.0245, -0.0314,  0.1065,  0.0165, -0.0681],\n",
            "          [-0.0065,  0.0277,  0.0404, -0.0816,  0.0433],\n",
            "          [-0.0590, -0.0959, -0.0631,  0.1114,  0.0987],\n",
            "          [ 0.1034,  0.0678,  0.0872, -0.0155, -0.0635]],\n",
            "\n",
            "         [[ 0.0577, -0.0598, -0.0779, -0.0369,  0.0242],\n",
            "          [ 0.0594, -0.0448, -0.0680,  0.0156, -0.0681],\n",
            "          [-0.0752,  0.0602, -0.0194,  0.1055,  0.1123],\n",
            "          [ 0.0345,  0.0397,  0.0266,  0.0018, -0.0084],\n",
            "          [ 0.0016,  0.0431,  0.1074, -0.0299, -0.0488]],\n",
            "\n",
            "         [[-0.0280, -0.0558,  0.0196,  0.0862,  0.0903],\n",
            "          [ 0.0530, -0.0850, -0.0620, -0.0254, -0.0213],\n",
            "          [ 0.0095, -0.1060,  0.0359, -0.0881, -0.0731],\n",
            "          [-0.0960,  0.1006, -0.1093,  0.0871, -0.0039],\n",
            "          [-0.0134,  0.0722, -0.0107,  0.0724,  0.0835]]],\n",
            "\n",
            "\n",
            "        [[[-0.1003,  0.0444,  0.0218,  0.0248,  0.0169],\n",
            "          [ 0.0316, -0.0555, -0.0148,  0.1097,  0.0776],\n",
            "          [-0.0043, -0.1086,  0.0051, -0.0786,  0.0939],\n",
            "          [-0.0701, -0.0083, -0.0256,  0.0205,  0.1087],\n",
            "          [ 0.0110,  0.0669,  0.0896,  0.0932, -0.0399]],\n",
            "\n",
            "         [[-0.0258,  0.0556, -0.0315,  0.0541, -0.0252],\n",
            "          [-0.0783,  0.0470,  0.0177,  0.0515,  0.1147],\n",
            "          [ 0.0788,  0.1095,  0.0062, -0.0993, -0.0810],\n",
            "          [-0.0717, -0.1018, -0.0579, -0.1063, -0.1065],\n",
            "          [-0.0690, -0.1138, -0.0709,  0.0440,  0.0963]],\n",
            "\n",
            "         [[-0.0343, -0.0336,  0.0617, -0.0570, -0.0546],\n",
            "          [ 0.0711, -0.1006,  0.0141,  0.1020,  0.0198],\n",
            "          [ 0.0314, -0.0672, -0.0016,  0.0063,  0.0283],\n",
            "          [ 0.0449,  0.1003, -0.0881,  0.0035, -0.0577],\n",
            "          [-0.0913, -0.0092, -0.1016,  0.0806,  0.0134]]],\n",
            "\n",
            "\n",
            "        [[[-0.0622,  0.0603, -0.1093, -0.0447, -0.0225],\n",
            "          [-0.0981, -0.0734, -0.0188,  0.0876,  0.1115],\n",
            "          [ 0.0735, -0.0689, -0.0755,  0.1008,  0.0408],\n",
            "          [ 0.0031,  0.0156, -0.0928, -0.0386,  0.1112],\n",
            "          [-0.0285, -0.0058, -0.0959, -0.0646, -0.0024]],\n",
            "\n",
            "         [[-0.0717, -0.0143,  0.0470, -0.1130,  0.0343],\n",
            "          [-0.0763, -0.0564,  0.0443,  0.0918, -0.0316],\n",
            "          [-0.0474, -0.1044, -0.0595, -0.1011, -0.0264],\n",
            "          [ 0.0236, -0.1082,  0.1008,  0.0724, -0.1130],\n",
            "          [-0.0552,  0.0377, -0.0237, -0.0126, -0.0521]],\n",
            "\n",
            "         [[ 0.0927, -0.0645,  0.0958,  0.0075,  0.0232],\n",
            "          [ 0.0901, -0.0190, -0.0657, -0.0187,  0.0937],\n",
            "          [-0.0857,  0.0262, -0.1135,  0.0605,  0.0427],\n",
            "          [ 0.0049,  0.0496,  0.0001,  0.0639, -0.0914],\n",
            "          [-0.0170,  0.0512,  0.1150,  0.0588, -0.0840]]],\n",
            "\n",
            "\n",
            "        [[[ 0.0888, -0.0257, -0.0247, -0.1050, -0.0182],\n",
            "          [ 0.0817,  0.0161, -0.0673,  0.0355, -0.0370],\n",
            "          [ 0.1054, -0.1002, -0.0365, -0.1115, -0.0455],\n",
            "          [ 0.0364,  0.1112,  0.0194,  0.1132,  0.0226],\n",
            "          [ 0.0667,  0.0926,  0.0965, -0.0646,  0.1062]],\n",
            "\n",
            "         [[ 0.0699, -0.0540, -0.0551, -0.0969,  0.0290],\n",
            "          [-0.0936,  0.0488,  0.0365, -0.1003,  0.0315],\n",
            "          [-0.0094,  0.0527,  0.0663, -0.1148,  0.1059],\n",
            "          [ 0.0968,  0.0459, -0.1055, -0.0412, -0.0335],\n",
            "          [-0.0297,  0.0651,  0.0420,  0.0915, -0.0432]],\n",
            "\n",
            "         [[ 0.0389,  0.0411, -0.0961, -0.1120, -0.0599],\n",
            "          [ 0.0790, -0.1087, -0.1005,  0.0647,  0.0623],\n",
            "          [ 0.0950, -0.0872, -0.0845,  0.0592,  0.1004],\n",
            "          [ 0.0691,  0.0181,  0.0381,  0.1096, -0.0745],\n",
            "          [-0.0524,  0.0808, -0.0790, -0.0637,  0.0843]]]])), ('bias', tensor([ 0.0364,  0.0373, -0.0489, -0.0016,  0.1057, -0.0693,  0.0009,  0.0549,\n",
            "        -0.0797,  0.1121]))])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get shapes of weight and bias tensors within conv_layer_2\n",
        "print(f\"conv_layer_2 weight shape: \\n{conv_layer_2.weight.shape} -> [out_channels=10, in_channels=3, kernel_size=5, kernel_size=5]\")\n",
        "print(f\"\\nconv_layer_2 bias shape: \\n{conv_layer_2.bias.shape} -> [out_channels=10]\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r9Sdm7hQ_vm8",
        "outputId": "ffbcca21-c57f-4f7c-8b0d-1ab6fa501f32"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "conv_layer_2 weight shape: \n",
            "torch.Size([10, 3, 5, 5]) -> [out_channels=10, in_channels=3, kernel_size=5, kernel_size=5]\n",
            "\n",
            "conv_layer_2 bias shape: \n",
            "torch.Size([10]) -> [out_channels=10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print out original image shape without and with unsqueezed dimension\n",
        "print(f\"Test image original shape: {test_image.shape}\")\n",
        "print(f\"Test image with unsqueezed dimension: {test_image.unsqueeze(dim=0).shape}\")\n",
        "\n",
        "# Create a sample nn.MaxPoo2d() layer\n",
        "max_pool_layer = nn.MaxPool2d(kernel_size=2)\n",
        "\n",
        "# Pass data through just the conv_layer\n",
        "test_image_through_conv = conv_layer(test_image.unsqueeze(dim=0))\n",
        "print(f\"Shape after going through conv_layer(): {test_image_through_conv.shape}\")\n",
        "\n",
        "# Pass data through the max pool layer\n",
        "test_image_through_conv_and_max_pool = max_pool_layer(test_image_through_conv)\n",
        "print(f\"Shape after going through conv_layer() and max_pool_layer(): {test_image_through_conv_and_max_pool.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dWr6g7_C_wfX",
        "outputId": "79657ba7-adc6-47ed-e189-35fe20a8a058"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test image original shape: torch.Size([3, 64, 64])\n",
            "Test image with unsqueezed dimension: torch.Size([1, 3, 64, 64])\n",
            "Shape after going through conv_layer(): torch.Size([1, 10, 62, 62])\n",
            "Shape after going through conv_layer() and max_pool_layer(): torch.Size([1, 10, 31, 31])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "# Create a random tensor with a similiar number of dimensions to our images\n",
        "random_tensor = torch.randn(size=(1, 1, 2, 2))\n",
        "print(f\"Random tensor:\\n{random_tensor}\")\n",
        "print(f\"Random tensor shape: {random_tensor.shape}\")\n",
        "\n",
        "# Create a max pool layer\n",
        "max_pool_layer = nn.MaxPool2d(kernel_size=2) # see what happens when you change the kernel_size value\n",
        "\n",
        "# Pass the random tensor through the max pool layer\n",
        "max_pool_tensor = max_pool_layer(random_tensor)\n",
        "print(f\"\\nMax pool tensor:\\n{max_pool_tensor} <- this is the maximum value from random_tensor\")\n",
        "print(f\"Max pool tensor shape: {max_pool_tensor.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4qHYiTfm_zep",
        "outputId": "0f1e1e4d-56d6-4eaa-d8b2-5584f67c20a6"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Random tensor:\n",
            "tensor([[[[0.3367, 0.1288],\n",
            "          [0.2345, 0.2303]]]])\n",
            "Random tensor shape: torch.Size([1, 1, 2, 2])\n",
            "\n",
            "Max pool tensor:\n",
            "tensor([[[[0.3367]]]]) <- this is the maximum value from random_tensor\n",
            "Max pool tensor shape: torch.Size([1, 1, 1, 1])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup loss and optimizer\n",
        "\n",
        "loss_fn = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.SGD(params=model.parameters(),\n",
        "                             lr=0.1)"
      ],
      "metadata": {
        "id": "Fl-eehYS__3J"
      },
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# Measure time\n",
        "\n",
        "train_time_start_model = timer()\n",
        "\n",
        "# Train and test model\n",
        "epochs = 10\n",
        "for epoch in tqdm(range(epochs)):\n",
        "    print(f\"Epoch: {epoch}\\n---------\")\n",
        "    train_step(data_loader=train_dataloader,\n",
        "        model=model,\n",
        "        loss_fn=loss_fn,\n",
        "        optimizer=optimizer,\n",
        "        accuracy_fn=accuracy_fn,\n",
        "        device=device\n",
        "    )\n",
        "    test_step(data_loader=test_dataloader,\n",
        "        model=model,\n",
        "        loss_fn=loss_fn,\n",
        "        accuracy_fn=accuracy_fn,\n",
        "        device=device\n",
        "    )\n",
        "\n",
        "train_time_end_model = timer()\n",
        "total_train_time_model = print_train_time(start=train_time_start_model,\n",
        "                                           end=train_time_end_model,\n",
        "                                           device=device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 934,
          "referenced_widgets": [
            "f0850e4ba881459da7089010152ed54f",
            "c93c0686ca884d7899905bb1f6738d18",
            "2b748e1170d84e0e98ac8ef48c175269",
            "f76c3c30799b427e9f97782ddeeaf229",
            "07280a8ca74a4274a926e34822559f29",
            "a2144ce3ce854a4989496aa98acba76d",
            "4fced3fe9c794c62a34a5adb5748ff55",
            "30e92f95d9de4f5ca7f46355030173c7",
            "6f62000e9b6543b3b5732608b54216e1",
            "3e8a1cbfad7243f993ecec03c6f7478b",
            "73d145d56ca045beb43bd109df92b10c"
          ]
        },
        "id": "EExXudrSGprC",
        "outputId": "f16bf024-6408-45e3-d3d7-900c0fae8e08"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/10 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "f0850e4ba881459da7089010152ed54f"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0\n",
            "---------\n",
            "Train loss: 1.88464 | Train accuracy: 31.09%\n",
            "Test loss: 1.55359 | Test accuracy: 43.51%\n",
            "\n",
            "Epoch: 1\n",
            "---------\n",
            "Train loss: 1.24854 | Train accuracy: 55.41%\n",
            "Test loss: 1.27484 | Test accuracy: 53.43%\n",
            "\n",
            "Epoch: 2\n",
            "---------\n",
            "Train loss: 0.99306 | Train accuracy: 65.29%\n",
            "Test loss: 0.98357 | Test accuracy: 65.55%\n",
            "\n",
            "Epoch: 3\n",
            "---------\n",
            "Train loss: 0.83976 | Train accuracy: 71.06%\n",
            "Test loss: 0.89442 | Test accuracy: 69.23%\n",
            "\n",
            "Epoch: 4\n",
            "---------\n",
            "Train loss: 0.74402 | Train accuracy: 74.12%\n",
            "Test loss: 0.90380 | Test accuracy: 69.23%\n",
            "\n",
            "Epoch: 5\n",
            "---------\n",
            "Train loss: 0.66891 | Train accuracy: 76.76%\n",
            "Test loss: 0.82877 | Test accuracy: 72.30%\n",
            "\n",
            "Epoch: 6\n",
            "---------\n",
            "Train loss: 0.60482 | Train accuracy: 79.05%\n",
            "Test loss: 0.97336 | Test accuracy: 68.55%\n",
            "\n",
            "Epoch: 7\n",
            "---------\n",
            "Train loss: 0.55964 | Train accuracy: 80.49%\n",
            "Test loss: 0.95783 | Test accuracy: 69.47%\n",
            "\n",
            "Epoch: 8\n",
            "---------\n",
            "Train loss: 0.52366 | Train accuracy: 81.65%\n",
            "Test loss: 1.07861 | Test accuracy: 66.49%\n",
            "\n",
            "Epoch: 9\n",
            "---------\n",
            "Train loss: 0.49124 | Train accuracy: 82.75%\n",
            "Test loss: 1.05929 | Test accuracy: 68.18%\n",
            "\n",
            "Train time on cuda: 141.079 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get model results\n",
        "from pyexpat import model\n",
        "\n",
        "\n",
        "model_results = eval_model(\n",
        "    model=model_instance,\n",
        "    data_loader=test_dataloader,\n",
        "    loss_fn=loss_fn,\n",
        "    accuracy_fn=accuracy_fn\n",
        ")\n",
        "model_results"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i5pC0S0NGqyJ",
        "outputId": "4752f8d3-92a3-4013-9cae-f0b23a8a0158"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'model_name': 'Cifar10Model',\n",
              " 'model_loss': 2.3025572299957275,\n",
              " 'model_acc': 10.553115015974441}"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Σε αυτό το σημείο βλέπω πως το υπάρχον μοντέλο δεν έχει σε καμία περίπτωση τις επιθυμητές αποδόσεις. Επιχειρώ να**"
      ],
      "metadata": {
        "id": "es5JYU2FJvHU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a function to create the model for KerasClassifier\n",
        "def create_model(learning_rate=0.001, momentum=0.9):\n",
        "    net = Cifar10Model()\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=momentum)\n",
        "    return net, criterion, optimizer\n"
      ],
      "metadata": {
        "id": "l68zHobNHSkX"
      },
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Define the hyperparameter grid\n",
        "param_grid = {\n",
        "    'module__hidden_units': [10, 20, 30],  # Adjust as needed\n",
        "    'module__learning_rate': [0.001, 0.01, 0.1],\n",
        "    'module__momentum': [0.9, 0.95, 0.99]\n",
        "}\n",
        "\n",
        "# Define the scoring functions\n",
        "scoring = {\n",
        "    'accuracy': make_scorer(accuracy_score),\n",
        "    'precision': make_scorer(precision_score, average='weighted'),\n",
        "    'recall': make_scorer(recall_score, average='weighted'),\n",
        "    'f1': make_scorer(f1_score, average='weighted')\n",
        "}\n",
        "\n",
        "# Convert PyTorch tensors to NumPy arrays\n",
        "X_train = np.array([data[0].numpy() for data in train_data])\n",
        "y_train = np.array([data[1] for data in train_data])\n",
        "\n",
        "# Convert y_train to torch.long\n",
        "y_train = torch.from_numpy(y_train).long()\n",
        "\n",
        "# Create the KerasClassifier\n",
        "net = NeuralNetClassifier(\n",
        "    module=Cifar10Model,\n",
        "    module__input_channels=3,  # Adjust as needed\n",
        "    module__hidden_units=10,  # Initial value, will be tuned\n",
        "    module__output_classes=len(class_names),  # Adjust as needed\n",
        "    module__learning_rate=0.001,  # Initial value, will be tuned\n",
        "    module__momentum=0.9,  # Initial value, will be tuned\n",
        "    iterator_train__shuffle=True,\n",
        "    max_epochs=10,\n",
        "    train_split=None,\n",
        "    callbacks=[\n",
        "        ('accuracy', EpochScoring(scoring['accuracy'], lower_is_better=False)),\n",
        "        ('precision', EpochScoring(scoring['precision'], lower_is_better=False)),\n",
        "        ('recall', EpochScoring(scoring['recall'], lower_is_better=False)),\n",
        "        ('f1', EpochScoring(scoring['f1'], lower_is_better=False)),\n",
        "    ],\n",
        "    verbose=0\n",
        ")\n",
        "# Create the GridSearchCV object\n",
        "grid_search = GridSearchCV(net, param_grid, scoring=None, cv=3, refit='accuracy', n_jobs=-1)\n",
        "\n",
        "# Fit the model to the data\n",
        "grid_search.fit(X_train, y_train)\n",
        "\n",
        "# Print the best parameters and their metrics\n",
        "print(\"Best parameters found: \", grid_search.best_params_)\n",
        "print(\"Best metrics found:\")\n",
        "for metric, value in grid_search.best_score_.items():\n",
        "    print(f\"{metric}: {value}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        },
        "id": "39KeLvpSKFPN",
        "outputId": "e43d7dd4-b8f6-4704-94bb-6ae15666f3a6"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-66-622e83cc92e9>\u001b[0m in \u001b[0;36m<cell line: 46>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     44\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m \u001b[0;31m# Fit the model to the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 46\u001b[0;31m \u001b[0mgrid_search\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     47\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     48\u001b[0m \u001b[0;31m# Print the best parameters and their metrics\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/model_selection/_search.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, groups, **fit_params)\u001b[0m\n\u001b[1;32m    872\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    873\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 874\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_search\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevaluate_candidates\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    875\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    876\u001b[0m             \u001b[0;31m# multimetric is determined here because in the case of a callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/model_selection/_search.py\u001b[0m in \u001b[0;36m_run_search\u001b[0;34m(self, evaluate_candidates)\u001b[0m\n\u001b[1;32m   1386\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_run_search\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevaluate_candidates\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1387\u001b[0m         \u001b[0;34m\"\"\"Search all candidates in param_grid\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1388\u001b[0;31m         \u001b[0mevaluate_candidates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mParameterGrid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparam_grid\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1389\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1390\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/model_selection/_search.py\u001b[0m in \u001b[0;36mevaluate_candidates\u001b[0;34m(candidate_params, cv, more_results)\u001b[0m\n\u001b[1;32m    819\u001b[0m                     )\n\u001b[1;32m    820\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 821\u001b[0;31m                 out = parallel(\n\u001b[0m\u001b[1;32m    822\u001b[0m                     delayed(_fit_and_score)(\n\u001b[1;32m    823\u001b[0m                         \u001b[0mclone\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbase_estimator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/sklearn/utils/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m     61\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mdelayed_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m         )\n\u001b[0;32m---> 63\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterable_with_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     64\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1950\u001b[0m         \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1951\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1952\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0moutput\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreturn_generator\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1953\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1954\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__repr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m_get_outputs\u001b[0;34m(self, iterator, pre_dispatch)\u001b[0m\n\u001b[1;32m   1593\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1594\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mretrieval_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1595\u001b[0;31m                 \u001b[0;32myield\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_retrieve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1596\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1597\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mGeneratorExit\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m_retrieve\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1705\u001b[0m                 (self._jobs[0].get_status(\n\u001b[1;32m   1706\u001b[0m                     timeout=self.timeout) == TASK_PENDING)):\n\u001b[0;32m-> 1707\u001b[0;31m                 \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.01\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1708\u001b[0m                 \u001b[0;32mcontinue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1709\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    }
  ]
}