ClassificationMachineLearning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classify the Model then Search for answer \n",
    "\n",
    "Lets see if we can first predict the tag and then We will add the guessed Tag into the query and then will compare the distances of query and our database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/lakshaychhabra/anaconda3/lib/python3.7/site-packages/sklearn/externals/joblib/__init__.py:15: DeprecationWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "import pandas as pd\n",
    "import sqlite3\n",
    "import csv\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "from wordcloud import WordCloud\n",
    "import re\n",
    "import os\n",
    "from sqlalchemy import create_engine # database connection\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk.stem.snowball import SnowballStemmer\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import f1_score,precision_score,recall_score\n",
    "from datetime import datetime\n",
    "from sklearn.metrics.pairwise import cosine_similarity  \n",
    "from sklearn.metrics import pairwise_distances\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.externals import joblib\n",
    "import scipy.sparse\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "con = sqlite3.connect('dataset/processed.db')\n",
    "processed = pd.read_sql_query(\"\"\"SELECT * FROM processed\"\"\", con)\n",
    "con.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "processed = processed.drop([\"index\"], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Title</th>\n",
       "      <th>Body</th>\n",
       "      <th>Tags</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>implementing boundary value analysis software ...</td>\n",
       "      <td>&lt;pre&gt;&lt;code&gt;#include&amp;lt;iostream&amp;gt;\\n#include&amp;...</td>\n",
       "      <td>c++</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>dynamic datagrid binding silverlight</td>\n",
       "      <td>&lt;p&gt;I should do binding for datagrid dynamicall...</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dynamic datagrid binding silverlight</td>\n",
       "      <td>&lt;p&gt;I should do binding for datagrid dynamicall...</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>java lang nosuchmethoderror javax servlet serv...</td>\n",
       "      <td>&lt;p&gt;i want to have a servlet to process inputs ...</td>\n",
       "      <td>java</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>specified initialization vector iv match block...</td>\n",
       "      <td>&lt;p&gt;I've had troubles using an CryptoStream for...</td>\n",
       "      <td>c#</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               Title  \\\n",
       "0  implementing boundary value analysis software ...   \n",
       "1               dynamic datagrid binding silverlight   \n",
       "2               dynamic datagrid binding silverlight   \n",
       "3  java lang nosuchmethoderror javax servlet serv...   \n",
       "4  specified initialization vector iv match block...   \n",
       "\n",
       "                                                Body  Tags  \n",
       "0  <pre><code>#include&lt;iostream&gt;\\n#include&...   c++  \n",
       "1  <p>I should do binding for datagrid dynamicall...    c#  \n",
       "2  <p>I should do binding for datagrid dynamicall...    c#  \n",
       "3  <p>i want to have a servlet to process inputs ...  java  \n",
       "4  <p>I've had troubles using an CryptoStream for...    c#  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# processed = processed[processed.Title != \"\"]\n",
    "processed.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = {\"c#\" : 0, \"java\" : 1, \"c++\" : 2, \"c\" : 3, \"ios\" : 4}\n",
    "labels_map = { 0 : \"c#\" , 1 : \"java\" , 2 : \"c++\" , 3 : \"c\", 4 : \"ios\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "processed[\"Tags\"] = processed[\"Tags\"].map(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Title</th>\n",
       "      <th>Body</th>\n",
       "      <th>Tags</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>implementing boundary value analysis software ...</td>\n",
       "      <td>&lt;pre&gt;&lt;code&gt;#include&amp;lt;iostream&amp;gt;\\n#include&amp;...</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>dynamic datagrid binding silverlight</td>\n",
       "      <td>&lt;p&gt;I should do binding for datagrid dynamicall...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dynamic datagrid binding silverlight</td>\n",
       "      <td>&lt;p&gt;I should do binding for datagrid dynamicall...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>java lang nosuchmethoderror javax servlet serv...</td>\n",
       "      <td>&lt;p&gt;i want to have a servlet to process inputs ...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>specified initialization vector iv match block...</td>\n",
       "      <td>&lt;p&gt;I've had troubles using an CryptoStream for...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               Title  \\\n",
       "0  implementing boundary value analysis software ...   \n",
       "1               dynamic datagrid binding silverlight   \n",
       "2               dynamic datagrid binding silverlight   \n",
       "3  java lang nosuchmethoderror javax servlet serv...   \n",
       "4  specified initialization vector iv match block...   \n",
       "\n",
       "                                                Body  Tags  \n",
       "0  <pre><code>#include&lt;iostream&gt;\\n#include&...     2  \n",
       "1  <p>I should do binding for datagrid dynamicall...     0  \n",
       "2  <p>I should do binding for datagrid dynamicall...     0  \n",
       "3  <p>i want to have a servlet to process inputs ...     1  \n",
       "4  <p>I've had troubles using an CryptoStream for...     0  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "processed.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = processed.Title.values\n",
    "y = processed.Tags.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((343506,), (114503,), (114503,))"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20,stratify = y)\n",
    "X_train, X_cv, y_train, y_cv = train_test_split(X_train, y_train, test_size=0.25, stratify = y_train)\n",
    "X_train.shape, X_test.shape, X_cv.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On Unigram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((343506, 52506), (114503, 52506), (114503, 52506))"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tfidf = TfidfVectorizer()\n",
    "X_train = tfidf.fit_transform(X_train)\n",
    "X_cv = tfidf.transform(X_cv)\n",
    "X_test = tfidf.transform(X_test)\n",
    "X_train.shape, X_cv.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics.classification import accuracy_score\n",
    "score_train = []\n",
    "score_cv = []\n",
    "for i in ([1e-9, 1e-8, 1e-7, 1e-6, 0.00001, 0.0001, 0.001, 0.01, 0.1]):\n",
    "    clf = SGDClassifier(alpha = i, loss = \"log\", class_weight=\"balanced\", n_jobs=-1)\n",
    "    clf.fit(X_train, y_train)\n",
    "    y_predict = clf.predict(X_train)\n",
    "    y_predict_cv = clf.predict(X_cv)\n",
    "    score_train.append(accuracy_score(y_train, y_predict))\n",
    "    score_cv.append(accuracy_score(y_cv, y_predict_cv))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "lis = [0.000000001, 0.00000001, 0.0000001, 0.000001, 0.00001, 0.0001, 0.001]\n",
    "plt.plot(score_train[:-2], lis, label = \"Train Accuracy\")\n",
    "plt.plot(score_cv[:-2], lis, label = \"Cv Accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_alpha = 1e-7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Accuracy of model is :  0.7585035202040495\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics.classification import confusion_matrix\n",
    "import seaborn as sns\n",
    "clf = SGDClassifier(alpha = best_alpha, loss = \"log\", class_weight=\"balanced\", n_jobs=-1)\n",
    "clf.fit(X_train, y_train)\n",
    "y_predict = clf.predict(X_test)\n",
    "acc = accuracy_score(y_test, y_predict)\n",
    "cm = confusion_matrix(y_test, y_predict)\n",
    "print(\"The Accuracy of model is : \", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1a45858208>"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_ax = [\"c#\", \"java\", \"c++\", \"c\", \"ios\"]\n",
    "y_ax = [\"c#\", \"java\", \"c++\", \"c\", \"ios\"]\n",
    "sns.heatmap(cm, annot = True, fmt=\"d\", xticklabels=x_ax, yticklabels=y_ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We are observing as Maximum of data belongs to c# and Java\n",
    "# hence it tend to be majority class. Confusion between C and C++"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets See how SVM will perform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "score_train = []\n",
    "score_cv = []\n",
    "for i in ([1e-9, 1e-8, 1e-7, 1e-6, 0.00001, 0.0001]):\n",
    "    clf = SGDClassifier(alpha = i, class_weight=\"balanced\", n_jobs=-1)\n",
    "    clf.fit(X_train, y_train)\n",
    "    y_predict = clf.predict(X_train)\n",
    "    y_predict_cv = clf.predict(X_cv)\n",
    "    score_train.append(accuracy_score(y_train, y_predict))\n",
    "    score_cv.append(accuracy_score(y_cv, y_predict_cv))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lis = [0.000000001, 0.00000001, 0.0000001, 0.000001, 0.00001, 0.0001]\n",
    "plt.plot(lis, score_train, label = \"Train Accuracy\")\n",
    "plt.plot(lis, score_cv, label = \"Cv Accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_alpha = 1e-6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Accuracy of model is :  0.7510875072063731\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1a514b6e48>"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAAD8CAYAAAC8TPVwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XdcFEcbwPHfcIAUe8NuLCQaY0dEwa5YomKPJfZEE0uMxhY1scdeY+8lxobd2LDFrmDvDY1iBUFFRIG7ef+48wQFORQ4jne++ewnd7Oze88gPDc7O7srpJQoiqIolsHK3AEoiqIoplNJW1EUxYKopK0oimJBVNJWFEWxICppK4qiWBCVtBVFUSyIStqKoigWRCVtRVEUC6KStqIoigWxTuoPiAzyT3WXXDoVqG3uEJJEWhs7c4eQ6HSkul8/AJ6+CjN3CEnixctb4lP3kZCcY5O14Cd/XnJTPW1FURQLkuQ9bUVRlGSl05o7giSlkraiKKmLNsrcESQplbQVRUlVpNSZO4QkpZK2oiipi04lbUVRFMuhetqKoigWRJ2IVBRFsSCqp60oimI5pJo9oiiKYkHUiUhFURQLooZHFEVRLIg6EakoimJBVE9bURTFgqgTkYqiKBZEnYhUFEWxHFKqMe1k9fp1BO279yMiMhJtlJZa1Tzo8V1bBo+ahN+Z86R1dARg9OA+FPm8EFJKxkydw8GjvtjZpWH04F/48ovC3H/4iJ8HjUKr1REVFUXrZg35pvHXhIW9pF23fsbPexQYRH3Pagz8+Ydka+Ofs8bgWacaQYFPcC//NQALl0ylsHNBADJkSMezZ6FUcW9ImbIlmDJ9FABCwLgxf/LPFp8492MuOXM7MWXWH2RzyorU6fh7qTeL5q7gy6++4I/Jv5EmTRq0UVoG9xvF2VMXABg+ZiDValUiPPwVv3QfwoVzlwHIlTsH46cPJ2fuHCAl7Vt0I+DufTO1KwfTDO3SGdq1cO5f9BnQjdZtm/LkSQgA40ZOY+/ug9jYWDN2ylBKliqGTicZ+utYjh72BaB4yS+ZMnMUdnZ27PU5yO+/jjFLmwBmzRlH3TrVCQx8gmu5OgBkypSBpctmkC9/bu78d492bbvz9OlzKlUqz6o18/jvvwAANm/awdgxfwJw8fJBXoS+QKvT/51V9vAyW5uMUvmYtpAyaZ/skdAn10gpCQ9/hYODPZFRUbT7sS8De3VlzcZtVHF3xbNapRj1Dxw5wd/rtjB74gjOXbzC2GlzWTl/KpGRkUgpsbW15eXLcBq1/YG/5kwme7YsMbZv0akn/X/qgkup4ibH+KlPrqngXo6wF2HMnjch1mQ78o+BPH/2ggnjZmBvb0dERCRarRYnp2wcOLqFL53d0Wq18e4noT7lyTXZnbKS3SkbF85dxjGtA//sXc33bXsx9I8BLJi9nP27D1GtZiV++Kkj3zTsRLWalejQpTXtW/xIaZcSDBszAK9abQBYvXkRMybP5+D+ozg42qPTSV6Fv/qouD71yTXvtmv73jV0bvsTDRrVISzsJXNnLIlRv33nlpQoXYxfevxGlqyZWb5mNl/XaImUkq0+K/l90FhO+Z5l+ZrZLJq3gn27D31UXJ/65Bp3d1dehIUxf/4kY9IeOWogISFPmTxpDn1++YGMGTPw+2/jqFSpPD/9/D3Nm3733n4uXj5IZY+Gxi+vT5UYT655dWqzyf/odmUaqifXfCohBA4O9gBERUURFRWFEHH/XPcdOkbDOjUQQlDyq6KEhr4gMCgYGxsbbG1tAYiIjEQXy5fTf3fv8STkKWVLfpU0jYnD0cO+hIQ8i3N9o8b1WOe9BYDw8FdotfrDvTR2aYj+JRvffpLT40dBxp5y2IuX3Lh2ixw5nZBSki6d/ugoXfq0PHoYCIBnvWqsW7UZgNN+50ifPh3ZnbLi/EVBrK01HNx/FICXYeEfnbATw7vtun7Nnxw5neKs7/xFIQ7/exyAJ0HBPH8WSsnSxcjulJW06Rw55XsWAO9Vm6ldr3rSNyAOhw+fICT4aYyyr+vXYsWKdQCsWLGO+g08zRHap5M60xcLZFLSFkJkTepAotNqtTRt353K9VtRoVxpShQrAsD0uUtp3O5Hxk2bS0REBACPAp+QI/vb8JyyZ+VRYBAADx4F0rjdj9Rs3I7ObZq/18ve5rOfOjUqf/BLIblVcC/H48dB+N/8z1hW1qUkR05s49Cxrfzy8+/GJJ5S5cmbi2IlinD65DmGDxrHoOG/cOy8D0NG/MK4EVMByJEzOw/uPTRu8/D+I3LkzE6BQp/x/Fkoc5dOYdv+NQwa3gcrq5TRt8iTNxdflSjK6ZPnAOjwXSt8Dq5n4p8jyZAhPQCXL17Fs141NBoNefPlpnipL8mVOwc5cjrx4P4j474e3H/0weRvDtmzZzV+qT56GEi2aH8vrq5lOHpsG+s3LqZoUWdjuZSSTVuWcfDwZjp2apXsMcdKG2n6YoE++NcghHizfle0sl5JGhGg0WhYt3QmezYs5/yla1z3v83PP3Rky8r5rF4wjWfPQ1n411oAYhveeZOEczplY8Oy2WxbvZBN23cTFBzzEG77nn+pV7NqUjcnQZo2q896760xyk76naWiaz1qVm3Kz326kiaNrZmii5+Doz1zl05h+KBxvAgNo23HbxgxeDxuxWsxYsgEJkwfoa8YyxellGBtraFchTKM/n0SDWq0It9neWje2vzjpA6O9sxbOoVhhnYtW7Qa9zJ18azclMcPA/ltlP48yaq/NvDg/iO27V3NsD8GcPLEGaKitLF2DJJ6aDKxnDlzkS+LeFDBrR5zZi9l5eq5xnU1azTDo2IDmjTqSJcubXF3dzVjpAY6nemLBYqvC/OvEGIHkEMIUUcIkQtoH99OhRBdhBB+Qgi/BctWfnRw6dOlpVyZEhw65ke2rJkRQmBra0ujrz05f/kaADmyZ+Xh4yDjNo8eB5E9a8wedfZsWShcID+nzl4wll257o9Wq6NYEWdSCo1GQ/2GnmxYty3W9deu3uTly3CKfvl5MkdmGmtra+YuncIG73/YsXUPAE1bNWT7lt0AbN24k5Jl9UNRD+8/0p9oNMiRy4lHDx/z4P4jLp67wp3/AtBqtez6Zy9flfgy+RsTjbW1NfOWTmWD9z9s36pvS1DgE3Q6HVJK/l7mTaky+nZptVqGDx5P7SrN6PztT6TPkJ5b/v/x4P5DcuZ627POaWhvSvL4cRBOObIB4JQjG4GBTwAIDX1BWNhLAHbt3I+NjQ1ZsmQC4OEDfRsCA5+wZctOyrqUNEPk7/h/Hh6RUlYCWgLhgCswHfhcCLFKCPHjB7abJ6V0kVK6fNcuYYdMwSFPeR76AoBXr19zzPc0BfLnJTAo+M2+2XvgCM4F8wNQ1cONzTv2IKXk7IXLpE3rSLasmXn4OJBXr18D8Ox5KKfPX+KzfHmMn7N9937q1qySoNiSWtVqFbl+zZ/7998OG+TLnweNRgPoD88LOxfgzp175grxgyZMH86Na/4smLXMWPboYSBu7i4AuFcuz+2bdwDw2b6Ppi0bAlDapQShz1/w+FEQZ09dIEPG9GQ2JIWKlctz/erNZG5JTBOnj+DGNX/mR2tXdqe3Q3J16tfg6uUbANjZ22FvOCdTqWoFoqKiuH7Vn8ePgnjx4iVlXEoA0KxlQ3Zt25eMrYjftn9206ZNUwDatGnKP1v1s5Sit7WsS0msrARPnoTg4GBP2rT68xUODvZUr1GJS5euJn/g70rlPe0PTvkTQuwCjgI64E8pZYgQ4jTQH6icFAEFPglh8KiJaHU6pE5Su3olqrqXp1PPgYQ8fYaUki+cCzK0X08AKlcox8GjvtRt0Ql7OztGDuoNgP/tu0yYMR8hBFJKOrRqwueFChg/Z+feg8yaOCIpmhCv+Yum4F7JlSxZMnHhykHG/jGNv5Z507hZfdatjTk04lahLD/36UpkZBQ6nY5+fYYRbDhTH9d+zKFc+dI0bdmQyxevsf1f/dDV+JHTGdhrGMPGDERjreH169cM7D0cgL0+B6lWqzIHT24jPPwVfXsMAUCn0zH690ms3LgAIQTnz1xipZna9KZdzQzt2vmvPo5xI6fh1bQexYp/gZRw9849BvbRtytr1sys8J6LTkoe3n9Erx9+Ne5rUN+RTDZM+du/+yB7dx80S5sAFi+ZRqXKbmTJkomr148wetRUJk+azbLlM2jXvgUBd+/T9tvuADRuXI/vvmtDVJSW8Fev6NDuJ0A/Br5ylX6oxNpaw5o1m9ntc8BsbTKy0GRsqg9O+RNCOAAVgL8AP8AJKAyMBA5KKf3i+4CETvmzBJ865S+l+pQpfynVp075S6k+dcpfSpUYU/7C9y8y+R/dvmqnlDMLwUQf7GlLKV8Ce4QQD6WUDQCEEOeBu+jHtuNN2oqiKMnKQseqTWXqFZFNo70+JKX0Bsx3zKooihKXVD48YuoE2KFCiIwAUsofhRCZhBCLkjAuRVGUj5NIs0eEEHZCiBNCiLNCiItCiOGG8gJCiONCiOtCiNVCCFtDeRrD+xuG9Z9F29evhvKrQoja0crrGMpuCCEGmtI8U5N2CSml8fIpKWUIUNrEbRVFUZJP4s0eeQ1Ul1KWBEoBdYQQbsA4YIqU0hkIATob6ncGQqSUhYEphnoIIb5EPwuvGFAHmCWE0AghNMBMoC7wJdDKUPeDTE3aVkKITG/eCCEykwJvNqUoipJYPW2p98Lw1sawSKA6b4eHlwKNDK+9DO8xrK8h9FdVeQGrpJSvpZS3gBvop1C7AjeklP5SyghglaHuB5maeCcBR4QQ3oagWwCjTdxWURQl+UQl3kMQDL3hk+hnzc0EbgJPpZRvPiQAyG14nRv9JA2klFFCiGdAFkP5sWi7jb7N3XfKy8cXk0lJW0q5TAjhh/4bRgBNpJSXTNlWURQlWSVg9ogQogvQJVrRPCnlPOOu9DfnLmU4p7cBKBrbJ77ZXRzr4iqPbaQj3umKJg9xGJK0StSKoqRsCZg9YkjQ80yo91QIsR9wAzIKIawNve08wJubvQcAeYEAIYQ1kAEIjlb+RvRt4iqPU8q4fZqiKEpiSbzZI9nezJoTQtgDNYHLwD6gmaFae2CT4fVm3t6bqRmwV+qvXtwMtDTMLikAOAMnAF/A2TAbxRb9ycrN8TVPnUxUFCV1Sbx52jmBpYZxbStgjZRyqxDiErBKCDEKOA0sNNRfCCwXQtxA38NuCSClvCiEWIN+pCIK6G4YdkEI0QPYCWiARVLKi/EFpZK2oiipSyJdESmlPEcsU5ullP7oZ368W/4KaB7HvkYTy+QNKeU2IPbbesZBJW1FUVKXRJw9khKppK0oSupiIQ+X+FgqaSuKkrqk8nuPqKStKErqopK2oiiKBVG3ZlUURbEgWq25I0hSSZ60K5bokNQfkezurYzz8ZgWLXer2eYOIdHZalJnv0SbynuTn0QNjyiKolgQlbQVRVEsSCo/ClFJW1GUVEXq1DxtRVEUy6GGRxRFUSyImj2iKIpiQVRPW1EUxYKopK0oimJB1A2jFEVRLIjqaSuKolgQNeVPURTFgqjZI4qiKJZDquERRVEUC6KGRxRFUSyIuveIoiiKBVE9bUVRFAsSpU5EKoqiWA41PGJ+VlZWLNsxj8cPgujTfiAu7mXo9Xs3bGysuXzuGqN+GYdWq6VO41q0694agPCX4YwdOInrl24CkDZ9WoZM7E+hIgWQEkb2Gcv5kxeTJf6HIS8YsnIfT0JfIoSgqVtR2lQuztX7TxjtfYCXr6PIlTktf7SpQVo7WyKjtIz0PsClu0FYCejXyJ1yhXMBsP3UDRbuOY0QkC29A6NbVydTWnsAVh68wKrDF9BYWVGpaD56N3BLlva98eesMXjWqUZQ4BPcy38NwMIlUynsXBCADBnS8exZKFXcG1K1mju/D++Lra0NERGRDB0yjoMHjgGwdv1CnHJkw9ramqNH/OjXZxg6M80IyJU7B3/OGUu27FmROsnypWtYMGc5Dbxq03dgD5y/KEjd6i04e0b/u2Rtbc3kP0dSvMSXaKw1rF21iT+nzAdgyoxR1KpdlaDAYKpWbGiW9sSmZ8/OdOjQEiklFy9eoUuXfsyZM54yZYoTGRmFn99ZevT4laioKFq2bESfPj8AEBb2kp9+Gsz585fN3IJ3pPLhEStzB2CKlt8149b1/wAQQjBs2iAG/ziMltU78PDeQ75uUQeA+3cf0LVpT1rX7MjCKUsZNL6fcR+/jPiJo/uP07xyW1rX7GjcX3LQaAS/NHRjw4BvWP5TI1YfvsjNhyEMX/MvP31dHu9+zan+VQGW7jsLwLpj+j8C737NmdO1PpO3HEWnk0RpdYzfdJj5P9Znbd/mOOfMwqrD+mThe+Me+y/eZm3f5qzv34L2VUsmW/ve+HvFepo37hSjrHOHn6ni3pAq7g3ZsnknWzfvAuDJkxBat+iKh1t9unftz+z5E4zbdGrfi8oVG1LRtR5Zs2amUeO6ydqO6KKitAwbMp7K5etTr9Y3dPyuNZ9/UYgrl6/TqW1Pjh3xi1G/QaPa2NraUs3di9pVm9Gu4zfkzaf/wl3990ZaNetijmbEKVcuJ7p164i7e31cXDzRaDQ0b96AVas2UrJkdVxcPLG3T0PHji0BuH37Lp6eLXB1rcOYMdOZOXOMmVvwPqnTmbxYIpOTthAiuxAi35slKYOKLnvObHjUqMCmv/8BIEOm9ES8juCOfwAAx//1o3q9KgCc87tA6LMXAJw/dZHsObMB4JjWgdJuJY37iIqM4sXzF8nVBLKld6RoHkMsdrYUdMrI42dh/Pf4KWUL5gTA7fM87DnvD4D/oxDKO+cGIHM6e9LZ2XIxIBCJBAnhEVFIKQl7HUG29A4ArDlyiY7VS2FrrTFul9yOHvYlJORZnOsbNa7HOu8tAJw/d4mHDx8DcPnydezs0mBrawtAaKj+38ba2hobWxukGe8l8fhRIOfPXgIg7MVLrl+7SY6cTly/5s/NG7ffqy+lxMHRHo1Gg52dHRERkYQ+DwPg2BE/noY8Tc7wTWJtrcHe3g6NRoO9vT0PHjxi5859xvV+fmfJnVv/e3rs2EmePn0OwIkTp4zlKYpOmr5YoHiTthCioRDiOnAL+Be4DWxP4riM+gzvyfRRs42Hx0+Dn2FtY03REl8AUKN+VZxyZX9vO69W9Tmy7zgAufPn4umTpwyd8it/7VrA4In9sbO3S64mxHAvOJQr955QPH92CuXIzP6L+h6/zzl/Hj7V/3F/nisL+y78R5RWx70nz7kUEMSjpy+w0WgY1LQSzSeupdbwv/B/FELj8kUA+C/wGaf8H/DttA10nrmZC3cem6V9cangXo7Hj4Pwv/n+EU5DrzqcO3uJiIgIY5n3hkVc8z/Gi9AwNm3ckZyhxilvvlx8Vbwop06ejbPO1k27eBkWzrmrBzh5YQ+z/1zE06dxf5GZ2/37j5g6dR7Xrh3l1i1fnj8PZc+eg8b11tbWtGrVBB+f/e9t26FDS3bufL/c7P7fkzYwEnADrkkpCwA1gMNJGpWBR80KhASFcOX8tRjlg38cTu/hPVjyz1zCXrxEq42Ksb5sxdI0bPU1M0bPAUCj0fBFcWe8l23kW8/vePXyFR16tEmOJsTw8nUkfZfuop9XBdLa2TL8myqsPnyRVlPWEfYqAhuN/p+jkWsRnDI60nrqeiZsOkLJz5zQWFkRqdWy9shFVvVpis/Qb3HOmYVFe84AoNXpCA2PYPlPjfi5gRv9l+82aw/1XU2b1We999b3yosUKczQEf3o0+v3GOXNGneiqHNF0qSxpXKVCskVZpwcHB1YsGw6vw8ay4vQsDjrlS5bHK1WS8kiVXAtWYsfenQkX/48yRhpwmTMmJ769T0pWtSDggVdcXS0p2XLxsb106aN4vDh4xw+7Btju8qVK9C+/TcMGZLyhkfQak1fPkAIkVcIsU8IcVkIcVEI0eud9X2FEFIIkdXwXgghpgshbgghzgkhykSr214Icd2wtI9WXlYIcd6wzXQhhIiveaaciIyUUj4RQlgJIayklPuEEOPiaWwXoAtA/gyFyebwcYdQJcsVp5KnOxVruJEmjS2O6RwZ8ecQfu85ii6NewJQvko58hV8+0dRuGhBhkzsT69v+/EsRH8Y9/hBII8fBHLxtH6seM/W/bRP5qQdqdXyy5Jd1CvjTI0S+hNzBZwyMaer/oTdf4FPOXj5DgDWGiv6eVU0bttu+kbyZc3A1XtPAMibNQMAniULsmivPmk7ZXCkevECCCEoni87VkIQEvaKzGmTf5jkXRqNhvoNPaleqXGM8ly5crBs5Sy6de3H7Vt33tvu9esItm/bQ92va7B/X7L0E2JlbW3NwmXTWL92C9u2+HywbpNm9dm35xBRUVEEBQXje/wUpUp/xZ3/ApIp2oSpXt2D27fvEhQUDMDGjTtwcyvLqlUbGDSoF9myZeabb36Nsc1XXxVh9uxxeHm1Jzg45Q33JOIzIqOAX6SUp4QQ6YCTQggfKeUlIUReoBYQ/Re3LuBsWMoDs4HyQojMwFDABZCG/WyWUoYY6nQBjgHbgDrEM5JhSk/7qRAiLXAAWCGEmGZoTJyklPOklC5SSpePTdgAM8fMo75LM7zKf8OgH4fje+gUv/ccRaYsGQGwsbWhfbfWrF++GQCn3NkZv2AUQ38abRzzBngSGMyj+4/JXygvAOUqleXW9dsfHVdCSSkZvvpfCjhlpG2VEsby4NBwAHQ6yXyfUzSv8CUA4RGRhL+OBODo1QCsNYJCOTKRPYMj/o+eEvxCv92xa/co6JQJgGpfFcD3xj1A/wUQGaUlk6N5hoDeVbVaRa5f8+f+/YfGsvQZ0rHKex4jh07i+LFTxnJHRwecnPTj/xqNhlqeVbh+zT/ZY45uyoxRXL/mz9yZS+Otey/gAR6VywPg4GBPWZeSXL9u3vg/5O7d+7i6lsbeMFxYrZo7V6/eoEOHltSqVYV27XrGOGLLmzcXq1bNpXPn3ty4cctcYX9YIg2PSCkfSClPGV6HApeB3IbVU4D+6JPwG17AMql3DMgohMgJ1AZ8pJTBhkTtA9QxrEsvpTwq9T/kZUCj+JpnSk/bCwgHegNtgAzACBO2SzJtu7XCo2ZFrKwE65Zuwu+w/o/+u94dyJApAwPG9Ab0Z/7b19WfrZ84ZBojZvyGjY0N9+7cZ0Tv5DusO3PrIVtPXsc5Z2ZaTPIGoGc9V+4EPmO1YfZHjeIF8HLVj9MHv3hFt3n/YCUE2TM4MqpVdQCyZ3Ckq2dZOs/cjLXGipyZ0jKiZTUAGrl+wdDV+2k6YQ02Gg0jW1XDhCOtRDV/0RTcK7mSJUsmLlw5yNg/pvHXMm8aN6vPurUxh0a+79KWAgXz03dAd/oO6A5AU68OCCFYsXoOadLYotFoOPDvURYvXJms7YjO1a0MzVt6ceniVXYfXA/AmBFTsU1jy+hxg8mSNTN/rZnDhfNXaNX0exYt+JtpM0fz79EtCAGrVmzg8kX98N7sBROp6OFK5iwZOXVxHxPGzmDl8nVmaxuAr+8ZNmzYxtGj/xAVpeXs2YssXPg3T55c5s6de+zfvwGATZt2MGbMdH79tReZM2di6tSRgP5vzMOjgTmb8L4kmBUihPgMKA0cF0I0BO5JKc++8zeWG7gb7X2AoexD5QGxlH84lvjGPYUQvYG1UsqPOr4rl6tyyhlYTSQH5sX7ZWiRcreabe4QEp2txiIuRUiwZ69fmjuEJBEe/t8n9zRCu9U1Oeekn72jK4ahXIN5Usp50esYRhr+BUYDO4B9gKeU8pkQ4jbgIqUMEkL8A4yRUh4ybLcHfW+8OpBGSjnKUP4b8BL96MUYKWVNQ3kloL+U8oPfgqb8RqcHdgohgoFVgLeU8pEJ2ymKoiS/BIxpGxL0vLjWCyFsgHXACinleiFEcaAA8KaXnQc4JYRwRd9Tzhtt8zzAfUN51XfK9xvK88RS/4PiHdOWUg6XUhYDugO5gH+FELvj205RFMUcpFZn8vIhhpkcC4HLUsrJAFLK81LK7FLKz6SUn6FPvGWklA+BzUA7wywSN+CZlPIBsBPwFEJkEkJkAjyBnYZ1oUIIN8NntQM2xde+hBw7PgYeAk+A9ydGK4qipASJN3vEHWgLnBdCnDGUDZJSbouj/jagHnAD/fBHRwApZbAQYiTwZt7kCCllsOH1j8ASwB79rJF4r4GJN2kLIX4EvgGyAd7A91LKS/FtpyiKYg6JNeXPMDb9wTF2Q2/7zWuJfkQitnqLgEWxlPsBXyUkLlN62vmBn6WUZ+KtqSiKYm4WeqWjqeJN2lLKgaC/9whgF638/ashFEVRzM0y7wNlMlOGRxoAk9GfhHyMvud9GSiWtKEpiqIknIxK3VnblCsiR2Gme48oiqIkmC4BiwUyJWlHSimfAMZ7jwClkjguRVGUjyJ10uTFEplyIvLNvUcOor/3yGPiufeIoiiK2VhoD9pUpvS0G6Kfc9gL/SWcN4D6SRmUoijKx/q/7WkLIQ5JKT2AR7y9k9WbOYujDJe1T5BSzkriGBVFUUyXynvacSZtQ8JGSpkutvVCiCzAEUAlbUVRUgyZygdvP/oWaIYHI1RNxFgURVE+mfx/7WmbwnDDE0VRlJRDJW1FURTLoXraiqIoFkQl7U8U8DIoqT8i2WVsNsXcISSJXjk8zB1Cotvx6ra5Q0gSweGh5g4hxZLa5H3MXnJTPW1FUVIV1dNWFEWxIFKnetqKoigWQ/W0FUVRLIiUqqetKIpiMVRPW1EUxYLo1OwRRVEUy6FORCqKolgQlbQVRVEsiLTM22SbTCVtRVFSFdXTVhRFsSBqyp+iKIoF0arZI4qiKJZD9bQVRVEsiBrTVhRFsSCpffaIlbkDUBRFSUxSJ0xe4iOEWCSEeCyEuBCtrJQQ4pgQ4owQwk8I4WooF0KI6UKIG0KIc0KIMtG2aS+EuG5Y2kcrLyuEOG/YZroQIt6gUnRPO1fuHEyfM4bs2bOi00n+WrqGBXP+ov/gntSuVx2dTvIk8Am9ug3i0cNAKniUY8mKGdy5cw+AbVt8mDJ+NoUKf8acxZON+82fPw8TxvzJ/NnLzdW0GK5ePcKL0DC0Wi1RUVpJAU8wAAAgAElEQVQqun/NX8tn8fnnBQHIkDE9z54+x7V8HVq2bESf3j8Yty1evCjl3epy7tylZI+7+fiuFK1emhdPnjO5dn8A7DM40mZGLzLnyUpwQBAruk8j/HkYBd2K0n5eX0ICHgNwYYcvu6evB6BS57qU+6Y6SMnDq3dZ028OUa8jKVShGPUHt0FjY03AhVt495+LTpv8N5awsrJi5c7FPH4YSM+2fRkzcxjFShYhKiqK86cvM7LfWKKitNRr4kmnHm0BeBkWzqgB47l26QYAw6cMpkqtigQHhdCk6rfJ3oa4pEmThr171pEmjS3W1hrWr9/GiJGT2LtnHenSpQUgW7Ys+PmdoVnz76hcuQLrvBdy+/ZdADZu3M7oP6aaswnv0eoStS+6BJgBLItWNh4YLqXcLoSoZ3hfFagLOBuW8sBsoLwQIjMwFHABJHBSCLFZShliqNMFOAZsA+oA2z8UUIpO2lFRUQwfMp7zZy/jmNaBnfu9ObDvKLOmL2L86D8B6Nz1W/r078aAPsMBOH70JO1adouxn5s3blOrUhNA/wd4+vJ+tm/dk7yNiYdn7RY8eRJifP9t27dtGDf2N549fw7AqlUbWbVqIwDFihVhnfcCsyRsAD/vfzmydCffTH4ba7Ufvbhx5AL7Z2+m6o8NqdqtIdvHrgTgtu8VFneeEGMf6Z0y4d6hDhNr9iXqdSRtZvSiZIMKnFp3kG8m/ci8NqMIuvUQz97NKNu0Mr5r9idnEwFo830Lbl2/jWM6RwD+Wb+TX7sPA2Dc7OE0adOQNUs3cO/OAzo27kbos1A8qrsxdOJA2tT7DoDNq/9h1aK1jP7z92SP/0Nev36NZ+0WhIW9xNramv37NrBj5z6q12hqrLN61Ty2bNlpfH/o8AkaN+5ghmhNk5jDI1LKA0KIz94tBtIbXmcA7hteewHLpJQSOCaEyCiEyIk+oftIKYMBhBA+QB0hxH4gvZTyqKF8GdCIeJJ2ih4eefwoiPNnLwMQ9uIl16/5kyNndl6EhhnrODjYIxPwr1Spihu3b90h4O79+CunEE2b1WfN6k3vlX/zjRer12w2Q0R6t05c4eWzFzHKitUqy0nvAwCc9D7AV7Vc4t2PlUaDjZ0tVhorbO1tef4oBIdMaYmKiCTo1kMArh06T/G6ronfiHg45cxG5ZrurF/x9ud8aM9R4+vzpy/jlDM7AGf9zhP6TP8YsLMnL5LdUA5w8tgZnj19nkxRJ0xY2EsAbGyssbGxjvH3lDatI1WrVmTT5p1xbZ7i6KQweRFCdDEMcbxZupjwET8DE4QQd4GJwK+G8tzA3Wj1AgxlHyoPiKX8g1J00o4uT75cFC9elFMnzwEwcEgv/C7soUnz+kz4409jvbKupdh9aD0r1s7l8yKF39uPV9N6bFy3LdniNomU/LN1BUeP/EPnzq1jrPLwKM/jR0HcuHn7vc2aN2vA6liSuTmlzZaB0MCnAIQGPsUxa3rjunxlnPl5+1g6LRmAk3MeAJ4/CuHf+VsZdGQGQ07M5lXoS64fPE9YcCgaaw15iuuHiErUK0+GnFmSvT39R/7M5JEz0MVyv09raw0NmtXh8L5j761r0roBh/cefa88JbKyssL3xE7uBZxlz56D+PqeNq5r5FWHffsOExr69svZrXxZ/Hx3sXnzcr4s+rk5Qv4gKUUCFjlPSukSbZlnwkf8CPSWUuYFegMLDeWxjUfLjyj/oAQlbSFEsYTUTywOjg4sXDaN3weNMfayx46ahstXNVi/disdu7QB4PzZS5QrXpOaHk1YOG8Fi1f8GWM/NjY21K5bjS0bU1avoWq1JrhVqEdDr3b80LU9Hh7ljeu+aeHFmjXvJ+Zy5Urx8mU4ly5dTc5QP9q9C7cZ496TqXUHcmTJTtrP6wOAfXpHitVyYWylnxhVvhs2Dmko3Uj/gOEVP/1Jg9/a0mPjSF6/eJXs49mVa7kTHBTC5XOx/4wHj+3HyWNnOHX8bIzycu5laNyqAVNGzUyOMD+ZTqejnGttChQsh4tLKYp9+YVxXYtvGsXoGJw+fZ7CzuVxKefJrFmLWeu9MLZdmpWUpi8fqT2w3vB6LfDmEDAAyButXh70QycfKs8TS/kHJbSnbdKZu+iHHC8jQuLf4AOsra1ZuGwq69duZduW3e+t3+D9D183qAXAi9AwXhoO9fb6HMDGxprMmTMa61avVYnzZy8RFPjkk2JKbA8ePAIgMPAJmzbvoJxLKQA0Gg1eXnVY6/3+EEiL5l6sjiWZm9uLwGeky6b/mafLlpGwIP2QwOsX4US8fA3Alf1nsLKxxiFTOgp7fEXw3ceEBYeii9JyYYcv+cvqe293Tl1ndovhzGj0G/4nLhuHSpJLqXIlqOpZie2+6xk/ZySu7mX5Y8ZQAH74pROZsmRkwtBpMbZxLlqIYZN+pVeH/jwLSZnDIXF59uw5Bw4cxbN2VQAyZ85IOZdSbNv+9vxPaOgL43DKjh17sbG2JkuWTOYIN04JGR75SPeBKobX1YHrhtebgXaGWSRuwDMp5QNgJ+AphMgkhMgEeAI7DetChRBuhlkj7YB4/6gTmrRNamX0Qw4H20/7B508YyTXr/kzd+ZSY1mBgvmNrz3rVuPGdX8AsmXPaiwvVaY4VsKK4OCnxrJGTeuxIYUNjTg42JM2raPxdc0albl4Ud+zq1G9Elev3eTevZjJSghBkyZfs3at+caz43Jp90nKNqsMQNlmlbnocxLQD5u8kbdkIYQQvAwJ5en9IPKVdsbGzhaAwu5f8fiGfvaPYxb90IrG1pqqPzTk2Ir3v7ST0vQ/ZlOrjBd1yzWh/w+/ceLwSQb1GE6T1g2oWNWNAT8OjTH+myO3E1MWjWVQjxH853/3A3tOObJmzUyGDPqfs52dHdWre3D1qn7GS9Om9dm2bTevX7821ndyymZ87eJSCisrqxgn0FMCrc7K5CU+QoiVwFHgCyFEgBCiM/A9MEkIcRb4A/3sD9DP/vAHbgDzgW4AhhOQIwFfwzLizUlJ9EMtCwzb3CSek5BgwuwRIcRQ3o6/OAkhjKe/pZQj4tv+U7i6laF5Sy8uXbyKz0H90ciYEVNp3bYJhQoXQCd1BNy9z4De+pkj9b08ad+pJVHaKF6Fv+aHzr8Y92Vvb0flahXp33tYUoacYE5O2Vizej6gHyNdtXoTu3z2A9C8RcNYT0BWqlSee/cecOvWneQM9T2tp/ekoFtRHDOlY9DRGfhM8Wbf7M20mdkL1xZVCbn/hL+66aeDlahbHrdva6HTaol8FcHfPacDcPfMTc5vP06vf/5AF6Xj3sXbHF+p79lV7VKfIjXKYCUER1fs5ubRi2Zra3RDxvfnQcBDlm/VD3/u2fYvcycv4oc+nciYKT2Dx/YFQKvV0qp2J0A/y8SlYhkyZs6Iz6lNzJqwgA0rt5itDW/kzOHEwoVT0Gg0WFkJvL23sm2b/ufforkXEybGHOJp0uRrunZpS1SUlvDwVzFmOaUUiXltjZSyVRyrysZSVwLd49jPImBRLOV+wFcJiUnEN/Mi+kRwYAQQPWkvfX+LmHJm/DLVXZ8U/CrU3CEkiV45PMwdQqLb8eq2uUNIEldCLKMnn1ARrwM++Rr0IzmbmpxzKj5YZ3HXvMfb046emIUQvUxJ1IqiKOaibhgVU+r+aSiKYvFS+cPYE5y0ayRJFIqiKIlEpvK+ZYKSdrQznoqiKClSVCofHknoxTXrkioQRVGUxCARJi+WKKHDIwWTJApFUZRE8n8/pi2EyPfmJWAjhMhreI2U0rwThRVFUd5hqT1oU5nS017K24tr8hveC0NZ9aQLTVEUJeH+73vaUspqb14LIU5LKVWiVhQlxdKqnraiKIrlSOXP9U1w0p4WfxVFURTz0aXynrZJU/6EEEuFEBmllEsM7zMJId67+YmiKIq5yQQslsjUnnYJKaXxHqdSyhAhROkkiklRFOWj/d+fiDSwEkJkMjw9GMPThdV4uKIoKY5OpO7hEVMT7yTgiBDCG/1RRQtgdJJFpSiK8pG05g4giZmUtKWUy4QQfujnZQugiZTyUpJGpiiK8hHU7BEDQ5JWiVpRlBQttc8eSfJx6ZBXL5L6I5KdVpc6T3XMDTph7hASXaF0Oc0dQpLQfcKjxFO71P6TUScTFUVJVdTwiKIoigVJncfBb6mkrShKqqJVPW1FURTLoXraiqIoFkQlbUVRFAuSyh8RqZK2oiipi+ppK4qiWBB1GbuiKIoFSe3ztE26n7aiKIql0CVgiY8QYpEQ4rEQ4kK0sglCiCtCiHNCiA1CiIzR1v0qhLghhLgqhKgdrbyOoeyGEGJgtPICQojjQojrQojVQgjb+GJSSVtRlFQlMZM2sASo806ZD/CVlLIEcA34FUAI8SXQEihm2GaWEEIjhNAAM4G6wJdAK0NdgHHAFCmlMxACdI4vIJW0FUVJVRLzyTVSygNA8Dtlu6SUUYa3x4A8htdewCop5Wsp5S3gBuBqWG5IKf2llBHAKsBLCCHQ3znV27D9UqBRfDGppK0oSqqiE6YviaATsN3wOjdwN9q6AENZXOVZgKfRvgDelH+QStqKoqQq2gQsQoguQgi/aEsXUz9HCDEYiAJWvCmKpZr8iPIPUrNHFEVJVXQJuDmrlHIeMC+hnyGEaA/UB2pIabxPbgCQN1q1PMB9w+vYyoOAjEIIa0NvO3r9OKmetqIoqUoin4h8jxCiDjAAaCilfBlt1WagpRAijRCiAOAMnAB8AWfDTBFb9CcrNxuS/T6gmWH79sCm+D5fJW1FUVKVxDwRKYRYCRwFvhBCBAghOgMzgHSAjxDijBBiDoCU8iKwBv0TvnYA3aWUWkMvugewE7gMrDHUBX3y7yOEuIF+jHthfDFZVNLOkCE9f/89h7Nn93LmzB7Kly/D8uUzOX58O8ePb+fq1cMcP64/J2Btbc2CBZPx89vFmTN76Nevu5mjj938eZO4H3CWM6f3xCjv3q0jFy8c4OyZvYwdMzjGurx5c/E0+Bp9endNzlDjNWPWWG7cOsHRE9uNZYN/683hY/9w8MgWNmxaQo4c2QFInz4tq9bM49DRrRzz3U6bb5satxk+oj9HT2zn6IntNGn6dbK3411WVlb8vWsR05aNA2Dhxpms9FnMSp/F7Dy9kUmL/wCgbpNarN6zhNV7lrB482ycvyxs3Efa9GkZP38k6w6uYN2BvyhRtphZ2hKb2H4Hx40ZwoXz/3LqpA/eaxeQIUN6APLnz0Posxv4+e7Cz3cXM2eMNVfYcUrMnraUspWUMqeU0kZKmUdKuVBKWVhKmVdKWcqw/BCt/mgpZSEp5RdSyu3RyrdJKT83rBsdrdxfSulq2GdzKeXr+GKyqDHtSZOG4eOzn9atf8DGxgYHB3vatn2bjMeOHcLz56EANG36Nba2tri4eGJvb8eZM3tYs2YT//0XYK7wY7Vs2RpmzVrM4sXTjGVVq1SkYYPalC5Tk4iICLJlyxJjm0kTh7Fj577kDjVef69Yx/y5y5kzf6KxbPrU+YweOQWArj+2Z8CvPend6ze+79KWq1du0LJFF7JkzczJUz6sWb2ZatXdKVmqGB4V6pMmjS3bdqzEZ9e/hIaa77F1rb5vzq3r/5E2nQMAnRu9/Z2bsGAU+3ceAuDenQd816Qnoc9CqVjdjSET+tP+a/15rX4je3Fk33H6f/8b1jbW2NnbJX9D4hDb7+DuPQcYNGQMWq2WMX8MYuCAHvw6SP/ldNP/P1zKeZor3HhFidT9wDGTetpCiKXvXPWTSQixKOnCel+6dGnx8HBl8eJVAERGRvLs2fMYdZo1q8/q1fohISkljo4OaDQa7O3tiIiINCb0lOTgoeMEhzyNUda1azvGT5hJREQEAIGBT4zrGjaszS3/O1y6dDVZ4zTFkcO+hLzTlujJ1tHBnjfnbKSUpE3nCEBaRwdCQp4RFRVFkSLOHDp0Aq1Wy8uX4Vw4f5matSonXyPekT1nNirVqMDGv7e8t87B0Z5y7mXZv/0AAOf8LhD6TP87dv7kRZxyZgPAMa0DZdxKsvHvrQBERUbx4nnKeXZqbL+DPrsPoNXq7+Jx7Pgpcue2nGdtJubwSEpk6vBICSml8V9VShkClE6akGJXoEA+AgODmT9/EseObWP27HE4ONgb13t4uPLoURA3b94GYP36bYSFveT2bT+uXz/G1KnzCAl5lpwhfzRn54J4eLhy5NAW9u72xqVsSQAcHOzp37c7I0ZNNnOECfPb0F+4eOUQzb/xYvSoqQDMm7ucz78ozNUbRzlyfBsD+o9ASsmF85epVasK9vZ2ZM6SiUqV3cyaMPqO+Ilpo2aj073/J16tXhVOHPIj7MXL99Y1alWfw3uPAZA7fy5Cnjxl2NRB/L1rEb9NHJCietrx6dihZYwjuwKf5cP3xE727vbGw93VjJHFLqlPRJqbqUnbSgiR6c0bIURmknloxdramtKlv2LevOW4udUjLCycfv26Gde3aOHFmjVvT7yWK1cKnU5LgQLlKFLEnV69vqdAgXzJGfJHs7bWkDFjBip6NGDAwFGs/HsOAMN+78vU6fMJC3s/SaRkI4dPolgRD9au3kSXrm0BqFGzEufPXeKLwhWoVLEBEycNI126tOzdewifXfvZtWctixZP5cSJ00RpzXPftko1KxIc9JTL52I/qqnTqCY7Nu5+r9ylYmkatf6a6aNnA6Cx1lCk+Od4L91Ia89OhIe/omPPb5M09sTy68CfiIqK4u+/1wPw4MFjChRypZxrbfr2G87yZTNJly6tmaOMSYc0ebFEpibtScARIcRIIcQI4AgwPq7K0Sesa7WJcxh4794D7t17gK/vGQA2bNhGqVJfAaDRaPDyqoO399tD2G++8WLXrn+JiooiMPAJR4/6UaZMiUSJJandC3jAxo36cxi+fmfQ6XRkzZoZV9fSjP1jMDeuHeOnnt8xcEBPuv3YwbzBJsDaNZtp6KW/jUObb5uxZfNOAPz9/+O//wJw/rwgABMnzKJSxQY0atgeIQQ3b9w2S7wlXYtTxdOdrSfWMmbOMFw8yjJqxm8AZMiUnmKlinJo99EY2zgXLcRvkwbSu8OvPAvRD989vh/I4weBXDh9CYA9W/dRpPjnyduYj9C2bXO+rleTtu16GMsiIiIIDg4B4NTp8/j73+Zz54LmCjFWangEkFIuA5oCj4BAoImUcvkH6s+TUrpIKV00msT5Fn70KJCAgAc4G35BqlVz5/Ll6wBUr+7BtWs3uXfvobH+3bv3qVq1IqAfVnB1LcPVqzcSJZaktmnzTqpVcwf0QyW2trYEBQVTtXoTCn/uRuHP3Zj+5wLGjvuTWbOXmDfYeBQs9Jnxdd2va3L92k0AAgLuU8Xw75MtexYKOxfg9u27WFlZkSmz/vRJsWJfUOyrIuzdczDZ4waY8cdc6pZtQn3X5vz6wzD8Dp1kSI+RANRsUI2Du48Q8TrCWD9HbicmLhzNbz1Hcsf/7VXLTwKDeXT/MfkL6a+vcPVw4da128naloSq7VmVfn270ahJB8LDXxnLs2bNjJWVPm0UKJCPwoUL4H/rjrnCjFVqHx4xeYhDSnkJ/fxDs+nd+3eWLJmOra0Nt27doUuXvgC0aNGQ1as3x6g7Z85S5s2bxKlTuxFCsGzZGi5cuGKOsD/or+UzqVK5AlmzZua2vx/DR0xk8ZJVLJg/iTOn9xAREUmnzj+bO0yTLFw8FY9K5cmSJROXrh5izOhpeNauSmHnguh0Ou7euUfvXvqe6vixM5g9dzxHjm9DCMHQ38YT/CSENGls2bFLf7I59PkLunTuYzwhlpLU9qrJkhl/xSj7vncHMmTKwK9jfgFAq9XybZ3vABg3eAqjZw7FxsaagDv3GfbzmGSPOS6x/Q4O6N+DNGnSsGO7/t/i+PFTdO8xkEqV3Bg2tC9RUVq0Wi3de/z63slnc9NabB/aNOLtFZhJw84uX6r7CUbpUl4SSQyOtpZzcsxUhdJZzqyHhDj35Ja5Q0gSURH3Pvk2Tr0+a2lyzpl2e5XFPTLBouZpK4qixEem8p62StqKoqQqljpWbSqVtBVFSVUsdSqfqVTSVhQlVUndKVslbUVRUpmoVJ62VdJWFCVVUSciFUVRLIg6EakoimJBVE9bURTFgqietqIoigXRJvFV3uamkraiKKmKmqetKIpiQdSYtqIoigVRY9qKoigWRA2PKIqiWBA1PKIoimJB1OwRRVEUC6KGRz6RTqb20wKpR1jEq/grWZjU+oSXCtmKmDuEFCu1ZxzV01YUJVVRY9qKoigWJLUPj1iZOwBFUZTEJKU0eYmPECKjEMJbCHFFCHFZCFFBCJFZCOEjhLhu+H8mQ10hhJguhLghhDgnhCgTbT/tDfWvCyHaf0r7VNJWFCVV0SJNXkwwDdghpSwClAQuAwOBPVJKZ2CP4T1AXcDZsHQBZgMIITIDQ4HygCsw9E2i/xgqaSuKkqrokCYvHyKESA9UBhYCSCkjpJRPAS9gqaHaUqCR4bUXsEzqHQMyCiFyArUBHyllsJQyBPAB6nxs+1TSVhQlVUnE4ZGCQCCwWAhxWgixQAjhCDhJKR8YPusBkN1QPzdwN9r2AYayuMo/ikraiqKkKgnpaQshuggh/KItXaLtyhooA8yWUpYGwng7FBIbEUuZ/ED5R1GzRxRFSVUSMuVPSjkPmBfH6gAgQEp53PDeG33SfiSEyCmlfGAY/ngcrX7eaNvnAe4byqu+U77f5CDfoXraiqKkKlopTV4+REr5ELgrhPjCUFQDuARsBt7MAGkPbDK83gy0M8wicQOeGYZPdgKeQohMhhOQnoayj6J62oqipCqJPE+7J7BCCGEL+AMd0Xd21wghOgN3gOaGutuAesAN4KWhLlLKYCHESMDXUG+ElDL4YwNSSVtRlFQlMZO2lPIM4BLLqhqx1JVA9zj2swhYlBgxqaStKEqqYspFM5ZMJW1FUVKV1H4Zu0raiqKkKuqGUYqiKBZEm8pvB62StqIoqUpqH9O2mHnaadKk4fChrfj57uLM6T38/tsvAFSr5s7xY9vxPbGTfXvXU6jQZwD06vU9Z8/s5aSfDzt2rCJfvo++ajRZ9ezRmTOn93D2zF5+6vmdsbx7t45cvHCAs2f2MnbMYDNGaJr58yZxP+AsZ07viVEeVzuKFy/KoQObOXtmL6dP7SZNmjTJHXK8YmvT8GH9OHXSBz/fXWz/529y5nQCoFWrxpw66cOpkz4c/HcTJUp8aa6wY7Xm2AqW7J7Pol1zmb9tlrG8acdGrDiwhGV7F/Lj4C4xtsmeKzs7r22lZdfmxrIW3zdl2d6FLN2zgKEzB2ObxibZ2hCXxLr3SEplMT3t169f41m7BWFhL7G2tmb/vg3s2LmPGX+OoWmzTly5coOuXdvx68Cf+O77Ppw5cxG3CvUID39Fly5tGfPHYNp8283czfigYsW+oHPn1lSo+DUREZFs27qCbdv3kCd3Tho2qE3pMjWJiIggW7Ys5g41XsuWrWHWrMUsXjzNWFa1SsVY26HRaFi6ZDodOvbi3LlLZM6cicjISHOFHqfY2jRx0myGDpsAQI/unRgyuDfdewzk9q27VK/RjKdPn1GndjXmzBpHRY8G5go9Vr2a/8KzkOfG96UrlsKjdkU61PyeyIhIMmbJGKN+z2E/cnzfCeP7rDmy0rRTY9pW60TEqwiGz/mNGl7V2b7mo68bSRRqTDsFCQt7CYCNjTU2NtbGm76kS5cOgAzp0/HgwSMA/v33iHG7E8dP0bpVk+QPOIGKFHHm+PFThIfrH/t14OAxGnnVoWzZkoyfMJOIiAgAAgOfmDNMkxw8dJz8+fPEKOvatV2s7fCsVYXz5y9z7twlAIKDQ5I3WBPF1qbQ0BfG146ODsZD86PH/Izlx46fInfunMkT5Cdo1K4Bf81cRWSE/gvz6ZOnxnWVarvz4M4Dwl/GfCSdxlpDGrs0aCOjsLO3I+hhULLGHBudGh5JOaysrPA9sZN7AWfZs+cgvr6n6fpDPzZvWob/TV/atGnK+Akz39uuQ8dW7Ny5zwwRJ8zFi1eoVMmNzJkzYW9vR9061cmTJxfOzgXx8HDlyKEt7N3tjUvZkuYO9aPE1Q5n54JICdu2ruDE8R30/eVHM0eaMCNHDODWTV9atWrMsOET3lvfqWNLdqSw3z8pJZNXjmfB9tk0aPM1AHkL5qGka3HmbpnBn96TKVJSf/W2nb0drbu3ZPHkZTH2EfQwiFVz1uJ9YiUbT6/lxfMX+B44mexteZdMwH+WyKSkLYRwN9ySECHEt0KIyUKI/Ekb2vt0Oh3lXGtToGA5XFxKUezLL+j10/c09GpHwULlWLpsDRPGD42xTetWTShbpgSTJs9J7nAT7MqVG0yYMJMd21eybesKzp67hDZKi7W1howZM1DRowEDBo5i5d8pvy2xiasd1tYa3CuWo237Hv9r786DqyrPOI5/f1zEpCwpIbjVtS4j1ZS9ggaQ2FFxGWJioZWqATuouHZcRop2oAvVUcc6ji0SKSpSgmBBWzZtHBJopWIl1g0mFBHNoEgkqVgdSe7TP+6BCYXEG4R7ck6ez8yZe899X5Ln4Zw8efOejRHnFlE0ehSFIwtCjjZ99/z8Pk46eTDz5i3ihknj92o7d8TZjB//Iyb/bHpI0e3fpKJbuObC67j9x5MpLh1N37PySSQSdM/pxrWX3sjvfvUY02bcA8CE26/mmbKF+4yyu+V0o+CCsxk7ZBxFA8aQ/Y1szi/+fhjp7KXJkmkvUZTuSPv3wH8l9QXuBN4Dnmqpc/PbHSabPjsIYe6toeE/VFW9zAUXjiT/u31Yu3YdAAsWPM/QoQP39CssLOCuu26iuGT8nj/J27vZT5TzvbMuZOR5JezYUU/Nxnep/WArixcvA2Dtq9Ukk0ny8nJDjrTtWsrjg9qtVK1aQ13dDj7//AuWLX+J/v3PDDnatptXvrPKuysAAAc9SURBVIjLLrtoz3p+fh8em3E/xSUT2t2UT91Hqamp+rp6qpatpk+/0/l468dULlsNwDvVG7Ck8c3cHL7Tvw/XT5nIM2vm8oOflHDlTVdQXDqaQcMGsHXLh9R/0kBTYxOVy1Zx5qDwD7gmzdJeoijdot0YXFc/GnjYzB4GurfU2cxmmtkgMxvUKdH1YMRJXl4uOTk9AMjKyqKwsID162vI6dGDU089CYDzzhvO+vUbAejX9wweffReiksmRGIOeLfdB+eOO+4YiopGUT5/Mc89v4KRI88BUlMJXbp0Yfv2A77fTGhayuOFFyrJz+9DdnYWiUSC4cOG8M47NSFHm55TTjlpz/tLLzmfDRv+DaS234L5ZZSOv4Wamk1hhbdfWdlZZHfN3vN+8IhBbNqwmVUr/sbAc/oDqamSzl06U/9JAzcW38qYIeMYM2QcCx5/ljmP/JE/PfEc22q3ccaAPhyelTrTZ2DBAN6r2RJaXrvFfXok3QORn0qaDFwJDJOUADJ6bs/RRx3JrFkPkUgk6NRJLFz4F5YureD66+9kfnkZyWSSHTsamHht6lTA39x7N926dt3zJ/j779dSXDIhkyEfkAXzy8jt1ZNduxq5+eYp1Nc3MPuJch4ve5DqdRV8+eUuJlxza9hhfqWn5zzKiOFDycvLZfOmV5n2iwdazKO+voHfPjyTNS8vxcxYvvwlli6r+IrvkHn7y2nUqEJOO+1kkskkW7bUMumG1D3y757yU3r16skjj6SmRRobGxky9KLWvnzG9Ozdk+mzpgGpM3deXFzBKyvX0vmwzkx+8A6erHicxl2NTL/1vla/ztvr1rNySRWzVsygqbGJmrc28vzcJZlIoVVRHUGnS2k+kfgo4ApgrZmtknQ8cK6ZtThFsluXw4+N3f9g3HcK1/4N7X162CEcEqtqK/b3lJc2+XZe/7R/QDdtX/e1v1+mpTU9EtwMfC6QI+kS4It0CrZzzmVakzWlvURRumePjAFeIXWz7zHAPyRdfigDc865A3EQH+zbLqU7pz0FGGxm2wAk9Qb+SuqZac45125E9fL0dKVbtDvtLtiBOiJ2YY5zrmOI6gg6XekW7eWSVgDzgvWxpJ6H5pxz7UrcTxRIq2ib2R2SSoBzAAEzzWzRIY3MOecOQFTPv05X2jeMMrNngWcPYSzOOfe1RfXy9HS1WrQlrTazAkmfwl6/vkTq4cM9Dml0zjnXRh16TtvMCoLXFi9Zd8659sTntJ1zLkI69EjbOeeixs/Tds65CPGRtnPORUiHPnvEOeeixg9EOudchPj0iHPORYhfEemccxHiI23nnIuQuM9pp/W4saiQNNHMZoYdx8EWx7zimBPEM6845hRlcbsn9sSwAzhE4phXHHOCeOYVx5wiK25F2znnYs2LtnPORUjcinZc593imFccc4J45hXHnCIrVgcinXMu7uI20nbOuViLXdGW1FXSi8H71ZLa9bnokv4edgzOge+LURG7og0MBdZI6gl8ZmaNYQfUGjM7O+wYMkXSSkknttJeKmlqxgJye+lI+2KURbZoS7pK0r8kvS5pjqSTJVUDTwNXAP8E+kqqlnREuNG2TNJOSd0kVUh6TdIbkkYHbfdJmtSs71RJt7XUvz34/+0SdjyZEoe8Je0MXiXpfklvBvvX2ODzoyVVBT9Tb0oaFm7EHZSZRW4BzgA2AHnBem6ztiVAL2AqcHHYsaaRy05StxPoEaznARtJPTy5P1DZrO/bwPEt9W8HubS4XYL1lcCJrfz7UmBq2Hkc7LyjsgA7g9cS4EUgARwJbAGOBm4DpgR9EkD3sGPuiEu7nu9tRSGw0My2A5jZJ83ajjCzOkn5QFko0bWdgOmShgNJ4FvAkWa2TtIRko4BegM7zGyLpMP21x/4MKT4d9tnu0gaD9wStJ8CLJX0JfCumV0mqRdQEbTnAl0kFQXrV5rZGxmM/0C1tj9GUQEwz8yagI8kVQKDgbXAH4L9b7GZVYcZZEcV1aIt2Pv+i5JmkNrZjg2mSU4Flkh60sweCiHGthhHqigPNLNdkjYDWUHbQuBy4CigPI3+Ydpnu5jZbGA2pOa0gVIz29ysvQ7oF7SXkhqJT81ItAfPPnlHnPb3oZlVBQOFi4E5ku43s6cyG5qL6px2BTAmGKUhKdfMrgOmAb8EioAlZtYvAgUbIAfYFhTgkcAJzdrKgR+SKtwL0+gfpn22S8jxZErc8q4CxkpKSOoNDAdekXQCqf2uDJgFDAgzyI4qkiNtM3tL0q+BSklNwDpS86EjgKeAYUBleBG2iQFzgT9LehWoBtbvaUzl2h2oNbOtwcct9g9TK9sl1mKY9yJSZ2G9Tmr/vNPMPpR0NXCHpF2kjsVcFWKMHZZfERmiYGT2mpm1l5Gyc66di+r0SOQFBxdfBh4IOxbnXHT4SNs55yLER9rOORchXrSdcy5CvGg751yEeNF2zrkI8aLtnHMR4kXbOeci5H8MnD8llRVI9AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "clf = SGDClassifier(alpha = best_alpha, class_weight=\"balanced\", n_jobs=-1)\n",
    "clf.fit(X_train, y_train)\n",
    "y_predict = clf.predict(X_test)\n",
    "acc = accuracy_score(y_test, y_predict)\n",
    "cm = confusion_matrix(y_test, y_predict)\n",
    "print(\"The Accuracy of model is : \", acc)\n",
    "sns.heatmap(cm, annot = True, fmt=\"d\", xticklabels=x_ax, yticklabels=y_ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just Similar Kind of Accuracy, Now Lets See If doing bigrams Helps\n",
    "import random\n",
    "random.seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((343443,), (114482,), (114481,))"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20,stratify = y)\n",
    "X_train, X_cv, y_train, y_cv = train_test_split(X_train, y_train, test_size=0.25, stratify = y_train)\n",
    "X_train.shape, X_test.shape, X_cv.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((343443, 703980), (114481, 703980), (114482, 703980))"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tfidf = TfidfVectorizer(ngram_range=(2,2))\n",
    "X_train = tfidf.fit_transform(X_train)\n",
    "X_cv = tfidf.transform(X_cv)\n",
    "X_test = tfidf.transform(X_test)\n",
    "X_train.shape, X_cv.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "score_train = []\n",
    "score_cv = []\n",
    "for i in ([1e-9, 1e-8, 1e-7, 1e-6, 0.00001, 0.0001]):\n",
    "    clf = SGDClassifier(alpha = i, loss = \"log\", class_weight=\"balanced\", n_jobs=-1)\n",
    "    clf.fit(X_train, y_train)\n",
    "    y_predict = clf.predict(X_train)\n",
    "    y_predict_cv = clf.predict(X_cv)\n",
    "    score_train.append(accuracy_score(y_train, y_predict))\n",
    "    score_cv.append(accuracy_score(y_cv, y_predict_cv))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lis = [0.000000001, 0.00000001, 0.0000001, 0.000001, 0.00001, 0.0001]\n",
    "plt.plot(score_train, lis, label = \"Train Accuracy\")\n",
    "plt.plot(score_cv, lis, label = \"Cv Accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CASE OF OVERFITTING\n",
    "best_alpha = 0.000001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Accuracy of model is :  0.6587323771422582\n"
     ]
    }
   ],
   "source": [
    "clf = SGDClassifier(alpha = best_alpha, loss = \"log\", class_weight=\"balanced\", n_jobs=-1)\n",
    "clf.fit(X_train, y_train)\n",
    "y_predict = clf.predict(X_test)\n",
    "acc = accuracy_score(y_test, y_predict)\n",
    "cm = confusion_matrix(y_test, y_predict)\n",
    "print(\"The Accuracy of model is : \", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hence Bigrams are not useful so no need to go further for checking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "# So lets Take our clf_final which is classifier from LR on Unigram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(572512, 68851)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tfidf = TfidfVectorizer()\n",
    "data = tfidf.fit_transform(processed.Title)\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "scipy.sparse.save_npz('data.npz', data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = scipy.sparse.load_npz('dataset/data.npz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = processed.Tags.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'dataset/y'\n",
    "\n",
    "\n",
    "# outfile = open(filename,'wb')\n",
    "# pickle.dump(y,outfile)\n",
    "# outfile.close()\n",
    "\n",
    "infile = open(filename,'rb')\n",
    "y = pickle.load(infile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'dataset/tfidf.sav'\n",
    "# joblib.dump(tfidf, filename)\n",
    "tfidf = joblib.load(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGDClassifier(alpha=1e-07, average=False, class_weight='balanced',\n",
       "              early_stopping=False, epsilon=0.1, eta0=0.0, fit_intercept=True,\n",
       "              l1_ratio=0.15, learning_rate='optimal', loss='log', max_iter=1000,\n",
       "              n_iter_no_change=5, n_jobs=-1, penalty='l2', power_t=0.5,\n",
       "              random_state=None, shuffle=True, tol=0.001,\n",
       "              validation_fraction=0.1, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf_final = SGDClassifier(alpha = 1e-7, loss = \"log\", class_weight=\"balanced\", n_jobs=-1)\n",
    "clf_final.fit(data, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'dataset/clf_final.sav'\n",
    "# joblib.dump(clf_final, filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf_final = joblib.load(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "query = \"global static variable vs static variable function\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now we will add this return label into the title and then we will search for\n",
    "# the Similar queries to see the improvement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_query(query):\n",
    "    preprocessed_reviews = []\n",
    "    sentance = re.sub(\"\\S*\\d\\S*\", \"\", query).strip()\n",
    "    sentance = re.sub('[^A-Za-z]+', ' ', sentance)\n",
    "    sentance = ' '.join(e.lower() for e in sentance.split() if e.lower() not in stopwords.words('english'))\n",
    "    preprocessed_reviews.append(sentance.strip())\n",
    "    return preprocessed_reviews\n",
    "\n",
    "def tfidf_search(query):\n",
    "    query = process_query(query)\n",
    "    query_trans = tfidf.transform(query)\n",
    "    pairwise_dist = pairwise_distances(data, query_trans)\n",
    "    \n",
    "    indices = np.argsort(pairwise_dist.flatten())[0:10]\n",
    "    df_indices = list(processed.index[indices])\n",
    "    return df_indices\n",
    "\n",
    "\n",
    "def label(query):\n",
    "    query = process_query(query)\n",
    "    query = tfidf.transform(query)\n",
    "    ans = clf_final.predict(query)\n",
    "    return labels_map[ans[0]]\n",
    "\n",
    "\n",
    "def change_query(query):\n",
    "    tag = label(query)\n",
    "    return query + \" \" + tag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def enter_queries(query) : \n",
    "    print(\"The Query is :\", query)\n",
    "    query = change_query(query)\n",
    "    df_indices = tfidf_search(query)\n",
    "    print(\"The Model Interpreted Query is :\", query)\n",
    "    print(\"Top Results : \")\n",
    "    for i in (df_indices):\n",
    "        print(\"Title : \", processed.Title.iloc[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Query is : synchronization\n",
      "The Model Interpreted Query is : synchronization java\n",
      "Top Results : \n",
      "Title :  java synchronization\n",
      "Title :  java synchronization\n",
      "Title :  java synchronization\n",
      "Title :  synchronization\n",
      "Title :  java synchronization code\n",
      "Title :  java array synchronization\n",
      "Title :  java method synchronization\n",
      "Title :  synchronization thread java\n",
      "Title :  thread synchronization java\n",
      "Title :  java synchronization problem\n"
     ]
    }
   ],
   "source": [
    "query = \"synchronization\"\n",
    "enter_queries(query)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note : We are getting Indices from the Database, Also we have Body of the dataset. We can make an api system where after a query user can redirected to that thread where the body of question is solved"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "In previous notebook where we used only Distances was giving other results related to other languages also but after using Machine learning we can see the results have improved. And are query Oriented.\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Future Improvement : \n",
    "We can make a web api to do what is mentioned in Note\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}