00-keras-intro-sequential-api.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to keras\n",
    "\n",
    "> Keras is a high-level neural networks API, written in Python and capable of running on top of either [TensorFlow](https://www.tensorflow.org),[CNTK](https://github.com/Microsoft/cntk) or  [Theano](https://github.com/Theano/Theano). It was developed with a focus on enabling fast experimentation. \n",
    "> _Being able to go from idea to result with the least possible delay is key to doing good research._\n",
    "\n",
    "There are two ways to build Keras models:  _sequential_  and  _functional_.\n",
    "\n",
    "The [Sequential API](https://keras.io/getting-started/sequential-model-guide/)  is a linear stack of layers. Only for single-input, single-output, it is fit for most of use cases.\n",
    "It is limited in that it does not allow to create models that share layers or have multiple inputs or outputs.\n",
    "\n",
    "Alternatively, the [Functional  API](https://keras.io/getting-started/functional-api-guide/) provides a more flexible way for defining models, allowing to connect layers to any other layer. This results in the definition of complex models, such as multi-output models, directed acyclic graphs, or models with shared layers.\n",
    "\n",
    "The package offers many recipes to follow and many [examples](https://github.com/fchollet/keras/tree/master/examples) for problems in NLP and image classification.\n",
    "\n",
    "The example below was originally published at [Mike Irvine's Blog](https://sempwn.github.io/blog/2017/03/24/keras_basic_intro)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Toy dataset\n",
    "\n",
    "We start by generating data using the [scikit learn library](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T13:19:16.593000Z",
     "start_time": "2019-09-30T13:19:15.303974Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline\n",
    "from sklearn.datasets import make_moons\n",
    "from sklearn.preprocessing import scale\n",
    "from sklearn.model_selection import train_test_split\n",
    "X, Y = make_moons(noise=0.2, random_state=0, n_samples=1000)\n",
    "X = scale(X)\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T13:19:16.594000Z",
     "start_time": "2019-09-30T13:19:16.593000Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T13:19:16.854004Z",
     "start_time": "2019-09-30T13:19:16.594000Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(X[Y==0, 0], X[Y==0, 1], label='Class 0')\n",
    "ax.scatter(X[Y==1, 0], X[Y==1, 1], color='r', label='Class 1')\n",
    "ax.legend()\n",
    "ax.set(xlabel='X', ylabel='Y', title='Toy binary classification data set');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our data has a binary class (0 or 1), with two input dimensions ($x$ and $y$) and is visualised above. In order \n",
    "to correctly classify the class the neural network will need to successfully separate out the zig-zag shape that intersects\n",
    "where the two classes meet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to the Sequential API\n",
    "Now we import the keras library as well as the `Sequential` model class which forms the basic skeleton for our neural network. We'll only consider one type of layer, where all the neurons in a layer are connected to all the other neurons in the previous layer.\n",
    "\n",
    " * Models can be instaniated using the `Sequential()` class. \n",
    " * Neural networks are built up from bottom layer to top using the `add()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow\n",
    "print(tensorflow.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tf1 vs. tf2\n",
    "# tf1: import keras, tf.Session.run, tf.placeholder, tf.get_variable\n",
    "# tf2: import tensorflow.keras as keras or use tensorflow.keras since tensorflow was imported already above\n",
    "\n",
    "# if you need to migrate: https://www.tensorflow.org/guide/migrate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.2.4-tf'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensorflow.keras.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T13:19:23.007108Z",
     "start_time": "2019-09-30T13:19:18.168023Z"
    }
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow import random\n",
    "random.set_seed(3) # for reproducible results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining the model\n",
    "\n",
    "We'll create a very simple multi-layer perceptron with one hidden layer.\n",
    "\n",
    "This is done in keras by first defining a `Sequential` class object. Layers are then added from the initial layer\n",
    "that includes the data, so we need to specifiy the number of input dimensions using the keyword `input_dim`. We also define the acitvation of this layer to be a rectified linear unit `relu`. \n",
    "\n",
    "Finally a densely connected layer is added with one output and a `sigmoid` activation corresponding to the binary class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T13:19:23.089111Z",
     "start_time": "2019-09-30T13:19:23.007108Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create sequential  multi-layer perceptron\n",
    "model = Sequential()\n",
    "\n",
    "# The model expects rows of data with 2 variables input dimensions.\n",
    "model.add(Dense(32, input_dim=X.ndim, activation='relu'))\n",
    "\n",
    "# The output layer has one node and uses the sigmoid activation function.\n",
    "model.add(Dense(1, activation='sigmoid')) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compiling the model\n",
    "\n",
    "Before training a model, we need to configure the learning process, that is, compiling the model.\n",
    "The  `compile`  method uses the efficient numerical libraries under the covers (the so-called backend) such as Theano or TensorFlow. The backend automatically chooses the best way to represent the network for training and making predictions to run on your hardware, such as CPU or GPU or even distributed.\n",
    "\n",
    "It expects the following parameters:\n",
    "+ [optimizer](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers), the optimization algorithm such as  `RMSprop`  or  `adagrad`\n",
    "+ [loss function](https://www.tensorflow.org/api_docs/python/tf/keras/losses), the objective that the model will try to minimize such as  `categorical_crossentropy`  or  `MSE`\n",
    "+ any additional [metrics](https://www.tensorflow.org/api_docs/python/tf/keras/metrics) we want to consider.  For any classification problem we want to set this to  `metrics=['accuracy']`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T13:19:23.169111Z",
     "start_time": "2019-09-30T13:19:23.089111Z"
    }
   },
   "outputs": [],
   "source": [
    "model.compile(optimizer=tensorflow.keras.optimizers.Adadelta(),\n",
    "              loss=tensorflow.keras.losses.BinaryCrossentropy(),\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T09:58:50.525182Z",
     "start_time": "2019-09-30T09:58:50.522180Z"
    }
   },
   "source": [
    "## Investigating the model\n",
    "\n",
    "Let's see what we've constructed layer by layer:\n",
    "\n",
    "+ **Confirm layer order**. It is easy to add layers in the wrong order with the sequential API or to connect them together incorrectly with the functional API. The graph plot can help you confirm that the model is connected the way you intended.\n",
    "+ **Confirm the output shape of each layer**. It is common to have problems when defining the shape of input data for complex networks like convolutional and recurrent neural networks. The summary and plot can help you confirm the input shape to the network is as you intended.\n",
    "+ **Confirm parameters**. Some network configurations can use far fewer parameters, such as the use of a TimeDistributed wrapped Dense layer in an Encoder-Decoder recurrent neural network. Reviewing the summary can help spot cases of using far more parameters than expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T13:19:23.863123Z",
     "start_time": "2019-09-30T13:19:23.854122Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 32)                96        \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 1)                 33        \n",
      "=================================================================\n",
      "Total params: 129\n",
      "Trainable params: 129\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fitting the model\n",
    "\n",
    "We have defined our model and compiled it ready for efficient computation.\n",
    "Now it is time to execute the model on some data. Keras models are trained on Numpy arrays of input data and labels. \n",
    "\n",
    "\n",
    "The training process will run for a fixed number of iterations through of the rows in the dataset, that we must specify using the __epochs__ argument. \n",
    "\n",
    "We must also set the number of dataset rows that are considered before the model weights are updated within each epoch, called the batch size and set using the __batch_size__ argument.\n",
    "\n",
    "Training occurs over epochs and each epoch is split into batches:\n",
    "+ Epoch: One pass through all of the rows in the training dataset.\n",
    "+ Batch: One or more samples considered by the model within an epoch before weights are updated.\n",
    "\n",
    "\n",
    "For more on that, check out this post on [Machine Learning Mastery Blog](https://machinelearningmastery.com/difference-between-a-batch-and-an-epoch/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T08:56:30.548532Z",
     "start_time": "2019-09-30T08:56:25.037981Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f9ea845abd0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train, Y_train, batch_size=32, epochs=200,\n",
    "          verbose=0, validation_data=(X_test, Y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluating the model\n",
    "\n",
    "This will only give us an idea of how well we have modeled the dataset (e.g. train accuracy), but no idea of how well the algorithm might perform on new data. \n",
    "\n",
    "You can evaluate your model on your training dataset using the evaluate() function on your model and pass it the same input and output used to train the model.\n",
    "\n",
    "This will generate a prediction for each input and output pair and collect scores, including the average loss and any metrics you have configured, such as accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T08:56:30.548532Z",
     "start_time": "2019-09-30T08:56:25.037981Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss 0.653573055267334\n",
      "accuracy 0.532\n"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(X_test, Y_test, verbose=0)\n",
    "for i, s in enumerate(score, 0):\n",
    "    print(model.metrics_names[i], s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting the model predictions across the grid\n",
    "We can create a grid of $(x,y)$ values and then predict the class probability on each of these values using our fitted model. We'll then plot the original data with the underlying probabilities to see what the classification looks like and how it compares to the data.\n",
    "\n",
    "More details about how to make predictions for classification and regression models can be found at the [Machine Learning Mastery Blog](https://machinelearningmastery.com/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-30T08:56:38.954373Z",
     "start_time": "2019-09-30T08:56:38.835361Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAFpCAYAAAC/CnOrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9e5hcVZ3v/f1VVVfn0p3O/UISgbwJhsswRi4DSjho5HI8Q4MgDsYjxuGYx3MGmRkGMLzjC8iMYwzIwRl5z0y46DgHDCgOp9UoYoARMHEgRpFckCbK5Ebu6XSnr1W1zh+7dvWuXWutvfatau/q3+d5+klq195rr727utZ3/64khADDMAzDMEySyTR6AgzDMAzDMF6wYGEYhmEYJvGwYGEYhmEYJvGwYGEYhmEYJvGwYGEYhmEYJvGwYGEYhmEYJvGEFixENI6I/p2Ifk1EW4noi1FMjGEYhmGY5EJEVxDRG0TUTUSrFPt8jIi2lfXB447tRSL6Vfmny+h8YeuwEBEBmCiE6COiFgAvAfhzIcSmUAMzDMMwDJNIiCgL4LcALgWwG8ArAD4uhNjm2GcRgCcBfFAIcZSIZgohDpTf6xNCtPk5Z2gLi7DoK79sKf9wNTqGYRiGaV7OB9AthNgphBgGsA7AVa59PgPgQSHEUQCwxUpQIolhIaIsEf0KwAEAzwohfhHFuAzDMAzDJJK5AHY5Xu8ub3NyGoDTiOhlItpERFc43htHRK+Wt19tcsJcuPlaCCGKAN5DRJMB/CsRnSWEeN25DxGtBLASADKZ/DkTJ0yP4tTMGIQGRxo9hYYjxrU0egpMgyiO41yJNNJ/aPchIcSMep1v6SXjxNEjpVBjbP3NyFYAg45Na4UQa8v/J8khbu9KDsAiAJcAmAfgxbI+OAbgXUKIvUS0AMBzRPQbIcRbuvlEIlgqMxXiGBG9AOAKAK+73lsLYC0ATGqfK84758+iPDUzhsm/safRU4ic4Xe7H1SYsUzPwnGNngITks2P/NXb9Tzf0SMlPPXDcIaBxe/aNyiEOFfx9m4A8x2v5wHYK9lnkxBiBMDviOgNWALmFSHEXgAQQuws64YlAOIVLEQ0A8BIWayMB/AhAF8JOy7DmCJb3BstYlhwMFHAQoVJMK8AWEREpwLYA+B6AMtd+zwN4OMAvklE02G5iHYS0RQA/UKIofL29wNY43XCKCwscwD8czliOAPgSSHEDyIYl2ECw4KBSTMsVJikI4QoENFNAJ4BkAXwqBBiKxHdA+BVIURX+b3LiGgbgCKA24QQh4nofQD+iYhKsHTDamd2kYrQgkUI8RosUw7DMAwTAhYq6aP3ZFkox9hACLEewHrXtjsd/xcAbin/OPf5OYA/8Hu+SGNYGIZhGH+wSEkPY1mcJAEWLAzDMA2AhUo6YJGSHFiwMAzD1BEWKsmGBUpyYcHCMAxTB1ioJBMWKOmBBQvDMExMsEhJJixS0gkLFoZhmIhhoZI8WKSkHxYsDMMwEcFCJXmwUGkeWLAwDMOEgEVK8mCR0pywYGEYhgkAC5XkwUKluWHBwjAM4wMWKsmCRcrYoSGCpTguo/yj7+gelG5nGIZpFCxSkgWLlLFJ4iwspl8MLGwYhokbFirJgoXK2CZxgsUUttAwDBMXLFSSA4sUxia1gkWF7ouGxQzDMDpYqCQHFiqMm6YTLDpYzDAM44ZFSnJgkcLoGFOCRQe7mBhmbMFCJTmwUGFMYMHiAQsZhmkuWKgkAxYpjF9YsASE3UsMkx5YpCQHFipMUFiwxACLGYZJBixUkgGLFCYKWLDUGa8vUBY0DBMeFirJgIUKEyUsWBKGyRctixqGqYVFSjJgkcLEBQuWFMIuJ4YZhYVK42GRwtQDFixNhvvLmwUM06ywUGk8LFSYesKCpclhAcM0GyxUGguLFKZRsGAZY7CAiY7eaZNx5F1zUMi3IDc8gqn/sQ/th481elpNCYuUxsNChWk0LFjGOCxggtE7bTIOLpgPkc0AAAqteRxcMB8AWLRECAuVxsIihUkSLFiYKmQLBIuYWo68a05FrNiIbAZH3jWHBUsEsFBpLCxUmCTCgoXxhK0wtRTyLb62M96wSGksLFKYpMOChfENW2GA3PAICq156XbGHyxUGgsLFSYtsGBhImGsWWGm/se+qhgWAKBiCVP/Y18DZ5UeWKQ0FhYpTBphwcLEQrMLGDtOhbOEzGGR0nhYqDBphgULUxea0Y3UfvgYCxQPWKQ0HhYpTLOQ8d6FYeKhZ+G4qh8m/fDvNBn0nkyVH4aJCyK6gojeIKJuIlql2OdjRLSNiLYS0eOO7Z8iojfLP58yOR9bWJjE0OxupGaDBUnyYIHC1AsiygJ4EMClAHYDeIWIuoQQ2xz7LAJwB4D3CyGOEtHM8vapAO4CcC4AAWBz+dijunOyYGESSzO6kdIKi5PkwiKFaRDnA+gWQuwEACJaB+AqANsc+3wGwIO2EBFCHChvvxzAs0KII+VjnwVwBYBv607IgoVJFWyFiR8WJ+mAhQpTB6YT0auO12uFEGvL/58LYJfjvd0A/sh1/GkAQEQvA8gCuFsI8WPFsXO9JsOChUk1bIUJB4uTdMEihTHlaHECvnv8vSFH+eEhIcS5ijdlH0bhep0DsAjAJQDmAXiRiM4yPLYGFixM08FWGDUsUNIJCxUmgewGMN/xeh6AvZJ9NgkhRgD8jojegCVgdsMSMc5jX/A6IQsWpukZqwKGxUm6YZHCJJxXACwiolMB7AFwPYDlrn2eBvBxAN8koumwXEQ7AbwF4O+IaEp5v8tgBedqYcHCjDn8uJF6p01ORXE4FifNAwsVJg0IIQpEdBOAZ2DFpzwqhNhKRPcAeFUI0VV+7zIi2gagCOA2IcRhACCiv4ElegDgHjsAVwcLFoaB3ArTO21yVfn9QmseBxdYFtB6ixYWJM0NixQmjQgh1gNY79p2p+P/AsAt5R/3sY8CeNTP+ViwMIyEnoXjcGTKSVW9ggBAZDM48q45gQQLiw7GDQsVhjGHBQvDKChl5H8ehXwLiw8mMCxSGCYYLFgYRkGmVEAp2yLdzjB+YJHCMOHhXkIMo2DCiYOAKFVvFCVrO8MYwP18GCY62MLCMDpECXaNIxJFTOw7gHHDvY2dUwAG8+3onzgDpUwOmVIBE04cTOV1pAEWKAwTD6EtLEQ0n4ieJ6Lt5W6Mfx7FxBimkQzm29HXPhvI5AAigAiC0mmQtK+llG0BiFDKtqCvfTYG8+2NnlpTwdYUhomXKCwsBQB/JYT4JRG1w+q6+KyzYyPDpI3+iTMAt0ChDPonzkidZaKZriVpsEBhmPoRWrAIIfYB2Ff+fy8RbYfVxIgFC5NaVBlCqu1JppmuJSmwUGGY+hPpNxYRnQJgCYBfSN5bCWAlAOQ6plT+4Nvf9ux3xDB1p5kyhJrpWhoJixSGaSyRCRYiagPwFIC/EEIcd79fbkm9FgDGzZ1fUSnuLwEWMEwSmHDioBXD4nSlpDRDqF7X0qyBvSxUGCYZRCJYiKgFllh5TAjxvTBjyb4cWMQwfohi4Rw33Av0IlULsOq663EtlSDlsiiyA3vRi0TfMxUsUhgmeYQWLEREAB4BsF0IcX/4KdXCIoYxJcqFs7LYx4BKXAQVW17XHee1AM0T2MtChWGSSxQWlvcD+CSA3xDRr8rb/t9yU6TYUH2xsJAZ26Rh4VSJi5GB8Rga3xFIbDX6utMe2MtChWGSTxRZQi/BrqyVAFjIjG3SsHCqxMXQ+MlWzRfXdhPR0ejrTmtgLwsVhkkPyfkWjxndFxOLmeYhDQunXxFhsn+jrztNQcosUhgmnYwZwaKDrTLNQz0WzrBBvSpxodvfi0YLhjQEKbNQYZh0w4JFA1tl0kfcC2cUQb0qcdE60FMVw2JvT6KVQkbcgb1BYaHCMM0BC5aAsFWm/jgtGxBFAFRZ3J2NCeNcOMMEtzrnT6IIIUoAZatEVUthIJDYanTQbRJhocIwzQULlohhq0w8uC0boOqPrqBcXep+BA1udc9fUA4QJbT17quab1Cx1eig26TAIoVhmpex9W3WYNgqExypBcFNHSwKQYNb47aANDrottGwUGGY5ocFSwLw+rJlQWNuKYjbohA0uNWvBcRvYG+jg24bBQsVhhk7sGBJAX6+lNMkbvwsyqaZNXFbFIIG9ZIoWm4gyXY38sDeORgZGI/2/gORziuNsEhhmLEJC5YmIy3WGr/ZNlILgps6WRSCxJmo7rpsu9x9RBgaPxkthQHluZOapRMVLFQYZmzDgmWMkZQ4Gr8xHW4Lgi5LKG4C1WGhrPF2pVuLKPFZP3F0bGahwjAMwIKFKVPv7KYgWS1RWRDCLKq9E2ZWldA3qcMymG9XjidzYencX0nO+omy8SSLFIZh3CT3249JDHFYZRqV1RJmUR3Mt/vu9zN6Psk9VLiwLPfXHOkx9cr6CSLqosiEYqHCMIwKFixMYMJYZRqV1RJmUbWOlV+zyvKhTMcWAm297yjdX1bnZpc4Cnl/TEVIUFEXphYMCxWGYbxgwcLEgvcC1Ie2fe/UPavFdFGVLe66hVdl+fBycalo7z8QuOqtDD8iJKioC2I1Y6HCMIwpLFiYhjEypw8t6Bt9PQkYAflyNfl1XZgsqsrFXYUQSstHGNdXlFk/fkRIUEuJqdWMRQrDMEFgwcIkDveCphIwqnolfWIWAFHTpwcwW1RVi7sUIdA6cEwpLJJS0M2PCAkqsrxqwbBQYRgmDCxYmMSjEjCqeiXOVGG368OkwJpxJo4QVb2AlNaeBBR08yNCwogsmVWIhQrDMFHAgoVJBIWRdhRHpgMiB1AB2ZZDyLXIF3V7ASydMPz4ulwfXq4W06q6ANDXNhN9NMeqC0MZZYyILuU5CjHjNY4fERKFyGKRwjBM1LBgYRpOYaQdxeFZAMqLqWgpv0aVaHGLGqAI04+wn/olLUN98vRlN0SjXaMlZfe9AlWjqltiUsrfrwgJGj/DQoVhxg5EdAWArwHIAnhYCLHa9f4KAPcC2FPe9HUhxMPl94oAflPe/h9CiE6v87FgYRpOcWQ6KmKlQgbFkekVwSITNUCp/OPRxRn+6peMtLZ5ixVDSpkcjkxZIBUJUXVwNi3lH1fpfhYpDDP2IKIsgAcBXApgN4BXiKhLCLHNtesTQoibJEMMCCHe4+ecLFiYxiMUH0PHdpWoAQqwREsWgGrhLIHGH0LvJLNg3qirydruJbcFxSQQ1sRl1IhS/ixSGGbMcz6AbiHETgAgonUArgLgFiyRwYKFaTxUKFtMJNttVKIGWbROfLPaXYRi5T1dPIwqmNdPDIsWIbRVcb0CYU1dRvUo5c8ChXEyNH9Y+37rrnydZpIsvO5LCplORK86Xq8VQqwt/38ugF2O93YD+CPJGNcS0cUAfgvgL4UQ9jHjymMXAKwWQjztNRkWLEzDybYcqnb3AABKyLYcGn3pIWpyLb3KIF1T7EWZRg4BNfMxQJRAogRRTqf2sqB4BcJ6uYyc1hepOEKwUv4sTsYOcS2wsnHTJGKaQXgcL4zDs+8sDjnKDw8JIc5VvCn7onCbrb8P4NtCiCEi+iyAfwbwwfJ77xJC7CWiBQCeI6LfCCHe0s2GBQvTcGyhocsSMhI1PtBlJVXmMzwbajeTC0mp/SNTFmgtKF6BsDrB47a+2HPwW8p/MN+Ovo4Z1fcBye0GzahJ+iLrnF9c4iXp96DJ2A1gvuP1PAB7nTsIIQ47Xj4E4CuO9/aW/91JRC8AWAKABQvTGPykKntZSLxEjftclOmDKLWp9/XIShoVLbUiyaLaKiLrC2SSSqwLhNW5jJQ1aMSoW0sW7+K0nlTug9BnZ+nw8ztmzGn2hbfZr2+M8AqARUR0KqwsoOsBLHfuQERzhBD7yi87AWwvb58CoL9seZkO4P0A1nidkAULEwumqcp+UIka2blEcTIq1hHXuU2ykpzzdC/INdvyhzDS1oeR8vnsWJiw9Uyk6dVlwdPXPkd53PTDvwVgiZMRjYXI9D6oiON3PFbhBZxJG0KIAhHdBOAZWFkPjwohthLRPQBeFUJ0AbiZiDphxakcAbCifPjpAP6JiOw0z9WS7KIaWLAwsaBcDIetnjxBFjTV07z8XO6FOoPi8AzrvJqspKH+U2vcQ7K56uZvWzEq8y35FyuD+XYMje9wiRWB1oEejBvuRX9phjzQloBD00+z7s+Ih7XDIDvLSU0dHEEII3jGOixSmLQjhFgPYL1r252O/98B4A7JcT8H8Ad+z8eChYkHZVYPBXoK1z3Nq8/lplyyXxXAC4rMSlA1Xypn+EyajYE8GY071D9j1FVTmR5haGIbMOOgIjBYQGVVkqK8D0UM9Z9aa1WqqYOjaFJp/PsYe7BIYZjg8DcLEw/KxRCQFoXTxEFYi78sANYaR3+uWuQBvOr5mVKdWg3lfI3G9bB+1LirDM4njfMpdqA2RicjiWuRFehTuJvIf2ZSM8MihWGigQULEwueokDkUBhpB1D75O60DIxaKhSLo8ghm3/HMKOnWBkXcC72kuN8WglqLEAqTMc1qE3jdFcNnVikPZ88zqcDlO2pCk623DzuOWagvrfC9V7wzK1mgkUKw0QPCxYmMmqe4LM91cGvVZDmyX3UMiCPT3EOU7D2G54B/ce5hGx+NDvHXuwt14dH0ToDPOfpc1zfadweAkcVUyRKbWid8LvKFqXwUVIESHCWUBkWKgwTHw0RLCIvlH/YaSouxIyifoI/JnE72Gie3G1LhNYiMbqAZ/MHFRYOAaCIbP6gdCGNrL6LkeXEfFyT2jROPK/DNMBWE9dije0aX3FfxxIsUhimPiTOwsIln9OJ7gk+m9/vrwgbMGqJUC6gAtn8/qpsHsvKIomzIKGt/1KZv08rQW3MigxRuQ6/1gc/1Xs9r8Ok/QE0wqdsneKaK6OwUGGY+pI4weKF7kuCxUwD0TzBV1w7fp7cbcuJcgHdL1kss8o5FEbaAxetkyGPWZHEc0jnGQ/u6yiMtI9m+6jm57L4eAmfsSxQABYpDNNIUidYdLCYaSAeT/BBn9xrA2StwNni8GwUR6ZXF3JTTy7ygmbq2i/BLSpRog8C1rvJoujL1EywSGGYZNBUgkUHi5l48Yqh0D2529lCKuwFVFuLxTPgVZ9S7LvEvM4NRAVA5Coiqp6Lf7WbSuWC07vJGAsWKgyTLMaMYNHBAcDhUdUFcS7asid3P+XdVXEyxugquPotMa+r/WJvr3OpeuPUaoCLuylgkcIwyYW/tTSwVUaNyiJRKo7T9vFx46ufTQSL7PDgDOTHVXcw9ttTpzDSXq5X4o4Jcb/Wj2OP5ceyo9vfOLUaSEVxt3o2VmShwjDJhwVLQMayVUZlkagRKxU0i7affja+KtrKxAOV53fQtav5HNTBtkXogn5l6F1cbmsVUBOg7BaDxoIu+cXd6tFYkUUKw6QLFiwRMxasMsoUZmWROKgXU8N0W0AdJ2Ofv3qbzxRqwzkog21JADAfRz1WxpGe7X5Pdg8dYtBT0ImGBwObEraTtA4WKgyTTliw1JGmscoEcc0oFm0/hdtUgbuybXZXaBN8FY/TWGOsFgE+itAp72MWvgRXeRx9OwQByh6rcYclFp+dpL1gkcIw6YcFSwJInVXGZ7NBQCgXbb+F21Qpt+5tcveUtWiHmoPGGuO7CJ3v+6igLAblgc/lXXyIlXrGjijxYfXSwUKFYZoHFiwJJ4lWGZVFwuod5C7Db4kEeXbQDIzGfRSRzb8TaGGULbD5cQcxPIiyaLHQLdqmtUdM0rdNr0Ht4irB/E+z2oITtoZKPWJHTAjTMoFFCsM0JyxYUkojrTL6miqDNU/4otSGwshg5Th54Gou0MKoW2AtcRKtC6Ry7VViq6Tc32gsmYtL6dqxBU02FuuHOq5m9ug118HqEqRlAgsVhmluWLA0IfWwyrgXFHeRtFoRYS142fxBTfqt/6DKuIIzvd0izsaNIcSW5hw1rp0YhEKtpUsFofJ1ocpmcs0vrGvJxFrEIoVhxg6RCBYiehTAHwM4IIQ4K4oxmehxf7mHETA6y4a6bL29sGsCSv0GVUYcnAl4u0WiEEle56hHeXxfheZqkGQzuYVMTK4lFikMMzaJysLyTQBfB/CtiMZj6oDsi98WMUZP/4pFWy8WMqj025Hht6CZJnB1qP/UQBYJT0ESgUjSpTTXK1bEV6E5KbJspoyjr1O0li8WKtHRuXELbn/qGZx0+Bj2TpuMNddejq4LlzR6WgyjJRLBIoT4GRGdEsVYTGMZmj8M9HQA78wChObpWLdoG2W/lFC7oPkvaKZO5aXgT/VegiSKDBZNSrOus3SkaAWWrPBeBOP6tHyxSImezo1bsPqb38OE4REAwLzDx7D6m98DABYtTKIJ83jlCyJaSUSvEtGrxd4T9TotE4SDDrFSIYNiadroS9XiXAkc1VhRAFiCpVjezyq6ls3v971Q51p6kc3vB2hEcU7nE78hmmsDUL4+d6CtT7GlFDfkf75B0QqsIvTBxPbvTzGuxz30Ymj+sLlY6ekAuk8Ddpxp/dvTYXbcGOX2p56piBWbCcMjuP2pZxo0I4Yxo25Bt0KItQDWAkDrqfO8VjMmCno6LPFRaAFyI8CM/UBHj/dxBYV1pNCCoYXlRaTnHeCduS5hU6q4YKz4BtXHyw7gLPlOZVa5qnItvRg6sUh+kM+n+jCdp/2dYzakVow6NSZUW6dKyOat7KpRF58tTrLQZzOVjN6TEcia0tNR/Tks5K3XgNlnfQxy0uHaWkS67QyTFDhLqFkJ80WeG7H2l223scdwCaLc8QEAsLKBPAM6ow1UNXHVmGSu1BZgsxbr4vBsFEemV4mkoGhFXZ0aE8pTtIvI5g9W3jO5RqNMJ42oC+X2kVkDRcbazoJFyt5pkzFPIk72Tpss2ZthkgMLlmYlzBf5jP211hMqWduddPTUjDVUscYfBnoKo4LGGqT2XCJnnP46mpXiZDRQ1csy4qcomi1IVMdc+ZtNuO3572FOz1Hs65iC+z/0YfzgD8+pvT4NclFX38aEfoWX7HfVOuF3gcaOJD5FYw1k5Ky59vKqGBYA6M+3YM21lzdwVgzjTVRpzd8GcAmA6US0G8BdQohHohibCUiYL3KF9cT3E6tT0HSfJrfaoOgj/VVVKyRbtb9K/ARJR5Yd07n13/B3P/7fmFAYAgDM7TmKv+16EgB8iZYoXEv1JEwV3CqhY3+eEIFgMbEGMlXYgbWcJcSkjaiyhD4exThMhIT9IpdYT0KhstoA8gDfgOmv2qd6TfaPMjNHcsztP/tWRazYjB8ZwS0/Xe/byhJ1vZU4+wAFrT9jzWlWPHEmptZApoquC5ewQGFSB7uE0oSfINqkfZGrrDb75sn3F7lal8GOIuQf2dpsFdnCrU63JrWlQHLMScflLps5PUfl11InYu8DFKD+zND8YaB7WnxxJlFZAxmGSTwsWNKC3yDaKL7Ig2YZqZBZbQ7OMrcEzdkH7JuLmmaBc/YBx0e3qBZueXNGG8tScPW2F3DLT9dXYlPu/cA1ePrdV1Uds3fSdMw7XtujaO+kGVamUh1dO1XCDICqkFskc/FRf6ZKbMYdZxK1NTChcLE3ZqzDgiUtBAmiDfNFrhJI/ROAE+3RiRiZJQjCGr/7tOrxNSJsyFl6o3saZK4LUWpDNr9fmU7c+fpL+NtnnsT4EUssze05ii//0Cre/PTiP65Ya+77YCe+/MNvVfYDgP5cK9ZcfANCFazziXFpfY80abc1ijJ9EKW2GreSLqi5MNJu1emxfy89jt8bx5mEhou9MQwLlvRQ72wIlUDqmYrKYl/IWy6d/XOAWfuCCRe3CAGqx3dbkUxEmOqeiByKCw5bgkaygN7+s2oRAlixKbc9/z386L1nVrb96L1nIpv9GG756Y8wp+co9k6ajjUX34CuMz/gOLLWshF1fIlxaX1NmrTMGiWKk1H5HUjEl/saitMKeutf0tyTKURX7I0FCzNWYMGSFur9lKoUQm7LBAGlXLggSluEyDKJgsQ6eN0rxQJ6ksTNA8hjU54+4xI8tfBPoBUMDstGLPElRgXm9GnS6kaVTkbFlzNIeGj+sBU91H2a3vrHcSah4WJvDMOCJT3U+ylVteirkAkLVQyMantUViSve6VYQHUFtWoCgN8wsG44LBtRdHiWji8NIhaV951WHGkgsmlVXcd+Vfeip8Ps9zZG4kzigou9MUmEiK4A8DVYtSUeFkKsdr2/AsC9APaUN31dCPFw+b1PAfhCefvfCiH+2et8LFjSQr2fUisZPD4a4DkXKF0MzPEpcvdBVFYkk3slWUC1BbXcIstzoXdZNiLo8OxGGVMi6ckkt/DMNj9ZbqRWtNm/Y91npKeDhUoEcLE3JmkQURbAgwAuBbAbwCtE1CWE2Oba9QkhxE2uY6cCuAvAubCesDaXj9WmWrJgSRP1fErt6AHemeNvQXUKC5MYGOf2g7OitSIFuFfKglpnXFIrvpTNHUVFIBU7epDbVRZgUXR4duGn8Jze9ePuzOx6rfodSJtkusbnvj6RwMXemARyPoBuIcROACCidQCuAuAWLDIuB/CsEOJI+dhnAVwB4Nu6g1iwMKO4rQiTeqqtIQCsLr0C1uKnWdSMY2Ac+ycg1kFaUKtbtjATpAv77D1V861YJTTNIsNgXHhOKzwlvxMqACKr/x2YuOq4r49vVOnLXOyN8cPwcA6/3zUj7DDTiehVx+u15UbGADAXwC7He7sB/JFkjGuJ6GIAvwXwl0KIXYpj53pNhgULYyFz4RyfAkw6OprGDAAgIFcAJh4b3Z4pWmv3vnmjlhK/MTC2dcbLMhJ1bRgTdAtzbthsLgoxVmWFiRNlvIt0ZyBbAhbu0O9m+jseY319wtRL4fRlJmEcEkKcq3hP9vTpNj1/H8C3hRBDRPRZAP8M4IOGx9bAgoWxULlwTrTXumpsMTO7HEcli1WZdFRinVFg6vYJ04E6DLrYmoW/NR9HIcbcsSGtAQSMV8q0PN5FN6CByJDW0JEQJJOtEcI0AsIKDk5fZlLEbgDzHa/nAdjr3EEIcdjx8iEAX3Ece4nr2Be8Tmj47cU0PbpMD13ROp3Qmb3HskBo4z2Ga9woSnTziJMZ+1Ye780AACAASURBVEf7HtnEmKE1NH+45kdHJaBWtMBZuK4w0l45vrjgMDBnD5ApwOBBxkxkdPRU/44zBVguQwdB7pMtTAt563psYdrT4Xloo9EJDhOiSl/u3LgFL926Gjs/vQov3boanRu3+DqeYQx4BcAiIjqViPIArgfQ5dyBiOY4XnYC2F7+/zMALiOiKUQ0BcBl5W1a2MLCWOisCEHSjW2hY7uMShlU6WNJvIcn9S6eZ5OA2BqtaFFU9i2WpgFwPODYFp7fLrZq56jwIzLcVqMoLCNBqjonhLCCI4r0ZXYrMfVACFEgoptgCY0sgEeFEFuJ6B4ArwohugDcTESdAAoAjgBYUT72CBH9DSzRAwD32AG4OliwMBa6DB1dvx+taCkfU8oBKJkFcuqIKu05yKKa5DoifoVcKasYSIQXY1Hcp0YJ0wgIKziiSF9mtxJTL4QQ6wGsd2270/H/OwDcoTj2UQCP+jkfu4QYC7d53+mqmdiLGjeC51N4bbVUZEvA4q1W3EeQRS0K10yK3Q1KVIItyPagv5so8TvvBLHm2svRn68WVn4ER9eFS7BqxTXYPW0ySgB2T5uMVSuu8SU0uCou06ywhYUZRfZ03NNhBc+663RMOmrtq7K+yAj7hByFa6aB7obYuu1Kg19LQDED7Diz9j4lvbdP0uenwbReiu6zEDZ9maviMs0KC5axiB+XiLQ4GFlBtdin7rYsy1qL4gk5rMuhQe6GWOMK3ELOjhmya6+4s6kSEJOjJenz88BLcMQdYyJzK5UAbDh7ceixGaaRsGAZa+hSg4HaRcJrge/oscrt90wdfW98HzA4MZlPyPVuIlkm9rgCpxDpPq02qNZtRYoqJieu9OMkxwyFJO7PQteFS3DOm2/jk89vqvj8MwCue3kzNi86meNYmNTCgmWsoXKJ7J9j/esWMlSUV0m1F3iZy2hwYnXBuSQ9ITfI3VDXuIJ6WZEaVRcnZbjdP/X4LCx7bUdNgCIH3jJphwXLWMH5JCyjlIW0x4+qBL29wOvqsKiKqpk+lcfx9B6Du8EkNqWucQX1siKZxgP1dJT7UpWzkzJFYNY+83ue0iJygNz9U1LsG+VngQNvmWakIYIlny/glPkHK68j6HfA6HA/CfvC2SAPtWX4/T7Nmz6Vx/n0HqG7wTQeIWy6qq+A3XpZkUx+9z0dwL65qEpILOXK2+D9e0i5FUfm/snAiilx/jVG3XmZA2+ZZiQRFhaneJHBgiYkXl11qQQIRVPC0Z2sSqZut5Gqaqrqad70qTwhxcO8hIJpPEKYbrtf/NbTVfEInkGaYaxIfqwZJpacg6p2AIa/y4R8DoKismgQrJTluDovmwjk2LLWGCYmEiFYvNAJGhYzBihjFxyFwvbN8x5H5jbychmZzsW93XS/GN0FJtYTP6b3IOmqnRu3VIkVG894hCBWJL/WDBNLjlc1ZC9SXEQOUFs69kybjIvuWxXbeb0EMlfDZdJIKgSLDrbOGGDSvM9PPRXpOQy7FpvGV5jsF7O7wMR6Erfp/fannlFWd4w8HsGvNUNmyZnYa73eN896rQraBsxiahqU1RUVUVSuDYpMINtWlbmHj9U8enBQLpN0Ui9YvGBBA2sR6ZkKrRXEq/MulQCU1BlD7gBbleVDVbdlYm/18SZP7zG7C0ysJ6oFacPZi/HSratDm9t1oiTyeIQg1gynJUcmIFH+3NTILsOYmhQXkQPCuQJNMXXtuK0qMjgol0kyTS9YvGh6d5NXpVobWfExgereP4D34lGVEVI+p9vyUanbYs+JrDlO6K+uE+Kcj8xyE9Jd4PVFb2o9Gcy3YHx5ETgycTx+cP4f4rqXN0diblfNoQRE+5Sua01gas2QxkplyrFPJX9ZQk7BS0UgU7JckinLEgLCV67V4ce1I7MYuuGgXCbJjHnBoqMprDOqSrU9U6sFAmAe96ASEbpsJKfl40Q7pCnUbsuI13xCuAtMvui9zPmyJ9bxIwVc+cpralfSGZf4irlRVS39lw9cEO0ieHAWpNWJIcysGT0d+pT5xVvN5+L+HIly88w5u1MlVOqBnyJ0XtaTMK4qDuBl6gELlhBELmjiCCBVWhsoWLyHTkR4ZSPZc4kqkDKEu8Dki97LnK8aY7ziKfakw8d8x9zUw6VgzcXD7aPDFhhSwVOm+zTzz3PKM4PqiZ+gb5W1TsAKAjb9XLnFyYazF0dmUWQYHSxYYsSXuymuAFKVFQKoXQTCCiYvwWFbPnRz8rOwhUjfNf2i15nz/fr7906aEWghjtOlUCFMcKuXUHV2xQa8fz8pzwyqJ36CvlUWQz/doGWWyUBZbAwTgCCVxJgIOGX+waqf7NHp6sUsDDP2lwNmFdiLgC2YCnlULTC62AY3usXNaflQzinAeTt6rIDfxVutfw0FlspX78eHr9r3yMTx6M9XL679+RasufgG+UBRLcQ9HZbg23Gm9a+f353sd2Ia3Go6f9PPs+pzlJLMoHqy5trL5Z81iWun68IlWLXiGuyeNhklWHVg/IgVQF0ITwYH8DJRwxaWhFAcHCd/o9BSY6nx5WqyF/B986DtoByFGV6VAeQOsnRbRkziWSLGT7qpyj+vGuOLn+gEIHHjzHg/UJBMJoqFOKyFLkyxOZ3FzI2JuEl5ZlA98esyDGut8yNCOICXiRoWLAkhO24QxcHx0u1ufMfO2IuObhGIwgzvZ9GzY2F2nBn+vAEw/aKXmcAfWPsEznnzbdx1w9XaMWoWhp4YF+IoBGfQlgUqoaoTyF7zAFLbPyhqvAJa6+IyLKPLWouz1QDDACxYEsOUhTtxeNtiiFK2so0yRUxZuNPz2L59M3G0ewGKg+OQHTeI6Qt3om3Ogeqd5h9E37Tjlf1qFoGoCnT5XfQaWBjM5IteZQL/5PObsHnRyf4WizgX4kbGfagKyB2fElycRdjvKc34bssQMyqr4nfefw6WvbaDs4SYWGHBkhBsgeEUHlNkwsNF376ZVUKnODgeh7ctrhrTeQ7VeH05qhFMdTHDJ9z8rzKBZ4BgQYU+F2LjdNFGV4SVXdeE/mjEWYq7NYchcFuGGNFZJu+q+2yYsQYLlgShExQqjnYvqBYZAEQpi6PdC3yNZSqYIq89k3Dzv8oEDsQfVOir30sShV8UVhJ3t+dC3rzTc8qpa1sGH9TTBcUwTliwpBxVsK4yiNeF253kZdWJpZheA8z/ppaLNddejgfWPiFdOGRBhVEW0PJTFKxhwi9u68f+OajNQ8lY24M0d9TNNWGWnLq2ZWCYFMCCJeWYBuvKhAkAY3eSKWlodeDHctF14RKc8+bbNab5oWymJqgw6g64foqCAai/8Iu5+SSAcodwH9tVeM21HteiQCVy69aWgWFSAguWlGMSrKuMc8kUI3EnyZAJpFPm68esl6DxZbkAsHnRyfj4i68gXyhWthHVZsCYjOvHAhN3J+jQpKkirddcG3QtOpFbt7YMDJMSWLCkHJPYkyNvLJIKE5TkHnJTd5IKP4HATuplnfFrubj9qWeqxAoA5AvFGoHjNa5fC4yfWjENoR6ZSVSUdwinYu02HV5zbVCWlU7kXnTfqso+boFbz9493CeISQosWJoAbfbPvpkojfj70nW6k/zGuADRBQI7iTJ2xq/lwlTgHJ04HtNODCjH9WvZqVsfoaDUIzNp9r7qoFsAQMna7gevuTYoy2qu4rNlb5cFuEbtenSO6/6sAYjlXAwTBBYsTc7R7gVQN6WTd+e13UlBLSVhA4GD4EfQ+LVcmAiczo1b0D40XLOPM9bFd0wKEp6RUY/MpKiCib3m2qAsq2KGkCsJ6XYVfoWvCSoRNNCSi/xcDBMUFixNjlokKCqRotrNFMRS4qdqb1hMLUBOQfPa/Hn46rRL8ZlHXsTMg73YO1VvuTARODK3EQCcGD+uMm7iY1L8Uq/MpCiCib3m2qAsq4xErOi2A8GEr5dbJ1DncYapMyxYUo5zwbZFiHPhVokHlWBxioqglpIwVXv9ENQCBAAblp2ODctOr9p2CuRWmi54u2ZUX+CT+/ori8Xcw8ear4R5mirSes21AdfiJWJlQuNY2wRM7etXHuNGZj2579Hv4q7HujDlxAD2TpusdE3p5s0w9Ya7NacYe8G2BAnB+nVSZeHu2zcTUxbuBGWqn/wpU0TbvD3S7dWiQvWUp376AyyxMO2MHciOGwAgkB03gGln7AideeRGZwGKklPmH8RrH5uH//rEjfjSHR9GLlvEAw89gU2f/xJu/O3PAKi/wI9OHI/7Hv0u5h0+VvkNCVjZHkfaJmCgJYcH1j6B7hvvwO8+vQov3boanRu3RDp/Jrnoui3bQmPe4WPIwBIa9z7yHUySxEkN57JK4SuznuQLRUw7MVAZV/UXfbRtgnE3aIaJG7awpBjZgm1jL9zzl26q7Ot2m4ybfNzDneIn9qWaIFV7/VLvWJllG7bjtvt/gnFDVsvl2Qd6cdv9PwFuAb6x8n1V7wHAYGsOrYVijauIAJxozWPc8EhlIbFdABzUOLbQBVa/dOvqGqHRWixJx+ltzSs/LybumwzkDQzvXn6lcn4MU28iESxEdAWArwHIAnhYCLE6inEZPV4Ls/2+Sjx4iYp6xqIEIY75LduwvRLbcmBGOx66cWnFdfSZR16sEiQAMG6ogM888iKuf3xlZR/nsV/48nrpeSYODStlHwc1Jog6VL9VBVb7iROZIrG62OjaS7jZPW2yWedxhoH52k9EHwXwHQDnCSFeJaJTAGwH8EZ5l01CiM96nS+0YCGiLIAHAVwKYDeAV4ioSwixLezYjB51fMro+2GoVyxKUKKen9KCAivmZebBXulx9nZZXIxKsHjZqE46EjKoMQll5pMwhzDUufqtO15FlSYvQxdTIgsa1+3L4oQxwXTtJ6J2ADcD+IVriLeEEO/xc84oLCznA+gWQuwsT24dgKsAsGCJGdmCPYrA+OmHQo0ftIN0vYh6fjoLyoZlp+PAjHbMPlArWg7MaFeO2dPeism9Q77ncmBGe/BCej4XWq+UcN/nDzCHhiMTV3WsfisLjB3OZTGUzVS5gYayGRBRlZvRK6ZE1V7CTeAO5MxYxXTt/xsAawDcGvaEUQiWuQB2OV7vBvBHEYzLeGAvzIdePx218dOEgUPTAXRXbXWnAY+ffggDh6YrF3yn28g+9tDrZyRGvEQZK6OyoMw60ItlG7bjoRuXSuNUHrpxac0xtmupo3dIk0AuRzWmE62Y6T5NudCecla3/CCfqM5fnbXmuuqklu1XiSuh+K3FUP1WFRh7pG0CDrbma4q5+Y0pWfbaDqMMC05XZnzgufYT0RIA84UQPyAit2A5lYi2ADgO4AtCiBe9ThiFYJFXH3PvRLQSwEoAaJ2pfiJl/NE25wAOvX6G9D13jIssDbhv9zzYv0JdWnCYFOK0oLKgEIDb7v8J7r3lMtx7y2XKGBcbt2sJsAIaCeo/lmKGkC0J7J8pH9MXDSoz7/6MqObgFjsNb4qpsqSocmdiqH6rS4t/7z/cic6NW3D349/H19Y+AQA4MnE8/mLlnxhbQ0yFCKcrNw80TGjdJane7I/pRPSq4/VaIcRa+xSS/St/NESUAfA/AayQ7LcPwLuEEIeJ6BwATxPRmUKI47rJRCFYdgOY73g9D8Be907li1wLAO3vnq3Pi2V8YRp8Ks8qqv7MqQrDxVFuv1GoAmtlFhQbZ3Ctl5iQuZYyAI5NGodxQ4UaC829t1wWTqC4aFThPuu7Sv8cL5tDwwWMTshRqS7Vb3X1WDo3bsF9j363yg007cQA7n3kOwDMAmJNAm85XZmRcEgIca7iPa+1vx3AWQBeKDeLnQ2gi4g6hRCvAhgCACHEZiJ6C8BpAJziqIYo6rC8AmAREZ1KRHkA1wPoimBcxhBVrRV38Klpum9xcBx2vXgBfv/sJdj14gXo2zezIeX248C2fsw+0IuMsAJrv/Dl9Xj6I18HANx7y2XKmhQql5HpfpN6B3HvLZfhnZntKBHwzsz2yMUKYP55CIu8DpAGKqFUyFZ9rtw0xNqispjkRoDZe4DcMABh/Tt7TywuLV09FlUV5dZiCfc//CR2GtTvkY0/nMvi8MTxKMHKDlq14hqOX2H8oF37hRA9QojpQohThBCnANgEoLOcJTSjHLQLIloAYBEAzy+o0BYWIUSBiG4C8Ays1KZHhRBbw47LmGMafOqVVeTE3s92/WRaRlAaqTUvJiXF2YRlG7bjjq/8qKZ3CwGY3DtUcfvsn+k/uNa9n+p4WSZR1NQrWFpXB6gaUf785CDKDQYT5VLU9RGqU/VbXT2WB8puIBk5w/o9duDtJ/7tF8iWBIoZwreXnoe7brg6hqthxgKqtZ+I7gHwqhBCZ7i4GMA9RFQAUATwWSHEEa9zRlKHRQixHoA8f5OpCybBp/qsIpvaEFFRygKZIihTTGyKsxe2ZUXWaM7Gdvv4Ca6VEfb4KGhk4b5qSsi0FModw83cj3WnQX2E3KjqsZjWUdHV7+ncuAXXvby58vnPlQSue3kzNi86ma0qTGBka78Q4k7Fvpc4/v8UgKf8no8r3TYBpg0A3U/efnJXRKEF08/altgUZy9kcSUyZh7srSoUpwuuVRH2+LTgbbETAEFqmbNxip6GBt/WsY+QVyNCN2uuvbwmhkWFKrg2jg7PDFNvWLCklOpgR8Ak08fe1jbngDSjgzJFULaodP3U46k9LkzjT2y3j9N1Ywfp/vXq9cbiox6unyjQVfb1wshi586+cZEml2IUyOqteLVisLff/fj3MaXc9FAV3nx0olxABunwzDBJgwVLCvFKHzUxtaviHAAkurptUFRxJU5KAH5+QXXjRK/qt1ERRjiEOWeYa9PXAfLG+blqeGpznQhq6XC7i375uXukHZvL2Rg1eHWFZpg0wN2aU4hJsKNJfEHbnAOYv3QTpp9lFSY89PoZONq9ABNP2ht7p+V689CNSzHYWq3PC1mCs5VcBsCHn9mKZRu2V7bpqt9GhSxz6bb7f1I1jziI4tra5hxApkXlalO5HJvnc+WXqCwdkyViRbddl4XEMGmBBUsKMREjpqZ2d2pqcXA8Tuw9CVMW7sQpl76A+Us3NcWismHZ6TUpxX0T8jV/AO4F26t/kI5lG7Zj3fK1eO7Sr2Ld8rVKAVIPUSQjzLU5sQJqzaBMEdPP2tY0nyu/qCwafi0dqv0JkKY4d124BKtWXIPd0yZzGjOTWtgllEK8gh39uHCaqSCcF+64kucu/ap0v1kHerFu+Vo8dOPSQP2DAH/ulqiEg1+CXpsb83R5IbWqjBV3ECBvRBjE0qFqaEhQx8WospAYJi2whSWFyAqDWWF4/k3tzVIQLgiqhZkwKjB+fsGCGleSSYqyH6uJah4loljdQjI3WZD0a/nnsRY7cHssE5Wlwx7nSNsEaaFDOy6GYZoJtrCkkCgLg9WzjHvS0JXiByyB8b5NO436B7nxYzVRzSNXEvjCl9fjr7+8Hgei6DHkQpd+bZoqD9R+Hu0icc7nIZXVz8i6IuuknLQGij6I0tIxcWBQGSnEGUBMs8GCJaVElWIsS01thqwgE5wL9qwDvdIvfrsui1+h4MfdYo+tqsLrtPg4948C2bUFaXTp/jyaCJ7fv76wWohM7AVOtFcLE0DeSRlItWiJgrse60JrsaR8nzOAmGaDXUJjnLY5BzDtjB1NlxVkyoZlp+P6x1div6KD+PH2YK4xv+6WDctOR0boe4LWIxAX0Mc1mfD7XTNwqCBQPOUtYPFWFE95C4cKAr/fNaNiUenbN9MSHoU8ALL+7Zla/fqducD+OfJOygdnRXClyaRz4xa8dOtqzx5BU08MKMcIkwFken6GqTdsYWFSXRAuKh66cSk+f++PkS9UP7FOODGEZRu2+7ZqBKl2a1IrJs5A3N/vmoFT5h+MPa7p97tmAN2LJEXlXDYukQGEwuGh67CcYoIUlnMjgMAZQFGcn2Higi0sDANLYPSPr10E80UR2KphW28++Oxf4frHV3qKnoduXAq1gd9CFaBrmkKtwrZ8/H7XDGX34kjjmsIKDlWH5ZSjKyzn5mjbBOkYR9smBBYXfs7PMPWGBQvDlJnUNyTdHtSq4VdEbFh2Op7u/EOlaFG5lMIWnqsJfJ2x3+pW7MBPXNMp8w9672QqOKhYM5dKJ+UmxE9hubuXX4nhXLXrbjiXxd3Lr/R9XtsNNJdL+DMJhgULw5RRWS/81iUB/IkIp7B536adeLrzD/HOzHYIAIWMVY33nZntuPeWy6RWmjCF56RZOh09wOw9QG4YgABywxCz9kbrNpSIIrgTdKkEzN5XMxfM3tO0AbeqQNlShmpiSrouXIJvLz0PhQxVPivfXnqeb+uK7Qaad/iYMuOIA3iZJMAxLAxTRpZeHKQuCaAXEU7RISsw9+FntirFiYyghee0KcWS7sXu/Z2WFN/F3+yxvbKE7P0iFih+OybXa1xZQTgBVLLHnDElAHDdy5sr7+VKAte9vBmbF53s65wyN5ATLuHPJAUWLAxTJkigrApTEWEqbHREVbHWL6Er1EpEEbAv3JgGxBVYGmZcp9A51jYBAy05TDkxgFKGalLdnTElQRopulG5ewSAPRGKOYYJCwuWlOKnsBdjTpCaKzJUIoIEKmX/Nyw7PZKy/EEsQ6kvhx+imFzQjslxjesWOlP7+tGfb8G/fOAC3PD8Jukxcw8fk1a4BfzHm6g6Oe+ZNhkX3bfK11gMEyccw5JCZA0LD29bbNW2YBKBrA4LUF0EbtmG7ZHEzcgaO/pxKaWOno7aGi7vzLW2GxBVx+SoxlUJnU8+v0kZU1LMUGSNFLmTM5MW2MKSQsZSw8K04lVF13b7RBU3E5VlKBUcnKUuJmdgZVFZFPZOmQp0nxa4BYByXA8BoRI0uqfJTElE1kjRtv7EEdPDMFHCgiWFRFHYi11K8WOLiOcu/SpIYr+3y/4DZnEzyzZsjyS+JvXuIFUNl/J2r8BX6ULfkseai1aUrTYI1AIgqIBQCR2vY6IUGtzJmUkDLFhSiJ+GhTJhAqCmV8yhrafj8I5FEIUWFjARo4pnsbsxm1hHZNlEcfQWSgW5kVFh4dpuEvgqXegvWoGuxR+sHq9stenc9oKRKAgqINZcezkeWPuEsX/eKYJYaDBjCRYsKcS0YaGyiV2mWONSgshAlBcBk2Z3jBq3JeTnFyzAh5/ZKu3GbCo6wmQTuefzd1d/uLLIxZXeGysz9lc3RAQqxeRu/0ezwNeahX7HmdJTdf76Zaz+iXnmj0pA6O5z14VL8LW1T3hetm2kG8w3Z1sChvGCBUsKsUWEbTmh3AiIgEOvn4Gj3Qsq1hFVrAtK3s9yccbENLM7SlVXZf3lZ6LzB6/VpKiaig7TbCIvsTT7QG9VHY9U9o2R1XApx5sEDqhVWG1u/9m3QmcUmVh99ijcQoUMIVsSEBiNaZna15+O3xPDRExDsoQm5QZx6ewdlR/GP21zDmD+0k2YftY2oJRFacTKmHBmDIVtVhdVszsnzZ7hpLKEvG/TTmU3ZpMUZpNsIll13au7fl0zH3vBTXXfmI4eYOFvgcVbrX/LIiZw5oys8i6VcNJxeZsBPxlFJvdZlalzy3/7GPZMm1zzRZ2a3xPDREgi0pqd4oUFjD90GUOqZnWZlhFQpug5dqTN7sro5tsM6CwhpqJD1n9IlibtziaSiSXVH/hJh4/Flt7bSAKn6EraEWD2nkhSh03uc9eFS7BqxTXYPW0ySgB2T5tc6bjcjL8nhglCIl1CMtHy7DuLGzCT5KPLGJp+1jZprMvUd78JYNSllGkZQWkkB+fy5qfZXVTzbQZ0VWe9Uphl7qTPr/kRPvfgc5jUO4jj7eMwmM9iUt+QNEvIT7E5e8ENkoabZEJlzkgq70aROmya7qyKfwmaLs0wzUYiBYsMt4hhAWOhyxhyx7q440WccSP1iivxk+GURnSixCuFWWYhyRcF8setezP5+CAGW3P40qoPS2NelNlIqLa0OBfcKOp4AAhVeTZqosyc8SOAVIG1YUVPVPVWGCbtpEawuGErjIVXxlDbnANGwsN0v7CYZjilFS9RokthNrGQ6IJ0VWJp/eVn4n2bdmLmgV7pghs6S8iuPGtn7QSoYZJkTASQSWBt0PvMhd0YxoKEIhAwTuaeOVn8jycviv08Y0XApC3rJm3zDcPNf/9TdP7gNWRLAsUMoeuPz8bf3/wh6b7rlq+VWkjclAj44LN/JX1PVVwu1mJx3acp6qIMWwGxcZAgiw4AvHTraqnbZnfM/Xj8pqWnMo29SXj706s2CyHOrdf5xs2dL07+7C2hxvjtnbfUdc5epNbCYsJYscLUyzoSFWmbb1Bu/vuf4iNdv66U5c+VBD7S9WvM230Et6/5WM3+MguJDF2foYaU6JdUnu3c+jxu/9m3cNLxg9EvjAm06DQiMNZvd+i4ulQzTL1IRJZQPXFnJHFWEhMXnT94raaHEAE475e7Ktk/TtxNDI+1t2I4V/0nGqTPUBR0btyCl25djZ2fXoWXbl2Nzo1bRt/MVafsdm59Hqt//HXMO34QGYwujFXHhEHXS6hBRNWI0A9+09JTncbOMGhyC4spHNDLxEG2JHe3EqCMQ3FbSKLqH+QkiBtB+2Tuqjx7+8++hQmFoaox/BZb0+LRS6gRNCIw1q9Vh9OjmbTDgkXCWHElMfFSzFBNZVsb0xTkKFw8zviVIG4B3ZN514VLairPnnT8kHScyBZGTS+hRhFFNpFf/KY7c3o0EzVEdAWArwHIAnhYCLFasd9HAXwHwHlCiFfL2+4AcCOAIoCbhRCepj4WLIawFSY8zRZsq7N+LNuwHUP5LLKDhRq3EKCPQ4lqDjI8xYcEoydzh2jZO2k65kkqxEa2MGp6CdUDleAIk010zptvY9lrO5QiRnZOv1YdTo9mooSIsgAeBHApgN0AXiGiLiHENtd+7QBuBvALx7YzAFwP4EwAJwH4IjkfZgAAIABJREFUKRGdJoTQVjRlwRIQtsL4Q9mIEelssKjrngxAGzzrLhZnIjhk+wHA5+/9MfKFUmUOn7/3xwDUzRSDuAV0T+ZVC+mkGVhz8Q1Yc/ENWP3jr1e5hcIujDUL9n/+CLpOvrLuWUJhA1dVgvGTz2+qBBS6x1Sdc9WKa7BqxTW4+/HvY0pfPwBgoCWHc958Wymo7DnMPXwMxQxhnCOGhQNvGZ+cD6BbCLETAIhoHYCrAGxz7fc3ANYAuNWx7SoA64QQQwB+R0Td5fE26k445oJu44SDedU0W0l+Xfdk2XuA1W33nZntuPeWy7Bh2enS3j+33f+TmoBc1X63PPBsRazY5AslfO7B5yqv3enMvoNDezqw5qIV6M+1Vm3uz7dgw9mLsfqb38O8w8es4NrjB7H6x18HAKy64ibsnjQDJVBVmfkg2At25TyHj2H1k/8bnQefqOklFDdhA1dVwlDXK8jrnOOGR0CwYqOmnRjADc9vqr5XjoBnu5DdQL4FuZKIJyiaaSamE9Grjp+VjvfmAtjleL27vK0CES0BMF8I8QPXuJ7HymALS4yYWGGazU2iotlK8pt2T3YiCLj+8dG/d53ocbqW7vjKj6RdnlUVlDqOq6sG+3ILlNOHuxbPB4rZcpryIeydMgVrrrtUvpAWhnD7z76Fi/77N9B15gcACEtUhCCIGysu5ioEh2q7G5W1SoYtbnRWMdm9cbsg3fcqSfeTiY/sMND+dug6a4c0dVhk3u7KCYkoA+B/Aljh91gVLFjqjFPEdO9ciBe3n4Zi0cpuSLubREezleTX9QwCoH3Pxkv02JYVVeBuEEyCQ0fdLz3YO2k61lx8A7rO/EBZgKBSEO6BtU9Iz1EVdBtBIGySsltUgdTFjOz7txaZYHS3TrCxrV46l5zpPXDul6T7yaSa3QDmO17PA7DX8bodwFkAXiAiAJgNoIuIOg2OlcIuoQbyyq8uQKFYnYqZZjeJjikLd9Z0iE5zSX5d92STzsqAOvDW3q5yLdmUFNt72lsV71h0XbgEF923Cgu+sRoX3beqRqyMul9Exc3TufX50QEKLcCOM7F3krx67t5J063/RBQI24gaJyoyCvGo2u5G1pX5Xz5wQU2HaQFg/OAQOjdu0XagNr0Hzv2SdD+ZVPMKgEVEdCoR5WEF0XbZbwoheoQQ04UQpwghTgGwCUBnOUuoC8D1RNRKRKcCWATg371OyIKlgfSdaJNuLw6Oa7p4mLY5BzDtjB3IjhsAIJAdN4BpZ+xIrSXJXeTNGZuie8+Jl7DRuZcGW3P4P51/iOFs9ZP9cJbwDzctA1Abv2KCys1z94a1eOl/fRo7v3IlXvpff4rOrS9gzcU31Ma25Fqx5uIbLCvM7D2RxJboFux6E8Vi7xaMd91wNVatuAZH2iZUbOJ2PIodfOsWOXZMkOzeuKWT+14l6X4y6UUIUQBwE4BnAGwH8KQQYisR3VO2ouiO3QrgSVgBuj8G8GdeGUIAu4QaStvEPvSdqH3KbpvYV7OtGdKqm60kv6zI27rla41TjL0aJarcToUMVQTQ1jPnRlpYTuUWmDLQi6kD1lxsq8uqK27CqitukpTgnwEguh5C/txY0fbIcY+74ezFuO7lzZGnBndduAS3P/UMppazfWzs2BK3Jcx5HICaOepSpN3HlDKE8ZwtxARACLEewHrXtjsV+17iev0lAF/yc76mbn6YdLp3LsSLmy6pcgvlsiNYesELWLig2/d4aRQxzYI7zRmwrCAyy0q9xgxiYVE18ZOxe9IMXPTfv4EoAmvD4E77BSwRESYzSTfud95/jlYQBGXnp1dJTd4lAAu+Ia3HFYq47hsjp97NDyfOmC9Ov+ovQ42x+ZG/4uaHjIUtSl751QXoO9GGtol9OO89mwKJFaA5rDBpxSTjx4lJ/RUvC4yOoN2ZZUGhAvKQ/kpwbQMrzALxZb2oxl322o5YOjAHqUQbxrLE2UJM2mDB0mAWLugOLFC8YAFTP/ykOeuKzslESz27L8tcDOMHhzDtxEDNvnsnTa9rhVkVcWW9+Bk3jHCwj517+FhNxpDO3RS2iJ3q+uYePoaXbl0dbYdthokAFixjCKeAYfGiJkjDQa80Zyd+rTFh5hUEd4l5qesg14o1H/hE8MDano5K76GwlWpVloljbRPw0q2rA7tuTC0eMuFw36PfxZe++T20lbcdbZuAu5dfWXN+97GE0ewve84ApNcR1kKiuj6Cf/HDMPWAs4TGKM2SfRQ1ptVn3ZimMgNqa8ysA71Yt3yt9FxB59W5cQteunU1dn56FV66dXWgaqayVNxVf3o1uq6ejc5tL/gev3PDG3jpzjux80vXWhlHv37Z6g3U06E/sKcD6D4N2HGm9W95f1nWy3Aui4kDg8qKryaYZtPIhEO+UES7owLt1L5+3Pfod2vOLzs2A0tM2G6nmiq/5esIa1mSXZ8TPxV8GaYehLKwENF1AO4GcDqA8+0ujEx6sEULW1wsglo//MSbqKwxBLV7yM+87PiVsC4DLzdHkPE7N27B6nVPV/oMOcv5d2Xfr7aylKvuVhoeFvLWa5i7sfzGZ5h2YDYVCPlCseb8XqJDZ0UJ233Z3VtIGqfExeSYBBHWJfQ6gGsA/FMEc2EaCAsXiyAl921M400eunGptjmiTIiYVMW1xdLeqdbCGsZlYCJGgox/+1PPVDVFBEbL+XedeYl6QgdnVXdnBqzXB2cBHT01bqydn5YHxfpdgE06MAcpt+917LG2CdL9neP8xco/Cd192b4+VXYYF5NjkkQol5AQYrsQ4o2oJsM0nmYrWOcXr+qzUeAsLKcqKuAWKLp5ud1FtrhQ9bcxWbRVYuTux79fcQEFGV+5AB8/pM82KihcF4rt9azm6uVa0Z1/zbWXYziXrdlv4sAgOjdu0V6H1FUXMCVZdg0lABvOHtsPMEyyqFvQbbnL40oA6JhT21OGSSYmoqWZrDIy64cqFiUMtjVm3fK1RsG6D924FJ+/98dV3ZmHcxk8dONSqbtowvAICoq+NyaLtrKAXF9/TXEzP+MfnThemnF0dFxbJdtI6oqacZrlBnKjEDm+mjyGxO06OtY2Ae0n+tHiuvXDuWzN+bsuXIK7HuvCtEL1PWktlnD7U894XoeJBcj0Gs5582188vlNlafYDIDrXt6MzYtO5sBbJhF4ChYi+imspkVu/loI8X9MTySEWAtgLWAVjjOeIZN4dKImbWImTO2TIPgSSO4ij+XXKndRpiTQn28JtGjrMkh0eI1fboJWuz1bAjp61K6oj01A17yPVLuFNCnVpvEncdDfmsf3zzsbf/zvv8bUsjhTZQkBwBSJgAMs0VjP61j22o4akzvXZWGShKdgEUJ8qB4TYZqTNKZSx1X7RJeW7CWQPvPIi8gXqwVLvijwuQefQ4kIGUnFantxC1LS3k8BOVH+cR6vGneywjoz+cQJAJq4mB/9K7r+v/N9pUJHZX3wQiayrnt5s7F7xit4tl7XwV2cmaTDdViY2OneubCqmu+4U/+jqXoKmeBVLM5LIKmsKB3HB6UiwrZ0yBY7Z6EygdFANlVgrVcBuT2OFFx7fFXArtfirF00O3oiaaYYFrcYmzA0HKoeypprL8e9j3wHrcVRd99QNhPafeW3mF3YrCOGiZuwac0fAfAPAGYA+CER/UoIwS0/mQrufkl9J9oxuP00/EHHXvxuQnPpZS8Liiot2X5fZ2HRpUK7KWRI+XQvK1TmxLnQGhWQc7iAnEJINa4uJkNXI0W2aMbV8FB2jrmHj6GYIWTKMUFOkafyb/uxTLhdZSrXmSlBUs7rGffDMEEImyX0r0KIeUKIViHELBYrjJtXfnVBVXNHACgUW/DKry5oqkwkr8JuyrTk8n5eBeFkhelUC2WmJPRpxcOabByoF1pdVoq9QM5T1POwx9WNcftTzyib/7kXTef57IJqX1v7BH75uXsCFceT4b6mXEkgg9ovTZ208JpL58YtuP/hJ5EvFKu22zVbgqJLOVcRZdYRw8RBcz3iMomj70Sb5/ZmqAHjVdhNZSEpZcioIJzTUjPrQC+KGUJWkgEE6E34Jk/9uuNV8RQmQsgrJkM1N0KtVUB2PruibFQl5U2uyUYW35Mpj6EtovfN70kzuYBwsSNB41HqFS/DMEHg0vxMrLRN7DPenmaLi1dhN1XpfpXocI9nu5tmHeiFgPW0r4tdUeEVjxDUBeC1EJqMq5rbHsl23fmiKikfRbCpbgwvQeTVpVnXEqGedWgYpl6wYGFi5bz3bEIuW/2lnMuO4Lz3bFIekxThsmzDdqxbvhbPXfpVZY8fG1Vht+NtrQCqi8WVCHhnZjvuveUy7J/pXajO6W4iyP9oBcxM+GuuvVzpShJAYBeAaiFUzUu24Jr27tGdzyYKsWG6uPfnW3C0XJnWzxi6OZp0adb1SfJzLxkmLbBLiImVhQu6AaAqS+i892yqbNdx6ewdDXMTeWX1uHnoxqX4/Jof1aQeTxgYwbIN2yuZQLJjveqwyNxNbgRQlamjouvCJbj78e9Li7/ZlowgHY5VAZsyAaQKCF214hqsWnGNUSCt7HxOglgSvvitp/GJf/sFsiWBYobw83cvwNTeE9JzlGC5gPY4OiqbBKw6A4VLjiBeJ0VSB00DZi0RGlmHhmHiggULEzsLF3QbCRQZjRItfpsgblh2Oj734HPIHx+s2p4vlLSNE03qsMySxL648bNA3738SuniuuHsxZ6ZJarMHD8LpG7Bvei+VUaLqr3PXY91YeqJgSr3WBBLwhe/9TRueH5TZZxcSWDp9rfw4un/DxYcOFyVJeR1babNIjMlIY19KWT0GUKm8Skcj8I0GyxYGEZCkCaIk3oHpdu9Gid61WEpKkrs28hSi3WiQSUuVELi/oefxANrn8CxtgmYODBYqRfiFjSmC6RuwdXNX/beOV+/K5L05k/82y9qhAMBWLr9LeyZNhl/vvJPPMf0un5VoLAbuyy/qn6OSs44RWs9Ur4Zpt6wYGESTyOsLKqsHl0TxCDHmCBzGwCWG2j/zHb83dUfBgBsvumLVdYGXe0N2eL6wNonpOexxZLMjRSkdLuuQ7HbwvPA2ifwtbVP4MjE8WgfGq6k/8rEkl+cLiAVJDlXUPzE1bj3ldXAceIWrX5rsDBMGuCgW4aRoMrq0TVBDHKMCQcUgbn7Z7bj+sdXArDiJ6a5XCOAv4yZoBkkfgNcVQGhQoiaBTkDSzRMOzFQU6skTDaQ7QKys628yrSFOZcdYOynFJz7d6HKKJIFNQepwcIwaYAFC5N4GhHDosrq0blughxjgk4I/X7XDM/0WFNBIRMSJvgVOqoCZaomgDqCZgPJXEBxnMuroN5wLouhbPXXsCwGR3VuO9jaaTnhnkBMs8IuIYZREFcTxCDzABSBubu8FyJTQeF8Qp9bHjNsd2Y37tiKv3DEhtz+1DNSV5GOoFYhnRtIBcHKoLKvN2iAMWAJDWeGkddYfvr8cE8gpllhwcIwEeE3FdoPOvGkWqAAa2H0IyjshVIVLzGcy6K3NY8pJwZ8B3N6xVZ4pSq7UYklk4BTr0BmGXY8y32PfhdCCGXwsZO5HpYRG6976KfPD/cEYpoVdgkxTER4NTiMizXXXo6S4r0jE8f7DrRUWQUKGcKtf/pRnPP1u7DgG6uNU5B14zpjK9yuIvc1DWUzONI2QdvnxqSoGgA89p/+SFlAz4lsn3yhWNVZ2X0dzrmozhGVG012/7knENOssIWFYSIiSCp0GH6/awYAa4E658238cnnN1U9gfTnW/DFT3T6HlflYtI1VfSic+MWpbXBeT5nxk+Q1FyTomoAcNcNVwNAVe0VGX7iXNz3zU8zRxP8ZENxDRamGWHBwiSaNDVEjCut2YS7brgamxedHEntjTAxEDKRAVguJpP6IU5MF93OjVtw9+PfxxRJ2rWNTITddcPVWPbaDt9xMyrc16GLLWIxwTD+YcHCMBHx0I1LPcvsx0lUT9VBYyCkMSqPPo3BlrxR/ZAgdG7cgvse/W5NyrMblSgyiZspodp3PpzLVsWwAPLr4OBXhokWjmFhmIiIK61Zhu0OioOgMRBSd0xhCFMG5C6xMM0Wnef0Eis6UeQVN9Ofb8G/fOCCqntx659+FLfdeJ3n/eEGhAwTLWxhYZgISUoqtJMgsSBBrDV+63zsmTY5tEVId05n6rDuPCZxM3cpjtPBDQgZJlpYsDCJJU3xK1GxbMN2bSNEv8jcNF9b+wTueqwLX/xEZ6SLp8oFcqKlFRlhWVtsorI06FK690ybbNTB2knUwaoc/Mow0cEuIYaJgWUbtmPd8rV47tKvYt3ytVi2YbvRMbfd/xPMPtCLjBit47Jsw/aa8dxpuipUDfemnRiQpvuGYc21l2M4l63ZPnFkCCUiHB7XjhIo0jRb1TmHshl2vTBMzBDRFUT0BhF1E1HN0wERfZaIfkNEvyKil4jojPL2U4hooLz9V0T0jybnYwsLw0RM0AJyqjoun3vwOYwbKlSNZ9rMTucyCdK4UEfXhUtw12NdmFaoLrFPANpGBpERAn/xX1ega9m7IzmffU4AVVlCRyaOj9x6xDBMNUSUBfAggEsB7AbwChF1CSG2OXZ7XAjxj+X9OwHcD+CK8ntvCSHe4+ecLFgYJmJ0BeR0gkVVr6Xj+KCyqaHXoqxzmQDh+svI4j10/YAmFIZw+4/+FV3L/LlpvGC3C8M0hPMBdAshdgIAEa0DcBWAimARQhx37D8R8lqMxrBLiEkkaY5fCVpAzm+9FhOx4dXQ0J1ia3cW3vnpVXjp1tVKl5GqouzRieNDz5lhmMQwnYhedfysdLw3F8Aux+vd5W1VENGfEdFbANYAuNnx1qlEtIWI/o2IjGo/sIWFYSImaAE5VR2XwXwWk3uHavY3qefhdpk4LTXuwFevXj9OVBVlB/Mt6M+3KOuacA0ShqkP2cESOroHww5zSAhxruI9WS3IGguKEOJBAA8S0XIAXwDwKQD7ALxLCHGYiM4B8DQRnemyyNTAFhaGiZiHblyKwdbqZwGTAnKqOi7/cNOymvH8ZNl0XbgE7/2HO/HnK/9EWzvEq9ePE5WlZHJfP1atuAaHJ46v+eYKmhlkavVJKmmfP8Mo2A1gvuP1PAB7NfuvA3A1AAghhoQQh8v/3wzgLQCneZ2QLSwMEzF2nEqQ9GRdHZfPPPIiZh7o1dbz0NVc8Yr1UIkQ2XZdFVf7PEHqv8iux9TqU29Mri/J82eYkLwCYBERnQpgD4DrASx37kBEi4QQb5Zf/hcAb5a3zwBwRAhRJKIFABYB2Ol1QhYsDBMDUReQs8fTVbgNuzj6KSVvUr4/imBY02aG9cb0Xid1/gwTFiFEgYhuAvAMgCyAR4UQW4noHgCvCiG6ANxERB8CMALgKCx3EABcDOAeIioAKAL4rBDiiNc5WbAwiSPNAbdx4lWOP+zi6KeHkN8qrkGtLX6sPvXE9F4ndf4MEwVCiPUA1ru23en4/58rjnsKwFN+z8eChWGahLCLo18R4qebclDLT1IbCJre66TOn2HSCAsWhmkSolgco6pp4rSolDKEXKk6BNdtjVBZYIJ2jo4b03ud1PkzTBrhLCGGSQEm3ZmT0h3YXaPFLVZsbGuEqqZL58YtgTtHx43pvY5z/px9xIw12MLCJAqOXwlOEroDd27cgvsfflIpUpzY1giveJB6VrI1jbXxc6/jmD9nHzFjERYsDNNENLJMvb2ImogVpzUiKYGpfkVAI+81Zx8xYxF2CTEMEwmyRdRJIUNSt4gqxqbegakqEXDXY111nYcJSRF5DFNP2MLCMAnHJH4lCegWy/58izJ2IymBqar5Tz0xUImnSQqcfcSMRdjCwiQGjl9JN6rFspAhbaBp14VL8J33n4NChiDK+3/n/efUXSCo5k+AtD1BI0lKgDXD1BMWLAzDRIJqEb3lv31MKz46N27BdS9vRq4kQLCyiq57eXPds17WXHt5bee2MklztSQ1e4ph4oRdQgyTYPy6g6Lo3xOUoFlKutgR1VhxXGfXhUtw9+Pfx9S+/pr3kuhqaWTQL8M0AhYsDNMk1CPV1UsoBFlEdbEjdGIAQPW1AIjtOu9efmVs8TSNFJMM0wywYGGYJiHuVNe4BJEqgJRcr+1rsf8ve89rHiaCC4i+lg3XTWGY8LBgYRIBB9yGJ+5U17gEkSxLSKBWsAD6a/G6TlPREIerheumMEx4WLAwTELxG78Sd6prXIJIZtWYMDSsjSUxvU6/PY1UhHXncN0UhgkPCxaGaRI2nL0YNzy/qcoyIcrboyBOQeS2aritIUB1LIlJnEnnxi2495HvoLVYAgBkPHoaqYjCncN1UxgmPJzWzDBNwrLXdtS4Uai8PQrqWftDl7ZrmtJ712NdFbGiw0s06Nw5pnDdFIYJD1tYmIbD8Su1BKluG7fbod7NFXWxJCZxJlPLGUY6TERDFPc1CY0pGSbtsGBhmCYhDreDLHbjovtWhZlmwxHlH1PRENV95bopDBOOUC4hIrqXiHYQ0WtE9K9ExA5ZhmkQUbsd7NiNeYePIYPR2I16V6ANytG2CcrtC76xGhfdt8pIQLA7h2GSQdgYlmcBnCWEOBvAbwHcEX5KDMMEIepy7VHEbjSSu5dfieFctmrbcC6Lu5df6WscLoPPMMkglEtICPETx8tNAD4abjrMWIPjV2oJ0505SrdD2lNxo4wbYXcOwzSeKGNY/hTAE6o3iWglgJUA0DFnfISnZRgmDpohFZeFBsM0D54uISL6KRG9Lvm5yrHPXwMoAHhMNY4QYq0Q4lwhxLkTp+SjmT3DMLHBsRsMwyQJTwuLEOJDuveJ6FMA/hjAMiGEqjs7wzAGhHEHRQ2n4jIMkyRCuYSI6AoAnwfwn4QQtXW0FUzJ9uOjk35Zef3d4+8NMw0mpXD8SvJhlwrDMEkhbAzL1wG0AniWiABgkxDis34HcYoXFSxqGMY/YXvgMAzDJIWwWUILo5qIF25RwwKGYfRE0QOHYRgmKaS2l9BHJ/2y8sMwzUDU8Stpr6PCMAzjpClK83M8DMPUkvY6KgzDME5Sa2FRwVaXdMABt/GjqpeSpjoqDMMwNk0nWGxYuDBpIo50Zq6jwjBMM9G0gsWGRQszVuEeOAzDNBNNEcPihS1aOL6FGWtwHRWGYeKiXIvtawCyAB4WQqx2vf9ZAH8GoAigD8BKIcS28nt3ALix/N7NQgjPbICmt7A4YTdRMuD4FYZhmHRDRFkADwL4zwDOAPBxIjrDtdvjQog/EEK8B8AaAPeXjz0DwPUAzgRwBYD/vzyeljElWGxYuDBJIknl+BmGYQw5H0C3EGKnEGIYwDoAVzl3EEIcd7ycCMBu33MVgHVCiCEhxO8AdJfH0zImBYsNixaGYRiGUTKdiF51/Kx0vDcXwC7H693lbVUQ0Z8R0VuwLCw3+znWzZiIYdHB8S0MwzBMs0GDI8i/sSfsMIeEEOeqTiHZVtMAWQjxIIAHiWg5gC8A+JTpsf+3vbsNseMswzj+v4xtIm1FoQVbEzRCKA01pFDyRVHBaOMLbUQKLSqCShGMVkSoGkixEqgGRBA/NNCAQrVUqxg02lpbUZHYxBq1SVqNBW2NGHwpGupbktsPZ4Inm82e2XN2d2az/x8sOXPO7MyzT3azV+a55z5TLekrLMNcJloY1q+cyeUgSYvUM8Cqoe2VwNEZ9r8X2Dzm5wIGlrMYWiRJGmkfsCbJ6iQXMiii3T28Q5I1Q5tvAX7TPN4N3JRkeZLVwBrg0VEnXPJLQtNxmUiSpHOrqhNJtgAPMLiteVdVHUxyB7C/qnYDW5JsBP4L/I3BchDNfvcBh4ATwAeq6uSocxpYZmBwkSRpelW1B9gz5bltQ49vneFztwPbZ3M+A0sLvrmi5oP1K5LUnjUss2Rx7vgsuJUkjcvAMiZDiyRJC8fAInXA5SBJmh0DywS8yiJJ0sIwsGhBWL8iSZqEgUWSJPWegWVCLgtptqxfkaTZM7BIkqTeM7Bo3lm/IkmalIFFWkAuB0nSeAwskiSp9wwskiSp9wwsE/LNEGdm/YokaS4YWKQFYv2KJI3PwCJJknrPwCJJknrPwDIB61fUlstBkjQZA4vmjQW3kqS5YmCRJEm9Z2CRJEm9Z2AZk/Urasv6FUmanIFF88L6FUnSXDKwSJKk3jOwSPPI5SBJmhsGFkmS1HsGljFYcDsz61ckSXPNwCJJknrPwCLNE+tXJGnuGFgkSVLvGVhmyfqVmVm/IkmaDxMFliSfSvLLJAeSPJjkirkamLSYuRwk6XyXZFOSJ5McSfKxaV7/SJJDTU74fpKXDb12sskOB5LsbnO+Sa+w7KiqdVW1HvgWsG3C40mSpJ5Lsgz4AvAmYC1wc5K1U3b7OXBtVa0DvgZ8Zui1f1bV+ubj+jbnnCiwVNXfhzYvAmqS42lxczlIkpaMDcCRqnqqqv4D3AvcMLxDVT1SVc81m3uBlZOccOIaliTbkzwNvIPz/AqL9SuSJAHwUuDpoe1nmufO5b3Ad4a2VyTZn2Rvks1tTpiqmS+KJHkIeMk0L22tqm8O7fdxYEVV3X6O49wC3NJsXg083maAS9ylwJ+7HsQi4Vy14zy151y14zy1c2VVXbJQJ0vyXQZ/N5NYAfxraHtnVe1sjn8jcF1Vva/Zfhewoao+OM1Y3glsAV5bVf9unruiqo4meQXwMPD6qvrtTIN5/qjRVtXGdl8XXwa+DUwbWJov8vQXur+qrm153CXLeWrPuWrHeWrPuWrHeWonyf6FPF9VbZrnUzwDrBraXgkcnbpTko3AVobCSjO+o82fTyX5AXANMGNgmfQuoTVDm9cDT0xyPEmStCjsA9YkWZ3kQuAm4Iy7fZJcA9wFXF9Vx4aef3GS5c3jS4FXAYdGnXDkFZYR7kxyJXAK+B3w/gmPJ0mSeq6qTiTZAjwALAN2VdXBJHcA+6tqN7ADuBjkBc7wAAAC90lEQVT4ahKA3zd3BF0F3JXkFIMLJ3dW1fwGlqp6+5ifunOS8y4hzlN7zlU7zlN7zlU7zlM75908VdUeYM+U57YNPZ62pKSqfgK8crbnG1l0K0mS1DVb80uSpN7rLLDY1r+dJDuSPNHM1TeSvKjrMfVRkhuTHExyKol3LExjVBttQZJdSY4lse3CCElWJXkkyeHmZ+/WrsfUR0lWJHk0yS+aefpk12NarDpbEkrywtOdcpN8CFhbVRbtTpHkjcDDTYHTpwGq6raOh9U7Sa5iUPx9F/DRqlrQWwj7rmmj/WvgDQxuR9wH3Nym0G0pSfIa4Djwpaq6uuvx9FmSy4HLq+qxJJcAPwM2+z11pgyqTS+qquNJLgB+DNxaVXs7Htqi09kVFtv6t1NVD1bViWZz4tbG56uqOlxVT3Y9jh4b2UZbUFU/BP7a9TgWg6r6Y1U91jz+B3CYmTudLkk1cLzZvKD58PfdGDqtYVlKbf3nyHs4s7Wx1NZs22hLrSV5OYPGXz/tdiT9lGRZkgPAMeB7VeU8jWFeA0uSh5I8Ps3HDQBVtbWqVgH3MGjbuySNmqdmn63ACQZztSS1mSedU6Z5zv/laWJJLgbuBz485cq5GlV1sqrWM7hCviGJy41jmLRx3Izmqq3/+W7UPCV5N/BWBu+1sGR/yczi+0lna9VGW5qNpibjfuCeqvp61+Ppu6p6tmlDvwnfT2/WurxLyLb+LSTZBNzGoLXxc6P2l85hZBttaTaaYtK7gcNV9dmux9NXSS47fXdnkhcAG/H33Vi6vEvofuCMtv5V9YdOBtNjSY4Ay4G/NE/t9W6qsyV5G/B54DLgWeBAVV3X7aj6Jcmbgc/x/zba2zseUu8k+QrwOgbvcvsn4PaqurvTQfVUklcDPwJ+xeDfcYBPNN1P1UiyDvgig5+75wH3VdUd3Y5qcbLTrSRJ6j073UqSpN4zsEiSpN4zsEiSpN4zsEiSpN4zsEiSpN4zsEiSpN4zsEiSpN4zsEiSpN77H5TCepKHltp8AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid = np.mgrid[-3:3:100j,-3:3:100j]\n",
    "grid_2d = grid.reshape(2, -1).T\n",
    "X, Y = grid\n",
    "prediction_probs = model.predict_proba(grid_2d, batch_size=32, verbose=0)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "contour = ax.contourf(X, Y, prediction_probs.reshape(100, 100))\n",
    "ax.scatter(X_test[Y_test==0, 0], X_test[Y_test==0, 1])\n",
    "ax.scatter(X_test[Y_test==1, 0], X_test[Y_test==1, 1], color='r')\n",
    "cbar = plt.colorbar(contour, ax=ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see in the graph above, the model is not able to fully capture the zig-zag pattern to fully separate the classes. \n",
    "We could potentially experiment adding more layers or additional input ($xy$ for instance)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion\n",
    "\n",
    "This was a trivial example of the use of keras on some test data. The real power comes when we start to consider [convolutional](https://en.wikipedia.org/wiki/Convolutional_neural_network) or [recurrent](https://en.wikipedia.org/wiki/Long_short-term_memory) neural networks. \n",
    "\n",
    "More on this on the next notebooks."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}