Recurrent Neural Network (RNN).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from tqdm import tqdm\n",
    "import pandas as pd\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.tokenize import word_tokenize\n",
    "import nltk\n",
    "import tensorflow as tf\n",
    "from gensim.models import Word2Vec\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "import os\n",
    "from keras.models import load_model\n",
    "from sklearn.metrics import confusion_matrix, classification_report, roc_auc_score\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from keras.layers import LSTM, Dropout, Dense"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\hp\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n",
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     C:\\Users\\hp\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('punkt')\n",
    "nltk.download('stopwords')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>prompt_id</th>\n",
       "      <th>text</th>\n",
       "      <th>generated</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0059830c</td>\n",
       "      <td>0</td>\n",
       "      <td>Cars. Cars have been around since they became ...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>005db917</td>\n",
       "      <td>0</td>\n",
       "      <td>Transportation is a large necessity in most co...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>008f63e3</td>\n",
       "      <td>0</td>\n",
       "      <td>\"America's love affair with it's vehicles seem...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>00940276</td>\n",
       "      <td>0</td>\n",
       "      <td>How often do you ride in a car? Do you drive a...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>00c39458</td>\n",
       "      <td>0</td>\n",
       "      <td>Cars are a wonderful thing. They are perhaps o...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1373</th>\n",
       "      <td>fe6ff9a5</td>\n",
       "      <td>1</td>\n",
       "      <td>There has been a fuss about the Elector Colleg...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1374</th>\n",
       "      <td>ff669174</td>\n",
       "      <td>0</td>\n",
       "      <td>Limiting car usage has many advantages. Such a...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1375</th>\n",
       "      <td>ffa247e0</td>\n",
       "      <td>0</td>\n",
       "      <td>There's a new trend that has been developing f...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1376</th>\n",
       "      <td>ffc237e9</td>\n",
       "      <td>0</td>\n",
       "      <td>As we all know cars are a big part of our soci...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1377</th>\n",
       "      <td>ffe1ca0d</td>\n",
       "      <td>0</td>\n",
       "      <td>Cars have been around since the 1800's and hav...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1378 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            id  prompt_id                                               text  \\\n",
       "0     0059830c          0  Cars. Cars have been around since they became ...   \n",
       "1     005db917          0  Transportation is a large necessity in most co...   \n",
       "2     008f63e3          0  \"America's love affair with it's vehicles seem...   \n",
       "3     00940276          0  How often do you ride in a car? Do you drive a...   \n",
       "4     00c39458          0  Cars are a wonderful thing. They are perhaps o...   \n",
       "...        ...        ...                                                ...   \n",
       "1373  fe6ff9a5          1  There has been a fuss about the Elector Colleg...   \n",
       "1374  ff669174          0  Limiting car usage has many advantages. Such a...   \n",
       "1375  ffa247e0          0  There's a new trend that has been developing f...   \n",
       "1376  ffc237e9          0  As we all know cars are a big part of our soci...   \n",
       "1377  ffe1ca0d          0  Cars have been around since the 1800's and hav...   \n",
       "\n",
       "      generated  \n",
       "0             0  \n",
       "1             0  \n",
       "2             0  \n",
       "3             0  \n",
       "4             0  \n",
       "...         ...  \n",
       "1373          0  \n",
       "1374          0  \n",
       "1375          0  \n",
       "1376          0  \n",
       "1377          0  \n",
       "\n",
       "[1378 rows x 4 columns]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the data\n",
    "df = pd.read_csv('Data/train_essays/train_essays.csv')\n",
    "\n",
    "# Display the data\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>prompt_id</th>\n",
       "      <th>prompt_name</th>\n",
       "      <th>instructions</th>\n",
       "      <th>source_text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>Car-free cities</td>\n",
       "      <td>Write an explanatory essay to inform fellow ci...</td>\n",
       "      <td># In German Suburb, Life Goes On Without Cars ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>Does the electoral college work?</td>\n",
       "      <td>Write a letter to your state senator in which ...</td>\n",
       "      <td># What Is the Electoral College? by the Office...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   prompt_id                       prompt_name  \\\n",
       "0          0                   Car-free cities   \n",
       "1          1  Does the electoral college work?   \n",
       "\n",
       "                                        instructions  \\\n",
       "0  Write an explanatory essay to inform fellow ci...   \n",
       "1  Write a letter to your state senator in which ...   \n",
       "\n",
       "                                         source_text  \n",
       "0  # In German Suburb, Life Goes On Without Cars ...  \n",
       "1  # What Is the Electoral College? by the Office...  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the data\n",
    "df_prompts = pd.read_csv('Data/train_prompts.csv')\n",
    "\n",
    "# Display the data\n",
    "df_prompts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1378/1378 [02:11<00:00, 10.51it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elapsed time: 00:02:32.98\n"
     ]
    }
   ],
   "source": [
    "# Initialize the lemmatizer\n",
    "lemmatizer = WordNetLemmatizer()\n",
    "\n",
    "# Define the function to preprocess the text\n",
    "def preprocess_text(text):\n",
    "    # Tokenize the text\n",
    "    words = word_tokenize(text)\n",
    "    \n",
    "    # Remove stopwords and lemmatize the words\n",
    "    words = [lemmatizer.lemmatize(word) for word in words if word not in stopwords.words('english')]\n",
    "    \n",
    "    return words\n",
    "\n",
    "# Initialize tqdm for pandas\n",
    "tqdm.pandas()\n",
    "\n",
    "# Define a function to apply to the DataFrame\n",
    "def preprocess_df(df):\n",
    "    # Apply the preprocess_text function to the 'text' column with a progress bar\n",
    "    return df['text'].progress_apply(preprocess_text)\n",
    "\n",
    "# Start the timer\n",
    "start_time = time.time()\n",
    "\n",
    "# Preprocess the text\n",
    "df['text'] = preprocess_df(df)\n",
    "\n",
    "# Train a Word2Vec model\n",
    "model = Word2Vec(df['text'].tolist(), vector_size=100, window=5, min_count=1, workers=4)\n",
    "\n",
    "# Convert words into numerical representations\n",
    "df['text'] = df['text'].apply(lambda text: [model.wv[word] for word in text])\n",
    "\n",
    "# Pad the sequences\n",
    "df['text'] = pad_sequences(df['text']).tolist()\n",
    "\n",
    "# Convert the list of sequences into a numpy array\n",
    "X = np.array(df['text'].tolist())\n",
    "\n",
    "#  y is target variable\n",
    "y = np.array(df['generated'].tolist())\n",
    "\n",
    "# End the timer and print the elapsed time\n",
    "end_time = time.time()\n",
    "elapsed_time = end_time - start_time\n",
    "hours, rem = divmod(elapsed_time, 3600)\n",
    "minutes, seconds = divmod(rem, 60)\n",
    "print(f\"Elapsed time: {int(hours):02d}:{int(minutes):02d}:{seconds:05.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code is performing several steps to preprocess text data and prepare it for a machine learning model. Here's a step-by-step explanation:\n",
    "\n",
    "1. **Initialize the lemmatizer**: The `WordNetLemmatizer` from the `nltk` library is used to reduce words to their base or root form (e.g., \"running\" to \"run\").\n",
    "\n",
    "2. **Define the preprocess_text function**: This function takes a string of text, tokenizes it into individual words, removes stopwords (common words like \"and\", \"the\", \"is\", etc.), and lemmatizes the remaining words.\n",
    "\n",
    "3. **Initialize tqdm for pandas**: `tqdm` is a library that provides a fast, extensible progress bar. The `tqdm.pandas()` function modifies pandas to include progress bars when applying functions across a DataFrame.\n",
    "\n",
    "4. **Preprocess the text**: The `preprocess_text` function is applied to the 'text' column of the DataFrame, transforming the raw text into a list of preprocessed words.\n",
    "\n",
    "5. **Train a Word2Vec model**: A Word2Vec model is trained on the preprocessed text. Word2Vec is a technique for natural language processing where words are mapped to vectors of real numbers. It represents words in a coordinate system where related words, based on a corpus of text, are placed closer together.\n",
    "\n",
    "6. **Convert words into numerical representations**: The words in the 'text' column are replaced with their corresponding vector representations from the trained Word2Vec model.\n",
    "\n",
    "7. **Pad the sequences**: The sequences are padded to ensure they all have the same length. This is typically required for neural networks which expect input tensors to have the same shape.\n",
    "\n",
    "8. **Convert the list of sequences into a numpy array**: The preprocessed and padded text data is converted into a numpy array, which can be used as input to a machine learning model.\n",
    "\n",
    "9. **Convert the target variable into a numpy array**: The target variable is also converted into a numpy array.\n",
    "\n",
    "10. **Print the elapsed time**: The time taken to execute the above steps is calculated and printed. This is useful for performance analysis.\n",
    "\n",
    "This code is preparing the data for a machine learning model that can handle sequence data, such as a Recurrent Neural Network (RNN)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the data into training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data shape: 1102\n",
      "Test data shape: 276\n",
      "Training labels shape: 1102\n",
      "Test labels shape: 276\n"
     ]
    }
   ],
   "source": [
    "print(f\"Training data shape: {X_train.shape[0]}\")\n",
    "print(f\"Test data shape: {X_test.shape[0]}\")\n",
    "print(f\"Training labels shape: {y_train.shape[0]}\")\n",
    "print(f\"Test labels shape: {y_test.shape[0]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "35/35 [==============================] - 110s 2s/step - loss: 0.0752 - accuracy: 0.9719 - val_loss: 0.0315 - val_accuracy: 0.9964\n",
      "Epoch 2/10\n",
      "35/35 [==============================] - 70s 2s/step - loss: 0.0161 - accuracy: 0.9982 - val_loss: 0.0262 - val_accuracy: 0.9964\n",
      "Epoch 3/10\n",
      "35/35 [==============================] - 76s 2s/step - loss: 0.0159 - accuracy: 0.9982 - val_loss: 0.0247 - val_accuracy: 0.9964\n",
      "Epoch 4/10\n",
      "35/35 [==============================] - 73s 2s/step - loss: 0.0134 - accuracy: 0.9982 - val_loss: 0.0253 - val_accuracy: 0.9964\n",
      "Epoch 5/10\n",
      "35/35 [==============================] - 73s 2s/step - loss: 0.0137 - accuracy: 0.9982 - val_loss: 0.0248 - val_accuracy: 0.9964\n",
      "Epoch 6/10\n",
      "35/35 [==============================] - 72s 2s/step - loss: 0.0131 - accuracy: 0.9982 - val_loss: 0.0263 - val_accuracy: 0.9964\n",
      "Epoch 7/10\n",
      "35/35 [==============================] - 82s 2s/step - loss: 0.0130 - accuracy: 0.9982 - val_loss: 0.0261 - val_accuracy: 0.9964\n",
      "Epoch 8/10\n",
      "35/35 [==============================] - 68s 2s/step - loss: 0.0127 - accuracy: 0.9982 - val_loss: 0.0273 - val_accuracy: 0.9964\n",
      "Epoch 9/10\n",
      "35/35 [==============================] - 71s 2s/step - loss: 0.0136 - accuracy: 0.9982 - val_loss: 0.0284 - val_accuracy: 0.9964\n",
      "Epoch 10/10\n",
      "35/35 [==============================] - 90s 3s/step - loss: 0.0118 - accuracy: 0.9982 - val_loss: 0.0274 - val_accuracy: 0.9964\n"
     ]
    }
   ],
   "source": [
    "# Define the size of the vocabulary, the embedding dimension, and the maximum sequence length\n",
    "vocab_size = len(model.wv.key_to_index) + 1  # Adding 1 because of reserved 0 index for padding\n",
    "embedding_dim = 100  # This should match the size of the Word2Vec vectors 🙂\n",
    "max_seq_length = len(max(df['text'], key=len))\n",
    "\n",
    "# Build the RNN model\n",
    "model_rnn = tf.keras.Sequential([\n",
    "    LSTM(units=128, return_sequences=True, input_shape=(max_seq_length, embedding_dim)),\n",
    "    Dropout(0.2),\n",
    "    LSTM(units=128),\n",
    "    Dropout(0.2),\n",
    "    Dense(1, activation='sigmoid')\n",
    "])\n",
    "\n",
    "# Compile the model\n",
    "model_rnn.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "\n",
    "# Fit the model\n",
    "history = model_rnn.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model used in this code is a simple Recurrent Neural Network (RNN) built using TensorFlow's Keras API.\n",
    "\n",
    "Here's a breakdown of the model:\n",
    "\n",
    "1. `tf.keras.Sequential`: This is used to initialize a linear stack of layers. In this case, the model consists of two layers.\n",
    "\n",
    "2. `tf.keras.layers.SimpleRNN(units=128, input_shape=(max_seq_length, embedding_dim))`: This is the first layer of the model, a simple RNN layer with 128 units. The `input_shape` is set to `(max_seq_length, embedding_dim)`, which corresponds to the maximum length of the sequences and the size of the embeddings, respectively.\n",
    "\n",
    "3. `tf.keras.layers.Dense(1, activation='sigmoid')`: This is the second layer of the model, a dense (fully connected) layer with one unit. The activation function is set to 'sigmoid', which is commonly used for binary classification problems.\n",
    "\n",
    "The model is then compiled with the 'adam' optimizer and the 'binary_crossentropy' loss function, which are common choices for binary classification problems. The 'accuracy' metric is used to evaluate the model.\n",
    "\n",
    "Finally, the model is trained on the training data for 10 epochs with a batch size of 32, and the validation data is set to `(X_test, y_test)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9/9 [==============================] - 5s 528ms/step - loss: 0.0274 - accuracy: 0.9964\n",
      "Accuracy: 99.63768124580383%\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the model\n",
    "loss, accuracy = model_rnn.evaluate(X_test, y_test)\n",
    "print(f'Accuracy: {accuracy * 100}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAMWCAYAAADs4eXxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABijklEQVR4nO3deXiddZk//nfSLelK25RuljZUBpRBQMAKOs6o1bKIwKAIMgNUhUEBRRS/gGyyKqOIgOIyig6byCLDTwcYqAuDIiCrDosCTSgtLaSlCy3dkvP7o8mB2IUmzclJcl6v68olefLknPt0qte8+dzPfVcVCoVCAAAAgC5XXe4CAAAAoK8SugEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBIRugEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBIRugGgF6qqqsrZZ5/d4d9raGhIVVVVfvzjH3d5TQDA+oRuAOikH//4x6mqqkpVVVXuueee9X5eKBQyadKkVFVV5UMf+lAZKgQAyk3oBoAtVFNTk2uvvXa967/97W/z/PPPZ9CgQWWoCgDoCYRuANhC++67b2644YasXbu23fVrr702u+22W8aNG1emyirH8uXLy10CAGyQ0A0AW+iwww7LwoULc+eddxavrV69OjfeeGM+/vGPb/B3li9fni984QuZNGlSBg0alO233z5f//rXUygU2t23atWqfP7zn8+YMWMybNiwfPjDH87zzz+/wdecO3duPvGJT2Ts2LEZNGhQdtxxx/zoRz/q1GdatGhRvvjFL2annXbK0KFDM3z48Oyzzz559NFH17t35cqVOfvss/N3f/d3qampyfjx4/PP//zPeeaZZ4r3tLS05Fvf+lZ22mmn1NTUZMyYMdl7773zxz/+McmmnzX/2+fXzz777FRVVeXxxx/Pxz/+8YwcOTLvfve7kySPPfZYjjrqqGy77bapqanJuHHj8olPfCILFy7c4J/XJz/5yUyYMCGDBg1KfX19Pv3pT2f16tV59tlnU1VVlW9+85vr/d7vf//7VFVV5brrruvoHysAFah/uQsAgN5uypQp2XPPPXPddddln332SZLcdtttWbJkSQ499NBceuml7e4vFAr58Ic/nF//+tf55Cc/mV122SV33HFHTj755MydO7dd0PvUpz6Vq6++Oh//+Mez11575Ve/+lX222+/9WpYsGBB3vnOd6aqqirHH398xowZk9tuuy2f/OQns3Tp0px44okd+kzPPvtsbrnllnz0ox9NfX19FixYkO9973v5x3/8xzz++OOZMGFCkqS5uTkf+tCHMmvWrBx66KH53Oc+l2XLluXOO+/Mn//850ydOjVJ8slPfjI//vGPs88+++RTn/pU1q5dm//93//NH/7wh+y+++4dqq3NRz/60Wy33Xa54IILiv+y4s4778yzzz6bmTNnZty4cfm///u/fP/738///d//5Q9/+EOqqqqSJPPmzcs73vGOLF68OMccc0x22GGHzJ07NzfeeGNWrFiRbbfdNu9617tyzTXX5POf/3y7973mmmsybNiwHHDAAZ2qG4AKUwAAOuXKK68sJCk88MADhcsvv7wwbNiwwooVKwqFQqHw0Y9+tPDe9763UCgUCpMnTy7st99+xd+75ZZbCkkK5513XrvX+8hHPlKoqqoqPP3004VCoVB45JFHCkkKn/nMZ9rd9/GPf7yQpHDWWWcVr33yk58sjB8/vtDU1NTu3kMPPbQwYsSIYl2zZ88uJClceeWVm/xsK1euLDQ3N7e7Nnv27MKgQYMK55xzTvHaj370o0KSwsUXX7zea7S0tBQKhULhV7/6VSFJ4bOf/exG79lUXX/7Wc8666xCksJhhx223r1tn/P1rrvuukKSwt133128dsQRRxSqq6sLDzzwwEZr+t73vldIUnjiiSeKP1u9enWhrq6ucOSRR673ewCwIdrLAaALHHLIIXn11Vfzi1/8IsuWLcsvfvGLjbaW//d//3f69euXz372s+2uf+ELX0ihUMhtt91WvC/Jevf97al1oVDITTfdlP333z+FQiFNTU3FrxkzZmTJkiV56KGHOvR5Bg0alOrqdf9vQnNzcxYuXJihQ4dm++23b/daN910U+rq6nLCCSes9xptp8o33XRTqqqqctZZZ230ns449thj17tWW1tb/OeVK1emqakp73znO5OkWHdLS0tuueWW7L///hs8ZW+r6ZBDDklNTU2uueaa4s/uuOOONDU15V/+5V86XTcAlUXoBoAuMGbMmEyfPj3XXnttbr755jQ3N+cjH/nIBu9tbGzMhAkTMmzYsHbX3/KWtxR/3vaf1dXVxRbtNttvv32771966aUsXrw43//+9zNmzJh2XzNnzkySvPjiix36PC0tLfnmN7+Z7bbbLoMGDUpdXV3GjBmTxx57LEuWLCne98wzz2T77bdP//4bf2LtmWeeyYQJEzJq1KgO1fBG6uvr17u2aNGifO5zn8vYsWNTW1ubMWPGFO9rq/ull17K0qVL8/d///ebfP2tttoq+++/f7vJ9Ndcc00mTpyY973vfV34SQDoyzzTDQBd5OMf/3iOPvrozJ8/P/vss0+22mqrbnnflpaWJMm//Mu/5Mgjj9zgPW9729s69JoXXHBBzjjjjHziE5/Iueeem1GjRqW6ujonnnhi8f260sZOvJubmzf6O68/1W5zyCGH5Pe//31OPvnk7LLLLhk6dGhaWlqy9957d6ruI444IjfccEN+//vfZ6eddsqtt96az3zmM8UuAAB4I0I3AHSRgw46KP/2b/+WP/zhD7n++us3et/kyZNz1113ZdmyZe1Ou5988sniz9v+s6WlpXia3Oapp55q93ptk82bm5szffr0LvksN954Y9773vfmhz/8YbvrixcvTl1dXfH7qVOn5r777suaNWsyYMCADb7W1KlTc8cdd2TRokUbPe0eOXJk8fVfr+3Uf3O8/PLLmTVrVr7yla/kzDPPLF7/61//2u6+MWPGZPjw4fnzn//8hq+59957Z8yYMbnmmmsybdq0rFixIv/6r/+62TUBgH9NCwBdZOjQobniiity9tlnZ//999/offvuu2+am5tz+eWXt7v+zW9+M1VVVcUJ6G3/+bfTzy+55JJ23/fr1y8HH3xwbrrppg0GyZdeeqnDn6Vfv37rrS+74YYbMnfu3HbXDj744DQ1Na33WZIUf//ggw9OoVDIV77ylY3eM3z48NTV1eXuu+9u9/PvfOc7Har59a/Z5m//vKqrq3PggQfm//v//r/iyrIN1ZQk/fv3z2GHHZaf/exn+fGPf5yddtqpw10DAFQ2J90A0IU21t79evvvv3/e+9735stf/nIaGhqy884753/+53/yX//1XznxxBOLz3DvsssuOeyww/Kd73wnS5YsyV577ZVZs2bl6aefXu81v/rVr+bXv/51pk2blqOPPjpvfetbs2jRojz00EO56667smjRog59jg996EM555xzMnPmzOy1117505/+lGuuuSbbbrttu/uOOOKI/Od//mdOOumk3H///fmHf/iHLF++PHfddVc+85nP5IADDsh73/ve/Ou//msuvfTS/PWvfy22ev/v//5v3vve9+b4449Psm492le/+tV86lOfyu6775677747f/nLXza75uHDh+c973lPLrrooqxZsyYTJ07M//zP/2T27Nnr3XvBBRfkf/7nf/KP//iPOeaYY/KWt7wlL7zwQm644Ybcc8897R4NOOKII3LppZfm17/+db72ta916M8RAIRuAOhm1dXVufXWW3PmmWfm+uuvz5VXXpkpU6bk3//93/OFL3yh3b0/+tGPiu3Nt9xyS973vvfll7/8ZSZNmtTuvrFjx+b+++/POeeck5tvvjnf+c53Mnr06Oy4446dCoqnnXZali9fnmuvvTbXX3993v72t+eXv/xlTjnllHb39evXL//93/+d888/P9dee21uuummjB49Ou9+97uz0047Fe+78sor87a3vS0//OEPc/LJJ2fEiBHZfffds9deexXvOfPMM/PSSy/lxhtvzM9+9rPss88+ue2227L11ltvdt3XXnttTjjhhHz7299OoVDIBz/4wdx2223FveJtJk6cmPvuuy9nnHFGrrnmmixdujQTJ07MPvvsk8GDB7e7d7fddsuOO+6YJ554IocffnhH/hgBIFWFv+3BAgCgnV133TWjRo3KrFmzyl0KAL2MZ7oBADbhj3/8Yx555JEcccQR5S4FgF7ISTcAwAb8+c9/zoMPPphvfOMbaWpqyrPPPpuamppylwVAL+OkGwBgA2688cbMnDkza9asyXXXXSdwA9ApTroBAACgRJx0AwAAQIkI3QAAAFAi9nR3UktLS+bNm5dhw4alqqqq3OUAAADQjQqFQpYtW5YJEyakunrj59lCdyfNmzcvkyZNKncZAAAAlNGcOXPypje9aaM/F7o7adiwYUnW/QEPHz68zNUAAADQnZYuXZpJkyYVs+HGCN2d1NZSPnz4cKEbAACgQr3R48YGqQEAAECJCN0AAABQIkI3AAAAlIhnukusubk5a9asKXcZvdbAgQM3OX4fAACgJxO6S6RQKGT+/PlZvHhxuUvp1aqrq1NfX5+BAweWuxQAAIAOE7pLpC1wb7311hk8ePAbTrRjfS0tLZk3b15eeOGFbLPNNv4MAQCAXkfoLoHm5uZi4B49enS5y+nVxowZk3nz5mXt2rUZMGBAucsBAADoEA/LlkDbM9yDBw8ucyW9X1tbeXNzc5krAQAA6Dihu4S0Q285f4YAAEBvJnQDAABAiQjdlNSUKVNyySWXlLsMAACAshC6SbKujXtTX2effXanXveBBx7IMccc07XFAgAA9BKml5MkeeGFF4r/fP311+fMM8/MU089Vbw2dOjQ4j8XCoU0Nzenf/83/uszZsyYri0UAACgF3HSTZJk3Lhxxa8RI0akqqqq+P2TTz6ZYcOG5bbbbstuu+2WQYMG5Z577skzzzyTAw44IGPHjs3QoUOzxx575K677mr3un/bXl5VVZX/+I//yEEHHZTBgwdnu+22y6233trNnxYAAKB7CN3doFAoZMXqtWX5KhQKXfY5TjnllHz1q1/NE088kbe97W155ZVXsu+++2bWrFl5+OGHs/fee2f//ffPc889t8nX+cpXvpJDDjkkjz32WPbdd98cfvjhWbRoUZfVCQAA0FNoL+8Gr65pzlvPvKMs7/34OTMyeGDX/J/5nHPOyQc+8IHi96NGjcrOO+9c/P7cc8/Nz3/+89x66605/vjjN/o6Rx11VA477LAkyQUXXJBLL700999/f/bee+8uqRMAAKCncNLNZtt9993bff/KK6/ki1/8Yt7ylrdkq622ytChQ/PEE0+84Un32972tuI/DxkyJMOHD8+LL75YkpoBAADKyUl3N6gd0C+PnzOjbO/dVYYMGdLu+y9+8Yu588478/Wvfz1vfvObU1tbm4985CNZvXr1Jl9nwIAB7b6vqqpKS0tLl9UJAADQUwjd3aCqqqrLWrx7kt/97nc56qijctBBByVZd/Ld0NBQ3qIAAAB6EO3ldNp2222Xm2++OY888kgeffTRfPzjH3diDQAA8DpCN5128cUXZ+TIkdlrr72y//77Z8aMGXn7299e7rIAAAB6jKpCV+6UqiBLly7NiBEjsmTJkgwfPrzdz1auXJnZs2envr4+NTU1Zaqwb/BnCQAA9ESbyoSv56QbAAAASkToBgAAgBIRugEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBLpX+4CoLcrFAr5+v88lafmv1LuUgAAoE+5+GM7Z3jNgHKXsUWEbthCT7ywLN/+9TPlLgMAAPqcNWtbyl3CFhO6YQs927TuhHvbMUNy9D9sW+ZqAACg7xgyqPdH1t7/CaDMGheuSJLsOmlkDnvHNmWuBgAA6EkMUiNJUlVVtcmvs88+e4te+5ZbbumyWnua2U3LkyRTRg8ucyUAAEBP46SbJMkLL7xQ/Ofrr78+Z555Zp566qnitaFDh5ajrF6hceG60D25bkiZKwEAAHoaJ90kScaNG1f8GjFiRKqqqtpd++lPf5q3vOUtqampyQ477JDvfOc7xd9dvXp1jj/++IwfPz41NTWZPHlyLrzwwiTJlClTkiQHHXRQqqqqit/3JQ2t7eX1o4VuAACgPSfd3aFQSNasKM97DxicVFVt0Utcc801OfPMM3P55Zdn1113zcMPP5yjjz46Q4YMyZFHHplLL700t956a372s59lm222yZw5czJnzpwkyQMPPJCtt946V155Zfbee+/069evKz5Vj/HKqrV5admqJMk22ssBAIC/IXR3hzUrkgsmlOe9T5uXDNyyE9izzjor3/jGN/LP//zPSZL6+vo8/vjj+d73vpcjjzwyzz33XLbbbru8+93vTlVVVSZPnlz83TFjxiRJttpqq4wbN26L6uiJ2lrLRw0ZmBG1vXt/IAAA0PWEbjZp+fLleeaZZ/LJT34yRx99dPH62rVrM2LEiCTJUUcdlQ984APZfvvts/fee+dDH/pQPvjBD5ar5G7V0LSug8EQNQAAYEOE7u4wYPC6E+dyvfcWeOWVdTuof/CDH2TatGntftbWKv72t789s2fPzm233Za77rorhxxySKZPn54bb7xxi967N2hY2Da53PPcAADA+oTu7lBVtcUt3uUyduzYTJgwIc8++2wOP/zwjd43fPjwfOxjH8vHPvaxfOQjH8nee++dRYsWZdSoURkwYECam5u7seru09ZePsXkcgAAYAOEbt7QV77ylXz2s5/NiBEjsvfee2fVqlX54x//mJdffjknnXRSLr744owfPz677rprqqurc8MNN2TcuHHZaqutkqybYD5r1qy8613vyqBBgzJy5MjyfqAu1NZePll7OQAAsAFWhvGGPvWpT+U//uM/cuWVV2annXbKP/7jP+bHP/5x6uvrkyTDhg3LRRddlN133z177LFHGhoa8t///d+prl731+sb3/hG7rzzzkyaNCm77rprOT9Kl9NeDgAAbEpVoVAolLuI3mjp0qUZMWJElixZkuHDh7f72cqVKzN79uzU19enpqamTBX2DT35z3L5qrXZ8aw7kiSPnvnBjBhsejkAAFSKTWXC13PSDZ3UuHBda/nIwQMEbgAAYIOEbugkQ9QAAIA3InRDJ832PDcAAPAGhG7opEaTywEAgDcgdEMntU0ur9deDgAAbITQXUItLS3lLqHX68nD9dtC92Tt5QAAwEb0L3cBfdHAgQNTXV2defPmZcyYMRk4cGCqqqrKXVavUygU8tJLL6WqqioDBvSs6eArVq/NgqWrkiT1QjcAALARQncJVFdXp76+Pi+88ELmzZtX7nJ6taqqqrzpTW9Kv379yl1KO23rwrayLgwAANgEobtEBg4cmG222SZr165Nc3NzucvptQYMGNDjAnfy2rowreUAAMCmCN0l1NYW3dNao9lyDa0n3fUmlwMAAJtgkBp0QkOTk24AAOCNCd3QCW2Ty6fUOekGAAA2TuiGTmhoWtdePsVJNwAAsAlCN3TQq6ubM3/pyiRCNwAAsGlCN3TQc4vWnXKPqB2QkUMGlrkaAACgJxO6oYNmtw5Rm2JyOQAA8AaEbuggO7oBAIDNJXRDB702uVzoBgAANk3ohg56bXK59nIAAGDThG7ooEYn3QAAwGYSuqEDVq5pzrwl1oUBAACbR+iGDmhbFzaspn9GDh5Q5moAAICeTuiGDmhoXRdWXzckVVVVZa4GAADo6YRu6IAG68IAAIAOELqhAxoWmlwOAABsPqEbOqCtvdwQNQAAYHMI3dABjW0n3XVOugEAgDcmdMNmWrcu7NUkTroBAIDN07/cBVAihUKyZkW5q+hTnn/xldQUVmbYoP4ZNWBNsnptuUsCAIC+bcDgpJdvDRK6+6o1K5ILJpS7ij7lzUmeqGn95sJyVgIAABXitHnJwN7dZaq9HAAAAErESXdfNWDwun8rRJc5+9b/y/V/nJNj3zM1n5u+XbnLAQCAvm9A7x9gLHT3VVVVvb4No6d5enEhr6YmE8fW+bMFAAA2i/Zy2Eyzizu6e/+/bQMAALqH0A2bYdXa19aFTbYuDAAA2ExCN2yGOYtWpFBIhg7qn7qhA8tdDgAA0EsI3bAZGprW7TyfPHpwqnr5nkAAAKD7CN2wGRoWtj7PXae1HAAA2HxCN2yGYug2RA0AAOgAoRs2Q+PCtvZyJ90AAMDmE7phM7SddNdrLwcAADpA6IY3sHptS+a+3LYuTHs5AACw+YRueANzXl6RlkIyZGC/jBk6qNzlAAAAvYjQDW+goWlda/nk0UOsCwMAADpE6IY30NA6RG1KndZyAACgY4RueAONxXVhhqgBAAAdI3TDG5jdJHQDAACdI3TDG3htR7f2cgAAoGOEbtiE1Wtb8vzL60K3Hd0AAEBHCd2wCc+3rgsbPLBfxgyzLgwAAOgYoRs24bXWcuvCAACAjhO6YRNeG6LmeW4AAKDjhG7YhLZ1YZNNLgcAADpB6IZNmL2wbYiak24AAKDjhG7YBCfdAADAlhC6YSPWNLfk+ZdfTWJdGAAA0DlCN2zE8y+/muaWQmoGVGdr68IAAIBOELphIxoWtk0uty4MAADoHKEbNqKx6bXQDQAA0BllD93f/va3M2XKlNTU1GTatGm5//77N3rvmjVrcs4552Tq1KmpqanJzjvvnNtvv73dPcuWLcuJJ56YyZMnp7a2NnvttVceeOCBdvccddRRqaqqave19957l+Tz0Xs1tE4un2xyOQAA0EllDd3XX399TjrppJx11ll56KGHsvPOO2fGjBl58cUXN3j/6aefnu9973u57LLL8vjjj+fYY4/NQQcdlIcffrh4z6c+9anceeedueqqq/KnP/0pH/zgBzN9+vTMnTu33WvtvffeeeGFF4pf1113XUk/K73P69vLAQAAOqOqUCgUyvXm06ZNyx577JHLL788SdLS0pJJkyblhBNOyCmnnLLe/RMmTMiXv/zlHHfcccVrBx98cGpra3P11Vfn1VdfzbBhw/Jf//Vf2W+//Yr37Lbbbtlnn31y3nnnJVl30r148eLccsstna596dKlGTFiRJYsWZLhw4d3+nXouf7p33+dhoUrct3R78yeU0eXuxwAAKAH2dxMWLaT7tWrV+fBBx/M9OnTXyumujrTp0/Pvffeu8HfWbVqVWpqatpdq62tzT333JMkWbt2bZqbmzd5T5vf/OY32XrrrbP99tvn05/+dBYuXNgVH4s+4vXrwqZoLwcAADqpbKG7qakpzc3NGTt2bLvrY8eOzfz58zf4OzNmzMjFF1+cv/71r2lpacmdd96Zm2++OS+88EKSZNiwYdlzzz1z7rnnZt68eWlubs7VV1+de++9t3hPsq61/D//8z8za9asfO1rX8tvf/vb7LPPPmlubt5ovatWrcrSpUvbfdF3zVv8ata2rgsbO6zmjX8BAABgA8o+SK0jvvWtb2W77bbLDjvskIEDB+b444/PzJkzU1392se46qqrUigUMnHixAwaNCiXXnppDjvssHb3HHroofnwhz+cnXbaKQceeGB+8Ytf5IEHHshvfvObjb73hRdemBEjRhS/Jk2aVMqPSpnNbp1cPnnUkFRXWxcGAAB0TtlCd11dXfr165cFCxa0u75gwYKMGzdug78zZsyY3HLLLVm+fHkaGxvz5JNPZujQodl2222L90ydOjW//e1v88orr2TOnDm5//77s2bNmnb3/K1tt902dXV1efrppzd6z6mnnpolS5YUv+bMmdPBT0xv0tg2uXy01nIAAKDzyha6Bw4cmN122y2zZs0qXmtpacmsWbOy5557bvJ3a2pqMnHixKxduzY33XRTDjjggPXuGTJkSMaPH5+XX345d9xxxwbvafP8889n4cKFGT9+/EbvGTRoUIYPH97ui76r7aS7vs7kcgAAoPP6l/PNTzrppBx55JHZfffd8453vCOXXHJJli9fnpkzZyZJjjjiiEycODEXXnhhkuS+++7L3Llzs8suu2Tu3Lk5++yz09LSki996UvF17zjjjtSKBSy/fbb5+mnn87JJ5+cHXbYofiar7zySr7yla/k4IMPzrhx4/LMM8/kS1/6Ut785jdnxowZ3f+HQI/U2LoubLJ1YQAAwBYoa+j+2Mc+lpdeeilnnnlm5s+fn1122SW33357cbjac8891+5Z7JUrV+b000/Ps88+m6FDh2bffffNVVddla222qp4z5IlS3Lqqafm+eefz6hRo3LwwQfn/PPPz4ABA5Ik/fr1y2OPPZaf/OQnWbx4cSZMmJAPfvCDOffcczNo0KBu/fz0XG3t5SaXAwAAW6Kse7p7M3u6+661zS3Z4Yzbs7alkN+f8r5M2Kq23CUBAAA9TI/f0w091bzFK7O2pZBB/aszbrh1YQAAQOcJ3fA3Zhef5x5sXRgAALBFhG74G4aoAQAAXUXohr/R0LRuiJp1YQAAwJYSuuFvNLyuvRwAAGBLCN3wN9pC9xTt5QAAwBYSuuF1mlsKmbOobUe30A0AAGwZoRteZ97iV7OmuZCB/asz3rowAABgCwnd8DptreXbjLIuDAAA2HJCN7xOQ5PnuQEAgK4jdMPrNCxsfZ7b5HIAAKALCN3wOo1tk8sNUQMAALqA0A2vM1t7OQAA0IWEbmi1bl3Yq0mSydrLAQCALiB0Q6t5i1/N6uaWDOxXnQlb1Za7HAAAoA8QuqFVY+sQtUmjatPPujAAAKALCN3Qqm1Hd70hagAAQBcRuqFV247uyYaoAQAAXUTohlZ2dAMAAF1N6IZWdnQDAABdTeiGJC0thTQuajvpFroBAICuIXRDkheWrszqtS0Z0K8q40fUlLscAACgjxC6Ia8NUZs0anD69/NfCwAAoGtIF5DX1oVpLQcAALqS0A1JGhd6nhsAAOh6Qjckmd3UNrncujAAAKDrCN2Q19aFTXbSDQAAdCGhm4rX0lIotpfXC90AAEAXErqpePOXrsyqtS3pX12VCVtZFwYAAHQdoZuK1za5fBvrwgAAgC4mYVDxGprWtZZPHm2IGgAA0LWEbiqeIWoAAECpCN1UvLZ1YfV1QjcAANC1hG4qXtvkcu3lAABAVxO6qWgtLYU0LnLSDQAAlIbQTUVbsGxlVq5Zty5s4la15S4HAADoY4RuKlrb5PI3jay1LgwAAOhyUgYVrW1y+RSt5QAAQAkI3VS02W2h27owAACgBIRuKlpjk8nlAABA6QjdVLQG7eUAAEAJCd1UrEKh8Fro1l4OAACUgNBNxXpx2aqsXNOSftVVedNI68IAAICuJ3RTsWY3rTvlftPI2gywLgwAACgBSYOK1bYubLLWcgAAoESEbirW7NbJ5fUmlwMAACUidFOxnHQDAAClJnRTsRoWtp50WxcGAACUiNBNRSoUCq876dZeDgAAlIbQTUV6admqrFjdnOqq5E0jhW4AAKA0hG4q0mvrwgZnYH//NQAAAEpD2qAiNbY+z621HAAAKCWhm4rU0Po8tyFqAABAKQndVKQG68IAAIBuIHRTkRqa1rWXT9FeDgAAlJDQTcV5/bqwKdrLAQCAEhK6qTgvvbIqy4vrwmrLXQ4AANCHCd1UnLbJ5RO2qs2g/v3KXA0AANCXCd1UnLYd3SaXAwAApSZ0U3Eai5PLDVEDAABKS+im4jQsbJtc7qQbAAAoLaGbitPQ2l4udAMAAKUmdFNR1q0Laz3prtNeDgAAlJbQTUVpemV1Xlm1NlVVyaRRQjcAAFBaQjcVpW2I2oQR1oUBAAClJ3RTUdqGqFkXBgAAdAehm4rSNkTNujAAAKA7CN1UlIaFJpcDAADdR+imohRDt/ZyAACgGwjdVIxCoZDGptZ1YdrLAQCAbiB0UzEWLV+dZdaFAQAA3UjopmI0vG5dWM0A68IAAIDSE7qpGA2treUmlwMAAN1F6KZiNBqiBgAAdDOhm4oxe6EhagAAQPcSuqkYbSfdk+3oBgAAuonQTUUoFAqZ3bQudNdrLwcAALqJ0E1FeHnFmixbuTZJso11YQAAQDcRuqkIr60Lq7EuDAAA6DZCNxWhocnz3AAAQPcTuqkIDW2Ty+u0lgMAAN1H6KYitJ10T3HSDQAAdCOhm4pgXRgAAFAOQjcVoa293LowAACgOwnd9HkvL1+dJa+uSWJdGAAA0L2Ebvq8tnVh44bXpHagdWEAAED3Ebrp89pCt8nlAABAdxO66fMamlrXhRmiBgAAdDOhmz7P5HIAAKBchG76vNnFyeXaywEAgO4ldNPnOekGAADKReimT1u8YnUWr1i3LmzyaCfdAABA9xK66dMaWlvLxw4flMED+5e5GgAAoNII3fRpWssBAIByErrp02Y3rQvd9UI3AABQBkI3fVpja3v5ZJPLAQCAMhC66dMaFjrpBgAAykfopk9raPJMNwAAUD5CN33WkhVr8rJ1YQAAQBkJ3fRZba3lWw8blCGDrAsDAAC6n9BNn9UWuqdoLQcAAMpE6KbPaptcPsXkcgAAoEyEbvosQ9QAAIByE7rps7SXAwAA5SZ002c1aC8HAADKTOimT1ry6posWr46ifZyAACgfIRu+qTnWk+564YOylDrwgAAgDIRuumTZrc+z12vtRwAACgjoZs+qdHkcgAAoAcQuumT2oao1dcJ3QAAQPkI3fRJbevCJo/WXg4AAJRP2UP3t7/97UyZMiU1NTWZNm1a7r///o3eu2bNmpxzzjmZOnVqampqsvPOO+f2229vd8+yZcty4oknZvLkyamtrc1ee+2VBx54oN09hUIhZ555ZsaPH5/a2tpMnz49f/3rX0vy+SiPRju6AQCAHqCsofv666/PSSedlLPOOisPPfRQdt5558yYMSMvvvjiBu8//fTT873vfS+XXXZZHn/88Rx77LE56KCD8vDDDxfv+dSnPpU777wzV111Vf70pz/lgx/8YKZPn565c+cW77noooty6aWX5rvf/W7uu+++DBkyJDNmzMjKlStL/pkpvWUr16TplbZ1YU66AQCA8qkqFAqFcr35tGnTsscee+Tyyy9PkrS0tGTSpEk54YQTcsopp6x3/4QJE/LlL385xx13XPHawQcfnNra2lx99dV59dVXM2zYsPzXf/1X9ttvv+I9u+22W/bZZ5+cd955KRQKmTBhQr7whS/ki1/8YpJkyZIlGTt2bH784x/n0EMP3azaly5dmhEjRmTJkiUZPnz4lvwx0MX+PHdJPnTZPakbOjB/PP0D5S4HAADogzY3E5btpHv16tV58MEHM3369NeKqa7O9OnTc++9927wd1atWpWampp212pra3PPPfckSdauXZvm5uZN3jN79uzMnz+/3fuOGDEi06ZN2+j70rs0aC0HAAB6iLKF7qampjQ3N2fs2LHtro8dOzbz58/f4O/MmDEjF198cf7617+mpaUld955Z26++ea88MILSZJhw4Zlzz33zLnnnpt58+alubk5V199de69997iPW2v3ZH3TdYF/qVLl7b7omdqsC4MAADoIco+SK0jvvWtb2W77bbLDjvskIEDB+b444/PzJkzU1392se46qqrUigUMnHixAwaNCiXXnppDjvssHb3dMaFF16YESNGFL8mTZq0pR+HEmlbFzbF89wAAECZlS1019XVpV+/flmwYEG76wsWLMi4ceM2+DtjxozJLbfckuXLl6exsTFPPvlkhg4dmm233bZ4z9SpU/Pb3/42r7zySubMmZP7778/a9asKd7T9toded8kOfXUU7NkyZLi15w5czr1uSm9tpPuKXZ0AwAAZVa20D1w4MDstttumTVrVvFaS0tLZs2alT333HOTv1tTU5OJEydm7dq1uemmm3LAAQesd8+QIUMyfvz4vPzyy7njjjuK99TX12fcuHHt3nfp0qW57777Nvm+gwYNyvDhw9t90TO9dtItdAMAAOXVv5xvftJJJ+XII4/M7rvvnne84x255JJLsnz58sycOTNJcsQRR2TixIm58MILkyT33Xdf5s6dm1122SVz587N2WefnZaWlnzpS18qvuYdd9yRQqGQ7bffPk8//XROPvnk7LDDDsXXrKqqyoknnpjzzjsv2223Xerr63PGGWdkwoQJOfDAA7v9z4Cu9cqqtWl6ZVWSZHKd9nIAAKC8yhq6P/axj+Wll17KmWeemfnz52eXXXbJ7bffXhxy9txzz7V7FnvlypU5/fTT8+yzz2bo0KHZd999c9VVV2WrrbYq3rNkyZKceuqpef755zNq1KgcfPDBOf/88zNgwIDiPV/60peyfPnyHHPMMVm8eHHe/e535/bbb19v6jm9T1tr+eghAzO8ZsAb3A0AAFBaZd3T3ZvZ090z/fKxF3LctQ/l7dtslZs/865ylwMAAPRRPX5PN5RCcUe3IWoAAEAPIHTTpxQnlxuiBgAA9ABCN31KY+vk8sl2dAMAAD2A0E2fMru1vbxeezkAANADCN30GctXrc1Ly1rXhWkvBwAAegChmz6jrbV81JCBGVFrXRgAAFB+Qjd9Rtvkcs9zAwAAPYXQTZ9RXBemtRwAAOghhG76DOvCAACAnkbops9oaH2me0qd9nIAAKBnELrpMxq1lwMAAD2M0E2fsGL12ixYum5dmNANAAD0FEI3fULburCtBg/IiMHWhQEAAD2D0E2fYIgaAADQEwnd9AnFIWp2dAMAAD2I0E2f0DZEbbKTbgAAoAcRuukTZre2l9fXCd0AAEDPIXTTJ7QNUpusvRwAAOhBhG56vVdXN2f+0pVJnHQDAAA9i9BNr9e4aF1r+YjaAdlq8MAyVwMAAPAaoZter6HJ5HIAAKBnErrp9RpaJ5dP0VoOAAD0MEI3vZ51YQAAQE8ldNPrtbWX19dpLwcAAHoWoZter8FJNwAA0EMJ3fRqK9c054Ul69aFTRG6AQCAHkbopldrXLiutXx4Tf+MHDygzNUAAAC0J3TTq71+cnlVVVWZqwEAAGhP6KZXa5tcrrUcAADoiYRuerXZrZPLp4w2uRwAAOh5hG56NTu6AQCAnkzopldraHrtmW4AAICeRuim11q5pjnziuvCtJcDAAA9j9BNrzVn0brnuYcN6p9RQwaWuRoAAID1Cd30WrObrAsDAAB6NqGbXqtx4bqT7slaywEAgB5K6KbXamidXF5viBoAANBDCd30Wg3WhQEAAD2c0E2v1dC0rr3c5HIAAKCnErrpldatC3s1iR3dAABAzyV00ys9//KKFArJ0EH9M9q6MAAAoIcSuumViq3ldYOtCwMAAHosoZteyRA1AACgNxC66ZXaQrchagAAQE8mdNMrvTa53Ek3AADQcwnd9ErFk26TywEAgB5M6KbXWbW2OfMWr1sXNll7OQAA0IMJ3fQ6cxa9mpZCMmRgv4wZOqjc5QAAAGyU0E2v0/i6yeXWhQEAAD2Z0E2vM7tpXeiu9zw3AADQwwnd9DqNC9dNLvc8NwAA0NMJ3fQ6r+3odtINAAD0bEI3vY51YQAAQG8hdNOrrF7bkrkvr1sXNkV7OQAA0MMJ3fQqz7+8Ii2FZPDAfhkzzLowAACgZxO66VUarAsDAAB6EaGbXqWhad3kcq3lAABAbyB006sYogYAAPQmQje9SsNCJ90AAEDvIXTTqzTa0Q0AAPQiQje9xprmljzfti5MezkAANALCN30Gs+//GqaWwqpHdAvW1sXBgAA9AJCN71GQ1PburDB1oUBAAC9gtBNr9HgeW4AAKCXEbrpNRpbJ5dPrjO5HAAA6B2EbnqN2a3t5fVOugEAgF5C6KbXaFsXNlnoBgAAegmhm15hTXNL5rSuC6u3LgwAAOglhG56hbmt68JqBlRbFwYAAPQaQje9Qtvk8smjhqS62rowAACgdxC66RXadnRPMbkcAADoRYRueoWG1nVhdnQDAAC9idBNr9A2uXyKIWoAAEAvInTTK7SddE8erb0cAADoPYRuery1zS2Zs0h7OQAA0PsI3fR4cxe/mrUthQzqX51xw2vKXQ4AAMBmE7rp8V7fWm5dGAAA0JsI3fR4xSFqWssBAIBeRuimx5vdZHI5AADQOwnd9HiNJpcDAAC9lNBNj9fQetJdr70cAADoZYRuerS1zS2Z83LrSbf2cgAAoJcRuunRXliyMmuaCxnYvzrjrQsDAAB6GaGbHq1tiNrkUdaFAQAAvY/QTY/Wti5ssue5AQCAXqjDoXvKlCk555xz8txzz5WiHmhndtO657nr60wuBwAAep8Oh+4TTzwxN998c7bddtt84AMfyE9/+tOsWrWqFLWBk24AAKBX61TofuSRR3L//ffnLW95S0444YSMHz8+xx9/fB566KFS1EgFa2gN3VOEbgAAoBfq9DPdb3/723PppZdm3rx5Oeuss/If//Ef2WOPPbLLLrvkRz/6UQqFQlfWSQVqbilkzqJXkyRTtJcDAAC9UP/O/uKaNWvy85//PFdeeWXuvPPOvPOd78wnP/nJPP/88znttNNy11135dprr+3KWqkw8xa/mtXNLRnYrzrjR9SWuxwAAIAO63Dofuihh3LllVfmuuuuS3V1dY444oh885vfzA477FC856CDDsoee+zRpYVSeRoXrhuits3owelnXRgAANALdTh077HHHvnABz6QK664IgceeGAGDBiw3j319fU59NBDu6RAKtfs4vPcWssBAIDeqcOh+9lnn83kyZM3ec+QIUNy5ZVXdrooSJLGJpPLAQCA3q3Dg9RefPHF3Hfffetdv++++/LHP/6xS4qC5HWTy+uEbgAAoHfqcOg+7rjjMmfOnPWuz507N8cdd1yXFAVJ0tD6TLf2cgAAoLfqcOh+/PHH8/a3v32967vuumsef/zxLikKmlsKea4Yup10AwAAvVOHQ/egQYOyYMGC9a6/8MIL6d+/0xvIoJ0XlqxbFzagX1UmbGVdGAAA0Dt1OHR/8IMfzKmnnpolS5YUry1evDinnXZaPvCBD3RpcVSutnVhk0ZZFwYAAPReHT6a/vrXv573vOc9mTx5cnbdddckySOPPJKxY8fmqquu6vICqUyzWyeX12stBwAAerEOh+6JEyfmscceyzXXXJNHH300tbW1mTlzZg477LAN7uyGzmhcaF0YAADQ+3XqIewhQ4bkmGOO6epaoKg4ubzO5HIAAKD36vTks8cffzzPPfdcVq9e3e76hz/84S0uChpa28tNLgcAAHqzDofuZ599NgcddFD+9Kc/paqqKoVCIUlSVbVu2FVzc3PXVkjFaWkppHGRdWEAAEDv1+Hp5Z/73OdSX1+fF198MYMHD87//d//5e67787uu++e3/zmNyUokUozf+nKrF7bti6sptzlAAAAdFqHT7rvvffe/OpXv0pdXV2qq6tTXV2dd7/73bnwwgvz2c9+Ng8//HAp6qSCtLWWTxo5OP37dfjfCwEAAPQYHU40zc3NGTZsWJKkrq4u8+bNS5JMnjw5Tz31VNdWR0VqG6I2ebQhagAAQO/W4ZPuv//7v8+jjz6a+vr6TJs2LRdddFEGDhyY73//+9l2221LUSMVpqF1XdiUOs9zAwAAvVuHQ/fpp5+e5cvXhaJzzjknH/rQh/IP//APGT16dK6//vouL5DKY3I5AADQV3Q4dM+YMaP4z29+85vz5JNPZtGiRRk5cmRxgjlsicbijm6hGwAA6N069Ez3mjVr0r9///z5z39ud33UqFECN12ipaXwWnu5Z7oBAIBerkOhe8CAAdlmm23s4qZkFixbmVVrW9K/uioTt6otdzkAAABbpMPTy7/85S/ntNNOy6JFi7qkgG9/+9uZMmVKampqMm3atNx///0bvXfNmjU555xzMnXq1NTU1GTnnXfO7bff3u6e5ubmnHHGGamvr09tbW2mTp2ac889N4VCoXjPUUcdlaqqqnZfe++9d5d8HrbM7LZ1YaOsCwMAAHq/Dj/Tffnll+fpp5/OhAkTMnny5AwZ0v6524ceemizX+v666/PSSedlO9+97uZNm1aLrnkksyYMSNPPfVUtt566/XuP/3003P11VfnBz/4QXbYYYfccccdOeigg/L73/8+u+66a5Lka1/7Wq644or85Cc/yY477pg//vGPmTlzZkaMGJHPfvazxdfae++9c+WVVxa/HzRoUEf/KCiBRuvCAACAPqTDofvAAw/ssje/+OKLc/TRR2fmzJlJku9+97v55S9/mR/96Ec55ZRT1rv/qquuype//OXsu+++SZJPf/rTueuuu/KNb3wjV199dZLk97//fQ444IDst99+SZIpU6bkuuuuW+8EfdCgQRk3blyXfRa6xmvPcxuiBgAA9H4dDt1nnXVWl7zx6tWr8+CDD+bUU08tXquurs706dNz7733bvB3Vq1alZqamnbXamtrc8899xS/32uvvfL9738/f/nLX/J3f/d3efTRR3PPPffk4osvbvd7v/nNb7L11ltn5MiRed/73pfzzjsvo0eP3mi9q1atyqpVq4rfL126tEOfl83z2rowJ90AAEDv1+HQ3VWamprS3NycsWPHtrs+duzYPPnkkxv8nRkzZuTiiy/Oe97znkydOjWzZs3KzTff3G6w2ymnnJKlS5dmhx12SL9+/dLc3Jzzzz8/hx9+ePGevffeO//8z/+c+vr6PPPMMznttNOyzz775N57702/fv02+N4XXnhhvvKVr3TBJ2dTiu3l1oUBAAB9QIdDd3V19SbXg5Vysvm3vvWtHH300dlhhx1SVVWVqVOnZubMmfnRj35UvOdnP/tZrrnmmlx77bXZcccd88gjj+TEE0/MhAkTcuSRRyZJDj300OL9O+20U972trdl6tSp+c1vfpP3v//9G3zvU089NSeddFLx+6VLl2bSpEkl+qSV6fXrwuq1lwMAAH1Ah0P3z3/+83bfr1mzJg8//HB+8pOfdOgkuK6uLv369cuCBQvaXV+wYMFGn7UeM2ZMbrnllqxcuTILFy7MhAkTcsopp2Tbbbct3nPyySfnlFNOKQbrnXbaKY2NjbnwwguLoftvbbvttqmrq8vTTz+90dA9aNAgw9ZK7MVlq7JyTUv6VVdl4kjrwgAAgN6vw6H7gAMOWO/aRz7ykey44465/vrr88lPfnKzXmfgwIHZbbfdMmvWrOJwtpaWlsyaNSvHH3/8Jn+3pqYmEydOzJo1a3LTTTflkEMOKf5sxYoVqa5uv2qqX79+aWlp2ejrPf/881m4cGHGjx+/WbVTGm2n3G8aWZsB1oUBAAB9QJclm3e+852ZNWtWh37npJNOyg9+8IP85Cc/yRNPPJFPf/rTWb58eXGa+RFHHNFu0Np9992Xm2++Oc8++2z+93//N3vvvXdaWlrypS99qXjP/vvvn/PPPz+//OUv09DQkJ///Oe5+OKLc9BBByVJXnnllZx88sn5wx/+kIaGhsyaNSsHHHBA3vzmN2fGjBld8CdBZ702RE1rOQAA0Dd0ySC1V199NZdeemkmTpzYod/72Mc+lpdeeilnnnlm5s+fn1122SW33357cbjac8891+7UeuXKlTn99NPz7LPPZujQodl3331z1VVXZauttirec9lll+WMM87IZz7zmbz44ouZMGFC/u3f/i1nnnlmknWn3o899lh+8pOfZPHixZkwYUI++MEP5txzz9U+XmYNrUPUTC4HAAD6iqpCoVDoyC+MHDmy3SC1QqGQZcuWZfDgwbn66qvz4Q9/uMuL7ImWLl2aESNGZMmSJRk+fHi5y+kTPn31g7ntz/Nz1v5vzcx31Ze7HAAAgI3a3EzY4ZPub37zm+1Cd3V1dcaMGZNp06Zl5MiRnasWkszWXg4AAPQxHQ7dRx11VAnKoNIVCoXXdnRrLwcAAPqIDg9Su/LKK3PDDTesd/2GG27IT37yky4pisrz4rJVeXVNc/pVV+VNI4VuAACgb+hw6L7wwgtTV1e33vWtt946F1xwQZcUReVpm1w+cavaDOxvXRgAANA3dDjdPPfcc6mvX3/I1eTJk/Pcc891SVFUnrbW8il1nucGAAD6jg6H7q233jqPPfbYetcfffTRjB49ukuKovLMXtg2RE1rOQAA0Hd0OHQfdthh+exnP5tf//rXaW5uTnNzc371q1/lc5/7XA499NBS1EgFaGwN3ZNNLgcAAPqQDk8vP/fcc9PQ0JD3v//96d9/3a+3tLTkiCOO8Ew3nTa7aV17eX2dk24AAKDv6HDoHjhwYK6//vqcd955eeSRR1JbW5uddtopkydPLkV9VIB168KcdAMAAH1Ph0N3m+222y7bbbddV9ZChXrplVVZsbo51VXJJOvCAACAPqTDz3QffPDB+drXvrbe9Ysuuigf/ehHu6QoKktDa2v5xJHWhQEAAH1LhxPO3XffnX333Xe96/vss0/uvvvuLimKytJQnFyutRwAAOhbOhy6X3nllQwcOHC96wMGDMjSpUu7pCgqS0OT0A0AAPRNHQ7dO+20U66//vr1rv/0pz/NW9/61i4pisrSuHBde/lkO7oBAIA+psOD1M4444z88z//c5555pm8733vS5LMmjUr1157bW688cYuL5C+T3s5AADQV3U4dO+///655ZZbcsEFF+TGG29MbW1tdt555/zqV7/KqFGjSlEjfVihUHitvbxO6AYAAPqWTq0M22+//bLffvslSZYuXZrrrrsuX/ziF/Pggw+mubm5Swukb2t6ZXWWt60LG1Vb7nIAAAC6VKf3M91999058sgjM2HChHzjG9/I+973vvzhD3/oytqoAI2treUTtqrNoP79ylwNAABA1+rQSff8+fPz4x//OD/84Q+zdOnSHHLIIVm1alVuueUWQ9TolNkmlwMAAH3YZp9077///tl+++3z2GOP5ZJLLsm8efNy2WWXlbI2KoDJ5QAAQF+22Sfdt912Wz772c/m05/+dLbbbrtS1kQFmd3aXl5viBoAANAHbfZJ9z333JNly5Zlt912y7Rp03L55ZenqamplLVRAdqe6Z6svRwAAOiDNjt0v/Od78wPfvCDvPDCC/m3f/u3/PSnP82ECRPS0tKSO++8M8uWLStlnfRBhUIhjU3r2svr67SXAwAAfU+Hp5cPGTIkn/jEJ3LPPffkT3/6U77whS/kq1/9arbeeut8+MMfLkWN9FELl6/OslVrU1WVvGmk0A0AAPQ9nV4ZliTbb799Lrroojz//PO57rrruqomKkRxXdiI2tQMsC4MAADoe7YodLfp169fDjzwwNx6661d8XJUiNmtreVTtJYDAAB9VJeEbugMQ9QAAIC+TuimbBpad3RPsaMbAADoo4Ruyqahad1J9xQn3QAAQB8ldFMWhUIhDa3t5VPqhG4AAKBvEropi0XLV2fZynXrwrYZpb0cAADom4RuyqLtee7xw2usCwMAAPosoZuyMLkcAACoBEI3ZVEcouZ5bgAAoA8TuikL68IAAIBKIHRTFo0mlwMAABVA6KbbFQqFzLajGwAAqABCN91u8Yo1WbpybRLrwgAAgL5N6KbbzW5tLR8/oia1A60LAwAA+i6hm2732rowp9wAAEDfJnTT7Rqa2iaXe54bAADo24Ruul2DyeUAAECFELrpdnZ0AwAAlULopts1NDnpBgAAKoPQTbdavGJ1lry6Jol1YQAAQN8ndNOt2lrLxw4flMED+5e5GgAAgNISuulWxdZyk8sBAIAKIHTTrYqTy4VuAACgAgjddCtD1AAAgEoidNOtrAsDAAAqidBNt2psbS+frL0cAACoAEI33WbJijV5ecW6dWFT6px0AwAAfZ/QTbdpG6K29TDrwgAAgMogdNNtipPLDVEDAAAqhNBNt2loMkQNAACoLEI33cYQNQAAoNII3XSb2a2hu157OQAAUCGEbrpNY+uO7snaywEAgAohdNMtlry6JouWr06ivRwAAKgcQjfdou157jHDBmXoIOvCAACAyiB00y0aFppcDgAAVB6hm27R0NS6o1trOQAAUEGEbrpFQ2t7+RSTywEAgAoidNMtTC4HAAAqkdBNt9BeDgAAVCKhm5JbunJNFrauC9NeDgAAVBKhm5JrbFrXWl431LowAACgsgjdlFxxiJrnuQEAgAojdFNyja2he7LnuQEAgAojdFNys1vby+vrnHQDAACVReim5Jx0AwAAlUropuQaFraddAvdAABAZRG6KallK9ek6ZVVSZJtDFIDAAAqjNBNSTW2nnKPHjIww2sGlLkaAACA7iV0U1LFdWFaywEAgAokdFNSbSfdk7WWAwAAFUjopqQamlpPuk0uBwAAKpDQTUlpLwcAACqZ0E1Jta0Lm6K9HAAAqEBCNyXzyqq1eWnZunVhk7WXAwAAFUjopmQaW1vLRw0ZmBG11oUBAACVR+imZEwuBwAAKp3QTcnMbp1cXq+1HAAAqFBCNyXT1l7ueW4AAKBSCd2UTHFyeZ32cgAAoDIJ3ZRMQ2t7+RQn3QAAQIUSuimJFavX5sXWdWFCNwAAUKmEbkqioWlda/nIwQMyYrB1YQAAQGUSuikJQ9QAAACEbkqkOETNjm4AAKCCCd2URHGIWp2TbgAAoHIJ3ZREw0KTywEAAIRuSqIYup10AwAAFUzopsutWL02C5a2rQvzTDcAAFC5hG663HOL1g1RG1E7IFsNHljmagAAAMpH6KbLGaIGAACwjtBNl7MuDAAAYB2hmy5XPOk2uRwAAKhwQjdd7rXJ5U66AQCAyiZ00+UaW9vLJzvpBgAAKpzQTZd6dXVzXliyMklSL3QDAAAVTuimS7WtCxte0z9bDR5Q5moAAADKS+imS7U9z11fNyRVVVVlrgYAAKC8hG66VNvkcs9zAwAACN10MTu6AQAAXiN006WKO7rrnHQDAAAI3XSpxoXaywEAANoI3XSZlWuaM691XZj2cgAAAKGbLtS2LmxYTf+MGjKwzNUAAACUn9BNlyk+zz3aujAAAICkB4Tub3/725kyZUpqamoybdq03H///Ru9d82aNTnnnHMyderU1NTUZOedd87tt9/e7p7m5uacccYZqa+vT21tbaZOnZpzzz03hUKheE+hUMiZZ56Z8ePHp7a2NtOnT89f//rXkn3GStG2o9sQNQAAgHXKGrqvv/76nHTSSTnrrLPy0EMPZeedd86MGTPy4osvbvD+008/Pd/73vdy2WWX5fHHH8+xxx6bgw46KA8//HDxnq997Wu54oorcvnll+eJJ57I1772tVx00UW57LLLivdcdNFFufTSS/Pd73439913X4YMGZIZM2Zk5cqVJf/MfZl1YQAAAO1VFV5/BNzNpk2blj322COXX355kqSlpSWTJk3KCSeckFNOOWW9+ydMmJAvf/nLOe6444rXDj744NTW1ubqq69OknzoQx/K2LFj88Mf/nCD9xQKhUyYMCFf+MIX8sUvfjFJsmTJkowdOzY//vGPc+ihh25W7UuXLs2IESOyZMmSDB8+vNN/Bn3J4f/xh/zu6YX5+kd3zkd2e1O5ywEAACiZzc2EZTvpXr16dR588MFMnz79tWKqqzN9+vTce++9G/ydVatWpaampt212tra3HPPPcXv99prr8yaNSt/+ctfkiSPPvpo7rnnnuyzzz5JktmzZ2f+/Pnt3nfEiBGZNm3aRt+XzdPQtO6ku77OSTcAAECS9C/XGzc1NaW5uTljx45td33s2LF58sknN/g7M2bMyMUXX5z3vOc9mTp1ambNmpWbb745zc3NxXtOOeWULF26NDvssEP69euX5ubmnH/++Tn88MOTJPPnzy++z9++b9vPNmTVqlVZtWpV8fulS5d27AP3cevWhb2axI5uAACANmUfpNYR3/rWt7Lddttlhx12yMCBA3P88cdn5syZqa5+7WP87Gc/yzXXXJNrr702Dz30UH7yk5/k61//en7yk59s0XtfeOGFGTFiRPFr0qRJW/px+pQ5i1akUEiGDeqf0daFAQAAJClj6K6rq0u/fv2yYMGCdtcXLFiQcePGbfB3xowZk1tuuSXLly9PY2NjnnzyyQwdOjTbbrtt8Z6TTz45p5xySg499NDstNNO+dd//dd8/vOfz4UXXpgkxdfuyPsmyamnnpolS5YUv+bMmdOpz91XtQ1Rm1w32LowAACAVmUL3QMHDsxuu+2WWbNmFa+1tLRk1qxZ2XPPPTf5uzU1NZk4cWLWrl2bm266KQcccEDxZytWrGh38p0k/fr1S0tLS5Kkvr4+48aNa/e+S5cuzX333bfJ9x00aFCGDx/e7ovXNLauC9NaDgAA8JqyPdOdJCeddFKOPPLI7L777nnHO96RSy65JMuXL8/MmTOTJEcccUQmTpxYPKW+7777Mnfu3Oyyyy6ZO3duzj777LS0tORLX/pS8TX333//nH/++dlmm22y44475uGHH87FF1+cT3ziE0mSqqqqnHjiiTnvvPOy3Xbbpb6+PmeccUYmTJiQAw88sNv/DPqK2U3rQne90A0AAFBU1tD9sY99LC+99FLOPPPMzJ8/P7vssktuv/324pCz5557rt2p9cqVK3P66afn2WefzdChQ7PvvvvmqquuylZbbVW857LLLssZZ5yRz3zmM3nxxRczYcKE/Nu//VvOPPPM4j1f+tKXsnz58hxzzDFZvHhx3v3ud+f2229fbzI6m6+xrb3cjm4AAICisu7p7s3s6W7v3V/7VZ5/+dXceOye2X3KqHKXAwAAUFI9fk83fceqtc2Zt9i6MAAAgL8ldLPF5ix6NS2FZMjAfqkbal0YAABAG6GbLdbQOkRtSt0Q68IAAABeR+hmizW0rguborUcAACgHaGbLWZyOQAAwIYJ3Wyx4kl3nZNuAACA1xO62WLaywEAADZM6GaLrF7bkrkvr1sXNqVOezkAAMDrCd1skTkvr0hLIRk8sF/GDB1U7nIAAAB6FKGbLdLY2lo+ebR1YQAAAH9L6GaLzG5aN7m8Xms5AADAeoRutsjrT7oBAABoT+hmi8xuWhe664VuAACA9QjdbJHGhevayyeP1l4OAADwt4RuOm312pY8//K60D2lzkk3AADA3xK66bTnW9eF1Q7ol62HWRcGAADwt4RuOu31reXWhQEAAKxP6KbTGlonl9drLQcAANggoZtOa2iyLgwAAGBThG46raG1vXyKyeUAAAAbJHTTaW3t5SaXAwAAbJjQTaesaW7J8y+/miSZor0cAABgg4RuOmXuy6+muaWQmgHV1oUBAABshNBNp8xuay0fPSTV1daFAQAAbIjQTac0FieXG6IGAACwMUI3nVKcXG6IGgAAwEYJ3XRKw+vaywEAANgwoZtOaWw96dZeDgAAsHFCNx22trklcxatC9312ssBAAA2Suimw+YufjVrWwoZ1L86Y4fVlLscAACAHkvopsNmN1kXBgAAsDmEbjrM89wAAACbR+imw4qTyz3PDQAAsElCNx3W0GRdGAAAwOYQuumwtvbyKdrLAQAANknopkPWNrdkzsutz3RrLwcAANgkoZsOmbd4ZdY0FzKwf3XGD7cuDAAAYFOEbjqkbYja5FGDrQsDAAB4A0I3HWJyOQAAwOYTuumQhiZD1AAAADaX0E2HNLa1l1sXBgAA8IaEbjpkdmvortdeDgAA8IaEbjZbc0shcxa1rgvTXg4AAPCGhG4227zFrxbXhU0YUVvucgAAAHo8oZvN1ja5fBvrwgAAADaL0M1ma1hocjkAAEBHCN1stoam1h3dJpcDAABsFqGbzVZcF2ZyOQAAwGYRutlss1tPuuuddAMAAGwWoZvNsm5d2KtJrAsDAADYXEI3m+WFJa9mdXNLBvarzoStrAsDAADYHEI3m6Whad3k8kmjatPPujAAAIDNInSzWdp2dJtcDgAAsPmEbjZLcXK50A0AALDZhG42y+zW9vL6OkPUAAAANpfQzWZx0g0AANBxQjdvqKWlkMZFbSfdQjcAAMDmErp5Qy8sXZnVa1syoF9Vxo+oKXc5AAAAvYbQzRtqbFrXWj5p5OD07+evDAAAwOaSoHhDs9vWhWktBwAA6BChmzfUuHDd89yTR5tcDgAA0BFCN29odmt7uSFqAAAAHSN084asCwMAAOgcoZtNamkpFNvLp2gvBwAA6BChm02av3RlVq1tSf/qqkzcqrbc5QAAAPQqQjeb1NDaWj5plHVhAAAAHSVFsUlaywEAADpP6GaTGpoMUQMAAOgsoZtNamsvd9INAADQcUI3m9TQ1Npebkc3AABAhwndbFRLSyGNi9pOuoVuAACAjhK62agXl63KyjUt6VddlYkjrQsDAADoKKGbjZrdOkRt0sjaDLAuDAAAoMMkKTaqcaHJ5QAAAFtC6GajZreG7npD1AAAADpF6GajGlsnl0+2LgwAAKBThG426rUd3U66AQAAOkPoZoMKhUIaF9rRDQAAsCWEbjboxWWr8uqa5vSrrsqbrAsDAADoFKGbDWpbF/Ym68IAAAA6TZpig6wLAwAA2HJCNxvU0PY8t8nlAAAAnSZ0s0ENTSaXAwAAbCmhmw0qnnTXOekGAADoLKGb9axbF+aZbgAAgC0ldLOel5atyorVzamuSiaNdNINAADQWUI362lrLZ84sjYD+/srAgAA0FkSFesxRA0AAKBrCN2sp2Gh0A0AANAVhG7W09jaXj7Zjm4AAIAtInSzntmt7eX1dU66AQAAtoTQTTvWhQEAAHQdoZt2XnplVZa3rQsbVVvucgAAAHo1oZt22p7nnrBVbQb171fmagAAAHo3oZt2rAsDAADoOkI37RTXhdWZXA4AALClhG7aaWhtL3fSDQAAsOWEbtrRXg4AANB1hG6K1q0Laz3p1l4OAACwxYRuihYuX51XVq1NVVXyppFCNwAAwJYSuilqay2fMKI2NQOsCwMAANhSQjdFDVrLAQAAupTQTVFj67qwyYaoAQAAdAmhm6LZre3l9UI3AABAlxC6KWqbXD55tPZyAACAriB0k2TdurC2QWr1dU66AQAAuoLQTZJk0fLVWda6LmzSKCfdAAAAXUHoJslrk8vHD6+xLgwAAKCLCN0keW1H9xSt5QAAAF1G6CaJdWEAAAClIHSTJJnd2l5eX+d5bgAAgK7SI0L3t7/97UyZMiU1NTWZNm1a7r///o3eu2bNmpxzzjmZOnVqampqsvPOO+f2229vd8+UKVNSVVW13tdxxx1XvOef/umf1vv5scceW7LP2NM56QYAAOh6ZQ/d119/fU466aScddZZeeihh7LzzjtnxowZefHFFzd4/+mnn57vfe97ueyyy/L444/n2GOPzUEHHZSHH364eM8DDzyQF154ofh15513Jkk++tGPtnuto48+ut19F110Uek+aA9WKBQyu+2ZbqEbAACgy5Q9dF988cU5+uijM3PmzLz1rW/Nd7/73QwePDg/+tGPNnj/VVddldNOOy377rtvtt1223z605/Ovvvum2984xvFe8aMGZNx48YVv37xi19k6tSp+cd//Md2rzV48OB29w0fPrykn7WnennFmixbuTZJMnm09nIAAICuUtbQvXr16jz44IOZPn168Vp1dXWmT5+ee++9d4O/s2rVqtTU1LS7Vltbm3vuuWej73H11VfnE5/4RKqqqtr97JprrkldXV3+/u//PqeeempWrFixhZ+od2pobS0fP8K6MAAAgK7Uv5xv3tTUlObm5owdO7bd9bFjx+bJJ5/c4O/MmDEjF198cd7znvdk6tSpmTVrVm6++eY0Nzdv8P5bbrklixcvzlFHHdXu+sc//vFMnjw5EyZMyGOPPZb/9//+X5566qncfPPNG3ydVatWZdWqVcXvly5d2oFP2rM1aC0HAAAoibKG7s741re+laOPPjo77LBDqqqqMnXq1MycOXOj7eg//OEPs88++2TChAntrh9zzDHFf95pp50yfvz4vP/9788zzzyTqVOnrvc6F154Yb7yla907YfpIRpaJ5dPMbkcAACgS5W1vbyuri79+vXLggUL2l1fsGBBxo0bt8HfGTNmTG655ZYsX748jY2NefLJJzN06NBsu+22693b2NiYu+66K5/61KfesJZp06YlSZ5++ukN/vzUU0/NkiVLil9z5sx5w9fsLUwuBwAAKI2yhu6BAwdmt912y6xZs4rXWlpaMmvWrOy5556b/N2amppMnDgxa9euzU033ZQDDjhgvXuuvPLKbL311tlvv/3esJZHHnkkSTJ+/PgN/nzQoEEZPnx4u6++Qns5AABAaZS9vfykk07KkUcemd133z3veMc7cskll2T58uWZOXNmkuSII47IxIkTc+GFFyZJ7rvvvsydOze77LJL5s6dm7PPPjstLS350pe+1O51W1pacuWVV+bII49M//7tP+YzzzyTa6+9Nvvuu29Gjx6dxx57LJ///Ofznve8J29729u654P3INrLAQAASqPsoftjH/tYXnrppZx55pmZP39+dtlll9x+++3F4WrPPfdcqqtfO5BfuXJlTj/99Dz77LMZOnRo9t1331x11VXZaqut2r3uXXfdleeeey6f+MQn1nvPgQMH5q677ioG/EmTJuXggw/O6aefXtLP2hMtXrE6S15dkySZPMpJNwAAQFeqKhQKhXIX0RstXbo0I0aMyJIlS3p1q/nDz72cg77z+4wbXpM/nPb+cpcDAADQK2xuJizrM92UX2Nra/nk0VrLAQAAuprQXeFmtw5Rq6/TWg4AANDVhO4KZ10YAABA6QjdFa44uVx7OQAAQJcTuitcQ+tJ9xTt5QAAAF1O6K5gi1eszuIVrevCnHQDAAB0OaG7grW1lo8dPiiDB5Z9ZTsAAECfI3RXMEPUAAAASkvormANTYaoAQAAlJLQXcEMUQMAACgtobuCFUO39nIAAICSELorWENT2zPd2ssBAABKQeiuUEtWrMnLrevCnHQDAACUhtBdoRoXrTvlHjNsUIYMsi4MAACgFITuCjW7tbW83ik3AABAyQjdFapx4bp1YZ7nBgAAKB2hu0JZFwYAAFB6QneFaptcbogaAABA6QjdFUp7OQAAQOkJ3RVo6co1Wbh8dRLt5QAAAKUkdFegxqZ1p9x1QwdlqHVhAAAAJSN0V6DiEDWt5QAAACUldFeg4hA1reUAAAAlJXRXoIbWIWpOugEAAEpL6K5AdnQDAAB0D6G7AjUutKMbAACgOwjdFWbZyjVpemXdujA7ugEAAEpL6K4wjQvb1oUNzLCaAWWuBgAAoG8TuitM2/Pck7WWAwAAlJzQXWHa1oVpLQcAACg9obvCtK0Lq3fSDQAAUHJCd4Vpm1w+2bowAACAkhO6K8zsJifdAAAA3UXoriCvrFqbpldWJUm28Uw3AABAyQndFaSttXzUkIEZUWtdGAAAQKkJ3RWkobW1fIpTbgAAgG4hdFeQth3dUzzPDQAA0C2E7grStqN7isnlAAAA3ULoriCNrTu6J2svBwAA6BZCdwXRXg4AANC9hO4KsXzV2ry4bN26MKEbAACgewjdFaKttXzk4AEZMdi6MAAAgO4gdFeIYmu5IWoAAADdRuiuEJ7nBgAA6H5Cd4VobDK5HAAAoLsJ3RVidutJd732cgAAgG4jdFeIxtbQPVl7OQAAQLcRuivAitVrs2Bp27ow7eUAAADdReiuAG3rwrYaPCBbDR5Y5moAAAAqh9BdAbSWAwAAlIfQXQFmt04ur9daDgAA0K2E7grgpBsAAKA8hO4K0NAauqfUOekGAADoTkJ3BWhobS+f4qQbAACgWwndfdyrq5szf+nKJEI3AABAdxO6+7jGRetay0fUDsjIIdaFAQAAdCehu497rbXc89wAAADdTeju40wuBwAAKB+hu497bXK50A0AANDdhO4+Tns5AABA+QjdfVyD9nIAAICyEbr7sJVrmvPCknXrwuq1lwMAAHQ7obsPe27RutbyYTX9M3LwgDJXAwAAUHmE7j5sdtO61vL6uiGpqqoqczUAAACVR+juw6wLAwAAKC+huw9rWGhyOQAAQDkJ3X1YQ2t7+RQn3QAAAGUhdPdhjW0n3XVOugEAAMpB6O6jVq5pzrwlryZx0g0AAFAuQncfNWfRihQKybBB/TNqyMBylwMAAFCR+pe7AEqjpZC8b4etM7BftXVhAAAAZSJ091HbjxuWHx21R7nLAAAAqGjaywEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBIRugEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBIRugEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBIRugEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBIRugEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBIRugEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBIRugEAAKBEhG4AAAAoEaEbAAAASkToBgAAgBIRugEAAKBE+pe7gN6qUCgkSZYuXVrmSgAAAOhubVmwLRtujNDdScuWLUuSTJo0qcyVAAAAUC7Lli3LiBEjNvrzqsIbxXI2qKWlJfPmzcuwYcNSVVVV7nI2aOnSpZk0aVLmzJmT4cOHl7sc6BL+XtMX+XtNX+TvNX2Rv9e8XqFQyLJlyzJhwoRUV2/8yW0n3Z1UXV2dN73pTeUuY7MMHz7c/yjQ5/h7TV/k7zV9kb/X9EX+XtNmUyfcbQxSAwAAgBIRugEAAKBEhO4+bNCgQTnrrLMyaNCgcpcCXcbfa/oif6/pi/y9pi/y95rOMEgNAAAASsRJNwAAAJSI0A0AAAAlInQDAABAiQjdfdS3v/3tTJkyJTU1NZk2bVruv//+cpcEW+TCCy/MHnvskWHDhmXrrbfOgQcemKeeeqrcZUGX+epXv5qqqqqceOKJ5S4FttjcuXPzL//yLxk9enRqa2uz00475Y9//GO5y4JOa25uzhlnnJH6+vrU1tZm6tSpOffcc2M8FptD6O6Drr/++px00kk566yz8tBDD2XnnXfOjBkz8uKLL5a7NOi03/72tznuuOPyhz/8IXfeeWfWrFmTD37wg1m+fHm5S4Mt9sADD+R73/te3va2t5W7FNhiL7/8ct71rndlwIABue222/L444/nG9/4RkaOHFnu0qDTvva1r+WKK67I5ZdfnieeeCJf+9rXctFFF+Wyyy4rd2n0AqaX90HTpk3LHnvskcsvvzxJ0tLSkkmTJuWEE07IKaecUubqoGu89NJL2XrrrfPb3/4273nPe8pdDnTaK6+8kre//e35zne+k/POOy+77LJLLrnkknKXBZ12yimn5He/+13+93//t9ylQJf50Ic+lLFjx+aHP/xh8drBBx+c2traXH311WWsjN7ASXcfs3r16jz44IOZPn168Vp1dXWmT5+ee++9t4yVQddasmRJkmTUqFFlrgS2zHHHHZf99tuv3f9uQ2926623Zvfdd89HP/rRbL311tl1113zgx/8oNxlwRbZa6+9MmvWrPzlL39Jkjz66KO55557ss8++5S5MnqD/uUugK7V1NSU5ubmjB07tt31sWPH5sknnyxTVdC1WlpacuKJJ+Zd73pX/v7v/77c5UCn/fSnP81DDz2UBx54oNylQJd59tlnc8UVV+Skk07KaaedlgceeCCf/exnM3DgwBx55JHlLg865ZRTTsnSpUuzww47pF+/fmlubs7555+fww8/vNyl0QsI3UCvc9xxx+XPf/5z7rnnnnKXAp02Z86cfO5zn8udd96ZmpqacpcDXaalpSW77757LrjggiTJrrvumj//+c/57ne/K3TTa/3sZz/LNddck2uvvTY77rhjHnnkkZx44omZMGGCv9e8IaG7j6mrq0u/fv2yYMGCdtcXLFiQcePGlakq6DrHH398fvGLX+Tuu+/Om970pnKXA5324IMP5sUXX8zb3/724rXm5ubcfffdufzyy7Nq1ar069evjBVC54wfPz5vfetb2117y1vekptuuqlMFcGWO/nkk3PKKafk0EMPTZLstNNOaWxszIUXXih084Y8093HDBw4MLvttltmzZpVvNbS0pJZs2Zlzz33LGNlsGUKhUKOP/74/PznP8+vfvWr1NfXl7sk2CLvf//786c//SmPPPJI8Wv33XfP4YcfnkceeUTgptd617vetd5Kx7/85S+ZPHlymSqCLbdixYpUV7ePTv369UtLS0uZKqI3cdLdB5100kk58sgjs/vuu+cd73hHLrnkkixfvjwzZ84sd2nQaccdd1yuvfba/Nd//VeGDRuW+fPnJ0lGjBiR2traMlcHHTds2LD1ZhIMGTIko0ePNquAXu3zn/989tprr1xwwQU55JBDcv/99+f73/9+vv/975e7NOi0/fffP+eff3622Wab7Ljjjnn44Ydz8cUX5xOf+ES5S6MXsDKsj7r88svz7//+75k/f3522WWXXHrppZk2bVq5y4JOq6qq2uD1K6+8MkcddVT3FgMl8k//9E9WhtEn/OIXv8ipp56av/71r6mvr89JJ52Uo48+utxlQactW7YsZ5xxRn7+85/nxRdfzIQJE3LYYYflzDPPzMCBA8tdHj2c0A0AAAAl4pluAAAAKBGhGwAAAEpE6AYAAIASEboBAACgRIRuAAAAKBGhGwAAAEpE6AYAAIASEboBAACgRIRuAKBbVVVV5ZZbbil3GQDQLYRuAKggRx11VKqqqtb72nvvvctdGgD0Sf3LXQAA0L323nvvXHnlle2uDRo0qEzVAEDf5qQbACrMoEGDMm7cuHZfI0eOTLKu9fuKK67IPvvsk9ra2my77ba58cYb2/3+n/70p7zvfe9LbW1tRo8enWOOOSavvPJKu3t+9KMfZccdd8ygQYMyfvz4HH/88e1+3tTUlIMOOiiDBw/Odtttl1tvvbW0HxoAykToBgDaOeOMM3LwwQfn0UcfzeGHH55DDz00TzzxRJJk+fLlmTFjRkaOHJkHHnggN9xwQ+666652ofqKK67Icccdl2OOOSZ/+tOfcuutt+bNb35zu/f4yle+kkMOOSSPPfZY9t133xx++OFZtGhRt35OAOgOVYVCoVDuIgCA7nHUUUfl6quvTk1NTbvrp512Wk477bRUVVXl2GOPzRVXXFH82Tvf+c68/e1vz3e+85384Ac/yP/7f/8vc+bMyZAhQ5Ik//3f/539998/8+bNy9ixYzNx4sTMnDkz55133gZrqKqqyumnn55zzz03ybogP3To0Nx2222eLQegz/FMNwBUmPe+973tQnWSjBo1qvjPe+65Z7uf7bnnnnnkkUeSJE888UR23nnnYuBOkne9611paWnJU089laqqqsybNy/vf//7N1nD2972tuI/DxkyJMOHD8+LL77Y2Y8EAD2W0A0AFWbIkCHrtXt3ldra2s26b8CAAe2+r6qqSktLSylKAoCy8kw3ANDOH/7wh/W+f8tb3pIkectb3pJHH300y5cvL/78d7/7Xaqrq7P99ttn2LBhmTJlSmbNmtWtNQNAT+WkGwAqzKpVqzJ//vx21/r375+6urokyQ033JDdd9897373u3PNNdfk/vvvzw9/+MMkyeGHH56zzjorRx55ZM4+++y89NJLOeGEE/Kv//qvGTt2bJLk7LPPzrHHHputt946++yzT5YtW5bf/e53OeGEE7r3gwJADyB0A0CFuf322zN+/Ph217bffvs8+eSTSdZNFv/pT3+az3zmMxk/fnyuu+66vPWtb02SDB48OHfccUc+97nPZY899sjgwYNz8MEH5+KLLy6+1pFHHpmVK1fmm9/8Zr74xS+mrq4uH/nIR7rvAwJAD2J6OQBQVFVVlZ///Oc58MADy10KAPQJnukGAACAEhG6AQAAoEQ80w0AFHnqDAC6lpNuAAAAKBGhGwAAAEpE6AYAAIASEboBAACgRIRuAAAAKBGhGwAAAEpE6AYAAIASEboBAACgRIRuAAAAKJH/H+vqaFO4m670AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create the directories\n",
    "os.makedirs('images/Recurrent Neural Network (RNN)', exist_ok=True)\n",
    "\n",
    "# Plot training & validation accuracy values\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "plt.title('Model accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Test'], loc='upper left')\n",
    "plt.tight_layout()\n",
    "plt.savefig('images/Recurrent Neural Network (RNN)/accuracy.png', dpi=600)\n",
    "plt.show()\n",
    "\n",
    "# Plot training & validation loss values\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('Model loss')\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Test'], loc='upper left')\n",
    "plt.tight_layout()\n",
    "plt.savefig('images/Recurrent Neural Network (RNN)/loss.png', dpi=600)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\hp\\AppData\\Roaming\\Python\\Python311\\site-packages\\keras\\src\\engine\\training.py:3079: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
      "  saving_api.save_model(\n"
     ]
    }
   ],
   "source": [
    "# Create a new directory\n",
    "os.makedirs('Models', exist_ok=True)\n",
    "\n",
    "# Save the model\n",
    "model_rnn.save('Models/Recurrent Neural Network (RNN).h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the model\n",
    "loaded_model = load_model('Models/Recurrent Neural Network (RNN).h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9/9 [==============================] - 7s 339ms/step\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00       275\n",
      "           1       1.00      0.00      0.00         1\n",
      "\n",
      "    accuracy                           1.00       276\n",
      "   macro avg       1.00      0.50      0.50       276\n",
      "weighted avg       1.00      1.00      0.99       276\n",
      "\n",
      "ROC AUC: 0.5\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# X_test is the test data and y_test are the true labels\n",
    "y_pred = loaded_model.predict(X_test)\n",
    "y_pred = (y_pred > 0.5)  # Convert probabilities to binary outputs\n",
    "\n",
    "# Print the classification report\n",
    "print(classification_report(y_test, y_pred, zero_division=1))\n",
    "\n",
    "# Print the ROC AUC score\n",
    "roc_auc = roc_auc_score(y_test, y_pred)\n",
    "print(f'ROC AUC: {roc_auc}')\n",
    "\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "sns.heatmap(cm, annot=True, fmt='d')\n",
    "plt.title('Confusion matrix')\n",
    "plt.xlabel('Predicted label')\n",
    "plt.ylabel('True label')\n",
    "plt.tight_layout()\n",
    "plt.savefig('images/Recurrent Neural Network (RNN)/confusion_matrix.png', dpi=600)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9/9 [==============================] - 5s 557ms/step\n"
     ]
    }
   ],
   "source": [
    "# Create an array of IDs\n",
    "ids = df['id'].values\n",
    "\n",
    "# Split the IDs into training and test sets\n",
    "_, ids_test = train_test_split(ids, test_size=0.2, random_state=42)\n",
    "\n",
    "# Generate predictions\n",
    "predictions = loaded_model.predict(X_test)\n",
    "\n",
    "# If predictions is not a 1D array, flatten it\n",
    "if predictions.ndim != 1:\n",
    "    predictions = predictions.flatten()\n",
    "\n",
    "# Create a new DataFrame with IDs and predictions\n",
    "result_df = pd.DataFrame({\n",
    "    'id': ids_test,\n",
    "    'predictions': predictions\n",
    "})\n",
    "\n",
    "# Define the directory and file paths\n",
    "dir_path = 'Data/submission'\n",
    "file_path = os.path.join(dir_path, 'submission.csv')\n",
    "\n",
    "# Create the directory if it doesn't exist\n",
    "os.makedirs(dir_path, exist_ok=True)\n",
    "\n",
    "# Save the DataFrame to a CSV file in the specified directory\n",
    "result_df.to_csv(file_path, index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>predictions</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>70d7c567</td>\n",
       "      <td>0.000646</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>81977e6c</td>\n",
       "      <td>0.000636</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>e43869b8</td>\n",
       "      <td>0.000623</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>d33eca96</td>\n",
       "      <td>0.000628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>71f7131e</td>\n",
       "      <td>0.000733</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>271</th>\n",
       "      <td>62b480e1</td>\n",
       "      <td>0.000648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>272</th>\n",
       "      <td>7405b110</td>\n",
       "      <td>0.000641</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>273</th>\n",
       "      <td>47e743a7</td>\n",
       "      <td>0.000650</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>274</th>\n",
       "      <td>95d41c3e</td>\n",
       "      <td>0.000640</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>275</th>\n",
       "      <td>ee6fb060</td>\n",
       "      <td>0.000673</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>276 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "           id  predictions\n",
       "0    70d7c567     0.000646\n",
       "1    81977e6c     0.000636\n",
       "2    e43869b8     0.000623\n",
       "3    d33eca96     0.000628\n",
       "4    71f7131e     0.000733\n",
       "..        ...          ...\n",
       "271  62b480e1     0.000648\n",
       "272  7405b110     0.000641\n",
       "273  47e743a7     0.000650\n",
       "274  95d41c3e     0.000640\n",
       "275  ee6fb060     0.000673\n",
       "\n",
       "[276 rows x 2 columns]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "submission_df = pd.read_csv('Data/submission/submission.csv')\n",
    "\n",
    "# Display the data\n",
    "submission_df"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}