Week_10/Day_3/scikit_learn_online_supervised_learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "import itertools\n",
    "import os.path\n",
    "import re\n",
    "import tarfile\n",
    "import time\n",
    "import sys\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rcParams\n",
    "\n",
    "from html.parser import HTMLParser\n",
    "from urllib.request import urlretrieve\n",
    "from sklearn.datasets import get_data_home\n",
    "from sklearn.feature_extraction.text import HashingVectorizer\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.linear_model import PassiveAggressiveClassifier\n",
    "from sklearn.linear_model import Perceptron\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "\n",
    "\n",
    "def _not_in_sphinx():\n",
    "    # Hack to detect whether we are running by the sphinx builder\n",
    "    return '__file__' in globals()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReutersParser(HTMLParser):\n",
    "    \"\"\"Utility class to parse a SGML file and yield documents one at a time.\"\"\"\n",
    "\n",
    "    def __init__(self, encoding='latin-1'):\n",
    "        HTMLParser.__init__(self)\n",
    "        self._reset()\n",
    "        self.encoding = encoding\n",
    "\n",
    "    def handle_starttag(self, tag, attrs):\n",
    "        method = 'start_' + tag\n",
    "        getattr(self, method, lambda x: None)(attrs)\n",
    "\n",
    "    def handle_endtag(self, tag):\n",
    "        method = 'end_' + tag\n",
    "        getattr(self, method, lambda: None)()\n",
    "\n",
    "    def _reset(self):\n",
    "        self.in_title = 0\n",
    "        self.in_body = 0\n",
    "        self.in_topics = 0\n",
    "        self.in_topic_d = 0\n",
    "        self.title = \"\"\n",
    "        self.body = \"\"\n",
    "        self.topics = []\n",
    "        self.topic_d = \"\"\n",
    "\n",
    "    def parse(self, fd):\n",
    "        self.docs = []\n",
    "        for chunk in fd:\n",
    "            self.feed(chunk.decode(self.encoding))\n",
    "            for doc in self.docs:\n",
    "                yield doc\n",
    "            self.docs = []\n",
    "        self.close()\n",
    "\n",
    "    def handle_data(self, data):\n",
    "        if self.in_body:\n",
    "            self.body += data\n",
    "        elif self.in_title:\n",
    "            self.title += data\n",
    "        elif self.in_topic_d:\n",
    "            self.topic_d += data\n",
    "\n",
    "    def start_reuters(self, attributes):\n",
    "        pass\n",
    "\n",
    "    def end_reuters(self):\n",
    "        self.body = re.sub(r'\\s+', r' ', self.body)\n",
    "        self.docs.append({'title': self.title,\n",
    "                          'body': self.body,\n",
    "                          'topics': self.topics})\n",
    "        self._reset()\n",
    "\n",
    "    def start_title(self, attributes):\n",
    "        self.in_title = 1\n",
    "\n",
    "    def end_title(self):\n",
    "        self.in_title = 0\n",
    "\n",
    "    def start_body(self, attributes):\n",
    "        self.in_body = 1\n",
    "\n",
    "    def end_body(self):\n",
    "        self.in_body = 0\n",
    "\n",
    "    def start_topics(self, attributes):\n",
    "        self.in_topics = 1\n",
    "\n",
    "    def end_topics(self):\n",
    "        self.in_topics = 0\n",
    "\n",
    "    def start_d(self, attributes):\n",
    "        self.in_topic_d = 1\n",
    "\n",
    "    def end_d(self):\n",
    "        self.in_topic_d = 0\n",
    "        self.topics.append(self.topic_d)\n",
    "        self.topic_d = \"\"\n",
    "\n",
    "\n",
    "def stream_reuters_documents(data_path=None):\n",
    "    \"\"\"Iterate over documents of the Reuters dataset.\n",
    "\n",
    "    The Reuters archive will automatically be downloaded and uncompressed if\n",
    "    the `data_path` directory does not exist.\n",
    "\n",
    "    Documents are represented as dictionaries with 'body' (str),\n",
    "    'title' (str), 'topics' (list(str)) keys.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    DOWNLOAD_URL = ('http://archive.ics.uci.edu/ml/machine-learning-databases/'\n",
    "                    'reuters21578-mld/reuters21578.tar.gz')\n",
    "    ARCHIVE_FILENAME = 'reuters21578.tar.gz'\n",
    "\n",
    "    if data_path is None:\n",
    "        data_path = os.path.join(get_data_home(), \"reuters\")\n",
    "    if not os.path.exists(data_path):\n",
    "        \"\"\"Download the dataset.\"\"\"\n",
    "        print(\"downloading dataset (once and for all) into %s\" %\n",
    "              data_path)\n",
    "        os.mkdir(data_path)\n",
    "\n",
    "        def progress(blocknum, bs, size):\n",
    "            total_sz_mb = '%.2f MB' % (size / 1e6)\n",
    "            current_sz_mb = '%.2f MB' % ((blocknum * bs) / 1e6)\n",
    "            if _not_in_sphinx():\n",
    "                sys.stdout.write(\n",
    "                    '\\rdownloaded %s / %s' % (current_sz_mb, total_sz_mb))\n",
    "\n",
    "        archive_path = os.path.join(data_path, ARCHIVE_FILENAME)\n",
    "        urlretrieve(DOWNLOAD_URL, filename=archive_path,\n",
    "                    reporthook=progress)\n",
    "        if _not_in_sphinx():\n",
    "            sys.stdout.write('\\r')\n",
    "        print(\"untarring Reuters dataset...\")\n",
    "        tarfile.open(archive_path, 'r:gz').extractall(data_path)\n",
    "        print(\"done.\")\n",
    "\n",
    "    parser = ReutersParser()\n",
    "    for filename in glob(os.path.join(data_path, \"*.sgm\")):\n",
    "        for doc in parser.parse(open(filename, 'rb')):\n",
    "            yield doc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "downloading dataset (once and for all) into /home/david/scikit_learn_data/reuters\n",
      "untarring Reuters dataset...\n",
      "done.\n",
      "Test set is 878 documents (108 positive)\n",
      "                 SGD classifier : \t   962 train docs (   132 positive)    878 test docs (   108 positive) accuracy: 0.903 in 0.69s ( 1403 docs/s)\n",
      "          Perceptron classifier : \t   962 train docs (   132 positive)    878 test docs (   108 positive) accuracy: 0.855 in 0.69s ( 1392 docs/s)\n",
      "      NB Multinomial classifier : \t   962 train docs (   132 positive)    878 test docs (   108 positive) accuracy: 0.877 in 0.72s ( 1329 docs/s)\n",
      "  Passive-Aggressive classifier : \t   962 train docs (   132 positive)    878 test docs (   108 positive) accuracy: 0.938 in 0.73s ( 1324 docs/s)\n",
      "\n",
      "\n",
      "                 SGD classifier : \t  3911 train docs (   517 positive)    878 test docs (   108 positive) accuracy: 0.927 in 1.89s ( 2068 docs/s)\n",
      "          Perceptron classifier : \t  3911 train docs (   517 positive)    878 test docs (   108 positive) accuracy: 0.936 in 1.89s ( 2065 docs/s)\n",
      "      NB Multinomial classifier : \t  3911 train docs (   517 positive)    878 test docs (   108 positive) accuracy: 0.885 in 1.90s ( 2055 docs/s)\n",
      "  Passive-Aggressive classifier : \t  3911 train docs (   517 positive)    878 test docs (   108 positive) accuracy: 0.934 in 1.91s ( 2051 docs/s)\n",
      "\n",
      "\n",
      "                 SGD classifier : \t  6821 train docs (   891 positive)    878 test docs (   108 positive) accuracy: 0.954 in 3.09s ( 2208 docs/s)\n",
      "          Perceptron classifier : \t  6821 train docs (   891 positive)    878 test docs (   108 positive) accuracy: 0.952 in 3.09s ( 2205 docs/s)\n",
      "      NB Multinomial classifier : \t  6821 train docs (   891 positive)    878 test docs (   108 positive) accuracy: 0.900 in 3.10s ( 2197 docs/s)\n",
      "  Passive-Aggressive classifier : \t  6821 train docs (   891 positive)    878 test docs (   108 positive) accuracy: 0.957 in 3.11s ( 2195 docs/s)\n",
      "\n",
      "\n",
      "                 SGD classifier : \t  9759 train docs (  1276 positive)    878 test docs (   108 positive) accuracy: 0.958 in 4.26s ( 2290 docs/s)\n",
      "          Perceptron classifier : \t  9759 train docs (  1276 positive)    878 test docs (   108 positive) accuracy: 0.953 in 4.26s ( 2289 docs/s)\n",
      "      NB Multinomial classifier : \t  9759 train docs (  1276 positive)    878 test docs (   108 positive) accuracy: 0.909 in 4.27s ( 2284 docs/s)\n",
      "  Passive-Aggressive classifier : \t  9759 train docs (  1276 positive)    878 test docs (   108 positive) accuracy: 0.940 in 4.27s ( 2283 docs/s)\n",
      "\n",
      "\n",
      "                 SGD classifier : \t 11680 train docs (  1499 positive)    878 test docs (   108 positive) accuracy: 0.935 in 5.29s ( 2208 docs/s)\n",
      "          Perceptron classifier : \t 11680 train docs (  1499 positive)    878 test docs (   108 positive) accuracy: 0.956 in 5.29s ( 2208 docs/s)\n",
      "      NB Multinomial classifier : \t 11680 train docs (  1499 positive)    878 test docs (   108 positive) accuracy: 0.915 in 5.30s ( 2202 docs/s)\n",
      "  Passive-Aggressive classifier : \t 11680 train docs (  1499 positive)    878 test docs (   108 positive) accuracy: 0.958 in 5.31s ( 2201 docs/s)\n",
      "\n",
      "\n",
      "                 SGD classifier : \t 14625 train docs (  1865 positive)    878 test docs (   108 positive) accuracy: 0.960 in 6.48s ( 2258 docs/s)\n",
      "          Perceptron classifier : \t 14625 train docs (  1865 positive)    878 test docs (   108 positive) accuracy: 0.903 in 6.48s ( 2257 docs/s)\n",
      "      NB Multinomial classifier : \t 14625 train docs (  1865 positive)    878 test docs (   108 positive) accuracy: 0.924 in 6.50s ( 2249 docs/s)\n",
      "  Passive-Aggressive classifier : \t 14625 train docs (  1865 positive)    878 test docs (   108 positive) accuracy: 0.959 in 6.50s ( 2248 docs/s)\n",
      "\n",
      "\n",
      "                 SGD classifier : \t 17360 train docs (  2179 positive)    878 test docs (   108 positive) accuracy: 0.957 in 7.56s ( 2294 docs/s)\n",
      "          Perceptron classifier : \t 17360 train docs (  2179 positive)    878 test docs (   108 positive) accuracy: 0.933 in 7.57s ( 2294 docs/s)\n",
      "      NB Multinomial classifier : \t 17360 train docs (  2179 positive)    878 test docs (   108 positive) accuracy: 0.932 in 7.58s ( 2291 docs/s)\n",
      "  Passive-Aggressive classifier : \t 17360 train docs (  2179 positive)    878 test docs (   108 positive) accuracy: 0.964 in 7.58s ( 2290 docs/s)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "vectorizer = HashingVectorizer(decode_error='ignore', n_features=2 ** 18,\n",
    "                               alternate_sign=False)\n",
    "\n",
    "\n",
    "# Iterator over parsed Reuters SGML files.\n",
    "data_stream = stream_reuters_documents()\n",
    "\n",
    "# We learn a binary classification between the \"acq\" class and all the others.\n",
    "# \"acq\" was chosen as it is more or less evenly distributed in the Reuters\n",
    "# files. For other datasets, one should take care of creating a test set with\n",
    "# a realistic portion of positive instances.\n",
    "all_classes = np.array([0, 1])\n",
    "positive_class = 'acq'\n",
    "\n",
    "# Here are some classifiers that support the `partial_fit` method\n",
    "partial_fit_classifiers = {\n",
    "    'SGD': SGDClassifier(max_iter=5),\n",
    "    'Perceptron': Perceptron(),\n",
    "    'NB Multinomial': MultinomialNB(alpha=0.01),\n",
    "    'Passive-Aggressive': PassiveAggressiveClassifier(),\n",
    "}\n",
    "\n",
    "\n",
    "def get_minibatch(doc_iter, size, pos_class=positive_class):\n",
    "    \"\"\"Extract a minibatch of examples, return a tuple X_text, y.\n",
    "\n",
    "    Note: size is before excluding invalid docs with no topics assigned.\n",
    "\n",
    "    \"\"\"\n",
    "    data = [('{title}\\n\\n{body}'.format(**doc), pos_class in doc['topics'])\n",
    "            for doc in itertools.islice(doc_iter, size)\n",
    "            if doc['topics']]\n",
    "    if not len(data):\n",
    "        return np.asarray([], dtype=int), np.asarray([], dtype=int)\n",
    "    X_text, y = zip(*data)\n",
    "    return X_text, np.asarray(y, dtype=int)\n",
    "\n",
    "\n",
    "def iter_minibatches(doc_iter, minibatch_size):\n",
    "    \"\"\"Generator of minibatches.\"\"\"\n",
    "    X_text, y = get_minibatch(doc_iter, minibatch_size)\n",
    "    while len(X_text):\n",
    "        yield X_text, y\n",
    "        X_text, y = get_minibatch(doc_iter, minibatch_size)\n",
    "\n",
    "\n",
    "# test data statistics\n",
    "test_stats = {'n_test': 0, 'n_test_pos': 0}\n",
    "\n",
    "# First we hold out a number of examples to estimate accuracy\n",
    "n_test_documents = 1000\n",
    "tick = time.time()\n",
    "X_test_text, y_test = get_minibatch(data_stream, 1000)\n",
    "parsing_time = time.time() - tick\n",
    "tick = time.time()\n",
    "X_test = vectorizer.transform(X_test_text)\n",
    "vectorizing_time = time.time() - tick\n",
    "test_stats['n_test'] += len(y_test)\n",
    "test_stats['n_test_pos'] += sum(y_test)\n",
    "print(\"Test set is %d documents (%d positive)\" % (len(y_test), sum(y_test)))\n",
    "\n",
    "\n",
    "def progress(cls_name, stats):\n",
    "    \"\"\"Report progress information, return a string.\"\"\"\n",
    "    duration = time.time() - stats['t0']\n",
    "    s = \"%20s classifier : \\t\" % cls_name\n",
    "    s += \"%(n_train)6d train docs (%(n_train_pos)6d positive) \" % stats\n",
    "    s += \"%(n_test)6d test docs (%(n_test_pos)6d positive) \" % test_stats\n",
    "    s += \"accuracy: %(accuracy).3f \" % stats\n",
    "    s += \"in %.2fs (%5d docs/s)\" % (duration, stats['n_train'] / duration)\n",
    "    return s\n",
    "\n",
    "\n",
    "cls_stats = {}\n",
    "\n",
    "for cls_name in partial_fit_classifiers:\n",
    "    stats = {'n_train': 0, 'n_train_pos': 0,\n",
    "             'accuracy': 0.0, 'accuracy_history': [(0, 0)], 't0': time.time(),\n",
    "             'runtime_history': [(0, 0)], 'total_fit_time': 0.0}\n",
    "    cls_stats[cls_name] = stats\n",
    "\n",
    "get_minibatch(data_stream, n_test_documents)\n",
    "# Discard test set\n",
    "\n",
    "# We will feed the classifier with mini-batches of 1000 documents; this means\n",
    "# we have at most 1000 docs in memory at any time.  The smaller the document\n",
    "# batch, the bigger the relative overhead of the partial fit methods.\n",
    "minibatch_size = 1000\n",
    "\n",
    "# Create the data_stream that parses Reuters SGML files and iterates on\n",
    "# documents as a stream.\n",
    "minibatch_iterators = iter_minibatches(data_stream, minibatch_size)\n",
    "total_vect_time = 0.0\n",
    "\n",
    "# Main loop : iterate on mini-batches of examples\n",
    "for i, (X_train_text, y_train) in enumerate(minibatch_iterators):\n",
    "\n",
    "    tick = time.time()\n",
    "    X_train = vectorizer.transform(X_train_text)\n",
    "    total_vect_time += time.time() - tick\n",
    "\n",
    "    for cls_name, cls in partial_fit_classifiers.items():\n",
    "        tick = time.time()\n",
    "        # update estimator with examples in the current mini-batch\n",
    "        cls.partial_fit(X_train, y_train, classes=all_classes)\n",
    "\n",
    "        # accumulate test accuracy stats\n",
    "        cls_stats[cls_name]['total_fit_time'] += time.time() - tick\n",
    "        cls_stats[cls_name]['n_train'] += X_train.shape[0]\n",
    "        cls_stats[cls_name]['n_train_pos'] += sum(y_train)\n",
    "        tick = time.time()\n",
    "        cls_stats[cls_name]['accuracy'] = cls.score(X_test, y_test)\n",
    "        cls_stats[cls_name]['prediction_time'] = time.time() - tick\n",
    "        acc_history = (cls_stats[cls_name]['accuracy'],\n",
    "                       cls_stats[cls_name]['n_train'])\n",
    "        cls_stats[cls_name]['accuracy_history'].append(acc_history)\n",
    "        run_history = (cls_stats[cls_name]['accuracy'],\n",
    "                       total_vect_time + cls_stats[cls_name]['total_fit_time'])\n",
    "        cls_stats[cls_name]['runtime_history'].append(run_history)\n",
    "\n",
    "        if i % 3 == 0:\n",
    "            print(progress(cls_name, cls_stats[cls_name]))\n",
    "    if i % 3 == 0:\n",
    "        print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAEWCAYAAADPZygPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAACEc0lEQVR4nOydZ3hURReA35PeCwQCIfQuvUmTLkVBsYCoqCAoYsFCsX2oqKhgw4YiKlWkCooK0qSpIDX0DiEJLSEkIYW03fl+3JuwhHSyKTrv8+yzd6fdc8vec2fmzDmilEKj0Wg0mpLAoaQF0Gg0Gs1/F62ENBqNRlNiaCWk0Wg0mhJDKyGNRqPRlBhaCWk0Go2mxNBKSKPRaDQlRplWQiIyQUS+t2P7B0Skq7ktIjJTRGJEZJuIdBKRI3bYZzURSRARx6JuW2M/RCRQRDaJSLyIfFTM+04QkVrFvE93EflFROJEZLGd9pHv/5i9/o9lBRGZJSIT7dBubxH5qYB1XEXksIhUyE/5Uq+ERORBEdlh/tHOichKEbmlOPatlGqklNpg/rwF6AkEK6VuVkptVkrVv9F9iEioiNxqs88wpZSXUspyo21ripURwEXARyk1xl47EZENIvKYbZp5v5y01z5zYAAQCJRXSg3MmlkUL4gF+Y8V1f9Rcx3vAJOyyxCRM+bLSHcRWZqRrpRKAWYAL+dnB6VaCYnIaOAT4F2MG74a8CXQvwTEqQ6EKqUSS2DfZR4RcSppGexMdeCg+u+s/q4OHFVKpRemsjmyUKqfP/91RKQN4KuU2ppNXlUgWil1BWgF7MpS5AdgiIi45rkjpVSp/AC+QAIwMJcyE4DvbX4vBs4DccAmoJFN3u3AQSAeOAOMNdMDgF+BWOASsBlwMPNCgVuB4UAyYDFlehPoCkTYtF8VWApEAdHAF2Z6beAPM+0iMA/wM/PmAlbgitnui0ANQAFOZpkgYLkp23Hg8SzHvwiYYx7XAaB1LufrUyAcuAzsBDrZ5DkCrwInzLZ2AlXNvEbAGlOGC8CrZvosYKJNG1nPSSjwErAXSAGcMN6OMvZxELg7i4yPA4ds8lsC44Afs5T7DPg0h+PMcR9AHWCjeY9cBBbmcr5yvJ+ylJsFpAGp5nW8NZ/nZqx5buKAhYCbTX5/IMS8VieAPhhvpRaMezGBq/eYAurY/G/mYNyHp4HxXL2fhwJ/Ah8CMcAp4LZcjr8hsAHjv3EAuNNMf9M81jRTjuFZ6vXJkr/HTN9gHsNfGPd8HeBRm+t9EniiMOesEOf3ReAccBZ4zPYc5vAs+s4sfwaYiPF/cTGv0Sib/9BfwOvm75uBLeb5Owd8AbjYtKuAp4Bj5vG/jfG8+Nu87osyymccH8Z/9KJ5fIOz3IO291s/U7ZYs72mNnkvmccRDxwBeuRw3K8D3+aQdzcw09xeCNyeTZljQJc8n/V5FSipj3kjp2M+jHMoM4FrldAwwBtwxehBhdjkncN86AL+QEtz+z1gGuBsfjoBYnMj32r7B87uD2LefHuAKYAn4AbcYubVwRjGcwUqYDzMPsnyZ7nV5ncNrlVCmzB6f25Ac4yHS3eb40/GULCO5rFszeV8PQSUx1AGYzAesBl/4nHAPqA+IEAzs6y3ee7GmDJ4A21zuPEzz4nNsYVgKGh3M20ghmJ1AAYBiUBlm7wzQBtThjoYb9yVzXIZytsJiARa5XCcue1jPvA/My/zOuXQTo73UzZls56L/Jybbaac5TAexCPNvJsxHpw9TTmrAA3MvA3AY1n2bauE5gA/m3LXAI5iKgmMezgNQ9E7Ak9iPIQlm+NxxnjpeRXjYdsd46FVP7v/Xl7/TRvZwzBeapzMffTFePAK0AVI4up/syDnrCBl+2Dc+40AD+B7cldCy4CvMf7bFc12nzDzGmMo9IYY99VWwNHMawW0M4+1hinD81mu28+AjylLCrAOqIWh+A4CQ2yOLx34GON+7IJxX2dcj1mY9xvQAuP/0da8zkPM8+GK8f8OB4Jsnje1czjuxcC4LGlvYCi2ZPNaxWK8GMWZ2442ZZcDz+b5rM+rQEl9gMHA+TzKTCCHPwLgZ15kX/N3GPAExpi9bbm3zBvhuhuQ/Cuh9hjKIUeFaVPvLmB3dvuwuSmUeeNWNS+wt03+e8Asm+Nfa5N3E3ClAOc4Bmhmbh8B+mdT5gFbebPkZd74Wc+JzbENy0OGkIz9AquA53IotxKzF4jxlnewAMdpu485wHSMub2C3I/X3E/5OBf5OTcP2fx+H5hmbn8NTMlhPxvIQQlhPHBSgZts8p4ANtjcw8dt8jzMupWy2U8njAe1g03afGCCzb1XGCX0Vh7n+aeMe6CA56wgZWcA79nk1SEHJYQxDZCC+RJl859Yb/N7DMb/Jwaom8uxPQ8sy3LdOtr83gm8ZPP7I8wXVq4qIU+b/EXAa1nvN+Ar4O0s+z6CobjqYCioWwHnPK7FGkzFnSXdCUOhBgIdgN9yqD8Ps1eY26c0j8lGAwH5nUsQEUcRmSQiJ0TkMsZNCMZwG8C9GD2G0yKyUUTam+kfYLzxrRaRkyKSr8m0LFQFTqtsxsdNq6kF5iTeZYy3roDrWsieIOCSUireJu00xptxBudttpMAt5zOmYiMFZFDpkVTLMbbVoYsVTGGfbI7tuzS80t4FhkeEZEQEYk1ZWicDxkAZmP05DC/5+a0wzz28SLGW/c20/pxWA5t5HU/FQVZr52XuV3Ycx6A0bs4bZOW4/2ilEoyN724niAgXCllzaWtwpD1frhNRLaKyCXzWt1O7uc4p3NWkLJBWeS4RqYsVMc4p+ds7qevMXpEGcw2y61QSh3LSBSReiLyq4icN++hd7n+2C7YbF/J5rft8cWoa+ekT5vHkp3MYzLkNWWuitH7OY6hDCcAkeazKbs2wFCq3jbH09xsKwZDmR0B1gNdzf3ck6W+N0bvKFdKsxLagvEGclc+yz+IMY5+K8bDtYaZLgBKqe1Kqf4YN89PGG8RKKXilVJjlFK1gDuB0SLSo4CyhgPVcnj4v4vxxtNEKeWD8QAVm3yVS7tngXIi4m2TVg1jyKpAiEgnjAfwfYC/UsoPowudIUs4xrBIVsIxhgeyIxHjbTqDStmUyTw+EakOfAM8g2FV5Qfsz4cMYFyzpiLSGKMnNC+7QnntQyl1Xin1uFIqCKOX8KWI1MmmqVzvp3yQn3OTE7mdh9zul4sYw23VbdIKdb9g3HtVsxgPFKStnOS0vR9cgR8x5qgCzWu1gvyf48JyDgi2+V01l7LhGM+hAKWUn/nxUUo1sinzJca8cu8slrtfAYcxekc+GEObN3Js/iLiafO7GsZ1yk7md2zk9VNKeSil5gMopX5QSt2CcZ8oYHIO+9sL1Mv4oZQKMa/ROxg9HD+MIcNm5j6WZqnfEGOaIldKrRJSSsVhTIxNFZG7RMRDRJzNN6f3s6nijXGzRGP8+d/NyBARFxEZLCK+Sqk0jEk/q5nXT0TqiIhgPJQtGXkFYBvGjT1JRDxFxE1EOtrIlQDEiUgVjLkXWy6Qw0NeKRWOMan4ntlmUwwjicKYvnpjdOejACcReR1jLDqDb4G3RaSuabnUVETKY/y5KovI86b9v7eItDXrhAC3i0g5EamE8YaVG54YN30UgIg8itFLsZVhrIi0MmWoYyoVlFLJwBIMq5ttSqmwwuxDRAaKSMYDKMYsm931zvF+yichFOzc2PId8KiI9BARBxGpIiINzLzc7hcLxsvVO+Z1qg6MpnD3yz8YvYcXzf9dV+AOYEE+618AauRhAeeCMU8RBaSLyG1Ar0LIWlAWYZzfhiLiAbyWU0Gl1DlgNfCRiPiY16O2iHQBEJGHMeZ+hgLPArNFJKP34o3xrEkwr9+TRSD7m+bzrBPGy1h2a7S+AUaKSFvzf+QpIn3Ne6K+GCbVrhjzOlfI+Xm3AmMILyutgF0i4sLV3tU1mM+6chhzZLlSapUQgFLqI4w/0XiMGzUc4w33p2yKz8Honp7B0M5ZD/5hINTsFo/EmHMCqAusxVAUW4AvlVLrCyinBeMPWgdj7ikCY0IcDEuilhgK7jcMCzpb3gPGm93Zsdk0/wDGW/hZjAnSN5RSawsin8kq4HeMierTGDeg7TDExxh/ztUYf5zvMMbB4zEmyO/AGN44BnQz68zFeNMJNestzE0ApdRBjHHuLRgPqSYY1kQZ+Ysx3rJ+wJgE/wnjRs5gtlknx6G4vPaBYfTwj4gkYEycPqeyX2OT1/2UFwU6N1mOYRuG1dgUjPtmI1d7N58CA8RYNP1ZNtVHYfTCTmJYwv2AMQdSIJRSqRjX/DaMHtaXwCNKqcP5bCLj4RgtIlnNdzP2EY/x4F6E8ULwIMY1sStKqZUY1pXrMYbiM65tSg5VHsFQmAcx5FyC8WJWDcNg5RGlVIJS6gdgB8Z1A8M670GMe/kbCnAP5MB5c/9nMUYCRmZ3PZRSOzCMT74wyx/HUJJgKP1JGNf0PMbI0CvZ7UwptQvj5bltlqwMk+wmGKMM2fEgMFsZa4ZyJcMKTKMp9Zh/+sMYE+mXS1oezb8DEWmI8TB1zW5etzRg9kS/V0oF51G0qPfbC3hKKXVXAeq4YryAdVZKReZVvlT3hDSaDMxhndHAAq2ANDeKiNxtDi/7Y8yJ/FJaFVBJopRaXRAFZNZJUUo1yI8CAjsrIRGZISKRIpJtl80cr/xMRI6LyF4RaWmTN0REjpmfITbprURkn1nnM3MuR/MvxpyMvYwxLPhGCYuj+XfwBIap8gmMeeCimK/RFAK7DseJSGeMuZY5SqnG2eTfjjGGfTvGwqpPlVJtRaQcxthqa4yJ450YCxNjRGQbxjjyPxgTZ5+ZY7wajUajKWPYtSeklNqE4eolJ/pjKCilDP9EfiJSGegNrFFKXVJKxWAsmupj5vkopbYqQ3vOIf8m3BqNRqMpZZS0U8kqXGuhFWGm5ZYekU36dYjICAzPxri7u7eqWjW3pQA5Y7VacXAoG1NnZUXWsiInlB1Zy4qcUHZkLStygv1kPXr06EWlVL5CMhSWklZCdkMpNR3DPQutW7dWO3bsKFQ7GzZsoGvXrkUomf0oK7KWFTmh7MhaVuSEsiNrWZET7CeriJzOu9SNUdJq/gzXrlYONtNySw/OJl2j0Wg0ZZCSVkLLgUdMK7l2QJy5QnkV0EtE/E0Tyl7AKjPvsoi0M63iHsFwPqrRaDSaMohdh+NEZD6G99cAEYnAMK91BlBKTcOwbrsdY0VvEsYqcZRSl0TkbWC72dRbSqkMA4enMDzGumN4VtaWcRqNRlNGsasSUko9kEe+Ap7OIW8G2bgbMV1SXGfurdFoNJqyR0kPx2k0Go3mP4xWQhqNRqMpMbQS0mg0Gk2JoZWQRqPRaEoMrYQ0Go1GU2JoJaTRaDSaEkMrIY1Go9GUGFoJaTQajabE0EpIo9FoNCWGVkIajUajKTG0EtJoNBpNiaGVkEaj0WhKDK2ENBqNRlNiaCWk0Wg0mhJDKyGNRqPRlBhaCWk0Go2mxNBKSKPRaDQlhlZCGo1Goykx7KqERKSPiBwRkeMi8nI2+dVFZJ2I7BWRDSISbKZ3E5EQm0+yiNxl5s0SkVM2ec3teQwajUajsR9O9mpYRByBqUBPIALYLiLLlVIHbYp9CMxRSs0Wke7Ae8DDSqn1QHOznXLAcWC1Tb1xSqkl9pJdo9FoNMWDPXtCNwPHlVInlVKpwAKgf5YyNwF/mNvrs8kHGACsVEol2U1SjUaj0ZQI9lRCVYBwm98RZpote4B7zO27AW8RKZ+lzP3A/Cxp75hDeFNExLWoBNZoNBpN8SJKKfs0LDIA6KOUesz8/TDQVin1jE2ZIOALoCawCbgXaKyUijXzKwN7gSClVJpN2nnABZgOnFBKvZXN/kcAIwACAwNbLViwoFDHkZCQgJeXV6HqFjdlRdayIieUHVnLipxQdmQtK3KC/WTt1q3bTqVU6yJv2BallF0+QHtglc3vV4BXcinvBURkSXsOmJ5Lna7Ar3nJ0qpVK1VY1q9fX+i6xU1ZkbWsyKlU2ZG1rMipVNmRtazIqZT9ZAV2KDvpiIyPPYfjtgN1RaSmiLhgDKstty0gIgEikiHDK8CMLG08QJahOLMnhIgIcBewv+hF12g0Gk1xYDclpJRKB54BVgGHgEVKqQMi8paI3GkW6wocEZGjQCDwTkZ9EakBVAU2Zml6nojsA/YBAcBEex2DRqPRaOyL3Uy0AZRSK4AVWdJet9leAmRraq2UCuV6QwaUUt2LVkqNRqPRlBTaY4JGo9FoSgythDQajUZTYmglpNFoNP9GIg/DmtfBkl7SkuSKXeeENBqNRlOMWC1wZCVs+xpObQJHV2h0NwS1KGnJckQrIY1GoynjOKXFw5+fwPbvIC4MfIKhxxvQcgh4ZnVCU7rQSkij0WjKKuf3wT9f037PQrCmQo1O0PsdqH87OJaNx3vZkFKj0Wj+6yRehKjDEHnI+D67G87sBCd3LgR2Jaj/G1CpcUlLWWC0EtJo/ouc/hssaVCrS0lL8p8lNTychA0bcapYEe/u3RBnZyMjMdpQMlGHDOOCDMWTdPFqZVcfqNAAer4NLR7i6La9BJVBBQRaCWk0/z0unYLvB4AlFYb+BtXalrRE/wmUUqQcO0b8mjXEr11HyqFDmXlOPq74NfXAr2okzirqaiUXb6jYAOrfBhUbQoX6UKEh+ASBSK77s6amEr9mDT63347kUbYk0UpIU3xYreCgVwWUKFYr/Pw0ODiCVxVY9DCM2GA81P6DKKXAakUcHe3TvtVK8v79huJZvYbU06dBBPcWLaj43JN4h31IysVkYk74cvHPFC46uODTujP+9/TFvWtfxDc4T2WT3THFr15D5IcfkhYejktwMO7Nmtnl+IoCrYQ0xcMf78CfU6ByM2pLEFSIhaptwadySUv23+KfaXD6L+g/Faq0gm96wMKHYOgKcHYraemKnfMT3iR2yRJcgoNxqVnT/NTAtWZNHC5fRilV4F6ESk8nacdOs8ezlvQLF8DJCc+2bSn36KN49+iOU4UKsOgRiE7BZdRqvCs3IzUsjJj5C4hdupTLL3+Ka72V+D/4IL539MPB0zNf+75y4ACR700iaccOXOvWpep335ZqBQRaCWmKg4vHDQUU1BwcXQgK/x0Wmw7VfatB1TaGQqp6MwQ2Bkfn65pIO3uWC++9h2O58nh17YJn+/Y4uP33Hpo3xMVjsO5NqNcHmg823rDv+dpQQr+NNhRTKR62KVKsVlL/XkLs4oV41CyHY+36pIaGkrhlCyolBYAKwNG3J+JSsyauNWsYCqqGqaiqV7vm/rOmpJD499/Er1lLwh9/YImNRVxd8ex0Cz6jX8Cra1ccfX2v7v/I73DwZ+j+mvG/AFyqVyfw5Zeo8NyzXP7tNy798APnJ0wg8sMP8b37bvwfuB/XWrWyPRyHuDjOvvo/4pYtw9HPj0oT3sBvwADEqfQ/4ku/hJqyz6pXwckNBs0D70D+/GMNXeqXg/BtEP4PhG2F/T8aZZ09jDf0qjdD8M1Q9WZSL10hbMgQLDExAMQuXIi4ueHZvj1eXbvi1bUrzoEVS/AAi5fkw4eJX7MWzw7tcW/WLH8PGks6LBtpXIc7Pr2qbBreAV1ego2ToXIzaPtE3m1ZLbB3IYgDNB5QZkyBAYg+AXvmQ8h8Lq5JQMSdKo0P4tT/AejwKcpqJe3sOVJPneLAmtVUd3Ii5dQpErf+Q9zPNpFoRHCuXBmXmjVx8HAn8a+/sSYl4eDlhVe3bnj3vBWvW27BwcPjehlSE2HFWMOwoMOz12U7uLvjN2AAvvfey5WQEGJ+mE/sggXEzJ2LR/t2lBs8GK+uXREnJ6zJyVyaNYvyX00jzmql3LBHCRg5Ekdvb07GneSHQz/wWJPHqORZyY4n9cYoQ3ePpkxybA0cWwU93wLvQACUg7OhaKq0gnZPGuXiIkylZCqmvz4Fazqp8Y6c3lgJq8WRaq8+iGud2iQdDCVhx2ESdoaQsH49AG61gvBq1QCv1g1wq1kZKaK5pwqRB2H/pWsTq7UrsTmUlFOnCHt0GJaYGC5OnYqDry9enTrhVrEClubNcfTzy77i35/BmR1w73fgneWB1OVlY73J769AxZugZqecBTgbAr8+b5gHg6G8ur4Kje8tvfN9yZfh4E8Q8gOEbQFxILXcLcSdPon/g4NwqnME1k6AGh2RoBa4BFfBJbgKVyzpVOraNbMZa2IiqadPk3LqFKmnQkk9dSrz49O3L969euLZti3i4pK7PBveg7hwePR3cMq5rIjg0aIFHi1akP7yS8QuXkLMwoVEPDMKp8qV8bntNi7/vpL0s+dIbd6cRpMn4VK9emb9NaFrWHRkEU80zceLRQmilZDGfqSnGg+2crWh7ZO5l/UNNj6N7zF+pyaRsm0lYWPfRVlSqN4rCbcDk+CAEYLXyxdUN0iJcyLhrBsJZ1O5uPgMFxf/gZObBa+gZLyqJOMZmIqDU+FD2DcCOJgl0b0cDF4MwfaNepyV9Kgowh97HESo8eMS0sIjSNiwgYRNm/C9dImjs2bj3rIFXl264N21Ky516hjzGRcOGA++m/obyiIrDg5w99fwbQ9YPMQwVPCrdm2ZlHhY/64xp+QRQNo903Fy9kI2vAtLH4M/P4Zur0KDfqVjSM9qhdBNhuI5uBzSr0D5unDrBGg6iOgPvkKcwij/+EjwdoJpnWDJMHhiE7h6Z9ukg6cnbjfdhNtNNxVernN7YcuXhieD6u3zXc2pfHkCRj5B+ceGk7BhAzE//MClGTNwvakhQe9NYvuVpGsUEMC6sHU0q9CMCh4VCi9vMaCVkMZ+bJsO0cfgwUW5vvFlR0r4OU6/8gk4uFFtwXzc6tWF2NOQlpxZRgA38xMApMfGkbB1Fwl/b+fythBiT15BXFzwbNUErw6t8WrfGueKAQU7hO3buLnNzVcTkuNg2RMwqx8MnAX1+xSovcJiSUggbMQTpMfEUH32bNwbNcK9USN8+vRGWa38NXs29S5fJmHjRqI++piojz7GOSgIry6d8bqyAg8fHxz6fpyzgnDzgfvnwzfdYMGDMGw1uHiAUnD4V1j5Elw+C62Hobq/xvCNz5GQlsCnD86navh2Q0EtfMjwUdZ9PNTuUTLKKGO4bc8Co7fh6gvN7ocWDxk9bxHSzpwhdtlP+A8adHUY995vYFZf+G0M3DPdPrJZLfDLc+BRDnq+WagmxMkJ71tvxfvWW7HExeHg7W30+jdsuKZcRHwEhy4dYmzrsUUguH3RSkhjHxIijaGaOj2hXu8CVU0+epSwR4eBCNXnzMa1Th0jw79GrvWcKoJfvbb4PfIkKjWVpB07iF+/gYT160n46Gvgazy7dKbql1/m2yQ3yfO8sU7DluGrYd5A42F9xyfQ8pECHV9BsaamEvHMKFKOHaPqtGm4N7l2UaI4OJBesyYVu3al4nPPkXbhAgkbN5KwYSOxPy4hJjUdcfXEM+INvLp0watrF5wDA6/fUUAdY7juh/tg+Si49Q1Y8SIcXWkYjAycDVXbsDF8A7sjd+Pk4MQDKx/kwy4f0u6pf4x5oo2T4Pt7oVoHQxnV6GjXcwNkO9xGrW5Gr6dBX3B2v6b4xenfICKUf/yxq4nVOxjDkhveNeo2f6Do5dz+HZzdZZxjd/8bbu4aQ4csrAtbB0D3aqU/BqhWQhr7sO4tSEuCPu8VqFry4cOEDX0UcXGh2qxZuNaqWajdi4sLnh064NmhA+rVV0g9cYLYpcu4NGMGcb/8gt9ddxWqXQC8KhqLPBc9Yjys489D53F2efNXVitnX3qJpK1bCXp/Ml63dGTbuW38dfYv2lRqQ5tKbXB1dL2mjnNgIP733Yf/LXWxTptPkkd3ElKbGYrpjz8AcG3YEL+7+uP/4INXV+oD1OsFPV4zrt/Bnw1LxZ5vG3N3js4opfhqz1cEewXz5a1fMnrDaEauGcm4NuN4sPmDSJOBsGs2bPoQZt0OtbsbyqhKq6I7KVaL4UEgYjuE/gmHf7s63NbjDaPnk8OcXdq5c8QuXYrfvffgXCnL3FjnsYbn6d/GQHCbopMXjF7kureM85HdkGgRsy5sHQ3KNaCqd1W77+tG0UpIU/Sc3Q27v4f2T0NA3XxXu7L/AGHDh+Pg4UH1WTOvG+MuLCKCa506pD4xCOvmP7j4xVR8+/a99uFbUFy94MGFhhJa/47xkOn7kbEItIhQSnHhvUnEr/ydiuPG4dnvdj7b9Rnf7vsWhWLG/hm4O7nTtnJbKiVWomFiQwI9zR5OegosexIH34p4PfUNXu7+KDWe1OPHSdi4kfi167jw3iRily6j0oQ38Ghh4+r/ltEQd8ZwE9Nr4jXzQ5vPbOZg9EHe6vAWNX1r8v3t3/PK5leYtG0SRy4dYXy78bjc/Lgx/LX9W8M0/5vuUL8vdP8fBDYq+IlIiDKMKiK2G4YrZ3dDaoKR51HeUDrNBxtzdHm8CER/8y0AASNGXJ/p4GgMxU3rCD8OQ+q+VnBZc2LlS2BNM+4ROw9TRiVFERIZwpPN85iHLSXYVQmJSB/gU8AR+FYpNSlLfnVgBoZJ/iXgIaVUhJlnAfaZRcOUUnea6TWBBUB5YCfwsFIq1Z7HUeZJvgwunkX6gMwRpYw/nGcAdHkx39Wu7N1L2PDHcPT2ptqc2bgEBxeZSJFJkXy952uWHltKk+ZpvLLYQuyPS/G/f9CNNezoDHd9ZVib/TnFGIIc8N11wz+FJfrbb4mZO5dyQ4aQOug2hq0axu7I3dxb915eaPUC+y7uY2P4Rjaf2cyGhA0sWLKABuUa0Dm4M13OHqVx1CEcBi/JHPoREVzr1sW1bl3KP/YY8WvXcn7iO5x+cDB+991HxdEvGEM8ItDv4+vkUUoxbc80qnhVoV/tfgB4OnvySbdP+DLkS77e+zUn404ypesUYzK8wyhoNRS2ToO/P4evOkLje3D36AEY1mbXLcK0pBmWehE7IGKboXhiQo08cYRKTaDZA0ZPJbg1lKuV74d62oULxC5ejN9dd+EclIN1o28VY73Uggep5TgHuvfMV9u5cmQlHFoOPV435LUz68PXo1DcWu1Wu++rKLCbEhIRR2Aq0BOIALaLyHKllK2t0YfAHKXUbBHpDrwHPGzmXVFKNc+m6cnAFKXUAhGZBgwHvrLXcZRpEi/C5o+NN9Iat8ADCwpsIFBg9i02TKzv/ALcch6ztiVp927CHx+Bo78/1WfNxLlKlSIRJTY5lhn7Z/DD4R+wWC3cW+9eDvjv59iWfTD1M3zvvgsHV9e8G8oNEWPuwTsIVr4Ic/ob59mj3I3Jvuwnoj76GJ++fTn04M2M/3UgaZY0JnWaRN9afQG4pcot3FLlFpRSLFizgCtBV9gYvpFv937DdBTlatXmlgsb6OxspUNQB7xdrrX68r71Vjzatefi559zae5c4teuJfDll/Dp1y9bLwF/n/2bfRf38Ub7N3B2uNqLdBAHnmnxDPX86zH+r/Hc/9v9fNrtUxoHNDYszbqMgzbDDUX0zzRuTltGwr7lRMw7RLnB91HxjiZmL2c7nAuBdNP4xKuSsZC59TBD6VRubhhLFJLob79DKUX5J7LpBdnSoC/cPIKq26bD0dXGEGVhSUmA38Ya/t7ajyp8OwVg7em1VPepTh2/OsWyvxtGKWWXD9AeWGXz+xXglSxlDgBVzW0BLtvkJWTTpgAXAafs9pHTp1WrVqqwrF+/vtB1i5tMWa/EKrVuolLvBCk1wU+pOXcr9YaPUkseU8pisZ8AyfFKfVhfqa+75Lof23OauH27OtyipTreq7dKPXeuSMRISE1QX4Z8qdrOa6uazGqiXt38qgq7HKaUUioyMVI9MfkWdbB+AxX69ed5tlWg679/mVJvBSj1eWulYk4XTnilVPzGjergTY3UqaFD1eS/3lGNZzVWA5cPVKFxoXnLmZKoYj9rrn77opF68Y8XVIcfOqjGsxqr5rObq+G/D1ez9s9Sp2JPXVf/yoED6uTA+9TB+g3U6UcfVSmnri1jtVrV4N8Gq56Le6rU9NQc5TgcfVj1WtxLtZzTUi0/vjybg4tUJ8ffqQ41rK8O3VRfHaxfXyWMDDDO2ze3KrXyFaX2/ahUbLhSVms+zlb+SL1wQR1q2kydefXVfFa4ouLfb6bU5JpKXb6B+/L3V43/3umthW8jH2Rc/9jkWNV8dnP18Y6Pi6RdYIeyk47I+Iixn6JHRAYAfZRSj5m/HwbaKqWesSnzA/CPUupTEbkH+BEIUEpFi0g6EAKkA5OUUj+JSACwVSlVx6xfFViplLrOh7mIjABGAAQGBrZasGBBoY4jISEBLy+vQtUtbq7EXaRe3EaqhS3FOT2ByAodCa3xIEmewVQ7vZhap74nPPhOTtQeZpdx6Zon51I9bAm7Wkzmsm+DHMtlnFPnI0fwn/ollnLliHn+Oaw5LbTMJ6nWVP5M+JM1cWtIsCbQzKMZfX37UtnlWv90EakRuHz8HjUjIXbiJJw9sl8XYitrfvGN3U+Tfe9icXRhb9M3SPQqmGGF06lQyk2ZQnJgeSYOduWYRNDFuwv9/fvjLDnPYWXIWefYNwSf+ZWQZm8T698Ui7IQmhLK/iv7OXDlAOfSzgFQwakCXX260tm789VGrFbcN23G66efkPR04u+7jyudjYWrh68cZmrkVAaVG8Qt3rfkegzxlnhmRs3kWMoxevj04E6/O3EQYyGr87Fj+H32OSqgHB53VSVl4SGs6RA9fjxWH78CnauC4LV4CR7r1xP95gQsFfK3bkZFHaXzofFc9qnPnmZvGlZ3Bdln/Ela7RzDuco9OVr/qcKInW8yrv8/Cf/wffT3jKk0hhquNW643W7duu1UStl3QZy9tBswAGMeKOP3w8AXWcoEAUuB3RhzRxGAn5lXxfyuBYQCtTGWgxy3qV8V2J+XLP/6nlBaslJbv1bJ71Q33rq+H6DU2ZBry1itSv02zsj/85OilyH6pFJvVVDqx8fzLLp+/XoV/+ef6lCz5up4374qLSrqhnadaklVi44sUt0XdVeNZzVWI1aPUPui9uVaZ/Pv36mD9Ruo2ePuUBZr/npt+eb8fqU+bKDUu8FKndyY72rJJ0+qI+3aqz1dO6qeX7dR7X9or9aeXpuvuuvXr1fq5Cbj+v42NsdyZ+LPqPmH5qtHVjyiGs9qrOYdnHddmdQLF1To0KHqUJOmKvXsWWW1WtUjKx5R3Rd1VynpKfmSJ9WSqiZumagaz2qsnljzhIpNjlVJe/aowy1bqb1dumZe86T9+9XBxk1U2NNPK2sR9nxsSYuKUoeaNVdnXnq5QPXWr1+v1M45xjnd9GHBdmpJN0YE3q+jVNKlgtUtBBn36ah1o1SPRT1yvacLAsXQE7Knn40zppLIINhMy0QpdVYpdY9SqgXwPzMt1vw+Y36fBDYALYBowE9EnHJq8z+FJd2wQvu8NawcxxX3IBi2yljNXzmL51wR6DMJGt0Na16HkPlFK8vq8eDgZMyP5IHL/v1EPPkULtWrU33OHJwCCraANAOrsvLbyd/o/1N/3tryFkGeQczoPYOve35tzEfkwi29hxHTug43rTrGtM0fFWr/ORLYCB5bY5gJf3/vVb94uZAWGUnYY4+RmJ7E6DtjqRBclyV3LKFHtR752qVjehL8/JQx8Z3LNQjyCuL+BvfzXe/v6Fa1G+9te4/fTv52TRnnihUJmjgRlCLqiy/Yfn47uyJ3MbzxcFwc8zen6OzgzP/a/Y832r/BP+f+Ydy3AwgdPgzHcuWIee65zGvu3qgRFUePJmHtOmIXLsxX2wUleuZMVGpq3nNB2dHiIWh0j+EFPnxb/utt+8aw4uvzXpGsCcoPSWlJ/H32b3pU65HZ8ywL2FPS7UBdEakpIi7A/cBy2wIiEiCSebZewbCUQ0T8RcQ1owzQEThoaub1GL0sgCHAz3Y8htKJ1QoHlsGX7YzYMJ7l4aGlhDR/x/BrlhMZ7llqdjHqHV1dNPKcWG+squ80Ok+favF/rMdv2te41KlNtVkzcSpX8Al8pRTrw9Yz4JcBvLz5ZTycPJjaYypzbptDm0r5X9/R4n/v45kCMbNm8suJXwosR674BsOjK431MUuGGa5acsASH8+J4UNJjDrHhHvT6dt5OLP6zCLIK//+6WqfmAWx4Ya1nkvebv+dHJz4oMsHtA5szfg/x7M5YvM1+c5VquD/4APELfuJRas+ooJ7Be6tV/D1LQPqDWBG3Td5/LszXHRI4vykJ7H6+11TptyQR/Ds2JEL700i5fjxAu8jN9IvXSLmh/n49O2La81CrDkTMRYk+wbDkuFwJTbvOnFn4I+3Da8RxbAmKIM/z/xJiiWFW6uXDau4DOymhJRS6cAzwCrgELBIKXVARN4SkTvNYl2BIyJyFAgE3jHTGwI7RGQPhtKZpK5a1b0EjBaR4xhm2t/Z6xhKHUoZimN6Z1g81DC5HvQ9PL4e6uTTTYqTq1GnUmPDT1j49huTyZIGv79seDNo/0yuRS+vWUPEc8+RXqUK1WfOxMm/4G+I/5z7h4dWPMSz658l1ZLKB50/YNEdi+gc3LnAcV/cGzbE67Y+9NshfLTmdXZH7i6wPLniUQ4eXmb4U1v1itFbtFqvKWJJSWH38PtJO3GKaYN8GPfwNF5o9cI11md5cnwtQedWQYdncn8JyYKroyufd/+cuv51Gb1hNCGRIdfklx85EuXmQpOl+xjWeNh1i2LzQ8qpU3iO/QBvj3LMG1mXp/a/weq41RnD6YDh8SFo0ns4eHpyZsxYrGYohaLg0sxZqORkAp4cWfhG3HxhwAyIP2s4b81rHn3li8aC2n65uEmyA2vD1uLv6k+Lii3yLlyKsOs6IaXUCmBFlrTXbbaXAEuyqfc30CSHNk8CN2eX968m9E9Y9zaEbzUe+HdPhyYDCrf2x80HBi+B73rBDwONIbwK9Qsn144ZEHXYCNOQS1C0y2vWcOb5F3Bv3JjIoUOuczmSYkkhNjmW2JRY4lLiiEmJIS4ljtgUIy02OZbT8afZG7WXSp6VeLPDm9xZ+06cHG7sFq446lkSVq3mge2uPOf3HPP6zivaVebO7nDfHOPB9PfnEH/BWIfi5EJiSgKbht9Fjb1n+O2hOrz1wndU9ChgSIorsfDzKBI9gvHsNr7A4nm5ePHVrV8x5PchPLXuKWb1mUU9/3oAOPn783fXinRcEUblpPwvOs4gNSLCcL9ktVJz7hymVA/ijb/e4JfQX0jflM6bHd/E3clYU+VUoQKV332HiJFPEvnRR1R69dUC7y8r6TExxMybh89tt+UYhyffBLc2PD+snWC49Wk1JPtyh38zRgVunZCnm6miJE2lsSliE71r9L7h/0RxU7ak/a+RmgSnNhqOQE/8Ad6Voe/H0OLhG1/v41URHl4K3/WGufcY/tB8C7g+JzHa8BZQq6uxtiKnYtu3EzFmDJdrVWD5yPocvLiAeauXXVUwKbFcSb+SY30PJw/83fzxd/XnxTYvcl/9+wr1Vp4drrVq4nvXXXT+9Rd+uVkYtW4Uc2+fe92amhvCwRFu/9BY1PrHREi4wKGm9/DnZ19xy47LnHjoFl54dRqOhXmh+P1lSLjA4RaTaVXIyKjl3cszved0Hl75MCPXjGTObXMI9g5m14VdTGt4hjZ/exL3yRf4zr05373NtHPnCBsyFHXlCtXmzMa1dm0AJneejHOsM7+E/kLo5VAeuukhqvtUp7p3dfy6dsX/4YeJmTMXr44d8erSpVDHk8Gl2bOxXrlyY70gWzo8Byc3Gouxq7a93qdgSjysGGeEw8hjVKCoOZp8lMS0xHzPIZYmtBIqbcSGwdFVxid0s7Fwz72c4T6lzWNFthofMCaxH1oCM/saE+jDVhZsEnX9RGMxXp/J2Q47pFvT2bTpe/xe+JBLXhZeuz0Kh/NrcbW6Ujm9MhU8KlDXvy5+rn7Gx83v6rb58XX1zfdkeGEJeOop4n75hXeON2eo+1bGbRzHFz2+KNo3ShHoPA6rV2UWbXyVw9OOM2iLIrWFE/2auBgGJsFtjEBn+Y3Lc/g3w2N053HEOxS8p2JLkFcQ03tOZ8jvQxixZgRzbpvDtD3T8PQpT6WnH+XSO5NJ3LQpX4ohLTKSsKGPYomLo9qsWbjVv9rLFhF6+vakd6vevLL5Ff735/8y83xdfanVqCojq/iQOu4FLnz1EsE1mlDdpzqezvkLb52BJS6OmLnf4927N651b+zcZJIxp/pVB2Oe7/F11/4f179nuG8aOCvb6MD2ZE/SHjydPWlXOf/DsaUFrYRKGku6sVr86O9wbDVEmlNf5WoZK8Xr9jI8/DoVzZv/dVRuBvfPg3kDYP4DxhxGfhTd+X2wcxbcPOK6N8LEtESWHlvKr1tn88xXZ0hzciTuvWdZ12EIHs4ebNiwga42wcJKGpfgKvgPHEDMosW8ecez/O/UZ7y//X1ebXvjQ0IZKKX488yffH5mORUjvHl6oxW3NtVp0NsbDq8wlBCAq8+1kWWDW2X/YpAYbYQFCGwCnV+EP/++YRlr+9Xmyx5f8tjqx3hoxUOcSTjD6FajqVjvQeLn/EDkx1Pw7NQp14CB6ZcuETZsGGlRUVT79lvcG2fvK65zcGc23LeBiIQIwi6HEXo5lLDLYZyOP81X97gz9qvLRI9/k7GDHFAiBLgHUM27GjV8a1DNu5rRe/KpTlXvqrg5Xd8DvDR7DtbExKLrBWXgHWgoonn3wurXoO+HRvrZ3fDPV8Z/tmrxzhakW9PZl7SPztU72/2FzR5oJVQSJF2C4+uMiKPH1kByrGHeXL0D9HoH6vUx3OoXAcpq5fTDj+BSrRqV3pyAQ3ZRH2t1MRw3Ln7UeMO7b27uIZuV6R/OzQ+6vpyZfD7xPD8c+oElR5dgib/M+wtcKGdxo8bc72nbqBCOK4uR8k+MJPbHpbT+7ThDBgxh9sHZ1PStSWUq5105D3ac38Hnuz9nV+QueoX7M3wleLRvT7WvpxlROJUy4uBk+EoL3w6bPgBlGjEE1Dd6SVXbGIqpQgNYMcaYD3r4pyJ1xdS0QlM+6foJT//xNP6u/gyqPwhxdqHCc89xduxYLv/6K7533pltXUtcHGHDHyMtPIKq06fj0TL3CXJnR2dq+takpm9NumDTw+oFF3zn4DLxPb6OuZMDt9YyFNTl02wM30h0cnRmURcHF7689UvaVm57VY7Ll7k0dy7ePW+9phdWZNS91Rhu2/KFMRRdr4/xQuBZwfAPV8zsjtxNgjWhzPiKy4pWQsWBUobr+WPmMFv4P8YDxiMA6t9uxNup3S3fvtYKQvK+fVzZuZMrO3eSduYMwV98jqOPz/UFG91t+JpbMRZ+ewHu+Cxny54Dy+D0X9BvCrj7czD6ILMPzGZ16GoUit5B3XnklzAcLh6l2tfT8CzlCgjAObAi/oMHc2nmTJ4a/hOng08zedtknqjwBF3pWqg2D0Qf4PNdn/PX2b+o4F6Bya4PUHPhAtwaNyb488+vhoEWMV46AupA8weNtJR4OLPLUEzh2+HICggxe0suXoYX6e7jDSvHIqZDlQ7M7D3TCC/tbPhq87n9NqJnfEfUp5/h3afPdS8zloQEwh4fQerx4wR/9RWebW+sN1Bx8MOkbtkGM37lod4LcOt4NfZPQmoCp+NPE3Y5jA+3f8jM/TOvUUKXvv8ea3w8AU/Z0UtBjzeM/8DPTxvxpM7tgQEzwd0v300opZiyawqCMKTREMq5Fc7f4NrTa3EWZ26pkrsni9KKVkL25EqsEXHyyEqICzPSKjWFTmMNxRPUMv/j/4Xk8qrV4OxM4Csvc+G9SZwePJiq06fjXDmbN/ybH4eEC8ZbuFeg8ZDLSmoSrH4Na6XGbK5Yk9mrhrH9/HY8nT15oOEDPFj/AXjjY+J3HyDog/fx7NDBrsdXlJR//DFiFy7k0hdTmfzRZB5Z+QgzombQK7YXtf1q57udE7En+GL3F6wNW4ufqx9jWo2hf0JdLox8Bpfatan2zXQcvfKY43D1NnqotcweglJw6aSxYDJim/ES0/GFGzja3Glesfk1v8XBgYovjCb88ceJXbCQco88nJlnTUoi/ImRJB88SPBnn+F1y40HshMRKk98m1P97+LMmLHU/HEJDh6GQvRy8aJR+UY0Kt+I0LhQvtzzJeHx4VT1roolIYFLs+fg1b07bg0b3rAcOeLkYgSn+7oz/P2ZEbyx0d0FamJ9+Hpm7p8JwPzD87m/wf0MbTS0QMrIqqysDVtLA7cGmS8MZY2ys6y2LHJqI2z72njDveNTGH0IRm424qoEt7a7AlJKEb96NZ7t21HuwQepNv1r0s6dJ3TQ/SQfOZJ9pW7/M97sNn0A/1wf5jh580csUrH0L+fOM+ufJexyGGNajWHNgDW82OZFnKfOM+PfjMX3jjvsenxFjZO/P+WGDCF+9Wrk6Cm+6PEFLg4uPL3uaS4lX8qzfnh8OP/783/cs/wetpzbwlPNnmLlPSsZZGlB5FPP4hwURLXvvs01ImaOiED52kbEz35TjPsptyFTO+B5S0c82rbl4rRpWBISAbAmJxP+1NNc2b2bKh9+gHf3bkW2Pyd/f4ImTyI1NJQL703Ktszdde/GQRz48ajhlSLm+3lY4+Ls2wvKoHxt6P+FMVza98MCrQlKTk/m/e3vU8evDj/e+SPdqnZj1v5Z9PmxD1N2TiEmOSZf7Ry4eIDIpEiaeTTLu3ApRSshe2JJM777TDbiquThTaCoST54kLSICHx6G+G1Pdu3p/q870GE04MfInHLlusriUDfKUYQspUvwv6lAERfiWbq1nfpdXoBbweUw8OjPJM7TWblvSsZ2ngo3i7eRM+YyaXZs/F/5GHKDRtWnIdaZJR7dCgOvr5EffYZlTwr8XiFx7l45SLPr3+eVEv2YasikyKZuHUidy67k1Whqxhy0xB+v+d3nmz+JE4nwgl7fASO5ctTbeYMnMqXL+YjKjpEhIpjRmO5dIlLM2caYceffZakf/4haNJ7+PTpU+T79GzfnvKPDSd28WKjV5+FSp6V6BLchWXHl5FyOZZLM2fi1aVLjgYRRU6ju+GZbQVeEzRj/wzOJJzh1bavUs+/HpM7T+an/j/RtWpXZu6fSe8fe/PJzk/yVEZrw9biJE40di/6YdniQishe2JNN76LI5hcNsSvWg2Ojnh1vxpn3q1+fWosXIBz5cqEjXiCuOXLr6/o6GQEZ6vWjmO/PMXrvz9OryW9+PrIfJqlpjGz42QW9F3A7bVuz1zZH/frb0S+/z7effoQ+PLLBfZeUFpw9Pam/PDhJG7cRNKu3dRwrcHEWyayO3I3b25585qV/jHJMXy04yNuX3o7Px79kXvr3cuKe1YwuvVo/Nz8SDlxgrBhw3Hw9KTazJk4BwaW4JEVDe5Nm+LdqxeXZs4kYtQoEjdtptJbb+ZorFAUVHj2WdyaNOHc66+Tdu7cdfkD6w3kUvIldk57B0tcHAFPle6IouHx4Xy37ztuq3HbNW6mavnV4v3O72cqoxn7Z9Dnxz58uuvTbJWRUop1YetoU6kNno4FM2EvTWglZE8ylFAxrxkAcyhu1So827a9zj2Oc6VKVJ/3PR4tW3L2xZe4+PX0ax6uVmVl04XtPB5UmXuCKrDy3Bbu9qnL8vCzfN5gGK3r3H6NkkncupWzr7yCR5s2BE2elKsJb1mg3EODcQwIIOqTT0Ap+tTow9PNn2b5ieV8t/87ElIT+CrkK25behuzD8ymd43eLL97OePbjc/0eJAaFkbY0EfByZHqM2fgElw0gfpKAxWefx5rSgqJGzcROH48/gMH2nV/4uxMlQ8/QKWlcfbFl1AWyzX5HYI6UMO5Eq4Lf8fzlltwb1a6h6be3/Y+jg6OjG49Otv8DGW0rP8yugR34bt932Uqo9jk2MxyJ2JPcPry6TK5QNWWsv20KO1k9oSK3/4j5egxUk+fxrtX9lEhHX18qPrNdHz69SNqyhTOv/kmScnxLDqyiLt+voun1z3NyfgwnrtpGGvjYPzuldTwrAwdnr2mneTDh4l4+hlca1QneOoXNx6ptBTg4OFBwIgRJG3bhsvhwwA80fQJbq95O5/u+pTeP/bmyz1f0iGoA8v6L+OdW965xtVP2tmzhA19FJWWRvUZM3CpUaOEjsQ+uNaqSaXXX6fyu+9S7qHBxbJPl+rVqfTaayRt3070N99ck+fo4MiTJ2vhkZhO2tB7ikWewrIpYhMbIjYwstlIKnlWyrVsbb/avN/lfZbeuZTOwZ35bt939P6xN5/t+oy4lDjWhq1FELpX635d3ZjEVH4OOcO4xXtITrNk03rpQVvH2ZMSVELxq1aBgwPet+b8luTg4kLQ+5NJLe9N7Oz5bNi1lI/usFKncmMmdZpErxq9jOG2Gn1h6WPQ/bVrwiunnTlD+OMjcPD2puo332Rv+l1G8bt/ENEzZ+L183LUyJGICG91fIuEtASUUjzd/GkaBVw/75AWGcnpRx/FEh9PtVkzi261finDf9B9xb5P37v6k7h5M1Gff4Fnu3a4N28OgPXKFWqt2MfeGg6EuR5gLLcVu2z5IcWSwqRtk6jhU4OHGxrWhXvCY7mUlEqApyvlvFwo7+mCm/O1w/d1/OvwQZcPeKLpE0zbO41v933LD4d/wNXRlWYVmlHBowJWpQgJj2XjkSg2HI1kT3gsVgX+Hs4Mu6UmDSuX3v+mVkL2xGq+gZSAErq8ehUerVvnGqvnQPQB5h6cy6oqq7i1lyOPrklj9ora1Pt2Ks62E+gV6sETm66pa4mNJezxEVhTUqgx73ucK+X+VlfWcHBxIeCpJzn/2uskrF+Pd/fuuDq6MrXH1BzrpMfEEDZsGOlRF6n23be4l4H1UWUJEaHShDe4EhLCmbHjqPnTMhy9vIhdtAh1KYbQR9vyy4mfGdVyVJH5FixKZh+YTXh8OF/f+jV/HY9h6vrjbA+9fq7H08XRVEiulPd0oZynC+W9jO0O3s/TsulA1p//ga2Rf9Ch3AM8v2A36w4kEb/qL0SgWbAfo7rXpWv9CjQN9sPRoXTPz2olZE8yrOOK2TAh5cQJUo+fwH/8A9eLZLWwIXwDcw7OYVfkLjycPLi/wf08ePeD+N15hDNjxnL6wQepNn06LtWrZ9u+NTmZ8CefIi08nGozvvvXvu373XUXEZ99TtSnn+HVtWuuc12Wy5cJGz7c8Bbw9dd4tChb7vTLCo4+PgR9+CGnH3qI82+9ReW33uLit9/i0bYtnfo+wdw1I1hzeg39avUraVGv4WzCWb7Z+w1N/G7h3aUW9p/ZTmVfNybccRNNgn2JTkjlUmIq0Ymp5nYK0YmpnItL5sDZy1xKTCXVYhsGpBc4dmT+IQ/Ke16kcQVH7u/chE51K1DOs2y57tFKyJ6U0HBc/GrDlNW7Z8/MtMS0RJYdW8a8Q/OISIggyDOIsa3Hck/de656jL61KtVmzSTiyacIvf8Bqk776rpJXmWxcGbsWK6EhFBlyhQ82uQ/iFxZQ5ydSbyjH04zZnJ55Up8+2bvKdyamEj4iCdIOXacql9OxbNd22zLaYoGj5YtCHj6KS5+/gWW6EtYoi4S8OFHVK3cmqreVVl8ZHGpUkJpFivPr3mL5HQLW7bfQnXfdCbf24S7WwTj4pS/aXmlFPEp6VxKSCU6MYXohFRir6RRP9CbJlV82bRpI12bl03jF62E7EkJKaHLq1bj3rIlzoEVUUoxbc805hycQ0JaAs0rNOeFVi/QvVr3bL1Ee7RoQfX5PxA+4glODxlKlY8/wts08VZKcX7iRBLWriPwf//Dp0/vYj2ukiC5dWsqbt7Mxc+/wKd3b8Tp2nOW0Su8sm8fVT6ZglenTiUk6X+LgCeeIPHvLST+9RfurVvhcXMbRISB9Qby8c6PORF7okBeLuxBcpqFJTsj+HzLbySV+wuf5Dt4Z2A3+japXOAhMhHBx80ZHzdnagSUXXPs7NDWcfakBOaEUk+fJuXwYXx6G1Zxn+/+nC/3GA4ef7j9B+bePpdeNXrlGqbAtWZNaiyYj2vdukQ8M4qYBQsAiP56OrHzF1D+seGUe/ihYjmeEsfBgYBnnyU1NJS4n69dU2VNTSVi1LMkbd9O0KRJ+Nj0PDX2RZycqPL+ZDzatSPwxRczlwz0r9MfZwdnFh9dXGKyJaak8+3mk3R+fz3jfwohzW8pAa5VWDf8De5sFlTq52iKG90TsifWdECKdU7oss1Q3MLDC/lm3zfcW/de3mj/RoEWkDqVL0/12bM4M3oM5ye8ScLGTSSsX4/PnXdQYXT26xv+rXjfeitujRtzcepUfO7oh4OLCyo9nbNjxpC4eTOV3n4L3ztKz/DPfwXnKlWoPmvmNWnl3Mpxa7VbWX5iOc+1fC4zcmtxEJeUxuwtocz86xQxSWm0r1WePh0Psez0Bd68ZSpuzqXPWKI0YNeekIj0EZEjInJcRF7OJr+6iKwTkb0iskFEgs305iKyRUQOmHmDbOrMEpFTIhJifprb8xhuCGt68c8HrVqNW9OmbEo7xDv/vEPX4K6Mbze+UB4MHDw8CP7ic/zuu4+E9evx7NCBoIkTy/xi1IIiIlR47jnSzp4ldvFilMXC2ZdfIX7NWgJffdXuizU1BWNg/YHEp8azKnRVsewvKj6FSSsP03HyH3y85igtq/nz45MdmDK4Br+fmUvXql3pHNy5WGQpi9jtCSkijsBUoCcQAWwXkeVKqYM2xT4E5iilZotId+A94GEgCXhEKXVMRIKAnSKySikVa9Ybp5RaYi/Zi4xiVkIOF6NJ3r+ftJEP8OKmF2kS0IT3u7x/QxFCxcmJSm9OwKdvX9ybNrkafuA/huctHXFv3YqL06aRvP8Al3/9lQqjR1/jTVpTOmgd2JqavjVZfHQxd9W5q8jaTU6zEBqdyMmoRE5GJXAyKpETFxM5dO4yaRYrtzepzNNd63BTkLEm58WNL2KxWnixzYtFJsO/EXs+IW8GjiulTgKIyAKgP2CrhG4CMsZ21gM/ASiljmYUUEqdFZFIoAIQa0d5ix6rpViVkNvu3QCMd/mNIK8gvujxRZEMR4jIDceHKeuICBWfe47TDz9C3LJllH9yJAEjHi9psTTZICIMqDuAD3Z8wJFLR6hfLv+B7ZRSnL+czMmoRNaFpbFh+QFOXjSUzpnYK9h4t6KSjxu1KngyuG01HmpXndoVvDLztp3bxsrQlTzZ7MlrvGlorseeT8gqQLjN7wggq+3qHuAe4FPgbsBbRMorpTJDJ4rIzYALcMKm3jsi8jqwDnhZKZWSdeciMgIYARAYGMiGDRsKdRAJCQmFrlsnPJRAq+KvQtYvKJ7b/yGskhPRPk684DWEPVv3FMt+C8qNnNPiJqusXt27o7w8udC0KQdL0TGU5XNqD8pbyuOEE5+s/4RB5Y3RfItVkZgGCWmK+FRFQprxuXRFcT7Ryvkk4zvFxsuNq2MolTwdqOIhtKrlTGVPByp5CpU8HXBzEiAZSCb8QFTmw86iLEw6N4lyjuWoc6lOsVyXsnT9s1LShgljgS9EZCiwCTgDZN4CIlIZmAsMUSoj1jGvAOcxFNN04CXgrawNK6Wmm/m0bt1ade3atVACbtiwgcLWJeFniHErfP0CEBN2jPNhEfzezZVvb/uWhuXtGNDrBrmhc1rMXCdrKZW7TJ/TG+BkVALn4pKJSUolJimNmMRUYpJSiU3yw0e14a/4Hew/2Z/YRCE+OT3bNkSgip87tSp50S3Ak9oVPKlVwYsLx/dyd+9uBZ5PnXNgDufDzvNpt0+z9etmD8rS9c+KPZXQGcC2HxpspmWilDqL0RNCRLyAezPmfUTEB/gN+J9SaqtNnQxf7ikiMhNDkZVOimlOKNWSyrxpz9ID6DX0jVKtgDSaomBPeCwfrTnKpqNR1+V5ujji5+GCh09HlOcWAisfort3T/w9XfD3cMHPwxl/D8Mdjp+HMwFertf5awPYEOFQYAUUlRTFl3u+5JYqt9CtatEF+Ps3Y88n5HagrojUxFA+9wMP2hYQkQDgktnLeQWYYaa7AMswjBaWZKlTWSl1Toy74y5gvx2P4cYohjkhq7Ly6p+v0n57KJcr+dO2bcFCDGs0ZYkDZ+OYsuYoaw9F4u/hzIt96tOiqj/lPF3w93DG18MZVydDoSiluGf5Tzg6buXNfvYLhW7LlJ1TSLWk8vLNZTemVnFjtyekUipdRJ4BVgGOwAyl1AEReQvYoZRaDnQF3hMRhTEc97RZ/T6gM1DeHKoDGKqUCgHmiUgFQIAQYKS9juGGsabbdY2QUooPtn/A1v2/MywCEvt2sNu+NJqS5OiFeD5Ze5QV+87j7ebEmJ71GNqxBt5uOcfqyvCg8N629zgQfYBG5e3rUHbXhV38cvIXHm/yONV9sve7qLkeu76mK6VWACuypL1us70EuM7UWin1PfB9Dm0WzyBrUWBNt2tAu9kHZvP9oe8Zf7kNoraS3LKl3fal0ZQEJ6MS+HTdMZbvOYuHsyOjutfhsVtq4euRv//VHbXv4JNdn7D4yGIadbCfEkq3pvPOP+9QybMSjzV5zG77+TdS0oYJ/27sOCf068lf+WjnR/Su0Zt26y+SXqsWlsqV7bIvjaa4Cb+UxKfrjrF0VwSuTo480bk2IzrXKrCHaG8Xb/rU6MOKUysY23osXi5eeVcqBIuOLOJozFE+6vIRHs4eeVfQZJLn0ncRuUNE/ltL5IsKO80JbTm7hdf+eo02ldrw9k1jSdq+A+9ePQ0zH42mDHM29gqvLN1Htw83sHzPWR7tWJNNL3bj5dsaFDpEwcB6A7mSfoXfTv5WxNIaRF+J5ovdX9Cucjt6Vtf+AwtKfp6Qg4BPRORHjHmdw3aW6d+DHeaEDkUf4vn1z1PTtyafdvuU5J9/B4sFn9694cKFIt2XRlNcRF5OZur648zfFo5C8WDbajzdrQ6BPm433HbjgMY0LNeQRUcXcV/9+4rcYODTXZ9yJf0Kr9z8ijZGKAR5KiGl1EOmufQDwCzTiGAmMF8pFW9vAcs0RTwcFxEfwZNrn8TX1ZevenyFt4s3YatW41ytGq4NGmglpClzRCekMG3jCeZsOU26VTGwVTDPdK9DsH/RDWmJCAPqDeDtrW+z9+JemlVolnelfLIpYhPLji/j0UaPUsuvVpG1+18iX09IpdRlEVkCuAPPY3g3GCcinymlPrejfGUbS1qRKaGY5BhGrh1JmjWNGb1nEOgZiCUujsStWyk/dIh+A9MUG+firrD2UCTn464Uqv7p06lsTzlM3JU0lu46Q3KahbtaVOG5HnWpXt4+sXL61urLRzs+YvGRxUWmhH449APvb3+f+v71eaLZE0XS5n+RPJ+QInIn8ChQB5gD3KyUihQRDww/cFoJ5UQRzQldSb/CM+ue4Xzieb7p9U3mG1f8H+shPR3v3v/+4HKakkMpxbHIBFYfOM/qgxfYGxEHgKODUJhXH6UUEnoSBwehd6NKPNejLnUq2sdgIANPZ0/61urL8hPLGddmHL6uvoVuK82axuRtk1l4ZCFdq3ZlcqfJ2hjhBsjPE/JeYIpSapNtolIqSUSG20esfwnWdHC6Ma/T6dZ0xm0cx/7o/Xzc9WNaVGyRmRe/ahVOQZVxa9z4RiXVaK7BYlXsCovJVDyno5MAaFHNjxf71KfXTZUKrThKysXMwHoDWXx0Mb+e/JXBDQcXqo24lDjGbhzL1nNbebTRozzX8jkcizFe2L+R/CihCUCGqxxExB0IVEqFKqXW2UuwfwXWdHC4sTekOQfnsDFiI6+1e40e1XpkplsSEkj86y/8Bw/WQ3GaIuNKqoWF28P4ZvMpzsRewcXRgQ51yjOicy16NgykYhEYCpQUDcs3pElAExYfWcyDDR4s8P/m9OXTPLPuGSISInirw1vcXVd7JykK8qOEFgO2S/EtZlobu0j0b8KaDg43tlj1j7A/aBrQlPvq33dNesL6Dai0NLx79bqh9jUagJjEVGZvCWX236HEJKXRuro/L93WgG71K+TqlaCsMbDeQF7/+3V2Re6iVWCrfNfbdm4bL2x4AQdx4Nte3xaoriZ38qOEnJRSqRk/lFKppm83TV7c4JzQ5dTL7Lu4j8ebXB+3Jn71KpwqVsS9edFZ+mj+e0TEJPHt5lMs3B7OlTQLtzasyMgutWldo1xJi2YXetfozfvb32fx0cX5ViSLjy7m3a3vUt2nOp/3+FzHBypi8vOEjBKRO01fb4hIf+CifcX6l3CD64S2n9uOVVnpEHStTzhrYiIJmzbjN3Dgfy7U9n8ZpRSXElM5dTGRyPhrQ2gdOJ9O0r5zOdS8HqtS/HEokp/3nEWAO5sHMbJLbeoFehex1KULD2cP7qh9B0uOLuGlNi/h7+afY1mrsjJ522S+P/Q9Hat05IPOH+Dt8u8+PyVBfpTQSAynoV9gOA0NBx6xq1T/Fm5wndDfZ//G09mTJhWaXJOesHkzKiUFn956KO7fSGJKOqcuJl7zOXkxkVNRCVzOISYOACG7CrQfDxdHhrSvwfBONanid+MReMsKA+sNZP7h+Sw/sZwhjYZkWyYhNYGvI7/mYPJBHmr4EGNaj8GpGKMk/5fIz2LVE0A7M94PSqkEu0v1b+EGldCWc1toE9gG5yzzSpdXrcKxfHnctcPSMktqupWwS0mmkkkwFE1UIqHRiVy4fG0vp4qfOzUDPLmzeRA1A7yoFeBJJV83HGwm1rdv306bNgWbpq3s54bPv2i+J7/U9a9Li4otWHx0MY/c9Mh1Bgrh8eGMWjeKU8mneK3da9fNx2qKlnw9IUWkL9AIcMu4YEqp66KZarJwA0ooPD6c8PhwHmr40LVNXrlCwsZN+N55B+KoTUPLAmkWK4fPxbMrLIadp2PYGxFL2KUkrOpqmXKeLtQM8KRT3QrUDPCkVoAnNSt4Ur2cJ+4ueV/nc94O1K+kh4ryy8B6A3n1z1fZdn4bbSu3zUzfeWEnL6x/AYuy8FTFp7QCKgbys1h1GuABdAO+BQYA2+ws17+DG5gT2nJ2CwDtg9pfk57w55+opCTDV5ymVBKdkMKusNhrlE5ymhGdPtDHlRZV/bmzWRA1K3hSo7wnNQM88fPQtj7FSc/qPZm0bRKLjy7OVEI/Hf+JN7e8SbBXMJ93/5zQ3aElK+R/hPy8pndQSjUVkb1KqTdF5CNgpb0F+1dwAz2hree2UtmzMjV8alyTHr96DY5+fngUcOhFYx/SLVaOXIhnV1gsu0/HsDMsJnNhp5OD0CjIh/vbVKNVdX9aVvcnyNdNr+sqBbg5udG/Tn/mH55PVFIUcw/NZeb+mbSt3JaPunyEr6svoYSWtJj/CfLzhEw2v5NEJAiIBnTgmvxgTcdqkbzjZWTBYrWw9dxWelbvec0Dy5qaSsIff+B9Wx/ESU+SlgQxiansDo9h12mjpxMSHktSqgWAAC9XWlbz48Gbq9Gyuj9Nqvji5qyHTEsrA+oNYO7Budz/2/1EJkUyqP4gXrr5pevmYDX2JT9Psl9ExA/4ANgFKOAbewr1byHpvOL0zN/x3epGxTGjcapQIV/1DkQfID41/rqhuMS//sKamKiH4ooJi1URHm9l3j+n2XU6lt1hMZy8mAgYftMaVvZmQKtgo5dTzZ9gf3fdyylD1PKtxc2VbmbHhR28cvMrPNDgAX39SoBclZAZzG6dUioW+FFEfgXclFJx+WlcRPoAnwKOwLdKqUlZ8qsDM4AKwCXgIaVUhJk3BBhvFp2olJptprcCZmF49F4BPKeUUpRC0hMMseJ++on4NWsIeOYZyj00GHHO/U3r77N/IwjtKrW7Jj1+9RocfHzwbNs2h5qaGyE2KZXd5lzOrrAY9oTHkZCSDuynnKcLLav5cW+rYFpW86dZVV88XHRvtKwzufNkYpJjqOtft6RF+c+S679IKWUVkalAC/N3CpCSW50MRMQRmAr0BCKA7SKyXCl10KbYh8AcpdRsEekOvAc8LCLlgDeA1hg9r51m3RjgK+Bx4B8MJdSHUjpHpSzGZHTVr6dx6YcfiJw8mdglS6j0v1fx7NAhx3pbzm6hYfmG+Ln5XW0rNZX4devw7tYNcdGT2DeKxao4esGwWNt1Opbd4TGcjLray2lQyZu7W1TBPek8g3u3p1o5D/2W/C8kwD2AAPeAkhbjP01+XuXWici9wNIC9jhuBo4rpU4CiMgCoD9G+IcMbgJGm9vrgZ/M7d7AGqXUJbPuGqCPiGwAfJRSW830OcBdlHIl5FK7NtW+/pr49eu58N4kwoYNx7tnTyq+9BIuwVWuqZOYlsjeqL0MbTz02vR/tmG9fFmHbcgnFqsi7koaMUmpxCalEpNobIddSsrSy+FqL6fl9b2cDRsu2i3GjUajyZ8SegJDUaSLSDKG1wSllPLJo14VDO8KGUQAWceR9gD3YAzZ3Q14i0j5HOpWMT8R2aRfh4iMAEYABAYGsmHDhjzEzZ6EhITC1VVWmpkLQbZu24b1+HEQgXFj8Vi7FrXydy5v2EBi714k9uoFZu9mX9I+0lU67pHu1+zXe+73uLm5sdOSDjnIU2hZi5nCyGlVivOJirgURUKaIj7V+E5MVSSkQUKaIsFMS0hTJKUZXeisOAhU9Xbg5kAH6vi5UtvXgYoegkgikEhKeATbbO68f/M5LSnKiqxlRU4oW7JmJT8eE+y5Am4s8IWIDAU2AWcwvHTfMEqp6cB0gNatW6vCxi8pdOyT9FRivjU2O3TqdK1RQs+epD3/PJEffID8+hv+u0Oo+PJLeN96K39v+xv3GHeG9hyKi6OhmFR6OsdeeRXPHj1o1LNn0ctazORHzoSUdELCYtlpmj3vDoshPhuXNR4ujvh7uODn4UxlX+O7nKcLfh4u+Hs4Z+b5e7jg7+FCBW/XfC3+LIispYGyIieUHVnLipxQtmTNSn4Wq3bOLj1rkLtsOAPYupsNNtNs2ziL0RPCdAt0r1IqVkTOAF2z1N1g1g/Orc1SgzUdpcw5hGzMqZ0rV6bKxx/jN+h+LkycyJlRz+LZoQPH20bQqnarTAUEkLRjB5aYGLz/pb7ilFKEX7rCzrBLhtI5HcuR85exKqPzWD/QmzuaBdGiqh9V/N3x93ChnKcLvu7O2gRaoynj5Gc4bpzNthvGXM9OoHse9bYDdUWkJoaiuB940LaAiAQAl5RSVuAVDEs5gFXAuyKS4eK2F/CKUuqSiFwWkXYYhgmPUFrDi1vTyZhBy829jmfbm6m5bCkx8xdw4dNPeGFrIhf7VcbSLgFHLyNy5eVVqxB3d7w6dSoOye1OqkWxIzRD4RiWaBcTjGgh3q5ONK/mR+8edWlV3Z9mVf3+k/7NNJr/CvkZjrvD9reIVAU+yUe9dBF5BkOhOAIzlFIHROQtYIcZGqIr8J6IKIzhuKfNupdE5G0MRQbwVoaRAvAUV020V1JKjRKwpoNhl5DnwlJxcqLcww+xuYGV8A8n0eOXbZz4+zYqjhmD7x39iF+7Fq8uXXBwL7uejo9diGfh9nB2hsWwNzwJyxrDLVHNAE+61KtIy+p+tKruT92K3jg6aCs0jea/QmEWOkQADfNTUCm1AsOM2jbtdZvtJcCSHOrO4GrPyDZ9B9C4APKWDFYLyprzcFx2/Jm0j133VmbY/6ZwYeI7nHvlFaK/+QZL1EV8euU8F1SaSbdYmb75JJ+sOYYINAv2o3cNZ+7u1IyW1fwo7+Va0iJqNJoSJD9zQp9z1dDIAWiO4TlBkxv5HI7LLK6sbD23lc7BnfFo2pQaC+YTt+wnIj/+GAcPDzw7d7GzwEXP8ch4xizey57wWPo2qcxb/RtR3svVmES9KbCkxdNoNKWA/Lyi77DZTgfmK6X+spM8/x6s6ZBhmJCP6KeHLh0iNiU201WPODjgd+89ePfuhTUuDkevsrNWxWJVzPjzFB+sPoKniyNfPNiCfk2DSlosjUZTCsmPEloCJCulLGB4QhARD6VUkn1FK+NY01FWwNEhXyvtM0I3tKt8raseRy+vTAOFssDJqATGLdnLztMx9LopkHfubkIFbz3kptFosidfHhOAW4GMiKruwGogZ78zGmNOSEm+A89tObuF+v71y6wLEatVMevvUN5fdRhXJ0c+GdSc/s2DtKsbjUaTK/lRQm62Ib2VUgki4mFHmf4dWNPACuKY91BcUloSuyJ3XRdFtaxwOjqRcYv3si30Ej0aVOTde5oQ6ONW0mJpNJoyQH6UUKKItFRK7YJML9ZX7CvWv4AMw4R8KKGdF3aSbk2/LnRDacdqVXz/z2neW3EYJ0fhw4HNuLdlFd370Wg0+SY/Suh5YLGInMXwG1cJGGRPof4VWNNR1vwNx205twUXBxdaVmxZDIIVDeGXknhxyV62nIymc70KTL63CZV9y+46Jo1GUzLkZ7HqdhFpANQ3k44opdLsK9a/AKsFpfJnnr3l7BZaBbbCzan0D2EppfhhWxjv/nYIEWHSPU0Y1Kaq7v1oNJpCkZ91Qk8D85RS+83f/iLygFLqS7tLV5axpoNV8hyOi0yK5Hjsce6sfWcxCVZ4zsZe4aUf97L52EU61inP5HubEuyvpwc1Gk3hyc9w3ONKqakZP5RSMSLyOKCVUG6Yc0J5uezJMM3uEFR6jQ0TUtL5OeQMk1YcxqIUE+9qzOC21XTvR6PR3DD5UUKOIiIZAe3MiKk6tGde5HNOaMu5LZRzK1fqwguHXkzkj8ORrD8SydaT0aRZFO1qleODAc2oWk73fjQaTdGQHyX0O7BQRL42fz9BaXUaWpqwpoMCccpZCVmVlS1nt9CucjscJG8rOnuSmm5lR+gl/jgcyR9HIjNDXdeu4MmjHWvSrX5F2tYsh4N2LqrRaIqQ/CihlzAilI40f+/FsJDT5IZpmEAuPaFjMce4lHypxIbiLiaksOFIFH8cvsDmoxeJT0nHxdGBtrXK8Ui76nRvEEi18rrXo9Fo7Ed+rOOsIvIPUBu4DwgAfrS3YGUeS5oxHJfLnFBOrnrshVKKA2cv88fhSNYdjmRvRCxKQUVvV/o2rUz3BhXpWCcAT9fCOFfXaDSagpPj00ZE6gEPmJ+LwEIApVS34hGtjGPGExLHnB/of5/9mzp+dQj0zN6jdHKahX1n4jgdnT83fYfPpHFxZ8R16Rarld1hsfxxOJLI+JTMkAov3FqP7g0q0ijIRxsZaDSaEiG3V97DwGagn1LqOICIvFAsUv0byAjvncOcUHJ6MrsidzGw3kDA6KVExFxhV1gMu07HsDs8loNnL5NuVdnWz5F9e7JN9nZ1onO9CnRrUJGu9SsQoOP4aDSaUkBuSugejJDc60Xkd2ABhscETX7IXKya/SnecmYHKZYUYqJr8vicHewOi+ViQgoA7s6ONKvqy+Oda9Gymj91K3rlK9ro1q1badcu+6G9Sr5uOOfDhZBGo9EUJzkqIaXUT8BPIuIJ9Mdw31NRRL4ClimlVheLhGUVc7GqODujlOJ0dBK7w2PYdTqW3eExHE9fiJOfIws2OVOjXDyd6wbQoro/Lar60aCSN06FUBgnPBy0+bRGoylT5McwIRH4AfhBRPyBgRgWc3kqIRHpA3wKOALfKqUmZcmvBswG/MwyLyulVojIYGCcTdGmQEulVIiIbAAqc9WJai+lVGReshQ75mLVIxeTuHviWqITUwHwdHGkWVU/KnqEUt69Md+N70s5T73sSqPR/DcpkBmUUioGmG5+csVc1DoV6AlEANtFZLlS6qBNsfHAIqXUVyJyE7ACqKGUmgfMM9tpAvyklAqxqTdYKWUb8bX0YS5WjUyycHPNctxSN4AWVf2pX8mbmJRoui06zSN179IKSKPR/Kexpy3uzcBxpdRJABFZgDGsZ6uEFOBjbvsCZ7Np5wGM+aiyhdUCCtLFkXG961OrwtXoqFvPbQWgfeWyFbpBo9Foihp7KqEqQLjN7wigbZYyE4DVIjIK8MSI4JqVQRjKy5aZImLBWK80McOlkC0iMgJjkS2BgYFs2LChEIcACQkJhaobHH4YsUK6gyM7tm8jzOPqHM+yi8vwdPDkwr4LRElUoeQqSlmLm7IiJ5QdWcuKnFB2ZC0rckLZkvU6lFJ2+QADMOaBMn4/DHyRpcxoYIy53R6jl+Rgk98W2JelThXz2xtjXuqRvGRp1aqVKizr168vXMU/P1HHWtVR03rcp87EJGUmW61W1X1hdzVmw5hCy5QThZa1mCkrcipVdmQtK3IqVXZkLStyKmU/WYEdyk46IuNjT5vdM0BVm9/BZpotw4FFAEqpLYAbhkeGDO4H5ttWUEqdMb/jMQwmbi5SqYsKc7FqujjiZGNefSL2BJFXIvVQnEaj0YBdldB2oK6I1BQRFwyFsjxLmTCgB4CINMRQQlHmbwcMN0GZ80Ei4iQiAea2M9AP2G/HYyg8VgtKCWkOTtes8dlyznDVU9ZCeWs0Go09sNuckFIqXUSeAVZhmF/PUEodEJG3MLp4y4ExwDemJwYFDDW7gACdgXBlGjaYuAKrTAXkCKwFvrHXMdwQ1nRURk/IZs3P32f/poZPDYK8gkpQOI1Goykd2NVTpVJqBYbZtW3a6zbbB4GOOdTdALTLkpYItCpyQe2B6bbHIg6Zw3GpllR2XtjJXXXuKlnZNBqNppSg/bjYCzOekMXBESdHQwmFRIZwJf2Kng/SaDQaE62E7IXVgrJm9ISM07zl3BacxIk2ldqUsHAajUZTOtBKyF6Ybnss4kiGXcKWs1toWqEpXi5eudfVaDSa/whaCdkL00QbRwdEhNjkWA5GH6RdUPEEsNNoNJqygFZCdkKlpQKC1QzvvfX8VhSqxEJ5azQaTWlEKyE7odLTjQ0HwwBxy9kteDt706h8oxKUSqPRaEoXWgnZi/Q0AJSjI0optpzdQtvKbXFysKtVvEaj0ZQptBKyEypDCTk4EHo5lHOJ57SXBI1Go8mCfi23E5lKyNGJLWe1qx5N6SMtLY2IiAiSk5OLdb++vr4cOnSoWPdZGMqKnHDjsrq5uREcHIyzs3MRSpU/tBKyF2nmnJCjI1vObiHYK5iq3lVzr6PRFCMRERF4e3tTo0YNRCTvCkVEfHw83t7exba/wlJW5IQbk1UpRXR0NBEREdSsWbOIJcsbPRxnJ5QlQwkJ2y9s170gTakjOTmZ8uXLF6sC0pQ+RITy5csXe484A62E7ESGdVyaSyyJaYnaNFtTKtEKSAMlex9oJWQvMpXQBRzEgZsrl86wRxqNRlOSaCVkJzJ6QqnO52gc0BgfF58SlkijKX2ICGPGjMn8/eGHHzJhwgQAJkyYQJUqVWjevDkNGjTgySefxGq1XtfGhAkTEBGOHz+emfbJJ58gIuzYsSPX/U+YMIEPP/wQgFmzZnH27NnMvGeeeYaDBw/eyOHlye23305sbGyuZWrUqMHFixftKkdJopWQnciYE0pxitJeszWaHHB1dWXp0qU5PmRfeOEFQkJCOHjwIPv27WPjxo3ZlmvSpAkLFmTGv2Tx4sU0alSwheFZldAXX3zBTTfdVKA2CsqKFSvw8/Oz6z5KO9o6zl6YPSGLo6Jt5bYlLIxGkztv/nKAg2cvF2mbNwX58MYduSsCJycnRowYwZQpU3jnnXdyLJeamkpycjL+/v7Z5t911138/PPPjB8/nhMnTuDr63uNubGXlxcJCQkALFmyhF9//ZVZs2Zl5i9ZsoQdO3YwePBg3N3d2bJlC7fffjtTpkyhdevWeHl58dxzz/Hrr7/i7u7Ozz//TGBgIKGhoQwbNoyLFy9SoUIFZs6cSbVq1Rg6dCju7u7s3r2byMhIZsyYwZw5c9iyZQtt27bN3HeNGjXYsWMHAQEB3HXXXYSHh5OcnMxzzz3HiBEj8nmmyza6J2QnVLoFAIsDlHcrX8LSaDSll6effpp58+YRFxd3Xd6UKVNo3rw5lStXpl69ejRv3jzbNnx8fKhatSr79+9nwYIFDBo0qEAyDBgwgNatWzNv3jxCQkJwd3e/Jj8xMZF27dqxZ88eOnfuzDffGAGdR40axZAhQ9i7dy+DBw/m2WefzawTExPDli1bmDJlCnfeeScvvPACBw4cYN++fYSEhFwnw4wZM9i5cyc7duzgs88+Izo6ukDHUFbRPSE7kTEcZ3UARwfHEpZGo8mdvHos9sTHx4dHHnmEzz777LqH/wsvvMDYsWNJS0tjwIABLFiwgPvvvz/bdu6//34WLFjAqlWrWLduHTNnziwyGV1cXOjXrx8ArVq1Ys2aNQBs2bKFpUuXAvDwww/z4osvZta54447EBGaNGlCYGAgTZo0AaBRo0aEhoZep1A/++wzli1bBkB4eDjHjh2jfPl//wusXXtCItJHRI6IyHEReTmb/Goisl5EdovIXhG53UyvISJXRCTE/EyzqdNKRPaZbX4mpdXG1GJMoFoc0P7iNJo8eP755/nuu+9ITEzMNt/Z2Zk+ffqwadOmHNvo168fc+fOpVq1avj4XGsIZPuYKMx6GGdn58w2HB0dSc9wUJwLrq6uADg4OGRuZ/zOWn/Dhg2sXbuWLVu2sGfPHlq0aFFi63aKG7spIRFxBKYCtwE3AQ+ISNZZvvHAIqVUC+B+4EubvBNKqebmZ6RN+lfA40Bd89PHXsdwI2T0hCwOgqPonpBGkxvlypXjvvvu47vvvss2XynFX3/9Re3atXNsw8PDg8mTJ/O///3vurzAwEAOHTqE1WrN7G1kxdvbm/j4+ALJ3aFDh0yDiHnz5tGpU6cC1c8gLi4Of39/PDw8OHz4MFu3bi1UO2URe/aEbgaOK6VOKqVSgQVA/yxlFJDxyuILnCUXRKQy4KOU2qqUUsAc4K4ilbqIsJ0T0j0hjSZvxowZc52VXMacUOPGjbFYLDz11FO5tnH//ffTsmXL69InTZpEv3796NChA5UrV8627tChQxk5ciTNmzfnypUr+ZL5888/Z+bMmTRt2pS5c+fy6aef5qteVvr06UN6ejoNGzbk5Zdfpl27/07wSzGe5XZoWGQA0Ecp9Zj5+2GgrVLqGZsylYHVgD/gCdyqlNopIjWAA8BR4DIwXim1WURaA5OUUrea9TsBLyml+mWz/xHACIDAwMBWtuabBSEhIQEvr4KH426yeASR6xx5ZYgjj988GU9Hz0LtvyAUVtbipqzICWVH1sLI6evrS506dewkUc5YLBYcHUv/6EBZkROKRtbjx49fZxzSrVu3nUqp1jfUcB6U9Cv6A8AspdRHItIemCsijYFzQDWlVLSItAJ+EpECzZwqpaYD0wFat26tunbtWigBN2zYQGHqxv9o3BAWB+jSqQteLvZ/kBVW1uKmrMgJZUfWwsh56NChEnHQWVYcg5YVOaFoZHVzc6NFixZFJFH+sacSOgPYuo0ONtNsGY45p6OU2iIibkCAUioSSDHTd4rICaCeWT84jzZLBcpiARyxaOs4jUajyRF7zgltB+qKSE0RccEwPFiepUwY0ANARBoCbkCUiFQwDRsQkVoYBggnlVLngMsi0s60insE+NmOx1BoDCVkmGjrOSGNRqPJHrs9HZVS6SLyDLAKcARmKKUOiMhbwA6l1HJgDPCNiLyAYaQwVCmlRKQz8JaIpAFWYKRS6pLZ9FPALMAdWGl+Sh+2JtqilZBGo9Fkh12fjkqpFcCKLGmv22wfBDpmU+9H4Mcc2twBNC5aSYseZTpatDo4aHf5Go1GkwPabY+dUJYMJaTngzQajSYntBKyF6YSUo76FGs0OeHo6Ji5DmjgwIEkJSUVSbv5CZGQX9LT06lQoQIvv3yd05cSZ9q0acyZM6ekxbgh9BPSHiiFshrrr5TuCWk0OeLu7k5ISAj79+/HxcWFadOm5V0pHxRliIQ1a9ZQr149Fi9eTFGtq1RKZRsbqaCMHDmSRx55pAgkKjn0jLk9sFrIuFdVGVnspvmPs/JlOL+vaNus1ARum5Tv4p06dWLv3r388ssvTJw4kdTUVMqXL8+8efMIDAxk48aNPPfcc4DhC27Tpk0kJCQwaNAgLl++THp6Ol999RWdOnXKDJHw4YcfUrVqVZ5++mnACGLn5eXF2LFj+eCDD1i0aBEpKSncfffdvPnmm9nKNX/+fJ577jm++uortmzZQocOHQBD0Y0ePRpPT086duzIyZMn+fXXX4mKiuLBBx/k7NmztG/fnjVr1rBz504SEhLo3bs3bdu2ZefOnaxYsYJFixZdJ0NiYiL33XcfERERWCwWXnvtNQYNGsTLL7/M8uXLcXJyolevXpkBAL28vOjWrRtPPvkk27ZtAyA0NJQ77riDffv2sXPnTkaPHk1CQgIBAQHMmjUrR68RJYHuCdkDaxpYDWMEpc2zNZo8SU9PZ+XKlTRp0oRbbrmFrVu3snv3bu6//37ef/99wIi6OnXqVEJCQti8eTPu7u788MMP9O7dm5CQEPbs2XOdZ+pBgwaxaNGizN+LFi1i0KBBrF69mmPHjrFt2zZCQkLYuXNnts5Rk5OTWbt2LXfccQcPPPAA8+fPz0x/4oknWLlyJTt37iQqKiqzzptvvkn37t05cOAAAwYMICwsLDPv2LFjPPXUUxw4cIAjR45kK8Pvv/9OUFAQe/bsYf/+/fTp04fo6GiWLVvGgQMH2Lt3L+PHj79Gznr16pGamsqpU6cAWLhwIYMGDSItLY1Ro0axZMkSdu7cybBhw7L1rVeS6CekPbCmozJ62ronpCkLFKDHUpRcuXIlU3F06tSJ4cOHc+TIEQYNGsS5c+dITU2lZs2aAHTs2JHRo0czePBg7rnnHoKDg2nTpg3Dhg0jLS2Nu+666zol1KJFCyIjIzl79ixRUVH4+/tTtWpVPv30U1avXp3pISAhIYFjx47RuXPna+r/+uuvdOvWDXd3d+69917efvttPvnkEw4fPkytWrUyZXvggQeYPn06AH/++Wemk9Q+ffpcE4ivevXqmX7hVq9ena0MnTp1YsyYMbz00kv069ePTp06kZ6ejpubG8OHD6dfv36ZYSVsue+++1i4cCEvv/wyCxcuZOHChRw5coT9+/fTs2dPwHDvU5p6QaCVkH2wpl8djnPSSkijyYmMOSFbRo0axejRo7nzzjvZsGEDEyZMAODll1+mb9++rFixgo4dO7Jq1So6d+7Mpk2b+O233xg6dCijR4++bo5k4MCBLFmyhPPnz2cGu1NK8corr/DEE09cU3bq1KmZAesWLVrE/Pnz+fPPP6lRowYA0dHR/PHHH1SoUKFQx+vpedWHZE4yAOzatYsVK1Ywfvx4evToweuvv862bdtYt24dS5Ys4YsvvuCPP/64ps6gQYMYOHAg99xzDyJC3bp12bdvH40aNWLLli2Fkrc40MNx9sBqASVYAQcH5zyLazSaq8TFxVGlShUAZs+enZl+4sQJmjRpwksvvUSbNm04fPgwp0+fJjAwkMcff5zHHnuMXbt2XdfeoEGDWLBgAUuWLGHgwIEA9O7dmxkzZmSG/D5z5gyRkZE8/fTThISEEBISgqenJ5s3byYsLIzQ0FBCQ0OZOnUq8+fPp379+pw8eZLQ0FDAGP7KoGPHjplDgKtXryYmJibb48xJhrNnz+Lh4cFDDz3EuHHj2LVrFwkJCcTFxWWGHN+zZ8917dWuXRtHR0fefvvtTGVbv359oqKiMpVQWloaBw4cyP/FKAZ0T8gemMNxVgdw0LGENJoCMWHCBAYOHIi/vz/du3fPnOf45JNPWL9+PQ4ODjRq1IjbbruNBQsW8MEHH+Ds7IyXl1e25sqNGjUiPj6eKlWqZA5F9erVi0OHDtG+fXsAvLy8+P7776lYsWJmvV9++YXu3btfE5Cuf//+vPjii3z11Vd8+eWX9OnTB09PT9q0aZNZ5o033uCBBx5g7ty5tG/fnkqVKuHt7Z2pbDLISYbjx48zbtw4HBwccHZ25quvviI+Pp7+/fuTnJyMUoqPP/4423M3aNAgxo0bl3nOXFxcWLJkCc8++yxxcXGkp6fz/PPP06hRyUXSvQ6l1L/+06pVK1VY1q9fX/BKseHqfP9gFdKogeo+/85C77ugFErWEqCsyKlU2ZG1MHIePHiw6AXJB5cvXy6R/RaUvOSMj49XSilltVrVk08+qT7++GOllFLJyckqLS1NKaXU33//rZo1a2ZXOZUqmnOa3f2A4WLNrs9n3ROyB9Z0sGZEVdWnWKP5N/LNN98we/ZsUlNTadGiRebcTlhYGPfddx9WqxUXF5fMOSZN9ugnpD0w1wlZHNChvTWafykvvPACL7zwwnXpdevWZffu3SUgUdlEGybYA2s6yipYRXQsIY1Go8kFrYTsgSUNpSDdET0cp9FoNLmglZA9sKaDVbCKDmin0Wg0uaGVkD3Qc0IajUaTL7QSsgfmnJDFQXDWPSGNJkfsFcqhIPz0008cPHiw2PerMdBKyB5Y00H3hDSaPClsKIf09PQikyE3JVSU+9Fkj11f00WkD/Ap4Ah8q5SalCW/GjAb8DPLvKyUWiEiPYFJgAuQCoxTSv1h1tkAVAaumM30UkpF2vM4CozpO87ioOeENGWDydsmc/jS4SJts0G5Brx080v5Lp8RyiExMZFRo0axf/9+0tLSmDBhAv3792fWrFksXbqUhIQELBYLv/32G6NGjWLHjh2ICG+88Qb33nsvq1ev5o033iAlJYXatWszc+ZMvLy8qFGjBvfddx8rV67M9MAdGRnJ8uXL2bhxIxMnTuTHH39k+PDhNG/enE2bNjF48GCaN2/O2LFjSU9Pp02bNnz11Ve4urpSo0YNhgwZwi+//EJaWhqLFy+mQYMGRXoO/wvYrSckIo7AVOA24CbgARG5KUux8cAipVQL4H7gSzP9InCHUqoJMASYm6XeYKVUc/NTuhQQ2AzHaSWk0eQH21AO77zzDt27d2fbtm2sX7+ecePGkZiYCBiOPZcsWcLGjRt5++238fX1Zd++fezdu5fu3btz8eJFJk6cyNq1a9m1axetW7e+xsVNRvlnnnmG559/ng4dOnDnnXfywQcfEBISQu3atQFITU1l48aNPP300wwdOpSFCxeyb9++zJhFGQQEBLBr1y6efPJJPvzww+I9af8S7PmEvBk4rpQ6CSAiC4D+gG2/VwE+5rYvcBZAKWW70usA4C4irkqpFDvKW3RYLabHBK2ENGWDgvRYipLsQjl06NCB5cuXZz7Uk5OTM2Py9OzZk3LlygGwdu1aFixYkNmWv78/v/76KwcPHqRjx46AoUwyfLOBEXIh4zu7haYZZDgAPXLkCDVr1qRevXoADBkyhKlTp/L8888DcM899wDQqlUrli5dekPn4r+KPZ+QVYBwm98RQNssZSYAq0VkFOAJ3JpNO/cCu7IooJkiYgF+BCaaPo5KD9Z0lBIsjloJaTS5kV0oB6UUP/74I/Xr178m/Z9//rkmFEJ2KKXo2bNnZvC5rIhItttZyWs/GWQ4N3V0dNTzR4WkpJ+QDwCzlFIfiUh7YK6INFbKCAknIo2AyUAvmzqDlVJnRMQbQwk9DFznOldERgAjAAIDA9mwYUOhBExISChw3YCoELzMOaGY6EuF3ndBKYysJUFZkRPKjqyFkdPX15f4+Hj7CJQLFovlmv1mlaFbt2589NFHfPjhh4gIe/bsoVmzZiQnJ5OamppZvkuXLkyZMoXJkycDEBMTQ+PGjfnzzz8zh9YSExM5e/YsdevWRSnFnDlzGD16NAsWLKBNmzbEx8fj6upKVFRUZrsWi4XExEQsFgtBQUGcOnUqs70ZM2bQtm1b4uPjUUqRkJCAq6trZvmSOJ8ZMt/ovpOTk0vmXreXZ1SgPbDK5vcrwCtZyhwAqtr8PglUNLeDgaNAx1z2MRT4Ii9Zit2L9r4l6lSHWmp+75vUS3+8Veh9F5R/s8fnkqKsyFpWvWh7enpel5+UlKRGjBihGjdurG666SbVt29fpZRSM2fOVE8//XRmufj4ePXII4+oRo0aqaZNm6off/xRKaXUunXrVOvWrVWTJk1UkyZN1M8//6yUUqp69erqxRdfVE2aNFGtW7dWx44dU0op9eeff6qGDRuq5s2bq+PHj6suXbqo7du3Z8q5du1a1bx5c9W4cWP16KOPquTk5Mz2oqKilFJKbd++XXXp0qWIz1T+KctetO2phJxMpVITw8ptD9AoS5mVwFBzuyHGnJBgWMvtAe7Jps0Ac9sZWAKMzEuWYldCexaqk+1rqe9vu0mN3/huofddUP7ND8ySoqzIWlaVUHFiqzTyQ1kJOaFU2VZCdrOOU0qlA88Aq4BDGFZwB0TkLRG50yw2BnhcRPYA802FpMx6dYDXRSTE/FQEXIFVIrIXCAHOAKXPT3qmdZzSc0IajUaTC3Z9QiqlVgArsqS9brN9EOiYTb2JwMQcmm1VlDLaBXOxqtUBnB21EtJoSgMZobg1pQvtMcEeWNOxWsHiCC5aCWk0Gk2OaCVkD6wWlDIWqzo7OJe0NBqNRlNq0UrIHti47dE9IY1Go8kZrYTsgY3bHmdH3RPSaDSanNBKyB5Y0jK9aLto6ziNJlfeeecdGjVqRNOmTWnevDn//PMP6enpvPrqq9StW5fmzZvTvHlz3nnnncw6GSEgGjVqRLNmzfjoo4+wWq0leBSawqKfkPbAasnsCenhOI0mZ7Zs2cKvv/7Krl27cHV15eLFi6SmpjJ+/HjOnz/Pvn37cHNzIz4+no8++iiznq27n8jISB588EEuX77Mm2++WUJHoiks+glpD8w5IW2irSkrnH/3XVIOFW0oB9eGDaj06qu5ljl37hwBAQGZPtgCAgJISkrim2++ITQ0FDc3NwC8vb2ZMGFCtm1UrFiR6dOn06ZNGyZMmJCrTzhN6UMPx9kDazroOSGNJk969epFeHg49erV46mnnmLjxo0cP36catWq4e3tne92atWqhcViITKy9EV20eSOfk23BzqyqqaMkVePxV54eXmxc+dONm/ezPr16xk0aBCvZpFl5syZfPrpp0RHR/P3339TtWrVEpFVYx+0ErIH1nQdT0ijySeOjo507dqVrl270qRJE77++mvCwsKIj4/H29ubRx99lEcffZTGjRtjsViybePkyZM4OjpSsWLFYpZec6Po4Tg7oNLTAcHiIDiJVkIaTU4cOXKEY8eOZf4OCQmhfv36DB8+nGeeeYbk5GTACFWQmpqabRtRUVGMHDmSZ555Rs8HlUH0E9IOqHTjz2LVPSGNJlcSEhIYNWoUsbGxODk5UadOHaZPn46vry+vvfYajRs3xtvbG3d3d4YMGUJQUBBwNSJrWloaTk5OPPzww4wePbqEj0ZTGPQT0h6kpxlfDuDooOeENJqcaNWqFX///Xe2eZMmTWLSpEnZ5uU0LKcpe+jhODug0gwlpHtCGo1GkztaCdkBZcaa19ZxGo1GkztaCdkDczhOe9HWlHaMGJKa/zoleR9oJWQHlI0S0j0hTWnFzc2N6OhorYj+4yiliI6OzvROUdzoCQs7YDscp+eENKWV4OBgIiIiiIqKKtb9Jicnl9gDryCUFTnhxmV1c3MjODi4CCXKP/oJaQ/SDcsdq7aO05RinJ2dqVmzZrHvd8OGDbRo0aLY91tQyoqcULZkzYpdh+NEpI+IHBGR4yLycjb51URkvYjsFpG9InK7Td4rZr0jItI7v22WBpSNibbuCWk0Gk3O2E0JiYgjMBW4DbgJeEBEbspSbDywSCnVArgf+NKse5P5uxHQB/hSRBzz2WaJoyzGcJzVAe0xQaPRaHLBnj2hm4HjSqmTSqlUYAHQP0sZBfiY277AWXO7P7BAKZWilDoFHDfby0+bJY85HKfnhDQajSZ37PmErAKE2/yOANpmKTMBWC0iowBP4Fabuluz1K1ibufVJgAiMgIYYf5MEJEjBZQ/gwDgYqFqvguz3q2Sd7mio/CyFi9lRU4oO7KWFTmh7MhaVuQE+8la3Q5tXkNJv6Y/AMxSSn0kIu2BuSLSuCgaVkpNB6bfaDsiskMp1boIRLI7ZUXWsiInlB1Zy4qcUHZkLStyQtmSNSv2VEJnANvAH8Fmmi3DMeZ8UEptERE3DI2eW9282tRoNBpNGcGec0LbgboiUlNEXDAMDZZnKRMG9AAQkYaAGxBllrtfRFxFpCZQF9iWzzY1Go1GU0awW09IKZUuIs8AqwBHYIZS6oCIvAXsUEotB8YA34jICxhGCkOVsXz7gIgsAg4C6cDTSikLQHZt2usYTG54SK8YKSuylhU5oezIWlbkhLIja1mRE8qWrNcg2mWHRqPRaEoK7TtOo9FoNCWGVkIajUajKTG0EsqFknYRJCJVTbdGB0XkgIg8Z6ZPEJEzIhJifkrc3ZGIhIrIPlOeHWZaORFZIyLHzG9/M11E5DNTlr0i0tKmnSFm+WMiMsQOcta3OW8hInJZRJ4vLedURGaISKSI7LdJK7LzKCKtzOt03KwrRSjnByJy2JRlmYj4mek1ROSKzbmdlpc8OR1zEcpaZNdbDEOpf8z0hWIYTRWVnAttZAwVkRAzvUTPaZGilNKfbD4Yhg8ngFqAC7AHuKmYZagMtDS3vYGjGO6KJgBjsyl/kymnK1DTlN+xOI4FCAUCsqS9D7xsbr8MTDa3bwdWAgK0A/4x08sBJ81vf3Pb387X+DzGgrxScU6BzkBLYL89ziOGlWk7s85K4LYilLMX4GRuT7aRs4ZtuSztZCtPTsdchLIW2fUGFgH3m9vTgCeLSs4s+R8Br5eGc1qUH90TypkSdxGklDqnlNplbscDh7jqOSI7Spu7o/7AbHN7NnCXTfocZbAV8BORykBvYI1S6pJSKgZYg7mOzE70AE4opU7nUqZYz6lSahNwKRsZbvg8mnk+SqmtyngSzbFp64blVEqtVkqlmz+3Yqzjy5E85MnpmItE1lwo0PU2exndgSU3Kmtucpr7uQ+Yn1sbxXVOixKthHImO7dDxeqDxxYRqQG0AP4xk54xhz1m2HSrc5K5OI5FYbhg2imGyySAQKXUOXP7PBBYCuS05X6u/VOXtnOaQVGdxyrmdtZ0ezAM4y08g5pieMvfKCKdzLTc5MnpmIuSorje5YFYG+Vrr3PaCbiglDpmk1Yaz2mB0UqoDCAiXsCPwPNKqcvAV0BtoDlwDqObXtLcopRqieHh/GkR6Wybab6VlZr1AOa4/Z3AYjOpNJ7T6yht5zE7ROR/GOv75plJ54BqyvCWPxr4QUR8cqqfFTsdc5m43jY8wLUvTKXxnBYKrYRyJj9uh+yOiDhjKKB5SqmlAEqpC0opi1LKCnyDMVQAOcts92NRSp0xvyOBZaZMF8zhgYxhgsiSltOG24BdSqkLptyl7pzaUFTn8QzXDpEVucwiMhToBww2H3SYQ1vR5vZOjLmVennIk9MxFwlFeL2jMYZBnbKkFxlm2/cAC23kL3XntLBoJZQzJe4iyBwH/g44pJT62Ca9sk2xu4EMa5oScXckIp4i4p2xjTFBvd/cR4Zl1hDgZxs5HxGDdkCcOUywCuglIv7m8EgvM80eXPNmWdrOaRaK5DyaeZdFpJ15bz1i09YNIyJ9gBeBO5VSSTbpFcSIBYaI1MI4hyfzkCenYy4qWYvkepuKdj0wwF6yYkQXOKyUyhxmK43ntNCUtGVEaf5gWB8dxXjL+F8J7P8WjC7zXiDE/NwOzAX2menLgco2df5nynsEG8snex4LhsXQHvNzIKN9jPHydcAxYC1QzkwXjOCEJ8zjaG3T1jCMyeDjwKN2Oq+eGG+wvjZppeKcYijGc0Aaxnj+8KI8j0BrjAfuCeALTK8pRSTncYx5k4x7dZpZ9l7zvggBdgF35CVPTsdchLIW2fU27/9t5vEvBlyLSk4zfRYwMkvZEj2nRfnRbns0Go1GU2Lo4TiNRqPRlBhaCWk0Go2mxNBKSKPRaDQlhlZCGo1GoykxtBLSaDQaTYmhlZCm1CMifiLyVCHrrhDTm3MuZd4SkVsLJVwpRUQSiqidT7J6vxCR3iLypumVeaVNej8xIidrNPlGm2hrSj2m37xflVKNs8lzUlf9dmlMRCRBKeV1g22UB35TSrXLkj4RY4GmF9BYKfWOmS4Ya1Y6KpvFqhpNbuiekKYsMAmoLUbclA9EpKuIbBaR5cBBABH5yXSeesDGgWpGnKMAMeKvHBKRb8wyq0XE3SwzS0QG2JR/U0R2iRGTpYGZXkGMGCwHRORbETktIgFZBRWRXiKyxay/WES8RKS6GDFcAkTEwZS9Vx5yJ5jHekBE1orIzSKyQUROisidZpmhIvKzmX5MRN7I7uSJyDgR2S6Gs843zTRPEflNRPaIyH4RGZRN1XuB323aGSRGPJtngU8w3N08al4HlPFGuwHDbY9Gkz9KerWs/uhPXh+yxE4BugKJQE2btAwvAu4Yq8XLm79DgQCzjXSguZm+CHjI3J4FDLApP8rcfgr41tz+AnjF3O6D4ckia/ykAGAT4Gn+fomr8V8ew1hNPw74Oh9yK67GgVkGrAacgWZAiJk+FGOFfXmb+q3NvATzuxcwHcO7ggPwK0bcmnuBb2zk8M3mvM/GZiW+mSbA3+b2OsA7S/5g4POSvmf0p+x8MpzuaTRljW3KiPeSwbMicre5XRXDl1Z0ljqnlFIh5vZODMWUHUttytxjbt+C4WMMpdTvIhKTTb12GEHR/jJGpnABtph1vhWRgcBIDM/NecmdytVeyD4gRSmVJiL7ssi9RpmOLEVkqSnnDpv8XuZnt/nby9zHZuAjEZmMMdS5OZvjqQxEZUmrhxEkDwxlG58lPxIIyqYtjSZbtBLSlFUSMzZEpCuGk8f2SqkkEdkAuGVTJ8Vm24LRe8iOFJsyBfmPCIZSeOC6DBEPrno39gLi85A7TSmVMWFrzZBJKWWVqx6b4Xp3/Fl/C/CeUurrbGRqieEPbaKIrFNKZTUquGIjD2KEbQ8AnETkIFDZHJ4bZaPE3Mx6Gk2+0HNCmrJAPEZ485zwBWLMB3kDjB5JUfMXRmRLzPkc/2zKbAU6ikgds5yniNQz8yZjxNd5HWMupajk7mlaqbljRMr8K0v+KmCYGDGpEJEqIlJRRIKAJKXU98AHGGGls3IIqJPxQynVGvgNI0Ln+xhOPJtn6UXV46pHao0mT7QS0pR6zOGmv8wJ9A/+394dqkQQBgEc/4/FR7BdtggiGAwiYrXaNdhsPoAIFp/AJ/AE0SiITRCUi4fgQ1guizKG2XDChQ2eH8j/l2d3Z9PsN/Ox34yQe+rr/I3axPAyhzROqeMRXoE96mTKH62ozHyn5jRXETGmWnHLEbEFrAPnmXkJfETEwS/lPaLOmxoDt5k53YojMx+AIfDctfJuqIK+Aoy6lcwJcDbj3nfU/G3aGvXn5k3gccY12911Ui9u0ZZ6iIhF4CszPyNiA7jIzNXGOe1TGxGO5viMJ2A3Myc9YpeAYWbuzCsf/T/OhKR+BsB1RCxQmwYOG+fzV46pd5/0iB108VJvroQkSc04E5IkNWMRkiQ1YxGSJDVjEZIkNWMRkiQ18w2CpFrlk4rCQAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "def plot_accuracy(x, y, x_legend):\n",
    "    \"\"\"Plot accuracy as a function of x.\"\"\"\n",
    "    x = np.array(x)\n",
    "    y = np.array(y)\n",
    "    plt.title('Classification accuracy as a function of %s' % x_legend)\n",
    "    plt.xlabel('%s' % x_legend)\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.grid(True)\n",
    "    plt.plot(x, y)\n",
    "\n",
    "\n",
    "rcParams['legend.fontsize'] = 10\n",
    "cls_names = list(sorted(cls_stats.keys()))\n",
    "\n",
    "# Plot accuracy evolution\n",
    "plt.figure()\n",
    "for _, stats in sorted(cls_stats.items()):\n",
    "    # Plot accuracy evolution with #examples\n",
    "    accuracy, n_examples = zip(*stats['accuracy_history'])\n",
    "    plot_accuracy(n_examples, accuracy, \"training examples (#)\")\n",
    "    ax = plt.gca()\n",
    "    ax.set_ylim((0.8, 1))\n",
    "plt.legend(cls_names, loc='best')\n",
    "\n",
    "plt.figure()\n",
    "for _, stats in sorted(cls_stats.items()):\n",
    "    # Plot accuracy evolution with runtime\n",
    "    accuracy, runtime = zip(*stats['runtime_history'])\n",
    "    plot_accuracy(runtime, accuracy, 'runtime (s)')\n",
    "    ax = plt.gca()\n",
    "    ax.set_ylim((0.8, 1))\n",
    "plt.legend(cls_names, loc='best')\n",
    "\n",
    "# Plot fitting times\n",
    "plt.figure()\n",
    "fig = plt.gcf()\n",
    "cls_runtime = [stats['total_fit_time']\n",
    "               for cls_name, stats in sorted(cls_stats.items())]\n",
    "\n",
    "cls_runtime.append(total_vect_time)\n",
    "cls_names.append('Vectorization')\n",
    "bar_colors = ['b', 'g', 'r', 'c', 'm', 'y']\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "rectangles = plt.bar(range(len(cls_names)), cls_runtime, width=0.5,\n",
    "                     color=bar_colors)\n",
    "\n",
    "ax.set_xticks(np.linspace(0, len(cls_names) - 1, len(cls_names)))\n",
    "ax.set_xticklabels(cls_names, fontsize=10)\n",
    "ymax = max(cls_runtime) * 1.2\n",
    "ax.set_ylim((0, ymax))\n",
    "ax.set_ylabel('runtime (s)')\n",
    "ax.set_title('Training Times')\n",
    "\n",
    "\n",
    "def autolabel(rectangles):\n",
    "    \"\"\"attach some text vi autolabel on rectangles.\"\"\"\n",
    "    for rect in rectangles:\n",
    "        height = rect.get_height()\n",
    "        ax.text(rect.get_x() + rect.get_width() / 2.,\n",
    "                1.05 * height, '%.4f' % height,\n",
    "                ha='center', va='bottom')\n",
    "        plt.setp(plt.xticks()[1], rotation=30)\n",
    "\n",
    "\n",
    "autolabel(rectangles)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Plot prediction times\n",
    "plt.figure()\n",
    "cls_runtime = []\n",
    "cls_names = list(sorted(cls_stats.keys()))\n",
    "for cls_name, stats in sorted(cls_stats.items()):\n",
    "    cls_runtime.append(stats['prediction_time'])\n",
    "cls_runtime.append(parsing_time)\n",
    "cls_names.append('Read/Parse\\n+Feat.Extr.')\n",
    "cls_runtime.append(vectorizing_time)\n",
    "cls_names.append('Hashing\\n+Vect.')\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "rectangles = plt.bar(range(len(cls_names)), cls_runtime, width=0.5,\n",
    "                     color=bar_colors)\n",
    "\n",
    "ax.set_xticks(np.linspace(0, len(cls_names) - 1, len(cls_names)))\n",
    "ax.set_xticklabels(cls_names, fontsize=8)\n",
    "plt.setp(plt.xticks()[1], rotation=30)\n",
    "ymax = max(cls_runtime) * 1.2\n",
    "ax.set_ylim((0, ymax))\n",
    "ax.set_ylabel('runtime (s)')\n",
    "ax.set_title('Prediction Times (%d instances)' % n_test_documents)\n",
    "autolabel(rectangles)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}