06-사람의_지도_없이_학습하는_오토인코더/denoising_autoencoder.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.5"
    },
    "colab": {
      "name": "denoising_autoencoder.ipynb",
      "provenance": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3cj79zAEQcMb"
      },
      "source": [
        "# 오토인코더로 망가진 이미지 복원하기\n",
        "\n",
        "잡음제거 오토인코더(Denoising Autoencoder)는 2008년 몬트리올 대학에서 발표한 논문\n",
        "[\"Extracting and Composing Robust Features with Denoising AutoEncoder\"](http://www.cs.toronto.edu/~larocheh/publications/icml-2008-denoising-autoencoders.pdf)\n",
        "에서 처음 제안되었습니다.\n",
        "\n",
        "앞서 오토인코더는 일종의 \"압축\"을 한다고 했습니다.\n",
        "그리고 압축은 데이터의 특성에 중요도로 우선순위를 매기고\n",
        "낮은 우선순위의 데이터를 버린다는 뜻이기도 합니다.\n",
        "\n",
        "잡음제거 오토인코더의 아이디어는\n",
        "중요한 특징을 추출하는 오토인코더의 특성을 이용하여 비교적\n",
        "\"덜 중요한 데이터\"인 잡음을 버려 원래의 데이터를 복원한다는 것 입니다.\n",
        "원래 배웠던 오토인코더와 큰 차이점은 없으며,\n",
        "학습을 할때 입력에 잡음을 더하는 방식으로 복원 능력을 강화한 것이 핵심입니다.\n",
        "\n",
        "앞서 다룬 코드와 동일하며 `add_noise()` 함수로 학습시 이미지에 노이즈를 더해주는 부분만 추가됐습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6KaivYoXQcMd"
      },
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import torch.nn.functional as F\n",
        "from torch import nn, optim\n",
        "from torchvision import transforms, datasets\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IJoImUwUQcMe",
        "outputId": "6d117327-d03a-4025-a351-050ce11dae22",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# 하이퍼파라미터\n",
        "EPOCH = 10\n",
        "BATCH_SIZE = 64\n",
        "USE_CUDA = torch.cuda.is_available()\n",
        "DEVICE = torch.device(\"cuda\" if USE_CUDA else \"cpu\")\n",
        "print(\"다음 기기로 학습합니다:\", DEVICE)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "다음 기기로 학습합니다: cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0sJU9nCjQcMf"
      },
      "source": [
        "# Fashion MNIST 학습 데이터셋\n",
        "trainset = datasets.FashionMNIST(\n",
        "    root      = './.data/', \n",
        "    train     = True,\n",
        "    download  = True,\n",
        "    transform = transforms.ToTensor()\n",
        ")\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(\n",
        "    dataset     = trainset,\n",
        "    batch_size  = BATCH_SIZE,\n",
        "    shuffle     = True,\n",
        "    num_workers = 2\n",
        ")"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LLq1ZsfBQcMf"
      },
      "source": [
        "class Autoencoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Autoencoder, self).__init__()\n",
        "\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Linear(28*28, 128),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(128, 64),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(64, 12),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(12, 3),   # 입력의 특징을 3차원으로 압축합니다\n",
        "        )\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.Linear(3, 12),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(12, 64),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(64, 128),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(128, 28*28),\n",
        "            nn.Sigmoid(),       # 픽셀당 0과 1 사이로 값을 출력합니다\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        encoded = self.encoder(x)\n",
        "        decoded = self.decoder(encoded)\n",
        "        return encoded, decoded"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-XGCA-B0QcMg"
      },
      "source": [
        "autoencoder = Autoencoder().to(DEVICE)\n",
        "optimizer = torch.optim.Adam(autoencoder.parameters(), lr=0.005)\n",
        "criterion = nn.MSELoss()"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vnjDqrpFQcMg"
      },
      "source": [
        "def add_noise(img):\n",
        "    noise = torch.randn(img.size()) * 0.2\n",
        "    noisy_img = img + noise\n",
        "    return noisy_img"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K0DPkTReQcMg"
      },
      "source": [
        "def train(autoencoder, train_loader):\n",
        "    autoencoder.train()\n",
        "    avg_loss = 0\n",
        "    for step, (x, label) in enumerate(train_loader):\n",
        "        noisy_x = add_noise(x)  # 입력에 노이즈 더하기\n",
        "        noisy_x = noisy_x.view(-1, 28*28).to(DEVICE)\n",
        "        y = x.view(-1, 28*28).to(DEVICE)\n",
        "\n",
        "        label = label.to(DEVICE)\n",
        "        encoded, decoded = autoencoder(noisy_x)\n",
        "\n",
        "        loss = criterion(decoded, y)\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "        avg_loss += loss.item()\n",
        "    return avg_loss / len(train_loader)"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U-DRauRxQcMh",
        "outputId": "ab9649bb-7b22-4565-cb2f-cc0d94053d8e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "for epoch in range(1, EPOCH+1):\n",
        "    loss = train(autoencoder, train_loader)\n",
        "    print(\"[Epoch {}] loss:{}\".format(epoch, loss))\n",
        "    # 이번 예제에선 학습시 시각화를 건너 뜁니다"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[Epoch 1] loss:0.035159787588091546\n",
            "[Epoch 2] loss:0.025439083669533225\n",
            "[Epoch 3] loss:0.024218387588032526\n",
            "[Epoch 4] loss:0.0235924444365889\n",
            "[Epoch 5] loss:0.023148948070543535\n",
            "[Epoch 6] loss:0.02284147526854391\n",
            "[Epoch 7] loss:0.022596745426133116\n",
            "[Epoch 8] loss:0.022522441673475797\n",
            "[Epoch 9] loss:0.02247953488787354\n",
            "[Epoch 10] loss:0.022218294660133846\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ui0bMTJfQcMh"
      },
      "source": [
        "# 이미지 복원 시각화 하기"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GkZZ7XSYQcMh"
      },
      "source": [
        "# 모델이 학습시 본적이 없는 데이터로 검증하기 위해 테스트 데이터셋을 가져옵니다.\n",
        "testset = datasets.FashionMNIST(\n",
        "    root      = './.data/', \n",
        "    train     = False,\n",
        "    download  = True,\n",
        "    transform = transforms.ToTensor()\n",
        ")\n",
        "\n",
        "# 테스트셋에서 이미지 한장을 가져옵니다.\n",
        "sample_data = testset.data[0].view(-1, 28*28)\n",
        "sample_data = sample_data.type(torch.FloatTensor)/255.\n",
        "\n",
        "# 이미지를 add_noise로 오염시킨 후, 모델에 통과시킵니다.\n",
        "original_x = sample_data[0]\n",
        "noisy_x = add_noise(original_x).to(DEVICE)\n",
        "_, recovered_x = autoencoder(noisy_x)"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KCUJM0QtQcMi",
        "outputId": "641291bb-258e-4913-ec24-fe85110abe76",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 310
        }
      },
      "source": [
        "f, a = plt.subplots(1, 3, figsize=(15, 15))\n",
        "\n",
        "# 시각화를 위해 넘파이 행렬로 바꿔줍니다.\n",
        "original_img = np.reshape(original_x.to(\"cpu\").data.numpy(), (28, 28))\n",
        "noisy_img = np.reshape(noisy_x.to(\"cpu\").data.numpy(), (28, 28))\n",
        "recovered_img = np.reshape(recovered_x.to(\"cpu\").data.numpy(), (28, 28))\n",
        "\n",
        "# 원본 사진\n",
        "a[0].set_title('Original')\n",
        "a[0].imshow(original_img, cmap='gray')\n",
        "\n",
        "# 오염된 원본 사진\n",
        "a[1].set_title('Noisy')\n",
        "a[1].imshow(noisy_img, cmap='gray')\n",
        "\n",
        "# 복원된 사진\n",
        "a[2].set_title('Recovered')\n",
        "a[2].imshow(recovered_img, cmap='gray')\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2cAAAElCAYAAABgRJorAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5zdVXnv8e/D5J5M7hdyvxOSEHJpuEZMRBAKCJYCSq2lHirq0Var1lrPq8X29JyjPWqttdhi4YAooC8xiJSLiMilQCQXJAFCEsiEJEzut8l9Jlnnj71Thzj5PU9m9sysZD7v14tXhr2eWXvNb/Ze+/fMvnwtpSQAAAAAQPs6pb0XAAAAAACgOQMAAACALNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRmOm5l90cz+vdK1gbmSmU2oxFwAOiYze9jMbmjvdQBAezKzMeXzqk7tvRa8nZFzBjP7Y0mflTRe0i5J8yX9VUppR3uu62hmliRNTCmtau+1AGg/ZlYjqYeksSmlPeXL/kTSH6aU5rXj0gCc4Mr7yxBJhyTtlvSIpE+mlHa357oqzczGSFotqXNKqaF9V4PGeOasgzOzz0r6iqS/kNRH0rmSRkt6zMy6NFHPX1gA5KBK0qfaexEATkrvTSn1kjRD0kxJf9XO63FxfnbyoDnrwMyst6S/lfSnKaVHUkr1KaUaSddJGiPpD83sS2b2IzP7npntkvTH5cu+12iePzKzNWa21cz+2sxqzOyi8th/1TZ6Cv0GM3vTzLaY2f9oNM/ZZvacme0ws1oz+1ZTDSIASPq/kj5nZn2PHjCz883sBTPbWf73/EZjvyw/yyYzm2BmT5brtpjZD8qX/4uZfe2oOR8wsz9v5Z8JQEZSShskPapSkyYzO9fMni2fp/zazOYdqTWz/mb2/8zsLTPbbmb3Nxr7iJmtMrNt5b1kWPnyb5vZVxtfp5n9xMw+U/56mJndZ2abzWy1mf1Zo7qmzs/6mNlt5XOo9Wb292ZWVa6vMrOvlve6NyRd3moHDi1Cc9axnS+pm6QfN76w/NT9Q5IuLl90laQfSeor6fuNa81siqRbJH1Q0lCVnn0b7lzvOyRNkvRuSX9jZpPLlx+S9OeSBko6rzz+35vxcwE4+S2U9EtJn2t8oZn1l/Qfkr4paYCkr0v6DzMb0MQc/1PSzyT1kzRC0j+XL79T0vVmdkp5zoGSLpJ0d8V/CgDZMrMRkn5X0iozG67S3vL3kvqrtPfcZ2aDyuV3qfRy66mSBkv6x/IcF0r6Pyr94XuopDWS7i1/zz2S3m9mVq7tJ+k9ku4t7z8/lfRrlc6r3i3p02Z2SaMlHn1+doekBkkTVHrG7z2S/qRc+xFJV5Qvny3pmpYeH7QOmrOObaCkLcd4rXFteVySnksp3Z9SOpxS2ndU3TWSfppSeialdFDS30jy3sj4tymlfSmlX6u06UyXpJTSopTS8ymlhvIzeP8maW7zfjQAHcDfSPrTRidHUumvwStTSneV95J7JC2X9N4mvr9epZdxD0sp7U8pPSNJKaVfSdqp0smQJH1A0i9TShtb6wcBkJX7zaxO0lpJmyTdLOkPJT2UUnqofD70mEp/JLrMzIaq1MR9LKW0vfxKpCfLc31Q0u0ppcUppQMqvUTyvPJ7vp5W6ZzpgnLtNSqdc70l6SxJg1JKf5dSOphSekPSd1Taj474r/MzSb0lXSbp0ymlPSmlTSo1iEfqr5P0jZTS2pTSNpUaRmSI5qxj2yJp4DFepzy0PC6VNqdjGdZ4PKW0V9JW53o3NPp6r6RekmRmp5nZg2a2ofwU/f/WbxpEAHiblNIySQ9K+kKji4ep9Jfpxtao6Wf0Py/JJP3KzF42s//WaOxOlU7GVP73roosGsCJ4H0ppWpJ8ySdrtK5yGhJ15Zf0rjDzHao9EqgoZJGStqWUtrexFxv25PKr07aKml4Kn0q372Sri8P/4F+8wql0ZKGHXV9X1Tpw0qOaHx+NlpSZ0m1jer/TaVn8Y6so3H90fskMkFz1rE9J+mApKsbX2hmvVT6C9Dj5YuKngmrVenlQEe+t7tKLyVqjm+r9BfuiSml3iptQtbMuQB0DDer9HKdI83XWyqdpDQ2StL6o78xpbQhpfSRlNIwSR+VdIv9Jq7je5KuMrPpkiZLuv/o7wdwcis/+3WHpK+q1NjclVLq2+i/nimlL5fH+jf1HlgdtSeZWU+VzpOO7En3SLrGzEZLOkfSfeXL10pafdT1VaeULmu8xEZfr1XpnG5go/reKaWp5fFalZrII0Yd7/FA26A568BSSjtV+kCQfzazS82sc/lp9h9KWqfYX4p/JOm95Tfgd5H0JTW/oapW6aP8d5vZ6ZI+3sx5AHQQ5WiNH0g68kb5hySdZmZ/YGadzOz9kqao9Azb25jZteX3lEjSdpVOdA6X510n6QWV9sH7mnhJN4CO4RsqvQf/WZXOdy4pf7hGNzObZ2YjUkq1kh5W6Q88/crnU+8sf/89kj5sZjPMrKtKrwpaUH77hlJKS1R6pdK/S3q0UYzRryTVmdlfmln38nWeYWZnNbXI8hp+JulrZtbbzE4xs/FmduTtIT+U9GdmNqL83rYvNDUP2h/NWQeXUvoHlZ6h+qpKjdEClf768u7ya6O9739Z0p+q9LR8rUqZIJtU+uvN8fqcSk/p16n0uuofNGMOAB3P30nqKUkppa0qven9syq9dOjzkq5IKW1p4vvOkrTAzHZLekDSp8rv6zjiTknTxEsagQ4rpbRZ0ndV+gPQVSqdM21W6VzpL/Sbc+kPqfQ+1uUqnQd9uvz9P5f01yo9I1arUqZs4/eNSaUPG3rbhw6llA6ptJfNUCmP7EgD16dguX8kqYukV1T6g9OPVHrZpVQ6r3pUpff6L9ZRHwaHfBBCjYoqvyRyh0ovTVzd3usBgOYq/+X7e5JGJx4sAQBtgGfO0GJm9l4z61F+HfVXJS2VVNO+qwKA5jOzziqFXP87jRkAoK3QnKESrlLpDa9vSZoo6QOczAA4UZWzF3eo9HKgb7TzcgAAHQgvawQAAACADPDMGQAAAABkgOYMAAAAADLQqS2vzMx4DSVwEkopndBh4V27dk09evQorDlwwE+H6N69e+F4Q0ODO0fkpeZdu3Z1a/bs2VORebw19+rVy51jy5amPsX++PXs2dOt8X5u7/csSVVVVW5N5PZw+PBht2bIkCFuzb59LY9Yi6w38rs8dOiQW1NXV+fWeL+H+vp6d47IfWXnzp1bUkqD3MKMce4EnJyOde7UoubMzC6V9E+SqlT6RKsvt2Q+AKiU49mfevTooXnz5hXOV1NT417n5MmTC8e3b9/uzhE5iR43bpxbs3DhworMs3Xr1sLxOXPmuHN85zvfcWsizjvvPLdmwYIFheMzZsxw5+jdu7dbE7k97N692635/Oc/79YsXbq0cDzSpKxe7SebRI5vpPH6+c9/7tbMmjWrcLy2ttadI/Jz/+QnP1njFrUxzp0AFGn2yxrNrErSv0j6XUlTJF1vZlMqtTAAaC72JwA5Ym8C4GnJe87OlrQqpfRGSumgpHtV+kh1AGhv7E8AcsTeBKBQS5qz4ZLWNvr/deXL3sbMbjKzhWbmv8YGACrD3Z8a702RlxICQAVw7gSgUKt/WmNK6daU0uyU0uzWvi4AiGq8N0U+GAMA2grnTkDH1ZLmbL2kkY3+f0T5MgBob+xPAHLE3gSgUEuasxckTTSzsWbWRdIHJD1QmWUBQIuwPwHIEXsTgELN/ij9lFKDmX1S0qMqfRzs7Smllyu2MgBopuPdnxoaGrRjx47COWfOnOle7yuvvFI47uWgHVlLJVx22WVuTeTjyr2MrR//+MfuHHPnznVrIscmkj924403Fo57H0svSaec4v/dMrKWPn36uDVPPfWUW9O3b9/C8V/84hfuHMOH/9bbmn7Lvffe69ZMmzbNrVmxYoVbM3HixMLxSEZcJfLf2hrnTgA8Lco5Syk9JOmhCq0FACqG/QlAjtibABRp9Q8EAQAAAAD4aM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABloUc4ZAJwsvPDnlStXunPU19cXjvfo0cOdY8CAAW7NGWec4dbcd999bo0XvC1J1157beH40KFD3TkmTJjg1tx9991uTc+ePd0aL7x4165d7hzV1dVuTeRnWrdunVuzceNGt8bMCsd79+7tzrF582a3ZuzYsW7NQw/58VxTp051a7p161Y4vn//fneON954w60BgBMNz5wBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGSDnDECHd/jwYe3du7ewJpLd9OyzzxaOz5kzx53jiSeecGv69evn1ng5UtGa+fPnF47X1dW5c0Ty3ebNm+fWLFq0yK158803C8cHDRrkzvHKK6+4NYMHD3ZrTjvtNLdm1apVbs1bb71VOL5hwwZ3jne9611uzWuvvebW9OnTx62ZNm2aW+NlwB04cMCdI/K7BIATDc+cAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADBBCDaDD69evn6655prCmscff9yd56yzzioc37x5sztHJBg6EtAb4QVvS9LIkSMLx3fv3u3OsWbNGrcmEsbcu3dvt6ahoaFwPBJkPWHCBLdm/Pjxbk3k2FRXV7s1O3bsKByfMmWKO4d3XKTY72nEiBFuTSQUe+HChYXjkyZNcuc4ePCgWwN0RGbWZteVUmqz6+ooeOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgBBqAB3e3r17tWTJksKaSDDx8uXLC8e7du3qzrFu3Tq35tRTT3VrevXq5dZcccUVbs3ixYtbvJZdu3a5NQMHDnRrBg0a5Na8+uqrhePXXXedO8ejjz7q1owbN86t2bRpk1tTVVXl1ng/04UXXujOsWDBArfmve99r1vzi1/8wq2J3CZ+53d+x63x1NbWtngOICeR8OhIzSmn+M+9RPaeyDxewP3hw4fdOSJB1pUKu67U8fN4x6Xw+lt87QAAAACAFmvRM2dmViOpTtIhSQ0ppdmVWBQAtBT7E4AcsTcBKFKJlzW+K6W0pQLzAEClsT8ByBF7E4Am8bJGAAAAAMhAS5uzJOlnZrbIzG5qqsDMbjKzhWa2sIXXBQDHo3B/arw3HThwoB2WB6CD4twJwDG19GWN70gprTezwZIeM7PlKaWnGheklG6VdKskmVllPmoFAHyF+1Pjval///7sTQDaCudOAI6pRc+cpZTWl//dJGm+pLMrsSgAaCn2JwA5Ym8CUKTZzZmZ9TSz6iNfS3qPpGWVWhgANBf7E4AcsTcB8LTkZY1DJM0vh7l1knR3SumRiqwKAFrmuPan/fv3a+XKlYUT9u7d271SL2zzrLPOcufYssX/ALeamhq3ZsaMGW6NF24sSZs3by4cr66udueIhDHX1dW5NSNHjnRr+vfvXzgeCWO++OKL3ZrXX3/drYkEmU6ZMsWt8bz22mtuTeRn2r59u1tz5plnujU///nP3ZrzzjuvcDxyf9u2bZtbkyHOnTowLwC5Uyf/tLxHjx5uTa9evdyayN7dtWtXt2br1q2F45H3dEcCmw8dOuTWVIr3c0eCtffs2VM4XnRcmt2cpZTekDS9ud8PAK2F/QlAjtibAHj4KH0AAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAy0JoQZOKlVVVYXjkdDBlFJF1hIJfowEO06YMKFwfNWqVeE1ncy6devmHqtIAOZzzz1XOD5s2DB3jkhw8fvf/3635tZbb3VrLrnkErfGC0netWuXO8eiRYvcmrlz57o1kdurd98ZMmSIO8czzzzj1kTu6+PGjXNrnn76abemX79+heM9e/Z054jcrtavX+/WRIKqL7zwwhav55577nHnuPzyy90aoK14AdOSf57RvXt3d46RI0e6NWPHjq1ITd++fd2azZs3F457IdWSdPDgQbfGC3WOivyeunXrVjge2SuXLVsWXtPReOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgBBqNIsX4hcJ+YuEOg8fPtytOe+889yahx9+2K2pVMBhJUQCpiN+//d/v3D8K1/5SkWu50S3f/9+rVy5srDm9NNPd+cZMWJE4fhbb73lzjFx4kS35tFHH3VrBg0a5NasWbPGrZk1a1bh+G233ebOMXnyZLdmxYoVbs2oUaPcmtdff71wfMmSJe4cXvC2JO3bt8+tufjii92ayL7jhUx7IdWStHz5crfmggsucGt69+7t1nzmM59xa+64447C8SeeeMKd49VXX3VrgLZSiRDqyP0rEkI9ffr0iswzbNgwt2bv3r2F45H9qaGhwa2pr693a1JKbs2hQ4fcGi9Y+6677nLniJzjHgvPnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZIOcMraIl+Q6NRXJ3zjnnHLcmktXxzW9+M7SmtjB48GC35pJLLnFrdu3aVYnlnPTMzM2fGTJkiDvP0KFDC8c7dfK33Ejey8GDB92a/v37uzXezyxJjz32WOF4JMNmzJgxbk0keyZybDZs2FA4Hsn26dWrl1tz/vnnuzX79+93ayJZjqecUvx3VC9nSJJWrVrl1tx///1uzbRp09yaj3/8426N9/u+4oor3DkiuXc333yzWwNUgnc/laTu3bsXjvfp08edI7JnRO6nkceIyF7o5TB26dLFnaNv375uTeTxyssnk6QtW7a4NV7WbOSxvCV45gwAAAAAMkBzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSAEGo0ixcGGAmLnT17tlszefJkt2bjxo1uzcSJE92a+fPnF45v27bNncMLmJSkNWvWuDUDBgxwa3r37u3WrFu3zq1BKSRz7NixhTXPP/+8O48XQp1ScueIBJlGQt6XLl3q1sycOdOt8UJR6+rq3DlefPFFt2bPnj1uzaBBg9waL/g5Mkd9fX1FaiL7wbhx49yazp07F45H9oI5c+a4NZFg1TfffNOtiYSOe8fv4YcfdueIPD4AlRAJQO7atatb4wU2n3rqqe4cU6dOdWt69Ojh1nhB8FIsFNsLqo6EUEfOeSKPjZGA6cjPHdm7PZH1HvN7W3ztAAAAAIAWc5szM7vdzDaZ2bJGl/U3s8fMbGX5336tu0wA+G3sTwByxN4EoLkiz5zdIenSoy77gqTHU0oTJT1e/n8AaGt3iP0JQH7uEHsTgGZwm7OU0lOSjn6zzVWS7ix/faek91V4XQDgYn8CkCP2JgDN1dwPBBmSUqotf71B0pBjFZrZTZJuaub1AMDxCu1PjfemSrz5FwAcnDsBcLX4A0FS6ePHjvkRZCmlW1NKs1NK/kfzAUAFFe1PjfemyKdsAUClcO4E4Fia25xtNLOhklT+d1PllgQALcL+BCBH7E0AXM1tzh6QdEP56xsk/aQyywGAFmN/ApAj9iYALvc9Z2Z2j6R5kgaa2TpJN0v6sqQfmtmNktZIuq41F4m2FQnO80KmvaBFSbr22mvdmgMHDrg13bp1c2uqq6vdGjMrHI8cF28OKRYguXbtWrdm+/btbk0kVPZEVqn9qaqqyg3y7du3r7ue5cuXF45Hfh8f+tCH3JpVq1a5NZGw4MjtbMeOHYXjGzZscOcYOXKkWxP5mfbt2+fWXHXVVYXjkdD6Cy+80K2J/C69cFYpFpo6ffr0wvFIsH2kJhJmvXv3brcmsid7geyRfXLbtqM/byMfnDvlIfK4HQmYjtzfIy+P90KdIwHuw4YNc2siIdSRcOjIsTl8+HDh+N69e905IscuMk/kvOjgwYMtvq5K3K6KzhfdW1tK6fpjDL3b+14AaE3sTwByxN4EoLla/IEgAAAAAICWozkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGTg5E6obQOR0GEvbFPyA+0ic0RqIoGChw4dcms8H/vYx9yaSHjt/v373ZpIaGMkFNULp61EGKMk7dmzx62JhCRGAmO9YMdIWHhkvSe6+vp6rV+/3q3xnHvuuYXjNTU17hyPPPKIWxMJ7Jw0aZJbEwkmPvPMMwvH+/Xr584RCS6ePXu2W1NbW+vWLFy4sHD8yiuvdOeoVGBzJKj01FNPdWvq6uoKxw8cOODOMXDgQLcmEvIdCeiO/NwPPfRQ4fgZZ5zhzvHcc8+5NchT5NwpUuM9LkfCoytxPVLsPjZhwoTC8VGjRrlzVCJEWYo9pu3atcut8Y5xZH+KnOtFzk0jP9POnTvdGm8PGzRokDuHd05eNM4zZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAMdNoS6UuHRkZqISHixp60CpiXp+uuvLxyPBKsuXrzYrencubNb07dvX7dm69atbs22bdsKxyMBk9XV1W5N5PcUEQl67dGjR+H4xIkT3TlefPHF8JpOVIcOHXLDtt944w13Hi/sPBK0/NJLL7k1kf0iErQ5Y8YMt+buu+8uHL/gggvcOU4//XS3ZtOmTW7NxRdf7NZ4e48XNi/FAqa7dOni1owZM8atieyD3h63atUqd44tW7a4NdOmTXNrIvvOkCFD3Jqrr766cPyWW25x5xg5cqRb8/zzz7s1qKzIbSTyOBiZx6uJnKNF7suRx/+pU6e6NV7IdNeuXd05Iucz3bt3d2six9d7XJT84xc571y/fr1bEwnfbmhocGsiv2/v2AwbNqzF11P08/DMGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJCBDptzVql8skrkcEh+DkRkvZXKMPvwhz/s1kyaNKlwfO3ate4ckdyQSB5dJM8jkqHhZZRFsqX27t3r1nhZWFLlcvg8l1xyiVvTEXLOunTpoqFDhxbWRLK6fv3rXxeOP/nkk+4cI0aMcGsimVWRfWfZsmVuzXXXXVc4HsnYeuWVV9yaSPZM5DbvZYtFcs68/U2K5WetXLnSrYmsx9tXPvGJT7hz1NfXuzXLly93a5YuXerW7Nixw63p1atX4fill17qzjF//ny3Br8ReVypxByRfNLIPJEab5/r2bOnO0dkz41k6kX2DS9D0csmlWJZaJEcuUr9LitxLlKptUTOryLZbd4xHj9+vDuHd25atA6eOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABk4IUOoI+GqnkhoXiQULxJMHKmphGHDhrk1V199tVsTCXX2wlW9gFEpFqQ4YMAAt+bgwYNuTeT3HQl/9ESCwA8cOFCReSJBit5tb86cOe4cHUFVVZX69OlTWBMJbJ42bVrheE1NjTvH2LFj3ZpIWPBpp53m1kTCrL39YPDgwe4ckfvoqaee6tZMnDjRrfnRj35UOP7Od77TneOJJ55wa+bOnevWrFu3zq2ZMWOGW7Nt27bC8Z/97GfuHJF9Z/r06W5N5DZz5plnujXPPvts4XgkGHjcuHFuTST4/WQQCR32VCL0WZI6dfJPLSOh85EAae8cIXIbiQRMR85XIjXeY3vk91iJcxUpdq4XCXVuaGgoHO/fv787R319vVuzc+fOiswTCbP2bueVCBzfvn37sa/fm9zMbjezTWa2rNFlXzKz9Wb2Yvm/y9xVAkCFsT8ByBF7E4DmijwFdYekS5u4/B9TSjPK/z1U2WUBQMgdYn8CkJ87xN4EoBnc5iyl9JSk4tdUAEA7YH8CkCP2JgDN1ZI3b33SzF4qP3Xfr2IrAoCWY38CkCP2JgCFmtucfVvSeEkzJNVK+tqxCs3sJjNbaGYLm3ldAHA8QvtT471p3759bbk+AB0T504AXM1qzlJKG1NKh1JKhyV9R9LZBbW3ppRmp5RmN3eRABAV3Z8a702RT60CgJbg3AlARLOaMzMb2uh/f0+S/xnTANAG2J8A5Ii9CUCEG0ZhZvdImidpoJmtk3SzpHlmNkNSklQj6aOtuEYAaBL7E4AcsTcBaC63OUspXd/Exbc19wq9gL1I+G5bhTpHgosjBg0a5NaMHj26cPz000935xg6dKhbEwmD3bVrl1vTt2/fwnEvfE+KBQFGQh0jtwfv+EbWs2PHDneOSABiZL2RoM/I+6S8+1tdXZ07x9SpUwvHX3/9dXeO1lKp/am+vt4N1/3oR/3zKO/lkbfffrs7x4oVK9yaUaNGVWSeSKizF0K6f/9+d45IYHN1dbVbE9mbzjjjjMLxyL5+1llnuTUrV650a+bNm+fWbN682a3ZsGFD4XgkyPq5555zaxYsWODWjB8/3q15/vnn3RovvDzyuBkJLm8vbX3uFHms9PanSHh0JBi6Xz//c04i5yuR8OIJEyYUjkeCtSOPyZHQ7Mjx81TqJfaR8OjI+Upkf/fO24vClo+IHN9IQHfk565E+LZ3DhypWbdu3THHWvJpjQAAAACACqE5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADLQ8sS84xQJmfYMGTKkcDwSOBwJUozURMLsxo4d69b06NGjcDwSFrh79263JhJu3KdPH7fG+7kbGhrcObyfWZL27t3r1hw4cMCtiQQc1tbWFo5HjkvkZ4oEMvbq1cutiQR97tmzp3A8EuI6YMCAwvE1a9a4c+QupeQGtN91113uPCNGjGjRuCStXr3arbnuuuvcmohIEE+QloUAABM4SURBVLx3G4nsk5H9KxKq7oUxS/79NBKqOmvWLLcmEuD98MMPuzWRcPvLL7+8cNy77Uqxn+mRRx5xayK/p/POO8+tWbt2beF45DEk8vhwMjAz97565plnuvN4wc+R+0YkGHrSpEluTSWCgCU/vD5yG4mcO0VCviO32UpcT+ScJ3I/jQR0R67LO++JhHNXIkRdknr37u3WRPZcr1eJ9DKRcPNj4ZkzAAAAAMgAzRkAAAAAZIDmDAAAAAAyQHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQgTYPofZcdNFFbs2wYcMKxyOBp4MHD3ZrIoHNkZC5yHrq6uoKxyOhxJFA4UjoYCQM0AtSjhy7yM9UVVXl1nhBy5J/fCVp586dheOR20ylRIKqI7c9L7QxEs7tBWumlNw5ctfQ0KCtW7cW1kyePNmd553vfGfheCRE8/XXX3drRo4c6dZEwkO3bdvm1ixevLhwPLJfRIK1Z86c6dZceeWVbs13v/vdwvFzzjnHneO5555zayKh9GPHjnVrampq3Brv+EX2gtNOO82tiYToTpkyxa1ZtmyZW+MF00ZuV5H7wcmgS5cuGj16dGHNxRdf7M7j7T+RPSMSDD1ixAi3ZvPmzW5N5HbtnSNE7qeRx8HIeVxkf/dCs8eMGePOEQnNjqw3InKeNmTIkMJxL0Bd8oOsoyLXFQno9kKmDx486M7RknMnnjkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZaNMQ6t69e+vcc88trLnxxhvdeZYvX144Xltb686xa9cutyYSgBwJoovM44mEKEeCFL1gPan0e/J4YdaRMMZIwGQkUDASvu2FJErS1KlTW7yWSvyupViwdiS0cf/+/S2+nk2bNhWOR4Jrc9ejRw/NmDGjsCZyH/R+/y+88II7R8+ePd2aN998062JhBtHeHv20qVL3TkGDhzo1rz22mtuzZIlS9wab0+O3F69/U2KBe0uWrTIrfHChSXp9NNPLxxfu3atO0ckEPvqq692ayLXNWHCBLfG25s2bNjgzjF//ny35mTQtWtXjRs3rrAmEkLthRfv2LHDnSMSQu0FLUuxcwQvqFySBg8eXDgeCTOPPA5Gwpgj1+XN05bh0ZHfZeTxyNsvK7WWyO8pst7IubIXyB4Jsh4+fHjh+OrVq485xjNnAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAbaNOdsz549+tWvflVY42XqSNK0adMKx+fMmXNc6zqWSB5OJPto27ZtLa7ZuXOnO0ckuyGS3zNgwAC3ZtKkSYXjkQyuSJ5aSsmtmT59ulvz0ksvuTVeLtRFF13kzhHJOYn8TBGR2+f69esLxyN5f15GySmnnBx/4/EyAL2cIcnP2Lr88svdOSK3j0heoZfbJ/mZkZKfRxXJK4pkY0V4WXSS1KdPn8LxSDZl5GeKrCWS9xVZj5epM2rUKHeOkSNHujWRnMYLLrjArXnllVfcGi/Xbu7cue4czzzzjFtzMqivr3f38ocfftidx8sEjeSBDho0yK2JZE3169fPrYnshd51RfJJI+crkfOrSI33M0VyziKP/ZHzzshjdySP1rvd9O3b150jInJ+FcnGi+xze/fuLRyP3Da9x5Gi4+/+ZsxspJk9YWavmNnLZvap8uX9zewxM1tZ/te/pwFAhbA3AcgV+xOA5or8ybtB0mdTSlMknSvpE2Y2RdIXJD2eUpoo6fHy/wNAW2FvApAr9icAzeI2Zyml2pTS4vLXdZJelTRc0lWS7iyX3Snpfa21SAA4GnsTgFyxPwForuN6s4iZjZE0U9ICSUNSSrXloQ2S/BcrA0ArYG8CkCv2JwDHI9ycmVkvSfdJ+nRK6W2fIpBK74xr8t1xZnaTmS00s4WRNxYCwPGoxN7kfeACADRHJfanyAdAADh5hJozM+us0uby/ZTSj8sXbzSzoeXxoZI2NfW9KaVbU0qzU0qzT5ZPdQOQh0rtTZFP5wOA41Gp/SnyCXQATh6RT2s0SbdJejWl9PVGQw9IuqH89Q2SflL55QFA09ibAOSK/QlAc0X+HDNH0ockLTWzF8uXfVHSlyX90MxulLRG0nWts0QAaBJ7E4BcsT8BaBarVCBu6MrM2uTKvNBcSTrnnHPcmtNOO82tOf/8892awYMHuzVeIHMk1DESMB35fUfeG+gFHEbCbR977DG3JhKs6YXkVsoDDzzg1kTCYLds2eLWRMLNIzXeexUOHDjgzvG5z32ucHzfvn06dOiQf+PL2IABA9Ill1xSWDNlyhR3nv/8z/8sHD/jjDPcOVatWuXWRAJcv/Wtb7k1Dz74oFvjBZVHgpYj4bavvvqqW+MF8Ur+sYkEJHthvZJ02223uTWR4PLIfrtx48bC8VtuucWdo6amxq2J/C6XLFni1kQei7zA3k2bmny139s8//zzbs0999yzKKU02y3MWFVVVerWrVthTeSxx5sjcp4RCaGurq52a/r37+/WjB8/vsXX5Z1bSbEw5ojIY/KKFSsKxyPnTtu3b3drIoHYEZF5vHPcefPmuXNEXrob2Vcit+Hdu3e7NRs2bCgcj4R8/+AHPygcr6mp0b59+5r8oXgTGAAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgAzRnAAAAAJABmjMAAAAAyMBJGUINoG2llE7oEOrevXuns88+u7BmzJgx7jxeCHUkVDUSmrpjxw63JhKSGQnF9kLen3nmGXeOyLEbNmyYW+OF6ErS6tWrC8cjxzdi9OjRbs1Pf/pTt2b69OluzdixYwvHI8G1kcf6tWvXujXdu3evSI0XTPvyyy+7c2zdutWteeqpp074EOrIuVMkSNmricwRCQuuqqqqyDyR+7s3T2QtkftGJCy+vr7erTlw4ECL54gcu86dO7s1kVDnQ4cOuTXeMe7Ro4c7RyTsuqGhwa2J8H4Hkv9zHzx40J3DCyVvaGjQ4cOHCaEGAAAAgFzRnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZ8JPsAOAkV19frw0bNhTWRMI4vbDlwYMHu3MsWLDArYmExU6YMMGtqampcWu8QOFJkya5czz99NNuzZVXXunWREJpq6urC8cjobSRkO9IWOwFF1zg1uzevdutqa2tbfEckdtD5HY1YMAAt2b48OFuTd++fQvHI8HAPXv2dGs6ikhIcqTGEwnfrZRISHIl5ojc1iqlEtdVieNSSd562vL4tpXW/pl45gwAAAAAMkBzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSAEGoAHV6nTp3Ur1+/wpoZM2a483gBxy+88II7x5AhQ9yarVu3ujWRIOVOnfyHgD179hSOe2HCknTOOee4NatXr3ZrBg0a5Na88cYbheOzZ89259i8ebNb8/3vf9+tecc73uHWLF682K3xwpYj4cJz5851ax588EG35pprrnFrXnrpJbema9euheNdunRx51i2bJlbgxNXJYJ+CUBufbmt52TAM2cAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZoDkDAAAAgAzQnAEAAABABmjOAAAAACAD5oXHmdlISd+VNERSknRrSumfzOxLkj4i6Uha5xdTSg85c5FUB5yEUkrW1tdZyb2pV69eyQuZbmhocNc0efLkwvEDBw64c+zbt8+t2bZtm1sza9Yst6aurq7F17V37153jmHDhrk1Tz75pFszePBgt2bmzJmF45s2bXLneP31192aSPDqtGnT3BovjFmSFi5cWDg+ZcoUd45IsPb27dvdmki4eeQYX3bZZYXjXii8FLuv3HnnnYtSSn7yeIVx7gTAc6xzp06B722Q9NmU0mIzq5a0yMweK4/9Y0rpq5VaJAAcB/YmALlifwLQLG5zllKqlVRb/rrOzF6VNLy1FwYARdibAOSK/QlAcx3Xe87MbIykmZIWlC/6pJm9ZGa3m5n/GgQAaAXsTQByxf4E4HiEmzMz6yXpPkmfTintkvRtSeMlzVDpr0NfO8b33WRmC82s+EXzANAMldibIu8nA4DjxbkTgOMVas7MrLNKm8v3U0o/lqSU0saU0qGU0mFJ35F0dlPfm1K6NaU0uz3ekAvg5FapvalTp8jbbwEgjnMnAM3hNmdmZpJuk/RqSunrjS4f2qjs9yQtq/zyAKBp7E0AcsX+BKC5In8uniPpQ5KWmtmL5cu+KOl6M5uh0kfE1kj6aKusEACaxt4EIFfsTwCaxc05q+iVkdUBnJTaI+eskgYNGpSuuuqqwpp169a585T+WH5sVVVV7hzdunVza6qrq92aJ554wq258MIL3ZolS5YUjk+cONGdI5KNFXnf36FDh9yaUaNGFY6PHDnSnSPyO/jlL3/p1vTp08etieSceTVeDpok9e/f360ZPtz/MMFIplokL+3ZZ58tHI/k50Vue/Pnz2+XnLNK4twJODkd69zpuD6tEQAAAADQOmjOAAAAACADNGcAAAAAkAGaMwAAAADIAM0ZAAAAAGSA5gwAAAAAMkBzBgAAAAAZoDkDAAAAgAx0au8FAEB7279/v1577bXCmuXLl7vzXHrppYXjO3fudOcYO3asW/P000+7NbNmzXJr3nzzTbfGC3VesWKFO8fZZ5/t1kRCsysR0B0J8I6EhU+fPt2tGTNmjFvzr//6r27NBz/4wcLx/fv3u3PU1dW5NWvWrHFrOnfu7Nbs2bPHrfGCyUePHu3OMXjwYLcGAE40PHMGAAAAABmgOQMAAACADNCcAQAAAEAGaM4AAAAAIAM0ZwAAAACQAZozAAAAAMgAzRkAAAAAZIDmDAAAAAAyYCmltrsys82SGqdcDpS0pc0W0HKst3Wx3tbVWusdnVIa1Arztpkm9iaJ329rY72ti/WWnIz7E7/b1sV6WxfrLTnm3tSmzdlvXbnZwpTS7HZbwHFiva2L9bauE2297e1EO16st3Wx3tZ1oq23PZ1ox4r1ti7W27raY728rBEAAAAAMkBzBgAAAAAZaO/m7NZ2vv7jxXpbF+ttXSfaetvbiXa8WG/rYr2t60Rbb3s60Y4V621drLd1tfl62/U9ZwAAAACAkvZ+5gwAAAAAoHZszszsUjN7zcxWmdkX2msdUWZWY2ZLzexFM1vY3us5mpndbmabzGxZo8v6m9ljZray/G+/9lxjY8dY75fMbH35GL9oZpe15xobM7ORZvaEmb1iZi+b2afKl2d5jAvWm+0xzgV7U2WxN7Uu9qaOhf2pstifWg97UwvW0h4vazSzKkkrJF0saZ2kFyRdn1J6pc0XE2RmNZJmp5SyzGYws3dK2i3puymlM8qX/YOkbSmlL5c38X4ppb9sz3UecYz1fknS7pTSV9tzbU0xs6GShqaUFptZtaRFkt4n6Y+V4TEuWO91yvQY54C9qfLYm1oXe1PHwf5UeexPrYe9qfna65mzsyWtSim9kVI6KOleSVe101pOCimlpyRtO+riqyTdWf76TpVuZFk4xnqzlVKqTSktLn9dJ+lVScOV6TEuWC+KsTdVGHtT62Jv6lDYnyqM/an1sDc1X3s1Z8MlrW30/+uU/+acJP3MzBaZ2U3tvZigISml2vLXGyQNac/FBH3SzF4qP3WfxVPdRzOzMZJmSlqgE+AYH7Ve6QQ4xu2IvaltZH+/aUL29xv2ppMe+1PbyP6+04Ss7zvsTceHDwSJe0dKaZak35X0ifJTyyeMVHr9au4fzfltSeMlzZBUK+lr7buc32ZmvSTdJ+nTKaVdjcdyPMZNrDf7Y4zjxt7U+rK/37A3IVPsT60v6/sOe9Pxa6/mbL2kkY3+f0T5smyllNaX/90kab5KLy/I3cbya2iPvJZ2Uzuvp1BKaWNK6VBK6bCk7yizY2xmnVW6w34/pfTj8sXZHuOm1pv7Mc4Ae1PbyPZ+05Tc7zfsTR0G+1PbyPa+05Sc7zvsTc3TXs3ZC5ImmtlYM+si6QOSHmintbjMrGf5zYEys56S3iNpWfF3ZeEBSTeUv75B0k/acS2uI3fWst9TRsfYzEzSbZJeTSl9vdFQlsf4WOvN+Rhngr2pbWR5vzmWnO837E0dCvtT28jyvnMsud532JtasJbUTiHUVvooym9IqpJ0e0rpf7XLQgLMbJxKf/GRpE6S7s5tvWZ2j6R5kgZK2ijpZkn3S/qhpFGS1ki6LqWUxRtJj7HeeSo9bZwk1Uj6aKPXJbcrM3uHpKclLZV0uHzxF1V6PXJ2x7hgvdcr02OcC/amymJval3sTR0L+1NlsT+1HvamFqylvZozAAAAAMBv8IEgAAAAAJABmjMAAAAAyADNGQAAAABkgOYMAAAAADJAcwYAAAAAGaA5AwAAAIAM0JwBAAAAQAZozgAAAAAgA/8f0jnPqo1A0mMAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 1080x1080 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}