data_download_and_prep.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "Load Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import time\n",
    "import random\n",
    "import requests\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from matplotlib import pyplot as plt\n",
    "from typing import Optional, List, Tuple\n",
    "\n",
    "from sklearn.feature_extraction.text import ENGLISH_STOP_WORDS, CountVectorizer\n",
    "\n",
    "# see https://spacy.io/usage for proper spacy installation\n",
    "import spacy\n",
    "from spacy.lang.en import STOP_WORDS\n",
    "\n",
    "nlp = spacy.load('en_core_web_sm')  # load text processing pipeline from spacy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data\n",
    "\n",
    "The data we will use can be found [here](https://cogcomp.seas.upenn.edu/Data/QA/QC/). The dataset comprises three variables: `question`, `category`, and `sub-category`. However, our analysis will only use two variables: `question` and `category`. Essentially, we will build a model that uses the content of the question to predict its category. For example, (e.g. Who was Abraham Lincon?) and the output or label would be Human. There are six disnnct categories in the dataset:\n",
    "\n",
    "1. ENTY (Entity): Questions that seek specific entities as answers, like objects, organisms, or concepts.\n",
    "2. HUM (Human): Questions about humans, individually or as a group.\n",
    "3. DESC (Description): Questions asking for description, explanations, or reasons.\n",
    "4. Num (Numeric): Questions expecting numerical answer.\n",
    "4. LOC (Locanon): Questions that are geographically oriented.\n",
    "6. ABBR (Abbreviation): Questions seeking the extended form or explanation of abbreviations.\n",
    "\n",
    "For this work, we will use the Training Set 5 dataset for training the model and the single test set available for testing the model.\n",
    "\n",
    "We will now create the data download utility function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir_name = './data'\n",
    "os.makedirs(dir_name, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def download_data(dir_name: str, filename: str, url: str, expected_bytes: Optional[int]=None) -> str:\n",
    "    \"\"\"\n",
    "    Download a file if not present, and make sure it's the right size if the expected size is provided.\n",
    "    \n",
    "    Args:\n",
    "        dir_name (str): The directory where the data will be stored.\n",
    "        filename (str): The filename under which the data will be stored.\n",
    "        url (str): The URL from which to download the data.\n",
    "        expected_bytes (Optional[int]): The expected size of the data in bytes. \n",
    "                                        If provided, the function will check if the downloaded file size matches this.\n",
    "                                        If not, an exception will be raised.\n",
    "                                        If not provided, no size check will be performed.\n",
    "                                        \n",
    "    Returns:\n",
    "        str: The file path where the data is stored.\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # Define the filepath\n",
    "    filepath = os.path.join(dir_name, filename)\n",
    "\n",
    "    # Download the file if it doesn't already exist\n",
    "    if not os.path.exists(filepath):\n",
    "        response = requests.get(url)\n",
    "        with open(filepath, 'wb') as f:\n",
    "            # Write the content of the response to filepath\n",
    "            f.write(response.content)\n",
    "\n",
    "    # If an expected size is provided, verify the size of the downloaded file\n",
    "    if expected_bytes is not None:   \n",
    "        statinfo = os.stat(filepath)\n",
    "        if statinfo.st_size == expected_bytes:\n",
    "            print(f'Found and verified {filepath}')\n",
    "        else:\n",
    "            print(f'File size {statinfo.st_size} does not match expected size {expected_bytes}')\n",
    "            raise Exception(\n",
    "              f'Failed to verify {filepath}. Can you get to it with a browser?')\n",
    "    \n",
    "    # Return the filepath for use elsewhere\n",
    "    return filepath\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found and verified data/train_5500.label\n",
      "Found and verified data/TREC_10.label\n"
     ]
    }
   ],
   "source": [
    "# Download the data.\n",
    "url = 'http://cogcomp.org/Data/QA/QC/'\n",
    "dir_name = 'data'\n",
    "train_filename = download_data(dir_name, 'train_5500.label', url+'train_5500.label', 335858)\n",
    "test_filename = download_data(dir_name, 'TREC_10.label', url+'TREC_10.label', 23354)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_data(filename: str) -> Tuple[List[str], List[str], List[str]]:\n",
    "    \"\"\"\n",
    "    Read data from a file with given filename.\n",
    "\n",
    "    Returns:\n",
    "        Tuple containing three lists of strings representing questions, categories, and sub-categories, respectively.\n",
    "    \"\"\"\n",
    "    \n",
    "    questions, categories, sub_categories = [], [], []\n",
    "    \n",
    "    try:\n",
    "        with open(filename,'r',encoding='latin-1') as f:        \n",
    "            for row in f:\n",
    "                # Check if the row can be split into category and sub_category+question\n",
    "                if ':' in row:\n",
    "                    cat, sub_cat_and_question = row.split(\":\", 1)\n",
    "                    tokens = sub_cat_and_question.split(' ')\n",
    "                    sub_cat, question = tokens[0], ' '.join(tokens[1:])\n",
    "                    \n",
    "                    questions.append(question.strip())\n",
    "                    categories.append(cat)\n",
    "                    sub_categories.append(sub_cat)\n",
    "                else:\n",
    "                    print(f\"Skipping invalid row: {row}\")\n",
    "                    \n",
    "    except FileNotFoundError:\n",
    "        print(f\"The file {filename} was not found.\")\n",
    "        \n",
    "    return questions, categories, sub_categories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's inspect Sample data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Data:\n",
      "===========\n",
      "Data has 5452 questions and 5452 labels\n",
      "Sample Observations:\n",
      "\tQuestion - How did serfdom develop in and then leave Russia ? / Category - DESC / Sub-category - manner\n",
      "\tQuestion - What films featured the character Popeye Doyle ? / Category - ENTY / Sub-category - cremat\n",
      "\tQuestion - How can I find a list of celebrities ' real names ? / Category - DESC / Sub-category - manner\n",
      "\tQuestion - What fowl grabs the spotlight after the Chinese Year of the Monkey ? / Category - ENTY / Sub-category - animal\n",
      "\tQuestion - What is the full form of .com ? / Category - ABBR / Sub-category - exp\n",
      "\n",
      "\n",
      "Test Data:\n",
      "==========\n",
      "Data has 500 questions and 500 labels\n",
      "Sample Observations:\n",
      "\tQuestion - How far is it from Denver to Aspen ? / Category - NUM / Sub-category - dist\n",
      "\tQuestion - What county is Modesto , California in ? / Category - LOC / Sub-category - city\n",
      "\tQuestion - Who was Galileo ? / Category - HUM / Sub-category - desc\n",
      "\tQuestion - What is an atom ? / Category - DESC / Sub-category - def\n",
      "\tQuestion - When did Hawaii become a state ? / Category - NUM / Sub-category - date\n"
     ]
    }
   ],
   "source": [
    "def print_samples(questions: List[str], categories: List[str], sub_categories: List[str], n_samples: int):\n",
    "    \"\"\"\n",
    "    Print samples from the questions, categories, and sub_categories lists.\n",
    "\n",
    "    Args:\n",
    "        questions: A list of questions.\n",
    "        categories: A list of categories corresponding to the questions.\n",
    "        sub_categories: A list of sub_categories corresponding to the questions.\n",
    "        n_samples: The number of samples to print.\n",
    "    \"\"\"\n",
    "    \n",
    "    print(f\"Data has {len(questions)} questions and {len(categories)} labels\")\n",
    "    print(\"Sample Observations:\")\n",
    "    for question, cat, sub_cat in zip(questions[:n_samples], categories[:n_samples], sub_categories[:n_samples]):\n",
    "        print(f\"\\tQuestion - {question} / Category - {cat} / Sub-category - {sub_cat}\")\n",
    "\n",
    "train_questions, train_categories, train_sub_categories = read_data(train_filename)\n",
    "test_questions, test_categories, test_sub_categories = read_data(test_filename)\n",
    "\n",
    "n_samples = 5\n",
    "print(\"Train Data:\")\n",
    "print(\"===========\")\n",
    "print_samples(train_questions, train_categories, train_sub_categories, n_samples)\n",
    "print('\\n')\n",
    "print(\"Test Data:\")\n",
    "print(\"==========\")\n",
    "print_samples(test_questions, test_categories, test_sub_categories, n_samples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convert Trand and Test Data to Pandas Dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 5452 entries, 0 to 5451\n",
      "Data columns (total 3 columns):\n",
      " #   Column        Non-Null Count  Dtype \n",
      "---  ------        --------------  ----- \n",
      " 0   question      5452 non-null   object\n",
      " 1   category      5452 non-null   object\n",
      " 2   sub_category  5452 non-null   object\n",
      "dtypes: object(3)\n",
      "memory usage: 127.9+ KB\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>question</th>\n",
       "      <th>category</th>\n",
       "      <th>sub_category</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>How did serfdom develop in and then leave Russ...</td>\n",
       "      <td>DESC</td>\n",
       "      <td>manner</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>What films featured the character Popeye Doyle ?</td>\n",
       "      <td>ENTY</td>\n",
       "      <td>cremat</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>How can I find a list of celebrities ' real na...</td>\n",
       "      <td>DESC</td>\n",
       "      <td>manner</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>What fowl grabs the spotlight after the Chines...</td>\n",
       "      <td>ENTY</td>\n",
       "      <td>animal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>What is the full form of .com ?</td>\n",
       "      <td>ABBR</td>\n",
       "      <td>exp</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                            question category sub_category\n",
       "0  How did serfdom develop in and then leave Russ...     DESC       manner\n",
       "1   What films featured the character Popeye Doyle ?     ENTY       cremat\n",
       "2  How can I find a list of celebrities ' real na...     DESC       manner\n",
       "3  What fowl grabs the spotlight after the Chines...     ENTY       animal\n",
       "4                    What is the full form of .com ?     ABBR          exp"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create train and test data\n",
    "\n",
    "train_data = pd.DataFrame({\n",
    "    'question': train_questions, \n",
    "    'category': train_categories, \n",
    "    'sub_category': train_sub_categories\n",
    "})\n",
    "\n",
    "test_data = pd.DataFrame({\n",
    "    'question': test_questions, \n",
    "    'category': test_categories,\n",
    "    'sub_category': test_sub_categories\n",
    "})\n",
    "\n",
    "train_data.info()\n",
    "train_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial Data Exploration\n",
    "\n",
    "\n",
    "Let's create a function to clean our data before exploration. See the docstring for details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lemmatizer(text: str) -> List[str]:\n",
    "    \"\"\"Performs lemmatization on a text.\"\"\"\n",
    "    return [word.lemma_ for word in nlp(text)]\n",
    "\n",
    "## get stop words\n",
    "stop_words = ENGLISH_STOP_WORDS.union(STOP_WORDS)\n",
    "stop_words = {words.replace(\"'\", \"\") for words in stop_words}\n",
    "\n",
    "def clean_questions(question: str) -> str:\n",
    "    \"\"\"\n",
    "    Cleans up a question.\n",
    "\n",
    "    - Replaces all new lines (\\n) with white space.\n",
    "    - Converts all words to lower case.\n",
    "    - Removes all characters except a-z, A-Z, hyphens and white space.\n",
    "    - Removes hyphens that are not part of a word.\n",
    "    - Removes extra white spaces.\n",
    "    - Removes stop words.\n",
    "    - Performs lemmatization.\n",
    "    \"\"\"\n",
    "    question = question.replace('\\n', ' ').lower()  # replace newlines and convert to lowercase\n",
    "    question = re.sub('[^-a-z ]', '', question)  # keep only letters, hyphens, and white space\n",
    "    question = re.sub('(?<=[^a-z])-(?=[^a-z])', '', question)  # remove hyphens not part of a word\n",
    "    question = re.sub(' +', ' ', question)  # replace multiple spaces with a single space\n",
    "    question = ' '.join([word for word in question.split() if word not in stop_words])  # remove stop words\n",
    "    question = lemmatizer(question)  # lemmatization\n",
    "    return ' '.join(question)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total time taken (mins): 0.38 \n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "train_data.loc[:, 'cleaned'] = train_data.loc[:, 'question'].apply(clean_questions) \n",
    "print('Total time taken (mins): {:.2f} '.format(float(time.time()-start_time)/60))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Let's compare our data cleaning result with the original text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Sample Number: 4119\n",
      "Original: Who created Harry Lime ?\n",
      "Cleaned: create harry lime\n",
      "Category: HUM\n",
      "\n",
      "Training Sample Number: 2935\n",
      "Original: What is the origin of the word `` mushroom '' ?\n",
      "Cleaned: origin word mushroom\n",
      "Category: DESC\n",
      "\n",
      "Training Sample Number: 82\n",
      "Original: What is the origin of head lice ?\n",
      "Cleaned: origin head lice\n",
      "Category: DESC\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Get the total number of questions\n",
    "num_questions = train_data.shape[0]\n",
    "\n",
    "# Define the number of samples you want to compare\n",
    "num_samples = 3\n",
    "\n",
    "# Randomly select unique indices\n",
    "indices_to_compare = random.sample(range(num_questions), num_samples)\n",
    "\n",
    "\n",
    "# Loop over indices and print original and cleaned text, along with their category\n",
    "for index in indices_to_compare:\n",
    "    original_text = train_data.question[index]\n",
    "    cleaned_text = train_data.cleaned[index]\n",
    "    category = train_data.category[index]\n",
    "\n",
    "    print(f'Training Sample Number: {index}'\n",
    "          f'\\nOriginal: {original_text}'\n",
    "          f'\\nCleaned: {cleaned_text}'\n",
    "          f'\\nCategory: {category}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our data cleaning step was successful, all stop were removed, all letter convertd to lower case, and so on. Next, we will view the label distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Data Characteristics:\n",
      "==============================\n",
      "Total questions: 5452\n",
      "Total Entity Questions: 1250\n",
      "Total Hunman Being Questions: 1223\n",
      "Total Description Questions: 1162\n",
      "Total Numeric Questions: 896\n",
      "Total Location Questions: 835\n",
      "Total Abbreviation Questions: 86\n"
     ]
    }
   ],
   "source": [
    "print(f'Training Data Characteristics:\\n=============================='\n",
    "      f'\\nTotal questions: {train_data.shape[0]}'\n",
    "      f'\\nTotal Entity Questions: {train_data[\"category\"].value_counts().loc[\"ENTY\"]}'\n",
    "      f'\\nTotal Hunman Being Questions: {train_data[\"category\"].value_counts().loc[\"HUM\"]}'\n",
    "      f'\\nTotal Description Questions: {train_data[\"category\"].value_counts().loc[\"DESC\"]}'\n",
    "      f'\\nTotal Numeric Questions: {train_data[\"category\"].value_counts().loc[\"NUM\"]}'\n",
    "      f'\\nTotal Location Questions: {train_data[\"category\"].value_counts().loc[\"LOC\"]}'\n",
    "      f'\\nTotal Abbreviation Questions: {train_data[\"category\"].value_counts().loc[\"ABBR\"]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Some Visualizations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlQAAAHACAYAAABkh/bhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMgklEQVR4nO3deVwVZf//8fdBBNwAcQEpQHPXTMsFzQ0Ld02LNNMS0zS91XK51ex2QdxN07TSMpfs1jIrtbTcNVzIBdPMzLRcSAUrBFySdX5/9ON8PTdgeOYgi6/n43EeD891XTPzmfEIb2fmXGMxDMMQAAAA7OaU1wUAAAAUdAQqAAAAkwhUAAAAJhGoAAAATCJQAQAAmESgAgAAMIlABQAAYJJzXhdwr0hPT9fFixdVqlQpWSyWvC4HAADkgGEYunr1qnx9feXklP15KALVXXLx4kX5+fnldRkAAMAO0dHRuv/++7PtJ1DdJaVKlZL091+Iu7t7HlcDAAByIjExUX5+ftbf49khUN0lGZf53N3dCVQAABQw/3S7DjelAwAAmESgAgAAMIlABQAAYBKBCgAAwCQCFQAAgEkEKgAAAJMIVAAAACYRqAAAAEwiUAEAAJhEoAIAADCJQAUAAGASgQoAAMAkAhUAAIBJBCoAAACTCFQAAAAmOed1Afg/9UetyOsS8oWo13vndQkAANwRzlABAACYRKACAAAwiUAFAABgEoEKAADAJAIVAACASQQqAAAAk5g2AYUO00/8H6agAIC7gzNUAAAAJhGoAAAATCrQgSoiIkKdO3eWr6+vLBaL1q1bZ+1LSUnRmDFjVKdOHZUoUUK+vr7q3bu3Ll68aLOOuLg49erVS+7u7vL09FS/fv107do1mzHff/+9mjdvLjc3N/n5+WnWrFl3Y/cAAEABUaAD1fXr11W3bl29/fbbmfpu3Lihw4cPa/z48Tp8+LA+//xznTx5Uk888YTNuF69eun48ePaunWrNmzYoIiICA0YMMDan5iYqDZt2iggIEBRUVF6/fXXFRYWpvfeey/X9w8AABQMBfqm9Pbt26t9+/ZZ9nl4eGjr1q02bW+99ZYaNWqk8+fPy9/fXydOnNCmTZt08OBBNWjQQJK0YMECdejQQbNnz5avr69Wrlyp5ORkLV26VC4uLqpdu7aOHDmiN954wyZ4AQCAe1eBPkN1pxISEmSxWOTp6SlJioyMlKenpzVMSVJwcLCcnJy0f/9+65gWLVrIxcXFOqZt27Y6efKkrly5ku22kpKSlJiYaPMCAACF0z0TqG7evKkxY8bo2Weflbu7uyQpJiZG5cuXtxnn7OwsLy8vxcTEWMd4e3vbjMl4nzEmK9OnT5eHh4f15efn58jdAQAA+cg9EahSUlLUvXt3GYahhQsX3pVtjh07VgkJCdZXdHT0XdkuAAC4+wr0PVQ5kRGmzp07px07dljPTkmSj4+PLl++bDM+NTVVcXFx8vHxsY6JjY21GZPxPmNMVlxdXeXq6uqo3QAAAPlYoT5DlRGmTp06pW3btqlMmTI2/U2aNFF8fLyioqKsbTt27FB6eroCAwOtYyIiIpSSkmIds3XrVlWvXl2lS5e+OzsCAADytQIdqK5du6YjR47oyJEjkqQzZ87oyJEjOn/+vFJSUvT000/r0KFDWrlypdLS0hQTE6OYmBglJydLkmrWrKl27dqpf//+OnDggPbu3ashQ4aoR48e8vX1lST17NlTLi4u6tevn44fP67Vq1frzTff1IgRI/JqtwEAQD5ToC/5HTp0SK1atbK+zwg5oaGhCgsL0xdffCFJqlevns1yO3fuVFBQkCRp5cqVGjJkiB5//HE5OTkpJCRE8+fPt4718PDQli1bNHjwYNWvX19ly5bVhAkTmDIBAABYFehAFRQUJMMwsu2/XV8GLy8vrVq16rZjHnroIe3evfuO6wMAAPeGAn3JDwAAID8gUAEAAJhEoAIAADCpQN9DBSB31R+1Iq9LyBeiXu+d1yUAyOc4QwUAAGASgQoAAMAkAhUAAIBJBCoAAACTCFQAAAAmEagAAABMIlABAACYRKACAAAwiUAFAABgEoEKAADAJAIVAACASQQqAAAAkwhUAAAAJhGoAAAATCJQAQAAmESgAgAAMIlABQAAYBKBCgAAwCQCFQAAgEkEKgAAAJMIVAAAACYRqAAAAEwiUAEAAJhEoAIAADCJQAUAAGASgQoAAMAkAhUAAIBJBCoAAACTCFQAAAAmEagAAABMIlABAACYRKACAAAwiUAFAABgEoEKAADAJAIVAACASQQqAAAAkwhUAAAAJhGoAAAATCJQAQAAmESgAgAAMIlABQAAYJJdgerYsWNaunSpEhMTrW1//fWXBg0apPvuu09VqlTRokWLHFZkdiIiItS5c2f5+vrKYrFo3bp1Nv2GYWjChAmqUKGCihUrpuDgYJ06dcpmTFxcnHr16iV3d3d5enqqX79+unbtms2Y77//Xs2bN5ebm5v8/Pw0a9as3N41AABQgNgVqKZMmaLx48erVKlS1rbXXntN7777rq5evaro6GgNHjxYW7dudVihWbl+/brq1q2rt99+O8v+WbNmaf78+Vq0aJH279+vEiVKqG3btrp586Z1TK9evXT8+HFt3bpVGzZsUEREhAYMGGDtT0xMVJs2bRQQEKCoqCi9/vrrCgsL03vvvZer+wYAAAoOZ3sWOnDggFq1aiWLxSJJSk1N1bJly9SoUSPt2rVLcXFxeuSRR/Tmm2+qdevWDi34Vu3bt1f79u2z7DMMQ/PmzdO4cePUpUsXSdKKFSvk7e2tdevWqUePHjpx4oQ2bdqkgwcPqkGDBpKkBQsWqEOHDpo9e7Z8fX21cuVKJScna+nSpXJxcVHt2rV15MgRvfHGGzbBCwAA3LvsOkP1+++/y8/Pz/r+4MGDSkxM1MCBA+Xm5iZfX1916dJFR48edVihd+rMmTOKiYlRcHCwtc3Dw0OBgYGKjIyUJEVGRsrT09MapiQpODhYTk5O2r9/v3VMixYt5OLiYh3Ttm1bnTx5UleuXMl2+0lJSUpMTLR5AQCAwsmuQOXs7KykpCTr+127dslisahVq1bWtjJlyuiPP/4wX6GdYmJiJEne3t427d7e3ta+mJgYlS9f3qbf2dlZXl5eNmOyWset28jK9OnT5eHhYX3dGkABAEDhYlegqlixonbu3Gl9v2bNGlWqVEkBAQHWtgsXLqhMmTLmKyygxo4dq4SEBOsrOjo6r0sCAAC5xK5A9fzzz+vo0aMKDAxUixYtdPToUfXs2dNmzPfff6+qVas6pEh7+Pj4SJJiY2Nt2mNjY619Pj4+unz5sk1/amqq4uLibMZktY5bt5EVV1dXubu727wAAEDhZFegGjJkiLp166ZDhw5pz549at++vV577TVr//Hjx3X06FE99thjDiv0TlWqVEk+Pj7avn27tS0xMVH79+9XkyZNJElNmjRRfHy8oqKirGN27Nih9PR0BQYGWsdEREQoJSXFOmbr1q2qXr26SpcufZf2BgAA5Gd2fcvP1dVVq1evVmJioiwWi830CdLf9xh99913qlixoiNqzNa1a9d0+vRp6/szZ87oyJEj8vLykr+/v4YNG6YpU6aoatWqqlSpksaPHy9fX1917dpVklSzZk21a9dO/fv316JFi5SSkqIhQ4aoR48e8vX1lST17NlTkyZNUr9+/TRmzBj98MMPevPNNzV37txc3TcAAFBw2BWoMmR3Gats2bIqW7asmVXnyKFDh2xuhB8xYoQkKTQ0VMuXL9fo0aN1/fp1DRgwQPHx8WrWrJk2bdokNzc36zIrV67UkCFD9Pjjj8vJyUkhISGaP3++td/Dw0NbtmzR4MGDVb9+fZUtW1YTJkxgygQAAGBlKlBJf0+uGR8fr7S0tCz7/f39zW4iW0FBQTIMI9t+i8Wi8PBwhYeHZzvGy8tLq1atuu12HnroIe3evdvuOgEAQOFmd6BasmSJ5syZo5MnT2Y7xmKxKDU11d5NAAAAFAh2BaqFCxdq8ODBcnZ2VosWLXT//ffL2dn0yS4AAIACya4UNG/ePJUtW1Z79uxRtWrVHF0TAABAgWLXtAnnzp1T9+7dCVMAAACyM1BVqFAh25vQAQAA7jV2BarQ0FB9/fXXun79uqPrAQAAKHDsClTjxo1Tw4YN1bp1a0VEROjatWuOrgsAAKDAsHumdEkyDMNmYs3/xbQJAADgXmBXoGrevLksFoujawEAACiQ7ApUu3btcnAZAAAABZdd91ABAADg/5ie3vzChQs6cuSIEhMT5e7urnr16um+++5zRG0AAAAFgt2B6vTp0xo0aJB27NiRqe/xxx/XO++8oypVqpgqDgAAoCCwK1BFR0erWbNmunz5smrUqKEWLVqoQoUKiomJUUREhLZt26bmzZvrwIED8vPzc3TNAAAA+YpdgWrSpEm6fPmy3nnnHb300kuZvvH37rvvatCgQQoPD9fixYsdUigAAEB+ZVeg2rx5szp37qyBAwdm2f/SSy/pq6++0tdff22qOAAAgILArm/5Xb58WQ8++OBtxzz44IP6/fff7SoKAACgILErUJUrV04//vjjbcf8+OOPKleunF1FAQAAFCR2Baq2bdvqiy++0JIlS7LsX7p0qb788ku1a9fOVHEAAAAFgV33UE2cOFFffvmlBgwYoHnz5qlly5by9vZWbGysIiIidPz4cZUtW1YTJ050dL0AAAD5jl2Byt/fX3v37tVLL72kXbt26fjx4zb9rVq10sKFC5kyAQAA3BPsntizatWq2rFjh6KjozPNlE6QAgAA9xLTj57x8/MjQAHAP6g/akVel5AvRL3eO69LAHIFD0cGAAAwKUdnqPr27SuLxaJp06bJ29tbffv2zdHKLRZLtt8EBAAAKCxyFKiWL18ui8WiMWPGyNvbW8uXL8/RyglUAADgXpCjQHXmzBlJ0n333WfzHgAAADkMVAEBAbd9DwAAcC+z66b08PBwRURE3HbM7t27FR4ebldRAAAABYldgSosLEy7du267ZiIiAhNmjTJntUDAAAUKLk2bUJycrKKFCmSW6sHAADIN+wOVBaLJdu+5ORk7d69W+XLl7d39QAAAAVGjmdKf+CBB2zez507V8uWLcs0Li0tTX/88Ydu3ryp/v37m68QAAAgn8txoEpPT7eelbJYLDIMQ4ZhZBpXtGhR1a5dW4899pjGjx/vuEoBAADyqRwHqrNnz1r/7OTkpOHDh2vChAm5URMAAECBYtfDkc+cOSNPT08HlwIAAFAw2RWospvY8+zZs9q6davc3Nz05JNPqmTJkqaKAwAAKAjs+pbftGnTVKlSJV25csXatmvXLj344IMaOHCg+vTpo0ceeURxcXEOKxQAACC/sitQrVu3ThUrVlTp0qWtbWPGjFF6eromTZqkQYMG6fTp05o3b56j6gQAAMi37Lrkd/bsWXXr1s36/uLFizp48KBGjhypcePGSZJOnjyptWvX8vgZAIDD1B+1Iq9LyDeiXu+d1yXgFnadoUpMTLS5KT0iIkIWi0WdO3e2tj3yyCM6f/686QIBAADyO7sClbe3t86dO2d9v3XrVrm6uiowMNDadvPmzdvOpg4AAFBY2HXJr2HDhlq/fr02bNggNzc3rV69Wq1atZKrq6t1zJkzZ+Tr6+uwQgEAAPIru85Qvfbaa0pNTVWXLl3Utm1b3bx5U6+99pq1PykpSRERETZnrAAAAAoru85QPfLII/r222/14YcfSpK6d++uRo0aWfu/++47tWrVSj179nRMlQAAAPmYXYFKkurWrau6detm2de4cWOtXbvW7qIAAAAKErsu+d3q2rVrOnz4sHbv3u2IehwqLS1N48ePV6VKlVSsWDFVrlxZkydPtnmos2EYmjBhgipUqKBixYopODhYp06dsllPXFycevXqJXd3d3l6eqpfv366du3a3d4dAACQT9kdqM6ePasuXbqodOnSatiwoVq1amXt27t3r2rVqqVdu3Y5oka7zZw5UwsXLtRbb72lEydOaObMmZo1a5YWLFhgHTNr1izNnz9fixYt0v79+1WiRAnrfWEZevXqpePHj2vr1q3asGGDIiIiNGDAgLzYJQAAkA/Zdcnv/Pnzaty4sf7880916dJFMTExioyMtPYHBgbqjz/+0EcffaSgoCBH1XrH9u3bpy5duqhjx46SpIoVK+qjjz7SgQMHJP19dmrevHkaN26cunTpIklasWKFvL29tW7dOvXo0UMnTpzQpk2bdPDgQTVo0ECStGDBAnXo0EGzZ8/O9puMSUlJSkpKsr5PTEzMzV0FAAB5yK4zVBMnTtSVK1f0zTff6NNPP1Xr1q1t+p2dndW8eXPt3bvXIUXa69FHH9X27dv1888/S5KOHj2qPXv2qH379pL+ntohJiZGwcHB1mU8PDwUGBhoDYiRkZHy9PS0hilJCg4OlpOTk/bv35/ttqdPny4PDw/ry8/PLzd2EQAA5AN2BarNmzfrySef1KOPPprtmICAAF24cMHuwhzh1VdfVY8ePVSjRg0VLVpUDz/8sIYNG6ZevXpJkmJiYiT9PVHprby9va19MTExKl++vE2/s7OzvLy8rGOyMnbsWCUkJFhf0dHRjtw1AACQj9h1yS8uLk4VK1a87RjDMGwueeWFTz75RCtXrtSqVatUu3ZtHTlyRMOGDZOvr69CQ0Nzdduurq42E50CAIDCy65A5e3tnembcP/r2LFj8vf3t6soRxk1apT1LJUk1alTR+fOndP06dMVGhoqHx8fSVJsbKwqVKhgXS42Nlb16tWTJPn4+Ojy5cs2601NTVVcXJx1eQAAcG+z65Jf69attWHDBn3//fdZ9u/evVs7duxQhw4dTBVn1o0bN+TkZLuLRYoUUXp6uiSpUqVK8vHx0fbt2639iYmJ2r9/v5o0aSJJatKkieLj4xUVFWUds2PHDqWnpzMTPAAAkGTnGapx48bp008/VYsWLTRq1CidPn1akvT1119r3759euONN1S2bFmNGjXKocXeqc6dO2vq1Kny9/dX7dq19d133+mNN95Q3759JUkWi0XDhg3TlClTVLVqVVWqVEnjx4+Xr6+vunbtKkmqWbOm2rVrp/79+2vRokVKSUnRkCFD1KNHD55VCAAAJNkZqCpWrKjNmzerR48eGj9+vCwWiwzDUKdOnWQYhvz9/fXpp5/aXEbLCwsWLND48eP1r3/9S5cvX5avr69eeuklTZgwwTpm9OjRun79ugYMGKD4+Hg1a9ZMmzZtkpubm3XMypUrNWTIED3++ONycnJSSEiI5s+fnxe7BAAA8iG7Hz0TGBioU6dO6csvv9T+/fsVFxcnd3d3BQYGqkuXLnJxcXFknXYpVaqU5s2bp3nz5mU7xmKxKDw8XOHh4dmO8fLy0qpVq3KhQgAAUBjYHaikv6cPePLJJ/Xkk086qh4AAIACx/Sz/AAAAO51dp2hut3lsVtZLBaNHz/enk0AAAAUGHYFqrCwsNv2Z9ykTqACAAD3ArsC1c6dO7NsT0hI0OHDhzV//nwFBwdr8ODBpooDAAAoCOwKVC1btsy274knnlCvXr30yCOPKCQkxO7CAAAACopcuSm9atWqevLJJzVjxozcWD0AAEC+kmvf8itfvrxOnjyZW6sHAADIN3IlUCUlJWnTpk3y9PTMjdUDAADkK3bdQ7VixYos21NTU3XhwgV9/PHH+umnn/Tyyy+bKg4AAKAgsCtQ9enTRxaLJVO7YRiS/p424dlnn+UeKgAAcE+wK1AtW7Ysy3YnJyeVLl1a9evXz/MHIwMAANwtdgWq0NBQR9cBAABQYPEsPwAAAJPsOkN14cIFLV++XHv37tWFCxeUnp6u++67T7Vq1VLv3r1Vr149B5cJAACQf91xoJoyZYomT56s1NRU603oknT8+HFt2bJFb775prp06aIVK1aoZMmS1v6ff/5Z1apVc0zVAAAA+cgdXfIbMWKEJkyYoFKlSmn06NHasmWLTpw4oRMnTmjLli0aPXq0vLy8tH79erVs2dIaul566SV9/PHHubUPAAAAeSrHZ6h2796tefPmqVGjRvriiy9Uvnx5m/7q1asrODhYI0eO1BNPPKEDBw4oPDxcp06d0ieffMIUCgAAoNDKcaB65513VLJkSa1bty5TmLpVuXLltHbtWlWrVk1Tp06VYRjq16+fRowY4ZCCAQAA8pscX/Lbu3evOnbsKB8fn38c6+Pjo44dO0qSZs+ercWLF6tIkSL2VwkAAJCP5ThQXb58WQ888ECOV5wxljNTAACgsMtxoCpZsqTi4+NzvOKEhAQejgwAAO4JOQ5UtWrV0pYtW2ymSshOenq6Nm/erNq1a5sqDgAAoCDIcaAKCQnRL7/8ovDw8H8cO3XqVP366696+umnTRUHAABQEOQ4UA0cOFBVq1ZVeHi4QkNDderUqUxjTp06pT59+igsLExVq1bVSy+95NBiAQAA8qMcT5vg6uqqjRs3ql27dvrwww/13//+V/fdd5/8/PwkSdHR0bpw4YIMw1DlypW1ceNGubq65lrhAAAA+cUdPXqmSpUqOnz4sGbNmqXly5frt99+02+//Wbt9/X1Vd++fTVq1CiVKlXK4cUCAADkR3f8LD93d3dNmTJFU6ZM0fnz5xUTEyPp77mn/P39HV4gAABAfnfHgepW/v7+hCgAAHDPu6OHIwMAACAzAhUAAIBJBCoAAACTCFQAAAAmEagAAABMylGgeuqpp/TJJ59Y30dEROj8+fO5VhQAAEBBkqNAtW7dOv3000/W961atdLy5ctzqyYAAIACJUeBytPTU4mJidb3hmHkWkEAAAAFTY4m9qxVq5Y++ugjNWzYUBUqVJAknT17VhEREf+4bIsWLcxVCAAAkM/lKFBNmDBBXbt2Vc+ePa1tH3zwgT744IN/XDYtLc3+6gAAAAqAHAWqNm3a6MSJE9q2bZsuXLigsLAwtWzZUi1btszt+gAAAPK9HD/LLyAgQP369ZMkhYWFKSgoSBMmTMi1wgAAAAoKux6OfObMGXl6ejq4FAAAgILJrkAVEBBg/XNqaqpOnjypxMREubu7q3r16nJ2tmu1AAAABZLdM6XHxcWpf//+8vDw0EMPPaRmzZrpoYcekqenpwYMGKA///zTkXUCAADkW3adSoqLi1Pjxo11+vRpeXl5qXnz5qpQoYJiYmJ06NAhvf/++/rmm28UGRkpLy8vR9cMAACQr9h1hmry5Mk6ffq0Ro0apXPnzmnTpk1atmyZvv76a507d05jxozRqVOnNHXqVEfXe8cuXLig5557TmXKlFGxYsVUp04dHTp0yNpvGIYmTJigChUqqFixYgoODtapU6ds1hEXF6devXrJ3d1dnp6e6tevn65du3a3dwUAAORTdgWq9evXKygoSDNnzlSJEiVs+ooXL67p06crKChIa9eudUiR9rpy5YqaNm2qokWL6uuvv9aPP/6oOXPmqHTp0tYxs2bN0vz587Vo0SLt379fJUqUUNu2bXXz5k3rmF69eun48ePaunWrNmzYoIiICA0YMCAvdgkAAORDdl3yu3jxop599tnbjmnSpIn27dtnV1GOMnPmTPn5+WnZsmXWtkqVKln/bBiG5s2bp3HjxqlLly6SpBUrVsjb21vr1q1Tjx49dOLECW3atEkHDx5UgwYNJEkLFixQhw4dNHv2bPn6+t7dnQIAAPmOXWeoPDw8dO7cuduOOXfunDw8POwqylG++OILNWjQQN26dVP58uX18MMPa/Hixdb+M2fOKCYmRsHBwdY2Dw8PBQYGKjIyUpIUGRkpT09Pa5iSpODgYDk5OWn//v3ZbjspKUmJiYk2LwAAUDjZFahatmypNWvWaNu2bVn2b9++XWvWrFFQUJCZ2kz79ddftXDhQlWtWlWbN2/WoEGD9PLLL1sfmRMTEyNJ8vb2tlnO29vb2hcTE6Py5cvb9Ds7O8vLy8s6JivTp0+Xh4eH9eXn5+fIXQMAAPmIXZf8Jk6cqI0bN6pt27bq0KGDWrZsKW9vb8XGxmrXrl36+uuvVbx48TyfST09PV0NGjTQtGnTJEkPP/ywfvjhBy1atEihoaG5uu2xY8dqxIgR1veJiYmEKgAACim7AlXt2rW1efNm9enTRxs3btTGjRtlsVhkGIYkqXLlylq+fLlq167t0GLvVIUKFVSrVi2btpo1a+qzzz6TJPn4+EiSYmNjVaFCBeuY2NhY1atXzzrm8uXLNutITU1VXFycdfmsuLq6ytXV1RG7AQAA8jm7pzRv1qyZTp06pb179+q7776zzpT+8MMPq2nTprJYLI6s0y5NmzbVyZMnbdp+/vln60zvlSpVko+Pj7Zv324NUImJidq/f78GDRok6e+b6+Pj4xUVFaX69etLknbs2KH09HQFBgbevZ0BAAD5lqlnxFgsFjVr1kzNmjVzVD0ONXz4cD366KOaNm2aunfvrgMHDui9997Te++9J+nv+ocNG6YpU6aoatWqqlSpksaPHy9fX1917dpV0t9ntNq1a6f+/ftr0aJFSklJ0ZAhQ9SjRw++4QcAACSZDFT5XcOGDbV27VqNHTtW4eHhqlSpkubNm6devXpZx4wePVrXr1/XgAEDFB8fr2bNmmnTpk1yc3Ozjlm5cqWGDBmixx9/XE5OTgoJCdH8+fPzYpcAAEA+VKgDlSR16tRJnTp1yrbfYrEoPDxc4eHh2Y7x8vLSqlWrcqM8AABQCNj9cGQAAAD8jUAFAABgEoEKAADAJAIVAACASXYFqiJFith8Uw4AAOBeZlegcnd35zEqAAAA/59dgapRo0Y6evSoo2sBAAAokOwKVGFhYdqxY4dWrFjh6HoAAAAKHLsm9ty6dauCgoL0wgsvaMGCBWrYsKG8vb0zPb/PYrFo/PjxDikUAAAgv7IrUIWFhVn/HBUVpaioqCzHEagAAMC9wK5AtXPnTkfXAQAAUGDZFahatmzp6DoAAAAKLCb2BAAAMMnuQJWamqq5c+eqUaNGcnd3l7Pz/53sOnLkiP71r3/p559/dkiRAAAA+Zldl/z++usvtWnTRvv27VPZsmXl7u6u69evW/srVaqkZcuWycvLS1OmTHFYsQAAAPmRXWeopk2bpr1792r69OmKiYnRiy++aNPv4eGhli1bavPmzQ4pEgAAID+zK1CtXr1arVq10ujRo2WxWDLNPyVJDzzwgM6fP2+6QAAAgPzOrkB1/vx5NWjQ4LZjSpUqpYSEBLuKAgAAKEjsClSlSpXS5cuXbzvml19+Ubly5ewqCgAAoCCxK1A1btxYX375peLj47Psj46O1ldffaUWLVqYqQ0AAKBAsCtQjRo1SleuXNHjjz+uvXv3KjU1VZJ048YNbd++XW3btlVqaqpGjBjh0GIBAADyI7umTWjRooXeeustvfLKKzZnoUqVKiVJKlKkiN555x3Vr1/fMVUCAADkY3YFKkkaNGiQgoKCtGjRIu3fv19xcXFyd3dXYGCg/vWvf6l27dqOrBMAACDfsjtQSVLNmjX15ptvOqoWAACAAoln+QEAAJhkKlCtXbtWXbp0kb+/vzw8POTv768uXbpo3bp1DioPAAAg/7Prkl9qaqp69uypzz77TIZhyNnZWWXKlFFMTIy+/PJLbdiwQSEhIVq1apXNQ5MBAAAKI7vOUE2fPl2ffvqpmjdvrt27d+vmzZu6dOmSbt68qYiICDVr1kyfffaZZsyY4eh6AQAA8h27AtWyZctUo0YNbdu2TU2bNpWT09+rcXJyUrNmzbRt2zZVq1ZNS5cudWixAAAA+ZFdgerSpUvq3LlztpfzihYtqs6dO+vSpUumigMAACgI7ApUfn5+unbt2m3HXL9+Xf7+/nYVBQAAUJDYFahefPFFffLJJ9megbpw4YJWr16tF1980VRxAAAABUGOvoJ3/vx5m/fdu3fX3r179fDDD2vYsGFq1qyZvL29FRsbq927d+vNN99Us2bN1K1bt1wpGgAAID/JUaCqWLGiLBZLpnbDMPSf//wny/YvvvhCGzZssD44GQAAoLDKUaDq3bt3loEKAAAAOQxUy5cvz+UyAAAACi6e5QcAAGASgQoAAMAkuwPVnj171LVrV1WqVEmurq4qUqRIphfP8QMAAPcCuxLPhx9+qD59+sgwDD3wwANq1KgR4QkAANyz7EpBkydPVunSpfXVV1+pUaNGjq4JAACgQLHrkl90dLR69OhBmAIAAJCdgSogIEDJycmOrgUAAKBAsitQ9e/fXxs2bFBcXJyj6wEAAChw7LqHauTIkfr111/VtGlTjRs3TnXr1pW7u3uWY/39/U0VCAAAkN/ZPW3CI488opiYGPXu3Vt169ZVpUqVMr0eeOABR9Zq2owZM2SxWDRs2DBr282bNzV48GCVKVNGJUuWVEhIiGJjY22WO3/+vDp27KjixYurfPnyGjVqFM8oBAAAVnadoVqwYIGGDRumokWLqlWrVqpQoUK+nzbh4MGDevfdd/XQQw/ZtA8fPlwbN27UmjVr5OHhoSFDhuipp57S3r17JUlpaWnq2LGjfHx8tG/fPl26dEm9e/dW0aJFNW3atLzYFQAAkM/YlYLmzp2r++67T/v27dP999/v6Joc7tq1a+rVq5cWL16sKVOmWNsTEhK0ZMkSrVq1So899pgkadmyZapZs6a+/fZbNW7cWFu2bNGPP/6obdu2ydvbW/Xq1dPkyZM1ZswYhYWFycXFJa92CwAA5BN2XfKLiYlRSEhIgQhTkjR48GB17NhRwcHBNu1RUVFKSUmxaa9Ro4b8/f0VGRkpSYqMjFSdOnXk7e1tHdO2bVslJibq+PHj2W4zKSlJiYmJNi8AAFA42XWGqkqVKoqPj3dwKbnj448/1uHDh3Xw4MFMfTExMXJxcZGnp6dNu7e3t2JiYqxjbg1TGf0ZfdmZPn26Jk2aZLJ6AABQENh1hmr48OFav369zp075+h6HCo6OlqvvPKKVq5cKTc3t7u67bFjxyohIcH6io6OvqvbBwAAd49dZ6gqV66sli1bqkGDBho2bNhtp01o0aKFqQLNiIqK0uXLl/XII49Y29LS0hQREaG33npLmzdvVnJysuLj423OUsXGxsrHx0eS5OPjowMHDtisN+NbgBljsuLq6ipXV1cH7g0AAMiv7ApUQUFBslgsMgxD48ePl8ViyXZsWlqa3cWZ9fjjj+vYsWM2bS+88IJq1KihMWPGyM/PT0WLFtX27dsVEhIiSTp58qTOnz+vJk2aSJKaNGmiqVOn6vLlyypfvrwkaevWrXJ3d1etWrXu7g4BAIB8ya5ANWHChNuGqPyiVKlSevDBB23aSpQooTJlyljb+/XrpxEjRsjLy0vu7u4aOnSomjRposaNG0uS2rRpo1q1aun555/XrFmzFBMTo3Hjxmnw4MGcgQIAAJLsDFRhYWEOLiPvzJ07V05OTgoJCVFSUpLatm2rd955x9pfpEgRbdiwQYMGDVKTJk1UokQJhYaGKjw8PA+rBgAA+Un+no0zF+zatcvmvZubm95++229/fbb2S4TEBCgr776KpcrAwAABZXdj54BAADA3+w6Q+Xk5JSje6gsFgvPvAMAAIWeXYGqRYsWWQaqhIQEnTp1StevX1fdunUzTZgJAABQGNkVqP73PqRb3bhxQ6+++qo2bdqkrVu32lsXAABAgeHwe6iKFy+u+fPny8PDQ6NGjXL06gEAAPKdXLspvXnz5tq4cWNurR4AACDfyLVA9fvvv+vatWu5tXoAAIB8w+GBKj09XR9++KFWr16tevXqOXr1AAAA+Y5dN6U/8MADWbanpqbq8uXLSklJUdGiRTV9+nRTxQEAABQEdgWq9PT0LKdNKFq0qB588EE1bNhQQ4YMUe3atU0XCAAAkN/ZFajOnj3r4DIAAAAKLh49AwAAYBKBCgAAwKQcX/Lr27fvHa/cYrFoyZIld7wcAABAQZLjQLV8+fIcr9RiscgwDAIVAAC4J+Q4UEVGRuZo3OnTpxUWFqZffvnF7qIAAAAKkhwHqsDAwNv2//HHH5o0aZIWL16s5ORkNWvWTDNnzjRdIAAAQH5n17QJt7px44Zmz56tOXPm6OrVq6pdu7amTZumzp07O6I+AACAfM/uQJWWlqZ3331XkydPVmxsrO6//37NmzdPoaGhcnLiy4MAAODeYVegWrNmjcaNG6fTp0/Lw8NDM2bM0Msvvyw3NzdH1wcAAJDv3VGg2rVrl8aMGaNDhw7JxcVFI0eO1GuvvSZPT89cKg8AACD/y3Ggat++vbZs2SInJyeFhoYqPDxc999/f27WBgAAUCDkOFBt3rxZFotF/v7+iomJ0YABA/5xGYvFoo0bN5oqEAAAIL+7o0t+hmHozJkzOnPmTI7GWywWu4oCAAAoSHIcqHIaogAAAO41OQ5UAQEBuVkHAABAgcWEUQAAACYRqAAAAEwiUAEAAJhEoAIAADCJQAUAAGASgQoAAMAkAhUAAIBJBCoAAACTCFQAAAAmEagAAABMIlABAACYRKACAAAwiUAFAABgEoEKAADAJAIVAACASQQqAAAAkwhUAAAAJhGoAAAATCJQAQAAmESgAgAAMKnQB6rp06erYcOGKlWqlMqXL6+uXbvq5MmTNmNu3rypwYMHq0yZMipZsqRCQkIUGxtrM+b8+fPq2LGjihcvrvLly2vUqFFKTU29m7sCAADyqUIfqL755hsNHjxY3377rbZu3aqUlBS1adNG169ft44ZPny4vvzyS61Zs0bffPONLl68qKeeesran5aWpo4dOyo5OVn79u3TBx98oOXLl2vChAl5sUsAACCfcc7rAnLbpk2bbN4vX75c5cuXV1RUlFq0aKGEhAQtWbJEq1at0mOPPSZJWrZsmWrWrKlvv/1WjRs31pYtW/Tjjz9q27Zt8vb2Vr169TR58mSNGTNGYWFhcnFxybTdpKQkJSUlWd8nJibm7o4CAIA8U+jPUP2vhIQESZKXl5ckKSoqSikpKQoODraOqVGjhvz9/RUZGSlJioyMVJ06deTt7W0d07ZtWyUmJur48eNZbmf69Ony8PCwvvz8/HJrlwAAQB67pwJVenq6hg0bpqZNm+rBBx+UJMXExMjFxUWenp42Y729vRUTE2Mdc2uYyujP6MvK2LFjlZCQYH1FR0c7eG8AAEB+Uegv+d1q8ODB+uGHH7Rnz55c35arq6tcXV1zfTsAACDv3TNnqIYMGaINGzZo586duv/++63tPj4+Sk5OVnx8vM342NhY+fj4WMf877f+Mt5njAEAAPeuQh+oDMPQkCFDtHbtWu3YsUOVKlWy6a9fv76KFi2q7du3W9tOnjyp8+fPq0mTJpKkJk2a6NixY7p8+bJ1zNatW+Xu7q5atWrdnR0BAAD5VqG/5Dd48GCtWrVK69evV6lSpaz3PHl4eKhYsWLy8PBQv379NGLECHl5ecnd3V1Dhw5VkyZN1LhxY0lSmzZtVKtWLT3//POaNWuWYmJiNG7cOA0ePJjLegAAoPAHqoULF0qSgoKCbNqXLVumPn36SJLmzp0rJycnhYSEKCkpSW3bttU777xjHVukSBFt2LBBgwYNUpMmTVSiRAmFhoYqPDz8bu0GAADIxwp9oDIM4x/HuLm56e2339bbb7+d7ZiAgAB99dVXjiwNAAAUEoX+HioAAIDcRqACAAAwiUAFAABgEoEKAADAJAIVAACASQQqAAAAkwhUAAAAJhGoAAAATCJQAQAAmESgAgAAMIlABQAAYBKBCgAAwCQCFQAAgEkEKgAAAJMIVAAAACYRqAAAAEwiUAEAAJhEoAIAADCJQAUAAGASgQoAAMAkAhUAAIBJBCoAAACTCFQAAAAmEagAAABMcs7rAgAAwN1Xf9SKvC4hX4h6vbdD1sMZKgAAAJMIVAAAACYRqAAAAEwiUAEAAJhEoAIAADCJQAUAAGASgQoAAMAkAhUAAIBJBCoAAACTCFQAAAAmEagAAABMIlABAACYRKACAAAwiUAFAABgEoEKAADAJAIVAACASQQqAAAAkwhUAAAAJhGoAAAATCJQAQAAmESgugNvv/22KlasKDc3NwUGBurAgQN5XRIAAMgHCFQ5tHr1ao0YMUITJ07U4cOHVbduXbVt21aXL1/O69IAAEAeI1Dl0BtvvKH+/fvrhRdeUK1atbRo0SIVL15cS5cuzevSAABAHnPO6wIKguTkZEVFRWns2LHWNicnJwUHBysyMjLLZZKSkpSUlGR9n5CQIElKTEzMdjtpSX85qOKC7XbHKCc4jv+HY+kYZo+jxLHMwGfScTiWjvFPxzGj3zCM26/IwD+6cOGCIcnYt2+fTfuoUaOMRo0aZbnMxIkTDUm8ePHixYsXr0Lwio6Ovm1W4AxVLhk7dqxGjBhhfZ+enq64uDiVKVNGFoslDyvLXmJiovz8/BQdHS13d/e8LqdA41g6BsfRcTiWjsOxdIyCchwNw9DVq1fl6+t723EEqhwoW7asihQpotjYWJv22NhY+fj4ZLmMq6urXF1dbdo8PT1zq0SHcnd3z9cf7oKEY+kYHEfH4Vg6DsfSMQrCcfTw8PjHMdyUngMuLi6qX7++tm/fbm1LT0/X9u3b1aRJkzysDAAA5AecocqhESNGKDQ0VA0aNFCjRo00b948Xb9+XS+88EJelwYAAPIYgSqHnnnmGf3++++aMGGCYmJiVK9ePW3atEne3t55XZrDuLq6auLEiZkuVeLOcSwdg+PoOBxLx+FYOkZhO44Ww/in7wECAADgdriHCgAAwCQCFQAAgEkEKgAAAJMIVAAAACYRqAqRPn36yGKxZHq1a9dOklSxYkVZLBZ9++23NssNGzZMQUFBNmOye/Xs2VPFixfXqlWrbNaRnp6uRx99VE8//fRd2de7pU+fPuratWum9l27dslisSg+Pl7Lly/PdtJWi8WidevWSZLOnj0ri8WiIkWK6MKFCzbjLl26JGdnZ1ksFp09e9axO5GHbv1MFi1aVN7e3mrdurWWLl2q9PR067jsPnczZsywjlm7dq0aN24sDw8PlSpVSrVr19awYcNstpecnKxZs2apbt26Kl68uMqWLaumTZtq2bJlSklJuVu7nasyjumtx0aS1q1bZ30KA5/JO5Pdv3NJ+uuvvzRx4kRVq1ZNrq6uKlu2rLp166bjx49nGpuYmKj//Oc/qlGjhtzc3OTj46Pg4GB9/vnn//wcuAIqMjJSRYoUUceOHW3aMz5bGS8XFxdVqVJFU6ZMsTkWYWFhNuM8PDzUvHlzffPNNzbru/VnRPHixVWnTh29//77d2Ufc4pAVci0a9dOly5dsnl99NFH1n43NzeNGTMm2+UPHjxoXe6zzz6TJJ08edLatnDhQs2YMUNDhw7VpUuXrMvNmTNHv/76qxYtWpR7O1dI3HfffVqxYoVN2wcffKD77rsvjyrKXRmfybNnz+rrr79Wq1at9Morr6hTp05KTU21jgsPD8/02R06dKgkafv27XrmmWcUEhKiAwcOKCoqSlOnTrUJScnJyWrbtq1mzJihAQMGaN++fTpw4IAGDx6sBQsWZPkLsKByc3PTzJkzdeXKFYes7177TOZUUlKSgoODtXTpUk2ZMkU///yzvvrqK6WmpiowMNDmP6fx8fF69NFHtWLFCo0dO1aHDx9WRESEnnnmGY0ePVoJCQl5uCe5Z8mSJRo6dKgiIiJ08eLFTP3btm3TpUuXdOrUKU2aNElTp07V0qVLbcbUrl3b+m8+MjJSVatWVadOnTIds4yfET/88IOee+459e/fX19//XWu7t8dccTDg5E/hIaGGl26dMm2PyAgwHj55ZcNFxcXY+PGjdb2V155xWjZsmWm8Tt37jQkGVeuXLFpT09PN1q1amV07NjRMAzDOHHihOHm5masX7/eEbuRr2R3TG89NsuWLTM8PDyyXF6SsXbtWsMwDOPMmTOGJGPcuHFG1apVbcZVq1bNGD9+vCHJOHPmjGN3Ig9ld/y2b99uSDIWL15sGMbfn825c+dmu55XXnnFCAoKuu22Zs6caTg5ORmHDx/O1JecnGxcu3btjmrPr0JDQ41OnToZNWrUMEaNGmVtX7t2rZHxI53P5J3J7nM6Y8YMw2KxGEeOHLFpT0tLMxo0aGDUqlXLSE9PNwzDMAYNGmSUKFHCuHDhQqb1XL161UhJScmV2vPS1atXjZIlSxo//fST8cwzzxhTp0619mV8tr777jubZR5//HHjX//6l/X9xIkTjbp169qMiY6ONiQZBw4csLZl9TPCy8vLGD58uMP2xyzOUN1jKlWqpIEDB2rs2LE2l1zuhMVi0bJly7R7924tXrxYffr0UY8ePfTEE084uNrC6YknntCVK1e0Z88eSdKePXt05coVde7cOY8ru3see+wx1a1bV59//nmOxvv4+Oj48eP64Ycfsh2zcuVKBQcH6+GHH87UV7RoUZUoUcLuevObIkWKaNq0aVqwYIF+++030+vjM5m1VatWqXXr1qpbt65Nu5OTk4YPH64ff/xRR48eVXp6uj7++GP16tUrywfolixZUs7OhW8e7U8++UQ1atRQ9erV9dxzz2np0qW3vbR56NAhRUVFKTAwMNsxSUlJWrZsmTw9PVW9evUsx6Snp+uzzz7TlStX5OLiYno/HIVAVchs2LBBJUuWtHlNmzbNZsy4ceN05swZrVy50u7tBAQEaN68eRo4cKAuXbqkN99802zp+VZWx7R9+/Z2r69o0aLWHz6StHTpUj333HMqWrSoo0ouEGrUqGFzb86YMWMyHefdu3dLkoYOHaqGDRuqTp06qlixonr06KGlS5cqKSnJuvypU6dUo0aNu70beebJJ59UvXr1NHHiRNPr4jOZtZ9//lk1a9bMsi+j/eeff9Yff/yhK1eu3FOfP+nvy33PPfecpL8v7SckJGS69+nRRx9VyZIl5eLiooYNG6p79+7q3bu3zZhjx45Z/80XK1ZMs2fP1kcffZTpgckZPyNcXV319NNPq3Tp0nrxxRdzdyfvAIGqkGnVqpWOHDli8xo4cKDNmHLlyunf//63JkyYoOTkZLu39cILL6hChQoaOnRovn9SuBlZHVOzN0P27dtXa9asUUxMjNasWaO+ffs6qNqCwzAM603UkjRq1KhMx7lBgwaSpBIlSmjjxo06ffq0xo0bp5IlS2rkyJFq1KiRbty4YV3fvWbmzJn64IMPdOLECdPr4jOZtZx8ru7Fz97Jkyd14MABPfvss5IkZ2dnPfPMM1qyZInNuNWrV+vIkSM6evSoPvnkE61fv16vvvqqzZjq1atb/81HRUVp0KBB6tatmw4dOmQzLuNnxI4dOxQYGKi5c+eqSpUqubujd6DwnYO8x5UoUSJHH7ARI0bonXfe0TvvvGNqe87OzoXyVPatsjqmt15mcXd31/Xr15Weni4np//7P0p8fLwkycPDI9M669Spoxo1aujZZ59VzZo19eCDD+rIkSO5Un9+deLECVWqVMn6vmzZsv/42a1cubIqV66sF198Uf/5z39UrVo1rV69Wi+88IKqVaumn376KbfLzldatGihtm3bauzYserTp4+1nc+kY1SrVi3bsJrRXq1aNZUrV06enp731OdvyZIlSk1NtbnEaRiGXF1d9dZbb1nb/Pz8rP+ua9asqV9++UXjx49XWFiY3NzcJMn6DcAMDz/8sNatW6d58+bpv//9r7U942dElSpVtGbNGtWpU0cNGjRQrVq1cnt3c4QzVPeokiVLavz48Zo6daquXr2a1+UUaNWrV1dqamqmXz6HDx+W9PcP3Kz07dtXu3btuifPBOzYsUPHjh1TSEiI3euoWLGiihcvruvXr0uSevbsqW3btum7777LNDYlJcU6rrCZMWOGvvzyS0VGRlrb+Ew6Ro8ePbRt2zYdPXrUpj09PV1z585VrVq1VLduXTk5OalHjx5auXJllt90u3btms03Wgu61NRUrVixQnPmzLE5o3z06FH5+vrafLP8fxUpUkSpqan/eHWkSJEi+uuvv7Lt9/Pz0zPPPKOxY8favR+OVrhPLdyDkpKSFBMTY9Pm7OyssmXLZho7YMAAzZ07V6tWrbrtTYK4vdq1a6tNmzbq27ev5syZowceeEAnT57UsGHD9Mwzz2T71fP+/furW7du2c4XVFhkfCbT0tIUGxurTZs2afr06erUqZPNvRRXr17N9NktXry43N3dFRYWphs3bqhDhw4KCAhQfHy85s+fr5SUFLVu3VrS3/Opbdy4UY8//rgmT56sZs2aqVSpUjp06JBmzpypJUuWqF69endz1++KOnXqqFevXpo/f761jc/knUtISMgUQJ977jmtX79enTt31pw5cxQYGKjY2FhNmzZNJ06c0LZt26yXradOnapdu3YpMDBQU6dOVYMGDVS0aFHt3r1b06dP18GDBwvNcd2wYYOuXLmifv36ZTrbGRISoiVLlljnP/zzzz8VExOj1NRUHTt2TG+++aZatWplc5tIamqq9d/+1atXtXr1av3444+3neJHkl555RU9+OCDOnTokPX2gDyVl18xhGOFhoYakjK9qlevbhhG1l87XbVqlSHpjqZNuNU/fd29oMvJtAmGYRhXrlwxXn75ZaNy5cpGsWLFjKpVqxqjR482rl69al0mu68RZ/juu+8K3VfUb/1MOjs7G+XKlTOCg4ONpUuXGmlpadZxAQEBWX52X3rpJcMwDGPHjh1GSEiI4efnZ7i4uBje3t5Gu3btjN27d9ts7+bNm8b06dONOnXqGG5uboaXl5fRtGlTY/ny5YXma+tZfSbPnDljuLi4GLf+SOczmXPZ/ezs16+fcf36deM///mPUaVKFaNo0aKGl5eXERISYhw7dizTeuLj441XX33VqFq1qvVzGhwcbKxdu9Y6vUJh0KlTJ6NDhw5Z9u3fv9+QZBw9etTmWBYpUsS4//77jf79+xuXL1+2jp84caLNuOLFixt16tQxFi5caLPe7H7XtG3b1mjfvr1D989eFsO4B++mAwAAcCDuoQIAADCJQAUAAGASgQoAAMAkAhUAAIBJBCoAAACTCFQAAAAmEagAAABMIlABAACYRKACAAAwiUAFAABgEoEKAADAJAIVAACASQQqAAAAkwhUAAAAJhGoAAAATCJQAQAAmESgAgAAMIlABQAAYBKBCgAAwCQCFYACLygoSBaLJa/LAHAPI1AB94idO3fqmWeekZ+fn1xdXVWmTBk1b95cCxYsUHJycl6Xd1thYWGyWCzatWtXXpdyR65cuaIpU6aoSZMmKlOmjIoWLapy5copODhYCxYs0LVr1+xe9/Lly2WxWLR8+XLHFQzAbs55XQCA3JWamqrBgwfrvffeU4kSJdS+fXtVqVJFCQkJ2rJli15++WW9++67+uqrr+Tv75/X5dplxYoVunHjRl6XYWP79u3q3r274uLiVLNmTXXr1k1lypTRn3/+qYiICL388suaN2+efvnll7wuFYADEKiAQm7s2LF677331LBhQ61du1b33XeftS8tLU3h4eEKDw9Xhw4ddPDgQRUrViwPq7VPfguCR48eVefOnSVJ//3vf9WrV69MY3bt2qWxY8fe7dIA5BYDQKF18uRJw8nJyfDy8jJiYmKyHdezZ09DkjF9+nSbdklGy5Yts1wmICDACAgIyNSelJRkzJkzx3j44YeN4sWLGyVLljSaNWtmrF+/PtPY+Ph4Y/z48UbNmjWNEiVKGKVKlTIqV65s9O7d2zh79qxhGIbRsmVLQ1Km163bzhjzv1JSUow5c+YYDz30kOHm5ma4u7sbQUFBxhdffJFp7LJlywxJxrJly4zNmzcbTZo0MYoVK2Z4eXkZvXv3Nv74449sj9//atGihSHJeP/992877ubNm9Y/JyUlGfPnzzfatGlj3H///YaLi4tRrlw548knnzQOHz5ss1xoaGiWx+R/j0FiYqIxYcIEo1atWoabm5vh4eFhtGnTxti9e3eW9Rw9etRo3769UbJkScPd3d1o3769cezYMev2zpw5YzPe3uP7xRdfGI8++qhRsmRJIyAgwNi6dashyRg0aFCWdZ0+fdqwWCxGmzZtbns8gbxEoAIKsddee82QZLz66qu3HXfixAlDkvHAAw/YtN9poLp586YRFBRkSDLq1atnDB061Bg4cKDh5+dnSDIWLFhgHZuenm4EBgYakoymTZsaw4cPN0aOHGk8/fTThqenp7F161bDMP7+RZwRmEJDQ42JEycaEydONObOnWtdV1aBKj093ejSpYshyahWrZoxcuRIY+DAgUbp0qUNScYbb7xhMz7jF/6TTz5puLi4GCEhIcbIkSONhg0bWmvMiVOnThmSDD8/PyMtLS1HyxiGYVy6dMlwcnIyWrZsaQwYMMAYM2aM0a1bN8PV1dVwc3MzDhw4YB27du1a67516dLFekwmTpxoHfPnn38atWvXttY+bNgwo2/fvkaZMmUMZ2dnY+3atTbbP3LkiFGqVCnDycnJePrpp42xY8carVu3Njw8PKwB8dZAZe/x7dChg+Hs7Gx07drVGD16tDFw4EAjPT3dqFy5suHh4WFcv34907F59dVXDUnGmjVrcnw8gbuNQAUUYhnhJiOc3I6vr68hybh06ZK17U4DVUaAGz9+vJGenm5tT0xMNBo0aGC4uLgYFy5cMAzDML7//ntDktG1a9dM675586Zx9epV6/uJEycakoydO3dmWUtWgeqDDz6w1p+UlGRtP3funFG2bFnD2dnZ+OWXX6ztGb/wnZ2djT179ljbU1NTrccxMjIyy+3favny5YYk47nnnvvHsbe6efOm8dtvv2Vq/+GHH4ySJUsawcHBNu23nvHJSsZZx8WLF9u0x8bGGn5+fka5cuWMv/76y9rerFkzQ5KxcuVKm/Hjx4+3nv26NVDZe3ydnJyy/DzOnDnTkGQsX77cpj0lJcWoUKGCUb58eSM5OTnLfQXyA77lBxRiMTExkiQ/P79/HJsx5sKFC3ZtKz09XQsXLlTlypU1adIkm2kMSpUqpQkTJig5OVmff/65zXJZ3bPl6uqqkiVL2lVHhg8++ECSNGvWLLm4uFjb/f39NXz4cKWmpmrlypWZluvZs6eaNm1qfV+kSBGFhoZKkg4ePPiP28045vfff/8d1evq6mpzf1uG2rVrq1WrVoqIiFBKSkqO1vXHH39o9erVeuyxx/Tiiy/a9JUvX16jRo3S77//rm3btkmSzp07pz179qhu3brq2bOnzfgxY8aodOnSmbZh7/Ht0qWLgoODM7W/8MILcnFx0fvvv2/TvnHjRl26dEmhoaEqWrRojvYfyAvclA7ARnp6ul3LnTx5UleuXJGvr68mTZqUqf/333+XJP3000+SpJo1a+qhhx7SRx99pN9++01du3ZVUFCQ6tWrJycn8//X++6771S8eHE1atQoU1+rVq0kSUeOHMnUV79+/UxtGeEoPj7edF23c+TIEc2aNUt79uxRTExMpgD1xx9/qEKFCv+4noMHDyotLU1JSUkKCwvL1H/q1ClJf/9ddOrUSUePHpUkmyCZoUSJEqpXr5527txp027v8c1qvCSVK1dOTz31lD7++GP99NNPqlGjhiRZA9b/BkMgvyFQAYWYj4+PfvrpJ0VHR6t69eq3HRsdHS1JWZ4lyYm4uDhJ0vHjx3X8+PFsx12/fl2S5OzsrB07digsLEyfffaZRo4cKenvX6xDhgzRf/7zHxUpUsSuWiQpMTEx2zNzGaEkMTExU5+7u3umNmfnv39UpqWl/eN2fXx8JN35mb59+/bpsccekyS1adNGVatWVcmSJWWxWLRu3TodPXpUSUlJOVpXxt/F3r17tXfv3mzHZfxdZByH8uXLZznO29s7U5u9xzerdWV46aWX9PHHH+v999/X7NmzdfHiRX399ddq2bKlqlWrlu1yQH7AJT+gEHv00Ucl/T0n0u389NNPunjxokqXLm0NBJJksViUmpqa5TIJCQk27zOCSEhIiIy/78/M8rVs2TLrMmXKlNGCBQt04cIF/fjjj3rrrbfk5eWliRMnatasWXbt8631XL58Ocu+jMtyWYUnszLO8uzateuOzvZNnTpVSUlJ2rZtm7744gvNmTNHkyZNUlhYmM3fSU5k7NfIkSNv+3cxceJEm/HZHa/Y2Ngst2HP8b3djPZBQUGqUaOGVqxYoeTkZC1btkxpaWnq37//bfYWyB8IVEAhFhoaKicnJy1evNh6yS0rU6dOlSQ999xzNpfbSpcuneWZlrNnz2a6/FWzZk25u7vr0KFDOb7XJ4PFYlHNmjU1ePBgbd26VZL0xRdfWPszzlTl5AxRhocfflg3btzQgQMHMvVlzLher169O6ozJ6pUqaIWLVooOjraep9Rdm494/TLL7/Iy8tLzZo1sxlz48YNHT58ONOytzsmDRs2lMViUWRkZI5qrlu3rqS/z5L9rxs3blgvCd4qt47vgAED9Pvvv2vdunVaunSpSpcurZCQkDteD3C3EaiAQqxatWoaMWKE/vzzT3Xu3FmXLl2y6U9PT9fkyZP13//+V56enho2bJhNf8OGDXX27Fl988031rbk5GSNGDEi07acnZ01aNAgnTt3Tv/+97+zDFU//PCD9azG2bNndfbs2UxjMs6GuLm5Wdu8vLwk/d9lyZzIuJF87NixNrVER0frjTfekLOzc5YTbjrCm2++qWLFimnIkCFavXp1lmN2795tvcQnSQEBAbpy5YrN5dK0tDT9+9//zjIM3+6Y+Pj4qHv37tq3b59ef/11GYaRacz+/futs8sHBASoadOmOnLkSKZ6X3/9deslxFvl1vENDQ2Vm5ubhg8frl9//VXPP/+8zWcByK+4hwoo5KZPn66EhAQtXrxYVatWVceOHVW5cmUlJiZqy5YtOnXqlNzc3PTxxx/rgQcesFl2xIgR2rJlizp06KBnn31WxYsX19atW+Xp6ZnlzdGTJk3S4cOHNX/+fG3cuFEtWrRQ+fLldeHCBR07dkxHjx5VZGSkypcvryNHjuipp55So0aNVKtWLfn4+OjChQtat26dnJycNHz4cOt6W7VqJYvFotdee03Hjx+Xh4eHPD09NWTIkGz3+/nnn9fnn3+u9evX66GHHlKnTp10/fp1rV69WnFxcZozZ06m/XWUevXq6csvv1T37t3Vo0cPhYeHq0WLFvLy8lJcXJz27t2rY8eOqUqVKtZlhg4dqi1btqhZs2bq3r273NzctGvXLl24cEFBQUGZnmPYpEkTFStWTPPmzdOVK1dUrlw5SdK4ceMkSe+8845Onjyp0aNH68MPP1STJk3k6emp6OhoHTp0SKdOndKlS5dUvHhxSdKCBQvUokUL9erVS5999pmqVKmiw4cP69tvv1WLFi0UERFhc/Yyt46vl5eXunXrpg8//FCSuNyHgiMPpmoAkAe2b99udO/e3fD19TWcnZ2tcws1btzYOH36dLbLrVmzxqhTp47h4uJi+Pj4GEOHDjWuXr2a7Uzpqampxrvvvms0bdrUcHd3N1xdXQ1/f3+jXbt2xsKFC41r164ZhmEY0dHRxquvvmo0btzYKF++vOHi4mL4+/sbTz31VJbzPS1fvtyoU6eO4erqekczpc+ePdu6XKlSpYyWLVtmOWv77eZ12rlzpyHJZuLMnPjzzz+NyZMnG40bNzZKly5tODs7G2XKlDGCgoKM+fPnW49Fhk8//dR45JFHjOLFixtly5Y1unfvbvzyyy/ZzlS+ceNGo2HDhkaxYsWynCn9xo0bxqxZs4z69esbJUqUMIoVK2ZUqlTJ6Nq1q7FixQojJSXFZvx3331ntG3b1ihZsqRRqlQp60zpnTp1MiQZV65csRnvqOP7v7Zt22b9bAIFhcUwsjgXDKDQ+/nnn9W4cWO5urpq9+7dNmdLgAxpaWmqXLmy/vrrryxvTs8Ns2fP1qhRo7RkyRL17dv3rmwTMIt7qIB7VLVq1fTZZ5/pzz//VOvWre2e0BOFQ2pqqv74449M7TNmzNC5c+fUtWvXu1LHzZs39dZbb6l06dLq0aPHXdkm4AicoQLucV9++aWioqJUo0YNfoHdw+Lj4+Xt7a3WrVurWrVqSklJ0f79+3Xw4EFVqFBBUVFROZpU1F579uzRN998o82bN2v37t2aPn26Xn311VzbHuBoBCoAgJKTkzVs2DDt2LFDFy9e1M2bN1WhQgW1b99e48ePt3vC15wKCwvTpEmTVLZsWT3//POaNWuWdUJVoCAgUAEAAJjEPVQAAAAmEagAAABMIlABAACYRKACAAAwiUAFAABgEoEKAADAJAIVAACASQQqAAAAk/4fIjrHCDfFgKwAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.countplot(x='category', data=train_data, order=train_data['category'].value_counts().index)\n",
    "plt.ylabel(\"Number of Questions\", labelpad=12, fontsize=14)\n",
    "plt.xlabel(\"Question Category\", labelpad=12, fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Let's check word statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    5452.000000\n",
       "mean       10.204512\n",
       "std         3.888865\n",
       "min         3.000000\n",
       "1%          4.000000\n",
       "25%         7.000000\n",
       "50%        10.000000\n",
       "75%        12.000000\n",
       "99%        22.000000\n",
       "max        37.000000\n",
       "Name: wordlengths, dtype: float64"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data['wordlengths'] = train_data[\"question\"].str.split(\" \").str.len()\n",
    "train_data.wordlengths.describe(percentiles=[0.01, 0.25, 0.5, 0.75, 0.99])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    500.000000\n",
       "mean       7.516000\n",
       "std        2.732889\n",
       "min        4.000000\n",
       "1%         4.000000\n",
       "25%        5.000000\n",
       "50%        7.000000\n",
       "75%        9.000000\n",
       "99%       15.010000\n",
       "max       17.000000\n",
       "Name: wordlengths, dtype: float64"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_data['wordlengths'] = test_data[\"question\"].str.split(\" \").str.len()\n",
    "test_data.wordlengths.describe(percentiles=[0.01, 0.25, 0.5, 0.75, 0.99])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Overall Distribution:** The mean word count for the training data stands at 10.2 words per quesnon, which indicates that on average, quesions in the training set are moderately long. This contrasts with the test data, which has a slightly shorter mean length of 7.5 words.\n",
    "\n",
    "- **Variability:** The standard deviation, a measure of the amount of variation or dispersion of the word counts, is 3.89 for the training data and 2.73 for the test data. This suggests that the word counts of quesions in the training set are more spread out from the mean compared to those in the test set.\n",
    "\n",
    "- **Word Count Range:** The range of word counts in the training set spans from a minimum of 3 words to a maximum of 37 words. This indicates a diverse set of quesions, from very concise to relanvely lengthy. The test data, on the other hand, contains quesions ranging from 4 to 17 words, suggesnng that it might lack the longer quesions seen in the training set.\n",
    "\n",
    "The distribution of word length is plotted below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.histplot(x = 'wordlengths', data=train_data, binwidth=2)\n",
    "plt.ylabel(\"Frequency\", labelpad=12, fontsize=14)\n",
    "plt.xlabel(\"Number of words\", labelpad=12, fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Let's plot the top words per category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Count-vectorize, eliminate words that occur in less than 10 documents\n",
    "cv = CountVectorizer(stop_words=list(stop_words), min_df=10)\n",
    "data_cv = cv.fit_transform(train_data.question)\n",
    "data_stop = pd.DataFrame(data_cv.toarray(), columns=cv.get_feature_names_out())\n",
    "data_stop=data_stop.assign(category=train_data['category'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1000 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "for index, cat in enumerate(train_data[\"category\"].value_counts().index):\n",
    "    plt.subplot(2,3,index+1)\n",
    "    top10=data_stop[data_stop['category'] == cat].iloc[:,:-1].sum(axis=0).sort_values(ascending=False).iloc[:10]\n",
    "    idx, value=top10.index, top10.values\n",
    "    sns.barplot(x=value, y=idx)\n",
    "    plt.title(f\"Top 10 words in category {cat}\")\n",
    "    plt.xlabel(\"Frequency\", labelpad=12, fontsize=14)\n",
    "    plt.ylabel(\"Words\", labelpad=12, fontsize=14)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Write Clean Data to File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "## pickle data for later use\n",
    "\n",
    "train_data.to_pickle('./data/train_data.pkl')\n",
    "test_data.to_pickle('./data/test_data.pkl')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}