HW2-Part2/Part1_WGAN_AlirezaHosseini.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ceN9TKLMPjcL"
   },
   "source": [
    "<div style=\"display:block\" direction=rtl align=right><br><br>\n",
    "    <div  style=\"width:100%;margin:100;display:block\"  display=block align=center>\n",
    "        <img width=130 align=right src=\"https://i.ibb.co/yXKQmtZ/logo1.png\" style=\"margin:0;\" />\n",
    "        <img width=170 align=left  src=\"https://i.ibb.co/wLjqFkw/logo2.png\" style=\"margin:0;\" />\n",
    "        <span><br><font size=5>University of Tehran , school of ECE</font></span>\n",
    "        <span><br><font size=3>Deep Generative Models Course</font></span>\n",
    "        <span><br><font size=3>Fall 2023</font></span>\n",
    "    </div><br><br><br>\n",
    "    <div style=\"display:block\" align=left display=block>\n",
    "        <font size=3>Homework 2 - Part 2</font><br>\n",
    "        <hr />\n",
    "        <font size=3>TA: <a href=\"mailto:p.zilouchian@ut.ac.ir\">Parham Zilouchian</a><br></font><br>\n",
    "        <font size=3>TA: <a href=\"mailto:alirezaghafouri@ut.ac.ir\">Alireza Ghafouri</a><br></font><br>\n",
    "        \n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "13CbqFIB52lb"
   },
   "source": [
    "# Working with WGANs using PyTorch\n",
    "\n",
    "This notebook is a homework assignment for the Deep Generative Models course at the University of Tehran. The goal of this assignment is to get familiar with the concept of Generative Adversarial Networks (GANs) and how to implement it with PyTorch. We will use the MNIST dataset for this assignment.\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "**Requisites**\n",
    "\n",
    "*   Python 3.x\n",
    "*   Jupyter\n",
    "*   PyTorch >= 1.8\n",
    "*   NumPy\n",
    "*   Matplotlib\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BdMSG6Zp4ey0",
    "outputId": "f6d202b5-ef24-43a5-e6ed-fbccb17b280f",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              total        used        free      shared  buff/cache   available\n",
      "Mem:          64129        7092        4260          18       52776       56306\n",
      "Swap:          8191        1092        7099\n",
      "Filesystem      Size  Used Avail Use% Mounted on\n",
      "overlay         916G  874G     0 100% /\n",
      "tmpfs            64M     0   64M   0% /dev\n",
      "tmpfs            32G     0   32G   0% /sys/fs/cgroup\n",
      "shm              64M     0   64M   0% /dev/shm\n",
      "/dev/sda1       3.7T  2.1T  1.7T  55% /code/Datasets\n",
      "/dev/nvme0n1p2  916G  874G     0 100% /code/content\n",
      "tmpfs            32G   12K   32G   1% /proc/driver/nvidia\n",
      "tmpfs           6.3G  2.8M  6.3G   1% /run/nvidia-persistenced/socket\n",
      "udev             32G     0   32G   0% /dev/nvidia0\n",
      "tmpfs            32G     0   32G   0% /proc/asound\n",
      "tmpfs            32G     0   32G   0% /proc/acpi\n",
      "tmpfs            32G     0   32G   0% /proc/scsi\n",
      "tmpfs            32G     0   32G   0% /sys/firmware\n",
      "Fri Dec 15 10:23:29 2023       \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 535.104.12             Driver Version: 535.104.12   CUDA Version: 12.2     |\n",
      "|-----------------------------------------+----------------------+----------------------+\n",
      "| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                                         |                      |               MIG M. |\n",
      "|=========================================+======================+======================|\n",
      "|   0  NVIDIA GeForce RTX 3090        Off | 00000000:01:00.0 Off |                  N/A |\n",
      "| 38%   65C    P2             121W / 370W |   4820MiB / 24576MiB |      4%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   1  NVIDIA GeForce RTX 3090        Off | 00000000:03:00.0 Off |                  N/A |\n",
      "| 36%   42C    P8              18W / 370W |      2MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "                                                                                         \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| Processes:                                                                            |\n",
      "|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |\n",
      "|        ID   ID                                                             Usage      |\n",
      "|=======================================================================================|\n",
      "+---------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!free -m\n",
    "!df -h\n",
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!pip install -qq pytorch-fid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HC2hjO_16xcU"
   },
   "source": [
    "# **Import Libraries:**\n",
    "\n",
    "Import your required libraries!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "c-0r2NYZ6k4Q",
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/root/miniconda3/envs/torch2/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision.datasets as datasets\n",
    "import torchvision.transforms as transforms\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torchvision\n",
    "\n",
    "import argparse\n",
    "import numpy as np\n",
    "import os\n",
    "import torch\n",
    "import torchvision\n",
    "from torch import nn, optim\n",
    "from torch.nn import functional as F\n",
    "from torchvision.utils import save_image\n",
    "from tqdm import tqdm\n",
    "import torchvision.utils as vutils\n",
    "\n",
    "from torch import autograd, nn, optim\n",
    "from torch.nn import functional as F\n",
    "\n",
    "import argparse\n",
    "from pprint import pprint\n",
    "from torchvision import datasets, transforms\n",
    "import random\n",
    "\n",
    "import torch\n",
    "from torchvision.models import inception_v3\n",
    "import numpy as np\n",
    "from scipy.linalg import sqrtm\n",
    "from torch.nn.functional import adaptive_avg_pool2d\n",
    "from scipy import linalg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "UuQrToSp64B3",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7febca7c97b0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use_cuda = torch.cuda.is_available()\n",
    "device = torch.device(\"cuda:1\" if use_cuda else \"cpu\");\n",
    "torch.manual_seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y2BJPsY26qbY"
   },
   "source": [
    "## **Downloading the dataset:**\n",
    "\n",
    "We will use the MNIST dataset for this assignment. The dataset is already available in PyTorch, so we just need to download it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "9XMDl6xO6mQZ",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train dataset shape:  torch.Size([60000, 784])\n",
      "Test dataset shape:  torch.Size([60000, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "preprocess = transforms.ToTensor()\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "            datasets.MNIST(root='./data', train=True, download=True, transform=preprocess),\n",
    "            batch_size=128,\n",
    "            shuffle=True\n",
    "        )\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "            datasets.MNIST(root='./data', train=False, download=True, transform=preprocess),\n",
    "            batch_size=128,\n",
    "            shuffle=True\n",
    "        )\n",
    "\n",
    "# Create pre-processed training and test sets\n",
    "X_train = train_loader.dataset.data.to(device).reshape(-1, 784).float() / 255\n",
    "y_train = train_loader.dataset.data.to(device)\n",
    "X_test = test_loader.dataset.data.to(device).reshape(-1, 784).float() / 255\n",
    "y_test = test_loader.dataset.data.to(device)\n",
    "\n",
    "print('Train dataset shape: ', X_train.data.shape)\n",
    "print('Test dataset shape: ', y_train.data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "mViiTort75hR",
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Reshape(torch.nn.Module):\n",
    "    def __init__(self, *shape):\n",
    "        super().__init__()\n",
    "        self.shape = shape\n",
    "    def forward(self, x):\n",
    "        return x.reshape(x.size(0), *self.shape)\n",
    "\n",
    "\n",
    "class ReLU(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "    def forward(self, x):\n",
    "        return torch.maximum(x, torch.zeros_like(x))\n",
    "\n",
    "# class ReLU(nn.ReLU):\n",
    "#     def __init__(self):\n",
    "#         super().__init__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nGEFjVJv7BcS"
   },
   "source": [
    "## **Define Generator:**\n",
    "\n",
    "We will use a simple 5-layer convolutional neural network for this assignment. The network is defined in the `Net` class below. The network is composed of 3 convolutional layers and 2 fully connected layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "G1FwF6wk66iW",
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    def __init__(self, z_dim=64, num_channels=1):\n",
    "        super().__init__()\n",
    "        self.z_dim = z_dim\n",
    "\n",
    "        # Define the generator layers\n",
    "        self.layers = nn.Sequential(\n",
    "            # Block 1: Linear -> BatchNorm\n",
    "            nn.Linear(z_dim, 512),\n",
    "            nn.BatchNorm1d(512),\n",
    "            ReLU(),\n",
    "\n",
    "            # Block 2: Linear -> BatchNorm\n",
    "            nn.Linear(512, 7 * 7 * 64),\n",
    "            nn.BatchNorm1d(7 * 7 * 64),\n",
    "            ReLU(),\n",
    "\n",
    "            # Block 3: Pixel Shuffle\n",
    "            Reshape(64, 7, 7),  # Reshape to (16, 7, 7) before Pixel Shuffle\n",
    "            nn.PixelShuffle(2),\n",
    "\n",
    "            # Block 4: Conv -> BatchNorm\n",
    "            nn.Conv2d(16, 32, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(32),\n",
    "            ReLU(),\n",
    "\n",
    "            # Block 5: Pixel Shuffle\n",
    "            nn.PixelShuffle(2),\n",
    "\n",
    "            # Block 6: Conv\n",
    "            nn.Conv2d(8, num_channels, kernel_size=3, padding=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3ma0GeGU7ErX"
   },
   "source": [
    "## **Define Discriminator:**\n",
    "\n",
    "We will use a simple 5-layer convolutional neural network for this assignment. The network is defined in the `Net` class below. The network is composed of 3 convolutional layers and 2 fully connected layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "EI1HHHfM7Hwr",
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self, num_channels=1):\n",
    "        super().__init__()\n",
    "\n",
    "        # Define the discriminator layers\n",
    "        self.layers = nn.Sequential(\n",
    "            # Block 1: Conv -> ReLU\n",
    "            nn.Conv2d(num_channels, 32, kernel_size=4, stride=2, padding=1),\n",
    "            ReLU(),\n",
    "\n",
    "            # Block 2: Conv -> ReLU\n",
    "            nn.Conv2d(32, 64, kernel_size=4, stride=2, padding=1),\n",
    "            ReLU(),\n",
    "\n",
    "            # Flatten the output\n",
    "            nn.Flatten(),\n",
    "\n",
    "            # Block 3: Linear -> ReLU\n",
    "            nn.Linear(7 * 7 * 64, 512),\n",
    "            ReLU(),\n",
    "\n",
    "            # Block 4: Linear\n",
    "            nn.Linear(512, 1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YsWv1STH8zgn"
   },
   "source": [
    "## **Define Your GAN:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "BsK56XCd8xrN",
    "tags": []
   },
   "outputs": [],
   "source": [
    "class GAN(nn.Module):\n",
    "    def __init__(self, z_dim=2):\n",
    "        super().__init__()\n",
    "        self.z_dim = z_dim\n",
    "        self.g = Generator(z_dim=z_dim)\n",
    "        self.d = Discriminator()   \n",
    "\n",
    "    def loss_wgan(self, x_real, *, device):\n",
    "        '''\n",
    "        Input Arguments:\n",
    "        - x_real (torch.Tensor): training data samples (64, 1, 28, 28)\n",
    "        - device (torch.device): 'cpu' by default\n",
    "\n",
    "        Returns:\n",
    "        - d_loss (torch.Tensor): WGAN discriminator (critic) loss\n",
    "        - g_loss (torch.Tensor): WGAN generator loss\n",
    "        '''\n",
    "\n",
    "        # Generate fake data\n",
    "        z = torch.randn((x_real.size(0), self.z_dim), device=device)\n",
    "        x_fake = self.g(z)\n",
    "\n",
    "        # Critic (discriminator) loss\n",
    "        # In WGAN, the critic outputs a scalar (Wasserstein estimate)\n",
    "        wasserstein_estimate_real = self.d(x_real)\n",
    "        wasserstein_estimate_fake = self.d(x_fake.detach())\n",
    "\n",
    "        # The critic aims to maximize the difference between its output on real and fake data\n",
    "        d_loss = -(torch.mean(wasserstein_estimate_real) - torch.mean(wasserstein_estimate_fake))\n",
    "\n",
    "        # Generator loss\n",
    "        # The generator aims to minimize the critic's output on its generated data\n",
    "        wasserstein_estimate_fake = self.d(x_fake)\n",
    "        g_loss = -torch.mean(wasserstein_estimate_fake)\n",
    "\n",
    "        return d_loss, g_loss\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eDsS8ytN9zTv"
   },
   "source": [
    "## **Training Process:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "9unvk3VO91Yh",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Lists to keep track of progress\n",
    "img_list = []\n",
    "G_losses = []\n",
    "D_losses = []\n",
    "iters = 0\n",
    "\n",
    "class Trainer:\n",
    "    def __init__(self,\n",
    "                 model,\n",
    "                 optimizers,\n",
    "                 device=\"cuda:1\",\n",
    "                 iter_max=10000,\n",
    "                 iter_save=1000,\n",
    "                 num_latents=100,\n",
    "                 out_dir=\"\"\n",
    "            ):\n",
    "        self.model = model\n",
    "        self.optimizers = optimizers\n",
    "        self.device = device\n",
    "        self.iter_save = iter_save\n",
    "        self.iter_max = iter_max\n",
    "        self.out_dir = out_dir\n",
    "        self.num_latents = num_latents\n",
    "\n",
    "        self.G_losses = []  # Store generator losses\n",
    "        self.D_losses = []  # Store discriminator losses\n",
    "        self.img_list = []  # Store generated images during training\n",
    "\n",
    "        # fix visualization latents\n",
    "        self.z_test = torch.randn(100, self.num_latents).to(device)\n",
    "\n",
    "    def viz(self, global_step=1):\n",
    "        with torch.no_grad():\n",
    "            generator = self.model.g\n",
    "            generator.eval()\n",
    "            fake = ((generator(self.z_test) + 1) / 2.)\n",
    "            self.img_list.append(fake)\n",
    "            generator.train()\n",
    "\n",
    "            # Show generated images\n",
    "            vutils.save_image(fake, '%s/fake_%04d.png' % (self.out_dir, global_step), nrow=10, padding=2, normalize=True)\n",
    "\n",
    "\n",
    "    def checkpoint_and_log(self, global_step, loss, summaries):\n",
    "        if global_step % self.iter_save == 0:\n",
    "            with torch.no_grad():\n",
    "                self.viz(global_step)\n",
    "                torch.save((self.model.g, self.model.d), '%s/model_%04d.pt' % (self.out_dir, global_step))\n",
    "\n",
    "        # Print generator and discriminator losses\n",
    "        if global_step % self.iter_save == 0:\n",
    "            print(f\"Iteration {global_step}:\")\n",
    "            print(f\"Generator Loss: {loss['generator_loss']:.4f}\")\n",
    "            print(f\"Discriminator Loss: {loss['discriminator_loss']:.4f}\")\n",
    "\n",
    "\n",
    "    def gan_step(self, x_real, y_real):\n",
    "        assert len(self.optimizers) == 2\n",
    "\n",
    "        generator, discriminator = self.model.g, self.model.d\n",
    "        g_optimizer, d_optimizer = self.optimizers\n",
    "\n",
    "        # Compute discriminator and generator losses\n",
    "        discriminator_loss, generator_loss = self.model.loss_wgan(x_real, device=self.device)\n",
    "\n",
    "        # Update generator\n",
    "        g_optimizer.zero_grad()\n",
    "        generator_loss.backward(retain_graph=True)\n",
    "        g_optimizer.step()\n",
    "\n",
    "        # Update discriminator\n",
    "        d_optimizer.zero_grad()\n",
    "        discriminator_loss.backward()\n",
    "        d_optimizer.step()\n",
    "        \n",
    "        # Weight clipping for the discriminator\n",
    "        for p in discriminator.parameters():\n",
    "            p.data.clamp_(-0.01,0.01)\n",
    "\n",
    "        # Update the optimizers in the class\n",
    "        self.optimizers = [g_optimizer, d_optimizer]\n",
    "\n",
    "        # Append losses to the lists\n",
    "        self.D_losses.append(discriminator_loss.item())\n",
    "        self.G_losses.append(generator_loss.item())\n",
    "\n",
    "        return {\"discriminator_loss\": discriminator_loss, \"generator_loss\": generator_loss}, None\n",
    "\n",
    "    def train(self, train_loader, reinit=False):\n",
    "        global_step = 0\n",
    "\n",
    "        # train model from scratch\n",
    "        if reinit:\n",
    "            # OPTIONAL: Initialize your model if needed\n",
    "            pass\n",
    "\n",
    "        # train models for multiple epochs\n",
    "        with tqdm(total=int(self.iter_max)) as pbar:\n",
    "            # for epoch in range(self.iter_max):\n",
    "            while global_step < self.iter_max:\n",
    "                for batch_idx, (x, y) in enumerate(train_loader):\n",
    "                    x_real = x.to(self.device)\n",
    "                    y_real = y.to(self.device)\n",
    "\n",
    "                    loss, summaries = self.gan_step(x_real, y_real)\n",
    "                    global_step += 1\n",
    "                    pbar.update(1)\n",
    "                    self.checkpoint_and_log(global_step, loss, summaries)\n",
    "\n",
    "                    if global_step >= self.iter_max:\n",
    "                        break\n",
    "\n",
    "    def generate_fake_images(self, num_images):\n",
    "        z = torch.randn(num_images, self.model.z_dim).to(self.device)\n",
    "        with torch.no_grad():\n",
    "            fake_images = self.model.g(z)\n",
    "        return fake_images\n",
    "    \n",
    "    \n",
    "    \n",
    "    def evaluate_fid(self, test_loader):\n",
    "        # Load the Inception model\n",
    "        inception_model = inception_v3(pretrained=True, transform_input=False).to(self.device)\n",
    "        inception_model.eval()\n",
    "\n",
    "        # Generate a batch of fake images\n",
    "        fake_images = self.generate_fake_images(num_images=128)  # Adjust the batch size as needed\n",
    "\n",
    "        # Get a batch of real images\n",
    "        real_images, _ = next(iter(test_loader))\n",
    "        real_images = real_images.to(self.device)\n",
    "\n",
    "        # Resize images for Inception model\n",
    "        real_images = F.interpolate(real_images, size=(299, 299), mode='bilinear', align_corners=False)\n",
    "        fake_images = F.interpolate(fake_images, size=(299, 299), mode='bilinear', align_corners=False)\n",
    "\n",
    "        # Compute FID score\n",
    "        fid_value = calculate_fretchet(real_images, fake_images, inception_model)\n",
    "        print(f\"FID Score: {fid_value}\")\n",
    "        return fid_value\n",
    "    \n",
    "    def plot_losses(self):\n",
    "        plt.figure(figsize=(15, 5))  # Increase the figure size for three subplots\n",
    "        iterations = list(range(0, len(self.D_losses) * self.iter_save, self.iter_save))\n",
    "\n",
    "        # Subplot 1: Generator Loss\n",
    "        plt.subplot(1, 3, 1)\n",
    "        plt.plot(iterations, self.G_losses, label=\"Generator Loss\", marker='o', linestyle='-')\n",
    "        plt.xlabel(\"Iteration\")\n",
    "        plt.ylabel(\"Loss\")\n",
    "        plt.title(\"Generator Loss\")\n",
    "        plt.grid(True)\n",
    "        plt.legend()\n",
    "\n",
    "        # Subplot 2: Discriminator Loss\n",
    "        plt.subplot(1, 3, 2)\n",
    "        plt.plot(iterations, self.D_losses, label=\"Discriminator Loss\", marker='o', linestyle='-')\n",
    "        plt.xlabel(\"Iteration\")\n",
    "        plt.ylabel(\"Loss\")\n",
    "        plt.title(\"Discriminator Loss\")\n",
    "        plt.grid(True)\n",
    "        plt.legend()\n",
    "\n",
    "        # Subplot 3: Both Losses\n",
    "        plt.subplot(1, 3, 3)\n",
    "        plt.plot(iterations, self.G_losses, label=\"Generator Loss\", marker='o', linestyle='-', color='blue')\n",
    "        plt.plot(iterations, self.D_losses, label=\"Discriminator Loss\", marker='o', linestyle='-', color='red')\n",
    "        plt.xlabel(\"Iteration\")\n",
    "        plt.ylabel(\"Loss\")\n",
    "        plt.title(\"Generator and Discriminator Losses\")\n",
    "        plt.grid(True)\n",
    "        plt.legend()\n",
    "\n",
    "        plt.tight_layout()\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "mkdir result_wgan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mwzMBX0jDmCW",
    "outputId": "f1f5c2aa-41b2-41df-a637-124a819ed71f",
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|█         | 1009/10000 [00:12<02:16, 65.63it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 1000:\n",
      "Generator Loss: -0.0220\n",
      "Discriminator Loss: -0.0650\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██        | 2009/10000 [00:24<02:08, 62.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 2000:\n",
      "Generator Loss: -0.0435\n",
      "Discriminator Loss: -0.0304\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|███       | 3009/10000 [00:36<01:53, 61.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 3000:\n",
      "Generator Loss: 0.0802\n",
      "Discriminator Loss: -0.0246\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████      | 4013/10000 [00:49<01:26, 68.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 4000:\n",
      "Generator Loss: 0.1516\n",
      "Discriminator Loss: -0.0256\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|█████     | 5010/10000 [01:01<01:14, 67.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 5000:\n",
      "Generator Loss: 0.0652\n",
      "Discriminator Loss: -0.0174\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|██████    | 6010/10000 [01:14<00:59, 66.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 6000:\n",
      "Generator Loss: 0.0951\n",
      "Discriminator Loss: -0.0135\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|██████▉   | 6997/10000 [01:26<00:37, 79.31it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 7000:\n",
      "Generator Loss: -0.0239\n",
      "Discriminator Loss: -0.0027\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████  | 8010/10000 [01:38<00:29, 66.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 8000:\n",
      "Generator Loss: 0.1985\n",
      "Discriminator Loss: -0.0073\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████▉ | 8998/10000 [01:50<00:12, 81.90it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 9000:\n",
      "Generator Loss: 0.3617\n",
      "Discriminator Loss: 0.0006\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [02:03<00:00, 81.25it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 10000:\n",
      "Generator Loss: -0.1308\n",
      "Discriminator Loss: 0.0019\n"
     ]
    }
   ],
   "source": [
    "def build_model(device='cpu', num_latents=64):\n",
    "    model = GAN(z_dim=num_latents)\n",
    "    return model.to(device)\n",
    "\n",
    "\n",
    "def build_optimizers(model):\n",
    "    g_opt = torch.optim.RMSprop(model.g.parameters(), lr=1e-4)\n",
    "    d_opt = torch.optim.RMSprop(model.d.parameters(), lr=1e-4)\n",
    "    optimizers = [g_opt, d_opt]\n",
    "    return optimizers\n",
    "\n",
    "\n",
    "num_latents = 64\n",
    "device = torch.device('cuda:1' if torch.cuda.is_available() else 'cpu')\n",
    "model = build_model(device, num_latents=num_latents)\n",
    "optimizers = build_optimizers(model)\n",
    "\n",
    "\n",
    "trainer = Trainer(model, optimizers,\n",
    "                    device=device,\n",
    "                    iter_max=10000,\n",
    "                    num_latents=num_latents,\n",
    "                    out_dir='./result_wgan'\n",
    "                  )\n",
    "\n",
    "trainer.train(train_loader)\n",
    "\n",
    "trainer.viz()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lehQgTE0DlD6"
   },
   "source": [
    "## **Plot Losses:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "tW2_XrSaDqAa",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "############################# TODO #############################\n",
    "# Here, you should use the \"G_losses\", and \"D_losses\" in order to plot the \"Loss Values Variation Diagram\".\n",
    "\n",
    "trainer.plot_losses()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IQVPVIKW9JMi"
   },
   "source": [
    "## **Visualization:**\n",
    "\n",
    "By using the \"img_list\" you can visualize the animation of changes that occurred during training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "eGhbbD_hD6Z4",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<link rel=\"stylesheet\"\n",
       "href=\"https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css\">\n",
       "<script language=\"javascript\">\n",
       "  function isInternetExplorer() {\n",
       "    ua = navigator.userAgent;\n",
       "    /* MSIE used to detect old browsers and Trident used to newer ones*/\n",
       "    return ua.indexOf(\"MSIE \") > -1 || ua.indexOf(\"Trident/\") > -1;\n",
       "  }\n",
       "\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    var slider = document.getElementById(this.slider_id);\n",
       "    slider.max = this.frames.length - 1;\n",
       "    if (isInternetExplorer()) {\n",
       "        // switch from oninput to onchange because IE <= 11 does not conform\n",
       "        // with W3C specification. It ignores oninput and onchange behaves\n",
       "        // like oninput. In contrast, Microsoft Edge behaves correctly.\n",
       "        slider.setAttribute('onchange', slider.getAttribute('oninput'));\n",
       "        slider.setAttribute('oninput', null);\n",
       "    }\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src =\n",
       "            this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function() {\n",
       "        t.anim_step_forward();\n",
       "    }, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function() {\n",
       "        t.anim_step_reverse();\n",
       "    }, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<style>\n",
       ".animation {\n",
       "    display: inline-block;\n",
       "    text-align: center;\n",
       "}\n",
       "input[type=range].anim-slider {\n",
       "    width: 374px;\n",
       "    margin-left: auto;\n",
       "    margin-right: auto;\n",
       "}\n",
       ".anim-buttons {\n",
       "    margin: 8px 0px;\n",
       "}\n",
       ".anim-buttons button {\n",
       "    padding: 0;\n",
       "    width: 36px;\n",
       "}\n",
       ".anim-state label {\n",
       "    margin-right: 8px;\n",
       "}\n",
       ".anim-state input {\n",
       "    margin: 0;\n",
       "    vertical-align: middle;\n",
       "}\n",
       "</style>\n",
       "\n",
       "<div class=\"animation\">\n",
       "  <img id=\"_anim_img6f754011198942b2973ad7a65041d684\">\n",
       "  <div class=\"anim-controls\">\n",
       "    <input id=\"_anim_slider6f754011198942b2973ad7a65041d684\" type=\"range\" class=\"anim-slider\"\n",
       "           name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\"\n",
       "           oninput=\"anim6f754011198942b2973ad7a65041d684.set_frame(parseInt(this.value));\">\n",
       "    <div class=\"anim-buttons\">\n",
       "      <button title=\"Decrease speed\" aria-label=\"Decrease speed\" onclick=\"anim6f754011198942b2973ad7a65041d684.slower()\">\n",
       "          <i class=\"fa fa-minus\"></i></button>\n",
       "      <button title=\"First frame\" aria-label=\"First frame\" onclick=\"anim6f754011198942b2973ad7a65041d684.first_frame()\">\n",
       "        <i class=\"fa fa-fast-backward\"></i></button>\n",
       "      <button title=\"Previous frame\" aria-label=\"Previous frame\" onclick=\"anim6f754011198942b2973ad7a65041d684.previous_frame()\">\n",
       "          <i class=\"fa fa-step-backward\"></i></button>\n",
       "      <button title=\"Play backwards\" aria-label=\"Play backwards\" onclick=\"anim6f754011198942b2973ad7a65041d684.reverse_animation()\">\n",
       "          <i class=\"fa fa-play fa-flip-horizontal\"></i></button>\n",
       "      <button title=\"Pause\" aria-label=\"Pause\" onclick=\"anim6f754011198942b2973ad7a65041d684.pause_animation()\">\n",
       "          <i class=\"fa fa-pause\"></i></button>\n",
       "      <button title=\"Play\" aria-label=\"Play\" onclick=\"anim6f754011198942b2973ad7a65041d684.play_animation()\">\n",
       "          <i class=\"fa fa-play\"></i></button>\n",
       "      <button title=\"Next frame\" aria-label=\"Next frame\" onclick=\"anim6f754011198942b2973ad7a65041d684.next_frame()\">\n",
       "          <i class=\"fa fa-step-forward\"></i></button>\n",
       "      <button title=\"Last frame\" aria-label=\"Last frame\" onclick=\"anim6f754011198942b2973ad7a65041d684.last_frame()\">\n",
       "          <i class=\"fa fa-fast-forward\"></i></button>\n",
       "      <button title=\"Increase speed\" aria-label=\"Increase speed\" onclick=\"anim6f754011198942b2973ad7a65041d684.faster()\">\n",
       "          <i class=\"fa fa-plus\"></i></button>\n",
       "    </div>\n",
       "    <form title=\"Repetition mode\" aria-label=\"Repetition mode\" action=\"#n\" name=\"_anim_loop_select6f754011198942b2973ad7a65041d684\"\n",
       "          class=\"anim-state\">\n",
       "      <input type=\"radio\" name=\"state\" value=\"once\" id=\"_anim_radio1_6f754011198942b2973ad7a65041d684\"\n",
       "             >\n",
       "      <label for=\"_anim_radio1_6f754011198942b2973ad7a65041d684\">Once</label>\n",
       "      <input type=\"radio\" name=\"state\" value=\"loop\" id=\"_anim_radio2_6f754011198942b2973ad7a65041d684\"\n",
       "             checked>\n",
       "      <label for=\"_anim_radio2_6f754011198942b2973ad7a65041d684\">Loop</label>\n",
       "      <input type=\"radio\" name=\"state\" value=\"reflect\" id=\"_anim_radio3_6f754011198942b2973ad7a65041d684\"\n",
       "             >\n",
       "      <label for=\"_anim_radio3_6f754011198942b2973ad7a65041d684\">Reflect</label>\n",
       "    </form>\n",
       "  </div>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_img6f754011198942b2973ad7a65041d684\";\n",
       "    var slider_id = \"_anim_slider6f754011198942b2973ad7a65041d684\";\n",
       "    var loop_select_id = \"_anim_loop_select6f754011198942b2973ad7a65041d684\";\n",
       "    var frames = new Array(11);\n",
       "    \n",
       "  frames[0] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAPm0lEQVR4nO3c224WdRsF8I/uWyoBRAyyETeJiTGayF146lV6GZ4ZEw6MwSBB\\\n",
       "kYohyKY7untb2u8WnvXoX+jL73e8MpmZd6aLOWCdOTk5OfkfAIRmXvcJAHA6KRAAWhQIAC0KBIAW\\\n",
       "BQJAiwIBoEWBANCiQABoUSAAtCgQAFoUCAAtCgSAFgUCQIsCAaBFgQDQokAAaFEgALQoEABaFAgA\\\n",
       "LQoEgBYFAkCLAgGgRYEA0KJAAGhRIAC0KBAAWhQIAC0KBIAWBQJAiwIBoEWBANCiQABoUSAAtCgQ\\\n",
       "AFoUCAAtCgSAFgUCQIsCAaBFgQDQokAAaFEgALQoEABaFAgALQoEgBYFAkCLAgGgRYEA0DL3uk/g\\\n",
       "33Tt2rVy9syZM0OyJycn5Wzi+Pi4nJ2Zqf+7ILm2xcXFcnYymZSzyfkeHR2VswsLC+Vscr7JcQ8O\\\n",
       "DsrZ2dnZcvbVq1flbHJ/k+f3tGVHvReJ5BzW1taGnMO/yRcIAC0KBIAWBQJAiwIBoEWBANCiQABo\\\n",
       "USAAtCgQAFoUCAAtCgSAlqmaMhk1P5DMJSTnkMxyJBMIycxFcr77+/vlbHLPkuMmMyJ7e3vlbDIj\\\n",
       "khx31PMwaoonmcxJnrNRkyPJ75Zkk/NNfrdRU0eviy8QAFoUCAAtCgSAFgUCQIsCAaBFgQDQokAA\\\n",
       "aFEgALQoEABaFAgALVM1ZTJqGiTJHh4elrOJZDYiOd/EqHmHUVMbc3P1xzu5tuS4yfMw6nxHPZPJ\\\n",
       "b5HMiIyaJErOd9TzkLwXp4EvEABaFAgALQoEgBYFAkCLAgGgRYEA0KJAAGhRIAC0KBAAWhQIAC1T\\\n",
       "NWWSTHiMms8YNcOQSM4hmWwYdQ4LCwvlbDIF8SZc22nLJvds1DRIIplISSTXlhg1M/S6TNfVAPCf\\\n",
       "USAAtCgQAFoUCAAtCgSAFgUCQIsCAaBFgQDQokAAaFEgALRM1ZTJqHmHxKjZk2QCYW6u/rO+evWq\\\n",
       "nE0mR5L7cNomaJLzTaY2Rs1yJJLJkeTZGfVuvglzKpPJpJxN3s3TwBcIAC0KBIAWBQJAiwIBoEWB\\\n",
       "ANCiQABoUSAAtCgQAFoUCAAtCgSAlqn6f/XJVMGouYRkjiI57pswG3F4eFjOJvchubbkHI6OjsrZ\\\n",
       "xcXFcnZjY6OcXV1dLWf39vbK2QsXLpSzyW+xtLRUzq6vr5ezydzHqMmR5H2bn58fcg7TxhcIAC0K\\\n",
       "BIAWBQJAiwIBoEWBANCiQABoUSAAtCgQAFoUCAAtCgSAlqmaMpmZqffhqNmT5LhJNpmjSI6bzH3M\\\n",
       "zdUfl5cvX5azyZTJwsJCOZvch2TmInnOkvO9efNmOXvt2rVydnl5uZzd2dkpZ+/du1fOPn/+vJxN\\\n",
       "nsnk3UzmSUa9m8m1nQa+QABoUSAAtCgQAFoUCAAtCgSAFgUCQIsCAaBFgQDQokAAaFEgALRM1ZRJ\\\n",
       "Mj+QSCY8Dg8Phxw3yR4cHJSzyQzD/v5+OZtMg5w7d66c/eyzz8rZ5NqSmYsXL16Us4mvv/66nL1w\\\n",
       "4UI5m0yv3L9/v5zd2toqZ0dNxSTvRXIOyXGnbZ4k4QsEgBYFAkCLAgGgRYEA0KJAAGhRIAC0KBAA\\\n",
       "WhQIAC0KBIAWBQJAy1RNmSSSmYtXr16Vs2fOnBlyDkk2mYJIZk+SuY/r16+Xs9988005++WXX5az\\\n",
       "Fy9eLGd//fXXcvb27dvl7ObmZjmbTMXs7OwMya6trZWzybOeGDUdlLxDyTxJMqGUvJunwXRdDQD/\\\n",
       "GQUCQIsCAaBFgQDQokAAaFEgALQoEABaFAgALQoEgBYFAkDLVE2ZJPMDyVxCMuGRTCskMyLJnEoy\\\n",
       "rZCc76VLl8rZW7dulbPffvttOfvFF1+Usw8ePChnf/zxx3L27t275ezW1lY5++6775azN27cKGe3\\\n",
       "t7fL2eTZSaZMknfz+Pi4nE3mSUZNjoy6Z6eBLxAAWhQIAC0KBIAWBQJAiwIBoEWBANCiQABoUSAA\\\n",
       "tCgQAFoUCAAtUzVlksyTJPMDyYxIMsOQzBok15bMk5w/f76c/eijj8rZZHLkww8/LGefPHlSzv7w\\\n",
       "ww/l7Pfff1/O/vzzz+Vs8rtdvXq1nE1+t8uXL5ezyWzPs2fPhhw3mT0ZNSOSHDcx6riviy8QAFoU\\\n",
       "CAAtCgSAFgUCQIsCAaBFgQDQokAAaFEgALQoEABaFAgALVM1ZZJMFSRzCbOzs0OyiYODgyHHTe7Z\\\n",
       "Bx98UM4msxz37t0rZx8+fFjOfvfdd+VsMnuyvr5ezl65cqWcvXnzZjn78ccfl7PJtM0ff/xRzm5s\\\n",
       "bJSzyXOWZJOZoeS4b8L0ymngCwSAFgUCQIsCAaBFgQDQokAAaFEgALQoEABaFAgALQoEgBYFAkDL\\\n",
       "WztlkkjmBxYXF8vZZJ5k1LTCpUuXytnPP/+8nE2ubW1trZxNZk9+++23cnZvb6+cTX7j9957r5yd\\\n",
       "man/e257e7ucffr0aTn7119/lbOJZE4ledZHTYMkEynJ72bKBAD+p0AAaFIgALQoEABaFAgALQoE\\\n",
       "gBYFAkCLAgGgRYEA0KJAAGiZqimT4+PjcjaZFBg1MbG8vFzOJlMb58+fL2eTeZLLly+Xs8m1PXz4\\\n",
       "sJy9fft2Ofv333+Xs8n5JlMbyXGXlpbK2WSe5O7du+VsMiuTzH3MzdX/1CTv8ezsbDmbnG8imVBK\\\n",
       "ru008AUCQIsCAaBFgQDQokAAaFEgALQoEABaFAgALQoEgBYFAkCLAgGgZaqmTJJ5kmR+4PDwsJxN\\\n",
       "Zi4SCwsL5ezVq1fL2WQKIplTuXPnTjn7008/lbOPHz8uZyeTSTmbTG0kky4rKyvl7P7+fjm7u7tb\\\n",
       "zib3LJn7GPW+JdNBo84hOW5yz5JrOw2m62oA+M8oEABaFAgALQoEgBYFAkCLAgGgRYEA0KJAAGhR\\\n",
       "IAC0KBAAWqZqyiSZKjg+Ph54JjWLi4vl7NLSUjm7urpazp49e7acTSZHfvnll3L2wYMH5Wwy95HM\\\n",
       "vywvL5ezyezJO++8U84eHR2Vs48ePSpnnzx5Us4mEx5JdtT7lkzxJJK/JcmUyZvwd+ff5AsEgBYF\\\n",
       "AkCLAgGgRYEA0KJAAGhRIAC0KBAAWhQIAC0KBIAWBQJAy1RNmSTm5+fL2WRiIplWODg4KGdnZupd\\\n",
       "v7e3V87euXOnnH3x4kU5u7m5Wc5ubW2Vs8k8STI5kvzGk8mknP3999/L2eT+JtlEMsuRvEPJ7Mmo\\\n",
       "SaLkHJL3ODnf5Jk8DXyBANCiQABoUSAAtCgQAFoUCAAtCgSAFgUCQIsCAaBFgQDQokAAaJmq/1c/\\\n",
       "atYgkRw3mTVIJjx2d3fL2WSG4fDwcEg2mY1I7lky/5JMmayvr5ezZ8+eLWefPXtWzu7v75ezyfTK\\\n",
       "8vJyOZvcs5WVlXI2eXaS6ZU3wai/O6+LLxAAWhQIAC0KBIAWBQJAiwIBoEWBANCiQABoUSAAtCgQ\\\n",
       "AFoUCAAtUzVlMmqWI5naSM4hmV5J5iiSeYf5+flyNpnPGDXZkPwWyTmMmj1JZmWSZzKZHHn//ffL\\\n",
       "2XPnzpWzyaxMcm3b29vlbHJ/k98tySbPzrR5e68cgH9EgQDQokAAaFEgALQoEABaFAgALQoEgBYF\\\n",
       "AkCLAgGgRYEA0DJVUybJpEAy4ZHMkyTZlZWVcnZpaamcvXDhQjmbTDYkMxfJ1EYyvZLMvyTZ5D6M\\\n",
       "mmm5cuVKOXv9+vVy9uLFi+Xs6upqObu5uVnOPn/+vJx9+fJlOZv8xsnfh2SmJXkekr8Pp4EvEABa\\\n",
       "FAgALQoEgBYFAkCLAgGgRYEA0KJAAGhRIAC0KBAAWhQIAC1TNWWSSCYQklmDJDtqaiM57uLiYjn7\\\n",
       "6aeflrOTyaSc3dnZGZJNJjH29vbK2WRW5ubNm+XsV199Vc4msyfJBM36+no5++DBg3L26dOn5ezh\\\n",
       "4WE5m0jei0QyT5LM9pwGvkAAaFEgALQoEABaFAgALQoEgBYFAkCLAgGgRYEA0KJAAGhRIAC0TNWU\\\n",
       "ycnJSTmbzA/Mzs6Ws8lcQnK+yQRCMrVx8eLFcnZ5ebmc3djYKGe3t7fL2WTSJZlpSaZXPvnkk3L2\\\n",
       "xo0b5eytW7fK2eTZSa4t+S0eP348JLu5uVnOJu9x8l4k73GSTc73NPAFAkCLAgGgRYEA0KJAAGhR\\\n",
       "IAC0KBAAWhQIAC0KBIAWBQJAiwIBoOWtnTKZn58fcg7JVMHe3l45m5zv8+fPy9lEMmXy5MmTcnZr\\\n",
       "a6ucnZurP7LJcRcWFoZkE8n5rq2tlbPJDM79+/fL2UePHpWzL168KGcPDw/L2eS3SI6bzBclf3eS\\\n",
       "7GngCwSAFgUCQIsCAaBFgQDQokAAaFEgALQoEABaFAgALQoEgBYFAkDLVE2ZJJJ5h5mZMT076hy2\\\n",
       "t7fL2WTeYXd3t5wdNdNydHRUzu7v75ezyXTF06dPy9nLly+Xs7dv3y5nnz17Vs7++eef5Wzy7Gxu\\\n",
       "bpazk8mknE1+i+S9SGaGjo+Ph2RH/S15XabragD4zygQAFoUCAAtCgSAFgUCQIsCAaBFgQDQokAA\\\n",
       "aFEgALQoEABa3topk2R+YNTkSDKtsLGxUc4mUxDJxEQyXbGwsFDOJhMpyf1NJlKS4yYTKXfv3i1n\\\n",
       "d3Z2ytmtra1yNvndkvuQzOAkz0PyXiROTk6GZKdtniTx9l45AP+IAgGgRYEA0KJAAGhRIAC0KBAA\\\n",
       "WhQIAC0KBIAWBQJAiwIBoGWqpkySCY9kqiCZVkiyyTmsrq4OOYdklmN5ebmcPTo6KmeTyZFkPiOx\\\n",
       "tLRUzib3LJkcSWZlkimexcXFcjb53ZLnIZE8v8nMUPK+zc3V/zQmx03O9zTwBQJAiwIBoEWBANCi\\\n",
       "QABoUSAAtCgQAFoUCAAtCgSAFgUCQIsCAaBlqqZMkkmBmZkx3ZlMTCSSCYRkjiI53zdhsiGZq0l+\\\n",
       "42RyJLm/yfnu7u4OOW4yDXL27NlyNpmVGTXxM0pyDsk7lNyH08AXCAAtCgSAFgUCQIsCAaBFgQDQ\\\n",
       "okAAaFEgALQoEABaFAgALQoEgJapmjIZNZ8x6rijJhCSiYlk7mMymZSzydRGMg2S3Ifkd0t+i+Ta\\\n",
       "EisrK0OOm5xv8uwk93fUBM0oo56dubmp+pPrCwSAHgUCQIsCAaBFgQDQokAAaFEgALQoEABaFAgA\\\n",
       "LQoEgBYFAkDLmZOTk5PXfRIAnD6+QABoUSAAtCgQAFoUCAAtCgSAFgUCQIsCAaBFgQDQokAAaFEg\\\n",
       "ALQoEABaFAgALQoEgBYFAkCLAgGgRYEA0KJAAGhRIAC0KBAAWhQIAC0KBIAWBQJAiwIBoEWBANCi\\\n",
       "QABoUSAAtCgQAFoUCAAtCgSAFgUCQIsCAaBFgQDQokAAaFEgALQoEABaFAgALQoEgBYFAkCLAgGg\\\n",
       "RYEA0KJAAGhRIAC0KBAAWv4PXp+Cr2FUjJwAAAAASUVORK5CYII=\\\n",
       "\"\n",
       "  frames[1] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAPP0lEQVR4nO3cS2tdZRsGYE2acw/UVqtNtCBSwRM40Wl/gaBj/2edOCo4kyIW\\\n",
       "8VCxiq1io2maNMed9PsJ3/Pc+Jpkc13jm8W71147d9bkfvH58+fPXwCAppmTPgAAZ5MCASCiQACI\\\n",
       "KBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCi\\\n",
       "QACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgC\\\n",
       "ASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACInDvpA/yb\\\n",
       "1tbWytmZmXp3vvjii+Xs8fHxkOs+f/58yHU7Zmdny9nOeUdlR31vnWdn1HU7Oveso3Peo6OjIWc4\\\n",
       "DTrPWSf766+/Jsf5T3kDASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACITNWUyaip\\\n",
       "jc4cRecMnXmH0zCn0rlu5/5OJpNy9ty5+iPbub+nYSqmY9Q8yajfxWmYdBk1HTTquzgLvIEAEFEg\\\n",
       "AEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAESmasqkozM/0JlWGDWfMeq8o84warqiM0fR\\\n",
       "mT0ZdR860zajpjY6z+SoZ71zH07D89vROW/nd3EWeAMBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAi\\\n",
       "CgSAiAIBIKJAAIhM1ZTJqKmCUfMDnemKjs596Jxh1DzJqOmKjlFzFJ3sqM826jkbNUEz6j6MMm3z\\\n",
       "JB3eQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIlM1ZdLRmUsYNXPRmXfonKGj\\\n",
       "c965ubly9ujoKDnO/9X53s6dqz/ene9ifn6+nO3ch9NwzzpGPeud8476HXeyne9t1KzMSfEGAkBE\\\n",
       "gQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQmaopk1GzBh2dqYJR8w4dnTN0JhtmZ2fL\\\n",
       "2c5n61z32bNn5ezq6mo5O2oipTMV07lnneseHh6Ws48fPy5nd3Z2ytnORMqo56xzho5Rv+OT4g0E\\\n",
       "gIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASAyVVMmZ82o6ZXOdTvZUbMne3t75ezK\\\n",
       "yko5+/bbb5ezr732Wjl77dq1cvavv/4qZzv398KFC+Vs556tr6+Xs53Zk8533DFqBmfU5MioiZST\\\n",
       "4g0EgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASAyVVMmnSmIURMeo4yaVuhMpHR0\\\n",
       "7tnFixfL2ffff7+c/eSTT8rZy5cvl7MPHjwoZ7e2tsrZzjzJ8vJyObu0tFTOdu7DxsZGOTuZTMrZ\\\n",
       "p0+flrO7u7vlbGdGpDN70vlso37HJ8UbCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAAR\\\n",
       "BQJAZKqmTDpGzZ6chjOMml7pTDbMz8+Xsx988EE5+/nnn5ezn332WTn79ddfl7NffvllOduZPTk8\\\n",
       "PCxn33333XL20qVL5Wxn2ubKlSvlbGf25PHjx+Vs51nvfLbOs34apo5OijcQACIKBICIAgEgokAA\\\n",
       "iCgQACIKBICIAgEgokAAiCgQACIKBIDIVE2ZHB8fl7OjJhA6kyOjJlI61+18ttnZ2XJ2ZWWlnP3o\\\n",
       "o4/K2ffee6+cvX//fjl7+/btcvaLL74oZ3d2dsrZzjO5sLBQzr7xxhvl7JMnT8rZzmfb3NwsZ0f9\\\n",
       "Lo6OjoZc9zTMDJ0UbyAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIAJGpmjLpTG10\\\n",
       "Zk9OwzxJZwKhc4aDg4Nydn9/v5ztTI50pkx2d3fL2a+++qqcvXPnTjnbmUi5cuVKOfvhhx+Ws++8\\\n",
       "8045Ozc3V852nrPO7MmoOaBRv4vO35LOGTp/d84CbyAARBQIABEFAkBEgQAQUSAARBQIABEFAkBE\\\n",
       "gQAQUSAARBQIAJGpmjIZNTlyGuZJOtMKR0dHyXH+r6tXr5azN2/eLGcPDw/L2W+//bacvX37djl7\\\n",
       "7969cnZtba2c7UyZdOZfVldXy9mHDx+Ws48ePSpn//7773J2Z2ennF1aWipnO1M8p2G+aNTfkpPi\\\n",
       "DQSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIDJVUyadaZBOdmam3rOd646aHOmc\\\n",
       "4dy5+iNw/fr1cnZxcbGc3djYKGe///77cva7774rZ7e2tsrZzhzFxx9/XM7euHGjnP3xxx/L2bt3\\\n",
       "75az//zzTzk7Pz9fznaes062M0/Smczp/IY6Z+hc9yzwBgJARIEAEFEgAEQUCAARBQJARIEAEFEg\\\n",
       "AEQUCAARBQJARIEAEJmqKZPOpEBHZ7qiM1UwOztbzk4mk3K2MwWxvLxczi4tLZWzu7u75ewPP/xQ\\\n",
       "zv7555/l7IULF8rZznf80ksvlbM3b94sZ998881y9sGDB+XswcHBkGxnymRlZaWc3d/fL2c7Ot/x\\\n",
       "qN9857pngTcQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBIDIVE2ZjJofGKUzvbK4\\\n",
       "uDgku7e3V85ubW2Vsz/99FM5u7q6Ws4+fvy4nO1MunTmSW7dulXOfvrpp+Xs1atXy9lvvvmmnN3c\\\n",
       "3CxnDw8Py9nOFE/nmTw6OipnZ2bq/wN3/j50rttxGv7u/Ju8gQAQUSAARBQIABEFAkBEgQAQUSAA\\\n",
       "RBQIABEFAkBEgQAQUSAARKZqymSUURMpnSmIhYWFcnZlZaWc7fj999/L2fPnz5ezGxsb5WxnnqRz\\\n",
       "fy9dulTOrq2tlbP7+/vl7M8//1zOPnr0qJztTIMsLS2Vs535l47O9EpH59np/OZHZc8CbyAARBQI\\\n",
       "ABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIAJGpmjLpTFd0JkdGzQ90phUuXLgw5LqHh4fl\\\n",
       "7NbWVjm7t7c3JNvRuQ+dOZW7d++Ws+vr6+Vsx71798rZzv29ePFiOTszU///s/N763xvHZPJZMgZ\\\n",
       "OlMxnXt2FkzXpwHgP6NAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIhM1ZTJ8fHxSR+h\\\n",
       "NYEwPz9fznZmWjrm5ubK2aWlpSFnODg4KGc7UxCdmZbO/b1z5045e/369XJ2e3u7nP3jjz/K2c4U\\\n",
       "z+7ubjm7ublZzi4sLJSznemVznd8GuZJOpMuZ4E3EAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJA\\\n",
       "AIgoEAAiCgSAyFRNmXTmKDrzGZ35gc4EQue6nTmKzn3oZDtTMZ3zdqYgOtmdnZ1ytjOJMZlMytnO\\\n",
       "c9Y5w/7+fjnbmavpPJOd6ZXOPesY9RvqGHXds8AbCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEg\\\n",
       "AEQUCAARBQJAZKqmTDpTG+fO1T96Z6pg1OzJ3t5eOTs/P1/OdmYulpaWytnOLEfne+tct/PZFhcX\\\n",
       "y9nOeTtu3LhRzq6urpaznedhfX29nO3Mk3Se38533Jm26fzeqPEGAkBEgQAQUSAARBQIABEFAkBE\\\n",
       "gQAQUSAARBQIABEFAkBEgQAQmaopk86swf7+fjnbmcTozJ4cHByUs53P1sl2dKZMOjr3oXN/O9nO\\\n",
       "PEnnutevXy9nb926Vc6+/vrr5ezTp0/L2fv375ezv/zySznbmT3p/DZHzeDMzs6Ws535os6zcxZ4\\\n",
       "AwEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiEzVlMnR0VE5e+5c/aN3pgo6Ouft\\\n",
       "TEEsLCyUs53Jhvn5+SHXffLkSTk7ap6kc97Os3Pp0qVy9q233hpyhu3t7XJ2ZWWlnL148WI5u7Oz\\\n",
       "U852nt/O76Jzz6ZtcmQUbyAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIAJGpmjKZ\\\n",
       "man34agJhFE6sye7u7vl7Msvv1zOdu7vwcHBkOzS0tKQ63amKzrZq1evlrPXrl0rZzvzJJ1Jl47D\\\n",
       "w8NytjMHtLm5Wc52Jmg631vnvJ37O2oW6aR4AwEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICI\\\n",
       "AgEgokAAiJz8Rse/qDP30ZnlGHXdzrRCR2fCozMb0TlvZ+ZiZWWlnO3MyiwvL5eznc/26quvlrOv\\\n",
       "vPJKOfvbb7+Vs+vr6+XsgwcPytnOs9OZzNnY2ChnO3Mfo+ZJTsN1zwJvIABEFAgAEQUCQESBABBR\\\n",
       "IABEFAgAEQUCQESBABBRIABEFAgAkamaMunMXEwmk3K2M1VwfHw85LrPnj0rZzs60wqdSZfO/e1k\\\n",
       "O7Mnly9fHnLdtbW1crYz6XLv3r1y9uHDh+XsqGenM6fSeXY62bm5uXK2813Mzs6Ws6ZMAKBJgQAQ\\\n",
       "USAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQmaopk1EzAZ15kpmZeid3zru8vFzO7u3tlbOd\\\n",
       "2YiFhYUhZzh//nw525mYmJ+fL2c796EzI9K5Dzs7O+Vs57ydiZ/t7e1ytvPZOjMio763zm9z1DyJ\\\n",
       "KRMAeEGBABBSIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABCZqimTjs4kxqhZg47JZFLOdqYg\\\n",
       "Ovb398vZzj179uxZOdu5D52pjYODg3J2cXGxnN3c3CxnO99b57voTJl0fhed6ZW5ublytqPznHWM\\\n",
       "mifpzKmcBdP1aQD4zygQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACJTNWVyfHxcznYm\\\n",
       "BTrX7ehctzMx0ZlWGDUF0bnu4eHhkOtub2+Xs537u7W1Vc6OmifpPL+d+3t0dFTOdu5Zx6gZkdNw\\\n",
       "BlMmAPCCAgEgpEAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEg8uLzUVsAAEw1byAARBQIABEF\\\n",
       "AkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQI\\\n",
       "ABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAA\\\n",
       "RBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkDkf2lLW6aXlPMnAAAAAElFTkSu\\\n",
       "QmCC\\\n",
       "\"\n",
       "  frames[2] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAPk0lEQVR4nO3cS2+V5fsFYCs9UGlFEA2gCR7AFB0YNTHGRE1MjEanfhQ/kHPj\\\n",
       "yIFzBx7iQAccNKCopBJQsAi0pcffR/jf9/r7CN1e13jlzbPf991d2YOuqd3d3d0HAKDpwXt9AAD2\\\n",
       "JgUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABE\\\n",
       "FAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBR\\\n",
       "IABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESB\\\n",
       "ABCZvtcH+CedOnWqnH3wQd25F01NTQ257vb29pDrduzbt6+c7dyHra2t5Dj/p855O/d3kr+bnc92\\\n",
       "/vz5gSf5Z0zukwJgKAUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQGSipkw60wq7u7vl\\\n",
       "7M7Ozj0/wyiT/NlGzZOMmvAYNfex157bKKNmcDr3bNLur18gAEQUCAARBQJARIEAEFEgAEQUCAAR\\\n",
       "BQJARIEAEFEgAEQUCACRiZoy6ehMeHRmI0ZNpHTOMOq6o6ZBOmfozFF0rjvq/s7Ozpaznfvbec86\\\n",
       "92zUTEvnup3zjpoGGTUrY8oEAB5QIACEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEJmrK\\\n",
       "pDMT0JlWGDUb0ZlA6Bh13VFn6NyzjpmZmXK284y3trbK2c7sSeed3NjYKGdHGfW92GsTP6OuuxdM\\\n",
       "1qcB4F+jQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACITNSUSUdnhmHUdUdNeGxvbw+5\\\n",
       "7qgZhs49G5XtWFhYKGc7kyOdiZROdnq6/jUflV1dXS1n74cZkVGTRKO+8/eKXyAARBQIABEFAkBE\\\n",
       "gQAQUSAARBQIABEFAkBEgQAQUSAARBQIAJGJmjIZNWswyqjZk/vhs3V0JjE60yCd7DPPPFPOHj16\\\n",
       "tJztTI7cunWrnF1fXy9nO5/tyJEj5ezFixfL2UuXLpWzN27cKGfn5+fL2VHTNh33wxn+SXvrLw0A\\\n",
       "9w0FAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkBkoqZM7ocJj87kyKhZg/vhDJ1ncffu\\\n",
       "3XJ2bm6unH3jjTfK2aWlpXL29OnT5ez58+fL2cuXL5ezTz/9dDn76quvlrOLi4vl7KefflrOXrly\\\n",
       "pZztvDvb29tDrns/fDf3gnv/FxeAPUmBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABCZ\\\n",
       "qCmTUe6HaZDOdTvnHZXd2toqZzuf7cknnyxnP/zww3L29ddfL2e/+OKLcnZlZaWcPXHiRDl75MiR\\\n",
       "cvbw4cPl7PPPP1/Ofvnll+XswsJCOXvgwIFytjODM2rKpJPtTK/sBX6BABBRIABEFAgAEQUCQESB\\\n",
       "ABBRIABEFAgAEQUCQESBABBRIABETJkUdKYKdnZ2ytnOtEJH57ydM6yvr5ez09P1V+vkyZPl7Dvv\\\n",
       "vFPOPvfcc+XsN998U85+/PHH5WxnyqRzz1599dVy9s033yxn//rrr3J2cXGxnN2/f38525kn6eh8\\\n",
       "NzvZffv2DcnuBX6BABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEJmrKpDM/0NGZ\\\n",
       "Hxg1T9K5buc+bG1tlbOdqY2FhYVytjPLsbS0VM5+9tln5eznn39ezp47d66c7dzfq1evlrOd9+GD\\\n",
       "Dz4oZy9fvlzO/vLLL0OuO+qdHPX3YXt7u5w1ZQIADygQAEIKBICIAgEgokAAiCgQACIKBICIAgEg\\\n",
       "okAAiCgQACITNWUyakZkd3d3yHU75+2cYWNjY8gZNjc3y9lXXnmlnH3//ffL2d9//72c7UyZ/Pzz\\\n",
       "z+Xs7du3y9m7d++Ws++88045+9Zbb5WzncmRznk779mxY8fK2Tt37pSzHaPmgDrzJKP+ltwrfoEA\\\n",
       "EFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQmaspklM6sQcf0dP32d87QuW5nhuHx\\\n",
       "xx8vZ1966aVydnZ2tpxdW1srZzuTGJ17duLEiXL24YcfLmc/+uijcvbll18uZz/55JNy9rfffitn\\\n",
       "//rrr3L20KFD5eyzzz5bzi4vL5ez6+vr5eyomaFJ4xcIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQ\\\n",
       "USAARBQIABEFAkBkoqZMpqamytnt7e1ytjNr0DnD6upqOduZxDh27Fg5u3///nL26NGj5ez8/Hw5\\\n",
       "u7KyUs7++eef5WxHZ2rj9u3b5ez7779fzr755pvlbGdy5Kuvvipnb9y4Uc6+9tpr5WxniufixYvl\\\n",
       "bOd96EyZdL7HpkwAoEmBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABCZqCmTzqTAqHmS\\\n",
       "zc3NcnZ6un77Z2dny9knn3yynH3kkUfK2c55OxMTFy5cKGfX1tbK2aWlpXK289w6Z+hMpNy8ebOc\\\n",
       "/frrr8vZK1eulLOdiZ8DBw6Us/v27StnO+/ZqOzW1lY52/lskzZ74hcIABEFAkBEgQAQUSAARBQI\\\n",
       "ABEFAkBEgQAQUSAARBQIABEFAkBkoqZMRunMO4yaJzl+/Hg5e/To0XK2M9lw+fLlcrYzFTM/Pz/k\\\n",
       "uqdOnSpnr1+/Xs52Zk8ef/zxIdnOBM21a9eGXHdlZaWcPXLkSDk7Sue5deZJOjrv714wWZ8GgH+N\\\n",
       "AgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgYsrkHzY1NVXO7t+/v5w9ePBgOTs3N1fO\\\n",
       "3rhxo5z95ZdfytnOFEQn+9RTT5WznemK27dvl7OdZ9E5w5kzZ8rZK1eulLOLi4vlbGe2pzNlcuvW\\\n",
       "rXK2M71y8+bNcrYzM9S5D515ks519wK/QACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACI\\\n",
       "KBAAIhM1ZdKZEdnd3R2S7djZ2SlnO/MkDz30UDnbmdq4ePFiOTs/P1/O3r17t5y9cOFCOduZ8OhM\\\n",
       "bXScO3eunH377beHXLcz4XH9+vVy9tdffy1nZ2dny9k//vijnN3Y2ChnO5MjnWxHZ7ZnL/ALBICI\\\n",
       "AgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgMlFTJp3Jkc7sSWd+oJPtzCV0rnvnzp1y\\\n",
       "9vLly+VsZ55kZmamnF1fXy9nO894dXW1nO1MYty8ebOcXVlZKWc7z61zf9fW1srZjs67s7W1Vc52\\\n",
       "3ofO93jUPMl/mTsKQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABCZqCmTzqxBZ1qh\\\n",
       "Y2dnp5w9dOjQkDNsbm6Ws51JjM6MSOe6HZ3rduZJHnrooXK2Mw3SmT05fPhwOXv8+PFy9qmnnipn\\\n",
       "v/vuu3J2eXm5nF1cXCxnO0ZNmXTe9U520vgFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEF\\\n",
       "AkBEgQAQmagpk1FTG51JjOnp+i3tzKncuXOnnJ2bmytnOxMTTzzxRDm7vb1dznamVzpTMZ3pis4k\\\n",
       "xsLCQjn722+/lbNHjx4tZ999991y9tKlS+Xs2bNny9mOznMbNa9zP8yTTNrsiV8gAEQUCAARBQJA\\\n",
       "RIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCACRiZoy6ejMiIy67vr6+pDsvn37ytkDBw6Usy+88EI5\\\n",
       "u7a2Vs52pjb+/vvvcnZ2drac7UyvdGZljh8/Xs6+99575ezJkyfL2Z9++qmcXV1dLWc7UzHz8/Pl\\\n",
       "bOdZdCZoOnMqoyZzJs1/95MD8P+iQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACITNSU\\\n",
       "SWfWoDP30Zkq6MwwjMoeOnSonD1y5Eg5u7CwUM52zru5uVnO3r17d8gZOhMenbmazvzL6dOny9nO\\\n",
       "Pfv+++/L2c5My8GDB8vZznPrfDc7z/i/PDkyijsKQESBABBRIABEFAgAEQUCQESBABBRIABEFAgA\\\n",
       "EQUCQESBABCZqCmT3d3dcnZnZ6ec7UwgTE/Xb2lnEmNjY6Oc/fXXX8vZF198sZx97bXXytmrV6+W\\\n",
       "sz/88EM525m5WFlZKWf3799fznZ0pkxOnjxZzn777bflbGeepDM5MjMzU87Ozs6Ws6PmSTpTR6NM\\\n",
       "2pzKZH0aAP41CgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAyERNmYyaJ+nozCV0pkyW\\\n",
       "l5eHnOHChQvlbGfuozOn0nkW6+vr5eyjjz5azl67dq2cXVpaKmdPnTpVzp49e7acPXPmTDm7trZW\\\n",
       "zh48eLCc7eg8t85czajvfOcMoyaU9gK/QACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACI\\\n",
       "KBAAIlO7nf/Dv891JiZGfezOVEHnDJ15ko7OdEVnymRzc7Oc3djYKGcfe+yxcnZ6esxSzxNPPFHO\\\n",
       "njhxopztzH38+OOP5Wxn9qQzr9OZBuk8i1FzH53rdrKjZk86z/he8QsEgIgCASCiQACIKBAAIgoE\\\n",
       "gIgCASCiQACIKBAAIgoEgIgCASAyZuthDxg1l9CZNdje3h5y3dXV1XL2+vXrQ87QmTKZnZ0tZzuz\\\n",
       "JwsLC+XszMxMOdt5d5aXl8vZjt9//72cHXV/O/MkoyZSRk0SjZpeGfV3517xCwSAiAIBIKJAAIgo\\\n",
       "EAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIDJRUyadWYNRUwVTU1Pl7KjZk/n5+XK289lGzZOsra2V\\\n",
       "s51JjM4sR+fd6Tzjzv0dNeHReXc634tR5x01DdI57/0wdbQX+AUCQESBABBRIABEFAgAEQUCQESB\\\n",
       "ABBRIABEFAgAEQUCQESBABCZqCmTjs60QseoGYbOBEJnamNmZqacnZubG3KGUTMinemVzn3oTKR0\\\n",
       "Jl06OvehM0/S0Xl/Rz3jzjxJ57qd+ZeOUc/iXvELBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQ\\\n",
       "ACIKBICIAgEgMrU7atMDgInmFwgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESB\\\n",
       "ABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUC\\\n",
       "QESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgA\\\n",
       "EQUCQESBABD5H3IOCqxaLk9uAAAAAElFTkSuQmCC\\\n",
       "\"\n",
       "  frames[3] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAQBklEQVR4nO3cS29VBbgG4AO97N6kpVCotJYgBBAwYQAmGg3GiSN17A/wdzk1\\\n",
       "DryMnDjROCDxEqMEUkgDqEARaLm0pfeen3C+7zssu/fmecZvVtZea+39dg367tnZ2dn5HwBI2rvb\\\n",
       "JwBAZ1IgAJQoEABKFAgAJQoEgBIFAkCJAgGgRIEAUKJAAChRIACUKBAAShQIACUKBIASBQJAiQIB\\\n",
       "oESBAFCiQAAoUSAAlCgQAEoUCAAlCgSAEgUCQIkCAaBEgQBQokAAKFEgAJQoEABKFAgAJQoEgBIF\\\n",
       "AkCJAgGgRIEAUKJAAChRIACUKBAAShQIACUKBIASBQJAiQIBoESBAFCiQAAoUSAAlCgQAEoUCAAl\\\n",
       "CgSAEgUCQIkCAaCkd7dP4EU6duxYONvT09PIOezs7ISze/bsaeQcMtrhfDPHbep8mzru9vZ2OJvR\\\n",
       "1GfL2Ls3/vfn5uZmOJv5bnba85DJ3rhxI5zdLd5AAChRIACUKBAAShQIACUKBIASBQJAiQIBoESB\\\n",
       "AFCiQAAoUSAAlHTVlEmnzZN02oxIO8xnNCXz2TITHhmZuY+M3t741zxz39rhHjf1/Ga0w3XYLd5A\\\n",
       "AChRIACUKBAAShQIACUKBIASBQJAiQIBoESBAFCiQAAoUSAAlHTVlElmqmB7e7uR43baXEJmlqMd\\\n",
       "JhuauseZ65CZHMkcN5PNXIemJn7W1tbC2cycSlOammlp6jvfCbyBAFCiQAAoUSAAlCgQAEoUCAAl\\\n",
       "CgSAEgUCQIkCAaBEgQBQokAAKNn9fYEXqKn5gUy2qbmPpuYSmpp0aYfZiKZmRDJarVY4m5lI2djY\\\n",
       "CGcz12x9fT2czUykdNo0SOYctra2wtmmnrPd0l2fBoD/jAIBoESBAFCiQAAoUSAAlCgQAEoUCAAl\\\n",
       "CgSAEgUCQIkCAaCkq6ZMmtLUDEM7HDczZZKZrshMNjR1DplZjsw0yODgYDibuW99fX3h7NraWjib\\\n",
       "ub4Z7TA5kpl/yTw7mc+WOW638QYCQIkCAaBEgQBQokAAKFEgAJQoEABKFAgAJQoEgBIFAkCJAgGg\\\n",
       "pKumTDITHhlNzYg0NWXSlMw5ZCYmWq1WI+fQ2xt/vMfHx8PZY8eOhbMnT54MZ5eXl8PZubm5cDYz\\\n",
       "tTE8PBzO/v333+Hs/Px8OJuZoMnc46a+xy8zbyAAlCgQAEoUCAAlCgSAEgUCQIkCAaBEgQBQokAA\\\n",
       "KFEgAJQoEABKumrKpB3mPjLaYSIlMwWRkZknycyebG1thbNvvfVWOHvq1Klw9ty5c+HszMxMODs6\\\n",
       "OhrOXr16NZx98uRJODsxMRHOfv/99+Hsn3/+Gc7eu3cvnN3Y2AhnefG8gQBQokAAKFEgAJQoEABK\\\n",
       "FAgAJQoEgBIFAkCJAgGgRIEAUKJAACjpqimTpjQ1OdLNx83Mk2RkpkE++eSTcPbNN98MZzMTHktL\\\n",
       "S+Hs2bNnw9lr166Fs6+99lo4OzY2Fs5evHgxnM1M0IyMjISz169fD2ebeiYz36Fu4w0EgBIFAkCJ\\\n",
       "AgGgRIEAUKJAAChRIACUKBAAShQIACUKBIASBQJASVdNmTQ14dHUVEFTx81ch4z19fVwdmhoKJy9\\\n",
       "cOFCOHvp0qVw9vXXXw9nf/jhh3D2yy+/DGczMyKZ487Pz4ezn376aTh79OjRcHZqaiqcPX78eDg7\\\n",
       "NzcXzmY09b1o6ridwBsIACUKBIASBQJAiQIBoESBAFCiQAAoUSAAlCgQAEoUCAAlCgSAkq6aMmlq\\\n",
       "nqQdpgp6enrC2e3t7XA2M0+yd2/8743R0dFw9sMPPwxnR0ZGwtnPP/88nL18+XI4m5kRWVhYCGcX\\\n",
       "FxfD2eXl5XD2wYMH4ezz58/D2Y2NjXD2/v37jRx3a2srnG2HSaLMd6gTdNenAeA/o0AAKFEgAJQo\\\n",
       "EABKFAgAJQoEgBIFAkCJAgGgRIEAUKJAACjpqimTjMw8SVNTJpnJkc3NzUaOOzQ0FM729sYfl5Mn\\\n",
       "TzZy3NnZ2XD2iy++CGefPn0azp44cSKczUzFHD9+PJydnJwMZzNzKr///nsj55B5zgYGBsLZjMzs\\\n",
       "SWZyJPP70NScym7xBgJAiQIBoESBAFCiQAAoUSAAlCgQAEoUCAAlCgSAEgUCQIkCAaDElElAZn4g\\\n",
       "k+3v7w9nM/MkU1NT4ez4+Hgj5zAyMhLO3rp1K5z98ccfGzmHI0eOhLMzMzPh7IEDB8LZjz/+OJyd\\\n",
       "np4OZ7/99ttw9tdffw1nz5w5E85mvm9jY2PhbE9PTzibkfkeZyZSMrM9ncAbCAAlCgSAEgUCQIkC\\\n",
       "AaBEgQBQokAAKFEgAJQoEABKFAgAJQoEgJKu+r/6zFxCZpYjc9zMVEHmHE6dOhXOXrp0KZxttVrh\\\n",
       "7MrKSjib+WxHjx5tJNvX1xfOnj9/PpzNTFdcvHgxnH3//ffD2Tt37oSzN2/eDGfn5ubC2XPnzoWz\\\n",
       "mfmX2dnZcLYdNDWn0gm8gQBQokAAKFEgAJQoEABKFAgAJQoEgBIFAkCJAgGgRIEAUKJAACjpqimT\\\n",
       "zHxGRmbKJOPQoUPh7DvvvBPOfvTRR+Hs/fv3w9lnz56Fs6urq+HssWPHGjnu/v37w9k33ngjnL11\\\n",
       "61Y4u7i4GM7evXs3nP3uu+/C2du3b4ezmVmOffv2hbObm5vhbGYqJpPNyHznd3Z2wtmmfqN2izcQ\\\n",
       "AEoUCAAlCgSAEgUCQIkCAaBEgQBQokAAKFEgAJQoEABKFAgAJV01ZdLU/EBm3iEzn/Hqq6+Gs2fO\\\n",
       "nAlnp6enw9mBgYFw9uuvvw5nM9MVmYmUmzdvhrOZ+3b58uVwNjP/srS0FM5mZi4yEymZcxgeHg5n\\\n",
       "//nnn3B2ZmYmnH3+/Hk4m3nOenvjP3eZe5H53dm7t7v+Zu+uTwPAf0aBAFCiQAAoUSAAlCgQAEoU\\\n",
       "CAAlCgSAEgUCQIkCAaBEgQBQ0lVTJpl5koytra1wNjOXMDk5Gc4eOnQonM1MV3zzzTfh7FdffRXO\\\n",
       "ZiYmxsfHw9m1tbVw9rfffgtnM9MVKysr4WxmKiYz0/L06dNwdmhoKJzNfIcykyNXrlwJZ+fn58PZ\\\n",
       "zFxNO2jqN2q3eAMBoESBAFCiQAAoUSAAlCgQAEoUCAAlCgSAEgUCQIkCAaBEgQBQ0lVTJnv27Gkk\\\n",
       "m9HX1xfOZuY+7t69G84uLy+Hs3/88Uc4m5kGGR0dDWcfPnwYzj569CicnZiYCGdXV1fD2Y2NjXA2\\\n",
       "4+DBg+Fsq9UKZw8fPhzOLi4uhrOZe5GZoMlMpDQ1DdLU70O38QYCQIkCAaBEgQBQokAAKFEgAJQo\\\n",
       "EABKFAgAJQoEgBIFAkCJAgGgpKumTDKzBpmpgu3t7XD2wIED4Wxvb/zy379/P5x98OBBOPvTTz+F\\\n",
       "s/v37w9nm5qCyJxDZiqmv7+/cjovVGaCZnp6OpydmZkJZ/ft2xfOZqZM/vrrr3B2fX09nO3p6Qln\\\n",
       "m5L53dm7t7v+Zu+uTwPAf0aBAFCiQAAoUSAAlCgQAEoUCAAlCgSAEgUCQIkCAaBEgQBQ0lVTJpmZ\\\n",
       "gMzMRavVCmcXFxfD2ePHj4ezmbmElZWVcDYzvfLw4cNwdmJiIpzN3IvMdEXmmmWmTLa2tsLZpmY5\\\n",
       "Tp8+Hc5euHAhnM1M28zOzoazmXuc+R43NV+U0dRxO4E3EABKFAgAJQoEgBIFAkCJAgGgRIEAUKJA\\\n",
       "AChRIACUKBAAShQIACVdNWWSkZknyUxXDA0NhbNLS0vhbGZGJHO+meswPT0dzj558iSczUxXZLIZ\\\n",
       "mamNwcHBcPbx48fh7NTUVDh7/vz5cDYz97GwsBDOZiZzMs9kU9MgTc3gvMy8gQBQokAAKFEgAJQo\\\n",
       "EABKFAgAJQoEgBIFAkCJAgGgRIEAUKJAACh5aadMVldXw9nM3Mfi4mLldP5Pw8PD4eyRI0fC2cOH\\\n",
       "D4ezIyMj4WxmymRubi6cXVtbC2dHR0fD2e3t7XA2M/eRmfA4ffp0ODsxMRHOXr16NZy9d+9eOJuZ\\\n",
       "lentjf/UNDVlkpknaYdz6ATeQAAoUSAAlCgQAEoUCAAlCgSAEgUCQIkCAaBEgQBQokAAKFEgAJR0\\\n",
       "1ZRJZiYgM62QmaN4/PhxOLu5uRnOjo2NhbOTk5Ph7NmzZ8PZzOzJzZs3w9nMjEjm+mauWU9PTzib\\\n",
       "uW+Dg4Ph7MmTJ8PZzIzItWvXwtmVlZVwdmBgIJxdX18PZzMzIp02DdLURMpu8QYCQIkCAaBEgQBQ\\\n",
       "okAAKFEgAJQoEABKFAgAJQoEgBIFAkCJAgGg5KWdMsnMZ7RarXA2M9mwuLgYzs7Pz4ezly9fDmff\\\n",
       "fvvtcPazzz4LZ69fvx7O9vf3h7MHDx4MZ5eXl8PZtbW1cPbevXvh7NTUVDj7wQcfhLNNfbaMzKRL\\\n",
       "ZnolI/Odb4cZkXY4hxfJGwgAJQoEgBIFAkCJAgGgRIEAUKJAAChRIACUKBAAShQIACUKBICSrpoy\\\n",
       "ycyTZKYVMpMNmamCzPnevn07nH3+/Hk4e+fOnXD2ypUr4ezCwkI4++6774azGxsb4ezExEQ4+8sv\\\n",
       "v4Sz7733Xjibec4y9/jnn38OZx89ehTOrqyshLOrq6vhbGZyJKPTpkGaug67xRsIACUKBIASBQJA\\\n",
       "iQIBoESBAFCiQAAoUSAAlCgQAEoUCAAlCgSAkj07XfS/9SdOnNjtU0jJXPqmplcmJyfD2f3794ez\\\n",
       "4+Pj4ewrr7wSzrZarUaOu7W1Fc7u27cvnP3333/D2YcPH4azs7Oz4WxmymR9fT2czdyLjKYmidrh\\\n",
       "py4zvXLjxo0Gz+TF8AYCQIkCAaBEgQBQokAAKFEgAJQoEABKFAgAJQoEgBIFAkCJAgGgpHe3T2C3\\\n",
       "ZKYrMnp6esLZzAxDJpuZmHjw4EE4m5naGBgYCGf7+/vD2d7e+CM7NDQUzmYmJjLPzsLCQjibuW9L\\\n",
       "S0vhbEZfX18jx21qtqcdziEzvdIOcyovkjcQAEoUCAAlCgSAEgUCQIkCAaBEgQBQokAAKFEgAJQo\\\n",
       "EABKFAgAJS/tlElmEqOp+YHMBEJTNjY2wtnBwcFwdnNzM5x99uxZOJsxMjISzmbmSVZXV8PZzHXI\\\n",
       "nG/mHDITKU1NujQlc30zM0PtML3SCV7eTw7A/4sCAaBEgQBQokAAKFEgAJQoEABKFAgAJQoEgBIF\\\n",
       "AkCJAgGgpKumTDIzDE3Nk2Q0NWWSOe7AwEA4m5mCyJxD5r5lJmjW1tYaOW7G8PBwOJuZ5cjMk2SO\\\n",
       "22mzHJnzzTxnmec381vS19cXznaCznpaAGgbCgSAEgUCQIkCAaBEgQBQokAAKFEgAJQoEABKFAgA\\\n",
       "JQoEgJI9O+2w6QFAx/EGAkCJAgGgRIEAUKJAAChRIACUKBAAShQIACUKBIASBQJAiQIBoESBAFCi\\\n",
       "QAAoUSAAlCgQAEoUCAAlCgSAEgUCQIkCAaBEgQBQokAAKFEgAJQoEABKFAgAJQoEgBIFAkCJAgGg\\\n",
       "RIEAUKJAAChRIACUKBAAShQIACUKBIASBQJAiQIBoESBAFCiQAAoUSAAlCgQAEoUCAAlCgSAEgUC\\\n",
       "QIkCAaBEgQBQ8r9aWuImcLc6ewAAAABJRU5ErkJggg==\\\n",
       "\"\n",
       "  frames[4] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAPh0lEQVR4nO3cyY5VhRoF4FsNRVVRVGgTezRCFJTIxMQ4ME4YOJb4Aj6Ez+JD\\\n",
       "GCcmTPQaE6PEBhtixAQlQQglCNJKUe19BP9/xX3r1OH7xis7++ymFnvAmtjc3Nz8DwA0TW71CQCw\\\n",
       "PSkQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEg\\\n",
       "okAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICI\\\n",
       "AgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIK\\\n",
       "BIDI9FafwL/ppZdeKmcnJiYGOYfNzc0tP4dR0LkOk5P1f8cMdX03NjbK2c75DnXcznXoGOq+da7D\\\n",
       "OL8Xnd927ty5Ac/k3+ELBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgMlZTJqMw\\\n",
       "gTAK5zAKtttUTGeWo2MU5kk612F9fb2cHWrKZGpqqpztGIVncqh7vFV8gQAQUSAARBQIABEFAkBE\\\n",
       "gQAQUSAARBQIABEFAkBEgQAQUSAARMZqymQUjMJcwijoXIfObxtqPmOo43Z0rtlQz9nMzEw5u7a2\\\n",
       "Vs5OT9f/1Az1rG+3d2g78AUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABAxZVIw\\\n",
       "1CzHKBhqEmMU5j468ySd7FATHh1DzbR0ftsozPYMdQ6d43buxVDnu1V8gQAQUSAARBQIABEFAkBE\\\n",
       "gQAQUSAARBQIABEFAkBEgQAQUSAAREyZFAw1rTAKsydDTWJ0skNdh85xOxMend82NTU1yDl0JlKG\\\n",
       "uscdQ71D6+vr5Wznmo3CnMp24AsEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASAy\\\n",
       "VlMmozA/0DmHTnaoaZBRuA6diYnOdEVnRuSxxx4b5LgzMzPl7M6dO8vZ1dXVQc6hc99+/fXXcrZz\\\n",
       "vp3plc69GIXpoHHjCwSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIDJWUyZDzXJ0\\\n",
       "jjvUjMgozDAMNU+yvLxcznau2dtvv13O7t69u5y9f/9+Odu5ZkePHi1nO5MunWmQhYWFcvb06dPl\\\n",
       "7L1798rZK1eulLM3b94sZzvXoTMdNNTfne3AFwgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABE\\\n",
       "FAgAEQUCQGSspky2m1GYMumcw1CTIwcPHixn5+fny9ljx46Vs4uLi+Xs+++/X86ura2Vsx2dOZXO\\\n",
       "PMnx48fL2ZMnT5azf/31Vzl74cKFcvazzz4rZztzKo/yPEmHLxAAIgoEgIgCASCiQACIKBAAIgoE\\\n",
       "gIgCASCiQACIKBAAIgoEgMhYTZkMNQ0y1IzIKMyTdExNTZWzBw4cKGfffffdcnZ2dracPXv2bDl7\\\n",
       "5cqVcvaLL74oZ/ft21fOnj9/vpxdXV0tZ995551Bjnv48OFy9oknnihnv/3223K28w51nl9TJjW+\\\n",
       "QACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAImM1ZTLUPMlQswad43ZmGNbX18vZ\\\n",
       "O3fulLOLi4vl7NGjR8vZEydOlLNfffVVOfvhhx+Ws9evXy9n5+bmytn9+/eXs5cuXSpnr169Ws4u\\\n",
       "LS2Vs5OT9X9T3rx5s5y9ePFiOXvt2rVydnl5uZwd6j3e2NgoZzvXdzsYr18DwP+NAgEgokAAiCgQ\\\n",
       "ACIKBICIAgEgokAAiCgQACIKBICIAgEgMlZTJh2dWYOhJhA6cyqdeZKVlZVy9sCBA+XswsJCObtv\\\n",
       "375y9qeffipnP/3003L2woUL5eyzzz5bznamV6an66/Yc889V87eunWrnL1x40Y5e+bMmXL2scce\\\n",
       "K2f/+OOPcvbBgwflbMfa2togx+3MDI0bXyAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAA\\\n",
       "RBQIAJGJzc6exog7fvz4IMcd6hJ1JhA2NjbK2aeeeqqcffrpp8vZxx9/vJy9e/duOXv//v1y9uzZ\\\n",
       "s+VsZ7ri+eefL2ffeuutcrYzy9GZSOl4//33y9nO5EhnpqXzDt25c6ecvX37djk71PvWyU5O1v/N\\\n",
       "fu7cuXJ2q/gCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACI1LcIxkxnfqCjM1Ww\\\n",
       "srJSzh4+fLicPXXqVDm7d+/ecnZ9fb2cvXr1ajn7559/lrOdiZTO1MbJkyfL2c7cx5EjR8rZgwcP\\\n",
       "lrM//PBDOdu5Fzdu3ChnOzM4CwsL5ezS0lI525mrmZiYKGc7hjruduALBICIAgEgokAAiCgQACIK\\\n",
       "BICIAgEgokAAiCgQACIKBICIAgEgMlZTJpubm4MctzNP0plI6cw7dKZMXnvttXK2M09y7dq1crYz\\\n",
       "TzIzM1POdq7D4uJiOXvo0KFy9ueffy5nP/jgg3K2M23TmSd5+PBhObtr165ydv/+/eXsgwcPytnO\\\n",
       "e7xjx45ytqPzznfeoaEmlLaKLxAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgMhY\\\n",
       "TZl0TExMDHLczgTC2tpaObtnz55y9vr16+XsnTt3ytkPP/ywnF1aWipnO3MUv//+ezl74sSJcvbz\\\n",
       "zz8vZ2/cuFHOduZfOs/O1NRUObt3795ydnp6mD8JQ02DDKVzDp3plaH+7mwVXyAARBQIABEFAkBE\\\n",
       "gQAQUSAARBQIABEFAkBEgQAQUSAARBQIAJFHdsqkozNV0Jkn2bVrVzk7NzdXzn755Zfl7OnTp8vZ\\\n",
       "q1evlrOda9aZMlleXi5nv//++3J2ZWWlnO3c447Z2dlytvPsdH7bwsJCOfvw4cNy9tKlS+XsxsZG\\\n",
       "OduZBulkO8/vo8wXCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJA5JGdMulMFXSm\\\n",
       "FTo60wrnz58vZzvne+3atUGOOzk5zL9NOscdap6kc99mZmbK2QcPHpSzndmTvXv3lrOdKZOpqaly\\\n",
       "9v79++XsUM9O553vnEPnuJ1nZzvwBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEA\\\n",
       "EHlkp0w6UwWdCY/du3cnp/OPlpeXy9nOtEJnPmN+fr6cHWr2ZG5urpxdX18f5ByG0plT6UyOvPji\\\n",
       "i+XsM888U85+88035Wzn+Z2efmT/LG07W//WALAtKRAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCi\\\n",
       "QACIKBAAIo/sZkBn7qOT7cxRvPrqq+Xs4uJiOXvr1q1yds+ePeXsjRs3ytmhJl0696JjqGmb1dXV\\\n",
       "crbz7Bw5cqScPXXqVDn7448/lrNLS0vl7FBTMUM9D5173DHU+W4VXyAARBQIABEFAkBEgQAQUSAA\\\n",
       "RBQIABEFAkBEgQAQUSAARBQIAJGxmjKZmJgoZzvTCp35gb1795azU1NT5WznfDuTI3Nzc+VsZ/bk\\\n",
       "3r175ez0dP0x3LlzZznbuW+d6zs7O1vO/vnnn+Vs57cdO3asnL1+/Xo5e+bMmXL24sWL5WznmnXe\\\n",
       "46HucUfnHDq/bTvwBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEBmrKZPOpMDK\\\n",
       "yko525naePDgQTnbmYLozIgcOHCgnO3Mnuzevbuc7cxy3Lx5s5wd6r5tbGyUs53zvX37djn75ptv\\\n",
       "lrOde/Hdd9+Vs7/88ks523kmO9e3Y319fZDjDjU50vkbtR34AgEgokAAiCgQACIKBICIAgEgokAA\\\n",
       "iCgQACIKBICIAgEgokAAiIzVlElnfmComYuhpkw65/DCCy+Us88+++wgx+1MeHzyySfl7NLSUjk7\\\n",
       "OVn/99H8/Hw525mK2bdvXzl75MiRcnb//v3l7EcffVTOdmZaFhcXy9m1tbVydiijMCPSeSa3g/H6\\\n",
       "NQD83ygQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACJjNWXSmSroZDvzA53Jhs48SceF\\\n",
       "CxfK2TfeeKOcfe+998rZy5cvl7MrKyvl7J49e8rZzr04dOhQObuwsFDOzszMlLOzs7Pl7PXr18vZ\\\n",
       "q1evlrNDPetTU1Pl7Orqajk71DTIKMyebAe+QACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCi\\\n",
       "QACIKBAAImM1ZdIxMTExyHE7kw3T0/XLv7y8XM6ur6+Xs1euXCln//vf/5azd+/eLWdfeeWVcrZz\\\n",
       "315//fVytjOfsbi4WM52ZmU+/vjjcvbrr78uZ+/du1fOzs/Pl7Mdnee38w51jMI8ySicw7/JFwgA\\\n",
       "EQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQGRic4z+b/3LL79cznYmMTY2NgY5bie7\\\n",
       "trY2SLYzp7Jv375ydseOHeXs7OxsObtz585y9sknnyxnO7/tzp075ezly5fL2UuXLpWz9+/fL2c7\\\n",
       "93hysv5vys570dH5k9R5h4Y67lDOnTu31afwj3yBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUC\\\n",
       "QESBABBRIABE6hsHY2aoeZKOzrRCZ+5jZWWlnO1ch2vXrpWzDx8+LGc78xmdKZPffvutnO2Ympoq\\\n",
       "Z2/fvl3OLi4uJqfzj8Z5nmQUzmEU/pZsFV8gAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEg\\\n",
       "AEQUCACRR3bKpDPvMNQEwtra2iDHHWq6ojOnMj1df7RmZmbK2b///ruc7fy2TrYzZdL5bZ173Lm+\\\n",
       "neehcw7r6+vl7CjMiIzCO2/KBAD+o0AACCkQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiIzV\\\n",
       "lMlQMwGd43YmEDo6kw2d8+1MbXTs3LmznO1MYszPzyen869aXV0tZ+fm5srZznXozHKsrKwMctyh\\\n",
       "5j46Ouc7lM516MzgbAdbf/UB2JYUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCACRic2h\\\n",
       "tjcAGGu+QACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAA\\\n",
       "IgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACI\\\n",
       "KBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgMj/AEaH\\\n",
       "xmCIFQB2AAAAAElFTkSuQmCC\\\n",
       "\"\n",
       "  frames[5] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAPRklEQVR4nO3cS29VdbgG8LNtC72AXCQqlwBeSDREY0ycqCOd8EH8FMZv4lDH\\\n",
       "Jg40MTEmBOKIYOINIygBEZRrpVBaaOmZnPl530cX7G5+v/GTlf9ee60+7AHPaGNjY+N/AKDpqcd9\\\n",
       "AAA2JwUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBR\\\n",
       "IABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESB\\\n",
       "ABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUC\\\n",
       "QESBABCZftwH+C+9+uqr5exTTw3TnQ8fPnSGMTnDUDqfraNzH4a6v5N83XEwNTVVzv74448DnuS/\\\n",
       "sbneXADGhgIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIDJRUybjMK3QMdQZNts0SEfn\\\n",
       "nnVmIzY2NsrZcbi/nTOMRqMBT7J5jMN73HnONoPH/yYAsCkpEAAiCgSAiAIBIKJAAIgoEAAiCgSA\\\n",
       "iAIBIKJAAIgoEAAiEzVlMg7zJOMwc9G5D0MZalamM0+yvr5ezm62GZyOznzG9HT9T8La2lo5Ow73\\\n",
       "YRzei0nz+L9VADYlBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJAZKKmTMZhjmIcZi6G\\\n",
       "uu5oNCpnOzMiHZ1Zjs596Hy2jnF4zoaaJxnKOLxDHZ3zTtqcyuO/+wBsSgoEgIgCASCiQACIKBAA\\\n",
       "IgoEgIgCASCiQACIKBAAIgoEgMhETZl0jMOMyDjMXHR0zjA1NVXOduZJhrpnnemVztxHZ0akc4bO\\\n",
       "PRvqvJ3rjsOzPg6zJ5PGHQUgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiEzUlMk4\\\n",
       "THgMdYaOcThvZ2pjqMmRmZmZcvbQoUPlbOeezc7OlrNzc3Pl7PLycjnbuQ/PPvtsOXvmzJly9u+/\\\n",
       "/y5nFxcXy9n5+flytmMc3uPNwC8QACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBIDI\\\n",
       "RE2ZdHTmM8bhuh2dGYahZk+mp+uP1r1798rZzjTIBx98UM7u3LmznL1y5Uo5u7q6Ws7u2bNnkOvu\\\n",
       "2rWrnN2/f385u3fv3nL2119/LWe///77cvbOnTvl7Di8F5Pm8f+1A2BTUiAARBQIABEFAkBEgQAQ\\\n",
       "USAARBQIABEFAkBEgQAQUSAARJ7YKZOhjMNcQue6nezy8nI525kcOXjwYDm7sLBQzh46dKic7UyZ\\\n",
       "fPXVV+Xs2bNny9l9+/aVs7du3SpnO/Mkb7311iDX7XwX27ZtK2dPnDhRzq6srJSzT/I8SYdfIABE\\\n",
       "FAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAkYmaMhlqGmSoM4zDdTc2NsrZ+fn5crYz\\\n",
       "XfHhhx+Ws/fu3StnP/3003K2Mw3y3XfflbOrq6vl7B9//FHOXr58uZx9//33y9k///yznD169Gg5\\\n",
       "27G0tFTOrq2tlbNDvUNDzQxtBpP1aQB4ZBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQI\\\n",
       "AJGJmjKZZJ0JhM68w507d8rZPXv2lLNvv/12Ofvuu++Ws59//nk5e/LkyXK2M5GysLBQzs7Ozg5y\\\n",
       "hrm5uXL2xo0bg1y3c97r16+Xs+fOnStnO1M8o9GonB3KUBNKj4tfIABEFAgAEQUCQESBABBRIABE\\\n",
       "FAgAEQUCQESBABBRIABEFAgAkYmaMunMBHSmQTo6cwmdGYahPtvhw4fL2e3btw9yhm+++aac/eyz\\\n",
       "z8rZzkzLzp07y9ktW7aUs9PT9VfstddeK2dv3bpVznYmRy5evFjObtu2rZy9cOFCOdt51jvvW2fi\\\n",
       "ZyhD/d15XCbr0wDwyCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACKjjc6expg7evRo\\\n",
       "OTsOsyed6y4vL5ezL730Ujn7xhtvlLNPP/10OXv16tVytnMfjh8/Xs52vuO5ubly9sCBA+Xs3r17\\\n",
       "y9n33nuvnF1cXCxnv/jii3K2M/fR+d5u3rxZzl65cmWQM0xNTZWzHevr64Nc98yZM4Nc97/kFwgA\\\n",
       "EQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQGT6cR9g0oxGo3J2ZWWlnN29e3c5e+zY\\\n",
       "sXK2M7XRmSeZnq4/Wtu2bStnO/fs0qVL5ez+/fvL2bt375azndmTzpzKuXPnytkHDx4McoYdO3aU\\\n",
       "s52JlAsXLpSzW7duLWfHYbVpqFmkx2WyPg0Aj4wCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoE\\\n",
       "gIgCASDyxE6ZdCYFOtmHDx+Ws/Pz8+VsZ3LkyJEj5ey9e/fK2c4URGe6ouPgwYPl7MzMTDnbmeVY\\\n",
       "WloqZ48fP17Onjx5spztfG+dKZPnnnuunN23b185e+3atXK28150poM6z2/nuh2dvw+bgV8gAEQU\\\n",
       "CAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCACRJ3bKpKMzgdCxurpazs7Ozpaz3377bTnb\\\n",
       "mbk4ffr0INftTGJcunSpnO3Mcvz000/l7K1bt8rZ+/fvl7OdmYutW7eWs535l127dpWzzzzzTDm7\\\n",
       "e/fucnZ9fb2c7UyOdCaJhnrnO2fYDCbr0wDwyCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAA\\\n",
       "iCgQACKmTP5jnTmKubm5cvb69evl7L1798rZX375pZydmpoqZztzFIuLi+Xs7du3y9mVlZVydnl5\\\n",
       "uZzt6ExiTE8P8zrevHmznO3Mk2zbtq2c7XwXnees8751stT4BQJARIEAEFEgAEQUCAARBQJARIEA\\\n",
       "EFEgAEQUCAARBQJARIEAEJmoKZPNNlVw//79cnZpaamcvXbtWjnbmc/ozHJs2bKlnF1bWytn5+fn\\\n",
       "y9nO/X3qqfq/pTrP2Wg0KmcfPHhQznbmPp5++ulytqMzV9OZU+l8b53nt/MdU+OOAhBRIABEFAgA\\\n",
       "EQUCQESBABBRIABEFAgAEQUCQESBABBRIABEJmrKpDNV0JmY6Ex4DHXdxcXFcnbHjh3l7MrKSjnb\\\n",
       "mSfpzH10ZjmGur8dQ82/dKZM9u7dW84ePny4nH3hhRfK2bNnz5azN27cKGc7z1lH55kcavak8/xu\\\n",
       "Bn6BABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEJmrKpDNVMA4OHTpUzs7MzJSz\\\n",
       "6+vr5ezq6mo5u7y8XM4ONUfRmZhYW1srZzvzJJ372znDwsJCOfv666+Xs8eOHStnl5aWytnz58+X\\\n",
       "s51nZyidZ2eovyVDTaQ8LpP1aQB4ZBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIAJGJ\\\n",
       "mjKZmpoa5LqdOYqtW7eWs7Ozs+XskSNHytl//vmnnO3cs8uXL5ezi4uL5exoNCpnO5MuQz0Pc3Nz\\\n",
       "5ezNmzfL2c5z9vLLL5eznfmMH374YZDsyspKOduZwelMjnTuwzjMnmwGfoEAEFEgAEQUCAARBQJA\\\n",
       "RIEAEFEgAEQUCAARBQJARIEAEFEgAEQmaspkfX29nO1MFXSmNjpnuHv3bjnbmSd55ZVXytnV1dVy\\\n",
       "dmlpqZzt6Mx9DDVl0pmjWF5eLmfv3LlTzr755pvlbGca5NSpU+XsiRMnytnOszM9Xf9T03nfxsGT\\\n",
       "PHviFwgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQGSipkw6kwJDXbczZXL+/Ply\\\n",
       "tjP30ckePny4nN29e3c5e/ny5XL29OnT5WxnwqMzFbOwsFDOduzcubOc3bt3bzl74MCBcvaTTz4p\\\n",
       "Z3///fdytmN2drac3djYKGeHeueHmhwZ6ryPy2R9GgAeGQUCQESBABBRIABEFAgAEQUCQESBABBR\\\n",
       "IABEFAgAEQUCQGSipkzGYX6gM8MwNTVVzt6+fbuc/e2338rZ7du3l7MfffRROduZxPjyyy/L2c7c\\\n",
       "R+e7GI1G5eza2lo523kmO8/ZqVOnytm//vqrnO3YsmVLOdv5Lob63jrX7Zi0eZKOJ/eTA/CvKBAA\\\n",
       "IgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIhM1ZTIOZmZmBrnu/fv3y9k7d+6Us6dPny5n\\\n",
       "v/7663L2+eefL2ffeeedcrYz//Liiy+Ws2fOnCln5+fny9mLFy+Ws53v4ueffy5nL1++XM7u2LGj\\\n",
       "nO1MeIzD/Mtmu+5mMFmfBoBHRoEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEHlip0w6\\\n",
       "kxjr6+uDnGE0Gg2S7Uwr3Lx5s5z9+OOPy9nt27eXs1u3bi1nO1MQQ2WXlpbK2du3b5eznQmazjTI\\\n",
       "rl27ytnOs9N5LzrP72YzafMkHU/uJwfgX1EgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEg\\\n",
       "AESe2CmToeZJhtKZ+5iern+tW7ZsKWfv3r1bzl69erWc7UxBdD7bgwcPBjlD57vo3LPZ2dlytvO9\\\n",
       "jcOz3jnDUBM0nZmWTrZj0mZPJuvTAPDIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAA\\\n",
       "Ik/slMlQEwgda2tr5exoNCpnNzY2kuP8v6ampsrZ+fn5crYzDbKyslLOLiwslLP3798vZzszIp17\\\n",
       "NjMzU86OwzxJ5znrZDvPeucdGuqdn7R5ko4n95MD8K8oEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIB\\\n",
       "IKJAAIgoEAAiEzVl0pmN6EwrbLbZk47p6foj0LlnnVmOzj3rzIh05j4692Go+Yyhpm2GOm9H57wd\\\n",
       "m+2d7zxnm4FfIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAkdFG5//3A8D/8QsE\\\n",
       "gIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAA\\\n",
       "IgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACI\\\n",
       "KBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACI/C+4srGuRgIK5wAA\\\n",
       "AABJRU5ErkJggg==\\\n",
       "\"\n",
       "  frames[6] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAOt0lEQVR4nO3czW6VddvG4WfR0paWWkJRJHyjaNRAMCFGnenULXDqbrgtDhzr\\\n",
       "0JEDoiMhxoGiMRTkQyJtSoFCamlXW9Y7eCfPzOt/Pty2qxzH+Exzd/XGn2ty9QaDweA/ANBoz3Y/\\\n",
       "AADDSUAAiAgIABEBASAiIABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAA\\\n",
       "IgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEBASAiIAAEBEQ\\\n",
       "ACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABAZ\\\n",
       "3e4HeJ5OnTpV3vZ6ve4eBDo2GAzK267e9T176v//+ezZs06eYdi0fGZ//PFHh0/yfPgGAkBEQACI\\\n",
       "CAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIjsqlMmzpPw37o6tdHyc1u0PEPLuz4yMlLebm1t\\\n",
       "lbctz7sTTq/sBLvtpItvIABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIgAEQEBIDIrjplwu7X\\\n",
       "1XmSFl393K7OfbScJ2k5e7K5udnJz91t5z52M99AAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJA\\\n",
       "REAAiAgIABGnTCjbzWdEWk5ttJwG2QnP0HL2ZGNjo7zdCe8D28s3EAAiAgJAREAAiAgIABEBASAi\\\n",
       "IABEBASAiIAAEBEQACICAkDEKRPKWs5RDNuZi5bTIC3POzExUd62nBwZGxsrb7s6kbK5uVneDgaD\\\n",
       "8rblefv9fnk7bO/kMPANBICIgAAQERAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABBxyoROtJyC\\\n",
       "GB2tv4br6+vl7d69e8vbQ4cOlbdTU1Pl7ezsbHn78ssvl7ctJ1JanrfF77//Xt7Oz8+Xt0tLS8nj\\\n",
       "/KOWd7Ll9ErLCZqWcyrDYHf9NgD8awQEgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEBASAiFMm\\\n",
       "L7iW0wpdnSdZWVkpb8fHx8vbTz/9tLw9evRoedty5mJ6erq8PXLkSHnb7/fL265OpPz000/l7Z9/\\\n",
       "/lne/vDDD+Xt9evXy9utra3y9kU+T9Lixf3NAfifCAgAEQEBICIgAEQEBICIgAAQERAAIgICQERA\\\n",
       "AIgICAARp0wo29jYKG8nJyfL2/fee6+8PXz4cHl78eLF8nZtba28/eabb8rb+/fvl7ct51RaToOc\\\n",
       "PXu2vH3jjTfK25MnT5a3H330UXnb8re4ceNGedtygqbllMmLzDcQACICAkBEQACICAgAEQEBICIg\\\n",
       "AEQEBICIgAAQERAAIgICQMQpk11oz55u/r9gfHy8vG05y/HFF1+UtxMTE+Xt559/Xt5evny5vF1c\\\n",
       "XCxv//777/L26tWr5e38/Hx5+/jx4/J2dXW1vD1//nx5e+LEifJ2a2urvB0drf8nrOWUScv22bNn\\\n",
       "5W1X/za3y+76bQD41wgIABEBASAiIABEBASAiIAAEBEQACICAkBEQACICAgAEadMhsTIyEh523IK\\\n",
       "Ym1trbw9ePBgefvWW2+Vt4cOHSpvv/322/L266+/Lm9bzn28+uqr5e3U1FR523KWY2ZmprxtOU+y\\\n",
       "sbFR3racaZmbmytvr127Vt62vL8tZ0S6Ok/ilAkA/EdAAAgJCAARAQEgIiAARAQEgIiAABAREAAi\\\n",
       "AgJAREAAiDhl8px1dS5hMBiUt+Pj4+XtsWPHytvp6elOnuHLL78sb7/66qvyttfrlbctn8Ps7Gx5\\\n",
       "u2/fvvL2+PHj5e2DBw/K2/X19fJ2cnKyvL137155++jRo/J2eXm5vO3qxE9XWv4dDwPfQACICAgA\\\n",
       "EQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARp0wKWs6TtBgdrX/8Lc9w4cKF8vbMmTPl7aFD\\\n",
       "h8rbq1evlreXLl0qb+/cuVPeHj58uLxtOStz+vTp8vbEiRPl7euvv17e3r17t7xt+cz6/X55e+vW\\\n",
       "rfK25ezJ/fv3y9uW8yQtZ09aTo509QzDwDcQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAA\\\n",
       "IgICQMQpk4KWMxct50k2NjbK25aTI5988kl523JqY35+vrxtOe8wPj5e3k5MTJS3Lc975MiR8vbg\\\n",
       "wYPl7ezsbHm7ublZ3j58+LC8bdFyrqblLMf09HR52/LvreXkSIuWZ+j1ep383GHgGwgAEQEBICIg\\\n",
       "AEQEBICIgAAQERAAIgICQERAAIgICAARAQEg4pRJwZ499c62nKNoOe9w9uzZ8vadd94pb1vOqYyN\\\n",
       "jZW3a2tr5e3S0lJ5u3fv3vL2pZdeKm8nJyfL28ePH5e3v/76a3nbctKl5d1p2R44cKC8bfl8FxYW\\\n",
       "ytuWc0At51Razp60/JvfbedJWvgGAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIg4\\\n",
       "ZVLQ6/XK267OnkxMTJS3Lecz+v1+eXvlypXydm5urrxtOUcxPz9f3h49erS8vX37dnn79OnT8nZl\\\n",
       "ZaW8bXl3jh07Vt6ePHmyvG05e9JycmRmZqa8bTFsZ0Ra/sbDYHf9NgD8awQEgIiAABAREAAiAgJA\\\n",
       "REAAiAgIABEBASAiIABEBASAiFMmBYPBoLxtOa0wNjZW3i4uLpa3ly5dKm9//vnn8rbld3v06FF5\\\n",
       "Oz4+Xt6urq6Wty1/t/X19fK2xdbWVnnb8jksLS2Vty3nMy5evFjeTk5Olrctn2/LiZRhM2ynV/6J\\\n",
       "byAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEBASAyO69GfActZwfaDnD0HJiYmVlpby9\\\n",
       "ceNGJz93Y2OjvB0ZGSlv+/1+edty/qXleVv+Fi3vQ8vnsLm5Wd4+efKkvJ2dne3kGbp6f58+fVre\\\n",
       "sr18AwEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEXthTJi1nGFrOO+zfv7+8PXHi\\\n",
       "RHnb8rzT09Pl7eLiYifP0KKr8y8tJ0e6Ok+ytbVV3ra8Z1NTU+Vty/O2/Nzbt2+Xt9euXStv19fX\\\n",
       "y9uu3oeutPwthoFvIABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIgAEQEBIDIC3vKpOWsQcu5\\\n",
       "hJZTJh9++GF5OzExUd5euXKlvH306FF5u7y8XN529fm2aHmGlnMqg8Ggk23LKZPjx4+Xt+fPny9v\\\n",
       "NzY2ytuFhYXydmVlpbxtsRPOk7RoOW0zDHwDASAiIABEBASAiIAAEBEQACICAkBEQACICAgAEQEB\\\n",
       "ICIgAER21SmTlpMYvV6vk2eYnZ0tb/ft21feXrx4sbw9duxYefvLL7+Utz/++GN5+9tvv5W3/X6/\\\n",
       "vG05OdLViZSWZ2g5XdFy9uTgwYPl7dGjR8vbe/fulbdzc3Pl7erqannb8ncbtlMmu41vIABEBASA\\\n",
       "iIAAEBEQACICAkBEQACICAgAEQEBICIgAEQEBIDIrjpl0tVZg4mJifJ2ZWWlvH3y5El52/K7ffDB\\\n",
       "B+VtiwcPHpS3jx8/Lm/v3r2bPM4/6uqUSct5kvX19fL21KlT5e3bb79d3s7MzJS3N2/eLG9b3t8W\\\n",
       "zpMMD99AAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIAJFddcqkK6urq+Xt0tJSefv9\\\n",
       "99+Xt2tra+XtuXPnyttXXnmlvH333XfL24WFhfK25ezJw4cPy9t+v1/eTk9Pl7e9Xq+8nZqaKm9b\\\n",
       "Tpl8/PHH5W3Le3bnzp3ytuVv3PKZtZygcfZke/kGAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAA\\\n",
       "IgICQERAAIg4ZVIwOlr/mJaXl8vb9fX18nZjY6O8/euvv8rb999/v7z97LPPyts333yzvP3uu+/K\\\n",
       "2wMHDpS3MzMz5W3LyZGW0zYt5z7OnDlT3racf1lcXCxvW07x7N27t7zd3Nwsb50nGR6+gQAQERAA\\\n",
       "IgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiTpkU9Hq98nZkZKS8XVtbK2/n5+fL25azJy3P\\\n",
       "8Nprr5W3LWcuLly4UN5ubW2Vt+fOnStv5+bmytuxsbHy9tq1a+Xt5cuXy9ubN2+Wt9evXy9vnzx5\\\n",
       "Ut62vOt79tT/X9Upk+HhGwgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARAQEg0hsMBoPt\\\n",
       "fojn5fTp09v9CDvCxMREeTs+Pl7eTk9Pl7f79+8vb1vOnrScaWn53VpOpCwvL5e3CwsL5W3LP8WW\\\n",
       "5205I7ITOGXy/27durXdj/CPhuvNAmDHEBAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAi\\\n",
       "o9v9AC+ykZGRTn5uy7mPtbW18nZlZaW8XV9fL2+7OjkyOlp/vVu2LadBWj6Hrt6Hlufd3Nzs5Od2\\\n",
       "dZ5kJzzDi8w3EAAiAgJAREAAiAgIABEBASAiIABEBASAiIAAEBEQACICAkDEKZPnrOW0QsvJkbGx\\\n",
       "sU5+bq/XK29bTm1MTU2Vt4PBoLzdCfr9fnnbcqal5d3pSstJl5bTIC1/45b3zHmS7bX9bywAQ0lA\\\n",
       "AIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiOyqUyZdnYJoOZfQ1WmFnXCeZHNzs7zdCWc5\\\n",
       "Wv4WLb9by7blNMjW1lZ526Ll57b83Vo+35Z3skVXz9uVln9vw2D7/5UDMJQEBICIgAAQERAAIgIC\\\n",
       "QERAAIgICAARAQEgIiAARAQEgEhvMBgMtvshABg+voEAEBEQACICAkBEQACICAgAEQEBICIgAEQE\\\n",
       "BICIgAAQERAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAiIABE\\\n",
       "BASAiIAAEBEQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARAQEgIiAA\\\n",
       "RAQEgIiAABAREAAiAgJA5P8ANexGPiRqV98AAAAASUVORK5CYII=\\\n",
       "\"\n",
       "  frames[7] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAPK0lEQVR4nO3cy25WBdsG4J9uaGkhocUKAgE+ZSMOjERJHGnixCPQw3HimZgY\\\n",
       "N+dgoiRuBhIGaAQiESJEdkIpYO2Wb/AfgM9zfy5pX69rfGdlvWut9727Br13PH369On/AUDT2LM+\\\n",
       "AQC2JwUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBR\\\n",
       "IABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESB\\\n",
       "ABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUC\\\n",
       "QESBABCZeNYn8Hc6ceJEOTs+Pl7OPn36NDmdv9WOHTvK2c75do7bMdQ12wrXwWfbnsftGOocxsbq\\\n",
       "f7P/9NNP5eyz4g0EgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASAyUlMm222epGO7\\\n",
       "TUEMZWNjo5ztPA8dW2H+Zahz6Oic7+bmZjm73e5bx3b7vv0VbyAARBQIABEFAkBEgQAQUSAARBQI\\\n",
       "ABEFAkBEgQAQUSAARBQIAJGRmjLZCjMBozyXMNRESmfmYmKi/sh2zmGoazY2NszfaJ1Jl84168yI\\\n",
       "rK+vD3IOnedhK8zKbIXjPiveQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIiM1\\\n",
       "ZTLU1MZ2O+5205nP2AozLZ0Zkc5x19bWBjluZ3KkMyPSmWkZ6ride9F5zoayFaaO/k7eQACIKBAA\\\n",
       "IgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIiM1ZTLUzIV5kv831HXo6By3M5/R0ZnE6Ext\\\n",
       "dM53ZmamnF1dXS1nJybqPwmd43au2VCzJx1DfY+323f+r3gDASCiQACIKBAAIgoEgIgCASCiQACI\\\n",
       "KBAAIgoEgIgCASCiQACIjNSUyVC22zzJUOc71HEnJyfL2eXl5XK2M7Xx+uuvl7MLCwvlbOez7d27\\\n",
       "t5zdvXt3OduZU1lbWytnf/jhh3L2l19+KWd///33cnbXrl3lbOeZ3ApzKtvBv/eTA/A/USAARBQI\\\n",
       "ABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAAREyZFGyFuY+Ooc63ozPv8PDhw3K289nef//9cvbd\\\n",
       "d98tZ/ft21fO/vbbb+XsyspKOXvlypVy9tixY+XszMxMOdu5F53nYXp6upy9f/9+OTvUPMlW+M4/\\\n",
       "K95AAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiIzVlshUmBbbC7EnnuJ3s6upq\\\n",
       "OTs3N1fO/uc//ylnjx8/Xs6+/fbb5Wzn+n700Ufl7I0bN8rZO3fuDHLcl19+uZw9e/ZsOTs1NVXO\\\n",
       "vvXWW+Xsl19+Wc4uLS2Vs+vr6+Vsx1aYDnpWvIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJA\\\n",
       "RIEAEFEgAERGaspkqHmSoWyFCYTOOWxubpazu3fvLmc///zzQY774YcflrOffvppOdu5Dg8ePChn\\\n",
       "Z2dny9nr16+XswsLC+Xs+fPny9n33nuvnJ2fny9nO/e4M68zMVH/uet8L4bKbgfeQACIKBAAIgoE\\\n",
       "gIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIiM1ZdKZ+9hukwLj4+PlbGfeYah5klOnTpWzT548\\\n",
       "KWe//fbbcvaDDz4oZ3ft2lXOHjx4sJw9cOBAObu8vDzIOVy9erWc7TwPN2/eHCT79ddfl7PT09Pl\\\n",
       "7Pr6ejnb+S0ZamZoO/AGAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQGakpk60w\\\n",
       "TzLUrMGff/5Zzo6N1f8uOH36dDk7Pz9fzs7MzJSzn332WTn78ccfl7OHDx8uZzsTHrOzs+XsyspK\\\n",
       "Odu5vpOTk+XsUDM4nez169fL2c69GGqeZGNjo5ztXN9R4w0EgIgCASCiQACIKBAAIgoEgIgCASCi\\\n",
       "QACIKBAAIgoEgIgCASAyUlMmnamCzuxJ57hDTZl05h3OnDlTzr722mvl7L1798rZy5cvl7MXL14s\\\n",
       "Z5eWlsrZQ4cOlbO3b98uZzszIidOnChnd+/eXc7euHGjnO3MciwsLJSzy8vL5ez9+/fL2Y7O96Iz\\\n",
       "OTIxUf9p7MypdGaGtoPR+jQA/GMUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCACRkZoy\\\n",
       "GUpn9qSjMwWxZ8+ecvbNN98sZ48fP17OXr16tZy9c+dOOXvw4MFy9oUXXihnb926Vc4ONXOxtrZW\\\n",
       "zi4uLpaznXsxNTVVznZ0Zns6EymdezGUzkTKqM2TdPx7PzkA/xMFAkBEgQAQUSAARBQIABEFAkBE\\\n",
       "gQAQUSAARBQIABEFAkDElMnfrDPvsGvXrnL20KFD5WxnnmR6erqcnZycLGc78yTPP/98OXvs2LFy\\\n",
       "9tKlS+Xso0ePytnOTMu1a9fK2dXV1XJ2fX29nO1Mmezbt2+QbOeadb5DnRmRoSaJ/s28gQAQUSAA\\\n",
       "RBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAAREZqyqQzVdCZS+jY3NwcJLu2tlbOXrhwoZzt\\\n",
       "TJmcO3eunO1MeJw+fbqc7UxidCZS7t69W84uLi6Ws0Pd44mJ+ld3fHy8nO1M5szNzQ2S7ZzvxsbG\\\n",
       "IMft2Aq/O8+KNxAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgMhITZkMZSvMDzx5\\\n",
       "8qSc/eabb8rZzjTI0tJSOdtx8eLFcnZ9fb2c7UyOLC8vl7NjY/W/uzrZycnJcrbzTHZmT86cOVPO\\\n",
       "vvjii+Xs999/X8527vFQ383OPMlWOO6z4g0EgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoE\\\n",
       "gIgCASAyUlMmm5ub5ez4+Hg525kfWFtbK2c7MwwrKyvl7N27d8vZ1dXVcrZzzTrzGZ3piqmpqUGO\\\n",
       "25kR6TwPnWeyo/PZ5ubmytn5+flytjOD08l2dJ7Jjs53s/M8bIVZpL+TNxAAIgoEgIgCASCiQACI\\\n",
       "KBAAIgoEgIgCASCiQACIKBAAIgoEgMhITZl0Zg06kwKdOYrp6elydu/eveVsZ7qiMyPy8OHDcnbn\\\n",
       "zp3lbOf6dmZEhtK5x2Njw/zd1TmHzj3unG/nHM6fP1/OXr58uZwdakZkKKM2T9LhDQSAiAIBIKJA\\\n",
       "AIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIDJSUyZDzRp05h06kyNHjx4tZ2dnZ8vZa9eulbOd\\\n",
       "6ZXl5eVBjtuZgujMcgw1/9J5HjrZ1dXVcvbIkSPl7NmzZ8vZzrTNnTt3ytmtYKiJlE521GZPvIEA\\\n",
       "EFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAERGaspkK8wEzMzMlLOdCYTDhw+Xs/v3\\\n",
       "7y9n9+zZU85euXKlnH3y5Ek5OzU1Vc525j7Gx8fL2c6z05k96cypLC0tlbMLCwvl7NzcXDn73Xff\\\n",
       "lbNfffVVOdu5Zp37NtR80VC22/n+FW8gAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQU\\\n",
       "CACRkZoyGWomoDPDsLi4WM7evn27nH3uuefK2Zdeeqmc3bt3bznbmcToTIM8fvy4nO3MnnQmMTY2\\\n",
       "NsrZzjxJZ3rllVdeKWffeOONcnZ6erqc/fHHH8vZjrW1tXK2c994tryBABBRIABEFAgAEQUCQESB\\\n",
       "ABBRIABEFAgAEQUCQESBABBRIABERmrKZCid6YqOn3/+uZztzFHMzMyUsydPnixn9+3bV86eO3eu\\\n",
       "nL1161Y525nE6EykdCZddu3aVc4ePXq0nD18+HA5u3///nL2k08+KWc796Iz8TPUzNB205n42Q68\\\n",
       "gQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAAREyZFIyPj5ezncmGqampcvb69evl\\\n",
       "7IMHD8rZY8eOlbPvvPNOOdu5Zq+++mo5Ozs7W84eOXKknD148GA5e+DAgXL2ypUr5ez8/Hw5+8UX\\\n",
       "X5Sznedhc3OznO1MmXSO27EVJlJGbZ6kwxsIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQI\\\n",
       "ABEFAkBkpKZMOpMCQ00gTE5OlrNra2vl7MrKSjn7+PHjcnZxcbGcPXPmTDnbmUg5depUOdu5bydP\\\n",
       "nixnO/etc81u3rxZzp47d66cvXDhQjn76NGjcrYzFdOZJ+nct60wT9Kx3c737+QNBICIAgEgokAA\\\n",
       "iCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgsuPpCP0ffmcSozN7srGxUc6Oj48Pcg7r6+uDnEPn\\\n",
       "uJ3z3b9/fznbmRFZXl4uZzvX4Y8//ihnJybqC0D37t0rZ6empsrZzvkONU8yNjbM35+dc+joPL8d\\\n",
       "nZ/QzjlcunQpOZ1/lDcQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBIBIfZNhxHTm\\\n",
       "BzqTGEPNGuzcubOcXV1dLWc7n61z3F9//bWcHWoSozPT0rm+HZ3r2zEzM1POdq7vUNM2Qy0mdT7b\\\n",
       "UBMp/2beQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIv/aKZOOoWYYOtMKnXOY\\\n",
       "mKjf1s50xezsbDm7srJSznbmPjrnOzU1Vc4ONUHT+Wyd52Go+ZfOs9OxsbFRzg41TzLU9ErnuKPG\\\n",
       "GwgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQGSkpky221RBZ96hozNH0cl25kmG\\\n",
       "msSYnJwc5Lide9yZzxhqrmaocxjqO9SZJ+lkh5oZ6hjqOmwHo/VpAPjHKBAAIgoEgIgCASCiQACI\\\n",
       "KBAAIgoEgIgCASCiQACIKBAAIjueboUtAAC2HW8gAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEA\\\n",
       "EFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJA\\\n",
       "RIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAAR\\\n",
       "BQJARIEAEFEgAEQUCAARBQJA5L/9Lbp4A0Qi3AAAAABJRU5ErkJggg==\\\n",
       "\"\n",
       "  frames[8] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAO6klEQVR4nO3cy25WhdsF8A9aSwulIJTKOSTEKJ4QB46MDsVr8XYcOHDqHejA\\\n",
       "hMSBiQPjiGggHCMCQkREKKWHt+13CT7P+rOlffn9xis7e+93767uydqxubm5+X8A0LTzRZ8AANuT\\\n",
       "AgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIK\\\n",
       "BICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQ\\\n",
       "ACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAA\\\n",
       "iEy+6BN4nt54441ydseOHYOcw+bm5gs/h63AfRhW5/7u3Fn/P3E0GpWzExMT5ew4G+q3uHTpUnI6\\\n",
       "/ylfIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABEFAgAkbGaMulMYgw1tbEVzmEoW+F8\\\n",
       "hzqHrXBtHZ1JjK1w3O12f6nxBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEBmr\\\n",
       "KZOOrTCXsBXOYbtNTAx1Dtvt2jY2NsrZzjxJJzsajcrZycn6n5rOMzmUod6Lzu+2HfgCASCiQACI\\\n",
       "KBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIvLRTJkMZ52mQTrZzH7bCPesctzPhMTExMchx\\\n",
       "OzrzJKurq+Xs1NRUOdu5ts75dgz1rA91DtuBLxAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACI\\\n",
       "KBAAIgoEgIgpk+dsK0wVDDUN0jnuUIY636FmRFZWVsrZjY2Ncnb37t3l7PLycjk71PRK59o6OrMn\\\n",
       "W2GKZ9z4AgEgokAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiIzVlMlQEx5bwVaYJ+kc\\\n",
       "d6j7u7q6Ws6ur6+Xs0eOHClnp6eny9nOfZidnS1nFxYWytmpqalBzuHy5cvl7JUrV8rZpaWlcnZm\\\n",
       "ZqacHWqeZLvNAT1PvkAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiCgQACJjNWWy3eZJ\\\n",
       "Ooa6tqHmSTqTDSsrK+Xs/v37y9nz58+Xs6dPny5nDx48WM7ev3+/nO3Mcty9e7ec7Zzvq6++Ws52\\\n",
       "Zk86bt68Wc52pm06xvlvyfPkCwSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIDJW\\\n",
       "UybjrDMNMtQ8yWg0Kmd3795dzn700Ufl7NmzZ8vZEydOlLOda7t+/Xo5+9tvv5Wzi4uL5ezFixfL\\\n",
       "2c6USWfSpTNl8v7775eznWmb27dvl7Pr6+vlbMdQ7+Z24AsEgIgCASCiQACIKBAAIgoEgIgCASCi\\\n",
       "QACIKBAAIgoEgIgCASBiyuQ52wqTI0PNJSwvL5ezCwsL5exXX31Vzm5sbJSzn3/+eTl74cKFcnZq\\\n",
       "aqqcXVpaKmcnJ+uv4++//17Ovvbaa+XsH3/8Uc5++umn5ezRo0fL2c7kSGf2ZGJiopwd6h3q/H3Y\\\n",
       "DnyBABBRIABEFAgAEQUCQESBABBRIABEFAgAEQUCQESBABBRIABExmrKpDM/0JnE2AozIp0Zhs68\\\n",
       "Q2c24vjx4+Xsxx9/XM6ura2Vsz/++GM5++WXX5azBw4cKGdnZmbK2b1795aznamYgwcPlrMPHz4s\\\n",
       "ZzszLfv27StnFxcXy9mrV6+Ws53723nOOnbufHn/D395rxyA/4kCASCiQACIKBAAIgoEgIgCASCi\\\n",
       "QACIKBAAIgoEgIgCASAyVlMmm5ub5exQkyNDWV1dLWc796EzT/LZZ5+Vs2+99VY5+/PPP5ezX3zx\\\n",
       "RTl74sSJcrZjz5495WxnPuPo0aPl7OPHj8vZubm5cnZ+fr6cPXToUDl748aNcrbzbnZmezqTI513\\\n",
       "qGO7/d35N75AAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiYzVl0pkJ2NjYGOS4\\\n",
       "Q00VjEajcvb1118vZ8+ePVvOHjt2rJy9d+9eOXvp0qVy9tGjR+XsUOe7vLxczh4+fLicPX36dDnb\\\n",
       "0bm2zpRJ51nv3LOJiYlytjNPMtR73Hk3O9e2HfgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoE\\\n",
       "gIgCASCiQACIjNWUyebm5gs/7lATCJ1zOHXqVDnbmTLpzDDcunWrnJ2crD+GZ86cKWcvX75czi4u\\\n",
       "LpaznfmMzjRI5z5cvXq1nD148GA5Ozs7W86urKyUs9PT0+XsUJNEnfvbOW7neRg3L++VA/A/USAA\\\n",
       "RBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARMZqymS76UyDdMzNzZWzjx49KmeXlpbK2Tt3\\\n",
       "7pSzhw8fLmePHz9ezg41T7K6ulrOPn36tJztTHh0np1//vmnnF1YWChnO/fsyZMn5WxncqSjM0/S\\\n",
       "+S06hppbelF8gQAQUSAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARF7aKZPOVEFnfmA0\\\n",
       "Gg1y3OXl5XL2l19+KWc7UxsXL14sZx88eFDOHjt2rJxdW1srZztTG53725ky6cxy/Pnnn+VsZ67m\\\n",
       "lVdeKWdPnjxZzu7atWuQ7Pr6ejnbMdR0UEfnmdwOxutqAPjPKBAAIgoEgIgCASCiQACIKBAAIgoE\\\n",
       "gIgCASCiQACIKBAAIi/tlElnRqQzP9CZSOlMNnQmMe7du1fO3r59u5ztzH107sPdu3fL2aHuWWci\\\n",
       "pTOJMdTz0JnMmZ+fL2fPnDlTzh44cKCc/emnn8rZzu+2sbFRznZ0/j4MNYu0HfgCASCiQACIKBAA\\\n",
       "IgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIjNWUyVDzA525hE62M4mxurpazq6srJSznZmWjs5x\\\n",
       "OxMeQ51vZz5jKJ3ntzNlsmvXrnJ29+7d5eyvv/5aznYmczrP+lC/W+fvw8vMFwgAEQUCQESBABBR\\\n",
       "IABEFAgAEQUCQESBABBRIABEFAgAEQUCQOTF7zc8R1thfqAzT9I536mpqeR0/tXS0lI5Oz09Pcg5\\\n",
       "dOZJOnMfQxlqBqcz6dKZHDly5Eg5++TJk3L24sWL5WxnyqTzPGyFd75ju53vv/EFAkBEgQAQUSAA\\\n",
       "RBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQGaspk6F05ig6UxudWYPRaFTOduZUJifrj8Dq6uog\\\n",
       "xx1quqLzu3XOoaNzvs+ePStnz507V86ePXu2nH348GE5e+3atXK2c22dezbU+zaUrTDF8zz5AgEg\\\n",
       "okAAiCgQACIKBICIAgEgokAAiCgQACIKBICIAgEgokAAiJgyKehMg6yvr5ezu3btKmdnZ2fL2SNH\\\n",
       "jpSzR48eLWevXr1azt65c6ec7cyIDDXp0jE1NVXOrqyslLMzMzPl7KlTp8rZd999t5z95ptvytkb\\\n",
       "N26Us3v27ClnO78xL5YvEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiCmTgs3N\\\n",
       "zUGOu7a2Vs7u37+/nH3vvffK2QMHDpSzGxsb5ezjx4/L2b///ruc7cx9DDVl0pmrefbsWTk7Pz9f\\\n",
       "zr755pvl7PXr18vZS5culbOd53d1dbWc7fxuQ72b1PgCASCiQACIKBAAIgoEgIgCASCiQACIKBAA\\\n",
       "IgoEgIgCASCiQACIvLRTJp0JhB07dpSzO3fWO7kzidHJ7tu3r5z95JNPytmFhYVy9ubNm+XsjRs3\\\n",
       "ytnl5eVytjMj0plImZysvzbHjh0rZ0+fPl3Ozs3NlbNff/11OfvXX3+Vs7Ozs+Vs5x3qGOq4Q/19\\\n",
       "GDe+QACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIi/tlMl2m1ZYWloqZy9fvlzO\\\n",
       "vvPOO+Xshx9+WM7evXu3nD137lw5OxqNytmTJ0+Ws4cOHRrkuFeuXClnT5w4Uc5euHChnL127Vo5\\\n",
       "u7a2Vs5OTEyUsx2dd6gzOcLz5wsEgIgCASCiQACIKBAAIgoEgIgCASCiQACIKBAAIgoEgIgCASAy\\\n",
       "VlMmQ00gDDVP0jmHp0+flrO3bt0qZ7/77rty9vz58+Xs9PR0Ofv222+Xs53f4oMPPihn9+zZU87O\\\n",
       "zMyUs53f4ocffihnv//++3J2cXGxnO3ch6Het60wTzLUOz9ufIEAEFEgAEQUCAARBQJARIEAEFEg\\\n",
       "AEQUCAARBQJARIEAEFEgAETGaspkqAmEjY2NcrYzgTA5Wb/9Kysr5ezt27fL2aWlpXL222+/LWfn\\\n",
       "5+fL2eXl5XJ2dna2nO1c2969e8vZ9fX1cvbBgwflbOc569yzubm5Qc6h877t3Fn/X7VzDh3mSZ4/\\\n",
       "XyAARBQIABEFAkBEgQAQUSAARBQIABEFAkBEgQAQUSAARBQIAJGxmjLp6MwwdCYQhppTmZmZKWfX\\\n",
       "1tbK2YcPH5aznWu7f/9+OTsxMVHOdiY8nj59OshxO9mpqalytqMzvdK5v6PRaJDjDjVPMtREitmT\\\n",
       "Gl8gAEQUCAARBQJARIEAEFEgAEQUCAARBQJARIEAEFEgAEQUCACRsZoyGWpGpGOoCYShplc6OnMq\\\n",
       "Q819dKY2OnMf6+vr5exQ8ySTk/XXsfMbd6ZtOtMgnWeyMyMy1DkMddyXmS8QACIKBICIAgEgokAA\\\n",
       "iCgQACIKBICIAgEgokAAiCgQACIKBIDIWE2ZdOYdhpoqGOocOlMbHRMTE+VsZ0Zkeno6OZ1/NdSM\\\n",
       "SGfmojPL0dE5buc56xy38zwMNSPSyW4FQ92H7WC8rgaA/4wCASCiQACIKBAAIgoEgIgCASCiQACI\\\n",
       "KBAAIgoEgIgCASCyY3OoTQ8AxpovEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSA\\\n",
       "iAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAi\\\n",
       "CgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgoEAAiCgSAiAIBIKJAAIgo\\\n",
       "EAAiCgSAiAIBIPL/jz9SoUtYYo0AAAAASUVORK5CYII=\\\n",
       "\"\n",
       "  frames[9] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAOw0lEQVR4nO3cy26VhdvGYUtbWqCCbEQ21ZgQMURjcIcTEz0AHHkAJh6JiWdh\\\n",
       "wiGYODHKwJCgIyHGBCQqRomAoEDZV+n2P/gO4HueO7xpu7iu8Z2Vt2u1/lgDn7HV1dXVpwCgadNa\\\n",
       "PwAAG5OAABAREAAiAgJAREAAiAgIABEBASAiIABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIg\\\n",
       "AEQEBICIgAAQERAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAi\\\n",
       "IABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARAQEg\\\n",
       "MrHWD/A47d+/v7wdGxsb8Ek2js77sLq6OuCT1HjeYZ9hZWWlvN20qf7vz/XwWawHnc/i6tWrAz7J\\\n",
       "4+EbCAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAyUqdMnFbo22jvQ+fUxlBnRDba\\\n",
       "eZL18LN1thvt73io93cj8A0EgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEBASAiIAAEBmpUybr\\\n",
       "4azBejhzMcqGOgXRed318Bl3Trp0ToN0tktLS4O87kb7u1gPvw9rxTcQACICAkBEQACICAgAEQEB\\\n",
       "ICIgAEQEBICIgAAQERAAIgICQGSkTpmsB51TBRvtBMJGe96Ozs/WOSMy1OmVjs4ZkYWFhUFet/P7\\\n",
       "MNTvziifU1krvoEAEBEQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAAIk6ZrKGhziWM8jmV\\\n",
       "jqF+tqFOYiwtLZW3W7ZsKW87nn766fK2c/ak87Oth/Mv1PgGAkBEQACICAgAEQEBICIgAEQEBICI\\\n",
       "gAAQERAAIgICQERAAIiM1CmToU54bDRDndroGOr9XV5eLm875zOeffbZ8nao37OJifqf4549e8rb\\\n",
       "l156qbydnZ0tb0+dOlXenjt3rrwdHx8fZMvj5xsIABEBASAiIABEBASAiIAAEBEQACICAkBEQACI\\\n",
       "CAgAEQEBIDJSp0xG+TxJx1DnSTonUjqfRWd74MCB8vbtt98ub/fu3Vvebtu2rbydn58vb6enp8vb\\\n",
       "znt29OjR8vbFF18sb+/fv1/edk6OXL58eZBnGOrv4knmGwgAEQEBICIgAEQEBICIgAAQERAAIgIC\\\n",
       "QERAAIgICAARAQEgMrY6Qv9/f+fMxXrQOUfR+ZiGOumytLRU3m7ZsqW8PXbsWHn75ptvlredsxy3\\\n",
       "bt0qb2/evFnezs3Nlbedz+38+fPl7a5du8rbl19+ubzdt29feds5/3Lq1KlBtp3f387fW2fbOQd0\\\n",
       "9erV8nat+AYCQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiEys9QM8yYa6ItN53YmJ\\\n",
       "+q/AUKdMPvnkk/J2fHy8vP3000/L2++++668nZ6eLm87Oq/766+/lrfPPPNMeXvv3r3y9uOPPy5v\\\n",
       "X3nllfL266+/Lm9XVlbK26FO/Ax19mQj8A0EgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEBASA\\\n",
       "iIAAEBmpUyadUwVDnRQY6hk62865j507d5a3MzMz5e3BgwfL286JlIsXL5a3n3/+eXnb+dy2bt1a\\\n",
       "3k5OTpa3nTMinbMnnff35s2b5e2NGzfK299//728/eOPP8rbTZvq/wZeXFwsbzu/D52/t1HjGwgA\\\n",
       "EQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARAQEgMlKnTIY6TzKUzvN2Tlfs2LGjvH3//ffL\\\n",
       "28OHD5e3U1NT5W3nzMVnn31W3j733HPl7b///lvebt68ubztfBZ79+4tb+/fv1/edn62PXv2lLed\\\n",
       "ky6XLl0qb+/evVveLi8vl7cdnb/NztmTznYj8A0EgIiAABAREAAiAgJAREAAiAgIABEBASAiIABE\\\n",
       "BASAiIAAEBmpUyadMwErKyvl7aZN9c52nmFiov72d7YffPBBefvWW2+Vt7t37y5vf/755/L2/Pnz\\\n",
       "5e3t27fL28nJyfK2c+6jc1bm1VdfLW9feOGF8vbPP/8sb69du1be7tu3b5Dtb7/9Vt4uLS2Vt52/\\\n",
       "447O33HnnIpTJgDwlIAAEBIQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQGalTJqurq+Vt56TA\\\n",
       "UK+7uLhY3s7Ozpa3R48eLW/feOON8vby5cvlbefkyPz8fHnb+dl+/PHH8nbbtm3l7YEDB8rb/fv3\\\n",
       "l7cLCwvlbeezOHTo0CDboc72dE6ZdM6IjI+Pl7dD/c2PGt9AAIgICAARAQEgIiAARAQEgIiAABAR\\\n",
       "EAAiAgJAREAAiAgIAJGROmWyHnTOGkxPT5e3O3bsKG87ZznOnTtX3l64cKG8PXPmTHm7a9eu8nbT\\\n",
       "pvq/eQ4fPlzeds6ITE5Olredky5bt24tbzu/D/fv3y9v7927V95ev369vP3ll1/K287Zk85n0Tl7\\\n",
       "8iSfJ+nwDQSAiIAAEBEQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQccrkMVtZWRnkde/cuVPe\\\n",
       "nj59epBnOHnyZHn7999/l7e7d+8ubzunTKampsrb1dXV8rbzGW/evHmQ192/f39523Ho0KHytnOC\\\n",
       "pnO2Z3FxsbxdWloqbzu/O51TJp3fnVE7keIbCAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgI\\\n",
       "ABEBASDilEnBUOcHOq979+7d8vbbb78tb2/evFnezs/Pl7edExOdZ+ic+xgfHy9vO8/bMTk5Ocgz\\\n",
       "zM3NlbdHjhwpb48dO1bedk6ZfPnll+Vt5+9iPZwn6RjqddeKbyAARAQEgIiAABAREAAiAgJAREAA\\\n",
       "iAgIABEBASAiIABEBASAyEidMumcCeicQFgPZw0ePnxY3v7333+DPMPCwkJ52zkj0nmG9XBWprPt\\\n",
       "nF4Z6vehY2pqqrz94YcfyttLly6Vt52TOUP9nlHjGwgAEQEBICIgAEQEBICIgAAQERAAIgICQERA\\\n",
       "AIgICAARAQEgMlKnTDrnSYYyMVF/Szdv3lzeLi4ulred8xmPHj0qbzs/W+cZhjLUiZTO71nnfVhe\\\n",
       "Xi5vO5/FzMxMeXvr1q3ytnPK5OLFi+Vt5zxJ53NbD6dMhjrFs1bW/r+4AGxIAgJAREAAiAgIABEB\\\n",
       "ASAiIABEBASAiIAAEBEQACICAkBkpE6ZDHWqoHNiovMMu3fvLm875yju3LlT3j548KC87ZxT6bwP\\\n",
       "Q52gWQ/P0Dld0Xl/33vvvfL23XffLW+vXbtW3nbOk3T+hjrnX9bD+aInmXcfgIiAABAREAAiAgJA\\\n",
       "REAAiAgIABEBASAiIABEBASAiIAAEBmpUyZD6ZxLmJiov6Xbt28vbw8dOlTe7tu3r7ztPO/3339f\\\n",
       "3v7000/lbefkyNLSUnk7Pj5e3nZ03rOFhYXydufOneXtsWPHytvjx4+XtydOnChvz549W952Tpl0\\\n",
       "PrehzhcNZaM97//HNxAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAxCmTgs4pk852\\\n",
       "ZWWlvO2cJ3n99dfL28nJyfL2n3/+KW+vXLkyyOt2zoiMjY2Vt533oaNzwqPzGb/22mvl7fnz58vb\\\n",
       "c+fOlbdzc3Plbef97XzGrC3fQACICAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARNwMK\\\n",
       "OucoOm7fvl3eXr9+vbztnI3onMTovA+d8xkXL14sb6enp8vbe/fulbczMzPlbedczfPPP1/eHj16\\\n",
       "tLydmpoqb0+cOFHedj6Lznu2uLhY3g6lc9pmdXV1wCcZHb6BABAREAAiAgJAREAAiAgIABEBASAi\\\n",
       "IABEBASAiIAAEBEQACJOmRR0Tld0TiA8fPiwvL1y5Up5e/bs2fL2yJEj5e2HH35Y3q6srJS333zz\\\n",
       "TXnbOeGxffv28vbgwYPl7f79+8vb+/fvl7ezs7Pl7cmTJ8vbzlmZzu9k5zPu/A2xcfhUAYgICAAR\\\n",
       "AQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIAJGROmUyNjZW3nZOjnR0TjY8evSovP3rr7/K2wsX\\\n",
       "LpS3X3zxRXn70UcflbebN28ub48fP17ezs/Pl7fvvPNOedt53j179pS3Z86cKW9Pnz5d3n711Vfl\\\n",
       "7Y0bN8rb9XCepPMMrC3fQACICAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICACRsdWhbnqs\\\n",
       "gQMHDgzyup23qHPeofO6ne2OHTvK29nZ2fL2zp075e2uXbvK2857NjMzU94+ePCgvN26dWt5OzFR\\\n",
       "vwDUOUFz9+7d8nZubq687Tzv8vJyeTvU2ROnTP5P53dnrfgGAkBEQACICAgAEQEBICIgAEQEBICI\\\n",
       "gAAQERAAIgICQERAAIg8sadMOj/22NhY8jiP1VCnICYnJwd5hs5JjG3btpW3U1NT5W3n9ErnfehY\\\n",
       "WFgobzvv2VDndRYXF8vbzomUoc72dP4218PrdjhlAsDIEhAAIgICQERAAIgICAARAQEgIiAARAQE\\\n",
       "gIiAABAREAAi9VsEPHZDnUDovG7nfMZQz/Dw4cPy9sGDB+Xt0tJSeds5/9J53c65j47x8fHytvO8\\\n",
       "nZMunfesY6i/i/VwnmQ9nEV6nHwDASAiIABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIgAESe\\\n",
       "2FMmQ50U6LxuZ9s5GzHUyYbFxcXytnMSY6hzKp1zHx1DfW6d7Xo4gzPUM2zaNMy/a4d63g6nTADg\\\n",
       "KQEBICQgAEQEBICIgAAQERAAIgICQERAAIgICAARAQEgMra6Hv7/fgA2HN9AAIgICAARAQEgIiAA\\\n",
       "RAQEgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIg\\\n",
       "AEQEBICIgAAQERAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAi\\\n",
       "IABEBASAiIAAEBEQACICAkBEQACICAgAEQEBIPI/0jCFa/xJsggAAAAASUVORK5CYII=\\\n",
       "\"\n",
       "  frames[10] = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90\\\n",
       "bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9h\\\n",
       "AAAPYQGoP6dpAAAOw0lEQVR4nO3cy26VhdvGYUtbWqCCbEQ21ZgQMURjcIcTEz0AHHkAJh6JiWdh\\\n",
       "wiGYODHKwJCgIyHGBCQqRomAoEDZV+n2P/gO4HueO7xpu7iu8Z2Vt2u1/lgDn7HV1dXVpwCgadNa\\\n",
       "PwAAG5OAABAREAAiAgJAREAAiAgIABEBASAiIABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIg\\\n",
       "AEQEBICIgAAQERAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAi\\\n",
       "IABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARAQEg\\\n",
       "MrHWD/A47d+/v7wdGxsb8Ek2js77sLq6OuCT1HjeYZ9hZWWlvN20qf7vz/XwWawHnc/i6tWrAz7J\\\n",
       "4+EbCAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAyUqdMnFbo22jvQ+fUxlBnRDba\\\n",
       "eZL18LN1thvt73io93cj8A0EgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEBASAiIAAEBmpUybr\\\n",
       "4azBejhzMcqGOgXRed318Bl3Trp0ToN0tktLS4O87kb7u1gPvw9rxTcQACICAkBEQACICAgAEQEB\\\n",
       "ICIgAEQEBICIgAAQERAAIgICQGSkTpmsB51TBRvtBMJGe96Ozs/WOSMy1OmVjs4ZkYWFhUFet/P7\\\n",
       "MNTvziifU1krvoEAEBEQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQERAAIk6ZrKGhziWM8jmV\\\n",
       "jqF+tqFOYiwtLZW3W7ZsKW87nn766fK2c/ak87Oth/Mv1PgGAkBEQACICAgAEQEBICIgAEQEBICI\\\n",
       "gAAQERAAIgICQERAAIiM1CmToU54bDRDndroGOr9XV5eLm875zOeffbZ8nao37OJifqf4549e8rb\\\n",
       "l156qbydnZ0tb0+dOlXenjt3rrwdHx8fZMvj5xsIABEBASAiIABEBASAiIAAEBEQACICAkBEQACI\\\n",
       "CAgAEQEBIDJSp0xG+TxJx1DnSTonUjqfRWd74MCB8vbtt98ub/fu3Vvebtu2rbydn58vb6enp8vb\\\n",
       "znt29OjR8vbFF18sb+/fv1/edk6OXL58eZBnGOrv4knmGwgAEQEBICIgAEQEBICIgAAQERAAIgIC\\\n",
       "QERAAIgICAARAQEgMrY6Qv9/f+fMxXrQOUfR+ZiGOumytLRU3m7ZsqW8PXbsWHn75ptvlredsxy3\\\n",
       "bt0qb2/evFnezs3Nlbedz+38+fPl7a5du8rbl19+ubzdt29feds5/3Lq1KlBtp3f387fW2fbOQd0\\\n",
       "9erV8nat+AYCQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiEys9QM8yYa6ItN53YmJ\\\n",
       "+q/AUKdMPvnkk/J2fHy8vP3000/L2++++668nZ6eLm87Oq/766+/lrfPPPNMeXvv3r3y9uOPPy5v\\\n",
       "X3nllfL266+/Lm9XVlbK26FO/Ax19mQj8A0EgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEBASA\\\n",
       "iIAAEBmpUyadUwVDnRQY6hk62865j507d5a3MzMz5e3BgwfL286JlIsXL5a3n3/+eXnb+dy2bt1a\\\n",
       "3k5OTpa3nTMinbMnnff35s2b5e2NGzfK299//728/eOPP8rbTZvq/wZeXFwsbzu/D52/t1HjGwgA\\\n",
       "EQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARAQEgMlKnTIY6TzKUzvN2Tlfs2LGjvH3//ffL\\\n",
       "28OHD5e3U1NT5W3nzMVnn31W3j733HPl7b///lvebt68ubztfBZ79+4tb+/fv1/edn62PXv2lLed\\\n",
       "ky6XLl0qb+/evVveLi8vl7cdnb/NztmTznYj8A0EgIiAABAREAAiAgJAREAAiAgIABEBASAiIABE\\\n",
       "BASAiIAAEBmpUyadMwErKyvl7aZN9c52nmFiov72d7YffPBBefvWW2+Vt7t37y5vf/755/L2/Pnz\\\n",
       "5e3t27fL28nJyfK2c+6jc1bm1VdfLW9feOGF8vbPP/8sb69du1be7tu3b5Dtb7/9Vt4uLS2Vt52/\\\n",
       "447O33HnnIpTJgDwlIAAEBIQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQGalTJqurq+Vt56TA\\\n",
       "UK+7uLhY3s7Ozpa3R48eLW/feOON8vby5cvlbefkyPz8fHnb+dl+/PHH8nbbtm3l7YEDB8rb/fv3\\\n",
       "l7cLCwvlbeezOHTo0CDboc72dE6ZdM6IjI+Pl7dD/c2PGt9AAIgICAARAQEgIiAARAQEgIiAABAR\\\n",
       "EAAiAgJAREAAiAgIAJGROmWyHnTOGkxPT5e3O3bsKG87ZznOnTtX3l64cKG8PXPmTHm7a9eu8nbT\\\n",
       "pvq/eQ4fPlzeds6ITE5Olredky5bt24tbzu/D/fv3y9v7927V95ev369vP3ll1/K287Zk85n0Tl7\\\n",
       "8iSfJ+nwDQSAiIAAEBEQACICAkBEQACICAgAEQEBICIgAEQEBICIgAAQccrkMVtZWRnkde/cuVPe\\\n",
       "nj59epBnOHnyZHn7999/l7e7d+8ubzunTKampsrb1dXV8rbzGW/evHmQ192/f39523Ho0KHytnOC\\\n",
       "pnO2Z3FxsbxdWloqbzu/O51TJp3fnVE7keIbCAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgI\\\n",
       "ABEBASDilEnBUOcHOq979+7d8vbbb78tb2/evFnezs/Pl7edExOdZ+ic+xgfHy9vO8/bMTk5Ocgz\\\n",
       "zM3NlbdHjhwpb48dO1bedk6ZfPnll+Vt5+9iPZwn6RjqddeKbyAARAQEgIiAABAREAAiAgJAREAA\\\n",
       "iAgIABEBASAiIABEBASAyEidMumcCeicQFgPZw0ePnxY3v7333+DPMPCwkJ52zkj0nmG9XBWprPt\\\n",
       "nF4Z6vehY2pqqrz94YcfyttLly6Vt52TOUP9nlHjGwgAEQEBICIgAEQEBICIgAAQERAAIgICQERA\\\n",
       "AIgICAARAQEgMlKnTDrnSYYyMVF/Szdv3lzeLi4ulred8xmPHj0qbzs/W+cZhjLUiZTO71nnfVhe\\\n",
       "Xi5vO5/FzMxMeXvr1q3ytnPK5OLFi+Vt5zxJ53NbD6dMhjrFs1bW/r+4AGxIAgJAREAAiAgIABEB\\\n",
       "ASAiIABEBASAiIAAEBEQACICAkBkpE6ZDHWqoHNiovMMu3fvLm875yju3LlT3j548KC87ZxT6bwP\\\n",
       "Q52gWQ/P0Dld0Xl/33vvvfL23XffLW+vXbtW3nbOk3T+hjrnX9bD+aInmXcfgIiAABAREAAiAgJA\\\n",
       "REAAiAgIABEBASAiIABEBASAiIAAEBmpUyZD6ZxLmJiov6Xbt28vbw8dOlTe7tu3r7ztPO/3339f\\\n",
       "3v7000/lbefkyNLSUnk7Pj5e3nZ03rOFhYXydufOneXtsWPHytvjx4+XtydOnChvz549W952Tpl0\\\n",
       "PrehzhcNZaM97//HNxAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAxCmTgs4pk852\\\n",
       "ZWWlvO2cJ3n99dfL28nJyfL2n3/+KW+vXLkyyOt2zoiMjY2Vt533oaNzwqPzGb/22mvl7fnz58vb\\\n",
       "c+fOlbdzc3Plbef97XzGrC3fQACICAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICAARNwMK\\\n",
       "OucoOm7fvl3eXr9+vbztnI3onMTovA+d8xkXL14sb6enp8vbe/fulbczMzPlbedczfPPP1/eHj16\\\n",
       "tLydmpoqb0+cOFHedj6Lznu2uLhY3g6lc9pmdXV1wCcZHb6BABAREAAiAgJAREAAiAgIABEBASAi\\\n",
       "IABEBASAiIAAEBEQACJOmRR0Tld0TiA8fPiwvL1y5Up5e/bs2fL2yJEj5e2HH35Y3q6srJS333zz\\\n",
       "TXnbOeGxffv28vbgwYPl7f79+8vb+/fvl7ezs7Pl7cmTJ8vbzlmZzu9k5zPu/A2xcfhUAYgICAAR\\\n",
       "AQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIAJGROmUyNjZW3nZOjnR0TjY8evSovP3rr7/K2wsX\\\n",
       "LpS3X3zxRXn70UcflbebN28ub48fP17ezs/Pl7fvvPNOedt53j179pS3Z86cKW9Pnz5d3n711Vfl\\\n",
       "7Y0bN8rb9XCepPMMrC3fQACICAgAEQEBICIgAEQEBICIgAAQERAAIgICQERAAIgICACRsdWhbnqs\\\n",
       "gQMHDgzyup23qHPeofO6ne2OHTvK29nZ2fL2zp075e2uXbvK2857NjMzU94+ePCgvN26dWt5OzFR\\\n",
       "vwDUOUFz9+7d8nZubq687Tzv8vJyeTvU2ROnTP5P53dnrfgGAkBEQACICAgAEQEBICIgAEQEBICI\\\n",
       "gAAQERAAIgICQERAAIg8sadMOj/22NhY8jiP1VCnICYnJwd5hs5JjG3btpW3U1NT5W3n9ErnfehY\\\n",
       "WFgobzvv2VDndRYXF8vbzomUoc72dP4218PrdjhlAsDIEhAAIgICQERAAIgICAARAQEgIiAARAQE\\\n",
       "gIiAABAREAAi9VsEPHZDnUDovG7nfMZQz/Dw4cPy9sGDB+Xt0tJSeds5/9J53c65j47x8fHytvO8\\\n",
       "nZMunfesY6i/i/VwnmQ9nEV6nHwDASAiIABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIgAESe\\\n",
       "2FMmQ50U6LxuZ9s5GzHUyYbFxcXytnMSY6hzKp1zHx1DfW6d7Xo4gzPUM2zaNMy/a4d63g6nTADg\\\n",
       "KQEBICQgAEQEBICIgAAQERAAIgICQERAAIgICAARAQEgMra6Hv7/fgA2HN9AAIgICAARAQEgIiAA\\\n",
       "RAQEgIiAABAREAAiAgJAREAAiAgIABEBASAiIABEBASAiIAAEBEQACICAkBEQACICAgAEQEBICIg\\\n",
       "AEQEBICIgAAQERAAIgICQERAAIgICAARAQEgIiAARAQEgIiAABAREAAiAgJAREAAiAgIABEBASAi\\\n",
       "IABEBASAiIAAEBEQACICAkBEQACICAgAEQEBIPI/0jCFa/xJsggAAAAASUVORK5CYII=\\\n",
       "\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        anim6f754011198942b2973ad7a65041d684 = new Animation(frames, img_id, slider_id, 1000.0,\n",
       "                                 loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.animation as animation\n",
    "from IPython.display import HTML\n",
    "\n",
    "img_list = trainer.img_list\n",
    "fig = plt.figure(figsize=(4, 4))\n",
    "plt.axis(\"off\")\n",
    "ims = [[plt.imshow(i.detach().cpu().numpy()[0, 0], animated=True, cmap='gray')] for i in img_list]\n",
    "ani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True)\n",
    "\n",
    "HTML(ani.to_jshtml())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **FID SCORE**\n",
    "\n",
    "https://www.kaggle.com/code/ibtesama/gan-in-pytorch-with-fid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# trainer.evaluate_fid(test_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated and saved a total of 10000 fake images to generated_images_wgan.\n"
     ]
    }
   ],
   "source": [
    "# Set device\n",
    "device = torch.device(\"cuda:1\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Set model to evaluation mode\n",
    "model.eval()\n",
    "\n",
    "# Generate fake images\n",
    "num_samples = 10000  # Change this to the desired number of fake images\n",
    "num_latents = 64  # Change this based on your GAN architecture\n",
    "\n",
    "output_directory = \"generated_images_wgan\"\n",
    "os.makedirs(output_directory, exist_ok=True)\n",
    "\n",
    "batch_size = 2048  # Adjust the batch size based on your available memory\n",
    "\n",
    "for batch_idx in range(num_samples // batch_size):\n",
    "    # Generate random latent vectors for each batch\n",
    "    z_fake = torch.randn(batch_size, num_latents, device=device)\n",
    "\n",
    "    # Generate fake images using the generator\n",
    "    with torch.no_grad():\n",
    "        fake_images = model.g(z_fake).detach().cpu()\n",
    "\n",
    "    # Save generated images for each batch\n",
    "    for i in range(batch_size):\n",
    "        image_path = os.path.join(output_directory, f\"fake_image_{batch_idx * batch_size + i + 1}.png\")\n",
    "        save_image(fake_images[i], image_path)\n",
    "\n",
    "    #print(f\"Generated and saved {batch_size} fake images for batch {batch_idx + 1}.\")\n",
    "\n",
    "print(f\"Generated and saved a total of {num_samples} fake images to {output_directory}.\")\n",
    "\n",
    "# # Create a directory to save the MNIST images\n",
    "# mnist_directory = \"mnist_images_wgan\"\n",
    "# os.makedirs(mnist_directory, exist_ok=True)\n",
    "\n",
    "# # MNIST data loader\n",
    "# mnist_loader = torch.utils.data.DataLoader(\n",
    "#     datasets.MNIST(root=\"./data\", train=False, download=True, transform=transforms.ToTensor()),\n",
    "#     batch_size=10000,  # Use the full test set batch size\n",
    "#     shuffle=True,\n",
    "# )\n",
    "\n",
    "# # Get the full batch of MNIST test images\n",
    "# mnist_images, _ = next(iter(mnist_loader))\n",
    "# mnist_images = mnist_images.to(device)\n",
    "\n",
    "# # Save MNIST images\n",
    "# for i in range(num_samples):\n",
    "#     image_path = os.path.join(mnist_directory, f\"mnist_image_{i + 1}.png\")\n",
    "#     save_image(mnist_images[i], image_path)\n",
    "\n",
    "# print(f\"Saved MNIST Test images to {mnist_directory}.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 200/200 [00:10<00:00, 19.98it/s]\n",
      "100%|█████████████████████████████████████████| 164/164 [00:07<00:00, 20.59it/s]\n",
      "FID:  49.9483332913274\n"
     ]
    }
   ],
   "source": [
    "!python -m pytorch_fid  'mnist_images_gan'  'generated_images_wgan' --device cuda:1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# !rm -rf generated_images_wgan\n",
    "# !rm -rf mnist_images_wgan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}