DC_GAN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "DC_GAN.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AbhishekKaushikCV/Deep_Learning_Assignments/blob/main/DC_GAN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mntVzX-KkTMw"
      },
      "source": [
        "# **Deep Convolutional Generative Adversarial Network (DC-GAN):**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "je6HpbYU3OBS"
      },
      "source": [
        "# Implementation\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iUxeV8eY3qsO"
      },
      "source": [
        "### Import Import TensorFlow and other libraries\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5YMUoIHY3w6G"
      },
      "source": [
        "from __future__ import absolute_import, division, print_function, unicode_literals"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "huTsTCrE34lX"
      },
      "source": [
        "import tensorflow as tf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WmyRGuXl37HQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "f04ea60b-cf8a-493c-ccc1-fc73116e327f"
      },
      "source": [
        "tf.__version__\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'2.5.0'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZuZj95fJ39FP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "740e8972-1dd8-4edc-98a1-1ce9e0c23b17"
      },
      "source": [
        "# To generate GIFs for illustration\n",
        "!pip install imageio"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: imageio in /usr/local/lib/python3.7/dist-packages (2.4.1)\n",
            "Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from imageio) (7.1.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from imageio) (1.19.5)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GwD5GaM84AtH"
      },
      "source": [
        "import glob\n",
        "import imageio\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import os\n",
        "import PIL\n",
        "from tensorflow.keras import layers\n",
        "import time\n",
        "\n",
        "from IPython import display"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MMXQ85DR4DlX"
      },
      "source": [
        "### Load and prepare the dataset\n",
        "\n",
        "You will use the MNIST dataset to train the generator and the discriminator. The generator will generate handwritten digits resembling the MNIST data.\n",
        "\n",
        "You can also repeat the exercise for other avaliable variations of the MNIST dataset such as: EMNIST, Fashio-MNIST or KMNIST. For more details, please refer to [tensorflow_datasets](https://www.tensorflow.org/datasets/datasets).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "14Bcb0jq60Hf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f95e8d90-79ce-430b-b212-f28dddf4b03b"
      },
      "source": [
        "(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11493376/11490434 [==============================] - 0s 0us/step\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ujQOxSnZ62fO"
      },
      "source": [
        "train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')\n",
        "train_images =  (train_images - 127.5) / 127.5 # Normalize the images to [-1, 1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UJHsgGAk6454"
      },
      "source": [
        "BUFFER_SIZE = 60000\n",
        "BATCH_SIZE = 256"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0XfVAF_X66U2"
      },
      "source": [
        "# Batch and shuffle the data\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FOP8x5Eu7B9Z"
      },
      "source": [
        "## Create the models\n",
        "\n",
        "Both the generator and discriminator are defined using the [Keras Sequential API](https://www.tensorflow.org/guide/keras#sequential_model)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8XDMtsqY7DQ3"
      },
      "source": [
        "### The Generator\n",
        "\n",
        "The generator uses `tf.keras.layers.Conv2DTranspose` (fractional-strided convolutional) layers to produce an image from an input noise vector. Start with a fully connected layer that takes this vector as input, then upsample several times until you reach the desired image size of $28\\times 28 \\times 1$. Utilize the `tf.keras.layers.LeakyReLU` activation and batch normalization for each intermediate layer, except the output layer which should use tanh."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kTJNxJgP7_v2"
      },
      "source": [
        "def make_generator_model():\n",
        "    model = tf.keras.Sequential()\n",
        "    model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,))) # Fully connected layer  \n",
        "    model.add(layers.BatchNormalization()) # Batch normalization\n",
        "    model.add(layers.LeakyReLU()) # Activation function (Leaky Rectifier Linear Unit)\n",
        "    model.add(layers.Reshape((7, 7, 256))) # Reshaping the output\n",
        "\n",
        "    assert model.output_shape == (None, 7, 7, 256) # Note: None is the batch size\n",
        "    \n",
        "    # Layer 2: Hint use layers.Conv2DTranspose with 5x5 kernels and appropriate stride\n",
        "    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False)) # Deconvolution layer\n",
        "    assert model.output_shape == (None, 7, 7, 128) # Note: None is the batch size\n",
        "    model.add(layers.BatchNormalization()) # Batch normalization\n",
        "    model.add(layers.LeakyReLU()) # Activation function (Leaky Rectifier Linear Unit)\n",
        "\n",
        "    # Layer 3\n",
        "    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False)) # Deconvolution layer\n",
        "\n",
        "    assert model.output_shape == (None, 14, 14, 64) # Note: None is the batch size\n",
        "    model.add(layers.BatchNormalization()) # Batch normalization\n",
        "    model.add(layers.LeakyReLU()) # Activation function (Leaky Rectifier Linear Unit)\n",
        "\n",
        "    #Layer4\n",
        "    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh')) # Deconvolution layer using \"tanh\" activation function\n",
        "\n",
        "    assert model.output_shape == (None, 28, 28, 1) # Note: None is the batch size\n",
        "\n",
        "    return model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Asj3IVEg905a"
      },
      "source": [
        "Use the (as yet untrained) generator to create an image."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "feQZ-lJC91tW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "outputId": "e6715bcb-ad82-4e46-b5b1-2412041235d1"
      },
      "source": [
        "generator = make_generator_model()\n",
        "\n",
        "noise = tf.random.normal([1, 100])\n",
        "generated_image = generator(noise, training=False)\n",
        "\n",
        "plt.imshow(generated_image[0, :, :, 0], cmap='gray')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f17a0237810>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Xmmb04o95iz"
      },
      "source": [
        "### The Discriminator\n",
        "\n",
        "The discriminator is a CNN-based image classifier."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cPtnRu5G96Sm"
      },
      "source": [
        "def make_discriminator_model():\n",
        "    model = tf.keras.Sequential()\n",
        "    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',input_shape=[28, 28, 1])) # Layer 1: use layers.Conv2D with 5x5 kernels and appropriate stride\n",
        "    model.add(layers.LeakyReLU()) # Activation function (Leaky Rectifier Linear Unit)\n",
        "    model.add(layers.Dropout(0.3)) # Dropout Layer (0.3)\n",
        "\n",
        "    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same')) # Layer 2: Conv2D\n",
        "    model.add(layers.LeakyReLU()) # Activation function (Leaky Rectifier Linear Unit)\n",
        "    model.add(layers.Dropout(0.3)) # Dropout Layer (0.3)\n",
        "\n",
        "    # Layer 3: Fully connected layer, output dimension must be 1\n",
        "    model.add(layers.Flatten()) # Flatten layer\n",
        "    model.add(layers.Dense(1)) # One neuron at output\n",
        "\n",
        "    return model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EkHjQFuX-9pe"
      },
      "source": [
        "Use the (as yet untrained) discriminator to classify the generated images as real or fake. The model will be trained to output positive values for real images, and negative values for fake images."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4CGrJESq-_sW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ee1c4225-d37d-4ab2-9e21-ff01baa0eb2c"
      },
      "source": [
        "discriminator = make_discriminator_model()\n",
        "decision = discriminator(generated_image)\n",
        "print (decision)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tf.Tensor([[-0.00057048]], shape=(1, 1), dtype=float32)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kpZVwskn_C7e"
      },
      "source": [
        "## Define the loss and optimizers\n",
        "\n",
        "Define loss functions and optimizers for both models.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XV6so7s2_HCG"
      },
      "source": [
        "# This method returns a helper function to compute the binary cross entropy loss\n",
        "cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f5pIPcDWAVve"
      },
      "source": [
        "### Discriminator loss\n",
        "\n",
        "Define the discriminator loss function. [Hint](https://www.tensorflow.org/api_docs/python/tf/keras/losses/BinaryCrossentropy): compare the discriminator's predictions on real images to an array of 1s."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f2WIIBvLA_A1"
      },
      "source": [
        "def discriminator_loss(real_output, fake_output):\n",
        "    real_loss = cross_entropy(tf.ones_like(real_output), real_output)\n",
        "    fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)\n",
        "    total_loss = real_loss + fake_loss\n",
        "    return total_loss"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZU44oU0sBFx3"
      },
      "source": [
        "### Generator loss\n",
        "The generator's loss quantifies how well it was able to trick the discriminator. Intuitively, if the generator is performing well, the discriminator will classify the fake images as real (or 1). Again, use the same principle used to define the real_loss to define the generator_loss."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5-99MaPHBIX-"
      },
      "source": [
        "def generator_loss(fake_output):\n",
        "    generator_loss = cross_entropy(tf.ones_like(fake_output), fake_output)\n",
        "    return generator_loss"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nu1nNZ6rEOYd"
      },
      "source": [
        "The discriminator and the generator optimizers are different since both networks are trained separately. Hint: use Adam optimizers. Experiment with the learning rates."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4qcuMJOYEPr1"
      },
      "source": [
        "generator_optimizer = tf.keras.optimizers.Adam(1e-4) #Learning rate of 1e-4\n",
        "discriminator_optimizer = tf.keras.optimizers.Adam(1e-4) # Same learning rate as generator optimizer(1e-4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R5F29ay2Dzgh"
      },
      "source": [
        "### Save checkpoints\n",
        "This notebook also demonstrates how to save and restore models, which can be helpful in case a long running training task is interrupted (especially for larger datasets)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RFHeBD5lD5Z9"
      },
      "source": [
        "checkpoint_dir = './training_checkpoints'\n",
        "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt\")\n",
        "checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,\n",
        "                                 discriminator_optimizer=discriminator_optimizer,\n",
        "                                 generator=generator,\n",
        "                                 discriminator=discriminator)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mrlCVZutD6wX"
      },
      "source": [
        "## Define the training loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "smzVTAp1D8vV"
      },
      "source": [
        "EPOCHS = 50\n",
        "noise_dim = 100\n",
        "num_examples_to_generate = 16 # For visualization\n",
        "\n",
        "# We will reuse this noise_vector overtime (so it's easier)\n",
        "# to visualize progress in the animated GIF)\n",
        "noise_vector = tf.random.normal([num_examples_to_generate, noise_dim])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gwbo6eQLEGpm"
      },
      "source": [
        "The training loop should begin with generator receiving a random vector as input. That vector will be used to produce an image. The discriminator should then be used to classify real images (drawn from the training set) and fakes images (produced by the generator). The loss will be calculated for each of these models, and the gradients used to update the generator and discriminator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CYNp18ugFVyI"
      },
      "source": [
        "# Notice the use of `tf.function`\n",
        "# This annotation causes the function to be \"compiled\".\n",
        "@tf.function\n",
        "def train_step(images):\n",
        "    noise_vector = tf.random.normal([BATCH_SIZE, noise_dim])\n",
        "\n",
        "    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:\n",
        "      # Generator output\n",
        "      generated_images = generator(noise_vector, training=True)\n",
        "      \n",
        "      # Discriminator output\n",
        "      real_output = discriminator(images, training=True)\n",
        "      fake_output = discriminator(generated_images, training=True)\n",
        "      \n",
        "      # Loss functions\n",
        "      gen_loss = generator_loss(fake_output)\n",
        "      disc_loss = discriminator_loss(real_output, fake_output)\n",
        "  \n",
        "    # Gradients\n",
        "    gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)\n",
        "    gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)\n",
        "\n",
        "    # Update both networks\n",
        "    generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))\n",
        "    discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7Go3wxFZG7be"
      },
      "source": [
        "def train(dataset, epochs):\n",
        "  for epoch in range(epochs):\n",
        "    start = time.time()\n",
        "\n",
        "    for image_batch in dataset:\n",
        "      train_step(image_batch)\n",
        "\n",
        "    # Produce images for the GIF as we go\n",
        "    display.clear_output(wait=True)\n",
        "    generate_and_save_images(generator,\n",
        "                             epoch + 1,\n",
        "                             noise_vector)\n",
        "\n",
        "    # Save the model every 15 epochs\n",
        "    if (epoch + 1) % 15 == 0:\n",
        "      checkpoint.save(file_prefix = checkpoint_prefix)\n",
        "\n",
        "    print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))\n",
        "\n",
        "  # Generate after the final epoch\n",
        "  display.clear_output(wait=True)\n",
        "  generate_and_save_images(generator,\n",
        "                           epochs,\n",
        "                           noise_vector)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CEfIpOdgG_G9"
      },
      "source": [
        "**Generate and save images**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g2Utgnx5HA2V"
      },
      "source": [
        "def generate_and_save_images(model, epoch, test_input):\n",
        "  # Notice `training` is set to False.\n",
        "  # This is so all layers run in inference mode (batchnorm).\n",
        "  predictions = model(test_input, training=False)\n",
        "\n",
        "  fig = plt.figure(figsize=(4,4))\n",
        "\n",
        "  for i in range(predictions.shape[0]):\n",
        "      plt.subplot(4, 4, i+1)\n",
        "      plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')\n",
        "      plt.axis('off')\n",
        "\n",
        "  plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))\n",
        "  plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_DeQczr2HDD9"
      },
      "source": [
        "## Train the model\n",
        "Call the `train()` method defined above to train the generator and discriminator simultaneously. Note, training GANs can be tricky. It's important that the generator and discriminator do not overpower each other (e.g., that they train at a similar rate).\n",
        "\n",
        "At the beginning of the training, the generated images look like random noise. As training progresses, the generated digits will look increasingly real. After about 50 epochs, they resemble MNIST digits. This may take about one minute / epoch with the default settings on Colab."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_eQcxFIFHJoF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "outputId": "ae6706cb-64d3-4fe2-a2f6-c03a05f45330"
      },
      "source": [
        "%%time\n",
        "train(train_dataset, EPOCHS)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 16 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 4min 54s, sys: 31.9 s, total: 5min 26s\n",
            "Wall time: 23min 22s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9SKdS1TKHMbU"
      },
      "source": [
        "Restore the latest checkpoint."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bp2IoZ2wHPa1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e6e3d1cb-a4d9-48a7-d434-02bd7ec5ccda"
      },
      "source": [
        "checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f16ff5526d0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zWldh9PxHQ9W"
      },
      "source": [
        "## Create a GIF"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "52O9ZFnAHSZ-"
      },
      "source": [
        "# Display a single image using the epoch number\n",
        "def display_image(epoch_no):\n",
        "  return PIL.Image.open('image_at_epoch_{:04d}.png'.format(epoch_no))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3cO4mviuHUPt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 305
        },
        "outputId": "11e5b6b5-909a-4538-cc36-91f77edf0d02"
      },
      "source": [
        "display_image(EPOCHS)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAASAAAAEgCAYAAAAUg66AAABqD0lEQVR4nO2dd5Cd13mfn9t72713ey/YXWCx6BBBggQoSqRIqliWLUuajGg7tpzElmccZxzZ43Eix5FjSy4JEztOTNuyRHXLskiKIimBIAoJkABRtvfeb+/95g/kHO6CAAmQAO69y++Z4UgEgcV3vvI773mrqlAoFFBQUFAoAupiX4CCgsJ7F0WAFBQUioYiQAoKCkVDESAFBYWioQiQgoJC0VAESEFBoWgoAqSgoFA0FAFSUFAoGooAKSgoFA1FgBQUFIqGIkAKCgpFQxEgBQWFoqEIkIKCQtFQBEhBQaFoKAKkoKBQNBQBUlBQKBqKACkoKBQNRYAUFBSKhiJACgoKRUMRIAUFhaKhCJCCgkLRUARIQUGhaCgCpKCgUDQUAVJQUCgaigApKCgUDUWAFBQUioYiQAoKCkVDESAFBYWioQiQgoJC0VAESEFBoWgoAqSgoFA0FAFSUFAoGooAKSgoFA1FgBQUFIqGttgXcC1UKlWxL+FdUSgUbuj3KessD5R13j4UC0hBQaFoKAKkoKBQNBQBUlBQKBqKACkoKBSNknRCK9w8wgFaKBRQq9Xy/xfDsaigcKMoArQFUKlUaLVXHmWhUECv16NSqchkMuTzeXK5nCJECiWJIkBljhAfu91OdXU1DQ0N1NXVYbVa0el0m6ygQqFAJBJhfX2dn/zkJ2QyGXK5XJFX8O7ZaP1tJVwuF1VVVfT29uJ2u9Hr9eTzeTKZDH6/n0AgwNDQEJFIhHQ6TS6XK7vnWdYCtFVfvJtBCJDL5WLXrl28//3vZ9++fdTU1FBZWYlarUalUqFSqSgUCszNzXHx4kXOnDlDJBIpuxdWINZ0de6NENxyfyfUajXV1dXs2bOHX/3VX2Xnzp3Y7Xay2SyxWIzBwUEmJib4+7//exYWFgiFQqTTaVKpFPl8vtiXf8OUvQBtFKFyuvG3inw+Tzqdxuv14vP5CIVCBINBTCYTZrMZvV4vj2QqlYrKykoaGhrYuXMn09PTzMzMFHsJN4xarcZisdDe3s7OnTtxu90YjUYymYwU4ng8TiKRYH5+Hp/Px4ULF8hms2UlSG63m0ceeYS9e/dy+PBhmpubsdvtaLVa1Go1arWaHTt20NLSQkdHB/F4nHQ6TTgcxuv18vd///cMDQ2VxfdQ1gIEV0RIo9EASH/Hxht/tQUgXkSVSiUfpkqlIpVKldVLupF8Pk88HiccDuPz+QgEApjNZmkB6fX6TWvTaDQ4HA6MRmMRr/rmUKlUGI1G6uvr6e7u5uDBg9TU1GA2m0mn06jVanQ6HZFIhFgsRmVlJUtLSywvLxMOh4lEIiX7QYp3U6VSodPpcDqd7Nu3j71797Jnzx7534W1qlarcTqdOJ1Oamtr5bMNBAKsra3x8ssv4/P5WF1dLdk1C8pagMRDc7vd6HQ6DAYDXq+XUChEPp9Ho9FgtVoxmUxYrVYikQiZTAYAs9mM2+3G4XBgNps5ffo0oVCoLEWoUCiQTqcZHBxkcXGR5eVluru7sdlsuFwutFothUKBTCbD8ePHGRoaYmhoCJ/PV+xL33SEeqt7b7PZ2L59O3/9139NZWUlTqdTbiLX+sgymQyxWIyZmRmeeuopnnjiCcLhsHz+pcLGDUKtVrNt2zZ27tzJxz72MVwuFyqVinQ6TSaTYWVlRQYULBYLJpMJo9GITqdDr9dTVVWF2+3mz/7sz5iamuKTn/wkXq+32Et8S8pagADplNNoNGi1WjweD5WVldjtdsxmM1VVVRiNRsxmM6lUilwuJ3dTh8OBxWJBq9USCoVYXl5mZmambP0iqVSKUChELBYjmUzKD1SlUpFMJolGo/T39zM0NEQwGCSZTBb7km8ItVpNXV0dra2t0sFuNBrJZrPS6oUrlp34R6/Xo1arsdvtmEwm+e+lhlqtRqPRoFar0Wq1OBwObDYbOp2OfD5PIpFgbW2NYDDI66+/Lt9ho9GIXq/HaDRis9no6enB4XDgcrmorKwkFovJyGgpU/pX+BYIszQQCGC1WrHZbHR1ddHU1MTBgweprq6mq6sLrVaLVqvFaDTKBy2OZel0mnQ6TW1tLZcuXeKJJ56QD7ncyGazJBIJstksgHxJVSoVkUiElZUVnn76aUZGRgiHwyVh7W08EoujxtVoNBoOHTrEnj17MJvNaLVastksyWSSdDpNMBhErVZjNBoxmUzy443H4/j9ftLpNCaTSR7VSwWxQeh0OkwmEwaDQVp38XicbDaLSqXi1VdfZWxsjL/9278lFAqRyWSk+KrVapqbm/nt3/5tdu3axcGDB9Fqteh0ure8p6VCWQuQIJfLyZ3C6XRiNpsJBoPo9XpWVlakOOl0OmkRwJWXX6PRoNPp2LVrFx6PB5PJxPnz5zl58qR8yOWCyWTCbrfT19fHvn37sNvtGI1GuUadTkcqlSKZTJbcSymO08Knp9VqMRgMuFwu3G43Bw4coLW1leXlZaanpxkYGGBpaYlIJEIqlcJoNFJRUcH27dtpaWnBYDAQi8W4cOECk5OTBAKBkjt+wRVxtVgs1NfXU1VVRXd3N7W1taysrJDJZIhGowwPDzM9PU0kEiGRSEg/p7hna2trfOtb3yIQCFBTU0NFRQV2u51HH32UoaEhXn755WIv87psCQHK5/OkUimy2SyBQAC73U4gEJBWjzhLazQa8vm8FJWNodzW1lZqamqorq5GrVZz4cIFotEo6XS6yKu7cYxGIx6Ph46ODrq6uuTxUuyC4rhaih+iQKVSYTAYMJlMOBwOmpqaaGhooLu7G7fbzeLiIq+++irPPvssY2NjBINB6ROpq6sjHA6TSqWw2WzEYjFGRkaYm5sjHA6X3GYiNkCLxUJNTQ2tra0y4hUMBgkGg6ytrTE9Pc3CwoKMdm3cPAqFAsFgkBdffBG3280999yD1WrFbDZz+PBh1Gq1IkB3AnEcE+HX8fFxjEYjdrsdi8UirSBxJLFarTQ2NtLa2kptbS0VFRXodDrq6+t59NFHaWtr42//9m8ZGBggkUiUnMVwNSqVij179vDJT36Svr4+Kbpip/zxj3/Mc889x9LSUsl9iAIhJD//8z/Pjh07eOCBB9Dr9Wi1WvL5PFNTU/zX//pfWVlZYXV1VW46ALFYjLm5OU6fPs3c3BxOp5NEIsHFixcJBoMleaRWqVTY7XZ27NjBoUOH6OnpwWQyAVf8ebFYjIWFBQYHB5mfn3+T+FzN66+/zp//+Z/zu7/7u+zZs4ejR4+SSCRK+hi2ZQQIrrzAyWRSJmtpNBqMRqPcUU0mk3TM2Ww2fD4fkUgEn89HV1cXTqeTmpoa6urq0Ov1bN++nXg8zujoaElbDXDlZXa5XHR2duJyuTAYDKhUKnkv5ubmGBoaKnnHs1qtpqqqisbGRnp7e4ErFu7y8jLZbJbJyUnC4TCJRGLTn8vlciSTSYLBIAaDgWQySSKRwOfzven3lgrCSd7V1UVzczP19fVks1ni8biMZi4uLuL3+4lEIm8rIoFAgLGxMaLRqPzZFovlDq3mnbGlBAiQYcqNO+O1MmOFA9But+NwOPjsZz8rk7tsNhsNDQ18/vOfZ3R0lM9//vP4/f6S3UXgDQHq6OjA6XRiMBjQaDQEAgH6+/u5fPlyWSSniWcnHKziiCyOFRuP0FcjkjLFMxeRP/EulBIiErtt2zZ+9Vd/VUbqgsEg4XCYp556ivHxcYaHh2/YFxkMBolGo0SjUfL5vHTSi1SFUnx/t5wAXY3wfVzr5udyOfmyhkIhotEogExQ3BhNKHWEL2B6epquri4MBgPZbJalpSWefvpppqamSl58ANLpNOfPn5dpAj09PTQ3N6PT6aisrOQDH/gAw8PDDAwMXLPINpPJSCs4nU6X7Ien0+no6uqitbUVk8lEKpUiEAhw4sQJJicnGRsbY21tjUwmc8PXL1IS/H4/8/PzDAwMMDY2VtKlKVtOgK6uEXq7Gy9qZ4LBIJFIZNOuK/58OQhQPp9nfX2d/v5+amtrcTqdZLNZpqen+drXvkYsFiv2Jd4QqVSK48ePc+7cOV566SUee+wxPvShD9HS0kJNTQ2f+tSn+NGPfsT4+LhMl9j4jDOZjPTZCQEqNYSjfe/evXR3d6PX61lfX2dhYYEnn3ySyclJVlZW3pFo5PN5VlZWmJiY4NixYwwPD5fkPRBsKQESSV0ajUaarTei/iqVStZMwRsFjSJHoxzyKQDi8Tirq6tkMhlZN6TX66VPpJxIJBIsLy/zzW9+k5dffpk/+qM/oqWlhQMHDtDc3MyHP/xhVlZWWFlZ4atf/SqhUIhkMklzczO1tbUsLCzI0pRSo7a2loaGBh599FGamprQarWMjIxw5swZ5ubm3vVx32AwYLfbOXjwIADHjh17U4lSqbBlBGhjbZdarb6pqmghQCKBTUTU8vl8WRUyivIDke0tkvMqKipIpVLE4/FiX+INI47Ho6OjLCwsMD09jdPppLm5mZqaGvr6+pifn2dubo5Tp07h9XqJxWIyqhkMBkt2vR6Ph+bmZjo6OvB4PKjVatbW1hgfHycUCpFKpd7Vz9fr9VgsFhoaGpiZmZHpJ6XIlhAgUQltMBjI5XKyEdeN3HSRtl9TU4PH4yGdTkvRGR0dZWBg4KbO4cUkl8vJvjBi/S0tLXz+85/n29/+NsePHy+LdWwkl8sRiUT49V//dfbs2cOTTz6J1WpFr9fL9Im//Mu/lM/cZrOhVqv5D//hPxAIBIp9+W9Co9HwyCOPyCp3g8FAoVBgcXGR11577V0dlUWuW01NDe3t7bIWrpRdCGUvQKKyWxTkiWroG/3QRK5QRUUFDocDQGYLLy0tMT8/X5JRlGshasHm5+dlsa1er6enp4cjR45gtVp55ZVXCAaDZbMmuHIk9nq9TExM8PTTT8tyC7jy/Ovq6rDZbHK9QoDfrSVxqxFH+erqahobG2WkUlxrLBZ7V5aK2+2mvr5e5rSJQIooXSnFXKiyFiC1Wo3BYKCzs1PWeU1OTt5QzoTA6XTS0NBAa2srDQ0NqFQqYrEYKysrXLp0iQsXLpRNq45IJMLMzAzHjx9nZmaGo0ePUllZyT333MM999xDPB7nIx/5CBcuXCAcDhf7cm+KXC7HxMQEjz32mNzRtVotFRUVfOELX2Dnzp10dnaiUqlIJBLEYjGi0WhJPTdxLG5sbGTbtm3S5yjytRKJxLsSoB07dvCJT3yC5uZm2ZK3UChgNpvJZrMlmctW1gLk8XjweDw8/PDDxONxBgcHb7jiWfReufvuuzl69Citra3YbDZyuRzT09OcPHmSoaEhFhcXS3LnuBaxWIylpSXOnTvH1NQUqVSKbdu28cADD8gXsqKiArfbfVMiXWqI685ms4TDYf7pn/6JQCDA0aNHUavV5HI5otFoyUX+dDqdbBInCmOF8Igj5DtBq9VSWVlJV1cXd999N06nk1gsxg9/+ENee+01otFoSYoPlLkAVVZW0tzczF133cXa2hozMzNvar51LYTT2Wq1smvXLh588EHpDIxGoywtLfHqq68yMzPD+vr6HVrNu0ccwRKJhMz6zmazMhqSTCYxm81YrdayiOq9HYVCgUQiwenTp6msrNz0AYvOiKWEXq/H4XDIoxcgW268Ez+j8H2azWZqa2tpa2tjx44dAPj9fk6cOMHIyMi7tqxuJ2UrQCqVivvvv5+DBw+yfft2mpubsVqtJJNJZmdnr1s3o9Fo8Hg87N+/n9/4jd+go6OD+vp6tFotyWQSv9/PxMQEZ86ckYmJ5YKophaO6KWlJQKBABcvXsTv9xMMBpmamnrXvoZSo1AokEqlWF9fx263A8geO6WyTrVazZEjR3jsscfYsWOHPEYmk0nW1tZk/6ZrvbPX6n1tNBqxWCx85jOfYdu2bRw+fJiKigpUKhVjY2NMTEzwyiuvlHxXxLIVIICKigpqa2uxWq0YDAZaWlqorKzEbDaTy+Wko1WE5p1OJ1arla6uLvbs2cOuXbtkRMXv9+P3++nv72dmZkZ2VSwXVCoVTqeT1tZWefyYnZ0lFAqxtLSEz+eTleLltK4bJZVK4fV6ZZMukQ9WCmsVU0saGxvZsWMHdrtdlpxEo1EWFhbetNmJHDSDwYDT6ZS9ncS6hCW7Z88e2tvb6ejoIJPJ4PP5GBsbY2RkBL/fX7KpCIKyFiCTyYTNZpP/a7Va6ezspLm5mfHxcZkPYzAYMJvNPPLII+zcuZNPfepTsm8QXMmfef7557l48SL/+3//75I2Wa+FOFJ2dnbysY99jIWFBVZWVhgeHsbn8+H3+0u2JOFWEQgEOHPmDHfffTctLS2y+LgUfB9Wq5W7776b3bt309bWhlarlSUTw8PDfOc732FiYkIKpnhnxbHqwQcfpL29nYaGBtmmRDQw02g05HI5gsEgc3NzjI2N8Y//+I8MDAyUZAuSqylrARKe/Y2d5drb2zl06BCRSIRQKITRaKSzs5Pdu3ezd+9eGhsbZbFmoVCgv7+f8fFxfvKTnzA1NUU8Hr9jTudb5YcxGo20tbXR3NyMx+NhaGhIZgILMb2eab+xQ6T4fSKHqJwEy2w209LSgt1ulwmYBoOh2JeFWq3G4XBw5MgRGaUT+Vo+n49YLCaLnwHZkrWtrQ23201NTQ3bt2/H7XbL99ZoNMoj2ZkzZ1hbW2Nqagqv18vKygozMzMl3YR/I2UtQGIOErwx/aK3txeDwcDIyAjr6+tUVlby6KOP8ou/+ItyWJ/wDWQyGU6dOsXTTz/NK6+8UpTQ9K0QIbPZTF9fH9u2baO6uprV1VVGRkYIBALX7X4oktY0Go1sVyoiMaLlZ7lE/wDsdju9vb2bBMhkMhXd2a5Wq6msrOQjH/kIFRUVcjhAMplkeXmZeDyOx+OhUChQXV0tfZIf/OAHsVqtWCwW6QPamOEvqv6ffvppLl++zJkzZzYloZYLZStAwnrR6XQcOHBA5lR4PB40Gg2f/exnSSaTVFdX09raisVikSHaSCRCf38/X//617l06RKTk5NFOStf6+MQaQQ3+hIZjUYaGhp47LHHqK+vx2QyEQgEWFxclD6wjWLjcrmwWCxUV1djMBjQ6/U0NjZisVhkf+Xp6WmSySTJZJL5+XmSyWTJi5EYZ6PX60kmk3i9Xrxeb9GtOLVaTTqdZm5uTs5rE/7JSCSC1WqV6QMqlUpOaamsrJSOdJGdn0wmZcLiyZMnuXDhAi+99BJer5dkMll2ViuUsQABLC8vMzU1RTKZlAJjMplwu9309fWRz+eprq6Wlo8wfRcXFxkeHuYnP/kJ6+vrJZWUt7Fx+lvVsm1Mu29ubmbHjh1YLBY0Go30eVmt1k1+MFFyIlqdGo1GjEYjra2t2O12OeBQr9fLMHYmk5HDDm+0vOVOIj5aEd4Woh6LxUomDJ/JZJibm8NischZbIVCgWg0SmVlJU1NTXLMzsa+5eJ+R6NREokEgUCARCIhJ2ScOnWK2dnZsvNZbqSsBWhgYAC/38/U1BS5XI7q6mrpfLRarbKiXVgVoVCIhYUF/u2//bfMz88XPUQpTOqNPaqdTqc8Domufldfo2jl6XK5+F//63/R29tLTU2N9Av85m/+Jj//8z/P008/TTqdRqfTyVHNtbW1mM1mHA6H7HckfECifYVoBlYoFJiYmGB8fJzHH3+cQCBAKBS64/fprXA4HPzu7/4uu3btktaCOHaWgjWQyWSYnZ3lS1/6krzfLpdLzjnr7u5m3759GAwGKT7wRn5QNBrlhRdeYGJiguHhYdnBc2VlBb/fLy2fcqWsBSiVShEOh+nv7yeXy1FVVSV3j6sTEguFApOTkwwPD7OwsIDP5yv6seLqI5harZaWi8vlIhqNEg6HZXP8QqGATqfDbrfT0NBAfX09LS0t8tgp8Hg8GAwG9u/fLwXI5XLJ7o96vR6TySTbl8DmqRRarRaNRoNKpSIajcoJI6U21qaqqoq6ujp6enpobGwEYHV1lbm5uZJpPyJ8Puvr6/J+x2IxrFar7PI4Ozsro7niqKzT6QgGg6yvrzMyMsLY2BjT09PE43Hi8bgcslkKIvtuKGsByuVyhEIhvvnNb3LkyBEOHDggnXXwxtRNYWX86Ec/4sSJE3i93pItVKysrKSxsZEPfOADBAIBlpaWNo2VqaiokKOJt2/fLosaNyaqibG94qPc2JpkY5OujdaXmKMlrkV8CDabTY40KiUBEk34+/r6uPvuu2Uh8cWLFzlx4gTBYLC4F7gB4XcUBINBtFotkUhEHnkrKirkFF+j0Yjb7WZubo7R0VFeeOEFJicnZYN5rVa7JcQHylyA4Eoofnx8nOrqasbHx6mtrcXlcr2pJkylUrGwsMDk5GTJVIJf3bMon8/j9/txu920tLTQ3t5ONpuVzbZWVlZIp9MkEgleffVVTpw4gcfjoaqqisOHD1NTU0N9ff2m2WfwhhCL5u5+v5/R0VE5+kXM1gqHwzIsL/wRgUCA9fV1lpeX74hPRdToGQwGbDYb8Xhczv2yWCy0tLTItIqmpiYqKytlvk8gEGBwcJDTp0+XdBa76DPl9/tlLZg4gonqdavVKq1PMZJHDCq8mWZ7pU7ZC1Aul2NxcZHZ2VkmJydlXyCz2bxJhAqFAj6fj+Xl5aIfvQRXHxGFwzEej1NZWSlbhKjVarLZLBMTEywuLnLp0iX6+/sZHh5Gr9dTX1+PzWYjlUpht9tl9EQg0g5Eecb8/DzHjx9ndXWVhYUF1tbWiMVi0gISs6oMBoM09e/EkUZYgUJ8ampqCIVCxONx6fPat28fR48e5aMf/aj8AEUjttXVVcbHxxkaGioZB/T1yOfzRCIRIpEIi4uLm/6bEGFxPzKZTMm8s7caVaEEJfSdNFASw93cbjdVVVV86UtfoqOjA6PRSDweJxwO89hjj/H888/fhivezI3eUuHo3Yhovv7QQw+xd+9e7rnnHrRaLel0mpMnTzI8PMwzzzwjhUokYLrd7k25LwIxZVT4m4Q1JSqkRYj36giXcN6LnsvXWtONrvNGn6fYPDo7O2lsbGT//v20tLRQW1tLZWWlnINus9lwOBzEYjGCwSDPPvsso6OjvPjiiywsLOD1em+pY/ZWr/Nmf9ad+kSLIQVlbwEJYrEYk5OTrK6usri4yPnz50mlUvT09BCNRktyNO+1HrgYxzs6Oip7+4oz/9jY2JsalosOkHNzc9f8OzZmOouffyMfZy6XK8quK2qkMpmMPH6Jaa4iNC3KDsLhsAxJj4+PMzg4WHbjtK9HCdoFt4UtYwFd/edNJhPbt2/n7/7u72RB5pe//GXOnTt3i67y+rwbCwjeaLOg1Wpl9KlQKEg/QKmY47fLMtjY21scJ0X0zmq1ks1mpW9MdK+8nYJZDAuoGCgW0C1C9IlZXl7m29/+tsyp8Pv9xb60G2LjcL5MJiP9OVsl8vF2bDwObpxIotVq5dA9MQm1lARZ4ebZkhaQQKPRyHwLm83G4uLiHWnT+W4toHJBsQw2815Z561kS1pAApHbkk6niUaj1y3MLBY3OjxRQWGrsqUFSIRoRQ1YKToni12tfSd4L6xR4Z1RkkcwBQWF9wY3NkJCQUFB4TagCJCCgkLRUARIQUGhaCgCpKCgUDQUAVJQUCgaigApKCgUDUWAFBQUioYiQAoKCkWjJDOh3ys1NUotWHmgrPP2oVhARaScxUdB4VagCJCCgkLRUARIQUGhaCgCpKCgUDRK0gmtoPBW6HQ69Hq97JyYzWY3zThTKB8UAVIoG8TIHpfLRVVVFYlEgnQ6TSAQ2DSS+b2GGMYpZoWVE1tagDZOSQU2TQRVKD8MBgMNDQ0cPnyYRx99lNnZWdbW1jhx4gTr6+vMzc2Ry+XeU5aQaN5vNpulCJcTW1KAVCoVbrcbh8NBW1sber0enU4nB/AlEglpsofDYWKxmJysUM4Iwe3s7MTtdsvRzGKKRD6fx2w2o9PpsFgscuKEGAX0ox/9iGg0WnJjqwUmk4menh66u7vp7OzEbreztrbG/Pw8gPzfrYYYrVRTU4PNZqOqqkq+32IaSCgUYnJyksHBwbLaYLekAKnVaurr62lpaeHDH/4wdrsdm83GhQsXWFlZYX19XU5WmJmZYWlpaUv4EdRqNXq9nve973309fVx5MgR1Go1kUiEZDJJOp2muroam81GfX29HAUci8VYXFzkwoULLCwslKQAqVQqLBYLe/fuZdeuXXR3d9PQ0IDf72dycpJkMiknaGwlVCoVGo0Gk8lEd3c3jY2N7N27l76+Ptra2uRI7f7+fn784x8zPDxcVkexLSdA4oHV1tbS0dHB3r17sVqtmEwmqqurpbWjUqnQ6/XEYjFisRivvvoq09PT/PCHP7zh4X2lhEqloqenh7vuuov77ruP5uZmnE6nnJoqpptaLBZ0Oh1Go1Ga7xaLhYaGBv7kT/6EEydO8Kd/+qcl9wKLsTz19fU4nU4prMvLy/zkJz9hfn5+09iiq4VIDDUsF1QqFfv27eOBBx6go6ODiooKPB4PFosFp9OJw+HAbDYTi8WIRCIMDQ2xurpa7Mu+abakAKnVaioqKnC73dTU1GAymeS8+EwmQyqVQqfTYbVaZRRFrVZjs9k4deqUPJaVC2q1GpPJRENDA3v37qW1tRWPx4NWq0WtVmM0GuWumM/nSaVSpNNpjEYjZrMZjUaDzWbj3nvvJRQKlaxDU6vV4nQ6sVgsUoC8Xi+zs7PSqr0aIUQb54uVOjqdDpfLRVdXF4cPH6a3txe3241er5ebhkBYq7FYjEwmg16vJ5VKlcU6YYsJkJgoajQa6erqoru7W35gYrJoNBpldXUVi8VCU1MTBoMBk8nE+973PlpaWgA4ffo0P/7xj4u7mJvA6XRy//33c/ToUT7ykY/I49bs7CyFQgG1Ws3i4iJra2uMj48TiUSIxWIcOXKET3ziE7hcLgwGg7wXNptNjjMqJQwGAx0dHdKie/XVV3nttdcIBoNvOjZutITEpnS9GfelhE6nY9u2bXz5y1+msbGRlpYWdDqdnBIr2OjDTKfTdHR0kEwmCYVCTE9PEwqFiriKG2dLCRC8YQGJ3S6ZTBKLxfD5fMzMzBAIBFhbW8NsNtPQ0EBVVRUulwuHw4HBYKCpqYmhoSE0Gk1JWgFXo9FosFgsbNu2jdraWrRaLcvLy6yvrzM+Pi6PJevr6wQCAebn5+Ux1GQyYTKZuOeee6ivr5drLtWjikajwWw2o9frKRQKeL3eTf67ayF+vRzER6PR0NXVxc6dO2lsbKSyshK1Wi0je8LyEcdJEVjQ6XQ0NTWRz+fRaDQEg0FFgIqFMFHFMEK/309/fz+nTp3i9OnTLC4uEgwGMRgMVFRUsG/fPrZv386DDz6I3W6ntbWVmpoaDAYDqVSq5CNjBoOByspKjh49SkVFBeFwmFOnTtHf388LL7xALBaTM9Gu/gAHBgZ48skn+e///b/zwAMPUFVVJY9npbZusbFYLBaZhDg7O8vo6CiZTOa6f04IT6mKqkAclT/96U+zc+dOqqqqUKlURCIR+U6Lf1QqlXxOhUIBm83G+973Pvbu3UsikWB8fJy5ubmSXzNsIQHSarUYDAbsdjsOh4NwOMzU1BQTExNMTU3R39/P0tISkUhE7hw+n4/Z2Vl0Oh0f+tCHcDgcOBwOGhoaqKmpYWVlhXg8XuylXRcRGbJYLBQKBUKhEH6/n8uXL3Px4kWi0ah0qL+dhaBWq2WS37Zt21hcXMTn893J5bwlQoC0Wq3064hIZjmj0WjQ6/Xcd9997N27l7vvvhu32y3FJZ/PY7Vapf9H3Ae9Xo9Go5HuBSHKNpuNn/u5n6OtrY0nn3yy5H2ZW0KAhO/HZrPhcDhwOp1Eo1Gi0Sijo6MsLS0xOzu76UPM5XJkMhm8Xi9msxm1Wi2jZZWVlbhcrpL6AK+HwWCQR5JYLEYwGGRqaoqpqakb9uGInVU45uvq6ggGgyW1fvHhbbQChACV+tHqeohIrMvl4tChQ3z0ox+loaEBjUZDOByWRy/xfos/A0jx0ev10s8l3A5Hjx6lvr6e73//+4oA3W5Een53dzef+MQn8Hq9+P1+BgcHCQaDLC8vv+VRqqamhp6eHiwWCwDxeBy/38/i4mJZZJUKZ7HVamVtbY3l5WVp+bwd4qOurq6msbFR+g/Onz9PJBK5A1d/42w8Sol/IpEIoVDoth01bmdOkUgVufvuu/md3/kdqqurcTqd5PN5EomEDJQ4nU5p5cRiMZlmks1m5Tut0WiwWq1SnJubm9FqtbjdbpLJJNFo9Lat491S9gKkVqtxuVzU1tbS29vL6OgoqVRK7uCRSOS6O6RarcbtdtPS0iJD1aFQiHA4TDweLxvzXqVSYTab0Wq1cte8EaugqqqKxsZGPB4Per1epvKHw+EbErA7jRAgsTbhiL2df9/NiNCNhvkdDgd2u51du3axZ88e+vr65NqmpqZkcqXZbMbpdGIwGKRfE7imANlsNqqrq2Vk12az0djYqAjQ7Uav13Pw4EHuuusu7r33XhKJBEtLS1KArrc7Cp/HgQMH+Pmf/3lcLhexWIzz588zOTn5lsJVShiNRpmen0wmsdls0lx/K9RqNT/7sz/LH//xH0sfktfrJRgMluSxRnygmUyGbDYrjxwbQ9O36++9Gd5OhFQqFYcPH6avr4/Pf/7zuFwudDod0WiUYDDI448/zsjICJOTk1JkUqnUJsG51s/U6/X82q/9Gv/lv/wXtFotZrOZT3/607zyyiv83//7f29qDXeSshcgQPoEABly35gVezXCeVtbW0tFRQUGg4FgMMjCwgLPPfccw8PDJfcBXg9xnRqNhlwuRzKZfMsjiUajoaqqip/5mZ/h/e9/P1arVUZbvvOd73Du3LmSTT/IZrOEw2EZjjebzTgcDqLRaMmI5ltdgwiU9Pb2cvDgQWw2G9lsltnZWV599VUGBwe5cOECq6urciMQovt2zySdTjMyMsKPfvQjDh48KJ9rqSdgbgkBEs7ITCZDMBhkdXX1bQXIZrPR2dlJZWUlOp2O+fl5hoeH+da3vlUWvh+B8IeoVCqy2exbHh1VKhU6nY7m5mb+6I/+CKvVKs15sfsuLS2VbPg2m83i9/ul1WOz2fB4PKytrVEoFIp+ZH67j1xEaQ8cOMCRI0cwGAx4vV6Gh4f5+te/zg9/+MN3/HfncjkGBgb46le/SlVVFd3d3WXRGaDsBSidTnP+/Hm0Wi333nsvDQ0NPPzww6ysrLC4uEg4HAauvBwicmCz2ejo6OCRRx6hs7MTk8kkd4lS3SmuhUqlwuVy4XQ6Aaivr+e+++7j5MmTLCwskEgk0Gg0GI1GHn74Ye666y4aGxupqqqSTstMJsPf/M3fcPbsWbxe7231qbwbRBJeKpVCpVLhdDr57Gc/y8MPP8zS0hIDAwN873vfIxAIlJzPQ5TK9PT0cODAAdml4Ny5c1y8eJF//Md/ZGZm5l3/PWtra5w/f16K9P79+0mn0xw7dgyv1yu/hVKi7AUol8uxurrKwsICU1NT2O12Ojs7aWtrQ6vVEggENmXDCodtbW2ttICEz2Tj7ysXjEajFFC73Y5Wq6WxsZGFhQVCoRA6nQ673S4LG9va2mSSZTKZJBKJcObMGU6ePEkikSjZHVP4e0RI2mAwsH37dmkV2Ww2zp49K0suxFH0Tj7L6x11RL+empoaWR6UTqcZGxvj0qVLnDlz5pb8/fF4nEwmQzKZRK1WU1VVhcfjwWq1lmxmdNkLEEAmk6G/v5///J//M//m3/wbPvrRj/L4449vKtoDGB8fZ21tjUuXLlFXV0d7ezsVFRWy1mZj4WI5iJBarZaJl6LC3el08gd/8AeEw2HW1tYwmUw0NTVht9tlEWcgEODYsWMcP36cZ555Bp/Pd81+SKV0H/R6PTabjZaWFtxuN1qtFo1Gg06no6Kigr179/I7v/M7XLx4kdHRUU6dOoXf7ycejxdVhFQqFSaTia6uLjo7O2lpaSEQCLCwsMAf//Efs7y8fMv/fq1WKzfVZDLJ+vo6iUTilv49t4otIUBwxTRfX1/n0qVLOBwOent78Xg8tLa2SmFZWVkhGo1SV1dHXV0dNpsNnU5HoVBgcnKSycnJknXAXo3I4amqqqKqqkq+dCK1wG63Y7VaMRgMMq0/n89z5swZFhYWeOWVVxgcHGRpaalkHLjXQxw1KysrZTsRQKYNTE5Okk6nqaiooLu7m4qKCoxGI8FgEL/fz8rKCvPz87e9tOZagi2OXxuF0+fzsb6+js/nu6XHRVGwKjbecDhMNBolkUiU7NF6ywhQLpcjFovxrW99i3/6p3/iM5/5DLt37+aXfumXZLZoIBAgGAzS3d1NVVUVFRUVsq7mmWee4fz58yX7oK6FRqOht7eX3t5ejEajLFMwm80YjUYcDgdw5UiZzWaJRqN88Ytf5NKlS/h8vpIWnY2o1Wo6OjpkF0STyQQgrbzvfve7VFRUcP/993PvvffKUoZYLMbk5CTPPvssX//611lfX7+tFpHY6DZW4uv1eioqKjh06BAulwuAsbExZmZmbvmRV6vVYjKZ0Gq1FAoF5ubmWFhYIBKJlOzRessIkEB8bGfOnGFiYkJWtsMVCwjgs5/9LG63G5VKhd/vZ319ndnZWVZXV0v2QV0PEY7emDAncmXS6TTxeJxAIMDp06e5ePEiY2NjRKPRG/oIS0WghKiaTCay2Syrq6usra3x9NNPMzY2xtDQEC6XC6/Xy4c//GEZ2RSpFtXV1bjdboLB4G1dk3gGwgJRq9U4nU7sdjuZTEb+s7S0xMzMzC23xiwWiyykTiQSHDt2jEuXLpW0Vb/lBAiuhKZHRkYAOHXqlPx1tVqNx+PhF37hF+Sv+f1+ZmZmWFlZIRAI3PFrfbeIPj4byWazZDIZWVYirIAf//jHb5meUKqoVCqMRiNGo5FUKsXq6iojIyM89dRTXLhwgWw2i9PpJBgM0tfXx4EDB6Rfr6KiAqfTecMJmu/2Ojf+f9EqxWw2b4qwhsNh+a7dSj+bcHQbDAbS6TQXL15kYmKipJ/3lhSg6yFC0n19fdTX15PP5/n+97/Pt771LRYXF4t9eTeFeKFDoZCshxKOdIPBgFarJZPJMDMzw5//+Z8zNTVVluJjMpmwWCy0t7djt9v5/ve/z4ULF3jppZc29QKKRqOMj48zNTXF7OwsNTU1qFQqvF4v6+vrrK+v3/Ze1xur9MX/5vN5WatYW1tLXV0dXV1dLC0t8Yd/+IfMzs7ekhA8wJ49e/jVX/1V2tvbpfgZjcZb8rNvF+8pAXK73TQ0NMioUSQSYXFxkYmJiZJsxP52iA9v45FK7LxCoKLRKFNTU7f9+HGrEZuF0+nE5XKh0WiIRqOMjY0xPDzM1NTUJue5SML0+XwsLy9jsVhkw/1sNisd9Hcqsifuv2j9YjQasVqtOBwOrFYrdrudPXv24HK5MBqNrK6uvmMLXKfTUVlZSXNzM52dnVitVul4LnWf5ntKgB599FHe9773YbPZiEQiDA8Ps7i4WPItC65HPp9nenoal8u1qXBSVEXHYjFCoRBra2tFzxK+WaxWK62trfT09NDU1MTa2hoDAwO8/PLL143q5PN5xsbGeOmll2QD/kAggFqtZtu2bfh8PilIt4ON1fri3wOBAH6/n1QqJbsX6nQ6amtr+W//7b/h8/kYHR3l8ccf5wc/+MENiePVRz2Px8OnP/1p7rvvPtrb21Gr1USjUebn51lfX78ta71VvCcESORGtLe3s2PHDrRaLaurqzz77LPMzs4W+/LeMSL5UGQ1b4zCJJNJTp06xeXLl0vaCXkt1Go1lZWVHDx4UPbGmZ6exuv1Eo/HrykgosxE9LQWeUIGgwGLxYLdbsdgMMiaudtxP66+z4VCgXQ6TTAY5LXXXtvUKkMUQzudTlpbW/nIRz5CfX09Fy9exO/3Mzc3J3s0NTQ04HK5aG1tlT6/jSJkt9vZv3+/FB9RPyZa75Yy7wkBEi9id3c3e/bsQavVMj8/zze+8Y2ydDzDG83WKysr8Xg8mwQon88Ti8V4+umnGR0dLbvIniiYvf/++7l8+TJjY2OMjIwQCASue1QWzbmcTicejwej0Yher8disWC1WmVbi9tZPX+t+yzy044dO4bNZuOuu+7aNNnCbDbT0tLCY489xqc+9Sn+6q/+ioGBAcLhMFqtFqvVyr333su2bdt49NFHZVTt6uPkxqLTbDYr54WVckdPeI8I0L59+3jooYfo6Oggm80yMjLC6OgoPp+v5CY/3CgbOwTCG71x8vk8f/EXf8GZM2d47bXXSq6x2NshZn9VVVWh0+kIBoPMzs6SSCTI5XLXzDTW6XS0tLTwwAMPcOTIEfr6+gAIBAIcP36coaEhzp8/L5vT3S5r8Ho/Nx6Pc/nyZSlEv/3bv83+/ftlCQ28MVTyox/9qJxWIn5edXU1drtd3pPriaiwwM6cOUN/f7+cAFzKvCcEqK6ujrvvvpvKykry+TwLCwusrKy8beuKUmVjPZTRaMRgMJDP52UzsZdffpljx44Ri8VK/gXciLBiRJLoxhq9jf2ghYNXZH9XVlbS1tbG/v376ejokP28I5GI3GympqakQN9pstksPp+PQCDA6OgoH/rQh2QHRKPRiN1ul8GDtrY28vk83d3dpNNp0um0FB1xPzYOGRDr2ZhiMD09/bbN+kuF94wA3Xvvveh0OsLhMMeOHZO+kXJD+AUaGxtpbGzkyJEjtLe3k0qleO655/ja177G+fPny0584Ep73Orqaj7+8Y9TW1uL0+nk0KFDNDc389xzz7G+vk4ymZTNuZqamqirq+NXfuVXqKuro7GxUZZpDA4OcunSJZ555hk5GaTYCAf17/3e72G1Wunu7ubw4cP8x//4H6VfCK4kkq6urhIOh/H7/VKcnE6nzPiPRCIkEgnpS6qpqZFlGGfPnuW1114riTW/HVtagEQCm8lkkvkQuVyOxcVFvF5vka/uneF0Ounp6aG9vZ3m5maqq6uxWCzkcjl8Ph8TExM3nOlcKuj1egwGA52dnbS2tsq6qcrKSjQaDS6Xi0QiIYfwif5PIsO5vb0dl8uFxWKRJRiDg4MMDg7ecH/sO0kwGCQSicjOhU899ZQUD+FAFhE7USsmRhKJntGJREK2JhGjmfR6PXq9ntnZWfx+f1m8A1tagMRcdJvNJh9uOp1maGiIhYWFd/Wzr677uVN0dHTwm7/5m3R3d9PU1ITJZCKfzxMMBvF6vYyPj5eVZSemkXg8Hh599FF2795NY2MjFosFt9stW3A89NBDANL/ca1ezaJx+8rKCt///vcZHBws2fSDXC7HzMwMc3NzPPvss9L6udlj4sZxRRaLRY6kulZ3g1JkSwuQ2+3mX//rf83dd98NgM/nk7O+3k3iYbHER6PRYLfb6e7uprq6WhYeCuesqHgvF/R6PdXV1dTV1dHS0iKngdpsNrk2sS7B1S1WRNRHCM/x48c5d+4cy8vLZXEvxDUKsbjZaxb+MCG+mUymJAdLXo8tLUAul4sPf/jD1NXVyabri4uLJBIJMplMSfW7uRFEen1jYyMmk0nWO21MfCsntFotFRUV1NTU0NLSInN1NjYV2yg4Vwu/WHc6ncbn8zE+Ps6xY8d4/vnny+oY+m6FUrSjFT3By4ktK0AiKa22tlb2hvnLv/xLjh8//q5bjxbjxRY+ADE+aGP3xlQqxfz8fNnlNKXTaTmtdnZ2ltdffx2TybQptUB8WCIMD8hK/43Cm81mSSaT+P1+2aRe4Q2KZbW/HVtOgESIuquri56eHvR6vcwsHRoaYmJioixM82sh/B+JREKm9It5UUtLSyXbdvN65PN52UQ/kUgQDAZlHdtG8RH/XQivSLRTKH+2nACJRlx/9Vd/xfbt2ykUCjz11FN8+ctfxu/3l634iFBsIpFgenqaxsZGGZL3+/1ynFA5ITK2byRbt9R27nKjVO/flhEgMddc5Mfk83kWFxe5dOkSFy5cIBgMllw49mYoFAoyPHvx4kVmZ2exWq1EIhFWV1fp7++XDdfKjVL9OBRuP1tGgAwGAx6Ph927d7Njxw7ZauOrX/0qMzMzJV8T83YIX8/q6iqnT5+WDvTJyUmCwSDz8/Ml33pBQeFqVIUS3H5uZh63QLTgdDqdWK1WrFYrmUyG2dlZ4vH4HRWgG72lNzt3XJRfiDlgG0Ovou7nTj7OG/27hFO5BF+1G+J2PM9SpBjPZ8sIkPCHbKyRKdagwdv1wm4MSZfCDDNFgDajCNDNU5ICpKCg8N5A/fa/RUFBQeH2oAiQgoJC0VAESEFBoWgoAqSgoFA0FAFSUFAoGooAKSgoFA1FgBQUFIqGIkAKCgpFoyRrwd4rGaXKOsuDm8n4Lue83qL0ubrjf6OCwhalnMWnWCgCpKCgUDQUAVJQUCgaigApKCgUDUWAFBQUioYiQAoKCkWjJMPwxcJisdDZ2UlDQwONjY3Mzc3h9Xq5cOFCWczZfi+hUqkwmUwYDAYcDodsV1tuQwc2Dl4sVgO9YqII0P9HpVJht9u5//77ueeee3jwwQd57rnnuHz5MkNDQ2UpQBvzb7bSiy3GETscDux2O52dnXi9XtbX18vuIxatdsV153K5srr+d8t7RoBUKhX19fUYjUZ8Ph/pdJpMJiPnTm2cOpFKpTCZTNTX1xMKhdBqy+M2GQwGzGYzBw8epK6ujsrKSjKZDMFgkEuXLjE1NUUsFiv7oX01NTW0trbS09ODy+UiEomQzWbR6XQAZdOcX6fTUVNTw759+9DpdGg0GiYmJohGo/I55XI5DAYDKpUKn89HNpslk8lsGk75dgixtlgshEIh0ul0ycxVK48v610gdhidTofb7ZajbDYOvhNks1mCwSDJZFKOQbbZbCWfyStGHFutVux2O7t27aK1tZXa2lrS6TTr6+uk02my2Szr6+skEgkikUjZ7rQVFRX09PTQ09ODzWZjaGgIrVb7prnxpYxarcZut1NbW0tfX58cSa1SqQiHw4RCIfmOms1m4MrMu2QySTweJ5lMbpoOK95RlUqFTqdDpVKRTqflv1dUVOBwOORoKkWAbjHCLN8oFuLm19XV0dbWRk9PDzqdjoGBgWuO741Go7z88sv09fWhUqnI5XIlv5uqVCo6Ojr4m7/5GzweD5WVlRgMBjQajZwymsvl+OQnP0kikeDkyZP09/fzl3/5l5te4HJBpVJx11138fu///v4/X7W19c5fvw46+vrJJPJsliPSqXCZrPxr/7Vv6Kvr4+HH36YTCZDJpPhkUceoVAooNfr0el0GAwG+R76fD58Ph/j4+MMDAwwOTmJ3++XVpL4/d3d3ZjNZs6ePYter6e2thaPx4PFYuHkyZOsrKwQi8VK4l5tGQFSq9XSVFWr1ZuGEKZSKTmeWaPRXPfDE6OChb9nZGSEc+fOlaz/R61W09TURFdXF01NTbhcLux2uzxe+nw+ADktBK4c0ywWC1VVVQSDQcLhcDGXcFOoVCqMRiNms1laPpOTkywuLuLz+W7qWFJMzGYzLpeL7du3097ejsPhIBwOy+NyLpfDbrdjNpsxGAzSuhNHL71eL4/bFRUV6PV6qqur5a/X1dWhVquZmZmRFtP6+jrBYJBgMEg8Hi+Z+7RlBEir1WKz2dBqtWg0GiKRCJlMhnQ6zfLyMgsLC5w/f/4tb3w+n5cfb6FQ4Nvf/jZPPfVUSewUVyOsu4ceeojdu3fjdrvR6/Vks1kCgQChUIgLFy6gUqlwOp3yuLm2tkY+n2fnzp1MT08zOjpaNj4hrVaLw+FAr9eTSCR44YUXePnll7l48WLJbhLXwu1209raygc+8AE8Hg8ajYZ4PM7a2hrHjh0jFotRV1eHy+XC7XZTUVGBSqXi9ddfJ5FIkMlkpJvggQceoLm5mX379kmrKRqN4vV6mZiYYGpqiosXLxKNRkkkEsTj8ZJydJe9AGk0GioqKqivr+fQoUNMTEwwPz9PIBAglUrJm30jN9zhcHD33XfT09MDXLEwNBpNSQiQsPAqKiro7OyU1k59fT2BQIAvfvGLZDIZstks8XicTCbD+vo6cMXqEevXarXY7XYeeOAB/H4/i4uLvPjii8zPz5e8EOl0Ourr63E4HAD4fD5WV1dL/ro3olKp2L9/P3v37sVqtcr3a3p6mkuXLnH69GmCwSBWqxWTyYTdbqeurg6r1UowGMRisVBXV8eOHTsoFAr09PTgdrsxm81oNBrUajXpdJpoNMr4+Dhzc3My6JLNZktKfKDMBUilUqHRaKiqqmLbtm0cPXpUfni5XO6mZ8FbrVbuuusuWltbAaQfpdgz5cU6HQ4HDQ0NMspVUVFBIBBgfn6ef/iHfyAWi5FIJK77c9RqNfX19XR1dfFLv/RL0uSfnJzE5/MRjUZL6uW8GhE1stvtqNVqIpEIfr+/JDaIG0WlUtHd3c3evXsxmUyo1Wqy2SyLi4v09/czODi46eis1+vp7OyUTmSxfrEBtbS0YLFY5CZTKBSIx+OEQiHm5+dZWloiHA6X7D0qawEym81UV1fzxS9+kYaGBqqrq/npT3/KxMQEyWTypn+ey+XiU5/6FB6Ph0KhcNvDlWK++9thNBrxeDz84R/+Ic3NzbS2thIKhfD7/TzxxBOMj49L38Fbkc/nWVtbw+PxyJfYZrNhNBoZHh7mS1/6EsFg8Bat7tbjcDh48MEH6evrw2azAbcm5H6jz+HdIqb3Go1GTCbTJsvc5/MxMzOz6YgkNh6Xy0VzczMHDhygvr6e3t5e9Ho9Wq0WrVaLSqUilUoRj8eJRCJ8//vf59KlS0xOTpaMs/l6lLUAeTwempub6erqwuPxyDyQeDx+UzddRCXcbje1tbUYjUZyudwdcWreyMvvcrmoq6ujp6eHuro63G43KysrzMzMMD8/z8rKyg2vN51Oy/Cs0WjE6XSybds2ABm+LVUrSK/X09jYSGVlpfzw3o6N4emNH7wIVphMJikI2WwWr9crn/2tRmQ9p1IpEokEuVxOpg6o1WopKGJtGx3N1dXVNDQ0UFNTg9PplI5pcaxKp9MEg0GWlpaYmJhgYmJCHsVLmbIVIJVKxYc+9CEOHTpES0sLWq2WaDRKPp+/afHRarUcPHiQvXv3otfrZTTsdofgb+RjV6vVvO9972P37t3U1tZiNpuJRqN87Wtf4x/+4R9IJBI3td5CoUA+nyeZTJLNZtFoNLS2tkpzv5QFyGg00tPTIzcbg8GAXq+/prUrPna9Xi//PZvNyvdDp9NhNpvp7u6mtbWVnTt3Eg6H+epXv0okEiEWi93S+7AxTWR6ehq73c6OHTuwWq2o1Wpqa2vp7e1lYWFBWklOpxOPx8P+/fvZtm0bXV1dWCwWKT5iTUJ8+vv7OXHiBKdPn2ZmZqYsHPNlK0CAPEZoNBoZ9VlbW7upn6HRaDAYDDQ2NlJbW0sikWBkZISXX36Z+fn523TlV3i7F1y8tEajEYPBgN/vZ2pqitdee41Lly7dtPgIkskk4+PjGAwG6uvrZbSw1MsYMpkMy8vLaLVazGbzpqS7jU52rVZLdXW1zI3JZDKkUikCgcAmsRL5NZlMhrW1NRk5vV1ObZFYODo6SiqVwu124/F4aGpqQq1W09DQwOHDh8lkMrhcLkwmE2azmYaGBkwmE+FwmHQ6LSNgKpWKeDxOKpXC6/WyvLwsE01LPX9NUNYCZLVacTqdqNVq1tfXefHFF1lYWLipnyF2wra2NpqamohEIrz00kv86Z/+KZFI5DZd+RVuxPrRaDQYjUb0ej1LS0tcuHCBr3zlKzd9zNxIPB7n0qVLOJ1O+vr6ZK5IKfsK4Eo+18TEhMxqF1aQ6MW88djS3d2NzWZDo9EQjUYJBAIyEiTuezabJZlMEolEmJqaIhKJSMvwdgixONKLJMJwOEx7eztHjhyRlmhHRwdGo5H6+nqZRCqu2+fzodFopP9HrVbL8PrKygoLCwusrq6+442pGJS1AGk0Gnlerq+v5+d+7ueYmZnh9ddfv6E/r1Kp2LdvH/v27eOBBx6gsrISn8+H3++X9UXFQqVSUVlZSV1dHYcOHWLnzp2kUimZYv9udmlhAXV3d8vENhFJ0Wq1Jes38Pv9fOc73+FjH/sY+/bt41d+5Vf44Ac/yKVLl2QtWHV1NU6nk3A4LGvggsGg/DDFfRPW3vLyMsFgkHw+L/NrbocFJARNBDdyuRyXLl1idnaWqakptm/fLjdBIapqtVomF+ZyOaLRqEyqTSQSpFIpIpEIqVSKaDTK8vIya2trJVNmcSOUtQAlEgnp97FarXR1ddHS0kJdXR3BYFCmt18L4fRraWlhz549NDc3o9VqmZ6eln+2mAjHeGNjI42NjdTX17OysoLZbMZutxMKhd6xQObzebnbFwoF6f/R6XQlLUCJRILh4WEOHTqERqNh586dtLa2YjabyWaz6PV6mcB34cIFmRMVjUbl8UpYISqVinw+Lws/RfLpnbAchB9qbW2NcDhMOByWznC73b6pFEMIkPhf4cdKp9MkEglZuxiJRAiFQkSj0bI5fkEZC1ChUOAHP/gBIyMj7Nmzh8rKSmw2G1/4whf43Oc+x3/6T/+JgYEBRkZG3mRSi4+7oaGBo0eP8jM/8zMYjUYmJyd5/PHHGR8fL+LK3sj7aWlp4cEHH6StrY2qqircbjc2mw2dTsd3vvMdXnrppZv+2VqtFovFQnt7Ox6PRzprtVotTqeTUCj0lrlExUREqaLRKGq1GovFgslk4siRI1JUVCoVmUyGyclJ+vv7OXfuHKlUSpbfbIyCbYyiFaOMo1AokEwm8Xq9vPjii7zyyisyItfc3IzH46G2tpbDhw/T2NgofUbiaJbJZDhx4gRzc3P09/fLkpRycD4LylaAANbX17FYLKysrMgPyOl0Yjabufvuu6mtrWXbtm1yxwmHw6RSKfL5PA6Hg/b2dtra2rBYLKTTaWKxGPPz8yWRCyN26Hw+L601gMrKSnp7e3nxxRfRarU3tNuJkLvRaJTHup6eHqqrq+XvKRQKZLPZkt49r+6XI44pFotFOnjX1tZYW1tjbGyM6elpGc0Uls3VIrPxaFQMxJpEhbsIiuTzeXw+H16vVyaQ9vb2yqx/USztdrtlHZlwqJdyIOFqylqAVldXyWazXL58mUwmw549e6Qj8t/9u38HvHHWz+fzDAwMyCiBaOlgsVhQq9XEYjEZZYrH40Ve2RWEczGdTsuwq8fjwePx8NRTT2E0Gt/WeSwiaR6Ph6qqKvbt20d7ezsf//jHcTgcqNVqWScWDodLZu3X4+qPS4TahXhevnyZs2fP8uMf/5iVlZW3/Dml8qFenToSj8cJBALy33/6059is9n4zGc+w969e2lvb5fRv23btslooNhESmVdN0JZCxBALBbjq1/9KlVVVTQ2NvLwww9z4MAB9Hq9TPISL5tI4NJoNLLSOB6P4/V6+Zu/+Rv6+/ulhVRMxK44OzvLT3/6U+666y7cbjdut1uuSUROvva1r70pEVFYTHV1dbKWqKmpiZqaGjo7O6mursZkMpHP5wmFQvzoRz/i8uXL+P3+kraAhJjClY9Wo9EAV+5XNBplZmaGV155hWPHjpVVlf/bkc1micVinDhxgmg0SltbG62trVRXV8seUBaLRYqQIkB3kGQyyfPPP49er8fhcOB2u+ns7MRsNm/KMlWpVFitVtnOQeSL+P1+lpeX+d73vsfo6GjJPLxcLsfKygper5fp6WnpbBW5LXv37qWqqoqf/vSnRCKRTZEbYcY3NzdTU1NDT08PTU1N1NbWUl9fj9VqxWAwyOjJT37yE06fPn3NHkmlhvDdXP2c4vE4U1NTDAwMcP78+SJd3e2hUCiQSqXo7++XkVur1YrH48FkMmGz2bDb7RiNxpJ5f28UVaEEr/iddCAUjtuamhoqKiqk+Gg0Gh599FEee+wxKioqMJlMaLVamV/x13/91/zgBz/g8uXLRKPRW3L9t3JmukqloqGhgcrKSu677z727t3LZz7zGRk2np+fl9Es8XcLh6rRaJQfrKiuFgWQAM8//zzf+MY3OHfuHCsrKzcdvr3Ts+HFUePXf/3X+cpXviJ/bj6f58SJE/ze7/0eMzMzb3n0eifc6XW+FWazmaqqKn77t3+bX/iFX8BisZBMJhkbG+Nb3/oWjz/++Du24IshBWVvAQnE+XdhYWFTMqJaraa3t5dkMrkpc1bkU8zOzjI6OlqykZ9CocD8/Dxra2tYrVYAWY7gdDppa2uTbRjE74/FYjLzV/hIbDYbJpNJtn+IRqOsrKzI6utyyB3RaDSyUZcQ1mw2y9LSErOzs0xPT2+po9e1SCQSst1MMpmUz7W2tla2KSkntowAXQ+RMyE+MLVaTT6fZ319nRMnTjA5OSl7RJcyqVSKl19+mXPnzvHkk0/y6U9/mg984APs2LEDh8OBy+WSR5O5uTmWlpb40Y9+RGVlJffeey8dHR04nU7git9scnJSNqwq1byfq7FYLLzvfe+jpaVFWhuxWIwnnnhCluGUoEF/SxH+wXA4zNraGi6XS/YAKvXj87XY8gIEyMI+US2fz+fx+/2cP39eOnDL4cXN5/Oyydq5c+eIxWKcPXsWs9ksG5fDlehgKBRiYGAAm82G1+vl4x//ODU1NbJsIZVKybqnclg7vNGOo7u7G7jiJ0skEly+fJnJycmyWcetQEQuxfMT70WpD1C4mveMAHk8Htm0KZfLsb6+zsmTJ1laWiqrnUOMDzpz5gxnzpx529+vVqs5fvw47e3tHDp0SOYXpVKpTfkx5UBFRQW/8Au/II8a2WyWaDTKuXPnWF5eLvLVvXPeaQcCIUDieQpLtpQ7GlzNe0KAri5ajEaj+P1+5ufnS74L4LtFHEFFsyqR6r/xhS0XRGcAMcjv8ccf5/Tp02XXFVEgfJLCkXwjxyhRH+ZwOPB4PLID6D//8z9z6dKlsrHmBe8JARKlBmL3F3U04XC4pPNebhX5fP5NWc6imrpcXlar1Sqr24Xz+fXXX+ell14ikUiUzTquxmAwUFVVJctFotGoLIq9VtKlyGZ3Op0yAzwejzM5OSknw5YT7xkB2ng2TqVScscptwf2TrFYLLhcLrnj9vb23tARrhTQ6XQyC1in0xGLxQiFQvh8PkKhUFk/w/b2dn7t135NNtt/+umnGR8f57nnnttkEanVamw2Gzt37uSXf/mX2bt3Lw6Hg0QiIUW5HNnyAnT1sMJMJsPAwAAzMzNl/eLeLCI7emMV+Dvpm32nEUeOrq4u2Tp2dnaW1157TY4YKmdEDWNtba0slRFFwqJ9bqFQQK1W43Q66ezspLu7e1NbWjHRNxaLFXs5N82WFiBRF7ZxtnssFuMb3/gGw8PDRbyyO4tobCZKFxKJBENDQ7c8Ye92IHKY7r33Xnbu3EmhUODFF1/kD/7gD8ryg9uIEBadTofD4aCuro6Pf/zj5PN5Pve5z8lWIvl8XvaH0uv1mEwmuakWCgUSiQTj4+N4vd4ir+jm2dIC5HK5+OAHP0hfX5/8tWw2y+zsLKurqzf0M66uPyo3q0lkiG+cmy4igaVsPRiNRlwuF0ePHmX//v3U1tYSDoc5duwY58+f39RcrJxZWFjgySefZHV1lf3799PV1YXZbMZkMsluneKdMxqN0qIXka+NdXzlYNFezZYWIJvNxn333UdHRweALL9YWVnB7/e/7Z8XvqONWcYb/7ccEAJ0tY+glPN/VCoVZrOZ+vp6jh49yoc//GGcTieLi4scP36c0dHRsup581asra3Janej0Uh1dfWmaR1CgDZ2dRBHs1gsxunTp7l06VLRO3i+U7a0ADkcDh555BEqKysBGB4eZnR0lEgkckMvsHjoG83dcmNjBFCsR/RCzmazMjO8VNDpdDQ3N3PXXXfxW7/1W1RVVWGz2Th//jz9/f388Ic/3FLlFiKX6ZlnnuHEiRM8/vjjNDY28tnPfpaWlhba29tlac3MzAyrq6sMDAwwNjbG7Owsc3NzxGKxsmvDIdiSAqRSqWhqaqK9vV2OrQWYnp5mcHCQVCp1Uw9r4+8tx4cszPVYLCazwW02Gw6HA4fDIUO/xaayshKHw8GuXbvo6+ujp6dH9iuamppibGwMr9dbEtd6KxHNx0TTea/Xy44dO/D5fASDQdmsbHZ2luXlZYaHhxkfH2dhYaHsI7lbUoD0ej1f+MIX5PhbcWb+3ve+x7PPPnvTVe+lZCHcLKJcYX5+nuHhYerr69HpdBw6dEj20Hn99dflHPlioVar+eAHP8iePXv41Kc+hdPpxGg0yiPHv/zLv8g+z1uZXC7H4uIif/ZnfyaP/xuP/uIYVo7+yGuxJQUIkE26E4kE8Xgcv9/P+vr6LR84Vw4UCgVGRkZ44YUXaG9vl5NfFxcXsVqtRZ+IqtVqMRgMWCyWTdcjxvBMT0/LVrnvhWcnym3eC2w5ARL+mqWlJdxuN9FolKWlJcbGxlhfX7/p49dW4fXXX2d+fp6dO3diNpvlCy6a3Iujzp1GtAuxWCyYzWYpjsLReu7cOU6cOCGnlShsLbZMQ7KNqNVqWlpasNvtVFdXk0wmiUajTE5O3pHM2VJqYCUwGAwYDAbsdruMiun1evR6PYuLi+8oivJu1ymuwWw2y7FKHo+H+vp6EokEi4uLLCwssLa2JntjF4NSfJ63g2JIwZYUoGJT6i+sCM0bjUYsFouMCt4uAbpezZkoLhUCJDpWmkwmAoEAIyMjpNPpoh9HSv153ioUAVJQUHhPoX7736KgoKBwe1AESEFBoWgoAqSgoFA0FAFSUFAoGooAKSgoFA1FgBQUFIqGIkAKCgpFQxEgBQWFoqEIkIKCQtEoyWLU90pKu7LO8kBZ5+1DsYAUFBSKhiJACgoKRUMRIAUFhaKhCJCCwhbg6um/5YIiQFchhviJSRIKCuWAeFfL7Z0tyShYsRDzmIQARSKRojfDUrgxNs5v2/gRijaz74W2V8IKKqeG9YoA/X9EX+Kuri5MJhNms5mBgQG8Xi/xeLxsHuh7AdHRsaWlBbfbze7duzEYDNec/ppIJJicnGRwcFB2ftwKE1Wv5urJGRvZeDwrtQkv73kBEg/HaDTi8Xi49957cTqd2O124vE46XSaZDJZli/tW5nj5SyoGo0GvV7Pzp072bVrF5///Oex2+2bBCibzZJOp/H5fDz11FOEQiHm5+cJh8NlZSHcKNdbjxDrjb+vlNb+nhQgMS3UZDLR0NBAVVUVvb29eDweOZvbbDbzkY98hJ07d/Ld736XUChEPB4v9qW/JVqtFr1eT19fHw0NDRw6dAiHw4HT6dy0A8ZiMUZHR1laWmJ2dpalpSXC4TCBQEDOjC+1FxXe+JiOHj3Kxz/+cXp6evB4PFgsFtl3WszNmpubY3FxkWeeeYa5uTm0Wi06nQ69Xk8mkym5tQnEGq1Wq1xLIpG46X7darUai8WCTqfDaDQSj8dJpVIlJ77vCQESjmW1Wi39PCaTCZfLRXt7O42Njezfvx+Xy0VFRQV6vR6DwUBXVxc2m42XXnpJvgil9PDgijWg0+lwuVwYDAaMRiM9PT10dHTw/ve/n8rKSqqqqjYJUDgcpqqqiunpaex2OxaLBZ/PR6FQIJlMEo/HS3b4nUajobGxkfvvv5+amhosFgtarZZ8Pk8mkyEWi5FIJJiammJqaoqzZ8+SSqXkB1zKTlqVSiXfzZqaGrkZLC0t3dQ8OzHtpKqqSgrQ+vp60aaKvBVbXoA0Gg1OpxOPx4PT6aSyspKHHnqIhoYGtm/fjsViwWg0otVq5QeYy+XI5XJUVFTQ3t6O1+vl0qVLfP/73yebzZbMOVqlUlFbW0tvby9f/vKXsdls6PV6+d/EkL+Nv1YoFHC73dx///0cPnyYTCZDMpkkGAzyD//wD4yNjfHKK68QjUZJJBLFXN6bEJuH0+mkpqYGk8mEWq0mm80SCoWYnp7mhz/8IadOnWJqaopYLEYsFgOurF3MTy+V5ycQDnS9Xs+DDz5IV1cXH/vYx0in04TDYf70T/+Uc+fO3fBMu+3bt9PS0sLP/MzPoFKp8Pv9/OAHP+D06dMlt/YtLUAajQaz2Yzb7aa5uZmmpibcbjddXV1UVVVRU1ODTqdDo9FI0dkYTdHpdORyOfR6PRqNpuSsAa1Wy/79+9m9ezcNDQ2k02mCwSBTU1OEw2Fp+el0Ojl3vb6+HoPBIC1CvV6PVqslm81it9sxm81ybliprRfePJ5YjG4OhULS6pmenmZtbU3OTRd+vlJcj7g2YanU1tbS0NBAbW0t8XgctVqN1WrFaDTKo6NYS6FQkFa9Wq3GbDZjt9vZs2cPnZ2d1NfX4/f7mZubIxKJlJz4wBYWIDH0rrq6mq6uLvbv38++ffuora2VH6HBYCCbzcp/crkcmUxGnsPFg47FYsTjcbmDlgLCGvj1X/91du3ahdFoZHR0lJMnT/L1r3+dkZERMpkMOp0Oq9XKwYMH2bVrF5/85Cel9QBvHMlCoZA8wqnV6pI8qoiRxWLQpEajkT6thYUFXnrpJQYHB1lcXNwUNChFfxa8IT7iWTocDrZt28a2bduw2+3ynRQz04QFJKy+XC6HyWSSvr/W1la2b9/OL/7iL9LV1YXf72dqaopvf/vbBINBRYDuBGLH3717N7W1tWzfvp3m5mY6Ozuprq7GbDaTSqUIBoOsra0xMzPD2tqajKxUVVXR2NhIW1sber0elUpFe3s7a2trxV4acEV4tFot9957L3v27MHlcjE7O8s3vvENlpaWWFhYYHFxkUwmI/0i0WiUoaEhuV6bzYbdbsftdlNTU0NtbS1Go5GGhgbUajXpdJrz588zPj5eUtE/ISRicxGWaj6fJxKJMDU1VbIf2tWoVCoMBgNOp5O2tja2bdtGc3Mz+/fvp7q6Wm4c1dXVPPzww+zatYtUKoVWq8VisUjrT6QfaDQaKioqcLvdtLW1YTQaiUajhEIhQqFQSfp/YIsJkAinWywW9uzZQ1tbG3v37qWqqora2lqZpLWysoLX62V0dFR+aGJs8Y4dO9Dr9Wzbtk2+5A0NDbjd7mIvTx6ZrFYrBw4c4JFHHsFgMDA2Nsbf/u3fEo/H3yQY+XyeVCrF7Owss7OzvP766+h0Ovni9/b2cuDAAWpra6msrJSiu7i4yNTUVMk5oguFgtwshAAJkV1cXCQajZbU9V6LjZGumpoadu3axcGDB+np6aGtrU1aNWazGZVKxcGDB0mlUmg0GkwmExUVFcCVe6HT6eTP02q1aLVa1Go1qVRKik8p57FtGQHS6/XYbDY+8YlPcP/999Pb24vT6ZRREp1Ox9jYGLOzs/zFX/wF6+vrRKNRYrEYyWRSPsALFy6QSqXYv38/RqMRvV4vI0XFfIh6vZ7t27dz4MABPve5z+F0OtFqtXzhC19gYGDgmuJzLTYm6AWDQVZXV5mZmSGZTFJfX49Wq6Wzs5OOjg5WVlbkfysFNvpLxMcZj8c5ffo0r776KnNzcyVzrW+FXq+nsrKS3/md36G9vZ0dO3ZgtVoxmUwYDAZ5/BXWbiqVIhqNsry8LAMKBoMBvV5POp2WKSWAzPmJRCL8j//xPxgfHy9Z8YEtIkAqlQqHw0Fvby+7du2it7eXpqYmDAYDuVyOUCiEz+djYGBAZsUGg0Hp0xFmvVqtJh6Ps7KywtraGhaLBZPJVHR/iJihvnPnTvbs2cOuXbuIxWIEAgEmJyeZnJy8qaOSOMIIKyKTyZBIJIjFYlitVlwuF7W1tTQ3N7O6ukomkymJo9hGX47I+8nn83KnTyQSJXGdb0dlZSWNjY309vbS0tJCc3Pzm36PWFsmk2Fubo61tTUWFxfR6XQsLS3JzVFYxNu2bQPeiPYlk0mmp6dZXl6+08u7KbaEAIlo0F/91V9tiuRkMhnW19d54YUX+M53vsPAwAA+n++aiWjCMojH44yNjfHss8/ycz/3czQ2NhKJRIqahGg2m6mrq+P3f//3qaurQ6fTEQgEmJmZIRwO3/SubzAYaGlpoa6ujsbGRkwmE7lcjqWlJerq6tixYwf33nsvra2tLCwsyCNOsSkUCjINQvh5xK/lcrmbTtYrBiqVive///3s37+fPXv2bMrgFgIr3sVQKMTq6ip/8id/wqlTp2Qemtgs1Wo1ra2t7Nq1i6985SvSeorH44RCIbxeL6FQqMgrfmvKXoAMBgP79u2jr68Pm81GLBZjdXWVs2fP4vf7CQaDjIyMMDU1dcPOuOXlZc6cOcORI0fweDzMzMywsrJyB1ZzbcTHJV7ObDZLf38/p06duukXTGSB2+127Ha7zLhNpVKk02lMJhN+v59AIEAoFNqUxFcK5PN5gsEg09PTuFwuEokEly9fZnJystiXdkOoVCp8Pp/0sZnNZvL5PMvLy/h8vk2RLp/Px/LyMuPj48RisTcVRqvVatbX1/F6vZtqwU6cOMHFixdLPnMfylyAROboBz7wAfr6+jAYDMzNzTExMcFXvvIVJicn35FPQJi8n/3sZ2lubmZ8fJyFhYXbsIIbI5vNymOS8Fe98sorPPnkk/j9/pv6WWq1Wjqh7XY7NpuNeDxOIpEgHA6j1WpZWlpieXmZ5eVlEolESXUEyOfzrK2tMTg4SHd3N9lsltOnT7O4uFjsS3tbxFF+aWkJnU7HxYsX0ev1JJNJzpw5w9DQkNxQDAYDPp+PpaWl60b18vk8Pp8Pn8+3qYTmhz/8Ic8995xMwixlylqAnE4n9fX1fOADH6CxsRGNRsNLL73ED37wAxYWFt5x6FGcvYXA9fb2EgwGb+3F3wTZbJZYLMaZM2fo6Oigt7cXu91OW1sbiUSCaDQqX9KNlc9X5y0J34+IFLrdbpqamqTj0ufzkc1mmZqa4vz584yMjBAIBEourC2sQIvFgs1m47d+67c4c+YMTzzxRLEv7S0Rz2JmZobV1VXm5ubkr/v9fiKRiLQ2RTrE2917kbtlNptl4mwkEiEUCpXcc7sWZS1AZrMZp9NJU1MTHo8HlUrF3NwcFy9e3PRR3iwbE8Q0Gg0ulwubzXaLr/7GKRQKpNNpJiYmMBqNdHV1yRyR6elpMpkM2WwWjUYjs7+1Wq0sYhRmfaFQkHVuRqMRq9UqI4XCMvJ6vczNzTE7O8vMzMwNp//fScQxUkQ+Dxw4QCgUKtls540UCgXC4TDhcJjV1dV3fL3i/RT1i1rtlU9ZJGomk8mSvxdQ5gJUW1tLe3s7FosFvV4v0/Lfbdq5yLUwm82o1WqCwWDRnbDxeJx/+qd/IhgM8sgjj7B9+3Y0Gg1+v5+1tTVSqRRut5v6+noeeugh6uvrWVxcZGFhgVdffRWv10skEkGr1eJyuaivr6ehoYGWlhYZ0jcYDKytrfHiiy+ytLRUsun7brebnp4e7HY7Op2O5uZmamtrMZlMpNPpkvJZXYtbIQwmkwmbzcZv/MZv0NfXh16vl5HRaDRaUsfmt6KsBchoNMrSAeBNEZJ3Sk1NDXv37sXlcpHP55mcnCy6jyGXyxEMBgkGg9IqEYWmIldEHNUymQxqtZrm5mbsdjtarVa+mOFwWL68ZrNZWkSi9CSbzcrIWimKD1zJdRFlNIlEApVKRU1NDQ8++CAzMzPSoVvqQnSjbCxWNRqNOBwOGhoaaGhooKenh/r6egqFAj6fj9HR0bJIxhSUtQAZDAaZkJbL5Ugmk7fkpdu/fz///t//ezo6Okgmkzz33HNMTU3dgit+5xQKBUKhEMFgkEAgQCwWI5VKybot4aBeX1+npaWFXC7Hgw8+SG9vLw8++CCZTIZUKsXrr79OJBKhUChgs9lk6crGfKBAIEAqlSrqeq+HWK9KpSIcDqPRaGSO1F//9V/zzW9+kxdeeIHTp08TDoeLfbm3BJ1Oh06no6KigtraWnbv3s0HP/hBDhw4IJ9hNptlfHycp556qqgR25ulrAVodnYWjUbD4uIihUKBgYEBZmdn3/XPtdlsMis4Eomwurp609Gm20GhUGB6epr/83/+jyycXV5eJhAIbPrYXn75ZcbHx5menqanp4eHH35404ebyWRYXV19Uy3R6Ogo09PTt0zIbzWi5GBqakoeRzOZDHq9nsbGRu655x7q6uq4++67GRwclAXE5Yp4XiaTCbvdzuHDh2loaKCvr08GD+LxOMlkkvn5eV577TXOnTtX1IDJzVLWArSysiLzJWKxGK+//vq7KhpVq9WyJsztdpPL5UilUjJCUQosLy/z1FNP4fF4sNvtBAIBmSgpwrCDg4PodDpmZ2fx+XwcOnRI1hcJP9na2hparRaHwyGPaXNzc6yurt5Q9KVYiA3npZdeYm5ujmg0isFgYNeuXXR0dGC32+nu7sZqtUrLoFwRAmQwGGS/8tbWVnbu3CmfmUg6HB4eZnh4mNHR0bIoRxGUtQCJj2llZUXuEOPj4wwPD8teMDdDa2srf/RHf0RPTw9arZbl5WXm5uZKKr0/nU6zvr6O0+nc1NdnY9GoyAmZn5/nhRdeYHZ2loMHD9LZ2cn09DSxWIxwOIzVapXiZTAYMJlM0qdWii0sREmKOI76/X5p+SUSCUKhEJWVlXJdxS6hebfk83lUKpU8cn/3u9+lr6+P2tpaLBYLFotF/vfh4WEWFhZIJBIlu3lci7IWoI3Nw4xGo2xF0NnZyczMzNvWBqlUKmw2GxaLhYqKCrq7u9mzZw9ut5tCocDMzAxDQ0MlFVEQoitesuv17hHZzT6fj6GhIWw2m/xws9msrJwW1dQi92ljxnWpIQRIpVKRSqXIZDKyTi0YDDI2NkZ1dTU2m61swtBvx8byk+XlZRobG+VRVKfTSat2ZWWlbHJ/NlLWAiSc0FVVVTQ1NVFXV8cv//Iv8/73v58vfvGLTExMyCkIVyMqje+66y727dvHJz/5Serq6mSrg2w2yxNPPMHzzz9fUs5MUaQopnXAGxXQ1yKdTuP1ejl79ixjY2O0tbVRWVlJV1cXLS0ttLS0yA92cXGRtbU1crlcSX68Wq2WyspKWSclhLhQKEhfyPLysvRzleIa3gmiNky8y3V1ddjtdplFHY/HOXv2LIFAoNiXetOUtQABsq+KmADg8XjQaDR85CMfkR9UMpmU4VqtVkt9fb1s/t3V1SXzSKxWK9lslomJCVk5Hw6HS+5FFtej0WhoaGggHA6zvr5+XWtPdBJMpVKy4dqOHTtwu904nU5SqRSBQICxsTHp0C81RJ6Sy+UiGo3KxmMbJ3hs7Pcs1nA967DcUKvVOBwOXC6XHEAAEAqF5BGtVJuOvRVlL0AqlUr269FqtbjdblwuF7/4i79IOBxmbm4Ov9+Pz+eTDZ3uu+8+nE4nFRUV8giTz+fJ5XLSmf13f/d3jI6OllxjdoEww5uamohEIgwMDLxl8zBR0NrU1ERPTw8HDx6U4fepqSlZX+Xz+W7LtV7ruoQ43IggiB5AHo+HQqGA1+uVltrGQsyrRxQLR+5GIdp4n8pFjDQaDR6Ph+rqarnJivuwtrZGPB4vKVfBjVLWAhSLxVhfX+fVV1+lq6uLPXv2AFdeuoqKChwOB263W+7+4qN1u93S9yFKFY4fP87MzAwnTpxgdnaWycnJkol8XYtUKkU8Hmf37t0yv0dU/1+LyspKOQmko6MDq9VKLpcjnU7zz//8z5w5c4ZwOFwyDnfRbmLjiCQxv21kZISFhYU3WTeiI6Yo0dDr9ZhMJiwWCw6HQw4fEI54UecmNp9SFSORA/S5z32OnTt3yqBDIpHgiSee4MKFC2V75CxrAUqn08RiMcbGxtDr9bIXrsgYFU5m2LzTiR1ZnKtDoRCXL19maGiI559/nmQyWbKJeBsRx8lCoUBzczM6nU4K6saiRp1OJyeD1NTUyNar8XiceDzOyMgIFy9evG1rfrsP42prRThYLRYLVqsVs9kse3o3NjYSCARwOp1EIhH54Yl1OhwO6Rc0mUxYrVYcDgcVFRWyR5RIthS1csLJW6wPWARThItA3A8RJDCbzVRXV7Nv3z6am5s3bZyDg4MMDQ2VzMZxs5S1AInCvv/5P/8n27ZtY3JyksOHD9Pb2yuPZIKNxwCxe/j9fp566ilOnjzJK6+8Is/S5bCTtLe3y0kXLpeLbdu2cfHiRU6ePMmpU6dYXl6mUCjI3s8/+7M/y5EjR2hsbJRz0BYXFzlz5gyzs7MyO/p28FZHrY3NtURLUrfbTXt7Ow8++KBsnCbq1QqFAt3d3ezevZt/+Zd/YXx8nHg8jt1up729nb6+Pjo7O2ltbcVms2G1WuXHLUpR7HY78/PzmEwmgsEgkUhEJjXe6SiSVqvFaDTK3kzi+ahUKpqbm+nu7qatrQ2Px0N3dzcGg4FCoUAkEmFtbe0dNaQrJcpagADZknNpaYlLly6h1+sJh8NUVFRgMplwu93yJY9Go6RSKRKJhNwFh4aGmJqaKivxAQgGgywvL5PL5TAYDNTX15NMJslkMlgsFrxeL/l8HpvNRl1dHdu3b6empkbm+SQSCRYXF7lw4UJRW26IZyOapNlsNjo6Omhvb6elpYXGxkaqqqpkxX42m6Wurg6VSsW9994rW5JYLBbq6+tpa2ujvr5eTvowGAzk83lpMQCyWrwYgnMtVCoVZrOZiooKOjo6cDgcOBwO6urqaG1tpba2FrvdvilHK5vNlqXT+WrKXoDgys4qMoRff/11qqqqqK+vp7q6msOHD8vhgxMTE3i9XhYWFmRkTBSaluLY5bdCzL/63Oc+R319PRUVFVRUVHDgwAHgjXA9bHbEivwgr9fL+fPn+eY3v3lHOudd796Ko5PRaKSuro7a2lre//7309DQINuOmM3mTUmXDoeDtrY27rnnnk1O6I3O5o2tTVOplJwSsba2xuTkJMvLy3i9Xpn7VEwhUqlUOJ1OmpubOXz4MC0tLezYsUMWW2+8d2Jdwq8JyFy4cmRLCBC80URMTLtYW1vDbDYzMTEhd9lgMCiH2omoUCgUKunK7+uRyWSIRCL8y7/8C3Nzc3ziE59405HzaidtoVBgYWGBubk5vvvd73Lx4sWSWLt4dqKC/ezZswwODvLqq69K53BzczP19fV88IMflEdI2Hy03ig+sVgMn8/HqVOnWFpaYmZmRpatjIyMEIvFZLsR4YQuxn3I5/OylisajVJbW0sikaCvr2+TP0j8XmHN+f1+FhcX5SjxcmXLCJAwS8WEBMHly5eLeFW3DzFa5+TJk8RiMT72sY/JlhoC8XEKR6uYsDAwMMD3vve9Ozaw7q0sS2GpiWcnHOjC0RqJREgmk/T19bFjxw4OHDiAxWKReTBinWKTET9PjCQ+duwYw8PD9Pf3k0qlSi7aJZJKV1dX8fl8DA8PSx/QRuf8xn7giUQCr9crBajYG8i7YcsI0HuRfD7P5cuXyefzTExMyBwR8bKmUikWFhY4ffo0p06dor+/n3A4TDwef8vExTvFxokWKpWKdDqNWq3G6/XK3yMsk7Nnz3Lp0iV+8pOfSOtHOJdNJhMej4fe3l7W19fluKJoNMr6+ro8bpf6h5rL5Th79iyJRIKVlRWZKCosn3A4zPz8PCdPnuTFF1/kwoUL0g9YrigCVOaI46bwfYkJrhsF6Pz585w/f57BwcGSmm8vuDqL+VqINqYbux1sbFfh8XhkoW4wGGRubq4k28m+FSKqu7q6ysDAAK2trbLMJpPJMDs7y/j4OJcuXWJsbIz5+fmyFh8AVaEEn1C5VzHf6C29VesUzeav9vtsdMTeik6RV3On1/l2f8fGKv5b+Vrf6XXq9Xpqamp46KGH+PSnP43JZCKRSPDkk08yPj7OmTNnbovjvBhSoFhAWwBh7byXEUK7FchmswQCAQYHB3nmmWfkCOb+/n7W1tbKNuv5WigW0G2glCyD24myzs3cynWKo6VIpBQzwG5nxrZiASkoKABvWLUbrbpilovcLhQBUrjtlMO8rlIkl8ttmWPl9SjJI5iCgsJ7g/LN4VZQUCh7FAFSUFAoGooAKSgoFA1FgBQUFIqGIkAKCgpFQxEgBQWFoqEIkIKCQtFQBEhBQaFoKAKkoKBQNBQBUlBQKBqKACkoKBQNRYAUFBSKhiJACgoKRUMRIAUFhaKhCJCCgkLRUARIQUGhaCgCpKCgUDQUAVJQUCgaigApKCgUDUWAFBQUioYiQAoKCkVDESAFBYWioQiQgoJC0VAESEFBoWgoAqSgoFA0FAFSUFAoGooAKSgoFA1FgBQUFIqGIkAKCgpFQxEgBQWFoqEIkIKCQtFQBEhBQaFoKAKkoKBQNBQBUlBQKBqKACkoKBSN/wevEmJ4nYmAogAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=288x288 at 0x7F17A017FE90>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E_uoQPxdHV4t"
      },
      "source": [
        "Use imageio to create an animated gif using the images saved during training."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P-JQiFzeHXZ1"
      },
      "source": [
        "anim_file = 'dcgan.gif'\n",
        "\n",
        "with imageio.get_writer(anim_file, mode='I') as writer:\n",
        "  filenames = glob.glob('image*.png')\n",
        "  filenames = sorted(filenames)\n",
        "  last = -1\n",
        "  for i,filename in enumerate(filenames):\n",
        "    frame = 8*(i**0.25)\n",
        "    if round(frame) > round(last):\n",
        "      last = frame\n",
        "    else:\n",
        "      continue\n",
        "    image = imageio.imread(filename)\n",
        "    writer.append_data(image)\n",
        "  image = imageio.imread(filename)\n",
        "  writer.append_data(image)\n",
        "\n",
        "import IPython\n",
        "if IPython.version_info > (6,2,0,''):\n",
        "  display.Image(filename=anim_file)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RTCG8bdiHZY9"
      },
      "source": [
        "If you're working in Colab you can download the animation with the code below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bviCMXpwHahP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "outputId": "05773bb5-34bb-4660-b95e-63489ae5b387"
      },
      "source": [
        "try:\n",
        "  from google.colab import files\n",
        "except ImportError:\n",
        "  pass\n",
        "else:\n",
        "  files.download(anim_file)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_ade2fd8f-5646-4d3d-87b6-f84da0acb5a0\", \"dcgan.gif\", 471039)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}