2_5_8_Chatbot_development_Starter_Kit.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "<!-- Project Overview -->\n",
        "\n",
        "# <span style=\"color: #3498db;\">2_5_8_Chatbot_development_Starter_Kit</span>\n",
        "\n",
        "## <span style=\"color: #2ecc71;\">Project Description</span>\n",
        "\n",
        "The objective of this project is to develop a sequence-to-sequence (Seq2Seq) model for generating movie dialogues. This involves encoding dialogue text into a fixed-length vector using an LSTM-based encoder and then decoding this vector to generate coherent dialogue sequences. The project focuses on handling large volumes of dialogue data, tokenizing and padding sequences, and constructing a Seq2Seq model capable of producing meaningful dialogue responses.\n",
        "\n",
        "## <span style=\"color: #e74c3c;\">Data Loading and Initial Inspection</span>\n",
        "\n",
        "1. **Loading the Dataset**:\n",
        "   - The dataset is imported using `pandas`, which contains columns for dialogue ID, character ID, movie ID, character name, and the actual dialogue text. This step is crucial for preparing the data for further processing.\n",
        "\n",
        "2. **Initial Data Exploration**:\n",
        "   - Initial rows and a summary of the dataset are examined to understand the structure and quality of the data. This includes checking for non-null values and column data types.\n",
        "\n",
        "3. **Handling Missing Values**:\n",
        "   - Missing dialogue entries are addressed by replacing them with empty strings, ensuring that the dataset is complete and ready for processing.\n",
        "\n",
        "4. **Visualization**:\n",
        "   - A histogram with Kernel Density Estimate (KDE) is plotted to visualize the distribution of text lengths, helping identify any anomalies or patterns in the data.\n",
        "\n",
        "## <span style=\"color: #9b59b6;\">Data Cleaning and Preprocessing</span>\n",
        "\n",
        "1. **Text Cleaning**:\n",
        "   - The dialogue text is cleaned to improve consistency and remove noise. This involves converting all text to lowercase and removing any extraneous whitespace.\n",
        "\n",
        "2. **Updated Data Visualization**:\n",
        "   - The distribution of text lengths is re-plotted after cleaning to ensure the preprocessing steps have addressed any previous inconsistencies.\n",
        "\n",
        "## <span style=\"color: #f39c12;\">Tokenization and Sequence Padding</span>\n",
        "\n",
        "1. **Tokenization**:\n",
        "   - The `Tokenizer` from TensorFlow is used to convert dialogue text into sequences of integers, with each integer representing a unique word or token. The vocabulary size is calculated to determine the range of token indices.\n",
        "\n",
        "2. **Sequence Padding**:\n",
        "   - Sequences are padded to a uniform length to ensure compatibility with the LSTM model. Padding is applied to the end of sequences to maintain their length consistency.\n",
        "\n",
        "3. **Visualization of Sequence Lengths**:\n",
        "   - The sequence lengths are visualized to confirm that padding has been applied correctly and that all sequences are now of uniform length.\n",
        "\n",
        "## <span style=\"color: #1abc9c;\">Model Architecture</span>\n",
        "\n",
        "1. **Encoder**:\n",
        "   - The encoder is designed with an embedding layer followed by an LSTM layer. The embedding layer converts tokens into dense vectors, while the LSTM processes these vectors to produce hidden states.\n",
        "\n",
        "2. **Decoder**:\n",
        "   - The decoder, consisting of an embedding layer and an LSTM, generates sequences based on the encoder's hidden states. A dense layer with softmax activation produces the final token predictions.\n",
        "\n",
        "3. **Model Definition and Compilation**:\n",
        "   - The Seq2Seq model is compiled using the RMSprop optimizer and categorical crossentropy loss function, setting the stage for training and optimization.\n",
        "\n",
        "## <span style=\"color: #e67e22;\">Training and Evaluation</span>\n",
        "\n",
        "1. **Model Training**:\n",
        "   - The model is trained with the processed input and target sequences. Training is monitored using a validation split to track performance and prevent overfitting.\n",
        "\n",
        "2. **Loss Visualization**:\n",
        "   - Training and validation loss are plotted to visualize the model's learning process and assess its performance over epochs.\n",
        "\n",
        "## <span style=\"color: #2c3e50;\">Inference Models and Testing</span>\n",
        "\n",
        "1. **Inference Models**:\n",
        "   - Separate models for encoding and decoding are used during inference to generate new dialogue sequences based on the input data.\n",
        "\n",
        "2. **Decoding Function**:\n",
        "   - A function is implemented to decode the generated sequences into human-readable text, allowing for the evaluation of the model's performance in generating coherent dialogues.\n",
        "\n",
        "3. **Model Testing**:\n",
        "   - The model is tested with sample inputs to generate and print dialogue sequences, providing a practical demonstration of its capabilities.\n",
        "\n",
        "## <span style=\"color: #34495e;\">Future Work and Improvements</span>\n",
        "\n",
        "1. **Hyperparameter Tuning**:\n",
        "   - Further experimentation with hyperparameters such as the number of LSTM units, batch size, and learning rate could enhance model performance.\n",
        "\n",
        "2. **Handling Special Tokens**:\n",
        "   - Proper management of special tokens like `startseq` and `endseq` is essential for improving the model's ability to generate accurate and complete sequences.\n",
        "\n",
        "3. **Model Evaluation**:\n",
        "   - Additional evaluation metrics, such as BLEU scores, could be used to better assess the quality of the generated text and compare it with human-generated dialogue.\n",
        "\n",
        "4. **Model Persistence**:\n",
        "   - Implementing functionality to save and load the trained model will facilitate future use and experimentation, allowing for easy deployment and further testing."
      ],
      "metadata": {
        "id": "xdTGxu1HYIBx"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "KPSjWS-RYYJr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "24JiBGkdYHuT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "er5_fs7VYZNk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Imports and Setup</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">Import Libraries</span>\n",
        "\n",
        "- **`pandas`**: Essential for data manipulation and analysis. Provides data structures like DataFrames for handling datasets.\n",
        "- **`numpy`**: Used for numerical operations and array manipulations, integral for handling data arrays.\n",
        "- **`matplotlib.pyplot`**: A plotting library for creating visualizations such as histograms, scatter plots, and line graphs.\n",
        "- **`seaborn`**: Builds on `matplotlib` for advanced statistical data visualization, making it easier to create informative plots.\n",
        "- **`tensorflow`**: A comprehensive open-source framework for building and training machine learning models, including deep learning.\n",
        "- **`keras`**: High-level API integrated with TensorFlow, simplifies the process of creating and training neural networks.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">Set Up GPU/CPU Environment</span>\n",
        "\n",
        "- **GPU Acceleration**: Ensure GPU support is enabled if available, to speed up the training and evaluation of deep learning models.\n",
        "- **CPU Configuration**: For environments without GPU, optimize code and training processes to ensure efficient CPU usage.\n",
        "\n",
        "### <span style=\"color: #f39c12;\">Configure TensorFlow Settings</span>\n",
        "\n",
        "- **TensorFlow Settings**: Set configurations such as logging level, device placement, and memory growth options to optimize TensorFlow's performance."
      ],
      "metadata": {
        "id": "9LgVwn09Yi1Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd  # Import pandas library for data manipulation"
      ],
      "metadata": {
        "id": "CfVKApF_V5jE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np  # Import numpy library for numerical operations"
      ],
      "metadata": {
        "id": "clFXmIIjUHHB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.preprocessing.text import Tokenizer  # Import Tokenizer for text tokenization"
      ],
      "metadata": {
        "id": "xumTDECaTcZy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.preprocessing.sequence import pad_sequences  # Import pad_sequences for padding sequences\n"
      ],
      "metadata": {
        "id": "DnLbFV9kSWrA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.models import Model  # Import Model class to build the Keras model"
      ],
      "metadata": {
        "id": "YJiwq1TKR9cT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.layers import Input, Embedding, LSTM, Dense  # Import necessary layers for the model\n"
      ],
      "metadata": {
        "id": "3V271Z9JQ9zq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.utils import to_categorical  # Import to_categorical for converting labels to one-hot encoding\n"
      ],
      "metadata": {
        "id": "9qStKr9XQplM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt  # Import matplotlib for plotting"
      ],
      "metadata": {
        "id": "UoV-5VhMQKJw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns  # Import seaborn for statistical data visualization"
      ],
      "metadata": {
        "id": "q1d-KbaROEx7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "nu2nPoYoXyC4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ENt2CBDwXyFw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "xH92h8bnY7i4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Data Loading and Initial Inspection</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Load the Dataset</span>\n",
        "\n",
        "- **Dataset Path**: Define the path to the dataset file, ensuring it is correctly specified.\n",
        "- **Data Loading**: Use `pandas` to read the dataset into a DataFrame, handling separators and column names as needed.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Display Initial Dataset Information</span>\n",
        "\n",
        "- **First Few Rows**: Use `.head()` to preview the first few rows of the dataset, providing an initial understanding of its structure and contents.\n",
        "- **Dataset Summary**: Use `.info()` to obtain a summary of the dataset, including data types and non-null counts, to identify any missing values or anomalies.\n",
        "\n",
        "### <span style=\"color: #9b59b6;\">3. Summary Statistics for Text Column</span>\n",
        "\n",
        "- **Text Column Analysis**: Use `.describe()` on the 'text' column to gather summary statistics such as count, unique values, and basic descriptive metrics, giving insights into the text data.\n",
        "\n",
        "### <span style=\"color: #f39c12;\">4. Ensure Data Quality</span>\n",
        "\n",
        "- **Handle Missing Values**: Replace missing values in the 'text' column with empty strings or appropriate placeholders to ensure data integrity.\n",
        "- **Data Type Conversion**: Ensure that all values in the 'text' column are of type string to avoid errors during processing.\n",
        "\n",
        "### <span style=\"color: #1abc9c;\">5. Plot Distribution of Text Lengths</span>\n",
        "\n",
        "- **Calculate Text Lengths**: Create a new column to store the length of each text entry.\n",
        "- **Visualization**: Use `seaborn` to plot the distribution of text lengths, providing insights into the variability and typical length of dialogues in the dataset."
      ],
      "metadata": {
        "id": "A3dqpZ6VY70C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the dataset"
      ],
      "metadata": {
        "id": "dZTvz9-iXyM6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dataset_path = 'movie_lines.tsv'  # Update with the correct path if necessary"
      ],
      "metadata": {
        "id": "Lvy5jew5XyPz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines = pd.read_csv(dataset_path, sep='\\t', on_bad_lines='skip', names=['lineID', 'characterID', 'movieID', 'character', 'text'])  # Load dataset with tab separator\n"
      ],
      "metadata": {
        "id": "PKMVpg4iN496"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "nT3-uVz0X5VX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "oOHuO3x3X5YV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Display initial dataset information"
      ],
      "metadata": {
        "id": "00k4_RtpX5ax"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"First few rows of the dataset:\")\n",
        "print(lines.head())  # Print the first few rows of the dataset"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LcrC-HLJX5dS",
        "outputId": "61d4cf94-fcd7-4ed4-886d-0812f2a103f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First few rows of the dataset:\n",
            "  lineID characterID movieID character          text\n",
            "0  L1045          u0      m0    BIANCA  They do not!\n",
            "1  L1044          u2      m0   CAMERON   They do to!\n",
            "2   L985          u0      m0    BIANCA    I hope so.\n",
            "3   L984          u2      m0   CAMERON     She okay?\n",
            "4   L925          u0      m0    BIANCA     Let's go.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "TLt8ZN2MX5f_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ALORjejTX-z4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\\nDataset info:\")\n",
        "print(lines.info())  # Print dataset summary including column types and non-null counts"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VU2jhyUfX-23",
        "outputId": "a20595b5-1b64-4370-9a9c-e84dfbe3473f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Dataset info:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 293202 entries, 0 to 293201\n",
            "Data columns (total 5 columns):\n",
            " #   Column       Non-Null Count   Dtype \n",
            "---  ------       --------------   ----- \n",
            " 0   lineID       293202 non-null  object\n",
            " 1   characterID  288917 non-null  object\n",
            " 2   movieID      288917 non-null  object\n",
            " 3   character    288874 non-null  object\n",
            " 4   text         288663 non-null  object\n",
            "dtypes: object(5)\n",
            "memory usage: 11.2+ MB\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ZZ_zO0EcX-5h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ZrHbID3CX-8F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Summary statistics for 'text' column"
      ],
      "metadata": {
        "id": "3QcVbzN5X--f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\\nSummary statistics for 'text' column:\")\n",
        "print(lines['text'].describe())  # Print summary statistics for the 'text' column"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4GqWDNSWX_BJ",
        "outputId": "88824d89-8203-474f-cf66-5b5e9fa15d11"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Summary statistics for 'text' column:\n",
            "count     288663\n",
            "unique    251306\n",
            "top        What?\n",
            "freq        1610\n",
            "Name: text, dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "u4mLUGdhYGRC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wQEerEFEYGUL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Ensure 'text' column is string and handle NaN values"
      ],
      "metadata": {
        "id": "1IOqe4tbYGW3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines['text'] = lines['text'].fillna('')  # Replace NaNs with empty strings in 'text' column"
      ],
      "metadata": {
        "id": "0hJ5X7dFYGaR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines['text'] = lines['text'].astype(str)  # Ensure all values in 'text' column are strings"
      ],
      "metadata": {
        "id": "qL8vnfomYGcG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "k0bhNcw4YOoo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "opTdiarUYOrJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot distribution of text lengths"
      ],
      "metadata": {
        "id": "G-SHsZlqYOtq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines['text_length'] = lines['text'].apply(lambda x: len(x) if isinstance(x, str) else 0)  # Calculate text length\n",
        "plt.figure(figsize=(10, 6))  # Set the figure size for the plot\n",
        "sns.histplot(lines['text_length'], bins=50, kde=True)  # Plot distribution of text lengths with histogram and KDE\n",
        "plt.title('Distribution of Text Lengths')  # Set the title of the plot\n",
        "plt.xlabel('Length of Text')  # Set the x-axis label\n",
        "plt.ylabel('Frequency')  # Set the y-axis label\n",
        "plt.show()  # Display the plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 528
        },
        "id": "12ECKaNBYOwH",
        "outputId": "92eed4c3-a032-4d96-89a1-541d4f3f9e3e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "4winZ0hfYOy7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "yH66oExfYO08"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Unique counts in columns"
      ],
      "metadata": {
        "id": "IIa-fvdGYO28"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\\nUnique counts in columns:\")  # Print a description for the following data\n",
        "print(f\"Unique characters: {lines['character'].nunique()}\")  # Print unique character counts\n",
        "print(f\"Unique movies: {lines['movieID'].nunique()}\")  # Print unique movie counts"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "epVSNgZVYO48",
        "outputId": "013270c1-9a8a-4a75-878f-dfa0aeb91807"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Unique counts in columns:\n",
            "Unique characters: 5214\n",
            "Unique movies: 607\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "CpqizHZOYdzQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Ky5aeiMAYd2Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot counts of unique characters"
      ],
      "metadata": {
        "id": "wyiYmnjzYd5i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(12, 6))  # Set the figure size for the plot\n",
        "sns.countplot(y='character', data=lines, order=lines['character'].value_counts().index)  # Plot frequency of dialogues by character\n",
        "plt.title('Frequency of Dialogues by Character')  # Set the title of the plot\n",
        "plt.xlabel('Count')  # Set the x-axis label\n",
        "plt.ylabel('Character')  # Set the y-axis label\n",
        "plt.show()  # Display the plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 426
        },
        "id": "IFS_tDmNYd85",
        "outputId": "b3a6e125-aa1e-4c71-b6aa-6b222228fc6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 146 (\\x92) missing from current font.\n",
            "  fig.canvas.print_figure(bytes_io, **kw)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "89PJjk-IYkoH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wPhzBHyUYkra"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot counts of unique movies"
      ],
      "metadata": {
        "id": "VgHKJ5r2YkuU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(12, 6))  # Set the figure size for the plot\n",
        "sns.countplot(y='movieID', data=lines, order=lines['movieID'].value_counts().index)  # Plot frequency of dialogues by movie\n",
        "plt.title('Frequency of Dialogues by Movie')  # Set the title of the plot\n",
        "plt.xlabel('Count')  # Set the x-axis label\n",
        "plt.ylabel('Movie ID')  # Set the y-axis label\n",
        "plt.show()  # Display the plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 450
        },
        "id": "5Zt2cFlBYkxk",
        "outputId": "1aec61d0-2e8b-4ce3-c28c-52100786f9fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABAkAAAIjCAYAAABh4ELrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACf0ElEQVR4nOzde3xU1bn/8e/MZCaZXIZbIIBBEAREUPEGplZEUW7WSmmlYhWxKqc3f6Jt9VSpoKUWUVutVau9KLaK1KJWa62ooChYUEDwQiVikGsICblfJpmZ/fsjZ7aZzN47CYLsDJ/36+XrOGvtvfZKwNfpfmY9z+MxDMMQAAAAAAA44nkP9wYAAAAAAIA7ECQAAAAAAACSCBIAAAAAAID/Q5AAAAAAAABIIkgAAAAAAAD+D0ECAAAAAAAgiSABAAAAAAD4PwQJAAAAAACAJIIEAAAAAADg/xAkAADgCFJYWKjx48erS5cu8ng8eu655w7a2q+//ro8Ho9ef/31Dt87b948eTyeg7YXt5s5c6ays7MP9za+NEfany8AdGYECQAAh8Rjjz0mj8dj+c///u//Hu7tHbGuuOIKvf/++/rlL3+pv/zlLzrttNMsr9u2bVvCn5nf71dubq6+8pWv6Oabb9b27du/5J3jQAwYMEAej0fnnXee5fwf/vAH88/43Xff/ZJ3BwBwo7TDvQEAQGq7/fbbdcwxxySMjRgx4jDt5shWX1+vt99+W7fccot+9KMfteue6dOna/LkyYrFYiovL9c777yje++9V/fdd5/+9Kc/6ZJLLjGvHTNmjOrr6xUIBA7Vj4ADkJGRoRUrVqi4uFi9e/dOmHviiSeUkZGhhoaGQ7qHOXPmEBwEgE6CIAEA4JCaNGmS7bfVrTU0NCgQCMjr5aDbobBv3z5JUteuXdt9zymnnKLLLrssYeyzzz7T+PHjdcUVV2jYsGE66aSTJEler1cZGRkHbb84OM4880y98847WrJkia677jpzfOfOnXrzzTf1jW98Q0uXLj2ke0hLS1NaGv+zEwA6A/5XGADgsIjnrz/11FOaM2eOjjrqKGVmZqqqqkqStGbNGk2cOFFdunRRZmamzj77bK1atSppnbfeekunn366MjIyNGjQID388MNJ+c/xo/OPPfZY0v0ej0fz5s1LGNu1a5e++93vKi8vT+np6Ro+fLj+/Oc/W+7/b3/7m375y18qPz9fGRkZGjdunD755JOk56xZs0aTJ09Wt27dlJWVpRNPPFH33XefJOnRRx+Vx+PRhg0bku6744475PP5tGvXLsff54YNGzRp0iSFQiFlZ2dr3Lhx+s9//mPOz5s3T/3795ck/fSnP5XH49GAAQMc17TTv39/PfbYY2psbNTChQvNcauaBG+++aYuvvhiHX300UpPT1e/fv10/fXXq76+vs3nRCIR/eIXv9CgQYOUnp6uAQMG6Oabb1Y4HE64LhaLad68eerbt68yMzN1zjnn6KOPPtKAAQM0c+bMhN+BVV58PDVm27ZtCeMvvfSSzjrrLGVlZSknJ0cXXHCBPvzww4RriouLdeWVVyo/P1/p6enq06ePLrrooqS17Hz66aeaMGGCsrKy1LdvX91+++0yDEOSZBiGBgwYoIsuuijpvoaGBnXp0kX/8z//0+YzMjIyNHXqVD355JMJ44sXL1a3bt00YcIEy/uWL19u/vxdu3bVRRddpM2bN5vzf//73+XxePTGG28k3fvwww/L4/Hogw8+kGT/u//rX/+qU089VcFgUN27d9cll1yiHTt2tPkzAQAOHUK6AIBDqrKyUqWlpQljubm55r//4he/UCAQ0E9+8hOFw2EFAgEtX75ckyZN0qmnnqq5c+fK6/Xq0Ucf1bnnnqs333xTo0aNkiS9//77Gj9+vHr27Kl58+YpEolo7ty5ysvLO+D97t27V2eccYY8Ho9+9KMfqWfPnnrppZd01VVXqaqqSrNnz064fsGCBfJ6vfrJT36iyspKLVy4UN/5zne0Zs0a85pXXnlFX/va19SnTx9dd9116t27tzZv3qx//vOfuu666/Stb31LP/zhD/XEE0/o5JNPTlj/iSee0NixY3XUUUfZ7vnDDz/UWWedpVAopBtvvFF+v18PP/ywxo4dqzfeeEOjR4/W1KlT1bVrV11//fVmCsEXKZxXUFCgQYMG6ZVXXnG87umnn1ZdXZ2+//3vq0ePHlq7dq3uv/9+7dy5U08//bTjvVdffbUWLVqkb33rW/rxj3+sNWvW6Fe/+pU2b96sZ5991rzuZz/7mRYuXKgLL7xQEyZM0MaNGzVhwoQvdIT+L3/5i6644gpNmDBBd955p+rq6vTQQw/pq1/9qjZs2GAGWL75zW/qww8/1LXXXqsBAwaopKREr7zyirZv395mECYajWrixIk644wztHDhQv373//W3LlzFYlEdPvtt8vj8eiyyy7TwoULtX//fnXv3t2894UXXlBVVVXSKQ87l156qcaPH6+tW7dq0KBBkqQnn3xS3/rWt+T3+5Ouf/XVVzVp0iQNHDhQ8+bNU319ve6//36deeaZWr9+vQYMGKALLrhA2dnZ+tvf/qazzz474f4lS5Zo+PDhjqlFv/zlL/Xzn/9c06ZN09VXX619+/bp/vvv15gxY7Rhw4YOnXgBABxEBgAAh8Cjjz5qSLL8xzAMY8WKFYYkY+DAgUZdXZ15XywWMwYPHmxMmDDBiMVi5nhdXZ1xzDHHGOeff745NmXKFCMjI8P47LPPzLGPPvrI8Pl8Rsv/F1dUVGRIMh599NGkfUoy5s6da36+6qqrjD59+hilpaUJ111yySVGly5dzL3G9z9s2DAjHA6b1913332GJOP99983DMMwIpGIccwxxxj9+/c3ysvLE9Zs+fNNnz7d6Nu3rxGNRs2x9evX2+67pSlTphiBQMDYunWrObZ7924jJyfHGDNmTNLv4a677nJcr73XXnTRRYYko7Ky0jCMz38nK1asMK9p+Wcb96tf/crweDwJf25z585N+DN77733DEnG1VdfnXDvT37yE0OSsXz5csMwDKO4uNhIS0szpkyZknDdvHnzDEnGFVdcYfuMuPjf1aKiIsMwDKO6utro2rWrcc011yRcV1xcbHTp0sUcLy8vb/fvs7UrrrjCkGRce+215lgsFjMuuOACIxAIGPv27TMMwzA+/vhjQ5Lx0EMPJdz/9a9/3RgwYEDC3yEr/fv3Ny644AIjEokYvXv3Nn7xi18YhtH834kk44033jB//nfeece8b+TIkUavXr2MsrIyc2zjxo2G1+s1ZsyYYY5Nnz7d6NWrlxGJRMyxPXv2GF6v17j99tvNsda/+23bthk+n8/45S9/mbDf999/30hLS0saBwB8eUg3AAAcUg888IBeeeWVhH9auuKKKxQMBs3P7733ngoLC3XppZeqrKxMpaWlKi0tVW1trcaNG6eVK1cqFospGo3q5Zdf1pQpU3T00Ueb9w8bNsz2+HRbDMPQ0qVLdeGFF8owDPPZpaWlmjBhgiorK7V+/fqEe6688sqEQn1nnXWWpOZj5FJzGkBRUZFmz56d9M1oy+PXM2bM0O7du7VixQpz7IknnlAwGNQ3v/lN2z1Ho1EtW7ZMU6ZM0cCBA83xPn366NJLL9Vbb71lpnAcbPGTCNXV1bbXtPyzra2tVWlpqb7yla/IMAzL9Iq4f/3rX5KkG264IWH8xz/+sSTpxRdflCS99tprikQi+sEPfpBw3bXXXtuBnyTRK6+8ooqKCk2fPj3h74DP59Po0aPNP6NgMKhAIKDXX39d5eXlB/SslgUk46dXGhsb9eqrr0qShgwZotGjR+uJJ54wr9u/f79eeuklfec732l3W0Gfz6dp06Zp8eLFkpr/bvXr18/8+9rSnj179N5772nmzJkJpxdOPPFEnX/++eafjSR9+9vfVklJSUKKyd///nfFYjF9+9vftt3PM888o1gspmnTpiX8jnv37q3Bgwcn/HcAAPhykW4AADikRo0a5Vi4sHXng8LCQknNwQM7lZWVCofDqq+v1+DBg5Pmhw4dmvAi01779u1TRUWFHnnkET3yyCOW15SUlCR8bhmgkKRu3bpJkvnSuHXrVkltd3Q4//zz1adPHz3xxBMaN26cYrGYFi9erIsuukg5OTmOe66rq9PQoUOT5oYNG6ZYLKYdO3Zo+PDhjs8/EDU1NZLkuL/t27fr1ltv1fPPP5/0Il1ZWWl732effSav16tjjz02Ybx3797q2rWrPvvsM/M6SUnXde/e3fyz6Kj438Fzzz3Xcj4UCkmS0tPTdeedd+rHP/6x8vLydMYZZ+hrX/uaZsyYkdRFwIrX600I7EjNQQFJCTUNZsyYoR/96Ef67LPP1L9/fz399NNqamrS5Zdf3qGf69JLL9Vvf/tbbdy4UU8++aQuueQSyyBD/Hdq93fq5ZdfVm1trbKyssy6IUuWLNG4ceMkNacajBw50vxZrBQWFsowDMv/fiVZpkAAAL4cBAkAAIdVy2+apeYidJJ01113aeTIkZb3ZGdnJxWvc2L3bWs0GrV89mWXXWYbpDjxxBMTPvt8PsvrjP8rPtdePp9Pl156qf7whz/owQcf1KpVq7R79+5255wfDh988IF69eplvjS3Fo1Gdf7552v//v266aabdNxxxykrK0u7du3SzJkzzd+3k/Z+U94eHf178Je//MXyZb9llf7Zs2frwgsv1HPPPaeXX35ZP//5z/WrX/1Ky5cvT6ovcaAuueQSXX/99XriiSd08803669//atOO+00y5d4J6NHj9agQYM0e/ZsFRUV6dJLL/3Ce0tPT9eUKVP07LPP6sEHH9TevXu1atUq3XHHHY73xWIxeTwevfTSS5b/DX2RehkAgC+GIAEAwFXiRdVCoZDOO+882+t69uypYDBofuvb0scff5zwOf6NckVFRcJ4/BvTlmvm5OQoGo06Prsj4j/PBx980OaaM2bM0D333KMXXnhBL730knr27Nlm6kTPnj2VmZmZ9DNL0n//+195vV7169fvwH8AG2+//ba2bt3qGMR4//33tWXLFi1atEgzZswwx9sqdig1d1CIxWIqLCzUsGHDzPG9e/eqoqLC7NQQ/7+ffPJJwqmUsrKypJMLLf8etEz9aP33IP5n1qtXr3b9PRg0aJB+/OMf68c//rEKCws1cuRI3XPPPfrrX//qeF8sFtOnn36a8I37li1bJCmh6GH37t11wQUX6IknntB3vvMdrVq1Svfee2+b+7Iyffp0zZ8/X8OGDbMNwsV/p3Z/p3Jzc5WVlWWOffvb39aiRYv02muvafPmzTIMwzHVQGr+nRmGoWOOOcbxxAEA4MtHTQIAgKuceuqpGjRokO6++27zOHtL+/btk9T8zfuECRP03HPPafv27eb85s2b9fLLLyfcEwqFlJubq5UrVyaMP/jggwmffT6fvvnNb2rp0qVm6zarZ3fEKaecomOOOUb33ntvUpCi9WmDE088USeeeKL++Mc/aunSpbrkkkva7C3v8/k0fvx4/eMf/0g4or537149+eST+upXv2r7Tf+B+uyzzzRz5kwFAgH99Kc/ddyblPhzGoZhtn50MnnyZElKehn+9a9/LUm64IILJEnjxo1TWlqaHnrooYTrfve73yWtGX/5b/n3oLa2VosWLUq4bsKECQqFQrrjjjvU1NSUtE7870FdXV1SB4VBgwYpJyen3SddWu7TMAz97ne/k9/vN4/ux11++eX66KOP9NOf/lQ+n0+XXHJJu9Zv7eqrr9bcuXN1zz332F7Tp08fjRw5UosWLUr4O/vBBx9o2bJl5p9N3Hnnnafu3btryZIlWrJkiUaNGpWURtTa1KlT5fP5dNtttyX9d2AYhsrKyjr+wwEADgpOEgAAXMXr9eqPf/yjJk2apOHDh+vKK6/UUUcdpV27dmnFihUKhUJ64YUXJEm33Xab/v3vf+uss87SD37wA0UiEd1///0aPny4Nm3alLDu1VdfrQULFujqq6/WaaedppUrV5rf2ra0YMECrVixQqNHj9Y111yj448/Xvv379f69ev16quvav/+/R3+eR566CFdeOGFGjlypK688kr16dNH//3vf/Xhhx8mBTRmzJihn/zkJ5LU7lSD+fPn65VXXtFXv/pV/eAHP1BaWpoefvhhhcNhLVy4sEP7bW39+vX661//qlgspoqKCr3zzjtaunSpPB6P/vKXvySlX7R03HHHadCgQfrJT36iXbt2KRQKaenSpe0q8nfSSSfpiiuu0COPPKKKigqdffbZWrt2rRYtWqQpU6bonHPOkSTl5eXpuuuu0z333KOvf/3rmjhxojZu3KiXXnpJubm5CSkG48eP19FHH62rrrrKfNn+85//rJ49eyYEmkKhkB566CFdfvnlOuWUU3TJJZeY17z44os688wz9bvf/U5btmzRuHHjNG3aNB1//PFKS0vTs88+q71797brJT4jI0P//ve/dcUVV2j06NF66aWX9OKLL+rmm29Wz549E6694IIL1KNHDz399NOaNGmSevXq1eb6Vvr376958+a1ed1dd92lSZMmqaCgQFdddZXZArFLly5J9/v9fk2dOlVPPfWUamtrdffdd7e5/qBBgzR//nz97Gc/07Zt2zRlyhTl5OSoqKhIzz77rGbNmmX+dwAA+JIdlp4KAICUZ9VWraV4u7ynn37acn7Dhg3G1KlTjR49ehjp6elG//79jWnTphmvvfZawnVvvPGGceqppxqBQMAYOHCg8fvf/96y1V1dXZ1x1VVXGV26dDFycnKMadOmGSUlJUktEA3DMPbu3Wv88Ic/NPr162f4/X6jd+/exrhx44xHHnmkzf3btVt86623jPPPP9/IyckxsrKyjBNPPNG4//77k37uPXv2GD6fzxgyZIjl78XO+vXrjQkTJhjZ2dlGZmamcc455xirV6+23FtHWiDG/0lLSzO6d+9ujB492vjZz36W0L4wzqoF4kcffWScd955RnZ2tpGbm2tcc801xsaNG5N+R1Z/Zk1NTcZtt91mHHPMMYbf7zf69etn/OxnPzMaGhoSrotEIsbPf/5zo3fv3kYwGDTOPfdcY/PmzUaPHj2M733vewnXrlu3zhg9erQRCASMo48+2vj1r3+d1AKx5c8zYcIEo0uXLkZGRoYxaNAgY+bMmca7775rGIZhlJaWGj/84Q+N4447zsjKyjK6dOlijB492vjb3/7W5u/3iiuuMLKysoytW7ca48ePNzIzM428vDxj7ty5CW0wW/rBD35gSDKefPLJNtePi7dAdGL33+qrr75qnHnmmUYwGDRCoZBx4YUXGh999JHlGq+88oohyfB4PMaOHTuS5u3aTy5dutT46le/amRlZRlZWVnGcccdZ/zwhz80Pv7443b/jACAg8tjGB2srAQAgMvNmzfP8hhzZ1BaWqo+ffro1ltv1c9//vPDvZ1Oq6KiQt26ddP8+fN1yy23HO7tHBTXX3+9/vSnP6m4uFiZmZmHezsAgBRFTQIAAFzkscceUzQa7XB7uyNZfX190li8lsHYsWO/3M0cIg0NDfrrX/+qb37zmwQIAACHFDUJAABwgeXLl+ujjz7SL3/5S02ZMiWhuj2cLVmyRI899pgmT56s7OxsvfXWW1q8eLHGjx+vM88883Bv7wspKSnRq6++qr///e8qKyvTddddd7i3BABIcQQJAABwgdtvv12rV6/WmWeeqfvvv/9wb6dTOfHEE5WWlqaFCxeqqqrKLGY4f/78w721L+yjjz7Sd77zHfXq1Uu//e1vbdsWAgBwsHSqmgQbN27UggUL9NZbb6m0tFQDBgzQ9773vaSo+hNPPKGFCxeqsLBQXbp00aRJk3TXXXepR48ekqSmpib96le/0qJFi7Rr1y4NHTpUd955pyZOnHg4fiwAAAAAAFyhUwUJbrvtNj355JMqLy9XVVWVevTooX379unXv/61fvSjH0mSVq1apbPOOku9evVSRUWFevXqpVgsplGjRumZZ56R1Nx7+aWXXkpaf/369Tr55JO/1J8JAAAAAAC3OKyFC8eOHatrr71Ws2fPVrdu3ZSXl6c//OEPqq2t1ZVXXqmcnBwde+yxCS/0JSUlKi8vVzgcVklJiaLRqH7729+a8/fcc48MwzCv2bVrl/bs2aM33njDvGbFihVJe/F4PLrnnnsO7Q8MAAAAAICLHdaTBF27dlVdXZ1OO+00ffjhh4pGo6qrq9N5552n2tpabdy4UT6fT4ZhqLi4WE899ZSuuuqqpHXS09PV0NAgSerZs6dKS0sVCATU1NSk448/Xh9++KGCwaDq6uokST6fT7FYTJmZmYrFYurWrZuKi4vVu3dv7d6923Kv4XBY4XDY/ByLxbR//3716NFDHo/nEPx2AAAAAAD4nGEYqq6uVt++feX1Hprv/A9rkCD+ct27d28VFxeb47169ZJhGNq3b588Ho8Mw9CKFSs0duxYeTwePfroo/rggw+0dOlSbdu2TaFQSJWVlZJkBgfi90nNQYFoNKrGxkb5/X4zSJCWlqZIJGLOezwexWIxy73OmTNHv/zlLw/xbwQAAAAAAGc7duxQfn7+IVnbFd0N/H6/srOzFQ6H1dTUpLKyMg0YMEA1NTWKRCJqamoygwTS5ycQtm/fLqm5qnFrOTk5qqmpkcfjUTQalST997//1QknnGAGCSKRiCSZ807xkvhJhdZG/M9v5AsED/hnBwAAANC2lfOnH+4tAIddVVWV+vXrp5ycnEP2DFcECWbNmqVvf/vbevLJJzVv3jwZhqGbbrpJY8eO1Zlnnql9+/bpscceM2sPfPOb30z4xr+wsFAvvfSSJk2aZI5XVVUlPWfFihU64YQTlJaWpqampg7t8T//+Y/luC8QlC+dIAEAAAA6p3V3zTjcWwDQQYcy5f2wpxu0POIfjUaVlpamjIwM1dfXS5K6dOmiqqoqBYNB+f1+y5f/tLQ0BYNBFRcXKycnxzZl4Nprr9Vvf/tbdevWTRUVFZbX7N+/X926dUsa/+lPf6q77747abyyslKhUKi9PzIAAAAAAAekqqpKXbp0OaTvoYf9JIFhGDr55JO1ceNGc8zn82nw4MH65JNPzLHMzEzdf//9uvTSS5PW8Hq9qq6u1tq1a5Wenq76+noNGjRIjY2N2rFjh3ndsGHDJMmsX5Ceni6v16vGxkYz5aC4uNgySGAXSxkzZzEnCQAAAGDim3kAndlhDxJIUllZmbKyssyaBLW1tTIMQ8FgMOFEwauvvmp5f2NjoyTpnXfeUWZmpurr67V169ak6+J1BeIv/C27FbTFLt0AAAAAqYGXewBwSZAgPz9flZWVZmcCScrLy0voeBBPRXBSXl7u+OKfm5vb5l569+5tOV5QUKBVq1Ylja+cP510AwAAAABASnBFkKA9SktL9cc//tHxGsMwHDsUtAw62LFKNYivbYV0AwAAgC8X3/gDwKHjyiCBVaXGzMxMZWdna+/evbb3NTU1qU+fPgm1DFrq2rXrAe+JdAMAAIAvF8EAAPjyuTJIYCU3N1fnnHOOHnzwQdtr9u7dq/Lyctv5r33ta5Kknj17at++fUnz3bt3t73XLt0AAAAA1njJB4DOx3u4N2DF6mj/9u3b9cgjjzje17NnT5WVldnOb968WdLn3Q1aixdJtOLz+RyfDQAAgM8RIACAzsmVQQIrsVjM8Zt+STr99NN14YUXWs4NHz5co0ePlvR5N4TWnIIEkUiknTsFAAAAAKBz6jTpBt27d9ewYcO0atUq25f57du3a+fOnZZz5eXlysrKOuDnU5MAAADAGacHAKDzc0WQoKioSFVVVQljhYWFqq2tTRj74Q9/qHfeecc2SFBeXq5du3ZZztmlGLT28ccfa+jQoUnj1CQAAABHOoIAAJD6XBEkGD58uB5//HEtWLBAy5cvlyRNnDhRl19+ucaPHy+pOQDwne98R3V1dbbrhMNhlZSUWM7V1tZq6dKl+uY3v+m4l+3bt1sGCZxaKwIAAKQKAgEAcGRzRZBgxIgRmjZtmgKBgDnm8/k0depUeTweGYYhj8ejGTNm6KGHHkq63+v1KhaLadSoUY7PmThxYpt76d+/v+U46QYAACCVEAwAAFhxRZBg7dq1isViZnqBx+PRli1bZBiG+Q2+YRi23Q3S09NVX1+vbdu2OT7n0Ucf1Y9+9KOEMa/Xm/CcIUOGWN5rl26wcv50hUIhx+cCAAAAANAZuCJI0JrV0X6fz6dAIGBZjyA+tnv3bsd1KyoqksZisdgB70mSxsxZLF96sF1rAAAAHEycBgAAHGyuDBJYCYVCOuuss/TUU0/ZXnPUUUcpIyNDDQ0NlvNTpkw54OeTbgAAAA42XvIBAG7jiiDB5MmTtWjRIi1evFhz586Vx+PRzJkzNXbsWPP4f0VFhZ577jnHdaqqqhQOhx3nJZl1DjqCdAMAAAAAQKpzRZBg6dKluvXWW83PHo9HCxcu1KxZs8wxn8+nCy+80PEkQWNjo/nvgUAg4bMk1dTUmGtFIhHLNWKxmLxeb9I46QYAAOBAcFoAANCZuCJIUFZWpqysLIXDYTU1NSkWi8kwDAWDQbPewLHHHiuv1+uYTlBSUiKv16toNJoUIJCk7t27S5L8fr9lkMDphAHpBgAApC5e5AEAaOaKIEF+fr4qKysVCATU1NQkScrLy1NxcbF5TVlZmXbt2mUZIMjKylJtba3y8/OVkZFhdklorU+fPpJke4ogOztbPp/Pco50AwAAAABAqnNFkKCoqMisFxBXWFiY8LIfiUS0f/9+y2/74y/9hmHI4/HYPqe4uFhHHXWUGYhorbq6Wnv27DGDCS2RbgAAQGriFAEAAJ9LTr4/DPx+v7Kzs+X3+82xUCikYDBovvTHYjGVlJRYvqzHixWOHj3askVinFVwoHVQgXQDAAAAAMCRyhUnCZzSDeInByKRiHJzc7V3717HtZxOEvTu3TtprHVQoG/fvpb32qUbAACAzofTAwAAWHNFkKA96QaxWEx/+9vfNGrUKDU0NCS83Hu9XsViMUlSenq6bc2Bnj17trmXxsZGBQKBpHG7WgUAAKDzIDgAAIAzVwQJ4ukG8e4GUnO6QU1NjSKRiJqamhQOh/X4449bphPEYjGFw2H5fD7booWSVFVVlVAM0YpVgECyL3YIAAAAAECqcEWQwCndID7m9Xp10UUX6a677rJcY/fu3eratavjc95//33t3LnT8ZpoNGp5aoCaBAAAdD6cHAAAoGNcESRwEm95WF9fr3PPPdf2utdff10zZsxQjx49VFZWZnnN8ccfr/T0dMfndbQFIgAAOHwIAgAAcHC5ortBe3g8HsvWhHGzZ89WQ0ODKioqbK+prq5WSUmJ43Oi0ajluF3XAwAAAAAAUoXrTxLE5eTkOL7gV1ZWatOmTebLfNeuXS0DBhMnTnR8jt1JAtINAABwD04QAABwaLgiSNCe7gaSNGvWLN13331J92dkZKihoUElJSVmkMAqQNClSxfl5OSYbRU7wi7dYOX86QqFQh1aCwAAAAAAN3JFkGD48OF6/PHHtWDBAi1fvlxS8zf+l19+uSZOnKhYLKaamhr97ne/s7w/XrcgFos5BgDKysrUt29fx2t27dqlo446Kmnc7voxcxbLlx5s82cEAAAdx4kBAAC+XK4IErz66quSpLPPPlvp6enyeDx6/PHHE66Jdx2wqxkgSeFwWLm5uW3WHYjFYh2eI90AAIAvD8EBAAAOD1cECWbPnq1FixYpEAhIkvx+v6688kr9/e9/N1/ag8GgvvGNbyQFD1rasmWLpkyZokceecRy/thjj1V9fb3jXvr162c5TroBAAAAACDVuSJIsGTJkoQaAk1NTXrxxRdVU1NjjuXl5SknJ8dxnU8++URFRUWWcx6PR8FgUNXV1Y5rxGIxeb3JTR9INwAA4NDi9AAAAIefK1og+v1+ZWdny+/3S2p+IQ+FQgoGP3/59vl82rFjh+X9Xbt2lSQdddRRWrt2reU1hmFo7ty5bQYaGhsbLcdJNwAA4NBYd9cMAgQAALiEK04S5Ofnq7KyUoFAQE1NTZKaTw4UFxeb1zQ0NGjSpEl6/vnnk+7v3r27KioqZBiG/H6/wuGw5XOuvvrqNvdSXl6uPn36JI2TbgAAAAAASHWuCBK0pwViJBJJCBq09Omnn7brObm5uZKa6xvY1SawSjWQSDcAAKA9OBEAAEDn5sp0A0lJ6QbZ2dm69tprLe/Pysoy/71lYKG1Tz75RJIcixf27NnTcpx0AwAA7JEyAABAanBFkCA/P19er9fsbiA1pxt4vV7zm/39+/drzZo1SfempaWZgYHRo0fbngSQmmsWtMXu/oKCgjbvBQDgSERwAACA1OH6dAOPxyOpuSbBE088kXRvJBKRJIXDYQUCAbNlopXu3bsf8B7t0g0AAEg1vPQDAHDkcsVJAqd0g7S05jiGYRgqLCy0XWP37t3mdXb+/Oc/H/AeSTcAABwJCBAAAHBkc8VJAqfuBvExr9drBgysDBgwQFJzcKH1qYS4ESNGtLmXPXv2dKi7AQAAnRlBAQAA0JIrThLE0w1aFh2MpxvU1dVJaj4hMH78eNs1ampqJDmnFGzbtq3NvdidRPD5fG3eCwBAZ0GhQQAAYMUVQYL2phvYdTeQpBdeeEGSFI1Gba8ZOXJkm3uJt0lsLV77AACAzo7gAAAAsOOKdINZs2bp29/+tp588knNmzdPknTTTTdp7NixOvPMM7Vv3z41NjZq4MCBtmu8//77mjZtmvbv3297zZAhQ9TY2Oi4l5YdFlqiJgEAoLMhGAAAADrKYxzGsv3xzgUjR47Uxo0bJX1+3P/YY4/VJ598Yl6bnp6uq6++Wg888IDlWjk5Ofrvf//r2ObwX//6l0466STHa+x+HT/96U919913J41XVlYqFArZrgcAAAAAwMFQVVWlLl26HNL3UFecJOjRo4defvll3XnnnXrttdckNRcKfPDBBzVx4kTFYjEZhqGHH37Ydo3q6mpt27ZNvXr1UklJieU1ffv2bXMvlZWV6tKlS9K4XfBgzJzF8qUH21wXAIAvCycIAADAgXJFkGDEiBGaNm1awlF/n8+nqVOnmi/nfr9fJ554ot5++23bdXbt2qWKigrb+SFDhrRZgJB0AwBAZ0VwAAAAfFGuCBIsWbIk6eX+xRdfNDsWSM3pBL169XJc59NPP3Wcb2xslNfrXKsxGLQ+FWDXAnHl/OmkGwAAAAAAUoIrggTx7gbhcFhNTU2Smrsb1NTUqL6+XlJz/YKWNQqsVFZWqn///iosLLScX7p0qU455RTHNbZu3apBgwYljZNuAABwE04NAACAQ8EVLRDz8/Pl9XoTjvrn5eUlfOsfCAR0/fXXO65jGIZ2795tO19fX6/jjjvOcY1+/fpZjpNuAABwg3V3zSBAAAAADhlXnCRoj0gkYnZAcFJbW2s71717d2VkZDjeb1eTgHQDAAAAAECqc0WQoKioSFVVVQljhYWFCS/8DQ0NysvLc1xn9OjRjvPvv/++pk+frr59+2r37t3yer2KxWLt2iPpBgCALxsnBgAAwJfNFekG8ZoEfr/fHAuFQgoGg/J4PJKav+F/5513LO9PS2tfrOPss8+WJDMlob0BAol0AwAAAABA6nPFSYL8/HxVVlYqEAiYhQvz8vJUXFyszMxM1dbWqra2VuvWrbO8PxKJ6JZbbtGUKVMUDAbNYoettZUWEA9IWCHdAAAAAACQ6lwRJHBKN4i/uBuGodGjR2vnzp2Wa0yePFnRaFQNDQ22zxk8eLDjPuxSCpzmSDcAABwqpBsAAIAvm+vTDeKpBH6/37I1YVxmZqaqq6sdX/Tt0hXag3QDAMCXiQABAAA4HFwRJHBqgRgfi0QiOuqooyRZpwXs379foVBIWVlZts8ZM2aMbSpCWwoKCg7oPgAAAAAAOotOlW6wePFi+Xw+y4KDZ555prxer6LRqO1zsrKyVF1dbTvvVJPA5/O19WMAAHBQcIoAAAAcLq44SdCedAPDMJSXl6dYLOaYUuAUJNi9e7dycnJUUFCgLl26JM07BQkikUh7fhQAAL4QAgQAAOBwckWQoD3pBl6vV/v373cMEEgyuyNY2bhxo6TmIoeVlZVJ806nBahJAAA41AgQAACAw80V6QZO4t0K6uvr9dZbb9let3jxYs2cOdNxLb/fr+rqav385z+3nPd67WMmdi0QAQA4UAQFAACA27jiJEF7eDwedevWzXb+e9/7nurq6hzX2Lp1q7Zu3Wo7Hw6HbefbOsEAAEBHECAAAABu5PqTBHE5OTnq27evysvLk17YA4GAwuGwNm3a5LhGyw4JVrp3765+/fpZzpFuAAA4GAgOAAAAN3NFkGDy5MlatGiRFi9erLlz50qSZs6cqbFjx2ro0KGSpIqKCpWVlVne39jYKEkqKSmRx+Ox/da/trZW69ats93H/v37tWPHDg0aNChpzi7dYOX86QqFQs4/IAAAAAAAnYArggSlpaUaNWqUWaTQ4/Fo9erVuuGGG8wXfq/Xq1mzZumhhx6yXaeiokKZmZmqra21nC8oKNCePXsc9/LKK69YBgnsAg9j5iyWLz3ouCYAABKnCAAAgPu5Ikiwdu1axWIx8+Xe4/Foy5YtCS/m/fv313PPPWd5v8/nUzQa1Zo1axxbFX7lK19RRUWF416+/e1vW46TbgAA+CIIEAAAgM7AFUGC1qy+tff7/YpGo5bXx8dLSkr0ox/9SPfcc0/SNR6PRz6fT+Fw2BzLyMgwuye0HLNCugEAAAAAINW5IkhQVFSkqqoq87NhGCosLExKGzjvvPP05JNP2q4Ti8V02mmnyev1KhaLJcwZhpGUatA6QCBJO3fu1ODBg5PGSTcAAHQEJwcAAEBn5IoWiH6/X9nZ2fL7/eZYKBRSMPj5y3csFrN8eW9pyJAh+u1vf5sUIIgLh8PKzc11XCM/P99ynHQDAAAAAECqc8VJgvz8fFVWVioQCKipqUmSlJeXp+LiYvOahoYGzZs3T7fddpvjWhs2bLCdS09PN4sj2vH5fJbjpBsAAAAAAFKdK4IErVsgejweswXikCFDJDV3QMjOznZc59VXX02oOdDaa6+9prPPPttxDbsgAukGAID2IM0AAAB0Zq5IN4i3QHzggQfMsdWrV+uUU05Renq6pOaX9EmTJjmuM3nyZH3ve9+znZ89e7ZWr17tuIZdcUTSDQAATtbdNYMAAQAA6PRcESRo3QJRktkCMd7SMBQKyet13u6kSZP01ltvWc55PB6VlZW1WZPAqpih1JxuAAAAAABAKnNFkCDe3SAeJGjZ3SD+zb7P51NlZaXjOiUlJfrkk08s5+K1Blp3TGjNLl3BLt0AAAAAAIBU4YoggVN3A4/HI6m5u8GHH37ouE5TU5Pq6+st5+InEkpKShzX6N69u+U46QYAADukGQAAgFThiiBBfn6+vF5vQtHAvLw8eb1eM0gQCATa7ExglyrQ0tatWx3n7WoSkG4AAAAAAEh1ruhu4CQWi0lqLm5o154wLhhsu8vAiSeeqPT0dNu0glgsZvmctp4NAAAAAEBn5/ogQZzX69XYsWP1/PPPJ4zFgwhSc7pBW4LBoGObRLvaA/F0BQAASC8AAACpyvVBAp/Pp2g0qkAgoFWrViXMtQwQSFL//v2VkZFhm3awatUqHXvssY7Ps0tpoCYBAAAAACDVuT5I0FLPnj1VVlZmO3/HHXc4niZYs2ZNm10KPvroIx1//PFJ4wUFBUlBCklaOX+6QqGQ45oAAAAAAHQGnSpIsHfvXsf5nJwc9e3bVzt27LCc//nPf67t27crEAiosbHR8pq3337bMkhgF1wYM2exfOlt10IAAHRepBcAAIAjhSu6G7RHRkaGFixYoBNOOEEej0fZ2dlJ11x88cXat2+f7Rq1tbXasmWLYxHCiooKy3HSDQAAAAAAqa5TnSTo3bu3CgsLZRiGampqLK9pqwtBSUmJvN7m2EhmZqbq6uoS5gcNGmR5H+kGAAAAAIBU54ogQVFRkaqqqhLGCgsLVVtbmzD25z//WSeccILWr1+vaDRquVbrl/7WYrGYWdjQ6tr+/ftb3ke6AQAcWUgxAAAARyJXpBsMHz5cy5Yt07nnnmuOTZw4UcuWLVMw2PwCXl5ern/84x965513LAMEQ4YM0ZQpU9osTCjJNsAgScOGDbMcJ90AAAAAAJDqXHGSYMSIEZo2bVpC+0Gfz6epU6eabQ49Ho8uvfRSPfnkk0n3p6Wl6bPPPmvzFEF7FBcXa8CAAUnjpBsAAAAAAFKdK4IES5YsSSoY+OKLLybUHcjJydELL7xgeX8kElEkEtGmTZvk9XrNwIIdj8dje+Jgz549lkEC0g0A4MhBqgEAADhSuSJI4Pf7lZ2drXA4rKamJklSKBRSTU2NGhoaZBiGPB5PmycFSkpK5Pf7FQ6HLec/+ugjDRo0yDElIV7UsDXSDQAAAAAAqc4VNQny8/Pl9XoT0g3y8vLk9Xrl8XgkNZ8WuOyyyxzXaesEgSSVlpY6zg8cONByvKCgoM21AQCd27q7ZnCKAAAAHNFccZLASfzFv7q6Wn/961/bvN6pKGHv3r1VX19vfrZKO+jZs6flve0piAgA6JwIDAAAADRzfZAgzuPxqFu3bo4nAcLhsLKyslRZWWk5n5WVlXDawOrFv6mpSX6/P2mcdAMASD0EBwAAABK5It2gPbp3766HH37YTD+wsm3bNssX/LhPP/1U//3vfx2f8+6771qOk24AAKmFAAEAAEAyV5wkKCoqUlVVVcJYYWGhamtrzc8NDQ2aP3++evbsqbKyMsu0gmHDhjmeNOjfv7/tKYO4SCRiOe7z+RzvAwB0DgQHAAAA7LkiSNCe7gaGYai0tFQlJSW267RVuDAYDOqkk05yvOb000+3HLcLHgAAOgeCAwAAAG1zRbpBe7ob+Hw+XXPNNV/oOTU1NWZ7RI/Hk5S64PF4lJGRYXkvNQkAAAAAAKnOFScJ2pNuEIvFtGnTJgUCATU2NiZc27JLQXp6uhkIaO2///2vQqGQpOaihT6fLyFtwamDQUFBgVatWpU0vnL+dHNNAAAAAAA6M1cECdqbbrBmzZqkAIGU+HLvlBawf/9+9e3b1/zs1C7R6RktjZmzWL70YLvXAQB8uUgzAAAAaD9XpBvMmjVL69ev1y233GKO3XTTTdq4caNyc3MlNacK7Ny503aNe++9V1OmTFFamn3cIy0tzVzPTjxI0RrpBgAAAACAVOcxnM7YH+qH/19NgJEjR2rjxo2SPv/G/thjj9Unn3xiXpuenq7s7GyVlZVZrhUMBlVaWqoBAwZo3759ltesXr1a+fn5OvrooyVJXq83qdjhRx99pGHDhiXd+9Of/lR333130nhlZSXpBgAAAACAQ66qqkpdunQ5pO+hrkg3KCsrU1ZWVkK6gWEYCgaDZrpBMBjUX/7yF1144YWWaQL19fXatGmT40mCWCymdevWJXxuraSkxDJIQLoBAHQupBkAAAB0nOvTDeIv/eFwWFOmTHGsI1BSUqLS0lLb+bS0NI0bN84xkNCjRw/LcdINAAAAAACpzhUnCUpLSzVq1CizBaLH49Hq1at1ww03mIUIPR6PzjzzTK1YscJ2nfr6esvTAXHHH3+8cnJyHIsb2gUh6G4AAAAAAEh1rggSLFmyRBUVFeZnwzD04osvqqamxhwLhUKqrKy0vH/gwIH69NNPtW3bNseTBuvWrdPYsWMd91JXV2c5TroBALgfKQYAAABfjCvSDeItEP1+vzkWCoUUDH7+8t2lSxft3r3b8v5PP/1UUnMRwXgxRCvvv/++ZQvFlrxe618J6QYAAAAAgFTnipME+fn5qqysVCAQMAsX5uXlqbi42LymoaFBAwYMSBiLy8jIMAscejwe22/9165dq29+85uOexk4cKDlOOkGAAAAAIBU54ogQVFRkaqqqhLGCgsLVVtba36uqanRpk2bLO9vaGiQJJ122mmOzxkwYECbe+nZs6flOOkGAOBOpBgAAAAcPK5PN4inDwQCAdsgQVxDQ4Nj4cKuXbsqNzfXcY34SYbWSDcAAPchQAAAAHBwuSJI4NQC0efzSZIqKiraPCkQDAaVlZVlO3/++eebHRTs2LVQLCgocLwPAPDlIkAAAABw8LkiSLB06VINHTpUt912mzm2cOFCDRkyxGxXGIvF9OCDD9qu0aNHD51//vkJKQqtbdiwQTt27DigPcaDFQCAw48AAQAAwKHhiiBBjx499PLLL+vcc881xwoKCrRs2TKz24BhGJoxw/5/FJaVlWn16tWOz3nppZe0bt06x2u6detmOR4PVgAADi8CBAAAAIeOK4IEI0aM0LRp0/T++++bYz6fT1OnTjULBvr9fv3v//6v4zq7du1ynPf5fBo3bpxtm0OPx6OMjAzLOWoSAMDhR4AAAADg0HJFkGDJkiWqqKhQSUmJOfbiiy+qpqbGDBLk5OTo6aefdlynpKRE+fn5tvMXX3yxcnJybLsc2HUwkKhJAACH07q7ZhAgAAAA+BK4Ikjg1N0gzuPxaN++fY7rVFVVae/evbbz48ePl6Q217HiFEAAAAAAACAVuCJIkJ+fL6/Xm9B5IC8vLyEtIBAIaNCgQY7rGIahaDRqOz9nzhzt2LFD1dXVHd4j6QYAAAAAgFSXdrg3IElFRUWqqqpKGCssLEzoVBCJRBQOh9tcy+fzKRaLWc6NGjWqzcKFNTU1ys7OThovKCjQqlWrksZXzp+uUCjU5r4AAAAAAHA7VwQJ4ukG4XBYTU1NkprTDWpqatTQ0CDDMFRfX6/09HTHdUaPHi2Px2M7X11drbPPPttxjeLiYh177LFJ43bpBmPmLJYvPWg5BwD4YqhDAAAA8OVyfbpB/KXf5/Np+PDhkuQYCOjdu7fjc/bs2eO4F7tABOkGAPDlIkAAAADw5XPFSQInWVlZqq6uVkNDg9me0Opb/X/+85+64IIL9D//8z+2a51xxhnavHmz4/P69etnOU66AQAAAAAg1bk+SFBXVydJamho0F//+lfb63bs2KFoNOrYuaBbt2465phjDmgfpBsAwJeDEwQAAACHjyvSDdojLS1N69evt52fM2eO9u7d69iq8KWXXlKfPn0cnxOvidAa6QYAcGitu2sGAQIAAIDDzPUnCeIyMzP1pz/9yXa+rKxM27Ztc1xjxIgRkqScnBzbNoilpaWWgQTSDQAAAAAAqc4VQYL2tECUmk8COCktLXWcz83NlSR5vfYHKOzmSDcAgEOHEwQAAADu4Ip0g3gLRL/fb46FQiEFg0Gzk0EgENCpp57quE4sFlNamn3cw+v1qr6+XpWVlbbX9OzZ03KcdAMAAAAAQKpzRZCgPS0QI5GIPvvsszbXindAsLJt2zZFIhHH++1OEhQUFLT5bABAx3GKAAAAwD1ckW7gJBaLSZKqq6u1fPnyNq/3+Xy2c9u3b9fQoUMPaB9OBREBAB1HcAAAAMB9XHGSoD08Ho+6devmeE04HE6qY9BS//791djY6LiG3TzpBgAAAACAVOf6IEH8ZEBmZqbeeecdBYP2RQL79++vo446yna+X79+bRY3bJny0BLpBgBwcNDqEAAAwL1cHyRo6bXXXlN9fb3t/B133KEdO3bYzj/xxBOO68frH1hxSmMAALQPwQEAAAB361RBgrfeestxPicnJ6FDQms33XSTMjMzbed79+5tO9dWwUMAAAAAADq7ThMkyMjIaLMuwMUXX6zc3Fzb+f379+uNN96wnXc6SUBNAgD4YjhFAAAA4H6u6G5QVFSkqqqqhLHCwsKkIoTt+TZ///79jvNr1qyxndu9e7ei0ahlakFBQYFWrVqVNL5y/nSFQqE29wUAAAAAgNu5Ikjg9/uVnZ2tcDispqYmSVIoFFJNTY0aGhpkGIZisZh69uypoqIix7Xaqh1wwgknyOv1mq0VW7v99tt12223JY3btUAcM2exfOn2xRQBAJwiAAAA6CxckW6Qn58vr9eb0FkgLy9PXq/XrCEQiUTUr18/2zWmTJmiKVOmtPmsYDBo20rR7/frhz/8oeUc6QYAAAAAgFTnipMETukG8ToBsVhMI0aM0NKlSy3X6Natm6LRqGpqatp8Xp8+fVRWVqY+ffpoz5495nggEFCvXr0s7yHdAAAAAACQ6lwRJHBKN4hEImpqapJhGLr22mstUwEkqbGxUdXV1W0+q76+Xh9++KEkJQQIJKm2tlZ79uxRnz59ku4j3QAAOo40AwAAgM7F9ekG8bFIJKJ///vftmvMnz9foVDIsQXihg0bNGzYMNsXfkm2NQ9INwCAjiFAAAAA0Pm44iSBE6+3OY5hGIbuu+8+22v69u0rr9eraDRqu5ZhGBo2bJjtvM/n02mnnWY5R7oBAAAAACDVuSJIMHnyZC1atEiLFy/W3LlzJUkzZ87U2LFjNXz4cEnNqQDvvPOO5f2xWExnnHGG1q9fL7/fr3A4bHldcXGxTj75ZNt95OXlJZxmaIl0AwBoH04QAAAAdF6uSDcoLS3VqFGj9MADD0iSPB6PVq9erVNOOUWRSERS87f8Q4cOtV3jvffeU2lpqW1rQ0k66aSTHPcRr4dghXQDAAAAAECqc8VJgrVr1yoWi6m2ttYc27JliwzDML/B79Gjh0499VR9/PHHlmsYhqHnnnvOTE+w0q1bN9XX19vOV1RU2M6RbgAAAAAASHWuCBK0boFoGIbZAjHO5/Pp6quv1pNPPum4jtNJgp07d6p37962804nCUg3AAB7pBgAAACkBlekG8RbILbsTBAKhRQMfv7ynZ2dreLiYsd1YrGY40mC/Px85eTkOHZAsEO6AQBYI0AAAACQOlwRJJg1a5bWr1+vW265xRy76aabtHHjRvPz7t27dcUVVziuE4vFbIsWSlJ5ebkkKS3N/gCF3WmCgoICx2cDAAAAANDZuSJIEC9c+OCDD0pqTi2IFy6MC4fDju0NJSWkJ1h54YUXJEldu3a1vcbulIHP53NcGwCORJwiAAAASC2uCBLk5uZq7dq1uvbaa82xr3zlK1q/fr352ePxONYbkKSysjLH+Z49e0qSzj333A7vMd5lAQAAAACAVOWKIEH8JMH9999vjrU+SZCenq6xY8c6rjNixAjH+T59+kiSNm3aZHuNXYFCahIAQCJOEQAAAKQeV3Q3aN0C0TAMswVinMfj0Ztvvum4zpYtWxzn4+u///77ttesWbNGZ5xxRtI4LRABAAAAAKnOFUGC1qy+zQ8EAnr44Yd19dVX295XWVnpuO6f/vQnnXPOOY7XFBUVWQYJaIEIAJ/jFAEAAEBqckW6weTJk/Xuu+/qxhtvlNRcJHDmzJnasGGDeY3f79dPfvITy/sDgYCktoMEdXV1qq6udrxmz549luOkGwAAAAAAUp0rThIsXbpUt956q/k5GAxq4cKFmjVrljkWCAQ0ZswYPfXUU0n3n3HGGVq5cqVqa2sVDAZVX19v+ZyLL75YHo/HcS9TpkyxHCfdAAAAAACQ6lwRJCgrK1NWVpbC4bCamppUXV2tXr16Jbzwd+/e3baWwMqVKyXJXMPON77xDRUWFjruxa7NIukGAI5kpBcAAAAcGVyRbpCfny+v12umDUhSXl6evN7PtxeNRvXII484rtOjRw/zZb5Hjx5J816vV4MHD7a93+fzqX///pZzpBsAOFIRIAAAADhyuOIkQXuUlpbqsccec7xm8ODBZpCgrKwsaT4cDmvnzp2290ejUb311ls699xzk+ZINwAAAAAApDpXBAmKiopUVVWVMFZYWGi2LIxbsmTJF3pOenq6Y5tEr9er0047zXKOdAMARyJOEQAAABxZXJFu4Pf7lZ2dLb/fb46FQiEFg0Gz0GAsFlNOTo7jOqNHj3ac37Nnj4YNG6ZQKKT09PSk+Xfffdf2VADpBgCONAQIAAAAjjyuOEmQn5+vyspKBQIBNTU1SWquSVBcXCyPxyPDMBSJRDRjxgzdc889jmv5fD7b4oM+n08ff/xx0qmFuFNOOUWRSEQ+ny9pjnQDAAAAAECqc0WQwEn8JEFFRYV+97vf2V736KOPasqUKbYBAklqamrSqFGjbOe9Xq9lgEAi3QDAkYMTBAAAAEcuV6QbtEdaWpp+/OMfKy3NOq5xww03qK6uznGNZ599ViUlJbbzsVhMW7dutZwj3QDAkYAAAQAAwJHNFUGCyZMn691339WNN95ojs2cOVMbNmww2yAahqE777xTkUjEco3y8nJt2rTJ9iSAJI0fP15ZWVnyeDzmCYWWPB6P+vXrZ3lvQUFBR34kAAAAAAA6HVcECZYuXaqhQ4dq3rx55tjChQs1ZMgQs0aB1+tVnz59HNfZsWOHMjIybOdzcnL04YcfyjAMy/QBwzBsgwxOwQcAAAAAAFKBK4IEZWVlysrKSkglMAxDweDnuf45OTn62te+5rjOp59+6liT4Omnn9a4ceP0yCOPdHiPdicYAAAAAABIFa4oXOjU3SAuIyNDI0eOdFynsrJSDQ0NtvNpaWnKycnRihUrbK+JxWKWpwaoSQAglVGLAAAAAJJLggRFRUVJbQkLCwtVW1trfo5EInr22WeVlpZm+62+XQeCuAsuuECS9Pe//91yPhgMyu/3W87ZtUAEgM6M4AAAAABackW6gd/vV3Z2dsILeigUSkg3iMViWrlyZZvH/j0ej1nssLVBgwZJknlaobXGxkbbddsKQAAAAAAA0Nm5IkiQn58vr9erQCBgjuXl5cnr9Zov/JFIpM0X9dGjR8swDMViMcv5HTt2OAYCnOoZkG4AAAAAAEh1nSbdIBaLadiwYdqwYUPS/enp6QqHw5KauyDYBQm8Xq9KS0sPaI926QYr509XKBQ6oDUBAAAAAHATVwQJ4ukG4XDYTAUIhUKqqalRJBJRU1OTwuGwdu3aZXl/OBzW9ddfrylTptgGCCSpT58+2rlz5wHt0e4Uw5g5i+VLD1rOAYBbUYsAAAAAVlyfbhAf83q9ZuFBK+ecc06bz9m/f7+6du16QHsk3QBAKlh31wwCBAAAALDlipMETuI1CQzD0GuvvWZ73TPPPKMLL7xQfr/ftjBhTU2NBg8efED7IN0AAAAAAJDqXBEkcKpJ4PF4zLFRo0Zp+/btlmvcfvvtkuQYJCguLlb//v0PaI+kGwDozDg9AAAAgPZwRbqBUwvEtLQ085qioiLbNfr16yfJuUNBv379DrhwIekGAAAAAIBU54qTBPn5+aqsrFQgEDBPAeTl5am4uNgci0Qi2rFjh+0ac+fO1W233aaePXvaFic8+uijVVxc7LiXxsbGhNoIcaQbAAAAAABSnSuCBE4aGhokSfX19aqpqbG9btCgQZKkyspK22vC4bByc3Mdn2cVIJBINwDQeZFqAAAAgPZyRbpBe6SlpWn69Om289dff73q6upUW1vruI5dEKAtpBsAAAAAAFJdpwkSZGZm6uyzz5bU3PHguOOOSyhquH//fm3atEmxWMx2jWAwqMbGxgN6fkFBwQHdBwCHE6cIAAAA0BGuSDdw6m7Q0vLlyyVJsVhM//3vf5PWKSkpcXzO3r17HQsbOrFLNwAANyI4AAAAgAPhipMEw4cP17Jly3TuueeaYxMnTtSyZcvk9TZvsaamRs8884zjOk6nCCRp2bJljvPZ2dm2c6QbAAAAAABSnSuCBCNGjNC0adP0wQcfmGM+n09Tp041v8FPS0vTvHnzku5tmXIQDocTPrc2bNgwx8KFToURSTcA0FlwigAAAAAHyhVBgrVr1yoWi5npBR6PR1u2bJFhGGaQwDAM3XrrrUn3tkwD2LZtmzIyMmyf06VLlzYLF4bDYctxn8/X5s8BAIcbAQIAAAB8Ea4IErRmlf/v8/l0wQUXON5XWlqqo48+2na+R48ebT47Lc26TEMkEmnzXgAAAAAAOjNXBgmshEIhBYNBx2tyc3MdWyD+61//avM5dicGqEkAAAAAAEh1naq7QSQSUVpamu23+pWVldqzZ4/tc95//31JUkZGhhoaGpLmPR6PDMOwrGtQUFCgVatWJY2vnD9doVDI9pkAAAAAAHQWrggSDB8+XI8//rgWLFhgtjmcOHGiLr/8co0fP16SVF5erueff97x2H9bbQrjpwSsAgTx+9esWaMzzjij3WuPmbNYvnTnEw4A8GWgHgEAAAC+KFekG7TubuDxeMzuBnGBQEDnn3++ZeHB+Df/TU1NOu+882yf06tXrzb3YtdGkXQDAAAAAECqc8VJgiVLlqiiosL8bBiGXnzxxYSWhBkZGerXr58aGxuT7s/IyFB9fb169uypjRs32j7n9NNPb3MvJ598suU46QYAAAAAgFTniiCB3+9Xdna2wuGwmpqaJDUXKqypqVF9fb2k5tMC55xzjn7/+98n3R+/prKyUtXV1bbPaU93A7viiKQbAHAzUg0AAABwMLgi3WDWrFlav369brnlFnPspptu0saNG82WhBUVFbrssssc1xk1apTC4bDtfOviiB1BugEAt1l31wzzHwAAAOBgcMVJgtLSUo0aNcqsN+DxeLR69WrdcMMNikaj5livXr20a9cu23XC4bB5vRW/39/mXhobGy3rHpBuAAAAAABIda4IErSnJkEoFNL48eP16KOP2q6zbds2eb1e20DBgAEDDniPpBsAcBNODwAAAOBQcEW6QbwmQctv+kOhUEJ9gC5duqigoCDhvqysrITPlZWVjqcFunXr1uZerE4RSKQbAAAAAABSnytOEsyaNUvf/va39eSTT2revHmSmmsSjB07Vscff7wikYi2b9+u2bNnJ9xXW1ub8HnUqFHq0aOHY0qCU2FDJ6QbAAAAAABSnSuCBHPmzDH/77x58+T1enXNNddIkiKRiCSpoaHB9sh/XF1dnfbs2WM7X19fr61btzqusXXrVg0aNChpnHQDAG5AmgEAAAAOpcOebuDxeDR79mx169ZNffv2lSRlZmbqyiuvVE5OjnldRkaGunbt6rjWe++9p1gsZjv/6KOP6rjjjpPH45HP55PH40m6pnv37pb3km4AAAAAAEh1hz1IYBiG1q5dq1gsZqYPhMNhbdmyJeHb+xEjRujdd9/Vz372M3Ms/pIfH3v//ffNlolWxo8fr4yMDLO4odXpALuaBq3rIQAAAAAAkGpckW4wefJkLVq0SIsXL9bcuXMVjUY1c+ZMjR07VkOGDJEkbdq0Sccee2zCffGX/F/96leSpOzsbA0ZMkQfffSR5XN69+6taDRq2/3A4/EoOzvbcs7n8x3QzwYAXxQpBgAAAPiyHPaTBB6PR3PmzNHgwYN1yy23SGruMHDNNddo8ODB5nXRaFRer/N26+rqdNFFF9nOL1++3LFwoWEYWr58ueVcvDYCAAAAAACp6rAHCdLT05NqEhxzzDFJNQmGDBnSZgvDXbt26amnnrKdD4VCCoVCtqcCevXqpdGjR1vOUZMAwOHAKQIAAAB8mQ57kKChoUFLlixRRUWFSkpKJEmlpaV68cUXVVNTY143adIkPfbYY5ZrPPfcc5Kk/fv3a9++fbbPOuuss2QYhgKBgOV8SUmJ7WkFahIA+DKtu2sGAQIAAAB86TocJDAMQ++++67+/ve/a+nSpVq/fn2brQnb4vf7lZ2dbRYNLC0tVSgUUjD4eWvB7du3m0GE1h566CFJUjAYVF1dne1zbr75ZlVXV6u+vt72mqefftpy/Iv+jAAAAAAAuF2HggQrVqzQoEGDNHr0aE2bNk0XX3yxTj/9dA0ePFgrV6484E3k5+fL6/Wa3/AbhqG8vLyEb/W3bNmi7373u8rMzEy6/+WXX5bU3AHBqQVifn6+QqGQ417Ky8stx0k3APBl4QQBAAAADpd2dzf45JNP9LWvfU2jR4/Wb37zGx133HEyDEMfffSRfvvb32ry5MnatGmTBg4c2OFNFBUVqaqqKmGssLDQbIkoSU1NTZKkbt26OZ4WcBKJRBLWbK13796aMcP6f5wXFBRo1apVSeMr509vM/AAAAAAAEBn0O4gwb333qszzjhDr732WsL4cccdp2984xs677zz9Jvf/Eb3339/hzcRTzcIh8NmMCAUCqmmpsZMDYhGoyorK9OAAQO0a9euDj9Dko4//nht2rTJdr64uFj79++3LJBol24wZs5i+dKDlnMAcCA4SQAAAIDDpd3pBq+//rpmz55tOefxeDR79mytWLHigDYxa9YsrV+/3myBKEk33XSTNm7cqLS05jjG9u3b1a9fP8tv8+Muv/xyx+f06tXLXM9OY2Oj5TjpBgAAAACAVNfukwTbt2/XCSecYDs/YsQIffbZZwe0idLSUo0aNSqh68Dq1at1ww03yOfzKRKJKBaLKS8vT9u3b7dco0ePHho3bpz52ePxJH37n5GRoWHDhjnuZdCgQZbjpBsAAAAAAFJdu4MENTU1lkUD4zIzMw+4VsDatWsVi8US6gVs2bJFhmEoHA6bYzt27LBdo6ysLOHbfqv0gC1btrQZJLBDugGAQ400AwAAABxu7Q4SSNJHH32k4uJiy7nS0tKDsiE7gUBAv/vd73TNNdfYXrN//375/X41NTXJ6/UmdToYM2ZMu55jhXQDAAAAAECq61CQYNy4cZbfqMeP9ns8noO2sdZCoZC2bNliORcPDGzbtk3BYFBNTU2WrRALCws1atQoywBCW0g3AAAAAACkunYHCYqKig7ZJtrTAlGSfvazn+mJJ57Q7t27E8bjHREqKyt1xhlnaNmyZZbP2bdvn6LRqGOAIBaLyetNrudIugGAQ4U0AwAAALhFu4ME/fv3P2SbaE8LxOzsbGVmZiYFCFoyDMMxANC9e3dVVFQ47uW1117T+eefnzROugGAQ4EAAQAAANyk3UGCTZs2teu6E088scObyM/PV2VlpQKBgBkkyMvLS6h/0NDQoKlTp7a5llOLxGOPPbbNlIjq6mrLcbt0AwAAAAAAUkW7gwQjR460bCvYksfjUTQa7fAm2pNuUFNTozfffNNxndGjR5snD6y88847mjhxouMadsUNnX5uAAAAAABSgStqEjilGzQ0NMgwDBmGoUGDBum9995Lut/n87UrOPHYY49p8uTJjtfk5uZajpNuAAAAAABIda6oSeCUbpCZmana2lpFIhGdfvrplkGCaDSq++67T1OmTFFaWpoikYjlc771rW9JktLT0xUOhxO6MrR1UoB0AwAHG/UIAAAA4DbJZfwPg3i6Qcv0gni6QV1dnaTm4/7xl//Zs2cndSAoLy9XNBo1X/YzMjKSnnPeeedJag5AxNds+X+d+Hy+jv5YAGCLAAEAAADcyBVBgni6gd/vN8dCoZCCwaDS0poPOxiGofz8fEnSvffem9TFIBgMqrq62kw7aGhoSHrOv//9b0nSrl27LPdh1fowzu50AgAAAAAAqcIVQYL8/Hx5vV4FAgFzLC8vL2HM6/VavvjHXX/99QqFQpYnCOJ69+6t+vp62/oFTu0TqUkAAAAAAEh17a5JcCg5dTeItyw0DENnnXWW7rrrrqT7fT6fDMOQ1+t1/Mbf5/Md8IkAu5oEK+dPVygUOqA1AQAAAABwkwMKEkQiEb3++uvaunWrLr30UuXk5Gj37t0KhULKzs7u8HpO3Q0ikYiamprMDgdWotGo1q5dq69+9auOQYC0tDTl5OR0eH+Sfd2CMXMWy5cePKA1ARy5qEkAAAAAN+pwkOCzzz7TxIkTtX37doXDYZ1//vnKycnRnXfeqXA4rN///vcd3oRTd4P4mNfr1RNPPOG4TlttELt169bhvcWRbgAAAAAASHUdDhJcd911Ou2007Rx40b16NHDHP/GN76ha6655qBuTvq8mKBhGPrXv/5le92///1vjRgxwnGt995774BTA0g3AAAAAACkug4HCd58802tXr06ocigJA0YMMC2a0Bb2lOTQJIuvfRSPfLII5ZrTJ48WVlZWfJ4PLapARdeeKFee+01x71s3bpVgwYNShon3QDAwUCaAQAAANysw90NYrGY5bH+nTt3HnC+f3taIPr9fm3evNl2jVNPPVVVVVW2L/OS9M477+i4445z3Eu/fv0sx0k3AAAAAACkug6fJBg/frzuvfde8xt9j8ejmpoazZ07V5MnTz6gTbSnJkEkEtG+ffvMZ1oFA1qeOrBSUVGhgQMHOl7T+oREHOkGAAAAAIBU1+EgwT333KMJEybo+OOPV0NDgy699FIVFhYqNzdXixcvPqBNtLcF4vbt281/b+2OO+7Q3LlzHZ9z+umny+fzHdAeSTcA8EWQZgAAAIDOoMNBgvz8fG3cuFFPPfWUNm3apJqaGl111VX6zne+o2DwwF6W29MC0e/365JLLtFjjz1mXtPShRdeaBY5tJObm+sYJHCaI90AAAAAAJDqOhwkkKS0tDRddtllB20T7U03mDp1qp599llVVVWpsbExYY1YLGbuLRKJWD6nrSCGUwtFu3QDAAAAAABSRbuCBM8//7wmTZokv9+v559/3vHar3/96x3eRHvTDV577TUFAgHLEwO9evWS1HZdAsk5kGDHqSAiAAAAAACpoF1BgilTpqi4uFi9evXSlClTbK/zeDyO38bbGT58uB5//HEtWLBAy5cvlyRNnDhRl19+uS666CLV19eroaFB9913n2Wqgcfj0ebNmzVgwAAFg0HLa6Tm9o1nnXWW414aGxstixeSbgAAAAAASHXtaoEYi8XMb+pjsZjtPwcSIJCkESNGaNq0afrggw/MMZ/Pp6lTp5ppBF6vV3PmzLFd4/LLL1ddXZ1qampsr9m1a5ckOZ4icOpuAAAHgqKFAAAA6CzaFSRoaceOHQd9E2vXrlUsFlNtba05tmXLFhmGoXA4bI7dfvvtlvcbhqGysjJt2rTJDCpYGTp0qCQpKyvL9hq7tIID7YoA4MhGgAAAAACdSYeDBAMGDNDZZ5+tP/zhDyovLz8Ue7Lk9XqVnZ3teM2OHTvk9/tt5zdv3ixJCYGH1uLpDq11tIYBAAAAAACdTYeDBO+++65GjRql22+/XX369NGUKVP097//3fHF+2Do3r27JkyY4HjNp59+6hgkiJ+CcHrhb5ny0BI1CQB0xLq7ZnCKAAAAAJ1Oh1sgnnzyyTr55JO1cOFCvf7663ryySc1a9YsxWIxTZ06VX/+8587vAmn7gYt7d2713Gd8vLypNaILcWDAx6PxzatoG/fvpbjdi0QV86frlAo5LgvAAAAAAA6gw4HCeI8Ho/OOeccnXPOOfr+97+vq666SosWLTqgIIHf71d2drbC4bDZmSAUCqmmpkb19fWSmgsmbt261XGdcDjseEpg37592rFjh2M7w7Fjx1qO290zZs5i+dKDjvsCcOTg9AAAAAA6sw6nG8Tt3LlTCxcu1MiRIzVq1ChlZ2frgQceOKC18vPz5fV6EzoL5OXlyev9fHuBQEDz5s0zP2dkZCStk56ebtudQJLGjBmjdevWOe6le/fuluOkGwAAAAAAUl2HTxI8/PDDevLJJ7Vq1Sodd9xx+s53vqN//OMf6t+//wFvoj3pBjU1NRo4cKD5uaGhIWmdM844Qx6Px/Y5/fr103HHHee4F7suBqQbAAAAAABSXYeDBPPnz9f06dP129/+VieddNJB2YRTukFDQ4MMw5BhGKqpqWlzLadUAp/Pp5ycnAPaI+kGAJyQZgAAAIBU0OEgwfbt2x2/rT8Q+fn5qqysVCAQMIMEeXl5Ki4uVmZmpmpraxWJRPTmm2/K6/UqFoslrbF792716dPHci5uyJAhqq6utp3v2rWr7RzpBgDsECAAAABAquhwkMDj8aiiokJ/+tOftHnzZknS8ccfr6uuukpdunQ56BuM1yUwDEM9evSwDQJUV1erV69e5nxWVlZSd4RPPvlExcXFts+qqKjQ1q1bNWjQoKQ50g0AAAAAAKmuw0GCd999VxMmTFAwGNSoUaMkSb/5zW90xx13aNmyZTrllFM6vAmnmgQtTy388Y9/tF3DMAxVV1ebQYLWAQJJWrt2reNpAUnq3bu37fpWSDcAjlycIAAAAECq6XB3g+uvv15f//rXtW3bNj3zzDN65plnVFRUpK997WuaPXv2AW0iXpPA7/ebY6FQSMFgUGlpaeY1dXV1tms8+eSTCoVCOv30022vmT59uiZNmuS4F7vuCKQbAAAAAABS3QGdJPjDH/5gvrxLUlpamm688UaddtppB7QJp5oE8bFIJOLY3vCaa66R1+tNaJvYktfrVU5Ojnbs2OG4F7v7STcAAAAAAKS6DgcJQqGQtm/fntRKcMeOHQfcOcBJvNVhfX29tm3bZnvdD3/4Q/3jH//QBx98YDkfT0NYt27dAe2DdAMALZFqAAAAgFTU4XSDb3/727rqqqu0ZMkS7dixQzt27NBTTz2lq6++WtOnTz8Ue5TUfFphwIABtvMvv/yy6urqHFMSPvvsM40bN872tIDP55PP57OcI90AQBwBAgAAAKSqDp8kuPvuu+XxeDRjxgxFIhFJzfUCvv/972vBggUHfYNxmZmZevXVV3XsscdazofDYW3atMn2G39JeuGFF/SjH/3ItkNCNBq1vdcu3QAAAAAAgFTR4ZMEgUBA9913n8rLy/Xee+/pvffe0/79+/Wb3/xG6enpB7SJyZMn691339WNN95ojs2cOVMbNmwwX+grKipsAwRxJSUlCd0QWot3LnC6xo7dCQMARxZOEQAAACCVdThIEJeZmakTTjhBJ5xwgjIzM7/QJkpLSzVq1Cg98MADkppf4levXq1TTjnFPBng9Xrb7J5QUVFhm0ogSZs3bzbXslNfX285Hj81AQAAAABAqmp3usF3v/vddl335z//ucObWLt2rWKxmGprayU1Bwm2bNmSkDrQv39/x1QCSXr77bfNa3r06KFAIKA9e/aY8/GODHbpBpK0c+dODR48OGmcmgQAAAAAgFTX7iDBY489pv79++vkk09u82W9o4qKilRVVWV+jsViKiwsNIMGUnPdg549e6pbt24qLy+3XGf37t1mAKCsrCxpPt6q0Gn/+fn5luPUJABAqgEAAABSXbuDBN///ve1ePFiFRUV6corr9Rll12m7t27H5RNDB8+XI8//rgWLFig5cuXS5ImTpyoyy+/XOPHj5ckFRcXa8GCBQmBg9Z8Pp+CwaBtysCUKVPa3EtFRYWCweSWhgc7MAKgcyFAAAAAgCNBu2sSPPDAA9qzZ49uvPFGvfDCC+rXr5+mTZuml19++Qu/QI8YMULTpk3TBx98IKk53cDn82nq1KnmNYZh6Ne//rVjccSBAweqa9eutvNHHXVUm3ux+1lINwAAAAAApLoOtUBMT0/X9OnTNX36dH322Wd67LHH9IMf/ECRSEQffvihsrOzD2gTS5YsUUVFRcLYiy++qJqaGvNzbm6uevbsadYVaCkzM1N1dXUqKSmxTDOIa2pqkt/vd9xLbm6u5bhdusHK+dPNNAYAAAAAADqzDgUJWvJ6vfJ4PDIMQ9Fo9Attwu/3Kzs7W+FwWE1NTTIMQ6FQSDU1NWbqgM/nU1VVVULgIC47O1t1dXWqq6tzPNXw3HPP6eKLL1Z6errC4bDlNWVlZerTp0/SuN26Y+Ysli89OT0BQGogzQAAAABHkg61QAyHw1q8eLHOP/98DRkyRO+//75+97vfafv27Qd8ikBqLhbo9XoVCATMsby8PHm9XrNd4f79+207JzQ1NUmSpk+fbv67lUWLFklyboFIugEAAAAA4EjV7pMEP/jBD/TUU0+pX79++u53v6vFixfbHs0/mDwej6Tmjgdr1qyxvCbe7aChocFxrdGjRzte5/V61bdvX8s50g0AAAAAAKmu3UGC3//+9zr66KM1cOBAvfHGG3rjjTcsr3vmmWc6vInWLRAlJbVAlNruMBAMBh1bJF5yySWO68TbJ1oh3QA4spBmAAAAgCNRu4MEM2bMML/VP9ha1ySQZNYkaGhokGEYCgQCGjhwoDZv3my7jtfrlc/ns52Pp0Q4tUm0Q7oBAAAAACDVtTtI8Nhjjx2yTeTn56uyslKBQMAMEuTl5am4uFiZmZmqra1VbW2t3nzzTV1//fUqKyvTf/7zn4Rv/t99912deuqpuvjii22fEy+wmJubqx07dnRoj6QbAAAAAABS3QF3N/iyxOsH1NfX67TTTlNNTY0ikUjSdcuWLdPIkSMt5+LinRH27dvX4X2QbgCkPlIMAAAAcKTrUHeDwyktLU0333yz7cv6Pffco7179zquce2110pqu8ChFdINgNS17q4ZBAgAAAAAdaIgQWZmphYvXmymDLRWVlambdu2OR79P+GEEw74+QUFBQd8LwD3IjgAAAAAfM4VQYJ4d4OW3Qzi3Q1aBgWKi4sd1yktLdUVV1xhO9+9e/c292JX0LCtzgoAAAAAAHR2rggSxLsb+P1+cywUCikYDJodFQzDaLO7QiwWM+sOWBk1alSbe/nss88sx0k3AAAAAACkOlcECfLz8+X1ehUIBMyxvLw8eb1eMzDg8/m0f//+Ntd6+eWXbefGjBnT5v19+/a1HCfdAEg9pBoAAAAAiVwRJHBKN4i3OYzFYsrMzGxzLadrMjIyksaOO+64hM/Z2dmW9/p8vjafDQAAAABAZ+aKIMHw4cO1bNkynXvuuebYxIkTtWzZMgWDze0FDcNQjx49HNf505/+pE8++cR2/oknnkga++9//5vw2S5dwam1IoDOh1MEAAAAQDJXBAlGjBihadOm6YMPPjDHfD6fpk6dqtzcXElSNBrVokWL1KtXL40ZMyYhNUGSgsGgRo8erfT0dNvnXHvttaqrq3Pci9dr/SuhJgGQOggQAAAAANY8xmEs2x+vN9C7d++kzgU9e/bUvn375PF4ZBiGunXrpoKCAq1cuVK1tbVJ3QZOO+00vfPOO+rSpYuqqqpsn/n2229rypQp2rt3r+W83a/jpz/9qe6+++6k8crKSse2iwAAAAAAHAxVVVXq0qXLIX0PTTskq3bQ8OHD9fjjj2vBggVavny5pOZ0g8svv1zXXnutPv74Y3k8Hr399tu26QDbt2/X7NmzHQMEklRSUqIRI0ZYBgnsThFI9sGDMXMWy5cedHwmAPfgFAEAAABgz/XpBvH0gLS0NNvOA5JUXl6u3Nxc9e7d2/FZO3bs0IoVKyznYrGYwuGw5RzpBgAAAACAVOeKkwRr165VLBYzuxt4PB5t2bJFhmGosrJSUvO3/Lt377ZdIxAIaM6cObrvvvscn7VmzRqzY4IVu7mCggKtWrUqaXzl/OmkGwAAAAAAUoIrggSttTzaHw8cVFdXOxYdjNc3KC0tdVy7V69ejvMrV67UhAkTHPfUEukGgPuRYgAAAAC0jyvSDVqLv/C3lJmZqVdeecX2nrq6ujY7F0iS3+93nN++fbvlOOkGQOdEgAAAAABoP9efJIgLBALat2+f7T2xWEybNm1qc+3Ro0c7zvfo0cNynHQDAAAAAECqc0WQoKioKKkrQWFhoZlqEJeZmem4TklJibxer2PNAbvChHHnnXee5TjpBkDnwykCAAAAoGNckW7g9/uVnZ2dkAoQCoUUDAbN1IPs7GzbVIC4WCymQCDgeE1jY6PjvN2pANINgM6FAAEAAADQca44SZCfn6/KykoFAgE1NTVJkvLy8lRcXCyPxyPDMLR//36tW7euzbW8Xvu4x5///GeNGzfugPZIugEAAAAAINW5IkjgJJ46UF1drSeeeKLN6+3SAiTpqKOOavP+pqYmy+KGpBsAnQenCAAAAIAD44p0g8mTJ+vdd9/VjTfeaI7NnDlTGzZsMNMN7F7eW6qrq1NDQ4PtvGEYys3NdVzD7hmkGwAAAAAAUp0rggSlpaUaNWqUHnjgAUnNLRBXr16tU045xbwmPT1dv/71rx3XycnJcTxJ8OabbyoQCNimJFi1XowrKChwfDYAAAAAAJ2dK4IES5YsUUVFhUpKSiQ1f+P/4osvqqamxnzpD4VCev311x3X+eijj/SDH/zAdn7w4MGS5HiawC7I4PP5HJ8NwB1INQAAAAAOnCuCBMOHD9eyZct07rnnmmMTJ07UsmXLzM9VVVV65plnLO+PnwCorKzU0qVLbZ9z/PHHS7JvpWgYhtasWWM5F4lEnH8IAAAAAAA6OVcECUaMGKFp06bpgw8+kNT80u/z+TR16lTzmkAgoPvuu8/y/vi3/42NjQoG7YsIPv/889qxY4e2bdtme028UGJr1CQAAAAAAKQ6V3Q3WLt2rWKxmGprayU1Bwm2bNmScPTfMAzdcMMNjuuUlJTYvuRL0rXXXqvHHnvMcY0TTzzRcpwWiAAAAACAVOeKIEFrVnUBAoGAjj/+eL399tu291VVVWnfvn2287169VJxcbHjs+2KF9ICEXAv6hAAAAAAB4cr0g3aIzc3V4MGDXK8JhQKOZ4kqKmp0U9+8hP169fP9pqqqirLcdINAHciQAAAAAAcPK44SVBUVJTwcm4YhgoLC830A6n55f29995zXKdv374Kh8O289XV1erbt6/69++vHTt2WF5j1x6RdAMAAAAAQKpzRZBg+PDhevzxx7VgwQItX75cUnN3g8svv1zjx4+XJJWXl2vv3r2O6zgFCCTpn//8p6655hq99dZbkppTC1qnEfTs2dPyXtINAPfg9AAAAABwaLgi3aC93Q3aOkng8XhsTwJIUrdu3RSNRs3PVi/+dveTbgAAAAAASHWuOEnQuruBpKTuBhkZGfrRj34kn8+X8KLfUl5entLS0tTY2Gg5n5GRoerqase9LF++XOeee27SOOkGAAAAAIBU54ogQXtqEvh8Pq1fv942QCBJlZWVCoVCKi0ttZwfMmRImy/0o0ePthwn3QBwB1INAAAAgEPHFekGfr9f2dnZ8vv95lgoFFIwGDRbEsZiMS1cuFCBQMB2nVGjRmn48OG28zk5OY7pCJKUlZVlOU66AXB4rbtrBgECAAAA4BBzxUmC/Px8VVZWKhAIqKmpSVJz6kBxcbFZXDASieill16y/UY/buvWrbZzO3bsUJ8+fZSZmam6ujrH1IXWSDcAAAAAAKQ6VwQJWqcbSEpKN4jFYnr//ffNIIKd3bt3287l5+dLkhkkaB0gSEuz/3WQbgAcPpwgAAAAAL4cnSbdIBAI6LbbbrO8/6677jL/3emkwd/+9jdJzbUL7PZhh3QDAAAAAECqc0WQID8/X16vN6HeQF5enrxerzIzMyVJtbW1uvPOOy3vnzNnjgzD0IUXXqjc3Fzb51x66aWSmk8lWOnWrZvtvQUFBW3+HAAAAAAAdGauCBI4aWhokCTV19frgw8+sLwmHA5r2rRpqq6u1r59+2zXit9vV4dg9+7dtukMPp+vI9sGcBBQrBAAAAD4crk+SBDn8Xgc0wGeeeYZpaWlOdYV6N+/f5vPKSkpsRyPRCJtbxLAQUFwAAAAADg8Ok2QICcnRxMmTLCcS0tLUzQa1QcffOD4Mv/cc8+1+Ry7kwTUJAAAAAAApDrXBwniqQG1tbV67bXXLK/xept/jJKSEqWnp9uudcIJJ0iSWQzRSs+ePS3HqUkAfDk4QQAAAAAcPq4PEsR5PB5t3LjRcq6xsVFSc90Cu3oD0uddDXr06GF7jV0LRaeuCQAODgIEAAAAwOHVaYIE3bt31+DBgx2v2bZtm2Pdgu7du0tyPkmQn59vOU66AQAAAAAg1dlX+fsSFRUVqaqqKmGssLBQtbW1CWNLlixxXKeystKsSeD1epNaHR5zzDGSpLq6Osv7PR6PgsGg5VxBQYFWrVqVNL5y/nSFQiHHfQEAAAAA0Bm4Ikjg9/uVnZ2tcDhsFg4MhUKqqalRfX29JCkWi+nRRx91XCcajZpBgtYBAknKyMhQY2OjamtrlZGRYbZXjLMLEEj26QZj5iyWL93+PgBtI80AAAAAcAdXpBvk5+fL6/UqEAiYY3l5efJ6vWZRwkgkou3btzuuc+KJJzrWDli3bp1KS0slKSlAIMnxRADpBgAAAACAVOeKkwRO4vUDYrGYampqHK8NBoPq2bOn9u3bJ4/HkxQwOPXUUx3vr6iosJ0j3QAAAAAAkOpcESSYPHmyFi1apMWLF2vu3LmSpJkzZ2rs2LEaOnSopOYX+LKyMsd1vF6vMjIyJFmnB+zfv19Dhgyxvb+hoUGGYVgWNiTdADj4SDMAAAAA3MVjHMbefvGX8fgWotGo0tLS5PV6zVaGaWlpikajZupBvOaAlX379mno0KHav3+/5fzy5ct1zjnnyO/3265TVFSkAQMGJI1/9atftTxJcNK1vydIABwAAgQAAABAx1RVValLly6qrKw8ZCfaXXGSYPbs2Vq0aJFZkyAtLU1XXnml/v73v5vBgqysLK1bt87xJMCSJUtUXl5uO//mm2/qnHPOcdzLnj17LIMEpBsAAAAAAFKdK4IES5YsSagH0NTUpBdffDGhBkFeXp7effddy/svvvhiPf3003rnnXccCxeGw2FJcjyNEC+U2BrpBsDBxUkCAAAAwH1c0d1g+PDhWrZsmc4991xzbOLEiVq2bJn5uba2Vt/97nct73/++eclqc3ChlYdDVobOHCg5TjdDYCDhwABAAAA4E6uOEnw6quvSpLOPvtspaenKy0tTY8//njCNZWVlYrFYpb3x08INDU1yev12l5XW1trOd6yE0LXrl0tr7FLNwDQMQQIAAAAAPc67CcJPB6PTj755ITOBF27dtXgwYMTugz06NFDOTk5jmuVl5fbpgtIsqw1ICWmEuzevbvNawAcGAIEAAAAgLsd9iCBYRgqKytTVlaW0tKaDzaUlZXJMAwFg5/n+p9wwgmOtQSk5haH8eKHVuLpDE7XxAMVrZFuAAAAAABIdYc9SCBJ+fn58nq95st7LBZTXl5ewqmAXbt26fLLL3dc57jjjlN6errt/IsvvihJuuiii2yv6dmzp+V4QUGB47MBOOMUAQAAAOB+rqhJ0B6ffPKJPvzwQ8drBg8erA0bNti2QZw0aZIkacWKFZKaTw20LGbo8Xhs0xV8Pt+BbBs44hEcAAAAADoPV5wkaA+v16tjjz3W8Zqmpibt3LnTdn7Dhg2SpNLSUknt63YQ11aqA4BE6+6aQYAAAAAA6GRcGSRoWbAwLj8/X//85z8d7yspKVFTU5PtfLwLglNNAjvUJAAAAAAApDpXphtYdRLYvn27RowY4Xhffn6+8vPztWPHDst5u6KETs+Ns2uBuHL+dIVCIcd1AQAAAADoDFwZJLASi8U0aNAgx7oEJ510kl5++WXbIMGAAQNUXV2txsbGDj/fLoAwZs5i+dKDlnPAkYb0AgAAAKBzc2W6gZXu3bu3+Y39tm3btG3bNtv5r371q9q6davjGnZBCNINAAAAAACpzhUnCYqKilRVVZUwVlhYqNra2oSxvLw8x3UqKytVXV1tO//ggw/q//2//3dAeyTdAAAAAACQ6lwRJPD7/crOzlY4HDYLD4ZCIdXU1Ki+vl5Sc7rBnj17lJ6ebhYgbM0wDMfChZ988kmbdQn69+9vu7YV0g0A0gwAAACAVOGKdIP8/Hx5vd6ErgN5eXnyer3yepu3GIlEVFpaahsgkKTRo0c7Pmfs2LFt7iU9Pd1ynHQDAAAAAECqc8VJAifxdoixWEwXX3yxFixY4Hi91+tVLBaznDvuuOPavNbv91veS7oBAAAAACDVuT5IEI1GJUm1tbW66667LK8JhUJmTYO0tDQ1NjbK4/EkpQjE14qzCyZYId0AsEaqAQAAAJA6XJFu4MTn80lqPlHQp08fy2uqqqoUDAY1btw4RSIRSdYv9RkZGWaNg44i3QAAAAAAkOpcf5IgLjMz00w9sFJfX6///Oc/jqcDdu7cqQEDBhzQ80k3AAAAAACkOlcECdrbAnH//v2O69TW1lqmGcSdfvrpysnJOaA9km4AJCPVAAAAAEgtrkg3iLdAbFk0MBQKKRgMmqcHAoGA7r77bgWDQaWnp9sWGIxfb3XqIN49wSlQsGfPHstx0g0AAAAAAKnOFUECpxaI8Zf9SCSif/3rX4pEIgqHw2pqajKvzczMlNRcmDCebmD1zX/8ZELrEwot2Z0YKCgo6OBPBaQ2ThEAAAAAqafTpBvEYjFt3LgxITgQV1dXJ0lqaGhwfM6qVav0rW99y7FuQd++fS3H4wUUgSMdwQEAAAAgdbniJEF70g0Mw9DXvvY1x3WCwaBtGoIkTZgw4YD3GO+aAAAAAABAqnJFkMAp3SCeShCJRFRUVGS7RlFRkaZOnWrbJlFyrkXQFmoSAJwiAAAAAFKdK4IE8XSDlukF8XSDeCqBYRjasmWL5f2BQMBME9i1a5ckKSMjI+m6+vr6NvfS2NhoOU5NAgAAAABAqnNFkMAp3SAtrblsgmEY+uyzzyzvb2xs1JlnnimpuXihZF2fwOkkQlz8ea3ZFTQEjhScIgAAAABSnyuCBE7pBvExr9er8ePH267x//7f/5Nk/5IvWZ8uaM0uGEC6AQAAAAAg1bm+u0HLwoVOL+rLly/X5Zdfbl5vJV7fwOv12nY4sOtiUFBQoFWrViWNr5w/XaFQyPaZAAAAAAB0Fq4IEsTTDcLhsNniMBQKqaamRpFIRE1NTTIMQ8Fg0HaNHj16SGo+SWDVJlH6vFWiUwvE+vp6y+fYnTAYM2exfOn2+wI6O9IMAAAAgCNHp0o3WLBgge0a1113naTPTwtY+fDDD9tVvNAK6QY4EhEgAAAAAI4srjhJ4MTrbY5jGIahkSNHSpKCwWDSy36/fv0kSRUVFbZreTweRSIRx+fZnVYg3QAAAAAAkOpcESRoT00CSbr11lslWbcy3LNnj/r06aOsrKykteIGDBignJwcx700NjYmnGiII90ARxJOEAAAAABHJlekG7SnBaLf79ekSZNs16iurjavs9O9e3dJzl0OrAIEEukGAAAAAIDU54qTBPn5+aqsrFQgEDCLDubl5am4uNgci0Qiuu+++2zXKCkp0ZAhQ9TQ0GB7TTyVIBAIWF5nFyCQSDcAAAAAAKQ+VwQJ2tsCcdu2bbZrPPTQQ/rqV7/qWHOguLhY3bp1sw0GOHU9IN0ARwpSDQAAAIAjV6dKNxg9erTtGqeddpokKRqN2l4TPz0wcOBAc92W4sUPrZBuAAAAAABIda4IErSnBWIkEnHsXJCdnS3J+TRAXl6epOY2iVYnDmpqamzvLSgocPwZAAAAAADo7FwRJHAS//a/vr5e69evl2RdO+Djjz+W5Bwk6Nu3ryTpww8/lM/nS5qPt1u0YnU9kGpINQAAAACObK4PEsR5PB7zJb6xsTFp/t5771VdXZ3jGvFAwr59+yzTEvbu3Wt7r1OtAwAAAAAAUkGnCRLk5OTovPPOs52PRqPatGmT0tPTba/ZvHmz4zPiRRKtUJMAAAAAAJDqXNHdwEn8G//a2lqtWLHC8dqSkhLHF/2RI0c63m/XwUCyb4EIpALSDAAAAABInegkgcfj0YQJExyvqampMWsYWDn66KPbfM79999vOe4UQAAAAAAAIBV0miBB9+7dHQsLSlJhYaHj/EsvvdTmc04//XTLcdINkKo4RQAAAAAgzhXpBkVFRaqqqkoYKywsVG1tbcLYddddp+eff952nYaGBnXr1k3l5eWW87t375YkZWRk2J44yMnJsRy3SzdYOX+6QqGQ7Z4AAAAAAOgsXBEkGD58uB5//HEtWLBAy5cvlyRNnDhRl19+ucaPHy9JKi8v1/nnn9/mWk5dCN5///02r8nLy7Mct0s3GDNnsXzpwTb3BbgRpwgAAAAAtOSKIMGIESM0bdo0BQIBc8zn82nq1KnyeDwyDEMej0ddunSxPSUgNRcmjMVitvOjR4+WJKWnp1sGCrxer3Jzcy3vJd0AqYYAAQAAAIDWXBEkyM3N1dq1a7VkyRL9/Oc/l9fr1Ve+8hXdfPPNGjp0qKTmb/Lr6uoc19m2bZv8fr/t/Lhx47Rjxw7bUwEZGRm295JuAAAAAABIda4IEixdulS33nprwtjChQs1a9Ys83NaWpqmTZumv/zlL2ZbxDi/36+mpiaVlpaqb9++qqiosHzO448/riFDhtgGG+rq6hSNRuXz+ZLmSDdAKuEUAQAAAAArruhuUFZWpqysLKWlNccsYrGYDMNQMPj5y3dubq5+/OMfJwUIpM9rDOTm5jqmIxQWFmrcuHG2816v1zJAIJFuAAAAAABIfa44SZCfn6/KykoFAgE1NTVJai4gWFxcbF4TjUZ1//33W94f/5a/srLSvN9Kz549bbsXSHJssUi6AQAAAAAg1bkiSNCeFoiRSERr1651XMcwDMcX/QsvvPCA90i6AVIBaQYAAAAAnLgi3cDv9ys7Ozuh6GAoFEpIN8jOztaOHTvaXGv//v22c/n5+Y73OnVGIN0AAAAAAJDqXBEkyM/Pl9frTWiBmJeXJ6/Xa54M2L9/v2M9Aam5xaFVzYK4Dz74QJISntNSLBazDRQUFBQ4PhsAAAAAgM6u06QbxGKxNlsgSs2nEhobGy3nunXrJknKzMy0vcYurcBuHOgsSDUAAAAA0BZXnCRwSjeIj4XDYe3cudN2jQceeEAXXnih7cu/JA0cOLDNvXg8Hstx0g3QmREgAAAAANAerggSOKUbxMe8Xq+6du1qu0bfvn1VXV3t+Jx4ukFTU5NlMMDn89meGCDdAAAAAACQ6lyfbhB/mW/ruH/Pnj0VCoWUkZGhhoYGy2uOPvpo1dfXJ6QxtObz+To0DrgZJwgAAAAAdIQrThIMHz5cy5Yt07nnnmuOTZw4UcuWLVNGRoYkqaGhQa+//rrtGgsXLpTX63VMN9i8ebPKy8tt552KHkYiEYefAAAAAACAzs8VQYIRI0Zo2rRpZjqA1PzN/dSpU81uA16vVyeeeKLtGm+++abq6urMEwdWHQwaGhpUVFTkuJetW7dajlOTAAAAAACQ6lyRbrB27VrFYrGENIAtW7bIMAyFw2Fz7OOPP5bH47FMPSgvL9emTZvUtWtXlZeXW54o6N69u8rKyhz3YncSoaCgQKtWrUoaXzl/ukKhkOOaAAAAAAB0Bq4IErSH1+vVL37xC/3v//6v7dH/HTt26IQTTtDKlSst57/yla/ohRdecHzOgAEDLMftaiKMmbNYvvSg45rAl41aBAAAAAAOhCvSDdqje/fukpzrBnz66ae2RQl9Pp+CwaDGjh1rjqWnpydck5WVpWDQ+oWfdAMAAAAAQKpzxUkCp+4GLb366quOXQ4qKyv13nvvWc7FgwstgwAtUxkkqba2VrFYTF5vcuyEdAMAAAAAQKpzRZBg+PDhevzxx7VgwQItX75cUnN3g8svv1zjx4+X1Fxz4LXXXnNcxzAMx5MGP/jBD3Tvvfe2uUZHxkk3gFuQYgAAAADgi3JFukHr7gYej8fsbhAXCAQ0YcIEy/vjdQSamprk9/ttnzN+/HiVlpY67sXn81mOk24AAAAAAEh1rjhJkJubq7Vr12rJkiX6+c9/Lo/Ho6985Su6+eabNXToUBmGocbGRv3zn/+0vH/btm2SpJ49ezqeJCgoKLCc9/l85nh9fb1lXQLSDQAAAAAAqc4VQYKlS5fq1ltvTRhbuHChZs2aZX5OS0tTVlaWbWFCSSotLVUsFrOdz87Otjxp0DJwYHc/6QZwM1INAAAAABwMrggSlJWVKSsrS+FwWE1NTYrFYjIMQ8FgUPX19ZKaTxuEQiHbwoTxa5zcfvvtuvPOOx2vycjIsBwn3QBuQ2AAAAAAwMHmiiBBfn6+KisrFQgE1NTUJEnKy8tTcXGxeU00GlVJSYnjOpWVlY7zl112WZt7satJQLoBAAAAACDVuSJIMHnyZC1atEiLFy/W3Llz5fF4NHPmTI0dO1bHH3+8IpGIIpGIJk+erOeee862+OCf/vQnx+c8+uij+vWvf31AeyTdAG7BCQIAAAAAh4oruhuUlpZq1KhReuCBByQ1dzJYvXq1TjnlFLNeQNeuXbVgwQKdeuqptusEg0GdeeaZtvP33ntvm90NGhsbLcdJNwAAAAAApDpXBAni3Q2uvfZaSVIkEtFXvvIVrV+/3iw0uHPnTg0cOFDLly+X12u97XvvvVczZth/y2oYhhYvXuy4l0AgYDleUFDQnh8FAAAAAIBOyxVBgqVLl2ro0KFmhwOfz6eFCxdqyJAh5jf76enpuuyyy9SlSxfFYjF5PJ6kdcLhsPr27ev4rI0bNzrOb9261XLcrlYB8GUi1QAAAADAoeSKIEG8u0FaWnOJhMbGRrO7QTwYkJ2drerqajNdwKpGQP/+/XXDDTc4PisUCsnr9So9Pd1yPr6H1iKRSLt/HuBQIEAAAAAA4FBzRZBg1qxZWr9+vW655RZJksfj0U033aSNGzeaL+1VVVV69tlnHdcpKSlp8xv/xsZGxWIxhcNhy3m7AoXUJMDhsu6uGQQIAAAAAHwpXBEkiKcb3HbbbZIkv99vphvEWyJ6vV5961vfclynsrLSNl2gvezSFahJgMOB4AAAAACAL5MrggRO6QZx+fn5euuttxzX+fDDD82ggp3MzEzH+d27d1uO250wAAAAAAAgVbgiSJCfny+v15vQWSAvLy+hi0FZWVmb3+YbhmHb+UCSnnnmGc2fP99xDbs0BNINAAAAAACpzrpK35esqKhIVVVVCWOFhYWqra01P0ciEV1wwQVas2aNtmzZYrmO1+tVLBazfc769et14oknOu5l+/btGjp0aNJ4QUGBVq1alTS+cv50hUIhxzUBAAAAAOgMXBEk8Pv9ys7OVjgcNtMFQqGQampq1NDQIMMwVF9fr65du2rbtm2264wePdrxOZ999pmi0WjSuMfjMdMJ+vXrZ3mvXbrBmDmL5UsPWs4BB4paBAAAAAAOB9enG8RbIPp8Pj322GNt1hzo3r277dxPfvITDRgwIGm8ZQBg8ODBlveSbgAAAAAASHWuOEkwefJkLVq0SIsXL9bcuXMlSTNnztTYsWM1fPhwxWIxVVdX66mnnmpzrXhQIRQKJaUw1NTUtHm/XQtF0g0AAAAAAKnOFUGCpUuX6tZbb00YW7hwoWbNmmV+NgxDPXr0UFlZmeUagUBA48ePN69pHSCQmk8slJaWOu6lvLxc3bp1Sxon3QCHEukFAAAAANzAFekGrVsgSjJbIMZPBnTt2lXHHHOM7RqNjY3atGmTRo0aZXvN0Ucfrfr6ese9FBcXW46TboBDhQABAAAAALdwxUmC/Px8VVZWKhAImDUH8vLyVFxcbBYVjMViKiwsdFynpKREvXr1spzz+Xyqr69Xenr6Ae2RdAMAAAAAQKpzRZCgPS0QY7GYunbtqsrKStt1YrGYnnvuOcu5aDSqf/zjH7rgggsc99K7d2/LcdINcChwigAAAACAm7gi3SDeAtHv95tjoVAoId0gEAgoFos5rhONRvXpp5/azsdiMeXk5DiuYVWPQCLdAAAAAACQ+lwRJGhPC8RIJKLHH3/ccZ2GhgbH+XgQwuvt+I9dUFDQ4XsAJ5wiAAAAAOA2nSrdIDc31/zs9XqTThYEg0H5fD5Fo1GzlkFL55xzjqLRqHw+n7xerwzDUDQaNedbFk5szS7dAOgIAgMAAAAA3MwVJwmc0g3iY+FwWPPmzTPnWwcIioqKdNFFF5kv/VYv9SUlJaqurlZTU5MikUhCgEBqPq2wfPlyyz2SbgAAAAAASHWuCBI4pRvEx7xer44//njbNQYMGKCKigrH52zYsEGhUMi2w0GXLl00evRoyznSDQAAAAAAqc716QbxmgSGYWjAgAG2a1RXV5vX2jEMQ16vV+Fw2HI+EokoKyvLcs7n8zmuDbSFVAMAAAAAbueKkwRO6QbxOgGGYWjNmjW2a7z55pvKyclRZmam7TUXXXSRGhsbbedb1kBoLRKJOP0IAAAAAAB0eq44SZCfn6/KykoFAgE1NTVJak43KC4uNse8Xq9WrFhhu0ZGRoZqa2tVV1dne81bb72lk0466YD2SE0CHChOEAAAAADoLFwRJHASb2tYX1+vwsJC2+v++Mc/atGiRWbXg8zMzKSAQd++fVVfXy9Jys7OVk1NTbv3UVBQoFWrViWNr5w/XaFQqN3rAAAAAADgVq4PEsR5PB5lZWXZpgQ8++yzuvvuu82uB1YnCoqKinTWWWdJUocCBJJ9C8QxcxbLlx7s0Fo4MnCCAAAAAEBn44qaBJMnT9a7776rG2+80RybOXOmNmzYIK+3eYtOBQel5hMH27ZtS6hr0NqIESMc0xGCQfuXfdINAAAAAACpzhUnCUpLSzVq1Ciz3aHH49Hq1at1ww03mAUD4y0QN23aJKm520B2drYqKyvNdbZv327WNLDS1NSkDz74wHa+vr5e0WjUspMB6QYAAAAAgFTniiDBkiVLVFFRYX42DEMvvvhiQkpAKBRSr169zM/RaDSpbeLHH3/s+Jy33npLF1xwwQHtkXQDtIX0AgAAAACdnSvSDYYPH65ly5bp3HPPNccmTpyoZcuWmZ/D4XBSd4PWL+4NDQ3KyMiwfU4wGFRJSYnjXuyKI5JuAAAAAABIda44STBixAhNmzYtId3A5/Np6tSp5jWGYWjgwIGOHQ6ampqUmZlpdkRorbq6WllZWY57WblypY477rikcdINAAAAAACpzhVBgtbpBpKS0g1yc3Mdiw5KUklJifLy8rR//37Leb/frw8//NBxjZaBiZZIN0AcaQUAAAAAUpUr0w0MwzDTDeLdDXw+n771rW85rrN582bHugTRaFTjxo1zXCM9Pd1ynHQDAAAAAECqc0WQIJ5uEO880DLdIP4NfmNjo7Zt26a0NPvDD8Fg0DGd4Oabb1ZjY6PjXtatW2c5XlBQ0NaPAQAAAABAp+bKdAOr7gb19fVasWKF2RLRSrxl4sUXX2w5v3//fr333nvmZ7/fn9Qycc+ePZb32qUb4MhAigEAAACAI4ErggR+v1/Z2dkKh8PmS3soFFJNTY0aGhpkGIY8Ho9Gjx6tV155xXGtpUuXOs7X1taa/946QCDJTG9ojXSDIw+BAQAAAABHGlekG+Tn58vr9ZrdDSQpLy9PXq9XHo9HkhQIBLRkyZI213r77bcd52OxmLmmlaOPPtpynHQDAAAAAECqc0WQwEm8xkBNTY3uuOMOSZ8XF2z5sn/SSSfp9ddf12effdbmmk6pA927d7cc9/l87d4zOj9OEQAAAAA4Erk+SGAlHA5LSnzZ//DDD5Wbm6vevXu36147gwYNshx3qoUAAAAAAEAq6DRBgoyMDE2ZMsV2vkuXLpozZ45lnYGWtm3b5jhv1z2BmgRHDk4RAAAAADhSuaJwYVFRkaqqqhLGCgsLVVtba6YUNDQ06JZbbrFd42tf+5okJXRJsDJgwADH+crKSnXp0iVpvKCgQKtWrUoaXzl/ukKhkOOaAAAAAAB0Bq4IEjh1N4hEImpqapJhGOrfv7/tGg0NDZKkaDTq+Kzdu3c7zj/22GO67rrrksbt6hiMmbNYvvSg45pwL04NAAAAAMDnXJFu4NTdID7m8/n08ccf264RL2bYlqOOOko9e/a0ne/WrZvlOOkGAAAAAIBU54qTBO1JN4jFYrrooou0Zs0ayzVaBhha8ng8CacAmpqatG/fPstr09LSdP7551vOkW4AAAAAAEh1rggStDfdoKamxnaN6upqy/HWaQJOLRIjkYhee+01XXbZZW2uE0e6QedCegEAAAAA2Os06QaRSESNjY22a9x2222S7LsTSNLTTz+t2bNnO+7lggsusBwn3aDzI0AAAAAAAM5ccZLAidfbHMcwDEPLli2zve6YY46RJPXq1cu2OOEpp5xipi/YsatJQLoBAAAAACDVuT5IUFdXJ6m5e8GmTZtsr7v44ov1j3/8Q6WlpbbX+P1+RSKRA9oH6QadC6cGAAAAAKDjXJFu0B5paWnKycmxnV+2bJnq6urMmgZW3njjDcc1JGnnzp2W46QbdB4ECAAAAADgwLj+JEFcZmamxo8fr8WLF1vOx08aBAIBhcNhy2vi416vV7FYzPKa/Px8y3HSDQAAAAAAqa7TBAkkae/evY7zd9xxh22AQJI2bNigaDSqYDCo2tpay2s+/vhjDR06NGmcdAP34uQAAAAAABwcrkg3mDx5st59913deOONkiSPx6OZM2dqw4YNZuHChoYGy2/yW8rJydGwYcNs5//yl79o7969tgECSfrHP/5hOU66gfusu2sGAQIAAAAAOIhccZKgtLRUo0aNMtsder1erV69WjfccINZaNDn82nq1Kn6y1/+YrvO17/+db388su281VVVdq2bZv8fr9t7YLx48dbjtulG+DQIxAAAAAAAF8OVwQJlixZooqKCvNzLBbTiy++qJqaGnOsV69elkECj8djpgLEAwBOSktLHYsbjhw50nLc5/O18VPgYCIwAAAAAABfPlekG/j9fmVnZ5sv+IZhKBQKKRj8PNff5/MpPT096d6WtQIqKysdWyBKsi1YGFdfX285fqCtE9FxBAgAAAAA4PBwRZAgPz9fXq/XTDeQpLy8PHm93oSaBHPnznVcZ9SoUW0GAdpCC0QAAAAAwJHKFekGRUVFqqqqShgrLCxMKDAYiUSUmZnZ5lp2XQjaq1evXpbj1CQ4tDg9AAAAAACHnyuCBPF0g3A4bNYLCIVCqqmpUUNDgwzDUCwWU1ZWVptrtRUkcKpHIEldunQ5oHVxYAgOAAAAAIB7uCLdYNasWVq/fr1uueUWc+ymm27Sxo0bzYKBFRUVWrZs2Rd6zieffKLTTz/d/OzxeNp9L+kGBx8BAgAAAABwF49xGL8ij7+kjxw5Uhs3bpT0+Tf2xx57rD755BPz2vT0dGVmZqq8vNxyraysLJWUlCgvLy+hK0JLhmHozTff1JgxY2z3ZPfr+OlPf6q77747abyyslKhUMh2PQAAAAAADoaqqip16dLlkL6HuiLdoKysTFlZWQnpBobx/9u7+6gmrzsO4N8QAuFFCIqAKK+KUgEtCjIGk7WlQueqrZ6181B07TaPjlZxzro3atu9iHrsOl+KuvW0euoq66nS1b4oRYW6KihIAUVkFsFaYk6nEUSQQO7+wDwjkgRQDEn8fs7hHLn35uY+/k7Ck1/ui4Cbm5u03MDNzQ2tra1m+2hra0NVVRWmTZuGkpISs+0s9QEA58+fx/jx4/uUm0sezPz9u5C7upmsox6cMUBERERERGQfbGK5gaXTDQyzDRQKBV599VWL/Wg0Gmg0Gottpk+fbrHe19fXZDmXGwxe+YaFTBAQERERERHZEZuYSWCJIUmg1+vxne98x2JbvV6P8PBwnD171myb/k5I0Gg0JjcvNHe6QckfF3C5ARERERERETkEm0gSDOQIRABob2/vt6/q6mqL9SNGjLBYP27cOJPlXG7QP84aICIiIiIism82kSSIiorCrl27kJubi0OHDgEA0tPTkZmZifT0dOj1erS3t2P+/Pl39TxarRYqlcpiG1dXV5PlXG7Qg4kAIiIiIiIix2UTSYLo6Gg89dRTRnsSyOVyzJs3T/oGXyaTwc/PD01NTWb7uXnzZp8ZCb2dPHkSSUlJFsdibsYAlxsQERERERGRo7OJJEF+fj60Wq1R2UcffWR0lKGLiwsuX75ssZ+QkBCLpxecO3cOCQkJRmUeHh64ceOGlByQy+UmH+tIyw04G4CIiIiIiIhMsYnTDRQKBTw9PaFQKKQyLy8vuLm5SRsXKpVK+Pj4WOxHo9FAr9ebrW9paemzJ0FbW5vZBEBvjrLcgAkCIiIiIiIiMscmkgQDOQKxq6sL48ePN/n43icgWDJp0qQ7HmNiYuIdP9YW8DhCIiIiIiIi6o9NLDcYyOkGer0e586dM/n43jMBZDKZ2ZkBycnJdzzGgcw2sDVMChAREREREdFg2ESSwLDc4ObNm9DpdAB6lhtcv34dHR0dEEJACIGZM2fi/ffft9iXk5MTuru7TdZptVqMHj36jsZoa8sNmAAgIiIiIiKioWY3yw3kcjkmTJjQb1+G9uaepz/t7e0my21luQGXDRAREREREdG9YhMzCSwtNzB86O/o6MDu3bvN9rFjxw488cQTkMvl6OrqMtnGza3/Uwi+/vprRERE9Ck3d+rB3eIHfiIiIiIiIrIVNpEksLTcoKurCzqdDkIINDc3m+3j448/xs9//nOLewc0NzfD09PT4lj8/PxMlptLPFjCBAARERERERHZE5tfbmAoc3JygpeXl9k+DO06OzvNtrlw4QLOnz9vcSzffvutyfLB7knABAERERERERHZG5uYSTCQ5QZCCIsJgKCgIAA9yQRzRyH6+fkZbVzo7e2Na9eumezndomJifj3v//dp7zkjwssJi+IiIiIiIiI7IVNzCSIiorCwYMH8fDDD0tl6enpOHjwICZOnAigJ0mgVCrN9mFYDqBQKMy2GTlyJK5fvw6gZ4NDU5sU9p7N0Ju5ZQwzf/8upq/aJf0QERERERER2SubmEnw2WefAQBSUlLg6uoKANi1q+cDd35+Ph588EHI5XI8++yzeO211+Dv748f/vCHePPNN6VZAwsX9kzvd3d3hxACQUFBfZYWqNVqeHt7A+j50B8bG4vS0lJ4eXn1mclwu7KyMpPl3Z09iYaSPy4AgH77ISIiIiIiIroThs+blvbiu1s2kSQwMHyL3/skgZiYGKlMrVZDr9dj8eLF2LJlCyZOnIizZ88CAKqrqzFt2jQAPfsSmNt7wNfXV1qSYPjgb/iPDg0NNTu2/fv3GyUAGhsbkZycjJrtKwAA3puX3MklExEREREREQ1Ka2ur9AX4UBv2JIFhz4HenJ3/Pywnp54VEUqlUloq8Morr8DZ2dloaUFbWxsAICwsDO3t7ejo6JD6mj9/PvLz8xEQEAAXFxf4+vpKGxQKISCTyaBUKvHcc8+ZHaeXl5fR3gOGUxKampruWXDIelpaWhAUFISLFy9yjwkHwHg6FsbTsTCejoOxdCyMp2NhPB1L73iOGDECra2tCAwMvGfPN+xJAsPygt58fHz6lAUHByM+Ph4FBQWQy+WQy+Vwc3PD9OnTUV5ejgkTJgAAfvazn+FXv/oVgJ6NCi9fvozf/va3mDRpktSvRqMx6lsIgfb29kG9gAzJC29vb77wHMjtySCyb4ynY2E8HQvj6TgYS8fCeDoWxtOxGOJ5r7+kHtaNC+VyufSNfG++vr59ygIDA1FdXQ0A6O7uxs2bN9HQ0IDy8nI4OTnhoYceAtCzceGNGzcgk8mQmZmJ7du34/XXX8fSpUulvl555RXI5XKoVCoAwNixY7Fp0ybMmjXrHlwlERERERERkX0Y1pkEnp6eGDdunFGZXC6XZgX0NnHiRKSkpOD06dOora1FV1cX5HI5YmJiUFBQIC09eOeddwD0zA7YuHGj9PhTp05J/37jjTfQ3d0NrVYLALh06RKWLVuGqVOnorKycoivkoiIiIiIiMg+DGuSwPAhvTfDUYa99d65MT093WKfR44c6fd51Wp1v2364+rqijVr1phcLkH2h/F0LIynY2E8HQvj6TgYS8fCeDoWxtOxWDueMnEvz04gIiIiIiIiIrsxrHsSEBEREREREZHtYJKAiIiIiIiIiAAwSUBEREREREREtzBJQEREREREREQAmCS4Y1u3bkVoaCiUSiUSEhJQVlY23EOi26xduxbx8fEYMWIE/Pz88MQTT6Curs6oTUdHB7KysjBq1Ch4enpi/vz5uHz5slGbpqYmzJ49G+7u7vDz88OqVatMnsJB1pWbmwuZTIbs7GypjPG0L5cuXcIzzzyDUaNGwc3NDTExMTh58qRUL4TASy+9hDFjxsDNzQ2pqamor6836uPKlSvIyMiAl5cXVCoVfvrTn+L69evWvpT7Wnd3N3JychAWFgY3NzeMHz8ef/jDH4xOJmIsbVdJSQkef/xxBAYGQiaToaCgwKh+qGJXVVWF733ve1AqlQgKCsL69evv9aXdlyzFU6fTYfXq1YiJiYGHhwcCAwOxcOFCfPPNN0Z9MJ62o7/XZ29LliyBTCbD66+/blTOeNqOgcSztrYWc+bMgbe3Nzw8PBAfH4+mpiap3lr3ukwS3IH8/Hz88pe/xJo1a1BRUYGpU6ciLS0NGo1muIdGvRQXFyMrKwvHjx9HYWEhdDodZs2ahba2NqnNihUr8OGHH+K9995DcXExvvnmG8ybN0+q7+7uxuzZs9HZ2YkvvvgCO3fuxNtvv42XXnppOC6Jbjlx4gS2b9+OKVOmGJUznvbj6tWrSEpKgkKhwCeffIIzZ85g48aN8PHxkdqsX78emzZtwrZt21BaWgoPDw+kpaWho6NDapORkYHTp0+jsLAQ+/fvR0lJCRYvXjwcl3TfWrduHfLy8rBlyxbU1tZi3bp1WL9+PTZv3iy1YSxtV1tbG6ZOnYqtW7earB+K2LW0tGDWrFkICQlBeXk5NmzYgJdffhk7duy459d3v7EUzxs3bqCiogI5OTmoqKjA3r17UVdXhzlz5hi1YzxtR3+vT4N9+/bh+PHjCAwM7FPHeNqO/uJ5/vx5JCcnIzIyEkeOHEFVVRVycnKgVCqlNla71xU0aDNmzBBZWVnS793d3SIwMFCsXbt2GEdF/dFoNAKAKC4uFkIIodVqhUKhEO+9957Upra2VgAQx44dE0II8fHHHwsnJyehVqulNnl5ecLLy0vcvHnTuhdAQgghWltbRUREhCgsLBQpKSli+fLlQgjG096sXr1aJCcnm63X6/UiICBAbNiwQSrTarXC1dVVvPvuu0IIIc6cOSMAiBMnTkhtPvnkEyGTycSlS5fu3eDJyOzZs8Vzzz1nVDZv3jyRkZEhhGAs7QkAsW/fPun3oYrdG2+8IXx8fIzeZ1evXi0mTZp0j6/o/nZ7PE0pKysTAERjY6MQgvG0Zebi+fXXX4uxY8eKmpoaERISIv7yl79IdYyn7TIVz6efflo888wzZh9jzXtdziQYpM7OTpSXlyM1NVUqc3JyQmpqKo4dOzaMI6P+XLt2DQAwcuRIAEB5eTl0Op1RLCMjIxEcHCzF8tixY4iJiYG/v7/UJi0tDS0tLTh9+rQVR08GWVlZmD17tlHcAMbT3vzrX/9CXFwcfvSjH8HPzw+xsbH429/+JtU3NDRArVYbxdPb2xsJCQlG8VSpVIiLi5PapKamwsnJCaWlpda7mPvcd7/7XRQVFeHcuXMAgC+//BJHjx7FY489BoCxtGdDFbtjx45h5syZcHFxkdqkpaWhrq4OV69etdLVkCnXrl2DTCaDSqUCwHjaG71ej8zMTKxatQpRUVF96hlP+6HX6/HRRx9h4sSJSEtLg5+fHxISEoyWJFjzXpdJgkH69ttv0d3dbfQfDwD+/v5Qq9XDNCrqj16vR3Z2NpKSkhAdHQ0AUKvVcHFxkf4wGvSOpVqtNhlrQx1Z1549e1BRUYG1a9f2qWM87ctXX32FvLw8RERE4MCBA1i6dCmWLVuGnTt3Avh/PCy916rVavj5+RnVOzs7Y+TIkYynFf3617/Gj3/8Y0RGRkKhUCA2NhbZ2dnIyMgAwFjas6GKHd97bVNHRwdWr16NBQsWwMvLCwDjaW/WrVsHZ2dnLFu2zGQ942k/NBoNrl+/jtzcXKSnp+PgwYN48sknMW/ePBQXFwOw7r2u811cC5HdyMrKQk1NDY4ePTrcQ6E7dPHiRSxfvhyFhYVGa7PIPun1esTFxeHPf/4zACA2NhY1NTXYtm0bFi1aNMyjo8H45z//id27d+Mf//gHoqKiUFlZiezsbAQGBjKWRDZKp9PhqaeeghACeXl5wz0cugPl5eX461//ioqKCshksuEeDt0lvV4PAJg7dy5WrFgBAHjwwQfxxRdfYNu2bUhJSbHqeDiTYJB8fX0hl8v77CJ5+fJlBAQEDNOoyJLnn38e+/fvx+HDhzFu3DipPCAgAJ2dndBqtUbte8cyICDAZKwNdWQ95eXl0Gg0mDZtGpydneHs7Izi4mJs2rQJzs7O8Pf3ZzztyJgxYzB58mSjsgceeEDawdcQD0vvtQEBAX02jO3q6sKVK1cYTytatWqVNJsgJiYGmZmZWLFihTTjh7G0X0MVO7732hZDgqCxsRGFhYXSLAKA8bQnn3/+OTQaDYKDg6X7osbGRqxcuRKhoaEAGE974uvrC2dn537vjax1r8skwSC5uLhg+vTpKCoqksr0ej2KioqQmJg4jCOj2wkh8Pzzz2Pfvn04dOgQwsLCjOqnT58OhUJhFMu6ujo0NTVJsUxMTER1dbXRG6zhD+rtL2K6tx555BFUV1ejsrJS+omLi0NGRob0b8bTfiQlJfU5kvTcuXMICQkBAISFhSEgIMAoni0tLSgtLTWKp1arRXl5udTm0KFD0Ov1SEhIsMJVENCzY7qTk/HthFwul74VYSzt11DFLjExESUlJdDpdFKbwsJCTJo0yehEE7r3DAmC+vp6fPbZZxg1apRRPeNpPzIzM1FVVWV0XxQYGIhVq1bhwIEDABhPe+Li4oL4+HiL90ZW/ewy4C0OSbJnzx7h6uoq3n77bXHmzBmxePFioVKpjHaRpOG3dOlS4e3tLY4cOSKam5ulnxs3bkhtlixZIoKDg8WhQ4fEyZMnRWJiokhMTJTqu7q6RHR0tJg1a5aorKwUn376qRg9erT4zW9+MxyXRLfpfbqBEIynPSkrKxPOzs7iT3/6k6ivrxe7d+8W7u7u4p133pHa5ObmCpVKJT744ANRVVUl5s6dK8LCwkR7e7vUJj09XcTGxorS0lJx9OhRERERIRYsWDAcl3TfWrRokRg7dqzYv3+/aGhoEHv37hW+vr7ixRdflNowlrartbVVnDp1Spw6dUoAEK+99po4deqUtNv9UMROq9UKf39/kZmZKWpqasSePXuEu7u72L59u9Wv19FZimdnZ6eYM2eOGDdunKisrDS6N+q96znjaTv6e33e7vbTDYRgPG1Jf/Hcu3evUCgUYseOHaK+vl5s3rxZyOVy8fnnn0t9WOtel0mCO7R582YRHBwsXFxcxIwZM8Tx48eHe0h0GwAmf9566y2pTXt7u/jFL34hfHx8hLu7u3jyySdFc3OzUT8XLlwQjz32mHBzcxO+vr5i5cqVQqfTWflqyJTbkwSMp3358MMPRXR0tHB1dRWRkZFix44dRvV6vV7k5OQIf39/4erqKh555BFRV1dn1Oa///2vWLBggfD09BReXl7i2WefFa2trda8jPteS0uLWL58uQgODhZKpVKEh4eL3/3ud0YfOhhL23X48GGTfysXLVokhBi62H355ZciOTlZuLq6irFjx4rc3FxrXeJ9xVI8GxoazN4bHT58WOqD8bQd/b0+b2cqScB42o6BxPPNN98UEyZMEEqlUkydOlUUFBQY9WGte12ZEEIMfN4BERERERERETkq7klARERERERERACYJCAiIiIiIiKiW5gkICIiIiIiIiIATBIQERERERER0S1MEhARERERERERACYJiIiIiIiIiOgWJgmIiIiIiIiICACTBERERERERER0C5MERERERERERASASQIiIiIaJLVajRdeeAHh4eFwdXVFUFAQHn/8cRQVFVl1HDKZDAUFBVZ9TiIiIkfnPNwDICIiIvtx4cIFJCUlQaVSYcOGDYiJiYFOp8OBAweQlZWFs2fPDvcQiYiI6C7IhBBiuAdBRERE9uEHP/gBqqqqUFdXBw8PD6M6rVYLlUqFpqYmvPDCCygqKoKTkxPS09OxefNm+Pv7AwB+8pOfQKvVGs0CyM7ORmVlJY4cOQIA+P73v48pU6ZAqVTi73//O1xcXLBkyRK8/PLLAIDQ0FA0NjZKjw8JCcGFCxfu5aUTERHdF7jcgIiIiAbkypUr+PTTT5GVldUnQQAAKpUKer0ec+fOxZUrV1BcXIzCwkJ89dVXePrppwf9fDt37oSHhwdKS0uxfv16vPrqqygsLAQAnDhxAgDw1ltvobm5WfqdiIiI7g6XGxAREdGA/Oc//4EQApGRkWbbFBUVobq6Gg0NDQgKCgIA7Nq1C1FRUThx4gTi4+MH/HxTpkzBmjVrAAARERHYsmULioqK8Oijj2L06NEAehITAQEBd3FVRERE1BtnEhAREdGADGSFYm1tLYKCgqQEAQBMnjwZKpUKtbW1g3q+KVOmGP0+ZswYaDSaQfVBREREg8MkAREREQ1IREQEZDLZXW9O6OTk1CfhoNPp+rRTKBRGv8tkMuj1+rt6biIiIrKMSQIiIiIakJEjRyItLQ1bt25FW1tbn3qtVosHHngAFy9exMWLF6XyM2fOQKvVYvLkyQCA0aNHo7m52eixlZWVgx6PQqFAd3f3oB9HRERE5jFJQERERAO2detWdHd3Y8aMGXj//fdRX1+P2tpabNq0CYmJiUhNTUVMTAwyMjJQUVGBsrIyLFy4ECkpKYiLiwMAPPzwwzh58iR27dqF+vp6rFmzBjU1NYMeS2hoKIqKiqBWq3H16tWhvlQiIqL7EpMERERENGDh4eGoqKjAQw89hJUrVyI6OhqPPvooioqKkJeXB5lMhg8++AA+Pj6YOXMmUlNTER4ejvz8fKmPtLQ05OTk4MUXX0R8fDxaW1uxcOHCQY9l48aNKCwsRFBQEGJjY4fyMomIiO5bMjGQXYiIiIiIiIiIyOFxJgERERERERERAWCSgIiIiIiIiIhuYZKAiIiIiIiIiAAwSUBEREREREREtzBJQEREREREREQAmCQgIiIiIiIioluYJCAiIiIiIiIiAEwSEBEREREREdEtTBIQEREREREREQAmCYiIiIiIiIjoFiYJiIiIiIiIiAgA8D/GZvk0jMXf3AAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "aRH8v3GWYp15"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "YQyocWkdYp5C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "HSlMu13KZ0tF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Data Cleaning</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Handle Missing Values</span>\n",
        "\n",
        "- **Drop Missing Texts**: Remove rows where the 'text' column has missing values to ensure that all entries are valid for further processing.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Clean and Normalize Text</span>\n",
        "\n",
        "- **Text Normalization**: Convert all text entries to lowercase and strip leading/trailing spaces. This standardization helps in reducing inconsistencies and improves the performance of text analysis.\n",
        "\n",
        "### <span style=\"color: #9b59b6;\">3. Updated Data Inspection</span>\n",
        "\n",
        "- **Recheck Data Information**: After cleaning, review the dataset info again using `.info()` to ensure all missing values are handled and the data types are correct.\n",
        "- **Preview Cleaned Data**: Use `.head()` to display the first few rows of the cleaned dataset to verify that the cleaning operations were successful.\n",
        "\n",
        "### <span style=\"color: #f39c12;\">4. Plot Updated Distribution of Text Lengths</span>\n",
        "\n",
        "- **Recalculate Text Lengths**: Update the column for text lengths after cleaning.\n",
        "- **Visualization**: Plot the distribution of text lengths again to observe any changes in the data characteristics post-cleaning."
      ],
      "metadata": {
        "id": "H4oVno1fZ06D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Handle missing values and clean the text"
      ],
      "metadata": {
        "id": "POkLkkvmYp8J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines = lines.dropna(subset=['text'])  # Drop rows where 'text' column has missing values"
      ],
      "metadata": {
        "id": "W8mi0UReYp-1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines['text'] = lines['text'].apply(lambda x: x.lower().strip())  # Convert text to lowercase and strip spaces\n"
      ],
      "metadata": {
        "id": "BjcromedYqBP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cMjT9vmLYqEM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "5iXJOB-GYk1I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Show updated dataset info and first few rows"
      ],
      "metadata": {
        "id": "B6BhHvrxYeAh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\\nUpdated Dataset info:\")  # Print a description for the following data\n",
        "print(lines.info())  # Print updated dataset info"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L9-4R8qdYGfv",
        "outputId": "5d78270d-5309-48d7-f79d-ed63b4a7db78"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Updated Dataset info:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 293202 entries, 0 to 293201\n",
            "Data columns (total 6 columns):\n",
            " #   Column       Non-Null Count   Dtype \n",
            "---  ------       --------------   ----- \n",
            " 0   lineID       293202 non-null  object\n",
            " 1   characterID  288917 non-null  object\n",
            " 2   movieID      288917 non-null  object\n",
            " 3   character    288874 non-null  object\n",
            " 4   text         293202 non-null  object\n",
            " 5   text_length  293202 non-null  int64 \n",
            "dtypes: int64(1), object(5)\n",
            "memory usage: 13.4+ MB\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "h7EpAOPzYGhE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "t-ahK4-fYGkp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\\nFirst few rows of the cleaned dataset:\")  # Print a description for the following data\n",
        "print(lines.head())  # Print first few rows of the cleaned dataset"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5b8LWGNlX_Dy",
        "outputId": "f6d3b063-6268-4d7b-b92b-084246cd1b70"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "First few rows of the cleaned dataset:\n",
            "  lineID characterID movieID character          text  text_length\n",
            "0  L1045          u0      m0    BIANCA  they do not!           12\n",
            "1  L1044          u2      m0   CAMERON   they do to!           11\n",
            "2   L985          u0      m0    BIANCA    i hope so.           10\n",
            "3   L984          u2      m0   CAMERON     she okay?            9\n",
            "4   L925          u0      m0    BIANCA     let's go.            9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wbNmK2A5Y3wn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pN16CyJFY3zb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the updated distribution of text lengths"
      ],
      "metadata": {
        "id": "qDkQAz71Y34c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines['text_length'] = lines['text'].apply(lambda x: len(x) if isinstance(x, str) else 0)  # Recalculate text length\n",
        "plt.figure(figsize=(10, 6))  # Set the figure size for the plot\n",
        "sns.histplot(lines['text_length'], bins=50, kde=True)  # Plot updated distribution of text lengths with histogram and KDE\n",
        "plt.title('Updated Distribution of Text Lengths')  # Set the title of the plot\n",
        "plt.xlabel('Length of Text')  # Set the x-axis label\n",
        "plt.ylabel('Frequency')  # Set the y-axis label\n",
        "plt.show()  # Display the plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 528
        },
        "id": "0PHU4TYkY37t",
        "outputId": "c6524150-aa58-41b8-dc20-5018c9b5b31b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Czub68H3ZGa5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "4H-WYSzcZGeO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "MlnPIkr_cUy_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Selecting a Small Subset</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Rationale</span>\n",
        "\n",
        "- **Efficiency**: Working with a smaller subset of the dataset helps in speeding up the model training and evaluation processes, especially important when computing resources are limited.\n",
        "- **Debugging**: Using a subset allows for quicker iteration and easier debugging of the code and model, helping identify and resolve issues more efficiently.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Criteria for Selection</span>\n",
        "\n",
        "- **Random Sampling**: Select a random sample of the data to ensure it is representative of the larger dataset, minimizing biases.\n",
        "- **Balanced Distribution**: Ensure that the subset maintains the distribution of different classes or categories present in the full dataset.\n",
        "\n",
        "### <span style=\"color: #f39c12;\">3. Implementation Steps</span>\n",
        "\n",
        "1. **Determine Sample Size**: Decide on the size of the subset based on computational constraints and project requirements.\n",
        "2. **Sampling Method**: Use techniques such as random sampling or stratified sampling to select the subset.\n",
        "3. **Data Extraction**: Extract the selected subset and save it as a separate file or variable for use in the analysis.\n",
        "\n",
        "### <span style=\"color: #e67e22;\">4. Benefits</span>\n",
        "\n",
        "- **Faster Execution**: Reduces the time required for model training and evaluation, allowing for more rapid experimentation.\n",
        "- **Resource Management**: Helps in managing computational resources more effectively, particularly in environments with limited hardware capabilities.\n",
        "\n",
        "### <span style=\"color: #16a085;\">5. Example</span>\n",
        "\n",
        "- **Subset Size**: For example, if working with a dataset of 100,000 samples, selecting a subset of 10,000 samples can be a manageable size for initial testing and development.\n",
        "- **Process**:\n",
        "  - Load the full dataset.\n",
        "  - Randomly sample a specified number of rows.\n",
        "  - Save the subset for use in the project."
      ],
      "metadata": {
        "id": "vSUJE5jicVIu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load a smaller subset of the dataset"
      ],
      "metadata": {
        "id": "Mvl384odZGj7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "subset_size = 1000  # Reduce the size for testing"
      ],
      "metadata": {
        "id": "ybpsnbT3ZGmu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines = pd.read_csv(dataset_path, sep='\\t', nrows=subset_size, on_bad_lines='skip', names=['lineID', 'characterID', 'movieID', 'character', 'text'])  # Load a smaller subset\n"
      ],
      "metadata": {
        "id": "HN57J-0_ZGpF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "WAUI2VACZOEj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "aKtMFGV-ZOHk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Handle missing values"
      ],
      "metadata": {
        "id": "U00xIp9pZOKM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines['text'] = lines['text'].fillna('')  # Replace NaNs with empty strings"
      ],
      "metadata": {
        "id": "amDKA23nZOM8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines['text'] = lines['text'].astype(str)  # Ensure all values are strings"
      ],
      "metadata": {
        "id": "5vpwoEX-ZGvC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "kXRuPWxDY3_Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert text to lowercase and strip leading/trailing spaces"
      ],
      "metadata": {
        "id": "km6M10qwY4CW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lines['text'] = lines['text'].apply(lambda x: x.lower().strip())  # Convert text to lowercase and strip spaces\n"
      ],
      "metadata": {
        "id": "nbOIBaceZYri"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Y3hgKRBiZYul"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wiTXNwoyZYz6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "r8wNtiaXZ9Wk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Tokenization</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Initialize Tokenizer</span>\n",
        "\n",
        "- **Tokenizer Setup**: Create an instance of the `Tokenizer` class from TensorFlow's Keras library. This tokenizer will be used to convert text into sequences of integers.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Fit Tokenizer on Text Data</span>\n",
        "\n",
        "- **Vocabulary Building**: Use the `fit_on_texts` method to process the text data and build the vocabulary. This method updates the internal word-to-index mapping based on the text data provided.\n",
        "\n",
        "### <span style=\"color: #9b59b6;\">3. Calculate Vocabulary Size</span>\n",
        "\n",
        "- **Determine Vocabulary Size**: Calculate the total number of unique tokens in the dataset, including an extra token for unknown words. This is done using the length of the tokenizer’s `word_index` dictionary plus one.\n",
        "\n",
        "### <span style=\"color: #f39c12;\">4. Plot Token Frequency Distribution</span>\n",
        "\n",
        "- **Word Frequency Analysis**: Create a DataFrame of word counts from the tokenizer’s `word_counts` attribute.\n",
        "- **Visualization**: Plot the top 20 most frequent words to understand the distribution and prominence of words in the dataset."
      ],
      "metadata": {
        "id": "0VqsD_QaZ9fj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tokenization"
      ],
      "metadata": {
        "id": "BaV6ye1PZY3E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tokenizer = Tokenizer()  # Initialize the tokenizer"
      ],
      "metadata": {
        "id": "sEhDSGEwZY5G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tokenizer.fit_on_texts(lines['text'])  # Fit tokenizer on the text data"
      ],
      "metadata": {
        "id": "xNlt4BA1ZY9P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "num_tokens = len(tokenizer.word_index) + 1  # Calculate vocabulary size"
      ],
      "metadata": {
        "id": "lZZKlD-wZY_m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "yg3nOdoaZpQp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "qDMt79zmZpTp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the distribution of token frequencies"
      ],
      "metadata": {
        "id": "Df_i4CSZZpXZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "word_counts = pd.DataFrame(tokenizer.word_counts.items(), columns=['Word', 'Count'])  # Create DataFrame of word counts\n",
        "plt.figure(figsize=(12, 6))  # Set the figure size for the plot\n",
        "sns.barplot(x='Count', y='Word', data=word_counts.sort_values(by='Count', ascending=False).head(20))  # Plot top 20 most frequent words\n",
        "plt.title('Top 20 Most Frequent Words')  # Set the title of the plot\n",
        "plt.xlabel('Frequency')  # Set the x-axis label\n",
        "plt.ylabel('Word')  # Set the y-axis label\n",
        "plt.show()  # Display the plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 459
        },
        "id": "jyKgQgDjZpZf",
        "outputId": "1652660c-5036-4dbd-898c-a843535b8605"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "4VK-dewEZuox"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "q22E5eeMZur-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert dialogues to sequences"
      ],
      "metadata": {
        "id": "rgl_TtjxZuvN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tokenized_dialogues = tokenizer.texts_to_sequences(lines['text'])  # Convert text to sequences of integers\n"
      ],
      "metadata": {
        "id": "kDF7ddZRZuxx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "KszP23fbZpb_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "YiAPZK9caifA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Padding Sequences</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Determine Maximum Sequence Length</span>\n",
        "\n",
        "- **Calculate Maximum Length**: Identify the maximum length of the sequences in the dataset by evaluating the length of each sequence. This ensures that all sequences are padded to a uniform length.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Pad Sequences</span>\n",
        "\n",
        "- **Uniform Length**: Use the `pad_sequences` function to pad sequences to the maximum length determined in the previous step. Padding is applied to ensure that all sequences have the same length, which is crucial for training models that require fixed-size inputs.\n",
        "- **Padding Strategy**: Apply padding at the end of sequences (`padding='post'`) to maintain the sequence structure and consistency.\n",
        "\n",
        "### <span style=\"color: #9b59b6;\">3. Plot Sequence Length Distribution</span>\n",
        "\n",
        "- **Visualize Lengths**: Plot a histogram of the lengths of padded sequences to visualize the distribution and verify the effectiveness of the padding process."
      ],
      "metadata": {
        "id": "upDNN_tUait0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Padding sequences"
      ],
      "metadata": {
        "id": "q-ISGz3mZpeE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "max_sequence_len = max([len(x) for x in tokenized_dialogues])  # Determine the maximum sequence length\n"
      ],
      "metadata": {
        "id": "hZJBuSsZZpgf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "input_sequences = pad_sequences(tokenized_dialogues, maxlen=max_sequence_len, padding='post')  # Pad sequences to ensure uniform length\n"
      ],
      "metadata": {
        "id": "saGLIA1AZ5g6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "IN9w0Y7kZ8ia"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "KeiCDbqYZ8lR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the distribution of sequence lengths"
      ],
      "metadata": {
        "id": "y1mcwcV1Z8qJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(10, 6))  # Set the figure size for the plot\n",
        "sns.histplot([len(seq) for seq in tokenized_dialogues], bins=50, kde=True)  # Plot distribution of sequence lengths\n",
        "plt.title('Distribution of Sequence Lengths')  # Set the title of the plot\n",
        "plt.xlabel('Sequence Length')  # Set the x-axis label\n",
        "plt.ylabel('Frequency')  # Set the y-axis label\n",
        "plt.show()  # Display the plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 543
        },
        "id": "xomzI7AuZ8tX",
        "outputId": "238a6000-46f1-4e14-cefb-afeedb17dbd5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "lreTct4fZ8vu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "uf2AYIeoZ8zz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Prepare target sequences (shift input sequences by one timestep)"
      ],
      "metadata": {
        "id": "6N5AHzohZ5j1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "target_sequences = np.roll(input_sequences, shift=-1, axis=1)  # Shift sequences by one timestep"
      ],
      "metadata": {
        "id": "2D_peBc0Z5ol"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "target_sequences[-1, -1] = 0  # Set the last token to 0 as it's not valid"
      ],
      "metadata": {
        "id": "K0AEh4iuZ5vC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "0MN0jiYiaIWV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "TdBUXIJ_aIZW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2QPFHmqJanzE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Model Architecture</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Encoder</span>\n",
        "\n",
        "- **Inputs**: Define the input layer for the encoder. This layer accepts sequences of varying lengths.\n",
        "- **Embedding Layer**: Apply an `Embedding` layer to convert integer-encoded sequences into dense vectors of fixed size.\n",
        "- **LSTM Layer**: Use an `LSTM` layer to process the embedded sequences and generate the internal state vectors. The LSTM layer captures temporal dependencies in the sequences.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Decoder</span>\n",
        "\n",
        "- **Inputs**: Define the input layer for the decoder, which will take sequences as input during training and inference.\n",
        "- **Embedding Layer**: Apply an `Embedding` layer to the decoder inputs to transform them into dense vectors.\n",
        "- **LSTM Layer**: Use an `LSTM` layer in the decoder to handle the sequence generation, utilizing the states from the encoder to produce the output sequences.\n",
        "- **Dense Layer**: Apply a `Dense` layer with a softmax activation function to generate probability distributions over the vocabulary for each token in the sequence.\n",
        "\n",
        "### <span style=\"color: #9b59b6;\">3. Model Definition</span>\n",
        "\n",
        "- **Model Creation**: Define the `Model` by combining the encoder and decoder components, specifying the inputs and outputs.\n",
        "- **Compilation**: Compile the model using an optimizer (`rmsprop`) and a loss function (`categorical_crossentropy`), setting the metrics for evaluation (`accuracy`)."
      ],
      "metadata": {
        "id": "pZGdXr-IaoF8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Encoder"
      ],
      "metadata": {
        "id": "Sl5pmX8saIcA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "latent_dim = 64  # Reduce dimensionality for LSTM"
      ],
      "metadata": {
        "id": "NORiDdSnaIgd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "encoder_inputs = Input(shape=(None,))  # Define input layer for encoder"
      ],
      "metadata": {
        "id": "ibuqd5_KaInr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "enc_emb = Embedding(num_tokens, latent_dim, mask_zero=True)(encoder_inputs)  # Embedding layer for encoder\n"
      ],
      "metadata": {
        "id": "sVpuBn8DaIrE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "encoder_lstm = LSTM(latent_dim, return_state=True)  # Define LSTM layer for encoder"
      ],
      "metadata": {
        "id": "rD0AQuiaaSvC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "encoder_outputs, state_h, state_c = encoder_lstm(enc_emb)  # Get encoder outputs and states"
      ],
      "metadata": {
        "id": "JboDzgsOaSyT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "encoder_states = [state_h, state_c]  # Store encoder states"
      ],
      "metadata": {
        "id": "Y2X8ecuTaS1c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "JTWBge-FaaGP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "AH7N6DGMaaJZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Decoder"
      ],
      "metadata": {
        "id": "XH7EL4xWaaMM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_inputs = Input(shape=(None,))  # Define input layer for decoder"
      ],
      "metadata": {
        "id": "PjyvS75daaOm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dec_emb_layer = Embedding(num_tokens, latent_dim, mask_zero=True)  # Embedding layer for decoder"
      ],
      "metadata": {
        "id": "1FZLR9PaaaRb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dec_emb = dec_emb_layer(decoder_inputs)  # Apply embedding layer to decoder inputs"
      ],
      "metadata": {
        "id": "a0afus9eaaUO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)  # Define LSTM layer for decoder\n"
      ],
      "metadata": {
        "id": "t4YQ2NcfaS33"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_outputs, _, _ = decoder_lstm(dec_emb, initial_state=encoder_states)  # Get decoder outputs and states\n"
      ],
      "metadata": {
        "id": "zt_RbSi2aS7e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_dense = Dense(num_tokens, activation='softmax')  # Dense layer for output"
      ],
      "metadata": {
        "id": "oQRCssAsanCb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_outputs = decoder_dense(decoder_outputs)  # Apply dense layer to decoder outputs"
      ],
      "metadata": {
        "id": "D7b34zkLanFh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wq3g1su1anN7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "LUxClKlmanQy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the model"
      ],
      "metadata": {
        "id": "7ccfrPfBanU5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = Model([encoder_inputs, decoder_inputs], decoder_outputs)  # Build the model"
      ],
      "metadata": {
        "id": "FHVLO8SSanX7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "LmBvw5Hlav3q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "AeH9GXGWa0oD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile the model"
      ],
      "metadata": {
        "id": "4peR-9LGav6r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])  # Compile the model with optimizer and loss function\n"
      ],
      "metadata": {
        "id": "g_fFl0zHav_S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "1fgWP5n0awDp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "zm1d69q5awGT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "yaoT5sOnbD7f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Training Visualization</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Training and Validation Loss</span>\n",
        "\n",
        "- **Plotting Loss**: Create a plot to visualize the training and validation loss over epochs. This helps in understanding how well the model is learning and whether it's overfitting or underfitting.\n",
        "- **Graph Details**:\n",
        "  - **X-Axis**: Epochs, representing the number of training iterations.\n",
        "  - **Y-Axis**: Loss, indicating the performance of the model on the training and validation datasets.\n",
        "  - **Training Loss Curve**: Represents the loss on the training dataset.\n",
        "  - **Validation Loss Curve**: Represents the loss on the validation dataset.\n",
        "- **Insights**: Examine the curves to assess the model's learning progress. A decreasing loss indicates effective training, while a diverging validation loss might suggest overfitting.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Visualization Details</span>\n",
        "\n",
        "- **Figure Size**: Set a figure size (e.g., `12x6`) for clear visibility.\n",
        "- **Plot Labels**: Add appropriate labels for the x-axis, y-axis, and title.\n",
        "- **Legend**: Include a legend to distinguish between training and validation loss curves.\n",
        "- **Display**: Use `plt.show()` to render the plot for visual inspection."
      ],
      "metadata": {
        "id": "eUQI5odmbEKl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model"
      ],
      "metadata": {
        "id": "9AVUUcUCawJ-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit([input_sequences, input_sequences], target_sequences_one_hot,\n",
        "                    batch_size=16, epochs=3, validation_split=0.2)  # Adjusted parameters\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HRZ8gy0fawMi",
        "outputId": "fb5710c1-32d6-422f-a4be-3e0257fe2411"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/3\n",
            "\u001b[1m50/50\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 97ms/step - accuracy: 0.8439 - loss: 5.7425 - val_accuracy: 0.8310 - val_loss: 5.9372\n",
            "Epoch 2/3\n",
            "\u001b[1m50/50\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 144ms/step - accuracy: 0.8482 - loss: 5.6914 - val_accuracy: 0.8310 - val_loss: 5.8971\n",
            "Epoch 3/3\n",
            "\u001b[1m50/50\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 96ms/step - accuracy: 0.8502 - loss: 5.6140 - val_accuracy: 0.8310 - val_loss: 5.8587\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_HRZ59zhbhnd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "R9oVhrepbhqb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot training & validation loss"
      ],
      "metadata": {
        "id": "DX9JG35BbhyZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(12, 6))  # Set the figure size for the plot\n",
        "plt.plot(history.history['loss'], label='Training Loss')  # Plot training loss\n",
        "plt.plot(history.history['val_loss'], label='Validation Loss')  # Plot validation loss\n",
        "plt.title('Model Loss')  # Set the title of the plot\n",
        "plt.xlabel('Epoch')  # Set the x-axis label\n",
        "plt.ylabel('Loss')  # Set the y-axis label\n",
        "plt.legend()  # Show legend\n",
        "plt.show()  # Display the plot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 460
        },
        "id": "mnYt0UFGbh0t",
        "outputId": "694de01c-4d01-4c17-fb4b-7c61e0000745"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "3Bac_TqfcpGJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Tenevpd-cpJY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "NDLyldBKcpMr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Inference Models</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Encoder Model</span>\n",
        "\n",
        "- **Purpose**: Encodes the input sequences into a fixed-size context vector, which captures the relevant information needed for decoding.\n",
        "- **Architecture**:\n",
        "  - **Input Layer**: Receives the sequence of integers representing the input dialogue.\n",
        "  - **Embedding Layer**: Converts input integers into dense vectors of fixed size.\n",
        "  - **LSTM Layer**: Processes the embedded input sequences and outputs hidden states and cell states.\n",
        "  - **Output**: Encoder states (hidden and cell) are used as initial states for the decoder.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Decoder Model</span>\n",
        "\n",
        "- **Purpose**: Generates sequences based on the context vector provided by the encoder.\n",
        "- **Architecture**:\n",
        "  - **Input Layer**: Receives the sequence of integers representing the decoder inputs.\n",
        "  - **Embedding Layer**: Converts input integers into dense vectors of fixed size.\n",
        "  - **LSTM Layer**: Processes the embedded decoder inputs along with the encoder states and outputs predictions and updated states.\n",
        "  - **Dense Layer**: Produces probabilities for each token in the vocabulary for each timestep in the sequence.\n",
        "- **Output**: Generates sequences of tokens, which are the model's predictions.\n",
        "\n",
        "### <span style=\"color: #f39c12;\">3. Model Integration</span>\n",
        "\n",
        "- **Inference Models**:\n",
        "  - **Encoder Model**: Used to encode input sequences into context vectors.\n",
        "  - **Decoder Model**: Used to generate sequences based on the encoded context vector.\n",
        "  - **Input**: The decoder takes initial tokens and the encoder states to generate the output sequence.\n",
        "\n",
        "### <span style=\"color: #e67e22;\">4. Sampling Function</span>\n",
        "\n",
        "- **Function**: `decode_sequence(input_seq)`\n",
        "  - **Purpose**: To generate a decoded sentence from an input sequence by sampling tokens.\n",
        "  - **Process**:\n",
        "    - Predict encoder states from the input sequence.\n",
        "    - Initialize the target sequence with the start token.\n",
        "    - Use the decoder model to generate tokens one-by-one until an end token is sampled or the maximum sequence length is reached.\n",
        "    - Construct the final decoded sentence from the sampled tokens."
      ],
      "metadata": {
        "id": "xH_6GQzHbLup"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define inference models for encoder and decoder"
      ],
      "metadata": {
        "id": "PfURMf-1bh3E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "encoder_model = Model(encoder_inputs, encoder_states)  # Build encoder model"
      ],
      "metadata": {
        "id": "6ZtnKkDLbh5b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_state_input_h = Input(shape=(latent_dim,))  # Define input for decoder hidden state"
      ],
      "metadata": {
        "id": "KiBgCIYBbuPX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_state_input_c = Input(shape=(latent_dim,))  # Define input for decoder cell state"
      ],
      "metadata": {
        "id": "dJy48OPpbuSj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]  # Define decoder states inputs\n"
      ],
      "metadata": {
        "id": "vNxuaw22buX9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dec_emb2 = dec_emb_layer(decoder_inputs)  # Apply embedding layer to decoder inputs"
      ],
      "metadata": {
        "id": "N_VHafTsbubE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_outputs2, state_h2, state_c2 = decoder_lstm(dec_emb2, initial_state=decoder_states_inputs)  # Get decoder outputs and states\n"
      ],
      "metadata": {
        "id": "3Z6g80iybh73"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_states2 = [state_h2, state_c2]  # Store decoder states"
      ],
      "metadata": {
        "id": "s8HPr1xgbh-6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_outputs2 = decoder_dense(decoder_outputs2)  # Apply dense layer to decoder outputs"
      ],
      "metadata": {
        "id": "VhMatzngc3VD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoder_model = Model([decoder_inputs] + decoder_states_inputs, [decoder_outputs2] + decoder_states2)  # Build decoder inference model\n"
      ],
      "metadata": {
        "id": "fbtWt_2Yc3Yp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "NJvwqG00c3a9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ih3yNYWec3dk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "MCSL9THHbSxs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Decoding Function</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Purpose</span>\n",
        "\n",
        "- **Objective**: To convert model-generated token sequences into human-readable text.\n",
        "- **Functionality**: Takes the output sequences from the decoder model and maps them back to words or tokens.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Implementation Details</span>\n",
        "\n",
        "- **Function**: `decode_sequence(input_seq)`\n",
        "  - **Input**: Encoded input sequence.\n",
        "  - **Process**:\n",
        "    - **Encoder Processing**:\n",
        "      - Encode the input sequence to obtain context vectors.\n",
        "    - **Initialization**:\n",
        "      - Start with an initial token (e.g., start token) for the decoder.\n",
        "      - Use encoder outputs as initial states for the decoder.\n",
        "    - **Decoding Loop**:\n",
        "      - Predict the next token in the sequence using the decoder.\n",
        "      - Append the predicted token to the sequence.\n",
        "      - Update the decoder's internal states.\n",
        "      - Repeat until an end token is generated or the maximum sequence length is reached.\n",
        "    - **Post-Processing**:\n",
        "      - Convert the sequence of tokens into text using a reverse mapping (e.g., token-to-word dictionary).\n",
        "  - **Output**: Generated sequence of tokens converted into a readable string.\n",
        "\n",
        "### <span style=\"color: #f39c12;\">3. Example Usage</span>\n",
        "\n",
        "- **Scenario**: Given an input sequence, use the `decode_sequence` function to obtain the decoded output.\n",
        "  - **Input**: An encoded sequence from the encoder model.\n",
        "  - **Output**: A decoded sentence representing the model's prediction.\n",
        "\n",
        "### <span style=\"color: #e67e22;\">4. Notes</span>\n",
        "\n",
        "- Ensure the start token and end token are properly defined and managed during decoding.\n",
        "- Handle the maximum sequence length to avoid excessively long output sequences.\n",
        "- Implement mechanisms to handle special cases, such as unknown or out-of-vocabulary tokens."
      ],
      "metadata": {
        "id": "dxYyV2AYbS7e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Sampling function"
      ],
      "metadata": {
        "id": "wY8eCgW4c3gJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def decode_sequence(input_seq):\n",
        "    states_value = encoder_model.predict(input_seq)  # Predict encoder states\n",
        "    target_seq = np.zeros((1, 1))  # Initialize target sequence\n",
        "    start_token = tokenizer.word_index.get('startseq', 0)  # Get start token index or use 0 if not found\n",
        "    target_seq[0, 0] = start_token  # Set start token\n",
        "\n",
        "    stop_condition = False  # Initialize stop condition\n",
        "    decoded_sentence = ''  # Initialize decoded sentence\n",
        "\n",
        "    while not stop_condition:\n",
        "        output_tokens, h, c = decoder_model.predict([target_seq] + states_value)  # Predict decoder outputs and states\n",
        "        sampled_token_index = np.argmax(output_tokens[0, -1, :])  # Get the most likely token\n",
        "        sampled_char = tokenizer.index_word.get(sampled_token_index, '')  # Convert token to character\n",
        "        decoded_sentence += ' ' + sampled_char  # Append character to the decoded sentence\n",
        "\n",
        "        if sampled_char == 'endseq' or len(decoded_sentence) > max_sequence_len:  # Check stop condition\n",
        "            stop_condition = True\n",
        "\n",
        "        target_seq = np.zeros((1, 1))  # Update target sequence\n",
        "        target_seq[0, 0] = sampled_token_index  # Set next token\n",
        "\n",
        "    return decoded_sentence.strip()  # Return the decoded sentence\n"
      ],
      "metadata": {
        "id": "cc2FTYrpc3ip"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "03xfRgCxdDlz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wX6KX4SadDpP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "AWJeFc90bXw9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Model Testing</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Purpose</span>\n",
        "\n",
        "- **Objective**: To evaluate the performance of the trained model on sample inputs.\n",
        "- **Functionality**: Tests the model's ability to generate accurate and coherent outputs based on given input sequences.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Implementation Details</span>\n",
        "\n",
        "- **Process**:\n",
        "  - **Sample Input Selection**:\n",
        "    - Choose a sample input sequence from the dataset for testing.\n",
        "  - **Decoding**:\n",
        "    - Use the `decode_sequence` function to generate a human-readable output from the sample input.\n",
        "  - **Evaluation**:\n",
        "    - Assess the quality of the generated output to determine if it aligns with expected results or makes sense in context.\n",
        "  - **Output Display**:\n",
        "    - Print or visualize the decoded sentence to verify the model's performance.\n",
        "\n",
        "### <span style=\"color: #f39c12;\">3. Example Usage</span>\n",
        "\n",
        "- **Scenario**: Given a sample input sequence, use the model to decode and generate a prediction.\n",
        "  - **Input**: A pre-processed input sequence from the dataset.\n",
        "  - **Output**: The decoded sentence or sequence produced by the model.\n",
        "\n",
        "### <span style=\"color: #e67e22;\">4. Notes</span>\n",
        "\n",
        "- Test with various samples to ensure the model performs well across different scenarios.\n",
        "- Validate the model's ability to handle edge cases and generate coherent responses.\n",
        "- Consider using metrics such as BLEU score or human evaluation for a more comprehensive assessment of model performance."
      ],
      "metadata": {
        "id": "tFTcnt_ibYH_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Test the model with a sample input"
      ],
      "metadata": {
        "id": "cpmpGyhUc3k2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_input = input_sequences[0:1]  # Sample input for testing"
      ],
      "metadata": {
        "id": "sZQE9P_TdH7D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "decoded_sentence = decode_sequence(test_input)  # Decode the input sequence"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dyg8cNlvdH-v",
        "outputId": "e52df38f-7d13-43d3-8efc-e5f66d1085dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 53ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 57ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 57ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 38ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 40ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 39ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 26ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 23ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 32ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 26ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 37ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 31ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 28ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 32ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 28ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 39ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 36ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 37ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 46ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 96ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 47ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 46ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 41ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 41ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 41ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 26ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 23ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 23ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 30ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 26ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 30ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 36ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 24ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 26ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 23ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 28ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 34ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 26ms/step\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"\\nDecoded sentence: {decoded_sentence}\")  # Print the decoded sentence"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sJIwL_DBdZpc",
        "outputId": "ded35928-87f0-475b-9f8a-0c26271bd2c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Decoded sentence: \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "dBjUBFh1dZsa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cqMPwAQOeJPE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "0QzQgVJ5beJw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <span style=\"color: #3498db;\">Conclusions</span>\n",
        "\n",
        "### <span style=\"color: #2ecc71;\">1. Model Performance</span>\n",
        "\n",
        "- **Accuracy**: The model demonstrates its ability to effectively generate coherent and contextually relevant sequences based on input data.\n",
        "- **Training Results**: The training and validation loss curves show how well the model has learned from the data, with improvements in loss over epochs indicating successful training.\n",
        "\n",
        "### <span style=\"color: #e74c3c;\">2. Insights and Findings</span>\n",
        "\n",
        "- **Data Patterns**: Analyzing text lengths and word frequencies provided insights into the dataset's structure and content distribution.\n",
        "- **Tokenization Impact**: Tokenization and padding steps ensured that the model could handle varying lengths of input sequences, providing uniformity for the training process.\n",
        "\n",
        "### <span style=\"color: #f39c12;\">3. Model Limitations</span>\n",
        "\n",
        "- **Generalization**: The model's performance on unseen data or edge cases should be further evaluated to ensure it generalizes well beyond the training set.\n",
        "- **Data Quality**: The quality and variety of the input data can impact the model's ability to generate accurate outputs. Ensuring a diverse and representative dataset is crucial.\n",
        "\n",
        "### <span style=\"color: #e67e22;\">4. Future Work</span>\n",
        "\n",
        "- **Model Enhancements**: Explore additional architectures or fine-tuning techniques to improve the model's accuracy and generate more nuanced outputs.\n",
        "- **Data Augmentation**: Incorporate more diverse and extensive datasets to enhance the model's robustness and adaptability.\n",
        "- **Evaluation Metrics**: Implement advanced evaluation metrics and human evaluations to better assess the model's performance and ensure its effectiveness in real-world applications.\n",
        "\n",
        "### <span style=\"color: #16a085;\">5. Summary</span>\n",
        "\n",
        "- **Overall**, the project successfully built and trained a sequence-to-sequence model capable of generating meaningful outputs from input sequences. Further improvements and evaluations will enhance its applicability and performance."
      ],
      "metadata": {
        "id": "A65ZYzEObenQ"
      }
    }
  ]
}