Autoencoder_for_Image_File_Compression.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "To create the autoencoder, we use the Python language and the Torch framework. Let us start by importing the required libraries and the MNIST dataset we want to compress."
      ],
      "metadata": {
        "id": "9Yy3Pi03YzRq"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wE8Hg61LWqjr",
        "outputId": "8b20e796-86da-4ecc-cde7-a1856bb8b70d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 9912422/9912422 [00:00<00:00, 91005965.35it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/MNIST/raw/train-images-idx3-ubyte.gz to data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 28881/28881 [00:00<00:00, 46752487.00it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/MNIST/raw/train-labels-idx1-ubyte.gz to data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n",
            "100%|██████████| 1648877/1648877 [00:00<00:00, 21510322.68it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/MNIST/raw/t10k-images-idx3-ubyte.gz to data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4542/4542 [00:00<00:00, 1070013.97it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/MNIST/raw/t10k-labels-idx1-ubyte.gz to data/MNIST/raw\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "from torchvision import datasets\n",
        "import torchvision.transforms as transforms\n",
        "# convert data to torch.FloatTensor\n",
        "transform = transforms.ToTensor()\n",
        "# load the training and test datasets\n",
        "train_data = datasets.MNIST(root='data', train=True,\n",
        "                                   download=True, transform=transform)\n",
        "test_data = datasets.MNIST(root='data', train=False,\n",
        "                                  download=True, transform=transform)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create training and test dataloaders\n",
        "# number of subprocesses to use for data loading\n",
        "num_workers = 0\n",
        "# how many samples per batch to load\n",
        "batch_size = 20\n",
        "# prepare data loaders\n",
        "train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=num_workers)\n",
        "test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, num_workers=num_workers)"
      ],
      "metadata": {
        "id": "uOzMShH1W0zR"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once the loading of data is completed, the loader functions for training and testing our model have been created for visualization."
      ],
      "metadata": {
        "id": "RaZtbauIit-v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "# obtain one batch of training images\n",
        "dataiter = iter(train_loader)\n",
        "#images, labels = dataiter.next()\n",
        "images, labels = next(dataiter)\n",
        "images = images.numpy()\n",
        "# get one image from the batch\n",
        "img = np.squeeze(images[0])\n",
        "fig = plt.figure(figsize = (5,5))\n",
        "ax = fig.add_subplot(111)\n",
        "ax.imshow(img, cmap='gray')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 462
        },
        "id": "Z_8M3FcTW53y",
        "outputId": "6384e326-bf58-43a3-a717-9f47532908d3"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7ceb9432a6b0>"
            ]
          },
          "metadata": {},
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The linear autoencoder comprises only flattening layers. Activation functions like ReLU are at the input end, and Sigmoid is at the output end."
      ],
      "metadata": {
        "id": "Wqm6YcRiiIYE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "During training, we create an autoencoder class, that comprises two flattening layers, fc1 and fc2. fc1 is an encoder and compresses the input image to a (784, 32) dimension vector, and the second layer, fc2, works as a decoder and decompresses the image to the required output (32, 784) dimension."
      ],
      "metadata": {
        "id": "cJKSqumof9Ze"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "# define the NN architecture\n",
        "class Autoencoder(nn.Module):\n",
        "    def __init__(self, encoding_dim):\n",
        "        super(Autoencoder, self).__init__()\n",
        "        ## encoder ##\n",
        "        # linear layer (784 -> encoding_dim)\n",
        "        self.fc1 = nn.Linear(28 * 28, encoding_dim)\n",
        "        ## decoder ##\n",
        "        # linear layer (encoding_dim -> input size)\n",
        "        self.fc2 = nn.Linear(encoding_dim, 28*28)\n",
        "    def forward(self, x):\n",
        "        # add layer, with relu activation function\n",
        "        x = F.relu(self.fc1(x))\n",
        "        # output layer (sigmoid for scaling from 0 to 1)\n",
        "        x = F.sigmoid(self.fc2(x))\n",
        "        return x\n",
        "# initialize the NN\n",
        "encoding_dim = 32\n",
        "model = Autoencoder(encoding_dim)\n",
        "print(model)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VSH4c2suXxIT",
        "outputId": "60e5955e-b666-4c90-bfe5-c197b43b508a"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Autoencoder(\n",
            "  (fc1): Linear(in_features=784, out_features=32, bias=True)\n",
            "  (fc2): Linear(in_features=32, out_features=784, bias=True)\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, we need to decide the optimizer and loss function to train the entire model."
      ],
      "metadata": {
        "id": "fAoQ-wwyftgk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# specify loss function\n",
        "criterion = nn.MSELoss()\n",
        "# specify loss function\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
      ],
      "metadata": {
        "id": "tUiVF4V0X4U7"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this linear autoencoder, MSE (Mean Squared Error Loss) and the Adam optimizer is used.\n",
        "\n",
        "The entire training process works in the following way:\n",
        "\n",
        "1. After passing the input image to the model, we generate the output with the help of the sigmoid activation function.\n",
        "\n",
        "2. A loss calculation is done for the actual and predicted values.\n",
        "\n",
        "3. Backpropagation and adjustment are done for the parameters to minimize the loss."
      ],
      "metadata": {
        "id": "qVsU8tord78D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# number of epochs to train the model\n",
        "n_epochs = 20\n",
        "for epoch in range(1, n_epochs+1):\n",
        "    # monitor training loss\n",
        "    train_loss = 0.0\n",
        "    ###################\n",
        "    # train the model #\n",
        "    ###################\n",
        "    for data in train_loader:\n",
        "        # _ stands in for labels, here\n",
        "        images, _ = data\n",
        "        # flatten images\n",
        "        images = images.view(images.size(0), -1)\n",
        "        # clear the gradients of all optimized variables\n",
        "        optimizer.zero_grad()\n",
        "        # forward pass: compute predicted outputs by passing inputs to the model\n",
        "        outputs = model(images)\n",
        "        # calculate the loss\n",
        "        loss = criterion(outputs, images)\n",
        "        # backward pass: compute gradient of the loss with respect to model parameters\n",
        "        loss.backward()\n",
        "        # perform a single optimization step (parameter update)\n",
        "        optimizer.step()\n",
        "        # update running training loss\n",
        "        train_loss += loss.item()*images.size(0)\n",
        "    # print avg training statistics\n",
        "    train_loss = train_loss/len(train_loader)\n",
        "    print('Epoch: {} tTraining Loss: {:.6f}'.format(\n",
        "        epoch,\n",
        "        train_loss ))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9bR9naAYX9ne",
        "outputId": "14eb79a1-876a-43d4-b496-ef8b90e11ba0"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 1 tTraining Loss: 0.741553\n",
            "Epoch: 2 tTraining Loss: 0.404761\n",
            "Epoch: 3 tTraining Loss: 0.368203\n",
            "Epoch: 4 tTraining Loss: 0.360122\n",
            "Epoch: 5 tTraining Loss: 0.356951\n",
            "Epoch: 6 tTraining Loss: 0.354789\n",
            "Epoch: 7 tTraining Loss: 0.353070\n",
            "Epoch: 8 tTraining Loss: 0.351661\n",
            "Epoch: 9 tTraining Loss: 0.350417\n",
            "Epoch: 10 tTraining Loss: 0.349337\n",
            "Epoch: 11 tTraining Loss: 0.348391\n",
            "Epoch: 12 tTraining Loss: 0.347543\n",
            "Epoch: 13 tTraining Loss: 0.346775\n",
            "Epoch: 14 tTraining Loss: 0.346075\n",
            "Epoch: 15 tTraining Loss: 0.345432\n",
            "Epoch: 16 tTraining Loss: 0.344758\n",
            "Epoch: 17 tTraining Loss: 0.344211\n",
            "Epoch: 18 tTraining Loss: 0.343722\n",
            "Epoch: 19 tTraining Loss: 0.343243\n",
            "Epoch: 20 tTraining Loss: 0.342832\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As the training is done, let us apply it to one batch of test images."
      ],
      "metadata": {
        "id": "IjGjc81ralTD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# obtain one batch of test images\n",
        "dataiter = iter(test_loader)\n",
        "images, labels = next(dataiter)\n",
        "images_flatten = images.view(images.size(0), -1)\n",
        "# get sample outputs\n",
        "output = model(images_flatten)\n",
        "# prep images for display\n",
        "images = images.numpy()\n",
        "# output is resized into a batch of images\n",
        "output = output.view(batch_size, 1, 28, 28)\n",
        "# use detach when it's an output that requires_grad\n",
        "output = output.detach().numpy()\n",
        "# plot the first ten input images and then reconstructed images\n",
        "fig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(25,4))\n",
        "# input images on top row, reconstructions on bottom\n",
        "for images, row in zip([images, output], axes):\n",
        "    for img, ax in zip(images, row):\n",
        "        ax.imshow(np.squeeze(img), cmap='gray')\n",
        "        ax.get_xaxis().set_visible(False)\n",
        "        ax.get_yaxis().set_visible(False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 322
        },
        "id": "nBkjFpT8Y18C",
        "outputId": "e0b894d1-cf34-4b6e-dc36-8e06d1eb9e9b"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2500x400 with 20 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAB40AAAFICAYAAABEN2iVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABX00lEQVR4nO3dd5idZb3o/ZnMTCa9h5CQkJAERAg1ASKKYgURECQoih674AYbqGDZitjOZS8bg5xz3CoqojTZiBFRpKMSCBASWiCk916nvv+8+7zm/f2QJzOzZpL1fD7X5T/fa5V7MfdT7yxXbXt7e3sNAAAAAAAAAKXUq6cHAAAAAAAAAEDPsWgMAAAAAAAAUGIWjQEAAAAAAABKzKIxAAAAAAAAQIlZNAYAAAAAAAAoMYvGAAAAAAAAACVm0RgAAAAAAACgxCwaAwAAAAAAAJRYfZEHtbW11Sxbtqxm4MCBNbW1tZUeE3u59vb2ms2bN9eMGTOmplev6vx3CbYJdodtAnZlm4Bd2SZgV7YJ2JVtAnZlm4Bd2SZgV7YJ2NXubBOFFo2XLVtWM27cuC4ZHOWxePHimrFjx/b0MCrCNkFH2CZgV7YJ2JVtAnZlm4Bd2SZgV7YJ2JVtAnZlm4BdFdkmCv0zi4EDB3bJgCiXap431fzZqJxqnjfV/NmonGqeN9X82aicap431fzZqJxqnjfV/NmonGqeN9X82aicap431fzZqJxqnjfV/NmonGqeN9X82aicIvOm0KKxr7fTEdU8b6r5s1E51TxvqvmzUTnVPG+q+bNROdU8b6r5s1E51TxvqvmzUTnVPG+q+bNROdU8b6r5s1E51TxvqvmzUTnVPG+q+bNROUXmTXX+H7oDAAAAAAAAUIhFYwAAAAAAAIASs2gMAAAAAAAAUGIWjQEAAAAAAABKzKIxAAAAAAAAQIlZNAYAAAAAAAAoMYvGAAAAAAAAACVm0RgAAAAAAACgxCwaAwAAAAAAAJSYRWMAAAAAAACAErNoDAAAAAAAAFBiFo0BAAAAAAAASqy+pwcA9KxPfvKTofXt2ze0ww8/PLQZM2YUeo+ZM2eGdv/994d29dVXF3o9AAAAAAAAuo5vGgMAAAAAAACUmEVjAAAAAAAAgBKzaAwAAAAAAABQYhaNAQAAAAAAAEqsvqcHAHSfa6+9NrQZM2Z0+PXa2toKPe68884L7XWve11od955Z2iLFi3a/YHBXuiggw4K7YknngjtYx/7WGg//OEPKzIm2B39+/cP7Zvf/GZo2TFh9uzZoZ199tmhPf/88x0cHQAAAPDPhg4dGtr+++/f4dfLrtk/8YlPhDZ37tzQnnrqqdAeeeSRDo8F6BjfNAYAAAAAAAAoMYvGAAAAAAAAACVm0RgAAAAAAACgxCwaAwAAAAAAAJRYfU8PAKiMa6+9NrQZM2Z0+PWeeOKJ0P74xz+GNnHixNBOO+200CZNmhTaueeeG9rXv/71okOEvdpRRx0VWltbW2hLlizpjuHAbhs9enRoH/zgB0PL5vXUqVNDO/XUU0O74oorOjg66DpHH310aDfccENoEyZM6IbRFPOGN7whtPnz54e2ePHi7hgOdJnsOuPmm28O7cILLwztyiuvDK21tbVrBkZp7LPPPqH95je/Ce2+++4L7aqrrgpt4cKFXTKuShk8eHBor3zlK0ObNWtWaM3NzRUZEwDRm970ptBOP/300E488cTQJk+e3OH3feqpp0IbP358aI2NjYVer66ursNjATrGN40BAAAAAAAASsyiMQAAAAAAAECJWTQGAAAAAAAAKDGLxgAAAAAAAAAlVt/TAwA6b9q0aaGdeeaZhZ77+OOPh3b66aeHtmbNmtC2bNkSWu/evUN74IEHQjviiCNCGz58+AuOE6rdkUceGdrWrVtDu/HGG7thNPCvjRw5MrSf/exnPTAS6H4nnXRSaI2NjT0wkuJOO+200N73vveFds4553THcKBDsmuFH/3oR4We+x//8R+h/eQnPwlt+/btuz8wSmPo0KGhZdfTgwcPDm3lypWhLVy4sEvGVSnZ55g9e3Zo2Xnh1KlTQ3vmmWe6ZmBUhUGDBoX29a9/PbQpU6aE9rrXvS59zebm5s4PDPYgkyZNCu2CCy4I7YMf/GBoffv2Da22trZrBvYvHHTQQRV/D6CyfNMYAAAAAAAAoMQsGgMAAAAAAACUmEVjAAAAAAAAgBKzaAwAAAAAAABQYvU9PYAXM2PGjNCyH3dftmxZaDt27Ajtl7/8ZWgrVqwI7Zlnnik6ROhxo0ePDq22tja0xx9/PLSTTjoptOXLl3d4LBdffHFohxxySKHn/v73v+/w+8LeZMqUKaFdeOGFoV199dXdMRz4lz760Y+GdsYZZ4R27LHHdun7vvKVrwytV6/47x0feeSR0O66664uHQvlVV8fL5dOOeWUHhhJ58yePTu0iy66KLT+/fuHtnXr1oqMCXZXdlwYO3Zsoedec801oWX3C+C/jRgxIrRrr702tGHDhoX2ox/9KLSPfOQjXTOwbvT5z38+tAMOOCC08847LzT31Phn5557bmhf/epXQxs3blyh1xs0aFDa165du3sDgz1cdp7zsY99rAdGknviiSdCy+49QyVNnjw5tOw87swzzwztxBNPDK2trS20K6+8MrR77703tGo5//FNYwAAAAAAAIASs2gMAAAAAAAAUGIWjQEAAAAAAABKzKIxAAAAAAAAQInV9/QAXsw3vvGN0CZMmNDh1zvvvPNC27x5c2h7+o+2L1myJLTsv9WDDz7YHcOhh/3Xf/1XaNmPwGdzfd26dV06lnPOOSe0hoaGLn0P2NsdfPDBofXv3z+0a6+9tjuGA//Sd7/73dDa2toq/r5vectbCrXnn38+tLe97W2hzZ49u2sGRqm8+tWvDu1lL3tZaNl5+J5k6NChoR1yyCGh9evXL7StW7dWZEzwQhobG9P+uc99rsOvefXVV4fW3t7e4dej+h199NGhnXjiiYWee/nll3fxaCrv0EMPDe3iiy8O7cYbbwzNNQv/bOzYsaF973vfC2348OGhFd0v//CHP0z7hRdeGFpX3/OCf2XEiBGhfexjHwvt3nvvDW3WrFmh7dy5M7SNGzeGlp2vZ/eYbrvtttDmzp0b2t/+9rfQHn744dC2b99eaCzQEVOmTAkt289n94mybbEzjjvuuNBaWlpCe/LJJ0O75557Qsv2C01NTR0cXdfzTWMAAAAAAACAErNoDAAAAAAAAFBiFo0BAAAAAAAASsyiMQAAAAAAAECJ1ff0AF7MBz/4wdAOP/zw0ObPnx/aS1/60tCOPvro0E488cTQpk+fHtrixYtDGzduXGhFZT+WvXr16tBGjx5d6PUWLVoU2oMPPrj7A6MqPP/88xV/j0996lOhHXTQQYWe+7e//a1Qg2r06U9/OrRsm7UPp7vdeuutofXqVfl/Y7h27drQtmzZEtr48eNDO+CAA0L7+9//HlpdXV0HR0dZTJkyJbRrrrkmtAULFoT2ta99rSJj6ipvfvObe3oIUNhhhx2W9qlTpxZ6fnad/Yc//KFTY6K67bPPPqGdddZZhZ77/ve/P7Tsvs6e5NBDDw3t9ttvL/TcG2+8MbTNmzd3ekxUj09+8pOhDRs2rEvf421ve1vaTz755NC++tWvhvbDH/4wtKamps4PjFLp379/aLfddltoRxxxRGhnnnlmofd44IEHQsvWNhYuXBja/vvvH9qSJUtCa2trKzQW6CrZ2t4FF1wQWravHzRoUKH3WLp0aWh33313aM8991xo2T3b2bNnh3bssceGlh3vTjnllNAeeeSR0K688srQeopvGgMAAAAAAACUmEVjAAAAAAAAgBKzaAwAAAAAAABQYhaNAQAAAAAAAEqsvqcH8GL+/Oc/F2qZWbNmFXrc0KFDQzvyyCNDy37w+phjjin0HpkdO3aE9tRTT4U2f/780LIf1V6wYEGHxwIv5tRTTw3t8ssvD613796hrVq1KrTPfOYzoW3btq2Do4M914QJE0KbNm1aaNn+f+vWrZUYEtTU1NTUvOpVrwrtJS95SWhtbW2FWlFXXnllaLfddltoGzduDO01r3lNaJ/73OcKve+HP/zh0GbOnFnouZTD5z//+dD69+8f2sknnxzali1bKjKmjsiuE7LtvTPbMVTSWWed1annZ8cU+Fe+/e1vh/bOd74ztOye0G9/+9uKjKmSTjjhhNBGjRoV2k9/+tPQfvGLX1RiSOylxo8fH9p73/veQs999NFHQ1u5cmVor3vd6wqPZ/DgwaF98pOfDO2Xv/xlaCtWrCj8PpRPdq/zV7/6VWhHHHFEaF/72tdCu/322zs8loULFxZ63KJFizr8HtBVfvzjH4d25plnhjZixIhCr5etCz722GOhffaznw0tW4vLHH/88aFl95N+8pOfhJatKWbHtiuuuCK066+/PrTVq1e/0DAryjeNAQAAAAAAAErMojEAAAAAAABAiVk0BgAAAAAAACgxi8YAAAAAAAAAJVbf0wPYE6xfvz60O+64o9Bzsx/f7oyzzjortKFDh4aW/cD3tdde26VjgX82bdq00Hr37l3oudncvPPOOzs9JtgbvOpVryr0uNWrV1d4JJTZhAkTQvv1r38d2ogRIzr8Hs8//3xo119/fWhf+tKXQtu2bVuH3+NDH/pQaCNHjgztG9/4Rmh9+vQJ7T/+4z9Ca25uLjQ+9h4zZswI7ZRTTgntmWeeCe3BBx+syJi6yuc+97nQ2traQvvrX/8a2oYNGyowItg9r3zlKws/tqmpKbRsG4B/pb29PbRsv7ls2bLQsjnYU/r27RvaZz/72dD+7d/+LbTsv8H73ve+rhkYVevII48MbeDAgaHdfffdoWXXydm5+dvf/vbQsnldU1NTM2nSpND23Xff0H73u9+F9sY3vjG0devWpe9DdRswYEBon/nMZ0I79dRTQ1uzZk1o3/rWt0Irev0Le6psf/3pT386tA984AOh1dbWhpbdE505c2Zo3/zmN0PbunXrC46zI4YPHx5aXV1daJdddllos2bNCm38+PFdMq7u5JvGAAAAAAAAACVm0RgAAAAAAACgxCwaAwAAAAAAAJSYRWMAAAAAAACAEqvv6QGU2T777BPaj370o9B69Ypr+5dffnlo69at65qBUXo33XRTaG94wxsKPffnP/95aJ///Oc7OyTYax122GGFHveNb3yjwiOhzOrr4ynfiBEjOvx6d955Z2jnnHNOaGvWrOnwe2Sef/750L7+9a+H9p3vfCe0fv36hZZtdzfffHNoCxYsKDpE9hJnn312aNkcyc7N9yQTJkwI7dxzzw2ttbU1tK985SuhNTc3d8m4oKjjjz++UHshW7duDW3OnDmdGRK8oDe96U2h3XbbbaFt2LAhtJkzZ3bpWF71qleFduKJJ4Y2ffr0Qq933XXXdXZIlFBjY2No7e3toX33u98t9Ho7duwI7T//8z9Dy87jampqaiZOnFjofbZt2xZaU1NToedS/c4444zQLr300tAWLVoU2gknnBDaxo0bu2RcsCfJzjk+9alPhVZbWxva0qVLQzvrrLNC+/vf/96xwb2Aurq60MaNGxdatrZx6623hjZ06NBC75v9N7j66qtDy84fe4pvGgMAAAAAAACUmEVjAAAAAAAAgBKzaAwAAAAAAABQYhaNAQAAAAAAAEqsvqcHUGYXXHBBaCNHjgxt/fr1oT355JMVGRPlM3r06NCOP/740BobG0Nbs2ZNaF/5yldC27JlSwdHB3uX6dOnh/be9743tIcffji0P/3pTxUZE3TWgw8+GNr73ve+0LJjQne4+eabQzv33HNDO+aYY7pjOOyBBg8eHFq2v87MnDmzq4fTpT70oQ+FNmLEiNDmz58f2h133FGRMcHu6Oy+eU/fRtk7fP/73w/t1a9+dWhjxowJ7ZWvfGVotbW1oZ1++ukdHF0ue4/29vZCz3322WdD++xnP9vpMVE+b3/72ws97k1velNoN910U4ffd9q0aR1+bk1NTc0DDzwQmvtW/Lfsnmgmu6+zZMmSrh4O7JHq6upCa21tLfTclpaW0I477rjQZsyYEdrBBx9c6D22b98e2ktf+tJCLbu3NWrUqELvm1m5cmVo2fpJc3Nzh9+jq/mmMQAAAAAAAECJWTQGAAAAAAAAKDGLxgAAAAAAAAAlZtEYAAAAAAAAoMTqe3oAZfHyl788tEsvvbTQc88444zQ5s6d29khQU1NTU3N9ddfH9rw4cMLPfcXv/hFaAsWLOj0mGBv9brXvS60YcOGhTZr1qzQduzYUZExwQvp1avYvx087rjjKjySzqmtrQ0t+2xFP+9ll10W2rve9a7dHhd7jsbGxtD222+/0K655pruGE6XmjRpUqHHuXZgTzVt2rTCj92wYUNoM2fO7MLRUFazZ88O7fDDDw/tyCOPDO3kk08O7VOf+lRoq1evDu1nP/tZwRFGV199dWiPPPJIoefed999obmOpyOyc6fTTz89tGOOOSa0gw8+OLTDDjsstDPPPDO0oUOHpuPJjhPZYz/4wQ+Glm1T8+bNS9+H6jZjxoxCj8v2/1/84hdD+93vfhfanDlzdntcsCf5y1/+Etodd9wRWnafdP/99w/tBz/4QWjt7e2FxtLa2hpaXV1doedmRo0aVehxbW1tod14442hffSjHw1t+fLluz+wbuSbxgAAAAAAAAAlZtEYAAAAAAAAoMQsGgMAAAAAAACUmEVjAAAAAAAAgBKr7+kBlMUpp5wSWkNDQ2h//vOfQ7v//vsrMibK5/TTTw/t6KOPLvTcv/71r6F98Ytf7OyQoKocccQRobW3t4d23XXXdcdw4P86//zzQ2tra+uBkXS90047LbSjjjoqtOzzZu2yyy7rknGx59i8eXNoc+bMCe3www8PbdiwYaGtW7euS8a1u/bZZ5/QZsyYUei599xzT1cPB3bbK17xitDe8Y53FH7+xo0bQ1uyZEmnxgQvZP369aHdcccdhdoll1xSkTH9s4kTJ4ZWW1sbWna8++QnP1mJIVFCt99+e2jZvvqwww4Lbd68eaFl185F37empqbmggsuCO2WW24J7cADDwztox/9aGjZNRTVb+TIkaFl142NjY2hfeELXwjt85//fGhXXnllaA888EBo+++/f2jPPPNMaI8//nhomUMPPTS0bN3B+RUvZvv27aGdeeaZoQ0ZMiS0Sy+9NLSXv/zloa1duza0RYsWhZZti9n92WOPPTa0zrjqqqtC++xnPxvahg0buvR9u4NvGgMAAAAAAACUmEVjAAAAAAAAgBKzaAwAAAAAAABQYhaNAQAAAAAAAEqsvqcHUI369u0b2sknnxxaU1NTaF/84hdDa25u7pqBUSrDhw8PLfsx9oaGhkKvN2fOnNC2bNmy2+OCarHvvvuGdsIJJ4T25JNPhnbjjTdWZEzwQk477bSeHsJuGzlyZGiHHHJIaNmxrajVq1eH5ryr+mzfvj20BQsWhHbWWWeF9vvf/z6073znO10zsP/XlClTQps4cWJoEyZMCK29vb3Qe7S1te32uKCrZdcnvXoV/3fsf/rTn7pyOLBX+8IXvhBadky45JJLQsvOf6Aj1q1bF9pb3/rW0K677rrQBg8eXOg9fvjDH4aWzeuampqaHTt2hHbDDTeEdumll4Z20kknhTZp0qTQsnNIqsu3vvWt0C666KIOv152rvNv//ZvhVp3yI4Jf/3rX0M755xzumE0VJsNGzaElu2Du9rPf/7z0I499thCz928eXNo2T7gpz/9aWitra2F3mNP55vGAAAAAAAAACVm0RgAAAAAAACgxCwaAwAAAAAAAJSYRWMAAAAAAACAEqvv6QFUo0996lOhHXXUUaHNmjUrtPvuu68iY6J8Lr744tCOOeaYQs+96aabQvviF7/Y2SFBVXnPe94T2j777BPaH/7wh24YDVSfz33uc6FdcMEFHX69hQsXhvbud787tEWLFnX4Pdh7ZOc1tbW1ob3pTW8K7ZprrunSsaxZsya09vb20EaMGNHh9/jpT3/a4edCV5kxY0ahx23YsCHtP/7xj7twNLD3OPvss0P7H//jf4S2efPm0NauXVuRMcELuf3220PL9v/veMc7Qsv2/1/4whdC27FjR+HxfPnLXw7tpS99aWinn356offOrh+oLpdeemlo1157bWi/+tWvQquvj0st48aNC61Xrz3ne3wjR44MLdtmP//5z4f2la98pSJjgt3x6U9/OrRzzjmnw693/vnnh9bV9wD2dHvOHgoAAAAAAACAbmfRGAAAAAAAAKDELBoDAAAAAAAAlJhFYwAAAAAAAIASi7/Ozm5505veFNq///u/h7Zp06bQLr/88oqMCWpqamouuuiiDj/3wgsvDG3Lli2dGQ5UnfHjxxd63Pr16ys8Etj73XrrraG95CUv6dL3mDdvXmj33HNPl74He48nnngitLe+9a2hHXnkkaFNnjy5S8dy3XXXFXrcz372s9DOPffcQs/dvn37bo0JOmvs2LGhveMd7yj03CVLlqT9wQcf7NSYYG/1xje+sdDjbrnlltAeeuihrh4O7Lbbb7+9UKuE7Bzo2muvDe30008P7dWvfnVow4YNC23dunUdHB17otbW1tCyc5CDDjqo0Ou99rWvDa2hoSG0yy67LLRjjjmm0Ht0tdra2tCmTp3aAyOBXX3gAx8I7fOf/3xo9fXFlj0ff/zx0G644YbdH1iV8U1jAAAAAAAAgBKzaAwAAAAAAABQYhaNAQAAAAAAAErMojEAAAAAAABAiRX7RWhqampqaoYPHx7aD37wg9Dq6upCu/XWW0N74IEHumZg0MWGDRsWWnNzc5e+x8aNGwu9R0NDQ2iDBw8u9B5DhgwJ7aKLLir03Exra2tol1xySWjbtm3r8Huw9zj11FMLPe6//uu/KjwSeHG1tbWh9epV7N8OvvGNbyz0uKuuuiq0MWPGFHpuNpa2trZCzy3qtNNO69LXoxzmzJlTqHWHZ599tsPPnTJlSmhz587tzHDgXzr++ONDK3rcuemmm7p4NLB3y87Ftm7dGtq3v/3t7hgO7PV+85vfhHb66aeH9ra3vS20Cy+8MLTLL7+8awZGVfrzn/9c6HFHHnlkaMccc0xoLS0tof3nf/5naP/rf/2v0D7+8Y+H9o53vKPQ+KC7HXvssaFl5zoDBgwo9HpbtmwJ7fzzzw9t586dhV6vmvmmMQAAAAAAAECJWTQGAAAAAAAAKDGLxgAAAAAAAAAlZtEYAAAAAAAAoMTqe3oAe6q6urrQZs2aFdoBBxwQ2oIFC0L793//964ZGHSDRx99tOLv8dvf/ja05cuXhzZq1KjQ3va2t1VkTB2xYsWK0L761a/2wEiopFe84hWh7bvvvj0wEuiYmTNnhvaNb3yj0HNvueWW0Nra2go9t+jjuvq5V155ZYefC3uq2traQi0zd+7crh4O/EvDhw8v9Lg1a9aE9v3vf7+rhwN7jfPPPz+07Jp41apVoT300EMVGRNUm+w6I7s2evOb3xzaF7/4xdB+/etfh/bUU091cHSU1W233RZadn+xvj4u53zwgx8MbfLkyaGdeOKJHRtcTU3NkiVLOvxc6IjTTjsttIEDBxZ67tatW0M7/fTTQ7v33nt3f2Al4JvGAAAAAAAAACVm0RgAAAAAAACgxCwaAwAAAAAAAJSYRWMAAAAAAACAEou/nE5NTU1NzaRJk0KbOnVqoededNFFoS1YsKDTY4Ldceutt4b25je/uQdGkjv77LO79PVaWlpCa2trK/Tcm2++ObQHH3yw0HPvvvvuQo9j73bmmWeGVldXF9rDDz8c2l133VWRMcHuuOGGG0L71Kc+FdrIkSO7YziFrF69OrT58+eH9qEPfSi05cuXV2RM0JPa29sLNdgTnHTSSYUet2jRotA2btzY1cOBvcb5558fWrav//3vf1/o9QYOHBja0KFDQ8u2RSiTOXPmhPaFL3whtG9+85uhfe1rXwvtXe96V2jbt2/v2OAohexa9ze/+U1ob33rWwu93qtf/epCj2ttbQ0tO8ZceumlhV4POiI7X/n0pz/d4df75S9/Gdpf//rXDr9e2fimMQAAAAAAAECJWTQGAAAAAAAAKDGLxgAAAAAAAAAlZtEYAAAAAAAAoMTqe3oAe4Lx48eHdttttxV67qc+9anQbrnllk6PCTrrLW95S2jZD8g3NDR0+D0OPfTQ0N72trd1+PV+8pOfhLZw4cJCz73++utDe+KJJzo8FsqrX79+oZ1yyimFnnvdddeF1tra2ukxQWc9//zzoZ1zzjmhnXHGGaF97GMfq8SQXtRXv/rV0K644ooeGAnsGfr06VPocdu3b6/wSGBX2fXEpEmTCj13x44doTU3N3d6TFDtsmuMc889N7RPfOIToT3++OOhvfvd7+6agUEV+fnPfx7aeeedF1p2/+3yyy8P7dFHH+2agVGVsnP4j3/846ENGDAgtGnTpoW2zz77hJbdY7366qtDu+yyy/JBQhfI5vC8efNCK7pmke1bs22H4nzTGAAAAAAAAKDELBoDAAAAAAAAlJhFYwAAAAAAAIASs2gMAAAAAAAAUGL1PT2APcGHPvSh0Pbff/9Cz73zzjtDa29v7/SYoBK+8Y1vVPw93vGOd1T8PaCSmpubQ1u/fn1oN998c2jf//73KzImqIS77rqrULvttttCy86dTjvttNCy7eSqq64Krba2NrR58+aFBmX23ve+N7QNGzaE9uUvf7kbRgP/n7a2ttAefPDB0KZMmRLaM888U5ExQbX7wAc+ENr73//+0P7P//k/oTlOQDGrV68O7XWve11oCxcuDO2SSy4J7dxzz+2ScVEeK1euDC277n7Xu94V2vTp00P70pe+FNqqVas6ODromNe85jWhjR07NrSia2yf+MQnQtuxY8fuD4z/yzeNAQAAAAAAAErMojEAAAAAAABAiVk0BgAAAAAAACgxi8YAAAAAAAAAJVbf0wPobq94xStC+8hHPtIDIwFgT9Tc3Bza8ccf3wMjgT3DrFmzCjWgsv7xj3+E9p3vfCe0O+64ozuGA/9Xa2traJ/73OdCa29vD2327NkVGRPsrS688MLQLr/88tDuuuuu0GbOnBna+vXrQ2tqaurg6IBFixaFdvvtt4d2+umnh3bIIYeENm/evK4ZGKV29dVXF2qwJ/jyl78cWnadkPnmN78ZmuvfruebxgAAAAAAAAAlZtEYAAAAAAAAoMQsGgMAAAAAAACUmEVjAAAAAAAAgBKr7+kBdLcTTjghtAEDBhR67oIFC0LbsmVLp8cEAADwr5x22mk9PQQobNmyZaG9733v64GRwN7lnnvuCe01r3lND4wEKGrGjBmhPfLII6FNnjw5tHnz5lVkTAB7qmHDhoVWW1sb2qpVq0L73ve+V4kh8f/jm8YAAAAAAAAAJWbRGAAAAAAAAKDELBoDAAAAAAAAlJhFYwAAAAAAAIASq+/pAeypHnnkkdBe+9rXhrZu3bruGA4AAAAAAHuQTZs2hXbAAQf0wEgA9nzf+c53CrUvf/nLoS1fvrwiY2JXvmkMAAAAAAAAUGIWjQEAAAAAAABKzKIxAAAAAAAAQIlZNAYAAAAAAAAosfqeHkB3+/rXv16oAQAAAAAAAJ333e9+t1Cj5/imMQAAAAAAAECJWTQGAAAAAAAAKDGLxgAAAAAAAAAlVmjRuL29vdLjoApV87yp5s9G5VTzvKnmz0blVPO8qebPRuVU87yp5s9G5VTzvKnmz0blVPO8qebPRuVU87yp5s9G5VTzvKnmz0blVPO8qebPRuUUmTeFFo03b97c6cFQPtU8b6r5s1E51TxvqvmzUTnVPG+q+bNROdU8b6r5s1E51TxvqvmzUTnVPG+q+bNROdU8b6r5s1E51TxvqvmzUTnVPG+q+bNROUXmTW17gaXltra2mmXLltUMHDiwpra2tksGR/Vqb2+v2bx5c82YMWNqevWqzv8HdNsEu8M2AbuyTcCubBOwK9sE7Mo2AbuyTcCubBOwK9sE7Gp3tolCi8YAAAAAAAAAVKfq/GcWAAAAAAAAABRi0RgAAAAAAACgxCwaAwAAAAAAAJSYRWMAAAAAAACAErNoDAAAAAAAAFBiFo0BAAAAAAAASsyiMQAAAAAAAECJWTQGAAAAAAAAKDGLxgAAAAAAAAAlZtEYAAAAAAAAoMQsGgMAAAAAAACUmEVjAAAAAAAAgBKzaAwAAAAAAABQYhaNAQAAAAAAAErMojEAAAAAAABAiVk0BgAAAAAAACgxi8YAAAAAAAAAJWbRGAAAAAAAAKDELBoDAAAAAAAAlJhFYwAAAAAAAIASs2gMAAAAAAAAUGIWjQEAAAAAAABKzKIxAAAAAAAAQIlZNAYAAAAAAAAosfoiD2pra6tZtmxZzcCBA2tqa2srPSb2cu3t7TWbN2+uGTNmTE2vXtX57xJsE+wO2wTsyjYBu7JNwK5sE7Ar2wTsyjYBu7JNwK5sE7Cr3dkmCi0aL1u2rGbcuHFdMjjKY/HixTVjx47t6WFUhG2CjrBNwK5sE7Ar2wTsyjYBu7JNwK5sE7Ar2wTsyjYBuyqyTRT6ZxYDBw7skgFRLtU8b6r5s1E51TxvqvmzUTnVPG+q+bNROdU8b6r5s1E51TxvqvmzUTnVPG+q+bNROdU8b6r5s1E51TxvqvmzUTnVPG+q+bNROUXmTaFFY19vpyOqed5U82ejcqp53lTzZ6NyqnneVPNno3Kqed5U82ejcqp53lTzZ6NyqnneVPNno3Kqed5U82ejcqp53lTzZ6NyqnneVPNno3KKzJvq/D90BwAAAAAAAKAQi8YAAAAAAAAAJWbRGAAAAAAAAKDELBoDAAAAAAAAlJhFYwAAAAAAAIASs2gMAAAAAAAAUGIWjQEAAAAAAABKrL6nBwDseWpra0Pr1Sv+G5PW1tYufY/29vYOvx6URbbtZGxPAAAA7Ik6c137Qs91DQwAneebxgAAAAAAAAAlZtEYAAAAAAAAoMQsGgMAAAAAAACUmEVjAAAAAAAAgBKr7+kBAJUxdOjQ0N7znveEduqpp4Y2ceLE0LZt2xba3XffHdqsWbNCW7FiRWgtLS2hLVmyJLT169cXem5bW1to7e3toUFXqa2t7fDjevWK/2Yra0VfL5vrzc3NhR4HwO7J9sNFjwnZfti+GaC6FD1OFD12uNalGnVmDpv/0DHZfae+ffuGdsABB4Q2efLk0B5++OHQsnu7ra2tRYcI7AF80xgAAAAAAACgxCwaAwAAAAAAAJSYRWMAAAAAAACAErNoDAAAAAAAAFBi9T09AOCF1dfHTfT1r399aO9///tDe+Mb3xha3759Q6utrS00lra2ttAmT54c2jnnnBPajh07Qrv//vtD+/a3vx3a7NmzQ2ttbX3BcXZE9t+gvb29S9+DvVvR7aRXr/hvsQYOHBja9OnTQ5s6dWpoQ4cODe3BBx8M7a9//Wtoa9asCS3bdsx1/lk217PWu3fv0LK5fvjhh4e27777hpbN9V/84hehbdy4MTRzmK6SzfW6urrQsvOzhoaGQu+RnRO1tLSE1tXzOjs+ZYqeE2XnhdBVsu2upqamZtCgQaENHz48tCFDhoS2evXq0FasWBFaU1NTaI4z/Lds/z948ODQsjlc9Dixbt260LJjR3coelzMjjHNzc2h2ZYok6LnXs6p6ArZ8enggw8O7Z3vfGdob37zm0MbNWpUaNm1+G9/+9vQvve974W2cuXK0Lr63i7QdXzTGAAAAAAAAKDELBoDAAAAAAAAlJhFYwAAAAAAAIASs2gMAAAAAAAAUGLxV9L3Ar16xbXu9vb2Qs8t+jjobtm8PuOMM0K7+OKLQzvmmGNCq6ur6/BYmpubQ9u4cWNoLS0toTU2NobWu3fv0A466KDQjjjiiNDmzJnzQsPsMvYLvJjOHGOybXvbtm2h9evXL7SBAweG1qdPn9Cy7a7osbLoZ2trayv0OPZutbW1oWXza/z48aG94hWvCO2Tn/xkaKNHjw4tO8Zkc/2qq64KbfPmzaHZr/Nisn1kdr4ycuTI0IYOHVrouWvWrAlt3bp1oe3YsSO01tbW0LJ5nW2z9fXxEi9r2etl+/qsZeeAjhN0lRe6jhk0aFBor371q0M78MADQ3v44YdD+8tf/hJatt0WnduOPXuvbM6NGTMmtOOOOy60qVOnhpbtczds2BDaQw89VKhl1+fZfrio7BiY/TdoaGgILdsOs3PF7NwuO2fLjneUQ3YOU/RxL7S/7Y79cDaebFsZPHhwaNnxJNs32C74V7I5OGLEiNC+/vWvh3bSSSeFls3fTHZ/6uyzzw4tOwZm1/HPPvtsaE1NTYXGAlSWbxoDAAAAAAAAlJhFYwAAAAAAAIASs2gMAAAAAAAAUGIWjQEAAAAAAABKLP4yeQ/Kfni9d+/eodXV1YXW1tYWWktLS6HHtba2Fnpcpr29vdDj4MX06dMntP79+4c2cuTI0LI53NTUFNrKlStDu+OOO0K74oorQlu4cGGhsbzjHe8I7cwzzwytV6/4b1YGDRoUWrYdQ0fU1tZ2+Lmd2dfv2LEjtGz73Lx5c2jbt28Pbf78+aGtW7cutOw4VvRzZI8r+t/PcXHvls2b7LzruOOOC+3yyy8PbdSoUaFlc6lfv36hvfvd7w5t7ty5of35z38Orbm5OTTKK5tz2bxubGwMrW/fvqFNmjQptGHDhoW2ePHi0B577LHQdu7cGVom+xzZ+VR2TZV9tuxx2XEnO2Y5P6s+2fzKWmfOJYq+b7Z91tTU1Bx55JGhnXXWWaENHjw4tOw6KLuG6ozO/Pei+2T79cMPPzy0c889N7SjjjoqtPr6eFst25dm5zDZ+f/WrVtDy87Pim6zWcvGnJ2LZce2AQMGFGrZuVh2XdSZaxb2TNk+PJsjBx54YGinnXZaaNn5yp/+9Kf0vR966KHQsu0sm2NFr4Gzc6/sft6YMWNCW7NmTWhF73HbLsopm2/Zec5b3/rW0KZPnx5atv/vjGzbPvjgg0ObNm1aaNm1UnbsMPfpiKL770xXz7mi52LZ/C+6RtnVfNMYAAAAAAAAoMQsGgMAAAAAAACUmEVjAAAAAAAAgBKzaAwAAAAAAABQYl376+cv9CbJDzv3798/tEGDBoU2ZcqU0LIfrd62bVtoAwcODG3NmjWFXq+lpSW0zZs3h9bY2BhaQ0NDoee2traGlv0wdjaWHTt2hLZ27drQdu7cGVpP/YA2/1r2t3rkkUdCe+qpp0KbP39+aL/73e9Cu/XWW0Nbvnx5aEV/8H3dunWh3XLLLaHNmDEjtFGjRoV2+OGHh5ZtY9n8h3+W7UuLPq7o/M8UfW52XMyOgStXrgxt2bJloWXHwGxfX3R8Xf3fhb1Hdk40bNiw0C6++OLQ9tlnn9CKzqWsjRs3LrRLL700tA0bNoQ2e/bs0Jqbm0ODf5ZdO5x00kmhTZgwIbTsvH7BggWhZedOTU1NoWXbRLY9Zdts7969Qxs6dGho2XFn6dKloWXXIuzdis6lovvwrr6+7NevX9pPOeWU0I455phC4xk8eHBoRa+VnQPtvYruI8ePHx/a2LFjQ8vmZt++fUObM2dOaNn1eXa9v3Xr1tCKyuZq9t8gu2eVbSP7779/ofdYv359aNmxo66uLjT2btnfNNue3v72t4d2/vnnh5bdJ8rup06ePDkdz5e+9KXQnnnmmdCy+Vn0WJZtA9nxJLvXlr1v0XsX7L2y7ST7u2fHk+yaODv3Of3000PL9v/ZXM3Gkj0uu47J7ln9+te/Du2ee+4p9B7OufZuRfdn2TaR/e2z85XsGvaggw4K7cMf/nBo06dPLzS+xYsXh5adx2X3nYqe62Tb04oVK0LbtGlTaNu3by/0Hp3hm8YAAAAAAAAAJWbRGAAAAAAAAKDELBoDAAAAAAAAlJhFYwAAAAAAAIASq+/qF8x+oLp///6FHjd06NDQsh98z37wuugPbU+dOjW07IfhR40aFdo+++wT2vjx40Pr3bt3aAsXLgwt+8H3AQMGhDZ48ODQ1q9fH9pPf/rT0LIf6S76Q/N+fL7n7dixI7SZM2eGtnLlytAeeeSR0LK/fVfbb7/9Qhs+fHho2XaStZ6S7VOy1tbW1h3D4V/I/i7Zfj1TdD9X9BiTvW+fPn1CO+SQQ0IbPXp0aI8//nhoGzZsCC2bh53Zh9v/l1c2188777zQJkyYUOi5zc3NoTU1NYWWzbm6urpC7/ulL30ptOuuuy60W2+9NbTly5eHZr9eDn379g3tuOOOC+3YY48NLTvXyebXo48+GlrR+d8Z2fXEYYcdFtq+++4b2t///vfQ5s+f3zUDY4+Rna80NjYWem5nrieKnrONHTs2ff5rXvOa0AYOHBjapk2bQlu6dGlo3bE90n2y+ZX9PbO/+6pVq0LbunVraNu2bQtt3rx5of3xj38M7W9/+1uh9+jq65NMdt39kpe8JLTsuLh48eLQsvtdmzdvDq2lpaXgCNkTZfvrfv36hZbNmwsvvDC07L5r0fswa9asSceY3VfO7uWuW7cutOz+W3ZdkLXsmie7b5tt362trYUex54n2yaya4xsXSQ7D99///1DmzRpUmjZnFm0aFFo2Tnbxo0bQ3vyySdDy+5FZfv/bLt57rnnQsuOd9nnoPrU18flx2xdMNtXH3HEEaF94AMfCO3oo48ObeTIkaFl95iy7SSbm6eddlpob3nLW0LL1vGy7e43v/lNaH/4wx9C2759e6HW1XzTGAAAAAAAAKDELBoDAAAAAAAAlJhFYwAAAAAAAIASs2gMAAAAAAAAUGLxl6g7qaWlJbTsx5mzH4Vua2sLLfuR9ezH4rOW/fh81pYtWxbakCFDQuvXr1+h11u5cmVoCxYsCG38+PGhHXzwwYXGkv13XrVqVWh//OMfQ8t+pL69vT00ulf2N1izZk1o2fzavHlzaNkc6WqDBg0K7aKLLgqttrY2tGzbvu6660Lbtm1bodcrquhcz96joaEhtJ07d3Z4LHSN7G/Vq1f8N1F1dXWhZdtJdiwq+r7ZHNl///1DO+GEE0LLjovZ9m4fTiVNnz49tA9/+MOhZedE2TzMtqdsv7lly5ZC7zFw4MDQDjrooNA++MEPhvb6178+tC996UuhzZ8/P7Si+wX2TNn+f+LEiaGdf/75oU2ePDm0TZs2hfb444+Hls3rTNHzmuxxjY2Nob30pS8N7ZWvfGVo2XFn0aJFoT3xxBOhOe7sPYrOmwEDBhR6vezcqTPn19m+/pRTTkmfn13zZ+d82f2Hv/3tb6E1NTWl78PeKZuH2fzIHpftr5ubm0PLtpPsudm1bjYvi2472XGs6HPr6+Ntv+z65GUve1loBx54YGjZfacNGzaElp3vZWN2PNm7DR06NLQZM2aENnz48NCyY0K2X547d25oDzzwQDqe7H2OPPLI0J588snQsuNEdq8tk10rFJ3btoG9Q7Yvzc5LsmvObB+enYc///zzoWXzMjsXy87hlyxZEtry5ctD27hxY2jZtpjN8+w4mz3O9XQ5ZNtJtv6VnXOcdtppoe23336hjRkzJrTevXuHlp2HZOcrv/jFL0LLrn+PPfbY0E4++eTQsv1CdizJtol169aFVvSeQlfzTWMAAAAAAACAErNoDAAAAAAAAFBiFo0BAAAAAAAASsyiMQAAAAAAAECJxV+nroDsh52L/gB09mPsixcvDq1///6h1dbWhrZ+/fpCj8t+uHvEiBGFHpeNL/u8hx56aGjf+ta3Qttnn31Cy8bct2/fQuNjz1R0O2lpaQmttbW1ImP6Z9lcuuqqq0J7yUteEtrWrVtD+81vfhParFmzQss+W9FtNpP9d85apqmpqdDjqJxeveK/dSo6H7LHFW2Z7HHZ+LJt4sQTTwztqaeeCu3pp58OLdsHdIfs87a3t/fASOgqQ4YMCe0nP/lJaIMGDQotm+vZPvKZZ54J7cEHHwxt3LhxoWXbcfZ6o0ePDm3ChAmhvexlLwvt4x//eGiXXnppaOvWrQvN/O9eRfdB2dxsbGwM7aSTTgpt8uTJofXp0ye0hx9+OLRsH94d52e9e/cOLZvr06ZNC23nzp2hZdtd0fMk9kzZ3zRr/fr1Cy2bI119npRtn0cffXT6mtkYM//4xz9Cy7ZR+/Hql/2Ni147HHjggaFl50TZfaJs/5/N/2z/WldXF1q2r88+W9bGjh0b2gUXXBDalClTQlu9enVoTzzxRGjbtm3r8PjYu2XbxAEHHBBatt1l1w4PPPBAaJ/97GdD27JlSzqeiy++OLRjjjkmtLvuuiu0+fPnF3qfovO46P7Hdfaep6GhIbTs3vyMGTNCy+bbk08+Gdpf//rX0B577LHQsv1rJpu/2dzavn17aNmxqOgczJ5rnlefon/TUaNGhXbJJZeE9upXv7rQ+2brIrfeemto99xzT2iPPvpoaEuXLg0t289n54X77rtvaCNHjgwtu7bJ3mPBggWhZesnPbWd+KYxAAAAAAAAQIlZNAYAAAAAAAAoMYvGAAAAAAAAACVm0RgAAAAAAACgxOKvOndS9uPMLS0toWU/AN3a2lro9bIfgW9ubg6tqampw++RtaI/2l70R+D79esX2saNG0PLxrx+/frQ7r333tB27twZmh+a33tkc7g7/n4NDQ2hfec73wntDW94Q2jZ3Lz22mtD++1vfxva9u3bQ+vVq9i/bcke17t379CyfUW2nWTbMT0vm//Z376uri60bF+a/Z07s4316dMntFe84hWhjR49OrQ77rgjtA0bNoTWHfuAosc79h7Z3/RjH/tYaBMmTAgt28aybWfevHmhzZw5M7R//OMfoTU2NoaWnSsOHTo0tLe85S2hHXzwwaFl511HHnlkaOPHjw9t3bp1oVE5Xb0PGjJkSGhTpkwp9NwVK1aE9qtf/Sq05cuXh1b0XKIzn23AgAGhZfN/zJgxoWXb7NKlS0PLruUcE/YeRc916uvjrYFNmzaF1pn5kG3bw4YNC+2QQw5Jn58dj7J7A9dff31oO3bsKDJEqkzRuf7Sl740tOx8PTuXGDlyZGgHHHBAaIsWLQotuw4dNGhQoffNnjtixIjQvvWtb4WWHQOzbeS6664L7aGHHgotu8Z2nKg+2baTnV/07ds3tGx+ZedOv/zlL0PL5vprXvOadIynnHJKaP379w8tu/eafb6uZrvYO2T3k7Lz69e+9rWhZedOs2bNCm3OnDmhFd2XZudT2flZpqvvgWWK3rfrzOvR87K1gzPPPDO0U089NbTsXCfbdn7zm9+E9v3vfz+0NWvWhNaZuT5q1KjQ3v/+94eWHV+y93300UdDmzt3bmg9tQ6U8U1jAAAAAAAAgBKzaAwAAAAAAABQYhaNAQAAAAAAAErMojEAAAAAAABAidV3x5tkP9ic/bh7fX0cTvbc7Eehs9fLfni6q3Xmx6iHDBkSWvZD4Fu2bAntgQceCO3vf/97aDt27OjY4NgjdMePnWc/2v7LX/4ytJe97GWhZT80/4Mf/CC0u+66K7TFixeH1traGlr236C2trZQ69Ur/ruY7HHsPYrOh2z/39XHibq6utCGDRsW2hve8IbQsjHffffdoW3fvr2Do4NdZecX55xzTmhFz8WefPLJ0C688MLQHnnkkdCyc5Oi++aBAweGdswxx4SW7f/79OkT2rhx40KbNm1aaHPmzAmtO47R7L7sbz969OjQsrm+YsWK0LJzmKxl87o75kh23HnJS14SWvZ5N2/eHNqGDRtCy87P2Htk5zrZ3Mz+9tl1aNHXy/br2bnTpEmTQhs7dmxoL+TZZ58N7S9/+Uto3XFvgD1PNg+zc4nJkyeH1tLSElp2L2rw4MGhTZ8+vdD4evfuHVp2bpId2xoaGkJ75zvfGVq2jWWeeOKJ0G655ZbQtm7dGppzouqTzblsvmbXGNl2l82b7J7QxIkTQ5s6dWpoZ555Zmg1NTU1w4cPDy2bn9n243yH/5bNj+OPPz60bJu45557Qnv88cdDy44nnVH0PMf+mq4yYMCA0LL7n9l5UnZtmsm2new+aTavi16fZOtzN9xwQ2gHHHDACw1zF9k1dvZ669atC21P2j590xgAAAAAAACgxCwaAwAAAAAAAJSYRWMAAAAAAACAErNoDAAAAAAAAFBixX51upu0trYWapmiP/heVPbD2EV/jDp7bp8+fUKbPHlyaP369Qvt2WefDe36668P7ZlnngmtpaXlBcdJ+TQ0NIT2rW99K7TXvva1oTU3N4d2++23h3bHHXeEtmLFitCyH67Ptvdse+rVK/57l+xx2fzPtuPs9bp6n0L3yv7O2d+0M/v1+vp4CH3JS14SWrZfX7RoUWgPP/xwaEWPgZ2Rzf+i/13Ye7zsZS8LbcyYMaFl28mSJUtCe+973xtaNoeL7oeL2rx5c2jjxo0LbdCgQaFlc72xsTG0ww47LLS6urrQHCcqJ5sjRc/Ns31zdh6e/f2y85U//elPoW3YsKHQWLpadh6Xbdv77bdfaFu2bAnt6aefDm3lypWhmet7t2xuZuf1mc7sw7NtNjsneuUrXxlatr+uqamp2bZtW2g33XRTaGvXri0wQsqqd+/eoWX7yOyYkJ1fbNy4MbRRo0aFds4554S2//77hzZgwIDQsrk/YsSI0A444IDQsm0x2wfcd999oS1dujQ0x4RyyOZNdt48cuTI0LLjRFNTU2jZMeHlL395aBMmTAhtyJAhoe2O7PNl50/Z8WTnzp2hZZ+5aGPPM2nSpNCmTp0aWrYfXr58eWjZ/C8qm6tFW6Y77jFlsmNH0TGzZ8qusbP9aHZ9XvRe/xve8IZCz50zZ05o2TnMEUccEdo111wTWnZsy+4JZceD+++/P7Si98r2JL5pDAAAAAAAAFBiFo0BAAAAAAAASsyiMQAAAAAAAECJWTQGAAAAAAAAKLH4S9Q9qLm5udDj2tvbC7XO/Fh81oq+R2NjY2hTpkwJ7c1vfnNo69atC+36668Pbe7cuaFt2LAhtOyH5imHbG6eeOKJoZ188smhNTQ0hNbU1BRa9qPtEydODC378flse8oU3d6zlo0506tX/Pcz2X+/TNHPQeVkf4PW1tZCz+3qff2xxx4b2r777hvavffeG1q2D8/mZtHPlqmrqwutd+/eoe3cuTM0c33vkc3XSZMmhZadI2T79csuuyy02bNnh9aZuVlUNoez88ds/9+vX7/Qtm3bFtqyZctCK3pMoHsV/btk8yY753722WdD2759e2jZttOZfWS2r+/bt29oL3/5y0P70Ic+FFq2X8/Oxe65557Qtm7d+oLjpHpk++uuntfZ9jls2LDQpk2bFlp2LVJTU1OzevXq0B566KFC793Vsu3WtfeeJ5sL2X59+fLlod19992hrVmzJrSBAweGlu1zjzrqqNDGjBlTaHxDhw4NLbvGKHpts3LlytB+9KMfhbZjx45Cr0f1KXqftOh5Q3bcyeZ1dr6enRO90P3j7Fome+/sevf1r399ofdZu3ZtaKtWrSr0Ht1xvcTuyc45Ro8eHdrYsWNDGzx4cGj7779/ocdl1yKZPn36hJbt/7N7UU888URoCxYsCC2bl9nczx5X9P4se7eif+fHHnsstOxcZ8iQIaFl5xyHHHJIaAcccEBoS5YsCW3EiBGhZdcd2bEok83/OXPmhDZr1qzQ9sZ7TL5pDAAAAAAAAFBiFo0BAAAAAAAASsyiMQAAAAAAAECJWTQGAAAAAAAAKLH6nh7AP+vqH0/PnturV1wnz1pbW1uhx/Xu3Tu0YcOGhXbWWWeFduCBB4Y2f/780O67777QFi9eHFpLS0tolFdDQ0Nop512WmiNjY2hbd68ObQnnngitFWrVoW2YcOG0LIfiy+6vXemZT8q35nWmf0RlZP9XbJ9eCb7O2ey/X///v1DO/roo0PbsWNHaH/4wx9C27ZtW6HxZWPJHpcdnwYNGhRa9t+qubm50OPYM2X7/xNOOCG0bNtZs2ZNaHfeeWdo2X69q2VzvU+fPqHt3LkztLq6utCKzuGHHnqow8+lcjpznM+eu2XLltCyc6IRI0aElu1Ls3On7H2zY8eoUaNCmzRpUmhf+MIXQjv44INDy+Zrds42d+7cQs+l+mR/56LnREUfV18fbzVk29O4ceNCy85Dampqah588MHQli9fHlrRc6VM9tzsmJK9XlNTU2iuH3pW9vfMZPdXHn300dCWLVsWWvZ3z7axP/7xj6Fl5zXZNvHa1742tPPOOy+07Di2devW0C677LLQnnzyydA6c4/J9fTeLftbZfvmhQsXFmoTJ04s9L7r168Pbe3ataFl1841NTU1mzZtCi07HmXXPMcee2yhll0rXH/99aE99dRToWX7BttFz8rmx7777htadr4+cODA0N7//veHls3/WbNmhTZ48ODQzjnnnNCOP/740LLPMW/evNCy7Sm7f3DjjTeGdsstt4S2bt260LLjYsZxYu+WnV/MnDkztGyfedRRR4W2YMGC0J555plC75u93ujRo0PL5nom21cvWrQotF/96lehZffPsvvCe/pahG8aAwAAAAAAAJSYRWMAAAAAAACAErNoDAAAAAAAAFBiFo0BAAAAAAAASiz+Sno36akfcc7eN2tFf4y6rq4utAMOOCC04447LrS+ffuGds8994Q2f/780LIf/c5+pJtyyObmS1/60tAOO+yw0DZt2hTaU089Fdo111xT6HHbt28Prbm5ObRsvhbdL2SPy16vvj7u4gYOHBhaa2troddraWkpND66V9F9eK9exf6dVPZ62VwaP358aBMmTAht5cqVod15552hrV+/PrRsHmafo6GhIbQhQ4aE1r9//9CyfUDRY2BPHcv518aOHRtatv/P5k1TU1NFxvTPsrmUyba77Ng2ffr00LLPlr3vihUrQlu4cGFozrH2btu2bQtt0aJFoWX78IMOOii0fv36hbZly5ZCj8uuExobG0MbN25caIccckhoffr0CS3bjlevXh1aNmb4Z9k5R9F9eO/evUM76qijQhs8eHBoO3fuTF/zrrvuCu25554LLdtnZ9ft2WfJjh/Zc7PrAudKPSubr9nfLpMd+5ctWxZaNjeL/o03btxY6HFLliwJLftsZ599dqHXu/rqq0P71a9+FdoLbXeUUzavs3s92T2h6667LrRTTjkltGHDhoWWzf/sPbJr7Jqampp58+aFNnLkyNBe97rXhXbEEUeEll0/77fffqEtXrw4tGy/YjvrWdm5yYABA0LL5mbR84PseuLMM88M7fWvf31oo0aNCm3QoEGF3jfbZqdNmxZadjzJnjtmzJjQnn766dD+9re/hVaUa+y9W3ZMmD17dmgPPfRQodfL7s1nczObw3//+99Dy7anww8/PLTs2nnVqlWhXXLJJaH95S9/CW3Hjh2F3mNPn/++aQwAAAAAAABQYhaNAQAAAAAAAErMojEAAAAAAABAiVk0BgAAAAAAACix+p4eQHfLfkA7+6Ht2traQq83cODA0D7zmc+EdtBBB4V29913h/b73/8+tE2bNoWWjZnyyn7cveg8zH54fe3ataHNmzev0OO2b98eWtHtqajsR+979+4d2vDhw0MbPXp0aNk2tnLlytA2b94cWrZPoXtlf4OsFZ2H2eP69u0b2utf//rQ9t1339Dmz58f2qpVq0JramoKrejnKNpaWloKPS7bxrLHmf97pkGDBoU2cuTI0BobG0MbMWJEaCeeeGJoV199dWjZ8SSTzaV+/fqFdvjhh4f2ne98J7TJkyeHlh0Tsm3sT3/6U2hLly4Nrehno+dl58jLly8PbfHixaH16dMntKFDh4aWbRPZHB4yZEhojz32WGh33nlnaEX365mdO3eGlp3DZMcEyqEz50mZ7LmDBw8O7ZRTTgmtf//+oW3cuDF9n+eeey60DRs2hFZ0bhfdzrLzoqKt6HkqnVf0v+vWrVtDy64Hs31pd5wPZMexffbZJ7RsG3v22WdD+/a3vx1ads3e1czzvUfR/X+2b123bl1ot912W6HnjhkzJrTsfP3pp58OLZvrNTX5Paply5aFdvDBB4eW7Ruy88DsWmu//fYLLbvW2rJlS2i2le6T7cOz//7PPPNMaE8++WRoEydODK3oMaYz93Wyz5G1+vq47FNXV1fouQMGDAgtu94xf8sr2193h2zONTQ0hDZ16tTQsnu72XHjy1/+cmi33HJLaNm5Ylffo+4pvmkMAAAAAAAAUGIWjQEAAAAAAABKzKIxAAAAAAAAQIlZNAYAAAAAAAAosfiL6FWuMz/Qnv1A9YwZM0I74ogjQtu4cWNoV111VWgrVqwIrbW1tegQKYG6urrQsh93P+6440IbOnRoaC0tLYUel83/LVu2hNbW1hZa7969Q8tkc71Xr/hvW4YNGxbascceG9qkSZNCW758eWjr1q0LbcyYMaHde++9oWWfl57XmX19Nuey+TB9+vTQBg8eHNrjjz8eWjYPi+7rs20x24537txZ6D2y59bXFzs9yN6D7pXNh8z69etDGzJkSGiNjY2hvfWtbw3tz3/+c2hr164NLZtfDQ0NoU2ZMiW0//2//3doEydODC07Lmb75meffTa0K664IrTs2MaeKdvXZ/u57Dx8zpw5oW3YsCG0kSNHhrbvvvuGls31ZcuWhXbfffeFls25efPmhXbqqaeGdsghh4S2devW0Hbs2BFaZ46V7N2yv33WsmNM9rjs3Ck7D58wYUJo2TnHc889F1pNTU3NHXfcEVpTU1OhMRY9XmbHj6xlr5cd3zLZ/oLOy/7uzc3NoWXHiexv3FP7yGweZdcd2Xn4jTfeGNqaNWu6ZmCUStH5n+3PVq9eHdrdd98d2qGHHhraiBEjQtu+fXto2fV0TU1NzaZNm0LL7kdl1+gnnHBCaNm9seya56mnngotG3d27Ch6rKXzsv1/NmceeOCB0C677LLQJk+eHFp2jZ29Rza3sjmYXf9m513ZsWP06NGhFb12zq6fsm2p6PkVdJXs2uHTn/50aEceeWRo2XXDT3/609B+/vOfh5ZdT3fGnr6f901jAAAAAAAAgBKzaAwAAAAAAABQYhaNAQAAAAAAAErMojEAAAAAAABAicVfjqampib/Iffx48eH9olPfCK0YcOGhXbTTTeFdv/994fW0tJScISUVa9e8d96DB06NLTGxsbQsh+Lz354fdSoUaEdcMABoW3ZsiW0fffdN7SpU6eGNnjw4ELj69+/f2gTJ04Mbb/99gtt8+bNod13332hrVq1KrTsB+7XrFkT2ty5c0Oje2VzuDOybWz//fcP7dBDDw2toaEhtMcffzy0pqamDo4u/7zZsSOb/9lnKyo7LtLzsvmwYMGC0O65557QsmNH7969C73HG97whtCyeZ3t14888sjQ3v72t4c2fPjw0LJ52NbWFtrzzz8f2gc+8IHQFi9eHBp7t2w+bN++PbRsv5kd+1esWBHaww8/HFq2z920aVNozc3NoWWyc5PHHnsstOz4tG3bttAWLlwYWmtra6GxUA7ZtpPtc4u2MWPGhJad/2fb4u23356OMbv2KHoemD0u+8zZsSwbY9HzIudPPSv7uxfd93X1NUYmmx99+/YNLbsXlR2znnvuua4ZGCSKbhPZfnTp0qWhZdem48aNC+2pp54KbcOGDel7Z/v1bNzPPvtsaH//+99Dy64pnnjiidD+/Oc/h5adfxYdH5VR9F5Kdu/v3nvvDe2RRx4Jra6uLrRsX5/dO8qu2Q877LDQDjzwwNDOOOOM0IreA86uT9avXx9adm1j/lJJ2fb0uc99LrTzzz+/0HNXrlwZ2le/+tXQsnOssvFNYwAAAAAAAIASs2gMAAAAAAAAUGIWjQEAAAAAAABKzKIxAAAAAAAAQInFX0QvoewH6QcNGhTa//yf/zO0cePGhbZ58+bQfvKTn4S2devWokOE/6u+Pm622VxqaGgIrVev+O9EstebOHFiaOedd15o2Q/DT506NbSRI0cWet/W1tbQmpqaQmtpaQmtubk5tOwH7g866KDQnn/++dC2bNkS2qpVq0Jjz9Te3l7ocdn+f/DgwaGdfPLJoe27776hZfP1ySef7PD4imprawst256Kvm/2el09Zion2zfPnDkztOOPPz60UaNGhXbssceGNn369NB69+4dWnYsKnp8ymTzcOnSpaG95S1vCW3evHmF3oPqk82bbH+dncMX3b9u27YttOzcpKhsm+jfv39o2fhWr14d2oIFC0KzX+fFZHMkO3caNmxYaK9//etD69u3b2jZdnfnnXem48nme2dkn68z20W2b+jqMbN7is7hrlb0PbJr4kMPPTS0adOmhTZw4MDQTj/99ND+9Kc/hbZx48ZC48s4dvDPis6H7B5Odn9l/fr1oWXzdXf2rXV1daFl5233339/aNm4Fy9eHFrRc0jbz56n6FzKjvHZfM32/1nL9v/ZWLJ28MEHh5adi2VzP5NdsxTdFot+XnOfF5NdJ3z2s58N7ZJLLgmt6PaUrW1Yn8v5pjEAAAAAAABAiVk0BgAAAAAAACgxi8YAAAAAAAAAJWbRGAAAAAAAAKDE4q9El1CfPn1Ce/e73x3aG9/4xtCyH3f//e9/H9rDDz/cwdHBi1u7dm1oy5cvD61fv36hZXO4rq4utKOOOqrQ62WtV69i/z4lG0tLS0toO3bsCG3hwoWhzZ07N7RnnnkmtKeffjq0xx9/PLQ1a9aExt6jvb09tGxujh49OrQpU6aE1tDQEFo2D9etW1doLJ2RbTvZe7S1tXX4cew9sv3mE088EdrNN98c2vvf//7QBg0aFFp2nMi2p2xuFpXNw2y/fuqpp4a2ZMmS0Lp6u2PP1Jm/c1NTU2jNzc2FntvV+81Ro0aFNnbs2NBaW1tDy85rsnOYzmyflFc2b/bbb7/QJk6cWOi5q1atCi27tqmEbDydOacqep5Fz8r+Jt2xP6yvj7ffxo8fH9oXvvCF0LJjQjbmI488MrQJEyaElp0XZrJjTNF5XrTR84rO/6J/v6L7zC1btnT49V5oLEX34Vu3bg0tu5bPrvlXr14dWnYOab5Xv87s57L9a3ZOVPQ+ae/evQu9b7YtZtcJN9xwQ2hLly4NLfsc2X0Bxwn+WWNjY2jvec97QvvIRz4SWrZfzsyePTu0P/7xj4Wei28aAwAAAAAAAJSaRWMAAAAAAACAErNoDAAAAAAAAFBiFo0BAAAAAAAASqy+pwfQ3erq6kKbPn16aBdddFFo/fr1C23ZsmWhXXzxxaFlPwwPHbFz587QHnzwwdA+9KEPhfayl70stOOOOy60cePGhTZ69OjQ+vbtG1o219vb2ws9btOmTaH94x//CO3WW28NLftvsGrVqtCWLl0aWltbW6HxUX1qa2tDGzZsWGjZ/n/9+vWhPfDAA6GtWLGig6MrLtvGisrmP3u3bD5s3bo1tK985SuhZfP1sssuC23gwIGhZdtTJtu/rl69OrSzzz47tL/97W+hNTc3F3pfyqsz+8jOPLeo3r17h3bUUUeFtmHDhtD69OkT2sqVKwu9b0NDQ2gtLS2hdcd/A/ZuI0eODC07TmT76+x6evv27V0zsApyrVBduno/l50TZdcTb37zm0ObNm1aaPX18dZd0WvY7Dp+yZIloTU1NYWWfY7sfkT2XPYe2fzP/vZZ6+pzrEqcc2TbSnY8yj5fdjxyXkSlZPvwdevWhbZmzZrQsv1wtgaS3RP98pe/HNof//jH0DZv3hxa0f1Hth3alsohmw8DBgwI7bzzziv0uGzeZHPzlFNOCc39z+J80xgAAAAAAACgxCwaAwAAAAAAAJSYRWMAAAAAAACAErNoDAAAAAAAAFBi9T09gBeT/Vh20R9Zz37wfdSoUaG9613vCm3YsGGhZT8q/5Of/CS01atXhwZdJfvR9m3btoX2wAMPFGpFZdvTwIEDQzv44INDGzt2bGirVq0KbcWKFaFlP2a/du3a0Jqbm0PL9hXwz7Jjx8qVK0O7+eabQ2toaAjt/vvvD23Dhg2h9dTczPYflEM257L96w9/+MPQfve734V20kknhZbt67ds2RLaL37xi9CWLFkSmn041Sg7nxoxYkRogwcPDm3+/PmhtbS0FHqPIUOGhNa3b9/QsnNK+GfZ/GptbQ0t269n50RPP/10aNl5fU1N8XsDRWXPzVr2+eBfyc65d+7cGdrGjRsLPS67F5W1bHvKxpJdx2THk8bGxtCyczvXGOWQ7YOz1pN69er4d6Pq6+Mt8qxl50/ZtgxdITsmXHPNNaEdddRRoWXnL1/96ldDe/bZZ0PbsWNHaEXPuVzH88+ya4fDDz88tOycI5v/2XnI17/+9dDWrFlTdIgkfNMYAAAAAAAAoMQsGgMAAAAAAACUmEVjAAAAAAAAgBKzaAwAAAAAAABQYvU9PYCOyH5AO2v77LNPaOedd15ob3zjG0Pr27dvaNkPaF933XWhtbW1hQZ7u9bW1tA2bNgQ2gMPPNCl71tbWxtae3t7l74H5dXS0hLaM888E9qPf/zj0LK5uXXr1tB27tzZwdF1ju2Ejsi2iWeffTa0mTNndsdwoOpkx45t27aFNnfu3NCya4wtW7aENmfOnNCy7Tg7ZsGLyY4Ts2fPDu173/teaP379w/t6aefDm3ZsmXpe3fHdbZreSoluya4/fbbQ9tvv/1Cmzx5cmjZPbD7778/tIULF4aW3dsqeozJ7guwd8uuG3v1it8xyuZcfX28rdynT5/QduzYEVpTU1OhsezOPaFs3Nljs/E8//zzoTU0NIQ2YMCAQu9rW6ErZPM3m6vvfve7Q8u2ne3btxd6D+iI7DgxfPjw0M4444zQGhsbQ1u+fHloN954Y2hXXnllwRFSlG8aAwAAAAAAAJSYRWMAAAAAAACAErNoDAAAAAAAAFBiFo0BAAAAAAAASqy+pwfwYrIfY29tbS30uObm5tAOOuig0LIf5O7VK66nL1u2LLQVK1YUGgvQMbYnKimbX01NTaGtX7++w68HAP+tpaUltI0bN4b2yCOPhLZ06dLQ7rrrrtCy49iaNWtCy66V4MW0tbWFtnbt2tCyuZnJru2hLFatWhXaFVdcEVq23WVtx44dhRq8mGzfnM25ovdss/Of7LlFr6eze7Yv9N7Za27bti202tra0BobG0Pbvn17ocdl7wFdoeh9rM5sY9ARdXV1oR144IGhDRs2LLTnnnsutGw/+stf/jI05zpdzzeNAQAAAAAAAErMojEAAAAAAABAiVk0BgAAAAAAACgxi8YAAAAAAAAAJVbf0wPoKm1tbaH16dMntIMOOii01tbW0DZt2hTaFVdcEdr69euLDhGAvVR7e3tPDwGAKpUdY1paWkJbuXJlh1/PcYzull1jQ5ll++GdO3eGtn379i59D+gq2fxqbm7ugZFU5hhTdBvNHldbW9vl44HdkW0T5iXdrampKbR77rkntAkTJoR2xhlnhDZnzpzQHn/88Y4Mjd3km8YAAAAAAAAAJWbRGAAAAAAAAKDELBoDAAAAAAAAlJhFYwAAAAAAAIASq+/pAVTS888/H9pRRx1V6Ln9+vULLfsx75aWlt0fGAAAwAtob28v1ADYe7W2tobWq1f8bkdbW1t3DAf4/yl67uUcjT2Recme6he/+EWhRs/xTWMAAAAAAACAErNoDAAAAAAAAFBiFo0BAAAAAAAASqzQbxqX8f8D3++IdV41//eq5s9G5VTzvKnmz0blVPO8qebPRuVU87yp5s9G5VTzvKnmz0blVPO8qebPtjv8d9g91fzfq5o/G5VTzfOmmj8blVPN86aaPxuVU2TeFPqm8ebNmzs9mL3N9u3bw/9aW1vD/3hh1TxvqvmzUTnVPG+q+bNROdU8b6r5s1E51TxvqvmzUTnVPG+q+bNROdU8b6r5s+2O9vb28D9eWDXPm2r+bFRONc+bav5sVE41z5tq/mxUTpF5U9te4Ay0ra2tZtmyZTUDBw6sqa2t7ZLBUb3a29trNm/eXDNmzJiaXr2q8/8B3TbB7rBNwK5sE7Ar2wTsyjYBu7JNwK5sE7Ar2wTsyjYBu9qdbaLQojEAAAAAAAAA1ak6/5kFAAAAAAAAAIVYNAYAAAAAAAAoMYvGAAAAAAAAACVm0RgAAAAAAACgxCwaAwAAAAAAAJSYRWMAAAAAAACAErNoDAAAAAAAAFBi/w+KFdZ8FPJSuAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this way, we can create the image compressor using autoencoders applicable to any image dataset. However, instead of linear layers, we can also experiment with the LSTM and CNN layers."
      ],
      "metadata": {
        "id": "WzdG_B9kaBXm"
      }
    }
  ]
}