cd_Classifier_CNN84.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_CNN84.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": "94f7651d-5177-48a6-d39f-5af10c45ed7e"
      },
      "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": "4581d24a-9cca-49b6-a23f-982be5943914"
      },
      "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",
            " 98% 1.04G/1.06G [00:06<00:00, 170MB/s]\n",
            "100% 1.06G/1.06G [00:06<00:00, 166MB/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\n",
        "from keras import regularizers\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3ePtEQMG6zeQ",
        "outputId": "304592ff-0da7-404d-982d-f27f2b834305"
      },
      "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",
        "    horizontal_flip=True,\n",
        "    fill_mode='nearest',\n",
        "    vertical_flip=False\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=64,\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"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "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=(4,4),padding='valid',activation='relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(MaxPooling2D(pool_size=(3,3),strides=2,padding='valid'))\n",
        "\n",
        "\n",
        "model.add(Conv2D(256,kernel_size=(4,4),padding='valid',activation='relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(MaxPooling2D(pool_size=(3,3),strides=2,padding='valid'))\n",
        "\n",
        "model.add(Flatten())\n",
        "\n",
        "model.add(Dense(64, kernel_regularizer=regularizers.l1(0.01), activation='relu'))\n",
        "model.add(Dropout(0.3))\n",
        "\n",
        "model.add(Dense(1,activation='sigmoid'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QvCmGlD9VjnP",
        "outputId": "7698c2c3-1d96-45be-af04-0de0e5d0f333"
      },
      "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, 59, 59, 128)       131200    \n",
            "                                                                 \n",
            " batch_normalization_2 (Bat  (None, 59, 59, 128)       512       \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPoolin  (None, 29, 29, 128)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 26, 26, 256)       524544    \n",
            "                                                                 \n",
            " batch_normalization_3 (Bat  (None, 26, 26, 256)       1024      \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPoolin  (None, 12, 12, 256)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 36864)             0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 64)                2359360   \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 64)                0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1)                 65        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 3036481 (11.58 MB)\n",
            "Trainable params: 3035521 (11.58 MB)\n",
            "Non-trainable params: 960 (3.75 KB)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "v4dta_WKVlS0"
      },
      "outputs": [],
      "source": [
        "model.compile(optimizer = 'adam' , loss ='binary_crossentropy' , metrics = ['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iJkLR7WL18L2",
        "outputId": "faddf507-ef8d-4639-b752-6129412cbee7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "313/313 [==============================] - 368s 1s/step - loss: 12.1211 - accuracy: 0.5794 - val_loss: 5.8072 - val_accuracy: 0.5714\n",
            "Epoch 2/5\n",
            "313/313 [==============================] - 352s 1s/step - loss: 5.2882 - accuracy: 0.6471 - val_loss: 4.8293 - val_accuracy: 0.6754\n",
            "Epoch 3/5\n",
            "313/313 [==============================] - 350s 1s/step - loss: 4.4440 - accuracy: 0.7363 - val_loss: 4.7068 - val_accuracy: 0.5436\n",
            "Epoch 4/5\n",
            "313/313 [==============================] - 362s 1s/step - loss: 4.1051 - accuracy: 0.8063 - val_loss: 4.3334 - val_accuracy: 0.5928\n",
            "Epoch 5/5\n",
            "313/313 [==============================] - 349s 1s/step - loss: 3.7724 - accuracy: 0.8490 - val_loss: 3.6453 - val_accuracy: 0.8316\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=5,  # 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",
      "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": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 843
        },
        "id": "iO9FlT_BGbHH",
        "outputId": "d29dffea-0e2a-4f6f-924c-990bf775c751"
      },
      "execution_count": 13,
      "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": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGdCAYAAACyzRGfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABI5klEQVR4nO3deXhTVf4/8PdNui/pAl0hlAItFChQaEFAEaTKVgRcQEUEF0Coo46DDv6+4+6IOo7LKEVwARQQUSggi1iRTWRpKYVKa9lKF2gpa9N9Se7vj9C06Z42yU3S9+t57lPJvcn9HC6dvOfcc88RRFEUQURERGQmMqkLICIioo6F4YOIiIjMiuGDiIiIzIrhg4iIiMyK4YOIiIjMiuGDiIiIzIrhg4iIiMyK4YOIiIjMyk7qAurTaDS4dOkS3N3dIQiC1OUQERFRK4iiiKKiIgQGBkIma75vw+LCx6VLl6BUKqUug4iIiNogJycHXbt2bfYYiwsf7u7uALTFKxQKiashIiKi1lCpVFAqlbrv8eZYXPioudWiUCgYPoiIiKxMa4ZMcMApERERmRXDBxEREZkVwwcRERGZlcWN+SAiIuNSq9WoqqqSugyyAfb29pDL5e3+HIYPIiIbVlxcjNzcXIiiKHUpZAMEQUDXrl3h5ubWrs9h+CAislFqtRq5ublwcXGBj48PJ26kdhFFEVeuXEFubi5CQkLa1QPC8EFEZKOqqqogiiJ8fHzg7OwsdTlkA3x8fHDhwgVUVVW1K3xwwCkRkY1jjwcZi7H+LTF8EBERkVkxfBAREZFZMXwQEZFN6969Oz7++GPJP4NqccApERFZlNGjR2PQoEFG+7JPTEyEq6urUT6LjKPDhI+CkgIsT1qOsuoyvDP2HanLISKidhBFEWq1GnZ2LX+N+fj4mKEiMkSHue1y5toZvLr3VXx0+CPcKLshdTlERGYniiJKKksk2Vo7ydmcOXOwb98+fPLJJxAEAYIg4MKFC9i7dy8EQcDOnTsxZMgQODo64vfff8e5c+cwZcoU+Pn5wc3NDVFRUfj111/1PrP+LRNBEPDll19i2rRpcHFxQUhICLZu3WrQ32V2djamTJkCNzc3KBQKTJ8+HZcvX9btP3HiBMaMGQN3d3coFAoMGTIESUlJAICsrCxMnjwZXl5ecHV1Rb9+/bBjxw6Dzm/tDO752L9/P/7zn//g2LFjyMvLQ3x8PKZOnQpA+0z5v/71L+zYsQPnz5+Hh4cHoqOj8e677yIwMNDYtRtkhHIEBvoNxInLJ7AyZSVeGP6CpPUQEZlbaVUp3Ja0b2bKtip+uRiuDi3f+vjkk09w+vRp9O/fH2+++SaA2rklAGDx4sX44IMP0KNHD3h5eSEnJwcTJ07Ev//9bzg6OuKbb77B5MmTkZGRgW7dujV5njfeeAPvv/8+/vOf/+DTTz/FzJkzkZWVBW9v7xZr1Gg0uuCxb98+VFdXIzY2FjNmzMDevXsBADNnzkRERASWLVsGuVyOlJQU2NvbAwBiY2NRWVmJ/fv3w9XVFWlpae2eMdTaGNzzUVJSgoEDB2Lp0qUN9pWWliI5ORmvvPIKkpOTsWnTJmRkZODee+81SrHtIQgCFkYtBAAsS1oGjaiRuCIiIqrPw8MDDg4OcHFxgb+/P/z9/fUms3rzzTdx9913o2fPnvD29sbAgQMxf/589O/fHyEhIXjrrbfQs2fPFnsy5syZg4cffhi9evXCO++8g+LiYhw9erRVNe7evRupqalYt24dhgwZgmHDhuGbb77Bvn37kJiYCEDbMxIdHY0+ffogJCQEDz74IAYOHKjbN3LkSISHh6NHjx6IiYnBqFGj2vg3Zp0M7vmYMGECJkyY0Og+Dw8PJCQk6L322WefYejQocjOzm42hZrDzPCZeDHhRZy9fhYJ5xIwrtc4SeshIjInF3sXFL9cLNm5jSEyMlLvz8XFxXj99dexfft25OXlobq6GmVlZcjOzm72cwYMGKD7b1dXVygUChQUFLSqhvT0dCiVSiiVSt1rffv2haenJ9LT0xEVFYUXXngBTz31FL799ltER0fjwQcfRM+ePQEAzz77LBYsWIBffvkF0dHRuP/++/Xq6QhMPuajsLAQgiDA09Oz0f0VFRVQqVR6m6m4OrhizsA5AIC4pDiTnYeIyBIJggBXB1dJNmPNjFn/qZVFixYhPj4e77zzDg4cOICUlBSEh4ejsrKy2c+puQVS9+9GozFej/jrr7+OU6dOYdKkSfjtt9/Qt29fxMfHAwCeeuopnD9/HrNmzUJqaioiIyPx6aefGu3c1sCk4aO8vBz//Oc/8fDDD0OhUDR6zJIlS+Dh4aHb6iZJU6i59bLt9DZk3cwy6bmIiMhwDg4OUKvVrTr24MGDmDNnDqZNm4bw8HD4+/vrxoeYSlhYGHJycpCTk6N7LS0tDTdv3kTfvn11r4WGhuLvf/87fvnlF9x3331YuXKlbp9SqcTTTz+NTZs24R//+Ae++OILk9ZsaUwWPqqqqjB9+nSIoohly5Y1edzLL7+MwsJC3Vb3YppC7869MTZ4LDSiBsuPLTfpuYiIyHDdu3fHkSNHcOHCBVy9erXZHomQkBBs2rQJKSkpOHHiBB555BGj9mA0Jjo6GuHh4Zg5cyaSk5Nx9OhRPPbYY7jzzjsRGRmJsrIyPPPMM9i7dy+ysrJw8OBBJCYmIiwsDADw/PPPY9euXcjMzERycjL27Nmj29dRmCR81ASPrKwsJCQkNNnrAQCOjo5QKBR6m6nFRsUCAL5M/hIV1RUmPx8REbXeokWLIJfL0bdvX/j4+DQ7fuPDDz+El5cXRowYgcmTJ2PcuHEYPHiwSesTBAFbtmyBl5cXRo0ahejoaPTo0QPff/89AEAul+PatWt47LHHEBoaiunTp2PChAl44403AABqtRqxsbEICwvD+PHjERoairi4jjUUQBBb+/B1Y28WBL1HbYHa4HHmzBns2bPH4MldVCoVPDw8UFhYaLIgUq2pRvAnwchV5WLNtDWYOWCmSc5DRCSl8vJyZGZmIjg4GE5OTlKXQzaguX9Thnx/G9zzUVxcjJSUFKSkpAAAMjMzkZKSguzsbFRVVeGBBx5AUlIS1q5dC7Vajfz8fOTn57c4+Mec7GR2mD9kPgBgaWLDR4aJiIjIdAwOH0lJSYiIiEBERAQA4IUXXkBERAReffVVXLx4EVu3bkVubi4GDRqEgIAA3fbHH38Yvfj2eGrwU7CX2eNQ7iEczzsudTlEREQdhsHzfIwePbrZaXLbcRfHrPzd/HF/3/ux/s/1iEuMwxf3dqyRxkRERFLpMGu7NKZm4Ona1LVc74WIiMhMOnT4GKkciXDfcJRVl2H1idVSl0NERNQhdOjwIQiCrvcjLjGO670QERGZQYcOHwAwc8BMKBwVOHP9DHaf3y11OURERDavw4cPNwc3zB44GwAfuyUiIjKHDh8+AGBB5AIAwE+nf0J2YfMrIRIRkeXr3r07Pv74Y92fBUHA5s2bmzz+woULEARBN4dVWxnrc1oyZ84cvQk+rQ3DB4AwnzDcFXyXdr2XJK73QkRka/Ly8jBhwgSjfmZjAUCpVCIvLw/9+/c36rlsDcPHLbr1Xo5zvRciIlvj7+8PR0dHk59HLpfD398fdnYGT6PVoTB83HJv73vRxb0LCkoKsDF9o9TlEBF1SCtWrEBgYGCDlWmnTJmCJ554AgBw7tw5TJkyBX5+fnBzc0NUVBR+/fXXZj+3/m2Xo0ePIiIiAk5OToiMjMTx4/ozXavVajz55JMIDg6Gs7MzevfujU8++US3//XXX8fq1auxZcsWCIIAQRCwd+/eRm+77Nu3D0OHDoWjoyMCAgKwePFiVFdX6/aPHj0azz77LF566SV4e3vD398fr7/+ukF/bxUVFXj22Wfh6+sLJycn3H777UhMTNTtv3HjBmbOnAkfHx84OzsjJCQEK1euBABUVlbimWeeQUBAAJycnBAUFIQlS5YYdH5DMXzcUne9l7jEjrW6IBF1EKIIVJdIs7Vy9usHH3wQ165dw549e3SvXb9+HT///DNmztQuAlpcXIyJEydi9+7dOH78OMaPH4/Jkyc3u/ptXcXFxYiJiUHfvn1x7NgxvP7661i0aJHeMRqNBl27dsUPP/yAtLQ0vPrqq/h//+//YcOGDQC0K+9Onz4d48ePR15eHvLy8jBixIgG57p48SImTpyIqKgonDhxAsuWLcNXX32Ft99+W++41atXw9XVFUeOHMH777+PN998EwkJCa1qDwC89NJL2LhxI1avXo3k5GT06tUL48aNw/Xr1wEAr7zyCtLS0rBz506kp6dj2bJl6Ny5MwDgf//7H7Zu3YoNGzYgIyMDa9euRffu3Vt97rZgv1AdTw1+Cm/ufxMHcw7iRP4JDPQfKHVJRETGoy4FNrhJc+7pxYCda4uHeXl5YcKECVi3bh3Gjh0LAPjxxx/RuXNnjBkzBgAwcOBADBxY+7/Pb731FuLj47F161Y888wzLZ5j3bp10Gg0+Oqrr+Dk5IR+/fohNzcXCxYs0B1jb2+PN954Q/fn4OBgHDp0CBs2bMD06dPh5uYGZ2dnVFRUwN/fv8lzxcXFQalU4rPPPoMgCOjTpw8uXbqEf/7zn3j11Vchk2n7AAYMGIDXXnsNABASEoLPPvsMu3fvxt13391ie0pKSrBs2TKsWrVKN67liy++QEJCAr766iu8+OKLyM7ORkREBCIjIwFAL1xkZ2cjJCQEt99+OwRBQFBQUIvnbC/2fNQR4B6A+8PuB8DeDyIiqcycORMbN25ERYV2/N3atWvx0EMP6b6oi4uLsWjRIoSFhcHT0xNubm5IT09vdc9Heno6BgwYoLck/PDhwxsct3TpUgwZMgQ+Pj5wc3PDihUrWn2OuucaPnw4BEHQvTZy5EgUFxcjNzdX99qAAQP03hcQEICCgoJWnePcuXOoqqrCyJEjda/Z29tj6NChSE9PBwAsWLAA69evx6BBg/DSSy/pLfY6Z84cpKSkoHfv3nj22Wfxyy+/GNTGtmDPRz0Loxbi+1PfY03qGrx393vwdPKUuiQiIuOQu2h7IKQ6dytNnjwZoihi+/btiIqKwoEDB/DRRx/p9i9atAgJCQn44IMP0KtXLzg7O+OBBx5AZWWl0cpdv349Fi1ahP/+978YPnw43N3d8Z///AdHjhwx2jnqsre31/uzIAgNxr20x4QJE5CVlYUdO3YgISEBY8eORWxsLD744AMMHjwYmZmZ2LlzJ3799VdMnz4d0dHR+PHHH412/vrY81HPHd3uQH/f/iitKsXqFK73QkQ2RBC0tz6k2Or8P/+WODk54b777sPatWvx3XffoXfv3hg8eLBu/8GDBzFnzhxMmzYN4eHh8Pf3x4ULF1r9+WFhYTh58iTKy8t1rx0+fFjvmIMHD2LEiBFYuHAhIiIi0KtXL5w7d07vGAcHB6jV6hbPdejQIb0V3w8ePAh3d3d07dq11TU3p2fPnnBwcMDBgwd1r1VVVSExMRF9+/bVvebj44PZs2djzZo1+Pjjj7FixQrdPoVCgRkzZuCLL77A999/j40bN+rGi5gCw0c9giBgYeRCAEBcUpzePxgiIjKPmTNnYvv27fj66691A01rhISEYNOmTUhJScGJEyfwyCOPGNRL8Mgjj0AQBMydOxdpaWnYsWMHPvjggwbnSEpKwq5du3D69Gm88sorek+PANpxEydPnkRGRgauXr2KqqqqBudauHAhcnJy8Le//Q1//fUXtmzZgtdeew0vvPCC7jZSe7m6umLBggV48cUX8fPPPyMtLQ1z585FaWkpnnzySQDAq6++ii1btuDs2bM4deoUtm3bhrCwMADAhx9+iO+++w5//fUXTp8+jR9++AH+/v7w9PQ0Sn2NYfhoxKMDHoW7gztOXzuN3Zlc74WIyNzuuusueHt7IyMjA4888ojevg8//BBeXl4YMWIEJk+ejHHjxun1jLTEzc0NP/30E1JTUxEREYH/+7//w3vvvad3zPz583HfffdhxowZGDZsGK5du4aFCxfqHTN37lz07t0bkZGR8PHx0et5qNGlSxfs2LEDR48excCBA/H000/jySefxL/+9S8D/jZa9u677+L+++/HrFmzMHjwYJw9exa7du2Cl5cXAG0vzcsvv4wBAwZg1KhRkMvlWL9+PQDA3d0d77//PiIjIxEVFYULFy5gx44dRgtHjRFEC/u/9iqVCh4eHigsLIRCoZCsjmd2PIOliUsxrc80bJqxSbI6iIjaqry8HJmZmQgODtYbXEnUVs39mzLk+5s9H01YGKVNuFsytiCnMEfiaoiIiGwHw0cT+vr0xejuo6ERNVhxbEXLbyAiIqJWYfhoRs16L18kf4FKtfEe4SIiIurIGD6aMaX3FAS6B+JyyWVsSue4DyIiImNg+GiGvdwe8wbPAwAsTVwqcTVERES2geGjBXOHzIWdzA6/Z/+Ok5dPSl0OEZHBLOyhRrJixvq3xPDRgkD3QEzrMw0A13shIusil8sBwKjTjlPHVvNvqebfVltxbZdWiI2KxQ9pP2DNyTV4L/o9eDh5SF0SEVGL7Ozs4OLigitXrsDe3t6kk0aR7dNoNLhy5QpcXFxgZ9e++MDw0Qqjgkahn08/nLpyCt+c+AZ/G/Y3qUsiImqRIAgICAhAZmYmsrKypC6HbIBMJkO3bt30VultC85w2kpxiXGI3RGLPp37IG1hWrv/4omIzEWj0fDWCxmFg4NDkz1ohnx/M3y0kqpChS4fdkFxZTF2P7YbdwXfJXVJREREFoPTq5uAwlGBxwY8BoCP3RIREbUHw4cBdOu9/LUFuapciashIiKyTgwfBujn2w93Bt0Jtajmei9ERERtxPBhoJreD673QkRE1DYMHwaa1mcaAtwCkF+cj/j0eKnLISIisjoMHwayl9tj3hDtei9xSZzxlIiIyFAMH20wd/BcyAU59mftR+rlVKnLISIisioMH23QRdEF08K0670sS1omcTVERETWheGjjRZGageefnvyW6gqVBJXQ0REZD0YPtpodPfRCOschuLKYnxz4hupyyEiIrIaDB9tJAiC7rHbuMQ4WNgs9URERBaL4aMdHhv4GFztXZF+NR17L+yVuhwiIiKrwPDRDgpHBWYNmAWAj90SERG1FsNHO9XceolPj8dF1UWJqyEiIrJ8DB/tFO4Xjju63QG1qMYXyV9IXQ4REZHFY/gwgtioWADAimMrUKWukrgaIiIiy8bwYQTTwqbBz9UPecV52PzXZqnLISIismgMH0bgIHfQrfeyNHGpxNUQERFZNoYPI5k3ZB7kghz7svbhVMEpqcshIiKyWAwfRtJV0RVT+kwBoJ10jIiIiBrH8GFENQNPvzn5DYoqiiSuhoiIyDIxfBjRmO5j0KdzHxRXFuPbk99KXQ4REZFFYvgwIkEQdKvdLk1cyvVeiIiIGsHwYWQ1672kXUnD/qz9UpdDRERkcRg+jMzDyQOPDngUAB+7JSIiagzDhwno1nv5Kx6Xii5JXA0REZFlYfgwgQF+A3B7t9tRranGF8e43gsREVFdDB8mUjPwdEUy13shIiKqi+HDRO7vez/8XP1wqegStmRskbocIiIii8HwYSIOcgfMHTwXAGc8JSIiqovhw4TmDZkHmSDDngt7kHYlTepyiIiILALDhwkpPZSY0lu73suyxGUSV0NERGQZGD5MrOax29UnVnO9FyIiIjB8mNzY4LHo3ak3iiqLsDZ1rdTlEBERSY7hw8QEQcCCyAUAuN4LERERwPBhFrMHzYaLvQv+LPgTB7IPSF0OERGRpBg+zMDTyRMzw2cC4GO3REREDB9mUjPwdGP6RuQV5UlcDRERkXQYPsxkkP8gjFCOQLWmGl8mfyl1OURERJJh+DCj2KhYAMDyY8tRramWuBoiIiJpGBw+9u/fj8mTJyMwMBCCIGDz5s16+0VRxKuvvoqAgAA4OzsjOjoaZ86cMVa9Vu3+sPvh4+KDi0UXsTVjq9TlEBERScLg8FFSUoKBAwdi6dKlje5///338b///Q+ff/45jhw5AldXV4wbNw7l5eXtLtbaOdo56tZ7WZrY+N8fERGRrRPEdkw8IQgC4uPjMXXqVADaXo/AwED84x//wKJFiwAAhYWF8PPzw6pVq/DQQw+1+JkqlQoeHh4oLCyEQqFoa2kWK7swG8GfBEMjapC2MA1hPmFSl0RERNRuhnx/G3XMR2ZmJvLz8xEdHa17zcPDA8OGDcOhQ4eMeSqr1c2jGyaHTgYALEviei9ERNTxGDV85OfnAwD8/Pz0Xvfz89Ptq6+iogIqlUpvs3U1A09Xn1iN4spiiashIiIyL8mfdlmyZAk8PDx0m1KplLokkxvbYyxCvEOgqlBh7Umu90JERB2LUcOHv78/AODy5ct6r1++fFm3r76XX34ZhYWFui0nJ8eYJVkkmSDTTToWlxTH9V6IiKhDMWr4CA4Ohr+/P3bv3q17TaVS4ciRIxg+fHij73F0dIRCodDbOoLZA2fD2c4ZJy+fxMGcg1KXQ0REZDYGh4/i4mKkpKQgJSUFgHaQaUpKCrKzsyEIAp5//nm8/fbb2Lp1K1JTU/HYY48hMDBQ90QMaXk5e+nWe+Fjt0RE1JEY/Kjt3r17MWbMmAavz549G6tWrYIoinjttdewYsUK3Lx5E7fffjvi4uIQGhraqs+39Udt6zqedxyDVwyGvcwe2X/Phr9b47emiIiILJ0h39/tmufDFDpS+ACAEV+NwKHcQ3hrzFv416h/SV0OERFRm0g2zwcZrmbgKdd7ISKijoLhQ2IP9n0QnV06I1eVi58yfpK6HCIiIpNj+JCYo50jnop4CoD2sVsiIiJbx/BhAZ6OfBoyQYZfz/+KjKsZUpdDRERkUgwfFiDIMwgxoTEAuN4LERHZPoYPC7EwUjvwdFXKKpRUlkhcDRERkekwfFiIu3vejV7evVBYUYh1qeukLoeIiMhkGD4shEyQYUHkAgDaGU8tbPoVIiIio2H4sCCPD3ocznbOOHH5BA7lHpK6HCIiIpNg+LAgXs5eeLj/wwC43gsREdkuhg8LEzs0FgDww6kfcLn4ssTVEBERGR/Dh4UZHDAYw7oMQ5WmCl8d/0rqcoiIiIyO4cMCxUZpez8+T/qc670QEZHNYfiwQA/20673kqPKwfbT26Uuh4iIyKgYPiyQk50Tnox4EgAHnhIRke1h+LBQ84fMhwABCecTcPraaanLISIiMhqGDwsV7BWMSaGTAADLErneCxER2Q6GDwtWM/B0ZcpKrvdCREQ2g+HDgt3T8x709OqJwopCfPfnd1KXQ0REZBQMHxaM670QEZEtYviwcI9HPA4nOyek5KfgcO5hqcshIiJqN4YPC+ft7K1b7yUuKU7iaoiIiNqP4cMKLIxaCADYcGoDCkoKJK6GiIiofRg+rEBkYCSGdhmKSnUlvkrmei9ERGTdGD6sxMJIbe/H58c+h1qjlrgaIiKitmP4sBIz+s+At7M3sguzsf0M13shIiLrxfBhJequ9xKXyIGnRERkvRg+rMiCyAUQIGDXuV04c+2M1OUQERG1CcOHFQn2CsbEkIkAgM+TPpe4GiIiorZh+LAyNY/dfp3yNUqrSiWuhoiIyHAMH1ZmfK/xCPYMxs3ym1j/53qpyyEiIjIYw4eV4XovRERk7Rg+rNATEU/AUe6I5LxkHL14VOpyiIiIDMLwYYU6uXTCQ/0fAqDt/SAiIrImDB9WKjYqFgDw/anvcbX0qsTVEBERtR7Dh5WK6hKFyMBIrvdCRERWh+HDitX0fixLWsb1XoiIyGowfFixGf20671kFWZh59mdUpdDRETUKgwfVszZ3hlPDHoCAAeeEhGR9WD4sHJPRz4NAQJ+Pvszzl0/J3U5RERELWL4sHI9vXtifK/xALRjP4iIiCwdw4cNqBl4+vXxr1FWVSZxNURERM1j+LAB43uNR3fP7rhRfoPrvRARkcVj+LABcplct95LXFKcxNUQERE1j+HDRtSs95J0KYnrvRARkUVj+LARnV06Y0b/GQCAuET2fhARkeVi+LAhCyMXAgDW/7me670QEZHFYviwIUO7DMWQgCGoUFdg5fGVUpdDRETUKIYPGyIIAhZGaXs/uN4LERFZKoYPG/NQ/4fg5eSFzJuZ+Pnsz1KXQ0RE1ADDh41xsXfB44MeB8DHbomIyDIxfNigBVHaOT92ntmJ8zfOS1wNERGRPoYPG9TLuxfG9RwHESI+T/pc6nKIiIj0MHzYqJr1Xr46/hXXeyEiIovC8GGjJoZMRJBHEK6XXceGUxukLoeIiEiH4cNGyWVyPB35NABgaeJSiashIiKqxfBhw56MeBIOcgckXkpE4sVEqcshIiICwPBh03xcfTC933QAfOyWiIgsB8OHjasZeLr+z/W4VnpN4mqIiIgYPmzesC7DEOEfgfLqcqxM4XovREQkPYYPGycIgq73Y1nSMmhEjcQVERFRR8fw0QE8HP4wPJ08cf7Geew6u0vqcoiIqINj+OgA6q73wsduiYhIagwfHcSCSO16LzvO7EDmjUyJqyEioo6M4aODCOkUgnt63sP1XoiISHIMHx3IwsiFALTrvZRXl0tcDRERdVQMHx1ITGgMunl0w7Wya1zvhYiIJMPw0YHIZXI8PUS73ktcImc8JSIiaTB8dDBPDtau93Lk4hEcu3RM6nKIiKgDMnr4UKvVeOWVVxAcHAxnZ2f07NkTb731FkRRNPapqA18XX3xYN8HAbD3g4iIpGH08PHee+9h2bJl+Oyzz5Ceno733nsP77//Pj799FNjn4raaGGUduDpuj/X4XrZdYmrISKijsbo4eOPP/7AlClTMGnSJHTv3h0PPPAA7rnnHhw9etTYp6I2Gt51OAb5D0J5dTlWpaySuhwiIupgjB4+RowYgd27d+P06dMAgBMnTuD333/HhAkTGj2+oqICKpVKbyPTEgRB99htXGIc13shIiKzMnr4WLx4MR566CH06dMH9vb2iIiIwPPPP4+ZM2c2evySJUvg4eGh25RKpbFLokY8Ev4IPBw9cO7GOSScS5C6HCIi6kCMHj42bNiAtWvXYt26dUhOTsbq1avxwQcfYPXq1Y0e//LLL6OwsFC35eTkGLskaoSrgyvmDJoDgOu9EBGReQmikR9DUSqVWLx4MWJjY3Wvvf3221izZg3++uuvFt+vUqng4eGBwsJCKBQKY5ZG9WRczUCfpX0gQMD5586ju2d3qUsiIiIrZcj3t9F7PkpLSyGT6X+sXC6HRsNxBZamd+feiO4RDREilictl7ocIiLqIIwePiZPnox///vf2L59Oy5cuID4+Hh8+OGHmDZtmrFPRUYQG6Xtofry+Jdc74WIiMzC6OHj008/xQMPPICFCxciLCwMixYtwvz58/HWW28Z+1RkBDGhMVAqlLhaehU/pv0odTlERNQBGH3MR3txzIf5/Xv/v/GvPf/CbV1vw6EnD0ldDhERWSFJx3yQ9Xlq8FOwl9njcO5hJOclS10OERHZOIYPgp+bHx7o+wAArvdCRESmx/BBAGoHnq5LXYcbZTckroaIiGwZwwcBAEYoR2CA3wCUVZdxvRciIjIphg8CoF3vpab3Y1nSMq73QkREJsPwQTqPhD8ChaMCZ66fwa/nf5W6HCIislEMH6Tj5uCGOQPnAODAUyIiMh2GD9KzIGoBAOCn0z8huzBb4mqIiMgWMXyQnj6d+2Bs8FhoRA0+T/pc6nKIiMgGMXxQAwujFgIAvkz+EhXVFRJXQ0REtobhgxq4t/e96KroiiulV7jeCxERGR3DBzVgJ7PD/CHzAQBxSRx4SkRExsXwQY2qWe/lj5w/kJKfInU5RERkQxg+qFH+bv64v+/9APjYLRERGRfDBzVpYaR24Ona1LW4WX5T2mKIiMhmMHxQk27vdjvCfcNRWlWK1SmrpS6HiIhsBMMHNUkQBN1jt3FJcVzvhYiIjILhg5r16IBH4e7gjtPXTuO3zN+kLoeIiGwAwwc1y83BDbMHzgYALE1cKnE1RERkCxg+qEU1t162ZmxFTmGOxNUQEZG1Y/igFoX5hGFM9zHQiBosP7Zc6nKIiMjKMXxQq8RGxQIAvkj+guu9EBFRuzB8UKvc2/teBLoHoqCkAJvSN0ldDhERWTGGD2oVe7m9br0XDjwlIqL2YPigVps7eC7sZHY4mHMQJ/JPSF0OERFZKYYParUA9wDcF3YfAK73QkREbcfwQQapGXi6JnUNCssLJa6GiIisEcMHGeSObnegn08/7XovJ7jeCxERGY7hgwwiCIKu9yMuMQ6iKEpcERERWRuGDzJYzXovGdcyuN4LEREZjOGDDObu6I7HBj4GQLvaLRERkSEYPqhNFkQuAABs+WsLclW5EldDRETWhOGD2qSfbz+M7j4aalGNFcdWSF0OERFZEYYParOFkdrVblccW4FKdaXE1RARkbVg+KA2m9pnKgLcAnC55DLXeyEiolZj+KA2s5fbY96QeQA44ykREbUewwe1y7wh82Ans8OB7ANIvZwqdTlERGQFGD6oXQLdAzGtzzQA7P0gIqLWYfigdlsYpR14+u3Jb7neCxERtYjhg9rtzqA70denL0qqSvDtyW+lLoeIiCwcwwe1myAIusduud4LERG1hOGDjGLWwFlwc3BD+tV07L2wV+pyiIjIgjF8kFEoHBWYNWAWAGBp4lKJqyEiIkvG8EFGUzPwdPNfm3FRdVHiaoiIyFIxfJDR9Pftj1FBo7jeCxERNYvhg4wqNioWALAimeu9EBFR4xg+yKim9pkKfzd/5BfnY/Nfm6Uuh4iILBDDBxmVg9wB8wZr13vhwFMiImoMwwcZ3bwh8yAX5NiftR9/FvwpdTlERGRhGD7I6LooumBqn6kAuN4LERE1xPBBJlEz8PTbk99CVaGSuBoiIrIkDB9kEqO7j0ZY5zAUVxbj2xNc74WIiGoxfJBJCIKgm3QsLonrvRARUS2GDzKZWQNmwdXeFWlX0rAva5/U5RARkYVg+CCT8XDy0K33woGnRERUg+GDTKrm1kv8X/G4VHRJ4mqIiMgSMHyQSYX7heOObnegWlONL459IXU5RERkARg+yORqej+WH1uOKnWVxNUQEZHUGD7I5O4Luw9+rn7IK87jei9ERMTwQabnIHfA3MFzAWgfuyUioo6N4YPMYn7kfMgFOfZe2ItTBaekLoeIiCTE8EFm0VXRFVP6TAEALEtaJnE1REQkJYYPMpuFkdqBp9+c+AZFFUUSV0NERFJh+CCzuSv4LvTu1BtFlUVYc3KN1OUQEZFEGD7IbOqu97I0cSnXeyEi6qAYPsisZg+cDRd7F5y6cgoHsg9IXQ4REUmA4YPMysPJA4+GPwpA2/tBREQdD8MHmV3NrZdN6ZuQV5QncTVERGRuJgkfFy9exKOPPopOnTrB2dkZ4eHhSEpKMsWpyAoN9B+IkcqR2vVekrneCxFRR2P08HHjxg2MHDkS9vb22LlzJ9LS0vDf//4XXl5exj4VWbHYqFgAXO+FiKgjsjP2B7733ntQKpVYuXKl7rXg4GBjn4as3H1h98HX1ReXii5ha8ZW3N/3fqlLIiIiMzF6z8fWrVsRGRmJBx98EL6+voiIiMAXXzTdtV5RUQGVSqW3ke1ztHPUrffCgadERB2L0cPH+fPnsWzZMoSEhGDXrl1YsGABnn32WaxevbrR45csWQIPDw/dplQqjV0SWah5Q+ZBJsiw58IepF9Jl7ocIiIyE0E08kxPDg4OiIyMxB9//KF77dlnn0ViYiIOHTrU4PiKigpUVFTo/qxSqaBUKlFYWAiFQmHM0sgCTft+Gjb/tRnPRD2DTyd+KnU5RETURiqVCh4eHq36/jZ6z0dAQAD69u2r91pYWBiys7MbPd7R0REKhUJvo46jZuDp6hOrUVxZLHE1RERkDkYPHyNHjkRGRobea6dPn0ZQUJCxT0U24K7guxDaKZTrvRARdSBGDx9///vfcfjwYbzzzjs4e/Ys1q1bhxUrViA2NtbYpyIbIBNkutVu4xLjuN4LEVEHYPTwERUVhfj4eHz33Xfo378/3nrrLXz88ceYOXOmsU9FNmL2IO16L6kFqfg9+3epyyEiIhMzyQynMTExSE1NRXl5OdLT0zF37lxTnMZw51cDJVlSV0H1eDp5Yma4NpzGJcVJXA0REZlax1nbpSQLODwH2NId+GUEkPE/oIzriliKmvVeNqZtRH5xvsTVEBGRKXWc8FF5E/C7C4AAXD0EHHsOiO8C7L4LOLsCqLgmdYUd2iD/QRihHIEqTRW+TP5S6nKIiMiEOk748BoIjN0NTLsIDPkE6DwcgAhc3gMcnQ9s8gf2TATOfwNUcZZVKdQMPF1+bDmqNdUSV0NERKZi9EnG2suQSUrarfgCkL0ByFoP3Dhe+7rMEQicCAQ9BHSJAexcTFsHAQAqqiug/EiJK6VXsGn6JkwLmyZ1SURE1EqSTjJmVdy6A31fAiYkAzF/AeFvAIo+gKYCyI0HDs4ANvkCB2cCuT8B6ooWP5LaztHOEU8NfgoA13shIrJlHbvnozGiCNxM1faGZK0HSjJr99l7Asr7tD0ifmMAmdEXBe7wsm5mocf/ekAjapAem44+nftIXRIREbUCez7aQxAArwHAoHeAe88B9xwBev8dcA4Eqm4C578G9twDxAcCibFAwQFA1Ehdtc0I8gxCTGgMAGBZ4jKJqyEiIlNgz0driRrgyu/a3pDsH4CKq7X7nLsAQTO0PSLekdoAQ232y7lfMG7NOCgcFbj4wkW4ObhJXRIREbWAPR+mIMgA31FAVBwwLQ8Yswvo8Thg7wGUXQT++hDYNRT4qRdw4v+0t24sK9dZjege0QjxDoGqQoV1qeukLoeIiIyM4aMtZHZAwD3AbV8D910GRm0Bgh4G5C5A8Xng1DvAjgHAjv5A6luA6rTUFVsVmSDDgsgFALQDTy2sc46IiNqJt12MqboEuLhNe2vm0g5AU1m7z2uw9rZM0AzAtZt0NVqJG2U30OXDLiirLsPvj/+Okd1GSl0SERE1g7ddpGLnqg0Xo+KB+wqA21YBAeMBQQ7cSAZSXgK2BAG/jAQyPgXKOI14U7ycvfBI+CMA+NgtEZGtYc+HOZRfBXI2antECvYBuPVXLsgA39HaHhHlfYBjJymrtDjJeckYsmII7GX2yPl7Dvzc/KQuiYiImsCeD0vj1BkImQ9E7wGm5gKDPwY63aZ9gubyb8DRedrp3fdOAjK/5fTutwwOGIzbut7G9V6IiGwMez6kVJxZZ3r3lNrXZY5Al0naQayBEzv09O5rTq7BrPhZUCqUOP/cedhxYjciIotkyPc3w4elKPwLyP4eyPoOUGXUvm7nBnSdor01438PIHeQrkYJlFeXQ/mREldLryJ+Rjym9pkqdUlERNQI3naxRh59gPDXgEnpwIQUoO9iwLU7UF0MXFgL7JsMbPIDjjwF5P8KdJBVX53snPBUhHa9l7jEOImrISIiY2DPhyUTReDa0Vuzqn4PlOXV7nPyBZQPantEfEZoB6/aqAs3L6DHJz0gQkTGMxkI7RQqdUlERFQPez5shSAAnYcBQz4CpuQAY/cCvZ7WPhVTXgCcWQr8eof28d3kRcC1JJucVbW7Z3fdei/s/SAisn7s+bBGmiog/zft+JDceP2nY9x63prM7CHAs790NRrZrrO7MH7teHg4euDiCxfh6uAqdUlERFQHB5x2JOpy4NLP2lszF7cC6rLafR79tCGk2wxAESJdjUagETXo/VlvnL1+FvMGz0Ps0FiE+4ZD4CJ+REQWgeGjo6oq1k7vnr0euLRTf3p37yG3gsh0q53e/dMjn+LZn5/V/VmpUCImNAYxoTEY030MnO2dJayOiKhjY/ggoPImkLtZ2yOS/ysgqmv3+YwEuj0EdHsQcLaeWUNFUcQ3J77BxvSN+PX8ryirru3lcbZzRnSPaMSExmBSyCR0UXSRsFIioo6H4YP0lV+pM737fuhP7z6mzvTu3pKWaYiyqjLsubAH205vw7bT25CjytHbH+EfoesViQyMhMyGnwYiIrIEDB/UtNKLQPYP2iBy7Ujt6zJ77SRmQQ9pJzWzd5euRgOJoojUglRdEDmcexgiav9Z+7r6YlLIJMSExuDuHnfD3dF62kZEZC0YPqh1is8DWbemd795ovZ1uRMQWHd6d+saS3Gl5Ap2nt2Jbae3Yde5XVBV1D4NZC+zx+juo3W9Ij28ekhYKRGR7WD4IMMVpgNZt6Z3Lzpd+7qdG9B16q3p3e+2uundK9WV+D37d2w7vQ0/nf4JZ6+f1dsf1jlMF0RGKEdw7RgiojZi+KC2E0VtL0jWeu1WklW7z8ELUN6vDSK+owGZXLIy2+r0tdO62zMHsg+gus409Z5OnpjQawJiQmMwvtd4eDtbzxgYIiKpMXyQcYgicPXwrendNwDl+bX7nPy0T8sEPQR0Hm6V07vfLL+JX879gm2nt2HHmR24VnZNt08myDBSOVLXKxLWOYxzihARNYPhg4xPowau7L8VRH4EKq/X7nNRAkEztEHEa7B2Wngro9aoceTiEV2vSGpBqt7+YM9gXRC5M+hOONo5SlQpEZFlYvgg09JUaecOyVoP5MQD1UW1+9x61ZnevZ90NbZT1s0sbD+zHdtOb8Nvmb+hQl2h2+dq74p7et6DmNAYTAyZCH83fwkrJSKyDAwfZD7qcu1sqlnrgYs/1Zvevf+tIDIDcO8lXY3tVFJZgt2Zu3W9InnFeXr7owKjdL0iEf4RvD1DRB0SwwdJo6pYG0Cy1gN5O7U9JDW8I+tM766UrsZ20ogapOSn6IJI4qVEvf2B7oG6OUXGBo/lAnhE1GEwfJD0Km8AOZu1QeTy7nrTu99+a1bVB6xqevfG5BXl6eYU+eXcLyipKtHtc5Q74q7gu3RTvgd5BklYKRGRaTF8kGUpL6g3vfstggzwu6t2encHL+lqNIKK6grsy9qnm1Pkws0LevvDfcN1t2eGdRkGuRU+qkxE1BSGD7Jcpbna6d0vfAdcr3PLQmYP+I+7Nb37vVY1vXtjRFFE+tV03e2ZgzkHoRE1uv2dnDthYshExITGYFzPcfBw8pCwWiKi9mP4IOtQdA7I/l47s+rNk7Wvy52AwBig+8NAwASrm969MddKr2HXuV3Ydnobdp7diZvlN3X77GR2uKPbHbpekdBOodIVSkTURgwfZH0K02pnVS06U/u6nXud6d2jrW5698ZUa6rxR84ful6R9KvpevtDvEN0QeT2brfDwQbaTES2j+GDrJcoAjeO3woi3wOl2bX7HLwB5TTAPQSQuwJ2zWw1++VOFj/p2bnr53Rziuy9sBdVdZ4SUjgqMK7nOMSExmBCrwnwcfWRsFIioqYxfJBtEDX1pne/bPhnCDJA7tJ4MGkuuNi7teI4Z6NPK19UUYSE8wnYdnobtp/ZjoKSgtqmQMBtXW/T9YqE+4ZzThEishgMH2R7NGqgYB9wabt2avfqksY3dc3PcvPUVT/YGBJw9F5zq7ffBRpBQNKlJN3TMyn5KXqnViqUuiAypvsYONtb/9gYIrJeDB9EGnVtEGkpqBi6X11qnjbInfSCSqVgj6uVZbhYVojs4qtQaTQo0QAlGqBSsEMXr1CE+A1Cv4Ch8HZXNh+AZPbmaQMRdRgMH0SmJGq008i3FFyqitsWcGCGX0mZQ+t7agztxZE5WPw4GyIyPkO+v+3MVBOR7RBktV+0xiaK2ltGBvTMiFXFuF6cg0s3zuJaUTYqyq/DVQa4yQBXAXCXy6CQy+EENWS4NdeIphKorNTORGtsgryJW0m3ftorANfugFsPwC1Y+9M5wOjjZ4jIcjF8EFkSQdDOa2LnDKBz694CoNOtDQAKSgqw88xObDuzDbvO7kJRZRFwK3S4yuwwrvvtmNRjNO7uNgJKV++235qqv09TqS1AVANVKu3WWjJHwK074FonkNQNJ/bsBSWyJbztQmTDKtWVOJB1QDdo9dyNc3r7wzqH6QatjlCOgJ2sHf9/RFMFVJc2vPVUP6hU3gBKLgDF57VbSTYgVjf/2Q7eDQOJa83PbhzDQmQBOOaDiBoQRRGnr53WTm52ZhsOZB2Aus6Cf55OnpjQawJiQmMwvtd4eDt7m6cwTbV22v3i80BJ5q1QklkbTiquNP9+QQa4KPUDSd2Q4ujDMShEZsDwQUQtull+E7vO7sK2M9uw48wOXC+7rtsnE2QYqRyp6xUJ6xwm3ZwiVcW3QkmdQFKcCZTc+qkua/79dq51QkmdcOIarP2znYt52kFk4xg+iMggao0ah3MP63pF/iz4U29/sGewLojcGXQnHO0cJaq0HlHUTj5Xt7ekpM5/l+aixaeHnPzqBZK6A2G7AFx9mKhVGD6IqF0u3LyA7ae3Y9uZbfgt8zdUqit1+1ztXXFPz3sQExqDiSET4e/mL2GlLVBXaMeU6N3SqRNOqm42/36ZPeAS1LDXpOa/HbzM0gwia8DwQURGU1xZjN3nd+umfM8rztPbHxUYpesVifCPsK4p3ytv1LmdUyeclGRqB8XWWWenUfYezQyEDQLkFtJDRGQGDB9EZBIaUYPjecd1t2eSLiXp7Q90D8SkkEmICY3B2OCxcHUwwVwo5qJRA2WX9ANJ3ZBSnt/CBwiAS5emB8I6+XMgLNkUhg8iMou8ojzsOLMD285sQ8K5BJRUlej2OcodcVfwXYgJjcGkkEkI8gySsFITqC7Vf2RYN+bk1s/qkubfL3dqfiCsvbtZmkFkLAwfRGR25dXl2Hdhn65X5MLNC3r7w33DERMag3E9xyG0Uyj83Pwgs9VZTUVR+4hw/UBSE1JKs7XT9DfHsXPTA2FdlEB75mQhMgGGDyKSlCiKSLuSpgsif+T8AU29L1sHuQOUCiWCPIPQzaMbgjz0fyo9lHCyc5KoBSamqQJKcxr2mtQElYprzb9fkAMu3ZroNekBOHbiLR0yO4YPIrIo10qv4eezP2PbmW04mH0QF4suNggjjfFz9WsynAR5BsHLycu6Bri2VpWq4bwmuseILwCaiubfb+fWSK/JraDi2v3W9P1ExsXwQUQWrUpdhUtFl5BVmIXswmxk3bz1s7D2Z2lVaYuf42rv2mw4CXQPbN+U8ZZI1ABleQ17S2pCStnFlj/DOeBWMKnbc1Izt0kgF/mjNmH4ICKrJooirpddbzacFJQUtPg5ckGOLoouTYaTbh7d4ObgZoYWmZG6XNs70ti8JsXngeqi5t8vc2i46nDdHhQHD3O0gqwQwwcR2byyqjLkqHKaDCc5hTmoammeDgDezt7NhhNfV1/bGRgrikDl9cafzmn1In9egEdfwOcOwHcU0HkEAwkBYPggIoJG1CC/OF8XTuoGk5rXCisKW/wcR7kjlB7KJsOJUqG0nOnm26sti/wJMsBzEOB7K4z43AE4+Zi9dJIewwcRUSsUlhciuzC7Qa9JTTi5VHQJYktrwwDwd/NvMpwEeQTB08nTNgbGVhVrQ8iNZKBgv3YrPtfwOEWYNojUbC5dzV8rmR3DBxGREVSpq5Crym0QSrJVtbd6yqpbWFUXgJuDW7PhJMA9wHoHxpZeBAoOAFf2a38W/tnwGNdg/TDi1pOPAtsghg8iIjMQRRFXS682G06ulDZyq6IeuSBHV0XX2lCi6NbgKR6rmaq+4hpw5ffanpEbyQ0nVHMOAHzqhBGPvnzCxgYwfBARWYjSqlLkFOY0GU5yVDmo1rQwyBNAJ+dOzYYTX1dfy7y1U6UCrhy61TOyH7h2FNBU6h/j4K0dM+IzSvvTK4IzuFohhg8iIiuh1qiRX5zf7GPFqgpVi5/jZOdUO2NsvXAS5BmEroqucJA7mKFFLagu0waQgv3aQHLlD0Bdb04XOzftUzQ1PSOdorRr4ZBFY/ggIrIhheWFzYaTvKK8FgfGChAQ4B7Q7GPFnk6e5mlQXZoq4HqdAaxXfgeqbuofI3MEOg+rvVXTeThgb2Pzs9gAhg8iog6kUl1ZOzC2kXCSXZiN8uryFj9H4ahoNpwEuAVALpObtjGiBrj5Z23PSMF+oPyy/jGCHPAecuvR3lGA7+3a+UdIUgwfRESkI4oirpReaTacXC292uLn2Mns0FXRVRdKajalQqn7b3dHd2MXDxSdqdMzsh8oyap3kAB4htfepvG5A3D2N24d1CKLCh/vvvsuXn75ZTz33HP4+OOPWzye4YOIyPxKKkuQo8ppMpzkqnJbNTDW08mzNpgouumFlG4e3YzzWHFJlvax3powospoeIx7qP7jva5B7TsntchiwkdiYiKmT58OhUKBMWPGMHwQEVkptUaNvOI8XTjRbara/75ZfrPFz6m73k5TAcXDycDp2ssuA1cO1PaO3DwJ1B8D46Ks0zMyClD05lwjRmYR4aO4uBiDBw9GXFwc3n77bQwaNIjhg4jIhqkqVMgpzGkQTmpea+1jxTVjT2rCidJDqRdOurh3gb3cvukPqLwBXDlY2ztyPanhmjWOPvo9Ix7hgKnHs9g4iwgfs2fPhre3Nz766COMHj26yfBRUVGBiooK3Z9VKhWUSiXDBxGRjVFr1Lhcclk/nNTbrpVda/FzBAgIdA9s0GNSd/Ny8qqd96S6BLh6uLZn5Nph7eq/ddl7AD6314YR7yGArJmAQw0YEj5MMovL+vXrkZycjMTExBaPXbJkCd544w1TlEFERBZELpMj0D0Qge6BuK3rbY0eUzP2pKlwkqPKQaW6EheLLuJi0UUcyj3U6Oe42rs2Ekp6oluvMeg2yA/K6suwv3bo1riRg0BVIXBpu3YDALmL9pFe3VwjwwA7Z1P91XQ4Ru/5yMnJQWRkJBISEjBgwAAAYM8HEREZhUbUoKCkoDaM1NzmqTP2pKCkoMXPESDA381f+yixogtuc3XGEHkJeqkvwbckA3bV9VY8ltkD3lF1xo2MBOz5HVWXpLddNm/ejGnTpkEur713plarIQgCZDIZKioq9PbVxzEfRETUHmVVZbp5T5oaHNvcvCcCgDAHYKyrHe52d8Zwh0p0Fir0jhEhg+g1EDLfO2sf73XqbOKWWTZJw0dRURGysvSfwX788cfRp08f/POf/0T//v2bfT/DBxERmVLdBQGbCif5xfl67wm2A0Y51269GpmpPl/ujcsufVDuPRSOAdEI8I2Ej6sPZB1k0TyLGHBaV3O3Xepj+CAiIqlVVFcgV5Xb5PiTyuJMRNqV68JIf8eGn3GuEvi9QoY0dMJFp56wU4Sim2fDCdqsZsXiFkg+4JSIiMiaOdo5oqd3T/T07tnoflEUcaP8BrILs3G+MBuHr6fB/toRdC5OQ4/qiwgVStDTAejpoAFwBcAVXCw6jP0FwP4y4KMyIL1SOxtJzYrFTW3+bv4213vC6dWJiIiMrUqF6sv7UXxxJ4SCA3ArToe83lwj19QC9peJOFCmDSQpFYC6kY+yl9mjq6Jrg1Bi0mnt28DibrsYguGDiIhsTnUZcO1o7ZTwV/4A1KV6h1QKjrhgH4jjGgX2lWqQcPMmMlWXoBYbiyT6zDKtfQsYPoiIiCyZpgq4nlxnwbwD2rlG6pI5Quw0DCqPCOQ4dUea6IHMogKjTGsf6h2K10a/ZtQmMXwQERFZE40aKPxTf/Xe8nrzlQh22plX68414uDVpmnt+3Tug/TYdKM2geGDiIjImokiUHS6NowU7AdKs+sdJACeA+qEkTsAZ78GH9XYtPbOds6IHRpr1JIZPoiIiGxNSVbtYnlX9gOqjIbHuIfqL5jnGmS28hg+iIiIbF3ZZe1YkZqekZsnoX14tw6XbvphxD0UqFlwz8gYPoiIiDqayhvaRfJqwsj1JKD+kzJOvoDPrSASGgsYcf4Qhg8iIqKOrqoYuHb4Vhg5oP1v9a01bVyDgSnnjXo6znBKRETU0dm7Af7R2g0A1BXa3pCC/YCskfngzYjhg4iIqCOQO2ofz/UZKXUlsK3J4omIiMjiMXwQERGRWTF8EBERkVkxfBAREZFZMXwQERGRWTF8EBERkVkxfBAREZFZMXwQERGRWTF8EBERkVkxfBAREZFZMXwQERGRWTF8EBERkVkxfBAREZFZWdyqtqIoAgBUKpXElRAREVFr1Xxv13yPN8fiwkdRUREAQKlUSlwJERERGaqoqAgeHh7NHiOIrYkoZqTRaHDp0iW4u7tDEASjfrZKpYJSqUROTg4UCoVRP9sS2Hr7ANtvI9tn/Wy9jWyf9TNVG0VRRFFREQIDAyGTNT+qw+J6PmQyGbp27WrScygUCpv9RwXYfvsA228j22f9bL2NbJ/1M0UbW+rxqMEBp0RERGRWDB9ERERkVh0qfDg6OuK1116Do6Oj1KWYhK23D7D9NrJ91s/W28j2WT9LaKPFDTglIiIi29ahej6IiIhIegwfREREZFYMH0RERGRWDB9ERERkVjYXPpYuXYru3bvDyckJw4YNw9GjR5s9/ocffkCfPn3g5OSE8PBw7Nixw0yVto0h7Vu1ahUEQdDbnJyczFitYfbv34/JkycjMDAQgiBg8+bNLb5n7969GDx4MBwdHdGrVy+sWrXK5HW2h6Ft3Lt3b4NrKAgC8vPzzVOwAZYsWYKoqCi4u7vD19cXU6dORUZGRovvs6bfwba00Zp+D5ctW4YBAwboJp8aPnw4du7c2ex7rOn6AYa30ZquX2PeffddCIKA559/vtnjzH0dbSp8fP/993jhhRfw2muvITk5GQMHDsS4ceNQUFDQ6PF//PEHHn74YTz55JM4fvw4pk6diqlTp+LPP/80c+WtY2j7AO0Mdnl5ebotKyvLjBUbpqSkBAMHDsTSpUtbdXxmZiYmTZqEMWPGICUlBc8//zyeeuop7Nq1y8SVtp2hbayRkZGhdx19fX1NVGHb7du3D7GxsTh8+DASEhJQVVWFe+65ByUlJU2+x9p+B9vSRsB6fg+7du2Kd999F8eOHUNSUhLuuusuTJkyBadOnWr0eGu7foDhbQSs5/rVl5iYiOXLl2PAgAHNHifJdRRtyNChQ8XY2Fjdn9VqtRgYGCguWbKk0eOnT58uTpo0Se+1YcOGifPnzzdpnW1laPtWrlwpenh4mKk64wIgxsfHN3vMSy+9JPbr10/vtRkzZojjxo0zYWXG05o27tmzRwQg3rhxwyw1GVNBQYEIQNy3b1+Tx1jb72B9rWmjNf8eiqIoenl5iV9++WWj+6z9+tVoro3Wev2KiorEkJAQMSEhQbzzzjvF5557rsljpbiONtPzUVlZiWPHjiE6Olr3mkwmQ3R0NA4dOtToew4dOqR3PACMGzeuyeOl1Jb2AUBxcTGCgoKgVCpbTPfWxpquX3sNGjQIAQEBuPvuu3Hw4EGpy2mVwsJCAIC3t3eTx1j7NWxNGwHr/D1Uq9VYv349SkpKMHz48EaPsfbr15o2AtZ5/WJjYzFp0qQG16cxUlxHmwkfV69ehVqthp+fn97rfn5+Td4fz8/PN+h4KbWlfb1798bXX3+NLVu2YM2aNdBoNBgxYgRyc3PNUbLJNXX9VCoVysrKJKrKuAICAvD5559j48aN2LhxI5RKJUaPHo3k5GSpS2uWRqPB888/j5EjR6J///5NHmdNv4P1tbaN1vZ7mJqaCjc3Nzg6OuLpp59GfHw8+vbt2+ix1nr9DGmjtV0/AFi/fj2Sk5OxZMmSVh0vxXW0uFVtyXiGDx+ul+ZHjBiBsLAwLF++HG+99ZaElVFr9e7dG71799b9ecSIETh37hw++ugjfPvttxJW1rzY2Fj8+eef+P3336UuxWRa20Zr+z3s3bs3UlJSUFhYiB9//BGzZ8/Gvn37mvxytkaGtNHarl9OTg6ee+45JCQkWPTAWJsJH507d4ZcLsfly5f1Xr98+TL8/f0bfY+/v79Bx0upLe2rz97eHhERETh79qwpSjS7pq6fQqGAs7OzRFWZ3tChQy36S/2ZZ57Btm3bsH//fnTt2rXZY63pd7AuQ9pYn6X/Hjo4OKBXr14AgCFDhiAxMRGffPIJli9f3uBYa71+hrSxPku/fseOHUNBQQEGDx6se02tVmP//v347LPPUFFRAblcrvceKa6jzdx2cXBwwJAhQ7B7927daxqNBrt3727yXt7w4cP1jgeAhISEZu/9SaUt7atPrVYjNTUVAQEBpirTrKzp+hlTSkqKRV5DURTxzDPPID4+Hr/99huCg4NbfI+1XcO2tLE+a/s91Gg0qKioaHSftV2/pjTXxvos/fqNHTsWqampSElJ0W2RkZGYOXMmUlJSGgQPQKLraLKhrBJYv3696OjoKK5atUpMS0sT582bJ3p6eor5+fmiKIrirFmzxMWLF+uOP3jwoGhnZyd+8MEHYnp6uvjaa6+J9vb2YmpqqlRNaJah7XvjjTfEXbt2iefOnROPHTsmPvTQQ6KTk5N46tQpqZrQrKKiIvH48ePi8ePHRQDihx9+KB4/flzMysoSRVEUFy9eLM6aNUt3/Pnz50UXFxfxxRdfFNPT08WlS5eKcrlc/Pnnn6VqQosMbeNHH30kbt68WTxz5oyYmpoqPvfcc6JMJhN//fVXqZrQpAULFogeHh7i3r17xby8PN1WWlqqO8bafwfb0kZr+j1cvHixuG/fPjEzM1M8efKkuHjxYlEQBPGXX34RRdH6r58oGt5Ga7p+Tan/tIslXEebCh+iKIqffvqp2K1bN9HBwUEcOnSoePjwYd2+O++8U5w9e7be8Rs2bBBDQ0NFBwcHsV+/fuL27dvNXLFhDGnf888/rzvWz89PnDhxopicnCxB1a1T81hp/a2mTbNnzxbvvPPOBu8ZNGiQ6ODgIPbo0UNcuXKl2es2hKFtfO+998SePXuKTk5Oore3tzh69Gjxt99+k6b4FjTWLgB618Tafwfb0kZr+j184oknxKCgINHBwUH08fERx44dq/tSFkXrv36iaHgbren6NaV++LCE6yiIoiiarl+FiIiISJ/NjPkgIiIi68DwQURERGbF8EFERERmxfBBREREZsXwQURERGbF8EFERERmxfBBREREZsXwQURERGbF8EFERERmxfBBREREZsXwQURERGbF8EFERERm9f8B4PvwqSIGRtoAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}