Numpy_Linear.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.7.6"
    },
    "colab": {
      "name": "Numpy Linear",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Kshitij-Ambilduke/Memes-vs-Notes/blob/master/Numpy_Linear.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "akE-sGsGq7i6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "4f04b44c-de40-4b9b-bfa8-458ee8837188"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VOQaj9GSq7i_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "import os\n",
        "#import torch\n",
        "#import torch.nn as nn\n",
        "#import torch.nn.functional as F\n",
        "import cv2\n",
        "import random\n",
        "import numpy as np"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1t5oT9hrtTi0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "meme_path = \"/content/drive/My Drive/dataset stage 0 /meme\"\n",
        "note_path = \"/content/drive/My Drive/dataset stage 0 /note\""
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yy-MtmNQtWtY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def dataloader(folder,label):\n",
        "    images=[]\n",
        "    labels=[]\n",
        "    for file in os.listdir(folder):\n",
        "        img = cv2.imread(os.path.join(folder,file),0)\n",
        "        #img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
        "        img = cv2.resize(img, (100,100))\n",
        "        images.append(img)\n",
        "        labels.append(label)\n",
        "    return images, labels"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "afZGlQOJtZg-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "meme, memelabel = dataloader(meme_path, 1)\n",
        "note, notelabel = dataloader(note_path, 0)"
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oigPlvxyuqiq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "meme = np.array(meme)\n",
        "memelabel = np.array(memelabel)\n",
        "#print(meme.__len__())\n",
        "meme = meme.reshape(800,1,100,100)\n",
        "note = np.array(note)\n",
        "note = note.reshape(800,1,100,100)\n",
        "notelabel = np.array(notelabel)\n",
        "#print(len(notelabel))\n",
        "\n",
        "memezip = list(zip(meme, memelabel))\n",
        "notezip = list(zip(note, notelabel))\n",
        "\n",
        "toshuffle = []\n",
        "toshuffle = memezip[0:750] + notezip[0:750]\n",
        "random.shuffle(toshuffle)\n",
        "xtrain, ytrain = list(zip(*toshuffle))\n",
        "\n",
        "toshuffle = []\n",
        "toshuffle = memezip[750:775] + notezip[750:775]\n",
        "random.shuffle(toshuffle)\n",
        "xtest, ytest = list(zip(*toshuffle))\n",
        "\n",
        "toshuffle = []\n",
        "toshuffle = memezip[775:] + notezip[775:]\n",
        "random.shuffle(toshuffle)\n",
        "xval, yval = list(zip(*toshuffle))"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fUf1SJZn1B4h",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "0ae79cf3-121f-4fd2-a95c-e139a372821c"
      },
      "source": [
        "xtrain = np.array(xtrain)\n",
        "xtest = np.array(xtest)\n",
        "xval = np.array(xval)\n",
        "\n",
        "xtrain = xtrain.reshape(1500,-1)\n",
        "xtest = xtest.reshape(50,-1)\n",
        "xval = xval.reshape(50,-1)\n",
        "\n",
        "print(xtrain.shape)\n"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1500, 10000)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-bDzSKVVva7i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "xtrain = np.array(xtrain).T\n",
        "xtest = np.array(xtest).T\n",
        "xval = np.array(xval).T\n"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S7JlByeQxyx3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "243c7d40-7d0c-4d10-9326-c672623908cc"
      },
      "source": [
        "print(xtrain.shape)"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(10000, 1500)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "txb1QHYlq7jE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def one_hot(y):\n",
        "  Y = np.zeros((2,y.shape[0]))\n",
        "  for n,i in enumerate(range(len(y))):\n",
        "    #if y[i]!=0:\n",
        "    Y[y[i],n]=1\n",
        "  return Y\n",
        "\n",
        "Ytrain = one_hot(np.array(ytrain))\n",
        "Ytest = one_hot(np.array(ytest))\n",
        "Yval = one_hot(np.array(yval))"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yv7AL5hE0DCd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "03d8ab64-e8c5-49b0-d4c3-e8a6232552b0"
      },
      "source": [
        "print(xtrain.shape)\n"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(10000, 1500)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wHm15Pphq7jI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ytrain = np.array(ytrain)\n",
        "yval = np.array(yval)\n",
        "ytest = np.array(ytest)"
      ],
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vnLzeTSYq7jO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "fbc21b2a-26d2-4d0c-802d-6401ed5ae021"
      },
      "source": [
        "print(xtrain.shape)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(10000, 1500)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vEChjegEq7jc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def initialize_parameters(dims):\n",
        "    parameters={}\n",
        "    l = len(dims)\n",
        "    for i in range(1,l):\n",
        "        parameters['W'+str(i)] = np.random.randn(dims[i],dims[i-1])*0.01\n",
        "        parameters['b'+str(i)] = np.zeros((dims[i],1))\n",
        "    return parameters"
      ],
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NpfGkHrBq7jg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def relu(Z):\n",
        "    x = np.maximum(0,Z)\n",
        "    return x"
      ],
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y5ffLVfhq7jj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def softmax(x):\n",
        "    \"\"\"Compute softmax values for each sets of scores in x.\"\"\"\n",
        "    e_x = np.exp(x - np.max(x))\n",
        "    return e_x/np.sum(e_x, axis=0, keepdims=True)"
      ],
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "94I7zvffq7jl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def forward_propagation(X, parameters):\n",
        "    cache = {}\n",
        "    l = len(parameters)//2\n",
        "    cache['A0'] = X\n",
        "    for i in range(1,l+1):\n",
        "        cache['Z'+str(i)] = np.dot(parameters['W'+str(i)],cache['A'+str(i-1)]) + parameters['b'+str(i)]\n",
        "        \n",
        "        cache['A'+str(i)] = relu(cache['Z'+str(i)])\n",
        "        \n",
        "    cache['A'+str(l)] = softmax(cache['Z'+str(l)])\n",
        "            \n",
        "    return cache"
      ],
      "execution_count": 43,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2fvZ5KOUq7jp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def compute_cost(AL,Y):\n",
        "    m = Y.shape[1]\n",
        "    cost = -1*np.sum(Y*np.log(AL))/m\n",
        "    return cost"
      ],
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-LJ_WA-Lq7jt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def backRelu(Z):\n",
        "    z = np.zeros((Z.shape[0],Z.shape[1]))\n",
        "    for i in range(Z.shape[0]):\n",
        "      for j in range(Z.shape[1]):\n",
        "        if Z[i,j]>0:\n",
        "          z[i,j] = 1\n",
        "        else:\n",
        "          z[i,j] = 0\n",
        "    return z\n",
        "        "
      ],
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lVsCCJkWq7jy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def back_propagation(X, Y, parameters, cache):\n",
        "    m = Y.shape[1]\n",
        "    l = len(parameters)//2\n",
        "    back_cache = {}\n",
        "    \n",
        "    dZ = cache['A'+str(l)] - Y\n",
        "    back_cache['dW'+str(l)] = (1/m)*np.dot(dZ, cache['A'+str(l-1)].T)\n",
        "    back_cache['db'+str(l)] = (1/m)*np.sum(dZ, axis=1, keepdims = True)\n",
        "    \n",
        "    for i in reversed(range(1,l)):\n",
        "        dZ = np.dot(parameters['W'+str(i+1)].T,dZ)*backRelu(cache['Z'+str(i)])\n",
        "        back_cache['dW'+str(i)] = (1/m)*np.dot(dZ, cache['A'+str(i-1)].T)\n",
        "        back_cache['db'+str(i)] = (1/m)*np.sum(dZ, axis=1, keepdims=True)\n",
        "     \n",
        "    return back_cache"
      ],
      "execution_count": 46,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mxn8Ximxq7j3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def update(paramters, back_cache, lr):\n",
        "    l = len(parameters)//2\n",
        "    for i in range(1,l+1):\n",
        "        parameters['W'+str(i)] -= lr*back_cache['dW'+str(i)]\n",
        "        parameters['b'+str(i)] -= lr*back_cache['db'+str(i)]\n",
        "        \n",
        "    return parameters\n",
        "        "
      ],
      "execution_count": 47,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "at2P-jUckRoR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def predict(pred, Y):\n",
        "  temp=[]\n",
        "  pred = pred.T\n",
        "  for i in pred:\n",
        "    temp.append(np.argmax(i))\n",
        "  \n",
        "  count = 0\n",
        "\n",
        "  for i in range(len(temp)):\n",
        "    if temp[i] == Y[i]:\n",
        "      count+=1\n",
        "      \n",
        "  return count\n",
        "    \n",
        "\n"
      ],
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VOW0_Wu-296p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ytrain = np.array(ytrain)"
      ],
      "execution_count": 49,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MhDgSOKOq7j5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "parameters = initialize_parameters([10000, 5000,100, 2])"
      ],
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "831Qoz-33dno",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#print(ytrain.shape)\n",
        "xtrain = xtrain/255"
      ],
      "execution_count": 51,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4AJ-HrdXyYno",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "xval = xval/255\n",
        "xtest = xtest/255"
      ],
      "execution_count": 63,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "DoDs4urgq7j-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "outputId": "71b569d6-b9a3-4211-8abd-773ca808f894"
      },
      "source": [
        "trainloss=[]\n",
        "valloss = []\n",
        "trainacc = []\n",
        "valacc = []\n",
        "testacc = []\n",
        "\n",
        "for i in range(5):\n",
        "    k=0\n",
        "    for j in range(150):\n",
        "\n",
        "        cache = forward_propagation(xtrain[:,k:k+10], parameters)\n",
        "       \n",
        "\n",
        "        c = compute_cost(cache['A'+str(len([10000, 5000,100, 2])-1)],Ytrain[:,k:k+10])\n",
        "        #vloss = compute_cost(valcache['A'+str(len([10000, 5000,100, 2])-1)],Yval[:,k:k+10])    \n",
        "\n",
        "\n",
        "        grads = back_propagation(xtrain, Ytrain[:,k:k+10], parameters, cache)\n",
        "        parameters = update(parameters, grads, 0.01)\n",
        "        k+=10\n",
        "\n",
        "    valcache = forward_propagation(xval, parameters)\n",
        "    testcache = forward_propagation(xtest, parameters)\n",
        "    cache = forward_propagation(xtrain, parameters)     \n",
        "    \n",
        "    c = compute_cost(cache['A'+str(len([10000, 5000,100, 2])-1)],Ytrain)\n",
        "    vloss = compute_cost(valcache['A'+str(len([10000, 5000,100, 2])-1)],Yval)  \n",
        "\n",
        "        \n",
        "    tracc = predict(cache['A'+str(len([10000, 5000,100, 2])-1)],ytrain)\n",
        "    vacc = predict(valcache['A'+str(len([10000, 5000,100, 2])-1)],yval)\n",
        "    tacc = predict(testcache['A'+str(len([10000, 5000,100, 2])-1)],ytest)\n",
        "\n",
        "    trainloss.append(c)\n",
        "    valloss.append(vloss) \n",
        "    trainacc.append(tracc)\n",
        "    valacc.append(vacc) \n",
        "    testacc.append(tacc)\n",
        "\n",
        "    print(c) \n",
        "    print(f\"training acc = {tracc}\")\n",
        "    print(f\"testing acc = {tacc}\")\n",
        "    print(f\"validation acc = {vacc}\")\n",
        "    print()  \n",
        "    \n"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.6097969217966318\n",
            "training acc = 1002\n",
            "testing acc = 32\n",
            "validation acc = 32\n",
            "\n",
            "0.45852175572144294\n",
            "training acc = 1208\n",
            "testing acc = 39\n",
            "validation acc = 40\n",
            "\n",
            "0.20682679368460666\n",
            "training acc = 1379\n",
            "testing acc = 47\n",
            "validation acc = 45\n",
            "\n",
            "0.14189025141747327\n",
            "training acc = 1429\n",
            "testing acc = 49\n",
            "validation acc = 45\n",
            "\n",
            "0.16857241236409465\n",
            "training acc = 1406\n",
            "testing acc = 48\n",
            "validation acc = 45\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xfZjvZkwq7kB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "08610c0f-89e7-4d37-91ee-69ab8ff2e76e"
      },
      "source": [
        "from matplotlib import pyplot as plt\n",
        "def plot(data,labelx,labely):\n",
        "  plt.plot(data)\n",
        "  plt.xlabel(labelx)\n",
        "  plt.ylabel(labely)\n",
        "  plt.show()\n",
        "plot(trainacc,'epoch','train acc')\n",
        "plot(testacc,'epoch','test acc')\n",
        "plot(valacc,'epoch','val acc')\n",
        "plot(trainloss,'epoch','trainloss')\n",
        "plot(valloss,'epoch','val loss')\n"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU9b3/8deHEBLCkoAJyL4oCrixRNSi1ipWWv2htnqvtCBSEbXL1Z/3Vsu9tv5qa69d7q21rVUKyuZatWqp1aKodamERJEdZVN2gqxhSUjy+f0xJxBgAgPk5Mxk3s/HYx6Zs828OTr55HzPmc8xd0dERORgTaIOICIiyUkFQkRE4lKBEBGRuFQgREQkLhUIERGJq2nUAepLfn6+d+/ePeoYIiIppaSkZJO7F8Rb1mgKRPfu3SkuLo46hohISjGzT+tapiEmERGJSwVCRETiUoEQEZG4VCBERCQuFQgREYlLBUJEROJSgRARkbgazfcgRCT1rd+2h5mLN1JeWUXPgpb0zG9Bp7zmNGliUUdLSyoQIhIZd2fRuh3MWLiB1xZtYN6abYesk9W0CT3yW9CzoAU981vGfhbEfrbOzowgdfpQgRCRBlVRWc2sFZ/z2sINvLZoI2u27sYM+nfJ486hp3Jpn/bk5TRjeWkZyzftjP0s3cmidTt4dcEGqqr33+SsoFUWPfNjBeOkgv1FpHOb5jTN0Aj68VKBEJHQbdu1lzc/3siMhRt4a0kpO8oryc5swgW9Crjtkl58qXc7ClplHbBNQasszul5wgHzKiqr+WzzTpaV7mR56c59ReSV+evYsmvvvvWaZTSh6wk5QdFoeUARyctp1iD/5sZABUJEQrFq8y5mLNzAjIUbKFq5mapqJ79lFpef2YEhfdoz+OR8mjfLOKrXbNa0CSe3a8XJ7VodsmzLzgqWbypj2cadLNsUO+pYurGMmYs3srdq/1FH2xbNgoJRUzRiw1Vd2+aQqaOOA1hjuSd1YWGhq1mfSHSqq525a7YxY+F6Xlu4kSUbdgBwSvuWDOnTniF929Ovc16Dn3CurKpm1Zbd+4aqaorI8k1lbCqr2Lde0yZG17Y5+89x5O8/13FCi2aYNc4T5WZW4u6F8ZbpCEJEjtmevVW8u3QTry2KnU8o3VFORhPj7O5tuPvyPlzatz3dTmgRacamGbGT3D3yW3BJnwOXbdu994DCsTwYuvrHx5uoqKret15u88wDTpLXDF11OyGHrKZHdxSUSlQgROSobCorZ+bijby2cANvf7KJ3XuraJnVlC+eWsClfdpz0akFKTPOn9s8k/5d29C/a5sD5ldVO2u27N43VFVTRN5ZWspzH6zet14Tg85tcoKi0XJfETmpoAUFrbJS/qhDBUJEDsvdWVa6M3aUsHADJZ9twR065mZzbWFnhvRpzzk92zaqv6QzmhhdT8ih6wk5fOnUA5eVlVeyonQny0rLWF5axrJNsaOO95d/zp69+486WmU1pUdBiwOGqk4qaEmP/BZkZ6bGvtI5CBE5RGVVNR98tjV2PmHRRlZs2gnA6Z1ax84n9GnPaR1bp/xfyPWputpZt33PvqONZaX7jz7Wbtuzbz0z6Jjb/JCjjp4FLeiQm93g+1TnIETkiMrKK3n741JmLNrAG4s3smXXXjIzjPNOyudbg7tzSZ/2dMxrHnXMpNWkidEprzmd8ppzQa8D7+C5q6KSFZt27jvHUXO+40/Fq9hZUbVvvZxmGcGXAlvuu9Kq5qijRVbD/7pWgRBJY+u37QlOMG/gvaWfU1FVTV5OJhef2o4hfdtzQa98Wunbysctp1lTTuuYy2kdcw+Y7+5s2F5ea6gqVjjmrNrC9LlrqT3Ac2Lr7OAKq5ojj/BbkahAiKSRmtYWNUVh7upYa4tuJ+Rw/XndGNK3PYXd2uhbyA3EzDgxN5sTc7P5wsn5Byzbs7eKlZ/vPOAk+bJNO3lxzlp27Knct15W09gXDieMijtKdFxUIEQauYrKaopWbN53PiFea4uT27XU+YQkk52ZQe8TW9P7xNYHzHd3NpVVxI46guLRunk4R3kqECKN0Lbde3lzyaGtLc4/uYB/u+RkLu7d/pDWFpIazIyCVllxW5HUNxUIkUaiprXFa4s2ULRiM5X10NpC0lvoBcLMMoBiYI27X2FmbwM1jVTaAUXuflWc7aqAecHkZ+4+LOysIqmkprXFa0FRWLw+1tqiV7uWjL2wZ2StLaTxaIgjiNuARUBrAHe/oGaBmT0HvFjHdrvdvV/48URSx569Vby3bFNwpHBoa4shfdrTPT/a1hbSeIRaIMysM3A5cB9wx0HLWgMXA6PDzCCS6j4vK+f1eK0tTilgSN92fOnUdinT2kJSS9hHEA8Ad7J/SKm2q4DX3X17Hdtmm1kxUAnc7+4vHLyCmY0FxgJ07dq1fhKLJIGlG8vSqrWFJKfQCoSZXQFsdPcSM7sozirDgQmHeYlu7r7GzHoCM81snrsvq72Cu48HxkOs1UY9RRdpcDWtLWqKwvJarS1uu6SXWltIJMI8ghgMDDOzrwLZQGszm+buI8wsHxgEXF3Xxu6+Jvi53MzeBPoDy+paXyTV7Cyv5O1PSvn7wkNbW4xWawtJAqEVCHcfB4wDCI4g/sPdRwSLrwGmu/ueeNuaWRtgl7uXB8VkMPCLsLKKNJR4rS1ym2dyce92DOnTngtPUWsLSR5RfQ/iOuD+2jPMrBC4xd3HAH2AR8ysGmhC7BzEwoaPKXL8Vm7ayUsfrT2gtUXXtjmMPK8bl6q1hSQxtfsWCdHi9dv5+kPvsWtvFf275DGkb3u1tpCkonbfIhHYvLOCm6YU0yKrKa/cfiFd2uZEHUnkqKhAiIRgb1U133n8AzZsL+eZm89TcZCUpIFPkRD8ZPpC/rn8c+7/2hn065IXdRyRY6ICIVLPnpj1GVP++SljL+zJ1wZ0jjqOyDFTgRCpR0UrNvOjF+fzxVMKuGto76jjiBwXFQiRerJ6yy5unVZC17Y5PDi8PxnqoiopTgVCpB7sqqhk7JQSKqqq+eOoQnJDusOXSENSgRA5Tu7O9/80l8Xrt/Pg8P6cVNAy6kgi9UIFQuQ4/W7mUv46bx0/+EpvvnRqu6jjiNQbFQiR4/DqgvX8z4yPubp/J266oGfUcUTqlQqEyDFasn4Hdzw9h7O65PHfXztDrTOk0VGBEDkGW3ZWMGbKbFpkNWX8yIFkZ+rmPdL4qNWGyFHaW1XNt4M2Gk+PPZf2rbOjjiQSCh1BiByln9Zqo9G/a5uo44iERgVC5Cg8WfQZk//5KTdd0ENtNKTRU4EQSdDslfvbaPzgK32ijiMSOhUIkQSs2bqbW6aW0KWN2mhI+lCBEDmCXRWV3DS5WG00JO3oKiaRw6hpo7Fo/XYeveFstdGQtKIjCJHD2NdGY6jaaEj6Cb1AmFmGmX1oZtOD6UlmtsLM5gSPfnVsN8rMPgkeo8LOKXKwv9dqozH2QrXRkPTTEENMtwGLgNa15n3f3Z+tawMzawvcAxQCDpSY2UvuviXUpCKBJet38H+fnsNZnXPVRkPSVqhHEGbWGbgcmHCUm14GzHD3zUFRmAEMre98IvHUbqPxyMhCtdGQtBX2ENMDwJ1A9UHz7zOzuWb2azPLirNdJ2BVrenVwbwDmNlYMys2s+LS0tJ6Cy3pq3YbjUdGDuTEXLXRkPQVWoEwsyuAje5ectCicUBv4GygLXDXsb6Hu49390J3LywoKDj2sCKBmjYa/3212miIhHkEMRgYZmYrgaeAi81smruv85hy4DFgUJxt1wBdak13DuaJhOapWm00vj5QbTREQisQ7j7O3Tu7e3fgOmCmu48wsw4AFjvrdxUwP87mrwJfNrM2ZtYG+HIwTyQUs1du5ocvzudCtdEQ2SeKL8o9bmYFgAFzgFsAzKwQuMXdx7j7ZjP7CTA72OZed98cQVZJA7XbaPxWbTRE9jF3jzpDvSgsLPTi4uKoY0iK2VVRyTV/+CerNu/ihe8O1jelJe2YWYm7F8ZbplYbkrYOaKMxSm00RA6mVhuStn7/Rq02Gr3VRkPkYCoQkpb+vmA9v/q72miIHI4KhKSdmjYaZ6qNhshhqUBIWtmys4KbphSTk9WU8WqjIXJYKhCSNvZWVfOdJz5g/bY9aqMhkgBdxSRp476/LuK9ZZ/zq2vPYoDaaIgckY4gJC08VfQZk95byZjze3CN2miIJEQFQhq9mjYaF/TK5wdf6R11HJGUoQIhjdqarbu5dVoJndvk8LvhA2iaof/lRRKlcxDSaO2uqGLslGLK91bz1NhCcnMyo44kklJUIKRRcne+/+xHLFwXa6Nxcju10RA5WjrelkbpoTeXMX3uOu5SGw2RY6YCIY3OjIUb+OWrS7iqX0duVhsNkWOmAiGNyscbdnD7Ux9yZudc7v/6mWqjIXIcVCCk0diys4Ixk9VGQ6S+qEBIo1BZVc13n1QbDZH6pKuYpFH46V8X8e5StdEQqU86gpCU9/TsWBuNG9VGQ6ReqUBISiteuZm7X4i10RinNhoi9Sr0AmFmGWb2oZlND6YfN7MlZjbfzB41s7hfbzWzKjObEzxeCjunpJ41W3dzi9poiISmIT5RtwGLak0/DvQGzgCaA2Pq2G63u/cLHsNCzigppnYbjT9eP1BtNERCEGqBMLPOwOXAhJp57v6yB4AiQIPGclRqt9F4cHh/Tm7XKupIIo1S2EcQDwB3AtUHLwiGlkYCr9SxbbaZFZvZ+2Z2VbwVzGxssE5xaWlpvYWW5FbTRuPOy9RGQyRMoRUIM7sC2OjuJXWs8hDwD3d/u47l3dy9EPgG8ICZnXTwCu4+3t0L3b2woKCgfoJLUpuxcAO/+vsSruzXkVu+qDYaImEK8whiMDDMzFYCTwEXm9k0ADO7BygA7qhrY3dfE/xcDrwJ9A8xq6SAmjYaZ3TK5edqoyESutAKhLuPc/fO7t4duA6Y6e4jzGwMcBkw3N0PGXoCMLM2ZpYVPM8nVmwWhpVVkt/WXRXcNCXWRuORkQPVRkOkAURxXeDDQHvgn8ElrD8CMLNCM6s5md0HKDazj4A3gPvdXQUiTVVWVfOdJz5g3dZYG40Ouc2jjiSSFhqk1Ya7v0lsmAh3j/ue7l5McMmru79H7DJYkX1tNH55zZlqoyHSgI54BGFmPzOzvFrTbczsp+HGEomp3Ubj2sIuUccRSSuJDDF9xd231ky4+xbgq+FFEolRGw2RaCVSIDJqThgDmFlzIOsw64sct7VBG41Oec3VRkMkIomcg3gceN3MHgumRwOTw4sk6W53RRVjpxazZ281T40tVBsNkYgcsUC4+8+Dq4mGBLN+4u6vhhtL0lVNG40Fa7czcVSh2miIROiIBcLMegBvuvsrwXRzM+vu7ivDDifpp6aNxl1De3Nx7/ZRxxFJa4kM7P6JA3spVQXzROrVa2qjIZJUEikQTd29omYieN4svEiSjj7ZsIPbn57D6R3VRkMkWSRSIErNbN/9GMzsSmBTeJEk3WzdVcGYKcVkZ2Yw/nq10RBJFolcxXQL8LiZ/Q4wYBVwfaipJG1UVlXz3Sc+ZN3WPTw59ly10RBJIolcxbQMONfMWgbTZaGnkrRx38uLeGfpJn5xzZkM7KY2GiLJJKFeTGZ2OXAasZv4AODu94aYS9LAM7NX8di7K/nW4B78i9poiCSdRHoxPQz8K/A9YkNM1wLdQs4ljVzJp5v5rxfmcUGvfP7zq2qjIZKMEjlJ/QV3vx7Y4u4/Bs4DTgk3ljRma7fu5uapH6iNhkiSS+STuTv4ucvMOgJ7gQ7hRZLGbH8bjSomjFIbDZFklsg5iOlBu+9fAh8ADvwx1FTSKLk7dz43lwVrtzPherXREEl2iVzF9JPg6XNmNh3Idvdt4caSxuihN5fxl4/WcufQU7mkj9poiCS7o7qjnLuXA+UhZZFGrKaNxrCzOnLrF0+KOo6IJEBnByV0aqMhkppUICRUB7fRaN5MbTREUkUi34N4PZF5h9k+w8w+DM5fYGY9zGyWmS01s6fNLG7jPzMbF6yzxMwuS/T9JHnUbqPxyMiBaqMhkmLqLBBmlm1mbYF8M2tjZm2DR3eg01G8x23AolrTPwd+7e4nA1uAG+O8d1/gOmLf3h4KPGRm+tMzxdS00fjp1aerjYZICjrcEcTNQAnQO/hZ83gR+F0iL25mnYHLgQnBtAEXA88Gq0wGroqz6ZXAU+5e7u4rgKXAoETeU5LDM8WxNhqjB3dXGw2RFFXnVUzu/hvgN2b2PXf/7TG+/gPAnUDNBe8nAFvdvTKYXk38o5FOwPu1puOuZ2ZjgbEAXbt2PcaIUt9KPt3M3X+ez/kn5/NfX+0TdRwROUaJnKReb2atAMzsbjN73swGHGkjM7sC2OjuJccbsi7uPt7dC929sKCgIKy3kaNQ00ajQ142v/tGf7XREElhiXx6f+juO8zsfGAIMBH4QwLbDQaGmdlK4CliQ0u/AfLMrObIpTOwJs62a4Da4xJ1rSdJZHdFFTdPLYm10bi+kLwc3XhQJJUlUiCqgp+XA+Pd/a8kcMtRdx/n7p3dvTuxE84z3f2bwBvANcFqo4id0zjYS8B1ZpZlZj2AXkBRAlklIjVtNOav3cZvrutHr/ZqoyGS6hIpEGvM7BFiLb9fNrOsBLery13AHWa2lNg5iYkAZjbMzO4FcPcFwDPAQuAV4DvuXlXH60kS+MNbsTYa//FltdEQaSzM3Q+/glkOsUtN57n7J2bWATjD3f/eEAETVVhY6MXFxVHHSEuvL9rAmCnFXHFmRx68rp++KS2SQsysxN0L4y074pGAu+8CNgLnB7MqgU/qL56ksk827OC2p+ZwWsfW/EJtNEQalUS+SX0PsWGhccGsTGBamKEkNWzdVcFNNW00RhaqjYZII5PIuYSrgWHATgB3X8v+7zVImqppo7F26x4eGTmAjnlqoyHS2CRSICo8dqLCAcysRbiRJBX87OXFsTYaV53OwG5to44jIiFIpEA8E1zFlGdmNwGvEbTOkPT0TPEqHn13RayNxtlqoyHSWCVyR7lfmdmlwHbgVOBH7j4j9GSSlN76uJT/+vM8tdEQSQNHLBBm9nN3vwuYEWeepJHilZu5eWoxvdq14vffHKA2GiKNXCKf8EvjzPtKfQeR5LZg7TZGT5pNh9zmTP7WIHKbZ0YdSURCVucRhJndCnwb6Glmc2stagW8G3YwSR7LS8sY9WgRrbKaMm3MORS0yoo6kog0gMMNMT0B/A34b+AHtebvcPfNoaaSpLF2625GTizCHaaOOYdOupxVJG0c7n4Q24BtwPCGiyPJZFNZOSMmzmL77r08OfZcTipoGXUkEWlARzxJLelp+569jHq0iLVbdzPlW+dweqfcqCOJSAPTZShyiN0VVYyZVMyS9Tv4w4iBDOqhL8KJpCMdQcgBKiqrufXxEmZ/upkHr+vPl05tF3UkEYmIjiBkn6pq545n5vDmklJ+dvUZ/J+zOkYdSUQipAIhQOyOcHe/MJ/pc9cx7iu9GT6oa9SRRCRiKhACwM9fWcKTRZ/x7YtO4uYvnhR1HBFJAioQwkNvLuXht5Yx4tyufP+yU6OOIyJJQgUizU17/1N+8coSruzXkXuHna47wonIPioQaezFOWv44YvzuaR3O3517Vk0aaLiICL7hXaZq5llA/8AsoL3edbd7zGzt9l/R7p2QJG7XxVn+ypgXjD5mbsPCytrOpq5eAP//sxHDOrelt9/cwCZ6swqIgcJ83sQ5cDF7l5mZpnAO2b2N3e/oGYFM3sOeLGO7Xe7e78Q86Wt95d/zq3TPqBvx9ZMGFVIdqbuJS0ihwrtz0aPKQsmM4OH1yw3s9bAxcALYWWQQ81bvY0xk4vp0jaHSaMH0SpbbbtFJL5QxxXMLMPM5gAbgRnuPqvW4quA1919ex2bZ5tZsZm9b2aHDEEFrz82WKe4tLS0ntM3Pks37uD6R2eRl5PJtBvPoW2LZlFHEpEkFmqBcPeqYJioMzDIzE6vtXg48ORhNu/m7oXAN4AHzOyQi/Pdfby7F7p7YUFBQb1mb2xWbd7FiAlFZDRpwrQbz+HE3OyoI4lIkmuQM5PuvhV4AxgKYGb5wCDgr4fZZk3wcznwJtA/9KCN1MYdexg5cRa7KiqZeuMguue3iDqSiKSA0AqEmRWYWV7wvDmxW5cuDhZfA0x39z11bNvGzLKC5/nAYGBhWFkbs2279nL9xCI27ihn0rcG0adD66gjiUiKCPMIogPwRnC70tnEzkFMD5Zdx0HDS2ZWaGYTgsk+QLGZfUTsyON+d1eBOEq7KioZPamI5aU7GT+ykAFd20QdSURSSGiXubr7XOoYFnL3i+LMKwbGBM/fA84IK1s6KK+s4uapJcxZtZWHvjmA83vlRx1JRFKM7gfRCFVWVXP7U3N4+5NN/PKaMxl6eoeoI4lICtLXZxuZ6mpn3PPz+Nv89fzoir5cW9gl6kgikqJUIBoRd+e+lxfxp5LV3HZJL751fo+oI4lIClOBaER+O3MpE99ZwQ1f6M7tQ3pFHUdEUpwKRCPx2Lsr+N8ZH/P1AZ350RV91bZbRI6bCkQj8FzJan78l4Vcdlp7fv71M9S2W0TqhQpEint1wXrufG4ug08+gd9c15+matstIvVEv01S2LtLN/G9Jz7kjE65jB+ptt0iUr9UIFLUh59t4aYpxfTIb8Gk0WfTIktfaRGR+qUCkYKWrN/BDY/NpqBVFlNvHERejtp2i0j9U4FIMZ9+vpMRE2eRnRlr292utdp2i0g4VCBSyIbtexgxcRaVVdVMu/EcurTNiTqSiDRiKhApYsvOCkZMmMXmsgomjR5Er/atoo4kIo2czmymgLLySm54rIhPN+9i8uhBnNUlL+pIIpIGdASR5PbsreKmycXMX7udh74xgPNOOiHqSCKSJlQgktjeqmq++8SHvL/ic/7n2rMY0rd91JFEJI2oQCSp6mrnzmfn8tqiDdw77DSu6t8p6kgikmZUIJKQu/P//rKAP3+4hu9fdiojz+sedSQRSUMqEEnof2d8zJR/fsrYC3vy7YtOijqOiKQpFYgk88d/LOe3M5dy3dldGPeV3mrbLSKRCa1AmFm2mRWZ2UdmtsDMfhzMn2RmK8xsTvDoV8f2o8zsk+AxKqycyeTp2Z9x38uLuPzMDtx39RkqDiISqTC/B1EOXOzuZWaWCbxjZn8Lln3f3Z+ta0MzawvcAxQCDpSY2UvuviXEvJF6ed46xj0/jy+eUsCv/6UfGbqng4hELLQjCI8pCyYzg4cnuPllwAx33xwUhRnA0BBiJoW3Pi7ltqc+ZGC3Njw8YiDNmmrkT0SiF+pvIjPLMLM5wEZiv/BnBYvuM7O5ZvZrM8uKs2knYFWt6dXBvINff6yZFZtZcWlpab3nbwjFKzdz89RierVrxYRRZ9O8me7pICLJIdQC4e5V7t4P6AwMMrPTgXFAb+BsoC1w13G8/nh3L3T3woKCgnrJ3JAWrN3G6Emz6ZjbnCk3DiK3eWbUkURE9mmQsQx33wq8AQx193XB8FM58BgwKM4ma4AutaY7B/MajeWlZYx6tIhWWU2ZOuYc8lvGO5ASEYlOmFcxFZhZXvC8OXApsNjMOgTzDLgKmB9n81eBL5tZGzNrA3w5mNcorN26mxETZuEO08acQ6e85lFHEhE5RJhXMXUAJptZBrFC9Iy7TzezmWZWABgwB7gFwMwKgVvcfYy7bzaznwCzg9e61903h5i1wWwqK2fExFns2FPJk2PPpWdBy6gjiYjEZe6JXliU3AoLC724uDjqGIe1fc9eho9/n2WlZUy98RzO7t426kgikubMrMTdC+Mt0/WUDWR3RRU3TprNxxt28PCIgSoOIpL0dMOgBlBRWc2tj5dQ/OkWfju8Pxed2i7qSCIiR6QjiJBVVTt3PDOHN5eU8rOrz+CKMztGHUlEJCEqECFyd+5+YR7T567jP7/am+GDukYdSUQkYSoQIbr/lcU8WbSK73zpJMZeqLbdIpJaVCBC8tCbS3nkreWMPLcb//HlU6OOIyJy1FQgQjDt/U/5xStLuLJfR3487DS17RaRlKQCUc9enLOGH744nyF92vGra8+iidp2i0iKUoGoRzMXb+Dfn/mIQd3b8rtvDCAzQ7tXRFKXfoPVk/eXf86t0z6gb8fWTBhVSHam2naLSGpTgagHc1dvZczkYrq2zWHS6EG0ylbbbhFJfSoQx2npxh2MerSIvJxMpt54Dm1bNIs6kohIvVCBOA6rNu9ixIQimmY0YdqN53BibnbUkURE6o0KxDHauGMPIybOYvfeKqbeOIju+S2ijiQiUq9UII7Btl17uX5iEaU7ynls9Nn0PrF11JFEROqdCsRR2lleyehJRSwv3cn4kYUM6Nom6kgiIqFQgTgK5ZVV3DKthDmrtvLg8P6c3ys/6kgiIqHR/SASVFlVzW1PzuHtTzbxq2vPYujpJ0YdSUQkVDqCSEB1tfOD5+fxyoL1/OiKvlwzsHPUkUREQqcCcQTuzk//uohnS1Zz+5BefOv8HlFHEhFpEKEVCDPLNrMiM/vIzBaY2Y+D+Y+b2RIzm29mj5pZ3K8dm1mVmc0JHi+FlfNIHnx9KY++u4LRg7tz2yW9ooohItLgwjwHUQ5c7O5lQRF4x8z+BjwOjAjWeQIYA/whzva73b1fiPmO6LF3V/Dr1z7mmoGd+eHlfdW2W0TSSmgFwt0dKAsmM4OHu/vLNeuYWRGQlAP6z5as5sd/WcjQ007k/q+dobbdIpJ2Qj0HYWYZZjYH2AjMcPdZtZZlAiOBV+rYPNvMis3sfTO7qo7XHxusU1xaWlpvuV9dsJ67npvL+Sfn85vh/Wiqtt0ikoZC/c3n7lXBMFFnYJCZnV5r8UPAP9z97To27+buhcA3gAfM7JCbOrv7eHcvdPfCgoKCesn87tJNfO+JDzmzcy6PjBxIVlO17RaR9NQgfxq7+1bgDWAogJndAxQAdxxmmzXBz+XAm0D/sHN++NkWbppSTM+CFky6YRAtsvQ1ERFJX2FexVRgZnnB8+bApcBiMxsDXAYMd/fqOrZtY2ZZwfN8YDCwMKysAIvXb+eGx2ZT0CqLKTcOIjdH93QQkfVZGFAAAAaxSURBVPQW5p/IHYDJZpZBrBA94+7TzawS+BT4Z3BV0PPufq+ZFQK3uPsYoA/wiJlVB9ve7+6hFYhPP9/JyIlFZGfG2na3a6W23SIiYV7FNJc4w0LuHvc93b2Y2CWvuPt7wBlhZattw/ZY2+7Kqmqeufk8urTNaYi3FRFJemk/yN68WQantGvFbUN60at9q6jjiIgkjbQvEK2zM5l4w9lRxxARSTq6wF9EROJSgRARkbhUIEREJC4VCBERiUsFQkRE4lKBEBGRuFQgREQkLhUIERGJy2L39Ul9ZlZKrMfTscoHNtVTnPqkXEdHuY6Och2dxpirm7vHvV9CoykQx8vMioP7TyQV5To6ynV0lOvopFsuDTGJiEhcKhAiIhKXCsR+46MOUAflOjrKdXSU6+ikVS6dgxARkbh0BCEiInGpQIiISFxpVSDMbKiZLTGzpWb2gzjLs8zs6WD5LDPrniS5bjCzUjObEzzGNFCuR81so5nNr2O5mdmDQe65ZjYgSXJdZGbbau2vHzVQri5m9oaZLTSzBWZ2W5x1GnyfJZirwfeZmWWbWZGZfRTk+nGcdRr8M5lgrkg+k8F7Z5jZh2Y2Pc6y+t1f7p4WDyADWAb0BJoBHwF9D1rn28DDwfPrgKeTJNcNwO8i2GcXAgOA+XUs/yrwN8CAc4FZSZLrImB6BPurAzAgeN4K+DjOf8sG32cJ5mrwfRbsg5bB80xgFnDuQetE8ZlMJFckn8ngve8Anoj336u+91c6HUEMApa6+3J3rwCeAq48aJ0rgcnB82eBS8zMkiBXJNz9H8Dmw6xyJTDFY94H8sysQxLkioS7r3P3D4LnO4BFQKeDVmvwfZZgrgYX7IOyYDIzeBx81UyDfyYTzBUJM+sMXA5MqGOVet1f6VQgOgGrak2v5tAPyb513L0S2AackAS5AL4eDEk8a2ZdQs6UqESzR+G8YIjgb2Z2WkO/eXBo35/YX5+1RbrPDpMLIthnwXDJHGAjMMPd69xfDfiZTCQXRPOZfAC4E6iuY3m97q90KhCp7C9Ad3c/E5jB/r8QJL4PiPWXOQv4LfBCQ765mbUEngNud/ftDfneh3OEXJHsM3evcvd+QGdgkJmd3hDveyQJ5Grwz6SZXQFsdPeSsN+rRjoViDVA7SrfOZgXdx0zawrkAp9HncvdP3f38mByAjAw5EyJSmSfNjh3314zRODuLwOZZpbfEO9tZpnEfgk/7u7Px1klkn12pFxR7rPgPbcCbwBDD1oUxWfyiLki+kwOBoaZ2UpiQ9EXm9m0g9ap1/2VTgViNtDLzHqYWTNiJ3BeOmidl4BRwfNrgJkenO2JMtdBY9TDiI0hJ4OXgOuDK3POBba5+7qoQ5nZiTXjrmY2iNj/56H/UgnecyKwyN3/t47VGnyfJZIrin1mZgVmlhc8bw5cCiw+aLUG/0wmkiuKz6S7j3P3zu7endjviZnuPuKg1ep1fzU91g1TjbtXmtl3gVeJXTn0qLsvMLN7gWJ3f4nYh2iqmS0ldhL0uiTJ9W9mNgyoDHLdEHYuADN7ktjVLflmthq4h9gJO9z9YeBlYlflLAV2AaOTJNc1wK1mVgnsBq5rgEIPsb/wRgLzgvFrgP8EutbKFsU+SyRXFPusAzDZzDKIFaRn3H161J/JBHNF8pmMJ8z9pVYbIiISVzoNMYmIyFFQgRARkbhUIEREJC4VCBERiUsFQkRE4lKBEEkCFuumekh3TpEoqUCIiEhcKhAiR8HMRgT3CphjZo8ETd3KzOzXwb0DXjezgmDdfmb2ftDQ7c9m1iaYf7KZvRY0xvvAzE4KXr5l0PhtsZk93gCdhEUOSwVCJEFm1gf4V2Bw0MitCvgm0ILYN1lPA94i9s1ugCnAXUFDt3m15j8O/D5ojPcFoKbVRn/gdqAvsfuDDA79HyVyGGnTakOkHlxCrCnb7OCP++bE2kFXA08H60wDnjezXCDP3d8K5k8G/mRmrYBO7v5nAHffAxC8XpG7rw6m5wDdgXfC/2eJxKcCIZI4Aya7+7gDZpr98KD1jrV/TXmt51Xo8ykR0xCTSOJeB64xs3YAZtbWzLoR+xxdE6zzDeAdd98GbDGzC4L5I4G3gju6rTazq4LXyDKznAb9V4gkSH+hiCTI3Rea2d3A382sCbAX+A6wk9hNZe4mNuT0r8Emo4CHgwKwnP2dW0cCjwRdOPcC1zbgP0MkYermKnKczKzM3VtGnUOkvmmISURE4tIRhIiIxKUjCBERiUsFQkRE4lKBEBGRuFQgREQkLhUIERGJ6/8DmBYrWjAJjdAAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU9b3G8c83G2HHkEBCCIYdAllQRBGoWDdAJKhI9bZWra3WStVqrdqqbW1tq7a216Wt1Gu1tb2KqOybewUFCSUh7JsgkISEPRBCtt/9Y0ZviglMIJOTzDzv1yuvZuYcZp4cO+eZOefM72fOOUREJHxFeB1ARES8pSIQEQlzKgIRkTCnIhARCXMqAhGRMBfldYCGio+Pd6mpqV7HEBFpUVasWLHHOZdQ17IWVwSpqank5OR4HUNEpEUxs+31LdOhIRGRMKciEBEJcyoCEZEwpyIQEQlzKgIRkTCnIhARCXMqAhGRMBc2RfDpniM8sXA9VdU1XkcREWlWwqYIFq0p4tn3tvD155dRXFrudRwRkWYjbIrg1gt68/uvZZK38wDjn1pMzrZ9XkcSEWkWgloEZjbGzDaY2WYzu7+edSab2VozW2Nm/wxmniuHdOfN742gdUwk105dyl+XfIpmaBORcBe0IjCzSOBZYCyQBlxnZmnHrdMXeAAY4ZwbBNwVrDyfG5jUgVlTRjK6fwI/n72WO1/JpayiKthPKyLSbAXzE8EwYLNzbqtzrgJ4Bcg+bp3vAM865/YDOOeKg5jnCx1bRzP1+qHce1l/Zq8q4MpnP2JryeGmeGoRkWYnmEWQDOyodXun/77a+gH9zGyJmS01szF1PZCZ3WJmOWaWU1JS0ijhIiKM2y/sw9++NYzi0nKyn1nCwjVFjfLYIiItidcni6OAvsBo4DrgL2bW6fiVnHNTnXNDnXNDExLqHE77lI3qm8CcO0bRM6Ett/59BY8t0CWmIhJeglkEu4CUWre7+++rbScwyzlX6Zz7FNiIrxiaVHKn1ky7dTjXDevBn97fwjdf+IQ9h481dQwREU8EswiWA33NrKeZxQDXArOOW2cGvk8DmFk8vkNFW4OYqV6x0ZH8+qp0Hp+UQc72/Vzx9GJWfrbfiygiIk0qaEXgnKsCpgALgXXANOfcGjN7xMwm+FdbCOw1s7XAe8C9zrm9wcoUiMlDU3jjtvOJjDAmP/cxLy/drktMRSSkWUvbyQ0dOtQ1xVSVB8oquOvVXN7fUMJVZyXz6MR0WsdEBv15RUSCwcxWOOeG1rXM65PFzVanNjG8cMM53HVxX95cuYur/vQR2/ce8TqWiEijUxGcQESEcdfF/XjhxnMoOHCUK55ezDvrdnsdS0SkUakIAnBh/y7M+f5IUuLacPNLOTy5aAPVNS3rkJqISH1UBAFKiWvD67edzzVnd+epdzdz04vL2X+kwutYIiKnTUXQALHRkTw+KYNfX5XO0i17Gf/0YvJ3HvQ6lojIaVERNJCZcd2wHrz23eE457j6zx/xyiefeR1LROSUqQhOUWZKJ+bcMYpze8Zx/xv53Dd9FeWV1V7HEhFpMBXBaYhrG8OLNw1jyoV9eDVnB9f8+WN27CvzOpaISIOoCE5TZITxw8v68/w3h7Jt7xGueGYxH2xsnBFSRUSagoqgkVyc1pXZU0aS2CGWG//6CU+9s4kaXWIqIi2AiqARpca35c3vjWBiVjJPvrWRb/8th4NllV7HEhE5IRVBI2sdE8mTkzN5JHsQH24q4YpnFrOmQJeYikjzpSIIAjPjm8NTeeWW4VRU1XDVHz/i9RU7vY4lIlInFUEQnX3mGcy5YyRn9TiDe17L48EZ+Ryr0iWmItK8qAiCLL5dK/5+8zBuvaAXLy/9jMnPLaXgwFGvY4mIfEFF0ASiIiN4YOxA/vT1s9hSfJjxTy9myeY9XscSEQFUBE1qbHoSM6eMoHPbGK7/n2X88f3Nmv1MRDynImhivRPaMeP2EYxLT+LxBRu49e8rOFSuS0xFxDsqAg+0bRXF09cN4eHxaby7vpjsZ5awoajU61giEqZUBB4xM741sif//M55HD5WxcRnlzAzd5fXsUQkDKkIPDasZxxzvz+SwckduPOVXH42aw0VVTVexxKRMKIiaAa6dIjln985j5tH9uTFj7Zx3V+WsvtQudexRCRMqAiaiejICB4an8Yz/zWEdYWHuPypxSzdutfrWCISBlQEzcz4jG7MvH0EHVpH8fXnl/GXf23VJaYiElQqgmaob9f2zLx9BJcM7Mqj89Zx+z//zeFjVV7HEpEQpSJoptrHRvOnb5zFA2MHsGB1EdnPLGZzsS4xFZHGpyJoxsyMWy/ozcvfPpeDRyvJfmYJc1cVeh1LREKMiqAFOL93PHO+P4r+ie25/Z//5tG5a6mq1iWmItI4VAQtRGLHWF65ZTg3DD+Tv3z4KV9/fhnFpbrEVEROn4qgBYmJiuDn2YP5/dcyydt5gPFPLSZn2z6vY4lIC6ciaIGuHNKdN783gtYxkVw7dSl/XfKpLjEVkVOmImihBiZ1YNaUkYzu34Wfz17Lna/kUlahS0xFpOFUBC1Yx9bRTL3+bO69rD9zVhVw5bMfsbXksNexRKSFURG0cBERxu0X9uGlbw2juLSc7GeWsGB1kdexRKQFURGEiFF9E5hzxyh6JrTluy+v4Dfz1+sSUxEJiIoghCR3as1r3x3Of53bgz9/sIVvvvAJew4f8zqWiDRzKoIQ0yoqkl9dmc4TkzJYsX0/Vzy9mJWf7fc6log0YyqCEHXN0BRev+18oiKNyc99zMtLt+sSUxGpk4oghA1O7sjsKSMZ0SeeB2es5p7X8jhaUe11LBFpZoJaBGY2xsw2mNlmM7u/juU3mlmJmeX6f74dzDzhqFObGF644Rzuurgvb67cxZV/XML2vUe8jiUizUjQisDMIoFngbFAGnCdmaXVseqrzrks/8/zwcoTziIijLsu7scLN55D4cFyxj+9mHfW7fY6log0E8H8RDAM2Oyc2+qcqwBeAbKD+HxyEhf278Kc74+kR1wbbn4phycXbaC6RucNRMJdMIsgGdhR6/ZO/33Hu9rMVpnZdDNLqeuBzOwWM8sxs5ySkpJgZA0bKXFteP2287nm7O489e5mbnpxOfuPVHgdS0Q85PXJ4tlAqnMuA3gLeKmulZxzU51zQ51zQxMSEpo0YCiKjY7k8UkZ/PqqdJZu2cv4pxezaucBr2OJiEeCWQS7gNrv8Lv77/uCc26vc+7zbzw9D5wdxDxSi5lx3bAevPbd4TjnmPSnj3nlk8+8jiUiHghmESwH+ppZTzOLAa4FZtVewcySat2cAKwLYh6pQ2ZKJ+bcMYpze8Vx/xv53Dd9FeWVusRUJJwErQicc1XAFGAhvh38NOfcGjN7xMwm+Fe7w8zWmFkecAdwY7DySP3i2sbw4k3DmHJhH17N2cE1f/6YHfvKvI4lIk3EWtq3TYcOHepycnK8jhGy3l67mx9MyyUywvjD17IY3b+L15FEpBGY2Qrn3NC6lnl9sliamYvTujJ7ykgSO8TyrReXs2zrXq8jiUiQqQjkS1Lj2zL9tvNJiWvDD6fncfiYZj4TCWUqAqlTu1ZR/PaaTHbuP8qjc3UOXySUqQikXuekxnHLqF787yef8d6GYq/jiEiQqAjkhH5wST/6dW3HfdNXcaBM30AWCUUqAjmh2OhInpycxb4jFTw8c43XcUQkCFQEclKDkztyx0V9mZVXwNxVhV7HEZFGpiKQgHxvdG8yu3fkwRn5FJeWex1HRBqRikACEhUZwe8mZ1FWUc0Dr+dr2kuREKIikID16dKOH40ZwDvri3ktZ6fXcUSkkagIpEFuOj+V83rF8cictRqPSCREqAikQSIijCcmZQJw7/Q8ajTDmUiLpyKQBkuJa8ND4weydOs+Xvxom9dxROQ0qQjklEwemsJXB3ThsQXr2Vx82Os4InIaVARySsyM31yVTuuYSO55LY+q6hqvI4nIKVIRyCnr0iGWX04cTN6OA/zp/S1exxGRU6QikNMyPqMbV2R247/f2cTqXQe9jiMip0BFIKftF9mDiGsbwz3T8jTfsUgLpCKQ09apTQyPXZ3Bht2l/P6tjV7HEZEGUhFIo7hwQBeuG5bC1A+3snzbPq/jiEgDqAik0fzk8jS6n9Gae6blcUTTW4q0GCoCaTTtWkXx20mZ7Nhfxq/maXpLkZZCRSCN6txenbl5RE/+sewzPthY4nUcEQmAikAa3Q8v6+8bqXR6HgfLKr2OIyIncdIiMLM7zayD+fyPmf3bzC5tinDSMvmmt8xkz+EKfjprtddxROQkAvlE8C3n3CHgUuAM4HrgN0FNJS1eRvdOTLmwDzNyC5ifr+ktRZqzQIrA/P87Dvi7c25NrftE6jXlq31IT+7Ij9/Mp6T0mNdxRKQegRTBCjNbhK8IFppZe0AjjMlJRUdG8OTkTI5UVPPAG5reUqS5CqQIbgbuB85xzpUB0cBNQU0lIaNv1/bce2l/3l63m+krNL2lSHMUSBEMBzY45w6Y2TeABwGNLiYB+9bIngxLjeOR2WvZdeCo13FE5DiBFMGfgDIzywTuAbYAfwtqKgkpkRHGb6/JpNo57n1N01uKNDeBFEGV8x3czQaecc49C7QPbiwJNT06t+HBy9P4aMte/vbxNq/jiEgtgRRBqZk9gO+y0blmFoHvPIFIg1w3LIXR/RP4zYL1bC3R9JYizUUgRfA14Bi+7xMUAd2BJ4KaSkKSmfHY1Rm0iork7mma3lKkuThpEfh3/v8AOprZeKDcOadzBHJKunaI5ZHsQeTuOMBz/9rqdRwRIbAhJiYDnwDXAJOBZWY2KdjBJHRNyOzG5elJ/OHtjawtOOR1HJGwF8ihoZ/g+w7BDc65bwLDgIeCG0tCmZnxi4mD6dg6hrun5XKsStNbingpkCKIcM4V17q9N8B/J1KvuLYxPHZ1OuuLSvnD25u8jiMS1gLZoS8ws4VmdqOZ3QjMBeYFN5aEg4sGdmXy0O4898EWVmzX9JYiXgnkZPG9wFQgw/8z1Tl3XyAPbmZjzGyDmW02s/tPsN7VZubMbGigwSU0PDQ+jaSOvuktyyo0vaWIFwI6xOOce905d7f/581A/o2ZRQLPAmOBNOA6M0urY732wJ3AssBjS6hoHxvNE9dksG1vGb+Zv97rOCJhqd4iMLNSMztUx0+pmQVyqccwYLNzbqtzrgJ4Bd+3k4/3C+AxoPyU/gJp8c7vHc9NI1L528fbWbxpj9dxRMJOvUXgnGvvnOtQx09751yHAB47GdhR6/ZO/31fMLOzgBTn3NwTPZCZ3WJmOWaWU1KieXBD0X1jBtAroS33Ts/j4FFNbynSlDy7+sc/VMWT+AayOyHn3FTn3FDn3NCEhITgh5Mm55veMovi0mP8fPYar+OIhJVgFsEuIKXW7e7++z7XHhgMvG9m24DzgFk6YRy+slI6cfvo3rzx710sXFPkdRyRsBHMIlgO9DWznmYWA1wLzPp8oXPuoHMu3jmX6pxLBZYCE5xzOUHMJM3clK/2ZVC3Dvz4jXz2HNb0liJNIWhF4JyrAqYAC4F1wDTn3Boze8TMJgTreaVli4mK4MnJWZSWV/GTNzW9pUhTiKpvgZmVAnW9Cg1wgZwwds7N47gvnznnHq5n3dEnezwJD/0T23PPpf349fz1vLlyF1ed1d3rSCIhLZhXDYmcsm+P6sU5qWfw01lrKND0liJBFfChITPrYmY9Pv8JZiiRL6a3rHHc9/oqHSISCaJAhqGeYGabgE+BD4BtwPwg5xLhzM5t+fG4gXy4aQ8vL93udRyRkBXIJ4Jf4Lu0c6NzridwEb4rfESC7uvn9uAr/RL41bz1bNtzxOs4IiEpkCKodM7tBSLMLMI59x6ga/2lSZgZj1+dQXSkcc9reVTX6BCRSGMLpAgOmFk74F/AP8zsvwG9NZMmk9gxlkeyB7Ni+36manpLkUYXSBFkA2XAD4AFwBbgimCGEjledlY3xg5O5PdvbWR9kaa3FGlMgRTBrUCSc67KOfeSc+4p/6EikSZjZvxy4mA6tI7iB6/mUVFV43UkkZARSBG0BxaZ2YdmNsXMugY7lEhdOrdrxa+vymBd4SGeekfTW4o0lkBmKPu5c24QcDuQBHxgZm8HPZlIHS5J68qks7vzx/c3s/Kz/V7HEQkJDRlrqBgowjd5fZfgxBE5uYev+P/pLY9WVHsdR6TFC+QLZd8zs/eBd4DOwHeccxnBDiZSnw6x0TwxKYOte47w2AJNbylyuuoddK6WFOAu51xusMOIBOr8PvHceH4qL360jUvSujKiT7zXkURarEDOETygEpDm6L4xA+gV35Z7X8vjULmmtxQ5VZ5NVSlyulrHRPLbyZkUHSrnkdlrvY4j0mKpCKRFO6vHGdw2ujfTV+zkrbW7vY4j0iKpCKTFu/OifgxM6sADb6xir6a3FGkwFYG0eL7pLTM5eLSSB2es1twFIg2kIpCQMDCpAz+4pB/zVxcxM7fA6zgiLYqKQELGrV/pzVk9OvHwzNUUHSz3Oo5Ii6EikJARGWH8bnIWldWOH2l6S5GAqQgkpPSMb8sD4wbwr40l/GPZZ17HEWkRVAQScr5x7pmM7BPPr+atY/tezaEkcjIqAgk5ERHG45MyiIww7pmm6S1FTkZFICGpW6fW/OyKQeRs38/zH2p6S5ETURFIyLrqrGQuTevK7xZtZENRqddxRJotFYGELDPjV1el0z42irun5Wp6S5F6qAgkpMW3a8WjV6azpuAQz7yr6S1F6qIikJA3ZnAiVw1J5tn3t5C344DXcUSaHRWBhIWfThhEl/atuHtaLuWVmt5SpDYVgYSFjq2jeXxSBltKjvD4gg1exxFpVlQEEjZG9U3g+vPO5IUln/Lxlr1exxFpNlQEElYeGDeA1M5t+OFreZRqeksRQEUgYaZNTBS/m5xJ4cGj/HLOOq/jiDQLKgIJO2efGcctX+nNqzk7eHe9prcUURFIWPrBJX0ZkNie+17PZ/+RCq/jiHhKRSBhqVVUJL+bnMmBsgoenLna6zginlIRSNga1K0jd17Ul7mrCpmVp+ktJXypCCSsffeC3mSldOKhGavZfUjTW0p4UhFIWIuKjOB3kzM5VlXNfZreUsJUUIvAzMaY2QYz22xm99ex/Ltmlm9muWa22MzSgplHpC69E9px35gBvL+hhFeW7/A6jkiTC1oRmFkk8CwwFkgDrqtjR/9P51y6cy4LeBx4Mlh5RE7khuGpDO/VmV/OWcuOfWVexxFpUsH8RDAM2Oyc2+qcqwBeAbJrr+CcO1TrZltAn8vFExERxhPXZGBm3PNaHjWa3lLCSDCLIBmo/Tl7p/++/2Bmt5vZFnyfCO6o64HM7BYzyzGznJKSkqCEFel+RhseviKNTz7dxwtLPvU6jkiT8fxksXPuWedcb+A+4MF61pnqnBvqnBuakJDQtAElrFxzdncuHtiFxxduYNNuTW8p4SGYRbALSKl1u7v/vvq8AkwMYh6Rk/p8esu2MZHcPS2PympNbymhL5hFsBzoa2Y9zSwGuBaYVXsFM+tb6+blgOYSFM91aR/Lo1emk7/rIM++t9nrOCJBF7QicM5VAVOAhcA6YJpzbo2ZPWJmE/yrTTGzNWaWC9wN3BCsPCINMS49ieysbjzz7mbydx70Oo5IUFlL+wLN0KFDXU5OjtcxJAwcLKvk0j98QIfYaGZ/fySx0ZFeRxI5ZWa2wjk3tK5lnp8sFmmuOraJ5vFJmWwqPszvFml6SwldKgKRE7igXwJfP7cHzy/+lGVbNb2lhCYVgchJ/HjcQFLOaMMPp+dx+FiV13FEGp2KQOQk2rbyTW+5c/9RHp2r6S0l9KgIRAJwTmoct4zqxf9+8hnvbSj2Oo5Io1IRiAToB5f0o1/Xdtw3fRUHyjS9pYQOFYFIgGKjI3lychb7jlTw0Mw1XscRaTQqApEGGJzckTsu6svsvALmrNL0lhIaVAQiDfS90b3J7N6RB2espljTW0oIUBGINJBvesssjlZUc/8b+ZreUlo8FYHIKejTpR0/GjOAd9cXMy1H01tKy6YiEDlFN52fynm94nhktqa3lJZNRSByiiIijCcmZWJm/FDTW0oLpiIQOQ0pcW14aPxAln26j79+tM3rOCKnJMrrACIt3eShKSxcs5vHFqyn8MBRJg5JZlC3DpiZ19FEAqL5CEQaQUnpMX7yZj7vbSimstrRO6EtE7OSyc5KpkfnNl7HkxBQU+OocY6oyFM7kHOi+QhUBCKNaP+RCuatLmTmygI+2bYPgLN6dGLikGQuT0+ic7tWHieUlqS6xrF82z7m5xcyf3URD1+RxviMbqf0WCoCEQ/s3F/GrLwCZq4sYMPuUqIijFF945k4JJlL0rrSJkZHZuXLqqpr+OTTfcxbXciC1bvZc/gYraIiuLB/F24e1ZNzUuNO6XFVBCIeW1d4iBm5u5iVW0DhwXLaxERyaVpXsockM6pP/Cl/3JfQUFVdw9Kt+5ibX8iiNUXsPVJB6+hIvjqgC2PTE7mwfxfatjq9Nw4qApFmoqbG8cm2fczM3cXcVYUcKq+ic9sYxmckkT0kmSEpnXSSOUxUVtfw0Za9zFtVyKK1Rewvq6RNTCQXDezKuMGJjO7fhdYxjTdPtopApBk6VlXNBxtKmJlbwNvrdnOsqoYzO7chO7Mb2UOS6Z3QzuuI0sgqqmpYsnkP8/ILWbR2NwePVtKuVRQXD+zC2PQkLuiXQGx04+38a1MRiDRzpeWVLFhdxMzcAj7asocaB+nJHcnO6sYVmd3o2iHW64hyisorq1m8aQ/zVhfy1trdlJZX0T42ikvSujJucBIj+8YHbedfm4pApAUpPlTuO8mcW0D+roNEGAzv3ZnsrGTGDE6kQ2y01xHlJMorq/lgYwnz8wt5e10xh49V0bF1NJemdWVcehLn9+lMq6jg7/xrUxGItFCbiw8zK3cXM3IL+GxfGTFREVw8sAvZWcmM7p/Q5DsTqd/Rimre31DMvNVFvLtuN0cqqunUJprL0hIZl5HE8F6diYny7qIAFYFIC+ecY+WOA8xcuYs5qwrZe6SCjq2jGZeeSHZWMsNS44iI0EnmplZWUcW764uZn1/Eu+uLOVpZTVzbGC4blMi49ETO69WZ6GZyRZiKQCSEVFbXsHjzHmau3MWitbspq6imW8dYrsjqxsSsZAYmdfA6Ykg7fMy385+3qpD3NxZTXllDfLtWjBnsO+Y/rGdcs7wcWEUgEqLKKqp4a+1uZqzcxb827aG6xtG/a3uyh3RjQmY3up+h4S0aw6HySt5dV8zc/EI+2FhCRVUNXdq3YuzgRMamJ3FOahyRzfwTmYpAJAzsPXyMefmFzMgtYMX2/QAMS40je0g3Lk9PolObGI8TtiwHj1by9trdzMsv5MNNe6ioriGxQyxj0xMZl57E2T3OaFGH41QEImFmx74yZvpPMm8uPkx0pHFBvy5kZ3Xj4oFdG/WLSqHkQFkFi/w7/yWb91BZ7Uju1PqLd/5DUjq1qJ1/bSoCkTDlnGNNwSFm5u5iVl4Buw8do21MJJcNTmRiVjLn9+7cLI9nN6V9RypYtKaIeauL+GjzHqpqHN3PaM249CTGpSeR2b1jSHzbW0UgIlTXOJZt3cuM3F3Mzy+i9FgV8e1acUVmEhOzkskIkR1eIPYcPsbCNUXMzy/i4617qa5x9Ihrw7j0JC5PT2JwcujNJ6EiEJH/UF5ZzXvri5mRu4v31pdQUV1Dr/i2TPBfeZQa39briI2uuLSchauLmJdfxLJP91LjoGd8W8b5j/mnJYXezr82FYGI1OtgWSXzVxcyI3cXyz7dh3OQmdKJiVndGJ/RjYT2LXcOhd2Hylmwuoi5+YUs3+b723ontOXy9CTGpicxILF9SO/8a1MRiEhACg8eZXZeATNWFrC28BCREcaIPvFMzOrGpYMSaXeaQyE3hYIDR1mwuoh5+YWs+Gw/zkG/ru2+OObfr2t7ryN6QkUgIg22aXcpM3J3MTO3gJ37jxIbHcElaYlkZ3bjK/0SPB0u4Xg795d98c5/5WcHABiQ2N7/zj+RPl3Cc+dfm4pARE6Zc44V2/czwz+Hwv6ySs5oE8249CQmDkn27Hr6HfvKmJdfyLzVReTt8O38B3XrwLj0JMYOTqSXhvH+DyoCEWkUFVU1fLiphBm5Bby1tojyyhqSO7UmO6sbE4ckB/2wy7Y9R5i3upD5+UXk7zoIQEb3jowdnMS49ETO7Bx6J7kbi4pARBrd4WNVLFpTxIzcApZs9g1vMTCpAxOzujEhqxtJHVs3yvNsLTnse+efX8TawkMAZKV0Ylx6ImMHJ5ESp2E0AqEiEJGgKik9xpxVBczILSBvxwHM4NyecUzMSmZsehIdWzdsDoXNxaXMXVXE/NWFrC8qBeDsM8/44hu+yZ0ap2TCiWdFYGZjgP8GIoHnnXO/OW753cC3gSqgBPiWc277iR5TRSDSvG3bc4SZuQXMzN3F1j1HiImM4MIBCUzMSubCAV3qnI3LOcfG3YeZm1/I/PxCNhUfxgzOOTOOsemJjBmc2GifMMKVJ0VgZpHARuASYCewHLjOObe21joXAsucc2Vmdhsw2jn3tRM9ropApGVwzpG/6yAzVhYwe1UBJaXHaB8bxVj/8Bbn9urMhqJS5q8uZG5+IVtLjmDmGyjv8owkLhuUqCk6G5FXRTAc+Jlz7jL/7QcAnHO/rmf9IcAzzrkRJ3pcFYFIy1NVXcPHW/cyY2UBC9cUcfhYFa2jIzlaWU2EwXm9OjMuPYlLB3WlS3vt/IPhREUQzG+HJAM7at3eCZx7gvVvBubXtcDMbgFuAejRo0dj5RORJhIVGcGovgmM6pvAo5WDeXvdbhZv2kNG905cNqgrndu13G8vh4Jm8TVBM/sGMBS4oK7lzrmpwFTwfSJowmgi0shioyMZn+EbvkKah2AWwS4gpdbt7v77/oOZXQz8BLjAOXcsiHlERKQOwfyO+HKgr5n1NLMY4FpgVu0V/OcFngMmOOeKg5hFRETqEbQicM5VAVOAhcA6YJpzbo2ZPWJmE/yrPQG0A14zs1wzm1XPw4mISJAE9RyBc6gluQMAAAYsSURBVG4eMO+4+x6u9fvFwXx+ERE5ueYzfKCIiHhCRSAiEuZUBCIiYU5FICIS5lrc6KNmVgKccGC6E4gH9jRinMaiXA2jXA3XXLMpV8OcTq4znXMJdS1ocUVwOswsp76xNrykXA2jXA3XXLMpV8MEK5cODYmIhDkVgYhImAu3IpjqdYB6KFfDKFfDNddsytUwQckVVucIRETky8LtE4GIiBxHRSAiEuZCsgjMbIyZbTCzzWZ2fx3LW5nZq/7ly8wstZnkutHMSvwjseaa2bebKNcLZlZsZqvrWW5m9pQ/9yozO6uZ5BptZgdrba+H61qvkTOlmNl7ZrbWzNaY2Z11rNPk2yvAXF5sr1gz+8TM8vy5fl7HOk3+egwwlyevR/9zR5rZSjObU8eyxt9ezrmQ+gEigS1ALyAGyAPSjlvne8Cf/b9fC7zaTHLdiG/e5qbeZl8BzgJW17N8HL5pRA04D1jWTHKNBuY08bZKAs7y/94e2FjHf8cm314B5vJiexnQzv97NLAMOO+4dbx4PQaSy5PXo/+57wb+Wdd/r2Bsr1D8RDAM2Oyc2+qcqwBeAbKPWycbeMn/+3TgIjOzZpDLE865fwH7TrBKNvA357MU6GRmSc0gV5NzzhU65/7t/70U31wbycet1uTbK8BcTc6/DQ77b0b7f46/QqXJX48B5vKEmXUHLgeer2eVRt9eoVgEycCOWrd38uUXxBfrON8EOgeBzs0gF8DV/sMJ080spY7lXgg0uxeG+z/ezzezQU35xP6P5EPwvZuszdPtdYJc4MH28h/myAWKgbecc/VuryZ8PQaSC7x5Pf4B+BFQU8/yRt9eoVgELdlsINU5lwG8xf+3vtTt3/jGT8kEngZmNNUTm1k74HXgLufcoaZ63pM5SS5Ptpdzrto5l4Vv3vJhZja4KZ73ZALI1eSvRzMbDxQ751YE+7lqC8Ui2AXUbu7u/vvqXMfMooCOwF6vcznn9jrnjvlvPg+cHeRMgQpkmzY559yhzz/eO99seNFmFh/s5zWzaHw72384596oYxVPttfJcnm1vWo9/wHgPWDMcYu8eD2eNJdHr8cRwAQz24bv8PFXzezl49Zp9O0VikWwHOhrZj3NLAbfyZTj50KeBdzg/30S8K7zn3nxMtdxx5En4DvO2xzMAr7pvxrmPOCgc67Q61Bmlvj5sVEzG4bv/89B3YH4n+9/gHXOuSfrWa3Jt1cguTzaXglm1sn/e2vgEmD9cas1+esxkFxevB6dcw8457o751Lx7SPedc5947jVGn17BXXOYi8456rMbAqwEN+VOi8459aY2SNAjnNuFr4XzN/NbDO+k5HXNpNcd5jZBKDKn+vGYOcCMLP/xXdFSbyZ7QR+iu/kGc65P+Obd3ocsBkoA25qJrkmAbeZWRVwFLi2CQp9BHA9kO8/vgzwY6BHrVxebK9AcnmxvZKAl8wsEl/xTHPOzfH69RhgLk9ej3UJ9vbSEBMiImEuFA8NiYhIA6gIRETCnIpARCTMqQhERMKcikBEJMypCESakPlGAP3SiJIiXlIRiIiEORWBSB3M7Bv+8epzzew5/wBlh83s9/7x698xswT/ullmttQ/ONmbZnaG//4+Zva2f5C3f5tZb//Dt/MPYrbezP7RBCPfipyQikDkOGY2EPgaMMI/KFk18HWgLb5vdw4CPsD3TWeAvwH3+Qcny691/z+AZ/2DvJ0PfD7MxBDgLiAN3/wUI4L+R4mcQMgNMSHSCC7CN8DYcv+b9db4hiquAV71r/My8IaZdQQ6Oec+8N//EvCambUHkp1zbwI458oB/I/3iXNup/92LpAKLA7+nyVSNxWByJcZ8JJz7oH/uNPsoePWO9XxWY7V+r0avQ7FYzo0JPJl7wCTzKwLgJnFmdmZ+F4vk/zr/Bew2Dl3ENhvZqP8918PfOCfJWynmU30P0YrM2vTpH+FSID0TkTkOM65tWb2ILDIzCKASuB24Ai+CUwexHeo6Gv+f3ID8Gf/jn4r/z/a6PXAc/6RIyuBa5rwzxAJmEYfFQmQmR12zrXzOodIY9OhIRGRMKdPBCIiYU6fCEREwpyKQEQkzKkIRETCnIpARCTMqQhERMLc/wFJOBsFRpppGAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}