FaceDedection.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "FaceDedection.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "SdMzw2uoKraB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# import the necessary packages\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from tensorflow.keras.applications import MobileNetV2\n",
        "from tensorflow.keras.layers import AveragePooling2D\n",
        "from tensorflow.keras.layers import Dropout\n",
        "from tensorflow.keras.layers import Flatten\n",
        "from tensorflow.keras.layers import Dense\n",
        "from tensorflow.keras.layers import Input\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from tensorflow.keras.applications.mobilenet_v2 import preprocess_input\n",
        "from tensorflow.keras.preprocessing.image import img_to_array\n",
        "from tensorflow.keras.preprocessing.image import load_img\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "from sklearn.preprocessing import LabelBinarizer\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import classification_report\n",
        "from imutils import paths\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import argparse\n",
        "import os\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e-BPJjxzLZaQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5a377cfa-ed68-4700-ad5f-bb8ebe58cb07"
      },
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import cv2\n",
        "from google.colab import drive\n",
        "\n",
        "# Accessing My Google Drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 3,
      "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": "NTJqKzS0LZgC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# defining global variable path\n",
        "# Location of my dataset on My Google Drive\n",
        "path = \"drive/My Drive/dataset\"\n",
        "import tensorflow as tf\n",
        "\n",
        "def loadImages(path):\n",
        "  image_files = list(paths.list_images(path))\n",
        "  return image_files"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5vh4WhmQLZlr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "imagePaths=loadImages(path)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m6S_CJH-LZw1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# In[ ]:\n",
        "\n",
        "# initialize the initial learning rate, number of epochs to train for,\n",
        "# and batch size\n",
        "INIT_LR = 1e-4\n",
        "EPOCHS = 20\n",
        "BS = 32\n",
        "\n",
        "data = []\n",
        "labels = []"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8OpIQ2xJLZ4J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "# loop over the image paths\n",
        "for imagePath in imagePaths:\n",
        "\t# extract the class label from the filename\n",
        "\tlabel = imagePath.split(os.path.sep)[-2]\n",
        "\n",
        "\t# load the input image (224x224) and preprocess it\n",
        "\timage = load_img(imagePath, target_size=(224, 224))\n",
        "\timage = img_to_array(image)\n",
        "\timage = preprocess_input(image)\n",
        "\n",
        "\t# update the data and labels lists, respectively\n",
        "\tdata.append(image)\n",
        "\tlabels.append(label)\n",
        "\n",
        "# convert the data and labels to NumPy arrays\n",
        "data = np.array(data, dtype=\"float32\")\n",
        "labels = np.array(labels)\n",
        "\n",
        "# perform one-hot encoding on the labels\n",
        "lb = LabelBinarizer()\n",
        "labels = lb.fit_transform(labels)\n",
        "labels = to_categorical(labels)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5okEzsAgLZ9Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# In[ ]:\n",
        "# partition the data into training and testing splits using 75% of\n",
        "# the data for training and the remaining 25% for testing\n",
        "(trainX, testX, trainY, testY) = train_test_split(data, labels,\n",
        "\ttest_size=0.20, stratify=labels, random_state=42)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0LrQcPFgLZ3J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# construct the training image generator for data augmentation\n",
        "aug = ImageDataGenerator(\n",
        "\trotation_range=20,\n",
        "\tzoom_range=0.15,\n",
        "\twidth_shift_range=0.2,\n",
        "\theight_shift_range=0.2,\n",
        "\tshear_range=0.15,\n",
        "\thorizontal_flip=True,\n",
        "\tfill_mode=\"nearest\")"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9SEQYC9PLZqn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        },
        "outputId": "c7bc94dc-fae3-4370-eab8-c6a726bb5422"
      },
      "source": [
        "\n",
        "# load the MobileNetV2 network, ensuring the head FC layer sets are\n",
        "# left off\n",
        "baseModel = MobileNetV2(weights=\"imagenet\", include_top=False,\n",
        "\tinput_tensor=Input(shape=(224, 224, 3)))"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:`input_shape` is undefined or non-square, or `rows` is not in [96, 128, 160, 192, 224]. Weights for input shape (224, 224) will be loaded as the default.\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet_v2/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224_no_top.h5\n",
            "9412608/9406464 [==============================] - 0s 0us/step\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k3j_PHBkLZkg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# construct the head of the model that will be placed on top of the\n",
        "# the base model\n",
        "headModel = baseModel.output\n",
        "headModel = AveragePooling2D(pool_size=(7, 7))(headModel)\n",
        "headModel = Flatten(name=\"flatten\")(headModel)\n",
        "headModel = Dense(128, activation=\"relu\")(headModel)\n",
        "headModel = Dropout(0.5)(headModel)\n",
        "headModel = Dense(2, activation=\"softmax\")(headModel)"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uXw_4zKbLZe-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# place the head FC model on top of the base model (this will become\n",
        "# the actual model we will train)\n",
        "model = Model(inputs=baseModel.input, outputs=headModel)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "urWwPs7BLZZS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# loop over all layers in the base model and freeze them so they will\n",
        "# *not* be updated during the first training process\n",
        "for layer in baseModel.layers:\n",
        "\tlayer.trainable = False"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cK2NTRsFLZS7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e2e17d9d-55aa-470d-c36e-4dcc2a7b7459"
      },
      "source": [
        "# compile our model\n",
        "print(\"[INFO] compiling model...\")\n",
        "opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)\n",
        "model.compile(loss=\"binary_crossentropy\", optimizer=opt,metrics=[\"accuracy\"])"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[INFO] compiling model...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BfEs5y7gqtDr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 714
        },
        "outputId": "da01223a-63c1-4822-dd70-e8e46d50fa92"
      },
      "source": [
        "# train the head of the network\n",
        "print(\"[INFO] training head...\")\n",
        "H = model.fit(\n",
        "\taug.flow(trainX, trainY, batch_size=BS),\n",
        "\tsteps_per_epoch=len(trainX) // BS,\n",
        "\tvalidation_data=(testX, testY),\n",
        "\tvalidation_steps=len(testX) // BS,\n",
        "\tepochs=EPOCHS)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[INFO] training head...\n",
            "Epoch 1/20\n",
            "95/95 [==============================] - 39s 409ms/step - loss: 0.3372 - accuracy: 0.8476 - val_loss: 0.0980 - val_accuracy: 0.9740\n",
            "Epoch 2/20\n",
            "95/95 [==============================] - 38s 397ms/step - loss: 0.1141 - accuracy: 0.9608 - val_loss: 0.0679 - val_accuracy: 0.9792\n",
            "Epoch 3/20\n",
            "95/95 [==============================] - 38s 396ms/step - loss: 0.0777 - accuracy: 0.9727 - val_loss: 0.0518 - val_accuracy: 0.9818\n",
            "Epoch 4/20\n",
            "95/95 [==============================] - 37s 392ms/step - loss: 0.0661 - accuracy: 0.9799 - val_loss: 0.0587 - val_accuracy: 0.9805\n",
            "Epoch 5/20\n",
            "95/95 [==============================] - 37s 389ms/step - loss: 0.0599 - accuracy: 0.9776 - val_loss: 0.0519 - val_accuracy: 0.9818\n",
            "Epoch 6/20\n",
            "95/95 [==============================] - 38s 400ms/step - loss: 0.0481 - accuracy: 0.9842 - val_loss: 0.0334 - val_accuracy: 0.9883\n",
            "Epoch 7/20\n",
            "95/95 [==============================] - 38s 401ms/step - loss: 0.0459 - accuracy: 0.9852 - val_loss: 0.0428 - val_accuracy: 0.9831\n",
            "Epoch 8/20\n",
            "95/95 [==============================] - 38s 399ms/step - loss: 0.0456 - accuracy: 0.9839 - val_loss: 0.0349 - val_accuracy: 0.9883\n",
            "Epoch 9/20\n",
            "95/95 [==============================] - 38s 397ms/step - loss: 0.0413 - accuracy: 0.9875 - val_loss: 0.0353 - val_accuracy: 0.9870\n",
            "Epoch 10/20\n",
            "95/95 [==============================] - 38s 401ms/step - loss: 0.0352 - accuracy: 0.9898 - val_loss: 0.0278 - val_accuracy: 0.9922\n",
            "Epoch 11/20\n",
            "95/95 [==============================] - 38s 397ms/step - loss: 0.0362 - accuracy: 0.9891 - val_loss: 0.0310 - val_accuracy: 0.9896\n",
            "Epoch 12/20\n",
            "95/95 [==============================] - 38s 397ms/step - loss: 0.0304 - accuracy: 0.9908 - val_loss: 0.0335 - val_accuracy: 0.9883\n",
            "Epoch 13/20\n",
            "95/95 [==============================] - 37s 394ms/step - loss: 0.0300 - accuracy: 0.9921 - val_loss: 0.0240 - val_accuracy: 0.9922\n",
            "Epoch 14/20\n",
            "95/95 [==============================] - 38s 395ms/step - loss: 0.0277 - accuracy: 0.9914 - val_loss: 0.0211 - val_accuracy: 0.9948\n",
            "Epoch 15/20\n",
            "95/95 [==============================] - 38s 405ms/step - loss: 0.0271 - accuracy: 0.9901 - val_loss: 0.0269 - val_accuracy: 0.9896\n",
            "Epoch 16/20\n",
            "95/95 [==============================] - 38s 405ms/step - loss: 0.0323 - accuracy: 0.9905 - val_loss: 0.0263 - val_accuracy: 0.9909\n",
            "Epoch 17/20\n",
            "95/95 [==============================] - 38s 405ms/step - loss: 0.0279 - accuracy: 0.9914 - val_loss: 0.0254 - val_accuracy: 0.9909\n",
            "Epoch 18/20\n",
            "95/95 [==============================] - 38s 402ms/step - loss: 0.0315 - accuracy: 0.9898 - val_loss: 0.0267 - val_accuracy: 0.9896\n",
            "Epoch 19/20\n",
            "95/95 [==============================] - 38s 403ms/step - loss: 0.0264 - accuracy: 0.9908 - val_loss: 0.0216 - val_accuracy: 0.9922\n",
            "Epoch 20/20\n",
            "95/95 [==============================] - 39s 412ms/step - loss: 0.0242 - accuracy: 0.9928 - val_loss: 0.0209 - val_accuracy: 0.9935\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DlpFE6NdqwrA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "029ca2cd-407a-4663-aa03-9c95dc439d68"
      },
      "source": [
        "# make predictions on the testing set\n",
        "print(\"[INFO] evaluating network...\")\n",
        "predIdxs = model.predict(testX, batch_size=BS)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[INFO] evaluating network...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i1OYRBBFqwyZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# for each image in the testing set we need to find the index of the\n",
        "# label with corresponding largest predicted probability\n",
        "predIdxs = np.argmax(predIdxs, axis=1)\n"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3-1vdcRyqw4Z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "1672cc6f-fdde-4ca4-d572-7b8df612680a"
      },
      "source": [
        "# show a nicely formatted classification report\n",
        "print(classification_report(testY.argmax(axis=1), predIdxs,target_names=lb.classes_))"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "   with_mask       0.99      1.00      0.99       384\n",
            "without_mask       1.00      0.99      0.99       384\n",
            "\n",
            "    accuracy                           0.99       768\n",
            "   macro avg       0.99      0.99      0.99       768\n",
            "weighted avg       0.99      0.99      0.99       768\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CaX0NGZIq5hu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "afc278d1-f08d-4966-c458-6ab49badbf7c"
      },
      "source": [
        "# serialize the model to disk\n",
        "print(\"[INFO] saving mask detector model...\")\n",
        "model.save('my_model.h5')"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[INFO] saving mask detector model...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ur7PfpJq5uj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "outputId": "0a2f1282-c43c-48f6-f81f-fea5410c00cf"
      },
      "source": [
        "# plot the training loss and accuracy\n",
        "N = EPOCHS\n",
        "plt.style.use(\"ggplot\")\n",
        "plt.figure()\n",
        "plt.plot(np.arange(0, N), H.history[\"loss\"], label=\"train_loss\")\n",
        "plt.plot(np.arange(0, N), H.history[\"val_loss\"], label=\"val_loss\")\n",
        "plt.plot(np.arange(0, N), H.history[\"accuracy\"], label=\"train_acc\")\n",
        "plt.plot(np.arange(0, N), H.history[\"val_accuracy\"], label=\"val_acc\")\n",
        "plt.title(\"Training Loss and Accuracy\")\n",
        "plt.xlabel(\"Epoch #\")\n",
        "plt.ylabel(\"Loss/Accuracy\")\n",
        "plt.legend(loc=\"lower left\")\n",
        "plt.savefig('plot.png')"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEaCAYAAAD+E0veAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd5hU5dn48e8p07ayHREwslIEXkFcpWgosmqUYgNLAhbARn4xGhMjBF/IqxRJsBF9QxQxIjGYF2KCiglFBUUNkaJYQZGsAm6FXXZ32jnP74+ZHXbYNttX9v5c17nm1Dn3nJ0995znOed5NKWUQgghhAD09g5ACCFExyFJQQghRIQkBSGEEBGSFIQQQkRIUhBCCBEhSUEIIUSEJAURszfeeANN0/j6668btZ2maTz//POtFFXnNXr0aGbMmNHeYYiTjCSFk5CmafUO3/ve95r0viNGjODQoUN069atUdsdOnSISZMmNWmfjSUJqHZ33HEHhmHwxBNPtHcoooOTpHASOnToUGRYs2YNADt27IjM2759e9T6fr8/pvd1Op107doVXW/c16Zr16643e5GbSNaTnl5OatWrWL27Nk89dRT7R0OEPt3TrQ9SQonoa5du0aG1NRUADIyMiLzMjMzefzxx/nhD39IcnIyU6dOBeBXv/oVZ555JnFxcfTo0YPbb7+do0ePRt73xOKjqukNGzYwcuRI4uLi6N+/P+vXr4+K58Rf75qm8eSTTzJ16lQSExPp3r07CxcujNqmqKiIyZMnEx8fT1ZWFvfffz833ngjubm5zTo2f/zjH+nfvz9Op5Pu3bszZ84cgsFgZPlbb73F+eefT2JiIomJiQwaNIh//OMfkeULFiygV69euFwuMjIyuOSSS6isrKxzf3/6058YOnQoycnJpKenM27cOD7//PPI8q+++gpN03jxxRcZP348cXFx9OrVi2effTbqfQ4cOMAPfvADPB4PPXr0YOnSpTF/5hdeeIHevXszZ84cDhw4wHvvvVdjndWrV3POOefgdrtJS0vj0ksvpaSkJLL8iSeeoH///rhcLjIzM7n66qsjy773ve/x4IMPRr3fjBkzGD16dGR69OjRTJ8+nfvvv59TTjmFnj17xnR8APLz87n55pvJysrC7XbTt29fnnnmGZRS9OrViwULFkStX15eTlJSEitXroz5GInjJCl0Ur/+9a8ZMWIEO3bsiPxDezwe/vCHP/Dxxx/z7LPP8sYbb3DnnXc2+F4///nPmT17Nrt372bo0KFce+21USeUuvY/cuRIdu3axaxZs5g9ezabNm2KLL/55pvZvXs3L7/8Mps3b+brr7/mpZdeatZnfuWVV5g2bRpTp05lz549LFmyhCeeeIJf//rXAASDQSZOnMjQoUPZsWMHO3bsYN68ecTFxQGwdu1aFi1axGOPPcbevXvZsGEDl156ab379Pl8zJkzhx07drBhwwYMw2DcuHE1finfd9993HDDDXzwwQdcd911zJgxI3JyVEpx5ZVXUlRUxBtvvMG6dev4+9//zo4dO2L63MuWLeOmm27C5XJx3XXXsWzZsqjlK1asYMqUKVxxxRXs2LGD119/nR/84AdYlgXA3Llz+eUvf8nMmTP58MMPee211xgyZEhM+67uxRdfpKCggE2bNrFhw4aYjk9lZSWjRo1i9+7drFq1io8//pilS5cSFxeHpmnccsstLF++nOqt9fz5z3/GNE0mT57c6BgFoMRJ7fXXX1eAysvLi8wD1LRp0xrcdu3atcrpdCrLsmp9r6rpNWvWRLY5fPiwAtRrr70Wtb+VK1dGTf/kJz+J2le/fv3Ufffdp5RS6vPPP1eA2rhxY2S53+9X3bt3V2PHjq035hP3Vd0FF1ygJk+eHDXv0UcfVW63W/l8PlVcXKwA9frrr9e6/cMPP6x69+6t/H5/vTHUp6ioSAHqrbfeUkoptX//fgWoJUuWRNYJBoMqISFB/f73v1dKKbVhwwYFqM8++yyyTn5+vnK73Wr69On17m/nzp3K6XSqwsJCpZRS77zzjoqLi1NHjhyJrNOjRw/14x//uNbtjx07ptxut/rNb35T5z5OO+009cADD0TNmz59uho1alRketSoUap3796R71JdTjw+Tz/9tHK5XFHf3+oOHz6sHA6H2rBhQ2TesGHD1J133lnvfkTd5EqhkzrvvPNqzFu7di0jR46kW7duJCQk8KMf/Qi/38/hw4frfa/BgwdHxrOysjAMg2+//TbmbQC6desW2ebjjz8GYNiwYZHlDoeDnJyc+j9UAz766CNGjhwZNW/UqFF4vV6++OILUlJSmDFjBpdccgmXXnopixYt4rPPPouse8011xAIBDjttNO46aabWLlyJWVlZfXuc9euXVx55ZWcfvrpJCYmRopNDhw4ELVe9eNhGAaZmZlRxyM9PZ0+ffpE1snIyKBv374NfuZly5Yxfvx40tLSgNAx7d69e6Q4Lz8/n7y8PC6++OJat//oo4/wer11Lm+Mc845p0Z9VEPH5/3336d///5079691vfMysri8ssvj9SV7Nmzh3fffZdbbrml2fF2VpIUOqn4+Pio6ffee4/JkyczcuRI/vrXv7Jjxw5+//vfAw1XCjqdzhrzbNtu1DaaptXYRtO0et+jNTz11FO8//77XHTRRbz55psMHDgwUtxy6qmn8umnn/LMM8+QmZnJAw88QN++fcnLy6v1vSoqKrj44ovRNI0VK1bwr3/9i+3bt6NpWo1jGsvxaKyqCuaXXnoJ0zQjw969e1u0wlnX9ajiG4BAIFBjvRO/c405PvW5/fbbeemllygsLOTpp59m+PDhDBw4sGkfRkhSECFvvfUW6enpPPjggwwdOpQ+ffo0+nmEltK/f38A3nnnnci8YDDI+++/36z3HTBgAFu2bIma9+abb+LxeMjOzo7MGzhwID/72c9Yv34906dP5w9/+ENkmcvl4gc/+AGLFy/mww8/pKKios66jk8++YSCggLmz5/P6NGjOfPMMykpKalxAm1I//79KSwsZO/evZF5hYWFUVcxtXnhhRcwTZNdu3ZFDW+88QYffPAB7733HpmZmXTv3p1//vOfde7b7XbXuRwgMzOTgwcPRs3buXNng58rluNzzjnn8PHHH9f7Xbzwwgvp2bMny5YtY+XKlXKV0ExmewcgOoa+fftSUFDA8uXLGTNmDG+99RZPPvlku8TSu3dvJkyYwI9//GOWLVtGRkYGS5YsobS0NKarh//85z/s2rUral63bt2YNWsWEyZMYNGiRVx11VXs2rWLefPmcc899+B0Otm3bx9PPfUUEyZMoEePHhw8eJCtW7dGKlWXL1+Obducd955dOnShU2bNlFWVhZJYic67bTTcLlcLF26lHvuuYevvvqK++67r9FXQGPHjmXQoEFMmTKFpUuX4nQ6+eUvf4nD4ah3u2XLlnHllVfyX//1XzWWDRs2jGXLljF06FDmzp3LHXfcQVZWFpMmTcK2bV5//XWuu+460tPTueeee5g3bx4ej4eLLrqIyspKXn31VWbNmgVAbm4uTz75JFdeeSWnnXYav//97zlw4EDkzre6xHJ8rr/+ehYvXszEiRNZvHgx2dnZfPnllxQWFnLttdcCoauqW2+9lTlz5uDxeCLzRRO1c52GaGV1VTTXVhk7Z84clZmZqeLi4tSll16q/vSnPylA7d+/v9b3qu29lVLKMAy1YsWKOvdX2/7Hjh2rbrzxxsh0YWGhuvrqq5XH41EZGRnq/vvvV5MmTVLjx4+v9/MCtQ4LFy5USin17LPPqn79+imHw6G6deumZs+erQKBgFJKqYMHD6orr7xSnXrqqcrpdKpTTjlFzZgxI1Ipu2bNGjV8+HDVpUsX5fF41IABA9TTTz9dbzx/+ctf1BlnnKFcLpcaPHiweuONN6KOT1VF89atW6O2y87OVnPnzo1M79+/X1100UXK5XKpU089VT366KNq1KhRdVY079y5s0aFf3WPPvpoVIXz888/r8466yzldDpVamqquuyyy1RJSYlSSinbttWjjz6q+vTpoxwOh8rMzFSTJk2KvFdpaamaMmWK6tKli8rIyFBz586ttaK5tlgbOj5KKXXo0CE1depUlZaWplwul+rbt2/UcqWUKigoUA6HQ82cObPWzytipyklPa+Jjs+yLPr168fEiRNZsmRJe4cjOpiPPvqIgQMHsmvXLgYNGtTe4XynSfGR6JC2bNlCfn4+Z599NmVlZTzyyCN89dVX3HTTTe0dmuhAfD4fhYWFzJo1izFjxkhCaAGSFESHZFkWDz74IPv27cPhcDBw4EBef/31WsvHRef1wgsvMG3aNAYMGMD//d//tXc4JwUpPhJCCBEht6QKIYSIkKQghBAi4jtfp3DiQzOxSk9Pp7CwsIWjaTkSX/NIfM3X0WOU+Jquvj5R5EpBCCFEhCQFIYQQEZIUhBBCREhSEEIIEdEmFc1PPvkkO3bsIDk5udYmCpRSrFixgp07d+JyuZg5cya9evVqi9CEEEJU0yZXCqNHj2b27Nl1Lt+5cyeHDx/m8ccf59Zbb+Xpp59ui7CEEEKcoE2SQv/+/UlISKhz+b///W9GjhyJpmn06dOH8vLyBvv4FUII0fI6xHMKxcXFpKenR6bT0tIoLi4mJSWlxrobN25k48aNACxatChqu8YwTbPJ27YFia95JL6G2bZNIBAgGAxGhqrpQCBAaWkpPp+vxvxgMIhlWbhcLjweD263G4/HEzXudDpbvee8jnAM6xNLfLZtRw2WZdWYVzXfCtoELYtgwCIQtMjMTCM1tUvLx93i79jKcnNzyc3NjUw39eGQjvxgCXTc+ILBIJWVlcTFxVFRUYHL5cLhcLRJ15lKKfx+P16vl0AggKZp6LqOpmkYhhGZ1nWd9PR0SkpKItPV41NKYdtgBRVer4/KSh+VlV68Xi8+nw+v14fP58Xn9eHz+/BXHwI+AgE/lhVA03QM3UA3TAzdwDBMdN1AD48bhoGhm+iGERqvtl5cXBx+XwDQAB00DQ2d4xfvOigdDQ2FBkqPrKuUBgqCVpBgMIBlHR+CVgDLDmBbQSw7NM+2w/NUANsOYtsBbBUEmtfdZ300NAzThWk4MU0npunCYbowTScOhwuH6UQpUMoODwqlQidARWhc2dXmh1+rr6/rOpZth3rMCP9do78vtY9XrY+moWk6uqaj66FxTdfRNS38Gpof+puG1zWOzw+drIPYthU6adtV46FXhSIYrDrmVngIjysLpZp3/M8a8H1Gjz27SdvW9/Bah0gKqampUSfAoqKiBnttEs2nlCIQCFBZWdngUFEReg0Ga/a9q2k6DocTh+nC4ag6AUSfCEzTFRoMJ6bhQtdNbDtA0PKFhqCfoOUnGPQRCPoIBvwEwuOBgJ9A+GR8/D+6sTQ0NNBCJ1ogfGKs7/00dM2JrjsxNBe67kTX4nGbTnSHA4WNUlZosCyCloVSwfBJqxKb4PHlykIRem36Z4jxk2qhZGQYDgzDgWk6cBouDCMB03RgGg4M04Guh5JUaP3Qq66b6JqBphu4XR4CARu9aplW9WoCOgHLT9DvIxCs9ncL+iN/T8vyEbRCr16vjwqrDMv2Ydm1/R2r/33CSbzauFaVOCN/Py36h4gGNX6WVJ8XtaqGQoF9YsKplnhQUG08dAKv7e+moVUdF0LHrepY6bqJhoGmu3AYBrqj2nzdwNDDSahqiCQhHcMIzzN0DL3aeHi+YWj06Nk6V0kdIink5OTw2muvcf7557N3717i4uJqLTpqL5ZlhX9Bhn5J+nw+/H5/1GW3ZVlRrw3Ns2076pftib94XS4XlmWh6+FfiErDVjrYGkpp2LaGouqLevwLHRnnhC+5Uijbxg6PW1boF79lWbV+Zk0zMA0Xhu5B11xoWjpxTheG242hudF0B8oOYClf+BeoD9vy4wv6qbS9WOootu3HVo09kesYuhM9chJ2oeuJuE0n8c7q8x2AinxWwsdC1xWarjDM0K9QTbfRNQWaQtMUmmaHx8HhcOJyunC6nLicblxuF25X+NXtxuk0MU0dXQfd0NB1MAzC/7jhT6XCXbup4+MoFf4VHPpEJ47bVpCExCRKSopDn6Hq76jsyLgd/pVcW1FC1XyHw4HD4cDpdOJ0OiPThmE06vtdl9a6WlVKEQwGo670mnKl2dZX06H/JxUpzjFNs8ZVaHvG11LaJCk8+uijfPzxx5SVlXH77bdzzTXXEAwGAbj44os5++yz2bFjB3feeSdOp5OZM2e2ajylpaUUFRWRn58fOcmfeNKvPl0VayxM08Q0Q0UH1V9N08ThcODxeMInfoNgMFxOGLTDrxY+r8KyLJRdfrx8UdmhEw3VXlGEfqXo4WKH0HjUa6RYIvTLLvTlrfrlZRDvcmHo7sig6y4chhu3x4PH48Tl1nG6NFwuHadbw+XScLp0XC6NzK6pHD1aEv6HBi304w1NA13TIuOEL6Grin2qjm0gEMDpdOJ2u3G5XOGTmgvDMEFpkSKe0Am12rgNth06wxqmhmlqGCaYhoZuHP/nbIt/yLpPYw2d4JykpyeA5m3ZgL4jNE1rsH/pjqgqeem6jml2iN/TraJNPtldd91V73JN05gxY0ZbhALA3r17efvtt6PmORyOyAnK5XLRpUuXyHjVUH25y+WqcfKv+pVfxbYU5eU25WU2x8qsqFefN3xiCw9VxcnOBA2XWyMh0YVuBHG5dFweLerV7dFwODRsFdqHbYMVfrUthW2BZR9fZluqxrRS4Kx2kg+d9HUMk5h+tSV3cRIIxvKLVMMwQscrMTEx5r9RwydWIURrOHnTXT369OnDgAED8Hq9kRN8qJim8ZRSeCsVZUcsjpX5o078FeV2VAWX06WRkKiTeYqD+ITQyd3p1nG7tcivcl0PnQxj+aWrA5hy8hRCtJxOmRQSExObVbxwrNTi84+8lJXalB+zsKqVLukGJCTqJKUYdOvpID7RICFRJz5Rx+mUVkWEEB1bp0wKzWFZiu1vl+OttElJM0nLcJKQaBCfpJOQaOD2NK3STAghOgJJCo30yQdejpXaDB0ZT+Yp373KMiGEqI+UZzRCwbcB9n/u43tnOCUhCCFOSpIUYuT32+x6r4KERJ0zB3naOxwhhGgVkhRitOf9SnxexdnD4jDljh8hxElKkkIMvjng55v/BOgzwE2XVKmGEUKcvCQpNKCywubD9ytJSTM440xXe4cjhBCtSpJCPZRS7HqvAluFio2qHiwTQoiTlSSFeuz/3EdhfpABgz3EJ7RMI2NCCNGRSVKoQ9lRi08+8JLVzaRnL2d7hyOEEG1CkkItbEux490KTIfGoHPj5AllIUSnIUmhFp995KX0iMWgc+NwueUQCSE6DznjnaCoIMi+T3z07OWk66ny1LIQonORpFBNIKDY+V4FcfE6AwbLU8tCiM5HkkI1H+2opLLCDj217JB6BCFE5yNJIezQ137yvvLT+0wXqeny1LIQonOSpAB4K212b68kOcWgzwB3e4cjhBDtptMnBaUUu7dXYFny1LIQQnT6pHDgCz/5h4L0H+QhMUmeWhZCdG6dOikcK7P4aFclGV1NvneGPLUshBCdNinYlmLnuxUYhsbg8+SpZSGEgE6cFHa/X8yRYouzcjy4PZ32MAghRJROee9lSVGQ3f8+RvfTHHTrIcVGQghRpVP+RC49YpGQ5GDgkLj2DkUIITqUTnmlcFq2i8E53SgpKWrvUIQQokPplFcKAIYhFctCCHGiTpsUhBBC1CRJQQghRIQkBSGEEBGSFIQQQkS02d1Hu3btYsWKFdi2zdixY7niiiuilhcWFvLEE09QXl6Obdv88Ic/ZMiQIW0VnhBCCNooKdi2zfLly5kzZw5paWnMmjWLnJwcunfvHllnzZo1DB8+nIsvvpivv/6ahQsXSlIQQog21ibFR/v27aNr165kZWVhmiYjRoxg+/btUetomkZFRQUAFRUVpKSktEVoQgghqmmTK4Xi4mLS0tIi02lpaezduzdqncmTJ/Pggw/y2muv4fP5uP/++2t9r40bN7Jx40YAFi1aRHp6epNiMk2zydu2BYmveSS+5uvoMUp8raPDPNH89ttvM3r0aCZMmMDnn3/O0qVLWbJkCboefTGTm5tLbm5uZLqwsLBJ+0tPT2/ytm1B4mseia/5OnqMEl/TdevWrc5lbVJ8lJqaSlHR8SYlioqKSE1NjVpn8+bNDB8+HIA+ffoQCAQoKytri/CEEEKEtUlSyM7O5tChQ+Tn5xMMBtm2bRs5OTlR66Snp7Nnzx4Avv76awKBAElJSW0RnhBCiLA2KT4yDINp06Yxf/58bNtmzJgx9OjRg9WrV5OdnU1OTg433HADy5Yt45VXXgFg5syZ0vGNEEK0sTarUxgyZEiNW0yvvfbayHj37t154IEH2iocIYQQtZAnmoUQQkRIUhBCCBEhSUEIIUSEJAUhhBARkhSEEEJESFIQQggRIUlBCCFEhCQFIYQQEZIUhBBCREhSEEIIESFJQQghRIQkBSGEEBGSFIQQQkRIUhBCCBERc1J49tln+eqrr1oxFCGEEO0t5v4UbNtm/vz5JCUl8f3vf5/vf//7pKWltWZsQggh2ljMSWHatGncdNNN7Ny5k61bt7J27Vp69+7NyJEjGTp0KG63uzXjFEII0QYa1fOaruucc845nHPOOeTl5fH444/z5JNP8vTTT3P++edzzTXXkJqa2lqxCiGEaGWNSgoVFRW8++67bN26lQMHDjB06FCmT59Oeno6L7/8MgsWLOC3v/1ta8UqhBCilcWcFJYsWcLu3bs588wzueiiizj33HNxOByR5TfccAM33XRTa8QohBCijcScFHr37s306dPp0qVLrct1Xeepp55qscCEEEK0vZhvST3rrLMIBoNR8woLC6NuU3W5XC0WmBBCiLYXc1JYunQplmVFzQsGg/zud79r8aCEEEK0j5iTQmFhIVlZWVHzunbtSkFBQYsHJYQQon3EnBRSU1P58ssvo+Z9+eWXpKSktHhQQggh2kfMFc3jxo3jN7/5DRMnTiQrK4tvv/2WdevWcdVVV7VmfEIIIdpQzEkhNzeX+Ph4Nm/eTFFREWlpadxwww0MGzasNeMTQgjRhhr18Nrw4cMZPnx4a8UihBCinTUqKRw5coR9+/ZRVlaGUioy/8ILL2zxwIQQQrS9mJPCv/71L5YuXcopp5xCXl4ePXr0IC8vj379+klSEEKIk0TMSWH16tXMnDmT4cOHc/PNN7N48WJef/118vLyWjM+IYQQbSjmpFBYWFijPmHUqFHceuut3HDDDQ1uv2vXLlasWIFt24wdO5Yrrriixjrbtm3jL3/5C5qmcdppp/HTn/401vCEEEK0gJiTQlJSEkeOHKFLly5kZGTw+eefk5iYiG3bDW5r2zbLly9nzpw5pKWlMWvWLHJycujevXtknUOHDvHSSy/xwAMPkJCQwNGjR5v2iYQQQjRZzElh7NixfPrppwwbNoxx48bx61//Gk3TGD9+fIPb7tu3j65du0aeiB4xYgTbt2+PSgqbNm3ikksuISEhAYDk5OTGfhYhhBDNFHNSmDhxIroeegB61KhRDBgwAK/XG3Vir0txcXFU151paWns3bs3ap2DBw8CcP/992PbNpMnT2bw4ME13mvjxo1s3LgRgEWLFpGenh7rR4himmaTt20LEl/zSHzN19FjlPhaR0xJwbZtpk6dyrPPPhvpQ6GlP6xt2xw6dIi5c+dSXFzM3Llz+e1vf0t8fHzUerm5ueTm5kamCwsLm7S/9PT0Jm/bFiS+5pH4mq+jxyjxNV23bt3qXBZT20e6rtOtWzfKysqaFEBqaipFRUWR6aKiohrddqamppKTk4NpmmRmZnLKKadw6NChJu1PCCFE08TcIN4FF1zAQw89xBtvvMGHH37Inj17IkNDsrOzOXToEPn5+QSDQbZt20ZOTk7UOueddx4fffQRAKWlpRw6dKhGq6xCCCFaV8x1Cv/85z8B+Mtf/hI1X9O0BvtUMAyDadOmMX/+fGzbZsyYMfTo0YPVq1eTnZ1NTk4OgwYNYvfu3dx9993ous6UKVNITExswkcSQgjRVJqq3l7Fd1BVBXVjdeTyPpD4mkvia76OHqPE13TNrlMQQgjROcRcfHTHHXfUuex///d/WyQYIYQQ7SvmpPCTn/wkarqkpIRXX32V888/v8WDEkII0T5iTgr9+/evMW/AgAHMnz+fyy67rEWDEkII0T6aVadgmib5+fktFYsQQoh21qims6vz+Xzs3LmTs88+u8WDEkII0T5iTgrVn0gGcLlcjB8/npEjR7Z4UEIIIdpHzElh5syZrRmHEEKIDiDmOoWXXnqJffv2Rc3bt28ff/vb31o8KCGEEO0j5qTw6quv1mgmu3v37rz66qstHpQQQoj2EXNSCAaDmGZ0aZNpmvj9/hYPSgghRPuIOSn06tWLf/zjH1Hz/vnPf9KrV68WD0oIIUT7iLmi+cYbb+TBBx9ky5YtZGVl8e2333LkyBHuv//+1oxPCCFEG4o5KfTo0YPHHnuM999/n6KiIoYOHco555yD2+1uzfiEEEK0oZiTQnFxMU6nM6qto2PHjlFcXFyjFzUhhBDfTTHXKfzmN7+huLg4al5xcTG//e1vWzwoIYQQ7SPmpHDw4EF69uwZNa9nz5588803LR6UEEKI9hFzUkhKSuLw4cNR8w4fPixdZgohxEkk5jqFMWPGsGTJEq677jqysrI4fPgwq1ev5sILL2zN+IQQQrShmJPCFVdcgWmarFy5kqKiItLS0rjwwguZMGFCa8YnhBCiDcWcFHRdZ+LEiUycODEyz7Ztdu7cyZAhQ1olOCGEEG0r5qRQ3YEDB3jzzTd56623sCyL5cuXt3RcQggh2kHMSeHo0aNs3bqVLVu2cODAATRN4+abb2bMmDGtGZ8QQog21GBSeOedd3jzzTfZvXs3p556KhdccAG/+MUv+NWvfsWwYcNwOp1tEacQQog20GBSePTRR0lISODuu+/mvPPOa4uYhBBCtJMGk8Idd9zBm2++ycMPP0x2djYXXHABI0aMQNO0tohPCCFEG2owKYwePYd4YGsAACAASURBVJrRo0dTUFDAm2++yWuvvcZzzz0HwM6dOxk5ciS6HvMzcEIIITqwmCuaMzIymDRpEpMmTeLTTz/lzTff5I9//CMvvPACy5Yta80YhRBCtJEGk8IHH3xA//79o3pd69evH/369WPatGls3769VQMUQgjRdhpMCuvWreOxxx6jb9++DBkyhCFDhkSaynY4HIwYMaLVgxRCCNE2GkwKv/rVr/D5fHz44Yfs3LmTtWvXEh8fz9lnn82QIUPo06eP1CkIIcRJIqY6BZfLRU5ODjk5OQD85z//YefOnfz5z3/mm2++YcCAAYwbN47evXu3arBCCCFaV5OauejZsyc9e/bk8ssvp6Kigt27d1NZWVnvNrt27WLFihXYts3YsWO54ooral3v3Xff5eGHH2bhwoVkZ2c3JTwhhBBNFHNS2LNnD5mZmWRmZlJSUsKqVavQdZ0f/vCHDB8+vN5tbdtm+fLlzJkzh7S0NGbNmkVOTg7du3ePWq+yspL169fLFYcQQrSTmCsDli9fHqk7eO6557AsC03TYroddd++fXTt2pWsrCxM02TEiBG13rW0evVqLr/8chwORyM+ghBCiJYS85VCcXEx6enpWJbF7t27efLJJzFNk9tuuy2mbdPS0iLTaWlp7N27N2qdL7/8ksLCQoYMGcLf//73Ot9r48aNbNy4EYBFixaRnp4e60eIYppmk7dtCxJf80h8zdfRY5T4WkfMScHj8XDkyBHy8vLo3r07brebYDBIMBhsdhC2bfPcc88xc+bMBtfNzc0lNzc3Ml1YWNikfaanpzd527Yg8TWPxNd8HT1Gia/punXrVueymJPCD37wA2bNmkUwGOSmm24C4NNPP+XUU09tcNvU1FSKiooi00VFRZFnHQC8Xi95eXn8+te/BuDIkSMsXryYe++9VyqbhRCiDTWqO87zzjsPXdfp2rUrEDrZ33777Q1um52dzaFDh8jPzyc1NZVt27Zx5513RpbHxcVFddQzb948pk6dKglBCCHaWKNuSa1+ybFnzx50Xad///4NbmcYBtOmTWP+/PnYts2YMWPo0aMHq1evJjs7O/L8gxBCiPYVc1KYO3cu119/Pf369eOll17ilVdeQdd1LrnkEq666qoGt69qIqO6a6+9ttZ1582bF2tYQgghWlDMt6Tm5eXRp08fADZt2sTcuXOZP38+GzZsaLXghBBCtK2YrxSUUgAcPnwYIPLgWXl5eSuEJYQQoj3EnBT69u3LM888Q0lJCeeeey4QShCJiYmtFpwQQoi2FXPx0Y9//GPi4uI47bTTuOaaawA4ePAgl112WasFJ4QQom3FfKWQmJjID3/4w6h5J1YcCyGE+G6LOSkEg0HWrl3Lli1bKCkpISUlhZEjR3LVVVdF9cr2XWEVd8wnDYUQoj3FfDZ//vnn+eKLL7jlllvIyMigoKCANWvWUFFREXnC+bvCfuVFCl99EX3Jc2juuPYORwghOoyY6xTeffdd7r33XgYNGkS3bt0YNGgQP//5z3nnnXdaM75WofX9L/D7UTvebe9QhBCiQ4k5KVTdknpSyO6HnnkK6r032zsSIYToUGIuPho+fDgPPfQQkyZNirT+t2bNmgY72GlrSim8Xi+2baNpWp3r6TfdRTBvP9qREjSnqw0jjM23336Lz+drt/0rpdB1HbfbXe9xFEKcXGJOClOmTGHNmjUsX76ckpISUlNTGTFiRIs0nd2SvF4vDoejwcpvI7sPQYcJuoYW1/HqFUzTxDCMdo0hGAzi9XrxeDztGocQou3EnBRM0+Taa6+Naq/I7/czdepUpkyZ0irBNYVt2zHdDaU5XeB0QXkZJHVpg8i+e0zTbNerFSFE24u5TqE2HbFYoVExxSeCz4sK+FsvoO+4jvg3FkK0nmYlhe+8+ARAg/Jj7R2JEEJ0CA2Ws+zZs6fOZR2tPqGxNNOBcruhvAyVnCK/ioUQnV6DSeF///d/613+XeyYOkp8IhTlg98HLnez3+7o0aP89a9/bfQDfVOnTuV3v/sdycnJjdrurrvuIjc3l/HjxzdqOyGEqE2DSeGJJ55oizjaT1wCFBeEKpxbICmUlpby3HPP1UgKwWCw3grwlStXNnvfQgjRXN+9Rosawf7zU6i8/bUv07TjD+QF/GDbMSUFrcfp6NfdUufyBQsWcODAAS666CIcDgcul4vk5GT27dvHW2+9xbRp0zh48CA+n4/p06dH7twaOnQo69evp7y8nClTpjB06FC2b99O165deeaZZ2K6LXTr1q088MADWJbFoEGDWLhwIS6XiwULFvDPf/4T0zQZOXIk//3f/826det45JFH0HWdpKQk1q5d2+D7CyFOfid1UoiZboBlgW2Fxpth9uzZfPbZZ2zYsIFt27Zxww03sHnzZnr27AnAkiVLSElJobKyknHjxnHZZZeRmpoa9R779+9n2bJlLF68mNtuu41XX32Vq6++ut79er1e7r777ki/13feeSfPPfccV199NevXr2fLli1omsbRo0cBePTRR1m1ahWnnHJKZJ4QQpzUSaG+X/SmaUYqypVtw9f7IS4BLT2rRWMYPHhwJCEAPPPMM6xfvx4I9Uexf//+GkmhR48eDBw4kGAwyFlnnUVeXl6D+/niiy/o2bMn2dnZAEyePJk//vGP3HzzzbhcLu655x5yc3PJzc0FICcnh7vvvpsJEyZw6aWXttTHFUJ8x3XuW1LDNF0P1S1UlIcSRAuKq/a09LZt29i6dSvr1q1j48aNDBw4sNaHw1yu481uGIaBZVlN3r9pmrzyyiuMGzeOjRs38qMf/QiAhx56iHvvvZeDBw9y6aWXUlxc3OR9CCFOHif1lUKjxCfCsVKorAg/v9DEt4mP59ix2p97KCsrIzk5GY/Hw759+9ixY0eT93Oi7Oxs8vLy2L9/P6effjpr1qxh2LBhlJeXU1lZydixYzn33HMjbVV99dVXDBkyhCFDhvD6669z8ODBGlcsQojOR5JCFbcHDDN0F1IzkkJqairnnnsuF154IW63O+qW3dGjR7Ny5UpGjRpFdnZ2i/Zc53a7efjhh7ntttsiFc1Tp07lyJEjTJs2DZ/Ph1KKuXPnAvDggw+yf/9+lFJccMEFDBgwoMViEUJ8d2nqO94m9sGDB6OmKyoqoops6lK9TqGKKi6AsqPQ/XS0dm6Mrrb42kNdx7OqpdyOSuJrvo4eo8TXdN26datzmdQpVBefCEpBRXl7RyKEEO1Cio+qc7rAdISKkBKT2juaKLNnz2b79u1R82bMmBHVaq0QQjSXJIVqNE1DJSTCkRJUMIgWQxPcbWXBggXtHYIQohOQ4qMTxScCCiqk5VQhROcjSeEEmsMJTjccK2vvUIQQos1JUqhNQiL4pfMdIUTnI0mhNnFVne/I1YIQonNps5rUXbt2sWLFCmzbZuzYsVxxxRVRy19++WU2bdqEYRgkJSVxxx13kJGR0VbhRdFME+X2wLEyVHJqq3a+07t3b/bu3Vvrsry8PG688UY2b97cavsXQojq2uRKwbZtli9fzuzZs3nkkUd4++23+frrr6PW+d73vseiRYv47W9/y7Bhw3j++efbIrS6xSdCMBDqfEcIITqJNrlS2LdvH127diUrK9QC6YgRI9i+fTvdu3ePrDNw4MDIeO/evdm6dWuz9/v0v79lf4m31mVa9f4UaqEU4LPgk6/RTEdk/ukpbmbk1N2S6oIFC+jWrVukk50lS5ZgGAbbtm3j6NGjBINB7r33Xi655JJGfRav18usWbP44IMPMAyDuXPncv755/PZZ5/xs5/9DL/fj1KKP/zhD3Tt2pXbbruNQ4cOYds2P/3pT7n88ssbtT8hROfUJkmhuLiYtLS0yHRaWlqdRSYAmzdvZvDgwW0RWp00DZQR6mdBmQ5iLUCaOHEic+fOjSSFdevWsWrVKqZPn05iYiLFxcVMmDCBiy++uFHFUs8++yyaprFp0yb27dvH9ddfz9atW1m5ciXTp0/nqquuwu/3Y1kWmzdvpmvXrpHe3EpLSxv56YUQnVXHeTorbMuWLXz55ZfMmzev1uUbN25k48aNACxatKhGH9HffvttpNvL24ed2qxY7GNlWIe/xuiWhR4XWyN5gwcPpqioiMLCQoqKiujSpQvdunXjv//7v3nnnXfQdZ3Dhw9TUlJCZmYmQJ3ddBrh9pdM0+Tf//4306dPxzRN+vXrR48ePThw4ADnnnsujz32GN9++y3jxo2jV69eDBw4kAceeICFCxdy0UUXMWzYsCYfA5fLVWs/3KZpduj+uSW+5uvoMUp8raNNkkJqaipFRUWR6aKiolqbaf7ggw/461//yrx583A4HDWWA1EdxQA1Gpzy+XyRk2l9YmlwTjldoBtYpUexnbH33zxu3Dj+9re/kZ+fz4QJE3jxxRcpKChg/fr1OBwOhg4dSnl5eWT/tcVhmmakH4VgMIhSCsuyjncMFJ6+/PLLGTRoEJs2beL666/noYce4oILLmD9+vVs3ryZhQsXcsEFF3D33XfHHH91Pp+v1ka9OnJjXyDxtYSOHqPE13Tt3iBednY2hw4dIj8/n2AwyLZt28jJyYlaZ//+/Tz11FPce++9JCcnt0VYDQp1vhMPFcca1fnOxIkT+dvf/sYrr7zC+PHjKSsrIz09HYfDUWsleyzOO+88/vrXvwKhXta++eYbsrOzOXDgAKeddhrTp0/nkksu4ZNPPuHw4cN4PB6uvvpqbr/9dj788MNG708I0Tm1yZWCYRhMmzaN+fPnY9s2Y8aMoUePHpH+hHNycnj++efxer08/PDDQCjL/vKXv2yL8OoX6XynPNwERsP69u1LeXl5pHL9qquu4sYbb2Ts2LGcddZZnHHGGY0O48Ybb2TWrFmMHTsWwzB45JFHcLlcrFu3jjVr1mCaJpmZmfzkJz9h9+7dPPjgg2iahsPhYOHChY3enxCic5L+FBqglIKvvwKXGy3zlKaG2WjSn0LzSHzN19FjlPiart2Lj77LNE0L9cRWWY5qRl/JQgjxXdDh7j7qkOITofRIqOXUxJav7/jkk0+48847o+a5XC5efvnlFt+XEELUR5JCLJwucDjDne+0fFI488wz2bBhQ9S8jlJ8JIToXKT4KAahIqRE8FaigoH2DkcIIVqNJIVYxYcfXiuXzneEECcvSQox0hxOcLmlOW0hxElNkkJjxCeC34eSllOFECcpSQqNEZ8QaimvniKko0eP8uyzzzb6radOncrRo0ebEZwQQjTfSX330Z4dFZQeqf3Zgoaazq5LkjOZAd8rQ3WpvfOd0tJSnnvuuUgrqVWCwWCdDd8BkRZNhRCiPZ3USaFVOByhznd8XnB7aixesGABBw4c4KKLLsLhcOByuUhOTmbfvn289dZbTJs2jYMHD+Lz+Zg+fTpTpkwBYOjQoaxfv57y8nKmTJnC0KFD2b59O127duWZZ57B46m5L4BVq1axatUq/H4/p59+Oo8//jgej4eCggLuu+8+Dhw4AMDChQs599xz+ctf/sKyZcuA0K2wS5cubaUDJYT4Ljqpk8LAIXU3d9HU5wCUbUFeUajCuZakMHv2bD777DM2bNjAtm3buOGGG9i8eTM9e/YEQp3upKSkUFlZybhx47jssstqtBi7f/9+li1bxuLFi7ntttt49dVXufrqq2uN59JLL+VHP/oRAA899BAvvPAC06ZN4/7772fYsGEsX74cy7IoLy/ns88+47HHHuPvf/87qamplJSUNPrzCyFObid1UmgNmm6g4uKh/BjKEw+euHo7yxk8eHAkIQA888wzrF+/Hgi127R///4aSaFHjx4MHDiQYDDIWWedRV5eXp3v/9lnn7F48WJKS0spLy9n1KhRALz99ts89thjAJF+r//v//6P8ePHR/aXkpLStIMghDhpSVJoiqQuoeKj/IPgdKGSukB8Yq3JoXpjctu2bWPr1q2sW7cOj8fDpEmT8Plq3snkcrki44Zh4PXW3qUowN13383y5csZMGAAq1ev5p133mnmhxNCdGZy91ETaC43nNoT0rNAAYXfwjcHUKVHiI+L49ix2u9OKisrIzk5GY/Hw759+9ixY0ezYzl27BhZWVkEAoFIfwsAF1xwAc899xwAlmVRWlrK+eefz8svv0xxcTGAFB8JIWrolFcKvqDNUZ+feIeGqcfeT3J1mqZDQhIqPhEqK6C0BIoLSNENcgadxYVjxuD2eKK64xs9ejQrV65k1KhRZGdnM2TIkGZ/ll/84heMHz+etLQ0zj777EhC+p//+R/uvfde/vznP6PrOgsXLiQnJ4c777yTSZMmoes6AwcO5NFHH212DEKIk0en7E+huDJIcUWoDaM4p0GSyyDOoaPXUzcQC+WtDLemWg4akJAESV1CT0M3UkdpEE/6U2gdHT0+6PgxSnxNV19/Cp3ySiHVY5LscVJS4aPMZ3HYb6FrGomuUIJwmU0rVdPcHnB7UAE/HD0S6rGtrDRUMZ2cEip2EkKIDqxTJgUAl6mTHucgzWNSEbAp9Vkc9QY56g3iMnWSXAYJTgOjCcVLmsMJ6ZmoLqlQdgTKSkP9PLvjILkLuOu/Y6k2s2fPZvv27VHzZsyYwbXXXtvo+IQQoi6dNilU0TSNeKdBvNPAshVlPotSv0VBeYDC8iDxzlCC8Dj0Rp/INdOElHRUckooMZQegW/DdywlJof7aXCg6UaD77VgwYKmfkQhhIhZp08K1Rm6RhePSRePiS8Yunoo81kc81uY+vHiJYfRuOIlTTcgOQWVlBxqN+loCRTlR5Yrwww9KW06wq9OlNuN0nQ0XW4QE0K0HUkKdXCZOhmmTlqcSbnfpsxnUVIZpKQyiMehk+g0cJs6DkOL+Qoi6o6lgB8CAQiGXwOB0F1Mx0KVy1VVzMqsniwcoR7gTAc4zND7CSFEC5Kk0ICqCuhEl0HAsinzh64e8stDdy9pmobb1HAZOi5Tx2VqOPT6E4WmaaGiI6erxjJlWxAIYNg2ls8bSh7BQOgKw45u3E/pBhgG6AYYeui1ap5RbVzXQ69a44vAhBCdiySFRnAYOqkenRS3id9S+II2PkvhDdoc9Vqo8O97XdNwmRpuUw8ni9DzELGckDXdAJeBbprYnjiUUlgKLFthWRZWIIhlWdiWjaFsDNtCt4MYVhDD78WwAlDXXcaadjyRGMYJVx6hKxFJGkJ0bpIUmkALn/Sr37pqK0UgnCCqkkVJ5fHnDAxdiySIqmIn24b/6t+Xf3/4CZZSWHb45K8UtvIRtELjNRnhgdAz6SeUIhm6hqGBgTo+qKokEsSwLUwrgHni1YemhYqrqiUKVX4MFfCFnreQhCHESe+kTgpbtmyhoKCg1mVN7U8hIyODkSNH1piv15Eo/EGF1woniqCiovKEIiAFBeGiKF3TMHQwNA2HoeMKlwoZuoZZbZmha2ga2FVXEOFEYtkQVFXToWWB8HylwnFpzkhOMd2hoi83Nh4VxBH0oQWr6jfKQSnUF59j/3kZeOIgsxta1qmQ1Y3K089A+f1gOsFhhpLIifUfkenwcsOUxCJEB3dSJ4X2sGDBArp168ZNN92Ermk88fjDGIbBtm3bOHr0KIFAgLvu+QWjcy/C0EIn99O6uDB0LeqJatM0OXr0KDffdDNHjx4lGAxy7733cskllwDU2i9CXX0oQChBhRIIWNWuaiqDNsdsABNdc+B267gTNTymjgsbzelGu/5WOPwN6tuDqC8+ge1bKG3Kg/CaRqUzjvz4DMpciSQGK0kNHiPB9qGhhZ4CRwv1blc1Ht4u8lo1rhuhpsvdnlBLtZ44cMeFkpc7joqMDOygXW2+J2q55nA0Pn4hOoFO2cwFtF4zEnv27GHu3LmsWbMGCLV3tGrVKpKSkkhMTKS4uJgJEybw1ltvoWkavXv3Zu/evbXG5/V6qaysrLHd559/zvTp06P6RUhJSeH222/nnHPO4ZZbbon0oZCUlFRvvEopgnY4QQRCr37LDi/VOFxSyhdlcGaGh34ZcSS5DFTAT4qyKMn/NlQJHr66sANBjlQGyPfaFPigwA+FAZ2CoEFB0KTAdlBey+8Qh7JIwU8qPlKUj1TlJUX5SMFHqu0lBS8pto9E/GhKhRohtC2Uzxu6Y8tbEX6tDF3h2HaNfdQ8wA5ISAw1RZKQhBZ+rX1eeL7T1WJXOh25CYQqHT1Gia/ppJmLNjRw4EAKCws5fPgwRUVFJCcnk5mZybx583jvvffQNI3Dhw9TUFBAZmZmve+llGLRokU1tnv77bdr7Rehtj4UGqJpGg4jVFyVGL4ZyrKPX0UcLoG/f1rM2o9Dy3okO+mfEceA7ql8UxxPQXmAgvJg6GG/igDBE87H8Q6djHgHGfEm/eMdZMQ5SI93kOw2KPVaFIdv8616zasM8kFlkPJAzRO7qWukegxSPKHtNUL5IfSzRqFUqEgNZWPqOj6vFywLZduoqtfwuG5bJFmVpASO0cV7hC5lJaQcPEhKaT5d/KUk+csxOOH3ksN5PEHEJYQPlgXKDr3adqiOpvprZHn1ZTb5GqEn3BMSIT4ROyEZf3wSgbgk/HGJ+D2JBNwJBNxx+F1x+J1xBAwnAQV+K3TVl+IxyYx3kBHvwOPoHLcnK8sKtS3mrcDSCf0waMFkLSQptIrx48fzyiuvkJ+fz8SJE1m7di1FRUWsX78eh8PB0KFDa+1H4URN3a65DP34U95DuiXwp8np7Cvy8nFBBZ8UVLL1QCn/2HcEXYMUj0lGnIM+aR5G9EyMnKTS40wy4h3EOxt+Wrs2vqAdarjwhKRRXBGk2Bsk/1jVLcGh9fVwcZMWnudw6Fi6A3QnuhYpiAqNaxq2rTjgs9hdGaTcZUMycMrx/etAskPRxbDoQoAU20tKsJwu/jK6eI+QVHmUgGbgdzvw6k58hgO/5sCrO/DpJn7NxKs78GsmPs3Aq5n4MPBrBl4M/JqJ3wY/Gn4M7KpnTirCQ5RaZ0ZJtLxk2OVkWOHBLifDqiDDriDTLieBQLiI7vigVdX/OJxgmjXuRKvokoLt90fuUtNOrC/S9dCg6aH31LXj45F5J7xqOgrw24C3Aq2iHK2iHCqPoVUcQy8/hlZ5LNQsTHk5VBw7PpSXg68y8pkjv8E1/YTiwXCRYtX0CUWImicOXG4IBlBeL/i9UMur8ntD/aZEBl9o/z4fyu9Dc7nAEw/xCZFXrdp0RWZXbFuhVVseWa8JjWS2FUkKrWDixIn84he/oLi4mDVr1rBu3TrS09NxOBy8/fbbfP311zG9T1lZWa3bnX/++UyfPp1bb701qvioqg+FxhQfxcJl6gzIimNAVqhYzrIVelwSVkVpk5sej2WfpyQ6OSWxaf88jbl09wVtjniDlFRalHiDkYcUj0TGLf7jDXIkkIJlAgnhoQ6mDi5Dx2nquIzwrcnhZ1kSw+NJcR5U0I8zfJXmNLTQuA5OK4Aj4MXp9+L0V+DwVeD0leOoLMdZWYqjvAzNW06x5qZAj6fAOD4cNBLZ7TwFrx5dZ+K2A2QEy8gIHiMjWEZ6oAxPhQ9n0IszUIEz4MUZ9OLyVeK0fDjtAC4rEHq1AzitAKayOPGvHdAMyhxxlDniOGbGhcfjOWZ66pgXzzGHh0BUfPHhISsyRzMVWrJCT1ahRM/xqiYtXBdnAFr4rjodha7s0GBbx1/9FrrXOj5PWeiqFJ0j2OhYmo6lm1haEpbWBVszsPTw4Daw48LrYGBpGhY6tqZho+HGIl75ibd8JFhe4gIVJJSVE19QRrw/n/jgAeKDlSQEKokPeokLVpIQrCQ+WIlHs9GczujbwmtJzDgcoWR8YkJ2ONDOOg/t9N4xfccbQ5JCK+jbty/l5eV07dqVrKwsrrrqKm688UbGjh3LWWedxRlnnBHT+9S1Xd++fWvtF6GuPhRamqFrpCe4KPSeHJfsLlMnK8FJVj0neghV1h/zWZR4LUp9QZxG6KQfemjx+HgsibIlyptPqWO+Uir8gGWoWC+/PBB+TaGgPMDe8gBl/hjqXU6gAU4dXLrCRFFha3jtuj+riSLRsEnQbRJ1m1N0iz66RaJWQbxuoTscKIcL2+EEhxPb4UCZTpSuo1SoWFAROu4QKhpUSmETWuZ0uamorMRWCluF1rPt8F151ecpsG0b27LCg41t2Zjh28QNw8AwjdCroYXv8AvfDVh1158eHteI3P3nDdgc89uUByyO+W2K/Bb/8VuU++1aiz+r01HhRBZ61cKDrkKDhkJTdni5jaYUut9G99loto2mbK779BAjWyEpSEVzB9VR4pP+FFpHe8fnq/Y8jc+y8QdV6IHMyLiNMy6eoiOl+MLTfktFHtoM2Io4hx562t9pRJ76rz7uakQTME3R3sewPpat8CSlkHc4P5Q4/KE21MrDSaTcbxO0VVTiiyS9GvNC40oRToihW84v7pXE2acmNim+DlHRvGvXLlasWIFt24wdO5YrrrgiankgEOB3v/sdX375JYmJidx1110NVsQKIZqm6uqmPqGTbtPqhDo7Q9dIcpuhK9D2DqaR2iQp2LbN8uXLmTNnDmlpacyaNYucnBy6d+8eWWfz5s3Ex8ezdOlS3n77bVatWsXdd9/dFuG1u08++YQ777wzap7L5eLll19up4iEEJ1VmySFffv2RcrXAUaMGMH27dujksK///1vJk+eDMCwYcN45plnUEo1+vLzu1gaduaZZ7Jhw4aoeR2l+Oi7eDyFEE3XJkmhuLiYtLS0yHRaWlqNB7aqr2MYBnFxcZSVldW4e2bjxo1s3LgRgEWLFpGenh61PHS7oY0jhidWTbNj17O3d3yBQICEhISov10V0zRrHPuOROJrvo4eo8TXOjr2WbEWubm55ObmRqZPrGhSSuH1eqmoqKj3KsPlcrXJPf9N1d7xKaXQdR23211rZV5HruQDia8ldPQYJb6ma/eK5tTUVIqKiiLTRUVFkadxT1wnLS0NpGTDYwAACxJJREFUy7KoqKggMbHxNeuapuHxeBpcryP/waDjxyeEODm1ybPx2dnZHDp0iPz8fILBINu2batx//w555zDG2+8AcC7777LgAED5NF1IYRoY21ypWAYBtOmTWP+/PnYts2YMWPo0aMHq1evJjs7m5ycHC688EJ+97vf8ZOf/ISEhATuuuuutghNCCFENW1WpzBkyBCGDBkSNe/aa6+NjDudTn72s5+1VThCCCFq8Z1/olkIIUTL6Rzt7dbivvvua+8Q6iXxNY/E13wdPUaJr3V02qQghBCiJkkKQgghIox58+bNa+8g2kuvXr3aO4R6SXzNI/E1X0ePUeJreVLRLIQQIkKKj4QQQkRIUhBCCBHxnWsQr7E6cuc+hYWFPPHEExw5cgRN08jNzeWyyy6LWuejjz5i8eLFkZiGDh3KpEmT2iQ+gB//+Me43W50PdRt4aJFi6KWK6VYsWIFO3fuxOVyMXPmzDYrRz148CCPPPJIZDo/P59rrrmGcePGRea1x/F78skn2bFjB8nJySxZsgSAY8eO8cgjj1BQUEBGRgZ33303CQk1+/984403WLt2LRDqjnX06NGtHtvKlSt5//33MU2TrKwsZs6cSXx8fI1tG/outGaML774Ips2bYq0mnz99dfXeBgWGv5/b634HnnkkUgvkFW9Ff7mN7+psW1bHcNmUScxy7LU//t//08dPnxYBQIB9fOf/1zl5eVFrfPa/2/vXkOa/OI4gH/VvKSDOS94S9NKAzOzUAzTrCTfJBlSUmEiWRYGFtIw39QLNQm1LDQyEbIgkCCTgtIwLySCqXktM6+EmqLTOculc+f/Qnr+TqeubM9Kf59XY+cZz2+Hc/Z7nrPt/F69Yjk5OYwxxt6+fctu3rzJW3wSiYR1dnYyxhj7/v07i4uLWxBfS0sLS01N5S2m+WJjY5lUKl20va6ujqWkpDClUsk+ffrEEhMTeYzufzMzM+zMmTNsaGhI5Xld9F9rayvr7Oxk8fHx3HOPHj1ihYWFjDHGCgsL2aNHjxa8TiaTsQsXLjCZTKbyWNuxNTQ0MIVCwcWpLjbGlh8L2oyxoKCAFRUVLfk6Tea7tuKbKz8/nz158kRtG199uBKrevlobnGfdevWccV95qqtreWuxnbv3o2WlhbeCsuIRCLuqnr9+vVwcHCARCLh5dx/Sm1tLfbu3Qs9PT24ubnh27dvGB0d5T2O5uZm2Nrawtramvdzz+fu7r7gLuDdu3cIDAwEAAQGBi4Yh8DsVa6npycEAgEEAgE8PT3R0NCg9dh27NgBA4PZsptubm46H4PqYtSEJvNd2/ExxlBdXY09e/b88fPyZVUvH/3J4j7aNjQ0hO7ubmzZsmVBW3t7O8RiMUQiEU6dOgVHR0deY0tJSQEAHDx4UKWWBTDbf3MLiVhaWkIikUAkEvEaY1VV1aITUdf9BwBSqZTrE3Nzc0il0gXHzB+vFhYWvH9Av3nzBn5+fou2LzUWtK24uBiVlZXYtGkTIiMjF3wwazLfte3jx48QCoWws7Nb9Bhd9qEmVnVS+FfI5XJkZGQgKioKpqamKm0uLi64e/cuTExMUF9fj7S0NNy5c4e32JKSkmBhYQGpVIrk5GTY29vD3d2dt/NrQqFQoK6uDidPnlzQpuv+U0dPT++v3Bb+6dOnMDAwQEBAgNp2XY6F4OBg7ruggoICPHz4ELGxsbyc+1csdXEC/BvzaVUvH/1KcR8AKyru87sUCgUyMjIQEBAAX1/fBe2mpqYwMTEBMLvT7MzMDMbHx3mL72d/CYVC+Pj4oKOjY0H73GJA6vpY296/fw8XFxeYm5svaNN1//0kFAq5ZbXR0VG1d6Lzx6tEIuGtL8vLy1FXV4e4uLhFE9ZyY0GbzM3Noa+vD319fQQFBaGzs1NtfMvNd22amZlBTU3NkndauuxDTa3qpPC3F/dhjOHevXtwcHBASEiI2mPGxsa47zg6OjqgVCp5S1pyuRyTk5Pc46amJjg5Oakc4+3tjcrKSjDG0N7eDlNT079q6UiX/TeXt7c3KioqAAAVFRXw8fFZcIyXlxcaGxsxMTGBiYkJNDY2wsvLS+uxNTQ0oKioCAkJCTA2NlZ7jCZjQZvmfk9VU1OjdglQk/muTc3NzbC3t1db0xzQfR9qatX/o7m+vh75+flccZ+wsDCV4j5TU1PIyspCd3c3V9zHxsaGl9ja2tpw9epVODk5cYnoxIkT3JV3cHAwXr16hZKSEhgYGMDIyAiRkZHYunUrL/ENDg4iPT0dwOxVkL+/P8LCwlBSUsLFxxhDXl4eGhsbYWRkhNjYWGzevJmX+IDZyRUbG4usrCxu6W1ufLrov8zMTHz48AEymQxCoRDh4eHw8fHBrVu3MDw8rPKT1M7OTrx+/Rrnz58HMLumX1hYCGD2J6n79+/XemyFhYVQKBTcGr2rqytiYmIgkUiQk5ODxMTERceCNqiLsbW1FT09PdDT04O1tTViYmIgEolUYgTUz3c+4jtw4ACys7Ph6uqK4OBg7lhd9eFKrPqkQAghRHOrevmIEELIr6GkQAghhENJgRBCCIeSAiGEEA4lBUIIIRxKCoTwJDw8HF+/ftV1GIQsiba5IGvShQsXMDY2Bn39/6+L9u3bh+joaB1GpV5xcTFGRkZw8uRJXLt2DadPn8bGjRt1HRZZpSgpkDUrISEBnp6eug5jWV1dXdi1axeUSiX6+vqwYcMGXYdEVjFKCoTMU15ejtLSUjg7O6OyshIikQjR0dHYvn07gNl/qebm5qKtrQ0CgQChoaHcbpdKpRLPnj1DWVkZpFIp7OzsIBaLuZ1km5qacP36dYyPj8Pf3x/R0dHLbqvS1dWFo0ePor+/H9bW1tw214RoAyUFQtT4/PkzfH19kZeXh5qaGqSnpyM7OxsCgQC3b9+Go6MjcnJy0N/fj6SkJNja2sLDwwMvXrxAVVUVEhMTYWdnh97eXpX9hOrr65GamorJyUkkJCTA29tb7f5G09PTOHv2LBhjkMvlEIvFUCgUUCqViIqKwuHDh//KLRLIv4+SAlmz0tLSVK66IyIiuCt+oVCIQ4cOQU9PD35+fnj+/Dnq6+vh7u6OtrY2XLlyBUZGRnB2dkZQUBAqKirg4eGB0tJSREREwN7eHgDg7Oyscs4jR47AzMwMZmZm2LZtG3p6etQmBUNDQzx48AClpaX48uULoqKikJycjOPHj6utuUHIn0JJgaxZYrF40e8ULCwsVJZ1rK2tIZFIMDo6CoFAgPXr13NtVlZW3FbOIyMjS26oOHd7b2NjY8jlcrXHZWZmoqGhAT9+/IChoSHKysogl8vR0dEBOzs7pKam/tJ7JURTlBQIUUMikYAxxiWG4eFheHt7QyQSYWJiApOTk1xiGB4e5vbJt7S0xODg4Iq3RL506RKUSiViYmJw//591NXVobq6GnFxcSt7Y4Qsg/6nQIgaUqkUL1++hEKhQHV1Nfr6+rBz505YWVlh69atePz4MaamptDb24uysjKuWllQUBAKCgowMDAAxhh6e3shk8l+K4a+vj7Y2NhAX18f3d3dvG5JTtYuulMga9aNGzdU/qfg6ekJsVgMYLamwMDAAKKjo2Fubo74+HiuOM/FixeRm5uLc+fOQSAQ4NixY9wyVEhICKanp5GcnAyZTAYHBwdcvnz5t+Lr6uqCi4sL9zg0NHQlb5cQjVA9BULm+fmT1KSkJF2HQgjvaPmIEEIIh5ICIYQQDi0fEUII4dCdAiGEEA4lBUIIIRxKCoQQQjiUFAghhHAoKRBCCOH8B1+FPCeyAWkvAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jlqofAdnq58p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}