seminars/seminar-3/NN_regularization_practice.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "a_NFNi16lDRI",
      "metadata": {
        "id": "a_NFNi16lDRI"
      },
      "source": [
        "# Regularization tricks for NN"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "2b193247",
      "metadata": {
        "id": "2b193247"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "os.environ[\"CUDA_DEVICE_ORDER\"]=\"PCI_BUS_ID\"  \n",
        "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\" # change 0  with whatever card is available"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9b74fc4c",
      "metadata": {
        "id": "9b74fc4c"
      },
      "source": [
        "## Dropout\n",
        "\n",
        "- It has a hyperparameter $p \\in [0, 1]$ which is a probability of zero out\n",
        "- Different behaviour in train and test stages\n",
        "- Induce sparsity of activations\n",
        "- Formally it is a layer $f$ that\n",
        "  - in train: $f(x) = m * x$, where $m$ is a mask tensor such that for example $$m_{ij} = \\begin{cases} 1, & \\text{with probability } p \\\\ 0, & \\text{with probability } 1-p \\end{cases}$$ \n",
        "  and  $*$ means elementwise product\n",
        "  - in test: $f(x) = px$ to preserve expected value\n",
        "- Different extensions that make forward pass in training stochastic and \"marginalized\" it in inference stage. What can you propose as an example of such methods?\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "39ABeyB3jtSz",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "39ABeyB3jtSz",
        "outputId": "f7e47286-7a7f-480b-df4b-5561f57cefb1"
      },
      "outputs": [],
      "source": [
        "!pip install wandb -q\n",
        "!wandb login"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "c820f6ef",
      "metadata": {
        "id": "c820f6ef"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from torchvision import datasets, transforms\n",
        "import torch.nn.functional as F\n",
        "import copy\n",
        "import wandb"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "01f04bc9",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "01f04bc9",
        "outputId": "d14d746e-bed9-44e4-93fc-b74c2822f8d4"
      },
      "outputs": [],
      "source": [
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "print(device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "eebdef08",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447,
          "referenced_widgets": [
            "a9b259fd21334cef9c6a15094b587706",
            "f1bc6b4bca8f463e9a0f8c6c06ee2231",
            "c32f88131ce7417c83fbe34de3a9b2a9",
            "3f885b2b34c546ed99257fcbd3502d61",
            "851aaa65665f4599b217cdc7b6f179df",
            "6aa47870a67b4600a80863865c70f902",
            "b5a008397ffc4297937ab302fab67f34",
            "3f8bc06225e3454a98145c5f9fbb2434",
            "b2d59d6f38c94a9899107dad087449d8",
            "76bc0639e95d4c0f9283f1b83217c0b7",
            "394163f60bc749a7861d23260f0954cc",
            "988d236eb1f14936b4e5f1182360dd1a",
            "cb4a6d719cbb4da3ad91621e8a838250",
            "dc73530c83744167bd25b05b417e28a0",
            "f2e0e812b5ea4b7795b8978be056c82e",
            "b6e84644c9ae46ff87abf7afa53fc88c",
            "25b89ea96ce743b48885db0a4043be63",
            "f2b5e6132c3d4c25bb0013468decd49d",
            "506ddc0ae32d46069ebb0b01072b7315",
            "14299d1b86dd4bc282ce2839149bb164",
            "98ba5ea41d3f44bab99e7afc217b8510",
            "1e0515b3ad2648eea23b7eb28292faa4",
            "a18865f1446d46739d036623a2f4c1b9",
            "43c33354ca8b40d1842d77c3fc85b0ec",
            "e5742f85c21148288d1f27c5ce7b5842",
            "b1e6b5a0799c4714af41e2300e1a103d",
            "4be593f3a3504a8193e16a477ccefe5d",
            "fd9a41308c964b679b9ea1a7a8321267",
            "5590bb0db1ac433fbbda9dc35eff815e",
            "ace09eeabde4415faa1dba06ef35140e",
            "e24d990f58114022baa5bb4c36e47280",
            "9e8057197c934d858a4a15e236c79191",
            "2a3106b795dd40ecaecc8a35db705f83",
            "abfdc31b4490489caf4d4115c8670892",
            "aec995c2c7974f20a0a24ede8fd226ab",
            "e11109b3b34f42fc95a2af72d74265cd",
            "8fa3c6b6e5544569bc90e29ea3aecfc1",
            "80b1cc9c6aa4466abbb34f447927440b",
            "6ac68b0450bb408ab29c7f13a2dfaaa9",
            "31a397c4da834a368377db5220021ec3",
            "7055aab9e9754befa98a4f26303ccfad",
            "50d8ca00caac459ebeca1da1d5793d60",
            "cbc48f2ca9e94012be032efba30f9b1f",
            "8606168802f542f793c47cfb9fbc8c94"
          ]
        },
        "id": "eebdef08",
        "outputId": "ca1fb51e-0a9b-44b3-ffcc-a8e48e3846cc"
      },
      "outputs": [],
      "source": [
        "batch_size = 1000\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(datasets.MNIST('../data', train=True, download=True,\n",
        "                                           transform=transforms.Compose([\n",
        "                                           transforms.ToTensor()\n",
        "                                           ])),\n",
        "                            batch_size=batch_size, shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(datasets.MNIST('../data', train=False, download=True,\n",
        "                                                           transform=transforms.Compose([\n",
        "                                                           transforms.ToTensor()])),\n",
        "                batch_size=batch_size, shuffle=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "8d70362f",
      "metadata": {
        "id": "8d70362f"
      },
      "outputs": [],
      "source": [
        "class MLP(nn.Module):\n",
        "  def __init__(self, num_layers, hidden_dim):\n",
        "    super(MLP, self).__init__()\n",
        "    self.layers = nn.ModuleList([nn.Linear(28*28, hidden_dim)])\n",
        "    self.nonlinearity = nn.ReLU()\n",
        "    self.layers += nn.ModuleList([nn.Linear(hidden_dim, hidden_dim) for i in range(num_layers)])\n",
        "    self.final = nn.Linear(hidden_dim, 10)\n",
        "  def forward(self, x):\n",
        "    # print(x.shape)\n",
        "    x = x.view(-1, 28*28)\n",
        "    for l in self.layers:\n",
        "      x = l(x)\n",
        "      x = self.nonlinearity(x)\n",
        "    x = self.final(x)\n",
        "    return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "b6d35d0b",
      "metadata": {
        "id": "b6d35d0b"
      },
      "outputs": [],
      "source": [
        "def train(model, train_loader, optimizer, epoch, log_interval):\n",
        "    model.train()\n",
        "    current_conv = []\n",
        "    crit = nn.CrossEntropyLoss()\n",
        "    for batch_idx, (data, target) in enumerate(train_loader):\n",
        "        data, target = data.to(device), target.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        output = model(data)\n",
        "        loss = crit(output, target)\n",
        "        loss.backward()\n",
        "        current_conv.append(loss.detach().cpu().item())\n",
        "        optimizer.step()\n",
        "        if batch_idx % log_interval == 0:\n",
        "            train_loss = loss.item()\n",
        "            wandb.log({\n",
        "                \"Train loss\": train_loss,\n",
        "                \"epoch\": epoch\n",
        "            })\n",
        "            print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n",
        "                epoch, batch_idx * len(data), len(train_loader.dataset),\n",
        "                100. * batch_idx / len(train_loader), train_loss))\n",
        "    return current_conv\n",
        "\n",
        "def test(model, test_loader, train_loader):\n",
        "    model.eval()\n",
        "    test_loss = 0\n",
        "    correct = 0\n",
        "    crit = nn.CrossEntropyLoss(reduction=\"mean\")\n",
        "    with torch.no_grad():\n",
        "        for data, target in test_loader:\n",
        "            data, target = data.to(device), target.to(device)\n",
        "            output = model(data)\n",
        "            test_loss += crit(output, target).item() # sum up batch loss\n",
        "            pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
        "            correct += pred.eq(target.view_as(pred)).sum().item()\n",
        "\n",
        "    test_loss /= len(test_loader.dataset)\n",
        "    test_accuracy = 100. * correct / len(test_loader.dataset)\n",
        "    wandb.log({\n",
        "                \"Test loss\": test_loss,\n",
        "                \"epoch\": epoch,\n",
        "                \"Test accuracy\": test_accuracy\n",
        "            })\n",
        "    print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
        "        test_loss, correct, len(test_loader.dataset),\n",
        "        test_accuracy))\n",
        "    train_loss = 0\n",
        "    correct = 0\n",
        "    with torch.no_grad():\n",
        "        for data, target in train_loader:\n",
        "            data, target = data.to(device), target.to(device)\n",
        "            output = model(data)\n",
        "            train_loss += crit(output, target).item() # sum up batch loss\n",
        "            pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
        "            correct += pred.eq(target.view_as(pred)).sum().item()\n",
        "            \n",
        "    train_loss /= len(train_loader.dataset)\n",
        "\n",
        "    return train_loss, test_loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "fc8469af",
      "metadata": {
        "id": "fc8469af"
      },
      "outputs": [],
      "source": [
        "config = dict(\n",
        "    model = \"FC\",\n",
        "    lr = 5e-4,\n",
        "    n_epoch = 20,\n",
        "    log_interval = 10\n",
        ")\n",
        "\n",
        "mlp_no_dropout = MLP(10, 1000).to(device)\n",
        "initial_mlp_model = copy.deepcopy(mlp_no_dropout)\n",
        "conv_mlp_no_dropout = []\n",
        "adam_opt = torch.optim.Adam(mlp_no_dropout.parameters(), lr=config[\"lr\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c10021ed",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c10021ed",
        "outputId": "e14aa91d-c0a1-461f-e217-d9d86a5759cc"
      },
      "outputs": [],
      "source": [
        "mlp_no_dropout"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "GRWAL0XroIzg",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GRWAL0XroIzg",
        "outputId": "ffb11dda-1a92-4d69-8073-6f3b91d5e88c"
      },
      "outputs": [],
      "source": [
        "def count_parameters(model):\n",
        "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
        "\n",
        "print(f\"{count_parameters(mlp_no_dropout)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "16e63fbd",
      "metadata": {
        "id": "16e63fbd"
      },
      "outputs": [],
      "source": [
        "epoch_train_loss = []\n",
        "epoch_test_loss = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "26f086cb",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "26f086cb",
        "outputId": "61fb1141-e9cd-4463-a15c-ae21fbb71e5f",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "wandb.init(\n",
        "      # Set the project where this run will be logged\n",
        "      project=\"NN practice. Dropout\", \n",
        "      # Track hyperparameters and run metadata\n",
        "      config=config,\n",
        "      tags = [\"No Dropout\"]\n",
        "      )\n",
        "for epoch in range(1, config[\"n_epoch\"] + 1):\n",
        "  cur_conv = train(mlp_no_dropout, train_loader, adam_opt, epoch, config[\"log_interval\"])\n",
        "  conv_mlp_no_dropout = conv_mlp_no_dropout + cur_conv\n",
        "  cur_train_loss, cur_test_loss = test(mlp_no_dropout, test_loader, train_loader)\n",
        "  epoch_train_loss.append(cur_train_loss)\n",
        "  epoch_test_loss.append(cur_test_loss)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "21eab052",
      "metadata": {
        "id": "21eab052",
        "outputId": "97f60b2d-2123-445c-ec41-d7b769e6eab4"
      },
      "outputs": [],
      "source": [
        "plt.plot(conv_mlp_no_dropout)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "41f9ae69",
      "metadata": {
        "id": "41f9ae69",
        "outputId": "c9014c81-c506-4e27-8e42-e532b1bb0782"
      },
      "outputs": [],
      "source": [
        "plt.plot(epoch_train_loss, label=\"Train\")\n",
        "plt.plot(epoch_test_loss, label=\"Test\")\n",
        "plt.legend()\n",
        "plt.yscale(\"log\")\n",
        "plt.title(\"No dropout\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1f515211",
      "metadata": {
        "id": "1f515211"
      },
      "outputs": [],
      "source": [
        "class RegularizedMLP(nn.Module):\n",
        "  def __init__(self, mlp, num_layers, hidden_dim):\n",
        "    super(RegularizedMLP, self).__init__()\n",
        "    self.layers = [nn.Linear(28 * 28, hidden_dim)]\n",
        "    self.layers += [nn.Linear(hidden_dim, hidden_dim) for i in range(num_layers)]\n",
        "    for l, l0 in zip(self.layers, mlp.layers):\n",
        "      l.weight = copy.deepcopy(l0.weight)\n",
        "      l.bias = copy.deepcopy(l0.bias)\n",
        "    \n",
        "    self.layers = nn.ModuleList(self.layers)\n",
        "    \n",
        "    self.nonlinearity = nn.ReLU()\n",
        "    self.final = nn.Linear(hidden_dim, 10)\n",
        "    self.final.weight = copy.deepcopy(mlp.final.weight)\n",
        "    self.final.bias = copy.deepcopy(mlp.final.bias)\n",
        "    self.dropout = nn.Dropout(0.5)\n",
        "  def forward(self, x):\n",
        "    x = x.view(-1, 28*28)\n",
        "    for l in self.layers:\n",
        "      x = l(x)\n",
        "      x = self.dropout(x)\n",
        "      x = self.nonlinearity(x)\n",
        "    x = self.final(x)\n",
        "    return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "13d428ee",
      "metadata": {
        "id": "13d428ee"
      },
      "outputs": [],
      "source": [
        "mlp_dropout = RegularizedMLP(initial_mlp_model, 5, 1000)\n",
        "adam_opt_drop = torch.optim.Adam(mlp_dropout.parameters(), lr=config[\"lr\"])\n",
        "conv_mlp_dropout = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "51c259d6",
      "metadata": {
        "id": "51c259d6",
        "outputId": "3a04b44b-8640-4282-c650-fd2e81310bf2"
      },
      "outputs": [],
      "source": [
        "mlp_dropout"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f21ed627",
      "metadata": {
        "id": "f21ed627"
      },
      "outputs": [],
      "source": [
        "epoch_train_loss_drop = []\n",
        "epoch_test_loss_drop = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "40ddd75e",
      "metadata": {
        "id": "40ddd75e",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "wandb.init(\n",
        "      # Set the project where this run will be logged\n",
        "      project=\"NN practice. Dropout\", \n",
        "      # Track hyperparameters and run metadata\n",
        "      config=config,\n",
        "      tags = [\"Dropout\"]\n",
        "      )\n",
        "for epoch in range(1, config[\"n_epoch\"] + 1):\n",
        "  cur_conv = train(mlp_dropout, train_loader, adam_opt, epoch, config[\"log_interval\"])\n",
        "  conv_mlp_dropout = conv_mlp_dropout + cur_conv\n",
        "  cur_train_loss, cur_test_loss = test(mlp_no_dropout, test_loader, train_loader)\n",
        "  epoch_train_loss.append(cur_train_loss)\n",
        "  epoch_test_loss.append(cur_test_loss)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e3f5d077",
      "metadata": {
        "id": "e3f5d077",
        "outputId": "1126c9e1-c6b5-4e85-d677-d9055df0ad1f"
      },
      "outputs": [],
      "source": [
        "plt.plot(conv_mlp_dropout, label=\"Dropout\")\n",
        "plt.plot(conv_mlp_no_dropout, label=\"No dropout\")\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e34c201d",
      "metadata": {
        "id": "e34c201d",
        "outputId": "aa96d086-6582-4802-d0a9-3cb4eac06a3b"
      },
      "outputs": [],
      "source": [
        "plt.plot(epoch_train_loss_drop, label=\"Train\")\n",
        "plt.plot(epoch_test_loss_drop, label=\"Test\")\n",
        "plt.legend()\n",
        "plt.yscale(\"log\")\n",
        "plt.title(\"Dropout\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8518c652",
      "metadata": {
        "id": "8518c652",
        "outputId": "e11263ee-34ed-4633-9be4-07ab1e44835a"
      },
      "outputs": [],
      "source": [
        "plt.plot(epoch_train_loss_drop, label=\"Train, dropout\")\n",
        "plt.plot(epoch_train_loss, label=\"Train, no dropout\")\n",
        "plt.plot(epoch_test_loss_drop, label=\"Test, dropout\")\n",
        "plt.plot(epoch_test_loss, label=\"Test, no dropout\")\n",
        "plt.legend()\n",
        "plt.yscale(\"log\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dc886d50",
      "metadata": {
        "id": "dc886d50"
      },
      "source": [
        "## Normalization layers\n",
        "\n",
        "- Batch normalization\n",
        "- Layer normalization\n",
        "- Instance normalization\n",
        "- Group normalization\n",
        "\n",
        "**Q**: what is the difference between them?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "03e463f6",
      "metadata": {
        "id": "03e463f6"
      },
      "outputs": [],
      "source": [
        "x = torch.randn((1000, 3, 32, 32)) + 5\n",
        "bnorm = nn.BatchNorm2d(3)\n",
        "lnorm = nn.LayerNorm((3, 32, 32))\n",
        "inorm = nn.InstanceNorm2d(3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0079c9b2",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0079c9b2",
        "outputId": "7fb85000-477a-434c-8717-4f6b6c3bd2c8"
      },
      "outputs": [],
      "source": [
        "bnorm_res = bnorm(x)\n",
        "print(bnorm_res.shape)\n",
        "print(torch.mean(x[:, 1, :, :]).item())\n",
        "print(torch.mean(bnorm_res[:, 1, :, :]).item())\n",
        "\n",
        "lnorm_res = lnorm(x)\n",
        "print(lnorm_res.shape)\n",
        "print(torch.mean(x[0, :, :, :]).item())\n",
        "print(torch.mean(lnorm_res[0, :, :, :]).item())\n",
        "\n",
        "inorm_res = inorm(x)\n",
        "print(inorm_res.shape)\n",
        "print(torch.mean(x[0, 0, :, :]).item())\n",
        "print(torch.mean(inorm_res[0, 0, :, :]).item())\n",
        "\n",
        "# How to make layer norm and instance norm equal?\n",
        "# print(torch.norm(inorm_res - lnorm_res).item())"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7685a911",
      "metadata": {
        "id": "7685a911"
      },
      "source": [
        "### Now let us check simple CNN and observe the gain from different normalizations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "47b17966",
      "metadata": {
        "id": "47b17966",
        "outputId": "4ec1c456-5894-4b26-9348-92217512098a"
      },
      "outputs": [],
      "source": [
        "batch_size = 1000\n",
        "train_loader = torch.utils.data.DataLoader(datasets.CIFAR10('../data', train=True, download=True,\n",
        "                                           transform=transforms.Compose([\n",
        "                                           transforms.ToTensor(),\n",
        "                                           transforms.Normalize((0.1307,), (0.3081,))\n",
        "                                           ])),\n",
        "                            batch_size=batch_size, shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(datasets.CIFAR10('../data', train=False, transform=transforms.Compose([\n",
        "                                       transforms.ToTensor(),\n",
        "                                       transforms.Normalize((0.1307,), (0.3081,))\n",
        "                            ])),\n",
        "                batch_size=10*batch_size, shuffle=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1109ce5c",
      "metadata": {
        "id": "1109ce5c"
      },
      "outputs": [],
      "source": [
        "class SimpleCNN(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(SimpleCNN, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 32, kernel_size=2)\n",
        "        self.conv2 = nn.Conv2d(32, 64, kernel_size=2)\n",
        "        self.conv3 = nn.Conv2d(64, 128, kernel_size=2)\n",
        "        self.conv4 = nn.Conv2d(128, 256, kernel_size=2)\n",
        "\n",
        "        self.fc1 = nn.Linear(256, 256)\n",
        "        self.fc2 = nn.Linear(256, 10)\n",
        "        self.nonlinearity = nn.ReLU()\n",
        "        self.pooling = nn.MaxPool2d(2)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv1(x)\n",
        "        x = self.nonlinearity(x)\n",
        "        x = self.pooling(x)\n",
        "\n",
        "        x = self.conv2(x)\n",
        "        x = self.nonlinearity(x)\n",
        "        x = self.pooling(x)\n",
        "\n",
        "        x = self.conv3(x)\n",
        "        x = self.nonlinearity(x)\n",
        "        x = self.pooling(x)\n",
        "        \n",
        "        x = self.conv4(x)\n",
        "        x = self.nonlinearity(x)\n",
        "        x = self.pooling(x)\n",
        "        \n",
        "        x = x.view(-1, 256)\n",
        "        x = self.nonlinearity(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "02fe9746",
      "metadata": {
        "id": "02fe9746"
      },
      "outputs": [],
      "source": [
        "cnn_no_norm = SimpleCNN().to(device)\n",
        "initial_cnn_model = copy.deepcopy(cnn_no_norm)\n",
        "conv_cnn_no_norm = []\n",
        "lr = 1e-3\n",
        "n_epoch = 20\n",
        "log_interval = 10\n",
        "adam_opt = torch.optim.Adam(cnn_no_norm.parameters(), lr=lr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b6a5d17b",
      "metadata": {
        "id": "b6a5d17b"
      },
      "outputs": [],
      "source": [
        "train_cnn_epoch = []\n",
        "test_cnn_epoch = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "80941c39",
      "metadata": {
        "id": "80941c39",
        "outputId": "4fb975e3-1ecb-4082-b4dc-34e63d36bbb8"
      },
      "outputs": [],
      "source": [
        "for epoch in range(1, n_epoch + 1):\n",
        "  cur_conv = train(cnn_no_norm, train_loader, adam_opt, epoch, log_interval)\n",
        "  conv_cnn_no_norm = conv_cnn_no_norm + cur_conv\n",
        "  cur_train_loss, cur_test_loss = test(cnn_no_norm, test_loader, train_loader)\n",
        "  train_cnn_epoch.append(cur_train_loss)\n",
        "  test_cnn_epoch.append(cur_test_loss)  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ccc14ba3",
      "metadata": {
        "id": "ccc14ba3",
        "outputId": "b76fa864-8004-48ca-cd06-d26d90519484"
      },
      "outputs": [],
      "source": [
        "plt.plot(conv_cnn_no_norm)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7850f5aa",
      "metadata": {
        "id": "7850f5aa",
        "outputId": "fb51e394-2dbb-4600-a7ac-6750c931aa6b"
      },
      "outputs": [],
      "source": [
        "plt.plot(train_cnn_epoch, label=\"Train\")\n",
        "plt.plot(test_cnn_epoch, label=\"Test\")\n",
        "plt.legend()\n",
        "plt.yscale(\"log\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d8126dcf",
      "metadata": {
        "id": "d8126dcf"
      },
      "outputs": [],
      "source": [
        "class NormalizedCNN(nn.Module):\n",
        "  def __init__(self, cnn, normalization):\n",
        "    super(NormalizedCNN, self).__init__()\n",
        "    \n",
        "    self.nonlinearity = nn.ReLU()\n",
        "    self.pooling = nn.MaxPool2d(2)\n",
        "    self.conv1 = nn.Conv2d(3, 32, kernel_size=2)\n",
        "    self.conv1.weight = copy.deepcopy(cnn.conv1.weight)\n",
        "    if normalization == \"batch_norm\":\n",
        "        self.norm1 = nn.BatchNorm2d(32)\n",
        "    elif normalization == \"layer_norm\":\n",
        "        self.norm1 = nn.LayerNorm((32, 31, 31))\n",
        "    elif normalization == \"instance_norm\":\n",
        "        self.norm1 = nn.InstanceNorm2d(32)\n",
        "        \n",
        "    self.conv2 = nn.Conv2d(32, 64, kernel_size=2)\n",
        "    self.conv2.weight = copy.deepcopy(cnn.conv2.weight)\n",
        "    if normalization == \"batch_norm\":\n",
        "        self.norm2 = nn.BatchNorm2d(64)\n",
        "    elif normalization == \"layer_norm\":\n",
        "        self.norm2 = nn.LayerNorm((64, 14, 14))\n",
        "    elif normalization == \"instance_norm\":\n",
        "        self.norm2 = nn.InstanceNorm2d(64)\n",
        "    \n",
        "    self.conv3 = nn.Conv2d(64, 128, kernel_size=2)\n",
        "    self.conv3.weight = copy.deepcopy(cnn.conv3.weight)\n",
        "    \n",
        "    if normalization == \"batch_norm\":\n",
        "        self.norm3 = nn.BatchNorm2d(128)\n",
        "    elif normalization == \"layer_norm\":\n",
        "        self.norm3 = nn.LayerNorm((128, 6, 6))\n",
        "    elif normalization == \"instance_norm\":\n",
        "        self.norm3 = nn.InstanceNorm2d(128)\n",
        "        \n",
        "    self.conv4 = nn.Conv2d(128, 256, kernel_size=2)\n",
        "    self.conv4.weight = copy.deepcopy(cnn.conv4.weight)\n",
        "    \n",
        "    if normalization == \"batch_norm\":\n",
        "        self.norm4 = nn.BatchNorm2d(256)\n",
        "    elif normalization == \"layer_norm\":\n",
        "        self.norm4 = nn.LayerNorm((256, 2, 2))\n",
        "    elif normalization == \"instance_norm\":\n",
        "        self.norm4 = nn.InstanceNorm2d(256)\n",
        "        \n",
        "    self.fc1 = nn.Linear(256, 256)\n",
        "    self.fc1.weight = copy.deepcopy(cnn.fc1.weight)\n",
        "    self.fc1.bias = copy.deepcopy(cnn.fc1.bias)\n",
        "    self.fc2 = nn.Linear(256, 10)\n",
        "    self.fc2.weight = copy.deepcopy(cnn.fc2.weight)\n",
        "    self.fc2.bias = copy.deepcopy(cnn.fc2.bias)\n",
        "    \n",
        "    \n",
        "  def forward(self, x):\n",
        "    x = self.conv1(x)\n",
        "    x = self.nonlinearity(x)\n",
        "    x = self.norm1(x)\n",
        "    x = self.pooling(x)\n",
        "\n",
        "    x = self.conv2(x)\n",
        "    x = self.nonlinearity(x)\n",
        "    x = self.norm2(x)\n",
        "    x = self.pooling(x)\n",
        "\n",
        "    x = self.conv3(x)\n",
        "    x = self.nonlinearity(x)\n",
        "    x = self.norm3(x)\n",
        "    x = self.pooling(x)\n",
        "\n",
        "    x = self.conv4(x)\n",
        "    x = self.nonlinearity(x)\n",
        "    x = self.norm4(x)\n",
        "    x = self.pooling(x)\n",
        "\n",
        "    x = x.view(-1, 256)\n",
        "    x = self.nonlinearity(self.fc1(x))\n",
        "    x = self.fc2(x)\n",
        "    return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bfa813d1",
      "metadata": {
        "id": "bfa813d1"
      },
      "outputs": [],
      "source": [
        "cnn_layer = NormalizedCNN(initial_cnn_model, \"layer_norm\").to(device)\n",
        "adam_opt_cnn_layer = torch.optim.Adam(cnn_layer.parameters(), lr=lr)\n",
        "conv_cnn_layer = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b8a47b5a",
      "metadata": {
        "id": "b8a47b5a",
        "outputId": "d154cd71-584d-47fe-cafc-56144a5924cd"
      },
      "outputs": [],
      "source": [
        "cnn_layer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "72ea4b7e",
      "metadata": {
        "id": "72ea4b7e"
      },
      "outputs": [],
      "source": [
        "epoch_train_loss_layernorm = []\n",
        "epoch_test_loss_layernorm = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b34cfd07",
      "metadata": {
        "id": "b34cfd07",
        "outputId": "eada76a1-93a2-475f-bad5-93b3c06596d8",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "for epoch in range(1, n_epoch + 1):\n",
        "  cur_conv = train(cnn_layer, train_loader, adam_opt_cnn_layer, epoch, log_interval)\n",
        "  conv_cnn_layer = conv_cnn_layer + cur_conv\n",
        "  cur_train_loss, cur_test_loss = test(cnn_layer, test_loader, train_loader)\n",
        "  epoch_train_loss_layernorm.append(cur_train_loss)\n",
        "  epoch_test_loss_layernorm.append(cur_test_loss)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "24b9cd8a",
      "metadata": {
        "id": "24b9cd8a",
        "outputId": "3c0a2542-cf00-4556-cdf2-4e57720e1aec"
      },
      "outputs": [],
      "source": [
        "plt.plot(conv_cnn_no_norm, label=\"No norm\")\n",
        "plt.plot(conv_cnn_layer, label=\"Layer norm\")\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9149dd6c",
      "metadata": {
        "id": "9149dd6c",
        "outputId": "b9373863-d572-493b-ec74-5ad30e439824"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(train_cnn_epoch, label=\"Train, no norm\")\n",
        "plt.plot(test_cnn_epoch, label=\"Test, no norm\")\n",
        "plt.plot(epoch_train_loss_layernorm, label=\"Train, layer norm\")\n",
        "plt.plot(epoch_test_loss_layernorm, label=\"Test, layer norm\")\n",
        "plt.legend()\n",
        "plt.yscale(\"log\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5d48eb64",
      "metadata": {
        "id": "5d48eb64"
      },
      "outputs": [],
      "source": [
        "cnn_batch = NormalizedCNN(initial_cnn_model, \"batch_norm\").to(device)\n",
        "adam_opt_cnn_batch = torch.optim.Adam(cnn_batch.parameters(), lr=lr)\n",
        "conv_cnn_batch = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9c6e5ba8",
      "metadata": {
        "id": "9c6e5ba8",
        "outputId": "967b854f-d6ca-4a09-d1d0-bc4176eeb97e"
      },
      "outputs": [],
      "source": [
        "cnn_batch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6be4b37f",
      "metadata": {
        "id": "6be4b37f"
      },
      "outputs": [],
      "source": [
        "epoch_train_loss_batchnorm = []\n",
        "epoch_test_loss_batchnorm = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dadf509c",
      "metadata": {
        "id": "dadf509c",
        "outputId": "2d430394-eb8c-445a-86cc-bd76bcaababd",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "for epoch in range(1, n_epoch + 1):\n",
        "  cur_conv = train(cnn_batch, train_loader, adam_opt_cnn_batch, epoch, log_interval)\n",
        "  conv_cnn_batch = conv_cnn_batch + cur_conv\n",
        "  cur_train_loss, cur_test_loss = test(cnn_batch, test_loader, train_loader)\n",
        "  epoch_train_loss_batchnorm.append(cur_train_loss)\n",
        "  epoch_test_loss_batchnorm.append(cur_test_loss)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fd3ef756",
      "metadata": {
        "id": "fd3ef756",
        "outputId": "76357ce4-b1ea-45fe-866f-89079fbe5314"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fa6242d7a30>"
            ]
          },
          "execution_count": 123,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(conv_cnn_no_norm, label=\"No norm\")\n",
        "plt.plot(conv_cnn_layer, label=\"Layer norm\")\n",
        "plt.plot(conv_cnn_batch, label=\"Batch norm\")\n",
        "plt.yscale(\"log\")\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5f94f437",
      "metadata": {
        "id": "5f94f437",
        "outputId": "95429772-985e-4382-eb80-498dbf868199"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAADFVElEQVR4nOzdd3xT1f/H8Vdmm3TvQSe0QMseZUvZIIqKIqiooOJCBX+KW7YbUBw48UsBUVERBAXZe6+yWgqlLS3QQfdI2zTJ/f2REqhsaElSzvPxyDfJTXLvJ/lK8845554jkyRJQhAEQRAEwU7IrV2AIAiCIAjC9RDhRRAEQRAEuyLCiyAIgiAIdkWEF0EQBEEQ7IoIL4IgCIIg2BURXgRBEARBsCsivAiCIAiCYFdEeBEEQRAEwa4orV1AbTOZTJw5cwYXFxdkMpm1yxEEQRAE4RpIkkRJSQmBgYHI5VduW6l34eXMmTMEBwdbuwxBEARBEG5ARkYGQUFBV3xOvQsvLi4ugPnNu7q6WrkaQRAEQRCuRXFxMcHBwZbv8Supd+HlXFeRq6urCC+CIAiCYGeuZciHGLArCIIgCIJdEeFFEARBEAS7IsKLIAiCIAh2pd6NeREEQbgdSZKEwWDAaDRauxRBuCSFQoFSqayVaUxEeBEEQbBzer2ezMxMdDqdtUsRhCvSarUEBASgVqtvaj/1JrzMmjWLWbNmiV8dgiDcVkwmE6mpqSgUCgIDA1Gr1WKCTsHmSJKEXq/n7NmzpKamEhkZedWJ6K5EJkmSVIv1WV1xcTFubm4UFRWJU6UFQaj3KioqSE1NJTQ0FK1Wa+1yBOGKdDodJ0+eJDw8HEdHxxqPXc/3txiwKwiCUA/czK9YQbhVauu/U/FfuyAIgiAIdkWEF0EQBEEQ7IoIL4IgCEK9EBYWxsyZM61dhnALiPAiCIIg3FIymeyKl0mTJt3Qfnfv3s0zzzxTu8UKNqnenCpd1yqqjDz3016Gtg+mfzN/FHJxKqIgCMKNyMzMtNxeuHAhEyZMICkpybLN2dnZcluSJIxGI0rl1b+ufHx8ardQO6PX6296/hR7IVpertGifafYkHSW0Qv20ffTjfy2OwO9wWTtsgRBEC4iSRI6veGWX6515g1/f3/Lxc3NDZlMZrl/9OhRXFxcWLFiBe3atcPBwYEtW7Zw4sQJ7r33Xvz8/HB2diYmJoY1a9bU2O9/u41kMhmzZ89m8ODBaLVaIiMjWbp06XV9lpMmTaJ169bMnz+fsLAw3NzceOihhygpKbE8p7KykjFjxuDr64ujoyPdunVj9+7dV9xvWFgYH3zwAU8++SQuLi6EhITw/fff13jOoUOH6NWrFxqNBi8vL5555hlKS0stj48cOZL77ruP999/n8DAQJo0aUJaWhoymYzffvuNO+64A41GQ0xMDMeOHWP37t20b98eZ2dn7rzzTs6ePXtdn4UtES0v1+jO5gFkF1UQty2NlNwyXl90kM/WHOPpOxryUIdgtGrxUQqCYBvKq4xET1h5y4+bMKV/rf0tfPPNN5k+fToNGzbEw8ODjIwMBg4cyPvvv4+DgwPz5s1j0KBBJCUlERISctn9TJ48mU8++YRp06bx5ZdfMnz4cE6ePImnp+c113LixAmWLFnC33//TUFBAUOHDuWjjz7i/fffB+D1119n0aJFzJ07l9DQUD755BP69+9PcnLyFY8zY8YMpk6dyttvv80ff/zB888/T2xsLE2aNKGsrIz+/fvTuXNndu/eTU5ODqNGjeLFF18kLi7Oso+1a9fi6urK6tWra+x74sSJzJw5k5CQEJ588kkeeeQRXFxc+Pzzz9FqtQwdOpQJEybwzTffXPPnYEtEy8s18nRS80q/Jmx7qzdvD2yKr4sDmUUVTPk7gW4fr+fLtccp0lVZu0xBEIR6YcqUKfTt25dGjRrh6elJq1atePbZZ2nevDmRkZFMnTqVRo0aXbUlZeTIkTz88MNERETwwQcfUFpayq5du66rFpPJRFxcHM2bN+eOO+7gscceY+3atQCUlZXxzTffMG3aNO68806io6P54Ycf0Gg0/Pjjj1fc78CBAxk9ejQRERG88cYbeHt7s379egB+/vlnKioqmDdvHs2bN6dXr1589dVXzJ8/n+zsbMs+nJycmD17Ns2aNaNZs2aW7ePGjaN///5ERUUxduxY9u7dy/jx4+natStt2rThqaeeshzLHonmguvk7KDkme6NeLxzGIv2neK7jSmk5+uYsfoY321KYXinEJ7qFo6vi+PVdyYIglAHNCoFCVP6W+W4taV9+/Y17peWljJp0iT++ecfMjMzMRgMlJeXk56efsX9tGzZ0nLbyckJV1dXcnJyrquWsLAwXFxcLPcDAgIs+zhx4gRVVVV07drV8rhKpaJDhw4kJiZec23nus7O7TcxMZFWrVrh5ORkeU7Xrl0xmUwkJSXh5+cHQIsWLS45zuXCfV/43Au3Xe/nYEtEeLlBjioFwzuGMqx9MP8cyuSbDSc4mlXCdxtTmLM1jQfbBfFs90aEeInpugVBuLVkMpndd2Vf+KUN5paE1atXM336dCIiItBoNAwZMgS9Xn/F/ahUqhr3ZTIZJtP1jVesjX3U1X7/+zldat/n1rr677baeA/WIrqNbpJSIefe1g1YMfYOfhzRnrYh7ugNJhbsTKfnjA28/Ot+krJKrr4jQRAE4bK2bt3KyJEjGTx4MC1atMDf35+0tDRrl0WjRo1Qq9Vs3brVsq2qqordu3cTHR19w/uNioriwIEDlJWVWbZt3boVuVxOkyZNbqrm+kCEl1oik8noHeXHoue78Oszneje2AejSWJJ/Bn6z9zEqLl72JdeYO0yBUEQ7FJkZCR//vkn8fHxHDhwgEceecQmWg6cnJx4/vnnee211/j3339JSEjg6aefRqfT8dRTT93wfocPH46joyMjRozg8OHDrF+/npdeeonHHnvM0g10OxPhpZbJZDI6NfRi3pMdWPZiNwa28EcmgzWJ2dz/9TYe/n4Hm4+fveZTCgVBEAT49NNP8fDwoEuXLgwaNIj+/fvTtm3bm95vWFjYDU+Kd85HH33EAw88wGOPPUbbtm1JTk5m5cqVeHh43PA+tVotK1euJD8/n5iYGIYMGULv3r356quvbqrW+kIm1bNv0etZUvtWOXG2lG83nGDx/tMYTOaPu0UDN17o2Yh+0f7IxYR3giDcoIqKClJTUwkPD8fRUZwocD10Oh1eXl6sWLGCHj16WLuc28KV/nu9nu9v0fJyCzTycWbag63Y9HpPnugahqNKzqHTRTz30z76fraR3/dkUGW0fvOnIAjC7WT9+vX06tVLBBc7JFperCCvtJK4bWnM3ZZGcYUBgAbuGp6+I5x7WjfA0+n2mN5ZEISbJ1peBHtSWy0vIrxYUUlFFT/vTOeHzankllYCIJNB62B3ejXxpWdTX5oFulpOcxMEQfgvEV4Ee1Jb4cW+JwKwcy6OKp6NbcSILmH8sfcUC3amk5hZzP70QvanFzJj9TH8XB3o2cSXHk186RbpjbOD+L9MEARBuL2Jb0Ib4KhS8GinUB7tFEpmUTnrj55lfVIOW5NzyS6u5NfdGfy6OwOVQkbHcC96NvWlV1Nfwr0vPTmRIAiCINRnotvIhlUajOxMyWfd0RzWJ+VwMk9X4/EwL60lyHQI98RBWXtTcwuCYB9Et5FgT8SYl8uoT+Hlv1LOllqCzK7UfKqM5/+v06oVdI3wpldTX3o28cXfTfwRE4TbgQgvgj0RY15uQw19nGno48yoOxpSWmlgy/Fc1leHmZySSlYnZLM6wbzaaHSAqznINPWhdbAHilqeS0aSJCoNJiqrTFQajFQaTHg5q+1+PRVBEATB9olvGjvl7KBkQHN/BjT3R5IkjpwpZv3RHNYl5RCfUUhCZjEJmcV8tT4ZD62K2MY+tAv1wGiqDh0GExVVxurbxuoQYr5dcUEgORdOKi54vNJgQm+4eF4arVrB4DYNeLxzGE38XS5RtSAIgiDcPNFtVA/llVay6fhZ1h09y8akHMtcMnVFJgOVQl4j0HQI92RE5zD6NfNDpRBzIQpCXbHHbqOrTf8wceLEG56yXyaTsXjxYu67774ber1Qt0S3kXBZXs4ODG4TxOA2QRiMJvalF7LuaA4nzpbioJTjoFTgoJKfv62U46gyX5u3V9+usf38NgeVAscLtimru6S2n8hj3vaTrE7MZldqPrtS8/FzdeDhDiE80iEEX1f7+MMqCELdyszMtNxeuHAhEyZMICkpybLN2dnZGmXZDb1ej1p9m09mKtUzRUVFEiAVFRVZu5Tb1plCnTR95VGp3dRVUugbf0uhb/wtNXrrH2n0gr3SjhO5kslksnaJglBvlJeXSwkJCVJ5ebm1S7khc+bMkdzc3Gps++GHH6SmTZtKDg4OUpMmTaRZs2ZZHqusrJReeOEFyd/fX3JwcJBCQkKkDz74QJIkSQoNDZUAyyU0NPSa64iNjZVeeukl6bXXXpM8PDwkPz8/aeLEiTWec/LkSemee+6RnJycJBcXF+nBBx+UsrKyLrvP1NRUCZAWLVok9ejRQ9JoNFLLli2lbdu21XjeH3/8IUVHR0tqtVoKDQ2Vpk+fXuPx0NBQacqUKdJjjz0mubi4SCNGjLB8bsuWLZMaN24saTQa6YEHHpDKysqkuLg4KTQ0VHJ3d5deeuklyWAwXPPnUNeu9N/r9Xx/i/Ai1JnKKqO0ZP8p6f6vt1pCTOgbf0v9P9so/bQjTSqtqLJ2iYJg9y75ZWAySVJl6a2/3MAPk/+Gl59++kkKCAiQFi1aJKWkpEiLFi2SPD09pbi4OEmSJGnatGlScHCwtGnTJiktLU3avHmz9PPPP0uSJEk5OTkSIM2ZM0fKzMyUcnJyrrmO2NhYydXVVZo0aZJ07Ngxae7cuZJMJpNWrVolSZIkGY1GqXXr1lK3bt2kPXv2SDt27JDatWsnxcbGXnaf58JL06ZNpb///ltKSkqShgwZIoWGhkpVVea/f3v27JHkcrk0ZcoUKSkpSZozZ46k0WikOXPmWPYTGhoqubq6StOnT5eSk5Ol5ORkac6cOZJKpZL69u0r7du3T9q4caPk5eUl9evXTxo6dKh05MgRadmyZZJarZZ+/fXXa/4c6lpthRfRbSTUGbVSzr2tG3Bv6wYcOVPE/O0nWRJ/mqNZJbyz+DAfLT/KA+2CeKxzKI18RDOxINSaKh18EHjrj/v2GVDf3OSZEydOZMaMGdx///0AhIeHk5CQwHfffceIESNIT08nMjKSbt26IZPJCA0NtbzWx8cHAHd3d/z9/a/72C1btmTixIkAREZG8tVXX7F27Vr69u3L2rVrOXToEKmpqQQHBwMwb948mjVrxu7du4mJibnsfseNG8ddd90FwOTJk2nWrBnJyck0bdqUTz/9lN69ezN+/HgAGjduTEJCAtOmTWPkyJGWffTq1YtXX33Vcn/z5s1UVVXxzTff0KhRIwCGDBnC/Pnzyc7OxtnZmejoaHr27Mn69esZNmzYdX8etkyMpBRuiWaBbnz0QEt2vtWHd++KIsxLS0mlgbhtafSesZHHftzJqiNZGE31avy4IAjXoaysjBMnTvDUU0/h7Oxsubz33nucOHECgJEjRxIfH0+TJk0YM2YMq1atqrXjt2zZssb9gIAAcnJyAEhMTCQ4ONgSXACio6Nxd3cnMTHxmvcbEBAAUGO/Xbt2rfH8rl27cvz4cYxGo2Vb+/btL9qvVqu1BBcAPz8/wsLCaowZ8vPzsxyrPhEtL9fhj2N/0CO4B94ab2uXYrfctCpG3dGQJ7uGszk5l3nb0liXlMPm47lsPp5LA3cNj3QM4aGYYLycHaxdriDYJ5XW3ApijePehNLSUgB++OEHOnbsWOMxhcI8g3jbtm1JTU1lxYoVrFmzhqFDh9KnTx/++OOPmzo2gEqlqnFfJpNhMl08LcTN7PfcmVbXu18np4tbtC5Vb129B1sjwss1WnZiGZO3T+b7g9/zVe+vaOzR2Nol2TW5XEZsYx9iG/uQka/jp50n+W13BqcLy5m2MonP1xznrpYBPNY5lDbB7mJlbUG4HjLZTXffWIOfnx+BgYGkpKQwfPjwyz7P1dWVYcOGMWzYMIYMGcKAAQPIz8/H09MTlUpVo8WitkRFRZGRkUFGRoal9SUhIYHCwkKio6Nvar9bt26tsW3r1q00btzYEtiEi4nwco1aeLcg1DWUk8UneWz5Y0yLnUb3oO7WLqteCPbU8tadUfxfn8b8fTCT+dvTOHCqiMX7T7N4/2maN3Dl8c5hDGwRIFbVFoR6bvLkyYwZMwY3NzcGDBhAZWUle/bsoaCggFdeeYVPP/2UgIAA2rRpg1wu5/fff8ff3x93d3cAwsLCWLt2LV27dsXBwQEPD49aqatPnz60aNGC4cOHM3PmTAwGA6NHjyY2NvaSXTrX6tVXXyUmJoapU6cybNgwtm/fzldffcXXX39dK3XXV2LMyzUKcwtjwcAFdPDvgM6g46V1LzHvyDyk+jXHn1U5qhQMaRfEXy92468XuvJA2yDUSjmHTxfz+h8HaTV5FQ98s41PVyWxMyXvkrP8CoJg30aNGsXs2bOZM2cOLVq0IDY2lri4OMLDwwFwcXHhk08+oX379sTExJCWlsby5cuRy81fZzNmzGD16tUEBwfTpk0bANLS0pDJZGzYsOGG65LJZPz11194eHjQvXt3+vTpQ8OGDVm4cOFNvd+2bdvy22+/8euvv9K8eXMmTJjAlClTagzWFS4mZti9TlWmKt7f8T6Lji8CYEjjIbzd8W1UctVVXinciPwyPQt3Z/DbngxSc8tqPKZRKegQ7km3CG+6RHgR5e+KvJbXcBIEW2ePM+zeauvXr+f+++8nJSWl1lpihBsjVpW+jFuxPIAkScxPmM/0PdORkOjo35EZPWbg5uBWJ8cTzDLydWw7kcuW5Dy2JeeSV6av8bink5rOjbzoFuFNtwhvgj1vbvCgINgDEV6u7rXXXsPX15fXXnvN2qXc9kR4uYxbubbRxoyNvL7pdXQGHaGuoXzV6yvC3MLq9JiCmckkkZRdwtbkXLYm57IzNR+dvuYgvWBPjblVppE3XRp5ibOXhHpJhBfBnojwchm3emHGpPwkXlr3EpllmbiqXfmsx2d0COhQ58cVatIbTBw4VWgJM/vTCzH8Z86YqABXukV40SXCm47hnmjVYvCvYP9EeBHsiQgvl2GNVaVzy3MZu34sB88eRClT8k6ndxjSeMgtObZwaaWVBnan5rOlOswczSqp8bhKIaNNiAddG3nTLdKLlkHuYvVrwS6J8CLYExFeLsMa4QWg0ljJ+K3jWZG6AoDHox/nlXavoJCL8/RtQW5pJdtO5LH1eC5bknM5XVhe43GNSkGol5YgDw1BHjWvgz20uGnFgGzBNonwItiT2govot28ljgoHPj4jo9p6NaQWfGzmJcwj5PFJ/m4+8c4qexvsqj6xtvZgXtaBXJPq0AkSSI9X8fW5Dy2Juey7UQuBboqjmaVXNRCc46Lo/KCUGMONOcCTrCnBhdHEW4EQRBuFdHyUgf+TfuXd7e8S6WxkkiPSL7q9RWBzlZYJE24JiaTRGpeGRn5Ok4VlFdfdGQUlHO6QEduqf6q+3DTqC4ZbII8zddicj2hroiWF8GeiJYXGzYgbAANnBowZv0Yjhcc5+F/HuaLXl/QyqeVtUsTLkEul9HIx/myK1uX642cLtSRkW8ONecCTkb17fwyPUXlVRSVV3HkTPEl9+HlpDYfw9fJcqxGPs408NCgEHPTCIIgXBfR8lKHssqyeHHtiyQVJKGWq5nSdQp3NbzLqjUJta+s0sDpwvILWm50NcJNoa7qsq9VK+U09D4XaJxo5GsONQ19nMTZUMI1ES0vgj0RLS92wN/Jn3l3zuPNzW+yPmM9b25+k9SiVEa3Ho1cJs5sqS+cHJQ09nOhsZ/LJR8vqajiZJ6OE2dLOXG2jBM5pZw4W0pKbhl6g+myY20auGto6FMdbHzN4SbCxxkfFwexUKUgXEJYWBgvv/wyL7/8cq3tc9KkSSxZsoT4+Pha26dw80R4uUb6CgPbFiXToLEHkTF+1/w6rUrLzJ4zmblvJnMOz+G7g9+RVpzG1K5T0Sg1dVixYCtcHFU0b+BG8wY1Z2A2miROF5RXh5rqS04ZJ86Wklem53RhOacLy9l8PLfm/hyUNKwOM+e6nwLdHXHXqHHTqnBxUIplEgSbdrXwPXHiRCZNmnTd+929ezdOTuIEiduBCC/XKGHLGY5sPkPy3hwCItxx9rj22VrlMjmvtHuFcNdwpuyYwsq0lZwuOc0Xvb7AR+tTh1ULtkwhlxHipSXES0vPpr41Hiso018Qas631qTn6yipNHAgo5ADGYWX3K9cZh5A7K5VV1+rcP/vfa3KEnbOPebqqEQp5roRboHMzEzL7YULFzJhwgSSkpIs25ydz48/kyQJo9GIUnn1rysfn/r59/R6PoPaoNfrUavVt+RYN0r8pbpGLXoG4RvqQqXOwPr5iTe0mvTgyMH80PcH3BzcOJx3mIf/eZij+UfroFrB3nk4qWkf5smwmBDeHhjFjyNj2PBaTxKnDmDV/3Xnm+FtebVvY+5rHUiLBm74uzriqDL/czZJUKCrIjW3jPiMQjYknWVJ/BnitqXx+drjTF6WwP8tPMATcbu5/+tt9JqxkbZTVxPxzgpaTFrJHZ+sY9CXW3jsx528+PM+xi85zPztaRzIKKTSYLxK5YJwdf7+/paLm5sbMpnMcv/o0aO4uLiwYsUK2rVrh4ODA1u2bOHEiRPce++9+Pn54ezsTExMDGvWrKmx37CwMGbOnGm5L5PJmD17NoMHD0ar1RIZGcnSpUtvqvbdu3fTt29fvL29cXNzIzY2ln379lkef/LJJ7n77rtrvKaqqgpfX19+/PFHAEwmEx9++CHh4eFoNBpatWrFH3/8YXn+hg0bkMlkF30G/3Vutew///yTnj17otVqadWqFdu3b6/xvEWLFtGsWTMcHBwICwtjxowZNR4PCwtj6tSpPP7447i6uvLMM88QFxeHu7s7f//9N02aNEGr1TJkyBB0Oh1z584lLCwMDw8PxowZg9F46/8uiJaXa6RQyOk9MprfPthNekI+RzafoXn3Bte9n/b+7fll4C+8sO4FUotSeXzF43x0x0f0CulVB1UL9Y2DUnHF8TUVVUaKy6soLK+iUFdFoU5PYXkVRboqCsv15m3/uV+kq6Kk0gBASYWBkgoDGZRfcv9qhZyoABdaBrnTKtidVkFuNPJxFt1UNkaSJMoNl/7/sC5plJpaG4/15ptvMn36dBo2bIiHhwcZGRkMHDiQ999/HwcHB+bNm8egQYNISkoiJCTksvuZPHkyn3zyCdOmTePLL79k+PDhnDx5Ek9Pzxuqq6SkhBEjRvDll18iSRIzZsxg4MCBHD9+HBcXF0aNGkX37t3JzMwkICAAgL///hudTsewYcMA+PDDD/npp5/49ttviYyMZNOmTTz66KP4+PgQGxt72c/gct555x2mT59OZGQk77zzDg8//DDJyckolUr27t3L0KFDmTRpEsOGDWPbtm2MHj0aLy8vRo4cadnH9OnTmTBhAhMnTgRg8+bN6HQ6vvjiC3799VdKSkq4//77GTx4MO7u7ixfvpyUlBQeeOABunbtanlvt4o42+g6HVibwZbfj6NUyxn2bgfcfW9s5eJifTHjNoxje+Z2ZMh4ud3LPNHsCTEQU7AKg9FEcYXhkmEnt7SSI2eKOZBRSMElzpxydlDSvIFrdZhxp2WQGw3ca+9LTLiyS529oavS0fHnjre8lp2P7ESrur6/iXFxcbz88ssUFhYC5laHnj17smTJEu69994rvrZ58+Y899xzvPjii8DFA3ZlMhnvvvsuU6dOBaCsrAxnZ2dWrFjBgAEDrqm+qw3YNZlMuLu78/PPP1taXJo1a8aIESN4/fXXAbjnnnvw8vJizpw5VFZW4unpyZo1a+jcubNlP6NGjUKn0/Hzzz9f82eQlpZGeHg4s2fP5qmnngIgISGBZs2akZiYSNOmTRk+fDhnz55l1apVlte9/vrr/PPPPxw5csTyubVp04bFixdbnhMXF8cTTzxBcnIyjRo1AuC5555j/vz5ZGdnW7r2BgwYQFhYGN9+++01fZ7ibCMradkziNSDZzmdVMjauEQGj2t7Q786XdWufN3naz7a9RELkxby2d7PSC1KZUKnCagUYrZW4dZSKuR4OqnxdLp8P7ckSZwqKCc+o5CDpwo5kFHEodNFlFYa2JGSz46UfMtzvZ3VtKwOMudCzZX2LQj/1b59+xr3S0tLmTRpEv/88w+ZmZkYDAbKy8tJT0+/4n5atmxpue3k5ISrqys5OTk3XFd2djbvvvsuGzZsICcnB6PRiE6nq1HHqFGj+P7773n99dfJzs5mxYoVrFu3DoDk5GR0Oh19+/atsV+9Xk+bNm1qbPvvZ3A5F77Hc609OTk5NG3alMTExIsCUNeuXZk5cyZGoxGFQnHZY2m1WktwAfDz8yMsLKzGmCQ/P7+b+jxvlAgv10kml9F7RDS/TtlJVkoR8avTads/9Ib2pZQrebfTuzR0a8jHuz9mSfIS0ovT+bTHp3hpvGq5ckG4OTKZjGBPLcGeWga1Ms8YbTCaSD5bysGMIuJPmUPN0cwSckv1rDuaw7qj5/+oBXtqzN1NQW60CnKneQM3nMTMw3VCo9Sw85GdVjlubfnvWUPjxo1j9erVTJ8+nYiICDQaDUOGDEGvv/IM2CpVzR+DMpkMk8l0w3WNGDGCvLw8Pv/8c0JDQ3FwcKBz58416nj88cd588032b59O9u2bSM8PJw77rgDMIcwgH/++YcGDWoOPXBwqHkiyLWeOXXhezzX4nm97/FSx7rUZ1fbn+eNEn85boCLpyPdhjZm3bxEdi5NIaSZF95Bl56d9Vo8EvUIIa4hvLbxNfbl7OPhfx7my15f0sSzSS1WLQi1T6mQ09Tflab+rgyNCQbM424SMos5mFHIgVNFHDhVSMrZMjLyy8nIL+efg+YzTeQyiPR1oUWQG038XIjwc6axnwuBbo6iy+kmyWSy6+6+sXVbt25l5MiRDB48GDCHgLS0NKvU8fXXXzNw4EAAMjIyyM2tOZ2Bl5cX9913H3PmzGH79u088cQTlseio6NxcHAgPT29xviWuhIVFcXWrVsveg+NGze2tLrYIxFeblDTzv6kHjhL6oFc1sxJ4ME326NQ3fjJW90adGPBXQsYs24MJ4tP8tiKx/ig2wf0Ce1Ti1ULQt1zVCloG+JB25DzAwyLyqs4fLqoRpdTVnEFSdklJGXXnKDPSa0gwteZSD8XIn3NgSbC15kG7hoxMPg2FhkZyZ9//smgQYOQyWSMHz/eKr/4IyMjmT9/Pu3bt6e4uJjXXnsNjebiFqdRo0Zx9913YzQaGTFihGW7i4sL48aN4//+7/8wmUx069aNoqIitm7diqura43n1oZXX32VmJgYpk6dyrBhw9i+fTtfffUVX3/9da0e51YT4eUGyWQyegxvSlbKTvJOl7Lr71Q6D2509RdeQUO3hiwYuIDXNr7G9szt/N+G/2N069E81/I58UtUsGtuGhVdI7zpGuFt2ZZTXMGBU0UcPl1Eck4px7JLSM0to0xvrG6xKaqxD211qImoDjTngo0INbeHTz/9lCeffJIuXbrg7e3NG2+8QXHxpdcSux5hYWGMHDnymifF+/HHH3nmmWdo27YtwcHBfPDBB4wbN+6i5/Xp04eAgACaNWtGYGDNhXmnTp2Kj48PH374ISkpKbi7u9O2bVvefvvtm34//9W2bVt+++03JkyYwNSpUwkICGDKlCk1zjSyR+Jso5uUsv8sK747hEwGg19tS0CE+03v02AyMGPPDH5K/AmAfqH9mNp1ar1rBhaE/6oymkjLLeN4TinHs0s5llNCcnYpKbmlVBkv/afKUSU3Bxpfc9dTpK8Ljf2cCfLQ3haLXoq1jW6cTqfDy8uLFStW0KNHj1rdd2lpKQ0aNGDOnDncf//9tbpve1ZvzzYqLCykT58+GAwGDAYDY8eO5emnn7Z2WZfVsI0PTTv5c3RHFmvmJjLsnRjUjjf3sSrlSt7o8AaRHpFM3TGVVSdXkVGSwec9PyfAOaCWKhcE26NSyM3dRX4u0OL8doPRRFqejuSckupQU8rx7BJSzpZRUWXi8OliDp+u+SvcQWkONeHeTgS6awhwcyTATUOguyP+bo54OzmIFpvb3Pr16+nVq1etBheTyURubi4zZszA3d2de+65p9b2LZxncy0vRqORyspKtFotZWVlNG/enD179uDldW1n31hjVenKcgO/TtlJaUElzbo3oMcjtTfQdl/2Pv5vw/+RX5GPp6Mnn/f8nNa+rWtt/4JgzwxGE+n5Oo7nlFq6no5nm5dSqDRceTyEWiHHz83BHGjcHAlwr7520xDgbr720KpsvstWtLzYlnNzrwQFBREXF0fv3r2tXZJNqbctLwqFAq3W3D1SWVmJJEk3NBX/reSgUdJ7RBR/zYznyKbTNGzlTUiz2jnVua1fW36961deWvcSSQVJPLHyCSZ0msDgyMG1sn9BsGdKhZyGPs409HGmf7Pz240miYx8HceyS0jP15FZVEFmUTlnCs3XOSWV6I0myxlQl+OokpvDzAWtNufDjfm2m0bMyyScFxYWZvPfWfXBdYeXTZs2MW3aNPbu3UtmZiaLFy/mvvvuq/GcWbNmMW3aNLKysmjVqhVffvklHTp0uOZjFBYWEhsby/Hjx5k2bRre3t5Xf5GVBTX1pGXPIA6uP8W6eYk8NKEjjk6180ctwDmAeXfO492t77L65GombJvA8cLjvNLuFZRym8ufgmB1CrmMMG8nwrwvPU9GldFEdnEFmUUVnCksJ7OogqwLbmcWlZNbqqeiykRqbhmpuWWXPZaLo5IQT63lEnzB7UB3DWqlWEJOEGrbdX/zlZWV0apVK5588slLDkJauHAhr7zyCt9++y0dO3Zk5syZ9O/fn6SkJHx9zSvntm7dGoPBcNFrV61aRWBgIO7u7hw4cIDs7Gzuv/9+hgwZgp+f3w28vVur0+BGpCfkU5itY9Ovx+j3VLOrv+gaaVVapsdO57sD3/H1ga+ZnzCflMIUPon9BFf1rekeE4T6QqWQE+ShJcjj8oPgK6qMZBdXWFprLgw6566LyqsoqTBw5EwxR85cfOaLXAYBbprz4carZrixh24pQbBFNzXmRSaTXdTy0rFjR2JiYvjqq68A8+Cl4OBgXnrpJd58883rPsbo0aPp1asXQ4YMueTjlZWVVFZWWu4XFxcTHBx8S8e8XCg7tZhF0/YimST6jWpGZPvaD12r0lbx7tZ3KTeUE+Yaxhe9viDcLbzWjyMIwpXp9AZOFZSTnqcjPd98ycg/f/tq426cHZTVYUZzUctNAw8NDsqrTyImxrwI9sQmx7zo9Xr27t3LW2+9Zdkml8vp06fPRUt0X052djZarRYXFxeKiorYtGkTzz///GWf/+GHHzJ58uSbrr22+IW70u7OUPb8k8bGX5IIjHDHyd3h6i+8Dv3C+hHiGsJL614irTiN4f8MZ1rsNLo26FqrxxEE4cq0auVlV/mWJImzJZWWIPPfcJNdXElppYHEzGISMy9utZHJIMDVkVAvJ8K8tebrc7c9ndCo7Xd2VEG4WbUaXnJzczEajRd18fj5+XH06NFr2sfJkyd55plnLAN1X3rpJVq0aHHZ57/11lu88sorlvvnWl6sqf3AME4eyuNsegnr5h/l7hdb1nrTcFPPpvxy1y/83/r/I/5sPKPXjubVdq/yWPRjohlaEGyATCbD19URX1dH2od5XvR4RZWRUwXVoSZPR3p+eY1wU15l5ExRBWeKKtieknfR6/1dHQn10tIyQEvfYBkl5XokuQq1Un5bzG8j3N5sbrRnhw4dLrv0+KU4ODhctJiVtSkUcvqMjOa3D3aTfiSPhC1naHZHg6u/8Dp5a7z5sf+PvLfjPRYnL2banmkcLzzO+E7jUSvECr6CYMscVQoifF2I8L10q01uqZ70/DJO5ulIyy0jLU9HWp558HBJhYGs4gqyiis4lVtEB29fzhRVICszd1OpFHLUSjkOCjlqVfW1Uo5aqajVYCNJElL1tUm68Np8W6GQoVbIxQ8qodbVanjx9vZGoVCQnZ1dY3t2djb+/v61eSib5xnoRKf7GrL1j2S2/JFMUFMP3Hxqf4ZctULN5C6TaezRmGl7prEkeQlpRWl81vMzvDW2f5aWIAgXk8lk+Lg44OPiQLvQmq02kiRRqKsiNa+Mk3llZOWXoFXrcVQpMMhkGE0SVUYTVUYTlzpHSqk4H2ZUCjkSEpIEJkmyhA6TBBLnt1382PntV6NSyHF2UOLkoMTZQYH6GsbxWEOPHj1o3bo1M2fOtHYpwjWo1XP41Go17dq1Y+3atZZtJpOJtWvX0rlz59o8lF1o1SuYwEh3DJVG1s5NxGSqm3P/ZTIZj0Y/yje9v8FF7UL82Xge/udhEvMS6+R4giBYj0wmw8NJTdsQDwa3CeKJruF4OqkJ9XKiWaAb0QGuRPg6E+ypxc/VEQ+tGq1aibK6xcVgNFGmN1Cg05NTUsHZkkpySyvJL9NToNNTWF5FcUUVJRVVlFUa0OkNVFQZqTQY0RtNGEwmjCbpksFFLpOhkMtQKuSWFpcqo4kCnZ5TBTqOZpVwNLMYmUx2xcu1rjN0uc9nyZIlN/x6wT5cd8tLaWkpycnJlvupqanEx8fj6elJSEgIr7zyCiNGjKB9+/Z06NCBmTNnUlZWVmNJ8NuFTC6j94gofp26i8zkIuLXpNO2X2idHa9Lgy78PPBny0DeEf+O4L2u79EvrF+dHVMQBNuiVMhRKuRoL9FzbDCa0BtN6A0mKg0mDEYJmcx8SrdMJrNcy2Qgp/q6+r7lcf7zvHO34aLuIZNJokxvoKzSSGmlgXK9OQCt3Xt+DOSaf5bw1bQP2BV/CCe1EpVSjrOzcx1/SrZJr9ejVt+6Lv+qqipUKvucZPG6W1727NlDmzZtaNOmDQCvvPIKbdq0YcKECQAMGzaM6dOnM2HCBFq3bk18fDz//vuvXczTUhdcvTV0GxoJwM6lKeSdLq3T44W5hbHgrgV0bdCVckM5r258lVnxszBJt37peEEQbIs51Chx16rxc3WkgYeGQHcN/m4a/Fwd8XFxxNvZAS8nBzyc1Lhr1bhqVLg4qnB2UKJVK9GoFTioFJZuJ4VcXh1wLh7XIpfLcHFU4e/mSISvM9GBroR7OxHVKISQoAb4+PqjcXIBGejVrhSgpQgnvvlxHk2aNsXR0ZGmTZvy9ddfW/ap1+t58cUXCQgIwNHRkdDQUD788EPAPLstwODBg5HJZJb7N2L+/Pm0b98eFxcX/P39eeSRR8jJyQHM3WcRERFMnz69xmvi4+ORyWSWH/iFhYWMGjUKHx8fXF1d6dWrFwcOHLA8f9KkSbRu3ZrZs2df8VT3uLg43N3dWblyJVFRUTg7OzNgwAAyMzMtzzGZTEyZMoWgoCAcHBxo3bo1//77r+XxtLQ0ZDIZCxcuJDY2FkdHRxYsWMDIkSO57777+OCDD/Dz88Pd3Z0pU6ZgMBh47bXX8PT0JCgoiDlz5tzwZ1kXrju89OjRw3Im0IWXuLg4y3NefPFFTp48SWVlJTt37qRjx461WbPdieoSQFhLb0wGidVzEjBeZe6Hm+WqdmVWr1k8Hv04AN8e+JZXN7yKrkpXp8cVBME2SJKESae75ZerTRumqA4zAW6a6jDjgrezAzJkaFQKZMCfv//CtA+m8uyr7/Dnup288Np43nl3PN98/yNVRhNffPEFS5cu5bfffiMpKYkFCxZYQsru3bsBmDNnDpmZmZb7N6KqqoqpU6dy4MABlixZQlpaGiNHjgTMLUxPPvnkRV/oc+bMoXv37kRERADw4IMPkpOTw4oVK9i7dy9t27ald+/e5OfnW16TnJzMokWL+PPPP694sopOp2P69OnMnz+fTZs2kZ6ezrhx4yyPf/7558yYMYPp06dz8OBB+vfvzz333MPx48dr7OfNN99k7NixJCYm0r9/fwDWrVvHmTNn2LRpE59++ikTJ07k7rvvxsPDg507d/Lcc8/x7LPPcurUqRv+PGudVM8UFRVJgFRUVGTtUmooK6qUZr+6Sfrq2bXS9sXJt+y4i48vltrMayM1j2su3f/X/VJywa07tiAIda+8vFxKSEiQysvLLduMZWVSQpOmt/xiLCu77vrnzJkjubm5SZIkSVVGoxTesJE064c46VhWsXQgo0A6kFEgvTDuHalVuxjpQEaB9NhTz0pdu/eQCkorpLKKKklXWSXp9AapXG+QKvQGCZB+X7RIqjIYpSqDUTIYTZLRZJJMJtMV64iNjZXGjh172cd3794tAVJJSYkkSZJ0+vRpSaFQSDt37pQkSZL0er3k7e0txcXFSZIkSZs3b5ZcXV2lioqKGvtp1KiR9N1330mSJEkTJ06UVCqVlJOTc9XPCJCSk8///Z41a5bk5+dnuR8YGCi9//77NV4XExMjjR49WpIkSUpNTZUAaebMmTWeM2LECCk0NFQyGo2WbU2aNJHuuOMOy32DwSA5OTlJv/zyyxXrvBaX+u/1nOv5/ra5U6XrK62rmh6PNOHf7w+zb+VJwlp649/Qrc6Pe1/EfYS5hvHy+pc5VnCMocuGMqbtGB6NehSF3DZH/QuCcHuqLC8nNeUE48Y8j/zlFyzbDQYDzi7mGVfveuBhnn1kMK1aNKNrj950792fLrG9auznVH45CZeY+A8uHJ9jHr9jvgad3khBmZ5j2SXIgISD8cz69CMSjxyisKAAk8ncYp6enk50dDSBgYHcdddd/O9//6NDhw4sW7aMyspKHnzwQQAOHDhAaWkpXl41F+ktLy/nxIkTlvuhoaH4+Phc9bPRarU0atTIcj8gIMDSjVVcXMyZM2fo2rXmRKVdu3at0U0F0L59+4v23axZM+Ty8x0xfn5+NG/e3HJfoVDg5eVlOZ4tqDfhZdasWcyaNQuj0WjtUi6rUVtfmnT0J2lnFmvmJDDs3Q6oHOo+QLT2bc1vg35j4raJbDm9hel7prMufR3vdX2PYFfrTugnCELtk2k0NNm31yrHvRmlpeYxgT/88MNFww0UCgXBAa6EenZmx4FE/l2xgq2b1vP66Cfp1C2Wz36Yx7leqyvNKiNVz01zwf9YthsliYoqIzpdGSOH3UeX2F5M/exb/P38KM7NZNjgQej1estrRo0axWOPPcZnn33GnDlzGDZsGFqt1vJeAgIC2LBhw0U1uLu7W247OV168dD/+u/AWplMdkOrV1/qeJfa96W2nQtwtqDehJcXXniBF154wbI2gq26Y1gkp48VUHS2nG1/JhP7cJNbclxfrS9f9/6aP4//ySe7P2Ffzj4eWPYAr7Z7laFNhopJpAShHpHJZMi0tT+vVF3z8/MjMDCQlJQUhg8ffsnnuGnVuIX40fTZkbz87EhWrlzJgAEDCHA04unpiUqlIsjDkRYN3Cz55Ny8NOYJ9c7fh/NhxlGlwE2joqG3E/v2JVFYkM/bk97D1csfCYl9+/YAkJ6vI6i0EjeNioEDB+Lk5MQ333zDv//+y6ZNmyx1tm3blqysLJRK5U0NHL4Wrq6uBAYGsnXrVmJjYy3bt27dSocOHer02NYi1mq/xRy0Kno9HgXA4Y2nSU+4eNrvuiKTyXig8QP8ee+fxPjHUG4o572d7/Hs6mfJKsu6ZXUIgiBczuTJk/nwww/54osvOHbsGIcOHWLOnDl8+umnAHz66af88ssvHD16lGPHjvH777/j7+9vac0ICwtj7dq1ZGdnU1RYiFwuQyE3nz5umXlYqcBRZb5o1OazqBRymXlCPUcVUZENUavV/LXgRxzKz3Jw61pmf2E+s6iiysiZwnKOZhZzMr+cYY88yltvvUVkZGSN+cz69OlD586due+++1i1ahVpaWls27aNd955hz179tT65/baa6/x8ccfs3DhQpKSknjzzTeJj49n7NixtX4sWyDCixUER3nSokcQAOvmHaWirOqWHr+BcwNm95vNmx3exFHhyPbM7Qz+azBLkpfcUDOkIAhCbRk1ahSzZ89mzpw5tGjRgtjYWOLi4ggPDwfAxcWFTz75hPbt2xMTE0NaWhrLly+3jNmYMWMGq1evJjg42DKlx7nThC/VhXMpPj4+xMXF8fvvv9OyRXO+/nwGn39mDk8+zg5o1UokoLTSQJ/7Hkav13Pv0OEU6PQYqycjlclkLF++nO7du/PEE0/QuHFjHnroIU6ePFnrU4eYJImnnxvN8y+O5f9eeYUWLVqw9O/lxP3yOz4NQqmoMl7TbMj2RCbVs2+r61lS25qq9EZ+e383hdk6Gnfwo++TzaxSR1pRGu9sfYeDZw8C0COoBxO7TBRLCwiCnaioqCA1NfWK84Tc7tavX8/9999PSkoKHh4etbJPvcFIYXkVa9ZtZMSDg1i18zBePr7IZTJcHJW4a1W4OKiQ1/JaUnqjiYoqExVVxuqLedJBiSt/lctkMhyU8uoWp+prpQKV4tJz9NSVK/33ej3f3/VmzIu9UakV9B4ZxZ+f7OXYrmzCW/kQ0c73ltcR5hbGvAHziDsSx6z4WWw4tYH9f+3n3U7vMiBswC2vRxAEobYtX76ct99+u9aCC4BkNKAvyuXHLz7hgQeGENUohCJdFZUGI0XlVRSVV6GQyXDVqHDTmif5k19HSDAYqwOKwWQJKVdqQVHIZZauMEelHAksr6usMloGI1dUGS9+naUb7Xy4Uchtu2NGtLxY2c6lKexZnoajk4qHJnTAyc16K2QfKzjGu1veJTHfvCbSgLABvNPxHdwd3a1WkyAIVyZaXqwjLi6Op556itatW7N06VIaNGiAVB0QCsurKNJVoTeePztHIZfhplHhrlHh5KC0tHaYTBIVBmPN1hSDCYPx0mf2yGQyHC/RgqK8QguKJJkX6zx/DFP1elWXb7FRK8z7dlDJ0ajMsyo7KOXXFcAupbZaXkR4sTKjwcQfH+8hN6OU0BZe3DW6pVXP/KkyVvH9oe/54eAPGCUjXo5eTOoyiR7BPaxWkyAIlyfCi22SJAmd3twKU6irwnDBacYqhTkQVBpM6A3Gy3b4qJXyi1pFHJTyWvuOMEkSlVWm6vB0PtRUXS44IcNBZa7JyUGBl/P1/9gW4eUy7C28AOSdKeX3D/ZgNJhoPzCMDoPCrX7q8pHcI7yz5R1OFJknU7q30b280eENXNQuVq1LEISaRHixfZIkUVZpMLfIlFdZBvWeo5TLa3TZOCrNLR2KWhwvcz0MRvPCnReOq6mo7no6x8VRRbj3tc1RcyERXi7DHsMLwIG1GWz53bwGRWSMH70ea4pSbd0ZcCuNlczaP4u4I3FISPg7+TOlyxQ6B3a++osFQbglRHixLyZJorTCgN5osgygVcpv7aDZG2HueqoeN2MwolbIcb/U0uVXUVvhxbZH5NxGWvUOpsfwJsjlMo7vzmbxp/spK6q0ak0OCgdeaf8Kc++cS7BLMFllWTyz+hne2/GeWORREAThBsirB/F6Ozvg4qhCpai9bqC6JJPJUCvluGpU+Lo43lBwqU31JrzMmjWL6OhoYmJirF3KDWt2RwMGjW2Ng5OSnLRifv9wD2fTS6xdFm182/DHoD94qMlDACxMWsiQZUPYl73PypUJgiAItyPRbWSDCnN0LP/6IAVZOpQqOX2eiKZR21t/GvWl7Mjcwfit48kqy0KGjMejH+elti/hoLDeWVKCcDsT3UaCPRHdRvWYu6+WB95oT0i0J4YqE/9+f5g9y1NtYvbbTgGd+POePxkcMRgJibkJcxm6bCiHcw9buzRBEAThNiHCi41y0Ci564WWtOxlXkZg59JUVv8vAYPe+qtmu6hdmNJ1Cl/1+gpvjTcpRSk8uvxRvtz/JVXGW7vUgSAIwjlhYWHMnDmzVvc5adIkWrduXav7vFZ18X7qCxFebJhcIeeOoY1rDuSdsc/qA3nPiQ2OZfE9i7kz7E6MkpHvD37PI8sf4VjBMWuXJgiCDZPJZFe8TJo06Yb2u3v3bp555pnaLbaWyGQylixZYu0y6g0RXuxAszsacM+5gbwnS2xmIC+Au6M7n8R+wvTY6bg7uHM0/yjD/h7G7EOzMZqs30okCILtyczMtFxmzpyJq6trjW3jxo2zPFeSJAwGwzXt18fHB61WW1dl37b0er21S7iICC92okETD4a80R4Pfy1lhZX8OW0vJ/blWLssi/5h/Vl872J6BPXAYDLw+b7Pefzfx0krSrN2aYIg2Bh/f3/Lxc3NDZlMZrl/9OhRXFxcWLFiBe3atcPBwYEtW7Zw4sQJ7r33Xvz8/HB2diYmJoY1a9bU2O9/u1lkMhmzZ89m8ODBaLVaIiMjWbp06Q3V/N133xEcHIxWq2Xo0KEUFRVZHtu9ezd9+/bF29sbNzc3YmNj2bfv/NmYYWFhAAwePBiZTGa5D7Bs2TJiYmJwdHTE29ubwYMH1ziuTqfjySefxMXFhZCQEL7//vsr1tmjRw/GjBnD66+/jqenJ/7+/he1ZKWnp3Pvvffi7OyMq6srQ4cOJTs72/L4ua6y2bNn1xhYK5PJ+O6777j77rvRarVERUWxfft2kpOT6dGjB05OTnTp0oUTJ05cz0d7Q0R4sSOXGsi7+x/bGMgL4K3x5oteXzC161ScVc4cPHuQB5c9yILEBZikS083LQhC7ZMkiapK4y2/1ObfojfffJOPPvqIxMREWrZsSWlpKQMHDmTt2rXs37+fAQMGMGjQINLT06+4n8mTJzN06FAOHjzIwIEDGT58OPn5+ddVS3JyMr/99hvLli3j33//Zf/+/YwePdryeElJCSNGjGDLli3s2LGDyMhIBg4cSEmJuYV89+7dAMyZM4fMzEzL/X/++YfBgwczcOBA9u/fz9q1a+nQoUONY8+YMYP27dtbjvn888+TlJR0xXrnzp2Lk5MTO3fu5JNPPmHKlCmsXr0aAJPJxL333kt+fj4bN25k9erVpKSkMGzYsIve86JFi/jzzz+Jj4+3bJ86dSqPP/448fHxNG3alEceeYRnn32Wt956iz179iBJEi+++OJ1fb43QqwqbWfODeTduiiZg+tOsWtZKgWZZfR6PMrqM/KCOZnfF3EfHf07Mn7beHZm7uSjXR+xPn09U7pOIdA50NolCkK9Z9Cb+H7sxlt+3Gc+j0XlUDt/h6ZMmULfvn0t9z09PWnVqpXl/tSpU1m8eDFLly694pflyJEjefjhhwH44IMP+OKLL9i1axcDBgy45loqKiqYN28eDRo0AODLL7/krrvuYsaMGfj7+9OrV68az//+++9xd3dn48aN3H333fj4+ADg7u6Ov7+/5Xnvv/8+Dz30EJMnT7Zsu/A9AgwcONASlN544w0+++wz1q9fT5MmTS5bb8uWLZk4cSIAkZGRfPXVV6xdu5a+ffuydu1aDh06RGpqKsHBwQDMmzePZs2asXv3bstcaXq9nnnz5llqP+eJJ55g6NChlno6d+7M+PHj6d+/PwBjx47liSeeuJaP9aaIlhc7dNFA3j05NjWQFyDAOYDv+37P2x3fRqPUsDNrJ/cvvZ/FxxfbTEuRIAi2q3379jXul5aWMm7cOKKionB3d8fZ2ZnExMSrtry0bNnSctvJyQlXV1dycq6vyz0kJMQSXAA6d+6MyWSytIBkZ2fz9NNPExkZiZubG66urpSWll61tvj4eHr37n3N9Z/rXrta/Re+BiAgIMDymsTERIKDgy3BBSA6Ohp3d3cSExMt20JDQy8KLv/dt5+fHwAtWrSosa2iooLi4uIr1nizRMuLHWt2RwPcfbWs+P6QZSDvXaNb4hNiG4snymVyHm76MF0Cu/DulneJPxvPhG0TWJu+lomdJ+KjvfgfhiAIN0+plvPM57FWOW5tcXKquejfuHHjWL16NdOnTyciIgKNRsOQIUOuOphUpVLVuC+TyTCZarcbe8SIEeTl5fH5558TGhqKg4MDnTt3vmptGo3mqvu+kfpr4z3/9/O/1L7PLWtwqW21/Rn/l2h5sXOXGsibvNd2BvIChLqGEjcgjlfavYJKrmLjqY0MXjqYf1P/tXZpglAvyWQyVA6KW36pyzV6tm7dysiRIxk8eDAtWrTA39+ftLS0OjvehdLT0zlz5ozl/o4dO5DL5Zaum61btzJmzBgGDhxIs2bNcHBwIDc3t8Y+VCoVRmPNMzBbtmzJ2rVr6/4NXCAqKoqMjAwyMjIs2xISEigsLCQ6OvqW1nIz6k14qQ9rG90oy0DeZuaBvCt/sK2BvAAKuYInmj/Bb3f/RpRnFEWVRby26TXGbRxHQUWBtcsTBMHGRUZGWgaPHjhwgEceeaTOf92f4+joyIgRIzhw4ACbN29mzJgxDB061DJ+JTIykvnz55OYmMjOnTsZPnz4Ra0qYWFhrF27lqysLAoKzH/zJk6cyC+//MLEiRNJTEzk0KFDfPzxx3X6Xvr06UOLFi0YPnw4+/btY9euXTz++OPExsZe1FVny+pNeHnhhRdISEiwjOK+3TholNw1uiWtepn7MXctS2X1j0dsYkbeC0V4RLDgrgU83+p5FDIFK9NWMvivwWzI2GDt0gRBsGGffvopHh4edOnShUGDBtG/f3/atm170/sNCwu76qR4ERER3H///QwcOJB+/frRsmVLvv76a8vjP/74IwUFBbRt25bHHnuMMWPG4Otbcz26GTNmsHr1aoKDg2nTpg1gPq35999/Z+nSpbRu3ZpevXqxa9eum35PVyKTyfjrr7/w8PCge/fu9OnTh4YNG7Jw4cI6PW5tEwsz1kNHNp9m0y/HMJkkfENdGPh8S5zcbW/hxCN5R3hn8zucKDLPCXBfxH28HvM6LmrbGLMjCPZALMx443Q6HV5eXqxYsYIePXpYu5zbgliYUbisi2bk/ch2ZuS9UDOvZiwctJCRzUYiQ8aS5CU8sPQBdmTusHZpgiDcBtavX0+vXr1EcLFDouWlHis6q+OfWQcpyNKhVMnpPTKaiHa+V3+hFezL3sc7W97hVOkpAB5u+jAvt30ZrUpM9S0IVyJaXgR7IlpehKty87l4IO/mhccwVNnWOBiAtn5tWXTPIoY1Mc/y+MvRX3hw2YPE58RbtzBBEATB5ojwUs9ZBvL2MQ/kPbj+FH98tIe806VWruxiWpWWdzu9y3d9vsNP60d6SToj/h3BZ3s/Q2+0vYXBBEEQBOsQ4eU2IFfI6TYkkrteaInGRUXe6TJ+/2gPB9efsqnTqc/p0qALf977J/c0ugeTZOJ/h//HsL+HcTj3sLVLEwRBEGyACC+3kbAW3jw0viMhzbwwVpnYvPAYy78+iK7Y9lo1XNWuvN/tfWb2nImnoyfJhck88s8jTNo2ifyK61tUTRAEQahfRHi5zWhd1dz9Yku6DY1EoZSTdiiPX9/bRfqRPGuXdkm9Q3qz+N7FDGo4CAmJRccXcfefd7MgcQEGk8Ha5QmCIAhWIMLLbUgmk9GqVzAPvtUez0Anyov1LPvyAFt+O26Tg3k9HT354I4PmHfnPKI8oyipKuGjXR/x4LIH2ZVZtxM6CYIgCLZHhJfbmFcDZx58sz0tegQBcGBdBn98tJf8M2VWruzS2vi24Ze7fmF8p/G4O7iTXJjMU6ue4tUNr5JZmmnt8gRBEIRbRISX25xSraD7Q40vGMxbym8f7ubQBtsczKuQKxjaZCh/D/6bh5o8hFwmZ9XJVdyz5B6+O/AdlcZKa5coCIId6tGjBy+//PItP25aWhoymYz4+Phbfmx7JsKLAJgH8w57twMhzTwxVpnY9Osxln9ziPIS2xvMC+Dm4MY7nd7ht7t/o61vWyqMFXwV/xX3LrmXdenrbDJ4CYJgJpPJrni52lpDV9v3kiVLaq3W67FhwwZkMhmFhYVWOf7tRIQXwcLJzYG7X2hFtwcjkStlpB3M5depu0hPsM3BvABNPJsQNyCOj+/4GF+tL6dLTzN2/VieX/M8qUWp1i5PEIRLyMzMtFxmzpyJq6trjW3jxo2zdom3Jb3eNn+sXkq9CS+zZs0iOjqamJgYa5di12RyGa16B/Pgm+3xCHBCV6xn2RcH2PLHcYxVt2b5+eslk8kY2HAgy+5bxqgWo1DJVWw9s5X7/7qfGXtmUKq3vQn5BOF25u/vb7m4ubkhk8lqbPv111+JiorC0dGRpk2b1ljBWa/X8+KLLxIQEICjoyOhoaF8+OGHgHmFaIDBgwcjk8ks96+VwWDgxRdfxM3NDW9vb8aPH1+jFXf+/Pm0b98eFxcX/P39eeSRR8jJyQHM3T89e/YEwMPDA5lMxsiRIwEwmUx88sknRERE4ODgQEhICO+//36NY6ekpNCzZ0+0Wi2tWrVi+/btV6xVJpMxe/ZsBg8ejFarJTIykqVLl9Z4zsaNG+nQoQMODg4EBATw5ptvYjCcP0uzR48evPjii7z88st4e3vTv39/S+vRypUradOmDRqNhl69epGTk8OKFSuIiorC1dWVRx55BJ1Od12fb62S6pmioiIJkIqKiqxdit3TVxqkDT8flb56dq301bNrpV/f2ynlnSm1dllXdbLopPTCmhek5nHNpeZxzaUeC3tIS5OXSkaT0dqlCUKtKy8vlxISEqTy8nLLNpPJJOnLy2/5xWQyXXf9c+bMkdzc3Cz3f/rpJykgIEBatGiRlJKSIi1atEjy9PSU4uLiJEmSpGnTpknBwcHSpk2bpLS0NGnz5s3Szz//LEmSJOXk5EiANGfOHCkzM1PKycm55jpiY2MlZ2dnaezYsdLRo0eln376SdJqtdL3339vec6PP/4oLV++XDpx4oS0fft2qXPnztKdd94pSZIkGQwGadGiRRIgJSUlSZmZmVJhYaEkSZL0+uuvSx4eHlJcXJyUnJwsbd68Wfrhhx8kSZKk1NRUCZCaNm0q/f3331JSUpI0ZMgQKTQ0VKqqqrpsvYAUFBQk/fzzz9Lx48elMWPGSM7OzlJeXp4kSZJ06tQpSavVSqNHj5YSExOlxYsXS97e3tLEiRMves+vvfaadPToUeno0aPS+vXrJUDq1KmTtGXLFmnfvn1SRESEFBsbK/Xr10/at2+ftGnTJsnLy0v66KOPrvnzPedS/72ecz3f32JhRuGqUg+cZd38o1SUVqFUyen6YCTN7ghEJpNZu7Qr2nRqEx/v+pj0knQAWvm04u2ObxPtFW3lygSh9lxqobuqigq+GDHkltcyZu4fqK5zcci4uDhefvllyziRiIgIpk6dysMPP2x5znvvvcfy5cvZtm0bY8aM4ciRI6xZs+aSf4NkMhmLFy/mvvvuu646evToQU5ODkeOHLHs980332Tp0qUkJCRc8jV79uwhJiaGkpISnJ2d2bBhAz179qSgoAB3d3cASkpK8PHx4auvvmLUqFEX7SMtLY3w8HBmz57NU089BUBCQgLNmjUjMTGRpk2bXvLYMpmMd999l6lTpwJQVlaGs7MzK1asYMCAAbzzzjssWrSIxMREy/v5+uuveeONNygqKkIul9OjRw+Ki4vZt2+fZb/n3sOaNWvo3bs3AB999BFvvfUWJ06coGHDhgA899xzpKWl8e+//17X5ywWZhRumfBWPjw0vgPBUR4Yqkxs/DmJFd8eorzUtvtHuwd1Z/G9ixnbdiwapYYDZw/w0N8PMXn7ZAoqCqxdniAI/1FWVsaJEyd46qmncHZ2tlzee+89Tpw4AcDIkSOJj4+nSZMmjBkzhlWrVtXa8Tt16lQjEHXu3Jnjx49jNJrnv9q7dy+DBg0iJCQEFxcXYmNjAUhPT7/sPhMTE6msrLQEgctp2bKl5XZAQACApUvqWl7j5OSEq6ur5TWJiYl07ty5xvvp2rUrpaWlnDp1yrKtXbt2V923n58fWq3WElzObbtafXVJabUjC3bFyc2BQS+15sC6DLYvOUHqgVyy03bRZ2Q0wVGe1i7vstQKNaNajGJQw0F8uvdTlqcu549jf7AybSUvtn6RoU2GopSLfwZC/aJ0cGDM3D+sctybUVpqHp/2ww8/0LFjxxqPKRQKANq2bUtqaiorVqxgzZo1DB06lD59+vDHH3X7fsvKyujfvz/9+/dnwYIF+Pj4kJ6eTv/+/a840FWj0VzT/lUqleX2ucBhMl15nOGFrzn3uqu95r+cnJyuqZ7aOFZtEn+1hWsmk8to3SeEBk08WP3jEQqydCz9PJ7WfYLpdG8jFCrbbcjzc/Lj4+4fM7TJUD7c+SFJBUl8uOtD/jj+B291eIsYfzHQW6g/ZDLZdXff2AI/Pz8CAwNJSUlh+PDhl32eq6srw4YNY9iwYQwZMoQBAwaQn5+Pp6cnKpXK0lJyvXbu3Fnj/o4dO4iMjEShUHD06FHy8vL46KOPCA4OBszdRhdSq9UANY4fGRmJRqNh7dq1l+w2qitRUVEsWrQISZIsYWjr1q24uLgQFBR0y+qoK7b7bSPYLJ9gFx58O4Zm3RsAEL8mgz8+2UNBlm3OzHuhdn7tWHj3Qt7p+A6ualeOFxznyZVP8trG18SCj4JgAyZPnsyHH37IF198wbFjxzh06BBz5szh008/BeDTTz/ll19+4ejRoxw7dozff/8df39/yxiTsLAw1q5dS1ZWFgUF19c9nJ6eziuvvEJSUhK//PILX375JWPHjgUgJCQEtVrNl19+SUpKCkuXLrWMNzknNDQUmUzG33//zdmzZyktLcXR0ZE33niD119/nXnz5nHixAl27NjBjz/+ePMf1hWMHj2ajIwMXnrpJY4ePcpff/3FxIkTeeWVV5DL7f+r3/7fgWAVKrWCHo804c7nWuDopCI3o5Tf3t/NwfWnkEy2PQZcIVfwUNOH+GfwPwxtPBQZMv5N+5eH/n6Io/lHrV2eINzWRo0axezZs5kzZw4tWrQgNjaWuLg4wsPDAXBxceGTTz6hffv2xMTEkJaWxvLlyy1fyDNmzGD16tUEBwfTpk0b4Pwsths2bLjisR9//HHKy8vp0KEDL7zwAmPHjuWZZ54BwMfHh7i4OH7//Xeio6P56KOPmD59eo3XN2jQgMmTJ/Pmm2/i5+fHiy++CMD48eN59dVXmTBhAlFRUQwbNqzOx4s0aNCA5cuXs2vXLlq1asVzzz3HU089xbvvvlunx71VxNlGwk0rK6xk7dwEMhLNv3KCozzo9Xg0zh431/99qyTkJfDaxtdIL0nHUeHI1G5TGRA2wNplCcI1udLZG4LZ+vXruf/++0lJScHDw8Pa5dzWxNlGgs1wcjcP5r1jWGOUKjkZiQX8OnUnx3ZnWbu0axLtFc3Pd/1Ml8AuVBgreG3ja3yx7wtMkm1OyicIwvVZvnw5b7/9tggu9YhoeRFqVUFWGWvmJJBzsgSAiPa+xD7cBEcn1VVeaX0Gk4HP931O3JE4AHoE9eDDOz7EWe1s3cIE4QpEy4tgT0TLi2CTPPyduP/1dsTcHY5MLiN5Tw6/TNnJySO2uz7SOUq5klfbv8oH3T5ALVez4dQGhi8fzsnik9YuTRAEQbiACC9CrVMo5HS4O5wHXm+Hu58WXZGev788wMafk6iqvLFTGG+lQY0GMffOufhqfEkpSuHhfx5m6+mt1i5LEARBqCbCi1Bn/MJcGfpODC17mucUOLzpNAvf30VWapGVK7u65t7N+fXuX2nl04oSfQmj145m7pG51LNeVkEQBLskwotQp1RqBXcMa8w9Y1vj7OFAUU45f36yl51LUzAabXtArI/Wh//1/x+DIwZjkkxM3zOdt7e8TYWhwtqlCcJFrDnbqSBcq9r671QM2BVumYqyKjYvPMaxXdkA+IS40GdkNJ6Bl56e2lZIksQvR3/hk92fYJSMNPdqzsyeM/Fz8rN2aYKAyWTi+PHjKBQKfHx8UKvVNr9oqnD7kSQJvV7P2bNnMRqNREZGXjRZ3vV8f4vwItxyyXtz2PDzUSrLDCiUcjoPbkTLnkHI5Lb9B3dn5k7GbRxHYWUh3hpvPuvxGa19W1u7LEFAr9eTmZmJTqezdimCcEVarZaAgADLUgoXui3Dy6xZs5g1axZGo5Fjx46J8GLjygorWTc/kfQj5in5GzTxoPeIKFw8bftUz1MlpxizfgzHC46jkqsY32k8gyMHW7ssQUCSJAwGww2v6yMIdU2hUKBUKi/bMnhbhpdzRMuL/ZAkiSObz7D1j+MY9CbUjgq6P9SYxh39bbrZW1el450t77AmfQ0AjzR9hHEx41DJbX8uG0EQBFslwosIL3alMFvHmrgEslOLAWjUxofY4U3QOF/crGgrTJKJ7w9+z6z4WQB09O/I9NjpuDu6W7cwQRAEOyXCiwgvdsdkNLFvZTq7/07FZJLQuKrp9VhTwlp4W7u0K1qbvpa3N7+NzqCjgXMDvuj1BY09Glu7LEEQBLsjZtgV7I5cIaf9wDCGvNkejwAnyov1/DPrIOsXHEVfYbB2eZfVO6Q3Pw38iSDnIE6XnubR5Y+y5uQaa5clCIJQr4mWF8HmGKqM7PgrhQNrM0ACV29H+oyMJiDC3dqlXVZRZRHjNo5jR+YOAJ5v9TzPtXoOuUz8PhAEQbgWottIhJd64XRSAWvmJlCaX4lMBl0eiKB1nxBrl3VZBpOBGXtm8FPiTwD0Cu7FB3d8gJPKtuexEQRBsAWi20ioFxo08eCh8R1p2skfSYKtfySTtDPL2mVdllKu5I0ObzC161RUchXrMtbx6PJHySjOsHZpgiAI9YoIL4JNc9Ao6T0ymtZ9zS0u6+YlciqpwMpVXdl9EfcRNyAOH40PyYXJPLz8YUt3kiAIgnDzRHgR7EKXwY1o1NYXk1FixbeHyDtdau2SrqilT0t+vftXWni3oKiyiOdWP8fqk6utXZYgCEK9IMKLYBdkchl9nogioJEb+nIDf391gLLCSmuXdUW+Wl/mDJjDneF3YpSMvL7xddanr7d2WYIgCHZPhBfBbihVCgY+3xJ3Py2lBZX8PeuATZ9GDeCgcODDbh8yMHwgBsnAKxtfYdOpTdYuSxAEwa6J8CLYFUdnFXe/2AqNi4rcjFJWfn8Yo7F2llivKwq5gve7vU+/0H4YTAb+b/3/se30NmuXJQiCYLdEeBHsjpuPhrtGt0KpkpOekM+mn5Ow9TP+lXIlH3X/iN4hvdGb9IxZP4admTutXZYgCIJdEuFFsEt+4a70G9UMmQwStmayd8VJa5d0VSq5imndp9EjqAeVxkpeWvcSe7L2WLssQRAEuyPCi2C3wlv5cMcw8zpCO5em2PQcMOeoFCpm9JhB1wZdKTeUM3rtaPbn7Ld2WYIgCHZFhBfBrrXoEVRzDpij+Vau6OrUCjUze8ykU0Anyg3lPL/meQ6ePWjtsgRBEOyGCC+C3asxB8x3h21+DhgAR6UjX/T6ghj/GMqqynhu9XMcyTti7bIEQRDsgggvgt2zxzlgADRKDV/1+oq2vm0pqSrhmVXPcDT/qLXLEgRBsHkivAj1gj3OAQOgVWn5us/XtPJpRbG+mKdXPc2xgmPWLksQBMGm1ZvwMmvWLKKjo4mJibF2KYKV2OMcMABOKie+6fMNzb2aU1hZyNOrnuZE4QlrlyUIgmCzZJKtT5Bxna5nSW2hfspOLWbJp/swVJmI7hpAj0ebIpPJrF3WVRVVFvH0qqdJzE/EW+PN//r/j3C3cGuXJQiCcEtcz/d3vWl5EYRz7HEOGAA3Bze+7/s9jT0ak1uey6iVo0gvTrd2WYIgCDZHhBehXrLHOWAA3B3d+aHfD0S4R5BTnsNTq57iVMkpa5clCIJgU0R4EeqtFj2CaGNnc8AAeDp68kO/Hwh3CyerLItRq0aRWZpp7bIEQRBshggvQr3WeXAjItrZ1xwwAN4ab2b3m02oayinS0/z5MonyS7LtnZZgiAINkGEF6Fek8ll9B4ZRUCEfc0BA+Cr9WV2v9kEOQdxqvQUT616irO6s9YuSxAEwepEeBHqPXudAwbA38mfH/v/SKBTICeLT/LUqqfILc+1dlmCIAhWJcKLcFtwdLLPOWAAAp0Dmd1/Nn5aP1KLUnl61dMUVBRYuyxBEASrEeFFuG24+Wi464VWKFVy0hPy2fRzEvYyzVGwSzD/6/8/fDQ+JBcm8/SqpymqLLJ2WYIgCFYhwotwW/EL++8cMGnWLumahbiG8GP/H/Fy9CKpIImnVz1Nsb7Y2mUJgiDcciK8CLedmnPApHJ0h/2chhzuFs6P/X/E09GTxPxEnlv9HCX6EmuXJQiCcEuJ8CLcli6cA2b9vKNk2MkcMACN3BvxQ78fcHdw51DuIZ5f8zxlVWXWLksQBOGWEeFFuG1Z5oAxSfz77SFyT9nHHDAAjT0a833f73FRu3Dg7AGG/zOcv5L/Qm/UW7s0QRCEOifCi3DbqjEHTIWRpV/EU5its3ZZ1yzKK4of+v6Aq9qVE0UneHfru/T9oy/fxH8jTqcWBKFeE6tKC7e9irIqlny2n7xTpTh7ODB4XFtcvTTWLuuaFVUWsej4In5O/JlsnXkWXpVcxcDwgTwa/ShNPZtauUJBEISru57vbxFeBAHQFetZPGMfhdk6XH003D+uLU5uDtYu67pUmapYe3It8xPnc/DsQcv2GP8YHo16lNigWBRyhRUrFARBuDwRXkR4EW5AaUEFf07fR0leBR4BTgx+tQ0aZ7W1y7ohB84eYEHCAladXIVRMgLmuWKGRw3nvoj7cFI5WblCQRCEmkR4EeFFuEFFZ8tZPH0vZUV6fEJcuPf/2uCgUVq7rBuWVZbFL0d/4Y9jf1jmhHFWOTM4cjCPNH2EIJcgK1coCIJgJsKLCC/CTcjPLGPxjH1UlFYR0MiNQWNao3Kw7+4WXZWOv1P+5qfEn0gtSgVALpPTM7gnj0Y9Sju/dshkMitXKQjC7UyEFxFehJt0NqOEvz7bT6XOQFBTD+56oSVKlX0HGACTZGLbmW38lPATW89stWyP8ozi0ehHGRA2ALXCPrvKBEGwbyK8iPAi1IKslCL++jweQ6WRsJbeDHi2OQpF/Zld4EThCRYkLmDZiWVUGCsA8NZ4M6zJMB5s/CBeGi8rVygIwu1EhBcRXoRaciqpgL+/OoCxykRke1/6PNkMubx+da8UVhTyx/E/+CXxF3LKcwBQy9Xc1fAuhkcNp4lnEytXKAjC7UCEFxFehFqUdiiXFd8cwmSSiOoaQM/hTZHVswAD5lOtV6etZn7CfA7nHbZs7+jfkTc6vEGkR6QVqxMEob4T4UWEF6GWJe/NYdXsw0gStOwVRLcHI+vtAFdJkjhw9gA/Jf7EmpNrMEpGAp0C+f2e33FVi39TgiDUjev5/q4/HfiCUIci2vnS6/EoAA6uO8WuZalWrqjuyGQyWvu2ZnrsdJbfv5wg5yDOlJ3hve3vUc9+6wiCYKdEeBGEa9S0cwDdH2oMwJ7laexbedLKFdW9QOdAPu7+MQqZghVpK1iWsszaJQmCINSf8DJr1iyio6OJiYmxdilCPdaiRxCdBzcCYPviExzacMrKFdW9lj4tGd16NADv73ifjOIMK1ckCMLtTox5EYQbsHNpCnuWpwHQ6/EooroEWLegOmY0GXlq1VPszd5LS++WxN0Zh0qusnZZgiDUI2LMiyDUsQ6DwmnZyzy1/vr5iSTvzbFyRXVLIVfwYbcPcVG7cDD3IN/Ef2PtkgRBuI2J8CIIN0Amk9HtwUiiuwYgSbD6xyOkHcq1dll1KsA5gAmdJwAw+9Bs9mTtsXJFgiDcrkR4EYQbJJPJiB3elMgYP0wmiX+/O8yppAJrl1WnBoQN4L6I+5CQeGvLWxRVFlm7JEEQbkMivAjCTZDLZfQeGUVYS2+MBhP/fH2QrJT6/YX+Voe3CHEJIassiynbp4jTpwVBuOVEeBGEm6RQyOn/dDOCmnpgqDSy7MsDnM0osXZZdUar0vJx949RypSsOrmKJclLrF2SIAi3GRFeBKEWKFUKBj7fkoBGbujLDSz7Ip78zDJrl1Vnmns354U2LwDw4a4POVlc/+e8EQTBdojwIgi1ROWg4K4XW+ET4kJ5SRVLZ+6n6Gy5tcuqM080e4IY/xjKDeW8sekNqoxV1i5JEITbhAgvglCLHDRKBo1phWegE2VFepZ+vp/Sggprl1UnFHIFH3T7AFe1K0fyjjArfpa1SxIE4TYhwosg1DKNs5p7xrbGzUdDcW4Ff82MR1est3ZZdcLfyZ9JXSYB8L/D/2NX5i7rFiQIwm1BhBdBqANObg7c83JrnD0cKMzWseSz/STvzcFoMFm7tFrXN7QvD0Q+IE6fFgThlhHhRRDqiKuXhntfboPGVU1BZhkrfzjM3Le2sn1xMoU5OmuXV6tej3mdMNcwcnQ5TNo2SZw+LQhCnRJrGwlCHSsrrOTQxlMkbs2s0X0U1NSDZnc0ILyVNwql/f+OOJJ3hEeXP4rBZGBS50k80PgBa5ckCIIduZ7vbxFeBOEWMRpNnDyUx5HNp0lPyIfqf3kaFxVNOwcQ3S0Qd1+tdYu8Sf87/D8+2/sZGqWGhXcvJNwt3NolCYJgJ0R4EeFFsHHFueUkbsskYesZdEU1W2OiuwXSsLWPXbbGmCQTz6x6hp1ZO4n2iuanO39CpRCrTwuCcHUivIjwItiJ860xZ0hPyKsXrTHZZdk8sOwBiiqLeKL5E7zS7hVrlyQIgh0Q4UWEF8EO1afWmLXpa3l5/csA/NDvBzoFdLJuQYIg2DwRXkR4EeyYyWgirR60xkzZPoXfj/2Or8aXRfcswt3R3dolCYJgw0R4EeFFqCeK88pJ3Hpxa0yDJh40u8O2W2PKDeUM+3sYqUWp9AruxcyeM5HJZNYuSxAEGyXCiwgvQj1zrjUmYcsZTh75T2tMpwBa9grC2cPRukVeQmJeIo8sfwSDycD4TuMZ2mSotUsSBMFGifAiwotQj51rjUnceoay6tYYZw8HHp7YEbWj0srVXWzukblM3zMdR4UjC+9eSEP3htYuSRAEG3Q939+22d4sCMJluXpp6HhPQx7/oAt3PtcCZ08HSgsqiV+TYe3SLumx6MfoHNCZCmMFb2x+A72xfq7zJAjCrSPCiyDYKblCTsPWPnR9IBKA/atOUlZUaeWqLiaXyXm/2/t4OHhwNP8oX+z7wtolCYJg50R4EQQ716itD37hrhj0JnYtTbF2OZfko/VhcpfJAMxNmMu209usXJEgCPZMhBdBsHMymYyuQ8ytL4nbMsk7XWrlii6tZ0hPhjUZBsA7W98hvyLfyhUJgmCvRHgRhHogoJEbjdr4IEmw7c8T1i7nsl5t/yqN3BqRW57LxK0TxerTgiDcEBFeBKGe6HRfI+RyGelH8shItM1WDY1Sw8fdP0YlV7Hh1AZ+S/rN2iUJgmCHRHgRhHrC3U9L89gGAGxdlIzJZJutGk08m/B/7f4PgGl7ppFckGzligRBsDcivAhCPdL+rjDUGiV5p0o5tjPL2uVc1vCo4XRt0JVKYyVvbH6DSqPtnSUlCILtEuFFEOoRjbOadgNCAdi5NIUqvdHKFV2aXCbnva7v4enoybGCY7y34z0x/kUQhGsmwosg1DMtewVZJq47sNY2J64D8NZ48+EdHyKXyVmSvIT5CfOtXZIgCHZChBdBqGeUKgWd7m0EwL6VJ9EV2+6Mtl0CuzCu/TgAZuydwdbTW61ckSAI9kCEF0GohxrH+OET4kJVhZHd/6Rau5wrejTqUQZHDMYkmXht42ukFtl2vYIgWJ8IL4JQD8nkMro+EAHAkc1nKMgqs3JFlyeTyXi307u09mlNSVUJY9aNoaiyyNplCYJgw0R4EYR6qkETD8JaeiOZJLYvtt2J6wDUCjWf9fwMfyd/0orTeH3T6xhMBmuXJQiCjRLhRRDqsc6DGyGTy0g9kMuZ4wXWLueKvDXefNnrSzRKDdvObOPTvZ9auyRBEGyUCC+CUI95BjgR3S0QgK1/JCPZ6MR15zT1bMr73d4HYH7CfBYfX2zligRBsEX1JrzMmjWL6OhoYmJirF2KINiUDneHo3JQkHOyhON7s61dzlX1De3L862eB2DKjinsz9lv5YoEQbA19Sa8vPDCCyQkJLB7925rlyIINkXrqqZtf/PEdTsWp2Coss2J6y70XKvn6BvaF4PJwMvrXyazNNPaJQmCYEPqTXgRBOHyWvUJxsndgZL8Cg6tP23tcq7q3Ay8TT2bkl+Rz5j1Y9BV6axdliAINkKEF0G4DajUCjre0xCAPSvSqCitsnJFV6dVafmi5xd4OnpyNP8o7259F5NksnZZgiDYABFeBOE20aSTP14NnNGXG9izPM3a5VyTAOcAZvaciVKuZPXJ1Xx34DtrlyQIgg0Q4UUQbhPyCyauO7TxFEVn7aMbpo1vGyZ0mgDA1we+ZvXJ1VauSBAEaxPhRRBuI8HRnoQ088RklNi+OMXa5VyzwZGDeTTqUQDe2fIOR/OPWrkiQbBdJXm5FOeerdcrtSutXYBdOfwnNB4Aaq21KxGEG9bl/ggyEnZxYl8OWSlF+Dd0s3ZJ1+TV9q9yovAE2zO3M2bdGH656xe8NF7WLksQbEJxbg5J27dwbPtmsk4cB8DZ04vAxlHmS5Om+IY1RKFUWbnS2iGT6lk0Ky4uxs3NjaKiIlxdXWtvx+k74X/9QOMJHZ6BDk+Dk3ft7V8QbqF18xNJ3JqJf0NX7n+tHTKZzNolXZOiyiIeXf4oacVptPFtw+x+s1Er1NYuSxCsoiQ/l+M7tnJ0+2Yyj51vjZTJ5CADyVRzgLtSpcavUSSBTaoDTeOmaF1t58fL9Xx/i/ByrY6vgeWvQkGa+b7SEVoPh84vgFej2juOINwCZYWV/DRhOwa9iQHPNKdRW19rl3TNUotSGf7PcEqqShgcMZjJXSbbTfgShJtVVljAsZ1bSdq2mdNJCXDuK1wmIyiqGU06dyeyQ2fUjhqyUo5zJimRM8cSOXPsKBWlJRftzyMg8HzrTOOmeAWFIJNbZ0SJCC91EV4AjAZIXArbvoAz1bN+yuQQNQi6jIWgdrV7PEGoQzuXpbDnnzRcfTQ8MrEjCqX9DIHbenoro9eOxiSZeCPmDR6NftTaJQlCndEVF3F85zaStm/mVMJhpAumDAhsEk2Tzt1o3LErzp6X70aVJImCzNM1wkzeqfSLnqfWaAls3NQSaPwjGuOg1SLp9ZgqKjCVlyOVlyNTqVA1aFCr71OEl7oKL+dIEqRtga2fQ/IFZz6EdoOuYyCiL1gpuQrCtdJXGPhpwg7Ki/V0GxpJq17B1i7pusw9Mpfpe6Yjl8n5pvc3dGnQxdolCUKtKS8tIXnXdpK2byb98IEaXUD+EY1p0vkOGnfqhqu3z0WvNeTmUpWZhalch1RRgUlXjqnCHDpM5RWW7eUlJZwtzCO3tIiz5WXkGSq5aP5tScKlsgqP0nI8dBW4l1Wg1Rtw6dGD4G+/qdX3LMJLXYeXC2UnwLYv4dBvYDKYt/lEQZeXoMWDoBT98YLtOrL5NBsWJOHgpOSxqZ1x0NrPYD5Jkhi/dTx/nfgLF7ULPw/8mTC3MGuXJQg3rFJXRvLuHSRt28TJQ/GYjOejhG94I5p0voMmne/AzdevxuskSaLy6FFK1q+ndN16Kg4fvqHjm4BSRzUFTo7mi9aRcoeL/yaoDUaCXDwYHPfzDR3nckR4uZXh5Zyi07DzG9gTB/rqfkWXQOj0HLQbCY62MyhKEM4xGU38+t5uCjLLaNM3hC7V88DYC71Rz5Mrn+TA2QOEuYax4K4FuKpv4b97QbhJ+nIdJ/bs5Oj2zZw8sA+jwWB5zCckjCZdutO4czc8/ANrvM6k16PbuYvS9espWb8eQ2bN9b+U/v7ItVrkjo7ItBrkjhrkGg0yjSNyzX+3OyLTVN/WapA5Vj9H40h5lZ6srNNkZZwkMyWZnLQTGA0GGnfsyqBX3qrVz0KEF2uEl3MqimDPHNj5LZRU/8ekdoH2T0Cn58E18MqvF4RbLO1QLv/MOohCKeeRSR1x9dZYu6Trkluey0N/P0S2LpuuDboyq9csFHKFtcsShEuSJImywgJOJR7m2PYtpO7fg6FKb3ncKyjE3CXUuRteDWp25RoKCijduJHSdesp27IFk+78RJMyR0ecunTBpVdPnGNjUfpc3J1UGwx6PdmpJ1Aolfg3iqzVfYvwYs3wco6hEg79bu5SOlt9CptcZe5K6vIS+EVbrzZBuIAkSfw1M57TSQVExvjR76lm1i7puiXmJfL4isepMFbwePTjvBbzmrVLEm5jlboyinKyKcrOoigni6Kz2Zb7xWdzaoQVMJ/xc65LyDskzLJdkiT0qanm1pV16ynfvx8uGPui9PHBuWdPnHv2wKlzZ+SOjrfoHdYNEV5sIbycYzKZB/Vu/RxObj2/PbIfdB0LoV1BnOYpWNnZ9BJ++2A3AA++1R7fUBv4t3OdVqatZNzGcQBM7TqV+yLus25Bgl2SDAZ0e/ZSHh+Pws0VpZ8fSl8/VP5+KDw9kcnlGKqqKD6bYw4mOdkU5WRRnJNNYfV1RVnpFY8hk8lxDwgkMqYTTbp0xyc03HK6v2QwoNu3j9J16yldvx79yZM1XuvQtKm5daVnLxybRVvttOa6IMKLLYWXC53aYw4xicuA6o89sK35DKWoe0A0dQtWtGZOAkk7swiMdOe+V9rY5dwps+Jn8e2Bb1HJVfyv//9o7dva2iUJN8FkMlKan0dhViaF2ZkUZmdRmHWGwmxzSJAkCaVajcrBAaXaAaVabbm+lm0qtRqlgwMKuQJD8gn0e/dSsWsXFBQik6BCrUSnVqFTKylXq9A5qih3UFOhuHpg0Li64ebrh5uvf/X1udv+uHh5o1Cen+DeWFJC2ZYtlKxbT+mmTZiKis7vSKXCqWNHnHv2wKVnT1SB9XfogQgvthpezsk7Adu/gvifwVBh3uYRbp7wrtn94CSmPBduvZL8ChZM3IGxysTA51sQ3qpu+szrkkky8cqGV1ibvhYvRy9+vftX/J38rV2WcAXmVozsCwJKZvXtLIpzsmoMYLUlCqMJjb4Krd6AVl+FpvpaqzfgrNHi6OuH0s8XlZ+/ufXGzxeVnx9KPz9Ufn4YS0vNrSsb1lO2azdc8D4V7u44x8bi3KsXTl27onB2suI7vXVEeLH18HJO6VnY/QPs+h7KC6o3yqBBO4jsa54vJrC1aJERbpnti0+wb+VJ3P20PDShA4pr+IVpa3RVOh5b8RjHCo4R5RlF3IA4tCqxHpk16ct15lYTSzDJpCg7k4KsTErycs/PEnsJcoUSN19f3P0CcPMLwN0vAHd/cwuGQqmkqrISg16PQX/++nLbqnQ6KjIyKD99Cv3ZsxgkEya5DKNMjlGlRNJoMKkUGE0SJqMBZy9v3HyqW028fXF21OCEHE2VEWVRMYacbAzZORiys6mqvi1VVNzQZ6Ru2NDcutKrF5rWrZEpbr+/+yK82Et4OUdfBvsXwL65kP2f8/O1XtColznIRPQW6ykJdaqy3MBP47dTUVpF7MONaR4bZO2SbsiZ0jM8/M/D5Ffk0y+0H9NipyGX2V8QsycVZaUUZp6hIDuTwswzFGZV387KpLy46IqvVTk44u7nj7t/IG5+/uaA4heAu38ALt7eyG/iB5yxtJTS9RsoWbWK0s2ba4QLpb8/Ln374tqvL5q2bW86MEiShKmoiKrsnOpgk01VVnaNcGPIzsZYUAAKBdq2bXHu1QuXnj1Qh4Xd1LHrAxFe7C28XKj4DCSvgeOrIWUDVBZf8KAMAtucb5Vp0Fa0ygi17uD6U2xeeAyNi4pHp3RGrbHPxef3Ze/jqVVPYTAZGNViFGPbjrV2SXbPElCyzlCYlVl9fYaCrEwqSoqv+FqNi6slkJhbUMxhxd3PH62be62OsTIWFlKydh0lq1ZRtm0bUlWV5TFVUBAu/frh2r8fji1aWGXAq6myEoxG5FrRInghEV7sObxcyFgFGbvMZysdXwPZh2o+rvGo2SrjbD+L6wm2y2g08cvknRTllNPuzlA63Wu/C48uSV7C+K3jAZjYeSJDGg+xckW2r6K0tDqQXH9AcXL3wN0/EI+AwOqgEoi7v7kVxaGOv6gNubmUrFlrDiw7d8IFs9Oqw8Nx6d8P1379cIiKssvB6LcDEV7qS3j5r+JMOLHW3CpzYj1U/qcpNqD1Ba0y7UBhn7+YBetLiT/Lim8PoVDJeXRKJ5w97Hf+iHNnIClkCmb1nkXXBl2tXZLVmIxGykuKzZfiIkoL8inIPGMei1Ld5XO9AcUjINASUtSOt3aCw6rsbEpWraZk5Up0+/bVmAPFoUkTXPr1xbVfP9QRESKw2AERXupreLmQ0QCndle3yqyGrIM1H3d0h0Y9q1tl+oCL3yV3c1mSZG75qdJBVTkYys3XVeXV2yrOP3bu2iPMPH+NWM/J7kmSxOIZ+8hMLqJpZ396j7DfSRUlSeKdLe+wLGUZTion5g6YSxPPJtYuq1ZUVVZQXmwOI7riIsqLiy5xu9hyu6K05Jr2a+2AIkkSprIyjLm5GHJzMeTmma/zcjFW367KyqIyMbHG6xybNzd3CfXrK8aQ2CERXm6H8PJfJdnmsTLJq+HEOvMyBRfybwlBMWCquiCEXBBGDBeGkeqLdNH6olfn5AOtH4G2I8DLfrsbBMhKLWLRx3tBBsPeicE7yMXaJd2wKmMVz615jl1Zu/DV+rJg4AKbP4W6KCeLjCOHKCssoLykyBxCqltMdNVhxFBZeUP7dnR2QePqhpObu6Vbp64DijmQ6DDmXRBI8nKrA8rF4US6xvemadvW3MLSty+qBg1qvW7h1hHh5XYMLxcyGuD03vOtMpnxN7c/mRxUWlBpqi/Vt5Wa89sUavMMwqXZ518Xdod5UcqoQaB0uLkaBKtYOfswyXty8A114f5x7VCo7PeMnaLKIh5f8TgpRSk09mjM3AFzcVY7W7ssC5PJyJljR0nZt5uUvbvIO5V+Ta9TKJVoXN3QuLharrWubmhcXdG4uKF1rbnd0dkFeR2ehmssLaN83150u3ZRmZaG8WwuhrzqQHKdpxHLtVoU3t4ovb1Renmh8Paqvu2N0tsLxxYtUfmJsX71hQgvt3t4+a/SHEheC3nJoHS8OIRc6r7ygm0K1bUtYWCsgmMrYW+cuRXo3CzCGs/zrTE+jevynQq1rCS/goXv76KyzECLnkF0H2bf//+dLj3N8H+Gk1eRR9fArnzZ+0tUcpXV6qkoKyXtwD5S9u0mdf+eGt06MrmcwMZNcfcPvCCQuF10W63RWHU8h0mnQ7dvP7qdOynbtZOKw0dqDJb9L5lWawkjSm8vczipDiNKb28UXl6Wx8XZOLcXEV5EeLG+wnTY/xPsmw8lZ85vD+kC7UZA9L3mcCTYvHOrTgP0f7o5Ee3s+5fukdwjPLHyCcoN5TwQ+QATO0+8pV/++WdOk7JvFyn7dnP66BFMF3zROzo5E9a6HY3adSCsVTscnW2nZegcU0UF5fHxlO3ciW7nLsoPHYILTkUGUAUHo+0Qg2OzZih9fMzhxEcEEuHKRHgR4cV2GA3mVph9c+HYvyBVnw3g6AYtHzIHGT/7W8X4drN9cTL7VqajdlTw4NsxuPva9xfQ+vT1jF0/FgmJsW3HMqrFqDo7ltFg4PTRBEtgKcg8XeNxzwbBNGwbQ6N2HQhsHFWnXTo3wqTXU3HgAGU7d6HbuZPyAweQ9DVXRVYGBuDUoSPajh1x6hAjxp4IN0SEFxFebFPxmeqZhOdB0QX9+UEx5rExzQaD+vZYw8PemIwmlny2n8zkIryDnXng9XYoVbb1JXu9FiQu4KNdHwHwSfdPuDP8zlrbd3lJManxe0nZu4u0A/uo1JVZHpMrlARFN6dR2xgatu2Au39ArR23Nkh6PeWHD1d3A+2ifN/+iwbPKn19zUGlYwe0HTuiCgoSpyILN02ElzoKLya9HrlanAZ800xG8zw1++IgaQWYqhckc3CFFkPMQSaglTUrFC6htKCShe/voqK0imbdG9DjEfs/3fiT3Z8wP2E+KrmKH/r9QDu/dje0H0mSyDuVTsq+3ZzYu4vMY0eRpPNzjmhcXGnYNoaG7ToQ2qJNnU/Ydj0kg4GKI0csLSu6ffuQystrPEfh7Y1TB3NQ0XaIQR0WJsKKUOtEeKmD8GIsLCRl8P24PzgEr1GjRIipLSXZEF/dGlOQen57QGtziGkxBBzs9xTd+iY9IY9lXx4ACfo+FU3jGNs+3fhqjCYjr258lbXpa3FzcGP+nfMJdwu/ptca9HpOJR42nx20bxdFOdk1HvcJCaNhuw40bNsB/4jIm1qfp7bpT56kdONGSrdupXzPXkxlZTUeV3h4oO3QAW3HDjh17Ii6YUMRVoQ6J8JLHYSX/Llzyf7Q3MSsDg/Hf+JEnDp1rLX93/ZMJkjbBHvnQuIy83w0AConaPEAtB1pXstJ/AG1up1LU9izPA2Vg4IH32qPh799d/WVG8p5auVTHMo9RJBzEAvuWoCno+cln1t8NofU+D2k7N9D+uEDNeZZUahUhDRrScN2HWnYtj2u3rYzsFnS69Ht2WMOLBs3oU9Lq/G43M0NbUx7y7gVh8gIq6z5I9zeRHipg/AiSRLFy5eT/eFHGHNzAXC7915833gdpeel/9AJN6gsFw78Yj7lOi/5/HbXIAjrCmHdzBePcBFmrMBkklj6+X5OJxXi1cCJB95oj0ptO60KNyKvPI/hy4dzuvQ0LX1a8mO/H3FUOmI0VHH6aCKp8XtI3b/norlXnDw8adimPQ3bdSS0eStUjrazjEJVdg6lmzZStmkTZVu3YdLpzj+oVKJt3x7n7t1x6tQRh6ZNRVgRrE6ElzocsGssLubszJkU/PIrSBJyNzd8x72K+wMPiH/8tU2S4OQ2c4hJ+AuM/5lx07WBOcSEVgcaz4YizNwiZUWVLHx/N+XFeqK6BNDr8Shrl3TTUopSeGz5YxiKy+hrbEdMeUPSD8Wjv2D8h0wmJ7BJU8Jbtye8TXt8QsNtpjtFMhopP3iQ0k2bKN24kcqEmlPnK3y8ce7eHefYWJy6dEFhg6dhC7c3EV5uwdlG5QcOkDlpsmVtDU3btvhPmohjY/uexMtm6cvMK2ynbTFfTu8937V0jktgdatMV/PsviLM1KlTR/NZ+nk8kgS9R0bRtJNtnTVzrUxGI2eOHyV1/x6O7N5E2emaY1e0bu6Et25HWOt2hLVsa1NzrxgLCyndupXSjRsp27wFY0HB+QdlMhxbtsA5Nhbn2Fgco6LEDyzBponwcotOlZYMBvJ/+omzX3yJpNOBUonXyBF4jx4tJmKqa3odnLogzJzac4kwE3C+iym0m3mtJRFmatXuf1LZtSwVpVrOkDfb4xVoO1/sV1JWWGCe2Xb/Hk4e3EflhQNWZXDWrZJTPuX07fkQj/ccbTNf+pIkUXnsePXYlY2U799fYyVluasrzt26mltX7rhDdGkLdkWEl1s8z0tVZibZH3xAyeo1AKgCA/GbMB6XHj1uyfEFqsPM7gtaZvaAseZEWjj7nw8zYXeIMFMLTCaJv7+MJyOxAA9/LUPebI/aUWntsi5iMhnJPpFMyn7z2JXslOM1Hnd0diGsVVvC27QnrFVbFqT9xhf7v0Auk/N5z8/pEdzDOoVjnn6/bMdOc2DZtAlDZmaNxx0iI3HuEYtz9+5o2rRBprS9z18QroUIL1aapK5k3Xqy3puK4Yz5j4tL3774vfM2Kn/7Pp3ULlWV1wwzp3ZfIsz4nQ8zIV3AIwxUtjPg0l7oivX89v4uyor0NOnoT++RUTYxDkRXXMTJg/tJ3b+HtAP7KC8prvG4b3gjGrYxj13xj2hc41RmSZKYtH0Sfx7/E41Sw5wBc2jmVbszQUsGA8biYowFBRgLC82XC24bCgsxnDmDbs/eGjPayhwdcerY0RJYxGy2Qn0hwosVZ9g16XScnTWL/Li5YDQi12rxGTsGj+HDxS8ia6oqN3ct1QgzlRc/T+sNbg3ALdg8INitQfV1kPnaJQAU4v/H/zpzvIAln8UjmSR6PtaU6K6Bt7yGc60rqfF7SI3fS9aJ4+ZB39XUGq25daV6/Iqzx5W7VKpMVbyw5gW2Z27HW+PNgoELCHS+9PsyVVZeMoBceN9guW++NhUXX3Jfl6Jq0MA8dqVHLNoOHZDb0FlNglBbRHixgeUBKpKSyJo4ifL4eAAcoqMImDQJTcuWVqtJuEBVhblr6cIBwFW6q79OJjcHmEsFm3OhR+sNNjJG4lba+28aO5akoFDJGfJGe7yD6n78i664iJOWsSv7L2pd8Q4JI7x1Oxq2iSGgcVMU1/kDolRfyuP/Ps7xguNEuEcw9865uKpd0WdkULR0KSX//ov+1OmLZqS9HnI3NxTubijc3VG6e6BwdzdfPNxReHiibdcWdaNGNtGaJQh1SYQXGwgvAJLJROEff5AzfYb5V5ZMhsfDD+Pzfy+jcBGzxtoUSYLyAig6BcWnL7g+d/sUFGdePCj4UhRqcA00z0tzLuC4B4N7CLiHmgNOPeyekkwS/3x9kJOH83Dz1TD0rRjUmtptpbqW1pXQlq0Jb20eu+Li5X3Tx8wqy2L4P8Mpy8/mkdOhDDruSkX1j5IaFIqawaP6ttLdHYXHhaHkgtuurqJFVhCqifBSR+ElYfN6Qlu0xsnd47peZ8jLI/vjjyleugwwz7fg/9ZbuNx5p/g1ZU9MJijLMQea4lPV16ehKOP87ZIs4Br+STn7V4eZ6otH6AXhJgiUDnX+dupCRWkVC9/fRWlBJRHtfen3VLOb/m9cV1RI2rmxKwf3U/Gf1hWf0HDCW7cjvHX7G2pduRKTXk/phg2c/uNnDFt2ojx3Yo9cjlOnTrjdew+aNm1QuLsjd3ER/54F4SaI8FIH4eXIxrX8+/VneAQG8eD493DxvP5fdGXbt5M1aTL6kycBcOrWDf8J41GHhNRanYKVGaugJPOCYFPdglOYAYXpUHgS9KVX2YnM3DV1UbC5INwoVLfk7dyIrJQiFk/fh8kkEftwY5rHBl3X600mI1nJx0iN30vq/r1kpybXaF1x0DoR2qI1YW3aEd6qHc6eXrVavyRJlO/bR9FfSyn+998aY1PSfGVsai4j4sGRPNXztVo9riDc7kR4qYPwUpB1ht+nvkNJ7lnc/PwZOv4DXH2uf+0SU2UlebNnk/fd90h6PTIHB7yffw7PJ58Uiz3eDs51TxWeNIeZgurrc8GmMP3qY29kcvOEfBcGGycfUDuBSgtqZ/Nty8X5/GO3aCzO/tXpbFuUjFwpY8jr7fEJuXI3qa6okLQD+0iN30vagX1UlJbUeNwnrGF160o7AiJrt3XlnMrUVIqWLqV46TKqTp+2bFf6+eE26G5cB93DUuKZumMqAO93e597Gt1T63UIwu1KhJc66jYqPpvDb1Pfpig7CxdvHx4c/z4e/jd2VoU+LY3MyZPRbd8BgLphQ/wnTcSpQ4faLFmwN5IEurzqUHOyZqg5dzFU3Pj+VU7/CTaXCDmXuu3ZEHyagvraJl+UJIkV3x4i9UAurt6ODH2nAw4apblVo7iI3Ix08k6nk3cqg6zkYxfNu+KgdSK0ZZtrPjPoRhny8yn+ZzlFy5ZRcfCgZbtcq8WlXz/c7r0HbYcOyBTnT6P+bO9n/O/w/1DKlHzb91s6BogFWgWhNojwUocDdkvyc/l96rsUnDmFk4cnD45/H68GwTe0L0mSKP77H7I/+ghjXh4Azj174v3cs2hatarNsoX6QpKgNOeCUFMdbMoLzEso6MvM3VL6MvPEfefuX8s4nKuSmefC8WsGvlHgG22+eDW6qBtLkiTyM8+yeNpqygqycPHUoXUpJe90xkVjVs7xDWtEeBtzWAmMbIpcUTeLPZoqKihdt46ipcso3bIFDAbzAwoFTt264jboHlx690Ku0Vz69ZKJ1ze9zsq0lbioXJg/cD6N3BvVSa2CcDsR4aWOzzYqKyzgj/feJTfjJFo3d4a8+x4+IWE3vD9jURE5n35G4W+/Wfr2nbp0xuvZ59B2iBGDAIWbI0nmeW5qBJvq21W6S2z/z/2KIsg9BmVnL7nrUsmJPIdI8uWB5OpdyCuVyM8tokJ3me4vmQx3X388g4LxCgrBJziUkBsYCH9dH4HJhG7XbvPpzStXYrpgOQDH5s1xu2cQrgMHovS+trFslcZKnl71NPtz9hPkHMRvg37DRS3OIBSEmyHCyy04VVpXXMSi9yeQk3YCR2cXhrwzFb+GETe1z8qUVPJ++IGiZcssvwY1bdrg/dyzOHXvLkKMYDWSJFGSkUR+wg7yUhLIPZVOXm4x+SUmKk2XHn8iQ8JdK6F09CNfF45C6UWf4a2J6NoOlUPdnyouGQxUJB6lZNVKipb9jSEry/KYMjAAt0H34HbPIBwa3VirSWFFIcP+HsaZsjP0D+vPtO7TxL9RQbgJIrzconleKspK+fODiWQmJ+GgdeL+tyYR2Djqpvdbdfo0eT/+SOEfiyzTgjtER+H97HO49O1jM4vECfWTrqiQs+lp5GWc5Gz6SfIyTpJ3Oh39ZSZik8nluHu64uWqxMuhHC+y8dKn4KEsQSU3IUmwsvA1TlR2wUWew9CQD3AMCKvudqrufvJsCFrPm1prStLrKT98BN2ePej27KZ8774aLSxyFxdcB/TH7Z570LRrVyv/jg6cPcDIFSMxSAYmdJ7Ag40fvOl9CsLtSoSXWzhJnb5cx58fTeb00SOoHDXc/8ZEgqKb18q+q3JyyI+bS8Gvv5pXrQbUjRrh/czTuN51l5jcSrgp+opy8jLSLUElNyON3Ix0dEWFl3y+XKHA3T8Qr6BgvIJCq69D8AhogFL1n1O3jVWQdwJyjkBOIpWnj/PbrrsorvImzGEXA90/vDinOLiaz57yCAfP8JrXrg0uWpbBVFFB+YGD6PbsRrd7D+Xx8UgVNQczy52d0XbqiNvdg3Du2QO5Q+3PnzPn8Bw+3fspDgoHfr7rZxp7NK71YwjC7UCEl1u9qnRFBUumv0f6oXiUagfufe1dwlq2qbX9GwoKKJg/n/yfFljmnFAFBeE1ahRu9w8Wp1gLV2Q0GCg4c4rcjJPnL+lpFOVkX/oF1WNSvENC8Q4Jwzs4tDqkBKJQ3vj8MmfTS1j0yR6MBokunYpo478bchLgbBKUnLnyi+VKjNpgyst80eWo0aXrqEjNQTIYazxN4e6ONqY92pgYtO3b49CkSY0zheqCSTLxwtoX2HJ6C+Fu4fx6169oVdd2VpYgCOeJ8GKF5QEMej1LP/2A1P17UKhUDPq/t2jUrnZPezaWllLw8y/kx8VhzM8HQOnri+eTT+AxdChy7f+3d9/xVdX348dfd2ZPsjdhjwwIIYADZYMiOHCUWrQKrUVbu9TWKtjaasWv9Sciooi4WhEHCAiyQWYCCSEhrJAQskP2vrnj/P44yU0C2dyMGz7Px+M+7jrncz4nJzf3nfdniT+YNzPJZKK88KqcQbnSGKgUZ2dhMhpa3MfB1a0+QAnCI7AxUNF008J/yQezOfDf8yiUCu79wxh8B7vKb+hr5FFTxelQkg7F6RhzUqk+m051WjHV+WpqSzQgNU/XqG2N2HvpsA+wxX6YH9rBQ1EMCJVHRTVkbRw8bqg5qiOKa4tZ8P0CCmoKmDdoHq/e+mq3Hk8Q+iMRvPTS2kZGg56tb79BatxRlCo1d//uOYbETLL4cUw1NZRu3EjRR+sw5Mv/Pavc3HBftAi3hT8T6ybdJAx1dWSmJJEWH0d+2kUKM6+gr225X4rWzo4BgcF4BobI90HBDAgMxt7ZpUfrLEkSu9alcDEuHwdXGx76WzR2jnLm0FBURPWJk1THxVF94gS68+ebzawLoPF0wT7UDXtfJfZuZWhMmSh0pW0fVGUj96excwM7d7BzrX9e/1rT95o+VncuoxmXF8eTO5/EJJn4163/Yu6guZ3aXxBudiJ46cWFGY0GA9tXvcX5IwdRKJXMXvoHRtx6R7ccy1RXR9mmTRR9uBZ9ZiYgd0p0W/gz3BctQu3WfUNPhd5RXVZKWnwcl07GknE6Ab3umj4eKjUD/AMYENjY5OMZFIKTh2efGAkjSRK1V0v45q0kykqN+LrWMkEbS83JE9RdunTd9tqQkGbNQBq/FiaFrCmpz9hcNmdtKLks35dn0+U5bjQOTYKZa4Ic83N3cPSUl3Nw8GJ18oe8d+o97NR2bLh7AwNdBnbt2IJwExLBSy+vKm0yGdn5/krOHNgNCgUzf/VbRt85vduOJxkMlG/fTuGaNdSlyl8ACjs73B56CPfHH0fj3fllDIS+QZIkCq9c5tLJWNJOxpJ76UKzbISjmzuhUeMJHBmGR1AIbr7+3TJ1fmfqaywqQp+Tgz47u/4+R76vf81UVUWlgx8nxv4Zk0pLaNpmQq7sBMBm6FDsx42TA5Zx41B7et5YhQw6qMyXA5zqYqgprn9c0uRx/X1Nsfy4thQkU7tFX0ehxOjgxZIB9sQqDQxVOfKF/z3YugSAs68c4Dj5yoFPHwgkBaGvEcFLLwcvIPc/2LNuNYm7tgMw9YnfEDljTrcfs2L3boreX0NtSgoACo0Gl/vvY8CTi9EG+Hfr8QXLMOj1ZJ05zaX4WNLi4yi/WtDsfe/QwYSOHc+gqPF4DRzUoxkVyWDAUFDQGIw0BCkNAUpuLpJO1245Kjc38kKnkuR0JyAxYgiMuXc0bqHe3X8S7TGZQFdWH9SUNgY1TQOcpo8rC+QASZI7D19VKXnA35dilYqHyiv4W1FJ8/JVNuDkA85+8r2T3zXP64OcDi7FIAj9hQhe+kDwAvJ/ofs/XUv8D5sBuOMXTxJ11/weOW7VoUMUvr+GmpMn5RdVKpznzMH5rjk4TJokRij1MdVlpaQlnCDtZCyXTyc067ui1mgJCotgUFQMoWOjLb6KcmuMlVVU/XSQykOH0F/JlIOU/HwwGtveUaFA7eWFxs8Pjb+/fO/nh8a//t7XF6W9vfz5+OI8KYfkkUYKpYLBYz2JnB6EV3DvfnY7zWSUZyCuyIXyXA7nHuXXVzYB8H9KX2ZUVMrv1RR3vEwbFzmYcfBobKKyH1B/a/LYzk2+t3XpvYyOUQ+6CtCVQ215/eMKsHEE79FyPyNBaEe/CF6qq6sZMWIECxYs4M033+zwfn0peAE5kDj05afEbtoIwK0P/4KYex/sseNXx8VRuPp9qo4cMb+mtLfH8Y7JOE2bhsPtk1E5OvRYfQSZJEkUZmaQdjKWS/Gx5F5s3jnVwc2d0LHRDIoaT9DoiB6ZkRbkYfmVe/dSsWs3VUeOmCdJbEajQePj0yQouSZA8fZG0cHgWJIkMs8Wc2rXFTLPNmYo/Ie5EjktiOBRA1AorbOJ5e2Tb/NR8kc4ahz5au5XBDoFgr4WKvOgIg/Kc+T7itz6W545+EFf1f4BrqVQNQY1DZ2PmwU51wY/7nK/nrpKOejQVTQPPHTlja83vdWWXfNaefuLhboGgU94/S1MvrkEiOYzoZl+Eby8+OKLpKamEhgYaNXBC8h/oI99+yVHvvoCgAn3P8ykBQt7NN1fk5RE2XebqNi9G0NBYzOEQqPBYdIknKZPw3HKFNTu3bN6r1DfHJSSJPdfiY+j/GrzeVa8Bg5iUNR4BkXF4BUS2mMzKetzcqjYvYeKXbuoPnlSbjappwkOwmnqNGxHjjQHJ2oPj26ZO6Uwq4KEXVdIjSvAZJL/LLn5OhA5LZBh431QaaxrZmm9Sc/jOx4n8WoioweM5tPZn6JRdWCeHEmSg4KGoKa6WF5pvKZEvq8uanytoR9PXWX3n1BHqO3A1hlsnOTVyGuK5SHwLbF1lYMY34jGgMZj6HWLfAqdZzTKn2GVyro+M1YfvFy8eJEXXniBuXPnkpycbPXBS4O477/h4BcfAzBu7n3cvvDxHh8BIplM1CYlUbF7NxU7d1GXkdH4plKJ/dixOE2fhtO0aWj8RR+ZG1VTUV4/Oug4lxNbbg4KHTue0KhonNw7tiigJeguXaJi1y4qdu2m9syZZu/ZjByB0zT5d8BmyJAe/x2tKK7l9L4szvyUjb5WbqKyd9YSdmcAo2/3x9bBer7ccipzWLBlAeV15SwauYg/Rf+pew6kr23sg1NdVP+4Ici59rUiucNyXUXj/mo7OeBoCDxsnOQZj22aPm94/5rXmj5vKfCoKYG8ZMhLqr+dhqvnwNTC3EMqG3nJCJ+wJlma0XLZQofU1Rj439+PY+uo4YHnx6FSW08A063By8GDB1mxYgUnT54kNzeX7777jvnz5zfbZtWqVaxYsYK8vDwiIiJYuXIl48d3fMK2efPmsWLFCo4cOdKvgheA+O1b2Ld+DQCRM+9mymNLem2tIkmSqEtNlQOZXbvNnXwb2I4cKQcy06ejHdSzHUOtWWleLqknjnHpxHGyz6UgNRm54uDqRujYaEKjYggeHdFtk8FdS5IkOWjdtZuK3bupS09vfFOhwC5qrDlg0QYE9Eid2qOrMZByKIfTezOpLJE7AattVIyc5EvE1ECcPex6uYYds/fKXn6373cAvDvlXSYHTu7lGtUz6ORVw1sLOrr72FfPycFM7unGwKZpQNWUe2hjdsanPlPj5COanVqQcjiHfZ+dA2DyI0MZPblvfJ47oluDl+3bt3P48GGioqK47777rgteNmzYwC9+8Qvef/99YmJiePvtt9m4cSPnz5/Hy0seshsZGYnBcH3UvXPnTuLi4jh06BArVqxg/fr17QYvOp0OXZPRDeXl5QQGBvbZ4AXg9J4d7PpwFUgSYVNmMG3xUpTK7p3CvCPqsrKp3CMHMtXx8c2aD7QhIeaMjG1YmFgcsgnJZCIv7SKXThwnNe4YRVnN0+SeQSEMip7AoLHj8Q4d3GM/O8lgoPrECTlg2bOn2arKCo0G+4kTcJo+HacpU1AP6JlOwF1hNJpIPVFAwq4rFGXJzSMKBQwa60Xk9CC8Q/rm57yp12Nf54uzX+Bi48LXc7/Gx8Gnt6vU95hMUHq5SYamPrBpbekI+wFy01PTeXzMX2dSK8/hmget76NSy9mfoAkQNFF+3MmJC3vDdytiybkkf04cnFT8/JXxqO2tI9DvsWYjhUJxXfASExNDdHQ07777LgAmk4nAwECeeeYZXnjhhXbL/Mtf/sLnn3+OSqWisrISvV7PH//4R15++eUWt1++fDmvvPLKda/35eAFIOXgXna89zaSZGLEbXcy66lnUXbzGiydYSgubt5xU683v6f29sZp6lScpk/Dftw4FNcuyncTMOj1ZCYnyhmWk7FUlTSOIlEolQSOHM2gcRMYFBWDi1fPDf811dZSdeQIFTt3UblvH8ayssZ62dvjOPl2nKZNw3HyZFSOjj1WL0uQJImscyWc2nWFKymNP2+/Ia5ETg8iZHTf7dxbZ6zj5z/8nLPFZxnrNZaPZn6EWikWVu2QqsLmTU55SVB4oWtz8dwItS34j6sPZiZAQHTvj6LS18o/j+yTkH2S8svpfHbxr4AJe2Up1SZ3bnVaR4RvgrxkhltI/eKn9Y9dg8HRq89ksHoteKmrq8Pe3p6vv/66WUCzaNEiSktL2bx5c6fK76+Zlwbnj/7EDyvfxGQ0MnTCrcx55k+9OsFYa4yVlVQdPEjF7t1U7j+AqX6FawCliwtOd9yB0/Rp2IaHo7S1RWFjg0Kr7fPNTJLRiKTTYdLpwGRC5ebWZlakprKC9Pg4Uk8cu67/isbWjoGRUQweF8PAMdHY9lBgIEkSxpISqg4foWLXLioPHTKvQA7yfCqOU+6UR5ZNmtQtqyr3hsKsShJ3X+FCXD4mo/wnzNXbXu7cO8EHtabv/CPQ4Er5FR7c+iBV+iqWhC/hmTHP9HaVrJe+Rl7Qs9kop/q/N+a/O03+/lz7WrM/Ta3sV1cJWScg8zhcOSr33eGa/bxHQWCMnJkJmgCugTdwUu0wGeVzrg9UyImH/DPN+g6dqHyA45ULCbC/wBC3ZPZl34edspSfezyFVtnKiDCNvRzEXBvUNAQ62p4bjdqZ4MWi35SFhYUYjUa8vZv/p+nt7c25c+cseSgzGxsbbKz0D/KwibehUmvY+vbrXDh2CIO+julPLu2xeTw6SuXoKM8RM2cOpro6qo8epXzXLir37sNYXEzZ5s2UXRuYKhRyEGNjg7Lh3tYGhY1ts9cUtjYotTYobG3l97X1r9k0bKuVAyKtDZLBUB9s1CLp6pB0tZh0OvlxbS2mOh1Sra75NrW1mOrk+4ZAxRywNMkmAaBWo/H2Ru3rg8bHF42vLzXOjmRXlXMlN5OcK+lITZrSHN3cGTQuhkHjJhA4Khx1N2SgTDU16HPzMOTlos/NRZ+bhz4vF0NOLvq8PHlSuJrm6xmpfX3N/Vfso8ai6IMB8Y3yCHBk6mMjiZk3iNP7MjlzMJvS/Gr2f3Ge49+nEXZHAGGTA7B17DtZwSDnIJZNXMZzB5/jw9MfMs57HBP9JvZ2tayTxg78Irv/OCG3yvcmExRdhCvH6m9H5aUo8pPl24mP5O2c/eUgJrA+O+M9CrrSJUCS5FFaDUFKdjzknGp5CL2DJ/hHIflFce7HKACGLZjHkPFLOLn8OOVXIWnUN0SNyIGSjPplNC5DaQaUZYG+Gq6elW8tcfC8JqAJkYMa91B5uHsvsWjmJScnB39/f44cOcLEiY0fyueee44DBw5w/PjxG65we/p6h92WpJ86yfdv/hODXp5Tw9XHl4ARo803Z0+vPpnFkIxGauLj5Q6/e/aiz86+biE9ayMBZXY2FLjYk+/sQIVd88DYSafHFzWBLgPw9A9A6+ePxtcHja8vah9fNL4+KO061r5snq22Pigx5OWibxKUGHJzMZaWdqgs7aBBcsAyfTq2o0b2yd+X7lRXYyDlcA6Je5p07tUoGTHJl4hpQbh49p02/+VHlvPNxW8YYDuAr+/5Gg+7nhtlJlhQRT5kHoMr9ZmZ3ETzLMtmWicIjG7MzPhHtZzJqCqqD1LqsyrZ8VBdeP12WkfwjQT/sXJZ/lHm+XLy0sr45o2TqLVKHn/jVrS2as4fz2P3xynY2Kt59J+TsLG75h8ZQx2UZTYPaBoel2TIS2W0JnACPPFjZ35i7eo3zUZdYY3BC0BmShIHPltHQfqlZqNTAJwGeBIwYhQBI0bjP2IU7n4BffLLSZIk0Osbsxu1OqQ6nZz9ML92TdakfpuWXm/Inhhraqiqq8GkUqPUauUJ0LRalFoNaLQobLQoNBo5a6PVyE1WGi1o1HIziVqD0kYLGg0KjbZ+m/p91WoUWi3V5aVcOvwTaafjqapsHPGgAAaYFHiXVeGZdxX7uhaGd15D5eqK2tdXnsjN1xe1rw9KG9v6oCQHQ259cHL1arNO0a1R2tuj9vM1Z4PMmSE/+RhqHx+UPTRqqa8zGk1cii8gYecVCjPlTotqrZJ5vx+Dz8CeXUG7NTWGGn627WeklqYywXcCa6avQakQHeCtXl2VHHg0ZGYy464fPaVQyfPaBE2QR0vlnJL3Kc24vjylWp6d2D+qMVjxGNpqJufAf8+TfDCboTHeTH98FAAmk8SXfz9OSV410XcPZPzdnVwotKZEDmLMQU2T4CZ4Esx7t3PltaPXO+yOHz+elStXAnKH3aCgIJ5++ukOddi9UdYavDTQVVeRfT6FrLNnyDqbTP6li5iumY7d3sWVgOGj8B8xmsCRo/EIDLb60T+1VZWU5edRmp9HWUEepfm5lNU/Li+82qy5prtpbO0YGDGWQeNiGDg2GjtHeY4JU20thry8+iCkSSDSJCgxVXVyZlSNBo23d2NQ4uuHxlcOSBoeK52c+mSw2pdJkkT2hVKOb75EXlo5dk4a7n8uChfPvrFe0KXSSzyy7RFqDDX8dsxvWRy+uLerJFiaySj3SblyrD5Dc6x+lfNWDBjcmE3xj5IDF03H/ikx6k18/MIhdFUG7vltJIEjGycbTT1ZwI8fJqO1VfHoq5P6VFPqtbo1eKmsrCQ1NRWAMWPG8NZbb3HnnXfi7u5OUFAQGzZsYNGiRaxZs4bx48fz9ttv89VXX3Hu3Lnr+sJ0B2sPXq6lr60l5+K5+mAmidyL5zFe01fDxsEB/+FyZiZwxGi8Bg7qUyOXAExGIxVFhXJQUpDXLFApy8+jtqrtGUJVGg0abX0TjqKxg535K73+taZf8oo2tjNvjwIU8oRxgaPCGNzQf6WLaz8ZKyrQ5+TW91Gpz7Dk5WLS1clBil9j85LG1xfVgAFWH3j2ZXW1Bja9lcDVKxW4eNnxwHPj+swf7+8ufsfLR15GpVCxbuY6xnqP7e0qCd2tNLMxM1NdKA+/9o8CvzE3NHIpLeEq29ck4eCi5Rev3YKyyag7ySSx4V9xFGVVMnZmMBPvHWSBE+ke3Rq87N+/nzvvvPO61xctWsT69esBePfdd82T1EVGRvLOO+8QExPTmcN0WX8LXq5l0OvJu3SBrJRkss4mk3P+LHpd817kGls7/IYOl/vMjByNz6Ch3dKZ9Fq66uomgUlufQZFfl5eWHBdBula9i6uuHr74uLtg4uXD67ePrh4++Dq5YODa9sjgQShNVVlOr7+9wkqi3X4DnLhnmcj+8RoJEmS+Ouhv7I1bSve9t58PfdrXG1de7taghX6YfVp0hMLGTMjiEn3Db7u/fTThfzw3mnUWiWPvjoJe+e+OV+N1S8PcCP6e/ByLZPRSEH6JTLPysFM9rkz6K5pulBpNPgOGYZnsNzeaTIYMZmM8r3RgMloxGQ0YjQakIxGjEaj+b7p+yaDQd7P/NjU+JrBaO5w3BqVWo2zlw+uXt64ePvKwUlDkOLl02OzzQo3n6KcSr5dEU9djYHBUV7MeGJUn5gTpkpfxcNbH+Zy+WUmB0xm5ZSVoolQ6JSayjrWP38Yk1Hi4ZfGM8D/+mkaJEni63+fpOByORFTA7l1wZBeqGn7RPByEwUv15JMJgozM8hMSSb7bDJZ585QXVbaY8e3c3bB1cvnuuyJi5cPTu6iiUToPVnnitmyMhGTUWr1P9TecK74HAu3LaTOVMdz0c/x6MhHe7tKghVJ2p/FwS8v4BHoyEMvtr4Mz5WUIra8k4hKreTn/5iIo1vfm2Kk1+Z56U2rVq1i1apVGNtpmujvFEolnsED8QweyNjZc5EkiZLcbLJSkinNz0WpUsk3pQqlWt34XKVGqVKiVKlRqVQoVCpUKjVKdf22TR+rr99fpVJj4+CIjX3f6BApCNcKGO7OlEeHs3v9WRJ2XsHZw47Rt/f+4qPD3Yfz5+g/88/j/+Stk28xxmsMoz1G93a1BCtx7pi87MfwCb5tbhc4wh3fwS7kppZxcsdlJj8yrCeq121E5kUQhJtK3LZ0Yreko1DAnN+EExLW+/OsSJLEHw/8kV0Zu/B39Gfj3I04acVKykLbSvKq+O/y4yiUCh57/ZZ2+7JkXyhh01sJKFUKFr4yoc8tbtqZ72+RwxcE4aYybk4IIyb5Iknw49ozFGSU93aVUCgULJ+0HH9Hf7Irs3nl6Cv0s/8rhW5w/ricdQka5d6hTrj+Q90IGO6GyShx4ofL3Vy77iWCF0EQbioKhYLJC4cROMINg87ItlWnKS+qaX/HbuasdeaN299ArVDz4+Uf+XzbZr598yRpCVd7u2p9jiRJZJwpMs+mfDOSTJI5eBkW0/FVymPuCQXk5qbS/Op2tu67RPAiCMJNR6VSMmtJGAP8Hagur2Pru6fRVevb37GbhXuG87vIZ7kl/X7KtzqTm1rGjg+TRQBzjWObLrF1ZSJbVp7CZLo5M1Q5F0upLNahtVMzMLzjTZ8+oS6EhA1AMknEbUvvxhp2LxG8CIJwU9Laqbn76QgcXLSU5FaxfU0SRkPPzeTckrKrNdhvG0lY3u3yc+d8JJPEj2uTuZzUwlo3N6HEPZnE/3gFgOKcKlJP5vdyjXrHufqsy+Cxnqi1nZu3aPxcOftyIS6fopy2Jwjtq0TwIgjCTcvRzZa7no5AY6Mi+3wp+z4712t9TdISrvLVv+K4mlGB1l7FkfANfDnydXQhVzEZJXasSeZKSlGv1K2vuBCXx6GNFwHwDJI7NMdtvYzJaNmg80LJBf584M+kl/XNzIS+zsilkwUADGtnlFFLPIOcGDTGEySI29I3z7E9IngRBOGm5hnoxKwlo1EoFZw/nkdsD/8xNxpM/PTVBbavSaKuxoBPqDMP/y2GZ+97Eklh4hPvf+E2XI3RYGL76iSyz5f0aP36isyUYvasPwtA+J0BzP/DGGwc1JTmV3MxznLZF0mSeOXoK+y4vINXj71qsXItKf3UVfQ6I84etvgO6tqCo9FzB4ICLiVc5eqVivZ36GNE8CIIwk0vaNQA7viZPO/FiR8uk3I4p0eOW15Yw7dvxnN6bxYAkdODmP/HsTi52xLtE82CoQswKU38N2AFgaPcMOhNbH3vNLmppT1Sv76iIKOc7WuSMBklBo/z4tYFQ9Daqhk7IxiA2G2XMVoo+xKbF8vpq6fNj2NzYy1SriWdr5/bZWiMT5dnih7g58jQaHm9wdgtaRarW08RwYsgCAIw8lY/ombJX4YHvjhPZkpxtx4v7ZTcTFRwuRwbezVzfhPOLfcPRqVq/LP8+6jf42XnRUbVZS6NP2AeIbXl3UTy03t/iHdPKM2vZuu7ieh1RgKGuzFt0UjzF3bYHQHYOWkov1pj/kK/UR+c/gAAR408zf6qU6v61LD1qjIdmWfl383OjDJqSfRdA1EoFVxOKiIvrcwS1esxIngRBEGoFzMvlCHR3phMEts/SKIwy/KdGY1GE4e+vsj295PQVRvwCnHmwRejWxwx4qR14sUJLwLwyfn1hD5og98QV/S1RrasPGWV6f7OqCrTsWXlKWoq9HgGOTH7V2GoNI1fWxobFWNnygHniR8u33CH61MFp4jNi0WtVPP+9PfRKrXEF8RzLPfYDZVrSRdi85EkedSQq9eNzWju6m3P8AlyAHT8e+vKvvSb4GXVqlWMHDmS6Ojo3q6KIAhWSqFQMPUXI8wBwtZ3Ey06l0hFcS3fvRlP4u5MACKmBnLfn8biPKD1mU6nBE1hRvAMjJKRv59YzqynRuET6oKu2sD3/+8URdnWOVqkPboaA1tWJlJeWIuzpx13Px2B1u76FW1G3e6PvbOWiqJazh3NvaFjNmRd5g2aR4RnBA8OexDoW9mXhgzTsAk3lnVpMG5OCEqVgqxzJWRfsJ7+VP0meFm6dCkpKSnExcX1dlUEQbBiKo2S2b8Ow83HnqpSHVtXJVJXY7jhci+fLmTDq7Hkp5ejtVMz+9dh3LpgCCp1+3+G/xLzF5y1zpwtPsv/0r7g7mci8Ap2orZKz+a3EyjJq2q3DGti1JvYvvo0RVmV2DlpuOe3Ea3OIKvRqoia3ST7ou9a9iWlKIWfsn9CqVDyy9G/BOCJsCewVdmSeDWRwzmHu3YyFlSYVUFRdiVKtYLBUV4WKdPZw46Rt/oBcvalrwRp7ek3wYsgCIKl2DpouPvpCOyctRRlVfLjh8ld7hBqNJo48k0q2947LTcTBTvx0IvRhEZ6drgMDzsP/hz9ZwDeO/Ueefps5v42Eo9AR2oq9Gz+TwKlBdY7W2pTJpPEro/PkH2hFI2NirnPROLi2XbzyMhb/XBwtaGyRNflztZrk9YCMHvgbIKcgwD55/7QsIcAWJXQ+9mXhkUYB4Z5YOugsVi5UbNCUKmV5KaWmfvT9HUieBEEQWiBs4cddy8NR61VciWlmIP/Pd/pL6/Kklo2/V8CCbvkSdXC7gzgvj9FdWlBvHmD5jHRdyI6o45Xjr6Cjb2ae34XibufA1VldWx+O6FPLHNwIyRJ4tCGC1yKv4pSpWD2U2Hm+VzaotaoGFeffTm5/TKGOmOnjnup9BK7MnYB8OToJ5u99/jox7FT25FclMzBrIOdKteSTEYTF2LlIeGWajJq4Ohmw+jJ8grrxzdbR/ZFBC+CIAit8Ap2ZsaTo1EoIOVwLid3ZHR434zkIja8GkdeWhlaWxUzF4/m9oeGNutw2hkKhYKXJ76MndqOuLw4vrn4DXaOWuY9OwZXb3sqi3Vs/k8ClSW1XSq/Lzi5PYOkA9mggGmPjyRwuHuH9x0xyQ9Hdxuqyuo481Pnsi8NWZdpQdMY7Da42XsD7AbwyPBHgN7t+5J5roSa8jpsHTUEjRpg8fLHzgxGrVVSkFHB5dN9fzZnEbwIgiC0YWC4B7c9NBSQ/yttWAyvNSajiaObLrH13URqq+RRMg++GG2RPgoBTgE8Hfk0AG+deIuC6gLsneUAxtnTjvLCWjb9J4GqMutbsDDlUI55xMttDw5hyDjvTu2v0iiJnjMQgJM7LqPXdSz7klmeyQ/pPwDwZPiTLW7z2KjHsFfbc7b4LHsz93aqXpbS0FF3SLR3h/pJdZa9s5bwKYEAHN+SjtTH14wSwYsgCEI7wu4IIHKa/Id976dnW53ltrJEx6b/JBBfn6EZPdmf+/48tt0+G52xcMRCwjzCqNBX8M9j/0SSJBzdbJj/+zE4udtSVlDD5rdPUVNRZ7Fjdrf0xKvs/+IcAFGzggm/M7BL5Qyb6IOzhy01FXqSD2R3aJ+Pkj/CJJm41f9WRg0Y1eI2brZuLByxEJD7HJmknl0Dq67GQNopeXHOG53bpS1jpgehtVVRlFXJpT6+GKgIXgRBEDpg0n2DGTTWE5NRYvuaJIpzm4/wuZJSxFf/iiU3tQyNrYoZT45i8iPDUGs6t2hee1RKFcsnLUetULM3c6+5r4aTuy3zfh+Jg6sNJblVbH77FLVVvb9SdntyU0v5ce0ZJAlGTPIlZl5ol8tSqZSMq8++xO/MoK627VFieVV5bL60GYAl4Uva3HbRqEU4ahy5UHKB3Rm7u1zHrkiNL8CoN+HmY49XcNt9gMp0Zdy7+V5mfTOL9069R3Zlx4I4kDuqR0yTOyvHbknr0yt2i+BFEAShAxRKBdMeG4lPqDO6agNbVyZSVabDZJI4/n0aW1YmUlOhxyPQkQf/Et3pZo/OGOo2lCfCngDgX8f/RZlOnh3VxdOeec9GyqOksiv5/v+dQmeBYd7dpSinkm3vncaoNxESNoA7Fg5DoejadPcNhsV44+JlR22lnqT9WW1uu/7MegwmA9E+0YzxGtPmti42Ljw68lFAzr4YTZ3rFHwjms7t0t7P55/H/0lqaSrZldmsTlzNrG9m8eTOJ/kh7QdqDe33h4qYGoiNg5qSvGouxlpm1uLuIIIXQRCEDlJrVcz5TTgunnZUFNeybdVpvn87gRM/XAYJRt3mx/3PReHqbblmotYsCV9CqEsoRbVF/N+J/zO/7ubjwLxnI7F11HD1SgVb3jnVbgaiN1QU17LlnUR01fJilDMWj0apuvGvJKVKSfRdcvYlYeeVVufoKawp5OsLXwOwOGxxh8r++cif46R14lLZJXZm7LzhunZEeWENORdLQQFDx7fdZLTz8k62p29HqVDyh6g/EOMbA8Dx3OM8/9PzTNk4hVePvcqZojOtdjy2seueNaMsTQQvgiAInWDnqOXuZyKwdZCDg4b5SKY/MZI7Fg63eDNRa7QqLa9MegUFCr5L/a7ZFPYD/ByZ92wkNvZq8tPLzWsD9RW1lXq2vHOKqlIdbj723LU0Ao3Wcj+3IdHeuPnYo6s2kLg3s8VtPk35FJ1RR7hHOBN8J3SoXGetM4tGLgJ6LvtyoT774T/UDSd321a3K6opMq+C/cToJ3h89OOsnbGWHffv4KmIp/B18KWiroIN5zfw8NaHeWDLA3ye8jmltaXXldVszaijfTP7IoIXQRCETnL1sueupeHY2KvxCHRkwV/GMTS6+zpStibSK9I8idorR16hxtA4z4tHgBP3/C4Sra2K3NQyflh9utPzn3QHvc7I1lWJlORV4+hmw9zfRlp0wjUApVJB9N1y9uXU7szr+v6U6crYcG4DIGewOtNUtXDEQlxsXLhcftk8Sqm7SJLE+ePy3C7D25jbRZIk/n7075ToShjqNpRfR/za/J6/oz+/ifwNO+7fwQfTP2D2wNlolVoulFzg33H/ZsrGKfxx/x85lH3IHIxpbFREzQoBIG5bepdnLe5OIngRBEHoAp9QFx779y08+Ndo3Hwceq0ez0Y9i4+DD1mVWaxKWNXsPa9gZ+b+NhK1jYqscyVsX5Pcq19ERqOJH9cmk58ur6R99zMRbWYTbsTgsV64+zlQV2MgcU/z7MsXZ7+g2lDNMLdh3B5we6fKddQ68tioxwB4P/F9DKbua5LLv1xOaX41aq2S0DGtz8i8NW0rezP3olaq+det/0Krun4pBaVCyUS/ibxx+xvsfXAvf435KyPcR6A36dmZsZOndj/FjG9m8E78O2SWZzLq9sZZi88c6tqsxd2p3wQvYmFGQRB6mlqjuuEOpjfKQePASxNeAuCzs5+RXJjc7H2fUBfmPh2OWqPkypkiflzb9aUOboQkSez//BwZSUWoNEruWhrBAD/HbjueQqlg/Fw5+5K4N5PaSjn7UllXyRdnvwBgcfjiLl2/nw3/GW42blypuMLWtK2Wq/Q1GjrqhkZ6orW9flFKgPyqfF6LfQ2AX4f/mmHuw9ot18XGhUeGP8JXc79i49yN5mxSQXUBHyZ9yJzv5rBk72K048oBedZifR/I2jXVb4IXsTCjIAg3q9sDbmfOwDmYJBPLjixDb2reTOI3xI05vwlHpVaSnljIro9SMPVwAHNsUxrnjuahUCqYuXg0voNcuv2YoRGeeAQ6oq81krBbXqJhw/kNlNeVE+IcwrSgaV0q115jb1688f3E96/7eVuCUW/i4om2lwOQJIllR5dRUVfB6AGjzSPQOmO4+3BeGP8Cexfs5c3Jb3KL3y0oUBCXF8e/K/5CpU0J1eV17Pohrk8tG9BvghdBEISb2fPjn8fVxpULJRf4OPnj694PHOHOrF+NRqlScCm+gD2fnO2xeTwS92QS/6M8cd8dC4cxMNyjR46rUCoYX9/35fS+LIpLyvk05VNAzrqolF3vJPzQ8IcYYDuA7Mpsvk/93iL1bSojuQhdlQF7Fy0BrSyT8O3FbzmcfRitUss/b/0namXL2ZmO0Kq0zAyZyfvT32fnAzt5OvJp/Jx9iQvYDkDK7gIe+OZBPjnzCUU1RV0+jqWI4EUQBKEfcLd15/nxzwNyNiCtLO26bULCPJi5eDRKpYILsfnsWZ9CRnIRV69UmOessbSLcfkc2ngRgJh5oYy8xc/ix2hLSLgHXsFOGHRGvt24n+LaYvwd/Zk9cPYNlWuntjNnOtacXoPeaNnsy7ljuQAMG++DUnl901Z2ZTZvxL0BwG/H/pZQ165P7nctHwcffhXxK7bdt43nfrYEg1MVdgZHHM4H8uaJN5m2cRrPHXyuVzMxXQ/TBEEQhD7lroF3sS1tG4eyD/HKkVf4eNbHKBXN/0cNjfRk2i9HsuujM1yIzTevVAygUICtkxZ7Zy0OzvK9vYsWe2cb+bH5uRatnbrd/iKZZ4vZvT4FkFfUjpoVbPmTbodCoWD83FC2vptI1Skb7MY48cvRv0SjvPERTguGLuDj5I/Jrcrlu9TveHDYgxaosTyUPCNZzm601GRkkky8dPglqg3VjPEaw89H/Nwix72WUqFkvP94XBfksWtdChMK5iCNKuZU2UmUCmWv9vcSwYsgCEI/oVAoeHnCy8zfPJ/4gng2nt/IQ8Mfum67IeO80WhVJB/MpqpMR3V5HTXldUgS1NQ/bq9hQKVRNgY0zlrsXWyaPUeC3etTMBklBkd5cduCIb32ZRc0yh2NrwFyNdySfw/zB8+3SLm2alueDHuS12Jf44PTHzBv8DxsVDY3XO7FE/mYjBIegY4M8L++U/P/zv2PuLw47NR2vHrLqzfU/NURg8d5c3JHBsU5VTytfBn3e4zdfsz2iOBFEAShH/F19OV3Y3/Ha7Gv8Z/4/zA5cDI+Dtf/9x4S7kFIk74nJpNEbaWe6nId1WV1VJfX38rq5Nfqn1eV1VFXY8CoN1FRVEtFUdtTzvsPc2PaYyNRtND00VOMkpGffL9lQu6DDM6Npq5cQutmmbIfGPoA65LXkV+dzzcXvuFnI352w2U2rFze0iKMl8su8/bJtwH4fdTvCXIOuuHjtUdZP3Jrx5pkEvdk8uiUidg5Xj8cuyeJ4EUQBKGfeXj4w2xP386pq6d49dirrJyyst2sh1KpaMyaBLRdvqHO2BjcmIMcXbPnVWU6vIKdmfqLEag0vdu9cnv6dk5pDxPqEoNXWTDxOy5z+yPtDynuCK1Ky5LwJfzj2D9Ym7SW+4bch62663PXlORVkZ9ejkKpYEh08/WxjCYjfzv8N2qNtcT4xpgnKOwJoZHyyK3CzEoSdl5h0n2De+zYLRHBiyAIQj+jVCh5ZdIrPLDlAQ5kHWDH5R033EG1KbVWhbOHHc4edhYrs7uYJBNrk9aCAvzv1KDfBGcO5zBmZrDFJsi7d/C9fJT0ETlVOWy8sNG8gGNXNGRdgka64+DSvAnqk5RPSLyaiIPGgX9M+sd1/Zm6k0KhIOaeULatOk3SviwipgZeV7+eJEYbCYIg9EOhrqEsCV8CwOuxr7e4hs3NYM+VPaSVpeGkdeJnU+bjP8wVk0HixPbLFjuGRqXhVxG/AmBt0lqq9dVdKkcySY1NRtd01E0tSeXdhHcBeD76eXwdfW+gxl0TPHoA3gOdMehNxO/I6PHjNyWCF0EQhH7qidFPMNh1MMW1xeZhtTcTSZL48PSHgDwrrqPWkfFz5SHF5w7nUl5Y09bunTJ30FwCHAMori3mq/NfdamMnIulVBbr0Nqqms2Fozfp+euhv6I36bk94HaLdTjuLIVCQcw8+edXmFWJ1EPzBLVEBC+CIAj9lEalMa88vSVtC4eyD/V2lXrUT9k/cbb4LHZqO/NwYr/BrgSOdMdkkjjxw2WLHUuj1JgXRFyXvK5L2ZeGrMvgKC/UTVbZXpu0lrPFZ3HWOrN84vJeHaIcMMyNe/80lvl/GNOrnbBF8CIIgtCPhXuGs3DEQgD+fvTvXW7SsDaSJPHB6Q8AeGjYQ7jauprfa5h199yxPEoLLPfzuCv0LoKdgynRlfDfc//t1L76OiOp8QUADJvQ2CSUUpTCB4nyebwY8yKe9q0v0NgTFAoFfoNde31NLxG8CIIg9HPPjHkGf0d/cqtyWZmwsrer0yPi8uJIvJqIVqll0ahFzd7zCXUhePQAJJPEiW2XLXZMtVJtzr6sP7OeyrrKDu+bnngVfa0RpwG25nWf6ox1vHjoRQySgenB0y3a6dra9ZvgRawqLQiC0DJ7jT0vT3gZgC/OfkHi1cRerlH3a8i63DfkPjzsrl9LqWHF6QuxeZTkVVnsuLNDZjPQZSBlujLz6tUd0bCC9LAYH3NzzHun3iO1NBV3W3f+NuFvvZ7t6Ev6TfAiVpUWBEFo3ST/Sdwz6B4kJJYfWW7xtXj6klMFpziedxy1Qm1e/flaXsHODIzwQJIgzoLZF5VSxW8ifgPIQ5vL68rb3aeqTEdmSjHQODFd4tVEPj4jL7D58oSXcbdteXHGm1W/CV4EQRCEtj0X/Rzutu6klqbKc5/0Ux8mySOM5g6a2+aQ4uj6vi8XT+RTlN3xJp72zAiZwWDXwVTUVfB5yuftbn8hNh9JAp9QZ1y97akx1PC3Q3/DJJm4O/RupgZPtVjd+gsRvAiCINwkXGxc+EvMXwD4IOkDUktSe7lGlne26CwHsw6iVCjNqz63xjPQiUFjPEGCuG3pFquDUqHkN5Fy9uWzlM8o05W1uX3j3C5yoPVO/DtcLr+Ml50XL4x/wWL16k9E8CIIgnATmRk8kzsC78BgMrDs6DJ0Rl1vV8miGrIus0JmEezc/irW0XcPBAVcir9KYVaFxeoxNWgqw9yGUamv5JMzn7S6XWFWBUVZlSjVCgZHeRGXF8fnZ+VszfJJy3GxcbFYnfoTEbwIgiDcRBQKBX+L+RuOGkdOXz3N7G9m88mZT/rFEOq00jR2Z+wG4MmwJzu0zwB/R4ZEeQEQu6V7si9fnP2CktqSFrdr6KgbEuaBUVvHS4dfAuD+IfdzW8BtFqtPfyOCF0EQhJuMt4M3b9z+Br4OvlytucqbJ95k1jez+PD0h1TUWS770NPWJq1FQmJq0FSGuA3p8H7Rdw9EoYD0xEIKMtrvYNtRdwbeyQj3EVQbqs2db5syGU1ciM0H5I66/3fi/8iuzMbPwY8/R//ZYvXoj0TwIgiCcBO6LeA2tt27jb9P+juBToGU6Ep4J+EdZn49k3cT3rW6tZAyKzL5If0HABaHL+7Uvm4+DgwZL6/gHLvVctkXhULB02OeBuDLc19SWFPY7P3McyVUl9dh66Ah2/08Gy9sBOAft/wDB42DxerRH4ngRRAE4SalUWm4d8i9fD//e16/7XUGuQyiQl/BmtNrmPHNDN468dZ1X7h91brkdRglI7f438KoAaM6vX/0nIEolAoykorIS2u7g21n3OZ/G2EeYdQYavg4uXn2paHJKDjKjeXHlwHyGkzjfcdb7Pj9lQheBEEQbnJqpZq7Qu/i23nf8p87/sMI9xHyl+2Zj5n1zSxeO/4aeVV5vV3NVuVV5bEpdRMAS8KWdKkMV29780rOls6+LI1cCsCG8xu4Wn0VgLoaA2mn5MeH7LdSUF1AsHMwz0Y9a7Fj92cieBEEQRAAuZPptOBpbLh7A6umriLcMxydUcd/z/2X2d/OZvmR5WRWZPZ2Na/zyZlPMJgMjPMex1jvsV0uZ9zsEJRKBZkpxeSkllqsfpP8JhHpGYnOqOOj5I8AuJRQgFFvQjsAvin9AqVCyau3vIqd2s5ix+3PRPAiCIIgNKNQKLg94HY+n/05a2esZbzPeAwmA99c/Ia5383lrz/9lbTStN6uJgCFNYV8feFroPN9Xa7l4mnH8EnyXCuWHHmkUChYOkbOvmw8v5G8qjxzk9EJlz2ggEWjFhHpFWmxY/Z36t6ugCAIgtA3KRQKYnxjiPGNIaEggQ9Of8Ch7ENsSdvC1rStTA+ezuLwxQx3H95rdfws5TNqjbWEeYQx0XfiDZc3bk4I547mkn2+hM1vJ2DrqEFrp8bGVo3WTr7Z2KnMj7V2arS2amzs1GjtVChVLecEYnxiiPKO4mT+SdYd/QyXC1EAnHb9iUEug8xNS0LHiOBFEARBaNcYrzGsnraaM0Vn+PD0h+y5soedGTvZmbGTOwLuYHH4YsI9w3u0TmW6Mr489yUAi8MWW2ThQid3W0bd7k/SviyyzrU8N0tb1FplfYDTPLjR2qmYa3oCMj0ouqDGBch2vkCNbTn/vG01NiqbG677zUQhSZLU25WwpPLyclxcXCgrK8PZ2bm3qyMIgtAvXSy5yIdJH/Lj5R8xSSYAJvpOZEn4Esb5jOuROqw+tZr3Et9jqNtQNs7diFJhmZ4QRr2JzLPF1FTWUVdjRFdjoK7hVivf62qMja/VGDDoTZ0+zr5BXzBlepR5MrubXWe+v0XwIgiCIHTZ5bLLrE1ay9a0rRglIwBjvcayJHwJk/wmWSQb0pIqfRUzvp5BeV05KyavYFbIrG45TkcZjab6QKYxqNE1CXYaAp6c4jyOXD5GjaaSkshzfH7PZ2iUml6te18hghcRvAiCIPSo7Mps1iWt47vU79Cb9AB42HngonXBUeuIo8ax8V7jiIPWASeNEw4aB5y0jfdNt7NR2bQa/KxLXsd/Tv6HEOcQNs3bhEqp6snTvSHPHXiOo7lHWTdzXadmAu7vbsrgZdWqVaxatQqj0ciFCxdE8CIIgtAL8qvyWX9mPV9f+JpaY+0NlaVWqHHUOjYPcDROOGgdOJx9mFJdKa/e8irzBs+zUO17jkkyWayZq7+4KYOXBiLzIgiC0PvK68rJLM+kUl9JZV2lfN/C4wp9BVV1Vc1eq9JXIdH+V5O/oz9b7t0iml36ic58f4vRRoIgCILFOWudGeXR+Wn6Qc5KVOurrw92Gp7XVVJjqGFK0BQRuNykRPAiCIIg9ClKhVLu96J1BLE+odAC0eAmCIIgCIJVEcGLIAiCIAhWRQQvgiAIgiBYFRG8CIIgCIJgVUTwIgiCIAiCVRHBiyAIgiAIVkUEL4IgCIIgWBURvAiCIAiCYFVE8CIIgiAIglURwYsgCIIgCFZFBC+CIAiCIFgVEbwIgiAIgmBVRPAiCIIgCIJV6XerSkuSBEB5eXkv10QQBEEQhI5q+N5u+B5vS78LXioqKgAIDAzs5ZoIgiAIgtBZFRUVuLi4tLmNQupIiGNFTCYTOTk5ODk5oVAoLFp2eXk5gYGBZGZm4uzsbNGy+xpxrv3XzXS+4lz7r5vpfG+Wc5UkiYqKCvz8/FAq2+7V0u8yL0qlkoCAgG49hrOzc7/+BWpKnGv/dTOdrzjX/utmOt+b4Vzby7g0EB12BUEQBEGwKiJ4EQRBEATBqojgpRNsbGxYtmwZNjY2vV2VbifOtf+6mc5XnGv/dTOd7810rh3V7zrsCoIgCILQv4nMiyAIgiAIVkUEL4IgCIIgWBURvAiCIAiCYFVE8CIIgiAIglURwcs1Vq1aRUhICLa2tsTExBAbG9vm9hs3bmT48OHY2toSFhbGDz/80EM17brXXnuN6OhonJyc8PLyYv78+Zw/f77NfdavX49CoWh2s7W17aEa35jly5dfV/fhw4e3uY81XleAkJCQ685VoVCwdOnSFre3put68OBB5s6di5+fHwqFgk2bNjV7X5IkXn75ZXx9fbGzs2PatGlcvHix3XI7+5nvKW2dr16v5/nnnycsLAwHBwf8/Pz4xS9+QU5OTptlduWz0BPau7aPPfbYdfWeNWtWu+X2xWvb3rm29PlVKBSsWLGi1TL76nXtTiJ4aWLDhg384Q9/YNmyZcTHxxMREcHMmTMpKChocfsjR47wyCOP8MQTT5CQkMD8+fOZP38+ycnJPVzzzjlw4ABLly7l2LFj7Nq1C71ez4wZM6iqqmpzP2dnZ3Jzc823jIyMHqrxjRs1alSzuh86dKjVba31ugLExcU1O89du3YBsGDBglb3sZbrWlVVRUREBKtWrWrx/TfeeIN33nmH999/n+PHj+Pg4MDMmTOpra1ttczOfuZ7UlvnW11dTXx8PC+99BLx8fF8++23nD9/nnvuuafdcjvzWegp7V1bgFmzZjWr9//+9782y+yr17a9c216jrm5uaxbtw6FQsH999/fZrl98bp2K0kwGz9+vLR06VLzc6PRKPn5+UmvvfZai9s/+OCD0l133dXstZiYGOlXv/pVt9bT0goKCiRAOnDgQKvbfPzxx5KLi0vPVcqCli1bJkVERHR4+/5yXSVJkn73u99JgwYNkkwmU4vvW+t1BaTvvvvO/NxkMkk+Pj7SihUrzK+VlpZKNjY20v/+979Wy+nsZ763XHu+LYmNjZUAKSMjo9VtOvtZ6A0tneuiRYukefPmdaoca7i2Hbmu8+bNk6ZMmdLmNtZwXS1NZF7q1dXVcfLkSaZNm2Z+TalUMm3aNI4ePdriPkePHm22PcDMmTNb3b6vKisrA8Dd3b3N7SorKwkODiYwMJB58+Zx5syZnqieRVy8eBE/Pz9CQ0NZuHAhV65caXXb/nJd6+rq+Pzzz/nlL3/Z5iKl1nxdG6Snp5OXl9fsurm4uBATE9PqdevKZ74vKysrQ6FQ4Orq2uZ2nfks9CX79+/Hy8uLYcOG8dRTT1FUVNTqtv3l2ubn57Nt2zaeeOKJdre11uvaVSJ4qVdYWIjRaMTb27vZ697e3uTl5bW4T15eXqe274tMJhPPPvsst9xyC6NHj251u2HDhrFu3To2b97M559/jslkYtKkSWRlZfVgbbsmJiaG9evXs2PHDlavXk16ejq33XYbFRUVLW7fH64rwKZNmygtLeWxxx5rdRtrvq5NNVybzly3rnzm+6ra2lqef/55HnnkkTYX7uvsZ6GvmDVrFp9++il79uzh3//+NwcOHGD27NkYjcYWt+8v1/aTTz7BycmJ++67r83trPW63oh+t6q00DlLly4lOTm53fbRiRMnMnHiRPPzSZMmMWLECNasWcM//vGP7q7mDZk9e7b5cXh4ODExMQQHB/PVV1916D8aa/XRRx8xe/Zs/Pz8Wt3Gmq+rINPr9Tz44INIksTq1avb3NZaPwsPP/yw+XFYWBjh4eEMGjSI/fv3M3Xq1F6sWfdat24dCxcubLcTvbVe1xshMi/1PDw8UKlU5OfnN3s9Pz8fHx+fFvfx8fHp1PZ9zdNPP83WrVvZt28fAQEBndpXo9EwZswYUlNTu6l23cfV1ZWhQ4e2Wndrv64AGRkZ7N69myeffLJT+1nrdW24Np25bl35zPc1DYFLRkYGu3btajPr0pL2Pgt9VWhoKB4eHq3Wuz9c259++onz5893+jMM1ntdO0MEL/W0Wi1RUVHs2bPH/JrJZGLPnj3N/jNtauLEic22B9i1a1er2/cVkiTx9NNP891337F3714GDhzY6TKMRiNJSUn4+vp2Qw27V2VlJZcuXWq17tZ6XZv6+OOP8fLy4q677urUftZ6XQcOHIiPj0+z61ZeXs7x48dbvW5d+cz3JQ2By8WLF9m9ezcDBgzodBntfRb6qqysLIqKilqtt7VfW5Azp1FRUURERHR6X2u9rp3S2z2G+5Ivv/xSsrGxkdavXy+lpKRIS5YskVxdXaW8vDxJkiTp0UcflV544QXz9ocPH5bUarX05ptvSmfPnpWWLVsmaTQaKSkpqbdOoUOeeuopycXFRdq/f7+Um5trvlVXV5u3ufZcX3nlFenHH3+ULl26JJ08eVJ6+OGHJVtbW+nMmTO9cQqd8sc//lHav3+/lJ6eLh0+fFiaNm2a5OHhIRUUFEiS1H+uawOj0SgFBQVJzz///HXvWfN1raiokBISEqSEhAQJkN566y0pISHBPLrm9ddfl1xdXaXNmzdLp0+flubNmycNHDhQqqmpMZcxZcoUaeXKlebn7X3me1Nb51tXVyfdc889UkBAgHTq1Klmn2OdTmcu49rzbe+z0FvaOteKigrpT3/6k3T06FEpPT1d2r17tzR27FhpyJAhUm1trbkMa7m27f0eS5IklZWVSfb29tLq1atbLMNarmt3EsHLNVauXCkFBQVJWq1WGj9+vHTs2DHze5MnT5YWLVrUbPuvvvpKGjp0qKTVaqVRo0ZJ27Zt6+Eadx7Q4u3jjz82b3PtuT777LPmn4u3t7c0Z84cKT4+vucr3wUPPfSQ5OvrK2m1Wsnf31966KGHpNTUVPP7/eW6Nvjxxx8lQDp//vx171nzdd23b1+Lv7cN52MymaSXXnpJ8vb2lmxsbKSpU6de9zMIDg6Wli1b1uy1tj7zvamt801PT2/1c7xv3z5zGdeeb3ufhd7S1rlWV1dLM2bMkDw9PSWNRiMFBwdLixcvvi4IsZZr297vsSRJ0po1ayQ7OzuptLS0xTKs5bp2J4UkSVK3pnYEQRAEQRAsSPR5EQRBEATBqojgRRAEQRAEqyKCF0EQBEEQrIoIXgRBEARBsCoieBEEQRAEwaqI4EUQBEEQBKsighdBEARBEKyKCF4EQRAEQbAqIngRBEEQBMGqiOBFEARBEASrIoIXQRAEQRCsigheBEEQBEGwKv8f1rD6eMLY8bwAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(train_cnn_epoch, label=\"Train, no norm\")\n",
        "plt.plot(test_cnn_epoch, label=\"Test, no norm\")\n",
        "plt.plot(epoch_train_loss_layernorm, label=\"Train, layer norm\")\n",
        "plt.plot(epoch_test_loss_layernorm, label=\"Test, layer norm\")\n",
        "plt.plot(epoch_train_loss_batchnorm, label=\"Train, batch norm\")\n",
        "plt.plot(epoch_test_loss_batchnorm, label=\"Test, batch norm\")\n",
        "plt.legend()\n",
        "plt.yscale(\"log\")"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "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.8.10"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "14299d1b86dd4bc282ce2839149bb164": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "1e0515b3ad2648eea23b7eb28292faa4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "25b89ea96ce743b48885db0a4043be63": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2a3106b795dd40ecaecc8a35db705f83": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "31a397c4da834a368377db5220021ec3": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "394163f60bc749a7861d23260f0954cc": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "3f885b2b34c546ed99257fcbd3502d61": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_76bc0639e95d4c0f9283f1b83217c0b7",
            "placeholder": "​",
            "style": "IPY_MODEL_394163f60bc749a7861d23260f0954cc",
            "value": " 9912422/9912422 [00:00&lt;00:00, 109716394.88it/s]"
          }
        },
        "3f8bc06225e3454a98145c5f9fbb2434": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "43c33354ca8b40d1842d77c3fc85b0ec": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_fd9a41308c964b679b9ea1a7a8321267",
            "placeholder": "​",
            "style": "IPY_MODEL_5590bb0db1ac433fbbda9dc35eff815e",
            "value": "100%"
          }
        },
        "4be593f3a3504a8193e16a477ccefe5d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "506ddc0ae32d46069ebb0b01072b7315": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "50d8ca00caac459ebeca1da1d5793d60": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "5590bb0db1ac433fbbda9dc35eff815e": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "6aa47870a67b4600a80863865c70f902": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "6ac68b0450bb408ab29c7f13a2dfaaa9": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "7055aab9e9754befa98a4f26303ccfad": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "76bc0639e95d4c0f9283f1b83217c0b7": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "80b1cc9c6aa4466abbb34f447927440b": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "851aaa65665f4599b217cdc7b6f179df": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "8606168802f542f793c47cfb9fbc8c94": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "8fa3c6b6e5544569bc90e29ea3aecfc1": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_cbc48f2ca9e94012be032efba30f9b1f",
            "placeholder": "​",
            "style": "IPY_MODEL_8606168802f542f793c47cfb9fbc8c94",
            "value": " 4542/4542 [00:00&lt;00:00, 307797.79it/s]"
          }
        },
        "988d236eb1f14936b4e5f1182360dd1a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_cb4a6d719cbb4da3ad91621e8a838250",
              "IPY_MODEL_dc73530c83744167bd25b05b417e28a0",
              "IPY_MODEL_f2e0e812b5ea4b7795b8978be056c82e"
            ],
            "layout": "IPY_MODEL_b6e84644c9ae46ff87abf7afa53fc88c"
          }
        },
        "98ba5ea41d3f44bab99e7afc217b8510": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9e8057197c934d858a4a15e236c79191": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a18865f1446d46739d036623a2f4c1b9": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_43c33354ca8b40d1842d77c3fc85b0ec",
              "IPY_MODEL_e5742f85c21148288d1f27c5ce7b5842",
              "IPY_MODEL_b1e6b5a0799c4714af41e2300e1a103d"
            ],
            "layout": "IPY_MODEL_4be593f3a3504a8193e16a477ccefe5d"
          }
        },
        "a9b259fd21334cef9c6a15094b587706": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_f1bc6b4bca8f463e9a0f8c6c06ee2231",
              "IPY_MODEL_c32f88131ce7417c83fbe34de3a9b2a9",
              "IPY_MODEL_3f885b2b34c546ed99257fcbd3502d61"
            ],
            "layout": "IPY_MODEL_851aaa65665f4599b217cdc7b6f179df"
          }
        },
        "abfdc31b4490489caf4d4115c8670892": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_aec995c2c7974f20a0a24ede8fd226ab",
              "IPY_MODEL_e11109b3b34f42fc95a2af72d74265cd",
              "IPY_MODEL_8fa3c6b6e5544569bc90e29ea3aecfc1"
            ],
            "layout": "IPY_MODEL_80b1cc9c6aa4466abbb34f447927440b"
          }
        },
        "ace09eeabde4415faa1dba06ef35140e": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "aec995c2c7974f20a0a24ede8fd226ab": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_6ac68b0450bb408ab29c7f13a2dfaaa9",
            "placeholder": "​",
            "style": "IPY_MODEL_31a397c4da834a368377db5220021ec3",
            "value": "100%"
          }
        },
        "b1e6b5a0799c4714af41e2300e1a103d": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9e8057197c934d858a4a15e236c79191",
            "placeholder": "​",
            "style": "IPY_MODEL_2a3106b795dd40ecaecc8a35db705f83",
            "value": " 1648877/1648877 [00:00&lt;00:00, 23549151.95it/s]"
          }
        },
        "b2d59d6f38c94a9899107dad087449d8": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "b5a008397ffc4297937ab302fab67f34": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "b6e84644c9ae46ff87abf7afa53fc88c": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "c32f88131ce7417c83fbe34de3a9b2a9": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_3f8bc06225e3454a98145c5f9fbb2434",
            "max": 9912422,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_b2d59d6f38c94a9899107dad087449d8",
            "value": 9912422
          }
        },
        "cb4a6d719cbb4da3ad91621e8a838250": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_25b89ea96ce743b48885db0a4043be63",
            "placeholder": "​",
            "style": "IPY_MODEL_f2b5e6132c3d4c25bb0013468decd49d",
            "value": "100%"
          }
        },
        "cbc48f2ca9e94012be032efba30f9b1f": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "dc73530c83744167bd25b05b417e28a0": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_506ddc0ae32d46069ebb0b01072b7315",
            "max": 28881,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_14299d1b86dd4bc282ce2839149bb164",
            "value": 28881
          }
        },
        "e11109b3b34f42fc95a2af72d74265cd": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7055aab9e9754befa98a4f26303ccfad",
            "max": 4542,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_50d8ca00caac459ebeca1da1d5793d60",
            "value": 4542
          }
        },
        "e24d990f58114022baa5bb4c36e47280": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "e5742f85c21148288d1f27c5ce7b5842": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_ace09eeabde4415faa1dba06ef35140e",
            "max": 1648877,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_e24d990f58114022baa5bb4c36e47280",
            "value": 1648877
          }
        },
        "f1bc6b4bca8f463e9a0f8c6c06ee2231": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_6aa47870a67b4600a80863865c70f902",
            "placeholder": "​",
            "style": "IPY_MODEL_b5a008397ffc4297937ab302fab67f34",
            "value": "100%"
          }
        },
        "f2b5e6132c3d4c25bb0013468decd49d": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "f2e0e812b5ea4b7795b8978be056c82e": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_98ba5ea41d3f44bab99e7afc217b8510",
            "placeholder": "​",
            "style": "IPY_MODEL_1e0515b3ad2648eea23b7eb28292faa4",
            "value": " 28881/28881 [00:00&lt;00:00, 1854780.18it/s]"
          }
        },
        "fd9a41308c964b679b9ea1a7a8321267": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}