{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pytorch tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal of this tutorial is to very quickly present pytorch, the main deep learning framework nowadays, to students with already some experience in tensorflow/keras. \n",
    "\n",
    "We will train a small fully-connected network on MNIST and observe what happens when the inputs or outputs are correlated, by training successively on the 0 digits, then the 1s, etc. This will explain why correlated inputs are a problem for neural networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installing Pytorch\n",
    "\n",
    "Like tensorflow / keras, Pytorch provides a lot of ready-made layer types, activation functions, optimizers and so on. Do not hesitate to read its documentation on <https://pytorch.org/docs/stable/index.html>.\n",
    "\n",
    "The first step is to install pytorch if you are not on colab (where it is installed by default). The easiest way is to use pip:\n",
    "    \n",
    "```bash\n",
    "pip install torch torchvision\n",
    "```\n",
    "\n",
    "`torchvision` is necessary if you want to deal with images, such as the MNIST dataset.\n",
    "\n",
    "`torch` is now available for importing. There is quite a lot to import, so let's just copy and paste:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device: mps\n"
     ]
    }
   ],
   "source": [
    "# Imports\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import TensorDataset, DataLoader, Subset\n",
    "from torchvision import datasets, transforms\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Select hardware: \n",
    "if torch.cuda.is_available(): # GPU\n",
    "    device = torch.device(\"cuda\")\n",
    "elif torch.backends.mps.is_available(): # Metal (Macos)\n",
    "    device = torch.device(\"mps\")\n",
    "else: # CPU\n",
    "    device = torch.device(\"cpu\")\n",
    "print(f\"Device: {device}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random data\n",
    "\n",
    "Let's train a MLP on some dummy data. To show the (overfitting) power of deep neural networks, we will try to learn noise by heart. The following cell creates 1000 random samples of dimension 10, artificially ordered in 3 classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 1000\n",
    "nb_features = 10\n",
    "nb_classes = 3\n",
    "\n",
    "X = np.random.uniform(-1.0, 1.0, (N, nb_features))\n",
    "t = np.random.randint(0, nb_classes, (N, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start by splitting this data in training / validation sets using scikit-learn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, t_train, t_test = train_test_split(X, t, test_size=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The four numpy arrays have to be converted to torch tensors. The inputs are `float32` (32 bits) numbers, while the classes are integers (`long`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_tensor = torch.tensor(X_train, dtype=torch.float32)\n",
    "t_train_tensor = torch.tensor(t_train, dtype=torch.long)\n",
    "X_test_tensor = torch.tensor(X_test, dtype=torch.float32)\n",
    "t_test_tensor = torch.tensor(t_test, dtype=torch.long)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using these four tensors, we can now create datasets (`TensorDataset`) and data loaders (`DataLoader`) allowing to sample minibatches very easily. Note that you have to define the batch size at the time of creation of the data loaders. It cannot be changed later unless you create new ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create TensorDatasets for both train and test sets\n",
    "train_dataset = TensorDataset(X_train_tensor, t_train_tensor)\n",
    "test_dataset = TensorDataset(X_test_tensor, t_test_tensor)\n",
    "\n",
    "# Create DataLoaders for train and test sets\n",
    "batch_size = 32\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now is time to create a MLP in pytorch. The standard way of creating a neural network is to create a class inheriting from `torch.nn.module`. \n",
    "\n",
    "There are only two methods that need to be defined:\n",
    "\n",
    "1. The constructor `__init__(self, ...)` that instantiates the layers. Do not forget the first line with `super()`, it is super important. The first argument `MLP` should be replaced with the name of the class if you change it. The layers are created in the constructor and saved as attributes to the class (`self.fc1`). The order does not matter.\n",
    "2. The forward method `forward(self, x)`that defines how the input `x` will be processed, and in which order the layers will be called.\n",
    "\n",
    "The following class defines a MLP with two hidden layers, and the ReLU activation function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLP(torch.nn.Module):\n",
    "    \"MLP with two hidden layers.\"\n",
    "\n",
    "    def __init__(self, nb_features, nb_layer1, nb_layer2, nb_classes):\n",
    "        super(MLP, self).__init__() # Obligatory, do not forget\n",
    "\n",
    "        # Layers\n",
    "        self.fc1 = torch.nn.Linear(nb_features, nb_layer1)\n",
    "        self.fc2 = torch.nn.Linear(nb_layer1, nb_layer2)\n",
    "        self.output = torch.nn.Linear(nb_layer2, nb_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.output(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`torch.nn.Linear(N, M)` creates a fully-connected layer between a layer of size `N` and a layer of size `M`.\n",
    "\n",
    "There is more than one way to create this network. For example, the ReLU non-linearity does not have to come from the functional module `F`, but could be a layer of its own:\n",
    "\n",
    "```python\n",
    "class MLP(torch.nn.Module):\n",
    "    \"MLP with two hidden layers.\"\n",
    "\n",
    "    def __init__(self, nb_features, nb_layer1, nb_layer2, nb_classes):\n",
    "        super(MLP, self).__init__() # Obligatory, do not forget\n",
    "\n",
    "        # Layers\n",
    "        self.fc1 = torch.nn.Linear(nb_features, nb_layer1)\n",
    "        self.fc2 = torch.nn.Linear(nb_layer1, nb_layer2)\n",
    "        self.output = torch.nn.Linear(nb_layer2, nb_classes)\n",
    "\n",
    "        # Activations\n",
    "        self.relu = torch.nn.ReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.output(x)\n",
    "        return x\n",
    "```\n",
    "\n",
    "Note that it would be much closer to `keras` and much shorter to use the `Sequential` model, but for some reason (reusability, etc) it is not recommended:\n",
    "\n",
    "```python\n",
    "model = torch.nn.Sequential(\n",
    "    torch.nn.Linear(nb_features, nb_layer1),  \n",
    "    torch.nn.ReLU(), \n",
    "    torch.nn.Linear(nb_layer1, nb_layer2),  \n",
    "    torch.nn.ReLU(), \n",
    "    torch.nn.Linear(nb_layer2, nb_classes)\n",
    ")\n",
    "```\n",
    "\n",
    "Contrary to tensorflow/keras, there is no need to create an input layer explicitly, as the input tensor is passed as the argument `x` in `def forward(self, x)`.\n",
    "\n",
    "Note that the output layer does not use a softmax activation function, although we are doing a classification. The cross-entropy loss function that we will define later expects logits as an input, not probabilities, so we just keep the numbers as they are."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another big difference with `keras`is that there is no `model.fit()` method that trains the model for you. You have to define the whole training procedure by yourself. The equivalent of an high-level keras API would be **pytorch lightning** (<https://lightning.ai/>) or **pytorch ignite** (<https://pytorch.org/ignite>).\n",
    "\n",
    "Here, we will define a `train()` method applying backpropagation and the optimizer on each minibatch. Skipping some details, the pseudo-algorithm would be something like this:\n",
    "\n",
    "```python\n",
    "# Create the neural network\n",
    "model = MLP(nb_features, nb_layer1, nb_layer2, nb_classes)\n",
    "\n",
    "# Select the optimizer, e.g. Adam\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
    "\n",
    "# Select the loss function, here cross-entropy as we do a classification\n",
    "loss_function = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "# Iterate over the minibatches contained in the loader\n",
    "for batch_idx, (data, target) in enumerate(train_loader):\n",
    "\n",
    "    # Reinitialize the gradients (important!)\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # Forward pass\n",
    "    y = model(X)\n",
    "\n",
    "    # Compute the loss function on the minibatch\n",
    "    loss = loss_function(y, t)\n",
    "    \n",
    "    # Backpropagate the gradients\n",
    "    loss.backward()\n",
    "    \n",
    "    # Apply the optimizer on the gradients\n",
    "    optimizer.step()\n",
    "```\n",
    "\n",
    "We also need to send the data to the GPU if needed, compute the metrics (loss and accuracy), etc. The following function is quite generic and can be reused in many networks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, device, train_loader, optimizer, loss_function):\n",
    "    \n",
    "    # Tell pytorch to start training, i.e. to remember gradients, enable dropout, etc.\n",
    "    model.train()\n",
    "\n",
    "    # Initialize metrics\n",
    "    training_loss = 0\n",
    "    correct = 0 ; total = 0\n",
    "    \n",
    "    # Iterate over the minibatches\n",
    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
    "    \n",
    "        # Send the data to the device\n",
    "        data, target = data.to(device), target.to(device)\n",
    "    \n",
    "        # Reinitialize the gradients\n",
    "        optimizer.zero_grad()\n",
    "    \n",
    "        # Make the forward pass\n",
    "        output = model(data)\n",
    "    \n",
    "        # Compute the loss function on the minibatch\n",
    "        loss = loss_function(output, target)\n",
    "\n",
    "        # Accumulate training loss. data.size(0) is the batch size.\n",
    "        training_loss += loss.item() * data.size(0)\n",
    "    \n",
    "        # Backpropagate the gradients\n",
    "        loss.backward()\n",
    "    \n",
    "        # Apply the optimizer on the gradients\n",
    "        optimizer.step()\n",
    "    \n",
    "        # Compute metrics\n",
    "        pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability\n",
    "        total += target.size(0)\n",
    "        correct += pred.eq(target.view_as(pred)).sum().item()\n",
    "    \n",
    "    # Info\n",
    "    training_loss /= len(train_loader.dataset)\n",
    "    accuracy = 100 * correct / total\n",
    "    print(f'Training loss {training_loss:.4f}, accuracy {accuracy:.4f}')\n",
    "\n",
    "    return training_loss, accuracy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function does a similar function on the validation set, but does NOT apply backpropagation. `model.eval()` and `with torch.no_grad():` make sure that the gradients are not computed, speeding up the computations (also dropout and batchnorm are switched off)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate(model, device, test_loader, loss_function):\n",
    "\n",
    "    # Evaluation mode, without the gradients\n",
    "    model.eval()\n",
    "\n",
    "    # Initialize metrics\n",
    "    test_loss = 0\n",
    "    correct = 0; total = 0\n",
    "\n",
    "    # Important! No backpropagation when testing.\n",
    "    with torch.no_grad():\n",
    "\n",
    "        # Iterate over the minibatches\n",
    "        for data, target in test_loader:\n",
    "\n",
    "            # Send the data to the device\n",
    "            data, target = data.to(device), target.to(device)\n",
    "\n",
    "            # Make the forward pass\n",
    "            output = model(data)\n",
    "\n",
    "            # Compute the loss function on the minibatch\n",
    "            test_loss += loss_function(output, target).item() * data.size(0)\n",
    "\n",
    "            # Compute metrics\n",
    "            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability\n",
    "            total += target.size(0)\n",
    "            correct += pred.eq(target.view_as(pred)).sum().item()\n",
    "    \n",
    "    # Info\n",
    "    test_loss /= len(test_loader.dataset)\n",
    "    accuracy = 100 * correct / total\n",
    "    print(f'Validation loss: {test_loss:.4f}, accuracy: {accuracy:.4f}')\n",
    "\n",
    "    return test_loss, accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can create the neural network (with two hidden layers of 100 neurons each), the Adam optimizer with a fixed learning rate and the cross-entropy loss. Note again that `torch.nn.CrossEntropyLoss()` expects the network to output logits, not probabilities.\n",
    "\n",
    "It is important to **send** the network to the device (GPU, TPU, etc) after creating an instance of the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the model\n",
    "model = MLP(nb_features, 100, 100, nb_classes).to(device)\n",
    "\n",
    "# Optimizer\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
    "\n",
    "# Loss function\n",
    "loss_function = torch.nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** Train the model for 50 epochs, by calling repeatedly the `train()` and `validate()` methods. Record and plot the training/validation losses and accuracies, and plot them. Comment on the final accuracies on the training and test sets, and what this means in terms of overfitting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1\n",
      "Training loss 1.1055, accuracy 34.6667\n",
      "Validation loss: 1.0964, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 2\n",
      "Training loss 1.0907, accuracy 40.3333\n",
      "Validation loss: 1.0941, accuracy: 39.0000\n",
      "------------------------------\n",
      "Epoch: 3\n",
      "Training loss 1.0784, accuracy 40.7778\n",
      "Validation loss: 1.1034, accuracy: 42.0000\n",
      "------------------------------\n",
      "Epoch: 4\n",
      "Training loss 1.0584, accuracy 43.2222\n",
      "Validation loss: 1.1462, accuracy: 36.0000\n",
      "------------------------------\n",
      "Epoch: 5\n",
      "Training loss 1.0423, accuracy 44.8889\n",
      "Validation loss: 1.1389, accuracy: 31.0000\n",
      "------------------------------\n",
      "Epoch: 6\n",
      "Training loss 1.0099, accuracy 48.5556\n",
      "Validation loss: 1.1941, accuracy: 30.0000\n",
      "------------------------------\n",
      "Epoch: 7\n",
      "Training loss 0.9948, accuracy 50.5556\n",
      "Validation loss: 1.1785, accuracy: 31.0000\n",
      "------------------------------\n",
      "Epoch: 8\n",
      "Training loss 0.9852, accuracy 51.8889\n",
      "Validation loss: 1.2804, accuracy: 30.0000\n",
      "------------------------------\n",
      "Epoch: 9\n",
      "Training loss 0.9565, accuracy 51.0000\n",
      "Validation loss: 1.2593, accuracy: 32.0000\n",
      "------------------------------\n",
      "Epoch: 10\n",
      "Training loss 0.9345, accuracy 53.8889\n",
      "Validation loss: 1.2260, accuracy: 34.0000\n",
      "------------------------------\n",
      "Epoch: 11\n",
      "Training loss 0.8977, accuracy 57.0000\n",
      "Validation loss: 1.3809, accuracy: 40.0000\n",
      "------------------------------\n",
      "Epoch: 12\n",
      "Training loss 0.8690, accuracy 59.5556\n",
      "Validation loss: 1.3564, accuracy: 39.0000\n",
      "------------------------------\n",
      "Epoch: 13\n",
      "Training loss 0.8330, accuracy 60.0000\n",
      "Validation loss: 1.2849, accuracy: 41.0000\n",
      "------------------------------\n",
      "Epoch: 14\n",
      "Training loss 0.7771, accuracy 63.3333\n",
      "Validation loss: 1.5084, accuracy: 36.0000\n",
      "------------------------------\n",
      "Epoch: 15\n",
      "Training loss 0.7264, accuracy 65.5556\n",
      "Validation loss: 1.5501, accuracy: 40.0000\n",
      "------------------------------\n",
      "Epoch: 16\n",
      "Training loss 0.7222, accuracy 67.5556\n",
      "Validation loss: 1.5811, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 17\n",
      "Training loss 0.6414, accuracy 72.0000\n",
      "Validation loss: 1.7553, accuracy: 39.0000\n",
      "------------------------------\n",
      "Epoch: 18\n",
      "Training loss 0.6592, accuracy 71.5556\n",
      "Validation loss: 1.7342, accuracy: 36.0000\n",
      "------------------------------\n",
      "Epoch: 19\n",
      "Training loss 0.5931, accuracy 74.8889\n",
      "Validation loss: 1.9607, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 20\n",
      "Training loss 0.5110, accuracy 79.5556\n",
      "Validation loss: 1.9841, accuracy: 40.0000\n",
      "------------------------------\n",
      "Epoch: 21\n",
      "Training loss 0.5248, accuracy 79.4444\n",
      "Validation loss: 2.2092, accuracy: 36.0000\n",
      "------------------------------\n",
      "Epoch: 22\n",
      "Training loss 0.4959, accuracy 79.3333\n",
      "Validation loss: 2.2976, accuracy: 34.0000\n",
      "------------------------------\n",
      "Epoch: 23\n",
      "Training loss 0.4526, accuracy 83.3333\n",
      "Validation loss: 2.4661, accuracy: 36.0000\n",
      "------------------------------\n",
      "Epoch: 24\n",
      "Training loss 0.4183, accuracy 82.5556\n",
      "Validation loss: 2.5979, accuracy: 34.0000\n",
      "------------------------------\n",
      "Epoch: 25\n",
      "Training loss 0.3557, accuracy 87.0000\n",
      "Validation loss: 2.4773, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 26\n",
      "Training loss 0.3363, accuracy 88.5556\n",
      "Validation loss: 2.6867, accuracy: 34.0000\n",
      "------------------------------\n",
      "Epoch: 27\n",
      "Training loss 0.2912, accuracy 90.3333\n",
      "Validation loss: 2.8239, accuracy: 37.0000\n",
      "------------------------------\n",
      "Epoch: 28\n",
      "Training loss 0.2521, accuracy 91.5556\n",
      "Validation loss: 2.8978, accuracy: 37.0000\n",
      "------------------------------\n",
      "Epoch: 29\n",
      "Training loss 0.2019, accuracy 93.8889\n",
      "Validation loss: 3.3692, accuracy: 35.0000\n",
      "------------------------------\n",
      "Epoch: 30\n",
      "Training loss 0.1780, accuracy 95.3333\n",
      "Validation loss: 3.3565, accuracy: 32.0000\n",
      "------------------------------\n",
      "Epoch: 31\n",
      "Training loss 0.2206, accuracy 92.4444\n",
      "Validation loss: 3.5362, accuracy: 36.0000\n",
      "------------------------------\n",
      "Epoch: 32\n",
      "Training loss 0.2107, accuracy 93.3333\n",
      "Validation loss: 3.8159, accuracy: 39.0000\n",
      "------------------------------\n",
      "Epoch: 33\n",
      "Training loss 0.2043, accuracy 92.2222\n",
      "Validation loss: 3.7950, accuracy: 32.0000\n",
      "------------------------------\n",
      "Epoch: 34\n",
      "Training loss 0.2347, accuracy 92.0000\n",
      "Validation loss: 3.7059, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 35\n",
      "Training loss 0.1886, accuracy 93.7778\n",
      "Validation loss: 3.8443, accuracy: 36.0000\n",
      "------------------------------\n",
      "Epoch: 36\n",
      "Training loss 0.1232, accuracy 97.1111\n",
      "Validation loss: 3.9547, accuracy: 34.0000\n",
      "------------------------------\n",
      "Epoch: 37\n",
      "Training loss 0.1396, accuracy 96.3333\n",
      "Validation loss: 3.8313, accuracy: 37.0000\n",
      "------------------------------\n",
      "Epoch: 38\n",
      "Training loss 0.0965, accuracy 98.3333\n",
      "Validation loss: 4.3278, accuracy: 35.0000\n",
      "------------------------------\n",
      "Epoch: 39\n",
      "Training loss 0.0718, accuracy 98.3333\n",
      "Validation loss: 4.3182, accuracy: 37.0000\n",
      "------------------------------\n",
      "Epoch: 40\n",
      "Training loss 0.0455, accuracy 99.6667\n",
      "Validation loss: 4.4293, accuracy: 35.0000\n",
      "------------------------------\n",
      "Epoch: 41\n",
      "Training loss 0.0341, accuracy 99.6667\n",
      "Validation loss: 4.6197, accuracy: 36.0000\n",
      "------------------------------\n",
      "Epoch: 42\n",
      "Training loss 0.0247, accuracy 99.8889\n",
      "Validation loss: 4.7609, accuracy: 36.0000\n",
      "------------------------------\n",
      "Epoch: 43\n",
      "Training loss 0.0209, accuracy 99.8889\n",
      "Validation loss: 4.7736, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 44\n",
      "Training loss 0.0168, accuracy 99.8889\n",
      "Validation loss: 4.9289, accuracy: 37.0000\n",
      "------------------------------\n",
      "Epoch: 45\n",
      "Training loss 0.0198, accuracy 99.6667\n",
      "Validation loss: 4.8742, accuracy: 40.0000\n",
      "------------------------------\n",
      "Epoch: 46\n",
      "Training loss 0.0158, accuracy 99.8889\n",
      "Validation loss: 5.0379, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 47\n",
      "Training loss 0.0123, accuracy 99.8889\n",
      "Validation loss: 5.1073, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 48\n",
      "Training loss 0.0103, accuracy 99.8889\n",
      "Validation loss: 5.2024, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 49\n",
      "Training loss 0.0092, accuracy 99.8889\n",
      "Validation loss: 5.2690, accuracy: 38.0000\n",
      "------------------------------\n",
      "Epoch: 50\n",
      "Training loss 0.0084, accuracy 99.8889\n",
      "Validation loss: 5.3432, accuracy: 38.0000\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Recording arrays\n",
    "train_losses = [] ; train_accs = []\n",
    "val_losses = [] ; val_accs = []\n",
    "\n",
    "# 50 epochs of training and validation\n",
    "for epoch in range(50):\n",
    "\n",
    "    print(f\"Epoch: {epoch+1}\")\n",
    "\n",
    "    # Train \n",
    "    train_loss, train_acc = train(model, device, train_loader, optimizer, loss_function)\n",
    "\n",
    "    # Validation\n",
    "    val_loss, val_acc = validate(model, device, test_loader, loss_function)\n",
    "\n",
    "    print('-'*30)\n",
    "\n",
    "    train_losses.append(train_loss); train_accs.append(train_acc)\n",
    "    val_losses.append(val_loss); val_accs.append(val_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x158351820>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8gAAAIQCAYAAABdSEf0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC3NklEQVR4nOzdd3hUZd7G8e+k94SQDgFCDb1XAQFRREQQsC0qiopr20VfV2UVFRv2tZe1wKogigp2EJEmvRdpAQIJpJPey5z3jwPBSA0kOZPk/lzXXHPmtLknaM788jzneWyGYRiIiIiIiIiI1HNOVgcQERERERERcQQqkEVERERERERQgSwiIiIiIiICqEAWERERERERAVQgi4iIiIiIiAAqkEVEREREREQAFcgiIiIiIiIigApkEREREREREUAFsoiIiIiIiAigAllEREREREQEUIEsYpmZM2dis9nYsGGD1VFERETkL9555x1sNhu9e/e2OoqI1CAVyCIiIiIifzFr1iyaNWvGunXr2Ldvn9VxRKSGqEAWEREREfmT2NhYVq1axauvvkpwcDCzZs2yOtIp5eXlWR1BpM5RgSziwDZv3szw4cPx8/PDx8eHSy65hDVr1lTYp6SkhGnTptGqVSs8PDxo2LAh/fv3Z9GiReX7JCUlceutt9K4cWPc3d0JDw9n1KhRHDx4sIY/kYiIiOObNWsWDRo0YMSIEYwbN+6UBXJmZib3338/zZo1w93dncaNG3PzzTeTlpZWvk9hYSFPPvkkrVu3xsPDg/DwcMaMGcP+/fsBWLp0KTabjaVLl1Y498GDB7HZbMycObN83S233IKPjw/79+/niiuuwNfXl/HjxwOwYsUKrrnmGpo0aYK7uzuRkZHcf//9FBQUnJR79+7dXHvttQQHB+Pp6UmbNm149NFHAViyZAk2m4158+addNzs2bOx2WysXr260j9PkdrExeoAInJqf/zxBwMGDMDPz4+HHnoIV1dX3n//fQYNGsSyZcvK74l68sknmT59Orfffju9evUiOzubDRs2sGnTJi699FIAxo4dyx9//MF9991Hs2bNSElJYdGiRcTFxdGsWTMLP6WIiIjjmTVrFmPGjMHNzY0bbriBd999l/Xr19OzZ08AcnNzGTBgALt27WLixIl069aNtLQ0vvvuOw4fPkxQUBBlZWVceeWVLF68mOuvv55//vOf5OTksGjRInbs2EGLFi0qnau0tJRhw4bRv39/Xn75Zby8vACYO3cu+fn53HXXXTRs2JB169bx5ptvcvjwYebOnVt+/LZt2xgwYACurq5MmjSJZs2asX//fr7//nueffZZBg0aRGRkJLNmzeLqq68+6WfSokUL+vbtewE/WZFawBARS8yYMcMAjPXr159y++jRow03Nzdj//795esSEhIMX19fY+DAgeXrOnfubIwYMeK075ORkWEAxksvvVR14UVEROqoDRs2GICxaNEiwzAMw263G40bNzb++c9/lu/z+OOPG4DxzTffnHS83W43DMMwPv74YwMwXn311dPus2TJEgMwlixZUmF7bGysARgzZswoXzdhwgQDMB555JGTzpefn3/SuunTpxs2m804dOhQ+bqBAwcavr6+Fdb9OY9hGMaUKVMMd3d3IzMzs3xdSkqK4eLiYjzxxBMnvY9IXaMu1iIOqKysjF9++YXRo0fTvHnz8vXh4eH87W9/4/fffyc7OxuAgIAA/vjjD2JiYk55Lk9PT9zc3Fi6dCkZGRk1kl9ERKS2mjVrFqGhoQwePBgAm83Gddddx5w5cygrKwPg66+/pnPnzie1sh7f//g+QUFB3Hfffafd53zcddddJ63z9PQsX87LyyMtLY1+/fphGAabN28GIDU1leXLlzNx4kSaNGly2jw333wzRUVFfPXVV+XrvvjiC0pLS7nxxhvPO7dIbaECWcQBpaamkp+fT5s2bU7a1rZtW+x2O/Hx8QA89dRTZGZm0rp1azp27Mi//vUvtm3bVr6/u7s7L7zwAj///DOhoaEMHDiQF198kaSkpBr7PCIiIrVBWVkZc+bMYfDgwcTGxrJv3z727dtH7969SU5OZvHixQDs37+fDh06nPFc+/fvp02bNri4VN0djS4uLjRu3Pik9XFxcdxyyy0EBgbi4+NDcHAwF198MQBZWVkAHDhwAOCsuaOjo+nZs2eF+65nzZpFnz59aNmyZVV9FBGHpQJZpJYbOHAg+/fv5+OPP6ZDhw58+OGHdOvWjQ8//LB8n8mTJ7N3716mT5+Oh4cHU6dOpW3btuV/VRYRERH47bffSExMZM6cObRq1ar8ce211wJU+WjWp2tJPt5S/Vfu7u44OTmdtO+ll17Kjz/+yMMPP8z8+fNZtGhR+QBfdru90rluvvlmli1bxuHDh9m/fz9r1qxR67HUGxqkS8QBBQcH4+XlxZ49e07atnv3bpycnIiMjCxfFxgYyK233sqtt95Kbm4uAwcO5Mknn+T2228v36dFixb83//9H//3f/9HTEwMXbp04ZVXXuGzzz6rkc8kIiLi6GbNmkVISAhvv/32Sdu++eYb5s2bx3vvvUeLFi3YsWPHGc/VokUL1q5dS0lJCa6urqfcp0GDBoA5IvafHTp06Jwzb9++nb179/K///2Pm2++uXz9n2ezAMpv2TpbboDrr7+eBx54gM8//5yCggJcXV257rrrzjmTSG2mFmQRB+Ts7Mxll13Gt99+W2EqpuTkZGbPnk3//v3x8/MD4OjRoxWO9fHxoWXLlhQVFQGQn59PYWFhhX1atGiBr69v+T4iIiL1XUFBAd988w1XXnkl48aNO+lx7733kpOTw3fffcfYsWPZunXrKadDMgwDMGeQSEtL46233jrtPk2bNsXZ2Znly5dX2P7OO++cc25nZ+cK5zy+/Prrr1fYLzg4mIEDB/Lxxx8TFxd3yjzHBQUFMXz4cD777DNmzZrF5ZdfTlBQ0DlnEqnN1IIsYrGPP/6YBQsWnLT+ySefZNGiRfTv35+7774bFxcX3n//fYqKinjxxRfL92vXrh2DBg2ie/fuBAYGsmHDBr766ivuvfdeAPbu3csll1zCtddeS7t27XBxcWHevHkkJydz/fXX19jnFBERcWTfffcdOTk5XHXVVafc3qdPH4KDg5k1axazZ8/mq6++4pprrmHixIl0796d9PR0vvvuO9577z06d+7MzTffzCeffMIDDzzAunXrGDBgAHl5efz666/cfffdjBo1Cn9/f6655hrefPNNbDYbLVq04IcffiAlJeWcc0dHR9OiRQsefPBBjhw5gp+fH19//fUpB+Z844036N+/P926dWPSpElERUVx8OBBfvzxR7Zs2VJh35tvvplx48YB8PTTT5/7D1KktrNyCG2R+uz4NE+ne8THxxubNm0yhg0bZvj4+BheXl7G4MGDjVWrVlU4zzPPPGP06tXLCAgIMDw9PY3o6Gjj2WefNYqLiw3DMIy0tDTjnnvuMaKjow1vb2/D39/f6N27t/Hll19a8bFFREQc0siRIw0PDw8jLy/vtPvccssthqurq5GWlmYcPXrUuPfee41GjRoZbm5uRuPGjY0JEyYYaWlp5fvn5+cbjz76qBEVFWW4uroaYWFhxrhx4ypM4ZiammqMHTvW8PLyMho0aGDceeedxo4dO045zZO3t/cpc+3cudMYOnSo4ePjYwQFBRl33HGHsXXr1pPOYRiGsWPHDuPqq682AgICDA8PD6NNmzbG1KlTTzpnUVGR0aBBA8Pf398oKCg4x5+iSO1nM4y/9KkQEREREZF6rbS0lIiICEaOHMlHH31kdRyRGqN7kEVEREREpIL58+eTmppaYeAvkfpALcgiIiIiIgLA2rVr2bZtG08//TRBQUFs2rTJ6kgiNUotyCIiIiIiAsC7777LXXfdRUhICJ988onVcURqnFqQRURERERERFALsoiIiIiIiAigAllEREREREQEAJeafkO73U5CQgK+vr7YbLaafnsREZEKDMMgJyeHiIgInJz0d+OqoGu9iIg4mnO93td4gZyQkEBkZGRNv62IiMgZxcfH07hxY6tj1Am61ouIiKM62/W+xgtkX19fwAzm5+dX028vIiJSQXZ2NpGRkeXXJ7lwutaLiIijOdfrfY0XyMe7Wvn5+emiKSIiDkNdgauOrvUiIuKozna9181WIiIiIiIiIqhAFhEREREREQFUIIuIiIiIiIgAFtyDfC7sdjvFxcVWx5Aq4ubmpqlTRETkJGVlZZSUlFgdQ6qAq6srzs7OVscQEblgDlcgFxcXExsbi91utzqKVBEnJyeioqJwc3OzOoqIiDgAwzBISkoiMzPT6ihShQICAggLC9OAdyJSqzlUgWwYBomJiTg7OxMZGalWxzrAbreTkJBAYmIiTZo00UVTRETKi+OQkBC8vLx0bajlDMMgPz+flJQUAMLDwy1OJCJy/hyqQC4tLSU/P5+IiAi8vLysjiNVJDg4mISEBEpLS3F1dbU6joiIWKisrKy8OG7YsKHVcaSKeHp6ApCSkkJISIi6W4tIreVQTbRlZWUA6opbxxz/9zz+7ysiIvXX8XuO9Yfwuuf4v6nuKxeR2syhCuTj1NWqbtG/p4iI/JWuDXWP/k1FpC5wyAJZREREREREpKapQHZQzZo147XXXjvn/ZcuXYrNZtOIoCIiIrWErvUiIo5HBfIFstlsZ3w8+eST53Xe9evXM2nSpHPev1+/fiQmJuLv739e7yciIiKnpmu9iEj94VCjWNdGiYmJ5ctffPEFjz/+OHv27Clf5+PjU75sGAZlZWW4uJz9xx4cHFypHG5uboSFhVXqGBERETk7XetFROoPtSBfoLCwsPKHv78/Nput/PXu3bvx9fXl559/pnv37ri7u/P777+zf/9+Ro0aRWhoKD4+PvTs2ZNff/21wnn/2u3KZrPx4YcfcvXVV+Pl5UWrVq347rvvyrf/tdvVzJkzCQgIYOHChbRt2xYfHx8uv/zyChf50tJS/vGPfxAQEEDDhg15+OGHmTBhAqNHj67OH5mIiFST5cuXM3LkSCIiIrDZbMyfP7/CdsMwePzxxwkPD8fT05OhQ4cSExNTYZ/09HTGjx+Pn58fAQEB3HbbbeTm5tbgp3A8utaLiNQfDl0gG4ZBfnGpJQ/DMKrsczzyyCM8//zz7Nq1i06dOpGbm8sVV1zB4sWL2bx5M5dffjkjR44kLi7ujOeZNm0a1157Ldu2beOKK65g/PjxpKenn3b//Px8Xn75ZT799FOWL19OXFwcDz74YPn2F154gVmzZjFjxgxWrlxJdnb2SV+mRESk9sjLy6Nz5868/fbbp9z+4osv8sYbb/Dee++xdu1avL29GTZsGIWFheX7jB8/nj/++INFixbxww8/sHz58kp1A64sXesr0rVeRMRaDt3FuqCkjHaPL7TkvXc+NQwvt6r58Tz11FNceuml5a8DAwPp3Llz+eunn36aefPm8d1333Hvvfee9jy33HILN9xwAwDPPfccb7zxBuvWrePyyy8/5f4lJSW89957tGjRAoB7772Xp556qnz7m2++yZQpU7j66qsBeOutt/jpp5/O/4OKiIilhg8fzvDhw0+5zTAMXnvtNR577DFGjRoFwCeffEJoaCjz58/n+uuvZ9euXSxYsID169fTo0cPwLxWXHHFFbz88stERERUeWZd6yvStV5ExFoO3YJcVxz/knFcbm4uDz74IG3btiUgIAAfHx927dp11r8qd+rUqXzZ29sbPz8/UlJSTru/l5dX+QUTIDw8vHz/rKwskpOT6dWrV/l2Z2dnunfvXqnPJiJimZICqxPUKrGxsSQlJTF06NDydf7+/vTu3ZvVq1cDsHr1agICAipct4YOHYqTkxNr166t8cy1ia71IiJ1g0O3IHu6OrPzqWGWvXdV8fb2rvD6wQcfZNGiRbz88su0bNkST09Pxo0bR3Fx8RnP4+rqWuG1zWbDbrdXav+q7E4mImKJ0iL4ZSrEr4HbFoGLu9WJaoWkpCQAQkNDK6wPDQ0t35aUlERISEiF7S4uLgQGBpbvcypFRUUUFRWVv87Ozj7nXLrWV6RrvYik5xWzJymHmJQc9iTlcCA1j5Ky0/8eOBs3FydaBPvQOtSH1qG+tA71pYG32yn3LSwp40BqHnuTc9iTnENMcg6Z+SXn/d5VYWL/KK7oGF5j7+fQBbLNZquyrk+OZOXKldxyyy3l3Z1yc3M5ePBgjWbw9/cnNDSU9evXM3DgQADKysrYtGkTXbp0qdEsIiLn7Oh++OpWSNxqvt73K0SPsDaTMH36dKZNm3Zex+paX310rRdxDBsOprP9SNZpt9sNiE/PZ29yDnuTc0nLLTrtvudr1f6jFV4H+7rTJtSXVqE++Li7EJOcy96UHA6m5WF3sL+xXdmp5opjcPACua5q1aoV33zzDSNHjsRmszF16tQz/nW4utx3331Mnz6dli1bEh0dzZtvvklGRgY2m63Gs4iInNWOb+C7f0BxDngGwtXvQWtrWh5ro+PTAyUnJxMefuLLRnJycnmxFBYWdlJ33tLSUtLT0884vdCUKVN44IEHyl9nZ2cTGRlZhelrH13rRQRg1tpDPDpvR6WPiwz0pHWIL63DfGkZ7IO3+/n3eMktKiMmJYeY5Fz2JOVwJLOA1JwiUnOK+H1f2kn7+3m40CbMt7y1OcTXHSt/ZbQN96vR91OBbIFXX32ViRMn0q9fP4KCgnj44Ycr1R2tqjz88MMkJSVx88034+zszKRJkxg2bBjOzlXX5UxE5IKVFMCCKbBxhvm6SV8Y+xH4N7I2Vy0TFRVFWFgYixcvLi+Is7OzWbt2LXfddRcAffv2JTMzk40bN5bfp/rbb79ht9vp3bv3ac/t7u6Ou7u6uv+ZrvUi8uX6+PLi+KKWDWngdepuzQBhfh60PlaUtgrxwdu9+sq03KJSYpJzzG7USbnkF5fSMsTsft0m7HhBXH//iGYzavhGlezsbPz9/cnKysLPr+JfAwoLC4mNjSUqKgoPD4+ajCWA3W6nbdu2XHvttTz99NNVdl79u4rIeUuLgbm3QPIOwAYDHoBB/wbnqvvicKbrUm2Tm5vLvn37AOjatSuvvvoqgwcPJjAwkCZNmvDCCy/w/PPP87///Y+oqCimTp3Ktm3b2LlzZ/nv5+HDh5OcnMx7771HSUkJt956Kz169GD27NnnnEPXesdVXdd60L+tyJ99vfEwD361FcOAWy9qxuNXtqvXRacjONfrvVqQ67FDhw7xyy+/cPHFF1NUVMRbb71FbGwsf/vb36yOJiICW7+AH+6HkjzwCoIx/4WWl1idyqFt2LCBwYMHl78+3u15woQJzJw5k4ceeoi8vDwmTZpEZmYm/fv3Z8GCBRWKmVmzZnHvvfdyySWX4OTkxNixY3njjTdq/LNI1dC1XqTmfbvlCP86Vhzf1KepiuNaRgVyPebk5MTMmTN58MEHMQyDDh068Ouvv9K2bVuro4lIfVaQCQsega2fm6+bDYCxH4Lv6e+BFdOgQYPOOIKxzWbjqaeeqjBP7l8FBgZWqrVYHJuu9SI168dtiTzw5VbsBtzQK5JpV7VXcVzLqECuxyIjI1m5cqXVMURETtj7C3z/D8hJBGxw8cNw8UPgpPslRc6HrvUiNWfhH0n8c85myuwG47o35tnRHXFyUnFc26hAFhER6xVkwsJ/w5ZZ5uvAFjD6HWjSx9JYIiIi52LxrmTunb2JUrvB6C4RvDC2k4rjWkoFsoiIWCtmkTl9U04CYIM+d8OQx8DNy+pkIiIiHM7IZ+me1NPewpJdWMrrv8ZQUmZwZadwXr6mM84qjmstFcgiImKNwiyz1XjzZ+brwOYw6h1o2tfaXCIiIscUFJcx/sO1HDqaf9Z9L28fxn+u64KLs1MNJJPqogJZRERqXtwa+GoiZB/BbDW+C4ZMVauxiIg4lFd+2cOho/kE+bjRKyrwtPu1CvHlnsEtcVVxXOupQBYRkZq1bzHMGQ+lBcdajd+Gpv2sTiUiIlLB5rgMPl4ZC8BL4zozODrE4kRSE1Qgi4hIzdn9I8y9BcqKoeWlcO3/wM3b6lQiIiIVFJWW8dBX27AbcHXXRiqO6xH1AXAAgwYNYvLkyeWvmzVrxmuvvXbGY2w2G/Pnz7/g966q84iInNX2r+CLm8ziuO1VcP1sFcdSb+haL1K7vP3bPmJScgnycePxK9tZHUdqkArkCzRy5Eguv/zyU25bsWIFNpuNbdu2Veqc69evZ9KkSVURr9yTTz5Jly5dTlqfmJjI8OHDq/S9REROsukT+Pp2MMqg0/Uwbga4uFmdSuSc6FovUr/sTMjmnaX7AZh2VQcaeOt6VZ+oQL5At912G4sWLeLw4cMnbZsxYwY9evSgU6dOlTpncHAwXl41M1BNWFgY7u7uNfJeIlJPrXkPvrsPMKDHRBj9LjjrDh+pPXStF6n9TjdF01+Vltl5+OttlNoNhrUP5YqOYdWcTByNCuQLdOWVVxIcHMzMmTMrrM/NzWXu3LmMHj2aG264gUaNGuHl5UXHjh35/PPPz3jOv3a7iomJYeDAgXh4eNCuXTsWLVp00jEPP/wwrVu3xsvLi+bNmzN16lRKSkoAmDlzJtOmTWPr1q3YbDZsNlt53r92u9q+fTtDhgzB09OThg0bMmnSJHJzc8u333LLLYwePZqXX36Z8PBwGjZsyD333FP+XiIiFax4BRY8bC73vRdGvApOuvRI7aJrva71Urv9HpNG28cXcNvM9Rw6mnfGfT9YEcv2I1n4ebjw9KgO2Gyaz7i+cew/4RsGlJx9zrFq4eoF5/A/hIuLCzfffDMzZ87k0UcfLf+faO7cuZSVlXHjjTcyd+5cHn74Yfz8/Pjxxx+56aabaNGiBb169Trr+e12O2PGjCE0NJS1a9eSlZVV4R6m43x9fZk5cyYRERFs376dO+64A19fXx566CGuu+46duzYwYIFC/j1118B8Pf3P+kceXl5DBs2jL59+7J+/XpSUlK4/fbbuffeeyt8KViyZAnh4eEsWbKEffv2cd1119GlSxfuuOOOs34eEaknDAN+e9oskAEufhgGTTmn36tSz+har2u9SDV7a0kMhSV2Fu9OYcW+NP4+sDl3DWqJp5tzhf32p+byn1/3AjD1ynaE+HlYEVcs5tgFckk+PBdhzXv/O+GcB4+ZOHEiL730EsuWLWPQoEGA2eVq7NixNG3alAcffLB83/vuu4+FCxfy5ZdfntNF89dff2X37t0sXLiQiAjzZ/Hcc8+ddC/RY489Vr7crFkzHnzwQebMmcNDDz2Ep6cnPj4+uLi4EBZ2+m4is2fPprCwkE8++QRvb/Ozv/XWW4wcOZIXXniB0NBQABo0aMBbb72Fs7Mz0dHRjBgxgsWLF+uiKSKm/HT4YTLs/NZ8PXQa9J9sZSJxZLrW61ovUo1i0/JYcyAdmw16NQtkbWw6b/y2j683HeHxke24rF0oNpsNu93gka+3UVxqZ2DrYMZ1b2x1dLGI+rlVgejoaPr168fHH38MwL59+1ixYgW33XYbZWVlPP3003Ts2JHAwEB8fHxYuHAhcXFx53TuXbt2ERkZWX7BBOjbt+9J+33xxRdcdNFFhIWF4ePjw2OPPXbO7/Hn9+rcuXP5BRPgoosuwm63s2fPnvJ17du3x9n5xF/cwsPDSUlJqdR7iUgdFfMrvNPXLI6dXGDEKyqOpU7QtV7XeqmdvtwQD8DFrYOZM6kP74zvRoS/B0cyC7jz041MmLGeA6m5fLrmEOsPZuDt5sxzV6trdX3m2C3Irl7mX3eteu9KuO2227jvvvt4++23mTFjBi1atODiiy/mhRde4PXXX+e1116jY8eOeHt7M3nyZIqLi6ss6urVqxk/fjzTpk1j2LBh+Pv7M2fOHF555ZUqe48/c3V1rfDa/KubvVreS0RqieJ8WPQ4rP/AfB3UGsb8FyK6WptLHJ+u9edE13qRyisps/PVRnNwvet7RmKz2biiYziD2gTzzpL9/Hf5AZbvTWXYa8txdjIL4keGR9O4Qc0MoCeOybELZJut1syRee211/LPf/6T2bNn88knn3DXXXdhs9lYuXIlo0aN4sYbbwTM+4z27t1Lu3bnNp9a27ZtiY+PJzExkfDwcADWrFlTYZ9Vq1bRtGlTHn300fJ1hw4dqrCPm5sbZWVlZ32vmTNnkpeXV/6X5ZUrV+Lk5ESbNm3OKa+I1ENHNsE3k+BojPm6150w9Elw0xcMOQe61utaL1JNftudQmpOEUE+bgyJDi1f7+XmwoPD2jC2e2Omff8HS/ekUlJm0CsqkPG9m1qYWByBulhXER8fH6677jqmTJlCYmIit9xyCwCtWrVi0aJFrFq1il27dnHnnXeSnJx8zucdOnQorVu3ZsKECWzdupUVK1ZUuDgef4+4uDjmzJnD/v37eeONN5g3b16FfZo1a0ZsbCxbtmwhLS2NoqKik95r/PjxeHh4MGHCBHbs2MGSJUu47777uOmmm8rvSRIRKVdWCstego8uNYtjnzC48Wu44kUVx1In6VovUrt8sd7sXj22e2PcXE4ue6KCvJlxS08+vLkHN/ZpwuvXd8HJSV2r67tKFchPPvlk+dQBxx/R0dHVla3Wue2228jIyGDYsGHl9xE99thjdOvWjWHDhjFo0CDCwsIYPXr0OZ/TycmJefPmUVBQQK9evbj99tt59tlnK+xz1VVXcf/993PvvffSpUsXVq1axdSpUyvsM3bsWC6//HIGDx5McHDwKaef8PLyYuHChaSnp9OzZ0/GjRvHJZdcwltvvVX5H4aI1G0FmTDzCljyDNhLod1ouHs1tBxqdTKRaqVrvUjtkJhVwNI95n3z1/WIPO1+NpuNoe1CeWZ0R8L9PWsqnjgwm3Gus2ZjFshfffVV+fQBYE59EBQUdM5vmJ2djb+/P1lZWfj5+VXYVlhYSGxsLFFRUXh4aFj1ukL/riJ10PeTYeMMcPeDK16CTtfV2imcznRdkvOja339pH9bcSRvLo7hlUV76RUVyJd3njzondQ/53q9r/Q9yGebPkBEROq4wxtg40xz+YbPoVl/S+OIiIj8md1u8MWx0auv73n61mORU6n0PcgxMTFERETQvHlzxo8ff9bpBYqKisjOzq7wEBGRWspeBj/cDxjQ6XoVxyIi9URhSRm//JFEQfGZB4JzBCv3p3E4owBfDxeu6BhudRypZSpVIPfu3ZuZM2eyYMEC3n33XWJjYxkwYAA5OTmnPWb69On4+/uXPyIj9VccEZFaa/1HkLQN3P3hsqetTiMiIjWguNTOHZ9sYNKnG3nmx51WxzmrOccG57q6ayM8XJ3PsrdIRZUqkIcPH84111xDp06dGDZsGD/99BOZmZl8+eWXpz1mypQpZGVllT/i4+MvOLSIiFggJxl+O1YUXzIVfEKszSMiItXObjd46KutrIhJA2DuxsOk5Z48QrqjSM8r5pc/kgC4Tt2r5Txc0DRPAQEBtG7dmn379p12H3d3d/z8/Co8RESkFlo0FYqyIbwL9JhodRoREakB03/exfwtCbg42WgU4ElxqZ1PVh86+4EW+WbTYUrKDDo28qd9hL/VcaQWuqACOTc3l/3795dPal9VKjGwttQC+vcUqQNiV8C2LwAbXPkqOKnLmlwYu91udQSpYvo3rXv+u3w/H6yIBeDFcZ2YcoU5vetnaw455L3IhmGUd6++vpdaj+X8VGoU6wcffJCRI0fStGlTEhISeOKJJ3B2duaGG26okjCurq7YbDZSU1MJDg7GVkunDJETDMMgNTUVm82Gq6ur1XFE5M9KCs2pmVzcz7xfaTH8+H/mco+J0Kh79WeTOsvNzQ0nJycSEhIIDg7Gzc1N1/tazjAMiouLSU1NxcnJCTc3N6sjSRX4ZtNhnvtpNwD/viKaMd0aU1pmp3EDTw5nFPD1psPc2KepxSkr2hSXwb6UXDxdnbmqc4TVcaSWqlSBfPjwYW644QaOHj1KcHAw/fv3Z82aNQQHB1dJGGdnZxo3bszhw4c5ePBglZxTrGez2WjcuDHOzmpxEnEYRTnwwRDIOgIX/QP63gvuPqfed83bkLYHvILMe49FLoCTkxNRUVEkJiaSkJBgdRypQl5eXjRp0gQnpwvqoCgOYOmeFB76ahsAt/ePYtLAFgC4ODsx8aIonvphJx/9HsvfejXByclx/sA1Z53ZejyiUzi+HmqYkfNTqQJ5zpw51ZWjnI+PD61ataKkpKTa30tqhqurq4pjEUez+ClI22suL50OGz6GQVOg603g/KdLQ2YcLHvRXL7sGfBsUPNZpc5xc3OjSZMmlJaWUlbmeN00pfKcnZ1xcXFRb4A6YEt8Jnd9tolSu8HoLhH8+4q2FbZf2zOS137dS2xaHr/uSuay9mEWJa0op7CEH7YlApr7WC5MpQrkmuLs7KyCSkSkusSthXUfmMsDH4LtcyEjFn6YDGvehUunQevLze7XC6ZAST406Qedr7c0ttQtx2+90e03Io7jQGouE2eup6CkjAGtgnhxXOeTWoh93F0Y36cp7y7dzwcrDjhMgfzd1gQKSspoGeJD96b6Y66cP/WBERGpT0qL4Lv7AAO6jIchj8I96+DyF8Az0OxK/fn1MHMErHwddv8ATi4w4hWzYBYRkTopLbeImz9eR3peMZ0a+/Pejd1xczl1qXBLv2a4OttYfzCDzXEZNZz01L44PjhXz0j1ZJALogJZRKQ++f0/ZhHsHWx2mQZwcYM+f4d/bIaLJoOzOxxaCYseN7f3uRtC21kWWUREqt/LC/dwOKOAZg29+PiWnni7n76jaaifB1d1bgTAh8dGubbSxkPpbDuchauzjau7NrI6jtRyKpBFROqLlN2w/GVzefgL4BVYcbtngNm9+r6N0PlvgA0aNIOLH67hoCIiUpN2J2Xz5QazBfaVazsT5HOW2Q2A2wdEAfDzjkTi0/OrNd+ZZBeWcP8XWwEY1aURDc8hu8iZqEAWEakP7GVm12p7iXl/cfsxp983IBKufhce2AmTlp1+dGsREan1DMPg2R93YTdgRMdwujcNPPtBQNtwPwa0CsJuwEe/n70V+UhmAav3H8UwjAuNXM4wDP79zXbi0vNp3MCTqVeqt5NcOBXIIiL1wfqP4PA6cPOFEa+e2/3EfhFmq7KIiNRZS/emsiImDTdnJx6+PLpSx04a2ByALzfEk5lffMp97HaDmStjueSVpdzwwRr+PW87JWX2C859/H1/2JaIs5ONN27oir+nBv2TC6cCWUSkrsuMh8XTzOWhT4C/7s8SEREoLbPz3I+7AJjQrylNGnpV6vj+LYOIDvMlv7iMWWvjTtp+OCOfGz9ay5Pf76SwxCyKP18Xz60z1pNVcGFTusYk5/DEd38A8OBlbejWRCNXS9VQgSwiUpcZBvz4ABTnQmQf6HGb1YlERMRBfLEhnpiUXAK8XLl3cKtKH2+z2bhjgNmK/L9VBykqNec1NwyDLzfEc/lrK1i1/yiers48Pao9H9zcAy83Z37fl8bYd1cRd/T87l0uLCnj3tmbKSyxM6BVEHcea8kWqQoqkEVE6rIdX0PML+DsBle9AU76tS8iIpBTWMJ/Fu0F4J+XtMLf6/y6J4/sHEGonzspOUV8tyWBlOxCbv/fBh76ahu5RaV0b9qAn/85gJv6NuPSdqHM/Xtfwvw82JeSy+h3VrLxUHql3/PpH3ayJzmHIB93Xr22y0lzNYtcCH1TEhGpq/LT4edjI1AP/BcEt7E2j4iIOIz3lu0nLbeYqCBvxvduet7ncXNx4pZ+5ojWr/0aw2WvLWfx7hTcnJ2YMjyaL+/sS7Mg7/L920f48+29F9GhkR/pecXc8MFavt1y5Jzf76ftieXduf9zXWeCfTVqtVSt009wJiIijs8woCADMg5CZhxkHjKfMw5Byi7IT4OQdub8xiIiIpgjSh+fv3jK8GjcXC6szexvvZvw1m8xHMksAKB9hB+vXtuFNmG+p9w/1M+DL+/syz/nbGHRzmT+OWcLB9Py+cclLbGdYRDJ+PR8Hv56GwB3DWrBgFbBF5Rb5FRUIIuI1FabPoVfHoXCrNPv4+YDV70JLm41l0tERBzaSwt2U1Rqp3dUIJe2C73g8/l7uvLPoa14Y/E+JvaP4r4hLXF1PnPR7eXmwns3duf5n3fxwYpY/vPrXjbGZdC3eUPahPnQOtSXRgGe5QVzSZmdf8zZTE5hKV2bBPDApa0vOLfIqahAFhGpjRI2ww+TwV5qvvYJg4Am0KCp+Rxw7DmsI3gHWRpVREQcx9b4TOZvSQDgsRHtzthiWxmTBrbgjgHNK3U+Zycbj45oR1SQD1O/3cHyvaks35tavt3bzZlWob60DvUht6iUzXGZ+Hq48Mb1Xc9agIucLxXIIiK1TXE+fH2HWRy3vQrG/BdcPa1OJSIiDs4wDJ49Nq3TmK6N6NjYv0rPf77F9t96N6FTY3+W7E5hb0oue5NyOJCWS15xGVviM9kSn1m+7/NjOhEZWLnpqEQqQwWyiEht88ujcDQGfMNh5OsqjkVE5Jws/COZdQfTcXdx4sFhjjVwY4dG/nRodKJgLymzczAtjz3JOexNzmVfSg7dmjRgRKdwC1NKfaACWUSkNtmzADZ8bC6Pfhe8Aq3NIyIitUJeUSnP/2y2Ht8xoDkRAY79x1VXZydahfrSKvTUA32JVBd13hcRqS1yU+Dbe8zlvvdCi8HW5hERkVohK7+EGz9ay8Gj+QT5uPP3QS2sjiTisNSCLCJSGxiGWRznp0FIexgy1epEIiJSC6TkFHLzR+vYnZSDv6crH07ogY+7SgCR09H/HSIitcGGjyDmF3B2h7EfgquH1YlERMTBHc7I58YPzZbjYF93Prut92nnJhYRkwpkERFHl7oXFj5mLl86DULbWZtHREQc3r6UXG76aC2JWYU0buDJrNt707Sht9WxRByeCmQREUdWWgzf3A6lBdB8MPS60+pEIiLi4HYcyeLmj9eRnldMyxAfPrutN2H+6nkkci40SJeIiCNb+hwkbgXPQHPUaif92pYLk5OTw+TJk2natCmenp7069eP9evXl283DIPHH3+c8PBwPD09GTp0KDExMRYmFpHKWBebzg3/XUN6XjEdG/nz5Z19VRyLVIK+aYmIOKpDq+H318zlka+Dn+Z+lAt3++23s2jRIj799FO2b9/OZZddxtChQzly5AgAL774Im+88Qbvvfcea9euxdvbm2HDhlFYWGhxchE5myV7Urjpo7XkFJXSKyqQ2Xf0JtDbzepYIrWKCmQREUdkGLDw34ABXW6EdldZnUjqgIKCAr7++mtefPFFBg4cSMuWLXnyySdp2bIl7777LoZh8Nprr/HYY48xatQoOnXqxCeffEJCQgLz58+3Or6InMHOhGzu/HQjRaV2hkSH8MnEXvh6uFodS6TWUYEsIuKIdv8ICZvA1RuGPml1GqkjSktLKSsrw8OjYndLT09Pfv/9d2JjY0lKSmLo0KHl2/z9/enduzerV6+u6bgico7yi0u59/NNFJfaubh1MO/f1B0PV2erY4nUSiqQRUQcjb0MfnvGXO57N/gEW5tH6gxfX1/69u3L008/TUJCAmVlZXz22WesXr2axMREkpKSAAgNDa1wXGhoaPm2UykqKiI7O7vCQ0RqzhPf/sGB1DxC/dz5z3VdcHXWV3yR86X/e0REHM32ryB1F3j4Q997rU4jdcynn36KYRg0atQId3d33njjDW644QacLmAAuOnTp+Pv71/+iIyMrMLEInIm8zcfYe7Gw9hs8Np1XXXPscgFUoEsIuJISovNkasBLpoMngFWppE6qEWLFixbtozc3Fzi4+NZt24dJSUlNG/enLCwMACSk5MrHJOcnFy+7VSmTJlCVlZW+SM+Pr5aP4OImA6m5fHovO0A3DekFX1bNLQ4kUjtpwJZRMSRbP4UMg6Cdwj01pzHUn28vb0JDw8nIyODhQsXMmrUKKKioggLC2Px4sXl+2VnZ7N27Vr69u172nO5u7vj5+dX4SEi1auotIx7P99EXnEZvZoF8o8hLa2OJFInuFgdQEREjikpgOUvmcsD/wVu3tbmkTpp4cKFGIZBmzZt2LdvH//617+Ijo7m1ltvxWazMXnyZJ555hlatWpFVFQUU6dOJSIigtGjR1sdXUT+5MUFe9hxJJsAL1deu74LLrrvWKRKqEAWEXEU6z+EnETwbwLdJ1idRuqorKwspkyZwuHDhwkMDGTs2LE8++yzuLqa08E89NBD5OXlMWnSJDIzM+nfvz8LFiw4aeRrEbHOb7uT+ej3WABeGteZiABPixOJ1B02wzCMmnzD7Oxs/P39ycrKUhcsEZHjCrPh9c5QkA6j3oGu461OVG/oulT19DMVqT5JWYVc8cYK0vOKuaVfM568qr3VkURqhXO9NqkvhoiII1jzjlkcB7WGTtdZnUZERBxQmd1g8hebSc8rpn2EH1OuiLY6kkidowJZRMRqeUdh1Vvm8uB/g7PufhERkZO99ds+1hxIx8vNmTdv6Iq7i7PVkUTqHBXIIiJWW/kfKM6BsE7QdpTVaURExAEt/COJ1xbvBeCZ0R1oHuxjcSKRukkFsoiIlbITYN0H5vIlj4OTfi2LiEhFO45kMXnOFgwDburTlDHdGlsdSaTO0jcxERErLX8JSguhSV9oOdTqNCIi4mBSsgu545MNFJSU0b9lEE+MbGd1JJE6TQWyiIhVUvfApk/M5UseB5vN2jwiIuJQCkvKuOPTjSRmFdI82Ju3x3fTfMci1Uz/h4mIWCEnGWaNA3sptLwUmvazOpGIiDgQwzB4cO5WtsZnEuDlyscTeuLv6Wp1LJE6TwWyiEhNK8yGWWMhMw4aRMHod61OJCIiDub1xTH8sC0RFycb747vTrMgb6sjidQLKpBFRGpSaTF8cSMkbQfvYLjpG/AJtjqViIg4kO+3JvDarzEAPHt1B/q2aGhxIpH6QwWyiEhNsdth/l0QuwxcvWH8XAhsbnUqERFxIFviM3lw7lYA7hgQxXU9m1icSKR+UYEsIlJTFk2FHV+Bkwtc9ylEdLU6kYiIOJCEzALu+GQDRaV2LokO4ZHhba2OJFLvqEAWEakJq96E1W+Zy6PehpaXWJtHREQczpPf/UFqThHRYb68fkNXnJ00u4FITVOBLCJS3bbNhV8eM5cvfQo6X29tHhERcTgFxWUs25sKwCvXdsbH3cXiRCL1k/7PExE5X4YBC/8NhzeATwj4hIJv2Illn1DIPmLedwzQ+y7o9w9rM4uIiENatT+NolI7jQI8aRfuZ3UckXpLBbKIyPnKioc175zbvu2vhmHPgU3d5URE5GS/7U4BYHB0MDZdK0QsowJZROR8JWw2nwNbQJ+7IDfZfOQce85NgbwUaDEErn4fnHRXi4iInMwwDJYcK5CHRIdYnEakflOBLCJyvhK2mM/N+kOvO069j2Go1VhERM5oT3IOCVmFuLs40bd5kNVxROo1NWeIiJyv4y3IZ5quScWxiIicxfHu1Re1DMLTzdniNCL1mwpkEZHzYRiQuMVcjuhiZRIREanlftt1/P5jda8WsZoKZBGR85EZBwUZ4OQKIe2sTiMiIrVURl4xm+IyAN1/LOIIVCCLiJyP492rQ9uDi7u1WUREpNZaHpOK3YA2ob40CvC0Oo5IvacCWUTkfKh7tYiIVIET0zup9VjEEahAFhE5H8dHsA7vYmUKERGpxUrL7Czbmwqoe7WIo1CBLCJSWYZxbiNYi4iInMHm+Ewy80vw93SlW5MAq+OICCqQRUQqL/MQFGaCs5sG6BIRkfN2vHv1xa2DcXHW13IRR6D/E0VEKut463FIO3BxszaLiIjUWkuOFcjqXi3iOFQgi4hU1vH7j9W9WkREztORzAJ2J+XgZDNbkEXEMahAFhGpLI1gLSIiF+h463HXJg1o4K3eSCKOQgWyiEhlGIZakEVE5IKpe7WIY1KBLCJSGRkHTwzQFdzW6jQiIlILFZaUsXJ/GqACWcTRqEAWEamM492rQ9trgC4RETkvq/cfpbDETri/B9FhvlbHEZE/UYEsIlIZmv9YREQu0PHpnQZHh2Cz2SxOIyJ/pgJZRKQyjt9/HN7FyhQiIuKg9qfmUlhSdtrthmGUF8hD2qh7tYijUYEsInKuDEMjWIuIyGn9vD2RS15ZxpCXl/LT9kQMwzhpn5iUXI5kFuDm4kS/lg0tSCkiZ6ICWUTkXGXEQmEWOLtrgC4RETnJFxviAUjIKuTuWZu46aN17EvJqbDP4l1m63Hf5g3xcnOp8YwicmYqkEVEztXx7tUaoEtERP4iq6CElfvMkalv7NMENxcnft+XxuWvreC5n3aRW1QKnJje6ZK26l4t4oguqEB+/vnnsdlsTJ48uYriiIg4sPIBurpYGkNERBzP4l3JlJQZtA714ZnRHVl0/0CGtg2h1G7w3+UHGPLyUmavjWNjXAYAg3X/sYhDOu8Cef369bz//vt06tSpKvOIiDiu8vuPNYK1iIhU9POOJAAu7xAOQNOG3nw4oScf39KDpg29SMkp4t/ztlNmN2gV4kNkoJeVcUXkNM6rQM7NzWX8+PF88MEHNGjQoKoziYg4HsOAhK3mskawFhGRP8ktKmXZ3lQArugYVmHbkOhQFk4eyP9d2hoPV/Or92XtQ2s8o4icm/MaGeCee+5hxIgRDB06lGeeeeaM+xYVFVFUVFT+Ojs7+3zeUkTEWukHoOjYAF0hGqBLREROWLI7heJSO1FB3rQJ9T1pu4erM/dd0oqruzVi9f6jjOwcYUFKETkXlS6Q58yZw6ZNm1i/fv057T99+nSmTZtW6WAiIg7lePfqsA7g7GppFBERcSw/70gEYHiHMGw222n3a9zAi2t6qGu1iCOrVBfr+Ph4/vnPfzJr1iw8PDzO6ZgpU6aQlZVV/oiPjz+voCIiljo+QJe6V4uIyJ8UFJexZLfZvXr4sfuPRaT2qlQL8saNG0lJSaFbt27l68rKyli+fDlvvfUWRUVFODs7VzjG3d0dd3f3qkkrIlLVcpLg8HpoPRycz/Ar8fgUTxqgS0RE/mTZ3hQKSspo3MCTDo38rI4jIheoUgXyJZdcwvbt2yusu/XWW4mOjubhhx8+qTgWEXFomfHw0WWQkwC97oQrXjz1fnY7JG4zlzXFk4iI/Mnx0avP1r1aRGqHShXIvr6+dOjQocI6b29vGjZseNJ6ERGHlp8On40xi2OAde9DeCfoeuPJ+2bEnhigKzi6ZnOKiIjDKiotY/GuFACGd1T3apG64LznQRYRqbWK82H2tZC2F/wama3HAD/cD/GnGIDw+P3HYR01QJeIiJT7PSaN3KJSwvw86NI4wOo4IlIFzmuapz9bunRpFcQQEakhZSUw9xbzvmOPALjxGwhqDdlHYPcP8MWNMGkp+P2pJeD4CNbqXi0iIn/y03aze/XlHcJwclL3apG6QC3IIlJ/GAZ8PxliFoKLB/ztSwiJBicnuPo9CG4LuUnw5U1QemL+9vIBujSCtYiIHFNcamfRTrNAvkLdq0XqDBXIIlJ/LH4KtnwGNicYNwOa9D6xzd0Xrp8FHv5m6/KPD5gFtd0OiVvNfTSCtYiIHLP6wFGyC0sJ8nGne9MGVscRkSqiAllE6oe178Pvr5rLV74G0VecvE/DFjDuY7OA3vwZrP8Q0g9AUbbZ4qwBuqQOKCsrY+rUqURFReHp6UmLFi14+umnMQyjfB/DMHj88ccJDw/H09OToUOHEhMTY2FqEcfz8/ZEAC7vEIqzuleL1BkqkEWk7tvxDfz8sLk8+DHoPuH0+7YcCkOfNJcXPAJr3jaXQzuceZ5kkVrihRde4N133+Wtt95i165dvPDCC7z44ou8+eab5fu8+OKLvPHGG7z33nusXbsWb29vhg0bRmFhoYXJRRxHaZmdX3YmAzC8g7pXi9Ql+rYnInXbwd9h3p2AAT3vgIEPnv2Yfv8w5z3e8RVs+Nhcp+7VUkesWrWKUaNGMWLECACaNWvG559/zrp16wCz9fi1117jscceY9SoUQB88sknhIaGMn/+fK6//nrLsos4inWx6aTnFdPAy5XeUYFWxxGRKqQWZBGpu/KOwle3QVkxtL0Khr8AtnPoBmezwVVvQlinE+s0grXUEf369WPx4sXs3bsXgK1bt/L7778zfPhwAGJjY0lKSmLo0KHlx/j7+9O7d29Wr15tSWYRR/PzDnNwrsvaheHirK/TInWJWpBFxHq7foDsBGjUzezK7Opx4ec0DPj2HnNU6qDW5ijVTs7nfrybF1w/G/47CAoyoEnfC88k4gAeeeQRsrOziY6OxtnZmbKyMp599lnGjx8PQFKS+cU/NDS0wnGhoaHl2/6qqKiIoqITI79nZ2dXU3oR69ntBgv+MP9fGN4xzOI0IlLVVCCLiLVS98AX40+8dnKFsA4Q0Q0adTcfQa0qV9yCOcDW3p/B2Q3GfgRu3pXPFhAJf//dLLIbtqj88SIO6Msvv2TWrFnMnj2b9u3bs2XLFiZPnkxERAQTJpzh/vwzmD59OtOmTavipCKOaWNcBqk5Rfh6uNCvRZDVcUSkiqlAFhFrbfvCfPYJA3sJ5B+FhM3mY8NH5jY3X+hxCwyddm6FcvJO+OUxc3noNAjvdOb9z8Qv3HyI1BH/+te/eOSRR8rvJe7YsSOHDh1i+vTpTJgwgbAws0UsOTmZ8PAT/+0nJyfTpUuXU55zypQpPPDAA+Wvs7OziYyMrL4PIXIBlu1NZdX+NAK93Gjo405DHzcaeh9b9nbDw/XM15mfjo1efWm7UNxc1L1apK5RgSwi1jEM2D7XXL78OWg/BjLj4MhG83G8UC7OgVVvQnosjP0QXD1Pf86SAvj6NigtNEek7v33mvksIrVEfn4+Tk4Vv9Q7Oztjt9sBiIqKIiwsjMWLF5cXxNnZ2axdu5a77rrrlOd0d3fH3d29WnOLVIXCkjL+/ulGCkrKTruPj7sLgd5uxwpnd4J8Tiw39HFjwbH7jzV6tUjdpAJZRKwTv9YsiN18oPVwc3CsBk3NR4cx5j5lpbBzPsy/G3b/AJ+Mhhs+B6/TjBq66AlI2QnewTD6XXDSX/dF/mzkyJE8++yzNGnShPbt27N582ZeffVVJk6cCIDNZmPy5Mk888wztGrViqioKKZOnUpERASjR4+2NrzIBVoXm05BSRkNvFwZ3CaEtLxijuYWcTS3mKN5RZSUGeQWlZJbVEpcev5pz+Pt5syAVupeLVIXqUAWEesc717d9ipzUKxTcXaBjuPANxw+vwHi18DHl8ONX5v3CP/ZngWw7n1zefR74BNSfdlFaqk333yTqVOncvfdd5OSkkJERAR33nknjz/+ePk+Dz30EHl5eUyaNInMzEz69+/PggUL8PCoggH0RCy0bG8qYI4+/cK4irffGIZBdmEpR3OLSM8rJu1Y0Xw0t/jYa3M5s6CEa3s0PmtXbBGpnWyGYRg1+YbZ2dn4+/uTlZWFn59fTb61iDiS0mJ4pbU5QvRN86DFkLMfk7wTPhsLOQlmwTz+K3NAL4CcJHi3n3kPc597zC7bIudA16Wqp5+pOKqhry5jX0ou74zvxhUd1UVapD4512uT+h6KiDX2LzaLY59QiLr43I4JbQe3L4LgtpCTCDOGQ+wKsNth3t/N4ji0Iwx9onqzi4hIrXMks4B9Kbk42eAijT4tIqehAllErLHtS/O5w9jKTeHk3xgm/gxN+kFRNnw2Br66FQ4sARdPGPcRuGiwIBERqWj5se7VXZs0wN/L1eI0IuKoVCCLSM0ryoE9P5vLHa+p/PGeDcxu2W2vgrJicxAvgOHPQ3CbKospIiJ1x/ECeWCrYIuTiIgjU4EsIjVv1w9QWgANW0JE1/M7h6sHXDMTek0yX7cfA90mVFlEERGpO0rK7PwekwbAxW1UIIvI6WkUaxGpecdHr+50nTm10/lycoYrXoKLJoNfxIWdS0RE6qwt8ZnkFJUS4OVKx0b+VscREQemAllEalZOMsQuM5c7jquac/o3qprziIhInXS8e/WAVsE4O+mPqSJyeupiLSI1a8fXYNihcU8IbG51GhERqQeOz398cWt1rxaRM1OBLCI1a/ux0as7XmttDhERqReO5hax/UgWAANbaXonETkzFcgiUnPS9kHCZrA5Q/urrU4jIiL1wO/70jAMaBvuR4ifh9VxRMTBqUAWkZpzvPW4xRDwUTc3ERGpfse7Vw9srdZjETk7FcgiUjMM40+jV6t7tYiIVD+73WD53mPTO+n+YxE5ByqQRaRmHN4AGQfB1RuiR1idRkRE6oGdidmk5Rbh5eZMj6aBVscRkVpABbKI1Izj3aujR4Cbt7VZRESkXlgeY3av7teiIW4u+torImen3xQiUv3KSmDHN+ayuleLiEgNWbZH0zuJSOWoQBaR6ndgKeSngVcQNB9sdRoREakHcotK2XgoA4CBKpBF5BypQBaR6rftWPfqDmPA2cXaLCIiUi+s2pdGqd2gWUMvmjbUrT0icm5UIItI9co6DLu+M5c7qnu1iIjUjBPTO6n1WETOnQpkEalevz0DpYXQ9CJo3MPqNCIiUg8YhlFeIOv+YxGpDBXIIlJ9ErbA1jnm8mVPg81maRwREakfYtPyOJxRgJuzE32aN7Q6jojUIiqQRaR6GAb88hhgQMdroFF3qxOJiEg9sfxY63GPZg3wdtfYFyJy7lQgi0j1iPkFDq4AZ3cYMtXqNCIiUo+oe7WInC8VyCJS9cpK4ZdjRXHvO6FBU2vziIhIvVFYUsbqA0cBDdAlIpWnAllEqt7mTyBtD3g2gAH/Z3UaERGpRzYczKCwxE6IrzvRYb5WxxGRWkYFsohUraIcWPKcuXzxI+AZYGkcERGpX5btTQHM1mObBocUkUpSgSwiVWvlG5CXCoHNocdEq9OIiEg9YhgGv+xMBnT/sYicHxXIIlJ1shNg1Zvm8tBp4OJmbR4REalXVh84yqGj+fi4uzAkOsTqOCJSC6lAFpGq89uzUFoAkX2g7Uir04iISD3zxfp4AEZ2jtD0TiJyXlQgi0jVSNoOW2aZy8OeBd33JSIiNSgzv5ifdyQBcEOvSIvTiEhtpT+ticjZFeWacxp7NoCApuATCk5/+vuaYcAvjwEGtB8DjXtYFlVEROqn+ZuPUFxqp224Hx0b+VsdR0RqKRXIInJ2vz0Na9878drZHQKamPMbBzQBFw84sBSc3WDoE5bFFBGR+skwDOYc6159fc9IjV4tIudNBbKInN2BZeazVxAUpENZERyNMR9/1msSNGhW4/FERKR+23o4i91JObi5ODG6SyOr44hILaYCWUTOrCgHUneby3etAq9AyD4CGYcg89CJZydXuPgha7OKiEi99MX6OACu6BCGv5erxWlEpDZTgSwiZ5awBTDAPxJ8Q811DZqppVhERBxCXlEp321JAOD6Xk0sTiMitZ1GsRaRMzuy0Xxu1M3aHCIiIqfw47ZE8orLaNbQi95RgVbHEZFaTgWyiJzZkQ3mc6Pu1uYQERE5hTnHuldf17OJBucSkQumAllEzuzIJvO5kaZuEhERx7I3OYdNcZm4ONkY212Dc4nIhVOBLCKnl51oDshlc4LwzlanERERqWDOOnNqp0vahhDi62FxGhGpC1Qgi8jpJRxrPQ5uC+4+1mYRERH5k6LSMr7ZfBiA63tqcC4RqRoqkEXk9DRAl4iIOKhf/kgmM7+EMD8PBrYOtjqOiNQRKpBF5PTKC2QN0CUiIo7l+OBc1/ZojLOTBucSkaqhAllETs1uhyObzWUVyCIiUoMy8oopsxun3R53NJ+V+45is8E1PSJrMJmI1HUuVgcQEQeVvh+KssDFE0LaWp1GRETqiQU7Evn7Z5sI9nVnRMdwRnYOp2tkA5z+1Er85QZzcK7+LYOIDPSyKqqI1EEqkEXk1I53rw7vDM6u1mYREZF648sN5sBbqTlFzFx1kJmrDhLh78GITuFc2SmC9hF+zN1oFsganEtEqpoKZBE5Nd1/LCIiNaywpIxV+9MAmHZVe7bEZ7JoZzIJWYV8sCKWD1bEEuTjTlpuEYHebgxtF2JxYhGpa1Qgi8ipaQRrERGpYav3H6WwxE6Evwc3923KhH7NKCwpY+meVH7YlsDiXSmk5RYBMKZrI9xdnC1OLCJ1jQpkETlZaREkbTeX1YIsIiI15LfdKQAMjg7BZjPvOfZwdebyDmFc3iGM/OJSFu9KYV9KLrcPiLIyqojUUSqQReRkSTugrBi8GkKDZlanERGResAwjPICeUj0qbtOe7m5MLJzRE3GEpF6RtM8icjJ/nz/sU1zS4qISPXbm5zLkcwC3F2c6NciyOo4IlJPqUAWkZNpgC4REalhx1uP+7ZoiKeb7i0WEWuoQBaRk6lAFqmzmjVrhs1mO+lxzz33AFBYWMg999xDw4YN8fHxYezYsSQnJ1ucWuqDJWfpXi0iUhNUIItIRQWZcDTGXI7QCNYidc369etJTEwsfyxatAiAa665BoD777+f77//nrlz57Js2TISEhIYM2aMlZGlHsjML2ZjXAYAg9uoQBYR62iQLhGpKGGz+dygGXg3tDSKiFS94ODgCq+ff/55WrRowcUXX0xWVhYfffQRs2fPZsiQIQDMmDGDtm3bsmbNGvr06WNFZKkHlu1Npcxu0DrUh8hAL6vjiEg9phZkEalI3atF6o3i4mI+++wzJk6ciM1mY+PGjZSUlDB06NDyfaKjo2nSpAmrV6+2MKnUdUv+NL2TiIiV1IIsIhUd2WQ+q0AWqfPmz59PZmYmt9xyCwBJSUm4ubkREBBQYb/Q0FCSkpJOe56ioiKKiorKX2dnZ1dHXKmjyuwGy/amAjBE3atFxGKVakF+99136dSpE35+fvj5+dG3b19+/vnn6somIjXNMODIBnNZBbJInffRRx8xfPhwIiIubF7Z6dOn4+/vX/6IjIysooRSH2yJzyAjvwQ/Dxe6N21gdRwRqecqVSA3btyY559/no0bN7JhwwaGDBnCqFGj+OOPP6orn4jUpOwjkJsMNmcI62R1GhGpRocOHeLXX3/l9ttvL18XFhZGcXExmZmZFfZNTk4mLCzstOeaMmUKWVlZ5Y/4+Pjqii110PHpnQa2DsbFWXf/iYi1KvVbaOTIkVxxxRW0atWK1q1b8+yzz+Lj48OaNWuqK5+I1KTj9x+HtgM3DZIiUpfNmDGDkJAQRowYUb6ue/fuuLq6snjx4vJ1e/bsIS4ujr59+572XO7u7uW9y44/RM7Vb7vN7tWXtFX3ahGx3nnfg1xWVsbcuXPJy8s740VTRGqR8gG6elibQ0Sqld1uZ8aMGUyYMAEXlxNfBfz9/bntttt44IEHCAwMxM/Pj/vuu4++fftqBGupFgmZBexKzMZmg4tbq0AWEetVukDevn07ffv2pbCwEB8fH+bNm0e7du1Ou78G7hCpRTRAl0i98OuvvxIXF8fEiRNP2vaf//wHJycnxo4dS1FREcOGDeOdd96xIKXUB0v2mN2ru0YGEOjtZnEaEZHzKJDbtGnDli1byMrK4quvvmLChAksW7bstEXy9OnTmTZt2gUHFZFqZi87MQeyCmSROu2yyy7DMIxTbvPw8ODtt9/m7bffruFUUh8dn95piKZ3EhEHUemRENzc3GjZsiXdu3dn+vTpdO7cmddff/20+2vgDpFaIm0vFOeCqzcEt7E6jYiI1HGFJWWs3HcU0PzHIuI4LngeZLvdXqEL9V+5u7vj7u5+oW8jItXt+P3HEV3BydnaLCIiUuetOXCUgpIywvw8aBeugd1ExDFUqkCeMmUKw4cPp0mTJuTk5DB79myWLl3KwoULqyufiNSU8gG6ulmbQ0RE6oXj0zsNjg7BZrNZnEZExFSpAjklJYWbb76ZxMRE/P396dSpEwsXLuTSSy+trnwiUlPKC2TdfywiItXLMIzyAln3H4uII6lUgfzRRx9VVw4RsVJJAST/YS6rQBYRkWq2LyWXwxkFuLk4cVHLhlbHEREpV+lBukSkDkrcBvZS8A4B/8ZWpxERkTrueOtxn+YN8XK74CFxRESqjApkkfou7ygse95cbtQddB+YiIhUs/Lu1W2CLU4iIlKR/mQnUp8dWgVf3QY5CeDsDr3vtDqRiIjUcVkFJWw4lAHAkOhQi9OIiFSkAlmkPrKXwe+vwpLnwLBDw1ZwzQwI62h1MhERqeNmrT1Emd2gRbA3TRp6WR1HRKQCFcgi9U1OMsybBAeWmq87XQ8jXgF3H0tjiYhI3bc/NZfXfo0B4K5BLS1OIyJyMhXIIvXJ/iXwzSTISwFXL7Mw7vI3q1OJiEg9YLcbPPL1NopL7QxsHczYbo2sjiQichIVyCL1gd0OS56FFa8ABoS0N7tUB7exOpmIiNQTn645xPqDGXi7OTN9TEdsGhRSRByQCmSR+uD3V2DFy+Zy91vh8ung6mltJhERqTfi0/N5YcFuAB4ZHk2jAF2DRMQxqUAWqevi18GS6ebyiFeg5+3W5hERkXrFMAz+PW87+cVl9IoKZHzvplZHEhE5Lc2DLFKXFWSa0zgZZdDxGuhxm9WJRESknpm78TArYtJwd3HihbGdcHJS12oRcVwqkEXqKsOAH+6HrDgIaAojXgXd7yUiIjUoJbuQZ37YCcADl7YmKsjb4kQiImemAlmkrtr8GfzxDTi5wLiPwcPP6kQiIlKPGIbBY/N3kF1YSqfG/tzWP8rqSCIiZ6UCWaQuSt0LPz9kLg95DBr3sDaPiIjUOz9uT+SXncm4Ott4cVwnXJz1tVNEHJ9+U4nUNaVF8PVEKMmH5oOg3z+tTiQiIvVMel4xT3z7BwB3D2pJdJh6MYlI7aACWaSu+fVJSNoOXg3h6vfBSf+bi4hIzXrq+z84mldMm1Bf7hnc0uo4IiLnTN+cReqSvQthzTvm8uh3wTfM2jwiIlLv/B6TxvwtCTjZ4MVxnXBz0ddNEak99BtLpK7ISYL5d5nLve+C1sOszSMiIvVOSZmdJ783u1bf3LcZnSMDrA0kIlJJKpBF6gK7HebdCflHIawjXDrN6kQiIlIPfbL6EPtScgn0duP+S1tbHUdEpNJUIIvUBXt/hgNLwdULxn4MLu5WJxIRkXomNaeI1xbtBeChYW3w93S1OJGISOWpQBap7QwDVrxiLve5C4L1F3sREal5Ly3cTU6ROefxtT0irY4jInJeVCCL1Haxy+DIRnDxMO89FhERqWFb4jP5csNhAJ4Y2R4nJ5vFiUREzo8KZJHa7njrcbcJ4BNsbRYREal37HaDJ78zB+Ya060R3Zs2sDiRiMj5U4EsUpsd3gCxy8HJBfrdZ3UaERGph77edJgt8Zn4uLvwyOXRVscREbkgKpBFarMVr5rPna6HAN3vJSIiNSu7sIQXFuwB4B+XtCTEz8PiRCIiF0YFsoijOLDMLHhLi85t/+SdsOdHwAb9J1dnMhERkVN6c3EMablFNA/y5pZ+UVbHERG5YC5WBxARzEG2PhsL9hI4uh9GvQW2swxw8vt/zOd2V0FQq+rPKCIi8if7UnKYsfIgAI+PbIebi9pdRKT2028yEasVZMDcW8ziGGDLZ7D67TMfkx4LO74yl/s/UK3xRERE/sowDKZ9v5NSu8HQtqEMahNidSQRkSqhAlnESoYB8++BzDgIaAqDHzXXL5oKMYtOf9zK18GwQ8uhENGlRqKKiIgct2hnMiti0nBzdmLqlW2tjiMiUmVUIItYac075n3Ezm5w7f9g4L+g601m8fvVREjdc/IxOUmwZZa5POD/ajaviIjUe6Vldp75cRcAdwyMomlDb4sTiYhUHRXIIlaJXw+LHjeXhz0HEV3N+45HvApN+kFRNnx+PeSnVzxu9VtQVgyRfaBpv5rPLSIi9drymFTi0vNp4OXKPYNbWh1HRKRKqUAWsUJ++rH7jkuh/RjoefuJbS5ucN2n4N8E0g+Y+5WVnDhu/cfmslqPRUTEAnPWxQMwpltjvNw03quI1C0qkEVqmt0O8+6E7MMQ2AJGvn7yiNXeQXDD5+DqDbHLYOG/zfXr/gsleRDaEVpdWvPZRUSkXkvJKWTx7hQArusZaXEaEZGqpwJZpKateh1ifgEXD/O+Yw+/U+8X1gHG/NdcXvdfWPUmrH3PfD3ggbNPAyUiIlLFvtp4mDK7QbcmAbQO9bU6johIlVOBLFKTDq2CxU+by8NfhLCOZ96/7ZUwZKq5/Mtj5pRQgS2g3ajqzSkiIvIXhmHwxXqze/X1vZpYnEZEpHqoQBapKbmp5sjURhl0uh663Xxuxw34P+gw7sTr/pPByblaIoqIiJzOmgPpHDqaj4+7CyM6hlsdR0SkWmhkBZGa8sNkyEmE4Gi48tVz7yJts8Got6AoB0oLzeJaRESkhn2xPg6AkZ0j8HbXV0gRqZv0202kJsT8Crt/ACcXGPcxuFVyzkhXTxj/ZfVkExEROYus/BJ+2pEEwPUanEtE6jB1sRapbqXFsOBhc7n33yG0vbV5REREKmne5sMUl9qJDvOlU2N/q+OIiFQbFcgi1W3NO3B0H3iHwMUPW51GRESkUgzDYM6xwblu6NUEm2ZREJE6TAWySHXKToDlL5nLlz51+imdREREHNS2w1nsTsrBzcWJ0V0aWR1HRKRaqUAWqU6LHofiXGjcCzpdZ3UaERGRSjveenxFhzD8vVwtTiMiUr1UIItUl0OrYPtcwAZXvARO+t9NRERql7yiUr7bcgSA63pq7mMRqfv0jV2kOpSVwk//Mpe73wIRXaxMIyIicl5+3J5IXnEZzRp60ad5oNVxRESqnQpkkeqwcQYk7wCPALjkcavTiIiInJc568y5j6/rqcG5RKR+UIEsUtXyjsJvz5jLQx4DL/3FXUREap+9yTlsisvE2cnG2O4anEtE6gcVyCJV7benoDATwjpCj4lWpxEROcmRI0e48cYbadiwIZ6ennTs2JENGzaUbzcMg8cff5zw8HA8PT0ZOnQoMTExFiYWK3xxbHCuS6JDCPH1sDiNiEjNUIEsUpWObIKN/zOXh78ETs7W5hER+YuMjAwuuugiXF1d+fnnn9m5cyevvPIKDRo0KN/nxRdf5I033uC9995j7dq1eHt7M2zYMAoLCy1MLjWpqLSMbzYdBsy5j0VE6gsXqwOI1Bl2O/z8EGBAx2uhaV+rE4mInOSFF14gMjKSGTNmlK+LiooqXzYMg9dee43HHnuMUaNGAfDJJ58QGhrK/Pnzuf7662s8s9S8RTuTycgvIczPg4Gtg62OIyJSY9SCLFJVfn8VDq8HNx+49Cmr04iInNJ3331Hjx49uOaaawgJCaFr16588MEH5dtjY2NJSkpi6NCh5ev8/f3p3bs3q1evPuU5i4qKyM7OrvCQ2scwDHYcyWL6z7uY9v1OAK7t0RhnJw3OJSL1h1qQRS6U3Q6/PApr3jFfD3kM/MKtzSQichoHDhzg3Xff5YEHHuDf//4369ev5x//+Adubm5MmDCBpKQkAEJDQyscFxoaWr7tr6ZPn860adOqPbtUjz1JOXy/NYEftiVw8Gh++fpwfw/+1ruphclERGqeCmSRC1FSCPPuhJ3zzdeXPgW9/25pJBGRM7Hb7fTo0YPnnnsOgK5du7Jjxw7ee+89JkyYcF7nnDJlCg888ED56+zsbCIjI6skr1SP7MISZvx+kB+2JRCTklu+3t3FiUvahnBlpwgGtwnB001jaYhI/aICWeR8FWTAnPFwaCU4ucLod6HTNVanEhE5o/DwcNq1a1dhXdu2bfn6668BCAsLAyA5OZnw8BO9YZKTk+nSpcspz+nu7o67u3v1BJZqcc+sTayISQPAzdmJga2DGdk5nKFtQ/F219dDEam/9BtQ5HxkxsOscZC6G9z94LrPoPnFVqcSETmriy66iD179lRYt3fvXpo2NbvSRkVFERYWxuLFi8sL4uzsbNauXctdd91V03GlGqw5cJQVMWm4Ott49uqODGsfhr+nq9WxREQcggpkkcpK2mEWxzmJ4BsB4+dCWAerU4mInJP777+ffv368dxzz3Httdeybt06/vvf//Lf//4XAJvNxuTJk3nmmWdo1aoVUVFRTJ06lYiICEaPHm1teLlghmHw6qK9AFzXM5Jre6grvIjIn6lAFqmMA8vgixuhKBuC28KNX4F/Y6tTiYics549ezJv3jymTJnCU089RVRUFK+99hrjx48v3+ehhx4iLy+PSZMmkZmZSf/+/VmwYAEeHh4WJpeqsHLfUdbFpuPm4sS9g1tZHUdExOHYDMMwavINs7Oz8ff3JysrCz8/v5p8a5ELc3gjfDwM7CXQtD9cPws8A6xOJSIXSNelqqefqWMyDIMx765ic1wmt17UjCdGtrc6kohIjTnXa5NakEXO1YqXzeK41TC47lNw0YA0IiJSeyzdk8rmuEw8XJ24a1ALq+OIiDgkJ6sDiNQKR/fDnp/N5WHPqjgWEZFa5c/3Ht/ctxkhvuouLyJyKiqQRc7FmncBw2w9DtI9WyIiUrss2pnM9iNZeLk5c+fA5lbHERFxWCqQRc6mIAO2zDKX+95tbRYREZFKsttPtB7felEzGvqoF5SIyOmoQBY5m43/g5J8CO0AUZrrWEREapefdySxOykHX3cX7hig1mMRkTNRgSxyJmUlsM6cG5Q+d4HNZm0eERGRSiizG7z2q9l6PLF/FAFebhYnEhFxbCqQRc5k57eQfQS8Q6DjNVanERERqZQftiUQk5KLn4cLtw2IsjqOiIjDU4EscjqGAavfNpd73q6Rq0VEpFYpLbPz2q8xAEwa2Bw/D1eLE4mIOD4VyCKnE78WEjaBszv0mGh1GhERkUqZt/kIsWl5NPBy5ZaL1HosInIuVCCLnM7x1uNO14JPsLVZREREKqGkzM4bv5mtx3+/uAU+7i4WJxIRqR1UIIucSsZB2P2Dudz3HkujiIiIVNY3mw4Tn15AkI87N/dtZnUcEZFaQwWyyKmsfR8MO7QYAiFtrU4jIiJyzgzDYMbKgwBMGhiFp5uztYFERGqRShXI06dPp2fPnvj6+hISEsLo0aPZs2dPdWUTsUZhFmz61Fzuo9ZjERGpXdbFprM7KQdPV2eu69HE6jgiIrVKpQrkZcuWcc8997BmzRoWLVpESUkJl112GXl5edWVT6TmbfoUinMgqA20vMTqNCIiIpXyyZpDAIzuGoG/l0auFhGpjEqN2LBgwYIKr2fOnElISAgbN25k4MCBVRpMxBJlpWb3aoC+d4PNZm0eERGRSkjOLmThjiQAburTzNowIiK10AUNaZiVlQVAYGDgafcpKiqiqKio/HV2dvaFvKVI9dr9A2TFgVdD6HSd1WlEREQqZfbaOErtBj2bNaBdhJ/VcUREap3zHqTLbrczefJkLrroIjp06HDa/aZPn46/v3/5IzIy8nzfUqR6FeXC6rfM5R4TwdXT2jwiIiKVUFxqZ/a6OABu0sjVIiLn5bxbkO+55x527NjB77//fsb9pkyZwgMPPFD+Ojs7W0WyOIbcFIhbc+yxGhK3glEGTq7Q83ar04mIiFTKwj+SSM0pItjXncvbh1kdR0SkVjqvAvnee+/lhx9+YPny5TRu3PiM+7q7u+Pu7n5e4USq3KHVsOUzsyg+uu/k7X6NYfAU8NUXCxERqV0+XW0OznVDrya4uWgmTxGR81GpAtkwDO677z7mzZvH0qVLiYqKqq5cIlUv/QD870qwlx5bYYOQdtCkDzTpaz4HqHeDiIjUPrsSs1l3MB1nJxt/66WpnUREzlelCuR77rmH2bNn8+233+Lr60tSkjlKor+/P56eul9THNza983iOKIbDHoEInuBZwOrU4mIiFywT461Hl/ePowwfw+L04iI1F6V6n/z7rvvkpWVxaBBgwgPDy9/fPHFF9WVT6RqFGbB5s/M5SGPQuthKo5FRKROyCooYf7mIwDc1LepxWlERGq3SnexFqmVNn0KxbkQHA0tLrE6jYiISJX5auNhCkrKaBPqS++o00+9KSIiZ6cRHKTuKys1u1cD9LkLbDZr84iIiFQRu93gszVm9+qb+jbFpmuciMgFUYEsdd+eHyErDjwDodN1VqcRERGpMr/vSyM2LQ9fdxeu7trI6jgiIrWeCmSp+1a/Yz73mAiuGkxORETqjk9WHwRgbPfGeLuf1+ydIiLyJyqQpW47shHi14CTK/S83eo0IiIiVSY+PZ/Fu1MADc4lIlJVVCBL3bbmXfO5wxjwC7c2i4iISBWatTYOw4D+LYNoEexjdRwRkTpBBbLUXdkJ8Mc8c7nPXdZmERERqUKFJWV8sT4OgJvVeiwiUmVUIEvdte4DsJdCk34Q0dXqNCIiIlXmu60JZOSX0CjAk0vahlodR0SkzlCBLHVTcT5snGEu973b2iwiIiJVyDAMPlxxADDvPXZ20tROIiJVRQWy1E3b5kBBBgQ0hTZXWJ1GRESkyizbm8re5Fy83Zy5oVcTq+OIiNQpKpCl7rHbTwzO1fvv4ORsbR4REZEq9MGx1uPrezXB39PV4jQiInWLCmSpe/b/Bml7wc0Xut5odRoREZEq80dCFiv3HcXZycatFzWzOo6ISJ2jAllql6IcOLTa7D59OmveNp+73QQefjWTS0REpAZ8uCIWgCs6htO4gZfFaURE6h4XqwOInDPDgM9vgIMrzNeBLaBRd/PRuAeEdoCMWLMF2eYEve+0Nq+IiEgVSswq4PutCQDcMSDK4jQiInWTCmSpPXbOP1Yc2wAD0vebj+1fmtudXMEzwFxucwU0aGZJTBERkeowc+VBSu0GfZoH0qlxgNVxRETqJBXIUjuUFMIvj5vLgx6BXpPgyCY4svHYYwPkH4W8VHOfvvdal1VERKSK5RSWMHttHAB3DGhucRoRkbpLBbLUDqvfgqw48GsE/f4Bbl7Qaqj5ALP7dWacWSi7+0HTvtbmFRERqUJfrI8np6iUFsHeDG4TYnUcEZE6SwWyOL6cJFjxqrk8dJpZHP+VzQYNmpoPERGROqSkzM6MlQcBuH1Ac5ycbNYGEhGpwzSKtTi+xU9BSR407gkdx1mdRkREpErEp+cTn55/1v1+2p7IkcwCgnzcuLproxpIJiJSf6kFWRxbwmbYMstcvvx5s6VYRESkllu2N5U7/rcBu2Fw35BW3D24Ba7OJ7dbGIbBBysOAHBz32Z4uDrXdFQRkXpFLcjiuAwDFkwxlztdZ07lJCIiUsut3JfGpE82UFxmp9Ru8J9f9zL23VXEJOectO+aA+nsOJKNh6sTN/bRbUQiItVNBbI4rj/mQdxqcPWCS56wOo2IiMgFW3PgKLf9bz1FpXaGtg3lP9d1xt/TlW2Hsxjx5u98sPwAZXajfP/jrcfjujcm0NvNqtgiIvWGuliLYyopgEXHiuKLJoO/7rkSEZHabf3BdCbOXE9hiZ3BbYJ5e3xX3F2c6dciiIe/3sbSPak8+9MuFu1M5uVrOlNcVsZvu1Ow2eC2/praSUSkJqhAFsdUYVqn+6xOIyIickE2xWVw64z15BeXMaBVEO/e2B13F/N+4lA/D2bc0pMv1sfz9A87WXcwnctfX07LEB8ALm0bSlSQt5XxRUTqDXWxFseTnQgr/mMun25aJxERkVpi2+FMJny0jtyiUvq1aMgHN/c4abAtm83G9b2asGDyQPo0DyS/uIxth7MAmDRQrcciIjVFBbI4Hk3rJCIidcSOI1nc+OFacopK6RUVyIcTTi6O/ywy0IvZt/fhiZHt8HJzZmjbELo3bVCDiUVE6jd1sRbHUZQDO7+DrbPN15rWSUREarHdSdnc9NFasgtL6d60AR/f0hMvt7N/9XJysnHrRVHcdGzUapuuhSIiNUYtyGKtnCTY8DF8Ng5ebA7f3m2u17ROIiLV4sknn8Rms1V4REdHl28vLCzknnvuoWHDhvj4+DB27FiSk5MtTFw7ZReWcOuM9WTkl9A5MoCZt/bEx71y7RIuzk64nGJuZBERqT5qQZaal7oXdv8Au3+EIxsqbgtsAW1HwsB/WZNNRKQeaN++Pb/++mv5axeXE18H7r//fn788Ufmzp2Lv78/9957L2PGjGHlypVWRK21pv+0m8SsQpo29OKTib3w9XC1OpKIiJwDFchSM0qLYee3sP4DiF9bcVujHhB9BURfCUGt1a1aRKSaubi4EBYWdtL6rKwsPvroI2bPns2QIUMAmDFjBm3btmXNmjX06dOnpqPWSqv2p/H5ujgAXhjbCX9PFcciIrWFCmSpXllHYOMM2Pg/yEsx1zm5QPNBED0CWg8Hv3BLI4qI1DcxMTFERETg4eFB3759mT59Ok2aNGHjxo2UlJQwdOjQ8n2jo6Np0qQJq1evPm2BXFRURFFRUfnr7Ozsav8Mjiq/uJRHvt4OwPjeTejTvKHFiUREpDJUIEvVMww4uALW/Rd2/wRGmbneNxy63wrdJ4DvyS0XIiJS/Xr37s3MmTNp06YNiYmJTJs2jQEDBrBjxw6SkpJwc3MjICCgwjGhoaEkJSWd9pzTp09n2rRp1Zy8dnjll73EpecT4e/BI8Ojz36AiIg4FBXIUrXy0+HTqyFxy4l1TftDrzvMFmNndTMTEbHS8OHDy5c7depE7969adq0KV9++SWenp7ndc4pU6bwwAMPlL/Ozs4mMjLygrPWNpviMvh4ZSwAz47pqPuORURqIRXIUrVWv20Wx67e0Pl66Hk7hLazOpWIiJxGQEAArVu3Zt++fVx66aUUFxeTmZlZoRU5OTn5lPcsH+fu7o67u3sNpHVcRaVlPPTVNgwDxnRtxOA2IVZHEhGR86C5A6TqFOfDho/M5avfgytfVXEsIuLgcnNz2b9/P+Hh4XTv3h1XV1cWL15cvn3Pnj3ExcXRt29fC1M6vrd+28e+lFyCfNyYeqWufSIitZVakKXqbP0cCjIgoKnZnVpERBzOgw8+yMiRI2natCkJCQk88cQTODs7c8MNN+Dv789tt93GAw88QGBgIH5+ftx333307dtXI1ifwc6EbN5duh+Ap0Z1oIG3m8WJRETkfKlAlqpht8Oad8zlPneDk7O1eURE5JQOHz7MDTfcwNGjRwkODqZ///6sWbOG4OBgAP7zn//g5OTE2LFjKSoqYtiwYbzzzjsWp3ZcpWV2Hvp6K6V2g8vbh3FFR83MICJSm6lAlqoR8wsc3Qfu/tB1vNVpRETkNObMmXPG7R4eHrz99tu8/fbbNZSodvvvigPsOJKNv6crT41ub3UcERG5QLoHWarG6rfM5x63gLuvpVFERERqwv7UXF77NQaAqVe2I8TXw+JEIiJyoVQgy4VL3GrOe+zkAr3utDqNiIhIjXjux10Ul9q5uHUwY7s1sjqOiIhUARXIcuFWH7s3rf3V4K8vCCIiUvel5hSxZE8KYLYe22w2ixOJiEhVUIEsFyY7AXZ8ZS73udvaLCIiIjXkh20J2A3o3NifliE+VscREZEqokG66qN1H8Af86FRV2jaH5r0Ac+A8zzXf8FeCk0vgkbdqjKliIiIw5q/JQGAUV3Uc0pEpC5RgVzfJGyBnx8GowwO/Q6r3gRsENYRmg2AZhdBk77gFXj2cxXlwoaPzeW+91RnahEREYcRm5bH1vhMnJ1sjOwcYXUcERGpQiqQ65OyEvjuXrM4bj4IAprAwZWQvh+StpmPNW8DNrNIHvk6BLc+/fm2fg6FWRDYHFpfXlOfQkRExFLfbjkCwEUtgwj2dbc4jYiIVCUVyPXJ6rcgaTt4NoAxH4JPsLk+OxEOrTQfB1dC2h6IWwXvD4Thz0O3CfDXwUfsZbDm2OBcfe4GJ+ea/SwiIiIWMAyDb491rx7dRa3HIiJ1jQrk+uLoflj6vLk87LkTxTGAXzh0HGc+ADLjzZbmA0vh+39CzCK46s2K3a73LoD0A+ARAF3+VlOfQkRExFLbDmcRm5aHh6sTl7UPszqOiIhUMY1iXR/Y7fDdP6C0EFoMgc43nHn/gEi4cR5c9gw4ucLuH+DdiyB2+Yl9Vr9tPve4Fdy8qy+7iIiIA5l/rHv1pe3C8HFXO4OISF2jArk+2PyJOSCXqxdc+Z+Tu0ufipMT9LsPbv8VGraCnAT431Ww6AmIX2d2x3ZygV6Tqj+/iIiIAygts/P91kRA3atFROoqFch1XXYi/PK4uTzkMWjQrHLHR3SBO5eZ9yFjwMrXYOaV5rYOY8FPXxBERKR+WLn/KGm5RTTwcmVg6+CzHyAiIrWO+gY5ooQtMP9ucPeFxj3M+YUbdYeApufW+vtnPz0IRVkQ0Q16//388rh5w1VvQMtLzK7ahZnm+j53n9/5REREaqFvN5vdq0d0CsfVWW0MIiJ1kQpkR5O0HT4dDQUZ5uv4NSe2eQWZhXKj7tC4OzS9CFw9T3+und+a9w87uZiDbF3oSNPtRpnvvfhpsyU6osuFnU9ERKSWKCguY+EfSQCM7tLI4jQiIlJdVCA7kpRd8Mkoszhu1AN63gZHNsGRjWbhnJ8GMQvNB4CrN7S5HNqNhlaXViyWCzLgp3+Zy/3vh7AOVZPRvzGMeb9qziUiIlJLLNqVTF5xGY0beNK9aQOr44iISDVRgewoUveag2DlH4XwLnDj1+AZcGIKpZJCSN5hFstHNprzFWcfhh1fm4+/Fsu/TIXcZAhqDQP/ZeEHExERqf2Od68e3aURtsre7iQiIrWGCmRHcHQ//G8k5KVAaEe4aZ5ZHP+Zq4d5P3LjHuZrwzBbl//4xuxKnRVfsVguyTP3G/kGuLjX6McRERGpS9Lzilm2NxWA0V01OKWISF2mAtlq6bFmcZybBCHt4OZvwSvw7MfZbOZ9yI27m/MVH9kIf8yDP+abLcsAPW+Hpn2rNb6IiEhd9+P2RErtBu0j/GgZ4mt1HBERqUYqkKtLWSmUFoK7z+n3yYwzu1VnHzG7Qt/8LXg3rPx72WwnWpcvewYOb4C0vdBx3PnnFxEREaBi92oREanbVCBXtbIS2DgTlk437yf2DYegVmYBHNT6xDKYLcdZcRDYAiZ8Dz4hF/7+NhtE9jQfIiIickHi0/PZcCgDmw1Gdlb3ahGRuk4FclUxDNj9I/z6BBzdd2J9TqL5iF3+lwNsgGFOlzThe/ANq8GwIiIici6+25oAQN/mDQnz97A4jYiIVDcVyFXh8Eb45TGIW2W+9gqCwVOg3dWQEWt2d07dA2kx5nL6ATDKIKCJWRz7q8uWiIiIozEMg3nqXi0iUq+oQD6dnCTzXl53H/AMNAfO8mwArl5mN2aAjIOw+Clz5GgAFw/oew9cNBk8/Mx13g1PjDx9XGmxef+xbyi4a7APERERR/RHQjb7UnJxc3Hi8o7q6SUiUh+oQP6rwxtg7XvmiND20pO3O7ubhbJXoNmVuqwYsEHnG2DIo+Df+Ozv4eIGQS2rPLqIiIhUDcMweH/5AQCGtg3Bz8PV4kQiIlITVCCD2aK7c75ZGB/ZeGJ9SDvz3uKCdMhPB3sJlBWZUzLlJpn7RF1sjhwd3smS6CIiIlL1Pl1ziO+3JuDsZOO2/lFWxxERkRpSawvkotIyYpJzaRbkjY/7eX6M3BTY8LH5yE021zm7QYdx0PtOiOhyYl/DgOK8E8VyQYbZjTqi24ku1yIiIlLrbTyUzlPf7wTgkcuj6d400OJEIiJSU2ptgXzwYCxfzXidElzw8PAgwMebhv4+NPT3ISTA13z4e+NanGkWwrkpZhH85+ecRHOwLACfMOh5O3S/BXyCT35Dm828H9ndxxxcS0REROqclJxC7p61iVK7wYiO4dw+QK3HIiL1Sa0tkItT9vGk6yfmizIg69ijshr3MluL215l3hssIiIi9VJJmZ17Z28mObuIliE+vDCuEzb1EhMRqVdqbYHcsVUUJIylpLiI/IICCgsLKC4qoqS4kLKSIuylxTgbpWThTaoRQKrhbz7jX/46hUB8c5rQcVcAHbOP0LGxP+3C/fF0c7b644mIiEgNe3HBbtbFpuPj7sJ7N3Y//1u4RESk1qq9v/mD28C4j3EF/I89/swwDFJyisjKyKcoo4DsjALSMgs4klHAkYx8DmcUUFRqJzE5l73JuXy9yTzOyQatQnzp0Mifjo38aB3qS8sQH4J93fVXZBERkTrqh20JfLAiFoCXr+lEyxAfixOJiIgVam+BfBY2m41QPw9C/Tzo3vTk7YZhkJxdxI4jWWz/0yM1p4g9yTnsSc4pL5oB/DxcaBniQ6sQs2BuGepD+3A/Qvw8au5DiYiISJWLSc7hoa+2AXDnxc25vEO4xYlERMQqlS6Qly9fzksvvcTGjRtJTExk3rx5jB49uhqiVS+bzUaYvwdh/h4MbRcKnCiajxfLOxOy2JeSS1x6PtmFpWyKy2RTXGaF83SODGB4hzCGdwijaUNvCz6JiIiInK+cwhLu/HQj+cVl9GvRkH9d1sbqSCIiYqFKF8h5eXl07tyZiRMnMmbMmOrIZJk/F82XHiuaAQpLyohNyyMmJZd9KbnsS8khJjmXfam5bI3PZGt8Js//vJu24X7lxXKrUF8LP4mIiIicjWEYPDh3KwfS8gj39+CNG7ri4uxkdSwREbFQpQvk4cOHM3z48OrI4rA8XJ1pG+5H23C/CutTcgpZ+EcyC3YksuZAOrsSs9mVmM2ri/bSItibga2DaRHsQ/Ngb1oE+xCi+5hFREQcxhfr41n4RzJuzk68e2N3gnzcrY4kIiIWq/Z7kIuKiigqKip/nZ2dXd1vWWNCfD24qU9TburTlIy8YhbtTGbBH0n8HpPG/tQ89qfmVdjfx92FqCBvmgd70zzIh8YNPAn2dSfEz50QXw8CPF1xclIBLSIiUt0Kist4ddFeAP41rA1dIgOsDSQiIg6h2gvk6dOnM23atOp+G8s18Hbj2p6RXNszkuzCEpbsTmH74SwOpOVxIDWX+IwCcotKy+9vPhVXZxtBPu6E+LoT7OtBl0h/BrUJoX2En1qeRUREqtCMVbGk5BTRuIEnN/c7xWieIiJSL9kMwzDO+2Cb7ayDdJ2qBTkyMpKsrCz8/PxOe1xdU1xqJy7dbFU+kGoWzUnZhaRkF5GaW0R6XvFpjw32dWdQ62AGR4fQv1UQfh6uNZhcRKRuy87Oxt/fv95dl6qTo/9Ms/JLGPDib2QXlvLqtZ0Z062x1ZFERKSaneu1qdpbkN3d3XF31z09bi5OtAzxpWXIqQfvKi61k5ZbREpOESnZhRzJLGDV/qOs3JdGak4RczceZu7Gwzg72ejetAGD2gTTOyqQ9hH+eLg61/CnERERqb3eWbaP7MJSosN8GdWlkdVxRETEgdTZeZBrGzcXJyICPIkI8Cxfd+tFURSVlrE+NoOle1JYsieF/al5rItNZ11sOmB2y24X4U+3JgF0a9KArk0CaBTgqS7ZIiIip5CYVcDMlQcBeOjyNjhr7A8REfmTShfIubm57Nu3r/x1bGwsW7ZsITAwkCZNmlRpOAF3F2f6twqif6sgHruyHfHp+Szdk8LymDQ2x2WQlltcPtXUjGMX/BBfd7o3bcAVHcO5tF2oWphFRESOeWNxDEWldno1C2RwmxCr44iIiIOp9D3IS5cuZfDgwSetnzBhAjNnzjzr8Y5+X1JtYhgGhzMK2BSXwea4TDbFZbAzIZtS+4l/Ul8PF67sFMHYbo3o3rSBWpZFRP5C16Wq5zA/07yj8M3t0Ho49J7E/tRcLvvPcsrsBl/f1ZfuTQOtyyYiIjWq2u5BHjRoEBcwrpdUIZvNRmSgF5GBXuX3UBWWlLH9SBbL9qQyb/MRjmQW8Pm6OD5fF0fThl6M6dqYMd0aERnoZXF6ERGRarbmHdj/GyRth1538PLCPZTZDYa2DVVxLCIip3RBo1ifD4f5q3I9YLcbrIk9yjebjvDT9kTyi8vKt/Vs1oBL2oYyuE0IrUN91LIsIvWWrktVzyF+piUF8J/2kH8UgJ3X/s4Vn8Rhs8HCyQNpHXrqQTNFRKRucphRrMU6Tk42+rUIol+LIJ4a1Z4FO5L4ZtMRVu5PY/3BDNYfzOD5n3cT4e/BoOgQBrUO5qKWQXi76z8LERGp5bbPLS+OARYv+hHoyJiujVUci4jIaakSqie83FwY060xY7o1JiGzgEU7k1myJ4XV+4+SkFXI7LVxzF4bh5uzE72iArmkbQhXdoog2FdTdImISC1jGLDmPXPZwx8Ks/BO3Yybc2fuv7SVtdlERMShqUCuhyICPJnQrxkT+jWjsKSM1QeOsnR3Cr/tSSE+vYDf96Xx+740nvlxF/1bBjGmWyMubReKl5v+cxERkVrg4ApI+QNcvbAPehSnBQ/RxWkfN/VqSuMGGoNDREROTxVPPefh6szgNiEMbhPCk4bBgbQ8luxO4YdtiWyJz2TZ3lSW7U3F282ZYR3CGNO1MX1bNNS8kSIi4rjWvGs+d/kbS8o6cwnQwXaQZgMiLY1Vqyx/GQ6tgmv/B+7qki4i9YcKZClns9loEexDi2Afbh/QnAOpuczfksD8zUeIS8/nm01H+GbTEUL93Lm+ZxMmDWyu+5VFRMSxpB+APT8DcKjlTTz9bTpdDF8a2nIIzNkD/j0sDlgL7F8Cvz1tLu/+CTpfZ20eEZEa5GR1AHFczYN9eODS1iz71yC+vqsv43s3wd/TleTsIl5fHMOgl5cyZ10cZXZN+yUiIo4he9nbgMF6l25cPOMIB9ML2Ol07L7jwxsszVYrFOXC9/848Tp2mXVZREQsoAJZzspms9G9aSDPXt2R9Y8O5c0butKsoRepOUU88s12RryxghUxqVbHFBGRSnr++eex2WxMnjy5fF1hYSH33HMPDRs2xMfHh7Fjx5KcnGxdyHMQn57Pe8v2c83rC7FtmQXAm/mX4upsY0h0CK26DTF3PLzewpS1xG9PQ2YcuHiYrw8sMwc9ExGpJ1QgS6W4uTgxsnMEv9x/MY9f2Q5/T1d2J+Vw00fruGXGOmKSc6yOKCIi52D9+vW8//77dOrUqcL6+++/n++//565c+eybNkyEhISGDNmjEUpz6y0zM6tM9Yx4MUlPP/zbtqn/ICvrYAjLpFcOfpGNjx6KR/f0pOwdheZB6hAPrO4NbD2fXN53Mfg7AbZh81u6yIi9YQKZDkvbi5OTOwfxbJ/DWLiRVG4OttYuieVy19fwaPztpOaU2R1RBEROY3c3FzGjx/PBx98QIMGDcrXZ2Vl8dFHH/Hqq68yZMgQunfvzowZM1i1ahVr1qyxMPGpbTuSxZI9qdhs0C8qgP/zXwJAo2GTubZXE/y9XM0dG3UHbJB5CHLV4+mUSgrh23sBA7rcCNEjoHEvc9uBpVYmExGpUSqQ5YIEeLnx+Mh2/HL/xQxrH0qZ3WDW2jgGHvtrfkZesdURRUTkL+655x5GjBjB0KFDK6zfuHEjJSUlFdZHR0fTpEkTVq9efdrzFRUVkZ2dXeFREzYezADgkuhQZg/Kxjc/3pz3uPMNFXf08IfgNubykXpyH3L8evhwKGyZfW77L3sBjsaATygMe8ZcFzXQfI5dXrn3Li2CL26CX6Y6Xvdsw4CFj8LcW6BU31FEWP4SzLoWCjKsTuIwVCBLlYgK8ub9m3rwxaQ+dG7sT0FJGe8t20//F37jlV/2kJVfYnVEEREB5syZw6ZNm5g+ffpJ25KSknBzcyMgIKDC+tDQUJKSkk57zunTp+Pv71/+iIysmemUNhxKB6BHswaw5h1zZbcJ4OZ98s6Nj41eXV+6WW/42Pys8++C7+6DkoLT75uwBVa+bi6PeBU8j/UqaH6x+Ry7HOz2c3/vmF9g13ew6g34Y955xa822+fC6rfMXPt/szqNiLUyDsGS5yBmISx8zOo0DkMFslSp3s0bMv+ei/hoQg/aR/iRV1zGm7/to/+Lv/H6rzFkF6pQFhGxSnx8PP/85z+ZNWsWHh4eVXbeKVOmkJWVVf6Ij4+vsnOfjmEYbDxktngM8Es2izibE/S649QHNDpeINeTFuQ/t5Rv+gQ+uvTU9xKXlcB394JRBu2vhrZXntjWqDu4+UBBOiTvOPf33vntieWf/gV5RyufvzrkpsLPD594/eecIvXR+g/AOPbHry2fwb7F1uZxECqQpcrZbDYuaRvKD/f1570bu9Mm1JecwlL+8+teBrywhLeX7GPV/jQ2x2WwJymH+PR8UnOKyCsqxa4po0REqs3GjRtJSUmhW7duuLi44OLiwrJly3jjjTdwcXEhNDSU4uJiMjMzKxyXnJxMWFjYac/r7u6On59fhUd1O3Q0n7TcYtycnWhz0By5mrYjIaDJqQ9o3NN8PrIJ7GXVns9SBRmQttdcHvcxeAVB0nZ4fxDs+qHivitfM7d5BsLwlypuc3aFpv3M5XOd7qm0CPYsMJe9giA/DRY8cr6fpGr9/C+z2PcKMl/v+VHdrKX+Kso1/3gGx8ZpAL6fbK6v51ysDiB1l81m4/IOYVzWLpSfdiTy2q8x7EvJ5aWFe854XAMvVx64tDU39mmKzWarobQiInXfJZdcwvbt2yusu/XWW4mOjubhhx8mMjISV1dXFi9ezNixYwHYs2cPcXFx9O3b14rIp7XhWOtxvwhw+eMrc2Xvu05/QEhbcPWG4hxI3QOh7WogpUWObDSfG0RBh7HQpC/MvRXi18AX46HffXDJE3B0Pyx70dx3+AvgE3zyuaIuNrtMH1hmHnc2+5eYP2PfCLjuU7PlevuX0HEctB5WdZ+xsnb9YHartjnD+Lkw+1rIS4WDy6Hl0LMfL1LXbP0cCrMgsAXc/C2828+c4m3xNLjipbMfX4epBVmqnZOTjSs7RbBw8kBeu64LvaICaRXiQ+MG/9/enYdHWV0PHP/OZN83yEYWQtiXsAQIARTZRFREBLV1w60ugBWx/tS2rrWFSiuooFjbirUqigqIWGQPskMA2QMESNiSEAJJyJ7M+/vjzmQh28xkkslyPs+TJ+/MvPPOzc3AzZl77zluBHg44+bkUOX8K/klvLLiML9fdpDiUgv2PAkhhKiTl5cXvXv3rvLl4eFBQEAAvXv3xsfHh8cee4xZs2axceNGEhMTeeSRR4iPj2fIkCH2bn4VpuXVD7tsgtJCCOkLEXW0Ue8AHQao49aeqOucMUA2zZp7h8LDP0D8DHV72/vw6QRYMQ3KiqHLOOhzd83XMu1DTtmmlmPX5+j36nuPCWrf95Bp6vbKmeqPcXsouAKrZqnjYc+q90F341LyI9/bp01C2JPBUFHSLe5JcPGCCe+p27v+ASm1J2VsC2QGWTQZB72OO/t34M7+Hao9pmkahSUG8otLWZp4jr+uPsaXu85yPP0aHz4wgEAv2+2VE0IIUbt58+ah1+uZPHkyRUVFjBs3jg8++MDezaomMSWLEC4zJPNbdceQaVDfqqOwgXDmZ5W8asBDjd9IezElIjMFyKCWS4/7M4THwYrpkGr8A9jFG26fV3vfBfYC9wDIv6xmpuv6EKKsBI6tUsc9J6rvI/8AST+q/c9rX4UJ79bf/mOrYOciGPEidBxe//n1+emPcC0d2nVV1zS1L/ETOPaDSkzmIH8SN7qd/4BTG2HyP2tOpCeaTvIGlbXexRv63afuix4J/R+EfZ+pvARPbQEnN/u2005kBlk0CzqdDjdnBwI8XXhqRDSfPDwIL1dHElOucMf7Wzlw7qq9myiEEK3Spk2bmD9/fvltV1dXFi5cSFZWFnl5eXz33Xd17j+2h+z8EoIvbWWVy8u4Fl4Cn3CVYKo+poCxNSfq0rRKAfLA6o/3vAOe2ARBvdXtW2aDT/UPrsvp9dDxBnV8qp59yKc3Q+FV8GhfEUg7u8Md76vjxMV1l4wqK1WloZbcp877YVbDy0SdXK+SD6GDOxaAk/ED947DVbbu/MuQuq1hryHqdy0D1hg/LDmx1t6tEaas//0fVLPHJje/BV4hcPkkbJpjn7Y1AxIgi2bppm6BrJg+jOj2HqTlFHL3ou0s23fO3s0SQghhb4Yysla9wWKnt/HXXYPgGJi6Ehxd6n+uKZN1xlEoym3cdtrL5WQVpDq4VATB1wuIhicSYOZB6P9A/dcsL/dUT4BsygrdY4Ja0m7ScTgMfFQdf/8MFOdVf25umlr2vc24zFPvCJlJDSvFVHRNLe0GtYw0Iq7iMQcn6H5b1XaLxrPn32o5P1iWEV3Y3qUkSF4P6Kpn/XfzVSsqQP1bPL+3qVvXLEiALJqtTu09WTZ9GKO7B1JUauC5r37hLz8epcyY6bqotIzDF7L5NvEcf151hAf/tZOBb63jprkbWXO49nqdQgghWqi8TPh8ClGH30ev09juNwEeWwv+UeY93ysIfCIArfX+4WfaXx3aDxydaz/PwbH2jN/XizIGyGd31Rzcgpr9NS2v7nFH9cfHvAHeYXDlDGz4c9XHTm+GRTeomVxnL7jnPzDocfXYzkXmtbEm69+A7FT1c456pfrjPYzLwI+utKzOs7BMaRHs/lfF7bSDtZ8rGp/p31T322r+v7P7rSq5n2aAFTPaZKZ32XAhmjVvVyc+fmgg76w9zoKNJ/nH5lNsOZFJSZmBU5l55cFyZZnX4InPEpnYL5TXJ/TCz6OOPxCEEEK0DGd3wdKHIec8RbjwUvGjxMVPI97JwhwVYQNV0HRud8XMaGtS0/7jhvLvpJaxZ5+F1B3QeXT1c1K3qZJObv417xt29YYJ8+HzKWp5Z69JqrTM1nmw4S31x3hQbxUcB0Sr450fqQzamSegXRfL2pyyTSUbApV8yMWz+jmdRoCLj9qffHYnRDavTO2txuFlkJcBeicwlEiAbE8FV+CXJeo47qnazxv/NpzaBBmHYcs8uOnF2s9thWQGWTR7er2O343rxoL7+uPm5MCRizmcyLhGmUHDx82JuCh/Hh7akTl39WHZtKFMuykavQ5W7L/A2HkJrD500d4/ghBCCGtpGuz4ED4ZDznn0fw7M6XsLZYZbmBgRz/Lr1deDznRtu1sLkwBsqmuqS3odBWzyLUtszYtU+5+q1q+XJMuY6HvrwFNJQr78lew/k0VHPe7X60GCIhW5wZEQ9db1LEp2665SgrUzBeoPZbRI2s+z9EFuhlf46hks24Umlax33Wo8XeScx7ys+zXprZs73+gJF99AFVXAjyPdipIBtg8F9KPNE37mgmZQRYtxu0xofQM8WbLyUzC/dzpHuJFsLdrtVrJ/SP8GNcrmBe++YXj6dd46r97uT0mhDfu6EWApxl71IQQQjQPhTkqm6op+Oo1iYMD3uLgx7/g6+5Ep3Y1zArWx5S46txu9cd7fZmvW5LifEg/rI5tOYMMEHWjSnZVU6Iug0EtUwboeWfd1xn3F5U4KzNJfTm6wq1/gwEPVj93yFNw/H+w/wsY9Ue1P9Icm2ZDVrJKNnTzW3Wf23MiHPhKlXsa9xf7vx8OfQf7P4c7PwTPQPu2xRZSd8DFX9TvOf4ZOLwcrpxWs8iWrOAoK1VlybxDVQ1ve/+empOUbeo9P/DRupMVlpWqTOIAQ56uvw97T4ZD36rEaotvVcn37OWG30Hfe5vs5SRAFi1Kp/aedGpf/x9EfcN9WfnMcN5ff5IPE5L54cBFtidf5k939ubWPiFN0FIhhBANVpKv6nHqjSWKBj/Bri2nAYiN8EOvt+KP5OAYdb28S3A1Bfw62rbN9nTxFzCUgmcw+ITZ9tpRN1a8Rn4WuPtXPHZ2p1qm7OJTMdNcG3d/VVbq6wfBN1ItqQ6JqeU1R0BgT8g4okrPDH2m/nae36vqPINKNlRfUB09Cpw8IOecem6YDWfeLaVpKot3zjnY/U8Y+Xv7tcVWTLPHMfeARwAE97EuQD63S32QAerfcO+7bN/WlqjgKix9BK6lqb38qTtg7J9qzj9w7Af13nJvB72n1H9tnU79G0rdrpZmF1yxefPNVni1SV9OAmTRark4OvC7cd3KZ5OPpeUy7fO9TOgbypy7+uDhIm9/IYRo1ryC4Z5PVUAbrmZEE1PUH2mx1iyvBlXmJyRGLbE+t6d1BciVyzvZeobNOwTadVOzvme2qHJRJqblyd3G150YzKTH7fDsATVDWlf2cZ1O7ZNc+Vs18xX3dN31ikuL1dJqzaBmv7rfWn9bnNyg6zg4/B0cWW7fAPn8XhXAgJrRbukB8tVUFZSB+t2BCpCPfm/5PuTKpdl+fEF9eOIRYJt2tmRr/qCCYzc/FcDuXKT+b7t7cfUPyUzJuQY+UlHurD7eITBtpyr7ZE/mJmK0EYkQRKvXJ8yH72cMZ8GGE3ywKZmVv1zgRHou/5w6kDA/d3s3TwghRF0ih5YfaprGHmOAPDDSv7Zn1K/DwIoAuY8ZMykthSmDdU31j22h0wgVIJ/eXBEga5oK5qBq0Fwf33Dzzou5B9a9rhKrJf1Y92tsmaeSCrkHVOyfNEfPO1SAfPR7GPum/ZbvHllecXzpKFw6Du272qcttrDrY/VhRdQICOqp7gvuo75bWurJ9OEPOpUMbvVLMPljmzW1RUreAPuMNb5/9aWaZV32pOqrRTeo/uk8Rp17YZ+aCdY7wcDHLHsdryD11YZIki7RJjg76pl1cze+ejKedp4uHEvLZeKCrew+I0kihBCipTibVcCl3CKcHHTEhPlYfyHT/tzyP7pbCdMsm633H5vUlKjLNOvp7KmWK9uak5ua8YK6Sz6lH1HJhEAFxx7tzH+NzmPB0U2VoEo7YHVTG0TTKmbiXYzv7aMtuD5zcR7s/VQdD3m64n5TgHzpmCr/ZC7Te3vsm6DTw8Gv4fhPtmlrS1R0Db5/Vh0P/o3KwN5tPDy5GUL6QkEW/HcKbPwLGMpgh/HfTq9JalZY1EkCZNGmxEb68f2MYfQK9eZyXjH3fbyDr3an2rtZQgghzLAnRX2o2buDD65ODtZfyDTDmnbAsj/Sm7Ps8yo7sE4Pof0b5zU6DlfXzzwOORfUfaZZzy43q2C2MQx6HPSOkLJV7YG+nqFMJXMzlEDX8Wp5tSVcPCtKV5lmw5ta2gEVoDu6VSytPtKCA+RfvoTCbPCLgi7jKu737qCWAxtKVZBsjuzzkHtBvfcGPQbx09X9K2eq12iL1r+pVlX4RKikZSZ+HeHRNSphFxok/BX+M1El24KqH1aIWkmALNqcUF83lj4Vz219Qigp03jx24O8ufIIpWUGezdNCCFEHSqWV1u5/9jEr6NKVFNW3HpqspqWVwf2AmePxnkNN181OwVqmXXlWc+eExvnNUFlLjZdf0cNs8g7PlBL5l284fZ3rFsibcq+fWSF+rmamikw7zxaLSvXOaj3ZtYp86+hafD9b2FhXN1fm+Y0zs9gYjBU/J7ingJ9pXBDp1MlhsD8f3um93aQ8b190+9Vbe7cC7D2Vdu0OXkjLL7d+v8P1r2hkmUV59umPXVJ3VGpxvf86jW+nVxVIrxJH4GTO5z5WX14FB4HHQY0fvtaAQmQRZvk7uzIgvv689wYtbfn31tP88ji3WQXlFQ7t7TMwNmsfLacyOTr3WfZm3qFMoMdBk8hhGjjEs8YE3Q1ZP8xqD/SK5d7ag3ONfL+YxPTMutTCVVnPbuMbdzXHTJNfT/0DVzLqLj/cjJsMJZyuvktFUxbo+s4cHCGyyfMn9m0FU2rmC3ueafK9B11g7ptyYz2qU1qWfOlY3V/bZoNJ9fZ+qeokLxB9aOLN/S/v/rjwcas5Wlm7kMur+1tfG87u8MdC9Rx4mL1YU1DaBr870UVSH7zmOWrSo6sgC3vqH3sG//csLbUp6TQWONbg34PVKx8qEnfX8Hj6yGgC6CD4bMat22tiCTpEm2WTqfj2TFd6Brkyayvf+HnE5lMWriV++IiOJuVz5nL+aRm5XM2K5/S6wJiP3cnRnRtz8jugdzYpT1+HmZk7RRCCGG17IISjmfkAmq7TIOFDYTjq6tmx23JGnv/sUmnEbB1vtqHbNrL2GVM481am4QNNCZX2wN7/g03vaRmKr//LZQWqsB9wEPWX9/VW+2hPr5aBTyBPWzX9vpcOqYCSgdnFagD9LhDBbxHv4fhM827zo4P1fc+99RcVxpUqaR9/1XLk6dtBxevBja+BjuN7ej/QM3XN+1DNne29lyi+l75vd1xmEo2tedf8P0z8PQ269+DyRtU8jlQ3zfPVXW3zZGfBat+V3F7xwfQ667Gy4aeMEe9VzyDYFw9Nb5BJUd7epvKdO0b0ThtaoVkBlm0eeP7hPDN0/GE+rhyKjOPt1Yd5dPtKSQcv8TpzDxKDRrOjno6B3oyNDoAL1dHruSXsHz/BZ5dsp/Yt9Yy+cNtLNhwgkPns9HssTRLCCFaub2pV9A06BjgTnuvOkoDmas1JeoqK1FZaqHxZ5DDh6hALuc87PlE3WdantzYTPsnd/9LzfIlfgIpW9Qy0jvea3j2adMy7qbeh2yaPY4epQJ1gB4TAJ1aOn71bP3XuJwMJ35Sz7npJVW3uqavW/6qAqXss2pZsK1dOm6cndbB4CdqPqdygFzf30xV3tvXffgz5nXwDlOrGDY0YObW9MGCaWZ7yzzzg/effg95GaoEWq9JKmv3iumNk9vgwn7Y+p46vu0dtZfbHI7OEhxbSGaQhQB6hfqwYsZw/r4miZzCEiIDPIj0dyciwJ2OAR4Ee7ui16uBt7TMwN7Uq2xMymDjsQyOpeWSmHKFxJQr/G3NcXqEePPosI5M6BvasCQyQgghytlsebVJ6ABAB1dT4Nol8Gxvm+vaQ8YRKC1Q2Y8DujTuazm7q72MZ35WmXIdnFWCrqbQcyKs+SPkXoRt78GWd9X9o1+zTT3rbuNVMrCMw5B5Etp1bvg1zWEKyHtUKmHlGahKnKVshaMrIX5a3dfY+ZH63uVmCIiu/TwXT5jwHnx2J+z+GHrfVaWUWoOZMo13u7X22rXtuqpyQ0XZqlayX2Tt10s/XOm9fd3vw9UbJrwLn082ztxOKq+XbrbME3ByLaBTtYPXvab6e8V0eHxD3XW3T6xVycjQwcQF4B8Np39WJbp+fgdGvmxZW+pSVmKs8V2mfs4et9vu2qIamUEWwqi9lwtzJsfwwf2xvHhLd341OIKh0e0I9XUrD44BHB30DI7y58VburN65o1se2kUf5nUh7E9g3B10nP0Yg4vfHOAYXM28M6aJDJyCu34UwkhROtgymA9sKMNlleD+uO6fXd1fL6FL7M2zYKHxVZNiNRYom6sOI4eXTHr2dgcnFRGa1D7jotzVbBe20ylpdz8KvZYN1WJpcyTKiDXO6oAvbLyGe162lKYDfs/V8fmZCmOHgn9jUuwV8yAkgLL2lybgivGgBEY8lTt5zk6Q6Dx31599ZDLa3vX8t7uMgb6/hrQrJu5NQX0XW9RHyzc+ndw9VXZ0re9V/vzCnPUMnVQfR4+GDwC4FZjqbGf/6aCe1vZMh/SD4KbP4yfa7vrihpJgCxEA4X6unFfXAQfPzSQHS+P5sVbuhPi48rlvGLe23CSYX/dwHNf7efAuav2bqoQQrRIJWUG9p+9Ctggg3VlpuXIZ3fZ7pr2YNp/3KGRl1ebmIJIgJ531H5eY4h9BBxd1bGDi0rWZMsPBUw/z+Fl1mWzzjwBn94BR38w73xTIB51o0rOVVmPCer72Z2Qc7H2a+z7LxRfg/Y9oNNN5r3uzW+BVwhkJaukXbaw9zMoyVdZqjveUPe55Ym66lnKbM7e+nF/AY/Aiv3D5iq4CvuvC+i9guAWY39smqN+nzVZ97qq/+3Xsep+5V6ToPvtqozViulQVlp/OzJPwOd3wwdDa/9K+Ks6d/zbLXu1SwshAbIQNuTr7szTN0Xz8/+NZOF9A4iN9KOkTGPZvvPcsWArkz/cxuc7U8jKK7Z3U4UQosU4ciGHwhIDPm5ORLf3rP8J5gofrL6nbrfdNe2hqRJ0mXQYoOqvugdUn/VsbB4BMGCqOh71B2jf1bbX7367CrzTDsIvSyx7blkpfPcblcBs2VOQfa7+55Rnr66hTJZ3KIQNBjQ4VkvAbSirmAWNe9L8fdhuvmofK8C29+H8XvOeVxdTfw1+ov52mFvq6foM1jVx94fb/qaOt8yDiwfqbyvAvs+gJA8Ce1b90Kfvr6HzGCgrUjPshuvKgJ7ZopKDgVquXjk5mE4Ht/0dXH3U3ukdC+tuw6Hv4B83wYk1aiVBbV+GErVsvc8U83420SASIAvRCBwd9NwWE8K3Tw/l+xnDmNS/A04OOhJTrvCHZYcY9Od1TP33Lr5NPEdOYfXSUkIIISqY6h/HRvpV2fLSYKalwud2Q9E12123KeVnqay20PgJukwcnOCJTfD0dvMTBdnSuD/DtB0w7FnbX9ujnUpyBbD6JchNN/+5OxZWJJQqzoUfnqt7FvrKGbWUV6dXgXlNTDPatS2zTvqf2sfr5gcx95rfVoDut0LvycbEUjOgtAEf3ldeKm7OqgJzMlnnZ8Hlk+q4vvd2z4lqD3f5zG09f1uVlcJOYy3huKeqBvQ6Hdw+H5w94ewOtVfbpDhfZc0G9UFNp0qBtYlXsJrVBtj4F9U31ysthh//D755RM3+d7wBHvgOHlpR89fDq2DKJw1PRCfMIgGyEI0sJsyXeff2Y8uLo3hpfHd6hXpTZtBIOH6J55f+wsC31vHkZ3v44cAF8ovNWIojhBBtTKJx/7FNyjtV5tdRZXc1lLbcWWTTzJ9/dPUluo3JI0AtR7UHB6fGLcM09LcQ0hcKr8KPv6v3dEAFQRuNQdGwmSp52Yk1cODr2p9jSs4VOUwF5jUxJe5K2aqSyV3PNHsc+7BKoGap8W+rlQAZh9Xsq7XKl4qPMO9Dk2DjDPLVFLXUuSaWvrdv/ZvaP5x2oO79wwBJP0J2qtrTG3NP9cd9w1WWbFDZvq+kqONNf4GsU+AVCjf/qfbr97tfZSUvLVQBdeVZ6Ktn4ZPxsMuYWG34LHhwuapp3Ommmr86Dgcn13q7QNiGBMhCNJEgb1eeGhHNqt/ewPrnR/DcmK5Et/eguNTAT4fTmfHFPuL+sp7PdqRgMFix70kIIVohTdPYc6ZiBtnmTEsrTyfY/tpNoTxBVxPNHrcFDo4wcaGaDT36ff1JsgwGFQSVFqqgaMzrMOL/1GOrX4RrGTU/r67l1SZ+kRDST83yXr/M+uIBlU1c5wCDfmPOT1adRzsVJIPav5t+xLrrlP8sZu5Jd/NTy/Sh9mRWlr63vYLgljnqeNNfVcmp2pg+WBj4CDi51XzOwMfUhxclebDyt6oe83bjkunb56ll1LUxzUI7eUDqtool2SfWwUc3qORjrj7w669gzGt1Z8sWTU4CZCHsILq9J8+O6cK6WSP437M3MH1kNOH+buQWlvLK8kNMWbSNpLRcezdTCCHs7tyVAjJyi3DU6+gb5mv7FzAlNTrVQgPk8028/7itCO4Dw59Tx6t+p5b71mbPv1QQ5OShgiKdTs0iB/dRmZ1/fKH6c7LPGX93utqXV5uYAuij19VnNpV26jkRfDqY8UPVovdk6Dpe7XP9foba12wJc5aK1yS4nn3I1ry3+/6qYv9wbT/LxV/UjLzesSIrek30erjjfZUU7tQm+K+xznGfe6DbLfW3xS+y0iz067D69/D5FPWeCOkHT2427zqiyUmALIQd6XQ6eoR488K47mz63Uhen9ATD2cH9qZe5bb3fubt1ccoLLFwoBJCiFbEVN6pVwcf3Jwboba8aR9y2sG6g6DmyGColKBLZpBt7sYXVCmwvAz46fc1n3M1VQU/oIIhU01fByc1C61zgCPLVW3dyky3w+PAO6TudpgC5NObK96j1y7BQePybXNKO9VFp4Pb3wEXbzifWDG7ai5zlorXxLQPOb2GANna93aV/cM7YdfH1c/ZYfz5ek5UidDqEhANI42/+8JscG9XMUttjkGPQ0S82me8YyGgwcBH4dGfbFO7WzQKCZCFaCYc9DoeHhbFuudHcHPPIEoNGh9sSmbc/M1sOZFp7+YJIYRdmJZX27S8U2WegSqLLZoKQFqSrGS1T9bRtSIrsLAdR2MZKXSqvu+JtVUf1zRVC7f4mgqCrp+NDOlbkUhs1fNq5tDEFFTWtbzaJCBa/X4NpSopF0DiJ1BWDB1ibbN6wDsUxr6pjrfMs6ye8FELfpbK6krU1ZD3tm84jH1DHa9/Q81wm1zLgEPfqOMh08y73pDpFX1829/V/ntz6fXqPeTsCU7uMOkfanm27Cdu1iRAFqKZCfFx4x8PDWTRA7EEe7uScjmfB/61k+e+2k/mNQsGLCGEaAUSUxo5QIaKWeSWtg/ZNMMW0k/NWArbCx9UEUitfBYKcyoe++VLSF5vrMf8fs31mEe8CO26wrV0+OkP6r7c9IqkcKZax/XpUSmbdWkx7P6nuh33tO0yG/d/QCWfyrukyg+ZI/u8ca+wzvyfxcQU+GYcrZ512rT/2Nr3duyjxv3D+er3Zsomvuffxg8WBpo/M+3gqJJoTd8Fve60vC3tOsOM3TDzEPS1MNO4sAsJkIVopm7pHczaWTcyNT4SnQ6W7TvPoD+vY/TfN/Hskn38Y3My205mkp0vZaKEEK1TdkEJSekqH0Nsx8YMkI2JulraPmRJ0NU0Rv1RLYfNOQ/rXlP35abD6pfV8ciXoV2Xmp/r5FoxC73/czi5Do6tBDQ1++sbbl4bTLOzpzbC3k9VwO0ZbPmsbV0cnGCwMdnXjg/qLlFlYloqHjFElTeyhG+kWtZdVgyZ1yXUaujWgev3D+/7TM2K7zYmy7J0WbqLJ7TvZl1bQM3QWzLzLOxKUqYJ0Yx5uTrxxsTe3Nm/A6+uOMzB89kkX8oj+VIeK/ZfKD8v3N+NXiE+3Ni1PXcN6ICrUyPs0xNCiCbm5eLITzNv5PCFbAK9GnFJYsdhKsFQVrJKnuQT1nivZUsSIDcNZ3cVbH06Qc1A9rpLlegpvKpmOOOfqfv5EXEQ96Ta27tyJngZ9xxbEtwGdod23SAzCdb8Ud03+HFwdLbiB6pD7MOQ8LYqlZS6HSKH1n2+OZm4a6PXq1nk1G2QdgiCelU8Zov3dkC0+nBjzR/hpz9C/mW1n9wrxLYfLIhWR2aQhWgB+kf4sfKZ4ez+wxgWPzKIF8Z1Y3zvYCL8Vc3Ds1kFrD6cxu+XHWTonA3MW3ucy7IcWwjRwun1OroGeTGpfyMHrK4+EDpAHbeUfcjF+RXlcSSDdeOLulEFjwBfPaBmTvWOMHGBeSV6Rr2iam5nn4Vzu9R9PcwsiWRiKqFUWqiWdcc+YtnzzeFeqS7wjg/qPteapeLXK9+HfKDiPlu+t4dMUzP1RdkVydQGPS5bEkSdJEAWogVp7+XCTd0CmT6yMx8+EMvm/xvJL6/ezBe/ieOFcd0I83MjK6+Yd9efYOicDfx+2UFOXbpm72YLIUTz16mFLbO+sBe0MjUb5t2AEj/CfGPfVHt0C6+q28Ofqwjw6uPiCRPeq7gdHAP+UZa9fuVZz5i7LcsYbQnT8uNjq+BKSu3nlS8VH2j9qouaSj1d3G+797bewVjT2hgQO7o2zgcLolWRAFmIFs7H3Ymh0e2YPrIzm353Ewvu609MmA9FpQa+2JnK6HcS+M1/9rD7TBaaOfuJhBCiLaqcqKu5/19pMMAmY6mZyGG2S9Ik6ubqAxPmAzoI7KXKQFkiemRFcNbvPstfP6i3CqwdnFVm5cYS2EPVB9cMsLuGMkkm5Zm4LZwJr6xyJmvTvzvT8uoOsbZ5bwf2gJteVMf9H5S9wKJesgdZiFbE0UHP7TGh3NYnhF2ns/j451OsO5rB2iPprD2STs8Qb349OJyJ/Tvg7SrLi4QQolx4nFq2mnsRMk9A+672blHt9i6GMz+rsjGj/mDv1rQtXcfB9J3gGaTKQFnqtnfUUu3gGMufq9PBQyugKKfxa+gOmaaSWyX+B0a8pGbAK8u7DGe2qGNLl4pX1r6HqhVdkKX+7XmHVtp/bMOtAze+AF3GqbrWQtRDZpCFaIV0Oh1xnQL459RBrJs1gl8PDsfZUc+Rizm8suIwg/+8jue//kVmlYUQwsTJTSVTguZd7in7HKx5VR2PegX8O9m3PW1R+27g5mvdc/V6CO1Xc0koc7j7N35wDNB5LPhHq727v3xZ/fGkVWoZtDVLxStzcq3IDm1aZn0uUX239d76kBjbJzUTrZIEyEK0cp0DPZl9Vww7Xx7NK7f3pEugJ4UlBr7de467F21n7LzN/PPnU5LUSwghTOWemmuArGnww3NQnAthg1VmZCEag15f8f7auUgt66+sIdmrr2eqh5x2QNVVzr2gZpVD+zX82kJYQQJkIdoIPw9nHhsexZrnbuTbp4dyd2wYbk4OnMy4xlurjjJk9npe+vYAZ7Py7d1UIYSwj043qe+nfwZDmV2bUqMDX8OJNWoP6sQFKgGREI2l332qTvHlk5C8vuL+gisVyexsESCX70M+VLG8OqgnOHs0/NpCWEECZCHaGJ1OR2ykH3Pv7suuP4zmz5N606eDDyVlGkt2n2XU3zfx8ncHOX+1wN5NrVdhSRkbkzJ4Z00SG5MyZLm4EKJhQvqpgKDwatWyM83BtQxYbUw0NOL/KpalCtFYXLxUUiuAHR9W3J+0GgwlENgT2nVp+OtUTtR1fo86ltJlwo4kSZcQbZiXqxP3x0Vyf1wke85kMX/dCbaczOTLXal8k3iWewaGM31kZ0J93ax+jTKDxqakDFIu59Pey4Ugb1cCvVwI9HbB3dny/4Ky8orZcCyDdUfS2XziEvnFFbM83YO9eGpENLfFhODkIJ//CSEs5OCoskIf/5+aIQvtb+8WVfjxBTVzF9wHhs20d2tEWzH4N6oecvJ6uJSkPpgxLa9uSHKuykwBctYplRgMVOkoIexEAmQhBAADO/rz38fj2HU6i/nrjrMt+TKf70xl6Z5z3DsonGkjownxMT9QvppfzFe7z/LZjhTOXal5NtrLxZH23i4Eebni7+mMj5sT3q5O6rubY/ltd2cH9qZeYe2RdBJTrmCoNFEc7O3KgEhfEpIucSwtl5lf7WfuT0k8fkMU9w4KtyoIF0K0YZ1GqAD5dAIMn2nv1ihHV8KR5Wpf5sSF4CBVCEQT8Y+C7rfBsR/UXuQxb0DyBvWYLZZXg6rn7BWislibEnXJDLKwI/nLUQhRxeAof774zRB2nLrM/HXH2XEqi892pLBkdyp9w3wZFOXP4Ch/YiP9aiwVdSwth0+3nWHZvvMUlqikHr7uTgyJCiArv5iMnELSc4ooKCkjt6iU3EulnLqUZ1Ebe4Z4M6ZnEDf3DKJXqDc6nY7s/BL+uzOFT7ae5vzVAt5YeYR315/gofiOTI2PJMDTinIcQoi2x5SoK2U7lBZZV8rHlgquwKrn1fGwZyGkr33bI9qeuKdUgLz/S7WsuqwIAjqr+sK2EtxHBcig6k0HdLbdtYWwkE5r4k17OTk5+Pj4kJ2djbe3d1O+tBDCCtuTLzNv3XF2nc6qcr9eB92DvRlsDJh1wH+2p7D91OXyc3qEePPw0Egm9uuAq1NFMhlN07hWVEpGbhEZOUVk5BaSlVdMTkEp2QUlZBeUkFNo/F5QQm5hKZ3aezC2ZxCjewTRoY4l34UlZXyTeI6Pfz5FymWVcMzVSc8zo7rwxI2dZOm1qEbGJdtr0X2qafC3rpCXAQ+vgo7D7due5dNg/+fQris8+bMqiyNEU9I0WDQc0g+BoxuUFsANz8PoV233GuvfhJ//ro6jR8GDy2x3bSGMzB2bZAZZCFGn+OgA4qPjSbmcx87TWew+ncXuM1mcuZzPkYs5HLmYw+JtZ8rPd9DrGNcriIeHRjGoox86na7aNXU6HV6uTni5OhHd3tOm7XV1cuCBIZH8enAEqw+lsSghmYPns5n7UxI/HrzI21Ni6BXqY9PXFEK0IjodRN0Ih76B05vtGyCfXKeCY3RwxwIJjoV96HQw5GlYMV0Fx2C7/ccmplJPIMurhd1JgCyEMEtkgAeRAR7cMzAcgIycQnadUQHzrjNXyCkoYWK/UB4YEtmgpF624qDXcVtMCLf2CWb5/vO8/v0RDl/IYeKCrUy7KZrpozrj4iglUoQQNTAFyKcSYOTv7dOGolxYOVMdxz0JEXH2aYcQAL2nwNrXID8TfCNtv9Q/OKbiWAJkYWcSIAshrBLo7crtMaHcHhNq76bUSafTMal/GMM6t+PV5YdZfTiN9zacZPXhNN6e0pd+4b51Pr+4VO2jdnaUpdlCtBmdjPuQz++BomvgYtuVLmZZ9wZknwXfCBj1StO/vhCVObmqWeQNf1L1kWtYHdYg/p3Ue70wB8Ikg7WwLwmQhRBtQqCXK4sejOXHgxd5Zfkhjqdf464PtvKbGzrx3NiuAJzOzONExjVOpudyIuMaJzKucSYzD0cHHZP6d+DhoVF0C/ay808ihGh0fh3VLNnVFEjZBl1vbtrXT9kGuz9WxxPes0+ALsT1bngeokdCcCMkitPr4bF1qr6ym5/try+EBSRAFkK0Kbf2CWFIpwDeXHmY5fsv8NHmU3yxK5W8otIq5aMqKzVofLnrLF/uOsvQ6AAeGRbFqO6BOOht/Am6EKL56DQC9v5HlXtqygC5pABWzFDH/R9UAYkQzYFOBx1iG+/6XkGNd20hLCABshCizfH3cGb+r/pze0wof1h+kPScIgC8XR3pEuRFl0DPSt89OXelgE+2nmb1oTS2JV9mW/JlIvzdmTq0I3cPDKux3JUQooWLMgbIpxKa9nU3zYasZFUX9ua3mva1hRBCSIAshGi7xvQMIj46gGNpuYT7udHey6XGrNshPm4M6ujP+asF/Gf7GZbsOktqVj5/+uEI76xJ4tY+IQztHEBcVECzSFAmhLCBqBvV9/SDkHcZPAIa/zXP74Vt76vj294BN9/Gf00hhBBVSIAshGjTPFwciY00b79TB183Xh7fg2dHd2H5vgt8svU0JzKusTTxHEsTzwEQ4e9OXJQ/QzoFENfJnzA/98ZsvhCisXgGQmBPyDgCx1ZC7MOWPb+sBDbPhStnYOyb4BVc9/mlxWpptWZQGYO732pty4UQQjSABMhCCGEhd2dH7ouL4NeDw9l+6jKbki6x89RlDp7PJjUrn9Ss/PKAuYOvG0OjAxjWuR1DOwcQ6CV1TIVoMbrdqgLkH56DvEwYPkslE6pP9nn45hE4u1PdTt4IU/5VMStdky3zIOMwuAfA+L/apv1CCCEsptM0rZa0NI0jJycHHx8fsrOz8fb2bsqXFkKIRpVbWMKelCvsPJXFDmPAXHZd5q+uQZ4M69yO4Z3bEdcpAE8X+ZzS3mRcsr1W06clhfDj87Dvv+p2l5th0kfg7l/7c5I3wLePQ/5lcPFRM8eZSaDTw6g/wrDnqgfZ6UfgoxtVBt/J/4I+UxrvZxJCiDbK3LHJqgB54cKFzJ07l7S0NPr27cv777/P4MGDbdowIYRo6a4VlbLnTBbbky+zNTmTwxdyqPw/roNeR98wH7oFexPq40qIrxuhvq6E+rgR7OOKq5OD/RrfhrS1cenDDz/kww8/5MyZMwD06tWLV199lfHjxwNQWFjI888/z5IlSygqKmLcuHF88MEHBAWZn2G21fXp3s/gx99BaSH4hMPdn0LYddl8DQa1pHrTbECD4D5wz3/AMxhWzYJfvlTndRkHkxZVBNllpfCvsXBhr5qx/tUXtq8xK4QQovEC5K+++oqHHnqIRYsWERcXx/z581m6dClJSUkEBgbarGFCCNHaXMkrZvupy2w5mcnWk5mkXM6v8/x2ns6E+LgR6OVCey+X8u/lX56uBHg64+bkgF5KTlmtrY1LK1euxMHBgS5duqBpGp9++ilz585l37599OrVi6effppVq1axePFifHx8mDFjBnq9nq1bt5r9Gq2yT9MOwtcPQdYp0DvBLbNh0OMqmM27DN/9BpLXq3MHTFXLpJ2MSfs0TWXE/vEFKCsCnwi451PoMAC2vgdrX1GzzdN3gneI/X5GIYRoxRotQI6Li2PQoEEsWLAAAIPBQHh4OM888wwvvfSSzRomhBCt3dmsfHadzuLslXwuXC3gYnYh568WcPFqIQUlZRZdy9lRj5uTg/pydsDFUY+bs0OV+9xNt50dy4/1eh1FpWUUlRgoKjWo41IDxaXqtoMO3JwdcDVex910bLyeq6O67eKkx9XJdNt47OSAo4MOJ70eRwcdjnpdjVnC7U3GJfD392fu3LlMmTKF9u3b88UXXzBlilrme+zYMXr06MH27dsZMmSIWddrtX1amA0rpsPRlep27ykw4EFYPh1yzoGjG9z+DvS7r+bnX/xFBdlXzoCDs9rTvHW+mpm+430Y8FBT/SRCCNHmmDs2WbT5rbi4mMTERF5++eXy+/R6PWPGjGH79u3Wt1YIIdqgcH93wv2rZ7nWNI3sgpLyYPnStSIu5Vb6Mt7OyC2ksMQAQLExqM0uKGnqH8MijnpdlaDZQa9Dr6v47uigw0GnQ69X33U60Ot06PXqu06nQ2+6Twfz7u0nmcIboKysjKVLl5KXl0d8fDyJiYmUlJQwZsyY8nO6d+9OREREnQFyUVERRUVF5bdzcnIave124eoD93wG2xfC2lfh0DfqC8A/Wi2pDu5d+/ND+sITCbB8GiStgoQ56v5ON0H/Bxu9+UIIIepnUYCcmZlJWVlZtX1IQUFBHDt2rMbntJlBUwghbESn0+Hr7oyvuzO9Qn1qPU/TNApLDBSUlKmv4jIKjceFxtsFlb7nGx/Pr3R/mUHD1UmPs6MeF0c18+ziqGaEnR30GDSt4jrXXTe/WM08m+4vLC2joNhAkfG4pKz6AqVSg0apQaMQg036qrjUNtdpaw4ePEh8fDyFhYV4enqybNkyevbsyf79+3F2dsbX17fK+UFBQaSlpdV6vdmzZ/PGG280cqubCZ0Ohs6ADrGw9GG4lgY9J8IdC8DVjNlyN1/41eeq3vG618HJHSa8K/uOhRCimWj09KltatAUQogmpNPp1DJq5+aZzKu0zECpQaOkzEBpmUaJQX0vLdMoNajHyoxfBq3yd8qPNQ0M2vXHGG9rBHpL2SxrdOvWjf3795Odnc0333zD1KlTSUhIsPp6L7/8MrNmzSq/nZOTQ3h4uC2a2nxFxqs9w5nHIWyQZQGuTgfDfgs97wCdA/i28r4SQogWxKIAuV27djg4OJCenl7l/vT0dIKDg2t8TpscNIUQQuDooMfRAcnG3Qw5OzvTuXNnAGJjY9m9ezfvvvsu9957L8XFxVy9erXKLHJd4zyAi4sLLi4ujd3s5sfNF8LNq+JRI7+OtmqJEEIIGzGj2n0FZ2dnYmNjWb9+ffl9BoOB9evXEx8fX+NzXFxc8Pb2rvIlhBBCiObDYDBQVFREbGwsTk5OVcb5pKQkUlNTax3nhRBCiNbE4iXWs2bNYurUqQwcOJDBgwczf/588vLyeOSRRxqjfUIIIYSwoZdffpnx48cTERFBbm4uX3zxBZs2beKnn37Cx8eHxx57jFmzZuHv74+3tzfPPPMM8fHxZmewFkIIIVoyiwPke++9l0uXLvHqq6+SlpZGv379WL16dbXEXUIIIYRofjIyMnjooYe4ePEiPj4+xMTE8NNPPzF27FgA5s2bh16vZ/LkyRQVFTFu3Dg++OADO7daCCGEaBoW10FuqFZbG1EIIUSLJOOS7UmfCiGEaG7MHZss2oMshBBCCCGEEEK0VhIgCyGEEEIIIYQQSIAshBBCCCGEEEIAEiALIYQQQgghhBCABMhCCCGEEEIIIQQgAbIQQgghhBBCCAFIgCyEEEIIIYQQQgASIAshhBBCCCGEEIAEyEIIIYQQQgghBCABshBCCCGEEEIIAUiALIQQQgghhBBCABIgCyGEEEIIIYQQgATIQgghhBBCCCEEAI5N/YKapgGQk5PT1C8thBBCVGMaj0zjk2g4GeuFEEI0N+aO900eIOfm5gIQHh7e1C8thBBC1Co3NxcfHx97N6NVkLFeCCFEc1XfeK/Tmvgjc4PBwIULF/Dy8kKn0zXoWjk5OYSHh3P27Fm8vb1t1MLWT/rNetJ31pF+s570nXUs6TdN08jNzSU0NBS9XnYe2YKM9c2D9J11pN+sI/1mPek761jab+aO900+g6zX6wkLC7PpNb29veXNZAXpN+tJ31lH+s160nfWMbffZObYtmSsb16k76wj/WYd6TfrSd9Zx5J+M2e8l4/KhRBCCCGEEEIIJEAWQgghhBBCCCGAFh4gu7i48Nprr+Hi4mLvprQo0m/Wk76zjvSb9aTvrCP91nrI79J60nfWkX6zjvSb9aTvrNNY/dbkSbqEEEIIIYQQQojmqEXPIAshhBBCCCGEELYiAbIQQgghhBBCCIEEyEIIIYQQQgghBCABshBCCCGEEEIIAbTgAHnhwoV07NgRV1dX4uLi2LVrl72b1Oxs3ryZCRMmEBoaik6nY/ny5VUe1zSNV199lZCQENzc3BgzZgwnTpywT2ObkdmzZzNo0CC8vLwIDAzkzjvvJCkpqco5hYWFTJ8+nYCAADw9PZk8eTLp6el2anHz8OGHHxITE1NerD0+Pp7//e9/5Y9Ln5lnzpw56HQ6Zs6cWX6f9F3NXn/9dXQ6XZWv7t27lz8u/dY6yHhfNxnrrSNjvfVkvLcNGe/N19TjfYsMkL/66itmzZrFa6+9xt69e+nbty/jxo0jIyPD3k1rVvLy8ujbty8LFy6s8fG3336b9957j0WLFrFz5048PDwYN24chYWFTdzS5iUhIYHp06ezY8cO1q5dS0lJCTfffDN5eXnl5zz33HOsXLmSpUuXkpCQwIULF7jrrrvs2Gr7CwsLY86cOSQmJrJnzx5GjRrFxIkTOXz4MCB9Zo7du3fz0UcfERMTU+V+6bva9erVi4sXL5Z/bdmypfwx6beWT8b7+slYbx0Z660n433DyXhvuSYd77UWaPDgwdr06dPLb5eVlWmhoaHa7Nmz7diq5g3Qli1bVn7bYDBowcHB2ty5c8vvu3r1qubi4qJ9+eWXdmhh85WRkaEBWkJCgqZpqp+cnJy0pUuXlp9z9OhRDdC2b99ur2Y2S35+fto///lP6TMz5Obmal26dNHWrl2rjRgxQnv22Wc1TZP3W11ee+01rW/fvjU+Jv3WOsh4bxkZ660nY33DyHhvPhnvLdfU432Lm0EuLi4mMTGRMWPGlN+n1+sZM2YM27dvt2PLWpbTp0+TlpZWpR99fHyIi4uTfrxOdnY2AP7+/gAkJiZSUlJSpe+6d+9ORESE9J1RWVkZS5YsIS8vj/j4eOkzM0yfPp3bbrutSh+BvN/qc+LECUJDQ+nUqRP3338/qampgPRbayDjfcPJWG8+GeutI+O95WS8t05TjveONmlxE8rMzKSsrIygoKAq9wcFBXHs2DE7tarlSUtLA6ixH02PCTAYDMycOZNhw4bRu3dvQPWds7Mzvr6+Vc6VvoODBw8SHx9PYWEhnp6eLFu2jJ49e7J//37pszosWbKEvXv3snv37mqPyfutdnFxcSxevJhu3bpx8eJF3njjDW644QYOHTok/dYKyHjfcDLWm0fGesvJeG8dGe+t09TjfYsLkIVoStOnT+fQoUNV9jmI2nXr1o39+/eTnZ3NN998w9SpU0lISLB3s5q1s2fP8uyzz7J27VpcXV3t3ZwWZfz48eXHMTExxMXFERkZyddff42bm5sdWyaEaElkrLecjPeWk/Heek093re4Jdbt2rXDwcGhWmay9PR0goOD7dSqlsfUV9KPtZsxYwY//PADGzduJCwsrPz+4OBgiouLuXr1apXzpe/A2dmZzp07Exsby+zZs+nbty/vvvuu9FkdEhMTycjIYMCAATg6OuLo6EhCQgLvvfcejo6OBAUFSd+ZydfXl65du3Ly5El5z7UCMt43nIz19ZOx3joy3ltOxnvbaezxvsUFyM7OzsTGxrJ+/fry+wwGA+vXryc+Pt6OLWtZoqKiCA4OrtKPOTk57Ny5s833o6ZpzJgxg2XLlrFhwwaioqKqPB4bG4uTk1OVvktKSiI1NbXN9931DAYDRUVF0md1GD16NAcPHmT//v3lXwMHDuT+++8vP5a+M8+1a9dITk4mJCRE3nOtgIz3DSdjfe1krLctGe/rJ+O97TT6eG9Vai87W7Jkiebi4qItXrxYO3LkiPbEE09ovr6+Wlpamr2b1qzk5uZq+/bt0/bt26cB2jvvvKPt27dPS0lJ0TRN0+bMmaP5+vpqK1as0A4cOKBNnDhRi4qK0goKCuzccvt6+umnNR8fH23Tpk3axYsXy7/y8/PLz3nqqae0iIgIbcOGDdqePXu0+Ph4LT4+3o6ttr+XXnpJS0hI0E6fPq0dOHBAe+mllzSdTqetWbNG0zTpM0tUzmqpadJ3tXn++ee1TZs2aadPn9a2bt2qjRkzRmvXrp2WkZGhaZr0W2sg4339ZKy3joz11pPx3nZkvDdPU4/3LTJA1jRNe//997WIiAjN2dlZGzx4sLZjxw57N6nZ2bhxowZU+5o6daqmaar8wyuvvKIFBQVpLi4u2ujRo7WkpCT7NroZqKnPAO2TTz4pP6egoECbNm2a5ufnp7m7u2uTJk3SLl68aL9GNwOPPvqoFhkZqTk7O2vt27fXRo8eXT5Yapr0mSWuHzCl72p27733aiEhIZqzs7PWoUMH7d5779VOnjxZ/rj0W+sg433dZKy3joz11pPx3nZkvDdPU4/3Ok3TNOvmnoUQQgghhBBCiNajxe1BFkIIIYQQQgghGoMEyEIIIYQQQgghBBIgCyGEEEIIIYQQgATIQgghhBBCCCEEIAGyEEIIIYQQQggBSIAshBBCCCGEEEIAEiALIYQQQgghhBCABMhCCCGEEEIIIQQgAbIQQgghhBBCCAFIgCyEEEIIIYQQQgASIAshhBBCCCGEEIAEyEIIIYQQQgghBAD/D5H5oIZvNrf5AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 6))\n",
    "plt.subplot(121)\n",
    "plt.plot(train_losses, label='Training')\n",
    "plt.plot(val_losses, label=\"Validation\")\n",
    "plt.title(\"Loss\")\n",
    "plt.legend()\n",
    "plt.subplot(122)\n",
    "plt.plot(train_accs, label='Training')\n",
    "plt.plot(val_accs, label=\"Validation\")\n",
    "plt.title(\"Accuracy\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** The final training accuracy is 100%, the validation accuracy is 33%, i.e. chance level. The network has learned the training examples by heart, although they are totally random, but totally fails to generalize.\n",
    "\n",
    "The main is reason is that we have only 1000 training examples, with a total number of free parameters (VC dimension) around 11500. By definition, the model can learn this training set perfectly, although it is totally random. Its VC dimension is however way too high to generalize anything. It is even worse here: as the data is random, there is nothing to generalize. A nice example to understand why NN overfit..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training a CNN on MNIST\n",
    "\n",
    "Let's now try to learn something a bit more serious, the MNIST dataset. The following cell load the MNIST data (training set 60000 of 28x28x1 monochrome images, test set of 10000 images), and normalizes it (values betwen 0 and 1 for each pixel)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# torchvision.transform allows to normalize the images. The mean=0.1307 and std=0.3081 are common practice.\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),  # Convert the image to a tensor (scaling to [0, 1])\n",
    "    transforms.Normalize((0.1307,), (0.3081,))  # Normalize with mean and std\n",
    "])\n",
    "\n",
    "# Download the data if needed.\n",
    "dataset_train = datasets.MNIST('./data', train=True, download=True, transform=transform)\n",
    "dataset_test = datasets.MNIST('./data', train=False, download=True, transform=transform)\n",
    "\n",
    "# Create the data loaders \n",
    "batch_size=128\n",
    "train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=batch_size)\n",
    "test_loader = torch.utils.data.DataLoader(dataset_test, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** Create a convolutional neural network with two convolutional layers (AlexNet-like) that can reach around 99% validation accuracy after **10 epochs**. Feel free to translate what you did in the course Neurocomputing, search the web, ask ChatGPT, etc. Some ingredients/tips you might need:\n",
    "\n",
    "* Convolutional layers, obviously: <https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html>. You need to define the number of channels / features in the previous layer and in the next one. The first convolutional layer works on the image directly, so the number of input channels is 1 on MNIST (because the MNIST images are monochrome, it would be 3 for RGB images). Keep the kernel size at 3 (i.e. 3x3 filters) and define the padding as `'same'` or `'valid'`, as you prefer.\n",
    "\n",
    "```python\n",
    "self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, padding='same')\n",
    "```\n",
    "\n",
    "* Max-pooling layers can be defined using the functional module `F`:\n",
    "\n",
    "```python\n",
    "def forward(self, x):\n",
    "    x = F.relu(self.conv1(x)) # Conv layer + ReLU\n",
    "    x = F.max_pool2d(x, 2)  # 2x2 max pooling\n",
    "```\n",
    "\n",
    "or as a reusable layer:\n",
    "\n",
    "```python\n",
    "def __init__(self):\n",
    "    self.max_pooling = torch.nn.MaxPool2d(2)\n",
    "def forward(self, x):\n",
    "    x = F.relu(self.conv1(x)) # Conv layer + ReLU\n",
    "    x = self.max_pooling(x)  # 2x2 max pooling\n",
    "```\n",
    "\n",
    "The functional approach is usually preferred, but they are equivalent, pick the approach you prefer.\n",
    "\n",
    "* After the last convolutional block, you need to **flatten** the tensor into a vector, before feeding it to the next fully-connected layer. It must be defined as a layer: \n",
    "\n",
    "```python\n",
    "def __init__(self):\n",
    "    self.flatten = torch.nn.Flatten()\n",
    "def forward(self, x):\n",
    "    x = self.flatten(x)  # flatten\n",
    "```\n",
    "\n",
    "* The caveat is the size of that flattened vector, which will be the first argument of the next FC layer. For convolutional layers, the (width, height) dimensions of the input image do not matter, but FC layers require fixed numbers of inputs. The size of the vector will depend on 1) the image size, 2) the number of conv and pooling layers, 3) the padding method, etc. \n",
    "\n",
    "The trick to find the size of that layer is to create the network up until the flatten layer, pass a single image to the `forward()` method and print the shape of the returned tensor:\n",
    "\n",
    "```python\n",
    "class CNN(torch.nn.Module):\n",
    "    def forward(self, x):\n",
    "        ...\n",
    "        x = self.flatten(x)\n",
    "        return x\n",
    "\n",
    "model = CNN().to(device)\n",
    "\n",
    "# Random image (batch_size, channels, width, height)\n",
    "img = torch.randn(1, 1, 28, 28).to(device)\n",
    "\n",
    "# Forward pass\n",
    "res = model.forward(img)\n",
    "print(res.shape)\n",
    "```\n",
    "\n",
    "For an AlexNet-like network on MNIST with 2 convolutional layers, `padding=same` and 32 features in the last convolutional layer, you should get `torch.Size([1, 1568])` or `torch.Size([1, 32, 7, 7])` depending on whether you print before or after `flatten()`. This means that you have one tensor (the first dimension is always the batch size) of size 7x7 with 32 features, or 1568 elements when flattened. This is the input size for the next FC layer. Of course, you have to adapt this to your network.\n",
    "\n",
    "* You will likely observe overfitting if you only have conv, pooling and fc layers in your network. It never hurts to use a bit of dropout after each conv and fc layer. If you use the same level of dropout everywhere, you can define a single layer in `__init__` and use it in forward:\n",
    "\n",
    "```python\n",
    "def __init__(self):\n",
    "    self.dropout = torch.nn.Dropout(p=0.5)\n",
    "def forward(self, x):\n",
    "    x = self.dropout(x)\n",
    "```\n",
    "\n",
    "If you want different dropout levels, create as many layers as needed, or use the functional `F.dropout(x, 0.5)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNN, self).__init__()\n",
    "        \n",
    "        # First convolutional layer\n",
    "        self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=3, padding='same')\n",
    "        # Second convolutional layer\n",
    "        self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=3, padding='same')\n",
    "        # Flatten layer\n",
    "        self.flatten = torch.nn.Flatten()\n",
    "        # Fully connected layer\n",
    "        self.fc1 = torch.nn.Linear(32 * 7 * 7, 128)\n",
    "        # Fully connected layer\n",
    "        self.fc2 = torch.nn.Linear(128, 10)\n",
    "\n",
    "        # Dropout layer\n",
    "        self.dropout = torch.nn.Dropout(p=0.5)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Apply first convolution, followed by ReLU and max-pooling\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = self.dropout(x)\n",
    "        x = F.max_pool2d(x, 2)  # 2x2 max pooling\n",
    "        # Apply second convolution, followed by ReLU and max-pooling\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = self.dropout(x)\n",
    "        x = F.max_pool2d(x, 2)  # 2x2 max pooling\n",
    "        # Flatten the tensor into a vector\n",
    "        x = self.flatten(x)\n",
    "        # Apply first fully connected layer, followed by ReLU\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.dropout(x)\n",
    "        # Apply second fully connected layer (output layer)\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1\n",
      "Training loss 0.3420, accuracy 89.4550\n",
      "Validation loss: 0.1742, accuracy: 97.4300\n",
      "------------------------------\n",
      "Epoch: 2\n",
      "Training loss 0.1341, accuracy 96.0333\n",
      "Validation loss: 0.1163, accuracy: 98.3100\n",
      "------------------------------\n",
      "Epoch: 3\n",
      "Training loss 0.1075, accuracy 96.7433\n",
      "Validation loss: 0.0958, accuracy: 98.7200\n",
      "------------------------------\n",
      "Epoch: 4\n",
      "Training loss 0.0944, accuracy 97.1050\n",
      "Validation loss: 0.0702, accuracy: 98.6100\n",
      "------------------------------\n",
      "Epoch: 5\n",
      "Training loss 0.0869, accuracy 97.3817\n",
      "Validation loss: 0.0681, accuracy: 98.6400\n",
      "------------------------------\n",
      "Epoch: 6\n",
      "Training loss 0.0817, accuracy 97.4617\n",
      "Validation loss: 0.0613, accuracy: 98.9700\n",
      "------------------------------\n",
      "Epoch: 7\n",
      "Training loss 0.0766, accuracy 97.6350\n",
      "Validation loss: 0.0519, accuracy: 98.8500\n",
      "------------------------------\n",
      "Epoch: 8\n",
      "Training loss 0.0731, accuracy 97.7367\n",
      "Validation loss: 0.0494, accuracy: 99.0500\n",
      "------------------------------\n",
      "Epoch: 9\n",
      "Training loss 0.0706, accuracy 97.8450\n",
      "Validation loss: 0.0488, accuracy: 99.0600\n",
      "------------------------------\n",
      "Epoch: 10\n",
      "Training loss 0.0675, accuracy 97.9750\n",
      "Validation loss: 0.0508, accuracy: 99.0900\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "model = CNN().to(device)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "loss_function = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "# Record\n",
    "train_losses = [] ; train_accs = []\n",
    "val_losses = [] ; val_accs = []\n",
    "\n",
    "# 10 epochs of training and validation\n",
    "for epoch in range(10):\n",
    "\n",
    "    print(f\"Epoch: {epoch+1}\")\n",
    "\n",
    "    # Train \n",
    "    train_loss, train_acc = train(model, device, train_loader, optimizer, loss_function)\n",
    "\n",
    "    # Validation\n",
    "    val_loss, val_acc = validate(model, device, test_loader, loss_function)\n",
    "\n",
    "    print('-'*30)\n",
    "\n",
    "    train_losses.append(train_loss); train_accs.append(train_acc)\n",
    "    val_losses.append(val_loss); val_accs.append(val_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x15837f7d0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 6))\n",
    "plt.subplot(121)\n",
    "plt.plot(train_losses, label='Training')\n",
    "plt.plot(val_losses, label=\"Validation\")\n",
    "plt.title(\"Loss\")\n",
    "plt.legend()\n",
    "plt.subplot(122)\n",
    "plt.plot(train_accs, label='Training')\n",
    "plt.plot(val_accs, label=\"Validation\")\n",
    "plt.title(\"Accuracy\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Correlated inputs\n",
    "\n",
    "Now that we have a basic CNN working on MNIST, let's investigate why deep NN hate sequentially correlated inputs (which is the main justification for the experience replay memory in DQN). Is that really true, or is just some mathematical assumption that does not matter in practice?\n",
    "\n",
    "The idea of this section is the following: we will train the same network as before for 10 epochs, but each epoch will train the network on all the zeros first, then all the ones, etc. Each epoch will contain the same number of training examples as before, but the order of presentation will be different (correlated instead of i.i.d).\n",
    "\n",
    "To do so, we only need to sort the datasets according to their targets, and tell the Pytorch DataLoaders not to shuffle the data when sampling minibatches. \n",
    "\n",
    "The following function sorts the datasets `dataset_train` and `dataset_test` (generated earlier when downloading MNIST), so that the data loaders can iterative deterministically over them (the flag `shuffle=False` is important)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to sort dataset by labels\n",
    "def sort_dataset_by_labels(dataset):\n",
    "    sorted_indices = np.argsort(dataset.targets.numpy())\n",
    "    sorted_dataset = Subset(dataset, sorted_indices)\n",
    "    return sorted_dataset\n",
    "\n",
    "# Load and sort the MNIST dataset\n",
    "train_loader_sorted = DataLoader(\n",
    "    sort_dataset_by_labels(dataset_train), \n",
    "    batch_size=batch_size, shuffle=False\n",
    ")\n",
    "test_loader_sorted = DataLoader(\n",
    "    sort_dataset_by_labels(dataset_test), \n",
    "    batch_size=batch_size, shuffle=False\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** Using these new data loaders, train the same CNN as before (after reinitializing it, of course) for 10 epochs. What do you observe? Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1\n",
      "Training loss 2.0049, accuracy 33.3683\n",
      "Validation loss: 2.2980, accuracy: 9.7400\n",
      "------------------------------\n",
      "Epoch: 2\n",
      "Training loss 1.7866, accuracy 37.1683\n",
      "Validation loss: 2.3609, accuracy: 10.1200\n",
      "------------------------------\n",
      "Epoch: 3\n",
      "Training loss 0.9784, accuracy 68.9767\n",
      "Validation loss: 2.4074, accuracy: 10.9400\n",
      "------------------------------\n",
      "Epoch: 4\n",
      "Training loss 0.4875, accuracy 83.7250\n",
      "Validation loss: 2.2668, accuracy: 21.0600\n",
      "------------------------------\n",
      "Epoch: 5\n",
      "Training loss 0.3559, accuracy 88.6050\n",
      "Validation loss: 2.2929, accuracy: 22.1700\n",
      "------------------------------\n",
      "Epoch: 6\n",
      "Training loss 0.3019, accuracy 90.1700\n",
      "Validation loss: 2.0056, accuracy: 30.4200\n",
      "------------------------------\n",
      "Epoch: 7\n",
      "Training loss 0.2645, accuracy 91.5133\n",
      "Validation loss: 1.7671, accuracy: 36.2700\n",
      "------------------------------\n",
      "Epoch: 8\n",
      "Training loss 0.2635, accuracy 91.6400\n",
      "Validation loss: 1.5903, accuracy: 42.2600\n",
      "------------------------------\n",
      "Epoch: 9\n",
      "Training loss 0.2499, accuracy 92.0167\n",
      "Validation loss: 1.4598, accuracy: 47.9600\n",
      "------------------------------\n",
      "Epoch: 10\n",
      "Training loss 0.2429, accuracy 92.4400\n",
      "Validation loss: 1.4415, accuracy: 52.1300\n",
      "------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x30293e4e0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = CNN().to(device)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
    "loss_function = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "# Record\n",
    "train_losses = [] ; train_accs = []\n",
    "val_losses = [] ; val_accs = []\n",
    "\n",
    "# 10 epochs of training and validation\n",
    "for epoch in range(10):\n",
    "\n",
    "    print(f\"Epoch: {epoch+1}\")\n",
    "\n",
    "    # Train \n",
    "    train_loss, train_acc = train(model, device, train_loader_sorted, optimizer, loss_function)\n",
    "\n",
    "    # Validation\n",
    "    val_loss, val_acc = validate(model, device, test_loader_sorted, loss_function)\n",
    "\n",
    "    print('-'*30)\n",
    "\n",
    "    train_losses.append(train_loss); train_accs.append(train_acc)\n",
    "    val_losses.append(val_loss); val_accs.append(val_acc)\n",
    "\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.subplot(121)\n",
    "plt.plot(train_losses, label='Training')\n",
    "plt.plot(val_losses, label=\"Validation\")\n",
    "plt.title(\"Loss\")\n",
    "plt.legend()\n",
    "plt.subplot(122)\n",
    "plt.plot(train_accs, label='Training')\n",
    "plt.plot(val_accs, label=\"Validation\")\n",
    "plt.title(\"Accuracy\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** For the learning rate used here (you might observe a different behavior), the training accuracy increases a bit more slowly than before, but the validation accuracy is barely better than chance level... We only changed the order (and stochasticity) in which the samples are presented to the network during learning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** To better understand what happened, modify the `validate()` method so that it returns a list of accuracies on each minibatch of the sorted test set, and plot these accuracies.\n",
    "\n",
    "As the test set is also sorted, the first minibatches will only have zeros in them, the following only ones, and so on. If you want, you can figure out which digits are in a minibatch using the list `np.argsort(dataset_test.targets.numpy())` and the batch size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate_per_minibatch(model, device, test_loader, loss_function):\n",
    "\n",
    "    # Evaluation mode, without the gradients\n",
    "    model.eval()\n",
    "\n",
    "    # Initialize metrics\n",
    "    accuracies = [] \n",
    "\n",
    "    # Important! No backpropagation when testing.\n",
    "    with torch.no_grad():\n",
    "\n",
    "        # Iterate over the minibatches\n",
    "        for data, target in test_loader:\n",
    "\n",
    "            # Send the data to the device\n",
    "            data, target = data.to(device), target.to(device)\n",
    "\n",
    "            # Make the forward pass\n",
    "            output = model(data)\n",
    "\n",
    "            # Compute metrics\n",
    "            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability\n",
    "            correct = pred.eq(target.view_as(pred)).sum().item() \n",
    "\n",
    "            # Record accuracies over the minibatches\n",
    "            accuracies.append(100. * correct / data.size(0))\n",
    "    \n",
    "\n",
    "    return accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x3029fd310>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "val_acc = validate_per_minibatch(model, device, test_loader_sorted, loss_function)\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(val_acc, label=\"Validation\")\n",
    "plt.title(\"Accuracy over the minibatches\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** We nicely observe **catastrophic forgetting**. The last digits seen during training were the 9s: they have a good test accuracy. The 8s were seen not too long ago, they are also OK. But the other digits have been completely forgotten! The older memories have been erased. This explains why you cannot train a deep network on-policy: the last episode would be remembered, but all the previous ones would be erased.\n",
    "\n",
    "Depending on your learning rate, a notable exception is for the 6s, which look like 9s, and the 0s, which look like 8s: they share features with the digits which are still well recognized, so they perform OK."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Optional Q:** Increase and decrease the learning rate of the optimizer. What do you observe? Is there a solution to this problem? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** Increasing the learning rate worsens the problem. Decreasing does help, but then learning is very slow. There is no solution to this problem for now, apart from taking **i.i.d** samples in each minibatch, which we can't if we act online."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}