Bhargav_Solanki_assignment_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please fill in your name and that of your teammate.\n",
    "\n",
    "You: Bhargav Solanki\n",
    "\n",
    "Teammate: Carmen Sangro Prieto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the second lab. I hope this environment is starting to look more familiar, and that you learned some of the shortcuts. At least try to use shortcuts to evaluate a cell, create a cell above or below the current, and switch between code and markdown, as these will dramatically improve your efficiency and significantly cut the time it takes to complete the assignment.  \n",
    "Also, if you have not tried LaTeX in the previous assignment, give it a try in this one $y=mx+q$: a little practice goes a long way for when you will need to write more complex equations and LaTeX will be required (e.g. future assignments + exam)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Today's assignment is likely going to be a bit more time consuming than last week. And there is _a lot_ of Python.  I received multiple emails from people who are not confident in their Python skills or are worried having to learn it now in parallel with the main class content. I understand the concern and will be sure to hold your hand step by step in learning and practicing the required skills even if you have no prior experience.  \n",
    "Please understand nonetheless that proficiency in Python as seen here will be mandatory to pass the exam, so give it your best effort. You may want to start completing this assignment for example a few days before the deadline, to leave yourself time to ask any question on Moodle if needed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Last week we introduced three libraries: `numpy` does the main number crunching in Python; `matplotlib` is the foundation of most plotting; and `seaborn` wraps the plotting in a convenient interface and eye-pleasing defaults."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Today we introduce **Scikit-learn**, another heavy-weight library in the field which provides basic (but high-quality and fast) data analysis and ML tools.  \n",
    "Head over to the home page of [Scikit-learn](https://scikit-learn.org/stable/): how many of the concepts are you already familiar with? Over the next week you will become confident in almost each single word used in that page. Also check out the [user manual](https://scikit-learn.org/stable/user_guide.html) for an overview of the methods at your disposal.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to pass the lab?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below you find the exercise questions. Each question awarding points is numbered and states the number of points like this: **[0pts]**. To answer a question, fill the cell below with your answer (markdown for text, code for implementation). Incorrect or incomplete answers are in principle worth 0 points: to assign partial reward is only up to teacher discretion. Over-complete answers do not award extra points (though they are appreciated and will be kept under consideration). Save your work frequently! (`ctrl+s`)\n",
    "\n",
    "**You need at least 14 points (out of 21 available) to pass** (66%)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Fundamentals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The topics of *Classification* and *Feature* are fundamental ML concepts. Today's lecture has barely scratched the surface, especially if you think Data Analysis as a goal rather than a simple step, so we will explore these topics in further detail in the upcoming weeks. Let's make sure to have a solid grasp of these concepts before moving ahead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, let's start easy. Here is an example dataset of snakes. It has three fields: `head size`, `length` (in cm) and whether it is `poisonous` or not. It looks like this:\n",
    "\n",
    "```python\n",
    "snakes = [['small', 38, False],\n",
    "          ['small', 62, True],\n",
    "          ['medium', 55, True]]\n",
    "```\n",
    "\n",
    "This simple list of lists puts the emphasis on the data points (the rows), which is an intuitive approach at first for humans to manually write down the data. You will often encounter tables, JSON and CSV files that look like this. We will explore more machine-friendly formats later (spoilers: column-oriented), so understand this approach is just a step for ease of comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's lighten the mood by focusing on cats and dogs instead for your exercise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.1 **[1pt]** Name three features that are highly discriminative to classify cats from dogs, and three which are not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$Discriminative$\n",
    "\n",
    "|  Features  |      Dogs      |  Cats |\n",
    "|----------|:-------------:|------:|\n",
    "| Sound    |  Barks   | Meows |\n",
    "| Heavy Breathing |    True   |   False |\n",
    "| Retractable Claws | False |    True |\n",
    "\n",
    "$Non Discriminative$\n",
    "\n",
    "|  Features  |      Dogs      |  Cats |\n",
    "|----------|:-------------:|------:|\n",
    "| Tailsize    |  Small, Medium, Large   | Small, Medium, Large |\n",
    "| hasFur|    True   |   True |\n",
    "| Eye color | Any |    Any |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 **[1pt]** Is \"number of legs\" a numeric feature? Is it discrete or continuous? Is it ordinal? What about \"length of tail\"?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Careful not to confuse \"discrete cardinal\" with \"continuous\". If you cannot tell the difference, refresh the concept!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Number of legs is a Numeric feature. Its Discrete and cardinal( We can answer \"how many?\"). The length of the tail is Numeric and Continuous "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3 **[1pt]** Write a dataset named `pets` containing cats and dogs, with at least 3 features and 5 entries. Write the corresponding labels in a variable named `labels`. Save the feature names in a variable named `feature_names`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure to include some small dog and large cat, such that their size is not highly discriminant. You can write more data if you want, but do not go overboard, your goal for now is uniquely to pass the assignment. We will load some demo dataset with Scikit-learn later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['Dog', 'Cat', 'Dog', 'Cat', 'Cat']\n",
    "feature_names = ['Height', 'Barks', 'Retractable Claws', 'Weight']\n",
    "pets = [\n",
    "            [90, True, False, 30],\n",
    "            [95, False, True, 35],\n",
    "            [45, True, False, 18],\n",
    "            [70, False, True, 22],\n",
    "            [22, False, True, 7]\n",
    "       ]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Human input means human errors: let's validate the length of these lists using `assert`, which is a Python keyword that will raise an error if its parameter is false (and just do nothing otherwise).  \n",
    "Here we use `map` to execute `len` over each element of a list (which here is: for each data row), then check if all values correspond to the length of feature names. The function `all` returns whether all of its arguments have truth value. We can also verify the number of labels against the number of data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we were told to rename the variable as $pets$ and not as $data$. So changed it here \n",
    "assert all(l == len(feature_names) for l in map(len, pets))\n",
    "assert len(pets) == len(labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Decision trees"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are going to write a decision tree by hand, that classifies cats from dogs on your dataset, by using a simple chain of `if/else` statements. Do not overlook this task: it is an industry standard to integrate human expert knowledge in an automated ML system.  \n",
    "\n",
    "Include at least two questions, meaning the tree depth (max number of decision nodes between start and leaf) should be at least 2. The leaves should contain decision labels, i.e. either $cat$ or $dog$, though you can have multiple instances of either.  \n",
    "I hope you find it obvious that the labels should not be passed to the function.\n",
    "\n",
    "Do you know the [splat operator](https://codeyarns.github.io/tech/2012-04-25-unpack-operator-in-python.html)? You may find it useful to pass data points to your function. Here is a short demonstration [video](https://www.youtube.com/watch?v=9LrtOJTnwJE).\n",
    "\n",
    "With `map`, `zip` and the splat you should now be able to understand the `transpose()` function from last week:\n",
    "\n",
    "```python\n",
    "transpose = lambda lst: list(map(list, zip(*lst)))\n",
    "```\n",
    "\n",
    "A decent Python skill level is nowadays a mandatory requirement for good Data Analysis or Machine Learning job positions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 **[2pt]** Implement a Decision Tree as a function that takes the features of a data point from the `data` defined above and returns a predicted label using an if/else chain. Run it over your `data` to obtain a list of predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Dog', 'Cat', 'Dog', 'Cat', 'Cat']"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from enum import Enum\n",
    "from typing import List\n",
    "\n",
    "class AnimalType(Enum):\n",
    "    DOG = 'Dog'\n",
    "    CAT ='Cat'\n",
    "\n",
    "class AnimalBarks(Enum):\n",
    "    DOG = True\n",
    "    CAT = False\n",
    "\n",
    "class Animal:\n",
    "    \n",
    "    def __init__(self, animal: List[str]):\n",
    "        self.height = animal[0]\n",
    "        self.barks = animal[1]\n",
    "        self.retractableClaws = animal[2]\n",
    "        self.weigth = animal[3]\n",
    "\n",
    "        \n",
    "class Tree:\n",
    "    \n",
    "    def identify(self, animal: Animal) -> str:\n",
    "        if animal.retractableClaws is True:            \n",
    "            if animal.barks == AnimalBarks.CAT.value:\n",
    "                return AnimalType.CAT.value\n",
    "            else:\n",
    "                return AnimalType.DOG.value\n",
    "        else:\n",
    "            if animal.weigth >=5:\n",
    "                if animal.barks == AnimalBarks.DOG.value:\n",
    "                    return AnimalType.DOG.value\n",
    "                else:\n",
    "                    return AnimalType.CAT.value\n",
    "            else:\n",
    "                if animal.height >40:\n",
    "                    if animal.barks == AnimalBarks.DOG.value:\n",
    "                        return AnimalType.DOG.value\n",
    "                    else:\n",
    "                        return AnimalType.CAT.value\n",
    "                else:\n",
    "                    return AnimalType.CAT.value\n",
    "\n",
    "def temp():\n",
    "    labels = ['Dog', 'Cat', 'Dog', 'Cat', 'Cat']\n",
    "    feature_names = ['Height', 'Barks', 'Retractable Claws', 'Weight']\n",
    "    pets = [\n",
    "            [90, True, False, 30],\n",
    "            [95, False, True, 35],\n",
    "            [45, True, False, 18],\n",
    "            [70, False, True, 22],\n",
    "            [22, False, True, 7]\n",
    "       ]\n",
    "    predictions = []\n",
    "    tree = Tree()\n",
    "    for pet in pets:\n",
    "        animal = Animal(pet)\n",
    "        predictions.append(tree.identify(animal))\n",
    "    return predictions\n",
    "                \n",
    "predictions = temp()\n",
    "predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To quickly check if it got them all right you can use `zip`, which builds lists taking one element in turn from each of its input lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Dog', 'Dog')\n",
      "('Cat', 'Cat')\n",
      "('Dog', 'Dog')\n",
      "('Cat', 'Cat')\n",
      "('Cat', 'Cat')\n"
     ]
    }
   ],
   "source": [
    "for pair in zip(predictions, labels): print(pair)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to properly assess the performance of our classification. This is commonly done using the [**Confusion Matrix**](https://en.wikipedia.org/wiki/Confusion_matrix): two rows and two columns, indicating the count (over the dataset) of\n",
    "\n",
    "$$\n",
    "\\begin{pmatrix}\n",
    "% \\hrule\n",
    "\\text{true positives} & \\text{false negatives}\\\\\n",
    "% \\hrule\n",
    "\\text{false positives} & \\text{true negatives}\n",
    "% \\hrule\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "(edit this cell and notice above how you can use multi-line `latex` by wrapping your code in `$$` pairs)   \n",
    "(also it does not matter whether you pick $cat$ or $dog$ as the \"positive\" class, but be careful and consistent)\n",
    "\n",
    "The confusion matrix if the foundation to most loss functions for classification, some of which can be [extremely sophisticated](https://en.wikipedia.org/wiki/Matthews_correlation_coefficient).\n",
    "\n",
    "Perfect classification means no false positives (positive answers for data points that should classify negative) and no false negatives (negative answers for data points that should classify positive) for all data points in your dataset.\n",
    "\n",
    "Hint:\n",
    "```python\n",
    "pos = 'cat'; neg = 'dog'\n",
    "tp = 0; tn = 0; fp = 0; fn = 0\n",
    "for pred, lab in zip(predictions, labels):\n",
    "    # your code here\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2 **[2pt]** Compute and display the Confusion Matrix. If your tree did not achieve perfect classification, write a new version that does."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print the result using string interpolation. There are three ways to interpolate strings in Python: using `format()`, using `%` and using f-strings. You can read about [why you should switch to f-strings](https://realpython.com/python-f-strings/), but for now just try using something like this:\n",
    "```python\n",
    "print(f\"tp: {tp}, fn: {fn}\\nfp: {fp}, tn: {tn}\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tp: 2, fn: 0\n",
      "fp: 0, tn: 3\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "\n",
    "\n",
    "def confusion_matrix(predictions: List[str], labels: List[str]):\n",
    "    tp = 0; tn = 0; fp = 0; fn = 0\n",
    "    # positives --> Dog\n",
    "    # negatives --> Cat\n",
    "    for pred, label in zip(predictions, labels):\n",
    "        if pred == 'Dog' and label == 'Cat':\n",
    "            fp +=1\n",
    "        if pred == 'Dog' and label == 'Dog':\n",
    "            tp +=1\n",
    "        if pred == 'Cat' and label == 'Dog':\n",
    "            fn +=1\n",
    "        if pred == 'Cat' and label == 'Cat':\n",
    "            tn +=1\n",
    "    print(f\"tp: {tp}, fn: {fn}\\nfp: {fp}, tn: {tn}\")       \n",
    "predictions = temp()\n",
    "labels = ['Dog', 'Cat', 'Dog', 'Cat', 'Cat']\n",
    "confusion_matrix(predictions, labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[think: did you just write a decision tree? can you name the features?]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Doing these things by hand can be tedious, but provides a different type of confidence to then go and study the documentation of the library you would rather use in real applications.  \n",
    "Here is the [scikit-learn](https://scikit-learn.org/stable/modules/tree.html) implementation of a decision tree, and here is [the main class](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html). Let's load the implementation with the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['sepal length (cm)',\n",
       " 'sepal width (cm)',\n",
       " 'petal length (cm)',\n",
       " 'petal width (cm)']"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier, export_text\n",
    "from sklearn.datasets import load_iris\n",
    "iris = load_iris()\n",
    "iris.feature_names\n",
    "#iris.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3 **[1pt]** Train a scikit-learn DecisionTreeClassifier on your dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(223.2, 244.62, 'Barks <= 0.5\\ngini = 0.48\\nsamples = 5\\nvalue = [3, 2]\\nclass = Cat'),\n",
       " Text(111.6, 81.54000000000002, 'gini = 0.0\\nsamples = 3\\nvalue = [3, 0]\\nclass = Cat'),\n",
       " Text(334.79999999999995, 81.54000000000002, 'gini = 0.0\\nsamples = 2\\nvalue = [0, 2]\\nclass = Dog')]"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcwAAAFUCAYAAACp7gyoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd0DU5R/A8fcdew8FRVQUFyAKiiQOHLi35UjNxs/KsrLSbJmlpmXTsrTUbKil5t57oDgQRFEUQQVB9t77uPv9gRycrAMOsHpef3353vP9Ps8deh+e9flKFAqFAkEoJy/4dFM3QRAeCwZOXk3dBOExIm3qBgiCIAjCP4EImIIgCIKgBhEwBUEQBEENImAKgiAIghpEwBQEQRAENYiAKQiCIAhqEAFTEARBENQgAqYgCIIgqEEETEEQBEFQg3ZTN0D4d3hx0UoCbt2t8nUtqRRTY0OaW5jRy7kzowc8QbfO7RqvgdXYd/oSi3/cBMDSuc8xwatPE7fo3yExNZ0/95/i/NVbxCYko6WlRSvrZgx+woVpowdiaW5ar/sf9L7MolV/qFV28nBPFs2ZUa/6BEEETKFRFMvlpGVmk5aZzd3IGLYd9mb6mEG8O2sKEomkqZsnaJjfjRDmf7me7Ny8cmeLuBsZw93IGHYe9+Gb916mp1OnOtcRej+q/g0VhFoQAVPQuB8XvY6VpVnZCQUUyWSkZWYTEh7FloOnSc/KYcvBM1iYmvDylFFN11hB4yJi4nl7xVpy8wvQ09Vh5rgh9OvpRHGxnDN+19l+5CypGVm8vWItf331AW1srOpUT0h4ScC0b2PD5/P+V21ZCxPjOtUhCOWJgClonH0bG2ytm1X62oBe3Rg7qDfT31lBRnYOG3YeYdLw/liamTRyK4WGsuKXv8nNL0BLKmX1x2/g7txZ+Zp7ty54uDgyb8VaMrNz+W7jblZ+8Eqd6gmNiAagW6d2OLRvo5G2C0J1xKIfodG1sm7GpOH9ASgoLOL4hYAmbtG/R1xSKj/+uY8NO480Sf13IqK5fD0EgDGDeqsEy1IDenVjvJcHAKcvBxIZk1DremISU8jMzgXAwV4ES6FxiIApNAnncgt+ImNr/4UpqPK9fpt5X6xl7Ksf8+uuo6RmZDVJO05evKY8Hj/Yo8pyTw7tpzw+fvFqresJDS+bvxS9S6GxiCFZoUloScv+VtPT1a2yXF5+AftOX8I38DahEdGkZ+UgkxVjYmSAfRsb+vVwYtIIT0yNDCtc+/EPGzlwxpd2ti3YteoTftl5mN0nLpCWkU0zcxN6d3dg6dznamxrfkEhc5evwf/mHQDGDHyCT+c+j5ZW2XsIDotk1/HzBNy6S3xSKgDmpsY4dmiLV29XRg1wR1tLS+3PRx3ZuXkcOOPL30fOElGul6YllWJjpTok7vrknDrVUdtVw9du3wNAV0cbly72VZZz6miHvp4u+QWFXL4RUut57NL5S4lEQpf2rWt1rSDUlQiYQpO4Hf5Aedy1o12lZfxuhPD+t7+Slpld4bXUjCxSM7K4cvMOWw6dYe2St+jQxqbK+pav/Ys9Jy8qf45PTkNbu+YAVlhUxLwv1iqD5bjBHix941mk5QL+xr0n+H7THh59Fnt8chrxyWmcuXydvw6e5qdP5mpkrvZeZAx/HznLobN+5OYXKM9bWZgxcWhfJg3vT8vmlvWupy7Co+OBkmF3HZ2qv160tbRoZWVJeHQ8YQ9ia11PyMMVsm1trIhJTGH7kbNcvhFKfHIqero6tLdtyZA+PZg6aiAGelX/QSYItSECptDoYhJT+PvwWQBat2jO4N4uFco8iEvkjeVrKCySoaerw8Qhfenj6kgzc1PSs3K4FxnDloNnSErLICk1g2U//cUfKxZUWl9UXBIRMQk4dWjLy1NGY2JkwOUbIQzx6FFtO4tkxSz46hcuBd4GYOKQvnzy2jMqwfLa7TBlsLRt0YwXJg6no50tWlIJUXFJbDl0hlv3IgkJj+KLX/7mqwUv1ekzkxUXc9o3kL+PnFXZ7yqRSHiiexemjPBk0BMuVfZit61cWKd6bWoReItkxcqhYBurmq9r0dyC8Oh40jKzKSqSVRtgH1UaMJNSM3h6/mfI5WV/rBQWybhx5z437tzn7yNnWbVwDp3sbNW+tyBURQRMQePCo+LIyslVOSeXy0nPyuFGaDjbDnmTnpWDsaEBKz94pdIv+fXbD1NYJANg2ZvPM7yfm8rrnm7OTBren0lvLiMpLYPAkDCSUjNUt7M8VCyX07K5Bb8sm4eRgT4AvSpZjFKerLiYD77dwLkrQQA8Naw/H8+ZUWHP6N6TF1AoFGhJpWxYNl8lUHTvYs+wfj15YeG3BN+L5OSlq2Rm52BqbFRt3eUlpWaw64QPu46fJyk1Q3ne3MSI8V59mDzCk7Y21jXepzHm+bKyc5S97NLPuTqG+npl1+bkqp3IIDUji8SUdABy8wuwNDNh6qgBuDp0wEBPj7CoWLYfPUdIeBSxiSm8/PF3/PXNh1Wu3BYEdYmAKWjc3OVraizTopkFv33+TpVfYslpmViYGmPdzLxCsCxlamxEf7euyqHW+OS0SgMmlAylqvMlDlBcLGfR939wyjcQgCkjPFn4yvRKEywkp5UEMQN9XZpX8oWvq6PDa9PGcjEwGFvr5siK5Wq1odQLC78mJiFF+bOrQwemjPBkWL+e6Oro1OpeDa1QJlMeq9O28nPX5a+tSUi5hAUO9m1Y8/EbNCv32bs42DPBqy9L1mzmwBlf0rNyWPbTX6xd8qbadQhCZUTAFJpEQkoaLy1ayeszxjN2UO8Kr5d+ucnl1QeY8l+UhUVFVZbr1qm9Wu1SyBUsXr2Jo+evADB15AA+nD2tymxE7VvbcOFaMNm5+bz7zQbenDkB+0fmUvu7OdPfzVmt+h9VfqhxiIcr7704lRbNLep0r4ZWfqhaneRNCsrem0Si/oJ9d+cu7FuzlJiEZDrZ2ar8GyilpSXl4zkzuBp8l5iEFHyv3+ZORDSd24kFQkLdiYApaNyhdcsr9BxlxcXk5OYTk5iMb2AIm/adIC4plUWr/iAuKbXKVZKlX8JFRTLiklOJTkjmQWwiYQ9iCbobQej9aGVZ+SOLbspTN8is33GY2MSyHp25iXG1qfumjR7I3lMXyc7Nw9vvOt5+12ndojkeLo70dnGgt4tDpSt41dXDsSPxyf4oFApO+Qbi7XcDz17dmDpyAH1cHdVOKxhSxzRyNs0tMTNRbwi5/BBrQWHVf7yUKixXRrcW85c62lrYtbLGrlX1Q9G6OjqMG+zB2m2HALh8PUQETKFeRMAUGoW2lhZmJkaYmRjh1MEOLw8Xnn3/K7Jy8vhp6wH69+yKY4e2Ktdk5eSx7fAZTly8StiDOIor6W1KpRKqiZNKxobqDceWBktdHW0Ki2T8tucYQ/r0qHLrQuuWVqxd8iaLf9xEWFQcANEJyew87sPO4z5oSaW4de3EhCF9GT3AvdZ5cz+f9z/mTBvL30fOsu/0RbJyygJzm5ZWTB7hyQSvPpibVp/6bdr8z2tVb6nabCsx1NdDIpGgUCjIK7d6tyqlK3wlEgkmRgZ1al9NurQrm7uNfbjdRxDqSiQuEJpEO9uWTB05EACFQsH+M74qr4fej+apuUtZs+UAdyJiKJbL0dXRppOdLUP79GTuzAn8/tk7vDhppHoV1iJQPTPOi6/ffRkAmayYxas3ISsurrK8c6d27Fz1Mb8sm8f0MYNVej7Fcjl+QaF89P3vvLpkFfkFhWq3o1QbGysWzJrM8Q0rWPTqDDq2bQVAVHwS323czfCXPmTRqj+4HhJe63trklQqpeXDnnx8clqN5RMelmlmbqLxPaql9MttKSkqUn+eVBAqI3qYQpPpVkW2n6IiGfO/XEvSwwU1T48ayJPD+tGxbasKX6xn/K5rtE2Th3vy7qwpAAzr25MTF68SEh7F77uP8fKU0VVeJ5FIcHfurEwFl5Cchv/NO/gEBHHm8nUKi2RcvhHKpn0nmT216vtUx0Bfj8kjPJk8whP/oFC2HfbG2+8GhUUyDnpf5qD3ZTq3a83UkQMYPcAdw3KLnAL3/FynOmvLvo0NcUmpxCSmUFwsV0nuUJ6suFjZ46tu/2xlbt6NIC4plfTMbCaP8Ky2114+45GluchXLNSP6GEKTab8nGP5+a9zV4KUK0PHDurNh7On4dC+TaW9kDgND7N161K2OOj9l6YqhwrXbz/CvUo22OcVFBJyP0o5HFuqRXMLxg7qzZfvvMS6pW8rz5duU6kv925d+Pb9Vzi0bhmzJo3A4uGQ7J2IaJav3cKarQc0Uk9tlWb3yS8oJDgssspywfcilb3tHk4da1XHmi37effrX/hs3VZlooSqXAu+pzx27tSuVvUIwqNEwBSaTGmSbkBlY3lkbKLyuLovudT0TGVSAYDiaoZN66K5hRnznn8KKHk82ZLVmykuty0kNy8fz2fmMW3+53yxfluV9+nh2AFjw5LAW91K3rpo2dySN2dO5NiGz1k69zmcHs4DP5p1qLEM69tTeVw+s9Kjdp+4oDyuKYHEo8rvoT3wyFB+eclpGRw+5weAhakxHi4OtapHEB4lAqbQJG6Ehiu/NLW1pCpbS8xNy1Zl+lTRI0vLzObdrzeoPKC4sAHmqJ4c2g+3riUPOb55N4LN+08qXzM00Fe+duXWXbyrGB4+dyVI2c6q0gDWl66ODhO8+rDlmw/ZuOJd3J27NEg9NWnfuiW9HwamfacuVtqj9gm4qQx0Hi6Otc7CM35wHwwejkhsOXhapRdZKjcvn/e+2aBcWPTS5FGP3b5V4Z9HzGEKGldZph8oWUCTnJbBhWvB7D99iaKHm9VfeHI4ti2aK8sNdO+Ovt4O8gsKuXAtmNeXreapof2wbmZOelYO14LvsffUxQpP5CgfPDVFIpHw8ZwZTJ33GYVFMn7edpDBT7hgZ9sCgDnTx+F/8w5yuYIFX//CBK8+9OvRFStLM9Iys/EPCmXHMR+gZAHK8xOHabyNj3JxqDrpeWP44KWnmf7O5+QXFjH/i7VMGz2YQU90RwGc9bvBtsNnKJbLMdTX44OXp1Z6jxcXrVSmAPxl2TyVx4RZWZox//mn+GzdVgqLZLyyZBXTRg/C080ZXR0dboc/YNO+k8oVzwPduzF9zKCGftvCf4AImILGqZPpB0qeqvHMOC9enzFe5Xwzc1M+ee0ZPvlhI7JiOReu3uLC1VsVrrexsuT5icP44pe/AQh7EFehjCa0s23Jy1NGsWbLAQoKi1i8ejO/fTYfqVSKq0MHPnltJp+t3UqRTMau4+fZdfx8hXuYGRuxYv4s2tm2bJA2Pk7at27J9wvnsOCrX8jOzePPA6f488AplTLGhgasfH92nT+PKSMHUCSTsXLjbgqLZGzad5JN+05WKDd6wBMseWOmSlIFQagrETCFRqOvq4OJkSFtbaxxdezA2EG9ad+68i/M0QOewL61DZv3n+Rq8D2S0jKQSiSYmRhh38YGr96ujBvUGz1dXTbsPEJyWibHLwbw+oxxDfLl+MKTIzh2PoB7D2IJDAlj6yFvnhnnBZQkZe/h2JGdx87hFxRKTEIy+QWFmBgZ0sbGGk83Z6aM8Kxxr+S/iYeLI3tXL2bz/lP4BNwkLikVuVxOK6tm9HfryrMThmJtaV6vOmaM9aK/mzPbDntz+XoIsQ/raGZuSk+njkwY0rfSB1gLQl1JFE21OkB4bOUFn27qJgjCY8HAyaupmyA8RsQ4hSAIgiCoQQRMQRAEQVCDCJiCIAiCoAYRMAVBEARBDSJgCoIgCIIaRMAUBEEQBDWIgCkIgiAIahABUxAEQRDUIAKmIAiCIKhBpMYT/hViElMY88oiAMYN9mDZm89r9P7+N+/w8sffAfDK02OYM22sRu/fECJjE/lz/0l8b4SQkJyGvp4urVs0Z1g/N54eOUDlAdOadPxCAO99swGomDi9MhEx8Ww5eAa/oFDik9NAocCqmTnuzl2YMWYQHWv5NBNBaCgiYArCv9Dhc34sXfMnBYVlz98sLJIRnP2A4LAH7D5+nlUL52Dfxkaj9aZmZLGimmeDPmr3ifOsWP+38sk1paLikoiKS2LfqYu8/fxTPDt+iEbbKQh1IQKmIPzLXLl5h49XbaRYLsfEyIBZk0bSw7EDufkFHDnnz4EzvkTFJzH3szVs+fpDzEyMar6pmj5ft420zGy1yvoE3GTZz1tQKBRoa2sxffQgend3QEdHm4Cbd9m07wT5hUV8+/tOLEyNVZ6ZKghNQSRfFyoQydf/uYqL5Ux+axn3Y+IxMtBn05fv0eGRXuTOYz4sX7sFgJnjhrBg1mSN1F1+KLZUdUOyT81dSnh0PNpaUtZ/+jY9nTqpvH43MobnPviavPwCLM1MOLZhBTraWhppq7pE8nWhPLHoRxD+RXwCgrgfEw/AsxOGVAiWAJNHeNK7excAdhw7p5EHb5cfirVQ4zFmMQnJhEeXtNPLo0eFYAnQyc6WJ4f2Vd7/Rmh4vdspCPUhAqYg/IucvHRNeTx+cJ8qyz05tB8ABYVFnPUPqne9pUOxnexseWpY/xrLJ6dlKo9trCyrLNe+3AOmk1LT69dIQagnMYcpPFbCouL4c/8p/IJCSEzJwMhAjy72bZgywpOhfXqy/Oct7Dzug42VJUfWf6a8rrpVsuVXuG764l2cOtqx6/h5jpzzJyImnryCQqwtzfFwdeTZ8UNoa2NdoV31WSVbvm21pc4q0/Ku3b4HgG2LZrSyblZlObeuZfe8fCOEMQOfqFP7oGQo9uSlq2hJpSx541nOXak5AFtZmimP7z2IrbJceHSc8ti6Wf0eOC0I9SUCpvDYOOR9mcVrNiOTFSvPpWfJuHw9hMvXQxg94An0dHXqVUd6Vg7Pvf8VwWEPVM5HxScRdTSJvScv8tWClxjc26Ve9TSFvIJCYhNTAbBr1aLaslaWZujr6ZJfUEhYNQGrJuWHYp+bMJSuHe3UCpitrJvRpX1rQu9Hc/FaML7Xb+Ph4qhS5n50PHtPXQJKeqHdOrWvczsFQRNEwBQeC2cuX2fRDxtRKBTo6+nyzFgv+vZwQiIB3+sh/Ln/FIfP+aGrU79/sp/+9CfJaZm4O3dm0vD+2LawIik1nb+PeHP5RihFMhmf/LiRQ87LMTUy1Mh7s7YwY9vKhXW6tm1LK7XLJqWmU7qGr7phzlItmpkTGZtIYkrdhzpLh2Lb2bbg1VruTf3olem89umPZOfmM3f5T0wfU7JKVldHm+uh4fyx5zh5+QXo6+my9I1n0ann714Q6kv8CxSaXH5BIV/9uh2FQoGRgT6/Lp+Pg30b5es9nToxvJ8bLy1aSXpWTr3qSk7L5LkJQ5n/wiSV84N7uzD3s584H3CTrJw8vC9fZ7xX1XOAtaGjo41D+zY1F6ynjKxc5bGRGkkJDPX1AMjKya2hZOVKh2KlUglL3ni21r3/7l3s2fjFe/y4eS/e/jfYtO8km/adVCnTr2dX3nlhksb3iwpCXYhFP0KTO+UbSFxSyVDinOljVYJlqY5tW/HO/+q//cHC1Jg3nhlf4bxEIuGpYf2UP9+JiKl3XY2tSFaWpECdnrieri4AhY8kDVBH+aHYaaMH4erQodb3ALgRGk50QnKVrwfduc+xCwEUFdW+jYKgaaKHKTQ5b7/rAEilkmp7dSM93flyw/Z6bYNw69oZXZ3Ke0Jtyg1/5uTl17mOpiKVlv39K5FIaiyvoGT4VqpG2UeVDsW2btGcuTMn1vp6uVzOsp+3sOfkBQDcnTsze+ponDu1A+DmvUg27DzC5eshrPv7EMH3Ivn2/dlV/u4EoTGIgCk0udD70UBJwKpu3lBHWwsH+zZcuXmnznW1sq56bq90iBKgWC6vcx2PKiqSEVZutWdttG1ppXbO1/LtL58SryqFD8vo1DIIlQ7FSiQSFr8+EwM93VpdD7DjmI8yWI7o78aKebNUAr67c2d6de3Epz/9xZ6TF/AJuMnavw/xZh2CsyBoigiYQpNLSS/Zk2euxob3ZuYm9arLoFxQqaBcT0uTCbAS0zKYNv/zOl1bm20l5ect8/ILaiyf+7CMmbH6i5vKD8VOGtYf925d1L62vG2HvIGS38dHr0xXCZalJBIJ7780FZ+AIJLTMtlx9ByvTR+HtlbjZvsRhFIiYApNrjTxtkIusjTWh7WlOdpaUmTF8pKnftQg4eHqWGtL9fc3frVhO2mZ2RgZ6DN6oDsh96MqlEkpl5QgKi4REyMDoKy3nJ2bp8xG1NOxA6bGVeey1dfTxdPNmT0nL5KVk0dETAId27ZSu72CoEkiYApNztzUmMSUdLWSdtd3lWxTsLVuRuCenxu8Hh0dbdraWBMeHU9UfFK1ZZNSM8gvKASgQ1v1V6Bef5ieLicvn1kfrayx/Kc//aU8Lu0t55br/ZqosXXHwqxsVEETafwEoa7EKlmhyTk+XBUbnZBMZjVbHORyOaHhFXs0QpnuXewBiIhJIDkto8pyAbfK5oF7OHZs8HaVZ25ipFyUVFNgB1T2iVqa1W9IXhDqQ/QwhSY30L07Z/2DUCgUHD7rx7TRgyotd9Y/6B/Zw2xMw/r2ZO+piwDsPXWRlyaPqrTc7hMlC250tLXx7NVN7fuXT0dYlZ+3HWTd34eAyudgdXV0cO5kR9CdCILDHhAeFVflPsvs3Dx8rtwESrITtalFIgdB0DTRwxSa3KgBT9DcwhSAn7YeqDS3aFxSKl9u+Luxm/aP09vFQZmw/LddxwgOi6xQZucxH/yCQoGSvLvqPF1E06aNHgyULK5a+P3vpGZkVShTWFTEolUbycgu+SNpxpjBam2XEYSGInqYQpMz0NNl4ezpvPPVejKzc3n+g695ZqwXvV0ckEqlBN6+x8a9J1R6l+KLs3LaWlosfGUaryxZRW5+AbM+WskLTw6jdzcH8guLOOLjz/7TJflZrSzNKk3iADBq9kfKZBKH1i3HtppE7nUxeoA7p32vcco3kJDwKKbOW87UkQNxdbBHX0+XOxExbDl0hvCoku04PRw7MHPcEI22QRBqSwRM4bHg5eHKh7Of5qtfd5CTl8/6HYdZv+OwSpmnRw3kYmAwUXFJ9c4p+2/m3q0Ln859nk9/+pP8gkLWbjvE2m2HVMpYNzNn9aLXm2xOUCKR8Pm8WaxYv429py6SnJbJT1sPVFp2oHs3lr/1P5FLVmhy4l+g8NiYOnIgPR078tfBM/gFhZCclomerg7OndoxbfQgBvTqxqjZHwGqm/SFisYO6o1LF3s27z/Jpeu3SUxJRyKR0NbGmsG9XXhmnJfGksvXlZ6uDkveeJanhvVj1/HzXL19j6TUDBQKBZZmJrg42DN+cB/69nBq0nYKQimJQpM7tIV/hbzg003dhCr1mzGPnLx8Brl35/uFc5q6OcK/nIGTV1M3QXiMiB6m0OQOnfXjzOVAWre04rkJQ6scJrx1L1KZ47Vzu9aN2URBEAQRMIWmp6+rw8lL1wAwMtDj5SmjK5TJKyjk6193ACXzX159XBu1jYIgCCJgCk2uX8+u2FhZEpeUys/bDhIeHc8QD1esLc3JzS/g3oNYdhw9R2RsIgDTxwxqlOdLCoIglCfmMIUKmmIOMyQ8ijc//0klq0tlZowdzLznJ6GjLRJwCw1PzGEK5YmAKVTQVIt+8vIL2HXiPGf9bnDvQSxZObkYGuhjbWmOW9dOTBjSB6cOdk3SNuG/SQRMoTwRMIUKHudVsoLQmETAFMoTqfEEQRAEQQ0iYAqCIAiCGkTAFARBEAQ1iIApCIIgCGoQ+zAFoQnV9OxIoYysuJi+09+msEhWY1ldHW38tv/YCK0S/ktED1MQhH+E+9HxagVLQWgooocpCMI/Qkh4lPL4m/depnVLqyrLSsXzUoUGIAKmIAj/CCH3SwKmjrY2A91dRLYnodGJIVlBEP4RSnuYHdvaiGApNAkRMAVB+EcIvR8NgIO9SLwvNA0xJCs0mMiYBLYfO4ffjVCiE5KRyYoxNzGicztbPHt1Y+KQvujr6VZ5fUJyGrtPXuDKzTs8iE0kIzsHqVSKuYkRDvZtGdanByM8e6GtVbG3MWr2R8QlpfL0qIF8OHsa/kGhbD3kTdCd+2Tm5NLM3JQ+ro7MemoEti2aA5CSnsnGvSfw9rtBfHIq+nq6OHdqx3MThuLh4lihjvIrXAP3/ExcUiq/7TrK+au3SE7LxMhAj64d7Zg03BMvj/o9jsz/5h32nbrI1eB7pKRnoqOthY1VM/q4OjJt9CBaWTer8trM7Bx2HjvPuStBhEXFkldQiImhAW1aWtHbxYGpIwdiZWlW6zbtO32JxT9uqtP7Cdzzc63KR8cnkZ2bB4CDfds61SkI9SUCptAgjvr4s+iHjchkxSrnk9IySErL4MK1YDbtO8naJW/S1sa6wvWb9p3khz/3VrgeIL6gkPjkNLz9rrPjmA8/ffIGhgb6VbZl5R+72LTvpMq52MQUdh0/z6lL19iwfD55+QW8vWItKemZyjKFRTIuXgvmUuBtFr82k4lD+1ZZx617kbz+6Y+kZ+Uoz6VnybhwLZgL14IZPeAJls59rtZDiQWFRSxevYmjPlcqnL8bGcPdyBi2HvJmwazJPD1qYIXr70XGMGfpjySlZaicT8vMJi0zmxt37rN530m+eOdFBj3hUqu2NabS+UuANi2t2LTvJCcvXSM8KpYiWTHWlub07u7AzPFetLNt2YQtFf7NRMAUNC46PonFqzcjkxVjYWrMrKdG4NTRDl0dHeKSUth94gK+128Tm5jCR9//zuYv31e5/qD3ZVb+sQsAKwsznh49EEf7tpgaG5KUmkFA8F12HfMhv7CIwJAwftt9jDeemVBpW45fCCAtMxsbK0uemzAUB/u2pKRnsHHvCYLuRJCelcPiHzcRm5hCXn4Bs54aQd8eTkilEk75BrLl4BkUCgVf/7aDoX17YGxoUGk9b3/+M+lZOfTt4cTkEZ40Nzcl9H40v+0+RlxSKofP+aGlJWXZm8+r/TnK5XLmf7GWC9eCAejp1JGJQ/rSvnVLCotk3Lhzn22HvElISWPF+m0AKkFTLpfz7tcbSErLQFtLyoyxXni4OmJmbERKeibn/IPYc/IC+YVFLPka0wEAACAASURBVPzudw7+/CmW5qZqt2+Qe3e2rVyodvn6KL9C9r1vfiE7N1/l9aj4JKLik9h76gJvPfcUz44f0ijtEv5bRMAUNO7QWT8KCosAWPnBq/Rw7KB8rVvndgzr25N5K9bi7X+DoDsRhN6Ppkv71gAoFArWbNkPgLGhAb9+Nr9CD9TLw5VhfXsy66NvkcsVnLx0rcqAmZaZjV0ra/5Y8S4WpsbK8/16dGXkyx+RkZ3DrXuRaGtr8cun81Ta2tOpE1pSKZv2nSQnLx//oDsM7l15LywpLYMXnhzO2889qTzXvYs9I/q78dLH33EnIoYDZ3x5cmhfejp1Uutz3H70nDJYzp4ymtdmjFN53a1rJyYN68cri1dxOzyKb37byaAnXGjRzByAa7fDuB8TD8ArT4/l5SmjVK4f0Ksbdq2s+faPXeTmF3DE5wrPjFP/6RxmJkaYmRipXb4+Qh7OXwLk5BUwsn8vhvdzw8rSnJT0DE5fvs4h78vIiuV8+/tOtLWkTB8zuFHaJvx3iEU/gsYllxv+a2tTca+cRCLhpSmjmDpyAPNfmISxYdlwamxSKsaGBhgb6jPey6PS4VoAV4cO2FqXzD3GJ6VW257XZ4xXCZYABvp69Hfrqvx5lKe7SrAsNeiJ7srjqPikKuvo2tGON2dWDNqmxkZ8OresV7n96Llq21pKLpezce8JADq3a82c6WMrLWdqbMTHrz0DQJFMxvYjZ5Wv1fR7AJg8wpMnh/bj9Rnj6drp8X3WaOjDHqa2tharPpzDF++8iJeHK906t2PQEy58Ovc5Vi2cg7ZWyVfat3/sIiYxpSmbLPwLiR6moHHtW5fNIb3z5XoWzJqMc6d2KmWcO7WrcA7A1roZO75fBJQEjeo0tzAlKj6Jghqyv/Tt4VTp+RbNLJTHvbs7VFrG0sxEeZybn19pGSgZCpVKK//708G+DV3atyb0fjTnA24hKy6udKFSeXcjY4l7+IdA7+5dkFSzEd+pgx2WZiakZmThFxQClATu8r+Hb//YhY6ONp5u3VTmUQ309Vj8+sxq2/I42Prth0QnJCOVSOjexb7SMv3dnHl+4nB+3XUUmayYrQfPsGDW5EZuqfBvJgKmoHFjB3uwce9JElLSCAwJY+Z7X2JlaYaHiyMe3R3wcHWkmRpzZaUBKDcvn5jEFKLjk4mMTeBuZAyBIWHEJJT0IKp7BrqZsVGV8446OmX//JtbVN4eHR0d5XF1j1rv4dix6hcpCWqh96PJzs0jKTUDGyvLasvfDn+gPN68/xSb95+qtnyp6Phk5XHndq0Z0Ksb564EkZiSzvwv1mFkoI+7c2d6uzjQx9WxXgtkMrJyiEuuvndfFYf2tdsa0tzCjOYWNa/knTS8P7/uOgrA5RshdWqbIFRFBExB40yNDFn/6dss/nETgSFhACSlZnDgjC8HzvgikUhw7mTH2EEePDW0n0rgKvUgLpE/95/CJ+Cmsqf1KKlUglxeTRQDDA301GqzVg09vprUtC3DwqxsSDg5LbPGgJmemV2ndmRk56j8/MX8WXyxYTsHzviiUCjIycvH2/8G3v43gJIVp8P7ufHMOC+V3rQ6vP1vNNq2EnW1sm6GiZEBWTl5xCWJIVlBs0TAFBpEyUKbBdy8G8Fp30DOX73F3cgYFAoFCoWCoDsRBN2JYNdxH9YtfVtljvHQWT+WrN5MkaxsqNXY0IB2ti2wb2ODU4e2uHfrwufrthJw625TvL0Kagq45QO7jk7Nwbm43HD0W889SR/XivtA1WFooM+nc5/jlafHcPLiVXwCbnI9JFz52UbFJ/HrrqNsP3qWnz55k26d29WpnseJvp4uWTl5IlG7oHEiYAoNqnSu8s1nJ5KWmY1/UCgXrt7i5KVr5OTlcycihlWb9rDkjWcBCIuKUwZLA309Xps2Fi8PV2VygfLy8gsa++1UKTM7p9ph5tSMLOWxtRpDi2bGZatPJdR+CPNRttbNeH7iMJ6fOIy8gkKuh4RxKfA2x85fIT45jaycPD76/nf2rl5c5VzsoyZ49WGCV596tUsdCSnphIZHkZqZRbfO7enQxqbKssXFcjIe7oVVZ9hfEGpDrJIVNK6wqIh7D2K5HfZA5byFqTHD+7mxdO5zbPnmQ2WWn3NXgpRldh47p+z9vP/SVJ6dMLTSYKlQKIhPTmvAd1E75fcJVubW3QigZOjWQo2hz452rZTH/kGh1ZaVy+X8suMwu46fV+lxy+VyouOTKlxvoKeLh4sj855/ij2rl9C5XcmWngdxiUTEJNTYtsZ2Nfgub37+E0tWb2b/6UvVlr11L0LZs+zasV0jtE74LxEBU9C4UbMXMfmtZSz4en2VZexaWSu3jBQWFSnPR8YmKo+dO1a9zeFS4G2VXpusuGJGoMZ0wNu3ytduhIYTFhUHwBCPHtWueC3VtWM7ZS/z0vXbyusrc/pyIGu2HGDZz3/x14HTyvMffvcbY+d8wsuffE9sFVssDPR06eVcti/0cRzG7OnUCam05DM7dv6Kyr+XR23aV7Y4apRnrwZvm/DfIgKmoHEDejkDEJOQwrbD3pWWCb0fTXhULFCyh7GUuUnZXOa5KzervHbxatXFJkVN/EV/1OcKxy4EVDifmpHFktWbAdDV0Wba6Irp6yqjo63F9LGDgJL5z/e/2UBqubR9peKSUvlyw3blz9PHlm3WH+DWTXm88o/dldaTnZuHz8PP2chAHzvbFmq1rzG1aGbOIPeShBHxyWms/GN3pSuj/zpwmpOXrgLg1KHtY53qT/hnEnOYgsbNemokR88HkJdfwFe/budq8D2G9ulBy+YWZOfmcz00nK2HziArliOVSnhpymjltSP6u3H4nB8AP23dT2JqOv17dsXMxIiElDTOXbnJUR//Cj2hrNw8DPTVWxHbUD5c+Su+gbcZ3s8NIwM9bt6N4Pc9x0lKLUkgMHvq6Fpt45j11AjOXblJ8L1I7j2IZcq8z5g5zgtXhw7IiosJuhPB5v0nSXu4onbikL64O3dWXj+8fy/+2HuCu5ExnLx0lWff/5JJwz1pa2NFsVzB/eg4/jpwWpmQ4fmJwzCoJhl+U1owazKBIWGkZmSx7bA34VFxTBk5ABsrSxKS0zhwxle58tfcxIjP3v4fWlqiPyBolgiYgsa1sbHim3df5v1vN5Cdm8/xCwEcr6T3pa+ny8LZ01S+5Ae6d2fKyAHsOHoOWbGcbYe9K+2lunXtRNeOdsqk6mEP4rC2NG+w91ST5yYMZfuRs+w5eYE9Jy+ovCaVSpg7cyL/e3J4re6pq6PD2sVz+WDlb1y8FkxKeiarNu+ttOzEIX1ZNGeGyjkdbS2+//BVXvv0RyJjE5Urkx8lkUiYMsKzQuq8x0kr62asW/oW879cR1RcEn5BofhVMrdb8m9vtkrSBkHQFBEwhQbRr2dX9vy4hO1Hz3Ip8DYP4hLJzcvHyMCAVtaW9O3RlSkjPWnZvOJ+xI9emU4fF0d2nThP8L1IMrNz0dHRxsrCjC7tWzN64BMMcu9OeHS8MmAe9fGv89YLTfDs1Y1Jw/rzy84jXL4eQmZOLjZWlrh17cQzY72wr2ZlZ3VMjY346ZO5XLh6i4NnL3MjNJyUtEzkCgVWlma4OnTgqWH9cetaeX5a2xbN2f7dIvaeusjpy4Hci4wt+Ty1tbCyNKOXc2cmDulLt87t6/P2G0UnO1t2PHwvpy5d425kDNl5+ZgaGWLfxoahfXrw5NB+6Onq1HwzQagDiaK6NCnCf1Je8OmaCwkqz8P8Zdk8lZ6y8O9g4KR+Mnrh308M8guCIAiCGkTAFARBEAQ1iIApCIIgCGoQAVMQBEEQ1CACpiAIgiCoQaySFSoQq2QFoYRYJSuUJ3qYgiAIgqAGETAFQRAEQQ0iYAqCIAiCGkRqPOEf78VFK5XPgQzc83MTt+bx5/rknArnbKwsObL+M5VzcrmcIz5XOOjtS0h4FNm5+ViameBg35qxgzwY2ke9R5XVV0FhEQe8fTntG0jo/WgysnPQ19Wldcvm9HV1YtqYQRXyCPvfvMPLH39X4V5uXTvx6/L5Dd5m4d9JBExBECrIzM5h3op1BATfVTmfkJJGQkoaZ/2DcHfuzJfvvIiluWmDtSM8Ko53vlzP/Zh4lfPZsjxCwqMICY9i62FvPp37HMP69mywdggCiIApCP9ZTh3a8snrMwHQ0S77KpDL5bz52c8EhoQpy00fM5g2NlYkJKex+8R5Lt8Ixf/mHd7+Yh2/LpuHjo7mv0pSM7J4dekPJKakA+Dp5sy4wR7YWDUjKyeXc1eC2Hnch7z8Aj749ldMjAzwcClJwN+1Q1u2rVyovNe0+Z9rvH3Cf48ImILwH2Wgr4dD+zYVzu8/46sMloPcu7Pyg1eQSsuWO4zo34slqzez99RFboSGc9jHnwlefTTevp+3HVQGyznTxvLK02NUXu/bw4nBvV14fdlqZLJiPlu7lT2rF6OtpYWhgX6l700Q6kMs+hEEQcXu4+cB0JJK+fi1Z1SCZam3n3tSeXz8/BWNt6GwqIgjDx8k3rFtK2ZPHV1pud7dHZg83BOAqPgkAm+HabwtglBKBExBEJQUCgWd2tnStaMdvV0caFbF/KS5qTGWZiYAxCWlarwdofejyc7NB2Bwb5dqFxeVfw5q6P1ojbdFEEqJIVmhzrYeOsOXG7YDsHTuc9UOy6WmZzL8pQ+RFcsZ2qcn37z3ssrr6ZnZ7Dl1Eb8bIYRFxZGZlYMCMDUypFM7Wwa6d2eCVx/09XRr1cZRsz8iLim10lWg5amz0ra4WM7hc34cvxBASHgUaVnZGBvo0751Swa6d2fqyAEYGujXqn2V1V8b4wZ7sOzN5+tUZ2UkEgkfz3mmxnLZuXlk5uQC0NzCTGP1lzI3MebVaWNISs2gh1PHasuWT1ZWWFSk8bYIQikRMIU6G+Xpzso/dlMkk3H4nF+1AfPo+SvIiuUAjB/sofLaER9/Pv3pL/LyCypcl1SYQVJaBhevBfP3YW/WLX0bK0vNf0HXJDYxhXlfrK3Qg0nPyuHa7TCu3Q7jzwOn+HrByzV+wf8brNlyAJmsGICRnr00fv82Nla8+vRYtcr637yjPG5pZanxtghCKREwhTozNzVmQC9nTvkG4h8USnJaRpW9jUNnS+ajmpmb0renk/J8wK27LPzudxQKBcaGBkwdNQBXhw5YmBqTmpHFrbuRbD18hqycPMKj4/lu424+n/e/Rnl/pVIzsvjfwm9JSElDKpUwesATeHm4Ym1pTmZ2LhevBbPzuA/JaZnMWfoDv3++AMcObWtVx+LXZ5JbyR8MNTEzNqr1NXVRXCwnOT2TW/ci+Gv/aeV2k349nBjfAAt+1JWclsG+UxcBkEol9O7u0GRtEf79RMAU6mW8Vx9O+QYilys4ev4KM8cNqVAmMjaRW/ciARg9wB1tLS3la2u27EehUKAllfLTJ2/QvYu9yrUD3bsz3suDyW8vJ7+gkNOXAykulqOl1XjT75+v20pCShra2lp8/8Gr9HdzVnm9bw8nJgzpw/8WfkN2bj4f/7CRHd8vqtWm/rY21pputkZNX7CCOxFlvWuJRMILE4fxytNjVH6fjUkul7N49WblXOeYgb2V86qC0BDEoh+hXvr17KpcGHL4nH+lZQ6dvaw8Lt8bySsoJL+wCFNjQwa4d6sQLEu1bmmFS5f2AOQXFJKRla2p5tfoQVwip3wDAZgywrNCsCzVyc6W2VNLtj3cexCL7/WQRmtjY4hLSlH5WaFQcMbvOnsf9u6awpcbtnPh6i0ALEyNmTtzQpO1RfhvED1MoV60tbQYPcCdzftPEXwvksiYBOxsW6iUOfIwkDrYt6GTna3yvIGeLlu+/gAo6S1Up5l52VBvQZFMU82vkc+Vm8pFJaWb4qvSr2dXVv6xCwC/GyEqqzf/yeRyOe+9OBW7VtYUFskIuHWXrYfOEBGTwBe//E3o/WgWP0yA0BgUCgVf/bqdv4+cBUBbS8oX77xYIT2eIGiaCJhCvU3w6sPm/acAOOzjz5xpZYs1roeEExWfBFRc7FNe6V6/gsIiYhNTiE5IJjI2gXuRsdwIDSc8uiw1mrwRH+F6O/yB8vitz9XPUxsVn1yreh7EJdZ5DtOmgRe6SKVSxpX73fVy7vxwCPpb4pJS2XPyAr2cOzNm4BMN2g6AoiIZS9ZsVs6Ja0mlLH/rBTF3KTQKETCFeutoZ4ujfRtuh0dx+JyfSsAsHY7V1tZipKd7pdcnpWbw18HTnLkcyIO4JCp7prlUKkEub/xnnadn5dTpuszs2l23dM2fj8W2EnW1bG7JwlemM3f5GqAk2UFDB8yMrBzmf7lO+TnpaGvz2dsvMLyfW4PWKwilRMAUNGK8Vx9uh0cRFZfEzbsROHdqh6y4mBMXrwIleUArW5Dhe/02C75ar1y4AaCvp0t72xa0a90SJ/u2uDl3YsvBMxz0vlzhek2pLEgDFBcXK4/XL30LUxP1VqUa6utppF2Ps76uTujr6ZJfUEhoRFSD1vUgLpG5y9cQGZsIgJGBPt+8N/tfM+wt/DOIgCloRPk9mUd8/HHu1I6L14JJyyxZoDOukuHY1PRM3vtmA9m5+WhJpbw4aSQjPXvRzrZFhXRs+QWFdWqXuitVs3PzKj1ffttGQ+YnfVweOSUrLiYuMZWohCRsrZpVmI8uT0tLiomhAfkFhRTJiqssV18h4VG89umPpGZkAWBlYcaPi17HwV7kihUal1glK2hE6Z5MgNMPV5Ue8SlZ7GNhaoynW7cK1xw660dmdkm2mBcnj+S1GeOwb2NTae7SuqZfK93yUF3AVSgUJCSnV/paR7tWymP/oNBq64pLSmX99sMc9L5MWFRcHVrb9G6HPWDca5/w2tIflfPSVcnJyyctsySIWTdrmAU3IfejmL34e2Ww7NDGhs1fvSeCpdAkRMAUNKZ0y0hcUiqBIWGc9bsBwEhPd3S0K+7VKx1eA3Du2K7K+4ZHxaksvik/TFoTU2NDADKyc6rsRQbduU9GFXOOfXuUJVnYccyHgsKqU69t3HuCn7YeYNGqP7h8/bbabXycdG7XGmPDkvR+xy8GkJOXX2XZ/acvKbM39XV1qrJcXaVlZjN3+RrlH1UuDvb8vmIBLZuLbD5C0xABU9CY8nsyv/p1h3LVZ1Up88xNy4Y7z10JqrRMTGIK7379i8qCn8JabCvp0r41AHK5gq2HzlR4PSMrh8/Xb6vyeqcOdvRy7gyUpMdbsmYzskoC9oWrt9h57BwAJkYGjK1mRfDjTE9Xh4lD+gGQmZ3LivXbKC6uuOUn4NZdVm3eC4CujjbPTRiq8bYsXfMnSakZAHRuZ8vPn8zF1MhQ4/UIgrrEHKagMY/uyYSSDf1VDZ8N6+vGb7uPIZcrSh4EXFDA8H5uWJqZkJKeie/1EA56+6osCIKq5xsrM3Zgb3Y9fFzVT1sPkpSagZeHK7o62gTdiWDroTPEJ6fRxsaKqLikSu+x+LWZzHh3BVk5eRw55094VBzTRw/Gvk1LMrJzuXD1FruOn1f2tt5/6el/9Bf7q9PGcP7qTSJiEjjofZm7kTFMHzOY9rYtyc7Nw9vvOntOXVTmkv3o1RnYtmhe4T6uT85RHleV0L4qgSFhePtdB0q2jrw4eRQP4iv//ZTX3Ny0QZLBCwKIgCloWPk9mVD93ssu7Vsz95kJyp7KobN+yv115XVuZ8vwfm6s/ms/AGEP4nB16KBWe3o4deTlKaP4ZccRFAoF24+eY/vRcyplnp84DEszE77buLvSe7SxseK3z95h/hfriIpPIvR+NEvWbK5QTldHmwWzJjN2UG+12va4MjY0YN2St3jnq/XcvBtR8n5XV3y/hvp6fPzaM4yqYrtQfew85qM8LpbLef+bDWpd98rTY1S2NQmCJomAKWhURztbnDq0JTjsAdpaUkbXsDfvf0+NwLlze7YdOsON0PukZWWjLZViYWZCx7atGNG/FyP6uZGbX8C6vw9TJJNx1MefScP7q92m12eMp4+rI38fOcvV4HukZ+ZgbmKEi4M9T48ehLtzZzbuPVHtPTrZ2bL7h0/Yf8aX05cDuXM/uqStWlq0btEcDxdHpo4a8NjnhFVXi+YW/LFiAcfOB3D4nB+3wx6QmZ2Dgb4edq1a0N+tK1NHDmyw3K23wx7UXEgQGplEUdUGNOE/Ky/4dFM3QWhApUOlbl07Nfh2li9++Zv9py9xcev3DVpPTer6ng2cvBqqScI/kFj0IwhCg7n3IJbWLSvObwrCP5EImIIgNIhjFwIIuHWXUQMaPsesIDQGMYcpCP9RefkFhNwvSWmno61NhzY2Grt3QWERK3/fxdA+PXhuvOa3nNQkNy9frVW1glAbImAKwn9UcNgDps3/HAAbK0uOrP9MY/fW09VhyzcfKPflNrZbYQ94+ePvmqRu4d9LDMkKgtAgmipYCkJDEatkhQrEKllBKCFWyQrliR6mIAiCIKhBBExBEARBUIMImIIgCIKgBhEwBUEQBEENYluJ8I8yavZHxCWlanwbhFC9mMQUjvr4c/l6CPej40nPykFLKsHCzIQu7dswyL07I/q7YaCv1yjtSc3IorhYjpWleDKJ0HhEwBQEoUqpGVl8t3E3h8/6USxXfS5mESUPC49LSsXb7zprtu7nw5en4eXh2mDtkcvl7D5xgR/+3Mu3778iAqbQqETAFAShUiH3o5i7fI3yIc5WlmaMGdgbly72NLcwQ1ZcTGRMAscvBnDxWjBJqRm889V63vnfJGaOG9IgbTpyzp/la7c0yL0FoSYiYAqCUEFMYgpzlvxAWmY2AJOHe7Jg1mT09XRVyvVw7MDEoX057RvIh9/9RkFhEd/+vov2ti3p17Orxtsle6SXKwiNSSz6EQShgsU/blIGy+ljBrFozowKwbI8Lw9XPnx5GgAKhYIvNvyNrLi4UdoqCI1FBExBEFScD7jJlZt3AGhl3Yz5L0xW67oJQ/rgaN8GgKi4JHyu3GywNgpCUxBDskKTScvM5qD3ZU5dukZ0QhLpWTmYmxjhaN+WCUP6MLRPzzrd9350PPtOX+LqrbtEJySTmZOLrrY2FmbGOHdqxyhPdwa6d0cikVR6fWRMAtuPncPvRijRCcnIZMWYmxjRuZ0tnr26MXFI3yp7W4mp6Ww/cpaLgbeJjEmgoKgIM2Mj2tm2oF+Prkwe6YmpkWGt39PP2w6y7u9Dtb6uLquJdx7zUR7PmjQCHW0tta6TSCS8NHkUAcF36enUkR6OHSotl5Ccxu6TF7hy8w4PYhPJyM5BKpVibmKEg31bhvXpwQjPXmhrldW77/QlFv+4SeU+pcnVxYppobGIgCk0iQtXb/HR97+TnpWjcj45LROfgJv4BNzE082Zr959GYNqhgLLk8vlfLdxN38dPI1crpoiWSYrJje/gJiEFI6dD2CIhytfv/syUqnqIMtRH38W/bARmUx1ODEpLYOktAwuXAtm076TrF3yJm1trFXK+N+8w9uf/0xOXr7K+ZT0TFLSMwm4dZeNe0+w+uPX6da5vVrvqbEVFcnwvRGi/HmQe/daXT+kTw+G9OlR5eub9p3khz/3Vvh8AeILColPTsPb7zo7jvnw0ydvYGigX6v6BaEhiYApNLqAW3eZ+9ka5HIFWlIp4708GPyEK2YmRtyPjuePvceJiEnAJ+Amy3/+i8/e/p9a992w8yib958CoI2NFU+PGkiHNq0wMtAjPjmNi9eCOejti6xYzinfQPaeushTw/orr4+OT2Lx6s3IZMVYmBoz66kROHW0Q1dHh7ikFHafuIDv9dvEJqbw0fe/s/nL95XXZuXk8d7Xv5CTl4+Bvh4vTBxGD8cOGBrok5SawdHz/hw7H0BGdg7vfbOBvauXoKero/ZnNmWEJ4N7u6hdvpSOdu3+i9+PiSe/oBCAtjbWNLfQ3LaNg96XWfnHLgCsLMx4evRAHO3bYmpsSFJqBgHBd9l1zIf8wiICQ8L4bfcx3nhmAlASuLetXMhZvxv8vO0gAJ+89gxOHe1q/R4Foa7EvzShURXJilm65k/kcgXaWlJWLXxNZTWli4M9w/v15IWF33AnIoZDZ/144cnhdLKzrfa+uXn5/Lb7GFAyRLfpi/ewMDVWvt69Cwzv54aHiwMfrPwNgJOXrqkEzENn/SgoLAJg5QevqgwpduvcjmF9ezJvxVq8/W8QdCeC0PvRdGnfGgBvv+vKRTKLXp3BmIFPqLRvcG8XLM1M2HrIm7ikVC5eC65VAGxuYabR4FWV2MQU5XEr62Yau69CoWDNlv0AGBsa8Otn8yv00L08XBnWtyezPvoWuVzByUvXlAHTzMQIMxMjQu9HK8u3sbHGoX0bjbVREGoiFv0Ijco/KJQHcYkATBs9uNKtB4YG+rz17JPKny9eC67xvvcexNLKyhJ9PV2eGeelEizLG97PTdkjiU9KVXktOS1DedzWxqrCtRKJhJemjGLqyAHMf2ESxob6al8LMHP8UCYN789bz06kdcvmNb6nppCTV6A8Njc10th9Y5NSMTY0wNhQn/FeHhWCZSlXhw7YWpd8No/+fgShqYkeptCovP2uK48nDOlTZbk+ro5s+3YhbW2s1JrH6t7Fnt0/LgZK5jKrIpVKsTQzISEljYKiIpXX2rduqTx+58v1LJg1GedO7VTKOHdqV+Hco9cuXr2ZD16aSi/nzipzpLbWzfh4zjM1vpempCUtWwhVVCTT2H1trZux4/tFQPW/H4DmFqZExSdRoMH6BUETRMAUGlVkbAIAujradGhjU2U5qVSKg33dhttKg1RWTh4xCclEJyRxPzqBOxHRBN4OI+lhb/DRhUFjB3uwce9JElLSCAwJY+Z7X2JlaYaHiyMe3R3wcHWkmblppXV6unWjS/vWhN6PJjwqjtmLV2FuYsQT3R3o3d2BPq6O9RriTE7LIDk9s9bX6WhX/zk/ytSkrFeZnplTTcm6K/393O0czQAAIABJREFU5OblE5OYQnR8MpGxCdyNjCEwJIyYhJJhYfFse+FxIwKm0KhS0rMAMDM2qrBCVRNuhz1gy6Ez+AbeVgbGR0kkkkq/jE2NDFn/6dss/nETgSFhACSlZnDgjC8HzvgikUhw7mTH2EEePDW0Hzo6Zf99tLSkrPn4DZb9/Bdn/YMASM/K4fiFAI5fCACgk50tozzdmTZ6YK1Xf+445tMo20rsWrVQHiekpNW6vpo8iEvkz/2n8Am4SVwVQ65SqaTCHzOC8DgQAVNoVA2Z/eX33cf44c99KsHQ3MSIdrYt6dDWhq4d7ejt4shLi1ZW+WVt18qaP1Ys4ObdCE77BnL+6i3uRsagUChQKBQE3Ykg6E4Eu477sG7p2ypzpc0tzFi18DXCouI4dekaPgFBBN97oExafjcyhruRMWw/epZfPp1HmyrmOpuSrXUzrCzMSErLIDohmfjkVFo2t1T7+uzcPL75bSe9nDvTy7mTyrWHzvqxZPVmimRlQ63Ghga0s22BfRsbnDq0xb1bFz5ft5WAW3c1+r4EQRNEwBQalalxyZBfZk4ucrlcY73MS4G3WbV5LwCWZia8PmM8nr2csbY0r1A2L7+gwrlHlc5VvvnsRNIys/EPCuXC1VucvHSNnLx87kTEsGrTHpa88WyFazu0saFDGxtmTx1Ndm4eAbfucvFaMMcvBJCWmU18chrLfv6L9Z++rfb7mzNtLHOmjVW7fH30d3Nmz8kLAFy4Gsyk4f1ruKLMhWvB7D11kb2nLuLh4sjaJW8CEBYVpwyWBvp6vDZtLF4erti2qLj4SZ3fjyA0BbFKVmhUpfNpBYVF3I9JqLbshNcXM3XecuXevepsO3xGefzlOy8yaXj/SoNlTl4+mTm5ld6jsKiIew9iuR32QOW8hakxw/u5sXTuc2z55kNllp9zV4KUZWTFxUTExCuHcksZGxow0L07H86exq5VH2PdrKRNfkGh5D3c7/i4mTikr/L47yPeNS7SKW/rwbLfw6gB7srjncfOKXuW7780lWcnDK00WCoUCuKTNT8ULAiaIAKm0Kg8XB2Vx4fOXq6y3K17kUTGJnInIkZlCK8qkbGJyuOuHe2qLHfknL9yfuzR5zuOmr2IyW8tY8HX66u83q6VtXJLRGG5Vbb/W/gNE99YyqtLflBu/H+UpbkpTh3K2lb0yCrdx4WLgz0eLiW/pzsRMazbflit63YcPaf8g6GVdTNGDyjbi1r+9+Ncze/nUuBtUjOylD8/OoQvrSKdoSA0BhEwhUbl1duVls0tAPhz/ymu3Q6rUKawqIjPHj7zUCKR8OTQfjXe9//svXd4HNW9uP/ObJdW1UXFTS5yw72BGwZMsXEoAQIGkkAg5Ca595eQJwVIQgoJyQ3kBm5IArl8Q0gjgKkGY8ANMDbuDXfJtmTLsmT1rbNTf3+MtNq1VtKuLckymvd59Dyj2XPmnJndmc986snOaPUlxmp+sWzZczBOWz0zbeLSGRMAOFldx4vvfJDwGGYUbCUQL5gvnTERACki86d/v5Wwb3VtAzv3lwIwJH9A1DzdG/nx12+P5pn++aUVPPn31+NeEM7kpZUf8t/PvgSYQTs/+eadcTVo47+fxEXZDx2r4Kd/iK8Xe+Z35IwJtAqHLdOtRc9i+9nPfvaz8z0Ji96FWnOs245tE0VGFw1ixUdbUDWdlR9todEfxCaK1DT42LBzHz968nlKj5tC6c7rruD6y1vzNf/11loCoTAZ6Z64RYrDkQgbduwDTD+aFImg6Qb1jX52Hijlzy+9w1P/ehM55gGsaTr3fWFxtAj7yCGFvLFmI6qqsXHXfo6cOIVhGATDEkdOnOLtDzfzq//7N+GIjCgK/PQ/v8Sg5lSR4mGFvP3BZkJShN2HjrL70FFEUSAYlig7Wc2aTbv4+Z/+GdWefnDvrYwuGtxt1/lcyfSmM3HMCFZt3IGqaew6eIQ3135Cgy+ArKgEQmHKK0+zbvMufv1/L/L66o0YhoEoCjx031KumTcj7nh2u413128DYPu+w9Q3mVWRmgJBPj18jOffWMXjf3kZfzAc1++2axeQHhNR3OgLsHzdJsBMtRlWmEd1bUP0JayrcQzonTV/Lc4PgmElO1mcQXj/2m4f44Mtu/nRk8+3KVQeyxeumc9DX1saFxi0+Gs/4lRNfZt0CVXT+O5v/hxN6WiPK2dPxeN28VbzQ/fNP/6cYYWtVWc27NjHA//z/wiE2p+X2+Xkh19byvVXxBdeOHDkOP/fo3+ktqH9fEm7TeQbt1/HvTcv6nCevYXS45X89Km/s6+0vNO2BQNy+fHX72h34ehH//xvlr37UYfHmH5RMReNGsbf31wNwNM//RazY8z44YjM9d/4SVzKkCgKbHjhyaSL9KeCZ/wVXX5MiwsXS8O0aEN3apgtFA3K5/NXzsXldBCWIoQjMrph0D8ni7nTLuKhry1l6bWXtVmCqz0NUxRFrpk7nYKB/QiEJAKhMKqq4XE5GZw3gLnTxvP9e27hKzddg91mY+X6rYAZ0DNjwujocYYWDOS6y2fjdjmQFRVJltE0jYz0NEYMzueGK+bwi299mekXjeZMBuRmceOVc8lMT0NRVaSIjKqqpHncDMkfwLULZvHTb36RhZe0v5pHbyM3K4Obr57HlHEj8bhdYBjIioqmaTidDgb2y+biSeO495ZF/Ojrt8dVPDqTS2dMZHTRYAJhiUAwjKKouJwOCgbkMmviGP7rizfwrS/ewMB+ObzcLFjtNjGu5q7DbmPutIuoPF1Hoz+AYRgMyM1mwcxJ7ZZDPBcsDdMiFkvDtGhDT2iYFhYXApaGaRGLFfRjYWFhYWGRBJbAtLCwsLCwSAJLYFpYWFhYWCSBJTAtLCwsLCySwBKYFhYWFhYWSWAJTAsLCwsLiySwBKaFhYWFhUUSWALTwsLCwsIiCSyBaWFhYWFhkQSWwLSwsLCwsEgCS2BaWFhYWFgkgSUwLSwsLCwsksASmBYWFhYWFklgCUwLCwsLC4sksJb3sojD0DUE0Xa+p2Fh0Suw7geLWCyBaWFhYWFhkQTdYpI11Eh3HNbC4oKkJ++HiGq9/1pYtNDV90O3aZiVj8zpjsNaWFxwFP5kY4+ON+e5yh4dz8Kit7LxnsIuPZ4V9GNhYWFhYZEElsC0sLCwsLBIAktgWlhYWFhYJIElMC0sLCwsLJLAEpgWFhYWFhZJYAlMCwsLCwuLJLAEpoWFhYWFRRJYAtPCwsLCwiIJ7Od7AhcKVQGN299sBOCaES4enO3t0uPvqlb4zmofAHdN9HD3pLQuPX53UOHTWHYwzPYqhdNBHbddoMArctlQFzeOduNxCOc8RkDWefWgxMcVMhV+DQwYkC5ycaGTm8a4KfBadT77AlpTFY3P3A6Aa8I1eJc82KXHV47vwvfv7wDgmXsXafPu7tLjdwdafQXhrctQyrej+04jONyI2QW4xl6Ge+qNCE7POY+hSwGkba8il3yM1lABgJgxAOeIi3FPvwlbdsE5j3EhYQlMi7Ni9bEIj28OIGut+xTZwF+vcbg+xNulEr+6LINhWWf/EzvaoPLAOj+1YT1u/wmfzgmfxDulEX4wO50FQ11nPYaFxYVIZP9qAisfB1WO7jM0Ba3KT6jqMNKut8m4+VfY+w876zHUmqP4X34APVAbt1+vP4FUf4LInndIv/YHuMYsOOsxLjQsgWmRMruqFX79SQDdAK9T4I7xHiYOtBNWDdaUybx3NEJlQOehD/w8syiLTFfqlv9GSeeBdT5qwwaiANcXu5g/xIVDhO1VCi/tDxNSDR7dEGBAmsj4/o5uOFMLi96HcnwXgbd/DYaO4PLimX0H9kETMZQw8v41RPa+h95Yif+Vh8i66xlET2bKY+ihRnwvP4ARqAVBxDX1elyj54PNgVK2nfCWlzDkEIG3HkX0DsAxaHw3nGnvw6ola5ESmm5wz4omjvs00uwCf1yUSdEZWuTyEokntgQBuGWsm/+cnp7yOL/dFGDFEbNo+Q/neLlqeLwWeahO5f7VTUgqFOfa+POiLATh3E3A3YFVS9aiqzB0jaa/3INWfxzBmUbml/6IvX9RXBtp13KC7z0BgHvGLaQv/M+Uxwms/C2RPSsA8H7uh7guuiruc7XqEE0v3A+KhC2vmKy7/twr7z+rlqzFeWVTpcJxn2mHvXWcu42wBLi+2M20fFPjW14iEVT0Nm06olHSef+YKSyn5NnbCEuAMf3s3DHe9NGU1Gtsr1JSGsPC4kJEObIJrf44AO6Zt7YRlgDuKdfjGDYNMIWnHgmmNIYeaiSy730A7EOntBGWAPb8MXguuQMArboEpWx7SmNcqFgC0yIlPjzeulTVNSPa9x0uGWl+JmuwsSI1YbbxpEyLjO1wjFHu6PYH5XK77SwsPitEDn0Y3XZNvKbddq5JS8wNVUYpTc3CIZduBM28Z10T2h/D3TIGIB/8IKUxLlT6nA+zrEnllQMSO6oVakM6HodAcY6d64pdLBjq4nebA7xVGiEvXeTFG3Oi/TqKko2NcP3jNZmMybXzVmmENWURjvs0JNWgv0dkRoGDW8d5GJTRNrLzXKJkY+eWKk9cmcmUvOT9f3trVAAKvCL5HUSoTo455o4qJaGW2B6fnlaj21M7mFuuR2RIhsgJv25pmBcIam0Z0tZXUMp3oAdqEZwe7AOLcU29DteYBQTe+x2RXW8hZuaR840Xo/06ipKNjXDN/OIfsReMIbLrLSL716DVH8dQJERvfxzDZ+CZeSu2nEFt5nUuUbKxc0uVzNufwDF0StLt1Yq9AIhZBdiy8ttt5xg6ObqtlO1IqCW2P8anrccZNrXddqI3FzF3CHr9CZTyvqFh9imBuepYhMc2BVBjLIRKxGB7lcL2KoUri2RctnOzwzdFDL75XhOH67W4/ZUBneUlEVYeifCTeRnMG+I8p3HOB5JqUBUwL97gBEI/ln4eEbcNJM18SUmF8ibz2jltMDCtYyNIYYaNE36dqqBOWDXw2HufH8XCJLJvFYF3HgO99fdghBWU8u0o5duRx1+JYD+3iGdDaqLpH99Eqzoct19vrCSyczmRPSvJuOEnOIvnndM45wNDkdCbqgCw5Q7usK3o7QcONygSal1ZSuNoteXmht2JmDGww7a27EL0+hPoTVUYcrhLUll6M31GYH58QubXGwMYgNsGN4/1MLPAgSCYUZfLDoRZXSbjOEcj9W83BaiXDKbm2fncKDcFXpHasM4bhyPsqFJQdPjNpgBT8rLxOrvGIt7PI/Ls4qyz6ptI222PurBOS4RYXnrncx+QZmp/NaHUfJgt7fPSxE4DCQbECNTakM6QTCsvszcil3xsRnZigMONZ8bNOIbPBAQz6nLbMuT9q8F2btHOgZW/xQjWYx86FffkzyFmF6AHaonseAOlfAdoCoEVvyH761MQ3V2TSy16+5F197Nn1TeRttseeqAOmu9AMTOv83llDDCFmb8mpTm1tBcz8zq9/8SMATHzq8WWOySlsS40+oTAjKgGf9gexADS7AJPXpVJcW7rqU8a6OCyoU7uX+3DFzm3oOF6yeDWcW6+MS0+MnTeYCcPfeBnc6VCQDb4uEJm0Qh3O0dJDYdNYFRu93+Vvkir4EtLoiiBu7lNQE7tmvplc5xkCh/EapQBWQcsgdnbMJQIwdV/AAwzsvOOJ7HnFUc/dwyZhHPsZfj+fT9G2HduYwXrcc+8lfQrvhG331k8D/8rD6Ec3YwRCSCXfIx74qJzGqsFwebAnjeqS47VEXrMtRGcnbtsBIf5fDGkQGrjSP7mMTrXFmPb6FLgM3/39Ymgn49OyFQHzYfwVyZ74oRlC8Oz7XxzWurpD2eS5RK4d3LbH7MgCHwuJkjlSIPWpk1vJzbY1Sl2LsxazNspBslG2zuTMI/HmtBTHceiZ5APf4TuqwbAM+8rccKyBfuA4aRf8c1zHkvwZJF26b1t9wsC7smfi/6vnT5yzmP1OFqrn16wd+7SiZq3tRT9+83tBVsKY5zNOBcgfUJgbqgwIyhFARZ1EHW5sMhJ+jmWc5uS52j3QV/obb3cYaVb0l+7lVgZmUzKVUuGb6pXtGWcZPrFXkXLe9k7kUs2mBuCiKsDrc45biGC69xeWh1Dp7QrTMSc1pw8Qw6f0zjnBSH2cZ3C3ZFqfmTLOEn1i7kDe2EeZlfTJ0yyRxrMIINBXrFDv6FdFCjOtbGrOrUglVjyO/DtxZoYtS6Ul4pmRANlUmVQhi3pmq+x5s9IEicg62YbR4p2Go9dwC8byY0R0yYZjdSi51GbtTkxZ1CHfkPBZseWV4x6fNdZjyV2EDkqOGJMjHrXWXgMTWkNlEkRW86gpANlYtsZaqSDli1tmlOtUvQLC04PhuRPbQyS00gvdPqEwKwPmw/VZEq05bjPTel2dxClGftJV+qXdWGd+1Y2nVXfVNJKYv2Wktr5GUjNWnRmisFNac0CU0rivSUcM48MpyUweyNGsB4gqRJtYlpOp206osVvl/jD7rkD9UAdTc/fd1Z9U0krifVbGorUafuWNqI7tdJ4gjMNQ/KDnMQYMZq64MlIaZwLkT5hklWaNZ0Lzwjau+jvEWlR4k4HO3cYtkS79u8kNeRM8ppN16dDnWsBLWMImNHCFr0Po8W31T1VOPsMYkZ/EE1zje4/3Wn7aLRrRv/UxskyI3C1FMYAATG9X0rjXIj0CQ0zy2WmdjRKnT/kzzVK9nyQ77Wx7s7u/7E6bAKDM2yU+zROBjoWZnVhHam5SVFWajbZoiwbe06rSCrUh3VyOxCElX5zkAKviMvKweyViJ4s9EAteqjz4hrnGiV7PrBl5dPvgXXdPo5gc2DLGYxWV47WcLLDtnqgDpo1TFuC8nkdYetfhHpiDygSeqAe0Zvbblut0axbLGYXIDg++6sG9YlX8tG55gP7VEBvTj1IjG4YlDScvf+yLzB+gPmOdcKnUx9u/1rurm6NmJs4MLX3sotiVh7ZVd1+5F1dWOeE35zDpIHWaiW9FVv+aAD0xlPoHaQ4GIaOerqkp6Z1QWIvNFcF0etPoAfq222nHN/d2mfwxJTGcBRe1HqcE+37k/VAHXr9CbPP4EkpjXGh0icE5pzBpjPaAFYda7/m6MYK5YLUMHuSy4a2OvbfOdK+j+PtUvMzhwizC1MLBpgz2BEtILHySPuBBytKW8effwFWTuorOEe1rFxkIO9f1W47pXTjBalh9iTOsZdFt6VP32m3nbTnbXPD5sA5cnZKYziK50QDhSJ7VrY/xu4VrfMaMz+lMS5U+oTAXFjkItdtmuv+uifEsca2WmR1UOOpbalV9e+LTM93MLS5ms4L+8Icqmt7LZeXSOxsjjS+eoSLrBQDqbxOkauba89uq1JYXtJWMB+qU3lxvxlwMDTTxsWFlobZW3GNX4iQbpr1Quv/ilpzrE0bzVdNcNVTPT21Cw5H0XRsuUMBCG96AbXqUJs20q7lqOU7AXBNuBoxLbUqYKLLi+uiqwFQyrYh7Vrepo1adYjwFrPWry13KI4RF6c0xoVKn/Bhuu0C989K56cfBfDLBv/1no+bx7qZnu9AFMyC4i8eCMdpl5Y3LDE2UeD+mel8b62PsAr3r2pi6XgP0/IdRDRzAel3j5paYX+PwFcTFHEAWPpGQ7SYxL9vyG5TyP2+KWlsqJBpjBg8sSXIgVqVhUVOXDaBHdUKL+4LI2lmzuZ3ZqVjS6KQgsX5QXC4Sb/6fgKv/xRD8uP753/hnnEzjqLpIIioFXsJb3kxXrvsAzl9Z4Mg2ki/+n58L30P5DBNL9yPZ9ZSHEXTMJRI8wLS75ptvf1Ju/SrCY/T8PTSaDGJ7K//u00h97QF9yGXbsAINRJ87wnUkwdwjl+I4HChlO8gvPlF00cqiKRf8x0E8bNe48ekTwhMgPlDXHx7plkiL6Qa/GNvmH/sjU9evnG0i62nFE769ZRzB/sSU/MdPHCJl99uDiBp8PynYZ7/NP5a9veI/PflGWSfZZpOllvk8YWZPLjOR13Y4N2jkaggbsFpg+9f7E1ptRWL84Nr9HyMq79NcPUfMOQQ4Y3/ILzxH/Ftpt2IcmwresPJc64p+1nGMWwq3msfIPDub0GRCG94nvCG5+PaiN7+ZHzhvxHTss9qDDEti8zbHse37EGMQB2Rve9GBXEUuxPv4u+ntNrKhU6fEZgAN4x2M2mgnVcPmst71YV1XDaBsf3sfH6Mm9mDnCx9owHAWvWiE64e4eKiAXaWHQizrUqhJqQjAoMybcwb7OSWse5zLi4/KsfO367L5tWDEh+fkDnp11F0gwFpItPyzaXSrGLrFw7uqTdgHzwJadur5vJewToEuwt7wVjc0z+Pc+RsGp5eCiRXx7Qv45pwNfZBFxHeugylbJuZ3iGI2HIG4Syeh3vGLedcXN4+cBTZX/0b0rZXkUs+Rm84iaEpiBkDcAybhmfWrZ/5YutnIhhG9yRHVT4yp/NGvZAlL9UTUg3mDHbw6ILUEn4tLBJR+JPUFvA9V+Y8V9mj43Ul9U8swZBDOEbNIfPmR8/3dCwucDbeU9h5oxToExrmqmMRPj4hU5ghcts4T7tmwkN1KqHmyjEjs/vEpbGw6HYi+1YhH/4YMacQz6zb2jUTqqcOYcghAOwDR/bkFC0skqJPSAWXzVyxBMyya1+a2DYQRWpeAgzMgJ9LrTQFC4uuwe5CPvwRYJZdS5vzpTZNDEUiuOYPzf8JOEdf2oMTtLBIjj4hMC8udJKXJlId0nn+0zDlPo35Q5wMSBMJKwbHmjSWH5aiSfA3jXH3yPqSFhZ9AeeIixEz89B91YQ/fh6trhzn6PmI3gEYShit5hjSruXRJHj39Jt6ZH1JC4tU6RNSwWUX+MWCDH74gZ/asM6aMpk1ZYkLGNw8xs3Xp3W+OKuFhUVyCA4XGTf9Av8rP0QP1CLvX4O8f03Ctu7pN5N2+dd7eIYWFsnRJwQmQHGunb9fn82KUomNFTLHGjX8skGaQ6C/R2Rynp1FI9yM6ddnLomFRY9hzysm+76/I+1egVy6Ea32GIbkR3CmIXr7Yx86GffERdjzx5zvqVpYtEufkg4eu8AtYz3cMtYKWbew6GkEpwfPzFvwzLzlfE/FwuKs6BOl8SwsLCwsLM4VS2BaWFhYWFgkgSUwLSwsLCwsksASmBYWFhYWFknQp4J+Pos8vyfE35oLnz9xZaZViLwTZM1g5ZEI68ojHG3UkFSDfh6R8f3tLB7pYkaBVbDCIjlCHz9PeMPfAMi8/Yk+VYT8bDBUmcje95APr0c9XYoR9iM4XIjZhTiGz8Qz7fOIGf3P9zQ7xBKYFn2GqoDGDz/wc6xJi98f1KkKyqwtl1kw1MmDs724reL7FhZdhlpbTuD1n6DVH4/bb0RUtOoStOoSpO2v4b32QVxjF5ynWXaOJTAt+gRh1eB7a32cbK7mND3fwbUjXQxMF6n067xyKExJvcaHx2UMI8DPL804zzO2sPhsoIca8b/0PfRALQCOkZfgmnANYmYehuRHObIJaddboEgElj+C4H4MZ9H08zzrxFgC06JP8OL+cFRY3jjaxbdnti59NGEALCxy8uA6P9uqFD46IbOrWrHM2xYWXUDo479GhaVn3t2kzb0r7nPniFk4i+fiW/Yg6CrB936H476/98pFqa2gH4s+wYpSCYAsl8A3pqW3+dwmCtw3tbUk4rrySJs2FhYWqWGoMvI+swyirf9wPHO+nLCdo2g67inXAaA3VqJWfNpjc0wFS2BafOYJKjrT8h2MyrExd7ATpy2xf3JYzGLU1UG9p6ZnYfGZRT1diiGbq0A5i+chCO3HBjiGz4jr1xvp1SbZEz6N5SUSO6oUKgMamg6ZLoGR2XYuGeTg2pFuXB0EZ9SENFaURthVrVDh1/BFDGwCZLpEinNtLBjq4ophTmxi22MsfaOB6qAeNd/trFJ4/bDE/loFv2yQ6xaZUeDgjos8FHjNB219WOflA2E2VMhUB3XcdoGx/ezcNs7N9ATRl7ERruvu7Ed1UOOFfWE2VyrUh3U8DoGxuXY+V+xi/hDXOV3LXdUK7xyR+PS0Sr2k4xAF8tLNc/j8aDf53vbNH/6IzlulET45KVPWZEaWeh0ChRk2puc7uGG0m36e1N+93j0i8ZtNwbM6n3V39ku6bbpD5IdzOvdJVgVbg4Fyz+J8Pkto9SeQdi5HKd+B1lgJuobgycQ+YCSOkZfgnnQtgqP936TmqyGyZwXK8V1oDRUYYR+INkR3Jrb8YlxjFuAcd0VCs1vD00vRfdW4pt2I96pvo5TvRNrxOkrlfgzJj5iei6NoBp5L7sCWXQCAHqwnvOVl5JIN6L5qBIcbe8FY3LNuS+gPi41w7ffAOjRfNeFPXkA5uhk9WI/g9GDPH4tryudwjZ5/TtdSOb4Lac87qBWfmscWHYhZeTiKZuCe/nlsWfnt9tUlP5FdbyGXfoJWW4ahSAhuL7bsQhzDpuOedgOiN/l7oQXp03cJvvObszqffg+sS7qt6MnCM/du9EAt9iETO25sGK3bqnJWc+tueq3AXFsW4defBFDPeNGvCxvUhRW2nFJ4+YDEbxdmMiij7U338oEwz+4KtemvAFJI53RIZ0OFwvISO49dnonH0b7gfXpHkJcPSHH7qoI6b5dG+OiEzJNXZhJWDX78oZ8GqfVLV2SDracUtp1S+N4l6Vw70t3uGIfqVH6wzocvEtM/YrDllHmuVxbJPDDbiz2BcO8IWTP4zScB1pbLbfYfbdQ42qjx+iGJb05P58bRbed3rFHl+2t91IWNuP2NEYPGiMr+WpWXD4R5eF4GcwdfuCkZmm7wl93h6P8Lh12453KuRPavJbDi16CrcfuNQB1KoA7l2BakrS+TedtvseUMatM/vOVlQh8+26Y/moKuSOj+0yglG7DvXE7mrY8hONuv7Rxc+zTS1pfj9ulNVUR2v418+CMyb38SQwnjf+3YCK2FAAAgAElEQVTHGMGG1rlqCsqxrSjHtpG++Hu4J13b7hjqqUP4lv3AFOot/cMKyrEtKMe2II+/Eu+1DyDYUntcGqpM4J3fIB9YG78fGa3mKFrNUaQdr5N+xTdxT7ux7bxqjuF7+fsYgbr4/qFG1FAjauV+wltfJuP6h3EWz01pbj2FLWcQafPu6rwh5otFC2LmwO6a0jnRKwVmpV/jN5tMYZntErj9Ig9jcu04baapbEVphG1VClVBnUc3BPjToqy4/u8fjfD0DnPl9n4egRtHuxmda8frFKgL6+w5rfJWiUREg701Ki/sC3PvlMRLen1QLtMYMchLF7l1nJviHDv1ks5L+yUO1Kn4IgaPbQpQFdAJqwZ3jHczs9CJKMD6EzKvHpQwgD9uC7FgqJN0R2LN5UcfmsJyZoGD64vd5HoESus1Xtgfpjqos7pMxiYGeXC2N2H/ROiGwcMf+tlyynxbmzTAzuJRLoZm2lA02F+r8vphiZqQzv9uNTW9WKGpGwY/Wx+gLmxq5jePdTOjwEGmU6Re0vmkQmbFkQgRDR7d4OdfN+SQ405eM5sz2Mmzi8/fT1DTDWpCOp/WmEK/tMHUMK8d6UpoEegLaI2VBFb+BnQVIS0bz8W3Yy8YAzYnuq+ayO4VKGXb0JuqCLz1KFlf/lNc/8je9wmtexoAwdsP97QbseeNRnB70QN1qCf2mBGRagT15F7Cm14g7dJ7E85FPvgBRqgRMTMP96xbsecVowfrkTa/hHrqAEbYR2DlY+hNVRhyGPcld+AcPhMEEfnweqRtrwIGoTV/xDlmAaKrre8awPfajzDCPhzDZ+Kecj1Cei7a6VLCm15A91Uj719NULThXfJg0tfRMHT8rz2McmwLAPbBk3BNWoyt31DQFNTK/UjbX0f31xBc9b8AcULTMHQCb/zMFJaiDff0m3EMn4HozkQP1SOXfkJk9wpQI/jffpScr/0LMT0n6fk5R83BfvezSbfvbvRAPZE9K81/BBGHFSWbPKvKIsjN1rFHLs1g4sDWaMVx/WHBUCc//sjPxgqFA3UqpQ0qo3LMUzEMg+d2m8Iy3SHwv1dltdFA5w9xsWCok2+v8qEb8OGJSLsCszFiMCRD5Kmrs8iKEQazCp0sfb0Bn2xwsE7DLsLvFmbGzXXSQAc2AV46IBFSDXZWqcwbkvhBXBc2WDrezX9Mbb2px/d3cPkwJ/ev9nG0UeO9oxGuHeli0sDkojffPCxFheWXJni4Z3L8OU7Oc/C5US6+u9ZHSb3Gn7YHmTvYwYA083p9elrluM/8Iu6e5OGLE+L7zx7kZHCmjad3hAirsKYsktJKMJkukUzX+TN93vBKA0GlVXN2iHDv5DRuGdu+JeCzTmTfKlBNa0TG5x/BMTjGjFY4DueYBfhf+zFK6UbUUwdQT5diH2gu9mwYBqH1zwEguNLJuuN/22igrtHzcY5ZgO+Fb4OhEzn0YbsC0wg1IuYOIevOpxDTWl+KncNn0fD0UgzJh3bqIIh2Mm//XdxcHUMmgWhD2vIShhxCPb4TZ/G8xOME6nBfvJT0y/6jtf+g8TjHXY7vhfvRao4S2fserknXmsdNAmnHm1Fh6ZnzJdLm3xP3uWPIZFyTP4fvxe+iVZcQXPsnHMVzsWUMAECt+DSas+iZezdpc74Y1985cja2nMHmy4kcJnJgDZ4Zya8CI3oyET2ZSbfvTgxDJ7Dysaiv03XRVYhp2ed5VonplY6a+nCrHTWRuVUQBL40IY0bil18Y1oa6THm1OqgTrpTIN0hsGiEK2F/gAkDHOSnm6d/upMAj3smp8UJSzCXCru4sFVwLSxyxQnLFubEmCkrA1qbz1sY28/GfQmEdoZLjNMq3zwstWmTCN0weGm/2XZkjo2vTEosyDJcIt+dZR5f0eHNw63RoXUx30NhOz7O64rdLBnp4t7JHsZeQGuJBhU9TliCef5ryyN8eDzx4uJ9AT1QH91OZG4VBIG0OV/CNfUG0i7/BoKz9QVP91UjuNIRnOm4JixK2B/AMXgCYrPfTved7nA+afPviROWYC4T5hh5cfR/1/iF8YK9GeeoOdFtraGy3TFsBWNJW3Bfm/2iOyNOq5R2vtnhXFswDB1py0vmsQeOxDPvKwnbie4MvIu+2zxBhUjM8fUYM6wtpzBhf/eU63BNWoJn/r3Y88cmNbfeSHD1UyhHNwMgpGWTdulXz/OM2qdXPuGGxkQr/nS9n/+cnt7mYTy2n52x/dqaJ/O9Nv6yxHw70Q2jzeex9POIVAb0qDbbHjMLE2t0A9Jahei0dnL2smMEbVhpfz43jHYjthNBVpxrZ1SOjdIGjc2VCppuJAxUiuVoo0Z1SI/OraPotDH97OS4BRokgx1Vrc72YVmt38PTO0I4bQKXDHLE+VE9doHvXZK8mbi3oOvw8FwvBV6RkGL6mt8skThcr/GLDQEq/BpfnpjY6vBZxtZvaHTb//pPSV/4n9gL4h/G9oKxeAvaPqBtWflk3/MXwBQaHSF6+6E3Vka12fZwDJ+ZuH+zJgbgGDYtcZsYLcWQwwnbALin3oAgJNYd7HnF2AaOQjtdinJ0M4audZofqNUcRfdVR+fW0b1nzx+DkJaDEWpAKdsBl5r7bf2GRduE1j6NYHPiGHlJnB9VcHrwLv5eh3PpzRiGQWjNU0R2vGHuEG1kXPfjXl0er1cKzGtGuHjpgOlb21uj8o13m+jvEZhe4GR6voPp+Y6kohhbBFBYMTgV0KgM6FT4NY42qOytVTkVMG/qjsRqplNo1+/oiElP6OdJfFM4Y7p2NM7EAR2bWcfk2ilt0AgqBrVhnbz0jm/akvrWgItlByWWHUxOM43Vgkfm2Jk9yMEnJxVqwzoPf+QnzS4wJd/O9HwHMwqccS83qeKL6J1q9+0xKvfcfroZLpErilqjPKcXOLl6uItvr/YRkA3+uifM1DxHQqvBZxnXhGuQtryE7q9BPbmXpr9/A8HbH2fRdBzNf2J6bqfHaRFAhhxGazqF3liJVl+BWnMUtWIvetOp5pbt3xWCO7Ndv6Nga/1ehPaiRO2x7o/2x0mkncYdJn8M2ulSjEgQPVCLLTOvw/ZqVUl0W9q6DGnrsg7bt6A1tmrB9oEjcYycjXLkE/RALf7XH0ZwpmEfOgVH0XScRTPiXm5SRQ/7OtXu28OeN+qsx23B0BQCKx9H3rfK3CGIeJf8sNf6LlvolQLT6xT53cJMfrMpwN4a88FfGzZ472iE945GEDA1zKtHuFgy0hUnuFo46ddYdiDMpkql3Zw6UQC9YyUUT5I1RTvT+DqjfycvALEm4fokBGZTpJMTawe/HN/v4bkZ/H5bkPeORjCAkGqwsUJhY4UChCj0ilw+zMUtY91x2nQybKyQeyStJFlG5Ni5d3JaNADq7dJInxOYottL5tLfEXjnN6gn9wJgBGqJ7H2PyN73AAF7wVhcE67GNXlJnOBqQWs4SXjrMpQjm6KaVhsEETrRQjuKno0/1LlVhBG9HWs0sSZhPVDfqcA0wk1nNQ9D8sf9n3H9wwRX/b75uhsYcgildCNK6UZCgJhdiGvc5bhn3JKyz08u3dgjaSWJ0MM+/K//BPXEbnOHzYH3cz/ENfayczpuT9ArBSbA4EwbT12dxcE6lfXHI2w+pXC0QcPAfFc8UKdyoM6Mdv3dwsw4gbLqWITHNwVQYu7HdIfAkEwbRVk2RufamZpv58ktQXafVtuMHUcP1eC2dSJrYs3LjiSEsxZz7l+bksbMgrN78HscAg/M9nLXRA8fHpfZVCmzr0aNXtvKgM6/9oV5s0TiscszGNf/whYw84c4owKztKGT38ZnFFvuYLK++BTqqYNEDq9HOboZ7fRRaL771FMHUE8dQNr1FplLfxcnUCL7VhFY+ThoraZ9wZWOLXcItn5F2AtGYx86leD7T7Y+MM83nQjcWPNyoheENuitVpq0y76GoyixWbkzBKcH75IH8My7C/ngh8hHN6Ge3Be9tnpjJeFP/oW0400ybn0MR+G4sxqnJ9EaTuJ75SH0+hMACM40vDf+HGdM0YLeTK8VmC2Yvko7902FJklnZ7XC5kqFj47LhFQzl/DPu0L8oNmPVtakRoWl2w5fmZTG/CHOaHGBWMLq2Wlh3YEvYpDbjlkXoDEmv7NfWueaXIar9ViCcO4mzHyvjdvGe7htvAdJNdhXo7D1lMK6cpnTIZ2AbPCrjQH+dl12u77YM1k00s2iDnJTuwpFMzgV0KkMaIzMsUWjgBOR6Wyd+5k5vH0Ne8FY03+54D70UBPK8Z0oRzcjH/oIQw6h1Rwl9MGf8V77AwDU2rJWYelwkzbvKzhHz48WF4jFUNr3KfY0huRD6MDMbAQbo9vJFAkQPLFFMoRzNmHasvLxXHwbnotvw1AklJP7UI5tRT6wDt1/GiMSIPD2r8i+72/t+mLPxD1xEe6Ji85pXqmiVpfge/kBjJCZLyt4+5F5y6+x5xX36DzOhV4ZJStrBscaVQ7Xx7/hZ7lFLhvm4oHZXv68OAt383Nv08nWwIHlJZGo9vOtGencOs6TUFgahpmD11voTJs5WGd+3t8jkO3qXCCNyG49551VHVfN0A2Df3wa4u1Sid3VStz+Sr/Wpr/bbvqTvz4tnb9dl83IHHOsCr/OCV8nEVTngfUnZO56u5GHPvCz6ljHQSaxPtwBSbyYfNYwVBm15hhq1eG4/WJaFq6xl+G99gGy7vozOMwXHfnIpmibyK7lUe0n/cpv4Zl1a2JhaRjovppuPIvUUKs7LsOmVh0EQPD2R0jC9GnrPyK6rZTv7LCtYeiENv4DadfbKDEat2HoaI2VbfoLDjfOoumkX/51su/7G7aBIwHQGyrQ6k50OrfzhVpdiu/F70aFpa1/EVlf+tMFJSyhl2qYS99ooEEyKPCKvHBD4mTcwZk2BmXaONKgxUW5VsQ8sDtKc9h6SomrypNM5Gl38t7RCLMKE+do7q9VKGtew3H+EFeHUXctjO1nJ9Mp4JMNtlUplDWpFGUlvh7rT8g8tyfcfHwnk5sjfn+5IcC65gpB/74hO2H5PLddYMpAB0eak/47izg+H0wcaI/6q989KnHbOHe73/WK0ta0mrM1Y1/INDyzFCPYgJhVQM7XX0jYxpY7GFvOILTTR+KiXLX6iuj2mZG1sSjHtkYfnEBSkafdSWTvezhHzEr4mXJyP1ptGWDmkCZz79kLxiK4MzEkH0rZNtTaMuz9ixK2lQ+vJ9ycu+ocPR/HkMkABJb/Evmg6SvM/vq/E5bPExxuHEOmmN8DgNY706H0UBO+Vx6K+mjtgy4i45b/RnRfeNH1vfIVevYgU3CcCui8fiix6aa0QaWs0Xw6j4kRjFkx2tcnJxNrVqUNptk2Fvk8K5try+WEK2Q0SjqPfWL61Bwi3DgmOROmXRS4qbmtbsAj6wM0SG1Psjqo8YdtrYE3N8Ucv+V7AHhmZyjhOEFF55NmDT/NbvqJexsD0mzRsn0nfDrP70n8m1pXHuHVQ2Y0cbZLYMmoc6vfeyHiHDkbAL3pFOHtrydso54ujQoRe8GY6H7B0+rLVI580m7fwMrHz9h5fh/08oG1RA60DWTRQ40EVz5m/mNzJCxflwjBZsc9/SbzH0Mn8OYj6DFl+1rQfNUEV/8h+n+0D+AcNTu6HVr3TMJx9EgQufk6C840bLlDkppfTxN493GM5uW9bANGkHnr4xeksIReqmHecZGHteURJBX+sD3EntMqC4Y6GZguEpAN9teqvHZIQjPMSNcvTWiNprt8mIvVZeYN+NzuELUhnYsLHWS4BGpCOptOKqwpi8QFBAEEZSPpiNju4pcbAmw/pXDZMCdpDoEDtSov7g9T21zH9csTPSmlcdx+kYdPTsocqtc41qRx74pGvjDWw4QBdlTdDJxadiBMY3NE7eKRrrg1IC8f5uTF/TaONpoLK3/z3SauKzaLQegGlDdpvHowTGVzes5t4924z/M1bI//nJ7G3hrTqvDPfWH21iosGemmMEOkPmywrjzCunIZA7CL8KO5XrzOXvk+2a14LrmDyIG1oEiE1vwBtWKPWVYuYyBGJNBc0u01M7BFEPHM+VK0r2vc5cj7VwMQWv8cur8Wx4iLETwZ6P4alNJNRA6siQsIAjAiwaQjYruLwFu/RCnbjnPsZQjONNRTBwhvfjH6oPfM/XJKaRyeS25HPvIJWtUhtNpjNP71XjwzvoB98ATQVPP4W5dhhEz/qGviYhxDp0T7O8dejm3zi2g1R5EPfUjT37+Ja8p1ZjEIQ0erKye87VUzlxVwz7oNwdH7KlQpFXtRSjaY/wgintlfRGs42Wk/MT0X0dt5+lJP0ysF5qAMGz+fn8EjHwcIKgYfHJf5IEH1FbcNvj0rPe4hP2ewk+uLXSwviaAZ8PphidcTVMeZPNAMJnqpuah6WZNK/7TzVz/0tnFu3jgsseJIhBVH4jVNUYCvTk7j9otSe6g4bQKPX5HJLzYEoibo/9uVWFNcPNLFd2fF57zZRYFfLsjggbU+Tvj1aGTymQjA9cWuuBeX3kZeuo3/WZjJTz/yc8Kvs6taZVd1oE27HLfAj+ZmMD2/75ljwazuk3Hjzwm8+QiGHEQ++AHywQ/aNnS4Sb/q2/EP+VFzcE29nsjO5aBrSDteR9rRVku1D5mMvWBstBqOWluG8zwmq7tn3Ya04w0ie1YQ2bMi/kNBJG3BV/FcfHtKxxTsTjJve5zA8l+YJuhgA6EP/y9hW9fExaS3VPxp6W+zk3HTL/EtewC9/kQ0MjnBSLimXh/34tKbkHYtb/3H0AksfySpfp65d5E27+7umdQ50CsFJpi1Wv92XTZvHpbYekrhpF8jpBikOwTyvCKzCkzBODBBPuJ3ZnmZUeBgRWmEQ3UqPtnAKZpLNo3KsXPVcBdzBjsob9KiAnNNmcyM81hw+5JBTpaMcvPPvWG2V8n4ZbPg++SBDm4Z62ZYO/7HzshwiTx2RSZbKmXePxZhf61KfVhHN6B/msiE/naWjHJH/ZZnUuC18f+WZPPOkQgfn5A52qgSkA3sopk7OjnPweKRLsZfAOkkw7PtPHttNu8ejfDh8QhHmgtBpDsFirJMs+3nRrlJ62Dlmr6Ac8Qssu/7m1kPtWwrWsNJDDmE4ExHzMrDOWIWrinXY0uwooT36u/gKJpBZPcK1KpD5gogdidiei72gaNwXXQVjuI5aLXlUYEpH1hzXtMKnCMvwT15CeFP/olctt1cQiwzD8eQybhn3IK9/7DOD5IA0Z1B5q2PIR/dQmTf+6gn96MH68HQEb39sQ+egHvykqjf8kxs2QVkf+X/EdnzDvLhj1Frj2JIAbDZEb39zXq0kxbjKBx/LqffrWjVJZ03uoAQDKOT+nFnSeUjczpv1MeJXQ/ziSsz4zRli88OhT/Z2KPjzXmu/bqpFiax62Fm3v5EnKZs8dlh4z2J6/CeLX3PSWNhYWFhYXEWWALTwsLCwsIiCSyBaWFhYWFhkQSWwLSwsLCwsEgCS2BaWFhYWFgkQa9NK+kL3D0pjbsn9b1Fii0szjdp8+7ulXl+Fr0bS8O0sLCwsLBIAktgWlhYWFhYJIElMC0sLCwsLJLA8mEC969qYvdps0bqujs7XyC2r3P5v+ra7MtLF3nxxvil2HTDYE2ZWZKvpF4lpBhku0WKc2xcPcLFpUOcSS2X1BXsqFJ447DE/lqFpohBplNgeLada0a4uLKo7Tx2VSt8Z7WvzXEmD7Tz5FVZbfZbnB1NL9yP2rwOZL8H2q4YYhFP3W8ub7NPzMwj5xsvttmvVh0ivO1V1BN70IP15oom/YbiGr8Q16QlCLbuf/wbqkxk73vIh9ejni7FCPsRHC7E7EIcw2fimfZ5xDPqCCvHd+H793faHMs+ZDJZdzzZ7XPuCEtgWnQL/ojOjz/ys+d0fLH2mpBOTUhn40mFqXl2Hp6XQY67+wwdhmHwh+0hXjsUX4C/XjKor1LYXqXw/jEHj8zPwNPHa8hafHYIb36R0IfPgtG6LJMRbkKt+BS14lOkPe+QefOvEL3dpyCoteUEXv8JWv3xuP1GREWrLkGrLkHa/hreax/ENXZBt82jK7EEpsVZMzrXxvcvNte1s8fUwNcNgx9+6GdvjRptd9MYD4MyRE4HdVYcibCjSmFntcrDH/p54spMHLbuEVb/2heOCsuhmTZuH+9maJaN00Gd1w5JfFqjsu2Uwi83+nl0QWa035hcO88ubtUk71vZ1C3zs7A4G2z5o/Eu+n7zP/GP8ci+VYQ++DMAorc/ntl3YssbjRFuRNq9AqV0I1rVYXyv/ZisO3+PYOv6GtZ6qBH/S99Db14ezTHyElwTrkHMzMOQ/ChHNiHtegsUicDyRxDcj+Esmg6APX8MWXc/Gz1W0/P3dfn8zhZLYFqcNR67wKjctj+h945GosJyzmAHv7g0A7HF5DkArihy8dimACuPRNhXq7KmLMKikV2/lt+pgMbfm4vbj8yx8dRVWVEtcnx/uHSok19tDLCmTGZjhcKGCjm60LTHkfjcLCx6A4LDgz1vVJv9eiRAcI25KLWYMYCsLz8dp0U6R80h+OGzSJteQDt1EGnncjwzbu7y+YU+/mtUWHrm3U3a3LviPneOmIWzeC6+ZQ+CrhJ873c47vs7gmhDcCY+t96AFfRj0eW8XWqu5ykK8N1Z3lZhGcN/TG3NP11X3nat067gtUNSdKHw/5qe3sbkKgoC35mVTqbT3P/vfeFumYeFRU8R+fQ9c0k1wDP/noQm17T59yDmDgFA2vISXb1glaHKyPvWAGDrPxzPnC8nbOcomo57ynUA6I2VqBWfduk8ugNLYFp0KYZhMCLbxth+NqbnO8j1JP6JZblEctymoKoO6gnbnCsfNS86np8utrt0WrpDZMFQU6vcX6tyOqh1y1wsLHoC+dBH5obdiWvcFQnbCKIN98RFAOj+GtSTe7t0DurpUgw5CICzeF6HgX2OmHVQ1dOlXTqP7uC82pxeOxTmqW0hAB64JL1Ds1yDpPOF1xrQDFgw1MnP5mfEfd4U0XmnNMKOaoWyRg2/rGMAGU6BEdl25gx2sniEC5c9NV/Z0jcaqA7qCaNAY0km0lbTDVaXyXxQHqGkQaUpYpDmEBiWaWPOYCc3FLvPOvAkdvxUuGaEiwdne89qzEQIgsB3L+78eEFFxy+bb7a5nq73X1YHNU6HTEHc2Tqjk/McvFUawQB2VCssGtF2UfLPGuHtrxFa/RQA6dc+EH2AJkIPNtDwpy+AruEcs4CMG38W/3m4icied1DKdqDVlqFLfsBAcGdgHzAC56g5uCYuRnC4Uppjw9NL0X3V7UaBtpBMpK2ha8j7VxM5+AFqdQlGqAnBlYat3zCco+bgnnoDgtOT0vwSjZ8KrgnX4F3y4FmNmQhD11BPHQDAXngRgt3Zblt7zKLVStkOHIMndtk8RE8Wnrl3owdqsQ/p5Lix2q2qdNkcuovzKjAXFrl4ZkcIRYfVZXKHAnNtWQSt+dpeMzz+xltTFuG3mwNICeRFXdigLqyw9ZTCG4ck/ufKTPq1o/V0J1UBjYc/8lPaEK/B+CIGn9aofFqjsuxAmJ/Nz2DiwM/+QtLP7Q6jNiuWC4tSe5AmQ3lT63UektmxACz0tv4eyhr7hobpGr+Q0LpnQFOQ963uUGBGDqwF3bwurgnXxH+2fw2Bd38LitSmnxGoQwnUoRzbirTjDTKX/k+3RmW2h9ZUhf+1h9HO0GCMsC8aNRreuoyMG3/WpYKjp9EbToJmCh1b7uAO29qyWxdW1mqPdek8bDmDSJt3V+cNMVNIWhAzB3bpPLqD8yows1wilwxysv6EzM5qhfqw3q4Jb3WZ6RfLcQvMKmwVKLurFR7dEMAA0h0CN4x2M2GAnSyXQKNkcLBO5fXDEgHZoNyn8cyOID+am5FwjO6iUdL51iofNSEdUYCFRU4uHeKif5qIL6Kz9ZTC2yUS9ZLB99f6+P3VWYxOMeDk+5d4CSup+yIyXD2TSqHpBvWSzqE6jWUHw9F0k1kFDhaN6HqBWRNqNfPmpXf8gjQwvVWgxvb7LCN6snCOvAT58HqU4zvRA/WI3tyEbSP7VwMgpOfgGDErul85sZvAW48CBoIrHffUG7APnoDgycIINaKeOoi0/XWMSACtrpzgumfIuO5HPXF6UfRQI75/fQvdXwOCiHP8QlyjL0XM6I8e9pnCfPfbGMF6fC99n6w7f489f3RKY3gXfx9DTt3/LXi69jmk+Wui27bMvA7biuk5YHOApqD7a7t0HsmiB+qJ7Flp/iOIOJqjZHsz5z0McNEIF+tPyOgGrC2PcMvYtmaRCp/GwTrzDffKIhc2sfUh/9zuEAZmgMljV2Qwvn+8djZnsJNFI1zcu6IRSYOPT8houhF3jO7miS1BakI6dhF+eWkGFw+KN5XMKjTNxd9a5SOoGPz3xgB/WZKVUlL/oIzebUb8j3ebOBKjXQvA0vFu7pqY1i3fhS/S+vKQ1okZ3hPzefAsXjouVFwTFyEfXg+GTuTAWjwzb2nTRquvQDt10Gw//koEsfV3FvroOcAAQSTjC4/hGDQ+rq9pil1E43P3giIhl3yMoWtxx+hugu89YQpL0U7GTb/EOfLi+DmOmIVr0mJ8//wWhhwksOK/ybrnLynde7acQV097bOiJdgHAGfnizoIDg+GpmBEAt04q8QYhk5g5WNRX6froqsQ07J7fB6pct6Dfi4udESDP1YfiyRss6qsdX+sNiKpBhHNIMMpMGeQo42wbKEww8b4AeZnkgY+ueceiif9GutPmMEn1xW72wjLFkbk2PnyRPNl4ViTxvaq3m/PT4UzA3sM4OMKmXeOJP7OzxVFb/2OnZ08n10xn8ta3xGYjhEXI6SbfvkWLfJMIvtWRbddMWZbQ5Ew1AiCOwPHqDlthGULtuxCHIXNnylS/EO9m9EaTpovBIB76nVthGUL9gEj8Mw1I1KaNGMAACAASURBVDm12mMoZdt7bI5ditb6zOjIf3lmG0Pr+WdNcPVTKEc3m/NIyybt0q/2+BzOhvOuYdpEgSuLXCw7KHGoXuOET2vjc2oRpMU5NkbktE7ZbRd4ZrH5VqJ3Ehqd6259Y+zJh+InJ2VaRpuR37Fvclahg6d3mNs7qhRmFHT+o78Q0A2D/5qezpBMEVmD3acVXjskccKn8/ttQY40qHzvkq4LPALT4hAlBW0hUQrMZxVBtOEafyXS1mVoVYfQ6k9ga043aKFFkNryirEPGNHa1+Em+65nAFNb6HCc9FZTr6F1TwpRIuQjn0Dz3ecomtFhW8eIWbDuaQCU8h04h3fcvlcipqb/RJ+CPfibNwyD0JqniOx4w9wh2si47sdtyuP1Vs67wARYPNIUmGAG8MSuEbmvRqEyYN6Q13Tg62p50MmaQVVApzKgUeHXONqosb9GpdzXag7s4rSjDimpbx33Rx/6k+7Xcs7JctKvnbUPMy+9e01koiDEfXdT8hxRE3R1c+WfyXkOrhredb7MWDOrrHZ8XSIxcT6O825z6VlcExcjbV0GmAE8sWtEKif3oTdWmu3OCPaJRRDMi2aoMnpTFVpjpWnKrTmKWrkfra68tXEP3nxadUl02/9q8r7TlnNOepyGk2ftw+zM15jS8Ryt7ixDTeLFpLlNd1T6SYShKQRWPo7cYrUQRLxLfnhB+C5b6BUCc3i2neJcGyX1GqvPEJirmrVLu9h+NGVdWOeVg2E2nJCp8OskuiVFAfTzYG1ripxdEIkvxX6Pbwr0irSSZBmYbuP+mek89IH5EvF2qdSlAjMtJj0n3InAjP28p4Kgegv2AcOx5RWjVZcQ2b86TmBGzbGiHdf4hQn764E6wtteQS7ZgF5fAYnuPkGMq2naU+ihsytnqEupmY0DKx/vFWklQqzfMkHU8pkYiinkBXdmJy3PHT3sw//6T1qvk82B93M/xDX2sm4fuyvpFQITTN9kSX2Ik36dg3UqY/vZ0XSDD5qTzy8pdJCdoEj39lMyP10fiAvWcNtgSJaNoZk2RufamTzQwWuHJN5vx0faFbT34hxr/f2fhZnRqjKd0RcKgc8scOC2mX7lIw1dm86Rn0Lka2yxggHnIeXofOOauIhQdQl6w0nUUwexF4w18xYPfgCYdUATBWTIZdsJvP7TaOCG2diNLXcItn5DseeNxjF0MtL214jsfb/7TqC9m09v/V4zl/5P0oLhbPMxzzdiVn50W/Of7rCtHmyI+jy72xyqNZzE98pD6PUnAFOwe2/8+QVp9u41AjM2J3NNWYSx/exsOWUuxQRwzYi2OZoNks7PPzaFpSjAnRd5WFjkZEimrY0vSupEy2iP6FE66R5oxxwaKyDTurE+aW9ZckrTDaqCpkk8P93WYQ6kTRRIdwpIYSMuSKcrKMpuHfekv2NhHGv+LsruNbdEjxGbkxnZvwZ7wViUY1swwqaG5k5gjtWDDQTe/LkpLAURz+w7cY5biK3fkKiJtgVD7lzbSUiSvrX2ojwFT6uAFJxp3Vaf9HwvOdWCmJUPDjcokpmT2QFajNnZ1r+o2+akVpfge/kBjFADAIK3H5m3/Bp7XnG3jdmd9JrX6ZacTCAaVbqmOTo2yyVwyaC2dvZVxyLRajFfnODhnslpDMuyJwzcOB06Ow3G3nyFIh0EChmGQW07WszwmAf3zk4iX6uDGn//NMT7RyOUNaVuXu0NHKpX+eLyRn6w1s+yAx37dUKKQaNkXtcBaV37U8xxi9GCBJ2ZqndXt34vEwf0PYHZkpMJRKNKI/vNWqCCJwtH82exRPatwpBMc7pn9hdJm38P9v7D2ghL6FzbaX9i5ndhqO1bhgzDaDeP0DZgeHRbKd/Z4VCar5rQhr8T2fs+am1Z6nPtBQiCgL1wHADqyX0YevvPvFgTcncVa1CrS/G9+N2osLT1LyLrS3+6YIUl9CKBCa0pI9VBnb01ChsrTMG5sMiFPUGuXkVMIM/YDjS38iaVwzHBN6kEyXqd5iXyyQZBJbFQPFCntpuqMjMm0nV5idRhhO5L+yX+uifMrz8JsP3UhZlWMirHTnqzOfmD4zKhDgKR3j0qRb+LmQVdH3jQUiP2uE9jb03i6xlU9KjZvzjXRr63d+ezdhctKSO6rxqlYi9y6UZz//iFCRca1hoqotv2grHtHletLUerOty6o4OH+JmIbtO3boR96JFgwjZq5QGMdnyOzuEzo9vSruUdBsJIm18i/PFfCaz49YWbVgK4xlwGgCGHkA+2XyZQ+vRdwCxGYe8GgamHmvC98lD0pco+6CIy73wK2wVQzacjepXAjM3J/MO2IOFmxaC9SjBZrtbpf3Iy8c1QFdD42fpAXMBPKmklo3LMB6huwGsH25qWfBGdJ7ckvpkBxvSzMyXPfOBUBXUe2xRAS2B+3FIps7zEPL7XKXQYEdybcdoEFo805+6XDZ7cmvh8d1crPLvTrCPsEOHWcV3vN1oyyh2Nev3t5mCbQCrdMHhySzBqpbg1QdGMvkJsTmZwzR+gOerT1U7JPNHT6gIw0zfaojVVEXjzZ/GLGCcTvdmMbWCzCdXQkba/1uZzPewjuKp9c6g9fwz2oVPMtk1VZqJ8AoEtH92CtGs5AILL22FEcG/HOe4KhObvJrjuGbSmqjZtwuufi/oT3dNv6pZCEoF3H8doXt7LNmAEmbc+Hn0BupDpVfanM3MyAUZk2yhuR3tcMMzJC/vD6Aa8VRpBUg0uG+Yi2y3QIBlsP6Xw/rFIm+otqVRzuXq4K7pc1V/3hKkL68wf4sRhEzhQq/LaIYnTIZ1BGSIn/Yk10O9d7OXr7zYRkI3/v73zDo+rOvP/5947VTMaFcu2LHe5d4MLxmAbxxQDDsGBEIcSWMpusiQhCctmyW4CPxKSJSTezaZAkg0Qkg01gE0xYIzBxo57r7KQZMuWrC6NRlNu/f1xx6MZq42NZEtwPs+j57maOefcNvd+z/ue97yHNWUqR5uaWDrOw4gshWDMYkuFxhvFrdbWN2f4EpZtX+SOqV42V6iUB01Wl6qUNjbxxXEehgUUWjSLDfGEBadyyX53to9B7Vh2C/+vLrHdUUL7zhicqXDLZC/P7IlwtMngH1c1ccskL6NyFGrCJq8cirInvm7nzHwni0Z8Oua9ng2nz8kE+0XXkfvMNX4BkU1/tbME7XodS4viHn8ZUkY2VksDWtl2YvveTQ0IAqwOLMX2cE++ktjuNwCIrH8aM1SHa+w8JMWJXnGQ6PZXMJurkXMGdzhm51/8LzT96WtYsRDqgTU01R7FM2MpSr8RWNEgWskWorvfSFi+vsu/2adf7LLHj+9zXyf05n9ihepo+tPX8M65GcfgSVjRoL2A9JENgH1/vbNuareduscWJrY7SmjfEdrxfYl92OPbt2J0MaYKIPtyO0zP2FvoVYIJqXMyofO5l6NzHNw9LYPf77ItldVlKqvL2vZgC7MVFg538cfddq+5rMlgcv/0XIBTBji5bbKXP++LYAErjsRYcSR1TOXLEzzkeGSejFtMpzM4U+GXlwf4wbpmKkImxQ0Gj29q++JwynDvDB9X9lHr8hQ+p8wvFgX44boQh+p0ihsMftbO+XodcP9F/h5Jvn6Kr0720hg1ea0oRlWLyfJ2vAFT+zt4aJ7/jNKhfRpJnpMJnc+9dAwYTcb8uwl/+HsA1P2rW+fXJaH0L8Q1YSGRdX8EwKgtwzlkclrH4xwyBe/FtxH5+58Bi9jOFcR2rkgp45n9ZeSMHMIfPNluG0rOYAK3/JLmV36A2ViBUV1My6rH2ynoxLfoXtyTr0zr2Hoz7slXYYbqCK/7I1akiXA8IUMySr/hZN7407QyAp0pp6x1ACyT0MpH0qrnveT2lGlNvZFeJ5gjsx2MzVUoqjdQJDt3bGd8ZZKXCXkOXjkc5UCtHVWrSJDtlhmZrbBwuJuFw11EdItn90bQTHvlkyWjO14Z5XTunJbBzEFOXiuKsrfa3kfALTEpz8nScR6mD3TywoHOA1wKcxw8sySbd0pjfFSuUhxf3sshwSC/woxBTq4f6+n1OWHTpX+Gwq+vDPD+UZU1ZTGK6nWCMQuvU2JIpsKcAidfGOtpd6pQdyJJEvfN8jN/qJsVR6Lsr9FojFl4HBKjshWuGOlmcaH7nOYW7q04+o9EyR9rjznKCu5Jl3da3jvnKzgKJhDd/gpaxQGscBPICnJGNkr/kbjHL8Q1YSGWGiGy4Vk7Cvfg+3imL0n7mDLm34lz5EyiO15DO74XK9KE5A3gLJiEZ8ZSnMOmE9n8QhfnVUj23c8Q2/sO6pGP7PUaw02gOFCyBtkLGV94fa/JCdsdeOfcjHPkLKLb/oZ2bBdmSz2S4kTpNwzX+IV4Lry+R8QSUhNGfNqQrO5ebjtOxSNze6JZQS/glKt02gBHj09n+Z+tLbxdEuWtL5/7ZaGS+STnXPDDjT1xSB0y96kzy1Qj6DuccpU6hk7r8eksLav/h+i+t+n3nbd6dD9d8UnOeeOdBV0XOgP67kCZ4DNBaZPe7vimQCDoWfTaUpSsQef7MHoVQjAFvZa1R2PsrtK7dMsLBILuJXZwLfqx3V265T9r9LoxTEHfIaJbFNfbUaYOBUZkdd/PSTUsntgRZv4wFzdNSH+8ubuIaFaXGYIEgvOFpUXQq4rtfxQHjm7M1mPpKuG1T+AaNx9PB1G0PYmlRtKKqj0fCMEUnDVF9Qb3rLLTpw30yTx/fU63te1SJJ5cnEXuecrterhe5zvvnbu1GwWCM8E4WUTTM/cAIAcGkvP157utbcnhIuv2J5F952eKh37yMMHnvnNe9t0VwiUr6LWcL7EUCD7rnC+x7O2IKFmBoIcRUbICwflBRMkKBAKBQHAeEIIpEAgEAkEaCMEUCAQCgSANPnNRsstea6Cqxez2qE5B55wMGawpU9l+UuVY0CAYsxf9znbLjM5VmDvExcLhbryOc5OirjFqYljQTwQW9RgNTyzDDFZ1exSnoJXwR88Q2fCnjgtIMihOZE8mck4BrsI5uCYu6vPLbJ0vPnOCKTi3NEZNntwZZnVpjHZW+aIqbFIVNtlwXOPp3WG+NcvHvKE9l6jAtCzeKI7xv7vCPDI/Uwim4NONZYIewwzFMEO16OV7CH/0NN6Lb8V78S09srTXpxkhmIIeo7he58EPgtRGbKXM80pcPtLNpDwn/bwSugnlzQYfHFXZWqlRG7F4aF2If55hcmMPrU25pkzlvzpZv1Qg6Kt4L70D1+hLUj80DSwtgtF0Eu3oDtSDa8HQiHz0NGZTJf5rvnd+DraPIgRT0COcDBk88H6Qxpgtlp8f7ebeGT7cp7lcpwxwcs0oD+vLY/x4QwjVgN9uDzMsoDC7oPtXU2hvMWuB4NOAHBiIY+Dodr9zAp4pi9Fnf5nmlx/EbK4htvdt5OzBZMy99dweaB9G+KMEPcJjm0IJsVw6zsN3L/K3Ectk5g11c98sHwAW8D/bWoS4CQTdjGPAKDK/9J+g2OsBRzb9H2ZL/Xk+qr6DEExBt7P5hMquKjvHbL5P5p8vzEir3tWFbsbk2mMqJ5pN/n5C67FjFAg+qzj6F+Kd9SX7Hy1KZMuL5/eA+hB92iXbFDV5tzTGunKVimaDoGoRcEmMzXWweJSbBcPOLnjkWJPBqpIoe6p1KkMGzaqFU4Zsj8z4fg4WjXAzd7ATSWrfYioPGqw8EmXHSY2KkIFhQsAtMSrbwZzBtguyI2urNmyyoijK1kqV8qCJalpkuqSEi/K6MW78rjPv5zyzJ8yf9na+yHV7nE008criaGL75kleHGkuzixJErdO8rKnWmfKAAdTBrT/86wJG7xZHGNXlcbxZjviVpEg4JYZk6uwYJibzw13pSwK/fbHUR7blDp2eSpXrIiY7hoz3ERs/7uoh9dhNFZgRYJI3gCO/LG4pyzGPW7BWbVr1B0juncVevkejMZKrGgzOJzI3mwcg8bjnrgI5+i5HT5rRn050Z0r0Y7uwGisANOwj6v/KJyj5uCZeg2Ss/33gNlcS3TnCtTSrZj15Vi6iuTNRMkdhqtwNu7p1yF7/Gd8Tl1GrnbAuYwm9ly4lMim5wALtWg9voVfa7ecpUaI7l2FeuQjjOoSrFgLksePkjcC15hL8ExbguTsfHEEvbaM6NaX0Y7uwAzVIrm8OAaMwX3B53GPW0DoneXEdr3eJ6Kp+6xgbqlQeXRjiGAs1W1XH7XYVKGxqUJjTkGMh+Zl4klzqoJpWTy5I8zfDkfbRHTqJkRCJpUhlbVHVeYNdfHwPD/yaQ/y+2Uxfvr3ELqZWr8uYlEX0dhSqfHiwSg/XxRgcGZqhNquKo1//6CZsJ6684aoRUNUZ3e1zgsHIvx0YSYT85xpndO5RjMsdlS2WoaXDDmzccj5w9zM76Sj8+LBCH/YFW5zfTUgGjapjkfcrjzi4GcLA3id52aayqcZtWQLoTcexYqkJqO3WurRPt6E9vEmYqPmkPmFh7p8eSbqWibhtU8S3fY3O5IzZYc6phpBbapEPbQW19h5+K9/GElK7SjGDrxP6M2fgqmnth2qQwvVoZVuIbr1RQJf/jlKzuCUMtqxXTT/7d+x1PBp59SA3tKAXr6byOYXyPzST3EWTEzrnPoScmYeSt4IjNpSzMYKjKaTKFn5KWW043sJrfwxZnN1yudWuBH92C70Y7uIbn4B//X/D+fg9q9RbP9qQm/9LOUeWREN7eh2tKPbUSdejuToO8v39UnB3F2l8eAHzZgWyBIsLnRz6RAXAbfE0aDB8wcilAdNNlVoLN8c4vuXZKbV7l/2RXjpkG0dDc6UuX6shxFZChlOieoWky2VGu+WxDAsWF+usurjGNeObn1BVDQbPLbJFstst8RXJnkZl+vApUBVi8mbxTG2ndQ42WLy6IYQv12clagbUk0eXm+LpccByyZ6mdLfSYZTojZs8v7RGGuPqgRVi0fWh3j2umxcSvpicN0YD5eeoXiBvWzXmXAsaBCNr4o1JFPu1gTq75bEeGKH/YLr55W4fqyHsbkO/C6JuojJnmqd149EiRmwr0bnr/sj3DXddgfPHeLiD1c72HBC5Zk9tqX9Lxf5GJfrOONz/Cyhle+m+eUHbVGTZNxTFuMacymSN4BRd5TI5ucx68vRPt5E6J3lZC75flrtRjb+hejWlwCQcwbjueB6lLwRSK4MzOZqtJItxPa/C6aBWrSe2J5VeKZdm6hvNFYQWvUYmDpSRjbei76CY9A4UFyYwSpiu99EK9uG2XSS0OuPkvXV3ybqmrEQza89bIul04P3omU4h0yx9x2qJXbgfdRDa7GiQUIrHiH7nmeRHOk/O57p1+Eac2na5RMo5/Z1rOQNx6gtBcCoKk4RTL3yEMEX/xU0+33oGrcA18RFyP48zFAt6v73UIvWYYZqCT7/XbJu/RWOgWNS2lePfETojZ8Cln2dZ96Ac+QsQEIr205k20uoB95LjKf2BfqcYOqmxc83hzAtUCT4yWWZKdGUk/o7WTjMzTfebaKk0WB1mcqyiTqFOZ2fakSzeG6//SId6JP5zZVZZHlaX/YT8+Cy4W5m5jv50YYQAB8eU1MEc3VZDDUuFo/Mz2TKgNYfwoQ8WDDMxX+sa2bjcY2DdTrFDTqj48e14bhGU9xa/u5sP1eMTOp19YNLh7rI9rTw6uEoVWGTLRUalw5N/yHO9XaveHXEyZZWayHf131KZFkWT+22xdLnlPjlFVltLPR5Q90sGObivtVBTAs+LI8lBDPglgm4ZYobWnu6gzMVRuf2uUfgnGEZOqFVP7fFUlbIvOEnuApnJ753Dp6Ee/xCmv7yDYyaEtT9q9EvWoajf2Hn7aoRIpufA2w3ZNatv0HOyEoqMRH3+MtwjphJ6PUfAaAe/jBFMGP7V4OuApC59BGcQ6a0Vi+YgGvcAppf+Q+04o3olQfRq4txDLAjSLUjG7Ai9rJ0/qu+i3vSFSnH5xpzKS2+bKLbX8UMVqGVbjkjAZT9ucj+3r/ah+zPS2yb8esBtvUfeuuxhFj6rvkenimLU+q6x84juuctWlY9DnqM5pU/IvvuZxJeAEuL0fLerwELyZVB4Ob/ThFU59CpuMZfRvC5b7fxXPRm+lzQz46TGseb7Zfy0nGedqceeJ0S/3RBa6DJ1squg0dKm3QG+hQ8Ctw43pMilslcNtyFM/5VdUuqK6k+0vr/6S9zsMfobpucwRfGuPn6hRn4ktyFqXXb3/dN4z0sGe3mH6dnUODvnbcurLW6kwPu7nOHVrWY+FwSPqfE4kJ3u9cXYHJ/J/k++9qcfn8EZ4Z2dAdmw3HAHvNKFstTSC4vGZf9U2udkq1dtqvXlKIEBoLTg2fmjaeJZSuuCZclrA8zmOoWNEOtkZ2nu1vBftYy5t6G+4IvkLHw60guX7t15XbqAnhm3YR72hIyFvwjcnb3rnjRW5CcrXOdrSTB1Ir/jlFbBoB78uI2YnkKz9RrcMU7G2Z9OeqRDYnv1KJ1mMEqALyX/kMb6xPA0X8kvs/98yc+j3NJn+tebzyuJravLuzY9z1zkJPfX53FkEwlrXGsiXlOnvl8NmCPZXaELElke2RqwnZATjLDAq0v8YfWN3PvDB/j+6Ve4vH9HIzv1zaQYFhWa92fbWrhWzN9TB/oSBkjzfcr3H/RmQchnEuSvcRaN+pVvl/hj9d2fX/ATndXETIT1r7g7FCLW5clc0+9usNyzpEzybrj9yg5Q5BcXSeccA6eSPbdzwC2NdMRkiQjZ2RjNtdg6WrKd0q/YYnt5lcfwrfoXhyDxqeUcQwaj/+0z06v2/LWz/Bd8S0cw6anjJEqWfn4F9/f5bn0ZSwj6ZomvWfU0i2JbfcF13XahufCpaj7VwOglWzGPXae3cYp8Yy78TvCNWER0nu/wor1jWQifU4wy+PWpVOGEdkdu/xkSWLMWbrbTolUSDWpDJlUhAzKgwbFDQb7ajTq4plrTg8MuqrQzQsHo9SETfbV6Hz97SbyvBIzBrmYke9kRr6zQ7fonAIno3MUihsMjjYZ3L8mSMAtceFAJzMGOZmZ7yTff/YuzvqImWLFpotDgRFZ6V/HzCSrsinWMxbeqfsT0SwqQwYVIZPjzQYlDTr7anUqQ/Z+xSzOT4ZZX25vKE6UvBEdlpMkuV0LIh1OiZQZC2E2VmI0VmDUlWNUF6Od2IcVqrMLnias7slXEd3yAmZzDfqJfTQ9+3Ukfx6uETNwxv86WgTZOWoOyoDRGNXFGHVHCT5/P5I3gHP4hTiHz8A5cmabAJgzwQzVn93cRsWBo5Pr3N1YsVBiW3K3dsSNmrL48Thx5I/ttA1H/ljbC2BoGDWlic/16o8B24LvLNJYUhwoA8egH9t1Fmdw7ulzgtkQf+kH3FKbCNXuoKhe55XDUbZVqglhPB2J9l/GfpfM8kUBHtsUYl+NPVZWG7F4pyTGOyUxJGwL88pCN9eOcuNMMscUWeKxhQF+sTnExvj8w2DM4oNjKh8cs3uChdkKi0a4WTrWc8bRnyuPRM/JtJKhSa7S2nD3C+aJZoOXDkbYVKFR1YHLVZbadmYEZ47Z0gCA5A20iVDtDvSTRUS3v4Jatq1VGNvQ/tMme/wEli0n9NZj6Cf2AWCFaonte4fYvncAyZ6WMvlK3NOuRUoKLJFkhcCXHiP0zi/Q4la0FQmiHvoA9dAHACj9C3FPXITnwqVpWc3JRHet7PXTSgDMpGsuZ7aOZ55yz0qezC5zzUqyguTJxGqpx4w2t7YR7zDI3kCXxyFn9J0pXX1OMPUu3HGfhOf221MWkvcQcNtzIEdkKYzv52BGvpNvvxfs8GU9JKDwqyuzOFSns/5YjM2VGiUNBhb2Y3+wTudgnR3NuXxRIGWsNNcr8+hlAcqadNYdU9l0QuNwvZ54+Zc0GpTsCrOiKMryy9tOS+kN5PsV+nkl6iIWFSGT6haDAWcQ/NOimfxme5jpA5xMH+hIqbu6NMbjm0Iprl6fU2Jo/P6MzXVwQb6D/97Swu5qvZ3WBWeCZfbcNYxseo7wh38gWQwlbwAldxhK3ggcg8bjHDGD4F+/nRgLOx0ldwhZt/4KvfIQsaL1aCWbMapL4m1adrBP5UGiu14nsGx5ylip7M8lcMOj6LVlqIfXoX28Cf3k4YQla9SUEP6whOiOFQS+srzdcdK+jl55OLHtyB+X2O7MTd4u8XeyRGsn3jK0lO8+LfQ5wQy4ZMCkWbUwLavbrMxtlSq/32VHYeZ4JO6clsGcAhd5GW171hG96x+BPVbp4J4L7AQLO6s0NldorDumEtYtShoNfrcrzL/OaeuuGJHlYMQUB1+dYgvI7iqdrZX2/M+mmEV12OQXm0Msv7z9YIn2uGNqBndMTS/jzidlToGLNz+OAbClUmPJ6PQFc0uFxqqPY6z6OMbMfCePL7J7qGVNekIsPQ74h6kZzBvqYlA7bup07o+ga2RPABOwos1YltltVqZauo3wh78HQMrIIWPenbhGzUmxck5haV17RRyDxtvjlwvuwQw3oR3biVayGfXwOiw1bIvfB7/Df82/tq2bN8J2g17yVcxYC3r5btTSragH12JFmjCbqwm98wuyli1P+/wyLr2DjEvvSLv8+UCvKcEK2x4EOXdoivta9ibdd9Po1Mq0DN1ONoHd4WltIwszVIsZbuzyWESUbA8yIh4coxr2nL/O+OrKBu56s5EndnQ9oPzq4dbsND+4JJMloz3timVYswip7b+QVcOitFGnqD61Z57lkblsuJvvXeznd1dn4Yn//jadaB10N0yLY0F7jDQZn1Nm7hAX983y8/SSbPLiY6A7q3SivVQYrh7VGoz16uFol0E6ybySdB8WjWiNgF55JJawLL8108dNE7ztiqVlWdT0gCv4s0hi3FJXMeqOdVq24Q9fpfGpu2h5/4ku243ueDWxnXndD/BMX9K+WMbCWNFQm88BLF1FrylFP1mU8rmcPG6wEQAACrdJREFUkYV7/GX4r/keWbf/DuKJFNSPN7XWNQ2MumNox/el1nX7cI2ei/+K+8i+6+nEtAv96E4sLcqnieiu1xPb7klXpnyn9B9lbxgaRtWRTtvRTxYlkhIkB1Mp8bFPs7ESs4N7CLY1q1d3vo/eRJ8TzBmDWsciVpeqHZY7XKdT3mxS0mikFa1Z3twqvqdHtibzXlnruo7Gae0ue62BO99s4uH1zW0rxhkSUBgcaBX9U3zz3SC3v97IA2uCxDoQwhyPzLh+rSKhGb1TMCf1t4OUwHYjP5vm2OnKomhi7DffJ3N50lzU48H07s/WSo2GaOt1OT2Be0cp1gRtcY6Ykdg+FQnZHnrlYcz6coyaEjC7nsJlnAomgjaRrcnEDr7XGuxjpnaOG55cRtNTd9L82sMd1ldyh7S6UpOibIN/+SaN/3s7wRcfwNJi7daVfTkog5LclManJ6+xXlVMbPebAEguX8r8VgBX4azEdnTnyk7biu1akdh2jpjZ2sboufEtC/VAx78drXijsDB7knlDXQyIW34vHYywt7rtD1k1LJZvsXs1EnDtqK5TL2W5Wy/F30+0L8Q7Tmo8mWStaqe9jC8ebFtElSGTVw+3LxLFDTpljfbDPy7pxX/xYFtgogY8tSfcbt2asMHe+NhcgV8m0917b993ZvsS80z/tDfC73a2oHYi8K8VRfnlNvvaypKdhSc5B21WUvRtR0nZixtst20y6mmdGmfSJYtovbPD0VtwjZ2HnDkAgMjWl9CO721TxtJVQu+ecldKuKde26bM6cje1qEEtfjv7ZbRju6gZe2Trfs5TbBcoy4GwGyqJLL9VdpDry5OzCd0JImfc/TF8Z1ECa9/qt26RrAGvdw+Xzm7ANmTXraw3o5e/THNr/4A4tfTO/8uZF9q0I1z9FzknCEAxPa+bSeJaAc7wOpdAOScIbjiU0oA3BMXIcXdvOH1T6MnRdCewghW0bL6V5/8pM4hfW4M0yFLfO9iPw+8H0Qz4f41Qb4w1sOcAicuRaKsyeDFg5FEcoMbxnsY1UWWH4CFw10J6+bxzSFKGw2mDXTgdUicbDFZX66yvlxNib4MaxaWZSWslpsneXn/aIyoDr/eHmZPtc6CYS4G+GRCqsWBWjsC14in9Lttcmv03fVjPaw4EqUuYvHiwSgljQZXjXST75eJ6RbFDQYvH4oSjLuDb59ybsYjz5aCTIUfL8jkwbVBogY8fyDKe6UqVxa6mdLfQY5HJqJbFDfovFsa40i93YmQJbhvpo8Zg1ITUiwc7ua9Mrsj89TuMLVhk4sKnGS6JWrCJptOaKwpi7XxJrSoFt6kXMLJ03peOhRJJFeY1L/vpOc6V0iKA/+13yP4wgNgaASfvx/PBV/AOWoOksOFUVtGZMuLrckNZt6AY8CoLtt1TViYiGwNvf04Rm0pjqHTkFxezKaTqEXrUYvWp0wlsdRwyrPmnXMzsYPv26K35tfox/fgGrcAOXMAViyEXnGA6PZXbMtUkvHOvS3RlufC64nuXIEVqiO69UWMmhLcU65CDuRj6TGMqmKi217GitqWT8Ylt3fbNe1JzGAVelVxymeWoWGpYTt94dEd9vzI+HV1T/883hlL27QjSTL+Jd8n+Nf7wNAIvfET1OKNuCcsQs7Mi6cPXJOIKEZx2nmEk1L7SU4Pviu/TejVh7CizQT/8g08M2+wvRaSjH58H5Etz6dal33A+yNZVs+EMVU8MrfrQp+ADcdVfrIh1CZReTLXjbHXWEwODFr2WgNVLWab6RKGafHDdc2JKR0dMX+oC69T4p0S25Xz589nMyQpYcGWCpVHPgrR0on14lHgvtk+FhemJqouqtd5cG2Q+mjHdRXJDni5ZfKZhbqfL0obdX62KcShuq6zCAzMkPnuRb4OF47+ry0hVh5p34V2imkD7GCrFw7aY06Pfy6TmUniG9Utbl3ZkDJlSJbgzZty007Sf6YU/HBj14W6kblPVXRre+qRDYTe+EmbROXJuKdfh+/K+1ICgxqeWIYZrGozXcIyDZpf/WFiSkdHuMbOR3J549NEIPueP6PkDmk9rpIthFY8gqV2EqPg9OC74r422Wr0k0UEX34wMf2hXWSFjEv/Ae/Ft3R6nOeTs1kZRXJl4L3kdryzb+q0nFa+h+YVD2PFpxe1h5xdQOZ1P0yx4JOJ7lxhp8jrIOLafeH1aKVbMRtOIOcOJeeeZ9M/kTTYeGf3ZmlSHn744Ye7tcU4zR/+sSeaTTAsoHDtaDduh0REt4jqdjB5rkdmdoGT+2b5WDrO22bM6uVDUVo0C79L4sbxraIjSxILh7vI98m0aBYtmoUej8gs8CvMHuTk3hk+bp7kRZFhTdzayfJITB/Yap0MzlS4qtCNW5FQDYgZFoaJvURXlsLVhR7+7WI/0wa2FYV+XplrR7vJdMlohkXUsI8hwykxOFPh8pFuHpjjY95ZLlt2PsjxyCwZ7WFKfwceh4QFaIa9+otbgbwMmRmDnNwyyct3ZvsY1kmShIsHuxiVoxDWLFpUCzXexgCfzAUDndw9PYO7p2eQlyGzIi6siiSl5Nx1yBKzC5ycDJkEYxaWZR/D3MGuDtMhflIyF9zVI+12xB93djyGfjYo/YbZcxkdbjtqVYuCZSH7cnEWzsZ3xX14Zyxt86xFt71sLwfl9uOddWPic0mScU1YaFt0aoud5cXQweVBySqw21x0L945N4OioB5YY9fLyMI5bHrrceUMxj3lKnu1C0PF0mP28l7uTJR+w/BMvRr/Nf+Ga9i0Nuck+/vhnnotsifTtsK0qJ3I3ZVhtzvxcnyLH8A9bl6bur0J7dgu9PLdHReQZCRXBnJgII6hU/HO/CK+xffjShqf7gglayCe6dcheQNJ18hA9ufhKJiAd+5t+K/4NkrWwA7bcAwab7tqDR0rGsIyVCRXBs6h0/Bd/g28M28kuuVFrFgLclY+numfP5vL0CF3XdC9rvQ+a2EKBH2Fvm5hCgQ9Sf1/XYulhnGOnkvghke7te3utjD73BimQCAQCHo3sf2rUYs+Qs4pwDv7y8gZ2e2W0ysPJ1z96Yx/n2+EYAoEAoGge3G4UYvWAfaYaUZS0NUpLC1Ky5pfx/+TcI2dfw4P8OwQgikQCASCbsVVeBFyYCBmsIrIR89g1B21pyn5+2NpEYyaUqK7ViYS/HtmfBHHwNHn+ai7RgimQCAQCLoVyekm84s/ovnl72OGalEPrEkEb52OZ8YNZCz82jk+wrNDCKZAIBAIuh3HwDFk3/Ms0d1vohZvxKgtxYo221G7/jwcw6bhmbI4JfF7b0cIpkAgEAh6BMnlxTvrxpRpRX2Z3ptbTSAQCASCXoQQTIFAIBAI0kAIpkAgEAgEaSAEUyAQCASCNBCCKRAIBAJBGgjBFAgEAoEgDYRgCgQCgUCQBkIwBQKBQCBIAyGYAoFAIBCkQY+sh2npMXtRV4FAcE6fh5hu4XZIXRcUCD4DdPfz0GMLSAsEAoFA8GlCuGQFAoFAIEgDIZgCgUAgEKSBEEyBQCAQCNJACKZAIBAIBGkgBFMgEAgEgjQQgikQCAQCQRoIwRQIBAKBIA2EYAoEAoFAkAZCMAUCgUAgSAMhmAKBQCAQpIEQTIFAIBAI0kAIpkAgEAgEaSAEUyAQCASCNBCCKRAIBAJBGvx/JwnvtXHCn2AAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn import tree\n",
    "clf = DecisionTreeClassifier()\n",
    "clf = clf.fit(pets, labels)\n",
    "features_i = ['Height', 'Barks', 'Retractable Claws', 'Weight']\n",
    "features_mapping = res = {i : features_i[i] [i] for i in range(len(features_i))}\n",
    "temp = new_pets.transform(pets).toarray()\n",
    "\n",
    "tree.plot_tree(clf,\n",
    "               feature_names = features_i, \n",
    "               class_names=['Cat', 'Dog'],\n",
    "               label='all',\n",
    "               filled=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4 **[1pt]** Compare the two trees (handmade and scikit-learn) in number of leaves, tree depth, selected features, and thresholds (in English)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$Comparing \\\\ trees$\n",
    "\n",
    "|  Features  |      My tree      |  Scikit's tree |\n",
    "|----------|:-------------:|------:|\n",
    "| Depth    |  3   | 1 |\n",
    "| Number of leaves|    7   |   2 |\n",
    "| Selected Features | Retractable Claws, Barks, Weight, Height |   Barks |\n",
    "| Thresholds | Retractable claws are true, weight greater than equal to 5, height is greater than =40| barks or retractable claws. keeps changing randmly but other features stay the same|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Perceptron"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is our first proper learning algorithm, and also the first with an iterative implementation. Its implementation is simple: you should use this opportunity to become confident in its features, as we will find them in much more complex algorithms over the next weeks. Any extra work in this section will make the following assignment much, much easier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 **[1pt]** Write the equation of an hyperplane in $\\mathbb{R}^k$, specifying the numeric set and dimensionality of each parameter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$w^k · x + b = y$\n",
    "Where $w$ is a vector normal to the hyperplane and $b$ is an offset. Numeric set is $w^k$ and dimensionality will be $k$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2 **[1pt]** Write the definition of *Linearly Separable Dataset* in plain English (no math)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a given dataset, for eg in a two dimensions, if we draw a line, all the points above the line are one group and those below, will belong to another. For higher dimension, lets say 3 Dimension, points on one side of the plane are one group and on the other side are another group. We assume that the dataset can be seperable using a hyperplane."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the next question, let's make sure the concept of Margin and its use is clear. Here is an example of point $(x, y)$ and hyperplane parametrization (w, b).\n",
    "\n",
    "$$\n",
    "\\text{point: }\\;\\; ((1, 3, -5, -2), +1)\\\\\n",
    "\\text{params: }\\;\\; ((2, 7, -3, 5), -2)\\\\\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3 **[1pt]**  Compute by hand (LaTeX not Python!) the *margin* for the point and hyperplane above: is the point correctly classified by the hyperplane? Why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$Given :$\n",
    "\n",
    "point: ((1,3,−5,−2),+1) \n",
    "\n",
    "params: ((2,7,−3,5),−2) \n",
    "\n",
    "$To Find:$\n",
    "Margin = ?\n",
    "\n",
    "$Formulae: $\n",
    "\n",
    "$ margin = y_{i} . f(x_{i})$\n",
    "\n",
    "$if margin > 0, correct,else \\\\ incorrect $\n",
    "\n",
    "$y = w.x + b \\\\ $\n",
    "$$ \n",
    "y = \\begin{pmatrix} 2 \\\\ 7 \\\\ -3 \\\\5 \\end{pmatrix}  x  - 2 \\\\\n",
    "= 2x_{1} + 7x_{2} - 3x_3 + 5x_4 -2 \n",
    "$$\n",
    "\n",
    "Subsituting the values of (1,3,−5,−2) to $(x_{1} , x_{2} , x_{3} , x_{4})$\n",
    "\n",
    " $ = 2.(1) + 7.(3) + -3.(-5) + 5.(-2) -2 \\\\ $\n",
    " \n",
    " \n",
    "  $ \\\\ = 26$\n",
    "\n",
    "$ margin = y_{i} . f(x_{i})$\n",
    "$ = +1. (26) $\n",
    "= 26 \n",
    "This is greater than 0 and hence classified correctly\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the next question we use `numpy`.  \n",
    "We use the definition of Affine Function for the parametrization: here `point` has been conveniently augmented with a trailing $1$ representing the constant input for bias.  \n",
    "Careful from now on you will need to take care of that yourself, starting from one of the next questions. Here are two examples (marked `1` and `2`) of how it can be done.\n",
    "\n",
    "```python\n",
    "x = [1, 3, -5, -2]\n",
    "y = 1\n",
    "w = [2, 7, -3, 5]\n",
    "b = -2\n",
    "point = [np.array([*x, 1]), y] # 1\n",
    "params = np.append(np.array(w), b) # 2\n",
    "```\n",
    "\n",
    "Use `np.dot()` to compute the inner product."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.4 **[1pt]**  Write a function that takes in input an hyperplane parametrization and a point, computes the margin, and returns a boolean indicating whether the classification is correct or not. Run it on the point and parametrization provided below (\"The Inputs\"), and print whether the classification is correct or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct\n"
     ]
    }
   ],
   "source": [
    "# The Inputs -- do not change\n",
    "import numpy as np\n",
    "point = [np.array([1, 3, -5, -2, 1]), 1]\n",
    "params = np.array([2, 7, -3, 5, -2])\n",
    "def my_margin(point,params):\n",
    "    point_x = point[0]\n",
    "    res = np.dot(point_x, params)\n",
    "    margin = res * point[1]\n",
    "    if margin >0 :\n",
    "        print(\"Correct\")\n",
    "    else:\n",
    "        print(\"incorrect\")\n",
    "    return margin\n",
    "marg = my_margin(point, params)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 10, -8, 3, -1]\n",
      "[ 2  7 -3  5 -2]\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5 **[1pt]** Implement the Perceptron update rule for a single point as a method that takes a hyperplane parametrization and a point (which we assume we know is misclassified) and returns the updated parametrization. Run it on The Input above and print the updated parametrization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 10, -8, 3, -1]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def update_perceptron_params(point, params):\n",
    "    new_params = []\n",
    "    point_x = point[0]\n",
    "    for i in range(0, len(point_x)):\n",
    "        new_params.append(params[i] + point_x[i]*point[1])\n",
    "    return new_params\n",
    "update_perceptron_params(point, params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.6 **[1pt]** Print whether the updated parametrization from the last question correctly classifies the point from The Input (use the margin-based function you wrote to answer two questions above)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_params = update_perceptron_params(point, params)\n",
    "my_margin(point, new_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alright, do you feel confident of your implementation so far? Let's scale it up: implement the Perceptron Algorithm and run it on a demo dataset from Scikit-learn.\n",
    "\n",
    "First we load the classic [Iris dataset](https://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html#sphx-glr-auto-examples-datasets-plot-iris-dataset-py), its history is very interesting so make sure to [have a look at it](https://en.wikipedia.org/wiki/Iris_flower_data_set).\n",
    "Since we are studying linear binary classification, let's collapse two classes together and focus on two if its four features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "iris_x, iris_y = load_iris(return_X_y=True) # print these to understand\n",
    "x1 = np.array([r[0] for r in iris_x]) # first feature\n",
    "x2 = np.array([r[2] for r in iris_x]) # third feature\n",
    "x = np.array([x1, x2]).transpose() # numpy transpose() for free\n",
    "# Reduce to two binary classes {+1, -1}\n",
    "labels = np.array([-1 if y==0 else +1 for y in iris_y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your Perceptron inputs should be $x$ input vector and $labels$ target labels / classes.  \n",
    "We learned last week what we need to plot such a dataset, right?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set(rc={'figure.figsize':(8,6)}, style=\"whitegrid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def todays_plot(): # learn to write your own\n",
    "    sns.scatterplot(x=x1, y=x2,\n",
    "      hue=labels, # let's use different colors for the two classes\n",
    "      palette=sns.color_palette(['darkred', 'darkblue']),\n",
    "      s=100)\n",
    "\n",
    "todays_plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The problem is clearly linearly separable. Let's see how the Perceptron performs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.7 **[4pt]** Implement the Perceptron Algorithm in a single cell (do not call any function defined above) as a function that takes the input vector and target labels and returns a trained hyperplane parametrization. Run it on the (partial) Iris data loaded above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(-3.3999999999999977, 9.100000000000001), -2]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from typing import List\n",
    "class Petal:\n",
    "    def __init__(self, x_1, x_2, y):\n",
    "        self.x1 = x_1\n",
    "        self.x2 = x_2\n",
    "        self.y = y\n",
    "    \n",
    "    def calculate_margin(self, params):\n",
    "        res = np.dot([self.x1, self.x2], [params[0], params[1]])\n",
    "        res += params[2]\n",
    "        return res * self.y\n",
    "    \n",
    "    def get_updated_params(self, params):\n",
    "        w1 = params[0] + self.x1*self.y\n",
    "        w2 = params[1] + self.x2 * self.y\n",
    "        b = params[2] + 1 * self.y\n",
    "        return [w1, w2, b]\n",
    "\n",
    "def pre_process(x, labels):\n",
    "    petals = []\n",
    "    for i in range(0, len(x)):\n",
    "        petals.append(Petal(x[i][0], x[i][1], labels[i]))\n",
    "    return petals\n",
    "\n",
    "def my_pre_process():\n",
    "    iris_x, iris_y = load_iris(return_X_y=True) # print these to understand\n",
    "    x1 = np.array([r[0] for r in iris_x]) # first feature\n",
    "    x2 = np.array([r[2] for r in iris_x]) # third feature\n",
    "    x = np.array([x1, x2]).transpose() # numpy transpose() for free\n",
    "# Reduce to two binary classes {+1, -1}\n",
    "    labels = np.array([-1 if y==0 else +1 for y in iris_y])\n",
    "    petals = []\n",
    "    for i in range(0, len(x1)):        \n",
    "        petals.append(Petal(x1[i],  x2[i],  labels[i]))\n",
    "    return petals\n",
    "\n",
    "def get_best_params(petals: List[Petal]):\n",
    "    count = 1000\n",
    "    params = [0,0,0] # two values, x1 and x2 and one for b\n",
    "    while count >= 0:\n",
    "        for petal in petals:\n",
    "            margin = petal.calculate_margin(params)\n",
    "            if margin <=0:\n",
    "                params = petal.get_updated_params(params)\n",
    "        count -=1\n",
    "    return params\n",
    "def perceptron(X,labels):\n",
    "    #petals = my_pre_process()\n",
    "    petals = pre_process(X, labels)\n",
    "    best_params = get_best_params(petals)\n",
    "    return [(best_params[0], best_params[1]), best_params[2]]\n",
    "perceptron(x, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok we can plot the points and we can plot a $y = mx + q$ model. But how can we plot the $f(x) = \\langle w, x \\rangle + b$ decision boundary? Well we know the two classes are $f(x)>0$ (positive, above) and $f(x)<0$ (negative, below), so our boundary is in $f(x) = 0$. Then we can find the function coefficients in the $w_1, w_2$ space as:\n",
    "\n",
    "$$\n",
    "f(x) = \\langle w, x \\rangle + b = 0\\\\\n",
    "w = \\begin{bmatrix}w_1\\\\w_2\\end{bmatrix}\\\\\n",
    "ax + by + c = 0\\\\\n",
    "y = mx + q\\\\[2ex]\n",
    "a = w_1,\\;\\; b=w_2,\\;\\; c = b\\\\\n",
    "w_1 x + w_2 y + b = 0\\\\\n",
    "-w_2 y = w_1 x + b\\\\\n",
    "y = \\frac{w_1}{-w_2} x + \\frac{b}{-w_2}\\\\[2ex]\n",
    "m = \\frac{w_1}{-w_2},\\;\\; q = \\frac{b}{-w_2}\\\\\n",
    "y = \\frac{w_1}{-w_2} x + \\frac{b}{-w_2}\n",
    "$$\n",
    "\n",
    "For now you can use the implementation below, but make sure you understand these simple (if tedious) steps above because next time you will need to implement it yourself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wb2mq(w, b):\n",
    "    assert len(w) == 2, \"This implementation only works in 2D\"\n",
    "    assert w[0] != 0 and w[1] != 0 and b != 0 # avoid edge cases for now\n",
    "    return [w[0]/-w[1], b/-w[1]] # m and q\n",
    "\n",
    "def params2boundary(w, b):\n",
    "    m, q = wb2mq(w, b)\n",
    "    print(f\"m: {m}, q: {q}\")\n",
    "    return lambda x: m*x + q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I hope the code above comes to no surprise after having derived it mathematically. If you read it aloud it should sound obvious in English; if not go back and make sure you understand the mathematical derivation (and the code above) before moving forward or it is only going to be more confusing.  \n",
    "Now we can plot the model on top of our data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w: (-3.3999999999999977, 9.100000000000001), b: -2\n",
      "m: 0.3736263736263733, q: 0.21978021978021975\n",
      "[2.1252747252747235, 2.050549450549449, 1.9758241758241741, 1.9384615384615367, 2.0879120879120863, 2.2373626373626356, 1.9384615384615367, 2.0879120879120863, 1.8637362637362622, 2.050549450549449, 2.2373626373626356, 2.0131868131868114, 2.0131868131868114, 1.8263736263736248, 2.386813186813185, 2.3494505494505478, 2.2373626373626356, 2.1252747252747235, 2.3494505494505478, 2.1252747252747235, 2.2373626373626356, 2.1252747252747235, 1.9384615384615367, 2.1252747252747235, 2.0131868131868114, 2.0879120879120863, 2.0879120879120863, 2.162637362637361, 2.162637362637361, 1.9758241758241741, 2.0131868131868114, 2.2373626373626356, 2.162637362637361, 2.274725274725273, 2.050549450549449, 2.0879120879120863, 2.274725274725273, 2.050549450549449, 1.8637362637362622, 2.1252747252747235, 2.0879120879120863, 1.9010989010988995, 1.8637362637362622, 2.0879120879120863, 2.1252747252747235, 2.0131868131868114, 2.1252747252747235, 1.9384615384615367, 2.1999999999999984, 2.0879120879120863, 2.835164835164833, 2.6109890109890093, 2.797802197802196, 2.274725274725273, 2.6483516483516465, 2.3494505494505478, 2.5736263736263716, 2.050549450549449, 2.6857142857142837, 2.162637362637361, 2.0879120879120863, 2.4241758241758227, 2.46153846153846, 2.4989010989010967, 2.31208791208791, 2.723076923076921, 2.31208791208791, 2.386813186813185, 2.5362637362637344, 2.31208791208791, 2.4241758241758227, 2.4989010989010967, 2.5736263736263716, 2.4989010989010967, 2.6109890109890093, 2.6857142857142837, 2.760439560439558, 2.723076923076921, 2.46153846153846, 2.3494505494505478, 2.274725274725273, 2.274725274725273, 2.386813186813185, 2.46153846153846, 2.2373626373626356, 2.46153846153846, 2.723076923076921, 2.5736263736263716, 2.31208791208791, 2.274725274725273, 2.274725274725273, 2.4989010989010967, 2.386813186813185, 2.0879120879120863, 2.31208791208791, 2.3494505494505478, 2.3494505494505478, 2.5362637362637344, 2.1252747252747235, 2.3494505494505478, 2.5736263736263716, 2.386813186813185, 2.8725274725274703, 2.5736263736263716, 2.6483516483516465, 3.059340659340657, 2.050549450549449, 2.9472527472527448, 2.723076923076921, 2.9098901098901075, 2.6483516483516465, 2.6109890109890093, 2.760439560439558, 2.3494505494505478, 2.386813186813185, 2.6109890109890093, 2.6483516483516465, 3.096703296703294, 3.096703296703294, 2.46153846153846, 2.797802197802196, 2.31208791208791, 3.096703296703294, 2.5736263736263716, 2.723076923076921, 2.9098901098901075, 2.5362637362637344, 2.4989010989010967, 2.6109890109890093, 2.9098901098901075, 2.9846153846153824, 3.171428571428569, 2.6109890109890093, 2.5736263736263716, 2.4989010989010967, 3.096703296703294, 2.5736263736263716, 2.6109890109890093, 2.46153846153846, 2.797802197802196, 2.723076923076921, 2.797802197802196, 2.386813186813185, 2.760439560439558, 2.723076923076921, 2.723076923076921, 2.5736263736263716, 2.6483516483516465, 2.5362637362637344, 2.4241758241758227]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f974396da30>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "todays_plot()\n",
    "perc_w, perc_b = perceptron(x, labels)\n",
    "# we can use the splat to separate the bias (last element)\n",
    "print(f\"w: {perc_w}, b: {perc_b}\")\n",
    "perc_boundary = params2boundary(perc_w, perc_b)\n",
    "print([perc_boundary(inp) for inp in x1])\n",
    "sns.lineplot(x=x1, y=[perc_boundary(inp) for inp in x1], color='black')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alright! Let's do the same with the scikit-learn Perceptron and we are done."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import Perceptron"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.8 **[1pt]** Train a scikit-learn Perceptron on the same data as the last question."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: it should take *no more than two lines*. You should still have the documentation open, the class you are looking for is `Perceptron`, and the method you need is typically called `fit` for most sklearn algorithms. Find out how it works and how to pass features and labels as arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import Perceptron\n",
    "perceptron = Perceptron()\n",
    "trained = perceptron.fit(x, labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To visualize the model boundary we need extract the vectors $w$ and $b$ from a trained scikit-learn Perceptron: they are stored as `coef_` (coefficients stands for weights) and `intercept_` (which is another term for `q` or bias) _(as mentioned: be flexible with the nomenclature as each library adopts its own)_.  \n",
    "Note though that they are both `list`s, because the algorithm is written to scale to _multiclass classification_, where you have multiple classes and therefore need multiple hyperplanes to partition the space in multiple regions. Of course with two classes you only need one hyperplane so be sure to access only the first element.  \n",
    "I will be providing the code below yet again, but make sure you study and understand it so you will be able to write it yourself in the next assignments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m: 0.423076923076923, q: 0.19230769230769226\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f89eb725190>"
      ]
     },
     "execution_count": 304,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "w, b = [trained.coef_[0], trained.intercept_[0]]\n",
    "d_boundary = params2boundary(w, b)\n",
    "todays_plot()\n",
    "boundary_preds = [d_boundary(inp) for inp in x1]\n",
    "sns.lineplot(x=x1, y=boundary_preds, color='black')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.9 **[1pt]** Compare the resulting boundary against the one trained with your hand-made algorithm, and hypothesize why _in your opinion_ they are similar/different (in English)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This exercise (as many more in the future) trains your ability to express your opinion and  fundamental understanding of the topic using technical language. It is scored based on your expressiveness, not on the correctness (although you should be able to formulate a correct opinion here) or on the English per se. Show your reasoning!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Similarities"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "They both have same slope. They both have correct classifications for the given data. This could be because we have positive values for both the features. The similarity can be because the weights calculated using the same process. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Differences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The offset is slightly different and weights are slightly different, that could be because there is no learning rate involved and that we offset by either +1 or -1 and that might be a bit too much be as accurate as scikit learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}