cd_Classifier_CNN.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Manik400/ML_DL/blob/main/cd_Classifier_CNN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "XiwJt5WU3FRS"
      },
      "outputs": [],
      "source": [
        "# Dataset - https://www.kaggle.com/datasets/salader/dogs-vs-cats"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "V6uVvp4c2teB",
        "outputId": "6fe8c64a-a23c-4950-f7e9-c7d83e6fd66e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (1.6.14)\n",
            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.16.0)\n",
            "Requirement already satisfied: certifi>=2023.7.22 in /usr/local/lib/python3.10/dist-packages (from kaggle) (2024.2.2)\n",
            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.8.2)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.31.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from kaggle) (4.66.4)\n",
            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle) (8.0.4)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.0.7)\n",
            "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from kaggle) (6.1.0)\n",
            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->kaggle) (0.5.1)\n",
            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle) (1.3)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.7)\n",
            "cp: cannot stat 'kaggle.json': No such file or directory\n",
            "chmod: cannot access '/root/.kaggle/kaggle.json': No such file or directory\n"
          ]
        }
      ],
      "source": [
        "!pip install kaggle\n",
        "!mkdir -p ~/.kaggle\n",
        "!cp kaggle.json ~/.kaggle/\n",
        "! chmod 600 ~/.kaggle/kaggle.json"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J76Vmiwp1whT",
        "outputId": "3d6e2059-15f6-4ee0-9059-72916c384be2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset URL: https://www.kaggle.com/datasets/salader/dogs-vs-cats\n",
            "License(s): unknown\n",
            "Downloading dogs-vs-cats.zip to /content\n",
            " 99% 1.06G/1.06G [00:12<00:00, 45.2MB/s]\n",
            "100% 1.06G/1.06G [00:13<00:00, 87.7MB/s]\n"
          ]
        }
      ],
      "source": [
        "# downloading the data from kaggle\n",
        "!kaggle datasets download -d salader/dogs-vs-cats"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "SxAyKow26y1r"
      },
      "outputs": [],
      "source": [
        "#extrating th data from zip file\n",
        "import zipfile\n",
        "zipref = zipfile.ZipFile('/content/dogs-vs-cats.zip', 'r')\n",
        "zipref.extractall('/content')\n",
        "zipref.close()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "-ZAW6RwS6zJz"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from keras import Sequential\n",
        "from keras.layers import Dense,Conv2D,MaxPooling2D,Flatten,BatchNormalization,Dropout\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "from tensorflow.keras.callbacks import EarlyStopping"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3ePtEQMG6zeQ",
        "outputId": "024a6676-cea1-4cc4-a08f-cb6ae69ba267"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 20000 images belonging to 2 classes.\n",
            "Found 5000 images belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "#genrators to generat ata from images\n",
        "\n",
        "# Create an ImageDataGenerator for the training set with augmentation\n",
        "train_datagen = ImageDataGenerator(\n",
        "    rescale=1./255,       # Normalize the data to [0, 1]\n",
        "    rotation_range=20,\n",
        "    width_shift_range=0.2,\n",
        "    height_shift_range=0.2,\n",
        "    shear_range=0.2,\n",
        "    zoom_range=0.2,\n",
        "    horizontal_flip=True,\n",
        "    fill_mode='nearest'\n",
        ")\n",
        "\n",
        "# Create an ImageDataGenerator for the validation set without augmentation\n",
        "validation_datagen = ImageDataGenerator(rescale=1./255)\n",
        "\n",
        "# Load the training data with augmentation\n",
        "train_ds = train_datagen.flow_from_directory(\n",
        "    '/content/train',\n",
        "    target_size=(256, 256),\n",
        "    batch_size=32,\n",
        "    class_mode='binary'\n",
        ")\n",
        "\n",
        "# Load the validation data without augmentation\n",
        "validation_ds = validation_datagen.flow_from_directory(\n",
        "    '/content/test',\n",
        "    target_size=(256, 256),\n",
        "    batch_size=32,\n",
        "    class_mode='binary'\n",
        ")\n",
        "\n",
        "# train_ds = keras.utils.image_dataset_from_directory(\n",
        "#     directory = '/content/train',\n",
        "#     labels = 'inferred',\n",
        "#     label_mode = 'int',\n",
        "#     batch_size = 32,\n",
        "#     image_size = (256,256)\n",
        "# )\n",
        "\n",
        "# validation_ds = keras.utils.image_dataset_from_directory(\n",
        "#     directory = '/content/test',\n",
        "#     labels = 'inferred',\n",
        "#     label_mode = 'int',\n",
        "#     batch_size = 32,\n",
        "#     image_size = (256,256)\n",
        "# )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "qLu9wTkTTCCv"
      },
      "outputs": [],
      "source": [
        "#normalize th data from {0 - 255} to {0 - 1}\n",
        "# def process(image,label):\n",
        "#   image = tf.cast(image/255. , tf.float32 )\n",
        "#   return image,label\n",
        "\n",
        "# train_ds = train_ds.map(process)\n",
        "# validation_ds = validation_ds.map(process)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "_FcGcmkescVi"
      },
      "outputs": [],
      "source": [
        "# create CNN model\n",
        "\n",
        "model = Sequential()\n",
        "\n",
        "model.add(Conv2D(32,kernel_size=(3,3),padding='valid',activation='relu',input_shape=(256,256,3)))\n",
        "model.add(BatchNormalization())\n",
        "model.add(MaxPooling2D(pool_size=(2,2),strides=2,padding='valid'))\n",
        "\n",
        "model.add(Conv2D(64,kernel_size=(3,3),padding='valid',activation='relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(MaxPooling2D(pool_size=(2,2),strides=2,padding='valid'))\n",
        "\n",
        "model.add(Conv2D(128,kernel_size=(3,3),padding='valid',activation='relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(MaxPooling2D(pool_size=(2,2),strides=2,padding='valid'))\n",
        "\n",
        "model.add(Flatten())\n",
        "\n",
        "model.add(Dense(128,activation='relu'))\n",
        "model.add(Dropout(0.1))\n",
        "model.add(Dense(64,activation='relu'))\n",
        "model.add(Dropout(0.1))\n",
        "model.add(Dense(1,activation='sigmoid'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QvCmGlD9VjnP",
        "outputId": "22b5dd0f-00aa-4f1f-c0b4-1d5616a531be"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 254, 254, 32)      896       \n",
            "                                                                 \n",
            " batch_normalization (Batch  (None, 254, 254, 32)      128       \n",
            " Normalization)                                                  \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2  (None, 127, 127, 32)      0         \n",
            " D)                                                              \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 125, 125, 64)      18496     \n",
            "                                                                 \n",
            " batch_normalization_1 (Bat  (None, 125, 125, 64)      256       \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPoolin  (None, 62, 62, 64)        0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 60, 60, 128)       73856     \n",
            "                                                                 \n",
            " batch_normalization_2 (Bat  (None, 60, 60, 128)       512       \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPoolin  (None, 30, 30, 128)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 115200)            0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 128)               14745728  \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 128)               0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 64)                8256      \n",
            "                                                                 \n",
            " dropout_1 (Dropout)         (None, 64)                0         \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 1)                 65        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 14848193 (56.64 MB)\n",
            "Trainable params: 14847745 (56.64 MB)\n",
            "Non-trainable params: 448 (1.75 KB)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "v4dta_WKVlS0"
      },
      "outputs": [],
      "source": [
        "model.compile(optimizer = 'adam' , loss ='binary_crossentropy' , metrics = ['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iJkLR7WL18L2",
        "outputId": "c91a69ea-07e4-468f-beeb-0a266865c8bd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "625/625 [==============================] - 367s 571ms/step - loss: 1.1615 - accuracy: 0.5580 - val_loss: 0.6518 - val_accuracy: 0.6254\n",
            "Epoch 2/10\n",
            "625/625 [==============================] - 351s 562ms/step - loss: 0.6546 - accuracy: 0.6281 - val_loss: 0.6621 - val_accuracy: 0.5826\n",
            "Epoch 3/10\n",
            "625/625 [==============================] - 353s 565ms/step - loss: 0.6162 - accuracy: 0.6636 - val_loss: 0.5461 - val_accuracy: 0.7256\n",
            "Epoch 4/10\n",
            "625/625 [==============================] - 354s 566ms/step - loss: 0.5689 - accuracy: 0.7055 - val_loss: 0.5507 - val_accuracy: 0.7222\n",
            "Epoch 5/10\n",
            "625/625 [==============================] - 351s 561ms/step - loss: 0.5598 - accuracy: 0.7194 - val_loss: 1.1494 - val_accuracy: 0.5130\n",
            "Epoch 6/10\n",
            "625/625 [==============================] - 353s 565ms/step - loss: 0.5444 - accuracy: 0.7237 - val_loss: 0.4855 - val_accuracy: 0.7688\n",
            "Epoch 7/10\n",
            "625/625 [==============================] - 358s 572ms/step - loss: 0.5105 - accuracy: 0.7520 - val_loss: 0.4644 - val_accuracy: 0.7800\n",
            "Epoch 8/10\n",
            "625/625 [==============================] - 348s 558ms/step - loss: 0.4834 - accuracy: 0.7713 - val_loss: 0.4874 - val_accuracy: 0.7558\n",
            "Epoch 9/10\n",
            "625/625 [==============================] - 347s 556ms/step - loss: 0.4673 - accuracy: 0.7850 - val_loss: 0.5797 - val_accuracy: 0.7058\n",
            "Epoch 10/10\n",
            "625/625 [==============================] - 349s 559ms/step - loss: 0.4354 - accuracy: 0.8020 - val_loss: 0.4416 - val_accuracy: 0.7920\n"
          ]
        }
      ],
      "source": [
        "\n",
        "early_stopping = EarlyStopping(\n",
        "    monitor='val_loss',   # Monitor the validation loss\n",
        "    patience=3,           # Number of epochs to wait for improvement\n",
        "    restore_best_weights=True  # Restore the best model weights\n",
        ")\n",
        "\n",
        "\n",
        "# history = model.fit(train_ds,epochs=10,validation_data=validation_ds)\n",
        "history = model.fit(\n",
        "    train_ds,\n",
        "    epochs=10,  # You can set a higher number of epochs\n",
        "    validation_data=validation_ds,\n",
        "    callbacks=[early_stopping]  # Add the early stopping callback\n",
        ")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "Jp5QNOsK2Oc6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 843
        },
        "outputId": "1c99c656-db13-433d-9bf8-983cd0258f65"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABkqklEQVR4nO3dd3zV5fn/8dfJyd6EQMIIO+w9BRdWEAGpWKtUqQqOthTqyE+ttIqrlQ4HraJUv1qx1YoLUEAUUcCBhGEUhDADYSVhJSE7Oef8/vhwDgkEyDgnnzPez8fjPHJyzmdcIUCu3Pd1X7fF4XA4EBERETFJkNkBiIiISGBTMiIiIiKmUjIiIiIiplIyIiIiIqZSMiIiIiKmUjIiIiIiplIyIiIiIqZSMiIiIiKmCjY7gLqw2+0cOnSImJgYLBaL2eGIiIhIHTgcDk6ePEnr1q0JCjr3+IdPJCOHDh0iJSXF7DBERESkAfbv30/btm3P+b5PJCMxMTGA8cXExsaaHI2IiIjURWFhISkpKa6f4+fiE8mIc2omNjZWyYiIiIiPuVCJhQpYRURExFRKRkRERMRUSkZERETEVD5RMyIiIu7jcDioqqrCZrOZHYr4OKvVSnBwcKPbbigZEREJIBUVFRw+fJiSkhKzQxE/ERkZSatWrQgNDW3wNZSMiIgECLvdTlZWFlarldatWxMaGqpGktJgDoeDiooKjhw5QlZWFqmpqedtbHY+SkZERAJERUUFdrudlJQUIiMjzQ5H/EBERAQhISHs27ePiooKwsPDG3QdFbCKiASYhv72KlIbd/x90t9IERERMZWSERERETGVkhEREQk4HTp0YM6cOaZfQwwqYBUREa83cuRI+vfv77Yf/uvXrycqKsot15LGC+iRkQVbFnDH4jtYf3C92aGIiEgjOZu51UWLFi20osiLBHQy8u7Wd3kt4zU+z/rc7FBEREzhcDgorihu8ofD4ahzjFOmTGH16tX84x//wGKxYLFY2Lt3L6tWrcJisfDxxx8zaNAgwsLC+Oqrr9i9ezfXXnstSUlJREdHM2TIED777LMa1zxzisVisfB///d/XHfddURGRpKamsqHH35Yrz/L7Oxsrr32WqKjo4mNjeXGG28kNzfX9f7333/PFVdcQUxMDLGxsQwaNIgNGzYAsG/fPiZMmECzZs2IioqiV69eLFu2rF7392UBPU0zrM0w3t/2PumH0s0ORUTEFCWVJUTPjm7y+xbNLCIqtG7TJP/4xz/YsWMHvXv35oknngCMkY29e/cC8NBDD/H000/TqVMnmjVrxv79+xk3bhx//vOfCQsL44033mDChAls376ddu3anfM+jz/+OH/729/4+9//zvPPP8/kyZPZt28fCQkJF4zRbre7EpHVq1dTVVXF9OnTmTRpEqtWrQJg8uTJDBgwgJdeegmr1UpGRgYhISEATJ8+nYqKCtasWUNUVBRbt24lOrrpvy9mCexkpO0wANYdWGdyJCIici5xcXGEhoYSGRlJcnLyWe8/8cQTjB492vV5QkIC/fr1c33+5JNPsnDhQj788ENmzJhxzvtMmTKFm266CYCnnnqKf/7zn6Snp3P11VdfMMaVK1eyefNmsrKySElJAeCNN96gV69erF+/niFDhpCdnc0DDzxA9+7dAUhNTXWdn52dzfXXX0+fPn0A6NSp0wXv6U8COhkZ2GogQZYgDp48yMHCg7SJbWN2SCIiTSoyJJKimUWm3NddBg8eXOPzoqIiHnvsMZYuXcrhw4epqqqitLSU7Ozs816nb9++rudRUVHExsaSl5dXpxi2bdtGSkqKKxEB6NmzJ/Hx8Wzbto0hQ4aQlpbGnXfeyX/+8x9GjRrFDTfcQOfOnQG4++67mTZtGp9++imjRo3i+uuvrxGPvwvompHo0Gh6t+wNQPpBTdWISOCxWCxEhUY1+cOde+KcuSrm/vvvZ+HChTz11FN8+eWXZGRk0KdPHyoqKs57HeeUSfU/G7vd7rY4H3vsMX788UfGjx/P559/Ts+ePVm4cCEAd955J3v27OGWW25h8+bNDB48mOeff95t9/Z2AZ2MgFE3ArDuoKZqRGqoyIdPLoLNT5odiQihoaHYbLY6Hfv1118zZcoUrrvuOvr06UNycrKrvsRTevTowf79+9m/f7/rta1bt5Kfn0/Pnj1dr3Xt2pX77ruPTz/9lJ/97Gf8+9//dr2XkpLCb37zGz744AP+3//7f7zyyisejdmbBHwyMrTNUEDJiMhZDn8Cx9bBjn+aHYkIHTp0YN26dezdu5ejR4+ed8QiNTWVDz74gIyMDL7//ntuvvlmt45w1GbUqFH06dOHyZMns2nTJtLT07n11lu5/PLLGTx4MKWlpcyYMYNVq1axb98+vv76a9avX0+PHj0AuPfee/nkk0/Iyspi06ZNfPHFF673AkHAJyPOkZENhzZgs9ct6xYJCPk/GB/Lj0LZEXNjkYB3//33Y7Va6dmzJy1atDhv/cezzz5Ls2bNGDFiBBMmTGDMmDEMHDjQo/FZLBYWL15Ms2bNuOyyyxg1ahSdOnViwYIFAFitVo4dO8att95K165dufHGGxk7diyPP/44ADabjenTp9OjRw+uvvpqunbtyosvvujRmL2JxVGfxd4mKSwsJC4ujoKCAmJjY916bZvdRtxf4iiuLGbztM2uGhKRgLdqAhxaYjy/chUkXW5mNOIGZWVlZGVl0bFjxwZv9S5ypvP9varrz++AHxmxBlkZ3NqoxNYSX5Fq8r8//bxwm3lxiIjfC/hkBE5P1WhFjcgpFSeg5HQhHgVbzYtFRPyekhGqNT9TEauIIX9zzc+VjIiIBykZ4fSKms15mymuKDY5GhEvcOJU8WpEK+NjoZIREfEcJSNA29i2tI5pjd1hZ9PhTWaHI2I+Z71Iyg3Gx9LDRt8REREPUDJyipqfiVTjXNbb8lKIOLVNQoGKWEXEM5SMnKLmZyKn2G2Qv8V4Ht8X4k51j9RUjYh4iJKRU7SiRuSUot1gKwFrBER3Pp2MqIhVRDxEycgpg1sPxoKF7IJscopyzA5HxDzOKZq43hBkrZaMaJpGfFuHDh2YM2eO63OLxcKiRYvOefzevXuxWCxkZGQ06r7uus6FTJkyhYkTJ3r0Hp6iZOSUmLAYerYw/tNV8zMJaM5kpFk/42Psqf0xNE0jfubw4cOMHTvWrdesLSFISUnh8OHD9O6tDt/nomSkGk3ViHA6GYnva3x0jowU74PKInNiEvGA5ORkwsLCPH4fq9VKcnIywcHBHr+Xr1IyUo2an4kAJ04t63UmI2HNIbyl8bww05yYJKC9/PLLtG7d+qydd6+99lpuv/12AHbv3s21115LUlIS0dHRDBkyhM8+++y81z1zmiY9PZ0BAwYQHh7O4MGD+e6772ocb7PZuOOOO+jYsSMRERF069aNf/zjH673H3vsMebPn8/ixYuxWCxYLBZWrVpV6zTN6tWrGTp0KGFhYbRq1YqHHnqIqqoq1/sjR47k7rvv5sEHHyQhIYHk5GQee+yxev25lZeXc/fdd9OyZUvCw8O55JJLWL9+vev9EydOMHnyZFq0aEFERASpqan8+9//BqCiooIZM2bQqlUrwsPDad++PbNnz67X/etDaVo1zhU16w+tx+6wE2RRriYBpqIAivcaz5v1Pf16bE8oyzP2qGk+2JTQxEMcDqNgualZI8FiqdOhN9xwA7/73e/44osvuPLKKwE4fvw4y5cvZ9myZQAUFRUxbtw4/vznPxMWFsYbb7zBhAkT2L59O+3atbvgPYqKirjmmmsYPXo0//3vf8nKyuKee+6pcYzdbqdt27a8++67NG/enG+++YZf/epXtGrVihtvvJH777+fbdu2UVhY6PqhnpCQwKFDh2pc5+DBg4wbN44pU6bwxhtvkJmZyV133UV4eHiNhGP+/PmkpaWxbt061q5dy5QpU7j44osZPXp0nf7cHnzwQd5//33mz59P+/bt+dvf/saYMWPYtWsXCQkJPPLII2zdupWPP/6YxMREdu3aRWlpKQD//Oc/+fDDD3nnnXdo164d+/fvZ//+/Re4Y8MpGammd8veRIZEUlheyPaj2+nRoofZIYk0rYJTS3ojUyC02enX43pA3iqtqPFHthJ4J7rp73tjEQRH1enQZs2aMXbsWN566y1XMvLee++RmJjIFVdcAUC/fv3o16+f65wnn3yShQsX8uGHHzJjxowL3uOtt97Cbrfz6quvEh4eTq9evThw4ADTpk1zHRMSEsLjjz/u+rxjx46sXbuWd955hxtvvJHo6GgiIiIoLy8nOTn5nPd68cUXSUlJ4YUXXsBisdC9e3cOHTrE73//e2bNmkVQkPGLcN++fXn00UcBSE1N5YUXXmDlypV1SkaKi4t56aWXeP311111Ma+88gorVqzg1Vdf5YEHHiA7O5sBAwYweLDxC0aHDh1c52dnZ5Oamsoll1yCxWKhffv2F7xnY+hX/2qCg4IZ1GoQoKkaCVBnTtE4xWp5r5hr8uTJvP/++5SXlwPw5ptv8otf/ML1g7uoqIj777+fHj16EB8fT3R0NNu2bSM7O7tO19+2bRt9+/YlPDzc9drw4cPPOm7u3LkMGjSIFi1aEB0dzcsvv1zne1S/1/Dhw7FUGxm6+OKLKSoq4sCBA67X+vat+e+wVatW5OXl1ekeu3fvprKykosvvtj1WkhICEOHDmXbNmNl3LRp03j77bfp378/Dz74IN98843r2ClTppCRkUG3bt24++67+fTTT+v1NdaXRkbOMLTNUL7M/pJ1B9Yxpf8Us8MRaVpnFq86qdeI/7JGGqMUZty3HiZMmIDD4WDp0qUMGTKEL7/8kueee871/v3338+KFSt4+umn6dKlCxEREfz85z+noqLCbSG//fbb3H///TzzzDMMHz6cmJgY/v73v7NunWd+eQ0JCanxucViOatupjHGjh3Lvn37WLZsGStWrODKK69k+vTpPP300wwcOJCsrCw+/vhjPvvsM2688UZGjRrFe++957b7V1fvkZE1a9YwYcIEWrdufcE12mAsnbr55pvp2rUrQUFB3HvvvQ0MtWm4VtQc0ooaCUBnLut1cq2o2QO2sqaNSTzLYjGmS5r6Ucd6Eafw8HB+9rOf8eabb/K///2Pbt26MXDgQNf7X3/9NVOmTOG6666jT58+JCcns3fv3jpfv0ePHvzwww+UlZ3++/3tt9/WOObrr79mxIgR/Pa3v2XAgAF06dKF3bt31zgmNDQUm812wXutXbsWh8NR49oxMTG0bdu2zjGfT+fOnQkNDeXrr792vVZZWcn69evp2bOn67UWLVpw22238d///pc5c+bw8ssvu96LjY1l0qRJvPLKKyxYsID333+f48ePuyW+M9U7GSkuLqZfv37MnTu3TseXl5fTokULHn744Rrzed7KuaLmh9wfKK0sNTkakSbksJ97ZCQ8CULijWMKdzR5aCJgTNUsXbqU1157jcmTJ9d4LzU1lQ8++ICMjAy+//57br755nqNItx8881YLBbuuusutm7dyrJly3j66afPuseGDRv45JNP2LFjB4888kiN1Slg1F388MMPbN++naNHj1JZWXnWvX7729+yf/9+fve735GZmcnixYt59NFHSUtLc007NVZUVBTTpk3jgQceYPny5WzdupW77rqLkpIS7rjjDgBmzZrF4sWL2bVrFz/++CNLliyhRw+jVvLZZ5/lf//7H5mZmezYsYN3332X5ORk4uPj3RLfmeo9TTN27Nh6NYnp0KGDa+nTa6+9Vt/bNbmU2BSSopLILc5l0+FNXNzu4gufJOIPirKgqhiCwiAmteZ7FosxOnL0G2Oqplnf2q8h4kE/+clPSEhIYPv27dx888013nv22We5/fbbGTFiBImJifz+97+nsLCwzteOjo7mo48+4je/+Q0DBgygZ8+e/PWvf+X66693HfPrX/+a7777jkmTJmGxWLjpppv47W9/y8cff+w65q677mLVqlUMHjyYoqIivvjiixqFoQBt2rRh2bJlPPDAA/Tr14+EhATuuOMOHn744Yb9wZzDX/7yF+x2O7fccgsnT55k8ODBfPLJJzRrZhSnh4aGMnPmTPbu3UtERASXXnopb7/9NgAxMTH87W9/Y+fOnVitVoYMGcKyZcvcliydyeKoPk5U35MtFhYuXFjn9rMjR46kf//+Ndrx1qa8vNxVpARQWFhISkoKBQUFxMbGNjTcOrv27Wv5cPuHPHvVs9w3/D6P30/EK+xfCF/+DBIGwdUbzn5/3V2w+/+g9yzo+/jZ74vXKysrIysri44dO9Yo1BRpjPP9vSosLCQuLu6CP7+9cjXN7NmziYuLcz1SUlKa9P7OuhGtqJGAcq4pGidnW3gVsYqIm3llMjJz5kwKCgpcD082WqmNs/mZkhEJKOda1uvkLGLVHjUi4mZeubQ3LCysSfYLOJchrYdgwcLe/L3kFefRMqqlabGINJlzraRxciUjO8BeCUEhtR8nIlJPXjkyYra48Di6J3YHtGmeBIjKIig6tUQxrk/tx0SmQHA0OKrg5O7ajxERaYB6JyNFRUVkZGS4NvzJysoiIyPD1YFu5syZ3HrrrTXOcR5fVFTEkSNHyMjIYOtW7x7qdU3VHNBUjQSA/M3Gx4jWEJ5Y+zEWC8QaSbqmakTEneqdjGzYsIEBAwYwYMAAANLS0hgwYACzZs0CjCZnZ7bGdR6/ceNG3nrrLQYMGMC4cePcEL7nqPmZBJQLFa86qROrX2jEIkqRs7jj71O9a0ZGjhx53hu//vrrZ73mi3/xnc3P0g+mawdf8X8XqhdxUjLi05ztxUtKSoiIiDA5GvEXJSXGrs9ntq+vD68sYPUGfVr2ITw4nPyyfHYe20m3xG5mhyTiOXUdGXFumFe4zbPxiEdYrVbi4+Ndm61FRkbW2KxNpD4cDgclJSXk5eURHx+P1Wpt8LWUjJxDiDWEga0G8s3+b0g/mK5kRPyXw1GPaZpTvUYKM8Fug6CG/+cj5nBubV/X3V9FLiQ+Pt7196qhlIycx7A2w/hm/zesO7iOW/rdYnY4Ip5RvA8qCyEoFGIvkHRHdTTaxdvKoHgvxHRukhDFfSwWC61ataJly5a17psiUh8hISGNGhFxUjJyHurEKgHBOSoS1/PCvUOCrMaKmvzvjboRJSM+y2q1uuWHiIg7qCrzPJzLe7/P+Z6yKm2bLn7qQp1XzxSnuhERcS8lI+fRIb4DLSJbUGmvJCMnw+xwRDyjrvUiTtqjRkTcTMnIeVgsFtcSXzU/E79V12W9TlreKyJupmTkAoa2NqZq1PxM/FJVMZzcaTxvyDSND/YQEhHvo2TkAjQyIn4t/0fAAeFJEF7HDSFjuoAlGKqKoOSAR8MTkcCgZOQChrQeAsDuE7s5WnLU5GhE3MxVL1LHKRowVtzEpBrPNVUjIm6gZOQCmkU0o2vzrgCsP7je5GhE3MxVL1LHKRon11SNkhERaTwlI3WgfiPit/LruazXSUWsIuJGSkbqQMmI+CWHA07Uc1mvk/aoERE3UjJSB87mZ+kH031yB2KRWpUcgMp8oxjV2TukruKq9RrRvwkRaSQlI3XQL7kfYdYwjpceZ/eJ3WaHI+IezimauB5gDa3fuTFdwRIEFSegLNf9sYlIQFEyUgeh1lAGtBoAaImv+JH6dl6tLjgCojoZz1U3IiKNpGSkjlzNzw6q+Zn4iRMNWNZbnfaoERE3UTJSR67mZypiFX/RmJERqFk3IiLSCEpG6si5oua7nO8oryo3ORqRRqoqhZPbjef17THiFKvlvSLiHkpG6qhTs040j2hOha2CH3J/MDsckcYp3AoOO4QlQnhyw66hxmci4iZKRurIYrG4lvhqqkZ8XvV6EYulYdeI7W58LMuD8mPuiUtEApKSkXpQ8zPxGw3tvFpdSDREtjOeF6iIVUQaTslIPbhGRrS8V3xdQ/ekOZOmakTEDZSM1IMzGdl5fCfHS4+bHI1IAzkcDduttzbao0ZE3EDJSD00j2xOl4QugHbwFR9Wesio8bBYTy/PbShXMqJpGhFpOCUj9aQiVvF5zlGR2G5gDW/ctZx72miaRkQaQclIPTmLWNWJVXyWu6Zo4PTISskBqCxs/PVEJCApGamn6itqtIOv+KQTjey8Wl1oM4hoZTzXVI2INJCSkXrql9yPkKAQjpYcJSs/y+xwROrPHct6q4vVHjUi0jhKRuopPDic/sn9AU3ViA+ylUNhpvG8sct6nbRHjYg0kpKRBnBN1ajfiPiawm3gsEFoAkS0cc81tbxXRBpJyUgDaEWN+KwT1aZoGtoG/kzaME9EGknJSAMMa2uMjGw6vIlKW6XJ0YjUQ74bi1ednCMjxXuhqsR91xWRgKFkpAFSE1KJD4+n3FauHXzFt7jawLthWa9TeAsIaw44oHC7+64rIgFDyUgDaAdf8VmeGBkBTdWISKPUOxlZs2YNEyZMoHXr1lgsFhYtWnTBc1atWsXAgQMJCwujS5cuvP766w0I1buo+Zn4nNIcKMsDS9DpqRV30YZ5ItII9U5GiouL6devH3Pnzq3T8VlZWYwfP54rrriCjIwM7r33Xu68804++eSTegfrTao3PxPxCc5RkZhUCI5077W1R42INEJwfU8YO3YsY8eOrfPx8+bNo2PHjjzzzDMA9OjRg6+++ornnnuOMWPG1Pf2XsM5TZN5NJP8snziw+PNDUjkQtzZBv5M2qNGRBrB4zUja9euZdSoUTVeGzNmDGvXrj3nOeXl5RQWFtZ4eJsWUS3oGN8RgA2HNpgcjUgdnHBz59XqnCMjJ3cZjdVEROrB48lITk4OSUlJNV5LSkqisLCQ0tLSWs+ZPXs2cXFxrkdKSoqnw2wQ5xJfNT8Tn+Cp4lWAiNYQEms0VDu50/3XFxG/5pWraWbOnElBQYHrsX//frNDqtXQ1lpRIz7CVnF67xh3Lut1sli0R42INFi9a0bqKzk5mdzc3Bqv5ebmEhsbS0RERK3nhIWFERYW5unQGs05MpJ+MB2Hw4HFXR0tRdytMBPslRASB5EeGmmM6wHHvtXyXhGpN4+PjAwfPpyVK1fWeG3FihUMHz7c07f2uAHJAwgOCia3OJfsgmyzwxE5t+pTNJ5KmrVHjYg0UL2TkaKiIjIyMsjIyACMpbsZGRlkZxs/jGfOnMmtt97qOv43v/kNe/bs4cEHHyQzM5MXX3yRd955h/vuu889X4GJIkIi6JtkzL9rqka8mifrRZzU+ExEGqjeyciGDRsYMGAAAwYMACAtLY0BAwYwa9YsAA4fPuxKTAA6duzI0qVLWbFiBf369eOZZ57h//7v/3x6WW91an4mPsETbeDP5FpRswPsVZ67j4j4nXrXjIwcORKHw3HO92vrrjpy5Ei+++67+t7KJwxrM4yXNrykkRHxbp5c1usU1Q6skWArgaI9ENvVc/cSEb/ilatpfImziHXjoY3awVe8U1kelOUAFojv7bn7WIIgtrvxXFM1IlIPSkYaqWvzrsSFxVFaVcqPR340OxyRs+VvNj7GdIHgKM/eK07Le0Wk/pSMNFKQJYghbYYAan4mXqoppmictKJGRBpAyYgbaNM88WpNsZLGyblHjZIREakHJSNu4Nw0TytqxCs1ZTJSfZrGYff8/UTELygZcQPnyMjWI1spLPe+Tf0kgNmroOBULZMnl/U6RXeCoFCwlUKxGgGKSN0oGXGDpOgk2se1x4FDO/iKdyncDvYKCI6BqPaev19QMMR2M55rqkZE6kjJiJtoqka8kmuKpo+x9LYpOOtGCpWMiEjdKBlxExWxildqis6rZ9KKGhGpJyUjbuJsfrbuwLrzdqgVaVJNuazXyZWMqNeIiNSNkhE3GdhqIFaLlcNFhzl48qDZ4YgYmnIljZNzw7zCraDEXETqQMmIm0SGRNInqQ+g5mfiJcqPQempxDi+T9PdNyYVLFaoLITSQ013XxHxWUpG3Eh1I+JVnKMi0Z0gJKbp7msNNVrPg+pGRKROlIy4kVbUiFc5YcIUjVOs9qgRkbpTMuJGzpGRDYc2YLPbTI5GAp4Z9SJOWlEjIvWgZMSNuid2JyY0huLKYu3gK+YzY1mvk/aoEZF6UDLiRtYgK4NbDwY0VSMms1dBwRbjuZkjI2p8JiJ1oGTEzVxFrFpRI2Y6uQtsZRAcZRSwNrXYboDFWNFTdqTp7y8iPkXJiJu5mp9pRY2YyTlFE9eEbeCrC46E6I7Gc03ViMgFKBlxM+eKmh+P/EhRRZHJ0UjAyj/VebWZCVM0TtqjRkTqSMmIm7WOaU3b2LbYHXY2HtpodjgSqMxc1uukFTUiUkdKRjxAzc/EdGYu63XSHjUiUkdKRjxAzc/EVBX5UJJtPDczGYnVihoRqRslIx6gkRExlXNUJKo9hMaZF0dcd+Nj6WGoOGFeHCLi9ZSMeMCg1oMIsgRxoPAAh05qozBpYt5QLwIQEguRbY3nmqoRkfNQMuIB0aHR9GrRC9BUjZjAVS9iQufVM2mPGhGpAyUjHqLmZ2Iab1jW66QVNSJSB0pGPETNz8QUdhvkm9gG/kxx2qNGRC5MyYiHOFfUaAdfaVJFe8BWAtYIiO5idjSnp2mUjIjIeSgZ8ZBeLXoRFRLFyYqTZB7NNDscCRTOKZq43hBkNTcWOD0yUpINlepILCK1UzLiIdV38NVUjTQZZ/GqN9SLAIQ1h/Ak43mhknIRqZ2SEQ9S8zNpct7QefVMsaobEZHzUzLiQWp+Jk3uhBct63WKUydWETk/JSMe5FxRszl3MyWVJSZHI36vshCKs4zn8X3MjaU67VEjIhegZMSD2sS0oVV0K2wOG5sObzI7HPF3+ZuNj5FtISzB3Fiq0zSNiFxAg5KRuXPn0qFDB8LDwxk2bBjp6eeuiaisrOSJJ56gc+fOhIeH069fP5YvX97ggH2JxWI53W9Ezc/E07yxXgROj4wU74GqUnNjERGvVO9kZMGCBaSlpfHoo4+yadMm+vXrx5gxY8jLy6v1+Icffph//etfPP/882zdupXf/OY3XHfddXz33XeNDt4XqG5EmsyJU8t6valeBIzVNKHNwGGHkzvMjkZEvFC9k5Fnn32Wu+66i6lTp9KzZ0/mzZtHZGQkr732Wq3H/+c//+EPf/gD48aNo1OnTkybNo1x48bxzDPPNDp4X6AVNdJkvHVkxGJR3YiInFe9kpGKigo2btzIqFGjTl8gKIhRo0axdu3aWs8pLy8nPDy8xmsRERF89dVX57xPeXk5hYWFNR6+anDrwViwsK9gH7lFuWaHI/7KYT9dM+ItPUaqc9aNaEWNiNSiXsnI0aNHsdlsJCUl1Xg9KSmJnJycWs8ZM2YMzz77LDt37sRut7NixQo++OADDh8+fM77zJ49m7i4ONcjJSWlPmF6ldiwWHq2MH4r1FSNeEzxXqgqgqAwiOlqdjRn04Z5InIeHl9N849//IPU1FS6d+9OaGgoM2bMYOrUqQQFnfvWM2fOpKCgwPXYv3+/p8P0KE3ViMc560XiekFQsLmx1EZ71IjIedQrGUlMTMRqtZKbW3O6ITc3l+Tk5FrPadGiBYsWLaK4uJh9+/aRmZlJdHQ0nTp1Oud9wsLCiI2NrfHwZSpiFY/ztjbwZ3KOjJzcCfZKc2MREa9Tr2QkNDSUQYMGsXLlStdrdrudlStXMnz48POeGx4eTps2baiqquL999/n2muvbVjEPsi5vDf9YDp2h93kaMQv5Xth59XqIttCcDQ4quDkLrOjEREvU+9pmrS0NF555RXmz5/Ptm3bmDZtGsXFxUydOhWAW2+9lZkzZ7qOX7duHR988AF79uzhyy+/5Oqrr8Zut/Pggw+676vwcr1b9iYiOILC8kJ2HNPSRvEA17JeLx0ZsVjU/ExEzqnek8uTJk3iyJEjzJo1i5ycHPr378/y5ctdRa3Z2dk16kHKysp4+OGH2bNnD9HR0YwbN47//Oc/xMfHu+2L8HbBQcEMaj2Ir7K/Yt2BdXRP7G52SOJPKougaLfx3JvawJ8priccX38qGbne7GhExIs0qNJtxowZzJgxo9b3Vq1aVePzyy+/nK1b9ZvQsDbDjGTk4Dpu63+b2eGIPynYYnyMaAXhLcyN5XxcG+ap14iI1KS9aZqIs4hVK2rE7by18+qZNE0jIuegZKSJOJf3fp/7PaWV2p9D3MhbO6+eyTUykgl2m7mxiIhXUTLSRNrFtSMpKokqexXf5QTGvjzSRHwlGYnqANZwsJdDcZbZ0YiIF1Ey0kSq7+CrqRpxG4ejWo8RL5+mCbJC7Knibe1RIyLVKBlpQkNbG1M1an4mblO8DyoLISgEYruZHc2FaY8aEamFkpEm5BwZWXdAyYi4iXNUJLankZB4O+1RIyK1UDLShIa0HgJAVn4WR4qPmByN+AVfqRdxUjIiIrVQMtKE4sLjXA3PVDcibuFc1uvt9SJOsdV6jTgc5sYiIl5DyUgT06Z54la+NjIS0xkswVBVDCW+vRu3iLiPkpEmpmRE3KaqxNgFF3wnGQkKgdiuxnNN1YjIKUpGmpiz+Vn6wXQcGqaWxij4EXBAeBJEJJkdTd3Fqm5ERGpSMtLE+ib1JTw4nPyyfHYe32l2OOLLvH2n3nPRHjUicgYlI00sxBrCwFYDAS3xlUbytXoRJ+1RIyJnUDJiAmfzM62okUbx1WSk+vJeTVWKCEpGTOFqfqYiVmkoh8P3lvU6xXYFSxBU5kNZrtnRiIgXUDJiAueKmoycDMqqykyORnxSyQHjh7kl+PR+L77CGg7RnY3nmqoREZSMmKJDfAcSIxOptFfyfc73ZocjvsjVBr47WMPMjaUhVDciItUoGTGBxWJRvxFpnHwfnaJxcq2oUTIiIkpGTKNkRBrlhI8Wrzq5ili1vFdElIyYpnrzM5F689WVNE4aGRGRapSMmMSZjOw6votjJcdMjkZ8iq0MTm43nvtqMuIsui3Lg7Kj5sYiIqZTMmKSZhHN6Nrc2KNDoyNSLwU/gsMOYYkQ0crsaBomOAqi2hvP1YlVJOApGTGRpmqkQarXi1gs5sbSGLFqCy8iBiUjJlIRqzSIr9eLOMVpwzwRMSgZMZEzGdEOvlIvvr6s1ylOvUZExKBkxER9k/oSag3lWOkx9pzYY3Y44gscDv8ZGYnVyIiIGJSMmCgsOIwByQMATdVIHZUehvJjYLGenubwVc6RkdKDUFlobiwiYiolIyZz1Y0cUDIideBqA9/N2OPFl4XGQ0Rr47man4kENCUjJnOtqDmkFTVSB856EV+fonHSHjUigpIR0w1ra4yMfHf4OypsFSZHI17P19vAn0mdWEUEJSOm69ysMwkRCZTbyrWDr1yYvxSvOmmPGhFByYjpLBaLmp9J3djKoTDTeO7ry3qd1GtERFAy4hXU/EzqpHAbOKogtBlEtDE7Gvdw1owU74WqYlNDERHzKBnxAkpGpE78pQ18deEtjD12cEDhdrOjERGTKBnxAkPaDAFgx7EdnCg9YXI04rVcK2n8ZIrGSXUjIgFPyYgXSIxMpHOzzgCsP7Te5GjEazmLV5v5SfGqU6xW1IgEugYlI3PnzqVDhw6Eh4czbNgw0tPPX3g5Z84cunXrRkREBCkpKdx3332UlZU1KGB/5Vziq+Znck7+tpLGSXvUiAS8eicjCxYsIC0tjUcffZRNmzbRr18/xowZQ15eXq3Hv/XWWzz00EM8+uijbNu2jVdffZUFCxbwhz/8odHB+5OhrdX8TM6jNBfK8sASBHG9zI7GvbSiRiTg1TsZefbZZ7nrrruYOnUqPXv2ZN68eURGRvLaa6/Vevw333zDxRdfzM0330yHDh246qqruOmmmy44mhJoqo+MaAdfOYuzXiQmFYIjzY3F3ZzTNEW7jeXLIhJw6pWMVFRUsHHjRkaNGnX6AkFBjBo1irVr19Z6zogRI9i4caMr+dizZw/Lli1j3Lhx57xPeXk5hYWFNR7+rn9yf0KCQjhScoS9+XvNDke8jb9O0QBEtIKQOHDY4OROs6MRERPUKxk5evQoNpuNpKSkGq8nJSWRk5NT6zk333wzTzzxBJdccgkhISF07tyZkSNHnneaZvbs2cTFxbkeKSkp9QnTJ4UHh9M/uT+g5mdSC39rA1+dxaI9akQCnMdX06xatYqnnnqKF198kU2bNvHBBx+wdOlSnnzyyXOeM3PmTAoKClyP/fv3ezpMr+DsxKp+I3IWf13W66S6EZGAFlyfgxMTE7FareTm5tZ4PTc3l+Tk5FrPeeSRR7jlllu48847AejTpw/FxcX86le/4o9//CNBQWfnQ2FhYYSFhdUnNL8wrM0w5q6fq2REarJVGN1Xwf+W9Tq5NsxTrxGRQFSvkZHQ0FAGDRrEypUrXa/Z7XZWrlzJ8OHDaz2npKTkrITDarUCqFDzDM4i1k2HN1FpqzQ5GvEaJ7eDvRJCYiGyndnReIZGRkQCWr2nadLS0njllVeYP38+27ZtY9q0aRQXFzN16lQAbr31VmbOnOk6fsKECbz00ku8/fbbZGVlsWLFCh555BEmTJjgSkrE0CWhC/Hh8ZRVlbE5b7PZ4Yi38Mc28Gdy1oyc3A72KnNjEZEmV69pGoBJkyZx5MgRZs2aRU5ODv3792f58uWuotbs7OwaIyEPP/wwFouFhx9+mIMHD9KiRQsmTJjAn//8Z/d9FX4iyBLE0DZD+XT3p6w7sI6BrQaaHZJ4A3+vFwGIagfWSLCVGEt8Y7uZHZGINCGLwwfmSgoLC4mLi6OgoIDY2Fizw/GoWV/M4sk1TzKl/xT+fe2/zQ5HvMEXV8PhT2Dov6DLr8yOxnOWD4bjG+HShZAy0exoRMQN6vrzW3vTeBnXihq1hRcnf+4xUp32qBEJWEpGvMywNkYRa+bRTArKCkyORkxXdgRKDwMWiOttdjSepT1qRAKWkhEv0yKqBR3jO+LAwYZDG8wOR8zmHBWJ7gwh0ebG4mlaUSMSsJSMeCE1PxMXZzLir/1FqnNN02SCw25uLCLSpJSMeCHnVI2SEeGEcyVNACQj0R0hKAxspVC8z+xoRKQJKRnxQtrBV1xcxat+vKzXKSgYYrsazzVVIxJQlIx4oQHJAwgOCia3OJf9hYGxL4/Uwl4FBT8azwNhmgZOT9UoGREJKEpGvFBESAR9k4wfPlriG8BO7gB7BQRHQ1QHs6NpGtqjRiQgKRnxUs66kfSD6SZHIqapXi9iCZB/qlpRIxKQAuR/ON+jFTUSMM3Oqout1mtE9VIiAUPJiJdyjoxsPLyRKm0cFpgCaVmvU0wqWKxQdRJKD5odjYg0ESUjXqpbYjdiw2IpqSzhx7wfzQ5HzHAiADbIO5M11EhIAApUNyISKJSMeKkgSxBDWg8BNFUTkMqPnR4ZiPfzNvBnUt2ISMBRMuLFXM3PtKIm8ORvNj5GdYQQ/96p+izOuhFtmCcSMJSMeDFn87P0Q1pRE3ACsV7ESSMjIgFHyYgXc66o+THvR06WnzQ5GmlSgVgv4lQ9GdGKGpGAoGTEiyVHJ9Murp128A1Egbis1ymmG2CBiuNQfsTsaESkCSgZ8XJqfhaA7DYo2GI8D8RkJDjC2DQPNFUjEiCUjHg5NT8LQCd3gq0MrJEQ09nsaMyhPWpEAoqSES/nWlGjZCRwuKZo+gROG/gzaY8akYASoP/T+Y6BrQZitVg5dPIQBwvVkTIgBHK9iJNW1IgEFCUjXi4qNIreLY2mVxodCRDVN8gLVNX3qBERv6dkxAeo+VmAcfUYCcBlvU5xp5KRshyoOGFuLCLicUpGfICanwWQinwoyTaex/cxNRRThcRAZIrxXHvUiPg9JSM+wLmiZsOhDdjsNpOjEY9ytoGPbAeh8aaGYjrVjYgEDCUjPqBHYg+iQ6Mpqihi6xH9x+zXnPUigTxF46S6EZGAoWTEB1iDrK4dfNX8zM9pJc1pWt4rEjCUjPgINT8LEEpGTtM0jUjAUDLiI9T8LADYbadrRpSMnJ6mKcmGSm0UKeLPlIz4COeKmi15WyiuKDY5GvGIoj1gKwFrOMSkmh2N+cISIDzJeF6YaW4sIuJRSkZ8ROuY1rSJaYPdYWfj4Y1mhyOe4JyiiesNQVZzY/EWrqka1Y2I+DMlIz7EOTqi5md+SvUiZ3NumFeouhERf6ZkxIc460bU/MxP5WtZ71nitLxXJBAoGfEhrhU1GhnxTyc0MnIWragRCQhKRnzI4NaDCbIEsb9wP4dPHjY7HHGnykIozjKeB3Ib+DM5p2mKs6Cq1NxYRMRjGpSMzJ07lw4dOhAeHs6wYcNITz/3tMHIkSOxWCxnPcaPH9/goANVdGg0vVr0AtT8zO84l/RGtIGw5ubG4k3CW0JoAjjscHKH2dGIiIfUOxlZsGABaWlpPProo2zatIl+/foxZswY8vLyaj3+gw8+4PDhw67Hli1bsFqt3HDDDY0OPhCp34if0k69tbNYVDciEgDqnYw8++yz3HXXXUydOpWePXsyb948IiMjee2112o9PiEhgeTkZNdjxYoVREZGKhlpIHVi9VOqFzm3WNWNiPi7eiUjFRUVbNy4kVGjRp2+QFAQo0aNYu3atXW6xquvvsovfvELoqKiznlMeXk5hYWFNR5icC7vXX9wPXaH3eRoxG2cK2mUjJxNe9SI+L16JSNHjx7FZrORlJRU4/WkpCRycnIueH56ejpbtmzhzjvvPO9xs2fPJi4uzvVISUmpT5h+rVeLXkSFRHGy4iSZR9WV0i847KdrRjRNczatqBHxe026mubVV1+lT58+DB069LzHzZw5k4KCAtdj//79TRSh97MGWRnUehCgJb5+o3gvVBVBUCjEdDU7Gu/j3KPm5E6wVZgbi4h4RL2SkcTERKxWK7m5uTVez83NJTk5+bznFhcX8/bbb3PHHXdc8D5hYWHExsbWeMhpKmL1M856kbheEBRsbizeKLItBEeDowqKdpkdjYh4QL2SkdDQUAYNGsTKlStdr9ntdlauXMnw4cPPe+67775LeXk5v/zlLxsWqbi4OrFqea9/UOfV87NYtEeNiJ+r9zRNWloar7zyCvPnz2fbtm1MmzaN4uJipk6dCsCtt97KzJkzzzrv1VdfZeLEiTRvrh4KjeVcUfND7g+UVJaYHI00mvakuTDVjYj4tXqPCU+aNIkjR44wa9YscnJy6N+/P8uXL3cVtWZnZxMUVDPH2b59O1999RWffvqpe6IOcG1j29IquhWHiw6z6fAmLml3idkhSWNoWe+FOetGtGGeiF9q0AT1jBkzmDFjRq3vrVq16qzXunXrhsPhaMitpBYWi4VhbYexKHMR6QfTlYz4ssoiKNptPFcycm4aGRHxa9qbxkcNba3mZ36hYAvggIhWEN7C7Gi8l6vXyHaw28yNRUTcTsmIj3I2P9PyXh+nepG6iWwP1giwl5/eUFBE/IaSER81uPVgLFjYV7CP3KLcC58g3kn1InUTZIXYbsZzTdWI+B0lIz4qNiyWHi2Moj4t8fVhrjbwWtZ7QdqjRsRvKRnxYWp+5uMcjmq79Wpk5IK0R42I31Iy4sPU/MzHlWRDZSEEhUBMN7Oj8X5aUSPit5SM+DBn87P0g+nawdcXnTg1RRPbA6yh5sbiC1y9RrYZmwuKiN9QMuLD+iT1ISI4goLyAnYc22F2OFJfrpU0qhepk5jOxihSVTGUaPNMEX+iZMSHBQcFu3bw1VSND1K9SP0EhZze1Vh71Ij4FSUjvshug9JcOJHBLYktmBILQXv+bdQfiO9wTtNoWW/dqW5ExC9pv3JvUlUCpYehLMf4WJoDZc6POaffK8sDh9GF8lfAr5KA0lWw8kq4ciWExJr5VUhdVJXAyZ3Gc03T1J32qBHxS0pGPM1hh/JjNZOM2pKN0sNQdbIeF7ZAeAsqQprzec42BodD4vENsPpaGLkMgiM89iWJGxT8CDggvCVEJJkdje/QyIiIX1Iy0lC2stNJxPmSjLJccFTV/brWcAhvZexVEpF86nnyqb1Lqn0MbwlBwYQ4HNz2TDJtj+WxrmMkwXmr4OtJcOn7xhy7eCe1gW8YVzKyzejTYrGYG4+IuIWSkeocDqg4fnZiUVvCUVlQv2uHJZ6dUFT/GJFsPA+Jrdd/sBaLhWFthvHRjo9IK+vCc6GZWA9+BN/eDsPng0VlQV5J9SINE9PV+DtdmW/8W4xoZXZEIuIGgZ2MZM6B3C+q1WLkgL2y7ucHhZ1/9MKVZCR5dJRiYveJfLTjI57f+wN7omBhKwjZ+1/2l56k9cj3sFoD+9vslbSst2GsYRDd2ai3KdiqZETETwT2T6lj6+Hgh2e/HppQS0JRS8IREucVw8S3D7idwa0H8+YPb/LWlre4LfcA/02ClNzFPPdqMw60/xU397mZga0GYvGCeAOe2sA3TlzP08lI8pVmRyMibmBxOBwOs4O4kMLCQuLi4igoKCA21o0rRQ5/CkVZNZON8CTjty8fZXfY+XLflxzY+DCTy78C4L4jMCcfujXvxuQ+k7m5z810TuhsbqCBrHg/LG4HlmC4scin/76ZIuMPsHU2pE6DIS+aHY2InEddf34HdjLi56p+eILgLY8C8Osjwbycf7qQ9qK2F3Fz75uZ1HsSLaNamhViYDq4FFZfA3G9Yfxms6PxPVn/hbW3QMvLYdQqs6MRkfOo689vVTf6seA+j0CP+wGY18LO51dMZ3Sn0QRZgvj2wLfcvfxuWj/TmrFvjuW/P/yXoooikyMOEFpJ0zhxp3qNaHmviN9QMuLPLBbo/zfofAcW7Fxx6BU+HfUAB+47wHNjnmNI6yHYHDaW71rOLQtvoeXfW3LT+zexZMcSKmwVZkfvv1Qv0jix3Y2P5Ueg7Ki5sYiIW2iaJhDYbfD1L2D/e2CNhJ98Bi2GA7Dj2A7e2vwWb25+k13Hd7lOaR7RnBt63sDkvpMZkTKCIC0Rdp8lPY2dZ0cug9ZjzY7GNy3uCMV7YdQaaHmp2dGIyDmoZkRqspXD6p9CzqcQEg+j10B8H9fbDoeDDYc28ObmN3l7y9vkFue63msf156bet/E5L6T6d2ytwnB+xFbGbwTZXTmnXgQIlubHZFvWjUeDi2DIfMg9ddmRyMi56CaEanJGgaXfQCJI4yGUZ9fBSdPj4RYLBaGtBnCnKvncCDtAJ/+8lNu63cbMaEx7CvYx1++/gt9XupDv3n9+NvXf2N/gbZwb5CCrUYiEtZcPTIaI1Z1IyL+RMlIIAmOgpFLjMLJshz4fDSUHDz7sKBgRncezesTXyf3/lwW/HwB13a7lpCgEH7I/YHff/Z72s1px+WvX87LG1/meOlxE74YH1W986p6vjScsy28NswT8QtKRgJNaDO44lOI7mLMuX9xlbGR3zlEhERwY68bWfSLReTcn8O/rvkXl7W/DIA1+9bw6yW/JvnpZCa+PZF3fnyH0srSJvpCfJQ6r7pH9T1qRMTnqWYkUBXvg08vhtKDkDAErlwJITF1Pj27IJu3t7zNm5vf5IfcH1yvx4TG8LMeP2Nyn8lc0fEKgoMCu8nvWVZeCbmfw7DXoPNUs6PxXRUF8F688fzn+RAaZ2Y0InIOKmCVCyvYBp9daoyMJF1hrO6whtf7Mlvytrha0WcXZLteT4pK4he9f8HkPpMZ3HqwWtE7HPBBC+PP++oNkDDI7Ih828I2UHoIrloLiReZHY2I1ELJiNTNsQ2w8idQdRLaXguXvAcNHM2wO+x8s/8b3vzhTd7Z+k6NWpLUhFRu7nMzk/tMJrV5qrui9y0lh2BRG2PX2RuLG5T4STWfj4acz2DYq9D5drOjEZFaaDWN1E3zwXD5h8YOxAcWw7e3G6s9GiDIEsQl7S7hpWte4vD/O8xHN33EL3r/gojgCHYe38njqx+n6wtdGfrKUOZ8O4ecohw3fzFezlkvEtNNiYg7xDqLWFU3IuLrlIwIJI2ES94FixX2/gc23mtMKTRCqDWUa7pew/+u/x+59+fyxsQ3GNN5DFaLlfWH1nPfJ/fR5tk2XPWfq5ifMZ/C8kK3fCleTW3g3ctVxKoVNSK+TsmIGNpOgIvmAxbY8Txsfsxtl44Ji+GWfrew/JfLOZh2kH9e/U+GtRmG3WFnxZ4VTFk8haSnk7jx3RtZnLmYSlul2+7tVZzLetUG3j20R42I31DNiNS040XYMN14PvA56H6vx2616/gu/rf5f7y5+U22H9vuer1NTBumD5nOrwb9iuaRzT12/ya3tA8UbIHLl0Cb8WZH4/vKjhoFwQA3Fhl9dETEq6iAVRpuy5/hh4eN5xf9GzpN8ejtHA4Hmw5v4q3Nb/Hfzf8lrzgPgPDgcG7teyt3D7ubXi17eTQGj7OVwzvR4KiCa7MhKsXsiPzD+y2NDfOu3ggJA82ORkTOoAJWabhef4DuacbzdXfA/oUevZ3FYmFQ60E8M+YZsu/NZv7E+QxIHkBZVRkvb3qZ3i/15qr/XMWyncuwN7C41nSF24xEJCQeItuaHY3/UN2IiF9QMiJns1hgwNPQ6dTKmq9/YSyhbAJhwWHc2u9WNv5qI6unrOZnPX5GkCWIFXtWMP6t8fSY24O56XMpqihqknjc5sSp4tVm/dQG3p20R42IX2hQMjJ37lw6dOhAeHg4w4YNIz09/bzH5+fnM336dFq1akVYWBhdu3Zl2bJlDQpYmojFAkNfhpTrwV4BaybC0W+b8PYWLmt/Ge/f+D67freLtIvSiA2LZcexHcz4eAZtn23LA58+wL78fU0WU6NoJY1nxGl5r4g/qHcysmDBAtLS0nj00UfZtGkT/fr1Y8yYMeTl5dV6fEVFBaNHj2bv3r289957bN++nVdeeYU2bdo0OnjxsCArjHgTkq+CqmJYNQ7yNzd5GB2bdeSZMc9w4L4DPD/2ebokdKGgvICn1z5Np3924oZ3b+Cr7K/w6vInJSOeoWkaEb9Q7wLWYcOGMWTIEF544QUA7HY7KSkp/O53v+Ohhx466/h58+bx97//nczMTEJCQhoUpApYTVZVbHS7PLoWwpPhqq8hupNp4dgddpbtXMacb+ewMmul6/VBrQZx70X3cmOvGwm1hpoWX60+SIKyPLhqHSQONTsa/1F6GBa2PtXVtgSsYWZHJCLVeKSAtaKigo0bNzJq1KjTFwgKYtSoUaxdu7bWcz788EOGDx/O9OnTSUpKonfv3jz11FPYbLZz3qe8vJzCwsIaDzFRcBSMXArxfaAsB1aOMlqbmyTIEsQ1Xa/hs1s/44ff/MCdA+4kzBrGxsMbuWXhLbSf054/rfkTR4qPmBZjDaW5RiKCBeJ7mx2NfwlPhpA4o7bp5A6zoxGRBqpXMnL06FFsNhtJSUk1Xk9KSiInp/bW3nv27OG9997DZrOxbNkyHnnkEZ555hn+9Kc/nfM+s2fPJi4uzvVISdEySNOFNoMrPoXozlCcBV9cZWz4ZrI+SX145aevsP++/fzpij/RKroVOUU5PPLFI6Q8l8Idi++osauwKVxt4FMhONLcWPyNxVJtqkZ1IyK+yuOraex2Oy1btuTll19m0KBBTJo0iT/+8Y/MmzfvnOfMnDmTgoIC12P//v2eDlPqIiIZfvIZRLSGgh+NGpLKk2ZHBUCLqBb88bI/svfevbz5szcZ3How5bZyXst4jX7z+nHlG1fy0faPzFkanH+q86rqRTxDdSMiPq9eyUhiYiJWq5Xc3Nwar+fm5pKcnFzrOa1ataJr165YrVbXaz169CAnJ4eKiopazwkLCyM2NrbGQ7xEdAf4yQoIaw7H0o1VNrYys6NyCbWGcnOfm0m/M52vb/+aG3regNVi5fOsz/np2z+l6/Nd+ee6f3KyvAmTqOrLesX9XBvmKRkR8VX1SkZCQ0MZNGgQK1eeLhq02+2sXLmS4cOH13rOxRdfzK5du7DbT/9GumPHDlq1akVoqJcVGUrdxPWEkR9DcDTkfg5f3wT2KrOjqsFisTAiZQTv3PAOe+7Zw4MjHiQ+PJ7dJ3Zzz/J7aPtcW9I+SSPrRJbng9FKGs/SHjUiPq/e0zRpaWm88sorzJ8/n23btjFt2jSKi4uZOnUqALfeeiszZ850HT9t2jSOHz/OPffcw44dO1i6dClPPfUU06dPd99XIU2v+RC4/CMICoMDi2DdnUYRoRdqF9eOv47+KwfuO8CL416kW/NuFJYX8ty3z9Hl+S5ct+A6Vu9d7ZmlwbaK07+xKxnxDOc0zckdXpcUi0jd1DsZmTRpEk8//TSzZs2if//+ZGRksHz5cldRa3Z2NocPH3Ydn5KSwieffML69evp27cvd999N/fcc0+ty4DFxySNhEveAYsVsubDpjTw4l4fUaFRTBsyja3Tt/Lx5I8Z03kMdoedRZmLGDl/JANfHsj8jPmUV5W776Ynt4O9EkJiIaq9+64rp0WmGCu+7JVQtNvsaESkAbRRnjRe1n9h7S3G8z6PQZ9HTQ2nPrYe2co/1/2TN75/g9KqUgBaRrVk2uBpTBs8jaTopAtc4QKy3oS1v4QWl8DoL90QsdRq+RA4vgEu/QBSrjM7GhE5RRvlSdPp+EsY9LzxfPNjkPkPU8Opj54tejLvmnkcSDvAX678C21j25JXnMfjqx+n3Zx2TFk0he8Of9fwG6hepGlojxoRn6ZkRNyj2wzo84TxfNO9sGe+qeHUV0JEAr+/5PfsuXsPb1//NsPbDqfCVsH87+cz8OWBXP765SzcthCb/dzN+mqlZb1NQ3vUiBnKj5myRYY/UjIi7tP7Yeh2n/F83R2wf5Gp4TREiDWESb0n8c0d3/DtHd9yU++bCA4KZs2+NfzsnZ/R5fkuPLf2OQrKCup2wXwt620S6jUiTS3vK1jSDZb1hb1vmR2Nz1MyIu5jscDAZ6DTVHDY4OtJkLPywud5qWFth/HW9W+RdU8WMy+ZSUJEAnvz95L2aRptn2vL3R/fza7ju859gbIjxt4pAHFqA+9R1UdG6jt6JVJfWW/C51ee7kK97i6NkDSSkhFxL4sFhr4MKT8DewWsuRaOppsdVaO0jW3LU1c+xf779vPyNS/Ts0VPiiqKeD79ebo+35Wf/u+nfJ71+dlLg52jItGdISS66QMPJFEdjWXmtjIo2Wd2NOKvHA744TGjKN1eAW0nQvJosJXAmuugIt/c+HyYkhFxv6BgGPEWJI8ydvxdNRbyt5gdVaNFhkRy16C72DJtC5/+8lPGp47HgYOPdnzElW9cSb95/Xjtu9coqzrVkVbFq00nyAqx3Yzn2qNGPMFWBt9Mhi2PG5/3eAAufR8u/p+xbL9oN3xzi9f2W/J2SkbEM6xhcOlCaH4RVBw3NtYr2mN2VG5hsVgY3Xk0S25eQub0TKYPmU5USBSb8zZzx4d3kPJcCo98/ggHs5cDUBjZiUpbpclRBwDVjYinlB2Bz0fBvv+BJdgY/R3wN7AEGVtjXPqBMTJ3aAn8+JTZ0fok9RkRzyo/Dp9dDgVbILoTjP4KIlqZHZXb5Zfl8+qmV3k+/Xn2FRjTBBtSYFA4XHcIFhVDfHg8LaNa0jKqJS0iW9T8GNWixnvNI5sTHBRs8lflYzY/CZtnQacpcNG/zY5G/EVBJqweb/wyFRIHl75njPqeafe/Yd3tgAVGLoPWVzd5qN6orj+/lYyI55UehhWXGsOYcb1h1GoISzA7Ko+oslexOHMx8zNe5V3HcsIsDlL3WthVWb9/ZhYsJEQknE5QolrQMvJ00uJMYpzvJUQkEGQJ8IHO7Pfgqxug+VAYs87saMQf5KyEL38OlflGXdLIpaf3QqpN+q9h18sQ2gyu3gjRHZssVG+lZES8S1EWrLgESg9B82Hwk8/8u6izYCss7QXB0dh/foLjZfkcKT5CXnEeR0qMj3nFecZrJXk13jtWcgwH9ftnGWQJIjEy8exE5YyRF+fn8eHxWCwWD33xJnH9mcfADQVGMbVIQ+1+FdJ/A44qSBwOly2C8JbnP8dWDp9dZuxo3mwAjP4agiOaJFxvVdef3xoHlqYR3RGu+PTUP9R1sGai8VuGNczsyDzjhLN4tQ9BQcEkRiaSGJlIjxbn+a3qlCp7FcdKjrmSllqTmGrvnSg7gd1hd71XF8FBwedMVM5MYtrGtiU8OLwxfxpNI7qLMZ9fdRJKD0JkW7MjEl/ksMP3f4CtfzU+b/8LY9rPWod/A9YwuOQ9WD4QTnwHG34Lw15TYlwHSkak6cT3gpEfG+vzc1fC1zcZG+35Y21EIzqvBgcFkxSdVOd9cSptlRwtOVr7qEv1xOXUx8LyQqrsVRwuOszhosMXvL4FCylxKXRJ6EJqQipdErq4nndq1omIEC/5zc8aCjGpRq+Rgq1KRqT+qkpg7a2w/33j896zjP226pNMRKXAxQvgi9Gw53VjJDj1N56I1q/44U8B8WqJQ+GyxbBqHBxYCOl3wbBXjap0f9KEnVdDrCG0imlFq5i6FQaXV5XXedQltziXksoSsguyyS7I5vOsz8+6XtvYtmclKV0SutA5oTORIZHu/nLPL67H6WSk1VVNe2/xbaWHYfW1cHw9BIUY/y91vKVh10r+CfSbDRm/h413G1M2icPcG6+fUTIiTS/5J3DJAvjyeuM3h5B4GPisfw1lenGPkbDgMNrGtqVt7IVHDhwOB0dKjrDr+C52Hd/FzmM72XXi9POC8gIOFB7gQOEBvtj7xVnnt4lpc1aS4nxEhUa5/4uL7Ql8oD1qpH7yN8Oq8VCyH0IT4LKF0PKyxl2zxwPGlPT+D4z/68ZuunDNSQBTMiLmaHutMZf67W2wfY5Rfd5nltlRuUf5cSg5YDz38TbwFovFVUcyImVEjfccDgfHSo+dM1E5UXaCgycPcvDkQVbvW33WtVtFtzp76qd5Kp2bdSYmLKZhAavXiNTXoY/hq0lGrVFMV6OWLaZL469rsRi1JgVboTDTuMdPVvjntLQbaDWNmGv788YwJsCgf0K33zV9DA67MVdcVQy2YuPjuR51eb8i3/gNK6oDXJvV9F+Plzheevx0knJ8F7tOnH5+rPTYec9NikpyJSddmp1OVLokdCE27Dz/B5z4Hj7ubyS31x/zr9E2cb8dc43/fxx2aDnS6Kjq7rYDBdvgk6FQVWSMlgz4m3uv7+W0tFd8x+YnYPOjxvPhb9Q+T2uvbFiCYCs+nWic63hbqWe+ri6/hqHzPHNtH3ei9IRrRGXX8V3sPL7T9fxIyZHzntsisoUrMenS7HSS0iWhC/HBYfBOFOCA63Igom5FwBJg7Db47v/B9n8Yn3e8zeiqag31zP2cPXAALnkX2v3cM/fxQkpGxHc4HLApzZiusViNOoszkwd7E7VTt0ZCcNTZD2str531frVzQ2Ihrpf/FeY2gfyyfHYf331WkrLz+M4LLl1OjEzku1YnaRtUzvzEKYS0Gu2aCmoW0ayJvgLxapUnjZV8h5Yan/d7Cno+5PlRtO8egG1PQ3A0jEk/f/M0P6JkRHyLww7r7jAKWs/HYq1bgnCu986VbARHgTVCyYOXKywvZPfx3WclKbuO7yKnKAeAxa3gp9Hw2zx4qeD0uZ2adWJit4lM7D6RESkjsAZZTfoqxDQlB2DVNcbSe2u4MRLb7oamube9ytijK/cLY1PHMenGLy1+TsmI+B6HA458bRSSnSupCApVHYDUqqiiiF3HdxG+5TG65y1mZXAPnihpwa7juzh08lCNY1tEtuCn3X7KxO4TGdVplG80dZPGOb4RVk8wlvCGtzRaDCRe1LQxlOXBxwONpnwp1xtTNn7+/5mSEREJTHvmw7dTIOkKuNLoi1JYXshnez5jYeZCluxYQn5ZvuvwqJAoxqaOZWK3iYxLHafpHH+0fxF8MxlsJcb06eVLILqDObEc/dboRG2vhP5/hZ4PmhNHE1EyIiKB6dh6Y/VCeDL87OwOs5W2StbsW8PCzIUsylzEwZMHXe8FBwUzssNIrut+Hdd2u5Y2sW2aMnJxN4cDMp816jVwQPJVRtfn0Dhz49o5D9ZPM6aFr1hh9F7yU0pGRCQwVZ6Ed0/9P3H9sfMu1XQ4HGw8vJFFmYtYmLmQrUdq9icZ0noIE7tP5Lru19E9sbv/bS7oz+yVsOF3sOtfxuddfgODn/eOPh8OB6y73aiRC0uEqzcZbeT9kJIREQlci9pDSTaM/gpaXFzn03Yc28HizMUszFzItwe+rbF7ctfmXZnYbSLX9biOoW2GEqRiZ+9VkQ9f3Qg5KwALDHwGut3rXfUZVaWw4mJjQ73mQ2HUGr/cOFTJiIgEri+uhsOfGL0jutzVoEscPnmYj3Z8xKLMRazMWkmFrcL1XnJ0Mtd2u5aJ3SdyRYcrCAv2vx8iPqsoC1ZfY3Q+tUbCxf+Dtj81O6raFWXB8kFQccJv+xIpGRGRwLUxDbY/B93ug0HPNvpyheWFfLzzYxZtX8TSHUs5WXHS9V5sWCzjUscxsdtExqaOPX+HWPGsI2thzbVQfgQiWsPlH0HCQLOjOr9Dy42NQ3EYW2R0nmp2RG6lZEREAteu/zN2hG41Bq5Y7tZLl1eV88XeL1iUuYjF2xe7+psAhFpDubLjlUzsPpGfdvspydHJbr23nMe+BbD2NrCXQ7P+RiISeeHNIL3C5idh8ywICoOrvoaEQWZH5DZKRkQkcB35xpiPj0yBidkeu43dYSf9YDoLty1kYeZCdh7f6XrPgoXhKcNdjdZSm6d6LI6A5nDAj0/BDw8bn7eZACPegpBoc+OqD4cd1kyEgx9BVHu4eiOENTc7KrdQMiIigaviBLx3ahXNDYUQ0sBdgOvB4XCQeTTTtTJn/aH1Nd7v2aIn13W/jondJzKo1SCtzHEHWzmk/wqy3jA+73YvDHgafLG7bkU+LB8MRbuNJcgjl/nm13EGJSMiEtg+aAVlOUbb7eZDmvz2BwoP8OH2D1mYuZBVe1dRZa9yvdc2ti3XdruW67pfx2XtLyPEGtLk8fm88mPw5c8gb42xTcTg5yF1mtlRNc6JH+DTi4zNO3v9Efr9yeyIGk3JiIgEtpVXQu7ncNHr0Ok2U0M5UXqCZTuXsWj7Ij7e+THFlcWu9+LD47mm6zVM7DaRq7tcTVRolImR+ojCnbB6PJzcCcExRiOz1lebHZV77H3L6BYLRst6b10JVEdKRkQksK2fATvnQo8HYcBfzY7GpbSylJVZK1mUuYgPt3/IkZIjrvfCg8MZ3Wk0E7tPZELXCbSIamFipF4qd7UxIlJxHCLbwcilEN/b7Kjca8M9sOOfxkZ6YzZArO/WGykZEZHAtuNF2DAdWl8DIz8yO5pa2ew2vtn/javOJCs/y/VekCWIS9pd4iqA7diso4mReok9b0D6nUZ31eZDjZGDCD9csWSrgM9/YmwcGtcbxnxrbBTqg5SMiEhgy10FK6+A6M7w011mR3NBDoeDLXlbXHvmfJfzXY33+yX1Y2L3iVzT9RoGJA/A6gfFjXXmsMMPj8KPp2ooUn4Ow+dDcKS5cXlS6WFjh9+yHGh/E4x407s6yNaRkhERCWxlefBBEmCBG4shOMLsiOplX/4+FmUuYtH2RazZtwa7w+56LzYslsvaX8bI9iMZ2WEk/ZP7+29yYiuDtVMge4Hxec+HoN+fjU3m/F3eV0ZC7aiCgXOg+z1mR1RvHk1G5s6dy9///ndycnLo168fzz//PEOHDq312Ndff52pU2t2lAsLC6OsrKzO91MyIiL15nDA+4lGbcHY74xGWD7qaMlRlu5YyqLti/g863MKywtrvO+3yUlZntF/4+hasAQb7f39rEPpBWX+Azbda3z9V34OLS81O6J6qevP73pvX7hgwQLS0tKYN28ew4YNY86cOYwZM4bt27fTsmXLWs+JjY1l+/btrs+1vl5EPM5igbiecOQrY58SH05GEiMTua3/bdzW/zZsdhsZORms2ruKVftWsWbfGgrLC1myYwlLdiwB/CQ5KdgKq8ZD8V4IiYfLPoCkK8yOqul1uxuOpcO+t4zN/8ZugohWZkfldvUeGRk2bBhDhgzhhRdeAMBut5OSksLvfvc7HnroobOOf/3117n33nvJz89vcJAaGRGRBkn/Nex6GXo9DP2eNDsajzhXclKdzyUnh1fAVz+HykKj5mfkUojtZnZU5qkqhk8ugoItxi7UP/kcrKFmR1UnHhkZqaioYOPGjcycOdP1WlBQEKNGjWLt2rXnPK+oqIj27dtjt9sZOHAgTz31FL169arPrUVE6i+2p/GxcKu5cXiQNcjKoNaDGNR6EP9vxP/z/ZGTXa/A+mngsEGLS+DShRCeaHZU5gqOgks/gE8GGytsvrsfBv/T7Kjcql7JyNGjR7HZbCQlJdV4PSkpiczMzFrP6datG6+99hp9+/aloKCAp59+mhEjRvDjjz/Stm3tmxiVl5dTXl7u+rywsLDW40REziuuh/GxwH+TkTM1NDm5tN2ljOxwOjkJDqr3LH7j2G3w/UOw7Wnj8w6/hGH/B9awpo3DW8WmwvD/wpqfwo7nofkw6DjZ7Kjcpl7TNIcOHaJNmzZ88803DB8+3PX6gw8+yOrVq1m3bt0Fr1FZWUmPHj246aabePLJ2odNH3vsMR5//PGzXtc0jYjUS8kBWJRitAu/scRnhrY9qa7TOk2anFQVwze/hAOLjM/7PA69H/HJpawe9/0jxhJnawRc9S0062t2ROflkdU0FRUVREZG8t577zFx4kTX67fddhv5+fksXry4Tte54YYbCA4O5n//+1+t79c2MpKSkqJkRETqx+GAd+Og6iSM/9EoaJUaTE9OSg4Zv+0f3whBoXDRv6HDze65tj+y24xW+Ic/Mepprt4AofFmR3VOHqkZCQ0NZdCgQaxcudKVjNjtdlauXMmMGTPqdA2bzcbmzZsZN27cOY8JCwsjLExDcyLSSM4VNcfWGVM1SkbOUtdpnaU7l7J051LAjcnJie9h9TXGCFZYIly2yCjQlHMLshoN0Jw7/H5zC1y+2Of7rtR7Nc2CBQu47bbb+Ne//sXQoUOZM2cO77zzDpmZmSQlJXHrrbfSpk0bZs+eDcATTzzBRRddRJcuXcjPz+fvf/87ixYtYuPGjfTsWbf/GLSaRkQa7NupsOd1Y+i/zyyzo/E5Hhs5ObgUvv4FVBVBbHe4fAnEdPbgV+Jnjm+CT0eAvRz6PAF9HjE7olp5rM/IpEmTOHLkCLNmzSInJ4f+/fuzfPlyV1FrdnY2QUGnM7QTJ05w1113kZOTQ7NmzRg0aBDffPNNnRMREZFGca2o2WZuHD7KrSMnZXlGz4ycz2HHP4w270k/gUvfg9BmJn+lPiZhIAx5CdbdDpsfheaDofVYs6NqMLWDFxH/dnCpMRUQ0cpoJd5sIDTrByExZkfmF86VnERYYGAYDA2HSyKDGREVQjKlNU/ufIfxAzUoxJzg/UH6b2DXv4xk7uqNEO1dGypqbxoRETAKJBe3M/pWuFggJtX47bLZwFMfB0BYgmlh+jS7zRh5OrYO+9F1lOWuJrxoF0HYzzp0azl8VxlCVmQ3cptdTtfEbnRt3pVuid1IiU3xnn4nvsJWDp9dZow4NesPo7/xqn2YlIyIiDgdWQs5nxrz7Cc2GQWTtYlqXy05GQgJA/yy9XajOBzGn9+x9FOPdXB8g7E890zhyTiaD+VQaArflFTxXu5elmevPavmxCnMGkaXhC50bd61xqNb824kRiZqK5FzKd4PywdB+RHoeJuxIslL/qyUjIiInEtZHhz/zkhMTnxnJClFu2s/Njz57BGUqPZe85+9x1UUGMnGsXWnE5DSw2cfFxwNCYOh+VDjkTgMItqc9efknNbJyMlgx7Ed7Di+gx3HdrDr+C4qbBXnDCM+PP50gpJwOlFJbZ5KdGi0u79q35PzOXwx2qjDGfISpP7G7IgAJSMiIvVTkQ8nMk6NnpxKVAozjf/czxTa7OwRlJhUn19eia0C8n+oOepRWEt3bYsV4vucSjyGGR9jexjLTht6a7uNfQX7jATljEd2QTYOzv2jqk1Mm7NGU7o270rH+I6EWAOoHmXr3yDj90YNzqg1kHiR2REpGRERabSqYjjxQ80RlIItYK88+9jgaGPOvvoISlwP7y3OdDiM0aBj6XD01KjHie+MpaJniupwOuloPtT4+oIjmyzU0spSdp/Yzfaj22uMpuw4toOjJUfPeV5wUDCdmnU6azSla/OutI5p7X/TPg4HfHUD7H/fGJW6eiNEJF34PA9SMiIi4gm2cij48fQIyvFNkP892ErPPjYoDOL7Gj+8nQlKfB+whjd93GVHqo14nHpUHD/7uNBmNUc8mg+B8JZNH28dHS89zs5jO9l+bPtZIyqlVbV8T06JComqdTSla/OuxIfHN90X4G6VJ+GTocaIVsuR8JMV0NT7DFWjZEREpKnYq6BwuzGCUr0WpbKWQk1LsNEJ1jnF02yAMaIS4sa6h6pSI4bqox7FWWcfFxRm3L96nUd0Z7+oh7E77Bw6eciVmGw/ut01opJ1IgtbjdVVNbWMalnraErnhM6EB5uQSNZXwTYjIakqgh73w4C/mxaKkhERETM57FC0p+YIyolNUF7btIIFYrvWnOKp61Jju834Lbh6gWn+D2csZT4ltnvNUY/4vgG5eWCFrYKsE1mnE5VqoyqHi2opzj3FgoX28e3p1rybK0Hp3bI3I1JGEOptf47Z7xlTNgCXvAPtbjAlDCUjIiLexrkstvoIyvFNUHqw9uOjOtQcQUkYCI6q00nHUeey2qKzzw1PNkY6XHUeg716QzVvcbL8JDuP76w1UTnXkuSY0BhGdx7NNanXMDZ1LMnRyU0c9Tl89yBs+zsER8GY9UYNUxNTMiIi4itKc0+t4Kk2glK0p+7nB0dVW1Z7KgGJbOsX0y3ewuFwkFecV6MmZfux7Xx74Ftyi3NrHDu49WCuSb2G8V3HM7DVQILMWmVlr4IvroLcLyC2G4xJh5Cm/RmqZERExJdVnDi11LjaCEphprF8OK53zVGP2J6NWlYrDWd32Nl4aKNrb54NhzbUeD85OplxXcYxvut4RncaTUxYE29DUJZnNEQrOQApP4NL3mvSJFXJiIiIv6kqMT424bJaqZ/DJw/z8a6PWbpzKZ/u/pSiitNTaCFBIVze4XLGp45nfOp4UpunNk1QR9fBZ5caS9L7/xV6Ptg090XJiIiIiKnKq8r5MvtLlu5YypKdS9h1fFeN97s27+pKTC5tf6lni2B3zoP104yRtSs+heQrPXevapSMiIiIeJEdx3awdIcxnbN632qq7FWu92JCY7iq81WMTx3PuNRxJEW7uVmZwwHrboc9r0NYotEQLaqde+9RCyUjIiIiXqqwvJAVu1e4ak3yivNqvD+k9RDGp47nmq7XMKDVAPcUwVaVwoqLjULphCEw+kuwhjX+uuehZERERMQH1LUI9pqu1zCq06jGFcEWZRkFrRUnoMuvYOi/Ghn9+SkZERER8UF1KYJ1Lh3uktCl/jc49AmsGgs4YNir0Pl29wV/BiUjIiIiPq4uRbDOxOSSdpfUvQh2y5/gh0eMLQGu+hoSBnkgeiUjIiIifsdZBLtk5xLW7FtTaxHsNV2vYWyXsecvgnXYYc1EOPgRRLU3ClrDmrs9XiUjIiIifqwuRbDXdL2G8anjay+CrciH5UOgaBckj4aRH7u9eZ6SERERkQBRvQh2yY4lbDy8scb7ydHJrp4mNYpg8zfDJ8PAVgp9n4TeD7s1LiUjIiIiAcpZBLtkxxJW7Flx/iLYwnTY/k+45F2ISnFrHEpGRERExFUEu2THEpbuXFprEeyELuO4dcBU+ib1deu9lYyIiIjIWc5VBPvaT19j6oCpbr1XXX9+B7v1riIiIuLVujbvStfhXblv+H2uItglO5cwNnWsaTFpZEREREQ8oq4/v93Q7F5ERESk4ZSMiIiIiKmUjIiIiIiplIyIiIiIqZSMiIiIiKmUjIiIiIiplIyIiIiIqZSMiIiIiKmUjIiIiIiplIyIiIiIqRqUjMydO5cOHToQHh7OsGHDSE9Pr9N5b7/9NhaLhYkTJzbktiIiIuKH6p2MLFiwgLS0NB599FE2bdpEv379GDNmDHl5eec9b+/evdx///1ceumlDQ5WRERE/E+9k5Fnn32Wu+66i6lTp9KzZ0/mzZtHZGQkr7322jnPsdlsTJ48mccff5xOnTo1KmARERHxL8H1ObiiooKNGzcyc+ZM12tBQUGMGjWKtWvXnvO8J554gpYtW3LHHXfw5ZdfXvA+5eXllJeXuz4vKCgAjN3/RERExDc4f247HI7zHlevZOTo0aPYbDaSkpJqvJ6UlERmZmat53z11Ve8+uqrZGRk1Pk+s2fP5vHHHz/r9ZSUlPqEKyIiIl7g5MmTxMXFnfP9eiUjDbn5LbfcwiuvvEJiYmKdz5s5cyZpaWmuz+12O8ePH6d58+ZYLBa3xVdYWEhKSgr79+8nNjbWbdeVhtP3xLvo++Fd9P3wLvp+XJjD4eDkyZO0bt36vMfVKxlJTEzEarWSm5tb4/Xc3FySk5PPOn737t3s3buXCRMmuF6z2+3GjYOD2b59O507dz7rvLCwMMLCwmq8Fh8fX59Q6yU2NlZ/kbyMvifeRd8P76Lvh3fR9+P8zjci4lSvAtbQ0FAGDRrEypUrXa/Z7XZWrlzJ8OHDzzq+e/fubN68mYyMDNfjpz/9KVdccQUZGRmadhEREZH6T9OkpaVx2223MXjwYIYOHcqcOXMoLi5m6tSpANx66620adOG2bNnEx4eTu/evWuc7xzhOPN1ERERCUz1TkYmTZrEkSNHmDVrFjk5OfTv35/ly5e7ilqzs7MJCvKNxq5hYWE8+uijZ00JiXn0PfEu+n54F30/vIu+H+5jcVxovY2IiIiIB/nGEIaIiIj4LSUjIiIiYiolIyIiImIqJSMiIiJiqoBORubOnUuHDh0IDw9n2LBhpKenmx1SQJo9ezZDhgwhJiaGli1bMnHiRLZv3252WHLKX/7yFywWC/fee6/ZoQS0gwcP8stf/pLmzZsTERFBnz592LBhg9lhBSSbzcYjjzxCx44diYiIoHPnzjz55JMX3H9Fzi1gk5EFCxaQlpbGo48+yqZNm+jXrx9jxowhLy/P7NACzurVq5k+fTrffvstK1asoLKykquuuori4mKzQwt469ev51//+hd9+/Y1O5SAduLECS6++GJCQkL4+OOP2bp1K8888wzNmjUzO7SA9Ne//pWXXnqJF154gW3btvHXv/6Vv/3tbzz//PNmh+azAnZp77BhwxgyZAgvvPACYHSSTUlJ4Xe/+x0PPfSQydEFtiNHjtCyZUtWr17NZZddZnY4AauoqIiBAwfy4osv8qc//Yn+/fszZ84cs8MKSA899BBff/11nXY9F8+75pprSEpK4tVXX3W9dv311xMREcF///tfEyPzXQE5MlJRUcHGjRsZNWqU67WgoCBGjRrF2rVrTYxMAAoKCgBISEgwOZLANn36dMaPH1/j34mY48MPP2Tw4MHccMMNtGzZkgEDBvDKK6+YHVbAGjFiBCtXrmTHjh0AfP/993z11VeMHTvW5Mh8l0d37fVWR48exWazubrGOiUlJZGZmWlSVALGCNW9997LxRdfrC0DTPT222+zadMm1q9fb3YoAuzZs4eXXnqJtLQ0/vCHP7B+/XruvvtuQkNDue2228wOL+A89NBDFBYW0r17d6xWKzabjT//+c9MnjzZ7NB8VkAmI+K9pk+fzpYtW/jqq6/MDiVg7d+/n3vuuYcVK1YQHh5udjiCkaQPHjyYp556CoABAwawZcsW5s2bp2TEBO+88w5vvvkmb731Fr169SIjI4N7772X1q1b6/vRQAGZjCQmJmK1WsnNza3xem5uLsnJySZFJTNmzGDJkiWsWbOGtm3bmh1OwNq4cSN5eXkMHDjQ9ZrNZmPNmjW88MILlJeXY7VaTYww8LRq1YqePXvWeK1Hjx68//77JkUU2B544AEeeughfvGLXwDQp08f9u3bx+zZs5WMNFBA1oyEhoYyaNAgVq5c6XrNbrezcuVKhg8fbmJkgcnhcDBjxgwWLlzI559/TseOHc0OKaBdeeWVbN68mYyMDNdj8ODBTJ48mYyMDCUiJrj44ovPWu6+Y8cO2rdvb1JEga2kpOSsDWGtVit2u92kiHxfQI6MAKSlpXHbbbcxePBghg4dypw5cyguLmbq1KlmhxZwpk+fzltvvcXixYuJiYkhJycHgLi4OCIiIkyOLvDExMScVa8TFRVF8+bNVcdjkvvuu48RI0bw1FNPceONN5Kens7LL7/Myy+/bHZoAWnChAn8+c9/pl27dvTq1YvvvvuOZ599lttvv93s0HyXI4A9//zzjnbt2jlCQ0MdQ4cOdXz77bdmhxSQgFof//73v80OTU65/PLLHffcc4/ZYQS0jz76yNG7d29HWFiYo3v37o6XX37Z7JACVmFhoeOee+5xtGvXzhEeHu7o1KmT449//KOjvLzc7NB8VsD2GRERERHvEJA1IyIiIuI9lIyIiIiIqZSMiIiIiKmUjIiIiIiplIyIiIiIqZSMiIiIiKmUjIiIiIiplIyIiIiIqZSMiIiIiKmUjIiIiIiplIyIiIiIqZSMiIiIiKn+P+bwxQ9xPV0PAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot(history.history['accuracy'],color='red',label='train')\n",
        "plt.plot(history.history['val_accuracy'],color='blue',label='validation')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "plt.plot(history.history['loss'], color='green', label='train loss')\n",
        "plt.plot(history.history['val_loss'], color='orange', label='validation loss')\n",
        "plt.legend()\n",
        "plt.show()\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": [],
      "mount_file_id": "1kHNrQ-2nQagW06B-Xsc-PNOsdAQlVxU3",
      "authorship_tag": "ABX9TyPr2xmXjKkYpqWxg5bccJMB",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}