learning.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LEARNING\n",
    "\n",
    "This notebook serves as supporting material for topics covered in **Chapter 18 - Learning from Examples** , **Chapter 19 - Knowledge in Learning**, **Chapter 20 - Learning Probabilistic Models** from the book *Artificial Intelligence: A Modern Approach*. This notebook uses implementations from [learning.py](https://github.com/aimacode/aima-python/blob/master/learning.py). Let's start by importing everything from the module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from learning import *\n",
    "from probabilistic_learning import *\n",
    "from notebook import *"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CONTENTS\n",
    "\n",
    "* Machine Learning Overview\n",
    "* Datasets\n",
    "* Iris Visualization\n",
    "* Distance Functions\n",
    "* Plurality Learner\n",
    "* k-Nearest Neighbours\n",
    "* Decision Tree Learner\n",
    "* Random Forest Learner\n",
    "* Naive Bayes Learner\n",
    "* Perceptron\n",
    "* Learner Evaluation"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MACHINE LEARNING OVERVIEW\n",
    "\n",
    "In this notebook, we learn about agents that can improve their behavior through diligent study of their own experiences.\n",
    "\n",
    "An agent is **learning** if it improves its performance on future tasks after making observations about the world.\n",
    "\n",
    "There are three types of feedback that determine the three main types of learning:\n",
    "\n",
    "* **Supervised Learning**:\n",
    "\n",
    "In Supervised Learning the agent observes some example input-output pairs and learns a function that maps from input to output.\n",
    "\n",
    "**Example**: Let's think of an agent to classify images containing cats or dogs. If we provide an image containing a cat or a dog, this agent should output a string \"cat\" or \"dog\" for that particular image. To teach this agent, we will give a lot of input-output pairs like {cat image-\"cat\"}, {dog image-\"dog\"} to the agent. The agent then learns a function that maps from an input image to one of those strings.\n",
    "\n",
    "* **Unsupervised Learning**:\n",
    "\n",
    "In Unsupervised Learning the agent learns patterns in the input even though no explicit feedback is supplied. The most common type is **clustering**: detecting potential useful clusters of input examples.\n",
    "\n",
    "**Example**: A taxi agent would develop a concept of *good traffic days* and *bad traffic days* without ever being given labeled examples.\n",
    "\n",
    "* **Reinforcement Learning**:\n",
    "\n",
    "In Reinforcement Learning the agent learns from a series of reinforcements—rewards or punishments.\n",
    "\n",
    "**Example**: Let's talk about an agent to play the popular Atari game—[Pong](http://www.ponggame.org). We will reward a point for every correct move and deduct a point for every wrong move from the agent. Eventually, the agent will figure out its actions prior to reinforcement were most responsible for it."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DATASETS\n",
    "\n",
    "For the following tutorials we will use a range of datasets, to better showcase the strengths and weaknesses of the algorithms. The datasests are the following:\n",
    "\n",
    "* [Fisher's Iris](https://github.com/aimacode/aima-data/blob/a21fc108f52ad551344e947b0eb97df82f8d2b2b/iris.csv): Each item represents a flower, with four measurements: the length and the width of the sepals and petals. Each item/flower is categorized into one of three species: Setosa, Versicolor and Virginica.\n",
    "\n",
    "* [Zoo](https://github.com/aimacode/aima-data/blob/a21fc108f52ad551344e947b0eb97df82f8d2b2b/zoo.csv): The dataset holds different animals and their classification as \"mammal\", \"fish\", etc. The new animal we want to classify has the following measurements: 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1 (don't concern yourself with what the measurements mean)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make using the datasets easier, we have written a class, `DataSet`, in `learning.py`. The tutorials found here make use of this class.\n",
    "\n",
    "Let's have a look at how it works before we get started with the algorithms."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intro\n",
    "\n",
    "A lot of the datasets we will work with are .csv files (although other formats are supported too). We have a collection of sample datasets ready to use [on aima-data](https://github.com/aimacode/aima-data/tree/a21fc108f52ad551344e947b0eb97df82f8d2b2b). Two examples are the datasets mentioned above (*iris.csv* and *zoo.csv*). You can find plenty datasets online, and a good repository of such datasets is [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets.html).\n",
    "\n",
    "In such files, each line corresponds to one item/measurement. Each individual value in a line represents a *feature* and usually there is a value denoting the *class* of the item.\n",
    "\n",
    "You can find the code for the dataset here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%psource DataSet"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Attributes\n",
    "\n",
    "* **examples**: Holds the items of the dataset. Each item is a list of values.\n",
    "\n",
    "* **attrs**: The indexes of the features (by default in the range of [0,f), where *f* is the number of features). For example, `item[i]` returns the feature at index *i* of *item*.\n",
    "\n",
    "* **attrnames**: An optional list with attribute names. For example, `item[s]`, where *s* is a feature name, returns the feature of name *s* in *item*.\n",
    "\n",
    "* **target**: The attribute a learning algorithm will try to predict. By default the last attribute.\n",
    "\n",
    "* **inputs**: This is the list of attributes without the target.\n",
    "\n",
    "* **values**: A list of lists which holds the set of possible values for the corresponding attribute/feature. If initially `None`, it gets computed (by the function `setproblem`) from the examples.\n",
    "\n",
    "* **distance**: The distance function used in the learner to calculate the distance between two items. By default `mean_boolean_error`.\n",
    "\n",
    "* **name**: Name of the dataset.\n",
    "\n",
    "* **source**: The source of the dataset (url or other). Not used in the code.\n",
    "\n",
    "* **exclude**: A list of indexes to exclude from `inputs`. The list can include either attribute indexes (attrs) or names (attrnames)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Helper Functions\n",
    "\n",
    "These functions help modify a `DataSet` object to your needs.\n",
    "\n",
    "* **sanitize**: Takes as input an example and returns it with non-input (target) attributes replaced by `None`. Useful for testing. Keep in mind that the example given is not itself sanitized, but instead a sanitized copy is returned.\n",
    "\n",
    "* **classes_to_numbers**: Maps the class names of a dataset to numbers. If the class names are not given, they are computed from the dataset values. Useful for classifiers that return a numerical value instead of a string.\n",
    "\n",
    "* **remove_examples**: Removes examples containing a given value. Useful for removing examples with missing values, or for removing classes (needed for binary classifiers)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing a Dataset\n",
    "\n",
    "#### Importing from aima-data\n",
    "\n",
    "Datasets uploaded on aima-data can be imported with the following line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "iris = DataSet(name=\"iris\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check that we imported the correct dataset, we can do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(iris.examples[0])\n",
    "print(iris.inputs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which correctly prints the first line in the csv file and the list of attribute indexes."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When importing a dataset, we can specify to exclude an attribute (for example, at index 1) by setting the parameter `exclude` to the attribute index or name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris2 = DataSet(name=\"iris\",exclude=[1])\n",
    "print(iris2.inputs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attributes\n",
    "\n",
    "Here we showcase the attributes.\n",
    "\n",
    "First we will print the first three items/examples in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(iris.examples[:3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we will print `attrs`, `attrnames`, `target`, `input`. Notice how `attrs` holds values in [0,4], but since the fourth attribute is the target, `inputs` holds values in [0,3]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"attrs:\", iris.attrs)\n",
    "print(\"attrnames (by default same as attrs):\", iris.attr_names)\n",
    "print(\"target:\", iris.target)\n",
    "print(\"inputs:\", iris.inputs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will print all the possible values for the first feature/attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(iris.values[0])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we will print the dataset's name and source. Keep in mind that we have not set a source for the dataset, so in this case it is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"name:\", iris.name)\n",
    "print(\"source:\", iris.source)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A useful combination of the above is `dataset.values[dataset.target]` which returns the possible values of the target. For classification problems, this will return all the possible classes. Let's try it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(iris.values[iris.target])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper Functions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now take a look at the auxiliary functions found in the class.\n",
    "\n",
    "First we will take a look at the `sanitize` function, which sets the non-input values of the given example to `None`.\n",
    "\n",
    "In this case we want to hide the class of the first example, so we will sanitize it.\n",
    "\n",
    "Note that the function doesn't actually change the given example; it returns a sanitized *copy* of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Sanitized:\",iris.sanitize(iris.examples[0]))\n",
    "print(\"Original:\",iris.examples[0])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Currently the `iris` dataset has three classes, setosa, virginica and versicolor. We want though to convert it to a binary class dataset (a dataset with two classes). The class we want to remove is \"virginica\". To accomplish that we will utilize the helper function `remove_examples`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris2 = DataSet(name=\"iris\")\n",
    "\n",
    "iris2.remove_examples(\"virginica\")\n",
    "print(iris2.values[iris2.target])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also have `classes_to_numbers`. For a lot of the classifiers in the module (like the Neural Network), classes should have numerical values. With this function we map string class names to numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Class of first example:\",iris2.examples[0][iris2.target])\n",
    "iris2.classes_to_numbers()\n",
    "print(\"Class of first example:\",iris2.examples[0][iris2.target])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see \"setosa\" was mapped to 0."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we take a look at `find_means_and_deviations`. It finds the means and standard deviations of the features for each class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "means, deviations = iris.find_means_and_deviations()\n",
    "\n",
    "print(\"Setosa feature means:\", means[\"setosa\"])\n",
    "print(\"Versicolor mean for first feature:\", means[\"versicolor\"][0])\n",
    "\n",
    "print(\"Setosa feature deviations:\", deviations[\"setosa\"])\n",
    "print(\"Virginica deviation for second feature:\",deviations[\"virginica\"][1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IRIS VISUALIZATION\n",
    "\n",
    "Since we will use the iris dataset extensively in this notebook, below we provide a visualization tool that helps in comprehending the dataset and thus how the algorithms work.\n",
    "\n",
    "We plot the dataset in a 3D space using `matplotlib` and the function `show_iris` from `notebook.py`. The function takes as input three parameters, *i*, *j* and *k*, which are indicises to the iris features, \"Sepal Length\", \"Sepal Width\", \"Petal Length\" and \"Petal Width\" (0 to 3). By default we show the first three features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
<<<<<<< HEAD
   "outputs": [],
=======
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAGMCAYAAABUAuEzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzsvXlwHOd95v/03CdugLgBEiAokiJEiqR4S7bkS7YUJ3GUY30p8dqu9cZxrHUuOZVSHK/KrnJVtCpn7dhxtLKtxFFZtixb1kqWvCElijQpHpJIADODGwNggMEAmPvq6f79gd/b6hnM0TPTB473U8UiORjMO0dPv09/j+fL8DzPg0KhUCgUCqUAOq2fAIVCoVAolI0NFQsUCoVCoVCKQsUChUKhUCiUolCxQKFQKBQKpShULFAoFAqFQikKFQsUCoVCoVCKQsUChUKhUCiUolCxQKFQKBQKpShULFAoFAqFQikKFQsUCoVCoVCKQsUChUKhUCiUolCxQKFQKBQKpShULFAoFAqFQikKFQsUCoVCoVCKQsUChUKhUCiUolCxQKFQKBQKpShULFAoFAqFQikKFQsUCoVCoVCKQsUChUKhUCiUolCxQKFQKBQKpShULFAoFAqFQikKFQsUCoVCoVCKQsUChUKhUCiUolCxQKFQKBQKpShULFAoFAqFQikKFQsUCoVCoVCKQsUChUKhUCiUolCxQKFQKBQKpShULFAoFAqFQikKFQsUCoVCoVCKQsUChUKhUCiUolCxQKFQKBQKpShULFAoFAqFQikKFQsUCoVCoVCKQsUChUKhUCiUohi0fgIUylaH53lkMhmwLAu9Xg+9Xg+GYcAwjNZPjUKhUCRBxQKFohBikZBOp5FKpaDT6QShYDAYoNfrodPphL+pgKBQKBsRhud5XusnQaFsJXieB8dxYFkWHMcBgPB/hmHA83zWHyIQiGggf3Q6nfCHQqFQtISKBQpFJsjmz7IsxsfHEY/HsXfvXjAMA5ZlwbJs3o0/VzyQ20gEIldA0DQGhUJRG5qGoFBkgEQOMplMVmSBbOjFNvZ8G79YNJA0hvi+4jSGOApBBQSFQlECKhYolCogmznLsgCyN3OSgqgEscgQRyPEEYhUKpX1O+R+BoMBRqORpjEoFIpsULFAoVSAuHiR47gskQCsjySIUwzVUCgKQf4MDw/DarWiu7ubpjEoFIpsULFAoZRBPpGQL/xPChnVQLzxk0iCwbD21SbpEJrGoFAo1UDFAoUigXwdDsU212rTENVCnpder8+6vVQao1AUgkKhbG+oWKBQipBPJEgJ4YsjC5lMBlNTU4jH46ipqYHD4YDNZlOklqBURKNUGoP4QYjvS9MYFAqFigUKpQC5HQ7lhOlJZGF2dhYejwdGoxEOhwNerxeRSAQAYLfb4XQ64XA4hL9zIwFqUKwbo1Aao5AnBBUQFMrWhIoFCiWHfCKh3ChANBpFMBhELBbDwMAAmpubBbtnnucRi8UQiUQQDoextLSEiYkJpNNp2Gy2LPHgdDphMpkUeqWFKZXG4DgOmUwGiUQC4+Pj2LdvnyAgDAaD8J7RNAaFsjWgYoFC+f8hbZCZTKZo8WIxQqEQ3G43VlZWYDKZcPr0aej1emQyGeE+DMPAbrfDbrdjx44dwtqpVArhcBiRSAShUAhzc3OIx+MwmUzrIhBWqzXv81K6sDI3CsEwDFZWVqDT6Wgag0LZwlCxQNn2SO1wKEY8HofH44HP50N3dzdaWlowNzcnOa3AMAzMZjPMZjOampqE21mWFSIQkUgEk5OTiEaj0Ol06yIQdrtdsw04N/JC0xgUytaCigXKtoWE09PptLC5lbthpdNpjI+PY2pqCjt27MDp06dhs9ng8/lkucI3GAyoq6tDXV2dcBvHcYhGo4KI8Pl88Hg84DgOBoMBJpMJJpNJEBGkjVIJCr1GqWkMMTSNQaFsXKhYoGw7Ku1wEMNxHKanpzE2Ngan04ljx46htrZW+HluOkDODU+n08HpdMLpdKKtrQ3A2mtKJBJwuVxgWRbLy8uYnp5GMpmExWLJikCQOggtNmHajUGhbE6oWKBsK6rpcADWNjafzwe32w29Xo/BwUE0NTVJMmVScnNjGAZWq1Voyezv7wcApFKprDTGwsICYrGY0J1BxANp59xIAgLITmOQ+ySTSaTTaTQ0NNA0BoWiElQsULYFZNMJh8O4ePEi7rnnnrI7HJaXl+FyuZBIJLB79250dHQUNWXSaqCreF2TyYSGhgY0NDQIt2UyGUQiEUFEzMzMCO2c+eogtGrnBLLTGOR1rayswO/3w+FwCLeL6yBoGoNCkR8qFihbmnwdDmTok1QikQjcbjcCgQB27dqFnp6eknUAWokFKRujXq9HbW1tVtqE4zjE43EhArG4uIixsTGwLAu73b5ORBiNRiVfRl7EczeIXTVQXhqDRCFoGoNCKQ8qFihbkkIdDuINptRmkUwm4fF4MDc3h87OTtx5550wm82S1t8okQWp6HQ6oZ1T/DjJZFKIQASDQXi9XiQSCZjNZqH2ged5xONxWCwW1Tbg3PbNYnUQuWkM2o1BoZQPFQuULUWpDgfyd7ENlWVZTExMYHJyEk1NTTh16lTWJioFLcWCXDAMA4vFAovFktXOmU6nBQGxsrICjuNw8eJF6PX6dREIJWytpbyvxeogxAWuBHKM0DQGhZIfKhYoWwKpHQ5k4+I4bl0unuM4eL1ejI6Owmaz4ciRI6ivr6/o+WiZhlB6XaPRiPr6etTX16OhoQHBYBCnTp3Kauecm5tDJBIBz/Pr0hgOh6Oqdk4pUaF85ApG8vnTNAaFUhoqFiibnnI6HIhYEG+oPM9jcXERbrcbPM9j//79aGlpqWoz2GxpiGrR6/WoqalBTU1N1vMQ10EsLS1hcnISqVQKVqt1nSul1BQPIG9niZQ0ht/vx/z8PPbt25eV0hKnMGgag7KVoWKBsmmpZIYDOZmT6MPq6ipcLhei0Sj6+/vR2dkpS9h8Ixc4qgXDMLDZbLDZbIKtNYCsOohIJAKfz4dYLJZlJEX+zmdrrcb7mk9AJBIJYbYHx3FIJBLCz2gag7LVoWKBsukgV3sk50xO7FJOyuR+0WgUIyMj8Pv96O3txeHDh2V1OtwukYVK1iK21o2NjcJtLMsiGo0iHA4jHA5jenoakUhEsLUWiwhSsKom4ohVuWkMIh5oGoOymaFigbJpyNfhUO5JN5VKged5XLlyBe3t7Thz5gwsFovsz5WMqFabzboBGQyGvO2csVgsKwIRiUTAsiwMBgOGhoayRISS7ZzFBIoUV0pxnQVNY1A2I1QsUDY8YpFQ6QyHTCaDqakpjI+Pg2EYDA4OorW1VamnvG0iC0oijioQeJ7H6OgoQqEQLBYLVldXMTMzI9ha56YxzGazLBtwuUWVUroxSqUxxFEICkVrqFigbFjkmOHA8zxmZ2cxOjoKk8mEQ4cO4fr167DZbEo9bQBbo3VyI0LC+larFbt27RJuT6fTQgQiHA5jcXER0WhUsLUWi4hK2jkr7cDIfe7iv6WkMVZWVlBfXw+z2UzTGBRNoWKBsuEQnzgrFQkA4Pf74Xa7wbIsBgYG0NbWJoSAlU4RbOXWyY2I0WjMa2tN6iAikQi8Xq9ga22329d1YxSztSY1C0pQLI3hcrmwb98+1NTUCIKFpjEoWkDFAmVDUe2gJwAIhUJwuVwIhUKCPbP4RK9GPYG4RZOewOVF6ntaqJ0zFosJEYilpSVMTEwgnU7DZrOtS2OYTKay1pQLIgo4joPRaITBYMhKY5C0HIGmMShKQ8UCZUNAIgmZTAZAeR0OhHg8Do/HA5/Ph56eHhw8eDBv0ZtOp1Pt6luLTWY7UOnrZBhGsLUm7Zw8zyOVSgkRiFAohLm5OcTjcZhMJjidTnAch0wmo7qttTiikVsgKb5PbhqD3LeYrfV2OVYo8kDFAkVTyFXS7OwsUqkUOjs7yz6RpdNpjI+PY2pqCq2trThz5gysVmvB+6uRhshn/qQWaq+pRRujnDAMI7Rzim2tWZYVIhA+nw/xeBwXL16ETqfLcqMk0zmVSFNwHCfJO6RUN4a4I4OmMSiVQMUCRRNy2yDD4TDi8Ti6u7slPwbHcZiensbY2Bhqampw7NixrNa7QqiR15cyg4JSGWpFawwGA+rq6lBXVyfUP+zduzfL1trn88Hj8YDjuLzTOau1ta60VqJUN0ahNIZYQNA0BkUMFQsUVcnX4UBOTFKv9nmeh8/ng9vthl6vx+DgIJqamiSf1NQqcAS0ucrfDgJFi2gGuSJ3Op1wOp1oa2sTfpZIJIQ0xvLyMqanp4V2TrF4IHUQUp6/uLhXDqSkMVKpFOLxOMbHx7F///6CaQylij0pGxcqFiiqUKoNUmodQSAQgMvlQjKZxO7du9HR0VH2yVSNAsd8YoFs5PRKrTq0Su0UM2WyWq2wWq1oaWkRbk+lUlm21gsLC4jFYkI7JxEPpJ2zUCRA6Y05NwrB8zxCoZDwncyXxsgVEMTWmh7bWxcqFiiKI6XDQafTCcWN+QiHw3C73VhZWcHOnTvR29tbtNWtGGoUOOYTC5lMpuLnXO66aqFVFEMru+dyMJlMeds5I5GIICJmZmaEds7cFAYpzlX7Kp7USeSuK05jsCyLdDot/IymMbY+VCxQFKOcQU+F0hCJRAKjo6OYm5tDV1cXDhw4ILSzVYrakYVoNAqXy4XFxUVh2qL4j9w2xVs9DaFFdEauNfV6fV5ba/F0zsXFRYyNjQk1BcPDw3lFhFIUKqqUmsYQv1c0jbF1oGKBIjvkyiOTyQie+qWuMHLrCFiWxcTEBCYnJ9Hc3IxTp07BbrfL8vzUjCx4PB7Mz8+jvb0dR48eFSYuhkIhzM7OIpFIwGw2rxMQ5YxrzrfuVkZJg6Riayr13up0OqGdU7ze6uoqrl27BpvNhmAwCK/Xm3W8iCMRcrZzchxXVgSskm4MmsbYfFCxQJGNfIOepIYhiVjgOA5erxejo6Ow2+04evQo6urqZH2eShc4ki4NAIhGozhx4gTsdjtSqRQcDkdWe16uTTHJa5P+fnFuW+qGsNUjC8DmSENUA8MwMJlM0Ov12Llzp3B7Op3OSmMsLS0hGo1Cr9evS2NUYmsNrKVKqn2tpboxxGkM8X15nofFYska800FxMaAigVK1ZDiRXL1AJQ/6IlhGKRSKbz22mtgGAb79+9HS0uLIicKpToGeJ6H3+/HyMiIcALcv38/nE5nwfXy2RSL+/vD4TACgYCwIYiL4siGIH6PtsOJVQsxVO7Vtlxr5n6eRqMR9fX1qK+vF27LZDJZ0znn5uYQiUTA8/y6dk6Hw1GynVOKt0MllEpjxGIxXLp0CadPnxZ+TtMYGwcqFigVI8egJwBYWVmB2+1GIpHAvn370NnZqejJQInIQigUwsjICMLhMHbv3o3Ozk688sorFW3k4v5+QqE5BwzDZG0GyWRSk9HYarKZaxbKXVPK90AsIsW/G4/HBdEZCAQwOTmJVCol1M2Ijxtx2kspsVAI8TlDr9fDZDLRNMYGhIoFSkXIMcMhGo3C7XZjaWkJra2tSKfTZZkyVYqcBY6JREKoS+jp6cGhQ4eEAjQ5Ixj55hxwHCdcUYbDYczPzyMUCoHneVy+fDmrBsJutyt2ZbwdTtBaiIVqNm2GYWCz2WCz2bLaOUnNDBGdPp9PSHsR8ZBMJoWNWs3XLI7eVJLGEHdj5FpbU6qHigVKWZTT4VCIVCqF0dFReL1etLe348yZM0gmk/D7/Qo962zkKHBkWRaTk5OYmJhAc3MzTp8+vW7stdJdFzqdTggtE4Mgr9eLxcVFdHR0CKOax8bGkMlkYLPZsgSElJD0RmQjX+XLiRJX+MTWurGxUbiNZVkhahUOh7G8vIxUKoVz586tG+/tcDgUex9KtRZL7cYQQ9MY8rH5zhQUTRB3OIjDgeWctDOZDCYnJzE+Po6GhgacPHkSDocDALKGSClNNZs4z/OYm5uD2+2GxWLBkSNHsvLHueto4eCo0+mwY8eOrEFJiURCuKJcXl7G1NQUUqlU1qRFpVo5lWA7pCHy1SwogcFgyGrnHB8fRyKRQHd3d1YEIhKJZIlOsYiQ45ip1IdESjcGERE0jVE5VCxQipKvw6HcLxXP85idnYXH44HFYsHhw4ezCvqAwj4LSlBpZGF5eRkjIyNIpVLYs2cP2trair4PWomFfLcRh8Hm5mbhdnFIWtzKabFY1gmISls5lWCjOTgquaYWV8AkHUAiCeLnIxadq6urmJmZEWytc7sxzGZz2RcTcr3eYmkMEh0VpzFWVlZgtVpRU1ND0xgFoGKBkhexSKi0w4HneSwtLcHlciGTyeCWW25Ba2tr3scgG7gaJ2WdTpflPlcKcW3Frl27JLtHaiEWAOmbab6QdLmtnFqwla/ytV6TrJvv+C4kOnOPmcXFRcRiMRgMhnVpjGLtnEo7nIqLKMXwPI/p6Wm0tbWtO6Zz0xjRaFS2SMpmg4oFShbiDoehoSHYbDb09PSUfdIKBoNwuVwIh8Po6+tDd3d30asG8jM1WtSkbuLpdBpjY2OYnp5Ge3s77rzzzrKusNUwf5Kbcls5rVYrWJaFz+fL28qpFNslDaFFZCGTyZRVy5LvmCnUvQMAdrt9XRpDr9erYoeeD4ZhkMlkYDQahdddKI1x77334k//9E/x8Y9/XPXnqTVULFAAvPPlENclZDIZpNPpsk6SsVgMHo8HCwsL67oDiqGmWCjVOslxHGZmZjA6OoqamhqcOHEiqy2tHLbC1MlirZyLi4uIRqN5WznJn0rNgQqxXdIQWokFOdbN171DvBTEhlITExNIp9OCyGQYBoFAQJjOqRYsy2YJpEJpjEgkUvG5YLNDxQKlYIeDwWCQXHSYSqUwPj6O6elptLa24syZM7BarZKfg1gsKE2hAsdcU6VyR1/nshkjC1IhmwEZF37kyJF1rZy55kBytXJSnwVlUdKUidhai4tvU6kUwuEwpqenkUgk4Ha7EY/Hq3IxLRepUY1wOJw112M7QcXCNoZEEsjAmtzixVKTIIG1L9n09DTGx8dRU1OD48ePZ11NSIWsqYZYyLeJ5zNVksPyNt+IaiXRshgrXysnMQciAkKuVs7tsHFvtJoFJWAYRqidWVlZgcPhwMDAQFbqKxKJYHJyEtFoFDqdbl0Kw263V/3ZlCMWaGSBsm2Q2uGg1+vX9S2LH2N+fh5utxtGoxG33XZb1syDciEtf2qJBbJOMVOlatnoBY5qIDYHkquVk6YhlEXOroRy1yWfdb7UF8dxiEajwnEzPz+PcDgMjuPy1kFIFZ5kJk2p+/M8TyMLlO1BuYOeSNFRLoFAAC6XC6lUCrt370Z7e7ssJ1K1xAJJQ4yOjhY1VZJjnY20cW8UKmnlFG8E26UzYaulIUqRyWSKdtiQqILT6cyKXCUSCSECsby8jOnpaSSTSVit1nXtnCaTad3nSM5xpSILsVgMmUyGigXK1iXfDAcpbZC5aYhwOAyXy4XV1VXs2rULPT09soYr1fBa4HkewWAQy8vLYFm2qKlStWjls7ARvB0qoZxWzlAohKWlJVXy2cD2iixouW655xOx8BTbWqdSqby21kajcV0EgrzWUmuHw2EAoGkIytaj2kFPZPMWh+q7urowODioSKUyaWFSCmKqFI/HYbPZcPz4cUU3gM28cW8U8rXlXb16FTU1NTCbzWVP5ayU7eLtQNbVKrIg18WHyWTK284pHu89MzMjtHMCgNvtFo6bfAW4kUhEELTbESoWtihyDHoC1r4gr776qmKhejFKRRZyTZWsViumpqYUPxHTmgVlIFX1JBQNZPf1k40gGo3K1sq5nbohtPI7ULpWQq/XZ9laA2vnycXFRbhcLuj1+nUFuA6HAyzLYmpqSijI3WqCXCpULGwx5Bj0RHwGPB4PeJ7H0aNHswqNlELumoVCpkqLi4uqbKi0ZkEZ8r2nUqZyVtPKqVU3hBab9laILEhFp9PBaDTCbDajv78fwNpnLa6fef311/HII49gYWEBFosFH/7wh3Ho0CEcPHgQhw4dQm9vr2zPp7e3F1NTU+tu/9znPod/+qd/km2dSqBiYYsgNlSSUrxY6DEWFhbgdrvBMAx6e3sxNzenilAA5BMLpUyVlJ4GqfY6uWtudaRe5cvZyklrFpRHy4iGeF2GYWCxWGCxWNDU1ISdO3fiox/9KH70ox/hG9/4Bu6++25cu3YNzz77LCKRCMbGxmR7LpcvX85Kxd64cQPvfe978cADD8i2RqVQsbDJKbfDoRArKytwuVyIx+Po7+9HR0cHgsEgvF6vQs98PdWKBWKq5HK5AKCgqZKaXRf5nqPSm46a0YzNFjmptJWTFFrabDbV5gJQsbCx1s1kMmhpacGf//mfZ90mJ+LuIAD42te+hr6+Ptx1112yrlMJVCxsUkjxYjqdrnjQE7BWk+DxeLC0tISdO3eit7dXuJpSa1MlVLNeKBSCy+VCKBQqaaqkVnqARhaUQW7BVayVk1TT+/1+TE5OCqPJc50FlSh60yr1wfO8ZukPLdbNtXouRCQSyZrCCZTuoKiGVCqFH/7wh3jooYc2xPeaioVNRrUdDoRkMomxsTF4vV50dHTkHZJUyGdBKSoRC4lEAqOjo5ibm0NPTw8OHjxY8spPzcgCLXBUBjVOnqTyvampCVNTUzh48KDQgVFoKqdYRFTbyqmVnwQAzSILGzmiEQ6HK3KnrZRnn30Wq6urePDBB1VbsxhULGwi5OhwYFkWk5OTmJiYQGNjI06ePLlOLROIz4Ja+dpyNvFMJoPJyUmMj4+jqamprE4NNSML22HjVhstHRylTOVcWlqSpZVTi3SAVmJBy4iG1CmbaouF733ve7j33nvR3t6u2prFoGJhE0BEwtTUFHieLznuudBjzM7OYnR0FBaLBYcPH8464eWDfHHVFAulIhlim2mz2VyRqdJWjixshHCl0my0NsZiUzmraeXUKg0BqC8WpLooKgHLspLWDYVCqrk3Tk1N4eWXX8ZPfvITVdaTAhULG5jcDod4PA6WZcvucPD7/XC73eA4Dnv37sWOHTskPQb5AqkVHizls0BMlVKpFAYGBtDW1lbRpqFFZMHv92N0dFS42qypqVHMdXA7RDPUFAtkfHs5a8rRyqlFZIF817VKf2gVWZBiMhcOh9HV1aXCMwKeeOIJtLS04EMf+pAq60mBioUNSKEOB4PBgGQyKflxgsEgXC4XwuEw+vv70dXVVdbJh9xXPOBFSQpd8cdiMbhcLsFUqbe3t6qTipoDq5LJJK5cuYKVlRX09vZCp9MhHA4LU/TEoWryx2q1Vnyy1iKyoMVVvhbrVfs6y23lZBgGXq8XyWSy7OFIlaL18Cotjl+paYhoNFowZSsnHMfhiSeewCc/+UnFP+9y2DjPhFKyw0FqwWEsFoPb7cbi4iJ6e3srnqRI1laroj93Ey9kqiTHOpVcLZZDOp3G6uoqotEourq6cODAAcHOmpyMOY7LynVPT08jEolULSBoZEFe5BIL+SjWynn16lWYTKayp3JWg9ZiQQvKSUOoUbPw8ssvY3p6Gn/yJ3+i+FrlQMXCBkBqh4PBYADLsgUfJ5VKYWxsDDMzM2hra8Odd95ZdIqbFNTsiNDpdEin0+tMlY4fPy7rl5S8r0qIBZ7n4fV64Xa7odPp0N7ejn379gFYExBidDpd3lB1NQJiq1/la7GmkmIhH6SVkxw/pLaItHKWmspZTSvndvNYIGtLLXBUo2bhfe9734YU/FQsaEw5HQ6FNu5MJoPp6WmMjY2hrq5unWNhNagpFhiGQSwWw/nz5wEABw4cQHNzs+wnafGVvZwnxuXlZQwPD4NlWdx6660IBAJlP34hARGNRhEKhdYJCIfDIdQ/OJ1OIWKylVG7wFFtsUDIPT7FrZyEQlM5xa2cREhIqY/Z6MZISiAlssDzPCKRyLadOAlQsaAZlcxwyN24eZ7H3NwcPB4PjEYjDh48mHUikQMpHQpyEA6HMT8/j3g8jltuuaXs+opyEEcW5EBcU9HX1yfUJqysrMiyhk6nE076BCIgyFUmERDktXk8HqGQspoaiI2KFmJBi86EUmtW2spJBERuK+d2jSxI9VlQqxtiI0LFgsqQDgeSTiDpBqndCWTjXlpagsvlQjqdrqozQMqaStYsJJNJeDweYQaF3W5HT0+PYusB2ZGFamBZFhMTE5iYmBDSPuLwb269h5yfj1hAkD5sjuPg8/kwOjoqpHJIu15uCkOu0c1asNXTEOJ1K9m4pbRyTk9P523lTCaTmo3F3gxpCBpZoChOvg6Hcp0XDQYDUqkU3njjDayurqKvrw/d3d2KfsmUSkPkM1VaWlqC3++Xfa1cyHteqVggXg8ulwtWqxXHjh3Le8WR26Kp9Can0+lgs9mg1+uxZ88eANkRiHA4DK/XK0QgNquAUDsNIa4jUhM5HRyltnKGw2FwHIfLly+XNZWzWrSKLJCLt1JrZzIZxGIxVU2ZNhpULCiMWCRUM8MhkUhgbGwMLMvCbrdjcHBQUm9wtcjdZig2VTKZTFmmSmqlPIhIq2TzXl1dxfDwMJLJJPbs2VM0orMRTJlKpTA2q4BQOw2hxXugtClTvlbO6elpBAIBtLe3r2vltNvtWVEIOVs5teqGkOrvEAqFAICmISjyI9cMh3Q6jYmJCUxNTaGxsREAcMstt6h28pIzsrCysoKRkREkk8m8qRM1B1eVu1YikYDb7cbCwgJ6e3uxc+fOkifKjTobopCAiMViQhGlWEDkFlFqLSC0SENokYLQwsGR53kYjUbs2LFD8lTO3E6MSlo5tSysBFDyuxwOh4XvwnaFigWZIV9yUrwIVCYSOI4TOhwcDgfuuOMOWK1W/PrXv1Y1vyeHWJBqqqR0fYQYqRu5OF3S3NyM06dPw2q1yrqGnFS6qYmvMgniMHUoFFonIJxOp/CZqb2hbvXIgpYzGnLXLDWVU45WTq3EAnHELfU+h8NhOBwOzbwgNgJULMiIHIOeeJ7HwsKC0Kcvbh8kJxCpJiJyUE1qINdU6cyZM0V9HzZSZIHneSwuLmJkZARGo1HSLI1ctBhRDch35Z0vTJ2b517IOhTMAAAgAElEQVRaWkIqlcK5c+fWmQXZ7XZFNlktWie1mtGghUiRem4p1spJ2jmltnJqVeAotbgxFArB6XRuyJScWlCxIAM8zyOdTq+LJJR7YC0vL8PlciGRSKC/vx8dHR1ZJynymGqOja7kar9SUyU1xUKxjTwcDmN4eBiRSAQDAwPo6OioeAZFsf9vRnIFxMrKCoaHhzE4OLiuUA7AuhoIOQTEdklDANoMdKpmzUpbOSORCOx2u+rvtdQLL+KxsBW+w5VCxUIVyNHhAKwdiG63G4FAALt27UJPT09etcswjKomSUB5aQgytMrlcgEo31RJ7chC7qaTSqXg8XgwOzuL7u7uim2yCZspDVHtmvlmHoiLKIsJiEJTF0utqRZapiG0WFfuOTBSWjkjkQiCwSB8Pp/kqZxyUI7HwnZumwSoWKgInueRSqWQSCRgNBqFnFe5X+xkMonR0VHMzs6is7NT0uwDvV5f1PJZbqSmIcLhMEZGRhAKhSoaWkXW0iKyQOpDRkdHUV9fj1OnTsFut8u6hpqoKVAKrVVIQIiLKMVTF/MVURY6ftQWYHK2MJa7ptaukUqR28qZTCbR0NCA+vp6yVM55UhbsCxbVhpiO0PFQhmIOxwWFhbg8Xhw6tSpsr/QLMticnISExMTaGpqwsmTJyVX2WoRWUilUgV/LjZV6u7uxsGDByu+MtEisuD3+zEyMgIAuO2227IKuKolN7Kgxol/I4dJGYaB3W6H3W5fJyBIkVyugCCbQ01NjSAgtKhZ2Kqbdr51tawdKGcqpxytnOVEFrazxwJAxYIk8rVBGo1GoZJWKhzHwev1YnR0FDabLctjQCoGg2FDpCHymSrZbLaq1lLLZwFY+0w9Hg9isRh2796tiL30Rm2d3EiIBURrayuAbAFBbMA9Ho8gIDiOg9/vB8dxsNvtim+qWtUsbKTpj+FUGL6oD7vrdyuybiGRUmwqZ7FWTnE3RrGLF5qGkA4VCyUo1OFQzqYtzuXzPI99+/Zhx44dFZ2A1I4s5G7guaZKlXQJFFtLjdHRY2NjiEajaGpqwpEjRxQzt8onFpTeyDdyZEEqpQTE0NAQ/H4/pqam1kUgSIhazo1Wq24IrWyX873W50efxxXfFfzl8b9Es02+6BuhnNZJKa2cwWAQXq83q5VTLCBIuldqGmK7D5ECqFgoSKlBT2RcdKmNbXV1FS6XC9FoFH19fVVfwapdsyDuhihlqiTHWoAyoVAyOtrj8Qj58fb2dkVdMHOLKDfTFf9GQywghoeHceutt8JisWRFIHw+X1YEQi4Bsd3SELnrzkfm8Zr3tbW/Z17D7+z5HdnXlcPBsVQrJzlGxK2c6XQaRqMR8Xi86FTOcDgspEa2K1Qs5CA2VCLqPl/xosFgENIT+Ta2WCwGt9sNv9+Pnp4eHD58WBZrVK1qFq5fvw6/31/UVKlaxAOe5Hx88ejo/fv3o6WlBZcvX1a8PoKmIZRBPNgpXwQiHo8LRZRiAWG327OKKKUKiO2Uhsj33Ts7fRbLiWW0O9pxduYsTnedlj26oJQpU6lWTq/Xi3g8josXL66byul0OoWJreFwWJi3sl2hYiEH4plQqsOBbPy5fbqpVApjY2OYmZmRZERULmrWLKTTaczPzwujWeV+LbnINQ2SEI/H4XK54Pf70dfXh56eHuGzytc6KTfbqXVSLUpNgBTnuEsJCI7j1hVR5hMQWnZDqE1uZIFEFVqsLWiyNWFoaUiR6IKaDo7iVs5gMAin04nOzs68Uzm//vWvIxQKwWw2w26346233sLevXtlby8FgNnZWfzVX/0VXnjhBcTjcQwMDOB73/seDh8+LPtalUDFQg4k3VDqi0ruw7IszGYzMpkMpqamMD4+jvr6epw4cUKRHJcakQVSiOnxeGCxWGCxWHDrrbcquiZQ/TRIAhkdPTk5idbW1rwiR422RhpZUI5yNtJiAoJsDgsLC0KVfW4KQyuxsBEKHElUYX/jfjAMgyZrk+zRhWIRWqUhIqXQVM6amhpcvHgRTz31FC5duoSTJ0+CZVkMDg7iq1/9Kt73vvfJ8jxWVlZw6tQpvPvd78YLL7yAlpYWjI2NZXlTaA0VC3mQetVpMBiQTqcxOzsLj8cDk8mEQ4cOCQOflEBJscDzPJaWljAyMgKe53HgwAEYDAa89dZbiqyXC4nmyDU6+o477ig4JY5GFjYncr2fhars87XpkejhyMhIVqGckpv5RqhZIFEFi96ClcQKAMCoN2IqNCVrdEHq5EclKGb3rNPpcPvtt+P222/H97//fXzta1/Dhz/8YXg8Hly7dg29vb2yPY+vf/3r6OrqwhNPPCHcJufjywEVC1XAMAzefPNN8DyvSMFfPvR6PZLJpOyPW8hUKRgMqt59UYlYCAaDGB4eRjweLzk6upp1ykELnwVga0cWSqUhqqGQgJicnITf74fBYMjq88+NQMgpILQaiy2+wp8JzcCsN4MBg2TmnXNOm70NY6tjsq1Jzi9aiCMpds88zyMSiaC2thY6nQ579uyRvX7hueeew/vf/3488MADOHv2LDo6OvC5z30On/70p2VdpxqoWKiAUCgEl8uFVCqFjo4O7Nu3T9V8m5ybdylTJTUnQQKVjY72eDzw+XySR0cD6lz1a5WG2A6otZEyDAOj0QiLxYL+/n4A7/T5kxqIXKMgUv9QjdPgRogsHG07ir1Ne/Pez6wv7jRbDlqKhY3iszA+Po5vfetbeOihh/Dwww/j0qVL+LM/+zOYzWZ84hOfUGzdcqBiIQ+FTvLxeFzYmLq7u8GyLBobG1UNn8mVhsg1VSpkcUx8FtS60pEqFkiNyNjYWNmjo8tZpxpyjyM1crPkM1Lr89JiqJPa5L6X4j7/XKMg4kSZT0CIiyilXM2qvXmS45OsyzAMnCblvQXIhq1FJEWKzwLP80KRt1JwHIcjR47g0UcfBQAcOnQIN2/exLe+9S0qFjYT6XQa4+PjmJqawo4dOwS3witXrqjqeQBULxbKNVUiJzU1xUKx1yfH6GhA/QLHQCCAoaEhxGKxrDkIYhtjinQ2mt2zWEC0tLQIv0cERDgcht/vx/j4+DoBQVIYYgGhRWSBfB+0WFeLegVAWmQhHo+DZVlFxUJbWxv27duXddvevXvxzDPPKLZmuVCxUAQyYGhsbAxOpxPHjh3LOmDUNkgia1YqFoipUiKRwMDAANrb20ueBMkXSQ7TFCkUu+IXj47evXs3Ojs7K9401Cpw5DgO165dQyAQQF9fH2praxGNRhEKhdaZCOUKCDnGYm81tIgsVNoNIUVALC0tYWJiAizLZgmIWCwm98soiZyFhjOhGUysTuDO7jtL3lfNtkkxHMeB47iSkQXxtFSlOHXqlDCtl+B2u9HT06PYmuVCxUIByNW3Xq/H4OAgmpqa8hozqS0WKllTbBC1c+dO7Ny5U/KXkwiETCajSG9xLvlqJFKpFEZHR+H1emUZHQ0oP4cik8lgdnYWyWQSBoMBZ86cgdFoRCqVgsPhyApfiycxzs7OwuVyrYWARaFrsUGMFLQqkFMaJQsci60p13pSBcTq6io4jsOlS5eKRiDkRK7IAs/zeNb9LFzLLvTU9qCntviGp5VYIN//UmtHIhGYTCZFPWa++MUv4uTJk3j00Ufx+7//+7h06RK+853v4Dvf+Y5iawJrewPpCNHr9dDpdAVTQlQs5GFkZASzs7PYvXs3Ojo6ihozbeTIgjh90tbWVpGpEvGTUKsjQhxZUGp0NKBc8SGZAzI8PAydTgeDwYADBw4AyO8fkW8SI8dx6wxiIpGI4DAnjkCYzeZ1+fTtwGYVC/nIJyBGR0eRTCbR3Ny8LgJBhiWR40AuAZHJZGQZiz0cGMabi28inArj7PRZfOJA8Zy7WlHLfOsCpcUCGU+t5DFw9OhR/PSnP8Xf/M3f4Ctf+Qp27tyJxx57DB/96EcVWe/ChQt4+umn4fP5YDabhc4ehmFw4sQJ3H///et+h4qFPOzcuRN9fX0lDyKDwYB4PK7Ss1pDilgQmyo5nU4cP368qvGqanZEELGg5Oho8TpyEo1GMTw8jGAwiIGBAdTU1OCNN96o6LmRK0kCx3GCRW0oFMLk5CSi0SgMBkOWeCBiUM1wvRYOjmqiVbGh0WhES0tLVgSCDEsKhUJ5BQQ5DioREHLUSfA8j1cmX0Eqk0JXTRd+M/cb3NV9V9HogpaRBSmFlWpNnLzvvvtw3333Kfb4RPRevnwZX/ziF7G0tITBwUGsrKwgFAohmUxiYmICyWQS999//7riTyoW8mC1WiVFDLSKLBQaYJXPVKm5ubnqk7ma8yg4jsPk5CQSiQT6+/vR3d2tyIlazsgCy7IYGxvD1NQUOjs7MTg4CJPJhHA4LJsg0el0gsNcR0cHgLWTXSQSyWrhI7nuGzduCPd3Op2KDszSgq0UWchHvqI/hmEER1UinsUCgoxrnpycRDqdXldE6XQ6i27KchQakqhCZ00nnCYnbkZulowuaCUWpHgsAOpEFtSAZVkYjUb8/Oc/B8uyuHr1atGLyNxaDioWqkCrmgVg/Re7kKmSHCid3wfeGR29srKCuro63HnnnYpPhKx2Ixc7RtpstnURHKV9FvR6PWpra7OKbuPxOC5cuIDa2lpEIhH4fD5hol5uCkOOwWZqsxFaJ9WA4zhJdTlSBcTU1BRSqVRRAVFtOkAcVSAtl62O1pLRBa0jC6VQK7KgNOR40ul0OHz4sHCuyv1OFUy7K/v0NidSTwxaRRaAdw70UqZKcq2pVBoid3R0U1MTGhoaFL8SrnYjD4fDQitkIcdILUyZiADo7OwU/k3G9IZCIYRCIXi9XiSTybyh640uILQqcFQyDZHKpPDW4lsYbBmESW8S1qz0NRYSEKlUSohC5RMQpENIivdAPkhUgQePyeCksK4/5i8aXdByDoaU1xmJRDa9WFheXkYkEkFdXR3uuece/OAHP8AzzzyDD37wg0JRY6mZSBv7zLDB0aJ1knypUqkUZmZmSpoqyYFSaYjl5WWMjIwgnU4Lo6Nv3LihSsqj0shCOp2Gx+OB1+stOXp8o8yGyDemV7xxrK6uYnp6OmvjkLt4jpDhMlhNrqLRWvn8lI2QEpCTawvX8DPPz8CDx9G2o8Kacm6gDMPAbDajubk5q/4nmUwKx0EgEEAqlcK5c+fyFlFK2Vj3Nu4Fj+xjfqBhABZD4cLqjZ6GCIfDVdV8bQQefvhhPPXUU+ju7kZzczNef/11/PCHP8QHPvABtLa2wul0oq6uDjzP4w/+4A/Q19e37jGoWKgCLSILAIQiFbPZXLEpUTnIXQxYanS0GsWU5a5DIiButxu1tbU4efIkHA5HyTXI76q9wZUSKSaTCU1NTWhqahJuE28cuf3/4vRFvjHOUrk4dxFvzL+BBwcfRK25fJMbrd5LpdZMskm8NvMavCEvXp15FYPNgzAbzKoVVYoFhN1uh9frxa233ipEosQRCHEkivwRC4h9Tfuwr2lfkdXyo1Zbdr51pQigrSAWPv7xj+PWW29FLBbD6uoq7rjjDvj9fszPz+PKlSsIh8NCgeOhQ4fQ19e3TrBSsZCHctIQag5ZIqZKPM+js7MT/f39qpw45YosiEdH79ixI28rp1pioZyr/tXVVQwNDSGdTuPWW29FS0uLpPddbetl8ZqVkHvlmc/CeHR0VDCRIkVfxNym1OYWSUXw+uzrmFydxPWF67ir+66yn+NWq1m4vngdE8EJ7G/ej4ngBN7yv4WjbUc1Cc2TmgWz2Qyz2bxOSJIaCHEkqpSAkLqukh4GhSinwHGzi4VTp07h1KlTZf1O7vFHxUIVkMiC0ptBrqlSKpVCQ0ODahuQXBbTLpcLFosFR48eLTinXafTqRKtkSJKkskk3G43fD5f2WZWQLZYUBs51ixkIBSPx7Ny3/F4HOfOncsKWzudznUulG8uvom5yByabE24MHsBB3ccrCi6oEVkQYmNm0QVLAYLHCYHTHqTEF2o1DWyGooJFCkCYmZmZl0tjBQBoZXds9T0RyQSQXt7uwrPSDnI99Zms+EjH/kIvvCFL+D06dNIpVLCcWY2m/HYY4/hD//wD9Ha2rruMahYqALyBZAaziqXQqZKCwsLqo+NrnS9ckdH6/V6pFKpSp+qZIpFFsRmUI2NjWUPqRKvAWytkdHiMc6tra1YWlrC6OioELoOh8Pwer2IRCKCC2VNTQ10Fh3OTp5FjakG7Y52jARGKooubKXIAokq9NWv5Yc7nZ0YXx3HW/63oON0msxoKGfNfAIitxZGioDQshtCahpisxc4ku8tAPziF7/Al7/8Zeh0unURnb/8y7/Ee9/7XioWpCL1xEAO8EqrhwtRylRJ7cLKSrohKh0drXXNQiAQwPDwMHiex8GDB7NOhOWihVjQohecYRg4HA44HI68LpShUAjnR87jzdk30W3rxrx1HuCBV9yvYG/tXjTXSPcC2So1CySqkMwksRRbEm6Ps3G8OvMqjuP4hhcL+chXC1NIQFitVmEOBhnWpGY3Dsuyki4CtkLNAgA88sgjsNlsMJlMeP755zE1NZVV0Dw/P4/6+vqC5zwqFgogJadNWk7k3Lj9fj9cLhc4jitoqqSmSVK56xFTJTI6+tSpU4KilYJWNQviosv+/n709PRUfeLc7GmIahC7UNY01WA5uIxd3bvQaGxEIpmALW6De8GNf/vPf8ORxiPrPCCKtc5qEZ6Xe80YG4NJb0JfXXbVudPkhFFnRCKVUP11KnWFX0hAECEZCAQwNzeHqakpQUCI/yhV/FhOGkLJiZNq8cYbbyASiSAajeI//uM/8Mwzz4BlWWQyGfA8D5/Ph9/5nd9BY2P+TiUqFqpELrEQDofhcrkQDAbR19dX1LlQ7cJKKWkIMjra5XJBr9dX3KWhdmQhk8lgcnIS4+PjBYsuK2U7RRaKMRWcQopNQa/TYzWzChgAxsmg39kPk92EW/vfqb5fWFhALBaD2WzOqn+oqamB0WjcMmmIeks9Pn/k8wV/fvHixU0ZWZCKyWRCY2MjGhsb4fP5sGfPHjgcDiGVJfYDUUpASIlk8Dy/JdIQAPDYY48hmUziC1/4Ah566CEYjUYkEgkkk0lwHIfW1lbceWfhKaFULFRJtRt3MpnE6OgoZmdn0dXVJVgFF0OLyEKxOgLiHhkOh2UZHa2WWEin0zh//jz0ej2OHDmC+vp6WdfYzpEFMXub9qLBml84Wg1WmPVmBJkg9nftB7B2EicbRjgcxtzcHBKJBCwWC6xWKziOw8rKSkWV95WglYOjFmJBy0JDsYAgkAgEOR5mZ2eRSCRkERBSIwtboRsCAPr7+wEAL774YkWfMxULBZDaWlep10Imk8HU1BTGxsbKNlXSomYhnzjJHR0th3ukGmIhGo3C5XIhnU5j9+7d6OrqUmQz2C6RhVLoGB3aHG0Ff35x9iJu+G/gtwd+G022JhgMBtTX12eJt3Q6jVAoBL/fL7SyigvnxFEIuTc8ubshfBEfWh3rC8iUXFMKUi2mlVi30GdWjoCwWCxZx0EpAVFOGmIriAVg7cLu0UcfRU9PD8xmM+x2O+rr69HQ0IC6ujrY7XbU1dXlja5SsVAl5YoFkhtyuVwwmUwVheu1TkNwHIeZmRmMjo6irq5OkkFRpWvJCcuyGB8fx+TkJJqbm2EwGNDd3a3IWgQtXByBjRVZKEYwGcSbi29iPjKPG/4beFfPu/Lez2g0orGxEXq9HoFAAKdOnSo6QElc/+BwOKqeeSCXCHtp4iU88tojePw9j+NI25GC99OidVLLroRyPp9yBYQ4lSUWEFLSEJlMBtFodMuIhWQyiaeffhoTExPC9yQej2N1dRUA0NbWht27d+Pzn/88PvKRj2T9LhULVVKOWCCmSolEAgMDA2hvb6/ohKBWe6F4PXK1L55qOTg4uClGR4sFmsViwfHjx8EwDAKBgKzr5IOYFon/r8aam4XhpWEsx5fRVdOFocAQbm2+FU224h0o4r5wcetevhHO4+PjyGQygokU2TDKcaGUSyxkuAy+e/27mA5O43tvfQ+HWw8XfFytIgtarMnzfNUiJZ+AEM9EyU1nOZ1OpNNpRCIR2O32ghGIcDgMAFuiwBFY++7cf//9WFhYwIMPPojGxkYEg0H88pe/xNmzZ/GZz3wGL7/8Mj772c8KcyQIVCwUQM5hUrmmSr29vVXlWrWqWbhy5QpWVlYUHR0t99CqcDiM4eFhRKPRLIEWjUZV67oQo8UgpI0Cz/OIpCPCREISVWi0NaLB2oCRpZGi0QXyGIUgA5RMZhOstVb0mfoEF0qyYfh8Png8HsGFUhyByDWRIsh1lf/y5Mu44b+Beks9Xpt5DVd8VwpGF7TauLVwjQSgSEQj30wUsYDw+/2YmpqC2+3OikCIC2qJWNjsBY5E8A4NDeH8+fN44YUXsrpT7rnnHnzlK1/B0NAQnn76aXz605/GP//zP1OxICfF6gdYlsXY2Ng6UyU51lRLLLAsi/n5eYTD4U0zOhpYOymMjo5iZmYG3d3duP3227MEWu4Vv1Js9TREOet4Vjx4c/FNvH/n+1FjrhGiCgONAwCAHY4dJaMLpa7yOY7Dj0d+jJHlEfzFsb+A1WgVXCh37NghPEYsFhM2jbm5ObhcLsEvQiwgrFarLJGFDJfBv7z5L+B4Do3WRsxF5gpGF3ie33AOjkquCSgjFvJBBERtbS3Gx8dx9OhRMAwjpDDC4TDm5+fhdrvxD//wD+jv70dbWxteeuklHD16VPZI6iOPPIK///u/z7ptx44d8Pl8sq5DjuH5+Xn4/f68DromkwkXL14EsFYM+dxzz2X9nIqFAlQzH4KYKo2OjsLhcODYsWOyhrHUGGDF8zxmZ2fhdrthNpthtVqxf/9+RdcEqhcL4uftdDoL1lOoNeRJLVGSu+ZGI5VJ4e3FtzG+Mg5PrQf9Df14c/FNGPQGrCRWhPv5o/6S0YVir+9rF7+GHw39CAMNA7g0fymvQyTDMLDb7bDb7YJTHcdxiMViQgTC6/UiHA4Lka75+XlwHAen0ykIfqnvcyAewBvzb+CG/wYarGs27bXm2oLRBSLAtLjKV7tmgdQraFGfAayJFL1evy4CsX//fjQ2NuJXv/oVRkZG8IUvfAGjo6Po6urCmTNn8NRTT8n2XPbv34+XX35Z+L8SnwF5f/v6+uB0OvHZz34Wf/EXfwG73Q6r1YorV67gueeew/HjxwGspZtzXRypWKgSg8GAZDIp/F9sqkTGLsv9RVA6srCysoLh4WGk02ns27cPJpMJb731lmLrialGLKyurmJ4eBjJZLLke09OxEq3i+l0ui0dWZDKZHASs5FZtNhacHPpJmxGG6wGK/S67Pe+o6YjSzzkUux1zYRm8MzIM1iML6Ip0YSXJl7CHW13wGos7dKn0+kEF0oCcaG8fv26YDYWjUYR4kP4ZeCXeH/v+3Gm9wxqampgNpvzPu6bi2/igZ8+gFZ7KzJ8BkadERkuA6vBipXESt7oglZiQcvhVWrDsiwYhim4dk1NDe677z6YzWacP38eIyMjCAaDuHbtGmZnZ2V9LgaDIa+9spyQ4+vQoUP40pe+hG984xv41Kc+hba2NiQSCVy7dg2Dg4N4+OGHMTU1hbm5Odx9993Zz1PRZ7gNIFf55ZgqVYtSYkHsYrhr1y709vZCr9cjGAyqlvaoRCwkk0l4PB7Mz8+jt7cXu3btKikA1GxrVLtOYaNFFkhUwWqwosXeAs+KB7F0DB/d/9G89y/1/Av9/Mm3noQv5oMeegTiAYwujxaMLkiBuFDq9Xr09PSgrq4OmUwG373yXbzqeRX/PvPv+Gbwm+jUdcJkMmWlL5xOJ0wmEx67/BiW4ktYSayg3lyPheiC8Ph6Ro+rvquYjcyi09kp3E6O/+2QhtCyA0Ov15d8j4khE8MwqKurw7vf/W7Zn4vH40F7ezvMZjOOHTuGRx99FLt27ZJ9HWDtmP7kJz+JwcFB/PKXv4TX64VOp8NnPvMZ3HfffcLn/9RTT607N1KxUIByvqjBYBAXLlyQbKpULXKLhUwmI7QU5nMxlLvosBhELEhJD4gHPjU0NJRlLS2OLCiJuGaB+OKTliWHw6HYiXIjRRZIVGFn7U7oGB0aLY24uXQTuxt2o8ZcXktaodc1E5rBT90/BQMG9dZ6BBNBLMWXyoouECZWJ9Bb25t3xLg/7ser869iIb626f9b4N/wi4/8ApFIREhhEBfKGXYGL469CLPOjAyfwcf2fwx39WQLF5vRhnZH9kRDckxuB1MmrcVCKZQ2ZDp27Bi+//3vY2BgAAsLC/jqV7+KkydP4ubNmwVtl+Xg0KFDOHToUNH75J5/qVioEGKqNDo6Cp1OV5apUrXIVbNARkeTuoRCo6OJ94EaTnZSawmWl5cxNDQEjuNw2223lV14RB5babFAnCJv3LiB+fl5tLS0IBAIYHJyEizLriuos9vtGy4yUIpizzeVSeHfh/4dDBhwNRxSmRQcJgcmghPwLHtwuO1wWWsVOi5IVMFhdMCgMwAM4I/54Vn2lBVduOG/gc//6vP477f/d/zeLb8HILsb4sWJF3EzcBNpLg0AeH32dby59CYOtx7O+u6k02k8+PMHwfEcbHobImwEz954Fnfr70ZdTV2WeZCOyRYFWkUWtEgJaCUWpA6tCofDsnnI5OPee+8V/n3gwAGcOHECfX19ePLJJ/HQQw8psuZLL72El156Caurq7BYLKirq0NDQwN0Oh1+67d+q2BUg4qFMsk1Verv74fX61VNKADyRBbKGR1NvsxqiAWyVqGQaCKRwMjISNUDn9RIQ/A8D5Zl8fbbb6O+vh4nT57MOkGRlr5QKASfzwe32y2MdSbioaamBhaLpaz3fSOJjWsL13Bu+hxqzDVotjULG6PdaMdkaBKHWg+t2yxLkfv6ZkIzeG7sOeh1evDgEU1HoWN08Mf9qLoo9QsAACAASURBVI/V4zdzv8Fd3XchmAwiEA9gV13hEO+Tbz+JydVJfP/G9/Ghvg/BanynG8IX8eGl8ZfgDXuzfufLZ7+M//sH/zfrtpvLN3Fu/hwsRgtMBhOceifm2XmMm8dxxn5m3fhmsWDU6/WaFP1tR4vpUqg9cdJut+PAgQPweDyyPi75bJ955hn87d/+LfR6PVpbW4WOoFQqhYmJCfT09GDXrl15jwUqFgqQ74tKCujEpkrBYBBTU1OqPje9Xi+0V5X75U4mk3C73Zifn8fOnTsljY4mXyo1rjzI4+fOmuc4DhMTExgfH0dLS0vVbagMwyjaqRAKhXDz5k2k02ns2rVL8GUnZloMw+Rt6YtGo0I4e3p6GpFIBAaDIWszKTWVkTzWRuDtxbdh1BvBMAwGGgZwW8ttws9MelPZQiHf6/rV5K/AgIHT+E4vvFFnhNVgxQ7bDqE24ieun2BoaQhfPvll1FnWR9Bu+G/g7PRZNNuaMbE6gefHnsfv3fJ7glggUYVUJtsQ7fXZ13HFdwWHW9+JkvyvN/4XWI6FzWQDz/Nr0Q4A3xv5Hv7LH/0X4f9iEymxCyUADA8PC597tS6Upaj0fFItGz0NobZYSCaTGB4expkzZ2R9XPLZPv744zh+/Dj+8R//MW8UmZDvOKBiQQLFTJXUaGPMhRzkLMtKro8Qj45uamrC6dOny87vZzIZxb3j86UH/H4/hoeHZR/4pESnQjqdhsfjgdfrRW9vLzKZDGprayX5LZA+f3HYM5PJCPnwUCiExcVFxGKxLB988jc5JjdKZGEqOIXXZ1/HrtpdCCQCuDB7Ae/qfte6DohyyX199+66F42W/PndTmcnOpwdmAxO4uLcRQTiAZz3nseH+j+07r5Pvv0koukoemp6MBedE6ILPM8jnA7j11O/xnRwOu86f3fu7/D87z8PYG32w9nps+B5HsFkMOt+U8EpXJ6/jBMdJwDkd6EMBAK4efMmTCYTFhcXMTY2JrhQ5ppIybW5k2NTq9ZJtZGahohEIoKYV4IvfelLuP/++9Hd3Y3FxUV89atfRSgUwic/+UlZ1yHfmWQyiQ984AOCUMj18yh27qBioQhSTJWIz4Kaqlx8pV8KOUZHk5CoGh0RpJ2J9L0PDw9jdXVVkYFPclpL8zwvmPs4nU6hhmVpaakqQaLX61FbW5vl0yF2oROP8rXb7XA6nYLAKMfSWAlemXwF7hU3dtftRqezEzeXbuL64vWsK/Byyfdetjna8OGBDxf9vf839f8QSobQZG3CK1Ov4FTnqazowg3/Dfzn9H+i3lIPhmHQbH0nutDIN8JmtGGgYQAsn//C4FXvq1iMLqLF3oJmWzO+c+93EE6F193PpDPh0I7ChWUMw8BoNMJgMKCvr094zfF4XPjMxS6Uua6DhVwoS0G+2zSykA2ZpKsUXq8Xf/RHf4SlpSU0Nzfj+PHjuHjxInp6emRdh7zWv/7rv8bLL7+MAwcOYN++fWV93lQsFCCTyeDVV1+FzWYraqpE1KmaCplhGEl1C2R0dCgUwsDAQFWjo9XsiGAYBhMTE5ibm0NHRwfOnDmjSIeJXO6K4XAYQ0NDiMVi2LdvH3bs2CG8z0o4OOazsU0mk4J44HkebrcbIyMjWZGHajaTcpkKTuFXE79Cik1hKjSFZlszOJ7DC2Mv4GDLwbKjCz/3/BxGvREHbQfLfv4kqtBqb0WduQ6vz72OP/vVn+FfPvgvMOnXjqsn334S4VQYdc46Ic3Ag8f3b3wf/63uv8FsMON/3PE/cKD5wLo0BADUWerQbFsrstXr9HhP73vKeo5i8l3t2Ww22Gy2dS6U4rkHxIUyd3CS1WqV1FkEbC+xILXAUcm5ED/60Y8Ue2wxJJX2k5/8BD/84Q9x8eJFnDhxAk1NTaitrUVdXR3MZjN+93d/t6BnCBULBTAYDDhy5AgcDkfRL5o4JaDmeNdiYkGJ0dFqWEzzPI+FhQVkMhmsrq7K7nyZS7WRBZZlMTo6iunpaXR3d+Pw4cPrTkBq2T2bzWY0NzejubkZ8/PzOHDgAIxGoyAgZmdnhc0kt/7BbDbnPcZ5nsdwYBj99f3CpprvPvn49eSv4V5xI87GEU1HcX3hOmrMNbi5dBPPjz2PPQ17sKdxj6TX5ov48OLEi9AzenTtLj+6RKIKnY5O8AyPxegiRpdH8cLYC/jwwIexmljFG743YDFY4I/7hd8z6AwIxAMYN43jbuZumA1m/Nbu3ypr7UqQEqUUu1C2tbUJvycWEKTmRa/XrxONuZ+5lt4OWnVDSDknKt0NoRbkc62rq8OnPvUp+Hw+XLp0CdFoFNFoFIlEAouLiwgEAlQsVEJNTY2kPHOx+RBKkW/NzTo6Gnhn4FMkEoHRaMS+ffsUn/RWaYEj6YgZGRmBzWbDiRMnCg6a0Wo2BADhalRsaUwKKEOhECYnJxGJRNYZCpEhOq5lF7597du4v/9+vHfne8taO5lJotZci0ZL41rongH2N+2HQW/ApflLGF8dR2dNJ+zG0l1EZ6fPIhBfmxB60XcRh0zF+8PFkKiC1WDFanIVs5FZhFIhJDIJfPf6d3Fv372os9Thu/d+F5FUZN3vMzwD/02/4pvoVd9V/ODGD/A/7/qfFU+cLORCGYlEhBQGcaHMLZoltsdatGtWM1SvmnWlFEirXeCoNI8//njBn6XT6aICiooFGdCqyFG8eSs9OlqpNETuwKdDhw7hwoULqmywlRQ4RiIRDA8PIxwO45ZbbinacgpoIxaKWVyTEHVHRweAtZOmuP5hfn5eGOP7i+Vf4O3A2wALHGs7hhqL9JNms60Zuxt2Y3/jfizFl+ANe3G66zQarY14evhpzIXn8Pbi2zjecbzo4/giPrzqfRUtthZk+AwuLFzAztadkp/HTGgGFr0FekaPWDoGd8ANnuNRb6nHeHAc52bO4T2970F/fX/e32dZFueYc4puojzP45+u/hN+M/cbHO84jnc3vlu29XQ6nSAAxZ+52ESKFM0CwFtvvZXlAaG0wdxG9lngeR6RSGTLjKcmTE9P48KFC7BYLHj/+98Pi8WCpaWlkqKIioUiSD3RayEWSGFlNBqFy+XC8vKy4qOj5YwsFBv4JGfhYTHKiSxkMhmMjY1hcnISnZ2dklM7uceQWuJB6hp6vR51dXXrDIWuTF+BZ8aDNlMbhuaG8N0Xv4szbWeyog+FvEXmwnO4NH8JrfZWxNk4fjP3G5gNZpydPosGSwOsRisMOgMuzl3EgZYDRaMLJKqwv2k/ePC4tnIN11au4W7cXfB3xJzuPC20a573nsdwYBgDDQOwGqyYCk3hmZFncGfXnTDpTRgJjOCZkWfwxTu+CIPOAJPepIpV93nveVz1XQXLsfjBjR/gjhN3KFo7kK9oNhAIYGhoCHV1dYJojMfjWV035LOXMxKwGQocN/t4ajEXLlzAl7/8ZQSDQVy/fh1zc3PQ6XT45je/if7+fnzsYx8r+LtULMhAvsmTSsMwDGZnZ/H222+jo6NDldHRcr3GYDCIoaEhJJPJdQWBcq9VDCmRBdJNMjw8DLPZjOPHj5cVltyMUycNBgMurVyCzqzDnqY9MK2a4DV70dLZAjbGYmFhAaOjo+B5HhaLBSzLwufzCSOdr/iuYDG2CIvegpnwDKaCUzAbzMhwGdRb6vGu7ndBx+gwEhgpGl0QRxUYhgEDBnXmOlxdvQp/zC8UFJZ6L2rMNWA5Fr8c+yX0jF6wmO50dsK17MK5mXO4p+ce/ODGD/Ca9zW0OlrxH8P/gb8/8/c43LzWuaHU5s3zPJ54+wmkuTS6nF2YDE7ipemXcIf1DkXWKwTDMDAYDOju7hZuy+26mZ2dRSKRgM1mW1dEWemGv5ELHHmeV7zAUU1WVlbwyCOPoLu7Gw888AAefPBBWK1W6PV6NDc341//9V/xsY99rKD5HhULRShnTLVakQVyRR4MBmGxWMrevCpFjjREKpWC2+3G3Nwcdu7cWXDgk1qdF6U2cnHr5p49e9DR0VH2RqyV50E1759r2YWrvqvocHbAG/bi8vxl9NX1wZP04L39a7ULpBrf6/VicXERMzMzQjFdRp/B3Q13gzNy8Ef9uKXpFoSSIfDg0WxrhlG/FpGptdQWjS5cmL0AX9QHk86EpfgSACCWiCGWjOHi7EXcv/t+ya/p8vxluJZdSGQScC+7hduj6SiedT+LRmsjLs9fRiqTwv+++r+xFF/Ct699G99+z7cBKPc5kqhCk7UJJr0JBsaAH4//GAf3HVRkvULkKzTM13WTSqUEAbG6uorp6WmkUimhbVdsIiVFBGhZ4Fhq3UQigXQ6vWVqFrxeL65fv44XX3wR4+PjgkDU6/Xo6urC9PSahwgVCwqillgQj46uqalBU1OTagdyNWkIUnjp8XjQ0NBQ0hBKrTREochCJpPBxMQEJiYm0N7eXlXrphaRhRuhG1icW8RvN/x22b/L8zxemngJK4kV1FnqcN57HgvRBegZPV6ceBEnO0/CbrQL1fj19fUIh8M4cuSIUExHrkRfmHgBwZUgdjp2gstwmI5Mo9vWjfGV8bXPmOcQiAVww38Dx9qPrXsuAw0D+OMDfyz837XsQiaWgY21YXdDeb3vXTVd+Nj+j4HH+s+73lyPH4/8GAk2gTZ7G171vgq70Y4rvis47z0PHZSxXhZHFYhYarY1wxv04lX/qziG9e+JUkj1iTGZTGhsbMwackTadsPhMJaWljAxMQGWZYWBaeK5J7lrbOQ0RDi85pOx2cUC2fxDoZBQ1Onz+WCxWITz8OLionCOKxRtpWJBBpTuhsg3OnpkZETVTajS1MDy8jKGh4eRyWQkD3xSUyzkrkPcIg0GQ8HBWuUgd41Ckk3CpDcV3LxWEisYCg9hbnEOJ6InsMNewH2O58HMzYGJRMDX14NvaQEAxNgY5iPzaLW3YnxlHEuxNVMpf9yPYCKIucgcdtfn36jFxXTL8WXMzs2iv7MfTaYmsKss5uJzWFpeQmO8EWazGXaLHY2WRsSiMWQyGfznzH/CrDfjdNdpAMD+5v3Y37wfwNpQqJ95fgYbZ8MnOj6BWxpvKfo+vTD2AjJ8Bvf13wdgLeXwiQOfyHvfawvX8M2r30SrvRUTwQlwPAeOXxt69X9u/h/8sfOP8/5etVyav4TrC9eRyqx5URBibAzPzz+PP+f+XLCFVppqfGLEbbvA2maTSCSECARxoeQ4Dg6HIysCwbKsJsZhUtIQpDOrGlv5jQA5V7S2tqKvrw+PP/44+vr6hBqxN954A88++yze857i3iBULBRB6zREsdHRavgeiCk3NZBIJOByubC4uIi+vj709vZKPiloUeAYj8cxMjKCQCCAgYEB2dwi5RQLSTaJh88+jDNdZ/DbA/mjBm8tvoUgG4QurcNV31Xc23fv+jsFgzD87GfQDQ+DicfBO53gDh0C+8EPwm6x4+9O/R1SXAoP/uJBGPVGdNV0YSG6gDpLXUGhkMt573lMh6fRXdONOOJoqGvAoHkQFoMF//XIf4WTdwoRiLAvjJ9N/Ay/Dv0aNosNDWwDupu7syZwvjL5CuYj8+DTPIZrhnE7bi+49mJ0Ec+P/X/svXd0XGe97v/ZZZpmRr3akmzLvceJU22nOQ4OIQRySHLuCSFwIIdLaOHAulw4wIJFCJwf/cAllEDKJbkphwDpEDt2QuzYcS/qsiSrd2mKpu7y+2Nrj2eksTSSRlKKnrWyVjya2e/u7/N+y/MY0ssXl1x8fsKEMbGZUQXBLtDua8cqWYloEdyim6PdR7lUvJTtbE/puCeDYmcxt6++HU1PvNeHhoawY5+0b8Z0kE4F2njfk8IREmqqUMaLSPn9flRVpb6+npycnFgdxEwLh+m6nlJkwev1Gq6gc6iCmk4sXbqU//k//yf/9V//RTgc5uzZs9x77728/vrruN1uvvKVrwDnl/yeJwtpgCzLMYOgdCDe2fJ81tGSJBEOh9M25kRIlZzEe1BM1fBptiMLjY2NnDlzhuLiYrZt23ZeUZKpIJ1k4bXW1zjRc4K+YB/XLLqGLFti4dVgaJAjXUfIsmRR5CjiZO9JLiy+MHGy1HXkZ59FOnQIrawMvawMYWgIac8edIcD9YYbcFgcvNn8Jqd6T5Fly8IqWbFJNv7W9Dfu9d3LQvfCCfe1YaiBYmdxgtphhiUDi2ihM9jJktIlCX4Iz9Y8i9Ao4Il4+EfDP1h5dmVMjVCxKbxQ+wK5tlz6o/280fMGt2u3n3fV/Xrr6/QGehEQeK3lNW5bfdt597Oyr5IjXUcIq2GOdB4hpISwiBY0NIajw1hECy/1vcRn9c+mffJelLWI/3XZ/xrzeWNjI+FweNbJwkymA+JVKE3dD13X2bt3L4WFhUQiEdra2vD7/bHrHp/CmKzz6ngw32MTRRbebZ0QALfddhsOh4P//u//Jj8/n3379rF9+3a++tWvkp+fP66z8DxZSANkWY71KU8X8dbRprNlsos320JQoihOOF684dNUPCjix5oNshCNRmlsbMRms6XVoCoeycjCVKy+w0qYv9T9BVEQafe180rTK3xk1UcSvnOy5yT9gX5yLDlk27JpCbWMiS4InZ2IVVVopaUwkovVc3MhEkE6fBh12zZwufj1sV8TVsIxg6ZcRy5d/i4eOPoA9111H6gqQlcXcksL1qEh0DSIW4F99sLPElSCAAxHhsmwnFstZloTc8A9gR6qBqtYWrCUqBbFi5f1G9Zj02x4vV6eqHqC1sFWSq2lOHUndcE6/nrkr1y15KoxDpw9wz3sbdlLfkY+AgKvt77OVeVXnTe6kOfI45aVt+AL+/j18V9jl8+t6M10RFOwiVO9pxIcM2cSc+X+OBcraF3XKS4uji0oTOEwM4URr0I52jjtfMqjE8EkC6lEFiZS8H0n4qabbuKmmxKLgzs7OxkYGBj3nT1PFsbBZNIQ000JxFtHL168mIqKinGZ72y3a0qSdN7oSSAQoKamhoGBgZjh03RePDNNFkKhEDU1NQwNDZGfn8+mTZtm7EU5WeEnRVPY27KXTUWbyHOcKyJ7rfU16gfrWZy5mN5AL881PMeOJTti0QUzqpCXkYffaygRFjuLx0QXBL/fSD2UliaMq7tcCP39CIEA+4ZOcqznGIqu0OHviH0nqkV5vuF5/n3Nv1Fw6DRiczMZQ0MU+P1IgoC6dSuM5EGtkhWrZCUQDfDo6Ue5dMGlXLPomqTHfLTrKEPhIRa4FqBjSEyf7D3JNYuuISgGqY5WU1FcQbGzmMHBQQaHBtnduptipZhwMBzTAsjMzGRP7x56/D2sLTRqHar6qsaNLpS4Svi3C/6NqBplee5y/NFEFcdQMERHWwdLs5emfA2ni6kqOE4Hc0FQzGc8ftKOFw5bsGABQExPxkxhNDY2Mjw8jNVqHROBSKUQ2ayTmOj9/m5TbzShaVrCgkUQBD7ykY+wdu1afvvb355XsGqeLKQB06lZ0DSNs2fP0tDQMCnr6LmoWRg9nllTYXYNpEvrYaZ0FuLPdWFhIUVFRbhcrhl9SU42DVHVV8XfGv+GP+KP1SWYUQWLaMEm2yh2FdMw2JAQXagbqKM/2I+AQFewC++QF4fDQVSNUtVXFSMLem4uemYmwtAQelxFuzA4iJ6djZ6ZSXGwmBuX3oiijb2nXRYXjiMnEOsb0crLiWZnE2lvR6ypAZsN9ZpEQnCo8xBVfVUMBz1c2hQh63Q9RCJo69ahXnwx3dYIx7uPU+IsiWkp5DvyOdR5iI2FG3n17Ku0elvJc+TR6mtlODyMKIn0CD1I5RLbCrfFVqGN3Y08V/0cmqbRpXRhtVnJ0DLYdWYX20q3UeIuOe95t0iWpL4PHo+H06HTuKyz5w8wF+2EcxXNgIk1LMyoQvzEPdq6vbu7m0AggM1mGxOBGC2eNhkTqXdbGgKSn2+LxULpyAJiPg0xg5gKWdB1nd7eXmpqapAkiQsvvDChHWkizDZZiJ/ATcOnmpoabDZb2g2fZoIsDAwMUFVVha7rsXN9+vTpGVdTnAxZUDSFN1rfYDA0yKHOQ1y64FJKXCUJUQUwDI5cFldCdGFR5iJuWXkLAJVKJQsXLozVuRRmFMbG0PPz0S68EOnVVyESQXe70QcHEIMh1J07wW6nwl7Bz6772Zj9e7L6SdZay3DvrUYrKQG7HYJBNJsNrbAQobkZvN5YeiMQDbDn7B5ccgYdVW9ypKmG7foSkCTkujrEqioqd1QwEBrAIlroCfag6zptvjYyrZlU91eDDhcWnytm9OpeFKtCXm4emq4laAGciJxAd+nIyPSoPSjDCpFohFA0xO9f+T07y3dO2oFztAPkbEDTtFk1pTPHnG2CMh1b7GQqlIqi4PP5YuSxo6MjJl1ukg2zAyOVY/X7/e+KyIKu62PeQeZ7yXzXDg4OTpiGnScL4yDVl8Rk6wfiraPNsP1kX0izXbNgdkPEeyOsWLFiSkJFE0EUxbQVjIbDYWpra+nu7h7TlTEbtRGCIHCi7wTkG7oB8RgKDbGvbR83LrsRMKIKtYO1rM5bTeNQIwc7DvKhFR9id/NuFE2hydMU+62ObngltL/JzoqdFLuKKXYZhWNqi0pFfkWsgHA0lBtuQM/IQHrrLRjo59mcbnK3XsplV1xx3uOo6a/hRwd/xArnIp6IXAu2Udu22RA8HoRIJKZkcKjzEC3eFlZGsujp87O72MbF9oW4BRt6NIpYW8uqVSW4N55LEXT6O3ms8jFcVheLMxezpXQLt3N77O9NTU0Eg0HWrFkzZh+X5SzjY+vGtkfq6JQ6Sim1lCZ14BzPjXEq9SXTxVyt8mfb0MnsSEjX+ZVlmZycnIRJL16F0uPx0NraSjgcRhAEKisrY9c/mYjUuyUNIQhC0nNsfmYWy5v1CvORhRlEqpGFeOvosrKyaVlHz4XEtN/vZ//+/dPe94mQDgVHXddpaWmhvr6evLw8tm7disPhSPjObAgmDQb6eLN7P722Xsozy5E490L63Ynf8Wz9s2RYMthWto03Wt9ARMRhcVDkLIpFF+5cdyc7K3Ym3f6Gwg1JP08WzWjztQGG5oB6/fWoW7fS0l3LkZa/4rD7WBX1kS0l15V45NQjDIWGOKkE2W1fxXUDDvSRqnZBEBLSGBAXVbC6sAwMsyBioyprmIN6C9cJy8FiQXc4KG8aYMHO22P7/PCphw2xpmA/vqgv6XGd72UWr8twqPMQ2bbsMeJN53PgbGpqiuXB48mDoiizThbeSzULMx3NSKZC2draSkdHBxkZGQwMDHD27NmYCmVmZiatra3YbDY8Hs87Og1hXtO7776b06dPU1paitvtjhGq7OxscnJycDgcNDc3T1iQPk8WxkG6dBbiraOzsrLSYh09W2kIXdfp6OiIOVqOZ8ecLkx3xT80NERVVRWKoowrBDWjHhRdXYgHD9Jx8DHC1hbOerqozNnAhjJDla/d184LDS/Q4evgscrHyHPkUTtYS7nb0ObPc+RR1VcViy5MBsnu24gaYVfTLnR07lh7h2GS5HBwKNJIkAjDwT4OdRxiXeE6SlyJuf2a/hpeaX6FPEce3oiXBy0n2O4pRmhtRVRVbF1dCGVlqJdfDiM1K4c6D3HWe5blOctRhWYkBFyClT1aA5cK5bgFG4KiGKmMEZz1nuWtjrdYlLmI7kA3u5p3sTJ35Zjjmei57A/281T1U+Q58vjyJV+OyUvHYzIOnPGrUPM3MznJzVXqYy6iGXOh3igIAna7nSVLDPdSXdcJh8Oxa//yyy/z5JNPEggEKCgoIBgMcvHFF7N582bWrl07I4uk73//+3z961/ni1/8Ij/72dgU4FRg3kMrV64kGAwSjUbp6OigtrYWv9+P3+8nEAigaRqaplFWVpbwu9GYJwtpgCzL6Lqe9IGbKevo2SALZhtnKBSivLycrq6uWWHaUyULpvdEZ2cnS5YsYcmSJeO+jERRJBqNTmdXk6OvD/HJJ+lrq+OEvZvCiBWhsY23gg+y8l9WY7G7eLzqcXoDvSxwL+Bo11EeOvmQoZAonOs+UHSFQ52HuDx/E6V/fRX5L39B8HhQL7qI6Mc/jrZ+/Xl3YXRkoXagNqYSWDtQy/qC9bR4W6jqrWKhayH+qJ+fH/45Rc4ifrbjZ7it567zI6ceYTgyTFlmGVbJyolQM69ckMmOviyEtjbC+fko112HvvRcx8CRriPIomykTmzDSM4gBMP4HCJVejeXerNA19HWrYvt756ze/BGvJS6S5FEiePdx6kdqE1Qa0yl/mN/2366hrsYCA1wrPsYlyxIzZQpmQNnZ2cnzc3NsVVoc3NzylLGU8VcRRbmombh7SD1bJIHu91OQUEBP/nJT/jRj37EP//zP5OXl0dWVhaPPfYY//7v/859993HF77whbTuz6FDh/jtb3/Lhg3Jo4RThTnpf/nLX451QGiahqqqKIqCqqpEo9GY38fSked3nixMEakUqJm5PkVRYt0AM20dbYbqZ2JFEG/4ZLZxmqprs4HJkgVd12lra6Ouro7s7Gy2bNmSUkfJTNlFCydOILS0cGSpjQGvwDI1D7czg7ruWv6x+/+RtfxCnq19lgw5gzxHHgPBAap6Krkzfzt4h8FuRysuAtmCLEjYvv8DrC+8hi5JYLEgP/880oEDhH75S7RNm5IeVzwiaoQjnUewS8Yq/nDnYVbkrOBw12FCaohMWya1A7Uc6z5GviOfvWf3xkyazKhCli3LUOazOOgL9vH7/r9x9U2P4uvopL+ri8XLliWMefvq2/FFzqURROdBpDfeQOwcZpE6hGhTUK+8Mrb/ZlShxJaP2NdHttVKhxIaE12YqIagP9jPa62vUZBRgD/i59Wzr7KpaFPS6EIqkCQJi8UyZhUaX4VvOnCObuNzOBxTihC8V3QW5krb4XytgfEQRZFgMMi2bdv49Kc/DRjXJd2LC7/fzx133MHvfvc77rvvvrRu24QgdkfyxQAAIABJREFUCGkhZfNkIQ0we3bN/t0zZ85w9uzZGbWONm/2dD5wuq7HDJ+ys7MT2jhnyzbaHCtVsuD1eqmsrCQcDrN+/fqYvGy6x5kMhOZmetwSh9Um8nEiIKBqoHoCHDj7Br3RKjo8HRRbi/F6vLj1DHo76ig/5mZHeCGIItoSJ8rttyO0tuL4+/+HlpUFI1EdPS8PsaUFy4MPEv4//yfpPsSTIDOqUJFVAUCjp5HXWl6jqreKBa4FRNUoB9oPENEieCNe/lTzJ65edDVuq5tHTz9KX6CPbHs24eFziqEne06yp2Uva+1rIcmEOEbl8f2rENZfi3jmDKgqkfJyIxIxcu/uad5DV8NRSpp7CYQiIAqI+VmciGjULr4uIbow3gS8v20/PcM9rC1YS449h/rB+klFF0ZjdEogfhUaL2UcCARiBCLegTNZAeVkx5wNvJfSEKmOO9qeWhTFtKq7Anz2s5/lxhtv5LrrrpsxspAuzJOFCZDK6tNkbu3t7bS2tuJ0OmfcOtq82VVVTUsObXBwkKqqKlRVTZoumS3baEhtEo9Go9TX19PW1sbixYtZunTppF88MxVZwOXiuNJKmzqIpKt0RwfRIjoZDomurCBved805GttAkE1iOj34lX8/NrZwGJ9CQ5ZJuvoUXRVxe5wQDQaEzsa2XF0txvpyBHjb+Nc//iogrm6tkt2/tb0NwSEmGVzi7cFq2glqkU53Xc6Fl0QEZMWUQoIqPrkyKNeVoY6khcdDcfpKrYd6gEBsGeCpiLUeWCoHv2KcyRlvOtlRhXyLdlI3b04ZBlJlKYVXUilG8J04HQ6nZSUGPUeox04e3p6kuoAZGZmjlnlzlWx4XuJLEw06eu6js/nm3Zt2Xh44oknOHr0KIcOHZqxMdKJebKQBgwODqKqKq2traxZs4aioqIZXxkIgpCW1X6qhk/mWLPRSjbecZkFl7W1tbjdbrZs2YLT6ZzyODNBgPR16yg49QrX9Gv0KVEkUWKBLCNl2jm8oIgj7e1k2bLQ0BBQEZQoRVIWviyBrMx85LDOsKqiHz9OV04OS0MhosPDyBYLkiwjiSKoqkEgkrxs40lQ7UAtTZ4mnBYnnf7Oc39H54rSKyjPLOd/7/nfWCQLxc5ivBEviqbwXP1zXL3oakPaeRx0dXVN/gSZ19bcd13n4y+0I1Zno5eXn/teOIxY2U3oxj7UBYnHlwz7W/fRVneI/DOdtARDIAqQ7aZu9QDHFk0tujDV+z3egdOEqQNgEoj29nbC4TAZGRkJEYh3a2fCaMwVWTBrTibC6MhCOtHa2soXv/hF/v73v8+oq+X53m+jo2WpYJ4sTAPBYJC6ujp6enqwWCysWbMm1po1G5iO1kK8mmFBQcGEhk/mQz1bZCHZTe7z+aiqqiIQCKSFlE23dbJ5qJlCZyEZlsT6iMGSEuTCDVx26hQuVUXVdQrWrEHfuZPtq1bxr8PnCqSEnh4sv/4Nel4udmsmLtEODsDpRFRVsj/0IaT9+xEHBwnl5BAKhxHCYRweD33XX0+gu3tcgaGIEmFx1mLQAc8QQl8futVKwcI1LFazaHvx/9Haf5pcZKzqMG6ni6AWonqgOqF2IR0QOjuRdu9GPHnSSLVccgnKNddARgZiW1ti9ATAZjOK/draMKnjePefvaaeKw92gqqBKwcUDc74YbAReXNwSvuczmLDZDoAkUgkRh76+vpobGxEURTq6+vp7+9PKKCcyeduLuoH5oIUQeokZSZFmY4cOUJPTw8XXXRRwn69/vrr/PKXvyQcDqeFSKXz/M6ThQmQ7AFVVZWmpiaamppi1tHHjx+fcTXA0ZhqR4SpHCkIQsrKkfFpj5l+wEenPBRFoaGhgZaWFsrLy7nooovSIiAzWd+GePQH+/npWz/lkpJLuGP9HcC51Eh7eztL3v9+Ftx6K91Hj+IdHiZv505D2TAaJdeee+4cLszCUrgIobMTveJcvYXQ04Oek4O4aRPqN76B9f77cQ8OAqALAoGLL6b/ttsYGBEYil/JKooSI5EXlVzERQUbsTz8MPJLb8DgIFitaKWlhOUD/DznVcjSUPQoQ/4eiNgIZFiwy3be6ngrbWRB6OvD8sADiI2N6Pn5oGnIzzyDcOYM0XvuQS8oMBQg43u9IxEEQLNakd58E93hQLdYEM8TQv7Aq61IpzLRlywBkxsoCkJNC5FrB1BSc9dOwEyTY6vVSn5+foID5759+ygqKkJVVTo7O6mrq0twYjQjEOl0YnwvpSFSKXA000gzRRa2b9/OqVOnEj77xCc+wapVq/jqV7+alvMyODjI/fffT2FhYczx0+l04nK5cDqdsc8cDgdut3vCTr15sjAJjGcdPR1/iKlissJM0zF8Mr+XrhqJicYyW326urqoqakhIyMj7RoP00lD7G3eS8NAA8ORYa5ZfA2CX6CmpgaXy8UVV1wRC3NG1q3D39cXk0AeA4sF9eqrkZ96CrGuzvBt8BtmRsr114PbjXLzzagbNyLv2oXg96OuWQNXX02F1UoFY/PjZsSrpaWFzMxMFh48SNHjj6Pl5KCsWEaV0MuGg4fpwUvxzQVcro+EWjUVoT+AlruczIVL+dQFn5rSuUkG6cABxKYmtDVrYukHPT8f6fRptJMnid56K7b//E/o6TFcMMNhhK4udIcD6+OPI/h86FYri/Pz6f3EJ2BU9wWA2NQEo7tgRiYFob19zPeFnh7kF19EPH4c3eVCvfJK1Guvjf0GZl/B0RzLbNkD4/rGF1A2NzczPDyMLMtjCiinWkw9V2RhtmWtzXEnmox9PqOTZ6bSEG63m3UjbcMmnE4neXl5Yz6fKoaGhti9ezc5OTmEw+FY95wJs9YuFAqxbt06Hn744XHvg3mykCI8Hg81NTUEAoGk1tFzQRZSjSyYhk/Nzc2UlJSwbdu2SVf1mh0fs9ERYdYsHD58GJ/Px6pVqygpKUn7S3uqBY79wX52N++m0FlIt6+b3+/5PVtcW1i9ejXFxcVj8oETjaFdeCGK3Y544ABiRwfqihVol1yCdsEFse/oixcT/VTyyXt0fjwUClGYl4dT0xiKRrH9/e/4wmECmsbxSBMvFfRyZ57CpTVR7muqQCk9VxAgNtSiLLsB4ZqP47RMrRYk6T7W16NnZCTWWNhsoOsIbW0ot96KMDCA5cknETo6QJbRi4oQQiEQBLSlSyEcxl5fT/FvfgOXXRbrDomdx0WLkEaTgpFnUh+VHhQ6OrD9x38Y+2W3IygK8v79RCsrid57b6zDYy7knkenPkRRxOVy4XK5EpwY4wliV1cXwWBwjA+C2+1OKQo3VzULM5mvH2/cVMnCO1nBsbS0lMcffxxFUQgEAgQCAfx+P8PDw7F/h8NhBgcHJzSRgnmyMCEikQjV1dUxzYHzhcDniiyMN+Zow6f4SMhUx0t3QeCpnlN0+jrZUbEj1n7a0tKCqqq4XK4ZlZWeamRhb/NeOnwdLJAXoPt1Tmon+fi2j1OSM9bVMClZCIeRDh9GrKwEWUZdvx5t82Zj1a3rSVsRU4amUbB7N6V79+IIBCgpKEDo6EAvLkbOz+atrE6qHF5+vzTKBacjRNt6iVpc2KxWrFYrGWERNSMXZRJEIZXJVHe7EeN8I879QQeHAySJ6D33oNx6qxFhcbmMtMWZM+cm+owMwqWl2NvbEQ4eRL3uuoRNKR/+MNKRIwjt7UaqQ1GM6ER5uVEbEQf5z39GrKtDW77cICYAg4PIL72Eun072ohAzly1MU40ZjIjpXgfhKGhIVpaWhJkjM3/RgtImVG890JRJaSWhvD5fDidzlndv71796Z1exaLhVWrVk38xTjMk4VpoKenh2g0OqF19GwbO8H4aYiZMHxKt2pkIBrgjdY38IQ8rMpfhS1ko7q6OhZKXbVq1Yy+qKdS4Ngf7OeFmhdQfApBe5BVZato8Dbwetvr3JFzR9Ix4smCEA5j/a//Qj5wAEHTQNeRX3oJZccOonffnbS7AZ/PCMNnZo4tAhwF63e/y7Lf/Q5R0xBtNvS2NoRQCN3j4dSiVTRnBBFkib2lfnYvl7jO5SLgcBAJhwm2tTEcDtOk60inTyesUKf70lQvvBDx4EGE7m70wsJYREHPzkaNC7vqBQWoBQWgqgh9fTCqal030woDA2PHuPpqIvfei+XhhxG6u0GS0NavJ/LVr8Kouhxp/37jfMZPGtnZCD09iKdOxcjC2yGykCqS+SDEC0j19PRw5swZNE3D5XLFrm+8lsps4u2ss+D1enG73bN+7dMN03HSvLZHjx6lqakJm82G3W4nNzcXq9VKYWHhhBo182RhApSVlcV6p8eDLMuEw+EJv5dOJJu844sB0234lG5hpuq+ajr9nUSjUf60/09ssG5g5cqV5Ofns3fv3hl/UU+2wDEcDvPIa49Q3VHNysKVuDPdRIUoGdYM9pzdw7VLrh3jqzB6DOmNN4yJqrwc3ZwIh4aQd+1C3bwZbfPm+AGRXnsN8cgRhOFhdKcT7eKLUa+6Kqm2gnjgAJZHH0VVVbSsLARRjIXxI94BXvWfYtip0S8NExAV/nC5k+tabGS1tACgZ2cT/uAHKbv6arw+X2x1Go1Gk65OJ3NttE2bUD/wAaRduxCrq43x8vJQPvxh9MWLx/5AktCWLEE+fNggF3HnBFFEX7hw7G8EAeXWW1F27kSsqwOHA23lyuQEzGKB8xHFOaxZOJ9s/FRhs9koKCiIFa/puk4wGIwRiLa2tljI/dSpU2RlZcWucboFiEZjrjowdF2fMLLg9/vf0SkIE6bjZDAY5Be/+AXPPvss/f399Pf343K58Hg8hEIhvva1r/GNb3xjXCI1TxYmwGTMpIaHh2d4bxIRTxZM/YG6ujqcTueMGD6lMw0RiAY42HaQiC9C2BOmNaOVmy+5mdK80pik6kwXXaUaWYiXk27wNbBswTKQwBv2AmAVrUiiRMNAwxiyMDqyIB4+bKgWxq+Ys7OhuRn5L39Ba2pCz8xEW7ECsaYGedcu9Lw89OJiBK8X+eWXQddRd+wYs5/ys89CMIjqciHIshFel2UEn4+jCwXqc3X8WpiooFPoyOd4voUXb7ye9w8VgCShrl2LvmgRuYJA7shKfLS88ejqfEmSiEQihMPh8ScXQTAKNTdvRmxsNMjAihVGuuA8UD/0IaTKSoTGRqNbIhLB3t5OaP16rPGkajTcbrS4lrSk2776aiwPPogeChlmVrpuRD0yM1Hjfjvb4XnzXpkpgiIIQqwK3mzzDgQCHDhwgMLCQnw+H42NjQkOnPEFlOlMCc5FZMGM/qZSs/BuiCyY79Dnn3+exx57jLvvvptDhw5x5swZvvCFL/CHP/yBQCDA+973PmD86NI8WUgT5rJmwev1UlVVRSgUYtWqVWOK7NI5XroiC/vr9/NW9Vssci1i+YrltAZbqeyvpCKvInbDzrRiZCqRBZ/PR2VlJaFQiPXr13NZ9mUMR5OTwvyMsRPfmJqFZDUJgUAs/K07HIjhMNL+/Qj9/eilpejmqnDEYls8fBh1VIGfqqk8EzrKtU7ICQYRFQXBZkO3WgkLKrsX6/SsXkRzuAubbEe2ZhDwt/Ho0B6u/cDDyGLyV0EyeeN4e+euri5CoRD79u2LqRPGTzCjV3D6woWoyaICSaBecQWRL30JyxNPIHR2gsXC0JYt+D76UUqnueqNfuhDiCdOIB09GhOJ0t1uoh/9aIIh1mxHFsx7frYJiiiKsSI3MCbV+ALKjo4OQqEQDocj4Rq7XK4pT/hzQRbM99dE59dMQ7zTYZKF3bt3s3btWj73uc/xla98BYvFwm233call17K1772NTo7Oyfc1jxZmADpsqmeCQiCQG9vL62trTHDp3ToD5wP6UhDBINBjp0+xvN1z7OwYCErywyToBKphMreSi4ovoBSt/HSmunOi/EKHBVFiXl8LFq0iKVLl8bOrdM6ueK/eLKgXXgh0r59EAwahX2A0NQE4TB6YSFiXR1CMGhMYP39aBUVCdvTs7IQOzoQPB70uJfZwY6DPJjTSO/yMJ89oIPFghAOgyThlcOE84vx2wSiUZ1Mm5GjzrPncWboDDX9NawrSL1dK97eWRRFOjs72bBhQ4I6YWtrK5FIBJfLRV4kQo7fj2PxYuwrx1pOj3PyUHfsMKIRp05Bfj6tmpael3h2NuHvfQ/p9dcRa2vB4UC97DLDyTNu/+YiDQGzSxaSRfBkWR7jwGm6E3q93qQOnCZBTNWBc67IgizLE15TM7LwTod5nH6/P2bF7vF4Ytdn0aJFdHd3U1tbC4xfdDpPFtKE2SQLpuFTS0sLFotlWpLHk8F00hCaptHU1ERjYyMehwd3iRtBFKjrr4t9J6gGqeyppCyzbNrqiqngfG2NPT09VFVVYbfbp53OGUMWtm2DAweQDx0ycuPRKLS1oeXkIDY3G59ZLODxIHR0oNXWol9yTqZY8PnQMzISiIKqqfz5+B/plgK8tELiAw0Ci4Z0oxsgFKIgL4+bbv02p/ufIdOWictiFEnquk53oJvDnYcnRRaSIZk6YXhoCOFHP8K+ezcMDxOVJHrXraPrU58iY+FCCs6cIe+FF7C0tKAtW0b0X/4F7cILz21U05Cfew752WeNKIvNxsKyMgJ33gmLFk1rfwHIyEDduRN1587zfmW2K/bNe362oxmpTO5Wq5W8vLyYiJuu64RCoRiB6Orqor6+PmUHzrnohlAUJWUTqZn09pktmOe8tLSUpqYmwuEwl156KQ8++CDPPPMMDoeD5uZmykY8W+a7IWYBs0UWBgcHqa6uRlEUFixYEGuNmg1MNQ3R399PVVUVoiiyefNmFJvCEs+SpN/NceTExpqNNET8GKFQiOrqagYGBlixYgVlPT1IP/4xQm0temEh+g03oF1/fcwpMRWMJgt6RgahL34R68GDhuyxriNWVyOO1CrEuh0yMxG7u5Fqa1GXLkV3uxG8XoSeHpQdOyCuZe7Q337H6QN/ZU3XMGdzBf6yxsHnqlzGftpsqNu3E11WwSJl0Rjzp2J3MREtMulzJ3R1IfT3I47z4nX//vdYXnwRPSsLvaAAWyCA6+RJcp56isGlSyn4+c8RIhFUWUY8fBjLs8/i+d73kD/8YWRZRtq1y6grsFrRiooQgkGy33wTRyQCP/lJYifDDOG9kIaYam2QIAg4HA4cDsekHDhNEjFXttipRF/fLWTBPL933XUXdXV1BAIBbrvtNl5++WW++c1vMjg4yNatW9myZUvC95NhnixMgFRfFOluKxyNUChEXV0d3d3dVFRUsHjxYjo7O1PKNaULk01DhEIhampq6OvrY9myZZSXl8duxoKM8aVFZ8rkKR5m9ELTNFpaWqivr6eoqIitW7diP3IE6Qc/MML92dmGJsLp09DZifaJT0xqjDHRC6fTCK+PFClafvYzpBMnEiv8vV7U8nKjLiEQQBwcRHc6Ua69FjVeM+DlF3n28W+g50dxRSDfp7GrxM8HBgtZdNUHIRCAnBwuKLqAC4ouICk8HsSqKnSn0zByGu+eHxrC+sMfIr/6KoTDlNrtCFu3wvr1iR0aAwPIL76I7najm22LIy2xWXv3kv3MM0aaxGpFk2UUlwtxcBDr/ffzWmYmGZmZrH/sMZyRCEJ5ObLFAhkZBINBnDU1CKdPJ4hWzRTmgiy8k1sYJ+PACVBfX092dnYsAjGTaVRIPbLg9/snlD9+J2H16tWsXr069u/f/va37Nq1C0EQuOWWW1I6J/NkIQWkosJnRhbS/XIZbfi0detWHCO57tmuk0h1tR+/z4WFhcbkO0mlttkgC2aB45tvvommaed8MjQN8YknEPx+9FWrDEtogK4uxL/+FW3nTkihnRZSu3fUjRuRn3sOoafHaPMbESrSS0vRysuJ3HMPQiBgRB7ivRM0jSO/+SbHF0cpDcggahQEdarzNF62N/PpaBTR6yV69dXJB9Y05D//Gfn55xEGB40V/Lp1RO++Gz3Z8ek6tm9/G/mVV9Czs9FzcxEGBljw178iLFpE9LOfPXdue3shEDCkm+PPRzCI2N1t1GTYbCAIiMPDWHQdPTcXt9fLldnZDBYUYBsaImC1EujrA13HMkIsHKEQens7wsaNMz6Rz0XNwrvN0CmZA2cwGOTNN98kMzMz1sI52oHTLKBM576lSox8Ph9L4wpd36kwBag++clP8vnPf54LLrgARVHIzc3ltttuA+CVV17h8ssvn9COe54spAmyLMd6pNPF0vv6+qiurj6v4dNMRzNGI5XxBgYGqKqqQtf1lE2qkmGmyYJp+gRQVFRERcW5Lgx6ehCamoz+/viJorAQobYWoa4uNpmqmsrx7uNsKtiAVFWNUFsLsmyI+lRUpCb3vHkz6iWXGKmInByw242uiO5u1EsugcLCscqHgN7VyZ+czQzZBWw69NsBDTQBXq7Q+ODJNyi59kOoV1yRdFzplVewPPIIekYGWmkpBINIb76JEAgQ/u53x2g5iHV1SPv3o+Xlxbwu1Lw8tGgUx3//N9GPfSzWoaEVFIDTaRCuEXKLphlqkqKIAEaaRBRBEIyiTocDBAGLzUZ+eTm20lKcHR1kl5QQVRSikQj+3l4iuk5VezvD+/YlTCwzsTKd7cl7rhQjZ5ugmOMtXrw4drzhcDhW/2A6cJpKrqMLKKd6jt5raQjzWB966CHuueeehM9MvO9976O2tpbly8d3WpsnC2mCeQFSDXONh0AgQG1tLf39/WPC9/GYbbIgiuJ5IxnhcJja2lq6u7tZunQpixcvntYLaKbIgq7rdHZ2UlNTE6v1WLJkSeK+2u3GRBkZlcuPRo08eZyS598b/85PD/yYr/WvZcc/2iEUMuoQsrLQPvIRhKuvHksWfD7kN95AfOstUBS0Cy5AueEG5FdeMWoB/H4Ih1EvuQT1yivPeyxRq4xTEbi0UxwRHpJA19C9KraoxvDFFxD51KcS6hti0DTkl19Gl6Rz6Q+bDc1mQ6yqQjxxIlEgChBaWhB8PiPyMTRkdFxkZKBlZBgqk11d5wovc3OJvv/9WP74R4Mwud3GbwIBQ77Z40EYHjaiC6II0SiCx4O2ciXaunWGDPbOnVh+/Wvo6sKSl4dFVRF6elA3bGDDxz6GLxQa09rndDpxu90xcaFUK/PPh/nIwszArFeIP7c2mw2bzZbgwGkKSPl8Pjo6OvD5fNNy4JxMgeO7oRvi8ccfx+VykZGRwfHjx4lEIlit1lg7dFdXF1lZWQmqn+fDPFlIAamsDkVRjE2mU1U+i7e+Li4untDwaS4iC5FRE6iu67F8f15eXkKaZDqYCbIwPDxMVVUVPp+P1atXk5+fz+7du8dGg7Kz0S+/HPHZZ43Qv91udBY0NaFXVKCvXw9ARI3wx9N/pKG7mj92NHJN/nVI2bnGZNrZifjUU8ilpYn3TiiE9cEHkY8eNSZQSTLEmFasIPLxjyN1dUEwiF5SYqgPjrMKsuYX8V3LDcgv/d1YvY+kMHSfD93pJPjL7yQnCiP7ISRzw3Q4zkktj0Y4bNQ3DA6iSxKCrmORZeP8FBfH9CBMRD/zGQRNQ37xRSPFYrWiL1iAXlKCvngx0qFDxjZ13djv3FzC3/lO7JiVG24Arxf5pZcQz55Ft9nwrl9P+O67KbLbybbbE1r7RksbNzQ0JFTmm/9Nxtp5tlf67/SahXSOmUxAytT4MCMQyRw4TQKRzIFzMmmId0Nk4ac//SmqqhIIBPjFL36Bw+FAkiSsI14wLS0tbN++PSXPoHmykEZMtYZA13V6enqoqanBYrGkbPg0234Uo8nJ0NAQVVVVKIrCxo0b01oQlE5paU3TDNfNmhqWhsNcZLUi1dSgjITdkhFB9a67oL0d8eRJdE1D0HX00lLUL37RmByB3U27qe6rpiLi5KRzkL0OP9uVXCN1UVICp09jOX06Qc5YOn4c8fhxtGXLYtvRi4sRa2qQampQb7xxUscW/u53EWtqEFtaYikTzWql42tfI2e81YLdbug6nDmTqKIYCBjKj6N14nXd0IewWIzoicVipBOGh7EGgygf+5ihRBkPh4PIV75C9K67DHOnggKkV1/F+oc/oOfno1x5JWJDA0JfH/rixQR/8xujRsSELKPccYch39zWhu5y0eTxUDTKQdJEMmnj+Mr8lpYW/H4/siyTlZUVi0C43e7zKhPORYHjeyENMdVOiHiNj6k4cKaShtB1Hb/fP2P21LOJX/3qV3i9Xr7whS/wmc98BlEUCQaDeDweIpEIN954Ix/96EfnCxxnG1OZvE3DJ6/Xy4oVKygtLZ2UEJSpdT4bLxhzAo9EItTV1dHZ2UlFRcXYMH6axkpHZKG/v5/KykqsoRDbGhpwnjljkANVxZKXR3ZxMVqyAsDCQtQf/ADt4EGE9nbIzka77LJYgaEZVRARyVWtDAL/11LF1UopEkYeHkFAGCl6NSG0tBieBPEFn7KMnpGBVF09abKgL15MYPduLM88g3j6NHpBAdUbNyKtWkXOeD8URZSdO7H+8pcIra1GVCAYROzoQLvwQkOcKA5Cd7exfxdeiNjUhNDXh6Bp6LJM1GZDPV8RJYY5lBl1UG67DWFoCPnVVxG8XvSiIpRrryX6pS+hL1iQfAN5eUadBMCxYynf68kq882JxePxxOSrQ6HQeQvr3gvdEO/0aMb5HDjN9EW8A6csyzgcjhiROF+a6t0SWbj44osBePjhh2P/P1XMk4UUMJnJO9XVcLxCYGlp6ZQMn8yHLdWinelCFEUCgQD/+Mc/yM7OZsuWLeM6cU4H09VZiK+hWL58OYsrK5Fqa43Q/khqR2hupvjgQfR/+qfk3Q12O/pVVyUtLjSjCgvdC9ED/ZS09XMis5e9chvblXIYHjYKHSsqEo9jxIcAXUcIBMDjAasVIRJBm6peRmYm0Y9/PPbPUGUlqWxJ3b6daCCA/NxziB0d6DYb6pVXEv3kJ8caVWma8Z/LhXbp3A74AAAgAElEQVT55UbNQShEQNehqwsp1XvXZiP6+c+j3HILYmsrelaWcU1SnKwmY/yVDMkmlkgkEluVmoV1pjNjOBzGbrfHVqqz0X3xXrCKnunUh8ViGSMgFQ6HOXXqFLIsJ6Sp4gsoh4aGWLZs2bumZsEkghdffDE//vGPeeONNygrK+P+++9HlmVqa2spLS1NqRB9niykEamkIcwCu9raWjIyMrjsssumzGDNhy0Vf/bpwuPx0NTURCgU4oILLpjQznS6mGpkId70KTc3l23btmG3WBAfe8zo94+rAdHLy7HV1iI0NqbcCgnnogoRNUJUjRLNciAMZRCKDPB/I29xTXMUORBE27IFddMm9CNHzo25bh24XEivvYbQ32+4Quo6ut1O9CMfmfTxJkPKE5oootx8M8r27QZZcDqN1X2S3+vFxWjLlyMeO2bUcWRloWdlIdXXE8zJwRbXw50KJuMRkfC7GVjpW61W8vPzEwrrzPTFmTNnGBgYoLOzc0xePN3GSjA3aYi5cn+cTYJiepxIkkRxcTElJSUJ19k00PrQhz4UE5B64IEHuPbaa7nkkktiKY904IEHHuCBBx6gubkZgLVr1/Ktb32LG264IW1jmBBFkeHhYX7wgx/w5z//mZKSEh566CF++MMfMjw8zLe//W2WLVvGD3/4wwmfrXmykEZMRBa8Xi/V1dUEAgFWrlxJSUnJtF4MZjXxTBY5mi2GbW1tFBQUIIrijBMFmBpZGG36FNvPaNTo6x/9chIEY6IecblMFa3eVvqD/WTbs/FH/caHC/LJ9lrp9EdpW1ZI2WXvQ9u+HYFzq+FIJEJdOEyuJLGwoQFBkhBsNsMhUhSR9+41pIeTFGZNFpNagbtcaCtWjP8dUST6sY9hbW9HrKlBt9uN4kSrla4bb2TRuyBkayI+fdHR0UFpaSn5+flJ8+KmsZLZfTFdXYC5SkOkm/RMhLkoqhw97ug01YoVK2hpaWHPnj18+tOfZmhoiG9+85tUVVVRWlpKQ0NDWs5TaWkpP/jBD1i2bBkAjzzyCDfffDPHjh1j7dq1096+CXPyr6+v54knnuCRRx6hqKiIa6+9FlmWyc3N5cYbb+TRRx9N+P75ME8WUsB0zaQikQgNDQ20tbWxaNEiLrroorRFAiaT+pgMTMvr2tpa3G43W7ZsIRgMUl1dnfaxkmEyZGE80yfACKmvXo2wZ49RuGe+jHt7UV0ulEmucJfmLOWPNxuRhdGwyTbyHHmYey4EArFoUnV1NZkZGeREIgSXLCFssaBGo6guF1JGBq7KSvxvvIH9yiundX8IgmC0InZ3ozud5ySkpwlt40bC99+PvGsX4pkzaMXF9K5bx0B+PmlwakgJc9HKKAhCyukLVVXHdF8k80U4H95LNQuzPaY57njPlt1uZ+XKlfj9fh566CEkSYrVlaWLUN10000J//7e977HAw88wIEDB2aELLS2tiJJEldccQV/+ctfEgTyzBoe8/vjYZ4spBGjyYJp+FRfX09WVtaMGD7NRPukz+ejqqqKYDDImjVrKCoqQhAEIpHIrLVqpkoWUjV90rZuRTxzBuH0aUM4aMSRcXDjRlxT6OJIZkedDOFwGIDq6mpWr15NocOBHIkglJbicLvRRZEoEI5EUDs7aT99mnbA6XTGVqtZWVlkZGSkNuHoOllvvkneG29gC4XA4UC56iqUf/onSMO9p1dUEP23fzt3fB0d0N097e1OBm+X7oRk6QtTF8BUJfT5fAm+COY1Ha/74t2eEoC5iyykorNg2lOb18Hlck27OPB8UFWVp59+muHhYS6//PIZGUMQBKxWK6qqYrfbcTqdSJKEruucOHGCxXHdWuNhniykgKlEFkzDp2g0yvr16ykoKJiRl1w62ycVRaG+vp7W1takEZB0tjNOhInIQjAYpKamJmb6NGEXSUkJ2ic/iXDsGMKZM+B2o2/YQH9fH6XTLJpLhnjJa4AtW7Zgs9nQRoSdxMpKI/cvioj5+VhdLsS8PFZfey2Lly/H6/Xi8Xjo6uqirq4OQRASJpvMzMykfeTSq69S+NRTiJKEXlqKEAhgefJJhP5+ovfeO77vwzsA0y1wnMp4k+m+SKYLEN990d3dnZC+iO++MIt63yutk3OdhjgfvF7vhNLH08WpU6e4/PLLCYVCuFwu/vznP7NmzZq0jmFe08suu4x169Zx5513kpeXh6qqVFVV8dRTT7F//36+9a1vARPPc/NkIY2QJIlAIMDJkyfp7u5myZIlLFmyZEYfinREFnRdp6urK6ZqeMUVVyR9WGbDCdLE+YhJ/CRcVFTEtm3bkk6aSVFQgH799QndDeLrrxsv6KoqxF27oKUFysvRduxAn2TRngmPx0NlZSWqqrJx40aOHjmCpaMDYWDAEDuyWIw2xcFBUBSoqUF3u1FuvRVtzRpsopigF2AK0ZgTjmnEMyZfbrdje+EFIoJApLQUx0gRou5wIB08iNLYiD4DevdzkRZ4p4yXzBfBbOvzer0MDAzQ3NyMoiixZ87sOppM+mI6eC8UOIJxLVPpHDM7IWby3K9cuZLjx48zNDTEn/70J+666y5ee+21tBMGXdfJz8/nC1/4Aj/96U/ZtWsXgUCAO+64A4/Hw+c//3luueUWYGKn03mykCZomobX66W3tzdmnpQOJcOJMN2aBb/fT1VVFcPDwxMWXZrEZDZe2KIoEh1VeDg0NERlZWWi6dM0IQgC8r59SH/4AwwOIjgc6IcPI+3Zg/rlL6Nv3ZrythRFoaGhgZaWFpYsWcLSpUtR+/tZ+eSTWHp7EUdaJdWsLEMp0es1fqjrRlfEeR7WeCEaE+aE4/F4YvlyeWiIC2tridrtEI2iqCqyJEFWFkJnJ2JnJ+q7wBznnS6/nKytLxQK4fF4aG1tJRAI8NZbbyUQjfGiSdPFXEUWZqPde/SYwIQkZTY0FqxWa6zAcfPmzRw6dIif//zn/OY3v0nrOOazctlll/Hkk0/y4osvcubMGSwWC+973/tYsmRJytuaJwspYKKXU39/f0zJ0O12s2nTplnas6lHFuKLAsvKyti0adOEBTzmC2U2VgXxkYVoNEpdXR0dHR1pF4GSFIWMJ580DI9Wr0Yf6ZAQGhoQH3nEMHJK4QXd29tLZWUlDofjXGRG15EeeIDCI0fQV640WjcHB5Gqq8FmQ928GSESQZdlhN5exKNHEWtr0VKIaCSbcAL9/Viffhqtr49AJEJnZyeSJGHXNJyqyrAgYJ+j8G+68HZOQ0wVgiDgcDhwOBz4/X5UVWX58uVJbZ3jVQmzsrJi6Yvp4L1Ss/B2IgujYepApHN7giBQWVnJU089RXd3NxdddBF33XUX73//+8d8LxXMk4VpwMybm4ZPNpst1js7W5gsWTClpaurq7Hb7ZPSeTAfstkkCx0dHdTU1OB2u7niiivSXiCa0dGB1NGBXl5+Lp8vCOgLFyK2tqI1NiZKEI9COBymurqavr4+Vq5cmVg70dKCePAgoZwcXDkjeoqZmdDebhRYqqrh6RCNGg6N0ShCczNMIf0hCALO/HzkD3wA4Te/QY5GcZaWoni90NiIp6KCU4pC5PXXYyI0ZvpitsLd6cI7KQ0xWZir/POlL3w+Hx6Ph8HBQc6ePRtLX8RHH1Iuhh015mxiLsiCoiixczseZlqQ6etf/zo33HADZWVl+Hw+nnjiCfbu3cvLL7+clu2b9+yxY8e45557aGhooKSkhEcffZSjR49y3333kZeXN+l7e54sTAHxhk9m3txms9HX1zerXg0wOT+K4eFhqqur8Xg8rFy5koULF07qZjEfMlVVZ7wvW1EUBgcH8Xg8rF69muLi4hl5aZsaB4yuxVBV4/OaGqTnnoP2dvRly9Df9z705cvRdZ329nZqa2tjBlrxLUmAIYkcCKBkZBiqjZKEnpdn6CtEowZhAASfDz03F2G0DPQUoNx8M0M1NbiPHkWuq0O22dAuu4yse+7higULCMU5NZrV+vFiQyaBSDVEPBcr/dnEbBcc6rp+3knUYrGQm5sbcwg00xfxzpu1tbWxtFX8NR0vfTEXNQtvV/MqmHmy0N3dzZ133klnZydZWVls2LCBl19+mR07dqRl+yYJePDBB3E6nTzyyCOsWrWKF198ke985zvccsst7NixY54szATME6rrOr29vbGe282bN5OTc06Bf6pGUtNBKpEFVVVpbGykqamJhQsXsmHDhinlPmdDBMo0fWpsbMRqtbJ169YZJSbhsjKiZWXYzp5FX7EiRhyE9nZ0txv5t781bJXtdoSjR2HPHnz33stJq5VgMJgo/jQKenExuFxYhobOfZifj56dDT09CF4vZGYaRk6ahlZUhLphw/QOyG6n95//Ge8111BhtaJnZhpyypKEALFwd1FRETC2Wt/0SnA6nQmTjdPpfFtEH4z2RBGPZ+zfZDkt3aFjxnu7tGqORnz6Iv56Dg8Px+pZzpw5MyZ9YRorxUcK3wsFjm8Xx8nf//73M7bteOzfv5+77747lnb43Oc+x89+9jN6enoA496eT0PMAAKBAFVVVXg8nvO26s22C6Q55uhCwHiYKQeLxcKll146bSe1meyIME2fJEli6dKl9Pf3T58o6Dr4fMaKPQlBEiwWPP/yLzgfegihutpQeVRV9KIiGB42VrIjaQhd0wifOsXgT35C5n33TSyutXAh+lVXYXv0UYMc+HyIJ08iDA+jCwLCwAB6VhaCoqAVFRn+DvFFm4ODyK+8ghAKoWzdil5RkdIhC6JIpKQEdcRVczwkC3dHIpGEzguz/dN0aUxltTpTCIUkXnklA00be95dLp0PfEBNK2F4pxlJxRfDLhwRG1MUJRZ9ME2VotFojBAqikI4HJ7VY52rNEQqETOfzzcrKrUzjf7+flaPSmk6nc5Y181kz/88WUgBmqZx6NAhCgoKxl2Vm50Js/nQSZJEKBQa87mptjg4OMjy5cspKytLyz7NhAjUaNOn8vJyenp66O3tndZ2hT17kB56CKGhATIy0G68EfVTnzJEmUYgiiKhVatQfvQjxNdfR+jpQS8qQs/MRP7Rj9BHqoXDkQiDg4PILhcLAgEWZGYaS9kJoH7mM7Q3NbH68GHEEydibZuCriN2daFmZBC4/360TZsQCgpgZLKQ//Qn7F/6kmFIBdgkiegnP0n4e98DUaS/H6LRsdfTYpl+mN5qtY6xeo5v3WxsbGR4eBi73Y7FYkFVVTweT4KQzUxBUcDnE8jLA7v93LGGQgJ+v0C6ufpsiyTNxCrflPaNT1+Ew+EYgdA0jaqqqpiWR/x/tjgvlXTi7Zz6eLeYSIVCIR555BFqa2uRJInS0lJaWlo4ffo0paWl2Gw2bDYbS5cuTelazJOFFCCKIlu3bp3wRjNZ62y2BY2OZmiaRlNTE42NjRQXF09OhyAFpFOYyTR9MvP+27Zti+X9p2tRLezdi/y1r4HfDzk54PUiPvggNDai/vznRlFhOIyAcc4oL0f7H//j3O+PHAFRRFMUPH4/gUDA0DKwWBCCQZRUWbnTSfMHP8jqXbvQgfjpXdA05BGPCDUnB3OmE+vrcX32s8Y+Wq1G4WU0iuV3v0NbuZKumz7Of/6nDY9nLFnIytK59VaJrKz0zZqCIOByuXC5XLHVqlls19bWhsfj4eTJk7FuoHjhqHQ7NZpE3G7XSTQ81QmF0k/Q50LXYaYnUdNUyW63U1BQQEtLC5deemlCBMIkhDabbQyBSEdE4O0cWfD7/e9oe2rzfr344oupra2lsbExNkdkZWXx9NNP8/zzz8ekrPfs2ZOQTj8f5slCirBYLBNOXuaNOBsukPFjmpN3X18fVVVVSJI0pp4iXUhXGiLe9GnDhg1jwn7TIgu6jvTwwwZRWLLkXJeDz4f4+uvwH/9hRBtCIZZkZxO65RYYJXmqrV5NID+fSGUlSnk5RUVFyIKAUFuLtmVLSi6Vuq6jaRqOSAT57Nnk35Fl7EeOIFx/PZqmoWkatqefNlIhJlHASJcQDiM/9BDh6+/C4zEnzHOr60BAwOMRUJTJTzY+H+ddlctyQjAGOFdsFwwG0XWdDRs2xKSOPR4PLS0t+P1+LBZLQu2D2+2e9rMxW5P3ZHO66cBsF1Saz5gkSTgcjjHpC7P7wuv10traSiQSGdN9MZV6lrd7geO7gSz86le/wufzEQqFCAQCBAIBIpEIPp+P4eFhgsEgHo8nZbXKebKQRpiGM7NZt2DWLBw/fpy+vj6WLVtGeXn5jK1OppuGmND0aQTTimAEAgj19ZCdnShv7HQiVFcjPvOMkV6w23FVVuJqb0coK0PfvBkwUjhV1dUI27axwe8nu7cX+vsNh8qKCrRPfnJc2WSzYl9VVTRNY/O2begWi9EBMRqqileWEaPRWMjX0ttraD3EX0NdN+ocOjpQFGVE513H6RwhE4JA/Op6Ml0DPh88/bQFny/5391uuPXW6BjCEI9kUseqquLz+WIEor29nXA4PKZ1czKtfrPZDWGO9U6qWZjKeJA8fy3LMjk5OQmLjvjui66uLurr6wHGdF+Ml74wSfTbmSy8G9IQixal195tniykGbPZEaFpGn19fXi9XpxOZ9L2vXRjOpN4qqZP5jhTnhhsNsNpcWAg8fOhIQiFYPlyQ0ExGiVSVIS9txfx6adRLrqIs2fPUl9fT3FxMSvvvhv5pptQ//EPoxhxwQK0q66C/PObSJmSsuaqVBRFJLcb9bbbkJ54AiHu3OmALklUrV/PwOuvY7fbycrKYsmCBRSC0c4ZN3EIgHrBBUiSFCMH8dEXTRNiHaCTOXdGHYBx2hyOxN8Fg8K4UYfxIEkS2dnZZGdnxz47X6vfZIyWZgtzQRbmIpIBE0v9mjDTF2Yk0KxnMQlhc3Mzfr9/TPoiPqI0HkGZSaQS8dV1HZ/PN+1C8Hcj5slCikj1AZ6tyMLAwEBMNdJqtbJx48YZHxOmloaIL7ZMVd9hWhEMWUa76SbEBx4wJJXdbmO2a201uh36+hDPngVVxSUIaE4n6qlTHNy3j8hoKenycrQ77phwSJMcaOEwemcnOBxIcamVyPe/j/3ECYTTp9FlOUYEon/4Axe9//0oioLH4zFeuFdeSeaDD2L1eAyyIIoIioIgy6hf/CIWiwVJkpAkAUnS4yZQgzz4fD6ys2UikUis3VUQhAknBIdDT9JJoBMOT33yGks07FgsdoqKClm27FzrpkkgTKOljIyMMa2b8ftvRFD0Uf9OL94LkQVVVWP3x1QQX8+yYMEC4Fz6Il7PIxwOx7ovTGG12W7FVVU1pYLNd3oaYqYwTxbSjJmOLMR3Dixbtozs7GyOHTs2Y+ONxmQm8emYPgmCMK3aCPVf/xWamhBfew36+oy0QX6+EVnweNDdbkMkye9H7u3FY7eTW1DA0mXLJr3i0XUdVVEQ9u3D8sILCF1dCFYr2saNKLfeCoWFkJdHaN8+pBdfRDx0CD0vD/X229FHah9kWT4n31xRgf63v6F+6UvIb70Fmvb/s/fmwZGd5bn4c07v3epFuzQa7dJoGUkzo7FnNOPxQmGcS1KXikMSUhds7FA4y4BNXNxAAbFZUj8MOBXjAHGK+GIu99oEE8hSBkO4MR6MB3tsxx6pW/s22lpSS72vZ/v9cfQdndPqVi/qbp2x+6lSTUkjdZ8+3ed8z/e+7/M8iDY0YOxDH4KXosCOjyMU6gRN6wDoQFFiFcbni2FrKwCNRoPW1lapOiM/j2RhSEcgQiGA43Zv4pGIqD7w+cQ50VwQDAI//KFOisCQw2YDfv/3GVitqaWbZKHZ3NzE7OwsBEGAzWaDIDCg6RCCQR1iMeX7VFEhZCNQyRqELFzvaohSP1+q9oVcfUF0/i+99FJK9UWxSEQ2g+fEp6JMFvaiTBayRC4x1cUwLeJ5HktLS5ienlYoB4iXfKmQbRtiT+hTZSUwPw/K7QZMJgg9Pfs66JAKRt5lWbMZ3KOPgn/rLVATE4DdDiEeh+7P/xwUAGFngJLnedCCAJvVioqODrHykCWkagLPA6+/Dt2TT4JiWVF6mUiA/s//hHZrC+ynPiXW+LVacO97H7j3vS/zg/f1gX3+eXBra0AsBqq1FX07YWWLiyHo9RGsrvJYXual4Vue53H0qAWnTh2H1bqb4wFAao2QcyonECxLg+c1CIeBF17QIRLZPd8MAyQSgNerx2c/m8CO+i4rsKxY2DEale2NaJRCIJC+taHX61FTU4OanXaPIAiIRCI7lZdJ9PVNIRSKSaVu0i+32y2wWApX2j6sNkSpyUIp2gEGg0GS44ZCIbz22mu44YYbJAKxsLCAcDisGIglX4UaFmdZNuNrDYVCEjEtQ4kyWSgwilFZIAsvx3E4efKkdBMFSpsESZ5vvx1/ytCneBz0//k/ogNiPC5WDZqaIHzgAxB2kteSQW6YB3pdFAXh5EkIJ0+Kj/mTn0A4cgQIBMB5vSJR0GrB1tdDX1UFPhoV46OzAFlwybnQ/fKXoGIxRY6EYLGAdrlAj46C3xmezBWCTHWhpWlJL//QQ2IVYG1tFUtLczAY9DuVhCBcLhYOhwN2uz3lDICcMJDj53kBgQDg8wnQ6QSQai1NA4JAIxCgdnwdlDMD2cwQ7G1v5CZzpCgKFosFFosF09PTOH26H0ajUTapv42FhXkpJ0Eu3TxI7sVhtSFK+XyHFU+t1Wr3tC/kA7GBQEAaiJW7iZI2Rj7HnM2AY3BnyrdMFvaiTBYKjEKShUQigampKaytraVNWyQf/lJ5O6RrQwiCgLW1NSn06aabboJ5RwhP/epXoH79a6C1VbQ3ZlnQMzPgf/ADCJ/4BJIE8wCUCZeFupnxTU1gLRb4KipgPHIEFUYjIlotaI8HuuZmcSgyBdbXxe4FeZ3yioLJRKHBEQc9Pw8kD0UZjeJswgHNpZLh9QL/+I/AwoIfDKNHZeVpmEziYKvVyuPChS1QlA8+nw+Li4tgGEbyP7Db7XA4HDAajdJnx2TiUVWlwfIykEjQ0Gh4aVCSpgGTiQMg7Kg7SluWTwYhj8mlbnnMc6rcCzmByPY6IUTq7TyzoKYQqVQDscnti5mZGQiCoFBfZOvnkc09MhgMwmw2lzw++3pA+YxkiVzaEAclC8SsaGpqCpWVlYqFN9XzAaUjCzRN73l94XAYLpcLoVBob+gTy4J69VWx4U3YulYLobMT9MwMhJkZCCnyEORkoRAIh8NwxWJobGnB0akpaBsaAJMJ2uVlcBoN+DvvVCgPCNbXgY9/XLtjgCRA3GyKO86O8Bj+eO3/Q2v8l6BiEaC6Gtx/+2+7pIFhxFkJ2c3voBAEAXNzq3A6DbBajWhtrQRF0SC7dY+HhsnkQEODQ/r9WCwGn88n+R84nU7odDqJPNjtdvz+79uxvq7B0pKAqirAbBZfq9gCEBAKiZkgLLu726YoquTBTuS5U/2M5CTIpZtkeNLv92N1dVWRe0EIRDqfgFIrE8hzvlPJQirI2xfAbkuKEIhUfh6kNZWsqMmmDREIBGC1WlWRg6I2lMlCgXFQNYTf74fL5UIikdg3pIiA3LRLNbeg0WiQSCQAKEOfjh49ipMnT+6VvLEsqHgcSJ5C1unEXXeaDPdCkQW5o2VTUxMaHnsMmv/7f4EXXwQVCoFpasL6bbeh7d3vTvn3O/OQMBh4Rd+9ITyHh6/8HmwJDwSrHhRNg1pZgfaf/gnsH/2RqGBYXITQ2Qn+oOFQOwiFQnC5XJiZ0cLtPoOtLQ1WVnb/n2HEKAy/H9hZLxWLaONOS4OUewmBIGY7iUQVotEeMIwGWq0BOp1OumlGIuKNW6tlpcoKwzDY3pGnJhIJaWAyeXAyGlW2L8Tv80Mu5ESj0UhkqLm5GcDuTtXv98PtdmNqakphc0wIhF6vPxSycBiVhcPwO8j3NcpbUvLPszwMjZBCuaKGZGBkU1l4O3gsFANlslBgaLXalFkNmcAwDKanp7G8vIz29nZ0dHRkdRETI6hSkgWO46TQJ61Wu39AldEIoa0N1KuvgvL7geVlcUWzWiE4HGIyYwoQEnQQsuDz+TA2NgYACkdL7v77gXvuAUIhrIfD8IZCaEuzsxR317t9d/HXKPzO1LdhZzzwaxyoMVOAxiwaLwUC0Lz0EvieHvADA+A+/OEDRyHyPI+FhQXMz8+jubkZAwPd4DgNTCal5XE4DIRCFPbJFQOQ3v9gZiYEgILHE8HWlgc0TUOvN0AQTBAEI3hekMjg1taW5JnR09MjzbLIP4c8D1RUiPMO0ahSnpdltEZKHGQBT96pJqc0zszMIBKJwGQySdW8QCCAioqKkizi74SZhUK7N8pJIYFcUePxeCTL4/HxcVRWVqZtX4RCoXJlIQ3KZCFLFEsNIQiCZE5js9lw0003STrkbFFK10ie5+H1erG5uSmFPmW62Qjnz4P+4Q9Bzc2JFQaOE7fBZ89iv/H6fA2gWJbF1NQUVlZW0s56wGYDbDZQi4spCQkxVxKfXrxM5J+BY57LEEADOy0AUJQ48xCLgT9yBMxDD4kpkQe8KQYCAbz88iRYlsaxY2dgtVqxurqrJJArUXcKPnnBaDTiyBEjWlt18PvtUuUgHk8gkUhAp9vEK6+Mo6FBvxMTHUVbWxus1g4EAhpJHkmGJvV6HtXVPO68M65QPRASqNNROxwqt4Wq0G2PVCmNDMNIsk1BEPDmm2+C53mZ6sJeFJmf3MirVFB7GyJfJCtqOI7Diy++iMbGRkQiEal9QWZaQqEQ1tfXsbm5Wa4spEGZLBQYucwsBINBuFwuRKNR9Pf3o76+Pq+bT7HkmnKQOYrZ2VlotVpF6FNGBIOATgehqwtUNCpmHtTWAtEoqMuXIdx+e8o/S5kPEQ4Dbre4LT1yZI96YX19HS6XCxaLBefPn89IvJKdIuXDi+IuTwNl/NPOSzLUgELSsQmC6N3Q3g4hi3jo/cBxHObm5jA2toaf/vQGCIJd+mx4vcDGBoVAgBi2TxoAACAASURBVIJOx0unIFNFIROqqoD/+T8ZGemgABgAGKDXWxGP81KCndVqxdWra3jyySokEiZotTrodDpotXpQFAW7HfjKVxKort5VXuyeW/GzSi6TbI2jSqVO0Ol0qK6uhk6ng8fjwU033ST56CfL/OSDkwcNWXon+DoAh5MLQe4jR44cUQyFk5mWV155BX/zN3+DtbU1WK1W3HXXXTh79izOnj2LEydOFCSM78tf/jJ+9KMfYWJiAiaTCefPn8dXvvIV9PT0HPixS4EyWSgwsiELLMtienoaS0tLaG1txenTpw80nFjsNgQJfYrH42htbYXX683JVpqanAQMBggDA+INkYQjTU2Buno1LVlIlmlSr78O6tIlUFtb4qJ89Cj4O+4AWlsRi8UwPj6O7e1t9Pb24siRI1ktKvJWR7KckCxiABCNKv/uhYYPoNf9IoxcGBBMYks+FBK9FH7v97I+N6ng9Xrhcrmg1WoxNHQDfvpTB8zm3dAoihK5EsOI/X/ycWNZsXBzkPtaqkIPkcOur6/j2LFjkgPntWsCvvtdDQyGBDSaGBKJIBIJFixrRChkwOKiFyaT2F+WLw7kHCsJxF7jKLKIJS9mpQySIsdCci/kfXJS5iYhSwzDwGKxSATCbrfnJN08LPXFYSzcpSYo5J4sf155++K+++7Dfffdhy9+8Yu4cuUKOjs78dxzz+Hhhx/GXXfdhccee+zAx/Diiy/i4sWLuPHGG8GyLD772c/ijjvukDY3akeZLGSJQqghiLxwcnJS2vlmm/i1H4pFFliWxczMDK5du4bW1lZ0dXXB4/HA4/Hk9kByIiQ/jzy/b+NaXlmgZmZAP/ccBI1GLO+zLKiFBVD/8i9Yes97MLG6irq6upwjueUuh5JJk4wkGAwC7HYBfj8F+SjKc6Y/QEv9Fbx343+DDvlBQQAMBjD33w/+woU9z7OxASQSez9Der0AMsNKSOTa2ho6OzvR0tICt1v8G7NZqexsaBCQSACnTnHSSEQ0KrotRqMUVlf3vla9Xtgv1gKAGJ8hb2dsb29jamoKNpuY52EymRTnTnSe1KCiQvw5x3HY3mawucljY2MDfv8GaJpWKC/sdnta34fk90L+XKVWXuw3P6DRaPZIN+XDk/Lci+TqQ7rci1xzGgqBt8PMQi7Pmek+Ho/H0dvbi89//vMAILXcCoHnn39e8f13vvMd1NXV4fXXX8ctt9xSkOcoJspkIQdkIxVLRxbIJHs4HEZPTw8aGxsLtoMoxsyCIvRpZAT2y5dBf/3rqF1YAF9VBcpkgjA8nNVjCf39wE9+IgY7ka1rMCgmKe4YJqWCgiyMjorKCVKy02oRbW6G7/JlbJrNOHnnnQqzqmxBURRisRi2trakMrL8famvB/7qrxIIBlPdUL+Ma2sfwLHlF8FpNODe856U7YeNDeDTn9bD79/7CHY78MgjCdC0B+Pj4zCZTBgZGUkrlQXEMQizGWAYCokEJfGtRAKYnKTxyCO6Pd5SiYT4N3/xF4yiemAw7BIInw/45jdFmSiZTYlEEnA4TqGpyYKTJ1nIuEKaY9PAZNLAYqEwNDSEI0d2J9X9fj/W1tYQjUalHTj5qqioyFh9ICSV4zgwDLNv9aEQyEUNQVHUnpAlkntB2hdut1uReyGXbsrJ0DuhDZGOMBXzObOp3gaDQcV9hFSVigH/zg2hKhdb1ENEmSwUGMkLtzySubm5GcPDwwX3QyjkzEKq0CfN//pf0Pz93wMsC41Oh5rJSWgfeADsl74E4bbbMj6mMDAA/rd+C/TPfgZpy6vTgb/lFggjI2n/TjGzsLUFYeei5Xkem5ub2PR40GQ04mR3N6gciQLZwRIZ1tWrV8GyLGw2m+R+6HA44Pcb8LWvpV7oAcBuvwFf/eoQ9lO4JhIU/H7Ro4m0EgDA56Owtibgl7+cA0270d7ehcbGRkSjKX2qJJhMwKlTPLa2KHz844z03G43hUce0cFmExSLeiwG/Nd/0YjFKGxv6xT/53AI+NKXGNTUiIRCJAphhEIbsFj0aG+vRyKhQyBA5TVAKU+UJPLFRCIhkYf19XVMTU0BwJ7qA6kQMQyDyclJbG5uore3FwaDIW31IdvQrGxwUOmk/LUTkCl9v98vmQwBYsQzWZQSiURWgUeFwGFJJ4udjpuMbDwWAHFT19HRUfTjEQQBDz74IC5cuICBgYGiP18hUCYLBYZWq5UkZJubm5iYmIDRaMTIyEjRLEQL0YZIG/q0sQHN974nDiW2tEBgGISNRpiDQWi+/W2wN9+ceeJfowH/P/4HhKEhUC4XwHEQenognDixr72ynCwIR46AnplBMBTCyuoqNDSNzpYWmDUa8FVVyLZATXapGxs8YjEBFGVGXd0p1NWJREmUWvmxtTW3M/zkwPLyCVgsNGw2HXQ6rdRJiUREEiCmMu4ewfo6FEmNa2sUIhEKJhMvtRKiUWB8nIPfz+M732lAXV23dDOz2wV87nMMSPBlKphM4ldNjVj9AESRiU4n/jx5oJvnKWg0QGXlrvVyJCISFnL8LMvC4/FDp/OjpaUadrsNAIVQCNhPDSxmSQhJ36eHXq/fY7Qjrz5MTU0hEonAbDbDaDQiEAjAbDZjZGRE0QYhVQd5JHguoVmZUAxlQqrcCyLd3NraAgD8+te/htFoVFQfrFZrUSoAonLl4MN7uT7nYbUhMqFUiZMf+9jHcPXqVbz00ktFf65CoUwWckC2bQgAeOONNxAMBhUDYcXCQcnCntAn2SpFjY6K7YP2dvH7ndch1NSAmp8XfRNaWzM/CU1DGBpK6daY/k92yUKirw/eX/wCsZdfRm13N6rsdlDXrkHo7s5aeUAWls1NAV/8on7HlVH+vugB2OFwHMXDDzNwOFi4XCFoNDQoKopo1ItIRIBer9/JYjCC55U7wPV14IEHyGOLiMWA6WkKFosGt93GwWDg4PEEEIlYYDDo0dpqQ0WFuOBGo+LuXpxvkC/AyteS/H020GpFywf57ANpx25ubuLKlRnwfC+am5tht2cuE4vzHKIJVLLRkt0u/v9+8HrJfAQFwAqdzoqamqM4cgQwGqPSwKrJZEI4HMbLL7+sqDw4HA7o9XppEcgmNCudcVQqlMKUSR7xbLPZ4PV6cf78eWlwcnt7GwsLC2BZVmFxbLfbs7I4zoR3ysxCNoZMQGlMmT7+8Y/j3/7t33Dp0iUcPXq0qM9VSJTJQgHBcRzm5+cBiOYvKR0Ni4B8yULK0KfkG4fBIFYOOA7Y6ecLgiB9jyKWE4m19OrqKibm51F3663o29iAfnMTiMchnD0L/tZbkamRniyHZBgN/H56x9RIuaCR3bY4CyDmD5jNOlRVmWCxACy76z0QDAbg9Wrw2mtT8PsNcDgcCAarsLlpgFYrSKdGXKvEAclgMAqvdxsUZYHRaIQgULBYOEUlwOsFVldFlYPXC9C0AI+H2nO67XbhQMoHcm4mJiZA06vo6OhHbW1t1mZJtbWiPFJeRSEwGATsFA5SwusF/u7vdPD59v6f0RjFzTe/hZoaDc6fPw+z2SztwInr5MzMDMLhMEwmk4JAJNv8Jg9NEsJIsF/1odQOjmSgUqvVSoFh5DhI1YsoL8bHx6HVahXKC6vVmnOL87BmFtRKUIpZWRAEAR//+Mfx4x//GL/85S/RvrMBu15QJgs5YL8bx8bGBsbHx6WdTnt7e8mGeLRaLeJpbJNTYb/Qpz2/OzwMoblZ3MW3tQEUBYplQfl84N/znt0aeBEgCAKuXbsGhmF2fSgEAZzPJxKVdK6RSY/BcRx2kp5BURpsbNAIh3c7IMmClHTDzxQlavDF99UCvV78WXt7O4zGbbjdbrz6qhtXr56DIABaLQ2KElsA4s6bx+pqFM3NNeB5o5S8uL4uqi4BsYjz2ms0PvEJHXYG7cEwIuHQ6wVcvMhIP9fpSBUCaGyU2ykrjzscFrld8joSjUaxtRUBy7K49dZzCATEnWokspdApYNICHJXKSQS4kClySSfr+CxsuLH8nIE73//UQwP71bk5Dtwshsj5kk+nw8ejwezs7PgeV5aPEn1wWAw5FV94DhOFSFSculmcu4FGZ4kCY2kQkHOgdls3vc1vFN8FrJ5TtIOS+tGe0BcvHgRTz/9NP71X/8VVqsVbrcbACSJrdpRJgsHRCQSwcTEBLxeL7q7u9Hc3IwXX3yxZI6KQG6VhX1Dn1LBbAb3qU9B+/nPg5qbg0YQYI5GwQ8NgXvggcK8gCSQ+Ynt7W3YbDaMjIzsEi+K2tf1kUBeTVhbA/7szwwIBsXXmUgAi4uiisBkAu64g0sXOAlAXKy9XgrxuHJRjMUo0DRQXV2N5mbxmFZWKMTjWgDCjkmSsENYAICGz2eHwSBaIG9uisfz/PO7cxAcJx5fIEDh1ls5KXvL6xVJxGc/q99TTbBage9+NwG9XoDDIcDnoxSEIRoVH1evFxCLATzPwefzw+9nUFHhwPHjx2E0imQqlUwUKEwVIxXIfEUsFoPb7QZF6VBfX4+jR5Uq21Qg5kmkbUZChkj1YW5OnDsxGo0Scci2+sCyrDStTpQXhRyeTIVcFu5UFsfxeFwiD2tra4rcC3kFIvm1vxPIghraEH//938PALgtaSj8O9/5Du65556iPGchUSYLeUIeUNTQ0KDQ9xcypjobZEMWsgp9SgPhppvAPPUU6P/3/wCPB+M+H3ouXoSxCFUFv98Pp9MJjuNQXV0Nh8ORc4VGPvQGAPE4jWCQgtEo7mJjMUCnE8v6iQSw36mLx8UWgBhzr1y9tFpgYEBQ9OZZltoxcqSg0YjZEjwPcJz4t4EAD46LIRzWgufFag5NC9Bodh9bNIoSKweExIRCoumSXq8MsRS9FcR/GxuBhx5i9vg5bG8DX/uaFsEghe3tBILBIHQ6HazWSlRVUTAaRetHhwO4eJFNqXpIft7CQYDHswWv17vjmliJ7W0aQO52lPKQIWLdTBZ9v9+Pra0tzM3NgeM4KbKbEAh5ZHckEsH4+DjC4TD6+vqk1lu+sw9Zn4kDDlQaDAbU1dUppJvhcFgiEBsbG1LuBSEOiUTiHUEW1NKGuJ5RJgs5gOzAPR4PXC4XNBqNIqCIoJTBTtk8X9ahT/uhqQn83XcDANw/+xm6CmAmJYfc1bKjowMdHR0YHx/PKUgqeXcol9IB4i7WYhGTqLVa8d9MnM7hAC5c4BUzCIBIOOJxCn/yJ0wa2aQAQeD3LCbxuBEUZUQiIYCQD44jByEOXIqR00Cqe4sov1T+TN6BEofslX945AjwyCMROJ2z8Pl86OjoQF2dDRTFKXwWyOstFRiGwfKyG2Yzh9bWFuj1hh1SVjiIplF7qw+EQMzPzyMYDMJgMMBut4OmaWxubqKurg5DQ0MSUU1lHJV8zR1UulnoECl57gUBad34/X54PB5EIhG4XC4sLy8rqg/FlG4ehhqCZdmMrykejyMejxetDXG9o0wWckA0GoXT6YTH40FXV1faEKVSVxbSPV88HsfExAQ2NjayDn3KBsk2zAcFMYAifunE1ZKoITY3U0v3jEaxZy5vObjdAuJxccElN97V1dRJjBwnfoXDu+rPVP15i0XsfMj5USgk7tiT7R0ikSgAPXie7BIpyE+VwSA+nlZLwecTS+11dRoYDOLxJxIc1td14HkBW1seaDQU9Ho9GMYIMachd6yvr2Nychy1tZW4+eZTspvm4ex0xDbTEtbXjaittaKqyoZ4nEI8nn5epFCQVx+OHDkCQFxItre3MTs7i3A4DI1GA7fbjXA4LFUekqsP5HUcxLY6GaVoCSS3bl5++WW0tbWBoij4/X4sLCwgFArBYDDskW4WaoFX64BjcIeplkI6eT2iTBZygN/vB0VRuPnmm/dlqYfdhhAEAUtLS5iamkJ1dXVuoU95PF++iMfjGB8fh8fjQU9PD44eParYWdE0DY+Hwle/qk05Na/XA5/8JAu7XbxZb20BX/qSEdEopeivx2LA7CwFnU5sCyQS4iIdi4lkwedTkgmHQ4Ben9tCSoKfFhfjAG5IWx3Q6cQv+ekT4zLEqHGtVrOzyNDQ6x1g2RgikQQ8HhYsq8X2dnTHJVsHrVaDeFyTNkAqkUhIBlu9vb15B5UVEqFQCGNjY/D7aXR3n0Y0asT2tvJ3HI6D5VvkCp/PJw37Dg8PQ6/XS8FR8gVUp9MpyIPNZlP0wZOrD8lZI8D+1YfDmB8QBEFy0yS5FyzLIhgMwu/3w+fzSUPGZHiSvPZcci8IyLlRYxsiGAxCo9EUzbHxekeZLOSAxsbGrCyFD5MsBINBjI2NIZFIYGhoSOpfFhL5RkcTkATLyclJ1NTUpCVfNE0jGuV3puaV5fetLQG/+hWN2Vkt9HrxY5xIAAsLFHQ64MwZXmobrK0BoRCNq1c1UgWBzBLQNPDHf8xieHh3Vc8mQ4FgYwNYXQ1genoaWq0WbW290OvFeQWy4DGMaM0svibl3/O8mCApPy6GEeceAgGdVAYXg6NoLC9XYHWV3yEhwo68DxgdXUd1tQFWqxUURWF9fR0TExOorKzE+fPnS268kwxBELC4uIjZ2Vm0tLTgzJlOnDlDI5HYy3T0eiCps1cUcByHqakprK2t7fFDSRccRQjE4uKitIDKCYTJZMq7+lDoNkS25yCZoBDJsDz3IhaLSdLN5eVlBINBKd5ZTiAyDRGS+4YaBxyDwSAqKipKTtiuF5TJQhFwGGSBYRhMTEwoQp+KdUEepA0RCoXgdDoRjUYzkhnRL1+8uciDlARBgN8v7KQsisZAFCWWsGlaLPsbjbu/bzDs3eFT1O7CXV0t4MiR/SsJqUyRAgEOH/sYg2BQB6NxGEajEeGwOAdBFnz5XIQooxTJA8vuHpP82EiiJM8DH/kIi/e8RzzPb75J44//WA+AAk3vvq8cJ4CiBPj9frzxxrLUD+Y4Ds3NzWhrazt0ohAOh+F0OsEwDE6fPg3HzmBEKQhBOvj9foyNjUGv12fM4gBSB0fFYjGJPFy7dk0aHE22rd6v+iAnE5GdDxnLskVXXsiPJ9NzUBQFk8kEk8mE+p2hZp7nEQwGJQK1traGWCwGi8WiIBAWi0VBgMh9Q42VhUAgUHRDpusZZbKQA3JJnszF9+Cg8Pl84HkePp8P586dK/oHPp82hFyN0dzcnFUstyIbArvTxGSHBihJASEAycTAYBC/jh7lIW9HxmKi/HG/4otOl1pOGIlE4PV6EArVoLa2AhUVGgACKisBvZ5DJELhL/+SRUODgNlZ4HOf00MQRJJAviiKVDioPYoMjQZoa+PR3Cy+GJbl0dUloKJCmfsQjQKhEIULF7phNFowOTkJk8mEaNSGsbEQXn31Vck62Gq1or7ehvb2/bX3hQJph83MzKCpqamoBDZbkM/h4uIiOjo6pH59rpAvoHLvA3n5fmlpCYlEAhUVFQryYDabFedBHgHe29t74NmHbEGeJ5/HkyeJJmd+BAIBrK+vK3IvSOVBp9MpUl1LhWyCpIgS4rBbdWpFmSwUAVqtFuFwuOjPQ0KftneavjfccEPBQ6pSIdc2xPb2NpxOJzQaTU5qDPnziORglyTkckHH42KLYm2Nhjxdm3gaPP00jeTsmJoaHr/1W2LV4iMfYaW5ABLb7fF4YLUewyOPVKCiYjdvAQDq6kRfhBtv5NHaKqC3F/jlLzn4fMpj3tqiMDtLoadHUJCYaFSsXHR2Ko9JpxNgMimfS/x9AePj46io2EB/fz+Aetx/v2g5LQg8WJYDy7I7E+FRXLz4a7S1mRTl80IbiJFh4Gg0ipMnT6oiWY/MSwiCgDNnzhScVGs0GjgcDjgcDrTuWKCT6oPP58Py8jLGx8cVHgk6nQ6Li4swGAxSBHi2kd0HrT6Qa6lQBC5V5odcujk7OytVT5xOp1R9KEXpP5sgqVJYPV/PKJOFIqDY0kl56FNDQwNuuukmvPjiiwVVKOyHbF8fSQtcW1tDV1cXWltbc7opkHaHKHcTwPPCzg0SKS2GCXhe2TaIRrHTEhAULobxuFhZeOQR/R4DIIoCfvjDmEQYAKIqmIDNZsMNN9yA9fXsXNdqaoCvfW2v/8HyshhdXVsr7FFaJHs6pIIgiEOioRADjUaDc+fOQa/XY3GRgt9PfCUoiJe5FtEoEItVoLf3FGy27T2R0fK0zUzOf+mPScDKygqmpqbQ0NCAkydPloTAZjqmpaUlTE9Po7m5GV1dXSXrS5PY6uTyvc/nw+rqKkI71p0ajQbz8/OK8588+1Do0Czy98U6F3LXTeJ74fGIUexmsxnb29uYn58Hz/NS9YW0MAqRe0FAzls2ZKGshEiPMlnIAbm0IYo1syAPfTp9+jSqqqqkHQLLsiXpT2eaWRAEAevr6xgfH5fspL1eM3ZiMyRsbor/Jns7GY1AQ4OwY04UgdEYRySiRzS6e1OLxXZNlUgRJx7fLe2LaYriz4n6Ibk9kc4jRRDEL4+HBsBJElQS253R9TIFUvkfMIw4jJksC90v4ZH8H8/zCIXCiER4mEwW9PT07FFwmEx7raxjMfEG3txskcrHxPnP7/eLORwTE4rdr8PhyGp4LRaLSe6gQ0NDWQ0DFxuxWAxOpxORSATDw8N7PFFKDZqmodfrsbGxAZ7ncebMGRiNRqn6QM6/vMxPzr9OpytoaBYh/KUc6KMoCjqdTspFILkXpPpw7do1SXkiH5y02Wx5V0DIOcl2wLGM1CiThSKgGGRhv9AnIrsrlRHUfm2IaDQKl8sFv9+P3t5eNDY2YnWVwgc/qJPyDwBxyG9lRVxwu7uVVsJWq4AnnojDZrOiqUmPP/zD3yAc5qTUPavVinjcjoceqkA8Tilklc3NAsxm4JFHEtIswltvUfjIRwwAKIU7YbJ8MRlbW5B2ydXV1WlVBcneANl6BRgMAmw2AYHAXntlm03pDGk0CrBagWCQQjDIIBqNQafT7cwjUDAa85+RSeX8J++9r6ysIBaL7XE9JNI5kjUyOTmJ2tpanDt3rmS5KOkgCALcbjcmJiZQV1eHEydOHHqFA4CUyVJfX4/h4WFpAUw+/6FQSLKtlld/5ATCYrEcKDSLLKKl7NEn7/DluRdy5Yl8eFI++yEnENlWv8i9uFxZOBgO/+q5zpBtTHWhyII89Mlms6UNfdJqtSUjC6kqC0QaNz09jYaGBly4cEFaWGMxsbRuMOymJsZiuzt40vMXBLH/HghQiER41NebcPLkSZw4Ie4+fD7fzg3UjVAohIsX7TAaKyUCQW4ek5NiwNKOtT9CIQrNzTysVgE79yMAgNMJzM6mv4HMz69gdnYWx48fT6nayGWxT4WGBuDv/i59auPO3BwA0cr5m98MYGxsFqFQCF1dXTvGOgyMRuXrOijku9qWlhYAyt67fPLfarUiFoshHo9LWSOHjUQigYmJCWxvb6d970oNolba2trKeEw0TUu7aQJ59cftdmNyclL6PTmBy6X6EIvFFJLNUlQYsnFvlM9+EBDpJql+yV+/nECkIqlEHprp9ZVnFvZHmSwUAYUiC7mEPpWyspD8XIFAAGNjY2BZFsPDw5I7HIHHI7YCDIbdcCD5v2az+EV6sbEYdi5u8ju7uw/iuscwjLR4+f3L2NgQDbNWV4/g/vuHdrIYKKn9QNQHw8OcNIOQzsyIQKfTKXbJa2t7ZyU+/WnxQZLv/cmLfTqIv7M/qRAEAaurq5ifn0JbWy16ek7tHNP+f5dvxSMVknvvHMdhcXER8/Pz0Ol0oCgKY2NjWFxclG70xPWwlPB4PHA6nbDb7arwlwB2B3wtFgvOnTuXl5VyutwHUn2YnJxEJBKB2WxWkIeKioqU1Qefz4fx8XFUVlYW3LZ6P+SbC0E+f8nVF0Ig1tfXEY1GYTab90g3sxluBESy0NbWlvOxvVNQJgs5ohSVBY7jpJCqbEOfSt2GYFkWHMdhZmYGi4uLaG9vR0dHx56Lcn0d+OIXtVhZoaQ8BkBsAZDdeCwGmM2i2mE3H4HCfouhTqdDTU2N1BcnNw+3OwGWpUBRAmiaRAxTYFkaPA+89dauMVMmslBfXwedTjyna2vAn/6pHoHAXrJmswl44olEQXf3BPI5gIGBAWnSfD8YjcK+6ZFG48FsnpN37g0NDYres8/nkzIXUiU+FmMHy7Ispqam4Ha70dPTgyNHjhy6BI7neczOzuLatWtSIm2hjkme+5AsXSSL59TUFAAoZJs2mw1ra2uYnZ1FR0cHWlpaQFGUYnCymKFZhbJ6llcVSGR5IpGQjKM2NzcxOzsLQRBgNpt3bOM3YbPZ0pK1chtif5TJQhGg0Wjy1jDnG/pUSiMojUYDv9+Pl156SZJ8pSvfiS0ISjIbIgs1OS2CIBoLEaKQ772U3Dzq6mjQNAWdjoJWS0k3P47jwDAa2GwROBwATWvg99PY2EhPwhyO3UU1HqcQCOwmVxJEo2KctFhxKFzWAlEVTE9Po66uDoODg1nPAdTXA48/nkAstvdkGo3CnoHSXLCxsYHx8XHY7XbFLjlV75llWQQCAfh8PmxtbWF2dhY8z8NmsymUFwfd/ft8PoyNjSnkh4eNcDiM0dFRCIKAs2fPlmRwLpV0MRQKSQRicnIS0WgUFEWhqqpKkninqz4UIzSrmImTer1esYEgoWFk5mZubg7hcFgKDZNXH7RaLUKhULkNsQ/KZKEIIINUuagTDhr6VKrKQjwex/r6utQayXa3RNMiURBPjSDlIYjyPyASER+jsEFCZJiL2CUDVqsOdjsDlo2D5wVsbtogCALsdmbHplkrxUxfuLB38SfJlXLsp17IB2RINBwOY3BwMC9VgUgICkdeiAx2c3MTPT09aGxszPi+a7VaVFVVSR4L5OZNSuczMzMIh8MwmUwK8lBRUZHVZ0pusNTZ2YnW1tZDryYQK/Pp6WkcPXq0pDLNZFAUJVUfDAaDlKbZ0NCAUCiEzc1NzMzMgOf5Pa6TBoOhKKFZpYynJqFhNpsNul0yewAAIABJREFUwWAQp0+flggsIbGLi4v4whe+gEAgAKPRCKfTibm5ObS3txf0s3Tp0iV87Wtfw+uvv461tTX8+Mc/xu/+7u8W7PFLgTJZyBHZLYwi686GLBQq9KnYZIHsdCcnJ2E0GlFZWSkNv2UL8fCEnWrC7s+DQWVFIZvhwHyh0WhgNGp2qg1xaLUCeJ6CTifKJFk2DpqmYTYLCAbXEYlU7OxUS+N4KPcokEckHyZItauiogLnzp3Lew5BnvhIdPdk9sTv92NjYwPT09MAdkvn8sE9OYptsJQPEokEnE4ngsGgaoyoOI7D9PQ0VldX0dvbK838kNkTuXFSMoGTkwer1VqQ0KzDiKeWE5RUBPab3/wmfvWrX+GJJ57Af/zHf+Db3/42HA4HRkZG8I1vfCPn+1wqhMNhnDhxAvfeey/e//73H/jxDgNlslAEUBSVVVsgEAjA6XQikUjgxIkTWfWj06GYZIF4+4fDYQwMDIBhGKytrWX99zQt7uw5TlCQBHHNEfDwwyyGhnZvMgbDwaf7k0+F/HuWZRGJREDTFDo7dQiHtXj8cR6trUAiwSAYDIJh/OD5Tbz8cgA6nQ6RSD3i8V4wDA1B0BR8B0uqCZFIRDUeBfI5gOSgpUIhefaElM5J9WFiYmKPbDASiUgZKJ2dnaoI/tnc3ITL5UJlZaUqpKOASKhGR0dB03Ta/ItUxkkMw0iDgx6PR9E+khOIfCK7GYaB0WgsacLmflbPFEWhp6cHx44dw6OPPoqnn34aZ8+exX/913/hN7/5TcF8Od773vfive99b0Ee67BQJgtFwn5kgVgGX7t2DW1tbejs7Dww2y7GzALP89KgZVNTE4aHh6HVarG2tpY1MREEMe75zBleZhokVhIiEbGqcPIkj5aWwlQSHA7RpZFlRSfH3eMQ1RAsm0AoFIHRaILBYEAsJrYn2tsFdHcLAHQAqna+2qW0wbGxMFiWxeZmAn4/B61WA51OD5bVQRDyXxjkZeuGhgbV+AGQCX6TyVTSOQB56Vw+uEfmHqanp6Xp9mAwiIWFhZSBTaWCPLmS+IqooRVCKlTNzc05EyqdTofq6mpJ1UTaR2R4dW5uDqFQSBpezTay2+v1wuv1oqWlRbpXFVN5QZCLGsJqtcJoNOLcuXM4d+5cUY7nesXh35WuMxzUxZE4G5KbcKHKp4WuLHi9XjidTgDAjTfeqNA8Z5sNoRySIkONu+ePpkU5ZSFx+rSA55+P7clhmJwM4StfsYCieGi1NggCjVgMyJT3RdIGu7oq0dioRyBgAc9ziMc5hMMsOC4OgyGAq1cnEA7vytaS0/ZSQZ6fcOLEiT2S08MAUbisrKygq6uroBP8+UKn04FlWbjdbtTX16Orq0uhvCADbPK4aIfDIZlGFQtEMqzVarNKriwFGIaBy+WCz+cr2GdK3j4ibQzS+/f7/ZJtM8uyiuqDw+GA0WgETdNYWFjA3NwcOjs70dTUtK/yotChWdnMSZCKVlkNkR5lslAkaDQaBVkgoU/EMrjQJV2NRoOE3J4wTzAMg+npaaysrKCzsxNtbW17Lths7J7JTUCvF7MVdhUDShRjPuH0aaKu2B3M294Oorb2JiQSJiRnfFksouvjfmhsBJ54ItlAScxcoGkKJlMbfD6f5GRI7JLlYU3khiWvJjQ2NqoiPwHYtRLX6XQ4e/YsLMmTnIeARCKB8fFx+Hw+hXRUr9enNY1aXl6Gy+WCVqtVkIeDWAbLQQzIZmdn0d7envIaOQxsb29jbGwMVqtVygkpFlL1/olxmt/vx8LCgmTbTO4Hvb29aGhoSJl5kfyv/N55UOmmGKC2/64kFArtDDpnpz57J+Lw71DXGXKtLCSHPt18881FuYgLUVlYX1+Hy+VCRUUFzp8/n3ax2O+5kgedGhoofP3rqV0KAXE+4SBSvv2wvr4uOV/+9/9+CufPC4hE9pYSzGagqSkzYRHnKFL9ng7ArmRNHhZEHA8ZhoHVaoXFYkEgEADLsqoZgpP7AahFVQDszgE4HI6Mi18q0yjyHvj9fsV7QMgD2fnmAlINisViuOGGG1SxuMhVIceOHcPRo0dL/v6lMk7b2NiA0+mU3puZmRkpLya5+pApNGs/2+pMBCLbECkA5crCPiiThSKB6HYvX76sCH0qFpIrGbkgFotJUddkYnq/m02qNkTyRLQ8s77QMr5MSBf8lA0hKATkdsmtra3Srmtubg5utxtarRYMw8DpdEqLVi6SwUKClNJpmi6ZH0AmkMHK9fX1rGWayUi2DBadQWN7dr56vV5RfdjPNMrtdmN8fBx1dXWqqQZFo1GMjo6CZVnVqEIIebl27ZrCICv5Pbh27ZpUyUoOzdJoNAULzdpvwJEgGAzCZDKpYjBVrTj8T/vbEAwjTtRHIhF0dXUpQp+KhXyyIQRBwLVr1zA1NYX6+vqsqx7JbQjC/OUe84exM5UHGu0X/FRqRCIRuFwuxONxDA8Po6qqCizLSmXzZMmg3C65WAsSGV5dWFhAW1tbST6j2YAYLBmNRoyMjBRssJKiKJhMJphMJkVgEZEMkr47x3F78hZomsbk5CQ8Ho9qsiaA3VCqhoYGHDt2rOSSxFSIRqMYGxsDwzA4c+aMgnymew/I7IO8AiSfPyGhZfmGZmUz4BgIBGC1Wot23wqFQpiZmZG+n5+fx5tvvomqqqqCSDNLgTJZyBH7fZjkoU80TaOxsRGdnZ0lOa5c2xDBYBBjY2NIJBI4depUTlI98lzJfcbDIgnA7kxIKBRSzQ2dkLHZ2VkcOXJEkTKo1Wr3TJwTySCJKpYP7cnL5gc9x8FgEE6nE4Ig4MYbb1RF6VXeCunq6pJsiIsJjUaT0jSKkLjZWTG0i8Qqt7S0lFz2lwosy0oGWWr5rAO7bYf6+nr09PRkRV7IADGRKJLqAyEPS0tLkqOtnMAR5UWm6kM8Hkc0GoUgCGAYJm31odghUq+99hre9a53Sd8/+OCDAIAPf/jDeOqpp4r2vIVEmSwUCMmhT6FQCLFCW/vtg2zJAsdxmJ2dxcLCAlpbW9HV1ZXzjoTcxBmGUfQND6uasLS0JM2E5GKLXEwQbwpCxjLptVNJBpOTHp1OpzTYR8hDLlkLZH5mbm4OLS0tqvEoIH4AFEUdaitEPvXf0NAg2QM3NTVBp9PB6/VicXERgiAoLKvtdnvJKlh+vx+jo6NS5aXUQV2pwPO8JB89aPKovPpAHofMnxACsby8vEf9YrfbYTabFdc+Gfi02+0SIUxnWx0MBovaBrztttsyZgqpHWWycEBwHIe5uTnMz88rQp+IlKhUyGZmgTjx6XQ6jIyM5LWjFAQBFEVBo9Hg5ZdfVux6i1nGSwVC0OLxuGqGBeWT8sTuN9/ycKqhPXnZfG5uTmHVS96HVGSJkBeGYVQzmCc/V62trejo6FAFeQmHwxgbGwPP8zh79qxixynPW/D5fFhfX5fSHuWzD9lIZ3OB/Fx1dHSgra1NFUOoJAMDAM6ePVsU+Wi6yGpyLaysrGB8fFxSINlsNsRiMaytreHYsWOS/De5+iCfs7p06RK2trYKfuxvJ5TJQo6QX6Aej0eSaCWHPpUy2Ik8X7rKQiKRwOTkJNxuN7q7u/OadpdfWBRF4ZZbbpH81T0ej9SPk5MHuVywkJDvkA+6IBcS8gX59OnTiptbIZCqbC6PKZ6amkIkEoHFYlHsuIgLn5rOFeltx+PxopyrfCA3M2pqakp5ruQVIHnaISEPbrcbk5OTiiHXg86fxONxjI2NIRqNqoboAeLMxPj4OJqamtDd3V1SopdMpIkCaWtrC0tLS2AYRno/Q6GQ9F5YLBYFmY7FYvirv/orPPPMM/jTP/3Tkh3/9YgyWcgDRPtNQp9SLb75DBweBKnaEGSGYnx8HA6HAxcuXMhrYEwuYwJ2S3fJCxfpuXu9XiwvLyORSMBqtSoIRCa9cyYEAgG4XC5JYaKWRYbs+ohjXikWZLlVr3zhIuRhaWkJLpcLAKRzT3qzh0UYBEHA6uqqlH9x6tQpVagKEokEXC4XAoFAzmZGyWmPJC6dvA/y+RM5eTCbzRlJ++bmJpxOJ6qrq1Xj7slxHCYmJrC5uYnBwcED2dQXCjRNS+TAbrfj+PHj4Hleqj6srq5Ks2SXL1/G1tYW+vv78dRTT4FhGLz++uvo6ek57JehalDC9d5IKTF4nscvfvEL2Gw29PX1pe0Zbm5uYnJyEhcuXCjJccXjcbzwwgu44447QNM0IpEInE6nNENRX19/oGoCaT/k8hjEpIV8hUIhKWGQfGVbriXtHmKRrZbp/VAoBKfTCZZlcfz4cdWQF7mFdH19vcJzgGEYqedOFq6DkrhsQBZkv9+P/v5+VSwygFghJDLWvr6+oswfxONx6fz7fD4EAoE9Q3vySly6AKjDRigUwtWrV6HT6TA4OKiKmQkySDwzM7PvcCwhcT/+8Y/x/e9/H2NjY9je3kZPTw/Onz+Pc+fO4X3ve59UrShDicOnqdcZiB4900VS6jYEuckkEgmsrq5KE/hkhiJXJFcTciUKAPbIpEjCoLxcK+9HEo11MgkgzoJarVZVWnLSCillNSETYrGYNGgr3yHLVRdyEpccE50ricsWGxsbUoWr2O6C2UK+IMv9AIoBg8GA+vp6RdmcSAblxl0VFRWwWCzwer2qctKUt2haWlpUM19C7K39fn/GSqOYJmvG/Pw83njjDTz++OP47d/+bbzyyiv4zW9+g6effhoDAwNlspAG5cpCHmAYZl+7Y0CU4rzyyiu4/fbbS3JMgiDgZz/7mXRjGRgYyCsxLVm7XEyVA+kzer1eafEiOncyMLm9vY21tTV0dnaipaVFFTcoUk3gOA7Hjx9XRQ9Z7jFRV1eHY8eOZU0S5SSO7H5Jz/2g8ydE5rexsSHZ/aphMC8YDGJ0dBRarRYDAwOHnutASNz8/DzW1tag0+nAMIxC/UKG90p9DTAMI1nVDw4OqmKQGNhVhpjNZgwMDGQkoG63G/feey/cbjeeffZZDA0NlehI3x4oVxaKBKJOIOX7YoJlWcnUp7q6Gr29vTnfUJIdGEshh5QPgZFjiEQi0pQ5kamZzWZEIhGsr68XzGsgH/A8j4WFBczPz0u7KzVUE+LxuNRvl+cnZIvkmGh5z51kLSQSiZSeD/vB6/VibGwMZrMZ586dU03JmsyXqKmdRa5hn8+HU6dOobq6OqVpFAlrkisvitlCki/IaqkIkTbb1NRUVsoQQRDwq1/9Cvfeey9uueUW/Pu//7sqvEWuN5QrC3kgm8pCIpHAf/7nf+L2228v6lDSxsYGXC4XTCYTQqFQXtPShWg5FAoMw0hWv93d3airq1PsegOBgGTRK7dJLvYNnxgZ8TyvqmoCyb+orq5GT09P0W7m8pRHn8+HYDAoRRQnvw88z2NmZgZLS0vo7u5WRXIlILZoSMrnwMCAKuZLAGUA1PHjx9O+h8mmUX6/X4qKlpOHQlwP8jkANUk1WZaFy+WC1+vF0NBQxuopx3H427/9W3zlK1/BI488gosXL6qCHF6PKJOFPMCybEalA8/z+PnPf453vetdRWH+sVgMExMT8Hg86O3tRVNTEy5duoSBgYGsJ7mnp4FAYLeiQC4iqxXo6ir9x0Ie/JRueJTstuQlc5IWVwybZHk1QU1eAESR4/V6pQHWUoLYVcsXLkEQYLFYEI1GpfK+WhZkEpJWV1eHnp4eVagKChEAxTCMJGEm70ey90auplGJREIajh4cHFTNexgMBnH16lUYjUYMDg5mfE1bW1u47777MDExge9///s4e/ZsiY707YnDv2LepqBpGjRNZxWPmgtICW5ychK1tbW4+eabpcfPRa45PQ0MDqY/rrfeipaMMKQLfkqFVF4DyTbJ8Xi8IJJNNdoiA8phwcPKv0i2qyYufsvLy7BYLOA4DleuXFHIBR0OB0wmU0l3qCzLSjK//v5+1QyvFSoASqfT7bENT+W9YTabFeQhnVuh1+vF6Ogo7HY7RkZGVOGGSoYrJycn0d7ejvb29oyfoStXruDuu+/G4OAgXnvttZyksGWkRpksFBGFVkSQwbpoNIoTJ07s6U1nY/lMZhP8/v2fayextagoRPBTKptkMu3v9/sxNzeXs2RTHrKkpmoCwzBSJoCahgWJTDeRSODGG2+UWjRELkjmHlwuF3Q6naJkXsyBPRJKZTKZVDMzARQ3ACqd9wapOqQzjbLZbFhaWsL8/PyhxVynAiF7W1tbOHnyZMZFn+d5PPHEE3j44Yfxuc99Dp/61KdUce2+HVAmC3kg24uoUGSBhOyQwbrTp0+nLKNmIgtKpcPhXkAk+CkYDBY8DCdbyabdbkdlZaVi0QoEAnA6nQCgqmoCcQutqKhQzcInl9M1NjbuWfiS5YIkYZAYdy0sLCjUL2ThOmilRF7eL1UoVTYgC1+p0yvTmUaRa4KYRlEUhdraWmg0GqkacZjnjXg66PV6jIyMZKwOBgIBXLx4EZcvX8Zzzz2HW2+9VRXv+9sFZbJQRBSCLGxvb8PpdEKj0eyxlE5GunyIUsohM+Ewgp9STfsTkyKfzyctWjqdDvF4XErNK4VRUSawLIupqSm43e6iewHkArkCY2hoKKvU0lQJg0T9Ivd8IDkL5CuXRSsSiWBsbOzA5f1CQ00BUDRNw2azwWazwWQyYWtrC3V1dairq0MwGNyTtZDKNKrYII6L2Xo6jI6O4kMf+hCam5vxxhtvHCjMqozUKJOFPJDtjSubcKd0ICXntbU1dHV1obW1NeMFkzyzQGZXSZz0YaZDAsrgp1wtdQsJeQm2tbUVfr9fCg6qra1FMBjEpUuXpIwFh8OBysrKkks2CVEksrV8rLqLAaLAqaqqwvnz5/Mme/KUx6amJgDKnAWyYMgXLVIFSl60iI305ORk2lyHw4BaA6BItXJpaUnhEEmqcXJCTazD5fJZ8n4U+pqQW0lnQ0IFQcD3vvc9fPKTn8QnPvEJfP7zn1fF8OrbEeWzWkTkkw8hCALcbjfGx8dhs9lw0003ZW0YI29DyOWQh11NUGvwk7xc3d7ejra2NomQkYyF5H47aVsUU7Ipdxbs7u5WVf9YbrBEFpZCIlXJXF4FIk6H8gFWs9mMubk5+Hy+rKscpYBaA6DIcCXHcThz5kzKSPBkDxRAVGDJ3weSYCsnDwfJHQmHw7h69Sq0Wm1W1ZdIJIIHH3wQP/nJT/CDH/wA733ve1VxnbxdUSYLRUSubYhoNCpZl5Jc+Fw+/KSSwfO8RBTSVRMyVWcLVb1VY/ATIJaFnU4naJpOWa7W6/VSaRZQ9ttJimMxJJtkKM9gMGBkZOTQnQUJkqscpSqjJ1eBBEFQLFrT09OIRqOgaRo1NTWIRqMIBoNpp/1LBRIAVVNTo5oAKGBXQprPcKXRaERDQ4NU4pdfE6SdR0yj5O2LbD4rJPCOWKdnIuFTU1O46667UFFRgddffx2tra1Zv44y8kPZZyEPCIKARCKR8fcI8z527Ni+v8fzPK5du4bp6WlpUCyfIa/p6WmEw2H09/dLxkr73TBnZqiUqodC+CxwHIf5+XksLi6qSlEgD6Tq6OjIqr2TCsmSTZ/Ph3g8LpVpKysrs75RkuMiZeHOzs68YsSLAY7jMDMzg5WVFXR1danGYEl+XJ2dnbBYLArPB4qiChYRnetxkapQX19fUaov+YAc19raWtEkpPLcEfJeENMo+ftgtVqla47jOExOTmJ9fT0r91FBEPCjH/0IH/vYx3Dvvffiq1/9qipcJd8JKJOFPJAtWZicnATHcejv70/7O4FAQBrIGhgYyMt3nbQa1tbWpGFIea9dfnGWAj6fDy6XCzRN4/jx46oaMiPn5/jx4ynLrweBfMdLXA6zkWwW+7jyBflsajQaDAwMqCLQCBD9L8bGxkDTdMrj4nle8hogX7FYTGpdFKvfHgqFMDo6CpqmMTg4qJqqECnv0zSNoaGhks6+pDLv4nkeNpsNFosF29vb0Gq1OHHiRMbjisfj+MxnPoNnnnkG//iP/4j3v//9qiCu7xSUyUIeyJYszM7OIhwOpwwsYVkWMzMzuHbtGtrb2/POGZArHcj3pMdLApp4nlcsWA6HoygzA+Q1kd2eWoKf5Lv2g1QTckW6gCZ528Lj8WBpaWnPzMRhQhAELCwsYG5uTlX5CXIL4lyrVbFYbI9dtdw2PHnHm+txEQlptmX0UoEMiZJZocM+LmIatbS0hJWVFal1Ski13LJaTgQWFhZw9913g2VZPPvss+ju7j7EV/HORJks5Il4PJ7xdxYWFrC9vY3h4WHFzzc3N+FyuWAwGDAwMJDXTpKQBLlVcyqWTS5OebIjcTiUD+sdtJS3tbUFl8sFo9GI/v5+1exC5fHWh71rlw/reTweeL1eCIIAq9WK6urqvKx5Cw0iPWQYBgMDA6oZyiO5DpFIpCAWxHLbcPIvsUmWL1qZlB4kItnn86kqkVHu6TAwMKCaoU/i9Clvh8hJNalCAMCTTz6Juro61NbW4hvf+Ab+4A/+AI8//rhqVEHvNJTJQp5IJBLIdOqWl5extraGG2+8EcCurfHm5iaOHTuWd/+XKB2IHDLX4CfSVyQEIhwOSzJBQiCyLdEmBz+pZXKf9LSXl5dVVeWQK0NaWlrQ2NiIQCAAr9cLv9+veC9KaZEs3x0fOXIE3d3dqlCsAOJQ3vj4OGpqatDb21uU2YNkm2Sfz4dIJKJ4L+x2u8LzgQRA2Ww29Pf3q6Z3TjIUyGZEDQZegHjfuXr1KgRBwNDQUNo2DWkjPfHEE/jpT38Kp9OJcDiMvr4+nD9/HufOncMf/dEfqabN805BmSzkiWzIgtvtxvz8PEZGRiRv86qqqrQhSZlQLDmkXCbo9XqlEi0hDpWVlSl77ST4yWq1or+/XzU3Ja/XK0kdjx8/rpoqRzgcxtjYGDiOS5tcKX8vSMomkaeRoclCz6AQgyXipqkWH325VJOog0qJVO+FVquF3W4Hx3Hw+Xzo7u5WjUOkPLq5ra0NHR0dqjguQPTmcDqdWasw3G437rnnHng8HvzTP/0T6urqcPnyZVy+fBm/+c1v8Pzzz5e0wvDlL38Zn/nMZ/DAAw/gscceS/k7Tz31FO699949P49Go6q5Nx4EZbKQJ7IhCx6PB06nEyaTCZFIBP39/XlZvBJyQGYT8qkm5AJyI5R/kV47IQ4rKyvw+XwZg59KieRqgloUBfJeO+lpZ7trT5an+Xy+gko2ya69uroavb29qggOAnYlpEajUTW7Y57nsbm5iampKTAMA4qiFHbVhWrp5QPSDvH7/XkPShcDPM9jenoaKysr6O/vz0j4BEHApUuXcM899+Dd7343/uEf/uHQB6SvXLmCP/zDP4TNZsO73vWufcnCAw88gMnJScXP3y5ukuoQ/16HoChqX7LA8zzcbjei0Sjq6uowPDyc1w1dXk0AUBJzJY1GsydRMBgMwuv1wu12I7ijt7Tb7QiHw9je3i6ZNC0dvF4vnE6n5COvlmoCCVmKx+MYHh6WrI6zRSqLZPkMCvH1T07ZzLS4ykOpDmPXng7yEC81ET5gt5JGdsc0TUstPblddS6hZYWA3+/H1atXUVFRgZGREdW0Q2KxGK5evQqO43D27NmM1yTHcXj00Ufx6KOP4qtf/Sr+7M/+7NBbh6FQCB/84Afx7W9/G3/913+d8fcpilLNtVRolMlCEUAWLjJ42NfXl/NjJFcTDtOBkaZp6PV6bG9vIx6PY2hoCBaLRbpJEgvniooKReuiFDctua6dzCaoYXEhJeHp6WkcOXIEw8PDBZkBkKcKkpRNuWRzYWEBwWAQRqNRMcAqX7CIwZLFYlFNKBWgzHVQU4jXfgFQZrMZZrNZsktOFVpGjKXklaBCfBbkVtJqI1YejwdjY2Ooq6tDT09Pxtfr8Xjw0Y9+FNPT03jhhRdw5syZEh3p/rh48SJ+53d+B7fffntWZCEUCqG1tRUcx+HkyZP40pe+hFOnTpXgSIuPMlkoIMiwH1m4GhoacOnSJclJMVskyyEPO/iJLHr19fWK4Cd5DG4sFpN2uyQWmgQCkUWr0IN629vbkqokm51LqUCcOCORSEkyMJKd9Yi23efzYX19XbFgsSyLYDCoqjRG4hEyMTGhuuHKXAOg0oWWkfdjeXkZiUQCVqtVQSByJWyJRAJjY2MIh8OqspKWZ05ka0r1yiuv4MMf/jBOnjyJ1157TTUtlO9///t44403cOXKlax+v7e3F0899RQGBwcRCATw9a9/HTfddBPeeuutt4XUszyzkCdYllXkPpA8h4qKChw/fhxmsxksy+IXv/gFbr/99qxK9GqqJgDK4Ke+vr6cFj2GYRSKi0AgoNC1V1ZW5m3JS/wcVldXVeUqSMKMpqampB2VGmx+SUtsenpamnkhtrxq6bX7fD4cP35cNRK/YgZAJbsckkpQss9AuhL89vY2RkdHUVlZib6+PtXMmcRiMYyOjoJhGAwNDWWUKfM8j29961v4whe+gIcffhif/OQnD73tQLC0tIQbbrgBP//5z3HixAkAwG233YaTJ0+mnVlIBs/zGB4exi233ILHH3+8mIdbEpTJQp4gZCEWi8HlcsHr9UrpbeSmIggCfvazn+G2227LuHM4qByykChG8JNc105kghRFKciDzWbLeLMgJXSTyYT+/n7VyKdisRjGx8cRCATQ39+f0ba2VOB5HgsLC5ifn5eMnyiKUvTak+WzpZJsbm1twel0wmq14vjx46rptcsDoAYHB4u+a5dXgojPgHyIldhWa7VazM3NYWFhAT09PWhqalIFSQbE93J0dBQ1NTXo6+vLeL/w+/348z//c7z66qt45plncMstt5ToSLPDv/zLv+DOO+9UvA6O46SsnXg8ntU98aMf/SiWl5fx05/+tJiHWxIc/rbnOsbi4iKmpqZQX1+Pm2++ec/NjqKojDHV8krCYadDAqJGm8xbFDL4SaMoy21cAAAgAElEQVTRoKqqSiox8jyPUCgkVR4WFxelyXJ5r53szFmWlbzt1eTnQFJCJyYmUFNTc6DI5kIjHA7D6XSmnAFI7rUTmaDf71ekbMrJQ6EkmzzPS6qVY8eOqWrRO4wAKK1WqxgolueO+P1+rK2tSWFZNE2jvb1dNaV6QRCk5Naenh7FZikd3nrrLXzoQx9Ce3s73njjjaLkVBwU7373uzE6Oqr42b333ove3l586lOfyoooCIKAN998E4ODg8U6zJKiXFnIE9PT01hYWEB/f/++pdMXXngBp06d2rPolloOmQmHHfwkCAIikYjCaTIajcJqtcJoNMLn88FsNmNgYEA11YREIoHx8XF4vd68ZbHFgHzOpKmpKa/KUCrJZrJteD4KGJKfQFEUBgcHVTNnotYAKEAkMGNjY7BaraioqEAgEFD4bxSazGULUoGJxWIYGhrKKHEUBAHf/e538Zd/+Zd48MEH8dBDD6miTZctktsQd999N5qamvDlL38ZAPCFL3wBIyMj6O7uRiAQwOOPP47vfe97+PWvf62agc2D4Pp5p1SG1tZWNDU1ZbwJp4qpPgw55H6QBz+limsuBSiKgsVigcVikYYmw+EwxsfH4fF4oNfr4ff78cYbbygqD3JHvVKC+BNUVlbi/Pnzqimhk7ZYKBQ60HBlOskmIQ5kt5utZFMQBCwtLWF6ehotLS2qyk+QB0CpKRZcXoFJJjByMre9vY35+fk9ng/FtA4ncxNVVVVZVWDC4TD+4i/+Aj//+c/xz//8z7jjjjtUU03KF9euXVN8hn0+H+677z643W7Y7XacOnUKly5delsQBaBcWcgbPM+DYZiMv3f58mW0t7ejoaFBdQOMag1+AnazJsxmM/r7+2EymaShSXkwk9zdkOyuinlOGYaRZHS9vb2qMaQCoGiH9PT0FL0dkiplkwzqyQ28EomEZNk7MDCQs9dEsSCvwKgtACoSiWB0dBSCIGRVgSGVOfm1EQ6HJUVSoci1IAiYn5/H/Px81nMTExMTuOuuu1BZWYlnnnlGkvyWcX2hTBbyRLZk4cqVK2hsbERTU5OimnCYLQdAvcFP8qyJTP1s+e6KtC8A7BmaLJQMjwSA2Wy2vC27iwFCYLa2ttDX13doPWD5oB5ZsADxWrFYLOjq6kJVVZUqZJGkhaQ2x0NArFq5XC40NjYeSEaaSCQU70cgEIBGo1FINnO5PohcMxKJYGhoKKMPhiAIePbZZ3H//ffjox/9KB555BHVzPOUkTvKZCFPZEsWSNm8ublZ8ls4TJKg1uAnQDRmcblcsFgsUjUhF6SK52YYRnFzzCZJMBnyjIJjx45lNcRVKhBFAZHsGgyGwz4kACKRm5iYwPr6Ompra8HzvPR+HLZkU60BUBzHYXJyEuvr63vMnwoBeeop+SLvh/waSfUZ8vl8uHr1Kux2O/r7+zNeQ7FYDJ/+9Kfx7LPP4sknn8Sdd96pmmumjPxQJgt5QhAEJBKJjL8zOjoKr9eL2tpaqQd8WOx6Y2MD4+PjsFqt6OvrU03UKyEwGxsb6O7uLth0vCAIiEajEnHwer2IRqMKp8lMhjip2iFqgHwgT22KAr/fj7GxMej1egwMDEjnjLwfqSSbdru9aOZdBDzPS5P7x44dUxVRJnMTGo0Gg4ODJfmcCYKwp5UUCoUku2oi2dza2sLc3By6u7uz8jSZn5/H3XffDUEQ8IMf/ABdXV1Ffy1lFB9lspAn9iML8rmERCIBr9eriIMmixW5ORZ7NxiPxzE5OYnt7W1VBT8BYmmfmFmVIrkyHo8rKg/BYFDh5V9ZWQmz2SwF4KyurqquAkMWY51Opyp1iLyfna2RUXKpXD6HUsgp/2g0itHRUbAsm5VhUKlAjLwmJydVMTfBMIxicJK09ux2O6qrq/dVwQiCgOeeew5/8id/gg984AN47LHHVNOqK+PgKJOFAyAejyu+z0YOmUwegsEgzGazIlOhULsKYqM7NTWFqqoq9Pb2qqbkKg8yOszSPsuyinjuQCAAmqbB8zz0ej2OHTuG2tpaVQy+yUOWOjo60NraqorjAsTFeGxsDIlEAoODg3nnOqSTbCa3knKR3BEr6YPOABQaLMtifHwcW1tbGBgYUI17JbAbTmWxWNDW1qZQwsiDy+SfxS9+8Yt48skn8a1vfQsf/OAHVUOuyygMymThAJCThWQ5ZLazCfIJf7JYGQwGBXnIZ4I5Go1ifHwcwWAQfX19qvEAANQ7KEhK+8vLy6iuroYgCAo3PfKeFCoIKBeEw2GMjY3h/2fvvMOiONc2fi+9CAsqFpSiKHVBFJRuL5Fj4jEqqEcF7B0hnqhYjg1LjDEaE40aBaOoEbvGWKI0QbCGDtItFFH6siy7+35/+M1klyKLUkYzv+viSpyd2Xm3zTzv8z7PfYvFYvB4PMaYLFEBaVpaGu3G2JLvTd2WTWn9jaZaNqUNoJikgwEA5eXltOcEj8djTK2JdItrY+ZU0ksXK1asQHh4OLS0tCCRSLBo0SJMmjQJ/fr1Y4sZPzHYYOEDEAqFtPJiS7VDisVimeChrKwMSkpKdODQlKdCXeMnU1NTxvxopbMJZmZm6N69O2NmH2VlZUhKSoKioiJ4PB7dHSKtpkdlg4RCIV2kRwUQrfUet4TAUmtRW1uLlJQUvHnzBlZWVm0mcS0QCFBWViaTnZNu2dTR0YFYLEZiYiLU1dVhZWXFmIBU+mbcq1cv9OrVizG/Acqno6ysDDY2Nk2qtxJCEBYWhrlz58LOzg62trZ4+PAhYmJiIBQK28U9ctu2bQgICICvr+87PRzOnj2LdevW0Y6dgYGBmDBhQhuO9OODDRY+gJqaGohEolZth5RIJCgvL5dZuqA8FajggVrTpYyfBAIBLC0tW93tsDlQxZVMyyZIF73Jk9qvW6RXUlICPp8PTU1NmWxQS7w+gUCApKQk8Pl8WFlZMaq9j+oo0NLSgqWlZbvOjOu2bJaUlIAQAg0NDXTv3r3dskF1qa2tRVJSEsrLy2Ftbc0YvQngbaYjPj6eVkltarlSLBbjm2++we7du/Htt99i3rx59O9GIpEgJSUFvXr1atN6mvv378PDwwPa2toYNmxYo8FCTEwM3NzcsHnzZkyYMAHnz5/H+vXrERUVBQcHhzYb78cGGyy8JzExMdi6dSucnZ3h6uraZjry0p4KVPAgFouhqqoKgUAAPT09WFhYMKY2QSgUIi0tjZEiRhUVFUhMTASHw4GVldV7K1dSdSjS4kTSS0k6OjrQ1NRs1uum1tn19PTaRGBJXqRVBZlW+EnJD/P5fJiYmND1KCUlJe3esllaWoqEhAS6xZUpv08qc5Weni53UeqrV68wZ84cZGdn49SpU7C3t2+j0TZOZWUlBgwYgJ9++glbtmx5pzukp6cnysvLZcydPvvsM1o0iqVh2GDhPcnLy8Px48cRERGBmJgYAICjoyNcXV3h4uKCAQMGtMkFgVr7FIlE6NChAyorK2ltgYYMmdqSwsJCpKamgsvlwsLCgjHrstJOjK3hg0HNdKkAoqysDIqKijIdF41V+Eun9pm2zl5ZWYnExEQAAI/HY0xHASBrAGVubi7zfadaBKUDutZQN2wIQghycnKQlZWFPn36wNDQkDHBlUgkoh1zra2t5cpcxcTEwMvLCwMHDsSRI0cYkx3x8vJCx44dsXv37iatpA0NDeHn5wc/Pz962+7du/H9998jNze3rYb80cF6Q7wnhoaGCAgIQEBAAEQiER4/fozw8HBERkbi+++/h0AgwKBBg+Di4gJXV1cMHDgQampqLXahkE6fS9/w6moLpKamylQvUwFEawYyQqEQqampjGzVrKysRFJSEsRiMezt7VvFfriuiyC1lETNcrOzs+uZMuno6KCkpATJycnQ0tKCk5MTY4IrJssiy2MAxeFwoK6uDnV1ddplU7qw+OXLl0hJSWnxls2amhp6Gam1vmvvS0VFBeLj46GmpgZHR8cmv2sSiQQ//PADtmzZgk2bNsHPz48x34FTp07h0aNHuH//vlz7FxQU1FM57dq1KwoKClpjeJ8MbLDQAigpKWHgwIEYOHAgVqxYAbFYjKSkJISFhSEyMhKHDx9GSUkJ7O3t6eDB0dGx2alpincZP3E4HNp+uEePHgAgM6vKyMigtR6kg4eWqiGQNlhi2g0vNzcXmZmZMDQ0RO/evdtsDVtBQYG+ARkbG9MV/tRn8uLFC7qzpmPHjoxSiKypqaGNqWxtbRlVN/EhBlDKysrQ09OjizLFYjGtbihtzCTdssnlcuVeDnr9+jUSExOhq6sLR0dHxrgrEkLw4sULpKen05OMpr5rpaWlWLBgAR4/fozr16/D1dW1jUbbNM+ePYOvry9u3LjRrGtY3ddMqeuyNA67DNEGSCQSpKenIzw8HBEREYiKisLLly9ha2tLBw/Ozs7gcrnv/MKKRCJkZmbi+fPnH2T8JBQK6VluSUkJLUxEFUxSBXrN+fFI2zWbm5uja9eujPnxVVVVISkpCUKhEDwer8kq77aEElhSUlJC165daTMgStmwbkDXlu8pldrv2LEjLCwsGFM30RaZjsZaNqkgu7FCVirjl5eXxzhlTbFYLKPrIE8B9JMnTzB9+nT07dsXv/76K6OWxQDgwoULmDBhgkzgLxaLweFwoKCggJqamnqTAnYZ4v1gg4V2gFK6kw4esrKywOPx6ODBxcUFnTt3pi80sbGxEAqFrWL8VFtbS6+xU1oPKioqMiqTjWVBCCF0bYKuri6jiiupNrWMjAzo6+szSpCnbhdG3cIyKqCjgrqKigr6M5F2dGyNG5G0RwHTilLb0wCKUv+sW8gqXfOQmZnJOJVI4G0WJj4+HioqKrC2tpZr2eHo0aNYvXo1/vvf/2Lt2rWM+e1IU1FRUe8G7+PjA3Nzc6xcuRI8Hq/eMZ6enqioqMDvv/9Obxs7dix0dHTYAsd3wAYLDIBKDVI1DxEREUhNTYW5uTns7Ozw/PlzxMXF4fr16+jfv3+rX7jFYrFMgV5paSkUFRVlggctLS26NqGkpKRd3Q4borq6GklJSaiurmZc2yFVKEgIAY/Hk6sLQ1p/g/qjljeoz0RbW/uDZ9hUwWxdXwcmwDQDKOmWzaKiIlRWVoLD4cj8TpjQsvny5UukpqbSy29NfUcqKyvh6+uL27dv48SJExgxYgRjgkV5qFvgOHPmTPTo0QPbtm0DAERHR2Pw4MEIDAzE+PHjcfHiRaxdu5ZtnWwCNlhgIIQQFBUVYdeuXfjxxx+ho6ODmpoacLlcesnCzc2tQXW11kBa60G6j50QQlsPd+rUiREFT9JrspSiIJPWiylBHgMDA/Tp0+e93zPKQVA6oJNeY9fV1W1Uw7+xsVFV+/K20LUVTDaAkvYQMTMzQ4cOHWQCOkrAS7o7qa2CHMr589WrV3LLSScnJ2PmzJno1KkTTp06Rdc9fUzUDRaGDh0KY2NjBAUF0fuEhoZi7dq1yMrKokWZvvzyy3Ya8ccBGywwlKVLlyIkJATff/89/vOf/6CsrAyRkZEIDw9HVFQUHj16hO7du8PFxYX+69u3b6vfsKmCt9LSUnTp0gUikQglJSUQi8Uya7ntMaMSCAR0MZ6lpSWjtPalBZZ4PF6Lt5zVXWMvKSlBTU2NjMOmrq5ugzcqaV8HHo/HqKp9phpAAQCfz0d8fDwAwMbGpl6BpbSrI6XGWllZ2SYtm1VVVYiPj4eioiJsbGyaLP4jhOD06dNYvnw55s+fj61btzKmRoWFGbDBAkOJiYlB7969G0ztUxLE0dHR9NLF/fv3oaOjQ4tEubq6wsLCosVu2IQQFBQUIDU1FZ07d4aZmRl945G+UVF1D9SMikrJNqeS/EPGxjQRI+mxdenSBWZmZm2W6airLSB9o6ICiNLSUqSlpaFr164wMzNr95S5NEw1gAL+HhtVCyNvkC7dsllaWory8nK5NTiaM7aUlBT07NlTruyVQCDA119/jXPnzuHo0aP44osvGJO5YWEObLDwCUBpK8TGxtLBw71796CmpgZnZ2d62cLGxua9blQCgQApKSkoLy+Xy5RKWgSH+qPMf6TXc1siHVtTU0MXvDHNMEtab4IJAkvUjUq6kBV4az/crVu3Jn1H2gomG0BRxZ9FRUUtMjZpDY6GlpOa07IpFouRnp6OgoIC8Hg8ubw6MjMz4eXlBUVFRZw+fRq9e/f+oNfD8unCBgufKDU1NXjw4AEdPERHRwN4qzJJLVvY2dm984Yt7Sj4oTN26XQsNcv9UD8FStOBafbbAFBcXIykpCRwuVxGFONJU1JSgsTERGhoaKBnz5605kNZWRntO0J9Ji1RNNkcysrKkJCQwDgDKODvjgJlZWVYW1u3ytgIIeDz+TIZobotmzo6OvUKT6klEQ6HAxsbmyYLUwkhuHz5MhYuXIipU6di9+7djNFEYWEmbLDwD4FSmYyIiKDbNQUCAQYOHEgvW0irTGZlZSE9PR3q6uqtMmOX1nqg0rGU1gN1o1JXV29wlis9Y6da+5gCNbvLz8+HmZkZowSWJBIJMjMzkZeXh759+8LAwEBmbFTRpHTdg1gsppeTWlM6XFo0i2kFltJFs/J2FLQkDbVsqqio0L8TsViMrKws9OjRQ64lEaFQiPXr1yMoKAgHDhzA1KlTGfNeszAXNlj4h0KpTFJaD5GRkSgpKYGdnR26deuG69evY9asWdi8eXObzIop0x/pYjDpCyKlK1BcXIzk5GS6fY5Js6HS0lIkJiZCVVWVcW2HVVVVSEhIACEE1tbWchUKNjbLrSsd/qGfAWUAVV1dDWtra0YVWEr7J8grZNTaSLc2v3z5EgKBAAoKCjIBXWMFxi9evICXlxfKy8tx5swZWFhYtMMrYPkYYYMFFgBvZ5Xh4eFYsmQJcnJyYG5ujvj4eNja2tI1D05OTtDR0WmTWQh1QZTOPgBvb2BdunSBkZHRBxeCtRTSrX0mJiZt1tIqD9Jqh/IWvL0LajmJ+lwqKytlMkLNre5/lwFUeyO9JMLj8RgVmFZXVyM+Pp4O/iQSiUxQJxQKaS2UrKwsDBs2DE+fPsWsWbPg7u6OH3/8kVGdJSzMhw0WWAC8lXUdMmQIJk2ahF27doHL5dIqk5GRkYiKikJmZiatMkkpTUqrTLYWlM6+mpoaOnXqRKfKCSEymYe2Xl8H3k9gqa0QCoVISkpCRUVFq6kd1q3uLysrow2ZpAW86n5HKAOo/Px8mJubN2gA1V4QQpCXl4eMjAzGLYkAQFFREZKSkmgdkboZBOmWzTt37iAwMBC5ublQUVGBnZ0dfHx84ObmBlNTU0a9LqbA+kQ0DBsssAB4m269e/cuhgwZ0uDj1LotVfMQGRmJlJQUmJmZyQQPLblGLxKJ6BtKXZ19qn2UquwvLS2FSCSqZ83dWu120jcUQ0NDRjkxAm9n7MnJybQEd1u1korFYhmHTSojJF00qaioiKSkJCgoKMDa2rpZBlCtDRVgVVZWwtramlE+IhKJBBkZGXj+/DksLS3lqtUpKirCrFmzUFhYiHnz5qGwsBBRUVGIi4vD8OHDZSSPW5P9+/dj//79yMnJAQBYWVlh/fr1GDt2bIP7BwUFwcfHp9726urqVi16ra2tZUzbNdNggwWW94JSmZQWioqPj4exsbFM8PC+s7I3b94gOTkZqqqqsLKyavKGUnd9nRIlqluc1xIXAkpKWiAQwMrKqsUFlj4E6fY5MzMzdO/evV1nSYQQOhNUUlKC169fQywWQ1VVlW7XbKnP5UMpKSlBQkICtLW1YWVlxYgxUQgEAsTHx0MsFsPGxqZJbxhCCKKjo+Ht7Q1HR0f88ssvMoFPTU0NioqKYGBg0NpDBwBcvnwZioqK6NOnDwAgODgYO3fuxOPHj2FlZVVv/6CgIPj6+iItLU1me0sXM7969QqBgYEYN24cRo4cCQBISUlBSEgIunbtivHjx7fZe8R02GCBpUUghKC0tJT2toiMjKRVJimhKHlUJsViMT176tOnDwwNDd/7ZlddXS0TPPD5fJnivMYUDd/1GqlW0q5duzJKShp46+tAOVhaW1szqsBSKBQiOTkZZWVl6Nu3L/19oTQ4pJUmW9IyXR4oY7fs7OwGu0Tam+LiYiQmJtKiXk1lyyQSCfbu3YvAwEAEBgZi2bJljMp6UXTs2BE7d+7E7Nmz6z0WFBSE5cuX05mp1uLBgweYOnUqhg4dis2bNyM1NRVjxozB0KFDERERgVGjRmHx4sUYM2ZMq47jY4ANFlhaBWqZICYmBmFhYXTqk1KZdHFxgZubm4zKZGRkJCQSCd1j35LOmsDfLWjU0gWl9SAdPDR2k6LcDktLS2FpaSmX4E1bId122KtXLxgbGzPq5tCUAZT050K1Bqqrq8ssXbSGJDJ1bqoTw8bGBtra2i1+jvdF2u7a3Nwc+vr6TR5TUlKC+fPnIz4+HqdOnYKzs3MbjLR5iMVinDlzBl5eXnj8+DEsLS3r7RMUFIQ5c+agR48eEIvFsLW1xebNm9G/f/8WG4dEIoGCggKCg4OxZ88eTJw4EUVFRRgwYAC8vLzw6NEjrFy5ElpaWti4cSOsra1b7NwfI2ywwNImUCqTcXFxCAsLQ2RkJGJjY6GqqgoHBwcQQnD79m0cPHgQEydObJObXV1FQ8pyWFplUkNDg27X1NHRYZQFN/A2PZ2YmAiBQMC4tsP3NYCq20ZbXl4OJSUlGVGiluiEoYSzOnbsCAsLC0ZliajPVSgUyu2J8fDhQ8yYMQMWFhb49ddfGeWNAgAJCQlwcnKCQCBAhw4dEBISAnd39wb3vXfvHjIyMmBtbY3y8nLs2bMHv//+O/766y/07du3RcYjFArp33JAQACuXLmCmpoaXLlyhT7HpUuXsGPHDtjY2GD79u2M+n21NWywwNJu1NTUICQkBAEBARAKhdDR0UFxcTEcHBzoZYumVCZbEspyuK4cMiEEXbt2hbGxMSPkkCkKCgqQkpLS5p4T8sDn85GYmAixWCy3rkNj1HU9pTphpItZm2NcRolTPXv2jHHCWcDf3T+dOnWSy99FIpHg8OHDWLNmDVavXo3Vq1czykeDQigUIi8vD6WlpTh79iwOHz6M8PDwBjMLdZFIJBgwYAAGDx6MvXv3ftA4NmzYAG9vbxgbG+PkyZOora3FlClTMGPGDNy8eRPBwcH4/PPP6f137tyJCxcu4PPPP8eqVas+6NwfM2ywwNJunD59Gj4+Pli5ciUCAgLA4XAaVZmkli2kVSZbk9LSUiQkJEBJSQkdO3ZEZWUlLYcsnXloD62H2tpapKWlMdI7AWh9AyhqiUt66YIyLpNu2WyoQJFysWyJIKalIYTQmRh5g5iKigosXboUERERCAkJwbBhwxgV+LyLkSNHwsTEBD///LNc+8+dOxfPnz/HtWvXmn2uiooKaGlp4fXr13B3d0d1dTXs7e1x/PhxhIaG4osvvkBycjJmz56NPn36YN26dTA1NQXwdhIxb9483L9/H0ePHoW9vX2zz/8pwAYLLO3Gy5cvUVBQgAEDBjT4uFgsRnJyMr1sERkZiTdv3sDe3p4WinJwcGjR2b60JHLdAktKDlm6XVNa64Ga4bZm8ED5OmhqasLS0pJR3gntZQBFLXFJL13w+fx63iPl5eVISkpipMMmVTshEAhgY2Mjl15HcnIypk+fjq5du+LkyZNy1TQwiREjRsDAwABBQUFN7ksIwaBBg2BtbY0jR4406zyzZ89GVlYWrl+/DhUVFdy5cwcjRoyAnp4enjx5gu7du0MsFkNRURGnTp3CN998g88++wyrV6+mP4esrCxkZmZi1KhR7/NSPwnYYIHlo0EikeDp06e0RHVUVBSeP38OW1tbulXT2dn5vVUmKysrkZCQAA6HAx6P1+SsU1rrgbpJUVoP0gFES9yUpNf/mVixzzQDKKFQKPO5VFRUAHir99C9e3fo6OhAU1OTEe/hmzdvkJCQAF1dXVhaWja5nEQIQUhICPz9/bF48WJs2bKFUUtQDREQEICxY8fCwMAAFRUVOHXqFLZv344//vgDo0aNwsyZM9GjRw9s27YNALBx40Y4Ojqib9++KC8vx969e/Hrr7/i7t27GDRoULPOHRkZiTFjxmDdunVYvXo1Tp06hb179yIuLg5Hjx7FjBkzIBKJ6Pdw3bp1uHXrFry9vTF//vx6z/dPFW1igwWWjxZCCHJycmSCh8zMTFhZWdE1Dy4uLtDT03vnj1u6m8DIyOi9jYLepfXQVHr8XVRVVSExMRESiYRxKpFMNoAC/vbEAABDQ0Pw+XxaaVJRUVGm46Ktl5So729WVpbcBaDV1dVYsWIFLl68iODgYIwbN45R73djzJ49G3/++Sfy8/PB5XJhY2ODlStX0jP1oUOHwtjYmM4y+Pn54dy5cygoKACXy0X//v2xYcMGODk5Neu8lMjS/v37sXTpUly5cgWfffYZAOB///sftm/fjgcPHsDa2hoCgQBqamoQCoWYOnUqMjMzERwcjH79+rXoe/GxwgYLLJ8M71KZpLQe6qpMPn36FK9evaJvxC2t2Eelx6mlCz6fT2sKNGXEJO122KNHD/Tp04dRqXOBQICkpCRGGkABb2snUlJSGvTEoIompeseJBKJTMdFayqACoVCJCYmgs/ny92ymZGRgRkzZkBVVRWnT59Gr169WmVsnwpUa2RFRQWePn2KBQsWQCQSITQ0FL1798br16/h5eWFp0+fIiUlhf5+lJaWoqqqCvfu3cPEiRPb+VUwBzZYYPlkIYTg1atXMsEDpTLp7OwMVVVVnDx5Ehs3bsS8efPaJJXbkNaDhoaGTPCgrq5OixiVl5fDysqKEW6H0jDZAEosFiM1NRWvXr2ClZWVXJoYhBBUVVXJZIUoMybprFBLdOaUlpYiPj4eXC4XlpaWTWaaCCG4ePEiFi1ahOnTp2PXrl2MMrViClTdgTTh4T7MdU8AACAASURBVOGYNGkSRo4ciczMTDx8+BDu7u747bffoK6ujrS0NLi7u8PU1BQ7duzApk2bUFtbi99++41+j/+pyw51YYOFNmDbtm0ICAiAr68vvv/++wb3aS8t9H8SlGrg1atXsXHjRjx79gxGRkbg8/kyEtVNqUy2JNJaD6WlpSgvL4eysjJEIhE0NTVhbm4OLpfLmIsVkw2ggLdV7wkJCVBWVoa1tfUH/Xaks0LUbFNaxItSmpT3s5FespG37kQoFGLdunU4duwYfv75Z3h6ejLmu8AkNm3ahJ49e8Lb25v+7VZWVmLUqFHo378/fvrpJ7x69QqxsbHw8PCAv78/tmzZAgCIi4vDpEmToKGhgU6dOuH69euM6pJhCsyZDnyi3L9/HwcPHoSNjU2T+2pra9fTQmcDhZaDw+EgLS0NX331Fdzc3BAdHQ01NTXExMQgPDwcZ86cwX//+19wuVyZZQtLS8tWS0crKytDT08Penp6EIvFSEtLQ35+Pjp27AiRSISHDx9CSUlJpqq/vbQeqAJQBQUFODg4MMoAirLiTk9Ph7GxMXr16vXBAZ+6ujrU1dXpgEgoFNIdF3l5eUhKSoKKiorMZ9NY0WRtbS3tAGpvby/Xkk1eXh68vLxoMTMzM7MPej2fGtIzfj6fX+8zLyoqQkZGBtatWwcA0NPTw7hx4/Dtt99i2bJlGDRoEL744gsMGjQIcXFxKCgogK2tLYCGsxT/dNjMQitSWVmJAQMG4KeffsKWLVtga2v7zsxCW2ih/9N59eoVbt68ialTp9a7qFPWvrGxsYiIiEB4eDhiY2OhoqJCS1S7urrCxsamxU2GqBmxkpISeDwefSOWSCQoKyuTmeFyOBwZierWLsyjbsRPnz6FgYEB4xw2a2trkZKSgpKSElhbW7eKFXdDiMViGXvu0tJSKCgoyGQetLW1UVFRgfj4eHTo0AE8Hk+uZYcbN25gzpw5GD9+PH744YcWlz7/lJB2ikxLS4OamhqMjIwAAL1798acOXMQEBBABxeFhYVwdHSElpYWQkJCwOPxZJ6PDRQahg0WWhEvLy907NgRu3fvxtChQ5sMFlpbC52l+dTU1ODBgwd0zUN0dDQkEgkcHR3p4GHAgAHvvYYsnZqWZ0ZMaT3ULcyj1Ax1dXWhra3dYhc76doJHo/XZjdieSkrK0N8fDw0NTXB4/HaVYpbWoeDCh5EIhEIIejYsSOMjIygo6PzzvoOkUiEwMBA/Pjjj9izZw9mzZrFLju8gxUrViAzMxPnz59HdXU1OnXqhPHjx2Pfvn3gcrlYtWoVoqOj8e2339I+GYWFhZg0aRJiY2OxdOlS7Nq1q51fxccBuwzRSpw6dQqPHj3C/fv35drf3NwcQUFBMlroLi4uLaqFztJ8VFVV6XqG1atXQyQS4cmTJwgPD0dkZCR++OEH8Pl8ODg40EsXAwcOhLq6epMXeeluAjs7O7k6MRQUFMDlcsHlcmFkZCRTmFdSUoJnz56htrZWJnjgcrnvVYAobQDl6OjIKE8M6SDLxMQERkZG7X5Tlf5sqGWH0tJS6Ovr00ZkNTU1Mg6bXC6XXmosLCyEj48PXr58ibt377Ite3JgZGSEY8eO4dGjRxgwYABOnTqFSZMmwcXFBUuWLIGHhwdSU1Ph7++PQ4cOoWvXrrh8+TK6deuGnJycj07Iqj1hMwutwLNnz2Bvb48bN27QP/imMgt1aUktdJbWQyKRICkpidZ6oFQm7ezs6MyDo6NjvTqD7Oxs5OTktLivA6VmKK0yKRAIoKWlJbO2/q5U+PsaQLUVQqEQSUlJqKyshLW1dYu3u34o5eXliI+Ph4aGRr1sh0AgkMk8/PTTT4iLi4OlpSUePHgAR0dHnDhxgnGvqb2h2iDrEhsbiyVLluDf//43/vvf/0JFRQVr1qzB3r17cfHiRQwfPhx37tzBt99+i+vXr6N3797Iz89HcHAwvvzySwCQEWRiaRw2WGgFLly4gAkTJsikgsViMTgcDhQUFFBTUyNXmvhDtNBZ2oemVCYHDBiA06dPo7CwEKGhoejatWurj4m6QUlX9UvPbnV1delllJY0gGoNqGyHvG2HbYl0kaW8AlX5+fnYtm0b7t27h6qqKrx48QJ6enpwc3PD9OnTMW7cuDYZ+/79+7F//37k5OQAAKysrLB+/XqMHTu20WPOnj2LdevW0dmdwMBATJgwoVXHuXr1apiamsp0jnl6eiIrKwvh4eF0rc+wYcNQXFyMixcvonfv3gCA27dvo7y8HA4ODozr4vkYYIOFVqCiogK5ubky23x8fGBubo6VK1fWK6hpiOZqoW/YsAEbN26U2da1a1cUFBQ0ekx4eDj8/f2RlJQEfX19fP3111iwYEGT52KRH2mVydDQUNy4cQPdunVDly5dMHDgQFqiukuXLm02e29ICllDQwOqqqooKytD165dGaedQJks5eTkMDLbIRKJkJyc3Kwiyzdv3mDevHlITk7GqVOn4OjoCD6fj7i4OERGRsLU1BSenp5tMHrg8uXLUFRURJ8+fQAAwcHB2LlzJx4/fgwrK6t6+8fExMDNzQ2bN2/GhAkTcP78eaxfvx5RUVFwcHBolTHevXsXbm5uAIBDhw5h1KhRMDQ0RGpqKqytrXH8+HH6/aqqqoKxsTHc3d2xffv2esEBW8TYfNhgoY2ouwzR0lroGzZsQGhoKG7dukVvU1RUbFSQJjs7GzweD3PnzsX8+fNx9+5dLFq0CCdPnmRVy1oYsViMTZs24dtvv8WmTZvg4eGByMhIOvOQnJwMU1NTujbCzc2tTW2Tq6urkZSUhLKyMqipqaG6uhqqqqoyHRcaGhrtdnMWCARITExETU2N3CZLbQnV7aCmpgYejydXseuDBw8wY8YM8Hg8HDt2jHGiWwDQsWNH7Ny5E7Nnz673mKenJ8rLy2Wynp999hl0dXVx8uTJDz43texA/ZcQgtraWnz11VdITEyEoqIi+vXrhylTpmDgwIGYMmUKCgoKcOnSJVoNMyoqCoMHD8auXbvg6+vLqA6ejxHmTB3+YeTl5cl8eUtLSzFv3jwZLfSIiIhmmaYoKSmhW7ducu174MABGBoa0sGLhYUFHjx4gG+//ZYNFloYBQUFVFVVITo6mq5hmTZtGqZNm0arTEZGRiI8PBz79u3D3LlzYWRkRGcd3NzcYGRk1CoXO2kDKBcXF6ipqUEsFqOsrAwlJSUoKChAWloaFBUV6cChLbUeiouLkZiYiM6dO8PW1pZx2Y6XL18iLS2N9hRp6j2RSCQ4ePAg1q1bh7Vr1+Lrr79m3AxXLBbjzJkzqKqqatSLISYmBn5+fjLbxowZI3dNVlNQ3/WcnBz6fVVQUED37t2hq6sLW1tbREVFYebMmfj9998xYsQIHDhwAPfv38eIESMgFovh6uqKw4cPY9iwYWyg0AKwmYVPhA0bNmDnzp3gcrlQVVWFg4MDtm7dSq/X1WXw4MHo378/9uzZQ287f/48PDw8wOfzGbUW/E+CEIKysjI68xAZGYmHDx+iW7dudLeFi4sLTE1NP+gCKG1i1NT6OuWjIF33IK31QOkJtOQFWSKRICMjA8+fP4e5uTnjqtbFYjFSUlJQXFwMa2truTID5eXlWLJkCe7evYuTJ09iyJAhjFpKSUhIgJOTEwQCATp06ICQkBC4u7s3uK+KigqCgoIwbdo0eltISAh8fHxQU1PzwWORSCTYsGEDtmzZgt9//x0uLi7Q0tJCbGwspkyZggsXLqBfv35YsGABHj58iKVLl2Lp0qVYsWIF1q1bB6FQKFNY2liBJIv8sMHCJ8K1a9fA5/NhamqKwsJCbNmyBampqUhKSmrwQmZqagpvb28EBATQ26Kjo+Hi4oKXL1+yBUAMgbLBplQmIyMjERcX90Eqkx9qACWRSOpZc4vFYhkHRy6X+94z5urqasTHx0MikcDGxoZxgkSVlZWIj49vlqR0YmIipk+fjh49euDkyZNyZwDbEqFQiLy8PJSWluLs2bM4fPgwwsPDYWlpWW9fFRUVBAcHY+rUqfS2EydOYPbs2RAIBC0ynoyMDAQGBuKPP/7AggULsGzZMujq6mLOnDnIysrC7du3Aby1vy4pKUFwcDBEIhFyc3PZ61crwJycHssHIV21bG1tDScnJ5iYmCA4OBj+/v4NHtOQgmFD21naDw6HAy0tLYwePRqjR4+upzJ57do1/O9//5NbZVLaAKpfv37vldZXUFCAtrY2tLW162k9lJaW4sWLFxAKheByuTLZB3nOVVhYiOTkZHTr1g2mpqaMS9FTTpbyKlkSQvDrr79ixYoVWLZsGTZt2sSopRRpVFRU6AJHe3t73L9/H3v27MHPP/9cb99u3brVK54uKipqke4eSmmxT58+OHr0KL766itcuHAB0dHRuHbtGpYsWYL169fj0qVL+OKLL7Bp0ybcvn0bsbGxyM3NBTv/bR2Y+a1l+WA0NTVhbW2Np0+fNvh4Yz92JSUlRhZbsbyFw+FAXV0dQ4cOxdChQwG8VZl8+PAh7a65Y8cOSCQSODg40MsWFhYW+Oqrr9CzZ08sXLiwRWdeHA4HHTp0QIcOHWBgYEBrPVBZh9TUVFRXV9NaDw05OIrFYqSnp6OgoACWlpZt0lLaHCjfjqKiItjY2KBz585NHsPn8/HVV1/hypUrOH36NNzd3T+qQJwQ0uiSgpOTE27evClTt3Djxg1aJbE53Lp1C/b29rS2BPUeUR0L27Ztw+XLl+Hn54dRo0Zh/vz50NXVxbNnzyCRSKCkpITRo0fDwcEB2tra4HA4rFNkK8AGC58oNTU1SElJoVuN6uLk5ITLly/LbLtx4wbs7e3lqldobqtmWFgYhg0bVm97SkoKzM3NmzwfS+OoqqrC2dkZzs7OWLVqFa0ySQUPu3fvRm1tLbp06YJu3bohPT0dXC5XLpXJ94HD4UBDQwMaGhp0rYFAIKCDh4yMDNrBkeq0eP78OZSVleHo6Ah1dfUWH9OHUFVVhfj4eCgqKsLR0VGuZYf09HTMnDkTmpqaePjwIYyNjVt/oB9AQEAAxo4dCwMDA1RUVODUqVMICwvDH3/8AaB+95avry8GDx6MHTt2YPz48bh48SJu3bqFqKioZp333r17GD16NA4cOABvb2+ZAFJRURGEEKioqGDixImwt7fHv/71Lxw/fhyZmZl4+vQpFi5cCOBtYEMtp7EiS60D+45+IqxYsQKff/45DA0NUVRUhC1btqC8vBxeXl4A3oqZvHjxAseOHQMALFiwAPv27YO/vz/mzp2LmJgY/PLLL81qe7KysqrXqtkUaWlpdGsTgEZbO1neHyUlJdjb28POzg4aGhq4desWpk2bBh6Ph+joaMyePRuvX79uUmWyJVFTU0O3bt3otXrKwfH58+d4/vw5gLcuj1lZWXTmobWCmeZQUFCA5ORk9OzZE3369JFr2eH8+fNYvHgxvL29sXPnTkbJZDdGYWEhZsyYgfz8fHC5XNjY2OCPP/7AqFGjANTv3nJ2dsapU6ewdu1arFu3DiYmJjh9+nSzNBYIIXB0dMTy5cuxdu1aWFhY1JvcUJ+/RCKBkZERzp49i/379yMhIQEpKSkIDg6Gj4+PzPeEDRRaB7bA8RNhypQpiIiIQHFxMfT09ODo6IjNmzfTxUne3t7IyclBWFgYfUx4eDj8/PxoUaaVK1fKLcq0YcMGXLhwAU+ePJFrfyqzUFJSwkrZthF5eXkYOXIkDhw4gOHDh9PbqU6DsLAwREZGIjIyklaZpIomnZ2doaur22o3a5FIhNTUVBQXF4PH40FHR0fGHKusrExu++fWQCKRIC0tDQUFBbCyskKXLl2aPKampgZr1qxBSEgIDh06hEmTJrV7sMNkpDsUnJycIBaLERISQtdN1IVaWnj16hWuXLmCCxcu4LfffntvEzeW5sEGCyzvRXNbNalgwdjYGAKBAJaWlli7dm2DSxMsLYc8SnVUGyW1bBEZGYnMzExYWVnRQlEuLi4tpjJJiRipqqqCx+M1mNaX1nqgfBQorQcqeNDS0mqVmzGfz0d8fDw4HA5sbGzkWhbJzc2Fl5cXhEIhfvvtN5iamrb4uD5FqCWDkpIS9OrVC5MmTcI333zTLHdTVo2xbWCDBZb3ormtmmlpaYiIiICdnR1qamrw66+/4sCBAwgLC8PgwYPb4RWwNAYlNiQdPFAqk9Ltmj169GjWzVraO6FXr17o1auX3MdTWg/S2QcA9ay5P7SXvqioCElJSejevbtcWhaEEPzxxx+YN28evvzyS+zdu5dxNRdM4l039uvXr2Ps2LH44YcfMGfOHLkyBqx+QtvBBgssLUJVVRVMTEzw9ddfN9qqWZfPP/8cHA4Hly5dauXRsXwIhBAUFxfLBA9//fUXjIyM6KyDq6srjI2NG71w19bWIjk5GWVlZbC2toauru4Hj6miooIOHiith7rW3PLOOCkDsJcvX8rdjVFbW4stW7bgwIED+OGHH+Dl5cUuO7wD6UDh6NGjyM3NhaKiIpYvXw5NTU0oKCjQjpHnz5/HiBEj2PeTQbDBAkuLMWrUKPTp0wf79++Xa//AwEAcP34cKSkprTwylpakrspkVFQUHj58iK5du8poPVAz8z///BO5ubno378/rKysWqXgj9J6kA4ehEIhtLW16aULHR2dBjt9KBEoQghsbGxo58J3UVBQAG9vbxQVFeHMmTOwtrZu8df0qfLll18iLi4OLi4uePDgAfT19bF161a6uHHYsGF4/fo1zpw5AzMzs3YeLQsFGyywtAg1NTUwMTHBvHnzsH79ermOmTRpEt68eUMrsbF8nFA36piYGISFhSEqKgpxcXHQ0tJC79698eTJEyxduhTr1q1rs0p1SryKChxKSkpktB6ouoeysjIkJibKLQJFCEFkZCS8vb0xdOhQHDx4UKa7h6VxBAIB/Pz8kJKSgtDQUHTu3BkxMTFwcXHBlClT8PXXX8PW1hbV1dXo1asX7O3tERQUJJemBUvrwy72sLwXK1asQHh4OLKzsxEbG4tJkybVa9WcOXMmvf/333+PCxcu4OnTp0hKSsLq1atx9uxZLFmypFnnffHiBaZPn45OnTpBQ0MDtra2ePjw4TuPCQ8Ph52dHdTU1NC7d28cOHCg+S+YpVEoUaZRo0YhMDAQYWFhSE1NhbGxMdLT0+Hm5ob9+/fDyMgIkydPxp49e/DgwQPU1ta26pjU1dWhr68PKysruLq6ws3NDcbGxpBIJMjMzER4eDiePHkCLS0t6OjoNDkesViMnTt3YuLEiVi7di1CQkLYQOEd1J2HikQiDBgwAN988w06d+6MXbt2wd3dHdOnT8fvv/+OY8eO4cWLF1BXV8eJEydQVlYmV5aHpW1gG1JZ3ovnz59j6tSpMq2a9+7dg5GREYC3srh5eXn0/kKhECtWrKAvBlZWVrh69WqjRjUNUVJSAhcXFwwbNgzXrl1Dly5dkJmZ+c5WzOzsbLi7u2Pu3Lk4fvw4bcWtp6fHumu2EuXl5XBycoKbmxtu3rwJLpcLoVCIBw8evFNl0s7OrlXb4CitBx0dHVRWVkJTUxMGBgbg8/nIy8tDUlIS1NTU6MyDpqYmXTT5+vVrzJ07F2lpabhz506z3GD/iTRUyNihQweMHj0aRkZGOHDgAA4fPoyDBw9i8uTJ8PX1xalTp2BsbAwfHx+MGDECI0aMaKfRszQEuwzB8tGwatUq3L17F5GRkXIfs3LlSly6dEmmLmLBggX466+/EBMT0xrDZAEQGxuLQYMGNVqgJhKJ8Ndff9HmWFFRUaiqqsKgQYNoW+6BAwe2uDATZXmtp6cHc3NzmRuaSCSi2zRLSkpw6NAhXLt2DTweD+np6TAzM6PT523Ntm3bcO7cOaSmpkJdXR3Ozs7YsWPHO9f0g4KC4OPjU297dXW1XCqUH0pGRgb27dsHIyMj9O3bF+PGjaMf8/DwQM+ePfHdd98BAObMmYPQ0FDweDyEhobS4l1stwNzYDMLLB8Nly5dwpgxYzB58mSEh4ejR48eWLRoEebOndvoMTExMRg9erTMtjFjxuCXX35BbW0ta8XdSjSl5KekpAQ7OzvY2dnB398fEokEycnJtFBUUFAQiouLYWdnR2ceHB0d31tbQSKRICsrC3l5eY1aXispKaFz5850MGBmZoZOnTohLCwMHTp0wP3792Fubg43NzdMnDgR06dPb/Y43pfw8HAsXrwYAwcOhEgkwpo1azB69GgkJye/05VTW1sbaWlpMttaK1CQvrGHhYVh5MiRcHNzw507d5CRkYHVq1djxYoVEAgEdCtuWVkZqqurUV5ejhs3bsDQ0FDGkZMNFJgDGyywfDRkZWVh//798Pf3R0BAAOLi4rBs2TKoqqrK1EdIU1BQUK8NrmvXrhCJRCguLmatbBmCgoICeDweeDwelixZQqtMRkRE0Eqjz549Q79+/ehuC3lVJmtqapCQkAChUIhBgwahQ4cOTY6nrKwMixYtQlxcHEJCQjBkyBDU1tbi0aNHiIiIQHl5eUu9dLmgPBoojh49ii5duuDhw4fv1CnhcDhtZodN3dhDQkKQlZWFvXv3YtGiRSgvL8eFCxfg4+OD7t27Y/bs2Zg+fTo2b96M69ev4+nTpxg7diy9tMOKLDETNlhgaRRCCD1bYEK/s0Qigb29PbZu3QoA6N+/P5KSkrB///5GgwWAteL+GFFQUICpqSlMTU0xZ84cEEKQm5tLL1usXbuWVpmkhKIaUpnMzc1FTk4OOnXqBFtbW7m6MeLj4zF9+nQYGRnh0aNHdLCprKwMBweHZvkftBZlZWUA0KTSYWVlJYyMjCAWi2Fra4vNmzejf//+rTauM2fOYMWKFeDz+Th//jyAt9mNmTNnIj4+HitXrsTMmTOxatUqGBsbIz8/H/r6+vD09ATw9rfJBgrMhM3xsMhA3UjFYjE4HA4UFRUZc1Pt3r077XVBYWFhIVNIWRfWivvTgMPhwNjYGF5eXjh8+DDS0tLw7NkzrF69GhwOB9u3b4eJiQns7OywZMkShISEwNfXF0OHDoWBgQGsrKyaDBQIIQgODsbIkSMxdepUXL9+nXFW2cDbcfr7+8PV1RU8Hq/R/czNzREUFIRLly7h5MmTUFNTg4uLS6O29c1FLBbX2+bg4IDp06ejoqICFRUVAEDbXK9cuRLKyso4c+YMgLd+Nn5+fnSgQF1zWBgKYWGpQ2xsLFm2bBlxcXEhHh4e5NSpU+TNmzftPSwydepU4urqKrNt+fLlxMnJqdFjvv76a2JhYSGzbcGCBcTR0bFZ537+/Dn5z3/+Qzp27EjU1dVJv379yIMHDxrd/86dOwRAvb+UlJRmnZdFPiQSCSkqKiJnz54lc+bMIVpaWkRbW5v069ePTJ8+nezfv58kJCSQiooKUlVVVe+vqKiITJ8+nXTu3Jn8/vvvRCKRtPdLapRFixYRIyMj8uzZs2YdJxaLSb9+/cjSpUs/eAwikYj+/xs3bpB79+6RgoICQgghGRkZxN3dnVhbW5OXL1/S+6WmppKePXuSO3fufPD5WdoeNlhgkSE+Pp507tyZuLu7k8OHD5OFCxcSW1tbMnz4cPL48eN2HVtcXBxRUlIigYGB5OnTp+TEiRNEQ0ODHD9+nN5n1apVZMaMGfS/s7KyiIaGBvHz8yPJycnkl19+IcrKyiQ0NFTu875584YYGRkRb29vEhsbS7Kzs8mtW7dIRkZGo8dQwUJaWhrJz8+n/6QvsiwtT3h4ONHX1yceHh4kNzeXXL58maxYsYI4OjoSZWVl0qNHDzJ58mSyZ88e8uDBA1JRUUEePXpErKysiJOTE8nNzW3vl/BOlixZQnr27EmysrLe6/g5c+aQzz77rEXG8vr1a+Lk5ERMTU1J3759iZmZGfnll1+ISCQit27dIvb29mTIkCEkNTWV5Obmkv/973+ke/fuJCEhoUXOz9K2sMECiwzr168npqampLS0lN729OlT8t1335Ho6GiZfSUSCamtrSVisbjNxnf58mXC4/GIqqoqMTc3JwcPHpR53MvLiwwZMkRmW1hYGOnfvz9RUVEhxsbGZP/+/c0658qVK+tlNJqCChZKSkqadRzLh7F//37y448/1ssMSCQSUlFRQW7cuEHWrFlDBg8eTNTU1AiXyyUqKipk+fLlpKampp1G3TQSiYQsXryY6Ovrk/T09Pd+Dnt7e+Lj4yP3MQ39tsViMSkuLibDhg0jU6ZMIa9fvyaEEDJ48GDSu3dv8vjxYyIWi8nBgweJrq4u4XK5xNvbm5ibm5PIyMj3GjtL+8MGCywy7Nq1i5iYmJDk5OR6jwmFwnYYUftjYWFBli9fTiZNmkT09PSIra1tvSClLlSwYGxsTLp160aGDx9Obt++3UYjZmkKiURC+Hw+OXv2LFmzZg2jlx0IIWThwoWEy+WSsLAwmUwVn8+n95kxYwZZtWoV/e8NGzaQP/74g2RmZpLHjx8THx8foqSkRGJjY+U6JxUoCIVCkpycTKqqqujHsrOziZ2dHcnPzyeEvJ1kdOjQQeZ3UVJSQlavXk0sLCzI4cOH6z0vy8cFGyywyFBQUEAGDx5MVFRUiLe3NwkLC6NT59SPPD8/nxw8eJCMGTOGTJ06lVy8eLHRQEIikXz0qXdVVVWiqqpKVq9eTR49ekQOHDhA1NTUSHBwcKPHpKamkoMHD5KHDx+S6OhosnDhQsLhcEh4eHgbjpzlU6Gh+hcA5OjRo/Q+Q4YMIV5eXvS/ly9fTgwNDYmKigrR09Mjo0ePrpcdbAjpwOnu3bvEycmJzJgxg4SFhdHbL126RExNTYlQKCRDhw4l5ubm5N69e4QQQvh8PomLiyOEEJKQkECmT59OBg4cSF68eEEIIR/99eCfCqvgyNIgISEhOHv2LF6/fo0FCxZgypQpAN62Yg0ZMgTa2toYM2YMsrOzERERgYCAn2h7lQAAE21JREFUAMyYMQPAW20DVVXVD7YhZgoqKiqwt7dHdHQ0vW3ZsmW4f/9+s1QgWUtulo+J7777DmvWrMFXX30FNzc3uLq60gJQr169goODA3JzczF16lR8//33tJjVmTNncPPmTWzbtg2dOnXCrVu3sHXrVhBCcOfOnfZ8SSwfAKuzwNIgHh4ecHBwwNatWzFv3jz07t0b/fv3x759+5Cbm4vi4mJ630uXLmHmzJkYN24cdHV1cfToURw6dAhbt27Fo0ePYGRkBA8PD+jp6dU7D9V+Ja3lQAgBh8NhjDhLYy2bZ8+ebdbzODo64vjx4y05NBaWVuHixYs4fPgwLly4gDFjxtR7XFNTEzNmzMDBgwfh4eFBBwpxcXHYsmULhg4dSotfjRw5EqmpqcjMzGTMb5ql+bA6Cyw0oaGhSE9PB/BW+tbExATbtm2Dnp4ewsLCUFVVhTt37qCkpASdO3eGnZ0dtmzZAj6fD11dXWRnZ6OmpgaFhYUoKChAUFAQxGIxfvzxR3h6eoLP59PnooIERUXFeloO1GMTJkzAwoUL6T7t9sLFxaWeZG56ejptmiUvjx8/bpZipLGxMTgcTr2/xYsXN3rM2bNnYWlpCVVVVVhaWtLCOCwszeHx48cwMDCAk5MTvS0rKwtPnjzBzZs3wefz4evri7Fjx2Ly5MkYPXo0pk6dilGjRmH48OHYs2cPVFVV6d/y3LlzsXv3bjZQ+IhhMwssNCdPnsTVq1fh4+MDBwcH1NbW4sSJE6isrISVlRUIIUhNTcW+ffvg7u6O0NBQ3LlzB/v27YOWlhYqKytRUVGBe/fuYeDAgfj111+hp6eHadOmYcKECTh06BB8fX0hFovx559/Yvfu3QCA4cOHw9PTE4aGhgBAX1BiY2OxePHid4rpUFmI1sTPzw/Ozs7YunUrPDw8EBcXh4MHD+LgwYP0PqtXr8aLFy9w7NgxAG8tuY2NjWFlZQWhUIjjx4/j7NmzzcpG3L9/X0b4JjExEaNGjcLkyZMb3D8mJgaenp7YvHkzJkyYgPPnz8PDwwNRUVGMUB1k+XjIyclBVVUVRCIRhEIh1q5di4SEBMTGxgIAOnXqhPDwcBw5cgSurq70JOPcuXO0W6R0FqE13URZ2oj2LJhgYQ4SiYSEh4eTKVOmkI4dO9IV/MbGxmTevHmksrKSEEKInp4eOXbsmMyxQqGQZGZmEolEQiIiIoiZmRld/UwVM02YMIFMnTqVEPK2P/vq1avkwIEDZNOmTcTe3p6MHj2aFBYW0sVVhYWFhMPhkJs3bzY6ZoFA0OLvQ2M0t2Vzx44dxMTEhKipqRFdXV3i6upKrl69+kFj8PX1JSYmJo1W7nt4eNTroR8zZgyZMmXKB52X5Z9HVlYWUVZWJmZmZkRJSYnY2dmRLVu2kOjoaBIZGUkcHBwa/V5JJBK24+EThA0WWBrk3r175MiRI/X6ov39/Ym1tTV58uQJIeRth0RZWRn9+M8//0w6d+5M0tLSCCF/39Dt7OyIn59fg+eSSCTE2tqaBAQE0NuOHz9OOnfu3KjwUXl5ORk/fnyjz/mpUVNTQzp16kQCAwMb3cfAwIB89913Mtu+++47Ymho2NrDY/kESUpKIidOnCC//fYbKS8vJ9XV1YSQtxOAzz//nEycOJEQ8neXFNPbT1k+DHYZgoVGIpHQRi6NGeZs2LABBQUFGDVqFMzMzMDj8aChoYGlS5eiR48eSE5ORkVFBb02r6qqiurqaiQmJsLf3x8AkJSUhOPHj+Px48fQ09PDnDlzoKOjg8rKSjp1efnyZdja2tKFUxTk/5cdsrOzUVZWBg0NDXrsn7Kd7YULF1BaWgpvb+9G92nMYbOuNwYLizxYWlrWK+wFgIqKCggEAtrtkvrdsb4Onzaf7tWVpdkoKCjQa4zk/x0npSGEQEtLCydOnEBYWBgmTJhAWwsbGxvjxYsXyM3NhZqaGrZs2QIAyM/Px9q1a6GhoYHJkyfjzZs3+Pe//42oqCiMGTMGqqqqWLx4MaKiotCjRw+IRCIAQEREBFxdXevZCZP/7/RNTExEdXV1k2vxhBCIRKJ6r+Vj45dffsHYsWOhr6//zv0acthkL+IsLUFVVRUeP36MsWPHoqKi4p1OryyfHmxmgaVBqMr7utuom09Ds47s7Gzk5+dj6dKlyMvLg7W1NVRVVcHn87Ft2zYoKyvj1q1bKC0txW+//UZb5aanp8PJyQkGBgZQVVVFSUkJCgoKMGjQoHrV09QsJjk5GSoqKrC2tqbHRkFlGaixymNLzGRyc3Nx69YtnDt37p37NeawyUTnRJaPi++++w737t3D48eP4ezsjODgYACffkaP5W8+7qsoS5sjrYUgkUjA4XDoi0V2djbKy8sxc+ZM9OjRA0FBQSgsLISnpycdWHC5XGhra+PRo0fo378/njx5gu3bt0NVVRUmJiYAgJs3b4LL5dL/rkt1dTUyMzPRrVs3GBsby4wLeBtQpKSk4MSJE7h9+zZ69eqFmTNnYtSoUQ1e2KSXX5jI0aNH0aVLF/zrX/96535OTk64efMm/Pz86G03btyAs7Nzaw+R5RPHyckJRUVF8Pb2hru7OwBAJBJ99IE4SzNop1oJlk+MmpoaMm/ePGJmZvbO/cRiMfHz8yPq6urEysqKzJ8/n6ioqBAPDw+SnZ1NCPm7s6CuCRNVQJWYmEiGDRtG1q5dSz+nNE+ePCEGBgbE09OTHDx4kMyaNYvY2NiQP//8k94nMzOTNsBhMmKxmBgaGpKVK1fWe6yuF8Ddu3eJoqIi2b59O0lJSSHbt28nSkpKtAyvvBgZGTUoLbxo0aIG9z969GiD+1MFcf8Etm7dSuzt7UmHDh2Inp4eGT9+PElNTW3yuNDQUGJhYUFUVFSIhYUFOXfuXBuM9v2QlnRnux3+ebDBAkuLIBQKSWhoKNm+fTshhJDa2loiEokavai8efOGXLlyhWRnZ5Px48eTgIAAUlFRQQghRFdXl6xevZrU1tbKHEM91+nTp4mDgwNtMy0SiehAoqCggMyYMYPY29vLHBsYGEhMTU0JIW+16+fOnUvMzMzI1atXycyZM8nPP/9M3rx50+BYRSLRO/XsW7MK/Pr167TVdV3qegEQQsiZM2eImZkZUVZWJubm5uTs2bPNPmdRUZGMWdHNmzcJAHLnzp0G9z969CjR1taWOYYyGPqnMGbMGHL06FGSmJhInjx5Qv71r38RQ0NDuuW4IaKjo4mioiLZunUrSUlJIVu3bn2v4I6FpS1gvSFY2hzSQNEd1QVRW1sLBwcHbNiwAV988UWDx23cuBF//vknjhw5gj59+sg8FhERAV9fX6SkpEBTUxOGhoaYNm0aSktLcfXqVVy/fh0SiQTz589HREQEvLy8oKmpidDQULi6uuLIkSNNFgVKr9P+E1Kxy5cvx5UrV/D06dMG35egoCAsX74cpaWl7TA6ZvLq1St06dIF4eHhdNdAXTw9PVFeXo5r167R2z777DPo6uri5MmTbTVUFha5YCtTWNoc6boH6k9RURGEECgrK+PRo0f1AgXqOKFQiCdPnoAQAi6XW+85xWIxcnJycPfuXURHR2PmzJkIDw9HUFAQuFwuhEIh8vPz8ejRI/j7+2PPnj3YunUr/P39cefOHURHR9PnuXXrFtzd3eHq6org4GBUVFQA+LvIkhCCXr16ISQkRKbj4s8//8SyZctQXV3dqu9jW0CpT86aNeudAVRlZSWMjIzQs2dPjBs3Do8fP27DUTKPsrIyAEDHjh0b3ScmJgajR4+W2TZmzBgZwzIWFqbABgss7Ya03wH1b4lE8s42x6qqKnTv3h13796FqakpXFxcsG7dOty+fRsCgQBGRkbg8/ngcDgwMzODn58frly5gpycHJw4cQIGBgaIj4+HhoYGvvzyS/p5TUxMoKWlhfLycgDA3r17MWvWLHTo0AGjR4/GjRs3sGzZMowcORIPHz5ERUUFDh06BEVFRfTp0wdKSkpQUFBAbW0tIiMjcejQIairq+NjT9zJo+9gbm6OoKAgXLp0CSdPnoSamhpcXFzw9OnTthsogyCEwN/fH66uruDxeI3ux+pisHxUtMfaBwtLS3D37l0SEBBArK2tib6+Pi1DPXnyZDJs2DCSl5dHCCGksrKSlJaWEkLe1lasXLmyXk3DkSNHSM+ePcnLly8JIW/rJjZv3kyrU169epXo6ekRZ2dnkpSURO7evUu4XC7hcDjEwsKCzJs3j+Tk5JDi4mLy5ZdfkkmTJtHPLRaLP9qCsNGjR5Nx48Y16xixWEz69etHli5d2kqjYjaLFi0iRkZG5NmzZ+/cT1lZmYSEhMhsO378OFFVVW3N4bGwvBef9mIryycH+f+WTUVFRTg7O8PZ2RmBgYEA3mYdACAwMBBLlixBv379wOPxYGRkhL59+2L58uXg8/nIzMyEhYUF/ZzV1dVITk5G586d0b17d9y6dQuVlZWYPXs2tLW1AQDu7u5QV1eHoaEh9PX1YWlpif79+6NTp05wdnZGaGgosrOzYW5ujr/++gvLly9HVVUVFBQUoK6u3vZvVAsgr75DXRQUFDBw4MB/ZGZh6dKluHTpEiIiItCzZ8937svqYrB8TLDLECwfFRwOh9ZDkEgkEIlEtDOjpqYmJBIJ+vbti+vXryMqKgoTJ06Evr4+nJycoK2tjdTUVDx69Aj29vb0cxYXFyM5ORm2trYAgISEBOjr66N79+60ouTz58/RoUMHWFhYQEdHB9XV1cjOzsbgwYPh7++P6OhoDB06FA8fPkRZWRni4uIwbdo06OrqwtPTE69fv27jd+rDkVffoS6EEDx58qRZdtzA22LRtWvXolevXlBXV0fv3r2xadOmJtU3w8PDYWdnBzU1NfTu3RsHDhxo1nlbAkIIlixZgnPnztHaHk1B6WJIw+pisDAVNrPA8tGioKBQT2RJWrmxIZVJAwMDTJgwgbbRBYDMzEwkJSXB09MTwNviNF1dXRQXF9PeFPfv30dtbS3dfREbGwtCiIxwlFgsRmJiIkpLS2FmZob58+cjKysLkydPxsWLFzFr1qxWeR9aA4lEgqNHj8LLy6tetwclurVt2zYAwMaNG+Ho6Ii+ffuivLwce/fuxZMnT/Djjz8265w7duzAgQMHEBwcDCsrKzx48AA+Pj7gcrnw9fVt8Jjs7Gy4u7tj7ty5OH78OO7evYtFixZBT08PEydOfL8X/x4sXrwYISEhuHjxIrS0tOiMAZfLpTNLdd83X19fDB48+P/au5tQ2P4wDuDfGCMvC8LELFgaGTtCsfOyUEZsZkqR8rJAFGYsEKVJWdhJKUPysiFNNrKgxEKGQo1ILFAa8tYsJjx34e/8TXdm7vUX93/N97N8Or9zzqzOM+f8nufBwMAADAYDFhYWsLy8jLW1tS+7b6Lf9kc/ghB9oufn54C9Hl6tr69Ldna20hRqY2NDUlJSZHh4WEREtre3JT8/X9LS0sThcIiISE9Pj2RnZ8vu7q5ynuvra6moqJCCggIldnd3JxUVFWIwGJR7+hu8p79DS0uLJCcni1qtloSEBCkqKpL19fV3X7OkpERqamq8YuXl5VJZWel3TUdHh+h0Oq9YfX295OTkvPv6HwEfTakAyNjYmHLMZ/XFIPoKTBYoqPzuZsPu7m6JiooSvV4vRqNREhMTxWQyKV0fS0tLpbKyUlwul7LG6XSKTqfzGhN9c3MjxcXFykPib93o+BWsVqukpKQoCcrOzo5oNJqfNgG+lZ+fL83NzV6xubk5UalUXh0Hiehj+BmCgoq/2RCvJZwejwcPDw/o7e1FU1MTnE4nVCoVDg4OkJ6ertTNazQanJ+fIyYmRjnP6ekpLi4uUFBQoMRcLhe2trYwNDQEgGN8AzGbzbi9vYVOp0NoaCienp7Q398Pk8nkd42/8sPHx0e4XK5375sgIt+4wZGCXkhIiPIQd7vdsNlssNlsiI+PR2pqKkZHR3F1deXVQKeqqgp7e3vQarVobGwE8LIxMjo6WpmECQDHx8e4urpCYWEhACYLgczOzmJychJTU1NwOBwYHx/H4OCgMuHQH19juX3Fiei/45sFojciIiLg8XhgNpvR1taG2NhYREZGoq+vD1lZWcpxeXl5ODo6wuLiotLIaXNzE4mJiQD+LfF0OBxISkqCRqP5ZRvpYNfe3g6LxQKj0QgAyMjIwOnpKaxWK6qqqnyu8Vd+qFKpEBcX9+n3TBQsmCwQvREeHg6LxQKLxYLDw0M4nU7k5uYqVRGv5J/W1GVlZUpsZmYGFxcXAF7+1brdbtjtdqWC4rU/BPnmdrt/+kwUGhoasHQyNzcXdrvdK7a0tITMzEyEhYV9yn0SBSMOkiL6gLdDpXzZ39+HiECv1/PNwi9UV1djeXkZIyMjSE9Px/b2Nurq6lBTU4OBgQEAQGdnJ87OzjAxMQHgpXRSr9ejvr4etbW12NjYQENDA6anp7+0dJLou2OyQET/C/f39+jq6sL8/DwuLy+h1WphMpnQ3d0NtVoN4CWhODk5wcrKirJudXUVra2t2N/fh1arhdlsRkNDwx/6FUTfE5MFok/EtwlE9B2wGoLoEzFRIKLvgMkCERERBcRkgYiIiAJiskBEREQBMVkgIiKigJgsEBERUUA/AFlBiSUXnjD6AAAAAElFTkSuQmCC",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f72c8967390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f72c8967400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f72c86b0cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
>>>>>>> pr/1276
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "\n",
    "show_iris()\n",
    "show_iris(0, 1, 3)\n",
    "show_iris(1, 2, 3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can play around with the values to get a good look at the dataset."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DISTANCE FUNCTIONS\n",
    "\n",
    "In a lot of algorithms (like the *k-Nearest Neighbors* algorithm), there is a need to compare items, finding how *similar* or *close* they are. For that we have many different functions at our disposal. Below are the functions implemented in the module:\n",
    "\n",
    "### Manhattan Distance (`manhattan_distance`)\n",
    "\n",
    "One of the simplest distance functions. It calculates the difference between the coordinates/features of two items. To understand how it works, imagine a 2D grid with coordinates *x* and *y*. In that grid we have two items, at the squares positioned at `(1,2)` and `(3,4)`. The difference between their two coordinates is `3-1=2` and `4-2=2`. If we sum these up we get `4`. That means to get from `(1,2)` to `(3,4)` we need four moves; two to the right and two more up. The function works similarly for n-dimensional grids."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def manhattan_distance(X, Y):\n",
    "    return sum([abs(x - y) for x, y in zip(X, Y)])\n",
    "\n",
    "\n",
    "distance = manhattan_distance([1,2], [3,4])\n",
    "print(\"Manhattan Distance between (1,2) and (3,4) is\", distance)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Euclidean Distance (`euclidean_distance`)\n",
    "\n",
    "Probably the most popular distance function. It returns the square root of the sum of the squared differences between individual elements of two items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def euclidean_distance(X, Y):\n",
    "    return math.sqrt(sum([(x - y)**2 for x, y in zip(X,Y)]))\n",
    "\n",
    "\n",
    "distance = euclidean_distance([1,2], [3,4])\n",
    "print(\"Euclidean Distance between (1,2) and (3,4) is\", distance)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hamming Distance (`hamming_distance`)\n",
    "\n",
    "This function counts the number of differences between single elements in two items. For example, if we have two binary strings \"111\" and \"011\" the function will return 1, since the two strings only differ at the first element. The function works the same way for non-binary strings too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hamming_distance(X, Y):\n",
    "    return sum(x != y for x, y in zip(X, Y))\n",
    "\n",
    "\n",
    "distance = hamming_distance(['a','b','c'], ['a','b','b'])\n",
    "print(\"Hamming Distance between 'abc' and 'abb' is\", distance)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean Boolean Error (`mean_boolean_error`)\n",
    "\n",
    "To calculate this distance, we find the ratio of different elements over all elements of two items. For example, if the two items are `(1,2,3)` and `(1,4,5)`, the ration of different/all elements is 2/3, since they differ in two out of three elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_boolean_error(X, Y):\n",
    "    return mean(int(x != y) for x, y in zip(X, Y))\n",
    "\n",
    "\n",
    "distance = mean_boolean_error([1,2,3], [1,4,5])\n",
    "print(\"Mean Boolean Error Distance between (1,2,3) and (1,4,5) is\", distance)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean Error (`mean_error`)\n",
    "\n",
    "This function finds the mean difference of single elements between two items. For example, if the two items are `(1,0,5)` and `(3,10,5)`, their error distance is `(3-1) + (10-0) + (5-5) = 2 + 10 + 0 = 12`. The mean error distance therefore is `12/3=4`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_error(X, Y):\n",
    "    return mean([abs(x - y) for x, y in zip(X, Y)])\n",
    "\n",
    "\n",
    "distance = mean_error([1,0,5], [3,10,5])\n",
    "print(\"Mean Error Distance between (1,0,5) and (3,10,5) is\", distance)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean Square Error (`ms_error`)\n",
    "\n",
    "This is very similar to the `Mean Error`, but instead of calculating the difference between elements, we are calculating the *square* of the differences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ms_error(X, Y):\n",
    "    return mean([(x - y)**2 for x, y in zip(X, Y)])\n",
    "\n",
    "\n",
    "distance = ms_error([1,0,5], [3,10,5])\n",
    "print(\"Mean Square Distance between (1,0,5) and (3,10,5) is\", distance)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Root of Mean Square Error (`rms_error`)\n",
    "\n",
    "This is the square root of `Mean Square Error`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rms_error(X, Y):\n",
    "    return math.sqrt(ms_error(X, Y))\n",
    "\n",
    "\n",
    "distance = rms_error([1,0,5], [3,10,5])\n",
    "print(\"Root of Mean Error Distance between (1,0,5) and (3,10,5) is\", distance)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PLURALITY LEARNER CLASSIFIER\n",
    "\n",
    "### Overview\n",
    "\n",
    "The Plurality Learner is a simple algorithm, used mainly as a baseline comparison for other algorithms. It finds the most popular class in the dataset and classifies any subsequent item to that class. Essentially, it classifies every new item to the same class. For that reason, it is not used very often, instead opting for more complicated algorithms when we want accurate classification.\n",
    "\n",
    "![pL plot](images/pluralityLearner_plot.png)\n",
    "\n",
    "Let's see how the classifier works with the plot above. There are three classes named **Class A** (orange-colored dots) and **Class B** (blue-colored dots) and **Class C** (green-colored dots). Every point in this plot has two **features** (i.e. X<sub>1</sub>, X<sub>2</sub>). Now, let's say we have a new point, a red star and we want to know which class this red star belongs to. Solving this problem by predicting the class of this new red star is our current classification problem.\n",
    "\n",
    "The Plurality Learner will find the class most represented in the plot. ***Class A*** has four items, ***Class B*** has three and ***Class C*** has seven. The most popular class is ***Class C***. Therefore, the item will get classified in ***Class C***, despite the fact that it is closer to the other two classes."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "Below follows the implementation of the PluralityLearner algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(PluralityLearner)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It takes as input a dataset and returns a function. We can later call this function with the item we want to classify as the argument and it returns the class it should be classified in.\n",
    "\n",
    "The function first finds the most popular class in the dataset and then each time we call its \"predict\" function, it returns it. Note that the input (\"example\") does not matter. The function always returns the same class."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "For this example, we will not use the Iris dataset, since each class is represented the same. This will throw an error. Instead we will use the zoo dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zoo = DataSet(name=\"zoo\")\n",
    "\n",
    "pL = PluralityLearner(zoo)\n",
    "print(pL([1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output for the above code is \"mammal\", since that is the most popular and common class in the dataset."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## K-NEAREST NEIGHBOURS CLASSIFIER\n",
    "\n",
    "### Overview\n",
    "The k-Nearest Neighbors algorithm is a non-parametric method used for classification and regression. We are going to use this to classify Iris flowers. More about kNN on [Scholarpedia](http://www.scholarpedia.org/article/K-nearest_neighbor).\n",
    "\n",
    "![kNN plot](images/knn_plot.png)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how kNN works with a simple plot shown in the above picture.\n",
    "\n",
    "We have co-ordinates (we call them **features** in Machine Learning) of this red star and we need to predict its class using the kNN algorithm. In this algorithm, the value of **k** is arbitrary. **k** is one of the **hyper parameters** for kNN algorithm. We choose this number based on our dataset and choosing a particular number is known as **hyper parameter tuning/optimising**. We learn more about this in coming topics.\n",
    "\n",
    "Let's put **k = 3**. It means you need to find 3-Nearest Neighbors of this red star and classify this new point into the majority class. Observe that smaller circle which contains three points other than **test point** (red star). As there are two violet points, which form the majority, we predict the class of red star as **violet- Class B**.\n",
    "\n",
    "Similarly if we put **k = 5**, you can observe that there are three yellow points, which form the majority. So, we classify our test point as **yellow- Class A**.\n",
    "\n",
    "In practical tasks, we iterate through a bunch of values for k (like [1, 3, 5, 10, 20, 50, 100]), see how it performs and select the best one. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "Below follows the implementation of the kNN algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(NearestNeighborLearner)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It takes as input a dataset and k (default value is 1) and it returns a function, which we can later use to classify a new item.\n",
    "\n",
    "To accomplish that, the function uses a heap-queue, where the items of the dataset are sorted according to their distance from *example* (the item to classify). We then take the k smallest elements from the heap-queue and we find the majority class. We classify the item to this class."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "We measured a new flower with the following values: 5.1, 3.0, 1.1, 0.1. We want to classify that item/flower in a class. To do that, we write the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "\n",
    "kNN = NearestNeighborLearner(iris,k=3)\n",
    "print(kNN([5.1,3.0,1.1,0.1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output of the above code is \"setosa\", which means the flower with the above measurements is of the \"setosa\" species."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DECISION TREE LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "#### Decision Trees\n",
    "A decision tree is a flowchart that uses a tree of decisions and their possible consequences for classification. At each non-leaf node of the tree an attribute of the input is tested, based on which corresponding branch leading to a child-node is selected. At the leaf node the input is classified based on the class label of this leaf node. The paths from root to leaves represent classification rules based on which leaf nodes are assigned class labels.\n",
    "![perceptron](images/decisiontree_fruit.jpg)\n",
    "#### Decision Tree Learning\n",
    "Decision tree learning is the construction of a decision tree from class-labeled training data. The data is expected to be a tuple in which each record of the tuple is an attribute used for classification. The decision tree is built top-down, by choosing a variable at each step that best splits the set of items. There are different metrics for measuring the \"best split\". These generally measure the homogeneity of the target variable within the subsets.\n",
    "\n",
    "#### Gini Impurity\n",
    "Gini impurity of a set is the probability of a randomly chosen element to be incorrectly labeled if it was randomly labeled according to the distribution of labels in the set.\n",
    "\n",
    "$$I_G(p) = \\sum{p_i(1 - p_i)} = 1 - \\sum{p_i^2}$$\n",
    "\n",
    "We select a split which minimizes the Gini impurity in child nodes.\n",
    "\n",
    "#### Information Gain\n",
    "Information gain is based on the concept of entropy from information theory. Entropy is defined as:\n",
    "\n",
    "$$H(p) = -\\sum{p_i \\log_2{p_i}}$$\n",
    "\n",
    "Information Gain is difference between entropy of the parent and weighted sum of entropy of children. The feature used for splitting is the one which provides the most information gain.\n",
    "\n",
    "#### Pseudocode\n",
    "\n",
    "You can view the pseudocode by running the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pseudocode(\"Decision Tree Learning\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "The nodes of the tree constructed by our learning algorithm are stored using either `DecisionFork` or `DecisionLeaf` based on whether they are a parent node or a leaf node respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psource(DecisionFork)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`DecisionFork` holds the attribute, which is tested at that node, and a dict of branches. The branches store the child nodes, one for each of the attribute's values. Calling an object of this class as a function with input tuple as an argument returns the next node in the classification path based on the result of the attribute test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(DecisionLeaf)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The leaf node stores the class label in `result`. All input tuples' classification paths end on a `DecisionLeaf` whose `result` attribute decide their class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(DecisionTreeLearner)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The implementation of `DecisionTreeLearner` provided in [learning.py](https://github.com/aimacode/aima-python/blob/master/learning.py) uses information gain as the metric for selecting which attribute to test for splitting. The function builds the tree top-down in a recursive manner. Based on the input it makes one of the four choices:\n",
    "<ol>\n",
    "<li>If the input at the current step has no training data we return the mode of classes of input data received in the parent step (previous level of recursion).</li>\n",
    "<li>If all values in training data belong to the same class it returns a `DecisionLeaf` whose class label is the class which all the data belongs to.</li>\n",
    "<li>If the data has no attributes that can be tested we return the class with highest plurality value in the training data.</li>\n",
    "<li>We choose the attribute which gives the highest amount of entropy gain and return a `DecisionFork` which splits based on this attribute. Each branch recursively calls `decision_tree_learning` to construct the sub-tree.</li>\n",
    "</ol>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "We will now use the Decision Tree Learner to classify a sample with values: 5.1, 3.0, 1.1, 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "\n",
    "DTL = DecisionTreeLearner(iris)\n",
    "print(DTL([5.1, 3.0, 1.1, 0.1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the Decision Tree learner classifies the sample as \"setosa\" as seen in the previous section."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RANDOM FOREST LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "![random_forest.png](images/random_forest.png)   \n",
    "Image via [src](https://cdn-images-1.medium.com/max/800/0*tG-IWcxL1jg7RkT0.png)\n",
    "\n",
    "#### Random Forest\n",
    "\n",
    "As the name of the algorithm and image above suggest, this algorithm creates the forest with a number of trees. The more number of trees makes the forest robust. In the same way in random forest algorithm, the higher the number of trees in the forest, the higher is the accuray result. The main difference between Random Forest and Decision trees is that, finding the root node and splitting the feature nodes will be random.  \n",
    "\n",
    "Let's see how Rnadom Forest Algorithm work :   \n",
    "Random Forest Algorithm works in two steps, first is the creation of random forest and then the prediction. Let's first see the creation :  \n",
    "\n",
    "The first step in creation is to randomly select 'm' features out of total 'n' features. From these 'm' features calculate the node d using the best split point and then split the node into further nodes using best split. Repeat these steps until 'i' number of nodes are reached. Repeat the entire whole process to build the forest.  \n",
    "\n",
    "Now, let's see how the prediction works\n",
    "Take the test features and predict the outcome for each randomly created decision tree. Calculate the votes for each prediction and the prediction which gets the highest votes would be the final prediction.\n",
    "\n",
    "\n",
    "### Implementation\n",
    "\n",
    "Below mentioned is the implementation of Random Forest Algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psource(RandomForest)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This algorithm creates an ensemble of decision trees using bagging and feature bagging. It takes 'm' examples randomly from the total number of examples and then perform feature bagging with probability p to retain an attribute. All the predictors are predicted from the DecisionTreeLearner and then a final prediction is made.\n",
    "\n",
    "\n",
    "### Example\n",
    "\n",
    "We will now use the Random Forest to classify a sample with values: 5.1, 3.0, 1.1, 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "\n",
    "DTL = RandomForest(iris)\n",
    "print(DTL([5.1, 3.0, 1.1, 0.1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the Random Forest classifies the sample as \"setosa\"."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NAIVE BAYES LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "#### Theory of Probabilities\n",
    "\n",
    "The Naive Bayes algorithm is a probabilistic classifier, making use of [Bayes' Theorem](https://en.wikipedia.org/wiki/Bayes%27_theorem). The theorem states that the conditional probability of **A** given **B** equals the conditional probability of **B** given **A** multiplied by the probability of **A**, divided by the probability of **B**.\n",
    "\n",
    "$$P(A|B) = \\dfrac{P(B|A)*P(A)}{P(B)}$$\n",
    "\n",
    "From the theory of Probabilities we have the Multiplication Rule, if the events *X* are independent the following is true:\n",
    "\n",
    "$$P(X_{1} \\cap X_{2} \\cap ... \\cap X_{n}) = P(X_{1})*P(X_{2})*...*P(X_{n})$$\n",
    "\n",
    "For conditional probabilities this becomes:\n",
    "\n",
    "$$P(X_{1}, X_{2}, ..., X_{n}|Y) = P(X_{1}|Y)*P(X_{2}|Y)*...*P(X_{n}|Y)$$"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Classifying an Item\n",
    "\n",
    "How can we use the above to classify an item though?\n",
    "\n",
    "We have a dataset with a set of classes (**C**) and we want to classify an item with a set of features (**F**). Essentially what we want to do is predict the class of an item given the features.\n",
    "\n",
    "For a specific class, **Class**, we will find the conditional probability given the item features:\n",
    "\n",
    "$$P(Class|F) = \\dfrac{P(F|Class)*P(Class)}{P(F)}$$\n",
    "\n",
    "We will do this for every class and we will pick the maximum. This will be the class the item is classified in.\n",
    "\n",
    "The features though are a vector with many elements. We need to break the probabilities up using the multiplication rule. Thus the above equation becomes:\n",
    "\n",
    "$$P(Class|F) = \\dfrac{P(Class)*P(F_{1}|Class)*P(F_{2}|Class)*...*P(F_{n}|Class)}{P(F_{1})*P(F_{2})*...*P(F_{n})}$$\n",
    "\n",
    "The calculation of the conditional probability then depends on the calculation of the following:\n",
    "\n",
    "*a)* The probability of **Class** in the dataset.\n",
    "\n",
    "*b)* The conditional probability of each feature occurring in an item classified in **Class**.\n",
    "\n",
    "*c)* The probabilities of each individual feature.\n",
    "\n",
    "For *a)*, we will count how many times **Class** occurs in the dataset (aka how many items are classified in a particular class).\n",
    "\n",
    "For *b)*, if the feature values are discrete ('Blue', '3', 'Tall', etc.), we will count how many times a feature value occurs in items of each class. If the feature values are not discrete, we will go a different route. We will use a distribution function to calculate the probability of values for a given class and feature. If we know the distribution function of the dataset, then great, we will use it to compute the probabilities. If we don't know the function, we can assume the dataset follows the normal (Gaussian) distribution without much loss of accuracy. In fact, it can be proven that any distribution tends to the Gaussian the larger the population gets (see [Central Limit Theorem](https://en.wikipedia.org/wiki/Central_limit_theorem)).\n",
    "\n",
    "*NOTE:* If the values are continuous but use the discrete approach, there might be issues if we are not lucky. For one, if we have two values, '5.0 and 5.1', with the discrete approach they will be two completely different values, despite being so close. Second, if we are trying to classify an item with a feature value of '5.15', if the value does not appear for the feature, its probability will be 0. This might lead to misclassification. Generally, the continuous approach is more accurate and more useful, despite the overhead of calculating the distribution function.\n",
    "\n",
    "The last one, *c)*, is tricky. If feature values are discrete, we can count how many times they occur in the dataset. But what if the feature values are continuous? Imagine a dataset with a height feature. Is it worth it to count how many times each value occurs? Most of the time it is not, since there can be miscellaneous differences in the values (for example, 1.7 meters and 1.700001 meters are practically equal, but they count as different values).\n",
    "\n",
    "So as we cannot calculate the feature value probabilities, what are we going to do?\n",
    "\n",
    "Let's take a step back and rethink exactly what we are doing. We are essentially comparing conditional probabilities of all the classes. For two classes, **A** and **B**, we want to know which one is greater:\n",
    "\n",
    "$$\\dfrac{P(F|A)*P(A)}{P(F)} vs. \\dfrac{P(F|B)*P(B)}{P(F)}$$\n",
    "\n",
    "Wait, **P(F)** is the same for both the classes! In fact, it is the same for every combination of classes. That is because **P(F)** does not depend on a class, thus being independent of the classes.\n",
    "\n",
    "So, for *c)*, we actually don't need to calculate it at all."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Wrapping It Up\n",
    "\n",
    "Classifying an item to a class then becomes a matter of calculating the conditional probabilities of feature values and the probabilities of classes. This is something very desirable and computationally delicious.\n",
    "\n",
    "Remember though that all the above are true because we made the assumption that the features are independent. In most real-world cases that is not true though. Is that an issue here? Fret not, for the the algorithm is very efficient even with that assumption. That is why the algorithm is called **Naive** Bayes Classifier. We (naively) assume that the features are independent to make computations easier."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "The implementation of the Naive Bayes Classifier is split in two; *Learning* and *Simple*. The *learning* classifier takes as input a dataset and learns the needed distributions from that. It is itself split into two, for discrete and continuous features. The *simple* classifier takes as input not a dataset, but already calculated distributions (a dictionary of `CountingProbDist` objects)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Discrete\n",
    "\n",
    "The implementation for discrete values counts how many times each feature value occurs for each class, and how many times each class occurs. The results are stored in a `CountinProbDist` object."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the below code you can see the probabilities of the class \"Setosa\" appearing in the dataset and the probability of the first feature (at index 0) of the same class having a value of 5. Notice that the second probability is relatively small, even though if we observe the dataset we will find that a lot of values are around 5. The issue arises because the features in the Iris dataset are continuous, and we are assuming they are discrete. If the features were discrete (for example, \"Tall\", \"3\", etc.) this probably wouldn't have been the case and we would see a much nicer probability distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = iris\n",
    "\n",
    "target_vals = dataset.values[dataset.target]\n",
    "target_dist = CountingProbDist(target_vals)\n",
    "attr_dists = {(gv, attr): CountingProbDist(dataset.values[attr])\n",
    "              for gv in target_vals\n",
    "              for attr in dataset.inputs}\n",
    "for example in dataset.examples:\n",
    "        targetval = example[dataset.target]\n",
    "        target_dist.add(targetval)\n",
    "        for attr in dataset.inputs:\n",
    "            attr_dists[targetval, attr].add(example[attr])\n",
    "\n",
    "\n",
    "print(target_dist['setosa'])\n",
    "print(attr_dists['setosa', 0][5.0])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we found the different values for the classes (called targets here) and calculated their distribution. Next we initialized a dictionary of `CountingProbDist` objects, one for each class and feature. Finally, we iterated through the examples in the dataset and calculated the needed probabilites.\n",
    "\n",
    "Having calculated the different probabilities, we will move on to the predicting function. It will receive as input an item and output the most likely class. Using the above formula, it will multiply the probability of the class appearing, with the probability of each feature value appearing in the class. It will return the max result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(example):\n",
    "    def class_probability(targetval):\n",
    "        return (target_dist[targetval] *\n",
    "                product(attr_dists[targetval, attr][example[attr]]\n",
    "                        for attr in dataset.inputs))\n",
    "    return argmax(target_vals, key=class_probability)\n",
    "\n",
    "\n",
    "print(predict([5, 3, 1, 0.1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can view the complete code by executing the next line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(NaiveBayesDiscrete)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Continuous\n",
    "\n",
    "In the implementation we use the Gaussian/Normal distribution function. To make it work, we need to find the means and standard deviations of features for each class. We make use of the `find_means_and_deviations` Dataset function. On top of that, we will also calculate the class probabilities as we did with the Discrete approach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "means, deviations = dataset.find_means_and_deviations()\n",
    "\n",
    "target_vals = dataset.values[dataset.target]\n",
    "target_dist = CountingProbDist(target_vals)\n",
    "\n",
    "\n",
    "print(means[\"setosa\"])\n",
    "print(deviations[\"versicolor\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see the means of the features for the \"Setosa\" class and the deviations for \"Versicolor\".\n",
    "\n",
    "The prediction function will work similarly to the Discrete algorithm. It will multiply the probability of the class occurring with the conditional probabilities of the feature values for the class.\n",
    "\n",
    "Since we are using the Gaussian distribution, we will input the value for each feature into the Gaussian function, together with the mean and deviation of the feature. This will return the probability of the particular feature value for the given class. We will repeat for each class and pick the max value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(example):\n",
    "    def class_probability(targetval):\n",
    "        prob = target_dist[targetval]\n",
    "        for attr in dataset.inputs:\n",
    "            prob *= gaussian(means[targetval][attr], deviations[targetval][attr], example[attr])\n",
    "        return prob\n",
    "\n",
    "    return argmax(target_vals, key=class_probability)\n",
    "\n",
    "\n",
    "print(predict([5, 3, 1, 0.1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The complete code of the continuous algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(NaiveBayesContinuous)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simple\n",
    "\n",
    "The simple classifier (chosen with the argument `simple`) does not learn from a dataset, instead it takes as input a dictionary of already calculated `CountingProbDist` objects and returns a predictor function. The dictionary is in the following form: `(Class Name, Class Probability): CountingProbDist Object`.\n",
    "\n",
    "Each class has its own probability distribution. The classifier given a list of features calculates the probability of the input for each class and returns the max. The only pre-processing work is to create dictionaries for the distribution of classes (named `targets`) and attributes/features.\n",
    "\n",
    "The complete code for the simple classifier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(NaiveBayesSimple)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This classifier is useful when you already have calculated the distributions and you need to predict future items."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples\n",
    "\n",
    "We will now use the Naive Bayes Classifier (Discrete and Continuous) to classify items:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nBD = NaiveBayesLearner(iris, continuous=False)\n",
    "print(\"Discrete Classifier\")\n",
    "print(nBD([5, 3, 1, 0.1]))\n",
    "print(nBD([6, 5, 3, 1.5]))\n",
    "print(nBD([7, 3, 6.5, 2]))\n",
    "\n",
    "\n",
    "nBC = NaiveBayesLearner(iris, continuous=True)\n",
    "print(\"\\nContinuous Classifier\")\n",
    "print(nBC([5, 3, 1, 0.1]))\n",
    "print(nBC([6, 5, 3, 1.5]))\n",
    "print(nBC([7, 3, 6.5, 2]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the Discrete Classifier misclassified the second item, while the Continuous one had no problem.\n",
    "\n",
    "Let's now take a look at the simple classifier. First we will come up with a sample problem to solve. Say we are given three bags. Each bag contains three letters ('a', 'b' and 'c') of different quantities. We are given a string of letters and we are tasked with finding from which bag the string of letters came.\n",
    "\n",
    "Since we know the probability distribution of the letters for each bag, we can use the naive bayes classifier to make our prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bag1 = 'a'*50 + 'b'*30 + 'c'*15\n",
    "dist1 = CountingProbDist(bag1)\n",
    "bag2 = 'a'*30 + 'b'*45 + 'c'*20\n",
    "dist2 = CountingProbDist(bag2)\n",
    "bag3 = 'a'*20 + 'b'*20 + 'c'*35\n",
    "dist3 = CountingProbDist(bag3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have the `CountingProbDist` objects for each bag/class, we will create the dictionary. We assume that it is equally probable that we will pick from any bag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dist = {('First', 0.5): dist1, ('Second', 0.3): dist2, ('Third', 0.2): dist3}\n",
    "nBS = NaiveBayesLearner(dist, simple=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can start making predictions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(nBS('aab'))        # We can handle strings\n",
    "print(nBS(['b', 'b']))   # And lists!\n",
    "print(nBS('ccbcc'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results make intuitive sence. The first bag has a high amount of 'a's, the second has a high amount of 'b's and the third has a high amount of 'c's. The classifier seems to confirm this intuition.\n",
    "\n",
    "Note that the simple classifier doesn't distinguish between discrete and continuous values. It just takes whatever it is given. Also, the `simple` option on the `NaiveBayesLearner` overrides the `continuous` argument. `NaiveBayesLearner(d, simple=True, continuous=False)` just creates a simple classifier."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PERCEPTRON CLASSIFIER\n",
    "\n",
    "### Overview\n",
    "\n",
    "The Perceptron is a linear classifier. It works the same way as a neural network with no hidden layers (just input and output). First it trains its weights given a dataset and then it can classify a new item by running it through the network.\n",
    "\n",
    "Its input layer consists of the the item features, while the output layer consists of nodes (also called neurons). Each node in the output layer has *n* synapses (for every item feature), each with its own weight. Then, the nodes find the dot product of the item features and the synapse weights. These values then pass through an activation function (usually a sigmoid). Finally, we pick the largest of the values and we return its index.\n",
    "\n",
    "Note that in classification problems each node represents a class. The final classification is the class/node with the max output value.\n",
    "\n",
    "Below you can see a single node/neuron in the outer layer. With *f* we denote the item features, with *w* the synapse weights, then inside the node we have the dot product and the activation function, *g*."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![perceptron](images/perceptron.png)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "First, we train (calculate) the weights given a dataset, using the `BackPropagationLearner` function of `learning.py`. We then return a function, `predict`, which we will use in the future to classify a new item. The function computes the (algebraic) dot product of the item with the calculated weights for each node in the outer layer. Then it picks the greatest value and classifies the item in the corresponding class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(PerceptronLearner)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the Perceptron is a one-layer neural network, without any hidden layers. So, in `BackPropagationLearner`, we will pass no hidden layers. From that function we get our network, which is just one layer, with the weights calculated.\n",
    "\n",
    "That function `predict` passes the input/example through the network, calculating the dot product of the input and the weights for each node and returns the class with the max dot product."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "We will train the Perceptron on the iris dataset. Because though the `BackPropagationLearner` works with integer indexes and not strings, we need to convert class names to integers. Then, we will try and classify the item/flower with measurements of 5, 3, 1, 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "iris.classes_to_numbers()\n",
    "\n",
    "perceptron = PerceptronLearner(iris)\n",
    "print(perceptron([5, 3, 1, 0.1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The correct output is 0, which means the item belongs in the first class, \"setosa\". Note that the Perceptron algorithm is not perfect and may produce false classifications."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LINEAR LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "Linear Learner is a model that assumes a linear relationship between the input variables x and the single output variable y. More specifically, that y can be calculated from a linear combination of the input variables x. Linear learner is a quite simple model as the representation of this model is a linear equation.  \n",
    "\n",
    "The linear equation assigns one scaler factor to each input value or column, called a coefficients or weights. One additional coefficient is also added, giving additional degree of freedom and is often called the intercept or the bias coefficient.   \n",
    "For example :  y = ax1 + bx2 + c .  \n",
    "\n",
    "### Implementation\n",
    "\n",
    "Below mentioned is the implementation of Linear Learner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psource(LinearLearner)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This algorithm first assigns some random weights to the input variables and then based on the error calculated updates the weight for each variable. Finally the prediction is made with the updated weights.  \n",
    "\n",
    "### Implementation\n",
    "\n",
    "We will now use the Linear Learner to classify a sample with values: 5.1, 3.0, 1.1, 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "iris.classes_to_numbers()\n",
    "\n",
    "linear_learner = LinearLearner(iris)\n",
    "print(linear_learner([5, 3, 1, 0.1]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ENSEMBLE LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "Ensemble Learning improves the performance of our model by combining several learners. It improvise the stability and predictive power of the model. Ensemble methods are meta-algorithms that combine several machine learning techniques into one predictive model in order to decrease variance, bias, or improve predictions.  \n",
    "\n",
    "\n",
    "\n",
    "![ensemble_learner.jpg](images/ensemble_learner.jpg)\n",
    "\n",
    "\n",
    "Some commonly used Ensemble Learning techniques are : \n",
    "\n",
    "1. Bagging : Bagging tries to implement similar learners on small sample populations and then takes a mean of all the predictions. It helps us to reduce variance error.\n",
    "\n",
    "2. Boosting : Boosting is an iterative technique which adjust the weight of an observation based on the last classification. If an observation was classified incorrectly, it tries to increase the weight of this observation and vice versa. It helps us to reduce bias error.\n",
    "\n",
    "3.  Stacking : This is a very interesting way of combining models. Here we use a learner to combine output from different learners. It can either decrease bias or variance error depending on the learners we use.\n",
    "\n",
    "### Implementation\n",
    "\n",
    "Below mentioned is the implementation of Ensemble Learner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psource(EnsembleLearner)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This algorithm takes input as a list of learning algorithms, have them vote and then finally returns the predicted result."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LEARNER EVALUATION\n",
    "\n",
    "In this section we will evaluate and compare algorithm performance. The dataset we will use will again be the iris one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "iris = DataSet(name=\"iris\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naive Bayes\n",
    "\n",
    "First up we have the Naive Bayes algorithm. First we will test how well the Discrete Naive Bayes works, and then how the Continuous fares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nBD = NaiveBayesLearner(iris, continuous=False)\n",
    "print(\"Error ratio for Discrete:\", err_ratio(nBD, iris))\n",
    "\n",
    "nBC = NaiveBayesLearner(iris, continuous=True)\n",
    "print(\"Error ratio for Continuous:\", err_ratio(nBC, iris))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The error for the Naive Bayes algorithm is very, very low; close to 0. There is also very little difference between the discrete and continuous version of the algorithm."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## k-Nearest Neighbors\n",
    "\n",
    "Now we will take a look at kNN, for different values of *k*. Note that *k* should have odd values, to break any ties between two classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kNN_1 = NearestNeighborLearner(iris, k=1)\n",
    "kNN_3 = NearestNeighborLearner(iris, k=3)\n",
    "kNN_5 = NearestNeighborLearner(iris, k=5)\n",
    "kNN_7 = NearestNeighborLearner(iris, k=7)\n",
    "\n",
    "print(\"Error ratio for k=1:\", err_ratio(kNN_1, iris))\n",
    "print(\"Error ratio for k=3:\", err_ratio(kNN_3, iris))\n",
    "print(\"Error ratio for k=5:\", err_ratio(kNN_5, iris))\n",
    "print(\"Error ratio for k=7:\", err_ratio(kNN_7, iris))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the error became larger and larger as *k* increased. This is generally the case with datasets where classes are spaced out, as is the case with the iris dataset. If items from different classes were closer together, classification would be more difficult. Usually a value of 1, 3 or 5 for *k* suffices.\n",
    "\n",
    "Also note that since the training set is also the testing set, for *k* equal to 1 we get a perfect score, since the item we want to classify each time is already in the dataset and its closest neighbor is itself."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perceptron\n",
    "\n",
    "For the Perceptron, we first need to convert class names to integers. Let's see how it performs in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris2 = DataSet(name=\"iris\")\n",
    "iris2.classes_to_numbers()\n",
    "\n",
    "perceptron = PerceptronLearner(iris2)\n",
    "print(\"Error ratio for Perceptron:\", err_ratio(perceptron, iris2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Perceptron didn't fare very well mainly because the dataset is not linearly separated. On simpler datasets the algorithm performs much better, but unfortunately such datasets are rare in real life scenarios."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AdaBoost\n",
    "\n",
    "### Overview\n",
    "\n",
    "**AdaBoost** is an algorithm which uses **ensemble learning**. In ensemble learning the hypotheses in the collection, or ensemble, vote for what the output should be and the output with the majority votes is selected as the final answer.\n",
    "\n",
    "AdaBoost algorithm, as mentioned in the book, works with a **weighted training set** and **weak learners** (classifiers that have about 50%+epsilon accuracy i.e slightly better than random guessing). It manipulates the weights attached to the the examples that are showed to it. Importance is given to the examples with higher weights.\n",
    "\n",
    "All the examples start with equal weights and a hypothesis is generated using these examples. Examples which are incorrectly classified, their weights are increased so that they can be classified correctly by the next hypothesis. The examples that are correctly classified, their weights are reduced. This process is repeated *K* times (here *K* is an input to the algorithm) and hence, *K* hypotheses are generated.\n",
    "\n",
    "These *K* hypotheses are also assigned weights according to their performance on the weighted training set. The final ensemble hypothesis is the weighted-majority combination of these *K* hypotheses.\n",
    "\n",
    "The speciality of AdaBoost is that by using weak learners and a sufficiently large *K*, a highly accurate classifier can be learned irrespective of the complexity of the function being learned or the dullness of the hypothesis space."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "As seen in the previous section, the `PerceptronLearner` does not perform that well on the iris dataset. We'll use perceptron as the learner for the AdaBoost algorithm and try to increase the accuracy. \n",
    "\n",
    "Let's first see what AdaBoost is exactly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psource(AdaBoost)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "AdaBoost takes as inputs: **L** and *K* where **L** is the learner and *K* is the number of hypotheses to be generated. The learner **L** takes in as inputs: a dataset and the weights associated with the examples in the dataset. But the `PerceptronLearner` doesnot handle weights and only takes a dataset as its input.  \n",
    "To remedy that we will give as input to the PerceptronLearner a modified dataset in which the examples will be repeated according to the weights associated to them. Intuitively, what this will do is force the learner to repeatedly learn the same example again and again until it can classify it correctly.   \n",
    "\n",
    "To convert `PerceptronLearner` so that it can take weights as input too, we will have to pass it through the **`WeightedLearner`** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(WeightedLearner)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `WeightedLearner` function will then call the `PerceptronLearner`, during each iteration, with the modified dataset which contains the examples according to the weights associated with them."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example\n",
    "\n",
    "We will pass the `PerceptronLearner` through `WeightedLearner` function. Then we will create an `AdaboostLearner` classifier with number of hypotheses or *K* equal to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "WeightedPerceptron = WeightedLearner(PerceptronLearner)\n",
    "AdaboostLearner = AdaBoost(WeightedPerceptron, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris2 = DataSet(name=\"iris\")\n",
    "iris2.classes_to_numbers()\n",
    "\n",
    "adaboost = AdaboostLearner(iris2)\n",
    "\n",
    "adaboost([5, 3, 1, 0.1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is the correct answer. Let's check the error rate of adaboost with perceptron."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Error ratio for adaboost: \", err_ratio(adaboost, iris2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "It reduced the error rate considerably. Unlike the `PerceptronLearner`, `AdaBoost` was able to learn the complexity in the iris dataset."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}