From 54ded7786348c3dda060d9fc202cbf3bf50f1c2c Mon Sep 17 00:00:00 2001 From: Roxane Date: Wed, 27 Jan 2016 11:57:54 +0100 Subject: [PATCH 01/13] add the beginning of comparison notebook for non parametric models --- ...n_sensorimotor_models_non_parametric.ipynb | 1210 +++++++++++++++++ 1 file changed, 1210 insertions(+) create mode 100644 notebook/comparison_sensorimotor_models_non_parametric.ipynb diff --git a/notebook/comparison_sensorimotor_models_non_parametric.ipynb b/notebook/comparison_sensorimotor_models_non_parametric.ipynb new file mode 100644 index 0000000..5a13509 --- /dev/null +++ b/notebook/comparison_sensorimotor_models_non_parametric.ipynb @@ -0,0 +1,1210 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Comparison between learning sensorimotor models \n", + "## Part 1 : non parametric models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, we compare the different sensorimotor models used in explauto in order to help the reader to use the most appropriate model depending on his aim. The notebook is split in two parts : non parametrics models (this notebook) and models based on gaussian mixtures (coming soon). There is also a tutorial explaining how to use the [SensorimotorModel abstract class](http://flowersteam.github.io/explauto/explauto.sensorimotormodel.html#explauto.sensorimotor_model.sensorimotor_model.SensorimotorModel) ([learning_sensorimotor_models](http://nbviewer.ipython.org/github/flowersteam/explauto/blob/master/notebook/learning_sensorimotor_models.ipynb)).\n", + "\n", + "As explained in the [Explauto introduction](http://flowersteam.github.io/explauto/about.html), an important challenge in Developmental Robotics is how robots can efficiently learn sensorimotor mappings by experience, i.e. the mappings between the motor actions they make and the sensory effects they produce. This can be a robot learning how arm movements make physical objects move, or how movements of a virtual vocal tract modulates vocalization sounds.\n", + "\n", + "Let's begin with defining a simple environment that will be used to test the sensorimotor models." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from explauto import Environment\n", + "environment = Environment.from_configuration('simple_arm', 'low_dimensional')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sensorimotor models introduction\n", + "\n", + "In Explauto, a sensorimotor model implements both the iterative learning process from sensorimotor experience, i.e. from the iterative collection of $(m, s)$ pairs by interaction with the environment, and the use of the resulting internal model to perform forward and inverse predictions (or any kind of general prediction between sensorimotor subspaces). \n", + "\n", + "Learning sensorimotor mappings involves machine learning algorithms, for which Explauto provides a unified interface through the [SensorimotorModel abstract class](http://flowersteam.github.io/explauto/explauto.sensorimotormodel.html#explauto.sensorimotor_model.sensorimotor_model.SensorimotorModel). \n", + "\n", + "Using the simple arm environment above, it allows to iteratively learn a sensorimotor model which will be able to:\n", + "* infer the position of the end-effector from a given motor command, what is called *forward prediction*,\n", + "* infer the motor command allowing to reach a particular end-effector position, what is called *inverse prediction*.\n", + "* update online from sensorimotor experience" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Decision tree\n", + "\n", + "In order to use the most appropriate model, there are several questions that have to be asked before using the following decision tree. The following paragraphs focus on these questions.\n", + "\n", + "*Add the decision tree*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Non parametric or gaussian mixture models ? \n", + "\n", + "Each of non parametric model is currently based on the nearest neigbhor look up. They are non paramtric models because they don't rely on assomptions that the data are drown from a given probability while gassian mixture models (GMM) assumes that the data points are generated from a mixture of a finite number of Gaussian distributions with unknown parameters. Thus, the last model can be used only with gaussian distributed data. Readers in this case should refer to the follwing tutorial : *coming soom* ." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Presentation of the different non parametric models\n", + "\n", + "Available non parametric sensorimotor models in Explauto can be accessed using: " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available sensorimotor models: ['LWLR-BFGS', 'nearest_neighbor', 'WNN', 'LWLR-CMAES']\n" + ] + } + ], + "source": [ + "from explauto.sensorimotor_model import sensorimotor_models\n", + "print 'Available sensorimotor models: {}'.format(sensorimotor_models.keys())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These 4 models are a combination of a forward and an inverse model:\n", + "* the **nearest neighbor** model searches the nearest point of a given input ($m$ or $s$) in the dataset and returns its corresponding value (respectively $s$ or $m$)\n", + "* the **WNN or weighted nearest neighbor** model searches the $k$ nearest points of a given input ($m$ or $s$) in the dataset and returns the average of the $k$ corresponding values (respectively $m$ or $s$)\n", + "* the **LWLR or The Locally Weigthed Linear Regression (LWLR)** offers two inverses model for the same forward one. The forward computes a linear regression of the $k$ nearest neighbors of $m$ and find the requested $s$ with the given $m$ based on that regression. Both inverse models are optimisation algorithm that minimize the error $e(m) = ||LWLR(m) - s_g||^2$ where $s_g$ is the goal, $LWLR$ is the forward model LWLR, and $m$ is the motor command to be infered.\n", + "\n", + "Let's see which of these 8 *(2 * 4)* possibilities is the best" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward or inverse model ?\n", + "\n", + "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward models comparison\n", + "For each model : \n", + "* Output descrptions\n", + "* Processing description\n", + "* When should it (or not) be used\n", + "* Time processing\n", + "* Distance between sg et s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#DRAFT bac a sable" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#import numpy as np\n", + "#import scipy as sp\n", + "from scipy import spatial\n", + "#from pylab import *\n", + "\n", + "#Environment definition\n", + "from explauto.environment.environment import Environment\n", + "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", + "\n", + "from explauto.sensorimotor_model import sensorimotor_models\n", + "from explauto import SensorimotorModel" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n", + "[ 0.31524469 -1.00946449 -0.99460699 0.04160849 0.24613563 -0.87940998\n", + " 0.90833414]\n" + ] + }, + { + "ename": "TypeError", + "evalue": "unhashable type: 'numpy.ndarray'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 18\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mm\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mtesting_m\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 19\u001b[0m \u001b[1;32mprint\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[0mtesting_couples\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompute_sensori_effect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 21\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 22\u001b[0m \u001b[0mdistance\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'numpy.ndarray'" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXl8FPd9//+cPaXVfaETJHGK0xhsThPwgTH4jjF2jC+c\n", + "OE2b9NfmaJv013aYb5tvv06T5vimTXPUkDh2Esf5gcEnjTHGjo1tMJgbBBJC97G6d6U95/fH7Ay7\n", + "q11pJQQS8Hk+HvuQduYzM5/VMa/5vE9JVVUEAoFAIEgE01hPQCAQCARXDkI0BAKBQJAwQjQEAoFA\n", + "kDBCNAQCgUCQMEI0BAKBQJAwQjQEAoFAkDBjKhqSJD0rSVKzJElHBhnzI0mSKiVJ+lSSpOsv5/wE\n", + "AoFAEMlYrzS2AHfE2ylJ0jpgqqqq04AvAj+5XBMTCAQCwUDGVDRUVX0X6BhkyD3AL0NjPwQyJUnK\n", + "vxxzEwgEAsFAxnqlMRTFQG3Y+zqgZIzmIhAIBNc84100AKSo96LuiUAgEIwRlrGewBDUAxPD3peE\n", + "tkUgSZIQEoFAIBgBqqpGP5gPyngXjR3AV4DfSpK0BOhUVbU51sDhfvBEkCRps6qqm0f7vJeSK23O\n", + "V9p8Qcz5cnClzReu2DkP+4F7TEVDkqTfACuBXEmSagEZsAKoqvpTVVVfkyRpnSRJZwAXsGnsZisQ\n", + "CASCMRUNVVU/l8CYr1yOuQgEAoFgaK4ER/hYsmesJzAC9oz1BIbJnrGewAjYM9YTGAF7xnoCw2TP\n", + "WE9gBOwZ6wlcDqSroQmTJEnqpfBpCAQ6kiRtBcpi7DqnquqTl3UyAsEoMZJ753h3hAsE44UyNP+b\n", + "QHBNI8xTAoFAIEgYsdIQCBLAYrHY/X5/3P3CfCW4VhCiIbimSeRmryjKA4WFhTfU1tbGGGZQhjBf\n", + "Ca4BhGgIrmoSEIUyBrnZK4ryb8A3TKYr35IrVkOC0UCIhmBUuRQ3pos8ZxkXtwL4CoDf7/8ErYBm\n", + "UtT+CkmSttpsNofX672IywyfEfxcyhCrIcFFIkRDMNqUMfo3pktxzkTZD9z09NNPK5s3b/5ajHlk\n", + "zJ8//4b29vaK8+fPj9pFhxKE0P77gIxRu6hAkABCNASCwXkbuAlYFWvnnDlzuO+++2Zv2bJltK9b\n", + "xuBCWcboCcZ8SZL2RG0TJitBTIRoCIDLa+8ewbUqYp2nsLDwM4899ljl1KlTfwS8LsvymVGb5AX2\n", + "AP8I3Ax0he8oLy/n/vvvByAYDB4CColjvor3M1QUxQJ8GbgeyAcKgPzS0tLCmpqaWIfMN5lMe+x2\n", + "+0KPxzNgp8lkIhgMRmwL+3nPj/MZM7jIlZzwl1w7CNEQ6JRx+UxAw71W9I0YAJvNJk2dOnUq8CPA\n", + "oyjKPbIs7xrmXM6ZzWZrZmbmxNTU1IkAjY2NH3u93nOh/R8AXuC6lJSU910uFwD5+fk8/PDDmM1m\n", + "jh07xq233jpx69atFgY+/WcA94We5CNuoIqiJAO/RetQmRAmkymjsLBwZVtbW8z9EydOZN26dQsU\n", + "Rfl74HlZlmsY2e+2IsbqA4S/5JpHiIZgUCZOnLhUUZTTQG/oVQ18U5blxljj7XZ7aqwn4AQJN5MM\n", + "+YTa2NjI7t27K2+55ZbTwJ3Ay4qi3C3L8h/Dhp3Tv0lPTy/MysqaDqhWq7VcUZQnN2/e3I72BO7Y\n", + "tm0bTU1NTp/P1w+Upaamvrdu3brJs2fPtgFMmDAhubq6moyMDB599FHsdjtHjx7l448/ZtOmTTmS\n", + "JBGrLI/FYsnw+/0RN1RFUbLQSv/fBLRv3bq1ua+vL99ms6WZTCZrU1NTzM8cDAaprx/QUsZAVVXy\n", + "8/PTgG+jrWCK442NtSoJI4lBRCDGyiLeKkZwlSFEQzAoJpPJBkwL27QCuElRlNWyLFdFjy8oKEgC\n", + "8Pv97sbGxoPBYFDPiDuXwOXCzSThJql+YtjvvV4ve/fubbjlllvuAX4CfBHYoSjKXbIs7waIerJP\n", + "ArYCDwKTgHBHxHsnT550eDyeBcCK2bNns3btWlJTUwkEAqrZbFaqq6vLHQ5H35NPPnl9Wlqao7q6\n", + "mh07djBz5kxcLldMwQAoLi7mwQcfpLm5eZaiKJuAXcCbwGy0kv9mVVVnNjfHbBUzLM6fPx948803\n", + "31uzZs1Kv99fEBLhmDf0wUQjOTnZ0tfXF2uXLuwVaOY0AMxmM4FA4GKnL7gCEKIhGJS6uroP0PqY\n", + "pALpwHeAG4A/KYpyuyzLR8LHb9q0aQPwFpptPhO4M2QiGS7hJqmThN2gopFlOagoyp+jlcX5AvCK\n", + "oihrZVl+ByKfinNycibn5eVJU6ZMYfr06WRkaFq0bdu2m1RVVTMzM7nzzjuZNk3TyfPnz7Nr165D\n", + "tbW1iizLKIryIPAiwPHjxw2/xtmzZ+N+kEAgQGpqKqmpqXnAs4CPUN8YIAXA7/f3AcnRx0qShCRJ\n", + "g60Iomlbs2bNBqDZ4/GYGGS1EC/DfdKkSUiSlBLHp6ILu6EQpaWlBAIB6urqEp2j4Armys9YElxS\n", + "AoGAV5blU7IsH5Bl+W3gFrSIogJgr6Ioy8LHy7J8HFgCHEd7kt6nKMrC4V7X4XBYFUUxDzXOZrM5\n", + "QtcNAn+GtnpIBl5TFOWu0LAytBvdSqfTOfHkyZPSq6++yu9+97setBs4XV1dLFy4UPqLv/gLpk2b\n", + "Rn9/Pzt37mTr1q1YrdbrFUXpVhTlU7Qw19cB7rzzTlatWgVAPHMSQH19Pb/85S/DzUpW/ZpAG7Ct\n", + "p6cn5h1XVVXM5sF/DBkZGRQUFOhvTxISIp/PN+hx8ZAkCa/XO9TBZoCKigoef/zxIecoSdJWSZL2\n", + "xHhtHdEkBWOGEA2BzjngnRivc+GDZFnuAdYB29FWEv+jKMqaqDE1wHIixeWusCHGtSRJivkInZeX\n", + "5wBOKorymCRJNZmZmb2lpaUUFRUFgS6LxeJLSUkhLy/PKOscEo6ngV8CDmCnoii/z8rKssW6htPp\n", + "TNuyZYt127Zt7rVr1wbXrFmDzWbj6NGj/PjHP+bAgQNMnDiRJ554AiANmAc8Aqytra0N+v1+CgsL\n", + "Aejv79dP2wV02Ww2srKyKC4uxuFwUF1dHbEaaWlp4fXXXw8CucD9WVlZ4SZAg8LCQoqKimLtMsjM\n", + "zORLX/oSX/3qV1m/fv00YA1ooiFJEiaTCZPJhM1mQ5KGroJdU1PT3djY6B5qXEZGBvfeey9mszlc\n", + "oLqI/fdTRki4o15lQ05IMK4Q/TQEIyIUKvozYNO2bduCp06d+rS/v787tLsCzbzUP2HCBJKTk/MB\n", + "uru7d7W3t68JO8eSZ5999oNYSXElJSV84Qtf0N9WAZND339TluVnFEX5R+B/Ad+WZfkfwo81m82/\n", + "XLVq1fKlS5eWW61Wk8fj4e233+ajjz6KMPOYTCZWr17N4sWLMZlMdHZ28uqrr1JZWRkxj6eeeoqh\n", + "yoioqkp7e3uvz+fryczMzEpKSjLMa7/4xS/Uuro66dZbb2XFihXGMb29vZ7U1NTHgcJnn332++fP\n", + "nx/wN1xaWkpmZiadnZ309/cTy+9hNpuZMWMGGzZsiNju8/lQVZXnn3+eWKamlJQU9Giw4SJJEk88\n", + "8QRlZWWcOnWK3/zmN/quAFrAhE6/1WrtCwQCE4LBoCPGqd5RVXXViCYhuGhEPw3BZUOWZb+iKJ8H\n", + "+js7O/+8v7//+hjDMlpaWow3BQUFNyiK8jggAUXA32VlZeFyuXA6nREHhkw3OpOB88CXZVl+JbRN\n", + "F6gBDvJgMFi6e/fuKfv372ft2rXMnDmTO+64g/nz5/PKK68YtveFCxeydOlSgsEg+/bt87z11lv2\n", + "aJNOS0uL+vLLL0t6PgbaTXGALUaSJHJyclLRfD8AfrT/L299ff2HwIrU1FRjfF9fH6mpqXbg58Av\n", + "MzMzA5IkRfw/BoNBr8VioaKiwjZt2jQsFgs/+9nPaGhoiLh2IBDg1KlTgZMnTwanTZtm1U1Fhw8f\n", + "Zvfu3bjdkYuGlJQU0tLS6OnpwW634/f7CQQCWK1W3TQV/fEGsHz5csrKyujp6eHll18GUNF+r2bC\n", + "fidFRUUZVqs1pmgNhsj7GL8I0RCMGFmWVUVR/trn8z3GhZtlXOx2ezaa6chg7dq1fW+++WZVZ2en\n", + "MxAIqABLly6dvHLlyolRh28LEwy4kGiXHu963d3d/O53v2P69OmsXbuWgoICPv/5z3PgwAHeeust\n", + "pkyZAsBrr73G/v37+wF79DkKCwul+++//xya8/t3wEFgGbAbiGn2AoJc+N9ylZeXp1ZVVZGWlqbt\n", + "DAax2+00NjZSWFiYHggE/nLq1KnMmzcPv9+vWiyWvwN+JctysyRJW8+ePVtWWFjouO+++260Wq0x\n", + "L1hcXGyuqKgwq6rKkSNH+Oijj8jKymLt2rV8+OGH9Pb2oqoqnZ2duFyumCuMoqIi7r77bn784x/H\n", + "+5Ea426++WYAduzYQVZWFmazWe3p6Yl4YpUkidLS0kFDhAehDJH3MS4R5inBRWOz2T70+XyLhhpX\n", + "XFzsevrpp7eh+USyufB0CtCI5sTORQudBS0n5FvAC6H3N8qy/AmAoij3A/8f8B5wtyzLnfp1QiGh\n", + "ETccq9XKqlWrWLJkCWazGZfLhdVqxWaz8YMf/IDOzs5mNCcyxcXFCy0WS6rb7W72eDz7v/a1r90t\n", + "y7Lxj6IoigQ0oPlrdLrQnrCPA7OiP/vx48eZMGECubm5fPzxx9x4440A1NbWMnGipo+tra3k5eWB\n", + "Zo47BWShic8R4MDLL7/8aG1t7ZJYiX2lpaU88cQTfPTRRxQUFDBp0iTDpFZbW0tJSQlbt24d9Im/\n", + "tLSUNWvW8Oyzz8aMrJIkiblz57J69WpjpZKcnIzFYmHLli3U1NSQnp5Obm4uU6ZMYe7cuaSnpxv7\n", + "4hDTPBXrdzjYeMHIEOYpwZjg8/liBvRH43a7W4Evodm8vcB04AE053UF8PfhpwXmybLcqyjKYuCr\n", + "wC8URbkzlFioJxfeBDQrivIGWnb1zjhzZP/+/Rw8eJC77rqLsrIyQAs7DSUjnlRVdVXoWvsAJ1Am\n", + "y3J/+HlCgvE6FwTDjeZ0100yRcCHwOLQ+zq/318ya9YsI4+jvr6etra24Jo1a0wTJ06ktraW4uJi\n", + "8vLyUFUVSZImc8GHA1qI86Z7772XZ599NuJzFRQUUFFRwbx58zCZTCxZsgTQTFb9/f0kJSUxceJE\n", + "/H4/vb29DIXFYiE7O5twsyJAcnIyWVlZdHV18cc//pH777+ftLQ0VFWlv7+fO++8k4yMDOz2yMVa\n", + "e3s7nZ2dxCHAhczzCLOTJEmmq+GB9mpErDQEF80gT4URWK3W3qKiorc2bdp0b1dXV9/3v//9j/R9\n", + "s2bNcm/YsMEFrA87pB8tCe4t4O/Qspt9aGaiH6CF9D6JVkxQ//33nTlzpvfAgQN5lZWVEU/Mqamp\n", + "xo3z4YcfpqJCyx/ct2/fuTfeeOMdVVWfVBRlS+ic/ybL8t+Gz19RFBPwX2giB/B/gX8BfgHcPchH\n", + "DwKthOWa7N+/v62qqir3vvvuw2az0djYSG5uLrr5qa+vz7d3715/fX19ckFBAaWlpUydOtVwOFdU\n", + "VFBRUUFmZqZxEVVVqaqq4uzZsyxatIjMzEx6enrYt28fBw8eHODb0LHb7eTn55OVlcWCBQvYvXv3\n", + "kCuSTZs2xdzncrloa2ujqamJo0ePMkTjqnC6gEPAuc2bN//bz3/+8w/r6+tTBhkXjvBzjJCR3DuF\n", + "aAguGt1paTKZzEVFRTc0NDQkxUpGKyoqCj722GOB5ORkK0BHRwcnTpzgxIkT1NXVvSPL8h/Q6kgF\n", + "iR0O3oXmw9B/1++hicc+4LPAw2j+BgC8Xm+gurraWVNTk9fY2Cilp6ezfPly9u7d27J69eq0jIwM\n", + "PZnuBVmWNyqKkg3Uo0V+TQsvgBgSDD3rHLRQ0mmyLPtD+x8nyl8TRQeauclAVVV9ZYFegiT8K2j+\n", + "D1VVMZlMRpJfeCSX2+3m/PnzOJ1Oli1bxvbt29W1a9dKSUlJ1NXV8dvf/tYQyuTkZGJleScnJ3Pz\n", + "zTcbK4WsrCzsdjsvvPACsSLbSktLeeSRR/D7/fT399Pd3c3u3btpa2vD4/EMJxFxAKtXr65evnx5\n", + "4ZYtW5KG4TwXJqsRIsxTgoQY7ciU8GMyMzNftVqt62LVn7Jarabk5GRT6BiysrJYtmwZy5Ytw+12\n", + "LwPqgKPAnLDD3gJ6gNUMjJS6KfSqRROPdaExG4CHbTbbwhkzZkyYMWMGhPlP1q9fPyHqPFNCXx9H\n", + "E4xdMQTjp2jZ5jpfCBMMS2h+On7gLDAjbFuEYMCFbO/w9+FfgQGhviaTid7eXlJSUpAkCbvdrlZU\n", + "VBgH3HvvvZLJZKK6upr33nuPyZMnM3PmTCZNmsSuXbvo7Oyko6ODvr4+rFYrqampFBQUsGjRQJdU\n", + "vJwOVVWx2+3Y7XZSUlLIycnBZDLFFKRorFYrqqrG9JlYrVZaWlrKAcxm8xlJkppUVQ2vTTKf2OXg\n", + "o0u7i5XHJUSIxrVJGZcoMqWrqyuWSQHQSmWcPHnSU1FRkfnHP/6R2tpaZs6cycyZM8nMzLQCG0ND\n", + "9UdVE3Ar8H20suOL0IRhHZG1qSYC3wsEAt+tqqpq3bNnz3t1dXU3KIoyFXgIbQUSLkTRTAv5Kr4U\n", + "ev9f+o6QYPwCrZSKHkb7mizLb4Wq1KaFxt+PVkcqJTRGjyH+GfAEFyKzVEB65ZVXuOuuuwgEAuoz\n", + "zzzzXlJS0oyNGzfm5Ofnm4PBIFu3bsXtdvPkk08SHqpbVVVFZWUla9Zo6S5ms1m/swcAsy4y5eXl\n", + "lJeXR3zIe++9F5/Ph81mIxAIYLFo//6BQIDq6mpqa2txOBzccMMNBAIBBis8ef78eZqbm2loaOCu\n", + "u+6KO27ixIncdtttWK1WMjIy2LVrFydPnowpGj6fj9bW1uAPf/jDP3Z0dNi5kO8DIEmSlKZnyDsc\n", + "Dvr7+/Wkwosu7S5IHGGeuga5lJEpVqv1A7/fvyTWvtLSUm699VYmTZrEiy++yPHjx419mZmZgYyM\n", + "DBMXTE/6dr1nRR3web30uaIok3fv3v1GSUnJtMmTJxs3QEA37+xEu9nvlWW5U1GU2WgCsgkoiTG9\n", + "02iO+QagNJSHYg6d40nAE5qbDc0sVojmrNbn6/7Rj370p+Tk5OUWi8Uxffp03/Lly61nzpzpP3Lk\n", + "SFKMPI+60Dx8wMTNmzf/LjU1deU3vvENAE6dOkVvby8LFy7E4/EY2dzBYJD+/n4cjlh5cqNLvKgn\n", + "SZIoKCjAZrNhMpl44okn+OlPf0pj48DCx9H+j2effTamySsM3WexUr/WpEmTmD9/PqWlpaSkpBjO\n", + "9kGisoS5KkGEeUow5uTk5EyLV621q6vrbGpqajlg6ujoiNjX2dnZ29nZOVgnuhLgTUVRqgAZeGnv\n", + "3r0NwDSLxUJZWRnXX389s2fP1sffHXqpiqIcBvaGXjcAvwJujzr/9NDXIqBGUZSzaKGzOaHt4WFB\n", + "N8WYnyMtLW21fhPzeDzW5cuXk52dndTR0RHkgrjoiYG6cFmBVyVJ6vP5fIbPIjc3lxkzZhAIBPD5\n", + "fNjtdsPXcbGCoaoqNTU1+Hw+zGYzFovF+JqUlGQUcczIyNCLFxrH1tfX4/f7sdls3HbbbUZEWKLl\n", + "8BMoY+LQrz1//nyuu+46srOzIwYEAgHcbndCSYiC0UeIhsBAkqSLrkVmNpsHJMiBFqEzceLESRkZ\n", + "GSrAvHnzuqxWa6okSWaA1tbW9FjRPYFAoJ+QiUIPR/V4PM999NFHv8zLywv09fXh9Xo5c+YMZ86c\n", + "obm5mVtuuQU0U9JxNBPHdaHXX4ZOG+6pjeV0Lwq9YnEY+AT4DNpKoxH4IdqT8Vp9UEtLC16vl+zs\n", + "bLxebzWa32R/6Ngvhp3PCyycP39+z2233Wb4MHJyNK0ym82GeSqRulGDEQwG+fTTT3nrrbfiht/q\n", + "K4M333wTp9Pprq+vdxQXF/OFL3wBSZLo6+tj27ZteDweI78EIC0tjfb29gHn8/v9uN1uY3UwmJPc\n", + "arUyc+ZM04IFC5aWlpYan7erq4tPP/2UY8eO0dnZmYhAzR+sW6Lg4hCiITDIycmZMvSoweno6DhD\n", + "jP4N2dnZnQ888IARH7p06dKMpUuXngBeARZv2bLlM7FMDWaz2ajhpN9E7HY7K1asMJ07d87U2tpq\n", + "RPN4vV4sFgsejwe73W5B82NUoj295oS+QqRIDFco54VexhSB24AjPT09s9H6dBAMBmlsbKS0tJQp\n", + "U6boORcNaMJ1BC1KTAJsgUAgePfdd6fFq2/lcrm8SUlJNr08SE9Pj5EjMRwheffdd6mqqjIEKT09\n", + "HavVGhGRpYfwhnwmnS+88IKlra3N5vF4SEpKIjk5mUceeWRAKG146K9OIBAgJycnYmUU6zOazWZu\n", + "vfVWFi5ciN1uNwNmn8/HyZMnOXjwINXV1XF7lcQhAygTpUguDUI0rk3Ohb+x2+2pBQUFCzIzM4tC\n", + "DYxeiXNcXBRFyQOW5uXlmVVV9YaaNxmkpqaa0UpxZAIL0W7iM0Ovjv7+/lYgL/q8wWDQg2YaCs8e\n", + "B+Cxxx6jp6eHzs5OI5onChOREUyXggloonFb9NN2XV0dpaWl4ZV47wE60aq/niLkzDebzQPupE6n\n", + "kz179pCenk5BQYE5zOxmlCMZ7spj5cqVrFw5LH9x0SOPPAJg3LRdLhcOhyNilQEYvdIHE7JYpdrt\n", + "djsbNmwwSrqE6oCxd+/e8MrBI0EPlBAO8lFGiMZVymBPWZs3b/4ntL4Qs4EzwDG0UuZ/DzyrKMpc\n", + "WZbjtpELhZjOBZaGvaYAPPXUU9HD9Zt9GloobCyyworCRmAymYyooyNHjvQEg8H0OXPmGP0b0tLS\n", + "jJvoWBB6Sm9Ec4xHoBdGDJUG0UkG7oh1rvAbblJSEvfff7/+ZG6ONWYYeIlfJ8vg7Nmz+P1+ZsyY\n", + "QTAY5MyZM0ycOJHk5GTjmikpcYPjAKMXBwA2mw2/38/OnTuNrPDW1lajY2BaWhobN26koKCA3t5e\n", + "I5quubmZ/Px8GhsbkSTJKKg4TPLRStIIRhkhGlcvZcR4yioqKlqAFgIaiwDa0/5+RVF+gCYmx9Ai\n", + "hxZzQSBuJNToJww38DHwQeg1Aa2Cazeab2EpWn+Nw8DU0GsyoYZEscwbUdtNc+fOjVucMDR3D9rf\n", + "tBUt/NWLZqqI1yHox2irmKeBzq1btzb19/dPyMvLy87Pzyc3N5eSkpKIkFf9iVu/iYZu6oUAN954\n", + "Y19mZqavq6srPdycMmFCdFpIbMLFIPrm7Pf7sVgsxphhisdggmH4dLq7u3nnnXeYMWMGJpOJ48eP\n", + "D1hR6Gzbti2iPIjJZGLjxo1YLBZefPHFiFVFa2vrgGz0vLw8Nm7cSGZmJk6nk1//+tc8+OCDANxz\n", + "zz2YTCbOnj3L1KlT2b59O4cOaUngen+QREQkOzvbHMvPwsC8DhAmq4QRIbdXKfHCakOOTjda/aT3\n", + "gXK0FcdstBt9olRxQSA+AA7ryW5g1GjaAdwF/A9a8psXmK63fw2FtM5B69s9H815fRBtVVJOVNXZ\n", + "o0ePoqoqc+fOJRAI0NHRQWpqKvFWKQmi145Sa2pqOlpaWrLdbjd9fX243W7cbjcTJkzg9ttvp6+v\n", + "j+TkZOrr6zlw4AC33377YNfuQqv8O2T3wfFCdLb5YMQKd33qqaeYNGkSzz33XETDKbvdHuG8Li0t\n", + "5eGHHyY5OZmmpiZ27NgBwOc//3kj8x2gt7eX1NRUOjo6MJlMhglyqMKLoK1yCgsLh1OSvQvYfq0J\n", + "hwi5FQxJW1vbUWCRLMsD0ncVRckF/hytuZGKtkqwoj2JfogmDvuAD2RZbok+PpxQ2fQvo9WFWg28\n", + "C6z41a9+9dbmzZsjWpuazebuhx9+uHKa1pj7RjQz2TNoT/DXoxUh7D906FCTw+EomTt3rqWnp4ed\n", + "O3fS19fXcs899/hLSkqK0Krh/gjNLJET9pqClqMhoT1ZB7jQo1v30kqlpaXZpaWlcT9TX18fPp+P\n", + "4uJijh8/zh/+8Ac2btwYb/hg4cPDRU8qvKSYTCa8Xq/RVyN8NaN/HwgE4rZ21SOjwldm0cyaNYvP\n", + "fvazWCwWTpw4wSeffMJDDz1khPmGP8Tq58nKikymT6RMSXRyos1mo6SkBKfTGd2rRScDuE9EXQ2N\n", + "EI1rDJfL5YwlGACyLLcB/6woSgrwN0Te+OYCzWg+EOPxOpQxfQNa5nY62pO1/rIAn6L5S1YABAKB\n", + "KVwo20FoG2+99Vb7tGnTKoFpwP8G/hrNYa/foWyPPvroqtC5ns/MzGTTpk39aKsjN5oYPAT8syzL\n", + "H0Z/NkVRPga+hyaA+uP0c2gmrYcJ6wfS0NBAfX29ES2kl9rIzs42TDI333yzntDmKywsjG5yMegq\n", + "o7u7m/T0dOrr68nPz8diseByuUhJSSEQCKhhWd46p7lQbj2m/2Q0cLlcAVVVzTabZs0KFw5dPOIJ\n", + "RlFREWVlZXg8Hk6dOoXD4SA1NZW2tjaSkpLIyclh0aJFXHfddUiSRHd3N6WlpcycOTPiPLoPQ89N\n", + "MZlM+sMBPp8Pn88XM7Q3mgkTJvDwww/j8XiM36EkSWzZsiWeaEAo6irBH9c1ixANwQBkWf6moijP\n", + "ALegrRLWoP0zbQi9UBSlHi0SqIgYdZWGS6hBU3gW1wQizWUmNP/KW2Hb/oRmwgpPtvs5IYEKR5bl\n", + "fw8lBv6BC6LxCFqV2inAA++///6PFi1aZCkqKsJisfD73/+e1tZWkpKS+PrXv47VaiUzMxOfz6da\n", + "rVbpoYce4siRI1a9T3gYcVcZx44dU202m6SHu1osFk6dOkWoPlZ4WZDw/JHw/hzDEoxo30e0Tyac\n", + "lJSUCEXQa1zFOk80ehvbQ4cOsXTpUkpKSpgyZUrc49LTNfeUz+fDZDJFiJHFYonI8L/rrruMMu/6\n", + "jX+oNrU2m81YvQwXEao7OMKncZUymn/4If/EMuDLwM1ENh/SaUC7qbegmbb0F6GvKcCiLVu2TIpl\n", + "Zx6s3HYCuNBMOPpdYhfwZKjvRvRn+RwXmjrpNAPbtmzZ8qX+/n4efPBBcnNz8fl8vPbaa7S3t7Np\n", + "06YGIhOOqWw5AAAgAElEQVT+9Jt6G5FROn1oEVIx2bVrV/Xtt99e7vV6sdls+Hw+9u7dy6233jrc\n", + "zzzqJOJc18eE+zRyc3P5yle+gt/v59VXX+Xee++NeawekeVyuSgqKiI/Pz96iNfj8ah+v9+akpIy\n", + "wLmiXzvcCd/Y2BgzM9xqtTJhwgTV6/VKwWBQDQQCrmAwmOxyucxpaWnYbLYBPUMALBbLPkmSTHGa\n", + "il115UlEafRrmNF+OgoJxQIulONYEDXkONrNNhvNdJWQBzVevaCLEI0WYjvwe4B/An4c7qAHUBTl\n", + "IbSGTZEH9PTw7rvvBpxOp3nx4sXd06dPT4fI7noMIQpDoUdB6Ql6e/bsYd68edGlMl5CM9NdN9Lr\n", + "RDOEkztm33PQVgJWqzXCl3H69GkjO9tisXDLLbdQXFxsrAbCcbvdWCwWQyADgYAxxuPxcOTIERoa\n", + "GrjnnnsS/RxqR0eH2tbWZvJ6vbzxxhtxVx1ms7k/EAgMiFTQ/Vbx/g7j7UOIBiDMU1cTZVxEIpOi\n", + "KJloCVEVaOGxdxH5ZN2H9gS/E3hVluWmqGNvQUtyy0V7CtdfgfD3LpfrTmKbWFTgDbRidfp4C5pp\n", + "LFqwwslB80msQTM32QE+/PDDtOPHj3/f7/d/+5lnnjnd19dXiOaL6QdOfutb3/Lb7XbLSy+9dH79\n", + "+vUlgCktLY1169bpN89HgX8FZoeHnW7bti1Zf8pdunQpFRUVOJ3OYG1trWn+/AGJ8AOwWCxGjoLH\n", + "42HGjBlkZ2dHP+V/luFnqg/KEFFRcSO8/H4/VqvVON7j8WC1Wo1kvnAxSkpKwuv10tTURHt7O/Pn\n", + "z4/I8bBarVitVpxOJ3/60584evSoUWrl9OnTpKWlEW7qi7XyaWlpUU+dOmUqLCxk7ty5HD16FEmS\n", + "aGhooLu7O2JsLMHQP0O8Mip+v3+w7HNRgh2x0rhqiBdim5ub2/CVr3zl79Cin6rQCuVVhL1mhr4O\n", + "sBWgNSR6BU0odsdzoA9znlsJrYgkSTLl5ORMTUlJKQyrZnsSuEeW5Ur9GEVR3iV2kUCdAFq01cto\n", + "PcXv6+rq4oc//GHcSJunn36a4uJinn/++UMbN268B83x/hUicxqq0HJJfGjRVuq+ffukN954A9Ds\n", + "5n/+539OVlbWSJPuhuRSnXcs6OrqIiMjA1VVef311/noI61xY/QqMxAIsHPnTtLS0rj11lv1nIwB\n", + "AQLh/pkh+pBfKq74MF2x0hAMICUlpQgtSggGMUOgrSROhl5H0Z76D8qyPKpPFbH+wRRFmYTmoL4B\n", + "TcBOKYryArBJlmUfWiHAh9GSEmOJhxktTPfv0aK72jMyMrIXLFjA/v37Y87D6XRSXFxMfn5+Llot\n", + "qT1oOSLPhQ3Ta0bpPzNpyZIlZGRksGPHDvr6+vif//kfNmzYEH5jjy53opuzGoCi8O58TU1NgcLC\n", + "QnMss45OvNDXK5Hdu3czffp0Zs+ezbp16+ju7qavr4+MjAy9Xhh6v4z77rvPOC5kFhvwocO7G15M\n", + "t8ChMJvN8ZIJr8loK7HSuEqIt9LIysqq/qu/+qvDwBK01UQTF8Qh/FUry/Kl+89LAEVR7kZrmapH\n", + "Y7nR8i7q0UxUC9GSEBNKmAsGg/zpT3/i8OHDtLa2RuxbtWoVq1at4vDhw8ybNy/OGQai39w6OzvZ\n", + "vn07t99+O0VFAwriniKy5tWAullR6MISr81tBGMlHInkaiRKf38/Xq+XlJSUAedSVRWPx0N3d7fR\n", + "gjbWPLq7u/nZz35Gb2/vgATC0WDSpEksXbrU98EHH1gH6QFyRfs5hCP8Gmaoxkohx3ayLMsD64+P\n", + "AxRFSUfLCl+IVtZjZpyhKprIHUEztd1AjDIZ0Y7faPPF3LlzeeCBBzh37hxlZWUJz/P3v/+9EVKq\n", + "37w6Ojowm81GGOkg6KLgQhO+8OWFbgKLyVgIxWiIQ/jKKhgMYjab436WwT5jMBjk5MmTHD9+nFmz\n", + "ZjFr1ixaW1v5j//4DyB+/3M9wCBWbofNZiM9PZ2MjAwyMjKM79PT08nOzjaSCocwfTWrqhormvCK\n", + "QJinrm3ODbY9ZGYaF4KhKEo2Wqb3Ai6sIKYleLiElsVtBV5Dc1b/B6GS5DomkyniJvT4449z+vRp\n", + "jhw5wunTp3E6tW6soRv9b0LnmxV6udDatSajmSAMUert7WXLli08+uijRjvVnp4eTp8+zW233TbU\n", + "3HUVS0YzFYaTkGBcTvGItQIY7rXD+56Hny8QCOD1evF6vYbYer3eWJWKAe33OWXKFKNtLGiNmr74\n", + "xS+SnZ3N66+/HlELSyczM9PYPmXKFMrLy8nJySE9PZ3k5BEHwYWTG+YcL0HryBjNVeUwFysNwWVF\n", + "UZR/A74RY5cXbfXwSeh1IPR+NVqfbf1pbrCSGh6gFpjicrmk8KJ/4Tc8r9dLbW0tU6ZMMUJggRPA\n", + "NjS/yK/Q+oU/DXydMEHatm0bycnJ3H777UbZDZvNFjPcdCj0sFu4ENqaKCMVj+rqapKSkkhPTx+y\n", + "Yi0MXG0MlhyYCJdK9ILBoOEPef/997nhhhuw2Wy0tbVhsViMwpfhOR6qqhIIBIxOhFOnTqW7u5uu\n", + "ri48Hg9dXV14vV6je2ICdBE7sXPcmrCEeUowrlEU5WZgN9pTtt7F7kDo6zFZlmP271QUxY4WFfUt\n", + "tKd+J1qehZcLq5UB9dEv4gbVghY6HO1fSMjnEGJU60VditWG3++nvb2dtrY20tPTKSmJ1Tp9+PPT\n", + "CQaDdHV1GWaeoeYdK3s9OhDA7XbT09NDfn4+Ho+Ht99+G1VVWbvWaJpIc3MzeXl5EeZJt9tNVVUV\n", + "r7/++pDZ5EOhzykam80WrwWtEI3RQpKkO4AfoNl3f6Gq6jNR+1ehhVFWhTb9QVXVf4lxHiEa4xxF\n", + "UWxodagqgH+SZfmfR3COmcBPuVAm5HXgL4DzwFeB7wIdaEK0gMiyJMBF33APogUTxGsFOypcShPU\n", + "hx9+SGVlJU6nk87OTlRVpbS0lCeeeGJALkf4PPx+Px6PZ9DVicvloqamhrq6Ourq6mhsbKSoqChm\n", + "0qaqqni9XjweD8FgMG5p/HBOnTrFu+++S2trK9/61rdQVZVXXnmFOXPmUFpaGjH/YDCI1+slKSmJ\n", + "9vZ26uvrycrK4o033jD6nIyUeNFUgzjjx21o7hXl0wj1hv4xWkJYPfCxJEk7VFU9ETX0HVVVE0sX\n", + "FYxnvoomGJXAv43kBLIsn1AUZRXweeA7aKG4xwhlfqOVOSlHqz/1xvbt218qKSmZkZ+fn5abm5ue\n", + "lJRkvsib8fUXc3Asos1SwylPPhKOHz8e4dRNTU1l/fr1Ma8ZvrKJrgcVi3fffZd9+/YlNA9JkiK6\n", + "Lfp8PiRJGnCNMPMhM2bMYMaMGREmsrvvvtsY297ezrlz51iwQMsF1c2F2dnZhkP8Yh37gJEhH43H\n", + "44kX0n5VheaOpSN8EXBGVdVzAJIk/Ra4F822HI5YQVzhKIpSinZjB/iKLMsj7uMZCgv+uaIoO9FW\n", + "qQ+hrTD+FtDjal8AzOGx/pcAPYz2OFqk14j+TnXB0PMMLqVgRGMymXjggQfQ29RGlTIxSFRoJ02a\n", + "lLBoRGO1Wgc0dtIJS/yMmI+qqrjdburq6khKSuLw4cN0d3ezYMECw08RTbzmTRaLBb/fH3OfLmb6\n", + "sYO0ob1ieqdcDGMpGsVoTkudOrTucOGowDJJkj5FW418Q1XV45dpfoLR4wdoEU8vyrK8azROGCpj\n", + "8rCiKI1o2dzhVXHNaP6HU2jRY9Vhr3PAZ4B/RiuiOFQORTz0Y8Ir0B5khKuRyy0WhYWF3HbbbZSX\n", + "l6OqalzBGA6TJl0IYDObzaxevZpZs2YNckQknZ2dg2Z19/b2cubMGTo6OigsLGTq1KmkpKQYFYJL\n", + "S0sJBAIqINlsNoLBYERZ94aGhrglQsxmc1zRUFU1UUd4XH/H1cRYikYiP9lPgImqqrolSVoLbAem\n", + "xxooSdLmsLd7VFXdc9EzFFw0iqLchdaPvBf42iifuwjQDeZ6n4kONNFIBz4CnoqRtHggVCZ9O1rE\n", + "VRLx8ySGIwQRzcDDk+H0NqVjzR133EF2dnZEaKskSUaJj5HS19dHamoqOTk5uFwuHn744WHlv+zf\n", + "vz9mngVciNj66KOPaGtrA6ClpYXjx48zY8YMpkyZYpii9FIjgUDA6ALo8/l4+eWX6enpITc31zB3\n", + "hftsGhsHFEQeEeNdMEJ+4lUXdY6x+pCSJC0BNquqekfo/beAYLQzPOqYamChqqrtUduFI3wcoijK\n", + "VLQih+XA12RZ/v4onltCC5G9Fy1f4yHgVbRVhJ5j4UDLKP/rWOVQFEV5CXiAC+VVXiTULySM40Su\n", + "JkDzyySUVxIr6mm0Hd2xzDqpqalMmTLFsO+PFvES/urr6ykuLubjjz9m2rRpZGZm4na72b9/P5/5\n", + "zGcSOvclqIBMS0sL//3f/43H4yEnJ4fHH3+c9PT0AT//9957j8OHD8cslz5KjMsIqivKEY4WcjlN\n", + "kqQytLo8DwGfCx8gSVI+0KKqqipJ0iI0kRu6bZdgzFAUJQntRvwFLjzRHAH+7yhf6kE0wegBviTL\n", + "cq+iKOvQ+pLfgtYgygr8P2irj80xzvGXaIEY+iP2aTTByQkbUxHjuFbgDuBtopIKo5EkaUAORyAQ\n", + "GNKpPBw6OztxOp2Ul5cbr+gWqaOBngcRi+LiYgBuvPFGY5vD4UhYMBK9/nDE9uTJk/zud78znv77\n", + "+vr44IMPSE1NZc6cOTQ3N2O32ykuLuamm26isrJyiDPGJiMjA7fbHW3CUoG9Ye/Pjejk45CxDrld\n", + "y4WQ2/9WVfVfJUn6MwBVVX8qSdKX0XpW+9Gymb+mquoAT5tYaYw9iqLMQxOKR4msHfUiIMuyHLd4\n", + "zwiulYu2AshDE4yfhu1LRjM73Y4mKClouRV/LcvyD2Oc62m05EHQQnf/Jex9PIJoyYYK2t/nkOg3\n", + "vL6+vtHKRDaI9fQfDAbjOoPHK0OtNM6dO0dTUxNOp5P29nb8fj92u52lS5ca2fk6n376Kdu3b8dq\n", + "tTJt2jRmzpzJtGnTYmacP//88zidTsOMGAwG6enpSdjUlJKSgsPhGFDfDE049DL/Ou1oZXB0xjRb\n", + "/IrL0xgthGiMDaFVxWNoYhHe6ewAWtjrb2VZjtuQ+SKu+xyaOL0D3BLtswjN6yXgTrSSIHpywSZZ\n", + "lrdGjTWhrRj0R+Kb0VrKRjsgutH8JDrfRROuZweba1QDpyu6Su2l5vz583R3d+PxePD5fHg8Hrxe\n", + "L1arlVWrVkWMVVUVp9NJamrqgEz8c+fOcfjwYSoqKpg8eXLEqq6pqQmz2Uxe3gX3UzyxSk5ONsqd\n", + "DMZFOr/HtHaVEA3BJSFWV0C73Z46ZcqUKRs2bNCzsrqAXwP/LcvywUs1l5AJ6lW0yrDzZFk+E2ec\n", + "DW2Vcy9a46UktCe+9bIsb4saOwMt38MMvIlWQ2h21CmjS0T0oiUW/mqw+b733nvcdJNWzV0vOTLa\n", + "7N27lxMnThhhu7ooFRUVJdwRbxQZaTTakASDQdxurXyaw+GIG1gQ7Uc6f/48J0+e5OTJk3R0dAzw\n", + "kQy2wlm/fj2HDx+moaGBM2fOGMl7elTWKJRk71JVdejMxkuEEA3BJSFeBd3QP18lWvjqS6PRpGko\n", + "FEU5i9bn4qeyLH9piLFWtJyN9WglR2yhr3fKsvzHqLH/jpaAqKI1dPpmjFN6CHUGDPEbovxw4eih\n", + "mnr4p36TG+0EvpE4kMf7imc05tfT00NXV5fRZtbv9xu5FvpN32Qy0dPTg9vtNsqqtLS04HQ6KSkp\n", + "ifj5RYfwwpAVcA2SkpLi5XdccaIhqtwKRozL5aoH5l+ucuuhiKk2NNH4M0VR8oCvy7J8LtZ4WZZ9\n", + "iqJ8Di2cVv9qA7YrinKbLMvh/rFvAn+GFnG1NM4UvESKxrrB5itJkrGyCBeJoZ6QvV4vTqczovXp\n", + "YMQrwRFv+2hHcamqiqqqoyqEozGvtLQ0oyDkcAkEAkaZFf1nFf759M+8aNEiPB4PTU1NA85htVqN\n", + "v4GhTFxXEmKlIRiSoXp1XM65hIoXfhX4BzRfRT9aWZL/E0+8FEUxA1vQ/C96eG0n8BlZlo+Ejfvf\n", + "aEUR1dC4y/JQpfel1rPD33nnHVasWDEu8jrGgnhi1tbWRkNDA83NzfT09HD33XdjtVqHrBDsdrs5\n", + "fPgwvb29Rv6Gz+cz+nvoL7vdTm5uLhMmTCArKyvmHILBID6fL8KhfpGtZgPAe4yRQ1yYpwSXhPEk\n", + "GjqKohSjmZE2hjbVopVc/32cnAwzWlTUU1yoVtsErND9IoqiZKCF3JoZaIrSGXWbfbizfLybjXT8\n", + "fj8mk2nYwub3+2lubjZCdGOZfOIRno+SlZVltIT95JNPhp2P4vP5aGlpoaGhgV27duHz+UhLSzPE\n", + "Qn9NmzaN3NxcCgsLcTgcA6LUPvnkE958883R6Bo4Jv9LQjQEl4TxKBo6iqIsR0vg0+8asizL/yvO\n", + "WBPwn2hmKP3mfw64SZbl+tCYF9FyQEbKiEqih4vFaHTMu9xcykKLaqj9a0tLC0VFRRHRUKqqcujQ\n", + "IaZOnUpaWlpEFNPFiG9LSwter5eioqKIz+XxeGhsbKS6upqVK1fy8ssvc/LkyYRFY5BIKyEalxMh\n", + "GpeWWNFTIca8I5k+t/z8/FlJSUl5Lpervq2t7Uy8uYX8Ij9ES+wLLzr4GVmWnYqirAHeGOSSQ600\n", + "6tHqqiVMuGC0t7eTmpo67vMr+vv7OXv2LFlZWUaP9J6eHoAh/QhqqPlRuEkuFvqYwRIh29ra2Lt3\n", + "LzNnzmTmzHgdgkdOIBCgqakJh8MRN2Fy27ZtwxKOOHQBh6K2XfL/LyEagmuOkayCQsLxXSJrYX0M\n", + "3IqWkHie+D0zLklIabRZKvR+OE2fLit9fX3Y7fYBbXWHInpF4vF4qKqqIi0tzXiq93q9fPDBB7S2\n", + "trJs2TIKCwsH7R0ea4Xj8Xh44403CAQC5OXlsWzZskFXb9u2baOjowNJknC5XPT39+P3+0lLS+OL\n", + "X/yiUQ7d5/PFLBN/kX6NeFzyHA4RPSUQJIAsy6qiKN9Ai6b6u9DmG9FKkKwDngvbHo1E/OKGwyYY\n", + "DFJfX2/4NPT+EU1NTRQWFo5LwQAistrDcyIG6/MNGCGup06d4vTp0+Tm5rJixQqSk5NRVZWqqir6\n", + "+vpYunRpxGprMGGqra3l7NmzXH/99WRkZBhlW3SnOUBdXR0PPvhg3FVLZ2cn588PLFqQn5+P1Wrl\n", + "0KFDvPnmm9x8880sWrTIMCH29/ezY8eOUSt4GMXw+gdfJsRKQ3BFczH+ltCKQwH+MWzzTuD/BQ4T\n", + "uaoI/z5es51rhpH2/3C5XDidTiRJIi8vz8jmdjqdpKenDzBXDSYWPp+P733ve0b+w1NPPWWUZ1dV\n", + "lePHj3P69GkqKytxu93MmTOH9evXxzxXvJVCcXExDoeDyspKZs2axYYNWj3Lffv2sWTJErq7u/nD\n", + "H/5gVN/Nzc0FtOz2we6tkiThcDjIzc2ltrZ2sCRBvaJCPxfKj4ya2UqYpwTXHKPhpFcU5R+BcOf5\n", + "r9FK8IeXRokXTSUYB+j3sVgCo+dUxCq4qItSPNHQzzdt2jQ2bNiAxWLh448/5vTp02zcuJGWlhb+\n", + "8z//E4hMpnzmmWfilnrXKS4udj/99NOmb3/720mJ9usIMWpOc2GeEghGgCzL/6woig/419Amva5V\n", + "OEIwxgGJdvcLZ7CQ3qF8MXa7neuvv56VK1ca3fuOHTvGnXfeCcDhw4cHHNPb20teXl5Mc1c4FovF\n", + "AVoZ+46OjkHHRjFfkqStYxWEIkRDcKVzbpjbYyLL8v9RFMULfC+0aSUX8jl0xq1j+lohXne/3t5e\n", + "o6eHy+UiJSWFmpoa3nzzTbq7u1m1ahU1NTV0d3cPODZe5jxoPo01a9YY781mM7NnzyYvLw+n08kH\n", + "H3ww4JjU1NRBxSgpKYmSkhLuu+8+VFUlPT19uKIxpj3HhWgIrmhG82lLluV/DwmH3vsjWiCEYIxT\n", + "UlNTjYTBQCCAy+WitLSUp59+2sj8PnLkSNwIJ104UlJSSE9PN15ZWVkRhSZVVWXhwoUAnDlzhuLi\n", + "Ypqbm41wW5fLRUNDQ1zHuN1u55vfjCxrNsISIxUh02w0lzxMV4iGQBCGLMs/Dpmq/mus56LT2dlJ\n", + "W1sb3d3ddHV14XK5sFgsFBYWct1114319MYFugMaID39QgV7SZIG+DH0trTZ2dnk5ORQUlJCWVlZ\n", + "QqHD4aauxYsXs3jxYgC6urpoa2vj7NmzHDx4MK4QSJJEXV0dSUlJOJ1ODhw4QHv7iPrKJRHbl3fJ\n", + "EY5wgSAGiqI8BfyCS1Tmezjs3LkTk8lEUVERRUVF5OXlXbN1qeI5rD/3uc8xY8aMQY999913ueGG\n", + "G4ZsguV2uzGbzezfv5/6+nra2tpwuVz8zd/8DaCtZI4cOYLD4SA7O5vMzMwBobzPP/88lZWVOBwO\n", + "cnJyMJlMtLe3GwmQ0dhsNnw+X8J9OUwmU3cwGEyPsWtYTnLhCBcIRo8twN8Qu93rZeXuu++OeB8M\n", + "Bo3VxmA5EdcKNpuNKVOmDDnupptuMronOp1OowOgJEksXboUu91OR0cHr7zyCo899hjLly/H4/EY\n", + "BRJ1zGYz8+fPH3D+3bt3U11dbRREzM/PN0KKbTbboKuY8JWJXoQxFmlpaSxbtowTJ06kx3G0X3In\n", + "uRANgSCKUCXdc2gtXcecrq4uurq6sFgs5OTkYLfbSUlJGfrAq5Bop3VeXh7Lly+PmbQXCATo6ekh\n", + "LS0Ns9mMJEns3r2bvXv3RowrLS1l5UrN0rNjx46InAm73W7kfgxFV1cXra2tMftmpKWlMW/ePMxm\n", + "MyaTyaisq3+v9/kAOHLkCPX19QPOMWnSJDZt2oQkSXg8Hurr6yOOC3HJneRCNASCMBRFmQScZhyF\n", + "2Kanp5ORcaFpYGtrK5WVlXR1dbF27doxnNnlJ15YbTR9fX3s378fj8fDypUrMZvNnDlzhpqaGkpL\n", + "SyPGZmZmGquAdevW0dHRwYEDBzh37hw+n49ly5YxadIkVFXF7XbHFez7778/rvksOzub1atXJzT3\n", + "xsZGzGbzgB4e4fNctWoV1dXVl6J0yZAI0RAIQiiKshqtWOG4chgEg0Gampqora2lrq7OMJUMFip6\n", + "rZOcnMyKFSsitk2dOpWpU6dGbNN7cehFFPPy8oz+4QsXLjTKugSDQZqbm0fc1CkYDOL1eo1y8vrN\n", + "P5bJKlwYW1tbjaz2qqoqnn/+eYqLiykqKoq1yrgsCNEQCABFUf4WrT/HuMNsNlNcXGyElApGD92s\n", + "JUlShImrubmZvLw8Y5vJZBq0k6IuLi6XK+b+3t7eISv2ghbS29rayoEDB6isrBwQWdXT00NlZWVC\n", + "n+1SIURDcM2jKMpvgYfGeh6CxBjNRlXxzpOfnz/gmoONt1gsqKoaNzAhPT097j69Um8gEOCFF16g\n", + "oaFhyBIkY4kQDcE1S6gp0xFg1ljPRTA44UIxFp0NE7mmJEnk5ubGXE1kZmaiqioul4umpiaCwSDp\n", + "6enk5ORgtVrxeDw899xz1NXVGefKzs5mwoQJxis5OZn6+npqamqoq6sLd7gH0Qpq6twkSVInkUUO\n", + "YZQS/0SehuCaRFGUNLQWsRlDjRVcuVxsR8FwsRrJufTjg8GgEd6bk5MTMaaxsZFdu3bR09NDcnIy\n", + "Pp9vQIiu7r8Kr7vV0NAQNzQ3DgNyOESehkCQAIqizAEOIv7+rxo6OzuN0NpwhrrJD2XqkiSJzs5O\n", + "zp07x7x58xI2jUX3PjeZTEbWut/v5+zZs4aDW6+HpUd1JScns2DBAiZPnkxPTw9tbW10dnayf//+\n", + "mMUao7Hb7aPRszwu4p9GcE2hKMoG4LeMg0xvwfCJd9MeaSRZIgKQmZlpJPM1NTXR29tLSkoKaWlp\n", + "pKamxjxmMLF64YUXqKqqitiWkZHB1KlTmTt3bsRnSUlJoaBASxeqrKxMSDQupWCAEA3BNYSiKN9B\n", + "y/IWXKEM158xmk5zwLiBD/faqqrS19eHw+EwQmUtFgsVFRVcf/31TJ482Rjb2dnJwYMHOXbsGHa7\n", + "nby8PCZPnhzs6+tTGQfNv4RPQ3BNoCjKH9F6gAsEY8rRo0exWq1MmjTJqIPl9/s5efIkVVVVHDx4\n", + "cEANKovFss/v988khg9OkqREa1YJn4ZAMBSKopiBGkAkOQhGjKqqnD9/nqKiooiWtG63m7NnzzJr\n", + "1qwB/pTwY8NXO3PmzDG+b2xs5MiRI1itVhYsWMDHH38cUwCSk5MzbDab1el0Dthns9nimaR8wPth\n", + "788N8TETQoiG4KpFUZQJaIKRNNZzEYxvEnGIh5cfCQaDdHd309/fz/Tp0+MKhn5sOEePHuX06dO4\n", + "XC5mzJjBqlWrjH4dSUlJEQUL7XY7BQUFZGZmzgQMH0owGCQQCBAIBAZr4NQ+Wm1hIz6PME8JrkYU\n", + "RVkGvIdweAtGEb/fj6qqEasNSNx3oo8LBAIR5URqa2t55513OHv2bMRKo7S0lI0bNxqi8tprr3Ho\n", + "0KFEGzd1qao6aISAME8JBICiKF/hQvc9gWBUePvtt9m7dy+qqpKUlERGRgZmsxmv18uXv/xlY1y0\n", + "Azzc56Bvj16Z7N+/n8bGRmw2G6qqEgwGCQaDnD9/nu985zv8wz/8A6CVNxlGp7+B5XZHASEagqsK\n", + "RVGeAx4d63kIrj727dtn3Pz7+/uNjGy73R6xyggXDF00wve7XC4OHz7MoUOH8Pl8WCwWLBYLPp8v\n", + "piCEFyYcpmUoKUZL2IvOChfmKcFVgaIoEnCccdA0SXB1EH3Tf/HFF2lra6OrqwuPx4MkSeTl5TF7\n", + "9myjH0c8M1V3dzeffvopLpeLQCBAfn4+EyZMMKremkwmtm3bRnNzc8y5hEJ1VY/Hc7H3uYgIqpHc\n", + "O4VoCK54FEVJApyAY6znIojNaOdLjCa6OAynREggEECSpJjH6J+1ubmZjIwMo3vfUMTrxTHKXLRo\n", + "CHbEvxgAACAASURBVPOU4IpGUZRy4AzjrAeGIJLxKhjAAPNRIiQSLRVdKVfH4/GMSpve8HmrqorD\n", + "4TBKlTQ1NV2yzHAhGoIrFkVR7gZ2jPU8rlbCnbiJ3lTdbjc1NTWUlZWRnJxMf38/hw4dYs6cOXFL\n", + "box3dGvMJ598YtyMA4EAbrcbm81GeXk5S5YsMRzYelTUyZMnqa6uprW1FafTSXl5OatWrRq15lmq\n", + "qlJUVMSmTZuwWCz4/f5gX1+fr7+/3/vSSy/Zm5ubbaNyoSiEeUpwRSJKgowv9Jvlr3/9a86cOUNK\n", + "Sgr33HMPM2bMAKC+vv6KbyK1bdu2mLWfMjMzB7ShVVWVrVu3DjA3mc1mbrnlFpYsWWK0dH355Zep\n", + "ra3F6/UaZq9AIEBKSgq9vb1DrRh8wPtWq/W81+t9XN8YcoCvjDFe+DRAiMa1hqIonwDXj/U8BANp\n", + "aGjAYrGQnJyMw+EY1IxztRPPR1FQUMADDzxAZmam0Wo23kru2Wef5fz584NdJmYuhiRJW4GyGOMj\n", + "oqeET0NwVROKkOoBUsZ6LoLYFBUVRbwfzw7w0UZ3qMPgPhy9CKGObgLs6+vD4/EYr+7ubpqamoa6\n", + "bKokSVujw2j19zHEoyy0Chlx6K0QDcEVgaIo6UAnIsP7iuJKE4zBRC6WIFRVVTF58mTa29vJzs5G\n", + "kiQ8Hg9vv/32AN+FXvbD4XDQ0dGBxWIhLS2Nnp4e0tLSOH36NNu3bzfG2+12CgsLUVUVt9tNd3d3\n", + "rDwOM/CIJEl3cKFLXwVa6Zz+0NdRbTQmzFOCcY+iKDcCH431PATXDqqq4vf7jQZMn376KfX19ZhM\n", + "JvLz80lPTyctLY3bb78dq9VKTU0NKSkpZGdnR4Thbtu2jfb2djo7O+np6Ym4RmlpKZs2bWL79u2s\n", + "W7cOm83Grl27eP/99yP2h/OTn/wkbi5HLGw2W7wM8ndUVV0lfBqCqw5FURTgn8Z6HgLBSExtg+Ve\n", + "ZGdns2rVKt59910mTJjAgw8+CMBzzz3H+fPnMZlMFBQU0NTURHJyMiUlJfT09CScy6EXWIwzfsSi\n", + "IcxTgnGLoiiVwNSxnodAAKNrarPZbGRkZDB37lyqq6sBOHHiBFOnTsXv9xtVbvUbvsfjweVykZ2d\n", + "jdlsjigtEg9VVYfbQzwhhGgIxiWKovgQf5+CqxSHw8HixYvp6OjgnnvuMQTplVdeweVyxTxGz8kA\n", + "8Hq99Pb28v7777N///6Y44eIuhox4p9SMK4INU3yIRzegkuA3++nr6+PQCBAUlJSwiU+RpuMjAwq\n", + "KrQyacFgEKfTSXt7O9XV1cRqtATg8/no7e0lOTkZm81GdnY2d911F06nk5qaGoLB4FCX7QIOhb4/\n", + "N9K5C9EQjBsURZkOnBrreQiuXvSIpZGQSDhtovj9fj788EMOHz6M2+0mLS2NrKysQc1JDQ0NfPe7\n", + "3wU089a0adO48847jTLqQxAA2kajKdOYikYoTOwHaGFjv1BV9ZkYY34ErAXcwJOqqh68vLMUXA4U\n", + "RfkD8Nmxnofg6sPr9RpNjBLZHot4TvBAIDAggdHr9WI2mzGbzTFLhqiqSlZWFosXL2bx4sUR+7Zs\n", + "2UJ3d3fMOeglSxwOBw6Hg7S0NLq7uxMtl24G6hIZOBRjJhqSJJmBHwO3AfXAx5Ik7VBV9UTYmHXA\n", + "VFVVp0mStBj4CbBkTCYsGFUkSfKj/SEDWt/k9evXj+GMBFcrNpsNl8tFXV0dDQ0NNDY20tDQQE5O\n", + "zoCQ1nDChSLe6qKyspKqqiqsVisTJ06kvLw8ohihXl4k/FzPP/88VquVhoYGCgoKcLlcdHV10dPT\n", + "E1cw7HY7FRUVA8qVDDa3S0Vc0ZAk6XXgL1RVrb5E114EnFFV9Vzoer8F7gVOhI25B/glgKqqH0qS\n", + "lClJUr6qqokHKgvGHdGCAVptotOnTzN9+vQxmpXgasZms9HV1UVNTQ2qqpKTk0NGRsagYbSSJNHV\n", + "1UVjYyMVFRX4fL4BbV4rKioM34TT6eTYsWOUl5eTlZU14FygmaWWLVvGmTNn2LlzJ01NTcZKwW63\n", + "x60zlZ+fz9q1a+nv78dmsxm5IB6PJxHT1Kgy2ErjWeBNSZJ+CXxHVdXRjt0qBmrD3tcBixMYUwII\n", + "0biyGVCQqKOjg507d/L1r399LOYjuMqxWq0sWrSIRYsWDes4l8tlOMujBQPgwIEDZGRkMHHiRHJy\n", + "csjJyRkwRhcmXXTKy8spLy8HtKrA586do66ujjNnztDS0jLgeJvNRlZWVkynvd1uH04fkFFpUBZX\n", + "NFRV/X1otfFPwH5Jkp4D1Au71X+/yGsnmlUY/RgQ8zhJkjaHvd2jquqeEcxJMIYMo/exQDDqqKpK\n", + "IBCgt7cXl8uF3W4nPz8/btFFVVU5fPgwtbW1ZGdnM3fuXFasWIHJZIpp2tJFJ9yh7nA4mDVrFrNm\n", + "zeKWW27h2LFjHD16NOJ/IbyKbjAYxO/3Y7FYDLHIzMxMtH9GriRJbwD7RvgjAob2afiAXrT6JWnA\n", + "aK6D6oGJYe8nMtBREz2mJLRtAKqqbh7FuQnGgMu9zBYIwpEkCcv/396bh7dV3Qn/n6PF8iZbdux4\n", + "iR1n3yGBQFMggAOlDWFrCoWWtmydlk5/3abTTpd5fyPuvNNl2plpp6UttKWBocPShgQSCPuShQCF\n", + "kI2QxFnsxE68yqtkS9Zy3j+uriLJki3vdnI+z6PHuvce3fuVLJ3vPd/VYsHhcKTU80JKyc0330x2\n", + "dnafu/34PiSp+EcsFgtLly5l4cKF7N27l4MHDxIMBnG5XPz4xz9OeFNlONtT/O2YgWVSytVRcjpT\n", + "eWGMnMkOhCOb/gvYDFwgpewe7MkH4D1grhBiBnAauA34bNyYTcDXgCeEEB8F2pU/46wgSAIT1XjF\n", + "zCsmHkbV12PHjjF16tSkXfDGE5PJRE5OTkz0krFakVLGmLMG46xOS0vj4osvZt68ebzxxhvs3buX\n", + "UChEYWEh8+fPp66ujpqaGoCIUhkEw/6RJa09JYTYDnxFSnlguBdJenEhruVMyO1DUsqfCCHuBZBS\n", + "Phgecz+wGvAAd0sp309wHlV7apKRwBku77vvPvU/VIwq9fX1gH6DYrfbsVjGJ4C0Pwf8Sy+9xPnn\n", + "n09xcTEAzc3NVFVVkZ2djcPhID09nc2bN1NX1zeC1jBlvfrqq8kywmP6b4x07akr5ChXM5RSPg88\n", + "H7fvwbjtr42mDIrxQUrZ57unaZoPGJUWlQoFQElJSZ99RtfBRAy2SKGRcW4kEAYCAVpbWyksLOxT\n", + "Un3q1KkxiYahUIjnnnuOY8eO8dZbb7FkyRKuuuoqCgsLY/pvQPIe5bm5uVRUVIxqGK6qcquYUGia\n", + "thO4ZLzlUJydGI2SAoEAUkrS0tKGPcEahQGbmpro6OjAarUmDB1PpIA6Ozupq6ujpKSEvLw8gsEg\n", + "Dz/8MLW1etCo2WzmvPPOw263093dHXmcOnWKQCDQ5xoFBQWUlpayf//+ZEl/w15pKKWhmHBomnYP\n", + "8NB4y6E4d0i2ohitzoPd3d309PSQmZlJRkZGzLH+yqkbJOuTMW3aNBYsWMCrr74qSVy/rVFKWWxs\n", + "KKWhOGvQNK2CYRRVUygmI1JKnn76adrb2wGShtJmZWVht9tpa2vDbDYjhCAYDOL1euOH+oGdUdvD\n", + "7hGulIZiwqJpmg3oQVW8VYww0X4MKSWNjY1UVVXh8Xiw2+0UFxczZ86chFngyRiNVUmyVUd2djYe\n", + "jydiguqnQ1+MOSoepTQUZx2apgn0ks5DK02qUEQRPbH7fD4OHjzI3r17aW5uxu12R8bl5eXxzW9+\n", + "E7fbTXZ29qjLZBCtdDZu3MiRI0cIBAKR/cFgMKEvw8gLSYBSGolQSuPsR9O0d9DrlSlGkVAoFKn+\n", + "atyJGxnIEwm/34/L5aKxsZHOzk4uv/zyYZ3P4/Hgdrsj2eAA559/fkTJDLcsen+rkI0bN9Le3k4o\n", + "FMLr9ZKZmQlAS0tL0oZM8SilMUiU0jg30DTtJ8D3x1uOs5W2tjZOnTqFy+XC7XZTUlLCwoUL+zhq\n", + "FSNLMhNUPyanPvSjNOJ9GgY1Usq7lNJQnPVomnYd8Ox4y3E2kKoNfrQiiAaLUUI8NzeXrKysET13\n", + "f7kaI4XX6+XkyZMcO3YMu93O4sWLycvLS6o0+qt6Owj8QCKnzFYpZaVSGopzAk3TZgNHx1uOsxWv\n", + "10t7ezvBYBC73Y7dbp8QSiMav99PdXU1R44cobu7m09/+tPDOp+UEq/Xi8vlIhQKkZ+fPyq+DCkl\n", + "b7/9Ni+99BJSSkpKSujp6YlES0UzVKVRUFDAmjVrAna73fvMM89k1tXVJdKGQ1Yao6taFYpRwOl0\n", + "HgOygGHfhin0iSwUClFTU4Pb7SY9PZ3i4mJKSkpobGzk9ddfHzM5Uh0jpaS2tpbdu3fHOLCHihCC\n", + "jIwMysrKmD59+ogojOPHj/Puu+8SCAQiZiYhBJdccgnf+c53uPHGG8nJyUmoMICkrV+tVmu/Sjwr\n", + "K4tZs2ZZCgsLs81m84jP8WqloZi0hCOraoDp4yyKYgwwzGRerzdS3LK9vZ3du3ezatWqIZ2zo6Mj\n", + "ojBSDa1NVdb333+fBQsWkJWVxYEDB7DZbEyfPr1Pi9lkFWyFEJSXl/dREAM5yLOysrrnzZu386ab\n", + "bvrBj370o/v9fn98nyJQ5imlNM5lNE17FrhuvOWY7Jw8eRIpJTabLfJIT08fdVv/UDBWR8lqMCV7\n", + "TapmtuFGSw107tdeew2LxcKcOXN47LHHEioBI+w3mueff57q6uqEzZqi2CqlrAQQQrwBXJlsjFIa\n", + "inMWTdM09IZhCkXKGLWojMZJHo+HjIyMPspoOMEAoVAokl/h8/nw+Xzk5uby+OOPc+LECUwmU59+\n", + "GNOmTePWW28lNzcXn8/Hs88+S2NjIz6fj46OjoEuGa00HgZmJBijoqeU0lBomnYT8PR4y6GYXIzm\n", + "qqI/GhoaaGtro6mpCa/XSyAQwO/343A4uPzyyzGbzZw+fZr169fT2tqa6mmD6AphTiqDldJQnPNo\n", + "mrYQ+AAV5KEYQfx+PxaLpU/GdltbW2RfdnY2CxYsYN68edhstmFf86233uKVV14hGAwO9qUdwJ7w\n", + "85haU/EopaFQAJqmOYBaYHTrPygmHB6Ph8zMzEH5Lnp6euju7sZut8dM9slMUqFQCLfbzfr16xM2\n", + "Opo5cyZ33nknGzZsoLm5GavVisViwWq1kp6eTkFBAQUFBUyZMgWHw0F1dXVEKRmZ9/v372fv3r1D\n", + "/BRiiJiqEjHSTZgUikmJ0+lsDyuOw8Ds8ZZHMXZkZGTQ1dVFWlpaSu2DhRBkZmZGSnfEH0uE0eY1\n", + "2XFjZdDR0RHpFNgfU6ZMYdq0aZSXl1NWVhYpltjd3U11dXWfWlOJfCBjiVIairMSp9MZBOZomvYc\n", + "sGa85VGMDcaEDrErhZHKak8lc9y4jsNxpuSTYdExnNnRuFwuXC4X+/btA6CiooK1a9fS29ubsDjh\n", + "eCoMUOYpxTmApmk/An443nIoxodQKERTU1Ok5/ZIkaz8R1lZGV/4whcS+jVSabAEejZ4dnY2Lpdr\n", + "uGKOuHlKOQsVZz1Op/Ofgc+MtxyK8cFkMg1bYQzm5tpsNkcURvzrHA4HFRUVkUcyh7nP56Orqyvh\n", + "sZFMQhwKaqWhOGfQNG0Z8B6QekaYYlITCoXo6ekhLS1tUJNtKuYso6R5PA6Hg7Vr18acKz4RMRgM\n", + "EgwGefTRRzl9+jTp6elkZGSQkZERMX8ly/xOoSaVip4aCKU0FKmiaVohcBwVWTXp8Pv91NfXI6Vk\n", + "2rRpE67HBwysbKL7c/h8PqSUfUrPNzU1UVVVxfbt2xMqh37KoBv0a5KKO5dSGgrFQGiaZgUOAbPG\n", + "WxZF/2zbtg2z2cycOXMoKioa8fNHT+Ijldw32HMFg0GOHz9OVVUVR44cSVrAcBAopTEQSmkoBku4\n", + "2OGLwDXjLYsiOcFgkO3bt7Njxw4yMzOZO3cuc+bMYc6cOeNi29+xYwcrV65MeXx/2ebd3d3U1NSw\n", + "a9cuWlpa8Hq9+P3+VKKjgvRvYlVKYyCU0lAMFU3T/gP4x/GWQ9E/LpeLN998k5aWFtra2igoKODO\n", + "O+8c8etIKQkGgxHTV/yqYaitb6NrXAUCAQKBQCSPpKGhgfXr19PS0jJSjZeU0hgIpTQUw0HTtLuA\n", + "deMth6Iv77//PrNnzyY3NzdmfzAYHFSF22SkYp4abG2q06dPc+TIERYsWEBRUVHSc+/atYvdu3dj\n", + "NpuRUtLd3d1v1FQKBIEdDOD8jkYpDYViiGiatgJ4ExVZdU6Rqv/hwIEDLF68mM7OTjZs2BBRJPGR\n", + "UgDbt29n586d3HLLLcyePZvnnnuOQCDAxRdfTHFxMYcOHWLRokV0dHTwi1/8IvK6iooK7r77bjZt\n", + "2kRTUxOhUIhQKBRZpWRmZnLhhRfyxhtvJCtg2CGldCQ6kAxVRkShGCJOp/MdTdNmAgfRuwIqJgD1\n", + "9fURc0305G6xWCguLh72aiPV1YPdbqelpYWCggJyc3P71IWKXo1cfvnlXHbZZQghCIVCHD9+HJfL\n", + "RWtrK83Nzdxwww2AXl8qEVdffTUvvPACjY2NMX0zhBDU19cnbNg0lqiVhkIRhaZpGeiRVaob4ARC\n", + "ShnTj8Lr9SKEoKSkZMSinnbs2MGRI0ciq4/8/HxuuummyPZbb73FJZdcgsvl4je/+Q2hUCiyOjDK\n", + "i4RCITweD9nZ2TElTGprayOl0K+55hqklPz3f/83nZ2dkesXFxdz7733xryfVDPIw4zJSkMpDYUi\n", + "Dk3TTMAbwOXjLIpihBjIZ2Ece+edd3jllVci/blvvfVWFi1aBBDxOeTl5bFhwwb27dsXURrr169n\n", + "9uzZLF26NNLQSQiBz+cjLS2tz7VdLhf79++nu7sbj8cT+WuxWFixYgUlJSXY7XaeeOIJpTRGA6U0\n", + "FCONpmm/Ab463nIozpBKscB4gsEgQoiUXmecv7m5mY0bN3L69GmmTp3K3//930cmfcMB7/V62bNn\n", + "D1OmTGHu3Ll4vV5sNtuIN3IaxEpjUM2XDJTSUChGAE3TPo6ew2EggS4gZ3wkUkSvBkKhEN3d3QSD\n", + "QbKyskYsM3zTpk1ccsklFBYWEgwG2bp1Kzt27ODzn/88s2YNnAeaqlO9q6uL999/n4yMDDIzMyPl\n", + "Q7KyssjNzeXUqVOcOnUKl8vF3r178Xq9qYifcphtNMoRrlAME03TioD1cbtfAL6J3hEwbcyFmjgM\n", + "lFQ2akRPxiaTiezswVWBiXZUR69YDAVksVhwuVw8+OCDXH311VxyySVcddVVzJs3jwMHDiRUGvFK\n", + "oj+FkWqdqmAwyDPPPBPjAJ9oKKWhUIQJ+zLWA/a4Q884nc4jmqYdBJaOvWQThkkbjhw9oR8+fJi3\n", + "3nqLyspKZs2aRXZ2diQLOxAI8OKLL1JVVcUnP/lJysrKkpYvSaQk4hWJoSwaGhoSJu35/X5aWloQ\n", + "QrBt2zaOHj2asEghEEJf8Y77/0ApDYXiDN8BomtEdAOZwD5N03KBxeMilWJEaWlpIT09nfb2drq7\n", + "u8nMzMRkMsU0TQqFQjz77LOsWLGCOXNSdxPU1NRw5MgR6uvrCQaDNDU19WteOn36NPfff/9Ap42Y\n", + "noQQbwBXpizQKKB8GooJgxDiYWBGgkMpZ7gOFU3TlgPvAsb3yBd+nobuy/j/ge+OpgyKkWOwWdwj\n", + "lWFuYDjGH3744cFEPyUjWmk8zAj+RpRPQzHZmcE43EVpmpaN7viO/vH8APgvoAbdJPCNsZZLMXQG\n", + "UhZSSjweD62trUyZMoWsLD2fMxAIRNquXnjhhRw7doyqqiquvfZajh49yssvv0xubi5XXXVVv42d\n", + "0tPTI3WshsHW8N+aKLnvGs4JRwKlNBQKeAqYErW9GTgdfr4fvVVsfIs1SaySUYwjiSKXPB4PTU1N\n", + "zJw5M2bfu+++y4cffoiUkhtvvJGsrCxCoRC9vb2kp6dz4YUX0tjYCEB5eTnV1dUA9PT00NjYSGNj\n", + "I1VVVSxevJjVq1djt8e7wOCJJ56gqqoqacVah8NBXl5e5NwDMEMI8fBEUBiglIbiHEfTtO8AH4/a\n", + "1QV8hTM5GodJvMropa8iUQyB2tpaMjIyyM/Pj8mnGExfikTjsrKyYhSGsa+yspLKysrIPo/Hw3vv\n", + "vcfJkydxOBxUVlZGnN9paWl87GMfA2DGjBnk5ubS0dEB6PWojh49ypVXXsmsWbNIS0uLdAjs6enp\n", + "t8R5bm4ud955J3/60584efJksmHj6rtIhlIainMWTdNWAj+L2/0PTqfztKZp54e355JYOQw29Fat\n", + "TJJQXl6ecP9gEuUMH0a0j9Z4/UDnycrK4sor9fnZ5/Phdrtpbm4mLy8Pi8USKYdut9txOBwRpWGM\n", + "f+mll1KWE/R2rb29vTQ0NIx4MuBYoJSG4pxE07RpwKvETuSvAX8KPz8v/PfaJKcY7K998s0O44TR\n", + "U1tKGXFODzS5pqogBsJms2Gz6fcIRrhsYWEh119/PRs3boypFWVg1JxKFZ/PR319PQ888MCgM9wn\n", + "AkppKCYSNQAmk8lSVlZ2iRDCFAwGvV6vN6RpmnA6nSMS6qdpmgN4n9jVQjfwJafTKTVNy0F3ygcZ\n", + "eEXhB8a+hdxZjBBiUJFMUko6OjpoaGigp6eHrKysyKogvv92KvT29mIymWhvb+fEiROcOHGCQCBA\n", + "W1sbbW1tfcZbrdYhN04ajLKZKCiloZgwRDv6NE1bBfwGWAisAt7QNO3bTqdz13CuoWlaJrAdmBp3\n", + "6J+dTufx8PMl4b+JbgM9xJZO34K+GknbuHEjJpOJm266ie7ubo4cOcLSpUtHPJzzbKG3t5e0tLTI\n", + "c5/Px5YtW+js7OxTGiRR34q2tja8Xi9Tp07F4XDE5FkY+Hw+Ojo6aG9vR0rJ/Pnz+5XHbDZHZMrJ\n", + "yYk0gHI4HJw+fTrh6waTtmCYuyYzSmkoJiROp/P1sF/hy8C/AlcA72qa9j/AD51OZ+JfcD9ompYG\n", + "bOKMUjB4B/h11LZhmkpk64i/Nfxf4CaA9vb2iOPViM4BDIWhfBpxvP7668yaNYvp06djs9lIS0uj\n", + "u7ubU6dOpfT6vLy8yPPu7m56e3sJBoNMmaIHwkkpSUtLo7CwkKlT4+8R+mIoC4Obb745ZvvYsWMJ\n", + "X2f0tzCZTFit1ohiSLT6MJvNqSoNL/r30qAmlReNBUppKCYsTqczAPxW07THgP+DHsV0J/BpTdN+\n", + "DzwOvJuK2UrTNDPwKHB13CE/8EWn0xkdUH9R1PPoyb6H2FVGB3BD9MkWLFgAwKFDh1i5Mjq5fOIo\n", + "jMFEJY0m11xzDbt27WLjxo3YbDaKi4sT1mdKhMfjiWR2OxwOMjMzyczMjBkz3PfY1dVFS0tLZKXS\n", + "0tKScJzNZuPrX/86FosFIQRWq5VHHnkkYVKfUXJ9AIZUfHCsUEpDMeFxOp3twHc0TXsA+HfgU8C3\n", + "wo/jmqY9ATwJ7E+kQDRNE8DvgFujdofQzU//5nQ6D8S95BNRz6NnnkPABVHbb0Wdsy07OzuvuLgY\n", + "n89HdXV1H3PKRCG6OdB4K4+LL76YZcuW0dnZSXd3N5s2bUrpdVlZWZGEPNAn+K6uLkwmE0VFRX3e\n", + "1+HDh9m7dy95eXlUVFQwY8aMPisLoBX9JmEKwPr161PK5i4uLiY7O5t33nmHqqoqAoEADQ0NCcdO\n", + "Rh9GPEppKCYNTqfzKHCzpmkXAZ8DbgNmoSff/RA4qGna48CTTqezKuqlPwW+FHc6E3ri3k+jd2qa\n", + "NgVIHAMKs+O2e9DDcXcD+Z/85CfzAI4cORKZ1IwQTsNkMpEYisLYuHEjPT09kTv7zMxMzjvvPHJz\n", + "cwd9LpfLRUdHB3PmzGHKlClMmTKlz2ohGX6/n1AohBAiEg6bKMnOMBHOnz+fqVOncujQIU6ePElT\n", + "UxMrV65kw4YN0SG0+cYTw0diZI77fL6IGcpqtVJQUEBPTw9WqzXiS1mxYgUXXXQRtbW1dHR04Ha7\n", + "6erqYt++fXR3dw/685mojEvtKSFEPvqdYQW6re5WKWWfdakQogboRI9i8UspP5LkfKr21DlI2OR0\n", + "OfAZ4BZis7rfB55Anwi+b+yMLlHd0NDwvs/n6wIWhA8fKigomJOVlTUN+jhfvUB6nAhdxFXEraur\n", + "Y+fOnXziE58gNzeX48ePY7PZmDZt2vDf8Agw3NVFoqZAaWlpfOlLX6KwsHDQ5/P5fDz99NM0NzeT\n", + "mZlJc3MzPT09fcaVlJTwuc99btAl0QciWZMjoyNfKq8tLCzk4osvpqysjOLi4j5htCk2UvIDO8PP\n", + "R73WmsGkacIkhPgZ0CKl/JkQ4ntAnpTy+wnGVQPLpZStA5xPKY1zHE3TrOj+is8Aa0nSMOlPf/qT\n", + "PHnyZErflbiJY6DQ2idefPHF2/Lz88Xy5csxmUy43W6sVmsk7n88iVcWQ1Uep0+fZufOnRw6dCjG\n", + "oTt//nw++9nPpiyLgSHD0aNHeeuttyJhs4nMOKlM5INlMEpDSonf74/kj7z11luYzWYWL15Mbm4u\n", + "69ato7m5mdLSUrKzs8nOzsZut/Puu+8m9YdEMS5+jMlUsPBGzqTIP4Lej7mP0gijlIFiQJxOpx+9\n", + "WdILmqZ9Bfg34B/jx4lBzJRxQxMpjL8CLvSyI7d94hOfCBHV72Ck74qHQ/R7GUrbVNAnzdLSUm65\n", + "5RZ6enrYt28f77//Pk1NTSxe3KdqfBuQl+A0CZXVnDlzIiXI6+rqcLvdBAIBgsEggUCAQCAwoOlq\n", + "586duFwuvF4vPT09BINBCgoKuOaaa0hPTycQCERyQDo7O5FSDipcVggR4we5/PIzLeQ7Ojoifpmj\n", + "R4+mesoOYE/4eU3Kgowz46U0iqSUjeHnjUDiLie6U+oVIUQQeFBK+YcxkU4x2bkKvdMenHF4Qwph\n", + "r0IIpk+fzpIlS1iyJD4ytw924D3gAHqvjVSSMcY99HaoCkMIwYkTJ7BarZSWlrJixQpWrFhBEVYc\n", + "4gAAIABJREFUT09PoiS6vESvj6a7u5u6ujpmzpyJ1XpGJ5eVlQ1aPoBLL720j8xerzdSiNBisRAM\n", + "BgkGg+Tk6AvR/u4htm/fTldXF3l5eRQWFhIKhWhrayMQCGCz2cjKyqK9vZ0PP/yQurq6QSmgMHsm\n", + "cpRUMkZNaQghXgYS1Q7+5+gNKaUUQiT7tC+TUtYLIQqBl4UQh6SU25Nc776ozTeklG8MQWzFJEfT\n", + "tNnA+qefftpy1VVXBXJyciwAPT09/oyMDKvb7e4B+sxwpaWlrFy5kvLy8oQO1SSsDj+S8Rx6JFb0\n", + "72zSrJyjJ3rjb0VFBV1dXWzfvp3s7GyWLl2aUtZ19OTc1tZGXl4emZmZzJs3r8/Y1tZWtm3bRiAQ\n", + "wGw2Y7FYsFgsFBQUcPHFFye9Rl1dHUKISM/t6IeBkWRpvLf+opmOHj2a0HQlhIisepJ02RsIY4VR\n", + "M5QXDwchRCVQOZxzjJrSkFJek+yYEKJRCFEspWwQQpQACRviSinrw3+bhRAbgY+gZ/MmGnvf8KVW\n", + "nAVcB2QsWbKkNycnJw0w7oStnZ2dtLa29pJAaVitVhYtWgQQKRlhRPagm1puAwrRk/lS5cJhvpdx\n", + "Jf4u3Jho7XY7l19+eWTb5/NhtVpTXsFs27aNZcuWUVFRETmv2+0mLS0Nm81Gfn4+H/vYx9i8eTO1\n", + "tbWYzWa6u7spKipKqDQMOV5++eWYSd5kMkXyOObOncuqVav6vLfoyrrGSqG3tzfyvhJhRFTZbDam\n", + "Tp06UD9vCQTQy9R40cO2x8zR3UcY/Wb6DWNbCOEc7DnGyzy1CT1J69/Df5+OHyCEyATMUsouIUQW\n", + "evlqbUylVExGrgGYM2dOxPhslKR49tlnycjICGRkZNRmZGRMNZvNEQ+13W6PlPuwWCwUFhZGRwPl\n", + "AYMrZapTMuR3MUGIX20YYa7GAxi0o//GG2+M2TYUUTTZ2dkxjvVQKER9fT3t7e1kZWXFmLOSmZhC\n", + "oRDd3d0Eg0GsVisej4eXXnqJvLw8rrjiCkwmE9deey0vvfQSwWAwEinX2dnJ1q1bOXToUL/vw+fz\n", + "DaQwOqSUfWubTHLGM+T2L8B0okJuhRClwB+klNcJIWYBG8IvsQD/K6X8SZLzqeipcxxN04rRQ2yv\n", + "hDOVUg1zRENDA2lpaeTn50e/7BR6OPf08HafEFr07+du4KOcBUpgMmAoqmiFFe28N6KYrFZrjMJ4\n", + "/fXX2bp1a5/zpaWlRYoXNjQ0YLfb+epXvxqj+Hw+HzabLeY6KYbK9seEVxqTJuR2pDkXlcZ49tOe\n", + "SGialgv8Cvg8UQUGN2/e/OFVV121KDprGKC7uzuUmZn5AHoJkqsYePXahh6JpQHR4VDRDu1xd25P\n", + "Jgbbv9vA7/dTV1dHeXl5n4KGBs3Nzbz77rs0Njbi8/kiTvorr7ySgoICNm/ezKWXXsqCBQvYt28f\n", + "vb29zJo1K/5mAoDq6mo++OADampqcLlcg3+j0CilTN4TdgKglMY5hBDiDRJ39prQdWtGCk3TstD7\n", + "eH+XM+XLfegZ2nu8Xu+S9PR0C5y5c92zZw979uzhrrvuakV3RF41wGWqgL6eWr0dbBPwxX5e24oe\n", + "Avwp+iYFnlMMVUkYzY/iz7Vz504uu+yyIcmyZcsW1qxZQ29vL7/61a9wu90ALF68mFmzZpGbm0tR\n", + "UVEfc1l3dzeNjY2cPHmSN998M5IdHkcQcIefe4EXJvoN3GTK01CMEiaT6az7n0avqiwWi1i5cmXp\n", + "pZdeOjMtLc0IcQ0BDwFH0f1kM9PT0y1SSl555ZXDHo/Hf+ONNy5ZtmwZQggfepZ4IoXh5sxqwkdf\n", + "hWGE795A/3jQlUVr+DpDuds8a1YvyZIKB8oXsVgs9PT0sH79ehYsWMBFF12EEIJLL700pqz622+/\n", + "zfTp0ykqKuq3BH13dzfLli0D4M0334woDAC3282+ffsi5qgpU6Ywc+ZMZsyYwcyZMyOtY2fOnMnx\n", + "48eTma3chKOiJrqyGA5qpTFJSbbSCGeyfgC8CewAnnE6nV1jLN6IIoRoMJlMRcuWLeOqq66KT5rb\n", + "CXzO6XTWaJr2v8DtUce+7HQ6/wCgadp/kCDZbwD6m7gNBRKtaKIJhI85gL+h53FkJRg3HBlGnIlQ\n", + "xDBVDKXT3d0dk/jX09NDWlpaRIFEl44B/T0ayX1msxm32820adOorKzk9OnTfRQK6FFW5eXllJeX\n", + "s2vXLurr6/sTbdKs9pV56hyiH6Uh77777ujPogH4HvBnp9M56Upsappm2rBhQ9eqVasyo/sndHV1\n", + "8eyzz3oOHTqUHTW2gzPlQ34JfBvd1/ETIFnxpx7gCHB+kuMG8bWnoidzF3rdqw4gvnLfccCJXpY9\n", + "VSTQS+Le5NG0ElVkbyJhZFtHt2wdTVpbW9m/fz/79++npaUFk8nEvffeS1FRUVKHtlGOPRqHwxHp\n", + "2DcMzmqlcdaZMs51Tp48uQPd1n8Z8Gn03hCPAH+vado3nE7nu+MpX6qEy5nfBPzfT33qU5HbyGAw\n", + "yLZt23jzzTfJzMw0a5qW7nQ6vZqm/V/OKIyXgZNAC7GTah0QnW7cgR7y/Xg/omxF77dxTNO0m8Nj\n", + "rZxRGA+hF0sEuBm9RM43ol4/C/ifVN93GEEShRF31xxTlXWsSrEnW40Eg0G6urrIzc2NiUwabQ4f\n", + "Pszjj8f+C6WUkcq7iQoggh4xNUzlcE6ilMbkpSbRTilljdPpfBN4M2yS+QJ6+e+PAn/TNG0d8AOn\n", + "09mY6PXjTVhZXIMesRSTyXX48GFeeOGFSJ/mvLy8dKBK07QtwL3hYQHg0vA5DPaiN3GKn7xN6KuQ\n", + "ZCnNv3Q6nf8QJZcjfH4jSaA9/MgFXkMPzf1F+Fj0SmTEZs8U7oJ96KazlJpjD8UclWy82WxO2HJ1\n", + "pK4bTbQ/ZO7cucycORO32x1TJiQ9PZ2uri4CgQAmkykm+9tsNhMMBvucd5BKJEhqpWPOKpR56hxA\n", + "07Qc9PIt/4A+4XWht1D9rdPpnDCF/jVNWwn8CL21a4T29vbQli1bTFVVVTHjS0tL+fKXv9zfKXei\n", + "FxP8EL1UumGCagW2AZ8MbyfyGzwOfN7pdIY0TSsC/sAZB3h0PSvj+f+H7jOZhe4I9xJbqn1EGKAq\n", + "aye6yfKpsBzjilFs0Ej+mwj+Er/fT2trK8899xwnT57sc9wwpSVSKAlIZI4EZZ5STHacTmcn8D1N\n", + "0x4C/gu91MbPge9rmvY74DdOpzNxq7ExQNO05egrC6OOkzGJ+4B/v//+++8NBAJ9ilpmZGRET97R\n", + "uNCjqLYAh9F9CobC8AJL0R3ThtKI/9H0AneHFcZN6AqjEH2S2IzuJzFkNK7/m6jXZzGw01uiK5yR\n", + "vFM1o/uvhqUw6urq2LdvH9OnT2f+/Pkx2deQ+uRvNptj/BnJypIMhDHunXfeobW1FYvFgpSSrKws\n", + "FixYMGCDq+iQX6vVSlFRsvqoKSmLILrZ8xC6qXNPgjE1A51kMqNWGucgmqatAe7jjPmnF72m0i+c\n", + "Tuf+MZRjMfqK51PhXdFK4HngG06n82h8IuPMmTPtlZWVs6dPn56bwqTTy5k8DoBX0ENzv0D/E/te\n", + "oBRdWYCubGyMfCTTfmAuKeZyDKdpUCp4vV7S09NpbGzkscceY968eVx33XWREivJGOwqInp8fX09\n", + "x48f5yMf+YihoFxAlpQyPdE5PR4Pp06d4vTp09TX17NmzRpyc3M5duwYXq+3T7HC6DInoVCIY8eO\n", + "8cQTT6S6moimA3j6bAqnVdFTipQJ2+gvQ48w+iRnJsOX0VcjL8b32x6JLPRws6QV6D6Iz4WvG20b\n", + "PoHe+/uZ6OuH5f0E8E/AKmJ5H704oBe9F/gdjIJpKIp29JVCwn4R9DV3JVsRJRrbL6OtNNavX09l\n", + "ZSUFBQW43W6eeuopVq1axfTp0wd8bXz5j4EUiRFdZTKZ8Pl8BIPBmNDZffv2cf75fYPa4kNoDWw2\n", + "G3PmzCErKwu73U5OTg4bNmygrq4uokCM9ruDmPeC6KHrcBbmXyiloRgS4XLi3wTu4czd94foyuN/\n", + "nU6nF5KH+ZpMps7S0tIqu92eZrfbM0wmk7mzs7Ph1ltvfRAoABYBS4CZ4e1EE2gvusnsx4afRdO0\n", + "UmAlutnqas7UiIqehJ9Ej2B6CXjL6XReGm4D+1ngjwwcttofRmu64Zhx452lyZRESsoj2YQZHz31\n", + "zDPPkJubS2VlZUqTt3F83bp1NDY28ulPf5rZs2cTCATYtGkTxcXFffpVDBav1wtAevrAi6pt27ax\n", + "d+9esrOzueKKK5g9ezaNjY3s3LmTI0eOJOy5nUhxngv1o4aDUhqKYaFpWh7wZfSQ0dLw7mZ0e/1L\n", + "P//5z3/v8Xj6dCYaxl2uG70J1250BTUbPeppOfqKJhW/QDq6A/rHwK/vu+++HGBGSUnJ0rS0NAdA\n", + "IBDwZGdnuz/72c8mN2YPnRB6WK4bXbH1117uJWAZMHUU5IghWhFIKWlsbOSDDz5g+fLlROe7xGNM\n", + "siaTidWrV/ORj3wEgD179rBgwYKUJvw4GbqATmBaZ2cnv/jFL5g7dy4XX3wxc+bM6VeZ+f1+nnnm\n", + "GZqamvjqV7/KQw89RFtbW5/EO4OMjAyWLl2K2+2mq6uLzs7OSKTdMJjw9aOGg3KEK4aF0+lsA/5d\n", + "07RfoOd4/CNwAbr/476CgoKETWeCwSBNTU14PB48Hg8mk4mysrJId7QE+ND7C5iBcnTH7S3JBqNP\n", + "yNXALvS8kyWcWW3Yw/sA3jOZTF8KhUIrjYzd/Px85s6dm7VkyZL+e4UOjQD6iuZK4Kv0XUFF9xX3\n", + "o5f3h76JgiONjG5rK4SguLi4TyJbPNEhqaFQiC1bttDS0sLq1asj5TeSXjCspKK7+AkhqK2ttb/y\n", + "yit2h8PBRRddFKlQm5GREaPUkj2/8MIL2bNnD/X19ZG+68no6enh7bff7lfOIdB/ffRzELXSUCQl\n", + "7Ee4An3lMf2BBx6Y1dDQkFIG8kjZ2MN40LO2g+irkB50v0IJenLe79HNUJ9Yt27dRpvNlmn0nE5U\n", + "vTQZ0b0iUsCLbv76NHq74iC6IosONWoGCpuamnjhhRcoLCz0zJs3T1RUVGQmq9I60gQCgUjCXSpN\n", + "khKZv8rKyli1alXSyrLRPProo5SXl3PZZZdFoq4OHjzIrl27uOWWWwiFQjFd76qqqrjgggsGPK+U\n", + "krq6Ourr69mxYwednZ19xhh+lBTwo4ddRyuEBeG/8UrirPNjRKPMU4phoWlaPvrd8Gp0R7JhWugE\n", + "LL/97W8/39TUVNjPKSLk5OQc+fa3v/00+o/xfKAibohErxR7EHgXeAc9amYqejTRvKi/SZ3aPp8P\n", + "j8dDfn5+K+CQUpriC+QZ3/FUO8sNIZ/Ajb5ySDirHjx4kLKyskjlVMNcVFhYKM1m85h8b41rtrW1\n", + "sXDhwj7H+nNcu1wuWltbmT17NiaTqd/PZ/PmzezatYucnBxuu+02pk3Tq7cYUVmgrwh27tzJwYMH\n", + "+eIXvxjTjvWZZ56hrKyMxYsXJzWFJfNTlJeXs3btWp588kkaGxPmrhrfuQlffXasUOYpxaDQNM2E\n", + "HnV0bfixguRRPpSUlPTpB93Q0JCwLWZeXt5c9LLlBt3oimEHejHFt51OZ0eKcuYDc7ds2fJwZmbm\n", + "gilTpmA8bDabEVKZD31zAaJXDskmu/j9xvO6ujpef/117HY7drudqVOnct555yVyWCcqWBjBmKT9\n", + "fj+hUIi0tDTDVJToxxpt0hoqoa6uLpPdbmf37t0cOHCA2tpafD4fFRUV8UojYspKpgiMzxoGVqiG\n", + "s7uzs5M//vGPfOUrX6GoqCiiAF577TU6OjpYunQpV199dZ/Xt7a2snv3bjZv3ozVaiUzM5OsrCym\n", + "TJmC3W5HSonP5yM/Px+z2YzJZIrkg+Tn55Ofn9+f32XbZEm6m8iolcY5RtjZ/Ql0JbGaWKesH70H\n", + "+xZ0c9AU9KS7UnRzTB26yaUT3R+R85e//GV+V1dXhhDCLISIRAnZ7faeW2655TnOVNvd63Q6/cOR\n", + "PVH0lpHgddFFF+FyuThw4ADNzc2RbGTjMW3aNO66666Y8/n9fk6cOGH0AY9g3BVv27aN1157LbJ/\n", + "hE1u/RIIBCIKJnqf4Q9IBa/Xy2OPPRaZ5FtaWgAoKCgwhkhAGNFJR48epb29HYfDwcyZMyOlNgZR\n", + "cDCwbt06S/QqYOrUqdx7772Rc0gpOXToEM899xy9vb2RkFuLxYLFYiEnJ4ePf/zjZGZm0tHRQVtb\n", + "G21tbezfv5+OjuT3GCaTCavVSnZ2Nm63O1l/70mTqT1WqJWGAkicT2E2m9PKyspy77777pnE1iWq\n", + "RVcSzwOvRZdR1zTtT+gKowq4KFGJdafTGXM9k8lkFkKYgsGg/4MPPvBIKX85ku8tHo/Hw+7du9m1\n", + "a1efYzabjcLCQm9BQYF/xYoV2YTv7I275erqaubNi22Z0dDQwIsvvui+8847s5cuXcrrr78eYyfv\n", + "7e3t9fl8luzsbNNgTFjBYDCy0jB8JzabTVosloQnSeQ/MCbWePoLw73nnnsi7/ehhx6itrY2OphB\n", + "gN4mddu2bcCZz2b79u0xYbwtLS3U1dVRUlJCXl5en1arhojxO5qamnj55Zf5+Mc/jslkQgjBwoUL\n", + "qa6u5m9/+1tknDHJOxwOysvLAWIyvWtra/tVGkII6fP5RBJloRhBlNI4O5lB3B15XPbrVuBZdEXx\n", + "YXwSH4CmaXcDd6M7nW8ZoCdH5HrRETgjjRDClGhlXFRURFtbW8Q0ErV/1z333FMPXG/IZkxcUsqI\n", + "wgiFQlLoUFRUxEc/+tGMjo4OcnNzmTVrFseOHYuc0+PxBLKystJSSV4LIwHx17/+lUOHzvhYi4uL\n", + "uffee5O+WEpJIBDAarXS2dkZiUQzrul2uxFCkJWVlbSIYXT5DEju03G73QmVjnFsx44dvPvuu5Hv\n", + "kFHzK7qzXjAYRAiRsGBhfX09W7Zs4frrr4+sZK6++mqqq6tpbm6OGVtbW8tPfvITgsFg0GKxSIvF\n", + "YrLb7aZAINDnvNEEg8FkJVmMbnpezvLyHmOFUhrnEF6vtxn4hNPp3N3fOE3TzuNMLaWvjmVpkWRo\n", + "mmaeOnXqwkQOzrS0NG6//XYeffRR/H4/hYWFVFZWsnjx4uXhISHAFD1pRvs5TCbTSnQH6TYhRMn8\n", + "+fMjk8/KlStjlEZeXl5m/Dna29upr6+nu7tbLl++/Ch6ZNfFRDVouv76631CCE95eXl+RUUFxcXF\n", + "MWGxYSR6LkeJEOJ8q9VKVVUV+/fv5+abb45RUnGNqBJy6tQpampqmDFjBkBCk01paSkmkymp0vj9\n", + "73/fJ1LJ+B9Em63CzYxCZrP5dHFxcens2bNNZWVlMRneAE8//TQrVqxg4cKF3HHHHRw+fBiXy4XL\n", + "5eL48eMEAgFDTrOhKPoLs02BHcokNbIopXEO0djY+GEKCsMO/BXdhLXO6XQ+PNTrlZSUXKBp2l3A\n", + "X51OZ98EjxQJh/7eX1xcXNDe3h4z+ZlMJjIzM5k+fTq33347XV1dnHfeeQghou+ETYFAICSEMEXb\n", + "1g0n+eOPP76hq6sry2q1ZoPeFjQjI4O8vDzWrl3L3/3d37Fjxw56enoIBAIhi8ViAti9ezcvv/xy\n", + "dHbytk2bNlVqmvZcePsp9JDgYHZ2tu22226Lzk5PtMoQ6KXatxg78vLyyMrScxw7OjpSLj0OMG3a\n", + "NGbMmBFZYcX7JpYsWcJNN93En//854SvDwQCSCmZPn06p06dilmt/vGPf6SkpITrrruOzs5OOjo6\n", + "KC8vN7lcrrITJ07wzjvvALpyKyoqYs6cOVxwwQVIKXnqqaf4whe+QEVFBRdddFHknMPI3g6iB1q8\n", + "n+BYzVBOqEiOUhqKCOHJ+ffAfOAD4GvDOV9aWloOsA74o6ZpH6JnfhuPPalGTwH/Anxl7dq1vvvv\n", + "v39nQUHBRzMzMzPS09OxWq0+i8XiCwQCOTNnzgR0U0lVVRXV1dXBNWvW/A2YZbFYYrLB6+vr24uK\n", + "ihxmsxmv11t0+vTphBfu7e2VZWVl4jOf+QydnZ2BvXv31i9fvry8p6eHTZs2JcsLMKrMGnU94s0m\n", + "0RFY8QUVtwCZLpeLUChEYWEhF154IaDb+wcTDtzY2Mi6deuQUpKXlxcxJQkhWLVqFVdcoVeg93g8\n", + "CSO2vF4vXV1dFBcX+y0Wi9VQGsFgkLq6Os477zwA9u/fz2uvvcb111/fp7+E2+3G7XZz7NgxDh48\n", + "GFHmjzzyCDNnzoxEZhUUFDCQCaof1GpiDFFKQxHNvcBn0M0qtwy310ZbW9thoA34CHBe+HGHcVzT\n", + "tONEKRH06K0p6OGzxt+PoocCA7R/7Wtfu4DYbGobcfWlzGbziYULF/5h4cKFa9AbMoFuMsowxpaW\n", + "lg54yy6l9KelpVnDcrlzcnLyli9fXh4IBMjIyKC0tJRTp05FxmdlZVk1TfslYKReJ0qJDxD7u0uL\n", + "O54JyFdffbXHZDJl3nDDDUydeibAbTDO9+jOdIa/Jj8/P7hs2TJzRUUFoVCIrVu3Hm1pabGjJyj2\n", + "eT1AS0tLnZRyBlGrIyEEixYtAuDAgQMEg0GeeeYZd05OTiN6bk0famtrI3kbRrXZaNNfPxh+iWzO\n", + "waZHEw2lNM5Oaga5H03T0tDDawG+7HQ6Dw/3ep2dnTVOp/MuTdMy0RP8LqiqqvpWXl5eSX5+frbZ\n", + "bJ6Ffld+c4rX6a92VD3wNnq71QrOvBeDaCVxHHhyw4YNN7S3t/eppWVgMpms6ArtVvTqu5/xeDy/\n", + "ywrbixYvXuwrLi4OzZ4921JWVmax2+2XckZJJSPpb+6DDz6gubmZEydOeE+cOOG32Wxs3bqVj3/8\n", + "48leor+xKJNVsrwZgDVr1kB40g0GgyGz2fz9VatWNRw7duxbPT09eTabLc1qtUZWMw0NeouVnJyc\n", + "mfEFAhcsWIDdbqe1tZWoVVpGZ2dnSTI5jQTDIWCmb7OjDs70sqgZykkVQ0PlaSgA0DTtevQGQweA\n", + "8xJFVI0ERq6FyWSisLCQ4uJiSkpKmD59eqi0tHSglO1u9KzxZvT6VdHZ4snKj/vQS0PUoPccBzjf\n", + "6XTuN2TJyspKWFPLyMtwu92++vr6k1ar1ZaVlVVQUFCQOYwOdKeB76OveB6MljmRTX/WrFnccYe+\n", + "OEulWu3DDz88rNLp0ZFazz//PCdOnKCoqIh9+/ZFTHEWi4WSkhJMJhMejyeS/2Gz2ZIqrCEQFEK4\n", + "zGZzXiAQSJTsqHIuRgCVp6EYDp8L/31stBRGNKFQiMbGRhobG9m7dy8VFRWmu+++uwt4dceOHSUt\n", + "LS3Z3d3dQZvNtsjv91tOnz59IBgMHvnud7/bAtxOXDXZjRs3mtrb22UoFAqYTCZrKBTymUwmm8Ph\n", + "sK1du3Yperc+gxc1Tbvc2EhUZtvA7/eTnZ1tmzt37txEx4PBID6fj8zMzDb0FrLb0Is8fh5dYaUR\n", + "6/QuBf6Efvds7JfAevQ6VjEYVWaBSKitETn16quvctlll0UyoAdSZC6XC9DzHzweDx0dHVgsFgoK\n", + "CjCZTLS1tfH8889z3XXXkZuby7XXXsuRI0eCr7322j4pZaRAVCAQoLa2ts/5Q6FQvOltOLSEQqHi\n", + "ZOX4FeOHUhoKNE3L5sxd+GPjIUNTU9Me4CNOp9MfnihWxA1ZXFFRsThquxo9MfEK4GhLS8u0U6dO\n", + "ZXDGoWsD6O3t7UQvvz6HM5N0CXD0a1/7mr+uro4jR45EGvOEQiHMZjPNzc00Nzfz5z//OZJbEAqF\n", + "CAQCzJgxg4qKChYsWEAwGOSRRx55v7GxcT8ww2w23zxt2rQV4QncFk6Q86BXwf2vpqamKYWFhRYj\n", + "z+Po0aNy+/bth0+ePNldUlIS03N64cKFzJ8/P+ZDOHXqVJuUsrGurm7G4cOH02tqarjnnnsiFWaT\n", + "YaxSPB4Pubm5ZGVlcfLkyUhJkc7OTh544IGIH2T58uVceeWVfPDBB2ar1TpQRcEQ0OX3+1OpJNzH\n", + "Wa6YXCiloQC9c18G8KbT6awZDwF6eno6UigzItFNOr9wOp1V4ZpULmBaQ0PDHuCS+BekpaXlbNy4\n", + "Mae9vT2SrHfeeedhNpspKCiwFhQUsGzZMkKhEMePH+fgwYPMmzePnTt3cuLEiYipJzobub6+nnfe\n", + "eYdvfetb5OTksGbNmkVPPPGEqaenZ1kwGOTkyZORsUIICWxED70VDocDIQStra04HA7mzp0rZs+e\n", + "veDYsWP5W7dutYEeRrxq1SpWrlyJECKm2N/8+fPzgLwFCxbwsY99jN7e3sgKIyMjA4fDgd/vj/gZ\n", + "jH15eXmR2kwGhsIIhUJIKbnttttoaWmhvb2d9vZ2/vKXv9De3h5ZofSDib4+h2S4UxyrSpJPUJTS\n", + "UIB+tw4gNE3LGk5OxWgSDAZ7gW85nU7DcN6GvoooMplM5kQ9n10u14etra2mrq6uBaC3EN29ezd3\n", + "3HEHb7/9Nrm5ub1lZWVpDocDo5x6IBBg69atSeUQQjBlyhSeeuopHA4HK1euTJ86deqyEydOYLPZ\n", + "KCsro7y83HgIdFMVoCci7t+/n40bN5Kbm8vKlStZtmwZc+fOnbpjxw7S09O5/fbbmT59esSHsG3b\n", + "togzfOPGjTQ0NASEEBar1RrJ8jZKftx4442YTCZ+9rOf0dPTE3m0tbXx4IMPRhTHJZdcQmZmJj6f\n", + "D5vNRm5ubkSpRrNu3bpUlMZoUjPI/YpRRikNBcCvgE9u3Ljx0qamptP/+q//uj9snzYYyZ4CNYPc\n", + "H8FsNtvQw4J/pWlaOnpOSRFAguxqANxut1GnwuiXwIkTJyINhk6cOJEGkJuby9y5c1m8eDEzZsyI\n", + "9IJIhJQyUv6io6OD9vZ2enp6KCkpIS0tjUAgQFtbG5WVlcZLDJNM6Mknn2w5ePDgVIC2tjY2b97M\n", + "c889h8VikYFAQJjNZv7yl7+Qn58fs4IwaG9vp7Gxsc/v1lhZrFq1CofDwbe//W3q6uoUNeJFAAAM\n", + "MElEQVR49tlng62trWav10t9fT1Gc6qamhq++MUvYjab+c///E/S09PJz8/H4XDEPIZRFsaPHrgA\n", + "egkPY+VQxpmoJ9A7GSZdeagS5hMPpTQUOJ3ODzRNW+lyufbV19fnAJeN1rVGYBL4P5qmvQA8ip7/\n", + "0Q3c0dvb+/XBnGTXrl3k5+dHEus6Ojp47733eO+998jOzk6pXzfovSESleDo7OzkySefpKGhgZyc\n", + "HHMoFOptbm4+4PV6S+PHhkIhent7hfHc7/dHl87oWLRo0YmOjo6K3NzcpJOr3++nubkZh8NBb2+v\n", + "TEtLEzNnziQ7O9ucaKVQW1vL7373O9LT0wkEAhEfziAYyDexM5XoJuXonnwopaEAwOl0Vv3bv/3b\n", + "bvRkuvGmJtHOjIyMRUAheuMmE3ASuNHpdO697777bujnXDMSHWhtbe2hb3Idbre7k9Rt9AkxSnob\n", + "z8PXuQA9vyBlHA5Hy6233voloOSVV1551O/325ONtVqtdHV18eCDDwqz2cyiRYvo7e1NOrkPMWfC\n", + "IFXfxEDUDHK/YpxReRqKCP3c9U2ImHhN076HXpvJ+F+3A/8N/NrpdCY1vCd7X1lZWd0ejydRxE8H\n", + "kDtlyhSys7P7rYeULDfB6EWRgEZinbz9mmemT5/OtGnT6O7uTlrNFvQ6U4sWLeLtt9+mqyumIPFI\n", + "RysZSXVl6P1Vksk/Ib4ziv5ReRqKsxZN074E/DS8+Sx6Ut8lgBP4jqZpDwD/5XQ6ExWRqonfccEF\n", + "FxQcPnx4cYKxmM3m7LVr1zJ//nysVis//vGP6e3tTSiXz+eLCZM1yMzMlF1dXYl+jIeiJ9OBzDNC\n", + "CCorK9m8eXOH2+3uQp+s+2CxWLjsssuYMWMGTzzxRLTiGKzCMJRCSj2zE/VuMcYN8rqKSYJSGooJ\n", + "SfRklJ2dXThlypRFAH6//91Tp07dEC6ueDnwQ/ROhP8IfF3TtPuB7zmdzogjP96PEs5+3/jzn/88\n", + "4bXT09PNS5bo1UWqq6sjCsNkMoWsVqtJShny+/3dUkojyqyP0ujq6krW32FQeDwebDYbq1evTv/d\n", + "7373AUmUhsvloquri7/97W/k5ubi8/mSKroB2DOYFYJyVJ97KPOUIkJ/d41jPTkMxlSmadpy4AfA\n", + "pzZu3CgaGhpam5qaDkgpo0N/aqSUd2madgN69nXar3/96zqXy9VnEi4uLg7OmDHDfOjQoRgnt8lk\n", + "2vYv//IvhcBC0Os3Pf7448Hq6mpLMBhM9fu3NW6l8TB6nkxSE9WcOXPw+/14PB5/S0tLorCuDpvN\n", + "Zp4/f352R0fHUMuLJ5RPcXajzFOKYTFZ7xqdTucu4BZN0y5tbW3d2tjYmI++ColgMpkumDp16urS\n", + "0tKicAvT37hcriUkuHNvaGhoaWho6JNcFgqFaoAvAN8FrjCbzed//vOfN/XTByK6qJ5BTfSGlPKu\n", + "OGXdx0dQXV1t+EfiFYZx/hqfz8fBgwdnZWZmXkxsFeBoguj92kE3P6UTGw7bRz6FIh6lNBRnDU6n\n", + "c+ePf/zj3ehd82IIhUI5zc3NORkZGRLdpPUz4LUkpzo0wN321wGys7N3lJWVXRbf2S6KlEw9cT6C\n", + "N+i/VW+/5x/AR+JWqwjFcFFKQ3FW0dvb228PkPr6+nedTudPAe67775hXcvj8QQOHx5MBfmUqEmw\n", + "r98Iq0HgHXiIQtE/Smkozin8fn90Vb+aJMOS7R91EpkIRzABTtVzUgwbpTQUE5WaQe4fNKPow4n4\n", + "Gkbp/P1Rwxl/RTRelL9CMQIopaGYkAxjQq8J/x0pk04q1+qzf4QVUtLrxO+YrMEMismDCrlVnJVM\n", + "pPBhhWKiMpS5UykNhUKhOEcZytw5UE9mhUKhUCgiKKWhUCgUipQZF6UhhPi0EOKAECIohLiwn3Gr\n", + "hRCHhBBHhBDfG0sZFQqFQtGX8Vpp7AfWAtuSDRBCmIH7gdXAIuCzQoiFYyNeRIbKsbzeSDDZZJ5s\n", + "8oKSeSyYbPLC5JR5KIyL0pBSHpJSVg0w7CPAUSlljZTSDzwB3DT60sVQOcbXGwkqx1uAQVI53gIM\n", + "gcrxFmAIVI63AIOkcrwFGAKV4y3AWDCRfRrTgNqo7brwPoVCoVCME6OW3CeEeBkoTnDoh1LKzSmc\n", + "YvLHAisUCsVZxrjmaQghXgf+UUr5foJjHwXuk1KuDm//AAhJKf89wVilYBQKhWIITMZ+GskEfg+Y\n", + "K4SYAZwGbgM+m2igSuxTKBSKsWG8Qm7XCiFqgY8Czwkhng/vLxVCPAcgpQwAXwNeBD4EnpRSHhwP\n", + "eRUKhUKhc1aUEVEoFArF2DCRo6fGHCFEvhDiZSFElRDiJSGEo5+xZiHEbiFEKk79USMVmYUQ5UKI\n", + "18MJlR8IIb4xDnIOmKgphPhV+PheIcQFYy1jAnn6lVkI8bmwrPuEEG8KIc4fDzmj5EkpGVYIcbEQ\n", + "IiCE+NRYypdEllS+F5Xh39oH4d4i40oK34sCIcQLQog9YZnvGgcxDVn+JIRoFELs72fM4H53Ukr1\n", + "CD/QW4D+U/j594Cf9jP228D/ApsmuszoUWzLws+zgcPAwjGU0QwcRa86a0XvNbEwbswaYEv4+Qrg\n", + "7XH+XFOR+RIgN/x89XjKnIq8UeNeA54Fbp4En7EDOACUhbcLJoHM9wE/MeQFXIBlnOS9HLgA2J/k\n", + "+KB/d2qlEcuNwCPh548An0w0SAhRhv5h/5HkjvyxYkCZpZQNUso94edu4CBQOmYSppaoGXkfUsp3\n", + "AIcQomgMZYxnQJmllG9JKTvCm+8AZWMsYzSpJsN+HVgPNI+lcElIRebbgaeklHUAUsqWMZYxnlRk\n", + "rgdyws9zAJfUfbRjjpRyO9DWz5BB/+6U0oilSErZGH7eCCT78H4BfBcIjYlU/ZOqzACEo9EuQJ/k\n", + "xopUEjUTjRnPSXiwyaVfBLaMqkT9M6C8Qohp6BPc78K7xtuhmcpnPBfID5tX3xNCfGHMpEtMKjL/\n", + "AVgshDgN7AW+OUayDYVB/+4mQsjtmNJP0uE/R29IKWWi/A8hxPVAk5Ry91jVmhmuzFHnyUa/y/xm\n", + "eMUxVqQ6OcWv2sZzUkv52kKIVcA9wGWjJ86ApCLvL4Hvh78ngvFfJacisxW4ELgayATeEkK8LaU8\n", + "MqqSJScVmX8I7JFSVgohZgMvCyGWSim7Rlm2oTKo3905pzSklNckOxZ2GBVLKRuEECVAU4JhlwI3\n", + "CiHWoPdhzhFC/I+U8o5REnkkZEYIYQWeAv4spXx6lERNximgPGq7HP2Opr8xZeF940UqMhN2fv8B\n", + "WC2l7M8MMNqkIu9y4AldX1AAXCuE8EspN42NiH1IReZaoEVK2QP0CCG2AUuB8VIaqch8KfAjACnl\n", + "MSFENTAfPfdsojHo350yT8WyCbgz/PxOoM/kKqX8oZSyXEo5E/gM8NpoKowUGFDm8F3lQ8CHUspf\n", + "jqFsBpFETSFEGnqiZvxEtQm4AyLVANqjzG7jwYAyCyGmAxuAz0spj46DjNEMKK+UcpaUcmb4u7se\n", + "+PtxVBiQ2vfiGWBlOFoxE91Z++EYyxlNKjIfAj4GEPYPzAeOj6mUqTP43914ePQn6gPIB14BqoCX\n", + "AEd4fynwXILxVzL+0VMDygysRPe/7AF2hx+rx1jOa9Gjto4CPwjvuxe4N2rM/eHje4ELJ8D3oV+Z\n", + "0QMhXFGf6d8msrxxY9cBn5ron3F4+zvoEVT7gW9MdJnRV3Gbw9/j/cDt4yjr4+gVNXrRV233DPd3\n", + "p5L7FAqFQpEyyjylUCgUipRRSkOhUCgUKaOUhkKhUChSRikNhUKhUKSMUhoKhUKhSBmlNBQKhUKR\n", + "MkppKBQjTLgU/XEhRF54Oy+8PX28ZVMohotSGgrFCCOlrEUvCvjT8K6fAg9KKU+On1QKxcigkvsU\n", + "ilFACGEBdqFnXn8RvZ9JcHylUiiGzzlXsFChGAuklAEhxD8BzwPXKIWhOFtQ5imFYvS4Fr3uz3nj\n", + "LYhCMVIopaFQjAJCiGXolU4vAf5BCJGoH4pCMelQSkOhGGHCpeh/h97sqhb4OfAf4yuVQjEyKKWh\n", + "UIw8XwJqpJSvhrd/CywUQlw+jjIpFCOCip5SKBQKRcqolYZCoVAoUkYpDYVCoVCkjFIaCoVCoUgZ\n", + "pTQUCoVCkTJKaSgUCoUiZZTSUCgUCkXKKKWhUCgUipRRSkOhUCgUKfP/ABqW6g4LJdxHAAAAAElF\n", + "TkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Random dataset\n", + "random_motors = environment.random_motors(n=1000)\n", + "\n", + "%pylab inline\n", + "ax = axes()\n", + "for m in random_motors:\n", + " environment.plot_arm(ax, m)\n", + " \n", + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])\n", + "\n", + "for m in random_motors:\n", + " s = environment.compute_sensori_effect(m)\n", + " model.update(m, s)\n", + " \n", + "testing_couples = {}\n", + "testing_m = environment.random_motors(n=30)\n", + "for i in range (len(testing_m):#m in testing_m:\n", + " testing_couples[] = environment.compute_sensori_effect(m)\n", + "\n", + "distance = {}" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFcZJREFUeJzt3Xu0pXV93/H3d2bwgo6OFLkIY8YIMRCNIilBIXpEscPU\n", + "4qXRBGNFSA1NF5AmbeOtqw/PH1kxaZsQZNVSL4iJC6yxtSjjBYQjJI0kqCAqBIgcGCSOBYGCoOHy\n", + "7R/PM7Bnzj7n/M6Zc/Zv7zPv11p77f08z2/2/sxZZ+/Pea47MhNJkkqsqR1AkjQ5LA1JUjFLQ5JU\n", + "zNKQJBWzNCRJxSwNSVKxqqURER+NiO0Rcf08Y86JiJsj4rqIOGKU+SRJO6u9pnE+sHmuhRGxBTgk\n", + "Mw8FfgP44KiCSZJmq1oamXkVcM88Q04ELujHXg1siIj9R5FNkjRb7TWNhRwEbBuYvgM4uFIWSdrj\n", + "jXtpAMQu0173RJIqWVc7wAK+B2wcmD64n7eTiLBIJGkJMnPXP8znNe6lcTFwOnBRRBwN3JuZ24cN\n", + "XOx/vEREnJWZZy33866kScs8aXnBzKMwaXlhYjMv+g/uqqURERcCrwT2jYhtQAPsBZCZ52Xm1ojY\n", + "EhG3AD8CTqmXVpJUtTQy86SCMaePIoskaWGTsCO8punaAZZgunaARZquHWAJpmsHWILp2gEWabp2\n", + "gCWYrh1gFGI1fAlTRORK7NOQpNVsKZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilUtjYjYHBE3RsTNEfGuIcunIuK+iPhGf/sPNXJKkjrrar1wRKwFzgVeA3wP+JuI\n", + "uDgzb9hl6Fcy88SRB5QkzVJzTeMo4JbMnMnMh4GLgNcPGRejjSVJmkvN0jgI2DYwfUc/b1ACL4+I\n", + "6yJia0QcPrJ0kqRZqm2eoiuEhXwd2JiZD0bECcBngJ8ZNjAizhqYnM7M6d1OKEmrSERMAVO79RyZ\n", + "JZ/dyy8ijgbOyszN/fR7gMcy8w/m+Te3Akdm5g93mZ+Z6WYsSVqEpXx21tw8dQ1waERsiognAb8C\n", + "XDw4ICL2j4joHx9FV3I/nP1UkqRRqLZ5KjMfiYjTgS8Ca4GPZOYNEXFav/w84JeB34yIR4AHgV+t\n", + "lVeSVHHz1HJy85QkLd6kbZ6SJE0YS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWrWhoRsTkiboyImyPiXXOMOadffl1EHDHqjJKkJ1QrjYhYC5wLbAYOB06KiMN2\n", + "GbMFOCQzDwV+A/jgyINqRUTEloj4QkRM9/dbameStLB1cy2IiM8D/zozb12h1z4KuCUzZ/rXuwh4\n", + "PXDDwJgTgQsAMvPqiNgQEftn5vYVyqQR6AviT4BDBmY/PyLIzK2VYkkqMN+axkeBL0bE+yJirxV4\n", + "7YOAbQPTd/TzFhpz8Apk0Widyc6FQT99RoUskhZhzjWNzPxUv7bxH4FrIuJPgXxicf7Rbr52LjwE\n", + "gCj5dxFx1sDkdGZOLyGTRuMpw2but99+R7Zt+1rgy03TPDriTNKqFxFTwNTuPMecpdF7GHiA7k2+\n", + "Hnhsd15sF98DNg5Mb6Rbk5hvzMH9vFky86xlzKaV9eNhM9evX/9s4IvAtrZtPwZ8rGma744ymLSa\n", + "9X9MT++Yjohmsc8RmcP/4I+IzcAfAZ8F2sx8cEkp53rhiHXA3wKvBu4E/ho4KTNvGBizBTg9M7dE\n", + "xNHA2Zl59JDnyszcdY1EY2rYPo01a9bcdtxxx1157LHHHgs8b2D4NN2m0k83TbOsv4PSnm4pn53z\n", + "lcZVwL/KzG8vR7g5XuME4GxgLfCRzPz9iDgNIDPP68fsOMLqR8Apmfn1Ic9jaUyYvjjOAJ4KPAR8\n", + "IDO3tm27BngFcCrwy/1ygPuBC4HzgaubpindvClpDstdGpFzLRwzlsbq1LbtM4G30BXI4BrmDXRr\n", + "H3/aNI1H0klLtKylMUksjdWvbdvDgVOAtwP79bMfBS6hK5CtTdM8XCmeNJEsDa16bdvuBZxAt/bx\n", + "OrpNmwA/AD4OnN80zXcqxZMmiqWhPUrbtgcAb6MrkMGrCVxNt/bxyaZp7quRTZoElob2SG3bBt0V\n", + "Bk4FTqI7PBy6HeyfpiuQrzRNs5yHjEsTz9LQHq9t272BN9EVyKsGFt1Kd+TVBU3T3F4jmzRuLA1p\n", + "QNu2Pw28o7/tOEk0gcvo1j4+0zTN0BMNpT2BpSEN0bbtWuA4urWPNwJP7hfdC3yCbg3k6577oT2N\n", + "pSEtoG3bfej2e5wCHDmw6Jt0ax+faJrmrhrZpFGzNKRFaNv2xXTl8TbgH/WzHwYupiuQLzVN80il\n", + "eNKKszSkJWjb9snAP6MrkM088ZUBd9J9n8v5TdPcXCmetGIsDWk3tW17EN1Z56ey83d+/AXd2sen\n", + "mqZ5oEY2ablZGtIy6c/9OIauPN4CPK1f9CPgf9AVyF+681yTzNKQVkDbtuuBN9MVyDEDi26mK4+P\n", + "N01zZ41s0u6wNKQV1rbtC+jO+zgZOLCf/RjwBboC+WzTNP9QJ520OJaGNCJt264DXku39nEisFe/\n", + "6C7gz+h2nn+zUjypiKUhVdC27bOBX6MrkBcNLPoa3drHhU3T3FMjmzQfS0OqqN95fiTdobtvBTb0\n", + "i34C/C+6AvmyF07UuLA0pDHRtu1TgTfQFchrgB2/n7cDHwM+1jTNrXXSSR1LQxpDbdv+FN2O81OA\n", + "TQOLPgGc3DTNozVySZaGNMbatl0DTNGVx5vpLpz4iqZprqqZS3uupXx2rlupMJJ21u/LuBy4vG3b\n", + "e4AzgOMBS0MTY83CQyStgEv7++OrppAWydKQ6pgGHgGOatt2wwJjpbFhaUgVNE1zP/BVuvfgqxYY\n", + "Lo0NS0Oqx01UmjiWhlSPpaGJY2lI9fwNcB9wSNu2m+pGkcpYGlIl/VfJXtFPurahiWBpSHW5iUoT\n", + "xdKQ6tpRGq9u23Zt1SRSAUtDqusW4DZgH+CIylmkBVkaUkX9d4y7iUoTw9KQ6rM0NDEsDam+LwMJ\n", + "HNO27d61w0jzsTSkypqmuZvuq2GfBLyichxpXpaGNB7cRKWJYGlI48HS0ESwNKTx8H+AB4EXtW17\n", + "QO0w0lwsDWkMNE3zE+DKfvI1NbNI87E0pPHhJiqNPUtDGh+Pl0bbtlE1iTQHS0MaH98Cvg8cCBxe\n", + "OYs0lKUhjYn+kiKX9ZNuotJYsjSk8eJ+DY01S0MaLzvWNF7Ztu2TqiaRhrA0pDHSNM2dwE3A04Cf\n", + "qxxHmsXSkMbPzf39T1VNIQ2xrsaLRsQ+wCfp3hQzwFsy894h42aA/wc8CjycmUeNMKZUy0x/v6li\n", + "BmmoWmsa7wYuzcyfobss9LvnGJfAVGYeYWFoDzLT32+qmEEaqlZpnAhc0D++AHjDPGM9yUl7mpn+\n", + "flPFDNJQtUpj/8zc3j/eDuw/x7gELouIayLinaOJJlU3099vqphBGmrF9mlExKXAsKt1vm9wIjMz\n", + "InKOpzkmM/8+Ip4NXBoRN2bmVXO83lkDk9OZOb2E2NI4mOnvN1XMoFUoIqaAqd16jsy5Pq9XTkTc\n", + "SLev4vsRcSBwRWb+7AL/pgEeyMz/MmRZZqabsbQq9Nedup/usNtnNU0z6yARaTks5bOz1uapi4GT\n", + "+8cnA5/ZdUBE7B0R6/vHTwNeC1w/soRSJf3lRGb6yU31kkiz1SqN9wPHR8RNwHH9NBHxnIi4pB9z\n", + "AHBVRFwLXA18LjO/VCWtNHoz/f2mihmkWaqcp5GZP2TIF81k5p3AP+0ffxd4yYijSeNipr/fVDGD\n", + "NItnhEvjaaa/31QxgzSLpSGNp5n+flPFDNIsloY0nmb6+00VM0izWBrSeJrp7zdVzCDNYmlI4+lu\n", + "4EfAM9u23VA7jLSDpSGNIc/V0LiqcsitpCIzdF/EdEnbtluBrcBlTdPcXzWV9mhVLiOy3LyMiFaj\n", + "tm1fB/x34MCB2Q8DV9EVyFbgxn6tRFq0pXx2WhrSGOuvQ/ViYEt/exk7b1ae4YkCuaJpmgdHnVGT\n", + "y9KQVrm2bfehuw7bFuAEYN+BxT8BrqArkM83TXPL6BNqklga0h6kbds1wC/wxFrIL7Dzl5bdzBNr\n", + "IVc2TfPjkYfUWLM0pD1Y27b7Af+ErkA2A4OH6j5I99XKW4FPNU1z9+gTatxYGpIAaNt2HfCLPLEW\n", + "Mnjxz4eAjwNnN01zY4V4GhOWhqSh2rY9iG7t4810ayM7XAL8MXC5R2HteSwNSQtq2/Yw4N8Abwee\n", + "0s/+Jl15XNg0zU9qZdNoWRqSirVt+2zgNOB0YP9+9nbgXOC/NU1zV61sGg1LQ9KitW37ZOAk4LeB\n", + "n+9n/5huv8d5wG3AfU3TPFInoVaKpSFpyfoTCY8Dfodu5/muHgDuAe7tb4OPfwh8rmmar40mrZaD\n", + "pSFpWbRt+7N0+z2OB55Fd/huyXvsL84999xH7rrrrjXArh8uM5n5jmUNqt1iaUhaEf2JhOvpymMD\n", + "TxTJjtvz6XasP+P888/ntttuG/Y0X8nMqZEEVhFLQ1I1bduuB07+8Ic//Id33HHHU4cMsTTGjKUh\n", + "qbqImAZeOWSRpTFmlvLZ6fdpSKvUCyO2bIQz18NT7ocfb4NzvpW5tXYuTTZLQ1qFXhix5WXwJx+C\n", + "Q3bMeyc8/4URWBzaHZaGtApthDMHCwPgQ3DIFjiD7qKFK2lmkfM1QSwNaRVa/8TlQXbydBi2g3pZ\n", + "eVjt6rZm4SGSJs393RndszzQXeFWWjJLQ1qFtsE574SdvrnvX8Lf3Q4fqJVJq4OH3Eqr1AsjtjwX\n", + "zng6PPUBeOh2+IA7wTXI8zQkScWW8tnp5ilJUjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQV\n", + "szQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxaqURkS8OSK+HRGPRsRL\n", + "5xm3OSJujIibI+Jdo8woSZqt1prG9cAbgSvnGhARa4Fzgc3A4cBJEXHYaOI9nmFqlK+3HCYt86Tl\n", + "BTOPwqTlhcnMvBRVSiMzb8zMmxYYdhRwS2bOZObDwEXA61c+3U6mRvx6y2GqdoBFmqodYAmmagdY\n", + "gqnaARZpqnaAJZiqHWAUxnmfxkHAtoHpO/p5kqRK1q3UE0fEpcABQxa9NzM/W/AUucyRJEm7KTLr\n", + "fTZHxBXAv83Mrw9ZdjRwVmZu7qffAzyWmX8wZKwFI0lLkJmxmPErtqaxCHMFvgY4NCI2AXcCvwKc\n", + "NGzgYv/TkqSlqXXI7RsjYhtwNHBJRHy+n/+ciLgEIDMfAU4Hvgh8B/hkZt5QI68kqVN185QkabKM\n", + "89FTIxcR+0TEpRFxU0R8KSI2zDN2bUR8IyJKduqvmJLMEbExIq7oT6j8VkScWSHngidqRsQ5/fLr\n", + "IuKIUWcckmfezBHxa33Wb0bEX0bEz9fIOZCn6GTYiPjHEfFIRLxplPnmyFLyezHVv9e+FRHTI444\n", + "LM9Cvxf7RsQXIuLaPvM7KsTckeWjEbE9Iq6fZ8zi3neZ6a2/AX8I/G7/+F3A++cZ+zvAJ4CLxz0z\n", + "3VFsL+kfPx34W+CwEWZcC9wCbAL2Aq7d9fWBLcDW/vEvAl+t/HMtyfwy4Jn94801M5fkHRh3OfA5\n", + "4J9PwM94A/Bt4OB+et8JyHwW8Ps78gJ3A+sq5f0l4Ajg+jmWL/p955rGzk4ELugfXwC8YdigiDiY\n", + "7of9YebekT8qC2bOzO9n5rX94weAG4DnjCxh2Ymaj/8/MvNqYENE7D/CjLtaMHNm/lVm3tdPXg0c\n", + "POKMg0pPhj0D+HPg/44y3BxKMr8V+HRm3gGQmXeNOOOuSjL/PfCM/vEzgLuz20c7cpl5FXDPPEMW\n", + "/b6zNHa2f2Zu7x9vB+b64f0x8O+Bx0aSan6lmQHoj0Y7gu5DblRKTtQcNqbmh/BiTy79dWDriiaa\n", + "34J5I+Igug+4D/azau/QLPkZHwrs029evSYi/sXI0g1XkvlDwM9FxJ3AdcBvjSjbUiz6fTcOh9yO\n", + "1DwnHb5vcCIzc9j5HxHxOuAHmfmNUV1rZnczDzzP0+n+yvytfo1jVEo/nHZda6v5oVb82hHxKuBU\n", + "4JiVi7OgkrxnA+/uf0+C+mvJJZn3Al4KvBrYG/iriPhqZt68osnmVpL5vcC1mTkVEc8HLo2IF2fm\n", + "/SucbakW9b7b40ojM4+fa1m/w+iAzPx+RBwI/GDIsJcDJ0bEFuApwDMi4uOZ+fYVirwcmYmIvYBP\n", + "A3+WmZ9Zoahz+R6wcWB6I91fNPONObifV0tJZvqd3x8CNmfmfJsBVlpJ3iOBi7q+YF/ghIh4ODMv\n", + "Hk3EWUoybwPuysyHgIci4krgxUCt0ijJ/HLg9wAy8+8i4lbgBXTnno2bRb/v3Dy1s4uBk/vHJwOz\n", + "Plwz872ZuTEznwf8KnD5ShZGgQUz939VfgT4TmaePcJsOzx+omZEPInuRM1dP6guBt4Oj18N4N6B\n", + "zW41LJg5Ip4L/E/gbZl5S4WMgxbMm5k/nZnP6393/xz4zYqFAWW/F/8bOLY/WnFvup213xlxzkEl\n", + "mW8EXgPQ7x94AfDdkaYst/j3XY09+uN6A/YBLgNuAr4EbOjnPwe4ZMj4V1L/6KkFMwPH0u1/uRb4\n", + "Rn/bPOKcJ9AdtXUL8J5+3mnAaQNjzu2XXwe8dAx+H+bNTHcgxN0DP9O/Hue8u4w9H3jTuP+M++l/\n", + "R3cE1fXAmeOemW4t7rP97/H1wFsrZr2Q7ooa/0C31nbq7r7vPLlPklTMzVOSpGKWhiSpmKUhSSpm\n", + "aUiSilkakqRiloYkqZilIS2z/lL0342IZ/XTz+qnn1s7m7S7LA1pmWXmNrqLAr6/n/V+4LzMvL1e\n", + "Kml5eHKftAIiYh3wNbozr3+d7vtMHq2bStp9e9wFC6VRyMxHIuJ3gc8Dx1sYWi3cPCWtnBPorvvz\n", + "otpBpOViaUgrICJeQnel05cBvx0Rw74PRZo4loa0zPpL0X+Q7suutgH/CfjPdVNJy8PSkJbfO4GZ\n", + "zPxyP/1fgcMi4pcqZpKWhUdPSZKKuaYhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaG\n", + "JKnY/wfSP/dwYGt2YAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NN TEST\n", + "for m in testing_couples\n", + " \n", + "sTest_pred = model.forward_prediction(mTest)\n", + "distance[\"NN\"] = abs(sTest_pred-sTest)\n", + "\n", + "%pylab inline\n", + "ax = axes()\n", + "environment.plot_arm(ax, mTest)\n", + "ax.plot(*sTest_pred, marker='o', color='red')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.65232833 -0.78444065 -0.07154134 0.98469259 -0.20240519 0.59945435\n", + " -0.5925971 ]\n", + "[ 0.54220714 0.79929109]\n", + "['NN']\n" + ] + } + ], + "source": [ + "sensorimotor_models.keys()\n", + "print mTest\n", + "print sTest\n", + "print distance.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.56816432 -0.60892505]\n", + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFbpJREFUeJzt3XuUpHV95/H3dxi8oOjIIiAXM0aIgWgUyRIQIi2Kzsxm\n", + "8bLRBGNEyIUkB8wmuxtve/bh+WNPTHY3QcNZw/GCmHjAGHfdUQYUhBZykQQVRGXCTKRxkDguCCwI\n", + "Gi7f/eN5hqmZqe7+dU93/apm3q9z6lQ9z/Obqs/06apPP9eKzESSpBIrageQJE0OS0OSVMzSkCQV\n", + "szQkScUsDUlSMUtDklSsamlExEciYmtE3DLHmPdHxKaIuDkijh1lPknSjmqvaVwMrJltYUSsA47M\n", + "zKOA3wA+MKpgkqRdVS2NzLweuHeOIacDl/RjbwBWRcTBo8gmSdpV7TWN+RwGbBmYvhM4vFIWSdrr\n", + "jXtpAMRO0173RJIqWVk7wDy+AxwxMH14P28HEWGRSNIiZObOf5jPadxLYz1wLnBZRJwA3JeZW4cN\n", + "XOh/vEREnJ+Z5y/18y6nScs8aXnBzKMwaXlhYjMv+A/uqqUREZcCpwAHRsQWoAH2BcjMizJzQ0Ss\n", + "i4jNwA+As+qllSRVLY3MPKNgzLmjyCJJmt8k7Aivabp2gEWYrh1ggaZrB1iE6doBFmG6doAFmq4d\n", + "YBGmawcYhdgTvoQpInI59mlI0p5sMZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilUtjYhYExEbI2JTRLxjyPKpiLg/Ir7a3/5zjZySpM7KWi8cEfsAFwKvAr4D/ENE\n", + "rM/MW3ca+sXMPH3kASVJu6i5pnE8sDkzZzLzEeAy4LVDxsVoY0mSZlOzNA4DtgxM39nPG5TAyyLi\n", + "5ojYEBHHjCydJGkX1TZP0RXCfL4CHJGZD0XEWuDTwE8MGxgR5w9MTmfm9G4nlKQ9SERMAVO79RyZ\n", + "JZ/dSy8iTgDOz8w1/fS7gMcz8w/n+De3A8dl5vd3mp+Z6WYsSVqAxXx21tw8dSNwVESsjognAb8I\n", + "rB8cEBEHR0T0j4+nK7nv7/pUkqRRqLZ5KjMfjYhzgc8B+wAfzsxbI+KcfvlFwC8AvxURjwIPAb9U\n", + "K68kqeLmqaXk5ilJWrhJ2zwlSZowloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", + "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", + "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", + "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", + "pGKWhiSpmKUhSSpWtTQiYk1EbIyITRHxjlnGvL9ffnNEHDvqjJKk7aqVRkTsA1wIrAGOAc6IiKN3\n", + "GrMOODIzjwJ+A/jAyINqWUTEuoi4MiKm+/t1tTNJmt/K2RZExBXAb2fm7cv02scDmzNzpn+9y4DX\n", + "ArcOjDkduAQgM2+IiFURcXBmbl2mTBqBviDeBxw5MPv5EUFmbqgUS1KBudY0PgJ8LiLeExH7LsNr\n", + "HwZsGZi+s58335jDlyGLRuvt7FgY9NPnVcgiaQFmXdPIzE/2axv/BbgxIv4cyO2L849387Vz/iEA\n", + "RMm/i4jzByanM3N6EZk0Gk8ZNvOggw46rm3bVwNfaJrmsRFnkvZ4ETEFTO3Oc8xaGr1HgAfp3uT7\n", + "A4/vzovt5DvAEQPTR9CtScw15vB+3i4y8/wlzKbl9cNhM/fff/9nA58DtrRt+1Hgo03TfGuUwaQ9\n", + "Wf/H9PS26YhoFvockTn8D/6IWAP8MfAZoM3MhxaVcrYXjlgJ/CPwSuAu4O+BMzLz1oEx64BzM3Nd\n", + "RJwAXJCZJwx5rszMnddINKaG7dNYsWLFHaeeeup1J5988snA8waGT9NtKv1U0zRL+jso7e0W89k5\n", + "V2lcD/xmZn5jKcLN8hprgQuAfYAPZ+YfRMQ5AJl5UT9m2xFWPwDOysyvDHkeS2PC9MVxHvBU4GHg\n", + "TzNzQ9u2K4CXA2cDv9AvB3gAuBS4GLihaZrSzZuSZrHUpRE528IxY2nsmdq2fSbwJroCGVzDvJVu\n", + "7ePPm6bxSDppkZa0NCaJpbHna9v2GOAs4K3AQf3sx4DL6QpkQ9M0j1SKJ00kS0N7vLZt9wXW0q19\n", + "/Dzdpk2A7wEfAy5umuableJJE8XS0F6lbdtDgLfQFcjg1QRuoFv7+ETTNPfXyCZNAktDe6W2bYPu\n", + "CgNnA2fQHR4O3Q72T9EVyBebplnKQ8aliWdpaK/Xtu1+wBvoCuQVA4tupzvy6pKmab5dI5s0biwN\n", + "aUDbtj8OvK2/bTtJNIGr6dY+Pt00zdATDaW9gaUhDdG27T7AqXRrH68Hntwvug/4ON0ayFc890N7\n", + "G0tDmkfbtgfQ7fc4CzhuYNHX6NY+Pt40zd01skmjZmlIC9C27YvpyuMtwL/qZz8CrKcrkM83TfNo\n", + "pXjSsrM0pEVo2/bJwL+lK5A1bP/KgLvovs/l4qZpNlWKJy0bS0PaTW3bHkZ31vnZ7PidH39Nt/bx\n", + "yaZpHqyRTVpqloa0RPpzP06iK483AU/rF/0A+Eu6Avkbd55rklka0jJo23Z/4I10BXLSwKJNdOXx\n", + "saZp7qqRTdodloa0zNq2fQHdeR9nAs/pZz8OXElXIJ9pmuZf6qSTFsbSkEakbduVwKvp1j5OB/bt\n", + "F90N/AXdzvOvVYonFbE0pAratn028Mt0BfKigUVfplv7uLRpmntrZJPmYmlIFfU7z4+jO3T3zcCq\n", + "ftGPgP9NVyBf8MKJGheWhjQm2rZ9KvA6ugJ5FbDt9/PbwEeBjzZNc3uddFLH0pDGUNu2P0a34/ws\n", + "YPXAoo8DZzZN81iNXJKlIY2xtm1XAFN05fFGugsnvrxpmutr5tLeazGfnSuXK4ykHfX7Mq4Brmnb\n", + "9l7gPOA0wNLQxFgx/xBJy+Cq/v60qimkBbI0pDqmgUeB49u2XTXPWGlsWBpSBU3TPAB8ie49+Ip5\n", + "hktjw9KQ6nETlSaOpSHVY2lo4lgaUj3/ANwPHNm27eq6UaQyloZUSf9Vstf2k65taCJYGlJdbqLS\n", + "RLE0pLq2lcYr27bdp2oSqYClIdW1GbgDOAA4tnIWaV6WhlRR/x3jbqLSxLA0pPosDU0MS0Oq7wtA\n", + "Aie1bbtf7TDSXCwNqbKmae6h+2rYJwEvrxxHmpOlIY0HN1FpIlga0niwNDQRLA1pPPwt8BDworZt\n", + "D6kdRpqNpSGNgaZpfgRc10++qmYWaS6WhjQ+3ESlsWdpSOPjidJo2zaqJpFmYWlI4+PrwHeB5wDH\n", + "VM4iDWVpSGOiv6TI1f2km6g0liwNaby4X0NjzdKQxsu2NY1T2rZ9UtUk0hCWhjRGmqa5C7gNeBrw\n", + "U5XjSLuwNKTxs6m//7GqKaQhVtZ40Yg4APgE3ZtiBnhTZt43ZNwM8P+Ax4BHMvP4EcaUapnp71dX\n", + "zCANVWtN453AVZn5E3SXhX7nLOMSmMrMYy0M7UVm+vvVFTNIQ9UqjdOBS/rHlwCvm2OsJzlpbzPT\n", + "36+umEEaqlZpHJyZW/vHW4GDZxmXwNURcWNE/PpooknVzfT3qytmkIZatn0aEXEVMOxqne8ZnMjM\n", + "jIic5WlOysx/johnA1dFxMbMvH6W1zt/YHI6M6cXEVsaBzP9/eqKGbQHiogpYGq3niNzts/r5RMR\n", + "G+n2VXw3Ip4DXJuZPznPv2mABzPzfwxZlpnpZiztEfrrTj1Ad9jts5qm2eUgEWkpLOazs9bmqfXA\n", + "mf3jM4FP7zwgIvaLiP37x08DXg3cMrKEUiX95URm+snV9ZJIu6pVGu8FTouI24BT+2ki4tCIuLwf\n", + "cwhwfUTcBNwAfDYzP18lrTR6M/396ooZpF1UOU8jM7/PkC+aycy7gH/TP/4W8JIRR5PGxUx/v7pi\n", + "BmkXnhEujaeZ/n51xQzSLiwNaTzN9PerK2aQdmFpSONppr9fXTGDtAtLQxpPM/396ooZpF1YGtJ4\n", + "ugf4AfDMtm1X1Q6zlF4YsW5txJVvipheG3HlCyPW1c6kcpaGNIb21HM1Xhix7kR43xXwmr+EU66A\n", + "15wI77M4JkeVM8KXmmeEa0/Utu1n6Q5BvwvY0N+ubprmgarBdsPaiCuvgNfsPH8dXLkhc22NTHuz\n", + "xXx2VjlPQ1KRPwNeChwK/Fp/e6Rt2+vZXiIb+7WSibA/PGXY/KfDU0edRYvjmoY0xvrrUL0YWNff\n", + "TmTHzcozbC+Qa5umeWjUGRfCNY3xspjPTktDmiBt2x5Adx22dcBa4MCBxT8CrqUrkCuaptk8+oRz\n", + "27ZP44Nw5LZ5vwb/9CV4+9czN9TMtjeyNKS9SNu2K4CfYftayM+w45eWbWL7Wsh1TdP8cOQhh3hh\n", + "xLrnwnlPh6c+CA9/G/7UwqjD0pD2Ym3bHkS36WcdsAYYPFT3IbqvVt4AfLJpmntGn1DjxtKQBEDb\n", + "tiuBn2X7WsjgxT8fBj4GXNA0zcYK8TQmLA1JQ7Vtexjd2scb2XFH9OXAnwDXTNJRWFoaloakebVt\n", + "ezTw74G3sv0Q2K/RlcelTdP8qFY2jZalIalY27bPBs4BzgUO7mdvBS4E/qxpmrtrZdNoWBqSFqxt\n", + "2ycDZwC/C/x0P/uHdPs9LgLuAO5vmubROgm1XCwNSYvWn0h4KvB7dDvPd/YgcC9wX38bfPx94LNN\n", + "03x5NGm1FCwNSUuibdufpNvvcRrwLLrDd0veY3994YUXPnr33XevAHb+cJnJzLctaVDtFktD0rLo\n", + "TyTcn648VrG9SLbdnk+3Y/0ZF198MXfcccewp/liZk6NJLCKWBqSqmnbdn/gzA996EN/dOeddw67\n", + "AKGlMWYsDUnVRcQ0cMqQRZbGmFnMZ6dfwiRJKmZpSJKK+SVMkpbazALna4K4T0OS9lLu05AkLStL\n", + "Q5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFL\n", + "Q5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScWqlEZEvDEivhERj0XES+cYtyYiNkbEpoh4\n", + "xygzSpJ2VWtN4xbg9cB1sw2IiH2AC4E1wDHAGRFx9GjiPZFhapSvtxQmLfOk5QUzj8Kk5YXJzLwY\n", + "VUojMzdm5m3zDDse2JyZM5n5CHAZ8NrlT7eDqRG/3lKYqh1ggaZqB1iEqdoBFmGqdoAFmqodYBGm\n", + "agcYhXHep3EYsGVg+s5+niSpkpXL9cQRcRVwyJBF787MzxQ8RS5xJEnSborMep/NEXEt8B8y8ytD\n", + "lp0AnJ+Za/rpdwGPZ+YfDhlrwUjSImRmLGT8sq1pLMBsgW8EjoqI1cBdwC8CZwwbuND/tCRpcWod\n", + "cvv6iNgCnABcHhFX9PMPjYjLATLzUeBc4HPAN4FPZOatNfJKkjpVN09JkibLOB89NXIRcUBEXBUR\n", + "t0XE5yNi1Rxj94mIr0ZEyU79ZVOSOSKOiIhr+xMqvx4Rb6+Qc94TNSPi/f3ymyPi2FFnHJJnzswR\n", + "8ct91q9FxN9ExE/XyDmQp+hk2Ij41xHxaES8YZT5ZslS8nsx1b/Xvh4R0yOOOCzPfL8XB0bElRFx\n", + "U5/5bRVibsvykYjYGhG3zDFmYe+7zPTW34A/An6/f/wO4L1zjP094OPA+nHPTHcU20v6x08H/hE4\n", + "eoQZ9wE2A6uBfYGbdn59YB2woX/8s8CXKv9cSzKfCDyzf7ymZuaSvAPjrgE+C/y7CfgZrwK+ARze\n", + "Tx84AZnPB/5gW17gHmBlpbw/BxwL3DLL8gW/71zT2NHpwCX940uA1w0bFBGH0/2wP8TsO/JHZd7M\n", + "mfndzLypf/wgcCtw6MgSlp2o+cT/IzNvAFZFxMEjzLizeTNn5t9l5v395A3A4SPOOKj0ZNjzgL8C\n", + "/u8ow82iJPObgU9l5p0AmXn3iDPurCTzPwPP6B8/A7gnu320I5eZ1wP3zjFkwe87S2NHB2fm1v7x\n", + "VmC2H96fAP8JeHwkqeZWmhmA/mi0Y+k+5Eal5ETNYWNqfggv9OTSXwU2LGuiuc2bNyIOo/uA+0A/\n", + "q/YOzZKf8VHAAf3m1Rsj4ldGlm64kswfBH4qIu4CbgZ+Z0TZFmPB77txOOR2pOY46fA9gxOZmcPO\n", + "/4iInwe+l5lfHdW1ZnY388DzPJ3ur8zf6dc4RqX0w2nntbaaH2rFrx0RrwDOBk5avjjzKsl7AfDO\n", + "/vckqL+WXJJ5X+ClwCuB/YC/i4gvZeamZU02u5LM7wZuysypiHg+cFVEvDgzH1jmbIu1oPfdXlca\n", + "mXnabMv6HUaHZOZ3I+I5wPeGDHsZcHpErAOeAjwjIj6WmW9dpshLkZmI2Bf4FPAXmfnpZYo6m+8A\n", + "RwxMH0H3F81cYw7v59VSkpl+5/cHgTWZOddmgOVWkvc44LKuLzgQWBsRj2Tm+tFE3EVJ5i3A3Zn5\n", + "MPBwRFwHvBioVRolmV8G/FeAzPyniLgdeAHduWfjZsHvOzdP7Wg9cGb/+Exglw/XzHx3Zh6Rmc8D\n", + "fgm4ZjkLo8C8mfu/Kj8MfDMzLxhhtm2eOFEzIp5Ed6Lmzh9U64G3whNXA7hvYLNbDfNmjojnAv8L\n", + "eEtmbq6QcdC8eTPzxzPzef3v7l8Bv1WxMKDs9+L/ACf3RyvuR7ez9psjzjmoJPNG4FUA/f6BFwDf\n", + "GmnKcgt/39XYoz+uN+AA4GrgNuDzwKp+/qHA5UPGn0L9o6fmzQycTLf/5Sbgq/1tzYhzrqU7amsz\n", + "8K5+3jnAOQNjLuyX3wy8dAx+H+bMTHcgxD0DP9O/H+e8O429GHjDuP+M++n/SHcE1S3A28c9M91a\n", + "3Gf63+NbgDdXzHop3RU1/oVure3s3X3feXKfJKmYm6ckScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ1pi/aXovxURz+qnn9VPP7d2Nml3WRrSEsvMLXQXBXxvP+u9wEWZ+e16qaSl4cl90jKIiJXA\n", + "l+nOvP5Vuu8zeaxuKmn37XUXLJRGITMfjYjfB64ATrMwtKdw85S0fNbSXffnRbWDSEvF0pCWQUS8\n", + "hO5KpycCvxsRw74PRZo4loa0xPpL0X+A7suutgD/DfjvdVNJS8PSkJberwMzmfmFfvp/AkdHxM9V\n", + "zCQtCY+ekiQVc01DklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxSwNSVKx/w8QfuxjT/fu\n", + "yQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#KNN TEST\n", + "model = SensorimotorModel.from_configuration(environment.conf, 'WNN', 'default')\n", + "\n", + "for m in random_motors:\n", + " s = environment.compute_sensori_effect(m)\n", + " # compute the sensori effect s of the motor command m through the environment\n", + " model.update(m, s)\n", + " \n", + "sTest_pred = model.forward_prediction(mTest)\n", + "print sTest_pred\n", + "distance[\"WNN\"] = abs(sTest_pred-sTest)\n", + "\n", + "%pylab inline\n", + "ax = axes()\n", + "environment.plot_arm(ax, mTest)\n", + "ax.plot(*sTest_pred, marker='o', color='red')\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 064faf836316dc17a35dfcee023c742c4d281678 Mon Sep 17 00:00:00 2001 From: Roxane Date: Mon, 1 Feb 2016 18:28:27 +0100 Subject: [PATCH 02/13] WIP comparing sensorimotor models --- ...g_sensorimotor_models_non_parametric.ipynb | 887 ++++++++++++++++++ 1 file changed, 887 insertions(+) create mode 100644 notebook/comparing_sensorimotor_models_non_parametric.ipynb diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb new file mode 100644 index 0000000..dba66c6 --- /dev/null +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -0,0 +1,887 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Comparison between learning sensorimotor models \n", + "## Part 1 : non parametric models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, we compare the different sensorimotor models used in explauto in order to help the reader to use the most appropriate model depending on his aim. The notebook is split in two parts : non parametrics models (this notebook) and models based on gaussian mixtures (coming soon). There is also a tutorial explaining how to use the [SensorimotorModel abstract class](http://flowersteam.github.io/explauto/explauto.sensorimotormodel.html#explauto.sensorimotor_model.sensorimotor_model.SensorimotorModel) ([learning_sensorimotor_models](http://nbviewer.ipython.org/github/flowersteam/explauto/blob/master/notebook/learning_sensorimotor_models.ipynb)).\n", + "\n", + "As explained in the [Explauto introduction](http://flowersteam.github.io/explauto/about.html), an important challenge in Developmental Robotics is how robots can efficiently learn sensorimotor mappings by experience, i.e. the mappings between the motor actions they make and the sensory effects they produce. This can be a robot learning how arm movements make physical objects move, or how movements of a virtual vocal tract modulates vocalization sounds.\n", + "\n", + "Let's begin with defining a simple environment that will be used to test the sensorimotor models." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from explauto import Environment\n", + "environment = Environment.from_configuration('simple_arm', 'low_dimensional')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sensorimotor models introduction\n", + "\n", + "In Explauto, a sensorimotor model implements both the iterative learning process from sensorimotor experience, i.e. from the iterative collection of $(m, s)$ pairs by interaction with the environment, and the use of the resulting internal model to perform forward and inverse predictions (or any kind of general prediction between sensorimotor subspaces). \n", + "\n", + "Learning sensorimotor mappings involves machine learning algorithms, for which Explauto provides a unified interface through the [SensorimotorModel abstract class](http://flowersteam.github.io/explauto/explauto.sensorimotormodel.html#explauto.sensorimotor_model.sensorimotor_model.SensorimotorModel). \n", + "\n", + "Using the simple arm environment above, it allows to iteratively learn a sensorimotor model which will be able to:\n", + "* infer the position of the end-effector from a given motor command, what is called *forward prediction*,\n", + "* infer the motor command allowing to reach a particular end-effector position, what is called *inverse prediction*.\n", + "* update online from sensorimotor experience" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Decision tree\n", + "\n", + "In order to use the most appropriate model, there are several questions that have to be asked before using the following decision tree. The following paragraphs focus on these questions.\n", + "\n", + "*Add the decision tree*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Non parametric or gaussian mixture models ? \n", + "\n", + "Each of non parametric model is currently based on the nearest neigbhor look up. They are non paramtric models because they don't rely on assomptions that the data are drown from a given probability while gassian mixture models (GMM) assumes that the data points are generated from a mixture of a finite number of Gaussian distributions with unknown parameters. Thus, the last model can be used only with gaussian distributed data. Readers in this case should refer to the follwing tutorial : *coming soom* ." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Presentation of the different non parametric models\n", + "\n", + "Available non parametric sensorimotor models in Explauto can be accessed using: " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available sensorimotor models: ['LWLR-BFGS', 'nearest_neighbor', 'WNN', 'LWLR-CMAES']\n" + ] + } + ], + "source": [ + "from explauto.sensorimotor_model import sensorimotor_models\n", + "print 'Available sensorimotor models: {}'.format(sensorimotor_models.keys())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These 4 models are a combination of a forward and an inverse model:\n", + "* the **nearest neighbor** model searches the nearest point of a given input ($m$ or $s$) in the dataset and returns its corresponding value (respectively $s$ or $m$)\n", + "* the **WNN or weighted nearest neighbor** model searches the $k$ nearest points of a given input ($m$ or $s$) in the dataset and returns the average of the $k$ corresponding values (respectively $m$ or $s$)\n", + "* the **LWLR or The Locally Weigthed Linear Regression (LWLR)** offers two inverses model for the same forward one. The forward computes a linear regression of the $k$ nearest neighbors of $m$ and find the requested $s$ with the given $m$ based on that regression. Both inverse models are optimisation algorithm that minimize the error $e(m) = ||LWLR(m) - s_g||^2$ where $s_g$ is the goal, $LWLR$ is the forward model LWLR, and $m$ is the motor command to be infered. Both **LWLR-BFGS** and **LWLR-CMAES** use LWLR forward model to predict $s$ but LWLR-BFGF uses Broyden–Fletcher–Goldfarb–Shanno algorithm and LWLR-CMAES covariance matrix adaptation which are going to be explained later.\n", + "Let's see which of these 8 *(2 * 4)* possibilities is the best" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward or inverse model ?\n", + "\n", + "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward models comparison\n", + "For each model : \n", + "* Output descrptions\n", + "* Processing description\n", + "* When should it (or not) be used\n", + "* Time processing\n", + "* Distance between sg et s" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from scipy import spatial\n", + "import time\n", + "\n", + "#Environment definition\n", + "from explauto.environment.environment import Environment\n", + "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", + "\n", + "from explauto.sensorimotor_model import sensorimotor_models\n", + "from explauto import SensorimotorModel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Nearest Neighbor forward model\n", + "\n", + "\n", + "To perform a forward prediction, the Nearest Neighbor model just looks in the dataset of tuples $(m, s)$ for the nearest neighbor of the given $m$ motor command, and returns its corresponding $s$.\n", + "The algorithm comes from scipy library : [scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html) (with x = $s_g$, k=1, eps = 0, p = 2, radius = +inf). It returns distance and indexes of found nearest neighbors.\n", + "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. \n", + "\n", + "Let's see how to use it and its results :" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "#Creation of the dataset\n", + "random_motors = environment.random_motors(n=1000)\n", + " \n", + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])\n", + "\n", + "for m in random_motors:\n", + " s = environment.compute_sensori_effect(m)\n", + " model.update(m, s)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "#Test of the model\n", + "test = environment.random_motors(n=50)\n", + "distance = []\n", + "timer = []\n", + "\n", + "for mTest in test :\n", + " start = time.time()\n", + " sTest_pred = model.forward_prediction(mTest)\n", + " end = time.time()\n", + " sTest_eff = environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", + " timer.append(end - start)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.24177072005089387, 0.16694489498320747, 0.70232748022294833, 0.00026514530181884763, 0.00027393861162125976, 0.002167940139770508]\n" + ] + } + ], + "source": [ + "# Distance between the predictive and effectiv value\n", + "comparison = {}\n", + "comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)]\n", + "print comparison['NN']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#DRAFT bac a sable" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFcZJREFUeJzt3Xu0pXV93/H3d2bwgo6OFLkIY8YIMRCNIilBIXpEscPU\n", + "4qXRBGNFSA1NF5AmbeOtqw/PH1kxaZsQZNVSL4iJC6yxtSjjBYQjJI0kqCAqBIgcGCSOBYGCoOHy\n", + "7R/PM7Bnzj7n/M6Zc/Zv7zPv11p77f08z2/2/sxZZ+/Pea47MhNJkkqsqR1AkjQ5LA1JUjFLQ5JU\n", + "zNKQJBWzNCRJxSwNSVKxqqURER+NiO0Rcf08Y86JiJsj4rqIOGKU+SRJO6u9pnE+sHmuhRGxBTgk\n", + "Mw8FfgP44KiCSZJmq1oamXkVcM88Q04ELujHXg1siIj9R5FNkjRb7TWNhRwEbBuYvgM4uFIWSdrj\n", + "jXtpAMQu0173RJIqWVc7wAK+B2wcmD64n7eTiLBIJGkJMnPXP8znNe6lcTFwOnBRRBwN3JuZ24cN\n", + "XOx/vEREnJWZZy33866kScs8aXnBzKMwaXlhYjMv+g/uqqURERcCrwT2jYhtQAPsBZCZ52Xm1ojY\n", + "EhG3AD8CTqmXVpJUtTQy86SCMaePIoskaWGTsCO8punaAZZgunaARZquHWAJpmsHWILp2gEWabp2\n", + "gCWYrh1gFGI1fAlTRORK7NOQpNVsKZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilUtjYjYHBE3RsTNEfGuIcunIuK+iPhGf/sPNXJKkjrrar1wRKwFzgVeA3wP+JuI\n", + "uDgzb9hl6Fcy88SRB5QkzVJzTeMo4JbMnMnMh4GLgNcPGRejjSVJmkvN0jgI2DYwfUc/b1ACL4+I\n", + "6yJia0QcPrJ0kqRZqm2eoiuEhXwd2JiZD0bECcBngJ8ZNjAizhqYnM7M6d1OKEmrSERMAVO79RyZ\n", + "JZ/dyy8ijgbOyszN/fR7gMcy8w/m+Te3Akdm5g93mZ+Z6WYsSVqEpXx21tw8dQ1waERsiognAb8C\n", + "XDw4ICL2j4joHx9FV3I/nP1UkqRRqLZ5KjMfiYjTgS8Ca4GPZOYNEXFav/w84JeB34yIR4AHgV+t\n", + "lVeSVHHz1HJy85QkLd6kbZ6SJE0YS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWrWhoRsTkiboyImyPiXXOMOadffl1EHDHqjJKkJ1QrjYhYC5wLbAYOB06KiMN2\n", + "GbMFOCQzDwV+A/jgyINqRUTEloj4QkRM9/dbameStLB1cy2IiM8D/zozb12h1z4KuCUzZ/rXuwh4\n", + "PXDDwJgTgQsAMvPqiNgQEftn5vYVyqQR6AviT4BDBmY/PyLIzK2VYkkqMN+axkeBL0bE+yJirxV4\n", + "7YOAbQPTd/TzFhpz8Apk0Widyc6FQT99RoUskhZhzjWNzPxUv7bxH4FrIuJPgXxicf7Rbr52LjwE\n", + "gCj5dxFx1sDkdGZOLyGTRuMpw2but99+R7Zt+1rgy03TPDriTNKqFxFTwNTuPMecpdF7GHiA7k2+\n", + "Hnhsd15sF98DNg5Mb6Rbk5hvzMH9vFky86xlzKaV9eNhM9evX/9s4IvAtrZtPwZ8rGma744ymLSa\n", + "9X9MT++Yjohmsc8RmcP/4I+IzcAfAZ8F2sx8cEkp53rhiHXA3wKvBu4E/ho4KTNvGBizBTg9M7dE\n", + "xNHA2Zl59JDnyszcdY1EY2rYPo01a9bcdtxxx1157LHHHgs8b2D4NN2m0k83TbOsv4PSnm4pn53z\n", + "lcZVwL/KzG8vR7g5XuME4GxgLfCRzPz9iDgNIDPP68fsOMLqR8Apmfn1Ic9jaUyYvjjOAJ4KPAR8\n", + "IDO3tm27BngFcCrwy/1ygPuBC4HzgaubpindvClpDstdGpFzLRwzlsbq1LbtM4G30BXI4BrmDXRr\n", + "H3/aNI1H0klLtKylMUksjdWvbdvDgVOAtwP79bMfBS6hK5CtTdM8XCmeNJEsDa16bdvuBZxAt/bx\n", + "OrpNmwA/AD4OnN80zXcqxZMmiqWhPUrbtgcAb6MrkMGrCVxNt/bxyaZp7quRTZoElob2SG3bBt0V\n", + "Bk4FTqI7PBy6HeyfpiuQrzRNs5yHjEsTz9LQHq9t272BN9EVyKsGFt1Kd+TVBU3T3F4jmzRuLA1p\n", + "QNu2Pw28o7/tOEk0gcvo1j4+0zTN0BMNpT2BpSEN0bbtWuA4urWPNwJP7hfdC3yCbg3k6577oT2N\n", + "pSEtoG3bfej2e5wCHDmw6Jt0ax+faJrmrhrZpFGzNKRFaNv2xXTl8TbgH/WzHwYupiuQLzVN80il\n", + "eNKKszSkJWjb9snAP6MrkM088ZUBd9J9n8v5TdPcXCmetGIsDWk3tW17EN1Z56ey83d+/AXd2sen\n", + "mqZ5oEY2ablZGtIy6c/9OIauPN4CPK1f9CPgf9AVyF+681yTzNKQVkDbtuuBN9MVyDEDi26mK4+P\n", + "N01zZ41s0u6wNKQV1rbtC+jO+zgZOLCf/RjwBboC+WzTNP9QJ520OJaGNCJt264DXku39nEisFe/\n", + "6C7gz+h2nn+zUjypiKUhVdC27bOBX6MrkBcNLPoa3drHhU3T3FMjmzQfS0OqqN95fiTdobtvBTb0\n", + "i34C/C+6AvmyF07UuLA0pDHRtu1TgTfQFchrgB2/n7cDHwM+1jTNrXXSSR1LQxpDbdv+FN2O81OA\n", + "TQOLPgGc3DTNozVySZaGNMbatl0DTNGVx5vpLpz4iqZprqqZS3uupXx2rlupMJJ21u/LuBy4vG3b\n", + "e4AzgOMBS0MTY83CQyStgEv7++OrppAWydKQ6pgGHgGOatt2wwJjpbFhaUgVNE1zP/BVuvfgqxYY\n", + "Lo0NS0Oqx01UmjiWhlSPpaGJY2lI9fwNcB9wSNu2m+pGkcpYGlIl/VfJXtFPurahiWBpSHW5iUoT\n", + "xdKQ6tpRGq9u23Zt1SRSAUtDqusW4DZgH+CIylmkBVkaUkX9d4y7iUoTw9KQ6rM0NDEsDam+LwMJ\n", + "HNO27d61w0jzsTSkypqmuZvuq2GfBLyichxpXpaGNB7cRKWJYGlI48HS0ESwNKTx8H+AB4EXtW17\n", + "QO0w0lwsDWkMNE3zE+DKfvI1NbNI87E0pPHhJiqNPUtDGh+Pl0bbtlE1iTQHS0MaH98Cvg8cCBxe\n", + "OYs0lKUhjYn+kiKX9ZNuotJYsjSk8eJ+DY01S0MaLzvWNF7Ztu2TqiaRhrA0pDHSNM2dwE3A04Cf\n", + "qxxHmsXSkMbPzf39T1VNIQ2xrsaLRsQ+wCfp3hQzwFsy894h42aA/wc8CjycmUeNMKZUy0x/v6li\n", + "BmmoWmsa7wYuzcyfobss9LvnGJfAVGYeYWFoDzLT32+qmEEaqlZpnAhc0D++AHjDPGM9yUl7mpn+\n", + "flPFDNJQtUpj/8zc3j/eDuw/x7gELouIayLinaOJJlU3099vqphBGmrF9mlExKXAsKt1vm9wIjMz\n", + "InKOpzkmM/8+Ip4NXBoRN2bmVXO83lkDk9OZOb2E2NI4mOnvN1XMoFUoIqaAqd16jsy5Pq9XTkTc\n", + "SLev4vsRcSBwRWb+7AL/pgEeyMz/MmRZZqabsbQq9Nedup/usNtnNU0z6yARaTks5bOz1uapi4GT\n", + "+8cnA5/ZdUBE7B0R6/vHTwNeC1w/soRSJf3lRGb6yU31kkiz1SqN9wPHR8RNwHH9NBHxnIi4pB9z\n", + "AHBVRFwLXA18LjO/VCWtNHoz/f2mihmkWaqcp5GZP2TIF81k5p3AP+0ffxd4yYijSeNipr/fVDGD\n", + "NItnhEvjaaa/31QxgzSLpSGNp5n+flPFDNIsloY0nmb6+00VM0izWBrSeJrp7zdVzCDNYmlI4+lu\n", + "4EfAM9u23VA7jLSDpSGNIc/V0LiqcsitpCIzdF/EdEnbtluBrcBlTdPcXzWV9mhVLiOy3LyMiFaj\n", + "tm1fB/x34MCB2Q8DV9EVyFbgxn6tRFq0pXx2WhrSGOuvQ/ViYEt/exk7b1ae4YkCuaJpmgdHnVGT\n", + "y9KQVrm2bfehuw7bFuAEYN+BxT8BrqArkM83TXPL6BNqklga0h6kbds1wC/wxFrIL7Dzl5bdzBNr\n", + "IVc2TfPjkYfUWLM0pD1Y27b7Af+ErkA2A4OH6j5I99XKW4FPNU1z9+gTatxYGpIAaNt2HfCLPLEW\n", + "Mnjxz4eAjwNnN01zY4V4GhOWhqSh2rY9iG7t4810ayM7XAL8MXC5R2HteSwNSQtq2/Yw4N8Abwee\n", + "0s/+Jl15XNg0zU9qZdNoWRqSirVt+2zgNOB0YP9+9nbgXOC/NU1zV61sGg1LQ9KitW37ZOAk4LeB\n", + "n+9n/5huv8d5wG3AfU3TPFInoVaKpSFpyfoTCY8Dfodu5/muHgDuAe7tb4OPfwh8rmmar40mrZaD\n", + "pSFpWbRt+7N0+z2OB55Fd/huyXvsL84999xH7rrrrjXArh8uM5n5jmUNqt1iaUhaEf2JhOvpymMD\n", + "TxTJjtvz6XasP+P888/ntttuG/Y0X8nMqZEEVhFLQ1I1bduuB07+8Ic//Id33HHHU4cMsTTGjKUh\n", + "qbqImAZeOWSRpTFmlvLZ6fdpSKvUCyO2bIQz18NT7ocfb4NzvpW5tXYuTTZLQ1qFXhix5WXwJx+C\n", + "Q3bMeyc8/4URWBzaHZaGtApthDMHCwPgQ3DIFjiD7qKFK2lmkfM1QSwNaRVa/8TlQXbydBi2g3pZ\n", + "eVjt6rZm4SGSJs393RndszzQXeFWWjJLQ1qFtsE574SdvrnvX8Lf3Q4fqJVJq4OH3Eqr1AsjtjwX\n", + "zng6PPUBeOh2+IA7wTXI8zQkScWW8tnp5ilJUjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQV\n", + "szQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxaqURkS8OSK+HRGPRsRL\n", + "5xm3OSJujIibI+Jdo8woSZqt1prG9cAbgSvnGhARa4Fzgc3A4cBJEXHYaOI9nmFqlK+3HCYt86Tl\n", + "BTOPwqTlhcnMvBRVSiMzb8zMmxYYdhRwS2bOZObDwEXA61c+3U6mRvx6y2GqdoBFmqodYAmmagdY\n", + "gqnaARZpqnaAJZiqHWAUxnmfxkHAtoHpO/p5kqRK1q3UE0fEpcABQxa9NzM/W/AUucyRJEm7KTLr\n", + "fTZHxBXAv83Mrw9ZdjRwVmZu7qffAzyWmX8wZKwFI0lLkJmxmPErtqaxCHMFvgY4NCI2AXcCvwKc\n", + "NGzgYv/TkqSlqXXI7RsjYhtwNHBJRHy+n/+ciLgEIDMfAU4Hvgh8B/hkZt5QI68kqVN185QkabKM\n", + "89FTIxcR+0TEpRFxU0R8KSI2zDN2bUR8IyJKduqvmJLMEbExIq7oT6j8VkScWSHngidqRsQ5/fLr\n", + "IuKIUWcckmfezBHxa33Wb0bEX0bEz9fIOZCn6GTYiPjHEfFIRLxplPnmyFLyezHVv9e+FRHTI444\n", + "LM9Cvxf7RsQXIuLaPvM7KsTckeWjEbE9Iq6fZ8zi3neZ6a2/AX8I/G7/+F3A++cZ+zvAJ4CLxz0z\n", + "3VFsL+kfPx34W+CwEWZcC9wCbAL2Aq7d9fWBLcDW/vEvAl+t/HMtyfwy4Jn94801M5fkHRh3OfA5\n", + "4J9PwM94A/Bt4OB+et8JyHwW8Ps78gJ3A+sq5f0l4Ajg+jmWL/p955rGzk4ELugfXwC8YdigiDiY\n", + "7of9YebekT8qC2bOzO9n5rX94weAG4DnjCxh2Ymaj/8/MvNqYENE7D/CjLtaMHNm/lVm3tdPXg0c\n", + "POKMg0pPhj0D+HPg/44y3BxKMr8V+HRm3gGQmXeNOOOuSjL/PfCM/vEzgLuz20c7cpl5FXDPPEMW\n", + "/b6zNHa2f2Zu7x9vB+b64f0x8O+Bx0aSan6lmQHoj0Y7gu5DblRKTtQcNqbmh/BiTy79dWDriiaa\n", + "34J5I+Igug+4D/azau/QLPkZHwrs029evSYi/sXI0g1XkvlDwM9FxJ3AdcBvjSjbUiz6fTcOh9yO\n", + "1DwnHb5vcCIzc9j5HxHxOuAHmfmNUV1rZnczDzzP0+n+yvytfo1jVEo/nHZda6v5oVb82hHxKuBU\n", + "4JiVi7OgkrxnA+/uf0+C+mvJJZn3Al4KvBrYG/iriPhqZt68osnmVpL5vcC1mTkVEc8HLo2IF2fm\n", + "/SucbakW9b7b40ojM4+fa1m/w+iAzPx+RBwI/GDIsJcDJ0bEFuApwDMi4uOZ+fYVirwcmYmIvYBP\n", + "A3+WmZ9Zoahz+R6wcWB6I91fNPONObifV0tJZvqd3x8CNmfmfJsBVlpJ3iOBi7q+YF/ghIh4ODMv\n", + "Hk3EWUoybwPuysyHgIci4krgxUCt0ijJ/HLg9wAy8+8i4lbgBXTnno2bRb/v3Dy1s4uBk/vHJwOz\n", + "Plwz872ZuTEznwf8KnD5ShZGgQUz939VfgT4TmaePcJsOzx+omZEPInuRM1dP6guBt4Oj18N4N6B\n", + "zW41LJg5Ip4L/E/gbZl5S4WMgxbMm5k/nZnP6393/xz4zYqFAWW/F/8bOLY/WnFvup213xlxzkEl\n", + "mW8EXgPQ7x94AfDdkaYst/j3XY09+uN6A/YBLgNuAr4EbOjnPwe4ZMj4V1L/6KkFMwPH0u1/uRb4\n", + "Rn/bPOKcJ9AdtXUL8J5+3mnAaQNjzu2XXwe8dAx+H+bNTHcgxN0DP9O/Hue8u4w9H3jTuP+M++l/\n", + "R3cE1fXAmeOemW4t7rP97/H1wFsrZr2Q7ooa/0C31nbq7r7vPLlPklTMzVOSpGKWhiSpmKUhSSpm\n", + "aUiSilkakqRiloYkqZilIS2z/lL0342IZ/XTz+qnn1s7m7S7LA1pmWXmNrqLAr6/n/V+4LzMvL1e\n", + "Kml5eHKftAIiYh3wNbozr3+d7vtMHq2bStp9e9wFC6VRyMxHIuJ3gc8Dx1sYWi3cPCWtnBPorvvz\n", + "otpBpOViaUgrICJeQnel05cBvx0Rw74PRZo4loa0zPpL0X+Q7suutgH/CfjPdVNJy8PSkJbfO4GZ\n", + "zPxyP/1fgcMi4pcqZpKWhUdPSZKKuaYhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaG\n", + "JKnY/wfSP/dwYGt2YAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NN TEST\n", + "for m in testing_couples\n", + " \n", + "sTest_pred = model.forward_prediction(mTest)\n", + "distance[\"NN\"] = abs(sTest_pred-sTest)\n", + "\n", + "%pylab inline\n", + "ax = axes()\n", + "environment.plot_arm(ax, mTest)\n", + "ax.plot(*sTest_pred, marker='o', color='red')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFcZJREFUeJzt3Xu0pXV93/H3d2bwgo6OFLkIY8YIMRCNIilBIXpEscPU\n", + "4qXRBGNFSA1NF5AmbeOtqw/PH1kxaZsQZNVSL4iJC6yxtSjjBYQjJI0kqCAqBIgcGCSOBYGCoOHy\n", + "7R/PM7Bnzj7n/M6Zc/Zv7zPv11p77f08z2/2/sxZZ+/Pea47MhNJkkqsqR1AkjQ5LA1JUjFLQ5JU\n", + "zNKQJBWzNCRJxSwNSVKxqqURER+NiO0Rcf08Y86JiJsj4rqIOGKU+SRJO6u9pnE+sHmuhRGxBTgk\n", + "Mw8FfgP44KiCSZJmq1oamXkVcM88Q04ELujHXg1siIj9R5FNkjRb7TWNhRwEbBuYvgM4uFIWSdrj\n", + "jXtpAMQu0173RJIqWVc7wAK+B2wcmD64n7eTiLBIJGkJMnPXP8znNe6lcTFwOnBRRBwN3JuZ24cN\n", + "XOx/vEREnJWZZy33866kScs8aXnBzKMwaXlhYjMv+g/uqqURERcCrwT2jYhtQAPsBZCZ52Xm1ojY\n", + "EhG3AD8CTqmXVpJUtTQy86SCMaePIoskaWGTsCO8punaAZZgunaARZquHWAJpmsHWILp2gEWabp2\n", + "gCWYrh1gFGI1fAlTRORK7NOQpNVsKZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilUtjYjYHBE3RsTNEfGuIcunIuK+iPhGf/sPNXJKkjrrar1wRKwFzgVeA3wP+JuI\n", + "uDgzb9hl6Fcy88SRB5QkzVJzTeMo4JbMnMnMh4GLgNcPGRejjSVJmkvN0jgI2DYwfUc/b1ACL4+I\n", + "6yJia0QcPrJ0kqRZqm2eoiuEhXwd2JiZD0bECcBngJ8ZNjAizhqYnM7M6d1OKEmrSERMAVO79RyZ\n", + "JZ/dyy8ijgbOyszN/fR7gMcy8w/m+Te3Akdm5g93mZ+Z6WYsSVqEpXx21tw8dQ1waERsiognAb8C\n", + "XDw4ICL2j4joHx9FV3I/nP1UkqRRqLZ5KjMfiYjTgS8Ca4GPZOYNEXFav/w84JeB34yIR4AHgV+t\n", + "lVeSVHHz1HJy85QkLd6kbZ6SJE0YS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWrWhoRsTkiboyImyPiXXOMOadffl1EHDHqjJKkJ1QrjYhYC5wLbAYOB06KiMN2\n", + "GbMFOCQzDwV+A/jgyINqRUTEloj4QkRM9/dbameStLB1cy2IiM8D/zozb12h1z4KuCUzZ/rXuwh4\n", + "PXDDwJgTgQsAMvPqiNgQEftn5vYVyqQR6AviT4BDBmY/PyLIzK2VYkkqMN+axkeBL0bE+yJirxV4\n", + "7YOAbQPTd/TzFhpz8Apk0Widyc6FQT99RoUskhZhzjWNzPxUv7bxH4FrIuJPgXxicf7Rbr52LjwE\n", + "gCj5dxFx1sDkdGZOLyGTRuMpw2but99+R7Zt+1rgy03TPDriTNKqFxFTwNTuPMecpdF7GHiA7k2+\n", + "Hnhsd15sF98DNg5Mb6Rbk5hvzMH9vFky86xlzKaV9eNhM9evX/9s4IvAtrZtPwZ8rGma744ymLSa\n", + "9X9MT++Yjohmsc8RmcP/4I+IzcAfAZ8F2sx8cEkp53rhiHXA3wKvBu4E/ho4KTNvGBizBTg9M7dE\n", + "xNHA2Zl59JDnyszcdY1EY2rYPo01a9bcdtxxx1157LHHHgs8b2D4NN2m0k83TbOsv4PSnm4pn53z\n", + "lcZVwL/KzG8vR7g5XuME4GxgLfCRzPz9iDgNIDPP68fsOMLqR8Apmfn1Ic9jaUyYvjjOAJ4KPAR8\n", + "IDO3tm27BngFcCrwy/1ygPuBC4HzgaubpindvClpDstdGpFzLRwzlsbq1LbtM4G30BXI4BrmDXRr\n", + "H3/aNI1H0klLtKylMUksjdWvbdvDgVOAtwP79bMfBS6hK5CtTdM8XCmeNJEsDa16bdvuBZxAt/bx\n", + "OrpNmwA/AD4OnN80zXcqxZMmiqWhPUrbtgcAb6MrkMGrCVxNt/bxyaZp7quRTZoElob2SG3bBt0V\n", + "Bk4FTqI7PBy6HeyfpiuQrzRNs5yHjEsTz9LQHq9t272BN9EVyKsGFt1Kd+TVBU3T3F4jmzRuLA1p\n", + "QNu2Pw28o7/tOEk0gcvo1j4+0zTN0BMNpT2BpSEN0bbtWuA4urWPNwJP7hfdC3yCbg3k6577oT2N\n", + "pSEtoG3bfej2e5wCHDmw6Jt0ax+faJrmrhrZpFGzNKRFaNv2xXTl8TbgH/WzHwYupiuQLzVN80il\n", + "eNKKszSkJWjb9snAP6MrkM088ZUBd9J9n8v5TdPcXCmetGIsDWk3tW17EN1Z56ey83d+/AXd2sen\n", + "mqZ5oEY2ablZGtIy6c/9OIauPN4CPK1f9CPgf9AVyF+681yTzNKQVkDbtuuBN9MVyDEDi26mK4+P\n", + "N01zZ41s0u6wNKQV1rbtC+jO+zgZOLCf/RjwBboC+WzTNP9QJ520OJaGNCJt264DXku39nEisFe/\n", + "6C7gz+h2nn+zUjypiKUhVdC27bOBX6MrkBcNLPoa3drHhU3T3FMjmzQfS0OqqN95fiTdobtvBTb0\n", + "i34C/C+6AvmyF07UuLA0pDHRtu1TgTfQFchrgB2/n7cDHwM+1jTNrXXSSR1LQxpDbdv+FN2O81OA\n", + "TQOLPgGc3DTNozVySZaGNMbatl0DTNGVx5vpLpz4iqZprqqZS3uupXx2rlupMJJ21u/LuBy4vG3b\n", + "e4AzgOMBS0MTY83CQyStgEv7++OrppAWydKQ6pgGHgGOatt2wwJjpbFhaUgVNE1zP/BVuvfgqxYY\n", + "Lo0NS0Oqx01UmjiWhlSPpaGJY2lI9fwNcB9wSNu2m+pGkcpYGlIl/VfJXtFPurahiWBpSHW5iUoT\n", + "xdKQ6tpRGq9u23Zt1SRSAUtDqusW4DZgH+CIylmkBVkaUkX9d4y7iUoTw9KQ6rM0NDEsDam+LwMJ\n", + "HNO27d61w0jzsTSkypqmuZvuq2GfBLyichxpXpaGNB7cRKWJYGlI48HS0ESwNKTx8H+AB4EXtW17\n", + "QO0w0lwsDWkMNE3zE+DKfvI1NbNI87E0pPHhJiqNPUtDGh+Pl0bbtlE1iTQHS0MaH98Cvg8cCBxe\n", + "OYs0lKUhjYn+kiKX9ZNuotJYsjSk8eJ+DY01S0MaLzvWNF7Ztu2TqiaRhrA0pDHSNM2dwE3A04Cf\n", + "qxxHmsXSkMbPzf39T1VNIQ2xrsaLRsQ+wCfp3hQzwFsy894h42aA/wc8CjycmUeNMKZUy0x/v6li\n", + "BmmoWmsa7wYuzcyfobss9LvnGJfAVGYeYWFoDzLT32+qmEEaqlZpnAhc0D++AHjDPGM9yUl7mpn+\n", + "flPFDNJQtUpj/8zc3j/eDuw/x7gELouIayLinaOJJlU3099vqphBGmrF9mlExKXAsKt1vm9wIjMz\n", + "InKOpzkmM/8+Ip4NXBoRN2bmVXO83lkDk9OZOb2E2NI4mOnvN1XMoFUoIqaAqd16jsy5Pq9XTkTc\n", + "SLev4vsRcSBwRWb+7AL/pgEeyMz/MmRZZqabsbQq9Nedup/usNtnNU0z6yARaTks5bOz1uapi4GT\n", + "+8cnA5/ZdUBE7B0R6/vHTwNeC1w/soRSJf3lRGb6yU31kkiz1SqN9wPHR8RNwHH9NBHxnIi4pB9z\n", + "AHBVRFwLXA18LjO/VCWtNHoz/f2mihmkWaqcp5GZP2TIF81k5p3AP+0ffxd4yYijSeNipr/fVDGD\n", + "NItnhEvjaaa/31QxgzSLpSGNp5n+flPFDNIsloY0nmb6+00VM0izWBrSeJrp7zdVzCDNYmlI4+lu\n", + "4EfAM9u23VA7jLSDpSGNIc/V0LiqcsitpCIzdF/EdEnbtluBrcBlTdPcXzWV9mhVLiOy3LyMiFaj\n", + "tm1fB/x34MCB2Q8DV9EVyFbgxn6tRFq0pXx2WhrSGOuvQ/ViYEt/exk7b1ae4YkCuaJpmgdHnVGT\n", + "y9KQVrm2bfehuw7bFuAEYN+BxT8BrqArkM83TXPL6BNqklga0h6kbds1wC/wxFrIL7Dzl5bdzBNr\n", + "IVc2TfPjkYfUWLM0pD1Y27b7Af+ErkA2A4OH6j5I99XKW4FPNU1z9+gTatxYGpIAaNt2HfCLPLEW\n", + "Mnjxz4eAjwNnN01zY4V4GhOWhqSh2rY9iG7t4810ayM7XAL8MXC5R2HteSwNSQtq2/Yw4N8Abwee\n", + "0s/+Jl15XNg0zU9qZdNoWRqSirVt+2zgNOB0YP9+9nbgXOC/NU1zV61sGg1LQ9KitW37ZOAk4LeB\n", + "n+9n/5huv8d5wG3AfU3TPFInoVaKpSFpyfoTCY8Dfodu5/muHgDuAe7tb4OPfwh8rmmar40mrZaD\n", + "pSFpWbRt+7N0+z2OB55Fd/huyXvsL84999xH7rrrrjXArh8uM5n5jmUNqt1iaUhaEf2JhOvpymMD\n", + "TxTJjtvz6XasP+P888/ntttuG/Y0X8nMqZEEVhFLQ1I1bduuB07+8Ic//Id33HHHU4cMsTTGjKUh\n", + "qbqImAZeOWSRpTFmlvLZ6fdpSKvUCyO2bIQz18NT7ocfb4NzvpW5tXYuTTZLQ1qFXhix5WXwJx+C\n", + "Q3bMeyc8/4URWBzaHZaGtApthDMHCwPgQ3DIFjiD7qKFK2lmkfM1QSwNaRVa/8TlQXbydBi2g3pZ\n", + "eVjt6rZm4SGSJs393RndszzQXeFWWjJLQ1qFtsE574SdvrnvX8Lf3Q4fqJVJq4OH3Eqr1AsjtjwX\n", + "zng6PPUBeOh2+IA7wTXI8zQkScWW8tnp5ilJUjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQV\n", + "szQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxaqURkS8OSK+HRGPRsRL\n", + "5xm3OSJujIibI+Jdo8woSZqt1prG9cAbgSvnGhARa4Fzgc3A4cBJEXHYaOI9nmFqlK+3HCYt86Tl\n", + "BTOPwqTlhcnMvBRVSiMzb8zMmxYYdhRwS2bOZObDwEXA61c+3U6mRvx6y2GqdoBFmqodYAmmagdY\n", + "gqnaARZpqnaAJZiqHWAUxnmfxkHAtoHpO/p5kqRK1q3UE0fEpcABQxa9NzM/W/AUucyRJEm7KTLr\n", + "fTZHxBXAv83Mrw9ZdjRwVmZu7qffAzyWmX8wZKwFI0lLkJmxmPErtqaxCHMFvgY4NCI2AXcCvwKc\n", + "NGzgYv/TkqSlqXXI7RsjYhtwNHBJRHy+n/+ciLgEIDMfAU4Hvgh8B/hkZt5QI68kqVN185QkabKM\n", + "89FTIxcR+0TEpRFxU0R8KSI2zDN2bUR8IyJKduqvmJLMEbExIq7oT6j8VkScWSHngidqRsQ5/fLr\n", + "IuKIUWcckmfezBHxa33Wb0bEX0bEz9fIOZCn6GTYiPjHEfFIRLxplPnmyFLyezHVv9e+FRHTI444\n", + "LM9Cvxf7RsQXIuLaPvM7KsTckeWjEbE9Iq6fZ8zi3neZ6a2/AX8I/G7/+F3A++cZ+zvAJ4CLxz0z\n", + "3VFsL+kfPx34W+CwEWZcC9wCbAL2Aq7d9fWBLcDW/vEvAl+t/HMtyfwy4Jn94801M5fkHRh3OfA5\n", + "4J9PwM94A/Bt4OB+et8JyHwW8Ps78gJ3A+sq5f0l4Ajg+jmWL/p955rGzk4ELugfXwC8YdigiDiY\n", + "7of9YebekT8qC2bOzO9n5rX94weAG4DnjCxh2Ymaj/8/MvNqYENE7D/CjLtaMHNm/lVm3tdPXg0c\n", + "POKMg0pPhj0D+HPg/44y3BxKMr8V+HRm3gGQmXeNOOOuSjL/PfCM/vEzgLuz20c7cpl5FXDPPEMW\n", + "/b6zNHa2f2Zu7x9vB+b64f0x8O+Bx0aSan6lmQHoj0Y7gu5DblRKTtQcNqbmh/BiTy79dWDriiaa\n", + "34J5I+Igug+4D/azau/QLPkZHwrs029evSYi/sXI0g1XkvlDwM9FxJ3AdcBvjSjbUiz6fTcOh9yO\n", + "1DwnHb5vcCIzc9j5HxHxOuAHmfmNUV1rZnczDzzP0+n+yvytfo1jVEo/nHZda6v5oVb82hHxKuBU\n", + "4JiVi7OgkrxnA+/uf0+C+mvJJZn3Al4KvBrYG/iriPhqZt68osnmVpL5vcC1mTkVEc8HLo2IF2fm\n", + "/SucbakW9b7b40ojM4+fa1m/w+iAzPx+RBwI/GDIsJcDJ0bEFuApwDMi4uOZ+fYVirwcmYmIvYBP\n", + "A3+WmZ9Zoahz+R6wcWB6I91fNPONObifV0tJZvqd3x8CNmfmfJsBVlpJ3iOBi7q+YF/ghIh4ODMv\n", + "Hk3EWUoybwPuysyHgIci4krgxUCt0ijJ/HLg9wAy8+8i4lbgBXTnno2bRb/v3Dy1s4uBk/vHJwOz\n", + "Plwz872ZuTEznwf8KnD5ShZGgQUz939VfgT4TmaePcJsOzx+omZEPInuRM1dP6guBt4Oj18N4N6B\n", + "zW41LJg5Ip4L/E/gbZl5S4WMgxbMm5k/nZnP6393/xz4zYqFAWW/F/8bOLY/WnFvup213xlxzkEl\n", + "mW8EXgPQ7x94AfDdkaYst/j3XY09+uN6A/YBLgNuAr4EbOjnPwe4ZMj4V1L/6KkFMwPH0u1/uRb4\n", + "Rn/bPOKcJ9AdtXUL8J5+3mnAaQNjzu2XXwe8dAx+H+bNTHcgxN0DP9O/Hue8u4w9H3jTuP+M++l/\n", + "R3cE1fXAmeOemW4t7rP97/H1wFsrZr2Q7ooa/0C31nbq7r7vPLlPklTMzVOSpGKWhiSpmKUhSSpm\n", + "aUiSilkakqRiloYkqZilIS2z/lL0342IZ/XTz+qnn1s7m7S7LA1pmWXmNrqLAr6/n/V+4LzMvL1e\n", + "Kml5eHKftAIiYh3wNbozr3+d7vtMHq2bStp9e9wFC6VRyMxHIuJ3gc8Dx1sYWi3cPCWtnBPorvvz\n", + "otpBpOViaUgrICJeQnel05cBvx0Rw74PRZo4loa0zPpL0X+Q7suutgH/CfjPdVNJy8PSkJbfO4GZ\n", + "zPxyP/1fgcMi4pcqZpKWhUdPSZKKuaYhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaG\n", + "JKnY/wfSP/dwYGt2YAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NN TEST\n", + "for m in testing_couples\n", + " \n", + "sTest_pred = model.forward_prediction(mTest)\n", + "distance[\"NN\"] = abs(sTest_pred-sTest)\n", + "\n", + "%pylab inline\n", + "ax = axes()\n", + "environment.plot_arm(ax, mTest)\n", + "ax.plot(*sTest_pred, marker='o', color='red')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFcZJREFUeJzt3Xu0pXV93/H3d2bwgo6OFLkIY8YIMRCNIilBIXpEscPU\n", + "4qXRBGNFSA1NF5AmbeOtqw/PH1kxaZsQZNVSL4iJC6yxtSjjBYQjJI0kqCAqBIgcGCSOBYGCoOHy\n", + "7R/PM7Bnzj7n/M6Zc/Zv7zPv11p77f08z2/2/sxZZ+/Pea47MhNJkkqsqR1AkjQ5LA1JUjFLQ5JU\n", + "zNKQJBWzNCRJxSwNSVKxqqURER+NiO0Rcf08Y86JiJsj4rqIOGKU+SRJO6u9pnE+sHmuhRGxBTgk\n", + "Mw8FfgP44KiCSZJmq1oamXkVcM88Q04ELujHXg1siIj9R5FNkjRb7TWNhRwEbBuYvgM4uFIWSdrj\n", + "jXtpAMQu0173RJIqWVc7wAK+B2wcmD64n7eTiLBIJGkJMnPXP8znNe6lcTFwOnBRRBwN3JuZ24cN\n", + "XOx/vEREnJWZZy33866kScs8aXnBzKMwaXlhYjMv+g/uqqURERcCrwT2jYhtQAPsBZCZ52Xm1ojY\n", + "EhG3AD8CTqmXVpJUtTQy86SCMaePIoskaWGTsCO8punaAZZgunaARZquHWAJpmsHWILp2gEWabp2\n", + "gCWYrh1gFGI1fAlTRORK7NOQpNVsKZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilUtjYjYHBE3RsTNEfGuIcunIuK+iPhGf/sPNXJKkjrrar1wRKwFzgVeA3wP+JuI\n", + "uDgzb9hl6Fcy88SRB5QkzVJzTeMo4JbMnMnMh4GLgNcPGRejjSVJmkvN0jgI2DYwfUc/b1ACL4+I\n", + "6yJia0QcPrJ0kqRZqm2eoiuEhXwd2JiZD0bECcBngJ8ZNjAizhqYnM7M6d1OKEmrSERMAVO79RyZ\n", + "JZ/dyy8ijgbOyszN/fR7gMcy8w/m+Te3Akdm5g93mZ+Z6WYsSVqEpXx21tw8dQ1waERsiognAb8C\n", + "XDw4ICL2j4joHx9FV3I/nP1UkqRRqLZ5KjMfiYjTgS8Ca4GPZOYNEXFav/w84JeB34yIR4AHgV+t\n", + "lVeSVHHz1HJy85QkLd6kbZ6SJE0YS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ5JUzNKQJBWrWhoRsTkiboyImyPiXXOMOadffl1EHDHqjJKkJ1QrjYhYC5wLbAYOB06KiMN2\n", + "GbMFOCQzDwV+A/jgyINqRUTEloj4QkRM9/dbameStLB1cy2IiM8D/zozb12h1z4KuCUzZ/rXuwh4\n", + "PXDDwJgTgQsAMvPqiNgQEftn5vYVyqQR6AviT4BDBmY/PyLIzK2VYkkqMN+axkeBL0bE+yJirxV4\n", + "7YOAbQPTd/TzFhpz8Apk0Widyc6FQT99RoUskhZhzjWNzPxUv7bxH4FrIuJPgXxicf7Rbr52LjwE\n", + "gCj5dxFx1sDkdGZOLyGTRuMpw2but99+R7Zt+1rgy03TPDriTNKqFxFTwNTuPMecpdF7GHiA7k2+\n", + "Hnhsd15sF98DNg5Mb6Rbk5hvzMH9vFky86xlzKaV9eNhM9evX/9s4IvAtrZtPwZ8rGma744ymLSa\n", + "9X9MT++Yjohmsc8RmcP/4I+IzcAfAZ8F2sx8cEkp53rhiHXA3wKvBu4E/ho4KTNvGBizBTg9M7dE\n", + "xNHA2Zl59JDnyszcdY1EY2rYPo01a9bcdtxxx1157LHHHgs8b2D4NN2m0k83TbOsv4PSnm4pn53z\n", + "lcZVwL/KzG8vR7g5XuME4GxgLfCRzPz9iDgNIDPP68fsOMLqR8Apmfn1Ic9jaUyYvjjOAJ4KPAR8\n", + "IDO3tm27BngFcCrwy/1ygPuBC4HzgaubpindvClpDstdGpFzLRwzlsbq1LbtM4G30BXI4BrmDXRr\n", + "H3/aNI1H0klLtKylMUksjdWvbdvDgVOAtwP79bMfBS6hK5CtTdM8XCmeNJEsDa16bdvuBZxAt/bx\n", + "OrpNmwA/AD4OnN80zXcqxZMmiqWhPUrbtgcAb6MrkMGrCVxNt/bxyaZp7quRTZoElob2SG3bBt0V\n", + "Bk4FTqI7PBy6HeyfpiuQrzRNs5yHjEsTz9LQHq9t272BN9EVyKsGFt1Kd+TVBU3T3F4jmzRuLA1p\n", + "QNu2Pw28o7/tOEk0gcvo1j4+0zTN0BMNpT2BpSEN0bbtWuA4urWPNwJP7hfdC3yCbg3k6577oT2N\n", + "pSEtoG3bfej2e5wCHDmw6Jt0ax+faJrmrhrZpFGzNKRFaNv2xXTl8TbgH/WzHwYupiuQLzVN80il\n", + "eNKKszSkJWjb9snAP6MrkM088ZUBd9J9n8v5TdPcXCmetGIsDWk3tW17EN1Z56ey83d+/AXd2sen\n", + "mqZ5oEY2ablZGtIy6c/9OIauPN4CPK1f9CPgf9AVyF+681yTzNKQVkDbtuuBN9MVyDEDi26mK4+P\n", + "N01zZ41s0u6wNKQV1rbtC+jO+zgZOLCf/RjwBboC+WzTNP9QJ520OJaGNCJt264DXku39nEisFe/\n", + "6C7gz+h2nn+zUjypiKUhVdC27bOBX6MrkBcNLPoa3drHhU3T3FMjmzQfS0OqqN95fiTdobtvBTb0\n", + "i34C/C+6AvmyF07UuLA0pDHRtu1TgTfQFchrgB2/n7cDHwM+1jTNrXXSSR1LQxpDbdv+FN2O81OA\n", + "TQOLPgGc3DTNozVySZaGNMbatl0DTNGVx5vpLpz4iqZprqqZS3uupXx2rlupMJJ21u/LuBy4vG3b\n", + "e4AzgOMBS0MTY83CQyStgEv7++OrppAWydKQ6pgGHgGOatt2wwJjpbFhaUgVNE1zP/BVuvfgqxYY\n", + "Lo0NS0Oqx01UmjiWhlSPpaGJY2lI9fwNcB9wSNu2m+pGkcpYGlIl/VfJXtFPurahiWBpSHW5iUoT\n", + "xdKQ6tpRGq9u23Zt1SRSAUtDqusW4DZgH+CIylmkBVkaUkX9d4y7iUoTw9KQ6rM0NDEsDam+LwMJ\n", + "HNO27d61w0jzsTSkypqmuZvuq2GfBLyichxpXpaGNB7cRKWJYGlI48HS0ESwNKTx8H+AB4EXtW17\n", + "QO0w0lwsDWkMNE3zE+DKfvI1NbNI87E0pPHhJiqNPUtDGh+Pl0bbtlE1iTQHS0MaH98Cvg8cCBxe\n", + "OYs0lKUhjYn+kiKX9ZNuotJYsjSk8eJ+DY01S0MaLzvWNF7Ztu2TqiaRhrA0pDHSNM2dwE3A04Cf\n", + "qxxHmsXSkMbPzf39T1VNIQ2xrsaLRsQ+wCfp3hQzwFsy894h42aA/wc8CjycmUeNMKZUy0x/v6li\n", + "BmmoWmsa7wYuzcyfobss9LvnGJfAVGYeYWFoDzLT32+qmEEaqlZpnAhc0D++AHjDPGM9yUl7mpn+\n", + "flPFDNJQtUpj/8zc3j/eDuw/x7gELouIayLinaOJJlU3099vqphBGmrF9mlExKXAsKt1vm9wIjMz\n", + "InKOpzkmM/8+Ip4NXBoRN2bmVXO83lkDk9OZOb2E2NI4mOnvN1XMoFUoIqaAqd16jsy5Pq9XTkTc\n", + "SLev4vsRcSBwRWb+7AL/pgEeyMz/MmRZZqabsbQq9Nedup/usNtnNU0z6yARaTks5bOz1uapi4GT\n", + "+8cnA5/ZdUBE7B0R6/vHTwNeC1w/soRSJf3lRGb6yU31kkiz1SqN9wPHR8RNwHH9NBHxnIi4pB9z\n", + "AHBVRFwLXA18LjO/VCWtNHoz/f2mihmkWaqcp5GZP2TIF81k5p3AP+0ffxd4yYijSeNipr/fVDGD\n", + "NItnhEvjaaa/31QxgzSLpSGNp5n+flPFDNIsloY0nmb6+00VM0izWBrSeJrp7zdVzCDNYmlI4+lu\n", + "4EfAM9u23VA7jLSDpSGNIc/V0LiqcsitpCIzdF/EdEnbtluBrcBlTdPcXzWV9mhVLiOy3LyMiFaj\n", + "tm1fB/x34MCB2Q8DV9EVyFbgxn6tRFq0pXx2WhrSGOuvQ/ViYEt/exk7b1ae4YkCuaJpmgdHnVGT\n", + "y9KQVrm2bfehuw7bFuAEYN+BxT8BrqArkM83TXPL6BNqklga0h6kbds1wC/wxFrIL7Dzl5bdzBNr\n", + "IVc2TfPjkYfUWLM0pD1Y27b7Af+ErkA2A4OH6j5I99XKW4FPNU1z9+gTatxYGpIAaNt2HfCLPLEW\n", + "Mnjxz4eAjwNnN01zY4V4GhOWhqSh2rY9iG7t4810ayM7XAL8MXC5R2HteSwNSQtq2/Yw4N8Abwee\n", + "0s/+Jl15XNg0zU9qZdNoWRqSirVt+2zgNOB0YP9+9nbgXOC/NU1zV61sGg1LQ9KitW37ZOAk4LeB\n", + "n+9n/5huv8d5wG3AfU3TPFInoVaKpSFpyfoTCY8Dfodu5/muHgDuAe7tb4OPfwh8rmmar40mrZaD\n", + "pSFpWbRt+7N0+z2OB55Fd/huyXvsL84999xH7rrrrjXArh8uM5n5jmUNqt1iaUhaEf2JhOvpymMD\n", + "TxTJjtvz6XasP+P888/ntttuG/Y0X8nMqZEEVhFLQ1I1bduuB07+8Ic//Id33HHHU4cMsTTGjKUh\n", + "qbqImAZeOWSRpTFmlvLZ6fdpSKvUCyO2bIQz18NT7ocfb4NzvpW5tXYuTTZLQ1qFXhix5WXwJx+C\n", + "Q3bMeyc8/4URWBzaHZaGtApthDMHCwPgQ3DIFjiD7qKFK2lmkfM1QSwNaRVa/8TlQXbydBi2g3pZ\n", + "eVjt6rZm4SGSJs393RndszzQXeFWWjJLQ1qFtsE574SdvrnvX8Lf3Q4fqJVJq4OH3Eqr1AsjtjwX\n", + "zng6PPUBeOh2+IA7wTXI8zQkScWW8tnp5ilJUjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQV\n", + "szQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxaqURkS8OSK+HRGPRsRL\n", + "5xm3OSJujIibI+Jdo8woSZqt1prG9cAbgSvnGhARa4Fzgc3A4cBJEXHYaOI9nmFqlK+3HCYt86Tl\n", + "BTOPwqTlhcnMvBRVSiMzb8zMmxYYdhRwS2bOZObDwEXA61c+3U6mRvx6y2GqdoBFmqodYAmmagdY\n", + "gqnaARZpqnaAJZiqHWAUxnmfxkHAtoHpO/p5kqRK1q3UE0fEpcABQxa9NzM/W/AUucyRJEm7KTLr\n", + "fTZHxBXAv83Mrw9ZdjRwVmZu7qffAzyWmX8wZKwFI0lLkJmxmPErtqaxCHMFvgY4NCI2AXcCvwKc\n", + "NGzgYv/TkqSlqXXI7RsjYhtwNHBJRHy+n/+ciLgEIDMfAU4Hvgh8B/hkZt5QI68kqVN185QkabKM\n", + "89FTIxcR+0TEpRFxU0R8KSI2zDN2bUR8IyJKduqvmJLMEbExIq7oT6j8VkScWSHngidqRsQ5/fLr\n", + "IuKIUWcckmfezBHxa33Wb0bEX0bEz9fIOZCn6GTYiPjHEfFIRLxplPnmyFLyezHVv9e+FRHTI444\n", + "LM9Cvxf7RsQXIuLaPvM7KsTckeWjEbE9Iq6fZ8zi3neZ6a2/AX8I/G7/+F3A++cZ+zvAJ4CLxz0z\n", + "3VFsL+kfPx34W+CwEWZcC9wCbAL2Aq7d9fWBLcDW/vEvAl+t/HMtyfwy4Jn94801M5fkHRh3OfA5\n", + "4J9PwM94A/Bt4OB+et8JyHwW8Ps78gJ3A+sq5f0l4Ajg+jmWL/p955rGzk4ELugfXwC8YdigiDiY\n", + "7of9YebekT8qC2bOzO9n5rX94weAG4DnjCxh2Ymaj/8/MvNqYENE7D/CjLtaMHNm/lVm3tdPXg0c\n", + "POKMg0pPhj0D+HPg/44y3BxKMr8V+HRm3gGQmXeNOOOuSjL/PfCM/vEzgLuz20c7cpl5FXDPPEMW\n", + "/b6zNHa2f2Zu7x9vB+b64f0x8O+Bx0aSan6lmQHoj0Y7gu5DblRKTtQcNqbmh/BiTy79dWDriiaa\n", + "34J5I+Igug+4D/azau/QLPkZHwrs029evSYi/sXI0g1XkvlDwM9FxJ3AdcBvjSjbUiz6fTcOh9yO\n", + "1DwnHb5vcCIzc9j5HxHxOuAHmfmNUV1rZnczDzzP0+n+yvytfo1jVEo/nHZda6v5oVb82hHxKuBU\n", + "4JiVi7OgkrxnA+/uf0+C+mvJJZn3Al4KvBrYG/iriPhqZt68osnmVpL5vcC1mTkVEc8HLo2IF2fm\n", + "/SucbakW9b7b40ojM4+fa1m/w+iAzPx+RBwI/GDIsJcDJ0bEFuApwDMi4uOZ+fYVirwcmYmIvYBP\n", + "A3+WmZ9Zoahz+R6wcWB6I91fNPONObifV0tJZvqd3x8CNmfmfJsBVlpJ3iOBi7q+YF/ghIh4ODMv\n", + "Hk3EWUoybwPuysyHgIci4krgxUCt0ijJ/HLg9wAy8+8i4lbgBXTnno2bRb/v3Dy1s4uBk/vHJwOz\n", + "Plwz872ZuTEznwf8KnD5ShZGgQUz939VfgT4TmaePcJsOzx+omZEPInuRM1dP6guBt4Oj18N4N6B\n", + "zW41LJg5Ip4L/E/gbZl5S4WMgxbMm5k/nZnP6393/xz4zYqFAWW/F/8bOLY/WnFvup213xlxzkEl\n", + "mW8EXgPQ7x94AfDdkaYst/j3XY09+uN6A/YBLgNuAr4EbOjnPwe4ZMj4V1L/6KkFMwPH0u1/uRb4\n", + "Rn/bPOKcJ9AdtXUL8J5+3mnAaQNjzu2XXwe8dAx+H+bNTHcgxN0DP9O/Hue8u4w9H3jTuP+M++l/\n", + "R3cE1fXAmeOemW4t7rP97/H1wFsrZr2Q7ooa/0C31nbq7r7vPLlPklTMzVOSpGKWhiSpmKUhSSpm\n", + "aUiSilkakqRiloYkqZilIS2z/lL0342IZ/XTz+qnn1s7m7S7LA1pmWXmNrqLAr6/n/V+4LzMvL1e\n", + "Kml5eHKftAIiYh3wNbozr3+d7vtMHq2bStp9e9wFC6VRyMxHIuJ3gc8Dx1sYWi3cPCWtnBPorvvz\n", + "otpBpOViaUgrICJeQnel05cBvx0Rw74PRZo4loa0zPpL0X+Q7suutgH/CfjPdVNJy8PSkJbfO4GZ\n", + "zPxyP/1fgcMi4pcqZpKWhUdPSZKKuaYhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaG\n", + "JKnY/wfSP/dwYGt2YAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NN TEST\n", + "for m in testing_couples\n", + " \n", + "sTest_pred = model.forward_prediction(mTest)\n", + "distance[\"NN\"] = abs(sTest_pred-sTest)\n", + "\n", + "%pylab inline\n", + "ax = axes()\n", + "environment.plot_arm(ax, mTest)\n", + "ax.plot(*sTest_pred, marker='o', color='red')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.65232833 -0.78444065 -0.07154134 0.98469259 -0.20240519 0.59945435\n", + " -0.5925971 ]\n", + "[ 0.54220714 0.79929109]\n", + "['NN']\n" + ] + } + ], + "source": [ + "sensorimotor_models.keys()\n", + "print mTest\n", + "print sTest\n", + "print distance.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.56816432 -0.60892505]\n", + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAFbpJREFUeJzt3XuUpHV95/H3dxi8oOjIIiAXM0aIgWgUyRIQIi2Kzsxm\n", + "8bLRBGNEyIUkB8wmuxtve/bh+WNPTHY3QcNZw/GCmHjAGHfdUQYUhBZykQQVRGXCTKRxkDguCCwI\n", + "Gi7f/eN5hqmZqe7+dU93/apm3q9z6lQ9z/Obqs/06apPP9eKzESSpBIrageQJE0OS0OSVMzSkCQV\n", + "szQkScUsDUlSMUtDklSsamlExEciYmtE3DLHmPdHxKaIuDkijh1lPknSjmqvaVwMrJltYUSsA47M\n", + "zKOA3wA+MKpgkqRdVS2NzLweuHeOIacDl/RjbwBWRcTBo8gmSdpV7TWN+RwGbBmYvhM4vFIWSdrr\n", + "jXtpAMRO0173RJIqWVk7wDy+AxwxMH14P28HEWGRSNIiZObOf5jPadxLYz1wLnBZRJwA3JeZW4cN\n", + "XOh/vEREnJ+Z5y/18y6nScs8aXnBzKMwaXlhYjMv+A/uqqUREZcCpwAHRsQWoAH2BcjMizJzQ0Ss\n", + "i4jNwA+As+qllSRVLY3MPKNgzLmjyCJJmt8k7Aivabp2gEWYrh1ggaZrB1iE6doBFmG6doAFmq4d\n", + "YBGmawcYhdgTvoQpInI59mlI0p5sMZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", + "mKUhSSpmaUiSilUtjYhYExEbI2JTRLxjyPKpiLg/Ir7a3/5zjZySpM7KWi8cEfsAFwKvAr4D/ENE\n", + "rM/MW3ca+sXMPH3kASVJu6i5pnE8sDkzZzLzEeAy4LVDxsVoY0mSZlOzNA4DtgxM39nPG5TAyyLi\n", + "5ojYEBHHjCydJGkX1TZP0RXCfL4CHJGZD0XEWuDTwE8MGxgR5w9MTmfm9G4nlKQ9SERMAVO79RyZ\n", + "JZ/dSy8iTgDOz8w1/fS7gMcz8w/n+De3A8dl5vd3mp+Z6WYsSVqAxXx21tw8dSNwVESsjognAb8I\n", + "rB8cEBEHR0T0j4+nK7nv7/pUkqRRqLZ5KjMfjYhzgc8B+wAfzsxbI+KcfvlFwC8AvxURjwIPAb9U\n", + "K68kqeLmqaXk5ilJWrhJ2zwlSZowloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", + "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", + "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", + "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", + "pGKWhiSpmKUhSSpWtTQiYk1EbIyITRHxjlnGvL9ffnNEHDvqjJKk7aqVRkTsA1wIrAGOAc6IiKN3\n", + "GrMOODIzjwJ+A/jAyINqWUTEuoi4MiKm+/t1tTNJmt/K2RZExBXAb2fm7cv02scDmzNzpn+9y4DX\n", + "ArcOjDkduAQgM2+IiFURcXBmbl2mTBqBviDeBxw5MPv5EUFmbqgUS1KBudY0PgJ8LiLeExH7LsNr\n", + "HwZsGZi+s58335jDlyGLRuvt7FgY9NPnVcgiaQFmXdPIzE/2axv/BbgxIv4cyO2L849387Vz/iEA\n", + "RMm/i4jzByanM3N6EZk0Gk8ZNvOggw46rm3bVwNfaJrmsRFnkvZ4ETEFTO3Oc8xaGr1HgAfp3uT7\n", + "A4/vzovt5DvAEQPTR9CtScw15vB+3i4y8/wlzKbl9cNhM/fff/9nA58DtrRt+1Hgo03TfGuUwaQ9\n", + "Wf/H9PS26YhoFvockTn8D/6IWAP8MfAZoM3MhxaVcrYXjlgJ/CPwSuAu4O+BMzLz1oEx64BzM3Nd\n", + "RJwAXJCZJwx5rszMnddINKaG7dNYsWLFHaeeeup1J5988snA8waGT9NtKv1U0zRL+jso7e0W89k5\n", + "V2lcD/xmZn5jKcLN8hprgQuAfYAPZ+YfRMQ5AJl5UT9m2xFWPwDOysyvDHkeS2PC9MVxHvBU4GHg\n", + "TzNzQ9u2K4CXA2cDv9AvB3gAuBS4GLihaZrSzZuSZrHUpRE528IxY2nsmdq2fSbwJroCGVzDvJVu\n", + "7ePPm6bxSDppkZa0NCaJpbHna9v2GOAs4K3AQf3sx4DL6QpkQ9M0j1SKJ00kS0N7vLZt9wXW0q19\n", + "/Dzdpk2A7wEfAy5umuableJJE8XS0F6lbdtDgLfQFcjg1QRuoFv7+ETTNPfXyCZNAktDe6W2bYPu\n", + "CgNnA2fQHR4O3Q72T9EVyBebplnKQ8aliWdpaK/Xtu1+wBvoCuQVA4tupzvy6pKmab5dI5s0biwN\n", + "aUDbtj8OvK2/bTtJNIGr6dY+Pt00zdATDaW9gaUhDdG27T7AqXRrH68Hntwvug/4ON0ayFc890N7\n", + "G0tDmkfbtgfQ7fc4CzhuYNHX6NY+Pt40zd01skmjZmlIC9C27YvpyuMtwL/qZz8CrKcrkM83TfNo\n", + "pXjSsrM0pEVo2/bJwL+lK5A1bP/KgLvovs/l4qZpNlWKJy0bS0PaTW3bHkZ31vnZ7PidH39Nt/bx\n", + "yaZpHqyRTVpqloa0RPpzP06iK483AU/rF/0A+Eu6Avkbd55rklka0jJo23Z/4I10BXLSwKJNdOXx\n", + "saZp7qqRTdodloa0zNq2fQHdeR9nAs/pZz8OXElXIJ9pmuZf6qSTFsbSkEakbduVwKvp1j5OB/bt\n", + "F90N/AXdzvOvVYonFbE0pAratn028Mt0BfKigUVfplv7uLRpmntrZJPmYmlIFfU7z4+jO3T3zcCq\n", + "ftGPgP9NVyBf8MKJGheWhjQm2rZ9KvA6ugJ5FbDt9/PbwEeBjzZNc3uddFLH0pDGUNu2P0a34/ws\n", + "YPXAoo8DZzZN81iNXJKlIY2xtm1XAFN05fFGugsnvrxpmutr5tLeazGfnSuXK4ykHfX7Mq4Brmnb\n", + "9l7gPOA0wNLQxFgx/xBJy+Cq/v60qimkBbI0pDqmgUeB49u2XTXPWGlsWBpSBU3TPAB8ie49+Ip5\n", + "hktjw9KQ6nETlSaOpSHVY2lo4lgaUj3/ANwPHNm27eq6UaQyloZUSf9Vstf2k65taCJYGlJdbqLS\n", + "RLE0pLq2lcYr27bdp2oSqYClIdW1GbgDOAA4tnIWaV6WhlRR/x3jbqLSxLA0pPosDU0MS0Oq7wtA\n", + "Aie1bbtf7TDSXCwNqbKmae6h+2rYJwEvrxxHmpOlIY0HN1FpIlga0niwNDQRLA1pPPwt8BDworZt\n", + "D6kdRpqNpSGNgaZpfgRc10++qmYWaS6WhjQ+3ESlsWdpSOPjidJo2zaqJpFmYWlI4+PrwHeB5wDH\n", + "VM4iDWVpSGOiv6TI1f2km6g0liwNaby4X0NjzdKQxsu2NY1T2rZ9UtUk0hCWhjRGmqa5C7gNeBrw\n", + "U5XjSLuwNKTxs6m//7GqKaQhVtZ40Yg4APgE3ZtiBnhTZt43ZNwM8P+Ax4BHMvP4EcaUapnp71dX\n", + "zCANVWtN453AVZn5E3SXhX7nLOMSmMrMYy0M7UVm+vvVFTNIQ9UqjdOBS/rHlwCvm2OsJzlpbzPT\n", + "36+umEEaqlZpHJyZW/vHW4GDZxmXwNURcWNE/PpooknVzfT3qytmkIZatn0aEXEVMOxqne8ZnMjM\n", + "jIic5WlOysx/johnA1dFxMbMvH6W1zt/YHI6M6cXEVsaBzP9/eqKGbQHiogpYGq3niNzts/r5RMR\n", + "G+n2VXw3Ip4DXJuZPznPv2mABzPzfwxZlpnpZiztEfrrTj1Ad9jts5qm2eUgEWkpLOazs9bmqfXA\n", + "mf3jM4FP7zwgIvaLiP37x08DXg3cMrKEUiX95URm+snV9ZJIu6pVGu8FTouI24BT+2ki4tCIuLwf\n", + "cwhwfUTcBNwAfDYzP18lrTR6M/396ooZpF1UOU8jM7/PkC+aycy7gH/TP/4W8JIRR5PGxUx/v7pi\n", + "BmkXnhEujaeZ/n51xQzSLiwNaTzN9PerK2aQdmFpSONppr9fXTGDtAtLQxpPM/396ooZpF1YGtJ4\n", + "ugf4AfDMtm1X1Q6zlF4YsW5txJVvipheG3HlCyPW1c6kcpaGNIb21HM1Xhix7kR43xXwmr+EU66A\n", + "15wI77M4JkeVM8KXmmeEa0/Utu1n6Q5BvwvY0N+ubprmgarBdsPaiCuvgNfsPH8dXLkhc22NTHuz\n", + "xXx2VjlPQ1KRPwNeChwK/Fp/e6Rt2+vZXiIb+7WSibA/PGXY/KfDU0edRYvjmoY0xvrrUL0YWNff\n", + "TmTHzcozbC+Qa5umeWjUGRfCNY3xspjPTktDmiBt2x5Adx22dcBa4MCBxT8CrqUrkCuaptk8+oRz\n", + "27ZP44Nw5LZ5vwb/9CV4+9czN9TMtjeyNKS9SNu2K4CfYftayM+w45eWbWL7Wsh1TdP8cOQhh3hh\n", + "xLrnwnlPh6c+CA9/G/7UwqjD0pD2Ym3bHkS36WcdsAYYPFT3IbqvVt4AfLJpmntGn1DjxtKQBEDb\n", + "tiuBn2X7WsjgxT8fBj4GXNA0zcYK8TQmLA1JQ7Vtexjd2scb2XFH9OXAnwDXTNJRWFoaloakebVt\n", + "ezTw74G3sv0Q2K/RlcelTdP8qFY2jZalIalY27bPBs4BzgUO7mdvBS4E/qxpmrtrZdNoWBqSFqxt\n", + "2ycDZwC/C/x0P/uHdPs9LgLuAO5vmubROgm1XCwNSYvWn0h4KvB7dDvPd/YgcC9wX38bfPx94LNN\n", + "03x5NGm1FCwNSUuibdufpNvvcRrwLLrDd0veY3994YUXPnr33XevAHb+cJnJzLctaVDtFktD0rLo\n", + "TyTcn648VrG9SLbdnk+3Y/0ZF198MXfcccewp/liZk6NJLCKWBqSqmnbdn/gzA996EN/dOeddw67\n", + "AKGlMWYsDUnVRcQ0cMqQRZbGmFnMZ6dfwiRJKmZpSJKK+SVMkpbazALna4K4T0OS9lLu05AkLStL\n", + "Q5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFL\n", + "Q5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScWqlEZEvDEivhERj0XES+cYtyYiNkbEpoh4\n", + "xygzSpJ2VWtN4xbg9cB1sw2IiH2AC4E1wDHAGRFx9GjiPZFhapSvtxQmLfOk5QUzj8Kk5YXJzLwY\n", + "VUojMzdm5m3zDDse2JyZM5n5CHAZ8NrlT7eDqRG/3lKYqh1ggaZqB1iEqdoBFmGqdoAFmqodYBGm\n", + "agcYhXHep3EYsGVg+s5+niSpkpXL9cQRcRVwyJBF787MzxQ8RS5xJEnSborMep/NEXEt8B8y8ytD\n", + "lp0AnJ+Za/rpdwGPZ+YfDhlrwUjSImRmLGT8sq1pLMBsgW8EjoqI1cBdwC8CZwwbuND/tCRpcWod\n", + "cvv6iNgCnABcHhFX9PMPjYjLATLzUeBc4HPAN4FPZOatNfJKkjpVN09JkibLOB89NXIRcUBEXBUR\n", + "t0XE5yNi1Rxj94mIr0ZEyU79ZVOSOSKOiIhr+xMqvx4Rb6+Qc94TNSPi/f3ymyPi2FFnHJJnzswR\n", + "8ct91q9FxN9ExE/XyDmQp+hk2Ij41xHxaES8YZT5ZslS8nsx1b/Xvh4R0yOOOCzPfL8XB0bElRFx\n", + "U5/5bRVibsvykYjYGhG3zDFmYe+7zPTW34A/An6/f/wO4L1zjP094OPA+nHPTHcU20v6x08H/hE4\n", + "eoQZ9wE2A6uBfYGbdn59YB2woX/8s8CXKv9cSzKfCDyzf7ymZuaSvAPjrgE+C/y7CfgZrwK+ARze\n", + "Tx84AZnPB/5gW17gHmBlpbw/BxwL3DLL8gW/71zT2NHpwCX940uA1w0bFBGH0/2wP8TsO/JHZd7M\n", + "mfndzLypf/wgcCtw6MgSlp2o+cT/IzNvAFZFxMEjzLizeTNn5t9l5v395A3A4SPOOKj0ZNjzgL8C\n", + "/u8ow82iJPObgU9l5p0AmXn3iDPurCTzPwPP6B8/A7gnu320I5eZ1wP3zjFkwe87S2NHB2fm1v7x\n", + "VmC2H96fAP8JeHwkqeZWmhmA/mi0Y+k+5Eal5ETNYWNqfggv9OTSXwU2LGuiuc2bNyIOo/uA+0A/\n", + "q/YOzZKf8VHAAf3m1Rsj4ldGlm64kswfBH4qIu4CbgZ+Z0TZFmPB77txOOR2pOY46fA9gxOZmcPO\n", + "/4iInwe+l5lfHdW1ZnY388DzPJ3ur8zf6dc4RqX0w2nntbaaH2rFrx0RrwDOBk5avjjzKsl7AfDO\n", + "/vckqL+WXJJ5X+ClwCuB/YC/i4gvZeamZU02u5LM7wZuysypiHg+cFVEvDgzH1jmbIu1oPfdXlca\n", + "mXnabMv6HUaHZOZ3I+I5wPeGDHsZcHpErAOeAjwjIj6WmW9dpshLkZmI2Bf4FPAXmfnpZYo6m+8A\n", + "RwxMH0H3F81cYw7v59VSkpl+5/cHgTWZOddmgOVWkvc44LKuLzgQWBsRj2Tm+tFE3EVJ5i3A3Zn5\n", + "MPBwRFwHvBioVRolmV8G/FeAzPyniLgdeAHduWfjZsHvOzdP7Wg9cGb/+Exglw/XzHx3Zh6Rmc8D\n", + "fgm4ZjkLo8C8mfu/Kj8MfDMzLxhhtm2eOFEzIp5Ed6Lmzh9U64G3whNXA7hvYLNbDfNmjojnAv8L\n", + "eEtmbq6QcdC8eTPzxzPzef3v7l8Bv1WxMKDs9+L/ACf3RyvuR7ez9psjzjmoJPNG4FUA/f6BFwDf\n", + "GmnKcgt/39XYoz+uN+AA4GrgNuDzwKp+/qHA5UPGn0L9o6fmzQycTLf/5Sbgq/1tzYhzrqU7amsz\n", + "8K5+3jnAOQNjLuyX3wy8dAx+H+bMTHcgxD0DP9O/H+e8O429GHjDuP+M++n/SHcE1S3A28c9M91a\n", + "3Gf63+NbgDdXzHop3RU1/oVure3s3X3feXKfJKmYm6ckScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", + "UjFLQ1pi/aXovxURz+qnn9VPP7d2Nml3WRrSEsvMLXQXBXxvP+u9wEWZ+e16qaSl4cl90jKIiJXA\n", + "l+nOvP5Vuu8zeaxuKmn37XUXLJRGITMfjYjfB64ATrMwtKdw85S0fNbSXffnRbWDSEvF0pCWQUS8\n", + "hO5KpycCvxsRw74PRZo4loa0xPpL0X+A7suutgD/DfjvdVNJS8PSkJberwMzmfmFfvp/AkdHxM9V\n", + "zCQtCY+ekiQVc01DklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxSwNSVKx/w8QfuxjT/fu\n", + "yQAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#KNN TEST\n", + "model = SensorimotorModel.from_configuration(environment.conf, 'WNN', 'default')\n", + "\n", + "for m in random_motors:\n", + " s = environment.compute_sensori_effect(m)\n", + " # compute the sensori effect s of the motor command m through the environment\n", + " model.update(m, s)\n", + " \n", + "sTest_pred = model.forward_prediction(mTest)\n", + "print sTest_pred\n", + "distance[\"WNN\"] = abs(sTest_pred-sTest)\n", + "\n", + "%pylab inline\n", + "ax = axes()\n", + "environment.plot_arm(ax, mTest)\n", + "ax.plot(*sTest_pred, marker='o', color='red')\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From efa4031337c8ee6f4f8afc6844ffe8139e2cb50d Mon Sep 17 00:00:00 2001 From: Roxane Date: Wed, 3 Feb 2016 22:24:48 +0100 Subject: [PATCH 03/13] WIP comparing SMM notebook : started inverse model but need some informations --- ...g_sensorimotor_models_non_parametric.ipynb | 874 ++++++------------ 1 file changed, 264 insertions(+), 610 deletions(-) diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb index dba66c6..c4e7469 100644 --- a/notebook/comparing_sensorimotor_models_non_parametric.ipynb +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "collapsed": true }, @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "collapsed": false }, @@ -111,33 +111,38 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Forward or inverse model ?\n", + "### Eploit or explore mode ?\n", + "\n", + "All the non-parametric sensorimotor models have two operating modes: \"explore\" and \"exploit\".\n", + "\n", + "In the \"explore\" mode, when the agent asks for the exact inverse prediction $m$ of a goal $s_g$, $m$ will be perturbated with some gaussian exploration noise in order to allow the agent to explore new motor commands. The sensorimotor models thus have a common parameter: sigma_explo_ratio=0.1 (default), which is the standard deviation of the gaussian noise, scaled depending of the motor domain size: if a motor value is bounded in [-2:2], then a sigma_explo_ratio of 0.1 will induce an exploration noise of (m_max - m_min) * sigma_explo_ratio = 0.4\n", "\n", - "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. " + "In the \"exploit\" mode, no exploration noise is added. This mode is used for instance when evaluating the inverse model for comparison purposes.\n", + "\n", + "*How to change it ? *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Forward models comparison\n", - "For each model : \n", - "* Output descrptions\n", - "* Processing description\n", - "* When should it (or not) be used\n", - "* Time processing\n", - "* Distance between sg et s" + "### Forward or inverse model ?\n", + "\n", + "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. \n", + "\n", + "In any case, it is possible to load the different library this way : " ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 8, "metadata": { "collapsed": true }, "outputs": [], "source": [ "from scipy import spatial\n", + "import numpy as np\n", "import time\n", "\n", "#Environment definition\n", @@ -152,19 +157,33 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Nearest Neighbor forward model\n", + "### Forward models comparison\n", + "For each model : \n", + "* Output descrptions\n", + "* Processing description\n", + "* When should it (or not) be used\n", + "* Time processing\n", + "* Distance between sg et s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Calculation comparison & computation\n", "\n", + "##### Nearest Neighbor forward model\n", "\n", "To perform a forward prediction, the Nearest Neighbor model just looks in the dataset of tuples $(m, s)$ for the nearest neighbor of the given $m$ motor command, and returns its corresponding $s$.\n", - "The algorithm comes from scipy library : [scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html) (with x = $s_g$, k=1, eps = 0, p = 2, radius = +inf). It returns distance and indexes of found nearest neighbors.\n", + "The algorithm comes from scipy library : [scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html) (with x = $s$, k=1, eps = 0, p = 2, radius = +inf). It returns distance and indexes of found nearest neighbors.\n", "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. \n", "\n", - "Let's see how to use it and its results :" + "Let's see how to use it : " ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 24, "metadata": { "collapsed": false }, @@ -183,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 25, "metadata": { "collapsed": false }, @@ -205,181 +224,59 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 26, "metadata": { "collapsed": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.24177072005089387, 0.16694489498320747, 0.70232748022294833, 0.00026514530181884763, 0.00027393861162125976, 0.002167940139770508]\n" - ] - } - ], + "outputs": [], "source": [ "# Distance between the predictive and effectiv value\n", "comparison = {}\n", "comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]\n", - "print comparison['NN']" + " np.mean(timer), np.std(timer), max(timer)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#DRAFT bac a sable" + "##### Weighted Nearest Neighbor forward model\n", + "\n", + "To perform a forward prediction of $m$, the Weighted Nearest Neighbor model looks at the $k$ (parameter) nearest neighbors of $m$ in the dataset, and returns the average of the $k$ corresponding $s$. This average is weighted by the distance to $m$ with a gaussian of standard deviation $\\sigma$ (parameter). It is the same algorithm than for NN model with k = n the number of interesting neigbhors. ([scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html)) It returns *How to choose the number of k? ? Can we change it? how does it compute ?*\n", + "\n", + "In order to compute WNN, the process is exactly the same than for NN research but these lines :" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 10, "metadata": { "collapsed": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAFcZJREFUeJzt3Xu0pXV93/H3d2bwgo6OFLkIY8YIMRCNIilBIXpEscPU\n", - "4qXRBGNFSA1NF5AmbeOtqw/PH1kxaZsQZNVSL4iJC6yxtSjjBYQjJI0kqCAqBIgcGCSOBYGCoOHy\n", - "7R/PM7Bnzj7n/M6Zc/Zv7zPv11p77f08z2/2/sxZZ+/Pea47MhNJkkqsqR1AkjQ5LA1JUjFLQ5JU\n", - "zNKQJBWzNCRJxSwNSVKxqqURER+NiO0Rcf08Y86JiJsj4rqIOGKU+SRJO6u9pnE+sHmuhRGxBTgk\n", - "Mw8FfgP44KiCSZJmq1oamXkVcM88Q04ELujHXg1siIj9R5FNkjRb7TWNhRwEbBuYvgM4uFIWSdrj\n", - "jXtpAMQu0173RJIqWVc7wAK+B2wcmD64n7eTiLBIJGkJMnPXP8znNe6lcTFwOnBRRBwN3JuZ24cN\n", - "XOx/vEREnJWZZy33866kScs8aXnBzKMwaXlhYjMv+g/uqqURERcCrwT2jYhtQAPsBZCZ52Xm1ojY\n", - "EhG3AD8CTqmXVpJUtTQy86SCMaePIoskaWGTsCO8punaAZZgunaARZquHWAJpmsHWILp2gEWabp2\n", - "gCWYrh1gFGI1fAlTRORK7NOQpNVsKZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilUtjYjYHBE3RsTNEfGuIcunIuK+iPhGf/sPNXJKkjrrar1wRKwFzgVeA3wP+JuI\n", - "uDgzb9hl6Fcy88SRB5QkzVJzTeMo4JbMnMnMh4GLgNcPGRejjSVJmkvN0jgI2DYwfUc/b1ACL4+I\n", - "6yJia0QcPrJ0kqRZqm2eoiuEhXwd2JiZD0bECcBngJ8ZNjAizhqYnM7M6d1OKEmrSERMAVO79RyZ\n", - "JZ/dyy8ijgbOyszN/fR7gMcy8w/m+Te3Akdm5g93mZ+Z6WYsSVqEpXx21tw8dQ1waERsiognAb8C\n", - "XDw4ICL2j4joHx9FV3I/nP1UkqRRqLZ5KjMfiYjTgS8Ca4GPZOYNEXFav/w84JeB34yIR4AHgV+t\n", - "lVeSVHHz1HJy85QkLd6kbZ6SJE0YS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWrWhoRsTkiboyImyPiXXOMOadffl1EHDHqjJKkJ1QrjYhYC5wLbAYOB06KiMN2\n", - "GbMFOCQzDwV+A/jgyINqRUTEloj4QkRM9/dbameStLB1cy2IiM8D/zozb12h1z4KuCUzZ/rXuwh4\n", - "PXDDwJgTgQsAMvPqiNgQEftn5vYVyqQR6AviT4BDBmY/PyLIzK2VYkkqMN+axkeBL0bE+yJirxV4\n", - "7YOAbQPTd/TzFhpz8Apk0Widyc6FQT99RoUskhZhzjWNzPxUv7bxH4FrIuJPgXxicf7Rbr52LjwE\n", - "gCj5dxFx1sDkdGZOLyGTRuMpw2but99+R7Zt+1rgy03TPDriTNKqFxFTwNTuPMecpdF7GHiA7k2+\n", - "Hnhsd15sF98DNg5Mb6Rbk5hvzMH9vFky86xlzKaV9eNhM9evX/9s4IvAtrZtPwZ8rGma744ymLSa\n", - "9X9MT++Yjohmsc8RmcP/4I+IzcAfAZ8F2sx8cEkp53rhiHXA3wKvBu4E/ho4KTNvGBizBTg9M7dE\n", - "xNHA2Zl59JDnyszcdY1EY2rYPo01a9bcdtxxx1157LHHHgs8b2D4NN2m0k83TbOsv4PSnm4pn53z\n", - "lcZVwL/KzG8vR7g5XuME4GxgLfCRzPz9iDgNIDPP68fsOMLqR8Apmfn1Ic9jaUyYvjjOAJ4KPAR8\n", - "IDO3tm27BngFcCrwy/1ygPuBC4HzgaubpindvClpDstdGpFzLRwzlsbq1LbtM4G30BXI4BrmDXRr\n", - "H3/aNI1H0klLtKylMUksjdWvbdvDgVOAtwP79bMfBS6hK5CtTdM8XCmeNJEsDa16bdvuBZxAt/bx\n", - "OrpNmwA/AD4OnN80zXcqxZMmiqWhPUrbtgcAb6MrkMGrCVxNt/bxyaZp7quRTZoElob2SG3bBt0V\n", - "Bk4FTqI7PBy6HeyfpiuQrzRNs5yHjEsTz9LQHq9t272BN9EVyKsGFt1Kd+TVBU3T3F4jmzRuLA1p\n", - "QNu2Pw28o7/tOEk0gcvo1j4+0zTN0BMNpT2BpSEN0bbtWuA4urWPNwJP7hfdC3yCbg3k6577oT2N\n", - "pSEtoG3bfej2e5wCHDmw6Jt0ax+faJrmrhrZpFGzNKRFaNv2xXTl8TbgH/WzHwYupiuQLzVN80il\n", - "eNKKszSkJWjb9snAP6MrkM088ZUBd9J9n8v5TdPcXCmetGIsDWk3tW17EN1Z56ey83d+/AXd2sen\n", - "mqZ5oEY2ablZGtIy6c/9OIauPN4CPK1f9CPgf9AVyF+681yTzNKQVkDbtuuBN9MVyDEDi26mK4+P\n", - "N01zZ41s0u6wNKQV1rbtC+jO+zgZOLCf/RjwBboC+WzTNP9QJ520OJaGNCJt264DXku39nEisFe/\n", - "6C7gz+h2nn+zUjypiKUhVdC27bOBX6MrkBcNLPoa3drHhU3T3FMjmzQfS0OqqN95fiTdobtvBTb0\n", - "i34C/C+6AvmyF07UuLA0pDHRtu1TgTfQFchrgB2/n7cDHwM+1jTNrXXSSR1LQxpDbdv+FN2O81OA\n", - "TQOLPgGc3DTNozVySZaGNMbatl0DTNGVx5vpLpz4iqZprqqZS3uupXx2rlupMJJ21u/LuBy4vG3b\n", - "e4AzgOMBS0MTY83CQyStgEv7++OrppAWydKQ6pgGHgGOatt2wwJjpbFhaUgVNE1zP/BVuvfgqxYY\n", - "Lo0NS0Oqx01UmjiWhlSPpaGJY2lI9fwNcB9wSNu2m+pGkcpYGlIl/VfJXtFPurahiWBpSHW5iUoT\n", - "xdKQ6tpRGq9u23Zt1SRSAUtDqusW4DZgH+CIylmkBVkaUkX9d4y7iUoTw9KQ6rM0NDEsDam+LwMJ\n", - "HNO27d61w0jzsTSkypqmuZvuq2GfBLyichxpXpaGNB7cRKWJYGlI48HS0ESwNKTx8H+AB4EXtW17\n", - "QO0w0lwsDWkMNE3zE+DKfvI1NbNI87E0pPHhJiqNPUtDGh+Pl0bbtlE1iTQHS0MaH98Cvg8cCBxe\n", - "OYs0lKUhjYn+kiKX9ZNuotJYsjSk8eJ+DY01S0MaLzvWNF7Ztu2TqiaRhrA0pDHSNM2dwE3A04Cf\n", - "qxxHmsXSkMbPzf39T1VNIQ2xrsaLRsQ+wCfp3hQzwFsy894h42aA/wc8CjycmUeNMKZUy0x/v6li\n", - "BmmoWmsa7wYuzcyfobss9LvnGJfAVGYeYWFoDzLT32+qmEEaqlZpnAhc0D++AHjDPGM9yUl7mpn+\n", - "flPFDNJQtUpj/8zc3j/eDuw/x7gELouIayLinaOJJlU3099vqphBGmrF9mlExKXAsKt1vm9wIjMz\n", - "InKOpzkmM/8+Ip4NXBoRN2bmVXO83lkDk9OZOb2E2NI4mOnvN1XMoFUoIqaAqd16jsy5Pq9XTkTc\n", - "SLev4vsRcSBwRWb+7AL/pgEeyMz/MmRZZqabsbQq9Nedup/usNtnNU0z6yARaTks5bOz1uapi4GT\n", - "+8cnA5/ZdUBE7B0R6/vHTwNeC1w/soRSJf3lRGb6yU31kkiz1SqN9wPHR8RNwHH9NBHxnIi4pB9z\n", - "AHBVRFwLXA18LjO/VCWtNHoz/f2mihmkWaqcp5GZP2TIF81k5p3AP+0ffxd4yYijSeNipr/fVDGD\n", - "NItnhEvjaaa/31QxgzSLpSGNp5n+flPFDNIsloY0nmb6+00VM0izWBrSeJrp7zdVzCDNYmlI4+lu\n", - "4EfAM9u23VA7jLSDpSGNIc/V0LiqcsitpCIzdF/EdEnbtluBrcBlTdPcXzWV9mhVLiOy3LyMiFaj\n", - "tm1fB/x34MCB2Q8DV9EVyFbgxn6tRFq0pXx2WhrSGOuvQ/ViYEt/exk7b1ae4YkCuaJpmgdHnVGT\n", - "y9KQVrm2bfehuw7bFuAEYN+BxT8BrqArkM83TXPL6BNqklga0h6kbds1wC/wxFrIL7Dzl5bdzBNr\n", - "IVc2TfPjkYfUWLM0pD1Y27b7Af+ErkA2A4OH6j5I99XKW4FPNU1z9+gTatxYGpIAaNt2HfCLPLEW\n", - "Mnjxz4eAjwNnN01zY4V4GhOWhqSh2rY9iG7t4810ayM7XAL8MXC5R2HteSwNSQtq2/Yw4N8Abwee\n", - "0s/+Jl15XNg0zU9qZdNoWRqSirVt+2zgNOB0YP9+9nbgXOC/NU1zV61sGg1LQ9KitW37ZOAk4LeB\n", - "n+9n/5huv8d5wG3AfU3TPFInoVaKpSFpyfoTCY8Dfodu5/muHgDuAe7tb4OPfwh8rmmar40mrZaD\n", - "pSFpWbRt+7N0+z2OB55Fd/huyXvsL84999xH7rrrrjXArh8uM5n5jmUNqt1iaUhaEf2JhOvpymMD\n", - "TxTJjtvz6XasP+P888/ntttuG/Y0X8nMqZEEVhFLQ1I1bduuB07+8Ic//Id33HHHU4cMsTTGjKUh\n", - "qbqImAZeOWSRpTFmlvLZ6fdpSKvUCyO2bIQz18NT7ocfb4NzvpW5tXYuTTZLQ1qFXhix5WXwJx+C\n", - "Q3bMeyc8/4URWBzaHZaGtApthDMHCwPgQ3DIFjiD7qKFK2lmkfM1QSwNaRVa/8TlQXbydBi2g3pZ\n", - "eVjt6rZm4SGSJs393RndszzQXeFWWjJLQ1qFtsE574SdvrnvX8Lf3Q4fqJVJq4OH3Eqr1AsjtjwX\n", - "zng6PPUBeOh2+IA7wTXI8zQkScWW8tnp5ilJUjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQV\n", - "szQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxaqURkS8OSK+HRGPRsRL\n", - "5xm3OSJujIibI+Jdo8woSZqt1prG9cAbgSvnGhARa4Fzgc3A4cBJEXHYaOI9nmFqlK+3HCYt86Tl\n", - "BTOPwqTlhcnMvBRVSiMzb8zMmxYYdhRwS2bOZObDwEXA61c+3U6mRvx6y2GqdoBFmqodYAmmagdY\n", - "gqnaARZpqnaAJZiqHWAUxnmfxkHAtoHpO/p5kqRK1q3UE0fEpcABQxa9NzM/W/AUucyRJEm7KTLr\n", - "fTZHxBXAv83Mrw9ZdjRwVmZu7qffAzyWmX8wZKwFI0lLkJmxmPErtqaxCHMFvgY4NCI2AXcCvwKc\n", - "NGzgYv/TkqSlqXXI7RsjYhtwNHBJRHy+n/+ciLgEIDMfAU4Hvgh8B/hkZt5QI68kqVN185QkabKM\n", - "89FTIxcR+0TEpRFxU0R8KSI2zDN2bUR8IyJKduqvmJLMEbExIq7oT6j8VkScWSHngidqRsQ5/fLr\n", - "IuKIUWcckmfezBHxa33Wb0bEX0bEz9fIOZCn6GTYiPjHEfFIRLxplPnmyFLyezHVv9e+FRHTI444\n", - "LM9Cvxf7RsQXIuLaPvM7KsTckeWjEbE9Iq6fZ8zi3neZ6a2/AX8I/G7/+F3A++cZ+zvAJ4CLxz0z\n", - "3VFsL+kfPx34W+CwEWZcC9wCbAL2Aq7d9fWBLcDW/vEvAl+t/HMtyfwy4Jn94801M5fkHRh3OfA5\n", - "4J9PwM94A/Bt4OB+et8JyHwW8Ps78gJ3A+sq5f0l4Ajg+jmWL/p955rGzk4ELugfXwC8YdigiDiY\n", - "7of9YebekT8qC2bOzO9n5rX94weAG4DnjCxh2Ymaj/8/MvNqYENE7D/CjLtaMHNm/lVm3tdPXg0c\n", - "POKMg0pPhj0D+HPg/44y3BxKMr8V+HRm3gGQmXeNOOOuSjL/PfCM/vEzgLuz20c7cpl5FXDPPEMW\n", - "/b6zNHa2f2Zu7x9vB+b64f0x8O+Bx0aSan6lmQHoj0Y7gu5DblRKTtQcNqbmh/BiTy79dWDriiaa\n", - "34J5I+Igug+4D/azau/QLPkZHwrs029evSYi/sXI0g1XkvlDwM9FxJ3AdcBvjSjbUiz6fTcOh9yO\n", - "1DwnHb5vcCIzc9j5HxHxOuAHmfmNUV1rZnczDzzP0+n+yvytfo1jVEo/nHZda6v5oVb82hHxKuBU\n", - "4JiVi7OgkrxnA+/uf0+C+mvJJZn3Al4KvBrYG/iriPhqZt68osnmVpL5vcC1mTkVEc8HLo2IF2fm\n", - "/SucbakW9b7b40ojM4+fa1m/w+iAzPx+RBwI/GDIsJcDJ0bEFuApwDMi4uOZ+fYVirwcmYmIvYBP\n", - "A3+WmZ9Zoahz+R6wcWB6I91fNPONObifV0tJZvqd3x8CNmfmfJsBVlpJ3iOBi7q+YF/ghIh4ODMv\n", - "Hk3EWUoybwPuysyHgIci4krgxUCt0ijJ/HLg9wAy8+8i4lbgBXTnno2bRb/v3Dy1s4uBk/vHJwOz\n", - "Plwz872ZuTEznwf8KnD5ShZGgQUz939VfgT4TmaePcJsOzx+omZEPInuRM1dP6guBt4Oj18N4N6B\n", - "zW41LJg5Ip4L/E/gbZl5S4WMgxbMm5k/nZnP6393/xz4zYqFAWW/F/8bOLY/WnFvup213xlxzkEl\n", - "mW8EXgPQ7x94AfDdkaYst/j3XY09+uN6A/YBLgNuAr4EbOjnPwe4ZMj4V1L/6KkFMwPH0u1/uRb4\n", - "Rn/bPOKcJ9AdtXUL8J5+3mnAaQNjzu2XXwe8dAx+H+bNTHcgxN0DP9O/Hue8u4w9H3jTuP+M++l/\n", - "R3cE1fXAmeOemW4t7rP97/H1wFsrZr2Q7ooa/0C31nbq7r7vPLlPklTMzVOSpGKWhiSpmKUhSSpm\n", - "aUiSilkakqRiloYkqZilIS2z/lL0342IZ/XTz+qnn1s7m7S7LA1pmWXmNrqLAr6/n/V+4LzMvL1e\n", - "Kml5eHKftAIiYh3wNbozr3+d7vtMHq2bStp9e9wFC6VRyMxHIuJ3gc8Dx1sYWi3cPCWtnBPorvvz\n", - "otpBpOViaUgrICJeQnel05cBvx0Rw74PRZo4loa0zPpL0X+Q7suutgH/CfjPdVNJy8PSkJbfO4GZ\n", - "zPxyP/1fgcMi4pcqZpKWhUdPSZKKuaYhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaG\n", - "JKnY/wfSP/dwYGt2YAAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "#NN TEST\n", - "for m in testing_couples\n", - " \n", - "sTest_pred = model.forward_prediction(mTest)\n", - "distance[\"NN\"] = abs(sTest_pred-sTest)\n", + "sm_cls, sm_configs = sensorimotor_models['WNN']" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "comparison['WNN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Locally Weighted Linear Regression forward model\n", "\n", - "%pylab inline\n", - "ax = axes()\n", - "environment.plot_arm(ax, mTest)\n", - "ax.plot(*sTest_pred, marker='o', color='red')" + "The LWLR computes a linear regression of the $k$ nearest neighbors of $m$ (thus a local regression), and find the requested $s$ with the given $m$ based on that regression. *Ewplain which method is used to compute linear regression*" ] }, { @@ -388,478 +285,235 @@ "metadata": { "collapsed": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAFcZJREFUeJzt3Xu0pXV93/H3d2bwgo6OFLkIY8YIMRCNIilBIXpEscPU\n", - "4qXRBGNFSA1NF5AmbeOtqw/PH1kxaZsQZNVSL4iJC6yxtSjjBYQjJI0kqCAqBIgcGCSOBYGCoOHy\n", - "7R/PM7Bnzj7n/M6Zc/Zv7zPv11p77f08z2/2/sxZZ+/Pea47MhNJkkqsqR1AkjQ5LA1JUjFLQ5JU\n", - "zNKQJBWzNCRJxSwNSVKxqqURER+NiO0Rcf08Y86JiJsj4rqIOGKU+SRJO6u9pnE+sHmuhRGxBTgk\n", - "Mw8FfgP44KiCSZJmq1oamXkVcM88Q04ELujHXg1siIj9R5FNkjRb7TWNhRwEbBuYvgM4uFIWSdrj\n", - "jXtpAMQu0173RJIqWVc7wAK+B2wcmD64n7eTiLBIJGkJMnPXP8znNe6lcTFwOnBRRBwN3JuZ24cN\n", - "XOx/vEREnJWZZy33866kScs8aXnBzKMwaXlhYjMv+g/uqqURERcCrwT2jYhtQAPsBZCZ52Xm1ojY\n", - "EhG3AD8CTqmXVpJUtTQy86SCMaePIoskaWGTsCO8punaAZZgunaARZquHWAJpmsHWILp2gEWabp2\n", - "gCWYrh1gFGI1fAlTRORK7NOQpNVsKZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilUtjYjYHBE3RsTNEfGuIcunIuK+iPhGf/sPNXJKkjrrar1wRKwFzgVeA3wP+JuI\n", - "uDgzb9hl6Fcy88SRB5QkzVJzTeMo4JbMnMnMh4GLgNcPGRejjSVJmkvN0jgI2DYwfUc/b1ACL4+I\n", - "6yJia0QcPrJ0kqRZqm2eoiuEhXwd2JiZD0bECcBngJ8ZNjAizhqYnM7M6d1OKEmrSERMAVO79RyZ\n", - "JZ/dyy8ijgbOyszN/fR7gMcy8w/m+Te3Akdm5g93mZ+Z6WYsSVqEpXx21tw8dQ1waERsiognAb8C\n", - "XDw4ICL2j4joHx9FV3I/nP1UkqRRqLZ5KjMfiYjTgS8Ca4GPZOYNEXFav/w84JeB34yIR4AHgV+t\n", - "lVeSVHHz1HJy85QkLd6kbZ6SJE0YS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWrWhoRsTkiboyImyPiXXOMOadffl1EHDHqjJKkJ1QrjYhYC5wLbAYOB06KiMN2\n", - "GbMFOCQzDwV+A/jgyINqRUTEloj4QkRM9/dbameStLB1cy2IiM8D/zozb12h1z4KuCUzZ/rXuwh4\n", - "PXDDwJgTgQsAMvPqiNgQEftn5vYVyqQR6AviT4BDBmY/PyLIzK2VYkkqMN+axkeBL0bE+yJirxV4\n", - "7YOAbQPTd/TzFhpz8Apk0Widyc6FQT99RoUskhZhzjWNzPxUv7bxH4FrIuJPgXxicf7Rbr52LjwE\n", - "gCj5dxFx1sDkdGZOLyGTRuMpw2but99+R7Zt+1rgy03TPDriTNKqFxFTwNTuPMecpdF7GHiA7k2+\n", - "Hnhsd15sF98DNg5Mb6Rbk5hvzMH9vFky86xlzKaV9eNhM9evX/9s4IvAtrZtPwZ8rGma744ymLSa\n", - "9X9MT++Yjohmsc8RmcP/4I+IzcAfAZ8F2sx8cEkp53rhiHXA3wKvBu4E/ho4KTNvGBizBTg9M7dE\n", - "xNHA2Zl59JDnyszcdY1EY2rYPo01a9bcdtxxx1157LHHHgs8b2D4NN2m0k83TbOsv4PSnm4pn53z\n", - "lcZVwL/KzG8vR7g5XuME4GxgLfCRzPz9iDgNIDPP68fsOMLqR8Apmfn1Ic9jaUyYvjjOAJ4KPAR8\n", - "IDO3tm27BngFcCrwy/1ygPuBC4HzgaubpindvClpDstdGpFzLRwzlsbq1LbtM4G30BXI4BrmDXRr\n", - "H3/aNI1H0klLtKylMUksjdWvbdvDgVOAtwP79bMfBS6hK5CtTdM8XCmeNJEsDa16bdvuBZxAt/bx\n", - "OrpNmwA/AD4OnN80zXcqxZMmiqWhPUrbtgcAb6MrkMGrCVxNt/bxyaZp7quRTZoElob2SG3bBt0V\n", - "Bk4FTqI7PBy6HeyfpiuQrzRNs5yHjEsTz9LQHq9t272BN9EVyKsGFt1Kd+TVBU3T3F4jmzRuLA1p\n", - "QNu2Pw28o7/tOEk0gcvo1j4+0zTN0BMNpT2BpSEN0bbtWuA4urWPNwJP7hfdC3yCbg3k6577oT2N\n", - "pSEtoG3bfej2e5wCHDmw6Jt0ax+faJrmrhrZpFGzNKRFaNv2xXTl8TbgH/WzHwYupiuQLzVN80il\n", - "eNKKszSkJWjb9snAP6MrkM088ZUBd9J9n8v5TdPcXCmetGIsDWk3tW17EN1Z56ey83d+/AXd2sen\n", - "mqZ5oEY2ablZGtIy6c/9OIauPN4CPK1f9CPgf9AVyF+681yTzNKQVkDbtuuBN9MVyDEDi26mK4+P\n", - "N01zZ41s0u6wNKQV1rbtC+jO+zgZOLCf/RjwBboC+WzTNP9QJ520OJaGNCJt264DXku39nEisFe/\n", - "6C7gz+h2nn+zUjypiKUhVdC27bOBX6MrkBcNLPoa3drHhU3T3FMjmzQfS0OqqN95fiTdobtvBTb0\n", - "i34C/C+6AvmyF07UuLA0pDHRtu1TgTfQFchrgB2/n7cDHwM+1jTNrXXSSR1LQxpDbdv+FN2O81OA\n", - "TQOLPgGc3DTNozVySZaGNMbatl0DTNGVx5vpLpz4iqZprqqZS3uupXx2rlupMJJ21u/LuBy4vG3b\n", - "e4AzgOMBS0MTY83CQyStgEv7++OrppAWydKQ6pgGHgGOatt2wwJjpbFhaUgVNE1zP/BVuvfgqxYY\n", - "Lo0NS0Oqx01UmjiWhlSPpaGJY2lI9fwNcB9wSNu2m+pGkcpYGlIl/VfJXtFPurahiWBpSHW5iUoT\n", - "xdKQ6tpRGq9u23Zt1SRSAUtDqusW4DZgH+CIylmkBVkaUkX9d4y7iUoTw9KQ6rM0NDEsDam+LwMJ\n", - "HNO27d61w0jzsTSkypqmuZvuq2GfBLyichxpXpaGNB7cRKWJYGlI48HS0ESwNKTx8H+AB4EXtW17\n", - "QO0w0lwsDWkMNE3zE+DKfvI1NbNI87E0pPHhJiqNPUtDGh+Pl0bbtlE1iTQHS0MaH98Cvg8cCBxe\n", - "OYs0lKUhjYn+kiKX9ZNuotJYsjSk8eJ+DY01S0MaLzvWNF7Ztu2TqiaRhrA0pDHSNM2dwE3A04Cf\n", - "qxxHmsXSkMbPzf39T1VNIQ2xrsaLRsQ+wCfp3hQzwFsy894h42aA/wc8CjycmUeNMKZUy0x/v6li\n", - "BmmoWmsa7wYuzcyfobss9LvnGJfAVGYeYWFoDzLT32+qmEEaqlZpnAhc0D++AHjDPGM9yUl7mpn+\n", - "flPFDNJQtUpj/8zc3j/eDuw/x7gELouIayLinaOJJlU3099vqphBGmrF9mlExKXAsKt1vm9wIjMz\n", - "InKOpzkmM/8+Ip4NXBoRN2bmVXO83lkDk9OZOb2E2NI4mOnvN1XMoFUoIqaAqd16jsy5Pq9XTkTc\n", - "SLev4vsRcSBwRWb+7AL/pgEeyMz/MmRZZqabsbQq9Nedup/usNtnNU0z6yARaTks5bOz1uapi4GT\n", - "+8cnA5/ZdUBE7B0R6/vHTwNeC1w/soRSJf3lRGb6yU31kkiz1SqN9wPHR8RNwHH9NBHxnIi4pB9z\n", - "AHBVRFwLXA18LjO/VCWtNHoz/f2mihmkWaqcp5GZP2TIF81k5p3AP+0ffxd4yYijSeNipr/fVDGD\n", - "NItnhEvjaaa/31QxgzSLpSGNp5n+flPFDNIsloY0nmb6+00VM0izWBrSeJrp7zdVzCDNYmlI4+lu\n", - "4EfAM9u23VA7jLSDpSGNIc/V0LiqcsitpCIzdF/EdEnbtluBrcBlTdPcXzWV9mhVLiOy3LyMiFaj\n", - "tm1fB/x34MCB2Q8DV9EVyFbgxn6tRFq0pXx2WhrSGOuvQ/ViYEt/exk7b1ae4YkCuaJpmgdHnVGT\n", - "y9KQVrm2bfehuw7bFuAEYN+BxT8BrqArkM83TXPL6BNqklga0h6kbds1wC/wxFrIL7Dzl5bdzBNr\n", - "IVc2TfPjkYfUWLM0pD1Y27b7Af+ErkA2A4OH6j5I99XKW4FPNU1z9+gTatxYGpIAaNt2HfCLPLEW\n", - "Mnjxz4eAjwNnN01zY4V4GhOWhqSh2rY9iG7t4810ayM7XAL8MXC5R2HteSwNSQtq2/Yw4N8Abwee\n", - "0s/+Jl15XNg0zU9qZdNoWRqSirVt+2zgNOB0YP9+9nbgXOC/NU1zV61sGg1LQ9KitW37ZOAk4LeB\n", - "n+9n/5huv8d5wG3AfU3TPFInoVaKpSFpyfoTCY8Dfodu5/muHgDuAe7tb4OPfwh8rmmar40mrZaD\n", - "pSFpWbRt+7N0+z2OB55Fd/huyXvsL84999xH7rrrrjXArh8uM5n5jmUNqt1iaUhaEf2JhOvpymMD\n", - "TxTJjtvz6XasP+P888/ntttuG/Y0X8nMqZEEVhFLQ1I1bduuB07+8Ic//Id33HHHU4cMsTTGjKUh\n", - "qbqImAZeOWSRpTFmlvLZ6fdpSKvUCyO2bIQz18NT7ocfb4NzvpW5tXYuTTZLQ1qFXhix5WXwJx+C\n", - "Q3bMeyc8/4URWBzaHZaGtApthDMHCwPgQ3DIFjiD7qKFK2lmkfM1QSwNaRVa/8TlQXbydBi2g3pZ\n", - "eVjt6rZm4SGSJs393RndszzQXeFWWjJLQ1qFtsE574SdvrnvX8Lf3Q4fqJVJq4OH3Eqr1AsjtjwX\n", - "zng6PPUBeOh2+IA7wTXI8zQkScWW8tnp5ilJUjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQV\n", - "szQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxaqURkS8OSK+HRGPRsRL\n", - "5xm3OSJujIibI+Jdo8woSZqt1prG9cAbgSvnGhARa4Fzgc3A4cBJEXHYaOI9nmFqlK+3HCYt86Tl\n", - "BTOPwqTlhcnMvBRVSiMzb8zMmxYYdhRwS2bOZObDwEXA61c+3U6mRvx6y2GqdoBFmqodYAmmagdY\n", - "gqnaARZpqnaAJZiqHWAUxnmfxkHAtoHpO/p5kqRK1q3UE0fEpcABQxa9NzM/W/AUucyRJEm7KTLr\n", - "fTZHxBXAv83Mrw9ZdjRwVmZu7qffAzyWmX8wZKwFI0lLkJmxmPErtqaxCHMFvgY4NCI2AXcCvwKc\n", - "NGzgYv/TkqSlqXXI7RsjYhtwNHBJRHy+n/+ciLgEIDMfAU4Hvgh8B/hkZt5QI68kqVN185QkabKM\n", - "89FTIxcR+0TEpRFxU0R8KSI2zDN2bUR8IyJKduqvmJLMEbExIq7oT6j8VkScWSHngidqRsQ5/fLr\n", - "IuKIUWcckmfezBHxa33Wb0bEX0bEz9fIOZCn6GTYiPjHEfFIRLxplPnmyFLyezHVv9e+FRHTI444\n", - "LM9Cvxf7RsQXIuLaPvM7KsTckeWjEbE9Iq6fZ8zi3neZ6a2/AX8I/G7/+F3A++cZ+zvAJ4CLxz0z\n", - "3VFsL+kfPx34W+CwEWZcC9wCbAL2Aq7d9fWBLcDW/vEvAl+t/HMtyfwy4Jn94801M5fkHRh3OfA5\n", - "4J9PwM94A/Bt4OB+et8JyHwW8Ps78gJ3A+sq5f0l4Ajg+jmWL/p955rGzk4ELugfXwC8YdigiDiY\n", - "7of9YebekT8qC2bOzO9n5rX94weAG4DnjCxh2Ymaj/8/MvNqYENE7D/CjLtaMHNm/lVm3tdPXg0c\n", - "POKMg0pPhj0D+HPg/44y3BxKMr8V+HRm3gGQmXeNOOOuSjL/PfCM/vEzgLuz20c7cpl5FXDPPEMW\n", - "/b6zNHa2f2Zu7x9vB+b64f0x8O+Bx0aSan6lmQHoj0Y7gu5DblRKTtQcNqbmh/BiTy79dWDriiaa\n", - "34J5I+Igug+4D/azau/QLPkZHwrs029evSYi/sXI0g1XkvlDwM9FxJ3AdcBvjSjbUiz6fTcOh9yO\n", - "1DwnHb5vcCIzc9j5HxHxOuAHmfmNUV1rZnczDzzP0+n+yvytfo1jVEo/nHZda6v5oVb82hHxKuBU\n", - "4JiVi7OgkrxnA+/uf0+C+mvJJZn3Al4KvBrYG/iriPhqZt68osnmVpL5vcC1mTkVEc8HLo2IF2fm\n", - "/SucbakW9b7b40ojM4+fa1m/w+iAzPx+RBwI/GDIsJcDJ0bEFuApwDMi4uOZ+fYVirwcmYmIvYBP\n", - "A3+WmZ9Zoahz+R6wcWB6I91fNPONObifV0tJZvqd3x8CNmfmfJsBVlpJ3iOBi7q+YF/ghIh4ODMv\n", - "Hk3EWUoybwPuysyHgIci4krgxUCt0ijJ/HLg9wAy8+8i4lbgBXTnno2bRb/v3Dy1s4uBk/vHJwOz\n", - "Plwz872ZuTEznwf8KnD5ShZGgQUz939VfgT4TmaePcJsOzx+omZEPInuRM1dP6guBt4Oj18N4N6B\n", - "zW41LJg5Ip4L/E/gbZl5S4WMgxbMm5k/nZnP6393/xz4zYqFAWW/F/8bOLY/WnFvup213xlxzkEl\n", - "mW8EXgPQ7x94AfDdkaYst/j3XY09+uN6A/YBLgNuAr4EbOjnPwe4ZMj4V1L/6KkFMwPH0u1/uRb4\n", - "Rn/bPOKcJ9AdtXUL8J5+3mnAaQNjzu2XXwe8dAx+H+bNTHcgxN0DP9O/Hue8u4w9H3jTuP+M++l/\n", - "R3cE1fXAmeOemW4t7rP97/H1wFsrZr2Q7ooa/0C31nbq7r7vPLlPklTMzVOSpGKWhiSpmKUhSSpm\n", - "aUiSilkakqRiloYkqZilIS2z/lL0342IZ/XTz+qnn1s7m7S7LA1pmWXmNrqLAr6/n/V+4LzMvL1e\n", - "Kml5eHKftAIiYh3wNbozr3+d7vtMHq2bStp9e9wFC6VRyMxHIuJ3gc8Dx1sYWi3cPCWtnBPorvvz\n", - "otpBpOViaUgrICJeQnel05cBvx0Rw74PRZo4loa0zPpL0X+Q7suutgH/CfjPdVNJy8PSkJbfO4GZ\n", - "zPxyP/1fgcMi4pcqZpKWhUdPSZKKuaYhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaG\n", - "JKnY/wfSP/dwYGt2YAAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "#NN TEST\n", - "for m in testing_couples\n", - " \n", - "sTest_pred = model.forward_prediction(mTest)\n", - "distance[\"NN\"] = abs(sTest_pred-sTest)\n", + "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS']" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "comparison['LWLR'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Distance between $s$ and $s_p$ comparison\n", "\n", - "%pylab inline\n", - "ax = axes()\n", - "environment.plot_arm(ax, mTest)\n", - "ax.plot(*sTest_pred, marker='o', color='red')" + "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to his neighbors even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Time processing comparison\n", + "\n", + "NN model is far away better than his neighbor in speed processing in any case : around 4 times better than LWLR model and twine better than WNN with an equal standard deviation. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Forward models for Non-Stationnary environments\n", + "\n", + "'NSNN' and 'NSLWLR' are modified versions of 'NN' and 'LWLR' where points are not only weighted by distance but also by the number of points that appeared after that one (gaussian with parameter sigma_t=100), to put less weight on old points and allow the learning of Non-Stationnary environments. *How to use it ?*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###Inverse models comparison\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Calculation comparison & computation\n", + "\n", + "##### Nearest Neighbor inverse model\n", + "\n", + "\n", + "To perform the inverse inference, the Nearest Neighbor inverse model just look in the dataset of tuples $(m, s)$, the nearest neighbor of the given $s$ motor command, and return its corresponding $m$.\n", + "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. \n", + "\n", + "Let's see how to use it : *pas de random s?*" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 24, "metadata": { "collapsed": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAFcZJREFUeJzt3Xu0pXV93/H3d2bwgo6OFLkIY8YIMRCNIilBIXpEscPU\n", - "4qXRBGNFSA1NF5AmbeOtqw/PH1kxaZsQZNVSL4iJC6yxtSjjBYQjJI0kqCAqBIgcGCSOBYGCoOHy\n", - "7R/PM7Bnzj7n/M6Zc/Zv7zPv11p77f08z2/2/sxZZ+/Pea47MhNJkkqsqR1AkjQ5LA1JUjFLQ5JU\n", - "zNKQJBWzNCRJxSwNSVKxqqURER+NiO0Rcf08Y86JiJsj4rqIOGKU+SRJO6u9pnE+sHmuhRGxBTgk\n", - "Mw8FfgP44KiCSZJmq1oamXkVcM88Q04ELujHXg1siIj9R5FNkjRb7TWNhRwEbBuYvgM4uFIWSdrj\n", - "jXtpAMQu0173RJIqWVc7wAK+B2wcmD64n7eTiLBIJGkJMnPXP8znNe6lcTFwOnBRRBwN3JuZ24cN\n", - "XOx/vEREnJWZZy33866kScs8aXnBzKMwaXlhYjMv+g/uqqURERcCrwT2jYhtQAPsBZCZ52Xm1ojY\n", - "EhG3AD8CTqmXVpJUtTQy86SCMaePIoskaWGTsCO8punaAZZgunaARZquHWAJpmsHWILp2gEWabp2\n", - "gCWYrh1gFGI1fAlTRORK7NOQpNVsKZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilUtjYjYHBE3RsTNEfGuIcunIuK+iPhGf/sPNXJKkjrrar1wRKwFzgVeA3wP+JuI\n", - "uDgzb9hl6Fcy88SRB5QkzVJzTeMo4JbMnMnMh4GLgNcPGRejjSVJmkvN0jgI2DYwfUc/b1ACL4+I\n", - "6yJia0QcPrJ0kqRZqm2eoiuEhXwd2JiZD0bECcBngJ8ZNjAizhqYnM7M6d1OKEmrSERMAVO79RyZ\n", - "JZ/dyy8ijgbOyszN/fR7gMcy8w/m+Te3Akdm5g93mZ+Z6WYsSVqEpXx21tw8dQ1waERsiognAb8C\n", - "XDw4ICL2j4joHx9FV3I/nP1UkqRRqLZ5KjMfiYjTgS8Ca4GPZOYNEXFav/w84JeB34yIR4AHgV+t\n", - "lVeSVHHz1HJy85QkLd6kbZ6SJE0YS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWrWhoRsTkiboyImyPiXXOMOadffl1EHDHqjJKkJ1QrjYhYC5wLbAYOB06KiMN2\n", - "GbMFOCQzDwV+A/jgyINqRUTEloj4QkRM9/dbameStLB1cy2IiM8D/zozb12h1z4KuCUzZ/rXuwh4\n", - "PXDDwJgTgQsAMvPqiNgQEftn5vYVyqQR6AviT4BDBmY/PyLIzK2VYkkqMN+axkeBL0bE+yJirxV4\n", - "7YOAbQPTd/TzFhpz8Apk0Widyc6FQT99RoUskhZhzjWNzPxUv7bxH4FrIuJPgXxicf7Rbr52LjwE\n", - "gCj5dxFx1sDkdGZOLyGTRuMpw2but99+R7Zt+1rgy03TPDriTNKqFxFTwNTuPMecpdF7GHiA7k2+\n", - "Hnhsd15sF98DNg5Mb6Rbk5hvzMH9vFky86xlzKaV9eNhM9evX/9s4IvAtrZtPwZ8rGma744ymLSa\n", - "9X9MT++Yjohmsc8RmcP/4I+IzcAfAZ8F2sx8cEkp53rhiHXA3wKvBu4E/ho4KTNvGBizBTg9M7dE\n", - "xNHA2Zl59JDnyszcdY1EY2rYPo01a9bcdtxxx1157LHHHgs8b2D4NN2m0k83TbOsv4PSnm4pn53z\n", - "lcZVwL/KzG8vR7g5XuME4GxgLfCRzPz9iDgNIDPP68fsOMLqR8Apmfn1Ic9jaUyYvjjOAJ4KPAR8\n", - "IDO3tm27BngFcCrwy/1ygPuBC4HzgaubpindvClpDstdGpFzLRwzlsbq1LbtM4G30BXI4BrmDXRr\n", - "H3/aNI1H0klLtKylMUksjdWvbdvDgVOAtwP79bMfBS6hK5CtTdM8XCmeNJEsDa16bdvuBZxAt/bx\n", - "OrpNmwA/AD4OnN80zXcqxZMmiqWhPUrbtgcAb6MrkMGrCVxNt/bxyaZp7quRTZoElob2SG3bBt0V\n", - "Bk4FTqI7PBy6HeyfpiuQrzRNs5yHjEsTz9LQHq9t272BN9EVyKsGFt1Kd+TVBU3T3F4jmzRuLA1p\n", - "QNu2Pw28o7/tOEk0gcvo1j4+0zTN0BMNpT2BpSEN0bbtWuA4urWPNwJP7hfdC3yCbg3k6577oT2N\n", - "pSEtoG3bfej2e5wCHDmw6Jt0ax+faJrmrhrZpFGzNKRFaNv2xXTl8TbgH/WzHwYupiuQLzVN80il\n", - "eNKKszSkJWjb9snAP6MrkM088ZUBd9J9n8v5TdPcXCmetGIsDWk3tW17EN1Z56ey83d+/AXd2sen\n", - "mqZ5oEY2ablZGtIy6c/9OIauPN4CPK1f9CPgf9AVyF+681yTzNKQVkDbtuuBN9MVyDEDi26mK4+P\n", - "N01zZ41s0u6wNKQV1rbtC+jO+zgZOLCf/RjwBboC+WzTNP9QJ520OJaGNCJt264DXku39nEisFe/\n", - "6C7gz+h2nn+zUjypiKUhVdC27bOBX6MrkBcNLPoa3drHhU3T3FMjmzQfS0OqqN95fiTdobtvBTb0\n", - "i34C/C+6AvmyF07UuLA0pDHRtu1TgTfQFchrgB2/n7cDHwM+1jTNrXXSSR1LQxpDbdv+FN2O81OA\n", - "TQOLPgGc3DTNozVySZaGNMbatl0DTNGVx5vpLpz4iqZprqqZS3uupXx2rlupMJJ21u/LuBy4vG3b\n", - "e4AzgOMBS0MTY83CQyStgEv7++OrppAWydKQ6pgGHgGOatt2wwJjpbFhaUgVNE1zP/BVuvfgqxYY\n", - "Lo0NS0Oqx01UmjiWhlSPpaGJY2lI9fwNcB9wSNu2m+pGkcpYGlIl/VfJXtFPurahiWBpSHW5iUoT\n", - "xdKQ6tpRGq9u23Zt1SRSAUtDqusW4DZgH+CIylmkBVkaUkX9d4y7iUoTw9KQ6rM0NDEsDam+LwMJ\n", - "HNO27d61w0jzsTSkypqmuZvuq2GfBLyichxpXpaGNB7cRKWJYGlI48HS0ESwNKTx8H+AB4EXtW17\n", - "QO0w0lwsDWkMNE3zE+DKfvI1NbNI87E0pPHhJiqNPUtDGh+Pl0bbtlE1iTQHS0MaH98Cvg8cCBxe\n", - "OYs0lKUhjYn+kiKX9ZNuotJYsjSk8eJ+DY01S0MaLzvWNF7Ztu2TqiaRhrA0pDHSNM2dwE3A04Cf\n", - "qxxHmsXSkMbPzf39T1VNIQ2xrsaLRsQ+wCfp3hQzwFsy894h42aA/wc8CjycmUeNMKZUy0x/v6li\n", - "BmmoWmsa7wYuzcyfobss9LvnGJfAVGYeYWFoDzLT32+qmEEaqlZpnAhc0D++AHjDPGM9yUl7mpn+\n", - "flPFDNJQtUpj/8zc3j/eDuw/x7gELouIayLinaOJJlU3099vqphBGmrF9mlExKXAsKt1vm9wIjMz\n", - "InKOpzkmM/8+Ip4NXBoRN2bmVXO83lkDk9OZOb2E2NI4mOnvN1XMoFUoIqaAqd16jsy5Pq9XTkTc\n", - "SLev4vsRcSBwRWb+7AL/pgEeyMz/MmRZZqabsbQq9Nedup/usNtnNU0z6yARaTks5bOz1uapi4GT\n", - "+8cnA5/ZdUBE7B0R6/vHTwNeC1w/soRSJf3lRGb6yU31kkiz1SqN9wPHR8RNwHH9NBHxnIi4pB9z\n", - "AHBVRFwLXA18LjO/VCWtNHoz/f2mihmkWaqcp5GZP2TIF81k5p3AP+0ffxd4yYijSeNipr/fVDGD\n", - "NItnhEvjaaa/31QxgzSLpSGNp5n+flPFDNIsloY0nmb6+00VM0izWBrSeJrp7zdVzCDNYmlI4+lu\n", - "4EfAM9u23VA7jLSDpSGNIc/V0LiqcsitpCIzdF/EdEnbtluBrcBlTdPcXzWV9mhVLiOy3LyMiFaj\n", - "tm1fB/x34MCB2Q8DV9EVyFbgxn6tRFq0pXx2WhrSGOuvQ/ViYEt/exk7b1ae4YkCuaJpmgdHnVGT\n", - "y9KQVrm2bfehuw7bFuAEYN+BxT8BrqArkM83TXPL6BNqklga0h6kbds1wC/wxFrIL7Dzl5bdzBNr\n", - "IVc2TfPjkYfUWLM0pD1Y27b7Af+ErkA2A4OH6j5I99XKW4FPNU1z9+gTatxYGpIAaNt2HfCLPLEW\n", - "Mnjxz4eAjwNnN01zY4V4GhOWhqSh2rY9iG7t4810ayM7XAL8MXC5R2HteSwNSQtq2/Yw4N8Abwee\n", - "0s/+Jl15XNg0zU9qZdNoWRqSirVt+2zgNOB0YP9+9nbgXOC/NU1zV61sGg1LQ9KitW37ZOAk4LeB\n", - "n+9n/5huv8d5wG3AfU3TPFInoVaKpSFpyfoTCY8Dfodu5/muHgDuAe7tb4OPfwh8rmmar40mrZaD\n", - "pSFpWbRt+7N0+z2OB55Fd/huyXvsL84999xH7rrrrjXArh8uM5n5jmUNqt1iaUhaEf2JhOvpymMD\n", - "TxTJjtvz6XasP+P888/ntttuG/Y0X8nMqZEEVhFLQ1I1bduuB07+8Ic//Id33HHHU4cMsTTGjKUh\n", - "qbqImAZeOWSRpTFmlvLZ6fdpSKvUCyO2bIQz18NT7ocfb4NzvpW5tXYuTTZLQ1qFXhix5WXwJx+C\n", - "Q3bMeyc8/4URWBzaHZaGtApthDMHCwPgQ3DIFjiD7qKFK2lmkfM1QSwNaRVa/8TlQXbydBi2g3pZ\n", - "eVjt6rZm4SGSJs393RndszzQXeFWWjJLQ1qFtsE574SdvrnvX8Lf3Q4fqJVJq4OH3Eqr1AsjtjwX\n", - "zng6PPUBeOh2+IA7wTXI8zQkScWW8tnp5ilJUjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQV\n", - "szQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxaqURkS8OSK+HRGPRsRL\n", - "5xm3OSJujIibI+Jdo8woSZqt1prG9cAbgSvnGhARa4Fzgc3A4cBJEXHYaOI9nmFqlK+3HCYt86Tl\n", - "BTOPwqTlhcnMvBRVSiMzb8zMmxYYdhRwS2bOZObDwEXA61c+3U6mRvx6y2GqdoBFmqodYAmmagdY\n", - "gqnaARZpqnaAJZiqHWAUxnmfxkHAtoHpO/p5kqRK1q3UE0fEpcABQxa9NzM/W/AUucyRJEm7KTLr\n", - "fTZHxBXAv83Mrw9ZdjRwVmZu7qffAzyWmX8wZKwFI0lLkJmxmPErtqaxCHMFvgY4NCI2AXcCvwKc\n", - "NGzgYv/TkqSlqXXI7RsjYhtwNHBJRHy+n/+ciLgEIDMfAU4Hvgh8B/hkZt5QI68kqVN185QkabKM\n", - "89FTIxcR+0TEpRFxU0R8KSI2zDN2bUR8IyJKduqvmJLMEbExIq7oT6j8VkScWSHngidqRsQ5/fLr\n", - "IuKIUWcckmfezBHxa33Wb0bEX0bEz9fIOZCn6GTYiPjHEfFIRLxplPnmyFLyezHVv9e+FRHTI444\n", - "LM9Cvxf7RsQXIuLaPvM7KsTckeWjEbE9Iq6fZ8zi3neZ6a2/AX8I/G7/+F3A++cZ+zvAJ4CLxz0z\n", - "3VFsL+kfPx34W+CwEWZcC9wCbAL2Aq7d9fWBLcDW/vEvAl+t/HMtyfwy4Jn94801M5fkHRh3OfA5\n", - "4J9PwM94A/Bt4OB+et8JyHwW8Ps78gJ3A+sq5f0l4Ajg+jmWL/p955rGzk4ELugfXwC8YdigiDiY\n", - "7of9YebekT8qC2bOzO9n5rX94weAG4DnjCxh2Ymaj/8/MvNqYENE7D/CjLtaMHNm/lVm3tdPXg0c\n", - "POKMg0pPhj0D+HPg/44y3BxKMr8V+HRm3gGQmXeNOOOuSjL/PfCM/vEzgLuz20c7cpl5FXDPPEMW\n", - "/b6zNHa2f2Zu7x9vB+b64f0x8O+Bx0aSan6lmQHoj0Y7gu5DblRKTtQcNqbmh/BiTy79dWDriiaa\n", - "34J5I+Igug+4D/azau/QLPkZHwrs029evSYi/sXI0g1XkvlDwM9FxJ3AdcBvjSjbUiz6fTcOh9yO\n", - "1DwnHb5vcCIzc9j5HxHxOuAHmfmNUV1rZnczDzzP0+n+yvytfo1jVEo/nHZda6v5oVb82hHxKuBU\n", - "4JiVi7OgkrxnA+/uf0+C+mvJJZn3Al4KvBrYG/iriPhqZt68osnmVpL5vcC1mTkVEc8HLo2IF2fm\n", - "/SucbakW9b7b40ojM4+fa1m/w+iAzPx+RBwI/GDIsJcDJ0bEFuApwDMi4uOZ+fYVirwcmYmIvYBP\n", - "A3+WmZ9Zoahz+R6wcWB6I91fNPONObifV0tJZvqd3x8CNmfmfJsBVlpJ3iOBi7q+YF/ghIh4ODMv\n", - "Hk3EWUoybwPuysyHgIci4krgxUCt0ijJ/HLg9wAy8+8i4lbgBXTnno2bRb/v3Dy1s4uBk/vHJwOz\n", - "Plwz872ZuTEznwf8KnD5ShZGgQUz939VfgT4TmaePcJsOzx+omZEPInuRM1dP6guBt4Oj18N4N6B\n", - "zW41LJg5Ip4L/E/gbZl5S4WMgxbMm5k/nZnP6393/xz4zYqFAWW/F/8bOLY/WnFvup213xlxzkEl\n", - "mW8EXgPQ7x94AfDdkaYst/j3XY09+uN6A/YBLgNuAr4EbOjnPwe4ZMj4V1L/6KkFMwPH0u1/uRb4\n", - "Rn/bPOKcJ9AdtXUL8J5+3mnAaQNjzu2XXwe8dAx+H+bNTHcgxN0DP9O/Hue8u4w9H3jTuP+M++l/\n", - "R3cE1fXAmeOemW4t7rP97/H1wFsrZr2Q7ooa/0C31nbq7r7vPLlPklTMzVOSpGKWhiSpmKUhSSpm\n", - "aUiSilkakqRiloYkqZilIS2z/lL0342IZ/XTz+qnn1s7m7S7LA1pmWXmNrqLAr6/n/V+4LzMvL1e\n", - "Kml5eHKftAIiYh3wNbozr3+d7vtMHq2bStp9e9wFC6VRyMxHIuJ3gc8Dx1sYWi3cPCWtnBPorvvz\n", - "otpBpOViaUgrICJeQnel05cBvx0Rw74PRZo4loa0zPpL0X+Q7suutgH/CfjPdVNJy8PSkJbfO4GZ\n", - "zPxyP/1fgcMi4pcqZpKWhUdPSZKKuaYhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaG\n", - "JKnY/wfSP/dwYGt2YAAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "#NN TEST\n", - "for m in testing_couples\n", + "#Creation of the dataset\n", + "random_motors = environment.random_motors(n=1000)\n", " \n", - "sTest_pred = model.forward_prediction(mTest)\n", - "distance[\"NN\"] = abs(sTest_pred-sTest)\n", + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])\n", "\n", - "%pylab inline\n", - "ax = axes()\n", - "environment.plot_arm(ax, mTest)\n", - "ax.plot(*sTest_pred, marker='o', color='red')" + "for m in random_motors:\n", + " s = environment.compute_sensori_effect(m)\n", + " model.update(m, s)" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 25, "metadata": { "collapsed": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-0.65232833 -0.78444065 -0.07154134 0.98469259 -0.20240519 0.59945435\n", - " -0.5925971 ]\n", - "[ 0.54220714 0.79929109]\n", - "['NN']\n" - ] - } - ], + "outputs": [], "source": [ - "sensorimotor_models.keys()\n", - "print mTest\n", - "print sTest\n", - "print distance.keys()" + "#Test of the model\n", + "test = environment.random_motors(n=50)\n", + "distance = []\n", + "timer = []\n", + "\n", + "for mTest in test :\n", + " start = time.time()\n", + " sTest_pred = model.forward_prediction(mTest)\n", + " end = time.time()\n", + " sTest_eff = environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", + " timer.append(end - start)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#DRAFT bac a sable" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": { - "collapsed": false + "collapsed": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0.56816432 -0.60892505]\n", - "Populating the interactive namespace from numpy and matplotlib\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAFbpJREFUeJzt3XuUpHV95/H3dxi8oOjIIiAXM0aIgWgUyRIQIi2Kzsxm\n", - "8bLRBGNEyIUkB8wmuxtve/bh+WNPTHY3QcNZw/GCmHjAGHfdUQYUhBZykQQVRGXCTKRxkDguCCwI\n", - "Gi7f/eN5hqmZqe7+dU93/apm3q9z6lQ9z/Obqs/06apPP9eKzESSpBIrageQJE0OS0OSVMzSkCQV\n", - "szQkScUsDUlSMUtDklSsamlExEciYmtE3DLHmPdHxKaIuDkijh1lPknSjmqvaVwMrJltYUSsA47M\n", - "zKOA3wA+MKpgkqRdVS2NzLweuHeOIacDl/RjbwBWRcTBo8gmSdpV7TWN+RwGbBmYvhM4vFIWSdrr\n", - "jXtpAMRO0173RJIqWVk7wDy+AxwxMH14P28HEWGRSNIiZObOf5jPadxLYz1wLnBZRJwA3JeZW4cN\n", - "XOh/vEREnJ+Z5y/18y6nScs8aXnBzKMwaXlhYjMv+A/uqqUREZcCpwAHRsQWoAH2BcjMizJzQ0Ss\n", - "i4jNwA+As+qllSRVLY3MPKNgzLmjyCJJmt8k7Aivabp2gEWYrh1ggaZrB1iE6doBFmG6doAFmq4d\n", - "YBGmawcYhdgTvoQpInI59mlI0p5sMZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilUtjYhYExEbI2JTRLxjyPKpiLg/Ir7a3/5zjZySpM7KWi8cEfsAFwKvAr4D/ENE\n", - "rM/MW3ca+sXMPH3kASVJu6i5pnE8sDkzZzLzEeAy4LVDxsVoY0mSZlOzNA4DtgxM39nPG5TAyyLi\n", - "5ojYEBHHjCydJGkX1TZP0RXCfL4CHJGZD0XEWuDTwE8MGxgR5w9MTmfm9G4nlKQ9SERMAVO79RyZ\n", - "JZ/dSy8iTgDOz8w1/fS7gMcz8w/n+De3A8dl5vd3mp+Z6WYsSVqAxXx21tw8dSNwVESsjognAb8I\n", - "rB8cEBEHR0T0j4+nK7nv7/pUkqRRqLZ5KjMfjYhzgc8B+wAfzsxbI+KcfvlFwC8AvxURjwIPAb9U\n", - "K68kqeLmqaXk5ilJWrhJ2zwlSZowloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", - "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", - "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", - "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", - "pGKWhiSpmKUhSSpWtTQiYk1EbIyITRHxjlnGvL9ffnNEHDvqjJKk7aqVRkTsA1wIrAGOAc6IiKN3\n", - "GrMOODIzjwJ+A/jAyINqWUTEuoi4MiKm+/t1tTNJmt/K2RZExBXAb2fm7cv02scDmzNzpn+9y4DX\n", - "ArcOjDkduAQgM2+IiFURcXBmbl2mTBqBviDeBxw5MPv5EUFmbqgUS1KBudY0PgJ8LiLeExH7LsNr\n", - "HwZsGZi+s58335jDlyGLRuvt7FgY9NPnVcgiaQFmXdPIzE/2axv/BbgxIv4cyO2L849387Vz/iEA\n", - "RMm/i4jzByanM3N6EZk0Gk8ZNvOggw46rm3bVwNfaJrmsRFnkvZ4ETEFTO3Oc8xaGr1HgAfp3uT7\n", - "A4/vzovt5DvAEQPTR9CtScw15vB+3i4y8/wlzKbl9cNhM/fff/9nA58DtrRt+1Hgo03TfGuUwaQ9\n", - "Wf/H9PS26YhoFvockTn8D/6IWAP8MfAZoM3MhxaVcrYXjlgJ/CPwSuAu4O+BMzLz1oEx64BzM3Nd\n", - "RJwAXJCZJwx5rszMnddINKaG7dNYsWLFHaeeeup1J5988snA8waGT9NtKv1U0zRL+jso7e0W89k5\n", - "V2lcD/xmZn5jKcLN8hprgQuAfYAPZ+YfRMQ5AJl5UT9m2xFWPwDOysyvDHkeS2PC9MVxHvBU4GHg\n", - "TzNzQ9u2K4CXA2cDv9AvB3gAuBS4GLihaZrSzZuSZrHUpRE528IxY2nsmdq2fSbwJroCGVzDvJVu\n", - "7ePPm6bxSDppkZa0NCaJpbHna9v2GOAs4K3AQf3sx4DL6QpkQ9M0j1SKJ00kS0N7vLZt9wXW0q19\n", - "/Dzdpk2A7wEfAy5umuableJJE8XS0F6lbdtDgLfQFcjg1QRuoFv7+ETTNPfXyCZNAktDe6W2bYPu\n", - "CgNnA2fQHR4O3Q72T9EVyBebplnKQ8aliWdpaK/Xtu1+wBvoCuQVA4tupzvy6pKmab5dI5s0biwN\n", - "aUDbtj8OvK2/bTtJNIGr6dY+Pt00zdATDaW9gaUhDdG27T7AqXRrH68Hntwvug/4ON0ayFc890N7\n", - "G0tDmkfbtgfQ7fc4CzhuYNHX6NY+Pt40zd01skmjZmlIC9C27YvpyuMtwL/qZz8CrKcrkM83TfNo\n", - "pXjSsrM0pEVo2/bJwL+lK5A1bP/KgLvovs/l4qZpNlWKJy0bS0PaTW3bHkZ31vnZ7PidH39Nt/bx\n", - "yaZpHqyRTVpqloa0RPpzP06iK483AU/rF/0A+Eu6Avkbd55rklka0jJo23Z/4I10BXLSwKJNdOXx\n", - "saZp7qqRTdodloa0zNq2fQHdeR9nAs/pZz8OXElXIJ9pmuZf6qSTFsbSkEakbduVwKvp1j5OB/bt\n", - "F90N/AXdzvOvVYonFbE0pAratn028Mt0BfKigUVfplv7uLRpmntrZJPmYmlIFfU7z4+jO3T3zcCq\n", - "ftGPgP9NVyBf8MKJGheWhjQm2rZ9KvA6ugJ5FbDt9/PbwEeBjzZNc3uddFLH0pDGUNu2P0a34/ws\n", - "YPXAoo8DZzZN81iNXJKlIY2xtm1XAFN05fFGugsnvrxpmutr5tLeazGfnSuXK4ykHfX7Mq4Brmnb\n", - "9l7gPOA0wNLQxFgx/xBJy+Cq/v60qimkBbI0pDqmgUeB49u2XTXPWGlsWBpSBU3TPAB8ie49+Ip5\n", - "hktjw9KQ6nETlSaOpSHVY2lo4lgaUj3/ANwPHNm27eq6UaQyloZUSf9Vstf2k65taCJYGlJdbqLS\n", - "RLE0pLq2lcYr27bdp2oSqYClIdW1GbgDOAA4tnIWaV6WhlRR/x3jbqLSxLA0pPosDU0MS0Oq7wtA\n", - "Aie1bbtf7TDSXCwNqbKmae6h+2rYJwEvrxxHmpOlIY0HN1FpIlga0niwNDQRLA1pPPwt8BDworZt\n", - "D6kdRpqNpSGNgaZpfgRc10++qmYWaS6WhjQ+3ESlsWdpSOPjidJo2zaqJpFmYWlI4+PrwHeB5wDH\n", - "VM4iDWVpSGOiv6TI1f2km6g0liwNaby4X0NjzdKQxsu2NY1T2rZ9UtUk0hCWhjRGmqa5C7gNeBrw\n", - "U5XjSLuwNKTxs6m//7GqKaQhVtZ40Yg4APgE3ZtiBnhTZt43ZNwM8P+Ax4BHMvP4EcaUapnp71dX\n", - "zCANVWtN453AVZn5E3SXhX7nLOMSmMrMYy0M7UVm+vvVFTNIQ9UqjdOBS/rHlwCvm2OsJzlpbzPT\n", - "36+umEEaqlZpHJyZW/vHW4GDZxmXwNURcWNE/PpooknVzfT3qytmkIZatn0aEXEVMOxqne8ZnMjM\n", - "jIic5WlOysx/johnA1dFxMbMvH6W1zt/YHI6M6cXEVsaBzP9/eqKGbQHiogpYGq3niNzts/r5RMR\n", - "G+n2VXw3Ip4DXJuZPznPv2mABzPzfwxZlpnpZiztEfrrTj1Ad9jts5qm2eUgEWkpLOazs9bmqfXA\n", - "mf3jM4FP7zwgIvaLiP37x08DXg3cMrKEUiX95URm+snV9ZJIu6pVGu8FTouI24BT+2ki4tCIuLwf\n", - "cwhwfUTcBNwAfDYzP18lrTR6M/396ooZpF1UOU8jM7/PkC+aycy7gH/TP/4W8JIRR5PGxUx/v7pi\n", - "BmkXnhEujaeZ/n51xQzSLiwNaTzN9PerK2aQdmFpSONppr9fXTGDtAtLQxpPM/396ooZpF1YGtJ4\n", - "ugf4AfDMtm1X1Q6zlF4YsW5txJVvipheG3HlCyPW1c6kcpaGNIb21HM1Xhix7kR43xXwmr+EU66A\n", - "15wI77M4JkeVM8KXmmeEa0/Utu1n6Q5BvwvY0N+ubprmgarBdsPaiCuvgNfsPH8dXLkhc22NTHuz\n", - "xXx2VjlPQ1KRPwNeChwK/Fp/e6Rt2+vZXiIb+7WSibA/PGXY/KfDU0edRYvjmoY0xvrrUL0YWNff\n", - "TmTHzcozbC+Qa5umeWjUGRfCNY3xspjPTktDmiBt2x5Adx22dcBa4MCBxT8CrqUrkCuaptk8+oRz\n", - "27ZP44Nw5LZ5vwb/9CV4+9czN9TMtjeyNKS9SNu2K4CfYftayM+w45eWbWL7Wsh1TdP8cOQhh3hh\n", - "xLrnwnlPh6c+CA9/G/7UwqjD0pD2Ym3bHkS36WcdsAYYPFT3IbqvVt4AfLJpmntGn1DjxtKQBEDb\n", - "tiuBn2X7WsjgxT8fBj4GXNA0zcYK8TQmLA1JQ7Vtexjd2scb2XFH9OXAnwDXTNJRWFoaloakebVt\n", - "ezTw74G3sv0Q2K/RlcelTdP8qFY2jZalIalY27bPBs4BzgUO7mdvBS4E/qxpmrtrZdNoWBqSFqxt\n", - "2ycDZwC/C/x0P/uHdPs9LgLuAO5vmubROgm1XCwNSYvWn0h4KvB7dDvPd/YgcC9wX38bfPx94LNN\n", - "03x5NGm1FCwNSUuibdufpNvvcRrwLLrDd0veY3994YUXPnr33XevAHb+cJnJzLctaVDtFktD0rLo\n", - "TyTcn648VrG9SLbdnk+3Y/0ZF198MXfcccewp/liZk6NJLCKWBqSqmnbdn/gzA996EN/dOeddw67\n", - "AKGlMWYsDUnVRcQ0cMqQRZbGmFnMZ6dfwiRJKmZpSJKK+SVMkpbazALna4K4T0OS9lLu05AkLStL\n", - "Q5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFL\n", - "Q5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScWqlEZEvDEivhERj0XES+cYtyYiNkbEpoh4\n", - "xygzSpJ2VWtN4xbg9cB1sw2IiH2AC4E1wDHAGRFx9GjiPZFhapSvtxQmLfOk5QUzj8Kk5YXJzLwY\n", - "VUojMzdm5m3zDDse2JyZM5n5CHAZ8NrlT7eDqRG/3lKYqh1ggaZqB1iEqdoBFmGqdoAFmqodYBGm\n", - "agcYhXHep3EYsGVg+s5+niSpkpXL9cQRcRVwyJBF787MzxQ8RS5xJEnSborMep/NEXEt8B8y8ytD\n", - "lp0AnJ+Za/rpdwGPZ+YfDhlrwUjSImRmLGT8sq1pLMBsgW8EjoqI1cBdwC8CZwwbuND/tCRpcWod\n", - "cvv6iNgCnABcHhFX9PMPjYjLATLzUeBc4HPAN4FPZOatNfJKkjpVN09JkibLOB89NXIRcUBEXBUR\n", - "t0XE5yNi1Rxj94mIr0ZEyU79ZVOSOSKOiIhr+xMqvx4Rb6+Qc94TNSPi/f3ymyPi2FFnHJJnzswR\n", - "8ct91q9FxN9ExE/XyDmQp+hk2Ij41xHxaES8YZT5ZslS8nsx1b/Xvh4R0yOOOCzPfL8XB0bElRFx\n", - "U5/5bRVibsvykYjYGhG3zDFmYe+7zPTW34A/An6/f/wO4L1zjP094OPA+nHPTHcU20v6x08H/hE4\n", - "eoQZ9wE2A6uBfYGbdn59YB2woX/8s8CXKv9cSzKfCDyzf7ymZuaSvAPjrgE+C/y7CfgZrwK+ARze\n", - "Tx84AZnPB/5gW17gHmBlpbw/BxwL3DLL8gW/71zT2NHpwCX940uA1w0bFBGH0/2wP8TsO/JHZd7M\n", - "mfndzLypf/wgcCtw6MgSlp2o+cT/IzNvAFZFxMEjzLizeTNn5t9l5v395A3A4SPOOKj0ZNjzgL8C\n", - "/u8ow82iJPObgU9l5p0AmXn3iDPurCTzPwPP6B8/A7gnu320I5eZ1wP3zjFkwe87S2NHB2fm1v7x\n", - "VmC2H96fAP8JeHwkqeZWmhmA/mi0Y+k+5Eal5ETNYWNqfggv9OTSXwU2LGuiuc2bNyIOo/uA+0A/\n", - "q/YOzZKf8VHAAf3m1Rsj4ldGlm64kswfBH4qIu4CbgZ+Z0TZFmPB77txOOR2pOY46fA9gxOZmcPO\n", - "/4iInwe+l5lfHdW1ZnY388DzPJ3ur8zf6dc4RqX0w2nntbaaH2rFrx0RrwDOBk5avjjzKsl7AfDO\n", - "/vckqL+WXJJ5X+ClwCuB/YC/i4gvZeamZU02u5LM7wZuysypiHg+cFVEvDgzH1jmbIu1oPfdXlca\n", - "mXnabMv6HUaHZOZ3I+I5wPeGDHsZcHpErAOeAjwjIj6WmW9dpshLkZmI2Bf4FPAXmfnpZYo6m+8A\n", - "RwxMH0H3F81cYw7v59VSkpl+5/cHgTWZOddmgOVWkvc44LKuLzgQWBsRj2Tm+tFE3EVJ5i3A3Zn5\n", - "MPBwRFwHvBioVRolmV8G/FeAzPyniLgdeAHduWfjZsHvOzdP7Wg9cGb/+Exglw/XzHx3Zh6Rmc8D\n", - "fgm4ZjkLo8C8mfu/Kj8MfDMzLxhhtm2eOFEzIp5Ed6Lmzh9U64G3whNXA7hvYLNbDfNmjojnAv8L\n", - "eEtmbq6QcdC8eTPzxzPzef3v7l8Bv1WxMKDs9+L/ACf3RyvuR7ez9psjzjmoJPNG4FUA/f6BFwDf\n", - "GmnKcgt/39XYoz+uN+AA4GrgNuDzwKp+/qHA5UPGn0L9o6fmzQycTLf/5Sbgq/1tzYhzrqU7amsz\n", - "8K5+3jnAOQNjLuyX3wy8dAx+H+bMTHcgxD0DP9O/H+e8O429GHjDuP+M++n/SHcE1S3A28c9M91a\n", - "3Gf63+NbgDdXzHop3RU1/oVure3s3X3feXKfJKmYm6ckScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ1pi/aXovxURz+qnn9VPP7d2Nml3WRrSEsvMLXQXBXxvP+u9wEWZ+e16qaSl4cl90jKIiJXA\n", - "l+nOvP5Vuu8zeaxuKmn37XUXLJRGITMfjYjfB64ATrMwtKdw85S0fNbSXffnRbWDSEvF0pCWQUS8\n", - "hO5KpycCvxsRw74PRZo4loa0xPpL0X+A7suutgD/DfjvdVNJS8PSkJberwMzmfmFfvp/AkdHxM9V\n", - "zCQtCY+ekiQVc01DklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxSwNSVKx/w8QfuxjT/fu\n", - "yQAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "#KNN TEST\n", - "model = SensorimotorModel.from_configuration(environment.conf, 'WNN', 'default')\n", + "from explauto import Environment\n", + "environment = Environment.from_configuration('simple_arm', 'low_dimensional')\n", + "\n", + "from explauto.sensorimotor_model import sensorimotor_models\n", + "print 'Available sensorimotor models: {}'.format(sensorimotor_models.keys())\n", + "\n", + "from scipy import spatial\n", + "import numpy as np\n", + "import time\n", + "\n", + "#Environment definition\n", + "from explauto.environment.environment import Environment\n", + "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", + "\n", + "from explauto.sensorimotor_model import sensorimotor_models\n", + "from explauto import SensorimotorModel\n", + "\n", + "#Creation of the dataset\n", + "random_motors = environment.random_motors(n=10000)\n", + " \n", + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])\n", "\n", "for m in random_motors:\n", " s = environment.compute_sensori_effect(m)\n", - " # compute the sensori effect s of the motor command m through the environment\n", " model.update(m, s)\n", " \n", - "sTest_pred = model.forward_prediction(mTest)\n", - "print sTest_pred\n", - "distance[\"WNN\"] = abs(sTest_pred-sTest)\n", - "\n", - "%pylab inline\n", - "ax = axes()\n", - "environment.plot_arm(ax, mTest)\n", - "ax.plot(*sTest_pred, marker='o', color='red')\n", - "\n" + " \n", + "#Test of the model\n", + "test = environment.random_motors(n=50)\n", + "distance = []\n", + "timer = []\n", + "\n", + "for mTest in test :\n", + " start = time.time()\n", + " sTest_pred = model.forward_prediction(mTest)\n", + " end = time.time()\n", + " sTest_eff = environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", + " timer.append(end - start)\n", + "# Distance between the predictive and effectiv value\n", + "comparison = {}\n", + "comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)]\n", + "#print comparison['NN']\n", + "\n", + "#Creation of the dataset\n", + "random_motors = environment.random_motors(n=10000)\n", + " \n", + "sm_cls, sm_configs = sensorimotor_models['WNN']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])\n", + "\n", + "for m in random_motors:\n", + " s = environment.compute_sensori_effect(m)\n", + " model.update(m, s)\n", + "#Test of the model\n", + "test = environment.random_motors(n=50)\n", + "distance = []\n", + "timer = []\n", + "\n", + "for mTest in test :\n", + " start = time.time()\n", + " sTest_pred = model.forward_prediction(mTest)\n", + " end = time.time()\n", + " sTest_eff = environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", + " timer.append(end - start)\n", + "\n", + "# Distance between the predictive and effectiv value\n", + "comparison['WNN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)]\n", + "#print comparison['NN']\n", + "#Creation of the dataset\n", + "random_motors = environment.random_motors(n=10000)\n", + " \n", + "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])\n", + "\n", + "for m in random_motors:\n", + " s = environment.compute_sensori_effect(m)\n", + " model.update(m, s)\n", + "#Test of the model\n", + "test = environment.random_motors(n=50)\n", + "distance = []\n", + "timer = []\n", + "\n", + "for mTest in test :\n", + " start = time.time()\n", + " sTest_pred = model.forward_prediction(mTest)\n", + " end = time.time()\n", + " sTest_eff = environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", + " timer.append(end - start)\n", + " \n", + "# Distance between the predictive and effectiv value\n", + "comparison['LWLR'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)]\n", + "#print comparison['NN']\n", + "\n", + "for i in range(0, 6) :\n", + " for c in comparison.keys():\n", + " print c, i, comparison[c][i],\n", + " print '\\n'\n", + " \n", + "#print comparison['NN']\n", + "#print comparison['WNN']\n", + "#print comparison['LWLR']" ] } ], From daeeffcdd8e2d3c660cdb0daa24e9f2eba87ec60 Mon Sep 17 00:00:00 2001 From: Roxane Date: Sat, 6 Feb 2016 18:24:27 +0100 Subject: [PATCH 04/13] Forward model explanations are done, TODO : decision tree and inverse models to complete with code --- explauto/sensorimotor_model/non_parametric.py | 8 +- ...g_sensorimotor_models_non_parametric.ipynb | 186 +++++++++++------- 2 files changed, 124 insertions(+), 70 deletions(-) diff --git a/explauto/sensorimotor_model/non_parametric.py b/explauto/sensorimotor_model/non_parametric.py index 5f7278c..827a5e9 100644 --- a/explauto/sensorimotor_model/non_parametric.py +++ b/explauto/sensorimotor_model/non_parametric.py @@ -14,14 +14,14 @@ class NonParametric(SensorimotorModel): Original code available at https://github.com/humm/models Adapted by Sebastien Forestier at https://github.com/sebastien-forestier/models """ - def __init__(self, conf, sigma_explo_ratio=0.1, fwd='LWLR', inv='L-BFGS-B', **learner_kwargs): + def __init__(self, conf, sigma_explo_ratio=0.1, fwd='LWLR', inv='L-BFGS-B', mode = 'explore', **learner_kwargs): SensorimotorModel.__init__(self, conf) for attr in ['m_ndims', 's_ndims', 'm_dims', 's_dims', 'bounds', 'm_mins', 'm_maxs']: setattr(self, attr, getattr(conf, attr)) self.sigma_expl = (conf.m_maxs - conf.m_mins) * float(sigma_explo_ratio) - self.mode = 'explore' + self.mode = mode mfeats = tuple(range(self.m_ndims)) sfeats = tuple(range(-self.s_ndims, 0)) mbounds = tuple((self.bounds[0, d], self.bounds[1, d]) for d in range(self.m_ndims)) @@ -79,8 +79,8 @@ def size(self): sensorimotor_models = { - 'nearest_neighbor': (NonParametric, {'default': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio':0.1}, - 'exact': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio':0.}}), + 'nearest_neighbor': (NonParametric, {'default': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio':0.1, 'mode':'explore'}, + 'exact': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio':0., 'mode':'exploit'}}), 'WNN': (NonParametric, {'default': {'fwd': 'WNN', 'inv': 'WNN', 'k':20, 'sigma':0.1}}), 'LWLR-BFGS': (NonParametric, {'default': {'fwd': 'LWLR', 'k':10, 'inv': 'L-BFGS-B', 'maxfun':50}}), 'LWLR-CMAES': (NonParametric, {'default': {'fwd': 'LWLR', 'k':10, 'inv': 'CMAES', 'cmaes_sigma':0.05, 'maxfevals':20}}), diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb index c4e7469..dd6773d 100644 --- a/notebook/comparing_sensorimotor_models_non_parametric.ipynb +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -48,37 +48,49 @@ ] }, { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], "source": [ - "### Decision tree\n", + "from scipy import spatial\n", + "import numpy as np\n", + "import time\n", "\n", - "In order to use the most appropriate model, there are several questions that have to be asked before using the following decision tree. The following paragraphs focus on these questions.\n", + "#Environment definition\n", + "from explauto.environment.environment import Environment\n", + "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", "\n", - "*Add the decision tree*" + "from explauto import SensorimotorModel" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Non parametric or gaussian mixture models ? \n", + "### Decision tree\n", + "\n", + "In order to use the most appropriate model, there are several questions that have to be asked before using the following decision tree. The following paragraphs focus on these questions.\n", "\n", - "Each of non parametric model is currently based on the nearest neigbhor look up. They are non paramtric models because they don't rely on assomptions that the data are drown from a given probability while gassian mixture models (GMM) assumes that the data points are generated from a mixture of a finite number of Gaussian distributions with unknown parameters. Thus, the last model can be used only with gaussian distributed data. Readers in this case should refer to the follwing tutorial : *coming soom* ." + "*Add the decision tree*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Presentation of the different non parametric models\n", + "### Non parametric or gaussian mixture models ? \n", "\n", - "Available non parametric sensorimotor models in Explauto can be accessed using: " + "Each of non parametric model is currently based on the nearest neigbhor look up. They are non paramtric models because they don't rely on assomptions that the data are drown from a given probability while gassian mixture models (GMM) assumes that the data points are generated from a mixture of a finite number of Gaussian distributions with unknown parameters. Readers in this case should refer to the follwing tutorial : *coming soon* .\n", + "\n", + "Available sensorimotor models in Explauto can be accessed using: " ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "collapsed": false }, @@ -100,11 +112,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "These 4 models are a combination of a forward and an inverse model:\n", + "### Presentation of the different non parametric models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These 4 non parametric models, which are a combination of a forward and an inverse model, are:\n", "* the **nearest neighbor** model searches the nearest point of a given input ($m$ or $s$) in the dataset and returns its corresponding value (respectively $s$ or $m$)\n", "* the **WNN or weighted nearest neighbor** model searches the $k$ nearest points of a given input ($m$ or $s$) in the dataset and returns the average of the $k$ corresponding values (respectively $m$ or $s$)\n", - "* the **LWLR or The Locally Weigthed Linear Regression (LWLR)** offers two inverses model for the same forward one. The forward computes a linear regression of the $k$ nearest neighbors of $m$ and find the requested $s$ with the given $m$ based on that regression. Both inverse models are optimisation algorithm that minimize the error $e(m) = ||LWLR(m) - s_g||^2$ where $s_g$ is the goal, $LWLR$ is the forward model LWLR, and $m$ is the motor command to be infered. Both **LWLR-BFGS** and **LWLR-CMAES** use LWLR forward model to predict $s$ but LWLR-BFGF uses Broyden–Fletcher–Goldfarb–Shanno algorithm and LWLR-CMAES covariance matrix adaptation which are going to be explained later.\n", - "Let's see which of these 8 *(2 * 4)* possibilities is the best" + "* Both **LWLR-BFGS and LWLR-CMAES** use **the Locally Weigthed Linear Regression (LWLR)** for their forward models. It computes a linear regression of the $k$ nearest neighbors of $m$ and find the requested $s$ with the given $m$ based on that regression. Both inverse models are optimisation algorithm that minimize the error $e(m) = ||LWLR(m) - s_g||^2$ where $s_g$ is the goal, $LWLR$ is the forward model LWLR, and $m$ is the motor command to be infered. BFGS and CMAES are inverse models which are going to be explained later." ] }, { @@ -119,63 +137,89 @@ "\n", "In the \"exploit\" mode, no exploration noise is added. This mode is used for instance when evaluating the inverse model for comparison purposes.\n", "\n", - "*How to change it ? *" + "Each model does not have several modes. In order to know what are their different modes and caracteristics :" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'default': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio': 0.1, 'mode': 'explore'}, 'exact': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio': 0.0, 'mode': 'exploit'}}\n" + ] + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor'] # or 'WNN', 'LWLR-BFGS' or 'LWLR-CAMES'\n", + "print sm_configs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Forward or inverse model ?\n", - "\n", - "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. \n", - "\n", - "In any case, it is possible to load the different library this way : " + "Then, it is possible to change its caracteristics like sigma exploration ratio for nearest neighbor models or the number $k$ of nearest neighbor in WNN models this way : " ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ - "from scipy import spatial\n", - "import numpy as np\n", - "import time\n", - "\n", - "#Environment definition\n", - "from explauto.environment.environment import Environment\n", - "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", - "\n", - "from explauto.sensorimotor_model import sensorimotor_models\n", - "from explauto import SensorimotorModel" + "sm_configs['my_mode']['my_caracteristic'] = my_new_value" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Forward models comparison\n", - "For each model : \n", - "* Output descrptions\n", - "* Processing description\n", - "* When should it (or not) be used\n", - "* Time processing\n", - "* Distance between sg et s" + "Whether changes are made or not :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "model = sm_cls(environment.conf, **sm_configs['my_mode']) # 'default' or 'exact'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Calculation comparison & computation\n", + "### Forward or inverse model ?\n", "\n", - "##### Nearest Neighbor forward model\n", + "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward models using guide" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Nearest Neighbor forward model\n", "\n", - "To perform a forward prediction, the Nearest Neighbor model just looks in the dataset of tuples $(m, s)$ for the nearest neighbor of the given $m$ motor command, and returns its corresponding $s$.\n", - "The algorithm comes from scipy library : [scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html) (with x = $s$, k=1, eps = 0, p = 2, radius = +inf). It returns distance and indexes of found nearest neighbors.\n", + "To perform a forward prediction, the Nearest Neighbor model looks in the dataset of tuples $(m, s)$ for the nearest neighbor of the given $m$ motor command, and returns its corresponding $s$.\n", + "The algorithm comes from scipy library : [scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html) (with x = $s$, k=1, eps = 0, p = 2, radius = +inf). It returns distance of found nearest neighbors $s_p$.\n", "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. \n", "\n", "Let's see how to use it : " @@ -183,18 +227,18 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [], "source": [ "#Creation of the dataset\n", - "random_motors = environment.random_motors(n=1000)\n", - " \n", "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", "model = sm_cls(environment.conf, **sm_configs['default'])\n", "\n", + "random_motors = environment.random_motors(n=1000)\n", + " \n", "for m in random_motors:\n", " s = environment.compute_sensori_effect(m)\n", " model.update(m, s)" @@ -240,22 +284,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "##### Weighted Nearest Neighbor forward model\n", - "\n", - "To perform a forward prediction of $m$, the Weighted Nearest Neighbor model looks at the $k$ (parameter) nearest neighbors of $m$ in the dataset, and returns the average of the $k$ corresponding $s$. This average is weighted by the distance to $m$ with a gaussian of standard deviation $\\sigma$ (parameter). It is the same algorithm than for NN model with k = n the number of interesting neigbhors. ([scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html)) It returns *How to choose the number of k? ? Can we change it? how does it compute ?*\n", + "#### Weighted Nearest Neighbor forward model\n", "\n", - "In order to compute WNN, the process is exactly the same than for NN research but these lines :" + "To perform a forward prediction of $m$, the Weighted Nearest Neighbor model looks for the $k$ (parameter) nearest neighbors of $m$ in the dataset, and returns the average of the $k$ corresponding $s$. This average is weighted by the distance to $m$ with a gaussian of standard deviation $\\sigma$ (parameter). It finds the $k$ nearest neighbors (with the same algorithm than for NN model :[scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html), with k = n the number of interesting neigbhors ) before weights them. It returns the n-dimensional weighted neighbor $s_p$. " ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { - "collapsed": false + "collapsed": true }, "outputs": [], "source": [ - "sm_cls, sm_configs = sensorimotor_models['WNN']" + "sm_cls, sm_configs = sensorimotor_models['WNN']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])" ] }, { @@ -274,9 +317,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "##### Locally Weighted Linear Regression forward model\n", + "####Locally Weighted Linear Regression forward model\n", "\n", - "The LWLR computes a linear regression of the $k$ nearest neighbors of $m$ (thus a local regression), and find the requested $s$ with the given $m$ based on that regression. *Ewplain which method is used to compute linear regression*" + "The LWLR computes a linear regression of the $k$ nearest neighbors of $m$ and finds the requested $s_p$ given $m$. As before, it is possible to change the number $k$ of nearest neighbors. " ] }, { @@ -287,7 +330,7 @@ }, "outputs": [], "source": [ - "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS']" + "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS'] # or LWLR-CMAES" ] }, { @@ -306,49 +349,60 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Distance between $s$ and $s_p$ comparison\n", + "#### Forward models for Non-Stationnary environments\n", "\n", - "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to his neighbors even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model." + "'NSNN' and 'NSLWLR' are modified versions of 'NN' and 'LWLR' where points are not only weighted by distance but also by the number of points that appeared after that one (gaussian with parameter sigma_t=100), to put less weight on old points and allow the learning of Non-Stationnary environments. *How to use it ?*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Time processing comparison\n", + "### Forward models comparisons\n", + "#### Distance between $s$ and $s_p$ comparison\n", "\n", - "NN model is far away better than his neighbor in speed processing in any case : around 4 times better than LWLR model and twine better than WNN with an equal standard deviation. " + "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to his neighbors even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Forward models for Non-Stationnary environments\n", + "#### Time processing comparison\n", "\n", - "'NSNN' and 'NSLWLR' are modified versions of 'NN' and 'LWLR' where points are not only weighted by distance but also by the number of points that appeared after that one (gaussian with parameter sigma_t=100), to put less weight on old points and allow the learning of Non-Stationnary environments. *How to use it ?*" + "NN model is far away better than his neighbor in speed processing in any case : around 4 times better than LWLR model and twice better than WNN with an equal standard deviation. These results were forseeable knowing that LWLR model uses WNN once which himself uses NN search." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "###Inverse models comparison\n" + "###Inverse models using guide" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Calculation comparison & computation\n", - "\n", - "##### Nearest Neighbor inverse model\n", + "####Nearest Neighbor inverse model\n", "\n", "\n", - "To perform the inverse inference, the Nearest Neighbor inverse model just look in the dataset of tuples $(m, s)$, the nearest neighbor of the given $s$ motor command, and return its corresponding $m$.\n", + "To perform the inverse inference, the Nearest Neighbor inverse model looks in the dataset of tuples $(m, s)$, the nearest neighbor of the given $s$ motor command, and return its corresponding $m$.\n", "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. \n", "\n", - "Let's see how to use it : *pas de random s?*" + "Let us see how to use it : *pas de random s?*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### WNN Inverse Model\n", + "\n", + "Typical robotic forward models are very redundant: e.g. a robotic arm can put its hand to position $s$ with an infinity of possible $m$ motor positions.\n", + "Thus, trying to infer a motor command $m$ to reach a given goal $s$ doing an average of the nearest neighbors of $s$ in the dataset would make no sense as those nearest neighbors might have very different corresponding motor commands.\n", + "\n", + "To perform the inverse inference of a given $s$, the Weighted Nearest Neighbor model looks at the nearest neighbor of $s$ in the dataset and gets its corresponding $m$. It finds now the $k$ nearest neighbors of $m$ in the dataset, and returns their average weighted by the distance of their sensory part to $s$, with a gaussian of standard deviation $\\sigma$ (parameter)." ] }, { From fe10b939c9bc4b135404930d55bfe843a210b9b0 Mon Sep 17 00:00:00 2001 From: Roxane Date: Sun, 7 Feb 2016 16:40:18 +0100 Subject: [PATCH 05/13] Think about deleting decision tree and need to add inverse model test and comparison --- ...g_sensorimotor_models_non_parametric.ipynb | 288 ++++++++++-------- 1 file changed, 164 insertions(+), 124 deletions(-) diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb index dd6773d..5d966fe 100644 --- a/notebook/comparing_sensorimotor_models_non_parametric.ipynb +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -202,27 +202,9 @@ "source": [ "### Forward or inverse model ?\n", "\n", - "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Forward models using guide" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Nearest Neighbor forward model\n", + "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. \n", "\n", - "To perform a forward prediction, the Nearest Neighbor model looks in the dataset of tuples $(m, s)$ for the nearest neighbor of the given $m$ motor command, and returns its corresponding $s$.\n", - "The algorithm comes from scipy library : [scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html) (with x = $s$, k=1, eps = 0, p = 2, radius = +inf). It returns distance of found nearest neighbors $s_p$.\n", - "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. \n", - "\n", - "Let's see how to use it : " + "For each of these models it is necessary to load the mode with the appropriate model chosen as explained earlier and then create a dataset of n $(m,s)$ couples which is going to be tested later:" ] }, { @@ -234,9 +216,6 @@ "outputs": [], "source": [ "#Creation of the dataset\n", - "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", - "model = sm_cls(environment.conf, **sm_configs['default'])\n", - "\n", "random_motors = environment.random_motors(n=1000)\n", " \n", "for m in random_motors:\n", @@ -245,71 +224,68 @@ ] }, { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": false - }, - "outputs": [], + "cell_type": "markdown", + "metadata": {}, "source": [ - "#Test of the model\n", - "test = environment.random_motors(n=50)\n", - "distance = []\n", - "timer = []\n", + "### Forward models using guide\n", "\n", - "for mTest in test :\n", - " start = time.time()\n", - " sTest_pred = model.forward_prediction(mTest)\n", - " end = time.time()\n", - " sTest_eff = environment.compute_sensori_effect(mTest)\n", - " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", - " timer.append(end - start)" + "The predicted sensorimotor effect $s_p$ of a command $m$ depending on a given model can be obtained this way :" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": { - "collapsed": false + "collapsed": true }, "outputs": [], "source": [ - "# Distance between the predictive and effectiv value\n", - "comparison = {}\n", - "comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]" + "s_pred = model.forward_prediction(m)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Weighted Nearest Neighbor forward model\n", - "\n", - "To perform a forward prediction of $m$, the Weighted Nearest Neighbor model looks for the $k$ (parameter) nearest neighbors of $m$ in the dataset, and returns the average of the $k$ corresponding $s$. This average is weighted by the distance to $m$ with a gaussian of standard deviation $\\sigma$ (parameter). It finds the $k$ nearest neighbors (with the same algorithm than for NN model :[scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html), with k = n the number of interesting neigbhors ) before weights them. It returns the n-dimensional weighted neighbor $s_p$. " + "In order to test foward models, we are going to generate randomly n $m$ and use one of these models to find out $s_p$. The distance between $s_g$ and the time processing are weighted and saved in $comparison$ dictionary." ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "sm_cls, sm_configs = sensorimotor_models['WNN']\n", - "model = sm_cls(environment.conf, **sm_configs['default'])" - ] - }, - { - "cell_type": "code", - "execution_count": 34, + "execution_count": 1, "metadata": { "collapsed": false }, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'environment' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m#Test of the model\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mtest\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom_motors\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m50\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0mdistance\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mtimer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'environment' is not defined" + ] + } + ], "source": [ - "comparison['WNN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + "#Test of the model\n", + "test = environment.random_motors(n=50)\n", + "distance = []\n", + "timer = []\n", + "\n", + "for mTest in test :\n", + " start = time.time()\n", + " sTest_pred = model.forward_prediction(mTest)\n", + " end = time.time()\n", + " sTest_goal = environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_pred,sTest_goal])[0])\n", + " timer.append(end - start)\n", + " \n", + "# Distance between the predictive and effectiv value\n", + "comparison = {} #to remove after the first use\n", + "comparison['my_model'] = [np.mean(distance), np.std(distance) ,max(distance),\n", " np.mean(timer), np.std(timer), max(timer)]" ] }, @@ -317,32 +293,31 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "####Locally Weighted Linear Regression forward model\n", + "#### Nearest Neighbor forward model\n", "\n", - "The LWLR computes a linear regression of the $k$ nearest neighbors of $m$ and finds the requested $s_p$ given $m$. As before, it is possible to change the number $k$ of nearest neighbors. " + "To perform a forward prediction, the Nearest Neighbor model looks in the dataset of tuples $(m, s)$ for the nearest neighbor of the given $m$ motor command, and returns its corresponding $s$.\n", + "The algorithm comes from scipy library : [scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html) (with x = $s$, k=1, eps = 0, p = 2, radius = +inf). It returns distance of found nearest neighbors $s_p$.\n", + "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. \n", + "\n", + "Let's see how to use it : " ] }, { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "collapsed": false - }, - "outputs": [], + "cell_type": "markdown", + "metadata": {}, "source": [ - "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS'] # or LWLR-CMAES" + "#### Weighted Nearest Neighbor forward model\n", + "\n", + "To perform a forward prediction of $m$, the Weighted Nearest Neighbor model looks for the $k$ (parameter) nearest neighbors of $m$ in the dataset, and returns the average of the $k$ corresponding $s$. This average is weighted by the distance to $m$ with a gaussian of standard deviation $\\sigma$ (parameter). It finds the $k$ nearest neighbors (with the same algorithm than for NN model :[scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html), with k = n the number of interesting neigbhors ) before weights them. It returns the n-dimensional weighted neighbor $s_p$. " ] }, { - "cell_type": "code", - "execution_count": 32, - "metadata": { - "collapsed": false - }, - "outputs": [], + "cell_type": "markdown", + "metadata": {}, "source": [ - "comparison['LWLR'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]" + "####Locally Weighted Linear Regression forward model\n", + "\n", + "The LWLR computes a linear regression of the $k$ nearest neighbors of $m$ and finds the requested $s_p$ given $m$. As before, it is possible to change the number $k$ of nearest neighbors. " ] }, { @@ -359,7 +334,7 @@ "metadata": {}, "source": [ "### Forward models comparisons\n", - "#### Distance between $s$ and $s_p$ comparison\n", + "#### Distance between $s_p$ and $s$ comparison\n", "\n", "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to his neighbors even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model." ] @@ -377,7 +352,66 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "###Inverse models using guide" + "###Inverse models using guide\n", + "\n", + "The predicted motor command $m_p$ to reach a goal $s_g$ can be obtained this way :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "m_pred = model.inverse_prediction(s_g)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to test foward models, we are going to generate randomly n $s_g$ and use one of these models to find out $m$. The distance between $s_g$ and the effective $s$ and the time processing are weighted and saved in $comparison$ dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'environment' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m#Test of the model\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mtest\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom_motors\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m50\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0mdistance\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mtimer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'environment' is not defined" + ] + } + ], + "source": [ + "#Test of the model\n", + "test = environment.random_sensors(n=50)\n", + "distance = []\n", + "timer = []\n", + "\n", + "for sTest in test :\n", + " start = time.time()\n", + " mTest = model.inverse_prediction(sTest)\n", + " end = time.time()\n", + " sTest_goal = environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest,sTest_goal])[0])\n", + " timer.append(end - start)\n", + " \n", + "# Distance between the predictive and effectiv value\n", + "comparison = {} #to remove after the first use\n", + "comparison['my_model'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)]" ] }, { @@ -388,9 +422,7 @@ "\n", "\n", "To perform the inverse inference, the Nearest Neighbor inverse model looks in the dataset of tuples $(m, s)$, the nearest neighbor of the given $s$ motor command, and return its corresponding $m$.\n", - "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. \n", - "\n", - "Let us see how to use it : *pas de random s?*" + "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. " ] }, { @@ -401,65 +433,72 @@ "\n", "Typical robotic forward models are very redundant: e.g. a robotic arm can put its hand to position $s$ with an infinity of possible $m$ motor positions.\n", "Thus, trying to infer a motor command $m$ to reach a given goal $s$ doing an average of the nearest neighbors of $s$ in the dataset would make no sense as those nearest neighbors might have very different corresponding motor commands.\n", - "\n", - "To perform the inverse inference of a given $s$, the Weighted Nearest Neighbor model looks at the nearest neighbor of $s$ in the dataset and gets its corresponding $m$. It finds now the $k$ nearest neighbors of $m$ in the dataset, and returns their average weighted by the distance of their sensory part to $s$, with a gaussian of standard deviation $\\sigma$ (parameter)." + "But to perform the inverse inference of a given $s$, the Weighted Nearest Neighbor model looks at the nearest neighbor of $s$ in the dataset and gets its corresponding $m$. It finds now the $k$ nearest neighbors of $m$ in the dataset, and returns their average weighted by the distance of their sensory part to $s$, with a gaussian of standard deviation $\\sigma$ (parameter)." ] }, { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": false - }, - "outputs": [], + "cell_type": "markdown", + "metadata": {}, "source": [ - "#Creation of the dataset\n", - "random_motors = environment.random_motors(n=1000)\n", - " \n", - "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", - "model = sm_cls(environment.conf, **sm_configs['default'])\n", + "####Optimization Inverse Model (BFGS and CMAES)\n", + "Another possibility to perform inverse inference is to use an optimization algorithm to minimize the error $e(m) = ||f(m) - s_g||^2$ where $s_g$ is the goal, $f$ is the forward model, and $m$ is the motor command to be infered.\n", "\n", - "for m in random_motors:\n", - " s = environment.compute_sensori_effect(m)\n", - " model.update(m, s)" + "This is how our [scipy.optimize based](https://github.com/flowersteam/explauto/blob/master/explauto/sensorimotor_model/inverse/sciopt.py#L8) inverse models do. \n", + "\n", + "They take a 'maxfun' ([BFGS](https://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm)) or 'maxiter' ([COBYLA] (https://en.wikipedia.org/wiki/COBYLA)) parameter that limits the number of error function (and so forward model) evaluation.\n", + "\n", + "The Covariance Matrix Adaptation -Evolutuionary Strategy optimizes that error function by making fewer assumptions on the regularity of the forward model to perform the search. It is based on a random exploration (with a computed covariance) around a current point of interest, and adapts this point and recompute the covariance matrix at each iteration, with memory of the taken path.\n", + "The initial point is set as the motor part $m$ of the nearest neighbor $s$ of the goal $s_g$, and the initial covariance matrix is identity times an exploration $\\sigma$ (parameter). This inverse model also takes a 'maxfevals' parameter that limits the number of forward model evaluations.\n", + "The method should be applied, if BFGS fails due to a rugged search landscape (e.g. discontinuities, sharp bends or ridges, noise, local optima, outliers). If second order derivative based methods are successful, they are usually faster than the CMA-ES: on purely convex-quadratic functions, BFGS is typically faster by a factor of about ten (in terms of number of objective function evaluations needed to reach a target function value, assuming that gradients are not available). \n", + "\n", + "See [Hansen's website](https://www.lri.fr/~hansen/cmaesintro.html) and this [tutorial](https://www.lri.fr/~hansen/cmatutorial.pdf) on CMA-ES." ] }, { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": false - }, - "outputs": [], + "cell_type": "markdown", + "metadata": {}, "source": [ - "#Test of the model\n", - "test = environment.random_motors(n=50)\n", - "distance = []\n", - "timer = []\n", + "### Inverse models comparisons\n", "\n", - "for mTest in test :\n", - " start = time.time()\n", - " sTest_pred = model.forward_prediction(mTest)\n", - " end = time.time()\n", - " sTest_eff = environment.compute_sensori_effect(mTest)\n", - " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", - " timer.append(end - start)" + "#### Distance between $s_p$ and $s$ comparison\n", + "\n", + "#### Time processing comparison" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#DRAFT bac a sable" + "## Total implementation" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { - "collapsed": true + "collapsed": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available sensorimotor models: ['LWLR-BFGS', 'nearest_neighbor', 'WNN', 'LWLR-CMAES']\n", + "LWLR 0 0.0686541978662 WNN 0 0.0884176480287 NN 0 0.177208535905 \n", + "\n", + "LWLR 1 0.0541419200709 WNN 1 0.0402551322972 NN 1 0.122515755016 \n", + "\n", + "LWLR 2 0.296264678198 WNN 2 0.202203225994 NN 2 0.454557748391 \n", + "\n", + "LWLR 3 0.0111941003799 WNN 3 0.000906777381897 NN 3 0.000500750541687 \n", + "\n", + "LWLR 4 0.0698805950638 WNN 4 0.00157149520023 NN 4 0.00172045156063 \n", + "\n", + "LWLR 5 0.500254869461 WNN 5 0.011901140213 NN 5 0.0125389099121 \n", + "\n" + ] + } + ], "source": [ "from explauto import Environment\n", "environment = Environment.from_configuration('simple_arm', 'low_dimensional')\n", @@ -567,7 +606,8 @@ " \n", "#print comparison['NN']\n", "#print comparison['WNN']\n", - "#print comparison['LWLR']" + "#print comparison['LWLR']\n", + "\n" ] } ], From c9760f045856f1471d5b0e11c01ebccc0fa986bf Mon Sep 17 00:00:00 2001 From: Roxane Date: Tue, 9 Feb 2016 20:04:59 +0100 Subject: [PATCH 06/13] WIP inverse --- ...g_sensorimotor_models_non_parametric.ipynb | 939 ++++++++++++++++-- 1 file changed, 859 insertions(+), 80 deletions(-) diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb index 5d966fe..d2080b4 100644 --- a/notebook/comparing_sensorimotor_models_non_parametric.ipynb +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 23, "metadata": { "collapsed": true }, @@ -63,7 +63,8 @@ "from explauto.environment.environment import Environment\n", "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", "\n", - "from explauto import SensorimotorModel" + "from explauto import SensorimotorModel\n", + "from explauto.utils import rand_bounds" ] }, { @@ -129,20 +130,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Eploit or explore mode ?\n", - "\n", - "All the non-parametric sensorimotor models have two operating modes: \"explore\" and \"exploit\".\n", - "\n", - "In the \"explore\" mode, when the agent asks for the exact inverse prediction $m$ of a goal $s_g$, $m$ will be perturbated with some gaussian exploration noise in order to allow the agent to explore new motor commands. The sensorimotor models thus have a common parameter: sigma_explo_ratio=0.1 (default), which is the standard deviation of the gaussian noise, scaled depending of the motor domain size: if a motor value is bounded in [-2:2], then a sigma_explo_ratio of 0.1 will induce an exploration noise of (m_max - m_min) * sigma_explo_ratio = 0.4\n", - "\n", - "In the \"exploit\" mode, no exploration noise is added. This mode is used for instance when evaluating the inverse model for comparison purposes.\n", + "### Changing models caracteristics (k, sigma, ...)\n", "\n", - "Each model does not have several modes. In order to know what are their different modes and caracteristics :" + "Each model have its own caracteristics. In order to know what are they :" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": { "collapsed": false }, @@ -169,13 +164,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": { "collapsed": true }, "outputs": [], "source": [ - "sm_configs['my_mode']['my_caracteristic'] = my_new_value" + "sm_configs['default']['sigma_explo_ratio'] = 0.4 #or any other value" ] }, { @@ -187,13 +182,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": { - "collapsed": true + "collapsed": false + }, + "outputs": [], + "source": [ + "model = sm_cls(environment.conf, **sm_configs['default'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Eploit or explore mode ?\n", + "\n", + "All the non-parametric sensorimotor models have two operating modes: \"explore\" and \"exploit\".\n", + "\n", + "In the \"explore\" mode, when the agent asks for the exact inverse prediction $m$ of a goal $s_g$, $m$ will be perturbated with some gaussian exploration noise in order to allow the agent to explore new motor commands. The sensorimotor models thus have a common parameter: sigma_explo_ratio=0.1 (default), which is the standard deviation of the gaussian noise, scaled depending of the motor domain size: if a motor value is bounded in [-2:2], then a sigma_explo_ratio of 0.1 will induce an exploration noise of (m_max - m_min) * sigma_explo_ratio = 0.4\n", + "\n", + "In the \"exploit\" mode, no exploration noise is added. This mode is used for instance when evaluating the inverse model for comparison purposes.\n", + "\n", + "The default mode is explore, in order to switch to exploit mode:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false }, "outputs": [], "source": [ - "model = sm_cls(environment.conf, **sm_configs['my_mode']) # 'default' or 'exact'" + "model.mode = 'exploit'" ] }, { @@ -209,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 19, "metadata": { "collapsed": false }, @@ -234,7 +255,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { "collapsed": true }, @@ -252,23 +273,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 22, "metadata": { "collapsed": false }, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'environment' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m#Test of the model\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mtest\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom_motors\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m50\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0mdistance\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mtimer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mNameError\u001b[0m: name 'environment' is not defined" - ] - } - ], + "outputs": [], "source": [ "#Test of the model\n", "test = environment.random_motors(n=50)\n", @@ -284,9 +293,9 @@ " timer.append(end - start)\n", " \n", "# Distance between the predictive and effectiv value\n", - "comparison = {} #to remove after the first use\n", - "comparison['my_model'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]" + "fwd_comparison = {} #to remove after the first use\n", + "fwd_comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)] # or WNN, LWLR, ..." ] }, { @@ -326,7 +335,7 @@ "source": [ "#### Forward models for Non-Stationnary environments\n", "\n", - "'NSNN' and 'NSLWLR' are modified versions of 'NN' and 'LWLR' where points are not only weighted by distance but also by the number of points that appeared after that one (gaussian with parameter sigma_t=100), to put less weight on old points and allow the learning of Non-Stationnary environments. *How to use it ?*" + "'NSNN' and 'NSLWLR' are modified versions of 'NN' and 'LWLR' where points are not only weighted by distance but also by the number of points that appeared after that one (gaussian with parameter sigma_t=100), to put less weight on old points and allow the learning of Non-Stationnary environments." ] }, { @@ -336,7 +345,9 @@ "### Forward models comparisons\n", "#### Distance between $s_p$ and $s$ comparison\n", "\n", - "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to his neighbors even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model." + "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to his neighbors even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model. So WNN is steadier than LWLR.\n", + "\n", + "In order to visualize these differences, it is possible to run the total code below." ] }, { @@ -377,30 +388,32 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 54, "metadata": { "collapsed": false }, "outputs": [ { - "ename": "NameError", - "evalue": "name 'environment' is not defined", + "ename": "ExplautoBootstrapError", + "evalue": "", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m#Test of the model\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mtest\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom_motors\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m50\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0mdistance\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mtimer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mNameError\u001b[0m: name 'environment' is not defined" + "\u001b[1;31mExplautoBootstrapError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0msTest\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mtest_cases\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[0mstart\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mmTest\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minverse_prediction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msTest\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 9\u001b[0m \u001b[0mend\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 10\u001b[0m \u001b[0msTest_goal\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompute_sensori_effect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmTest\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/sensorimotor_model/sensorimotor_model.pyc\u001b[0m in \u001b[0;36minverse_prediction\u001b[1;34m(self, s_g)\u001b[0m\n\u001b[0;32m 47\u001b[0m \"\"\" Compute a motor command to reach the sensory goal s_g. It is a shortcut for self.infer(self.conf.s_dims, self.conf.m_dims, s_g)\n\u001b[0;32m 48\u001b[0m \"\"\"\n\u001b[1;32m---> 49\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minfer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0ms_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mm_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ms_g\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/sensorimotor_model/non_parametric.pyc\u001b[0m in \u001b[0;36minfer\u001b[1;34m(self, in_dims, out_dims, x)\u001b[0m\n\u001b[0;32m 32\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0minfer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0min_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 33\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mt\u001b[0m \u001b[1;33m<\u001b[0m \u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 34\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mExplautoBootstrapError\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 35\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 36\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0min_dims\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mm_dims\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mout_dims\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0ms_dims\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;31m# forward\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mExplautoBootstrapError\u001b[0m: " ] } ], "source": [ "#Test of the model\n", - "test = environment.random_sensors(n=50)\n", + "test_cases = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=50)\n", "distance = []\n", "timer = []\n", "\n", - "for sTest in test :\n", + "for sTest in test_cases :\n", " start = time.time()\n", " mTest = model.inverse_prediction(sTest)\n", " end = time.time()\n", @@ -409,8 +422,8 @@ " timer.append(end - start)\n", " \n", "# Distance between the predictive and effectiv value\n", - "comparison = {} #to remove after the first use\n", - "comparison['my_model'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + "inv_comparison = {} #to remove after the first use\n", + "inv_comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", " np.mean(timer), np.std(timer), max(timer)]" ] }, @@ -445,7 +458,7 @@ "\n", "This is how our [scipy.optimize based](https://github.com/flowersteam/explauto/blob/master/explauto/sensorimotor_model/inverse/sciopt.py#L8) inverse models do. \n", "\n", - "They take a 'maxfun' ([BFGS](https://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm)) or 'maxiter' ([COBYLA] (https://en.wikipedia.org/wiki/COBYLA)) parameter that limits the number of error function (and so forward model) evaluation.\n", + "They take a 'maxfun' ([BFGS](https://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm)) or 'maxiter' ([COBYLA](https://en.wikipedia.org/wiki/COBYLA)) parameter that limits the number of error function (and so forward model) evaluation.\n", "\n", "The Covariance Matrix Adaptation -Evolutuionary Strategy optimizes that error function by making fewer assumptions on the regularity of the forward model to perform the search. It is based on a random exploration (with a computed covariance) around a current point of interest, and adapts this point and recompute the covariance matrix at each iteration, with memory of the taken path.\n", "The initial point is set as the motor part $m$ of the nearest neighbor $s$ of the goal $s_g$, and the initial covariance matrix is identity times an exploration $\\sigma$ (parameter). This inverse model also takes a 'maxfevals' parameter that limits the number of forward model evaluations.\n", @@ -474,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 50, "metadata": { "collapsed": false }, @@ -483,20 +496,635 @@ "name": "stdout", "output_type": "stream", "text": [ - "Available sensorimotor models: ['LWLR-BFGS', 'nearest_neighbor', 'WNN', 'LWLR-CMAES']\n", - "LWLR 0 0.0686541978662 WNN 0 0.0884176480287 NN 0 0.177208535905 \n", - "\n", - "LWLR 1 0.0541419200709 WNN 1 0.0402551322972 NN 1 0.122515755016 \n", - "\n", - "LWLR 2 0.296264678198 WNN 2 0.202203225994 NN 2 0.454557748391 \n", - "\n", - "LWLR 3 0.0111941003799 WNN 3 0.000906777381897 NN 3 0.000500750541687 \n", - "\n", - "LWLR 4 0.0698805950638 WNN 4 0.00157149520023 NN 4 0.00172045156063 \n", - "\n", - "LWLR 5 0.500254869461 WNN 5 0.011901140213 NN 5 0.0125389099121 \n", - "\n" + "Available sensorimotor models: ['LWLR-BFGS', 'nearest_neighbor', 'WNN', 'LWLR-CMAES']\n" ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEZCAYAAABrUHmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xm0XGWZ7/HvL2EGMXJRAiGAhkFktTQqk9BybFECKHjt\n", + "VhtpEbW7ab0MdyktOCBRG1vsQRmWtgLaeB0AxwbFKCIHEBHEDoQhIAlgMys0IMZACOe5f+z3JDuV\n", + "GnYNu3YNv89aZ53aVbt2PSc5p57a+33e51VEYGZmVsSMqgMwM7Ph4aRhZmaFOWmYmVlhThpmZlaY\n", + "k4aZmRXmpGFmZoU5aZiVSNKUpBdVHYdZrzhpmCWS7pH0R0lPpq/fS5pd4utNSlohadvcfQdKursm\n", + "poclbZK7728kXVFWXGbNOGmYrRHA6yPiOelr84h4qOTXXA6c0mKfGcAJJcdhVoiThlkLks6X9L50\n", + "e0665PTetD1P0qO5ff9B0gOS7pP0rhaHDuBM4Igml7AC+BfgREnP7f6nMeuOk4bZ2lTnvklgIt0+\n", + "ALgLeFVu+yoASfOB9wMHAjun763cD5wDfKzJPjekGE4scDyzUjlpmK0h4HuSHktf30n3XwXsL0nA\n", + "nwGfBvZLjx0AXJluvwX4UkTcFhF/BE4t8JoB/BPwBkkvabLPR4HjJG3Z9k9l1kNOGmZrBHB4RDwv\n", + "fb0JICKWkY09/ClZ0vg+8ICkncnOOKaTxtbAvbnj/XehF414BDgb+HiKod4+t6bXPbnRPmb94KRh\n", + "VsyVwJuB9SPigbR9NPA84Ma0z4PAdrnn5G+38s/Aq4GXN9nnVOBvgTltHNesp5w0zIq5EjiWNH5B\n", + "NsZwLHB1rFlf4CLgaEm7phLZIpenBBARTwD/CpzUaMd0xnMhrqSyCjlpmBVzFbAZa5LGNcDGuW0i\n", + "YiHwWeCnwK+By2l9KSn/+BnAqhbP+TiwSYHjmpVCVS7CJOlLwKHAbyPiTxrscyZwMPBH4OiIWNTH\n", + "EM3MLKfqM40vA/MbPSjpEGDHiNgJ+Dvg8/0KzMzM1lVp0oiIq4HHmuxyGHB+2vc6YJakrfoRm5mZ\n", + "ravqM41W5rB2CeN9wLYN9jUzs5INetKAdWfoegDQzKwi61UdQAv3A3Nz29um+9YiyYnEzKwDEVGv\n", + "dU5Dg540Liarhb9A0j7A4xHxcL0d2/3BB4mkBRGxoOo4OjHMsYPjr5rjr1YnH7grTRqSvkHWu2dL\n", + "SfeSTYZaHyAivhARl0o6RNJSsjYO76wuWjMzqzRpRMQRBfY5th+xmJlZa8MwED4OJqsOoAuTVQfQ\n", + "pcmqA+jSZNUBdGmy6gC6NFl1AP1W6YzwXpEUwzymYWZWhU7eO32mYWZmhTlpmJlZYU4aZmZWmJOG\n", + "mZkV5qRhZmaFOWmYmVlhThpmZlaYk4aZmRXmpGFmZoU5aZiZWWFOGmZmVpiThpmZFeakYWZmhTlp\n", + "mJlZYU4aZmZWmJOGmZkV5qRhZmaFVZo0JM2XdLukOyWdVOfxLSUtlHSjpFskHV1BmGZmllS23Kuk\n", + "mcAdwIHA/cAvgSMiYklunwXAhhHxQUlbpv23iohVNcfycq9mZm0atuVe9wKWRsQ9EfEMcAFweM0+\n", + "DwKbp9ubA4/WJgwzM+ufKpPGHODe3PZ96b68c4DdJD0A3ASc0KfYzMwakyaRppCmqg6l39ar8LWL\n", + "XBf7EHBjRExImgdcJmn3iHiydsd0KWvaZERM9iZMM7NEErCK/Adu6SYidq8spjZImgAmujlGlUnj\n", + "fmBubnsu2dlG3iuB0wAiYpmku4FdgBtqDxYRC8oJ08wMkFYC69fcOzUsCQMgfZienN6WdGq7x6jy\n", + "8tQNwE6SdpC0AfBW4OKafW4nGyhH0lZkCeOuvkZpZuNNegwpWDthBPARImZWFFVlKjvTiIhVko4F\n", + "fgTMBM6LiCWSjkmPfwH4JPBlSTeRJbgPRMT/VBWzmY0R6SjgP4Da6qLlRGzW/4AGQ2Ult73kklsz\n", + "6ylpFdmH2bxVRNRenhpqnbx3VjmmYWY2WKQVwEY19wYwk1H4hN0DbiNiZjZdQrtuwlhMxAwnjDV8\n", + "pmFm46teCW1mJREbVhDRwHPSMLPx1LiEduwqotrhy1NmNl5cQtsVn2mY2XhwCW1POGmY2egbkxLa\n", + "fnDSMLPR5RLanvOYhpmNHpfQlsZnGma2FkmHAMeTveE+BZwZEZdWG1VBLqEtnZOGma2WEsYZwI65\n", + "u+dJYhASR9OE5hLavnDvKTNbTdJC4KA6Dy2MiIMbPKcvZyYNEtrS/4YXzF2zwue0AE4h4rRexzFK\n", + "3HvKzLpVOwYwbeN6dzY5M9kT2JeaRJLWbziW7IzgGeDsiPhYwdiOz7/OjsAdsGOddzyX0JbIScPM\n", + "8p5qcP+K2jtSwjgf2LLmoR2BDwCb5O6bJ+ltwFtY+xLSh9OlryKJY3VCe4asfrYmYbiEtg9cPWVm\n", + "eWcCS2vuWwaclb8jd4ZRmzCmbVKzvSPrJgzS9rG1x5a0UNJk+n5IeuippcAU2addkV2DSot0z3DC\n", + "6A+faZjZaukSEsBxZJekVgBn1RmjWOtSUUGN3tRX39/octcD0ieehT3EmmQB8BlY/n54S4zC4OyQ\n", + "8EC4mbVN0iRwQI8O90hEPD8dd52B+On62ek/8AAegXhBtupnvYRmBXkg3Mz6pdHYRyvB2kMRzwBn\n", + "57ZXj1s8TXYKUvOONqWImc9nzdmG9ZfHNMysE/XGPopYBjwCPJG+n1YzCP7UI2TjFNMJI41buAvt\n", + "gKg0aUiaL+l2SXdKOqnBPhOSFkm6JZ0Sm1nF0iWhE4BfkZ0U1Pof4MGa+5YBJ0TE8yNiVvq+JmFI\n", + "Rz0Lr9uCtS9FLYflM+H1nnMxGCob05A0E7gDOBC4H/glcERELMntMwu4BjgoIu6TtGVEPFLnWB7T\n", + "MKtAk8mANwCn0npAffpAa3WhDWAVrNoAftL0edaVYRvT2AtYGhH3AEi6ADgcWJLb523AtyPiPoB6\n", + "CcPMKtVoMuDy9Ebf/M2+QRdawcz1XRI1kKq8PDUHuDe3fV+6L28nYAtJV0i6QdLb+xad2QhqMgei\n", + "U4UnA9YE4i60Q6rKM40ivxTrAy8DXkM2WehaSb+IiDtrd5S0ILc5GRGTvQjSbFSU1IzwTGBezTFX\n", + "Twas7Uu1I5x5J1yCu9BWQtIEMNHNMapMGvcDc3Pbc8nONvLuJavhXgGskHQVsDuwTtKIiAUlxWk2\n", + "KupNyNuRbNyho6TRbDJgbZK6G9h+3fEPd6Hto/RhenJ6O/UCa0uVl6duAHaStIOkDYC3AhfX7POf\n", + "wP6SZkraBNgbuK3PcZqNiraaERYVEZdGxMERMZG+Tyeg44EdP0lWQrs9a83mLlRCW8LlNOtSZWca\n", + "EbFK0rFkszpnAudFxBJJx6THvxARt6fqjMVkv3fnRISThllnOht/6NBeMOdaskQxnSwC+AGsen2B\n", + "PlGDvrbHuHIbEbMx0eBNeBlwfM/fhKVVATPz8y0eArbJNhuuzVETb9tre1h7hq3k1sz6qI1mhJ3L\n", + "ldDmu9Dm3mjW6Zi77iFWD57v02CXri6nWXecNMxGSKtV9ArNnejguGTdGl5FTauoX8CyV2aFK4WS\n", + "VIOzoVqlXE6zYpw0zEZEWWMATY8LP2RNI9q8lURsuC9tNxZs1XK95ZmKlatQ9ZSkTSTtUnYwZuOi\n", + "pKqgZiW1PT/u01m14xRrv49MEaEu5lw0qvB6AlhIGeMv1paWSUPSYcAisionJO0hqbY01swKyn1y\n", + "P4hsTYqDgDN6kDhKKamtPe7trO5COxPWdKH9V7hK8IYuX6tRhde1NeW8VpEiZxoLyOZHPAYQEYuA\n", + "F5UYk9moK+uMoKyS2qcgm0b8LLAz63ShZSboxGxMo9vkV2i5WatOkTGNZyLi8VR1MW2qpHjMxkFZ\n", + "ZwRNW3p0c9xn4KCZrJ0sVsGzG+Q60yalzTDvKHLruSJJ41ZJRwLrSdqJ7FPSz8sNy2yklXJGUMob\n", + "rrQicklueoLe4XDo9+ED1F/ytesZ5nSYdKx8RS5PHQfsRrbQyjeA3wP/t8ygzAZBiS0sSrsE06Sl\n", + "R3sadKEVLJ4RoUuy4/Z1hrkNhiJnGrtExIeAD5UdjNmgKLOFxUBfgskCa1hCW3NfWZfDbIC1bCOS\n", + "llidDXwTuDAibulDXG1xGxHrtbFsYSGtJFuOIK9pF9qUXOsmv5YTAq1ypbQRiYgJSVsDbwG+IGlz\n", + "4KKI+ESHcZoNg7IGqweP9Bgwq+beAE4puC63ar672eAIKzQjPCIeJCul+ylwEvBRwEnDRtnoX6+X\n", + "jgL+g5rWH8ByIjZr/fTGiYES1u6wwdAyaUh6CdlZxl8CjwIXAu8rOS6zqo329XppFeuWy66iQMvy\n", + "nGaJYXzO1MZMkTONLwEXAAdFxP0lx2M2EAZ6sLobuS60OQHM7GBd7maJYfTP1MZUkTGNRu2JzUba\n", + "SM0XaNCFFlhMxO4dHrVZYjiLUT5TG2MNk4akb0bEmyXdXOfhiIiXlhiX2VgprdKoQQnt07ByI7gC\n", + "2IisUqyT12t4CW9kz9SsccmtpG0i4gFJ00v75kVE/Kb06Apyya0NswYDykuBE7qczV23hDY1FezJ\n", + "6zUrubXB18l7Z5F5GqdHxEmt7quSk4YNs57PCWlRQjuWc1Csrk7eO4u0EXldnft60k5B0nxJt0u6\n", + "U1LDJCRpT0mrJL2pF69rNmB6U2kkHZVaf9QmjOVEzMjNuXBlk3Ws2ZjGe4D3ktVd58c1ngNc0+0L\n", + "S5oJnA0cCNwP/FLSxRGxpM5+p5MtwOKzCRtF3VcatVdC68om61iz6qmvky3l+CmyCX3Tb9hPRsSj\n", + "PXjtvYClEXEPgKQLgMOBJTX7HQd8C9izB69pVpouBrM7nxPSWQntaM9BsVI1TBoR8QTwhKQzgMci\n", + "4vcAkjaXtHdEXNfla88B7s1t30e22NNqkuaQJZI/J0sa7daRm/VFg8HsV0laApzSLHl0VGnURQmt\n", + "K5usG0Um930eeFlueznw78AeXb52kQTwWeDkiAhlv+UNL09JWpDbnIyIye7CM2tLvdnRG5P97ZzR\n", + "qudS4Tkh7XWhbWik5qBYYZImyBZh7FjR3lNTudvPpnGGbt0PzM1tzyU728h7OXBB+lS0JXCwpGci\n", + "Yp01yiNiQQ9iMutUo8Fl6FXPpQ660PaDu9kOj/RhenJ6W9Kp7R6jSNK4W9LxZGccAt4D3NXuC9Vx\n", + "A7CTpB2AB4C3Akfkd4iI1WuRS/oycEm9hGE2ABoNLk9bqzKprTfa7rvQlsbdbMdPkaTx92QDZx9J\n", + "25cDf9ftC0fEKknHAj8iq/o4LyKWSDomPf6Fbl/DbFofPg3XG1zOW12ZVPiNtssutH3ibrZjpuXk\n", + "vmHgyX3WTGkzruu/zsfIlkfOn1ksA47PLU7UenJdb7rQli4t0lZvnfArI2Kiv9FYu0qZ3CdpF0mX\n", + "S7o1bb9U0kdaPc9sgDT7NNwzaX3uPcmWEVgIXJm+H1+TnBpPrpNWIGUls7lDAzMGLWEknvMxZorM\n", + "CD+HbH3wlWn7ZmrGHswGXF9nQKfkcXBETKTvtWcz67zRng88m31ir411cZrNPaiXBM4kO2vL85yP\n", + "EVZkTGOTiLguVTCRyl+fKTcss54atE/Da41/TNfP1lwjaKuEtiqe8zF+iiSN30lafWov6S+BB8sL\n", + "yaznBmoG9PQb7Ur43nqwfk2yqLyEtl2e8zFeinS5nQd8EdgXeBy4Gzhyuv3HIPBAuLUyUC28B7iE\n", + "1sZLT1ujSzohIs6QtH9E/EzSZsCM6XYig8RJY3wN1cSy4SihtTHS66RxU0TsLmlRRHTbMqRUThrj\n", + "qV+ltD0xJCW0Nl56XXJ7m6Q7gV0k3Vzztbi7UM16oi+ltF2pKaENYAo4FA51wrBh1KzL7RGSZpPN\n", + "2D4Mr2Vhg2dwFxOq6UI7fT7/beDN2c2WTQzNBlGzRZguj4jXSPrRIK0HbpYzaKW0dbvQBtkkp5oM\n", + "51YbNpSaldxuLWk/4LC0QJLItTOPiP8qOzizFgaqlLZRF9oZcDX1W21Uf0Zk1qZmSeNU4BSyxZL+\n", + "tc7jry4lIrOCBmZiWasS2qzXVD1utWFDp8g8jY9GxMf7FE9HXD1llShYQtugymutJoZmVehpyW3u\n", + "oDOAI4EXRsTHJW0HzI6I6zsPtbecNIbHUM2raKbNEtqBmlxolpSVNP6drErwzyPixZK2AH4cEa/o\n", + "PNTectIYDkM1r6IRaQXrVm1lJbWD21TQrK5SWqMDe0fEe0nXXyPif1h3sM+siMGfV1GHpEO+L/1m\n", + "SooYvi60Zj1VpGHhyvya4JKeT3bmYdauwZ1X0cDh0iGr4Af5LrSphHblhkPQhdas14okjbOA7wIv\n", + "kPRJsgVmvAiTdaLteRWVjoFIK7+X60I7PZs7/dH81KcWNo5aJo2I+KqkXwGvSXcdHhFLyg3LRlRb\n", + "8yoKr6Xda7kS2unJSUFWDXLBmr0G9uzIrEyVrhEuaT7wWbIqlHMj4vSax48EPkD2t/sk8J6IWKfv\n", + "lQfCh0c7VUSF1tLubXDrlNAG8Ftgdr9iMOujTt47i1yeKkUaJzkbOBC4H/ilpItrzmLuAl4VEU+k\n", + "BPNFYJ/+R2u90uaCPf0bA2lQQjsDDqf+HAsvZ2pjqbKkAewFLJ1ezCm1KjkcWJ00IuLa3P7XAdv2\n", + "M0CrXPm9pVqU0AbT7aQ8x8IM2kgakjYiWyL86R699hzg3tz2fcDeTfZ/N27uNm7K6y1V04U2ZzER\n", + "u+fv8HKmZms063I7A3gjcATwSrI5HZL0LHAt8DXge9H5oEjh50l6NfAuYL8m+yzIbU5GxGSHcVkT\n", + "/axmKqW3VJ0utABPw8qN4Apgo9Qrajhnqps1IWkCmOjqGE1W7ruKrDvnxcCN02cYkjYE9iBbY2P/\n", + "iHhVRy8s7QMsiIj5afuDwFSdwfCXAt8B5kfE0gbH8kB4H/RqRndlZbQNutAK3sCwz1Q360Cvl3vd\n", + "sNWlqCL7NHnuesAdZKW8DwDXA0fkB8JTn6ufAn8dEb9ociwnjT7oRTVTJa1EWnSh7XuVltmA6Gkb\n", + "kdyZxb9J2q3ZPp2IiFXAsWQrA94GXBgRSyQdI+mYtNtHgecBn5e0SNLANEkcU72oZupfKxHpKKQp\n", + "1k0Yy1Prj9PSdqOfa46khZIm0/dDeh6j2ZApMhC+BPiipPWBLwHfiIgnevHiEfFD4Ic1930hd/tv\n", + "gL/pxWtZT/Simqk/ZbTtdaFt9HPNA/4kv+0lWm3ctWxYGBHnRMR+wFHADsDNkr6eBqdtvJxJdikp\n", + "r91qpnLLaKUVSFnJ7BoBzGjUtpz6P9cfgU1q7hv45opmZStUcpsm4r0Y2BX4HXAT8D5Jfx8Rby0x\n", + "PhsgPapmKqeMto0S2loNfq45rH2WMc3tQ2ysFVlP4zNk1SU/JWv1cX3usTsiYpdyQ2zNA+HDpacL\n", + "EjUooQVW0kUXWg+O2zgoaxGmdwIXRcTyOo/NiojH2wuz95w0xlSDEloiascyOji0l2i10VdK0qjz\n", + "ItsAj/ZwZnjXnDTGTIsS2t69jJdotdHWr6RxOdk16W9FxIltPbkkThpjok4XWoDlsHwz+BnDvu64\n", + "WZ/1pcttRLwmtRjZtd3nmnWsQQmt1nShzY8/uDTWrCQtS24lHVjn7rdHxK0lxGO2ttYltEO57rjZ\n", + "sGqZNIBTJX1e0qaSZku6hKzvlFl5pMk0m7t2MuDiNJt7+rrq0K07XkvSIZ55bsOiyOWpA4D3k83N\n", + "CODUiPh6qVHZ+Gq/hLb8NTdKVNmStmYdKnKm8TxgT7Jyw5XAdkozocx6KiuhnWLt38spItRkzkUv\n", + "ZqlXyZfXbKgUSRrXAj+KiIPIkscc4JpSo7LxIj2Wxi3ycy4C+EirORfp0/gJwELgyvS98FyKAbg0\n", + "NPSX12y8FLk89dqI+A1ARPwROE7SAeWGZWOhQQktWRfazYoeptOV9Qbk0tBQX16z8dPwTEPSPIDp\n", + "hJEXEVfm9zFrW1ZCez4pYQRwE4TgSsHP+vSJv9GlofP7eMYx7JfXbMw0O9P4pKRNyVbuuwF4kOwP\n", + "fGvgFWQVVE8Cf1V2kDZCpBXUXJJZCbE5LHs6e8OePovtxyf+RpeGtgTO6McZRylL2pqVqOmMcEk7\n", + "kiWF/YDt092/IZt9+42IuKv0CAvwjPAh0KQLrbIPJH1vDtikKWFfXt+saj2fEZ7W5P7HrqKy8Van\n", + "hDaAJ2DqefCGiLg0JZR6yh4MrtemvZ+vbzZ0iq6nMX2msXr/iPhKWUHZiKjpQhtk9bTpl2gG6RIQ\n", + "FQ0G5y4NnU92Saqvr282jIq0Efkq8M/A/mQlt9NfZvXVKaGdIrs2VfMpZXo+QmWDwWns4B1Vvb7Z\n", + "sClypvFy4CXRbjvcAiTNBz5L1lfo3Ig4vc4+ZwIHky2/eXRELOp1HNYjTUpoZ2bFFPVKtTeuejC4\n", + "6tc3GyZFksYtZBVTD/TyhdMSsmcDBwL3A7+UdHFELMntcwiwY0TsJGlv4PPAPr2Mw3qkQRfa1ety\n", + "Z4PO9ayAzuda9ErVr282LIokjecDt0m6HpheeCkiotumhXsBSyPiHgBJF5C1uV6S2+cwsuvNRMR1\n", + "kmZJ2ioiHu7yta1X6pTQkg1fzGTts9Ny1gY3s74qkjQWlPTac4B7c9v3AXsX2GdbwEmjak1KaInY\n", + "vXZ3XwIyGw0tk0ZETJb02kXHSGrflOo+T9KC3OZkiXGPt/a70K7mS0Bm1ZI0AUx0c4yWSUPSvmSX\n", + "FnYFNiS7bv2HiNi8mxcmG8eYm9ueS3Ym0WyfbdN964iIBV3GY63UlNAmU62aCprZYEgfpientyWd\n", + "2u4xinS5PRt4G3An2bXrdwOfa/eF6rgB2EnSDpI2AN5K1rIk72LgKABJ+wCPezyjAl10oTWz0VJo\n", + "cl9E3ClpZkQ8C3xZ0o3Ayd28cESsknQs8COys5fzImKJpGPS419I18EPkbQUWA68s5vXtDb1qAut\n", + "mY2Opr2nACRdBbwWOJesR9BDwDuizmBnVdx7qgStSmjNbOh18t5Z5PLUUWm/Y8km2G0L/EX74dlQ\n", + "kFakS1H5hBHADCcMM2t5pgEgaRNgbkTcUX5I7fOZRg+0WUJrZsOvlDMNSYcBi8jGHpC0h6TaAWsb\n", + "VpKQniVr8ZH/5VmZ1uZ2wjCz1YpcnlpANunuMYDU++lFJcZk/ZKV0E6x9u/BVEoWTedcmNl4KpI0\n", + "nomIx2vumyojGOsTl9CaWYeKlNzeKulIYD1JO5Gtq/zzcsOyUriE1sy6VKTkdlPgw8Dr0l0/Aj4R\n", + "EY0Wzuk7D4QX4BJaM6vRyXtnoeqpQeek0UTxLrRmNmbKqp7aU9J3JS2SdHP6Wtx5mNYX0iTSFOsm\n", + "jMVEzHDCMLNOFBnT+BpwItliTB4AH3RddKE1M2ulSNL4XUR4XsYwcBdaMytZkYHw15F1oP0JsDLd\n", + "HRHxnZJjK2zsxzSkx4BZNfcGcAoRp1UQkZkNgU7eO4ucabwD2CXtm788NTBJY2y5hNbM+qxI0ngF\n", + "8OLwwGkhkg4hm8uyEfAUcGYpS5q6hNbMKlAkafwceAlwa8mxDL2UMM4AdszdPU8SPUscLqE1swoV\n", + "GdO4HZgH3A08ne6OiHhpybEVNihjGpIWAgfVeWhhRBzc5cEncRdaM+uhssY05ncYzziqPQOYtnHH\n", + "R3QJrZkNkJZJIyLu6UMco6JRa5UVHR2tpoQ2gCmYWg8uA870tSgz67ciXW6tuDOBpTX3LQPOauso\n", + "NV1oU7KIjwDrZf9nBwFnpDEUM7O+qaz3lKQtgAuB7YF7gLfUtmCXNBf4CvACsvfOL0bEmXWONRBj\n", + "GrB6MPw4sktSK4CzCg+CNyih/QMsfw5sWucZ3Y+V2Fr6Vv1mNgCGqmGhpE8Dj0TEpyWdBDwvIk6u\n", + "2Wc2MDsibpS0GfAr4I0RsaRmv4FJGh1rUkKrbBD8gDrPujIiJsoObVw0qH5bCpzgxGGjqJSGhSU6\n", + "DDg/3T4feGPtDhHxUETcmG7/AVgCbNO3CPtBWpEuReUTRgAzcnMuejtWYo0cz9oJg7R9XAWxmA2k\n", + "KpPGVhHxcLr9MLBVs50l7QDsAVxXblh90l4X2t6MlVgrva9+MxsxRUpuOybpMmB2nYc+nN+IiFD2\n", + "abvRcTYDvkV2meAPDfZZkNucjIjJtgPuhw5KaCPi0uxpHY6VWFE+o7ORJmkCmOjqGBWOadwOTETE\n", + "Q5K2Bq6IiBfX2W994PvADyPisw2ONRxjGu5CO9AajGksA453grZRNGxjGheTNUMkff9e7Q7KPl6f\n", + "B9zWKGEMhZoS2iSAjzhhDI6UGE4AFgJXpu9OGGY5VZfcXgRsR67kVtI2wDkRcaik/YGrgMVkb7IA\n", + "H4yIhTXHGswzDXehNbMBNlQlt700kEnDXWjNbMCV1XvK2uEutGY2wtxGpFfaK6E1MxtKPtPolrvQ\n", + "mtkYcdLohktozWzM+PJUJ1xCa2Zjymca7XAJrZmNuZFKGqW2tXYJrZnZ6CSNBi0g5kmiq8ThEloz\n", + "s9VGaUyjt22tXUJrZraOkTnToFdtrV1Ca2bW0Cglje7bWruE1sysqVG6PNX5QkUuoTUzK2RkzjQ6\n", + "WqjIJbRmZm0Z3y63PSyhLbXU18ysJO5yW0SPS2hLK/U1MxtAozSm0Vx5JbS9LfU1Mxtgo3+mUX4J\n", + "bW9Kfc3MhsBoJ43+lNB2X+prZjYkKrk8JWkLSZdJ+rWkH0ua1WTfmZIWSbqkjRfoZwlt56W+ZmZD\n", + "pqoxjZOByyJiZ+DytN3ICcBtZG/6zUlHpXGL2iS0PI1bnNZhvA2lwe4TgIXAlen78R4EN7NRVEnJ\n", + "raTbgQMi4mFJs4HJiHhxnf22JZtHcRrwvoh4Q4PjRcCzuAutmVlhnZTcVnWmsVVEPJxuPwxs1WC/\n", + "zwD/AEwVOGY+YQQwwwnDzKy3ShsIl3QZMLvOQx/Ob0REKBt/qH3+64HfRsQiSRNtvPRiInZvK1gz\n", + "MyuktKQREa9t9JikhyXNjoiHJG0N/LbObq8EDkuT5zYCNpf0lYg4qt4xPwrPfgL+Mb3ARERMdv1D\n", + "mJmNkPQBfKKrY1Q0pvFp4NGIOF3SycCsiGg4GC7pAODEpmMa7bYRGQBuP2JmVRqmNiKfAi6S9G7g\n", + "HuAtAJK4Dbw+AAAK20lEQVS2Ac6JiEPrPGf4m2TluP2ImQ2j8W1YWDFJC4GD6jy0MCIO7nc8ZjZ+\n", + "hql6ytx+xMyGkJNGddx+xMyGjpNGddx+xMyGzmg3LBxgHa00aGZWMQ+Em5mNKQ+Em5lZqZw0zMys\n", + "MCcNMzMrzEnDzMwKc9IwM7PCnDTMzKwwJw0zMyvMScPMzApz0jAzs8KcNMzMrDAnDTMzK8xJw8zM\n", + "CnPSMDOzwpw0zMyssEqShqQtJF0m6deSfixpVoP9Zkn6lqQlkm6TtE+/YzUzszWqOtM4GbgsInYG\n", + "Lk/b9ZwBXBoRuwIvBZb0Kb6+kjRRdQydGubYwfFXzfEPn6qSxmHA+en2+cAba3eQ9FzgzyLiSwAR\n", + "sSoinuhfiH01UXUAXZioOoAuTVQdQJcmqg6gSxNVB9CliaoD6LeqksZWEfFwuv0wsFWdfV4I/E7S\n", + "lyX9l6RzJG3SvxDNzKxWaUkjjVncXOfrsPx+ka03W2/N2fWAlwGfi4iXActpfBnLzMz6oJI1wiXd\n", + "DkxExEOStgauiIgX1+wzG7g2Il6YtvcHTo6I19c53vAvdG5mVoF21whfr6xAWrgYeAdwevr+vdod\n", + "UkK5V9LOEfFr4EDg1noHa/eHNjOzzlR1prEFcBGwHXAP8JaIeFzSNsA5EXFo2m934FxgA2AZ8M4R\n", + "Hgw3Mxt4lSQNMzMbTkM5I7zo5MC070xJiyRd0s8YmykSv6S5kq6QdKukWyQdX0WsuXjmS7pd0p2S\n", + "Tmqwz5np8Zsk7dHvGJtpFb+kI1PciyVdI+mlVcTZSJF//7TfnpJWSXpTP+NrpeDvz0T6W71F0mSf\n", + "Q2yowO/OlpIWSroxxX50BWE2JOlLkh6WdHOTfYr/7UbE0H0BnwY+kG6fBHyqyb7vA74GXFx13O3E\n", + "D8wG/jTd3gy4A9i1onhnAkuBHYD1gRtrYwEOIZuICbA38Iuq/53bjH9f4Lnp9vxhiz+330+B7wN/\n", + "UXXcbf77zyIbs9w2bW9ZddxtxL4A+KfpuIFHgfWqjj0X358BewA3N3i8rb/doTzToMDkQABJ25L9\n", + "g5wLDNJgecv4I+KhiLgx3f4D2Wz4bfoW4dr2ApZGxD0R8QxwAXB4zT6rf6aIuA6YJane/JsqtIw/\n", + "Iq6NNeNl1wHb9jnGZor8+wMcB3wL+F0/gyugSPxvA74dEfcBRMQjfY6xkSKxPwhsnm5vDjwaEav6\n", + "GGNTEXE18FiTXdr62x3WpFFkciDAZ4B/AKb6ElVxReMHQNIOZJ8Uris3rIbmAPfmtu9L97XaZ1De\n", + "eIvEn/du4NJSI2pPy/glzSF7M/t8umuQBiuL/PvvBGyRLsneIOntfYuuuSKxnwPsJukB4CbghD7F\n", + "1itt/e1WVXLbkqTLyC7R1PpwfiMiot48DUmvB34bEYuq6A/Tbfy542xG9unxhHTGUYWib0C1Z3OD\n", + "8sZVOA5JrwbeBexXXjhtKxL/Z8nmMYUkMVhn1kXiX59sMu9rgE2AayX9IiLuLDWy1orE/iHgxoiY\n", + "kDQPuEzS7hHxZMmx9VLhv92BTRoR8dpGj6VBndmxZnLgb+vs9krgMEmHABsBm0v6SkQcVVLIa+lB\n", + "/EhaH/g28NWIWGcuSx/dD8zNbc8l+zTSbJ9t032DoEj8pMHvc4D5EdHsdL7fisT/cuCCLF+wJXCw\n", + "pGci4uL+hNhUkfjvBR6JiBXACklXAbsDVSeNIrG/EjgNICKWSbob2AW4oS8Rdq+tv91hvTw1PTkQ\n", + "Gk8O/FBEzI1sRvlfAT/tV8IooGX86dPiecBtEfHZPsZWzw3ATpJ2kLQB8FaynyHvYuAoAGUt7B/P\n", + "XYKrWsv4JW0HfAf464hYWkGMzbSMPyJeFBEvTL/v3wLeMyAJA4r9/vwnsH+qdtyEbED2tj7HWU+R\n", + "2G8nm3xMGgvYBbirr1F2p72/3apH9jusBtgC+Anwa+DHwKx0/zbAD+rsfwCDVT3VMn5gf7KxmBuB\n", + "RelrfoUxH0xWwbUU+GC67xjgmNw+Z6fHbwJeVvW/czvxkxVLPJr7t76+6pjb/ffP7ftl4E1Vx9zB\n", + "78+JZBVUNwPHVx1zG787WwKXpN/7m4G3VR1zTfzfAB4AVpKd0b2rm79dT+4zM7PChvXylJmZVcBJ\n", + "w8zMCnPSMDOzwpw0zMysMCcNMzMrzEnDzMwKc9IwSyRdmNpAdHOMDSVdJan0v63USvySdPsNLVqm\n", + "P1fSe3Lb20j6Ztkx2uhx0jADJO0IbBoRy7o5TkQ8DVxNg87LBWNp++8yIi6JiNOb7PI84L25/R+I\n", + "iDd3Ep+NNycNGzipZcPtkr4s6Q5JX5P0urQ40q8l7Zn22zQtMHOdpP+SdFju+VdJ+lX62jfdPyFp\n", + "UtI3JS2R9NXcy/4VqT2EpO3T6/wvSTMkXS3pwJoY3ynpM7ntv5X0b2nzYuCIJj/XVyXdluLYOD12\n", + "j6RPSfoV8Ob08/48xX+RpE3TfvNT7L8C/nfu2EdLOivd3krSd5UtCnRj+vk/BcxTtsjR6elnvCXt\n", + "v1H6t16c/h0ncsf8jqQfpn+PZknJxkXVU9z95a/aL7IFb54BdiPrvnkDcF567DDgu+n2J4Ej0+1Z\n", + "ZK0eNgE2BjZM9+8E/DLdngAeJ2vXIuDnwH7psR+Sa59A1h79IrLW+p+vE+OmZG0XZqbta4Dd0u0N\n", + "gfsb/FxTwL5p+zzg/en23cCJ6faWwJXAxmn7JOAUssab/w3MS/dfSGqPAxwNnJW7//h0ewbZGg/b\n", + "k1uEJ8Vyc7r9fuDcdHsX4DfpZzgaWAY8J23fA8yp+vfDX9V++UzDBtXdEXFrRARZP6KfpPtvIXvD\n", + "A3gdcLKkRcAVZG9sc4ENgHMlLSZ74981d9zrI7s0E2R9vbZP929PtpgOABFxHvBcsh49J9YGFxHL\n", + "yVbJe4OkFwPrR8St6bGngRmSNqrzc90bEdem218l6zE27cL0fR/gJcDP0892FLAd2Rv63bHmEtpX\n", + "qd8C/dWkdTUiYioift9gv2n7pWMREXeQJY2dydpjXx4RT6af6TbW/NvbmBrY1ug29p7O3Z4ia7Y2\n", + "fTv/e/umqFlzQdIC4MGIeLukmcBTDY77bM2xVr+xpk6r25K9cT4HWF4nxnPJ1kdZAnyp5jFRf02C\n", + "aLJP/jUui4i3rXVAafc6r9FIu+tpNNq/9t9rZpvHtRHjMw0bZj8Cjp/ekLRHurk58FC6fRTF3uh+\n", + "A2yd2z4d+H/AqWRrbEy/xuWStgGIiOvJEsvbyDqJTu+zIfBs+nRea7vUfpr0vKvr7HMdsN90JVca\n", + "u9mJrAX3DpJelPZbZ9wkuRx4T3ruTEmbA0+SJb96rgaOTPvvTHZWczv1E8kgLe5kFXDSsEFV+yk9\n", + "6tz+BLB+GsC9BfhYuv9zwDsk3Uh2SecPdZ5b62fAKwAkHUC2qNHpEfF1YKWkd6SqpnlkLdSnXQT8\n", + "LNasLw7Z0rzXUt8dwP+RdBvZ5a91lmeNiN+RjSd8Q9JNZGMvu6Qk9HfAD9JA+MO550Xu9gnAq9Pl\n", + "uRuAXSPiUeAaSTenAe38/p8ju5y2mGwN7HdEth52fp/V4TX4uWxMuDW6GZA+vZ8VEYc22Wc34J0R\n", + "cWLuvkuAf4uIK3L3fZJs8P27Nc/fAbgkIv6kx+Gb9Y3PNMyAiLgLeLLZ5L40MH8igKRZku4A/liT\n", + "MDYkG9xutDyvP6XZUPOZhpmZFeYzDTMzK8xJw8zMCnPSMDOzwpw0zMysMCcNMzMrzEnDzMwK+/9K\n", + "KsiXDl+gdgAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEZCAYAAABrUHmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XuYXFWZ7/HvLxfCTQhMlFuCYAREHmXQQVAU2hElRA0O\n", + "M17wgqijqIfLjDKKDkh0xBHPeUYEjx4GkGEGFbxPEAwi0oCISJQQLuESEOWuMqAQArm954+1Ktld\n", + "XVW9u+uyq7t/n+fpp2vvWrXrrX666q2917vWUkRgZmZWxpSqAzAzs/HDScPMzEpz0jAzs9KcNMzM\n", + "rDQnDTMzK81Jw8zMSnPSMOsASeslPa/qOMy6zUnDJh1J90p6StIT+efPkrbv0nMdIem2un2XN9n3\n", + "sUJ8j0javHD/30u6srC9XtIySSrs+6yk87rxOsxqnDRsMgrgDRHxrPyzVUQ83KXnuhp4gaS/AJA0\n", + "Ddgb2FTSrMK+/XPbminA8SMcewfgbYVtj9S1rnPSMMsknS/pI/n2Tvnb/Ifz9lxJjxba/pOkByXd\n", + "L+m9zY4ZEQ8A9wAH5V0vAW4BrgIOLOybAtxQexjwf4ATJG3dIuQvAJ+WNHW0r9VsrJw0bLJSg32D\n", + "wEC+fRDpw/7AwvbVAJLmAR8FDgZ2z79bubpwnAOBa4Br6/ZdFxHrCo9ZkuM5ocVxvw/8GTiqxWsy\n", + "6ygnDZuMBPxA0mP553t5/9XAK3M/watI3+QPyPcdRDo7AHgL8LWIuC0ingJOGeH5imcVr8rPc03d\n", + "vqvqHhPAp4Bja5exGlgPnAycLGn6CDGYdYSThk1GARwWEdvkn8MBIuJuYCXwl6QP8h8CD0ranfQB\n", + "X/tg3wG4r3C8343wfNcAL5Y0E9iPdFZxB7BD3ncAQ/szyPHcmmM4kSb9FRHxI+B+4Ohmbcw6yUnD\n", + "bKirgDcD0yPiwbx9FLANsDS3eQjYufCY4u1hIuIe4EHgA8Dv8tkJwHWkD/stgV80efgpwPuBnVo8\n", + "xT8DnwQ2b9HGrCOcNMyGugo4ho3f/Afz9jWxcR2BbwFHSdozl8WOdHkK0tnGRxh6RvGzvO+GiHim\n", + "0YPy2c9FtKikioirSJ3r78ZnG9ZlThpmQ11N+uZf+3C/FtissE1ELAZOB34K3Alcwcgf1lcBzyYl\n", + "ippr8r5hl6bqfIZ0FlF8jvrnOwnYdoTjmLVNVS7CJOlrwOuB30fEi5q0OQM4FHgKOCoibuxhiGZm\n", + "VlD1mcZ5wLxmd0qaDzw/InYjXQ/+aq8CMzOz4SpNGhFxDfBYiyYLgPNz2+uBmZK260VsZmY2XNVn\n", + "GiPZiaGljfcDsyuKxcxs0uv3pAHDR7m6OsTMrCLTqg5gBA8Acwrbs/O+ISQ5kZiZjUFEjGr6mX5P\n", + "GotINfIXStofeDwiHmnUcLQvvJ9IWhgRC6uOYyzGc+zg+Kvm+Ks1li/clSYNSd8kzekzS9J9pEFS\n", + "0wEi4qyIuFTSfEkrSNM7vKe6aM3MrNKkERFHlGhzTC9iMTOzkY2HjvDJYLDqANowWHUAbRqsOoA2\n", + "DVYdQJsGqw6gTYNVB9BrlY4I7xRJMZ77NMzMqjCWz06faZiZWWlOGmZmVpqThpmZleakYWZmpTlp\n", + "mJlZaU4aZmZWmpOGmZmV5qRhZmalOWmYmVlpThpmZlaak4aZmZXmpGFmZqU5aZiZWWlOGmZmVpqT\n", + "hpmZleakYWZmpTlpmJlZaZUmDUnzJN0u6S5JH29w/yxJiyUtlXSLpKMqCNPMzLLKlnuVNBW4AzgY\n", + "eAC4ATgiIpYX2iwEZkTEJyTNyu23i4i1dcfycq9mZqM03pZ7fRmwIiLujYg1wIXAYXVtHgK2yre3\n", + "Ah6tTxhmZtY7VSaNnYD7Ctv3531FZwN7SXoQuAk4vkexmZk1Jw0irUdaX3UovTatwucuc13sk8DS\n", + "iBiQNBe4XNLeEfFEfcN8KatmMCIGOxOmmVkmCVhL8Qu3dBMRe1cW0yhIGgAG2jlGlUnjAWBOYXsO\n", + "6Wyj6BXAqQARcbek3wB7AEvqDxYRC7sTppkZIK0GptftXT9eEgZA/jI9WNuWdMpoj1Hl5aklwG6S\n", + "dpG0CfBWYFFdm9tJHeVI2o6UMO7paZRmNrlJjyEFQxNGACcRMbWiqCpT2ZlGRKyVdAxwGTAVODci\n", + "lks6Ot9/FvA54DxJN5ES3Mci4n+qitnMJhHpSOA/gPrqopVEbNn7gPpDZSW3neSSWzPrKGkt6cts\n", + "0Voi6i9PjWtj+eyssk/DzKy/SKuATev2BjCVifANuwM8jYiZWa2EdnjCWEbEFCeMjXymYWaTV6MS\n", + "2mQ1ETMqiKjvOWmY2eTUvIR20lVEjYYvT5nZ5OIS2rb4TMPMJgeX0HaEk4aZTXyTpIS2F5w0zGzi\n", + "cgltx7lPw8wmHpfQdo3PNMxs4nAJbdc5aZjZxOAS2p7w5Skz6zuS5ktaLGkw/57forFLaHvIZxpm\n", + "1ldygvgS8PzC7rmSiIhLCw1dQlsBz3JrZn1F0mLgkAZ3LY6IQ3Mjl9B2wFg+O315ysx6qsSlp/qK\n", + "p5rNkFblS1HFhBHAFCeM3vDlKTPrmZKXnp6uf9wBwNVwUINDLhtPy61OBD7TMLNeOo6hCYO8fWxh\n", + "+wxgRW1jJXANwz6sVhMhJ4ze85mGmfVS80tPWURcKonb4Ye7g+ouuLuEtmI+0zCzUWvWL1Giv2LY\n", + "padsVeHgjwVcssfQhOES2j5R6ZmGpHnA6aROrXMi4rQGbQaAL5JqsP8YEQO9jNHMhmrRL7Ev8M4G\n", + "+4v9FWcAc+va3A2c6RLa8aGykltJU4E7gIOBB4AbgCMiYnmhzUzgWuCQiLhf0qyI+GODY7nk1qxH\n", + "WpTE/hGY1WD/E8AzwEPAg7ndIaQvgmuALwecjEtoe24sn51Vnmm8DFgREfcCSLoQOAxYXmjzduC7\n", + "EXE/QKOEYWY916xfotkH/LPyzyzgRaRLTQL4DnA4LKxr71lo+1iVfRo7AfcVtu/P+4p2A7aVdKWk\n", + "JZLe1bPozKyZZv0Sa0o+Xq8G1gGHk7JHITt4Fto+V+WZRpl/iunAS4DXAJsD10n6RUTcVd9Q0sLC\n", + "5mBEDHYiSDMbplm/xH8xvE9jmKeBTdjYcRHAEoh9I1yY02W5j3ignWNUmTQeAOYUtueQzjaK7iN1\n", + "fq8CVkm6GtgbGJY0ImJhl+I0s4JaSSxpbMVmpMqnM/P+G/L+11B3uWoQOJChyeLPwMy0eZlPLbov\n", + "f5kerG1LOmW0x6gysy8BdpO0i6RNgLcCi+ra/DfwSklTJW0O7Afc1uM4zSa9+lJagDwP1BdIeeBj\n", + "dftvrz3274H1bEwYkbd3YUPCSNVTNi5UdqYREWslHQNcRqqaODcilks6Ot9/VkTcnv8Rl5H+z86O\n", + "CCcNsw7LZbTHkTq5nwbOqJXJNimxPVDS/cCWwA6F/XPzWciDM+FFvyd9yNSSRQDnAu9PbZ8GbgU+\n", + "NWT2WutrnuXWbJJrkhRWAMfnS07NSmybWfwkvHZzmFq8FLUM+Mt0hWElhUta7b8CG6uxfHY6aZhN\n", + "ciNNRS5pkMaTBQ5zCXAoQ/stngG2gcVPO0n0nfE2TsPM+sNI80E1K7Hd4HXAj0jJovgJJFi2acTe\n", + "qxo/zMYhJw0zG2k+qEYlths8AjyboWcXSrPQzuhkkNYfSlVPSdpc0h7dDsbMKjFkKvJsQ0VTvqR0\n", + "PPBkscE3SNUpz2FjR/cqYApcJvibLsdsFRmxT0PSAuB/AzMiYhdJ+wCfjogFvQiwDPdpmLUnd4bX\n", + "xl3UJgd8kkIlVa3v402k6T+mMLQqag+GZJ4NHek9egk2Bt1a7nUhaXzEYwARcSPwvFFHZ2Z9KyIu\n", + "LYy72Bp4Kanz+xDgS5LmL4TlTwDfY+PMguuBc/J23alK/cJKNkGU6dNYExGPa+hSKOu7FI+ZVavh\n", + "ynpr4IfTCn3cAfwCeEXrY23W+m4bj8qcadwq6R3ANEm7SToT+HmX4zKzagyppFpJ+oZYTBjrIXaH\n", + "FSMkDCgurGQTRpmkcSywF6nc+puk6WL+oZtBmVnnlFhNr+hpgLNJs9BuxvBZaKdETFmROsYXA1eR\n", + "Buw9VHccTw0yQZXpCH9JRPy6R/GMiTvCzRobabR3ffvDpPnfg0tqndyQEsZqWD2jRQltXUe6R3uP\n", + "E10ZEZ5Hg24PfBu4KCJuGXOEXeKkYdZYidHeG+acegYOnF5Yl7s2sWDu+HQ11ATUleqpvCb3q0lL\n", + "NJ4l6WZJJ48tRDPrsaajvWtnIdfDIevhoFrCqCWLDzOkUsbVUAaUHNwXEQ9FxJeADwI3AZ/qalRm\n", + "1ilNR3v/LZy0Dp6/L0MvRd0P66YC/2/4Y1wNZSOX3Ep6IfAW4O+AR4GLgI90OS4za0PhstOOwFOk\n", + "lS9r7l4Dr51aNwvtWtKKeqRil20aHNbVUFZqnMbXgAuBQyLigS7HY2ZtatL5/RRw9yrYbQbMLSaL\n", + "YONgvewe0gC/+uVcXQ1lnhrdbKJp1Pn9QeD/svF6dO1dfwFw5NCHP0RabA9cDTXhdXRqdEnfjog3\n", + "S7q5wd0RES8edYRm1gtDOr/XsnGeqJrVsHrTDVejhnigkBycJGyYVpenjs+/38DQ/zcYMtbHzHqh\n", + "1ZKsdZ6G1DGxJcOmLF9PxNRNmy+stLLTcdvE0rR6KiIezDc/HBH3Fn9I1Xhm1iOFfopDqJtIsL7t\n", + "7+Dl69mYMGoltP8FZxNR674YaQ0Ns4bKlNy+rsG+VtMQlCZpnqTbJd0l6eMt2u0raa2kwzvxvGbj\n", + "UMOJBCmMnfiG9C/rpZgNWxXPLm6G1VPh9UdGfKDw2JZraJg106pP40OkM4q5df0azwKubfeJJU0F\n", + "vgwcDDwA3CBpUUQsb9DuNNI8N+7stglrhMtPLZdkXSutPWJ4CW1sAm+IiEvrryfn9THAnd02Sq36\n", + "NL5BWvb388DH2fiB/UREPNqB534ZsCJf7kLShcBhwPK6dseS1nzZtwPPadaXmpTJzpVUWzmv4eWk\n", + "r8CrkKL2Rq4roRXp/dMwEeTjOknYqLTq0/hT/kD/EvBYoT9jjaT9OvDcOwH3Fbbvz/s2kLQTKZF8\n", + "tRZWB57XrB+NdPlpyOWkuaSBFx/M7+FasjiOYWMuPIrbOqrM4L6vAi8pbK8kzTCwT5vPXSYBnA6c\n", + "GBGhdC7d9PKUpIWFzcGIGGwvPLOeann5qXY5aTocexfM25mhVVF3kZZbbcAd27aBpAFgoJ1jlEka\n", + "RMT6wu11uZ+hXQ8Acwrbc0hnG0UvBS7M115nAYdKWhMRixrEuLADMZlVpVk104vyYL0zAn4ATK+7\n", + "f/0UuIbG5bNP445tK8hfpgdr25JOGe0xylRP/UbScZKmS9pE0vGkaQbatQTYTdIukjYB3goMSQYR\n", + "8byI2DUidiX1a3yoUcIwmwAaVTMBbPv7NAvtJTE0YQRwUi6hbZZwbnXHtnVamaTxQeAA0pnB/cD+\n", + "wAdaPqKEiFgLHANcBtxGWqtjuaSjJR3d7vHNxpP84V5bDe8xgL8mrZ43i2HXZVcSMYWIU/N2s/JZ\n", + "z0ZtHee5p8z6SK6iumANbDOVof0Wa2Ht9Ij6y1O1x3wG2DU/5B7gUz7LsJF0ZREmSXtIukLSrXn7\n", + "xZJOGmuQZtaYpPmr4LvrYZtpDB3NPQXYBH7S6DGkCseXAtuSpjTfundR22RT5vLU2cAngdV5+2bg\n", + "iK5FZDbOSZovabGkwfx75BkUpMF1cMkM2LSWLIKUJXLVyVPALxo8csSR4madVKZ6avOIuD5XMJHL\n", + "X9d0Nyyz8anEIL1hDyBPRFuctnw1w2pwNwfeKemGuuO0LNU167QyZxp/kLThDSDp70hz7pvZcOW/\n", + "+Uur2Xj1iSB1fE+haSZodBxPPGg9VSZpHAOcBewh6UHgH4EPdTUqsz5V4tLTyN/8pceQgroS2h/D\n", + "v09rXHbb+DiJJx60nmo1YeHxEfElYIeIeI2kLYEpEfHn3oVn1j9KXnpq/s1fOhL4D4bPbLCSiC0P\n", + "SU8yn3Q2sR8l1un2xIPWa01LbiXdFBF7S7oxItqdMqSrXHJrvdBoGdVsSUTsm9s0Six3r4Fdpg2b\n", + "Foq1NCihbXUc4DgnBOuUji73Ctwm6S5gpwZLvnq5V5uMml162kvS/Ii4tP6b/yrYbwbMrXtXpolo\n", + "WwyS8hmE9auWg/skbU8asb2AulPq2pTm/cBnGtYLLc40ABZHxKGFxoPAgQy/FLWMiL27EqDZKHX0\n", + "TEPSFbkv47KI+G374Zn1txJrcJ9BSgSNylk3qx2EXEJbd/9qImZ0OmazXmt1eWoHSQcAC/ICSbUx\n", + "RwBExK+7HZxZr5Tp5M6XjJYzdKmAmlW5hHbYLLSFdbnNxr1WHeFvBt5HmqxwSf39EfHq7oZWni9P\n", + "WbtaXHoactmpUXI5HNZdBFPrvoEFcHJhUkGzvtPRy1MR8W3g25I+FRGfaTs6s/5WamR1sYN6d3ju\n", + "IOy5fWFt7mwlEVt2I0izqpWZRuSzkt4F7BoRn5G0M7B9RPyyy7GZ9VLpkdURcSnSIkZRQms2UZQZ\n", + "Ef4V4OXA2/P2k3mf2URSbmS1tCqP5i4mjACmOGHYZFDmTGO/iNhH0o0AEfE/kvzmsAllxHERLqE1\n", + "A8oljdXFNcElPZs0yZrZhJITxNDBcy6hNRuizOWpM4HvA8+R9DngWuBfuxqVWQeNaX2L9MAhs9Bm\n", + "64mQE4ZNViOeaUTEBZJ+Bbwm7zosIpZ3Nyyzzhj1+hbpQY8BM+v2uoTWjIrXCJc0Dzid1Kl4TkSc\n", + "Vnf/O4CPka4jPwF8KCKWNTiOx2lMcCVGazd7XKnxF7lxy1loxxC2WV/r9ISFXZX7Sb4MHAw8ANwg\n", + "aVHdWcw9wIER8aecYP4d2L/30VqVxnS2sFG5le2ktbiE1mxEZfo0uuVlwIqIuDci1gAXAocVG0TE\n", + "dRHxp7x5PTC7xzFaf2hnHezW4y9cQms2KqWThqRNJXWy828n4L7C9v15XzPvo76yxSaLdtbBbjj+\n", + "Yhk8B2l9g2MvI2JKq2nLzSazVrPcTgHeBBwBvIKUYCRpHXAd8HXgBzH2N1fpx0l6NfBe0jxYzdos\n", + "LGwORsTgGOOy/jPmdbDrx1/MhlX3wuumuoTWJiFJA8BAW8doMWHh1cA1wCJgaUQ8k/fPAPYhrbHx\n", + "yog4cExPLO0PLIyIeXn7E8D6Bp3hLwa+B8yLiIbrJ7sjfGLr2Cp2noXWbIixfHa2ShozaomixROO\n", + "2KbFY6cBd5BKeR8EfgkcUewIz/Nc/RR4Z0T8osWxnDQmOG1cO3szYAvSmcITlKmkcgmtWUMdTRqF\n", + "g/4bcG5E3NpOcE2OfSgbS27PjYh/lXQ0QEScJekc4G+A3+WHrImIlzU4jpPGJNHkrGMFcPywxOES\n", + "WrOWupU03g8cRTqt/xrwzUJFU19w0pg8So+7qCuhDWAtrN0kDU51QYUZY/vsHLF6KiLOjogDgCOB\n", + "XYCbJX0jd06b9VrrSqq6Etpg4zwgm6TCjy+VnkbEzIYpVXKbB+K9ANgT+ANwE/ARSRd1MTazRhpW\n", + "Ul0Ku9aX0AbpH7Wul7vs+A4za2DEEeGSvgi8kdQhfWph8aXTJN3RzeDMGjgDmEuhTyNPQbtzXbvV\n", + "U1Jp+EENjlFmfIeZNVBmGpFlwEkRsbLBfft1OB6zlorjLlbDwdNgWt0F2Y0ltKn/o5ERx3eYWWNl\n", + "+jTOKyYMSTvWRoZHxOPdDM6skYCvB8ybPjRhBHBS3ZiLcqvxmVlpo57lVtIVpMsD34mIE7oS1Si5\n", + "emqSGEMJbd34jqGr8ZlNcl0puW3yRFOAPbsxdmMsnDQmAc9Ca9ZxXSm5lXRwg93v6peEYROcZ6E1\n", + "6ytlSm5PkfRVSVtI2l7SxaR5p8y6Rxr0LLRm/adM9dRBwEdJJe8BnBIR3+hqVDZ5pdKoXEU7hGeh\n", + "NesDZc40tgH2JVWdrAZ2Vq55NGtG0nxJiyUN5t8jj8JOs9DWBnATwDpAcJXgSo/kNqtemaRxHXBZ\n", + "RBxCSh47Add2NSob1wqTCh5COlM9hAbTd9QSy83Sn0OKKExbvh7iTfBwPhVuegwz660yExY+NyJ+\n", + "W7fvoIi4qquRjYKrp/pLmUkFJc0/CM76KcwWqYa29p8oWCn42UjHMLP2dLR6StJcgPqEkfddVWxj\n", + "VmfE5VnXwA+vhNlT2JgwckfG4jzmop0lXs2sS1p1hH9O0haklfuWAA+R3t87AH9FqqB6Anhbt4O0\n", + "caf58qzSKmDT2j9e5J9CPW0tKYx5iVcz656mZxoR8VbgH4DnAKcCVwA/AT4LzAKOjQgnDGtk2PQd\n", + "n4Y/rUuXmzaFjcniKwwbsVdLCtcBT9Ud11OAmFWsZcltXpP7sz2KxSaI4qSCs2Czh+GgKbB18cLp\n", + "ali9aVqRsX7d7zNzZ/c7gc0L963PP2ZWoVLTiEg6AHguhSQTEf/ZxbhGxR3hfSqV0NaP2t4wC22z\n", + "eaFadKRDs6VdzWzUurXc6wXA84ClpLJ5ACKibxaycdLoM9JjwMy6vQGcTMSpIz9cgzReB6PGFVRm\n", + "HTCWz84yI8JfCrwwujBtg6R5wOmky9rnRMRpDdqcARxKur59VETc2Ok4rEPGMAttE806wWtcQWVW\n", + "kTJJ4xZSxdSDnXzivITsl4GDgQeAGyQtiojlhTbzgedHxG6S9gO+CuzfyTisQzo7C+2w1fnquILK\n", + "rCJlksazgdsk/RJ4Ju+LiGh30sKXASsi4l4ASRcChwHLC20WAOfnJ7xe0kxJ20XEI20+t3VKLqGt\n", + "25uqaMd4dlroSP8M8EKGnlm4gsqsQmWSxsIuPfdOwH2F7fsZvnxsozazASeNqqV+hwMZfilqGRF7\n", + "t3v43NF9qRdRMusvIyaNiBjs0nOX/RZa/6HU8HGSFhY2B7sY9+TW41loa8mj08c1m4wkDQAD7Rxj\n", + "xKQh6eWka8x7AjNI162fjIit2nliUj/GnML2HNKZRKs2s/O+YSJiYZvx2EhGKKE1s/6Wv0wP1rYl\n", + "nTLaY5SZ5fbLwNuBu0jXrt9HGsjbriXAbpJ2kbQJ8FbSlCVFi4AjASTtDzzu/owKSI/l1fOKCSOA\n", + "k5wwzCaXMn0aRMRdkqZGxDrgPElLgRPbeeKIWCvpGOAy0tnLuRGxXNLR+f6zcofofEkrgJXAe9p5\n", + "ThulzpXQmtkEUWZw39XAa4FzSJMWPgy8OzrQ2dkpHtzXBZ0toTWzPtTRqdELjsztjiENsJsN/O3o\n", + "w7NxQVqVL0UVE0YAU5wwzKzs3FObA3Mi4o7uhzR6PtPogC6X0JpZ/+nKmYakBcCNpL4HJO0jqb7D\n", + "2sYrSUjrSHM9DZ2INkJE7D2m9b7NbEIqO7hvP+BKgIi4UdLzuhmU9UiJEtrCet/FKT3mSsKD7Mwm\n", + "nzJ9Gmsi4vG6fV7XYDwbXQntcQyfA+r5pFHaZjbJlDnTuFXSO4BpknYjfYj8vLthWVeMrYTWa3Wb\n", + "2QZlzjSOBfYiTVb4TeDPpGVgbTxJJbTnMzRhrM39Fq3GXHitbjPboFT1VL9z9VQLbc5C26RP427g\n", + "OPdpmI1vXVmESdK+wCeBXQrtIyJePOoIrXc6VEJbXO8bzzRrNumVGRF+J3ACaTGmDR3gtXUw+oHP\n", + "NAp6PAutmY1f3Vru9Q8R4XEZ44FnoTWzLitzpvE60gy0PwFW590REd/rcmylTcQzjdyXcBypP+Jp\n", + "4Iyml4Skx4CZdXsDOJmIU7sZp5mNX90603g3sEduWxyf0TdJY6IpPaDOs9CaWY+VOdO4A3hB9HGZ\n", + "1UQ705C0GDikwV2LI+LQ3Miz0JpZW7o1y+3PgReOLSQbo+YD6jwLrZlVqEzSeDmwVNKdkm7OP8u6\n", + "HdgkN2xA3d8D69KkgvUJZRkRU8qMuTAza1eZPo15XY/C6p0BzCX3adTqZ+vOIV1Ca2Y95xHhfUrS\n", + "/Cfgh1uA6l6YS2jNrCO61adhvSY9FnDJlkMTRrNZaM3MeqaypCFpW0mX576SH0uqH2eApDmSrpR0\n", + "q6RbJB1XRaw9Ix2JtJ7hYy5W5n6LU7uxIJIXWTKzssr0aXTLicDlEfEFSR/P2yfWtVkD/GNELJW0\n", + "JfArSZdHxPJeB9t1JUpou7EgkhdZMrPRqPLy1ALSVN3k32+qbxARD0fE0nz7SWA5sGPPIuyF0ZXQ\n", + "dmNBJC+yZGalVZk0touIR/LtR4DtWjWWtAuwD3B9d8PqEWkwX4oaTQltNxZE8iJLZlZaVy9PSboc\n", + "2L7BXf9c3IiIUPq23ew4WwLfAY7PZxyN2iwsbA5GxOCoA+6F9mah7caCSF5kyWySkDQADLR1jKpK\n", + "biXdDgxExMOSdgCujIgXNGg3Hfgh8KOIOL3JscZHyW2bs9B2Y0EkL7JkNnl1a8LCbllEmgzxtPz7\n", + "B/UNlL6Vnwvc1ixhjAsdmoW2GwsieZElMxuNKs80tgW+BewM3Au8JSIel7QjcHZEvF7SK4GrgWWk\n", + "D1mAT0TE4rpj9eeZhmehNbM+NpbPTo8I7xbPQmtmfW68XZ6amKRVDK9ISiW1EyFDm9mk5mlEOmVs\n", + "JbQlDuvR2mbWP3ym0a72SmhHOrRHa5tZX/GZRjtSCe16hv4d1xOhDk1b7tHaZtZXnDTGQnosT/1R\n", + "7NTuxiy0Hq1tZn3Fl6dGo/cltB6tbWZ9xUmjrGpKaIes4JfdDZzZxec0M2vKSWMkFZbQerS2mfUb\n", + "D+5rftBB4ECGX4paRsTeHX0uM7MKeHBfJ3SxhNbMbLxz0ihqcxZaM7OJziW30MsSWjOzcW1yn2l4\n", + "Flozs1GZvEnDs9CamY3a5EsanoXWzGzMJk+fRpdmoTUzm0wm/pmGS2jNzDpmYicNl9CamXVUJZen\n", + "JG0r6XJJd0r6saSZLdpOlXSjpItH8QQuoTUz64Kq+jROBC6PiN2BK/J2M8cDt5E+9FuTjsz9FvVJ\n", + "aGXutzh1jPGamRnVJY0FwPn59vnAmxo1kjQbmA+cw/CxFPWN1+ZjFdutzQsiecyFmVkHVJU0touI\n", + "R/LtR4DtmrT7IvBPpNXxRlK87BTAlGZjLrzutpnZ2HStI1zS5cD2De765+JGRIRS/0P9498A/D4i\n", + "bpQ0MIqnbjkLrdfdNjMbu64ljYh4bbP7JD0iafuIeFjSDsDvGzR7BbAgf8hvCmwl6T8j4shGx/wU\n", + "rPsX+GyDdiCFAAALVElEQVR+goGIGGzy9K3W3XbSMLMJK38BH2jrGFWMaZP0BeDRiDhN0onAzIho\n", + "2hku6SDghIh4Y5P7S88Jr7ROxkEN7roqIgbKHMPMbCIYy3oaVfVpfB54raQ7gb/O20jaUdIlTR7T\n", + "qezWbN3tvdy3YWbW2qRbua9Jn0bNCuB4922Y2WQwns40KpMTwvHAHxvcXevbMDOzBiZd0oANiePW\n", + "Jndv1stYzMzGk0mZNLJmfRurehqFmdk4MpmTxhmkPoyiu4EzK4jFzGxcmNiz3LYQEZemWdM5lnRJ\n", + "ahVwpjvBzcyam3TVU2Zmlrh6yszMuspJw8zMSnPSMDOz0pw0zMysNCcNMzMrzUnDzMxKc9IwM7PS\n", + "nDTMzKw0Jw0zMyvNScPMzEpz0jAzs9KcNMzMrDQnDTMzK62SpCFpW0mXS7pT0o8lzWzSbqak70ha\n", + "Luk2Sfv3OlYzM9uoqjONE4HLI2J34Iq83ciXgEsjYk/gxcDyHsXXU5IGqo5hrMZz7OD4q+b4x5+q\n", + "ksYC4Px8+3zgTfUNJG0NvCoivgYQEWsj4k+9C7GnBqoOoA0DVQfQpoGqA2jTQNUBtGmg6gDaNFB1\n", + "AL1WVdLYLiIeybcfAbZr0GZX4A+SzpP0a0lnS9q8dyGamVm9riWN3Gdxc4OfBcV2kZYObLR84DTg\n", + "JcBXIuIlwEqaX8YyM7MeqGS5V0m3AwMR8bCkHYArI+IFdW22B66LiF3z9iuBEyPiDQ2ON/7XrDUz\n", + "q8Bol3ud1q1ARrAIeDdwWv79g/oGOaHcJ2n3iLgTOBi4tdHBvD64mVlvVHWmsS3wLWBn4F7gLRHx\n", + "uKQdgbMj4vW53d7AOcAmwN3AeyZwZ7iZWd+rJGmYmdn4NC5HhJcdHJjbTpV0o6SLexljK2XilzRH\n", + "0pWSbpV0i6Tjqoi1EM88SbdLukvSx5u0OSPff5OkfXodYysjxS/pHTnuZZKulfTiKuJspszfP7fb\n", + "V9JaSYf3Mr6RlPz/Gcjv1VskDfY4xKZK/O/MkrRY0tIc+1EVhNmUpK9JekTSzS3alH/vRsS4+wG+\n", + "AHws3/448PkWbT8CfB1YVHXco4kf2B74y3x7S+AOYM+K4p0KrAB2AaYDS+tjAeaTBmIC7Af8ouq/\n", + "8yjjfzmwdb49b7zFX2j3U+CHwN9WHfco//4zSX2Ws/P2rKrjHkXsC4F/rcUNPApMqzr2QnyvAvYB\n", + "bm5y/6jeu+PyTIMSgwMBJM0m/UHOAfqps3zE+CPi4YhYmm8/SRoNv2PPIhzqZcCKiLg3ItYAFwKH\n", + "1bXZ8Joi4npgpqRG42+qMGL8EXFdbOwvux6Y3eMYWynz9wc4FvgO8IdeBldCmfjfDnw3Iu4HiIg/\n", + "9jjGZsrE/hCwVb69FfBoRKztYYwtRcQ1wGMtmozqvTtek0aZwYEAXwT+CVjfk6jKKxs/AJJ2IX1T\n", + "uL67YTW1E3BfYfv+vG+kNv3ywVsm/qL3AZd2NaLRGTF+STuRPsy+mnf1U2dlmb//bsC2+ZLsEknv\n", + "6ll0rZWJ/WxgL0kPAjcBx/cotk4Z1Xu3qpLbEUm6nHSJpt4/FzciIhqN05D0BuD3EXFjFfPDtBt/\n", + "4Thbkr49Hp/POKpQ9gOo/myuXz64Ssch6dXAe4EDuhfOqJWJ/3TSOKaQJPrrzLpM/NNJg3lfA2wO\n", + "XCfpFxFxV1cjG1mZ2D8JLI2IAUlzgcsl7R0RT3Q5tk4q/d7t26QREa9tdl/u1Nk+Ng4O/H2DZq8A\n", + "FkiaD2wKbCXpPyPiyC6FPEQH4kfSdOC7wAURMWwsSw89AMwpbM8hfRtp1WZ23tcPysRP7vw+G5gX\n", + "Ea1O53utTPwvBS5M+YJZwKGS1kTEot6E2FKZ+O8D/hgRq4BVkq4G9gaqThplYn8FcCpARNwt6TfA\n", + "HsCSnkTYvlG9d8fr5ana4EBoPjjwkxExJ9KI8rcBP+1VwihhxPjzt8Vzgdsi4vQextbIEmA3SbtI\n", + "2gR4K+k1FC0CjgRQmsL+8cIluKqNGL+knYHvAe+MiBUVxNjKiPFHxPMiYtf8//4d4EN9kjCg3P/P\n", + "fwOvzNWOm5M6ZG/rcZyNlIn9dtLgY3JfwB7APT2Nsj2je+9W3bM/xmqAbYGfAHcCPwZm5v07Apc0\n", + "aH8Q/VU9NWL8wCtJfTFLgRvzz7wKYz6UVMG1AvhE3nc0cHShzZfz/TcBL6n67zya+EnFEo8W/ta/\n", + "rDrm0f79C23PAw6vOuYx/P+cQKqguhk4ruqYR/G/Mwu4OP/f3wy8veqY6+L/JvAgsJp0Rvfedt67\n", + "HtxnZmaljdfLU2ZmVgEnDTMzK81Jw8zMSnPSMDOz0pw0zMysNCcNMzMrzUnDLJN0UZ4Gop1jzJB0\n", + "taSuv7fyVOIX59tvHGHK9K0lfaiwvaOkb3c7Rpt4nDTMAEnPB7aIiLvbOU5EPANcQ5OZl0vGMur3\n", + "ZURcHBGntWiyDfDhQvsHI+LNY4nPJjcnDes7ecqG2yWdJ+kOSV+X9Lq8ONKdkvbN7bbIC8xcL+nX\n", + "khYUHn+1pF/ln5fn/QOSBiV9W9JySRcUnvZt5OkhJD03P89fSJoi6RpJB9fF+B5JXyxsv1/Sv+XN\n", + "RcARLV7XBZJuy3Fslu+7V9LnJf0KeHN+vT/P8X9L0ha53bwc+6+Avykc+yhJZ+bb20n6vtKiQEvz\n", + "6/88MFdpkaPT8mu8JbffNP+tl+W/40DhmN+T9KP892iVlGyyqHqIu3/8U/9DWvBmDbAXafbNJcC5\n", + "+b4FwPfz7c8B78i3Z5Kmetgc2AyYkffvBtyQbw8Aj5OmaxHwc+CAfN+PKEyfQJoe/VukqfW/2iDG\n", + "LUjTLkzN29cCe+XbM4AHmryu9cDL8/a5wEfz7d8AJ+Tbs4CrgM3y9seBk0kTb/4OmJv3X0SeHgc4\n", + "CjizsP+4fHsKaY2H51JYhCfHcnO+/VHgnHx7D+C3+TUcBdwNPCtv3wvsVPX/h3+q/fGZhvWr30TE\n", + "rRERpPmIfpL330L6wAN4HXCipBuBK0kfbHOATYBzJC0jffDvWTjuLyNdmgnSvF7PzfufS1pMB4CI\n", + "OBfYmjRHzwn1wUXEStIqeW+U9AJgekTcmu97BpgiadMGr+u+iLgu376ANMdYzUX59/7AC4Gf59d2\n", + "JLAz6QP9N7HxEtoFNJ4C/dXkdTUiYn1E/LlJu5oD8rGIiDtISWN30vTYV0TEE/k13cbGv71NUn07\n", + "NbpNes8Ubq8nTbZWu138vz086tZckLQQeCgi3iVpKvB0k+OuqzvWhg/WPNPqbNIH57OAlQ1iPIe0\n", + "Pspy4Gt194nGaxJEizbF57g8It4+5IDS3g2eo5nRrqfRrH3932vqKI9rE4zPNGw8uww4rrYhaZ98\n", + "cyvg4Xz7SMp90P0W2KGwfRrwX8AppDU2as9xhaQdASLil6TE8nbSTKK1NjOAdfnbeb2d8/TT5Mdd\n", + "06DN9cABtUqu3HezG2kK7l0kPS+3G9Zvkl0BfCg/dqqkrYAnSMmvkWuAd+T2u5POam6ncSLpp8Wd\n", + "rAJOGtav6r+lR4Pb/wJMzx24twCfzvu/Arxb0lLSJZ0nGzy23s+AvwKQdBBpUaPTIuIbwGpJ785V\n", + "TXNJU6jXfAv4WWxcXxzS0rzX0dgdwP+SdBvp8tew5Vkj4g+k/oRvSrqJ1PeyR05CHwAuyR3hjxQe\n", + "F4XbxwOvzpfnlgB7RsSjwLWSbs4d2sX2XyFdTltGWgP73ZHWwy622RBek9dlk4SnRjcD8rf3MyPi\n", + "9S3a7AW8JyJOKOy7GPi3iLiysO9zpM7379c9fhfg4oh4UYfDN+sZn2mYARFxD/BEq8F9uWP+BABJ\n", + "MyXdATxVlzBmkDq3my3P629pNq75TMPMzErzmYaZmZXmpGFmZqU5aZiZWWlOGmZmVpqThpmZleak\n", + "YWZmpf1/HOhEFZUoXMwAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEZCAYAAABrUHmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xm8XHV9//HXmxCWKBA0LWsQSRCRX7G4IArKtWAJqYaW\n", + "FgGpgEvrxtIqLahVgloV+qtK8CcPBORB3XCvidJYilxAQEgsYU2QsCiERUCRVb1JPr8/zneSc+fO\n", + "zD2znpk77+fjcR+Zc+bMmc+9ufd85nO+myICMzOzIjYpOwAzMxscThpmZlaYk4aZmRXmpGFmZoU5\n", + "aZiZWWFOGmZmVpiThlkbJK2XtFvZcZj1ipOGDQ1J90p6RtKT6esJSdt38f1GJb2jat8dkt6c294/\n", + "JZ7qfU9I2kTS8ZKubnD+Z9P38qik70vauVvfjxk4adhwCeCNEbFV+to6Ih7q8vtVj569Enhdbvt1\n", + "wKoa+66NiPUFzv++iNgKmANsAXymrYjNJuGkYUNP0sWS3p8e75Q++b83bc+R9Fju2H+S9ICk+yW9\n", + "vYW3u4rxCeIA4Myqfa9NxxUWEb8Fvg/s1UJMZoU5adiwUY19o8BIenwgcDcbL+IHki7gkuYBHwAO\n", + "Bl6U/m3W1cBekmZK2gR4BfANYGZu32sonjSUYns+cDhwfQsxmRXmpGHDRMB/SvpN+vpu2n8VcIAk\n", + "kX3KPwvYPz13INktJYA3A1+KiNsj4hng9GYDiIhfAL8kS0ovBe6MiN8B1+T2bUaxi7+ARZIeBx4B\n", + "ngu8r9mYzJrhpGHDJIDDImLb9HU4QETcBTwN/ClZ0vgB8ICkF5FdyCtJYwfgvtz5ftliHJVbVPnb\n", + "UD/J7bs+IsYKfj8nRsRMYG/gBcD8FmMyK8RJwyxzJXAEMD0iHkjbxwPbAivSMQ8Cu+Rek3/cjHzS\n", + "qPSMupqJiaQIAUTErcBHgE+nW1xmXeFfLrPMlcAJbLxgj6btq2Pj+gHfBI6XtKekGRS7PTVd0ha5\n", + "r03Te7yMLElck467BdgNeD0Tk4YkbZ4/T533uhiYQZb8zLrCScMscxVZm0Dlgn0NsGVum4hYCnwO\n", + "+DHwc+ByJnaprXYu8Ezu60sRcSfwK+DBiHginTvI2jG2Aq7NvT7IGsafzZ3jaUnTcs9X4hsDzgb+\n", + "uYnv26wpKnMRJklfAv4C+FVE/EmdYxYBh5L9sRwfETf2MEQzM8spu9K4CJhX70lJ84G5EbE78Pdk\n", + "n9rMzKwkpSaNiLga+E2DQxaQ3aclIq4n68u+XS9iMzOzicquNCazE+O7ON4PeG4dM7OS9HvSgIkj\n", + "eMtrhDEzG3Kblh3AJNYAs3PbO6d940hyIjEza0FE1Jpap65+TxqLyfrKXyJpP+DxiHi41oHNfuP9\n", + "RNLCiFhYdhytGOTYwfGXzfGXq5UP3KUmDUlfJ5vbZ5ak+8gGS00HiIjzIuJSSfMlrSab5uFt5UVr\n", + "ZmalJo2IOLrAMSf0IhYzM5vcIDSED4PRsgNow2jZAbRptOwA2jRadgBtGi07gDaNlh1Ar5U6IrxT\n", + "JMUgt2mYmZWhlWunKw0zMyvMScPMzApz0jAzs8KcNMzMrDAnDTMzK8xJw8zMCnPSMDOzwpw0zMys\n", + "MCcNMzMrzEnDzMwKc9IwM7PCnDTMzKwwJw0zMyvMScPMzApz0jAzs8KcNMzMrDAnDTMzK8xJw8zM\n", + "CnPSMDOzwpw0zMysMCcNMzMrrNSkIWmepFWS7pR0ao3nZ0laKmmFpFslHV9CmGZmligiynljaRpw\n", + "B3AwsAZYBhwdEStzxywENo+ID0qalY7fLiLWVp0rIkI9C97MbApo5dpZZqWxL7A6Iu6NiDHgEuCw\n", + "qmMeBLZOj7cGHqtOGGZm1jtlJo2dgPty2/enfXnnA3tJegC4CTi5R7GZmdUnLUEKpPVlh9Jrm5b4\n", + "3kXui30IWBERI5LmAJdJemlEPFl9YLqVVTEaEaOdCdPMLEdaC0yrbCHdRMRLywypKEkjwEg75ygz\n", + "aawBZue2Z5NVG3mvAf4VICLuknQPsAewvPpkEbGwO2GamZFVF/DGqr3rBiVhAKQP06OVbUmnN3uO\n", + "Mm9PLQd2l7SrpM2AI4HFVcesImsoR9J2ZAnj7p5GaWaWVRfVCWMZEWV+8C5Fad9wRKyVdALwI7JS\n", + "78KIWCnpXen584BPAhdJuokswf1zRPy6rJjNbMjUry6GLllUlNbltpPc5dbMOm5820XFMiL2LSOc\n", + "bhi0LrdmZv2n0jNqfMJYR4SmUsJo1dCWWGZmEwxBddEuVxpmZq4uCnOlYWbDzdVFU1xpmNlwcnXR\n", + "ElcaZjZ8XF20zJWGmQ0PVxdtc6VhZsPB1UVHuNIws6nN1UVHudIws6nL1UXHudIws6nH1UXXuNIw\n", + "s6nF1UVXOWmYWakkzQdOArYAfgcsiohLm33d3TDjhfDaqsOGekbabvAst2ZWmnThPxuYm9v9DHBW\n", + "RJxR9HVjZKVF1UXA1cUkWrl2OmmYWc/UqCr+CHhZjUOfAY5IjydUIZKWAod8Gzi8cm6yNaTl6qKw\n", + "Vq6d/sGaTTGt3u7ptjpVxfo6h88AzgBmVh0/RxLAFvnqItLXLbBm74idOxy65ThpmE0hdS7McyTR\n", + "B4njJMbHBY17cM4Btq3aN/drsOio7LkNCWMdMD17/pbBv3fS39zl1mxqqXVhngucWEIsG6Rk1mz7\n", + "woTr/xhwFMxR7oBr2ZAw7gLOaTlIK8SVhtnUskWd/VtWHvT69lWu+qmuGvLWM/5D7F3Ab4HnAfxf\n", + "4P2V86V/18G66XAZ2ff2LHBOH1RTU56ThtnU8rs6+5+F0m5f1ap+qt0IPEIuAaT9Z4/B3Oq2C8Gy\n", + "TSP29a2o3nPSMJtaFpHd789fpPO3bRrdvmo6aRSsWupVP/n4PjrhddKSSLHm2i7WbeqeUaXyD99s\n", + "CkndUSFLArVu20x6+6qoRlVLUkkme9U5xa+BG6h1WymN6s73Ba1UF83GaZ3lpGE2xaQLcL2qoeHt\n", + "qybVq1o+BmxT9dwYG9qrN7zfPVQnDGkJ8Maqc3rcRR8ptfeUpHmSVkm6U9KpdY4ZkXSjpFsljfY4\n", + "RLOpZhGwumrfg8AfSxqVtFTS/PS1NL+vxrnqVS27MTGZTCdr2K4kpy2BlwNnbzh3Vl1UJ4xlThj9\n", + "pbT/DEnTgM8DBwNrgGWSFkfEytwxM4H/BxwSEfdLmlVOtGZTQ43bV88BdmL8qOy9yZoQdsztq9VY\n", + "Xq9qqdc+PYPx1QbA3PfBeUjVA/JcXfSpMiuNfYHVEXFvRIwBlwCHVR3zFuA7EXE/QEQ82uMYzaac\n", + "iLg0Ig6NiBHgMWCHqkN2YHzCgNpjPWpVLXeR3XaqpTph8BhwDlQnDFcXfazM/5idgPty2/cDr6o6\n", + "ZndguqQrgK2AsyPiyz2Kz2wYTNazKW9cY3m9Rvf0dHUD+TgHkQ2wgHGTDLq6GACF/oMkzQBmR8Qd\n", + "HXzvIl2sp5OVzQeRlbbXSfppRNxZI8aFuc3RiBjtRJBmU1y9W0y1TGgsr9fonpLJl0mD8/K+CLyT\n", + "ieMuPCNt90kaAUbaOcekSUPSAuDfgM2BXSXtA5wREQvaeWOydozZue3ZZNVG3n3AoxHxLPCspKuA\n", + "lwITkkZELGwzHrNhVGtcx4NMbNNoaoqOVIUsAw6p7HsesILsXlQlYayFddNdXfRM+jA9WtmWdHqz\n", + "5yjyn7WQ7LbRFelNb5S0W7NvVMNyYHdJuwIPAEcCR1cd833g86nRfPMUx2c68N5mxqS3mOqN9Shq\n", + "Q0I6HfgoWSNq5RaDYNl0VxcDp0jSGIuIx3MDdqD+dMaFRcRaSScAPyKb4fjCiFgp6V3p+fMiYlWa\n", + "N//m9J7nR8Tt7b63mW3UYFxHW9OKRMSlX5c+8gaY+3y83sVUMekiTJK+BFwOnEa23slJwPSIeHf3\n", + "wyvGizCZ9SGv1d33Wrl2FulyeyLZNAC/B74OPAH8Q/PhmVm1goPo+p6k0yU9Iunxf5OeDCkYnzDW\n", + "ESEnjMFXpNJ4WUT8b4/iaYkrDRtEdeZuWg2cPEhTfKfG1A8D06tX00t/lK4u+lRX1ghPU3dsD3wL\n", + "+EZE3NpyhF3ipGGDqLLOdY2nlkbEob2Op1WSHjkVZn2qss2GGWlj0wgv9NbHunJ7Ko0afT3wKHCe\n", + "pFskfaS1EM0sp2MzzpZpLCWM/Gp6ZwPTs1vZNsUU+hQQEQ9GxNnAu4GbyHrPmVl7tqqz/7k9jaJV\n", + "0hKkyN+OWkd2UfnH7Iix0mKzrpk0aUh6iaSFkm4lm2DwWrIpQMysPfXuDff/gnRVM9LmqouKMbLr\n", + "hU0xRfpKf4lsMsFDImJNl+MxGyZP1dn/dE+jSOqtwpffvwh2PgHmVC2OtE7wceAEsrwxBnw+Is7o\n", + "8bdgPTBp0oiI/XoRiNkQ6uSCSG1psArfK4G/BeY26hmVSiMniSFQN2lI+lZEHCHplhpPR0Ts3cW4\n", + "zIbBZOt591K9VfhOOAVmnZV2uGeUNao0Tk7/vpFxsxcDg3DP1azPFVjPu5dq9uQag1n56iKAfwf+\n", + "Ca7yRWA41U0aEfFAevjeiBi3FKukM4Gay7OaWXGTrOfdS+NulV0AvD09zveMyjV09/wWmvWHIuXl\n", + "n9fYN5BTHZhZXRtW4RsjSxj5cRf/zriEUdYtNOsDdUeES3oP8F6ye6535Z7aCrgmIo7pfnjFeES4\n", + "WftWSle/GA6A8TPSChbQH7fQrMM6Oo2IpG2AbYFPk92Kqpz4yYh4rJ1AO81Jw6y4ml1rYTGekXbo\n", + "dGvuqVcDt0XEE2l7a2DPiLi+5Ug7zEnDrLYaCeI6UhdagP8kKyPAa3UPo24ljRXAyyJifdqeBiyP\n", + "iH1ajrTDnDTMJqoz9uIZYAZkbReekXa4dWs9DSoJIz1ex8Qy1sz6T62xFzOOJlsGs2rOKK93YYUU\n", + "SRr3SDpJ0nRJm0k6Gbi724GZWetSlTEhAdwPfJXxPaNuAKbDZb2LzgZZkaTxbmB/YA3Z79x+wN93\n", + "Mygza13uttS2lX2vJqsudmTijLT7uQutNWHSNo1B4DYNm+pSIvg48MK0627go7W6vlYv7nQ/45MF\n", + "wO2w5v9k4zLchXaIdashfA/gC8D2EbGXpL2BBRHxidZD7SwnDZvKUsK4ANih6qkHgL+rvuCn1TYP\n", + "nMfGoeaVhPEHWLe5e0ZZ0q2G8POBDwF/SNu3AEc3GZuZte4kJiYMyAqIE2vs/93jZAkj33bxCfiV\n", + "E4a1q0jSmJEfkxFZaeIVucx6p96ysFC9NKy0ZD0csjUbq4tngE3gro/C27oXog2LIknjEUkbuu1J\n", + "+hvgwU68uaR5klZJulNS3QkQJb1S0lpJh3fifc36jaT5kpZKGk3/5ud3q7fuBuQnDkyr6eWri4/C\n", + "Y8+FpcBJbrewTijSpjEH+CJZB4zHgXuAYyLi3rbeOBskeAdwMFnPrGXA0RGxssZxl5F9YLooIr5T\n", + "41xu07CBVWcQ3mrg5NzKebXaNB4E3hnwHnJLryYe1W2T6mibRhqPAbBDRBwE/DHw4ojYv92EkewL\n", + "rI6IeyNijGxJ2cNqHHci8G3gkQ68p1k/qrcA0omwYfr0dwI/A36dvpaTJYzFkRJGZb2Lu+F2Jwzr\n", + "lka3pyrT6Z8DEBFPVeaf6pCdgPty2/enfRtI2okskZybdg1+/2Czieq1WWxor4iISyPiFRHx/Ih4\n", + "fsBDAT8MmFY97mIObFZ1e8usYxp9Grld0p3ATjWWfO3Ecq9FEsDngNMiIpQtcVa3jJK0MLc5GhGj\n", + "7YVn1jk1Z5bd2MbQ3FrhWdvFhql8gqwUf/PGIypVitswbBxJI8BIO+dotHLf0ZK2B35ENhFmp9sM\n", + "1gCzc9uzyaqNvJcDl6QlMWcBh0oai4jFNeJd2OH4zDqiTpvE3pLemRJHsbXCpSVUtV2sg5he+29z\n", + "yxr7bMilD9OjlW1Jpzd7jrpJQ9LlEXGQpB9FxC9airCx5cDuknYlG6R0JFXjPyJit1w8FwFLaiUM\n", + "sz73cSY2Yu8AfAy4tNBa4VXVRbJseta+cQgTeTlW64pGt6d2kLQ/sEDSJYyfhYCI+N923jgi1ko6\n", + "gaySmQZcGBErJb0rPX9eO+c36yMvnGx/3bXCa1QX5HtGZVXM5FWKWYc0WrnvCOAdZJMVLq9+PiJe\n", + "393QinOXW+tnkn5NbvLAnDHgL+uOn6hTXVRPX55uf3k5Vmtat+ae+mhEfKytyLrMScP6maTlZO1z\n", + "tWwYj5F7QePqwqxDupU0NgGOAV4YER+TtAvZ5IU3tB5qZzlpWD9LlcD5ZHNF1bI0Ig5NBxeqLsw6\n", + "oVsTFn6BbDT4W9L2U2mfmRWQqoi/I2u0rmVLpCVIwfiE4dX0rO8USRqvioj3knpjRMSvgeldjcps\n", + "ikmJY1mt58bgtUy8HbXMt6OsHxVJGn9I8z8BIOmPyBYBM7PmLCJrwwDgs2xYqzv/d+jqwvpakU8y\n", + "5wDfA/5Y0ieBvwH+patRmU1B+fEYY3DINFDVzWS3XVjfK7Tcq6Q9gYPS5uXVM9GWzQ3h1opJpvbo\n", + "1pu6Z5T1jVaunYV+UVOS6KtEYdaOOtORz5FE1xKHe0bZFFCkTcNsKmo4HXlHuWeUTSEuiW1YTTod\n", + "eUe4urAppnClIWkLSZt3MxizHmpuOvJmubqwKarRyn2bSDpc0rckrSFb5vUXktZI+rakv0prXJgN\n", + "onHdX5POTPSX1uqu2utxFzYlNJqw8CrgamAxsCIifp/2bw7sQ7bGxgER8boexVqXe09ZKzo+0Z97\n", + "RtmA6ejcU5I2rySKBm846TG94KRhpXPbhQ2gjs49lassPiNpr0bHmA0tt13YkCnSEL4S+KKkGyS9\n", + "W9I23Q7KbCC47cKG0KRJIyLOj4j9gWOBXYFbJH1NUt8swmTWLknzJS2VNJr+nd/gYFcXNrQKfSJK\n", + "Exa+GNgTeAS4CXi/pHdHxJFdjM+s65oaHe62CxtyRRZh+izwJuDHwAX5xZck3RERe3Q3xMm5Idza\n", + "IWkpcEiNp/KLI7lnlE053Zp76mbgXyLi6RrPvaqZNzPrU41Hh+eqi8pHrM/Aw6fA2yef7tNsapk0\n", + "aUTERfltSTsCj0XE7yPi8a5FZtYBBWeyrTk6/FMwO7VdAFnCGAPStAjbAWd3dYJDsz7USmn9ZbL7\n", + "vd+OiFM6HZBZpzTRVrEImJM/bgyYBrtVtgN4H3Du+LeoTHDopGFDo+lZbiPiILI/posmO9asZIVm\n", + "sk0J5GRg6Sfgl2k1PXI3etdtAldWJYyKzk5waNbnJk0akg6usfutEXFbu28uaZ6kVZLulHRqjeeP\n", + "kXSTpJslXSNp73bf04ZK4ZlsI+LSgDd8GHYR4xJGZdxFdyc4NBsQRSqN0yWdK+k5krZX1otkQbtv\n", + "nLrxfh6YB7wEODqtEJh3N/C6iNgb+DjwxXbf14ZKsQt9sXEX3Zvg0GyAFGnTOBD4ANnYjABOj4iv\n", + "deC99wVWR8S9AJIuAQ4jt0JgRFyXO/56YOcOvK8NjwltFVRf6AuOu8iv702nJjg0G0BFksa2wCvJ\n", + "/th2BnZR6tzb5nvvBNyX276fxl1434EbHK0JDS/0LYy7SAnCv4M21IokjeuAMyPiQkkzgDOBa4DX\n", + "tPnehZNOmrLk7cD+DY5ZmNscjYjRliOzKaPmhd6jum1ISRoBRto6R4ER4S+IiF9U7TswIq5s642l\n", + "/YCFETEvbX8QWB8RZ1YdtzfwXWBeRFTfU64c4xHhNjmP6jYbp6NTo0uaA1CdMNK+K/PHtGg5sLuk\n", + "XSVtBhxJtuBTPoZdyBLG39ZLGGaFSGufTAljPfAd4JvwcycMs+Y0WoTpG8BzyC7ky4EHyXoi7gC8\n", + "gqwH1ZMRcVTLby4dCnyO7FbBhRHxKUnvAoiI8yRdAPwV8Mv0krGocQvBlYbVlaqL9WSfkO4A3kZ2\n", + "z5WsN9TJbsy2YdXRlfvSCecCR5G1Jbwg7f4F8BPg6xFxd4uxdpSThtWUa7tYD3wW+Bcm9MPdOCmh\n", + "2ZDpeNIYFE4aNk6Ntov3MmEKkIorI2Kk6zGZ9aFuzXKLpEqlseH4iPiP5sIz64E6PaPOhV9Te/pz\n", + "j+g2a8KkSUPSV8jmmloBrMs95aRh/WOynlHZ5IWNB/qZ2aSKVBovB17SgcF8Zt1RYNyFR3SbdUaR\n", + "pHErWY+pB7oci1lzmhx34RHdZu0rkjT+CLhd0g3A79O+iIi2Jy00a5lHdZuVokjSWNjtIMwK86hu\n", + "s1K5y60NDlcXZh3V0WlEcid9taRlkp6SNCZpvaQnWg/TrD5J8yUtlTSa/p1fcL0LM+uBIiX958lG\n", + "hX+TbPqQY4E9uhmUDZ60HvdJZKvl/Q5Y1GzPpFprev8BDgnGraQHri7MSlPoPnBE3ClpWkSsAy6S\n", + "tAI4rbuh2aCodbEH5kiiycSxYU3vtwEXVs6/8Xm3XZiVrMgf4NOSNgduknQW8BATPvjZkNtwsc+Z\n", + "SzYm4lIoXIlsAfAHsl9MkS26kioNVxdmfaDIGuHHpuNOAJ4hW73vr7sZlA2cLers3xLGVSKHkC0f\n", + "fAhwdtq/wSdgl/WMTxjrgE1gqROGWX+YNGmkNbwFbB8RCyPi/V7bwqr8rs7+yrxO9SqRizckDmnt\n", + "h+CFlRI2gA8C0z3Vh1lfKdJ7agFwI/CjtL2PpMWNX2VDZhHZ2hR5+Yt9vUpk1onw1Ug9o3LVRWwC\n", + "V54JS4GTPNWHWf8oOrjvVcAVABFxo6TduhmUDZYC8zrVrESeAmbAzHwDmWDZphH7Dv7oIbOpqUjS\n", + "GIuIx9NFoWJ9l+KxATXJvE6LyM0w+ybg++mJSnUh94wyGwhFGsJvk3QMsKmk3SWdA1zb5bhsCkkJ\n", + "5WTg0afIEka+7eIL8KAThtlgKJI0TgT2Ipus8OvAE8A/dDMom3oC3rMeZs1gQs+ou06Ad5YbnZkV\n", + "5bmnrPuktZFr6AY4Hfh41oX7rIg4o7zgzIZXV5Z7lfRK4EPArrnjIyL2bjpCGy65GWnz1cX0jUfM\n", + "APYrITIza1GR+8hfBU4hW4zJDeBWTNWMtAF8GThu4pFb9iwmM2tbkaTxSER4XIYVU2e9i03gf8hG\n", + "gld7tsY+M+tTRRrCz5B0oaSjJf11+jq8E28uaZ6kVZLulHRqnWMWpedvkrRPJ97XuiSrLqoTxrLU\n", + "M2qyAYBmNgCKVBrHkU2Fvinjb099t503ljSNbNr1g4E1wDJJiyNiZe6Y+cDciNhd0quAc/E98P5T\n", + "YDW9AgMAzWwAFEkarwBeHJ3vZrUvsDrNbYWkS4DDgJW5YxYAFwNExPWSZkraLiIe7nAs1qpc20WQ\n", + "Df0+Cn67GH6KND+fFCYZAGhmA6DI7alrgZd04b13Au7Lbd+f9k12zM5diMUKqqys92NpdUgRuYTx\n", + "fbLuUIthG+rMZGtmg61IpfFqYIWke8gG+EFnutwWrVyq+xDXfJ2khbnN0YgYbSEma6AyxfkYzJ3G\n", + "+PUujoDffAe2rXrJuDU1zKxckkaAkXbOUSRpzGvnDRpYA8zObc8mqyQaHbNz2jdBRCzsZHA20RWw\n", + "6MBsDqnqcRdLydopDqzxMnepNesT6cP0aGVb0unNnqPQehq1vpp9oxqWA7tL2lXSZsCRQHXX3sVk\n", + "i0AhaT/gcbdn9FbldtRaKQ6EOfk5o37ChoF6WzL5mhpmNgWUNklcRKyVdALZOh3TgAsjYqWkd6Xn\n", + "z0s9buZLWg08TbZ0tPVAuhX18QNg7ythU1F3VDeknlDkZrJN3KXWbIrx3FM2QaXtYhnMfTkbkwXA\n", + "Gekr5y7SQknpde5SazYgWrl2OmnYBEdJD3wNdshXF7cBf7LxkF8Dt+DEYDbQnDSsfVUz0gbZaMpl\n", + "449aGhGHtnZ6zSdbM3wLsnaQRU46ZuXoyiy3NiRqzEhbVV1UtNxOUbntxfh2jzmScOIwGwyuNKzm\n", + "jLQL4NkfjO8u+yxZHjm91Qu8pKXUnrSw5crFzFrnSsOaU2fOKEVs+oPuNGpvUWe/x3KYDQgnjWFV\n", + "VV0ky4jYF7o2T5THcpgNuCJzT9lUIi1BCsYnjHVEqJIwusjTo5sNOFcaw2SS6qLbPD262eBzQ/gw\n", + "KLDehZkNHzeE20QlVxdmNrW4TWOqKrftwsymKN+emopqVBer4PY9swWtPBLbzADfnrJ64y6yZXPP\n", + "ZvzAOo/ENrOmudKYKhq0XXgktpnV0sq1020ag65Y24VHYptZR/j21CAr3jPKI7HNrCNcaQyi5ntG\n", + "eSS2mXWEK41B08K4C4/ENrNOcUN4H6q5UBG8J6rWu1gH6zb1qG4za5FX7psCai1UNEZWWuTX6l4K\n", + "zM9uOZ3sisHMWuHeU1PDSaSEcSKwnvEJYx3Zf9r87Ni56TAzs57wrY3+swVMrC6CDdVFNXebNbOe\n", + "caXRZ/4ddq5TXTxaI2FArtuspPmSlkoaTf/WeYmZWWtKSxqSnifpMkk/l/TfkmbWOGa2pCsk3Sbp\n", + "VkknlRFrz0hr/xHmVG4wBvCvwPSse+znadBtNtcWcghwYPr3bCcOM+uk0hrCJZ0FPBoRZ0k6Fdg2\n", + "Ik6rOmZ7YPuIWCHpucDPgL+MiJVVxw12Q3jVnFGpuojpcBW57rFqsG63pwoxs2YN2oSFC8g+EQNc\n", + "DIwC45JGRDwEPJQePyVpJbAjMC5pDLQa4y4EyzaN2Lc6nU+ybrenCjGzriuzTWO7iHg4PX4Y2K7R\n", + "wZJ2BfYBru9uWD3S+fUuPFWImXVdVysNSZcB29d46sP5jYgIZRfQeud5LvBtsjEJT9U5ZmFuczQi\n", + "RpsOuFe6s5reImAOufEdeKoQM8uRNAKMtHWOEts0VgEjEfGQpB2AKyLixTWOmw78APiviPhcnXMN\n", + "RptGl9fqbtTmYWZWbaBGhKeG8Mci4kxJpwEzazSEi6y947GI+McG5+r/pOG1us2szwxa0nge8E1g\n", + "F+Be4M0R8bikHYHzI+IvJB1A1oPoZjbOoPHBiFhada7+TRpdri7MzFo1UEmjk/o2abi6MLM+5rmn\n", + "+kXne0aZmfUF3yLpNFcXZjaFudLoFFcXZjYEXGl0gqsLMxsSrjTa4erCzIaMK41WubowsyHkSqNZ\n", + "ri7MbIi50miGqwszG3KuNIpwdWFmBrjSmJyrCzOzDVxp1OPqwsxsAlcatbi6MDOryZVGnqsLM7OG\n", + "XGlUuLqsjutpAAAKMUlEQVQwM5uUKw1XF2ZmhQ13peHqwsysKcNZabi6MDNryfBVGq4uzMxaNjyV\n", + "hqsLM7O2DUel4erCzKwjpnal4erCzKyjpm6l4erCzKzjSqk0JD1P0mWSfi7pvyXNbHDsNEk3SlpS\n", + "8OSuLszMuqSs21OnAZdFxIuAy9N2PScDtwMx6Vmz6uKNVXuXEdHXFZWkkbJjaNUgxw6Ov2yOf/CU\n", + "lTQWABenxxcDf1nrIEk7A/OBCwA1PONgVxcjZQfQhpGyA2jTSNkBtGmk7ADaNFJ2AG0aKTuAXisr\n", + "aWwXEQ+nxw8D29U57rPAPwHrmzx/31cXZmaDqGsXVkmXAdvXeOrD+Y2ICGVVQvXr3wj8KiJubKIE\n", + "XOdkYWbWPYqYvKmg428qrQJGIuIhSTsAV0TEi6uO+STwVmAtsAWwNfCdiDi2xvl6/02YmU0BEdH4\n", + "1n+VspLGWcBjEXGmpNOAmRFRtzFc0oHAKRHxpp4FaWZmE5TVpvFp4A2Sfg78WdpG0o6SfljnNa4m\n", + "zMxKVkqlYWZmg2kgpxHp6uDAHigSv6TZkq6QdJukWyWdVEasuXjmSVol6U5Jp9Y5ZlF6/iZJ+/Q6\n", + "xkYmi1/SMSnumyVdI2nvMuKsp8jPPx33SklrJR3ey/gmU/D3ZyT9rd4qabTHIdZV4HdnlqSlklak\n", + "2I8vIcy6JH1J0sOSbmlwTPG/3YgYuC/gLOCf0+NTgU83OPb9wFeBxWXH3Uz8ZD3P/jQ9fi5wB7Bn\n", + "SfFOA1YDuwLTgRXVsZCNp7k0PX4V8NOyf85Nxv9qYJv0eN6gxZ877sfAD4C/LjvuJn/+M4HbgJ3T\n", + "9qyy424i9oXApypxA48Bm5Ydey6+1wL7ALfUeb6pv92BrDToxuDA3po0/oh4KCJWpMdPASuBHXsW\n", + "4Xj7Aqsj4t6IGAMuAQ6rOmbD9xQR1wMzJdUbf9Nrk8YfEddFxG/T5vXAzj2OsZEiP3+AE4FvA4/0\n", + "MrgCisT/FrLekfcDRMSjPY6xniKxP0jWu5P072MRsbaHMTYUEVcDv2lwSFN/u4OaNLo9OLDbisYP\n", + "gKRdyT4pXN/dsOraCbgvt31/2jfZMf1y4S0Sf947gEu7GlFzJo1f0k5kF7Nz065+aqws8vPfHXhe\n", + "uiW7XNJbexZdY0ViPx/YS9IDwE1kUx8Nkqb+dvt2IFxJgwM7pt34c+d5Ltmnx5NTxVGGoheg6mqu\n", + "Xy5cheOQ9Hrg7cD+3QunaUXi/xxwWvp9Ev1VWReJfzrwMuAgYAZwnaSfRsSdXY1sckVi/xCwIiJG\n", + "JM0BLpP00oh4ssuxdVLhv92+TRoR8YZ6z6VGne1j4+DAX9U47DXAAknzSYMDJf1H1Bgc2A0diB9J\n", + "04HvAF+JiP/sUqhFrAFm57Znk30aaXTMzmlfPygSP6nx+3xgXkQ0Kud7rUj8LwcuyfIFs4BDJY1F\n", + "xOLehNhQkfjvAx6NiGeBZyVdBbwUKDtpFIn9NcC/AkTEXZLuAfYAlvckwvY19bc7qLenFgPHpcfH\n", + "ARMuqBHxoYiYHREvBI4CftyrhFHApPGnT4sXArdHxOd6GFsty4HdJe0qaTPgSLLvIW8xcCyApP2A\n", + "x3O34Mo2afySdgG+C/xtRKwuIcZGJo0/InaLiBem3/dvA+/pk4QBxX5/vg8ckHo7ziBrkL29x3HW\n", + "UiT2VcDBAKktYA/g7p5G2Z7m/nbLbtlvsTfA84D/AX4O/DfZiHLIGop/WOP4A+mv3lOTxg8cQNYW\n", + "swK4MX3NKzHmQ8l6cK0GPpj2vQt4V+6Yz6fnbwJeVvbPuZn4yTpLPJb7Wd9QdszN/vxzx14EHF52\n", + "zC38/pxC1oPqFuCksmNu4ndnFrAk/d7fAryl7Jir4v868ADwB7KK7u3t/O16cJ+ZmRU2qLenzMys\n", + "BE4aZmZWmJOGmZkV5qRhZmaFOWmYmVlhThpmZlaYk4ZZIukbaRqIds6xuaSrJHX9bytNJb4kPX7T\n", + "JFOmbyPpPbntHSV9q9sx2tTjpGEGSJoLPCci7mrnPBHxe+Bq6sy8XDCWpv8uI2JJRJzZ4JBtgffm\n", + "jn8gIo5oJT4bbk4a1nfSlA2rJF0k6Q5JX5X052lxpJ9LemU67jlpgZnrJf2vpAW5118l6Wfp69Vp\n", + "/4ikUUnfkrRS0ldyb3sUaXoISS9I7/N8SZtIulrSwVUxvk3SZ3PbfyfpM2lzMXB0g+/rK5JuT3Fs\n", + "mZ67V9KnJf0MOCJ9v9em+L8p6TnpuHkp9p8Bf5U79/GSzkmPt5P0PWWLAq1I3/+ngTnKFjk6M32P\n", + "t6bjt0g/65vTz3Ekd87vSvqv9PNolJRsWJQ9xN1f/qr+IlvwZgzYi2z2zeXAhem5BcD30uNPAsek\n", + "xzPJpnqYAWwJbJ727w4sS49HgMfJpmsRcC2wf3ruv8hNn0A2Pfo3yabWP7dGjM8hm3ZhWtq+Btgr\n", + "Pd4cWFPn+1oPvDptXwh8ID2+BzglPZ4FXAlsmbZPBT5CNvHmL4E5af83SNPjAMcD5+T2n5Qeb0K2\n", + "xsMLyC3Ck2K5JT3+AHBBerwH8Iv0PRwP3AVslbbvBXYq+/fDX+V+udKwfnVPRNwWEUE2H9H/pP23\n", + "kl3wAP4cOE3SjcAVZBe22cBmwAWSbia78O+ZO+8Nkd2aCbJ5vV6Q9r+AbDEdACLiQmAbsjl6TqkO\n", + "LiKeJlsl702SXgxMj4jb0nO/BzaRtEWN7+u+iLguPf4K2RxjFd9I/+4HvAS4Nn1vxwK7kF3Q74mN\n", + "t9C+Qu0p0F9PWlcjItZHxBN1jqvYP52LiLiDLGm8iGx67Msj4sn0Pd3Oxp+9Dam+nRrdht7vc4/X\n", + "k022Vnmc/709PKrWXJC0EHgwIt4qaRrwuzrnXVd1rg0X1jTT6s5kF86tgKdrxHgB2fooK4EvVT0n\n", + "aq9JEA2Oyb/HZRHxlnEnlF5a4z3qaXY9jXrHV/+8pjV5XptiXGnYIPsRcFJlQ9I+6eHWwEPp8bEU\n", + "u9D9Atght30m8GXgdLI1NirvcbmkHQEi4gayxPIWsplEK8dsDqxLn86r7ZKmnya97uoax1wP7F/p\n", + "yZXabnYnm4J7V0m7peMmtJsklwPvSa+dJmlr4Emy5FfL1cAx6fgXkVU1q6idSPppcScrgZOG9avq\n", + "T+lR4/HHgempAfdW4Iy0/wvAcZJWkN3SearGa6v9BHgFgKQDyRY1OjMivgb8QdJxqVfTHLIp1Cu+\n", + "CfwkNq4vDtnSvNdR2x3A+yTdTnb7a8LyrBHxCFl7wtcl3UTW9rJHSkJ/D/wwNYQ/nHtd5B6fDLw+\n", + "3Z5bDuwZEY8B10i6JTVo54//AtnttJvJ1sA+LrL1sPPHbAivzvdlQ8JTo5sB6dP7ORHxFw2O2Qt4\n", + "W0Scktu3BPhMRFyR2/dJssb371W9fldgSUT8SYfDN+sZVxpmQETcDTzZaHBfapg/BUDSTEl3AM9U\n", + "JYzNyRq36y3P609pNtBcaZiZWWGuNMzMrDAnDTMzK8xJw8zMCnPSMDOzwpw0zMysMCcNMzMr7P8D\n", + "4kiXLbZ2HmUAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -516,9 +1144,18 @@ "\n", "from explauto.sensorimotor_model import sensorimotor_models\n", "from explauto import SensorimotorModel\n", + "from explauto.utils import rand_bounds\n", + "\n", + "#################\n", + "# FORWARD MODELS#\n", + "#################\n", + "\n", + "# ****\n", + "# *NN*\n", + "# ****\n", "\n", "#Creation of the dataset\n", - "random_motors = environment.random_motors(n=10000)\n", + "random_motors = environment.random_motors(n=1000)\n", " \n", "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", "model = sm_cls(environment.conf, **sm_configs['default'])\n", @@ -532,19 +1169,32 @@ "test = environment.random_motors(n=50)\n", "distance = []\n", "timer = []\n", + "pred_eff = []\n", "\n", "for mTest in test :\n", " start = time.time()\n", " sTest_pred = model.forward_prediction(mTest)\n", " end = time.time()\n", " sTest_eff = environment.compute_sensori_effect(mTest)\n", + " pred_eff.append([np.mean(sTest_pred),np.mean(sTest_eff)])\n", " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", " timer.append(end - start)\n", "# Distance between the predictive and effectiv value\n", - "comparison = {}\n", - "comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + "fwd_comparison = {}\n", + "fwd_comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", " np.mean(timer), np.std(timer), max(timer)]\n", - "#print comparison['NN']\n", + "figure(1)\n", + "for i in pred_eff:\n", + " plot(i[0], i[1], 'ok')\n", + " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", + "title(\"Fwd NN\")\n", + "xlabel(\"mean(x,y) prediction\")\n", + "ylabel(\"mean(x,y) effective\")\n", + "\n", + "\n", + "# *****\n", + "# *WNN*\n", + "# *****\n", "\n", "#Creation of the dataset\n", "random_motors = environment.random_motors(n=10000)\n", @@ -559,19 +1209,33 @@ "test = environment.random_motors(n=50)\n", "distance = []\n", "timer = []\n", + "pred_eff = []\n", "\n", "for mTest in test :\n", " start = time.time()\n", " sTest_pred = model.forward_prediction(mTest)\n", " end = time.time()\n", - " sTest_eff = environment.compute_sensori_effect(mTest)\n", + " sTest_eff = environment.compute_sensori_effect(mTest) \n", + " pred_eff.append([np.mean(sTest_pred),np.mean(sTest_eff)])\n", " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", " timer.append(end - start)\n", "\n", "# Distance between the predictive and effectiv value\n", - "comparison['WNN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + "inv_comparison['WNN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", " np.mean(timer), np.std(timer), max(timer)]\n", - "#print comparison['NN']\n", + "figure(2)\n", + "for i in pred_eff:\n", + " plot(i[0], i[1], 'ok')\n", + " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", + "title(\"Fwd WNN\")\n", + "xlabel(\"mean(x,y) prediction\")\n", + "ylabel(\"mean(x,y) effective\")\n", + "\n", + "\n", + "#******\n", + "#*LWLR*\n", + "#******\n", + "\n", "#Creation of the dataset\n", "random_motors = environment.random_motors(n=10000)\n", " \n", @@ -581,33 +1245,148 @@ "for m in random_motors:\n", " s = environment.compute_sensori_effect(m)\n", " model.update(m, s)\n", + " \n", "#Test of the model\n", "test = environment.random_motors(n=50)\n", "distance = []\n", "timer = []\n", + "pred_eff = []\n", "\n", "for mTest in test :\n", " start = time.time()\n", " sTest_pred = model.forward_prediction(mTest)\n", " end = time.time()\n", " sTest_eff = environment.compute_sensori_effect(mTest)\n", + " pred_eff.append([np.mean(sTest_pred),np.mean(sTest_eff)])\n", " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", " timer.append(end - start)\n", " \n", "# Distance between the predictive and effectiv value\n", "comparison['LWLR'] = [np.mean(distance), np.std(distance) ,max(distance),\n", " np.mean(timer), np.std(timer), max(timer)]\n", - "#print comparison['NN']\n", - "\n", - "for i in range(0, 6) :\n", - " for c in comparison.keys():\n", - " print c, i, comparison[c][i],\n", - " print '\\n'\n", - " \n", - "#print comparison['NN']\n", - "#print comparison['WNN']\n", - "#print comparison['LWLR']\n", - "\n" + "figure(3)\n", + "for i in pred_eff:\n", + " plot(i[0], i[1], 'ok')\n", + " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", + "title(\"Fwd LWLR\")\n", + "xlabel(\"mean(x,y) prediction\")\n", + "ylabel(\"mean(x,y) effective\")" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "angles and lengths must be the same size!", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 15\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mm\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrandom_sensors\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 16\u001b[1;33m \u001b[0ms\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompute_sensori_effect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 17\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ms\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/environment/simple_arm/simple_arm.pyc\u001b[0m in \u001b[0;36mcompute_sensori_effect\u001b[1;34m(self, joint_pos_env)\u001b[0m\n\u001b[0;32m 62\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 63\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mcompute_sensori_effect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mjoint_pos_env\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 64\u001b[1;33m \u001b[0mhand_pos\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mforward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mjoint_pos_env\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlengths\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 65\u001b[0m \u001b[0mhand_pos\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnoise\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mhand_pos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 66\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mhand_pos\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/environment/simple_arm/simple_arm.pyc\u001b[0m in \u001b[0;36mforward\u001b[1;34m(angles, lengths)\u001b[0m\n\u001b[0;32m 16\u001b[0m \u001b[1;33m.\u001b[0m\u001b[1;33m.\u001b[0m \u001b[0mwarning\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mangles\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mlengths\u001b[0m \u001b[0mshould\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mthe\u001b[0m \u001b[0msame\u001b[0m \u001b[0msize\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 17\u001b[0m \"\"\"\n\u001b[1;32m---> 18\u001b[1;33m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mjoint_positions\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mangles\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 19\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/environment/simple_arm/simple_arm.pyc\u001b[0m in \u001b[0;36mjoint_positions\u001b[1;34m(angles, lengths)\u001b[0m\n\u001b[0;32m 32\u001b[0m \"\"\"\n\u001b[0;32m 33\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mangles\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlengths\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 34\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'angles and lengths must be the same size!'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 35\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 36\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mangles\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mValueError\u001b[0m: angles and lengths must be the same size!" + ] + } + ], + "source": [ + "#################\n", + "# INVERSE MODELS#\n", + "#################\n", + "\n", + "# ****\n", + "# *NN*\n", + "# ****\n", + "\n", + "#Creation of the dataset\n", + "random_sensors = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=10000)\n", + " \n", + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])\n", + "\n", + "for m in random_sensors:\n", + " s = environment.compute_sensori_effect(m)\n", + " model.update(m, s)\n", + "\n", + "#Test of the model\n", + "test_cases = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=50)\n", + "distance = []\n", + "timer = []\n", + "goal_eff = []\n", + "\n", + "for s_g in test_cases :\n", + " start = time.time()\n", + " mTest = model.inverse_prediction(s_g)\n", + " end = time.time()\n", + " s_eff = environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([s_g,s_eff])[0])\n", + " goal_eff.append([np.mean(s_g),np.mean(s_eff)])\n", + " timer.append(end - start)\n", + " \n", + "# Distance between the predictive and effectiv value\n", + "inv_comparison = {} #to remove after the first use\n", + "inv_comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)]\n", + " \n", + "figure(1)\n", + "for i in goal_eff:\n", + " plot(i[0], i[1], 'ok')\n", + " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", + "title(\"Inv NN\")\n", + "xlabel(\"mean(x,y) goal\")\n", + "ylabel(\"mean(x,y) eff\")\n", + "\n", + "# *****\n", + "# *wNN*\n", + "# *****\n", + "\n", + "#Creation of the dataset\n", + "random_sensors = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=10000)\n", + " \n", + "sm_cls, sm_configs = sensorimotor_models['WNN']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])\n", + "\n", + "for s in random_sensors:\n", + " m = environment.compute_sensori_effect(m)\n", + " model.update(m, s)\n", + "\n", + "#Test of the model\n", + "test_cases = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=50)\n", + "distance = []\n", + "timer = []\n", + "goal_eff = []\n", + "\n", + "for s_g in test_cases :\n", + " start = time.time()\n", + " mTest = model.inverse_prediction(s_g)\n", + " end = time.time()\n", + " s_eff = environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([s_g,s_eff])[0])\n", + " goal_eff.append([np.mean(s_g),np.mean(s_eff)])\n", + " timer.append(end - start)\n", + " \n", + "# Distance between the predictive and effectiv value\n", + "inv_comparison = {} #to remove after the first use\n", + "inv_comparison['WNN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", + " np.mean(timer), np.std(timer), max(timer)]\n", + "\n", + "for m in random_motors:\n", + " s = environment.compute_sensori_effect(m)\n", + " model.update(m, s)\n", + " \n", + "figure(1)\n", + "for i in goal_eff:\n", + " plot(i[0], i[1], 'ok')\n", + " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", + "title(\"Inv NN\")\n", + "xlabel(\"mean(x,y) goal\")\n", + "ylabel(\"mean(x,y) eff\")" ] } ], From 2e60c3498791f77b496b88b15bb28899ccc03a23 Mon Sep 17 00:00:00 2001 From: Roxane Date: Thu, 11 Feb 2016 15:54:46 +0100 Subject: [PATCH 07/13] VO finished. Need feedback --- ...g_sensorimotor_models_non_parametric.ipynb | 8264 +++++++++++++++-- 1 file changed, 7270 insertions(+), 994 deletions(-) diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb index d2080b4..382d248 100644 --- a/notebook/comparing_sensorimotor_models_non_parametric.ipynb +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -14,21 +14,7 @@ "source": [ "In this notebook, we compare the different sensorimotor models used in explauto in order to help the reader to use the most appropriate model depending on his aim. The notebook is split in two parts : non parametrics models (this notebook) and models based on gaussian mixtures (coming soon). There is also a tutorial explaining how to use the [SensorimotorModel abstract class](http://flowersteam.github.io/explauto/explauto.sensorimotormodel.html#explauto.sensorimotor_model.sensorimotor_model.SensorimotorModel) ([learning_sensorimotor_models](http://nbviewer.ipython.org/github/flowersteam/explauto/blob/master/notebook/learning_sensorimotor_models.ipynb)).\n", "\n", - "As explained in the [Explauto introduction](http://flowersteam.github.io/explauto/about.html), an important challenge in Developmental Robotics is how robots can efficiently learn sensorimotor mappings by experience, i.e. the mappings between the motor actions they make and the sensory effects they produce. This can be a robot learning how arm movements make physical objects move, or how movements of a virtual vocal tract modulates vocalization sounds.\n", - "\n", - "Let's begin with defining a simple environment that will be used to test the sensorimotor models." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "from explauto import Environment\n", - "environment = Environment.from_configuration('simple_arm', 'low_dimensional')" + "As explained in the [Explauto introduction](http://flowersteam.github.io/explauto/about.html), an important challenge in Developmental Robotics is how robots can efficiently learn sensorimotor mappings by experience, i.e. the mappings between the motor actions they make and the sensory effects they produce. This can be a robot learning how arm movements make physical objects move, or how movements of a virtual vocal tract modulates vocalization sounds." ] }, { @@ -49,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 2, "metadata": { "collapsed": true }, @@ -64,20 +50,10 @@ "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", "\n", "from explauto import SensorimotorModel\n", + "from explauto.sensorimotor_model import sensorimotor_models\n", "from explauto.utils import rand_bounds" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Decision tree\n", - "\n", - "In order to use the most appropriate model, there are several questions that have to be asked before using the following decision tree. The following paragraphs focus on these questions.\n", - "\n", - "*Add the decision tree*" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -105,7 +81,6 @@ } ], "source": [ - "from explauto.sensorimotor_model import sensorimotor_models\n", "print 'Available sensorimotor models: {}'.format(sensorimotor_models.keys())" ] }, @@ -130,64 +105,47 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Changing models caracteristics (k, sigma, ...)\n", - "\n", - "Each model have its own caracteristics. In order to know what are they :" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'default': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio': 0.1, 'mode': 'explore'}, 'exact': {'fwd': 'NN', 'inv': 'NN', 'sigma_explo_ratio': 0.0, 'mode': 'exploit'}}\n" - ] - } - ], - "source": [ - "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor'] # or 'WNN', 'LWLR-BFGS' or 'LWLR-CAMES'\n", - "print sm_configs" + "### Creating models or changing their caracteristics (k, sigma, ...)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Then, it is possible to change its caracteristics like sigma exploration ratio for nearest neighbor models or the number $k$ of nearest neighbor in WNN models this way : " + "Then, it is possible to change its caracteristics like sigma exploration ratio for nearest neighbor models or the number $k$ of nearest neighbor in WNN models and so on. For instance, in order to create a model using LWLR forward model and Cobyla as inverse model : " ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 64, "metadata": { - "collapsed": true + "collapsed": false }, "outputs": [], "source": [ - "sm_configs['default']['sigma_explo_ratio'] = 0.4 #or any other value" + "from explauto.sensorimotor_model.non_parametric import NonParametric\n", + "custom_config = {'fwd': 'LWLR', 'inv': 'COBYLA', 'k': 10, 'maxfun' : 50}\n", + "sensorimotor_models['LWLR-COBYLA'] = {}\n", + "sensorimotor_models['LWLR-COBYLA'] = (NonParametric, {'default' : custom_config})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Whether changes are made or not :" + "Whether changes are made or not, in order to know the caracteristics of the different models:" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [], "source": [ + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "# or 'WNN', 'LWLR-BFGS', 'LWLR-CAMES', 'LWLR-COBYLA' (if the previous lines have been executed)\n", "model = sm_cls(environment.conf, **sm_configs['default'])" ] }, @@ -208,7 +166,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "metadata": { "collapsed": false }, @@ -221,27 +179,115 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Forward or inverse model ?\n", + "### Forward and inverse model distinction\n", "\n", "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. \n", "\n", - "For each of these models it is necessary to load the mode with the appropriate model chosen as explained earlier and then create a dataset of n $(m,s)$ couples which is going to be tested later:" + "For each of these models it is necessary to load the mode with the appropriate model chosen as explained earlier and then create a dataset of n $(m,s)$ couples which is going to be tested later." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 74, "metadata": { "collapsed": false }, "outputs": [], "source": [ "#Creation of the dataset\n", - "random_motors = environment.random_motors(n=1000)\n", + "def generateFwdDataset(_environment, _model, _n = 10000):\n", + " random_motors = _environment.random_motors(n=_n)\n", " \n", - "for m in random_motors:\n", - " s = environment.compute_sensori_effect(m)\n", - " model.update(m, s)" + " for m in random_motors:\n", + " s = _environment.compute_sensori_effect(m)\n", + " _model.update(m, s)\n", + " \n", + "# Distance between the predictive and effectiv value\n", + " \n", + "def generateFwdTest(_environment, _model, _n = 100):\n", + " #Test of the model\n", + " %pylab inline\n", + " test = _environment.random_motors(n=_n)\n", + " distance = []\n", + " timer = []\n", + " \n", + " \n", + " for mTest in test :\n", + " start = time.time()\n", + " sTest_pred = _model.forward_prediction(mTest)\n", + " end = time.time()\n", + " sTest_eff = _environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", + " timer.append(end - start)\n", + " figure(1)\n", + " plot(sTest_pred[0], sTest_eff[0], 'ok')\n", + " figure(2)\n", + " plot(sTest_pred[0], sTest_pred[1], 'or')\n", + " plot(sTest_eff[0], sTest_eff[1], 'ob')\n", + " plot([sTest_pred[0], sTest_eff[0]], [sTest_pred[1], sTest_eff[1]], '-g')\n", + " \n", + " figure(1)\n", + " axis([0,1,0,1])\n", + " plot([0,1], [0,1], 'r-', lw=2)\n", + " title(\"Fwd - Comparison between x of s effective and predicted\")\n", + " xlabel(\"x predicted\")\n", + " ylabel(\"x effective\")\n", + " \n", + " figure(2)\n", + " title(\"Fwd - Distance between effective and predicted\")\n", + " xlabel(\"x\")\n", + " xlabel(\"y\")\n", + " \n", + " return {'mean distance' : np.mean(distance), 'std distance': np.std(distance) ,'max distance' : max(distance),\n", + " 'mean time': np.mean(timer), 'std time': np.std(timer), 'max time': max(timer)}" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + " # Distance between the predictive and effectiv value\n", + " \n", + "def generateInvTest(_environment, _model, _n = 100):\n", + " #Test of the model\n", + " %pylab inline\n", + " test_cases = rand_bounds(np.array([[0,0], [1,1]]), n=_n)\n", + " distance = []\n", + " timer = []\n", + " \n", + " for sTest_goal in test_cases :\n", + " start = time.time()\n", + " mTest = _model.inverse_prediction(sTest_goal)\n", + " end = time.time()\n", + " sTest_eff = _environment.compute_sensori_effect(mTest)\n", + " distance.append(spatial.distance.pdist([sTest_goal,sTest_eff])[0])\n", + " timer.append(end - start)\n", + " figure(1)\n", + " plot(sTest_goal[0], sTest_eff[0], 'ok')\n", + " figure(2)\n", + " plot(sTest_goal[0], sTest_goal[1], 'or')\n", + " plot(sTest_eff[0], sTest_eff[1], 'ob')\n", + " plot([sTest_goal[0], sTest_eff[0]], [sTest_goal[1], sTest_eff[1]], '-g')\n", + " \n", + " figure(1)\n", + " axis([0,1,0,1])\n", + " plot([0,1], [0,1], 'r-', lw=2)\n", + " title(\"Inv - Comparison between x of s effective and predicted\")\n", + " xlabel(\"x goal\")\n", + " ylabel(\"x effective\")\n", + " \n", + " \n", + " figure(2)\n", + " title(\"Fwd - Distance between effective and predicted\")\n", + " xlabel(\"x\")\n", + " xlabel(\"y\")\n", + " \n", + " return {'mean distance' : np.mean(distance), 'std distance': np.std(distance) ,'max distance' : max(distance),\n", + " 'mean time': np.mean(timer), 'std time': np.std(timer), 'max time': max(timer)}" ] }, { @@ -250,12 +296,12 @@ "source": [ "### Forward models using guide\n", "\n", - "The predicted sensorimotor effect $s_p$ of a command $m$ depending on a given model can be obtained this way :" + "The predicted sensorimotor effect $s_p$ of a command $m$ depending on a given model can be obtained this way after defining the model: " ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": { "collapsed": true }, @@ -268,34 +314,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In order to test foward models, we are going to generate randomly n $m$ and use one of these models to find out $s_p$. The distance between $s_g$ and the time processing are weighted and saved in $comparison$ dictionary." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "#Test of the model\n", - "test = environment.random_motors(n=50)\n", - "distance = []\n", - "timer = []\n", - "\n", - "for mTest in test :\n", - " start = time.time()\n", - " sTest_pred = model.forward_prediction(mTest)\n", - " end = time.time()\n", - " sTest_goal = environment.compute_sensori_effect(mTest)\n", - " distance.append(spatial.distance.pdist([sTest_pred,sTest_goal])[0])\n", - " timer.append(end - start)\n", - " \n", - "# Distance between the predictive and effectiv value\n", - "fwd_comparison = {} #to remove after the first use\n", - "fwd_comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)] # or WNN, LWLR, ..." + "In order to test foward models, we are going to generate randomly n $m$ and use one of these models to find out $s_p$. The distance between $s_g$ and the real s plus the time processing are saved in $fwd_comparison$ dictionary." ] }, { @@ -311,6 +330,739 @@ "Let's see how to use it : " ] }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEZCAYAAACAZ8KHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXm8HVWV778rIUDCJBAFEgIoiTREoFEBFdAAPow0gkMj\n", + "DxGawQalIfHJU3AiEXCgbQfAbgRUUJBJxRbavKAfJUgDMiiTTC8JICEJaEgUNAETWP3H3uem7knV\n", + "OXXOPXWGqt/387mfe6pqV9WqXcPaa6+19jZ3RwghhMjLqF4LIIQQYrCQ4hBCCNESUhxCCCFaQopD\n", + "CCFES0hxCCGEaAkpDiGEEC0x8IrDzF42s9f0Wo6yYGZHmdmNXT7nE2Z2YDfPOYiY2VZm9isze87M\n", + "vlzgefYxs/lm9ryZHVrkec3sd2b21k4es9OY2TwzO6FH555tZpfH39vFe2JdOG/Dd7KriiMKszJe\n", + "/PPxQdy6wPPNM7NVZrZtYt3bzezxOpmeMbNxiXUfMrObRnjuD5jZ3fE6l5jZHDPbZyTH7Abu/n13\n", + "f0e3Txv/WibevwM6LE+/ciLwB3ff1N0/XuB5zgLOd/dN3P36Tp3XzC4zs7OT69z9de7+qxHKWzRt\n", + "P58dOnf44f5kvCcNZTGzaWa2qAPnzTxPty0OBw6JF79JfBCfLvicfwU+26TMKGBmp05oZh8Dvgac\n", + "A7wKmAT8O3Bop85RBGY2utcytIEDhbfA+oTtgYe7cJ7tgId6cN5SY2br9VqGjuHuXfsDHgcOSFn/\n", + "XeBj8fdE4GXg5Li8I/BsouzHgSXAU8DxsexrMs53E3Am8FytDPB24PE6mU4HngU2i+s+BNzU5jVu\n", + "BjwPvK9BmQ2ArwOL49/XgPXjtmnx2j4O/CFe67uBg4H/H+U8I3Gs2cAPgavjdf4G2C2x/QxgQdz2\n", + "IPDuxLZjgVuBrwLLgLPjulvidouyPQP8GbgfmJq4zu9FGZ8APg1Y4rj/DXwZWA48Bkxv8lycEeVb\n", + "DnwH2CCx/RDgXmBFlHfXuP5y4CVgZazzjwOXtfAspR43bpsA/Che32PAqXV1fi3huX0O+B3whoxr\n", + "ewvwR2DbuLx7vMbXNih/F/An4E7gzXH9ZcDfgBfjtaa9RwfHOnyO8Ayd1qDOjycoh+XAXGC7uH5h\n", + "XZ1eWX/e+FzUnqtlwDXA5olj7wvcFuv1SeCfgH+uO85PYtkn4jEnxHMmj7NHrLvRjWTOuL4fAEtj\n", + "Pd4M7JLYdhmhIfdfsa5+TeIbAvwv4JG47wXAPOCEjPPMpvH79wTwCcK7s4rQSH1Ton7uBd6WKP/q\n", + "KO9zwM/i+S+P23YgPM+j4vIWwKWEb8hy4DpgXDzPS7GenwO2znHPjgZ+H7d9ioxv9VD5dj6O7f5F\n", + "YQ5MWX8ccH38/YF4cVcnHpYfx9/TgaeBXWIFXUlzxXEC8JVE5acpjgMJH4mz47qRKI7pwOrazc0o\n", + "c1Z8cMbHv1uBs+K2aXH/zwCjoyzLgO8DG8VrXwlsn3hw/wa8N5Y/jfChq71s/whsHX+/H/gLsFVc\n", + "Pjae61/iA70hwxXHO4C7gU3j8k6JY30P+HGUaXvgUeD4xHH/FuvegA8DixvUxxOEF2sisDlB6dTu\n", + "xR4ExbVnPNYx8Z6NSdy/AxLHyvssZR431sVv4j1Yj/AyLwQOStT5qnivDfgCcHuD6zsH+AUwFniA\n", + "qMhSym1B+JgcFWX434QPwuZx+6XE5yRj/6XAPvH3ZsAeGeUOA+bH+zmKoPRvrXsnknU67LwE6/w2\n", + "wsd+DPBN4Mq4bXvCx+oIwvO4BbB7lvzJc8U6+lBi25eB/8gjc8o1Hkt4NscQGj/3JLZdRnin3hhl\n", + "vAK4Km4bH+WvvU8fJbwjx2ecZzaN378ngN8Snu0N4v9lxIYU4Xu0DNgyLt8O/FuUe78oy/fith0Y\n", + "rjh+ClwV7/V6wH5x/duARXVyNrpnuxCUzL7A+oTv5Wr6SHE8EQVcEf+ui+t3JLwgBlxI6FNdFLd9\n", + "F/ho/P0d4AuJ402hueI4Pj4Mf4oVlKY4DgCmxjLjGZniOApY2qTMAhItcOCgmkwExbGSta33TeI1\n", + "7pkofzdwaOLBvS2xzQhWyr4Z574nse+xwO9TXria4jiAoBD2JqEICS/Ii8DfJdadWKuzeIz5iW3j\n", + "4jW8KkOmx4ETE8vvBBbE3xey7sfmEda+JPUfubzPUtZx3xqvt75ePgl8J1HnP0ts2wVY2eB+rxfv\n", + "2QPAnAbljgZ+XbfuNuCf4u9LiQo1Y//fx+vdtMnz9/9IfAgJH+K/ApMy6nTYeQmt/uT2bQgfz9Gx\n", + "nn6Ucd515Ge44jgB+EXiOX6y9hw3k7nJ9b4iPn+bJOS4uO55ezj+PobE+xTXLaKx4kh7//ZJXN+x\n", + "ie2nExVBYt3ceN7tCB/ssYlt3yfF4oh1/hKxl6TueNNYV3E0umdnEpVI4n19kQaKoxc+jsPcffP4\n", + "914Ad19IeAj+nqBl/wtYYmavJbzIN8f9tyHcxBpP5jqp+zLgG4SWvmeUeTCe94ysMgBm9s2Ec/+M\n", + "lCLPAuPNrFHdTiC85DWejOuGjuHxDhJathBaxyTWbZxYfipxHR6Xt4nyHmNm95jZCjNbAbwO2DKx\n", + "b6YTzd1/Sai3fweeMbOLzGwTgnIdk3INExPLTyeOszL+TMpcT/19rdXH9sBpNfnjNWzL8PpKypz3\n", + "Wco67jZx24S6bZ8k+KtqJO/HSmDDrHvu7msISmsqoTWXxQTWfaZ/n3WtKbyP0F31RAwMeVNGue2B\n", + "8xLX9mxcPzGjfD07AD9O7P8QsAbYilCHj+U8Tj3XAW+OATNvBV529/9uVWYzG2VmXzKzBWb2Z8LH\n", + "G8JzWyPrfZpA4n2KNHM0p71/yXuW3H974PC6Z2sfQnfSBGCFu69KlE++Y0kmAcvd/c9NZKuxA9n3\n", + "bJu6a1jJ2vpNpZ/CcW8GDid0QSyJy8cSui7ujWWWErRyjeTvZnwZ2B94Q4Myswh9sZkvkLt/2Nc6\n", + "97+UUuR2grZ+T4PzLCHcyBrbxXXtMqn2I368tiV8LLcHLiZ0RW3h7psT+uOTzuRMJQng7he4+xsJ\n", + "rerXEvwIfyS0jOqvof6Fa4X6+7o4/n4S+HyisbG5u2/s7tc0kD/Ps9TouE8SLMDktk3d/ZAG58zE\n", + "zCYSWnXfAb5qZutnFF1M+LAk2Z61ddEQd7/b3d8NvBL4T4IfJo0nCRZe8vo2cvdf5zlP3H963f7j\n", + "Yl0vIlh9qSI2kX8FoV//CEI341VtynwUIRDlQHffjNDVCPmCKJYw/H2y5HIGqe9f8tLqruPyuuvY\n", + "xN3/lfB92zwZ4Um4/2n1tgjYwsw2S9mWVr7RPVtadw3jGN64XId+UxynALXQvHlx+ZZE6/ta4Fgz\n", + "2zle3KwcxzWAqJm/QjAVU4mt1WsYQYRVPM+ZwL+b2WFmNs7MxpjZO83s3FjsKuAzZjbezMbH8pe3\n", + "e07gDWb2nhi18VHgBYLDbyPCQ7QMGGVmxxEsjlyY2RvNbG8zG0NoVb8AvOTuLxPuxefNbOOooP4P\n", + "oa+4HQz4FzObaGZbEPqva4rhEuDDZraXBTYys38ws1oL8RnW/VDleZYaHfdO4Hkz+4SZjTWz0Wb2\n", + "OjN7Y0LefBcWPjyXAd9y9w8RXtKzM4rPAV5rZkea2XpmdgTwdwSrqeF54zN2lJlt5u41x+hLGcW/\n", + "CXzKzHaJ+25mZoc3uoyU/b9gZtvF/V9pZrWIwe8Dbzezw+M1bGlmu8dtzwDNcq6uJDjT3xd/tyPz\n", + "xoTG23Iz24jgg2p0PUnmAFMT79MMgjXQiKz3L40rgHeZ2UHxudowhs9OdPffE7o0Pxfv576EAI51\n", + "cPelhO67/zCzV8TytXyYZ4AtzWzTxC6N7tkPgUMs5O+sT+iZaagb+klx/Ipww2sv+60EZ+JQjLe7\n", + "zyVEI/2SEGH0C5q3/pLbzyOYZ432OYvQx9dSq3LYCd2/CnyM4Fz9A0Hbn0xwJkNwlt5NcAjfH3+f\n", + "kyFz2nL9tp8QWmnLCa2t97r7S+7+EEFZ3k7oOnodwfGc3DftXLV1mxIsluUE/9QyguUGcCqhS+gx\n", + "4BbCB+PSJsdtdA3fJ7Q2FxKcoOcAuPtvCFbgN6Ic8wn9wTW+SFDCKyyEQUO+ZynzuFExHkLo7nqM\n", + "YGFdHOuj1eubQegiqYWEHwccZyk5Pe6+PJ73NEJd/19C+PryBudN8kHg8dg9cyLhWVgHd/9P4Fzg\n", + "6lj2AUIgRBb15z0PuB74mZk9R3i+9orHXkToLjuN0N1xD7Bb3O/bwC7xXl2Xca7rgckEP+EDbcr8\n", + "PUIXz2KChX17nfyZ9y92ax8OfIlwDyYz/J2pJ/P9Sy3s/hTB0f8p1n4bTmPtt/gDBB/bckKD8rtp\n", + "ckaOJlj+jxCUxYx4jkcIjdPHzGx57PprdM8eIvRKXEmwlJbTpHvO1jbAOo+ZfQf4B0Ly0K4ZZc4n\n", + "OKdWEpxI9xQmUAkxs1nAZHc/uteyCFE1qvr+FW1xXEoIWUzFzA4mVPoUQgvpwoLlKSNVSX4Toh+p\n", + "5PtXqOJw91sIYbdZHEo0xdz9DuAVZrZVkTKVkGbdF0KI4qjk+9frFPiJDO9Le4oQkfBMenFRj7t/\n", + "rtcyCFFVqvr+9YNzvN7Uq5z2FkKIQaLXFsdihsdIb0tKzLqZSZkIIUQbuHvH/TC9VhzXE+Lrr7aQ\n", + "5fond0/tpiri4gcRM5vt7rN7LUc/oLpYi+piLZWsC7MphATTfeOaK4CZ1iQDvF0KVRxmdhVhwK3x\n", + "FsaHn0UYqgJ3v8jd55jZwWa2gJATcFyR8gghxCARI09nEAYgfYEwT8qcRIFRcfsXCLlKTwMnEeZR\n", + "gYLmfCpUcbj7kTnKnFKkDEIIMYhEpXEeIQmxxo5mhrvPybIyWJswWhi97qoSrTOv1wL0EfN6LUAf\n", + "Ma/XAvQR83otQIeYwXClATB5FJxKGLQz3croAoVmjncKM3P5OIQQ/UjT7qT2jzuP0NU/xGTgWvjz\n", + "HmEODmhiZRT17ZTFIYQQbdK0O2lkvDB0HtY6MsYFpdF1KyNJP+RxCCHEoJLanUQYBHSknA8smEwY\n", + "7vnrhNFX54dBXqf2SmmAFIcQooLEaM65Fia8mhsth3bYMGP92HZlq+Ew90b45QPw8n7As/DixXDW\n", + "FPcDu+EAb4S6qoQQlaLD3UsvZKxflbE+n08kRkwdlIiY2hJmnthjhVFDikMIUTUadS+1qjjOJ0wk\n", + "ljzeQuCCtMIZSms/M1sILFkfLngRptDDiKk8SHEIIapGx7qXYhIzBKUzkTB/90pgRs2CqbMwpjJ8\n", + "7nMIrotdJ8Ou3w9RVDX5upaX0SpSHEKIqpHVvTQ1hsC2FFKbUB7nEZTCeGBXQvfXnoSZGestnCHq\n", + "IqY2fBZe3BLe329WRhLlcQghKkVGd9Fq4nBIkQXAzLzKw8zmkj6V7TLWtTCGmExI/d4vLl8OfBxu\n", + "fdp936x9WkF5HEII0QHqupfGkt591KrPI6v7a0zayjorg6XAScANYfPzOc/ZM6Q4hBCVI1oScwDM\n", + "7H7SrYKJLRwyq/trdf2KycB34aW3wGgIVsZMhqZKzXSs9xPK4xBClJac+RrbZOyetT6N8wndW0kW\n", + "At8gGBQYQUHcB7wFRv8R1hwFC4+Bu1eEHL+5wIxODFdSNLI4hBClpIV8jaWkWxxL854rpftrFXBB\n", + "XP+uybBNvS9jJqy3IoTyLgBmDYLCqCHnuBCilDRwWM9193e2Wi6WbW1AQ7NRn4WnPgnbpPgykiwH\n", + "7mp6vBaRc1wIIVojb75GriS+ljPOY/b32bHLq86XUc8WBOXVqQESC0WKQwgxkORo/ecaDqRRN1Pd\n", + "fvkyzutm5fsjrDkB1kuxMtJoN4O9q0hxCCEGjpyt/9zDgSSjrBqQacHUlNhusPn3YMrusHncdsVu\n", + "MOFpOKDJsYcdr4WyPUGKQwgxiDRt/bdgSWSSMlxIGhNHwQ9OhXG1vIw/wEv/CZ8/0X3W0+EYb4qb\n", + "8pA5QGK/IMUhhBhEcvkvcloSqd1ecVOzDPOlU2DSt2GDuoip0StgrxMZUmALCcOQNGMg8jikOIQQ\n", + "g0jLw5lnkdXtBTzHulbNGMIwIg+OglWfhqlnwAYZEVNJJbaExorjZeAxWhjmpJcoAVAIMYhkJdy1\n", + "01rP6vbaIaP8gw7//BJsfBZMGkewMqayTphtUomlyZvMhRiob7EsDiHEwNEJ/0WCrG6vdfIfDDgb\n", + "XkVIAB/7LLx4HGyQEjH1MvBKMzvY3ecUND5Wz1ACoBCi0jRIALwbeAXRGpkMXAEv7J2YL2NPuOFu\n", + "+DzZw6anjrIbh29/W0r5m919WssXkUFR386BMo+EEKIAsrq9ZgEzR8Hcz8HCB+DlqDSeBg7D/ei7\n", + "3K8l5PXNJT23r2ZF1LNxhix9H1EF6qoSQlScht1eIft7Y4KzHBKz8qVEYj3F2vyNJMMiveJ+E1LK\n", + "LWUAIqpAikMIIdYN2zUbhdlHyZj7OyMSa2XG4eutiBmkj7y7ZBAiqkCKQwghhhPHmAJqs/Clzf2d\n", + "Fok1jqA8kol+aZFeWc74v7Qlbw+Q4hBCDCx5RqvNPaJt3RhT1FkZdWR9/BcCi2kc6dWxHJReIcUh\n", + "hBhIGo1XFZlB8CXsyHAr4K1m9hBw5tBHPZ+VkSTr47+4fij2FHKPodWvKBxXCDGQ5A2jbcCC9eGj\n", + "L8IU8lkZyXOnKa2F5JzBL+7fiRyUZucp5NspxSGEGEga5EKsID26aRiTgR/CiuRItjS2MurP35WP\n", + "/0jQRE5CCDGcrO6ihq1hY60jY1xQGrmsjHVOknMAxTKiBEAhxKCSlbj3RNYOk4Gbga8TnB5zwuCD\n", + "U9OUhpkdbGZzzWxe/H9wxyQfcGRxCCEGkqzEvbh5mP9hFLw4E0afA+vVRrL9KCy9Fv7ZU7qmWp4m\n", + "tmLIxyGE6Bh1oa8bE3qGnqdRGGxxcpwKjP17sBthy1fFiZhugGdOhN89DV/NkqeB431ujqipvmEg\n", + "fRxmNp1gFY4GvuXu59ZtH09wSG0dZfk3d7+sSJmEEMWQ0UpP0laLPSsPI7F+AiETeymh6+n8OFzI\n", + "XFLyMt7lfv3S5qfNNVFUVSnM4jCz0cCjwNsJCTF3AUe6+8OJMrOBDdz9k1GJPAps5e5r6o4li0OI\n", + "PqdBKz1JSy32DGW0gNDg/CDpSmrlNPjWTfB68udl1J9XFkcDinSO7wUscPcn3H01cDVwWF2ZpcCm\n", + "8femwLP1SkMIMTBktdKTtNpiz5pk6ZSU9RgwE8b9NOy3L4mRbPMqjUgnJ4oqHUV2VU0EFiWWnwL2\n", + "ritzCfBLM1sCbAK8v0B5hBDFkhUem6TVYTWylNGY+hWTCanftbm/58CSg2HXFhUG0PGJolLJPRRK\n", + "H1Kk4sjTB/Yp4F53n2ZmOwI/N7Pd3f35+oKxW6vGPHef1xkxhRAdIm0ojSTttNizlNHq2o+6vIzk\n", + "3N/z0yKm8lJknkZRUVtmNg2YNjLpmlOk4lgMTEosTyJYHUneQpg9C3dfaGaPAzsRhgwYhrvPLkZM\n", + "IUQnSGmlb0T4rv+F9lvsWeM6XQ6cPhnGJq2MywmzKsUZlfp50MCsLrgRTR0bG9TzastmNqvdYzWi\n", + "SMVxNzDFzHYgRDocARxZV+YRgvP8VjPbiqA0HitQJiFEgXS6lZ7ZZQRzz4QPnQHb1lkZNfrWHxGt\n", + "jb0yNg9E1FZhisPd15jZKcCNhHDcb7v7w2Z2Utx+EcG6vNTM7iM46j8xEtNSCJGPQepfT5lkaQpw\n", + "81mwLaRaGQ8Cs/rxehJdVFljafWzlTSEEgCFqBgNQlxn9uPHdoiU+TIuhotPCq33dRzY/agcm4Qs\n", + "5x5dt4XzaXTcXsshRBloJ0eh5x/hFufL6Ffl2GBE3+XA0Z2WbRDzOIQQ/UlLWdGJj/A7CB+9dwDn\n", + "dWXQv7Vzf98H7PsCrDgOfmswyeDKBjI0cj73kqwosTt7bQ21ggY5FKJ6tDp1aSERQE2pszLmwy/f\n", + "AjssCxnhNbJCWPt1yJCBn/0PZHEIUUVuB1bWrWv08eruR7jOyiBmf78WVi+D19SVzrIi+nJe76jg\n", + "ZgJzCSO8z6XDfo1uIItDiAoRu3Y+yPA5uFcClzf4eHXvI1xnZVwHfzoRxjwL5xCjqFJIU2Bdb9nn\n", + "9QOVYQIoKQ4hqkVat9M44E0N9in+I1wXMfUHeOlDMPqGMHc4wJYN9l5HgXVjyJAkVZu/Q4pDiGrR\n", + "crdT4R/hOivjp7DkaJiwIt/emQqsyy373viBeoQUhxDVoq1up0I+wil5GcBJh8DHCHNsZLEceIAw\n", + "URTAJ8xsBr3N0+hXZ3whSHEIUS36I6qnUV6G2clN9r6TIG8/dQ31pTO+KKQ4hKgQ3e77X4cMKwP3\n", + "6xOlGo2yW1Ny/dY11B8KuUsoc1wI0R1ayP5OzBk+kbXTwi4mKrkGGdg3u/u0zgvfnOQ853RbIWfL\n", + "pCFHei2HEKIN8lkZLR5yZFO79nwIlS5R1LdTXVVCiOJocYypFmi7a6hqobNFIItDCJGLllrpBVgZ\n", + "GfK03DU0UmtlkJDFIYToGS210ouzMoYxghDhSoXOFoEUhxAiD82jmFq0MtIsmMS5ivQ9VCp0tgik\n", + "OIQQeWjcSu/MfBm7Ac7w5L9hVs1InNqJfScQxudKjtdV2tDZIpDiEKJHDFhkT2orfRSsiiPZturL\n", + "SLNgtkkpN2TVtOrUrqvfTYCtGa6UVhIUxlCYbxOZ12HA7mHHkOIQogcMYGTPOlFMO8OT82AS8LW4\n", + "qhVfRpYFk0bN95A76S+jfusZByxu1yE+gPewY2g+DiF6Q7/OUJdKch6JUXDzOfDwA7DVq2Aqcb4M\n", + "3I/GfbmZHWxmc81sXvyfNktflp8hjZrvoRWndlr95t03LwN1DzuJLA4hesPARfa4+xzM5hN8GTvH\n", + "1cOsjBZa4Wl5GEtZ18eR9D204tTOa9GMxCE+cPewU0hxCDFC2uznHqzInvwRU7m6k7LGzIqbs3Iz\n", + "Wkn6y2PRjNQhPlj3sINIcQgxAkbQzz04g+K1FjGVuxXeIA8jtd5aHKAxy6JZDPy1yb55GZx72GGk\n", + "OIQYGW2N0trzUWrz0F72d6Gt8LxJf92o34G4hwWhIUeEGAH9OEprR2gz+zvDAlsIzKjCB7Xf0JAj\n", + "QvQn5ernHuEYU1VuhVcJWRyiY1QxGarbLexC67hLY0yJ7iGLQ/Q1VU2G6mYLu7A67sJItqJcyOIQ\n", + "HaFKQ1X3ilbrOJd1Iiuj1MjiEP1OZZOhukjuOm5mnWxg9g9nwr+dBq/dEEa9ACs2hGNlZTSnil2y\n", + "9UhxiE5RLidxf9JKHWeGCf+T2YRb4IK9oiK6HPgYrFgGa/q//6G3VLVLth6NVSU6xfnAgrp1lUiG\n", + "6iKt1PE61okBn4MpF8FFe8GGS4FDgWOAZfAaKjDGUgeo7PhUSWRxiI6gMMziabGOh1knkwmOjP1C\n", + "pjOXE0YsXDF8n5a7FSvYbaMuWaQ4RAcZwVSeIict1PH5wI4Gk2vhUuOAF2DFR+Dxy+D1Kfu01K1Y\n", + "0W4bdcmiriohSom7zzkGzr0HVnydoDTmwy83hMmXwWfpTLdiFbtt1CVLwRaHmU0Hvg6MBr7l7uem\n", + "lJlGmAhmDLBsoIdpEKIfiHkZ363Ly5gSI6Y8zKYHI+9WrFy3jbpkA4XlcZjZaOBR4O2EESnvAo50\n", + "94cTZV4B3Aq8w92fMrPx7r4s5VjK4xAiD13My1DuTv9T1LczV1eVmY0zs51aPPZewAJ3f8LdVwNX\n", + "A4fVlfkA8CN3fwogTWkIIXJgNirO/X0fQWkMm5WvoLOq26aiNFUcZnYocA9wY1zew8zyJAlNBBYl\n", + "lp+K65JMAbYws5vM7G4zOzqf2KKK5JyStHoEK+NmQpfvWIKVMTVvMl+79ZqcTjaefy4aBbcS5PFx\n", + "zAb2Bm4CcPd7zOw1OfbL0wc2hhDdcSDBf3e7mf3a3efn2FdUiIpG8DSmA2NMjbReFUlXTfIojtXu\n", + "/qfoEKrxco79FgOTEsuTCFZHkkUEh/gqYJWZ/QrYHVhHcZjZ7MTiPHefl0MGUR7amjCptHTOl6F6\n", + "LREx2Gha0efJozgeNLOjgPUsPKwzgNty7Hc3MMXMdgCWAEcAR9aV+QnwjehI34Bg2Xw17WDuPjvH\n", + "OUV5qVwETyqdH8m2Y/VawWTAviM2qOfVls1sVhHnyaM4TgU+DbwIXEXwdZzdbCd3X2Nmp8Tyo4Fv\n", + "u/vDZnZS3H6Ruz8SIzPuJ1gxl7j7Q+1diig5SrxqYGWM4KPdkXpVV2K1aBqOa2avd/ffdkmeLBkU\n", + "jltxKj0laRMrI6NuFgAzs+omoWgmEIYhGZfY3HK9KjS3P+nlsOpfNbOtgR8A17j77zothBDNqGzi\n", + "VT5fRkt+igxFs5KgMBajZEDRhKaKw92nmdk2wPuBi8xsU+Bad2/aXSVEJ6lUBE9rvoxWP9ppimYc\n", + "sHgE1oG6EitErgRAd1/q7ucBHyYkGJ1ZqFRCVJnW8zJa/WgXYR0oGbBCNLU4zGwXgrXxj8CzwDXA\n", + "xwqWS4jq0X7E1PkEP0W9/yfro91x66CyXYkVJY9z/NeE4UJ+4O6LuyLVujLIOS7KzQjzMqLfItdH\n", + "u9KBBhWjqG9nYYMcdhIpDlFaOp+XkfO02YpG+RjloeuKw8x+4O6Hm9kDKZvd3XfrtDBZSHGIUtLF\n", + "kWzzi9R6aK/oX3qhOCa4+xIz254wXXESd/ffd1qYLKQ4RKnokZWRB+VjlIuuD6vu7kviz5Pj0OhD\n", + "f8DJnRZEiEowwpFsu4DyMURT8oTjHpSyTsNZC9EKvZkvox2UjyGakhmOa2YfIVgWO9b5OTYhzNon\n", + "hMjDCHwZPXBUtxraKypIIx/HZsDmwJeA01nr53je3Z/tjnhDssjHIQaPEfoyeuWobiW0V/Q3PQvH\n", + "NbM3Aw+6+3NxeVNgZ3e/o9PCNJBBikMMFh2ImJKjWoyUXs45fiHwl8TyX4FvdloQIUpBZ30ZclSL\n", + "viTvWFUvJ36/RJhfQwiRpPMRU11zVGs+d9EKeYZVf9zMZhAsDwM+AjxWqFRCDBLF5WU0dFR3ynGu\n", + "SZhEq+RRHB8mPMCficu/AE4sTCIhmtBXQ2IUn/39Z2A5odH2GHBmHFCwkx97zTsuWiLPfBzPEOYL\n", + "F6Ln9E0jg0nbAAARU0lEQVTruODs74zr3Czxu5Mfe/lSREs09XGY2U5m9gszezAu72Zmn2m2nxAF\n", + "0eiD2R26k/3d7Do7+bFX0p9oiTzO8UuATwF/i8sPAEcWJpEQjeld67i72d/NrrOTH3tNwiRaIo+P\n", + "Y5y73xEnacHd3cxWFyuWEJn0pnXc/ZFsm11nxzK8NQmTaJU8iuOPZjb0cJrZPwJLixNJiIZ0d0iM\n", + "3o1k2/A6O/2xr9R87mLE5Mkc3xG4GHgz8CfgceCoOEpuV1DmuEjStSExejxfhob+ECOlF/NxzHT3\n", + "88xsX3f/bzPbGBhVG3qkm0hxiK7Sx/NlCNEKvVAc97n77mZ2j7vv0ekTt4IUh+gafTgrnxDtUtS3\n", + "s5GP4yEzmw9MTJk+tqtTxwpROBW0MvoqkVIMFJmKw92PNLOtgRuBQ1l3+lghykEFrYy+SaQUA0mj\n", + "iZx+4e4HmtmN3ZxfXIiuUUErI4GGGRFt06irahsz2wc41MyuJlgcQw4Rd/9t0cIJURgVtDLq0DAj\n", + "om0aKY5ZwGeBicBXUrbvX4hEQhRJta2MJBpmRLRNnjyOM939rC7JkyWDoqrEyJGVMUSGj2MhMEM+\n", + "jvLQy6ljRwFHAa9297PMbDtga3e/s9PCNJBBiqNCdDzaR1ZGKkowLD+9VBzfBF4GDnD3vzOzLYCf\n", + "ufsbOy1MAxmkOCpCRkt4ATCzrY+arAxRYXo55/je7n4yse/Twws3ptOCCBHpzLDp3R3JNp5S06+K\n", + "apBnkMO/mdnQHONm9kqCBSJEEYw82qcHVobyIkSVyGNxXAD8GHiVmX0BuBX4YqFSiSrTfrRPD6yM\n", + "BL2fYEqILtFUcbj7FcDpBGWxBDjM3a/Nc3Azm25mj5jZfDM7vUG5Pc1sjZm9N6/gorS0N6lQd2bl\n", + "a4TyIkRlyNNVhbs/DDzcyoFj99Y3gLcDi4G7zOz6eKz6cucCc9GwJpWn5Xkm+idiSnkRojLkUhxt\n", + "shewoDZvR8w+P4x1FdCpwA+BPQuURQwQuScV6q+Iqe5OMCVEDylScUwEFiWWnwL2ThYws4kEZXIA\n", + "QXE0jg0WAvrJyhhC06+KKtFUcZjZLu7+UN26ae4+r8mueZTA14Ez4jzmhrqqRDP6y8oYhqZfFVUh\n", + "j8VxrZldDvwroSV1LsE6eFOT/RYDkxLLkwhWR5I3AFfHltp44J1mttpTWo5mNjuxOC+H4hJlog+t\n", + "DCH6DTObBkwr/Dw5Msc3IiiLNwIbA1cCX3L3hrkcZrYe8ChwICEa607gyHrneKL8pcAN7n5dyjZl\n", + "jleZPrYyhOhnepk5vobQXzuWEHL4WDOlAeDua4BTCBNBPQRc4+4Pm9lJZnbSCGQWVaG3eRkDhbLW\n", + "RTfJY3HcB1wPnEXoTroIeNHdDy9evCEZZHFUDVkZuen4+F6iNPRykMM93f2uunXHuPv3Oi1MAxmk\n", + "OKpCl3wZZZpv28zmAu9I2TTX3d/ZbXlE/1DUt7Opc7xeacR1XVMaokJ0ycoo4bhSyloXXSWPj0OI\n", + "Yum+L6Ns40opa110FSkO0Vt6M8ZU2Vro7Y3vJUSbFJk5LkQ2vc3LKFULXVnrots0dY73A3KOl4we\n", + "R0xl+DhWElrpSxhgR7kQSXrmHBeiY/RJ9nddC30iYXDCccCu8W+QHeVCFI4sDtEd+jQvQ6Gsosz0\n", + "MnNciPbp/+zvsjnKhSgcdVWJ4uhTK6OOUjnKhegGsjgqSOHjGvW/lZFEoaxCtIgsjopReNb0YFgZ\n", + "QyiUVYjWkXO8YhTmDO6TiCkhxFoUjis6ReedwQNmZQghRoZ8HNWjc87gwfJlCCE6hBRH9eiMM7g3\n", + "Y0wJIfoAdVVVjBE7g+XLEKLyyDku8iNfhhADhTLHRe+QL0MIkUCKQzRGvozKUXiCqBh45OMQ6ciX\n", + "UUlKOK2uKABZHC1SidaYrIwqU7ZpdUUByOJogdK3xmRlCI0WLHIgi6M1ytsak5UhAhotWDRFiiOS\n", + "swuqfK0xRUyJ4Wi0YNEUdVXRUhdUuVpjBeZlxDqdQVC2L6B5vAcCjRYs8iDFEWjUBZV8Yc4nzE+d\n", + "LDt4rbGCfRml9wWVnHiPdJ9EJlIcgVxdUKVojXUn+zuvIhZCDCBSHIHcXVAD2xrrbsRU+XxBQogh\n", + "5BwPlNsh2P2IqXL5goQQw5DFQUm6oNLoXV5GOXxBQohUNDpuWenxSLbRQV4uRSzEgFHUt1OKo2wM\n", + "UPZ3ImR3ArANsBRYQg9CdxU+LMqI5hwXzRmg+TIyQnbHA7vS5dBdhQ8L0RpyjpeBwcz+TgvZrdHt\n", + "YVzKO5SMEAUgi2PQGSAro46skN0a3QzdVfiwEC1QuMVhZtPN7BEzm29mp6dsP8rM7jOz+83sVjPb\n", + "rWiZSsFgWhlJskJ2a3QzdFfhw0K0QKGKw8xGA98ApgO7AEea2c51xR4D3uruuwFnAxcXKVMpKMdI\n", + "tmm5MzW6Hbpb7jweITpM0V1VewEL3P0JADO7GjgMeLhWwN1vT5S/A9i2YJkGlwGKmKonLWoJmEnw\n", + "I0xkbVTVYroculvaPB4hCqJoxTERWJRYfgrYu0H5ExjE4TxyMOJwz8H1ZWRGLQEz3f2dvZFqOAM7\n", + "lIwQPaBoxZE7ScTM9geOB/bJ2D47sTjP3eeNSLIuMqJwzwG2MhJo0EMhuoCZTQOmFX2eohXHYmBS\n", + "YnkSweoYRnSIXwJMd/cVaQdy99lFCNgl2vtwDrCVUYeiloToArFBPa+2bGazijhP0VFVdwNTzGwH\n", + "M1sfOAIY1lI2s+2A64APunuWs3TQae3DOfgRU/UoakmIElGoxeHua8zsFOBGYDTwbXd/2MxOitsv\n", + "As4ENgcujA7K1e6+V5Fy9YD8H87yWBlJNOihECVCY1V1gQwfx0JgxpCPoxy+jEw06KEQ3UeDHA6w\n", + "4oAmH85yWhlCiB4jxTHgiiOVklsZQojeotFxy4asDCHEgKLRcbtN+SKmhBAVQxZHN5GVIYQoAbI4\n", + "uoGsDCFEiZDFUTSyMoQQJUMWR1HIyhBClBRZHEUgK0MIUWJkcXQSWRlCiAogi6NTyMoQQlQEWRwj\n", + "RVaGEKJiyOIYCbIyhBAVRBZHO8jKEEJUGFkcrSIrQwhRcWRx5EVWhhBCALI48iErQwghhpDF0QhZ\n", + "GUIIsQ6yOLKQlSGEEKnI4qhHVoYQQjREFkcSWRlCCNGUUlscZnawmc01s3nx/8EZBWVlCCFETkpr\n", + "cUQlcR4wObF6RzPD3eckCsrKEEKIFiizxTGD4UqDuHwqICtDCCHapLQWB7BhxvqxsjKEEKJ9yqw4\n", + "XqhfYcDZ8CqClTGWYGWchPv1XZZNCCEGljJ3VZ0PLKgtTAZuhxc+DTsTlMYVwFQpjbXkDiYQQlSa\n", + "0loc7j7HzBgFp86CKZ+AV28Yuq9kZaSQO5hACFF5Sqs4ABzmAxsDO8ZV8mVk0yiYQIpDCDFEObuq\n", + "FDHVDtnBBEIIkaB8FociptplnWCCyKquSiGE6HvKY3HIyhgpw4IJIguBC3ogixCijymHxSErY8TU\n", + "ggkIPo2xBEvjAjnGhRD1mLv3WoammJm7u6VsGEVw6n4B5WUIIcQwMr+dI2RwLQ5ZGUII0RMK9XGY\n", + "2XQze8TM5pvZ6Rllzo/b7zOzPXIcVL4MIYToIYUpDjMbDXwDmA7sAhxpZjvXlTkYmOzuU4ATgQub\n", + "HHQKcDPwNSqa/W1m03otQ7+guliL6mItqoviKdLi2AtY4O5PuPtq4GrgsLoyhwLfBXD3O4BXmNlW\n", + "qUeTlVFjWq8F6COm9VqAPmJarwXoI6b1WoCyU6TimAgsSiw/Fdc1K7NtxvEqa2UIIUQ/UaRzPG+4\n", + "Vr3HP2s/RUwJIUQfUKTiWAxMSixPIlgUjcpsG9etg8HWwE+wjkeWDRxmNqvXMvQLqou1qC7Woroo\n", + "liIVx93AFDPbAVgCHAEcWVfmeuAU4GozexPwJ3d/pv5ARcQhCyGEaI/CFIe7rzGzU4AbgdHAt939\n", + "YTM7KW6/KGYrH2xmC4C/AscVJY8QQojOMBCZ40IIIfqHvhrksJCEwQGlWV2Y2VGxDu43s1vNbLde\n", + "yNkN8jwXsdyeZrbGzN7bTfm6Rc73Y5qZ3WNmvzOzeV0WsWvkeD/Gx1ks7411cWwPxOwKZvYdM3vG\n", + "zB5oUKaz301374s/QnfWAmAHYAxwL7BzXZmDgTnx997Ar3stdw/r4s3AZvH39CrXRaLcL4H/At7X\n", + "a7l79Ey8AngQ2DYuj++13D2si9nAF2v1ADwLrNdr2Quqj/2APYAHMrZ3/LvZTxZHZxMGB5umdeHu\n", + "t7v7n+PiHWTnvww6eZ4LCKP6/hD4YzeF6yJ56uEDwI/c/SkAd1/WZRm7RZ66WApsGn9vCjzr7mu6\n", + "KGPXcPdbgBUNinT8u9lPiqPTCYODTJ66SHIC5Z3etWldmNlEwoejNmRNGR13eZ6JKcAWZnaTmd1t\n", + "Zkd3TbrukqcuLgGmmtkSwogTM7skWz/S8e9mP42O2+mEwUEm9zWZ2f7A8cA+xYnTU/LUxdeBM9zd\n", + "LUwqUsbw7Tz1MAZ4PXAgMA643cx+7e7zC5Ws++Spi08B97r7NDPbEfi5me3u7s8XLFu/0tHvZj8p\n", + "jo4mDA44eeqC6BC/BJju7o1M1UEmT128gZALBKE/+51mttrLNcpAnnpYBCxz91XAKjP7FbA7UDbF\n", + "kacu3gJ8HsDdF5rZ48BOhPyyqtHx72Y/dVUNJQya2fqEhMH6F/964BiARgmDJaBpXZjZdsB1wAfd\n", + "vX7K1zLRtC7c/TXu/mp3fzXBz/GRkikNyPd+/ATY18xGm9k4giP0oS7L2Q3y1MUjwNsBYn/+TsBj\n", + "XZWyf+j4d7NvLA5XwuAQeeoCOBPYHLgwtrRXu/tevZK5KHLWRenJ+X48YmZzgfuBl4FL3L10iiPn\n", + "M/EF4FIzu4/QQP6El3QkbTO7CngbMN7MFgGzCN2WhX03lQAohBCiJfqpq0oIIcQAIMUhhBCiJaQ4\n", + "hBBCtIQUhxBCiJaQ4hBCCNESUhxCCCFaQopDiA4QhzO/If5+V5Ph3zczs4+0cY7ZZnbaSOQUohNI\n", + "cQjRADNr+R1x9xvc/dwGRTYHTm5DHCVdib5AikOUjjih031mtoGZbRQn8tmlrswOcSKgK8zsITP7\n", + "gZmNjdueMLMvmdlvgMPN7CAzu83MfmNm15rZRrHcdDN7OJZ7T+LYx5rZBfH3Vmb24zih0L1m9mbg\n", + "S8COccKlc2O5j5vZnVHu2YljfdrMHjWzWwjDZgjRc/pmyBEhOoW732Vm1wPnAGOByzOG3ngtcJy7\n", + "325m3yZYAV8htOyXufsbzGw88CPgQHdfFbugPmZmXwYuBvaPg+hdQ7pFcD5wk7u/J1ovGwOnA1Pd\n", + "fQ8AMzsImOzue8UyPzGz/YCVhHGYdicMIfFbqjlIn+gzpDhEWTmL8JFdRZjkKY1F7n57/H0FMIOg\n", + "OACuif/fBOwC3BbHBFsfuI3Q+n/c3Rcm9j8x5Rz7Ax8EcPeXgefMbIu6MgcBB5nZPXF5I8LcGpsA\n", + "17n7C8ALURmWcch4MWBIcYiyMp7wAR5NsDpWppRJWghWt/zXxO+fu/sHkjua2e51x2r0Qc/zsf+i\n", + "u19cd46ZdftKaYi+QD4OUVYuAj4DXAlkOaq3i8NMQ5h29ZaUMncA+8TJgIg+kymEYbt3MLPXxHJH\n", + "ZpzjF8BH4r6jzWxT4HmCNVHjRuD4hO9kopm9EvgV8G4z29DMNgEOQQ5y0QdIcYjSYWbHAC+6+9UE\n", + "R/SeZjYtpeijwL+Y2UPAZqRMPevufwSOBa6KQ3TfBuzk7i8SuqZ+Gp3jzyT288TvmcD+ZnY/oets\n", + "Z3d/FrjVzB4ws3Pd/ecEBXd7LHctsLG730PoMruPMDXwnSOsGiE6goZVF5XEzHYAbnD3XXssihAD\n", + "hywOUWXUahKiDWRxCCGEaAlZHEIIIVpCikMIIURLSHEIIYRoCSkOIYQQLSHFIYQQoiWkOIQQQrTE\n", + "/wAmaRXA5XjUcAAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEACAYAAAC08h1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4VUXegN9JryR0SEgoCT30jkoRISSosKjBrijYDbvu\n", + "qp/r6s3Vdd1V1xVwVURR1grYlSSISCjSpSYQSmgJNRDSezLfH3Muubmk94R5n+c8N/ecOXPmnAu/\n", + "mfOrQkqJRqPRaK4e7Bp7ABqNRqNpWLTg12g0mqsMLfg1Go3mKkMLfo1Go7nK0IJfo9ForjK04Ndo\n", + "NJqrjFoLfiHEEiHEOSHEvgraLBBCHBZC7BFCDKntNTUajUZTc+pixf8RMLW8g0KIUCBQStkTeAh4\n", + "tw6uqdFoNJoaUmvBL6XcAFyqoMnNwFKj7VbAWwjRsbbX1Wg0Gk3NaAgdvy+QaPU9CejSANfVaDQa\n", + "TRk0lHFX2HzXeSI0Go2mkXBogGucAvysvncx9pVCCKEnA41Go6kBUkrbxXWFNITg/wF4AvhSCDEa\n", + "SJVSniurYXUH35QQQkRIKSMaexw1oTmPHfT4Gxs9/salJovmWgt+IcQXwHignRAiETABjgBSykVS\n", + "ykghRKgQ4giQBcyu7TU1Go1GU3NqLfillHdUoc0Ttb2ORlNXBAkR6gfhnuCSAbmJsCBWysjGHpdG\n", + "01A0hKrnaiGmsQdQC2IaewC1JKaqDYOECB0D8xdDoGXfXAgIEoJGFP4xjXTduiKmsQdQS2IaewAN\n", + "jWgqhViEELI56/g1zYMQIaKjIHhzFzjWGu7Yp1zOQiE6UsqQxh6fRlNdaiI7da4ezVWFJ7gAuBTC\n", + "q9fCH26HMx7gAa6NPTaNpqHQgl9zVZEBuQBDzsKO92HAORj0KOwbTWthFvqNU3NVoAW/5qoiERbM\n", + "hSMAzkXw8loY/QVJhybgCfwozMK3kYeo0dQ7WsevueoIEiLUH570ANdMyDkJC+Mi+AV4DngceBb4\n", + "WJqayH8OjaYCaiI7teDXtDiECAoFv3DwdIGMXEhcIGVslTx2hFkMAj4GzgIPSZNMrPgMjaZx0YJf\n", + "c9WjhP6Y+bA4sGTv3COweV41hL8jatU/D/UW8KFe/WuaKlrwa656hAiJhqhgxr4Bl3rAmSGQ2g2Y\n", + "Fi1lZLXcNYVZDEDVm0gB5kiTPFkPQ9ZoaoUW/JqrHiHCYmDZeCaaoPNO6LQLnLIgxS4Nn0sfAbuM\n", + "LV6aZEGl/ZmFA/A08BTwN8z9EpH+NVIjaTT1gRb8mqueyyt+a9zPQ/cp27l1z9fAEGAw4A/sp2Qi\n", + "2A3skSaZVWa/ZtGPbPtvuNDOn282u5La3ThSPTWSRlPXaMGvqVeaQ46bsnX8cxJgS7i1cBZm4QEM\n", + "RE0ElsmgH3CS0pPBLmmSyQDCPngVo2+YwjWvwddfwNEbjN5Cq61Gag7PUtM8qIns1Ll6NFWiiea4\n", + "uQIpYyOFCAJCnwQPV8jMgZMLbVfk0iQzgU3GBlw26valZDIIBQYLs8gEduE9tTebnoZDN0FWB6ve\n", + "PKoV9dtcnqWm5aJX/JoqESJEdCQE/28Q3LYf3AzteEvPcWNE83YHhvD2ta9xYUOPKxp5TdjHn9bd\n", + "RRXtBpZ8QQfaQde0q+dZauoHveLX1BuWHDerAmFLF3h3pdrf0nPcGG6cR4GjIiIoB+aWViO53HOR\n", + "8XsuAV8BfsIsrO0Gu4C9tnYDy7N8Yyx81Q+uPwbTD4L9EVo10G1prnL0il9TJSyr1DRnGPIIvLkK\n", + "ZsRffatUZUPwL1ONVIbdYAhKdWRtN9g15WWeW1XERIAUV1jZE77vA98FUliUbx/Prq6O7AtM5bxd\n", + "al15DWmbQstFG3c19Ya1XnpzF5hxO0z4gONxqTyuBUj5lGE3GOIRz7Bp0Th/mVryxv2AHSciHb0+\n", + "Oddj+AME9vCh9w+Q1R4SSCHrvJnJ5xfWNIisHJvCkc0wT/92zR8t+DX1inWOm21T8UkKIqfIg6HS\n", + "JIsae2zNCWEWotsSZndL5QkXB9qmuuIady12GT3svTh9nQOOWWBXCEWO4JwB3ocKcSrKQyWXiweO\n", + "tN2IX7+djPYswi7Tjvz4/vx8/ga2A/lAntVn3pC3+fC6NPo6S5DFcFMxjOPqe1trqWjBr2kwhFnY\n", + "A79y3O0YH4/rpAOaao/wuvE32j85lt7fQcd90OYouF6EHLtcPHP3A05Ae4po438Y+do+nEKOQKs8\n", + "uNudjJXX83vqMFIAZ6Otc6t9dAhdTe8v0rn8f+t5IBh4G9Ytl3IC1C6/kaZx0cZdTYMhTbJI9PH/\n", + "kOnnl+AbYc+pUcaRuQFCBKGFRg1IL8ogPRgSrOLPnDKg68Td3PX7Z6hYgyFC0j7fF7unfODB6XDt\n", + "SZgej2fib8h1P8hbrLsMESL6C+hz1gP2dYCB5+CVLHgByIQcKDe/kf4dWzB6xa+pMUKERNN3TjCT\n", + "n4FFuyDP4pRS/YCm5oStoXQrnTdfYtCY2q6Wqxp8douDWPdiO8bt7gQjTsH+DvBdH1jWm8JCZ3YB\n", + "3/FT5xR2DJwxia2jfyHVa6svPDtZCX97CeI8xWmu/JDXiR/516S55Pwymm4x4HlKBaZldaQmv6N+\n", + "c2h49Ipf08B4unDgFghcBX2/ht2zjf3VC2iqS+pb8NgaSlfiwUbGXw9fOJa0qtlquarBZ9lF5Aw6\n", + "B4POqe/9LsCt++GCPWtWvcDrnHMOZ1xaKGOPOMTGe7EhPpWxiRDzMUjgtCeE+pFwPoxNwETayAGc\n", + "AuzzoN9XMO1xSPOHM2mDhVlMA2LKS2VhjX5zaEZIKZvEpobS+OPQW3V+s6nRICWiUIK02kKiGmc8\n", + "/UNhzuHSY5lzGPqH1tU1pkK0BGmagFw8FDnGabi6jkuKZMZ9kmGLJB32yVZiVPJtEDMVovtDnV1f\n", + "Skl/CJ0Dh60f+oNwxHId9bsUS8a8Lh3v7iq9H7WX7Z9Gzp6O/L438l5HEqzHdPl3tGx2BZIumyXT\n", + "ffKJoAgTxQ7PkNduNhcCxhPn34M7K/z34HpR0nOlxC25Uf89XC1bTWSnXvFrakHiApgbgLRVTZxc\n", + "2Djj8QuHxYE45MCQJVDsAMVjAnHZ+KowCy+gECgwPq3/ruzz8t+3CNyQ0D4LNvjD7jPucAaQ9pA4\n", + "Fvw2wdjXyXY73i4jifFjE+G30wT1bCvCD1+U39TFXcZKGRkkBKE2VcRKXDM9XUBA/EwKsttTWByF\n", + "X84aNvS4WPzVRCkywuiBPZ8Ks4gHNjK24162PdCfwiVdAPXckj5IIKl1eMDm024BXrzVMxDfjf60\n", + "PXwNbbMd+Uy8KJaS4ZLHmTYZnPRIRqQtRlznhgQ8zsCYf4PPDshuDxeyhgqzmAdsBXZLk8yti+eg\n", + "qTlax6+pFRUFNDX8WMJiYPl4nNNh0nNgX6DcIt2iz9H7zFrAEaXetHw6lLGvwjbD/4fb9qMltaqD\n", + "Gc7PbL9yMP0H4zp9Dz1TIMsJjraiWDqwF9hISY6gk/VR4KXMDKUAhEYTERUK9ATuQuUiGgCks98T\n", + "dvRpTYE7iJwsBh3cxbDU9X2imfFREgN7XoQ2OSCATzxcmd2/T35Rr7ZO+G5Tz7i4oJhtXQRbt4jL\n", + "eYxEEbSLh14zY5l86DdgFNALiAO2AVv5zseFPQNuQbYqpZrTAWdVR7tzaq5qKhJ4dWVsLkvHP4tp\n", + "hVl8efnt2V+E8XSrKDr6ZnLWA373gRX+ZGW3wQFIRr09tAVygQ3Gtgm1Gq40109lVNVIDCDMwhWY\n", + "BEwHbgYuAluA44BDp0M83MWdDofbwlvRcP9uq8lu5t1weigcmwhdf4M+f0vFN9uLS30FRycrI/Gl\n", + "xYVM+bmA3pl7gH2oOISCthsZ0TOOG53thHeWo72I7zaATHEjnN10uv357Z9Ov5g+UwecVQ0t+DWN\n", + "SmOv0qoj8GqDbbH2LXTeconBo8HD1YvE/p8R224amaXOCYXoqAhuBQYBw4xtNCoBXDpgB7ijVsO/\n", + "oCaDzdIkL5Y3hoqedU3exIzYjFHADGNz7RRL8f924j/uBDgUK4+gCYxnHS+B01fQ6gy4nwb3QXD8\n", + "1G8UHvon/h7PE5DWiW5nveiY4YIdvwMHgEuAd6t9XBuyhj5fppa8Oc1ybkdk74lkDrqEve8v0j8H\n", + "MSoJ7t4L0w6XPEMdcHYlWvBrGo2mkhagsVVPZT2HOZCwBcLLeg7CLNwomQxGA2MBP5SPvQtqBb4N\n", + "WAmsBw72jyCkvp+1kZW0j9txnnF15vYib1xCjsD0eHj4yKDctLxpLvBKyQnuc2DqV4UMSHsNeOty\n", + "DQOVv2gccAMwGfBtc4z8v8fR8YajEJjC5ciyEQSzg2iuF95pb7dN89rmCz4ZMPmoOh5mFXCmKUEL\n", + "fk2jYUnidv8McC6ETpnQMQveKWZX3E08CZwztsyWXrjc9o2gtOG1cozJYCAwAqWGGQF0BIoA6X2S\n", + "gmcO4TE2EcYkgZORMKO+VsRBQoS28+YvF4PwTepN69SOdu04OVkQPx0O3FJSm8DxhlieX7MRmAUs\n", + "Bd6QJnnK5t46D45kzSAf+q7uAf9YA/ftUcfUm0QMo/G+sJm0drbj0Cv+stGCX9NohAkRsxzGf99b\n", + "+Ymf84CzHvBNWy4kd+cw0AklvARwlpKJoNy/jWIpGi7r4gcB1w/4macne+D9mz+s/Aza5qg2M5zZ\n", + "+f1zXFPfXjPCdcYGetx1LX2+h50PwvGJxpGwdVIunyDMwgf4MzAbWAH8S5rkUYt6yh5G/gStJVBk\n", + "p1RIYFnxd0nozDefTOPS3VV9a7ra0YJf02hYVvy2+21Xacarv2USsGydyvi7EyreqLIJotqTRHOP\n", + "Li3vWY/2J2PrAzgAB4Hfrba9dTkZVNWILsyiHTAPeNTpInumLSfwm3P4rwdWUUpRxB245kQRGJdG\n", + "scni1VObt6arCS34NY1GdXXblWHomD2ofIKwnSQqfptYEDiIlAn/sokubVYF0yt61nERrEWpiYZZ\n", + "bb2AQ5SeDPbUdDKorhFdmIVXt81szx5Az2tPwuurIekSrAb2Q0oObNOCveZowa9pVBprlVbGJFH+\n", + "BFFo50+xix2ZneBCX/j8J6OX5pVfqDrPWpiFC1dOBr25cjLYK00ypyrXr64RPUyImI8dGb94KMw8\n", + "AH7pxn5tsK01WvBrNJUgxG0xOC0Zj8dZlev+zFDjiNJPN+bYGhJjMhgADKf0ZHCYK98MqjQZVERV\n", + "VYGa6qOTtDUDyvK/jqM/zVnn3LzIzCXfE1I8bffXWrg1Jww1z3ZjA0pNBpaJ4EGgjzCLI5RMBDuo\n", + "wWSQCAvmQoCteuokNFJ6j6sbveJvQMrSzd6POPMN18sMfvEpadm8dM7NiYYK8mopCLNwpvRkMAxV\n", + "StJ6MrC8GWSX248ICnWgw8uu2HdzJFP4ciChmDST1uvXHq3qaeJYXnd/6gU3HAWXQrV/BMHs8PwQ\n", + "8rwg38No3bx0zs2JhgryauxI5rriCi8o92Pv8PTB01w5GSRQejLYLU0yu5x0zVVa3LSUZ1ifaFVP\n", + "E8cTXFb2hEduhB3vqyAnAHdyIfjPcDgE9txntG68nPYtHUPY1KvwKCeSOSBICJqT4CoR2u8HXo6x\n", + "zZobQITDPCljF11up94MgiiZCO4D+gmzSOCO9m1IGOjDmU1wdjAUuKEmgdAnqeB3aCnPsCmiBX8D\n", + "cqojdg9Mh2+XlQh9gCxcwGc7xJisWl9dOueWhh+Evw+BpzzBN0PtWwyBoVChsGt6GKmux7wJnXbB\n", + "2pchdXEgTHkJq/uQJplHyUofAGEWTkAQiZ2+oEMsDF4KB2bChr8aLa5c3AizcABaAV4j/Xn+HkHg\n", + "j87QLltFKTfPZ9j00IK/gRBm4W43G7/h60gem0h7y/77EUUpTqn2uCfDxd6qLfedkY2W015TE4RZ\n", + "eKNWvAOAAd4PM7qNNzgXwcGF4JWn2nlAM3uT83QB4Pe5MPYNeGgY7L4fNrj3EyIo1FpVYwh6ryu2\n", + "fW3ySVt0Zde+if2FWWzBEPTG5gpkAGlx02n7fKYqJn/DUSX4oTk+w6aHFvwNgOFnvrjYhXWZW1hu\n", + "KaCRAf2fQ7br4b+H+acdGSCvx4UsTnP41F6Zqlc0TRBDpdEXKyFvbN6ozJqxwL5u6zn08wlGtLcx\n", + "d1oKnDcfMlSQV74nxJhhx6Mw3gzhK10p5mvP28XFvltp71aM43AHODiCjIy+XATSLm/j9pxnzd1p\n", + "ZH/qdblbp/vO0enEO6hMpGmoDKVpqFxOxVC+C2jze4ZND23cbQCEWfwRuBe4xtoNzpLf5rQnJLWC\n", + "kUY6Kx3U0vgIs7BDpUweQGkh3x04isotH2t87gOOWwQW1H0kc2OhdPyjvoIPS1bZjuHQwwOHsQuy\n", + "HNtkufx3Dfb37lEpm8vLElpVg7q1IdmLeI8ZxPp8jOxsOd4cn2F9o716miDCLMYDy4DR0iSPWx/T\n", + "QS31Q3Vz8Qiz6ECJYLcI+f5ACiWC3SLo4w19dqW0lHwzQozbAeOHgT0qQehkYByj8b7wZpe0ds9M\n", + "hsFnYWGUal/Tf79lef94csPp4aw7047CzOb8DOsT7dXTxBBm0QX4ArjXVuiDDmqpD8pxHQwQIggi\n", + "4tahBLq1iiYIcKJEuO8APgLipEmm1mYshoBqAUIq5UU4e0XsQ3sys8ck0W79R5DpVHKk5jp4w5Ds\n", + "lAFeiZDcjwx+8VlL6F7t2ly3aMFfTxi64K+AhdIkfy6rTeVFszXVxy8csSiQtgeg4z7osA86Jgfi\n", + "c+Qro0E8Jav3aOPv041RI6C5+KhLGRspRBDK/bJEVVNAUTgwQACe+SXta66DNwzJnXdB2C2w6WnY\n", + "9GeQ2rW5rtGCv/6YD5wG/llRo5azKmwqeLqAhLDb4GIvODcA9t4F67JiefiXsdIkCxt7hND8fNTL\n", + "in0IEoK6fWM1DMknxsHi7TD9AejzLUTa2VVyoqaaaB1/PSDM4kHgaWCkNMn0xh7P1URDFFyvCyz2\n", + "nXx7yLcH93wVHlVX9p2GqjlQl3aMK9R0ohjGjL7A9TuccJARwAJpkkW1HW9zeMuqDo2i4xdCTAXe\n", + "Qll+PpBS/svm+ATge5QnBMDXUsq/1/a6TRVhFiNQq/xxWug3BokLYG7Albl4Gj4uoiLh66nq6bLV\n", + "F4LvUe3bZ8GlAq4RZrESSAbOW23W35MryqVfkZ2jroV/Xb6xXqFSkpk5bMpeyBR5EGV3mSnMYrY0\n", + "ySPV6dfyO3iR4hOKc8Dn5LlZjjXlt6z6pFYrfiGEParazw3AKVSmvzuklAes2kwAnpJS3lxJX81+\n", + "xS/Moj3KOPgnaZLfNPZ4rlYau+B6yRjKz09j69GV5QjJ7hDWhs3b7+UfQAegvfFZ1t95lDEhAOeJ\n", + "6jub5AUDyWoPGb6QbSlfW7O3nqawSjbca58EXgDMwH+t3WfLPc/qdxhOMNv5mcdD4a8bSiKqm7sX\n", + "XWOs+EcCR6RUHitCiC+B6cABm3bNWqBXBSPU/Evgcy30G5eGyMVTOYaHSod90CoJEqaALMlPY+vR\n", + "5V4A81JJyE7l79JUsVA1AgJbUfak0J3AS53o/Sq4J8PJa2HlO8aZ1TeSNhVbhCHk5wuziEKt/m8R\n", + "ZvGANMmjFZ9p/A4Bq3BP3Q0XVT3oX7vDPXtVi6sxEri2gt8XSLT6ngSMsmkjgbFCiD2ot4K/SCn3\n", + "1/K6TZF/AMXA3xp7IJqmgOGh4nYBJr4INz0Mux6AfdIbaufRZXggWSJjD9seFyKkd9l2jurnf/KD\n", + "8L+0JTBigHoreX114+bLkSZ5SJjFOOCPwFZhFi8Ci8pf/Ru/w8nryGqrmkw6Cmt6lAj+qzESuLaC\n", + "vyp6op2An5QyWwgRAnyHqgF6BUKICKuvMVLKmFqOr0EQZnEbEAYMr63xSdNSMDxUjk9UHiqddsOQ\n", + "D+Gh1cOMVesHRPBjbCWr+5pRezuHMAs/YJbnE1wzwRlmxcFde0uOV3WVXB9GZuP/2L8NW8hS1Or/\n", + "QWmSJ65sbfwOBW7En/2AWe5389KxTF69Tgmvuc0wbsZQn0+oVR+11PGPBiKklFON788BxbYGXptz\n", + "jgHDpJQpNvubpY5fmEV/IAYIlia5s5GHo2kilFvwpdWGv/DUIQ9gLqrU4f+AD6RJHqr765dt5yhP\n", + "GAuzaAfcCtyJCnT7ZvAyBu2IZ4S9jZioil68Nnn4q3yfSsX6F+DPwF9Rz/LyaG3H4MGP9Gk3q3Dv\n", + "7ByHYZ+xJf00Lzd3w26Dp2wQQjigjLuTUD7r27jSuNsROC+llEKIkcByKWW3uhh8YyPMwgtl0H5F\n", + "muTSxh6PpmlRmZFZmEVvVHnD+1CBZYuBr+uixm3FY7ISxk4ZMCDkHOO3JtKqsCcQhYo2XyVNMq82\n", + "OYeECIlGrAzm9hlw6EbYcw8UulIfrrXCLIKAj4ELwFxpkomgbBQdcHjZHtdumTiKA/gmpIkiE6b9\n", + "rwKdgFFlRdVXfF8N4ypb9fE0Qq4eQ31jcef8UEr5qhDiYQAp5SIhxOPAo0AhkI3y8NlSF4NvDC7/\n", + "6MLDhfvW9MU1e5t8J/emxh6XpvlipDO+EfUWMBIleBdLk9xT59cSIdHY/RhMrx9hwBcQsEoFTCUk\n", + "7CH0wLXSJDNtz6mpr74QYTGwbDxd16uUzr7bYdvjsHPbJpnx4zV1fm9m4Qg8C8wDnulr5tw18grD\n", + "9JHNMC8ugg5AOMowHixNVbM7NsRbTHXRSdrqmVI/+ri/Q89I+LjPEYq26fq4mjpBmIU/8ICxnUO9\n", + "BXwpTTK9LtwqhQiLQXwxnttmwZFgOHAL5LQBwtZJuXxCnd6LbTBd+/0w5k3o/3EhzkXvA/+prk9+\n", + "la5rFoOAj0cvxnfzKdrvb69y+ncxompCIToqgodRRWOeAl4HbpYmua3yexq3A64bhks65LZCeeSO\n", + "ozEDBGsiO3UodLUwXMMCo2D4u7D8KyhaEqhe5zWa2iNN8qQ0yQhU+ucXUZLlhPOTYlXXbiyKhODl\n", + "MD4KgsfA/CAhQqt3hYxcpL36t7tzriH0oX4qviUuUKthg+R+8AMJfNnlfuASsFmYxdfCLEbX5VWN\n", + "N6VR3jlkA2zuAkMehgWjoEgow7Q0yZNAKrAH9ab1kzCLSRX1qxZ+PfvBK5C7EHgFWAWsp7mVStWC\n", + "v1oYrmGDP4avvoQMH2N/8/rRNU0faZJF0iSjpEneAvTxOUi3wzfRZcBj8KPhE7cYAv2VW2U1sBHG\n", + "QH1FNqu34M3zIDQawtapzy3h8ujxz6RJ/g3ohnKM+FyYxUZhFjOEWdjXybVNMp8U4gEe3AUbl8C3\n", + "fWDUXDjRHUej2RpgkjTJH1FG7S+EWcwsv1e/cPjQFffzYG/JzP0KsJrmVipVq3qqQcmrq6R0TFrT\n", + "ygOjaXmECRGzDMav7woe+TDsjLG/BkV7mkJkc6nxKM+cP6DyW3kDbwJLa2vktjVMS2DsSNK2TkFK\n", + "Bz4GdrHb63G+G3MJPF1wSXFi+rbe9M14WprkElvV2mpu8inihwE8cA38+gocn2BcaVYuxN3SnHT8\n", + "OjtntWg6eWA0VxcZkCuA8Tae6jUJPmoakc0lGBlTVwiz+Aq4FjUBmIVZvAO8I00yuSb92gbJpbji\n", + "FOePr3RgD9CJAvEmJ4NaQ5TSfOQCKx48ya0rXm0/SYydAeOtDcOdOZd9FuDMUOi8s0Twtz+VLs83\n", + "MxuflLJJbGoojT+OysfZPxRCouC2GPXZP7Sxx6S3lr/1h9A5cFiCtGwPwpH+0CL//THE5yHCOiby\n", + "nEMBt3U8ySDfOXXRbx8XZlzbnqMT/Mgf6e6e5THNR3L7dInLpZJH6zh57Uh/MotBLhiJzHRUB37C\n", + "QzpzRxaDl0hm3qXaigeOEuaZTAQ3NNqzqoHs1KoejaaZ0FJKOVZGKe+5VokwbDGMeK2I/OKteBc8\n", + "LU1yk3X7qno7lRWTMIseRPacQmbCQii2KEDC1s20X+H4dRFj7/kDtM6FBUZZyVF47dvm3yedP+wb\n", + "wvzx6+HkQiLiCoEPgUHSVDowtSHQ7pwajabZc9mW1uYw3BMM33wCZwfDNYP3M+GIC8rN9Q3g+/4R\n", + "yrupLF99W+FvyYia2Ar2doRpRpajEQSzg2irlqHRU4kSURB8yQUGPAaffAMTj192Bb0ZlSepvTTJ\n", + "LABhFgtQSfLuaOhqbtqdU6PRtAAM77mUnhA1H2bdAqPnw7pByag8X/8GngHi88bx+kvuBN4aBqc8\n", + "1dnleTtZaiBkOcH9MyBVXQV3rEsbzCmEk1uM7KlHWufC+z/CA9PhHmeOnVSlVAuAOGCQ1YnPAgNR\n", + "6S6aPFrwazSaeiNIiNAQIaLDhIgJESK6anEHGSWS+NBN8P4OFWE8Z3UQ0EGa5NfAGGD2pUA6+T8F\n", + "J1uBvVV+zrKSyGUo8y19LsDNB+H1sWp/lnMsOM9Dpfq/1wHPDjfFShm5GeaFQvRHh1mfmUz2skdo\n", + "HReBJevATmCopW/DA+lu4C0jCK9JowW/RqOpFyw69ahqB53ZxBqkd4GlAQkUFUQDO4VZTDXUKUlZ\n", + "Xrg8vAOGnIW+T8DDN8LBtmV7O1lW8QCmdfDecLjZoyvxXk+B2zzgZWAceNFfmMVHcRFsipQyZIWU\n", + "4y/0wqegNXbA78IsfLAR/ABGksY3gaVG4ZgmS5MenEajab74QfhiCExzhq/7qn1VCTorM/BLbguX\n", + "H2bfDdwOLBZmsQTYYJ/MJ3lRHFn0Exx8GzplwqAHKVr9J7yFWVxrFK0BlHunZRX/lzTWOe5zyoke\n", + "F0Tm+b/CpR4lAzjttAGVV2yfMIupANIk01BBXq2B31B2hlKC3+A1lJv8UzV8bA2CNu5qNJp6IUyI\n", + "mOUw/pg3TLgf/m8jPLqjZkFn1gizmAz8iCrsNLl/BH2svZ2OePH+4T/RCZWq+QLKEPytba0M0bX7\n", + "7dxx+jMWxduR2t3YOycBtoQbaaonobx1VgN/liaZLsziXZQuvxvQBmhtW/9YmEV3VKbiSdIk91LP\n", + "aK8ejUbTZLCuK3y0NVx/Hzz9G6zcXvMat8IsbkBlL30A6IGqePeENMllZbS1R5WCfRrlcfMm8LHF\n", + "EwdAPOj2KbkeE/l8wuFyUme3QiVxm4pKob0F2AssR00sj0iT/LCMa99vHB9hOzHUNVrwazSaJoOt\n", + "3/xxbwjyDe93AAAgAElEQVSaTSHJfJj5iXykuv0ZeXTeA26VJrne2DcMVes6BpgnTTK7nHPHogq2\n", + "XGf08bY0yXPCLDxR5StvkCYZW8G1g1GZUn9CvW18gKpFMhwIkyYZbdNeAF8Bx6VJ/rm691odtODX\n", + "aDRNCtugs9i+LEucxYsot8j/lHfeFcVOZv0WT9+MMGCaNMldpdoq4f0uMKRTJG8P3sZ0SzDXVjpv\n", + "vsSgMZf7Gbz3a2acHoqyFaxAvQWEABOkSU6v6F6MwktvAhNRxl1/lLppLGrS+dKmfTtU9s97pEn+\n", + "Wp3nVh204NdoNE0ew93xV+A9aZJvXHHcttjJ2NdhdEQhv3o/JnedWlxOn6JVHG/kdWfe/DXYP/Q7\n", + "ROLB7dxYkMkXjiUtVdEUIuK2A48Z23ZgBDBDmuTmKox/GvA+4AmcRyWYi0JV4nvXpu1Uo+0gaZKX\n", + "Kuu7JmjBr9FomgXCLLoAa1E1ckvV6C6VBXfSX6HP9/DJz5D+UIVZcEOEiH6rLcGzboNhpyHph+H8\n", + "zDa4bRasewHODzBalmTTFWbhiip9GUERrfpGcbDfTtKzismpqNCNMIvWwDJgMjAD2IcyAi/pa2ZX\n", + "V1mSQmJrCAWXRpEhTbJKwV3VLbijs3NqNJpmgTTJJGEWE4BfhVnYS5P8R8lRI3LX7SK0OwgfrYfs\n", + "dlRW98ITXHpfhC0fqJQMz+AOCIifAXdMh8VbIbt9qX6MwKv3enuI04mP8LUYyeCd18CfNsPvuwkM\n", + "EoKyhK6xep8izCIdNQG8A9zgtZvNQ11o+2lOiWydE0XCcg+chFncIU3yi4ruoax8QnMhoLxx1BTt\n", + "x6/RaBoFaZKngAnAvcIsXig5YkTuZreDZd8YQh8qK3Ziicx1KYSRp8AZw3ln350QezuE3Qr2+WX2\n", + "0yOLx5ZG4SAFfPI1xHSDlfMISL+RBcIsOlVw2Z9Q1cRG2uWxYfQqvD7NwaHQTuX/B/gAAkb+RCIw\n", + "X5iFn+VEIYJChQiJFiIsRn0GhVpiH5JaKU8oqGnBnYrRgl+j0TQa0iTPoIT/HcIsTGpvzaqEWUfm\n", + "AoQTjzt3FADw698hzwtuCkovqx9PcJl2CA63gS1+8PVy2Pwh4IwrcECYxQfCLPqWcdkdwDqgZ+B6\n", + "LhW3VfmAAsLhhHdJozY5FADzMaJ6S+wYUcGwfLz6HDPfEXsfgBX94I2xJeeXlYKiNmhVj0ajaVSk\n", + "SZ4VZjERWCPMwp4ITEQAhFarSpht4ZVMMnOcWLcli9DRSA9XvsvOZ15CbyKKu9memwG5boUwexeY\n", + "J8C8rRCYAkFfszdxAPcAjwJrhVlsRwWErTfSRuwEZgIfXArk4Zs3w0o8SMkr4laXfrRFEE48meot\n", + "419AKPBH8JuC26uBXP8wrDMZZVwXByaz4gKkMToJPrFKAVeTgjsVoY27Go2mSSDMogPwC8pP/m/1\n", + "kd5YmEUAsAmVPvmyi6VFt/4fRwLbPAt/Ww8n15OwBcItunXDEHwPKjArHTUB/OJxkMRrvuS3gs5M\n", + "dEu2s99eMJZzs1FvGSfG4y5m4eC87rXUnLPPCrPoAWxlY+90Bqf2YN+dsPYlyPcAwItR+25jm+tC\n", + "BzWO5NdgXkHpcVxxT9qrR6PRNGcM3/c1KPfI5+pJ+F8PfA6MlSZ51LLfEnMQO5MBp/rROfAtZh7M\n", + "kN+Xcb4dcCPwF5FPr8GbaLd+E/Ye+er4LAKIHNeazHMvwMGb1c6uo7KYva0vqlj3j3bZDBj89gjh\n", + "me1GFs7EE04m04AbU7w4eWwoB/j9scJegWvYn3eQl+raq0cLfo1G06QQZtEWtfL/BXimnoT/4yj1\n", + "zRhpkhk2xzyAi8B/pEn+X0X9jAgUm7sNZfTa7vDQ72BeC47FMMJ9MDvcPoPkfqpPr+Az8k8/uwCi\n", + "zUZ+cO1A2B3JuLy+WvUziwAiGUImTwLjgLlHeOST/XTK+02a5GsV3osuxKLRaJo70iQvApOA64F/\n", + "W2fYrEPeQWXZ/NQ2hbI0yUxUJPA8I1dPuXRPIG/FCti6GLxzwcGoCeCe5XVZ6APYe6R0FHlkAQWD\n", + "NjJi13e4fDYQtvqq48tIoI/LbnAYaZyxOJCdPboCo+viZm3Rgl+j0TQ5jNq1N6By6/ynroW/8Rbx\n", + "JCrN8stlNHnR+Hylon4sLqQBl+CZ35QeByALl8tt7LzDmOsabxf8T2K9d/Ie7ejbPhvWfQTDT5f0\n", + "5d7uhFXdX+CYXy4wpj4mPi34NRpNk8QIkpqMqra1oB6Efz5wi8jnwX6jxB7rKmHSJNOB/wJzhVm0\n", + "tz3XUlmsCHwesPK4WQ9Mh+J2Yh0jndvg692TJXlRvHMkE0+J6+gfGNn7gmrbMwXsrZRYWTldSgv+\n", + "ZLtLKBntRx2j3Tk1Gk2TRZpkqjCLKUA08F9hFk9Ikyyu7LyKsE4A58UAj+s677PbcjcDn0lSK3BL\n", + "pCwRvIzK5fMvVBpo4Mro2vXATQ7I7CJOdZW0+R7ckLmQl8vjXOJsngfBDGcz3gMcyRQTcmN5VmTy\n", + "Lyuhf589xOc9azXKOQmQuBB4GKXuOVmbe77iGWjjrkajaeoYuvYoIBZ4tKbC3zYB3HCC2c7PfNMX\n", + "ngqG+LdV5G8oqmaAMIvXgHCgtzTJE1BSZyDTCdzzS9Q7wfakryqiVYYTmCbC6z9DtPTgLkJJo6Rc\n", + "QACzmEskmWRiDxQBkW3J2XkxZJ1t3IIwi+eA9tIky63opY27Go2mRWKoXqYC/YBFNa9p6xcOiwO5\n", + "5jW45l+4u6mF9MwD8OtSJfShVKTsP4BilM8+oKJ8AXrMg3MeJT27gzOAR74y2n46EBbQRwl9x2zw\n", + "3wBAAstYSx9eBiKABA+ykvqySMrIECmXT1Cfl4PVtlAPBl4t+DUaTbPAcLsMAXoBHxgVtqqJkQAu\n", + "uy24J5PlWZIpuYdV0uQkH/oIs3gLVXVrNXCzMIsJwiwcLAbdrqlwwqvknHR7tfgXwGur4YXrIRt3\n", + "ddAxC+68EezzANiEd0oYrJviwNqfbkSev+GyMdmWHcAgYRbO1b/X8tGCX6PRNBsMV8tQoDuwpPrC\n", + "30gAt+tB+PkN4s99yCwCSrW434Gko/58BCSiDKsCZQ+NBrJ/C2Pona3I7ZqmqooB3OtM8t6RFM0R\n", + "HAe4JlHZC3Z7Z6tcQdnt4UJf8N8IQA5FxzIg18GDrgNiSOsfwXXl3G8GKv/QoLKO1xSt49doNM0O\n", + "YRZuqNQOp4H7bQupl3uebZEXwJNJZ4az/nQ7CjMzIeckLLSNlBVm8U/gCZSX0Rnfb7itOJCn3bOw\n", + "77ibjNjRnEkbwnDPA2T33oGHZx75F1uTt7evhzs/Tc8i+1Mvxr8EzmmI1RfOTZTfFq1RCXoAmAtH\n", + "NsO8siJ0hVksAuKkSS4o+5505K5Go7lKMIT/90AycK80ycIqnSeCQsH/igRwV5R7JHGBRdduRBOf\n", + "AHZJk7zO2Pck0Eea5OPG90hgEbAK8EW9LfyNva068duAVvjk+DBhv51IdChy7p3p0CUdwuLgFSNj\n", + "kMWgXMZ9zgYml1fIRRdi0Wg0Vw3SJLOFWdwMfAd8Kpz7fkp+tyfKEtylzlP7Sq/oy3gTgLkBQgQh\n", + "ZWykNMmLwiz+CzwszOJ6I8HbCZTB2cJOYKg0ye+BBCBBmMUBBqbvZ+BvI1Ap+hNGRpG45nu6J9nE\n", + "BJebevl7H0euvzhDiLCYiu6rOmgdv0ajabYYFbSmk+4QwC1ZX2D3Q6n89kqgVwXD28flElz/PDhl\n", + "oiYBf+sCKK+jFsuWNBLHga5Wx3cCQ23Gdw6Vh/8VaZLH7LOJ3zOVbk5F0Pui2iyUlXpZiKBQdoc8\n", + "jYOrK+4La3BfZaMFv0ajadZIk8xlwcQUxEAPbr3dqLIFZQjuCjC8fYSEVknweD/o8x02ZRovoHL8\n", + "dEHV2T0BdLNEFHdZTivHbCZbRwAbp74JjBdmMaLXWvKdHRHXjS999dmQfRLKKDTjF478IJBTo8B3\n", + "Ww3uq2y04NdoNM2fQm9nln0N9gUw9AOrAxXX6S3B8PbJaQPfLYVvl8INz8LsX/oKs/C3avgGyo//\n", + "n0AmUAC0CRIiNHg/z3uC8wIPxkdB8BiYb6R/yES57L8esJ/MIgfYOQZmdlM7XwBOQULZqZeNCWnF\n", + "Mjh0Yw3uq2y04NdoNC2AjFyKnGH5V7DjEav9FdfpLcGm3OPxifDemARE7s/ATmEWfxZm4SBN8jzK\n", + "gOsB3I1a9Xf1g/APIHDoGdhlVOi1qZW7BOh4IgDXwWfh8d/hyFT4q73KEOcAp8q9L1BlI7G231b1\n", + "vspGC36NRtMCMAR3kRNIi1gru06vJcFaqaRsMjYSNs+D0GgIWweh0RTuCJcfZt+DShIXAuwQZjGq\n", + "61J22eXTwTmTRd7H6ey9i5mWaN4ntkHnzJJrWQy2hsfRs3GhtMs4wcVCO+iaBn8fB3MgoWw1j9V9\n", + "laLy+sOVod05NRpNi6A8N03rNkFCmEbCM0vAzbKvIh/6y30rPf6dopCFPfdhN6kAr+ie4JcGWQlc\n", + "aLOBkz/bGHahtIum0ce6NhspzOnP+JCFZCb645FcxOJjJ+UjtudW9b60H79Go9GUQ5AQoQGw4ntw\n", + "O9papVywpEUuy4e+LL/+ie5xT/WayKTvekO6C9gXwz17IDaSHb3B25KxE9RK3rZWrl+Q+NPYU7y+\n", + "8QHsYz5WqZnvaEX+7nxmHciR39XkvrQfv0aj0ZSDH4QPMVb6o+ZA3DvQIUsds/WhL8+vPysrKee9\n", + "n9K4bzfcPRNyHWBtdxgAWZvBFApPeoBreRHAQXEELwP7uYchsifM2wpfpOM0tp14V4iQRyqLQagr\n", + "tODXaDRXBZ4lyTdpmwMXXUsE/5U+9IZff6sk5UZ5YCawOPAgsemwhTFJsP4j6P2EytDZ2YPC2Ax5\n", + "RWBYWWMAeHSHmjQsOLnQiS6mTiRZEnGWBI/V/s6vRBt3NRrNVUEG5E4Bngfa5ECKscaf5orMcaXX\n", + "bdb+9775bZlxPzw60Mp/HjLo5HI/4gyAbwbMilP59DffSWpVxwAw9AyMTSzZn3VpEMy4T6VvBurC\n", + "V78itODXaDRXBYmw4BM4EgxcyIa33WAy5LbNJ3NtDj2Ww/hnuhGcci8ruHPDYC72ggVH4Jd/Xu6j\n", + "mCCn7wg6FQrRYbDu0G/EICDXh0nCLLpUZQxzVbbNy9yBa0581t8hcSx02WJ1pHa++hWhVT0ajeaq\n", + "IFbKyCAhOAVPZkmG7GrLeX8o+F8RQxNaw+23QrozmDfhNn+FU9b+nMN2kjZWi+O/AlNJ42BWpNx7\n", + "2RAszCIFlcL5ReChqowhFJ6kNb1TXXHdfzrwVCbThvF9KHXpq18RtV7xCyGmCiHihRCHhRDPltNm\n", + "gXF8jxBiSG2vqdFoNDUhVsrISClDTvfh84NTWOoNGQA+GfDCejjwX5i7E7q0znJ3Cf7Rju5jwXEO\n", + "MAu4CPwMnHW36XY3qj7ATGEWvao6hqh5BG1+iKK0cWc/U7761kK/9r76FVGrFb8Qwh54G7gBFXm2\n", + "XQjxg5TygFWbUCBQStlTCDEKeJd6KCWm0WgajiAhQv0g3BNcMiA3ERZU5AffBEkB2lh07q6FcPPB\n", + "koMBKbBu6EXEgN+RSRdg7VdwbqBx9AFfIYJCrQyv8aiyi/nAS8DtVRmAkV30Ra5Pns2GTfOQoRXG\n", + "INQltV3xjwSOSCmPSykLgC+B6TZtbgaWAkgptwLeQoiOtbyuRqNpJIKECB0D86MgeDml89I09tiq\n", + "wUWgbVk69+eAvWPgh2Uw8K1BcPxRuGcKdF1ntFjS2cbwegKIAwaikrFVR6uxFGiNab9DOTV364Xa\n", + "Cn5flG7LQpKxr7I2lRpBNBpN08QPwt+HwLMecKCd2meTl6Y5kAK0iZUycjPMsxhrQ+BCCLB+LUw+\n", + "Ct6FbrDlT7DgMJy81ur0UobX40Br4FtgF6pAe6UIERRKxNSVfDWqmFSXz4Vz3xsrP6tuqK1xt6ph\n", + "v7ZRZWWeJ4SIsPoaI6WMqcGYNBoNZUeeVnUlaaQX6AB0s9q6A93c/sg4N3fwzIfxx2HFCnVOuYVE\n", + "miYXgbagdO4Y/vdBQoR+AvPHGRG4zhiO/vmeNqeXMryeQOXlvx3YRr4oEn2GbuVgYE55z71UgFis\n", + "hGGTYEjOh0IEza7sNxJCTAAm1Oy2FbUV/KdQ5cUs+KFW9BW16UI5meiklBG1HI9Go6HyilKGYG9P\n", + "acHeDUO4owRZFmo1a9n2Aj8MXIH7L+e51r2g9DXLKiTShEkB2tjutPa68QDXMxx2F9zvK/m4c0mr\n", + "KwyvJ4Bu0iSPipva7OJcn9FcI0ZycBlqzVtWMJYRIOZ+XqWCXv0a3HFzB/b0/yOVBIEZC+IYy3ch\n", + "hKm6N19bwb8D6CmE6IYqejwLuMOmzQ+oIsVfCiFGA6lSynO1vK5Go6kQQ7C0Pgqdfwfv4+DtFEin\n", + "Ux8Ls0hGCfccSgv2/Sihcww4YeSRv4KgCMEfYb5tXpryM0w2PFUwPl+kDMEPpd8AwDKJVmh4PQd4\n", + "CrNw4+cbnCmI9mD4YOi10sihvzhQnW8t0I08+7Nmwq8vqzTQxyfAhB096+gRVEitBL+UslAI8QSq\n", + "uLA98KGU8oAQ4mHj+CIpZaQQIlQIcQS1gphd61FrNJpKMARLtxjouRJSu8GFPpDU6xz+2+5ECfb0\n", + "mvRsuyouLy9NY2ExPltPTHMhIEgIrMaYgqHqqYyyavSWOm6SxcIsEoGu5LcuBnv48X3Isy6qaxuM\n", + "lZELEtrHQXJ/tWvNK/BoT19hFh2Nko31Rq0DuKSUUUCUzb5FNt+fqO11NBpNdTAKeOx6QG2XiUqS\n", + "e+S+2vZuuypuSvhB+GIIvOAGbbOVsmUxBIYq47Mas7nfdfztgJtwnLmOwpycOkiKdhzo6sAFz0KA\n", + "pDE2h22DsRIX0OrOXhQ7dCerg9qV+koCKY576VxkAh6rxVgqRads0GhaJPVTwKM5YEmENvgROO5d\n", + "st9ifBYiKBQ5dj45HQQu/x1X0wLmQgSFChESLURYDAc69G3zo9Nj49nRKYBZpdtx3xnb5y5lbCRj\n", + "Vn9Aet6ly4Vf2BJO59y5wG3CLHrX7O6rhk7ZoNG0QKSMjRQiiEp00y2SDMi96AoZTtDNKnVaifHZ\n", + "sH9k9wfXFMjsTNl6+PK5wnh+5u8EHHu14y9kOM7rEcmvySNom+GOC1nsJykzkcHhQoQ9Y/HyAaBN\n", + "v3v43dXi+XP5txFm8TqpjkuECMmorzTNWvBrNC2UynTTLZVEWHCXL0EDzuNr8SMvbXw27B/HJ9ic\n", + "WZ2kaMbkYZ8HfpsgtRtudu6OkI1Lj0zu8tnB/22ElXhwGzd1gc+tjLYzB4C3IGWJxVPIp5Tnz5u9\n", + "DjEnaSR+f3Mg8RqjSd2madaqHo1G06KIlTJy4xhWJqRzMgzWhUJ06UpYhv0j8r8lhlWgeknRjMnD\n", + "6yTcche030eWcz4A2Y7gZri6LqAPOXzuiv9GcMowzu3nA0s6478RHI04ARYHOtDhJQDSezzCmncd\n", + "mPI0JSFPdZumWQt+jUbT4sgKwOlsEK8sl3JCpJQhpT2O6sL+YUweKT3h4xgY+BnxY/K5E+dsa8G/\n", + "y86jCICJL4DfZuNcB/A4C7fPAM/Tl3tsA/1U2gtPF/beBdltoZV1WFTdpWnWqh6NRtMSGQS8V9aB\n", + "iuwfVU8+l7gA5gbA4kAu9oIlG8n8Y3eizjv87tCKwF32pH4DJ1Lsiv0pph+nRqqCLglTgEKY9Ffl\n", + "bZVSogEaQoarHTwZR0Yu0h6++NHmmnWXplkLfo1G06IQZuEA9AFiy2tTlv2jIv9/UG6ilgmhPyyI\n", + "g3mXJ4+0zBwKxbDU6wtbA7kXAnlebpPfChEUisddyzg104PBH6tOfTfkEbjNmbdLXPUDCONJ4lkK\n", + "rpD42uVJ5TJ165GlBb9Go2lp9AaSpElmVdrSQIig0NF4LZ3vmNbu4/6wpjv871vl/z8FXuoKXrYT\n", + "AsTNi5Wx1gVZ1gJvAkvtMzEFO4hHbgPn/bmJJw/kxfYs9ou3Q9ycx9QLbu5x3siOk/DMdGdwShZP\n", + "Es80Mvkv5DSER5YW/BqNpqUxCNhTVbWNEEGhdOr5buKQlHZ+A9IYnQQP/w5SgJDgCT0WCVq/MAEe\n", + "3KVcRK0DwizXmdyevvkF/GP3ODIcOtLLcRaDli4H18J07ji/N3eZsHOUo/LccDxHVlsPXG7bydEF\n", + "xbgZ47D2PKpvjywt+DUaTUtjUNuN5FSWtkGYhQtwK494LKTVGe/iQ2nsXARd02A9qo6iA5ADHr8C\n", + "dhKGPQR37oO/rQePLFxLqYeSAeh4RwzFEx2wWzcB5oXA+z/CF5m4RF2QpI3fDp+thJCbKYwMY3zB\n", + "JbzYmuZE6uaGTHuhBb9Go2lpDBywlY6LIfC0J6ztBnftK1mlC7NIAB4G7gF2cr51Nh553hkb/skz\n", + "ae/xOAmsAl4p6c/xeQnBMfD4dvjHddDvcXDfT5e+kTy1uJjANd1V+ca+F+CLdOz+5AiffAupLlaj\n", + "srOHQidIGg1tCnE5eY54/kwmdpuljAyhAdHunBqNpqUxqHUOeQDP3gBxHSDPHr4Mgi1zGQ2sA/KA\n", + "UcAWup1vzUcbyLz4FyKZj5m2vILyoN/uozp8BVgNdMiCt6Jh0mJOnOvG0QJfxgFs8oP/jiwZgHOx\n", + "ekNoY/jhJLSGjHZSpWD2PAPFDgzLKmYI9xfakx0oRFiMSv9QvbQRNUULfo1G02IQZtEecM0pJG2T\n", + "H6zuAdkO4P8nWDwUOu/mOOCP0uS8AITyTec5XHz9CEAm0ygiiD0dYcL98MiNkGvoRfZDiiUgbP8l\n", + "HstbKKfYn2crwN17YVl/yLdXbfdJu1LFpsZNccd5yzXYeR9iQIepeCQXcZaj7ON6hyJiAmH5+Jrm\n", + "DKoJWtWj0WhaEoOAfZv/wM7xfZjsJrFzLIYNH8FrF0k4B88zDWfgK6AAmCCPHcsSIigVQp/Ew97z\n", + "wMRNw6b0xuWltTBnJ9gbIjwHtkVKWUolcyaPV+/EecXnqXlufS5AdCB8eg62ZTwjRvNOmiey+GQP\n", + "vM52zLP7w9eJxPYvYmr3fRxKhh0EkMoycD8PSMjqSHVzBtUULfg1Gk2LQJhFN+BZYFjaIDqKPM6M\n", + "/DdxJwpw/qNRMyAugl0oVc8O4DFpkoUARMT9DHHdgIi0c6y+9R36P5xND0vf5RWaiZUy0luMShhB\n", + "6wFpe49y/+gjFORLMr+cwgXOO2H3nishAwnYfJSvCo9x7ynY0gXc4iAQd075bIewW2GdySp9dt1F\n", + "6JaHFvwajabZYgRr3Ygy1o4AzgP/AeZIZ6atzpe/W7XtC2wGPgBekSYpjf0TgAXABWBS7jtyX9C7\n", + "IrSqhWbSaHN6B1EDiLsE09pDsR3INcCHrgxfAC6p+B71Bs4TEQN33AI9kuE0mTDpeYh+C+L/YNVj\n", + "3UXolocW/BqNptkhzMIPmAM8CJwgrtVmvgvqQKfiQQw89zSu2el81a4jpsvtrwW+Bp6VJvmxsc8f\n", + "eB0YDfwZ+NoyGVSv0IyRviF3cSAZncA9GTiSi9sFF8a/BBf7kH3RBVhD90twqC2MTYbbOEjCJyEc\n", + "pUToO3Nndl4D1EzQgl+j0TQ5lIHTL9w6Hz0RcauAqcAjwFjgcyCEiP5+0Gsx9PEh5x7oN86ed+La\n", + "wf99IETQHCLi3IB3gLulSf4szMIVeBoIB94GZkuTzK7pWEtF2l7KHYFnfhtI2c/EF4YSeydELSCe\n", + "lcziOP/xTMChGP6QBZ+QyQKiWMgIcnHnIDnZeSS+litP17svv5BSVt6qARBCSCmlqLylRqNpyVxR\n", + "5MTzNIwMTWH03kIc5XFgEbDMkpJBiJBoGBYML8PdU+FICGz5o+qszfgDhK9vhVIH7QH+APwbpeP/\n", + "izTJE2VNMjVNjyDMwgSY2NY6gqBsEwtP25Gjarp7OF+X1zVgE+dGFTsM/4hLJ2FVV2hb27rFNZGd\n", + "esWv0WiaGH7h8H4gAatg+CJVMD4urA2fOv8mj2+99sr2ni7gAA65Kr/+tsdLDrk6dAX6AR4oV/xO\n", + "wIPSJH8Fq0lGvBeItENV6K1F0ZNDHu0JyIS+Oc+x3aeI4mnHwC8JkZ6f+YfdY+P6FP8D8I2S8vFK\n", + "+6pHtB+/RqNpYni6gID+K+DIVPjPCfjpPTjRtbDs9hm5UAiFrrDqTSh2tDpUtB14ClgLfAcMtgh9\n", + "hVFJa+KLMPYNY1/Nip4IERTK/iG3gL3AtdiFmEOO5AVJ2P8aplXv0SdzC9AN2F/dvusaveLXaDRN\n", + "DKPIyQ8f2Owvz9slcQG4DoDnfS4nWhBFMPyaNIK3DQTigX7SJC9cea6nC20PqTeLd/da7a+JS6Vf\n", + "OLlzOmG3AdI7ge8OSLL45celoGIH7kHZJhoVveLXaDRNjOpVyFIqmUNzsVu3D+fgIrpfm89jXtlM\n", + "2JGEg5wkTfKRsoU+QHouIU/Chucgw8dqf01cKot86GeCLDf4vQcM/JfaLdzdgVDgW5TaKa76fdct\n", + "esWv0WiaFDXKRx8RdxpoB+z+//bOO76KKnvg35OQXoCEAKFJCTVROtIksVGiguISK6uyYN1F3XWx\n", + "rb489+euuq6urqIu4ip27KgBRZei0pEOgSR0CC1AKun398fMy3sJL8l7aS/lfj+f+bzJzJ2ZM5P3\n", + "ztx7zrnnAB2AOcBHtvDMSpmydgNtSy9l7Te+9o3uFT0x/ARhT9G6QzR9V8P+S2Hrv2FWNHz3IwRm\n", + "BIVu4fCg5Xy0+k6CLn+Wd2MSpZLKXg2DVvwajabR4U4+erHKVcDHQCmwBHhGWVSOC8cFMZjp/Bz+\n", + "JKVT4mpS9MQegdQhiitTYd+lkB8GZ3vAqWHQ+9GC1v47ZPJiOkzvRMzTx2ExTKiYIrqh0Ypfo9E0\n", + "Cc4Lu5SDL2PZeSVGQZTVwO3KotLcOOXjwC9q6alngWdrJpUZgTRwHHQ9APN/Bq9SY9eW6TD0LwV9\n", + "VuXFLMjH56UIiD5h7HIs5FKz69YOrfg1Gk2j57zY/nbJcPWll1EgXvipu5RFzXflPLZqWcUdadvq\n", + "drX5yCcAACAASURBVAZ3+oQZttm9NSPEHymFUcmw9N+Q1c2+a2cnmJARGvRpaAlk0eMs9M2w7w6G\n", + "es/JUxnauavRaJoAZtilXxaMfwjuuASS5/jwwuU/uaP0R8FLSTDB6wpGPLsCn/FpWGJEapEGOTuf\n", + "IfOBIDj4jcP2lZD/RSmp15Hj18UbYPJumOjgss6Bes/JUxla8Ws0miZAiFHLKuF68D8Dc7fDmgeh\n", + "oK3LM1a7wux5EPVxNOxvA39Ya5hcuhkml5rRYc98LptdQkAxBAzHSPF/Yz7ydD686cXW6SSPUNxA\n", + "r3KHVZbts6HQph6NRlOvuFr0vKpjwxh50WmADxcZE7XKcD3sMgT8c31g1mQYfQh8TFN8rUwu9+wd\n", + "TZ53Cmfzwjn+y07TObwG1edxAFInkjPobZJkOsPVGwSzoTiAjB8asr6uM7Ti12g09UaMSPwIePMt\n", + "iLRtmwEXxYjMrE7xORYy/0/wdu7zvoHizI8dWrgXdpkN+Tf8BkTBJ5/Yt9fU5GKmeZ5OYAlccGas\n", + "UguTbb6IYLJ8+jGBoJICcj/2IxlfNrAEfCfCY989HZ1I6CSRJTV5GdYFWvFrNE2Mukwq5tL1rCKA\n", + "HxBayRJS2b6gexhZ7E1gJz/wL4a9L8FbEDkenqKaiBabaSY9GCx35XD3F0mkZA5nFW1OZ+Ozzp2w\n", + "S4A1U9hwtg8Tlr0NoQXGtpqaXMxn8i+M9AtblEUlm1LPDubaqHju5COOGm2BG0gjKfAf5ISdPiGF\n", + "fHr6NkLeXkrgMKMJDR3eqRW/RtOEOC+6BagsqZhYxQsjOVllCrtKpV2hTSmQBWSbn86WbOC447Zh\n", + "X/PZ6/kQUmBXthgn7FHdvYaAP0DHHPhhAUSfzAE2kADbFlYogVgdYpVwBvNHnwx+fO4ARXNrmRET\n", + "I9tnFMbzmeogtX9vvxcYd9FRYobD3G8h9gB8TBojSk4Wrb89O7DzanLj1hP4WAiEtYV7zzR8eKdW\n", + "/BpNk8KMbhn5IrTZD35Z4JcVRevDC8QqaZRX2IFALpUradv6CSC1kn1ZQLayKAe17TpXJ0pJPyfb\n", + "j3ckWKzyV4we805gj7KociaXbMgHo8ccfdK+3V3TjFjFG/gRyC0KZ1KSUkVu3cT55/PDqPJ1AnjN\n", + "lg5CrHIh0zr03NYzgxV74dUkGHfAflzHgtzkrp+qfxaM5q1jnWDBFxCZY0wmgIYN79SKX6NpUpjR\n", + "LUVBcKYXFIRAQSjI0SMkrJlNeYWdqyyq1IPCkgV7H4ehTztse8gLzgZwGCgGrsXQfb3EKoexvwh2\n", + "th9D0m3riXqn0B4SU0PTzN+BfkC8stRO6Zs8gKH0OwKvi1VuAu4FehCStSxmbtvrF2afPE+JF1Ny\n", + "JDqZm77eg9fTl8C4O2DHXHi6xIgFasjwTl2IRaNpQhhFRxZPOH9P/BKlktwyf9QHTiJ4VveBO6Oh\n", + "kzdQAmyH9BQo59wV3/7X4NVlDj7+bfHL9GP0tsMMPduWUvq13Qb91+AVkk/JuRKO7+3KS4enMV9Z\n", + "VFZ18siUtk8Rk/Uoh9qd4d0hv9bWHyJWiTRugQxgGzAGI+naXGCRsqiiThJmiSNvzgcUBNqOmwlp\n", + "a2D2AJizEGIBMgIg3FT1N0L+dri+oQqxaMWv0TQhnNv4Z6bBmtn16eB1BccoHNu2WZC6Gt7rBiMr\n", + "qzRVid8iFVbf3997h9dIxStvlXKBbc9NoRR8cxWlOX3JwBgd7MJhpKAs6jSADOk8i/EnX0MCvXll\n", + "F+RElp3X3WcVIxLfRZi9fgYjclsTVBCEN968CryuLGqXs/bdnBRrnySyZDGc9+IeDxu/V2qYOzLZ\n", + "0Ipfo2kBGIqym+uZKxsIm1J7/0IILILrzDiXeFiSVIUztmwUM+Y5GD4XigKhMAi89pxuU5xVekUW\n", + "7YKKoOcZeHKFeS34bkkid2OkOa645AG7KfAaRWGED7uuhxUWyG1vXtG90VGvzpLQthevHh9Gu2PB\n", + "8M/vYP02jmw6x53u9tCdvRxto4GaRvTo0osaTQvAncyVDYktCuecDyyJsiv+6p2Wpt9i/T2wYxr4\n", + "5IFvLgQ/eKiP3yrvaSW0y/UxXiaO11IWtR/Yj8OzMMMsOwPvc86vGL9CHzpugrsGw4sHQXnjapEV\n", + "scow4F7v25g+OplWpbnw1DK4YzMAnWsShbNdqaQYEeKdjAbcOU9t0Ypfo9HUCbYonLEH4elL7Nur\n", + "d1qaFbcKQ4yljNbpYSAJEFPxiMrOqSxKiVVuAELwKfbioy/hwLiKR1cqj1glAEjAcNZ2AF6/8hX2\n", + "vJvNgMOh0Cnb3ramUTimkvfoi1vn6tFoNHXCIXh5FqT2PQU5vnA4tCwKZ80kkSUJIssniSw5Pyla\n", + "5RW3bOcst6eKyB6xyqXAn4E1FLCKA+86PW+MSPwkkSWTpdXWUdLmZEjERclybZd9FMsx4Abgr0Cv\n", + "6ES2+mbTHaBLFng5WMY9mWSttmgbv0ajqTNsTs0NtzEsYhdHZB1fjIJbnTh87z/fwevcb1GZo7Ti\n", + "tcUqXYF1GOGhzwEXkhg9uOJ5o9kxfATMmScEJvWGucNhWScvSjdfS9GvXgfI2HWv7dqTRJY8ChO+\n", + "EXjOQVXeAXnrYZon8+3Y0M5djUbTKBCr/AnoMTGRqMUw4VQgvDYMnlhp7K/O4VuD6/kBKzHq2l4O\n", + "fKss6l8V28WIxHcJ4pPYwQS+Pgw65MLv18G0HXBtcVtOM5wU0jecVVuHAySILF8IsSuBxQJ+yghJ\n", + "XQvbvlfqorqSvzZo565GoylHQ+f1ceBnYHoInAVYcQGs7WLfWRezVMvd27QOPel8+hBtitKAm4FX\n", + "yrU1nL6j2t3Cm2ldCOy8Cwanw4Q0+O0Wo83FnOEpvudmAqJjROK3K5Vk81uMA8Y59JHj4Uht5fck\n", + "2sav0TRT7PHxiyfAwljjc9RLxvZ651egV5YXJQDLekDcfvvOPLjQub3fNcrd26BJsXRo05W3pkZS\n", + "JHOB3yuLKgYQqwSLVe4ENgHvRBwl796XYP4iuGIfbIq0n3NVZ1DAB5wLsOXod9fH0FTQPX6Nptni\n", + "ULWq9QFAQD0Yhc+OR8y8PqUYus7xs662FQPrtw5mxayNdFvdnai3vzSkegyYA2HjalV03Ly34HS4\n", + "8mF445/Q6usevHFFIae8H5OvOvdjytEY4BYME9CfgR8vWEbSFOj1OBCfDu8MNM52ezDcc9rICwT2\n", + "EUljCb+sa7Ti12iaLWZ8fMfNEH8fSKmRjN7nwDBgEcaI3wtD3zl+1sU2AUjvGxw3/3QvVOh2rjwz\n", + "iIgOuzk9Loe2R2DcqtpkpTTvLScS/v0GFK4C3oe+i3yJnzuBDqev4HDAJ3Q5N0hZ1CHbUTGJ8vK7\n", + "0OtWiHo1D37tALe2hZlnIM7h7I4RO40h/LKuqbHiF5Ew4GPgAoxJFAlKqbNO2u3HSBhVAhQppUbU\n", + "9JoajcYdzPj4A+PgtW0O2+NX1HdeH7GKsKjT46TEPqa6Tg3g4NucPfcNYedu4PXPk5hMTlnbmtn7\n", + "zXsDyN8A/AOmJUDQcVh/LyQv9qbk2jZKJR0Cew6hAeC/rxV5N8aSmdcXr1Z5+GX7kRkHEbbTVTTl\n", + "eNBPUn8opWq0YIRLzTHXHwaeqaTdPiDMhfOpmsqiF73o5fwFouNhZgooZV9+lwrR8Q1yfa8JP4BS\n", + "xN+nGPV8mQwTGOYokJoEi2t1b4H3GKfyyVXl73XacqUU0RB/Bxx13HmrL9n9fLiGRD4Kncbzk2Dx\n", + "NFg+CRZHQ7zT65QtM1Ma6hm69ixQ7h5TG1PPZMwsc8A7wHLgkUra6jBNjaaBUWp7kkgMEO+ZvD6l\n", + "oYZ+SZ0AJweUbc4nqGy9po7Ssnvzv/IBIrIu5wBeFAVWaJV9TqzSaVBvXhwZSuSfwuG+9UbOn3cL\n", + "Cb4UrxeSV3UrzQpUYxbTfwcceu78Z2P6ErovB+8CSJuAkUwuvsGKptQHtVH8HZRSx8314xjTm52h\n", + "gB9EpAR4Qyk1rxbX1Gg0buDZvD6mOWbPNeW2bqbgVALsqMxR6qppRantSWKVWDa28eXIjF4Uv2UP\n", + "GA29qYCrfo4FNh0cR/jak9AnA/yK7ceH4N2TtDe8uORvwOIuziuZhfjTZbVhRvrEsd6va/l+GitV\n", + "Kn4RWYpRbKAijzv+oZRSIlLZTLAxSql0EYkAlopIslLqp0qul+jw53Kl1PKq5NNoNI2ZQy/je/tA\n", + "Ct920CEz0zLJnr2wkqiYSktLhvT14aE9qUBfoI+5DAQGM/RsHr6fpbMqOZ2C1oWUnMuk897/0jfn\n", + "Y+DRYe9x33wn9cMKCPYifTB02IrRP3XSk+++35dpU+CLBbD/UoejK8/3U9+ISBzlfdHun8O0EdXk\n", + "4slAnFLqmIhEAsuUUs6qrDkeYwFylFL/dLJPKT1zV6NpVkhk1K0EhL3FvgtWQW61pqayFM1+mXDZ\n", + "XyB8j7GEHijFW+0BHJe7gS+B/1OW8opMrDIceBfYONZK9IV+DJxrdwfzGLCEwWziV/DJNSqaAZCw\n", + "QqmFceY5YiiWlXwZl8/2/zlE/DeO+gc2Gnrm7iLgNuBZ8/NLJwIFAt5KqWwRCQLGA9ZaXFOj0TQh\n", + "VHrqe2KVRFh/n7KoHdUfYYZpFgcYpSVT4iGjD2Q+/LMq+dTmU0SskgD4AH93VPpiFR8Mi8Q9wB+U\n", + "RS2M+Enm7GxNTOBXeAeXGOGFW2iVn8Jf7WUsTVpzKDpBZPnhSLxkBgOUj7qX7SeyPOYnqSdqo/if\n", + "ARaKyO8wwzkBRKQTME8pdRWGmehzEbFd632l1Pe1klij0TQtTvnu44ce30ri1aHgB2Tvg6NPOFee\n", + "pl+gxBfWPOCwPS/PtiZWCQH+Cdxsm6Frbu8HLMAoizhYWdRRsUpHLuH+sDVYdpYw1jYJazMha3L4\n", + "8la4qsykFMyNRe+zvd2ANsTG3gijvudE5nqytjfS+ge1QSdp02g09YZITDy9A97n6MA25L5pTCJT\n", + "XsCMdFg3s6Lyr6q0ZDQ76Aqzd1/DgJwQvNt/wKztSiWJVbyA+4AngSew9j+IumA2XkEBzFwaQ0nR\n", + "EvVm3i1OZTMzd7bmUPT7bG83MiCH4XfCQ6vg3vV1n0yuPtBJ2jQaTSOj62z29WtD8Qtw4Qcw+h/w\n", + "5looeSuy8pDI3Zlw9WnwE8jeC0efjGYHo+ClByOIGtcfts+FJ+ClXp2lHXcyHQgBRpMY3bvsxRH3\n", + "OJzLhPe6jZD5MfEVXzKOEU8JIsuvglh1Dt5cBJftM9rURTK5xohO0qbRaOqREH8CFdx8DYx9Br7+\n", + "j2HGASqGRNp7+yuHwjdh8FlbuKA1QFeY/R+I+sMko+5uxxwj3UO4H/Mw5hCNVRaVUhZ33zsJBi6A\n", + "z98HNT/K6NlXji0Lp2BX+tC0i61Uhe7xa5okzXIafTNDrOLFuKgILv4W1j4CH3/uoPTh/JBIU2m3\n", + "2W9E8qSNxxZiGcIO/yJvuHKvYYKx0eko25RFPW3fYjqHAzLgsw8dCqxXHXdvZuHsVbEIelPPwlkZ\n", + "WvFrmhyVxnqfN/lG4ynEKn2ANxm5z4t3Yk9wPL89OCr9O9LhYHmlGkZrRt8NAz6Bnx4zFT9AcEA2\n", + "5PuWwCM/l79OYQEny28xncNbp1eQqOq4++aahbMytOLXNEHMnmHntRB8DI4Nhsz/RMFV1U6j1yMF\n", + "93HnmYlVWgF/wkiD/BSBJa9y/PgE+MkKV/d0iOp50nYOsUqk33HekFneF6uND8EruyGvncNZc87t\n", + "C2LerTDqvVxCbVud98gPvQyzep3vHD5Ybc+9OWbhrAyt+DVNEHM4H3oEhrwJHTeBdyGcZqRY5TmM\n", + "ohubgBRlUSW2o/RIwX3ceWZilUHAfIxwyuHKogxruQWnClWs0h54hBJm9TxI8ePL/cSSu480HJX+\n", + "zDSity3dPY1nj29g/cQkVGgpPpX1yO35icY/BSE9oUBB1nlZg1s6OpxT0+Qom93pSHA69Jy4kalb\n", + "vwAGm0t7YCu2F8F/R8zg8E+j8T8D/pnGxCAA4pfUd5ripkrZsw5LgbwIyG9j7rE/M7GKP/AEMAuY\n", + "A7xTcSZtuXNapR3wkNn+/XEvceGKM8SVCrzcJpikM/0oJIhNFBZmjU1bTedzF5E09ADZEZmujNIq\n", + "eVmlwur7m+MLXodzaloITobzOU+ksbXkSbXF3gMUq7QBBmG8BOKYsmMQIW0gOxJCjsCOG2HjLDjh\n", + "G9zw99BUMEdXlz8OUYsJTvam31ohpCDvsnHhkrw1ll8YSBywGbhIWdSximew5cL3CSJ4cxwdGUJ7\n", + "vPkAGKQs6lBCoiwHyAiA+TfmkBa2gegTEHS2lW9Wq9DRrIjNIvfzQcZEXah+lGaaAgF8c6AwmOaQ\n", + "UbMu0T1+TZPEcfKNq9PoRSYtodXnE+iwDfp+BSNegRI/8MsooVVpKnYT0SZgk7KoUw1xL40Zx9FV\n", + "MN8QL7/nY3WAbF949AqYPwDFWTLzu+CPUXsjGdhtLsk936DbmDP8Pepier58MUxJhuyf2b/zNPfZ\n", + "zDSTRJYshrIRXK4PbO4IN/XowKHwCOhUYpSOnLfeIb1z5aM08b9uJX1+cwkD34V2u+ClvaC8cczD\n", + "05yoie7Uil/TYjjPBOCbDdddmEOPgxn4q9lAG+xmosFAJvYXwa/m5+GKZgxbjzYE/LMh/xC83Fyi\n", + "QRyf2TAmsJ7vWd4dbrsWrtgLz38Pt+SzZHEiU4HeGNkz+5mf/aWEQXjh1S4XnlsKt28xzus4IzZG\n", + "JH4UvOQYSpkgF7BYvUoO64FE439VHAClNiNFeSVuzt6NA6ZT4H0rB8e3YstvYfdk7Hn6m6dJT5t6\n", + "NJoqOK8wSWHOORYG/RuL6ozhlPyTsqgHoUyR9MD+ErjH/GwlVrG9BDZ1+oqQScKcN5VdadW8gHjj\n", + "w/GZtWbdKKC1XzHMX2QofjBmtyqLOofhT9kqVgkE7gWubL+XUwt/pn2JGAVQbDjOiLWFUo6i9Tt+\n", + "DGqXiz/J6g/kcBWw2mhUGFJBMiM8U6zSH5gO3IrhVF7AR11uZ1/nRLjR7cieloLu8Ws0gFjlImAh\n", + "hqb5vbKo3EraRQJDMF8IftlM8vUl4KLjMPKw0QOGppHjxV0qmmQAVgJ/h1MhsCNLKNwYy95TcUwG\n", + "VgGJExN5vuIx4Pz5OHfKXpcObYG37GmR5Xf7if16CXEnhwGdgfeAd5VFbSt/LvdMgU0VberRaGqB\n", + "WCUYmAsMBRJcSSOcILL8DX9iN3eEQ63ht6YpIwFWLFQqrj7lbWgqmmRWAu9C0Ty715Vbgsn9qQuP\n", + "HNylXnF2DBjx92vg3a4wqqJ5zJnCBkC63E+QTxdaZ7Tjkm1B9Mv5wrg8PzqG7LZEtOLXaOoAscrt\n", + "wD+Ah4H/VhWa6KwXDM2zxw/QO1ymhoXwx+II2maG0H1kWwL3hMMZf0gxDSkV7z1GJL5b+Rmxa0bB\n", + "rY4vgxmQngpHO0KO7UWwI5HFwGjgt8BvMMxr7wKfK4vKbsj7bsxoxa/R1BFilQHAJxjK5m5lUTnO\n", + "2lXRo53dVG38ZjGT7thLHDqWOwwDUoGCbpsZ9NQ+WvXJMOrZhptJEaoa7YhVZOwrLJvdnth1nWFC\n", + "mt1X8ATwVyCtLUwdyultIyhUvpzByLH/vrKoQ/V2000Yrfg1mjrEdFL+GxgLTFMWtdVZOyc92kaf\n", + "40WsIhiFkpwp9+7AUewlDnebn6nAGIy89+mXPUfAj3kMr3huxx6/WKUtMBwYYVt88wibeBCfEUdg\n", + "6i7obwbN3hUEO26APeFw0zZYs5tV625jbFUjLo1W/JpGTFMOeRSr3Aq8iFHSb15TUkRmtSpnyr0P\n", + "Ririisp9D5CmLCrf4RxewPVAIkaI6xPA/6ITmVRxtHN7Kw4njeXbk3EEYyj6jsBGYJ1tmZDIvCVO\n", + "zGM3tYVbImBCKviUNk8/SX2gFb+mUWIzh/wHomz/4FmQuhrub0LKvx9G1M8O4C5lUVkeFqkM0zTT\n", + "E+cKvjWQwvnKfY+yqDOO56n4cj4ovLzTgi9GnexCDIX/nbIoZb4M+rX/gZm9U7jez5uwbH8Cdw9h\n", + "X1YMPwBrMRR9ckXnqzPz2GPARGCcQ7vm6iepa7Ti1zRKbA7QO6bA6q4w4KSxfJ7Lll2TuAPYrSwq\n", + "r9oTeRixSgBGz/9yICE6kciGGsWYpplOOFfu3YDDOO+9H1EWVVrd+R2VsQKSesP0KyjIDOVIaQAP\n", + "YExgG+GwDANO4tCTx5jt7FLhEkfz2FkIDobIz437A5q+n6Qh0Yq/EaHT/9pJEFm+EGILvCElHHZG\n", + "GMvrXTh5PIrjGD2/o8AuYKfDktyYetY2xCo3SjFvDP8fBWtWEVHdKMbNtMatKW+OcVTwOThX7nuV\n", + "RRXU5p5sL+fNHeHuq420Cdbl8I9MTqy5k2KMZPq2Xvw6YL2yqIzaXNORpugnaSxoxd9IaGnZAauj\n", + "upBHM4d7L6A/MMBc+mNM/T+N8RJwfCnsqkulUxPGRMrKc1O4pNdpo0Zra1PtVjRPOP0ueM9IZeCS\n", + "55mcfozzlXswDuYY7Ao+RVlUnacXFqv4AhfFv8gH32bSOzUMNnSChB3gpeCaYHZ+8xBXA/ubkm+j\n", + "JaFTNjQazOyAU2+BnI6QPgTS/xjF6QdbZHbA6sraKYsqxp7Y60tbG9OOfAH2F8JI4A5ggFglH4cX\n", + "gcP68YZQUJ2PUbpgPjwVC4Xe9u3nF+c2vwv9voCh84ySgqGHo8iVF4BlGEp9PfC+uX60vuQ3n2cU\n", + "5U02FwKpZ/0JIBOiThuLjZIcDpbl1dc0G3SPvx4QSVgOC2Pp9T1E/mpfQvaX4FOyFsNe+mu3Dwjs\n", + "v4fJoeDX1CJd3KUuh/IO9m7byMD2GQ14UWF0YH4eqkyh1sQs5+rErbLvQsfNEHrIqAFwtgeU3Frv\n", + "mSLFKh0pr+SHY0Tl2Mw1a4FflUXlNsf5CC0F3eNvNJh1P9PGO9QNBQIvX8ac/z0NDGmzkemjjzHm\n", + "Q4dCpLf5MaRbtPztUAKvO4bTQdMOh4S6LWtnKvAj5rLUcZ9YJYLyL4SrzPVQscouKr4Unu7fD8a8\n", + "6G5VLteLc5vfhWODjKWMqmvAuouZbmIo5RV9CHYl/zKGXf64s+NbWs3Zlo7u8dcDzm38M9NgzWyb\n", + "MrH1GL/rBaEFMPwotCqFkd3IXjsDH2APG9qe4JcLO3udC/KNKMiInK92Bl6FMYG0qYVDehqzKEt/\n", + "KvoRir26cepCL072h+VWt6pyuTKKceW7UIN78QFiKK/ke2Jkx3R0wKZpu3zzR/f4Gwnnpf91kh0w\n", + "BPzBiG55ZxDsbwPjDkB2OseBBBZ2iSXtsscoeCeiFDgOXBd6A7Mikng1LYd5EBUPzc5nUF8jG9Mx\n", + "upqyPL8G4n/dSsL+cgkRuyC/tcOe4Aq2+vNxZRTjynehKkyzVg/sCv5iYCBwALuCnwtsUxZV6Mo5\n", + "NRqt+OsJ84dd6Y8725g1yYNrjOVEECzrDvfH4A98ztXHI0kt8WPv25B2JWR3pijrY7acGw5sAJw5\n", + "Eps2zuzM9Z7bviA/j/ShkD60wo66M8VU911wxDRVlUtxAJzDruT/AmxsjGGumqaDVvweoqKNuH0u\n", + "LN1BWrsdzD6mVJK0n7CGrrEXE7UYAk/BqocAaFUUVHaOHEMhNBu6wux5EJXlZyTqGnyMBhjZOKnf\n", + "20BFO8xcQEMor+TDMaJ81gH/AWYqizpa37JoWhZa8XuIap1pJ73OcnIW/Dqr3HH+GPVBnDsSmzY2\n", + "89emjjAtARZ9aBQ3qc+RTW1NMa4iVvHG8Cs4mmz6ANsxlHwSRi6cPa7MtNVoaoN27jZSnDkF/bg5\n", + "byBJaeFkHvFExEV9z0YeL7Lxe6MHzLe94Y5rDeX/5GE2fq/UsLq6Tn1j2uW7Ub4nPwRjdrJjKOWW\n", + "2s641Wi0c7cZ4awnWsDBf69VZz3izK1kNnK1YY/ukA/qMeBvwFUp8PaXcPlN0OtTAqs71pOIVcI4\n", + "3y6vsEfY/B+woWJSNI3GU+gev8YlRCYtgcUTCN8N4/9shD1m9IG819dxw6apuDDj1DR3tAe6OFsC\n", + "shjhfwT/futg3EHwKYGQ3vCXqRQVBTBOWdSa+r3H6kc0YhV/YBDllXwkRuphx1DKwzqUUtMQ6Fw9\n", + "mnqjbAaq/1novsxIPRCeApGfZRJ5Nh8jx8wB4BhwFrCZMAKwK/tIjNw7h50to1/jqR8yuCSguPy1\n", + "B17Exq1T6QZMri/l73REIzNTGZL0PNekF2BX8gOAZMpnpdzV0uu+ajyHNvVonFJb27xYxZeIsULA\n", + "TxB62FhCjoL/GWhVBFCCMQO5nfnZESN1QhBGlEoJkAb8hKE0bfnhUxxLGsYkyjOzIbLibNiSrTzJ\n", + "VBSwSKwyRVlUuVj8usHMqRO+Bwb9F7qshciNURQWvAB8haHg3wM2N0QKaZ3dVVOfaMXfzKnONm/m\n", + "mO9MJeYXcwnjzl/OcGJqPmcu8yeri5Fv5uiWYxwLfI7Lcj8BjpnJ1spf33B0tsOefbI3MM1cjxKr\n", + "nMWWiTKRlIwkPrxyC3GtC1F5ijxHJ7ZY5TbgK4lr/wwrho6vW6UY4g9Aq3NQ7A+//BmODoe8e9cr\n", + "tfDm2p3bPcr9z6QElDd17U/RtGy0qaeZU2ab7/M1dNxi77GHL8smPK8Qw0RzhErML+ZyQllUiaGQ\n", + "utVZ2KOZLbIz9heCYx76btjrvtpGCHvY1HoCffNn88Eybw6PMs9U+5TXZc/pPKpP3VDXiExcQo85\n", + "Exj9PJzqB9+94DFZNI0fberROMHsyYanGL3ZYwNhz1WQn7uHGcsnAadcdUK6MwPVpfMZ8eqHzOVH\n", + "x31mPpru2F8K/YEpbOk7hh1Wb26aAh9+haH850URdLlFrLIZSK+ZU9VzE7lsmPc8jd+HjEHdZ0za\n", + "23aLQ4vq00hoNK6gFX+zx8wOufqPFba/dlJZ1MmGl8c1lEUVYfT0Uxy3S2LCcpgYyxcLIPiYfUeo\n", + "9AU2AYFiFdtxtmImKRgTo07jhBiR+Ikw24fkcyf55NQu+qZnEn6kPiZyOcMsiD4TeADYx8rujsie\n", + "8wAABthJREFUe9i2eQjKq0LLus3oqWm5aMXf7PF8T7ZuMV9kqRPLb073Xa0sapJZutDRbDQRmA30\n", + "EavYXiZlFa46LKHDRF8eeLuQXoYPOpNZrDu7ug4nyFWWeE6s0tmUbSZGeunfKItaL4kx8XCXk4ye\n", + "TfV/pmlsaBt/C6CubfOepKZpjk0ncwTl/Qi9A04znhCCw87BA2vgoVVG+4oFVWqKs8Rz13bi4OLr\n", + "SSkMZwiwAHipYpWr5vQ/09QvOo5f0yKoS6WYILL8IyH2cKjxd7dMczusWKhUXG1ltdVdUMCPPeH5\n", + "0bC1A/htY8/+0YzUs3k1tUU7dzUtgrp0MmdDvpeyK3wbdZX51JZ4LrkdPDAR/rQKvvoQppeQvu87\n", + "rfQ1nkErfk2LxvUSijXDVneh/ynYNhds3bLmllJb07TQil/ToqnvWrOOLxab0m+OKbU1TQtt49do\n", + "6hlXavNqNDVFO3c1Go2mhVET3Vlxhog7F5smIjtEpEREhlTRbqKIJItIiog8XNPraTQajaZuqLHi\n", + "B7YB1wErK2sgIt7AKxiTaAYAN4lI/1pcs9EiInGelqGmNGXZQcvvabT8TY8aK36lVLJSak81zUYA\n", + "qUqp/UqpIuAjYEpNr9nIifO0ALUgztMC1JI4TwtQS+I8LUAtifO0ALUkztMCNDS16fG7QmeMBFw2\n", + "DpvbNBqNRuMhqgznFJGlGEU1KvKYUuprF87fODzHGo1Goymj1lE9IrIM+JNS6lcn+0YCiUqpiebf\n", + "jwKlSqlnnbTVLwmNRqOpAZ5K2VDZRTcAvUWkO0ZRjRuAm5w11KGcGo1G0zDUJpzzOhE5BIwEvhWR\n", + "xeb2TiLyLYBSqhj4PfAdsBP4WCm1q/ZiazQajaamNJoJXBqNRqNpGOo7qscpIhImIktFZI+IfC8i\n", + "bapo6y0im0TEFWdyg+CK/CLSVUSWmZPctovIbE/IWkGmaifTicjL5v4tIjK4oWWsiurkF5FbTLm3\n", + "isgvInKRJ+SsDFcnM4rIcBEpFpGpDSlfVbj43Ykzf6vbRWR5A4tYJS58d9qJyBIR2WzKf7sHxHSK\n", + "iLwlIsdFZFsVbdz73SqlGnwBngPmmOsPA89U0faPwPvAIk/IWlP5MaKhBpnrwcBuoL8HZfYGUjHq\n", + "2PoAmyvKA8QDSeb6xcAaTz9rN+UfBbQ21yc2Nfkd2v0P+Aa43tNyu/Hs2wA7gC7m3+08Lbeb8icC\n", + "f7fJDmQArTwtuynPJcBgYFsl+93+3Xqkxw9MBt4x198BrnXWSES6YNzUm1TuQPYE1cqvlDqmlNps\n", + "rucAu4BODSbh+bgyma7svpRSa4E2ItKhYcWslGrlV0qtVkrZMuuvBbo0sIxV4epkxj8AnwKNqR6y\n", + "K7LfDHymlDoMoJQ61cAyVoUr8qcDZjkeQoEMZfgoPY5S6iegqtoNbv9uPaX4Oyiljpvrx4HKhHwR\n", + "+DNQ2iBSuY6r8gNgRjUNxlBGnsKVyXTO2jQW5enuZMDfUUfFWuqIauUXkc4YCuk1c1NjccC58ux7\n", + "A2GmeXODiExvMOmqxxX55wHRInIU2ALc30Cy1QVu/27rLR9/FZO/Hnf8QymlnMXwi8jVwAml1CZP\n", + "5NKorfwO5wnG6MHdb/b8PYWrSqTiyKqxKB+X5RCRS4EZwJj6E8dtXJH/X8Aj5ndKaDyjXFdk9wGG\n", + "AJcDgcBqEVmjlEqpV8lcwxX5HwM2K6XiRKQXsFREBiqlsutZtrrCrd9tvSl+pdSVle0zHRUdlVLH\n", + "RCQSOOGk2WhgsojEY5SvCxWRBUqp39aTyOWoA/kRER/gM+A9pdSX9SSqqxwBujr83RWjZ1BVmy7m\n", + "tsaAK/JjOnTnAROValSlDV2RfyjwkaHzaQdMEpEipdSihhGxUlyR/RBwSil1DjgnIiuBgUBjUPyu\n", + "yD8aeBpAKZUmIvuAvhhzkRo77v9uPeSseA542Fx/hCqcu2abWOBrTztZ3JEf4w28AHjR0/Ka8rQC\n", + "0jAcXL5U79wdSeNyjroifzcMJ95IT8tbE/krtP8vMNXTcrvx7PsBP2A4UgMxsvcO8LTsbsj/AmAx\n", + "1ztgvBjCPC27g3zdcc2569Lv1lM3EWZ+SfYA3wNtzO2dgG+dtI+lcUX1VCs/MBbDN7EZ2GQuEz0s\n", + "9ySM6KJU4FFz213AXQ5tXjH3bwGGePpZuyM/RhBAhsPzXudpmd19/g5tG43id+O78xBGZM82YLan\n", + "ZXbzu9MO+Nr83m8Dbva0zA6yf4iR+aAQY2Q1o7a/Wz2BS6PRaFoYnorq0Wg0Go2H0Ipfo9FoWhha\n", + "8Ws0Gk0LQyt+jUajaWFoxa/RaDQtDK34NRqNpoWhFb9Go9G0MLTi12g0mhbG/wNCBunWNpTTeQAA\n", + "AABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "modelNN = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelNN)\n", + "fwd_NN = generateFwdTest(environment, modelNN)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -320,6 +1072,733 @@ "To perform a forward prediction of $m$, the Weighted Nearest Neighbor model looks for the $k$ (parameter) nearest neighbors of $m$ in the dataset, and returns the average of the $k$ corresponding $s$. This average is weighted by the distance to $m$ with a gaussian of standard deviation $\\sigma$ (parameter). It finds the $k$ nearest neighbors (with the same algorithm than for NN model :[scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html), with k = n the number of interesting neigbhors ) before weights them. It returns the n-dimensional weighted neighbor $s_p$. " ] }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEZCAYAAACAZ8KHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xm8HFWd9/HPLyGQhB2iCCGAQkBAYRDZRDQID4SMghv6\n", + "sArIgAskPPKouAxExIVxVBZHNmURlLihwgwGfdSLDAQlyqaAkwCRkAQkJAqaBAL8nj/O6Xvr9q3q\n", + "ru7b1Uv19/165ZXb3dVVp6u769fn/M5i7o6IiEheYzpdABER6S0KHCIi0hAFDhERaYgCh4iINESB\n", + "Q0REGqLAISIiDen5wGFmL5nZqzpdjrIws2PM7JY2H3ORmR3UzmP2IjPbwsx+bWbPmNmXCjzO/ma2\n", + "wMyeNbPDizyumf3BzN7Uyn22mpkNmNn7O3Ts2WZ2bfx7m/ieWBuOW/M72dbAEQuzKr74Z+MH8RUF\n", + "Hm/AzFab2daJ+w42s0eryvSkmU1M3Heymf1qlMc+2szmx9e51MxuNrP9R7PPdnD3b7v7oe0+bPzX\n", + "sPj+vaXF5elWpwB/cfeN3P2jBR7nXOAid9/Q3W9s1XHN7Goz+2zyPnd/jbv/epTlLVrTn88WHTv8\n", + "4f5YfE9qlsXMppnZ4hYcN/M47a5xOPDW+OI3jB/EJwo+5j+Af62zzRhgVqsOaGYfAb4KnAe8HJgC\n", + "/AdweKuOUQQzG9vpMjTBgcJ/gXWJbYEH23CcbYAHOnDcUjOzdTpdhpZx97b9Ax4F3pJy/zXAR+Lf\n", + "k4GXgA/F29sDTye2/SiwFHgcOClu+6qM4/0KOBt4prINcDDwaFWZPg48DWwc7zsZ+FWTr3Fj4Fng\n", + "XTW2WQ+4AFgS/30VWDc+Ni2+to8Cf4mv9e3ADOB/YjnPSuxrNvADYE58nb8Ddks8fhawMD72R+Dt\n", + "icdOAG4HvgIsBz4b77stPm6xbE8CfwPuA3ZNvM5vxTIuAj4FWGK//w18CVgBPAJMr/O5OCuWbwVw\n", + "JbBe4vG3AvcAK2N5XxvvvxZ4EVgVz/lHgasb+Cyl7jc+thXww/j6HgFOrzrn3yN8bp8B/gDsmfHa\n", + "3gA8BWwdb+8eX+OONba/C/gr8Ftgv3j/1cDzwHPxtaZ9j2bEc/gM4TN0Zo1zfhIhOKwA5gLbxPsf\n", + "rjqn36k+bvxcVD5Xy4HvApsm9v1G4I54Xh8D3gf8S9V+fhK3XRT3uVU8ZnI/e8RzN7ZWmTNe3/eB\n", + "ZfE83grsknjsasIPuf+M5+pOEtcQ4H8BD8XnXgwMAO/POM5san//FgEfI3x3VhN+pO6bOD/3AG9O\n", + "bP/KWN5ngJ/F418bH9uO8HkeE29vBlxFuIasAG4AJsbjvBjP8zPAK3K8Z8cBf46PfZKMa/Xg9s1c\n", + "HJv9FwtzUMr9JwI3xr+Pji9uTuLD8qP493TgCWCXeIK+Q/3A8X7gy4mTnxY4DiJcJD4b7xtN4JgO\n", + "rK28uRnbnBs/OJPiv9uBc+Nj0+LzPw2MjWVZDnwbWD++9lXAtokP7vPAO+P2ZxIudJUv27uBV8S/\n", + "3wP8Hdgi3j4hHuvD8QM9nuGB41BgPrBRvL1TYl/fAn4Uy7Qt8CfgpMR+n4/n3oAPAEtqnI9FhC/W\n", + "ZGBTQtCpvBd7EALXXnFfx8f3bFzi/XtLYl95P0uZ+43n4nfxPViH8GV+GDgkcc5Xx/fagM8D82q8\n", + "vvOAXwATgPuJgSxlu80IF5NjYhn+N+GCsGl8/Cri5yTj+cuA/ePfGwN7ZGx3BLAgvp9jCEH/9qrv\n", + "RPKcDjsuoXZ+B+FiPw64FPhOfGxbwsXqvYTP42bA7lnlTx4rnqOTE499Cfh6njKnvMYTCJ/NcYQf\n", + "P3cnHrua8J16fSzjdcD18bFJsfyV79MZhO/ISRnHmU3t798i4PeEz/Z68f/lxB9ShOvRcmDzeHse\n", + "8O+x3AfEsnwrPrYdwwPHfwHXx/d6HeCAeP+bgcVV5az1nu1CCDJvBNYlXC/X0kWBY1Es4Mr474Z4\n", + "//aEL4gBlxDaVBfHx64Bzoh/Xwl8PrG/qdQPHCfFD8Nf4wlKCxxvAXaN20xidIHjGGBZnW0WkvgF\n", + "DhxSKRMhcKxi6Nf7hvE17pXYfj5weOKDe0fiMSPUUt6Ycey7E889AfhzyheuEjjeQggI+5AIhIQv\n", + "yHPAqxP3nVI5Z3EfCxKPTYyv4eUZZXoUOCVx+zBgYfz7EkZebB5i6EtSfZHL+1nK2u+b4uutPi+f\n", + "AK5MnPOfJR7bBVhV4/1eJ75n9wM319juOODOqvvuAN4X/76KGFAznv/n+Ho3qvP5+ymJCyHhQvwP\n", + "YErGOR12XMKv/uTjWxIunmPjefphxnFHlJ/hgeP9wC8Sn+PHKp/jemWu83o3iZ+/DRPluLzq8/Zg\n", + "/Pt4Et+neN9iageOtO/f/onXd0Li8Y8TA0HivrnxuNsQLtgTEo99m5QaRzznLxJbSar2N42RgaPW\n", + "e3Y2MYgkvq/PUSNwdCLHcYS7bxr/vRPA3R8mfAj+iRBl/xNYamY7Er7It8bnb0l4Eysey3VQ9+XA\n", + "1wi/9D1jmz/G456VtQ2AmV2aSO6flbLJ08AkM6t1brcifMkrHov3De7D4ztI+GUL4dcxifs2SNx+\n", + "PPE6PN7eMpb3eDO728xWmtlK4DXA5onnZibR3P2XhPP2H8CTZnaZmW1ICK7jUl7D5MTtJxL7WRX/\n", + "TJa5WvX7Wjkf2wJnVsofX8PWDD9fyTLn/Sxl7XfL+NhWVY99gpCvqki+H6uA8Vnvubu/QAhauxJ+\n", + "zWXZipGf6T9nvdYU7yI0Vy2KHUP2zdhuW+DCxGt7Ot4/OWP7atsBP0o8/wHgBWALwjl8JOd+qt0A\n", + "7Bc7zLwJeMnd/7vRMpvZGDP7opktNLO/ES7eED63FVnfp61IfJ+ieonmtO9f8j1LPn9b4Miqz9b+\n", + "hOakrYCV7r46sX3yO5Y0BVjh7n+rU7aK7ch+z7aseg2rGDq/qbqpO+6twJGEJoil8fYJhKaLe+I2\n", + "ywhRuSL5dz1fAg4E9qyxzTmEttjML5C7f8CHkvtfTNlkHiFav6PGcZYS3siKbeJ9zZpS+SNevLYm\n", + "XCy3BS4nNEVt5u6bEtrjk8nkzCAJ4O4Xu/vrCb+qdyTkEZ4i/DKqfg3VX7hGVL+vS+LfjwGfS/zY\n", + "2NTdN3D379Yof57PUq39PkaoASYf28jd31rjmJnMbDLhV92VwFfMbN2MTZcQLixJ2zJ0Lmpy9/nu\n", + "/nbgZcCPCXmYNI8RanjJ17e+u9+Z5zjx+dOrnj8xnuvFhFpfahHrlH8loV3/vYRmxuubLPMxhI4o\n", + "B7n7xoSmRsjXiWIpw79PlrydIfX7l3xpVa/j2qrXsaG7/xvh+rZpsocn4f1PO2+Lgc3MbOOUx9K2\n", + "r/WeLat6DRMZ/uNyhG4LHKcBla55A/H2bYlf398DTjCzneOLOyfHfg0gRuYvE6qKqeKv1e8yih5W\n", + "8ThnA/9hZkeY2UQzG2dmh5nZ+XGz64FPm9kkM5sUt7+22WMCe5rZO2KvjTOANYSE3/qED9FyYIyZ\n", + "nUioceRiZq83s33MbBzhV/Ua4EV3f4nwXnzOzDaIAer/ENqKm2HAh81sspltRmi/rgSGK4APmNne\n", + "FqxvZv9sZpVfiE8y8kKV57NUa7+/BZ41s4+Z2QQzG2tmrzGz1yfKm++FhQvP1cA33P1kwpf0sxmb\n", + "3wzsaGZHmdk6ZvZe4NWEWlPN48bP2DFmtrG7VxKjL2ZsfinwSTPbJT53YzM7stbLSHn+581sm/j8\n", + "l5lZpcfgt4GDzezI+Bo2N7Pd42NPAvXGXH2HkEx/V/y7mTJvQPjxtsLM1ifkoGq9nqSbgV0T36eZ\n", + "hNpALVnfvzTXAW8zs0Pi52p87D472d3/TGjS/Ex8P99I6MAxgrsvIzTffd3MNonbV8bDPAlsbmYb\n", + "JZ5S6z37AfBWC+N31iW0zNSMDd0UOH5NeMMrX/bbCcnEwT7e7j6X0Bvpl4QeRr+g/q+/5OMXEqpn\n", + "tZ5zLqGNr6FflcMO6P4V4COE5OpfCNH+Q4RkMoRk6XxCQvi++Pd5GWVOu1392E8Iv9JWEH5tvdPd\n", + "X3T3BwjBch6h6eg1hMRz8rlpx6rctxGhxrKCkJ9aTqi5AZxOaBJ6BLiNcMG4qs5+a72GbxN+bT5M\n", + "SIKeB+DuvyPUAr8Wy7GA0B5c8QVCEF5poRs05PssZe43Bsa3Epq7HiHUsC6P56PR1zeT0ERS6RJ+\n", + "InCipYzpcfcV8bhnEs71/yV0X19R47hJxwKPxuaZUwifhRHc/cfA+cCcuO39hI4QWaqPeyFwI/Az\n", + "M3uG8PnaO+57MaG57ExCc8fdwG7xed8Edonv1Q0Zx7oR2IGQJ7y/yTJ/i9DEs4RQw55XVf7M9y82\n", + "ax8JfJHwHuzA8O9MtczvX+rG7o8TEv2fZOjacCZD1+KjCTm2FYQflNeklTM6jlDzf4gQLGbGYzxE\n", + "+HH6iJmtiE1/td6zBwitEt8h1JRWUKd5zoZ+gLWemV0J/DNh8NBrM7a5iJCcWkVIIt1dWIFKyMzO\n", + "AXZw9+M6XRaRftOv37+iaxxXEbospjKzGYSTPpXwC+mSgstTRv0y+E2kG/Xl96/QwOHutxG63WY5\n", + "nFgVc/ffAJuY2RZFlqmE6jVfiEhx+vL71+kh8JMZ3pb2OKFHwpPpm0s1d/9Mp8sg0q/69fvXDcnx\n", + "6qpe30VvEZFe0ukaxxKG95HempQ+62amYCIi0gR3b3keptOB40ZC//o5Fka5/tXdU5upinjxvcjM\n", + "Zrv77E6XoxvoXAzRuRjSl+fCbCphgOkb4z3XAbOszgjwZhUaOMzsesKEW5MszA9/DmGqCtz9Mne/\n", + "2cxmmNlCwpiAE4ssj4hIqYSR6jMJgxwnEMZrnUpYRwUKWvOp0MDh7kfl2Oa0IssgIlJKGbUMhgaM\n", + "FqYbkuPSmIFOF6CLDHS6AF1koNMF6CIDnS5APbGlZa6FySjnxjFteZ88BrMzgHsJQeMJ4Ajcj2tH\n", + "0ICCR463ipm5chwiUgYxSFxImM6kYiEwy91vrvPkhmoZRV07VeMQEWmvmQwPGsTbp2c+owtqGUkK\n", + "HCLS90bVdNS48Rn3T0i9N9QybiWsZDiBUMvYdTAB3gGd7o4rItJRGU1H25sZdZuOmrMm4/7Vw27V\n", + "6zHVQapxiEi/a7zpaHQuIuQ0kh4GLh681YW1jCTVOESk3+VqOoo1k5lx+zXARc3USOL4NQiBaQKh\n", + "pnGxu9/czbWMJAUOEel3G2bcX1llsuXNWfE5w5/XwXEZjVLgEJF+lzUmIXl/VnPWj83sfsL0SfvR\n", + "TG2kR2oZSQocItLv/p5x//ZmNkAIBFtlbDMOeB2wOzC26rn1ayM9VMtIUuAQkX6X1ctpU8JcexCW\n", + "tq5lbNXtSnI9PXD0YC0jSb2qRKRvxdzFy6juCjvSROoHj2o9My6jUQocItKXEgnv1zF0kV8NPJvx\n", + "lIeB5Q0cYuS4jC4a/T0aChwi0q/SEt4TgOcytl8CvA9YmmPfPTUuo1EKHCLSr7LGb4xnZHBYBdwZ\n", + "k93/Avwt47krgLnAzMFxGSWpZSQpOS4i/SorKb4B8Dyh5rFevG8icKyZ3RUH8N3DUOI86X53Pwzo\n", + "2R5TeajGISL9Km3qj4rNGAoaFclpSLLnmyppLSNJNQ4R6UuJqT+uJQSKPCpJ9IuA7RmeI3n4ePgh\n", + "IZdRulpGkgKHiJRSnrmlYvC4Czg0525XJ54Hcb6pMbD6p/DYISGg9Ny4jEYpcIhI6TQ4t9Q84ABC\n", + "HqNiWfx/y8R9w3pKDc43NZTLOCU+VMpaRpJyHCJSRrmmSo8B5hSGB401wGXAycB8YCWht9TwnlR9\n", + "kMvIohqHiJRRVlfbyWY2l6Hmq+0ZOQ/VeOCtwF3AJoSpRyDkQS40MxwWUNIeU3mYe9bEkN2jqAXX\n", + "RaRcEnmNvRm64Cclu9jWsoIQOIblPgz4LDz4KdiOHshlFHXtVI1DREohI69RLU/QqBhWa9mBUMU4\n", + "AHaOd/VVLSNJOQ4RKYu0vEazHiUu5GTALEIi4wDgKVhLn+QysihwiEhZZOU1GuWEALTVDoRBGRcQ\n", + "sufXAq+BP3Zr01S7KHCISFlkjeZulBlsfAa8olLLWAYcDhwP/CV7nqq+ocAhImUxj5FrZqxtdCeV\n", + "WsZXwSq1jF2Bm4Y2qbd2R+kpOS4iPS8mxo9l+HiMVcCPgM0JPaBeS42pRYyhJfkmEmoZH4CXbhz+\n", + "A3v4dOl9SoFDRMogLTE+Edi8MlttHL+ROrVIoscUEGoZs4CVYVGneYTAsxq4uO464n1AgUNEyiAr\n", + "MZ5cvnXExIRptYxTGWyWWgt81d0/0/LS9jgFDhHpGTUmLsye5jyqnpjwn8Cug513DWuOJ2sZLxFq\n", + "GgoaGRQ4RKQn1Jq4kIxpzqnKR7j7zeuZ2dnw72fCjuNhzLPw95nwP1eHYKHmqBw05YiIFCrP9OY5\n", + "95OVo3ieoZrFU4S1wVMDwPvMTv4wXLx3bNq6FvgIPLIcTi9jsNCUIyLScxqc3ryerDzGuvEfhFTF\n", + "dSOamMzGADMvgy+PhzFVuYxXEZqvShc4iqJxHCJSpFzTm+eUZ4DfOOC0YfeE9TJuBb46HsakjMuA\n", + "4Ul0qaPQwGFm083sITNbYGYfT3l8kpnNNbN7zOwPZnZCkeURkbbLqiXsF7/7M9IeNLMZ8fGBxHa1\n", + "1ghPGhd3Mmy9jDWw8h3w3PGEBTaq9P2gvkYUluMws7HAn4CDCW2OdwFHufuDiW1mA+u5+yfMbFLc\n", + "fgt3f6FqX8pxiPSgWmMnooXArGSzVUbz1kJCpyeIvaKA/Rhqokpa7vAGqtbL2BK2egLekrL9KuBI\n", + "5TjyK7LGsTew0N0XuftaYA5wRNU2y4CN4t8bAU9XBw0R6Wn1agnDmq1i0LiGjOYtd7/Z3Q9z92mE\n", + "4RfDphQZA2uvCKv2jViV7wkYm1GGh8sYNIpUZHJ8MrA4cftxYJ+qba4AfmlmS4ENgfcUWB4RabOq\n", + "sRP7ARunbDYBhtU0JmXsbrKZ/Q54JaE56iVCq9MmwItTYZ1rwkGmA/wXLJ0N/+euoZlss3IkSxp9\n", + "Xf2uyMCRpw3sk8A97j7NzLYHfm5mu7v7s9UbxmatigF3H2hNMUWkSPHX/M01mq0q+YV662nsyMiF\n", + "mDYy4Ax48TwYWzX6eyvgc2b291iGXGM9epmZTQOmFX2cIgPHEmBK4vYUQq0j6Q3A5wDc/WEzexTY\n", + "iVDVHMbdZxdTTBFphRzjNepduGutp7GK4RMYAsPmmBoLw0Z/Jzc5Hbi5euQ4JRzsF39QD1Rum9k5\n", + "RRynyMAxH5hqZtsBS4H3AkdVbfMQIXl+u5ltQQgajxRYJhEpQJ7xGjku3FlNScsJFYnXDh6PmnNM\n", + "VRvsalup/TT04mSEwgKHu79gZqcBtxB+DXzT3R80s1Pj45cR3verzOxeQqL+Y96nSzGK9Lha4zUG\n", + "L9R1LtxZNZI4wHtopxkz2WZRV9sWK3TkuLv/FPhp1X2XJf5eDrytyDKISFvkmZ22powayZ2EdTY2\n", + "arCWUVGqHEa30JQjItIKdWenbYAl/n8bsEMDtYx/xGMuI+RZS5XD6BYKHCLSCqPusZSWJxkDq0+n\n", + "oVrGbZWFmxrVqskY+4ECh4iMWot6LA3Lk8RaxoQGchlNN0u1eDLG0tO06iLSFcxsAHhzA7mMBYRg\n", + "MSJQNVp7qDHGZG6zNZhuoGnVRaTs1qTlMs6AZ1eEmSWqLU27qDdZexh1cr+faFp1Eek8szG3wJ/v\n", + "Az+AUMs4HDgeHl4B/5PxrKzEezNTubcyuV96qnGISFtkNh+F9TKuPCTOZHszLD0JHn0yLOV6MbAX\n", + "sDPDR47Xymc0U3so/XQkraTAISKFy+gxtf3PzI44BI4jXNSfAE6d4X7jE8OfdyzDg8Yq4NoazU4N\n", + "1x76YTqSVlJyXEQKUVXD2JXErLfVuQzgOmAWVTNHNJO0zshxPAzM7LdAoOS4iPSMjIv3iDmmlsPz\n", + "k+BIhqY+r5bV7LSPmc1ICwSqPRRPgUNEijAiQZ3WY+pjcNuy7KAB2c1OmwIXZvWU0mSGxVKvKhHJ\n", + "JWMd8CyDNQUjDNy7lxA0kj2mnoCv1DlsrRUE6/WUkoKoxiEidWU0Pe0WV+/8OyMH2a2BmjPZ1ktw\n", + "A8Oana4FNkvZROMsOkCBQ0TySBsbsWX8VzE4yG5duPhM2PPTMClj9PdEYN88B47B4y5qrx4obaTA\n", + "IVJCBUzYV2t1vorQdGS24Dk4i9iL6npY+2EYlzLHVN3aQuJ1bMXIVQA1zqJDFDhESmY0E/bVCDhZ\n", + "Seqh5wKzYSohnTE4LuNo+BBN1BYyXscqQsDQlOkdpMAhUj65VuOrVivgkD6yetjOYy5j+3jX0LgM\n", + "sxdSnpuntpD2OiYCS3p54sEyUOAQKZ9mJ+zLDDjuflgMIOcCu1T2VT0uYw2sHA8nJMdlVI2rmEzI\n", + "i6wCZmriwd6kwCFSPs1O2FfzQh0DwMzK7eoeUwvgl1PDYL4V1TtIBI8LCbmPScBrqd2EpokHu5TG\n", + "cYiUT9rYhzxNQ3ku1OPTxmW8D/4w1f2gtKCR0Oistc2+DimYahwiJTOKKTfS8hjLgJfHRZbWvAY2\n", + "/zqp4zIev6Z+0XI3PSWS9KuB5WgN8a6iwCFSQs1MuZEScNYn5CReV8llfAF8AiPGZeStBeRqespI\n", + "0v8VBY2uodlxRSRVZWba6lzGj2HFB+HuJ8IPz9wTCOadtbasy7h2gmbHFSm5AgbtjcoYGH86qWt/\n", + "3+/uBze6vwaa0NSbqsspcIh0gdEM2quxv+aDkNnU38Nuu8ebiVwGjKJXU84mNPWm6nIKHCLdoalB\n", + "e2lGFYTMxsSyfH53mPAXePFkGJuYY6odvZq0jGuXU+AQ6Q6tbJ5pLgjFtb+Ja38D1/0z3DQfTqSN\n", + "CyJpIabup8Ah0h1a2TyTKwhVmrPGwPhzYYuz4JVjYT3iHFO433hX2PR7aTsrMiejhZi6mwKHSHdo\n", + "ZfNM3SBUac7aAXbIO/o7qdU5GektGjku0gXixXYWMBe4Nf4/s8mLcN0R12Ng5izYoXpVvh3h+XpB\n", + "I2p0FLiUiGocIl2iVc0zdXMEZlPnw757xO2rekzlzamoy2wfU+AQKaHUIJToMbUHTEhZlQ/y51TU\n", + "ZbaPKXCI9IOqHlML4JdvgO2Ww6sSWzWSU1GX2T6mKUdEyixRyyCxKh/uN8YEd9NdXkf7fCleUddO\n", + "BQ6RskoZl0FlVb62HL67plDpRz05V5WZTQcuAMYC33D381O2mQZ8FRgHLHf3aUWWSaT0atQy2lcE\n", + "ddcts8JqHGY2FvgTcDBhHv27gKPc/cHENpsAtwOHuvvjZjbJ3Zen7Es1DpE8OlDLSKtZxNua4bbD\n", + "OlrjMLOJwBR3/1MD+94bWOjui+I+5gBHAA8mtjka+KG7Pw6QFjREJIcO1TKyahZk965Sd90SqDsA\n", + "0MwOB+4Gbom39zCzPB/GycDixO3H431JU4HNzOxXZjbfzI7LV2wRGRRqGbcSmnwnEGoZu7apaSpr\n", + "IOCWGduru24J5Bk5PhvYhzg+yN3vZngXvix52sDGAa8DZhCqtf9q4UsgIvWYjcHsDMLy328k1DKO\n", + "wP24PE1TZjbDzOaa2UD8f0YTpcgaCLgMrRdeWnmaqta6+1/jSNSKl3I8bwkwJXF7CqHWkbSYkBBf\n", + "Daw2s18DuwMLqndmZrMTNwfcfSBHGUTKqYlcRlUuYkPgFcBWiU2aSV5nDQRcQggS6q7bRrGz0bTC\n", + "D+TuNf8RPpzHAPcTmpYuBi7N8bx1CL8wtgPWBe4Bdq7a5tXA/yP0upoYj7FLyr683vH0T/965R+h\n", + "hj0XGIj/z8j9fBjjcIbDKgd3WOZweM5jLiC0BNT699MmXkv1fhc29Jr0r8jPmhex3zw1jtOBTwHP\n", + "AdcTch2fzRGQXjCz0+L2Y4FvuvuDZnZqfPwyd38ori98H6EWc4W7P5CjTCKFK2IcwigXWRpNj6m0\n", + "XESahpLXrrUz+lLd7rhm9jp3/32bypNVBnd1x5U2yrjALwRmjeaiGH8oNdZNtQU9psxsAHhzjk1X\n", + "ELrOa7BeCRR17cyTHP+KmT1kZp81s9e0ugAiXaqoacMbm1W2dT2msnIR1TYjBLYLm0yWSx+oGzg8\n", + "jOQ+EFgOXGZm95vZvxZdMJEOK2ra8Hyzyo6yx1SKtDU6lgHzGZxRfRitrSGZci3k5O7L3P1C4AOE\n", + "D/LZhZZKpPOKmja87iJLRYzL8PSFok52970IOcY0Gqwnqeomx81sF+A9wLuBp4HvAh8puFwinVbI\n", + "tOE1k8kFj/727IWitLaGNCRPcvxOYA7wfXdf0pZSjSyDkuPSdm2dNryDM9lmdAR4mOaXrpUuoWnV\n", + "FTikjLpgJttQDK2tUUZtDxxm9n13P9LM7k952N19t1YXJosCh5RSh9fLkPLrRODYyt2Xmtm2QPWB\n", + "3d3/3OrCZFHgkFLpklqGlF/bx3G4+9L454fcfVHyH/ChVhdEpC90diZbkZbI0x33kJT7NDBIpBGt\n", + "H5ch0jGZ3XHN7IOEmsX2VXmODQmr9olIHsplSMnUynFsDGwKfBH4OEN5jmfd/en2FG+wLMpxSO9R\n", + "LkM6rGPdcc1sP+CP7v5MvL0RYXr037S6MDXKoMAhvaWLahlFzPIrvaGTa45fQlilr+IfwKXAHq0u\n", + "jEjP67JaxqimcRfJkHeuqpcSf79IWF9DRJK6s8dUUbP8Sh/LEzgeNbOZZjbOzNY1s1nAI0UXTKRn\n", + "dHePqaJm+ZU+lidwfADYn7CG8OPAvsApRRZKpGd0Zy0jSRMYSsvVzXG4+5PAe9tQFpHe0eZcxigS\n", + "3IXM8iv9Lc+06jsBXwde4e67mtluwOHufl7hpRPpRm3uMTWaBLfWBJci5OmO+2vgo8Cl7r6HhU/h\n", + "H9x913YUMJZB3XGl8zrUY6qpdcpF6Gx33Inu/pv4qwV3dzNb2+qCiHS1zo7LUIJbukqe5PhTZjZY\n", + "RTazdxPWKhYpv+7oMaUEt3SVPDWO04DLgZ3MbCnwKHBMoaUS6QbdM/q7qQS3RoxLUWpNcjjL3S8E\n", + "tnT3g8xsA2BMZeoRkdJqMJcxmgt0nuc2k+DWiHEpUq1JDu91993N7G537+j0IkqOS9s0WMvIuEAv\n", + "BGbVu0APMdv7AAAP6ElEQVSP5rn1KKEu0IGFnIAHzGwBoYnq/qp/97W6ICLtYmYzzGyumQ3E/2eM\n", + "Ipcxmik9ipwORAl1KUxmU5W7H2VmrwBuAQ5n5PKxIj0n7Vf+LvDqv8DfXw6VLuaN5DJGc4Eu8uKu\n", + "hLoUplaO4xcxt3FLO9cXFynY4K98YzCRse3E8Fgz4zJGc4Gu+dxRJrc1YlwKU6tX1ZZmtj9wuJnN\n", + "IXzPBhMi7v77ogsnUoDxEK6mVwIHxDtvgiffFuaYarTHVNoFeg3wcjObUedCn3lxH21yWyPGpUi1\n", + "kuNHAu8nTHA4v/pxdz+w2KINK4uS49ISY83mng6Hfh6YSBiQdCpw0yiSxvEi/xlCU1eymaluojs+\n", + "d8TFXcltaYVOrgB4truf2+oDN0KBQ1rCbOpf4EeVXMa1wCxgZfiVP3M0v8ZbfaE3swHgzSkP3eru\n", + "0xrdn/SnTk45cp6ZHQe80t3PNbNtCBMe/rbVhREpRGJcxsthwhpY+UF49Gp4ltY14bQ60a3ktnSt\n", + "PFOOfB3YDzg63v57vE+k+6WslzEedrjKfU93n+buh7Wo3b/VF/qLCE1dSUpuS1fIU+PYJ86KezeA\n", + "u68ws3EFl0tkdNo/k21LezEpuS3dLE/geN7MBtcYN7OXAS/V2F6kszowx1QRF/r4XAUK6Tp5kuPH\n", + "Au8B9gSuAd4NfNrdv1d88QbLoOS41Neh9TJEulXHelXFg+8MHBRv/sLdH8y1c7PpwAXAWOAb7n5+\n", + "xnZ7AfOA97j7DSmPK3BIbd0zk61I1+ho4Ghqx6F560/AwcAS4C7gqOqgE7f7ObAKuMrdf5iyLwUO\n", + "SadahkimTkxyOFp7AwvdfZG7rwXmAEekbHc68APgqQLLImWU0mOKMPpbQUOkQEUGjsnA4sTtx+N9\n", + "g8xsMiGYXBLvKqb6I+XSHavyifStuoHDzHZJuW9ajn3nCQIXAGd5aC8zNAOv1KNahkjH5emO+z0z\n", + "uxb4N8IX9XxgL2DfOs9bAkxJ3J5CqHUk7QnMid0YJwGHmdlaT7kImNnsxM0Bdx/IUXYpC+UyROqK\n", + "P+qnFX6cHN1x1ycEi9cDGwDfAb7o7jXHcpjZOoTk+EHAUuC3pCTHE9tfBdykXlUygnpMiTSlk3NV\n", + "vUAYzDSBMB/PI/WCBoC7v2BmpxEWghoLfNPdHzSzU+PjlzVfbOkLqmWIdKU8NY57gRuBcwnNSZcB\n", + "z7n7kcUXb7AMqnH0G9UyREatk9Oq7+Xud1Xdd7y7f6vVhalRBgWOLjfK1eqSO1ItQ6RFem4AYCsp\n", + "cHS3jNXq6i5ilLIj1TJEWqgXBwBK/xhcxzthB8Lgzvo0LkOkp+RJjovU0/wiRqpliPQc1TikFRpf\n", + "xEi1DJGepcAhrdDYanUlHP1tZjPMbK6ZDcT/Z3S6TCJFUVOVjFruRYxK2mMqo3PA9mZGUz3LRLqc\n", + "elVJe5Q4l2Fmc4FDUx6a6+6Htbs8IhXqVSW9qT9yGc13DhDpQWqqkuKUuJZRpfHOASI9TDUOab3+\n", + "qGUkNdY5QKTHqcYhrdU/tYxBuTsHiJSEkuPSGiXtMSXSy5Qcl+7VJeMyNJZCpD3UVCXNa3EtYzQz\n", + "7GoshUj7KHBIc1qcy2jBhb/WRIsKHCItpKYqaUxxPaZGN8OuxlKItI1qHJJfsT2mRnvh11gKkTZR\n", + "jUPqa8+4jNFe+DWWQqRNVOOQ2to3LuMiYHuGN1flvvBrLIVI+2gch6TrwLiMmCDXhV+kRbTmuAJH\n", + "+/Th6G+RMtIAQCle/80xJSJNUI5DAtUyRCQn1Tj6XYG1DE0BIlJOqnH0swJrGZoCRKS8VOPoR+3J\n", + "ZYx2JLiIdCnVOPpN+3IZmgJEpKRU4+gX7e8xpSlAREpKgaMfdGa9jK6bAkTJepHWUFNVmXVwVb5u\n", + "mwJEyXqR1tHI8bLSuIxhzGwucGjKQ3Pd/bB2l0ekHTRyXPLR6O8sStaLtIiaqspEtYxalKwXaRHV\n", + "OMqgR2sZbU5Wd12yXqRXqcbR63q0ltHuZHW3JetFelnhyXEzmw5cAIwFvuHu51c9fgzwMcCAZ4EP\n", + "uvt9VdsoOV6tgz2mWkHJapHiFXXtLLTGYWZjga8BBwNLgLvM7EZ3fzCx2SPAm9z9bzHIXA7sW2S5\n", + "el6P1jKqKFkt0qOKznHsDSx090XuvhaYAxyR3MDd57n73+LN3wBbF1ym3tWjuYwMSlaL9KiiA8dk\n", + "YHHi9uPxvizvB9TmnKYzo7+LpGS1SI8qOjmeO4FiZgcCJwH7Zzw+O3FzwN0HRlWyXtHjuYwsVcnq\n", + "ycCWwCpgpkZzizTHzKYB04o+TtGBYwkwJXF7CqHWMYyZ7QZcAUx395VpO3L32UUUsKuVI5eRKRE8\n", + "LgQmxX+vRVOBiDQl/qAeqNw2s3OKOE7RTVXzgalmtp2ZrQu8Fxj2S9nMtgFuAI519+qmi/5UrlxG\n", + "PVq3Q6THFFrjcPcXzOw04BZCd9xvuvuDZnZqfPwy4GxgU+CS+OtzrbvvXWS5ulrJaxkp1LtKpMdo\n", + "ksNuUdJcRj0azyFSHE1yWGbl6zHVCPWuEukxmnKkk/q0lpGkqUBEeo+aqjql/3IZItJmaqoqi/7q\n", + "MdVyWv5VpPPUVNVOqmWMipZ/FekOqnG0g2oZraIxHyJdQDWOoqmW0Uoa8yHSBVTjKIpqGUXQjLoi\n", + "XUCBowj9PS6jSBrzIdIF1FTVShqXUSiN+RDpDhrH0SrKZYhIl9E4jm6lXIaI9Bk1VY2Gahki0odU\n", + "42iGahki0sdU42iUahki0udU48hLtQwREUA1jnxUyxARGaQaRy2qZYiIjKAaRxbVMkREUqnGUU21\n", + "jExaC0NEQDWO4VTLyKS1MESkQjUOUC0jH62FISKAahyqZeSntTBEBOjnGodqGY3SWhgiAvRr4NB6\n", + "Gc3QWhgiAvRbU5XWy2ia1sIQkYr+WY9DuQwR6TNaj6NZymWIiLRUuZuqVMsQEWm5ctY4VMsQESlM\n", + "+WocqmWIiBSqPDUO1TJERNqiHDUO1TJERNqmt2scqmWIiLRd79Y4VMsQEemIQmscZjbdzB4yswVm\n", + "9vGMbS6Kj99rZnvk2KlqGSIiHVRY4DCzscDXgOnALsBRZrZz1TYzgB3cfSpwCnBJnZ32/RxTZjat\n", + "02XoFjoXQ3QuhuhcFK/IGsfewEJ3X+Tua4E5wBFV2xwOXAPg7r8BNjGzLVL31qO1jAJWzZvWinKV\n", + "xLROF6CLTOt0AbrItE4XoOyKzHFMBhYnbj8O7JNjm62BJ1P299X4f8/kMjqxal485kzC+hlrgIs0\n", + "EaGItFKRgSPv7InVE3BlPa8XZ7KttWpeyy/mWt5VRNqhsNlxzWxfYLa7T4+3PwG85O7nJ7a5FBhw\n", + "9znx9kPAm939yap9df8UviIiXaiI2XGLrHHMB6aa2XbAUuC9wFFV29wInAbMiYHmr9VBA4p54SIi\n", + "0pzCAoe7v2BmpwG3AGOBb7r7g2Z2anz8srg40AwzWwj8AzixqPKIiEhr9MRCTiIi0j26asqRQgYM\n", + "9qh658LMjonn4D4zu93MdutEOdshz+cibreXmb1gZu9sZ/naJef3Y5qZ3W1mfzCzgTYXsW1yfD8m\n", + "xe7v98RzcUIHitkWZnalmT1pZvfX2Ka1101374p/hOashcB2wDjgHmDnqm1mADfHv/cB7ux0uTt4\n", + "LvYDNo5/T+/nc5HY7pfAfwLv6nS5O/SZ2AT4I7B1vD2p0+Xu4LmYDXyhch6Ap4F1Ol32gs7HAcAe\n", + "wP0Zj7f8utlNNY7WDhjsbXXPhbvPc/e/xZu/IYx/KaM8nwsIXZx/ADzVzsK1UZ7zcDTwQ3d/HMDd\n", + "l7e5jO2S51wsAzaKf28EPO3uL7SxjG3j7rcBK2ts0vLrZjcFjrTBgJNzbFPGC2aec5H0fgoYF9Il\n", + "6p4LM5tMuHBUpqwpY+Iuz2diKrCZmf3KzOab2XFtK1175TkXVwC7mtlSwowTs9pUtm7U8utmN82O\n", + "2+oBg70s92syswOBk4D9iytOR+U5FxcAZ7m7m5kx8jNSBnnOwzjgdcBBwERgnpnd6e4LCi1Z++U5\n", + "F58E7nH3aWa2PfBzM9vd3Z8tuGzdqqXXzW4KHEuAKYnbUwiRsdY2W8f7yibPuSAmxK8Aprt7rapq\n", + "L8tzLvYkjAWC0J59mJmt9d6aZaCePOdhMbDc3VcDq83s18DuQNkCR55z8QbgcwDu/rCZPQrsRBhf\n", + "1m9aft3spqaqwQGDZrYuYcBg9Rf/RuB4GByZnjpgsATqngsz2wa4ATjW3Rd2oIztUvdcuPur3P2V\n", + "7v5KQp7jgyULGpDv+/ET4I1mNtbMJhISoQ+0uZztkOdcPAQcDBDb83cCHmlrKbtHy6+bXVPjcA0Y\n", + "HJTnXABnA5sCl8Rf2mvdfe9OlbkoOc9F6eX8fjxkZnOB+4CXgCvcvXSBI+dn4vPAVWZ2L+EH8se8\n", + "ByZGbYaZXQ+8GZhkZouBcwjNloVdNzUAUEREGtJNTVUiItIDFDhERKQhChwiItIQBQ4REWmIAoeI\n", + "iDREgUNERBqiwCHSAnE685vi32+rM/37xmb2wSaOMdvMzhxNOUVaQYFDpAYza/g74u43ufv5NTbZ\n", + "FPhQE8XRoCvpCgocUjpxQad7zWw9M1s/LuSzS9U228WFgK4zswfM7PtmNiE+tsjMvmhmvwOONLND\n", + "zOwOM/udmX3PzNaP2003swfjdu9I7PsEM7s4/r2Fmf0oLih0j5ntB3wR2D4uuHR+3O6jZvbbWO7Z\n", + "iX19ysz+ZGa3EabNEOm4rplyRKRV3P0uM7sROA+YAFybMfXGjsCJ7j7PzL5JqAV8mfDLfrm772lm\n", + "k4AfAge5++rYBPURM/sScDlwYJxE77uk1wguAn7l7u+ItZcNgI8Du7r7HgBmdgiwg7vvHbf5iZkd\n", + "AKwizMO0O2EKid/Tn5P0SZdR4JCyOpdwkV1NWOQpzWJ3nxf/vg6YSQgcAN+N/+8L7ALcEecEWxe4\n", + "g/Dr/1F3fzjx/FNSjnEgcCyAu78EPGNmm1VtcwhwiJndHW+vT1hbY0PgBndfA6yJwbCMU8ZLj1Hg\n", + "kLKaRLgAjyXUOlalbJOsIVjV7X8k/v65ux+dfKKZ7V61r1oX9DwX+y+4++VVx5hV9VwFDekKynFI\n", + "WV0GfBr4DpCVqN4mTjMNYdnV21K2+Q2wf1wMiJgzmUqYtns7M3tV3O6ojGP8AvhgfO5YM9sIeJZQ\n", + "m6i4BTgpkTuZbGYvA34NvN3MxpvZhsBbUYJcuoACh5SOmR0PPOfucwiJ6L3MbFrKpn8CPmxmDwAb\n", + "k7L0rLs/BZwAXB+n6L4D2MndnyM0Tf1XTI4/mXieJ/6eBRxoZvcRms52dvengdvN7H4zO9/df04I\n", + "cPPidt8DNnD3uwlNZvcSlgb+7ShPjUhLaFp16Utmth1wk7u/tsNFEek5qnFIP9OvJpEmqMYhIiIN\n", + "UY1DREQaosAhIiINUeAQEZGGKHCIiEhDFDhERKQhChwiItKQ/w9+ko845ptIQQAAAABJRU5ErkJg\n", + "gg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd8VUX2wL8nvUICBAgdEhAhFAUFVIqoQGJFBMGGDXVd\n", + "xV3d1Z+r7suzbnNXsYsidsFeKCIK2AAJAtKCEDoJIRAgvc/vj7kv7+XxXnjpAeb7+dxP8ubOnZnb\n", + "zsw9c+YcUUphMBgMhlMHv6ZugMFgMBgaFyP4DQaD4RTDCH6DwWA4xTCC32AwGE4xjOA3GAyGUwwj\n", + "+A0Gg+EUwwj+OiAiFSLSowHLHy4iqQ1VfkMjIjtF5IKmbkdTICKhIvKliBwRkTlW2uMikiUi6fVc\n", + "14MiMrM+y6xvRORGEfmhieruZr2rftbv+SJyfSPUmywibzd0PbXhlBH8lhAqEJFca8sRkfZN2J5k\n", + "ESm12pEjIltE5DnXNimlflBK9faxrOb4gClrqzHW/Rpdz+1pTK4C2gKtlFJXi0gX4F6gt1KqQ20L\n", + "FZFRIrLHNU0p9ZRSalrdmnvqoJRKUkod932ph2ew2S6SOmUEP/omXKKUirS2Fkqp/U3cnveVUi2A\n", + "aGA80B5Y3ZQdUjNCAdLUjagDXYHflVIV1u8uwCGl1KEmbNNJgYj4N1JVJ/oz6JVTSfB7RETeFJF7\n", + "rf87Wp+Ed1q/40TkkEvev4pIuojsFZGb61q1taGUKldKbQKuBrKA+6z6qozuROQBq+4cEUkVkdEi\n", + "Mg54ELja+pJZY+W9SUQ2WXnTROQ2l3JGWeXcKyKZ1jnd6LI/VESetkY8R0TkBxEJsfYNFZGfReSw\n", + "iKwVkZHHOc+zRWSjiGSLyCwRCXap5xKrjMMi8pOI9LPS30YLyi+tc/qriMyuwX3yWK61r4OIfCwi\n", + "B0Rku4jc7bIvWUTmWs9EjohsEJFBXm+gSG8R+UZEDln3Y6KVbgcecbkntwGLgA7W71nHu5Yi0kpE\n", + "3hCRfda1+0REwoAFLuXkiEis6xefiCwQkT+6tXOdiFxRXZu9nF9dnqHWIvKFiBwVkZVAXDX1OFQx\n", + "06zzTReR+9zuy0ci8raIHAWmikhLEXldnO/jY+JU5fiJyH9Eq9XSgIvd6lsqIre4/J7mcp4bReQM\n", + "D8/gX3y4Z91FZJlVziKgjbdzbnKUUqfEBuwALvCQfhPwhfX/NcA24APr983Ap9b/44D9QB8gDHgP\n", + "qAB61LI9ycDbHtLtwArr/1HAHuv/04DdQHvrdxdH3YANeMutnCSgu/X/CCAfOMOl3FKrDf5AorW/\n", + "pbX/BeA7IBY9OBgKBAEdgYPAOCvfhdbvNl7OcSfwm3VcNPAj8Ji17wwgEzgL3QHeYN2jQJf7NboW\n", + "98lruda5rAYeBgKA7kAaMMblnhRa91qAJ4HlXs4tHNgDTLXKHYjutE/3dE+AkY57af32di1bW7/n\n", + "Ae8DLa22DvdUjntdwPXAjy77+gCHrfOvts0ezrEuz9AH1hYK9AX2At97qacb+l1618qfABzAel+t\n", + "OkqAy6zfIcCnwEtW/hhgJXCbtf8OYDPO524JUA74WfuXADdb/0+02jbI+h0HdPHyDB7vni0H/mNd\n", + "6+FADm7vZXPZmrwBjXaiWgjlWi/BYeATlxudjX7RXwJuwyls3wT+ZP0/C3jSpbyeNIzgvwOtInC8\n", + "XI62xKMF2gVYwvF4Zbnl+RSY7lJugeNFsNIygbPRAqEA6OehjAfcH2RgIXCDlzp3OF5G63cisM36\n", + "/yXgUbf8qTgFnPtL5+t98lbuCGAIsMtt34PALJfruMhlXx+gwMu5XY2bIANeAf7u6Z643svjXUt0\n", + "h1uOJUTd8lQpx70uIBLIAzpbv58AXvOlzT48s74+Q/5oQd3LZd8TwA9eyu2Gfpdc8//Tpd3JwFKX\n", + "fe2AIiDEJW0K8J31/3duz91FVvmeBP/XwN3VPL+uz2B196wLuiMMddn3Lsd5L5tqO5VUPQq4XCkV\n", + "bW1XAiil0tAjlYHoXvorIF1EeqGFxTLr+Fj0aMnBbm8VibbGcUwir69hOzsCx+iBlVLbgD+hX4JM\n", + "EXlfRGKraUOiiKywPukPo0dvrV2yHFJO/TPolzgC/Xkagh4Ju9MVmGh95h62yj0XPTfhDfdr5pjY\n", + "7Arc51ZWJ5f9VajBffJWbqy1r4PbvgfRk7AOMt2uSYhDheDhWgxxK+satFDyhequZWcgWyl11Mey\n", + "KlFK5aK/FqZYSZPRAqjGba7DMxSD/krx6X1xwduzAnpU7qArelSd4XIeL1v1Qg3eVfSz4elZ90R1\n", + "96wDcFgpVeiSf5eP5TY6AU3dgGbCMvQnX6BSKl1ElgE3oj8T11p5MtC9uoMueEEp9QN65FUdyj3B\n", + "EjCXovXBnsp9H3hfRCLRI7V/okcbVcoSrUf/GLgO+FwpVS4in+LbRNVB9GgqHq2mcWU3egRz2zFH\n", + "ecf9mu1zKesJpdSTXo475vrg233yWq6IDAV2KKV61aBOb+wGlimlxtSyLK/X0urQW4lISw/C31O5\n", + "7mnvAzbR5pMhSqklPrbZtQ11eYaygDL0/d5ipXl9X1xwz7/PZZ/rOe4BitEqFteOx4HP76pVVryX\n", + "fe7Xtbp71hWIFpEwpVSBldwV/eXW7DiVRvzVsQy4C/je+r3U+v2Dsr7ZgLnAjSJyuuhJNlsd66x8\n", + "gUQkQEROR7+wbYH/HpNZpJfoydxg9ENfhPOh2g90ExFHmUHWdhCoEJFE4LgvO4D1Is0C/it64tBf\n", + "RIaJSBDwDnCpiIyx0kOsSb6O1ZzjH0VPxrYCHgLmWPtmAneIyNmiCReRi0UkwtqfybETgr7cp+rK\n", + "/QXIFZH7RU9g+4tIgogMdmmvr3wF9BKR60Qk0NrOEhGH+e3xyvJ6LZVSGehJ3BdFJMoqe4TLdWkt\n", + "Ii1cynKvaz5a6NjRenZf2+xKXZ6hcuATINm6zn3Q8wrH6wwftvL3RXfoczxlsq7PIvQzGil6MjfO\n", + "5RrNBaZbz1008H/V1Pka8BcROdN6XuJFm97Csc9gdfdsF5AC2K3reh5wyXHOt8kwgl/zPfoT1SFQ\n", + "fkJPGjl+o5RaCDyD1h/+DnxL3ex0FZbVB3AE+Bw9UhqkqpqZOuoIBp6y8mSgVTIPWvs+tP4eEpEU\n", + "63N/OvoFyEZ/9n/uoX5v/AVYD6xCq52eQutH9wKXA39DT77tRlsgeXuOFFrNsAj9Ob0VeBxAKbUa\n", + "mAY8b7VxK/rrxcFTaEFwWCxrHny7T17LtTq1S9Dqou3oa/kq4BCiysN18XidlFJ5aEE4GT0yzbDa\n", + "HORLWT5cy+vROuNUtACabh2Xih4gbBdt7RPrXpdSqgQteC9AGyH42mbX86vrM3QX+l7tRw8kZlWT\n", + "18Ey9KT9YuDfSqnFLvW413WD1e5NVvs+xKlynInW3a9DC+OPvbVVKfURev7hPfRk7CfoL0hwewZ9\n", + "uGfXoOeRsoG/o+eemiXiHCjVsgBtmnYxcEAp1c9Lnhnoib0C4Eal1Jo6VWowGE4aRKQbuiMO8KK6\n", + "MdQz9THifwNt/uYREUkC4pVSPdGWGC/VQ50Gg8FgqCV1FvzWRObharJchvXJo5RaCUSJiK+WDwaD\n", + "4dSgbqoHQ41oDB1/R6qaVu1Fm1AZDAYDSqmdSil/o+ZpPBprctfd6sD07gaDwdBENIYd/z70ghQH\n", + "nahqnwuAiJjOwGAwGGqBUqpGzuQaQ/B/gTbt+sBaQHNEKZXpKWNNG38iISLJSqnkpm5HQ3AynxuY\n", + "8zvROQXOr8aD5joLfhF5H+04qo1oT5I29HJqlFKvKKXmi0iSiGxDL7m/qa51GgwGg6H21FnwK6Wm\n", + "+JDnrrrWYzAYDIb6wazcbTyWNnUDGpClTd2ABmZpUzeggVna1A1oYJY2dQOaG3VeuVtfiIg6mXX8\n", + "BoPB0BDURnaaEb/BYDCcYhi3zIZ6RSQhCTpPh8gQyC2CPTOU2jC/qdtlMBicGMFvqDe00B/2LMx0\n", + "8W8+LU4kASP8DYbmg1H1GOqRztNhZjzhmeBXZqXNjIcud1d7mMFgaFTMiL+BODVVHpEhACTdBT3n\n", + "Q1Yf2D8QcnbHi13OA35TNpXTtG00GAxG8DcAp67KI7cIgA8/hKBcaLce2q+F7l8GA08DCWKXTHSY\n", + "xHUuf3cpW+Oal52aHbPBoDHmnA2ASOJCWDCWqJ0QchgK2kBBDJRduVCp+YlN3b6GwnOHd2sarJiu\n", + "1Ib5Yhd/dHzTgcAAl7/h6A7AtTPYqGyqqPHaOW0bLL/HCH/DiUZtZKcR/A2AyKSlMHckg1+GwS9D\n", + "2EEIywJVXkFg+W50yL+D1l9v/x8EjjT2SLiuaKHa5W6ICIW8Qtj93PGEqdglBt0BuHYGPdHhGl07\n", + "g7XKpg64H58gktQZpkdCSC4U7YEZG5TyWKfYRXjuvCW0vn8k7X6DlD9AYStrb9JJ3TEbTk6M4G8m\n", + "VI74q6Ag9KJveODbO4AYa2vj4X/XtFB0zFtfOoks4KCyqdIGPr1GQewSDPTB2RHoTqFMFBktyzkQ\n", + "XUhmyOG2u/d8f9n+vHEz9ZcEANNg23K4Z2MyS4G+1rH9K//mB4WRPjqIzP6w/F7Id8QFmrRMqbmj\n", + "GvE0DYY6YwR/M+F4Kg+fy7FLEJ47BG9prdGO8HzpJBz/550oXxXi1zeJqIQXaHttN9qtg/ZrGbzi\n", + "M7Vqd4VkhsOqjrCuHfzWDr7oREFRFAJsAX7DUiV1m0XM4d1DnzvK8jbH1mBG/IYTDyP4mxG1UXnU\n", + "uU67+AFR+NZJOP73x/dOIgvIVjZV7kt7aqKC8en8HF9S3ZZA2w3w662MLEtkKct4dgjM7wkDMmHA\n", + "fnjGj4qU8ezERVXUeQ7RYzbz0Hgi4u8hiTTmuJRe847ZYGgOGMFvqDFilzCO7Ry8dRJt0B3LEY7T\n", + "SbRbRK9Rm7j3jTy6hVom/Q4VTG2Ff+XcSdv1cP7fofNyBr/WglVHth6TNxG+XpjMn3CZNwgsYHS4\n", + "ENw/Ey5cGMFP+3tTRDhrKT54lNyp9S30jeWQoTEwgt/Q4IhdAoBWHKeTCDvEkOhAIrPCoGc2bHhR\n", + "H58EC+crVSt1yjFzJzEbiYi7i6TUpcw54sx3K6StgOnuHcwkkaUvhDFyXXvofhjiDlvpsGyuUqNq\n", + "0ybvbTWWQ4bGoTay09jxG2qEsqky4IC1eWWSyNK5MFIBhYHO9Ag9YV1L9syAaXGVwjSrL3lZcWlL\n", + "Y1Z/eW673AlBQcSWFrM3I4BH0/Yd+1WRC0UxBXDh9qrpeVBY+zZ5w1rF3CYVDvUC5Ydud9LdgBH8\n", + "hibFCH5Dg5ALRQAChLnYGdVFyCq1Yb5IAlp4OudOMg/kzAf+LHbpANwHPCN2GQ78U9nUNsfxe2DG\n", + "NIhztQC6FdJ2w3O1bZN3IkOIyICbhsPrP0N2Tys9og4dn8FQPxhVzylMfU++upc9DJ51F7KeVDD1\n", + "jdilNTAduBP4BnhK2dR6R7u6wN0REJoHhbvhufpsj+Oa/sLQs7Mndo7mUE/47gmXHMZyyFC/GB2/\n", + "wWc8Cea6Tr56qqMhhezxELu0AO4A/gysAp5UNrWioepzvabJPUN4clwApS8dgDLHIN9YDhnqHyP4\n", + "DR6xJmTbArGOrctK7k/yIz4jEqauhfGpOm9dJl+bK2KXUOAm4H70auAnge/6JpNYn188iSILF8DY\n", + "vCBIuBOmfRHCD9sT+Jmo7FwCf2kMk17DqYeZ3D3FsFa3tsdFoHvYOqAXdmUDGY4twI+ghANw0XYY\n", + "lOEss26Tr80TZVOFwItil5nANcAL/gXQri8t5m0i1s8a+0yDuAQRaiv8IyEEYE8LuGY9PLS9CEhh\n", + "Eqyfe5J1poYTGyP4myFil3A8C3D3tEggExeBbm2/uP0+4O7KIVFk4R+hi3vdDWPh0jywrsGbYpd3\n", + "en9LyuHzOG3ACLAvhSs3w0yIT4JaW904JrRPPwhPfutMz4NCY9NvaE4YwV9LfHmRq+bJKSJ26yxu\n", + "376B6kfosUAgxwrzDCDV7fdBZVMVtWl/41q4NC+UTZVPSpajc1bDojjY18K5ry5fPN6u6QpiV5ya\n", + "broNzRUj+GtBlcU5UqG9b7a87XRJav0aQ7L3ArFkBg/lmrbnE5ITQWQqROyHirKLKPbLILhiG07h\n", + "nQ6spqpAP9rQ/nM2KDU/QYSkJpx8bUpyoUiAsWlV0+vyxePtmh5mgLbpD8yH8mCoCKAxbfrN14bB\n", + "HSP4a4W1OGfE4zDyUShuAbmxXSgtvweYB2SwpWNPMp+KoDgCItN1NKojPfwouHG9Kl/YLPS9lpA/\n", + "JQVAQ33xeLqmIpPuB+CMWXDhg5DZH9IHweH0bmKXBCDVWhhX71RdQazQKyvM18apjrHqqQWVPmOC\n", + "8qA8UI/iAFe3vpV5Wm+BxOl6xB+ZAaEHFX7KVS+/n6qjfcfv/dakpKGBaCxz0yquJoJzoP0a6JAC\n", + "cf/IIP5gHnr+Zh36yy/F+pvqqzM8n+ru/BNc9AC8tRjKQjDrCU4ejFVPo2GFGCyJcEvPKzwmz6HT\n", + "4J2vncn+4xbxyNe3UFWn3x5IAC7CaaXTXuxSyPE7iAzqGLClIRdyNWca74vHxdVEcQvYNRJ2vZ3G\n", + "8nbTlcqaL3ZpCZwJDAKSgEfQ938dzo5gNbCl5p1BRAjn/AfO+Td8PssS+uBYQVxVDbQ/AkIEonJr\n", + "qxIyaqUTAzPirwW++Nuvq09+sYsA0VTtHNw7C8f/wbh8KeC9gzjgrlJojIVcpwrVCb2auukWu0Th\n", + "7AwGW3/boV1MOzqDFOB3bxP8YpdW7IpOxe+0GD6aA0ddjbiSFsLu55zP6PfA1+Bv01+xWiVUI6dy\n", + "xjFd02AWcDUivrzIjeWT33Kt7NoRePvf1Z5/P5DRaTUj7s+kR/s8vYgrwBIhJ+NCroakMYSe2CUa\n", + "3Rk4OoJBaG+oa3B+FaQAW608c8gIWcNrU/pRPuuYAYjupBaMJTgHiv8FPA7n/gu6fwtfvA45naiJ\n", + "SqhSrdRzPpQFw44LrD1GrdSQGFVPI2K9zNW+0L7kqZe22FQBsN3avGKt4I3BpVMILWFUahtY1g0m\n", + "bHbmPRkXcjUs1oR/yBEoDYPyIOrbckfZ1GHgW2sDrFG9szO4Angc3dn7AwuILfqQfl8vYF3ilajI\n", + "KgOQyknnKZfCZ110lIXlfwb/Yrj9TPj6v/BbeA2eg0itRyqJgEkT4MMPYecojGO65ocR/KcQlprH\n", + "ofYBIFFk4gvQzT3vybyQq2GwhN6At2BUMvx+CWyaANtDwhuyVmVT2cBiYLE1V/AaOlD9/9CTxhO4\n", + "In0wV6RHA78CG4EWYpeeMK4YgDmfQNR1WvBXBML3j8DWi2H8DQT0SR/WvatM3rFLfXD81ljzWrtG\n", + "aKE/cSLM/Rh25ZlnqZlhVD2nOE3pRfNkoorlTuQ+OP1TOP1j6PhDGUHlnwAfA/OVTeXVV52uk/K7\n", + "uhKYci3dKoL4HLhX2VRRlfbZpQ1O9ZBWFaVGtGbepX7kvhcKSyFkLhS9WHlMD/8JnHH+l8w7o7Q8\n", + "ZAtPHv5c/b36a+Cm7ur+LUy8uJxVLR5Q3x14ur7O21AVo+M31Iqm9qJ5MuB1Mr/Ltw9z884IYAJw\n", + "DrAE3Ql8ZaluaoWjw34V4l87E/52AfT5hv2H1nKLr/dO7BLDl7F3sCv+evyDo6nIbkFgQBABoUSV\n", + "5ZNckMo9R/L4qTNcMJGC4hZ8DExXNnXEa5nu81rjVv7I0Ox7gMuVTS2v/jhjDVQbjOA3GJqQ403m\n", + "W5Y6l6I7gdHAz+hO4DNlU1k1qcvhCfTT3mA7Hz6cC6cdqvuk/CUt5acpXTnn4dHQNh++eg9iCuCK\n", + "YH78/EF+s9p/i7Kpb3wtU+wyDngLuFTZ1Mpj9htroDphBL/BcIIgdolA2+xPAMaiLXM+Bj5VNrUP\n", + "ql9f4QhtWSFQ7A+OgPZ1jR/s6FDK/ODh0fBeP/jgI3h8j+5QxC5j0PMIXwF/VTaV7+P5XgzMAi5W\n", + "NpVSZV+lmkzBWS/B6ml6rsFYA/lEbWSnX0M1xmAweEfZVJ6yqbnKpq5GW1j9DzgL+E3s8nPEVJnZ\n", + "pxUvLICxc2HkAhg7DJ5NEEkCpydQP+UU+lD3SXnLlcW2gAr4x2J4cR6Mnkz599ezR+wiyqYWAf2B\n", + "cGCd2OVcH893HjANmCd2ObPqXmtivN16vdCswmFzYqyBGgoz4jcYmhFilyDg/HabeK2iK506H4Uf\n", + "3nDGLXaochpyUt59zmd9X+buncidwG7gZmVTR622XgG8BLwN/N19QtnL+Y23jhmnbGotuIz4Rzyu\n", + "HR4ufMbKbUb8vmBUPQbDScIkkaXvCyNXd4Cz97mku6hyGnNS3gr681+0Wuoqh9Du3lUm55zPM8Ut\n", + "iezzBesKdvL48dogdpkAvACMUTb1W6WOf9raeBb/E3aMxoSp9B0j+BsRY4VgaEgcunb39KZeUS12\n", + "mYz2YPpgHzvp5yiefVmI/yAB/jwOYn8lu+QnbtxcqL485ljXd6ZFVhSJqztzeu5IZVMbpFfX67lq\n", + "3+v86/LllBcWmDCVvmMEfyPR3K0QTlWnaycTzXl9hdilN/BRzBaid3xEh/NvhB1R0KYAssLgiD+l\n", + "5SG8CWzAsWDwk469SL3wQUpmx1UWFDQ1k/GfBnJ67nBgBDBc2dS1TXFOJzJG8DcSlTrJM2aB8tMe\n", + "D8uCISh5NVf+9gBQ7LIVuf0uBorrw+WuJ4zTtZOH2qhyGqvTF7uEx24hLfBoRLtO3/RGlYdDQD5j\n", + "WqXy6qi8zIzeRKJXCmcCseQGn0GIhFIRAE+nQ0mkLqjlqN/487I2wDbgBWVTc+u7rSc7RvA3EpW+\n", + "9pP+CEF5EFAEAcUQ9mM2XQ6tQ3vLdGwhbr8dWwXVdAy13Xfa19yVnEu/kDLofVBv0PQqAkPD09id\n", + "fj+JSskMGjsoq2ROZVocVxPG1ynrk49OBmajn/ObSJ44C+aMJOQoFLVEe/+ElgxZnxDzi9+KafQ9\n", + "73l+PpjDE2aAUjOMk7ZGw/JJMv8Ft/SkX3yxQrBcLgfgvVM4Xqfhui8caOVIz+lG20/KtG33+FSn\n", + "4DdO105+OsP0mRBvGwVvDoTAcgisIH6nPx+IXbYCpUCZ9bfUw+/q9h2T1++8Hm0rCi6Eitk6Ct3m\n", + "K0ljDgGMFmX7Lk3sMgr4E7CS4Wsz+eF7KPoG/eiXEUEkSayLm9CGsFd3w9c5nHOzHy8miNxphH/D\n", + "YgR/rXAJrFHJrWnav/nxsYKmOF6g3PpsWaLIwrkeJgWN07WTn0g9GOBPK+DGtVDqD2V+cFcIW5bc\n", + "wh+AQPQ7H+jhf1/2BQMRjt8V7Uv9KVkJfmV6FL/5SgDKAqJKQQe1B54Wuyxk8I5v6Hqd4vMVQm5H\n", + "AHrTUb1HcdgNveGyLfocZlXQdUwQD3CKhgRtLIzgrwXapW0C2uVuw/rarykNFUvW0PxxLOqKLtKb\n", + "gxA4qGwqxYsl2me1rU8ksRe81uGYHZ33nil2udhatIWyqY0SMHY9w4fFcscZkHI7LHmUcHqKIp1l\n", + "XeGJb52Hl7VliHTpcSN7TptsrOYaBiP4a0lj+dqvKRuUmp8gQpJxunbKUV2n78USrY5B1718+UZk\n", + "vAy8JHZ5B72wq4zylsEsTYYDfWHCNRD/NUfeDeeHArjmGXgdrUcaA/x+oN1RyvvOgkHiTH3bBIiv\n", + "R8zkrsFwEuHNEqjSEi0oD/q9p/3hINR1daw3x3RilxjgXSAImELyuDcq3Va3Wws3j8CvrITzvyhW\n", + "i7dQ+d6PJaJsERMUzA501vIQWnv5DytcpFk/40qTWPWIyDjgGXTEn9eUUv902z8K+BxndKiPlVKP\n", + "eyjHCH6DoYGotEQLy4Lrx8Luc2Hhs6AmL1Nq7qgGqdMu/sDDwG382HpG5OKB00/Dv0M4xeT7V5Df\n", + "5wdVfD4yYhc8Px/CS2Esg1nEKggohOgdkNXHKu0RYON6aB3aXNfPNBWNbtUjIv7A88CFwD5glYh8\n", + "oZTa7JZ1mVLqsrrUZTAY6oJliVYQA7OXwDWXwBVT4Yuc4/rXqS3W5K5d7PKzDD00p0fptwErv9eO\n", + "5SiHq9dT9voWAmcMgSBrVUsxVsCyjqvgqsnw2gorSLw/UBgLM9sQUAgt9kF2PJ7CW5pV9cenrt45\n", + "zwa2KaV2KqVKgQ+Ayz3kMyN5g6FJ2TNDj46B4pbwztcQ+W0B07+NErs0qKmvsqlvznuRdeFxRF46\n", + "BbKt2npCYEQJ/O0HCKzQacFYXp53jYCf74PJl0NgPvivVoQW6pgFcd/osI44tBVOL57OuYwFY2Hu\n", + "SP132LM63eCgroK/I7DH5fdeK80VBZwjIutEZL6I9MFgMDQqesS7/B5IWgiTllF61UI+bDGFlmU7\n", + "gAVilxYNWX/7bGTpbBiUAQWW9n4McIubmXEpWzKEG3VM6OX3QuYAGN+nnF5rlnD7yi5h4e8weMsL\n", + "jPxiK4PDziSCeei5BQdW0PuWuyEy3UqbGa/nIQwO6mrV48sEwa9AZ6VUgYgkAp8BvTxlFJFkl59L\n", + "lVJL69g+g8Fg4ckSTewyD62u/Vbskqhs6mBD1J0LRYEV8OgSZ9oI4GHYmAQHwyEsPZb4DcNyD6vv\n", + "frYTffbb7O24jnn5R/jzvi70KV8asjHQL2Dq1JHzZ1dITAbAWqZwdekyglY4S7V8+w9/Ao50hx//\n", + "z0o/eXz7W/Omo+pURl0md0VkKJCslBpn/X4QqHCf4HU7ZgcwSCmV7ZZuJncNhibAWkn+BDAeuEjZ\n", + "1N76rsMXp3NiFz90QJpxQICyqTgrPRb4pe8XZF0RxRlfnAbfvamdwgFcAtnlsGoPzNjIuOkEfDqW\n", + "ezvCy2shp7NV28nr27/RrXpEJADYAlwApAO/AFNcJ3dFpB1wQCmlRORsYK5Sqlt9NN5gMNQfYpe/\n", + "Anei/eRvre/yfXE6Z3VCi4EzgTOUTe200gcHFvLzqtkE/tAVpqyH1paCxwacTQS30qcgk/ADqo+K\n", + "5SwJ5s3vrFJPbt/+TWXOmYjTnPN1pdRTInI7gFLqFRH5I/AH9EqMAuBepdQKD+UYwW8wNDFil1sB\n", + "O5CkbGpdfZfvi/dQsctKYCX6C2ScsqmNAH2GyLrCYfT/ZaYOAO9gXFAE20qSSMNyFjd5OGzJK2FN\n", + "9y1QtK+FtpftAAAgAElEQVS5rKpvKIx3ToPBUGfELhPRev8rlU39VF/lHs97aIJIUpuW/OWnOxkx\n", + "6j8sWTeMLVmjuRp4ANjXch2jQlswPTSKsKs2Qm4wfBsGe8JaUBR4OgQfhTeWwfRe8L/dUDz5GPWO\n", + "09SzvAP4x0JoBhSmezL5PFHMQo3gNxgM9YLYZSzwTquVzDh7AefWh39/R1Sx5Z3gq15wJAQOh8KC\n", + "KLIqjnAw6RvixvYg6Kte8NFcmBxF+fyxHMk9nZbAOmB7YBaRfsGMCM0ieOjn+Lctg91lIRyt6EwL\n", + "WpIflkdqQlvyfl4GTKqyOM1p6nl9PHyNntZwUHUhWHMPtuRKrWSnUqpZbLopTd8Os5nNbHqLGcV9\n", + "wfdTNqcvSqG3W2FrX0iqTXkTYakC9WNn1OPDUc+fhXqnH+rsfvw2OpQVCtSESag3BjrrS4QFJDOc\n", + "ZA6QzFVKKeJimNDiLkpfHOzM9zdQy6z/JwW0VxF8pSBxgWv9MG4hoQcVra90HKaQcuf/Lvlh3EJQ\n", + "ip7zFIH5HvM0l602stM4aTMYDB4ZtJSL/rEZ/6Rr4WgwTPsVZkJ8ElRZKesrDu+h5+7Rm4N3YZ8j\n", + "XsTtKXBmhnNfBIQqm/pB7DIGmC92iR6XxYSv3yXgnFt0vInzd+qx+2Vt4bmRUBSwH7/AK8tpW95J\n", + "7LICR/yK/wuIJ6gtFAeCfwT4F0NBG3jaUaGryWdkCCGH9erhp9NxadFJYRZqBL/BYPBIJIQMyISl\n", + "s+GT053ptQ3qU5330LYEPAZlXLS96jGOOBLKptaKXUYCiySKirjD8N7H8LcL4OfXtWuADnkwehOE\n", + "lEFWeUmZvz/lReWQeg4pBT0YQ3ZoDl9/3oqsL6DsUSgPhvJA19pcFoLlFtFrHuw4H0oivOQ5cTGC\n", + "32AweMQxQu+ZDQ+4TPHWNqiPN5fhG+nLbtq3v5qdzCGtMv9UJGM3qjKOhLKprWKX8w61YBtH4IId\n", + "MOINpz+YmAKYtFH//x9aBOcHnjFge0w+6mDqma0y8+zZX3dZA+9ZOv5/UFXH7x5Iac8MEv52Hpse\n", + "Dfee58TFTO4aDAaP+LLoqj5wuIyOGJxI7607CT/alnxC2Up6yhH121nu+YeFyNqeQQx4yyV23d/Q\n", + "q75GANcSzhd+b5FXoSOCxXE1wXyzdRNDtjuteUrzIDBCW/Uca/IpdgmlnIP87/zl5LUJaE7Bltwx\n", + "MXcNBkO90XhBfbSbhby0F0i55nLY1xPmvQDl1+d7yt25mCPXlMG4DhC1H1pXQDF61ddTtOBH/9fJ\n", + "m2aHrzrA3qGkMYdozo2DBT2dpUw7AsunViPIx+DPSpX73YX1e67NAyP4DQaDVywh38CjXMtl9OEe\n", + "8PpyGH8DTB0NnwSWe8wNRePKYXQmLK+ARTiVNiMZSN7ln2nnbnuHVB5TSjs/znsKjnaF9dfgyZ2z\n", + "G+OBT+vrDJsbdfXOaTAYGgiRhCSRxIUik5bqvyera2Gny+iIkmUMnpPPqI/Xlp3Vctl5XfrIPcfk\n", + "1pPE24LKYSQ6NtcVUHAlrP9lyK4i2q6Hr17G1Rt8ATGwbwiMStbB4QFvFjpilwDgErRDyZMSM+I3\n", + "GJohDRMjt3mi1Ib5Igm0pL89iW1936MwlKMEcBQmR/F0+3Ol4/6f1P2O/O4qqP0QHgJ+RT2Q0lG7\n", + "A/xeu/RIRWlYlM79PfB0RQXd/djxLWxqDf3ehXVTqcZCZwSwQ9nUHi/7T3jM5K7B0AypjJF7/RhQ\n", + "fpA+WG8H/reE6d9foGzN5MWtRxwre98aAAfDIKxUb49GU5I2ii+BF4E8tM+vAqAg7gXOHXmIfzwV\n", + "Svzg2+CFefDs75HpyxicUUZAEHSKg1lhlZUE3AuJX8G889Ko+MWj4zaxy3NAhrKpJxvp1OuEcdlg\n", + "MJwkVMbIjUyHDil6i10Nnb8pJbQ0G0hx2VYrm8qotsATgEkiS+fCyJcGw9bWOmBLQSB8HcGhA3GA\n", + "1t3sRC/ICgPC/EpoQwD+SnT4xlaFurNIh9zCsogK8s9qSWkYZMfpGMMAHc8p5dwNz6s5Ofe6t8Hy\n", + "Drob7aHUPYRss8RY9RgMJw3WhGduB9hymd4ASPyW5IW3AYOt7W5gsNiliKqdQYqyqazGb3ftcawb\n", + "+ENK1fQkWLUgmUuBp9FWm5crm0oF3VnMgZEL4mHIXr0otyAQbgtjy5KgM/xRD59BYEHVhVrZMRvp\n", + "k3uF2OUBZVOlbs0YDOSfKEK/thjBbzA0S/bMgGlxVXX8t6bBnucs3fMeLKsTa5TaDWdn8BdgkNjl\n", + "KMd+GVQJgNScqG5lr7KpMuAescvNwPdil5uUTc3LhSIBkrZZB1ih40OyOQjhAqOPraiwdD9wEJgK\n", + "vOa296S25nFgVD0GQzNFT/B2uVtbn9RsAZEVzaoHzs5gMDq4SRZVO4NflU0d9VSGL77z6xsfg7UM\n", + "Az4CnutjJzhecf8ZEFaGjuP7lrXIbCN9OXaCXAdlIXnjESnh0wv/xdqoMoId57cxmaeBqcqmfmnI\n", + "86xPjI7fYDB4xeoMelG1MxiIjp7n2hms6ZvM8Op85zd+66sidunkX8h3nXYSu+kTIsIshc3NUPAL\n", + "/GuDUnbw3nkmiCQdupEPk9cTdvtqfeyNfhR9cQX+Z3/Kd3tVw3dy9YUR/AaDoUZYNuu9qdoZ9As5\n", + "gpq4i/DB6XD1BmhnraFNgoXzlWoWsWsvCpZF7S/moo1t4bMPoIv13eJLGxNFFto6MXbSRNg6A4Kt\n", + "pWIT2sDHB5tXJ3c8zOSuwWCoEZbufIO1zQYQuwQO+5ifR7ZhcEoHHenKIfhr65mzIYguIeitT+G/\n", + "w2BOX/jrzzrdlzZGQsjQvTBuG6S1gj7WNHgny/9PXdxPnwgYwW8wGKqgbKo0MVkO3bIHbllTdV9t\n", + "PXM2BI6J3fuWV033pY0OC6JXv6yaHlHs8n8z6uTqG+OywWAwHIPDLYJrmsPCpqna5E5d2ujp2L+h\n", + "3T84aE6dXH1jdPwGg8EjvljYNDXubVxL9IoMhgzzJUC649gQ6FgBcfdC2AhrX0O4n24ozOSuwWBo\n", + "UJrCxNNX6hIg/UTo5LxhBL/BYGgwPAVmqa31ixbSnaf7MjL3vUzLv1FAIZzxBqy609qTtFCp+c3C\n", + "EqkhMFY9BoOhwegM02dCfO+7YNWrEFnim/WL+1fCSmKXw8XXwatWByLUj+dRHdCF8iC46K+w7gYr\n", + "Xm7NA6Q3TMdU/2XWFiP4DQaDT0RCyDwi2NqygCR1DmEUMZ1UIsjzKlhdvxIUkNoGhvQIOp+uR4Po\n", + "1g7e/A4OJOBDYBQfsPwbKX842BtiNsG+s6lpgPSGcInd3NxsG6seg8HgE6m0jLiHJCokgB8rFrOI\n", + "VdxDEqm0DPd2jOMrYdqlEPsXSLoWwmKLgvj9Eng1xRL6Dmo+Mq+KM6ALBxKg7QZqFyC983SYGU9A\n", + "kUvazHi9Ari2WGVGZFjtqo8ya48Z8RsMBp/YzJlSxhzw89ejaiCNOQQw2qt+ORJCACZugod+gG5H\n", + "YCydWcQNHnLXbGTujiOgCyTdTe6OXnRb7MeaaI8+96vHUhlNmAK/XQ+br7TSa9cxiV2iOadfd+Iv\n", + "gNhf4ccHXTq8unZ2tcMIfoPB4BNltNHrWh8tc0/P83aMY6HUmDRn2nRSWcY1BcW85wyQUquR+bFY\n", + "Qn6+2CUR+LP6ZF8t1Ci5RaCgy09OH/5ATTomsUs4cBkwBRhJ/L5CVtlgaxKUucr6unV2tcUIfoPB\n", + "4COWDh33Ab534eXJ1fKn5KWFsfTtYpKG1sbzqI9sABKOm8sje2YQM7E3ZcFdOdrFStMdU3XmrGKX\n", + "IHS8gClAIrAceB+4jrdiz9O9yAQ3T6F17+xqgxH8BoPBR7zFCPAuvNzj4zps5LNVekNPaO4FwsUu\n", + "rZVNHarJgX3ZSHb3NHVoX1hJMBflF1K+vYwDf+/LRtzNWW8R4tqMkf6HziUe7ct/I1rYT68SCMeG\n", + "Uw3VcJ2dzxjBbzAYfKKKDr0GwssaETeqgOubTOKuP1Ax4FsWJyZLpq8LzRxWSNKuqFu/nUXczeKg\n", + "adByOc6JagX80hHe7wcL+hJfVMyDwGPAwOMHaHfY2zftmiUj+A0Gg884dOhN3Y7qcAjvc/cQNaAl\n", + "A+8EpkFcggjHE/4O4d63M9xuhYB0rFWIsCaq84LgjkvgilRYOhsePsSauUr9p7pyjTmnwWAwNCAO\n", + "4Z1wADa01WkzIb6LXmhWLZEQUi7QNwsGZDrTIyDUMVEdWQJrXgHbMuh1yFdnbpY5Z+ghGPEYSAVN\n", + "ac5pBL/BYDipcJiQ3rgW/r3Ime6Lm+VcKPJXMPdDCKhwpudBYd08lkaG0G0p3DEQQo6ClDtaZcw5\n", + "DQaDoa64jsxd8WVkXl3Ad28T1cdTH4ldArmkc2dO+xE+ewPSqjh/bhJzTuOkzWAwnFS4uon4HlgE\n", + "bIOibNiUDo8cT1DXp6dOsUs34D1yAoKYObEVue91d+7Vgd/r7gPIeOc0GAwGEkSSWoG9J/R93UXF\n", + "05ixdMUuk4EZwD+AZ0juO85T4Pc612MEv8FgONmorVfLESIpw2HQ5rbQMwsuVjCChg8YL3aJQAv8\n", + "84ApyqZWN1RdYNwyGwyGk4zamkEmiCQNgT5PABzQaQ9Z+1wneesjsIxrGTu7EeQ3hS4VwXwDnKls\n", + "yqs7i6bECH6DwdCMscwgT/8EygPh90vxxYVzZ5j+OoTmBMPEidpJ3F83wdNFzkleL4FlqrX3d//6\n", + "iGbd8glw3StC/DNDYcl5cO5CMrPX8OEG1TyFPhjBbzAYmjWWp8ycTjD5cvjucVhzC8czg3SYdIaU\n", + "wR0p8G5/uG8MRO6gIr+IX8UuIeMse//3EyC8VDuSm1nmPbCMp6+PAq4ZfgVfhj0+Io/5PWHla9Dj\n", + "MO2OF5ymqTGC32AwNGMsx3D7zobZy+C6cRCZAd/nVmsG6TDpDCqH8al6OxICQwayZ984hgH71k+i\n", + "ZMkvUCbw32Ew9QpI2gpZ2+ksdglVNlVZhzXSfxM6tiFoOgSMgIKrKOa9sOc4iw9WpvDgDxBo2f77\n", + "smagKTELuAwGQzPGJbjKoV7w+s+Q8HQJdy4pF7v4ez0KZlwfymHXtL8UkRa4gjuVTY0GBgRlc/Te\n", + "sfDgRXD2PvhoLpy7G34/m1ggQ+zyvthlgkT1Gq9H+gvaQDKUzIDSH4DvASginKgip9AHX1fzNh3G\n", + "qsdgMDRr9GjbxQwy5vfX+GPancAR4FplU0Wejms5UXYOnkdG60KKPdnjO3T8f4oh/t3+8F4/OFxG\n", + "SVke7xd0YwZwFnAVJf6jWHZRAGs7Qn4soIAxwDfAY7RnSEEGv1TGFrgV0lbA9MYwGQVjzmkwGE4R\n", + "xC7BwGygI3C5sqnDbvtPA5YAnZRNVY7F3SdnY1m5fCCHh0ZAaK5QmDKKbw+OJA6YCGwC3uXZYX8m\n", + "/8zTKHnepYaHgINAeVo0898eSsbQ+ljwVRuM4DcYDKcMYhc/4GngQiBR2dTeSsF+0Y5etDzqz0et\n", + "/+Aw+3ROzr4a7wwmM20bLL/H3TTUJajKtRT7T2THxcL6a2HLZVAWYuVKLIE945vKp76D2shOo+M3\n", + "GAwnJNZI/l7gLeAnGdzhdksXP5ZuLbqz+p0uMOxZLfABOk8n6qF4bhoB4ZZxv5uHzASRpESRhROT\n", + "WTQumTv7JvMm/xu3ic1XwpmvQWi2SwtCtzS10K8tdbbqEZFxwDOAP/CaUuqfHvLMQIciKwBuVEqt\n", + "qWu9BoPBoGxKAf8Wu+znwqzXOHBjEDm7IXo77BoBXOC0+e9eEMOV58CP/wf5bV1K0aah3uz6txQV\n", + "5JStmwrrprrVXrSvwU+wgajTiF9E/IHn0Z9EfYApInK6W54kIF4p1RO4DXipLnUaDAaDO8qm3uar\n", + "walMHg9dbTBrOFQ8ATwMlHUUu0zg6p/78eUrsHK629HaQ6bDj/97/WBxD71nJsSfzq8V2qGaK00X\n", + "L7c+qOuI/2xgm1JqJ4CIfABcDmx2yXMZ8CaAUmqliESJSDulVKZ7YQaDwVBrNkZlkPFkf8q/g6Of\n", + "OtPlxt5sinyZvWH38fsX0+FSjzGDHYu+MiJgeSe4cLs22OzC0bjcHnNz9xT9Vkp6+9RyyvbB7uf6\n", + "spFEkYV1cffQVNRV8HcEXGNM7gWG+JCnE2AEv8FgqEf2zPDP/mhUOQuD6fMhtEmF7x8BNTuQT9M3\n", + "qJJFz4kkpHmLGexY9DV0L3yQoIX+18BXED3unNzoJ9atYkk6ocutwCs1dffQnKir4PfVJMh9xtnj\n", + "cSKS7PJzqVJqaS3aZDAYTiEcljz+9OjgB0HlfmUw+mGY7zS/bFFaPniSyNJxULSHjR5H5o4gLDMy\n", + "iN8UAwuAp4BDoZDSAT6ZA9dY8XcVyEyIPxAObfP18Y7YvDSwqwYRGQWMqksZdRX8+4DOLr87o0f0\n", + "1eXpZKUdg1IquY7tMRgMpxCu/nPKgfLAP0HCm5DbAbZfWJnvbHIi5sJI8D4yd0TYmlDG3QFHOHdj\n", + "MFBMZOtCSHsWwkp1Poc7hhJ/OOcWuHslTF+pR7eN4arBGhAvdfwWEVtNy6ir4E8BeopINyAduBqY\n", + "4pbnC+Au4AMRGQocMfp9g8FQP2jvnRFd76N32evklyo2jyqDDxfjUDREhE9i37BUsn+CVoXVj8yt\n", + "zmC+JLX+PLO87ALIAaBlsTNPHhQqkKByWPwWXHIN/N4anl0IeRXeXTX46gK6tvEHakKdBL9SqkxE\n", + "7kKrwvyB15VSm0Xkdmv/K0qp+SKSJCLbgHzgpjq32mAwGACIDIlgHkmZs5lTdJRnh8B7+/3Zu/dP\n", + "xBBKHvn8Lz+VpX55PD0MnvhOHxUCHb1NzIokJBF0yZAdZd3Db+BfvOUiy12Dq0+DuJlHiP/pdbh6\n", + "InS+noLwBbzuqZUOU9EriIifQW+KCecQhcNbSYd/Zat0uyNfbeMP1BSzctdgMJywiCQuHEzF2FUs\n", + "Ii8I4qfDorehfyY8AvwOzLHylgv4W+LuCij4DCr967iGZBRJXBjBXWOTuJs/soNv0KPaX5Hy7ajH\n", + "Nihlh6qxeXP8KFp6O6XF7egOXKJs2tLRQaLIwruIGHtLYBKZpXOcO/ymKvotTmF8+hYggr0th1PR\n", + "tzVBefD+l3C0i5UxaaFS8z1GDTMRuAwGwynGnhmRZI0AQgsCwbZUC32ATVC2F3bcDBGzINYh9G+C\n", + "gnsh7OXB8O9zoE8W9Mkivjyfp8QuB5AJYb0DnuSG0izuDR1MVlA4rUrzubci1f/FIv+7omTIhNPZ\n", + "EtsD/4xSytM3wb82lKv5YhdhW/hLdChJle6D97IzpiWEZBBxJKt3l/AuD7ZoS2Z0f4i+BZYmQ05n\n", + "qHhT+O2yAeQE7OFgj26UtQhBdYKQwZDXzuU8q48/UFOM4DcYDCcsSm2YP1oCNwNnts2HP6Q49xXC\n", + "4pVKJSaIJI2BRyOhRzGofAgCuPVXGL0DNsbAphg40p32wGsM+a1f4dYD3HMoibTCOVAIu4GpUVcT\n", + "NuDrNhdv2NhmTn4+QBug3y1CXJc+0pZOrduT03M8xcHBXPdjHLldIDS7DSi2HA6siMzOhcM5sG8I\n", + "lIa5nESPIHa0GQeznIlFDwEr0VGCwbHIrL4wqh6DwdBsqE0MXE+uFlxdIzv2vyLE+1ni7iFgLE6x\n", + "CpAoLFxoYzW5QX9t8d+zgnLUjyAV0Psz2DweEKL9ziK7IoWUDvDI+ZDWCna3hIpiKkpzI4s4mBhG\n", + "7gbIvw6GPgOrp8GSx9ATzeOAhceeQOhl0P9CaLMZUsdD2hhrxyPAY+hFZiume9PxG1WPwWA4YalN\n", + "DFxwmmEmWfp2d9fIDlcMt1wKP3SFQekwKANezYD+GRBVBNeHsGPxnbQChjPzopQ81fYc/Ivhihuh\n", + "xT7YmghloVRUtAGgQy78cRX0OAzdD8OECHYuuKhFe+K+gVeS4MiD2rdPj8UgClruhNAAyL4Rimc7\n", + "Gx81BQZthJBOkNUHDnd3ObPUo5C03HWRWX1hBL/BYGgWdIbpr0L8j13gvN06zddFUQ4zTE/7HK4Y\n", + "XvkKUtvA6lj4NRYW9EbFtEP8i6goDqcjAWQAT1BecH9FcCuYnAiF0fD2okpXzA79SIdcvTk4GE1n\n", + "StRe3vuyO7H/g35PQMwmiNkMF/8BCltBbiGkt4SNwyBzEJSEw5E/wLeFBfBiGMeQv9zbhG5dMYLf\n", + "YDA0D1rT8tKxsCMKfn7daTtf10VRDlcMARWQcEBvU9dBPoiEwY5W+JUW47ejFZ075vKVdFoSuPqi\n", + "ZZTsioevvgHliPB4c3kJF/hfze/MYXtl+VdH+KnUgRVH6Jfeie7jSsnsH0jWPki7A1beAwd7g7LB\n", + "NYshqgtk3A0lz2dD2Hr4RyHsXgHTrqtqwtmwTuCMjt9gOAmojW68uWDFzr0roIh/234m8P6fdJB0\n", + "B0mwcL5S1Y58q1v05EmFdDMQLvCcJf6+B/4HtAuAjR1gQAT8tj1c/RSWUFEREi6E5AhnpZbSMz8g\n", + "Ypvy673cj/CCKPLLo0mNHE9e6dbd5G2+h5zAEu3fv6wj+MdCcAjh3SO4dgHsPw++ehkqAnA3zzwm\n", + "vGQN1DtGx28wnILUVjfeHBC7DABmAoVtv+aPu9Zwf5DbJK1jwZTXMo6z6Ml9DqAA+nWBVs8p+MZP\n", + "uw6OrIBPAcqA3XBtS9h4Wb6Et1qpctszB8gChgF980rbl6aMOj2K2F8h7Uz48N8AXSDpdkuYV15z\n", + "GdjpVs5f/CJr/xLIUht6kvfY0bwl5BsvXKMZ8RsMJy5il+gBH7JoUisGp3SA//sRzrY8YfkyUm4q\n", + "xC6hgA09+P4bMEvZVIXroihf49eKJC6EBWNpuwFQcKCftcfzoqf+EpWST89BbfwL6BG6mbg8xeP6\n", + "SLJDobVlOPkwkAqFHyfzGTq847PA8yRP/BzmjkQqIPgoFEVbJU9aptTcUS7nOAT4jNTIuXxwXq/a\n", + "jOZ9wYz4DYaTGLFLOHAmcJa1DQba7zqX8kM7YdJGiHOJDNgYDsNqg9jlQuBltK+v/sqm9jv2VTdJ\n", + "651IPfPa+1PwL3ER/McuehJJSBKu6KBCnqFV6268v09xRziQD991hz+Pg9WvQGCFFo5HQggN20lR\n", + "QTfilE3lAkhyYhEAys9F6IOrrb3Y5VJgFnCjej9nHu/X7IwaGiP4DYZmiNglGBiAFu4OQd8d2ACs\n", + "QvvHehxIHfoq857WZulVyMO7w7DG4Bi9e+cts7llxzjgfOBOZVPz6qemXC2Iy4Mh2MXUxuOip87T\n", + "FW/EMmUk4Z9FAEcJtrxujt4BnXLgX+fCQz/AOuDiYgiaTex8pVwK3jMDpsV5m4wVu9wOJANJyqZW\n", + "1c851i9G8BsMjUB1k49ilwB06FLHKP4s6/dWtJBfgQ5xul7ZVIl72QnJMmMaxLkvYDqebrwuHG8y\n", + "uareXUH/d2HstAvZH/wl7Yv7KpvKq6+2RLNueSlTRueVDQ0kQPcBEUwuDWTtimNzR4aAwGdvkH/4\n", + "TmAfE0r0gq4ngJe+gv63w7Ob+yIH21Cg8jnC1o6uJSi1Yb5IAu4BXUjeuEDs8hgwGRiubGpbfZ1j\n", + "fWMEv8HQwFQRglIBrbZB11sGyh9CVtC+uA0wEB3HIgUt6N8G1iqbKvCl/OMtYKpvfJtM1u6SCTkM\n", + "V02BiAx493t/0m0hSs2vN6EPMISMYXfxVeD95T9z2L+U/iznblIDXyBv6LG5ra+Dw3GkMp2rSWMO\n", + "OpzuI8BPRyMoWdqTnEsjYPZ3LFJ+hDC5zxCJ+q0VR9MdHZz7ZKzYJRCt2ukDnKNsKqs+z7G+MYLf\n", + "YGhwLCF44QMw+BUoioJ9Z7UjrUNv2u+4E1itbOpoXWqonW68dnSG6X+OIf6eQRB3WAchOXahlaV3\n", + "L24BGyfBuuuhIpD6djYGeoHWxeSRU5THijJ4lgwA3vQ4x+FU0+RxMfOBodxaMZgDfuu6VpB6pDdF\n", + "q1ZAv/Ng0KuQcgdFfOAfzVn9FpDSz5O1lNglAvgIbRM0WtlUfn2fY31jBL/B0OBYQnDNLbD8Pshv\n", + "a6VP2q8Wbf+u6dpVM8QuIcCEqNsZemEE3LwGLk917q86mWyNrJU/rLnZpZT6dTYGzgVaUzborbIm\n", + "D3Mc7mqaPPIKCyiMeZ6KQUf3w8DgcA4qf/h8FoQerjwuR8JBHdvBiV3aA/OA1eh5i7L6Pr+GwAh+\n", + "g6HBsYTgoV5u6fUvBBsCsctpwG3ADcCajinsWLOGgYEVVfNVFbTVT4DWFk9zC1ixcj3NcVQztzLf\n", + "tcxp8OzMYuJ7FeezE+Dg6VXq3RmTDwf0/44OzrouC4A3gMeVrZnYxvuAEfwGQ4PTMEKwIRG7BAHj\n", + "gduBvmjhNlTZVFpCsiTd6cEbputksrcJ0LrYr3ubW1gO9yyHe9znODbSF1+iWbnOkRxha8dgrokr\n", + "5r1K3zkBLSeRNSqVR/fDI99DAfQb3FNWyGR6qQD+omxqVm3PqakwC7gMhkagLkvyGxOxSxwwDR0i\n", + "dSPwCvCZsqli13y1WWhVVxJFFi6AsfN6wme9te+dgAr4JISd6QMqdezO7eduN5B7Vy+UP+wdqjeg\n", + "umhW4LxX/gR0jCGz5ytsCll+QR5PnwPRB2DMBlh4Dgz8kvSMVKY19epos4DLYGimNPaS/JpgWaRc\n", + "CtwBnAG8BYxQNrXF2zGNOZnswOFls2OuXp1c5qe31gG0D/6JSzM7sqKgG2louRZGsIRCOviVwaGe\n", + "leVEUTIsUWShN39GrvcqQSTpqY7MbvUL4adFElbYBuaM1vb+NwTR4V1/ptNM72t1GMFvMJyiiF26\n", + "okf3NwPb0KP7y5RNFTVpw7zgmMQduF9vDg5AyGNw2jTwXw5znUHTEwfB053dyxnC0ZYLYKyvvv7F\n", + "LknB+fyU9jL0+SO8+xFEF8MTw2HFhYwUu9wBzG6u180TRtVjMJykeJrYJHnjIiAJrbsfCrwDvKps\n", + "amOTNtYHPOn47wiBHq3hfg/+iTw5b2sVMokLei3gyb15xGf77s+o1c1y4NGNxLQpgMdGwJpXtAfR\n", + "wTQrhocAACAASURBVD1ZsfpastFrMZ4GXmlsc06j6jEYDIAHoddiL5x98VmUSgWBahvaV85EXxeJ\n", + "NQdcJ2HDYVhvaOnXA7I6Apbg///2zjw8yupc4L83CVnISlgTSAgS1kQEBBdEQVwgUdRahWqpS4HW\n", + "2oq211uXXh3G3l61Vq+Vam2xequ1CnWpIhDBKqAWlFVkCYQthJCwhKxkT87943yTDMMkTJJJZpKc\n", + "3/OcJzPfnO/MezIz73e+97yLs0up8wZzDNWXXkxx9MyQTPbFlTFpOow8CcWZDBG7RDgiiZuKSO6x\n", + "l//+5eU8W/B7gt48H56aDIfXsr8yi18rm1ohdhmLTjb3sNhlEbBI2VRRcxHbvsSs+A2GLkhDxsrE\n", + "L2DSMzD4c/j2Ntix+UuVvWGyr+VrK46N3oxkeGYS/Ot1fbypFbyjv+N5dSAsHwZzL+V44WCCgX8O\n", + "fI/daduZ73xHcTMcLYP8GCjNiWNsQS+Kk/M5uvpHXNh3Nfcd3aT+5Pw+YpeRwMPATHJDP+GtmydS\n", + "9qZTPcX5+2D9/b7OzhngrTc3GAz+hBU01vMk7J0J/3sYVrwIhxM7RYDRucjRvvv7CvJ6si4ukClc\n", + "QRwXlW8gzk1+nsb+jufBdbA8k/3xr3E3MArYObCIxxZD8p7esG2ALs4yCuJXwfilMGV9HtHjjzLw\n", + "YDlP14byQN5M7hS7nKFDlU1lKpu6C7iQwphL+OnKIaQtgEjrloTFydq7y7cYxW8wdEmsoLHMm2DL\n", + "PKiOsI53jqCxc7FDqRXvEve3uadvLK+tjmNdr1fJ56uehVw3R5tXzu5v+fpnzIK16ZCxARbsUGqF\n", + "sql8ZVO/SzzM5m/6w5V3wY5+sAqduK0kBG76nh7n7SICo0JC3+DXo7KBeuBed/IpmzrEO5cf5MWd\n", + "ul5v1BGnV72ftqKlGMVvMHRJcl7QZgVn/DtorKUUcsGlVfy9J3kXQtwW62jTK+odSq1YoVTaUqWm\n", + "rlAqzdWb5+BQQq79Afx+JczZfuYG6KdOxpqwiLoIAi76PR/Evw4sFLskupewtJKyOFj9W8i92Om4\n", + "7y++ZnPXYOiCtEfkrP9hmbM++qNLQZSWr6jFLtPkNkZNeo2Cb3LpvRPYbb3Wo07vCTg4XRcO448O\n", + "5atLnqT/5gJG574jdrn47JQN/huxbRS/wdBF8eegMe9gmbPK4lyOt2xFLXa5DngtbhlPDs/l/v+2\n", + "jq8D5kPdy3UE1li2kVkMILMyFSbvgM37Y1kdGEtyv2q28xTwkPO4/nzxNYrfYDC0K+cq2tJ6cl6I\n", + "5OrzRxAYH04VpwlhD7V5pRzzeEUtdpmNTvQ2c8w32F+FuOXDoC4AelXA5GICx5VE19ZLcVCE3ESF\n", + "qqW+6D8h9zk4/y2defT9VcHMmfyA2OUZZVMnncdv6uLrazdPo/gNBoPHtFRheVa0pXWksJMJ7JL/\n", + "o9HCchfCJjxzURe7zAV+DVyjbGr7rIUSCrAmCTL7QFEo5ByLIPvL6UHUfcDpwLf0Ri2/gnfnQ63l\n", + "NZp7EewbUMX5OavELq8ARUCh9dfRCh2Rve4Cy9wlj2tPjB+/wWDwiCYUVrN+6WkiGR8J04tDdV6d\n", + "flZMq6cRsw7c3TUkwIKVMP1IFLw2VmfO9HRsscsDwM/RSn+vNf5fL4Y+tcC1wBXAdCawio3wSCQ8\n", + "exSqI60RHkNfMywGTNrLPev7A18ApUAvIMap9QIUUERRaASlY8OpjIHPnoCjE61Bmk8e1+RcTOSu\n", + "wWBoP6xKYv2/gd5ZEFoEoSOSif34BbFLGmcquhggOvBR4oODIKoKrsuCv72nR4pwWx3LPU3dNWRb\n", + "+f9LQuCt8xsVf3Nji10E+C/gB+i6uIedxu/j6Pcr6+9WoiqBUMr7QGCN00hOu73M209+yc+BWqrl\n", + "DZ6btp3K2B5QWgQ5Tyi1Y4X1vqFADEsv+4DAJyYSWgQlzqmEOs7N0yh+g8HgIZYXzdDVMGi9LiFZ\n", + "FQ21oYHowvDOpo1ioGjK8/xldQVXBbgYFtxVx2qKBFiwGJK/6Q9LU+DRz2FxDclpcBIgrAYqnDRZ\n", + "U2Nbyve3wAx09tF85/Ez+8CLEyH1OKSdANsJCgorVDYwnt8fdBntq2q4tQLKaiDnDWsjN51by8OY\n", + "mno1Gc9b/RwmHLUCLVeFLEw7BZPcSNhxbp5G8RsMBg+xvGj+/aDL8cxMtXLvC85HLNPJ03XQbx6U\n", + "vwoNhU1ci7Y49Xe7AexIx9y3HA72glE/g2dWQehO8uZD0RO1JFcGNT02gBVh+xIwHpiibOqU4zXH\n", + "+JFVMKQIvh4Ir46Dzf2Jqdu3CVbcXk5pY2EWmFsDjwTDFcH6+fw5IqkbIWEBH/0tkntTdY3hvAvR\n", + "ZrF0p1rE4A9unkbxGwwGD/FMYbmaZtYBN0F5AOyvhFxH0RbHRnEgPeL7ctHQp9nV8zrKgDM3gB3p\n", + "mONL4e/vwrrBcF8aHLqMgT238V8HdnDzyWCuTIfV7grCiF2CgP8DBgFXKZsqdX7dMf7AUvjF+sbj\n", + "acLqDFvpT9i/5k4OXnEbgWExBBf35tJ9PRj4L/jLl1A6kEblHhFKRW94/ROXMptnmnD8ws1TKeUX\n", + "TYviezlMM820phukpEPaSrh1jf6bku7aZwZkKFD7eqHqQSmrpcHKM8eZl+X0shocdb2yDQs9q38K\n", + "pM+DLOXU+e4A9kV8n5dYyHEW8gcWUulW3oWEsJD3WcgKFtLTXR9348+FfSlw1tzg1jVIrSI2SyG1\n", + "TqfcugZmZDjPp7GlrWzJ/7jlnwmqpeeYFb/BYPAYT4LCIiG0XuCWWXrj9Xs74LYdEHHcedPV2igO\n", + "OwXjF8Oo98iO3cerOyNZmKUtSo5NWud0zA2lHutZVPo3tULs8jgngl+nT3WITB6Tyb/jD6GOrIeE\n", + "S5HwnsRfMpoLM3czvugqZVPV7uR1O36TpSRLK1GBcCrZ5XhZBeQs8rUJx1OMO6fBYPAqjhTICp3l\n", + "8q3z4e1UOFkVWFdxYNABcmuf4ttJd8DSKfQ8AVfaYPfNcGgKU+qvYQ1rAQ/dMh0upr96PZn8cRBQ\n", + "DCuG15L7QVAEyxnJC0SxrVJxatdxah9ra+yAe5fWefthw4KGDd4Orq3cGt1pFL/BYPAq7twvb5Xz\n", + "WJ7wYypSD0PqK3X8fWwNRzaEup47nYlksIl5sN+RPdN5XNcN4J3MWAArp/NQL3ghC4b/EK7eRMTn\n", + "KaRv3McSdahh7Pmwbz3c7x3l37HKvXl5WqE7fW0zbIudyjTTTPPPlgLpabDyaiJPTWC6ioh8SRGZ\n", + "q23eATWKuLFlhM89wxYewp1qDP1K0mClq33dnR1+HmQFMnM7KMW4VxQ9TiuwKUKK1YTeg5UC9c8R\n", + "qDWDG/canPcZukprje40Nn6DweB1rFX1CpFZa2DpFG6cDtsjYPsPoD4I8pJr4Q7gUQiqgdpQqvgh\n", + "2ynf8o1aepZ5x+FrP/sWeGk59K6AxZD8D06cLAbYOtfqWQtVUYRXJQHZVAbBj2ZCdBX855fQM5Oe\n", + "rmN3R0w+foPB0C6kiqRHk5NC7z0wYBvsutXp1bIanRThf6D2GXT6gytoKojJ4WtfGQQZTtb1EezO\n", + "O7PuwLXA/JrThAAweyfsflEHfT1/CXz0cyaKXX4mdgn36mQ7GUbxGwwGr+Ow87/Jjj7RE2fqKmC1\n", + "DpP+vP2Q84eWFIpx+NpflwXLnVzke1Ocy8iPf8+Qi6qIvD4TnsqA9b/JIm/T7YRVAAQouCkTRr3K\n", + "/qjNPAZMAw6KXZ4Qu/Tz+uQ7AWZz12AweB2HZ09ZMMQ/AONeHoOU9GIbVSeLKb2zpR4wjguJLYrk\n", + "C+6BY7+De+rZ/+FU/nhiKr8E7lU29a7rOYlNuGiKXYYDvwBmA0uBZ5VN7fV1uuTWYLx6DAaDXzBL\n", + "ZM1SmFIVCF8kwlVWqptZsHapUlNbM2aqSHoA0fadg4aNCz0RXV6ZdCy//tad/QlSs5RNfdyaMa0V\n", + "/8+AeyjqsY9/XpPAoeWDGns0n33UH2iN7jSmHoOhC5Mqkp4mkjFLZE2aSEaqyFmFyNsDh2kmpK5R\n", + "6UPLkrO5spMUvuXWmPojGwPLk+6LrL/h2DD+Pr2EhSmB5z7bPcqmjiubehwYwtbBMdyQOYi5k6DX\n", + "fqtH0zV8OzW+dkVqi0uSaaaZ1nRrygXSXSqCjnjvptIgeNoaUiL036Z4sL8ifqM19DWbvCFzQzqG\n", + "0f9Q9Cg7Ix2Drz/L5uVGtfScVrtzikgssAQYDBwCZimlitz0OwSUAHVAjVLqota+p8Fg8Jy4YB74\n", + "UR+SX+0Pd28FQbtApoNLtkjv07I0CJ5ipYU+Ngb+tAVK463jsaNFUtPbbo6x0jHsusXleMelS+4o\n", + "2uLH/zCwWin1WxF5yHr+sJt+CpiqVGMaVIPB4F3ELrHAOGCs42/ALxk1/ySMzdf5cnpadURaUgSl\n", + "LTh8+b03opUWGnFS+gDDwqDECxcz36dL7ijaovhvAKZYj/8KrMG94ge92DAYDG3EKiaSiIuSR5f2\n", + "+wbYCnwKPHvVUzy1qpZrXcdoi53dt+S8AHOvgL84XbgeRddV2dPmi5lfpEvuIFrt1SMihUqpXtZj\n", + "AU45nrv0O4CuxlMH/EkptbiJ8ZQyXj0GQwNWHvmRnK3kK4FtaCXv+HtA2VS98/nucua4y4HTmRC5\n", + "YhNMuVCXPqwDrkEHfrWuXm1XwOs1d0VkNTDAzUu/cn6ilFIi0tQV5DKlVJ6I9AVWi0imUurzJt5v\n", + "odPTNUqpNc3JZzB0FaxI0jFo5e5Q8KOBIzQq+KeBbcqmjnkyZvvY2X3Nqcch3012TM/NMZ3RV98Z\n", + "EZkKTG3TGG1Y8Weibff5IhIHfKaUGnmOc2xAmVLqWTevmRW/odPjiVKxfMcdK3iHkk8EdnHmKn67\n", + "sqmyjp2B/9OW7Jju0yr7v69+c3RoAJeI/BYoUEo9LSIPAzFKqYdd+vQEApVSpSISDqwC7EqpVd4Q\n", + "3mDwJ85SKlIPsbOzuXz1m4wtVjQq+Z6cqeC3AZnKpmp8JLpPaa7ebmsRuwQC0UCM1fTjVcOfoP6e\n", + "VEKLYP1/QFWUdUbnNRV53dRzDp4ClorIXCx3TkuIeGCxUuo6tJnoPb0FQBDwpjulbzB0DayqUiM+\n", + "gEnPQv9voDJmMMUB84A/AovRiv6wsrVyxdXFcLcPMR+GjgqRgMxHWc+ZyrslLRztRl50Rkss60tR\n", + "NlTG6AtzAxEd4unkL5iUDQaDl2hIQdx3F0TkQf5YqOgNzFqr1NKpPhbPL3Hk9DkWDlffAUWhupX1\n", + "QBHgorTdt+Imjpe6bnYDiKRlwMrpZ0tiVvwGg6FVWH7mJ0br1kDXCwDyFo50y7EV8Pd3IaZS586f\n", + "W826f9S3LqdP83QfX/3m6HKKv7Pv2Bs6M0aptBRHTp8e9XD+8cbjp9sp1qA7+eo3R5dS/E3s2A8V\n", + "SaW7fbCGjscolZaTAy/Mh6GusQaHod0ultbn0a0/ky5l42+w3wVV6o2bGkeVtc5rvzMYujrN5c03\n", + "nBtj43ckcUr8AmZ/B7KvgL0z4YCK8bFgBoNP8dRlsj1cK8+F93P6GM5FF1P81ubagavhf3MgOQOG\n", + "L4NrVl8odtkKfAQsAza52/E3GPwBbypfkdT0aAKeSCds9N+paHBZnA9DU0VwHrcp10rXfobOTxcz\n", + "9biz8c/bT/CXD/BoZglwPTATndBqOfoi8ImJjjT4C00o333r4f6WKl/H72ECh5NXh67ik/MgLQvC\n", + "rTCxdMhYoVSDCTRNJOMRmP7PIDgSA3El8N1qeMqlX3OyN3fBMo4X7UO3N/U0ublWtdvx5VoH/FLs\n", + "koy+CPwMeEPs8gX6buAjZVPZvpHeYIAEWLAYkvMiILMPXHmodTn0xS6BnDfhMZL6Je8d8haJ/WDy\n", + "YZiYC+HFuo9reuY6iP8YeK4WOKmP3R0BBT0Zdq73O9fdgnG88C+61Iq/Ve9rl2hgOvpCkA4cRd8J\n", + "LAM2Kpuq62iZDF2L5la6TmmWxwPj+2Rzb1AssdWBMPEorHgTAlTztWqt9ARJwCXo7/FEYDD1Ekh9\n", + "kAxbHcT2zRWE1p55npsV/4mV0GdjvA6iUqKLaSzoT/3ea9kJ/AOdXkLQZVsb/o7+iF89XsHYsmB4\n", + "OxXu2qbP/0042zOn8xyrhj9IxUOpoOBEChy5xCGFcbxoI91+xd8alE0VA0uBpdYP6BK0OegVoK/Y\n", + "ZQX6bmCVsqlSX2x+GTovZ6x0pR5i9xEZ+Z2Jk/oG1IT3UMETQ4nIvIjS0lGsB7YM2Eb2RweITSw+\n", + "s4hFGVRYi5QR6FTNI4BR6Pw/g9A6WtDpUzYA/8UfJv+YU2un5rGCO7mfJexvGM+dy2QY5AF9Xr8A\n", + "dvcFUfqiUxBEOVAP/BKdCzkLOEpRj74URp6HCgo8MfRU9Lv1tdQDnw2BvuX63OIQ+gPTSCzrS8Xn\n", + "oAKgJtxJ8XevVAn+Qrdf8TeH2OU84Dr0heDSoFKyxm1g0NKd9E2yiky21v5q6B40uBiHH4MFw4jY\n", + "EUr6p+UsOX26oY/zd2h0sFyfEsWiH/YiKbMP7OkD7/en8kQcFSqIYCAbKAeigARgH5aZEvha2VRt\n", + "43s3XnQiWM5IFhHFlkpF4c7j1D7u+p11pE9wnYPjzkDsEoD+LTxKVUAcqy8JZsua/tT3YALT2cgq\n", + "FBDyGBQ/CWG1Tud2wVQJ/oJZ8XsZZVMH0KuiRWKXyBFrWJcyiL4XzYcrD8KSdzquhqmhs2K5GJ/u\n", + "B88fYmTFbSxhFad7wK6+WrGXEJG859io92TQVbUkTAzbPT6zdHVMaUH0KSoDiyktVWxUQdQDl6Md\n", + "E74GMtCOCQVNvbPznlcZEWGbCKiAfouUOu72u3quYCplU/WpIjUJUFgTGjKquFdmZOb1Ayn79zoy\n", + "Ty5gNvtZwn5iK6AwDO4rdb6rMFHN/kS3U/yt9SxQNlU6a6EUv7YZ6gSORTS+1lE1TA2dEac6sRWx\n", + "hFMFwIph8D+XQ9S3EXy7JZ3ayiUhQAgoqLqpuPiaTz4tHlOeBExA7ztlAM8B37Yks2dLolTPVbjl\n", + "jA3cygrIq2D28kGsqNtDGTeyAriUO0+V1hSEfjeaLaWlPOk410Q1+xlKKb9oWpT2fo+UdJiXBUo1\n", + "tnlZkJLuyfkzIEOdebJSoNJgpa//f6b5Z3P9zk3gWuX83bmWCfphwheKm+5QPNhfcV+y4rtxh1jI\n", + "9SwkwtdzcLQZkFERhHr6MlRpcOMcJjDdaUppK1nIlyzkcl/L211aa3RnN1vxW/nSpQ7uGQel8VCc\n", + "kExt2fNWVaQcR1M2dVaSKF/kFTF0blxXulnkhd+FDPw/VBxAFeG6Y1AV5F4Max+HwqHArEPqnaUf\n", + "+U7ysykZwYALroGUE3D3Voio1sfDsW5qtOlmA9m9fsqW5JdkYVqu8dX3T7qZ4rfsrQi8+yZE50D0\n", + "Yej/aQgwDb1ZlgAMEruU4XQhAA6zkJyi9/jztbu5LroGOQ3lJq+I4Vy4mltSRdId5pRtVKUAfTg4\n", + "DQ5OczrLf1I5i116A88Ez2TE0mVw454zX69ixylI/xoOb4BL51BU1ReZ1hfuSjW++v5Jt/Lq8dSz\n", + "wPKt7ou+CCTSeEFwbgPQYS6NF4YzLxQ5QL5JDdG18LY7b5PR5mxY4Gtlaf0O5gDPAEuSF7FuagFP\n", + "ud7xboAFOkjL+n3NeACKE2H9L6xexnOnPTFePefEM88Ca/PsuNU2uxtJ7BKEVv7OF4YktOeF43kv\n", + "sUseTV8YcoACU4avc3Cu6NTWXBT8ddPTim7/I9AHmKlsaiM2SBWpaGrzt+GOeuNPoC7YaTTjq+9v\n", + "dKsVv36f1HRI7JAfmdglBB1c4+6OwdFCgSM0fWHIUTZV0h7yGZrGnRIfBAue68v0NUk69cHEo7pv\n", + "OmQchkXeyrHjS8QuwcCDwC+AJ4HfO8cGNHuu8dX3Ca3Rnd1O8fsbYpcImr8wJKCjJZu7azjibjPa\n", + "FRN17BmOlf2fIXlXX1iTBE8nU5afQFhCJYFTsuEnGxsV/yxYWwqVy4XpW+KgRx1ccEy/5poWwZ8R\n", + "u0wC/owOEvupsqlDLTrfj81WXRmj+Lsglp01hqb3GhKAgUApzVwcRj7FmMmVPNfZV6TthfV/7gVc\n", + "1W83zw3oxaC9vSG4Dm7ZBVMPwSuHObW2iFjXc6dFsDkrjfj6BOIiquGxdTBnu36tuRw7/oLYJQa9\n", + "ur8ReAD4R2vNjx15R23QGMXfTbFC6fvRzF2D1DEw7jSSWAzpWVo5QedakbYFS7HHAoMHrOTmYVnc\n", + "EhZARF4cYXsvg6oBRAGBQE1IKWrKMUIuPqJX9TP36jGuhW8HQ5jzxXN2DPUZV7Krdyk9MrYyYrhL\n", + "HK2//X/PDGAsqeQ7G7ZyQfEd6KSEDyubKvK1jIaWYTZ3uymW51C+1Ta663NLoKx9LpIrcqIgyMnP\n", + "qKtEHVuKvXfCEr4/NJe7wwKIKAmmx45J5BePpSd64702fD9lcaH0630NwZ8PhtgKGHSE0ycKeKkk\n", + "hd8qm8p1zVmjgG/7w95xhH4VTt03W6iNOU1hdRV5uQH8T/F7akmqSPozLjb+tsR4tIdZ7gxTTHQ2\n", + "XHcv9FZXsrbvo+rT48+2ZWxD58Io/m7C6XoqEoshsfjM42XgN/7izSF2kaRXmd0niAWqF9GHqyOj\n", + "TuanhqiA8EBCSoK5LCIwsr6s7rJcerxVQojjvDs+JuKjGr4unEgRMKY6jr7RAQRHF8F7b8MVhwEI\n", + "T4fhK5aqXNCBencHkXzbYIYuGw4fjoACoba2gt1VA3hh4/l8rmyq2lm+c6U7aAntVwnLCmActhy+\n", + "cyes/zkseT+YupuuBozi70YYxd9N8EbUcXtWUHKKnUgChgDDgWHW80HUMyhnDkH15YjsjaDk8zRU\n", + "6ZLGAQpvrxgVsiTgrZL6EAVsjYPxefB6BbEX7ebqjRM5AuyIOcaIhBJCIqsh0kl1R0CY2KUPkM5C\n", + "Zu6sY8A7JymK30dh/DvkRuTy5M765pWut2rHJsCCFwNJXjoSxubD8AJvJQO03C3zLoRX1sMpR30V\n", + "427Z3TCKv5vQ1hWppxWULBfWaKtFuTx2uLbGA/3RNvcYIBzt1qqsFgjUAKeBEqAwKo+SGYX0jqyG\n", + "1V+NpKp0CUgdDNgGSWshqSws9Mt6lqbo5GeiYP1fILQWkg7w5dc2vcGaJpLxumXGUcDuPrBsBGSc\n", + "zxhgP/AvYBmB/LT0JXW8Nf/rtiB2SRx6HaMGj4RRJ+GZVY2vtd0sZyWMKxuADkFx4D9RwoaOwSj+\n", + "bkRzK9Jzr+YtM0HPk3Dtf0BoMYSUJBN56C2xywkalXwA2nxUgy7eEQAEo5VWNVCEjnjOB3aiXQf3\n", + "A3utY9Xoi4EjajoRSAyEwZvj4UgUJP3Lym9z0R/gwj9D9uVQEs9XNwXU15yuD/jvT+G6vY2FTJzN\n", + "WYdCeXHGIFJHD2XgsuFQGQRhByjpcZj/ZQDPKJtyJJ7pMKzN+WuBnwCTy0Mo/fSvWvE703aznEmN\n", + "bNAYxW/wcDUfoc0ENWFw6EqoioLKaIh8BG7eGABEopX6IatlOz12PC9Hex8lOrXBwM1Oz6NodEt1\n", + "tC8SvyR16TEmJBTDTbWn2QOwZa4WbdLv4MRoAlcmZI3Oyg683sWctS+GV8UutwEzeZgZeyso2L2d\n", + "rPM+oCT0MCdyYFGBD1xaLdPS3cCP0Xc2LwG3x77HlOe8uFHswF+jhA0dj3HnNDRGXPY8Cb33QMwh\n", + "3eIXHWHUsUwgidcnnMeBjQFnnRwxbTMPfvYDtGKvp3GlPpgzFbwjDqGMRoWezZkK/jBw3F1+I+cN\n", + "zyWh4dw7cQinLj4OhyfDF4/A0Zf3w4YFKewkEe4L6UGvgkiit0+huvgChgBr0S6LHymbOurN/19L\n", + "sPYyLkGv7mcCH6BTI3zt7DufKpKe6IWNYkPXx7hzGlqJtek37lUY+T4UJemW27ecUcd+B2STXzoK\n", + "mfcs6pUhDaf1nFPEtK2VwOtoxR5NY/oJR/s38DZayecomypvjYQ7lFoxZIjEJIzh1/mjTyf2PJhZ\n", + "HPjm2Py6vMCT8HgFgYde5LHdxTvhhp36ohOLVvTL0JWqWvW+3sKK0L4duBe9p/Ey8POmKmh5a6PY\n", + "YHCHWfEbms6xMuCyI9zz70wcq/XdkTWsHw1VUTVQXkbKntVccXIVjUr+WHtkIxW7DEbnj/k+8Bbw\n", + "jLKpQ2KXSLRt/AYgHV2p6kO0st/kD5lRxS4p6NX97ei7jpeAf/mDbIaugVnxdyNa4lrpCG7Cvfll\n", + "MLMjk1k1W1G4pPHLEzankOFZ7wPLsRS7ervk9FmDtyNil5HAQ2jF/gowGr1RPFPscgNwKbAerewf\n", + "VzaV3ZHyNYWV6OxmtMIfBiwGxiibOuJTwQwGC7Pi74SctRkbWAUxc7IZ/9nLXFaQh3sbewVn29Mb\n", + "bey/HjWeuqSfdvSmn7sLGAt35gOPAFPQG5r/BqaiLwDxaBPIMmCVP2Uute5MfgTMBXahV/cfKJuq\n", + "8alghi6NydXTTWgwzSR9Bt+9HcJO6TKSlQWFxJUu5+xN0xxlU6U+FdoNZ13ABq+Dqd8rZ1B+BT3U\n", + "++g70hlAIY32+vXKpup8JrQLlivmdPTq/jLgDeBlZVOZPhXM0G0wpp5ug7UZe3Qi/HmTDshRgcCs\n", + "7Uot/YFvZXOP25W9Izag9x64cS5E5MMXT/Tky5eDmbN5KFrR/0bZ1D5fy++K5Yr5Q7QrZhF6dX+b\n", + "sqkONYcZDK3BKP5OiRWBWR2hWwP+GYHZRJ72oQQf1+Fa5X3h65/CrluhPggCVn6lbJumNTmgj7D2\n", + "Si5Fr+6vB/4J3AZsNFXUDJ0Jo/g7JZ0tAtNa2QdVQtIaGPEhDF+VzLtxdRwGKmJhx22N3esr/Mos\n", + "ZXkPfR+t8MPQrpj3K5s65VPBDIZWYhR/J6TzRWBapqm7puharHtnwhsfw8n7d8H8MH+9gIldUtHK\n", + "/jZgDdql1LhiGjo9RvF3Uiwl76eK3hXLNPXa5y5FuINyYf0if7qAWUnmHK6YyRhXTEMXxHj1K6O9\n", + "3wAABvFJREFUGNqdzlCLVeySRKMr5g70Zu2HxhXT4O8Yd06D3+KPtVjFLoE0umJOQqeeeFnZ1B5f\n", + "ymUwtASj+A0GJ5qKbha79EW7Yt4DFKBX92/7Op+PwdAajB+/wWBxtnlJwZDrU+T+4H3EMg54D5il\n", + "bMptjWKDoStjFL+hi2K5kAaXwZg3YOIfIahyEDsTyrj8wHnGFdPQnTGK39BFsVxIw4/DeZ/Ax8/B\n", + "wWmgvndMfbLfKH1Dt8YofkMXxXIhLTwPlr7rdNw/o5sNho7k7IpKHiIit4rIThGpE5HxzfSbISKZ\n", + "IpIlIg+19v0MhpaR8wLMd8nx4z/BYQaDL2m1V4+IjESX2vsT8B9KqS1u+gQCe4CrgVxgI3CbUmq3\n", + "m75d2qtHRKYqpdb4Wo72wF/n5i0XUn+dn7cw8+vcdKhXj1I67axIs+93EbBPKXXI6vs2cCNwluLv\n", + "BkxFh/13Rabih3PzYnTzVPxwfl5kKmZ+3YpWm3o8ZCCQ4/T8iHXMYDAYDD6i2RW/iKwGBrh56VGl\n", + "1DIPxveP6DCDwWAwNNDmyF0R+YymbfyXAAuVUjOs548A9Uqpp930NRcJg8FgaAW+itxt6k03AcNE\n", + "JAk4CsxGp7g9i668sWswGAz+RFvcOb8jIjnAJcByEVlpHY8XkeUASqla4GfAx+ji00vcefQYDAaD\n", + "oePwmyRtBoPBYOgY2turp0lEJFZEVovIXhFZJSIxbvokiMhnVqDYDhFZ4AtZPcWTYDURecF6/RsR\n", + "GdfRMraFc81PRL5vzWu7iHwpImN8IWdr8TTYUEQmikitiNzckfK1FQ+/n1NFZKv1e1vTwSK2Gg++\n", + "m31EJENEtllzu8sHYrYKEXlVRI6JyLfN9GmZXlFK+aQBvwV+aT1+CHjKTZ8BwFjrcQQ6GGyUr2Q+\n", + "x3wCgX1AEtAD2OYqK5AOrLAeXwxs8LXcXp7fpUC09XhGV5ufU79PgY+A7/pabi9/fjHATmCQ9byP\n", + "r+X24twWAk865oVOxx3ka9k9nN/lwDjg2yZeb7Fe8dmKH7gB+Kv1+K/ATa4dlFL5Sqlt1uMydOBX\n", + "fIdJ2DIagtWUUjWAI1jNmYY5K6W+AmJEpH/Hitlqzjk/pdR6pVSx9fQrYFAHy9gWPPn8AO4D3gFO\n", + "dKRwXsCT+d0OvKuULjOplDrZwTK2Fk/mlgdEWY+jgAKl9yD9HqXU50BhM11arFd8qfj7K6WOWY+P\n", + "Ac0KankGjUMrFH/Ek2A1d306i3JsaTDeXDpNTWDAg/mJyEC0QvmjdagzbZB58vkNA2It8+omEflB\n", + "h0nXNjyZ22IgRUSOAt8A93eQbB1Bi/VKu2bnbCYA7FfOT5RSqjk/fhGJQK+y7rdW/v6Ip0rA1W21\n", + "sygPj+UUkSvRFa4uaz9xvI4n83seeNj6vgpNuzH7I57MrwcwHrgK6AmsF5ENSqmsdpWs7Xgyt0eB\n", + "bUqpqSIyFFgtIhcopUrbWbaOokV6pV0Vv1LqmqZeszYrBiil8kUkDjjeRL8ewLvA35RS/2wnUb1B\n", + "LpDg9DwBfeVtrs8g61hnwJP5YW3oLgZmKKWauz31NzyZ34XA21Z+qj5AmojUKKU+7BgR24Qn88sB\n", + "TiqlKoAKEVkHXAD4u+L3ZG6TgN8AKKX2i8hBYAQ61qiz02K94ktTz4fAndbjO4GzlLq1qvoLsEsp\n", + "9XwHytYaGoLVRCQYHazmqhA+BO6AhqjmIidzl79zzvmJSCK6pOEcpdQ+N2P4M+ecn1LqPKXUEKXU\n", + "EPQd6E86idIHz76fHwCTRSRQRHqiNwp3dbCcrcGTuWWiswRj2b9HAAc6VMr2o+V6xYc71bHAJ8Be\n", + "YBUQYx2PB5ZbjyejUz9vA7ZabYavd9mbmVMa2vNoH/CIdezHwI+d+vzBev0bYLyvZfbm/IBX0N4S\n", + "js/qa1/L7O3Pz6nva8DNvpbZ2/MDHkR79nwLLPC1zN6aG/oObZn1u/sWuN3XMrdgbm+hMx9Uo+/K\n", + "fthWvWICuAwGg6Gb4UtTj8FgMBh8gFH8BoPB0M0wit9gMBi6GUbxGwwGQzfDKH6DwWDoZhjFbzAY\n", + "DN0Mo/gNBoOhm2EUv8FgMHQzjOI3GNwgInYRud/p+W/8vRCQweApJnLXYHCDiAwG3lNKXSgiAejU\n", + "IhNV50o8ZzC4pV2zcxoMnRWlVLaIFIjIWHRq8S1G6Ru6CkbxGwxN8wpwN7pI0Ks+lsVg8BrG1GMw\n", + "NIFVC2IHuqbrMGV+LIYuglnxGwxNoJSqEZFPgUKj9A1dCaP4DYYmsDZ1LwFu8bUsBoM3Me6cBoMb\n", + "RGQ0uuTgJ0qp/b6Wx2DwJsbGbzAYDN0Ms+I3GAyGboZR/AaDwdDNMIrfYDAYuhlG8RsMBkM3wyh+\n", + "g8Fg6GYYxW8wGAzdjP8HuK8w17ibVlIAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['WNN']\n", + "modelWNN = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelWNN)\n", + "fwd_WNN = generateFwdTest(environment, modelWNN)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -329,25 +1808,751 @@ "The LWLR computes a linear regression of the $k$ nearest neighbors of $m$ and finds the requested $s_p$ given $m$. As before, it is possible to change the number $k$ of nearest neighbors. " ] }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEZCAYAAACAZ8KHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXm8HVWV77/rhkASJoEIQpiEBJUINAIBhWgQHoZIgxP4\n", + "ABmliSgkNDwVh4YIaIO0CgEbAWUKoyK2pMWgDwjSDEKYFfAlIWHKABlkMAMB1vtj75PUPbfq3Dr3\n", + "njrj7/v53M89VbWrap06VXvV2mvY5u4IIYQQeelqtABCCCFaCykOIYQQVSHFIYQQoiqkOIQQQlSF\n", + "FIcQQoiqkOIQQghRFS2vOMzsXTPbrtFytAtmdqSZ3VHnc841s/3qec5WxMw2M7M/mdnrZnZBgefZ\n", + "28xmmtkbZnZwkec1s7+Y2cdrecxaY2bTzezLDTr3JDObEj9vHX8Tq8N5Kz6TdVUcUZhl8cu/EW/E\n", + "9xV4vulmttzMtkys29/M5pTJtNDMhiTWnWBmd/fz3EeY2Yz4PeeZ2e1mtnd/jlkP3P16d/9UvU8b\n", + "/6om/n6frLE8zcqJwCvuvoG7f73A85wNTHb39d39tlqd18yuNrNzkuvc/cPu/qd+yls0fb4/a3Tu\n", + "8MH9hfibVJTFzMaY2Ys1OG/meeptcThwUPzy68cbcUHB5/wH8G+9tOkCJtbqhGZ2GvAT4FxgU2Ar\n", + "4KfAwbU6RxGY2YBGy9AHHCj8DaxJ2AZ4pg7n2Rp4ugHnbWvMbK1Gy1Az3L1uf8Ac4JMp668BTouf\n", + "hwHvAl+Ny9sDixNtvw7MA14Cjo9tt8s4393AmcDrpTbA/sCcMpm+CSwGNozrTgDu7uN33BB4A/h8\n", + "hTbrABcCL8e/nwBrx21j4nf7OvBK/K6fAcYB/y/KeUbiWJOAW4Cb4vd8BNg5sf0MYFbc9lfgM4lt\n", + "xwL3AT8GFgHnxHX3xu0WZVsIvAY8CYxMfM9ro4xzge8Aljju/wAXAEuA54CxvdwXZ0T5lgBXAusk\n", + "th8EPA4sjfLuFNdPAd4BlsVr/nXg6irupdTjxm1bAL+O3+854JSya/5Lwn37OvAXYLeM7/Yx4FVg\n", + "y7i8S/yOO1Ro/zDwd+Ah4KNx/dXAW8DK+F3TnqNx8Rq+TriHTq9wzY8nKIclwDRg67h+dtk1vaH8\n", + "vPG+KN1Xi4CbgY0Sx94HuD9e1xeAY4B/KTvOb2PbufGYW8RzJo+za7x2AyrJnPH9fgXMj9fxHmDH\n", + "xLarCS9y/x2v1YMk+hDgfwHPxn0vBqYDX844zyQqP39zgW8Qnp3lhJfUvRLX53HgE4n274/yvg78\n", + "IZ5/Sty2LeF+7orLGwNXEfqQJcCtwJB4nnfidX4deF+O3+wo4Pm47dtk9NWr2/elc+zrXxRmv5T1\n", + "xwG3xc9HxC93U+Jm+U38PBZYAOwYL9AN9K44vgz8KHHx0xTHfoRO4py4rj+KYyywqvTjZrQ5O944\n", + "Q+PffcDZcduYuP93gQFRlkXA9cC68bsvA7ZJ3LhvAZ+L7U8ndHSlh+0LwPvi58OAN4HN4vKx8Vxf\n", + "izf0ILorjk8BM4AN4vIHEse6FvhNlGkb4G/A8YnjvhWvvQFfAV6ucD3mEh6sYcBGBKVT+i12JSiu\n", + "PeKxjo6/2cDE7/fJxLHy3kuZx43X4pH4G6xFeJhnAwckrvny+Fsb8APggQrf71zgTmAw8BRRkaW0\n", + "25jQmRwZZfjfhA5ho7j9KuJ9krH/fGDv+HlDYNeMdocAM+Pv2UVQ+veVPRPJa9rtvATr/H5CZz8Q\n", + "+BlwQ9y2DaGz+iLhftwY2CVL/uS54jU6IbHtAuA/88ic8h2PJdybAwkvP48ltl1NeKZ2jzJeB9wY\n", + "tw2N8peep1MJz8jxGeeZROXnby7wKOHeXif+X0R8kSL0R4uATeLyA8B/RLlHR1mujdu2pbvi+B1w\n", + "Y/yt1wJGx/WfAF4sk7PSb7YjQcnsA6xN6C9X0USKY24UcGn8uzWu357wgBhwKWFM9cW47Rrg1Pj5\n", + "SuAHieONoHfFcXy8Gf4eL1Ca4vgkMDK2GUr/FMeRwPxe2swi8QYOHFCSiaA4lrHm7X39+B33SLSf\n", + "ARycuHHvT2wzgpWyT8a5H0vseyzwfMoDV1IcnyQohD1JKELCA7IS+GBi3YmlaxaPMTOxbUj8Dptm\n", + "yDQHODGxfCAwK36+lJ6dzbOseUjKO7m891LWcT8ev2/5dfkWcGXimv8hsW1HYFmF33ut+Js9Bdxe\n", + "od1RwINl6+4HjomfryIq1Iz9n4/fd4Ne7r/fk+gICR3xP4CtMq5pt/MS3vqT2zcndJ4D4nX6dcZ5\n", + "e8hPd8XxZeDOxH38Quk+7k3mXr7ve+L9t35CjsvL7rdn4uejSTxPcd2LVFYcac/f3onvd2xi+zeJ\n", + "iiCxblo879aEDntwYtv1pFgc8Zq/QxwlKTveGHoqjkq/2ZlEJZJ4XldSQXE0wsdxiLtvFP8+B+Du\n", + "swk3wT8RtOx/A/PMbAfCg3xP3H9zwo9Y4oVcJ3VfBFxCeNP3jDZ/jec9I6sNgJn9LOHcPyOlyWJg\n", + "qJlVurZbEB7yEi/EdauP4fEXJLzZQng7JrFuvcTyS4nv4XF58yjv0Wb2mJktNbOlwIeBTRL7ZjrR\n", + "3P0uwnX7KbDQzC4zs/UJynVgyncYllhekDjOsvgxKXM55b9r6XpsA5xekj9+hy3pfr2SMue9l7KO\n", + "u3nctkXZtm8R/FUlkr/HMmBQ1m/u7m8TlNZIwttcFlvQ855+Puu7pvB5wnDV3BgYsldGu22AixLf\n", + "bXFcPyyjfTnbAr9J7P808DawGeEaPpfzOOXcCnw0Bsx8HHjX3f+nWpnNrMvMzjOzWWb2GqHzhnDf\n", + "lsh6nrYg8TxFenM0pz1/yd8suf82wKFl99behOGkLYCl7r480T75jCXZClji7q/1IluJbcn+zTYv\n", + "+w7LWHN9U2mmcNx7gEMJQxDz4vKxhKGLx2Ob+QStXCL5uTcuAPYFdqvQ5izCWGzmA+TuX/E1zv3z\n", + "Upo8QNDWn61wnnmEH7LE1nFdX9mq9CF2XlsSOsttgMsJQ1Ebu/tGhPH4pDM5U0kCuPvF7r474a16\n", + "B4If4VXCm1H5dyh/4Kqh/Hd9OX5+Afh+4mVjI3dfz91vriB/nnup0nFfIFiAyW0buPtBFc6ZiZkN\n", + "I7zVXQn82MzWzmj6MqFjSbINa65FRdx9hrt/Bngv8F8EP0waLxAsvOT3W9fdH8xznrj/2LL9h8Rr\n", + "/SLB6ksVsRf5lxLG9b9IGGa8sY8yH0kIRNnP3TckDDVCviCKeXR/niy5nEHq85f8amXfY0rZ91jf\n", + "3X9I6N82SkZ4En7/tOv2IrCxmW2Ysi2tfaXfbH7ZdxhC95fLHjSb4jgZKIXmTY/L9ybevn8JHGtm\n", + "H4pf7qwcxzWAqJl/RDAVU4lvqzfTjwireJ4zgZ+a2SFmNsTMBprZgWZ2fmx2I/BdMxtqZkNj+yl9\n", + "PSewm5l9NkZtnAqsIDj81iXcRIuALjM7jmBx5MLMdjezPc1sIOGtegXwjru/S/gtvm9m60UF9a+E\n", + "seK+YMDXzGyYmW1MGL8uKYYrgK+Y2SgLrGtmnzaz0hviQnp2VHnupUrHfQh4w8y+YWaDzWyAmX3Y\n", + "zHZPyJvvi4WO52rg5+5+AuEhPSej+e3ADmZ2uJmtZWZfBD5IsJoqnjfeY0ea2YbuXnKMvpPR/GfA\n", + "t81sx7jvhmZ2aKWvkbL/D8xs67j/e82sFDF4PbC/mR0av8MmZrZL3LYQ6C3n6gaCM/3z8XNfZF6P\n", + "8PK2xMzWJfigKn2fJLcDIxPP0wSCNVCJrOcvjeuAfzazA+J9NSiGzw5z9+cJQ5rfi7/nPoQAjh64\n", + "+3zC8N1/mtl7YvtSPsxCYBMz2yCxS6Xf7BbgIAv5O2sTRmYq6oZmUhx/IvzgpYf9PoIzcXWMt7tP\n", + "I0Qj3UWIMLqT3t/+ktsvIphnlfY5mzDGV9VbZbcTuv8YOI3gXH2FoO2/SnAmQ3CWziA4hJ+Mn8/N\n", + "kDltuXzbbwlvaUsIb1ufc/d33P1pgrJ8gDB09GGC4zm5b9q5Sus2IFgsSwj+qUUEyw3gFMKQ0HPA\n", + "vYQO46pejlvpO1xPeNucTXCCngvg7o8QrMBLohwzCePBJf6doISXWgiDhnz3UuZxo2I8iDDc9RzB\n", + "wro8Xo9qv98EwhBJKST8OOA4S8npcfcl8bynE671/yGEry+pcN4kXwLmxOGZEwn3Qg/c/b+A84Gb\n", + "YtunCIEQWZSf9yLgNuAPZvY64f4aFY/9ImG47HTCcMdjwM5xv18AO8bf6taMc90GDCf4CZ/qo8zX\n", + "EoZ4XiZY2A+UyZ/5+8Vh7UOB8wi/wXC6PzPlZD5/qY3dXyI4+r/Nmr7hdNb0xUcQfGxLCC+U16TJ\n", + "GTmKYPk/S1AWE+I5niW8nD5nZkvi0F+l3+xpwqjEDQRLaQm9DM/Zmhew2mNmVwKfJiQP7ZTRZjLB\n", + "ObWM4ER6rDCB2hAzOwsY7u5HNVoWITqNTn3+irY4riKELKZiZuMIF30E4Q3p0oLlaUc6JflNiGak\n", + "I5+/QhWHu99LCLvN4mCiKebufwbeY2abFSlTG9Lb8IUQojg68vlrdAr8MLqPpb1EiEhYmN5clOPu\n", + "32u0DEJ0Kp36/DWDc7zc1Os47S2EEK1Eoy2Ol+keI70lKTHrZiZlIoQQfcDda+6HabTiuI0QX3+T\n", + "hSzXv7t76jBVEV++FTGzSe4+qdFyNAO6FmvQtVhDR14LsxGEBNN94prrgInWSwZ4XylUcZjZjYSC\n", + "W0Mt1Ic/i1CqAne/zN1vN7NxZjaLkBNwXJHyCCFELYgRoRMIhUFXEOYvub0BgnRFOX5AyFVaAIwn\n", + "zKMCBc35VKjicPfDc7Q5uUgZhBCilkSlcREhObDE9mZGXZVHhpXBmoTRwmgG57iojumNFqCJmN5o\n", + "AZqI6Y0WoImYXvDxJ9BdaRCXp5jZtKhYisOsC7NTgScISmMBcAjuR9VDaUDBmeO1wsxcPg4hRDNg\n", + "ZtMJQ/BZzAImFmJ9VGllFNV3yuIQQojqWNHL9uGEWm61owmsjCRSHEIIUR2TCVZFJQbX7GzByriH\n", + "MJPhYIKVMXK1A7wBNDocVwghGkpahFTclBo1FaNBIVgVexLmeSlnecq6agWrHDHVQKQ4hBAdS0aE\n", + "1O6EsvzrJNZ1i5qK/2/P2H82cHHKefKH7zYwYioPUhxCiE4mLUIqbfa7kt/i9hQlcB2wF8EqWA5c\n", + "nFQKVYXvNrGVkUSKQwjRyQyqou3gLCVA5SiqrPDdUwgzDgaa3MpIIue4EKKT6S1CKslyKiuBLLKU\n", + "U3CgN1nEVB6kOIQQnUyeCCkIM5ReTG9KIJ0s5bS8GSOm8qChKiFEx1IWITUYWJcwT9DmiWbLgB/G\n", + "thMyDlUpimoyYThrtaXSBbN/H+Ybf4Im9mVkocxxIYRIEP0YJUXSzdldIYpqQqUoqeQx/wnsDthk\n", + "UxgZNxfmyyiq75TiEEK0PbWsZhuPdTawHWHiuTnAmb0eryxiagUsPQnmXA1v9FemCrIW0ndqqEoI\n", + "0XJUowiqrWab89gbsibxb2PgoorVccsipmbCXR+DbRfBR/LI1GxIcQghWoo+lDXPFw6b/9i5j5eV\n", + "l7EDfJVgsfR+jCZEUVVCiFaj2pDYaiKh8hw73/EqR0z1JTqraZDFIYRoNartdLPCYUfGEunJ+lSj\n", + "MtoOM7Np8dwjM9qEyKp82d/ZIbotgBSHEKLVqLbT7REOC6wChrJmXo2dACO9YCFx/53K9h+YWA71\n", + "qfJnf6fJ1KPGVbMixSGEaDWq6nRTcjVGEpRGki0qnO9dYEjZuoHAIuCvwPK14ZKVsANwCznyMlJk\n", + "6lHjqpmR4hBCtBT96HRLYakDqjxlli/4r+4+pq81pkoVdquUpSlQHocQojBqmT/RTxnKI6X6TRdM\n", + "ewfuoIkr2SqPQwjRUvQhbLYo0iKlypkf/29esVXkQ/DCdNiKEDEFTVzJtggUjiuEKIq+VJItgt5K\n", + "py8CToh/0wghtIvSGnbBknPhmadgs1gypOkr2RaBLA4hRFE0S65Cb6XTBxFKiLwZ2/4wru9mLUUr\n", + "44161JhqdqQ4hBBFUZNchUp+kpw+lLQorCTrAbsllnciWBLLgUVdMP9sWOsM2G4AbE0T+jLqjRSH\n", + "EKIo+p2rkOEnGW1mswm5FO+jeyhtDx9KIgrrewRroTeLZ4vSMYcD18N6o9ZYTx1rZSRRVJUQojAq\n", + "lSjPuf804FNVnnaaux9YQZ4phMKE2edlTer3EGAxrNwEDms1K0NRVUKIlqMGuQrVzAleItOiiNbH\n", + "w1RQRsMJSRmj4/IU4OswY0GLKY0iUVSVEKKZqWZO8BLr9rI9dbpYAyYSpuQbTYjPPRg4GlgY5swQ\n", + "ESkOIUQzk3dO8CTD4pBUDxLO9OWEkNungEc+DE89Aq9dSBiamkJwhkwNu9WshpSZjTOzaWY2Pf5P\n", + "lbPZ0VCVEKJpKSsvMozgbC+vG1XO5uSca6ML/v57eOAAOIqY/X05XD4+VMmtaQ2pJkqI7Ddyjgsh\n", + "WoaEs/2jhFn4sriHkI+RDNUdSiLsttyXQcERUxUc/ZnO/BqcU85xIURnU3K254i2Wpeeb/fLoWfE\n", + "1CJ4aygcWoeIqWZJiOw38nEIIVqRB4BlGdtmE/q28oS/wcMJpkjSl7ET3FunMNuWnrwpiRSHEKJP\n", + "1MLR25djxDZforuv4x1gLqHW1ATKoqAqREzNXgA/rlbuPpLm6G+ZyZuSaKhKCFE1tXD09uMYacUT\n", + "BwDPlnwFZjahtKHcl3E7zDse5sQQ27pNntTqkzclKdQ5bmZjCVbhAODn7n5+2fahBIfU+whK7D/c\n", + "/eqU48g5LkQTUQtHbzXHKKtJtTPpU7ze4+5jSu274KJTYHjJl/EKvPNf8P0T3c/KI1870HLOcTMb\n", + "AFwC7A+8DDxsZre5+zOJZicDj7n7t6IS+ZuZXefubxcllxCiJtTC0Zs1XWu3Y1QxEdNqX8HRsMXX\n", + "YMtRcflGWPUd+PFzHaQ0iqRIH8coYJa7z3X3VcBNwCFlbeYDG8TPGwCLpTSEaAn65eiNymD7jM0f\n", + "M7MZCX9HnomYgq/ArOsPZpf9DC4fBYNKvowjYOAcOKpVE+6ajSIVxzDgxcTyS3FdkiuAkWY2j+C3\n", + "mligPEKI2tFfR+8EshP5BhLyLa6IHX2lelXLgUeACQ4zgXsOgBMHg5Vlf0OwcOo9iVRbUqRzPI/z\n", + "5NvA4+4+xsy2B/5oZru4e4+6MGY2KbE43d2n10ZMIUS11MDRm6d4Yamjr1SvanAXvPoO7ADcAgxe\n", + "BG8dD2tPzWifU76WxMzGAGOKPk+RiuNlwpy8JbYiWB1JPgZ8H8DdZ5vZHOADwIzyg7n7pGLEFEL0\n", + "hX5Wvs1bvHAwIQM8dSKm4cAvQxb52Ljqup1giwXwyYzjtVzORDXEF+rppWUzK8SnU+RQ1QxghJlt\n", + "a2ZrA18EypNsniU4zzGzzQhK47kCZRJCNAd5ixcujwpqIol5wJN5GbuG0iOr5/5eAD8i+E/LmU8L\n", + "5kw0I4UpjujkPhm4A3gauNndnzGz8WY2Pjb7AbC7mT0B/F/gG97hM2sJ0Q70ltiXUAbTCBVqV6Yc\n", + "ZnVHH9sfA8wqz/6eCXcBI0vZ37HtCQTfx5L4NwM4oRVzJpoRFTkUQvSZtDm/46by8NlZwMSsjjse\n", + "52zg/XHVc8BZ3dqbdf0BLv04nDAIuhbDyl/D+Z2Ul1EtRfWdUhxCiD6RkV+xjFD+Y/2UXfpeBdZs\n", + "BCEBfJ+4RnN/56DlEgCFEO1JwsoYRc8M7kpzZVQf0WTWxZpitoMJvozxrTb3d7shxSGEyE0VWdxp\n", + "VBfRJCujaVF1XCFENeTJ4k4jf3KgWRdmpxKCpvYhETElpdEcyOIQQlRDnsS9JEuAh8ibHNgPKyPN\n", + "Ua8oqmKQ4hBCVENW4t4bhCrYSR/HbGBCToXRL19GO83n3QooqkoIkZuMDno2odOHvpQgqWBl5LUi\n", + "GjGfdyugqCohRENI6byvA/YiXUHkf7vvxcqo0opom/m8WwEpDiFEJlmdNxWS+XIeOI8vI80RP5xg\n", + "1ZSfu23m824FFFUlhKhEpc67eqqLmKrGimib+bxbAVkcQohK1G4IqPqIqdxWRDvN590KSHEIISqR\n", + "1Xmvm/sIfY+YmkzPcuqZVkQ/y7yLKpDiEKJNqVFew2RgJ3rODz7MzMb1erx+5GXIimheFI4rRBuS\n", + "4dSuWKG2wrEeAT6Ssik71LXGNaaU3Nc3FI4rhKiGaiKSeqPHVM6RdD9HjWtMKbmv+ZDiEKI9qWVe\n", + "Q6afIybeDQJWrA0Xr4QR1L6SbS2VoKgBUhxCtCe1zGtIc1LPB4YBuxM3XA+fYI3CqmUlWyX3NRlS\n", + "HEK0J7kikvL4DjKc1JsCHzHWODKGwKDFsHITOKzG82Uoua/JkOIQog3JE5FUyXcQKVcoByb2nT6c\n", + "4MgYHddNAb4OMxbUfpKlqsJyRfFIcQjRpuTIa8jyHXwPeA9ZzmizrnNhs38llMKdD4wHpoZ2WY70\n", + "PqOw3OZD4bhCdChmNp3glyhnKT2nhAWY5kHZrI6YmgJMjDtQTRl1URcUjiuEqDVZvoMeb5MGTAoR\n", + "U08QI6Yuh8vHh3nHZQV0GLI4hGgy6pXsVmFujddIJPyV+zLQ3N8tgywOITqAeia7ZfkO4uaLDIYn\n", + "IqZYAUsHwbE1jpgSLYgsDiGaiGaZye4YsxNOgx/uEn0dM+GuEXBob1aGSoM0F7I4hOgMGpvsFmtM\n", + "XVOW/T0ih5Wh0iCdgyZyEqK56Feym5mNM7NpZjY9/h+X+8yhxtQ9wE8ISuM6YGQVQ1O1nfRJNC2y\n", + "OIRoLvqc7NbnN/7aVbJVaZAOQYpDiCain8lu1RcDrG0lW5UG6RCkOIRoMvLMZJfmhKaaN/4az5cR\n", + "UWmQDkGKQ4gmoJpopIwhqdHAuxmH7/7GX+P5MkqoNEjnIMUhRIPpg28ibUhqSMbh17zx57Ay+htO\n", + "q3m/OwMpDiEKoopOuFrfRNaQVJIlwEOU3vhzWBkKpxV5keIQogCq7ISrjUbKckInecrdD8SsC7NT\n", + "yefL0Ex7IhfK4xCiGKrJaag2GmkyMKuX8y/vQ16GwmlFLgpVHGY21syeNbOZZvbNjDZjzOwxM/tL\n", + "LPMsRDtQTSecpggyo5GixTIRmAbMpayabResuiJ8fIIwNLUAOAT3o3pxgCucVuSisKEqMxsAXALs\n", + "D7wMPGxmt7n7M4k27wF+CnzK3V8ys6FFySNEncndCfclGqnkhI61rbYtrY+VbAeOhrFxVTURUwqn\n", + "FbnIpTjMbAiwlbv/rYpjjwJmufvceIybgEOAZxJtjgB+7e4vAbj7oiqOL0QzU1UnnBWNlMPBPgjC\n", + "fBnJSraL4K2hoShh7rwMhdOKvPSqOMzsYOACYB1gWzPbFfieux/cy67DgBcTyy8Be5a1GQEMNLO7\n", + "gfWBi9x9Sl7hhWhWatEJ53Swr0ib+/sbcO/8PiTzKZxW5CGPxTGJ0OHfDeDuj5nZdjn2y1OvfSBh\n", + "wpj9CC9KD5jZg+4+M8e+QjQ1NeiEK0c5mXXdAc+PBh8Mlpj7ezbw436cV4iK5FEcq9z97/HtqURW\n", + "hmqSl4GtEstbEayOJC8Ci9x9ObDczP4E7AL0UBxmNimxON3dp+eQQYhWJtvBHvMyDoh5GbfDvONh\n", + "zkJ4Aw0vdSxmNgYYU/h5epvIycyuBO4EzgA+R3gLGujuX+llv7WAvxGsiXmEZKTDy5zjHyQ40D9F\n", + "GAr7M/BFd3+67FiayEl0DAm/xijiREqrtwHnwDPfCQ7xWtWYEm1KIydyOgX4DrASuBG4Azint53c\n", + "/W0zOzm2HwD8wt2fMbPxcftl7v5sjAp5kmDFXFGuNIToJDL8GhBXXAcr9oQPxVWa+1s0hDwWx0fc\n", + "/dE6yZMlgywO0RGkTR1rwOmw7BwYNCjkXsnKELkoqu/MkwD445jEd46ZfbjWAgghutHNrzGckPp9\n", + "AQyJSqPaWfmEqDm9Kg53HwPsCywCLjOzp8zs34oWTIgOZQUEK2MiIfV7NLA4DBXnyf4WonBylRxx\n", + "9/nufhHwFcK9fGahUgnRuUzeEZ6/B7iQEKN+C7wxFo6WlSGahTwJgDsChwFfABYDNwOnFSyXEJ2H\n", + "WZfDDu/A+wYQsr+/Dn+5Gv5N4bWimcjjHH8QuAn4lbu/XBepesog57hobwqalU90NkX1nb0qjmZA\n", + "ikO0Mom8jC2AzYH5hNymyR4q3NZ67m8hgAYoDjP7lbsfamZPpWx2d9+51sJkIcUhWpVKeRk7wvN3\n", + "w5ubwsi4SlaGqCmNUBxbuPs8M9uGEOSRxN39+VoLk4UUh2hVsvIykpVskZUhCqLueRzuPi9+/Kq7\n", + "z03+AV+ttSBCtCmpeRmliKmpsBDlZYgWI0847gEp68bVWhAhWhkzG2dm08xsevxfekZS8zLmAweH\n", + "v8c0NCVajcxwXDM7iWBZbF/m51gfuK9owYRoFTL8GDub2Txg7R1g+c9hcHK+jInAUs2uJ1qUSj6O\n", + "DQmVOc8DvskaP8cb7r64PuKtlkU+DtG0pPkxoKcv4xV45yT4x63wPGHaAZU/F4VS9+q47v4a8JqZ\n", + "XQQsdffXoyAbmNme7v7nWgsjRIvSY96MjFn5ps9337+egglRBHl8HJcCbyaW/wH8rBhxhGhJVpQ+\n", + "ZPkyjgYW5JvGQIimJ2+tqncTn98hzK8hhAhMBmaVR0xNISRoTF3TbnkDZBOi5uRRHHPMbIKZDTSz\n", + "tc1sIvBc0YIJUSQVoqCq3sdh2h1w11Pw7mjgVVj1BVhyNLB0ze5yhIu2IU+tqs0Ib1T7xlV3AhPd\n", + "/ZWCZUvKIOe4qBkZUVCzCPd1qrM6a5+j4fxr4BjKakwZ7EWYPXMwwdKQI1zUHdWqkuIQNSIrCgqY\n", + "5u4H5tmnFDF1HryrWflEs9KwGQDN7ANmdqeZ/TUu72xm3621IELUkR5RUJHBefZJ+jI0K5/oRPL4\n", + "OK4Avg28FZefAg4vTCIhimdFxvpKzusVaRFTx8GjmpVPdBp5FMeQZM6Gh7GtVcWJJEThTCb4NJJU\n", + "dF4fDbc8CCuSEVM7w5yrQdMoi44jT1z5q2a22iFoZl8gvGwJ0ZK4++1mBnmc12ZdwIRrQgL4oFdh\n", + "1XhY+ZuNm78iAAATpElEQVRggcvKEB1Jnqiq7YHLgY8CfwfmAEfGKrl1Qc5x0RDKZuWbCXd9DLZd\n", + "BNslWlWMxhKikdTdOR7zNQA2d/f9gE2BD7r73vVUGkLUHbMuzE4luDP2IURMHbIDrCpTGhB85afU\n", + "W0QhGkklH8fx8f/FAO7+ZqlelRBti9mIV+BJ4CfA4N/BvD3CrHy30bdoLCHajko+jqfNbCYwLGX6\n", + "2LpOHStE4URfxjtw3qawznxgPDA1zBP+fTN7k75FYwnRdlSqjnu4mb0PuINQp00+BlEoMTt7AuHN\n", + "fgUwuS6+g4QvYwDd5ssoURqOmgxsT/fscZUSER1HpYmc7nT3/czsjnrOLy46k4ySHtubGYUpj2hl\n", + "ECKmBgMLjoFF18KHU1oPqyoaS4g2ptJETk8D/wL8AjiCYHGsbuzuj9ZDwCiLoqranN7KgJRZI+sR\n", + "7sc36KtlUhYxxZoaUzdkyLEMOFRKQrQSdZ/ICTiLkNw0DPhRyvZ9U9YJ0VcyHc8Z1kiS/JZJipVB\n", + "ssaU2WRCYviQsj2HECwNKQ7R8eTJ4zjT3c+ukzxZMsjiaHMqWRwE6yJtW7d2WQUKEydJtTLKy4WY\n", + "2ZPATilHuMfdx/QihxBNQ8OKHALnmtlRZnZmFGRrMxtVa0FEx1OpDEiWNZIkOyQ2Iy+jQo2peRlH\n", + "UvSUEORTHP9JyBo/Ii6/GdcJUTPiMNNEgoVxT/w/Ia7PCoNNkt6pByvjHmJeBvkq2VZdy0qITiJP\n", + "rao93X1XM3sMwN2XmNnAguUSHUhUEmk+hLQw2CQ9O/XefBm9yKHoKSGyyaM43jKz1XOMm9l7gXcr\n", + "tBeipqR05OsS/B5vktap5/Rl9HZO5AgXIpU8zvEvAYcBuwHXAF8AvuvuvyxevNUyyDkueqcfVoYQ\n", + "7UhDp441sw8B+8XFO939mVwHNxtLmChtAPBzdz8/o90ewAPAYe5+a8p2KQ5RmRpYGUK0Gy0353gc\n", + "3vobsD/wMvAwcHi50ont/khIsLrK3X+dciwpDpGOrAwhMmlkOG5fGQXMcve57r4KuAk4JKXdKcAt\n", + "wKsFyiLakb5FTAkh+kmRimMY8GJi+aW4bjVmNoygTC6Nq4oxf0RLYmbjzGyamU2P/8fFDdXmZQgh\n", + "akivUVVmtqO7P122boy7T+9l1zxK4ELgDHd3C2EzGo4SQHbRw2PMtrgGjkG+DCEaRp5w3F+a2RTg\n", + "h4ThgPOBPYC9etnvZWCrxPJWBKsjyW7ATTHUcihwoJmt8pShBjOblFicnkNxidZmAgmlYWHF8PPg\n", + "MoKlLF+GEGWY2RhgTOHnyRGOuy5BWexOqEp6A3Ceu1fM5TCztQjO8f0IJRweIsU5nmh/FTBVUVUC\n", + "wMymA5+AoD2uJFQejMjKECIHjXSOv01IshpMqBn0XG9KA8Dd3wZOJkwE9TRws7s/Y2bjzWx8P2QW\n", + "ncEKI9QgeYKgNOYDx8Gj8mUI0VjyWBxPALcBZxOGky4DVrr7ocWLt1oGWRwdxjFmJ3wNLh4VCxxO\n", + "AU6DOYvgZJX+ECIfDcvjMLM93P3hsnVHu/u1tRamggxSHJ1CWV7GYlh5Gsy8NvjHVC9KiCpouQTA\n", + "WiLF0SEo+1uImtKIGQCF6Bdl072unuK1fP3acPFKGIGyv4VoCaQ4RCFk5WHEumRfKq0fDlwfoqdK\n", + "kzXJyhCiydFQlSiEClPBLgKGxrwMfkCYzHsxrNwEDpOVIUTtaMVaVaKzyZrudeBwQoGpCwlKYwow\n", + "EmZIaQjRGkhxiKLoMd2rAf8H1krmZRwMHA0shDfqK54Qoq9IcYii6DZv93DgAVhxAaybsDKYGjZr\n", + "Pm8hWgg5x0UhlKZ77YJTzoIR34D3DwrDVwsuh8vHh7L7ms9biBZEznHRg6ww2j4cSHkZQjQQ5XGI\n", + "ulAhjJbcykOz8gnR1sjiEN2oEEa7hDD9b2XrQ1aGEE2DLA5RL7LCaDcmKJR060NWhhAdg6KqRDk9\n", + "wmjLGE6YJ34NmvtbiI5CikOU0y2MNoPBAOuYffr7Zs+sgGeBfVbAUjT3txBtjxSH6EYcgpoITAPe\n", + "zGi2/BizE+6FW74DHxwEXVOArWCphYm/hBBtjHwcogelHAxgF8J0wavpgvm/hxc+DpcNgq75wHhW\n", + "J/JtRxjGUk6GEG2MLA6RxdnA5skVw4GHYP0D4MSSlZHI/i4xuF4CCiEagxSH6EHM5dhx9TJr5v7e\n", + "LVggC46DR48mODXKWF4fKYUQjUKKQ6QxgWg5lFeyvR3mASOvhn+jpxNdNaeE6ADk4xBpDCqfL2M+\n", + "cBK89Vv4F3df4lDyg5yCak4J0VEoc1z0YFezP02G0aPj8hTCUNVSeMTdd2+gaEKIKlDmuKgZmUUM\n", + "Y/b3DBg1gGBlJCKmZgNnNkRgIURTIcXRYWQVMTzGbItr4BhgnwHATLjr4+ALwj2iYSghxGo0VNVh\n", + "lBcxLPkyzoN3B4VgCdWYEqJN0FCVqBWrixgOJ5Sxjb6MLlTJVgiRA4Xjdh4rknkZpbm/j4NHVWNK\n", + "CJEHKY4O42i45UFYUcrLmALsDHOuDnkZQgjRK/JxdApl82UshpWnwcxr4SXk+BaiLSmq75Ti6AQ0\n", + "K58QHUlRfaeGqtoZsy7MTiW4M/YhRExpvgwhRL9QVFW7IitDCFEQsjjaDVkZQoiCkcXRTsjKEELU\n", + "AVkc7UBOK8PMxpnZNDObHv+Pa5TIQojWRRZHq5PTysiqUWVmKBRXCFENhVscZjbWzJ41s5lm9s2U\n", + "7Uea2RNm9qSZ3WdmOxctU1tQvS9jAt2VBnH5lGIFFUK0G4VaHGY2ALgE2B94GXjYzG5z92cSzZ4D\n", + "Pu7ur5nZWOByYK8i5Wp5+ubLGJSxXnOECyGqomiLYxQwy93nuvsq4CbgkGQDd3/A3V+Li38GtixY\n", + "ptalfxFTKzLWa45wIURVFK04hgEvJpZfiuuy+DKg8fY0gpVxD/ATgpVwHTCyivLnk9Ec4UKIGlC0\n", + "czx3PRMz2xc4Htg7Y/ukxOJ0d5/eL8lahbIaU/Rxvgx31xzhQrQ5ZjYGGFP4eYqsVWVmewGT3H1s\n", + "XP4W8K67n1/WbmfgVmCsu5e/FXdurSrlZQgh+kGr1qqaAYwws23NbG3gi0C3N2Uz25qgNL6UpjQ6\n", + "EmV/CyGamEKHqtz9bTM7GbgDGAD8wt2fMbPxcftlwJnARsClcShllbuPKlKupkZWhhCiyVFZ9Wah\n", + "j76MmNg3gRBuuwKYLL+FEAI053h700crQ9ngQohGoFpVjaT/vgxlgwsh6o4sjkZRG1+GssGFEHVH\n", + "Fke9qW3ElLLBhRB1R4qjnpRlf0+FhZvD0wZv9/GIygYXQtQdDVX1gaojmcoipl6Bd06AAVNhM8Lf\n", + "1n1xaCsbXAjRCBSOWyUZkUyzgImpHXaZL+N3MO8o2GJpz0NPc/cDCxBZCNGhtGrmeDuSL5Ipw5dx\n", + "EMxMURrQT4e2ZvcTQtQLDVVVT++RTJUipsy+mrF/nx3ayucQQtQTWRwZVHiDz4pkGrmO2adzREwV\n", + "4dBWPocQom7I4kih0hs8oePfvmwbw2Ho9XALayyS1LyMghzayucQQtQNKY50Mt/g3f3A2PFfAww1\n", + "1oRLDYFBi2HlJnBYpRpTUUnUcghJ+RxCiLqhoap0Kr7Bx47/r8MJSRkXAkOAKcBImFHtJEs1QPkc\n", + "Qoi6IYsjncpv8GZd58Jm/0pQGPOB8cDU0OaN4sXrjvI5hBD1RHkc6edL83HMBiY4zCQRMTUFmAgs\n", + "TbZRhy2EaAJUVr2OpL3Brw2XrIQdCA7wwcCCy+Hy8TAKveULIToIWRz5BNCsfEKIlkOZ441Ac38L\n", + "IUQPNFSVhawMIYRIpaMtjtTscFkZQghRkY61ONIip3aED74Cb24KI+MqWRlCCFFGxzrHzWwa8CmA\n", + "suxvCFbG+AYk8gkhRM1QOG7tGQTB3LgSGB1XToWF/wwjZWUIIUQ6Hevj6IIVEwmOjNGE7O+Dw99j\n", + "UhpCCJFNZ1ocZiPmw5abxsVE9rfqOwkhRC90lo+jbO7vFbD0JJhzdagvpcxvIURbUZSPo3MUh/Iy\n", + "hBAdhjLH+4ryMoQQoqa0t+IIVsY9wE+AwVNh4ebwtMHbDZZMCCFalvZ0jpf5Ml6Bd06AAVNhM8Lf\n", + "1maG/BlCCFE97WdxlFkZv4N5HwxKI8lwQsl0IYQQVdI+iiPDl3EQzFyavsfg+gknhBDtQ3sojjIr\n", + "gxAxNTKWDKk8DawQQoiqaG3FkS9iajIwq2xPJfoJIUQfaV3neM68jLRpYFGinxBC9JlCEwDNbCxw\n", + "ITAA+Lm7n5/SZjJwILAMONbdH0tpsyaJpSxiihpWso2l1icQCiCuACZLwQghWpWWSwA0swHAJcBY\n", + "YEfgcDP7UFmbccBwdx8BnAhc2stBK/ky+itvaX6OTwGfiP8viuubBjMb02gZmgVdizXoWqxB16J4\n", + "ivRxjAJmuftcd18F3AQcUtbmYOAaAHf/M/AeM9ss9WjFZ39PIDGpU6QZw3bHNFqAJmJMowVoIsY0\n", + "WoAmYkyjBWh3ilQcw4AXE8svxXW9tdky43g1tzLKGJSxXmG7QgiRoEjneF7nSfn4W9Z+Rc/Kp7Bd\n", + "IYTIQWHOcTPbC5jk7mPj8reAd5MOcjP7GTDd3W+Ky88Cn3D3hWXHav4SvkII0YS02tSxM4ARZrYt\n", + "MA/4InB4WZvbgJOBm6Ki+Xu50oBivrgQQoi+UZjicPe3zexk4A5COO4v3P0ZMxsft18WcyzGmdks\n", + "4B/AcUXJI4QQoja0xEROQgghmoemKjliZmPN7Fkzm2lm38xoMzluf8LMdq23jPWit2thZkfGa/Ck\n", + "md1nZjs3Qs56kOe+iO32MLO3zexz9ZSvXuR8PsaY2WNm9hczm15nEetGjudjqJlNM7PH47U4tgFi\n", + "1gUzu9LMFprZUxXa1LbfdPem+CMMZ80CtgUGAo8DHyprMw64PX7eE3iw0XI38Fp8FNgwfh7bydci\n", + "0e4u4L+Bzzda7gbdE+8B/gpsGZeHNlruBl6LScC/l64DsBhYq9GyF3Q9RgO7Ak9lbK95v9lMFkdt\n", + "EwZbm16vhbs/4O6vxcU/k53/0urkuS8gJGreArxaT+HqSJ7rcATwa3d/CcDdF9VZxnqR51rMBzaI\n", + "nzcAFrt7W8786e73AhmzRwAF9JvNpDhqnTDYyuS5Fkm+DLRrTa1er4WZDSN0HKWSNe3ouMtzT4wA\n", + "Njazu81shpkdVTfp6kuea3EFMNLM5hEqTkysk2zNSM37zWaqjlvrhMFWJvd3MrN9geOBvYsTp6Hk\n", + "uRYXAme4u1sohdyO4dt5rsNA4CPAfsAQ4AEze9DdZxYqWf3Jcy2+DTzu7mPMbHvgj2a2i7u/UbBs\n", + "zUpN+81mUhwvA1sllrciaMZKbbaM69qNPNeC6BC/Ahjr7pVM1VYmz7XYjZALBGE8+0AzW+XFVRlo\n", + "BHmuw4vAIndfDiw3sz8BuwDtpjjyXIuPAd8HcPfZZjYH+AAhv6zTqHm/2UxDVasTBs1sbULCYPmD\n", + "fxtwNKzOTE9NGGwDer0WZrY1cCvwJXcvn6iqnej1Wrj7du7+fnd/P8HPcVKbKQ3I93z8FtjHzAaY\n", + "2RCCI/TpOstZD/Jci2eB/QHieP4HgOfqKmXzUPN+s2ksDlfC4GryXAvgTGAj4NL4pr3K3Uc1Suai\n", + "yHkt2p6cz8ezZjYNeBJ4F7jC3dtOceS8J34AXGVmTxBekL/htauk3VSY2Y2EqSCGmtmLwFmEYcvC\n", + "+k0lAAohhKiKZhqqEkII0QJIcQghhKgKKQ4hhBBVIcUhhBCiKqQ4hBBCVIUUhxBCiKqQ4hCiBsRy\n", + "5lPj53/upfz7hmZ2Uh/OMcnMTu+PnELUAikOISpgZlU/I+4+1d3Pr9BkI+CrfRBHSVeiKZDiEG1H\n", + "nNDpCTNbx8zWjRP57FjWZts4EdB1Zva0mf3KzAbHbXPN7DwzewQ41MwOMLP7zewRM/ulma0b2401\n", + "s2diu88mjn2smV0cP29mZr+JEwo9bmYfBc4Dto8TLp0f233dzB6Kck9KHOs7ZvY3M7uXUDZDiIbT\n", + "NCVHhKgV7v6wmd0GnAsMBqZklN7YATjO3R8ws18QrIAfEd7sF7n7bmY2FPg1sJ+7L49DUKeZ2QXA\n", + "5cC+sYjezaRbBJOBu939s9F6WQ/4JjDS3XcFMLMDgOHuPiq2+a2ZjQaWEeow7UIoIfEonVmkTzQZ\n", + "UhyiXTmb0MkuJ0zylMaL7v5A/HwdMIGgOABujv/3AnYE7o81wdYG7ie8/c9x99mJ/U9MOce+wJcA\n", + "3P1d4HUz27iszQHAAWb2WFxelzC3xvrAre6+AlgRlWE7lowXLYYUh2hXhhI64AEEq2NZSpukhWBl\n", + "y/9IfP6jux+R3NHMdik7VqUOPU9n/+/ufnnZOSaW7SulIZoC+ThEu3IZ8F3gBiDLUb11LDMNYdrV\n", + "e1Pa/BnYO04GRPSZjCCU7d7WzLaL7Q7POMedwElx3wFmtgHwBsGaKHEHcHzCdzLMzN4L/An4jJkN\n", + "MrP1gYOQg1w0AVIcou0ws6OBle5+E8ERvYeZjUlp+jfga2b2NLAhKVPPuvurwLHAjbFE9/3AB9x9\n", + "JWFo6nfROb4wsZ8nPk8E9jWzJwlDZx9y98XAfWb2lJmd7+5/JCi4B2K7XwLruftjhCGzJwhTAz/U\n", + "z0sjRE1QWXXRkZjZtsBUd9+pwaII0XLI4hCdjN6ahOgDsjiEEEJUhSwOIYQQVSHFIYQQoiqkOIQQ\n", + "QlSFFIcQQoiqkOIQQghRFVIcQgghquL/A4lyzbhX2qMhAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd8VUX6/99PeiUktNBLQk1QqYIFsAG5ILYFrKso6K4l\n", + "+ltXd60hrru6+90m6lpQXHUt4FrWEiKiBCx0BemE0AIJNSGFFFLm98ecm5xcbtpNhcz79Tqv5M6Z\n", + "OzOn3M+Z88wzz4hSCoPBYDC0HbxaugEGg8FgaF6M8BsMBkMbwwi/wWAwtDGM8BsMBkMbwwi/wWAw\n", + "tDGM8BsMBkMbwwh/AxCRchHp14TlXywi25uq/KZGRPaKyGUt3Y6WQEQCReQzETkhIguttKdF5KiI\n", + "ZDRyXY+IyPzGLLOxEZHbROTbFqq7j/Vb9bI+J4nILc1Q71wRebup6/GENiP8lggViEieteWKSGQL\n", + "tmeuiJRY7cgVkR0i8ry9TUqpb5VSg+pYVmu8wZS11Rvrel3ayO1pTn4BdAYilFIzRaQX8BtgkFKq\n", + "m6eFisgEEUm3pymlnlFKzWlYc9sOSimHUqrW30sj3IOtdpJUmxF+9EWYqpQKtbZ2SqlDLdye95RS\n", + "7YBw4BogEljfkg+kVoQCpKUb0QB6AzuVUuXW517AcaXU8RZs01mBiHg3U1Vn+j1YLW1J+N0iIm+K\n", + "yG+s/7tbr4R3W5+jROS4Le9DIpIhIgdE5PaGVm1tKKXKlFJbgZnAUeBBq74qvTsR+Z1Vd66IbBeR\n", + "S0VkMvAIMNN6k/nJyjtLRLZaedNE5E5bOROscn4jIoetY7rNtj9QRP5m9XhOiMi3IhJg7RsjIj+I\n", + "SLaIbBCR8bUc52gR2SIiWSKyQET8bfVMtcrIFpHvRWSolf42Wig/s47pIRH5dz2uk9tyrX3dRORD\n", + "ETkiIrtF5D7bvrkissi6J3JFZLOIjKj2AooMEpGvROS4dT2mW+mJwBO2a3InsAToZn1eUNu5FJEI\n", + "EXlDRA5a5+4jEQkCFtvKyRWRrvY3PhFZLCL3uLRzo4hcXVObqzm+htxDHUTkUxHJEZHVQFQN9ThN\n", + "MXOs480QkQddrst/ReRtEckBbhWRMBF5XSp/j3+QSlOOl4j8VbRZLQ2Y4lJfiojcYfs8x3acW0Rk\n", + "mJt78Ld1uGZ9RWS5Vc4SoGN1x9ziKKXaxAbsAS5zkz4L+NT6/0ZgF/C+9fl24GPr/8nAIWAIEAS8\n", + "C5QD/Txsz1zgbTfpicAq6/8JQLr1/0BgPxBpfe7lrBtIAN5yKccB9LX+HwecBIbZyi2x2uANxFn7\n", + "w6z9LwLfAF3RnYMxgB/QHTgGTLbyXW597ljNMe4Ffra+Fw58B/zB2jcMOAyMQj8Af2ldI1/b9brU\n", + "g+tUbbnWsawHHgd8gL5AGjDRdk0KrWstwJ+AldUcWzCQDtxqlXse+qE92N01AcY7r6X1ubpz2cH6\n", + "/AXwHhBmtfVid+W41gXcAnxn2zcEyLaOv8Y2uznGhtxD71tbIBADHABWVFNPH/Rv6R0rfyxwBOv3\n", + "atVxCphmfQ4APgZesvJ3AlYDd1r7fwVso/K+WwaUAV7W/mXA7db/0622jbA+RwG9qrkHa7tmK4G/\n", + "Wuf6YiAXl99la9lavAHNdqBahPKsH0E28JHtQmehf+gvAXdSKbZvAg9Y/y8A/mQrrz9NI/y/QpsI\n", + "nD8uZ1ui0YJ2GZY41laWS56PgXhbuQXOH4KVdhgYjRaEAmComzJ+53ojA8nAL6upc4/zx2h9jgN2\n", + "Wf+/BDzlkn87lQLn+qOr63WqrtxxwPnAPpd9jwALbOdxiW3fEKCgmmObiYuQAa8AT7q7JvZrWdu5\n", + "RD9wy7BE1CVPlXJc6wJCgXygp/X5j8BrdWlzHe7Zut5D3mihHmDb90fg22rK7YP+Ldnz/9nW7rlA\n", + "im1fF6AICLCl3QB8Y/3/jct9d4VVvjvh/xK4r4b7134P1nTNeqEfhIG2fe9Qy++ypba2ZOpRwFVK\n", + "qXBruxZAKZWG7qmch35Kfw5kiMgAtFgst77fFd1bcrK/uopEe+M4B5E31bOd3YHT7MBKqV3AA+gf\n", + "wWEReU9EutbQhjgRWWW90meje28dbFmOq0r7M+gfcQj69TQA3RN2pTcw3XrNzbbKvRA9NlEdrufM\n", + "ObDZG3jQpawetv1VqMd1qq7crta+bi77HkEPwjo57HJOApwmBDfn4nyXsm5Ei1JdqOlc9gSylFI5\n", + "dSyrAqVUHvpt4QYr6Xq0ANW7zQ24hzqh31Lq9HuxUd29ArpX7qQ3uledaTuOl616oR6/VfS94e5e\n", + "d0dN16wbkK2UKrTl31fHcpsdn5ZuQCthOfqVz1cplSEiy4Hb0K+JG6w8meinupNeVINS6lt0z6sm\n", + "lGuCJTBXou3B7sp9D3hPRELRPbU/o3sbVcoSbUf/ELgZ+J9SqkxEPqZuA1XH0L2paLSZxs5+dA/m\n", + "ztO+VT2u5+ygraw/KqX+VM33Tjs/1O06VVuuiIwB9iilBtSjzurYDyxXSk30sKxqz6X1QI8QkTA3\n", + "4u+uXNe094AE0e6TAUqpZXVss70NDbmHjgKl6Ou9w0qr9vdiwzX/Qds++zGmA8VoE4v9weOkzr9V\n", + "q6zoava5ntearllvIFxEgpRSBVZyb/SbW6ujLfX4a2I5cC+wwvqcYn3+VlnvbMAi4DYRGSx6kC2h\n", + "gXVW/IBExEdEBqN/sJ2Bv5+WWWSA6MFcf/RNX0TlTXUI6CMizjL9rO0YUC4icUCtP3YA64e0APi7\n", + "6IFDbxEZKyJ+wH+AK0VkopUeYA3yda/hGO8RPRgbATwGLLT2zQd+JSKjRRMsIlNEJMTaf5jTBwTr\n", + "cp1qKncNkCciD4sewPYWkVgRGWlrb135HBggIjeLiK+1jRIRp/ttbWVVey6VUpnoQdx/iUh7q+xx\n", + "tvPSQUTa2cpyrSsJLTqJaDt7XdtspyH3UBnwETDXOs9D0OMKtT0MH7fyx6Af6AvdZbLOzxL0PRoq\n", + "ejA3ynaOFgHx1n0XDvy+hjpfA34rIsOt+yVatOstnH4P1nTN9gHrgETrvF4ETK3leFsMI/yaFehX\n", + "VKegfI8eNHJ+RimVDPwTbT/cCXxNw/x0FZbXB3AC+B+6pzRCVXUzddbhDzxj5clEm2QesfZ9YP09\n", + "LiLrrNf9ePQPIAv92v8/N/VXx2+BTcBatNnpGbR99ABwFfAoevBtP9oDqbr7SKHNDEvQr9OpwNMA\n", + "Sqn1wBzgBauNqei3FyfPoIUgWyxvHup2naot13qoTUWbi3ajz+WrgFNElZvz4vY8KaXy0UJ4Pbpn\n", + "mmm12a8uZdXhXN6CthlvRwtQvPW97egOwm7R3j5dXetSSp1CC+9laCeEurbZfnwNvYfuRV+rQ+iO\n", + "xIIa8jpZjh60Xwr8n1Jqqa0e17p+abV7q9W+D6g0Oc5H2+43osX4w+raqpT6L3r84V30YOxH6DdI\n", + "cLkH63DNbkSPI2UBT6LHnlolUtlR8rAA7Zo2BTiilBpaTZ556IG9AuA2pdRPDarUYDCcNYhIH/SD\n", + "2Kca042hkWmMHv8baPc3t4iIA4hWSvVHe2K81Ah1GgwGg8FDGiz81kBmdg1ZpmG98iilVgPtRaSu\n", + "ng8Gg6Ft0DDTg6FeNIeNvztVXasOoF2oDAaDAaXUXqWUtzHzNB/NNbjr6nVgnu4Gg8HQQjSHH/9B\n", + "9IQUJz2o6p8LgIiYh4HBYDB4gFKqXsHkmkP4P0W7dr1vTaA5oZQ67C5jfRvfEojIXKXU3JZuR02c\n", + "CW0E087GxrSzcTmD2lnvTnODhV9E3kMHjuooOpJkAno6NUqpV5RSSSLiEJFd6Cn3sxpap8FgMBg8\n", + "p8HCr5S6oQ557m1oPQaDwWBoHMzM3fqT0tINqAMpLd2AOpLS0g2oIykt3YA6ktLSDagjKS3dgDqS\n", + "0tINaCoaPHO3sRARdSbY+A0Gg6E14Yl2mh6/wWAwtDGM8BsMBkMbwwi/wWAwtDHMQiytHJFYB/SM\n", + "h9AAyCuC9HlKbU5q6XYZDIYzFyP8rYyqQn8oBEZ3gwW2JRbnRInE0lDxjxVx9IT4UAjIg6J0mLdZ\n", + "KfNAMRjaAEb4WxFa9Mc+B/OtpeAeB56GsP0Qdx8s/BjU/Ghw3IdeZckjYkUcY+G5+RBd4gW+5TAH\n", + "omJFMOJvMJz9GBt/q6JnPMyPJuQQeBdT8VzO6QmhGTDkv1a+kMAG1QLx8yH640Fw/hwoE5gP0b3g\n", + "Pte8IrEOkbhkkYk/i8QdFbn2Z/051tGQNhgMhpbD9PhbFaEBAEy+H/ZcCutLrXSBr5+BKXfDtmug\n", + "PL+wQbVAwD/HwP9dAJ+9B97WVI4QvYwhoN8KvAh7KhDHkEK5IxD1DchToLw7AkMby+RkMBiaH9Pj\n", + "b0X4cCyUgBMQnQxbp6OXR31M79x9OeT0wmf4BadG80P3OJHkWL26Wb2QRPH+7lr6zB8OP7wOwzMr\n", + "9+VDIVSagrrSf0Rh1G2B9EwE+QM83An88q3c86Oh12lvCAaDofVjhL+VECviGM+6yE5DrtAiXxgB\n", + "jAM2ZcHE9d5M2xTxdWZR2Lj1fik+OUMXw6Sx8Fx9xF8SJQj44Eg/coa/we7eOZX7ZkPafngeKk1B\n", + "m648CFPvgiPngvKCE32g0xZbiQ0zORkMhpbBCH8roSfELyWvW+dzf+S8nzcynglMYhRDWbFbqSUj\n", + "r+CzjOMHtwaMP6B4YbT+TnV2eXdIonQCvgEKykIY/VMh9zkgeQYsd0DyKoh3DuyGQgBA95/bwb+2\n", + "QFGYLuTwUOiyyVZqw0xOBoOhZTA2/lZArIijD4xOAIZ/WM6teWlcRhoAM3Qo6wox/vNSyPGv/K7d\n", + "Lm+nilto5AEvbpdo/NQC4AmVoBQJJFGNZ1AeFAHM3XeQ+5lFGvcAj8GRodBZC78/NxYEsWFVo5wA\n", + "g8HQrBjhb2FsrpXhAORqq74v2tDjtLs7xTg6q+r3nfvtVHEL7fk9zLwOlo45wprcH5TaXGtUvnSY\n", + "Nwei5pMfDUk8z27WUlSiDp/yVv2PeJ3PD9zH9qC3KX8yTM65OZfy+80gr8Fw5mBMPS2M054OlT35\n", + "PwJfUdXubonxLvt37ftdStVuoYM+huuvgY/fhDU/dK7PYOw+yL0Osl4iP7uAdetGsHnT5iM7vXw6\n", + "n2Ax65hCPu9T4DWAbtEw+jXj3mkwnDmYHn8L4zTh7G0PF94Oe/+pJ1RthawdNrv7ZqWSYkVwwH0h\n", + "EJgPhfvhefcTriy30PxIeHsJHDrPSq99MNY+ucuZNgfa74PCrnlw7mE46Qchp/S+YArRM4sbNqms\n", + "KTDhLgwG9xjhb2GcJpw+J6BfNnw+AK7ZDoWwxlXUrc91EK68IgAOjHVJr30w1vkGUuQDfmXgpfQg\n", + "8mTIFWDpW1Xzn9TPLVqbh8/ps6DBmnswCnqONQ8DQ1vGmHpaGLsJ58718OqImkw4dS51HszZVTVt\n", + "dhrsr7VM5xvIRbfDeluEINoRMrMdVcYHZhDFduKtT63Nw8cyd/kshk5XA3MBFQ2jHoHFk2DReP13\n", + "7HPGTGVoa5gefwtjN+EEbCN4qYMxkUN4On2L5zFzlNqcJBKLNr+EBGpR3v98XXq2zjeQy3bDZwNh\n", + "VIZOD/PBa0W0V/aow7QPzugsJ0vOZTv3kc8UYFZmXR4qzUtoAKyA8q/h6CdW2uPA0/502QiDP4KU\n", + "RPQbQeszUxkMTYkR/laA3YQjifLcgRlENbRMS+TrLWbpMO8OGDdrJ4H3OuCpZfCADxw4D0r6lLPu\n", + "QL/rKen+EPj0gwXAc3sg48nWZi7x4VhoKUug/K9wxUOw5zLYZd3u57wDZb623K3LTGUwNDVG+Fsf\n", + "rwJLJFESVYIqrTV3I7NZqaTzRQ78Pj24/6bQYsLDRlDoV8a0Y9sJTclfnVyWtghY1Nztqi+D+VGl\n", + "0oGioe/C4I/h28eA7wAFMQvh3c9tuVubmcpgaFqM8LcyVILaIomyB5gC/K+5648VcXQmtMN+FUd5\n", + "agAnBoyGtffw+dHrywJY0eAJW03taeNcZ2AgRB/pvI2iySnw1lIoag9MhB63QUkwHIm1vlG3sQ+D\n", + "4WzCCH/r5FXgTlpA+HtCfBkDI9JYCDv/C8Nfg7X3UMj73oU4xnhabpVon76vBVISZO1pvCifdlfU\n", + "HH8YMnMrQUtGUXD4XCvHOGToL8tUKodhZmp9xj4MhrMJ49XTOvkAGCOJ0qu5Kw6FgGKC9YddkyDw\n", + "OEiZtdczW7hTkCOJHlF47uRA7hsAAdnW3saL8ul0RVXArKvhqt2KRRu30o9RjGcCXWR0gTpvfwEX\n", + "7LtUqUUTlEqKM6JvaIsY4W+FqARVCLwDzG7uuvOgKECHB4JToTB/LShva69ntvCeEP+SF9EbfrEf\n", + "LvwLvPMFFIXbcjTO4KrTFXV/mF5c5h/JMIV8hrMuJ4jlyaWXrX0Kf5WmEtSOxqjPYDhTMcLfBMSK\n", + "OOJEkmeIpHgaNx9t7rlDEqVZzXHpMK+MHRlRzKySLtzqsctmKAT4lEPk9lB4dR1UmF6cNM7gqtMV\n", + "tXcO/O998LdeVE7CyiSl4o5fRB9gYWPUZTCcyRjhbyScSxT6yLSfjzP6g3sJmbQIxnsSNx9AJajN\n", + "wF6gWScXbVYq6RB5c4L4cl0HxmaFckWWD5euV6yf7alZxCnIz2w+QlTprS57G29wtYZ4RqsmecuX\n", + "voXcceGLxHn4IDYYzhrM4G4jYA8PUAYcAuK9f8EpSeaa0pPMh2iHjptfP+Hc0m4VoV6viczY2pzh\n", + "BeoeGqJunB7tcxQ/0q4oG7WllCONNgdgCzHsoHPuQryzfMmX7mxLKyfn87Fw8/S+RJ84Dt8dZdwc\n", + "6ObJwvIm9o/hrEEp1So23ZSWb4dnbZ+cDEoR+67iyjmKu4YpHgtUw6P7KwVKgZoOKfUrM8aB7627\n", + "eDhCEbbPKmZ2KsQ4Wvp4PdliwBEHi6dDShwsjoFGPQ6IcejzU3HKFcxOvQSf9QrUrKtQfx9TuTMO\n", + "FntcvpS2qusRA47JkDwdUiZDcmOfW7O17s0T7WzxRjek8a1lg+kpoBRj/qEY9YKix0qFT4Eaz3jl\n", + "udBYD5O4exUTEmxiFlevctrKBpOTkVLF8FdtwqzU5YQeV6DmXIlKb1dxEj14EE9Kps8yxXXXK24b\n", + "32quRww4ZkOqrUFqNqQa8W87myfaaWz8jYIVDXPVA7D2HjgwBkoDcXrHeBZ0zQqtvP5O8C62pZvw\n", + "Am7xDgrk2ltg6HvgU3m+8vEVgFc/gx652NJPX8DGHf07yvXjOsj2Cd2WXDGybCohm9rBwo9sOVr2\n", + "ejhdWNd1g3eG6rT6LMlpaJsY4W8UTo+G6c+NBdmkbnJdz7buWA+TI0Ph62ds6Sa8gCuSKP7csmwQ\n", + "/jnaVbRichhso3ta3RewqShPJFHGh0+TZSPKeOfhrOCBfhkjvILTRxK8cxsBhQtsuVv2eoRCQK4/\n", + "XP8LHUbbSXVLchoMYAZ3GwV30TCL2f/8anWiAQN/6fNgTlTVePImvIArkihBwIe0z0/l+S65lAVW\n", + "OV85lCeshDotYCOJ0hH4JXrWdPnQ75FbToR43XBlJ/LSfgdbfwGAP7OAFcBbLX49cqHo11Pg0j0w\n", + "fWtlel3faAxtEyP8jYSn0TBrKs/T0MptBUmUUOAzIJ32JVdStmZiDefL7XmTRBHgYuAudHykT9ET\n", + "576PzGLZPAYNyls7H26eBEVhsPsKinkDiDsG6fGeXo/G8hD6YQZbpQuXZL6MnzOt4es5GM52xBoc\n", + "aHFERCmlpKXbYTgzkERpDywGNgG/Ugmq3F0+Z9C2UAjIg6J0mLdZqSRJlA5U9u4V8ArwtkpQFcvZ\n", + "x4kkFzJ+0nJSoNd3cPnv4I1vQXkBM5YrtWiCR213vzrYLlhZr0XrJVEGAt91/YInz1vLtNqX5DSc\n", + "jXiinUb4DWcckiidgCXAcuD/qQT3N7Hr+sEKmNKPA0unkloSwXD028IrwPfuyogVcRxn9AeHWK0H\n", + "DaTcEn0AR7JSSXEetV/ikiFpEu336TKz+9W7TEmUAGAl8IpKUC970g7D2YEn2mlMPYYzCkmUrsBS\n", + "4BPg8epEHyo9XrIC4a1z9bKWCnr03Eze7nH0s/fu3bFZqaQI6fYXf258uJh3gypFv35jLZY5qTcw\n", + "AhjBHRGj6dAJyvzgu9/DaufylfXyEPoLkIZ+cBkM9cIIv6FVYzfVZHYAr7voX+7HiypB/am274ZC\n", + "gAKuuAWGHIVXPoOL9sNMOJL2dc2i7yRLZSSKxK51jh34cCxkMD8yiJyH40TinaYjZ35L5HsBI3EK\n", + "vd5OAeuBdazrvoe0L8PJ7+pSW908hCRRpgHTgGE1PfgMhuowwm9otdhNNbsi4PJbYPgKjhV+xwYS\n", + "av9+HhQJsPo18LGNALjzeKluLAAqB+7dmY6uD2dg+NXyzolheFEp8iXAOrTQvwCsVwkqw1mXzI1d\n", + "C08+54nHliRKD2A+cI1KUNm15TcY3GFs/IZWS5xI8mKYtLUTTLwFnlwOd64HByQnKVWrLdxVqAFu\n", + "RTL/R2xGDoPynd40MWzBNd8c2PUhXf+TzbljnZ43Q1nZ8WdyRvx9LCyJgnXdwLcMirI5eqIX/0IL\n", + "fRWRrw49wNurXh5bkijewDfAEpWg/lhbHYa2gbHxG84qnPH1/3QxPLsUbv5Zp9d1ctJmpZJiRSp8\n", + "+I/hE7KO8V3zWDqiMtecqM7syJ1PaXRGKOT5QVQ2XF0eEv02Ex6Gdytmg+3ixsIv+IzI/HzuWQMj\n", + "MqFbHsyArYuUmuvMVxdXTQ/dfx8HyoBn6/k9g6EKpsdvaLU4e/wKsN8Yde3xu6K9aRZPImYhFHSC\n", + "PZcCcDntsr4iL2JhDDx6GWSGgvfxQPKPXg1HYnQYjqL2AExiFMmsq1LuWMKOraLHrdbcCzeumtdm\n", + "QP4haJ/nqc++JMo49FoCI+ryRmFoO5gev+GsojKcc6UJpmGTk6z4R+c/Dyser0h1xvOZuUVvBb5w\n", + "ccfB/Nh5MnTaAuXeFXl/IrQQ2xvHDKLYzHMd4ZPnRGIhvMNDRI2IZtBk2DkF1pwLDO6G72PdPF1n\n", + "2Jpz8B/gDiP6hsag1Qp/TYNthraBq6mm4ZOT8ooIOgqdN8GeSypSdTyfrPbOB0xQCWRk+hSQ+csg\n", + "1xKyYOtYwnr7c27Hkx3S2Z4/l/zQKBgUFc05779L2I5gdvSEH2frNYv5M3glwu2j4It/wYGx6LcB\n", + "R43rM1Sai0ICuC18MP6F36uXC839b2gUWqXwuxuUmwNRniyeYTizadxFYdLnMeSa89h9eRfK/K00\n", + "9/F8iklfBXNudvW8KeXIk6u8L/sdN+aOI0JB+VPgWwDbr4ZlQ/eRGnKI0v9MrPyOD4x+Hgo66qit\n", + "FYQEVjcWUMVcNOpF8NsNr59zjrwS6zAhOwyNQasUfufEm3w/OBQC0Vl4voqVwYDuTEyG+JUDfQJP\n", + "beuVd4ppe8soPVhTPB+7/z6SV8zwjd9zZebVlG69iPIgWHMPbJ0OGSPQoxCODO2SOadfxQOjXRaM\n", + "ewFe/4GqIxUnQtyEbYjS8Zl6xsP8aLpshAlz9XdL+0fV9pZgMNSVBgu/iEwG/gl4A68ppf7ssn8C\n", + "8D9gt5X0oVLq6ZrKdHpzrO0GT42HZW/qdBNq1uAJzjfIF7yJ7tyzlH0f7+ZRdgeutMYK4kSS3ZoU\n", + "5275Aba0B64CJgFBQBDFXtv55y/8KflzVGUt2g9fqc1J3SRiVG8+uDcY8V0dVxBSsKa/lB8f4FU1\n", + "bxHIK9F03gjtDkKqg0oTUIgei+i3FL78B2T1t75n1mIwNA4NEn4R8UZPULkcOAisFZFPlVLbXLIu\n", + "V0pNq2u5zsW5T/pBcEllugk1a/AE5xvkl30g9gh0KtBvkOMgcSC0t5sUrw9jQOhNsjh/AP2BMeh4\n", + "QJ8ADwB/BToTXDaNknWXuIsEGivimAI3z4eOX/SHBzrDOR/u5QCjCCCYLf6FRbnnpe4qGeQzksiO\n", + "cLITbL/GEn7Q5VlrMax80OVIzFoMhsahoT3+0cAupdReABF5H907chX+erkaOb05LvclOsgSfhNq\n", + "1uApzjdI33KIX12Z3k57DIUfaKdj+XwyCHZF0DcwnavzIR64ViWofGvi1JtAF2CaSlCFJOB27MH5\n", + "kCnwhXsdeuWvK0pP4ohcxw+3QfdcAnyPMvjQ1sEH+PDrDu7DNqQ/b9ZiMDQlDRX+7kC67fMB4HyX\n", + "PAq4QEQ2ot8KfquU2koNOL05vg3j2TwvOjlggwk1a/AU5xvkpXuqpvvre5PMEL09sxTG7YObykld\n", + "pNSHUDFb9t9AV+BKlaAKaqrL+ZBJ6g9jDsAVloGzbw68OU+/bcyAPR/g9ZfqwjaYtRgMTU1Dhb8u\n", + "s79+BHoqpQpEJA792jzAXUYRmWv7mMJEXgUGH1Tqnga209CGqW4+QB7kABGjMmCUzTveaVK0RP8N\n", + "oBt1EH2ofMj8Yitcvb0yPaIQOtnKr03c3c3src3F2bhAtw2scdMJDSmjocJ/EOhp+9wT3euvQCmV\n", + "Z/t/sYj8S0QilDo9OqKyTXsHkEQZDdaK5QaDh1Q3HwBgjovbsNOkaIn+AqAHMLUuog9VHzLOwHCP\n", + "ApNdyof6hW2wuzg7ZzLbXZzt+8sEvJVxgT5bUUqlACnOzyJSh5CFVWmo8K8D+otIHyADmAncYM8g\n", + "Il2AI0opJSKj0WEi6hQSFwgG6vSDMxhqorr5AO4eCFvm8iXwOjq8cp1F31mPvcwTEFIEahecfLYB\n", + "E9C6e3H/tf2IvvFcKBNY+N+qLs7OsYW13eA3k+DbN4wLtKF6GiT8SqlSEbkX+BLtzvm6UmqbiNxl\n", + "7X8F+AXwaxEpRYv49fWoIhg43JA2Ggw14fpAsHr6r6EXTpmqElS93zgba9KZFdt/GHCL32+5JCcL\n", + "btkIM7ZU5nG6ODvHFh6/FG7adPp+g8FOg/34lVKL0Wuf2tNesf3/IvCih8UHYUw9hmZCEsULHeu+\n", + "LzDFE9FvpHb0BG4CbkEL939GvMWqHw5xsWvefCgUiXWEMSbmvD6F7IzYzq9/8sH5szEu0AZ3eNWe\n", + "pWUQiXWwo9NVJJ8bLxKXrKexGwxNgyX6rwFRNLHoi8Q69D09I8V5b0uitJNEuV0SZRmwAf3wuQuI\n", + "UgnqydygnbkiAAAgAElEQVRDPDsHdtnLmQ1pGwhfBWOfy+GHjhsvC6Iw5TV+WzaFLwgxLtCGammV\n", + "IRsqYpWUZXcjdyYwfWB9IxoaDDVh94DJFYr87kFOdSSAZhD9ilANXiUQtQRG3H0hZQjefIUW6i9U\n", + "giq2f6+6AepMztfhHQZ8Dn55sOkG0riZmxh7rAer4s3ArsEtSqlWsemmOP+fnAxKcVOcov/nCpS1\n", + "xS1u6Xaa7czfYsAxG1IVqDJB3TEN1Wk2hdERXNvUdVfc22H7FL/trLhjrGLkvxQhlyz1rLzpKaAU\n", + "3dYoei+3/Vamp7T0eTZb82x27azr1ip7/BVx00sCoTjMlm5ilRgajtMDplzgrqmwswPsfouAGaeY\n", + "A3zUtLVb93ZOT3h9JWT3s9KXefhbtMI7ZIwCIIQvGMQ82rNyaJxIsvHlN7ijldr4rZt50Yew/yJb\n", + "uolVYmg4Tg+YrZ1gX3tIegdCTjWXB4x1byM20QfP7+30eTBnF2jRd3Ana1jCV+RFLIZJI5HXYkXM\n", + "+JihCq1U+Ctv5kpMrBJD4+CcXRt7BL58W4s+NJcHTOPe23rMa+X94EiO4ea8hWRwzfXwXS+9/9+o\n", + "rp3xeaqhrTacXbRKU4+JVWJoSuyza53RA5vLA6Yp7m3nDOArvEKzUHDbBvjlNbDxJQg9Bd4E9m28\n", + "IzCcDZjF1g1tklgRR69GW9KxZbBcUIeh1wqYNPJNLl67R0fCvWMaHFA+8Nl5/EB4aT7eX3uyyLuh\n", + "9eOJdhrhNxjOICRRugAT0WI/EchCz5xPDvvDkKcnlRUPX0gaH/gFc+OvoTT5XdjhXApjzi5Yeb8R\n", + "/7MLI/wGw1mGJIofcAE6ztsk9MSub4Bk4EuVoPZV5JVYRyiR8wfi0y2NcrJ7PQnTp8PLG+FkZyuX\n", + "I1mppLjmPg5D02GE32A4C5BEiaJS6McDO9C9+i+B1SpBlVT7XYl1QK/7IHgsfBDG2L/Dnkvh0HlW\n", + "juuyYcfNptd/9mCE32BoxVQXL18SJRS4BMtWjw5O6BT6r1SCOlbfukTikmHxpNP3PAEcqrPJRz9I\n", + "esZDaEAY20OGs006Uppn4v23HjzRzlbp1WMwnGnYBVL76lcdSLXHyy8X2NgF7hjESJ+H5CAh9APW\n", + "oIX+OuBnldDQHln6vNOWb/R5ANrFArdGc+qu30iifKkSVFnNx6TDS4TwBZO4n4WUVuw38f7PXEyP\n", + "32BoIFXi71RQdSA1TiR5MUy6ewp8NBjaFcOkXbDiIOt/vpbxTREfSLerz9swMoLAIzBmE/QvhIBs\n", + "CN5fin+pAPnoAeJsa6v8//s+13D80QEUhTOg6A+8X/Az4UXQPVevXwzggOQkpcyYQQtievwGQ4vQ\n", + "UwdK67QVjg5Gr481P1r76uu4/M7ZwlN3wkPfQ98T+pszIH/jxqYJCqfnDMSthbmTKASWWRsAjqX4\n", + "7n0Rv8gHCPYN8Q44GtY9aEdox5CCrjl+XiEHAjt4F/v4dGTQJ9D1R47kHWaWF2QHwCfvw7BDuhQT\n", + "7//MxAi/wdBgQgIY80+46Fl4dR3k9nCmV4iic7awI7XqNxtjtnDNZiY3Jh89U3gVJRf+g5L50ZyE\n", + "MlZwlP+jHQX0Ixef3ofYMekE+O2ClESi13/AWpaeVreJ939mYoTfYPAQkVgH0uMBOpaP5cCn8K/n\n", + "oaCHLUdl/J3qFnxv6GzhasxMFSHMnTOFfbj0qUC8+/mRr7qx7cRWGTatbMDUaC68EN7/f1DwE4Xe\n", + "H7K5zJfNCAFZMwn/ci3Z+68DdSfb6c5M9rCQtIpaTLz/Mxdj4zcYPEAk1oHX+S9S/nqfytTH0E45\n", + "49C96lXxrgO8jT1buMJ7J/Z9yBgJWU79r/TXtw8sl3rBohj4dU9/NeBnP/EpjmRDDz+KBgyAvl9r\n", + "n/8T+pCCuYyTJABfAdtzwtiRann15J+ps53rSnUeWC3dLncYG7/B0ES4CoFX4MV9yote7UP3NXBw\n", + "tJXrj8DULHh2Dex/PoYtxIkkO78DzGv8gVArzHPXHyHyJ1j6Z51KyfkzRFJOQGhHiHpZCHttGDxz\n", + "EfinQ6+8U1I2pZi09nmEpnWiaNvv4POXbRO9oIBO1n9/ABwrT6if28Qgrv1B6Uw72zyYjPAbDG6w\n", + "C/0JCB0AkR9Bt0IfeOgKKG+fCj26Qm53+PdyKG5nfTNok1KL4jwRj9pcQt1jhXn+aRbceil880co\n", + "9+ECToQv0pO/mBUIc6Nh4QVwPAj8I+H2XMXeY9A1FzYu7w1HbzmtZEV/dG//rTYVGbdTCA/OCif6\n", + "jQ4QVAIzt8B8iHZAxWD9mY4RfoPBBVfRzgqE2/rDxYNgzQDwKYe+y3zZs3hlhVmkEm3Xdy728skg\n", + "+McYGHgcBh8jes1JnpJE2QnsVQmqwim+Nlt99a21Bm+PzY/mRB+ITiZ851uEsp27h8DGMbCpC3Td\n", + "Aw+u1IPLr+fCXPR6BLsiYEm77bySdxOlRe/Yyn0UPXn4uayuLHv7XLLjZ4g83NrNHnVFEsUfvb7y\n", + "QJdtgHc87R84CgOPwaV7Kr9zNnkwGeE3GFxwivZ/h8BLI2FdNy0AJekwwQ8++AC+Lc5mOo8WFvKu\n", + "TQwq4+o73TfH74XQYtjREXZ0gIOD6QcsBbpIouwBtgM7uGDgVPbfHs3xLCiMsMqr6hLqjiqDtxuz\n", + "hgaed4vfgp2lTCGfu/bA9Cz4+hjcWapXbgcqpmANOaq3aeTzA9v4iScAb6AMLfrj8GHunilk33wm\n", + "mj0kUQToyuniPhDoDuwDdqJDYvwAvAHsuPxPvJmsB2uqcDZ5MBnhNxhccIp2QCnEr4YrdutX/ieA\n", + "xJXgpWAK+USTtGUTjmPu4uo73TfDi+CyPXoDSIXVSUrFSaIEAv1xClHv3E7ExEPHHfDOF7D/Yqs1\n", + "tS83qtTmpDiR+Pc34df7chgdBBTAK4XwRKE+mFCokPXvIOd2KFigRRGAcHZlCuko/t21suTZaYP5\n", + "kfkQfSgE7nXA376E+Tmty+whiRKC/Vzaeu9AAVrYnQK/zPq7u7qYR7FzpUk8sFoTRvgNBhecoj11\n", + "5+n7vCwnuNmQVk5OglJJbsWvNvdNlaAKgZ+tDZG4i3RsHQVi97Sr25KMoRAQVgz/SIZT3pXp3mij\n", + "zUwsXyNIOwbxxwCHzcPoMHnPK9bhukDMIHIeBuhYACMzYOSd8OelEPxT85o9JFG8gd5oMXcV+Ahg\n", + "F5UCnww8B+xUCSq7vnVtViopVqTK+TnbPJiMO6fB4IK7gdlZkJkGByPhZF2FoD7um+5t/Ke7hFaH\n", + "MySEa/pkyCmA1Pq0u6ZyN3XWq3vtLeHoieW9fkPakJvrNxhdM5IoEVT21u3iHgUcRYu7vQe/A9iv\n", + "ElR5Q+o9kzHROQ2GRqIlVuiqDKlc/yUZ3T2sZkPaKohvSLvdPgS9SXvn2oADJX3VRSS94c3m69Fh\n", + "Kuq20Iu1xoBzYNVV4P2pFHS7wKc2RTyjswEj/AZDG6apHlau5a6i66pszr0X3yEdiVwPHXvBT29Z\n", + "ufXEMWtgNZKq9nbn/z2BdNz33g81PDJp28IIv8FgqBXP5gvYv2szSfkWQMdfQ0Rf6OgF3V8+woDM\n", + "/WihP4X73nuaSlCnmuTg2iBm5q7BYKgRz+cLOLEikV57E/T+FoKOQnYUHFsDx6+BPe0OMyAzHtih\n", + "ElRWkx2IoUEY4TcY2hSWcPvnQEQaZA6nLvMFKrFCRKyOh2V/gBO9QXmjp4QdSAOf36sf1Mqma7+h\n", + "MTDCbzA0Aw0xrzQE1xhDYYzultMuHW5ywM4rLeGHmuYLuLQ9BlbAwXEuuVYfg/Q6eSAZWh4j/AZD\n", + "E1NhXvF6KZpy50+uPuYVz3B65LwK0U4D8I3eG4o+u2QY+RsehZX/z5bb/XyBakxDJYCvnhkA2u3U\n", + "iP6ZhBncNRiaEEkU4Z3hKxlw/vkM+QBeWw3Z/ay9laGTmwKnD/6DE/WkridWQOeTMDq4ffHak9n+\n", + "lTmrny9QEfbZLx9KAi2zDkDcMQjdUl+3U0PjYwZ3DYYWwF3s9i1z2QvcBNyIY3tnfrwW5q+BE31t\n", + "3zzdvNKYJiFn6InffwdPj4PB98D9q6HDqtxdMK4Q2kWBv4K8nBpK0Tb9CXMhJBM+eRP91hK6RalF\n", + "Ezxpl6Hl8WrpBhgMZzJOc8pimPSPUMZfPpZJGb/mIylhBXoy0rU8d/G3fPuYi+iDq3ml0qyyeBIs\n", + "Gq//jn1Op9cfZ+iJTgXwXDKsna8Dxa2cUj5wVLsN54wnN3wk+REh3D+8+nqssM/f/AECs+AX14P3\n", + "KTqQPjROJDlWxKO2GVoYpVSr2HRTWr4dZjNbfbbJkKxApfRGhf8Odfs01Nd9UZO8WOzMAzEOmJ0K\n", + "SlVud+yCGIe9LJicDEoRkqFw3K0IyLbyxi2urR26jsnJMD1F/41xDPJj2k3B5NoqVVdDxvXevsX2\n", + "tBlEqRA+d1tPlbZ7Fymun6aCbuiqPvIJVgrUbEiNAUdDzqHZGrZ5op3G1GMwNACnOeWCdMj4m47o\n", + "CfCyLXa7M3SyawC00004llnlVCghR/YyqHMkwUcGUFx08PxYEUe94vzI7P7bpxzIyyzP2TL5U/La\n", + "KfzyobAUOn9cVtL1WBAUe0O3PFhIGqN4nnW0O830ZG97aFnJ+WMWZYUXXneU12eUcvW7Z98CJW0F\n", + "I/wGQwNwmlN8y/XmxDV2uyXydVpNK+TUchzrdrCQYmATQPjt8Po4kYORkH/6YiiWb75vAYx+HlY+\n", + "COWv9eOH7ftyfv39iORPVJmzhhkiKQBfRsFvJ0KuP/TPgoPH10NRYA9JlFuBVPQs2+MqQSln22eI\n", + "pCwqZ3zph7Cmu47O8wUhrCb2fJEZKc3ppmpoGEb4DYYGUFv45epwNyAMMfNgTtQg9kcvJA0FfDII\n", + "xu+DBYVE3hNA5Iva4u6yGEpoAN7FMPNayI8EZQ3dHe66VyVUij5UPqhu2qS3XH9IjYAZHUuKj406\n", + "uRK4ArgbHXJBSaKkctwvn12RvaLOCe7649GT9D+u33C+IIT7cZDFwnCsZR7h9nNEYmcb8W/dGHdO\n", + "g6GB1Dc4WjXr8e5aCfdvIYbL2f/2V+RF5PvBjddBSh849xAcOgwX+sGCT7RXhgOSFxPzPPR4i46h\n", + "HfAugMO/BS6xSj3dXdRd3TfiX5BC0F8yVFaiM80KstaBlE63kt//IdpN6OLdYTkhHdZSEnGKdsVQ\n", + "fDyE7KyZcHwAbL8Kjg+0vj1xvVJLRjb8zBrqggnSZjC0IHVxxZREiThvEck3tWfUT5Hw9DfQ94Te\n", + "54DkJKXiXGPgF/lo8X9sAOyP0auBTUmFJXsC96alziij5N9RlTU8BkzCn5cLziUpLYKcDNc1cuu3\n", + "ToDlxy9l4FVGSNlXDJR5BIZ+f2Jdh4EhRRF3+tBhJ2y7DtIvsL51XZZSH3ZopNNqqAUj/AZDC3H6\n", + "AKuC9jfs5aIlbzIyuxwYZm0R7TMpv2U/YcMy4aodEGGNBsyA5YuUmuCuV+5c+vxiYFsn+KI/PDIo\n", + "tKSsC77suxh2ToV1vwIEPy4v+4jV3lPIB2CWD2kp3Xli7yzWAmHW1s72f/WfT/pH4+Pnh+9JWPG4\n", + "3rqvgY63H2Frr04UXyh6Fd+JVM7knZql1OdG+JsJM4HLYGgxrAHW8N0w9VcQ+RMgfcguvwd4HXgP\n", + "eBhIG/MKSfNqWMzbdem/ExASAl3/BN1WAEuOwq6jFHlvHelVVvQRRC2BLhvRw60wllLviB75dLke\n", + "cgKgXIhSJbyJjoGfY9tybf8fRS9fWDV9wcgX8J03np4rIeoreLgTbOgNy0eFU/wfm9g8Zv1NBnJ3\n", + "N+KJNTQBpsdvMHjA6WadwG7w0VD88qDPcsgcBnndgJnLXWe4erJaVqyIIxj+OQSi3gCvv4+FJw6M\n", + "pCB97Wl5JzGKT3zWkeMP7Yq1i+lM622iTseWKOHApcBETslVnAroSOpMb3ZfAbsvh5N3FhDw7yBi\n", + "FkJROGyZYX3zeqA4E1LN4G4zYnr8BkMzUGHWkZejK2PXXFUAwKlQbXap4PTgZ54u5h0J3d8Ar9eG\n", + "w7zz4YUN2/kjM0ljYUUef24ovo/t/gGllXMKAA5BcJxIst2LyFmfJIovMAbt0TMRGAJ8ByzBT83j\n", + "mb69UYfvQz4KJOYvwQw93J/evSFtIqy5z9bCkiwj+mcGRvgNhnrTMx6/v0dzw+WwPAH2TgAeDILb\n", + "C2BBUGW+2Wmw361bpyW6dRbInhA/DIJKveB/A2HJ2zCgMJ/OJHE/o+hBMAGcZC87939CvkyxvU1c\n", + "A5nR0H0BjARQwPRODAq9WZLy+9MdmIA283yFHk74XiWoYuf3BSmFrRuAW4BMlkVn8MnmMApdzfiF\n", + "a4zonxkYU4/BUE8k6KpvueHYRRwdAp+/Uuk3z8RN4HPQk8XSa2OGSMoAGP+0m31j+kHp5RBzBFbn\n", + "szv3BG/FbuSSsBI4ac3WXQLDF0fDx4NhSRSUekHxHr/iYwejdnTZdjB5WF7uuS5B5n4AZgC3AX2B\n", + "/wBvqgS12X2o5uojfBqalhbx6hGRycA/AW/gNaXUn93kmQfEAQXAbUqpn9zkMcJvaPVIorTnSMhe\n", + "9t0SRtILNtGHpgyzHCeS/AhM+hL4oy39LuBqHwiPhM2dIaE3ezPOJRWICdlBeMx3nOqWSeCQUvwK\n", + "BkKvcJiYBoOPwiWMZz0PMZXrS94j37dM4Ot+cOdI8vYNwAtvFrM2fDOLR11AeZi/3UVVi3+vWkJQ\n", + "GJoDj7SzgcGBvNGviH0AX2ADMNgljwNIsv4/H1jVWIGGzGa25tyYSwRzWcev/D+BO2oNutaYWww4\n", + "ZkPqclCPg0oAdRWUv2hrxB2wyxkwLQYcdwhp9mBsj4Jabvs8MjRGjWSiUqDWdkN1/w1qxJ2o50ej\n", + "RgSFHoMrfoZZJ6se5+zUpjxOs3lwX7ZAkLbRwC6l1F7ryfM+cBWwzZZnGvCm1brVItJeRLoopQ43\n", + "sG6DoclxhlbwCSE0aBZDy4tZUtSteDqsiqs96Frj4RwQPlh1QHjVKRiT4maAuCfEv6bolxoBPXIh\n", + "sFS/KTyB9raf4d2N7T5zGMHHAAw8Bov/A0OP6Pr+y/AOMLoDAQ/CBZb/fmkA9Vuf19Baaajwd0f7\n", + "Bjs5gO7V15anB2CE39Cqcbpd/jGY6MtugQe2wOFvOHcVxG2uU9C1xqU+A8LOqKHPjYH/nAOTd8H0\n", + "LbBhl5SOKpnos73sPvKzp3DSKi70VKXoA5z0L4bBG+DywbDtWvAqwSqSmtbnNZwZNFT46zpA4Gp/\n", + "cvs9EZlr+5iilErxoE0GQ6PQE+Jf8CZ6+K0wfSskpICcIWGIncHYXkjS7f54MLw8EpZdraRs77Z8\n", + "NhaEkHqS7SXx3MD3JTcjvvMYRDHBbKeUnNGbYIg/vPsFZIxyKd39+ryG5kFEJqA9sTymocJ/EOhp\n", + "+9wT3aOvKU8PK+00lFJzG9geg6HRCIUA/zJ462MYkVmZHmKLtd/UeLoUoz1qaKcCuHM9rFlPWq+e\n", + "PL7nwuyxXDDnRq7OD88/EHbs41Sf1I/WXzH81KkPKl1Rf7wdvh0GfALYhb/SRbUxl4k01B2rQ5zi\n", + "/CwiCfUto6HCvw7oLyJ9gAxgJnCDS55PgXuB90VkDHDC2PcNZwLOXrNd9OH0WPtNhXu3yTlRIrHU\n", + "JrDVTRLbvV8lAe8D90uidKBf1tXFvmHPMn5JELuv02vqngqBkwvQIwKTgKsLwCsNig46xzIa0jZD\n", + "y9MY7pxxVLpzvq6UekZE7gJQSr1i5XkBHWPqJDBLKfWjm3KUMu6chlaEJ6EVGpOKyJgAnbbC0SHW\n", + "Hs/dRmNFHN3gD6HQtxg4EsrBtUGX9SZ3UShRS2DzTCots9Nz4ORK+8C1JEoI0JdPYv+N/5zhtN8D\n", + "B8bawjaMWwfBx81bQPPRIiEblFKLgcUuaa+4fL63ofUYDM2Np6EVGo/QAEIzYPIDELkBXt4AJUF4\n", + "OrgaK+IYDa8tgK7OtBu8Cd+Wn6PyCyNg8/VV8of5pHt7X7Y6P2sst0mizEVP5AoG9jLsUBcO79AL\n", + "yGf3s76xAugfA6/b2mfeAlojZuauwdAKkUTxJiVqE6NyBrP+LljxGJQ69dSzHr8zzn9WIGzsAnvC\n", + "YU97eLsohP1bHKjcypg/UczgORbzfmD+8a+G8frhiXwM7AUOqwSlKt5GfAoh5DCEHIKQv0HIZfr/\n", + "HVdC5ogGtddQN0yQNoPhLEASZRjwCqP2lvHWtP0cfrpX5d7q4//UhtPF8/ue8H8XQt9svQjMeQX5\n", + "RIYkcSh3FH0Ixp+T3BS4na7t87kxmA5rIe4wnAAigUhJlEge8YoCv3K8vbzIj9RLPuanl5PfwYv8\n", + "LlDmZ6vZuH+2NozwGwytBEmUUOAp4EbgkcF/KzscWf7ZU960C8nHV7bRPS2H8gSlNie5W7O3NhOU\n", + "c7D6yp16c/IEMJR8vFlHAhD2CGwsgch8veWV0hm9OMseYCVwCP/yQ7zUZyiHB9wOodYktnad4eXh\n", + "p9ds3D9bG0b4DYZWgCTK1cA84BsgNmYuo/TAcmk05AEwh6z2K6l2zV7b4uvuSYd5t8M5dhv/o8Ah\n", + "dCS2Jehh3exnwdtmAXbATweV+v1pBSawHfig4hgk1gFz3ARv8+wNxdB0GBu/wdCCSKL0Ap4HBgK/\n", + "Ugl60qLTHn+gHfiXQicd7R8HJCuQxTBpfxh4KR2SwbkvSakabemWV89TITCwBIK6gNcv0WEcroHM\n", + "cMD+YKivF5MJ3tb8GBu/wXCGIIniA9wPPAI8B8ywx8B32uOTo+HJS+DVz2DqzqqTx5ZEwSOXQfsi\n", + "mLAXMg/TWxKlu0pQbidIQtWwD7EijjK47wUIfNbyWAIa5MWkWiCUhaH+mB6/wdAM2G3ye6Lw//EX\n", + "dC4PZDdwt0pQqa75nT1+gBW94dardTjl3Uv5yqeIcue+coEtnSClD8wdzOGsvvgAWeiZncuA5SpB\n", + "ZTTbgRqanRaJx99YGOE3nK04bfJ/9Sf60cvgo8HQ/xsOH9/A7VvKq19j127Hz/WHYVPJ2zOQ/O6f\n", + "8rfJm/mVu4llW+aSDMQCl6DjuYxHL6S+DP0wWK4SVKZrfYYzFyP8BkMrJE4k+Qth0rC7YOwBeGYp\n", + "hBfVbpOPFXH0cjG7bJmLP/BSxA+kjF5CuC/eXY8S0nUbAzNziMhwnSkrieIFnIN+CExAm/MPox8C\n", + "KegHwaEmO3hDk2OE32BohcwQSVkE47MDtOBXpMPyRUpNqG95kiiRwGsUeg3k31f5cfgjm5//nF2w\n", + "8v7qBlQlUbypfBBcAlwMZPofYXfUGnr03cnJslzy0mHeFmIwQdhaP0b4DYZWiN1eb6cuXjjVIYki\n", + "fN1/E2OzYlj+JKy517YMZN1nykqieHdZwt09fHiya3c6ftsbuufCiXTfkxl7x5wi7cNwCjpZuWt+\n", + "qBhaBk+006v2LAaDoSFYIZJ32dNmQ5rTi8YTVIJSfHveMV5bBbHvwZD/2vbWfaasSlBlw35gyroV\n", + "dBxzAK7aBuP2QXlel2CGtgsnPhruGg5ShvbP73Wfp202tB6MO6fB0MQ0VbA3H46FlmZFwxvfuiz6\n", + "7n6mbHWzfZ2uo5N3QZeusCsCSjdHQcrn4FUKHXaC8taFRKghkih3AGnoh1mGSlDlrnWZWP2tGyP8\n", + "BkMzUJ9lE+tCrIhjPKGRe5lJWnllcDXh1kzlZqZsTbN9e9rWHXCuPfATJ1kCUO5jCwcNeJ0sRg8Q\n", + "zwKigPaSKHvQDwK9rYloT6dL7iDr3d6VMXtMlM7WhLHxGwxnIM5xg08J4V8MoohgAjhJBqnrflYn\n", + "XNdK5FLxXf8NpcPLBQ6GQk/bbN/98LzrQ+EyQjOXcS2Kf3etLGV2GqyKd/EaCgH6oR8CejsQNp2g\n", + "Dh1odwBW/T9Y+qyV20TpbArMzF2DoY3gNM8k3pnPnvB1dM3TAdWOltJLEuWv6BA8mcAhPusafYm0\n", + "H4I6xpZOcMlt8MAqeOh7CCkj0J0p6jB5zyvWAY4awy+oBJUP/GxtAIjMGAyLxuNVAr4FttwmSmdr\n", + "wQi/wXAG4oy0uXY+ZAXCoRDIDIH4zhw6NIAjQDdgBBDJxdmj8o6XBLAXhh6B9a/AA5Nh6N0Q/A1B\n", + "UKMpygPTTJ52Wi33heIwW7qJ0tlaMKYeg+EMw7l8YgQMjobAiWije3UB1URmpIRw63gH8Sxkd0X6\n", + "xQP8y7+fWlaqymQ14SU31BTjpz64X4/3dDORoXEwfvwGw1mOu+UTZ8GpNPg5CxLceQo5V8sK4Qti\n", + "+A2d2McpgjhKH3b6PsbJS+ZmMXqLDz4qEXieuTFXNNQjx0TpbD6M8BsMZzkTRdYvgeGHg2F/GBT6\n", + "QpEPPBhE2ubreBwdvdO+BZAZMIRDPS8NOdQrzLF5BQtPllSUN5MokniO/K5/WsFdP5yiyCuahZN8\n", + "2JPUo7JWM3GrNWOE32A4y7lOJOtDCJ8/HF4ZCQGlEFgCG0q91THvjscoKy8hPHcDnYt3oMcBCoFC\n", + "UkP6nf9p2c2r8gpD94XB1/3g9p90maOYxDraLWfuB5fw+ZCfGJdzLmlXwFd/oXLWrvHIaa0Yrx6D\n", + "4SzHGbB/zo96czKKy+UYyZZKzymAlS+69tBniAwBxgeWQvxEeHv7eajCMNIoBw4FqwSlZO6ME/z8\n", + "OkyYC1N/DYucM4KNR87ZhAnZYDCcQeTC7sdc0maEebPdsR1CnNGW3YdWqPAEOhmC1/Y+pIycznJS\n", + "yGYJEN1d2+XzijgVCkv+Bh8stH3beOScTRjhNxjOILLgyW2Q8QQwF5hEOItzPiZ/07twsost5+k9\n", + "dGfMoHkMIm/V/2DUi+B9ytq7oKt+WKTP0zZ9KsM0mHVzzzqMqcdgOIOwJlvNKbImW61mYEw+V3Yk\n", + "3TXn6T1050St/bR/m8PnRPD1MzoWT0VYhZBApTYnicRS28Qtw5mNGdw1GM5gPPGZd7p3nr7HDOCe\n", + "iZjBXYOhjeFZDz19HsyJOv1hYcw5bQXT4zcY2iBmgtXZg/HjNxgMFVQXf7+l22VoXIypx2AwADXH\n", + "35H//1wAAB1KSURBVDfibzDunAbDWUhPiJ8P0ct7w4reOm0+RPcCs3SiwQi/wXA24ozX/1NXWBRT\n", + "mR6i4/cY2jhG+A2GsxDnLN2Bx2BHh8r0fB27x9DGMcJvMJyFOGfpDjwOOzrqtNmQth+My6bBDO4a\n", + "DC1FU3rdOGfp3p3DfQeDmXiFP19nFvNPM7BrAOPOaTC0CNV43exaCffXR5zr8vCQxP/f3pnHV1Vd\n", + "e/y7khBCSBhCFIiACEGGBJBRcIAgUJKgFaqAvraOYH1thbY+B9SaXH1aa/taUfuq8tQ69Ck4WwlB\n", + "aQ1aBWtEAXkgEASBIPMUSCAJ6/1xziWXmOFmuvcmd30/n/25556zzzm/M62zz95rry1rWNL5SZYP\n", + "ubQhg6sYoYm5czYA83k2mhrfe6w7pMyHxPd6wVPDYOZKeGIzyZcpt6SK4M+96I/LpkhqJj/q1I2i\n", + "c/4LhkWDd6DGWb1FUjHjH56Y4cd8no2mp/I9lu3OH7kDChLg7vEw6/vQei1Dh37KnxYcoKd33eru\n", + "Ra/L5qrOTj1+SRQMjyL5/fb8XjwyiI86DSQ2I4PCHh1IiAayIOI2OAlOuIbMW6jXYOpGc8cad6l4\n", + "gDZ0gg97OPPM59loTLz32M44x0CXufPbH4eb8yH/KXj7JTgeTbu/z6Ln2OvgxYFwPLL6e9HrsvlJ\n", + "N3hlACztBZ8lQWl72gEd+bz/+Rx7oSP7+kLiV85KJ38HvOduwQZXCVfM8FPxABXGwxUznE9vMJ9n\n", + "o/Hw3mNPD4WkW2HdSPhVpe/tx7+loN87bNz2B4g7AddNhXZz4ZJrYH8KSeBU3Yhk5IpMz3uXUSmL\n", + "iOOmz+CVV+D5N+Cpv0H7N9rvJDt9MHu7OP48e/tBzAGfPXnj7NvgKuGKNe4CGSK5i2ESwIZO8P2r\n", + "YfxmKFjCktwyTQ+GJqNl4XuPbW8HL6XCcx2g7VpOdjzECY5y/Fgpm2JA3oWhAAdi4IVBzstidWeg\n", + "JOIEHw4vI39pLCfiAYjj6tJb+Xur5ZzNcdqyihPHD3LGUXgrAe4B/rMKNb8GdtYYutloPliQtnpS\n", + "uf71UGvoP4Nju8+koDyO8Zqle4Khy2g5VNWOdAOcWNsZ7TWI1h8MhC5FoB9waNBX6F+UDt5818PO\n", + "j9vwkw39U35Lnz796ZkH/70WjiQBIJGZquU5Fc9Oq9kwZDu02wFLxwMP+ii5oRg2rYX9WWb0WwZm\n", + "+BtAqkhmD3dUoyIo3tKKP627mwuBq4ApmqWrgqXNaBmkimQmwX0JMKAPtJmI418zF0iNhzPOgD8O\n", + "ghVRMOoj6HkIOhyDr6BwBR2f2smY/4A344jdC8cSKzbcbSJc9i0s+SNsnuDMa38NtJoLe3cDS4H1\n", + "h+Docgu/3PIww98EiEeuBh4FbtYsfS3YeozmjbfKZ975sLkjdD8M3Q/Bg7GweTyMfh7e2APPDHGq\n", + "eDZ3hMu+grxViScKC8ZFw8IqtnoPnHWZ8wVwuLs7L5sK3yGw0bVaLvWxnda4WwuapS8B6cAfxSP3\n", + "iUfsnBn1xtvIO3gXnH3IcSh4dQDsGwxxpVAaBW1L4aJv4Nx9cNZhJ8haYfqxaKb8C9r85LTtteHH\n", + "wPdgx/k+Rh+g3Gf6+p02upbhi5X4/UQ80hl4DdgDXKNZeiTIkoxmiG8jry+/Bu4HLodjb0Gs77Ky\n", + "CGjfejzH2j4GSb+n3ertDOE4MRxlFFt5kXEUsMBnjdnAMaAbzgtgWb7qByOa8LCMIGIl/iZEs3QX\n", + "MB7YCywXj/QOsiSjGeINnuY773o49gmsyYTcAni48vJrTrY+VlLcG/b2h9VPc5LZdGY7ueSTzR7m\n", + "kUPnqBFEtJuoJE2CqW/BWTfhVPXcD3Q5GrgjNJoD9S7xi0gCsAA4G9gCTFfVg1Xk2wIcxil6lKrq\n", + "yGq2F9Ilfi/iEQF+CtwL/Jtm6d+DLMloZlR2JPgGHvPtlVt5+Rd0XLGTtJugfxI8AEAci+jPzONd\n", + "2LOhjPIdX8fw5HoZfwfFS0d9Z4ddLyzkJx//HvgM+EKz9LDvYmf83e6zLY5P8ySgjbsi8jCwV1Uf\n", + "FpE7gI6qemcV+b4Ghqnq/lq21ywMvxfxyDjgJRxfucc0K0TqzIwWiWOcEzzQrhe0Bo58DYX3+hpo\n", + "J8/oeU44BpfI67cxOuc1JuxuBQwDBgE7gJXASj7uFMk/02dy7MVeFXubtQmWzzHj3zwItOFfD4xV\n", + "1V0i0gXIU9V+VeT7Ghiuqvtq2V6zMvwA4pFzgLeAT4GfapYeD7IkI8xxjH+PW5xwDEXFld03xSNR\n", + "QF+cTmJD2Rl/LQl05FgnWD/FcQkFzAuo+RBow39AVTu60wLs9/6vlG8zcAinqudJVZ1fzfaaneEH\n", + "EI/EAc8BXYEfkJ0y1D6bw5fmFuVVZHoe8vJYEjZB7F7YdoG7ZPoy1YVpwdRm+Eejh2UWkfeALlUs\n", + "utv3j6qqiFT3BrlQVXeKyBnAeyKyXlU/rGZ/2T5/81Q1ryZ9oYBmaZF4ZBpwD6Wymu69Stj2to9f\n", + "nYW/DRe8vXOfgmQViNDmEOX1SAkaAfvOddIpLI5PqCIiaUBagzaiqvVKwHqgizvdFVjvxzpZwK3V\n", + "LNP6agmVxNCUldyWqAx8UUF9UsbiYGuz1PQpHXL3xKKXX4U+PaTiBsiAkL3+kJIJMzeefr/euAlS\n", + "MoOtzZK/1xCt6zoNicf/NnAt8Fv3983KGUQkFohU1SMi0hZnFAhPA/YZ2qwccJjtL8EVP4Svx0OR\n", + "92PJwt+GA4f60+W8DLh6DfxwdcX8UI7yqvpljkgqTmz+qtsFjJZHQwz/Q8BCEbkR150TQESSgPmq\n", + "Ohmnmuh1pwmAKOCvqvpugxSHNEdK2D0QnvgC1LeLhH02t2TEI9HAf7a6lH6LXoOJm09fXgQhff1d\n", + "I2+GPoyot+FXxz1zQhXzC4HJ7vRm4Lx6q2t2bHsUZvVGfdzpmFlg3eVbFqf5vXfZHsG1EV1pc3Ld\n", + "WQu4buE33D/RJwLnTCj4Buz6GyGFhWxoZGpzpzOaNxW+8k8lM+QZmHAn/LP3HlYcuU5Prs2prXOW\n", + "YTQ2Fp3TMJoYkYxcWDyJibdDci68+hLsScH83o1g0ejunIYRigTXVz4+BoBP/x3evw/KYtz51oBv\n", + "NB/M8BvNCq+v/BNCcoSCEGhf+SMlABw8p9J8a8A3mg8WndNoFngHGf+GCS9+w/Dkmf3iyBrnLJsP\n", + "yT3glsAo2faoE8vGF2vAN5oXVuI3Qh7f4GNHgHeBNhtmMHFDDh9QxBgC5yvfUL93i4RphAJm+I1m\n", + "QPfZMD+ZxHWgkbCvD8XlCzjOCJaQDwTWV76+fu9VRs+0kB5GEDDDbzQZjdcI6zao9vgI0rKcBtWN\n", + "kynOjeUBhYlQInDmdJG8UA6MFsWZ95cxP5n+r8M3F8LRzjgvgcxbsA5URgAJG8Pf3KImNne8jbDz\n", + "IbkkCmLKGtII6zaorpwJK2+EzmsgKZ82upwPgO4Q8YwTZhgIzcBoqSKZCYzrv7v9VrhsFjyxymep\n", + "eQQZgSUsGne9RmgxTFoIYxfDpNEwL1UkM9jaWirdYfZ8SN7QCQb8DFZ1dhphk+C+DJHc6SJ5GSK5\n", + "/l0D3wZVgV2D6P15LrewnneBZyB6V1vw9kgJbGOvf3SH2edxpA0X/wY+mQOHu/ksNY8gI7CEheH3\n", + "GqH5Q+HTJGdeKBqHlkQ8xACcuw9+sxQmXANv9oMEGJBTxxewU/+9fE5kwqhDZ8glpZMYwTwWM5ki\n", + "NkHJSYGLboD8pIp1Qi0wWjzEzGY95yzZAx/ddmp+G64uNo8gI9CERVVPPMT87VzIToOPn66YH2rG\n", + "oSVxBEq80zPWQq8DMPUq6JNIm7HJ4MmDcVucF3Cm8wKuuVome+3xctjb6UF+FXGCf38O2vwJisvg\n", + "zHfOZWjHEhheWJE91AKjHYGSyRRB6bs8xhhKaEsMRylk49rVejBkqqSM8CAsSvxbehJ94+XwxgI4\n", + "+1DF/FAzDi2JbfDoLDjl7z6iEC6cT0nhAGhdDtOmQa7r21LTC1gkNVMi0nPZE/8m7wwoWn8ipSxH\n", + "NWOhalqOakYh/HrWRRT/crnTmQtCMzCa93xMpohc8sljGd3ILzjJoaxgazPCjxZd4k8VyUxI4LZV\n", + "1zP8gkUcH7mD1t5loWgcWhJfquakipDpE7Cs6AhnfP4sw66bAl2Owo+mwtNvQ9FXVb+AT7k/plyS\n", + "zIn9kP/JYLhpnq/749psdkopR59bxwdvQExDAqM1pY99VefDArgZQSPYo8c0ZBSZmlIKZF7Tmk2D\n", + "b0YfvgBdBno5HJ0KqzNgcQrYCEMBTimQORM2vi/oxWlou1+gqedx8qyBLKz6nkjPRcqU2b2Vnu9X\n", + "OaIZ2TxPNrc3VFvVI1HN3GgjUVkK9VQf29niSvzeUltcxCUjd13xWcfuB44yaVMZKQJjlNhM2JGj\n", + "muGbN5x7UQbSzdUt9Y4oV25flkfsi/vhV5OQvv/gii4Xy399+6Heevoa8TFoJLywBA709pnvuD+K\n", + "R5KAy4A5DVfndhKTcog6DqWxmI+90VJpUYbfN1Z6UfotFEVGcvzt9mSMzeXIoCKGFcLW/aSIR6by\n", + "Qo+28L2scO5F6etr753X1D7w3WH0MxD793PAkwae9+HBsUS02shs8chGzdInKnK7/vunGX3wcX/8\n", + "GfCiZumBhitzO4ldcg+0Pgw5f3Lnm4+90fJoYY27bqnt/EehZx4sfIUjRa8wcFE/tjwCd/4Tysso\n", + "AWYxrfAZfpmbzPQrYeTj7vrzk51BVMKD7jD78UiSb5sIRdHOvLq4uaaKZNbVJ9/r5jn+a3gkFx66\n", + "GC7eCgd7cgL4nXjkPypyVxsQbYW0nvguxa1u488XDHZe+PXDewwJbBtEygJIfRnyfIeFNh97o+XR\n", + "okr8p0pt+/vA/74Dx9sDUEJbEorhlQIK4gv4heZojsi0PBJ+M5azPoG2u322ET4lvHiIiS6HfbEw\n", + "cWok8QvP44TGsYbj54ukZtb05VPfrwVfN89LN8CYrXDnBChpQySwDrhfPJKgWXpXNQHRVsDoHzFo\n", + "WDJb28KuNy+GWV3r86XmewyPdlnFLzOv5eQLK+BYopvDom4aLZRgN0w0pIHiu9tIzz29cc5JnRi1\n", + "r3KDbnV5fRsOGzulQGY65E6DvHTIbeoG5tr2lw65CvpGZFuNuT5RGT/X74ZN77oKWhhXcQIzoMbz\n", + "523g9T3pN8KmxEu4jWy+IpsNZFPK5A6fQvoeuPKg85uSdeq6Sbny83OVs/MadN28x7CrLXr2L9A7\n", + "B8ToJIZrPBP2QcZia9i11BxSfWxn0EU3RPx3t1GVZ8aNm6p6gOuStzFSVQZvJmxsKuPvz/68eb7H\n", + "cCV2tzLnHOWcpX4Z02mQp6Db49FOt6PHopyVpkGeP9oyYPE0yPN9IZNNDNk8wD2UcFeU0u91hWUK\n", + "dytcdRLGb4SJq5Fypc8ihZM+WqfVut/qjuHV/ui9aRXnyZ9jsGQpVFLYG35nOymZTmltWl5tpba6\n", + "5G1oGkfUZwr6bi/0kfNRf0vI1etOz3V0p+dWpdtbmi0T9Nu21e8vBTKdEq4q8TsUKffLmPqW+DN+\n", + "iP5lcP2P5zvH13X0fn7WV5kbrVw0ppKBv/6o8zLQSsm5frWdl+qOwTc1xjFYshSoZIY/RBOkZI7q\n", + "mFA8ZQbaazb69rlofUuXNfmbk42QTTLZXN3zcrZdfD0aNxedMqPm/dWn2sv3i+KtvuioG50qm8b4\n", + "goErDxJRqiRNUW4aqkz9sRJV7KPr8qNVfKllwcyNRB3zu7qqumon6+NhqTml+tjOFta4G3qIR9py\n", + "affH8gccibnvY3jpNSdEsZe6h41wPZdQaL8Nkj6FpMRkem1/HogEDgP5lFB87zIYVggdSyrWrnp/\n", + "2x6FWb1Pd22tuWHTtydq7EZiV36fkVvO5w87VzSGG2hRKSejoHAwPPtXmHItDHkGPv2puzyiADJ3\n", + "QFyb9qxvO5R1EasYPmd/15s7MqMfPPshHOpBbX741pvWCFfM8DcR4hEBZgC/o11pdPQT8/mi/OfE\n", + "lBWdynM1bYq/obiOXiOu59J5f4EJc2HHCCgcDsv7FXLlJxM1S3eB47GyAOZN8PG6qS5MRX2HE3QN\n", + "ZI57vNnfZpBSt2Opjm2Pw6y7oXMrSmPh1QWVlpfsUM3J8PXKGZhcxP6pGfC3J12j76VmLy3fYzCM\n", + "cEHcT4WgIyKqqlJ7ztBHPHIe8CgQB8yOyh43ryxq0dC4KYn0e30kbU8qR4lhI4X5B3X1iDptWzJy\n", + "YfEkpBw0gorQZJm5qjkZvnlTRTJ7BKg0Kx7pBqwGumuWHm3w9iQ1CxJ/Cb3j4Wmf/iYzC2DFbNUv\n", + "czJEchfDpDf7wYxLozjx8gewfXSlLX33vBhGS6I+ttNK/I2IeCQRuB/4AfBr4OmUbCZ1Ib/Ll+eO\n", + "Z1fsaPJPLnXycu1OZXtW3ffiVsto7dUygSzNapZuF498CFwFPF1b/lq3p196AI/TOavqLxFvZ7AL\n", + "tsFjz0bz8L5HKMDX8JsfvmFUhZX4GwHxSBRwM3Av8DKQ5Q0j4C2VXjg9kkMbu5H4eU9vHPb81Xqw\n", + "TqX9U/uT1Eynh7H/1TKBQDySCXg0S+t1XHXFe269/xcRx2P042M67D9Cq3+FynkxjKbESvxNTFVB\n", + "3cheW4xTrbMHGK9ZusZ3nXiIKY2AHUnlfP72VjqyFYDpUO/qENeYhaJBWwL8t3hkqGbpyqbemRvj\n", + "vre39/BkiniD/IIeMNsaaA2jeqzE7ycVAeDcKpb2WyFzTBHnbDtGtP4UeF2zvnsyvaXScoFIn6UZ\n", + "sDce1ra0gd/lhrbPcTT+EhaOKQhExNNAtmMYRihSL9sZbB/UhviiBlaf6+seVayM9Si3Jyhjs5Xo\n", + "iUtqWq8aX/ETywLUgzew5yglk3ZXbeaOjkr0Yb986S1ZstSwVB/b2cKiczYlrhslOEHdnlwJy7Lg\n", + "RIfWNazEl6o5y2FOJuROh2UZsPcaaBXRA97u6+RpOQO/d5/N4ZfO4etxMOiv7rz5yZB0X1BlGYZx\n", + "GlbH7zdubPiyGMh53Gd+7WF7fb1rpovkjYGxn5bBrMtg5A7oUnT6uLPNdYCYSFollQO8fx9opM+S\n", + "hIG1Rfs0DCNwWInfb6qNDV8nd0FvWOIRhTBrJdx0GSgVPWor2hIWT4KFY53f0fMaEnM+UMSxpysA\n", + "e1Jgbz+fJX2iw2mcA8MIdczw+4lTWl0+BzJzYfoy59fpSFSX7bieKJsA7l0GW9vDRcPZXdGj1g3J\n", + "EH3EaUCWkzSXAWL6sm5nDNdWmnsXMJFwGufAMEIdq+qpA43hRnlafJhy2rTJIWr5NaTqpbhuoG5b\n", + "QtfP4cqrnGEA9/aDI4VDxCNzcQYr+T9gs2ZpWXX78SVQ4+omcKiwP2sGfs6vccIGlQPpwBjgIRvJ\n", + "yjBCBHPnDAHEI/cAFwPpZKcvdqp3XGIOQuJ6OPu6NUz8agnQHxgAdAUKcF4C63x+N2iWngrLVs1I\n", + "WZuWw5zGNv6pIpldiJ+/hYykAiri6zi9lD+baXX8htH41Md2muEPAdyev8uB/yE7Zdtp/QUA3/g0\n", + "PuvEAufivAT6U/FC6AVsw30Z9F1C5vPfMLD/Hog/UbHFTMjNUW30GDapIpkRtPcU0r/XCeIopvzr\n", + "Mnbfa0bfMJoGM/zNGPHIAMpkOU9e8AV7YjtCZFdosxNKdtQl9IB4pBXQG/eF0HUDs7vEc+ZXnWDl\n", + "k9B3n5NvOixbqJrWVMdjGEZgsJANzZnslJ6MaX2CyVFjeC7Xjbw56yAsr1O8Gc3SUmC9m8gQuXgx\n", + "TDpZ6bao+zgAhmG0FMyrJ2ToPpsP/5VIRBmM9PYTaLg3j9eLKEIhwv24qy4uv2EY4YGV+EOG+Bg0\n", + "Et58FkbN85nfMDdIG2XKMIzKmOEPGdyewfv71LlncG3YKFOGYfhiVT0hQ+P0DDYMw6gN8+oJIUJ1\n", + "gBXDMEIXc+c0DMMIM+pjO+td1SMi00RkrYiUi8jQGvKli8h6EdkoInfUd3+GYRhG49CQOv41wFTg\n", + "g+oyiEgk8DhOwJYBwNUi0r8B+ww6IpIWbA210Rw0gulsbExn49JcdNaHeht+VV2vqhtqyTYS2KSq\n", + "W1S1FGcg8svru88QIS3YAvwgLdgC/CQt2AL8JC3YAvwkLdgC/CQt2AL8JC3YApqKpvbqOQsnboyX\n", + "7e48wzAMI0jU6McvIu8BXapYdJeq/s2P7YdGy7FhGIZxigZ79YjI+8CtqrqyimWjgGxVTXf/zwVO\n", + "qupvq8hrLwnDMIx6EKwgbdXtNB/oIyI9gUJgBnB1VRnNldMwDCMwNMSdc6qIbANGAYtEZLE7P0lE\n", + "FgGoahnwc2AJzkAhC1R1XcNlG4ZhGPUlZDpwGYZhGIEhaLF6RCRBRN4TkQ0i8q6IdKgiT3cRed/t\n", + "KPaliMwOkLZaO52JyKPu8lUiMiQQuqrQUKNOEfmhq2+1iHwkIoNCUadPvhEiUiYiPwikPp/9+3Pd\n", + "00Tkc/d+zAuwRK+G2q57oojkisgXrs7rgqDxGRHZJSJrasgTCs9QjTpD4Rny51y6+fx/flQ1KAl4\n", + "GLjdnb4DeKiKPF2A89zpOOAroH8T64oENgE9gVbAF5X3CWQCOe70+cCKIJw/f3SOBtq70+mhqtMn\n", + "3z+Ad4ArQlEn0AFYC3Rz/yeGqM5s4DdejcA+ICrAOi8GhgBrqlke9GfIT52h8AzVqNHnvvD7+Qlm\n", + "dM7vA8+5088BUypnUNVvVfULd7oIZxzZpCbW5U+ns1PaVfUToIOIdG5iXZWpVaeqLlfVQ+7fT4Bu\n", + "AdYI/nfiuwV4FdgTSHE++KPz34DXVHU7gKruDbBG8E/nTqCdO90O2KdOe1vAUNUPgQM1ZAmFZ6hW\n", + "naHwDPlxLqGOz08wDX9nVd3lTu8CarzormfQEJyT35T40+msqjyBviHq2jnuRoITk79WnSJyFo7x\n", + "+rM7KxgNT/6czz5Aglv9mC8iPw6Yugr80TkfSBGRQmAVMCdA2upCKDxDdSVYz1CN1Of5adKBWGro\n", + "AHa37x9V1Zr8+EUkDudtNsct+Tcl/hqdyu6ngTZWfu9PRMYBNwAXNp2cavFH5yPAne59IFTvHtyU\n", + "+KOzFTAUGA/EAstFZIWqbmxSZafjj867gC9UNU1EegPvichgVT3SxNrqSrCfIb8J8jNUG3V+fprU\n", + "8KvqxOqWuY0VXVT1WxHpCuyuJl8r4DXgRVV9s4mk+rID6O7zvztOaaSmPN3ceYHEH524jVHzgXRV\n", + "re1zsSnwR+cw4GXnniURyBCRUlV9OzASAf90bgP2qmoxUCwiHwCDgUAafn90XgA8AKCqBSLyNdAX\n", + "p19NqBAKz5BfhMAzVBt1f36C0aDiNkY8DNzhTt9J1Y27AjwP/DGAuqKAApzGs2hqb9wdRXAafPzR\n", + "2QOnIXBUEK9zrTor5X8W+EEo6gT6AUtxGtJicSLUDghBnX8AstzpzjgvhoQgnNOe+Ne4G5RnyE+d\n", + "QX+GatNYKZ9fz08wx9x9CFgoIjcCW4Dp4HQAA+ar6mScz6ofAatF5HN3vbmqmttUolS1TES8nc4i\n", + "gadVdZ2I/MRd/qSq5ohIpohsAo4C1zeVnoboBO4FOgJ/dksDpao6MgR1Bh0/r/t6EckFVgMnce7T\n", + "/ws1ncCDwLMisgqnHe92Vd0fSJ0i8hIwFkh0O3pm4VSVhcwz5I9OQuAZ8kNj3bfpviUMwzCMMMEG\n", + "WzcMwwgzzPAbhmGEGWb4DcMwwgwz/IZhGGGGGX7DMIwwwwy/YRhGmGGG3zAMI8www28YhhFmmOE3\n", + "jCoQEY+IzPH5/0CgBgIyjKbGeu4aRhWIyNnA66o6TEQigA3ACA3NIF2GUSeCGavHMEIWVd0qIvtE\n", + "5Dyc0OIrzegbLQUz/IZRPf+DEzysM/BMkLUYRqNhVT2GUQ3uWBBf4kTB7KP2sBgtBCvxG0Y1qGqp\n", + "iPwDOGBG32hJmOE3jGpwG3VHAVcGW4thNCbmzmkYVSAiA3CGVFyqqgXB1mMYjYnV8RuGYYQZVuI3\n", + "DMMIM8zwG4ZhhBlm+A3DMMIMM/yGYRhhhhl+wzCMMMMMv2EYRpjx/5WxPOsrMTqmAAAAAElFTkSu\n", + "QmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS']\n", + "modelLWLR = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelLWLR)\n", + "fwd_LWLR = generateFwdTest(environment, modelLWLR)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Forward models for Non-Stationnary environments\n", "\n", - "'NSNN' and 'NSLWLR' are modified versions of 'NN' and 'LWLR' where points are not only weighted by distance but also by the number of points that appeared after that one (gaussian with parameter sigma_t=100), to put less weight on old points and allow the learning of Non-Stationnary environments." + "'NSNN' and 'NSLWLR' are modified versions of 'NN' and 'LWLR' where points are not only weighted by distance but also by the number of points that appeared after that one (gaussian with parameter sigma_t=100), to put less weight on old points and allow the learning of Non-Stationnary environments. These models are not finished to be implemented yet." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Forward models comparisons" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'max time': 0.011260986328125, 'mean time': 0.00037045001983642577, 'mean distance': 0.16072982253082238, 'max distance': 0.43973074597217354, 'std time': 0.0010947639700226491, 'std distance': 0.10037534368797667} \n", + "{'max time': 0.011703968048095703, 'mean time': 0.00073633909225463863, 'mean distance': 0.093771696344595853, 'max distance': 0.30806254447231185, 'std time': 0.0011039698586537453, 'std distance': 0.058426547119284841} \n", + "{'max time': 0.012078046798706055, 'mean time': 0.00098849296569824218, 'mean distance': 0.085331665126708686, 'max distance': 0.5727275322273625, 'std time': 0.0011153885287879712, 'std distance': 0.086142758938267172} \n", + "\n" + ] + } + ], + "source": [ + "print fwd_NN, '\\n', fwd_WNN, '\\n', fwd_LWLR, '\\n'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Forward models comparisons\n", "#### Distance between $s_p$ and $s$ comparison\n", "\n", - "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to his neighbors even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model. So WNN is steadier than LWLR.\n", - "\n", - "In order to visualize these differences, it is possible to run the total code below." + "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to his neighbors even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model. So WNN is steadier than LWLR." ] }, { @@ -386,56 +2591,994 @@ "In order to test foward models, we are going to generate randomly n $s_g$ and use one of these models to find out $m$. The distance between $s_g$ and the effective $s$ and the time processing are weighted and saved in $comparison$ dictionary." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "####Nearest Neighbor inverse model\n", + "\n", + "\n", + "To perform the inverse inference, the Nearest Neighbor inverse model looks in the dataset of tuples $(m, s)$, the nearest neighbor of the given $s$ motor command, and return its corresponding $m$.\n", + "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. " + ] + }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 81, "metadata": { "collapsed": false }, "outputs": [ { - "ename": "ExplautoBootstrapError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mExplautoBootstrapError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0msTest\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mtest_cases\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[0mstart\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mmTest\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minverse_prediction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msTest\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 9\u001b[0m \u001b[0mend\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 10\u001b[0m \u001b[0msTest_goal\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompute_sensori_effect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmTest\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/sensorimotor_model/sensorimotor_model.pyc\u001b[0m in \u001b[0;36minverse_prediction\u001b[1;34m(self, s_g)\u001b[0m\n\u001b[0;32m 47\u001b[0m \"\"\" Compute a motor command to reach the sensory goal s_g. It is a shortcut for self.infer(self.conf.s_dims, self.conf.m_dims, s_g)\n\u001b[0;32m 48\u001b[0m \"\"\"\n\u001b[1;32m---> 49\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minfer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0ms_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mm_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ms_g\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/sensorimotor_model/non_parametric.pyc\u001b[0m in \u001b[0;36minfer\u001b[1;34m(self, in_dims, out_dims, x)\u001b[0m\n\u001b[0;32m 32\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0minfer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0min_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 33\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mt\u001b[0m \u001b[1;33m<\u001b[0m \u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 34\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mExplautoBootstrapError\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 35\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 36\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0min_dims\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mm_dims\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mout_dims\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0ms_dims\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;31m# forward\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mExplautoBootstrapError\u001b[0m: " + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXm8XFWV77/rBoSEGRmEyCAkiqIgIoMieBWfhthAt93I\n", + "QwUcnkT7QVBbG7UVIqI03T4FtJvJAQmNERDbYGNwwBtpGRpaQBRoQxgzgCYERJnJen/sXbnn1q1T\n", + "darqnKpzqn7fz+d+bp2h9lln1zl77bXXWnubuyOEEELUGOm3AEIIIcqFFIMQQogJSDEIIYSYgBSD\n", + "EEKICUgxCCGEmIAUgxBCiAlIMQwwZva4me3cw+vNM7P5vbpelTGz08zsD2a2osBrTDWzK83sUTP7\n", + "bpHXNbNPmdkFeZaZN2b2XjO7tk/X3tnM1prZSNy+ysyO7sF1O3onK6EYzOw+Mzu4T9d+qZldFl+m\n", + "R83sNjP7aO0HLjPuvom739fLS3b6xWFSKma2I/AxYDd3377AS/0NsA2wpbsfmdd1zWzUzB5M7nP3\n", + "0939g92JOzy4+2x3b/m8x7bvzd1cqpMvlb5xizhdNDqdYma7AjcC9wOvdPfNgSOAvYFNei1PVsxs\n", + "vX5duk/XrRo7AqvdfXXB19kJ+J27r+3xdQceM5vSo0s5/Xiv3L30f8C9wJvj5/cC/wn8M/AIcA8w\n", + "Kx47Erip7rsfBX7Q4XUvBq5scc5hwG+BNcDPCb2x2rH7gI8DvwYeB74BbAv8CHgM+AmweTx3Z2At\n", + "8EFgObAC+LtEWfsC18frrAC+CqyfOL4W+FtgCbA0sW+X+Hl2lPOPwLK6sj8Yv7ca+AGwXV25c4Df\n", + "xWt/rUldnAJcBiyI1/lvYI/E8e2B7wG/j7/bCXH/LOBp4JlYT7cAo8Dtie/+BPivxPa1wGHNyo3H\n", + "DPgkcDewCvgusEVdnR9DUP5/AD6dcm8viHIdH7enAL8EPpNy/mbARVGm+4B/iLK8BXgCeD7e6zcb\n", + "fHcr4IexvlcDvwAs5Tq7xbpZDdwFHBH3f66uTo9rdF1gf+C6eK1bgTcmyt4S+BbheXwEuAKYBjyZ\n", + "KOePwHbAPGB+/N6PgP9bJ+dtwF82kznl/t4H3BGvsxQ4LnFslPAsfwx4mPBevDdx/IXAQsK7diPw\n", + "eeDalOvUnoW0928ecDkwP5b3/vgbfyOeuyyWPxLPHwG+FJ+ppcD/jeXXjo8BH6h7B2v3+Vtgr3it\n", + "5+Pv9jjw8Qy/2UuAxbGcHxPaifltt32dNJi9/mOyYngG+ADhRfsQsDwemxYrZEbiuzcB7+zwuiuB\n", + "Y5scfynwJ+BgQkPxCUIDu15C7uuArQmN18PAr4A9gQ2AnwEn1z2Y/wZMBV5JaFQOjsdfQ1AOI4Se\n", + "4B3AiQlZ1gJXA5sDGyT27ZK4lwN8vNHaK35+c3x4X01o/M4GFteVuxDYFNghyvS2lPqYF3+bd8T6\n", + "+DtCQz0lyv3fwGeA9eIDvBR4a/zuKcBFibKmEhqgLYH1Y909CGwUjz0BbJGh3BPjb7B9LOdc4JK6\n", + "Oj8v/h57AE+RUO5197c7oYHcjdDQX0d6g30R8P0o707A/wDvj8feCDzY5Lk6HTgn1tuU2u/W4LyN\n", + "Yp0cG+vh1fG3fHlKnU64LjCdoCxrHau3xO0Xxu3/AL4Tn5f1gAPT5E9eCzga+M/EsVcQGrH1W8nc\n", + "4B5nAy+Jnw8C/sz4szsKPEt47qYAh8Tjm8XjC+Lf1PjbLQN+kXKd2rOQ9v7NIzzbtc7IhvH3PSee\n", + "vzVB+RwXj38IuDPW8RaETuPzjCuGnyeehyOibHvH7V2BHevbvoy/2fUEhbQ+cCChPbyo0T03bfs6\n", + "aTB7/cdkxbAkcWxa/EG3idvzgc/GzzNjxWzY4XWfITYwKcc/CyxIbFv8gQ9KyH1U4vjlwL8kto8H\n", + "vl/3YL40cfwM4Osp1/4IcEViey0wWndOUjHcT+g1blp3zjeAf0xsbxTve8dEGa9PHP8ucFKKTPOA\n", + "6+rqYwXwBmA/4P668z/FeM91HnU9G0JP+a8IPaSrCS/524A3AbfFc1qVe2fdi7VdvL+RRJ1vnzh+\n", + "I3Bkk9/8Y4RGfjWwa8o5Uwi99aT1eBzw8/h5lOaK4XPAv6eVnzjvSOoaOoKSq3U2JtRp/XWBk6hr\n", + "NIBFBAtqO0JDtlmD606Sn4kWwyaEDtMOcfsLxOe4lcwZ3snvA3MTcjxBbGzjvocJHagp8XdOvk9f\n", + "oLXF0PD9i/c3lji2LaETsWFi31HANfHzNUy0bv4XEy2GpGK4moSVWydXvWJo9pvtSFCUUxPH/o0O\n", + "LIaq+Bjqeaj2wd2fiB83jv8vIfxAAO8iNLxP1RdgZgfGqJ3Hzez2lOusJvQ009gOeCAhixN6Q9MT\n", + "5zyc+Pxk3fZTCblrJJ16D9SuH53gPzSzlWb2GOEhf2GT79bz14Te131mNmZm+yfu4f7EPfyZcN/J\n", + "e3go8fmJBjInWZYoy+P29oSHdnszW1P7IzTg2zQpazHh5T8wfl5M6K0eRDDFIfTGm5W7E/D9xLE7\n", + "gOcIL3ba/W3URKaL4r1c5e5LU87ZitBjuz+x7wEm1mkz/pkw9PVjM1tqZielnLcTsF/dvb+LiffW\n", + "jJ2AI+q+fwDwIoJ1+Ii7P5axrHW4++MEa6P2Hv5vQgPVtsxmdoiZ3WBmq+O5s5n43K/2cR8KjD+f\n", + "WxOsnPr3qRUN37/IssTnnQi/8crEfZwbrwvhvcp67RcTrNwsNPvNtgfWuPuTifPvb1RIK/rlpCyS\n", + "nwJbm9mehAfyI41Ocvdrae1A/imhQb0w5fgK4FW1DTMzwgu1vEmZrRxJOxJ6pLXPtbLOIQyZHOnu\n", + "fzazj0TZknhaoe5+M/CX0Wl2AnBpLH8FobdUu4eNCC9es3toxg6JskYID/1yQu/zXnd/acr31jbY\n", + "txj4MuHhPh14FPg6QaF+LZ7zYItyHwDe5+7X1x/oMJT3Xwnj/7PM7AB3/2WDc1YRem47EywWCHW9\n", + "rMG5k3D3PxF8Ux83s92Ba8zsJne/pu7UBwjDfm9NK6rFpR4g9CaPqz9gZtsBW5rZZg2UQ6Ny6/d9\n", + "Bzglhodu6O4/zyhzUoYNCL6j9xD8hM+b2ffJ5oz9A6EDUP8+tSLt/YOJ9/ggwSp8YZ1iqrGy7nrN\n", + "rv0gMCPlWH29NvvNdgK2MLNpiQ7zToR3ry2qajGk4u7PEhygXyKM7f2ki+JOAV5vZv9kZtsCmNkM\n", + "M5tvZpsSGte3m9mbzWx9wpj6U4Sx5075TIw/350wbPbduH9jggPqCTPbDfhw1gLNbH0ze3d8yWtO\n", + "w9rD8h3gfWa2Z3wRvwjc4O5pPZxWL+XeZvZXMTLqI4T6uIHg63nczP4+3t8UM3ulmb02fu9hYOeo\n", + "XGtcB7wM2IfgeL6D2OMkDDNBGPppVu65wBdjqCZmtrWZHdbiHhreY4w734swPj4X+HZUpBOIdXwp\n", + "8AUz2zi+sB8lBDO0xMzeHp8zIwyFPk/jl/uHwEvN7D3xN17fzPaJz0fqfSS4GDjUzN4a623DGIo6\n", + "3d1XEpzI/2pmm8eyD4rfexh4YXwH1oldV/ZVhN/qc4QhwKwyJ3lB/FsFrDWzQ4CWCgXW/QZXAPPi\n", + "c/EKwu/WSlmmvX/15a8kOHe/bGabmNmIme2aqKNLgblmNt3MtiAEQKTxdUIn4DUWmFF7Xgl1vWvi\n", + "3Ga/2f3AzcDnYr2+AfiLFvfbkCoqBmfyj1u/fQnBIXxZijbPdiH3e4DXEXp+vzWzRwl+gpuAP7n7\n", + "7wi9ma8SeihvBw519+dayJ/8XC/7YsIwwk+Bf3b3n8b9HyeY3H8Ezie8bPVlNbvWe4B7LQxDHQe8\n", + "O97jzwi+ku8RrIeXECyttHIbyZw89u+EceRH4jXe4e7Pxxf1LwjOxnsI9XU+wakNQZkDrDazm6Ns\n", + "TxCspN8m6vQ64D53XxXPWdui3LMIzvMfm9kfCc65fZvcX8N98UX9CnCMuz/h7t8hvIRfTqmLEwiO\n", + "0HsIEVT/RojwaXbdGjMJHZrH4/3+i7svniRksCzeSvi9lhN6qacTGtPaNVLfFXdfBhwOfJrgaH2A\n", + "0LmptQtHEyyfuwgN1Nz4vbsIHYp7zOyRaF14XdnPEBrmgwnvY1aZk/f3eLzmpYTn6ShC1FzD+2nA\n", + "8YQO1UPAN+NfK9Lev0Z1eUyU+44o32WEIR2ACwi+g9sIz8n30mR198sJQ8OXEN7vKwidWgh185k4\n", + "bPSxDL/Zuwgdp0eAk4FvZ7jnSVh0UBSCmX2T0Fj+3t1flXLO2YRogicIoWa3FCZQiYnDGvcQIpo6\n", + "VmZCiPbR+zeRoi2GbxFi1BtiZrMJoaUzCb3YcwqWRwghRAsKVQzRwbumySmHEU0dd78R2Lw2lj+k\n", + "FGe+CSFaofcv0m8fw3QmhnQtI0SxDB3ufp+7T5EZK0Tv0fs3kX4rBpgczSCtLYQQfaTfeQzLScS9\n", + "Mx7zPgEzk7IQQogOcPe2J+Hrt2JYSAgpW2AhE/dRd3+40Ymd3NwgYmbz3H1ev+UoA6qLcVQX4wxl\n", + "XZjNJITjviHuuRg40cIsBm1TqGIws+8QpjDYysL87acQ0shx9/Pc/Sozm21mdxNivt9XpDxCCDFQ\n", + "hNkF5hISU6cScjbm4L4wHu+o2EIVg7sfleGc44uUQQghBpIUKwH3R7otugzOZ9EeY/0WoESM9VuA\n", + "EjHWbwFKxFi/BSgUsxHCXGm3EZTCQ8DhuB+dh1KAgjOf88LMXD4GIcTQ06aV0GnbKYtBCCHKTp2V\n", + "sBqePhZ+Y7C1hfVKcqXfUUlCCCGaUWclXA6PHwebrAmrzL0S2NXMcPer8rqkLAYhhCgjDXwJ74Nf\n", + "HRGUQpIZhNl8c0OKQQghykawEhYTpnqfSvAl7H5hmIq9EVPzvLwUgxBClIXWEUeTlimOPJmyvyOk\n", + "GIQQok1iYu4iC+unL4pLCHRbaEMrYV2yWuBswkJCSZYSFgvLDTmfhRCiDaISOIuJ6zR37gBulb2c\n", + "IM4WAcGnMJVgKXw1T8czKI9BCCHawswWAW9rcGiRux/SZmGFZS+H4pXHIIQQvWDDlP3ZHcA9yF7u\n", + "BikGIUTlKWTMP53uHMDZfAl9RT4GIUSlyX3MvzVnA7vWXa+1A7gNX0K/kY9BCFFpch3zz37N2bTj\n", + "AC7Yl9BEzo7aTlkMQoiq0/2Yf5tEJdDaGqmQlZBEikEIUXV6kvTVNn2yEvJAzmchRNf02PlbT0+S\n", + "vjLTZsRRn+uuIbIYhBBd0Qfn7wR6lfSVifbXS+hr3aUh57MQoiv64fwtHR36EoquOzmfhRD9oufO\n", + "31LRnS+hlHUnH4MQolvK6fwtGrORH5ud9xTcRVxV7Xw4tc3s5VLWnRSDEKJbyuX87QVmM38Pv34r\n", + "HLchjMwHZsIGc+BdbTqPS1l38jEIIbqm7YSvqlLnS1gJzAGunHhWW/6BIuuu07ZTikEIIbJQ50u4\n", + "Eh4+FrZdM/nMxe4+2lPZUtDsqkKI0lDG2PyOSclLOAxubaAUYAB8K4pKEkLkSllj8zuiWcSR2XN0\n", + "MpleBdBQkhAiV9qJzY9KZC4hbPMp4Oyk8mh1vDAy5iWU3beiPAYhRFnIFJvfyrLom+XRRl5C5sn0\n", + "KoZ8DEKIvMkamz+XiY0+cfuEjMfzpeSrqvUSKQYhRN5kjc1vZVn0Liu4Aquq9RINJQkhcqWNSe02\n", + "SSmiZlkUnxWcw3oJffODFIgUgxAid1qNvcfG9EUNDq1k3LK4HngzsH7i+LPADbkI2YYvIa3xH6gI\n", + "rARSDEKIfjAX2L7B/uWJBvV1TFQKxO39u7pym1ZCs8af5n4QKQYhhGiDNP/BnzOc07mPobOZUJs1\n", + "/qWcHbVb5HwWQvSDLP6D/HwM3UUcNWv8M8lYtUxwWQxCiH5wNq2zhrOc05ru115u1vh/tZWMVfRD\n", + "FKoYzGwWcCYwBfi6u59Rd3wrwo/0oijLl9z9wiJlEkI0pxdRNlkil1qd01LOHCKOIqkKKmMEVvX8\n", + "EO5eyB9BGdwN7ExwGN0KvLzunHnA6fHzVsBqYL0GZXlRcupPf/ob/wNmA0sAT/wtAWb3W7a25ISZ\n", + "Dtc6ePyb77Bll9f7ETAW/2euj/gdb/A31oN68k6+V6TFsC9wt7vfB2BmC4DDgTsT56wE9oifNwVW\n", + "u/tzBcokhGhOVXq3DeUcgRMweyndWwkT8O6mvijlKm3NKNL5PB14MLG9LO5LcgGwu5mtIDiFTixQ\n", + "HiFEa6oSZTNJzhnAzSHEtePs5YKcxKVcpa0ZRVoMWaZt/TRwq7uPmtmuwE/MbE93f7z+RDObl9gc\n", + "c/exfMQUQiSoSu92nZzGuCNhGmxGh1ZCUU5iz54J3jVmNgqMdl1QgWNb+xOm2a1tfwo4qe6cq4AD\n", + "Ets/A16b1ziZ/vQ3DH+E8e9FhLHsRXThD6Dx2P3d7ZaZp0zN5JwB/otxP4L/Dn7WqS8hytnIF/Cj\n", + "fv/GXdSTd/K9Ii2Gm4GZZrYzsAI4Ejiq7py7gLcAvzSzbYGXAfcUKJMQA0XevVzPoXfbi/BMh0U/\n", + "hmsOgl02hJHV8PT34Izj3E/potiqDKMVTqEL9ZjZIYyHq37D3U83szkA7n5eDFf9FrAjwd9xurtf\n", + "0qAcdy3UI8Qk2lkUp1cULpPZzN/D97eB3QH+A1bMg4/e5H5pd8WWry67pZQL9bj7jwihXcl95yU+\n", + "rwIOLVIGIQacvvRyW+QQFCNTzEt4Hv5xG9hgJTAHuDLMufQFM/tTlxZJPgl1A4Ayn4WoNj13FmcY\n", + "KspfpkT28hRgPiGEcc34GV2H1OYxjDYoSDEIUW360cttleuQn0wNspePhVUXwSsbnN21leQDulRn\n", + "u0gxCFF9/gg8QojcXAqcUnAvt+lQUW4975Q5ji6CS2isGMoWUltZpBiEqCgpQzqb9+DSLYeKuup5\n", + "t5rjyEy+gIKRYhCiuvRr+oriGuYMM6HKFzCRIiY9lGIQorr0JSIprWGGdSGf7TdQbc6EKl9AoKic\n", + "ESkGIapL36avqG+Yu2qgul8vYZgpxGrUCm5CVJdGk7OtBLbuw0phzRqoxnS3qpoIFGI1ymIQoqI0\n", + "GNLZGNgO2DtxWq9WCmuvgZKVkBeFWI2yGISoMO5+lbsf4u6jwCpCFnCS5r32/MjWQMlKyJtCpvSW\n", + "xSDE4NDxsEIOkS2tI5VkJeROURFaUgxCDA4dDSvkEdnStIHKb+1l0YAiIrQKnV01LzS7qhCtSWng\n", + "lwJzmzXwhc4qWmIroYj4/7JRytlVhRC9o4thhfwjW0puJfRizYgqI8UgxADR4bBCvpEtJbYSEvQr\n", + "a7wSKCpJCJFPZEu1Io7qo7dqDN1qbY2QxSDEkJNLZEs1rARg3TDSrimHNUMrcj4LIbqh5L6ERjRx\n", + "tj8BHDFIPoZO204NJQkhOiNYCYuBrxCUwsXA7mVWCpE0Z/vSsisFM5sdpzopdMoTDSUJIdqjglZC\n", + "HWnO9uU9laJNehlJJYtBiAbk3TPrVU+vcKprJSQpZBqJHtD+RIUdIotBiDry7pkNRMx89a2EdVR4\n", + "oZ+erb8hxSDEZPKOca92zHyFIo6yUtGFfnq2/oaGkoSYTN49s76stNY11cpLGAZ6NgQmi0GIyeTd\n", + "M+vbSmsdM4BWQpVIm8epV0NgUgxCTCbvxe5zK6/wid8K8CUMw2R1eZLBJ1V43UkxCFFH3j2zvMor\n", + "3IldgJUwEI733tN3n5Qyn4WoCIVNj11gxFGhU3oPKGY2BryxwaHFcaW+dspS5rMQA04R02Nnykvo\n", + "Ig+jmo73/tJ3n5SGkoSoDvk1GG1YCV0OB/W9kasgefu42kaKQYjqkE+D0b4voZsx7743clWjDAl4\n", + "UgxCVISuG4zOfQkdDweVoZGrIv1OwJPzeYhQ2OAQ00XEkRzI1UVrPoumKGxwSGnTSmjUeUDDQUOH\n", + "LIYhQb2+IaRNKyGl83A3cGL8rOGgilFKi8HMZgFnAlOAr7v7GQ3OGSWEyq0PrGo3TldkRmGDXdCr\n", + "YbhcrtO5LyHVyRw7D1IEQ0JhisHMpgBfA95CWADjJjNb6O53Js7ZHPgX4G3uvszMtipKniqSc2M0\n", + "VGGDedZdr4bhcrlOd9nL6jwIIKNiMLNpwA7u/j9tlL0vcLe73xfLWAAcDtyZOOddwPfcfRmAu69q\n", + "o/yBpoDGaGjGiQuou15NUdD5dfLJXh6qzoNIp2Xms5kdBtwCXB239zKzLA/bdODBxPayuC/JTGBL\n", + "M/u5md1sZkdnE3soyHW1ptggnggsImS6LgLmDug4cWrddZjB26uedGfXyW9VtaqubCZyJovFMA/Y\n", + "D/g5gLvfYma7ZPheFq/2+sBrgIOBacD1ZnaDuy/J8N1BJ/fGqN+x0T0kre6m05kl0auedHvXyXmO\n", + "I+UciBpZFMOz7v5ofGBqrM3wveXADontHQhWQ5IHCQ7nJ4EnzewXwJ7AJMVgZvMSm2PuPpZBhioj\n", + "s75z0upuO6Dej5VlqKZXw3DZr1PQeglD1HkYSGIwz2i35WRRDL81s3cD61l4GOcC12X43s3ATDPb\n", + "GVgBHAkcVXfOD4CvRUf1BgTL5MuNCnP3eRmuOUgMjU+gANLq7gkmKwZoYYUletKfi+U68Fgukk6+\n", + "zj7A8QRr+llg/oQe+wCtvSzyJ3aYx2rbZnZKJ+VkUQwnAP8APA18h+Br+HwGAZ8zs+Pj+VOAb7j7\n", + "nWY2Jx4/z93vivH1vyZYIRe4+x2d3MigIbO+c9LqjtCgvqrBV7JaYZsDW8TPWwJn1Q9DdRINlfjO\n", + "9gTFMy1x+D1mdpO7X6VV1USvaJngZmavcfdf9UieNBmU4Ca6JiVaaSkZnPBZEgSbJYillZ/ynQmM\n", + "wKLnQwdLVoJoiyIT3L5sZi8CLgO+6+6/aVs6IUpAl1ZYlmCATsJNG31nwpcvhdcBs+KuyloJmqur\n", + "OrRUDO4+ambbAe8EzjOzTYFL3b3lcJIQZaML52qaQ3vjxOdOIskafscYdyRMg82ouJWgubqqRaYV\n", + "3Nx9pbufBXwIuA04uVCphCgfZwMrG+zfLpEL0Ukk2aTvzCAkJZxJcDYsgWvoLC+hTOSalyOKJUuC\n", + "2yvMbJ6Z/YYwxcV1TE5UE2Kgib3aFQ0Obc9449ZJgti67xghA/E24EBgNTx9Ppw60/3gKg4d1aHp\n", + "NipEFh/DN4EFhPmMlhcsjxBl5k8p+6dCZz6M2ndeDSd9E/bcKwwbAVz8QjjxuOorhBrKy6kQWXwM\n", + "+/dCECEqQMvGrW0fhtmIw0uBfRjsiCPl5VSIVMVgZpe5+xFmdnuDw+7uexQolxC5k0NUTL6NW4ny\n", + "EoqOGFJeTrVoZjHUFuf4C8LwZ5Lyr+4jRII8omKyNm4tG9mSZS/3KmJI021UhywJbme4+0mt9hWJ\n", + "EtxEt/RqBbuWSW4lshJqaHW/waXTtjNLuOpbG+zLMlWxEGWiV1ExDcMyR+AEzD5CCDp6A8FKOBz3\n", + "o9tVCh1OHd4MRQyJCTTzMXwY+FuCSZn0M2wC/LJowYTImV5FxWxfv2MGcAkcRA7ZywUN+yhiSEyg\n", + "mcVwCXAosJDgZzg0/u3t7u/ugWxC5EmvFqHZrvYhmZewT8hV69hKSFBEolhlF+gpwHoSNLEY3P0x\n", + "4DEzOwtY4+5/BDCzTc1sP3e/sVdCCtEtPYyKWQlsNYPgSDgw7rwCHn1HyF7u1pdQyAJOVYwY0jQb\n", + "xZHF+Xwr8Bp3Xxu3pwA3u/tePZCvJoOcz2ISZZyUbYrZohPgbXGOI1YCc4Arc3LkylE8juqiNUXO\n", + "rkpNKcTPz0flIERutNvIl7K3aDZzJbx4m7g5nzCUtCbfYRklio0jp3lBZFEM95rZXOAcwrDph4F7\n", + "CpVKDBUdNvKdTHFdDIm8hG1g6lOw5sNw74XwODkPy1R12Kcg5DQviCxDSdsSeilvirt+RojJ/n3B\n", + "siVl0FDSANPJkICZjQFvbHBosbuP5iddC0qYlzAsdLPw0rBQ2FCSuz9MWK9ZiKLoZEigv73FkmUv\n", + "DyOynoqjpWIws5cB/wq8yN13N7M9gMPc/bTCpRPDQieNfP/G2mUllAZNs1EMWTKfLwA+DTwTt28H\n", + "jipMIjGMtB1HHxuEE4FFhHVtFlH0EILZSF7Zy0KUmSzO52nufmM02XB3N7NnixVLDBOdDgn0tLco\n", + "K0EMEVkUwx/MbJ25bmZ/Q+MlDoXomNIOCciXIIaQLFFJuwLnA68DHgXuBd7t7vcVLt24DIpKEoXS\n", + "MI8CliArQVSY3KOSzOxEdz8L2M7dDzazjYGR2tQYQgwK9WGPBnwS9n4eNpkCGyArQQwZqRaDmd3m\n", + "7nua2S29nP4iRRZZDKIwknkU9XMcIStBVJgi8hjuMLMlwPQGy3tqaU8xSGxojDsSanMcfRJ+8233\n", + "o/sqmRB9oNnsqkeZ2YuAq4HDmLy8pxB9Ie/J814NI2czbiUk5jha9u1uhRWigjTzMfws+haudvf7\n", + "eymUEGnkOnlejDi6GfadwoSZUGF4J6YToulQ0nZmdgBwmJktIFgM6xwS7v6rooUTogH5TJ6XyEuY\n", + "AiyBaw4Cfyi8E5paQQw1zRTDKcBngenA/2tw/E0N9glRNN1NtZySlzDTfaGSc4QINPMxXAZcZmYn\n", + "u/upPZRJiGZ0PnmespeFyESWuZJOM7OjzexkADPb0cz2LVguIdJof31izXEkRFtkyXw+F1gLvNnd\n", + "dzOzLYEfu/treyFglEF5DGId0QGdbV4lWQliiOm07cyiGG5x972SiW615LcOZW0bKQbRNprjSIiO\n", + "284sQ0nPJNd4NrOtCRaEEOUkWAmLga8QlMLFwO5lUwpmNtvMFpnZWPw/u98yCQHZZlf9KvB9YBsz\n", + "+yLwN8BnCpVKiE6okJWQaz6GEDnTcigJwMxeDhwcN3/m7ndmKtxsFnAmMAX4urufkXLePsD1wDvd\n", + "/YoGxzWUJJpTMV9CJ+tcC9Euha35DBAVQSZlkBBoCvA14C3AcuAmM1tYr1TieWcQVuBS4y/ao0JW\n", + "Qh3d5WMIUSBZfAydsi9wt7vf5+7PAguAwxucdwJwOfCHAmURPaYn4+c5+RL6NNbfeT6GEAWTyWLo\n", + "kOnAg4ntZcB+yRPMbDpBWbwZ2IfElBuiuhQ+fp6jldDHsf6zgV3rrqv5mUQpaGkxmNkrGuwbzVB2\n", + "lkb+TOByLGg6AAARIUlEQVSTHhwdhoaSBoVm8xl1R/4RR8XJ2oSodE4kDKEujv/nyvEsykAWi+FS\n", + "M5sP/BPhRTyD0Lvfv8X3lgM7JLZ3IFgNSfYGFsSF4LcCDjGzZ73BS25m8xKbY+4+lkF20R/yHz8v\n", + "zpfQt7H+0q5zLSpL7LSPdltOFsWwH0EZXA9sDFwCvD7D924GZprZzsAK4EjgqOQJ7r5L7bOZfQu4\n", + "spFSiOfOy3BNUQ7yHT8vNuJIY/1iYIgd5rHatpmd0kk5WZzPzxFekqmE3tU97t4ywc3dnwOOJyz0\n", + "cwfwXXe/08zmmNmcToTtFUo86pr25zNqRG/mOMpHViEGiCxTYtwGLAROJQz3nAc87e5HFC/eOhl6\n", + "lseQ4oy8GzhR47/ZaWs+o8YF9CwvoWtZS0weq93lvWKe6B0dt53u3vQP2KfBvmNafS/PvyBmz661\n", + "iOA4r//7US/vuUx/wOxYL2Px/+zCrgcjDh9xeMLBHVY6HNbvOihN/bQv15K653hJO/LlUYb++voM\n", + "eCffa+ljcPebGuy7KKviqSBKPEqQNZwzl15l9bKXZxMs6Vcw8fkoy9QWeax2l8+KeaJSFJnHUFXk\n", + "jJxIy4ah61yAFhFHeQ5l5FVWyj3XKEvDmUcnRx2lIUSKYTJKPJpIloah815lCyshzwS0nJPZGt1z\n", + "kjI0nHl0ctRRGkKKnBKjkniXiUcDGNGUpWFov1eZPeIozwS0PMtKu+caZWg484i4UtTWECKLoQHe\n", + "YeJRVaZSbnM4JYsF1V6vsj1fQp5DGXmWlXbPUJKG092vismjHUdc5VGGqB5SDPlSekddu8orY8PQ\n", + "SHk8CWxtZrPXndtZ9nKeQxl5ltXonp8CfgucXJaGs9NOTt5liGohxZAvVXDUta28WjUMCeWRjNCZ\n", + "Spjy5Cwzw0OIYycRR3n6fHIpK2FxPQmsAlYSpoBRT1oMBFIM+VIFR10hyisqh7n15RjM+Dx8CdiZ\n", + "DuY4ynMoI4+yUiyuRzuVSYgyIsWQL1WIaCpSeU1QOjMIJsKB8PK4q6O8hDyHMnIoq/TDhUJ0ixRD\n", + "jlTEUVek8noKwtzpNUfCNGA1PP1CeGdWK6HkVGG4UIiukGLImbI76gpWXme/AnY7F3Y6MO64HB4/\n", + "A/7PTYOhFKAaw4VCdIUUwxCSp/KqOWJHYMPTYNtPwPYvAFbBM5+A31wIny2ZxdQtVRguFKIrWs6u\n", + "WgZ6ObvqsJDjrJtnzYAZ0ZcAwBK4ZiYcUdY5jrplkGdjFYNFp22nLIYhJK9EvBGYewLMqPkSVgJz\n", + "gCvhGR9QpQDlHy4Uols0JUYBVGBajO6nhjCbeTPsfyZBKcwHdgeuDEfliBWiwshiyJmKTIvReWRN\n", + "Int5L5iasBKSyBErRIWRxZA/eU7UVhSdRdaEOY4WA18Bpi6Ba/aAe+qUQmGO2ApYYkIMBLIY8qcK\n", + "ce7tRdakzHE0033hqh45YitiiQkxEEgx5E/p49zbymVoMRNqDx2xyjgWokdIMeRPJeLcWzbonc2E\n", + "WiRVsMSEGAikGHKmItNiNKecay+X3hITYlBQgpsYp3xWwjpSfAxLaWN1PSGGDSW4ie4op5WwjoGw\n", + "xISoCLIYSkwe01ZkuEhprQQhRHfIYhgwmoVnRhoqjLaUScmtBCFEf5BiKC9p4ZmnApuRrjBax/rL\n", + "ShBCNEGKobykhWfuAmxRt68Wz2+0ivWXlSCEaIGmxCgvaeGZaU6hqTSL9TcbwewjwG0EpfAQcDju\n", + "R0spCCGSyGIoL2mJco8CWzY4/0mCxTCJV4f9i5GVIITIgBRDSUkLz4yHG8Xz146tUyYGfBJWfR72\n", + "AzZAvgQhRAakGEpM2rQVzeL5a8f2gC0vgpl7wlbxa7IShBCZUB7DoKGIIyFERHkMQhFHQohcUFTS\n", + "IKCIIyFEjshiqDqyEoQQOVO4xWBms8zsLjNbYmYnNTj+bjO7zcx+bWa/NLM9ipaprLS1dKWsBCFE\n", + "QRRqMZjZFOBrwFuA5cBNZrbQ3e9MnHYPcJC7P2Zms4Dzgf2LlKuMtLV0pawEIUSBFG0x7Avc7e73\n", + "ufuzwALg8OQJ7n69uz8WN28EXlywTGWl2dKVAVkJQogeULRimA48mNheFvel8QGGd/3e5ktXBith\n", + "MfCVuO9iYHeFoQoh8qZo53PmJAkzexPwfuCAlOPzEptj7j7WlWTlo+HcSCPwZLQSlJcgRMnoyZop\n", + "7ckzCox2W07RimE5sENieweC1TCB6HC+AJjl7msaFeTu84oQsERMmhvp5fDAWKizr8Rd8iUIURLa\n", + "8gv2iNhhHqttm9kpnZRTaOazma0H/A9wMLAC+C/gqKTz2cx2BK4B3uPuN6SUMxSZz/FBO2EEpp4K\n", + "23wSdpmiOY6EKCVmtgh4W4NDi9z9kF7L04hSZj67+3NmdjxwNTAF+Ia732lmc+Lx84CTCesLnBPn\n", + "+XnW3fctUq6y4u5XYbaEEHH08rhbVoIQ5aS5X7DCaK6ksqA5joSoFINsMWhKjDKgiCMhqsjZwN11\n", + "+5JT4FcWTYnRT2QlCFFZ0tZM6WdUUl5oKKlfKHtZCFEwGkqqCspeFkKUHCmGnMg0AZ58CbnR1oSD\n", + "Qoi2kI+hBVkyG1smusiXkCtlTCwSYpCQYmhCGw1Q+gR443kJ8iXkR7MJB6UYhOiSoRpK6mD4ofWM\n", + "p4FJiS4GfA5mIl9CEQxsYpEQZWBoLIYOhx+yNkATJsCbQTARDgxzH4GshLxpOOEgIVxQCNElw2Qx\n", + "ZO39J0ltgJLWB7A1sMKAEwkmwoHhy2uQlVAEA5tYJEQZGBqLgc6GHybNeEpogG6gzvrYDX5/Mfxp\n", + "b9gYYAlcMxOOkELIn0FOLBKiDAyTYmh7+CGtASJhfRjrwo22mRa+9hAwZ2YJI47KNnd8N0S5Kym7\n", + "EGVnmBRDWu+/6fBDowbIzP4eJvgSALgSHj405CWUzkpQiKcQIitDoxjyHH4YgadOICQlTANWAnOA\n", + "K+EWL6FSiCjEUwiRiaFRDJDT8IPZzJXw4m3i5nyCw3lNwvoo6ZCNQjyFEJkYKsXQFYns5W1g6lOw\n", + "5sNw74XwOAnro8RDNgrxFEJkYpjCVTvHbObv4dfEOY7+A1YcCB/6lvve7j7q7ockGv1OwmJ7gUI8\n", + "hRCZkMXQjGglPA//uA1skPAlbA98wcz+1MAKKOWQjUI8hRBZkWJII7FewhQm+BJqpDluSztkoxBP\n", + "IUQWhm4oqeV8SQ3WSzgWfnMME5RCjUZWQF+GbDQNtRAiL4bKYsgwPXbDVdUugkuAVzYocpIV0I8h\n", + "mxI7vIUQFWSolvY0s0XA2+r3j8Ci5+FqUtZLSGl4lwJzy9Dwpt0XsMjdD+m1PEKIctBp2zlUFgMN\n", + "HMMzgEvhdcCsuGvSTKgVcNyW0uEthKgmQ6MYYq9/93XbjC+pNg02o8WqaiV33JbW4S2EqB5D4XxO\n", + "DAVtBcFKWAycSZjSYglcQ7XXXlaOghAiN4bFYpgLzKizEngI1i6E045zPyXtiyWd3mICFRjqEkJU\n", + "iGFRDBvWz4Q6H/gEXP9Qa6VQiWifkg91CSEqxOAPJZmNnAbb1lZVWwkcBhwDPBzmOWpGWae3EEKI\n", + "whhsxRDyEhb/A+w2jWAl7A5cGY5mGYNXtI8QYugYzKGkxEyoxLyE8+H8ObAv7Y3BK9qnTargkxFC\n", + "NGfwFENK9vJx7o8c135pHa36NqxUyScjhEhncDKfG1gJNMlLaOPas1G0TyaUgS1EuRjuzOcUKyGP\n", + "tZcV7dMW8skIMQBU2/ncYCZU4HDcj85DKYi2kU9GiAGguoohRhwRV1UjWAlVzl4eBJSBLcQAUKhi\n", + "MLNZZnaXmS0xs5NSzjk7Hr/NzPbKUGhLK0FrE/SHOOx2IrCIoLQXUZIZaIUQ2SnMx2BmU4CvAW8B\n", + "lgM3mdlCd78zcc5sYIa7zzSz/YBzgP2bFNrSlzDokTFmNuruY/2WI41e+mTKXhe9RHUxjuqie4q0\n", + "GPYF7nb3+9z9WWABcHjdOYcB3wZw9xuBzc1s24alZfclDHq28mi/BSgRo/0WoESM9luAEjHabwGq\n", + "TpGKYTrwYGJ7WdzX6pwXp5SX1ZegyBghhOiCIsNVsyZI1MfYpn0va16CImOEEKILCktwM7P9gXnu\n", + "PitufwpY6+5nJM45Fxhz9wVx+y7gje7+cF1Z5c/CE0KIElK2BLebgZlmtjOwAjgSOKrunIXA8cCC\n", + "qEgerVcK0NmNCSGE6IzCFIO7P2dmxwNXA1OAb7j7nWY2Jx4/Ly4wM9vM7gb+DLyvKHmEEEJkoxJz\n", + "JQkhhOgdpcp8LiQhrqK0qgsze3esg1+b2S/NbI9+yNkLsjwX8bx9zOw5M3tHL+XrFRnfj1Ezu8XM\n", + "fmNmYz0WsWdkeD+2ismtt8a6eG8fxOwJZvZNM3vYzG5vck577aa7l+KPMNx0N7AzsD5wK/DyunNm\n", + "A1fFz/sBN/Rb7j7WxeuAzeLnWcNcF4nzrgF+CPx1v+Xu0zOxOfBb4MVxe6t+y93HupgHnF6rB2A1\n", + "sF6/ZS+oPg4E9gJuTznedrtZJosh34S4atOyLtz9end/LG7eSHr+R9XJ8lxASGC8HPhDL4XrIVnq\n", + "4V3A99x9GYC7r+qxjL0iS12sBDaNnzcFVrv7cz2UsWe4+7XAmiantN1ulkkx5J0QV2Wy1EWSDzC4\n", + "U4O3rAszm05oGM6JuwbRcZblmZgJbGlmPzezm83s6J5J11uy1MUFwO5mtoIwY8KJPZKtjLTdbpZp\n", + "PYa8E+KqTOZ7MrM3Ae8HDihOnL6SpS7OBD7p7m5mxuRnZBDIUg/rA68BDgamAdeb2Q3uvqRQyXpP\n", + "lrr4NHCru4+a2a7AT8xsT3d/vGDZykpb7WaZFMNyYIfE9g4EzdbsnBfHfYNGlrogOpwvAGa5ezNT\n", + "sspkqYu9CbkwEMaTDzGzZ32wpmDPUg8PAqvc/UngSTP7BbAnMGiKIUtdvB74AoC7LzWze4GXEfKr\n", + "ho22280yDSWtS4gzsxcQEuLqX+yFwDGwLrO6YULcANCyLsxsR+AK4D3uXr8GwiDRsi7cfRd3f4m7\n", + "v4TgZ/jwgCkFyPZ+/AB4g5lNMbNpBEfjHT2WsxdkqYu7CDM7E8fTXwbc01Mpy0Pb7WZpLAZXQtw6\n", + "stQFcDKwBXBO7Ck/6+779kvmoshYFwNPxvfjLgvrbv8aWAtc4O4DpxgyPhNfBL5lZrcROsB/7wO6\n", + "qqOZfQd4I7CVmT0InEIYVuy43VSCmxBCiAmUaShJCCFECZBiEEIIMQEpBiGEEBOQYhBCCDEBKQYh\n", + "hBATkGIQQggxASkGIfqAmc0zs7/rtxxCNEKKQYj+oAQiUVqkGIRg3SI/t5nZBma2UVzc5RUNzvts\n", + "XCDmWjO7pNbrN7NXm9kNsYwrzGzzuP+DZvZfccGYy81saq/vTYh2kWIQAnD3mwhzypwGnAHMr59O\n", + "wsz2Ad4B7AEcAryW8Z7/RcAn3H1P4HbCtAQQ1kfY191fDdxJmCJdiFJTmrmShCgBpxImaHuSsPBP\n", + "PQcA/+7uzwDPmNmVAGa2KWE1vWvjed8GLoufX2VmpwGbARsDiwqUX4hckGIQYpytgI0IE7NNBZ6o\n", + "O+5MnNc+bd2H5P4LgcPc/XYzOxYYzUVSIQpEQ0lCjHMe8BngEsJwUj2/BA6NfoiNgbcDuPsfgTVm\n", + "9oZ43tHAWPy8MfCQma0PvIfxoadBXExIDAiyGIQAzOwY4Gl3X2BmI8B1Zjbq7mO1c9z9ZjNbSJjW\n", + "+mGCL6G27vaxwLlxHYSljE9t/FnCmtx/iP83rhWHIpNESdG020K0gZlt5O5/jgpgMfBBd7+133IJ\n", + "kSeyGIRoj/NjGOuGwIVSCmIQkcUghBBiAnI+CyGEmIAUgxBCiAlIMQghhJiAFIMQQogJSDEIIYSY\n", + "gBSDEEKICfx/BE/79jHEbCsAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4VVXWxn8rBVLpHemhJqA0JQKCWICggg3LWBgEy6jY\n", + "21hOjvNh1xmxMA6IBZViQSyA2GgKSFd6L9I7CaGG/f2x9iU3IeXm3hTU8z7PeZJ7yj77tLXXXuVd\n", + "YozBgwcPHjz8dRBW2h3w4MGDBw8lC0/we/DgwcNfDJ7g9+DBg4e/GDzB78GDBw9/MXiC34MHDx7+\n", + "YvAEvwcPHjz8xeAJ/hAgIidEpGExtt9ZRJYXV/vFDRFZLyIXlHY/SgMiEi0iX4rIPhEZY9f9n4js\n", + "FJEtRXyux0RkWFG2WdQQkX4iMr2Uzl3ffqth9vcEEbmxBM6bKiIji/s8weAvI/itEMoQkTS7HBCR\n", + "GqXYn1QROWb7cUBEVojIa/59MsZMN8Y0C7Ct0/EFM3YpNOzz6lbE/SlJXAVUAyoZY64RkbrA/UAz\n", + "Y0ytYBsVka4issl/nTHmWWPMwNC6+9eBMSbFGFPg91IE7+BpmyT1lxH86EO4xBgTb5dyxphtpdyf\n", + "UcaYckBF4HKgBjCvNAek0wgGkNLuRAioB6w0xpywv+sCu40xu0uxT38KiEh4CZ3qj/4O5om/kuDP\n", + "FSLynojcb/+vbaeE/7C/G4nIbr99HxKRLSLyu4j0D/XUdsEYk2mMWQpcA+wEHrDny6bdicgj9twH\n", + "RGS5iHQTkR7AY8A1diazwO77dxFZavddIyK3+rXT1bZzv4hst9fUz297tIi8bDWefSIyXUSi7LYO\n", + "IvKziOwVkYUi0qWA6zxbRJaIyB4RGSEiZf3Oc4ltY6+I/CQiLe36kaig/NJe00Mi8m4hnlOu7dpt\n", + "tUTkUxHZISJrReRuv22pIjLWvhMHRGSxiLTN8wGKNBORb0Vkt30eV9v1LvCk3zO5FZgM1LK/RxR0\n", + "L0Wkkoi8IyKb7b37TERigIl+7RwQkZr+Mz4RmSgid+bo5yIR6ZNfn/O4vlDeocoi8oWI7BeR2UCj\n", + "fM7jM8UMtNe7RUQeyPFcPhGRkSKyH7hZRMqLyNuS9T3+S7JMOWEi8pKoWW0N0CvH+aaIyC1+vwf6\n", + "XecSEWmdyzv4YADPrIGITLXtTAaq5HXNpQ5jzF9iAdYBF+Sy/u/AF/b/64HVwGj7uz8wzv7fA9gG\n", + "tABigI+AE0DDIPuTCozMZb0LzLL/dwU22f+bAhuBGvZ3Xd+5AQd4P0c7KUAD+/95wEGgtV+7x2wf\n", + "woGednt5u/0N4AegJqocdADKALWBXUAPu9+F9neVPK5xPfCrPa4iMAP4l93WGtgOtEcHwJvsM4r0\n", + "e17dgnhOebZrr2Ue8AQQATQA1gAX+z2TQ/ZZC/AMMDOPa4sFNgE323bPQgft5rk9E6CL71na33nd\n", + "y8r299fAKKC87Wvn3NrJeS7gRmCG37YWwF57/fn2OZdrDOUdGm2XaCAR+B2Ylsd56qPf0od2/yRg\n", + "B/Z7tec4Clxmf0cB44Chdv+qwGzgVrv9dmAZWe/dj0AmEGa3/wj0t/9fbfvW1v5uBNTN4x0s6JnN\n", + "BF6y97ozcIAc3+XpspR6B0rsQlUIpdmPYC/wmd+D3oN+6EOBW8kStu8B99r/RwDP+LXXmOIR/Lej\n", + "JgLfx+XrSwIq0C7ACseC2sqxzzhgkF+7Gb4Pwa7bDpyNCoQMoGUubTyS80UGJgE35XHOdb6P0f7u\n", + "Cay2/w8Fns6x/3KyBFzOjy7Q55RXu+cB5wAbcmx7DBjhdx8n+21rAWTkcW3XkEOQAW8BT+X2TPyf\n", + "ZUH3Eh1wM7FCNMc+2drJeS4gHkgH6tjfg4HhgfQ5gHc20HcoHBXUTfy2DQam59FuffRb8t//eb9+\n", + "pwJT/LZVBw4DUX7rrgN+sP//kOO9u8i2n5vg/wa4O5/31/8dzO+Z1UUHwmi/bR9SwHdZWstfydRj\n", + "gN7GmIp2uQLAGLMG1VTOQkfpr4AtItIEFRZT7fE1UW3Jh415nUg0GsfnRP6tkP2sDZxiBzbGrAbu\n", + "RT+C7SIySkRq5tOHniIyy07p96LaW2W/XXabLPsz6Ecch05Po1BNOCfqAVfbae5e225H1DeRF3Le\n", + "M59jsx7wQI62zvDbng2FeE55tVvTbquVY9tjqBPWh+057kmUz4SQy704J0db16NCKRDkdy/rAHuM\n", + "MfsDbOskjDFp6GzhOrvqWlQAFbrPIbxDVdFZSkDfix/yeldAtXIf6qFa9Va/6/ivPS8U4ltF343c\n", + "3vXckN8zqwXsNcYc8tt/Q4DtljgiSrsDpwmmolO+SGPMFhGZCvRDp4kL7T5b0VHdh7rkAWPMdFTz\n", + "yg8m5worYC5F7cG5tTsKGCUi8aim9jyqbWRrS9SO/ilwAzDeGJMpIuMIzFG1C9WmElAzjT82ohrM\n", + "racclTdy3rPNfm0NNsY8k8dxp9wfAntOebYrIh2AdcaYJoU4Z17YCEw1xlwcZFt53ks7oFcSkfK5\n", + "CP/c2s25bhTgiIZPRhljfgywz/59COUd2gkcR5/3Crsuz+/FDzn33+y3zf8aNwFHUBOL/8DjQ8Df\n", + "qm0rIY9tOe9rfs+sHlBRRGKMMRl2dT105nba4a+k8eeHqcBdwDT7e4r9Pd3YORswFugnIs1FnWxO\n", + "iOc8+QGJSISINEc/2GrAK6fsLNJE1JlbFn3pD5P1Um0D6ouIr80ydtkFnBCRnkCBHzuA/ZBGAK+I\n", + "Og7DRSRZRMoAHwCXisjFdn2UdfLVzuca7xR1xlYCHgfG2G3DgNtF5GxRxIpILxGJs9u3c6pDMJDn\n", + "lF+7vwBpIvKwqAM7XESSRKSdX38DxVdAExG5QUQi7dJeRHzhtwW1lee9NMZsRZ24b4pIBdv2eX73\n", + "pbKIlPNrK+e5JqBCx0Xt7IH22R+hvEOZwGdAqr3PLVC/QkGD4RN2/0R0QB+T2072/kxG39F4UWdu\n", + "I797NBYYZN+7isCj+ZxzOPCgiLSx70uCaOgtnPoO5vfMNgBzAdfe107AJQVcb6nBE/yKaegU1SdQ\n", + "fkKdRr7fGGMmAf9B7Ycrge8JLU7XYKM+gH3AeFRTamuyh5n6zlEWeNbusxU1yTxmt31s/+4Wkbl2\n", + "uj8I/QD2oNP+8bmcPy88CPwGzEHNTs+i9tHfgd7AP1Hn20Y0Aimv98igZobJ6HR6FfB/AMaYecBA\n", + "4HXbx1Xo7MWHZ1FBsFdsNA+BPac827WD2iWouWgtei//B/iEqMnlvuR6n4wx6aggvBbVTLfaPpcJ\n", + "pK0A7uWNqM14OSqABtnjlqMKwlrRaJ+aOc9ljDmKCt4L0CCEQPvsf32hvkN3oc9qG6pIjMhnXx+m\n", + "ok7774AXjTHf+Z0n57lusv1eavv3MVkmx2Go7X4RKow/zauvxphPUP/DR6gz9jN0Bgk53sEAntn1\n", + "qB9pD/AU6ns6LSFZilIQB2tYWi9ghzGmZR77DEGdehlAP2PMgqBP6MGDhz8dRKQ+OhBH5GG68VDE\n", + "CFXjfwcNfcsVIpICJBhjGqNRGENDPJ8HDx48eAgRIQl+68Tcm88ul2GnO8aY2UAFEQk06sGDBw9/\n", + "HYRiNvVQSBS3jb822cOqfkfDpzx48OABAGPMemNMuGfmKTmUhHM3Z8SBN7J78ODBQymiuOP4N6PJ\n", + "KD6cQfbYXABExBsMPHjw4CEIGGMKTyQXauovmm79Wx7bUoAJ9v8OWA6aXPYzpZ3CHOI9SC3tPnj9\n", + "L/1+lHb/r4YpBkxGBKbqQ5hVlTAGzNV+dAd5LT1g0rEwzCMXYtZU1OMMmF6wuwdMSoSUP+P9/6P0\n", + "PRFSBsAqA+aEfTYDNFTZBNNeSKYeERkF/Aw0FZFNItJfRG4TkdusNJ+AxhuvRjNN/xHK+Tx48JA3\n", + "0jSpj+jj0H8BvNFe16cr8Vy+iIwlruffYFF1qJyRtb4dVJoI3ZPh1SSN0vNQCqgDg4ZBwtut4UGb\n", + "Rjcs74zjAhGSqccYc10A+9wVyjk8ePAQGDbBkIHQaBgk/GMOtL4Ndk9h7cYjvJbfceJK06hbaX37\n", + "UnjxW4jwc7HujwSOqZBJgbvRrOA/LJJEUurAoHiISoPD0bnwYp2OiIeo7xrCPy+A6e+E3p7H1VM0\n", + "mFLaHQgRU0q7AyFiSml3IERMKYpGFhszIUmEFLg7bj/RbKPZuKv4Ju0Dk6ewFlcuAj6M3Mrw9G9I\n", + "ifDTIgdFwtJkTuZFx2mWdLH1v7iRJJKSDK/6a8o9YHOSSMpik/c9Oh2w6Qwirr8SPhkLTYpgqAop\n", + "c7eoICLGBOOg8HBaI6d2tQmGnO4f2J8J4sp5qIk10TjZQyXFFQHuRGsTXGMcMzVJJKUu3B0N57SA\n", + "irWrwLt9YNZwPSYFJk0wpmcJX0aRoafIpInQ/YTAviioZA1gp/t1iSs15CiLOk7CTJ+fxaQ6ANa8\n", + "DY2CkZ2exu+hWJCbdjUQGiWJ4An/EsN0lNDvQvwYX8WVSGAISmd9rnHMWsD3XCYkiaRUglf7ZZLw\n", + "fKweMwDWbCR/k9Hpjphwot9Pgmc7wSUr1awF+c5kSh3iSgzwhSnDm3vnMycF7o6D6HQ4ZJ/H18G0\n", + "6wl+D8UCnzNqZwxUydBkjj+LnfiPAuMYI64MQcnWJgOIK5VRQrNDQLJxzIGcx/lMRrcf4t6N8VzQ\n", + "EyZvgtf+qAO2uBIF9CtzL+337ILXJsIFa7O2B+L8Lg2IK2EoI+gK4OnFap7J9gyyCHkLB4+d00Ox\n", + "IF6LufDIRXDmHfBhSzgednprV382JImkXPgM10Ye4uKONWVarbZyGzALmA9clpvQ92GxMRO+PWQu\n", + "PhHB4Ump9P0jCn1xJVZcuR9lhr20/DyeTHiP1ReuzcoqPc1nMs+jhW8GGKdobfKexu+hWOALLXx7\n", + "PHyTAM91gie6QcQiqoor0cYxpaJliSSlQJ1BEB8FaYdh0xBjFhco1P5o/oqTprajJDw2F5Z1ofO8\n", + "epwbv5QhB8aYBwvR1Ha0Qlear93T/T6IKxXQmeXdKNXzJcYxC3AgSWRZTnNJUfa/qO6PuHI7ynWW\n", + "bBxzpKj654Mn+D0UC/xDC3ushh6roVc9Nk++ggPAOmuCeNM4Zl+wwriw0PMkvwrD/OKfBzYSSSK/\n", + "8/0R/RU+U9vhcDgUAV80g0kjCf/PWprnXt4kT/gE/+rT/T6IK9WA+1Am4C+B84xjlvvv4/NjFMf5\n", + "i+r+iCs90EJPnYxj9hRHXz3B76FYkC200KddbeC1Y6+YCeJKC7Rw9Rq5LfpHyvVpw4FRDbKOLlgY\n", + "B4c6g2BYApVWQUZVOFwBHQRS8vU7+ITo4mpwTzNInga1IaEOvJckcnNpCj1xpax2kfr+S/nbSa4V\n", + "A9vjoGwm9FgFK6tA3NpCm9p8gv/kfTBAehmIP3p6+G3ElTOAh9DiNaOBtsYx6+02QQu2RPkt0Tl+\n", + "B7KtwGPK3k/D/YaYqhGw9tXg7o+4ciYwEuhjHBNoLeBCwxP8HooNeWlXxjFLgZvFlXrsqjiVO76p\n", + "x9Jb4aeHYU8CgQjj4BAfhZyAK6+HWffBb9fb9XH5CkOfv+LrMlB3vi0hpqgyUDNai03jFVfKoIK9\n", + "ATmEu12qovxX6/2WyXVm0jyuHW3abYEPP4OFNWDgZdBgTqEdmScFv+8+vNUOZteGd2w9roL8NuJK\n", + "OFpBrqiFbiWgCVqudA9aJrIH0Mc6dKPteY+hpsfclkMBrN8TyDGdP2LYiAzOjjoOsceyrj9Qv5a4\n", + "UgudqdxtHPNTIMcEC0/weyg1GMdsEOm7npg363H2a1BzvhX8UJAwDg5ph2n5IZgwWHyt3/r0fIVh\n", + "Ghz+mjgmph1jSvoRNsdDrbT8I5UCNV/5Cfb6eSzVgC2oQF9n/04mS8hvMY45nqPNxCW9qNViPnuf\n", + "/YaKzxsI3wiVPufEb81JE1fqErhwTQCaiiv1OlajPjvg0hWaQXrkK51NbKpDS3Fldj7tRRC80PX9\n", + "3uv3fxW08t+ZaDnIUWgpxNzaO2IcUyIFz3umyt46uawPJGpIXIlDayL/1zhmdEH7hwpP8HsoZaQd\n", + "JqMKTHFzrM9dGIskpZQn7OnmbG4YxzEyObRuB8efDEjjrrjmLS667QLGfheB8QW0DVgDG/ON6phN\n", + "zZkz6NKtbdi0SNjC9VfCDb/CwPm6PadGl82XEHYMym+Cyv9IkuviP6dZ+iGgAb+Vb8m8JvUwXcsg\n", + "B4/SbsVmkg6sRSkE9qL1hCejwsvfVFEVHSgu9q2z2q3/9tqmDAd2pFF2RDi8fxxOCLi/E3ZNRa6a\n", + "uJSuaS3YR2BCNxOtSbx/RSLf3Lyfy99Lo2qr7TApAcatZevGSryKZu/m1d6xoohKEVfao/Vuk9H6\n", + "15fkF5lU0vD3a/nWBRI1ZGdEHwEL0Tq/xQ5P8HsoZWwaAgMbZXe45i6MRZJS4qkxrDvra43hpM+r\n", + "Yj9keJLIgAKF/z2rWrM3cjZb3CNExMYQlnaU+ivHcP3GneJKZ/LSWCt3vp7doyIPlq0GwJtfQ9d+\n", + "cME6aLgXNtUmUVz58eQx9c5OYMOwWPp1gTNmQXpN2Fe/Npll/wHpR1gel8n3PaLYNzrc9qwsu6+v\n", + "yfEJuzlrfxpQHjVR5BSgB8hfWF8J/A0tpj6r9Szeez6abvd2gt+qwffvw5i9yEWfs+zbMaZLIE9H\n", + "XLkKuN445lmAJJHxKXD37jU0uuVs4mqsYMDmhcXn47A2+vOAx4FmwIvA34xjMvI9sBSQq18rsKih\n", + "l4FY4KqiDtvMC57g91CqMGbxBJEk1KYfF62a/sbXcnfs1hnUlBO1xrCGxdVgciO4egm8e8DUTD6D\n", + "98WVZeRvIw6n4rEMnpzsr9X+g/zNDochJhpgebWuXLNjNmN2buSxGXBzH6j/Ids21GAomiWr+2+t\n", + "9RbQno/HwqFKcCLS9r/vNGPGdhXpOQlGd6fKcqi+CDZ2hrSPovk8ZbcZN+GKwt5D6+AdCrQB2hnH\n", + "bBRXai+/jKaJTeDmhfDBZ1n7h5ejUSGaP2njhyy/jbhSBVizO5Wphe1vILACvwcq8KsDzwEjjWOO\n", + "Fsf5igqFjRoSV+5GZ2/nluS1eYLfQ6nDCvkAPpb4qFh2ABB+ApZUhcG3Q7NdsHcDR4B/o+U9cxPi\n", + "bwIbjWMeL2z/JLVnY6BO+q9jmcDXtOc1YmYdYlHzn47Nvy5zwsF3zdM59tfpyMGc5aV95qv4KACi\n", + "9kLSaOh1p0YYbT90lrjyd5QWbW0g2p+4UhX4DNgJdALKiyuvAX87DvuXvgE10rMfsyeeauJKvHFM\n", + "WgCXn03w+2Acs0tc+RmNNR8VQDsBwWarXo6adMoAzwAf5/Rj/BkgrlwCPAZ0NI7ZV5Ln9jJ3PYSE\n", + "JJGUniKT+opM6SkyqXg529MOH6QsAM13wdtfwNaX4YlpsLcaBhiOTpu7AgeNYzYZx+wEmgMXoFpj\n", + "ENg0BAauBkinF3OZxDTTeE3arJq3ZjTgMnGlZV77Z8HffJV2GIDfk2HMOHhxB4waD9tidwMXoYL/\n", + "d3FltLjyD3ElyQpEIOueX1BH5pRJY0P07/wO3Itmev6G8vM0rziOO59MJ1s/BsCaVS2ZBdwc4MXn\n", + "KvgtRqFmpZAhrkSKKzcCi9FQ36eBM41jRv1JhX4b4B3gcuOYdSV+fo+d00OwyCNhZfVMuCfQ8MbC\n", + "ZDr6bPw9WV9rDFkhzjcjW+dhBixJ5XuUkKwvqon+CowFbgLeMo4ZEey1qsO27inmKHGlP8qFc7b/\n", + "VD2v/bO25UwkG7AGZg2ybQoavnke0Nn+rQTMiF3LjvN/pPstsdS59VJ4ciq8VpP9q1oRTjj/BV4y\n", + "jtnuf3/r5rA5L0klDR0km+dk7TzlurUvh4DKxjEHc2wrB2xq+BYDm2ylfzDZqj4eHVTYbwAGA9+V\n", + "lK27NCCu1AFmAvcYx3waUltByk5P8HsIGj1FJo0Pp/tzneDMbdB7ha4PlOY2mIHDRvW4zdnSMI6j\n", + "vqiep3z7+waSWCF6Tyzx8y6mzIFWNENt8GOBz/wFY6iwgnE88FthzEj5DQx5nKcW0Ln6b7wg9am7\n", + "PQ6a74St8TBgPsyZzQ8/7jcXFKLP84HHjGMmBbD/BuB8H4unP8rcJzPa/UTjn+dQzbcukMFfXIkF\n", + "bgMeABYBg4s7dv10gLgSD8wAPjCOeTHk9oKUnZ6N30PQONiIaq27Q8Ie+PuCrPWBJqz4MkHXV4Bv\n", + "GsFt8wrOdMzPH5BtIDFAOlz7Pcenryd1y2X8hs4EnhVX5pE1COws1EXn7I8yYA4EFokrXxnHzAzo\n", + "uID9GifPs0Vc+dzE8FpmGMQfhvM2wNM/QtUM6AvhBbeSrc8+1s4CBT9Z5p5TBH/jGcTGNqfawYVw\n", + "+bXw5UcwLDPvZ2h5dO6y587i0fkLQFyJAMagRHkvlWZfPBu/h0JDXCknrrwx60pauFPg89FQxy+a\n", + "OlCa2zLRxD52AbS9VakFfHPPYBk868CgRyqR8EQ3OGcAZAqM3k/EmfPpaBwz3jjmb0BN4HXUD7BK\n", + "XPlWXBloo1SCgp1B3AG8bzXZIoe40g7YsKM+VW5aCGteg6Ffq9CHoKiFRwHtxJUmAey7jTzs/E1+\n", + "JW1ObaVwCD8BH7bS9afkNrhSTVx5BmXKbAx0MY65+o8i9EP1ZdlZ1hB0gL6rtE1ZnsbvoVAQV/qg\n", + "CSkT64zkpm+2Mviq4BJWbom8m/YVV8KvQ6G2X3zJJiq31JDHwMjabNbj1RVuo0PHePjbbzD8Cwi3\n", + "n5a/ELKsoOOAcbbIRU90JvCSuDILnQl8bhxTqAJ3xjHj7L15EQ0RLRKIKw1Q7bAP8FP9d7n3wCb+\n", + "VaWQ9zyX/h4WV4aRpX3nhzwdvIePknHJSvg4ER78Ge5OgX4LId3oQJSDR2cMGm5a4s7MUFBE5Gv3\n", + "olFXnYxjjhW0c3HDE/weAoK1Mb8GJAE3GMdMtTS36fklrJxCXdD9l+kkcw2wt9JPPBz5E3fX9vug\n", + "+tKIxbxaCXp1z4+szWpQnYC/o+F/08/4hbXzfqV1mRwJ+nlpwzYJ6FPgU6up90IHgVdsqKJvENgb\n", + "4G26BzX5dDeO+SbAY3KFuNIQDWnsi2qJtxrHvG3v+YEiohYeCvwqrjxRQAZsnoJ/Eww5toyWo5Op\n", + "NX0ElD0OFzdj6/IIPrYDy5Vo9EqSccyWIPpY6vCZJDeWhxuugGnvFI58zSoED6Cx+qdFprEn+D3k\n", + "CxtGOBDlJvsvmjV52Lc9v4SVbNErVZbBxQ9CtaPdmF/hedrse2rbDGOSRFanwN3HiD9nHx0qLk9Z\n", + "SfruNTD3CGSeStZmNcib0EiQ46hQ+adxzLakVEm5M4dmFqg2bCNWxgJj7QziElToviqu+BzD4/OL\n", + "tzaO2Seu9OeYjJH4botIrxJeWJppcaURmrTUG3V6pgG9jWPm+vYpKmph45jfxZXv0NDO/O7RdjRr\n", + "9hQsNmZCsxi5Y01vPkmpzLx9a6m48EqqE8ELaO5EE+OYXaH2tTThI6ebUwvKH85aH4hJ0tJMDAN6\n", + "GMdsLK4+Fhae4PeQJ8SVZuhLG4FGdSwuXAuWBrnbE9D2LZjxGIz5LJLMy9uZ8RMM+GWCSt8pMLYL\n", + "c3+DCx+FDv+BH/4PFsdG28zU3qh2fw5aOvBG4Bd/W+liYya0CBOSazOyUhq7zX4V+oXVho1j0lF6\n", + "39E2CuNSdBB4TVyZig4CXxjH7D/l4NTEslx6PJzuNbrx6Ud25S3niZy3FPY8ldcAIA0a3MLhWi6R\n", + "Xatz7MhG+s5dSqVjcUD7YtaUhwAjxJU38gnt3A7kSfGwPMN8Ia58NelumgAVUP66K4xjphV9d0se\n", + "vqJCc2tBO78nUZBfRVypB3yOVtCaV5x9LCw8we/hFFjGyEfRqawLDA2O4dBmqK47H2bdCxk+/2lu\n", + "zJs2qWlHS/joa6g/BXreBb1WJKPMi3OBEcCVial0rQNuPET1TJVscePLHMoAW4GziiLxx2a3fgR8\n", + "ZOPWL0MHgTcsP89Y4MusKXydQUz6tAK3tYHEMbDkGuDtaHiyLWx7NafpSlxpzNyKb7Lv4m7sGx1G\n", + "3Fa4tk9DtteqxrtlbzT7VxS3eeQnIB3oDkzMY588TT3iio9HpzWaONYQdXTfgSai/eHhI19bX4uE\n", + "e2fpuoJmkuJKebQQ+ovGMeNLpqeBwxP8HrJBXOkI/A+NvmhjHLMp2LbKszyuMd2JXXeEg5RlOYNI\n", + "pxe5M29asraYZxNo+SG0fgei1x3nkMwmijOAE8DyxFS65uVoW5LKd6hz9c7iyPa0wv0D4AMblngZ\n", + "cB0wVFz5HhhL2JWxHIuBz0ZC+6FW8ANyAkyW6cpG0zwB9GRW0j72jQ4jeg8MPAfmDYRpT8RBr9tQ\n", + "jbHYkCO0MyDB78ej8080Suo5dEa2DmUOHQb8U1yp7yuI8kfGYmMmJIYJK85gfNnt/PIGHMhvJimu\n", + "RKKz0inAqyXZ10DhJXB5AE5qKM+iH/A9wKehhJwliaS0Q4a/i6npW3cNjZhIva1pbB+QQ+uNALqz\n", + "L/IxYk6cw7pqu1lYYwMrDz9tji/92n5I/QEn+S34eSs159SCyBPQajuEGegJuzZ0Y//W+pSrPYJ+\n", + "JVkVS1ypiN63vrzX/iLW/XKqQhV1EXTbChV276DJthVAIkotPITUq8fDWDWlVP8VttuYSPpONWZs\n", + "12Lvf3TzPtSIH8Pm2gs5dnhvTp+Evb71QEWyeHTKojw6Y32DrLjyKrDHOMYVV14AIo1j7ivu/pcE\n", + "xJUE4AfjmLoF7Ceo4lQL9c0UK92El8DlIWj4h2ii0ReBRrHkiTow6JVoU3NQV3h8GlQ/CGNYQzc2\n", + "bPnBHJtgz9sUtdvfCGyiwrERQC/z0ZZstnMb/vaWuPJBhcP8BjCvFrycDGll4aI1ELmGKtvbUuXn\n", + "d+CVYq6KlRP2fr0LvCtDGl9D2ZuHcOS9k5msRA6CqOsh+gWot6MKyrkv9rrrUX5HJXxXfFLoQ0EF\n", + "YooC6oDv9CIb/lsGE362rj0lmioNiAGW2P+fRs1bOX0Co1F/wdOo7+BXceXponifTgO0Q82NBeEh\n", + "u2/n05ljyBP8f2HYEM3XUe1TQzSLpl056xzqJXaCq5ZClN/rXyns+CFxZQAq8Bui9UUvsuUY84Vx\n", + "zMGeqbI+Zv9lAAAgAElEQVQSaHD7XLh9LqytqPTMg1tBeln425XQfTUJZTbjiCvflTSNr9m9aoxI\n", + "Uhr0GIW0LUf5DXD+NGj1OuxIgm+bbOCS5W1Re3gi0IUui5ow7dpMP35+COu/EbO+ULH5wcE64K/p\n", + "DdvPhGlPnIymsuarfiiPTiYa2fVRPjPBWWikSyvjmEXiyldo4fPni6q3heF2KmIUKPht7YK7gQ42\n", + "QOC0RciCX0R6oFPWcGC4Meb5HNuroHbRGvZ8Lxlj3g31vB4Kh2zx9HLgMNf+tIqmXIuGaF7vH6IZ\n", + "0nk0EmjoyvbUmjIK2udwTW6sRweUQvg5YFJhk1lyVjlquBemroLr9sPDn8KyqvBNAqy+gObATnFl\n", + "GvCNXVYbx5hAyyIGC60x0HcBZnAXjm2Hne/Aq9dAo2+h9WMVUefzBNQxPNyM3/u6hLVIoexFj1K2\n", + "THVi98XR+bdoWqS9bfs/DaU3WFoQqVrhYR3wXw+FS26DgWfDuPfgCI1RP8+v6MzkVWBVfuY/6y8Y\n", + "jfo9FqFMqRPElX8XxQBcRIlUwaI92cotZ4e40gENX73YOGZzMfclZIRk4xeRcGAFyoi4GZgDXGeM\n", + "Wea3TypQ1hjzmB0EVgDVjcmaBnk2/uLFKfH0l94KkcsOs6DM/eaXLUOL5Bzlm/ah86GXaLmtHrPr\n", + "rqoxdffYFPbd/PYJ6vv2uTGKXTPjuWf1DvNRPk0VCH/GyTRI7FuBKmMugTUVYfAPWpylF0yamMqN\n", + "6LvZ3S6H2VF2GdPObc2qz2typJxtceBqmHlPUQp/zTye2P3ULSmTSJ14M3AFGh3UGo3+GAtM9g3A\n", + "1lZcD2Xm7EIWQ+d0dBCYBiwMtZ5s9n4aOPN9uPghWFEmnTabLzCO+cX252u0HuyX+bbniq8ObgM7\n", + "EEwGPjSOeS+UfoKSAk6A7i92hNijcOccXR8oKWCwsJnm+4B6xjF7ctneEI2OGmAc83Vx9SPXvpUG\n", + "O6eIJAOOMaaH/f0ogDHmOb99bgNaGWPuFJGGwCRjTJMc7XiCvxhx8uOusE41uqkOzLkDzKWTjJlQ\n", + "6A8m53R76jnldhxKzryWzSmRfPcM1J4D7e7PiMvYxplT2VVlH7uOHGHHpuAzTPPti08L/L4BPHIR\n", + "rAvjiKwhdddkv/dQBWkSMxp8TM2EppwxU/nwR36DmttTgroXeaEg6mW/ftUgaxA4E/gSHQS+NY45\n", + "kq1NNc2dR9ZgUBv4GR0EpgFzC6tZiySlIB1exwxvcHJllSt3c9MX6yh3PAy42ThmsbgyAvjZOGZ4\n", + "vu3pfV4K9DeOmSmuXIxq/q1C5ae5vKxMi76Uzisrwzg/fqi+MHWsMV1DaTs/iCvNga+MY06pXGYd\n", + "3z8DrxvHvFFcfcizb6Xk3K0N+If7/Y4m2PhjGPCDiGwB4tEX3EOJwk7n9zWA11doOUAg93j6vCGS\n", + "lBJBtX9V4vzmtUmLviR+KRO6Z3C09mHDV58L8Vs0HHFLO5j775j0FSMmzzg6ORett+iQrc7pOqKr\n", + "DuPQ6j4s3N+RAeJKF+BR45hFVuj8JtJ3G4xtSmQGVFuMCn0o7L0oCIGWlDSO2YaaCN4UV2qiFAcP\n", + "o4RvX6CDwHfGMUdtItdou/iqb3VCB4HXgcbiyi9kmYZmW24iIBf6jCZLPyR1Y1uWbazKlOWb2FNt\n", + "C7F7Yui08Cjljp+N+mF+FFf+jeZS5FWQxf96jLjiK9AyE/gW5d+7GDW3BQVxpW7MrZx5+RaYPgKi\n", + "/fxGQRDUFRa52vdtvsunqMmyxIV+KAhV8Acygv8TWGiM6SoijYBvReRMYwIq++ahSJCWZb8/KfSh\n", + "MFEjPg32OMMSdkgmk9sP5bsuD3LVvEiSx58tM471hMor4a0FsN8X8fbpOZHSbV5z5ptm7E8vLmdc\n", + "bhQG4oqDUk1MsrQET2pMub0Xx2Jg89l+RxR9BE0Q1MtbUQH+urhSGx0E/gmMFFfGo4PA9z6/iKWU\n", + "HmcXH+VxR3RG8CzQUlxZCEzli1qHoOffYXhDKq6BTs9D4g8XsTVqPM3TmprRM7bYNqLQgihNjWNG\n", + "2Hs3HKVsCDQhazQwVVy53zgmU1x5CY12CUrwiyudgTFygI+jPqNLdIgEdUGgPWrG9u+TAG8BB4AH\n", + "i/n8RY5QaZk3owkbPtRBtX5/nIsmM2CMWYMmeTTN2ZCIpPotXUPsl4dsKKgUYCCw0R/Re2BAB2jx\n", + "MSfenc/+H84k5pgdV3Y38RP6AM3KH+eHNhl0b3szcV0mQvdkDbUsxvKMCqshvwE0QZ2U88SVf5eL\n", + "X7CoLNdnZN+7sPei+GEcs9k4ZohxTCfUBPQr8BSwVVwZLq5cbPMb/I/ZZxzztXHMI8YxyaiGngpk\n", + "sqPu/TC8IbV/0VlZenUYsjmMt86P9qeEsD4GH2snll+mOyq0rxJXHrY27/z6vhLYQhbNw2igmbjS\n", + "urD3QVy5DdWq+6e/ZwbMgntSYFJfmJoCk2bBoBJw7Oam8f8TaIlyV4XkZykMRKSrv6wMup0QbfwR\n", + "qLP2AvRB/8Kpzt1XgP3GGFdEqgPzUJv/Hr99PBt/MaOwFZ9OPd5y6WCg8URY1RMQutCVh5jHlVya\n", + "cYSPYk4eEHEfJC+BBiegTBpnT97P7I1aoqu4nXG59t+V6mW3M9yUI+WaL+PCti5txjFiWcGhjCNs\n", + "emGP2eKWZH+ChbhSF7gKNZk2QrX9scCU/OLGTz4/yYQy6XCkvG6ofcFBBv7wDmoamm4cs93ONn5D\n", + "HbT77Xm7oQlbGWjIZj/jmBX59PMhlKBtoN/vM41jbgjwOsugkURd0USolYEcV9SwyYX7gZo+Wg5x\n", + "5To0Kq2DnaWVGkrFxm+MOS4id6HaQDjwtjFmmXXoYox5C31Z3hGRRegM42F/oe+hZFBYs8Op8JmL\n", + "BFZlKexRHGQc6WtimDLyCCkdIDYZmpWnTDLs6gRb4uFIOSJ3PojqCMEXWgkFxjHbe4pEDqlE2H3d\n", + "01nScy6pU6D/AmIuO0GHku5PsLAa+CsodXR9dBB4BqgvrnyGct5PO1ULtc/PhGcJfYA98iuwEWXo\n", + "HCaubEcHgRUoh7xvQNwOlEdn8LcDM8SVZ4FX89B4xwALxJU7rcP5f8BacaVOQTQg4ko14BNU4J5T\n", + "ylTGLYCNfkK/EzogXVDaQj8UeJQNHgJCblEqYbHXZCYe/GbBCfY7vul2XmGM3WnPJDtbLkmN35ol\n", + "WgGdqq/mybDqVAV4cTKMaA2by0H8TyyZ25uWoUadlCZsSKFvJnAGah4ZC8wwjskMJMrI3quWqImm\n", + "D+or2IDa9uejGbsVrQO3IUqJHQ783ThmVS59mgE8Zxzzlf39MmCMY/K0iVtz0OdoYt9TRZ+3UDiI\n", + "K7cAXY1jbhRXGqPhtDebEOstFBW8Yuseih3ZzEVxu2K4aH6k+Wxf61P3yS5gGtGXV5lIL9IZAGuK\n", + "0y4rrkSjkWWd7JKM+qJmNP2GDhOX0bL+Po3lMWjW7xUppGVUZinw8J+BSthy+l+NDgI1Ue15LP9q\n", + "Xo7M+ncFYu6zzss5qGMXdBC4DjXp+qKGpqNm3qeAfwGvGcec8IX7bjqPhtvrEFf9QwYsNmaCNVMt\n", + "ABrmRmktrlyLOmr/YRzzcZHdkBAgrgwFlqNJqDOBl4xj/le6vcqCJ/g9lCisZvaOccxZp2zzGyAi\n", + "2BVno3oOhlgtKq9+VEYjWTqjgr4Vap+eDswAfvIVAskt83MArPk5nHuWPUkFNDNzMfBYYWsPFHc2\n", + "cLCwWqpvEKiKbxCAmQVp0+LKTajzsrv9vcW21QToEr+U7s1+oVJkWQ7+2o2oQ3Fsrj6Z51MW8cgw\n", + "SNgeC03vhj4vs2buMR3sxZUPgQXGMS/5nSccvffXAn2MYxYV/Z0IDuLKHDQi6WlglnHMw6XcpWzw\n", + "BL+HEoW4UgcVHmeU4DkFqE+WNt8ZzSWZRZag/8VoScVc4Z/1m3MgEi34cjsasTEBcEwAVZNyN6MU\n", + "fTZwqLCkeL5BoBIabTcWjfc/ZRCw92MjaupYJq4swBYV8Q2i/4MEQQvbtzufzEXnEt5iN9zwK9y8\n", + "CG6+HAbOg3eWqnlPXGmDZvY2Mo45allhP0JJ4PraENXTAvb696L9jUT7V6qmp5zwBL+HEoVoofI9\n", + "QHRx2catJphEljbfCbUp+4T8dOC3omZBtMLoIbSYyAjg2dxS9U/u7/NrtH1Ls4FPMmwWbTZwUcJm\n", + "o14NXIMmVvoGgV+MY4zPXLMqhWYHY5DKn3DHklQGAUOMYyb46BMuv1bJ8nrYYOHzqrN/29WUPxQJ\n", + "738G6yrBV00gYoxm14okpXDrppEsbLiDTdE76Te7AWVPfA7cX1jepuKGuNIOpdNYh1agK3a21MIi\n", + "WNkZahy/h78orFadCcQWRXsiSSkS1uNbiem9QKqct1IurzAHpS8eg8axT0SdjrWMY/raGPcFxUF9\n", + "axyz3zjmCXTQiQdWiCuPWP9BLp2Pi+KihyD533Ak3m9D0WYDFyWMY5YZxzxtHJMI9ESrcL0LrIu+\n", + "TT5pUIf/ToDuU6dT70gj6raJ4rUyu4nAZu/GQ5QAD/0E/frAsDbabtXtnFj2BgyaDX37wv6y8F0D\n", + "2BPDsZMzox9GV6LD/mbcsKoz359ThtTEiaeb0Le4E41A6306Cv1Q4NEyewgFu4AqqNAoNMSVSkBH\n", + "Zla6iXLdLyHtgygOhWkC/tf9tjHjpzvMzlWjirLDhYEN17vdUhYMBlbajOD3TVbxkShuqNyUiObw\n", + "9k9wqLJfC8XPp++PYCmLjWOWAI64kgokVd3MuJW9qVMzCi5cA+1/h9Zn0fCHjcjmyir4fXVoO25S\n", + "CoWeN8D6CnDgB9bebig/7GcSeq3SQeHoCTJnXck6RtokwOrPQflNMPlF+OXear6qZMV5bwoLcaUr\n", + "6nN4wThmeyl3p8jhCX4PocAn+NcXtKO1z9clu9mmLjCLeYkNOPBRFNf2hnm3wqpecOzdGuxKuQko\n", + "NcHvg01UuspS7z4PPCCuPIaam8ZT6cAq3kg4yPHKfiReJZsNXBSUxT4+o74iv4+BRi+eCy+dC2Uy\n", + "4YeGELeNCkCSuCKJfvTYjffAzOHQ/Ho5caBhWJlNozIfSDnIHXE7ia70NodP3EX0wUb049wta2N/\n", + "fo7ms4YQO7MyByP+j+UcIf00mxlZavExaATTV6XcnWKBZ+P3EBREklIY8Pv7zGy2hSUVt+RSri8M\n", + "NZX4nLCdUAeZzzY/A1hkHHP8ZFbpHa1g3PuwzRcoVDKlBwsDO4CloIyTddHM2RtJTewRSmZ0qOgp\n", + "MmkidD8UAZ+0gL/9piUpg8mZ8LVlgB43QLe18P5ZsEHYd7AqEcA2YGzVYbEVGmyO7xdN05iDRLEs\n", + "4lYO9r03nVpb1hGX2cXYylviSiywLWxHmTLV9p8oM+fL45xhU7KuoTyTqLFqv1neJK/+lCQs8d0s\n", + "tHbzK2jewpH8jyo9eKUXPZQYTtpq92RUJrxnZbihJQxIkDPPSOSKzRGokD8XZXScAUwGngTW5O4I\n", + "TjsMBiqsh331/daXrKkkENjkpR1AOTQ0sivwGalLHjPO4lJz5MZDFMCuGBjaHl4/G96YAHFbCp8l\n", + "7V/s5o0J0GEARPwYn3EwMSKeT9oYIg5W4bzFXXZee7TNziPlolnSGeYPVJ6mUX3i6F0nnrO2/Cyu\n", + "pBjHrDOOOSiufN1mWFTvy5IP0OY2+OhTuHAtjGE/HZBqBfeq+GEJ6saj3EKLgGWns9APBZ7g9xAE\n", + "rK024x6I2WXXDW/Evg6Pw+YRwNsoH3uAttFNQ4i5sTEmrCGHK9h1px9xGoC4chl6fbcYx3xhhcWd\n", + "KBvleCDVlEIFJp/Nvc4BmDECRraCS68Ds4mG4koVXy5DIMhGdb2H6CNjqyXu/r1nZbpMEk4Mgc0t\n", + "KjBq4NmwfTO1nqxP4liI2amC34TB5x03cNbHnwI/iSuXGcfMBUbFIVc9OQ0uWwFV/QJuo6ulx4or\n", + "g1Ee/yXAclNEFeEChZ2hvouGrz6JPtM5+R3zR4Zn6vEQEGzWpdrmh3W7ic3fx1J+A2SWhfQadq/g\n", + "TTPSscbdtE0bzGu95peGqSQQiCv/QIVCb+OrTOVL3IopE8eF82px5uYqhPMG8LxxzL6S6ltuNv4b\n", + "oln3yc38eqQGyYADDAuGSVKkxy6YVJnzn9KB/us37ZaeR2FimVOP0DBWcaU3mvnbH5jc7rlyh+Yc\n", + "PnDKd352+eijc+47NBitQZyIks9tImsg8C0rimtAsANPV5SD57C48j7KeZRv4ZnShmfq8VBksNpP\n", + "C7I7YqPx2eaV2CuZ/fVyHKmmmaCiSy7evhn4wZixfYr4ckKGvR/PAb2BjsYxayFH4lYG8AUw7dr1\n", + "/G1ca6oeXSmuPA+8URLaazYt3ZecdojXDg81E8SVVijP/0BLmjarcK3Hq5yYPQjK+vOlmWMwcOOp\n", + "/D86UzOOGS+ubEW5dwavTDix5prFcY3GkH5SUF1L7PFlSZnHgf/4EaFFAo3RdzAR5Q16HGgormwi\n", + "+2CwlBAHBHGlP5rPkOzXTjvUxv+nhKfxe/BlKLYjyxF7LhpD73PCzsCv0HZ+hF+JLCGX6JLVM+Ge\n", + "/IS/uHI/UNc45t6iv8LgYU0576LEZ72NY3af3OZL3IrMgPOfhG9fUPZLrav7AMqa2RqdJXxYkrzt\n", + "OWGd0tcDL6Bsuo8ax+wI6FjpuRMmVjl1S89dsOnmgpza4kpDjoRNZX3tCnHLI+KaLRBiyeQgGZnr\n", + "CBu9O3V7BJo9/O8CrqEM+l4l5lgaoCYa/8HAN0PI10YvrlwIfAic56OZFlfiUQd2hdM0v+AkvMxd\n", + "DwHDVmo6lyxtvg1KROWLuPnJaEnAvNvIg9/fFxGyOxoqHIZw+3oVFF0irgwB1hrH/KdILrIIYPMM\n", + "xgNbgZtyapUno5E6vgC15sDHPl6xLJOXpfF9Hk0EexSYWJosoOJKOZRU7SaUf+a/BSXBiSQ5kPw4\n", + "DPMr/DLgGMwabMzigOoYSHy377n6WDdqz4H/zoNdiXZLyiRSJz6JsokmBCNo7YDQmOyDQQt0QNjA\n", + "qSajlcYxR8SVROBH4GrjmKl+7XVBWUWTC9uXkoZn6vGQJ8SVM8geVtkQLZozA2VVnGWcwpXCzIvf\n", + "3xddMvg8GJ0EVy+BaxdD7O8FRpfUB34oTB+KE+JKAzRb+Evgkdw5WtIOE7UXzn0RRszwW58VjWQc\n", + "M8MK/8uAl4CHxZVHjGNmB9qXYBOzcoM1pzwoWjz9NbLMPzPyPMYsdrV+cM+7CIuJJfJABEe2DDZm\n", + "SeDFa9KrhDPyfbj9TLj2chjxM2RUAeKijWPmiivrUAqJj4K4pqNkCfWTsANCE7IGgqtQX0cDazKq\n", + "hUac1RBXktAB4Sh51Nj9M8HT+P9ksPbo5mQX9LFkj59fUFxTWJ/GD7CiMoxJ0gFgTTSHj8bxOhoq\n", + "Nz+n1iuu/Ipq1QuLo1+FgXSqPoiOe19gdpNNTK2zJi+mTZGkFLrzAWWSK/LlMLs2O8d9tv21mtPN\n", + "aHGTmcDjiakk5CfU80jMKtB0FtB1qvnnajQnYQpKS51vcRHLnzQbpWB+L+Bz+cxikgndnoAWn8KH\n", + "E2DPIJ8j+BJ0BtK2uGdEdsY7DViJzgZ8s4T6KC9PLFp/4CO73TcgnHbwTD1/UVitpi1ZQr4jyijo\n", + "s81PR1/cEnnQuQmqW2DNhLN5eVsKtdE0eNDMyNEoDTLAPqC+L+mntCCXVkqlRcYTfDEqnJWXwokI\n", + "cjJt+jTwsAqUm3Q7Z8tbHZZk7q2zN9BoJEtwN0iO81jCYszU7yhf05Je5BTqvoH0+wYQfRySN2kt\n", + "gaIsZiOuxKHO0wGoX+L1/BQDS172FdAiP/K6bMfk9Au1fQu63ZvJL/EPmyk7XrEKy2LgLuOYYpv5\n", + "2fN8jJaQvMn/u7C+rqaoD+RzlJcoEU3UW0d2/8ES1O8V0oAQ6mzOE/x/EVjmyGSyBH1btEyeT9D/\n", + "ZPyKZ5cGCqA+FtSncI1dDqIf2d1AuVK2f99BRuS/+XB6WWosgiZfwiej4VgsvhBF/4HtH70g5hjs\n", + "nxycBn5+vHzf9ly6vXMWzH8L6tnSJBfDvHDYFQ9RmdDqU6g4Kgme7AYVD8E9s2HcEqZ9etx0yf8M\n", + "hb7+psAQlOr6LuOYKfns+wYQYRxzW8Dt5/QLpcyaydl77wJuN475zFa7utI4JqWgtoKFuPICWqjn\n", + "4twcv+JKRdRRXMHnjPcbEHL6EOoCaznVh7AqkBl1UczmPMH/J4Vo4Wt//vkENLHEp83PMqVbkzRo\n", + "WO3rHFToX41+NKOBMcYx60q4H88CfXjz4r3s+OYcwo7BZQOhyjIY9SUcvGuqMWO7+jTw1ZU0o3XF\n", + "a1D5UHAaeF+RKWOhy/ZYqH4wa/21cGi0rUv8BFqhBJTzfkJjeLUDTKvBkWMxPIs6Z4uMRMwOzH2A\n", + "f6PmqAdzS0iz5pKlwBWFDw/N1k4bNBD2ZWAoqllfVNhCOAGe6zbgfjRsM9eZio3yeco45rwA2osi\n", + "+4DgCz+tgw4IOcNOsw0Ivnfpg1bQezksOKoOh2WwJwPmBKL9e87dPwHsR9eM7PHz5cjS5j9A7fOn\n", + "pb2xsLAO05niSg3UrvoKagqaLa6sRweBscYxvxdXH/zCNesA57Ij7EMATkTC5+/A+U9B/44wtrpA\n", + "lvN6QmO4b6YKfQiugLwv29Zf6AM0huilVWFQT0iYB/evgFeOa4TUpSth/ErWLG3Py1t70RpYLq58\n", + "gRY9nx/UTfCDnXGNE1e+AR4DFlkt+T/+751xzD5x5UHgv+JKu2DpsY1j5osr56KBAg2AN1Dh3D/U\n", + "a/GHuNID9a10KsA8FbBj10Z5LbKL/7miyRoQWgA32P/PEFfWYAeCtm2os2gzDLwUqi3RWpaDtYlK\n", + "QPfCkuwVBp7GX4qw9vk2ZGnzHYEDZI+fX16a5o+SgLhyH2rfv8f+jgDOx5biQ7WlMcAnBYWZFgR/\n", + "m+quODKn3UG1zFiWo/beQ7nmKHTosJMLfgkn0vTokcq/fM5rg9rbITiNP7epfn841A+i20bClPow\n", + "rR78ICBroNwhDhw5zq41dXl366W8ahxzQLT05ACUYmAD8CrweVHVKRBXEoD/oNm0dxvHfOe3TYBv\n", + "ga9CDcO1M4jPUFLuZCCxIEdzIdpuBXyPlnX8qYB9P0XfsyJnhbUDQjPszKDiem6JrUi1zeWgyg44\n", + "fyck7oR2WyDFlq4vMAzaM/Wc/rAx1MlkafPtgNVkj58vcZ6X0oa48iqwPrcEHjs4Xoz6Ay5Boy3G\n", + "AJ/6J1MFAn9Bu66CcsiHrWUf33DD0uPm65PnzCVHgdQlEcDbNb/i9V5zuSFn3d5gC8jn9IekQ9Vp\n", + "6rfJhovK8u13j/E8WvT8PKA9mnsxzS4z7fp70NnLG8DwQJ2vBUFcuRQdVOaj1bI22vVNOS6/8Gan\n", + "+eypIaHUG7bPejj6vEcXRTKfuFILvTePBiLMxZUNwIXGMatCPXdBSBJJievAO41rUC1mFnSuBkuq\n", + "qjLxzPe6T1+0clme/fUE/+kHcaUm2cMqm6DTSJ82P9M4Zn/p9fD0gCU3e9c4ZlwB+0Wj1aKuAXoA\n", + "P6PmoM8DuY8+m+qKynB+P3hsOtz9S+DauuXjH1fte8a2nU6T3JzXoSKvgvCzYGQdSPZFf6wvy9Dl\n", + "Tc5ozJYGtxJZtjLR+8vRdsVmkg5MQHlu2gAXouUUh9hiKyHB3v+HgEGoWe5lUhMfpWLVxwmvEsmu\n", + "pqjMHhl0vWE7i3gVncG0M45ZEEJ/Y9FB8TPjmMEB7F8NDfGslHveRtGj7F0yqe4S6jSdQs2voGLO\n", + "7Z7Gf5rDvrBNye6IrQD8RJbpZv6fleY1FIgri4B+hfnIbQjiJag56Hw0Dn008KVxTK4VwXzO1MMR\n", + "8HMd6GbdxwVpVTnO2xiYBIwE3OIww+USFTUrGW74nx0MBLiQ+C0/cIUY3q158sDw/ps478tJdNlV\n", + "FX3/0tAw2YbAbyjf0IRQhZpNbnuFo2Fn83G3yqz6tmzW1sdRS9hzIdUbFlfmoN9TL+OY6YU9vkUZ\n", + "uWTb33g7+hAnWo5h0e+BOEpd6Qk8YBxzYZDdLjREC9jfnphK5TwG/Hxnkp7gL2KcZF0kPiq36asl\n", + "kmpNdkdsOtnj55eXlObwR4UdMEOK4bchrr3RQaAjGoc9BhVyJ7No/ZPL/FFY+7y4Uh0twr0QuKO4\n", + "kuHsvWnS+Hs+bVeNxCn14dv31Q7cnXZMZg40/QIiD8Li6+xRJ5kxfYl856GskxejDvTDaEbyS8Bc\n", + "4xhT0LueZ/9anTmXrofasrMFTPo37GtgtzwJrAipiI64cg4a5hsODDKOGR3osUkiKZmX8GGtSlSY\n", + "+KFWEAuQL+opIMY45tFg+10Y2MCCPUBl45hD+YVB59mGF9VTdMjVwVf25gTpUbk1yXvKoMK+PRqy\n", + "NR0VMncXZ/TJnxg+Av6gKYytmed94H3r7LwCuAN4W1z5Cn0+kxNhZn/oPAJifMcOgDUblbqgMOfb\n", + "LlqTdSwwXlzpm9csozDwi+rqihaW7wIcPVibshcth8HfQ317l474atyfMQuO+te71zKGVuHwhRIO\n", + "tW03RKNlrkerTB2Ra8stI6pPXQ6/70fCNrCRSBIFCv/fmqazdCQkvwKdnyErezmcUIvoGMfMFldW\n", + "o6GeL4gr9dD6t7lqqv6DV1SHem2r1tsY9/57hpGtoP8CGAYJKRo2nN81tUPfo6BRyISsViiR3CHA\n", + "F71TIlTknuDPFbbQSLXF0GY41J0OVVY0Yk/YA2is8Yuofb7E+Nb/xKiPOnaLZOppHb7DgGFWM78K\n", + "eIhMPjx0JSZxITGPr4PIE7AQMlbDyGDs88Yx6eJKb+ZW/JpFTX6Xf125hMyMtMI4Nq0wboEK+K72\n", + "bwZqtpqEOiTX9xSZ9PccM5Wy2BjQmJ0BVS2z93cNaot5XFypAzxKg0O3cfnecGZ/B2svQA1JwxKI\n", + "ueApceX7/E2TaYfJLAszHsuxfmFGERXReREllEtGZ1gNxJW7ckYsZVPUmnzF4Y4zkLd7MixjGlN3\n", + "pfLHvAcAACAASURBVDMzHmqkwXFNTMsP7VD/RVAIou5xO2BesOcLBZ7gzxXxUQCEH4G0mjDxNdjS\n", + "FjJv/NWYsY+XcudOCxQhcVh9AijWHgysZv4uMLXJ93zUog4tX+wDB6LgpkVw72JinttIh6BPkJp4\n", + "ESQ3gGHlUbZTrLbcHuok5zSdSFadg652OQ81D05BKRAeMo7ZkPM0/qUQfeuOs2Kr0A8Tu7cmB32V\n", + "CwOvWmYcswm4U8pe3pKklM70uBfm3g6/3KU7VCAR2G1t7b7IoVnGMX5ZB5uGQP9WMCLLz0C/I7D6\n", + "hSIqovMVKvwT0Hvlm2Fdk32GZRW1Ggug999h1Jds3NeBkbRnzaaskPz+KoRTcntPbfRPJBoSGxTq\n", + "wKBhkHDuLTDpAyh3pMCZRjuULLHE4Qn+XJGm9Ltb2+pyEqdfDdjSQBCaTa4QSUrhgobPUC4zXkm8\n", + "Ch8GaGP+z0CTfxr6/fX9Xw5Yv6cp1Wpvh4d/hkoZsD0O7usOS8vRzVJCj0YFWyF8MlbgNPwWNnSB\n", + "zDKoebDPw/B5DHICqi2GhAFt5L4yK6lAM9SkNRWlez4ZFpkfciuysp201wxzodKGDzm2dx38b3tQ\n", + "VcuOHs5g/kCYPwDC/VwVW8rOQH0m56JC92ngLEumpwNB9YYxbN9n1KYfDmQCB3ZTRCULjWNOiCsv\n", + "o9nDl9qQ0jeBaeLKJVnUJFZRa/UBfD0UftexvA6x7IiFqgd1HjMCYvIRwu2xPo9g+xsPUZkCs2tD\n", + "rF+KZT7JfW3t9ZQ4Qhb8ItIDTfAIB4YbY57PZZ+uaAp4JLDLBBhBUXrYNAQGNsqrstBfHT7N5qq+\n", + "EHcUaqZBUjoJP59gsLiSjhax2Aak+T6kXByIMyH5BiJjEthaH7ivdm62ZWsOqcypgt339wy0qPta\n", + "NN1/Leq89P3eZhxzoqfIpNdzmEse+Qk61mTWz7exEzUPxYsrY1CfwLyChUB8FBGHoNNz0KcfzL0D\n", + "5t0KB8+Kodk4uGwALK0MsxOrsrBaDEePzuXYlqC04bzsv+LKHm6c3tc4ZnVh21T4veuZviqK+q5b\n", + "38lEu/jI5c5BB4L7GbC+C7vKhbOhjg4cO1oC1IKUgmzphZkxjgT+Ja40N45ZJq7cCvwTzfhO0TBV\n", + "q6hNfjnbgVEc5OY+WtT9gZl2XcRJn1JOhEzFnAaH90dB/NGsOhQA6ZqUlg32XjZGo61KHCEJfhEJ\n", + "R0u6XQhsBuaIyBfGmGV++1RAk0m6G2N+F5FcKvmcXjBm8QTlH0/Jt7LQXxU+2oL+C2BbnC7/z955\n", + "h0dVrH/886aQBBISivQqQZCE3lEBFQXitSLBXsEu2Ov1nj22q15/Kui1oSBWmgWVgIg0pTeRKhCk\n", + "hYDUEEpIQub3x8xJNsmm7W6K1/0+zz6Qc+bMnLPlnZm3fL9ba8PBujRGV503NC/Elr0cDz7FdY2a\n", + "cqRVJMcaaI3eY2P7k35XGHWfgh3nmZ7HxlKr36uGL8XdwOegDbljzFejqzy3ATtKkyLryV0yHJLT\n", + "UnlZWSoJbVzi0avcLwBxmwTWep4E0jPIjoCPf4J6a6HnGLivDWxqBmv6wptj4eRK85ZQA+gHIxqX\n", + "KnBaetRDT3xeoSzfdWWpE2jhkrkAEjJkPg0f6UvzBRDqbtsii6WvcHaMbwcRG5KjV+NF7RiVpU4a\n", + "QriHgBHmc3jBUHrMFVuugbhCC7UwrjtxP5uqt/8eeg6HTnvhwj8gpRFxYktND/xW3dDxO6+xC8bc\n", + "WZ22tU+Sq0laTPJAR2BDZaV3+5TOKSK9AUspNcj8/QSAUuoltzb3AA2UUv8qpp8ql84ZQNEobVqk\n", + "ybVvyOddPiXkiR7U2qYD5TVT4NReCGugXSE/PwXzjKZH3YF7uG/WG+St3v/wF1VzadPlzC6jM3oS\n", + "cBhEJ6HJ4zbltvOU/RVx7Qm6RFenRxJMagt7ZkHbb+CMDbDuGjh8Jk7Kpa/PY1aNh4CIyqD1yOXY\n", + "L4Tin8/5/rzWG2a1gnHToFE6dCB6xVp6H/QQG6kLbAHOdqfsMJlVk4BHcMUddK+2rsWvS4aQesNY\n", + "iJ3bAq4bAueNY8fs3qw73INQ4B9OGq75vPcDHXxltq1/now63olnE95idQnfsfuB+LKwm3pCZaVz\n", + "NkZXCTrYjd4KuqM1ECoic9Hyc6OVUp/4OG4AlYiiVs8FVzYmALdFXIknYShE79SGfm8XWLEL0sfB\n", + "EzGwxK0y/0Dwb8pS/ymP+y5tupwxoquAVWLL4+jv9DXAT2LLfpxJQKnCq+WTO5ewsPcNLN4WS9go\n", + "3eGRFtBqFgzvBYdbQnJ6a7GlkR/os88A9lcel1NBl+gC4LUTEN64uJiNs2O8fymkhUHnO+G2SZFs\n", + "3ZUQB5+77RYc159Kqn2JLIxbxsJEl+xyXENKqSSx5XxgOq7142B9gvt7ES+yPAHuj9xORPVfqf/l\n", + "HYTkRHANOkj8X7HlTtO+OZDpDzrzPwewCVg6WamLS2jaDV3vUynw1fCX5gsXii4fvxCdP71YRJYo\n", + "lZ8LQ0Rcbn/OU6poLvAAKheego3FF5sYH2xaM/jamfMXQPgNJ4DqZDhu16oXRzGGYQmwRGx5GF2o\n", + "NwztY96Bi0mw/g6TJQOASPxyci67n5PSE6jF3k4w/W2YMRpazoEeN0YB603V5hdoSoEy8w51b8k/\n", + "NyUQM1hkpi9yjN4iv5souzE0aQXfVAfa65fnegCHlTQ0B+x5MHgrXCBtOcnnEXR/G36/DI42QU8o\n", + "CffHi3BFEPHjcmiOdv/luoaM8e+NzgBqaYx5FuSf6M2q/nO023kY2ug+gs4a8qfUYm30LqwkdEXH\n", + "RssEEy/tX9brCsJXw5+CJoRy0BS96nfHLnRA9yRwUkQWoP1b+Qy/Usrl470EUIEoW7FJ4WB5FHZq\n", + "yzoLspPTcsLaU/foRhonp5FjVeU4ihHmmA/MF1tGoqkihgG/ii0b0ZlBU5V5b7QraMQYGNsK0FTP\n", + "ez49RE5GCLrqdym6ovZVseVn9CQwraRiMMdHfmUIsW8egRnlTOFbHBztZZHBMwl6vz1hhyD0RD7D\n", + "TYHvScEdY6/dUIOojJMQTrVjemf0xTSTURcZ0RRGfphD8xfPgxt+g2Zp+dMklaX2GrfPF6SHLJXq\n", + "Fx7kZJ1Qd3eRspQSW4aj+Z1uBi5BT+Z/oA2/XzKRKIXhNy7QlhTQCC4NzIJ4Xm5fIlZZ+wDfDf8K\n", + "oLWItAD2oH8E1xZoMw14ywSCw9Db5td8HDeAvxAKBhCj2VTjCtY1vjxKNf3oMEzjUK0RHIpZXNk3\n", + "WgaYIqIfgR/FlnuAi9DuoOfMSn4iLr7CxUjoaxNSI47g0DCyTqTydeOnOHtTDTSTZj00h85BdEXt\n", + "22LLTPQkMsNwvueDk1X1UQ2oZ7LqS1mZ6hFmNRwBRKPTX6NL8/+aa2nadjlNayhCu7Wk2qae1TjW\n", + "PFrHMd536pIKB3o97RiP6PehCwsfg0Ot4IZBuhJ407GTURCRI5AVpN1CjyyChxZD5Om8NEllqWMS\n", + "dvZ7DD79Kbfs78xnE8zkk7frUJY6LrZciWbrXANchqb32I4uFPMHaqOlT4tDJ2B9Zepq+GT4lVLZ\n", + "InIf+s0LBj5USm0UkTvN+feUUptEZCbwGzo7Y6xSaoOvNx7AXwvOyhB0cO8j6PZ6TB4FgS+Gq7Jh\n", + "fsDTgemGwXIQehL4Dw/9voUFPZqw7osI49KKI+TW/9ZypX3Qk9QjJ84kdENv7j9wJlEE8zHwHHpH\n", + "PBJNOTENvROY41SsOj7yw+F5hh+gWhh1xZbzKGysSzLmNYEstBZEmnl5+n8KWhshrdG3tLn4N+4c\n", + "n00uX8SwP84kidEc4xK3d8dz7UvBHaPZHelA+cYh2i14bT/oLcePjkeCFVjz4cbf4IFB0L4zVJ9L\n", + "jXydZra4j2lJ0fR5VU8c76wBlX/XoSy1TWy5GT2x9kBTWExDB3f9gVro96k4+NO15BUCJG0BVDgc\n", + "lsyXz4HoU3CX+QmUhSXTG/ix2rhUEFsimX72L5zZpiMt58DY5XDwLABiqvc4lZK1POxomA5w3luP\n", + "PT8PYFNmHbqgDcdCdFVvV3S1b0102mZ693E0X7ZTG70cgSDzE+7VjPSlt7GGkg24+/+PAkfLuvp0\n", + "MnOOhsGa+nCeKUPrzkBWMNO0Gp4MS0aWmsIinw5C+kkSlqbS4/BNoQfZfMN/CR2Xk5dMcGE7Uude\n", + "gahqLAIeVJbaKZI4DyZrHeLqB+CEkzmeWIgwTmx5Cr3ivw3t798L9PGVhsWpFFeWGl9Mm0/RE/k4\n", + "X8aCAElbAH8hOMG9xwtoIXkqdPEX/FVtDCC2BFP8ajrv2I4mDVj+NYSlwamauX0cOaN6WMxNUPsk\n", + "RGdAzVM0Cs8gLFP7b+uglcdC0Kkyz6LT3bsAfVfcyKl2q8n+bBXRnUxy43BIPraTkaYmodzh7DqS\n", + "a0HiUHhsITywBGJYdAgS13pT++K+K3QgtozOqsO8jx8meNv7/HJGGqd3tqB7Sgivq2q8BTwGrBZb\n", + "/g8ZmJmbbnLCvVzI467j3+hJdQwwBz3Zfim2DPbRBVOa4G5X4BUfxvAZgRV/ABWOYsRGvFKxKg2c\n", + "FWpGCBwJ16vso2FwRy2W/zqUlymDbxtt9NIpegWdd+z1fneQNq99wfs5J6Q73LSC7z6HWsaL777j\n", + "MX73PmiXz0XoCtY3laW2ii3tw1P4p6rJpcGnoe5mUrJTeSVllRpbcJzygnstx45ouPIaaLcf/vye\n", + "WbNOKQ+5/d7DKHPNR9MqPIDmhhioLHWFOX8m8AYborrw9ZAgssa7cQcVvesQW6LQ/v15QCLwNdrl\n", + "M9zbFFmx5RfgyaI0BIwK3x4gxh/ymAE+/gD+UvCGe9wXOO6lBwbBxHhNoBWdAdsURw41YS4lGfD8\n", + "/z9WWsPgqcgrjOtOfMl31RM4hvuXvihdAMOkeTdaW3cZWqHK0b51agyGAanoeMCk0nAA+YKCk/eJ\n", + "UIi7kmM7W7IvJ4ILPZHN+QrRou8PoVfondHC6b+7nb+EDVFj+SU+iD8b/EF2xpGSdh2GhC4WHZdZ\n", + "j95hTVGW+reX97gBGFqU4pnY0g94SVmqtzf9F+ovYPgDqEx4K+ZRUfCXCIs3KKjh615V6rQpldqS\n", + "Dhxfh84GCkEXzH1sslWC0bTO16L1CDaiJ4EpylJeUzoUh4KT9w7hzQ0WbdDul+uUpeb6e0yx5XL0\n", + "cylgtrLU5QXOh5vxR6GzB18tihbBvGdHgDvQrpdu6CSVxcBjylKTvLi/vUBnVYRQvKkFaaEsdX9Z\n", + "+/bYX8DwB1BZ8EhdwAivdVfLA5XhXirpfrzd8Rg3UD+0cTsP+Ah4S1lquzlfDT3JXYPOV1+KNpZf\n", + "V4TGs9hyIfAZ2o8+xt+VxWJLPNksJJiarG2Swrdnryd7z+gC5H4t0QVS7dAiSTMLLU66rfmGf6Q+\n", + "rCzVWmyx0XUZF6KVy2YDVyhLLSrDfQlwCqjpKQ3XtPkCmKksNcHrN8C9v4DhD6CykMvZcn0CzHoV\n", + "9rczZ/zDSeMvVLR7qSJgDNw9wK1oNbjRwPw4F4ObwsjwMKpvjAtqsjUuotbpphlR7Kl5kLSccXRM\n", + "e86QrpXXfbVA+8x/A+5yl8As1fXF7CBF4hOI6vAWd81qSXCmpsT4ptVO9m65u+BCQ2y5BBjDkdB9\n", + "fHxFQw5NbpF7stu5++izbJMandnfaCV8CyQrS40SWwYB49HupORSPnMNNIVG9WLabAauLMoVVFYE\n", + "DH8AlYbcNLqRsfDpDDjU2pwpnEYXQPnAGJ0bgZFBGUT0nEP1n1ZRL8KED4fRiunhL3C87Qno9NQJ\n", + "mu5VBPMNeifwY3kUExkSuQ+As4CrSht3KGkHmbvQqLcGbj8HjjeAsMOwKmYT522LK6ipILaEs7TZ\n", + "Wtofi2XJg7DwMa2dMPh+yErapH5MPtu0i0FX8D6rLPWJ2HI3elfVR1mqRBoGE4tZrCzVpIjzMWgm\n", + "gxhTBe4zvLWdQf4YPIC/OwwXT7V0yIxyOx4QrqkoKEsdV5Z6F4hr/x0H6rSiXvMHtSgIwCSSOTvz\n", + "Pfj1VvgotTpj+i9FcxA9BewRW94XW843fm9AG2CRwTNFEufpf+MTynhPJ4Dr0ZPLUhPYLAWajkTe\n", + "i+W8F6CaZq+I5IrYXuyekCgyrxfLekQyHf7sCK/u1aynWTXg7D+bALPElnyGV1kqgxk9U3h/hZaq\n", + "dOxkoxWws2GGW7sjwJXAa2JLF2Wpd9AcQF8Z91lJKCmVswuwxl9G3xcE8vgD8AMMF0+1Y7Gccgx/\n", + "1SNc+ztAWUoluuT45PVaI6Fhet65GjW35knap50RrCz1FvCWETIfhg6G1hdbJvFTvR1w6b3wgfuq\n", + "u3Qi7AXuB/g/o9w1SWx5AR2PKMbVEBWOCoI6m2HA40QmJZDAKCaSVlegHxxiGKNIAo5lXQJznoeD\n", + "rWHQ8GrATjSr6khlqYl5faZncKQlzByt/wzKgvq/wc7e+Sp2laXWiS33kClJUvP89aRfHUyjlLbE\n", + "/b5UZNA+qFlc8kJJhr/SK3YdBFb8AfgMpdYlEbrwQUJOQNYt8yFhZlkqNgPwL5wCudhDUMNNTfH4\n", + "kXZurfJ2Y8pSO5SlXlGW6gxcAByl29EXGDk3lose0yIzgHa9NPMqG0VZ6kd0XcJwYLzJvimEeJGE\n", + "XsyK60d/uk3bTWToJNqGW0wimeuGwNwWut0kkmnrzgK+5udkVsQ8AyQA7wMuseUz417BLE7yVMrq\n", + "rYf0kCwy9hZmyHTFHWf12dW4MvgCgr7ox55F9VkysCNxLQbqyuAZA6H3aA87oJIMf1eqiOEP+PgD\n", + "8AvElmhgl7JUzRIbB1BuEFvq1FnEmAHLGDbxCLlum0RaMSOXR6dkKgWRofNo+GQ/brwIIg7D6VBI\n", + "bwhHjx2k+cFP0UVIqW6vPcCRkjJ4TCziQzS98lXKUrlsvp4yr4aFNORAzf38dCibn1rCDVfBsrHQ\n", + "9ChcRNSh2QzKVyUstrRG8yYloSnh/wHcoiw1Ny+tNrsx3VJacuaRLCZ3WFZw9a6ZRr8byPWDYW9n\n", + "+NEU2TY/D6Lu1a4loGDygtgyAuipLDW8iGdPBi5xF/PxFQHKhgAqG1HoatYAKgFiS2PgYeCWg334\n", + "culm7ko4wpBIiDhASOQqqqtjTDgO/y0llcKxDFK7wCsHNN3EWdOh3RRo9V002g+ejHYcxQCN0FKb\n", + "1Uweu6dJwf3v69Bc+MvElmFOlavDOrqyITQ5CvWPw6TsVAakkwMEXfiHpoW4ohdcPAtqks4gpmTs\n", + "csvOUpbaIrb0QktzHkFXPn8qtnyBi6dxAfQeTYOWkWyPB+4fWNiFFRVOTghMnQhdPkCXDAik9IKo\n", + "7m7vUSHm0VoUseIXW2qjhXM2F/++VwwChj8AfyGSgOGvcIgtscDjwBB0Pn8HZandaJb2D7zv2U1D\n", + "4VQMrL0e1s5NptpZD/DUpix0odjlaP3j/0Mb2gygAXkTQUPz/7YF/q4B7ENXQf8otiwFZrfvQ8uk\n", + "/fBFvDa1E77RouWSxcZromkzMY2QXgvh9xq6QADtWimkRaAsdUhsuRh4D7DQNQ02sJywBkc5NTaW\n", + "Rl3h11vMs46NDeGCZ8nlCTLJCifrwMLH896S7HA43MrtPSqUvFAcJXNXYHXBjKPKQsDwB1AkyliN\n", + "+z+14q/qlchiS0fgCWAA8DZwlrLUAX/1X6QI+6mNznvwg/HTJ6AngVfRdQSOmIxHrhpz7+HoCaIh\n", + "mnrhaSB6b3Mix5wJu2vChrowKV7TTqdl0vRUNbbW20vrmnvJejSN8G+PaUrvDvs8U3orS2WKLbeh\n", + "J8UZaCbOjtQ7/T67gK8/hkN5ceva0C5eJEFPHoWFg2B4FtwU6va3p+SF2mitaE+oMoFdCBj+AIpA\n", + "EbnUxWV1/M8Yfi+evcIgtpwDPIlODXwNuENZqlzed09smfnO6+rUr9DpjlHoHUCJYjLm7+3mtVhs\n", + "+RgYf6gp4THv8cfMNFq+1QO+bgN1vmPH/Pa8cfxC/thfkwdrpNNtRQ1IjYI6J/SuACASCgm+mHjD\n", + "S2LLVmAWcDt7QxYDfdkfl69tE05EbKXXFyKJq6FpBiz+FBJ6uU16S2BPL3grohjm0eKCu12BL4t6\n", + "LysaAcMfQBFoOhLGxhKWBn2fh+P14VjfWHKWu8SW3eit+gG3nOQoNH/8/wDMs4NbbYJnGcGKgKEC\n", + "GIjOuW8CvAxcXRQtQGXATD6fov3pddGupyLFZApce0xsSTxdnccn38cjWyezpPlKMhf1oWtEH8Yd\n", + "mq7eABBbfqr3G/vGeqB/K47SW1lqqtiyE/iG89ZMD59zXfcMN1H3BlzDHmpzlKSaaCoM9Iq/zJQj\n", + "xRn+bugJu0ogkNXzN0FZXRe51bjhR6DrexC5D2rsg9ozj9DkUApQHx3YO4SeBATt5//K/O289pp/\n", + "9/uDhrYikPvsrafDRY/BO7+BCqaiK5FNMdVVaIMRinZtT/6rvI+QG3RORLuDmgNT0ZPAImWpnILi\n", + "OGu6sij1Uu5F++Z3oV1IHRwB9SYd5dFzd/Jv94yla6M4ueYkwzZkqe9KuJfmwHfRP0Q16Lm4zRkZ\n", + "1GB58+M0STnNluxV0HAlHGiri8GAslKOiC2/ArcqS60ucPwMtMZ4bX/7+ANZPQEUCe9cFybAlRGT\n", + "P8BFwhLnxyC2hKAzFeqjlYzi0Ya+PtDe/NvA/FtbbDlC/knB02sv8KfzQ68cpGdQfw1ccQt88a0x\n", + "+lBelcgFjd8fEbz9++PURfunDwMu4PuqEhgsC5SlUoDXgddNIHoY8C5QM+JOWXZxY3p8k0JTx3KN\n", + "WEmr2Qd5avstPIhmyUxBs2f+F2D3GvWfOoOld5819GqSyuZ0yFg8gPppHTkHKNbwK0vtEFvOPd47\n", + "/ac1rVfV2TQ5J+ijhvDC8X5wAOj0EcRNgYWPwoq7IauwXnAJKCqrpyuwqip9foEV/98AudwmMX9A\n", + "m+9g6UhzpugVjefJolhRi0eBespSj3rsT69e66IngeJeDUy7o5Q8SewD9hVFu+stJLb5DVx+YDw/\n", + "jA9hfaI5WjYZwdLCPXf9RCh80AWePIfsTGFtdhQPA/P8zW5ZFSC2tG+ykm9Cz+TMaqfh5l/hyV/0\n", + "uQSYOcNFIjpLKRadCdTakUU09NS/Ak8bN84ZaI6dh5SlvirF2CGhq2NSgptk1Yub0paV1YNg+zJ9\n", + "st5a6G9D04Xwa/VNnLetS2kJ5sSWdKBRwZiL2PJPNGPnY6Xpxx0lyYUGVvwBFIMoXSV5KhrOeRn2\n", + "doIdffGQh5yLIrM6is/qKdLHb2IBjrEuFoYpsQ6eJ4bWBf6uJ7Ycp/STRLE/YrGlBjfyIDuqf8b6\n", + "j+rD1ELP7k/t3qYw8j0h9oVzYUxPOHcnzJ9IyL/2sC9J+Z/P3h2VmbmkLLU2UWTXJDhzWWNYWz/v\n", + "XCREKEuliy1Xo+MaT6JX/Neba08awfRvxJYFylJ/mrZJYsuG4gqk4kUSBsHIUNL3relZPWbVjduq\n", + "sboH7LsTTr4Hf7aHyVOh0eW7SJxxCEgWW14G3i/uu2O4fMLx/BvoinZvlQn+lAstiIDh/1vAyUuu\n", + "DdPfhstuh3fXQFbxrouSsjoKIArtk/UZZku837zWFdfWTBK18DxJ9Cp4TGzJoOiJYT9a2m8bzU/c\n", + "q1TS8YLj+fvHGAXhQQpCcmDeR3C2Scj0lKXiT+Tu6ILfiuV0NXSIpmIzl9IhQ4CeKfrlwAnUmp3O\n", + "C2LLduATY9RfMOeWGGHzd8SWq5WlVogtTwBfiy09PGU65f/sTsPSdPodDjn185WzQ1TLajBu22+o\n", + "Wkfh2En27HxTvZ6ZJLZ0RrvaHhNbXgLGFhFUrwUcLmJ31g1dXFcmOAVt+6vr1Nb7lnlOXfUGAcP/\n", + "t4BbXvLvl0PcZLi46xGmB/uTRK1S0jnNJHHQvDYU19Zkx8TgeZLohuapqYv2qx8QW7IpMDk0S+Ci\n", + "Ln/S6qvjmgunqDzy0qIyhOc1TObSOc9ByClNdFbBmUu7YMwIaFVQHGcn5PteKkt9JrZ0BR431Mcj\n", + "DY20C1iJDhx/riw1TmzpCXxkJoN8RrgpjHwzhNiLroXXfoD2f8L8zdlhvb5g4dLbTnbGmr0HuNT9\n", + "OhOovdyM7zL38CLwYQEXo8eMHrGlAbpgraj8/iLhCNrviIGPOmnDD/5ZFAQM/98Ahdw2sw5kM+r3\n", + "znT3qxpTla/cNT/ow+aVzx0gttwDnIuWxTtsJomaFJggQmHwrw1gXyS0OaANP3j/Yyyt8fM/osIJ\n", + "yoZu78Fn092Olzmg6TXWKZUUL0JC6cRxngaGotWx5hrDniq23IR28cw1cocj0bq5j6HTXnMRBeHh\n", + "2XDLr3DBzXD3tHCWbo7n953R8bxz8nduWXIxETkfiy3DC8aNlKVWApeKLd3RE8ATZgIYZyaholI5\n", + "uwIrvYnTOIuCI+EQ47bH8MeiIGD4/yYo6LYRW64CxoktncqqjlQE/rIFXGLLYOAZ4BxlqcOQO0k4\n", + "Auu5/CqDRS59T6cl5oO3P8YyGj8/Ij2Ds77T6lX7Orodr1gNBfOcJT6r8es/gRZG+R7N8zPUuHze\n", + "A94XWy5Tljpl/P3LxJYVylI/OX04hvT6tbD3cASPD1OcXpwIix6JZp90ZuzQU9z8TReis2eLLVd6\n", + "qoRWlloOXGJ2Fi7gSUM1/SeeDb/XFbvOomBgOLGO4ffXoiBAy/w3hcl+WA0866cu/5IFXGJLB2AC\n", + "MERZaltJ7c2Pcav7MV9/jOuUSkpSavBkpfonKTW4YuQgd42h990nWX6P27Eqr6HgiKwnA3cD34ot\n", + "w4HngabAzQDKUrvQFcSfmdx9IP9nN2t3HKc/+B06fAaX3wZyGg5NCWNK1/po6oklYkvbom5EWWqp\n", + "stRgtK7xEGAsOmU5tEBTr6mY1ymVtBhGPV2bdUtgbwLM9JdGdCCd828Mkwb3G1oDdImPfa0GbleW\n", + "WuWXm6sAiC0N0SpUj+cX7Sge/wvavWJLG7JlCS9dtJTs6PBSZG1VCRjKii/QxG9NgW+AuWiqOXZx\n", + "MwAAIABJREFU5xlAF4fqWWx5BG2Yz3UCss5nt5gLex9hdjTVjkHcJFh9ux6g6QWZ3D63J5pD6CXg\n", + "OvddQzH3NRq4AjiNnog+UZbKElv2AL2VpTzUG5f6mR8BGihLPVLoXEB6MYCyQllqPzAy6BSTL6om\n", + "sxJF5g0WmRkvUiaJPYNKcfV4Kw9oeOG/Q2dplNroQ2Wt0P2OuwhR76qsHwYpNbm/UkmDq7rRB1CW\n", + "WoierB9Slvod6Ak0Bt4AxqEpIhxD+H/ANuAt53rnsztCqF7oZEbmGX2AE9nbgVHKUuPRxWafm11F\n", + "SUgz49+MTjvdKLaMAhxVMF8QQ552ml8QMPx/c8S5ON54B7W69eWiydBvBgzsDaO9MP4VHtzNKzKb\n", + "UZIyUv7rdDHZp+hU0Rcq5GY9IF4kYbDITB8n3DKPOSBcfgzJ4L5z/0ufihizHPAE8KDY0lBZ6iha\n", + "H2A22r3TFBgBuXGa24DeRiTFDQUUuQDt6kr9F3CF2NJAWWoecB46k+cVkzpcFGoDh5SlflaWupCv\n", + "G7/P7LOeZ3etWrzeb42EtrvUh8+76hl+ERkkIptEZIuIPF5Mu+4iki0iV/k6ZgD+Q1MYuXwakeM7\n", + "w4Yz9LGxENtMpycCpTZQleDjNymJtbdAr9fNsVLJA76Mzru+o7KqYp2c8hkw0McJt8xjXtuOAYN2\n", + "EPLzfvqW95jlAROL+RB4zvydoyxlA/ehs69eFVtamHPH0HxHL4gtPXL7UOuSYPEoLROamCcXemDL\n", + "JGASOoaAstRmdD1IT2Cq2Sl6Qm5Wj0h8AmsGjyDkmki23RNE2rz21Ojw1ekzoz79Xrz6vKuW4ReR\n", + "YPQ2ahDQDrhWRM4uot3LwEx0pUgAVQRREF7/OCz6EM52k5120hNLY6DMCjocKFTwVM53ryuSW87R\n", + "wtm5KDolUWy5E7gULfuXWb73VzSc4pyXz4HljfSxghNueY35Tne4Z3nFjFmOeBG4tGFvuddZlAxy\n", + "cU+jaTyJzt75xVTTYlxCI9CGu57TgVLrkrSLq5CrazRwl9ENQFnqIHAxmkZkvtjSyMP9uKVzmgVJ\n", + "oxWwp5s+lDYxZO+pNrXi74FNdfWhMrz30WhXkt/g64q/B7BVKbVdKZWF5t++3EO7+9GsfPs9nAug\n", + "EuGkuJ15OP+M7KQnNoWR7wQR+2FnmGCy/jx8YSOB4xW/ejYVyU2WwO5ebsc9pySKLY4S0yXKUsWJ\n", + "Ypc7nOKciGx46dy84+VZseuM+dmXMDC5YsYsLyhLHYnczFTVjv8kuS1KElbzaMv3uQ+oDmwQW+qb\n", + "9tOAT4BJhlywuL43AqvQriPn2CngVjT77BKxpZNzTiQ+gT9r9OLjvs9rXqzTemJIvjjf97JDSg3e\n", + "nAHN3dbupXzvq9aKHx1UcS/T322O5UJEGqMng3fMocpPIwogF8WlJ4otcqAzTdrfDZ90zKMTgEJf\n", + "2DIFdr0NyHq4e+2nzWf4Packii3x6B/+1cpSWwuer2g4E+7tq+Dn5vB7HX28PCt2nTHbHIQgt19h\n", + "+VcJlw/6TCS2dgQRn3aAtWYdPxZi2+7hVqAPmtxttSm6AvgXkEmucmOxeB14wC1QjLKUUpZ6Ea0X\n", + "/KPYcmke9UXDaI580EXHmZq0ggWwdBQca5DbYQTHGbBNT/YOSvne+93w+1rAVRoj/gbwhFJKiYhQ\n", + "hKtHRFxuf85TSs3z8d4CKAXWKZXUSGp3703OfTWQ0OOorB0EfZLqOnwSWLLhXJp9OQMGbvW8IzAo\n", + "VWA3XiQhiOhnI0hod9JNCMNbjhil1iVJo1aRxGz/nP3PLYQTJzylJJqy+e+BB5WlfinLGOWF3Ird\n", + "LGLvWQ6v9gH1XflW7FZelXD5IDqHsFGz4K5/wKlg6LcDrHkQuZ8IZalNYstTaErn6ZIY/QlTBsUR\n", + "GVKDO2fdK1fGZKmvjzxVTPc/AsFoGo986ZzKUpPFlh3A19Suk8ahsbFE1NFcWACMqw5XnIC+1Z1r\n", + "hJtTs/ldoScjoEzvfa7hF5H+QP9SXFMsfDX8KegouoOm6FW/O7oCE7XNpy4wWESylFLfujdSSrl8\n", + "vJcAvIBesQy5IZWx2vPYYDUMvOQxMuUuqqmHmr/N0S9P88ag4o1FiYFdJ1awk9axa/kczlivhauz\n", + "w/GJI+bObWnAz+r01PM9Pp8t1YFvgfHKUp+Vuf9ygnvFbvAKas64n+6NN+DasbX8UkMrr0q4fJAO\n", + "GYO36NjUxclwOkhTMeTs5SxTfDUGuJI10etpdvp+Bp0VyqxX4fO1cGOfx6R7o51q+Z53PfWtLKXE\n", + "ljeABylg+M35pWJLHyJC1gMwZqvWrshFUDIkpDjMtoqdb+4l3dv3PtfwmwXxPOeEiFilerMKPYBS\n", + "Xr/QE0cy0AKdr/orcHYx7ccDV3k4rny5j8DLl89w0ExQitpbFEOuUTzcUNH9v4qQi2c6beIgYTDM\n", + "GArzBsOMOEjI14eLC3Axt7hxBsFMBaof/RTtP1U8WlfRZLECZV5D53l1/y4sXPy7iHNBuJiKi09w\n", + "6WLFqvrCxWhcvFLU+ThIGAQzh8K8QTCz4Gfwd3zFQcJw2PJbPVS9R1CHwlE3hpFc/RY+wsWfuPgU\n", + "FxfQsnsm4YcV1yUoEu7R37eOHykeDD+Gi+hiPpMI00+bItsEXTw77zvs/ho8w0/fixBcZBf1/fXW\n", + "dvq04ldKZYvIfcAP6G3Rh0qpjSJypzn/ni/9B1ARiApHTkPi1bB+KHz7gZGemxfutCgFn0qJPn4n\n", + "sJh1xgEtdPHxT7Cvg1sLrzlieqEVnTzh30A94CJvA8/+5qwvhsv/NWCV2PKiIzjifk158bL/leHs\n", + "YFL+5P5qO+gYP4hTtb7h/uPjVZLYUhNN2DaJUzUzyIgJ5YtvIeKwvnjNzRD7TBrtd00QW67ypI5l\n", + "+IHeN/3c6/EmclJegxEtYGyrvIN+pb6IBtL8nTjhM0mbUmoGulTa/ZhHg6+UutXX8QLwN9IzUMHw\n", + "3ipQ7rH+MhniEn38TmDxqf07GPn2QLaddjf63v1QTEFNT+AWD+dGoPO3e3mr0OWdZGXRKM6AK6WS\n", + "xJbp6PzxfMFHJw1zRzQ0S9OxFn/xsheFyhRpKQucRYnJ3lm/p5Mm1DOFXc+LLW+SeWolEIUKhhN1\n", + "8y6edvZa2u+qjy4Ie7GIIf6Lzg56xlMmWD7m22hiqX2gKdVT31brdvnrvfJ7YBcClbsBOJkx+Yx+\n", + "mQ1xiT5+J3voEo4x5vQPDKQ7Z3BhRggXrPRB0vAs4IiyVD5VL7FlAJov5RKTg+0lTD52tXS44J8Q\n", + "nEkpC8Q892YMOMA+UwZUIDX2FWCkkz/uwNktXXO1FuRwUF5pmN5WRFcmzHfg/yhAxawslcaBwyMJ\n", + "vi2/SFDQbTvIThkDXA3cJ7ZcXES/qWhqjxGezoNbPcCRpNbcvHwIQ3c/IbYM8/GRHAQMfwD+R5EV\n", + "jGUzxCW6ehymwQSYOYFj84NYMbMec4ZkqTndfFhJ9kLztuRCbGkHfA4MNVWXPiAqnLA0uHEgVD8A\n", + "Oc4G2TvOeseAv3AeDBmWlxLnGHBlqXVoYZGb3a9zdkuv/AiPXQQnDP9j+aVhmgmvVjJE7jXHvJ/w\n", + "KhBvAN3Elr7uB5Val8TpZXcR038djS88zhnnbWPo1Nq41l+GdlFfi1b4alFMv/d5YN4sBGWp6cBF\n", + "wCtiyz/d00G9RMDwB1A+KKaCsbQoVR5/OZCb5TP8Zrs/HXhEWWqBj31D9QPZ3HgxpHaG799xc4V5\n", + "F49Ih4yXztU1EVMm56XHFjDgLwGPmmpoIG+3dN5OOGcnvHxOOadhNs6sw1XXw4ie0NCdbLXiRFq8\n", + "gdGVeAJ4rSCvjlLrknhgfgdGzFnAvb9M4Oz0M9EGdTWQCLwNfGWE3Av2uwpN9jaklPexBv3dvByY\n", + "ILaE+fBYAcMfQJVFZYmw5Bp+84OdhqbD/djXjsWW2tw/vzn70o6Q9BZ5Ztr7wN2Cm0l5oStZcyZA\n", + "Q+MYK2jATZ3BPtyMjPtu6chclrzYi6xZZ/O8vwO7YksPseUbbljQgX0dYPQ22OLu3alYkRYvMRHI\n", + "xgizu8MESEegOX2aKks9gaZ3Po4WeKmBlm2UgkWGrIqZjyaGK9UK3riI+pk+fxRb6pZwSVEIGP4A\n", + "qiwqnpnTlkigNfCrWd1NQK/KvMtrzt93HWA2ETnf8X3w9XCJL24wp88HT7Skb+0kbh+ezsxEmF+M\n", + "sMbLaEbIXCPj7JZmHFS9s8N5ftcw/OJvF1tEbLlAbJkNTAFm886Zw1i4dSunarq1rHiRFm/YLI1x\n", + "fxB40dRwFDyfgq68nSC2hClL7VeWegwt6TgTGMKx4NVEdXgrX4zju6uuJVOaAb1Le//KUifQcpGL\n", + "0DQPbUp7rRvKxfAHpBcD8AcqQ32rG7BGWSrTaJ82Agb4mvZmVmazgVnA4ypnvcLHzBnDy34f0H/H\n", + "ZrULTR1RHL5HZ/YMQFeQFsSr6EyT/oY62Jt7EuAfwFNogrF/owXLM7FAJD4zV6O5EkRafElhVZZa\n", + "LLYsBB7GMHgWwCfoHdUzwD/NNfuAUWLLJMJzfua+74NY+TAsfAyO1wf1YSxL5m+kb/IDaENeKpg0\n", + "0SfEls3AArHlGmWpuaW9nsCKP4AqjMpw9fRGr6JuRftor3RUlryFYW6cgzb0j/sjd1psuQ/tRjjf\n", + "SAKWCGMsXgE80pybleSjwOiSCMc83E+w2HItsKbmOt7o/xoRV7tIHeTimjgXA3LH8D3u4xOcDKhf\n", + "msHUdrA3ssxMok+gDXkhJk3zud4JjHDj8XHOLeLb7hvIjITww9BoZd7JRfEHgQvd5RxLC2WpcWg1\n", + "sIliy21luDRg+AOosqgMw9/LjPkS8A+jJuY1TGB4LlrK72lfCr5yfcP9Wq8nU54BLlCWKqsK0xfA\n", + "WWJL1yLOTwUOA4XUoTy5SMSWMKMktQm4t+F3TE2cSs7co3ScUkF6AGWBkwF1OFyzwra7F1rfD2uG\n", + "0UlsuV1saVOcv11ZajvwAQeqjfdECKgstRc9IU8omD7Lb7VTWDUcaidD8kV5xzMyjwEf4SWNtVnp\n", + "9wWeElteKkHYxUHA8AdQZVGhht/84M8B7gGuUZba5GN/DdH8J5OVpf7lW5WvyX/vOqAfXTLb8d6Q\n", + "E7ji2pW1L6MV8DpFr/oV2nDZYkst53hB/YSpoQyMOJcJksVudM767cB5HVfSZyzEftsGklrra6sS\n", + "N7+TwnrpZvjuCzjwCnw9CWqkchA4H+2K2ye2fCW2PCS2dC+Ubvl2qxVEBF1IgxeLqkeYBKwHns0/\n", + "+q4xzEvZSlYNuMh5+3NjHG8Ct4otUd48l9EG6IVmD53iKQ5RAAHDH0CVRSQV6+Pvgv5BPFpGfymQ\n", + "f0Xct47MDTrFcuAzo+LkA0z+e+Ol0Pd5mDAHDk5p4UP++1jgfLGltaeTJm3wK8CVewfGRXIkXNcL\n", + "nDkKmjWibrfP2awsNUhZaoGylHJW1PWOw+2XwftmX1EZ3PyedigF6cKDFLzxJ8nVFvCYstQNylLN\n", + "0XGeKeg4wIfAIbHlJ7HFJbYM4GiLO5n7ejADHyavaiKvHsFMnvcAN4otfZyxlFqXhFo6immnfiLu\n", + "3Qx6tFvjBPXNTmIuHqrFSwtlqQPoXP/jaGGXhsU0j8HPIiwQCO4G4B9U2IrfbMs/B7YqS31U1uvd\n", + "g4a7a8L510PHxRzMnMcq3/OBjCJYSg94byWcMFqWXua/K0sdE1veQWeh3FlEs2fQgd73laXWOwb9\n", + "0YvgVAjMnQDt9kMiZLlf5Kyoe+2Gn8dDwvWwPQbS55QfN78nniIA5/NQ6KTZEdBqMYwyKaxFslka\n", + "99lOtFsMs/PpA5wLWDw8rw9/HoGoPdDtHdg4RAdq3T4PZan9Yss96DTOTiZ+4lByJIktHUnYOJuE\n", + "fLojr6NdRG8rS5325r1QljolttwMPI2OVV1mJvKCiKYcVvyVzrDnC8Nc4FU1Xrg4jovIChgnCBdf\n", + "4OJ3XDzmTR8OS+iOaFSrkaj/9EEpUIPBZzbFXKbTQi/vmRpxcQYuDuGiYTFtRuLiR1yI83w5BW6i\n", + "4PM5zJbO+f3VUXXu4GToSObiIszfn13B8RSo4bDlPFihQG2ujeo5PO++/fJ5hA6YRbOfFee+qJk5\n", + "H49R3N9acU293bi4DRetHdZLXHyGizeKeH9vwMUWXMSYvwUXy3FxmZ++18MMC+glHs7txEWzor9z\n", + "KG/GDLh6AvAJFay3a6MpwNOAxd504KyIT4TCI4v0C/zl4jC8R/ngW/67CVp/hvbnF4V30Omslzku\n", + "Eveop6cqX/eisESYf9MJZtaZyLVZtTkI/OAeN/AHHBfUaYFk0/NYiK0JLQHGddZVyc59++XzyEp9\n", + "g50TtvLLk/D5dHjlIExtt4ugE9PQqbJzgL1iy5fABuBaseWCgt0oS32KzvH/RGwJMi6i19H1Aj5D\n", + "WWoSusp3rNgyskDQOpDHH0CVRIXo7Zpt8fXoashNaE6bMsNxcbQ9oF8O/MF7k4+p0b/57/8HrBRb\n", + "/q0sVcjfqyyVJbY8ALy73kUcruJdJA480W2LLd+i6wQWii2DlaV2+HjvQN6Eu60W9LsVdr+m/fZh\n", + "INlBMKETzHarty6Xz0MdO0nqzjfVZ+m5z2xSM881rwxgttgyHx3s/wVYqix1DF0TMAftmnkOHVt4\n", + "xbiHfvX5XnXtwTnoGo42pvYDtHaw3+Nnosr391q6mxBRSilfyYwCqASILY2B5cpShfKl/ThGf2Ay\n", + "2ujXAsYoS3Xzpi9PhUHDIbmICtoqA7HlM3TB2ivFtPkGbahKoylb0nijgMeASw1XjU8YLDJzBgwE\n", + "6HgX/DcJzt0JF8PK03E0OtmLhos+1G0r8/Mw73MMsBY4D+iEzvz5BVgHvMCy2m+T1OMcaslZhKVV\n", + "Y2/aHXGspwidhbKOH43+ruc0+5hJ9RXvt/iDRUX16a3tDLh6AvAV5RrYNWXuk4BrlaU24oGRsyxY\n", + "Txwfcf7Rmgw4VIdehzsQvaKqG32DV9Di3+HFtHkYeNhT0VJZoSw1Gl1tPFNs33P73bN0rt4AU9pp\n", + "A78H/rXgYnYc2sTaEmgsKgr3AO2B2cpS56DlYh8GDgBXk0MM3Q4/y9DIgTRPbEnmhMbQZVwDosY6\n", + "KbT3ETnwID2mhMhlv7nXDpQGZkd3Sdif5KQl8P6UQ4ROLoc6i4CrJwBfUW6G39AnTAeeUpZydE97\n", + "oTV0y96fybPPZmysc8OHGBHjZbigQqEstUYeDk1hWcsV4ko84EkcRVkqWWwZiy5qu8kPY34ttqSS\n", + "LUnS96w9/NzJ47ilgbveb+YW6iy4gQ6xPzJq4zP8CrT9/SKabvpFVTTtRyEoS6WJLcMli88urCFr\n", + "h54gxG21/aIED5zJ+Z0H0vFTfcEF/4Sg7PrrdoZwewZk7o5g4a+D2JszpTp6AmlfVvEeZansQSLB\n", + "g3oR2ns4fD0Reqb4WXzH39F7r6Lagayev+yrNHq7XvYbhoufcfGSUnmas2GPkNGnPgu80ZzNzboJ\n", + "P6zoZ/tdH7Vc32fiEmg1aDf3t1ZItrnv4VsgrqD+cRQuUnDRy2/j1h2ynftjFRc8qSDH47hefL7r\n", + "cdEbF0/iYmxlv7/urzhIiL2StNsuy/2CqAuJSgnh/JVw9RHIUVxyl6LxEv1+xPyh2nZoqwZfjwoe\n", + "Ga54Mkpx40WKbm97/R0bCvMUqG/PQj15Yd59DIV5+T8flDfPGHD1BOAr/F68ZbIaxgF7gaccv/wH\n", + "UQyMDCLsl32c59221+TZdxkLddw1Wqo2z7xG05EkJzXmZG1o+405VlgcRVkqHXgSGFNKSoCSxz0w\n", + "tTnzXNDlQ7jqBgh+yx+iLFPJqyT+wOfb9COawshV06k5p6Wuap5OJNsZ3CibOV2gTTQITH8HUnoC\n", + "Akda0Py3SJI+g3PH9IQ3/oBl98HJ2nmdRoQ2KMvn4V65/OJPecf9Jb4TMPwB+IrycPVY6ODrTcpS\n", + "OU4q4NImuuDI0ZwtO71AegZB2dDzTVjsnon3V+CZjwoHgQVPQ50tbsc9TlqfAjn4wd0DUeHU3gqD\n", + "HoQpkyD0JNwwCGqEeEVZ4IYp6CytDGCZ7/fpP0RBeFQmjJsGm+rCGNqSzCRo/xk0C0Mn9uQhJiSR\n", + "UxGaNSSM43CyDvx+Gax3U1+stzcW+MNw9HTwxPnvHgvYBWNuDuNP93H8Kb4TMPwB+Aq/Gn6x5Qa0\n", + "9OBlRlEpNxVwY11t+B2UPdd71xjaX7iXIy0g1eE+q3ieee+QrplHN18KvzzhdrzwpGXYPUeiOelr\n", + "FjxfJlQ7nMmwq2CeC3b0h8lTYG8nGD67ozcslW5Yj/78fijvVOCywlltn78dHloMJ0LC4dI7oN+z\n", + "cOpydHLSM9TkCoLO7M640zPYf/4x7o6Ao/yeHsZ1J/L3ODyZHceHoWmwFfAdGUF/cH7ox8S87ZFH\n", + "aJ1SSTPO4dtz67G9PILegeBuAL7CJ8PvXsaffBYRkkgbFcI57gLqzg/x6Z8hxy1xrazbXqXWJcnj\n", + "IUeY3TYVEo9WBs+899g1Bka00u4dB0VPWspSy8SWWejlqUeit5Igtgh3Vgtmb+N0lt+tV/gqGH5I\n", + "T6Ze0E/UYqGhGvAm3TMaCANK1LGtaJgMpFZjIXZzHVgzdCXsbwLvr4BMZ6PTl5DwnhmdB6wIv/J9\n", + "OLgX/jWUE7U/Tr/mFL9RTC3Hk2LL03zVaRGte/ZkRA9Yfq+eWBkbq6/Twdv9fUnd35fxylLPFr5L\n", + "3xAw/AH4Cq8Nv3tO/ZbacN5lMGAyKXs20xyL9U479x9ikFkberPtFVt6UZ0wLlsfr1au84pjpbLg\n", + "ZXHYk8BaseUDZaktxbTLhftE3Ko/9f7olRmeMyvkZrjkjnzjfnwsSWy5Cp3uebOy1IwyPtJ1wHzg\n", + "ErFlVFVa9TsZSHHdeWHLBcTV+UXtSV9YrRpEuZGpDU8+1n7Lpt1H6JAI246s49TeBHqmutimrHWb\n", + "KCbzRlkqR1yJGWx+G2aMhnD3mrx8rrsY3Ijq/ImA4Q/AV0QCKd5c6PjuD0bAJdfDs3Phjs00Lpiy\n", + "5p4KWFI1agl4EF389Zcy+g4c4rBSt7dUqtjyCrry97KS2rtPxIuawhXd4aqx7NiYtuXUOrV5sIf+\n", + "vxJbUtEi5f9SlhpbhscZjt6JvIMuklpdhmvLFWJLOC7+wYao+ozusWJvRu1MSI2CvinQ4Lgz+WVe\n", + "cnjYPnhustLPLbY8h3ax3VPyKMZ1lxMKJ9zlePO57sqFrgECPv4AfIfXK37Hdz8pHi7fBHcYEgZP\n", + "vntHc3ayUv2TlBpcVqMvtjRD87OM8+Ze/8IYDZwttgwsqaEzEe+NhMShOrg55SDNiwuiK0stRouL\n", + "PC62vFCcOIoDsaULWu7xJ3R2z9BSP005Q2xpBSxiVUx7piSeJGN2b+2Dn9UF2sTAhlfcFMm6Aivc\n", + "Ln8bzfdT22Pn+VAqXqeA4Q+gysJrw+/47u9ZDq+4Kcv6K2WtAO4DJihLHS2HvqsslKVOAQ8BbxQS\n", + "KikAZyI+HgpPL4B/mIzXkoLoxo3UG7gATWRWrYTbuh0YZ4LQU4GhpZkwyhtiy9Xoar5xfNvrOOqD\n", + "M6mxz61FXvqs2BKJJpjLdUkqS6WiiwvvKGksPXEsHgUJMyFxvv5Xc/67NQsY/gCqLLw2/O5l/M6v\n", + "3p8paw7Mj/Q2/NzvXwjfo3nr7y2ukTMRtzoMd7utY0szERsW0QvRpGIzxZYYT+3Elgi09uxH5tBK\n", + "tMu5fUljlBeMLOWbwMtAgrLUWxAVTnAm3N4H2kxza53rg+8ErDdKae54A7ivpEkWSqVrXC4iLBAw\n", + "/AH4jii8LOAqSA1cjjwttwDzlaX+8HO/fwmYwOkDwNNiyxlFtSuoegVlm4iNiMlQNMHZQuNeK4gh\n", + "wDJHg9jcm1PMVeEQW1qiCdgaA12VpcyUl57B6WowdSJcNhwaOolLuT74buR38wCgLLUa/R7643nK\n", + "R4QFPxh+ERkkIptEZIuIFEobE5HrRWSNiPwmIgtFpIOvYwZQpRCJD+mcvvrui4Ij5zc0SOaFHeXl\n", + "uvMrnpDHk6RgZY1hCO4+BZ4vqi9/TMTKUqeVpUahZSMXiS2dCzS5HS2T6I5KMfxiy5XAUvT7MkRZ\n", + "ys3IGh/8nu7w/btwzeUQfc12Nx98Qf++O14HHvSD+6rcXD0+ZfWISDDwFjpolgIsF5FvlVIb3Zpt\n", + "A/oqpdJEZBDwPppoK4D/DVSo0Hpp4J6d8l1r2J4OHedyZ7zIhopiffRE/zwCWsWL4M/JrYxj2MAm\n", + "seVdszItBE8c/d5AWeoNsWUXMEtsuUlZaobYEgvEUZhkbxkQKba0U5ba4OvYJcHEIF4GrgD+oSxV\n", + "qHI4X/rsxsgImoY05K4pwUTkLDBNugH/KWKI74HX0HGPRV7eYzBQg3L6bfm64u8BbFVKbVdKZQET\n", + "0UoyuVBKLVYqVzxiKdDExzEDqFqocobfyU4BeL03PLgEPvCK4sG3e3gfYu++BFaa7G/vaCaKH8PR\n", + "qn21D6w/o/gx4lz0af0TB2JSmTuonHYg7lCW+hJtD8aLLSPQcZaPC/rFjbvnSypg1W+qjRcArdCu\n", + "nSLpItx98PTZ3tYY/c9M/KIpWrWr8HU6XXg0vil01QTSTQDc7/DV8DeGfCLEu82xonA7/qAUDaAq\n", + "ocoZfvfslKhTmv8d/CWvWPp7EGDANhh0g5YW9Pc9OM95KgRSI/U48ffA1oG0FVtau7d1dgcbfyGu\n", + "BUTfGudffveioCy1CC1o8jh6Qiro5nFQ7u4eseVS9O5iCnC5stSh0l5rJqe70Ab5XWCtslR2MZeM\n", + "By4QW1p4ebvl5uYB3wu4Sl1tJyLno2f8c4o473L7c55Sap5PdxZAucNsRyOAEyW1rUg42Sk1smDa\n", + "xLzj5ZQmWuw9DNkI7fbDldfAssaQNlMf9+cY4dnwf7PgPz/CoqaQ2B0BFpjiqonA5EFmd/B6T7hm\n", + "HTx6MWzaTOzVWX7idy8GylJbxBYXuljrKbHldg/ZMIuBumJLG2Wp3/05vsmweRFIBK4uRf/8AAAd\n", + "7klEQVQwtQdlhrJUptgyBPgdHcAurm262PIROo34ES+G82j4RaQ/0N+L/vLB1xV/CnrL46ApetWf\n", + "DyagOxa4TCl12FNHSimX22uej/cVQMWgBlpvt1y2o97C1+wUf9/D2Qdg2ViYHs3xnx6ihdjiF3dn\n", + "wecMUvDRTpJrf8k9aJfqw2iXxvJFd9Pn9V4Qe1C7hc46AK+cU/67IIeBkj/OeIM5sTs4EtoKD+me\n", + "5jvkd3eP2NIUrZ/bDujirdF3YHYJS4AuYsuAEpq/CdwqtnjDZOrR8Cul5rnbSi/6BXw3/CuA1iLS\n", + "QkSqAcMoELgRkWbAV8ANSqly4Z0IoNJQ5dw8UKFpoqW+h2tOMbPm5ySers54YJnREfbrGO7PabJr\n", + "5ipL3Qk0avEzv6+tDzdfBfWPweIm8Hov2Fu39Lv2ssJRPCNy3EAaZNVhyeo4Rt94BvvC0oFfPKR7\n", + "+tXdYyQjl6Nt0qXKUgf91HUbYBTwudhydlGNlKW2owXab/VijHJ19fgsti4ig9FFC8HAh0qpf4vI\n", + "nQBKqfdE5APgSnQBCUCWUqpHgT6UCoit/+UgtrQFpilLtanse/krwawUP0Xr6L5eEQRljo//rWBi\n", + "Z7WCf58Li5sCpzlKCI8AX/nRMAIgMngmzBjIuS9BrWT4zqHyGTwT18xZ6B3JpbjiGkLTkRAZTosd\n", + "vWH/PeqPP4qKBZQ8ri0hwHPADWit5l98f5rcvmPQXo1o0/+/gF6mgM1T+3OACUCbsnBEiS23An2V\n", + "pYqdNLy1nT6TtCmlZgAzChx7z+3/w9GETAH878Hr4q2/M5SlZostPdGujR5iy3Blla/erEN0d+Vp\n", + "7o/cTETMZk6G38qBjOZcixZseVVsWYgWtv/GiH77CKN4tukKOO1eyBoVoSz1utiyi2yZR9uGx9g0\n", + "QwvEbwfCb3pZJD61tHTZ7oyie2ujgm+n7ukapKBdOx4Nsg/oAvxqjPgEseUs4GuxZYCylKf4zSLg\n", + "EJqLf5qH80WhXFf8gcrdAHxBlXT1/BWgLLUDOBcdGF9SMAunPFCwWC6jOTehF22dgbOATzC7c7Hl\n", + "G7HlWkN34SUMA+WBtnC4ldtxXf2qLDWVSZ038o+1jejipr6Y8XGd0ko7OjuZGTDw9lb023Ir/duv\n", + "pOHZz/FmORh9KFy49QyQCnzoqWDL7OZep+ypnQHDH0DVQ7xIQvw3/KfuduLLqyq1KsMfVblmhXg7\n", + "Ogi4UGwpkTrZnzBG6XLgODALmKIsdQXQDPgauBFIEVumiC1DDM9OGVAKBsotrTIYvwB6vAWRqXnN\n", + "QsNrlWYEp17imfPh9sth4lRYPYc6LU5zX9nutdTIR9VggtI3oetG/lXENVOBWA9VzMWhSqdzBvA3\n", + "hLPK6n+a2Onp8DkM9HdValWGP6tyjfF9T2xZA0wRW7oDrorSDFCWyhFbLgEWAuOMqEoa2i89QWyp\n", + "g94F3I1e1U5Hu4N+MMyfRfddKvGY9AwOngXvrQLltg6NOhBdmvt36iUapcPK96D+cX28HLOVuqE1\n", + "oXOhLHVSbLkcWBJ9tVTv8yUdoyA8HTJ2wRilVJLcWuNHTtX4XiRxi94J7RpTgisrYPgDqFpwKkbf\n", + "DdMFUqArRgsKqPyvwnn+hU3h2X7QezcM2U3stlQexMvnV5ZaIrZ0QxvV78WW68tSYOQLlKVWiC2f\n", + "oP3QzwH/dDt3EPgA+EBsqY8mWXsY+EhsmYauE5ijLJXlse8SxWOMpKRyk5QMvWUP568p1b07tQx3\n", + "F2DNKY+aDcOzfwawueA5Zam9DXvKy4f78+YzTQnuY8paR0CrRlK7O9Wv7Mv90xsROboRxxoCI1qJ\n", + "xFOM8Q+4egKoWnAqRrunwFC3ovWKrIytTDjPH/8n3LscMoN1Tvz8BzhfbNkktowXW+4UWzqaIrdC\n", + "cPLbRRLn6X/jE4zO8AA0FcAKsaVTBT7Wk+iF4A1ii0f/urLUPmWpt5Wl+qFplNcALmCP2PKe2HJB\n", + "Uc9bFDzz0i+9i/ZHzzA5+MWigms2ugKri6pb6bSMy7/+iuAhibDdVCmMhdjm5NzHiU/PZN210P1t\n", + "0zqP278IBFb8AVQtOKusrqn5j1dkZWxlwnn+6FNw2e/6BTAoiNk//IvH0SSEvdEBvUZiywp00c9i\n", + "YCmuuG7Qe3R+4XRnBaiSgIfFlmXAj2LLQ8pSn5T3MylL7TfSgUPQalr7lKUmF9M+BZ3G/YahJUhE\n", + "k5Y1Elumoncui0pT3OdpVyC2fGvu5Y3irvWjLGdpUBwjJ1EQPngrfPAtnHE873gNDDf/klHQxT1L\n", + "NdLjQkkkPoGR1Tvzdc9XxTX4YCncQmWGz3n8frmJQB7/XwqefNzDIbmii6QqC2V5fuMe6IGeCHoB\n", + "PTkaVo3tQyLY3Ru2XQgHnBqghJlKJQ12uzYeXfz4A/CwB5oDv8JQG/yK5qJ5Bp0D/1MZ+2iNLuQc\n", + "hl61TkZPAsvLUq9giq+eUpY6tyzjFwf3tE/H/16W76uZ0L5UlvrC0/nBIjNnQCGJy95EH1jCkbqF\n", + "r8j/eYNb0dsDs2IZvwDSmqMD5ItHeTL+3trOgOEPwCvEiyQ0q5hVVpWEt88vtgTx/oVLqH9dd5os\n", + "gT/jYOkoczZxvlKT+xdoHw18DNQFhipL7fH7w+Qf7yI0p85dwOfAIGWpVcVfVWRfceRNAqHoSWAi\n", + "sKakScBQJ+8F2pvdhU8oIiC/dTGMKu33VmzZDlysLFXIx1/UGMMhOYlan6Qy5Ib8O7zhyR6kFvOK\n", + "3p6IgTe2Q4bDbFF4ktDtA4Y/gAD+Esj9cRdCET9uW4KAp9CZNdcoS/1crveng7aL0UHMt4DzlKWS\n", + "S7xO4hN0BW5UuHvmislv74iWXBwGZKJ3AROVpTYUc90E9E7hLV+fyVmNHw6HmIw8qc8EmJmkVKH3\n", + "vNCz2VIXSAZqFee+KmpBoJ+xWTHZTWYcSZwHk/sRPxHWJ7plOhVeFOj2lVS5G0AAAZQVJpOl0Apw\n", + "p8eApDE0z5tYwVSx5XngrXKkengYHZPoADxLpvwsMf03kVYvqKhUxFwXRdFxi1+BX8WWJ4Hu6Alg\n", + "ljwZnM0F7SP5dUyd/2/vzOOkqK49/j2sg7IoIqAOgs6QKAOKgmxBGYmGYTTGuIWoMYKgL4kZl2jU\n", + "mKSnP4nPZ+KLxpi4oPjcEjWSF0XJPBGdxLCJC4QhGBbFgAoqLoCCbOf9caudnmF6urqru6t7+nw/\n", + "n/pM9+3bVb/u6Tp1696z8MHAJu+jlsc9LYENf2xBftxkuPcJOM67b0rBIWEY8HKyNYtEhWySezfF\n", + "8ILeGiY1a9+a0fUz8+oxjBzTsifL3rf9e70vonW4tYIpwIMSlX2yoi+iq3EunDdSW/FvXhzSmUmb\n", + "T6TzPePcncroXztDH0+/GphezqA/QsfYyubenisaUdWIvqgR/QFwKH8auoHOxx/AlONh5G3N3zcH\n", + "ONpzIw3EFtj+TldY3x2O2dDYnoJDQos1djOPj6C3DGCG3zBCIL66k/vrz2tDI/o6rqbFHmCBRKUs\n", + "yVvS5QbgJMq6/IRnl/TkrRFwzpm4EhwtuSJ2K0H2wMDZMG0EHBjz823ZcwW8O5mVZdv5y2/gv9+C\n", + "V6fEvdq1ixfZPBsXQBaIdXDb2V9k44lvQAdvzJ6i22dODH+6g4JUMcNvGAWGRvRT4Nu4+tXzPQ+Y\n", + "TB9jC3AdE1ZWIApP/xZeuJ7G2fHmBn3LdrQdPHEfzL8aLhwHRz9A8ikKb2pD28OO+LRAn7/vceDs\n", + "oJ+nQXX24jEsX7aB5Wmm6h4OvBxUhx/SHRSkghl+wyhAvCmT3wJnAHdLVCLeInAmeQh27+GoB51h\n", + "XlsZ91Jzgx43RbHkQrj/eTjh0p1cOrd961NSSac26oDhEpUDg3wQiYrsOIBBq8ZzWixJXQrePH2A\n", + "rsDrQTTkE2b4DaOA0YjOwy2WngQ80byyVcB976Fh3ygnf2c3neKTsO4957zXFMW7P6zj4T6T6LVj\n", + "I67wTIsFS5JNbWhEt+GM/+kBP85gXLW4dIz3MOClXNRNyBXmzmkYbQAv+OpmoBo4QyPaak3YlPZd\n", + "0/lZ3ux9GE+OXteaK2ICXYKrQHUTkFYUskTlLGCaRrQFF1jf+/gBUK4R/U4a7/0p0EUjel26x88W\n", + "5sdvGCGSyBc95zqich4uzUFNogjTNPZ5EK64+CjP4yedfQwB/gjMG3gLT5V9zCV+I2glKvsCbwOH\n", + "p1ol7PP/y5TFI1jSdy2v8ONUC7zs6sPwXdtY/95mfpRvQYpp205VDX1zMsLXYZtt6WxQUQ1TV4Fq\n", + "4zZ1FVRUh6KnlqOpZQ213ELJEV+Fqjo4u979TU8TtVxDLU8E1NW1Yw3P9biUz1b0avyypsKqCmhV\n", + "F7U8Ti2T0/q/dNimXNdVKfnQ9/+lAqqnwqo9oNvb+9eZ+98ems77bI7fMILS6aDL6X9+OWNvhCNn\n", + "eo1Jsy9mDY3oUmA4mzt8ifM3PUrX+ybAY6344PviVqBCovKVALq2jr+NHTfPp9Pxk2HRIa59OpQf\n", + "6lJ6t0Yahdi92IJ+8+DdIV76A3//l977cuWQkZQP+S7cPCYlnQWBRe4aRgp4c9b9gDHeNpqr2x3L\n", + "xi2wbgy8eUJc78Q+7NlGI/qhtKv6gHGjujDtOHj0T/D2cTjDV51y3QSN6GcSlStx2TiPTpR/Pxnd\n", + "oWTqKzBmHZTFVRvwEUH7NK5gzX4aUZ/pir2avweshFXx17oEWTHd/3YscHGHGir7roTbZ8O4tSnp\n", + "LAjM8BtGK3jJwo7BRczGjH1HXBHt+cCj/HJ8hB1zTt773ZkNs08Z7V5CfS28PRw+6x73QtoXpFnA\n", + "94DvAr9OZwexlNaDmlXDTRZBqxHdIlF5HjgNl7TOz9FcjMBLzddzm/5fvDw8FwDTvKbpY2/n4N9v\n", + "YXzzPbaV1ONm+A0jDolKb5oa+WNwybnm4wzfdcDr8a59Ujv4Vph2mN/cO7nDM3wrT23Wnt4FSSOq\n", + "EpUr2CULpMeJp7H5wPapLmR7hVPKmmew9BVB29B9Fd3a3yxyzhR/x02cE8kb3VfijH018CRwMfB3\n", + "jagOrpXXpsGhaeksAMyrxyhavGpRFcRP27jSegtpHNG/qBHdnHRfPrMv5pKWE6e1nA44pX2euuth\n", + "qNyPp+70WhPni2+JdFJaiwyupuTY33DFnw/nV+u9O5jkx93r/9J/xQNMXluKM/g7cNHPD7VU5nJQ\n", + "O6nuOoD/LV3HK9t38VE+ph43d07DSIKX234kjYZ+JC7ne8zILwD+6adqVKGQ6QuSyMQ6Sn4/gUuP\n", + "gIf+DzbEqkO2nFI6U3yeyvrcU2HZuW7zeVwvonk8bkR/MvBnnMFf2FpQlkSlFJemoW++Bm9ZWmbD\n", + "iMO7lS+n0ciPAQ7Dncjzcbfs52lE30u4kzaA/3TAfulWwvb94ek7oN2uuPZsL2R7C7VLvwXd4mt+\n", + "Jj6uRKUvLnhsKrAVuAu42P/isEvMlq9GPwhm+I02gZcPZjiNUzZjcAtxsdH8dFzlp7S8UYwY3rrB\n", + "ijOatWdnITsWRHUS3Y76iAm8tryGrVye8Lje6P5k3Oh+PM4N9JukWPrRI2eJ2XKNGX6jIPFuw+NH\n", + "8xVAA2665mHgUo3ouvAUtlVSKyIThKalDLcAz/AN1jAb2MopTY4rUTmExtH9+7gL/WQ/6zOtMBz4\n", + "XbBPkZ/YHL8RKn4KYHt5aIbS1NCX0Dian4+7JW8Trnb5Tq4WsmPlEt/bBw78tLF9BL12LubIpXR8\n", + "P8r1KxQ3uj8eV9N3ukY00Cjdfb7SGq55bjx3j57Hh5t+GfZCfSJCm+MXkSpcVF974B5VvamFPrcB\n", + "E4FPgQtV9dWgxzUKnwQFsMsOP1S6v3ERn9Bo5IfhUuLOxwXyXA+sydbcq5+LUTGT+XWDlomVSzzr\n", + "HJjUAN/xyqDs066sI+M/PpyRr80A3sAt1J6nEd0a9Jife0L1+HE5u0bDh3+thGmlroRkfhr/dAhk\n", + "+EWkPa4e5knAW8BiEXlSVVfE9akGylV1oIiMBO4ARgU5rtE26Ac1d0N5Q2+Y3+/zrfzf3XgQeB5n\n", + "6G8AFmlEP86FpviLkeLKjkyDssEitAXjX0gXtViw14wnYMxFcOT7ULkWPun/MnS6pCcPdpmnby4c\n", + "m9mjemkeDp7pAt+AdKOd85qACYJGA3Vxz68Frm3W507gG3HPXwP6ZCLRkG2FvZ0N9bsFPfZi9ILT\n", + "0TuHof/ojZ4p1IelqQrqFHT5geiE89FdgiroRPhL2N9X0C0+8VgqCdKa76MK6s6G+iqoy2bSsphe\n", + "BX32MLTPVWj1gT21a/vHPflnZ/x34pLZqSK7lC6b4pLuZf5YmdGLpvO+oFM9hwDxC2jrcb7RyfqU\n", + "AhsDHtsocLbA9nYKL9/dtP3TEMPiY9MLR7wP2zrAb0bC5QvbRo6W2B3W8IvhiUegdLNLPFbtEo8l\n", + "Hc3G3w3tEWin2b0balCdPViE0fS4v/MbQ3t1emEjdWdtZ8+9E2A3ZMeTKK4U5Laece0hp9/IMEGz\n", + "c/qdY22++BD+irIROl74fpP87mGHxcemF9opTJ8FPz8BXt+/beRo6QYlAgzdAI9VNLb7vaj1g5or\n", + "e1E+7asw4XzXlu2MlQ2qsxdS+u2/MnD1ukX/ZM9b4+HrF4BclKWUGElLQbYJgo7438JlKozRDzei\n", + "b61PqdfWBBGpjXtar6r1AbUZeU5sRFedYvh+NonPJfOFTfDDeTDm62w74L7Cz9ESu6hNaoAffRmu\n", + "XODak13UvGC4E3pdyPDKXvC9xXDj3MbXs303pNowW2QwcMr3mV2yD9PmHMWU3Yv0nk8z/jtpPFZ1\n", + "XqXfiCEilbgcQ8H2480TpSuiA/Av4Mu4CjkvAt/UvRd3L1XVahEZBdyqqqOa7UfV3DmNPCE+l8zm\n", + "dmyfczVle7pwk0b0nrC1BSE2VXNHO8oPuRL+PgNu+oA1C6GmpYutRKUDrpj7VUCPgXPZuXQBFV12\n", + "Ne1XDXWzVbOWrqEFXX2AxcAVGtGZyfq3ZULL1SMiE2l057xXVW8UkUsAVPUur8/tQBXwCTBZVV/J\n", + "hHjDyAUSlaOAucBQjehed6uFROyitvj0jsdt+ah3l131x67Zzc634zNdSlS6AlOAK3B38DcDsypq\n", + "qWrufjuVxBeObCJRGYYrwn6SV3imKLEkbYaRRSQqUVyK5q8Veu4WkcHVHNb/LiauLeV3DXhOq6vp\n", + "+3yU/1gzCBcQVQ/crBFdGP/edDJrZguJyjeB/wRGtPWcS4mwJG2GkV1uAF4BJgEZKWIeHgf/jLWz\n", + "Sul0GBywCjZ9AZheTpcR98Gau4CRGtE1Lb3TM/J5Md+tEf2DRGUIW9vPlQ4T3mF3j85hFrovJGzE\n", + "bxg+kaiMwBXsGFKoI0wXmTr4cXikC503N63M1e7Mebp7ZoYDorKLdBh0Cud+/CgffG1fno6l1Umt\n", + "PkAhk67ttGLrhuETjeiLwEOkWXYwP+hXA+XOC6dJOUZgz7YtIQgKxu7+3+exFfsyoB7KnvEawyt0\n", + "XyiY4TeM1PgpMEKi8tWwhaRHtxL4Cq6CZDxTthWmr3q3Ej7rDjNegDXxZY/DK3RfCNgcv2GkgEb0\n", + "U4nKVOAhicoLKRT1yBO2bIcTvMc/wTnj7QZWLy/MqREv0nbbAc3a21akbaaxEb9hpIhGtB54Cvhl\n", + "yFLSIBaZegLwM6AWeGcNfBAJV1e6FEekbaaxxV3DSAOJSndc4ZfJGtG5yfrnE/lYGD4Ibe3zpIL5\n", + "8RtGjpGoVOPSkg/RiH4Sth6j+DCvHsPIMRrR2cA84OdhazGMVDDDbxjBuByYJFEZHbYQw/CLGX7D\n", + "CIBGdBNQA9wrUekcth7D8IMZfsMIzuO4LLU/CVuIYfjBFncNIwNIVA4ClgJf0YguCVuPURzY4q5h\n", + "hIhG9B3gGmCGl8feMPIWM/yGkTn+B3gPV7jEMPIWm+oxjAwiURmAqw41ViP6r3DVGG0dm+oxjDxA\n", + "I7oWiOK8fOz8MvIS+2EaRub5HZ+035/6sgaRc+pFJta5tAKGkR/YIpRhZJraiip6f3FfLvxrf5b8\n", + "4kg+GgBMKxMZTLHkkDHyGxvxG0bG6VfDuzP7M/8qqLrMa7PiIEb+YCN+w8g43UoAmH8VdF8f127F\n", + "QYz8wEb8hpFxvOIgezrgpnliWHEQIz8ww28YGceKgxj5jfnxG0YWKObiIEbusEIshmEYRYYFcBmG\n", + "YRi+MMNvGIZRZJjhNwzDKDLSNvwi0lNE5ojIShF5RkT2a6FPPxF5XkSWi0iDiNQEk2sYhmEEJciI\n", + "/1pgjqp+AZjrPW/OTuAKVa0ARgHfE5EjAxwzLxGRyrA1BMH0h4vpD49C1h6EIIb/NOB+7/H9wOnN\n", + "O6jqBlVXjUhVtwIrgIMDHDNfqQxbQEAqwxYQkMqwBQSkMmwBAakMW0AAKsMWEAZBDH8fVd3oPd4I\n", + "9Gmts4gMAI4BFgU4pmEYhhGQVnP1iMgcoG8LL10f/0RVVUQSBgSISFdcQerLvJG/YRiGERJpB3CJ\n", + "yGtApapuEJGDgOdV9YgW+nUEngL+oqq3JthX+FFkhmEYBUg6AVxBsnM+CXwbuMn7++fmHUREgHuB\n", + "fyYy+pCecMMwDCM9goz4ewKPAYcCa4FzVPUjETkYmK6qp4jIWOBvwD+A2IGuU9W6wMoNwzCMtMiL\n", + "XD2GYRhG7gglctdP8Fdc3/Yi8qqIzMqlxtYo1OA1EakSkddEZJWIXJOgz23e60tF5Jhca2yNZPpF\n", + "5DxP9z9EZJ6IHBWGzpbw8917/Y4TkV0ickYu9SXD52+n0jtXG0SkPscSW8XHb6eXiNSJyBJP/4Uh\n", + "yGwREZkhIhtFZFkrfVI7b1U15xvwC+CH3uNrgP9qpe+VwMPAk2FoTVc/zhtqqPe4K/Av4MgQNbcH\n", + "VgMDgI7AkuZ6gGpgtvd4JLAw7O86Rf2jgR7e46p80e9He1y/53DOEGeGrTvF734/YDlQ6j3vFbbu\n", + "FPXXAjfGtAObgA5ha/f0HI9zhV+W4PWUz9uwcvUkDf4CEJFS3Ie6B8inBeBCDF4bAaxW1bWquhN4\n", + "BPhasz6ffy5VXQTsJyKtxmfkkKT6VXWBqn7sPV0ElOZYYyL8fPcA38e5Pb+XS3E+8KP/XGCmqq4H\n", + "UNX3c6yxNfzofwfo7j3uDmxS1V051JgQVX0B+LCVLimft2EZfr/BX7cAVwN7cqLKP4UYvHYIsC7u\n", + "+XqvLVmffDGefvTHcxGQL4VPkmoXkUNwxugOrymfFt/8fPcDgZ7e9OZLIvKtnKlLjh/904EKEXkb\n", + "WApcliNtmSDl8zZrxdaDBn+JyKnAu6r6ahj5NNpg8JpfQ9L8zipfDJBvHSJyIjAF+FL25KSEH+23\n", + "Atd6vychv+5w/ejvCBwLfBnYB1ggIgtVdVVWlfnDj/4fAUtUtVJEyoA5InK0qm7JsrZMkdJ5mzXD\n", + "r6onJ3rNW6joq43BX++20G0McJqIVAMlQHcReUBVL8iS5CZkQH8seG0m8JCq7hXnkGPeAvrFPe+H\n", + "Gxm01qfUa8sH/OjHW9CdDlSpamu3x7nEj/ZhwCPO5tMLmCgiO1X1ydxIbBU/+tcB76vqNmCbiPwN\n", + "OBrIB8PvR/8Y4AYAVV0jIm8AXwReyonCYKR+3oa0WPEL4Brv8bW0srjr9RkHzAp7kSUV/bgr8APA\n", + "LWHr9fR0ANbgFrg6kXxxdxR5sjiagv5DcYt4o8LWm6r2Zv3vA84IW3eK3/0RwLO4hdR9gGXAoLC1\n", + "p6D/V0DEe9wHd2HoGbb2OH0D8Le46+u8DetD9PR+JCuBZ4D9vPaDgadb6D+O/PLqSaofGItbm1gC\n", + "vOptVSHrnojzLlqNC6QDuAS4JK7P7d7rS4Fjw/6uU9GPcwLYFPd9vxi25lS++7i+eWX4U/jtXIXz\n", + "7FkG1IStOcXfTi9glve7XwacG7bmOO1/AN4GduDurKYEPW8tgMswDKPIsNKLhmEYRYYZfsMwjCLD\n", + "DL9hGEaRYYbfMAyjyDDDbxiGUWSY4TcMwygyzPAbhmEUGWb4DcMwigwz/IbRAiISFZHL4p7fkA/F\n", + "dAwjE1jkrmG0gIj0B/6kqsNEpB0uPcdxmj+J3wwjbbKWndMwChlVfVNENonIUFx67lfM6BttBTP8\n", + "hpGYe4DJuGyNM0LWYhgZw6Z6DCMBXj2FBlyq4YFqJ4vRRrARv2EkQFV3ishzwIdm9I22hBl+w0iA\n", + "t6g7CjgrbC2GkUnMndMwWkBEBuHKBj6rqmvC1mMYmcTm+A3DMIoMG/EbhmEUGWb4DcMwigwz/IZh\n", + "GEWGGX7DMIwiwwy/YRhGkWGG3zAMo8j4f5zK8+dXcH02AAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "#Test of the model\n", - "test_cases = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=50)\n", - "distance = []\n", - "timer = []\n", - "\n", - "for sTest in test_cases :\n", - " start = time.time()\n", - " mTest = model.inverse_prediction(sTest)\n", - " end = time.time()\n", - " sTest_goal = environment.compute_sensori_effect(mTest)\n", - " distance.append(spatial.distance.pdist([sTest,sTest_goal])[0])\n", - " timer.append(end - start)\n", - " \n", - "# Distance between the predictive and effectiv value\n", - "inv_comparison = {} #to remove after the first use\n", - "inv_comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "####Nearest Neighbor inverse model\n", - "\n", - "\n", - "To perform the inverse inference, the Nearest Neighbor inverse model looks in the dataset of tuples $(m, s)$, the nearest neighbor of the given $s$ motor command, and return its corresponding $m$.\n", - "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. " + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "modelNN = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelNN)\n", + "inv_NN = generateInvTest(environment, modelNN)" ] }, { @@ -449,6 +3592,992 @@ "But to perform the inverse inference of a given $s$, the Weighted Nearest Neighbor model looks at the nearest neighbor of $s$ in the dataset and gets its corresponding $m$. It finds now the $k$ nearest neighbors of $m$ in the dataset, and returns their average weighted by the distance of their sensory part to $s$, with a gaussian of standard deviation $\\sigma$ (parameter)." ] }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXncZEV1979nhkE22WQRkE1EEQIIyGJAfRRfGcYEEhPl\n", + "RVlEI2TBGTVG4oIMvKKSRYOSACIuQAAFIQGDg+uMhE1GAUcWwwzrwEhgAEEHZJnz/lHVM/fpp2/3\n", + "7e57+y79+34+/Xme2/d2Vd26devUqXNOlbk7QgghRItpZRdACCFEtZBgEEIIMQkJBiGEEJOQYBBC\n", + "CDEJCQYhhBCTkGAQQggxCQmGBmNmT5nZdiPMb66ZnT+q/OqMmX3azB4xs4cKzGNtM7vSzJ4ws28W\n", + "ma+ZfczMzskzzbwxs/eY2TUl5b2dma00s2nx+CozO3IE+Q70TtZCMJjZvWZ2YEl5v9LMLokv0xNm\n", + "dquZfaj1gKuMu7/Y3e8dZZaD/nCchIqZbQN8GNjJ3bcsMKs/BzYDNnb3w/LK18wmzOyB5Hfu/ll3\n", + "f/9wxR0f3H2Wu/ds77Hve/MwWQ3yo8p3bhFniE5nUMxsB+BG4D7gD9x9Q+AdwF7Ai0ddnqyY2Rpl\n", + "ZV1SvnVjG2C5uy8vOJ9tgf9x95UjzrfxmNn0EWXllPFeuXvlP8A9wJvj/+8B/hv4R+Ax4G5gZjx3\n", + "GHBT228/BPzngPleAFzZ45pDgNuAx4EfE0ZjrXP3Ah8BfgE8BZwLbA58F/gN8H1gw3jtdsBK4P3A\n", + "g8BDwN8m0toHuD7m8xDwJWBG4vxK4K+Bu4Alie9eHv+fFcv5JLC0Le33x98tB/4T2KIt3eOA/4l5\n", + "n9GlLk4CLgEujvn8DNgtcX5L4NvA/8bn9oH4/Uzg98CzsZ5uBiaARYnffh/4aeL4GuCQbunGcwb8\n", + "PbAYeBT4JrBRW50fRRD+jwAfT7m3NWO5jo/H04FrgU+mXL8BcF4s073AJ2JZ3gKsAF6I9/rVDr/d\n", + "BPhOrO/lwE8AS8lnp1g3y4E7gXfE709uq9NjO+UL7AdcF/O6BXhjIu2Nga8R2uNjwGXAOsDTiXSe\n", + "BLYA5gLnx999F/ibtnLeCvxJtzKn3N8xwO0xnyXAsYlzE4S2/GHgYcJ78Z7E+ZcAVxDetRuB/wdc\n", + "k5JPqy2kvX9zgUuB82N6743P+Nx47dKY/rR4/TTgn2KbWgL8TUy/dX4+8L62d7B1n7cBe8S8XojP\n", + "7SngIxme2fbAgpjO9wj9xPl9932DdJij/jBVMDwLvI/wov0l8GA8t06skFckfnsT8M4B810GHN3l\n", + "/CuB3wIHEjqKvyN0sGskyn0dsCmh83oY+DmwO/Ai4IfAp9oa5r8DawN/QOhUDozn9yQIh2mEkeDt\n", + "wJxEWVYCVwMbAi9KfPfyxL3s76s7rT3i/2+Ojfc1hM7vi8CCtnSvANYHto5lOiilPubGZ/P2WB9/\n", + "S+iop8dy/wz4JLBGbMBLgLfG354EnJdIa21CB7QxMCPW3QPAuvHcCmCjDOnOic9gy5jOWcCFbXV+\n", + "dnweuwHPkBDubfe3C6GD3InQ0V9Heod9HnB5LO+2wK+A98ZzbwQe6NKuPgucGetteuu5dbhu3Vgn\n", + "R8d6eE18lq9OqdNJ+QJbEYRla2D1lnj8knj8X8BFsb2sAbw+rfzJvIAjgf9OnNuZ0InN6FXmDvc4\n", + "C9g+/v8G4HesbrsTwHOEdjcdODie3yCevzh+1o7Pbinwk5R8Wm0h7f2bS2jbrcHIWvH5nhmv35Qg\n", + "fI6N5/8SuCPW8UaEQeMLrBYMP060h3fEsu0Vj3cAtmnv+zI+s+sJAmkG8HpCf3hep3vu2vcN0mGO\n", + "+sNUwXBX4tw68YFuFo/PB06M/+8YK2atAfN9ltjBpJw/Ebg4cWzxAb8hUe7DE+cvBf41cXw8cHlb\n", + "w3xl4vxpwFdS8v4gcFnieCUw0XZNUjDcRxg1rt92zbnA5xLH68b73iaRxh8mzn8TOCGlTHOB69rq\n", + "4yHgAGBf4L626z/G6pHrXNpGNoSR8p8SRkhXE17yg4A3AbfGa3qle0fbi7VFvL9piTrfMnH+RuCw\n", + "Ls/8w4ROfjmwQ8o10wmj9aT2eCzw4/j/BN0Fw8nAf6Sln7juMNo6OoKQaw02JtVpe77ACbR1GsA8\n", + "gga1BaEj26BDvlPKz2SN4cWEAdPW8fhUYjvuVeYM7+TlwOxEOVYQO9v43cOEAdT0+JyT79Op9NYY\n", + "Or5/8f7mJ85tThhErJX47nDgR/H/HzFZu/k/TNYYkoLhahJablu52gVDt2e2DUFQrp049+8MoDHU\n", + "xcbQzq9b/7j7ivjvevHvhYQHBPAuQsf7THsCZvb66LXzlJktSslnOWGkmcYWwP2JsjhhNLRV4pqH\n", + "E/8/3Xb8TKLcLZJGvftb+Ucj+HfMbJmZ/YbQyF/S5bft/Blh9HWvmc03s/0S93Bf4h5+R7jv5D38\n", + "OvH/ig5lTrI0kZbH4y0JjXZLM3u89SF04Jt1SWsB4eV/ffx/AWG0+gaCKg5hNN4t3W2ByxPnbgee\n", + "J7zYafe3bpcynRfv5Sp3X5JyzSaEEdt9ie/uZ3KdduMfCVNf3zOzJWZ2Qsp12wL7tt37u5h8b93Y\n", + "FnhH2+/3B15K0A4fc/ffZExrFe7+FEHbaL2H/5fQQfVdZjM72MxuMLPl8dpZTG73y321DQVWt89N\n", + "CVpO+/vUi47vX2Rp4v9tCc94WeI+zor5Qnivsub9MoKWm4Vuz2xL4HF3fzpx/X2dEulFWUbKIvkB\n", + "sKmZ7U5okB/sdJG7X0NvA/IPCB3q11POPwTs2jowMyO8UA92SbOXIWkbwoi09X8rrTMJUyaHufvv\n", + "zOyDsWxJPC1Rd18I/Ek0mn0A+FZM/yHCaKl1D+sSXrxu99CNrRNpTSM0+gcJo8973P2VKb9b2eG7\n", + "BcDnCY37s8ATwFcIAvWMeM0DPdK9HzjG3a9vPzGgK++/Eeb/Z5rZ/u5+bYdrHiWM3LYjaCwQ6npp\n", + "h2un4O6/JdimPmJmuwA/MrOb3P1HbZfeT5j2e2taUj2yup8wmjy2/YSZbQFsbGYbdBAOndJt/+4i\n", + "4KToHrqWu/84Y5mTZXgRwXZ0BMFO+IKZXU42Y+wjhAFA+/vUi7T3Dybf4wMErfAlbYKpxbK2/Lrl\n", + "/QDwipRz7fXa7ZltC2xkZuskBszbEt69vqirxpCKuz9HMID+E2Fu7/tDJHcS8Idm9g9mtjmAmb3C\n", + "zM43s/UJnevbzOzNZjaDMKf+DGHueVA+Gf3PdyFMm30zfr8ewQC1wsx2Av4qa4JmNsPM3h1f8pbR\n", + "sNVYLgKOMbPd44v4GeAGd08b4fR6Kfcysz+NnlEfJNTHDQRbz1Nm9tF4f9PN7A/M7LXxdw8D20Xh\n", + "2uI64FXA3gTD8+3EESdhmgnC1E+3dM8CPhNdNTGzTc3skB730PEeo9/5HoT58dnAN6IgnUSs428B\n", + "p5rZevGF/RDBmaEnZva22M6MMBX6Ap1f7u8ArzSzI+IznmFme8f2kXofCS4A/tjM3hrrba3oirqV\n", + "uy8jGJH/zcw2jGm/If7uYeAl8R1YVey2tK8iPKuTCVOAWcucZM34eRRYaWYHAz0FCqx6BpcBc2O7\n", + "2Jnw3HoJy7T3rz39ZQTj7ufN7MVmNs3MdkjU0beA2Wa2lZltRHCASOMrhEHAnhZ4Rau9Eup6h8S1\n", + "3Z7ZfcBC4ORYrwcAf9TjfjtSR8HgTH247ccXEgzCl6RI82wZud8NvI4w8rvNzJ4g2AluAn7r7v9D\n", + "GM18iTBCeRvwx+7+fI/yJ/9vL/sCwjTCD4B/dPcfxO8/QlC5nwS+THjZ2tPqltcRwD0WpqGOBd4d\n", + "7/GHBFvJtwnaw/YETSst3U5lTp77D8I88mMxj7e7+wvxRf0jgrHxbkJ9fZlg1IYgzAGWm9nCWLYV\n", + "BC3ptkSdXgfc6+6PxmtW9kj3dILx/Htm9iTBOLdPl/vr+F18Ub8AHOXuK9z9IsJL+PmUuvgAwRB6\n", + "N8GD6t8JHj7d8m2xI2FA81S833919wVTChk0i7cSnteDhFHqZwmdaSuP1HfF3ZcChwIfJxha7ycM\n", + "blr9wpEEzedOQgc1O/7uTsKA4m4zeyxqF96W9rOEjvlAwvuYtczJ+3sq5vktQns6nOA11/F+OnA8\n", + "YUD1a+Cr8dOLtPevU10eFct9eyzfJYQpHYBzCLaDWwnt5NtpZXX3SwlTwxcS3u/LCINaCHXzyTht\n", + "9OEMz+xdhIHTY8CngG9kuOcpWDRQFIKZfZXQWf6vu++acs0XCd4EKwiuZjcXVqAKE6c17iZ4NA0s\n", + "zIQQ/aP3bzJFawxfI/iod8TMZhFcS3ckjGLPLLg8QgghelCoYIgG3se7XHIIUdVx9xuBDVtz+WNK\n", + "ceqbEKIXev8iZdsYtmKyS9dSghfL2OHu97r7dKmxQowevX+TKVswwFRvBkltIYQokbLjGB4k4ffO\n", + "ap/3SZiZhIUQQgyAu/e9CF/ZguEKgkvZxRYicZ9w94c7XTjIzTURM5vr7nPLLkcVUF2sRnWxmrGs\n", + "C7MdCe64B8RvLgDmWFjFoG8KFQxmdhFhCYNNLKzffhIhjBx3P9vdrzKzWWa2mODzfUyR5RFCiEYR\n", + "VheYTQhMXZsQs3Ec7lfE8wMlW6hgcPfDM1xzfJFlEEKIRpKiJeD+2LBJV8H4LPpjftkFqBDzyy5A\n", + "hZhfdgEqxPyyC1AoZtMIa6XdShAKvwYOxf3IPIQCFBz5nBdm5rIxCCHqTAzonU3Yy+EZ4IvuflWf\n", + "ifSlJQzad5ZtfBZCiMYThcLpTF5FdQczI5Nw6GVLyBlNJQkhRPHMZurS2q8gLLbYnaAlLCAs4rg2\n", + "QUvYpSihABIMQggxCtZK+X7t1F+MwJaQhqaShBCieKbsIhl5uuO3BXocZUEagxBCFM8XCfs8JFlC\n", + "2MtlNSVqCUmkMQghRMHEYF4INoW1CZrClyYZnkvWEpLIXVUIIQYgF/fTkFBhHkdyVxVCiBExtPvp\n", + "6oQqoyUkkY1BCCH6IAqFbzCo+2lIpBK2hDSkMQghREYSmsImKZeku5+uTqSSWkISaQxCCJGdToFq\n", + "STq7n0LltYQk0hiEECI7aYFq0Mn9tEUNtIQk0hiEECI7aYFqjwKzpxiea6QlJJFgEEKI7KQFqh3d\n", + "QSiMfI2jvNBUkhBCZCRjoNpIV0ItAgW4CSFEXlTMljBo36mpJCGEGBazad8zO/sZuBM4YDn8/stw\n", + "StVtCWlIYxBCiGEw2/F/4fLNYBeA84E5wOPBFjFnoGUyMmXbe0kOLYkhhBCjJGFL2AzWXgYcB1y5\n", + "+opWJHTugiG3JTnS0pfGIIQQfdJmS7gSHj4aNn986pWPA79gmEX2OmZv84CDOpya5+4HJ66TjUEI\n", + "IQolJS7hELilg1AA2Ah4I6ETPz2O9POg/x3h+kCCQQjROMxslpnNM7P58e/wHXL3uIRO8Q3tZF9k\n", + "rzf97QjXJ7IxCCEaRe7z7xniEjrEN+wKbNwhtVxG9ARBtAOT7zF9SY4+kY1BCNEoss6/Z0xsoLiE\n", + "XMuQnscsugXaIa8kIYRoMfz8+/DRy4WO6IGW9lOIK6wEgxCiaQw3/55D9HKmpTMKoENsw2DpaCpJ\n", + "CNEkUmwMS+i0+unkH9Z6jaOU+0ZTSUKIsWeg0XrF1jgakF6bCGVGGoMQYnypuZaQxMzmE2ImJiGN\n", + "QQghstIMLSHJwDaFdhTgJkSFKSRQq2TKvCczmzXdbN4pZotbK6FSk13VMpAlyC4T0hiEqChFL5RW\n", + "BmXek5nN2hn+7SzY9vXxu0vhqdNgzk01nDpqJ8W2MnOQtGRjEKKiDBsklWVZ5lEzisCvlIynnQq3\n", + "fQh2WgdoWwm12LxLRAFuQjSPgQO1KqxtFLr4W0eiLeETsBNM2i+h+LxrSqE2BjObaWZ3mtldZnZC\n", + "h/ObxDnGW8zsl2b2niLLI0TNGCZQq5PrYp6LuA1KoYu/TaJtJdTl8PtDgKOYJBSKybvmFCYYzGw6\n", + "cAZhjmtn4HAze3XbZccDN7v7a4AJ4J/NTFqMEIFOxsSsyyqMfmSejWHuKTsdVkKdCUddOYq8G0CR\n", + "nfA+wGJ3vxfAzC4GDgXuSFyzDNgt/r8+sNzdny+wTLlRxflb0SyGXFZhdCPzPih8qYgucQk3AWb2\n", + "28LybhBFCoatgAcSx0uBfduuOQf4kZk9BLwYeGeB5cmNCs/fioYxxEJphS/iNiiFLf6WIS4hS95m\n", + "dhJhNmMG8Bxwhruf3HZNoweGRQqGLO5OHwducfcJM9sB+L6Z7e7uT7VfaGZzE4fz3X1+PsUciG7z\n", + "t41pHKK+lLWIWynkGL0chcInCEKhxSfioO/keE1lB4ZmNkGYlh8unaLcVc1sP2Cuu8+Mxx8DVrr7\n", + "aYlrrgJOdfdr4/EPgRPcfWFbWpVyV00LPQcWuPvEaEsjxBiTc/SymT0CbNLh1KPuvmm8phyX2wGo\n", + "4p7PC4EdzWw7M1sTOAxol+B3Am8BMLPNgVcBdxdYpryo5PytEC2aGDE9iZS9l3OIXp6R4fuqGvZz\n", + "o7CpJHd/3syOB64GpgPnuvsdZnZcPH82QfX7mpndShBSH/V6hKRXdv5WiCpPdeRCsWscPZfh+8YP\n", + "DBX5PCBZttUTogyqOtUxtMF2BCuhptgYniNMeXezMfTe76EEFPk8YorcVk+IIancVMfQWkz+toSO\n", + "QsrdT45G+1SvpHEw7EtjEKJhVFFjGLhMBWgJKUJqMTAn2bk3wSVVGoMQokUVbWD9azHF2RJ6ups3\n", + "3k7TAwkGIRpGRac6shtsi7clZBFSYx2rJMEgRAOpoA0smxYzml3VsgipytlpRokEgxCicHpqMaPd\n", + "ezmLkGq8S2o3ZHwWYsTU2ahZSNlL2Hu5l7v5IC6pVXyuMj4LUQPqbNTMveyj1RIm0WuqrV87TZ2f\n", + "ayekMQgxQqroSpqVXMtegpZQJFV9rlVcK0kIMZU6GzWHL3txaxyVTZ2f6xQ0lSTEaKmzUXO4sjdM\n", + "S2ijzs91CtIYhBgto9nashgGK3tztYQkdX6uU5DGIMQIqWjwWSYGKnuztYRV1Pm5dkLGZyFE/uTk\n", + "cVRFF9A6IXdVIUQ1yElLaJoLaJ2QjUEIkQ/52xK6rVck2shz1z5pDEKI4emgJewNVy6Ev8bswww2\n", + "DdQoF9AiSdOuBk1PgkGIMaGg5Sw62hIMnmf4aaDauoCWYBtJ064GQoJBiDGgkPn6braEEAk87LLV\n", + "VdxXoicl2UbStKuBkGAQYjzIb3+BbB5HQ08DlekCOuSIv4y9HNK0q4GQYBCixvTRgeUzX5/d4yiX\n", + "aaAy9pXIYcRfhm0kTbsayM4gwSBETemzAxt2OYt+4xJqOQ0UGXbEP3LbSJp2BfzXIOlJMAhRX/rp\n", + "wAbvqAeIS6h5JPCwI/5ShGIn7So+g76RYBC1Q9Gwq+jagXWopwuA/ci+nMVQ0csV3F40K0ON+AcR\n", + "ilVr0xIMolYoGnYSqR1YF7/2OZnqaUzWOEph6BF/P0Kxim1aayWJWlHVDVHKoNv2k/HTfz2VuKta\n", + "lei19WfbdUON9Its01orSYwLioadzJPAY4ARhMJJcSrjoynXp9fTeGsJk8gy4s9xpJ9rm24TVgOh\n", + "tZJE3ahtNGyeJDqlPYGNgY2ADROXZK6nF5m97VSzO56BO4EDnoHHad5+CUWQ11pOubXpRLs4CHhj\n", + "v79vIcEg6kajNkQZgl6dUqZ6OtrsL66BSz8BO60F084HtobH45IWojt5jfTzbNOd2kXfaCpJ1Iqa\n", + "u0HmSddOqWc9RVvC2fDPa8G0ZcBxwJUhjZdTbJRuU8gtiC/HNp3L0hgSDKJ21NgNMk96dkqp9ZSw\n", + "JawFnA/MIcwfJSjMZlM118whyC1eIcc2ncvSGBIMonI0qOMokv47pQ4eR8fAQ18Pdop2CrHZ5Oma\n", + "WXY7qaj22qld9I+7V/4Till+OfQZybOeBdwFeOJzFzCr7LJV7RPr6rvA/Pg3vY5gR4drHDx+zvdg\n", + "tO5U34uLqm9gXlterc931U4KaRc+SBqKYxCVQnEKOZMhLiGrz34+xbH5dPaWWeDuE32ko3aSAcUx\n", + "iKagOIW8yBiX4KO12eTlmql2UiCFuqua2Uwzu9PM7jKzE1KumTCzm83sl3E0IcYbxSkMS/57L+dJ\n", + "J9fMZ4DN+tyjWO2kSAqc55pOaADbATOAW4BXt12zIXAb8LJ4vElKWgPNk+lTvw8jnvNO5DmPMCc7\n", + "b5i88kxroE+KLaHs59qhjm4CVjCgjWDYdlL6cxpdXfsgv8s0lWRm6wBbu/uvslwf2QdY7O73xjQu\n", + "Bg4F7khc8y7g2+6+NN7Bo32kLxqIr/b0OIXgT+/AE0XlV4CXTDmLodVojaP4jGczddon854HPoRH\n", + "UBUXrasaPaeSzOwQ4Gbg6ni8h5llaWxbAQ8kjpfG75LsCGxsZj82s4VmdmS2YosxYAPCMg8bA3sB\n", + "p/c51ZCVvJY1yDut7ARbwgLgC4RO8gJglyoKhQS5bP3p7ge7+0T8m8fWm4JsNoa5wL7E+Bd3v5kw\n", + "kutFFnenGQQf6lkED4MTLTRyMd6M8sXN04i5ZY5p9abatoRelGkjkOG6B1mmkp5z9yfadgJameF3\n", + "DwJbJ463JmgNSR4AHnX3pwlryP8E2J0wdzgJM5ubOJzv7vMzlEHUk54vbo7BTbl0ULE8afvr5t/Z\n", + "1X8l1DK3/mys4drMJoCJoRPKYLz4KvBuYBFh6udLwFkZfrcG4UFvB6xJZ+PzTsAPCIbqdWIeO+dl\n", + "QNGnnh96BEGRY3BTSlp9G7u7lPl3g5Qr9QPTHD7osCIal5c5HFL2MxvwOWcP0Ms/35E6OJRYxz7Q\n", + "7zIkvC7BoLUwfk4F1spYqIOBX8VK/1j87jjguMQ1HyF4Ji0CZud5c/rU89Prxe0lOAbMb6gOKv62\n", + "U5l+kchjOC+YGngc1eVTllAq4T59kN/1jHw2sz3d/eddLyoYRT6PH92icfOKns2TbpG4BC273Qtm\n", + "Mdm32ayNx5GoFkVGPn/ezF4KXAJ8091/2XfphOgT7x6NW8U54m5z5t2M6d0FQ/1tCaKG9PRKiiOw\n", + "NwGPAmeb2SIzO7HoggnRhcpt1hMF2RyChrAg/p0dv+/fC6beHkei5vS1iJ6Z7QqcABzm7jMKK9XU\n", + "fDWVVEHKXPZ4lAu/DUvfC75JS+hJ2Utu14XCppLMbGfgncCfA8uBbwIf7ruEolGUHT3aY6qpamRz\n", + "zZQtIRNlt71xIIvx+QbgYuASd39wJKWaWgZpDBVDyx73R08NR1pCZtT2slOYxuDu+w1WJNFwFD3a\n", + "B6kajrSEQVDbK5hUwWBml7j7O8xsUYfT7u67FVguUX2q6BlUL6QlDIraXqQoW0s3jWFO/PtHQLsq\n", + "Uv1t30TRlLmkQb2RljAsansUa2vJYmM4zd1P6PVdkcjGUE3q5BlUGaQl5ILaXjZby6B9ZxbBcLO7\n", + "79H23SJ337XfzAZFgkHUHmkJImeyrACQu/HZzP4K+GuCapK0M7wYuLbfjIQYW6QliGIozNbSzcZw\n", + "IWFxqc8RgtpaUucpd18+bMZCNB5pCaJYCrO1ZJlKeh1wm7s/GY/XJyyffeOwmWdFU0midkhLECOg\n", + "l62lSBvDLcCe7r4yHk8HFrbbHYpEgqFZ5OliV7mlEXLSEip3X6KWFLm6Ki2hEP9/IQoHUTOq0Nnk\n", + "6WJXuaURctISKndfYuzIsufzPWY228xmmNmaZjYHuLvogol8SXQ2BxE8GQ4CTo/fj5I893Ouxqbu\n", + "+a+EWo37EmNLFsHwl8D+hD2clwL7AccWWShRCFXpbPJczqD8pRGClrAA+ELM9wJglyENzOXflxhr\n", + "sqyV9DBw2AjKIoqlKp1Nni525S2NUKzHkZZ8EKXSU2Mws1eZ2Q/N7LZ4vJuZfbL4oomcqUpnk+cm\n", + "O+Vs2FOMlpCkchsRifEii/H5HODvgLPi8SLgIuDTRRVKFEIl1pdx96vMDHJYziDPtDJRgJaQ5hAw\n", + "0vsSoo0s7qoL3f21yaUxzOwWd3/NSEqI3FXzQuvLDEEBcQkp3keLgTl6LiIPinRXfcTMVjVcM/tz\n", + "YFm/GYnyqdmuZ31RmCtusbaEbg4BjXxOoh5kEQzHA18GXmVmDwH3AO8utFRC9EFhfv/FRy/35RBQ\n", + "hTiUOqB6Gp5ui+jNcffTgS3c/UAzWw+Y1loaQ4gKke/Ie3RrHGV2CFDQWzZUT/nQzSvpvfHvlwDc\n", + "/bcSCqKi5OeKW7zHUZJ+vI+qEodSdVRPOdBtKul2M7sL2KrD9p6V2dpTaqMgD1fcElZCzeJ9lGjf\n", + "aXuvK+htMlWJ16k1qYLB3Q83s5cCVwOHMHV7z9KR2igiw7nilrgSajeHgJT23Y6C3iZTlXidWtPN\n", + "xvDDaFu42t3vG2Wh+kBeHQ1iUO1vYL//6u+X0Kl9J1HQ21QqEa9Td7pNJW1hZvsDh5jZxQSNYVXQ\n", + "g7v/vOjCZUBqY0MYVvvr2xW3HvslpLXv3wDXoziUKSg4MB+6CYaTgBOBrYB/7nD+TYWUqD+kNjaH\n", + "0Wh/1dcSkqS17+tbm72LqTQ5XmdUdLMxXAJcYmafcvdTRlimfqi82ijjeGaK1/7qoSUkqXz77oXa\n", + "fz3JEuD2aTM7Etje3U8xs22Al7r7TwsuW0+qrjbKON4XxWl/9dISVlH19t0Ltf/6kmWtpLOAlcCb\n", + "3X0nM9sY+J67v3YUBYxlqOVaSWY2j7AhTjvzNBUwmZROZAkwu+LRywPT9NG02n/5FLlW0r7uvoeZ\n", + "3Qzg7o+Z2Yy+SzieNMI4PooOLPfRccW1hDEZTTei/Y8jWQTDs8k9ns1sU4IGIXpTe+P4KDuw3IyG\n", + "FdYSEoyDq3Xt2/+4kmVrzy8BlwObmdlngGuBzxZaqubQhA1X6rPEQP57LxfJOIymm9D+x5IsW3te\n", + "YGY/Aw6MXx3q7ndkSdzMZgL/AkwHvuLup6VctzfBL/ud7n5ZppLXgLobDyP16MDqoSUkafxouiHt\n", + "fyzJMpVEFASZhEGLOP10BvAW4EHgJjO7ol2oxOtOA+ZRwWU3hqUMn+qcbQLV7sAqbkvoQu1dUbOg\n", + "mIJ6kkkwDMg+wGJ3vxcgRk8fylQB8wHgUmDvAssyNhRgE6huBzYCLaEow7tG06LKFCkYtgIeSBwv\n", + "BfZNXmDUoGAaAAAO9UlEQVRmWxGExZsJgqG776zIQq5GzUp2YCPSEoo2vGs0LapKT8FgZju7++1t\n", + "3024+/weP83Syf8L8Pfu7hZ6n8ZNJZVA7jaBSnVgo7UljIPnkBBTyKIxfMvMzgf+gdC5nEYY3aet\n", + "D9/iQWDrxPHWBK0hyV7AxXFEuglwsJk95x1GfmY2N3E4P4NgGleqbRMYlHJsCfUwvAsRMbMJYGLo\n", + "dDJEPq9LEAavBdYDLgQ+5+5dYxnMbA3gVwRvpoeAnwKHp3k0mdnXgCs7eSXVNfK5DAqLIC6TEWoJ\n", + "bTaFXQgDlnYUuStqQZGRz88TRptrE16Wu3sJBQB3f97Mjids9DMdONfd7zCz4+L5s/strOhNJW0C\n", + "gzJiLSFFqD4HJCP9q2F4F6JAsmgMtwJXAKcQRk9nA79393cUX7xVZZDGMG6UEJfQZW2fR4HbqLOQ\n", + "FWNJkRrDX7j7TfH/ZYSNe47qNyMhMlFuXEKaTeE2d58YQf5CVIIskc83dfjuvGKKI8aa8qOXm2m4\n", + "F6JPsqyVJESxVGeNI63tIwTFBrgJ0ZvytYRVNMpwL8QQ9DQ+VwEZnxtIfdc4EjWm6ZsjtVOk8VmI\n", + "fKmQliDGhzHZHCkXZGMQo6M6tgQxntRnb5GSkcYgRoO0BFE+WuIkI9IYRLFISxDVQe7IGZFgEMUR\n", + "tIQFwBcIo7ILgF1kYBYlIXfkjGgqSeSPPI5EBZE7cnbkrloBGuVCJ1uCEJVB7qo1pTEudNIShGgM\n", + "sjGUT/1d6GRLEKJRSDCUT31d6ORxJEQjkWAon3q60ElLKAUzm2Vm88xsfvw7q+wyieYhG0P5fBHY\n", + "galbca5yoauUcVq2hNJojD1KVJ5GeCVVquMcgFj+ji508dw5wJaJnzwEvH/k9yiPo1Ixs58Be3Y4\n", + "pT2oRUcG9UqqvWBIGUUtBuakdZx1EiRmthDYq8Ophe6+94gKIS2hZGKbvZTOtqcF2mFOdGKc3VW7\n", + "efVM6exrqI6/POv3hQg8aQlVYTbpDgnVtkeJ2tEEwdCvV09fgqQu5C7wpCVUjbR2/jRa0kHkTBO8\n", + "kvr16qmbe+g9Gb/PLx5CHkdVJK2d31ZRTVfUmCYIhn4Xxqqbe+iJwLK275YBn2r7bniBp7iEKpPW\n", + "zk8qoSyi4dR+KmmAhbF6uodWiXh/f0Hv+xtO4MmWUGm0AJwYJbX3ShowvVT30LqSYmNYAszuem85\n", + "2xLq5PElRNMZW3dVsZq+BV7OWsIgrsNCiOKQYBDZKcjjyMzmAQd1OKUALCFKYJzjGEQ/FGtLqJvH\n", + "lxCiA03wShJZGI3HUd08voQQHZBgGAdGF5egPXWFaACaSmoyI45elkulEM1AxuemMsZxCXKZFSIg\n", + "47MIjPkaRzVcJFGIyiGNoUl00BL2hisXwnsZk9GzXGaFWI00hnEmRUsweJ6po+fXm9kSwmY/TRQS\n", + "cpkVYkgkGOpON1tCGD23r7i6DrBr/DRxikUus0IMSeHuqmY208zuNLO7zOyEDuffbWa3mtkvzOxa\n", + "M9stp3ybvWl6triEtNFzi8GW5a42cpkVYkgK1RjMbDpwBvAW4EHgJjO7wt3vSFx2N/AGd/+Nmc0E\n", + "vgzsN2S+nQyQbzCz24FP1X6EnN3jKG30nKRRUyxymRVieIqeStoHWOzu9wKY2cXAocAqweDu1yeu\n", + "vxF4WQ75dtq0Zm3C3smn13b6pH+Po05LjLfTuCmW+Gzr93yFqAhFTyVtBTyQOF4av0vjfeTzQneb\n", + "Qqnn9MkA0cuxg5wDzAMWASvaLtEUixBiCkVrDJl9Yc3sTQS3yv1Tzs9NHM539/ldkus1hVKf6ZMh\n", + "4xKSo+cm7kMhhFiNmU0AE8OmU7RgeBDYOnG8NUFrmEQ0OJ8DzHT3xzsl5O5z+8i31xRKPaZPco5e\n", + "1hSLEM0mDpjnt47NbKCtX4ueSloI7Ghm25nZmsBhwKSRrpltA1wGHOHu7d4kA5GYQvkZU4VA9adP\n", + "ClwJtfHeWkKIoSlUY3D3583seOBqYDpwrrvfYWbHxfNnEza13wg4M3qTPOfu++SQ91XAVbWbPilw\n", + "jSMtFyGEyIKWxKgKI1jjSMtFCDFeaEmMOjO6lVC1XIQQoifaqKdMRrOrWhItFyGE6IkEQ1mMble1\n", + "JFouQgjRk0ZOJVV6o5YS90vQchFCiCw0zvic4nmzGJhTegc4xruqCSFGz6DG5yZOJXVaJ6ncZTBG\n", + "b0sQQoiBaaJgqJbnTTm2hIFRAJwQook2hmp43tRw72UFwAkhoJkaQ/meNzXTEhJUbxpOCDFyGqcx\n", + "lOp5U0MtoY0tU75XAJwQY0TjBAOUtIpojTyOOrnzxlM7pPxEAXBCjBGNFAwjpWZaQpodAXgSWKfD\n", + "T1agADghxorGxTGMlBppCS26LKT3GLBxh+8XuftuxZZKCFEEimMYJfWOS0hz501rPA+uukCurEKM\n", + "BZpK6pcaagltpLnzLgE2ZPIU0ypvLrmyCjE+aCopeyFqZUtII6WDX0K4N0jx5tJeDkLUD+3HUCT1\n", + "1xJWkcGdN230X62IciFEYUgwdKMhWkI7A7rzViOiXAhRODI+p1Hf6OWi6BRRvgK4oYSyCCEKRIKh\n", + "nXp7HBVG1DIuIAiDFusAR8g7SYhmIcGQRFpCL17H1CA4raUkRMOQYABpCdmRAVqIMUDG5wZ5HI0A\n", + "GaCFGAPGV2OQljAI5S9pLoQonPHUGKQlDESpS5oLIUbGeEU+NzQuQQghOqHI515ISxBCiEw038YQ\n", + "bQkvwCLggEfh2WPg5wYXSSgIIcRUmj2V1KYlnA/MAR4PZxcDczQ/LoRoKtqPIUmbx9Fy+P0hwFGs\n", + "EgqgwCwhhOhI82wMHWwJu8D2D8P+Ha4uJTCr057L0lyEEFWhOYKhi8fRw2EvgU6MPDBLG94IIapO\n", + "M6aSeq9xVKXArNlMFgqgaS0hRIWot8aQMS6hYoFZWm9ICFFp6isY+oxLGHBzmqHoZEtA6w0JISpO\n", + "oVNJZjbTzO40s7vM7ISUa74Yz99qZntkSLQWaxwlbAkHAW+Mf08Hrqc601pCCDGFwgSDmU0HzgBm\n", + "AjsDh5vZq9uumQW8wt13BI4FzuyRaOn7JZjZLDObZ2bz49+0TWrSbAn7EcIp5hHuZR4wO8u0Vsz7\n", + "pxnyHgvMbKLsMlQF1cVqVBfDU+RU0j7AYne/F8DMLgYOBe5IXHMI8A0Ad7/RzDY0s83d/eEpqQUt\n", + "odQ1jvr0KEq1JQwyrSVvpo5MAPNLLkNVmEB10WIC1cVQFDmVtBXwQOJ4afyu1zUvS0mvCruq9eNR\n", + "lLctQd5MQoiRUKRgyLrWRnu4dtrvqmBL6MejKG8XWXkzCSFGQmFrJZnZfsBcd58Zjz8GrHT30xLX\n", + "nAXMd/eL4/GdwBvbp5LMrPoLOgkhRAWp2rLbC4EdzWw74CHgMODwtmuuAI4HLo6C5IlO9oVc9mIQ\n", + "QgiRicIEg7s/b2bHA1cD04Fz3f0OMzsunj87Bp7NMrPFwO+AY4oqjxBCiGzUYtltIYQQo6NSayUV\n", + "EhBXU3rVhZm9O9bBL8zsWjPbrYxyjoIs7SJet7eZPW9mbx9l+UZFxvdjwsxuNrNfmtn8ERdxZGR4\n", + "PzaJsT63xLp4TwnFHAlm9lUze9jMFnW5pr9+090r8SFMNy0GtgNmALcAr267ZhZwVfx/X+CGsstd\n", + "Yl28Dtgg/j9znOsicd2PgO8Af1Z2uUtqExsCtwEvi8eblF3uEutiLvDZVj0Ay4E1yi57QfXxemAP\n", + "YFHK+b77zSppDKsC4tz9OaAVEJdkUkAcsKGZbT7aYo6EnnXh7te7+2/i4Y2kx3/UnSztAkI8x6XA\n", + "I6Ms3AjJUg/vAr7t7ksB3P3REZdxVGSpi2XA+vH/9YHl7v78CMs4Mtz9GibtQTaFvvvNKgmGvAPi\n", + "6kyWukjyPka8QOAI6VkXZrYVoWNoLanSRMNZljaxI7Cxmf3YzBaa2ZEjK91oyVIX5wC7mNlDhHXV\n", + "5oyobFWk736zSqur5h0QV2cy35OZvQl4L513qGsCWeriX4C/d3e3sL56E92bs9TDDGBP4EBgHeB6\n", + "M7vB3e8qtGSjJ0tdfBy4xd0nzGwH4Ptmtru7P1Vw2apKX/1mlQTDg8DWieOtCZKt2zUvi981jSx1\n", + "QTQ4nwPMdPduqmSdyVIXexFiYSDMJx9sZs95OcumFEWWengAeNTdnwaeNrOfALsDTRMMWeriD4FT\n", + "Adx9iZndA7yKEF81bvTdb1ZpKmlVQJyZrUkIiGt/sa8AjoJVkdUdA+IaQM+6MLNtgMuAI9y9femN\n", + "JtGzLtz95e6+vbtvT7Az/FXDhAJkez/+EzjAzKab2ToEQ+PtIy7nKMhSF3cCbwGI8+mvAu4eaSmr\n", + "Q9/9ZmU0BldA3Cqy1AXwKWAj4Mw4Un7O3fcpq8xFkbEuGk/G9+NOC/ub/wJYCZzj7o0TDBnbxGeA\n", + "r5nZrYQB8Ee9Qvu15ImZXUTY82UTM3sAOIkwrThwv6kANyGEEJOo0lSSEEKICiDBIIQQYhISDEII\n", + "ISYhwSCEEGISEgxCCCEmIcEghBBiEhIMQpSAmc01s78tuxxCdEKCQYhyUACRqCwSDEKwapOfW83s\n", + "RWa2btzcZecO150YN4i5xswubI36zew1ZnZDTOMyM9swfv9+M/tp3DDmUjNbe9T3JkS/SDAIAbj7\n", + "TYQ1ZT4NnAac376chJntDbwd2A04GHgtq0f+5wF/5+67A4sIyxJA2B9hH3d/DXAHYYl0ISpNZdZK\n", + "EqICnEJYoO1pwsY/7ewP/Ie7Pws8a2ZXApjZ+oTd9K6J130DuCT+v6uZfRrYAFgPmFdg+YXIBQkG\n", + "IVazCbAuYWG2tYEVbeedyevap+37kPz+68Ah7r7IzI4GJnIpqRAFoqkkIVZzNvBJ4ELCdFI71wJ/\n", + "HO0Q6wFvA3D3J4HHzeyAeN2RwPz4/3rAr81sBnAEq6eemriZkGgI0hiEAMzsKOD37n6xmU0DrjOz\n", + "CXef37rG3Rea2RWEZa0fJtgSWvtuHw2cFfdBWMLqpY1PJOzJ/Uj8u14rOeSZJCqKlt0Wog/MbF13\n", + "/10UAAuA97v7LWWXS4g8kcYgRH98ObqxrgV8XUJBNBFpDEIIISYh47MQQohJSDAIIYSYhASDEEKI\n", + "SUgwCCGEmIQEgxBCiElIMAghhJjE/wdZK7t2b8ZM0wAAAABJRU5ErkJggg==\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4lFX2xz8nBVIIIfReQw8KAgKKVGnBsjZU1rqKuvbu\n", + "urs6GXv/2RvYFbuuinQpolQRRaoQQHoJLaQQUu7vj3MnM5nMJJNkUpT5Ps/7zLzt3vu2c+8953vO\n", + "EWMMIYQQQgghHD8Iq+4GhBBCCCGEULUICf4QQgghhOMMIcEfQgghhHCcIST4QwghhBCOM4QEfwgh\n", + "hBDCcYaQ4A8hhBBCOM4QEvwVgIgUiEj7Siz/NBFZV1nlVzZEZIuIDK/udlQHRCRaRL4RkUMi8rHd\n", + "9pCI7BORnUGu614RmRjMMoMNEblCRBZUU91t7bcaZtenisilVVBvioi8V9n1lAfHjeC3QihLRI7Y\n", + "JV1EmlZje1JEJNe2I11E1ovIC55tMsYsMMZ0CbCsmviCGbuUGfZ5DQtye6oS5wONgfrGmAtFpDVw\n", + "O9DFGNO8vIWKyBAR2ea5zRjzqDFmQsWae/zAGJNsjCn1ewnCO1hjnaSOG8GPPoQzjDFxdqlrjNld\n", + "ze350BhTF0gAzgGaAsurs0OqQTCAVHcjKoA2wO/GmAK73hrYb4zZX41t+ktARMKrqKo/+zvoF8eT\n", + "4PcJEXlHRG63/1vYKeH1dr2DiOz3OPYuEdkpIttF5B8VrdouGGPyjTFrgAuBfcAdtr4iozsRucfW\n", + "nS4i60RkmIiMBu4FLrQzmRX22CtFZI09NlVErvEoZ4gt53YR2WOv6QqP/dEi8rQd8RwSkQUiEmX3\n", + "9ReRhSJyUER+EZHBpVznySKyWkQOiMibIlLbo54zbBkHReRHEelht7+HCspv7DXdJSJvl+E5+SzX\n", + "7msuIp+LyF4R2SQiN3nsSxGRT+w7kS4iq0Skt98HKNJFRGaJyH77PC6w253AfR7P5BpgJtDcrr9Z\n", + "2r0Ukfoi8paI7LD37gsRiQGmeZSTLiLNPGd8IjJNRG7wauevIvK3ktrs5/oq8g41EJGvReSwiCwB\n", + "OpRQj0sVM8Fe704RucPruXwmIu+JyGHgchGJF5E3xP09PihuVU6YiDwlqlZLBcZ61TdPRK7yWJ/g\n", + "cZ2rRaSXj3fwzgCeWTsRmW/LmQk09HfN1Q5jzHGxAJuB4T62Xwl8bf+PBzYCH9n1fwBf2v+jgd1A\n", + "NyAGmAwUAO3L2Z4U4D0f253AYvt/CLDN/u8MbAWa2vXWrroBB/CuVznJQDv7fxCQCfTyKDfXtiEc\n", + "GGP3x9v9LwFzgGbo4KA/UAtoAaQBo+1xp9v1hn6ucQuw0p6XAPwAPGj39QL2AH3RDvAy+4wiPZ7X\n", + "sHI8J7/l2mtZDvwXiADaAanASI9nkm2ftQCPAIv8XFsssA243JbbE+20u/p6JsBg17O06/7uZQO7\n", + "/i3wIRBv23qar3K86wIuBX7w2NcNOGivv8Q2+7jGirxDH9klGugObAe+91NPW/Rb+sAenwTsxX6v\n", + "to5jwFl2PQr4EnjFHt8IWAJcY/dfB6zF/d7NBfKBMLt/LvAP+/8C27bedr0D0NrPO1jaM1sEPGXv\n", + "9WlAOl7fZU1Zqr0BVXahKoSO2I/gIPCFx4M+gH7orwDX4Ba27wC32v9vAo94lNeRyhH816EqAtfH\n", + "5WpLIirQhmOFY2lleR3zJXCzR7lZrg/BbtsDnIwKhCygh48y7vF+kYHpwGV+6tzs+hjt+hhgo/3/\n", + "CvCA1/HrcAs4748u0Ofkr9xBQD/gD6999wJvetzHmR77ugFZfq7tQrwEGfAacL+vZ+L5LEu7l2iH\n", + "m48Vol7HFCnHuy4gDsgAWtn1h4FJgbQ5gHc20HcoHBXUnTz2PQws8FNuW/Rb8jz+cY92pwDzPPY1\n", + "AY4CUR7bLgbm2P9zvN67EbZ8X4J/BnBTCe+v5ztY0jNrjXaE0R77PqCU77K6luNJ1WOAs40xCXY5\n", + "F8AYk4qOVHqivfQUYKeIdEKFxXx7fjN0tOTCVn8VibJxXEbk38rYzhZAMT2wMWYjcCv6EewRkQ9F\n", + "pFkJbRgjIovtlP4gOnpr4HHIfuPWP4N+xHXQ6WkUOhL2RhvgAjvNPWjLPRW1TfiD9z1zGTbbAHd4\n", + "ldXSY38RlOE5+Su3md3X3GvfvagR1oU9XvckyqVC8HEv+nmVNR4VSoGgpHvZCjhgjDkcYFmFMMYc\n", + "QWcLF9tNF6ECqMxtrsA71AidpQT0vXjA37sCOip3oQ06qt7lcR2v2nqhDN8q+m74etd9oaRn1hw4\n", + "aIzJ9jj+jwDLrXJEVHcDagjmo1O+SGPMThGZD1yBThN/scfsQnt1F1rjB8aYBejIqyQY7w1WwJyJ\n", + "6oN9lfsh8KGIxKEjtcfR0UaRskT16J8DlwBfGWPyReRLAjNUpaGjqURUTeOJregI5ppiZ/mH9z3b\n", + "4VHWw8aYR/ycV+z+ENhz8luuiPQHNhtjOpWhTn/YCsw3xowsZ1l+76Xt0OuLSLwP4e+rXO9tHwIO\n", + "UfpklDFmboBt9mxDRd6hfUAe+rzX221+vxcPeB+/w2Of5zVuA3JQFYtnx+NCwN+qLSvRzz7v+1rS\n", + "M2sDJIhIjDEmy25ug87cahyOpxF/SZgP3Ah8b9fn2fUFxs7ZgE+AK0Skq6iRzVHBOgs/IBGJEJGu\n", + "6AfbGHim2MEinUSNubXRl/4o7pdqN9BWRFxl1rJLGlAgImOAUj92APshvQk8I2o4DBeRASJSC3gf\n", + "OFNERtrtUdbI16KEa7xB1BhbH/gP8LHdNxG4TkROFkWsiIwVkTp2/x6KGwQDeU4llbsUOCIid4sa\n", + "sMNFJElE+ni0N1BMATqJyCUiEmmXviLiot+WVpbfe2mM2YUacV8WkXq27EEe96WBiNT1KMu7rqmo\n", + "0HGievZA2+yJirxD+cAXQIq9z91Qu0JpneF/7fHd0Q79Y18H2fszE31H40SNuR087tEnwM32vUsA\n", + "/lVCnZOAO0XkJPu+JIpSb6H4O1jSM/sD+Alw2vs6EDijlOutNoQEv+J7dIrqEig/okYj1zrGmOnA\n", + "s6j+8HfgOyrG0zVY1gdwCPgKHSn1NkVppq46agOP2mN2oSqZe+2+T+3vfhH5yU73b0Y/gAPotP8r\n", + "H/X7w53Ab8AyVO30KKof3Q6cDfwbNb5tRRlI/t4jg6oZZqLT6Q3AQwDGmOXABOBF28YN6OzFhUdR\n", + "QXBQLJuHwJ6T33Jtp3YGqi7ahN7L1wGXEDU+7ovP+2SMyUAF4UXoyHSXbXOtQMoK4F5eiuqM16EC\n", + "6GZ73jp0gLBJlO3TzLsuY8wxVPAOR0kIgbbZ8/oq+g7diD6r3ehA4s0SjnVhPmq0nw08aYyZ7VGP\n", + "d12X2Xavse37FLfKcSKqu/8VFcaf+2urMeYz1P4wGTXGfoHOIMHrHQzgmY1H7UgHgPtR21ONhLgH\n", + "SuUsQKlpY4G9xpgefo55HjXsZQFXGGNWVKjSEEII4S8DEWmLdsQRflQ3IQQZwRjxv4XS33xCRJKB\n", + "RGNMR5SJ8UoQ6gwhhBBCCKGcqLDgt4bMgyUcchZ2ymOMWQLUE5FAmQ8hhBDC8YGKqR5CKBOqQsff\n", + "gqLUqu0ohSqEEEIIAWPMFmNMeEjNU3WoKuOuN+sg1LuHEEIIIVQTqoLHvwN1SHGhJUX5uQCISKgz\n", + "CCGEEEIoB4wxZQsmFwz3X9Tl+jc/+5KBqfZ/f2wcGh/Hmep2Y67MBUip7jZUx7V1h+SrYUMBGGOX\n", + "q2FDd0iu7naXtIyG6QbM150wvTphdtbRto+BaVXVhgtgngHzzomYvhMw+aJtuMAjfEFlP7+/wnIc\n", + "XJ8p6zkVVvWIyIfAQqCziGwTkX+IyLUicq1t0VSUc7wR9Ta9vqJ1hvDnQSu4+YUIEntfC++cCAUC\n", + "EyGxNdxU+tnVhzgNW8FpWyE6D5Kuh4cGQe1axFZVG46okx6XrITIfHijl27P0EByIYRQbgSD1XOx\n", + "Maa5MaaWMaaVMeZNY8xrxpjXPI650RiTaIw50Rjzc0XrDKFmIEkkeYzI9ES4YozI9CSl7hZBHERF\n", + "5cErU+DVPnDyBPihNdRRx6saC5fQrXcURmyCZRNhZROYejN9xSmXiNNn/J6gYhs8PwE2hhl4aSr8\n", + "dxj8PYbNW+GFyq47hL82Qp67VYd51d2AYCJJJHkAPDcNRk2ENtNg1AB4zlv4uwRovx2w8A24YyGM\n", + "Pw/mXEZncUq76ml96XAJXdAwlO0PQt1PSY1fzn9Rj9Yl4pTTKrMNq4yZughuSYbpj+xmfvgWtn5+\n", + "BWtW6Sw6mJgX5PJqGuZVdwO84Ro0jROZ52/QVJmosOdusCAixpTVQBFCtWGMyPRpMGp+G0itD2M2\n", + "QLMMSIbpU40Z4zrO1UFM9AiEdXkkmz67hB+z2jAWDZnwqHGY9Oq4jpKQJJLcGm6qA9EZkL0VXlhl\n", + "zFQ72r8IdelfBtxjHCbQCI/lhjglAY0zn2wcoZnznxW+vokJsHER3FKeTr08sjMk+EMoF8aJzPsE\n", + "Bs9vAy/3hVkdoO0hOLydrZv6Mh5YYhwmD0oUoC3QOCkj0YxVbxuHqZHRDH1BnBIN3Ibm0n0beNg4\n", + "TEnOjMGo8yrgauBU4wjx3v+McA2ajtSC9NrQ4ohu9x40BYqQ4A+hyuB6eV3reWGwuCVcfCKbtvcm\n", + "HY0OORONMjndOMwef2WJU/oA/4cG9brNOMy8ym19cCFOaQo8APwNeBB41ThMbiXVFYZmenrFOMzb\n", + "lVFHCJWLcSLzxndh8E1j4I5FcOtiux3mf2LMkLKWFxL8IVQZfE1Xr4bUxXCzHc03R2M4JaNRIlPR\n", + "cMHTgKXeI3txigDnA08AK4C7qkJ9EkyIU3oAT6Px3+8EvjWO4H9gtqP8BuhqHOZQsMuvaiSJJLeC\n", + "m+Mg6ggc3QbPV4Ido0ZAnNIyYQvLG9eh8WvfwGCPVC2hEX8Ifwr4U+F4HydOiQROQSO0JqPZimai\n", + "HcEM4zD7PI6NQtUnd6ABAB8yjrJnoqou2A5sNNoB7ALuMA7zS8lnlaue14Ac4zA3B7vsqkSw9d01\n", + "FeKUcOAG4L7orcy48F36v5XnjvXvOWgqc9khwR/CnwHilFa4ZwPD0Jjz09CO4CfjMAVWffIQa+PO\n", + "ZWavXRxsnAYZ2bBtEbQaAHFRcOQobHvemFU1TkCIUyLQvAAONBXif43D7Api+Q3QWPQjjMN4Z0rz\n", + "i+oeXdv70hboDHRusobbusTQ8vcGsP4FiDumx5V39FsTIU7piZIYsoDrjMOsC3TQFFD5IcEfwp8N\n", + "4pRawEDcs4HGaALraUxsl8/uIU+S/6ZHyI8JuXBppKbZBZiwERbdUhOFP4A4JR5N3HE1msjnaeMo\n", + "TM1X0bKvRVMjDgpEpVSVo2vbMXX2sbRDE8usB9Z3n8PoZ7fTsXMatEx3B/Uqr767JkGcEovmyL4M\n", + "zQL2dkVVf7467tXwbUjwh/CnhjilDdoJjOFY2Fj2nBzOhmRY9zfYa/P8RF0P7YaD2MRMsSm/MHbN\n", + "Y6jcqKlLAjACjVs1B1gVhDLD0BzEK9FMYyUe32g9I8dk09wIOOdCO2sdKLduWTvtDvgW8JFY4e61\n", + "bDAOd0Jyb5KAC5U94q/smY84JRl4CViAqvv2lXJKqfDXcU/SfCdlkp2hZOsh1CgYh/kDeBV4VSLP\n", + "nU/r6wfRcSokTvcQ/EfghA/AWJlWe38L4DzcKfpq4nIETQHYEhV0J6PqrS0VLPdddDYxFQ3l4PfY\n", + "ZlsYMDRb+8u6Oe57XpIXtbVZNMW3cG+Jhlx3CfXFaO6N9cCeQEa31lGugzdJoDK9k/0I0A5JIlRU\n", + "+ItTmgHPAScBE4yjMH1khdEKbp4IiTnh+upH5Wn4k0nlKCsk+EOoucjLzmbT6bDp9KLbD7WFjx/0\n", + "2DDmZ2OmjfNXjEhSMrS6uabYBSwl80LgMTQn7D3GYTZWoLwEoIVxmDtKOm5Mioy7QgV2EWRAtjgl\n", + "BuhIceHeCThG0VH7fPu7yTjMsfK2G9Q7OUmEZN9+Hq5ZTSQqqyI8/vva5u9/kW2dB3BP/6MkvhoO\n", + "HffD8M0qQJM1flT59Oz6TK9B6byvA5d7zmyCgTiI+r4NXHsG3PMjXFEBykBI1RNCtaE0gaz7BzwH\n", + "ExPdZ12dC5e5dfxxF2czaupektKvMw4z3Xcd3mXUDLuAdQC7FWUwvYMymEp1ALNCxlO4NUUTz4/D\n", + "5q7Fh9Br/j9OG7Cd266tS5P1DWF9A/i0Kcf2NueoiSQaTT6/x/6mAfvRxOF53mX5+V9uYVzC/gJb\n", + "f6799fc/4P3N1zFsdBZNIgrglG1w+a96X8vNo3dKEhqAEuAa4zCry1pGAHUkNFnDyoiWtHxhKpyz\n", + "zmMfZQ/LHBL8xwGqm8nhC4EKZD2u9U1QJ1pZPVsXQ+v+heuy5QUcayOAp9DYOncYh1nrPn/MdJg2\n", + "iugDELMPwvIgPBeir1nI5cvuoOyCKJhCzfU/ClWbxKOCNrOU88MoLtQigdoohTQfCMc9Wq5l64iS\n", + "PArq7MPEHaIgIp3ctMZszWrHZuCQLaeiArZcwtjf/8rwTg6WXcF23Pehqrb7gInBbq+d9VwAPFt7\n", + "D8vHvUW3d4/S3rX/akh9AzqEdPwhFEFl6jMrhlY3w8REaqfDdT3hSHM40jyRvIMviVNeRpP17CSF\n", + "jbD6fOMwmSWV1rW20KgOj4fH8uvAl2XXnnzu3pBmPtbZBND9Y+j/LBRE6BK++QSUZVNRoZWL0vSC\n", + "ISDboY5fzVEa6DQ/5xSggr0tbpVMF2A8UBftAH5H1TGu3/XA7wUP1ryYSFWNQO0KJQ2YxCkjgFdQ\n", + "Vd0JxmF2B7udlujwEvqczzv6slmU9Ioke6vFULpw2coOjfj/2nCNbrbVLUqXq26etMi4efDJYCQf\n", + "EjZD3E6I2wGNH0hl0Lqv0FzNzT1+jwE7cXUI7t+djebQeuhv3Pz+YdpG2vHWRfXI/64nk9IWjGxH\n", + "/oyRxVuQPN2YqTWOJ+7hAPYUqnZxosK+RFqkXSKBu4HOxmGOVHnj/0QojUfvOWAy6HczATbObsP9\n", + "W65kLHAqcL1xmGnBbpt19roJ+C8ayuTJkmwp5ZGdoRH/XxxxEJUbBoOv1Hg6I1NhRCqE/0Hd6m3Z\n", + "kaMAmHA4kKgLAO9tMN+tLWKktMKwHu5OwNUhdAGGZ/VgyI99iI+NhZN2weJJ8NEhwgds4Ly0u2cf\n", + "5avhO1kzu7m727s6FbbWmJj2fmiRh1Dmz1xU1z4f+AWYjA9apEdZJ6EC454qaXwNQllUmna73xlv\n", + "K7j56dokXjcCWh+GexdA/14kvj2St1HWTlJps9DyQJzSC5gIpAOnGIf5Pdh1QGjE/5eHa8RvgPUN\n", + "YVZ7mNkBprUjL78WvwKz7PKjcZickksLHvwYblNh8c1lNbq6IoXmCxyKggZWHF4A8z9L4Qlywl5l\n", + "X1wM03pvZkftNNj6QrAMu4EyhrxokZ0oKuRbUZQW6blkA/eiXsDPoQ5gmf7qtR7Pq4CBxmHWcZwg\n", + "2M5pA5Lk150jOGHEJrjmJ7hrJGRHQp0ZLJ/zh+kT3NYXOns5gMvRTvudQJ29QiP+EIrBU5/ZJQ26\n", + "pMGvS0lNjOb29fdwEA2J/AjQTZzyI9oJzARWV0aAMReMWTVVJAlI9jTclksgu5K9hBu30AfIhGzj\n", + "MFPFKR1oefg6Jsy5D9XJLgvGNfjsvCKvSJQBzdoxevc+SqdFfk9gtMh/2dg8jwLrZFz8x8gFZ2Mm\n", + "eRrGO4gkYZQG+TDwgjhlZGU+w5oEF8c9NwyyIiE+p3wUTXFKPeDphE50OXcSbOwDQ/8OE+bD08vg\n", + "TEOFHbF81DkKtRcsBHoYh9kb7DqK1Rka8f/1EUhcEMsFH4Z6l45AnXpmY2cElWG8ChZKixTq2iZO\n", + "qY+OqsajHPoXKsJDL2QMtZ8Npz4BDdZD7F7IkAwSsmfhPXpP6d6/ov4E4pQB7K0zjbxO8fxwDyCw\n", + "ZShkNcRlt7BB8VYADuMwn5f3+v4sEKc06DmVBV1a0XVGIvz3e7h9ke4rC0VTnDIWeDVhGSv7rqX/\n", + "lmTqd98Hz0+DV9JhDezaAFcHixQhTmmM6vAHAP80DjOjXOWEYvX89VFV1ExxSgfcncAwVBXhmg0s\n", + "CFa8mWChLEGvxCldUONpZ+Au4KvyjIwLDdT1N0KD3yGtszqXmYvnG/PJkKLH2tlB5HOJ5EZjzYXl\n", + "8icQuWAeSecNZtTtQAHUyoCDibDr8HZ6bbkWnUn0Rr16u1WGLro6YdVmXYEz7HJiwhaOPrGSxskb\n", + "oLmHWTsQEoMdEDyLxoy6vfE6XqzdjBaPz4KLVrktQyNh+UxTcTWPbf8V6ODjHcBZkWcUEvx/cVRX\n", + "CFsbUbEP7o6gF7AU7QRmAb9UVjaoyvS6FaeMBJ4B9qIJYH4tW9vsiL8YijOGCo8dczPU2QXfvA5H\n", + "E3weG3C9EdnQ/zk45Sn1bs75MZXe27ejz+oX1C/gF+DqqrTfVAbEKbWBwbiFfTiak2AKMK97CsMC\n", + "mfX5KPdvwMtoOI1fgYfa/ELeb1Np8Y+z4ez1cImNfRqMwHHilE5oSJK6aEiHFRUpD0KC/y+PEbVk\n", + "5pMNGLGmEfxtHcTYHE9VTc0Up8ShOchHoDaCBsB32I7AOMy2oNRTBV63HuGTU4Cv0fDJfrOFld4+\n", + "3wbqwtlBxFE4/V/Q5Uv48j3448Vis4My1xu7F0YMTCdpoyHCONA0kCcDZwPXAjmoZ+93aIC4FX+G\n", + "FJfWUJ2MCvrhqNF6Cirwi9mgyjjra4hy4Pug6r9/APWBa0an8NBHtRnV+jbY8iwkKP+sQt+ZZW7d\n", + "heaaeAh40ZWatKIICf6/CGwyki5AN6C7XbqF5dGh6wHCuu+F56ZD0ww9vrpD2IpTWgOno53AcJR+\n", + "6JoNzCsvp7xwZFt3O7SfBdsHqDqFsUHn4Fuj3n0oq+JJ4DlSug8rbbbhw7PYp4G62Oyg41Q46ypY\n", + "H5lKn21dy5qq0Ve9pKzeiqqw2qNC5mvUIczlbDQMfT5NgXloR/AdsL4mGIGtCqRngx+4LXE9Z0VD\n", + "bE4eaant+WDvCB4zDpMWpHrOR4X+xyht9kaU4PC8cZi8JJHk+D682bgDTb78WM+pUKIUpwxAKZpb\n", + "gBtsIMKgoVoEv4iMRvVj4cAkY8zjXvsbAu+jL1sE8JQxxXOFHo+C35+AR+l9qcBqNNnGamD1yAd5\n", + "dkY+xZyRqtsZyxM2jkxPtBMYgY48V+Cmjf4U6EincJTcaA0MeghaLYRaR2Bf2AHapD2DsiCWGYfJ\n", + "CGL7OwJPckz6MWUQrJzb1K3lLf9sw+fsIO7iLUz4bD9183KBvxuH2RSka3A5gO1DHbreBf5lHOYr\n", + "u7857k5gOPrtzsF2BMGasQXY1hjbhjOAM+JWU3D2t9R5L4t6rmOCpc60xtSXgB6oUfUm/AjjyDvl\n", + "587zkW4/cbi8iVJsLoZHgHPQmEyfVkoqzqoW/CISjjIWTkc9KZcBFxvjGStFUoDaxph7bSewHmhi\n", + "TNGP/68s+AMQ8IXC3S4bfY0AA2Wv1CTYD3sQbvtAS9QpaRYwsyRh51OHHrcTOo1cwZmr56DpHE9E\n", + "36lFaEewCNhc0Q9MuvdayuD8vhytB9P/D3b1tnvK7/HrZ5Q+HbgZTdZyq3GYyRVpd2FdqsK6CvX8\n", + "/QV93zp7O33ZUXYH3J3AUHQU7JoNzA3WSNujztbAWFTYn4ZSbL8Bvh2dwvMuT/PmR5SiCxVWswhw\n", + "ETpA/RCog+Z8uAX43PtdsaGV1wDNyxthU5xyDjqrmIpGXy01+F55UR2CfwDgMMaMtuv/AjDGPOZx\n", + "zLXACcaYG0SkPTDdGNMpGI2vabACvjNFhXt3fAv4Naj3ZZmm+MFM2VYdsB/V6bg7gizcs4E5nh+I\n", + "a5Rch78lduF5Yskhm/VZ28h5Yqc54LTl1UZjn5+C0uJOQYOTuTqBhcBy4zBHy9ROGTcP+XAwJ70B\n", + "Pd+GNxeolzHjyqyTD6g+9dicjA6ebjSO4MTUEafURR3AbkfvxRklMUjsjK0H7o5gIBrx0zUj+L6s\n", + "MywbgqAvcCYq7JujcYimoJ1/YcJ4lzPesMvhqp/h77/Z7eWPnNkMVXN1BD5A1Tr/A+71l8tZnHIL\n", + "0Ms4zBXlqK8lKvC7oJE6F5S1jDLXWQ2C/3xglDFmgl2/BOhnjLnJ45gw9KXpBMQB44wpHt/izyT4\n", + "SxHwmygq3FdTDgF/PMCOxJJwdwID0fvloo0ubpaS8O8hZN09mZwY13klTf1tma0p2hF0BX7DY1Zg\n", + "HGZ7iW0rMttwRWuByozxY703n0E7xvHGYZYEsexT0JnWATQN4HuBMLGsT0Bf3B2BizHkmhEs8cUY\n", + "sh3OSFTQJwO7UUE/xZ7j07js8jSf0w6uOwPWvAQRBeWKnCnApajK62NU8LdAhfGiUs5dihr5Z5ah\n", + "vnDgOpQk8CLwWFUxqapD8J8HjC5F8P8XaGiMuVVEOqAf9YnGFDX4iYhBp6UuzDPGzCt344KAkICv\n", + "Wtj7fQrujqDjgInkLNxBIwO8cRJ0ToOuaXBZVuCCwArUPrg7glPQmYarI1iIUlILn10wQ0qUFeKU\n", + "c9FR6nPA48Fi4IhT/o2qOCLQUM13GEfZvjGruhuI20bQBb1/36Eqt/aoGudk4AdU0H8bqEHTpc58\n", + "HRKHXgFXroAFv5ZNnSlOaYEmQ3GpFS9BO4CnS/s+rY1nAdAyYFuUU3qgxttctGNZW8opFYKIDEFZ\n", + "dS44qlrw9wdSPFQ99wIFngZeEZkKPGyM+dGufwfcY4z5yausahvxByjgPdU0GyuaeSiE0iFOaXjG\n", + "U8z/JoNu2RFwYzKsbQRrG0Im5OVGswhY67VsK02/b0eDiXjOCtbXSWRB0lGy4zM4lpNG1Lan2Bd1\n", + "KBDGTmXAqgzeQ6calwbD4GrVYr+hlMI6wOOo4f1uUrp3LKu/hJ0NjELj0Q+2ZebbMj9B1TllZgy5\n", + "1JnpnWj60xl0bvcyF67NNt8EcH2C0jIfA74E+qP5Cf4ZqOFcnHI/0MA4zC0BHOsZj/8/wBuV5c9S\n", + "YjuqYcQfgfbyw9EQuUspbtx9BjhsjHGKSBNgOarzP1DRxhc9v3RHHy8B72lobY1/I2tIwFcjfCXN\n", + "MECvbuSdOwm8AAAgAElEQVT9Oo7NwGY0kFk8+mzj0HdyLfo8XR1Cqr8RnEhSMtL/BczE9oUqnXoX\n", + "FTBy6h66HfkO96xgVVXy36364G6UEfJP4zBfBKHM0agqIsluuoW1cf/mm7MLyHqvnvtI3wwmcUoD\n", + "NGz0GehzScWtwlmBsveCxhgSp8wGPjQO80Ypx7VGR91N0Oc9BM1s9mHAwc6041gHXFaamk2cMhx1\n", + "xPoZNcrvCqSOykB10TnH4KZzvmGMedQadDHGvGaZPG+hwjUMeNSY4syFigj+YtPyiKPQ+KKtDJj7\n", + "ET3ScylZwLuMrCEBXwPhj8n0YyS3rftPYZC5Eagg+xGdpm9BVRld7dINNShuovgMYT0po7+AaaM4\n", + "4zpo8iv8MRi2DIZ9jy/itvlv4VYRNUcHNy4V0eLKZGu4IE7phxom56AexhUKwSBO+RI1eD8EIBGj\n", + "5pA/YygtlqgBe6crKkHydFKmJaP3z+Uxe4JtxxRgakkCzw9j6CBuR7JSGUPilFPRa+/k6xu1dVwD\n", + "PAzMQBlk01EmzQHv40upqzfWHuCvs7COX0/Za7nBOMyUstRRGThuHbgKDXFtvoezrob4rXCwPRzZ\n", + "u5v2+1+jqA4+JOD/ZAgwyFw9igaZi8UjyBxKUeyEuzNwLYlMGgrb50QRmQUtlkDb+dBmPrRcUEBk\n", + "/s9o7Jv5wCqmNLuULR0uI7J2faIOx9F7/Q6SjszGPStYXxnTfWssfQHoB1xcEVd/cUpbdOZ9knGY\n", + "P0TOXQlf9KDTFDj7Spj1JPxyBTQctYMbZ+ai0yDXqH5eWRlSHvX6Ywy5DMULfDGGxCnTgS+Nw7zm\n", + "tb0dMAn1HD8ANAOuNQ7zfTnb9wyQYRzmfh/7BPg7KvQ/BO4Lpv9IRXAcC37r6BN1UHneBzpCfi0q\n", + "i3oXQs2HOKU9RYPM7cDdCXzvGjWLUyJ45PQ5HJt1WrFCOvQ5xqXLV6PhlOMpoB0H6wobL6vFliHw\n", + "xyDIuWcbA6d8w9B98eisoB6wGPesYGkws2GJU8ajRt9HgWfL28lYXfaJpHR/Azp8Cl8pa6rRGrjw\n", + "HEgdCesWZ3P5T5cDn1WK45HaCE7GrRryyRiyM55P0ZF4ju1ArkcZNAvR+/4c8ER5mTRWrbYNGOad\n", + "x8C+S68CjdH4OkEJ6x0sHMeCP/BgWSEcf7AftWeQuZNQvrzSRh/o2pSCU58txuBpPvcBrtm0C5e6\n", + "aFedcdSLSCAiG47V0aTt6S1h34GtdN99DzorMKhqyKUe6gVsoKiDWWpFBKkd6U5GszRdXp6Q2dbe\n", + "tYH1DcM40Ko5SzvCQRufoPZhOC8pnxa79hCbH4Eaaf9jHGZHedscYJtcjKHhaGfgyRg6E1XDTAfe\n", + "QDvYcDTA3nUVzVQlThmGpjjs7bEtEjWE340awp+tiay941jwVx/1LoQ/H2yQucG4O4LG/FxvNd+f\n", + "WJ+M+hnkHT3ki8FTOLOM3g/x22BvktoEul6ayqC1q1Ev1DS0A3Cph3ajwv+Uej9zTseV9K2TT/jR\n", + "fA5u6MrUtNN4Ew1jUSYPUeuZez8aYO5q4zDflkZwsLRWV3iEsYAhJ6IJH38TQdYaCJsBInCkCWRu\n", + "X819cz615c9GBe8LwJOkdB9cWRFTva4xATXSDrftbYNSJv9AA6rdSRkyVZVS1xvAGuMwT9v1vqix\n", + "eA9lYAVVB45bwa/nBxYsK4TjB4HmLrDUyREeywGKBplLh9JnllYFkYR2KoNRQ2MmMD9uDQdGfce5\n", + "n+ynjeslvySGw1PGsOdwD1qiNijPWUGptFTb9kHAe+yp/QsTL+5O3lsd3HsnbKTLjIe4aFssKuwH\n", + "ojMdF7f+d7kqYS/rL2zEjw2BCKi9D/qvhX4/5BCT+29U/fESqtvuSa6MZMaAPJYvaIIJc9cTxIip\n", + "Pq6xM0oQ6YGO8ncCUajtwWUoLneMITv72WnLTwceBC5EO5bJNSGAXUk4rgX/nxVVlVilqlCZ8fPL\n", + "gvLmLrDC+0TcIaf7oXrnWXzWMpNVo/8JEz2Eq/+ZpUfCkEENNnJ/rSY0CzMw/y3oYLlAyTB9Wgrn\n", + "UtTBbAA6svV0MFvhj5ggTklgU/21xLZowufvQ61M6DRFl3prconK+xB3eIQiYQqkTbtnuWjXLby6\n", + "UdVWeqdyaTl7EldvaYiOuCejFM75TO51IqdF9SM6DXLqwtrzYU19OPBlGsStDuYzt7Oa21FP4y1A\n", + "Q9Ro3wql8PpjDH2HdtgBxRiycXVuQgO3vYh2JHcah9lf0WuoCoQEf5BR2UKsuhKrVBZ8qdxqMT6r\n", + "R8S3m+vWTt+9uRFvbrmCBUAkSrd0LRVdL7Yt4Q9OOzmXRsfCof92eOQ7bU85XP9demelja6La8/3\n", + "SZlkJqSTfWwXuTseNwVrSn1W40TmfQyDN9aHtocg0ppkfcWgsR1Ge4qGneiI8uQXNZ3G0R7LGVgv\n", + "D3ENFlZz/t30GjOYEXdBXhT8ehn8fiZsf2a+KfisSPlF6pIx0xnaZxQNfofPPvbYUziL6YIK3jOB\n", + "feyp25z318TRfhaMuAeO1IJpJ8HWr9ynhv9jG2bxP03+mm9Luy9+2+WU7ugoPx4V+C+jlM330ZAb\n", + "T3sdH4ZSTV2G4tNQ6naJjCF77hTU/yAeZQXNKW+7qwMhwR9EVEUSEJdzUr7AqsbQaT9E5/kXTtZI\n", + "6SngyiwQK3X97b6N2bK0FgOegQMdYP3ZAIS170vdC34i25B/LJJDJpJ0lCmTa389F912MLI+afGJ\n", + "5NUSTH4eDQ6toEnOBh/n+Fzv+yWOBzJJisyHJpmQZNNXVzR3gU0O4hlk7ihFg8z55I77ckSDwDsi\n", + "a5c4ucEPXD5yCedNPkJh7KLLa7Pvf3Ht09IPrO9KQiqcN15H71+/AVmXTYetL/gbwIiMm0fk24O5\n", + "uh+8Px2OtLClFmXEWQro3fzc4hoSTTiffax8/35j4dRfYeXfYf79kN1AT2h3ci6XL5uCjp7nAGsD\n", + "VF1FosbUO9ER/E40DMIauz8JtTkklkSn9GAMuQzF3oyhxUAe7pH+MyhFs1zROKsTIcEfRBTqc+P/\n", + "gHpblMERfgzq3PMzZ696nCCMUhN20K97HvUyIzUUQU6EBqTKNxQURJCNOzpYuD1HKEXgBXG97Oc8\n", + "eO7H5H8+gN6vQZvv4YsPAGgfN4S7O80nNhcej2DFqrP4FxorJ9N7MQ6TG4xOt6KCNhDYkXk33E5k\n", + "A1GnMFdHsMilnglWSG3Xdc1uD5vraRa22Fy4pz7Hfh8aHsneXsKunlB3OzSfm8+UhpNZN3oATCqs\n", + "N5rx2YlMXVPA4ftXM/pmmDYKybfRR13wzYiTZomX0KjVK4xaU4f5Dli2B2JvgCEpsO5vSgMFiDh3\n", + "Ef/98iVU6A4FYtC4OXPRjqAYs6lZf7n+cF8eNbWolVuL8JgtvHKkC7d5U1bFKR+hqq8iuT9Kghdj\n", + "aDiqgjuGhpjYBAyoSq/sYCIk+IOIQgZHn1ehx2T1C8ivBRE/7afdvrkEQcj2/ATn8xn0jSyAWvkQ\n", + "VgB76sBNzVm1YTjfoNP9jnbJorjX6VpgZ00xPhV2lnE74Poe8OQeKIikTYO+jDzlJzIjYVYcafva\n", + "sQLV1fpaDMfC4WiTCHJjYekNsMQVNiVwem515C6wsXA8g8x1Qj2JZwEzm6XUG9cGc2MsEpmJyf2D\n", + "sBdd4aUDhSts8Tsnwg+tISsSMmvBwlrkZUeTkxUVGVEQbcKJzA8jzIRRIMrUyY2BuQ/A4tsAGEVf\n", + "WvHTxs9p9v5Bxl5SFkacSFIyzer+hwtW9mV73Ui+3qTqpSIo+qwsBXWoXYYBBVjvXWBB9FaceY25\n", + "OD6fsNM3wf/NgPsyfKs9xSldUcZUYlnDV1tD7r3ADWie3TFoRIFoNCuZK7xEjchKFghCgj+IqArf\n", + "gECFkx1ZtsDtbdrF4380Gl9krcfvWmBToNEFg4UiI/Vr+sDMp+iw5WWeYxpj0Vl5SSNue52RPHnm\n", + "HMJfPpXITMiJh4ym9oiyOeRVd+4CG9dmODCCXDmLo1H12XhhBKkjNTl61j1ZsD0VwncGaj/yN5O5\n", + "D6WieNqIxCnhPH7WcnI+P5HILCiI0A4AaM0Q3mM+j8H0aXR/oTyMOHFKLAcjZ5ITdzKTf4kgvZXd\n", + "U0rHoc+5I9oBnAMMo4Dw2Dxk7O9w50Lou1OPLUHt+T6qPnq4tHZ6nDMIjdq5BlXxFNj/zVF66FCK\n", + "xhhyqYXmVGVWsrIiJPiDiKryDaiocBKn1KdoR+BamqHGLc/ZwTp0JJMVrPYXa4+l1cqI9b2iwzIb\n", + "fDIjM8Il9AMdcf8VHfJERk+nwfOjOPEdaPortP4BDraD1GjY9ABs/SCVvGWlvlu+BguXxkFOZxif\n", + "AcM2w0U5bmHp716Ooi+9+Yll8NtMY04o93U5RdgcM4kmuZcwvec+0qUBPdevoefh20oKnWBnR/eh\n", + "2cdovobM27bR9LU+sC0e2h+EoZthyS5WLz+bId4MHXFKJzQ2U6K/hCoexyYAT6DMpJuNw3xpt98K\n", + "9PROuOIRvdVlHxiGUnw9s5LVGMZPSPAHGX9m3wAbMrYzxTuFRNSpqJjaqKxBrUqp/6SwY3wz8hFW\n", + "xpWxU/srOuQVqg5H3wonvA8//wO2nQKd7oT2eRCzH/aFp9Hy8OOoamilP1WDa7AQCwM6Q3yneNjX\n", + "DaYnwuKWEHGAw4ea8QQww5dXcp2YcXyYNY0zyGAMpE0zplGFr88pp6OMmydQLvy/0JDIDwMzPK/F\n", + "OkdNBhJQZ6wrR6fwhCvl4onXwZcfwbKW8HAX9h1qTW00CqvLPvC9cZjD4pS30TSbPtVlVoCPQ423\n", + "XwD/9lQN2YQr/zEOM6uUa3MxhjxjDAXEGKoKhAR/CKXCcqPbUXyG0AVlqHiqi1zL9rLqO+1Htw04\n", + "3Tv2SUDn/4k7XV8oMvJOSIV+z8OJ70FqY6jdBlouhT0R+2mbNh31HaiL20g8yzjMTu8yfal9siJh\n", + "QBd+WnkeC9F99Vleb1X9bzsN6FEQHRVJJsMarePefSqnzoXfvqjAiL/INSrz50vUGe2fKAX03+h7\n", + "9Qga+uFBNFNVAaprf9U4TL7nTObi81TVs2aRzhBXpzAL6I3bUNwffS9XoLl0u3mHkxCntEEpoK3x\n", + "kXWrPAlXPM71ZAwNt20rwhiqymCQIcEfQrlhBXUzincIXdEEG94dwjqUmeE3dok45RXU1vBk5ba+\n", + "5sPnLCbqdjgpG/pNUfpl7u+7aX8gAlVhfIQKf1eQuV24O4L5xmEyA7ERWWE8asDrOBfupIl3u8rL\n", + "cvLn42LZM6+THTaAN0/Zzr6mhri0upyztCHts5qiLJrvUL58EWHtmslktqPx4vPo2v55xq3NKR72\n", + "2KqJ+tn7ci0anXMpOiOYh8ZiugelaD7lJ5yzA6gfSMKVUu+FhsI4FXdH0Al1unMZin+pTMZQSPCH\n", + "UCmwIY+9ZwddUYPzZnzEuDcOkylj699P67xbeXX0yur04q0pcM9iolpAQQe4PQYGQVgunDB8D6MW\n", + "phOdL2hYhd4ok+tZNJtVEm7aaG/gJ2BW41lk9FrEmLoFJavTkkSS+8Pzk9TbFYAL61EwYzBLD/fi\n", + "XVQdE1iWqlLothLWPZlTY96h/7aGfDUJOk6FXq8ZpCCbCDah1M7H0Tg7PqNpilN+AJ4zDvNpiW1x\n", + "h5iegMbzuRAN57AM+BbtDJZ5Cn+PhCuXGodZGsg1lwXW7jYYd0fQGO2QXOElgsoYCgn+EKoUlhrX\n", + "iRlNxrOh4/mERdclKj2KU1fXJl8OM3NMLNdNj+G5TerYI1dvxiy+8XgW/i74UmWRsnoaOnK8HY3z\n", + "8x2aUaozmoP3VeMwe8UpdSgaZK4JKlBmomohn/ltvYkEGxry7sYbEdToORLVzc+wy1x/CV8K1Vax\n", + "eyGrgQf/33r7uvaf/ByMvh1MGPx8FXyXOstkzxopThmIpirsgcYAmuhdl2je4TuNw5xS6r10yiRb\n", + "Vlt0pP8F6rnroo4m4h6Bz0X9YSZTQsKVYEI0B7DLSDwcpY96ZiXbXqHyQ4I/hLKiorGC/I7+wtfm\n", + "kP9Ddyb0gVUXw6I7dFe7k49x+bIlFFUZuXLlFostX1Ni/1Q1xCkdUMbLpajq5xgqOL5AR8IrPY5t\n", + "SVFv4kO4Qk6rAC+V6+4Ro2iUXfqg6pPpaEfwm0tIug3Vt0Dnr+Gnf6pgz/7nfGM+GSIybh4NHhrM\n", + "RWdBpA1hvTcJvjm2wBz9cpBHnb1RG8BANJ7+Sy6GjvVS3wCMNw6zuIR2j0Ypmk1Qhk6xROceI3DP\n", + "juAPtDOda68tKMlzSvuevBhDrhhD+3F3BD4ZQyWVGxL8IZQJwYgVVDi6azdHE5MURNg9ZxyAKfU5\n", + "5zLo+hm8vhzSukL4eYu474v/Ulx1FI87V64uXzdrxC+j76TgzUoLm1HTYdVsE9BOYCvqZTocvUf/\n", + "h6Y/LHAJhjpC1NbWRK4awrqsdrRGDaErcUcbXRqIMdOGiBiKzgZGof4iOht4cOQE8mcMA6D5Mmj9\n", + "MOzeA0fqHuPYsZ/pv6E1vY425/v/wNKbICwPxl4PbT46Qv3sXsZhUr3q6oYaesegCU+eNQ6TJk65\n", + "BTjFOMyFPtrXxF5/f9RYfBaQbRzmrlKuKxxNyvM4+t4NRdlF83CzhvyqYkoSwOX5nvwwhjbi7ggW\n", + "dE9hUEnlhgR/CAHBMns6d5nO5OS6nLCiGVz+C1z+q+4vi8FPIs+dz+mtBtH5a3h7HhxuY/ecdxA+\n", + "TyB2D9zSHnLi4INpsPs/vkMBOCUeb+ppeu3hxBDDobbKV/zkU6tW+PPy+csLyyQ5H1UD1UNnAScC\n", + "sXU2MPvcTxn5zjG3/t4lGFanMBfPIHOqDpmL21C8McAYOom4OoF1dYYx9Yww0j+M0rQDM4CHofUC\n", + "OPNaSD9s+KVROmuWxJNf25ZwVSrjP5lBp4zz0eQx033U0R5V1VwAvI2OyBdjU0TaYwS4EngMDeLm\n", + "NA6TZdUpv6EMH7+JaUSTpD/hlXClJe7ZwDA0PIpLLTQHpYya7mGS3DeC5x+OosOBaDgQDSlx7Fre\n", + "nY+PdGVHy+X884wC2h+Ihu774P75Wn6Zvien1AL64sEYitvNsdvWkTB8swYcrJVftNyQ4K+hqE51\n", + "hdXD90CTgfRCGQ9JwI4mG6l36xYa9dql9Ln6NjxVoIHMxCnt2Be7gv2nx/O/t+BogsfekcuhTTxM\n", + "TOSqAbBxJJz8eD7L6t5j5u592m+hnuXLuHlEvDuY+hsgYVNh0LfjOaWmFXyedoBp8VsZFd6QRv9Y\n", + "AbcsgZZWseNL4NiRsqdaKBf3bOC7QHw5xCm1+V/z29nZfgKHY1qTMyOcwQ9A79dh2nOw9lxocUo6\n", + "l/wUxerWu1ncYhNpB560rJ+BaCatl4BHfXU6VojfCVyOznKWGoe5xjptvYayzCYYh/nF67xnAWMc\n", + "5rYS2v4G6q37Juqt61oSPP63Q+0qbVDDrAB5FBBVqwBpkK202RP26DezCHbs7cLHnRZyzq0HaFc/\n", + "W8Nu97EE3IoEBhSnxPb/lIWDmnHCd+3hmuW6eJYbEvw1EG4d+OuJ+v5AZakrrFqgJ24h3wtlcfyO\n", + "cp5dy6/GYdIrEshMnPI34HVSY//HexcN9QwC5nK20v+tb2JkamfijoSRlTOJfgduRvW2s0u9nr+g\n", + "B28w4bIDRORw/dhNRMTmwpW/wOmWm1OawPHIF+CaDZyG2lxcs4GFpfHRC/X9jdZAegsNsQHQYPR2\n", + "Tl/4GXmx59IxrTm74w6wK+w5Bux/FA2R8BkaefMKfzmJxSmN0CxjN6Cj+dZont0XjcPk20GNt8B+\n", + "mR8bfMWKrv0hNorIdKHfml30PJyP0j7boT4ER1Bv3IP294CPddf/eKB7403ckd+UhgnZsKUevDoF\n", + "zvgdbsrU+1xZgQFLKzck+GsgCoXX2VfC1oGw4iq7p/zCy4Nz38traYTqcz2F/Gp/lLnyBDKzU9HH\n", + "gHOBi4zDLC7N2cqG0p2CfnQD0eBYVxuH+brE6/wLevBWBobFyuwxPRn+Qj8NdXD7IhVIZ5gy5x6o\n", + "hcb/144gnyR21Mtgc7N0fo/fxc70R03Baq90lH465wYDd3Lu+vo0PBrF9s5wNBOabjeE5eewP/xt\n", + "EjPuQ716T0MN2AcoPvKuD3RHVT8FKBsmC8gB4tB4OkWF9aq6JzAzuSnpH9YubEvklbvoOPsJxm0/\n", + "hjp8DS0Pr36MyPRvhVGrGsPov0PHA7CyCeQcJSM7gbfrreDw2Flc/H4W7V3nBCMwYGnfaUjwFyuz\n", + "+hkhhSOi+hvg0pGw7HpYeBeBqius8ac9RVU1vdCPYIXXstH1Qgd67WWJFWS9IT9GE1xfEWiIB9tR\n", + "bQLOMg7zmzilD9oR3GYc5kO/50lSMjR/EOLaQo5AeioccISEflG4BMPLYSR+3g2eHgDrYsgljUkZ\n", + "HbnLHy2zJIgkJRPT8wXant2eDrOgw0yI2JtPTv5cGhx7C5htHGav/87590PwfW/i34e270HrNpA4\n", + "DcJzIC/LUDcTwjiGhisX9J3aiXu0nYkaPRPR+Punorr9IcBl6AzgAeMwPxRpd8SoORRMG8qAZ2D5\n", + "NZolDIDk6aRMywSmGYd5o6z3A4oK4PPGwbjVMGMNqd+ewvN7RxAFDCWfwTGHyGu8lcN1N7MncxeP\n", + "btxrPi9Pfd51+/tOq0Xwi8ho1MkkHJhkTPEY2SIyBLXARwJpxsf0M9iCvyoSqQTWDo8RUd3tKvzX\n", + "nQ3frUiD7Zd7jYwj0fjunqP4E1F6nreQ9xtGoTKuXZxyJjAJeBJ4uhwhHJ4HdhuHecSuJ6FUwRTj\n", + "MJPKew01oXOvCfAUDEcg+6ehfJc2mAGoHWASqh7ZUUoxhSh8bzt/Bfs7wf6OkLAZeiSvYejG31Fj\n", + "6BZgJl83P8yKEwZj4moV+iTQ7W74ZDBhd0HBkxCZqY5qcbsgcQaceP8hmh2JtdXtQ0NyPw+kMK3p\n", + "A+xpdQcZCQc5yFrydzxNyur7gCeNw3xhPXcvR+MBbUNnDrOMw5hCu9CYm7Wz+t/bsGUIhJ33A/d/\n", + "cQLQxjjMoYre53Vn0t0cIzt2Brd50TUjUeOsK7xEP2AVbkPxj8EOkljlgl9EwlEK3ukoRWoZcLEx\n", + "bi6tiLgYCKOMMdtFpKExxXNhBl/wewjciGzIi7Z7qlY/XEyAxaTB30+A3T1hFds5ZcE3dMyohQr5\n", + "rujH5CngfylrJMDCa+/3vIbh3d4f9nUFc2aZr92+yI+gHpEXGYdZWJbzPcoZgY7QBri2tWsnVzWG\n", + "FxocYqc5xMai3OQx05FvRxGZCZFZkOmKNuB+fjWlc6/J8PIHmAo8Yxzm51LPk3HzkI8Gc+7focVS\n", + "iN2r7+zBbTvo+ce9aGyaeJR5MhIdnS/GZSh2jnoMM32UquRT4PR/aSKjGc/YGsbNJ+XTMahwvB4V\n", + "lNHkk8/CHoYlMyLIaGaPnbCR/t98yug9p5HS/VGPjj6HU1asZOSesUAG8DApo6+HaZoNpuNUOHMC\n", + "rB5H3YXT/ugetz6q5U7WBSO3tThlApq85R+lHBeFqs9crKGewM+4O4LF/lSxAbelGgT/AMBhjBlt\n", + "1/8FYIx5zOOY64Gmxpj7SykryILfqljCc+Bf9SA3Fg63hqPb99Nu32SULeC57A6WE0fxtiQlQ6t3\n", + "oF9D4rbC4B/gpFQ4Gg9/RG6j695HUSH/W/cUBvviCZfF0arw2k98F9rPhpaLIXYPpEUcouWBl9AP\n", + "dIlxmH0lttsprVDVzkHgstI6IKuWikVZF3FeSzzqaPM4IPUXc8KYBQx/PxPXXJyL65Lz7Sj2HelO\n", + "OLnhjYkoCCc3GrIawbNb7FFuFZk0GTif1pcMosNMTfu3u6c9JmT89YY4pR6bY56mUd540mNzWNZi\n", + "E6vy7zfH1hSLhQM+dPdRB6HZz5A4YT2nbv4VVTk2RW1Ky1GmTCQ6eDmdPGnE723C+T0pjtRX1Xv3\n", + "+iR45Tc40pwiHbhy668HHiQrIpbovIiYTWF0+y6e2J09yCSKDexafnjcllZ8cf4x8t5s6W7phI2E\n", + "/Xgr96+tDfyHVXXr8/Xfojn2jo4UovdTp3eX7ORVaVEfHUIK6RUVzG0tThmKUkkHlXpw0fPqoGor\n", + "V0fQFViCuyP4qaT4V1Dcl2C6DqqrVPCfj1Y6wa5fAvQzxtzkcYxLxdMdFQDPGWPe81FW5Y34MRC7\n", + "D+K3QtMrVnDW6ndRhoDnkoDOWrw7hMKlIqFX3br+jTqCPdAOzr0MYhZkMLnnYnLqR8azrs7fWNX8\n", + "bYxrqON6Qd8fAJcE6hji0+AWkwaJw5dz7sqp6AjkZHSKvQzVl65FdazR6HMaiDrGLEA/bJcw9yXU\n", + "XdtigWyUMeFaMjz+n4x6Yy45+Q3G31GXDvPbqCFyzEZt5ojaLJh9Lxfz+LC3OTrz9KLpAIG4oSu4\n", + "Y95iYCRZtVrx+0W1SB0JG8bC0Xr2oOOX7ukPhbOjsJcT6fY5DHgaYtblksYkOmYUswMEYli3LLJe\n", + "aOwg19Ic7Qx+Jy2yOVlR/WiYU5eMRM3SdaQ5fJ6wiWM/32TpnScAE1GD7TWkXPBq7d4NBjP8NSZ/\n", + "YzjX6g7GE5U9Jbbt/iOZa1tSbzMk3wg7+sH2frD7idkm47sR1pY0ipV1n+LnLu0oiKnNnoiFg3Pn\n", + "xc8ryDvhjpFKW75olZZZEbaNHRQtMQ7TvDzne5QTj6rjXB1Be+AH3H4ERQK8uewMl0LiTCACcAJV\n", + "LfjPA0aXIvhfREcHw9HgTIuAscaYDV5lGXsNLswzxswrf9vKxgixU7KWFO8QPJejlNAxALv8sQV8\n", + "CuOwPDirfR4NWkYweQp9si9mGTPZGwuNPT7DMZA2DRoWCGRGwpHakFELLq3LwqWX8x+8BfCPDU7i\n", + "xzHJZL1Xr7CQuIuzGTl1Bz3SDUUFdS4aMTEcfY8yUAZFDJrebhXFBbiv9SNozlzf1++UZsB/gWTg\n", + "aEQOiaO3EDH4DzhnrfKeAUY1ZNfMG2lJSvfRMOB5mFjolETChYbBM1bQ8/BkYCYpo56E6ZWeJa0i\n", + "IXx3gxoAACAASURBVC2qC3b2FW2XGF4f8AEFLw0kMks9qLMToPWPMPTsPbQ7EIHbDlAYN6Y8obHF\n", + "KXXx7gwKaMvB6AKORUbSJD2CAjHkhK0hNn8/6mNyD/CGcZgCkTHT+1Aw6pXmMzlvnDpBXbVCyz65\n", + "YdTRZQW/RZHRxM5kl0CLJdBiQT618jehI2fXEofOMJuOeIXsmXto+EtTGHEpzH8buu2rML8+DDVA\n", + "NyyP8byEchtSNLxEU9RLbg4wd5STJ8cYRn2C8m+hegR/fyDFQ9VzL1DgaeAVkXuAaGNMil2fBEw3\n", + "xnzmVVYlsXqCE9PdjiYaUHLH0BAdNRfvFL5t1obfTr+To++2d5d6ZRZyeQw3ToA6u+n/XgyLtu9l\n", + "yBUQnQuPz1YnkQvg8KcQP/48+KozxB2DuBzYY8g40pCf8SWEv2/YkhXd+pMXJ5CVTfv1n3LOzu8o\n", + "QVCLU7oAn0Jh4ouT0M5uscfys3GY7ADuV0v0BR6MMjEaop3+MGDoyAdImVFQnJvcvxWHllzFemAH\n", + "a+NGsqibIbPeYXKO7SZ/58Mma93/CuuoZLpnMEJaeMN6TcfgEsjF/5d13d++2ujsKwvI5lBMQ7I7\n", + "R5MbAzOe1tEyYHXtV1HUDvB/xmGWl+f6fF5zw47nEd/xWRqPbMlJkyB+C9TKBMMxwshCNQKLgC/4\n", + "pGX20DXHXp7D3uh9MZAfBk3tPHtYQuTRuVfHR7Gzr+Zi3jhaPbnDRk/n/hl3o4bUfujMMhHNC3BC\n", + "n3eJWLaJcIC3esITp8LSiTA2jvULbqJ7eUMmi1NWAxd7xk0KNuyAaQj63YwKy6VFg22EPbBGM5R1\n", + "2q/0vqoW/BGocXc4KvCWUty42wV4EXVAqI32xhcaY9Z4lfWn5/FbtkEL/HUMBbQnLzycI9E5ZERm\n", + "cTAqjH23NCA/AjrMplbj2fz2Th5tD8NrveGhQaoC2fgDeT+kEWFwu4ABjIEZ02ynG4S2j0bd5J8H\n", + "HjMOU2A7u/ZoPBTX0g3V5y4GFrd9k9pdtjIuOoL4A7HErhzIroN96YCGFZjvsfxmy/weeKx7CngL\n", + "1YviyZ06mswjXclC48+fbxxmS4ntrsSELS7HmbUNYVVjyI5Uj80n41m36TQ+oHzCOxwVxp5LdiWs\n", + "Hy2S9SoAZziPuEA3oR3/M8CUisaSL6w7Jg3G3ADdP4NvX4Ajby5h/PIPUbXiAHR0a/q8jSzbQrh3\n", + "OcOIWD639vhGdB3ampNfhOgDsCJhPxsPXW92pH5SpE7VpfcGHqyznlPGToOPDmmZE86EmbHkHMwl\n", + "Nas9Bf3f4UDzvZiyzujEKV+hoaW/qMj9KaH8SHTgdDYaiyi38RpqnbiJVs1awpx2cMMyuPeHKhb8\n", + "ACIyBjed8w1jzKMici2AMeY1e8ydKAe3AJhojHneRzl/esFfGqwgTUBdwVszr8OjRJ7Tlfitan9o\n", + "9BvUzqRZBnQ4AM0yYG49ctKaEt4ylbyPFhCVtBfic+DCePKnJpOf0ZlNKEc+1et3cyC0MTsCdaL0\n", + "uL8bh5lfyvHR6AeVXPc3zh89h8SPD7r7o0tiODy/LSnbx/G8z2ibTrkbHZGtqPsrF3X6la71sjmS\n", + "c4w9Wxry4raLeRlVOU1Gp+vnBJv+FijGicz7BAZ/0AO+7AoxubpMj2D7Hz15l/IJ5tyqCAXsjbLM\n", + "jqzAOQ+4A+3AnwXeLq9Ko9C+dfILSgnNj9RUk1+nF7HF2IQmPRss4pYRizjrw3QKnbAurkvOzFOY\n", + "cmBHi4Xsb303mfWO0HDfPpJXZtPg2EnAF01m8kuvhYz1VMutTmEgcGub97it01Yuioyhxb76NF1+\n", + "IXEFtSmodRQjkYSfsxZuWwSv7mHj0nz3jK7EqJhOeRr+n73zDo+iWv/456SRSugt9EQEg4CCVCki\n", + "ShJ7gStWFLAL3nu99p+zY9frtXdEQUSliKKUiCgISAelhA4CofeQQAgp5/fHO5Nskk2ym91NIub7\n", + "PPNkszNzzpnZmfe85y3flwPa0K+W5764vFdi809AhH0CknX/PTANWB/vIDEWJk+DcA1kB0KN3EoQ\n", + "/L7C30HwF4Wrl7HGBW2P5Vy+KartIv7MzSZzVzv+ONWCAJVNgg6krtKgcskljz15oWwE0hDHmEK0\n", + "yjqIg60lkghTdGKwPx9Asn+/ss6/VRv6oKsHPcXBLIT6wTbdXAqENVtK0OXBRG2sB312wos/yzVc\n", + "1JrcFbcXrAoQCtxWiFnycsTH8A4S+jfflWC3JqRPrH6v1GUU1PYH/JWCX1nwdHXkxAv0T+R3L+YH\n", + "cK9fFxFCI8+BcW3n6/0L+7o6x46XDwsg6nAt6qzuS2ZaR1oiExGIEvkd4gDdHraLW1QtbuqYRlDP\n", + "OZGs3tmW1URlHmqeoYjfOoduxzK0oYc4XVtPlcOCsFwCzjsE2+pCTgBkKwg6TlpGA8bVXMvpy+fx\n", + "j0lHaOEqGkiZ6n6ECvpuT+5HsfsjjuKrEWHfHQmomAb8oA29z8W9MbrCo5/KChJFteD/y6GEghwa\n", + "GIcI49n5x5oqHqFL6IAwF64HmlHcrNQQEez7kYnhDPJ8hCMrjiaIYzcIoYD9EdhWexm1L1nBXV8c\n", + "pcXkcJgZCEdqkHc8DL2xOzkZ53LKOu8osLbFas57LJWYdoeh/UGoZ4nvGwL4beozTAauRfwEkYgD\n", + "eTPCATMIqX40t9R7Iw60t5GXYaCn+QzeojyUFmcrXOQDuO0HcLnaGNDxKO02/q7fzhrg4TgaAAnk\n", + "8h55AZKck6vyVFBuUNsjqOCNkWxYmUT2iYlOZw3fzj8m1aFdem9t6HX2t906qrW7B9D+xvXwcyu4\n", + "biN82AWi17EjLYu5bdZzS2QgIRnBcGUOPGFNd/kcOaa6HHhcG7q/h9egkHf4GmtrgdzTaUgltDKj\n", + "B50T9iZD32rBf5ZAmaoXUnTjwaLl55Sp+gGvIua1/2hD/1JkfzAi3GUi2BF+GSej+hOZG0HUyRCi\n", + "M0MJJBCxox+y2olWZ2iiAgkM3QmJM2CKk5i9I4QDc+N4OXUwY2xSrZI0Ykvjn49o9LORZJ+6iOOt\n", + "OyI8GiKO78UUrAzWFuWKt16SF5HC3Ze50oD8CU8oLc4GuFFIpBYwHJkE3PYDFFNwGmwew/3bPgAu\n", + "1obe5MkYlWqfRKe6Y+hEI6Z/CLGzqX3Oo3lnmp8JyD0azukto2DbZZDak3xa6Ia9Urlv0VJt6EF2\n", + "O4lKJXfuz8DFTSH5CwjOg+VNoM8gTjc4QM6qaUTWtcIYHkfC0frgxIopNNJztaFbFB1jsTHLO9mH\n", + "Ant9LiLopyHZvB4VfC98P6q5es4qKFN1RDQBhzb06CL7FKI5v4Q42B/Thl5brA3VPgm6v0Xkc3HU\n", + "3wD1NkDMmzm02b6L8Lz6yCpAAblBWaj6ZwhKz4OsSKh/Ekb/AElW4G0iHE6FO6xlbtMGc/j3gD8Y\n", + "PiGDSLu/O4LZt7QGD21ML5mfRJmqLyIwhlLYcdwCyRnIjyKyBb0y1RNR63mw+7dsrZXtuSPOV/ir\n", + "hne6A0+imJz8AP9CVpEe+wGUqZ5C+PNv8WScSiUmE/D9QEbFwtffwb4L6cJAfgucTdemHVkdeyW0\n", + "/kmYQsdbC+aYS08x4pcQhHLkZW3oE+2VSuqmeGvnbcR12w0v/CIruu3BnOjUnwsmxhd+/v8PeI5C\n", + "Gn8QEtIZrQ192sX11aTAXp+IrK5tYZ/iK19PteA/C2EVwJgNfKQNFzxIwqh4L1LDdBZih62NXdnq\n", + "YOR11AyshQ6AzDqgciH8EORmZRGe8511zjxt6J22Bu8Ang6AfZFQM0ucyQAPhcKcARzf3J4TeaFE\n", + "AnMa/My+jkvoVCsb3NWIrRfmANDBmT/G0iYvovBkkAEsidhGWq/F3DhtB7VDLd3I29BKT+GbimWl\n", + "cwtVJveQ/fv/2gJWNYZb1ko+SWk+DUsB6YlMAB75AZSpolQOu7qNJaXZbnLcnUgLOYuzI+D3u4hk\n", + "BlcxKHMjHcJ+x6rUGJDjVBHu8pU4floCXIf4wr4C3ot30LJ+Tf69+G56tZnDurw/eOY8eHQS9J3X\n", + "EjbXLeC/dwC7i5j6lKk2A9fYJR+tMOarEGHfE0nGsu31e8u6J+VBteA/S2EVppiNMFo+DkiR84Ky\n", + "he2QzOhzkbDeHQgB2mom9LqPPd91In4iNFoNO/rCzr5wYuRayNzrLGDiSaEHvNUQ4p53MY7Lm0Df\n", + "WJi2h8XLb6e3N2F+IaPU3Ja/U7/TAg6X9MKrgvqk3Rut4/kmdWi+sZ6wIn42TY6pSEerLRj3RcLp\n", + "oIIon0E5JCfnlj2GsriFKpt7yI5iWt0QXu8B09pCvx2wZyMpK67lgrKoBIr4AWYhvEAl+gHaK5VU\n", + "oy+fxzag7iTLmOnORFpSaGo0HVacIeScTAZGC2+bjSeBhStwLOiDBDYMQ8JHRyAZ6+8i7KDfAD0S\n", + "HLzvyoTpvOJ1uuaZ1rXWQoR9Kwrb613WGvAlqgV/FUV5tThlqgLNXbIhb0Xs8cFIdI5dqNzeNiHa\n", + "vglcCbzD6O7/ZM/iOsVbv/YUAZPDyQu2/hcBE08KdcA8B+LHiGYEuLZxlutmIC983U6MiTqPRtO/\n", + "tHov44W3hdKpYFmJ2Jm+3o7FkzG3hC+6QO2UOrDqYkg/V+L6Twqx8BnKis/fVL8XJ25sQnY4bLpa\n", + "ahQDdiy9qnHZbFrffxntpkpx8t8eK7Tf39dY1GeTHgKT4+HhbhxLb0Q2EmI7Vht6dWntuOsHSFQq\n", + "eUowA2NHwezxkqwIZU/mpYWmCivoA31p+izs7Wpp/JcB70oheFM9BFyuDX2VtVq+ASn00gJYDTRv\n", + "8zrP9DnBf0vkv5cVa29E0N8J5ACfI2GXC8uaIH2N8sjOoLIPqYY3KEGLi1WqPRZXiUKSvpy1d3uL\n", + "oLBwvw95mfYiMfeuWP1OAsOUqe4EPqB3SjZT7ziQT1oFwJ2n4F/hXHkv1DgBv7wAR0bHQdJD6/S6\n", + "RGBme6WSEmFcN6iXS4HQBzHpeHNPmsHIrzbSqHmiCM2IbBgNcUmSOORS8KdLBjHh2QVCH+BIRMHk\n", + "5C84mXiktuRReOp7kZB9gERITnbkmxDCS9x2NO5ATnvhasopqBNCVEALZaopPBLYn915sOEG2Hit\n", + "0wgi/X6NAKnw9giItQVe1BlY9Dvbmv/OyBQHm5Fcjx+UqQ4jyX5faqM4065Fe/yaMtVbiGB9yun/\n", + "sXbUShSERmTD0/NhWUyB4I+k9N/UWh0BScVCU5VKHAl9YfccCqc7vmw/s6OBR5WpumpDL0NMPl8p\n", + "U3UCHkAzcPPwGhP2f9Fq37qD+w7XJ2NfDrl7tkXxyeZ/E65MNR55HbYjWv37QM3Syj1WRVRr/H5G\n", + "/rI0IAdqb4N6G6H+Bmj++h7aHNqLCPtTFNfeNwB7ijqArOxgO7np+qKhX1YI5JOIFnMHkM3amh+x\n", + "vF0DDjXcQWb2PsiJgdnnE3wKur0FPf8H62+EhamL9bEZPe22/BXOaGvvr/eAW9ZAQ8sdWJr27mos\n", + "Q4PYM/UGItPbcbM2/GfndzbxRGfJ5APi7Nvnwf0oMXs2pschRix5jP/1u5X0uS5CAyuObbSsKCaL\n", + "SfMSRNO9AvgZKXqeXFJkSkl+gAQHn/g6T8JNcrn7OBE0jNcHHHZehQMQ3f5dRsxrBXlCBX44I51m\n", + "qVuomXsOsAgR9t/bvillqiRglDa0i6zoikG1qacKIt8RFTcLrnhAePEPt4OMnzZx+Zq7gI3uVrLK\n", + "b1OWmh8iRdOT7POtGOcvEB/AEKeHMwAYjIRFbuCTbtHsXtIrv8GwI9D7Jej8ZjY1cv8LvGonTPkj\n", + "nLG8iVGuxpLi4AiyxC4W9uor2BPVYwPgnW7Q6hh03ge/7+fU/jAch/vwQVmx18pUMcyr/xQrBwwl\n", + "/UsnjXbYn7D0wZJt/FW31KSVZfoPJDqrNfLsfaYNnVLKOfl+gOCjrE6YSuz3u2lm7/eFYlFmKdDI\n", + "tldzT+o3TP4piFRbzxmxFTalwfzOnPstDB4MOcGQVRvC9ucSnPce8JY29PYi19MGqeoVSyWhWvBX\n", + "QfirYLilRb2CLDsvRzThLxFb4zOutC9rtXAfOcrBhtaKn+bV5IRNbT58G21nP8dNqf0QTe5l4H07\n", + "TM2X0SberCRKyCzejTizn9SGHlueMbmCfc3dWdZ1MUdrA5wJhJT6sLIJ/F8su/bHsx+ZgHchBTZW\n", + "Wn9/R4jprre2c4HpzGy0g+WdujtXqyoe1eMf7iF/QpnqXGQCuB2hNx8LfF2SUmP7AVQ2j0YeJqjt\n", + "EvbUWcvu3Xn+z5NQKjGZC68fSPwkGP+T054rj8L0OoQdhe6vw/lfwccrIOqmpTwwewGyylmKOIN/\n", + "jHeQ0BQePt2CAaE7mbMb3qyM0N5qwV8F4W8tTpnqCeARJIX9dm3oWW6cU4s9oR9RL/s61rbYxy+t\n", + "NnNq/0Jo1gOiQqlxLIjE5UF0SmsMPMML7Y6Q3esNX0ablGclUVo4ZYqDbUjk03+1od8tz5ic4fy7\n", + "RTKDJEYxkW35+4s4++wCJBcinsTeiN9GIxFWc4EpwDJt6GNF+/IWVSm3wDIFXYZMAglIVvhYYLar\n", + "KDDr3l2P8ALVBgr5AfwyRjV4HgET+nL3RfDldAqUnxuOwTe18w9MGCXcQl9nJ+u8WYnKVOFIsfYH\n", + "1RkaXbiQ4NnLqVfH8h5UdHhxwfVUC/4qCX9pcareOTcRWu8d2h6LpPP2AH6t+0+9ZN/7bp8vHCEm\n", + "Oeo65nbJZsnC+uSGWHtHbKXDrI+5fs+1HA3rwKzJkaAlE3K7zQTu2arFMlGFWlsNp8+h7nzfbBnD\n", + "hpwh9nQQDFkH3Yun0LdECnOP0YZ+yd1xuRyrvVLr/zQcjSVybSRtc8dQi0VHg0lfZk9U1sqrMyK8\n", + "bkAck1MRHpkjSKk9m5u+E5IpvZKClcHKolQUnqyu/EEd7StYUWk3IZNAU2A8ItQ3uji23PkAHo/L\n", + "/m1VnlQGy8flK6FFdL6CE3gGhjU5zeGchUztkZv/e6idb3eO3fBM2w50m3GOcFTdt0JaqAwep2rB\n", + "/zeC6tDsEVJ7vcTxryUyK34iXHFHLstqPqbnHvxfsePFzu9KqNZgVttxnF+zA9G7YPXtsP8CCMyC\n", + "6BdS6L9lNBsbP07TnEYoi2xz/WAIOg1h049TIzeLQBVMUDZEnzxARG5msfYLPiskOqfoluXO93FL\n", + "uGl4Oi1r5MLArdDOiidxdgpb/OU/AT8gpp9yPeD5vpk2P8AFn0LLebD5KtiwbTU3LeqCxIHbZpws\n", + "JAZ8KlI6z2WfljZ8DrIysCeDC4Dj2JPBsjoBzE+4k4wJrQrOLHl1laBU8ouNGfhdW6GOnmpR1FQ1\n", + "IjmLZ2ooEpK8gwJTUDHyPYsKYSRiNiozH8DjsZQaDgqFlLTGm9Zz695RTJkeyJ+XWseO2NqVyZlL\n", + "STv/QIQURaro8OLC11Mt+M96WAL8EcZe9Bw7loVw7jTo+q4I4ogDUGeLJoC9iOnHWQAHUViQFnw+\n", + "ULM1mRdEEXxKBP7htlImL/iXfcTvnsyqmKvIGNqKeinQdhoci4UV/eDkpiyyR9Ugp4ZVzP713TRZ\n", + "+V8uO/AzLoS5N3wk4L5T2KpilIzwAI0qTy3lYr6Z8ENw/pfQ9cls6p4KRDT3rxHNtNzp99bvGYs9\n", + "GeypeRd1AuuSHQ4pg+DHN+yrdObNt+PIr62RwT3Nsqhx3Ua4diP0SJXZtTIEkDuwxj4QsZcPQMJ3\n", + "PwN+KWoKcpEP8AaSAetVfQBwfxWuVGIyrR4ZyPW3ir0/PQaAaHocPs6SekWPr9b4PYS3gr8yU90r\n", + "CspUdRHWzjo8f50iZ2p3au2AOlvEBJMTCjF3byRpdX3gmdj3OB57hLuiNMEnNZkl2X7LckAX0pC6\n", + "vw4XfAazwmHHUtGG62yFn18sdI4/rt8Tp7AVcTId4UcZUdqk49JhTDzQ/W34pCBao+aQ03SZ8yV9\n", + "Dn+LVES6BWEcHQtM1oY+4e01ykpjYl8iJkH2QjhTF8kPWpqCY87/IYynVyCC8Lvuo0lYtIeLi744\n", + "VU3jdwXreb4ZWQnURwITxmmjSFnWwn6AOhTwAvnND5Dft73y6/E6HOgA24VMNJCr197JD2FVgbm1\n", + "XLJTa10lNhlKec+NT4LhW0Drgm34FohPquzr8tn9cdADBztx8BoOgiEhufD12lviLBx0UE9xuFt3\n", + "DjjvHA5b4qHYPXF9/4Ztdb5/ckziLGpcO5/Hg85Q48otxCzR/Ke+pt4Gp/MGzfPnfYiHpESYNQjm\n", + "JcIsV9fjdM8icPAjDibjIKSk9obDFuf7dEcI+2pdzXxuisygafcjRCduIfiyuUWfJxwE4+BqHEzF\n", + "wXEcfIGDATgILP+znJAMv2p4UhOUWTCsoNs010WvwsEDOGhW2viHwdbS7ktV3HDQAQev4+AADhbg\n", + "YBgOahY5RuGgFw6+wcFhHLyCg6Z+HVcp75n9LF4bwrKuLciorHteHtlZ6T+4N4Mv9uNcd5vmmjs1\n", + "7aZoaqRpSJxV2dfl9X2Rh/3f1gtxdcE1ly6sezbk19Yj0S9ejM5zOigRXN6TfMHOoHnyt+RJEwcv\n", + "0LpLKv9sqjl3WuEXQiXMrux7VmSsNSzBPBMHYUX3J0CyBj23Jdrsi/65FfpkMLpvLdbioL4H/dTD\n", + "wUM4WImDVBy8gIM2Ho+3Wcs7UVdlgdZcca88z8En84WNq3M8mQy9vp/EJ8n7Nmie/PWtcoWDYLo2\n", + "epYmPQ7QvF8OjXruoVOTJ3AQUOS41jh4EwdHcTABB138d71lKEUOwnBw2psJ37sxoj0956ww9eQv\n", + "x2pvh3NmQJvp0GwRHAo5TtOjzyI8IVvKaqcqwNnscDiS3AUjiMiJRgH/KFp/tjQ75WCl5r0ZRd+E\n", + "W+HTadDF4gX0he1Xmao5pwK283t8Oj+tqZW/I/LmkyRNP8V56Y8Dn3tr0/cVLLvyWCSy5Cpt6HTL\n", + "CXzdgI944ad91FrTECacDwtawOqGEHSM9BMN+QhhV1zoSREYZarzkazpWxFSsHHARGdHpv07R0Lo\n", + "ruYEr72MHZnNiAea8PrAIE4k1yYkA664Dxr9AZMnw+FnCpUqrGhUBImcyz5qDjlDwozjnJf+IWIK\n", + "yk+i8qcfoPCYSvcHKFOlAr3LqhHtD/xtbfwubdQhGRDfYxXXrFuF2EQzEJvvDGCBNvQZb8fsazjb\n", + "sJfGwD8GQdgWjutfuGPjKf29J23ZjtAzgRDi9Ar4wvarTPUBkMTCOvOY061BkephR5HEsvrAE0h6\n", + "e6U/ZJYTdTxS2Hs/wm46o9//iJ+bTifnY08Fw8WxLPv9Jn5AnKjdgd3IJLAAeX52utFnMOLIHEqB\n", + "I3Ncm/9So3Uj3m8bR8x3bcUZG7qV44cyefFwH17HkTCj4HnWcOEYuPQJmF9/tV6yvlMJ3fkd+e/Z\n", + "xS+JrXvvRdYe3/l18vtotgjiJ0Hym7IjdMAiHv95JTAESEEcwt9oQ2co1T6JwJhRXHC4KRdtbklo\n", + "diCr4lJZ2mgHp/e/EU8K/s5zUKaaC7ygDT3Hl+261fffV/CXniRlxQhfgEwAVyJZlHOQSWCmNvQB\n", + "ry/AB7CF9biO8J/L4eMfJFKjPMLaXzw7ylTDESfbUOBboFVRsjjrfici2b/pSHm6BeXt0xsoU7VD\n", + "4uuvRzT+/UgpyL7a0Knu3CdrxdABmQTsLQuniQBY7xw9VCzYoPHmCdyzvRdwA5p6DU/CoBQYsQrO\n", + "PyDCPz8fwdXz3PiaVIZOD6BG3kwkUskrorzyIH9lfd3t8Gd/+GOotWewz1Yi+X2EpMOIbrD4n7Bq\n", + "RH4fVvb5lcjzdzGHQ5Yzs387ts9sKndRQ7M7oMcuaLmO4DXhGVcvTj05JY18kkJ/5DkoU32ChPJ+\n", + "6Ks23e7778rOWRpbH4Clca6ytueUqRoigukK4A2rmIK9Gvi9POF/vkCUhF3SaT8sHQ2tjsv3ZbEV\n", + "usI6rWe2V4okH/LsKFN1R/h+emtDb1KmWoNEZXzmfJx1v2cqU/1o7R+vTLUWeMK55qk/4DTJ2wlV\n", + "UUh8/b8QQZ2L8KvNUaYaoN24T5bJyn5+3nKqE9AbWUH8C6irTPUbsIBvYnIh4b5CEUGZN13G6iPr\n", + "6Jj2XPfJ3NU7ho4TzofHF5LPIWn/zi6f53273qFG3gLgY2CJMtUgbejN/rqPrpEuVabSG0OkcwXM\n", + "DB9OQlYfZ6Lg62/hrovhQEfYI31YSsY3wDfKVI3YGDOPhF1NCYqDlXcLlXXq53BwJER8RO2ul0f+\n", + "ci+Rt2yBN36UwjJlMcGWE1txUh6qOs4KwQ/ysuDmD2lp+GOBsRYn98XIJPAlEGUVV5gBzKmIQgo2\n", + "bOrhjkXWH+WlQbaEl29sr2ITnwIMc6qR+hrwpjLVWFfmHMvOOl6ZahJCKf2zMtUshEtoly/GZY0t\n", + "gMIJVbmIcBgKLHcxkT+rTJUOzFemukx7eJ+sa92iVPtzoFkTiNpD0PHddFm7hoT9bUmPGQKfhBJ+\n", + "GBJHQlozONErgB0pOXRMW1RjD9e+vAFengMBTnfN+Xcu6XlWproZuAf4TZnqQW3oiUWPKQrfUTqk\n", + "vg0jYsmIj6O2bWYfvg12veN5W2X0weg4jpwLP3wM/7gkhykNxhU9Uht6v1KD9zNn4rk0WQGNVxXs\n", + "rLMd7uhKuzFBTJsLYztJNTkb2UR1k9WFz0K/tyI1pf8SOCtMPT4dh5Q6tE1C3ZEkoOnADG3obaWd\n", + "6y38ZZ7xFtbyei5Cvfus0/cKKaT+mDZ0shvtRCO8Qvcjq4SXPHGaFmkrGEntvx4pp3cY0ey/QYq2\n", + "l/lgK1ONAAwgwdOVSIE55uM4GqyDtt9B/BtZ1D2exUcDMjk0uyEh6fJ9zd0QnQoNJ+XS/MhRlUOE\n", + "gvAW6dD0BDRLgz8yOb6rDl9lnMNsxJ+QChwqafWpTHUBMBnhJ/qXq5qv4HtKB6XaJ3GRfoG2R2IY\n", + "f+FKf5DIFXOmjph7gpjT9YCBRQMGSs5B+T8IH0kXNYDlJ9cU23tRYB9W5P5q/ee9g9ri8x+vS6gY\n", + "6AAAIABJREFUDX1+edsod9+VYeNXSiUgCRWBwCdaF68Lax13ESJEB2utp7rYXyUEvzOUqaIQwqkr\n", + "rO04BSYhv1TaaaLqGC3IezACFXwSnb2TgHf36qOmr/vxBMpUHwENgBuKCiJlqtuAO7ShB3jQXmPE\n", + "3DIYqc70ljtFupWpQpHf43qkrul2RNhPLa/ZQ5lqCBIJcqU29Aq3z7MLft/XQQqrbLxOiqfsevlH\n", + "8hQuhVH4pUt49JfvgIsjN9Kv9XoCg4LITI/g1O42LM9sxn6gGeKLaArURJgu7Ymg6N804CUk83eQ\n", + "K8Wkj1Ir+kDnA5GwJxLOtIGIJrAgjIPHWtjFafNRmjBw3lcXKfU5v7Rza62iYbsVxEbkEngykNwN\n", + "Xdh6/EJc+dPKEkIaqXlzDFhbaM+qWo34JakTGRMiC758EuGH60NkaJ/Mq1jIl6d1vrl0cHQgsxIU\n", + "GTENYNM1sP1SSH3/Z53+s9vPcFFYsuIAEFnRpuIKF/xKqUCk3N8A5AFdDgzRWgoPFznuJ6TgyGda\n", + "629ctFXlBL8zLHPChRSsBuKQa5qO8HEf8rqPSq656nJMprobeBjo5srsZZnKtiOC8w8P2z4HeB4x\n", + "tZnAp8U0OlNFItTT1yNv82pE2H/rK3ORMtXVCPXCDe46ofOdkHW2wtFYCiz1g3+F9a+6UQwkABGe\n", + "F1PgMA6msMN4E9CYgsnA1d8oxIFeE1iCKFepwO6GP9H8kj94ecIpwmyT0qhgiGkAU+qxbvl1PO18\n", + "SaVdbpH/hbVVzHcuz200iwsHrmLY2Gwa2d8NDWH/jxfw6f5EnGwypfbrvD8KCRb4HKFGLtif3PAC\n", + "1rdLIC8yhNyMUPRpCKp3moCMbOI3JDfkAO1SSIjMI/gQkc1T6twfmRHVSWhG6myD1nOgxU+5hOT+\n", + "gQR9zAF+89SBrky1H+hs18GoKFSG4O8BGFrrBOv/xwG01i8XOe5h4AxwETD9ryj4i0KZqhEikK4A\n", + "LkUqaNmrgT+KmhrcsbPmL1uTHhRH1YEO1h7fhMt5SmuhTNUTYZm8uDSNWpnqMSBeG/p2d8fifD92\n", + "tCJk1Q2E50YSBjwZ+zaBTXN5OjiUJmnhRG/uyOq0TnwMTPNXBJYy1QDEx3OrNvTsMo93i+bCfUZW\n", + "y2zWnIJJ4GJEuC+hYCJYVlQYKVOFWcf1B55DbM1rgJjwI/QNCyMqPUTYI9+0jHH/B6z0psqVTMYH\n", + "gYiSTGp2hFq/oTDhG4ixVAavqmuZqgtC2tbbFcOnW22U9LsFDfyRp2e/iLzLA5AormVIhbE5CItq\n", + "LpT8LitTLQSe0ob+tVj7fkRlRPXEINqFjd0UcXAopWKQosT9EcFfNZwKXkIbej/wKfCpZQPvjUwC\n", + "k4Awy0E8Hfg53kFfF3bW2PZKUVj4R4UCkFlHOHDsGGYf1Fwtq/ZvseNN1QSxId/phhnlI2C7MlVT\n", + "HPEdyppcitmd/4QhH/Hnt7ewJrsW448NJuyTZOi3wxrln0Qv/o7d67T/wm61oecoU10LfKtMda82\n", + "9Leln+HkhMxHgaPTk2ADq38N7LS2LwCbbK4XMgm8ApyvTLUamQQWIlrpUWALsEWZaiLyTHYGBg98\n", + "h2lT4fzMIMgMLuhrC5zeBeV2yGpDZyhT5SKrjGLsmlAQodY4HWaeI2GrUL4INad+VyhTPY78Rl3L\n", + "F3hRwu+Ws+dtbej5iPnKUKaqiZiXLgXGADHKVL9GbmHf5Q1ImnKQFraktd9lHPmRPRUq+MsDbwW/\n", + "O0L8TeBxrbVWSilKWdoppRxO/87TWs/zbngVAyvEzF4i/tMqx3YlMAr4Ys8wsjqupd6fmwtCNF2H\n", + "lFmhbH8MheHd4KdXhHzNJ+FyzUbC6DhazoOsKNjXGXn4k4qFtVkT2TfAB9rQM8pqWRv6uDLV5yyu\n", + "8wb06FTW5NIMRo6GuNSa8M158E07WNuQVlG7CY3/is33NKPjsKvh9R/hmk2u75U/io9oQy9SpkoE\n", + "ZihTRWhDf1HisWWEEPsCWgqZT7M2lKkiEMXqYiRTdYIy1U4Km4duAEaqHH4/GUEoJyEsRzYbRyHF\n", + "B8EC+xCTj0vBb0eoXbEFppxXIPjLG6FmQxt6jBVW/JkV0uqRIunu72YR7k23NnuF3z88l1eX30JM\n", + "MwXXbIT3ZhY8nynwGxUQ0qmU6gf086YNbwX/Hiiol2l93l3kmM7A1yLzqQckKqWytS6eiaq1dng5\n", + "nioBS0N+HXhdmSo69ncWrWxGvdd6woZ3C17C4tqPpY0cGx3HwfZw7g+wPtlH4XLWaqJGGtz4D/jq\n", + "B9jTlaKrCcvk8C6wF4nZdxdvsTl2E4wOpn4K1NoJW5JwNbnY2uCkeEhpILHsl/4Jt+ewGWBIGtyw\n", + "AZTTK+18r+wVwwcBxAVoCYl0vYLyHNrQq5SpLgV+VKaKLC0hx1Ot3ltYDvBfrM1OLOuErDZvRJSs\n", + "TGDB+d9ydGt/Wt0zBz5yErV3wqm9Yp/3Frbgd2lySYW3R0DsS1uJu/8KOB0ED+awzZuVhhMeQia5\n", + "R4D/enpyeX43a4X/5WCl7p4IMaMjI/kwry39iKAGJznOlhhI24pMvD5FUSUnXpQch71fKWV43KiX\n", + "5EBBCBdJSyAECe1rV8rxnwHX+4po6K+y2URgzmRpJRGm5ZOldeu0gbtqHfQVCVYhlsE2PwirZtNF\n", + "xYi/cHAvDlJwEOVxHw0uOwha03yB5oF2GvJcMnba96PolgizSttX9Pzv26BbjUK/2hN9KLxkArpy\n", + "3S8hAduOg/9U9vPjwZgVDs7FwfDL6rP/SBg6qSf6X0FoA/TToC+DtT7q62sc3FzaMTZ5XPS9pHVs\n", + "z3JfksfhoDkO9uOgf0Xe4wRInk6kjmVwoUe0BkNOcl6zh3Hwuy/7c8W+OrwIy255ZKdXGr/WOkcp\n", + "9SBSVzMQGKO13qCUusfa/5E37Z8tsLWfovH5rrQfWxux6nvuxnF8tY9GUWDb3HwlfDsObr4kl+VR\n", + "P9tHKFP1Ap4FepXLfpqetw2oz65eEJANMcutVUVhU1VZ96Ose2WvGK7cLJmY718EcSMhYgcXKFN1\n", + "Q5ygXvmStKG3K1P1RjJ8owCjKnAOlQZrfJuATYkOdWMdGDhjUeFjLmpNO2WqXygwDy12xWvvRiCA\n", + "rfGXCDuBUJnqidU30kSv9V0uijb0LmWqWxBzV1dt6NQyT/IBUuHt4ZzXez8Twwk6DUGZEJBDVuBr\n", + "4RwefAOknqOk8HwQEqVV2t8yj2mRwLCY08Q9HQDDVomp2BeZx9UJXBWE8hQXt+Lnd3hbPza/vaKR\n", + "JglLF9L96MPI8nQbEsUwXLtRsL3E9qM6fEP6l6H0fkESl2ZkuywsX9r9KOteuarEdTgcuvZi05+9\n", + "qIHUun0fKe13qjzXkn9NpmqAKDbzkESpqvHClIGSkgHn1+KJLQ+TQUH00IXABgp8BAtxxHcpK6xY\n", + "mepRoIE29CNljUWZqgMSHRbr6/tnRZRdD/QpyhnlDsrjKwpSV6/J5fvzSRwJHT+H3GDICwJ1LIvI\n", + "rGCktORppIJOdgl/S9uX/7f1cm669STNg/Pg9tXQ3PKoFCo3+nclaTtbYWmvXwBt/CVwLHv210gp\n", + "wfHeTjKqW+Nn2d9iJBm1NnDPnM68FztYp236zutxOmmgQRyO6suKRnNIb2LvtzOcUxz8iEwKDyCO\n", + "0HHAh97QclvUvzMRVsh7fUn560+4o2xYSXFdKAgh7UlaaAjbbgln18Wwszcca41FI+dc/vE2JOP5\n", + "lrLGYfmNdlrHr/flNVptT0GynO/15NzyZjWXFsqLY1Yd4J/a0IuK7/cc7pQbrRb8ZxmUqVTAaXZ0\n", + "msr+2M1k+oNS1npxpiOxy1d4SytrJSZtBIYBTyMl8r7yqk0XoaiKofva892etqSdLEWotUZ4be5C\n", + "CNbeR2ozeCy4rdj1aUj8+u3+yNquClCmCmTMJUtodEMXWiyA+uvhwz9AB+DMwmnlPTypDd3fzXY/\n", + "ALZrQ3vsjHWj7ZpIUter2tCflXW8DVuoZgXC/khoYWnTZeUalFqs3ZFyS4Of2Hfhb7T3RcSZW+yx\n", + "1YL/7EJ7pZJC+zDu/NrU+2yafOdrSlllqvuRDMx/I6uL27Shf/SyzfuQLNuvgaHa0C60Iw/as+kR\n", + "Oo2DQ+dBak9rj3uJbZZWOwhZBTRG8g7GeJoMZrUzCaDNa4xpncF9/uR4ryw4a7SRzKAtbxNBFln8\n", + "cTidtDvWaT2zyUXq3mMX89pVb7LCnetXproCeFQbuq9fxiz02/ORVcVKd84ZrNS8SdB3Xkt44lJY\n", + "PMb6voRiRYX9HvsjxdVUK8M5JLTeQDUhcQGJ4zOpbZ/n7Ttb1sqtWvCfZUhUKnlsBAPbPgi73oAo\n", + "q3SMrwppW87LKUBPbehtTpm6Q7XhFX1zOGLnvBSxjXcqr/NNmSqYHzuspWv6uRyNhZ/+C/vtWiSe\n", + "88ArU3VGJrobEfPN+0gilFsvgjJVcPAx5tQ5wUVbJxAWaf0m/uB4ryzYGm0k18YlMYqv2UZOAATn\n", + "5V/nF53CuX36SFoft3L0y7p+65nYD7TQhj7ml3GbahDwKtDFHfI/W+N/6WI4FCF5I+D6/Sqm5Qdm\n", + "Qc3bd9B+3ltcenA70Aho2HA9o3pB3f2RUgBp7riS2/QVyiM7A/wxkGr4BlEQ2vAk9N0Jv7Qq+N6b\n", + "7EcbylRNgYkIwdo2kAQmhPxsrDLVVeVt23KofoiwcE4C3KZycBpfkDLVUGAj5++oz7efw/ifnIQ+\n", + "lCexTRt6pTb0cKAV4sz+FPhDmeoey5xT1vnZl7xD5pVHCLv8Njgu2RGMhrjmEmnxl4c4cBePas8t\n", + "hyeyjU8uhOFXy77RENcMHhx/itangyAzqOD70q7feibmA5f7bdyGnowoMl8pUwWWdbwVXbZ1SVPo\n", + "YaklJUXb5SdAXvwSPFYHnoyCoYta0uGkA7gb6ArUqH2IzCHr4JU58IlTppIv3llfolrwV2HY2Y8T\n", + "J0sGqw1vsx8tk8VUhBWzEJ2yNvRShHriE2Wq67zo5j3gJqwVhOVLcGdsQcpUtyORJkOBu/i42W3s\n", + "Gre18JHe8cBrQx/Thn4TaIskAiUAu5Sp3rHMBiUiOo/Q0d9D1z3wYZeC76vay11etFcqKYGUkU1J\n", + "Cwa4eS0saQpfWoTDkRCsgOs2QEZIwXluXP8MJKPdn3gCCYd8tqwD12k9c5Fi1MwWnPl0P0uSILlk\n", + "CnQrAXLl3fD2Fnj+NLyRCu8l/aENfaU29HBt6Kebz2fLjevh4l0Q67Su8fad9TXOmkIsZyPy491z\n", + "y47/dxeWAP4AKUz9qqtjtKGXW9QFM5WpArWhp3jajzb0AWWqKUhkTTYSMVIi86Wlod2EZJUeAO7W\n", + "hp4LgAH+okewKHR/An5SpmqGOIPnKlOtR8xA04o6ctPhtALeSAbnBXZVe7nLA2dnok3dGZENX30D\n", + "A2+F7rsh4xjZIN85w43rn4EUwQn0V2SUNnSOMtVNwAplqmXa0NNKO369wUbg0KwjukfpLVt0Kpl1\n", + "i3xfJEclj9duqkXfr48XKNXevrP+QLWNv4qjPPH/pUGZ6kFkadqjLA58q7hEMlLjtcxKTy7Ob4cU\n", + "cHkLiNOGHubimECEl/8ZJP7eAH6pzHh5i2r6esRUFYuUOxytDb0XKq5gjj/4iMqCbfdOqQ9TwuHo\n", + "XnjLmvZe7wEvns+Z6Km81+MU14zJonVIrgR6unv9Ssp13uurcMdS+ukG/IATs6yrpDQcKbWB67Sh\n", + "byy1vTLqejsfGz1Ibb1oBgfrZHLGF+9sWah27lajVChT9UVs7j20obeXdbx1zvlIlad/a0N/WY4+\n", + "pyMO3qeApvZkY4V9DkIEfZr196eqliBlXf/9yGpkDrIKmBfvINGXE3JR+LpylruwI11mxcHnHeHQ\n", + "IQjaAjma3PQQTq38ByG5EZwhF6UgQitUQC65WnFCB3EcOInU3ThVwufuCEX7t6UcU+i7ojUa3IUy\n", + "1T2I36E7jvg+LpPS7hu/gYZZv2pD/6/M9tyk2lZSavS78rwv5UG14K9GiVCmao7EOt/hDt98kXPj\n", + "EeH/hDb05x6eewkiLLchNM/jkUxhA3nBDeDHqibwi8KKFb8NCQkFuabx2tAu2Sm9ha15r68PDTOg\n", + "rmVQ8Gd0iHO/Rb+3+1Wmaohwcg3Rhp6npARmGBAORFh/S/vcFgkgmOTm8RFAHiVPEmV9HgIEMLV9\n", + "KCfe6cyZCDjRFDIstokHI09Q72SSNvRvPrmBgDLVi0CmNvRzvmqz1P4qgY+/Gn8BWMU6pgKveyr0\n", + "AbShU6wM3znKVEHa0J96cPo8xPa7FvgPki+QBTyKVC6r0gLfhkXT+54y1ftIrd/7gecsDvz3taGL\n", + "F3b1AjYf0Xdt4dVekLQFRqyEiB3+dSCXxaNk+W7uAsYrU3W06gFkAyfcad8y7R0AXnEnxNfySQXj\n", + "/sRif25kfd4FXMEl20NIc0iZzNW3wbKH5HN0ZiQUqgjmC2xFnpEqi2qN/yyH9eKMRdhTb/ZG0Fp1\n", + "Bn4GntOG/tiD/l9D/AqhSAz9mL+KwC8NSorVjECubTuyCvhGG/qMt207a95Hw2B8BxjdGbaGciqr\n", + "Js8iGdF+KUzjJtXDG0ALpFylR7+lMtUXSM3qEimvfQllqpZkBm3i6zkh7HSSx80XwFWJafrdjFo+\n", + "7q8P8JI2dC9ftltif9Vx/NVwgYcQzvbhPmCs3AxcAjxlZeeWCGUqpaSW7Uqk+tppJMa62dkg9AG0\n", + "ofdqQ5sILfmbwHAkJPQFy7RWbiyl8eLGdD3Vj74MyexC3NJIur3Ptpor+T/gXGCTMtUUZaqBlr/E\n", + "Z1in9cyZWidO0rrfTK0TS/ApPI7kQtxdji6mIyHDFQJt6B2srvksgxJyiXIqh9vq4SPk5vijWpZd\n", + "iavKolrjP4uhTNUPoU3ooQ39pw/bbY0UA/mfNvQ7RfYp5KV2IEt0B8Jx8y8kk7cd0NoKozzrYEUy\n", + "3QfciiQsvQ/M8eR6XUWQ1ODmU+HMe/Wo3mta/UQj9usRQF2kPOBn2tBFCyH5DcpUbRF65z6ekK8p\n", + "U9VGSNsaag8LmnsDdVfEOEIDrubjy9eQm3mKh+fUpFb2u95ySRXrR96BDKCxZSL0K6qdu9XIhzJV\n", + "C6RQ923eEq+V0H5LdYbFrZZyvPPPHDgBp5cn8dvRrlyFOPtMYKot8CxBtT3gNCc7fM/+c9ZzqiI5\n", + "bio6NNJyBt+J5AWEI1Es85Hoxyhrq+n0ueC7gxFdUM2jCUmHn1+CNbdarbrmJlKmuhCZAP6BlP8b\n", + "DcwsbzSMJ1CmGgE8CHTThj7twXm/Inb+CqO4sFZG3yJ1wh9Cqsz10Ibe4Ye+1gB3xDto7O/nrtq5\n", + "Ww2gkDP3NX8IfYB4B+fF1+b0yttoWzOctrsaQk4Yl0Sv5vW0jjxVVMPVhk6rm6h+bZlJQru2NPvC\n", + "0g99VTKxNJQQGlmsXyW1hksSyq6FdMn/hyJaXzri/LwNEZB7EEf3TmtfuvVdev6WfOErpH94AVlR\n", + "cKqe05VEunTsakOvAu5TpnoEyYl4HPhAmeozxJ9SbLVX2kTo0SRpnreH2/Y3JD1qq1KJ61wUbCkJ\n", + "dhZvRZauzLOywpcj9bBtumh/YGvDZAb1gEFlPXeVgWrBf5bBWmZ+jFAjv+6vfprByInHaPl4iiT2\n", + "XL8BfhtDyFWaTjOnujZrdP6ZuhOCCYsbCWk1IDrLN9WE3BnraIg7Ggb3XgnpIXCiBnHbI/lameoI\n", + "BUIbJDol3Wlz9f9BJDy1tGNOFfVlWEVdhgH3AvURM9CkopqyciT+G85zcSWlcxNZORKfIYXI2yOr\n", + "gOXKVCuRVcD32tBnmqg6Rj9qPPolWeH2ubZAAnBnkgTbJNXzLSa92pB7O8E5D8aw5btYpdrjhvCf\n", + "DsxSplIV6fPRhk5TproeWASs8GPfW9ts4cbRELczGp7rC6O/r5jn3R1UC/6zD6OA9kj5RL+9UHa4\n", + "4VML4IFlcNkd8GJviJxfcrhhrWx0/WxY+gnUdKqV5G+OG3us4dlw43qIyhKm02c0m+YOYzCWwC5P\n", + "BSdPoA19EHhJmepVxA9yP/A/SzP/sCCpzqlMZj484ybShl4HjFJSoeoGZLXxnronbMFFwZFJX2Zn\n", + "hR0NgycvhQ+mFwgkDWo0xL3TFaacB0F5EJRH3J4QxipTLaKgelQON9Xvx0liyHsS9naBa4bBh7/H\n", + "kTHMHcG2AYnPb4+sgCoM2tDrlKkWAt2UqepYIam+xrawAKIAYtJhcVOY0UbKhVYFTqdqwX8WQZmq\n", + "P7LM7669LDlYFmwCuagzss0bC/3vgJNRxJSkxdnntD1c+Ht/c9zY/YbmwOCUgu9D4bAvnd7uwuKp\n", + "+R74XpkqDlkBLFOmWgq8j4NkHIzyBTeRtZqYgNSmbcOBusnhDQ+EsRtqZ8KPsfBHI7hgf2GBdMUW\n", + "6HAAcgIgOxCMcA4sa85YnGvF7mzchayuEJADAblwKB6uuwO+iC5TsGlDayur+woqWPBbqIOEJn+h\n", + "THWlH4INtp6oQQ2QyfOVOfDYAEjYChl5VYDTyZcV4b3ZKEel+OrN6f45aImD/Ti4tCL6i4ek4bBF\n", + "g7a3IZH8GfA4O3DwPA4JHCjrnGGwNR6SKnqsFdGvh79fGA7uxMEKHGzHwaM4qOfzfhg0rwsD8u/D\n", + "05eg/zlQPifCrARIdr5P9pYIs4q3lZBc6LCAbM1dPTUDWm1085oTcLCwEu51KA5O4iAaB7/iwPRD\n", + "Hy2iBnPIfu7yQPcdiu7elYO+fu7KIzuro3rOAlhFLn4DPteGfqOi+nWV6JPiYDnCaTMLoXjQRc9p\n", + "EMWzKopzQ/ayMNXPBFaljbWyHWwlQZnqIoQa4lpkZfA+sNQXpjulEpMjeXBgEqOYyDY21YV+Q6Hv\n", + "GyGn1uWdGQTFbfwlEbC5JC6rM2gn939TiyB9aVmVsCx68ANIeG+ZhVN8BWWqHsC72tCdlakaASsQ\n", + "4rjpPuwjEDh57qsMaX2KuyMhbEdrQlYMoY0OpkVZBIke9VUdzvn3g+XM/QLQSOhmpf+gylR1Earj\n", + "ucAjLpycAcB64L586uVqFIN1H+9E8gLSkBoHX3ljxnOurtWWd4jgNCtG/JYXuCZ4QtqSU7eDZ5Ok\n", + "K+IyHCk1ET78C7WhM8q4xmmIg3tCea/JUyhT/QuI1YZ+wPq/JxLm2dMuSuSjfjYAgyx/i/3d18A6\n", + "bejnfdZPteD/+8F6iG9F6Gf9atf3BFaSzmwkeuLhosK/5hD1VmA4Qy77lPVnW81aX8OaKAcizuCe\n", + "wOfABzbdsMftFRXWt87fSdzJCG3o23w45s8ArQ19VxnHjQAu0Ya+2Vd9lwWLPfN7begvnL57gAK6\n", + "cp+8R8pUPyDhtN85fReLkCWeZzn7ve+nMgS/UioBSVcPBD7RWr9SZP8tCCGXQqIn7tO6OKFVteD3\n", + "HMpUAxC2y+7a0P6KRy43lKlqAT8iS+mHbAdae6WSLgri7VkPEzt3LLQ7fHbVrPUnlKlaIklhwxCW\n", + "zPeB6drQOa745t1xCFthppsR2uxSNXQPxinkZ6ujv+HbHheUNCZlqhhgDZLF6/eEM6vPVOCSeAdt\n", + "7HyFE3B67kMEn6nLPny0crb4jPZoQ79W5Ps3gSBt6Ae97QPKKTu9dCoEIrwULZH0/D+AdkWO6QFE\n", + "W58TgCW+clD8nTcctLKcuf0qeyxljDMaB4tw8CEOArTW2A5ER1/0vVegS3MgVm8l3tdQHNxq3dtd\n", + "3Bk+jqgh2wv7ZIdvgXi3HIk4mIGDW306xl4NR/JojRxq/VnqmHCwCge9K+i+NcXBofNUcYf/HcFs\n", + "DXiMbTh4yK22iE8SB/egefK32HU9gIMPXYyhHg4O46CNT66pHLLTW3KnrsBWrfUOrXU2wgtzTZGJ\n", + "ZbHW+ZzlS4GmXvb5t4flzP0WYQCcV8nDKRUWX/1AIB74WJkqwI6rf3gJvPhzwbFVIb75rwJt6NPa\n", + "0F9oQ/cEruFkVH/un9WKG4YI6yQacbo2d7cA/HjEZOg7/HZBEgufD+SGmyXkE0oa0wwqjrStO7Ck\n", + "uZakvmUxcFyq6TI2m9geY0kF/k+Z6uLSGilwbM8aCJP6yt8eb8n3+XBJ1qYNfRhhrH3JVxflKbwV\n", + "/DEI74WN3dZ3JWEYlZyx9leH5cwdA6wG3q7k4bgFbeh0IBE4BxiTFiBx9dFZUNspZ/VsqFlbGdCG\n", + "/p1Jfbbx1p+wuzt0f9Npr2uaBxf4HkloauS7kUWFsvhfQjvRZEVpY5qO/4uw2+gOLLaVj+FXww4n\n", + "UuYmQnQ9FJioTNW45GaajYTRcTT6A26x6ZOKTWqlsXS+BXS1HMsVDm8Fv9t2MKXUJcBdwGOlHONw\n", + "2vp5ObazFf9GBOi9VSGCx11YtuMkoPm8BwgeFsBW5/1VsSD1XwvppzldC5aOgknfIC41KIvmwYbl\n", + "0JyGMH76bkw6AL6aJhNSPoqNaTnQwPJf+Bs9gCXpcFoD22tDq2NOI5PKWTMR2pOJVoUxF4iSdUJm\n", + "HWjonH9WaFLbBTS2OKAKwWIl/T/gv5Yy5zaUUv2cZaUn59rwVvDvAZo5/d8M0foLQSnVAeEKuVpr\n", + "fazofhtaa4fTNs/LsZ11UKa6DBH811ckna2vYMUuX3WmLrnjH2RPQgA/DoZfkyDZ14XK/35IfRtG\n", + "bC38nWc0D/jc3GOPyVmuFR+T5fSfhZ/NPcpUIUhtiuWp8PatkfwZkisrTyimfDyHcC7913Vr6bJW\n", + "TW8MEQedTFkFk5o2dDZiEWlVwpDGIzxR13pyHVrrec6y0pNzbXgr+FcA5yilWiqlQhBa2O+dD1BK\n", + "NUeYIm/VWm910UY13IDFgf8FcJM29K7KHk95YWmW12TXIfPHZzgx2cFlpRT7qIabkEiZxaMgKRkG\n", + "/yp/l4z0kOZhHtBImcoVQ5y/x1QRxVk6AVu1odPXaT1zzoW8c+YkJ1wpH9ZkdBtwpTKVi1WQNanl\n", + "BYspK3I/JUy0W4FYV4OxqDseBV4ueWXhH3jF1aO1zlFKPYiE7AUCY7TWG5RS91j7PwJrzSLTAAAg\n", + "AElEQVSeAWoDHyhZ0WRrrbt6N+y/F5SpIoDvgOe1of1RMahCoQ2dqUx1HVKRa6Iy1U2+KFfoKSqa\n", + "o9/fsARqucevDZ2rTPUlovU/WcFjmg18qkwV4cus1iLoDiy2/znYn33A7ElaD3J1sDb0MYvJ82dl\n", + "qnXa0Pk2Ha3XzVSqPZD0EJkne9HguhROZD7nYlIrqxrXj8iqYDjwQfkuy3NUJ3BVcVj2v68Rx+ed\n", + "fyW7flmwbJ+TrH8H+5sd0xklcPT/7XMJlKk6AD8ArXDEJ5QnL8CLvn8B3tCG/sFP7X8F/KgNPVap\n", + "9kkMPPkmISqUH85dX9q1KVPdglSSu0gb+riL/d8AX2tDT3ax72EkS7jE6CplqguQybGNFQjh2XVV\n", + "19w9O9BeqaREpZIHKzWv5SI2Bp6iE38xZ647sAT9ICAX+MbibqkQ2Bz973SFb9vKd6Mhrrlwpf9t\n", + "oQ29BkhjQb1HCsIVJ5YUruhr2MVZ/IXuwOL8UMyQAeew79FmZV2bRScxCxhfQn3j3ZQcpl5m/V1t\n", + "6N8RfqtH3L4SL1Et+KsYbE10FgwcFkvfrPNpc+PHhMQ76F/ZY/MHLBPPP4BTwLdW9TC/ww7nO+8Q\n", + "PHI5ZAXK99W5BACMp17AQzA6jtrb4O4u0HANHuYFlAil2icplZis1OB58jdf4E4HrvA0ysWtPiVM\n", + "NRrYkh+KWftPOGb7Xcu8tkcQKmdXJjCvBL+Fp4EHSw8h9R2qBX8Vg62JnqgBQ6+FiZPh6+O0PJs1\n", + "USv64WbgODCtTS11nb3iSVQqub1SPtcybY7+S/+E+EPwTjf5vjqXAICvaH20EUGn4VhrWDoSbr8U\n", + "erwOKsKribFQ4pP6uuhKYjPyu3T0yVUURndgiThtrVDM3GA45ux3LTnnwVJQBiElLhOK7C5N8P8J\n", + "NC/LeWtRrnyKmJT8jmrBX8Vga6I1s2D5aOhtxe+c7ZqoxdNyW8gRAk/cwIQpwQycBH1nwcAe8Jav\n", + "hX8qvD1CtDH+Oxte6QU3R/JndS4BaEPv5kj4Cc6ZAShYfQd8shTOmwLDf2pv8euUE5a23Xwh3D4A\n", + "apzA1rYtU6a/ont6AEvkoxWKOWEWHHVWxsssbbkXuAkYp0zlHKJZouC3zJn7gOZujPFF4HplqnZu\n", + "HOsVqgV/FYOtiQI0PVHw/d9BE9WGzun3HtkJRwm74hbICJHv/WF7X6f1zMUwKgmS/+8IvwZvY+fU\n", + "20j5Ozt2C+G4HkfnUQXRNcdaw2dtt5F7ZhawSpnqhvI1bGnbqT3gcFu44xKJgy/Qtv1l53eK6Cl/\n", + "zoM29AJEQE91MkuWpvGDm+YebehjwMukBX1aginMZ6gW/FUMzpqoDX9mtTo7kv1lVvEE0XmEfjoN\n", + "uu2GgxEF3/tjxbNO65kztU6cpHW/fR3onNWQbr6KYf/L47x0B632KCL7/5wfg5+3bKQec+o2hI/r\n", + "FWWqT5Wpojxr2NK2dSDMeA+2JMGdvaHefjtwYT5wnjJVfV9dimVm6QwsA5/kPLyN1JP4wPJH7EUy\n", + "dANLOH4b7tn54bU2W1EhXWjxRGkcQN6jIhjx/MUwd7Zu8ZCUCLMGwbxEmOWvEoGuShIOhy2VWZLQ\n", + "k9J/vt5w8E8czKjs37+iNjfYJb/GwX0l3KtIHHyCg2046OFZn8O3FPp5L+58iKfUQRy0tdqeioPb\n", + "ffi7XoiDdT5+ViJwsMa+Pzg4gIMmLq/3slYbubZFqqt7XPz4hGTO/0IzvKuGPKdXILHE5788srNa\n", + "46+CcNZE/ZnVajuSN9SDfw2ENQ0rP6Sxolc8RfAe0EaZ6vIK6KtS4Sa7ZIkUDtrQGdrQw4H/AN8p\n", + "UzmUqcpMCHWpbS88fQfB+j/AXGWqLvjezu9k3/cNrCSz6wHTKuWYShFzT/49Tv3fuYR1aOqe9h4V\n", + "yrohcLoW1N7u9L3bZHtuoVrw/41hO5JrnYbwbLjiZuh8N+zqS5wyVZ3KGJOz7b2ieXysyI3/AP9z\n", + "R4j9tWE5WQNyINg25RcLaZwNxFl0IS6hDT0VuACpDLZAtWw1rCz7tNbrZmo9M1HrSf3k77qZ2tDj\n", + "kAIzM5Horst9SGNQKGPXV9CG3oowDk8CDlHMzm/d46NxUMfWZcoKG7WI7b74sUjEkXtke+7iLH+4\n", + "q1EabEdy4wx4/hcw58IvreDmnkQA25WpZgNjgdkVVR0JRPhTefTd04CHESbZjytpDD6DNYE1QYol\n", + "FWwjancjvDVE7YEFT8Gvz1hnFGiW2tDZylQTEa3/2ZL60Ibeq0yVwK/1PiCt20fwtZOte0SsUu1x\n", + "x36uDf29MtVgRJAeBnoh/EHeogfwsg/aKQZt6B+UqbqqbO5rtZiWg5UaadN/wCBxZB+LhSPnOJ1V\n", + "mvae+jaMiC1UwN5zsr0yUU3Z8DeGK9qC4bBtCYxMcbAICV27E9FkxgOfaUNvqqThVhiUqS5EokvO\n", + "1YY+UdbxlYkSBXvBFgMcBHYU2iZ1uod9Uy7iRDPIDXFqMSlZ65k2wTzKVF0RcsBzy8ocVyoxGWYN\n", + "JOwo5IRCdrjLNt24ps6IwF+oDe32eSW0VR/YAtSxS3/6CjbXU46iydIHiT/3NAHLR8u+EbB1Muen\n", + "pbGmc/EzS78frgrYlzZxVhdbr4bHaK9UUnN4KBLCMiBzF7xT1KxiRboMRdgK/wQ+AyZZ1bXOSihT\n", + "jQX2akP7hKzMi3GUT7AXbKmuCPAKbPxFNcvC0S1W1Mom4FZt6GUljLEx0Ic1zV+nYXQTau2Ar76H\n", + "Hf2sIwb/qvWkfq7OLfG6r631PB3TnmRhu+380mJreXmClKmuQuo9+9Rv46w0PQ007QyPDIRPp8Hg\n", + "FDmmP0Er5zI0uqx77C3KIzurTT1/c7hjVtGGXg88qkz1JFI3+U6kgMR0ZBKY62ttqgrgKWCNMtXH\n", + "2tA7/NVJOQX7b8AEShHsZaEQu2QpmqU2tFamGo9M+susiaAl0Mdpqwss4ERgOks/gX0XQJ6Teb7B\n", + "3hbKVKHa0KdxA0q1T0Ld+A/O+V7RPisWOsfyS4zbJqMi8It93w6M2FYbgo5B2yPQ5jC0cKJwq0dO\n", + "Bix+pqx7XBmoFvzVcBuWnX86MF2Zqh5Cs/AaUFuZahwwTht6e2lt/FWgDb1HmeptpC5quatSuSnY\n", + "D1FYsC8CvqRAsPuFtTSeFJqRoqKAdFCpLo6xBP1SYIr1m/dGKNh/BRYAbwIp2tB5sooYXXgVoYb9\n", + "SfeUvcikcbM29LqyR9ZsJPqTODYPE/t4u6kQdlEcs5o+hOe+nx6UWEyl/IiC0DOBcPltcOknsPcE\n", + "bA+DWXuE2vRyrGpeXlJl+wvVgr8a5YJVMPpt4G1lqk7IKmCpMlUKsgqY4kdedZ/DFTc/Dl4DNilT\n", + "9dCGdqk1linY82gWnElueDpZwemcPBnGr5lN+ZkKEOyloQRa6th2NVTAxifZh2jyva0tHckcPwD0\n", + "A7a5sve7XEXoXe9w4fFZyPMxV5nqeeCd0leIVnbv4n+DDoBlD8JN18CQDZ2VqULcXeFYCVVdkInL\n", + "p0iH0yG5MGEqDOkAuSsgMwqeURCgYQRk7/JxCKkvUW3jr4bPYJW2uxJ5yS9GKq99BvxWlSmlS+Pm\n", + "T3HQAMlr+Cfua+w7gB0xU2lx2Xqe+CynoAJTVeH8T1QqeRYMzAqE5TGwoDnMbwE/tSAnN4TNSAbt\n", + "fGCBNvRuZap7gX7a0DeVt09lqjjEUZwGDNWG3ufyONtJ7Iyg03Bbk4O0OLYKuNEdpUKZqiMwURu6\n", + "bXnHXBKcn5lbomFCGtT/D6x7HxpaI0uC5JnaO+e0O6i28VejUmFpYlMRHpPGSBjgx0Cw5Sz9XBva\n", + "lUWhUmHba6e2g3UNYEct2FGLuK31mIKYNRRyHSvwwBST6FDJn0Hst23hre7QJB1iThCXmctrVlW1\n", + "vUjd6r0VXYHMzuG46UZIjYY+O+GelRA0jWU/pOteLk6ZjJQIrFneSCdt6K3KVL0RCuLflanu1Yb+\n", + "//buPMyK6szj+PcnokhE0YggCi7gijEuUXGl4xJw301EAWPGMeNETSaJMcPjU1RmsjHJRMk2LlER\n", + "jIrGGBcgooJGH3ELIAioSBQ3XACNuKK888c5DZe2+/btvkvd7no/z9MPd6mu+xbd/Z6qU+e85/bP\n", + "btnMkMZPvvU8N/T+Nv+54lTgngF9dflOr3FOK6unHUAV+vch3BvbXeJouOBz73AAsOnX5sFHBRm1\n", + "ngsreuJ3VRHP5v5HqX4B7Eu4CpitVE8QrgJuL/VmX7U1JsG5W8KqLnDgSzB8Loxdydxp53Mo4Qbh\n", + "eODctixy37jfQ5aESXKvbAKv9IBPt2QTwhoEW8evPkr1NmsbgsKvwteWVerKqXEOx58mha6JRleG\n", + "BcY/wxJbplTTCbNVr2vv58YS3IlSTQUmKtUxwHcssZVrtmnpxvNHCyYr1eRur3HrspOZcM14Ntgq\n", + "fte5MGB3iSbJvyo3dhs1Dow4SpoKDP31lHXfr+fCit7V42omVjM8kdAI7EOYqHMt8HiWXUGN3R5N\n", + "Xy+8VFeq24DHLLGSJwKVst+47/WAXqxtCBq/+jZ53p1Q4relhqHx6qHVhNNc99ZwNnx/Bt3HvmrL\n", + "0+a+J1bkPN8SO7yU429NLPA2jtAteGZLw0WbGiZNPeQQhl6zF0ybADusCK838//6DHBaXFWsaorN\n", + "h6lFl56P43cdhlL1A0YS5gd8TGgAJlpiS2sdSyl/uLF/eiYwyBJ7vVL7bQul6g5sRfHGoS/wHkUa\n", + "hvjvG1uN2ezSfmx48Ubs3P09urGQC1jJ7YvgkYuaG3IYl8Z8BfiiJfZyW+MvclynEuok/Qb46aAx\n", + "fKXpjfbC/6/TpRmTYMhVe4ers0FvxtfhgUlmDXGfnyfMOdnMEvu0UrG2pHE+DD3ZeUUPer69lFEL\n", + "Pq7O2sFNeeJ3HU4cLngw4SrgJOAhQiNwVy37vUucyPZLYGNL7LxK7reS4v/n52n96mFTVm7wKW/v\n", + "1Y1/bg1/nlDSTFuluhJYZImNrXDc2wDXdXmPrU7+A90nLWe7xvea3hAv8QrtaOC7lbo6KVW8ersb\n", + "mGOJXVKTz/TE7zoypdoYOIXQCOxGuIF6rSU2J9PAIqXajDCL9XBLbG7W8ZRDqTbkN0MfYKNL92eT\n", + "V+Dp0wj3sKHYTFsd0etiBr13KeOOfTLU1m/fjNoWYlpv+4eY/+5e7PzLe2DEnLURFSb1Eq/QfgR0\n", + "scRGVyK2Nh5HL2AW4Z7QlNa2L/vzPPF3LM2NHc96mF+9UKoBwKj4tZxwFfDHOH8gy7guAI4Dhtbz\n", + "ENVSNDtsEmjpjD/MqB18ORdNG8iNd8LrexBWsmq+a6g9TpdmjO7NkOGnwJV3wkFxDFhhNw60fiWl\n", + "VNOAyy2xuyoRV1sp1aGEe1j7WGKvVPWzskj8koYRZu91Aa42s583s8044CjgfeBsM5vVzDa5SvzF\n", + "xo578l8rXjp/mXAVcCxwL6ER+GstK4YWxNMVmAv8hyUd++dUar2etdvHhuKw0dDlY5jWOCG2bUXY\n", + "imnsxlm1HnQtmOLVljHxceLWcmCgJfZmJeJqD6UaTeiSOqyav6vtyZ1l1eOX1IVwQ2YY4dL8DGnd\n", + "hYIVlvIbaGY7Av8K/L6cz+wsGseOP7Y1TBkIn6yX/SIo9cgSW22J3WeJnQVsS6gRPxpYolRja7Ew\n", + "dZN4VgHfI9Tsr1S9+Ey0fQnCOKP2qbNgh/sKXq/cIiGNC/EUJv12LMSzK/BGlkk/+ilh2OyYjOP4\n", + "jHLH8e8HLDILRawk3URYj3NBwTbHE8ZAY2aPSuopqbdZaSMjOqvGMd7LN4K0Ac45Ac6cCx/NZ4uM\n", + "Q6tbsRrolcCVSrULYUTQfUq1hHAVcLMl9naRXVTK3YSa/ecCv6vB51VN22rJxPVy39oVrny84PXK\n", + "LRJSODGqjBvig6mDcgmW2GqlGkFYnP4BS2xa1jE1KncFrq0JS441ejm+1to2xVakz4XGCTTDFsHM\n", + "q2H6eNjgU3joDHZXqllK9W2l2jLrOOuVJbYwjproT1gk5HDgBaX6o1IdWWTh60p8tgHfJUxE6lmt\n", + "z6k/L40LffqExdKBaiwSUoGlR6s2Y7et4tDfs4DxcTZ7XSj3jL/UGwRN+5+a/T5JYwqezjCzGe2I\n", + "qUOIl7QDGvv4d3kL3riP5wc8yLcXjOYDwk3NMUr1IOGK6a4sinnVu9h3OhmYHMdun0FYbalXQcXQ\n", + "RcX20c7PnaNUdxC6nb5f6f3Xo1JLOdeBwYR5AXXBEpuuVFewsstUdRn6Gqs37VbOiChJDYRiee1W\n", + "1s1dSYOBMWY2LD7/IbC68AavpP8jJPGb4vOFwJCmXT15u7kLJY1M6EEY3jgS2IMwSmA8YQZphx5R\n", + "Um1KtQehK+hMwhDMa4FbCksDVOAz+gDzgP0tsecrtV/XfvEK7GWgZxY3/1uiDXY7lhHLJ7H4mxsx\n", + "Y0x8tTIjomo+qkfS+sRxzYQZgY8BZ5jZgoJtjga+ZWZHx4biMjMbXIng80SptiUshjESWA1cD0yo\n", + "x6Jn9SRWDD2aMCroUOB2Qq2ZByvReMaRG3taYqeVuy9XPqX6CjDaEhuSdSyFpKOmsvG1Qzlvb7ht\n", + "IvzjsPhO+SOiaj6qx8w+Ab4F/BWYD9xsZgsknSfpvLjNZGCxpEXAFcD55XxmXlliL1pi/w3sTEhi\n", + "/QlFz+5VqpGx2qNrwhL72BK73RI7AdiFcIb+W2CRUl2qVP3L/Ij/BfZTqoPLjdVVRN3076+rRzdW\n", + "9glJX4VLEVRuRFRb+ASuDizWTjmOcD/gIOAvhK6gBzrhUogVE8sa7ENoQL9KmGV5HXBbW6pvFuxv\n", + "OKFe//7+/54tpZoCXNF8uefstHWyXNv27TN3cyv2Nw8nNAI9gQmE+vfPZhpYnYuN5wmERmA/Qt35\n", + "a4FHS+0KipPMHiGsLDWxWrG64uLPYRmwaxbF/opp62S5tu3bE79jzcpDowgNwWLC/YCbLbEVmQZW\n", + "52KhsBGERuBTwlXABEvs1RK+9yDgJmBnS+z9asbpmhfndkyxxLbPOpbmhOTfv+Ijojzxu3XEmaVf\n", + "ITQCQwn3Yq4nlDtYlWVs9Sx2BR1IaABOIay4dS1wZ7EhtUo1CZhrif1XTQJ161CqrwNHWmLDs46l\n", + "ljzxuxbFypKnExqBHQiVL8fXS+XLehVvmp9MaAS+ANxIuBKYZYlZOIvrdyH06EbXFeKkmV9i2t6P\n", + "saK3Kl290hWnVFcA8yyxik4oq3ee+F1JlGonwrDQEcAKwlXADaUuMJJXSrU9oeE8G3iH5z83kz+f\n", + "cCQrb1jbtbDRiNV84b31eOy2+EJlq1e6linVU8A3LLHHW924E/HE79ok3gwbQkhmJwAPExqBO+pl\n", + "Pdx6tOb/7dleE+n/cV/+cRg8fj4sPiJssN1B8OFvYeme8TsqV73SNS9OdnwN2LzWC9dnrT250xdb\n", + "z7E49HA6MD0ugnISsYKqUt1CGBo602cJr6vx/006/Tk2vLovu90Cmy1eu8Fr+8L6hWVZshmrnTP7\n", + "AbPzlvTbyxO/AyCWMpgATIiTms4i9GVLqRpnCb+YYYh16N0P+WgTmPWNdV/+qAd81LvghcpVr3Qt\n", + "GkxdTtyqT+VW53SdkCW2xBL7CWGm6wjCeq1PKtV0pTo7Xh24wmqVa/zLKjiy8HnFq1e6Zh1AHZRi\n", + "7ii8j9+VRKk2JKyANYpQ8+YOQlfQDEvs0yxjy1IzY7NnQv/BdV69slOJw2/fBPYoZc5FZ+M3d11N\n", + "xHUCziA0Ar0IXUTjLbFnMg3M5ZJS7QjcZ4mVW3epQ/LE72pOqb5AaADOBJYQrgJussSWZxqYy424\n", + "ytWxlthXs44lC574XWaUan1C5/YowhrM9xKGhk7xWcKumpTqd8Bzltivso4lC574XV2Ii2GcRmgE\n", + "diTMdh1PGG5XH79wrtNQqr8D51tiuby564nf1R2lGkiYJTwSeJfQANxgib2WaWCuU4glNd4gTNzK\n", + "5dKknvhd3YqzXQ8hXAWcRBhzfT3wl/bUwHcOQKmGAD+zxA7IOpaseOJ3HUI8SzuR0Ah8CbiV0Ag8\n", + "7F1Bri2U6hKgtyX2naxjyYonftfhxBr4ZxIagQ0IDcD1ltgLWcblOgaluh34oyU2KetYsuKJ33VY\n", + "cRLOlwj3Ar4GPE1oBG61xP6ZZWyuPsXfmaXAvpbYkqzjyYonftcpKNUGwDGEq4AG4C5CI3BfnmcJ\n", + "u3XFMtkPAdvkuYvQE7/rdJSqF+EKYBTQB5hI6Aqan2lgLnNxkftTLLFTso4lS574XaemVIMIXUFn\n", + "Aa8ShobeaIktyzQwlwmlGgcsscR+kXUsWfLE73JBqboARxCuAo4B7ic0ApO9Hnvnt2a5y39/+ECm\n", + "7TifZz/6UZ4L4dU88UvaHLgZ2BZ4ATjdzN5usk0/Qv/sloABV5rZuGb25YnftZlSbcLaWcK7ADcR\n", + "ft+ezHO/b2cVkv4Bl7P+uIFcvAWMfQs+uTDXy1tmkfjHAm+Z2VhJPwA2M7NLmmzTB+hjZrMlbQw8\n", + "CZxoZgvKDd65Qkq1A2H9gJHAh4SrgIl5LNXbWUlHTYUpQ+n/EAz9DlzVuLxufpe3bE/uLHchluMJ\n", + "f1zEf09suoGZLTWz2fHxSmABYWEP5yrKEltsiaXAQOCbwE7A00r1V6UarlTds43Qla9HNwDe6Qf3\n", + "/7jgdV/esi3KPeNfYWabxccCljc+b2H77YAHgEGxESh8z8/4XcXFZH8CoStof+A2wknK37wrqONZ\n", + "c8b/GX7G35bvaXXNXUnTCMPomhpd+MTMTFKLf0ixm+dW4KKmSb9gmzEFT2eY2YzW4nOuGEvsfUJ1\n", + "0BuVqi9hlvDvgO5xLeHrLbHFxfbh6slL4+DcAXDVwLWv5Wt5S0kNhPkt7d9HmWf8C4EGM1sqaStg\n", + "upnt0sx2XQmTcKaY2WUt7MvP+F1NxBmfexOuAr4GPEO4CrjFEnsny9hc65pZ7jLXy1tmdXN3mZn9\n", + "XNIlQM9mbu6K8Ee1zKzlQkqe+F0W4izhowiNwOHAZMLv6zSfJew6gqyGc04C+lMwnFNSX+AqMztG\n", + "0sHAg8BThOGcAD80s6nlBu9cJSnV51k7S3gb1s4SnpdpYM4V4RO4nKsQpdqVMCx0BPA6a2cJv5lp\n", + "YM414YnfuQqLs4QPIzQCxxFGpY0H7s7rik+uvnjid66KlKoHcCqhK2gQYdb69cDjPjTUZcUTv3M1\n", + "EksCn0VoBFaxdpbwy1BQT4Ye3eDdD+GlcXkeeeKqxxO/czUWh4YeSOgKOg14knmbzOaOk07i4+sG\n", + "rN3y3FzXk3HV44nfuQwp1UbA8Szp+Wt60YuFJ8KcUfDioWDrkefZpa56sqjV45yLLLEPLLGbuebI\n", + "+fx2AbyxOwz5EahxOoDXk3H1wRO/cxX37oes7AOPfBfG3w+ru8bXV36QaVjORZ74nau4l8aFPv1C\n", + "+aon4+qb9/E7VwVeT8bVit/cdc65nPGbu84551rlid8553LGE79zzuWMJ37nnMsZT/zOOZcznvid\n", + "cy5nPPE751zOeOJ3zrmc8cTvnHM544nfOedyxhO/c87ljCd+55zLmXYnfkmbS5om6VlJ90jqWWTb\n", + "LpJmSbqzvZ/nnHOuMso5478EmGZmOwH3xectuQiYD9RHKdAMSGrIOoZq6czHBn58HV1nP772KCfx\n", + "Hw+Mj4/HAyc2t5GkbYCjgauBPJddbsg6gCpqyDqAKmvIOoAqa8g6gCpryDqAelNO4u9tZq/Hx68D\n", + "vVvY7lfA94HVZXyWc865Clm/2JuSpgF9mnlrdOETMzNJn+nGkXQs8IaZzfLLLeecqw/tXoFL0kKg\n", + "wcyWStoKmG5muzTZ5ifACOAToBuwCfAnMxvZzP5y2//vnHPlqNnSi5LGAsvM7OeSLgF6mlmLN3gl\n", + "DQG+Z2bHtesDnXPOVUQ5ffw/A46U9CxwWHyOpL6S7m7he/ys3jnnMlY3i60755yrjcxm7pYyAUxS\n", + "P0nTJT0taZ6kC7OItVSShklaKOk5ST9oYZtx8f05kvaqdYzlaO34JJ0Zj+spSQ9L2iOLONurlJ9f\n", + "3G5fSZ9IOrmW8ZWrxN/PhjjZcp6kGTUOsSwl/H5uIWmqpNnx+M7OIMx2kXSNpNclzS2yTem5xcwy\n", + "+QLGAhfHxz8AftbMNn2APePjjYFngF2zirmV4+kCLAK2A7oCs5vGSpjPMDk+3h+YmXXcFT6+A4BN\n", + "4+Nhne34Cra7H7gLOCXruCv88+sJPA1sE59vkXXcFT6+McBPG48NWAasn3XsJR7fIcBewNwW3m9T\n", + "bsmyVk+rE8DMbKmZzY6PVwILgL41i7Bt9gMWmdkLZrYKuAk4ock2a47ZzB4Fekpqaf5DvWn1+Mzs\n", + "ETN7Jz59FNimxjGWo5SfH8AFwK3Am7UMrgJKOb7hhFF3LwOY2Vs1jrEcpRzfa4SRhcR/l5nZJzWM\n", + "sd3M7G/AiiKbtCm3ZJn4S50ABoCk7Qgt3qPVDavdtgZeKnj+cnyttW06SnIs5fgKfQOYXNWIKqvV\n", + "45O0NSGZ/D6+1JFukJXy89sR2Dx2rz4haUTNoitfKcd3FTBI0qvAHEIpmc6iTbml6ASucpU7Aaxg\n", + "PxsTzrIuimf+9ajUJNB0vG1HSR4lxynpy8A5wEHVC6fiSjm+y4BL4u+r6FglSEo5vq7A3sDhQHfg\n", + "EUkzzey5qkZWGaUc338Cs82sQdIAYJqkL5rZu1WOrVZKzi1VTfxmdmRL78UbFX1s7QSwN1rYrivw\n", + "J2Cimd1epVAr4RWgX8HzfoRWt9g228TXOoJSjo94Q/cqYJiZFbs0rTelHN8+wE0h57MFcJSkVWZ2\n", + "R21CLEspx/cS8JaZfQB8IOlB4ItAR0j8pRzfgcCPAczseUn/AHYGnqhJhNXVptySZVfPHcCo+HgU\n", + "8JmkHs+q/gDMN7PLahhbezwB7ChpO0kbAF8lHGOhO4CRAJIGA28XdHfVu1aPT1J/4DbgLDNblEGM\n", + "5Wj1+MxsBzPb3sy2J1yB/lsHSfpQ2u/nX4CDYxn17oSbhPNrHGd7lXJ8C4EjAEBzXtwAAAGTSURB\n", + "VGL/987A4ppGWT1tyy0Z3qXeHLgXeBa4hzDzF8LN27vj44MJxd1mA7Pi17Cs77AXOaajCCOPFgE/\n", + "jK+dB5xXsM1v4vtzgL2zjrmSx0eowLqs4Gf1WNYxV/rnV7DttcDJWcdc6eMDvkcY2TMXuDDrmCt5\n", + "fISrtDvj395cYHjWMbfh2G4EXgU+JlyZnVNObvEJXM45lzO+9KJzzuWMJ37nnMsZT/zOOZcznvid\n", + "cy5nPPE751zOeOJ3zrmc8cTvnHM544nfOedyxhO/cy2QlEq6qOD5j+t9MSDnSuEzd51rgaRtgdvM\n", + "bB9J6xHKi+xrHav4nHOfUdXqnM51ZGb2oqRlkvYklBf/uyd91xl44neuuKuBrxMWCrom41icqwjv\n", + "6nGuiLgexDzCmq47mv/BuE7Az/idK8LMVkm6H1jhSd91Fp74nSsi3tQdDJyadSzOVYoP53SuBZJ2\n", + "Iyw7eK+ZPZ91PM5VivfxO+dczvgZv3PO5YwnfuecyxlP/M45lzOe+J1zLmc88TvnXM544nfOuZz5\n", + "f95IrH54gZWFAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['WNN']\n", + "modelWNN = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelWNN)\n", + "inv_WNN = generateInvTest(environment, modelWNN)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -456,38 +4585,997 @@ "####Optimization Inverse Model (BFGS and CMAES)\n", "Another possibility to perform inverse inference is to use an optimization algorithm to minimize the error $e(m) = ||f(m) - s_g||^2$ where $s_g$ is the goal, $f$ is the forward model, and $m$ is the motor command to be infered.\n", "\n", - "This is how our [scipy.optimize based](https://github.com/flowersteam/explauto/blob/master/explauto/sensorimotor_model/inverse/sciopt.py#L8) inverse models do. \n", + "This is how our [scipy.optimize based](https://github.com/flowersteam/explauto/blob/master/explauto/sensorimotor_model/inverse/sciopt.py#L8) inverse models do. They take a 'maxfun' ([BFGS](https://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm)) or 'maxiter' ([COBYLA](https://en.wikipedia.org/wiki/COBYLA)) parameter that limits the number of error function (and so forward model) evaluation. These two algorithms are efficient to find local minima bacause they work with second order derivates.\n", "\n", - "They take a 'maxfun' ([BFGS](https://en.wikipedia.org/wiki/Broyden%E2%80%93Fletcher%E2%80%93Goldfarb%E2%80%93Shanno_algorithm)) or 'maxiter' ([COBYLA](https://en.wikipedia.org/wiki/COBYLA)) parameter that limits the number of error function (and so forward model) evaluation.\n", - "\n", - "The Covariance Matrix Adaptation -Evolutuionary Strategy optimizes that error function by making fewer assumptions on the regularity of the forward model to perform the search. It is based on a random exploration (with a computed covariance) around a current point of interest, and adapts this point and recompute the covariance matrix at each iteration, with memory of the taken path.\n", + "The Covariance Matrix Adaptation -Evolutuionary Strategy (**CMAES**) optimizes that error function by making fewer assumptions on the regularity of the forward model to perform the search. It is based on a random exploration (with a computed covariance) around a current point of interest, and adapts this point and recompute the covariance matrix at each iteration, with memory of the taken path.\n", "The initial point is set as the motor part $m$ of the nearest neighbor $s$ of the goal $s_g$, and the initial covariance matrix is identity times an exploration $\\sigma$ (parameter). This inverse model also takes a 'maxfevals' parameter that limits the number of forward model evaluations.\n", + "\n", "The method should be applied, if BFGS fails due to a rugged search landscape (e.g. discontinuities, sharp bends or ridges, noise, local optima, outliers). If second order derivative based methods are successful, they are usually faster than the CMA-ES: on purely convex-quadratic functions, BFGS is typically faster by a factor of about ten (in terms of number of objective function evaluations needed to reach a target function value, assuming that gradients are not available). \n", "\n", "See [Hansen's website](https://www.lri.fr/~hansen/cmaesintro.html) and this [tutorial](https://www.lri.fr/~hansen/cmatutorial.pdf) on CMA-ES." ] }, { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Inverse models comparisons\n", - "\n", - "#### Distance between $s_p$ and $s$ comparison\n", - "\n", - "#### Time processing comparison" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": 83, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXm4HFWZ/z9vrmxhx6hAZJMEgcgmA6KAXoUfhqgw4wzD\n", + "AIKKQtSBhHEBdFTiLuqjEhnZBJQwgIA4ggPBBW5kZBEciKxjErZsoAmgQXby/v44p5O6na7u6qW6\n", + "qru/n+e5z+1auupUddV5z7sec3eEEEKICmOKboAQQohyIcEghBBiFBIMQgghRiHBIIQQYhQSDEII\n", + "IUYhwSCEEGIUEgx9jJmtMLNtu3i+GWY2q1vn62XM7Mtm9mczW5LjOdYzs2vM7Ckz+3Ge5zWzT5vZ\n", + "eZ08Zqcxsw+Y2U0FnXtbM1tpZmPi8rVmdnQXztvSO9kTgsHMHjazAwo69w5mdkV8mZ4ys7lm9m+V\n", + "H7jMuPuG7v5wN0/Z6hcHSaiY2dbAx4Ed3X3LHE/1T8Crgc3c/fBOndfMhs1sYXKdu3/N3Y9rr7mD\n", + "g7tPcfeGz3vs+97Rzqla+VLpO7eI00an0ypmtj1wG/AI8AZ33wQ4DNgT2LDb7cmKmb2iqFMXdN5e\n", + "Y2tgubsvz/k82wB/dPeVXT5v32NmQ106lVPEe+Xupf8DHgLeET9/APgf4JvAE8CDwOS47XDg9qrv\n", + "/hvwsxbPezFwTYN9DgHuBZ4EbiSMxirbHgY+CfwBWAGcD7wGuA74C/BLYJO477bASuA4YDGwBPhE\n", + "4lh7A7fE8ywBvgesldi+EvgYMA9YkFj3uvh5SmznX4FFVcc+Ln5vOfAzYIuq404F/hjPfWade3Ea\n", + "cAVwWTzP74FdE9u3BH4C/Cn+bifG9ZOB54EX4n26ExgG7k5895fA7xLLNwGH1Dtu3GbAqcB8YBnw\n", + "Y2DTqnt+DEH4/xn4TMq1rR3bdUJcHgJ+C3w2Zf+NgYtimx4G/j225UDgGeDleK0X1PjuOODn8X4v\n", + "B34DWMp5doz3ZjnwAHBYXP+Fqnt6fK3zAvsAN8dz3QW8LXHszYALCc/jE8BVwFjg2cRx/gpsAcwA\n", + "ZsXvXQf8a1U75wJ/X6/NKdf3QeC+eJ4FwPGJbcOEZ/njwOOE9+IDie2vBK4mvGu3AV8Cbko5T+VZ\n", + "SHv/ZgBXArPi8Y6Nv/H5cd9F8fhj4v5jgG/FZ2oB8K/x+JXtI8CHqt7BynXeC+wRz/Vy/N1WAJ/M\n", + "8JttB8yJx/kFoZ+Y1XTf10qH2e0/1hQMLwAfIrxoHwEWx21j4w2ZkPju7cA/t3jepcD762zfAXga\n", + "OIDQUXyK0MG+ItHum4FXETqvx4H/BXYD1gF+DXy+6sH8T2A94A2ETuWAuP2NBOEwhjASvA+YnmjL\n", + "SuB6YBNgncS61yWuZV9f3WntET+/Iz68uxM6v5nAnKrjXg1sBGwV2/TOlPsxI/4274334xOEjnoo\n", + "tvv3wGeBV8QHeAFwUPzuacBFiWOtR+iANgPWivduIbB+3PYMsGmG406Pv8GW8ThnA5dU3fNz4u+x\n", + "K/AcCeFedX2TCB3kjoSO/mbSO+yLgJ/G9m4D/B9wbNz2NmBhnefqa8BZ8b4NVX63GvutH+/J++N9\n", + "2D3+ljul3NNR5wXGE4RlZWB1YFx+ZVz+b+DS+Ly8Atg/rf3JcwFHA/+T2LYzoRNbq1Gba1zjFGC7\n", + "+PmtwN9Y/ewOAy8Snrsh4OC4feO4/bL4t1787RYBv0k5T+VZSHv/ZhCe7cpgZN34+54V938VQfgc\n", + "H7d/BLg/3uNNCYPGl1ktGG5MPA+HxbbtGZe3B7au7vsy/ma3EATSWsD+hP7wolrXXLfva6XD7PYf\n", + "awqGeYltY+MP+uq4PAv4XPw8Md6YdVs87wvEDiZl++eAyxLLFn/gtybafURi+5XAfySWTwB+WvVg\n", + "7pDYfjrwg5RznwRclVheCQxX7ZMUDI8QRo0bVe1zPvD1xPL68bq3ThzjLYntPwZOSWnTDODmqvux\n", + "BNgPeBPwSNX+n2b1yHUGVSMbwkj5HwgjpOsJL/k7gbcDc+M+jY57f9WLtUW8vjGJe75lYvttwOF1\n", + "fvOPEzr55cD2KfsMEUbrSe3xeODG+HmY+oLhC8B/pR0/sd/hVHV0BCFXGWyMuqfV5wVOoarTAGYT\n", + "NKgtCB3ZxjXOu0b7Ga0xbEgYMG0Vl79CfI4btTnDO/lTYFqiHc8QO9u47nHCAGoo/s7J9+krNNYY\n", + "ar5/8fpGEtteQxhErJtYdwRwQ/x8A6O1m//HaI0hKRiuJ6HlVrWrWjDU+822JgjK9RLb/pMWNIZe\n", + "8TFU81jlg7s/Ez9uEP9fQviBAI4kdLzPVR/AzPaPUTsrzOzulPMsJ4w009gCeDTRFieMhsYn9nk8\n", + "8fnZquXnEu2ukHTqPVo5f3SC/9zMlprZXwgP+SvrfLeafySMvh42sxEz2ydxDY8kruFvhOtOXsNj\n", + "ic/P1GhzkkWJY3lc3pLw0G5pZk9W/ggd+KvrHGsO4eXfP36eQxitvpWgikMYjdc77jbATxPb7gNe\n", + "IrzYade3fp02XRSv5Vp3X5CyzzjCiO2RxLpHGX1P6/FNgunrF2a2wMxOSdlvG+BNVdd+JKOvrR7b\n", + "AIdVfX9fYHOCdviEu/8l47FW4e4rCNpG5T38F0IH1XSbzexgM7vVzJbHfacw+rlf7qt9KLD6+XwV\n", + "Qcupfp8aUfP9iyxKfN6G8BsvTVzH2fG8EN6rrOd+LUHLzUK932xL4El3fzax/yO1DtKIopyUefIr\n", + "4FVmthvhgTyp1k7ufhONHci/InSoP0zZvgTYpbJgZkZ4oRbXOWYjR9LWhBFp5XPlWGcRTCaHu/vf\n", + "zOyk2LYknnZQd78D+PvoNDsRuDwefwlhtFS5hvUJL169a6jHVoljjSE89IsJo8+H3H2HlO+trLFu\n", + "DvBtwsP9NeAp4AcEgXpm3Gdhg+M+CnzQ3W+p3tBiKO/3Cfb/yWa2r7v/tsY+ywgjt20JGguEe72o\n", + "xr5r4O5PE3xTnzSzScANZna7u99QteujBLPfQWmHanCqRwmjyeOrN5jZFsBmZrZxDeFQ67jV6y4F\n", + "Tovhoeu6+40Z25xswzoE39H7CH7Cl83sp2Rzxv6ZMACofp8akfb+wehrXEjQCl9ZJZgqLK06X71z\n", + "LwQmpGyrvq/1frNtgE3NbGxiwLwN4d1ril7VGFJx9xcJDtBvEWx7v2zjcKcBbzGzb5jZawDMbIKZ\n", + "zTKzjQid67vM7B1mthbBpv4cwfbcKp+N8eeTCGazH8f1GxAcUM+Y2Y7AR7Me0MzWMrOj4ktecRpW\n", + "HpZLgQ+a2W7xRfwqcKu7p41wGr2Ue5rZP8TIqJMI9+NWgq9nhZmdHK9vyMzeYGZ/F7/3OLBtFK4V\n", + "bgZeD+xFcDzfRxxxEsxMEEw/9Y57NvDVGKqJmb3KzA5pcA01rzHGne9BsI9PA34UBeko4j2+HPiK\n", + "mW0QX9h/IwQzNMTM3hWfMyOYQl+m9sv9c2AHM3tf/I3XMrO94vOReh0JLgbeY2YHxfu2bgxFHe/u\n", + "SwlO5O+b2Sbx2G+N33sceGV8B1Y1u+rY1xJ+qy8QTIBZ25xk7fi3DFhpZgcDDQUKrPoNrgJmxOdi\n", + "Z8Lv1khYpr1/1cdfSnDuftvMNjSzMWa2feIeXQ5MM7PxZrYpIQAijR8QBgFvtMCEyvNKuNfbJ/at\n", + "95s9AtwBfCHe1/2Adze43pr0omBw1vxxq5cvITiEr0iR5tlO5P4g8GbCyO9eM3uK4Ce4HXja3f9I\n", + "GM18jzBCeRfwHnd/qUH7k5+r2z6HYEb4FfBNd/9VXP9Jgsr9V+BcwstWfax653of8JAFM9TxwFHx\n", + "Gn9N8JX8hKA9bEfQtNKOW6vNyW3/RbAjPxHP8V53fzm+qO8mOBsfJNyvcwlObQjCHGC5md0R2/YM\n", + "QUu6N3FPbwYedvdlcZ+VDY57BsF5/gsz+yvBObd3neuruS6+qN8BjnH3Z9z9UsJL+O2Ue3EiwRH6\n", + "ICGC6j8JET71zlthImFAsyJe73+4+5w1Ghk0i4MIv9diwij1a4TOtHKO1HfF3RcBhwKfIThaHyUM\n", + "bir9wtEEzecBQgc1LX7vAcKA4kEzeyJqF1517BcIHfMBhPcxa5uT17cinvNywvN0BCFqrub11OAE\n", + "woDqMeCC+NeItPev1r08Jrb7vti+KwgmHYDzCL6DuYTn5CdpbXX3Kwmm4UsI7/dVhEEthHvz2Wg2\n", + "+niG3+xIwsDpCeDzwI8yXPMaWHRQ5IKZXUDoLP/k7ruk7DOTEE3wDCHU7M7cGlRiolnjQUJEU8vC\n", + "TAjRPHr/RpO3xnAhIUa9JmY2hRBaOpEwij0r5/YIIYRoQK6CITp4n6yzyyFEVcfdbwM2qdjyB5T8\n", + "1DchRCP0/kWK9jGMZ3RI1yJCFMvA4e4Pu/uQ1Fghuo/ev9EULRhgzWgGSW0hhCiQovMYFpOIe2d1\n", + "zPsozEzCQgghWsDdmy7CV7RguJoQUnaZhUzcp9z98Vo7tnJx/YiZzXD3GUW3owzoXqxG92I1/XAv\n", + "YmDOGYxOfJtPqI92rZmNEKoAQNzpAkKJAIB5cMNEOMxCFYOmydWUZGaXEpOUzGyhmR1rZlPNbCqA\n", + "u19LiIWeT6iX8rE82yOEED3CNNbMhp5AyI+BkDiKEapEziUIhaWEiJ4dYGsLNcZaIleNwd2PyLDP\n", + "CXm2QQghepB1U9avF//P3Bl2PBu2qWgJswhCIoaBJoVI0xRtShLNM1J0A0rESNENKBEjRTegRIwU\n", + "3YAOsEbhz8izmI1x2OFl2HwIeAz8eLBr1tx3vTVXZUOCocdw95Gi21AWdC9Wo3uxmj65FzMJNZKS\n", + "5qQFx4TSGnOA/eIUchfvAVs+FuZVqebZGusyIcEghBA5E53J0wgmog0I7oEVBM1gZvS3riI6mCGY\n", + "g9YbA89eB48eFATGeoT6T1Nxv/qxcOytqRIihBpuqZUn6rY3z1pJncLMXFFJQoheJCXCKMmqaKOU\n", + "A0wkBB3tF9dcDEzH/Ymqc5zI6pkPvxeFS0t9pwSDEELkiJnNJsw8WI/Z7n5w1RfHELSMr1KlJTRx\n", + "7pb6zjJkPgshRD+TFmGUZD0II38zm72b2W1zwzwU34nbLgYmNSMU2kGCQQgh8iUtwijJs2Y2ZQyc\n", + "MR3eeQvsvRts+id4+Vz4Iu5HJ01HeSPBIIQQ+TKT4EdIYwHwvd3h1BGY8F1gLCEvYUcYmjp6Yqmu\n", + "oKgkIYTIkeoII2B9QlTS08Cza8OZz8MOz8G+6xKyl6cCibyElvMRWkXOZyGEiFSFldYMJe3wCUdF\n", + "HFVlL1dY0zGd+fCt9Z3SGIQQgtSw0u3NjI4LhxoRR+fCuVPDnM218hG6ijQGIYSgblhpyyP2lBOl\n", + "5iWk5SO0fippDEII0Q6NCte1R4a8hCgE8jNdZUSCQQghAumF69olQ/ZymVC4qhBCBGqFlbZn4zcb\n", + "g9lJhCkT9iNoCYd2Oy+hWaQxCCEENcNK27Px95iWkETOZyGE6CQdqHHUuabI+SyEEMXSw1pCEvkY\n", + "hBCiXXrUl5CGBIMQoiaVSp9mNhL/Tym6TaUkaAlzKKgSah7IlCREj9GNsg1dzQLuVUrkS+g0EgxC\n", + "9BBd7LCnseaMYxMIETsSDH3iS0hDpiQheot6HXYnyTcLuFfpki+haDOeNAYheotuddj5ZQH3Kl3S\n", + "ErJqhXmaFCUYhOgtutVhzwS2pwSVPgun+76Ehma8vE2KEgxC9BZd6bA7ngXcqxTjS8iiFebqA5Jg\n", + "EKKH6GaHXZZKn4WQoiUYvARcglmeE/lk0QpzNSlKMAjRYwx0h92AjtjdU7QEg31Y03yzq5ktIUzT\n", + "2SlBkUUrzNWkKMEghGiZrk+F2bgtrdvdG/kSzGqZb7aIf82fL4WMWmGuJkUV0RNCtERKRzwfmF6E\n", + "cGhrBrYMvgQzGwHelqEpnZ3xLYUss72piJ4QotuULQmuebt7cxFHaeab7OfrIHmaFJXgJoRolbIl\n", + "wTVnd2++xlGtiXyyn2+N05e3FpU0BiFEq5QtCS6b3b3FvIQatv8NCP6FLeuerwZlr0UlH4MQoiVS\n", + "OrcFwLSCHdDpdvcO5yVksfOnfK91f0hz7Wup75RgEKKPyTtqqNWOseuUrBJqHUf2HHcf7uB55HwW\n", + "QqymG+aKnsipKGcl1LKZ4UaRq/PZzCab2QNmNs/MTqmxfVx0utxlZveY2QfybI8QA0a3KrGWk3LP\n", + "qlbLkV2aWlS5aQxmNgScCRwILAZuN7Or3f3+xG4nAHe6+6fNbBzwf2Z2sbu/lFe7hBggcosaKlNi\n", + "W03KqSWsouy1qPI0Je0NzHf3hwHM7DLgUCApGJYCu8bPGwHLJRSE6Bi5mCtKHVFTMl9CPcpshsvT\n", + "lDQeWJhYXhTXJTkPmBRrjcwFpufYHiEGjbzMFW2bqFqN4a/7vT6ce7ko8tQYsoQ7fQa4y92HzWx7\n", + "4Jdmtpu7r6je0cxmJBZH3H2kM80UIj+KNLnkaK5oy0TVqsaR9r11zOx5mEgPaAl5Y2bDwHC7x8lT\n", + "MCwGtkosb0XQGpK8BfgKgLsvMLOHgNcDd1QfzN1n5NNMIfKhDCaXnMwV7ZqoWi2lscb3JsCEK2EW\n", + "sGlcVSpfQreJA+aRyrKZndbKcfI0Jd0BTDSzbc1sbeBwoFqCP0BwTmNmryEIhQdzbJMQ3aRfo4La\n", + "NVG1qnGs+p4R7M5zgd2CUChTxFHPk5vG4O4vmdkJwPXAEHC+u99vZlPj9nMIqt+FZjaXIKROdv2o\n", + "on8oWy2hjtABE1WrGsdzECTrBcD+ceW1sGQK7JJFIJQ+mqok5Jrg5u7XAddVrTsn8XkZ8J482yBE\n", + "gZQ6iakd2jRRtTSXwNrwvU/Anp+FcWMJIY0nwdLL4bgsA8oymPZ6BWU+C5EfXZmfuddoSeMwm/g8\n", + "nAqMA7gGHj8e7nkMvt1Ep162MuGlRYJBiJzodhJTL5lJMmscKXkJ73G/emnzp+1L014eSDAIkSPd\n", + "SmLqSzNJ57OX+9a012k0UY8Q/UH/REDlV+Oo1PWJyoQ0BiH6g/4wk+RY46js9YnKhASDEP1Bb5tJ\n", + "ulTjqMz1icqETElC9Ae9ayZRjaOm6MZc0dIYhOgDetJM0kOVUPOglSiybgUZaGpPIfqMnghbbeBL\n", + "6IlraIOUDn4+ML1BIcGm5orW1J5CiPKHrWbQEkp/DZ2h1WS7rgQZyMcgRH9R2rDV95t9eC4sI/oS\n", + "5sEN1PYldPUaumGzr0GrHXxXggykMQjRX5QvbNVszC/grLPhuPXAlgJTgWtga2AfX3OE3LVrKFA7\n", + "abWD70qZFQkGIfqLcoWtRl/CQdGXMItQLvvJsDXNdNLNayiqflJLHXy3ggwkGIToL8pRuK/Kl7AM\n", + "XjgW1r5mzT3HR4fqKicz3b2GQjSsdjr4buRiKCpJiD4jmkeKC1utEXG0BWz5GLyjxt7PAGMTy/NZ\n", + "Pfd77tfQbJRPr9Fq3ynBIIToDHUijlJs+dVCoULXOuWUdi0ApvVDBJTCVYUQxdEgLyHFdDIe2KXG\n", + "0brmKO/JxMAuII1BCNE6bWQvd9KM0+8Jca0ijUEI0V3ar4TaESfzgCTEdRVpDEKI5uhgjaNOOMr7\n", + "3YHcDtIYhBD50+H5EjoUelm+pL4eRyUxhBCNyW9WtU5QrqS+PkCCQQhRn/LPl9C7c1GUFJmShBhg\n", + "6kbz9Mh8CQo57TxyPotCUZhhcdSdEwDmkdPcy6J7yPkseg6FGRbOGgXkDCZ8Cb4FbEuJtQSRL/Ix\n", + "iCIp7dwBA8KoaJ4JBEfCv8NOlNOXILqEBIMoEoUZFstzAEaoWjcX2B9YDs9TnogjUQASDKJIFGZY\n", + "LDN3hkfmAN8lVLO7ElZMhmOkJQw28jGIIinH3AGDiNkYhx1ehs2HgGXwwqfgnh/C5+TfEYpKEoVS\n", + "+NwBg0iHs5dFedF8DEKI+nQ4L0GhxuVH4apCiHQ6rCXkHWosoVMsEgxioEnrgPqmY8ove7leqHFb\n", + "90n5LcUjwSAGljod0F7A+2qs762OKV9fQp6hxrkJHZGNXMNVzWyymT1gZvPM7JSUfYbN7E4zu8fM\n", + "RvJsjxBVpHVAJ6SsL03inZlNMbPZZjYS/09JbOxGJdQ8Q42V31IwuWkMZjYEnAkcCCwGbjezq939\n", + "/sQ+mwD/AbzT3ReZ2bi82iNEDdI6oLVS1jfVMeVljqpraulejaM8Q42V31IwmQSDmY0FtnL3/2vi\n", + "2HsD89394XiMy4BDgfsT+xwJ/MTdFwG4+7Imji9Eu6R1QC+mrM/cMeVsJy+8xlHOFU2V31IwDU1J\n", + "ZnYIcCdwfVzew8yyPGzjgYWJ5UVxXZKJwGZmdqOZ3WFmR2drthAdIa2O/5kp65vpmNqqA1XXVFSS\n", + "Gkfufq27H+zuw/F/R+z/8TjTgdmES5sNTOsp/06Pk0VjmAG8CbgRwN3vNLPXZfhelgSJtYA3AgcQ\n", + "MvJvMbNb3X1ehu8K0Rb1Rr1mdnut9U0cvmU7eQZtY1WNo0q40VhCjaNXwj/3QzmLDk35KVoki2B4\n", + "0d2fii9QhZUZvrcY2CqxvBVBa0iyEFjm7s8Cz5rZb4DdCHbSUZjZjMTiiLuPZGiDEHVJ64A60DG1\n", + "YydvFJUzc2fY8WzYZv+48UpYcTp8+PY+EAqidcxsGBhu9zhZBMO9ZnYU8AoL4W/TgJszfO8OYKKZ\n", + "bQssAQ4Hjqja52fAmdFRvQ5BM/l2rYO5+4wM5xSiLLRjJ0/XNlTjSNQhDphHKstmdlorx8kiGE4E\n", + "/p1QivdSgq/hSxka+JKZnRD3HwLOd/f7zWxq3H6Ouz9gZrOBPxC0kPPc/b5WLqRZ+iaBSZSSNp2z\n", + "NbWN3YP1aA6w31BYdfE4mH6h+xMXdqLRQkQa1koysze6+/92qT1pbehoraS6UxpKOIiCqX4+DTgV\n", + "ln0JNhwKmrVmVROZyK2IXkw62xy4Avixu9/TUgvbIAfBMBt4Z41Ns9394E6dR4hWqVSd3RU2uwgm\n", + "7gabxk2qhCoy02rf2TBc1d2HgbcDy4BzzOxuM/tc800sFcqsFKXGYbbD9XNhlygU8sheFqImmUpi\n", + "uPtSdz8D+Aghzf7zubYqf5RZKcpLCPKYA3wHzb0sCiBLgtvOZjbDzO4hJP7czJqJar1GWmKTMitF\n", + "cXSnxlHP0CDJT+RIlqikC4DLCPWMFufcnq6Qczq/EM2jWdVGodLbxaIZ3ERX6ccw4bauKb/5Enoa\n", + "BYh0ho7P4GZmV7j7YWZ2d43N7u67Nnsy0RsUUhW0R4VDW9ckLaEeChApkHqmpOnx/7sJodRJyq9m\n", + "iJbodlVQen8CluavSVpCFhQgUiCpzmd3XxI/fszdH07+AR/rSutEEbRVFbQB/TgKbO6aFHGUFQWI\n", + "FEiWcNWDaqxTdED/kmfnncsosODolWzXpIijplDp7WKp52P4KEEz2L7Kz7Ah8Nu8GyYKI08VvuMT\n", + "sJTAb9H4muRLaAmV3i6O1KgkM9uYkHH5deAUVvsZVrj78u40b1VbFJXUJVI62gV0aLRWKfVAh8KE\n", + "yxC9knpN8iWIgsmzVtKbgXvd/a9xeSNgJ3e/raWWtoAEQ3fpdOedJ7GW19tqbJoTy7kUwwBrCf0Y\n", + "ktyrdDxcNcFZhFnWKvwNOBvYo9mTid6gx1T4ckWvDLiW0AnTngRL8WQRDLj7ysTnl+PEOkKUgfJM\n", + "HD/AWkKCtkKSS+AzEmQTDA+Z2TSC5mDAR4EHc22VEFWkjSJLUd5kwLWEKtqNauvHXJeeI4tg+Ahh\n", + "VPbZuPxr4PjcWiREFY1GkYWavqQlVNOuaa8fc116joaCwd0fJ8zXLAaEEtp4yzeKlJaQRrumvXL5\n", + "jAaUhoLBzF4PfB/Y3N0nmdmuwCHu/uXcWye6TkltvOUaRUpLSKUDpr3y+IwGmCzhqr8BPgWc7e57\n", + "WPjV73H3Sd1oYGyDwlW7RBnyAqopTZukJXSFXgqXLjt5hquOdffb4igAd3cze7HZE4meoVyj80Dx\n", + "o8gCtIQSmvS6Qo+FS/clWQTDn81s1QtpZv8ELM2vSaJgSmfjLTTyqCAtoaQmPTEgZDElbQ+cC7wZ\n", + "eAp4CDgqVlntCjIl5UvVyHQDYEtgi8QuHSuJ0VMU6EsojflM9DR5TNQz3d3PALZw9wPMbANgTKU0\n", + "hugPUkamS4DfA08ziDbecvgSymjSEwNCvbLbx8b/3wNw96clFPqSWqGgWwLbxM+DpamVZ76E0pn0\n", + "xOBQz8dwn5nNA8bXmN5TU3v2D2kj03GsLk7X/7btcmgJSYp3uIuBJVUwuPsRZrY5cD1wCIM2chwc\n", + "0kamSfq7JEEJ8xJKUepDDCz1fAy/jr6F6939kW42SnSVWiPTWvSfbbt8WsIoFLYpiqKeKWkLM9sX\n", + "OMTMLiNoDKtCmNz9f/NunMifGiPTSQQzUjX9ZdsuoZYgRFmoN4PbYcCHgH2BO6q3u/vb823aqLYo\n", + "XLVL5D2DW55kSggruZYgRCfJcwa3z7v7F1tuWQeQYOguvViSIEWgzQemr2q7tAQxYOQpGMYARwHb\n", + "ufsXzWxrQkG937XW1OaRYBCNqJsQBu9CWoIYQFrtO+vlMVT4PiHr+ci4/HRcJ0SZqBl2uytsRjny\n", + "EkqBmU0xs9lmNhL/Tym6TaJ8ZKmV9KZYVfVOAHd/wszWyrldQjTLqLBbI6gIX4e/IwyABl5LUP0l\n", + "kZUsGsMLyTmezexVwMo6+wtRBDMJPgUmEFSE7wLrhmd8oLWEBPUmPBJiFVkEw/eAnwKvNrOvAr8F\n", + "vpZrq4RoEne/dm046ctw/92wcn/gOXgSOBT3o+VgBlR/SWQky9SeF5vZ74ED4qpD3f3+LAc3s8mE\n", + "gdsQ8AN3Pz1lv72AW4B/dverMrVciCRmE5+HU4Gd4pqL180YcTRA8x6o/pLIRBYfA1EQZBIGFaL5\n", + "6UzgQGAxcLuZXV0tVOJ+pwOzUdmNviTXjrfNvIQBs7ur/pLIRCbB0CJ7A/Mr8zbE7OlDWVPAnAhc\n", + "CeyVY1tEQeTa8XYmL6Ge3b2vBIPqL4ms5CkYxgMLE8uLgDcldzCz8QRh8Q6CYKifVCGAnjN9dL7j\n", + "7Wz2clfs7mX5zVR/SWShoWAws53d/b6qdcPuPtLgq1k6+e8Cp8Z5pA2ZkhrSaARelg4oQWc73s5n\n", + "L+dudx8l4dGEAAAQs0lEQVQwc5XoA7JoDJeb2SzgG4SX+XTC6H6fBt9bDGyVWN6KoDUk2RO4LKq3\n", + "44CDzexFrzHyM7MZicWRDIKpX0kdgcf7WLYOqDMdb341jrphdx8Yc5UoFjMbBobbPpC71/0D1ic4\n", + "kW8F7gE+Q5jis9H3XkF4wbYF1gbuAnaqs/+FwHtTtnmj8w3KHzBC0Maq/0YIDvxa264rsL1TgHlV\n", + "7ZkPTMl8HJjocJODx79ZDpt1uI3XxXt4XVNta/M3K/p50l9//7Xad2bRGF4ijO7WI5gFHnT3hglu\n", + "7v6SmZ1AmOhnCDjf3e83s6lx+zkZzi3WpN4IPM08U1icurfj8OxSJVTP3+6uMFHRU2QpojcXuBr4\n", + "IsHccw7wvLsfln/zVrXBvY+L6DXjF6hXFjv+1S4k535wRxudN31UCbWXS5mL3qbVvjOLxvBhd789\n", + "fl5KmLjnmGZPJGrTrGOy3gg8ru/tOPU+nC+hLa1JiAJoqDGUgX7WGOqWi25hlN+Lcymsoo+0BCHK\n", + "QJ4ag8iXjoZzdsFe3nn6UEsQopfJUkRP5EuqY3IgaucHLaHhfAkDcS+EKAnSGIonLY7+VgrMScg9\n", + "Ua4JLUEJYkJ0FwmGgklzTJJjUlSjTj/3jrh5X4ISxIToIhIMJaCWX8DMTk7Zva2chIydfj4dceu+\n", + "BM0jIEQXkY+hvOSVFJVlFq+0jvjNLdv3M/oSUlCCmBBdRIKhvKyaqjJBJ3ISsoy+0zrijQmhtWdk\n", + "Fg5mYzA7CZhLMB09RvOzquV1L4QQNZApqaTkmBSVZfRdyyGeJJtZqUN5CUoQE6K7KMFtwMhaniGR\n", + "KPdmgqZQzRx3H045ifIShCgBSnATmcg6+q44xOtkZte27yt7WYieRxqDqEvmAnDSEoQoHdIYRC5k\n", + "0jCkJQjRV0hjEK0jLUGIUiONQXQXaQlC9C3KYxDN0Zm8BCFEiZHGILIjLUGIgUAagwAalLWWliDE\n", + "QCGNQdQvrAfzkJYgxEAhwSCgRmE9gwlfgm8B26KIo6bJfT4LIXJEgkFAVWG9CQQVYX/YKa6SltAE\n", + "mlhI9DryMQiIhfUMmE5wJOwPLIfnkS+hFbKUNheitEgwCICZO8Mjc4DvAmOBK2HFZDhGpqOW0MRC\n", + "oqeRKWnQMRvjsMPLsPkQsAxe+BTc80P4nMweLaOJhURPI41hkEnMqjYE6wAXj4MtLnTfU0KhLTSx\n", + "kOhppDEMIqpxlCuaWEj0OiqiN2goe1mIgaHVvlOmpEFB2ctCiIwMrGCoWwKi30j4EgimjYuBSTId\n", + "CSFqMZA+hoFJQJIvQQjRAgMpGKiTgBSdhr1fykC+BDEgqPxI5xlUwZCWgDSeXtckpCWIAWJgtP8u\n", + "M6g+hrQEpC3o5VIG8iWIwUPlR3JgUAVDWgLS0pT92y5l0Clnd83jKOJIDC4qP5IDA2lKSktAIow+\n", + "dqnxlaZLGVTZPTcENge2TOzStLpbS23eGXb8Ezz9apgUV8mXIAYJlR/JgdwFg5lNJtRmGwJ+4O6n\n", + "V20/CjiZUNxzBfBRd/9Dju2pdlR9o9I5R2GxPaNV06ZLGaTYPaupqLsNBUOizXsDm0K4WdGRsM3Y\n", + "sJt8CWIQmUkH3lkxmlwFg5kNAWcCBwKLgdvN7Gp3vz+x24PAW939L1GInAvsk1N76jqqqjSJ8QSf\n", + "wzPAtCZH97XsnrVoqO7WanNivgQAroHH3xN8CdISxECh8iP5kLfGsDcw390fBjCzy4BDgVWCwd1v\n", + "Sex/G/DaHNtTz1F1bWxP5UE7AxgX/3ahOdNPmt2zmizq7qo2J7QExhIcIlOBa+BOl1AQA0p8JyUI\n", + "OkjezufxwMLE8qK4Lo0Pke8PnNVR1W6kQ5rdM0lWdXfdysmT8yXMIjgVrpHaLIToMHlrDJkr9JnZ\n", + "24FjgX1Tts9ILI64+0gL7cnqqGo30qGW3XMpwZz2N5pQd8fAcydSU0t4Avhd1uMIIfofMxsGhts9\n", + "Tt6CYTGwVWJ5K4LWMAoz2xU4D5js7k/WOpC7z+hAe7I6qtqKdOiY3dNs4h9hp+3j4izC1JtPhjZP\n", + "k0AQQiSJA+aRyrKZndbKcfIWDHcAE81sW2AJcDhwRHIHM9sauAp4n7tX5xZ0lCY67LYjHdqye8bs\n", + "5Zfh69vDOgktAYIzfNagCAWVOxCi++QqGNz9JTM7AbieEK56vrvfb2ZT4/ZzgM8TQjDPip32i+6+\n", + "d45tathhFxrpkKhxNMQoLaHCWHKK2iobKncgRDFoop6yUKPG0fth2UXwhhp7z3H34W42rwjMbDbw\n", + "zhqbZrv7wd1ujxC9hibq6WXMJv4J/kCscfTfsGQvmH5R8NHUYlCyOlXuQIgCkGAokljj6GW4+9Uw\n", + "aSlwCPBu2PIO+ApwC4M9qbzKHQhRAANZK6kUNPYlTCD4EqYzuFmdKncgRAHIx9Bt5EtoiuiAHlTB\n", + "KERbtNp3SjB0k5RZ1QwuQU5WIUSHkfO5zDSeL2Ema84FsRSZTIQQBSAfQ95kn3u5WnUrvyonhOhL\n", + "pDHkRXOzqk1j9CQ+xGVNTyiE6DrSGPIgu5ZQQfH6QojSII2hk7Q+97Li9YUQpUGCoVMELWEOMXuZ\n", + "oCVMyjjV5kwGO5FNCFEiZEpqlxp5CTQ597KmJxRClAnlMbRD874EIYToGspjyIiZTTGz2WY2Ev9P\n", + "aeEgrfoS8mmPEEJ0kIEyJXWkvn8TWkKjSWY034AQoowMlCmprfr+TfoSUjr9+cD0Sqev+QaEEHki\n", + "U1I2WssXaC3iaBqjhQJxOZm0pvwFIUTpGDTB0Fy+QHu+hCydvvIXhBClY9AEQ/Z8gfbyEiBbp6/8\n", + "BSFE6Rgo53OmfIEO5CVEGk4yo/wFIUQZGSjnc4YTdTQvQZPMCCGKRBP1tHbcKcC0MbDuF+E1p8J2\n", + "Q7AOrWsJQghRGlrtOwfKlJSkEk46ASZcAOwf18+DGybCYcpezodGuR1CiOLpS8GQpfMZA9NOhAlf\n", + "BcYSpkubClwDL7iEQi4ooU+I3qDvBEOdzmcv4M3AurvDmFthz73ixlnAdODJsKgcgvyol9shwSBE\n", + "Seg7wUB653OywdhKuFGVlpBEOQT5oYQ+IXqAfsxjqNn5TICxc4DvEoTCLOAN8EyVUFAOQQbaKPyn\n", + "hD4heoB+1BhGdT7G6qSEGlrCAmAxCifNTJt+goa5HUKI4ulHwbCq85lASEqoRBxV+RIAFqtYXdO0\n", + "7CdQQp8QvUFPCoZ6UUfufu06ZvZ5+OYn4PXrwpgV8PSHYcXlsEXiMH0/Us0pNLQtP0E8vwSBECWm\n", + "5wSDmZ0GnEywDFVYbcowm/g8nArsFLddvCFMvxz2YYBGqjmGhspPIESf01OZz7Gzu4LRQgGAMTD7\n", + "Zbie9msc9QV5zfWQInAWANP6WdAK0YsMSubzNGoIhQnA5SFHYXJc1XKNoz7KzM0lNFR+AiH6n14T\n", + "DKM6u6qIo41pU0vos8zc3Ew+8hMI0d/0Wh7Dqs5uAmGyhEpewjy4gebmS6hFllnXegXN9SCEaIlc\n", + "BYOZTTazB8xsnpmdkrLPzLh9rpnt0eCQM8fA/OmEKdX2Bx4DPxUuneh+QAcK3/VNZm4c1U8HZhNk\n", + "6GzkBxBCZCA3wWBmQ8CZBLv/zsARZrZT1T5TgAnuPhE4Hjir3jEd5i2F5ytawrWw5D3wL193P7JD\n", + "zU4zv0xqIcs3F8xsOOu+7n6tux/s7sPxf18JhWbuRb+je7Ea3Yv2yVNj2BuY7+4Pu/uLwGXAoVX7\n", + "HAL8CMDdbwM2MbPX1DxanHv51TCJOPfyFPfxt7tf3sE21zK/vAiMA95GiPI5o2DhMJy2oY1SFb3K\n", + "cNENKBHDRTegRAwX3YBeJ0/n83hgYWJ5EfCmDPu8Fni8xvG+E/+3NataPWpE3EwiCIUkpawG2meO\n", + "cyFEgeSpMWRNkKiOsU373mPAobgfneckOknzC3Bvym5l9Dn0k+NcCFEguSW4mdk+wAx3nxyXPw2s\n", + "dPfTE/ucDYy4+2Vx+QHgbe7+eNWxyp+FJ4QQJaRsCW53ABPNbFtgCXA4cETVPlcDJwCXRUHyVLVQ\n", + "gNYuTAghRGvkJhjc/SUzO4FQpmIION/d7zezqXH7OdGmP8XM5gN/Az6YV3uEEEJkoydqJQkhhOge\n", + "pcp8ziEhrmdpdC/M7Kh4D/5gZr81s12LaGc3yPJcxP32MrOXzOy93Wxft8j4fgyb2Z1mdo+ZjXS5\n", + "iV0jw/sxLoZs3xXvxQcKaGZXMLMLzOxxM7u7zj7N9ZvuXoo/grlpPrAtsBZwF7BT1T5TgGvj5zcB\n", + "txbd7gLvxZuBjePnyYN8LxL73QD8HPjHottd0DOxCSGS7rVxeVzR7S7wXswAvla5D8By4BVFtz2n\n", + "+7E/sAdwd8r2pvvNMmkMnU2I620a3gt3v8Xd/xIXbyPkf/QjWZ4LCGG5VwJ/7mbjukiW+3Ak8BN3\n", + "XwTg7su63MZukeVeLAU2ip83Apa7+0tdbGPXcPebGDUx5Ro03W+WSTDUSnYbn2GffuwQs9yLJB+i\n", + "ZAl3HaThvTCz8YSOoVJSpR8dZ1meiYnAZmZ2o5ndYWZHd6113SXLvTiPUMpmCaG02vQuta2MNN1v\n", + "lqnsdqcT4nqZzNdkZm8HjgX2za85hZLlXnwXONU9zObEms9IP5DlPqwFvBE4gFBO7BYzu9Xd5+Xa\n", + "su6T5V58BrjL3YfNbHvgl2a2m7uvyLltZaWpfrNMgmExsFVieSuCZKu3z2vjun4jy70gOpzPAya7\n", + "ez1VspfJci/2JOTCQLAnH2xmL3p/zd6X5T4sBJa5+7PAs2b2G2A3oN8EQ5Z78RbgKwDuvsDMHgJe\n", + "T8ivGjSa7jfLZEpalRBnZmsTEuKqX+yrgWNgVWZ1zYS4PqDhvTCzrYGrgPe5e3Xhv36i4b1w99e5\n", + "+3buvh3Bz/DRPhMKkO39+Bmwn5kNmdlYgqPxvi63sxtkuRcPAAcCRHv664EHu9rK8tB0v1kajcGV\n", + "ELeKLPcC+DywKXBWHCm/6O57F9XmvMh4L/qejO/HAxbm+v4DsBI4z937TjBkfCa+ClxoZnMJA+CT\n", + "Pccaa0ViZpcSqj+PM7OFwGkEs2LL/aYS3IQQQoyiTKYkIYQQJUCCQQghxCgkGIQQQoxCgkEIIcQo\n", + "JBiEEEKMQoJBCCHEKCQYhCgAM5thZp8ouh1C1EKCQYhiUAKRKC0SDEKwapKfuWa2jpmtHyd32bnG\n", + "fp+LE8TcZGaXVEb9Zra7md0aj3GVmW0S1x9nZr+LE8ZcaWbrdfvahGgWCQYhAHe/nVBT5svA6cCs\n", + "6nISZrYX8F5gV+Bg4O9YPfK/CPiUu+8G3E0oSwBhfoS93X134H5CiXQhSk1paiUJUQK+SCjQ9ixh\n", + "4p9q9gX+y91fAF4ws2sAzGwjwmx6N8X9fgRcET/vYmZfBjYGNgBm59h+ITqCBIMQqxkHrE8ozLYe\n", + "8EzVdmd0Xfu0eR+S638IHOLud5vZ+4HhjrRUiByRKUmI1ZwDfBa4hGBOqua3wHuiH2ID4F0A7v5X\n", + "4Ekz2y/udzQwEj9vADxmZmsB72O16akfJxMSfYI0BiEAMzsGeN7dLzOzMcDNZjbs7iOVfdz9DjO7\n", + "mlDW+nGCL6Ey7/b7gbPjPAgLWF3a+HOEObn/HP9vUDkcikwSJUVlt4VoAjNb393/FgXAHOA4d7+r\n", + "6HYJ0UmkMQjRHOfGMNZ1gR9KKIh+RBqDEEKIUcj5LIQQYhQSDEIIIUYhwSCEEGIUEgxCCCFGIcEg\n", + "hBBiFBIMQgghRvH/AW6zmhuZz7RGAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4FNX6xz8vCSSBhN47JiAloIggYAGkJvZ7FXsXu1h+\n", + "9nuvu2PvBbtYrtfeOyAoBhRBioh06b0XKaFzfn+8Z9nNZjdtN9lNmO/zzJPszJkzZ2bOvO973irG\n", + "GFy4cOHCxeGDSrEegAsXLly4KFu4hN+FCxcuDjO4hN+FCxcuDjO4hN+FCxcuDjO4hN+FCxcuDjO4\n", + "hN+FCxcuDjO4hD8CiMhBETmiFPs/UUTmlVb/pQ0RWSoifWM9jlhARFJE5BsR2SoiH9l9D4rIBhFZ\n", + "HeVr3SMiw6PZZ7QhIpeJyM8xunZL+61Wsr9HiMjFZXBdr4i8U9rXKQkOG8JviVCuiGy32zYRaRjD\n", + "8XhFZJ8dxzYRmS8izweOyRjzszGmbRH7iscJZuxWbNj3dXKUx1OWOBuoD9Q2xpwrIs2B24C2xpjG\n", + "Je1URHqLyIrAfcaYR4wxQyIb7uEDY0y2MabQ7yUKczBug6QOG8KPvoRTjTFpdqtujFkb4/F8YIyp\n", + "DtQCzgIaAtNiyZDiCAaQWA8iArQA/jLGHLS/mwObjDGbYjimCgERSSijS5X3ORgWhxPhDwkReVtE\n", + "brP/N7FLwuvt73QR2RTQ9g4RWS0iK0XkikgvbTeMMQeMMXOAc4ENwP/Z6+WR7kTkLnvtbSIyT0RO\n", + "FpFBwD3AuXYlM922vVxE5ti2i0Tk6oB+ett+bhORdfaeLgs4niIiT1mJZ6uI/CwiyfZYdxH5VUS2\n", + "iMgfItKrkPvsJiKzRWSziLwpIkkB1znV9rFFRCaISEe7/x2UUH5j7+kOEflvMd5TyH7tscYi8pmI\n", + "rBeRxSJyU8Axr4h8bOfENhGZJSJdwr5AkbYiMkZENtn3cY7d7wD/CXgnVwOjgcb295uFPUsRqS0i\n", + "b4nIKvvsPheRqsDIgH62iUijwBWfiIwUkRuCxjlDRM4saMxh7i+SOVRHRL4Wkb9F5DcgvYDr+FQx\n", + "Q+z9rhaR/wt6L5+KyDsi8jdwqYjUEJE3xP89PiB+VU4lEXlSVK22CDgl6Ho5InJlwO8hAfc5W0Q6\n", + "h5iDtxfhnbUSkXG2n9FA3XD3HHMYYw6LDVgC9A2x/3Lga/v/BcBC4EP7+wrgC/v/IGAt0B6oCrwP\n", + "HASOKOF4vMA7IfY7wCT7f29ghf3/SGA50ND+bu67NuAB/hfUTzbQyv5/ErAT6BzQ7z47hgQgyx6v\n", + "YY+/CIwFGqHCQXegCtAE2AgMsu362d91w9zjUuBPe14t4BfgAXusM7AO6IoywEvsO6oc8L5OLsF7\n", + "CtuvvZdpwL+BRKAVsAgYEPBOdtl3LcDDwMQw91YNWAFcavs9GmXa7UK9E6CX713a3+GeZR37+zvg\n", + "A6CGHeuJofoJvhZwMfBLwLH2wBZ7/wWOOcQ9RjKHPrRbCtABWAmMD3Odlui39J5tnwmsx36v9hp7\n", + "gdPt72TgC+Bl274e8BtwtT1+LTAX/7z7CTgAVLLHfwKusP+fY8fWxf5OB5qHmYOFvbOJwJP2WZ8I\n", + "bCPou4yXLeYDKLMbVSK03X4EW4DPA170ZvRDfxm4Gj+xfRu4xf7/JvBwQH+tKR3Cfy2qIvB9XL6x\n", + "ZKAErS+WOBbWV1CbL4ChAf3m+j4Eu28d0A0lCLlAxxB93BU8kYFRwCVhrrnE9zHa31nAQvv/y8D9\n", + "Qe3n4SdwwR9dUd9TuH5PAo4DlgUduwd4M+A5jg441h7IDXNv5xJEyIBXgftCvZPAd1nYs0QZ7gEs\n", + "EQ1qk6ef4GsBacAOoJn9/RDwelHGXIQ5W9Q5lIAS6jYBxx4Cfg7Tb0v0Wwps/1jAuL1ATsCxBsBu\n", + "IDlg3/nAWPv/2KB519/2H4rwfw/cVMD8DZyDBb2z5igjTAk49h6FfJex2g4nVY8BzjDG1LLbPwCM\n", + "MYtQSeVolEt/C6wWkTYosRhnz2+ESks+LA93IVFvHJ8ReWYxx9kEyKcHNsYsBG5BP4J1IvKBiDQq\n", + "YAxZIjLJLum3oNJbnYAmm4xf/wz6Eaeiy9NkVBIORgvgHLvM3WL7PR61TYRD8DPzGTZbAP8X1FfT\n", + "gON5UIz3FK7fRvZY46Bj96BGWB/WBT2TZJ8KIcSzOC6orwtQolQUFPQsmwGbjTF/F7GvQzDGbEdX\n", + "C+fbXeehBKjYY45gDtVDVylF+l4CEG6ugErlPrRApeo1Affxir0uFONbRedGqLkeCgW9s8bAFmPM\n", + "roD2y4rYb5kjMdYDiBOMQ5d8lY0xq0VkHHAZukz8w7ZZg3J1H5oTBsaYn1HJqyCY4B2WwJyG6oND\n", + "9fsB8IGIpKGS2mOotJGnL1E9+mfARcBXxpgDIvIFRTNUbUSlqQxUTROI5agEc3W+s8Ij+JmtCujr\n", + "IWPMw2HOy/d8KNp7CtuviHQHlhhj2hTjmuGwHBhnjBlQwr7CPkvL0GuLSI0QxD9Uv8H7PgA8ou6T\n", + "ycaYn4o45sAxRDKHNgD70fc93+4L+70EILj9qoBjgfe4AtiDqlgCGY8PRf5WbV8ZYY4FP9eC3lkL\n", + "oJaIVDXG5NrdLdCVW9zhcJL4C8I44EZgvP2dY3//bOyaDfgYuExE2oka2TwRXvPQByQiiSLSDv1g\n", + "6wNP52ss0kbUmJuETvrd+CfVWqCliPj6rGK3jcBBEckCCv3YAeyH9CbwtKjhMEFEeohIFeBd4DQR\n", + "GWD3J1sjX5MC7vEGUWNsbeBfwEf22HDgWhHpJopqInKKiKTa4+vIbxAsynsqqN/JwHYRuVPUgJ0g\n", + "IpkicmzAeIuKb4E2InKRiFS2W1cR8bnfFtZX2GdpjFmDGnFfEpGatu+TAp5LHRGpHtBX8LVGoETH\n", + "QfXsRR1zICKZQweAzwGvfc7tUbtCYczw37Z9B5ShfxSqkX0+o9E5miZqzE0PeEYfA0PtvKsF3F3A\n", + "NV8HbheRY+x8yRB1vYX8c7Cgd7YMmAo49rmeAJxayP3GDC7hV4xHl6g+gjIBNRr5fmOMGQU8i+oP\n", + "/wJ+JDI/XYP1+gC2Al+hklIXk9fN1HeNJOAR22YNqpK5xx77xP7dJCJT7XJ/KPoBbEaX/V+FuH44\n", + "3A7MBKagaqdHUP3oSuAM4F7U+LYc9UAKN48MqmYYjS6nFwAPAhhjpgFDgBfsGBegqxcfHkEJwRax\n", + "3jwU7T2F7dcytVNRddFi9Fm+BviIqAnxXEI+J2PMDpQQnodKpmvsmKsUpa8iPMuLUZ3xPJQADbXn\n", + "zUMFhMWi3j6Ngq9ljNmLEt6+qBNCUccceH+RzqEb0Xe1FhUk3iygrQ/jUKP9D8ATxpgfAq4TfK1L\n", + "7Ljn2PF9gl/lOBzV3c9AifFn4cZqjPkUtT+8jxpjP0dXkBA0B4vwzi5A7UibgftQ21NcQvyCUglO\n", + "Vre0U4D1xpiOYdoMQ416ucBlxpjpJb6gCxcuKhxEpCXKiBPDqG5cRBmRSvxvoa5vISEi2UCGMaY1\n", + "6oXxcoTXc+HChQsXESIiwm+NmFsKaHI6drljjPkNqCkiRfV6cOHCxeGDSNSmLoqJ0tbxNyGvW9VK\n", + "1H3KhQsXLgAwxiw1xiS4ap6yQ1kYd4M9DlzO7sKFCxcxRGn78a9Cg1F8aEpe31wARMRlBi5cuHBR\n", + "Ahhjip1IrrQJ/9eoW9eHNnhmqzFmXaiGJRl8eYGIeI0x3liPo7Tg3l/5RkW+v4p8b1ByoTkiwi8i\n", + "H6BJo+qKZpH0oKHUGGNeNcaMEJFsEVmIhttfHsn1XJRPZIpkN4OhaZC8HXavgGGzjBkR63G5cHG4\n", + "IiLCb4w5vwhtbozkGi7KNzJFsnvAc8MDwuKHQHqmCC7xd+EiNnAjd8sGObEeQCkjJ9yBZjD0wWpk\n", + "fNEWNlbVfcMhozncFO6cOEROrAdQysiJ9QBKETmxHkA8wk3SVgYwxuTEegylicD7E0cqofnXewLH\n", + "p9xGr7aVocdKaLsR6tr0VamaaqFc4HB6f6WBWKr6Kvq7Kylcwu8iIogjqWh+kp5oitruaB6TCcDP\n", + "R33MERNWcXylIBPUDi144qKCw1X1xSciytUTtUGImIrs1VNRII4ImuLWR+R7Am2A6cCvvs14zAbf\n", + "OaE+/Ktg0SQY6n74FR9ZIqNGwsAFteHmLPjuPQ3syYZRI4zJivX4yjtKSjtdid9FWIgjldFMloGE\n", + "PhGV5n9F09RONx6zJ1wfs4wZkSlCNtyUCik7YNdyeN4l+ocH0rSoD+lbYGlN+PEI6Le4fKn6KiJc\n", + "wu/iEMSR2kAP/ES+C5o18VfgGzSv+RLjKd4y0RJ5l9AfhtiudSOoZOCen+HhE5Xwu6q+2MJV9Rym\n", + "sGqbNviJfE80svo3lNBPAH4znuKX/3PhwodAVd++StB6KHT4glXLlnG1u+qLHCWlnS7hP0wgjqQA\n", + "x5KX0G/HT+R/BWYZj9kfs0G6qJDIFMlublV903tRb+kxbN/3tOke63FVBLiE30UeiCON8BP544FM\n", + "YBYBhN54zOrYjdDF4QgrgCwGBhiPmRnr8ZR3uIT/MIY4koAS9kBCX5280vwU4zHlQq8qkpkNzYZC\n", + "WjJs3w0rhhkzy1ULVBCII3cCRxmPuTDWYynvcAl/OUC0AlnEkeqov7yPyHcDVuMn8r8C84trhI0H\n", + "KNHv8RwMz/DvHbIQJt7sEv+KATt/FwHdjccsinb/h1NuKNedM85R0kAWa4RtRV6XynRgGkronwMm\n", + "Go/ZVKo3UGZoNhSGZ1B5J+yrinp9D8+A7JtwPYMqBIzHbBNHXgHuBK6JZt+B39lBUW8iN2AsP1yJ\n", + "v4zgC2T5oyEcvda/PziQRRxJAjqTl9AfJK80/4fxmL1lOPwSoSSSl8jgHPi4F4Nugc5vwvpM3bZN\n", + "WEifOUNQA/TGsrkDF6UFcaQu8BeQGU1bk+87W5sKAy6GKa9B0oGKGzDmSvxxjh2tadC3ByyppZOx\n", + "jtW2pyRQXRw5HT+R7wwsQAn9Z8BtwPLyprbJFMk+Fnn9v5hGvn2XIZ0yRa4qmPhv3w3AqGdh3H1Q\n", + "fxbUnwktv0kCHgQyxZFdwEzUWD3TbnOMx+SW3h25iCaMx2wUR95G5/ft0erXFzDm6Q39FynRBzdg\n", + "LBiuxF/KEEd6AE6V7Zzw0lhSLpkBlQMqi3Zrxf4pl/IjfkPsZOMx22Mz2ujhZKk8bSz7j9mT4P/4\n", + "AE4mcdpYs+/YcOeF1vFftQgmDTVm1gir+mqGGrM72i0TOBKt6RzMEBa6LqrxCXGkKfAn0Dpaqsos\n", + "kVFP1mNgn8tg/vNQS8UIV+IPPs8l/KUDcaQbKqF2AiZWn0HTrJ845sOt/lTYlyew4je4fs5+823M\n", + "BloKEEdathmZNLt1+p6q41vAX89Dwx167OTalff8NHTfM2jk5i40snNXnu2Lxp34q90ZHEytjNmZ\n", + "S73FbzJk8Xe+9sZjDoS4ZmWgNfkZQmNgPvkZwqrytoqqiBBHXgdWGk90qmRlimRvvoRP7vyLqrdM\n", + "0n0VOTeUS/jjAFaCuQg1WDVBC8v/jkryE9JfpmqbdVxU0XLWWKJ7PHAKkA3Uq/NnlRovzt9bZcAi\n", + "v9QFcFzNqrmTb8l9CF16+7bkoN8FHUsG9hPMLMIxEdgHVAVqALWAekADIAFYASxBPUzmA3PRzKL5\n", + "+jIeE7BOcxEtiCOt0dXuEdFY6Yoj/WUvb/d/nD9r7Ce5In1noeAS/iihqD7k4kgiKs37dPO9gdqo\n", + "IXYU6m0zyXjM7uBzKwLEkYZAFkrs+6F2ie9Qz5upNbwdJw8kt8tH+L31BpPOaKpO3Wr+7BrBdQVI\n", + "IjyzKCoTqYUygHr2/xpANfT97bV/Qe1gSSgDCcdcCmI8JdnvW9kcFsxGHPkQmGo85skI+0lABa37\n", + "jcd8FpXBxTlcwh+VcYT3Icc7+1c0gZnP26YrsAyYh7pbNgUeAl6riMTeflRdUYk+G3UpHYMS+1HG\n", + "Y9blaS+Z2Wk0HH4kiY2rsZudJDOffWu2s+6qePXHt0VkWuBXE/lURunAcnRFsACNPF0KbEKZQlEY\n", + "T0n27yVKTKSI+2PCbMSRo1CBIT2Sb0ccuRy4sr3Dw82N68df4Hku4Q8cR9YoGDkQDNReCM1+1S39\n", + "nR3U2gUwBb9b5d+oR8LxwOPAK+UlMraosNk6B6BS/SBgLfqBfofGDuwr8HzJzIbmN0FqCuzYBcuf\n", + "j1eiXxDEkSqo8TiYIdRDmUGw/WBtpPaDgJVNNJhIUc9JQplNma1qsMxGHPkW+MZ4zKslfF7VgPn1\n", + "x/LU6eO5PiheZuFEuLkiEn+X8EdlHNaHPGUTXNsZVvSE5cfDus+mcfm47sZj9osj7QEP0At4EnjZ\n", + "eMzOmA48SrDEphMq0Z9i/89Bif0I4zHLYze6+IONQO1AfoYAfkZw6K/xmG2xGGdRYVc8PmYTKRMp\n", + "6n4fs9mL2mKWUTLm0g+on/kVKU9uo3PKfuiw3u827Xr1BJ3nEv7Acfgk/vHAaFS9ux8YPxXvzxcD\n", + "9wF9gaeBF43H7IjdaKMDcSQNvSefCmc3fl39uIqotipNWObZgLyeRR2B9sBG/KsCH0OYV1gwXkVO\n", + "QRDEbL4DPkFViMVhInWAc4Ex9ZbQ4+iD1NmVCA/8BL2X6nUGw7iPjeldZjdWRnAJf1TGkZkNbYZD\n", + "u8aqrgdqL4CTB+yi7bJ9JJrHgOfLs5+9JUyt8XvgdAcm4Sf2C+LBzbGiETtrI2mFnyH4mEJL1GYQ\n", + "zBCWGo85GCbVR4VUXYgjA4GngE7FsTVYl9DNxmPu9EXuBrdxJf6g81zCnxciA6bB6GOotQh6PQCt\n", + "v4PfboYpOWNM7g8DYj2+kkAcSUZVUz5in4xfVz823hjZYUbskoF25I8/qAXMrj+XxvcupWnmeui0\n", + "DurZ2OSKSMisUDIVcIzHfF3EczqhK4QjjcdsPdxqPLspG6KGmtuRgzD4bJh3Jjy/AHbXBP6sEuuR\n", + "FQfiSHP8uvpewAyU2P8DmBkPUn04NIOhwyFjRxVI3g+JB2E4ZGRDhUvUZlVp0+12COJILSCz/mre\n", + "mF8XPm0Pzf+G9z7X4xUxBYHxGCOOPAz8Sxz5pohz9AngQeMxW8Gt8VxUuIQ/H7bvxlSC16aBqRSw\n", + "f0dce+zYIKqe+HX1DYGRwHvApcZjNsdweMWCL9/KUz20RmvTbXDEFpi3i6NsLvdFqHpkcUUtDWk8\n", + "Zgvwc5ZXFr+kqrk8qMA1a79A9ax9gLEFNbSqoVbAK4H73RrPhcMl/PmwYhgMSccE54pZ/nzsxhQa\n", + "4kgD1M3yFKA/ShBHAFehATH5UhuUB/gKdHvGwd2/wLKasLgW3NSULajhtCdwBHCEOLIbZQKHmEHA\n", + "/6vK6zPwYQUMGwLpwaqL5RB38zEasK6djwL3UgDhtzaTJ4E7C3MrdpEfro4/BOLV/9x6QByLX4WT\n", + "AfyAEvuRxmPWFnB6uUFR9bRWJ1wfywTQQKvAv3VQ98BQTGFxeXHDDaxZezioLuzqdSFwjvGYyWHa\n", + "XAVcDPSOZ7VlaSNmxl0RGQQ8i+Y+ed0Y81jQ8brAu6jqIRF40hjz36A2cUX4Y4VQniyzvUxEg6iy\n", + "Uel+A9avHphQUaWdaBA7W9+1FXmZge//VmgQXiAzCGQQaw5nghJriCM3An2Nx5wV4lgqmsv/dOMx\n", + "U8t8cHGEmBB+EUlAk1v1A1ahka3nG2PmBrTxAknGmHssE5gPNDDGnyrXJfx+Kfc1yJhVH75rA0+3\n", + "ZfeGRhgSGIt64Iw0HrM0xkOtELCrp4bkXyX4/k/Dn8Btcb0ckjOn0rXGXg7s2sfWlYZnCy8q49YO\n", + "LinEkaooA+5rPGZ20LH70aRuF8VkcHGEWHn1dAMWGqPESEQ+BM5Aw9h9WINGgIIWAN8USPRdqAST\n", + "eTQPJDQlo8mRsDsRLvwT/pdD8tPLGT16jzk11mOsaLB+4qvt9nPwcStVtgLS643nlAGTOefdXGr4\n", + "jp9Xkz41/inzt3ViCvlXCxvwdsgKkfcpXSQTl/gXDuMxueLIc8DdqEoHAHGkCXADWrDIRQkRKeFv\n", + "gqa29WElcFxQm+HAWBFZjUpRgyO8ZrlBQRKfOJKB36++x+pjOdBmNnz+IfS/BJ4aDVUOwJsa1eii\n", + "jGGjsmcCM7NErn0XaqxOgz8aQvYC+HAriX2/Z+fYTvyCrhJOx79iSGLoEsO6NmlsuR02tYZp1+DW\n", + "Di42XgIWiSOtjMcssfseRBMhuulDIkCkhL8oeqJ7gT+MMb1FJB0YIyJHGRNfQUPRRr5Mnwl7IP20\n", + "TLkueSoN97RHUwCPQF3Rzun2Oh/fZiMO226ESU3hpGUV2m2v3MDnXro2FW4ZBC91hWdGQZ3N7DIe\n", + "80Zwe3GkJl92+4HUC7pQazHUWhJwNLXC+d+XFozH/C2OvArcAVwvjhyNpgJvE9uRlX9ESvhXoWXw\n", + "fGiGSv2B6InNf2CMWSQiS9BMh3mMMtYW4EOOMSYnwrHFGM2GwvAMkrbBWZdAy59gfWYTljTaScOl\n", + "g4EZgcbDTK8cctvrtxh+OAL+t6ziuu2VJ/jcS49ZA7NegueOgx5XQco8mokjacGRz8Zjtoo3ayOc\n", + "HaK3+I4HiUM8B8wTRx5A3TedeE92V5oQkd5o7Y/I+onQuJuIGmv7orrSyeQ37j4N/G2McUSkATAN\n", + "6GSMP6CoIhp3D2X6xED7z2BJH9hVBxg8zpiPe4c6x+fJsrUdjWb2pkWLl7mwIrvtlReEci89rzpL\n", + "v7iUhXvr0B7VQ78XmF+msNrBZTn+8g5xZBhaQrMD0NGtoexHLN05s/C7c75hjHlERK4BMMa8aj15\n", + "3gKaA5WAR4wx70dj8PEMf6bPYGSPMmZEgTlWbP6WDUCTw1m6iadEbeHcS8WR7uiqbB8wNNC9MF7j\n", + "QcobxJFWqF//hcZjPoz1eMoKRZn/bpK2OEOkEp848gPwnPGYb0pxmHGL8pSozbqGXgo8jLrd3ms8\n", + "Zn1sR1VxII5cg9bAeMV4zP2xHk9ZoKjz3yX8cYiSSHyHPIH6L2lD2rZKfF77+sNRSvSl153aGJps\n", + "gwY7oZIpflbKsvSlF0dqoDUbLkGZwAsVNcCurGCL3cwHrgNeQ/33y30djMLgm/+TmkJOS01dAvnn\n", + "v5udMw5hCUyRiUyeVcLsqXDmpUCP5w5H3+80SDbAzYNgYW3YlqTZKTflcpw48gpa83aJ/bsUWB8c\n", + "aRumhnLEvvThmIlNGPd/4shwVP05RBy5xXjM6Ghdo6RjLse4CxhtPOZLceSCaot4OkukeTyo/0oL\n", + "4kiVo7vR/LhOsKEaDP1N3SeF6GVldQl/HMD/kbfsBsNrUXce9Pk31FoM3a/IYOMf/xFHJlTUTJSh\n", + "sB12CzDhTf29s7Imazu/EYs3NWcmWsCkCxpk1RKoKo4sJZAZdGl/AWuuyWDrRsitg346kfnSF4WZ\n", + "GI+ZJ45kAacCL4sjM4HbjMcsjtY1DgeII82Aa4GjABp8z/htPXnmywQSk2zqvSGQnilCRSD+Nuni\n", + "NcC1i4+iyjvj4ZS/ICFAnImWe7dL+GOMvB+5V3dubwxTboTqq6Ddl1B1fgdglTiyFZhjt9m+/20K\n", + "3wqF4KyU1fbB0xtYdGAD95kZ+T9yW0KyZcDWig4bm3Ls1VBzCfx0P0y+ybaOxJfeuunWmQ9nXgY/\n", + "PgxL8zMTu/r4RhwZA9wKTLYrlUcKTw5nr5E1FOafBov7c5gGfz0EvGQ8ZiVA54mcao4g8dUucO5s\n", + "Vf9VhDoN4kgXYCgaBPgxMKDZcJp/A8+dXkpZWV0df4xxyPvnpAdg5izY8pH/4LEvQ9PfYOyy6dyW\n", + "8x808rkRGi/RAo0SzQB2oGkyZhHAFIzHbCrbuwmPknjoRJqoLY9nlRwMqK9QuGdV+D6tm64chPaf\n", + "QN9/aWTu+D1TzfKxXcOe50hT4DHgJOBO4MNwSeBE/vEnfN6RNt9A1lBY3RW+fxq2DZ1pzOedQp8T\n", + "n6ohm0E1GZ27hW3VA/5vimYBmIMGO6Yl7KP+gUQqCdBxHcywWfjLYz1dm4H0LJTgNwdeAN4I/GaL\n", + "Mv9d4245xSFC0u0F2DkbFhvYZWd07QVw+VGGhVUm0fnvv9EPyFdsOjlgq2r/JgI+X/JK9v89wE6U\n", + "OWwFNgHb0KCk3ejScXcBv4vSZhewJxwhi5WHTmn40udz003YC11egz637SVl38fAfwpKpCeOnAAM\n", + "Q9/JUOMx0/O1kawNMLIuAJVz4YRHoetLMLH2TvouqB1cnD2MamghTLy5JPcpjiRSNEIdimCH2g4A\n", + "2+22LeD/gra7gNHAh759Jz/Gf8fspl+vy+CGKXDeLB1veSpDKY7UBYYA16NqyeeAr0oam+AS/nKK\n", + "/P7+49ESonM2Q+5k/vX9MVQ2vYzHzCu0L3UrTMLPGJqjQS9t0SpO6agaxJegbB0aL7AJTVG8n7wM\n", + "JZjBFPQ7CWUy+RhD6npadt1JzeT90H8R3DpJx1sWH2y0fenDMpM64+7ipoUdUbXD/4CHjMdsDNmH\n", + "FhG5AngA+BL4d2BbkQF/QteONuBd0fxMGDh2F022LwVuMB7zk388zd6G4+oiu6DaUZB2JCRth5pD\n", + "p3HmzKcpPtGuggoKgYS4qAQ73xbMqAp9xo6cBjwKHBVIEH0CxFmtybi7H8x4GYaUk3q6tjbwUOCf\n", + "6DsfForpF7tfl/CXTxQmlYojbwC/G495MSrX06V3A6A9yhTaB/xfiSD7gd1WF5abPoDpJAdtKSe+\n", + "w+veg3TenQgNdkCXNXpOeVyiZ4pkV6LG/atp12ovqbKLA4v3s/6+gOR7DYD/AOcBzwDPhtPp27q6\n", + "XuB8lAm8bDxmvwoD9wxUASAB2A/Nk2Hw/btI3fcHytDH807zESwa4Mkzd2pcBD1mQqMawNzNtNg4\n", + "huIT7dxY1SKwKpCZwK3GY0YGH7cqw5t+uYkTW41n3sEZ3BevRN8y+NOAm9H8Qi+jCeaiFuPhEv5y\n", + "jIKkUnHkfGBwqIIUUR+HI/XxM4JAxpBECKMysLIoBMLnkxy8vzwt0SGvysrnXhdOZWWzrz4InAjc\n", + "D7wZzqdfHOmALvkbADfj7ZAcUhio/vPt3PZXJmosnseehG7MPzeRnfVg7TEw4xLb9j8oHym5LSNW\n", + "EEduQFPRoyUcAAAgAElEQVS7Dyxobokjg4FbgOM7eMmKlwhvO7ZawJVo+ui16Lv9vLgrnyJdyyX8\n", + "FRNWgpwH1ItVjhKrl2xPfqZQjbwrAx9jWBGYt6aopRTjHT4GNuw42JoM943T/QUxMHHkWNSo2xTN\n", + "VPt5KIJmV2JnAU8B03ij1besaHsupKaQtGUv3WeMos+GXWge+m5AB7YnJSA19bsZ+yD8fpXtzQus\n", + "LHd5gWwA3HyU6M8opG0CMLfuz7x+5o8MiYcIb3GkHarOOQ+N4B4WrnRk1K7pEv6KC3HkT2CI8Zjf\n", + "Yj2WQIgjtYF25Fcb1US9jA6tEJp+Sv3M2ZyTZuK/bmw4D5nBIjkfQ681qdDlGnj7C+i/uHCVlSXq\n", + "/VEGsBctED4uTNtmqLh+DlrUpQrqxTUHmA78Yf/+yWMnj2HXD91p/ykMvA2W9oYxT8COyzfCikvL\n", + "E9EHsEXW6xmPubKI7a+osZLHt75OnQv/AS99BzX26LHiriZLmhfKqjizUHVOJ+BVNLXEmqJeOxK4\n", + "kbsVGWuSF7KswTsig1fHk6ue8ZjNwAS7HYI4UhM/Q2gPnLzybNqvPJs66OplBXCU1efOBpYYjzlQ\n", + "poMPg4KCpwbZ9MyNdsB7n8EF/4Spr8GO7QUH1VgJf7TNv3Qe8JY4Mhd14asKHI1K8p3t7z+A94GO\n", + "aMH4K4CPtKpXs6GQdo6dB6Pg6rrMGZ7Bwiw46QG4vuVBVid+RsbOYkcLxxLiSAvU26VjMU57d3dN\n", + "XpraGKY3ghU1oIbVnhcnwjWM11mBgWE2lcRlqDF/G6rO+ch4zJ5ijD9mcCX+OIdIZjbtGg6n28HG\n", + "vD3W7i25q14sYT+WtuQ3KtdHi2cH2xAWBau3Sjtj5yEvq/qzYGc92NnAHske1YGRzwcSiIdPhGfa\n", + "srvuOwyeuyt8Mj3L4NqjhP1o4BjgWNR2shr4HMhBJfllgaogcaQXMIwdCfDeaTVZ80Vzf89DFsLE\n", + "d6F5d6RqNequa8Sg3xuRnrsBNdJeZzwmD1OOV4gj7wELjMd4i3Neel+Ze3Rd2m5PgtsmwqCFur84\n", + "En+WyKiPqzDw3U4wpx48PzJ8H+JIa+BGtBzkGJTgT4yZMdyV+Csqmg1l0SeNObOR+nTvq0p5jeK0\n", + "KaYn2+0QbH3btvgZwRX2/8biyAIsI6g5naQ+Dbjwow20qGwtCNEP2U9LBuCIH6DX/fDnhfDr7fB3\n", + "asosY0ZkipBtg2q2/8KurV2ps/FuegHf2HtJQ1MMBErxbdE0Ej5Vzbf2717gdtQIuB8YH0xAjMeM\n", + "E0e6MLnVDC6a0JzZN6o+f3dN7DzoHmjAFUeao66QA9DI4a+Au+I5W6g40hUtLnJNcc9NmM693w3h\n", + "k+ylJKysrvuKE+EqjrRv/g86tmgNJy+BGwJmpm/VEKCqG4raV15HXU1XhOiyXMCV+OMchwK8Lu4P\n", + "Yx+CVd3skfAFXSoKxJGq+BlC+1pLubJOGvVX1IBrp8Kzo7RdNL2D8sRVpK6F7s/AMa/DisRVHLm+\n", + "r/GY+QHjawicxH7eYFPqfpIPJFF1TxX2yUKqHsjBr4+faTwmt4D7bIS64gxGjbvPBbcXGZxDysu9\n", + "OPFhGP9v2F3LHgk9D8SRnijxa4QSsH8Br8aLSs0HS1THAW+HKmNZFFS7Qt42qZzVZCGbW49kbmH2\n", + "I7sCOwNluEc2m0zur7+Q3jSo8kX/ZMb8cDdfoOqcfWjg3fvGY+Kmippr3K2g8BMinwOhD+XPVS9S\n", + "+IyruxJhexLUt97x0YwHCKnjT7loCRd+/idNd/VBVTObUHVPZbYnLmdF03SO2JTGJx/Dkn5w8LoS\n", + "qeLEkTZo1FZP1DXnLZ+qqySFfazh8WLgcbtrHXC18ZhJxRlXaUIcORN1d+1cUqZkbUorgW+Nx5xX\n", + "QLtGwNV2W4gWc/+ig5d+gSq8JTXhlJ5snXcMlUwiP6IEf1ys1DkFwSX8FRRKiNoMh/aNVTO3H5i9\n", + "BhZcVd50/JGipPEAxbELiCNJfNjsatYecTWJSbVI2VaV42cl0XbHBuBPoDK63P8DuA/voP/AyIF0\n", + "ewFa5sDHn/pGVfJ8QI4ch3oANQDuAb5Sw27J0k9YVdo9qKrCAJ+inkUhI4vLCuJIFTS/1I0lSV0d\n", + "1NcnQDfjMS2C9guaH+kGoB+aAuJl4zEzA9t1qCTZSW3xrOzGEVsaUSNxM1/vbsztBaXfiAe4hL+C\n", + "Qgl/t9fhzUb+vVesgcmHHeEvSTxAQXmCZnuZgOriA/XxrYFF5HWd/CMwA6o4koR6dNzF6pq1+fGj\n", + "GizqB1VyYW+qbRWZKs4SrEEoA9gB3IW3Q1ok6SdsCcNngJPRtB13oonBYqL+EUeGAlnGE7maThzp\n", + "gxpbmxiPWWdtLRejOXEqodL9/4JLmYojKcCFKFNMRKX7dwrPoBofcAl/BcWhJX7KJujwCWxoDxva\n", + "Qe6lh52qB4qfsdO3SliTCtMawx8NYXpD+K4pu/ZU5wCaHiCQyM8yHrO7KGMRRxIZ2XYaXSp1Yn8K\n", + "/HwvzDvTZgGNjirOBipdgPr2/4mWdZwVYZ+9UH/zRqhr7eXGY6ZEOtZijqEmGqzVN9L7sf3VAVYB\n", + "76BG8/OBscCLQE6+Ij0aL3E9cBUwCSX4P8SjOqcguIS/guKQcbf6CujtQL05UHcuyM79JO+biD9Q\n", + "yvd3VXmbvKUJn13gpiz4qw50XgtHr4U3NjL5h2vpGam0K5KZjXR/jiNPzeDEh6DKTphUez2zN11l\n", + "ds3N5+IZQaBQMlp+8B7UK8gTiVdJQKK4J9AgsU/Q/DibS9pnMa//BFDDeMzVUeirMnAmqsYR1Kbx\n", + "vPGYVUHtBLWf3Iyqff6HlsdcGOkYYgWX8FdQhDbqGajZ5yduGfcg/kAp39+qaJBUIDOYSxwFSZUl\n", + "yiJPkD/XUrUUOiysStbMJFIPpKEE6L++FUQ00lPbtAZ3opWp3gAejYRY2/7uB66W/ZjWOSzpNIEN\n", + "O0zp5byxKqcpQKbxmLUR9NMYDfryGWvbYN2Fjcc8FNAuCTgXJfjVUen+7WC1T3mES/grKIqbU94m\n", + "iApmBu3QIKkF5F8hLCiN5FHxgljlCbLulPeiwVpPA68M8vLpSBi4LQmqHIBkG5pWEiZkiZ4Xze/z\n", + "BCrhltjNsFUrufLIBJ7f2ocUMfDiCHh5TenkvBFHPgRmG495oATnhjXWiiM5wNtoHMMRKJG/DmUM\n", + "M9Bgq1GBeaTKEqURfOgS/gqMaOSUF0eqoT7xgcygHZqffxn5VwjzyouBqzBEWskrEogjRwN3A30z\n", + "JrHjt3G0/LgD3DoQWm6Fjuvhj20sXdCDW1Ed/tLiECZxpC3wMNAV8KAGzGIn8/OtjHJawMz68GAv\n", + "OGcOzB3HDz/uMP2L218B4+2OehW1KSi2IcR5hRprxZF30eItl6FEPx34AGWKc6N1DyVBaRUjcgm/\n", + "ixLBLoMzyL9CaA2sJ/8KYW5FrPFb2hBH2tSfx9j9zWly5XSNEN2WBDMbwF2tWLzyGOaheWpqoWkr\n", + "ZqKMYCYaAFZgGU1xpAfqAVQHtQN8Uxxbj88WcmM2fJAJF/2pGUg/bMPBvVW5Ga19G5GkbKX1X4Dh\n", + "xmP+W8RzOqDEvjBjrc9O0RktYlANaG08ZkMkY44WfIx1RGv4+kh45VvdH6nK0SX8LqIKa/xrRf4V\n", + "Qjsgl/wrhDnAOtewHB6ZItkdavFig+60fLeTlg7cMJFlczdzvU/qs6q6TJQJBG47CWAEdpsb6IFk\n", + "CespwCNoRbW7ipqrJ9AWsqQmPNUT3usIso6dW1qSDCwHzjYe83tJ718cORuNID7WZ28KlQmVygcS\n", + "SGn4ANUSWpC0LYU2iz+j56Y7g421ts/6qCrnOtTtdRFa/GQEmjTtzZKON5o4RyTnhOPo9dgJ8NlH\n", + "0GOl7o80+NAl/C7KBJa4NCEvM/AlXEsgxAoBWB4rvWq8wad2qlSd6jN60XDl0dQjgS9QI21IdYR9\n", + "5s1RBtAJPzNIR+u25lkdoC6aF6FG299RF9A5hY0rWBVxQSpLvzyPSbuaMgj1lklDPYouMR7zd3Hu\n", + "20rkc9HI4R8hhP0qbTW0GridZR2q8fcHlfyR6vmTEoojnVFj7Rmo6miYfR5XGI85XRzpDbwGtIu1\n", + "U4M4UrnBbBbVq0uzb9+HFgFPzpX4XcJf7iGO1CMvM/D99flsBzOFfNk3DzdYf/Yb0ACiX4CHjcdM\n", + "K+K5SajdJnBl0AnVb89Cn3EdoA+aRO4e4zErw/WXKZJdn8T7E0g5YgdVzFwaL/mbg/fhnf0zKlXf\n", + "a/s2aG6hxwstyemT6Pssy6DVmuq82eSyQ9XlfB5rTSdBj6c0Md4bfWDTp3BTa1jbGRYN0G3r1dPw\n", + "jumOum3ejNqmXkTVRpvs8zgWLW14jGWWE9DSlx8X5XmWBuwK7pPEbaRd8CJ13t5Duu9YNJwMXMLv\n", + "otgo7RTHPgSkYw62IzRBl+ZzycsU5hc1iKqiwBrfr0Kzdc5Gi7X/XMK+auNXF3XCH51cGV0hfIu6\n", + "U85Ejfh7IJwHmV/atozmUtRrphawGTjDeMwvIcfh6y/lsQxubAtvjYONT/v788WodHoHkv/W0pF7\n", + "nga8Kv0f8QMcMQbSR8O+nVBj5y4qsQS1ZbwfLDTYXDwzjMfUt79PRQPfjomFCtKmcP4WrcZ1Rwcv\n", + "A6PtZOASfhdAaJ1pKA+g0vIyKNZYNVy+DflXCEegUZjBK4R5FcH3uiBY4nox6gm0BvXYGRUp4bIS\n", + "8HGo+qcn6tqbhNpxFgEzmdiiC0ueb826TvB3c/yqlrxRyNb+czGqXklD30/v4NTPhyT6fndB0jb4\n", + "7uU8/YWOUfk3Wqo4sKOD0PZkaPfXUjqtWQh0RyOtx6BePFONx+y349oFpBmP2WPv+Q/g7lCF20sT\n", + "VtX0IXCf8ZjXSu06sSL8IjIIeBbV775ujHksRJveaI6QysBGE2TMqMiEv6iEOHrXCiGx1Rh3J7cu\n", + "+B2o59ta/cK95xqO3FANkvar3zbERwF0G4l5BPlXCEcCW8i/QphTUMKxslrZRBPiSCJafvFeNCXw\n", + "w2gmyYGR3os40t721xmViH8HOjCt1UPUaNOM+jNh3H0wzZceP2zqZ0FVVI+hTORH4EzjMTsgIOq8\n", + "2no4mAC76uTpL/R8PWsN1KoDb1bxX+hOMKcCL+h5KjCciNYcGIDWMx6LMoL/ACcaj1lix3gecIPx\n", + "mBOL84wigThyJfp8L/DZM0rtWrEg/CKSgOpu+6ES2hTgfGP8RioRqYnq2gYaY1aKSF1j8n6kFZXw\n", + "F7Z0jv71rATV/Rno9B5U3QhVN0DCroMkmNXABt/W4g96D9lEk3q50HQbZC/QPqKZ4jjasGmGmxM6\n", + "QG0/IQzL7R069TSxXdlEAnvPpwD/qrSHxj3GUOWn32kQUIimxPcijhyPRhdXB+7GO/AmGKUSuBy0\n", + "OYegsLxDlgE8i1amEtR3/ma8g94tLJV0qBgVqH0/9OqisuQBtAbKSWHHYVU8/VAmcC6afvprlBGM\n", + "R6N5Ly+p6qyosCuOR1E7xKmBtRtK7ZoxIvw9AI8xZpD9fTeAMebRgDbXAw2NMfcV0E8FJfwBS9mM\n", + "kbDieNhTndLKpX9Iwqo7T5fWO+tBbl3Ye8U4Yz7pHdi2LFIZlBUs4WlAfmbQLmEvdbusJ7HdRui3\n", + "WP3TofzdpzgiR3/Eb7W70nVRbXhyNJxt/XQiuRf77E4DHmVHwgE+GVSTZd829bcoWupn21cK8BVK\n", + "qQ8wrcYYvvtnWw6+0bI4/RU3Wj1oDB+hK5gDKCPoAaxFDdKXYNVChd1LcWFTX7+Pqr7OLizuImrX\n", + "jVHpxSao65gPK1E9YiBaA5VF5Cf0oTxnjHknwuuWGSJT1dgyfpVzofuzcM5gWN0VVq5pYwNT5hRH\n", + "d1v4WLarQXRj26Azd+YL5V8Bw4ZAenAqg6KWrIsn2Ge41m5jA4+dniq/3F2b4+fUg4QAh9LiFOOO\n", + "BxiPMYO9kvvxXJjUFPZV8h+L5F7ss/taHBlB6oFLuWjEY6yss47vj1nG2sqbixMlblNGDLBz+2u6\n", + "/D2QRu/t45u5q9nUYBV792wqSn9q+M1Ey4sWO1p9JXDQeMyTwJOWGZ2M6tvfBuqLI2NR28Bon0oo\n", + "Ethyl1+jGo+zy0MKlEgJf1GIVmU0X0lfNIHYRBGZZIxZENhIRLwBP3OMMTkRji1ihFHVpItkUrRJ\n", + "aAnxvqrw7vdQeSe0+gmOGpKIWvpFHBkBjATG+nSjodBYanu6kXRnCnWr7uQg8xjKDr4MGsuKYTAk\n", + "Pb+ktDwfMQ+uH1vWqQzKCvt2sqPnTugZlMdyhxoByxW2w26A7kEOmdG4FysFvyGOfECrzTdx7Q93\n", + "oIbRP4prIzEeMxtIF0cup/GeF7hmYl00knYcaqMpfDw6p0syF1cBh4qxWGb0nThyHyr9+zJz9gcc\n", + "cWQHlgkAP5UgPuE44HO0ZOYzpe09ZO2lvSPuJ0JVT3fAG6DquQc4GGjgFZG7gBRjjNf+fh0YZYz5\n", + "NKBNXKp6Dqlq6s2G/SmwtQWYBIqqqiloyYp39kjUxTHbbt2AiehkHwn85ZtEmSLZnUj65B3ZU9UI\n", + "JB6Ec0lnBM+xgxfzelxEIa9PRUKskrSVBsryXqxL6D0c4NrMyez7JYdaNfboseLYFayh/lXUDXQj\n", + "sC9hB1s6fM+eNjPZsSPKxnZxZDAw2HjM2UH7U4HFqOF3vt0nqMurz0jcAw2E8zGCKQWphcSRc9EV\n", + "8pXGY/Kl4C4LxErHn4gtpoDWIp1MfuNuW+AFVJ+cBPwGnGuMP5Iwfgm/1ZkPvA3afwrV1sPWlrBj\n", + "0yZabvwf6hLn21aEik4tKiG2vu59gSyUEexBmcCIfg9z6x3N6H/7APjXeDh3tp7TlYFMpXqFL7oe\n", + "KWKZpC3aKOt7ObGu5GScQK/v2sBjY+DyP3R/ce0KNhXz5xiOqrmOPY0qkVzlINz1C/wwh4VfHGz0\n", + "7haO6hGp95vNivq08ZjuIY7dB7Q0HnNFmHNTgBPwM4LmwE/41UKLbTsB7kPrGZxuPGZGcccZLcTS\n", + "nTMLvzvnG8aYR0TkGgBjzKu2ze3A5Wi5t+HGmGHRGHxpI5+fceIuqL0Imp4/ndNnfYjaL3xbbVSi\n", + "WBBiW13MjIs+SSQbOJuDdKm6H86fCff8Aul2sdybXoyj6mFZictF2cCXvG1mfViTBgMW2f0l9P7q\n", + "cKz8vrofnXMrw7kzYWlt+Ku6sOnXY/bun/5zFfb7zBUl836z+vZfjcc0DXGsNpq3/2jjMcuL0FdD\n", + "/N5CA9BcQGPRlXpV1HOnxPUEogE3gKsUUBzvAht5mUFeZuDb0tAgmVBMYW0ovaA40qjWFN7KmE2f\n", + "GjvYn1qfqrtbw/TWUGO3ul+OWFhr919r659rdsz7Gsqnv7qLskdx5km0vb8Gi+S8m0CvO/rD8C5w\n", + "+wQYsbQ103q0hSaTYcIdMPH/fFcptlBjVUs7gaqh1DTiyONAkvGYm4vZrwC9UANxFSAVv1poDFr8\n", + "pczTj7iEv5QQpVz41QnPFJJRKcTHCJYB3ar9xblnfsn+d3Op6evnX0B/geoN4dI2CfvmHm3WHqh1\n", + "sAaQkzqf5dmjOPWjLbT0tS9P/uouCka0mHpxI7ajbVcIZCQrq8P/DYCvmySze+QnqkZtMhmm+zQx\n", + "JStYL46sAbqGyktkff5nA22DI40L6bMT6rnzFhr9nIyqhfqjq4EW+NVCY4zHLCruuEsCl/CXU9gk\n", + "Xa3R1AXnoJMoN2EPNVINiRmb4fZfNYUvwCmwc2NLUmosZXYCrJ7fhLeWDKFS3b94kiY0brATPv8I\n", + "2lgv4vLmr+4iP3zE92LIGI264k2H3EXw+CxjnOL05SO8exNgcwo0tH5kWbAxDWaHYirRtCuEYiS1\n", + "09vs3pJFMpuOhJHPwdZW9kjJ4l3EkSnATcZjJoU5/jKw2XjMv4rY36nAm8BQ4zEfhmnTgLxqoVzy\n", + "egttheivymPlx+8iQhiP2Wp1j3ehOdT7GI/5bbBIzssp9FpQB+oF1MFKFRImnEelrY9qNsYhq0if\n", + "6OXm9rDgA6HxtMbQLMAhrTT91csyHcXhjGYw9GLI+KwyPLfv0O6qV8CdmSJTikM40lRS5Z1O8G0b\n", + "+OIj3X8c1PWqKoMhkJ4pgq9f+zcq7zWUGzGLtk/ilYEX071NOld3hd+GwoTFi9mf3w25iFiJxhiF\n", + "wxPAZHHk8YLcN61651Y0cd7p4RgJgPGYdcB7wHv2vEyUAVwD/E8cmZmygiV9WnLSV8tpmuiPvM7z\n", + "rMsKLuGPIcSRjugkTEcLaH/p0/dvh911dkGdoMVquiF5V8BbGw4Z2XDTdtidYKBbUKmK0vJXjzzG\n", + "ITYoj3aQNEgejRJ9b2+omwvXT4E3DVVPqsMz4sha4I+iOBD4YgHOnQ139odlNTQ//M4EOP9MeP1r\n", + "GL5P5xRRIvbBCMVIRDKn8Mu6m5jbtSanPteK47ekUKX46giRzGz+2egYNtXKFG/WkFDCiPGYxeLI\n", + "SLR4y6Mh+9H6AS+ibtbdi2IMDujf4K+N8JQ4kgycUHsjr60eSNNG1WHl05B0wP/9UkrPOhxcwh8D\n", + "WD3jA8DpaCrCV4Kj/UJF1l4Buy6FlNf3wEGBSvazSIWUOfB42UbiNhsKwzPo+QSsPRoW90eZQHaZ\n", + "T+KiwqdmeEXI8MVDxEriKg62w27fh3reLLjiDPi4A7zxFVQVqqGpAmqLI2OA71Ed85pQfR2aV3vJ\n", + "uGQGvHIsyI9wygH47wE4/Xz45gNI3Ve2kc3BAVviSBYwTByZBdxiPGZZYX0cEkbWZjSn6kbgiYwC\n", + "hJFHgR/FkWHBtX/tCvxT1Eh8gvGY7RHdm6YY/2GwyPKPodWWZCX6PsQiirxS4U1cRAviSDVxxIMW\n", + "ydiMFpweFirEe5YxIybCzdkwajCMy4ZRC2FOL2D9E36iDyrVh2pfukFKaclkfgDdXoD1mQH7U+M2\n", + "FUIzGDocMkanQ5ub4IVu8GxlMpqrxBW3WAHDpqvOmLYb4ec34R9zocdVsOBotgMd0GLrOagwMUcc\n", + "mSGOPCGO9LMSJ5B3Xs2ezuSnjsH0SdRQ0De+gkY74MzzYGsV9pT9nfph0yh3BKYB08SRe9umyulZ\n", + "IqMGi+RkiYzKFMnOe5YVRrY1heq+pfLwDHXOyNf/bGAS6ot/COJIG7v/dzTTaEREPxC+1VatoEoT\n", + "MYkiN8bEfNNhxH4cpXZ/XhLwciVeVuHlfby0LEk/HSD7KlhgwPi2K2FhB8gu83tqc8xv3FHPUP/P\n", + "wOEYyBoZ6+cdbjsHcnwD/bUp5qxzMfXuwKRnsxQv9WM9vkLevedy2Bn4sP9Zh6UJtzMDL5Pw0j5g\n", + "viXipQdevHj5FS/b8TISL7fgpT1edeowxlDp+sS/qndutacXvcwAjjVfkWpanMv2xNuYipfkWN+3\n", + "vZ9WibcyMW0oe79P99//VbAgcO7DOTlgDLX/MmR+EPCozskJ0+9xeFmGlyr298l4WYeXq0rpHUb9\n", + "+y0p7XS9ekoZ4shAVI+/FbjdeMzkSPqLhyhUcaQN+2USn/TbxfzRjf1Hip7JMRYI5ZP+Vx046WRW\n", + "rOtAGvAR8JTx5M0jFS8I9e5nexmFlkV8AK158YTxmH2B59nyf31RY+NAdKX/PTNqbGBxp8s4bmdD\n", + "XpsKCElckJtSKefxrfet6YAGKf3TV6ErlsgSGXVDGwYOzYKhv8Et1swa6LUWurALFOQdJI78ALyL\n", + "+uY/AJxnPOan0rmL6H+/rjtnnCHAcHsEarj9Khbl36INcaQumlPocbwdVpWnvEAF+aTP9jIVzSd/\n", + "LVr79gnjMRNjNdbiQhxpgRYXr4fmng+ZRsB6nLQBBrK85r9psL8eCftgxDD4/WrbKnsU3pGnoxkt\n", + "KxMHGSd9EcS7EiG3MtSxypHACOJiBVz6PNLabW3ImVPaw8H1JJk+8cr0w8El/HECcaQxGuBxGipB\n", + "vBosgZVXWF3xj8DPxmPujvV4SoLCJC4bgX05cBuaf+oJ4JvipNyIFSxRvwytiPUyWrc3LMEWGZxD\n", + "wju9GHQLVFsHH39ujwz2VbqqAnyMZuEdHMt5XNQI4qIEXB5iEFWezuDs86D5LzCm4zqmbb0ingWX\n", + "UHAJf4xhs//djhoKXwce8QVtRIp4cEG0laDeBwQ4vzwQwkhgSx/+A7gDTbnxFPBOeSgCL440AV4B\n", + "WgJXGI+Z4jsWOJdG073D30ysS/IWuLk5vHAl7KwJ/LYRVlxqC6xXAT5DkwaeHyviH80I4kMqoQuz\n", + "4e9msHAAnPQwvFZ/lDEjy1Wwo0v4YwRbbu0yVMrPAf5lPGZptPqPh6LoAOLIQ0AfoK/NcX5YICBH\n", + "y51ojdoXgJeNx2yO6cAKgR33+aje/y3A28HLyYFz6TtSOY9T9+3gusqcejNs+weM/4/twZ8kzRaA\n", + "/xzYDlxU2jlpwgk60dKP+2sBr4Od9UEMXJcBY+puT1jQcGkqGxodydw1tfl7dbzHeZSYdsbaYh+J\n", + "ZTrWG14G4mUmXsbjpWtpXGMQjDJgJjXBPHii3xsgC8rMewYvV+BlIV7qxfqZx/h9Z+Llv3jZjJfn\n", + "SuqdVcZjboCXT/Ayr0trJhkwW5Ix+yrpPPqWVJNA3z00mGG4rbGh0t6QHlp4ScbL93h5Dy8JpTXe\n", + "UJ4vwd47ET8TBo3K64k2ztDxdMNlJx3al85g8y2pUb921N9vCWmn68dfAogjncSR79HgqP8AvQKX\n", + "09GEL8S+1VZ4vyPc30v3l1XQhzjSD3gEOMV4zIayuGa8wnjMLOMxl6H+5XtQ//L3xZHOsR1ZeBiP\n", + "WWc85hzg3zPPovMtg+DJHtDpOviiLWSzgzTYxbpO8OvtUCUgP0hATIZVcZ0J1AfesivdqMMXa2GA\n", + "eXV133CiHWuxYpiuaHwYDbM/gxoroNkEABbxEc/RthSuHR9wCX8xII40FkfeQNOwfgN0MB7zZWl6\n", + "6/iCPurvhLFvwweZ8NCJZRP0IY5konr9c3xViw4HZIpkFxQoZDxmlfGYO1GPrd+Bb8SRH8SRgVbF\n", + "Eh/MHh4AACAASURBVHcwHvNpz5f4ZWNV+KAjXPIHOL2h+1WwL8Vmapt0K+yuGXDWjl1BfewCzgCa\n", + "Aq9bu09U4RN01qZCzythiw09i6agowbciTdD9igYPA7mbuZgIvxylxZcslidUi3q144XuCkbioAg\n", + "w+1wNOK2WLU5S4rA1A0NLPE/8gr2HUgnZEh+tGDTSnwL3Go8ZnzYdhUsUVsYm0rItA52DjwpjgwD\n", + "zgOeBA6KI08CHxqP2RcPhnkfNuzgqYzPaf5sGzKuOxVO/Qv+XMv6ndlzEhl9QS7b36/qbx26VrPx\n", + "mFxx5DQ0vcJr4sjV0TT0+wSdRjvgtPnw6rFw9y/RF3QCU0SosZeB/H4VGD8v25y2E3aVz/rMhcE1\n", + "7hYAu5y9HDXc/gTcW5ScIdFGsFFrdmveX34h96E5fp6K9vWsS+M4NPbggbDt8vhNG9Thp2SVk+IF\n", + "PrfBS86CNalw4nI4aRk8vJrRo/eYEMFBflhpfyDqCdSm7nhGnTGWk1/XlQEQ+xoJvrlUuSppk06j\n", + "xYYMqpjKXM7Y+lmsaDGE3Jrb2WrmsmfNowW9QysMjQTmANdFi/gHMt4ZDSD7QhjwHIumHCi99COh\n", + "/P9byGA2/HMk53y5Y9HU/fFbn9n16ol4DEGSa9bkCRy3eTCaU+f20tLhlxTiSFOUOD9vPObZKPab\n", + "gHpwbEZdAcNOkMpy8rT9jD2GerMh62b43xiU+GdthLTZkawAYiUp+wKFNqfAhGbwcwsY3wKmNODg\n", + "wcpMBH4GxqPl/QpK6dulx6t88+saGr3WBfovUjsNxFeNBHFkABr49SPwb+BilHF9DTgFZaUUR9LQ\n", + "pHDTgRujpfIMFHS+H0ImW/jv35+Y26PRdzj4/P8TSGzi8+qZc93fzSov45nN35n743Vl6xL+iK4f\n", + "wPEb/An974DaE/exJOFRumz1xDLitqAJZ+uLjkPTDLwQles58ixqvMwqKPgnUyR7A30+XZ8wMoUh\n", + "3TSH+vQr7VGv3aAkK4BYubBaZvP2SKgbfKx/EmN+uIfHgJPs1hWYj58R/Bxs/D5HJCejL70+bwff\n", + "vwstLeEvab3a0oIl4I+i+vvr0Hu6A41ifhuNSQlp2LfV5UYDk4Gbo/2t2CydjwCdy/o7FEduBTri\n", + "7fBpiBTkcbGydQl/RNe3AR0Np8NFg2DcfTDtajh4RkwLmYfJeZ9nwokjLdH4gceMx7wc0fUcuQn9\n", + "8HsWFnyWJTLqIMcOHN2/N9ReCB99jkr7QOqVkPsqHPSZkIpXScmnbtleBdICWE9pSso+ZnOhrXL1\n", + "cMCxUIFC1re9C35GcDywCj8jmFB/Hr+0TKXJd+/Db7mpDKMte6jG9Cq5e7e1W3UfZ61+PJ7SeIgj\n", + "vdHgw9+Am1Eb4L9R+8XzwNOhslXaKnJj0FQXt0Xznqz6bBZa/erHaPVbxGs3B6bzwICpHPh+AHX+\n", + "gj1psKORbVGyCmFRHWMJaafr1QOoNI3mlR+2EKbcAAcrE/sUwzbN7NVd0PziEJxm1gaLnQzcI45c\n", + "HaqXosAa7O5B3TYLjThOg+SbmEsN+Rq+GY6P6CdXOh+O/x2StgW0Lt5z9Hl2XHkGtL0R7u4HvzWB\n", + "ahJ97wpxpKY4MnB7NsOWX0TGWXfBUdXUR9eLliQMFR1qPGaP8Zhfjcc8ajwmG6gNXIjqvM8B5m9q\n", + "Sr2Wn7L9t9xUbiab0UxhHDls2zu5CktPeoCZ1eeLI4NtlHDMYTwmBzgKWIcWETnBeMyNaDGSDGCB\n", + "OHJLYJpne95WNAHcScDj0fRsskzkaeD/CmsbbVg110KO3NYQgKPfgr6B1RpjTR9KDlfip2RZ/coC\n", + "hyIM76wLL8yF3Hr2SP4i1OJIBmqA9uDtsLY4+khx/p+98w6votra+G8lARJIaNI7GJEmqEhTkapA\n", + "sCvYsCHYy7VfvX7OmWvvBTteOxZEsQHBCihVEMFQFJDeOwkQIGF9f6w5yUk4SU5JgXvzPs95IHNm\n", + "Zu+ZM7P23mu9613SEUgFzlRHZ4bSN/+sfByJjKAVmVQhnt0sq76OpXv+hP2JAXtHNuNXYHYD+KIV\n", + "jG0NS6uw70Bl3gLGApPDFQ7z6IetgW7epyvQBJjTYjbNn1tCky5roG4AlT1ct4y4chRG9V0KPFn7\n", + "R67dN6PTtbsOTqlEs0mwq1Fu/YKqveZyx6S9QH3gGZ48dh17ml93OPiRxZVuWJ3ZBcBN6uhGT3jw\n", + "EWxw8GESFllgK6aGsdyZVY/O+/ezeesWbl54sHjcct5AswLorY4uLI5zhtH23SyseyujNzSi0k64\n", + "pSW89z1sOo6ytg9QPuOPEvkTOqAgOlvpIt3ThfEzZvzIOIRepo4uBfpwQJ7kxAqjoGM/aNPD/m05\n", + "0txGh8Jbzn4FXBeq0YccmunSgWSQymwmMZmalWfv2bjj2HV5jX7499F/bgE6rYNHfoSTX2ZZ7e+4\n", + "BViJid9tEFc+EFcu8FhIwa6thrjSX1xxvYS7bcCXmATDHCyQWUMd7dnyGxad/Wdeow/hUfnElcaY\n", + "q+cXTMZj1+beLNx16fIM7q4D3R+BpHW5B1TjOGA7MIGlVa4j/rhPbQIyuof92+2Fgn63koanTHoC\n", + "sASYL64MAdLU0bMxKYirvO3nt4kxN9nEbHr/sJbEnzfTvGM8H7SJyV8oJeK+ZAKvYPVvSxuf0XJT\n", + "EjHXLGVfNfj5fjj9Hg4P+xA5ymf8OX0oWtWvbPrU7QXu/SyZF5fA3qMoSvNe6p+YxmVL2vLdqzB/\n", + "iLf1X8DPs1WndMqzryvVMCP1TiS00HYiKfUrcX92bU7K2suKLdu4Y5G2pTjuYwgqmg2wYOR52Mx9\n", + "EhZg3I0Fp7sCjYHZmIz0DGCGOrqpoPaiEQETV9pi9MYvvT4MBOoBqYxv3Z4/fmnP3pp5D4rr9xMP\n", + "fPsKcBpbK19FYkwSazvDp6O93xoOi1mlKydhs/+VwPXq6NoA6upjXf5D8xmrqbYuCca0Mb18gO61\n", + "WPrzZj2mmPpQG/gLaOUVNi81iCtzmHrUp3zXuQexCZW5bdxJLEh8RFO3PFr00SXct/Lg7pGLQpk7\n", + "0i6F+xZ/yYspM9mdlV6UIRU5cxu1n6zBFX1h4jOQdon3zZnbVL85Kmc/VyoA4zCXxE2RBOTElT7A\n", + "Rxib46Nwj48GXnGRrpjL5lSgC3AQqIS5Bb7A8hz+DvWckYiAeQbpFkzELQszTuOxeztLHc0ORSde\n", + "ZPAk4t/oQeNpsLR/biJR3TO2cMN3Z6mjM0K9jpKAp9J5P3Aj8E/gbXVUxZWYgU+T9k0GrbclwClD\n", + "rRD8LbOgT0P2/Dicx9TRh4upD68BG9VRpzjOF0a79wGN1NGbvL8HYfeiY1mr1JYb/iMUITJ3dgJN\n", + "Qwm6ilywDT6rQZ00aPcx/Oi9cxXP2aX7vqzmnU8w7nYD4JxI1BbFlSswrfrB6ujkcI8Ps61YoA25\n", + "fvlumGzAr+SdzW8WVxKAvthK4CxgFTYIjAUWRMs48eIEx2Mz+oHY6iIOc0U8pY6uC3pcESvKAuNM\n", + "NXss4tYpCcAa7H5/U5bGRlzpgM3+twLD1dGVgVr5K6qb8X9xAry+hJ++e4AG2Iry8WJo+1jMlda0\n", + "NBVivTq8kzHjn+29P9OBl9XR90urH0H7Vm74j0zkvPBNJ8PuurCllfdN7hJfXNkFNA5FJkLkjDnw\n", + "7YmHfNG8cxZX/vpvjK99B0bROy3cYtLeQ/8AVqQ6RR1dFM7xIbZRk1wD3xVjlWwk18hPx/zNhQ5Y\n", + "HlvmFGwQOA84gA0AY7GBIiQD6nHV+2KGPgXYhc3oD2JMnrOjTfArbFWAb8G3wAUYt74KVhvgg7Kq\n", + "DeDd17sxps2DrR9i5SnZPO93k82tB92ugLg1zNrdkpswvaeR6uhTxdD219jg93q05wqz3XlYktrP\n", + "3t+nYtd1bFnKlJcb/iMUOcydIf3h1xvgz3O8b3KZO+JKOtBQHd1V0Hlyz9cuBTq/CW/Vz9169Xoa\n", + "TrmP4X9fDByLiU6dpI6uDauv5h56FQv6DVRHNxR1TFEZuN5svi15mTYNsNm838jPUEe3BDl9OH0X\n", + "bKbuHwRqYUHtscCPgQwhb99jMSM/EBt4pmHGfjywDFvqDwP6qaN/RdO3nHaLWhVYv3piRvcEjFv/\n", + "qjq6vTjaD7u/rrTGZv/7Gn7O++3nc6HfTTZjILO3d+J2zP31KVbzd4Q6+lyUbfbEisy0Kc2Vj7jy\n", + "f0AtdfS2gG1jgenq6JOl1Y9D+lVWhl9E+gPPA7HAm6r6RAH7dcJe4sGq+nm+7/6HDf9ps6F7RxrP\n", + "gLUnwsGzMDp0nhl/BlA/1Nl5QQZEXDkZo21mYb/ZY6FWVPJmvaOBbOAidTSjqGOCBUyHVObv8b14\n", + "b3snKmBGvhOwgVwj75/NZ4fSr0jh0V/PxQaBNlj26VKMj38GFivwG/of/NfrDVTPYz9Sf3W0RMXy\n", + "CoKnnHoXcDbwHvBcWehIeffjNmwgfAR40f/biStXYgys77BqZgo8qo4+HUV7ggXsHXX0myi7H067\n", + "rbHraOIfcDzX01Rs1r+1tPqSp19lYfhFJBZLW++LZS3+Clyimnf57+33HbAHeFtVP8v3/f+k4Q8+\n", + "O/8XsHA9LBkW4OPfDdRRR3cHP1MIbblyNMbgGYol57yB8cevVkd/L+LYBpgBnIEtd0OKCbST6rOr\n", + "Vjym45/VqhATu5uKHReT3j4D2cLWXQ15jdzZfNm8NEa/TMGM0mkYdbMyxg56D/hKHd2UE3yPS0jg\n", + "kiktqbtjM4nZ3UtLobUweJpNt2G/60QszjC3DPpxDJb1WwHTeFrsbf8XcCFGnXUxJtZY4PJIXVXi\n", + "yqVYfKFXcfQ9jHYXAMM8qqt/2yvAPnW0LKimZWb4uwGOqvb3/v4ngGreQI6I/APYj83uvik3/IYc\n", + "/361lRC7H7b5mW9nzFH99qSc/VzZCxylju6JqB1LKpoGPO+XdfBmTldiAcOXsZnYfutXAMuo0vY4\n", + "Os5vx5/HbmRr3fWQUWBikbhSC5vFd2VetTP5qV8HdnyS831ilYt4c/94PjuQUSZaNZ5vuhu5LpwG\n", + "2ApoHPCtOrrVW9mkYCuBfsyvuobx59RFX6rFRedBZg34PGkZWb8WSKktC3jU3GuxQWAx9rt+G2kw\n", + "OxKRPC/wfQNm4J/2PtmYe7A5cCbQh4N8yf5YYXLbv5lZbyUH174Qzr30XI5/Y8SE3yK5vkggrrhA\n", + "ojp6Z8C2uli2dmd1dFlp9SWn/TIy/BcC/VR1uPf3EKCLqt4SsE9D4ANMVuAt4OtyV48hx7/f/RGo\n", + "mAE/POZ9kzczV1zJxBKNwg4ieZoy32HUwkMUDsUKc78BNASuwte2waFSy8Oy4YpYmxQDDF9KxV9u\n", + "5/7Fa8gNwnbDeOuzgOk83SuFjB9PpPZCUIEtrQGo1LQTybVmz11wFh1LQ6fGo1v2x4z5GRjLZxwB\n", + "dMtCjo3n6V5TyfjxRM69Cg4kwPiXQGOBAYdlYW6PdnkJ5gY6iA0An4Tq0oPoRfI8/aiRQA1M1nwR\n", + "pvi6HbfNJ9Rs8wpXT2lKZjW7l1PqrSdt0zA9uCAc4383cLw6elmox0QLL3P5G6BZ4LPr+f/bqaMX\n", + "lVZfctqO0HZGqxESyov7PPBPVVURESBoJ0XEF/DnJFWdFGXfjgB4mblV18DmtgHbD8nMFUK713kP\n", + "sln9W8BmjGd+CLxknDOrLuDpPS2YGVezcnbmtpEJnPKkNTn1XuDNWGLuheSd0GgGNF6WTMO/vsCy\n", + "Omdgfs6ngYU5/l3f4O7E7YVBg62kn2f4EzYk7V90qQVWxZWbi9sv7V3zCeQycNoAP2KG/q5wAtrq\n", + "aKb4BltcZfwIT4bCe3wb7esprjyLuS2mlXRMIlR4q7Z3xZX3sAHvbuBRMdXVkaHEifzlD52eUD0T\n", + "bpgNI7NITrF8hSKNszq6QkzueSh2718CrgAmMjB9BN982pR5d0KXl2H+JXDyvPqctvJDceWCMITY\n", + "RgJ/iyuN1dHVIR4TLdKwQjEnYW5tP54F/hJXuoST/R4JRKQnFuCPCtEa/rVYdqQfjTG+cSA6Ah+b\n", + "zacWMEBEDqjqV4E7qaovyr4cgVj9IjHXtKLq5qYs81O4g6aCCzZ7CxcuNmvrVRgDoq2PAd3gbF8S\n", + "FdvHV7YSSMt7wYWXwLS7LZmo+iro8iKs6QZT74b1iTM046tTC246PZPT7zFdmt+vzNmasY8/Dlbi\n", + "ZMwgzRFXHgNeiCSXwA8xWeHTMWM/AMjADP3/YXLJ+yI9d87gvD8p7+YtMXOAnRizpoG44mcI/VBW\n", + "NMtAeDPSCcAEL/P2LuB+ceVNLAAbNN8AckXyLlwID/SG57uCOwkqzwtdJM9r/z+eVMbrGA/+Do7Z\n", + "8jUdX4cfHjchxFOehCUD4e+D6xkw71VxZRVwX1H0WHV0h7jyLrnJcyUOL2FtDBaz+DVg+25x5UHg\n", + "KXGlR0muZL0J8ST/3yISUTJbtK6eOCy42wdYhy3zDwnuBuz/NuWuHiDAj14psw1Xz27E+BOWsSpx\n", + "abDMXHElC0gIZ7kurlwFPAh0KyrF3Z+AcyAGmh91Ems3/wooXH+CZf8u74PZ0MBiXIdKCeSJDSRu\n", + "akSftGZMXBqbW8c1X7aqMWtewQp4h6wV5M3qW5KbRNUZCxSPA8aro0tCOU9IbYWSdetKc3IZQu0x\n", + "htBYry9lHgD2w+vn7cAQLKnt6WCiZ4EJWQDTGptC6uyqZOytweVYZbaQDYf3e10GPMOCupk0kSZ8\n", + "8zr8eTY0nQxDBkD2/gPEZw8BqmPP7UzggcLyRDyX0hzM9RJWPkqkEFdOAMYAyfncPbHAPOBf6uiX\n", + "pdEXKFs65wBy6Zz/UdXHROQ6ANW8SRblht9wiDG5uw683mc5u/64uYCgaTZQKdRZsbjSG5NS6BlK\n", + "gpW/6tSnbeDJ2oksnZzCDj6BTq9A08nEjalCFlfh9/En0Wf9SUxZX4usdH/gb4FR8fMayLgrt5C1\n", + "fAXU212Qbo9nFC5OWsRL7SeRUXczq/YcZHcQvn88Jq7md+HEkyuNkEO3LAmEo+MkrtTBMobPw27Y\n", + "NGwQ+KqsqJ/54QX7bwBuxqiRTwFT/IYsmI//Glg2NoX3tnfmAoz99E91wnPHiiv12FFhDFKxCxXj\n", + "4hiVCmu6Qr3zVjP8i+rEsgOLB9wF9Jcs/lV7KRknfsdqtrIzWIBZXBmNudqKrQpdEdcgGO33wvzs\n", + "KXElBXP7tItmBRtWf8oTuI4c5LB5jhkHK3rCP2vAw3tBzwoqyCWuHAQqFORHDmRgrG5I7MyrOU7j\n", + "OE8d/SmU/gTKIB8UuFwT2UYr0itVYuY/ZnD7iOr8sac5M6m2U9m05FzSGr6D5lBQh8PSTzlu507m\n", + "d6TOH6ZAmeO6KlpkrJ1ISldhxJuatzbtxGN5aPUlJGDGvidGQ/UHZueXRnA4GnguqP7YIDAAM2pj\n", + "gbFqaqplCk/e4nIsA3cnNgB8ro5mF6Rb5DF3LsaWf0uwOtQhM2vEFeH3ao/QOuMuYjSG9zpNZ3XG\n", + "Y/gWrMFWSqnAmfFr+eHcT+h09Ek0f/UkuGIebJrK8nkZ3JxvQtAF+ASbgZeOsXXlCSBLHf1Xvu0C\n", + "fA98qo6+Vip9KTf8Rw5EBk8i9oMeXDoQ4rdD0gZ4dg3BdPYBxBUFYoIZusDZ2cYq0HUYNJzKxh2z\n", + "GRpqmcL8M7wHAL+q1tXnQNvNcNc0q4ClIBOgX0ZFSE02PzBAN47aNoMtNen+iBVh+d6fxxf8mgLh\n", + "H3iyYmBGIxh3DIxrCYuqkZUVz2jM0E8sK75/ccBj2/TCBoFzMK0bv3zE3LIcxDxjfjYWd6mHzVrf\n", + "Low+7F3PMOxxmQL8XzguNo9t9Q0WiB+kjn4prhyPGf77ay3h4YQ61H8uFU5eDY92hw+Pg8Q0lq7q\n", + "TMfALHZx5RcsTvRp2BcfAcSVTsAoLHFL833X0buulm19dC/putHlevxHFNIzya4IH0yEdZ2gykZo\n", + "8ynBdPa9WQQFGQY/A2NPBTjrUpsZ/TKbuk0s6BUS0lTHT4fbUiB1MEyeArOHwnqATnPgsY5wEWRm\n", + "QZ0E474ztTGM6Jx7jkT228NXdz5sbB9w9kOvKT/8wcR7TodbBkCMwmvfwCkfAvA7NoM6Yo0+GNtG\n", + "HZ2ojl6PUWeHY9nBnwArxJUXxJWeUgbVuNTRg+roF+roKRj75nSvT65noIMds18dfQU4BpgPTBdX\n", + "XvOS/UJpc7M62gWjeX4qpry5DHPjPdY8ja3vfw5OL0irAyMmwOw34EA1krBKYLdLbiWwZ4A7/e9K\n", + "KWA29tu1y/+FOjoH+CFhNa91gxcmQL/R0GMC9OsGL7ST4qlREC3KDX+ZwCv8ojGwsod9zhh6gJt+\n", + "EDm0qEihD7PfaG5LgNOXgW+SbU8kvDKFaarjx6sOGK3ac4pqp1kw7DSYPXsNe+tnww3NiP8WTsyG\n", + "owGmNIXTAoiYWbJ3BdUu2Z/X8IdWrCLdKHI89S3Mfd0rvLIaKm5gGkYcmCNWEeq/Ap6hna6O3oMF\n", + "qVMwyu3TwHpx5W1x5WzPFVPafZuqjp4LdMcyu/8SV171AvHB9t+tjj6KaRvtAv4QVx4Xk80OBZdg\n", + "UiADMVfeUcDAuf1pmVER5r4GfT1h7eY74PiPmIs9Ez28vg3FVoS1gJMju+qCIdIuRWRAqsjgSfZv\n", + "uxRvEuZn9wTDv/bXYZCbRLICv1vhRkZCcjgTspJEueEvA1hgcPptNO62nfrOOtIXreD9epdQe/8m\n", + "YLa35PWjUA6/32g22mUG0z9KhFM5KhjSVMdXga1vQcK1c+CNjrb9Tqg8FPZMbpZr+IfBsnkpWRvo\n", + "OWEaNf48yFbfFEhJLaxgTCD8FbdiA65yGCxbt58nMN/4o8Bn4sorYoW9/2ugjqo6ukAdfVgdPQmj\n", + "P8/F2DcbxJXPxJUhwQxpMKNUjP36Ux29FmiFuaWme33pGqx9fP1H4Ws7CSvLWBMzyveKK5WLun4s\n", + "ySsNi4G8CVxXbS6+C84j+4cWuc/0MFi2yoTe0rzB6SJshTIPKztarHV5c0kYE/pR4e38VdEKNPzq\n", + "6MrGC9jg6wl7K8AZl8OfXiWMcCdkJYVyH38ZwZvNbQHeBparVwFLXLkMY0k9DLyIsaUy1dGgLoBo\n", + "K0cVBj/bZ1sCdLwWFr8ElbKhTwXSJt1L67OfYtq+feye24XZGwZwKfYCj1BHO4TbVggVt6oDj2H+\n", + "8duB0Yd7cDdaeBIYZ2JxgV4YxXEs8CW+th2KquNQzH1JxBKy7gBWM6fGj3xz/qXom0HbFxMwewiT\n", + "xX4I+E9hdGTv/JMxH/9RwMDKf5O6vz5XnPQ1i2ssZF2wwjiee+cM4AlM5fUadfQ9//eRSE/knNtP\n", + "wqixDK7qBR99BRuOB1JS8U0YiGWBnxGMEts7Ub5Pu5E+P71jVclWV4M3v7I42XjVYsv4Lg/uHmEQ\n", + "V7pjvsmVwBh19JOA747GtL63YPorK9TRCgWdK5LKUaEgkM+dLeCfkZ/YillzL0bV0a5iImFzsOBg\n", + "G6wg9uXRtl0QxBRGX8cSBW9UR5eXVFuHEzwXYD9sEBjIpioxzH+gGovPDajhACVdqtGLQVzIlsqv\n", + "o02qMv1OK/GZ5Xe3523fSx57FNPqeQCL1wRNJhRX6mH014ew9+JNrKJZR+DiwrJ6vQD1GGyA/A24\n", + "r62PWlFJT/glVcBicANvgjEfwfLXJ6uO7imuvABsUUcfyn9sO5GU+O68W68xtd4dC8fcCme8xoq0\n", + "ndxUnAHe8uDuEYJ2IikDRFJbTuXdBvOoHbuHduTLdvbEnk7FgmazijpnoH9+vOqA4nqw/C4YyDX6\n", + "w2DZ4pNZAkz2klbewzJBZ2LJS/OLo+2CoI5OA07Eshd/FVf+6Yl2/VfD86V/7g2qdfmp/UqqroYr\n", + "+kDzHwP2TCxRV4I6mqWOfsxLKXMZ/zK0/gwuDJSoydu+OjpbHT0DuB5zxcwWV/oFC8Sq1XcYgK3s\n", + "KmLVzf7EvD2fi2nxF9Svg1heAlidhc/XX8lbt9QheUybXF9peH729NwM7IWDYPSncMGl0CXN724s\n", + "0N2Tpjo+4zeu+b4+e89uwryEJaz88iLmFDerJ1KUG/5ShN8tMwH6Jdem+YjFNKuURXKj0RxSkFod\n", + "PaCO3gdcA8SJK096FLpSQ362TwqkzoBb9zahPkbhuxtzRfnVWEvc8EPOvXkCU3vtAfzmrQT+J6CO\n", + "HmBRtfWMfxmeWw0regR8WzSLqniQkcny3jBqAoz5uMj2vdl6F8yF+QLwY2C8IGC/PzGZ7Pewwuq3\n", + "YVnRO4FUOauGr6C4hidD8RUmrX1MnTXs7nslDDsL3jwht43Q/eweCcOPlT3gg26r6bu4gScSNw2o\n", + "I1aa8RAsztCv9iUxdNolZK1rT4/MBvSKJEblnywOFpk0QCS1OJhBpU4dO9JQWCH0cOGnXh4US4Mf\n", + "+RUcqEJcm7+4GHingMMmA/uwINtUceXS4pQkKAreDCXQ114RoyDuwfy9HTW3DmkHSsHw+6GOLvey\n", + "JQdhlMCvMZ2XMqlIVbpY/SIMPxrNLyVRNIuqWNtnZDJZfjt6aPuBPvb+/ixvH+0wSfBPxZXZmDTD\n", + "Av8x6ug0ceU6TMjvVHX0F3HlWLZXSKXjDof0LjDZwRYCw48WaUfAO/ksB+RHnujbc22W1uj04w6y\n", + "uy7m+rMymFcPHpwCGbtDIz6opo0XaQek5GZtb1g1ggr6B6aD1BCjo16ArVKCYTT2npyMsY9uKGTf\n", + "Q1CAUurR7USIavWgqmX+sW6UfT8O7VfbFBi2BFRzP8OWQNuUSM43CCYp6F810VY3oWuT0Lp3oYNM\n", + "jTR4H3xUxscefAg+bsbHZnxcgc/iM6V+P47pOIObEzNo2nk3Xes9EtDP+l7fSr1fXvvV8fEyPtbh\n", + "45Ky6kep/x4MmACDJtm/kT2XJdV+W0gZBksU9KD3Ag2DJW0hxfvNEvBxJz424eNtfDTN95vehI8/\n", + "8VHL2uufSucXlQdjlSt7KklrvXdywIQ8fbq67h46vJPzzh7NYD2hR6J2G4pWvJfshGsYhY+qormD\n", + "KQAAIABJREFUxfC8TcbHT/j4rYh9e+BjOT5OwMd6fCSE2k5/S5rULsPQbfHeBYEOgAl2vWgk/S93\n", + "9RSKxrfCyGTqzgfxqyWMTDbdlvDhp14esw3mvwprk6DhriKplzGAerS/lzAO8z+BD8SVqiWxDAyG\n", + "HGpb3Qu7sPSaKqycWZkZZw4OWGp3oAxlFNTRHeroTZib4J9Aqhck/6+Fatp41fEDVEf3tH9LtzBM\n", + "Ue37V7jft4CLPU94oI9dHd3rsdmOweJcv4krz/mTxtTRl/F0jowWmhTPrFvgnR9NJfb64+H4d4Aq\n", + "Aa6bxrfy8zsJnPwMfs/+Mj5h+dS2O36tw4Fq07lrb2OysCSwOwKSwMK7dkd3YMH2rUA7caVAJps6\n", + "OhnLUeiNESGuLGjf/PDn6WRUNGaQH9HSQssNf6FIsoei979gwK3khogiC6AFBksrHIQ1VWHjHnav\n", + "MmnfgpCHx6+Ozsf0wNNlP382a8prkWYHhscD9wbBppMDfMp5BsFS8e8XBXV0BnBSrSms6fQui1Jq\n", + "yt/9Rb49XDIm/5fgN1onr4ZJzWChlwOc32ipozvV0f/DWGFxwGJxxfG0ju7Hqm2NImanBVtXnQY/\n", + "PArvfwtdXoBh37UVV5rY8xvbmaXT4au6UGV0Ths7sprMy4rnmc29OUEdvRKbQJ2G5RtcE0nGtJr8\n", + "9kVYADrVY7gVhHuxCcnLwF0eMaJI+CeLjXfCqgDDH22eTrnhLxReVP/zD6Dpz9gsAiINoOUPlt5d\n", + "n0VbkvipCF/dIQlc6ugedfT6Nqls+HUQjR871eiWEDprIU9yinyUPzklCLxBcHlvWNU9Z2sscQ0H\n", + "iKTW/4s7j/2WvsVlYKNZybT1cfq5P3LarOVUGL+d5qlweqc43ig3/qULv9GqfABumwmPe9UbCjJa\n", + "6uhGdfQWLGifjInA3YIxgqpy3eQDMCw32LrheBh5/DKyD4wnS/6ga+LbyFc1wIW138Hu+RgHAbx3\n", + "9lGgj7jSNSAJbDAmU50mrlwYruyDJ5x4B3AAmCautC1gP38Vsj7ARiwukIOCnnf/ZLHxLlhd1fb1\n", + "J7KF089DO3RY+Coj81OVfL8CfPxVVyu3N1I6nLahuHyp+HgcH/cXsU81fOwM9t0gmLSqKtrjKnRK\n", + "k1z/X2Exg9xr658KqlRbqVzfQam8+RB/ab79J+aNddinHp13K+hxN6Bz6uf14Ub6CfQN+z/hnNfv\n", + "F/2pGdppOHr+YPS2/miTAezAx9X46IaPxviIC+0Z6J9qfuz+qaXtRy+rT3Fcd+DvuD0erXkPemFN\n", + "VoT6O+KjPT6+xscKfFyPj3lcVfmtYHEFGnX9hWGdlSt7KTWWBTw6DyhcszRnPx+X42MWPmIC2hF8\n", + "nIGPOfj4FR99w7pXPirgYws+bsPHRnx0L2C/evjYio9hXlsSyvPeFlKaDuCvFmeycgBMCLx/kdrO\n", + "clZPIcgT1d+VmMBnDeO44ud2nFdsRR8aYVK0hSGGAiQb0iGz8S746Z28gj6hLQO9GfzOJrC0P1x8\n", + "Lrz3PWQV4Mbq++smZl66l/QPc76vxKV73mRh5f2xsKQmtNlsK45QS/QVBL9v+KILYW59SNoHVfeR\n", + "vC6Gt8WV7+3S2eX9G/jZBaT3asRRyzOg2Q54eiJsSLLZkjYgDiv8shaj/NUSVzYCq73PmoD/r+a9\n", + "pscgfX35slPzs0j+6xC8+Ez4152mOr6dCClwS2ImCZUX0fjri1mU+XJobBTPrXmWuHIqRhmuRLM9\n", + "Z+KbcLs6OirPzmsaZ/HWh9D1ebjkLHhtHhyMAxZugz8DpUNGATdhctTveu0o8K33bF0AvCyurMEY\n", + "YkXm0aijB8SVL7F3dQgmL3KDOvpZvv02iCsvYklm8djs/3v/8/7YqdB5LfRZnvc98uSw61TcyuUt\n", + "QdrAPQNEbl1tmf0RodzwFwHvgQmkM54OjBErsbY4ytM34tBSlTloJ5LSK5E7f76FKgNEUvOnm3vL\n", + "wKPzyzWEtgwMSE754VG48GI4Zyh8nh5MIfRkTuV0Fsy8jvSUS/3Utg5MaziQjOO2VILrZ0O8p4Ye\n", + "beDJ7xseMcHE59IrQnol+GdVNv3alAlAVduNJEycKylw24zzadUrBnZVsmNjFJL2Q3o2MZhRb4C5\n", + "IX7A+OGCvQutsOSwRKA6F61uSuy7FdgzwZRUtzeHA28kw8CoBrZAFCdduPjgxXMq7bI6wxqDDQIp\n", + "h1x3Uf0PpAN7RWoWiyv1NYyiNB6dszsmZvcs8La4UlvzFF9Jz+RgnNV3nnmLZ/QB9s4K7I86elBc\n", + "uRX4Qlz5XAMqd3lJYJ+KK2OBqzAD/itGNz1EliEfxnj7PSeu9AO+8a7zpXz7PYNlI7+B+f2/9z/v\n", + "mXHwU3Mz/JD3PTpqGvVjG9NtQsC24XD0AiJDueEPE+rod+LKvcB4caXIsoZFoCE2+zwEfv7u49kk\n", + "H3MQJkC//PzdPDOqsOUaAnjYGgNj34WhjTO5Zs+OwL3ElWrYLOk6XbfsS+B9/3e9pcIcgFp74LmJ\n", + "ucdsIS4x3BsRCL9vuM5u+/hRC9bo7/pBUccHcp8V2BcHQ+NZPqU5D6+9gN+w8n6XYYG5H7Fi8ZXJ\n", + "HUxsENlatTbSrBoJ2y1DtlI6xO6DLDldXFlNASuOQv7Ou+2R1qfCKc9FO7MufnirwR4udHzDfOnr\n", + "T4Tt65qJK+2AxepoVrgrA3V0k7jyAaa1FFadXG9WPk5cSQV8wDPiygXALero73me5+xK3lHB8xrU\n", + "0VniyreYhMS9Qb7PAt4UV0YBNwKTxJVxgA9f27YFDHQ/AKPElYbq6FxvlZIqrjTEitWod+4MccUH\n", + "XAocLa507O89753XwgsBKW2BK/eW8xmwsRUJf9cw6fJxH9qq4M1wbmIAyrV6IoS44mACWj3V0d1F\n", + "7R/keMGSoGprkLKBfp2cLZWh1c2w5UnbXpwiT4eUFGyy6F2GrngEeFgdfdvr5yhglzp6Q/7jq0v7\n", + "2f3Y0/ETluVsG8zRfEvl2Tt0fqe87YQ+qy0O4blQ9IvElabAS5jU9HXq6M95748n0hWImCyI7/c9\n", + "9/w4lLwrj7yDRijbDlKVrMpWyH3Kv2CWPyZfsno7RSHPdcdvh/pzof5v0OKJ9SRvScdWqn/w6ikN\n", + "2PhLY+qkQZ00SLv4kP7nF0lb0IqPVl/Ms8Ax6ui2iPvoyiWY224/ZnQfxNe2ZRglMutjFMtuRSVE\n", + "epOfO8nmH8w9NpufplRndx3v2zzCdO8Cs9XREd5xtYCvsSD1MHV0v7c9DmPA/QJUb+vjnW7wwiNV\n", + "SD72Ztj6JFyreZ/38yrJlAn30P2X/8Cwc+B3r76XAJHYzvIZf+T4N9AU+FhcOU/DL/tWE1PdDFor\n", + "1r/8izsIp6zK3V6csq753VgA4srvmA7PKkyP/QSMPnoIdtIqY3zchXSqdRNV9AC7N3ZhMbeSwbs5\n", + "A2Ek/uLoVjK558h/bfmhjq4UV87GhM8+EldSGdn8O9Yee7UNUrsTYeh6eCunzCQHr1/Gno3PqaOr\n", + "Q+1LQRAZNIkK7/SgUnqAyBmUtN5O0QiYPWfWMCbX8g+XMa3uraqbx4srVYEOZFZ9C4AO70F2gJpI\n", + "NTlaXOnS8lnqnwZP5ck6XczR721h9v5a3AK4kfZQHf3IE3W7FqN7zsC3YDQsGBqKG0kdXS+uPIW5\n", + "Xs4uYt+dwINSveepdOvQi5taw6ybLXtY87jAxmD1gkd4x20RV/oAHwNfiysXqqPp6miW5zV4Eqi1\n", + "wMf9+Ljtqt3ckplFz+71mLVzPU8EPu+Z+9mTuB/WJUGV/ZHcsbwop3NGCG/pdh1WiefFcGlgFOLm\n", + "gVx3R/VM+DJACiVa/m5R8OIWg7FU8xeBS7SgEnz118RkXP8gsxv1YfLGG5lNNzKYDmwIKCbj+YtR\n", + "qL7C21Z0ElxJCc/lh5cY9znQho2VanPp+lG0v7QffNIDpnSEHQpnzIHBk8OpMRAaMjI5UAUy6kFm\n", + "oIRLaentBEdOvQhSUoNdtzq6Sx39mZ26DNSE2hYGaJUl7EgAXl16K5/NuIHkK8+FD7zaPCMh+aTP\n", + "iAdu9nj6kffT0ecwGefuWALhHoyW+WiImjjPA208n3zR2FknhtQX4I05sLemF/uAgIH6O6CDNyD5\n", + "+7gHSypcibmM/N99g9E6ZwB3+Z/3zCS+mnYdI/M/76vhxewM9q2sBlU8cethBCy1w0S54Y8Cnr74\n", + "hZjm+N1hHl5oYDcw2cuPYuHvhoZpwHaMTbQh2A7iykCumdGeiUk7mH00RpH2YRpcyQ1z8gGqVEik\n", + "8wi4/gS4LMVcJUDZz2rzQh3dxau9KjFqSizdnoPTHva++bwBxG0umezYfCJgQOnq7RSM0LKCV79I\n", + "w3Nt5bPBn7g6bBkbdl6njp54zuP88s4XcOoqC1z60XA9isVWri2Grt6JGdBnsbjB8UAdLDP3Himk\n", + "EIw6ug/j4D8XmsKrR4jY0Qxm3haw3QZqL6FrHLaCDGwnC5skfoHpbbX0Jo53Y6vpwQEDwiygM/mQ\n", + "pjo+oxJzn6jP37/HsMUvmFh0n4Oj3NUTJdTRXZ5Q2HRxZZU6+nGRBxkaUojhLw53RxR4EPNLzgK+\n", + "blldHjt6J9f5/bSz+7KBUzmdOB3AkhovwSMnAlAx3fzVvFWfKr194soQbovtwp9VYOIzsKJXwCyp\n", + "bGe1wZEUz7pOMHIWVAgM25TMIBVUBKwQv/ThBtW08TK88lRW1OwCF63K3/+9WeztuB465nO8eKvW\n", + "xzCCxMv42vaOlNnksXSuACYCT6ujdwDDxJWnsVnIX+LKv4G38bU9PX87+Pgao3fehK0ACkGACywH\n", + "hwzUYzB56Ffz9VOBh8SVdZgr9Vx1dKa4MgloAdwG3Ie9c4OCtZ5VjTlrT6QaIONVhwBIhGWGy4O7\n", + "xQRx5TgsyHShOjolhP1dAHXUKem+hQNxpQfmkzwe2FRxK9/X2UaXlR9SJcZ7VC6pSuasKly7bJ2+\n", + "LzJ4EpVf6UHvB6DRDHhtLiDQsM9uhv94H2+02Mi63o8c+rIUp8ukeBA0mAuUdbD1cIXn3lwEXBGM\n", + "715UkF5cGcePdf5mytn9o60kJlaa8hfgTc8F5N/eGXiMfTHHMv7UWOb/VC938mHt4FuwAlPBbaOO\n", + "bi60nfyEiHwDtVhlvQ1AckHnElcGYmq8VwMLsMIxB7FiNdnAJqCGPxgccNy9GPd/uTp6nfWnvBBL\n", + "mUId/QMrHP2puNI6hEMKdfWUBbyX532sfN1GdVR7vEpWiwpUuef03P0+2kX8seu5VFyJo8dvdbmp\n", + "DWRVgnd+IieVbG3Fn9XREbp22ejC/MWHFw5f18thijYYDfbXYF8WVM8hYNX6KKuaXQNvJJvYWk65\n", + "lLCFED0p7gHAHeLK4IDts9TRPnx53Hq67K7H8E6Q4CcTWTseR38UtkIovJ0iXGDq6F4s7nBuIX0d\n", + "hzECRwJ94tfzU53FxA94nrn9fXxWNY2NmPZVfqwGamOxjKhQ7uopRqijP3gFGvwc/6D+cQ+FunpK\n", + "G97s7Q1grDq57qTqWVR67RMYfpYpBCZ6c5CYJJoB6+iyogafnp7J8hcCaCnDlsHqHGMZjD10OOJI\n", + "d72UAS4APitMkbUwdpU6OlVe77sfJIGBN8CCwXDA75IP372mjq4SV84EvhNXNnqqmIaFLXez8BNo\n", + "8QPsDaxbn9OOS5b8Lc26tGNl0wNRJtONwQoojSykrzPFlR6yn8ktVlJp43FUfjaOFq2gxcWfx2dP\n", + "GN98jPja3Ziv/dVYPeKw6eP5UT7jL2aoFXp+C8vcKyyRqRGFsHrKAFcDxxKQ0CKuyIaa1K25Fz4b\n", + "nWv0ATbW4VhgKpWz27B89QVHxoy+aJS11PERhguBz4rcqzCkH7QVVmZ1iJuI5VT5gPS2havFBoc6\n", + "Og9LjhqdVzAtPRME/u5LPoETizX52nbj+8776V3pZGN0FSVaWCgmAN3ElZpF9PWv015mUXwTaiRv\n", + "h3v62vaPD2bGttzTpGmQ9lcD1Sg3/IctHgZ+j9vFD/1iZWIBCpOHjatHrHTcExh1M9PblgC8O683\n", + "Fa+qkJfZc2kiGbs2MUgdPU8dXVJuLP934FeRPL2+zKywh5atH6Ja0UcVgt0bHqTqJftYVB32TcNe\n", + "HR8woVakhlcd/R5j+4z3Mmcp2o3X+FZmPFaH7+Kg4sVYUneVZGj8brh98HJzvqeI/ACAOjuJmfQO\n", + "VN0Hf9SFHV7ScRUyCeLyWovJiZS7eg5HqKPaOkG+3HkRl7QYQOVXxnlF4jzJhQU+pmDFpMu8RKBY\n", + "KcUPAUe98nfiSmOsdim72rH/81iqLZzFgWp7SZdtpK3L4Ik/D5Oi0eUoPQQGax9LhpZpsD+b59uJ\n", + "aKRsMz24cLx0rf8085vez8GnhOQJsKYrZNagIH2gkM7r6AeePv54ceU0VS3CjZfdAL6HNT6MIPSI\n", + "/1S1YPgLEchojMFkQd4pbKd0yEzaD+NGwbCzof/l8M2HsHuP33Oa6/LyxOD2ASFQTwtH1DN+Eekv\n", + "IotFZImIHKJ7ISKXicg8EZkvIlNFJFjQ4r8OzTK56c+PqDyjETx5im0L0MpvCKwtzDdaingIWAe8\n", + "Kq7Eiit3YiJSrYDlwM701mz+9UrO/G69HvXtPu1RSpTSchxm8KtIAnzWBi5cGHr9h0IxYMODxCTY\n", + "u9DiB7ixHbQa630ZFZX2CYzp85m4UrHwlWlsfXgEYr4GHoGmk6HuPO+7iKrujQO6e3IPBcKfr1Ph\n", + "ILzzBfReDs2HVmBhdT+j8xDa816KIXs/KsMvIrGY1kl/LMJ/icghjJa/gdNUtT1mZN6Ips0jBUkQ\n", + "n7TfxJS2JwTU7rIf7bBw83jp5EOw1Pl/A5sx+dt3sd/pNCyDt4M6WpR8dDn+y+GXEdlTAWrshe6e\n", + "lEi0MiLq6EF0r6lkfvs0jPkYTr8XBg2Gapuzizi8sPMqluSUDrwlrhRi7xIs26DmSvuz+U/QdnTA\n", + "9+ENQOroLmAScFZh+/mZT72Jm9OHOnu/+6Ef+2cNZc/QB6FZyo4gjLL9mLsnKkQ74+8MLFXVFap6\n", + "AON/nxO4g6pOV9Wd3p8zMaP3Xw+/5EKDdHj8+9xwkpe8UuaMHs/3ORrjDE/E6GfbsSSSszBhsXbq\n", + "6LP5+cSl1sewSkOWo6QRWFHru/dNRwqKSUak/V9TqX6xnXFVd3h1HmQs2MEtk08UVy6PQBIFyKmQ\n", + "dSmWJPVowXvuXQfAFq9M8/oTTZwuBxElHI7BAuCFIk11/I964KSfqH3hbGJS98/aNpmpVVcwJDWx\n", + "Zr8FJwRW5qqwlTjs3YwK0fr4G2KRZj/WAF0K2f8ajgBaX3GgEK38GU2n80BMReKDaeyXNMSV47Hf\n", + "4dqkhew44VsqVEigwsY6NFjUjy3ZlRkMnK+OziytPgXtZzEVAylH8SG6+g9FoNP2eVRIPYpfT27O\n", + "2kaLyMrYywQZQRfdBPwHuERcua6tj+MC1T5DeX/U0b2eGN9UcWW1WhH3/FfnZeVengz3w/obof4c\n", + "bK0+PNJcjq+Bl8SVpEDd/wL7GUB7FleaJ6xk7u4OuJetJ3aIV836hDSyFrWmTQR9yYNoDX/IPmoR\n", + "6QUMxXRtgn3vC/hzkqpOiqpnZYwCJBdmdIMhFeJIbrMRbobG+TX2SwKeYNUlwDAsAWR+1TTWn/8F\n", + "sU9WpO2/usOCltD5J7J2/MYdC7PK1ugbPHG3ng5sPRb+uJRogn3liB4lLCOyneN3Tuf46U2BW73q\n", + "WwCIK52AeySLtMSu7Bs3k9r+LPJQ3x9PKXMA8Iu4sk4dHZvn+5wcjrW3QFZDdg2rT+z2mrQ54QC6\n", + "bYQuXBVJgHmHuPILMBDzhoSDFe1+IuGd3cQOuMxUOe+eCuf8TdziLXTKZy/DR3R1OekKpAb8fR9w\n", + "b5D92mOCY8kFnCeiupFH2sdfC/bsi9GxrXLraw6AoHVuo/ptrI5oT3y8j48d+BiNj374aIePzd2P\n", + "4s/MWLTZbeg/+llN1JLqS2TP1qBJtPxKub2xUmVjQDnSQZPKum/lnxL4vX0Mx8eb+LgHHx8G26dr\n", + "Q37uMsxqTC+pmfNAhPXM4qMjPjbj4+QQ9p2Ij4e9/c+K8LquxseYSI7tW4+tCromCR16NrovFp3e\n", + "CE26kYyc80doO6P18c8GjhGRZiJSESO/fhW4g4g0warLD1HVpUHO8T8Df3Bs0EI4IUC4qjg19sWV\n", + "BuLKfZjI2kuYDsgx6uhgTI/kA+D3uAQaV8qGua9b9azqmcXfl6hQd20M51wDn44mt+gFHJ7ibuUo\n", + "BuzAKqO9BpwhriTn36HxWrKn/gfOXQxvnpi7PZxnVh2dA1wBfC6uHFvE7r8B+7AZ++viyk2hthOA\n", + "L4HTxZUqRe6ZD5lZbANomA7/+QoqZkPjnZCZWMZ0TlXNwpToJgILgU9UdZGIXCci13m7PQjUAF4V\n", + "kbkiUmTx4v9W+INjQ+ZD052526MNjokrFcSVc8WVrzHRp+YYh/g4dfS5ALGo57B6s9kV1jMdcg1+\n", + "cfUlGviTg86rJFMqDppxElOa7WRNQC26ct2csOC/nwUkEB5u2AFU99gwrxCkNGM6ZMYq/GOGESb8\n", + "CPeZVUcnYN6JCYHa+UHwG3CiJ0B3KnCLuPJM4eygQ9rahmnuhy3yt6wp712alPfa/lEBPRBPjJd/\n", + "EzGiTuBS1QlYinLgttcD/j8M8y3/zyOa4Fj+Enar4cUFPpZhcZMrMVfaf7Ds20OqeokrNwDDgZeB\n", + "O9Zm0284NCmRQF0E8CcHvQHJl58JF685yJqZi7ZPoffSLGplRKubUxZFzYP9ZqUVyA+8n5A3gfAw\n", + "zcPwz/jBCgD9Ja646miOrElxBpfV0be9RMVx4krPAoKvc4Gnvf3/FldOBsZichCXe4JsocDP7hkT\n", + "Th/Xn8UrXy/m3gEfM9H/DP3SnzOIYR1GrFkezvnyoKx9e9H4qY7ET1tIGQATBsGkATChLaSEcsww\n", + "WKKgGRXQt49Haw9jrzzAdnw8iY9Whd5fH8PwkY2Pf0fbl5L6+OMfL3VCO1yP7q6AFlfMAdqmwLAl\n", + "uXECVfu7bYldb+Bv5v8MgyWldY/997PNjejf1XP7cLjEcA75jXwk42NpwN/P4OPZYPe1uJ5ZLw42\n", + "Eh+p+KgQ5PsYfOzEx1EB2yrhYxQ+pjVrwsX9IXUQTOoPqQX1hSbNLub+2ANUOG8K9E8N57nDx1J8\n", + "tPb+XwUfe/HxCz5Os2cbjejay/oHj6bz/ysf/0s8syFa/V504KXo563QfrG5gfUCHppYfDyCjz34\n", + "eLOsr6OwzyCYpKDz6qJLa6B+QzXIGF5RndteNlVi9ivx2wNs8YASM4L+32xHJXRXxdzrKS3D67+f\n", + "va9Av21RvPezJD74qIWPLQF/N8THNnzUKuF24/AxDh9v47P6JPm+n4SPvvm2xSQM4+PE29j/V0CQ\n", + "OdjAnjPpuKK30mps2JMOfHyIjyu9/9fGxxZ8fISPy+z8aCTXXS7SdgTAHxRuvxHSXjEtj/MWQ9Vs\n", + "4gs6xksV/xKrn7sIuKF0ehsZ/PGP9hvh6AAFo+KJOSTZfaqTBrc3gSH94KTXoHrh6fRRtej9ZiM7\n", + "Qv8hkO55ZEsreO6/n0dvh6UBGpFlGcMpAjuB6v5ELc/F8ylWmarE4JVFvAhoh6nD5cdc4MR8xxzs\n", + "8SbVn/2ZCt2HwtTGtj24fIVHS154IbTxe3rCkoAILMVYBVPmXA00DvH4oCg3/EcA/C9xfJZF+P0o\n", + "6CUWV1phD8wuzG96kVcf+LBFydYY9mqlbjgBnlkHvw2HJr/ADRNPEleme7VZW0LxBUT9v9kd0+G4\n", + "TbnGv7QMr/9+Jm+DZZ7hL8sYTlHwns9M8soRPAncIK5EnalaRNsZGHPnMnFleL6vfyOf4Qcb2If/\n", + "Bu+OhdkNcrcfOrB7k47F51mt3tw9Q50A5DX8aUkw6egz+aPxLVYxLjKUG/4jAOEYRa8QxRSs+HQH\n", + "4E51Dn8abQjVmqJAgCTv/kRYeCF8Hr+M55MvBByMBTUp9j5ZKWfwwUMN6PcJ9JgA/brBC5EYf/9v\n", + "FqPwyjgz/i2uJHPJUbwZ/fUUDf/9fG8vc9+rz9ZQ72cZy2QEBnhRR5dhjMESX62qo5sw5s2/vdKI\n", + "fgQ1/P6Bvd8yuC0g3fHQgd2bdGTUgx8DC3yFTEueC7QRV+IZ3eh0vh1Ylw1Pt6bi8Q2ClwkNDeU1\n", + "d48QtBNJaVJIxqS3RP4XcD3GIBiCVeu59DBRAS1ThFArNabj+0zt25yuY1vBSetg1Of2XQqkjlcN\n", + "m44X+JulC3t/ugHdV4dqQP9QUviLA+JKB2CUOtquyH2Dy2SEXf82Uogrf2DP6x8B244DvgOah8Gi\n", + "iaYPXYBvgBR19FdxJQ4bkBp4VFOg6HrCOecLek/DqzktrvwG3MBTvUaw+8dO1J8DZw+D162+dSS2\n", + "s9zw/xfAq/T1DkbxugDoiFHiTlBHd5Rh144oDBaZNBp6KFZmMsmTphsMk0er9oz2/B7/+xXgOIrJ\n", + "+BdFU/WejU1Aojp6sPBzecXmK+yBg7GQ7VUFKaVi8+LKz8D96ujP+bZ/CXwbXGOnRPpxNvA60F0d\n", + "XSquzADuzt+voiZjOecrYtIRQn9eAxbw1FnXsvurdlTaBS2/8WRMIjP85YVYjnCIKy2AL7CC15cB\n", + "NbFanxeUG/3w4F++C7lGH4rPL6+OHhRXbsSMf6q4MiBwFhkuQhGyU0czxJWdQH2KLPXp+aOTJ8BZ\n", + "18Ki82H+EFhVpbSyufO4egLwGPCJuPJGacSq1NGvxJUGWILXyeS6e/IY/sLqCec5X/Q1p2cBvYjd\n", + "ZRLV+6p6Rj9ylPv4j2CIK32B6djsZBhwANPSf00dnVqWfTsSUbIBZoM3674RmI8ZligClx5jpMFs\n", + "iPWPVEEZI8sIcEkUDM8fvegCeG0ebG0JA26FO7/qIq48Lq4U6S6KEjuwLP88UEdnYL9LdNYuAEUF\n", + "8dXR1zDZ8m+ANIL4+YurrRBgAd72i36iypBicRGWz/iPQHj+/NuBu4HB6uhkb/sdGOUOw640AAAe\n", + "LUlEQVTr4UIOL0cBKGH1yRx4M/+bsCzqCZHP/JPiSVwPlw2At34xFVMgCGNkKXA0ptVUCPzSxCOT\n", + "2dUIpt0N0/5cRudNz5CyoanX163AKOAjdbS4a0oUNOMHq4X4irjygaexHzGC+ecLyGp+AKsfchFB\n", + "BqRibqswLALq03fTOqqOn8L4lNhctxH9I+lXuY//CEBg6v/2iuyfch2x+4+iRuNPeLHtIi5OgvgV\n", + "zag4ewhtNI7j1dEVZd3nchQNz+f/MqZeG7bxFxmQyvlH9WNnY/jhsYBv8vrkxZUHgMrq6P1Fn7Ng\n", + "f7TX39Mwl+IFGONkFPCZOrqz4LOGeD2u/BvIUkf/HeQ7wVa3T6mjn0XTzgCR1AnQb28crKgOrbfY\n", + "9mBBfE8TZxzQE6gaboDZ39bfNeDxU61cZa/lcM7B8AgD4sokTHhxuzqao2MUqe0sN/yHOQJnDKur\n", + "wnkXw5adpMd/xYvd93LRSEjeXQFOvA7qTmXDtrlcc5hqsZQjCKIx/tK39j102PMIIzbFccAv/ngo\n", + "Y0RcuQQ4z1NoLa5+x+Nx34E+GO1yFDAhkopt7URS9vbh2exEqrT+kgXBdI28oKsP6BgNU22wyKRP\n", + "oMdlF0DCAVO+hIKD+J47bgPwrjoaFrXUTxjYUhne7QCftrWEuvgVbFjbhqHAD/77VVCgXqRdCufs\n", + "eIk6e2qwJmkLE5JyWFaR2s5yH/9hDn+B61+aQJfhcFEaLP+EpOZ7uc6/fLy9P3RdA1PmUi/qwtfl\n", + "KFV4Pv+bCNPnL65UoPuWK1hW8QkODEqFwZMhJbUAmqDf1VOc/c5URz9TR8/H8iC+B+4A1okrr4or\n", + "p4aqYumf3PxrG8f2hkaF5E98A1QAIuavgwXxHz4NltWAlwLuVEFBfG8w/hIYJK5cGW5bALX2wJ3T\n", + "Ycab8NvrUGkL2zFX0gZx5V05s6aPuE4vGjd/dA/7t9sLIu0c6PYCS55vTkKN6uy8OdnbHlV+Rbnh\n", + "P8zhT/3PjIO3v4C7pxnrJNFeANLqwKRmuQ/wYaOnX46QEWD852Fsn1CM/63AGk7Y8X+q4weoju5p\n", + "/walCS4FkiOtW1sU1NFt6ugb6mgPjEq8CiMcLBNXHhZXWhd2vH9yUz0TdngiJMHkD7z79BhQpMuq\n", + "MEw/j7mPn0TWFx9DQpZtCyGIPxX4AXhSXDkj1LaCEQb+vZNlCT9ylzp6CkbtnU2jrFu584ujOX8I\n", + "VNnk7TkyGRrfDCOTWdsZktbDgcqEKfkQFOXB3cMc/hlD37/zbs8wBg/tNsHc16DKgZzth6sWSzkK\n", + "gRfwvRkrnpMqrvQvyO0jrjTE9OS7heLyUEe3iyvZQC1gc1H7RwN1dCXwmLjyOJY5PgT4XlzZgBUB\n", + "+lgdXR94jH9y03YTnPlX7vYCJjGjgYfEle75efWhQFzpRAeG1U3l9msyGBhGEP83TP78ArJknDTv\n", + "vIAVzfYXJfFdFGHA0yQaITL4AhJf6EGrLyAzML6daEVXdjaGZWfAfr9LL2TJh6AoN/yHOQrSIF8N\n", + "7w+HISMh2W/0S0OLpSw15v/bEYbxfxqj7C4J4/R+d0+JGn4/vAHpd+B3ceVeLDg6BHhQXPkVGwTG\n", + "qqPp/snNsVvt40ewSYw6miWuPIENfGEZfnGlEaanP2zDdP0Su8+hYh7Qlsdb1eCYers5/69uvDXa\n", + "09/JmzuRH6Hx/dMzyagPs/OHEDK8t1ssqe6AX8ooukp05a6ewxyFaNi4JadtExx+X+wE6Dc6Si2b\n", + "cgSH5864GTOah7h9xJU+WK3rR8M89VJC4vIXP9TRbHX0B3X0aqwC3JuYrMhqceWjmQOZMTQmrPyJ\n", + "d4EO4soJofbBK334FfCiOvplBNewG1hB7Wr38sdP9Zl6L1x0PshBisP1kkdPKgfDlsHql3K2V9zt\n", + "zfijr0RXzuopR8jwU9O2JsCSo8zNlLg/ci2bchQMLzD6EnA8Ju+wy6MWzgP+Ga7xElceArLVUV+x\n", + "dzZCiCu1gEHAEMmibb3F7Eyey9Yqy9i4ugjXi5ez0jUUppJ3L8dgarVXR8oIEldGkdqhIzN+t4SJ\n", + "6isCFDcHT1Yd3TOS8+acvwAqbc7266Z3Y1KLxfy579/RsnrKDX85QoafmjazIdw0EBbWhgbpkL6D\n", + "LZta8DLGTJkP/F2ULkw5ikZ+448J8PUAzgzXeHlslL7q6OXF3tFigCc9cinmDorDqKGj1NG/Ctg/\n", + "Efgb09P5s4hzP4rVzD1dHd0XRR/v5I/6t/LZuiaHflvyekaeWNtwr2C8bYvQdpb7+MsRMvy+2C5r\n", + "YfYbkBVjnOQLmrNmUwvigKswPnotcSWN3IFgPvCHOrq9oHOX41Dky/D9CWgGdI5wxroUGzgOS6ij\n", + "fwMPiyuPYMygy4Ap4soqLB7wiTq60R9jGgTx649i54JujAAKZNmIK1dgmbddojH6Hn6jxaYMc73k\n", + "V9uMzvUSIqoAe4rjROUz/nKEjJClaF2pjlU0ah/wOQ7YTt7BYD7wl1cFqRwFwKNhLgEqAW0jkXcQ\n", + "V+phg2/t4u5fScGTRO6DDQJnx+1iaddJNEr9g7p+QsPF1Tn4ayLXLFut7wQ5/lTgc6CnOrqwGPpT\n", + "HVjNQ60vJrvZzZGqbUbR/hrgZHV0Vc62cldPOUoDoUrR5ofntmhGwGAQs4+uxFK/yg72xG9l154K\n", + "jN/dgtHAfHV0Y2Cb/8tMIo83/iqWJNUe6Be2vIMNHulAw+KQVyhtiCtVWk9gWvOjaT+1CXz3HnRa\n", + "Z9+dWpeVv2zQZvn2bw5Mw3z6EVeqCkQ7kZSldzKm+yj+iNvA9tJ+DsWVbcAx6mgO96nc8JfjiIJ/\n", + "9fB8BZL/qANpdeHphuxceiyrshNphOUpzI9fT3rHOZw8Yg11W2+x8pPDYel0uO1/wfiLK5WwldEd\n", + "GCXwZeAEIjP+vwND1dHfir2jpQB/jGlTFaiWCZU8qbZejcmadA2N/JMFjwk1DXhDHX2xONr2P6/b\n", + "B5N8wUK4JC2657CoOgpBj3FlH1BNHc3MPU+5ZEM5yhDhSs/6szVTk2FEF7jmN1j8NdXOeJq1WOWw\n", + "jsCz9ZbTtmkT6va5EqreB21ugowLSN7dj+fElYHiSuOSykg9THAnsFgdHef59m/CxNEmRiDpHKI8\n", + "8+EJf4ypzu5cow9wYD/rgH8AiCuxwMcYx7/Y/O7+5/XE9fBbfdsWvLh60citozChH7Ef9IAJ/RJo\n", + "P6a9VJ9d0Hvjub3igGjjFEB5cLccxYBIpGf92ZopS8DtCSM7wrVzLFvTM3BrgDWDRe4dBS0X1IY7\n", + "z4AFdUz3hEokYLIF7YF4cSV/7GCBV0QbiGyGVVbwu7b0KKrFXkvH+l9xHY59p45qQMB3opfkFarr\n", + "psy4/MWBgpIZ11XkYeAZL7HLASoCtxZnyVH/83rFPJNP8SMyiRSvjsLRE6HXg/DRV+zd/WFCAzp1\n", + "bMzsFwp4b6oAu4vrmsoNfzkKRSj+df9saEMi1N4NsWqzoRSbDQU1rv7ZW0IWjP4Uul8NXdZAxsa8\n", + "2Zr+/dpuhtRR8H0LuOsM2CIkAT51dLq4UgcLHrcHTsbYK63FlbXAfFYl7KVdl96sG1Gf7S1AYygq\n", + "27KsEDiInt8XnKn8f3vnHh1ldS3w3yZBIo+AgIKSKEIUIeSqVR4qVR6KJLrUakFRS8FHbVcF69Ki\n", + "0ktnxtZl9d5eRfF6W9/F+ojV6xMQUFHrRRQVBRQkqSiCgqAgSAivff8438CQzCSTzOPLzOzfWt/K\n", + "N9+czLfPPPY5Z5/94ItlTOkvsi4izD+s/CMjfONR/tXAoFTKn0qipT9YzEFvf7V60EXcs3snZdUr\n", + "GLRqJ232lCW7Ulf4e1hUx7jWvBQpXqWz6pFQvACuGAwPv872ze0a+t20A35o+r1ioKq+H04M/+Ww\n", + "Y/+jFCqugJUKGj6ugJWlUBHZbjTMV9BTx6Ntp6AnXolOOBftO4wqgpxOkG6NvfajZWiHSewo6cIF\n", + "jckwQagqHM2fCbKaIJUE6V3vOxUknyB9CXIhZxdVM/Zs5TeHK7/qH/FS5bP8fo/rHqNgtoLOLEFL\n", + "JqI1+U7YcqgnK0GEIPcQZAFBOjb22gQZTpDX/e5jsg4orYArVoIqR76iXH+I0vX8L6C0Itn3ivY9\n", + "vByq6v4W4pN71OyIl1FKZiqtduiZnKgKOhrmR/nsjiJIdf3XQpvTH5vxGzEphkn3tqLkvDFQvhJG\n", + "fwz31dSfkYRnQ68/DN+3cRlDlxwCs4+kNTAVKJOQ7AKW7D2CLNkxjckV3/GL9nDg1iXU1J6KVE3k\n", + "AgnJM+ElbdQkV8rdmyt1poRkKq4S2UIJyd+APxIsHeyW0qP3mnSg32qo7AVAfuQELbFEV6kgbFJ4\n", + "7hi4e5bbzIboJgVv5l83t09DM/+MNvXUxzOZdPkULhgL/3gCNgwrhoqYK83mktzqbBGVzgCqyunN\n", + "GCayHKi/ihDpX8ERA3/HOcu6iZTPToaZMmHFLyKjgDuBPOB+Vb0tSpu7gHJc8MF4Vf0g0fsaqSes\n", + "hC77AP5eBpPPgNM+h3UrOUJC0lYDug32t70W1sLJq+HB1VR3fo9Ja5/Smd7m62E4c0wZLvr06pXX\n", + "0GclrGXfgLACZ6P9BS6tLxA7yZV3/1skJPcDAXbJZ5xasIO3nu3K7jZeqyt7w+f7Fui7IvVnYomu\n", + "UkF4EL33RZd+O0wDueJjKv+6Zrq+eUz/ZCpdIj+7zMYzmYy4CV77A6wa5l1v1zYVd4u3uHpjeGkY\n", + "yGf4zZ2h3/FsOXAiyzmLrfVyFO3dCN4zoYRt1+Hy9CdupkzInVNE8nA/1tOBNcC7wFhV/SSiTQVw\n", + "tapWiMggYJqqDq7zOqrmztkgfviyh3PzhB9vOQCePQYmDmTD5iJaAy/gQuvnlQYZ2VT/fs9T4Sj2\n", + "DQhluKLWxbg6o+8SuUqArxra3JIeJ73JaQcP4ZClMO9WWDYGpz5PXQR9OtWPtoxatMRX4g2Sq4s3\n", + "uE7HvX+jSoOcEmXDverJ0bTZUkqFBnRpSjuSBtzsd9aZ5NWyb6AHOg1dqt/NL/NPsvhpLC5mbx97\n", + "zYUht8Hf5nnPuBQRfqVsGAhUqboaryLyBHAu7kcb5hxcNj1UdaGIdBKRbqr7AnSMhklSweYmU9eL\n", + "osMOeP0jqos+YtLmIO/hEmwFgEeWBXlqGdwMvB2v54EXsfuJd1SGr0tILseZiN4BjgYqcINCKwlJ\n", + "5ECwBFiqAd0CwNri3TxeCT1fg7LHPcUP0P0HWBBwJoD0Rls2leaaFCJm/ncDL3dry9b7tlFSmwcv\n", + "HQ3nf+I23Jf9H98sKKUEyHjFv9dksjtiQM8fv4aR73eWkOQlWpQ9HTS+ivBWNevLYH4w4rq/+fh7\n", + "AKsjHn9Jfa+BaG2KAFP8cRL2mgHYLfF5zSSDOJTQdGB6RIKtB4E2EpLHcQm2mhUmrwF9QEJyEs5D\n", + "51JPqQnQjX0rg5NwJqG+EpL1wBLOLipm1ROwrgxeuod9xpKtNZ6Sb3GKPhrNNSl479NE4O5F4xl3\n", + "x/vwXyfBcV+7PZoDd0FhLTtIchlGvwibTPYb0Hevupt+W6bg0j4/6bOISWCLC9ba2t0de0nMTJmo\n", + "4o/XTlR3KeJ/uHAGEba17xE4YCq0Uvcj3r6HERKSz3H23+3e3+SeB1mwDF4FamPN5Osk2DoWl1tl\n", + "joRkA/AY8LgGdHW0/22AScBC4HLgfu/eX3vH3HAjL2CnN1BGt43nUzi5G10K2lG4GjYeDd9+v5W2\n", + "67+SkFTgVghfNrYiySSf/yjkA4u3HsQvQ6fBM0/C8FX7nqzZzfdk0QZvtAFdQgKuClhlMn35/aHO\n", + "RjCQjKRwiSr+NTh7bJhi3Iy+oTZF3rX9EJFgxMP5qjo/QdmyhvCGXyuFXTfDzjyoyYfzCnhz/rVc\n", + "jvP4KPD+NnbeEejehPbh89ZeyHg8g8Z2XGHsLsBYICgh+QpnulkAbIzjNWpwq4hXJSTvaEA/ivbe\n", + "eMv5T73j6b25yw8obUePNXkM2LiQntvAef+U4VYkS6lvLtoEkVGVkT+0lunzH4m3X3Ip8HuguvNb\n", + "3NC5kKlTTqfjyzOgY63bK1jZi8eBU/2VNuXMwhWqOQv3PcxY6q9qqg6E5VVQM1BEBjb3dRPd3M3H\n", + "be6OwHlnvEPDm7uDgTttc7dpNHfDL5l4SdbCA0Hdv42dtwf64jJ2HgGsxw3+m3AZJ2P9b9iOKcC3\n", + "OK+wRFcxB+AGviJPll64FcMmYBnv9ziKz27ryfoyWN/fC/aCdORbbw7eimcsbq9lDfB7DegbAKWt\n", + "pGLjufJwzcHS+egZHb9fub3oX5t7bvkfxq+aogHt5afcqUZCMgY32J+c+bP+2PiWpE1EytnnzvmA\n", + "qt4qIlcBqOpfvDbTcYUkfgAmqO6fJMoUf+M0NytmS8PLL3MebjY/COcZ9BgwL1p6ZglJa+AB3CBw\n", + "PU0bcJpy3g5ox/s929JmgNBlBfz1PdjjLYp7jNjGla8up/GVTiImtp3xKilP4Y8GgsAGYKoG9LX9\n", + "2kj/Chg8jYqCEg5bBDNehtrrqhn75OH02dpeA7ojnntlIhKSPGpbfc7/HruW5SXbMtBkFxeWndPI\n", + "OCQk3YAxuEGgF86z5zHqeAZJSNriVpN3aEAfSKlMYfe5urQ545/cNO9aUjfwFOCSJsYzUHTFrZ5q\n", + "ccnIVkRt/1z/yXz/n8ezqwBO+At0roYZc+DQkdsY/87xsapbZQMi/SsYUPgQx7Q/hBlzvKtXVsGC\n", + "a7JJ+ZviNzIaCUlvnMniEpz55zHgsbBnkISkL/AGMFwDuiRlckS18afH59+z0zc0OAwDxgG7cYXD\n", + "qxts/9nBI9hzXBfya2BzMdR0gR7vwJwDN3HZ6xdrQGelsj9+IlI+m7znzmRSCTz5NKwd4D3TMk12\n", + "zcUUv5EVeG6bx+FWAWNxZoy/41LtDgOmACdGZt5Mugwxil6n6n4NyuLej7OBEG6v4/fAi/GYhOqv\n", + "XhTKJ0Gvh3Zw8A//rgH9jxSJ7TsiY+ZD5WmUPQbburqEaEAyiqK3JEzxG1mHZ8f+MW4QuADngdMa\n", + "5zl2UVZv2jmFPwoXFNcGt3n7bFP6HH31cnk1Vz+6na47ugJ9MrEaVzzENNnZjN/9nyl+IxPwKlGN\n", + "An4G/ASXc/9PwAvZkXfG4Sn803EKvxC3efu0BnRPs14vyuqF4LLWOIeM9cDIbFT+fprs0okpfiNn\n", + "kJAMwAWVfQiU0ohnUKYgIRmGU/gH40w7lalIOyAhKQWexgXCDcSVcdyU7Pv4TUsy2aUKU/xGTiEh\n", + "GQfchMvjczZuU/hIYngGtSTqRQYPX/QKp26owMUWhHCRzinLMyMhORD4DufCegfOrTYrlX+2Y4rf\n", + "yDkkJA/ibP7jvDw1DXoGtQT2M0EULXCl97ou2MWaVnfTb8vkdK1YJCRfAqcAXwDTMOWfkVixdSMX\n", + "mYhLQzwBQANarQH9I9APtxlcAMyVkHwgIfmthKQo/I8i/StEymeLjJnv/vZvsDh88vCKh4y8Hn56\n", + "kcsgOu27fCqH9E2zmaoKKPFWRdfg8iK9LN17j/bnfTHSic34jYxGQtIP598/LJp/f4Rn0CXA+cAS\n", + "VnT4iOfOOYttj0akLUhPcM9eN8NOq2DLoRF55NPrZugVr3lXA150fUiEdW2eZU+7M3mkug3bO3kt\n", + "sy/oKZuwGb+Rk3hmnOuASglJ+yjP79aAzteAXomrAnYH+QeMZtILvbjoXCh9Elrtwnl/HD4x9RJ7\n", + "aXY39dy/eEj6q4FVE5GeWQOq3Du0DV9c0oZLz4SCsMUnXe+LkU5M8RsZjwb0EeBt4L89d8hY7Wo1\n", + "oM8xY/gK7lgNn1wAfZ6PSMSWjhq8q+9ys+hIEk+z22QWd+zAZ53H7W/SKSxg1jRY/hPI3x7RuOXV\n", + "JjYSw4qtG9nC1bh8PuOBhxpuumU7tYXw4Th37CX1s+6oxUPS7GYo0r+CHqddyjmfdYPKbu5quDax\n", + "wD9vrPMfLa82sZEYNuM3sgIN6A+4bJW3S0j6N9za31m36tKZqjPLVSuHur/ptp8XT2LDjGIOqmZf\n", + "TaT7SmD7nhaxGjFSjs34jaxBA/qxhOS3wFMSkgGx8vm0hFm3v3QooLYQFlwH+bWwq8C7njm1iY3E\n", + "MK8eI+uQkDyMW83+vKUGcflJruSxyQWaqzttxm9kI78G3uXjDn8WKe+XobVzU0hq6rgamYPN+I2s\n", + "RAYc9kuGfzudh97L45tS76r5pIfJhTw2uYClbDCMCETKZ3PchWdyyu3w13dhZzvvGTNnGNmDmXoM\n", + "Yz86FLB4vAtEyq+NUPzmk24YpviNLMWLkH37N3Wum0+6YZgfv5GltJAIWcNogZiN38habAPTyHZs\n", + "c9cwDCPHsOychmEYRlyY4jcMw8gxTPEbhmHkGKb4DcMwcgxT/IZhGDlGsxW/iHQWkbki8qmIzBGR\n", + "TlHaFIvIayKyTESWisikxMQ1DMMwEiWRGf+NwFxVPRp4xXtcl53AtapaCgwGfi0ifRO4Z0YiIkP9\n", + "liGVWP8ym2zuXzb3LRESUfznAI94548A59VtoKpfq+pi73wr8Amu4HWuMdRvAVLMUL8FSDFD/RYg\n", + "xQz1W4AUMtRvAVoiiSj+bqq6zjtfB3RrqLGI9ASOBxYmcE/DMAwjQRpM0iYic4HuUZ76XeQDVVUR\n", + "iRkCLCLtgX8A13gzf8MwDMMnmp2yQUSWA0NV9WsRORR4TVWPidKuNfAiMEtV74zxWv7njTAMw8hA\n", + "0p2P/3ng58Bt3t9n6zYQEQEeAD6OpfSheYIbhmEYzSORGX9noBI4HFgFjFHVTSJyGHCfqp4lIkOA\n", + "N4CPgPCNblLV2QlLbhiGYTSLFpGd0zAMw0gfvkTuZmvwl4iMEpHlIrJSRG6I0eYu7/kPReT4dMuY\n", + "CI31T0Qu8fr1kYi8JSL/5oeczSGez85rN0BEdonI+emUL1Hi/G4OFZEPvN/b/DSLmBBxfDe7ishs\n", + "EVns9W+8D2I2CxF5UETWiciSBto0Ta+oatoP4HZgsnd+A/CnKG26A8d55+2BFUBfP+SNs095QBXQ\n", + "E2gNLK4rL1ABzPTOBwFv+y13kvt3EtDROx+VKf2Lp28R7V7FOStc4LfcSf7sOgHLgCLvcVe/5U5y\n", + "/4LAreG+ARuBfL9lj7N/P8a5wi+J8XyT9YpfuXqyMfhrIFClqqtUdSfwBHBunTZ7+62qC4FOItJg\n", + "/EMLotH+qeoCVd3sPVwIFKVZxuYSz2cHMBHnlvxNOoVLAvH072LgaVX9EkBVN6RZxkSIp39fAYXe\n", + "eSGwUVV3pVHGZqOqbwLfNdCkyXrFL8WfjcFfPYDVEY+/9K411iZTlGM8/YvkciBTyhw22jcR6YFT\n", + "Jvd6lzJpcyyez+4ooLNnXl0kIj9Lm3SJE0//7gNKRWQt8CFwTZpkSwdN1iuJuHM2SA4Gf8WrCOq6\n", + "rmaKAolbThEZBlwGnJI6cZJKPH27E7jR+74K9T/Hlkw8/WsN/AgYAbQFFojI26q6MqWSJYd4+jcF\n", + "WKyqQ0WkNzBXRI5V1S0pli1dNEmvpEzxq+oZsZ7zNiq6677gr/Ux2rUGngYeVdV6cQItjDVAccTj\n", + "YtzI21CbIu9aJhBP//A2dO8DRqlqQ8vTlkQ8fTsBeMLpfLoC5SKyU1WfT4+ICRFP/1YDG1S1BqgR\n", + "kTeAY4FMUPzx9O9k4BYAVa0Wkc+APsCitEiYWpqsV/wy9YSDvyDB4K8WxCLgKBHpKSIHABfi+hnJ\n", + "88A4ABEZDGyKMHm1dBrtn4gcDjwDXKqqVT7I2Fwa7Zuq9lLVI1X1SNwK9FcZovQhvu/mc8AQEckT\n", + "kba4TcKP0yxnc4mnf8uB0wE8+3cf4F9plTJ1NF2v+LRL3RmYB3wKzAE6edcPA17yzocAe3A79B94\n", + "xyi/d9gb6Vc5zvuoCheoBnAVcFVEm+ne8x8CP/Jb5mT2D7gf5y0R/rze8VvmZH52EW0fAs73W+Zk\n", + "9w+4HufZswSY5LfMyewfbpX2gve7WwJc7LfMTejb48BaYAduZXZZonrFArgMwzByDCu9aBiGkWOY\n", + "4jcMw8gxTPEbhmHkGKb4DcMwcgxT/IZhGDmGKX7DMIwcwxS/YRhGjmGK3zAMI8cwxW8YURCRkIhc\n", + "E/H4lkwoBmQY8WCRu4YRBRE5AnhGVU8QkVa49CIDNHMSzxlGTFKWndMwMhlV/VxENorIcbj04u+b\n", + "0jeyBVP8hhGb+4EJuEJBD/osi2EkDTP1GEYMvHoQS3E1XY9S+7EYWYLN+A0jBqq6U0ReBb4zpW9k\n", + "E6b4DSMG3qbuYOCnfstiGMnE3DkNIwoi0g9XdnCeqlb7LY9hJBOz8RuGYeQYNuM3DMPIMUzxG4Zh\n", + "5Bim+A3DMHIMU/yGYRg5hil+wzCMHMMUv2EYRo7x/+aA4Lwnek4NAAAAAElFTkSuQmCC\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "## Total implementation" + "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS']\n", + "modelBFGS = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelBFGS)\n", + "inv_BFGS = generateInvTest(environment, modelBFGS)" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 84, "metadata": { "collapsed": false }, @@ -496,428 +5584,1260 @@ "name": "stdout", "output_type": "stream", "text": [ - "Available sensorimotor models: ['LWLR-BFGS', 'nearest_neighbor', 'WNN', 'LWLR-CMAES']\n" + "(, {'default': {'fwd': 'LWLR', 'k': 10, 'inv': 'L-BFGS-B', 'maxfun': 50}})\n", + "Populating the interactive namespace from numpy and matplotlib\n" ] }, { "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXncHFWZ779PIkLYwYBCZFESdGAENxYFNCNeCdGBGUfk\n", + "ooKiV1AvJLiMqFclOi7jzHxckBlA3GEQATdwIIwKb2QEkYyKyOIkYcsmQlgMOyHP/eOczlvd6equ\n", + "Xqpr6d/38+nP+1ZX9alTp6rOc57zLMfcHSGEEKLBlKIrIIQQolxIMAghhGhCgkEIIUQTEgxCCCGa\n", + "kGAQQgjRhASDEEKIJiQYaoyZrTWz3Ud4vgVmdu6ozldlzOxTZnaPma3K8RzTzOxSM3vAzL6b53nN\n", + "7MNmds4wyxw2ZvY2M7u6oHPvbmbrzWxK3L7MzI4dwXn7eicrIRjM7A4zO7Sgc+9pZhfFl+kBM7vB\n", + "zN7buMFlxt23cvc7RnnKfn84TkLFzHYF3gc83913zvFUbwB2BLZ396OHdV4zm21my5Pfuftn3f2d\n", + "g1V3fHD3ue7e9XmPfd+rBjlVPz8qfecWcQbodPrFzPYArgPuBP7S3bcFjgJeAmw16vpkxcyeVtSp\n", + "Czpv1dgVWOPua3I+z27A/7j7+hGft/aY2dQRncop4r1y99J/gNuBV8X/3wb8F/DPwH3AbcCcuO9o\n", + "4PqW374X+FGf5z0PuLTLMUcANwH3A1cRRmONfXcAHwB+B6wFvgY8E7gceBD4CbBtPHZ3YD3wTmAl\n", + "sAp4f6Ks/YFr43lWAV8GNknsXw+8B1gCLEt899z4/9xYzz8DK1rKfmf83RrgR8BOLeWeCPxPPPcZ\n", + "HdriNOAi4IJ4nv8G9kns3xn4HvCneN9Ojt/PAR4Hnojt9BtgNnBj4rc/AX6V2L4aOKJTuXGfAR8C\n", + "lgL3At8Ftmtp8+MIwv8e4CMp1/b0WK+T4vZU4BfAR1OO3wb4dqzTHcD/i3V5NfAI8FS81q+3+e10\n", + "4MexvdcAPwcs5TzPj22zBrgVOCp+/4mWNj2h3XmBA4Fr4rl+C7wyUfb2wDcIz+N9wPeBzYFHE+X8\n", + "GdgJWACcG393OfB/W+p5A/A3neqccn3HAzfH8ywDTkjsm014lt8H3E14L96W2P8M4BLCu3Yd8A/A\n", + "1SnnaTwLae/fAuBi4NxY3tvjPf5aPHZFLH9KPH4K8C/xmVoG/N9YfmP/BPCOlnewcZ03AS+K53oq\n", + "3re1wAcy3LPnAItiOf9J6CfO7bnv66fDHPWHjQXDE8A7CC/au4CVcd/msUFmJn57PfDGPs+7Gnhr\n", + "h/17Ag8BhxI6ir8ndLBPS9T7GmAHQud1N/BrYF9gU+BnwMdbHsx/B6YBf0noVA6N+19MEA5TCCPB\n", + "m4H5ibqsB64AtgU2TXz33MS1HOSTndaL4v+vig/vCwmd3+nAopZyLwG2BnaJdTospT0WxHvz+tge\n", + "7yd01FNjvf8b+CjwtPgALwNeE397GvDtRFnTCB3Q9sAmse2WA1vEfY8A22Uod368BzvHcs4Czm9p\n", + "87Pj/dgHeIyEcG+5vr0JHeTzCR39NaR32N8GfhDruxvwB+Dtcd8rgeUdnqvPAmfGdpvauG9tjtsi\n", + "tslbYzu8MN7Lv0hp06bzAjMIwrIxsHp13H5G3P4P4DvxeXkacEha/ZPnAo4F/iuxby9CJ7ZJtzq3\n", + "uca5wHPi/68AHmby2Z0NPEl47qYCh8f928T9F8TPtHjvVgA/TzlP41lIe/8WEJ7txmBks3h/z4zH\n", + "70AQPifE/e8CboltvB1h0PgUk4LhqsTzcFSs20vi9h7Arq19X8Z7di1BIG0CHELoD7/d7po79n39\n", + "dJij/rCxYFiS2Ld5vKE7xu1zgY/F/2fFhtmsz/M+QexgUvZ/DLggsW3xBr8iUe9jEvsvBv41sX0S\n", + "8IOWB3PPxP7PAV9NOfcpwPcT2+uB2S3HJAXDnYRR49Ytx3wN+MfE9hbxundNlPHyxP7vAqem1GkB\n", + "cE1Le6wCDgYOAO5sOf7DTI5cF9AysiGMlP+WMEK6gvCSHwb8FXBDPKZbube0vFg7xeubkmjznRP7\n", + "rwOO7nDP30fo5NcAe6QcM5UwWk9qjycAV8X/Z9NZMHwC+GFa+YnjjqaloyMIucZgo6lNW88LnEpL\n", + "pwEsJGhQOxE6sm3anHej+tOsMWxFGDDtErc/TXyOu9U5wzv5A2Beoh6PEDvb+N3dhAHU1Hifk+/T\n", + "p+muMbR9/+L1TST2PZMwiNgs8d0xwJXx/ytp1m7+F80aQ1IwXEFCy22pV6tg6HTPdiUIymmJff9O\n", + "HxpDVWwMrfyx8Y+7PxL/3TL+PZ9wgwDeROh4H2stwMwOiV47a83sxpTzrCGMNNPYCbgrURcnjIZm\n", + "JI65O/H/oy3bjyXq3SBp1Lurcf5oBP+xma02swcJD/kzOvy2lb8jjL7uMLMJMzswcQ13Jq7hYcJ1\n", + "J6/hj4n/H2lT5yQrEmV53N6Z8NDubGb3Nz6EDnzHDmUtIrz8h8T/FxFGq68gqOIQRuOdyt0N+EFi\n", + "383AOsKLnXZ9W3So07fjtVzm7stSjplOGLHdmfjuLprbtBP/TJj6+k8zW2Zmp6YctxtwQMu1v4nm\n", + "a+vEbsBRLb8/CHgWQTu8z90fzFjWBtx9LUHbaLyH/5vQQfVcZzM73Mx+aWZr4rFzaX7u1/ikDQUm\n", + "n88dCFpO6/vUjbbvX2RF4v/dCPd4deI6zornhfBeZT33swlabhY63bOdgfvd/dHE8Xe2K6QbRRkp\n", + "8+SnwA5mti/hgTyl3UHufjXdDcg/JXSo30zZvwp4QWPDzIzwQq3sUGY3Q9KuhBFp4/9GWWcSpkyO\n", + "dveHzeyUWLcknlaouy8G/iYazU4GLozlryKMlhrXsAXhxet0DZ3YJVHWFMJDv5Iw+rzd3fdM+d36\n", + "Nt8tAj5PeLg/CzwAfJUgUM+IxyzvUu5dwPHufm3rjj5def+NMP8/x8wOcvdftDnmXsLIbXeCxgKh\n", + "rVe0OXYj3P0hgm3qA2a2N3ClmV3v7le2HHoXYdrvNWlFdTnVXYTR5AmtO8xsJ2B7M9umjXBoV27r\n", + "d98BTovuoZu5+1UZ65ysw6YE29FbCHbCp8zsB2Qzxt5DGAC0vk/dSHv/oPkalxO0wme0CKYGq1vO\n", + "1+ncy4GZKfta27XTPdsN2M7MNk8MmHcjvHs9UVWNIRV3f5JgAP0XwtzeTwYo7jTg5Wb2T2b2TAAz\n", + "m2lm55rZ1oTO9bVm9ioz24Qwp/4YYe65Xz4a/c/3JkybfTd+vyXBAPWImT0feHfWAs1sEzN7c3zJ\n", + "G0bDxsPyHeB4M9s3voifAX7p7mkjnG4v5UvM7G+jZ9QphPb4JcHWs9bMPhivb6qZ/aWZvTT+7m5g\n", + "9yhcG1wDPA/Yj2B4vpk44iRMM0GY+ulU7lnAZ6KrJma2g5kd0eUa2l5j9Dt/EWF+fB7wrShIm4ht\n", + "fCHwaTPbMr6w7yU4M3TFzF4bnzMjTIU+RfuX+8fAnmb2lniPNzGz/eLzkXodCc4D/trMXhPbbbPo\n", + "ijrD3VcTjMj/ZmbbxrJfEX93N/CM+A5sqHZL2ZcR7tUnCFOAWeuc5Onxcy+w3swOB7oKFNhwD74P\n", + "LIjPxV6E+9ZNWKa9f63lryYYdz9vZluZ2RQz2yPRRhcC88xshpltR3CASOOrhEHAiy0ws/G8Etp6\n", + "j8Sxne7ZncBi4BOxXQ8GXtflettSRcHgbHxzW7fPJxiEL0qR5tlO5H4b8DLCyO8mM3uAYCe4HnjI\n", + "3f+HMJr5MmGE8lrgr919XZf6J/9vrfsiwjTCT4F/dvefxu8/QFC5/wx8hfCytZbV6VxvAW63MA11\n", + "AvDmeI0/I9hKvkfQHp5D0LTSym1X5+S+HxLmke+L53i9uz8VX9TXEYyNtxHa6ysEozYEYQ6wxswW\n", + "x7o9QtCSbkq06TXAHe5+bzxmfZdyv0Qwnv+nmf2ZYJzbv8P1tf0uvqhfAI5z90fc/TuEl/DzKW1x\n", + "MsEQehvBg+rfCR4+nc7bYBZhQLM2Xu+/uvuijSoZNIvXEO7XSsIo9bOEzrRxjtR3xd1XAEcCHyEY\n", + "Wu8iDG4a/cKxBM3nVkIHNS/+7lbCgOI2M7svahfeUvYThI75UML7mLXOyetbG895IeF5OobgNdf2\n", + "etpwEmFA9Ufg6/HTjbT3r11bHhfrfXOs30WEKR2Acwi2gxsIz8n30urq7hcTpobPJ7zf3ycMaiG0\n", + "zUfjtNH7MtyzNxEGTvcBHwe+leGaN8KigSIXzOzrhM7yT+7+gpRjTid4EzxCcDX7TW4VKjFxWuM2\n", + "gkdT38JMCNE7ev+ayVtj+AbBR70tZjaX4Fo6izCKPTPn+gghhOhCroIhGnjv73DIEURVx92vA7Zt\n", + "zOWPKfmpb0KIbuj9ixRtY5hBs0vXCoIXy9jh7ne4+1SpsUKMHr1/zRQtGGBjbwZJbSGEKJCi4xhW\n", + "kvB7Z9LnvQkzk7AQQog+cPeek/AVLRguIbiUXWAhEvcBd7+73YH9XFwdMbMF7r6g6HqUAbXFJGqL\n", + "ScayLcxmEdxxD47fnAfMt5DFoGdyFQxm9h1CCoPpFvK3n0YII8fdz3b3y8xsrpktJfh8H59nfYQQ\n", + "olaE7ALzCIGp0wgxGyfifknc31exuQoGdz8mwzEn5VkHIYSoJSlaAu73DVp0GYzPojcmiq5AiZgo\n", + "ugIlYqLoCpSIiaIrkCtmUwi50m4gCIU/AkfifuwwhALkHPk8LMzMZWMQQow9PWoJ/fad0hiEEKLs\n", + "jEBLSFK0V5IQQohO5GhLSEMagxBClJERawlJpDEIIUTZKEBLSCKNQQghykKBWkISaQxCCFEGCtYS\n", + "kkhjEEKIIimJltBUJcUxCCFEQbTREvaDSxfD24HNCGumn+7ul/VXfH99p6aShBBi1KTkODJYR1in\n", + "fGbi6D3MjH6FQz9oKkkIIUZJ0BIWAV8gCIXzgL1j4rt5NAsF4vbJo6yiBIMQojLEbMwLzWwi/p1b\n", + "dJ0yk82WsFnKr6eNoooNNJUkhKgEUQgUPs3SF9k9jh5LKeHRvKrWDmkMQoiqUIpplp7o3ePodGBp\n", + "y3fLgC/nW9FmpDEIIapCKaZZMtNHXEJcvAyCsJtG0BS+PGqNSIJBCFEVSjHN0pVuq6p1IQqBQqfG\n", + "NJUkhKgKpZhm6Uhnj6PKII1BCFEJyjLN0pYBtYSyochnIYQYhJyjlwermiKfhRBidJQ8enkQZGMQ\n", + "QoheqUD08iBIMAghRFYqFL08CJpKEkKILGSPS9gypYQt8qrasJHGIIQYa7rmX+o9ejnN2FsZBxpp\n", + "DEKIsaVr/qUeopdjWfOAPVJO99Dwap4vEgxCiHGmraF4CpyM2Z5kjEtIETCtlCtCuwMSDEKIcWYj\n", + "Q/FM4EJ4GTAnfpVl7eV2AiZJuSK0uyAbgxBinNmQf8mA+QRDwotgG3pbeznNE+lBYCEwryoxDCCN\n", + "QQgx3pwO7DETZn4dOCR+uQSunAVHZRAIDdIS/F3r7ocPXMsRI41BiJpQ6dXNCsJh4RVw5Y2w/hBg\n", + "DTz+FfjkLPdDexAKUIUEfz2gXElC1IAU4+dSYH6VpjDSSHj8DC/3UB/rJWSoY6kS/PXbd0owCFED\n", + "zGwhcFibXQurOJXRIgi2BHYGdkoc0r/Qq1km1E4oiZ4Q403l0zA0yOj62cg91JtgGLKWUFdkYxCi\n", + "HlRjdbNsdHP9bJBd6PUevTzWSDAIUQ/qZPxM035aySb0arKq2ijJVTCY2Rwzu9XMlpjZqW32T4/e\n", + "E781s9+b2dvyrI8QdSXOtc8n+MwvooK+8wnStJ8k3YWetIS+yc34bGZTgT8ArwZWAtcDx7j7LYlj\n", + "FgCbuvuHzWx6PP6Z7r6upSwZn4WoIe28jeKuVhvDamAVId9Qd48f2RKAchqf9weWuvsdAGZ2AXAk\n", + "cEvimNXAPvH/rYE1rUJBCFFP0hLYETSf+fTj+jlGHkd5kqdgmAEsT2yvAA5oOeYc4EozWwVsBbwx\n", + "x/oIIcpF6kpn0cVWHkc90kYD64s8BUOWOaqPAL9199lmtgfwEzPb193Xth4Yp50aTLj7xHCqKYQo\n", + "iOG42EpLADYIha8QBuUDkadgWAnsktjehaA1JHk58GkAd19mZrcDzwMWtxbm7gvyqaYQg5FLVO54\n", + "MLiLrbSEJPMYglCAfAXDYmCWme1OMBodDRzTcsytBOP0L8zsmQShcFuOdRJiqHRd6EUAqUbm0wk2\n", + "hWTbZXOxLZmWUJLBQVY3367kJhjcfZ2ZnQRcAUwFvubut5jZiXH/2YSb+g0zu4HgOvtBH09JL6pL\n", + "6jw5vc6R15ShG5lLpiWUaHDQt02hFeVKEmIAzGwCeGWbXYvcffZoa1NOOuRxuhe4iawj7JJpCZPV\n", + "KkeeqrRUImVzVxViHKhTKoq8SJvimM6kUO08wi6ZltBCKfJUuftlZgbNGticjj9KQYJBiMHof558\n", + "fMgyxdF++q2kWkILpRkcRMG6oQ3NrK8pIQkGIQYgZZRWeB7+ktFOeLajeYRdbi0hSe0GBxIMQgxI\n", + "6yhNNNNGeO5NmEZqJYywq6ElbKCOgwMZn4UQuZDmwpliJF0GzHNYQjW0hEpQxlxJQogxpZsLZ+sI\n", + "++lwxuOwJ3AxMO0xuP/dcPs3Q2Ds+ZgpaHCESGMQQvRNB60guwtniy1hCVz5ctj9Xnhu4qjarF89\n", + "SqQxCCF6YtBo3U5aAVlcOFNsCXvCe2gWCqCgwZEiwSDEGDKkaN1OUd+dXTg7eRyZvS/lt9NKknqi\n", + "9mhpT1FrzGxuXCVwIv6dW3SdSkKnTj0rnbSCtkuNPh3OwOyUp+BG4OB74Ynj4dcG30kYmNOEyhYE\n", + "YXYYITDuMOBLuqfDRxqDqC0lymFTRoYRrZuqFbQzMB8H3/sWfAg4eCpwLjAfnn4/vJjQwTfuS1pc\n", + "wBTGNC/VqDUlCQZRZ5TgLp1hROt2DOzaEN8xaUs4HZi2Bh4/Hja9tLmsDfclLS4A+GBKPUaaemLU\n", + "FDHAkWAQdaYUOWxKysDRupkCu9rYEvaG59wNB7UpcsN9aRc0aGbzUqpS97xUIx/gSDCIOlOaHDZl\n", + "Y1jRuqlR3x2il+8Orqzt6HZfTiesEb9T4rvVVDj1REZGPsCRYBB1pjY5bPKYY84tlUf3HEeD3JfW\n", + "wKvyB2INzsgHOBIMorbUJYdNZYzoGXMcDXBf5gE7t3y3M/W3GY18gKPIZyFKTlkWgunICDKhjvOi\n", + "SHFw0PMAR5HPQtSX8hrRR5sJdWxtRqPO4KsANyHKTzk7xKAlLAK+QBAK5wF755geu23QHBW0GZUd\n", + "aQxClJ9yGdELWi+hLjajKiAbgxAVoN855hwqUpVV1UrLKKOY++07JRiEEN2p2KpqZSXFwyy3lOL9\n", + "9p2yMQghOjMkW4ISGgLDSV6YO7IxCCHaM0QtoTKxGPlTXg+zBNIYhBAbM3yPo0qMlEdAOT3MWpBg\n", + "EKIASjutYjYFs1OAGwgG5j8CR+J+7IAG5kqMlEdAJVxuNZUkxIgp7bRKvh5HlRgp501VXG7llSTE\n", + "iCldios+bQm9uF2mCMNlwLyydIp1XDZUKTGEqA7lmVbpU0voVesp+0i5tFpcQUgwCBFJjBh3JuT8\n", + "Xw2sYvgjx+KnVQb3OOp58ZhR5/vpEa32l0CCQQhSR4zTgRcw/JHjUFJc9D31MRxbQnm0nuFQt+sZ\n", + "CAkGIQLtRowNhjpyHMa0Sl9TH8ONXi5e6xkudbuegZBgECKQNmJsMNSR4xCmVXqb+hi+x1G5EvsN\n", + "Tt2uZyAkGIQIpI0YG5Rt5Jht6iOnHEdlNyb3St2uZ1AkGIQItBsxNijjyLH71EfOmVCzaj1VcQMt\n", + "uXF8pOQqGMxsDvBFYCrwVXf/XJtjZhPC7jcB7q37En2inLSMGGcw6ZW0knKOHK8FDgE2T3z3CDBj\n", + "qtnCy+HO18CxFJwJVW6g1SS3ADczmwr8AXg14eW6HjjG3W9JHLMt8AvgMHdfYWbT3f3eNmUpwE2I\n", + "SEpn64DNJKgIh0x+X+h6CaUL5hszck27bWabm9nzeix7f2Cpu9/h7k8CFwBHthzzJuB77r4CoJ1Q\n", + "EEJsxEaGZwObT0hwdAhB1Tkefj2EHEeD0tUWUtq8UWNMV8FgZkcAvwGuiNsvMrMsKukMYHlie0X8\n", + "LsksYHszu8rMFpvZsdmqLcRY09TZziSkQf0iYV7pXGBv4JuwduQ125iOtpCE9nMY8Mr490sSDsWS\n", + "RWNYABwA3A/g7r8Bnpvhd1nmqDYBXgzMJTwQH7NgMBNCpPMYgAGtWsIRwHHEl7UcnlTdsokqHXcJ\n", + "yWJ8ftLdH4iGuQbrM/xuJbBLYnsXgtaQZDnB4Pwo8KiZ/RzYF1jSWpiZLUhsTrj7RIY6CFFHTt8L\n", + "nn8W7NawJZwH6+fBlPsnjxnYk2oY3kQZ3EAVcTxEojPP7EHLySIYbjKzNwNPi6P5ecA1GX63GJhl\n", + "ZrsT8s0cDRzTcsyPgDOioXpTgmby+XaFufuCDOcUot6YTXHY8yl41lTgXnji7+H334RLgAMZkg/+\n", + "ML2JuriBKuJ4iMQB80Rj28xO67egjh9gC0JwzOL4+TSwWbffxd8eTvBMWgp8OH53InBi4pgPADcB\n", + "NxJS8LYrx7OcT5/yfAjTgwvjQ7oQmFt0nar8Aea+EH7+a3jAwePnXIftczrfQsJ0cOvn8hyekyUt\n", + "51iq52Vo7ev9/K6ru6qZvdjdf92X1BkScletFimjzaXAfJfves9savba98M3PwrTNyfYEk6B1RfC\n", + "/8mrPc1sgmAMbmWRDznWKD4vijjOgX77ziyCYQJ4FnAR8F13/31fNRwACYZqUQff9dJE65rNugGu\n", + "2xe2g+BxNJ8NxuXc2rMO91DkuFCPu882s52ANwJnm9nWwIXu/g991FOMB5U2KJYiWjeR42hfmLaa\n", + "MAd7afNRebanksqNMZkC3Nx9tbt/CXgXwTvu47nWSlSdqhsUi3WhDE4eiwipYqb9B6zam42EAuTY\n", + "nlEAzifYGhbFv6VZhlPkS1eNwcz2ImgLbwDWAN8F3pdzvUS1qfposxiNJyUT6utgHe3XS861PV1J\n", + "5caWLO6qXyekszjM3VfmXB9RA7z6KYxHr/F0yITqQMXbsxBKYycaAqO+ltyS6A0TGZ/FKEmxMSwj\n", + "j6mUnNZLGHfq5Bk3yLUM3SvJzC5y96PM7MY2u93d9+n1ZP0iwSBGzUhcKHNeL2GcqZNX1SDXkodX\n", + "0vz493WEtCxJyq9mCDEAuc6vS0sYBZX2jGth5NeS6pXk7qviv+/xkDp7wwd4T14VGleUenhMaPE4\n", + "ImgJe0soDJ2qe8YlGfm1ZHFXfU2b79RpDRGlHh4DzKZgdgrB3ftggpZwJMWvl1BXumV1rRIjv5bU\n", + "qSQzezdBM9ijxc6wFWHVNTE8OvnNV8pQJtogW8LIqYFn3AaKuJZOxudtCGH4/wicyqSdYa27r8mr\n", + "Qil1qbXxeZR5acQIkS1BFMzQjc/u/iDwoJl9Cbjf3f8cT7S1mR3g7tf1X13RQp3mQwVISxCVJouN\n", + "4UzgocT2w8BZ+VRnbKnTfOh4I1uCqAFZIp9x9/WJ/5+KC+uIIVGn+dCxJgctoU7Ru6I6ZBEMt5vZ\n", + "PILmYMC7gdtyrdUYorw0FSYnW0IpsryKsSTLVNK7gIMIazivICwfeEKelRKiMuQbl1BsllcxtmRZ\n", + "j+FuwnrNQogGo/E4qlP0rqgQXTUGM3uemf3MzG6K2/uY2Ufzr5oQJWV00csDeaspml70S5appHOA\n", + "jwBPxO0bgWNyq5EQZaWDx5HBgTl0wn17qymaXgxCFuPz5u5+XfSawd3dzJ7Mt1pClIwOHkd5GYmz\n", + "equ181xC0fRiALIIhnvMbMMDZmZvAFbnVyUhSkQ2W0JunXA3b7U0oUT6dJPsE6IrWQTDScBXgOeZ\n", + "2SrgduDNudZKiDKQPS6hSCNxmlC6N+V4RdOLrqTaGMyssR7DTu5+KLAj8Hx3Pyim3hainvQevVxk\n", + "SpM0obQaRdOLPulkfH57/PtlAHd/qJEvSYja0p/H0enAqpbvVjOaTjhNKK0kLLa1kHA9C8ljaVJR\n", + "SzpNJd1sZkuAGW2W9xzp0p5C5M7gcQlFZf89nWBTaF2f+suKphf9kpp2G8DMngVcARxBy4M/yumk\n", + "vhe0Vp6ZsSfTMzBgjqOi1xceyfrUopIMPe22mf3M3Q81syvc/c7Bqjd6lGemHBQpnOO5zwF2Tnz9\n", + "AjN7p7tfNsTo5UKMz23a9p9G3Lap91WDsmrTaSppJzM7CDjCzC4gaAwb1At3/3XelRuQ2vtxl/3l\n", + "K4Fw/iTNQoG4/QnCNOmwMqGO3PhcZNt2O3cJ7rsYFHdv+wGOIhis1gJXtX7SfpfHJ1Sz599MEARZ\n", + "62dilHXPsU3mAktarm0JMLfouiXquDDlHlw+ovPf13puA/8APOzwiIM7rHY4Iod7sbTbvYi/Wxif\n", + "1YW93Lsi27bbuYu+7/o03Svv53edVnC7CLjIzD7u7p9MO67E1H1VtCpoRKVKAjeToCIcApvHrzJr\n", + "CZ20M+9jPY0hjKqLbNtu5y7VfRe9kyXA7VNmdizwHHf/pJntCjzL3X+Vc90GJdVbo5jqDJ0qvHwD\n", + "C+cBp8tuB7YzJg0JmwP3wJM7wBvIaEtI6cRfYWY3Ax9398u8dw+gQQV7kQOfbueu+6Cs/mRQRc4C\n", + "/g24NW5vDyyugjpEUNUvJ6jql1OiaZYhtEnp1XX6nGLp8vum6TI6TMcAc58Pd/88TBm5g18Aj7wU\n", + "3jiktu5r+i7WeaNpLnqY6hykbTu12TDOPeh912d4n777zgwF/yb5N/5/QxUurs6fqrx8gwjnbsKv\n", + "o+CAKQ6nrIPHHPweePxt8N/9tA/p9qqehXFKnQcpq6e27dRmvQiMbuce5L7rM7xPnoLhOmBqQkDs\n", + "kBQSZb64un/K/PL10sl0KCOtQ56I+9sKjhfCIoerG1qCw7kO2w9wLZ00hsyj/Axl5S7YO5x/cZrA\n", + "KPpZ0meg++39/C6LjeHLwA+AHc3sM8AbAC3UUwK8pJGtQ3RX7DZX3WRnadgS/jG4oE5heKuqtbNX\n", + "tatPFtJsQ/cxmpQVaed/LrBdy3dlc2YQI6LrQj3ufh5wKvBZQj6YI939wiyFm9kcM7vVzJaY2akd\n", + "jtvPzNYw4jb1AAAPsElEQVSZ2euzVlyUmmGtVdxtoZoNgmMmISHQF4HNwnM9tFXVYmc9nzAV1SoE\n", + "enVoSBN2vxqBUOh0fk/5vkzODGJEZNEYcPdbgFt6KdjMpgJnAK8mJPS63swuiWW1Hvc5gopbVL4Z\n", + "MVyG4jHl3d1AT58Ce5wMMxseR3+Cp34Inz7B/bQ+655aF6ARvDVI+omiveXSzv8AwbGkFXkSjSGZ\n", + "BEOf7A8s9ZhTKUZPH8nGAuZk4GJgvxzrIkbL0NwVO02XOSz5Ezy+Y9y+DFadBu9dDA+dGPIXDT0i\n", + "fNDpuwzCLlfSzh93t07/1cm9W/RAnoJhBrA8sb0COCB5gJnNIAiLVxEEQ5o6K6pFvqPiRI6jHRM5\n", + "jua6X/LaCqRjKNo21Hr+RKzIo4QFflYTtPzSJeMrexqYutBVMJjZXu5+c8t3s919ostPs3TyXwQ+\n", + "5O5uYRijqaQakOuouHsm1CpEhJeGFEeBByivUCi10K8LWTSGC83sXOCfCC/55wij+wO7/G4lsEti\n", + "exeC1pDkJcAFsROZDhxuZk96G4OhmS1IbE5kEEyiQIY+Ks6eCbUKEeFlokqCtEp1LQQzmw3MHrSc\n", + "LILhAIIwuBbYEjgfeHmG3y0GZpnZ7gRvpqOBY5IHuPtzG/+b2TeAS9sJhXjsggznFHWkt/USlI6h\n", + "N6okSKtU10KIA+aJxraZ9eWE0dVdFVhHeKmmEW7Mbe6+PkMF1wEnERb6uRn4rrvfYmYnmtmJ/VRW\n", + "jBm9r70M3V1cRTNVEqRVqmul6biCG4CZ3QBcQshtPx04G3jc3Y/Kv3ob6uDexypEIn9yMwYOsKqa\n", + "VjTLTsq8/TJKuD50lepaFvpe/TKDYNjP3a9v+e44d/92ryfrFwmGcpLyoi4F5vf9og5vVTWRkSoJ\n", + "0irVtQzkJhjKgARDORn6WscDrr0shGim374zi41BiDSGYwzsz5ZQGGY218wWmtlE/Du36DoJMUzy\n", + "DHAT9WdwY2DFtAT50otxQBqDGIT+PYAqpiUkGFaCQCFKizSGHlA4fjN9RzhXTEtoQb70ovZIMCTo\n", + "1PFrCqE9PUU418PjSL70ovZIMEQydPwKxx+EamsJSYpOmy1E7kgwTNKt49cUQj/UQ0vYQNFps4UY\n", + "BRIMk3Tr+DWF0Cv10RKaKDptthB5I6+kSbp1/JXLwVOYv311PY6EEEhjSNJx7jiPKYQ8vZwKM5bX\n", + "VEsQYpxQSozm84wsD0sueYaayx9uuoruJ6yVLUGIOtBv3ymNIcGI547z9nIanbG8pFqC4k6E6A8J\n", + "huLIu+POxVie7GynwGOXw52vgWMpmZaguBMh+keCoTjy9nIaur99srOdSVARDpncXQotIYHiToTo\n", + "EwmG4sg1UConf/t5BjMbhoTNgdXAR+DX33A/dtA6D5mBNDJNQ4lxRoKhIEYRKDVsm8k+sN0ZTGoJ\n", + "5wLzgfth7TeGdZLh0bdGpmkoMe5IMBRIZQKlosfRdfDSzQhawonApZNHlDHIbxCNTNNQYqyRYBCd\n", + "SXgcbQZcDGtPgK3unzyilEF+A2pkSn8ixhoJhgKoxPx1SlzCUbCOiuQJGkAjU/oTMdZIMIyYSsxf\n", + "d4hLiOGQ5ahnfiiDqhhrFPk8YkYekdwLil7ewCij4IXIC0U+V4dyzl+XNHq5KCrjGCBEDii76ugp\n", + "1/y1MqEKIVqQYBg95UnfHbSERcAXCBrLecDeo5o6KiwtuBCiI5pKGjGlWAGsBLaEShjhhRhTZHwe\n", + "N0piSyi1Eb5gKuHOLCqBjM+iMyXQEloopxG+YKRJiTIgG8M4ULAtIYVyGeHLQ6d0HEKMhMoIBhkq\n", + "+6DcHkflMcKXC2lSonCqNJUk9boXSmJLSKMURvhyIk1KFE5ljM8pu8beULkR5bMliB5IsTEsA+ZJ\n", + "aIpeGVfjs9TrJCXXEkR3pEmJMlB1wSD1GqQl1Ayl4xBFUxnjMzJUtqecHkdCiAqTu2AwszlmdquZ\n", + "LTGzU9vsf7OZ3WBmvzOzX5jZPilFzQcWEjrBhYz7nGu5PY6EEBUmV+OzmU0F/gC8GlgJXA8c4+63\n", + "JI55GXCzuz9oZnOABe5+YEs5inxOMqAtQZG1QowHZTU+7w8sdfc7AMzsAuBIYINgcPdrE8dfBzw7\n", + "5zpVlyHYEhRZK4ToRt5TSTOA5YntFfG7NN6BjG7tGZ4tQZG1QoiO5K0xZJ6nMrO/At4OHJSyf0Fi\n", + "c8LdJwaqWVUYvsdRaSNrNcUlxGCY2Wxg9qDl5C0YVgK7JLZ3IWgNTUSD8znAHHe/v11B7r4gjwqW\n", + "mnziEkoZWaspLiEGJw6YJxrbZnZaP+XkPZW0GJhlZrub2dOBo4Gmka6Z7Qp8H3iLu7e6pI4n+Xoc\n", + "lTVHkaa4hCgJuWoM7r7OzE4CrgCmAl9z91vM7MS4/2zg48B2wJkx4vNJd98/z3oNSq5THjlHL5c4\n", + "sra0U1xCjBuVyZVUFnfVlCmPpcD8gTrXMY9e1sI9QgyffvvOKkU+l4XhT3koehnKO8UlxNhR9VxJ\n", + "RTC8KY8SaQlFewSVeIpLiLFDgqF3huPVU6JMqGXxCFLyOCHKgaaSemewKY9y5jiSR5AQYgPSGHpk\n", + "oCmPEmkJLcgjSAixgVoLhrzmzXue8iiRLSGFUga9CSGKobaCoSzz5iXWEpKcDuzBxstJyiNIiDGk\n", + "tnEMhfvFl19LaCIKUnkECVEjypp2O3c6TBcVN29eDS2hCXkECSEaVFowdJouooh584ppCUII0Y6q\n", + "u6t2crMcbSStopeFEDWh0hoDHaaLRhZJKy1BCFEzqi4YOk4X5T5vXkFbghBCdKPqU0ntposeAWaY\n", + "2cJogxg+5YxeFkKIoVBpjaFlumgGwRd/c+AF8TP8uAVpCUKImlObOIbc4xZkSxBCVIyxjWNIkF/c\n", + "grQEIcQYUTkbg5nNjfaDiRY7wvDjFmRLEEKMIZXSGLoEtA0334+0BCHEmFIpwUCHgDZ3P3wocQuy\n", + "JQghxpyqCYaOdoSB4xakJQghROVsDPnkP5ItQQghNlA1wTD8/EfKcSSEEE1UaippqPmPZEuoDXmt\n", + "1CfEuFKbALceC6ycLUGdX3tSPNWWAvPVPmLcUYBbFiqqJQy6TGnNhUqn1Ot1uUYhRsr4CIYKagkJ\n", + "+u78SrP2dX4Ut1KfEDWlasbn3qmHx9EgnV8noVIHRr9SnxA1p96CoT4eR4N0fnUfUY92pT4hxoB6\n", + "TiVV1JbQgUHSfdR6RD2ylfqEGCPq55VUbVtCKtFW0HPnl2JjWAbMU+cpRL3p1yupPoKhflrC0OhX\n", + "qAghqs14C4aaaglCCDEI/QqGahuf6+FxJIQQpaK6xmdpCUIIkQu5agxmNsfMbjWzJWZ2asoxp8f9\n", + "N5jZizIU2pOW0GHFNyGEEG3ITTCY2VTgDGAOsBdwjJn9Rcsxc4GZ7j4LOAE4s0uhPcUlJDxyDgNe\n", + "Gf9+qcrCwcxmF12HsqC2mERtMYnaYnDy1Bj2B5a6+x3u/iRwAXBkyzFHAN8CcPfrgG3N7JltS+vP\n", + "llDHqN/ZRVegRMwuugIlYnbRFSgRs4uuQNXJUzDMAJYntlfE77od8+yU8vqJXq571K8QQgydPI3P\n", + "Wf1gW12p0n7XT1xCraN+hRAiD3KLYzCzA4EF7j4nbn8YWO/un0sccxYw4e4XxO1bgVe6+90tZZU/\n", + "2EIIIUpI2dZjWAzMMrPdgVXA0cAxLcdcApwEXBAFyQOtQgH6uzAhhBD9kZtgcPd1ZnYScAUwFfia\n", + "u99iZifG/WfHBGhzzWwp8DBwfF71EUIIkY1KpMQQQggxOkqVEiOXgLiK0q0tzOzNsQ1+Z2a/MLN9\n", + "iqjnKMjyXMTj9jOzdWb2+lHWb1RkfD9mm9lvzOz3ZjYx4iqOjAzvx/QY0Prb2BZvK6CaI8HMvm5m\n", + "d5vZjR2O6a3fdPdSfAjTTUuB3YFNgN8Cf9FyzFzgsvj/AcAvi653gW3xMmCb+P+ccW6LxHFXAj8G\n", + "/q7oehf0TGwL3AQ8O25PL7reBbbFAuCzjXYA1gBPK7ruObXHIcCLgBtT9vfcb5ZJYxhuQFy16doW\n", + "7n6tuz8YN68jPf6j6mR5LiAELV4M3DPKyo2QLO3wJuB77r4CwN3vHXEdR0WWtlgNbB3/3xpY4+7r\n", + "RljHkeHuVwP3dzik536zTIJh2AFxVSZLWyR5B1DX9RW6toWZzSB0DI2UKnU0nGV5JmYB25vZVWa2\n", + "2MyOHVntRkuWtjgH2NvMVhEyJswfUd3KSM/9Zpmyqw47IK7KZL4mM/sr4O3AQflVp1CytMUXgQ+5\n", + "u1tY57OO7s1Z2mET4MXAocDmwLVm9kt3X5JrzUZPlrb4CPBbd59tZnsAPzGzfd19bc51Kys99Ztl\n", + "EgwrgV0S27sQJFunY54dv6sbWdqCaHA+B5jj7p1UySqTpS1eQoiFgTCffLiZPen1Wr0vSzssB+51\n", + "90eBR83s58C+QN0EQ5a2eDnwaQB3X2ZmtwPPI8RXjRs995tlmkraEBBnZk8nBMS1vtiXAMfBhsjq\n", + "tgFxNaBrW5jZrsD3gbe4+9IC6jgquraFuz/X3Z/j7s8h2BneXTOhANnejx8BB5vZVDPbnGBovHnE\n", + "9RwFWdriVuDVAHE+/XnAbSOtZXnoud8sjcbgCojbQJa2AD4ObAecGUfKT7r7/kXVOS8ytkXtyfh+\n", + "3GpmC4HfAeuBc9y9doIh4zPxGeAbZnYDYQD8Qa/pIl5m9h3CsgLTzWw5cBphWrHvflMBbkIIIZoo\n", + "01SSEEKIEiDBIIQQogkJBiGEEE1IMAghhGhCgkEIIUQTEgxCCCGakGAQogDMbIGZvb/oegjRDgkG\n", + "IYpBAUSitEgwCMGGRX5uMLNNzWyLuLjLXm2O+1hcIOZqMzu/Meo3sxea2S9jGd83s23j9+80s1/F\n", + "BWMuNrNpo742IXpFgkEIwN2vJ+SU+RTwOeDc1nQSZrYf8HpgH+Bw4KVMjvy/Dfy9u+8L3EhISwBh\n", + "fYT93f2FwC2EFOlClJrS5EoSogR8kpCg7VHCwj+tHAT80N2fAJ4ws0sBzGxrwmp6V8fjvgVcFP9/\n", + "gZl9CtgG2BJYmGP9hRgKEgxCTDId2IKQmG0a8EjLfqc5r33aug/J778JHOHuN5rZW4HZQ6mpEDmi\n", + "qSQhJjkb+ChwPmE6qZVfAH8d7RBbAq8FcPc/A/eb2cHxuGOBifj/lsAfzWwT4C1MTj3VcTEhUROk\n", + "MQgBmNlxwOPufoGZTQGuMbPZ7j7ROMbdF5vZJYS01ncTbAmNdbffCpwV10FYxmRq448R1uS+J/7d\n", + "slEc8kwSJUVpt4XoATPbwt0fjgJgEfBOd/9t0fUSYphIYxCiN74S3Vg3A74poSDqiDQGIYQQTcj4\n", + "LIQQogkJBiGEEE1IMAghhGhCgkEIIUQTEgxCCCGakGAQQgjRxP8H5NM2ovskyZwAAAAASUVORK5C\n", + "YII=\n" + ], "text/plain": [ - "" + "" ] }, - "execution_count": 50, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" }, { "data": { "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEZCAYAAABrUHmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xm0XGWZ7/HvL2EGMXJRAiGAhkFktTQqk9BybFECKHjt\n", - "VhtpEbW7ab0MdyktOCBRG1vsQRmWtgLaeB0AxwbFKCIHEBHEDoQhIAlgMys0IMZACOe5f+z3JDuV\n", - "GnYNu3YNv89aZ53aVbt2PSc5p57a+33e51VEYGZmVsSMqgMwM7Ph4aRhZmaFOWmYmVlhThpmZlaY\n", - "k4aZmRXmpGFmZoU5aZiVSNKUpBdVHYdZrzhpmCWS7pH0R0lPpq/fS5pd4utNSlohadvcfQdKursm\n", - "poclbZK7728kXVFWXGbNOGmYrRHA6yPiOelr84h4qOTXXA6c0mKfGcAJJcdhVoiThlkLks6X9L50\n", - "e0665PTetD1P0qO5ff9B0gOS7pP0rhaHDuBM4Igml7AC+BfgREnP7f6nMeuOk4bZ2lTnvklgIt0+\n", - "ALgLeFVu+yoASfOB9wMHAjun763cD5wDfKzJPjekGE4scDyzUjlpmK0h4HuSHktf30n3XwXsL0nA\n", - "nwGfBvZLjx0AXJluvwX4UkTcFhF/BE4t8JoB/BPwBkkvabLPR4HjJG3Z9k9l1kNOGmZrBHB4RDwv\n", - "fb0JICKWkY09/ClZ0vg+8ICkncnOOKaTxtbAvbnj/XehF414BDgb+HiKod4+t6bXPbnRPmb94KRh\n", - "VsyVwJuB9SPigbR9NPA84Ma0z4PAdrnn5G+38s/Aq4GXN9nnVOBvgTltHNesp5w0zIq5EjiWNH5B\n", - "NsZwLHB1rFlf4CLgaEm7phLZIpenBBARTwD/CpzUaMd0xnMhrqSyCjlpmBVzFbAZa5LGNcDGuW0i\n", - "YiHwWeCnwK+By2l9KSn/+BnAqhbP+TiwSYHjmpVCVS7CJOlLwKHAbyPiTxrscyZwMPBH4OiIWNTH\n", - "EM3MLKfqM40vA/MbPSjpEGDHiNgJ+Dvg8/0KzMzM1lVp0oiIq4HHmuxyGHB+2vc6YJakrfoRm5mZ\n", - "ravqM41W5rB2CeN9wLYN9jUzs5INetKAdWfoegDQzKwi61UdQAv3A3Nz29um+9YiyYnEzKwDEVGv\n", - "dU5Dg540Liarhb9A0j7A4xHxcL0d2/3BB4mkBRGxoOo4OjHMsYPjr5rjr1YnH7grTRqSvkHWu2dL\n", - "SfeSTYZaHyAivhARl0o6RNJSsjYO76wuWjMzqzRpRMQRBfY5th+xmJlZa8MwED4OJqsOoAuTVQfQ\n", - "pcmqA+jSZNUBdGmy6gC6NFl1AP1W6YzwXpEUwzymYWZWhU7eO32mYWZmhTlpmJlZYU4aZmZWmJOG\n", - "mZkV5qRhZmaFOWmYmVlhThpmZlaYk4aZmRXmpGFmZoU5aZiZWWFOGmZmVpiThpmZFeakYWZmhTlp\n", - "mJlZYU4aZmZWmJOGmZkV5qRhZmaFVZo0JM2XdLukOyWdVOfxLSUtlHSjpFskHV1BmGZmllS23Kuk\n", - "mcAdwIHA/cAvgSMiYklunwXAhhHxQUlbpv23iohVNcfycq9mZm0atuVe9wKWRsQ9EfEMcAFweM0+\n", - "DwKbp9ubA4/WJgwzM+ufKpPGHODe3PZ96b68c4DdJD0A3ASc0KfYzMwakyaRppCmqg6l39ar8LWL\n", - "XBf7EHBjRExImgdcJmn3iHiydsd0KWvaZERM9iZMM7NEErCK/Adu6SYidq8spjZImgAmujlGlUnj\n", - "fmBubnsu2dlG3iuB0wAiYpmku4FdgBtqDxYRC8oJ08wMkFYC69fcOzUsCQMgfZienN6WdGq7x6jy\n", - "8tQNwE6SdpC0AfBW4OKafW4nGyhH0lZkCeOuvkZpZuNNegwpWDthBPARImZWFFVlKjvTiIhVko4F\n", - "fgTMBM6LiCWSjkmPfwH4JPBlSTeRJbgPRMT/VBWzmY0R6SjgP4Da6qLlRGzW/4AGQ2Ult73kklsz\n", - "6ylpFdmH2bxVRNRenhpqnbx3VjmmYWY2WKQVwEY19wYwk1H4hN0DbiNiZjZdQrtuwlhMxAwnjDV8\n", - "pmFm46teCW1mJREbVhDRwHPSMLPx1LiEduwqotrhy1NmNl5cQtsVn2mY2XhwCW1POGmY2egbkxLa\n", - "fnDSMLPR5RLanvOYhpmNHpfQlsZnGma2FkmHAMeTveE+BZwZEZdWG1VBLqEtnZOGma2WEsYZwI65\n", - "u+dJYhASR9OE5hLavnDvKTNbTdJC4KA6Dy2MiIMbPKcvZyYNEtrS/4YXzF2zwue0AE4h4rRexzFK\n", - "3HvKzLpVOwYwbeN6dzY5M9kT2JeaRJLWbziW7IzgGeDsiPhYwdiOz7/OjsAdsGOddzyX0JbIScPM\n", - "8p5qcP+K2jtSwjgf2LLmoR2BDwCb5O6bJ+ltwFtY+xLSh9OlryKJY3VCe4asfrYmYbiEtg9cPWVm\n", - "eWcCS2vuWwaclb8jd4ZRmzCmbVKzvSPrJgzS9rG1x5a0UNJk+n5IeuippcAU2addkV2DSot0z3DC\n", - "6A+faZjZaukSEsBxZJekVgBn1RmjWOtSUUGN3tRX39/octcD0ieehT3EmmQB8BlY/n54S4zC4OyQ\n", - "8EC4mbVN0iRwQI8O90hEPD8dd52B+On62ek/8AAegXhBtupnvYRmBXkg3Mz6pdHYRyvB2kMRzwBn\n", - "57ZXj1s8TXYKUvOONqWImc9nzdmG9ZfHNMysE/XGPopYBjwCPJG+n1YzCP7UI2TjFNMJI41buAvt\n", - "gKg0aUiaL+l2SXdKOqnBPhOSFkm6JZ0Sm1nF0iWhE4BfkZ0U1Pof4MGa+5YBJ0TE8yNiVvq+JmFI\n", - "Rz0Lr9uCtS9FLYflM+H1nnMxGCob05A0E7gDOBC4H/glcERELMntMwu4BjgoIu6TtGVEPFLnWB7T\n", - "MKtAk8mANwCn0npAffpAa3WhDWAVrNoAftL0edaVYRvT2AtYGhH3AEi6ADgcWJLb523AtyPiPoB6\n", - "CcPMKtVoMuDy9Ebf/M2+QRdawcz1XRI1kKq8PDUHuDe3fV+6L28nYAtJV0i6QdLb+xad2QhqMgei\n", - "U4UnA9YE4i60Q6rKM40ivxTrAy8DXkM2WehaSb+IiDtrd5S0ILc5GRGTvQjSbFSU1IzwTGBezTFX\n", - "Twas7Uu1I5x5J1yCu9BWQtIEMNHNMapMGvcDc3Pbc8nONvLuJavhXgGskHQVsDuwTtKIiAUlxWk2\n", - "KupNyNuRbNyho6TRbDJgbZK6G9h+3fEPd6Hto/RhenJ6O/UCa0uVl6duAHaStIOkDYC3AhfX7POf\n", - "wP6SZkraBNgbuK3PcZqNiraaERYVEZdGxMERMZG+Tyeg44EdP0lWQrs9a83mLlRCW8LlNOtSZWca\n", - "EbFK0rFkszpnAudFxBJJx6THvxARt6fqjMVkv3fnRISThllnOht/6NBeMOdaskQxnSwC+AGsen2B\n", - "PlGDvrbHuHIbEbMx0eBNeBlwfM/fhKVVATPz8y0eArbJNhuuzVETb9tre1h7hq3k1sz6qI1mhJ3L\n", - "ldDmu9Dm3mjW6Zi77iFWD57v02CXri6nWXecNMxGSKtV9ArNnejguGTdGl5FTauoX8CyV2aFK4WS\n", - "VIOzoVqlXE6zYpw0zEZEWWMATY8LP2RNI9q8lURsuC9tNxZs1XK95ZmKlatQ9ZSkTSTtUnYwZuOi\n", - "pKqgZiW1PT/u01m14xRrv49MEaEu5lw0qvB6AlhIGeMv1paWSUPSYcAisionJO0hqbY01swKyn1y\n", - "P4hsTYqDgDN6kDhKKamtPe7trO5COxPWdKH9V7hK8IYuX6tRhde1NeW8VpEiZxoLyOZHPAYQEYuA\n", - "F5UYk9moK+uMoKyS2qcgm0b8LLAz63ShZSboxGxMo9vkV2i5WatOkTGNZyLi8VR1MW2qpHjMxkFZ\n", - "ZwRNW3p0c9xn4KCZrJ0sVsGzG+Q60yalzTDvKHLruSJJ41ZJRwLrSdqJ7FPSz8sNy2yklXJGUMob\n", - "rrQicklueoLe4XDo9+ED1F/ytesZ5nSYdKx8RS5PHQfsRrbQyjeA3wP/t8ygzAZBiS0sSrsE06Sl\n", - "R3sadKEVLJ4RoUuy4/Z1hrkNhiJnGrtExIeAD5UdjNmgKLOFxUBfgskCa1hCW3NfWZfDbIC1bCOS\n", - "llidDXwTuDAibulDXG1xGxHrtbFsYSGtJFuOIK9pF9qUXOsmv5YTAq1ypbQRiYgJSVsDbwG+IGlz\n", - "4KKI+ESHcZoNg7IGqweP9Bgwq+beAE4puC63ar672eAIKzQjPCIeJCul+ylwEvBRwEnDRtnoX6+X\n", - "jgL+g5rWH8ByIjZr/fTGiYES1u6wwdAyaUh6CdlZxl8CjwIXAu8rOS6zqo329XppFeuWy66iQMvy\n", - "nGaJYXzO1MZMkTONLwEXAAdFxP0lx2M2EAZ6sLobuS60OQHM7GBd7maJYfTP1MZUkTGNRu2JzUba\n", - "SM0XaNCFFlhMxO4dHrVZYjiLUT5TG2MNk4akb0bEmyXdXOfhiIiXlhiX2VgprdKoQQnt07ByI7gC\n", - "2IisUqyT12t4CW9kz9SsccmtpG0i4gFJ00v75kVE/Kb06Apyya0NswYDykuBE7qczV23hDY1FezJ\n", - "6zUrubXB18l7Z5F5GqdHxEmt7quSk4YNs57PCWlRQjuWc1Csrk7eO4u0EXldnft60k5B0nxJt0u6\n", - "U1LDJCRpT0mrJL2pF69rNmB6U2kkHZVaf9QmjOVEzMjNuXBlk3Ws2ZjGe4D3ktVd58c1ngNc0+0L\n", - "S5oJnA0cCNwP/FLSxRGxpM5+p5MtwOKzCRtF3VcatVdC68om61iz6qmvky3l+CmyCX3Tb9hPRsSj\n", - "PXjtvYClEXEPgKQLgMOBJTX7HQd8C9izB69pVpouBrM7nxPSWQntaM9BsVI1TBoR8QTwhKQzgMci\n", - "4vcAkjaXtHdEXNfla88B7s1t30e22NNqkuaQJZI/J0sa7daRm/VFg8HsV0laApzSLHl0VGnURQmt\n", - "K5usG0Um930eeFlueznw78AeXb52kQTwWeDkiAhlv+UNL09JWpDbnIyIye7CM2tLvdnRG5P97ZzR\n", - "qudS4Tkh7XWhbWik5qBYYZImyBZh7FjR3lNTudvPpnGGbt0PzM1tzyU728h7OXBB+lS0JXCwpGci\n", - "Yp01yiNiQQ9iMutUo8Fl6FXPpQ660PaDu9kOj/RhenJ6W9Kp7R6jSNK4W9LxZGccAt4D3NXuC9Vx\n", - "A7CTpB2AB4C3Akfkd4iI1WuRS/oycEm9hGE2ABoNLk9bqzKprTfa7rvQlsbdbMdPkaTx92QDZx9J\n", - "25cDf9ftC0fEKknHAj8iq/o4LyKWSDomPf6Fbl/DbFofPg3XG1zOW12ZVPiNtssutH3ibrZjpuXk\n", - "vmHgyX3WTGkzruu/zsfIlkfOn1ksA47PLU7UenJdb7rQli4t0lZvnfArI2Kiv9FYu0qZ3CdpF0mX\n", - "S7o1bb9U0kdaPc9sgDT7NNwzaX3uPcmWEVgIXJm+H1+TnBpPrpNWIGUls7lDAzMGLWEknvMxZorM\n", - "CD+HbH3wlWn7ZmrGHswGXF9nQKfkcXBETKTvtWcz67zRng88m31ir411cZrNPaiXBM4kO2vL85yP\n", - "EVZkTGOTiLguVTCRyl+fKTcss54atE/Da41/TNfP1lwjaKuEtiqe8zF+iiSN30lafWov6S+BB8sL\n", - "yaznBmoG9PQb7Ur43nqwfk2yqLyEtl2e8zFeinS5nQd8EdgXeBy4Gzhyuv3HIPBAuLUyUC28B7iE\n", - "1sZLT1ujSzohIs6QtH9E/EzSZsCM6XYig8RJY3wN1cSy4SihtTHS66RxU0TsLmlRRHTbMqRUThrj\n", - "qV+ltD0xJCW0Nl56XXJ7m6Q7gV0k3Vzztbi7UM16oi+ltF2pKaENYAo4FA51wrBh1KzL7RGSZpPN\n", - "2D4Mr2Vhg2dwFxOq6UI7fT7/beDN2c2WTQzNBlGzRZguj4jXSPrRIK0HbpYzaKW0dbvQBtkkp5oM\n", - "51YbNpSaldxuLWk/4LC0QJLItTOPiP8qOzizFgaqlLZRF9oZcDX1W21Uf0Zk1qZmSeNU4BSyxZL+\n", - "tc7jry4lIrOCBmZiWasS2qzXVD1utWFDp8g8jY9GxMf7FE9HXD1llShYQtugymutJoZmVehpyW3u\n", - "oDOAI4EXRsTHJW0HzI6I6zsPtbecNIbHUM2raKbNEtqBmlxolpSVNP6drErwzyPixZK2AH4cEa/o\n", - "PNTectIYDkM1r6IRaQXrVm1lJbWD21TQrK5SWqMDe0fEe0nXXyPif1h3sM+siMGfV1GHpEO+L/1m\n", - "SooYvi60Zj1VpGHhyvya4JKeT3bmYdauwZ1X0cDh0iGr4Af5LrSphHblhkPQhdas14okjbOA7wIv\n", - "kPRJsgVmvAiTdaLteRWVjoFIK7+X60I7PZs7/dH81KcWNo5aJo2I+KqkXwGvSXcdHhFLyg3LRlRb\n", - "8yoKr6Xda7kS2unJSUFWDXLBmr0G9uzIrEyVrhEuaT7wWbIqlHMj4vSax48EPkD2t/sk8J6IWKfv\n", - "lQfCh0c7VUSF1tLubXDrlNAG8Ftgdr9iMOujTt47i1yeKkUaJzkbOBC4H/ilpItrzmLuAl4VEU+k\n", - "BPNFYJ/+R2u90uaCPf0bA2lQQjsDDqf+HAsvZ2pjqbKkAewFLJ1ezCm1KjkcWJ00IuLa3P7XAdv2\n", - "M0CrXPm9pVqU0AbT7aQ8x8IM2kgakjYiWyL86R699hzg3tz2fcDeTfZ/N27uNm7K6y1V04U2ZzER\n", - "u+fv8HKmZms063I7A3gjcATwSrI5HZL0LHAt8DXge9H5oEjh50l6NfAuYL8m+yzIbU5GxGSHcVkT\n", - "/axmKqW3VJ0utABPw8qN4Apgo9Qrajhnqps1IWkCmOjqGE1W7ruKrDvnxcCN02cYkjYE9iBbY2P/\n", - "iHhVRy8s7QMsiIj5afuDwFSdwfCXAt8B5kfE0gbH8kB4H/RqRndlZbQNutAK3sCwz1Q360Cvl3vd\n", - "sNWlqCL7NHnuesAdZKW8DwDXA0fkB8JTn6ufAn8dEb9ociwnjT7oRTVTJa1EWnSh7XuVltmA6Gkb\n", - "kdyZxb9J2q3ZPp2IiFXAsWQrA94GXBgRSyQdI+mYtNtHgecBn5e0SNLANEkcU72oZupfKxHpKKQp\n", - "1k0Yy1Prj9PSdqOfa46khZIm0/dDeh6j2ZApMhC+BPiipPWBLwHfiIgnevHiEfFD4Ic1930hd/tv\n", - "gL/pxWtZT/Simqk/ZbTtdaFt9HPNA/4kv+0lWm3ctWxYGBHnRMR+wFHADsDNkr6eBqdtvJxJdikp\n", - "r91qpnLLaKUVSFnJ7BoBzGjUtpz6P9cfgU1q7hv45opmZStUcpsm4r0Y2BX4HXAT8D5Jfx8Rby0x\n", - "PhsgPapmKqeMto0S2loNfq45rH2WMc3tQ2ysFVlP4zNk1SU/JWv1cX3usTsiYpdyQ2zNA+HDpacL\n", - "EjUooQVW0kUXWg+O2zgoaxGmdwIXRcTyOo/NiojH2wuz95w0xlSDEloiascyOji0l2i10VdK0qjz\n", - "ItsAj/ZwZnjXnDTGTIsS2t69jJdotdHWr6RxOdk16W9FxIltPbkkThpjok4XWoDlsHwz+BnDvu64\n", - "WZ/1pcttRLwmtRjZtd3nmnWsQQmt1nShzY8/uDTWrCQtS24lHVjn7rdHxK0lxGO2ttYltEO57rjZ\n", - "sGqZNIBTJX1e0qaSZku6hKzvlFl5pMk0m7t2MuDiNJt7+rrq0K07XkvSIZ55bsOiyOWpA4D3k83N\n", - "CODUiPh6qVHZ+Gq/hLb8NTdKVNmStmYdKnKm8TxgT7Jyw5XAdkozocx6KiuhnWLt38spItRkzkUv\n", - "ZqlXyZfXbKgUSRrXAj+KiIPIkscc4JpSo7LxIj2Wxi3ycy4C+EirORfp0/gJwELgyvS98FyKAbg0\n", - "NPSX12y8FLk89dqI+A1ARPwROE7SAeWGZWOhQQktWRfazYoeptOV9Qbk0tBQX16z8dPwTEPSPIDp\n", - "hJEXEVfm9zFrW1ZCez4pYQRwE4TgSsHP+vSJv9GlofP7eMYx7JfXbMw0O9P4pKRNyVbuuwF4kOwP\n", - "fGvgFWQVVE8Cf1V2kDZCpBXUXJJZCbE5LHs6e8OePovtxyf+RpeGtgTO6McZRylL2pqVqOmMcEk7\n", - "kiWF/YDt092/IZt9+42IuKv0CAvwjPAh0KQLrbIPJH1vDtikKWFfXt+saj2fEZ7W5P7HrqKy8Van\n", - "hDaAJ2DqefCGiLg0JZR6yh4MrtemvZ+vbzZ0iq6nMX2msXr/iPhKWUHZiKjpQhtk9bTpl2gG6RIQ\n", - "FQ0G5y4NnU92Saqvr282jIq0Efkq8M/A/mQlt9NfZvXVKaGdIrs2VfMpZXo+QmWDwWns4B1Vvb7Z\n", - "sClypvFy4CXRbjvcAiTNBz5L1lfo3Ig4vc4+ZwIHky2/eXRELOp1HNYjTUpoZ2bFFPVKtTeuejC4\n", - "6tc3GyZFksYtZBVTD/TyhdMSsmcDBwL3A7+UdHFELMntcwiwY0TsJGlv4PPAPr2Mw3qkQRfa1ety\n", - "Z4PO9ayAzuda9ErVr282LIokjecDt0m6HpheeCkiotumhXsBSyPiHgBJF5C1uV6S2+cwsuvNRMR1\n", - "kmZJ2ioiHu7yta1X6pTQkg1fzGTts9Ny1gY3s74qkjQWlPTac4B7c9v3AXsX2GdbwEmjak1KaInY\n", - "vXZ3XwIyGw0tk0ZETJb02kXHSGrflOo+T9KC3OZkiXGPt/a70K7mS0Bm1ZI0AUx0c4yWSUPSvmSX\n", - "FnYFNiS7bv2HiNi8mxcmG8eYm9ueS3Ym0WyfbdN964iIBV3GY63UlNAmU62aCprZYEgfpientyWd\n", - "2u4xinS5PRt4G3An2bXrdwOfa/eF6rgB2EnSDpI2AN5K1rIk72LgKABJ+wCPezyjAl10oTWz0VJo\n", - "cl9E3ClpZkQ8C3xZ0o3Ayd28cESsknQs8COys5fzImKJpGPS419I18EPkbQUWA68s5vXtDb1qAut\n", - "mY2Opr2nACRdBbwWOJesR9BDwDuizmBnVdx7qgStSmjNbOh18t5Z5PLUUWm/Y8km2G0L/EX74dlQ\n", - "kFakS1H5hBHADCcMM2t5pgEgaRNgbkTcUX5I7fOZRg+0WUJrZsOvlDMNSYcBi8jGHpC0h6TaAWsb\n", - "VpKQniVr8ZH/5VmZ1uZ2wjCz1YpcnlpANunuMYDU++lFJcZk/ZKV0E6x9u/BVEoWTedcmNl4KpI0\n", - "nomIx2vumyojGOsTl9CaWYeKlNzeKulIYD1JO5Gtq/zzcsOyUriE1sy6VKTkdlPgw8Dr0l0/Aj4R\n", - "EY0Wzuk7D4QX4BJaM6vRyXtnoeqpQeek0UTxLrRmNmbKqp7aU9J3JS2SdHP6Wtx5mNYX0iTSFOsm\n", - "jMVEzHDCMLNOFBnT+BpwItliTB4AH3RddKE1M2ulSNL4XUR4XsYwcBdaMytZkYHw15F1oP0JsDLd\n", - "HRHxnZJjK2zsxzSkx4BZNfcGcAoRp1UQkZkNgU7eO4ucabwD2CXtm788NTBJY2y5hNbM+qxI0ngF\n", - "8OLwwGkhkg4hm8uyEfAUcGYpS5q6hNbMKlAkafwceAlwa8mxDL2UMM4AdszdPU8SPUscLqE1swoV\n", - "GdO4HZgH3A08ne6OiHhpybEVNihjGpIWAgfVeWhhRBzc5cEncRdaM+uhssY05ncYzziqPQOYtnHH\n", - "R3QJrZkNkJZJIyLu6UMco6JRa5UVHR2tpoQ2gCmYWg8uA870tSgz67ciXW6tuDOBpTX3LQPOauso\n", - "NV1oU7KIjwDrZf9nBwFnpDEUM7O+qaz3lKQtgAuB7YF7gLfUtmCXNBf4CvACsvfOL0bEmXWONRBj\n", - "GrB6MPw4sktSK4CzCg+CNyih/QMsfw5sWucZ3Y+V2Fr6Vv1mNgCGqmGhpE8Dj0TEpyWdBDwvIk6u\n", - "2Wc2MDsibpS0GfAr4I0RsaRmv4FJGh1rUkKrbBD8gDrPujIiJsoObVw0qH5bCpzgxGGjqJSGhSU6\n", - "DDg/3T4feGPtDhHxUETcmG7/AVgCbNO3CPtBWpEuReUTRgAzcnMuejtWYo0cz9oJg7R9XAWxmA2k\n", - "KpPGVhHxcLr9MLBVs50l7QDsAVxXblh90l4X2t6MlVgrva9+MxsxRUpuOybpMmB2nYc+nN+IiFD2\n", - "abvRcTYDvkV2meAPDfZZkNucjIjJtgPuhw5KaCPi0uxpHY6VWFE+o7ORJmkCmOjqGBWOadwOTETE\n", - "Q5K2Bq6IiBfX2W994PvADyPisw2ONRxjGu5CO9AajGksA453grZRNGxjGheTNUMkff9e7Q7KPl6f\n", - "B9zWKGEMhZoS2iSAjzhhDI6UGE4AFgJXpu9OGGY5VZfcXgRsR67kVtI2wDkRcaik/YGrgMVkb7IA\n", - "H4yIhTXHGswzDXehNbMBNlQlt700kEnDXWjNbMCV1XvK2uEutGY2wtxGpFfaK6E1MxtKPtPolrvQ\n", - "mtkYcdLohktozWzM+PJUJ1xCa2Zjymca7XAJrZmNuZFKGqW2tXYJrZnZ6CSNBi0g5kmiq8ThEloz\n", - "s9VGaUyjt22tXUJrZraOkTnToFdtrV1Ca2bW0Cglje7bWruE1sysqVG6PNX5QkUuoTUzK2RkzjQ6\n", - "WqjIJbRmZm0Z3y63PSyhLbXU18ysJO5yW0SPS2hLK/U1MxtAozSm0Vx5JbS9LfU1Mxtgo3+mUX4J\n", - "bW9Kfc3MhsBoJ43+lNB2X+prZjYkKrk8JWkLSZdJ+rWkH0ua1WTfmZIWSbqkjRfoZwlt56W+ZmZD\n", - "pqoxjZOByyJiZ+DytN3ICcBtZG/6zUlHpXGL2iS0PI1bnNZhvA2lwe4TgIXAlen78R4EN7NRVEnJ\n", - "raTbgQMi4mFJs4HJiHhxnf22JZtHcRrwvoh4Q4PjRcCzuAutmVlhnZTcVnWmsVVEPJxuPwxs1WC/\n", - "zwD/AEwVOGY+YQQwwwnDzKy3ShsIl3QZMLvOQx/Ob0REKBt/qH3+64HfRsQiSRNtvPRiInZvK1gz\n", - "MyuktKQREa9t9JikhyXNjoiHJG0N/LbObq8EDkuT5zYCNpf0lYg4qt4xPwrPfgL+Mb3ARERMdv1D\n", - "mJmNkPQBfKKrY1Q0pvFp4NGIOF3SycCsiGg4GC7pAODEpmMa7bYRGQBuP2JmVRqmNiKfAi6S9G7g\n", - "HuAtAJK4Dbw+AAAK20lEQVS2Ac6JiEPrPGf4m2TluP2ImQ2j8W1YWDFJC4GD6jy0MCIO7nc8ZjZ+\n", - "hql6ytx+xMyGkJNGddx+xMyGjpNGddx+xMyGzmg3LBxgHa00aGZWMQ+Em5mNKQ+Em5lZqZw0zMys\n", - "MCcNMzMrzEnDzMwKc9IwM7PCnDTMzKwwJw0zMyvMScPMzApz0jAzs8KcNMzMrDAnDTMzK8xJw8zM\n", - "CnPSMDOzwpw0zMyssEqShqQtJF0m6deSfixpVoP9Zkn6lqQlkm6TtE+/YzUzszWqOtM4GbgsInYG\n", - "Lk/b9ZwBXBoRuwIvBZb0Kb6+kjRRdQydGubYwfFXzfEPn6qSxmHA+en2+cAba3eQ9FzgzyLiSwAR\n", - "sSoinuhfiH01UXUAXZioOoAuTVQdQJcmqg6gSxNVB9CliaoD6LeqksZWEfFwuv0wsFWdfV4I/E7S\n", - "lyX9l6RzJG3SvxDNzKxWaUkjjVncXOfrsPx+ka03W2/N2fWAlwGfi4iXActpfBnLzMz6oJI1wiXd\n", - "DkxExEOStgauiIgX1+wzG7g2Il6YtvcHTo6I19c53vAvdG5mVoF21whfr6xAWrgYeAdwevr+vdod\n", - "UkK5V9LOEfFr4EDg1noHa/eHNjOzzlR1prEFcBGwHXAP8JaIeFzSNsA5EXFo2m934FxgA2AZ8M4R\n", - "Hgw3Mxt4lSQNMzMbTkM5I7zo5MC070xJiyRd0s8YmykSv6S5kq6QdKukWyQdX0WsuXjmS7pd0p2S\n", - "Tmqwz5np8Zsk7dHvGJtpFb+kI1PciyVdI+mlVcTZSJF//7TfnpJWSXpTP+NrpeDvz0T6W71F0mSf\n", - "Q2yowO/OlpIWSroxxX50BWE2JOlLkh6WdHOTfYr/7UbE0H0BnwY+kG6fBHyqyb7vA74GXFx13O3E\n", - "D8wG/jTd3gy4A9i1onhnAkuBHYD1gRtrYwEOIZuICbA38Iuq/53bjH9f4Lnp9vxhiz+330+B7wN/\n", - "UXXcbf77zyIbs9w2bW9ZddxtxL4A+KfpuIFHgfWqjj0X358BewA3N3i8rb/doTzToMDkQABJ25L9\n", - "g5wLDNJgecv4I+KhiLgx3f4D2Wz4bfoW4dr2ApZGxD0R8QxwAXB4zT6rf6aIuA6YJane/JsqtIw/\n", - "Iq6NNeNl1wHb9jnGZor8+wMcB3wL+F0/gyugSPxvA74dEfcBRMQjfY6xkSKxPwhsnm5vDjwaEav6\n", - "GGNTEXE18FiTXdr62x3WpFFkciDAZ4B/AKb6ElVxReMHQNIOZJ8Uris3rIbmAPfmtu9L97XaZ1De\n", - "eIvEn/du4NJSI2pPy/glzSF7M/t8umuQBiuL/PvvBGyRLsneIOntfYuuuSKxnwPsJukB4CbghD7F\n", - "1itt/e1WVXLbkqTLyC7R1PpwfiMiot48DUmvB34bEYuq6A/Tbfy542xG9unxhHTGUYWib0C1Z3OD\n", - "8sZVOA5JrwbeBexXXjhtKxL/Z8nmMYUkMVhn1kXiX59sMu9rgE2AayX9IiLuLDWy1orE/iHgxoiY\n", - "kDQPuEzS7hHxZMmx9VLhv92BTRoR8dpGj6VBndmxZnLgb+vs9krgMEmHABsBm0v6SkQcVVLIa+lB\n", - "/EhaH/g28NWIWGcuSx/dD8zNbc8l+zTSbJ9t032DoEj8pMHvc4D5EdHsdL7fisT/cuCCLF+wJXCw\n", - "pGci4uL+hNhUkfjvBR6JiBXACklXAbsDVSeNIrG/EjgNICKWSbob2AW4oS8Rdq+tv91hvTw1PTkQ\n", - "Gk8O/FBEzI1sRvlfAT/tV8IooGX86dPiecBtEfHZPsZWzw3ATpJ2kLQB8FaynyHvYuAoAGUt7B/P\n", - "XYKrWsv4JW0HfAf464hYWkGMzbSMPyJeFBEvTL/v3wLeMyAJA4r9/vwnsH+qdtyEbED2tj7HWU+R\n", - "2G8nm3xMGgvYBbirr1F2p72/3apH9jusBtgC+Anwa+DHwKx0/zbAD+rsfwCDVT3VMn5gf7KxmBuB\n", - "RelrfoUxH0xWwbUU+GC67xjgmNw+Z6fHbwJeVvW/czvxkxVLPJr7t76+6pjb/ffP7ftl4E1Vx9zB\n", - "78+JZBVUNwPHVx1zG787WwKXpN/7m4G3VR1zTfzfAB4AVpKd0b2rm79dT+4zM7PChvXylJmZVcBJ\n", - "w8zMCnPSMDOzwpw0zMysMCcNMzMrzEnDzMwKc9IwSyRdmNpAdHOMDSVdJan0v63USvySdPsNLVqm\n", - "P1fSe3Lb20j6Ztkx2uhx0jADJO0IbBoRy7o5TkQ8DVxNg87LBWNp++8yIi6JiNOb7PI84L25/R+I\n", - "iDd3Ep+NNycNGzipZcPtkr4s6Q5JX5P0urQ40q8l7Zn22zQtMHOdpP+SdFju+VdJ+lX62jfdPyFp\n", - "UtI3JS2R9NXcy/4VqT2EpO3T6/wvSTMkXS3pwJoY3ynpM7ntv5X0b2nzYuCIJj/XVyXdluLYOD12\n", - "j6RPSfoV8Ob08/48xX+RpE3TfvNT7L8C/nfu2EdLOivd3krSd5UtCnRj+vk/BcxTtsjR6elnvCXt\n", - "v1H6t16c/h0ncsf8jqQfpn+PZknJxkXVU9z95a/aL7IFb54BdiPrvnkDcF567DDgu+n2J4Ej0+1Z\n", - "ZK0eNgE2BjZM9+8E/DLdngAeJ2vXIuDnwH7psR+Sa59A1h79IrLW+p+vE+OmZG0XZqbta4Dd0u0N\n", - "gfsb/FxTwL5p+zzg/en23cCJ6faWwJXAxmn7JOAUssab/w3MS/dfSGqPAxwNnJW7//h0ewbZGg/b\n", - "k1uEJ8Vyc7r9fuDcdHsX4DfpZzgaWAY8J23fA8yp+vfDX9V++UzDBtXdEXFrRARZP6KfpPtvIXvD\n", - "A3gdcLKkRcAVZG9sc4ENgHMlLSZ74981d9zrI7s0E2R9vbZP929PtpgOABFxHvBcsh49J9YGFxHL\n", - "yVbJe4OkFwPrR8St6bGngRmSNqrzc90bEdem218l6zE27cL0fR/gJcDP0892FLAd2Rv63bHmEtpX\n", - "qd8C/dWkdTUiYioift9gv2n7pWMREXeQJY2dydpjXx4RT6af6TbW/NvbmBrY1ug29p7O3Z4ia7Y2\n", - "fTv/e/umqFlzQdIC4MGIeLukmcBTDY77bM2xVr+xpk6r25K9cT4HWF4nxnPJ1kdZAnyp5jFRf02C\n", - "aLJP/jUui4i3rXVAafc6r9FIu+tpNNq/9t9rZpvHtRHjMw0bZj8Cjp/ekLRHurk58FC6fRTF3uh+\n", - "A2yd2z4d+H/AqWRrbEy/xuWStgGIiOvJEsvbyDqJTu+zIfBs+nRea7vUfpr0vKvr7HMdsN90JVca\n", - "u9mJrAX3DpJelPZbZ9wkuRx4T3ruTEmbA0+SJb96rgaOTPvvTHZWczv1E8kgLe5kFXDSsEFV+yk9\n", - "6tz+BLB+GsC9BfhYuv9zwDsk3Uh2SecPdZ5b62fAKwAkHUC2qNHpEfF1YKWkd6SqpnlkLdSnXQT8\n", - "LNasLw7Z0rzXUt8dwP+RdBvZ5a91lmeNiN+RjSd8Q9JNZGMvu6Qk9HfAD9JA+MO550Xu9gnAq9Pl\n", - "uRuAXSPiUeAaSTenAe38/p8ju5y2mGwN7HdEth52fp/V4TX4uWxMuDW6GZA+vZ8VEYc22Wc34J0R\n", - "cWLuvkuAf4uIK3L3fZJs8P27Nc/fAbgkIv6kx+Gb9Y3PNMyAiLgLeLLZ5L40MH8igKRZku4A/liT\n", - "MDYkG9xutDyvP6XZUPOZhpmZFeYzDTMzK8xJw8zMCnPSMDOzwpw0zMysMCcNMzMrzEnDzMwK+/9K\n", - "KsiXDl+gdgAAAABJRU5ErkJggg==\n" + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4lFX2xz8nCaSQAKGHXkIPKIqABVBEEOwFUVdd+66r\n", + "4trbrpNXf+oW196xrm0FxQ4IqIAgRVCR3msIoQRIQkJIub8/zp3MZDKTTJIJCTDf53mfmbfde992\n", + "zrmnijGGMMIII4wwjh1E1PYAwggjjDDCOLwIE/4wwggjjGMMYcIfRhhhhHGMIUz4wwgjjDCOMYQJ\n", + "fxhhhBHGMYYw4Q8jjDDCOMYQJvzVgIgUi0jnGmx/sIisqqn2axoisklEzqztcdQGRCRWRL4SkX0i\n", + "8rHd9n8isktEtoe4rwdFZHwo2ww1RORaEfmxlvruaL/VCLs+WUSuPgz9porIezXdT1VwzBB+S4Ry\n", + "RSTbLlki0qoWx5MqIgV2HFkislpEXvAekzHmR2NMjyDbqosvmLFLpWGf17AQj+dw4lKgBdDEGDNW\n", + "RNoDdwE9jDGtq9qoiJwuIlu9txljnjTG3FS94R47MMaMNsZU+L2E4B2ss0FSxwzhRx/CucaYBLs0\n", + "NMbsqOXxfGSMaQgkAhcBrYDFtcmQ6hAMILU9iGqgA7DGGFNs19sDe4wxe2pxTEcFRCTyMHV1pL+D\n", + "AXEsEX6/EJF3ReQu+7+NnRL+xa53EZE9XsfeKyLbRWSbiFxf3a7tgjGmyBizAhgL7ALutv2Vku5E\n", + "5H7bd5aIrBKRYSJyNvAgMNbOZH61x14nIivssetF5Gavdk637dwlIhn2mq712h8rIv+xEs8+EflR\n", + "RGLsvkEi8pOI7BWR30RkaAXXOUBElotIpoi8JSLRXv2ca9vYKyJzRaSP3f4eSii/std0r4i8U4nn\n", + "5Lddu6+1iHwqIjtFZIOI3O61L1VEJth3IktElonIiQEfoEgPEZkuInvs8xhjtzvA372eyc3ANKC1\n", + "XX+ronspIk1E5G0RSbP3bpKIxAFTvNrJEpEk7xmfiEwRkVt9xrlERC4sb8wBrq8671BTEflSRPaL\n", + "yAKgSzn9uFUxN9nr3S4id/s8l09E5D0R2Q/8UUQaicib4vkeHxOPKidCRJ4SVautB87x6W+miNzg\n", + "tX6T13UuF5F+ft7Be4J4Zp1EZJZtZxrQLNA11zqMMcfEAmwEzvSz/TrgS/v/SmAd8D+7fj3wmf1/\n", + "NrAD6AXEAR8CxUDnKo4nFXjPz3YHmG//nw5stf+7A1uAVna9vbtvwAX816ed0UAn+38IcADo59Vu\n", + "gR1DJDDK7m9k978EfA8kocLBIKA+0AbYDZxtjxtu15sFuMZNwO/2vERgDvCY3dcPyABOQhngNfYZ\n", + "1fN6XsOq8JwCtmuvZTHwNyAK6ASsB0Z4PZM8+6wFeAKYF+DaGgBbgT/ado9HmXZPf88EGOp+lnY9\n", + "0L1sate/AT4CGtmxDvbXjm9fwNXAHK99vYC99vrLHbOfa6zOO/Q/u8QCvYFtwOwA/XREv6UP7PEp\n", + "wE7s92r7OAScb9djgM+AV+zxzYEFwM12/5+BlXjeux+AIiDC7v8BuN7+H2PHdqJd7wK0D/AOVvTM\n", + "5gFP2Xs9GMjC57usK0utD+CwXagSoWz7EewFJnk96Ez0Q38FuBkPsX0X+Kv9/xbwhFd7XakZwv9n\n", + "VEXg/rjcY0lGCdqZWOJYUVs+x3wGjPNqN9f9IdhtGcAAlCDkAn38tHG/74sMTAWuCdDnRvfHaNdH\n", + "Aevs/1eAR32OX4WHwPl+dME+p0DtDgEGApt99j0IvOV1H6d57esF5Aa4trH4EDLgNeARf8/E+1lW\n", + "dC9RhluEJaI+x5Rqx7cvIAHIAdrZ9ceBN4IZcxDvbLDvUCRKqLt57Xsc+DFAux3Rb8n7+H96jTsV\n", + "mOm1ryVwEIjx2nYF8L39/73Pe3eWbd8f4f8WuL2c99f7HSzvmbVHGWGs174PqOC7rK3lWFL1GOAC\n", + "Y0yiXS4GMMasRyWV41Eu/TWwXUS6ocRilj0/CZWW3NgSqCNRbxy3EXlpJcfZBiijBzbGrAP+in4E\n", + "GSLykYgklTOGUSIy307p96LSW1OvQ/YYj/4Z9COOR6enMagk7IsOwBg7zd1r2z0VtU0Egu89cxs2\n", + "OwB3+7TV1mt/KVTiOQVqN8nua+2z70HUCOtGhs89iXGrEPzci4E+bV2JEqVgUN69bAdkGmP2B9lW\n", + "CYwx2ehs4Qq76XKUAFV6zNV4h5qjs5SgvhcvBHpXQKVyNzqgUnW613W8avuFSnyr6Lvh7133h/Ke\n", + "WWtgrzEmz+v4zUG2e9gRVdsDqCOYhU756hljtovILOBadJr4mz0mHeXqbrQnAIwxP6KSV3kwvhss\n", + "gTkP1Qf7a/cj4CMRSUAltX+i0kaptkT16J8CVwFfGGOKROQzgjNU7UalqWRUTeONLagEc3OZswLD\n", + "956lebX1uDHmiQDnlbk/BPecArYrIoOAjcaYbpXoMxC2ALOMMSOq2FbAe2kZehMRaeSH+Ptr13fb\n", + "R4BL1H0yxhjzQ5Bj9h5Ddd6hXUAh+rxX220Bvxcv+B6f5rXP+xq3AvmoisWb8bgR9Ldq20oOsM/3\n", + "vpb3zDoAiSISZ4zJtZs7oDO3OodjSeIvD7OA24DZdn2mXf/R2DkbMAG4VkR6ihrZXNXss+QDEpEo\n", + "EemJfrAtgKfLHCzSTdSYG42+9AfxvFQ7gI4i4m6zvl12A8UiMgqo8GMHsB/SW8DToobDSBE5WUTq\n", + "A+8D54nICLs9xhr52pRzjbeKGmObAA8DH9t944E/i8gAUTQQkXNEJN7uz6CsQTCY51ReuwuBbBG5\n", + "T9SAHSkiKSLS32u8weJroJuIXCUi9exykoi43W8raivgvTTGpKNG3JdFpLFte4jXfWkqIg292vLt\n", + "azJKdBxUzx7smL1RnXeoCJgEpNr73Au1K1TEDP9mj++NMvSP/R1k78809B1NEDXmdvG6RxOAcfa9\n", + "SwQeKKfPN4B7ROQE+74ki7reQtl3sLxnthlYBDj2vp4GnFvB9dYawoRfMRudoroJylzUaORexxgz\n", + "FXgW1R+uAb6jen66Buv1AewDvkAlpRNNaTdTdx/RwJP2mHRUJfOg3TfR/u4RkUV2uj8O/QAy0Wn/\n", + "F376D4R7gKXAz6ja6UlUP7oNuAB4CDW+bUE9kAK9RwZVM0xDp9Nrgf8DMMYsBm4CXrRjXIvOXtx4\n", + "EiUEe8V68xDccwrYrmVq56Lqog3ovXwdcBNR4+e++L1PxpgclBBejkqm6XbM9YNpK4h7eTWqM16F\n", + "EqBx9rxVqICwQdTbJ8m3L2PMIZTwnok6IQQ7Zu/rq+47dBv6rHaggsRb5RzrxizUaD8D+LcxZoZX\n", + "P759XWPHvcKObyIeleN4VHe/BCXGnwYaqzHmE9T+8CFqjJ2EziDB5x0M4pldidqRMoFHUNtTnYR4\n", + "BKUqnKxuaecAO40xfQIc8zxq1MsFrjXG/FrlDsMII4yjDiLSEWXEUQFUN2GEGNWV+N9GXd/8QkRG\n", + "A8nGmK6oF8Yr1ewvjDDCCCOMaqJahN8aMfeWc8j52OmOMWYB0FhEgvV6CCOMMI4dVEdtGkYlUdM6\n", + "/jaUdqvahrpPhRFGGGEAYIzZZIyJDKt5Dh8Oh3HX1+MgzNnDCCOMMGoRNe3Hn4YGo7jRltK+uQCI\n", + "SJgZhBFGGGFUAcaYyieSq27oLxpuvTTAvtHAZPt/EDYHjZ/jTG2HMNfkAqTW9hjC1xe+vupcX28Y\n", + "fSOsNWDcy42wtjeMDnTO8PpM+6Qn5opLMLM6eM4bBVNqor9j9NmZqpxXLYlfRD5Ck0Y1E80i6UJD\n", + "qTHGvGaMmSwio0VkHRpuf111+gsjjOoiRWR0OxiXADHZcHArPL/MmMm1Pa66jnYwbjwkvzgADkXC\n", + "XfNgPCSPhtvRgDEAxJEE1MX70sh7GGa2wSUroNcuT1vxGntRYX+vQ/JlY+C9SRBd5L+/MKqGahF+\n", + "Y8wVQRxzW3X6OFoRJkCHHykio0+G516HZPfc+CbokiJC+N6XjwTN38SJ2+HaC+HOeWq8i4dYcSQR\n", + "TTVyCXAGmoX108EvkDgjmzKFTHI0A2qF/Qmworku/WxIYzBMI4yKEc7Vc3gw03vFTYDGe+UIOcIJ\n", + "0MzaHkBFEEfiU/rxf7QluVMX+P0VaJgftBQ58zANs7Yws6IDsjVFCIO2QVQxfN0VMhJgej96o8nI\n", + "fgA+Af5oXGYfQEqqpN8E7b3f8xth/RZ4Idj+jtsBS1p5CH8wTKOy13YsIkz4DwOMMTO9193T5r0x\n", + "cOllMHEijM87cqexvtdXVyCOdELVDucCp24/kcJey+Den5Tou1GRFFlXry9UCOb6tsLzVybQbXB3\n", + "Oh2KhEsuh1brOGAyeYN2PGFcJtv3nGXGTE4RYTTcHg+xOZC3BV4IRrjZCs/fBF2OyyB5iY38CZZp\n", + "VPbajkWECX8twD1tTjyoksyYMTD1fYgvPrqnsSIpo6HdOEiIgeyDsPV5Y5aFjNGJI1HAKXiIfTOU\n", + "kb4BjB3wBh/fCSN9z6uCFAkcG+o6caQdcDGpXLK8iBbTN5De+mf2F51Bcv3vuHZfhvmkvPPt/aj0\n", + "PXEzjZ+zcLb0Ink1zA+WaYRRMaqVqydkgxAxpiouSUcoRolMnWIJUJHA+VdA+/2w6RumTjFmVG2P\n", + "ryagRP/k52C8Vwrcm9bBvDuqQ/zFkaZo2pBz0Hu6Gc1C+TWwyLg8QUG+KrbZwNOQGwHr82B7ZQh3\n", + "AHXdunlwx5FOnOxM6RK0YHxX4CtUjTPDuMxBe8xEu/5aDY8lCU0Y2Ny46gCxqmOoKu0MS/y1APc0\n", + "djwkRxr46FNodzOHiv/AxtoeW82h3TgYn0zjTdDrE8hqA9lXJ5O36j5x5Hs3QakI4oigpfzORYl9\n", + "X1SP+zVwr3GZMnEibnirHgqhTVvo8rmW0ewD9AnGzmL7TxzQgYfPjSH5+cZwoB48OOfI9joRR7qh\n", + "hP4SNPbmc9RL7wfjMof8nPIm8BhaF6ImsQOtntUaPzFAcGzMvEKNMOGvBZTRfeaT1/AHJm67lCfE\n", + "kc+My0yv7TGGHgkxAEQUQMJ2aP0zNEyDxMUDgf3iSDb6YftbdgGd0Upb56DR31+j6XRnBss0QO+9\n", + "ODLllFeZdWZz4sa1hVt+hp67lXCPgnHiyHK0eEeHAL+FK84n6o3d0GE/JGd62j9SvE68GKhbsm+K\n", + "piS+B/jRuExhBU1MB14XR44zLrOkpsZpXMaII0uA4/BD+I9CR4nDgrCqpw5BHBmK5hUfbFxmdUXH\n", + "H0kQGTUVppTRr8O5mUjhz7Rb/Q7Xb1qN5ndqA/RAC6Z3Q4mSW2WzgwOR+0lv3ISshCIOROTQcM/n\n", + "HLf/a5QwbPeVUK06aACaK/0UYEB0DnHnbabewDS4Yim0sabJMzpgZl7HdlRltMXP7xbjMvu91XXe\n", + "GA1TJ9dRdZ0l9v1QYn8JOtv5FFXjzPNWiwXZngMkGpcZF+JxRqMV7NzLg6gdZorP9oRWy7hieBHt\n", + "sqPhtoUwfIO2UZefQyhRVdoZJvx1DOLIjcB9wCDjMpkVHX+kwL+O/yFUPT8E5MZ1DP7qZYbtbIKq\n", + "cdqjhay/Br41LpMpjsQxqc0VHOjjEHd1GxLSoOE2aPJZDm23byOuqAFajCMPLf0XhRrSo9CiJu53\n", + "bNug8TSal1aqfiwAo+DbKcYETDXuhj9J80ZYPx/G1SVJ0xL7AXjUOAYl9J8CP1dHby6OdEQLnbRH\n", + "AzcTfJaGfrYFswiQ7bVEo0VdfvLZnt37B66/dx/JCYfgpDRol6VjuwxmTTDm9Kpe25GCMOE/iiCO\n", + "PIPqnUcZlymozbGEUn+qxL/97RA7EHolEnUKdDsA3b6GrpPhUE4OiXkvocR+vj91Q8nMocVStRW0\n", + "WAbNVkHjVYXUL45EiUYeWgVpJ6omykKJRwJa2rJN/Gpizp1MxEf7NdIc4JoYdk8/ntd3nI179pBe\n", + "3v1PERndvgquijUNcSQSndm4JfscPMTerZaJo2pE2XdphiZ7zMGHKFdjyfdmSOLIccBHxmV6+V7r\n", + "kTjzCiXChP8ognVL/ArYYFzm1sPZtzeh3wHxydD6LUhy76+s54o/F07odR9MGMrA5yF5Kqw5B9ae\n", + "A/vum2XMhNMDtuVIMz4Z+D3NRvahyzRotQQKYmFnb9i9bQv9N96AqiwOVDguR+I7/Jcru2RwY2wE\n", + "CVn1iVg+gNWZAykkN7IXJqIjMYX1ORRZAMVbiC1eQWAbRFZNe5z4UX/4Lo1QYeF4oDtalzkDLesZ\n", + "6XNsPHAID6HNoupE+izgGuMyw2vw2usD+4EmxmVKud4eKTOvmkKY8B9lEEcaAfOAF43LvHw4+vT9\n", + "iP6GFsg9UA8eGA5nbYDTN8Hl+cFJU4FdOFfvh9knlj1j9FRjJo+CEkLXD49ufiDQnLSGBWy4tSnb\n", + "BhKXlk2vnPdoQD75/LY7m/1/rO7HXmrMUgTxGdD4T1vpN+cdTtiXgdof2uKxRbRBZxm+zGA7OuvY\n", + "hxLIQ6iUHSr1RzYqZceis5h2tq8lwAK0lGFAgh2E8Ta4+6XPaRswwLhMjXmliSO/A9cZl1nsu6+u\n", + "zrwOB8KE/yiEONIFLSj+B+My39V0f+5p80/t4OPeUDwTXjgI+6Phtf4wvTPMbwtRmezfl8TTaBH1\n", + "RYGIiKplJo+kyXqVzLPb2D0jFkOHRh6GYKD5pVsYOmMCKVkxKJHvDawGFqKEbAGwitTeZ8PJz8Vz\n", + "YfJo7uBj1pf0Fwo/+hJVUqPN0HgTRGdD/WxIdC3nzLVv458oNwaaoEQ9HiXwUUCRXhyCSt0FaO3p\n", + "bFSCzQR2oy6L29GiRbsoR/0hjsSgUvalqC1kNarGmWRcZlOw1xlSFZ4jz6LM5O9VOT/IPt5DXUuD\n", + "Kdp+zCDsx38UwrjMenHkcuBjceQ04zJra7I/d0RxmyxIyoEfmgDboVE+3DdXl9x6cEp31uy7lIbA\n", + "60A7ceR7lAlMR4nUScBArm96Es2aQUEcTP8XLLM5/eKj8xny6XvItKtpeaApLffFE1EcQz3TASXw\n", + "HwO/GJfJLTNIF5NFUkhh4rsfs7/ZtobQMgfqFXv86FNEqDpRs26nvT6FHp9BfkM4lACS2wSV7rOB\n", + "dGAN5atAcr29ZMSRekCr5t9zaYsDXGMSiN/fkHY7O1JU0IQmKDFvgzKLNFSK9nZnbSWO9EPTm/+K\n", + "6usf8he3UBFR957ZFQtEmGq7QL4JTBZHUo3LFFXh/GDgdukMIwQIS/xHAMSRm4G7UE+ffTXVj6+h\n", + "bDbqP/ek1zFjG1M8bQjz9p3Ae/aQZGAscCqqbhCUMM5nSo+urP6mL/E7oc0CaLtAf+M3F1K/aBYe\n", + "SX6hcZkdlRnrZSIzJ8DQv54Nn/eAe36C63+FqwpY2hRifYha0DMBkRGLYdoJZfeMWGzMtP6+Wysj\n", + "OQfIDloyNuuB0whlAF1Rl6fB6D3OQo3WsfaYDMqql7Y1nUPb05dwy3/30SGuoHQfy1OZAnTuNo3P\n", + "T25ByqwO8MAc+JNVnlTHICqOLABSjctMqcr5QbQ/AmV0p9dE+0cqwqqeoxClDKMXz+lIp117SCgc\n", + "GCr9rC/8GcougvQDsL0R5OyLJnJe+8SsA7ndBxER05D6OVEMWHWI7jlr0eyM7wEtgSuAUzG0xRDB\n", + "gVawbRCsORe2f72F3av/YgpXfFOdsXozqQVt4J+nwdx2kLCY3IXzidsRD1ddDJ9MgM57gydqIkMW\n", + "weATNTbMjYeAOYuMmX1SRferPCYzSmTqp/UYOeQ6zTHfc7dud4/NK73xpWidizmoZP+FcZk9JWNU\n", + "Y2cSpe0MbYA2Cemc3SKaxLQE6LpHEwDO6ggP9yB9d1eKgYhWa4l8ZDUt4tfAqiz1wywEFsLSacb0\n", + "rege+b1vKpyMNC5zSVXOD6L9lsBKoGk4dYMHYcJ/lKGMYTSiEK5un0tc5gzz8sELaqpft6GMxjTa\n", + "2onodf1Zd7ANzYD+rEg4wOTzEsj5IB6AuN3Qcewuhs7dRsv8dqhr3yFgHcoIvmBh4slExV1L+/3N\n", + "aZgXQ54solHh+6hqaF1VP2J/RPfilmz5aTAJh7qQeO2vmgTvxQHw/iQYvyE4v26Ry2bCbUNJfBVi\n", + "90JMJhyfBq2ys2mR9S0ayLUJ2HzmkzwwI59Tfm8JjQ9qviUIzGTcs5T3+sKDw+GHd3SMw45nzdIR\n", + "bEBnTd+hxP7rys7uxJGIYeNZcHFr+s/qCLM6aAGToZtgSQZrlo7gXGDd2alMeRBGfktp9nY95C6E\n", + "MVVR94gjDdEAt27GZXZW9vwg+9gBnGRcZmtNtF8XUFnbS1jHf9TB5rbpPQGyk2DrKfDxijj+nHSm\n", + "OPKnUCbHEkfigf7AAFIZuBxSUAPlQlTKWggsZMKp78MHI+n3Fgx+HOL2QNpJzdnWIouWW29A9bBd\n", + "UH31COBqBuydDXufRQl9JvUZbvc/BBSII9Psvu8rE7DmN+VvBi/0+4Rx4xsy8plB8MzJcPJWuPIS\n", + "SPiVVuKIVMxosg/CENg7BPYCUgw7M6DV+cu4atEnaKnRXsAo04zjSYMP+6hK6Qm3+b0xXcWRi1Em\n", + "sRnYY1zGuHPMn7UBvt0Iff4C9YugfhoNgbeBMcZlcoK9B9Zfvy86OxgKDJ47lrgO6+GcNfCv6dDR\n", + "so7RsGHpCDYBLZacyGcP7mbovbHEvBmrKarHrIC3IK6quYaMy2SJI58B1wBPVfb8IOHW8x+VhP9w\n", + "pp8IS/x1FCp5Wl/3fm9BfDqsvgB2z1/NyKWJwOXGZX6odLsaI9Ab9Zxxu0p2Bn7H6tvt7wZfIlky\n", + "pibrNOfOnu5gIoDL/PrfiyPNgDPxMAJBDcDTgRlAc7v9LFSXvdLum4YGcPlLDlYuvD+ezFh46ST4\n", + "v5MpPlSfPCKZA1zs12hcco3+XFBvXA/zx/lmEXWrm35J0tTazz0fzwv0YF5UQn52i4P7OWV5DilZ\n", + "TVBtSlrEQWLqF9KmuD6RceuaELk+iczM+qZBVtqz2bsz7qro2uyzOwEl8megM4RMYAXqvpkRu4Ue\n", + "7Xdx7on1aLQnDvbEwsp4Cg/Ec4hIolF2tqdROu0GZxHXNA/6pcMdC7SP6kS8iiOnAeOBXjWhjhFH\n", + "/g3sMy7zeIUH11GIIxFoCpIkNMo8yb00Xc9lvaJolR6vwsHLVhlanpoyLPEfdcjWxGMLxumSuB56\n", + "fgbHf9QSfW6TxZF7gHcCBSxZY2F7ShP5fqjE5CbyrwK/B0dk7Zgyk3225/jNZ29cZjfqofOxHUs3\n", + "lMhfDryCEqvpwDOoXeAE0mJuoX7k7TQ62ECub5JJwaFJJB94FlgdDDEpNRPIIzZnNnkdlvL62jvo\n", + "BDwKZIgjtwAfkNp7lL/6ACIpwOjbIT5Wr23LC/5SR7uzrL6eTnLuxnhuiRzNtqKPoZBottOCH8bk\n", + "0mDyJDrl9gW6Fsfwc8FvcRlmxuh++3Im6rcXUSA5SZfeKdc0uJouuZvw+P3no66gzdHMlEmoUbcY\n", + "jZQtQF1B96FRyS2AyLz2bNxWwMeylkGNchDyyGncgDcPXMwkYL/b02iUyNSvQlyb4GwYd6gNHchk\n", + "XkqqPFoDvvRLUBtInYO1u7TEQ8hLEXWvbS3xeIbtsL/pwKb2q9j76C5aJWVDa6+yNjWR+C8s8ddR\n", + "lCd5krr8N3Q6fT5KCL5HMyvOQomrm9APsCeWeM+g+Vn2h3pMlc2pb90bB6KM4CygD9lRa/i5b3tW\n", + "v9WM7NbQ6Qfo/lAWPTfkU8/kozOBacB3lqlUbvza51vA5eRF7OTb0yJY8n0rTKQ9ouL6AL6RyEks\n", + "mHc8ewf90GTA6QczF8RQ7wAMek7TSSSkwRbZSq+MG9AsogUlcQInvg5n3Qv1D8DBxlCQY2iUvw71\n", + "92+AxgfEos9XUK+eTaj9ZA2wHo8qaatxmfyyow2MUEa8VuStVJm2yoM40geYaFymR6jaDKLPBMoS\n", + "cX9EvRGwMyKP3Ia7aNQgm8KIXHL3NmJqTjdm4CHyOwI9q6qknwgbd49CeHLblJU8rYTxHqrz3G1/\n", + "41EJ8GdgAkokt4Zy2l3emKrVriON+bL39yQN6Ufn6VAYA68stXtHTSV16l/xqIWGAmvxqIV+qgzh\n", + "E0eG813yFLq2jCJ+B3w5HjadYfd6oofLnFdOMRmikx3yP+9PRAEMfwDWnAebB4O5opQarERdVj8b\n", + "IguU6JsIaDssnxt/qAf8hhp4ZwNzjMvss8+6HZoWugNqZ/D+3xp9B0oMz77//am3QhXxOkpk6pcR\n", + "jLz2Qrj6dzh7nb2TIc6XYxl3FurZE1BdF0Q7AdUtftYj8EjlvlK697bdvVMZWZ3iPFVhxmHCfxTD\n", + "qkmS8ahrBqB5WdahL/BK4G70Qz8LuAjNW78SnQl8ZlxmfZmG6xhKiCJA7B7IcyfPLG1DsIRwIB5G\n", + "0At1fXQzghUVMTupf/F8CiYNpP0cyGnlpb7yb6/Q8VlpvV4uNF8OGX2JL5pBCn/YvYaekZnMSyx7\n", + "lsf/XxxpyFNnfE/O92XTVcQPW8Q9P8xCbSJnVsbQbY28rSnLENz/26PqhTIMwf2/MrNAX8+TevVo\n", + "UzyGFDEwYSLEWmfjmsiQKY78BtxsXGahn33e6pZAqpYkPOoWXyLuj6hnBys4uSX2t/pBl0wYulm3\n", + "V4YBVpYZh3X8RxHEkea4VTVZUecQHdmXgqhidjbYB/lf0/nAfWhka471/Z4PDDQu8zvqCvip/QiG\n", + "oUzgJ3EkHfgMZQTL6qYvdLanoEoJ0QdfG4K1R/xol7/bezAMZQTjgPriSIkR2bhMRpmuCvLU32XL\n", + "aT47/NsrFDaqt+FWOP9G4jNXMXoKfJx9qNk3LGNszFgOHPzY6/j7oe2BTvLn2EkkHWwH9OSsXzYw\n", + "9epM8t5r4jnuxvXk7HSh8XJPAd+KI8ODJcY2WnarXX703W8l3BaUZgg90ACxDkAHcaSIALMF+3+P\n", + "cRnjK5Vm14dOV1I8Ihve/UwjqN2oqr3Az/jj8RDv/cCd4shmyhL1xmhGVl8i/hua4ruEwFdWNRYM\n", + "3JHvX3SHP3qVpqmMjr6qNYori7DEfxgQyDc3RWR0W+HO6Gia7o0jdulp7Nx3Au3QvC8/sy12D/NO\n", + "HsLm95Mgd4crAAAgAElEQVTIcSfILKuHtmXzfgTGGpeZ6du/V5rei4CLUcOgmwksrGwBjppCKGwI\n", + "dnbUBc9s4AyUcLntA3OMyxz021fUtWkULro5UF+eYjKzgWnEs5xT2MZVMav413U5ZEzqza6YRMhq\n", + "r15YA5dB7HGwY+12Tt18OXqv8ytQ4QnwPHAiGhCV7W8soYTtswmBVUkdUAPy5sZbaX75Dpp12A+X\n", + "LIc/XApJ6ZD4DbnvGOLcbY5tROH8FozbvMa8EqDPCNtnIKk8kLolHrV5fExZSX13DaaMqBBuib/v\n", + "LcoE+9lY9JpMER1W9dRR+OZFWdUMburIzjUJbB6+iL4fZRHtPvaP9cmY1ZZHNl/DG8ZlikslDCuK\n", + "hpyW6DtfVg8tjgwH3gdOLU+t41WFyc0EGqP1VScBs2s7/3+obQjWBXIAHkbQFy3oMZ0P2+eyptd5\n", + "kBBL/O4GnLMomZ7ZfwNe9jcj0rF1Gw89W2veUgChC2O5uflknio+gV2X74I1o2HlpbD9RCiuB5Fj\n", + "4IJpy+mbNQMtXLIIWBOI4Vqi+CqaXnlUdfTZoYIN0OowYBIfXhNNyrLmMLMTnL8a/jEDRsLSKEiL\n", + "jSRuV2OKfz2Tgpxe5KHSqz+i3hLNLhqM/rwk7bU4cibgMi4z5HBefzBIERk9CJ6b8CDJW57RoL6a\n", + "ThEdJvx1FG4pYFccJI+DFgdgQBqkfUfOd1nEf9kdLlxFSWkob+mgROc9+HE45T9QHAk7UyBrQxrH\n", + "bXGAZajaJhtAHLkVuBU4OVg1gTjSA2UCF6H+/F+jTGC6b+7zowE23fUZeBhBAp7YgjWoH/pC4FZ/\n", + "tXxLcvl0/wK6fwVfvgHASE7CANOGngsx++DbZ7zO+js0+Gkh937/CZrArj8a5fwLHkawCFjvReAi\n", + "0KCu1sB5lakrXBNwq1v6fcT71zdkQOrp0HuXBoilJ8CcRLLzmpCPR92SiXqYvY/mESqjT6+KusWq\n", + "QdeiJR9rn3j5oHNbGbvlj7x/8RPMPRwposOEv47CHaZvgMxYaGpJ6ahEsnMuJCHCwDcfQrz1ovc2\n", + "iJWuU2sgIV0rTnW6ZRWnbViARtj2RLM3LrXLSaiu8azKEgtxpB1wIToTOAFVjUwCvjEuk1X1u1B3\n", + "IY50whNgNgwlSlGoG+W5vrOnEmZ83WBYeBssHwvAUE7nXhZzXvMzjbl6kfDMFhvc5i4v+aKvgbop\n", + "X7a+hc1driEqOpHYrHgGrSykR/Z8PIzgF+AJ1FXwokCE0l+xm2BmSXb25/ZuCaRqca9HAukReRii\n", + "6HxaGjJyPSRlwwcHSV/WmCcyzmYiXuoWceQ74DXjMhMqGktlII5sR4WbzaFsNxQQR/oD443L9Dss\n", + "/YWNu3UT7jB9QYm+Ad48Ab4bTvyTP8Kd8zXc343SBrGtz8NNXVQPLZDdGrIfWc/62LvNdOPWCUei\n", + "Ou0U1NMnC9XnZ4sjq/EwhGX2d3MgFYPNgfIC8IKVrM4H/gC8Jo7MQZnAl+5cLKHM6V5bsMVDXgde\n", + "t/eyP8oErgfWiiOL0Xz304AlcPZB2iyARlthpScf2TLyM18iZ6HZldaXvJzWtD0XtiagnqdDgH+U\n", + "nj2l9h4IJ/8RXk8ume9tvmEjJ06Zw7npBvgj8CKevP5LxJGH0HiM7SUzA3+2iojru0j3Dk25cssq\n", + "yifqvuoWt1S+xfbjvS0LOKE4lq8bLuPpBp/Q+zeInQN5O+CFHf6f+5vADahrcSjhTt1Q5wg/ahPZ\n", + "VMtjqBDVlvhF5GzgWVQieMMY80+f/c3Q6V4r9CV+yhjzjs8xR63E763j3xEPN50HcxI51HA6b4xY\n", + "y4iKfHarovMWR5qgH+6HaKBPHzyMoRGwnNLMYKlxmV3ltNcQGI2qg0YCvzVYx6pzvmHkx3vp6D6u\n", + "JoJ2ahPiyCUo8foFVbk0IbPeCg4lDGTluBhmueyRNrAOgAFvMKRzEg12wpTngYeBFemw9sZSBnn3\n", + "bO6qkRqzsOZcXXJuKGW/EUdaAyejkn9D9BsqxD0reOqM88n5/gROegn6v6ZG5Zh9kC/5xBUsp3z9\n", + "eUaws0JxZDDqMfYn4zKfBXlOLOppdGIopXNx5B/AAeMyj4WqzVBBHLkXSDIuU2EKjpD0VxuqHhGJ\n", + "RCsADUf1eD8DVxhjVnodkwpEG2MetExgNdDSGE9q4aOZ8IMSf07g/9YOJ6XlSrbEzeCuVbnmy5os\n", + "GWd197OBS43LzPba3gTN1ePNDPqgKQJ8ZwfLfdNBuCtAtVjFK0XtadNxH9zwC9yySPcfbUWuxZGu\n", + "wBfovfw3cCnFPEZBJORGF7C18S7y897mpL3/IfXsT2DKSJqugWtPh6e3WXVP2Vz+JSqj2EytO9zt\n", + "K0j+FrKK8tjUOI0VnfezOXo3bNM0Elri8AtgD1oV8wSgP68N/xPp0xNJXK/VwrKTILcZyGVzTdGn\n", + "vr6qVb0HZwP/Ba40LjOjkue+gLqCpoZiLLbNK9GcS5eGqs1QQRx5CVhlXOaFw9JfLRH+kwGXMeZs\n", + "u/4AgDHmH17H/Anoa4y5VUQ6A1ONMd1CMfgjAdaY+AKqfrnGuMxPh7HvEcC7wCnl1UO1ut42eJiA\n", + "myF0RyVDX4awdkwq0z+MYOjsDrA7Di5brm3VRNBObcPOeN5FfeFXolGyD6PeUW4jcX9eO7OQ9Eca\n", + "wzSNyi2qZ3e/WCYorLT9xiKiADqcfpBuA2Kk60Si6u+m2VopTNx4aHPB1uJ7197JVNT4vgW4oZTn\n", + "ly86Dyjkmp+3Utp4vLiy6TrEkTGoyulC4zLzKnOuPf94lGF1DpWrpTjSGw1K7FbhwYcZ4shk4BXj\n", + "Ml8dlv5qScffhtIpUrehEZXeGA98LyLbUQ+Ky6rZ5xEDcWQY6pnxDXB8ZVLuhgLGZaaJI08AX4kj\n", + "p/gaaN06+jGldfT/8hp/FKqKcjODsagfY9tvxlFw7TZI2Ql9MmBLI2i3P3RBO3UJvVM5ra0Qu+Yc\n", + "2m48kVMSF+NkfmWK8BDUJ8SReDJzf4VvG8PjqpUH4GGI2N6kbKve9huL4ptz2fhkXHyDVxk9L4PH\n", + "6hXydTeivjqRLnPO45OoLBYVNuR94CrgZU0217tsO9y4nk05d6Bqvv52eRQ4XhxJozQz+DXQeymO\n", + "XI8+7xHGZZb4O6YiGJf5TRzZhWoFvq1KG36wGmgrjjQIlKCwFtEJqLGi86FCdSX+S4CzjTE32fWr\n", + "gIHGmNu9jvkb0MwY81cR6YK6zR1njCcw5WiT+K1u80m0ktKNxmWm1uJYBM2E2Ra4wC11VbZ6lE+b\n", + "cS2mc2PyIR4elEiLpS1haQvYU5/i4kJWFzVgNqXtB0GnH6hr8L5PT56mBed/akVR/c28kPU/c6f3\n", + "sSWunkmLIfIQbDtZd7Q4uZC/zN+Apy7xTOMyWWXtN4VtYFqffvXO5M6e3/NBX/jfJ+oPvjcGBvUn\n", + "bc1wfkXTMUej9/d2Hu3ZguKOt1VkB7KMvAceZtAfZeqbKM0MlgA3A3ei3mFrqnMPbTbUM4zLhEzo\n", + "s0b3W43LzA9Vm9WF/dYOAC0Ol5BXW6qeQUCql6rnQaDY28ArIpOBx40xc+36d8D9xphF3oMHHK+m\n", + "ZxpTNgL1SIA4ciKaPG0p8Bfvknm1BZvc6lt0qn8veOILDFAY4Qm1r05ekVXteHfjDeygtO0gBfUc\n", + "KWVMBlbWhcCkiuC+T/mR0Omv8O17eq/6Xc2Bg414B7jTHfRWordPngLn3ayEf8Y/YO/9s0j95E48\n", + "bqMD0YLp7txCi4BiPjxhHj36DYzq+S4jtxZy7W8aIFXfzh5GNid92q0Uocbd5SgDKEarnn0DfIWm\n", + "qAhaCrbvRm9KM4O+qAPaZ2jG10Vo6u4Sd9LKeHSJI41R5pJclayqAdp8G63ZELKCRNWFONIKFXSa\n", + "11gfIqcDp3ttctUG4Y9Cp11nAtvRwBdf4+7TwH5jjCMiLYHFqM4/0+uYI17it9LUQ8BtwB3GZT46\n", + "DH3GoJ4eDVFvnfL+N+OQnMeCToWs6ohEZcU26L8q4mCvHMYu1/KEEHodvVdNAG/bQQoa3LOVsgxh\n", + "vamhmsJVgTsOIy0BXu0Pj9nSNxfEMufL+9mPqi/HGJfZWUrfXi8XTn4aBj0La2I2cnzaCe5SiuJI\n", + "HFp4ZgTqLdUBKKJQCljUy/Sd06zJkpxZZcYyGqZOSWU0mpTubDQ3/WD02/sVtUG4E9Z9BXzdO5U+\n", + "lSDQAjyNfs/3ogF9bmbQFS34sihhFfln/MiFn6TT3i0wVDRbFEf+i6qVnvG3v7IQR/4KdDUuc2so\n", + "2gsFxJFBwPPGZQZ4b69Jt+da0fEbYwpF5DZUmowE3jTGrLQGXYwxr6FuaG+LyBI058Z93kT/aIA4\n", + "0h31etgH9DMuk1bB8fWomFAH+u+9DTRpVZZd/P3fC2xiWstObBqUxR9+as5aB7P5NJptHsszkyZz\n", + "odesNNQ6eutv7k729bXPPeiGhxlcbf8niSOrKM0QlgFptRGp6Y7DaJPtIfoABXnkoHEODrBIHLm4\n", + "lL69IA5m/w1+WZrHiNmNyIvKkKsT3iI5ZxwqTTchO+p06psubGyxh/1ROXTdsYX+K/ot7RmVn7w2\n", + "MvLf64qihm2ERvluV9+k+aQeN8UrUOtfpC6/FpXKW9glBw3gG0sR/0z7C9EXraT+uWvgpO3wJ+O/\n", + "lJ+NYXgdZRxDjcvs9dkfh/rO948RHlh3Aa0bN4aBafDduzAekiso2/gm8JI48myInuMSVJVal9AJ\n", + "Hx9+b1WhQSM2aqqcYmVwVEXuVjWCMej2VapPoDQRvhINcvoazQJYHqF2/6+HhzD7I9YVEfMstJpS\n", + "8Dno3dJo8lQ45xZ4cRUURTOSk5iKat1qOq+IL/xJQstTmY2qHnzVRfWwKSrw8jIylSxIXpUxVpQj\n", + "XYk+rwF3k9p7t+rtY9pAcRe4Kw6GQIvf4aJhB2mxp4hIismOXMt3p7Zm2dRWFLqTN960DvnpDlwr\n", + "tjXYwO1R9bkwpyWJsZlk5++O+a1g0bBkNn/RluIoz/HMu4PU5b+gxP8N1IPmbGCUFHBWSiaRjfMg\n", + "rSHk1Idz1sLPW/l12fkMceuhbSbX99GkaRdWpJ92z4Ky68O6Jp5kZOXNFu1sYg1wdSj08uJIU9SI\n", + "2rjOJBnUALtGxmXud287q75Mu70zZ03sBZsaw49v6/ZQuT0f8ykbyi2Skbp8KkqwKytR+/6PQfN4\n", + "7wdy0aA0AeaiHk3lEWvvbXmHW3otles+bhfkqhoygbMyz2bG0sORVwQ8xL4IWreFLm/hyehYnrpA\n", + "HGlBWWbQG51l+aqLVoUyt00w8RbWxfBzdkQvZ/zQWIriT4KeiUQOgUG/wfHvQEQh7N63je67DpCe\n", + "0IKvpyfSdgEsuB082Zp8A7higNP4tc3rtGreicSN8NM9OpvwOl4caYPGGjxnXOZ5gIvry+w/tWfw\n", + "lK6aHPDlb+DrbuD0YW9mW+qh7+1U4AJ7H6/oncqwitQSVakUZa/lAaCLcakzSHUhjmwDhhiX2RCK\n", + "9qoLceR1VOX2NqrGGxOVz+WnpBN12XK4eCUkWZYaKpVqOGUD7cbB+GRO+wd0/wJi9kN0VjIx6V+i\n", + "X9UBKpamN1ew3200uwKNVn4aeLIu6aQDwyvXfa7H9pRNvYUTqiF5BDvLEkek49tc3qct/7w+nnav\n", + "NIRmjeDKhp487uWpC2yaiO/t4m4zAtWPu5nBaOB+oIs4somy6qINVfElDyZHunGZ5dK6y8OMyHub\n", + "qwrimPiaBlIVPQR5m7XK19ZTgLHrSZ04nOUdl3P5hYnUy4W9nbRiF6CeOaXaPQjMELlsC0zoRIMM\n", + "jcwtgR5vXCbNug/PEkfyjcu8lldA7sj1MNIr29C4BTB1AQumpDIWzcv0L1SoWRuTxrsdOnLKl5tp\n", + "G2nFEn9qCXetYd9Z0BaNVykP7wIrxJE7Q+T1sgQ1RNc64bcBdgPQ9ClPAL8DE055hbaz9pUyxgK1\n", + "7/Z8FBF+WyRj9XmweQgcbAT5DaHgtnnc/+XQUEwH7fTyZZTIjDIus7i6bR4++PEb58b1sKXKEYae\n", + "WdbrycTs1wIlTe/sI1cmTKJ7zn7UqNvOLm22Xklk7H7q/fsg5O6EJvvguB1Q7CWvVKZohX2mG+3y\n", + "Zcm4VHXRHQ9DuN7+NhdHVuCjLkIzRZY7AwvKQJfe7Xr++3Ucw/4Gl10K78wEnoBf/o464ADk5BmX\n", + "KZTUURtZOLcbfxgNYy6DeXfDnPvhUKBCMJZxH2ipSwk8xxuX2WzTFs+UsQ27N6JPsytZl/chebEA\n", + "3xDPjfTK3UXLNvwn+zP+Mrs9scWfAncAA5rt4L0to2ibFA+XL4Pnp/hnxqUK2lci6ty4TLo4MhuN\n", + "5XmrvGODhDtnz+chaKvSsMR+BHo956Iutk8BVxmXSQdISZWNN0HbKjDJGsVRRPjth7Grt8/2gpwQ\n", + "Ef1RaDDaRODaIy1lsTHLJoukAKNDWC/XzrLuagvRWbC/HWS1a01h3GWQMwc15uejka5RxVG0z47W\n", + "ZHUnzIQH/Mh8oZCEjMscEklpB+2u8ZqJ/IXU5XMona7iPPsfccRXXbTcHfDmT89/JdGDG8vA9ftp\n", + "st0zy0mIwUTCd0/q/SiBu5i7N6Pd+jyH7urC168mc/VZ0GgLjGtRRFq9teJIVNlZZHCM27jMejmh\n", + "zaOcufeV/X3uj/xqaWNO4gXyWZ6/hsHk82EcCWl9uOYs+K3XXqYVf2OKlxcCP10msnUCdN7UGFY2\n", + "87TpjxlXo1LUm+isLFSEf2wI2gkaXsR+DPr+/I7ShAfQgLknvNWMVWWSNY2jiPCHXqIF3HnI/42q\n", + "Ea42LvNDBadUGzXl/mWJfHWKmkSiWR07Ap1IPLs7e1FD8aF4z4FJw2Po8V0e6uHgXjYOf5KXpxUy\n", + "AlQZ/TDwuFf7oZKEAth7upCKu3JZSeoBa3RsiWd2MAi4CehlI06XtT2PnmdsovPvO6HHbvWr/5D8\n", + "uJNI7LOIKX3gpi7KVNt51Gn5DT1dsygTRi/0ZrQljHhX2u0UZQ1h6crf2dnoI87KuBj4VRy5x7hM\n", + "SaRrpRj3r30vYdtTkVwznJyi51m0Yirwt2j4P0hcD9ecBYv+DHPvS9T29J1wezB13KeLGyFWS0xG\n", + "s732NC6P23cV8TulX6EagQ+xPxcVECYADxiX2W6PaQdk+rMtHa5yipXBUUP4a0KiFUdOQd005wJ9\n", + "K5vnpCoIEFF7WNy/rM7cTdi9l072tx2aJGwTsImoHJ1JeRN9gPT6PxmXucq3/ZRUee4m6Dwekt3l\n", + "ky6E3AhYfxDSQicJtRtH9H+SaT4fEjfA0itRJjDiUZFRPvYIMxnNXLkDDahy34tIe919Yg/x9Oc9\n", + "4LEhcPXv8JCtatsgbjPkFYEZn6zv3ZYAwscmv6Uj3YxYHHFx1aLGxmWet0nNzkdTY28A7jEus8z7\n", + "+IqvPyGGXb3h/alw4nhYMYaST73dTzD3PiX8gLdNoRq6+6BhXKZQHHkHTdd8TzWbW4u6/yaYEJeo\n", + "DEDsJ+JF7H3QkSMgHbMbRw3hh+pLtG5YHXEqqhv+i3GZSdVtM1i0g3HjIfnfp8DSltAyB3rkkDy3\n", + "mCfEkXwgAyVSmZVVYVnC3hI3Qd8cN5IDCWeSUNCAhrnRJFCPCDJRnfkmPKH8n9htW7wlGklNGQ03\n", + "+amR63+WVRPTXpseoyceL58U7ok+nfpJsKsX7OwDyy63WTKb9IL/eaktVFL3S5TVCLwOWDdK5E8T\n", + "8KSfduNAYjpc2xdmpsLKBrGmuMrCxwRgujhyt32mX4gjU4A/A9+LI58DjxiX2RHcXbFqz4zjYPKL\n", + "dpvVHP1+tc+xHhvBYVRLvAXMEUceMi5zqKqNWCayAp2pVTv5oSX2Z+HR2VdE7L1xROToceOoIvyh\n", + "gDiSgvo0b0ETqwX5sYUGCeoySr1V8fzyew9yIxpQVO8AWb1Wd4Dsh1EX0lZAvDiyEw8jcC/uNAj1\n", + "0MLUTdBkeh1RY2sWsIm99fLZ0TGFXbcnsq8j7OtIzP5H8roWTNtWzP7HgvnYqzLLquq01zLjriiB\n", + "dy+90VnIWjw+/q/x3onx7PxxiBJ7b3SNJX4HHGhhGYFbUi9/PP4k4cvowqq0Z2FaFJzxCAxfdoI4\n", + "cjGpfG5clZtlGpdZKY5konn359pth4DnxZH3UK3YMnHkWeDpilNd+FN7Lk9XOeatJM+2skz6cKgl\n", + "jMusFUdWojryT6vZnNvAWyXC70Xs3Tr7yhB7b3QkTPiPPNip/Z2o4el+4O3aihT9hnhezBzNej4u\n", + "2R7945X1mbPkKVwrFqEvWTKe1Acd0fzsTdG8kHn2NxL1kxc85Rm3AztYmzScXbclcrARHGoAhdEc\n", + "5J3Y1gw9sR2LngtWtRSqWZYb9jl0xhPE5V66oO62y9GP80P7u874FIiX1JRC+FPr0oTv+jy4NpYz\n", + "H4LYTJj0vlVRxVfoReQtCUcR2SaD5l1W8FxcDufYOcHE9Zyz7n2a5D0M/F0cSUUrlVXm/ZmAGirn\n", + "em+0EbT3iCMvA/8AVosjDwPvB6ykFoAh695QGveDgz+bFakl1bmqS/h/R106g4YfYr8cvf8PVpLY\n", + "e6MTPs+uLuOoCeCqVv9ad/UdlED+sbzc9TWNFJHRexgwcQcL4qh3AM66DxpvgsSNkLi6iKjiffgY\n", + "Tb3+b/bnHy2ONEBVPO7ZQicWdr6LiOGt6TwDog5CcT2I30FkUSGdc4rYUcDe7FZ8R+nZhPfsYmd1\n", + "punWqNqO0tJ7Cpo9ciceCd5N6CsVlFU282VOc5h9IpGHNHK59WL46EvY/+dSAVNVa1sJqL0mdxqH\n", + "QsAFTA6GAYgj3YCZQLvyYg3EkVOB/6AzuruNq24nMwyUBfbHOO5bfR9vAscZLflZJYgjQ9FYmlMq\n", + "OK4+HjWOm9hPBD6tKMVKkOOYCTxmXOa76rZVqX6P9cjdKvWrH+p1wD/t8kyoikVUB1Fy/u9FfNkH\n", + "KYKTXsatiiHr73NM3ueD/Z1j00m0pPyC2e7/ebw1IIqcDxpw40B4aYX1DTcMizmBlxv8xg1N+W3u\n", + "lfzDHu/NNNz/W6BqI39MwXc9Eo8e3r30QvPKuAm7e1lREyltS3v6GDj5GTj14SJ+TrjPzNz5dEj7\n", + "UlvKhSgDyEUZwLcVMQBx5Fc0wd/sCo4TdHbwJLCEz1t/w299L6mpVCXVwSiRqZ9HMvK/x8E1SyDa\n", + "fl024dxGIN1Uo4SiOJKIqmUb+c6AaprY+/S1CTjTuMz6io4Nab/hyN3KQRxpiSal6gAMMy6ztJaH\n", + "VIIiCrYDfTCRsPB2z46G++PFkXH4J+xNUH953/qqy4AZXus7jMvkSWrKaK4c9jHz7op3BwR1YSx3\n", + "HVxH94PQcA87jMt4dE0+sMStKb4zCTgeVcsk2TG5VU0FaPTzTlRl8w46S/FlFDVSWKOM+mNeTh5N\n", + "Yhdwxq4HxZEM4zIfhKwvJUCTrFH2UjTCe5844kLTJgdiABNQIlUu4bfn/08c+ZyNcS8xcverJHWN\n", + "YNYjGi1cjtH6cEIciep7Mh27D9SCPeevhpb26drYgDeBT8SRx6saa2NcZq+1j3QG1nkR+zHo7MtN\n", + "7B8KNbF3wyYcTEIZ0BGBY1LiF0cuRIuTvA04lUl2FqL+BSWK/iTyJJY06sX3o3qw/6N6JSc1vOIg\n", + "p09dzAn7fqNs4ewdwK7KpI4QR06lQD6L/Pdp25oeiurRj+zY21nFOeRUmKzNxjb0oqyhNYGyEvxy\n", + "1AW0OYFnD97rcSgT8J4xBJpN5FTXDiOO9EGjfj9APWdCnvDL2i0uQyX/XbafMvEg4kgymlK5TbAz\n", + "T5FRU4l7dySXXwTNVsOcBzT3T9FFlVZhhQpWKLgYeCwhnZZTJpN4qo8yxyvF9K+oy2qlavn69OdO\n", + "kNgWJfYrUCYacsk+QP+d0OI6HWq6rzJ9h1U9QfSj9W+fA05DdfmljDHVze5pOb+bmAVStSTZY3Ip\n", + "K517CPl7HbqyqccYihKi4EBIDXGW8cwDXjIu816gJGQ2QVgPSuvgU+z4V1JaB78M2BoCQhyD5x76\n", + "Ywze61CxmikDyCgv0tomgJtkj72mMoVMKgPLAK5AGcA2wOWr1hGtLHVPsIGCIpfNJPK9oYy8C3pN\n", + "hP0dIG4PzElcwXm/pITSQaGi78O+VyPQXDUAD/VyiDzFBM5uKo7cBpxqXOaKSo1FJfvhKEMdizLU\n", + "/6DEflv1rrRysDmSXMZlhh7OfiFM+Cvuw5HTUfXCVPTDKqVHriC75yzKJ+Tu9UQ86hZvadx3fUdt\n", + "pnwQRy5HC22cZFym2DIst5eQtwTfAQ1D95Xgq5TsLNSwM4/yZg/e//Mon0nsAe5G78P51SEeQRDI\n", + "KLRu7iNogjGXWwgRR+4HOhqXuSW4vryKv7SfA+ffCAeaQ8PFOSTmLUUNwJUuku7/mvx/H9awfSpK\n", + "8FsAf0cJsIHys5taHf1GNGtnudXqvIj9GDSj6ApUjXMQzZ11YXWvsyoQrU08xLjMtYe97zDhD9C2\n", + "SpBPoFLBTcYVQH3h/oCaroYzXBCfDgnp0HB9EfWKCyifkLv/7zpcBLEqaR3sFLw76j3yJdAAJfJd\n", + "0WpYvmqatdXx3KkrsJJoY8qfPXgbrcGT/K08ldOeMgbFCgikz7jqAdeghHI1OhPIABYArYNR3ZXp\n", + "L+ogDDtpLwOWRRDFJFQCn4v6pVfZW02/jwdHkvgy5LaE/ARtusN9c7luwT40iCoVeK+y2WrFkQ+A\n", + "Be500j77fIn9SjxqnG32mG6o8bxTVa+vOhBHHgOKjMukHva+w8bdshBHTkDr365A3cbKqfdps3se\n", + "TITV50N2EuQkQe7987nvy8G14dMfCBWldbCErg1lJfieqJE1H8gEfkSzCa6qOCjoyIV9dnvtUm5+\n", + "GKuOuQp4BvgYJchub6l+lGYSjWw+Hw9jOK/tEHamdCbnY03DnNWOQIFiNv7gTRukdR1K0JaiBvDT\n", + "UaN8+dfma7QuzMljmnmBU9iGFmZZhwoli8SRN9EkYlUoXlPUGr6Fvf/T1aZr4IzzodOGgcBdwCXV\n", + "sAFtBL0AACAASURBVJW9CTwrjrxgXMb4EPvzgVXovfl7gJnYejTzaqPDkVbFDzrhle7jSMBRSfjt\n", + "VPoBYBwalPVhxYTbnfa2hc3t4kZBdl0i+uBJ6wCwswEsbw59W5D8VUdeFUe2okQ+D48EPwd4FSVO\n", + "i9DSeqv9tV3TVczqOuyM7V1x5Dd0VuR2ACjzDlgC1QLv2UN+3FCarIf2cyGvqSX8UF6gmJ1VveaV\n", + "w+YJ4A1x5CLjMr9WOOYAQXTiyMloyuWH0HTirdEAsMeA13wD38pHZBI8rrWEz74Den4G8+6CeV8V\n", + "ctP8L6rpIDETjTK/XRzph4fYTyQwsS+BcZkicWQ5OuuYU41xVBUdOYKiduEoJPziSFc0sdoB4MTg\n", + "g0NqJrtnTcCd1mFZCxhynbrKpeyEZjs4mNGLh9CUwmVmNzYB2EflE/2yWS3rgmvg4YZxmSXiyEDg\n", + "M6CnOHKd76zIEuxtdgFAZNQYeN6PyiFQnv1S7eUDL4sjM4BfgG/EkflAqnGZ36twDUXA0+LI542W\n", + "8EmPRXSpH8W2388kNbs594sjtwJfBSfYxKYDzSiI1fxHM/4JeU0gcVYWmk30TTSQam8FDZXAMs4z\n", + "Ucm+Fcqg/oF6PVU2qMuduqE2CH+ZWrt1HUeNjt+qN24BHkUDZ16qdBKzABGZ1RlXTcBd+s795EqK\n", + "9pVT+k60IPxcoEcglVcpQ2HHmZDRR6VWn3KAxxKsjegN1DZyQUUh/f6Z543rYb7fDJ3l9DsPTTnc\n", + "FU0h8iM681hW2WvwVQ0a4KwepP9wEYXF0axDDcDlzixKvRulMHoqqVNuQPX77opeLwaKsvYh9heg\n", + "qrQJKMGehkYuB+VV5W3n+nUoLbaksDn/xerXsa0MbPqHLCAuVPa9ytjvjmnjrmi90TdR3/hrjMus\n", + "Ctng6iCCKQDuC3HkC2CucZl/BWq3pC5vZD5cPRKSftGAoD25u0jOeApYDCyumo74yIUVKh5Cs2Ve\n", + "aCqovBYKASL+Gnm9QQGjh/6PdZnRFMy7nC25nTgX+AFlAEHnsncLCjsbwO446LQXYgvhjAQWzryb\n", + "t1GiPRV4OJDfezAMTRzpya+N3mJJ9+PZ03wT2UVbYOtzpC6fQVliPxH4xFuyF0e+ASYYl3m3omvy\n", + "/QZ+bA8XjeJgq9e45HAWObGG5SnGZbqEor1AKS4C1qI+Vo271jXxOeAl1HBVpfq3R5Juu7Lpc60r\n", + "a18qrFZk7RxF0Vo2UIqhyVpIvmg7yRlJKIE4Xhxx2woWoczgF2OrVR2NsKqQx8WRVcBUceQW4zKf\n", + "BDy+monrUkRGn9uYs6bfTJv3I2lTPx9uepd1M5twy7pxdEPr6k4DHjUus6ai9tyqwQVt4N4RsKkx\n", + "NMmDA7mchLogf4DOLFZYlY3L+OS3DyoTa2rvTnByMxgfQ0RBD5K/68Fxtw6miEIiS7JeuspR47yB\n", + "2uQqJPxuO9fcdvDO8fDUNDjYlJi2Ef5rNtcgQpqOuVU0d17aluQHO8KjP1Rci7qqOGIJvzjSBCX2\n", + "xwPnGJdZVOW2vGvHlihODp9uuyqumcGmz7UunP9BMw9WkOTMx85hImDPv9ezJ+IhM7/E7zoSVXv0\n", + "t8slwHHWqLzIa/mtJnLu1CaMy3wqjmwEPhdHegCP14Thvx2M+98+Op66G77rBKPW2Y8/k5vWuswo\n", + "m6nzdmCuODIZTQ62LlB77spa563RpVhgewKc35rFv15ODlpxbDGwBlWX/lUcyUDtDBtKllQ2wPIx\n", + "gZ+rLcU56nbo8yHs6Q7Lb/t/9s47PKpqa+O/FTok9CZNkCAtgDQBUapSglgBu3IVxIq9ez2cz94V\n", + "O+gVsSEq9gCCUkRAAZEOUqSGIoSSAIGU9f2x9ySTkDItDed9nnkgZ07ZZ+bM2muv8r4VWPXhfi5f\n", + "enteKyWRmFhK9buJu2d1k1rnJLC31nY4Gp+bA+aZzM7YBT+cDrcsglqHIa021X35jEOIxnjF9/39\n", + "LduS3jMxK6K+pe6le8oO6Ps3JJeGMraY2h8tal9QIgz/Cd74wN/n0YWbMAIhHYJvhrIP7BUXQONZ\n", + "RjbvWOVo2PaJuLIIE8Pz6+VrxYT30k4x006IFbeuwpRw5sq744EvXp2NY662r4mQUUXVCuiImQyu\n", + "ANpYI+k9GSzLq2y0oCQnQwl19A+b9P0Gk/QdEepmPI9Ru2oFrKptDD9k/vjt6upJceV14E5gobjy\n", + "LfCEOrop+/my6wlEKIw5xMbjh3DU0TgxDJfjMbQH52Oovl/GfKdbMMatD4YPp4m4koj3hOB5lb64\n", + "CqnAxn5G5ctT0VR55j+w9DtxZQ7/azyDrS2Gea+szU7dXiXtmmj+PERk/TrVWuxNrFaJY22Osu+c\n", + "elL9uXhNcL3vyTOZVUqBR+bCo32g7W7Y2ICywX7+fiLD4/f8lsdBdIb7mO23bB2xNlhDj2ER2Aj8\n", + "BDzV6wXunXmMc7NfJMTyl8U/xp8ltuihKW4xIZWVFR7T6XufDs31bWxb0qHMYSOUXe4QVL7pD66d\n", + "+yBQOYBXKj5MENGzuOax/bT8qQmUT4WRf0DlY3BjGj/PvovzgeRAvUpxpSKmLO6K7PQU3igIg2uT\n", + "eK3JnAw6YQzJBrJOBsvV0WR/Y5tFDTHKX+9jjOJFGkLBHk9MPvv23JL3tvv1LuBWDL/9k+roFu99\n", + "8uqe9bqfxzDlpPdjwi0XY1hrN2C63VfZfEddzCSQ9TWhc2c2/17uhBuq3Hspd8++ld+qjWZBv2Ec\n", + "mOSlkDNyA6w7CHM6UuFmIkufQWzErXx2MLMu40rKHVnOsaHe4/V+Xo6Xgua3gWwncVc1fjgy3j/6\n", + "h2AgrkzCaC984vneXu4K+yrCEz+bRPo5dZjz6818gjH0vYEDGEP/EzDLu2PZ3/zdSZvczdJRe+Vg\n", + "2N4Vpo6F5CtDVmmSV8VCINewP47y+DBBNFzBtT3TqbczEuY0hub74Fgp2FKRlJQKpGFWZX6vOOzr\n", + "CswDdAVwOKcqp8I0uLYCog1mEvBMCM2BdbXXUPP/NtCgU7wpTfWm782tUqmoYb/nxzDSVheqo3+G\n", + "4ryBJO/teGpgmqluwlTKPOVvWaSto38X0+A3ClOqegsmuT0FE6PfneOxEhMLXcfCu5mJzopXH6Df\n", + "92s542AkKREtSalWiv2nwYznYHMvu9P5CfBdderF0ik+nUX8iALbqkAj246V03PgPZkt70b1v3pR\n", + "RcuxTB29wJ97Dgbiym/AXero/GEisydDz5GD4WgZKJcKP50GO8tw/HglJmONfX7fSX6TdJbrn7yG\n", + "33rj5Q6ZMMy6C+07w+aoTu4VmuuHpgQvEHh7d690ha9awKwP4Hw1D7r1nKPIewKpksO2GpiE7l4M\n", + "NUMFDP99lsmh+ibaXXSAOpWPQex6OM8GCgrL4FpPs23rn/nwzGo0W1wP7lgIN9jiwmEwZ7Jqr4Ie\n", + "RzAQV4Zh8k0j1dGvQ3FOf378OYynFkbIfCQmcft0fmWo2Y4vjZlA7sc0k72KecYexVBMvITRrjgh\n", + "/JBXRZPI0NlUeqMn1TbB/iZ46MCJHHSEI99UpMrV9Ny/i9nMYWsV6DAK4l+Esmn5Pwc297QWqKyO\n", + "1vH1XoOFuLKn8QQebrKXW8qWpdWxSpRbehacHgXXLoe+m+DuvUybWkC/pZPY8IfWG899DEVTw+/t\n", + "3aUJnHM9pK3mn8MLGB6kCPnbwBF19G77dylymEA6fMeLNyutDpWDTvHQwwYICtvg+hveKGqckHc6\n", + "+4+pnLvnPuA14Lni0O1tWUfvx6xIJgLP+BOSsjTR4zGOwwh1dLnd9gwmIfkwpivep36ZXH/LDbom\n", + "cvGackwbWbbTpo9ZlGaG2OM/cM98uHCdb8+BuDIEk8uq6U8jGfhZO296O7oBAyLXce+gacik/RlV\n", + "IVwbBT3KwIgE31ZqweAkNvxF540XFry9u01VqRlRleYNtrP4aCoHA4m3iyutMfXeLdTRhLz2LS4G\n", + "N9DwRlEgVyK2Zj/+H1dtvRNDk3FjkDQGIYO4cgqmCexaTF7iWXV0j4/HCpk0Eu9g8gfJ4srZmGqx\n", + "CEwDWJ7iMZDHb1nmjyZ2V2eik++NXELFQb8qkzQ5YlxHmHEaVPnct+fAjjURM8E94cv9QdZnL11M\n", + "8ts73Gmdpg5kJmS7YhKy206bS/9RxygTHwV3L/AKTZViP2n85s9KLRAUmeEXkQHAKxh5vXdV9dkc\n", + "9umFqRIoA+zVbJ5kfoMvKR21wSJU8XZb4vejOvpKINcsKoMbTHijMJHhuXZ+w4ifzB5j6AtMF+sQ\n", + "TGL0FOBiXw1sYcA2Oj6IqfQaDzyfN3FhlmPrAa9jiP5GqqPzbIWKRwJyKXC/Oro+z/PkFQoyBvbL\n", + "yHX0azOHQ1UPs/3HW2l36ntcuXGXfp73Oe3qq/62Vpy9qjQtE2v52knrcX5e6QLL65gCi9/rw+PN\n", + "2bXvNBIx9OQpwHFsxRWwAzhaeyPNr91F2XqJcOWKTIWxoTDn80JYMReJ4ReRUpguvHMxH8Qi4ArV\n", + "zK5CEamKoQror6rbRaSmataHrajF1osLPA9gUll4ozPc/6sp7/TH+xZXzsOoi7XylVK5pBjc4oKM\n", + "vFPFvdD7MWj1Bcx5DBbPnqtpX/S0BtEFrgEGazGS9QQQVxpiwjTDMF78i/lx4XsdeykwFvga0xty\n", + "yOZp7sDkFT7GNJb5dL4czt8KQ93wOnAPq6NSmHnGIRLq7spR2yCnVUTVy9OImf2q/rLrHntOAWpi\n", + "SOrqZ/83ai89y1UgMqGC+b1FKJROAznMkSPV+B5jv9ZgbFw8cNCyiN7W/S3un7ebhmRDoeXIisjw\n", + "dwMcVR1g/34QQFWf8drnFqCuqj6Wx3nChh/wVAU81Be2V4YPv7LbfYy3W49pKaal/8sCHey/GCfE\n", + "qmuvgAF3QbX5SVQ7OkQdnQ4grlyJWQ1fr45+X0TDzRXiyqnAI5gmvDeBl3yJjdvy0Rcw2rY3q6M/\n", + "2O21Md3dQzGrgDcCCXeJKyuAm3gtugHHznyPpI8rZb6bVdsg47uoswxqr4TKOyAqHupOTKPx/t8x\n", + "xv0UTGFDPJnGex8mz9WwbBK9IyMo33qPYbv9/lNomgCD8jHe4sqLNedS7aKfOcd7xXxFFEdWJDK0\n", + "MJynQG1nRP675In6GAEPD7bbbd5oBlQXkVkislhErgnymictEiF5fXUY3xGe82L39qN54zqMoPmU\n", + "AhheGBnYNtYYIIs9bWDiqRvZVP4l4HVx5Xtxpbk6+gkwGEO5fK/1PIsN1NEt6uiNmLLaesB6ccUR\n", + "I1Ga13H71dEbMBoCY8WVT8SVWuroHnX0FqAHpuFrtbgyJID7NqLz+6L/Q9LHlYjaYfj/AePZNxyd\n", + "uavV0YieDqd/D5V2w8FGsLHeUWChHUdVoBFmRbIcw+I5CmgI/FRtHvdd/DwbXpsKZdMhOgFGwsat\n", + "JlGfFxrv7cG0BXBHLEwbBnN6VWXV9B7MK+4r5mA7d31ZLpQhMzFSEVggIgtVs8YCRWSM15+zVXV2\n", + "kGMrcdgGY3udzzkPzKPiKbYp/vIqHF/akj/yO1aMDOHjmLhy0WfsT2Lk2uH8bUKcuPIUmXQKEzFs\n", + "sd0w3P6txJWbfA3BFRbUKHPdIK48jVED2yiuvAKMzYuDSR39SYxYvQusFFfuBT6yBHLniyt9MQng\n", + "O8WVe9TR33wZT71v2PXPeTxSiZTkAwD97oV9p8Ns27zb4FgPcWUo8AUMMDQkv96f9SSVv9tAX67B\n", + "0LP3wPSN/IGppb8D+D3je3AgRmTThmPcuy6Ks2PhJx/DnU2Av1eqLsLSp1itg4D4wnyBzZf2Cvo8\n", + "QYZ6ugJjvEI9DwHp3gleEXkAqKBqZMlE5F1gmmomyVU41GMgrgyKOMbb5z7PqiqplE+CoytimLl9\n", + "CPcCMXnFTcWVMcDp6uiVue0TRuHBhj0ex7BRjgE+xSR9qwOX+JpUzQ+h6Lo+oTT1tDVTuHZLD4xs\n", + "48vRY1kXncCNeV1DXOmEYciNB27ydA7b8ON1mM9iLiYvsDmv++kGry66ieiyEzqxqPbLcOkV8Ppa\n", + "SLERn8g+i7h3VmngOFPqT2H5wJFZYvxVLksjNi6V5klHMTz9zwC/5Ef3bHlzjgDlfClRFVcSML+5\n", + "vV7bJgI/q6MT8js+FCiqGH9pTHK3L+YL/50Tk7stMIma/kA5jJ7oZaq6OtjBn0ywXa0rgds8MWKv\n", + "917G1CbnGCazFRcrMMIzmwt6rGH4DnGlHSbOXxNDq9AXk1QdrE7mbyAQhKIKLC+NYMas+rtMAm9F\n", + "lOfsx+dR6pZFhhsnt2tYw3kfpvnr/zAx/jT7XiQm1HI78G7TN1nUbA8jsk8mngKHp86BeUcr8VOH\n", + "shxf8LqXKp4p5WbMqmkYz/0R1kTB7y0qkxKZSsqxvXRZvZkOB5ZgEtdzgWbqoySjuLKXPDQrvPar\n", + "gskXRHmvsMWV2Zjk9s++XC8QeE/2n0PPQo/xq2oqcBswHUPa9ZmqrhGRUSIyyu6zFsP1vRxj9Md7\n", + "G/0wMnA3Rjlreg7vPQqcJa7E5nLsE8C7YaNf/KCOLsPEmR1gHKYc8k1gtrgSVNWHh5r4hbPgm+Zm\n", + "23iIbmSMq69nMQSFnd6CeovstvHR0Oh2dXRN37EkL55Aqd/rQ7ubITUi92uooynq6FNAd2AIMM/2\n", + "lKCOJqkRI29bdi/ttw9n0vmd6f9xBD2nQv9u8GqMSKyHoG7kEuhd9jBNUw/Sb8VLlKva5xh1um/j\n", + "rO+nMGbVpRhiuPuBH2mZOIPrFh1ixKxPuXn+WXQ48DLG2K8Fvgfu8eNj3YOR08wPTYC/cwirNgK2\n", + "+nE9v+CZ7KdC/8nQM9DzBJvcRVWnqmpzVY1W1afttndU9R2vfV5Q1daq2kZVxwZ7zZMN4koDzMN5\n", + "d07v2yXqSOBtcaVytmPbAYMwDTZhFEOoo6qOTsGQ1C0AHsKIc78vrtwZaNLXYyTb74S7BhgaX/CX\n", + "wtcmR5vOgCre9spoBEdB+Zg98PnnsOBdKJ2e/zXUSHv2woS2ZtuEcVn73o4+r5O+cCKlvmoJnW/M\n", + "nEwiqTppOt269aInl6e155luwgfT0pnOEk5vNCuVm+c3oN/u5hgW0Vignjp6pTrq4aTagwnt9MPQ\n", + "tYPJP9xqQ2++YA9GQzk/NCab3KINa2UveAkpGsLod4To9dVhfRAE1CWCljk7SpJoio94HngrJ0pd\n", + "D9TRn8WVaRhpu5sgoz75BczS0qelbBhFB6uH8Ky48gFGVjECuLfsPwzoV0akairl/InTe6iJ+/5t\n", + "eOlf7AaP/OIvha8V34lIhfQyXtuNRrDnGgC1vAi187uGjZG/La58j1nh/GEprBdGQfkzdsGMibCu\n", + "ZuZkUp6oqEPMZw7AOQ8QtWE/e+L3ck35pH37U3kCuBJ4M6dVsRpVuIfElTcwxr6euPII5vfxMaZx\n", + "LUfHKhv88vizbasLJISyY9uGgGMwE1n7KjfRrWo1qHYU7lmAiaEEgBJn+E82QXDLhX4Wpi0+P9yH\n", + "qZ7orY7OAgZiStLGFeAQwwgxLF/ODeJKx6iVfBhZkfNSriLirclQ46jvegzePPsvTjfe8/IVbN56\n", + "IN8yRO+zGPGdiJRo0j3mYMRG2Ppa9mt4jhjhW6mj5163iysXYvIaX4krk/tFkEK6aZZq4RVJP0wr\n", + "E25Krgod3iPxzRVcxSV7GyQvvG7bKo0TV9LL7uP+gSJ35ZZoVke3Yz7bDpiV8AiMY/W4uPKyD2yl\n", + "vhr+xpxo+IMK89j+iHZAe6yhx5TDb8D05/zZZA7rftpM5+p22r0jwGuVOMOfEZOsvA0q7Ic9rUHH\n", + "R5vSukKVXAsalgVxLIbrPFeBEg/U0YPiys3Au5Y+9wVMm7xPoi9hFC+oo0sGimz9Xmj54Llw4RXw\n", + "y/98l9rLIsF5gAoVV9Pgq2vZdvxV36t6MkpTK26fSJkDO+D1eG8aBX9lPnO5TwU+E1dmAi8tGELb\n", + "4V8RPyGFep59hlGVtdwM598E5Q/A/Hsg6RQO0nDVAV0QB9D4ff7ZcSW9Pi9LRKQtiM1jklyAKTz5\n", + "E7NKTgHexkwGecEfj392tm2nYoRr8oRdqTck07ifYV81MbnQpcAvmMl1pXop58WMkbUPZEvoB4IS\n", + "aPhtTPKUP4woS+Qu2NEF9v7d0tIV/JZX7XExwyhMB2Gu+q3ZoY5+L0ZneAqwG/iugMYWRiEgCsqX\n", + "Unh+hhFC9wT7K0YQ6cvx3hKc4kolYI240j0v4Z3sUF0ZJ66sYNjC/7MryVyvEQxsOfJ14kq/KTBx\n", + "/S/EV9gdWfFgeveqa6lCEhfCHIWhl0Ot1Tb8lJQRUmqxhetabSHisV7QOR6uWJnnJLkM6KKOviqu\n", + "dMUQ1L0nrswDbldHl+YyzD0YY5wfcgr1nODxW+euOVm9+DMwE9FSzMT0KYZEb0N+ZaTZJ2ICTPCW\n", + "QMNvY5LrLjSviv9Ag4XQ4pY0TPNJB3FlIzDfvn4l5+x7kUJcqYmp9OgdwNgexbADXl/c7isM/+Ad\n", + "Q6/ptebbeiqdxZX/AB/4Snusjh4WVx7AdNOe6StJmUUZCrDxyBvq6I/iSvT8VjxO6uHr+OHILpY+\n", + "VJeIh6Dvd/D1+3DGBLiiyWG+rvSW57goKH/JcnjtTPiwHXTdDk0O5JpoXgbcaK+nwAfiSiPgAmCq\n", + "uDID+G8OlXD5evzWY29MtuQu0BRIElduIdOLb40p+/QY+ecxetQBK7ZlmexFAvr9B13VU/jI1i5/\n", + "pBb89c1Gvq1yuzraA9MgMxKzzBuMWTLtFFem2Lb5s2zCpKjxJIbLfFUAx47E3NcDxeRewggQNoae\n", + "RSh9BGzcWYEHMd/zInHlHD9OOQnThHS9n0MpjfFCCwW2vPMuSutA+v96jP9c/A89Ju3maHwKKyev\n", + "YBLTqbX7T+5bd5tdyZAIyResg9W14OZFcO3FkCa5JppXYjSRvZ3blzEhlosxjtMSceVFMcplHvgS\n", + "6qkBpAFdxJUHxJVJ4spaTJ7uQoxXvwzTt1FXHT1dHb1MHX1aHZ0WjNEPFYo9H3/O+/tO0+wVT+uO\n", + "SaKeBbTAzL6eVcF8zUVOriAgrnQEfsA0ihzw89iGmLGfgckPrFJHHw39KMMoLOTGjmqf3csxurcL\n", + "MPkcX2LI7YGp+PF8iStLgFHq6OIgbiUg2FJPFxPueAp4TB1Nt0Z7PCZUEtt6DGd1g1dTLiK67W74\n", + "7nQ4sIV9KbO5Nkc9WlfWYyQxV3ttuwPoq45eIK7UxUhnDsN44mNP/YCr66TzyqlbWJQIyVsieG3N\n", + "Y6wjayz+TKAapjnsTzK9+Y+A4XmEkUKOk1aIpUCuZ7oIO2Mmge4YLpUETFjIMxms8nOpnPc1M0pQ\n", + "I8vTcFs7Gv/9gc7dfWcAY/8Q2KKOPipGYGMZ0E9DpPcaRvGDuFIRU9E1GlMa+aw6mpTPMeMwOst3\n", + "+XiNZcC1tuGs0ODpQl19MTHHSlPqaDr7D7VhH9/U+5ClbS9BIstz8a+NabY7jQrpZ7UeQ8cyrRiz\n", + "sQ8tz5jE4nk30UFL0ysnYyuufAF8qY5+6rWtPPAXcJk6usBuaw48JSn06DKDUvMWUa2UNYuXVyM9\n", + "7jz2JbZiPplGvh5wnjp6SbbrHQBO03zEj0KJsOEP5vqGP70FmSuCszBUrr+RmScIOGmcV1u8PyWo\n", + "lg/lOww/SKLdNhxjELqEq3tObtjV3tOY5qiHWz7OvlPTuD2n0kYxururgR6WNC2/c68GhgYYegwI\n", + "ni7Uu2oR3XM4rHkDHjrChi87l123vw8Dmf9YBL/eD+ml4dwzEui88ijl0s/iyZZtuXPDF3xyznKS\n", + "0spx3tIqxBxqqY4ezdLjM/C3+jTYs1THHR2W7V5vAIZjcoIZCdeWU4mp0YqIA+Xh2ZlGgxpO5NYX\n", + "V+7DhHDu8dqWI4VDQSNQ21kCk7uhh02erbavdyEj+doNMwk8CnQMPGlsS1BbfQ5HasLm3phJwPcS\n", + "VK9mLcdj9C0+wIQD7sUYhTBOUtga9KvFla6ljjBh9wgav/cD5bptN+97lzaqo/+IK08Ar4grA3x4\n", + "Tgs1xg+mC3UcRA/oD4/ONcnt8RC9clGFqgv/Wh7BRddBuw9hyocwc1l10puuoeY/i0nrepQ/zy9H\n", + "i9Kd+ekpmHZVEoenfSoSMy6Lg7XpG6h1cz1p0eharti2n6yVNadiOMTmYEsnW//OS5N/45zvmsOv\n", + "DTMNfw7J4yYYYZZst8PWklJsETb8ucCSNH1nX544ZDtMaGgwhvGvlLiSkScAluTUtVeFhHrN6E+l\n", + "TTs5XHs9a7t0J2n5Z3A00o/Wei7A1Pn+L9s4VVwZBSwWV76y/CRhnMRQRxcOiJDNV7Wh+dBh0G8j\n", + "vPdNjqWNb2IqWwZjaKHzQmkKqarHgygon1zaNHHdsihzeyWkDAcbwYYBcOpcuHIwLL8K5rTdS4X9\n", + "aaT/L4bly+GKwfDzE5D0cSRruvSn1bH6rB4fTZ1l0PYjKDUL6uytyOHuExhffx8x62fRbd8kTBdv\n", + "B46Ucnnu3KZQuTUkDtnHzEpCKhesgwvWZY4nh+RxE0502Hyq4S8uKIFVPUUDdfS4OrpIHX1FHR0G\n", + "NMAkeSZj6nfHAvvElV/FlefFlYvFlToxIrGxLGu6iB+ZnbyCRVuTiV2+mMgBTaHrimq+8LRY1sPn\n", + "gPvU0RN+nDbhNwb4n+ULCeMkR2Wl/DXLYd1rcMWKzPp/b+/Uhv7uBF6yse28UGjlnB4kQnKFVHh1\n", + "GpTxKlg9jA1ZJp1itIzfXAGRu+HWqZ04XtnsubstfP82GZIge+r8RezaNlRIgNLJsOMozOwOpSpC\n", + "wufCjgU1mX5xe8a0TlJH/+LxlokkRTWm+c39YXJPmNp/MT3rDkd2eo8xly7lxoS4a7ewETb8AcIS\n", + "b21VRyepo6PV0U4Yro5HgQOYVvE1G+7mi1IXH6v4dif4yxaNfXb0IK3iSifT869IYLq40jSfy92E\n", + "8Sam5bHPW5gf7m3B3VkYJQGe+v9KKXCeF8NTdu9UHZ2BKW3ML8lb6KGe3EpZtxDxOozcQFJdzy/g\n", + "jgAAIABJREFUiNppSranlN/I2orPUHv36Rk7bxgIav2cI6nxbKq+i0G3wI4zYXVVSH3VTBB1PPlq\n", + "wzoKQNqptzPjo7L0eRTE1HAkMrPe18Ts6H4K8edHsTYWpi2E0d4VQ141/Nm9+xLl8YdDPSGErbSY\n", + "ZV+IKxFnf8rCXnXp/GsjSCwL9803+9Y5dmA9FdI7YDyy38SVFzCi11l+fOJKVcxkcl5e8UNb/jYC\n", + "mC+ufJcX4VsYJR9+cujcg3nGJqqjO3I5ZaF7/LnRQcRrQpxIzCJSVjxM1ZXtIXYubH1Nf0iIk8rN\n", + "V1Hx6vc48lGGPGTpMpentEuZd3aDKYnsaPi5rj21oSRtsaItG/tBWW/9FU94Nao862OhzadQZRsc\n", + "aAzAQVocnj9qxafAbnX0+RyGXQdIzKGqqhEliDImbPgLEOpo+gBXDt6wE27IVmyWStoOG7Z5QVz5\n", + "EhOPvVJcuVEdXegpc+tfg1aJpTl+cDcNcFiez/X+EleeJbH0lyIDdkPlk4W9NIxs8IdDRx3daMs7\n", + "nwFy07wudI8fcqeDsDQSi4A1qnEZFTV6aN2XIjFHqdj3v1TT9mWPJZaRc9aWue3vpDLD/wS2pXNZ\n", + "1ReIi2h/OCl9TCXmZm9x8VBAJCaDwJSPcno/ryauJpzYsQvhUE8Y3ljcl11XRZLFO8jumanRPI3F\n", + "NK9MKX+LfNuhPK9Nhf7T9tHw19008AhV5HvBp1qs4XDllnQYkhG7hG6vmjK3ME4mrFSNi1MdOFm1\n", + "V5zqwHyI054Ceosr3bw3xojEDhSZFpFC5c5PVV5fVbosFxk4rZg8L/uAKh4ufw9UV8bp4Z+6nbd7\n", + "1pyL0xZHLJubhNMLFjQw7392AFpXW56epcMf8GYdPYEBIOv7+Rn+7PF9KGGhnrDhL0CIK6fuO5uB\n", + "C6pyeyxMGwZzcoobQkbOYBIQU/Ufus26mdO+bpH5vs/KSscb38aU2eXo+xBEeVb1XrHNMEIKj+Ec\n", + "JjJ7oMg0nybnIoANTTyI4fGJgKxqTqUF+SXtUM3+7GsTyW3FwlmwZda5CqNUTaVci/3QfB/88Y7h\n", + "7vEgsmxaOn2+ng2x02DYHPPvwtGela/5d8Edubyfl+FvTDbDb4sv6mDkZ0sEwqGegsULwNhN23QC\n", + "MMGXA1qPoWsMVLrlVLhxMJRKh8F/mfd8U1aKKs+eNrDwLmg0D1ZdZrf7VToahg/IRfPWJy79IsLH\n", + "wC2Y5qX/eaQbwahglU6Hz9hIZ15lMT8WF6rznZiiiRN49BMh2ZOUqJGt4FL2sYweey+ix9Q+6uiK\n", + "nE5sjXxO95efx78k27Z6mJxAiWmgDHv8BQRxpS/QEcMB4jMawuhoqNBjCyx7K7OJBHxVVrLspb88\n", + "7GX0ITO2GUao4DGcz58FD/eFP06BcX5r3hYebHHA7cCT4koVj3SjYpyLCFs6UKnO71DuIMXEWdiF\n", + "6aI/Adtg7GqIfyTb9ssrk/r7BdQH3gA+DoDIcDd+ePyUsDAPhA1/gcAu/cYCd6ujfhncKCjfD7hP\n", + "oFwaeDhDrrfJu/zPkGfsMowQwmM4z9sE6QJDh0LTO2DtYFqLK2f60qNR2FBHl2AIAh/zlIQK8PWk\n", + "zF6Aw2mV4T89oNoen+igCxi7MB7/CVipGvcXjPwFFp8PCZdCQt+yrI4byOFDMXwC3AyUA57xMyT3\n", + "D1A7l+8vp+RuiUrsQjjUE1Jk8IT0bhlN0/iqvFf/OI5/50iE5B4AaohESmH4XzfAKl/CBxmKSsT6\n", + "xF4aRuDwGM4zdpnX0zNhWV24oBPHgQ+B8rZi60tgga+8+oWAh4FVa07jkZGbspaEDqMpa/e+Auv+\n", + "m8DNc1uJKy2KuBvcE+rJETlVBYkrgzFqW/0AR44zut7pXD31L2p69skrJKeOJosryUAVTE+O57yl\n", + "MNQM2b37Emf4wx5/iJBBxFZpQn86/dOUrxfWQM/yO0HmaWrpATyOacfdCRsT8H0KUV0Zpxo3UHVy\n", + "L/Nv2OgXBLI3IAnw+i42Vv6e0RjSv0HAIYwR2iauvCau9Czq7mp1dA/w9JZrufhX4Y5+sGQwEUnd\n", + "qZwyh0pJyby0hFkp11BWHwRmiytnFeFwc/X4c4M6+h1mdfwucFXLGfy9ZhA1bxwMB2z/sg/FEjnF\n", + "+esBe72lEC1KXKgn7PGHDJaI7dzrYdl1sLcF/hKxQWg0TsMoHPjwXa20rzHiSgvgUuAV4BRx5SuM\n", + "5OacnGg4ChIxIrHnlab/r7dxTunWNItcSYUppEeaOWp5mZFQZQGw0tEJ4spu4Btx5QZ1ND++n4LA\n", + "LuDcAI57FmgDvNdqEdvfXU7TB8+F3+pD/41mh3yKJTyG/y+vbXnV8BfFZxMwwoY/ZLBawMuvhvhO\n", + "Xtv9T5CFSuM0WGShuA03guUIX78rdXRtjMjShnBOWm2Orz+DPtva0zetAtXElW8wk8DP6ujxghxv\n", + "RiVSKtFTv4fRA2nabA1MiIQ2FaHjzqxkb+roVHElFvhWXKmrjo4ryPHlAL89fsggLxwBzN1dg8pV\n", + "9sFbP2TdJ59iiZw8/sacBDX8EA71hBC2mubvPnCsstf2kllNk6khMDXcCBYCeAzuN6Xo/+Mezvz7\n", + "R07/z7NIg8nch6EDfwwjETpBXDm/oCQ1PZVIuyvBEz2gWQLU6ArzU2DwlSZBva7GCWRvi4BzgPvF\n", + "FbeQk9Z5xvjzgi2suOjPvlQfXgZfyNe8kZPhP8Hjt59FOMb/78XJVk1jQ1elk6HdRLst3AiWE0Ri\n", + "Yk2367DZuXW9egxu7FXwQTuzbTxEt1nNZeroS+roWRja7z+A+4Fd4srHluU1ZGWVnkqkOoeNUHmt\n", + "JHiuO0RFwPqxxuM/+3qYcxlNrfALAOroBgwl+SBgXDYt24LEbkxoLKDJRh3dkdiK86dcQsXzyjFv\n", + "YDU2d63PoS+IObCKoffn0aWcm+HP7vFXA1IDFWkqqgbAsOEPEfLpBARKTpenQVR5yu+Hq/vD6d9D\n", + "hCcMXSxqu4sNfF0ZeQzu63HwSF8Y38Fsz+ZZb1dHx6qjPYCWwDwM2+ouceUzcWWoR3g8UHgqkQDG\n", + "ToWZTaHfBphxrmH6fHAe9H+dvw9VZj6wzIqR17Tj241R/2oIfGUlIQsU6uhh4DimwibQc/yW2JLR\n", + "Mx/ilGllT3v4t0E1yh7sMrJjPivZDMPvmdiJr3YRn50xKtu+AYd5vDunJ0PPqdDfZ2qWIBE2/CFE\n", + "XtU0RfklB4Qau+D6s2FnB/hikpG/A0pq6KrgYFdGFRLI4IbPYWXkMbgt9sKsCSbM8kbn3OPM6ugu\n", + "dfQtdbQvptxyJobqO15c+VJcuVJcqZzTsXnBuxKp+lF4+3uY0pD0lU3LaFSDjklV6bo37ugpHxwd\n", + "p5cBrTET1jpxxRFXoiz1w2CMRvVPnkmhgBFwuMcDdXQi8BWla7/OFwvL0+NxiNxl381xJbsHqJ1l\n", + "Yq8YVYVdX3bONlEEHObxrAL3VYAOo+xICqkBMGjDLyIDRGStiKwXkQfy2K+ziKSKyCW57XMyw7s9\n", + "3o+SsiKBuNKWm+a1ZkWFvUx/GdTzmJTk0FVBwSb1L70C2nuLo2VdGXkb3GYJMHsCPHA2qXOvZTv5\n", + "QB39Rx0dr472x4QbvgOuBLaLK9+KK9eKK9V8Ge1K1bgFcIeHO+qRv6osPra98THd00OSBkZEHpRf\n", + "a+5n0NUiMbHq6E519FaM4FAzYL24ciemvWQ4hn78V3GliS/XDgK5du/6iQdJi4SEaHj7T0jynktO\n", + "WMlaj99O7BEpZqI42JBsE0XAht+zCtwVCUe9Ame+UbMEh6AMv4iUwuhWDgBaAVeISMtc9nsWIyRS\n", + "7LoZCwOeL3lxPTjjJthiF66F8SX7A3GlNzCTMno7vyRfl1foKgzISOr/+AKc+yBU3Wy3Z10ZZTe4\n", + "tx5gWvWpjDh8Gr3ElYd8vZo6mqCOTlBHz8cYncnAJcAWcSVOXLkhPy/cm9VzBd328cMfFai1Bsom\n", + "2XxOVg9YHd2ojl6NaYjqC6wD/oNJSL8GzBNX2vt6DwEgoMqe7FBH09gTYQjSE+tne/eElaw1/HZi\n", + "L3XcyDyml7FvZ0wUAYd6PKvA3ZEm55IxEp+oWYJDsAmaM4ENqroZQEQmARdyohDx7Zhytc5BXq/E\n", + "wvMld4qHuxZA3+tg7vuQlFjwX7KvEFcux1BNXKaOzrItYyXK0Ht0DKKgfCIkb4OxBdsDsW0sjGzK\n", + "nvHRzL8XLrweJjbZiJ64Msqly3QG8LOlHv4/f8S61dEDwEfAR+JKFIbaewhGavF3zG/uaxubzwVR\n", + "5UmuZnjpq/4NfR+GNZfAsRNzOerocmCwuNIdeBq4DyMSdAdGSe5KdXSmr+P3A0GHejKQvuMlIm5o\n", + "Rvp7jTI35riStYY/0XjzKZVg/n1eb2dMFI2AxYEMxSOm0zuS6LqWuN2HaqOQIFjDX5+srHnbgS7e\n", + "O4hIfcxk0Adj+EuECn2o4a2YdMdvcLQMtBhOSo1vmZj/0QULWzFxN0YNrG9ubIbFHZ48yttCdISa\n", + "pWVBs2VmociYX7EC7Ra146pFM/TDRJ+up47Giys9gZ+AsuLKo63HMNDfyUsdTQQ+Az6zCeABmEng\n", + "WXFlKWYS+EodzUYdbFcsm3sDveHUX6DHEzAj91yOOvqrHfMADM9/KmYi+FhcuUsd/cSXe/cDIfH4\n", + "IeP7upnIPi7VaMuu0gtIiX8uh5VsAlCF0lveIHVkU7MK8iDLRNGIAD1+TwPgz7V5MS2NqFhYUVjN\n", + "mqK+OxgnHixyKTBAVUfav68Guqjq7V77fA68oKq/icgE4DtV/TLbeRRwvTbNVtXZAQ+smCJGJLaR\n", + "V5fn7BtIONqQGKC3OppQFGOy3OwvYbojB6qjJ9DflhQMFJk2Ffp/0Qoe6QM3LoHhf8I1R5kWpzow\n", + "/zMED3HldGA+0E0dXZ/f/l7H1QJmVF/Ixkum0fZtIdpD0DcSNiyAOwIxCFZkvR9mEhgMrMJMAl+q\n", + "o9syk5fWsEXuglsap/NjjZt06Y7xPpw/AhiKYRhJwDQ5Pa+OvujvWPO4xnCgjzp6bajOac97JyZk\n", + "1T0HKUVs13I7xrTuYEJfJ3JfiSs7gU55SFr6Mo5ngEPq6FP57ivSC1NZ5YGjqn6Hz4M1/F2BMao6\n", + "wP79EJCuqs967bOJzLh+TeAIMFI1s/1bRDSQwZd0WE/7OcwXea46erCQr18emIgRkbhIHd1fmNcP\n", + "NYaJzJ4MPRVY0BDe7gTfNoeKW9mz83SGAPP8CaUECnFlNHA5cI46mubHcdW7vMffC7dR+UFLUvD0\n", + "TPPjiSX4ycs2hfXFTAIXAuuBL/i8wT5WtRmWYdiunbuD0w6foo4O8uPcZTBG1AUqAl8B14eCmE5c\n", + "GYBhuu0X7LmynVeA9zClokOzj1VcWQFcZUNcOR1fDsNzUdGf7zmH80wA5qqj/8tv3xOODdB2BlvV\n", + "sxhoJiKNRaQscBnZOCtU9TRVbaKqTTCexs3eRv/fDGuE7gcWAnHiSmRhXdtWgUy3f/Yv6UYfMvMo\n", + "Apy1DSZ+BZtehQq72AeMB1aKK6N9rYAJAq8DxzAi5z5DHU1osIMVAPfOh5+awK2DDOVzKIoA1NFj\n", + "6micOno9JnTyX6AZQ7c/y5iptRnz+XTGTB3NaYdvAaItVYOv506xdA6nAS9iqo422hVQsAhdjN8L\n", + "9vd3M6Zi6LEcdslLkAVMP8OOYIy+RR1Mo1qhISjDr6qpmAaT6Zi2889UdY2IjBKRUaEY4MkO+/Dd\n", + "gUmIfxvKLs3cYDsy52G6RC/PgW2wRCI7WybA/UfZWOFn7sU0RN0CdAM2iSvviytdC4J+wHqO/wHu\n", + "E1di/Dn2cLrRZ655BH6aCKtqwbUXw6FShPQ7soZ6hjo6CsM6eS/QAJgLLAJ+A97Irnfrw3mPqqP/\n", + "Z891FFglrrwlruRlQPNDqMo5T4A6egxTFfUfcWVItrfzM/yhomoodMMfVKgnZIP4l4Z6vGGpeicC\n", + "1TFhl2MFdJ22GCGOl9XRlwriGkWJ7HmUnJJlNp4+HLgROAy8A3wcaNt9bhBXRgI3AV19leXLLud4\n", + "tDQ0vZIj/9RgeWoVehf0JG2fw26YcNAoTCjjHcxqfYU/oTJ7rnHABZja/9eBF/0NadrzJGNCKgUi\n", + "byiudMA4sOepo3/aba8Cf6ujr+RyzHBCkHsQV+KBM9XRfHs6Tjg2QNsZNvzFCJb/ZBKm2mposA95\n", + "9tLGRecxe1937gZGW2H3fzVsYrIPxsCdC3wOvGNVqkJxfsGUby5UR9389vfAM3lVFCrtqEfLNZ1Y\n", + "e7A9O8l0Ck5IRBYExJXmGM//E0yp6HHMBPAFsNSXScB+Bg8Ct2JWEt0xea03/FGns8axczBJVB+u\n", + "McyO7Ux1dI+48ghQSR19+IR9JSaWgYmvImXKENdsbaDMtfYZPGav4zcza9jwnySwS+spQBImsRRQ\n", + "/DC75zgpBobHkha5lEf3/qjPhHDIJwXElbrA9cBIYB/Gy/00WCMrrtQHlgID1NE/Aji+PMbQpmCq\n", + "ZloCgworJyOuPA/UAG7AaEhfiqniicAoi30B/J7fJCCuXIdp4rwHs5rojEkEv++LHoG48gdwozoa\n", + "UM28rxBXHscUW/QFrsWs1kZk2cdTCXVBejTbu8IfIzEEjQvu8Nf422a7v9TR6gGNt4iSu2GEGHbW\n", + "H4L5sb1nPQK/4aGIUODFbnDfebBoAqXOnEHPUI73ZIHlxnkKM1E+imGh3CquvCmutAvivDuAu4CJ\n", + "gVAt29DOJZj+l7rA78AscaVOoGPyE49j6vU7q6OL1dGHMPQNF2PCLxMwXcMviyvdc3te1dEPMOG1\n", + "l4H3MRPIFcBqcWWYD895yGr584GDmfjfwMT4c/icLY1Dla1w0NMHFjBzbV3MvRUqwoa/GML+2C/C\n", + "VEi8EUgC0kMRsaAhvN8e5r8HbfYUP4qI4gZ1NE0dnaaOXgS0xSTdvhdXFogrwwNkpPwEo+Tkc7gn\n", + "25iOYyrmkjDUKN8Bc8WVRnkeGALYvMfDwFiPcVZHVR1dpo7+Vx1tiZkY9gNvYfiDXhdXekk2iUl1\n", + "dBomZPQ2hoK6LyYEdD+wWFwZkMezXiCVPdlhE/PXAF2BnuSY3LU0DlE74eCpXtsDYq4t9MQuhA1/\n", + "sYWlox0EtMe04Ptl/D2ljWdtg8XjoKFNWxYGD8jJAkuT7GKI0Z7ChDi2iiuviiut/DiPYpK8wyVA\n", + "/Vqb77kKYyTOxtSfzw1RuWR+mIipkr06l7GtVkf/Tx1tC/QG4jFNgfHiytviyrk2f4UN1fTAGPsx\n", + "GNbRzsCTGFnK3DR+C8vj93RBX4AJ9eQwudpu57eWw97mXtsDYq4NG/4wssI+gAMxMccn/DnWu7Sx\n", + "vI2gFhYPyMkGdTRVHf3ONjR1xFS6zBRX5oorV9k4fH7n2IMpJ50Q4KoBGwsfjhEDGYxJRM62lVoF\n", + "BusFjwaetpxAee27Th19Sh3tgKkO2ogx6jvFlXfFlYGYEsizMN7/eKCUOvolEAN8AEwSwzraxuvU\n", + "BVbSmct9/I0x/HXFleis71rRJY0gszc1YObaIgn1hJO7JQA2ATQbmKSO+jwB+FLaGEZgsJ2qgzEV\n", + "Qe0xXvE4dfSvfI77GNirjt4RxLUjMDHo9pjwynPAherowkDP6eN1PwB2qqMPBnDsqZhcxRDSaMuG\n", + "WodY1fgAB6R2RMzafS1+lCO7Uls2TiGSI6RuTuu9chE9914EzMA0V3XE9JxcGtKbynvMgqm42Qh0\n", + "8S73NQnenGkc/LzGs8ABdfTpgMYYruo5uWGrTuZiyg1DxoMSRvAQV5piqoH+A6zEVAR9nVN5nrhS\n", + "HVgOXKOOzgrimoIJjXTHVMu8AVyhjv4U6Dl9uOYpwApMpcuG/PbP8RwSE0uVmNdp3r0Jrb6EOstg\n", + "Y0Ut9ddpkrZmOqSYxZAwfKdWXjCau/9qjVltzAEaqKNnhup+fBqvK5uBXzASixeGoEs3+/knECBd\n", + "A4Srek56qKO7sMkwceWWoh5PGJlQw1f/IKaFfxwmnr9VXHlaXDkt274JmMax9yUABS2v8yiGTfVn\n", + "TBXSDcCn4soFgZ7Th2vuBJ7HxO8DRMPRHJzUhL8Gw4TZ8MYa2NxW0s4oB/ecAtFTzbWYcAqHmt5g\n", + "cywtgANAR3HlKXGlatA34wNEYmL5p1JVPjq7FfGVu7Gj/KcFcJlwVU8YeUMNc2Zf4EFx5fqiHs/J\n", + "DF8E1LNDHT2ujn6mjvbBVISUBX4TV6aLK5fY8BDqaBwmhBHUys0a/wcw/FjPYKpR3hFXrgzmvPng\n", + "FY5HdJS27Rb789lkIqo8km5kPWutNipYi7vAxJkwdiNs887rmioZdfQfjNd/HFNls15ceTDQXIkv\n", + "yKjV39+rChH3d+CjjdWJLHWxDKnyXIgvFU7uhpE/bNLpXODxAv6B/2vhq4B6XrBJznswq4CJmFr+\n", + "zeLK47YM8x45zgXt2sriYSKzB4pMC0R/2ZZW/hfT8f0qpjb+OXHlJn/P5RPGtO7L172g57GOlPoo\n", + "gM8mMRmNgOVXwxkT7DZbfXCkJhzz1lTPrJKxjXSpGN2IczAx//Xiys2eCTW0sLX6h2tDpT1mbB8v\n", + "KE2zI3eKK6EUlAob/jB8g00g9gdekouqPeGvZxpGfrA/+qbToYEnXxpYg446mqyOfqyOnoPhxa8C\n", + "LC19iBltF1Bq73l0fLsCPadC/27waiDG317ncUxj1LsYSuj7xc1dAztwNBzN6pn12N8EznzdbvPn\n", + "s7EVMX8Oh7YfQkQq5fkjtS5XZNlLuG5nDlUyu4BT1NG16uhQTMnlRcBaMeLzIbRntlb/cG2oYJuk\n", + "97SBaWf8BXwlrtQL9gp2vLUwjWKFirDhL6FQR1cyvc4TND/6IM1uD9gzDSMTMSKxA0WmVSWlKwAR\n", + "qXDZJV46ugE16GRAHV2ljo4GGjZdSMUKp1HjUDkYdCXsiILxEN3IyJQGen5PkvdDDC3ydTYmHsLC\n", + "iajyIDD9ZUjzdrR9+2xM5cuCO9h79zSOHD1ETMclFfjziVpMXVyDbglRnJdQmj5LlCUjcqiSyVLL\n", + "r44uUSNAPwITCloqrpwfmvu1tfozn4b592Zu/rPWNkwD2le+lPHmgxoYARa/OXqCRdjwl2QsaH8+\n", + "H88pxUXDobZHLTHg1vF/NTzcRlOh/5kcNPGG9YNg3oNw5flQ7iABNuicAHX0SNv57FvwHsyYCK33\n", + "QJtb4OLLIKE19YPxXNXRlzEJ2MmYmv9+wGuh84atQdzbAn73fsx8/2xUV8apxg2kzsH7uWT5pgSN\n", + "d5frgc57dUGNQzqjRor+3CmX0sgcu3dtdVQ3DN3Cs8Av4so5/tzVibArE7znkIxa/ScxvRTjgpxk\n", + "iiTMA2HDX8IRVZ4dXeB/v8A/rb22B+eZ/hvh4TaKj4JbWEtTLjNv/HY7bO4FV7Q4Stm/3/A+JpAE\n", + "sAeezuquO+Dd72DryxC7Hlb25lSMgMlDgfLxqKNvAv+HIfu7GUM9McHTPRscPAbRGwE3L30G9LMl\n", + "rr4g1yYum+v4GnOv4zDcSHHiyhkBjCtzZULsNBg2x/y7cLTqyjibVL8e03B2bz6nygtFUtEDwYut\n", + "h1GksN7XvubZtofGM/03wcNtNPAqWFMriagVcVRZ1JnDx6NSUpckb+fqf0rz8K5bxZUdwFbcVl3g\n", + "rFezinCPbCoSgy+NPLazuqmHPTXyOPz2Bxsb/8HoVWPYg2kMWyuuzMD0BcxSP2QM1dF3xZXjwDeY\n", + "WPjjwOfiyuUahNZDFnH5IJuX1NED4kocJiH9Rn774wNtg62znyiufIYpm50qrswG/utv74G9pxzv\n", + "Sx09Iq5ciKnaWmUrtfxFkXn84QauEowThLIB430Zz6ToRlby4BFqB0iNgJ2RsLUKjDyFZWti+RRo\n", + "ikmaJgIVSYmI4sDppTjYCPY3hR/etGeKnaYa55M2bn6d1eJKFQw/zyiMju07wAR1dK+v9yWuXI5h\n", + "xByM4cepClxsuaCKHOJKP+BJdTTfShlbwtxDHR3ux/kjMQp3d2EopB8PJae/5RX6Guipjq7x89i7\n", + "gUbq6J0BXz/cufvvRKhax//tyK5fAIbbaCGM9hhjSzuwABjFMxfeT9RTZ1NlK1Tca8oTARg2R3Vy\n", + "r1COzcaRu2Aawy4EpmISjL/kx4Nvj78UeJNMiokWGE7/A6EcZyCwDJ6bgYHq6Mp89h0I3KGODgjg\n", + "OjUwPQ83YAjunlFHE8zvp+Fok7ROTA5EUMVOSA9hBFx81kkQV54DEtQJXB8jbPjDCCNI+Cjb2EVS\n", + "+bH1/yql14jvVPUw5VjLaJIYZPfw3eMPBGKE4q/BTAJg49m2Iziv4wZjDN5FwDBMg1l/Sx5XpBBX\n", + "ngTKqaN5xsvFlfaYFU/A+ghihHH+CwxhS8Uf+HhId45/0DRzj4AFVV4GWgOx6oOwjD3mA2C2Ovq+\n", + "P9fKco6w4Q8jjIJHjEhszXa8t7EPdRe+C/UT4TKaEserJPFVoYXZ7CrgbIwHPwjTvfsOsCC3VYC4\n", + "MgDTTDYE0wF+GUZjdltBjzcvWGrpuUBDzUNu1HIF/amOBi1CI640Y0ONOdQpcwq/PAxLboQ0j06O\n", + "/5O3TZz/AKxWR+/y8ZhpwNgA8wPmHGGunjDCyIpgqm5yQ0MYPXsZdW9ZBHdY0/AZG4nhqr2FmVux\n", + "VSy/qKNXYxSxlmPUsJaJK7fa/ECWz4AxA+7km3ovYyQT52JWC7+IK80KY8y5wTYkbsTmWPLAHqB6\n", + "KKqT1NH1fNTnLz6Og2ZToYt3UZL/VXGtx9Cv9/OUqnCQUc3PlhU+NuKFq3rCKPnILu6+DcYWFQ10\n", + "zolv36tucoOn+ufBeZDoJaTYkIOrFuiBIrlXm+x9UVx5CSOEMgp4Qm4r9xsN+7Vi27cNM+rRl45s\n", + "SvrU57l4x6eYkNETGE7/AeroilwuURh4H8Nu+n1uO6ijaeLKPgxfT3zwl0xMZld7+DgOxLtgyr+q\n", + "OE9+6M2jRG/8EHr8h5iGOyp8UEb6bE2lZmIeuYNwHX8YJRveDVCTCZ6CIHg0GE3VR6LxdIvdAAAg\n", + "AElEQVRp9UXQtAve8NTfC1DZqyiyOCib2VXAz+roZUAL1tdrwiWrGjKqI5yyxO41PpplbXtjYv0f\n", + "YjzOuzHCMl2KaOgAnwN9rfZEXgihEpdXT4J6TKH/PQkNYfQ4iG54N1Q7Crd+VZ5ll2rN1CoTOuTW\n", + "UW+T2jUpAroGCHv8YYQIngaoD9rBn3WhxlHocITo+cKT4soxIAEjYr0POOJLNYo/sNwpnYFOQCce\n", + "KNOHlO4Q3xn+GOG1Z3DNbdnr76F4Kpupo7tFhu1kxqTTOW0mJHpTy0RWUEfniyuDMB72TZiGpO/E\n", + "lcuC0QkIYrwHxZXvMTX9eX2WIdPeDVVPQhSU31oFRKH2YZi/IYa0BZfB5RfC/+ZBSiWM0xF7O5l9\n", + "ATWAg3nlNAoSYcMfRkjgCYGcehD+qQQJFWBbXdhbjQYYvvgaQHX7r9gl+z6yTgh5bvNUS4grtfAY\n", + "ePPqDJQBFgGLgbcY1608++f0OnGkwTW3rVSNixEhtkQom1kmzI39sm03n4E6usgmfOMw3P5DMU1e\n", + "N6ij3xXyYMHkKJ4jb8MfUgnGvJq0fEUiJC+uB53izUrwGJVg/j1QZQvUXAc7O9g9szgdRRbmgbDh\n", + "DyNE8IRAem02Lw+2weI41SwVEpZHvQZZJwPPqx6mFd7zdy1MTDdS3IxArGCEOXYDWzCt/5vwnjii\n", + "tn7IgRGN0He9hFACphbIAmvki6Ghz45tY2Fk0xMb/DI/A3V0qW2imo6pcx+E8fzvUkcLQngkL/wM\n", + "1BBX2qmjy3LZp9BE133FNhjrNOLMofFUAyjHYUBgavZHLYvTUYciSuxC2PCHESL4EwJRR48AR8xh\n", + "mRBXKgEdyPTkm2N+5EsxnvwajIE/jJkwvCeNFnhPJNdvrsG6z2rz+zLleGQqEUeO0XFtMm0PjRJX\n", + "hpDPCiMQWoNQNAOFEr6GMtTRFeLKucCPGH3bc4Fp4kqUOjqu0MbraLq4MhG4DpN3yAm78HrGigNW\n", + "qsaVuVc2T5nBplWQtJP1lYTh9ZUJXiuTE5yOuoQ9/jBKOvwNgVhK23ZkDdc0wWi6LsYoVD0FrA1G\n", + "51RcKYfRS62R7eWZNKJz2FZDXEnhxHBT7qGp8U3aI72fQN8LaRVRsPA1lKGOrhZX+gAzMZ97T2CG\n", + "uFJFHX2+gIfpjQ+AX8WVB3KJf+/E9C8UG4grQhSNl19Cq2XLdBd4nIA8J9wiDfUE3cAlIgMwos+l\n", + "gHdV9dls71+F4QgRDM/Jzaq6PNs+4QaukxhWISmGTAPfCeOhr8UY+cWY+PyqouAmzw7bHBVJzqGo\n", + "nLcdK9WIMpQhuQq8uslLSapgO3lDDasR/BOG32cKq6LmM6tdCnvrboOkQlnFiCtzgRfV0W9yeK8H\n", + "8JQ6WmyMv/3M5qqjDfw45jnMyvLZfHfO6zwB2s6gPH4RKQW8jlka7gAWici3qlnIijYBPVT1oJ0k\n", + "xgFdg7luGMUXtkytBVmNfBsMH4sn+foesFwdLfISyJxgK44S7WuzL8eIDJuNfNqTCvvhmLeGesmi\n", + "yFZHN4krvYCfmFuzHbMuTLV5EpsrKYRVzMzaS9jUdJyMGXZXDiGzYhfjxzzji/08pi6wugDG4hOC\n", + "DfWcCWxQ1c0AIjIJQyKVYfhVdYHX/r8BPs+KYRRvWHGPpmQ18u0xy3GPJ/8ZsNRqpp7ESExGSxlt\n", + "1iwoeRTZ6ugWcaUnG09bh75biah4OFwL0suQQ1liSGFCJIMvgHdrY5L6ZJtsQlbOGUIEYvhLdFVP\n", + "fbIm6LZjWARzww2UiGqIMLLDhj8akdXIdwQOkenJu8Af/jAUnjzIv4KmJEEd3SGPX7QVaMlFw2HJ\n", + "SFg91L5brgCdt4aj4d3TkHToMtYI4WiWySYJUw4cpY4mFtw4/EJHjOqZPyjRVT0+JwhEpDemSaR7\n", + "Lu+P8fpztqrODmpkYQQFS4jlbeQ7AWlkGvkXgSXFgd2xOCCUAiXFBmnHahEVD/UWwade4fZ6u08X\n", + "VyoVDKe/FTlv+Cuc8T4s9FDVm5CZOqriiifcU+SG3656OwJL8ts3GwKq6hGRXkAvf4/LjmAN/w6g\n", + "odffDTFefxaISFtgPDBANWdvUFXHBDmWMAKEbZPvSKaR74xpyPIY+XeAkUB8qDtuTyaEohmoeCFt\n", + "JzHX1mTtxZDqSVU8BE3iDwPTxZXzQ8/pb1XlWk/2WmFAtpCZJ9yzPrTXDghNMR24//h6gM2D1QB8\n", + "PsYD6xDPzjiXiOPvOSB4w78YaCYijTGkSZdhWq4zICKNMNqfV6v6J30WRmDIiyzNsjZ2JGsZZXWM\n", + "x7IY+BijVrS5OBn54lYj/+9AqXjabm7Dj3WBMZgF30CY/+dvnLdlPfCzuNLfH6OXP7aNRUY0pVVc\n", + "NBM8zBEnhMxC2r0bJAKJ79cADhQVXQMEafhVNVVEbsN0/ZUC3lPVNSIyyr7/DqYhpBrwlhhB+hRV\n", + "PTO4YYeRG7yVpA6XgaWnwF2N6Fj2DlmRUp36mLzMn5iH9RuMKMV6f/RcCxsFxbQZRj7otOxrIg/0\n", + "ZfOa0ubnDTBiI7rtNYwK2P8Bc8WV89TRE1b6gUB1ZZz0rdWalMP/5dBDq2myvT07Eu/WY2viwDzf\n", + "dS+lc/V9tBs4Rq4vSgZYi0AreoossQshaOBS1amYh8B72zte/x8BjMh+XBgFAw9Z2sIG0Oc6iNkD\n", + "neOpmbiYmuv6MQRY46tCUPFBw9EwPpozX4fSyabC5MhF0aQte1RcWYtZMicVpxXKSYHzdzYivvw3\n", + "6OBKueQt/iuuHMRw+p/nr5h5ruixtyHwvB6f8rgVSi8FmU7Nqf/Q6EgZeAqiR0LTGBGK0Ph3BJ70\n", + "85gireiBcOfuSQcPWVrHeNj/DJSzPa/DIGHtr0XKtx4ETMIvMmE1Lfb/QCWSOVw2jbXtD5+RZPhd\n", + "agGlxZW9mEkgp3+zb9tXlEvt4g6btLyKesmDVeOW57afOvqCuHKITE7/PHVzfbzuEKCP3TQBGA58\n", + "5XFq3kuEXxuZN8dDdCwUWHmpD2PtgP+J3SKt6IGw4T/p4CFLK5MtcFMc+OIDR2JyJD8Qu+FHPmNr\n", + "xtYrd5bT5XHcslI1zov4rRaG59z737Y5bKsuriTh+0SxFzjkvaoIJO9QnMRq8sHZmKRlrkbfA3V0\n", + "nLiSiOH0v0Ad/T2I63YH9qqja+3fXwAviyt1hlqnptFBWOC1touEomqSOx34Jz+94xxQ8kM9YRQv\n", + "lBS+eP+wbWwrRpzzGbsqpgvsioR6ifAJxyp6vL3ciN9yg/XWqmEmguyTQl0MxUT2SaScXVXsZVmV\n", + "dCIHNSXp48iMk5Yd3k461B/LhfE/YCcPbwoK7/yLZ1sxCFXkhquBj3zdWR391Br/78WVYeoEXI49\n", + "FCPK4jlvkrjyNXCVx6k5b5N5eVCETk0n/Pf2IRzqCSPUKFl88b5BdWXcBVJ6I9Dm3WoVueO6VLq8\n", + "3I1yHOYA6+sHdE6TzPaQrK3z5RhLLGcmih87jOfwx5FU/RuqbYK/+8LxCXX5p9u9EH+V3a+GuHIE\n", + "u2qoej2npe6j1n1HYNgq6BxftKGK3GDv81LgDH+OU0e/F1cuAyaLK9ero7nKKOZy3Qh73b7Z3poA\n", + "vL5VeGCkFiunJpDELhjDH1RILFiEDf9JiJLDF+87UkiL/4HINs8mDCS51BzmVPkADp5KOa5sKhIT\n", + "WxjVPepoMqZPZbuMGWaalyrtgSFXwLjFcLARbG+4Qp0FvSDDkFXBrhqaLeGdsyOotbdihgIuUKSh\n", + "itwQCyxTR31aPXlDHZ0lrgwGvhVXRqujn/lx+FkYwZ212bb/AlRa7bBbxnBHMXJqOmGqFv1FONQT\n", + "Rhi+YBuMHUGrc3YxuSJbh0CjebDiVI7xScWC5I7JHbbRaEcXWHA3XHI1fPAzpP9/e2ceJkV1LfDf\n", + "kVX2MQQEHBAZBAEVULaIMkZ0GFCTaMTgbgyaqIC+mAX1WVMhRoOJ4hI3NERiovKCOzCCIhqVRSKy\n", + "qwwIsmhQUVBBRDjvj1sNTdM93dP7zJzf98033VW3qs7tnjl166z7Eo2Cp4rPgp9VpWWy8TJnQtqP\n", + "PPS/VMnME4l6Oj+o718uvjRTTycmeOh+Zp6w8+0RX/4GXLJMNS+ejoIkrGOBt5I4POemHmu2blQL\n", + "lqlO/5jWqwFYVQoNt4btzUUFzLBG3a//GnbXg+8ft6Wy2jyB/2W/kMd0mCp6iAwtFSkfLjKnVKQ8\n", + "lQb34sshOFPL1FRkUk+X4mr6Xy++/DKB64aieQ5Q/AGTgRFBf4V8oCvwYZKZyxbVYxiJsptdm4Cj\n", + "WXRZxJ7sV8DcrzaPNjmY53bv4aqlPRmo22Idkwn/S8hhfN9BFO0RqL87ZYfxj4EX1NOtcUfGQT2t\n", + "COrnzwoyxr1Kci1CZp6V0Xaqp2vFlyXA6aR4U0oTSTl2UynXkE5sxW9UI8JW2XvJXQVM1WXTVaeX\n", + "qk4p1i1zvk9dvRh4VHwpiHXMMtXp01VLp6gWT1ctTdU+fZgw+pQeFHW7Cp7q6rZNhKL2zmGcDCmZ\n", + "eSIJ/AQnAWcAE4KVfTSimnkimARcmi7ZUiRZx25LXLmGnCZRmuI3qg3OgTt3DAwth+GvuN/zRudL\n", + "2Qb19DngOeDBoIx1xhBfRHwZ9vrVDLx9ANw7zUUKhUjGYSy+HA50A8rTJSdAUMH1ZJyyfFh82c/S\n", + "UJmZJ9yMdcotXMRuBgWVY3NNKhE9OTXzgJl6jGpGZRUw8yQ56lfAAlzviYcycYFQ+0GgoMPrvDf/\n", + "LXpF3mUiHcYJfjbnA1My0f5SPf1cfDkNeAp4XHw5P6yh/QDgs0gzT8iM9Zc6FNXfDeyEohVs+6gx\n", + "48hhGZjgxnUMsCiJw3Me0QO24jdikE6HYTYIKYkZUDIFBs2AkgFwZ7blDkI+fwLcIr4clc5ziy+9\n", + "xZcZuIbkDwLH8BY3Xh7HYZzIZxM8oaTVzBNJUL//DJzeeSbItgZn5pkSOb4QRj8gFA07D6Z1dtsm\n", + "vUmzPQWcm+knqjh0Az5QL7Y/pxJyHtEDpviNKOSLEq0KoTouX9WD4y+HCf3hTw1SsnUnjXq6ArgR\n", + "eCxIhkoJ8aWr+DIFeB5nSuqink5WT3cvU50+F8YMhfLh8MpQKJ8Ho8NX86HPZns92BOoyyh+gN5A\n", + "AyC8VWraCVb5w4HNuJr+LYhh328KDf88AHbUgxIXz8XAD4A61MWZWnJFsmYeMFOPka+EFMWd/eCF\n", + "IiipgOsqKLrm0/zKMA0nVJyu0S64ezrc1Q9+NwiaruIY8aVrlKSgTPMgcBpwK3BNnLFREV/aAx5w\n", + "JvAn4NJoXa/iJeyFPpuyYijYAWNfc9sj/AAXAI9Gi7pJdy8E9fRb8eUS4C5gHq4G0gHRPGs7Un/O\n", + "CfDmg1A3qD0lQKsVrF/Xn0twjYJyQbKlGsBMPUa+ElIUFy+Gy96CZa1g8EUw55cUiy/3iy8/FF+a\n", + "5VrOcEJ1XAQYsAEemwrL7gXdyQ5c5cgXxJdhlUSVpJVAgY4EzhJfhlXlWPGllfgyAWdD/hDorJ7+\n", + "MdlWh6HPZkE7OO7DfdtDfoDAZj0C14Rnf1n29kKYUQJTBrnfA+5025MnSG4bhevZ/B3xZb/SG+JL\n", + "0/+MoMNRM/moQ1hg6c9g9Z613Aycm46nqSRJdcVvit/IP0KKosXXcPZKmPgcfHAH9HqcN4H3gCuB\n", + "jeLLK+LLWPGlV7YUaiyiJUfd9AWrm01jNNABp9R84D3x5ZogrjyjBFUbL8BFssSNRBFfWogv44CV\n", + "uHtYN/X0xlTbG66Huy4TKt5qA8dvctsi/ACn4GzWe2sWBVFDLTni4BvpfmoRJ4yHji8FeycWQft0\n", + "mNAEaItLzvq3+HJE2L6799Sn/NPFXBZpxvpgpT6CuymemQYZqiawL/Vx2ddvJ3kKM/UY+Um0Cp8j\n", + "YfW2jdyqnk4Hbg8cc4OAIcBjQAvxZSYuFHBWetvxxSeB5KjJ4svfgf7AaOAm8eUx4O5MmoHU01fF\n", + "lweC65dE63QWfJajgOtwNvze6um6dMmwnO68c2jDb/Z8tWJP5x3Hbm3HytV72OotL+N18aUnMBbY\n", + "IL7cBRwOdAx+72Lou/XY/AR83hH21As7a1qypfvjSj9fJ75U4Lp5leAiZgYAvZepfkV0M9bfcHX6\n", + "D3AKZ5juwBr19Mskj88LU48pfuMAEskwDcog7+2+Jr50BEpwjrt7xZdVuJtAOTA/Gwkr8Wzdgfll\n", + "LjBXfGkL/BxnBlqMW/1Oz1ALynG4BtnXAeNDG4PV42U4R/AbwEmxMleTQXxpzKMdLqRe8U27Wxe3\n", + "YeNMtvDPgi3NRhxN6bQn4AsB1uHqyv8NeB/X2GYt8L56ulWktBymlhx49rRkS++N5lFP7w81dMF1\n", + "3Bocx7T1FHC3+NJWPd2UBlkSJRUzD+SJqUc0D7rViYiqai7Ds4w0Eii0AbingRLcCvIl3E3ghWSq\n", + "PmaKoPbLcGAM0AK4B5iUjpIFEdfpgHNGDsMV9hqBMz2tAm5QT5NJ/28AtGffCr1jxOvmTOr7Levm\n", + "N2bYlfDpkTAv8DPXKZnN/84cDJwHnK+eRrXZR+93/LPVqSbOBabBD4DTgiiokK9hKXAYcLp6+kqc\n", + "c0wEKtTTPyYrR1UJnt6WqadVyhYX6TGUg9qN5sZZp/H7U2exZ+Od6Ug8TFZ3muI3Mo74ciguwqUk\n", + "+L2Z4CYAvBrEvueUIC68P87kEjJfpcUMFEqeqtOEwnd702nN99i8pyHrgesrU26BImzHgQo99LoV\n", + "sBG3Ul8b/A5//RFl58yGKYMouRaWngeb+gDQnH5LB7Bg05s/pU+r5Ww4aD5jYyW7OeXfflSMvrtJ\n", + "Ib58D5ionnYP2zYO6Avchvv8Lw5Mi5Wd42GcLyQrikx8+Q9wtXqacNjr3ptnk3FF/OIYuG0zrvTI\n", + "3DEpf46m+I3qQFCkqjfuJjAEZ899jX03gvdy3TQ9zAx0ObDXDERZ9yHJtFocAHeO6EjR9afAjrpQ\n", + "8AY7Pl7Kj1d4lONsvrFW7O1wN8m1HKjU3wc2xjOhOVPNjP1MNU2Yxhmcvf2OxjsbdRkFG/8M1+yi\n", + "Yi6MyVams/hyB86+Xxa8HwQ8DvRSTz8SX/oDzwCj1NOodvzgZv0ucKF6Oj8LMjfAldhuGZg6Ezsu\n", + "9B20XuzKd98Xan09tFx1emlKMpniN/KZWCUDggSeU3A3gSHAt+y7CcxOMjsyLexnBvpG2vLqcfV4\n", + "88WW7AwFBMVftfXpJHObD6T/+y2g3wZothPWFsAr32Xn181RXDhjNKW+FhdpszPWuROaQxRTTV/a\n", + "bJ/PR43u7Af/aQuTn3Lbh0L5dNWUFFFCMjkzzzpgiHq6PCgF/TZwhXo6I2zcMTgf0k3q6cMxznU9\n", + "0F49/XkW5D4eeFg9PbZKx8nwOTBlEM3WQ8fZsPjiYM/wV1SnFKckU5K605y7RsaprNesuhXmVGBq\n", + "sILrhnsauBL4u/jyFvucxIsjna/pTi4KJ1C6fxdfHmVK77kc27kf13R0JpMZd4JOLAo1gTlAjj6L\n", + "n2HYh6c1OIted8+Gs1fAH06Cjp/BGe/BloYc9ObZ9FJPl8eTI6U5hJePDkw1rfm4HXD0d3bAz8Pc\n", + "lFnsBNYPl7S1PPjOJwJTw5U+gHq6RHwpxpV1bqae3hHlXJOBxeLLtepppstzJ+nYDZr2bCsMU/qQ\n", + "i3LiIUzxGxknlAn8TBeXgTlsVfRes4GJZ3nwExky+jjQPDxklLLufQ50PI7sJNKDdFbsVE9VyoZ/\n", + "TcU/oekm6DQTtE6wt8nB+62qC9ZAcRl03jKYNY0nnfj4V6+O/IZTAf40c985xx9CBfBX8WWgeror\n", + "XbJGlT+isF2pSDlw9AVL9h+XxU5gw9lXomEk0AnnZD4A9XRVRE1/P9wUqJ5uqHedrO38KnOHl8nn\n", + "GS7Ol6TiX38XjOx0oIM8N+XEwRK4jCwQygRu+g1cOwTOHAFrCuKvMNXT7erpDPV0jHraBRcp9AZO\n", + "caziqrWPcfKhRRS+DgeFTN1pSy6KIFi1fdEW3r4kbPuXO9xK/8EiSkfByL6wpRPcubkOk0867MNv\n", + "mBCt69bHn3Edrgn779Iva+VkqhNYIoSXYA6K2N0MjKjMpKWefoCr6f9D3IJgr2mjh8jQAbNp274L\n", + "x2ahrlRSpRrysZy4rfiNjBPKBP7++7D0Xrh9APQdCY2X0U58OTjRR3T19H3gfuB+8aU+s3rOp/Db\n", + "ngwdBVsL4fFngpGZaMVY2aqt269BYMMAeMWD7S33yhErJ2LFHp0uviwEFrUskW19ZjIoW+WkM9EJ\n", + "rAr0A74AVuPq9FyfSO6Cevpf8eVkYBrwkPhyuXq6uxBGP7mUQ9sPhk8aQcvt0Z8mU0V8ORiX77Ak\n", + "3tio8ldSTjwXmHPXyDjRbPzDC1j39EWs31VAO1wRs+eqGs2zX8RKnW9gd/1gT+rREtGvFz2sMVrk\n", + "TKJyfKdUbtjRnbJ191H3u0GcyEiyG2GTTcSX23GKvzkuXv8c9VR7iAxtC+OaQsedwDZYswVuivwM\n", + "xJcmwNPAFuCCc8qYOQUGbWvgHOchhsMrU1SL0yh3f+Be9bR3us6ZDpLVnWbqMTJOtNLBKz7jym8m\n", + "6Im4kMnxwPPiS1GcU0UQ1opxr9LPnO10v1aLOr1036N68i0h+5Zz4tVLqHvpDyF010uxdWLeEmbm\n", + "+RA4C7g8pPT7wkMzofdUKHgeCk6E446EiZEmm6BUwulAfeDpbcIu2F/pQ0b8FceRWsZuXpGy4heR\n", + "ISLyjoisEpHfxBhzV7B/sYj0SvWaRvUjVq9Z9fRFXCz/HGCe+DIurEFHpeSL7TQVOZpCw9/Phu31\n", + "4N2W+7ZnMcImm/TFKWQPuCAoYkchjP4rtJnUE/7d3g28GegObaPdAIOEv3OAT+f+iDY/gzXh+zPk\n", + "r0i1VENekZKNX0Tq4FLcB+MyCN8UkWdV99nsxN2xi1S1s4j0A+7DZUgaBgBBq7/bxJd/4urOrxBf\n", + "rgWejmf+yRfbabJyfAFf198NLz3iSlWGyGKETcYJ5XB0+AHdd8F3du7g6U9e0FdD+0PO/wa74aIf\n", + "QectMG421NkY+waonu4SXy7edgz3/J8wePXTdRbX3d2o/ZfU15W0/XwraS+5dDxO19UIUl3x9wUq\n", + "VHWtqu7Chdz9IGLMmbhWcajqfKCFiLRO8bpGDUQ93aiejgAuBX4PlIsvR+ZYrIwSirAJV/rZirDJ\n", + "BiH/zjShZM8RHPbCXA7+0Uz6hptwQs7/85bCu/e4nIdzhsM/zoN1h1Mv1rmDnI6rth3ScNGcKxsf\n", + "9WLTdwrm8ckhW1lyXDp6BoQQXxrjQk6XpeN8+UCqir8dEF5wa0OwLd6Yw1K8rlGDUU9fBnrisnff\n", + "EF9uCf75ahyJtE6szoRyOBa0g8bfQPfNMBE6hZtw1sNdF9Xnc4D6u+GK/8BP7oYG77PtzfPpKr48\n", + "Kb4cHe386qkysbg5i8bW59IToenGYE9aw3p7AstTzaLOJ1IN50w0CiPS65z7UCIjrwmSmm4Paubf\n", + "BqwUX34J/CvXtXzSTbxy0tWZkBmn3Tb4y/R9iiDchLO8jFc+WMG333+Odwp20GonsO1b1jAXT0uY\n", + "A/wCl8A1Byg7sHBe04a89lvY3AO2fzdse9rCemuUYxdSV/wbgcKw94W4FX1lYw4Ltu2HiJSFvZ2j\n", + "qnNSlM2oAainHwIXBEW87gEuF19Gp7NuvZE5Qmacwm3uJ0SED+PXX3Rj5uwn9PwYp/lzUA75alyz\n", + "lnLgd+ppRVAqw1X4fO/0iMPSVhLheKDSEtHZQkSKgeJUz5OqqWch0FlEDheR+sC5wLMRY54FLgIQ\n", + "kf7A56p6QCMCVS0L+5mTolxGDSMoX9wbeB73zz9efGmaY7GMOCzqz6IRzdmvJEW4DyNoKH818NvK\n", + "zqOefqme3orLBakA5snVDcop6P4XGNsSbog4Iq1hvXkT0aOqc8J1ZbLnSTmBS0RKgQm4rjkPq+ot\n", + "InJFIOQDwZh7cPVWvgIuVdW3Is5hCVxGwgT1/f+Iq+p5HX63bWj7jBRqM5JHfDkcWFD4BDf3WMmQ\n", + "aFnC4ss/cM1UvCqeu4CFhQvp9tURLD8XZg+GHYtwamj+J7D+4rQ0OnGLi4+AFpmuqZQMVpbZqHWI\n", + "LwPZcdAjfNyyDc/NPpiPQz090tPkwkieoInMHOAZ9fS2GGP6A/8CusRpsxj9GjJ8Do3uHcQJ46HN\n", + "WzD5xWBP6uWOw2Q8CRivnuZlCLqVZTZqHerpa1KnpILjzziCS4phyYXw0h/g233lknMtYy3mRmA7\n", + "8OdoO4NCaxOAsckofccXX7O9JcwaDxIet5/Wcsd5Y+ZJJ1aywaje7GnegAVXw73LYcchYaUbMlGo\n", + "zUgE8eVE4Apc68RYmVQjcHaZfyR/pbBSGRpSZWkv2VHjInrAVvxGtScol/xVK3j1xrDtuWtyUZsR\n", + "XwqAR4GRQURWtDGNgFtx5ZiTTrGN1mQmHf2AIazBzzWNTuJfR3eQsh6ba5Lp0BS/Uc3JvyYXtZXA\n", + "fPMgzq7/fCVDrwPeUE9fT/WamSjZsbexToM/FdGoHWx67QT4xZ3pbvCTS0zxG9WaTK76jCrzU6AL\n", + "cGGsAeJLO2A0zoSSpxSOholFtHkZPjoW9tTFLSxqjt/IFL9R7cmXQm21GfGlK858MyionhmLPwAP\n", + "qKfrsiNZMjRtCECzjfDBiWHba47fyBS/YRgpIb40AB4D/lc9XVHJuD7Aqbingjwm8BstuSBie83x\n", + "G1lUj2EYqXILsBZ4INaAsPDNG9TTL7IkV5Ik31inumArfsMwkkZ8GYJritIzTvG84bjCbI9kRbAU\n", + "qA1+I8vcNQwjKcSX1sAi4PyglHascQcDK4GL1NvXgMVIHeu5axhG1gj65/4NmFSZ0g+4FlhoSj9/\n", + "MFOPYRjJMAYoAMoqGyS+tAH+B9etz8gTTPEbhlElxJdewPVAvwQqVt4MPKSerokzzsgipvgNw0iY\n", + "oAXmY8A18ZS5+HIcUEreh2/WPszGbxhGVZgALFBPKy2uFoRv3oGL7d9W2Vgj+9exdvgAAAenSURB\n", + "VNiK3zCMhBBffgycDPRKYPhZQDNgUkaFMpLCwjkNw4hL0CJxIXC6erogztiGwArgsgQifowUsHBO\n", + "wzAygvhSB1dq+fZ4Sj9gDLDYlH7+YqYewzDicQOwCxgfb2DQD/lXQF62KjQcpvgNw4iJ+HICcCXQ\n", + "O8GmKeNwSV0VcUcaOcMUv2EYURFfWuBaI16unm5KYHxP4AwsfDPvMRu/YRgHEIRj3g9MU0+frXSs\n", + "9BgqMqScjQUvM7voU8q6n5AdKY1ksRW/YRjRuAToTpxSC3vbFHYdVkTdjfDaohY1rU1hTcRW/IZh\n", + "7If4ciTOkTtCPY3TfKRwNDxYxIl/gBduD2tT2H5UFkQ1ksRW/IZh7EV8qY8ryeCpp8viH9G0IQhM\n", + "fhF2NgvbXnPaFNZEbMVvGEY4NwMbgPsSGx60KdxP6UNNalNYEzHFbxgGAOLLacAIXMZtgin9Nb9N\n", + "YU3ESjYYhoH40grXTetC9XR2lY6VHkOdTb9mtinMZ5LVnUkrfhE5BHgC6IBrtDxcVT+PGFMITAZa\n", + "AQo8qKp3RTmXKX7DyBFB6ObzwBL1dGyu5TESJxe1en4LzFLVI4GXgveR7AKuVdXuuBTuq0TkqBSu\n", + "WS0RkeJcy5BJbH7VExd/X1rOk+3X83HjE7i16xu5lind1NTvLlVSUfxnAo8Erx8Bfhg5QFU/UtW3\n", + "g9df4hout03hmtWV4lwLkGGKcy1AhinOtQDpZm/8fetbS2jycTv+ubg5Xw+83W2vURTnWoB8JBXF\n", + "31pV/xu8/i/QurLBInI4ro73/BSuaRhGWigcDROLGHINVJTAZ52w+PvaQ6Vx/CIyCzg0yq4bwt+o\n", + "qopITGeBiDQB/gWMCVb+hmHklKYNAXjiKfj6jrDtFn9fG0jFufsOUKyqH4lIG+BlVe0aZVw9nONo\n", + "hqpOiHGu3IcWGYZhVEOSce6mkrn7LHAx8Mfg99ORA0REgIeBFbGUPiQnuGEYhpEcqYZzTgHaExbO\n", + "KSJtgYmqOkxEBgKvAktw4ZwAY1W1PGXJDcMwjKTIiwQuwzAMI3vkpGSDiBwiIrNE5D0RmSkiLaKM\n", + "KRSRl0VkuYgsE5HRuZC1KojIEBF5R0RWichvYoy5K9i/WER6ZVvGVIg3PxE5P5jXEhF5XUSOyYWc\n", + "yZDIdxeM6yMi34rIWdmUL1US/NssFpFFwf/bnCyLmBIJ/G22FJFyEXk7mN8lORAzKUTkryLyXxFZ\n", + "WsmYqukVVc36D67k66+D178Bbo0y5lCgZ/C6CfAucFQu5E1wTnWACuBwoB7wdqS8wFBgevC6HzAv\n", + "13KneX4DgObB6yHVZX6JzC1s3GxcsMLZuZY7zd9dC2A5cFjwvmWu5U7z/MqAW0JzAz4F6uZa9gTn\n", + "dyIuFH5pjP1V1iu5KtJWE5O/+gIVqrpWVXcBjwM/iBizd96qOh9oISKV5j/kEXHnp6pzVXVr8HY+\n", + "cFiWZUyWRL47gFG4sOSPsylcGkhkfucBU1V1A4CqfpJlGVMhkfl9CIRKiDYDPlXVb7MoY9Ko6r+B\n", + "zyoZUmW9kivFXxOTv9oB68Pebwi2xRtTXZRjIvML5zKguhTqijs3EWmHUyahcsXVyTmWyHfXGTgk\n", + "MK8uFJELsyZd6iQyv4lAdxHZBCwGxmRJtmxQZb2SsUYstTD5K1FFEBm6Wl0USMJyisjJwE+B6tJ7\n", + "NZG5TQB+G/y9Cgd+j/lMIvOrB/QGTgEaAXNFZJ6qrsqoZOkhkfldD7ytqsUi0gmYJSLHquoXGZYt\n", + "W1RJr2RM8avqqbH2BY6KQ3Vf8tfmGOPqAVOBR1X1gDyBPGMjUBj2vhB3561szGHBtupAIvMjcOhO\n", + "BIaoamWPp/lEInM7Dnjc6XxaAqUisku18kbkeUIi81sPfKKqO4AdIvIqcCxQHRR/IvP7Hq7JDKq6\n", + "WkTeB7oAC7MiYWapsl7JlaknlPwFKSZ/5RELgc4icriI1AfOxc0znGeBiwBEpD/weZjJK9+JOz8R\n", + "aQ88CVygqhVRzpGvxJ2bqh6hqh1VtSPuCfQX1UTpQ2J/m88AA0Wkjog0wjkJV2RZzmRJZH7vAIMB\n", + "Avt3F2BNVqXMHFXXKznyUh8CvAi8B8wEWgTb2wLTgtcDgT04D/2i4GdIrj3sceZVios+qsAlqgFc\n", + "AVwRNuaeYP9ioHeuZU7n/ICHcNESoe9rQa5lTud3FzZ2EnBWrmVO9/yA63CRPUuB0bmWOZ3zwz2l\n", + "PRf83y0Fzsu1zFWY22PAJuAb3JPZT1PVK5bAZRiGUcuwnruGYRi1DFP8hmEYtQxT/IZhGLUMU/yG\n", + "YRi1DFP8hmEYtQxT/IZhGLUMU/yGYRi1DFP8hmEYtQxT/IYRBRHxRWRM2Pubq0MzIMNIBMvcNYwo\n", + "iEgH4ElVPU5EDsKVF+mj1afwnGHEJGPVOQ2jOqOq60TkUxHpiSsv/pYpfaOmYIrfMGLzEHAprlHQ\n", + "X3Msi2GkDTP1GEYMgn4Qy3A9XTur/bMYNQRb8RtGDFR1l4jMBj4zpW/UJEzxG0YMAqduf+DHuZbF\n", + "MNKJhXMaRhREpBuu7eCLqro61/IYRjoxG79hGEYtw1b8hmEYtQxT/IZhGLUMU/yGYRi1DFP8hmEY\n", + "tQxT/IZhGLUMU/yGYRi1jP8H3BY7kBSPDXsAAAAASUVORK5CYII=\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, "output_type": "display_data" + } + ], + "source": [ + "\n", + "print sensorimotor_models['LWLR-BFGS']\n", + "sm_cls, sm_configs = sensorimotor_models['LWLR-COBYLA']\n", + "modelCOBYLA = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelCOBYLA)\n", + "inv_COBYLA = generateInvTest(environment, modelCOBYLA)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] }, { "data": { "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEZCAYAAABrUHmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XuYXFWZ7/HvLxfCTQhMlFuCYAREHmXQQVAU2hElRA0O\n", - "M17wgqijqIfLjDKKDkh0xBHPeUYEjx4GkGEGFbxPEAwi0oCISJQQLuESEOWuMqAQArm954+1Ktld\n", - "XVW9u+uyq7t/n+fpp2vvWrXrrX666q2917vWUkRgZmZWxpSqAzAzs/HDScPMzEpz0jAzs9KcNMzM\n", - "rDQnDTMzK81Jw8zMSnPSMOsASeslPa/qOMy6zUnDJh1J90p6StIT+efPkrbv0nMdIem2un2XN9n3\n", - "sUJ8j0javHD/30u6srC9XtIySSrs+6yk87rxOsxqnDRsMgrgDRHxrPyzVUQ83KXnuhp4gaS/AJA0\n", - "Ddgb2FTSrMK+/XPbminA8SMcewfgbYVtj9S1rnPSMMsknS/pI/n2Tvnb/Ifz9lxJjxba/pOkByXd\n", - "L+m9zY4ZEQ8A9wAH5V0vAW4BrgIOLOybAtxQexjwf4ATJG3dIuQvAJ+WNHW0r9VsrJw0bLJSg32D\n", - "wEC+fRDpw/7AwvbVAJLmAR8FDgZ2z79bubpwnAOBa4Br6/ZdFxHrCo9ZkuM5ocVxvw/8GTiqxWsy\n", - "6ygnDZuMBPxA0mP553t5/9XAK3M/watI3+QPyPcdRDo7AHgL8LWIuC0ingJOGeH5imcVr8rPc03d\n", - "vqvqHhPAp4Bja5exGlgPnAycLGn6CDGYdYSThk1GARwWEdvkn8MBIuJuYCXwl6QP8h8CD0ranfQB\n", - "X/tg3wG4r3C8343wfNcAL5Y0E9iPdFZxB7BD3ncAQ/szyPHcmmM4kSb9FRHxI+B+4Ohmbcw6yUnD\n", - "bKirgDcD0yPiwbx9FLANsDS3eQjYufCY4u1hIuIe4EHgA8Dv8tkJwHWkD/stgV80efgpwPuBnVo8\n", - "xT8DnwQ2b9HGrCOcNMyGugo4ho3f/Afz9jWxcR2BbwFHSdozl8WOdHkK0tnGRxh6RvGzvO+GiHim\n", - "0YPy2c9FtKikioirSJ3r78ZnG9ZlThpmQ11N+uZf+3C/FtissE1ELAZOB34K3Alcwcgf1lcBzyYl\n", - "ippr8r5hl6bqfIZ0FlF8jvrnOwnYdoTjmLVNVS7CJOlrwOuB30fEi5q0OQM4FHgKOCoibuxhiGZm\n", - "VlD1mcZ5wLxmd0qaDzw/InYjXQ/+aq8CMzOz4SpNGhFxDfBYiyYLgPNz2+uBmZK260VsZmY2XNVn\n", - "GiPZiaGljfcDsyuKxcxs0uv3pAHDR7m6OsTMrCLTqg5gBA8Acwrbs/O+ISQ5kZiZjUFEjGr6mX5P\n", - "GotINfIXStofeDwiHmnUcLQvvJ9IWhgRC6uOYyzGc+zg+Kvm+Ks1li/clSYNSd8kzekzS9J9pEFS\n", - "0wEi4qyIuFTSfEkrSNM7vKe6aM3MrNKkERFHlGhzTC9iMTOzkY2HjvDJYLDqANowWHUAbRqsOoA2\n", - "DVYdQJsGqw6gTYNVB9BrlY4I7xRJMZ77NMzMqjCWz06faZiZWWlOGmZmVpqThpmZleakYWZmpTlp\n", - "mJlZaU4aZmZWmpOGmZmV5qRhZmalOWmYmVlpThpmZlaak4aZmZXmpGFmZqU5aZiZWWlOGmZmVpqT\n", - "hpmZleakYWZmpTlpmJlZaZUmDUnzJN0u6S5JH29w/yxJiyUtlXSLpKMqCNPMzLLKlnuVNBW4AzgY\n", - "eAC4ATgiIpYX2iwEZkTEJyTNyu23i4i1dcfycq9mZqM03pZ7fRmwIiLujYg1wIXAYXVtHgK2yre3\n", - "Ah6tTxhmZtY7VSaNnYD7Ctv3531FZwN7SXoQuAk4vkexmZk1Jw0irUdaX3UovTatwucuc13sk8DS\n", - "iBiQNBe4XNLeEfFEfcN8KatmMCIGOxOmmVkmCVhL8Qu3dBMRe1cW0yhIGgAG2jlGlUnjAWBOYXsO\n", - "6Wyj6BXAqQARcbek3wB7AEvqDxYRC7sTppkZIK0GptftXT9eEgZA/jI9WNuWdMpoj1Hl5aklwG6S\n", - "dpG0CfBWYFFdm9tJHeVI2o6UMO7paZRmNrlJjyEFQxNGACcRMbWiqCpT2ZlGRKyVdAxwGTAVODci\n", - "lks6Ot9/FvA54DxJN5ES3Mci4n+qitnMJhHpSOA/gPrqopVEbNn7gPpDZSW3neSSWzPrKGkt6cts\n", - "0Voi6i9PjWtj+eyssk/DzKy/SKuATev2BjCVifANuwM8jYiZWa2EdnjCWEbEFCeMjXymYWaTV6MS\n", - "2mQ1ETMqiKjvOWmY2eTUvIR20lVEjYYvT5nZ5OIS2rb4TMPMJgeX0HaEk4aZTXyTpIS2F5w0zGzi\n", - "cgltx7lPw8wmHpfQdo3PNMxs4nAJbdc5aZjZxOAS2p7w5Skz6zuS5ktaLGkw/57forFLaHvIZxpm\n", - "1ldygvgS8PzC7rmSiIhLCw1dQlsBz3JrZn1F0mLgkAZ3LY6IQ3Mjl9B2wFg+O315ysx6qsSlp/qK\n", - "p5rNkFblS1HFhBHAFCeM3vDlKTPrmZKXnp6uf9wBwNVwUINDLhtPy61OBD7TMLNeOo6hCYO8fWxh\n", - "+wxgRW1jJXANwz6sVhMhJ4ze85mGmfVS80tPWURcKonb4Ye7g+ouuLuEtmI+0zCzUWvWL1Giv2LY\n", - "padsVeHgjwVcssfQhOES2j5R6ZmGpHnA6aROrXMi4rQGbQaAL5JqsP8YEQO9jNHMhmrRL7Ev8M4G\n", - "+4v9FWcAc+va3A2c6RLa8aGykltJU4E7gIOBB4AbgCMiYnmhzUzgWuCQiLhf0qyI+GODY7nk1qxH\n", - "WpTE/hGY1WD/E8AzwEPAg7ndIaQvgmuALwecjEtoe24sn51Vnmm8DFgREfcCSLoQOAxYXmjzduC7\n", - "EXE/QKOEYWY916xfotkH/LPyzyzgRaRLTQL4DnA4LKxr71lo+1iVfRo7AfcVtu/P+4p2A7aVdKWk\n", - "JZLe1bPozKyZZv0Sa0o+Xq8G1gGHk7JHITt4Fto+V+WZRpl/iunAS4DXAJsD10n6RUTcVd9Q0sLC\n", - "5mBEDHYiSDMbplm/xH8xvE9jmKeBTdjYcRHAEoh9I1yY02W5j3ignWNUmTQeAOYUtueQzjaK7iN1\n", - "fq8CVkm6GtgbGJY0ImJhl+I0s4JaSSxpbMVmpMqnM/P+G/L+11B3uWoQOJChyeLPwMy0eZlPLbov\n", - "f5kerG1LOmW0x6gysy8BdpO0i6RNgLcCi+ra/DfwSklTJW0O7Afc1uM4zSa9+lJagDwP1BdIeeBj\n", - "dftvrz3274H1bEwYkbd3YUPCSNVTNi5UdqYREWslHQNcRqqaODcilks6Ot9/VkTcnv8Rl5H+z86O\n", - "CCcNsw7LZbTHkTq5nwbOqJXJNimxPVDS/cCWwA6F/XPzWciDM+FFvyd9yNSSRQDnAu9PbZ8GbgU+\n", - "NWT2WutrnuXWbJJrkhRWAMfnS07NSmybWfwkvHZzmFq8FLUM+Mt0hWElhUta7b8CG6uxfHY6aZhN\n", - "ciNNRS5pkMaTBQ5zCXAoQ/stngG2gcVPO0n0nfE2TsPM+sNI80E1K7Hd4HXAj0jJovgJJFi2acTe\n", - "qxo/zMYhJw0zG2k+qEYlths8AjyboWcXSrPQzuhkkNYfSlVPSdpc0h7dDsbMKjFkKvJsQ0VTvqR0\n", - "PPBkscE3SNUpz2FjR/cqYApcJvibLsdsFRmxT0PSAuB/AzMiYhdJ+wCfjogFvQiwDPdpmLUnd4bX\n", - "xl3UJgd8kkIlVa3v402k6T+mMLQqag+GZJ4NHek9egk2Bt1a7nUhaXzEYwARcSPwvFFHZ2Z9KyIu\n", - "LYy72Bp4Kanz+xDgS5LmL4TlTwDfY+PMguuBc/J23alK/cJKNkGU6dNYExGPa+hSKOu7FI+ZVavh\n", - "ynpr4IfTCn3cAfwCeEXrY23W+m4bj8qcadwq6R3ANEm7SToT+HmX4zKzagyppFpJ+oZYTBjrIXaH\n", - "FSMkDCgurGQTRpmkcSywF6nc+puk6WL+oZtBmVnnlFhNr+hpgLNJs9BuxvBZaKdETFmROsYXA1eR\n", - "Buw9VHccTw0yQZXpCH9JRPy6R/GMiTvCzRobabR3ffvDpPnfg0tqndyQEsZqWD2jRQltXUe6R3uP\n", - "E10ZEZ5Hg24PfBu4KCJuGXOEXeKkYdZYidHeG+acegYOnF5Yl7s2sWDu+HQ11ATUleqpvCb3q0lL\n", - "NJ4l6WZJJ48tRDPrsaajvWtnIdfDIevhoFrCqCWLDzOkUsbVUAaUHNwXEQ9FxJeADwI3AZ/qalRm\n", - "1ilNR3v/LZy0Dp6/L0MvRd0P66YC/2/4Y1wNZSOX3Ep6IfAW4O+AR4GLgI90OS4za0PhstOOwFOk\n", - "lS9r7l4Dr51aNwvtWtKKeqRil20aHNbVUFZqnMbXgAuBQyLigS7HY2ZtatL5/RRw9yrYbQbMLSaL\n", - "YONgvewe0gC/+uVcXQ1lnhrdbKJp1Pn9QeD/svF6dO1dfwFw5NCHP0RabA9cDTXhdXRqdEnfjog3\n", - "S7q5wd0RES8edYRm1gtDOr/XsnGeqJrVsHrTDVejhnigkBycJGyYVpenjs+/38DQ/zcYMtbHzHqh\n", - "1ZKsdZ6G1DGxJcOmLF9PxNRNmy+stLLTcdvE0rR6KiIezDc/HBH3Fn9I1Xhm1iOFfopDqJtIsL7t\n", - "7+Dl69mYMGoltP8FZxNR674YaQ0Ns4bKlNy+rsG+VtMQlCZpnqTbJd0l6eMt2u0raa2kwzvxvGbj\n", - "UMOJBCmMnfiG9C/rpZgNWxXPLm6G1VPh9UdGfKDw2JZraJg106pP40OkM4q5df0azwKubfeJJU0F\n", - "vgwcDDwA3CBpUUQsb9DuNNI8N+7stglrhMtPLZdkXSutPWJ4CW1sAm+IiEvrryfn9THAnd02Sq36\n", - "NL5BWvb388DH2fiB/UREPNqB534ZsCJf7kLShcBhwPK6dseS1nzZtwPPadaXmpTJzpVUWzmv4eWk\n", - "r8CrkKL2Rq4roRXp/dMwEeTjOknYqLTq0/hT/kD/EvBYoT9jjaT9OvDcOwH3Fbbvz/s2kLQTKZF8\n", - "tRZWB57XrB+NdPlpyOWkuaSBFx/M7+FasjiOYWMuPIrbOqrM4L6vAi8pbK8kzTCwT5vPXSYBnA6c\n", - "GBGhdC7d9PKUpIWFzcGIGGwvPLOeann5qXY5aTocexfM25mhVVF3kZZbbcAd27aBpAFgoJ1jlEka\n", - "RMT6wu11uZ+hXQ8Acwrbc0hnG0UvBS7M115nAYdKWhMRixrEuLADMZlVpVk104vyYL0zAn4ATK+7\n", - "f/0UuIbG5bNP445tK8hfpgdr25JOGe0xylRP/UbScZKmS9pE0vGkaQbatQTYTdIukjYB3goMSQYR\n", - "8byI2DUidiX1a3yoUcIwmwAaVTMBbPv7NAvtJTE0YQRwUi6hbZZwbnXHtnVamaTxQeAA0pnB/cD+\n", - "wAdaPqKEiFgLHANcBtxGWqtjuaSjJR3d7vHNxpP84V5bDe8xgL8mrZ43i2HXZVcSMYWIU/N2s/JZ\n", - "z0ZtHee5p8z6SK6iumANbDOVof0Wa2Ht9Ij6y1O1x3wG2DU/5B7gUz7LsJF0ZREmSXtIukLSrXn7\n", - "xZJOGmuQZtaYpPmr4LvrYZtpDB3NPQXYBH7S6DGkCseXAtuSpjTfundR22RT5vLU2cAngdV5+2bg\n", - "iK5FZDbOSZovabGkwfx75BkUpMF1cMkM2LSWLIKUJXLVyVPALxo8csSR4madVKZ6avOIuD5XMJHL\n", - "X9d0Nyyz8anEIL1hDyBPRFuctnw1w2pwNwfeKemGuuO0LNU167QyZxp/kLThDSDp70hz7pvZcOW/\n", - "+Uur2Xj1iSB1fE+haSZodBxPPGg9VSZpHAOcBewh6UHgH4EPdTUqsz5V4tLTyN/8pceQgroS2h/D\n", - "v09rXHbb+DiJJx60nmo1YeHxEfElYIeIeI2kLYEpEfHn3oVn1j9KXnpq/s1fOhL4D4bPbLCSiC0P\n", - "SU8yn3Q2sR8l1un2xIPWa01LbiXdFBF7S7oxItqdMqSrXHJrvdBoGdVsSUTsm9s0Six3r4Fdpg2b\n", - "Foq1NCihbXUc4DgnBOuUji73Ctwm6S5gpwZLvnq5V5uMml162kvS/Ii4tP6b/yrYbwbMrXtXpolo\n", - "WwyS8hmE9auWg/skbU8asb2AulPq2pTm/cBnGtYLLc40ABZHxKGFxoPAgQy/FLWMiL27EqDZKHX0\n", - "TEPSFbkv47KI+G374Zn1txJrcJ9BSgSNylk3qx2EXEJbd/9qImZ0OmazXmt1eWoHSQcAC/ICSbUx\n", - "RwBExK+7HZxZr5Tp5M6XjJYzdKmAmlW5hHbYLLSFdbnNxr1WHeFvBt5HmqxwSf39EfHq7oZWni9P\n", - "WbtaXHoactmpUXI5HNZdBFPrvoEFcHJhUkGzvtPRy1MR8W3g25I+FRGfaTs6s/5WamR1sYN6d3ju\n", - "IOy5fWFt7mwlEVt2I0izqpWZRuSzkt4F7BoRn5G0M7B9RPyyy7GZ9VLpkdURcSnSIkZRQms2UZQZ\n", - "Ef4V4OXA2/P2k3mf2URSbmS1tCqP5i4mjACmOGHYZFDmTGO/iNhH0o0AEfE/kvzmsAllxHERLqE1\n", - "A8oljdXFNcElPZs0yZrZhJITxNDBcy6hNRuizOWpM4HvA8+R9DngWuBfuxqVWQeNaX2L9MAhs9Bm\n", - "64mQE4ZNViOeaUTEBZJ+Bbwm7zosIpZ3Nyyzzhj1+hbpQY8BM+v2uoTWjIrXCJc0Dzid1Kl4TkSc\n", - "Vnf/O4CPka4jPwF8KCKWNTiOx2lMcCVGazd7XKnxF7lxy1loxxC2WV/r9ISFXZX7Sb4MHAw8ANwg\n", - "aVHdWcw9wIER8aecYP4d2L/30VqVxnS2sFG5le2ktbiE1mxEZfo0uuVlwIqIuDci1gAXAocVG0TE\n", - "dRHxp7x5PTC7xzFaf2hnHezW4y9cQms2KqWThqRNJXWy828n4L7C9v15XzPvo76yxSaLdtbBbjj+\n", - "Yhk8B2l9g2MvI2JKq2nLzSazVrPcTgHeBBwBvIKUYCRpHXAd8HXgBzH2N1fpx0l6NfBe0jxYzdos\n", - "LGwORsTgGOOy/jPmdbDrx1/MhlX3wuumuoTWJiFJA8BAW8doMWHh1cA1wCJgaUQ8k/fPAPYhrbHx\n", - "yog4cExPLO0PLIyIeXn7E8D6Bp3hLwa+B8yLiIbrJ7sjfGLr2Cp2noXWbIixfHa2ShozaomixROO\n", - "2KbFY6cBd5BKeR8EfgkcUewIz/Nc/RR4Z0T8osWxnDQmOG1cO3szYAvSmcITlKmkcgmtWUMdTRqF\n", - "g/4bcG5E3NpOcE2OfSgbS27PjYh/lXQ0QEScJekc4G+A3+WHrImIlzU4jpPGJNHkrGMFcPywxOES\n", - "WrOWupU03g8cRTqt/xrwzUJFU19w0pg8So+7qCuhDWAtrN0kDU51QYUZY/vsHLF6KiLOjogDgCOB\n", - "XYCbJX0jd06b9VrrSqq6Etpg4zwgm6TCjy+VnkbEzIYpVXKbB+K9ANgT+ANwE/ARSRd1MTazRhpW\n", - "Ul0Ku9aX0AbpH7Wul7vs+A4za2DEEeGSvgi8kdQhfWph8aXTJN3RzeDMGjgDmEuhTyNPQbtzXbvV\n", - "U1Jp+EENjlFmfIeZNVBmGpFlwEkRsbLBfft1OB6zlorjLlbDwdNgWt0F2Y0ltKn/o5ERx3eYWWNl\n", - "+jTOKyYMSTvWRoZHxOPdDM6skYCvB8ybPjRhBHBS3ZiLcqvxmVlpo57lVtIVpMsD34mIE7oS1Si5\n", - "emqSGEMJbd34jqGr8ZlNcl0puW3yRFOAPbsxdmMsnDQmAc9Ca9ZxXSm5lXRwg93v6peEYROcZ6E1\n", - "6ytlSm5PkfRVSVtI2l7SxaR5p8y6Rxr0LLRm/adM9dRBwEdJJe8BnBIR3+hqVDZ5pdKoXEU7hGeh\n", - "NesDZc40tgH2JVWdrAZ2Vq55NGtG0nxJiyUN5t8jj8JOs9DWBnATwDpAcJXgSo/kNqtemaRxHXBZ\n", - "RBxCSh47Add2NSob1wqTCh5COlM9hAbTd9QSy83Sn0OKKExbvh7iTfBwPhVuegwz660yExY+NyJ+\n", - "W7fvoIi4qquRjYKrp/pLmUkFJc0/CM76KcwWqYa29p8oWCn42UjHMLP2dLR6StJcgPqEkfddVWxj\n", - "VmfE5VnXwA+vhNlT2JgwckfG4jzmop0lXs2sS1p1hH9O0haklfuWAA+R3t87AH9FqqB6Anhbt4O0\n", - "caf58qzSKmDT2j9e5J9CPW0tKYx5iVcz656mZxoR8VbgH4DnAKcCVwA/AT4LzAKOjQgnDGtk2PQd\n", - "n4Y/rUuXmzaFjcniKwwbsVdLCtcBT9Ud11OAmFWsZcltXpP7sz2KxSaI4qSCs2Czh+GgKbB18cLp\n", - "ali9aVqRsX7d7zNzZ/c7gc0L963PP2ZWoVLTiEg6AHguhSQTEf/ZxbhGxR3hfSqV0NaP2t4wC22z\n", - "eaFadKRDs6VdzWzUurXc6wXA84ClpLJ5ACKibxaycdLoM9JjwMy6vQGcTMSpIz9cgzReB6PGFVRm\n", - "HTCWz84yI8JfCrwwujBtg6R5wOmky9rnRMRpDdqcARxKur59VETc2Ok4rEPGMAttE806wWtcQWVW\n", - "kTJJ4xZSxdSDnXzivITsl4GDgQeAGyQtiojlhTbzgedHxG6S9gO+CuzfyTisQzo7C+2w1fnquILK\n", - "rCJlksazgdsk/RJ4Ju+LiGh30sKXASsi4l4ASRcChwHLC20WAOfnJ7xe0kxJ20XEI20+t3VKLqGt\n", - "25uqaMd4dlroSP8M8EKGnlm4gsqsQmWSxsIuPfdOwH2F7fsZvnxsozazASeNqqV+hwMZfilqGRF7\n", - "t3v43NF9qRdRMusvIyaNiBjs0nOX/RZa/6HU8HGSFhY2B7sY9+TW41loa8mj08c1m4wkDQAD7Rxj\n", - "xKQh6eWka8x7AjNI162fjIit2nliUj/GnML2HNKZRKs2s/O+YSJiYZvx2EhGKKE1s/6Wv0wP1rYl\n", - "nTLaY5SZ5fbLwNuBu0jXrt9HGsjbriXAbpJ2kbQJ8FbSlCVFi4AjASTtDzzu/owKSI/l1fOKCSOA\n", - "k5wwzCaXMn0aRMRdkqZGxDrgPElLgRPbeeKIWCvpGOAy0tnLuRGxXNLR+f6zcofofEkrgJXAe9p5\n", - "ThulzpXQmtkEUWZw39XAa4FzSJMWPgy8OzrQ2dkpHtzXBZ0toTWzPtTRqdELjsztjiENsJsN/O3o\n", - "w7NxQVqVL0UVE0YAU5wwzKzs3FObA3Mi4o7uhzR6PtPogC6X0JpZ/+nKmYakBcCNpL4HJO0jqb7D\n", - "2sYrSUjrSHM9DZ2INkJE7D2m9b7NbEIqO7hvP+BKgIi4UdLzuhmU9UiJEtrCet/FKT3mSsKD7Mwm\n", - "nzJ9Gmsi4vG6fV7XYDwbXQntcQyfA+r5pFHaZjbJlDnTuFXSO4BpknYjfYj8vLthWVeMrYTWa3Wb\n", - "2QZlzjSOBfYiTVb4TeDPpGVgbTxJJbTnMzRhrM39Fq3GXHitbjPboFT1VL9z9VQLbc5C26RP427g\n", - "OPdpmI1vXVmESdK+wCeBXQrtIyJePOoIrXc6VEJbXO8bzzRrNumVGRF+J3ACaTGmDR3gtXUw+oHP\n", - "NAp6PAutmY1f3Vru9Q8R4XEZ44FnoTWzLitzpvE60gy0PwFW590REd/rcmylTcQzjdyXcBypP+Jp\n", - "4Iyml4Skx4CZdXsDOJmIU7sZp5mNX90603g3sEduWxyf0TdJY6IpPaDOs9CaWY+VOdO4A3hB9HGZ\n", - "1UQ705C0GDikwV2LI+LQ3Miz0JpZW7o1y+3PgReOLSQbo+YD6jwLrZlVqEzSeDmwVNKdkm7OP8u6\n", - "HdgkN2xA3d8D69KkgvUJZRkRU8qMuTAza1eZPo15XY/C6p0BzCX3adTqZ+vOIV1Ca2Y95xHhfUrS\n", - "/Cfgh1uA6l6YS2jNrCO61adhvSY9FnDJlkMTRrNZaM3MeqaypCFpW0mX576SH0uqH2eApDmSrpR0\n", - "q6RbJB1XRaw9Ix2JtJ7hYy5W5n6LU7uxIJIXWTKzssr0aXTLicDlEfEFSR/P2yfWtVkD/GNELJW0\n", - "JfArSZdHxPJeB9t1JUpou7EgkhdZMrPRqPLy1ALSVN3k32+qbxARD0fE0nz7SWA5sGPPIuyF0ZXQ\n", - "dmNBJC+yZGalVZk0touIR/LtR4DtWjWWtAuwD3B9d8PqEWkwX4oaTQltNxZE8iJLZlZaVy9PSboc\n", - "2L7BXf9c3IiIUPq23ew4WwLfAY7PZxyN2iwsbA5GxOCoA+6F9mah7caCSF5kyWySkDQADLR1jKpK\n", - "biXdDgxExMOSdgCujIgXNGg3Hfgh8KOIOL3JscZHyW2bs9B2Y0EkL7JkNnl1a8LCbllEmgzxtPz7\n", - "B/UNlL6Vnwvc1ixhjAsdmoW2GwsieZElMxuNKs80tgW+BewM3Au8JSIel7QjcHZEvF7SK4GrgWWk\n", - "D1mAT0TE4rpj9eeZhmehNbM+NpbPTo8I7xbPQmtmfW68XZ6amKRVDK9ISiW1EyFDm9mk5mlEOmVs\n", - "JbQlDuvR2mbWP3ym0a72SmhHOrRHa5tZX/GZRjtSCe16hv4d1xOhDk1b7tHaZtZXnDTGQnosT/1R\n", - "7NTuxiy0Hq1tZn3Fl6dGo/cltB6tbWZ9xUmjrGpKaIes4JfdDZzZxec0M2vKSWMkFZbQerS2mfUb\n", - "D+5rftBB4ECGX4paRsTeHX0uM7MKeHBfJ3SxhNbMbLxz0ihqcxZaM7OJziW30MsSWjOzcW1yn2l4\n", - "Flozs1GZvEnDs9CamY3a5EsanoXWzGzMJk+fRpdmoTUzm0wm/pmGS2jNzDpmYicNl9CamXVUJZen\n", - "JG0r6XJJd0r6saSZLdpOlXSjpItH8QQuoTUz64Kq+jROBC6PiN2BK/J2M8cDt5E+9FuTjsz9FvVJ\n", - "aGXutzh1jPGamRnVJY0FwPn59vnAmxo1kjQbmA+cw/CxFPWN1+ZjFdutzQsiecyFmVkHVJU0touI\n", - "R/LtR4DtmrT7IvBPpNXxRlK87BTAlGZjLrzutpnZ2HStI1zS5cD2De765+JGRIRS/0P9498A/D4i\n", - "bpQ0MIqnbjkLrdfdNjMbu64ljYh4bbP7JD0iafuIeFjSDsDvGzR7BbAgf8hvCmwl6T8j4shGx/wU\n", - "rPsX+GyDdiCFAAALVElEQVR+goGIGGzy9K3W3XbSMLMJK38BH2jrGFWMaZP0BeDRiDhN0onAzIho\n", - "2hku6SDghIh4Y5P7S88Jr7ROxkEN7roqIgbKHMPMbCIYy3oaVfVpfB54raQ7gb/O20jaUdIlTR7T\n", - "qezWbN3tvdy3YWbW2qRbua9Jn0bNCuB4922Y2WQwns40KpMTwvHAHxvcXevbMDOzBiZd0oANiePW\n", - "Jndv1stYzMzGk0mZNLJmfRurehqFmdk4MpmTxhmkPoyiu4EzK4jFzGxcmNiz3LYQEZemWdM5lnRJ\n", - "ahVwpjvBzcyam3TVU2Zmlrh6yszMuspJw8zMSnPSMDOz0pw0zMysNCcNMzMrzUnDzMxKc9IwM7PS\n", - "nDTMzKw0Jw0zMyvNScPMzEpz0jAzs9KcNMzMrDQnDTMzK62SpCFpW0mXS7pT0o8lzWzSbqak70ha\n", - "Luk2Sfv3OlYzM9uoqjONE4HLI2J34Iq83ciXgEsjYk/gxcDyHsXXU5IGqo5hrMZz7OD4q+b4x5+q\n", - "ksYC4Px8+3zgTfUNJG0NvCoivgYQEWsj4k+9C7GnBqoOoA0DVQfQpoGqA2jTQNUBtGmg6gDaNFB1\n", - "AL1WVdLYLiIeybcfAbZr0GZX4A+SzpP0a0lnS9q8dyGamVm9riWN3Gdxc4OfBcV2kZYObLR84DTg\n", - "JcBXIuIlwEqaX8YyM7MeqGS5V0m3AwMR8bCkHYArI+IFdW22B66LiF3z9iuBEyPiDQ2ON/7XrDUz\n", - "q8Bol3ud1q1ARrAIeDdwWv79g/oGOaHcJ2n3iLgTOBi4tdHBvD64mVlvVHWmsS3wLWBn4F7gLRHx\n", - "uKQdgbMj4vW53d7AOcAmwN3AeyZwZ7iZWd+rJGmYmdn4NC5HhJcdHJjbTpV0o6SLexljK2XilzRH\n", - "0pWSbpV0i6Tjqoi1EM88SbdLukvSx5u0OSPff5OkfXodYysjxS/pHTnuZZKulfTiKuJspszfP7fb\n", - "V9JaSYf3Mr6RlPz/Gcjv1VskDfY4xKZK/O/MkrRY0tIc+1EVhNmUpK9JekTSzS3alH/vRsS4+wG+\n", - "AHws3/448PkWbT8CfB1YVHXco4kf2B74y3x7S+AOYM+K4p0KrAB2AaYDS+tjAeaTBmIC7Af8ouq/\n", - "8yjjfzmwdb49b7zFX2j3U+CHwN9WHfco//4zSX2Ws/P2rKrjHkXsC4F/rcUNPApMqzr2QnyvAvYB\n", - "bm5y/6jeu+PyTIMSgwMBJM0m/UHOAfqps3zE+CPi4YhYmm8/SRoNv2PPIhzqZcCKiLg3ItYAFwKH\n", - "1bXZ8Joi4npgpqRG42+qMGL8EXFdbOwvux6Y3eMYWynz9wc4FvgO8IdeBldCmfjfDnw3Iu4HiIg/\n", - "9jjGZsrE/hCwVb69FfBoRKztYYwtRcQ1wGMtmozqvTtek0aZwYEAXwT+CVjfk6jKKxs/AJJ2IX1T\n", - "uL67YTW1E3BfYfv+vG+kNv3ywVsm/qL3AZd2NaLRGTF+STuRPsy+mnf1U2dlmb//bsC2+ZLsEknv\n", - "6ll0rZWJ/WxgL0kPAjcBx/cotk4Z1Xu3qpLbEUm6nHSJpt4/FzciIhqN05D0BuD3EXFjFfPDtBt/\n", - "4Thbkr49Hp/POKpQ9gOo/myuXz64Ssch6dXAe4EDuhfOqJWJ/3TSOKaQJPrrzLpM/NNJg3lfA2wO\n", - "XCfpFxFxV1cjG1mZ2D8JLI2IAUlzgcsl7R0RT3Q5tk4q/d7t26QREa9tdl/u1Nk+Ng4O/H2DZq8A\n", - "FkiaD2wKbCXpPyPiyC6FPEQH4kfSdOC7wAURMWwsSw89AMwpbM8hfRtp1WZ23tcPysRP7vw+G5gX\n", - "Ea1O53utTPwvBS5M+YJZwKGS1kTEot6E2FKZ+O8D/hgRq4BVkq4G9gaqThplYn8FcCpARNwt6TfA\n", - "HsCSnkTYvlG9d8fr5ana4EBoPjjwkxExJ9KI8rcBP+1VwihhxPjzt8Vzgdsi4vQextbIEmA3SbtI\n", - "2gR4K+k1FC0CjgRQmsL+8cIluKqNGL+knYHvAe+MiBUVxNjKiPFHxPMiYtf8//4d4EN9kjCg3P/P\n", - "fwOvzNWOm5M6ZG/rcZyNlIn9dtLgY3JfwB7APT2Nsj2je+9W3bM/xmqAbYGfAHcCPwZm5v07Apc0\n", - "aH8Q/VU9NWL8wCtJfTFLgRvzz7wKYz6UVMG1AvhE3nc0cHShzZfz/TcBL6n67zya+EnFEo8W/ta/\n", - "rDrm0f79C23PAw6vOuYx/P+cQKqguhk4ruqYR/G/Mwu4OP/f3wy8veqY6+L/JvAgsJp0Rvfedt67\n", - "HtxnZmaljdfLU2ZmVgEnDTMzK81Jw8zMSnPSMDOz0pw0zMysNCcNMzMrzUnDLJN0UZ4Gop1jzJB0\n", - "taSuv7fyVOIX59tvHGHK9K0lfaiwvaOkb3c7Rpt4nDTMAEnPB7aIiLvbOU5EPANcQ5OZl0vGMur3\n", - "ZURcHBGntWiyDfDhQvsHI+LNY4nPJjcnDes7ecqG2yWdJ+kOSV+X9Lq8ONKdkvbN7bbIC8xcL+nX\n", - "khYUHn+1pF/ln5fn/QOSBiV9W9JySRcUnvZt5OkhJD03P89fSJoi6RpJB9fF+B5JXyxsv1/Sv+XN\n", - "RcARLV7XBZJuy3Fslu+7V9LnJf0KeHN+vT/P8X9L0ha53bwc+6+Avykc+yhJZ+bb20n6vtKiQEvz\n", - "6/88MFdpkaPT8mu8JbffNP+tl+W/40DhmN+T9KP892iVlGyyqHqIu3/8U/9DWvBmDbAXafbNJcC5\n", - "+b4FwPfz7c8B78i3Z5Kmetgc2AyYkffvBtyQbw8Aj5OmaxHwc+CAfN+PKEyfQJoe/VukqfW/2iDG\n", - "LUjTLkzN29cCe+XbM4AHmryu9cDL8/a5wEfz7d8AJ+Tbs4CrgM3y9seBk0kTb/4OmJv3X0SeHgc4\n", - "CjizsP+4fHsKaY2H51JYhCfHcnO+/VHgnHx7D+C3+TUcBdwNPCtv3wvsVPX/h3+q/fGZhvWr30TE\n", - "rRERpPmIfpL330L6wAN4HXCipBuBK0kfbHOATYBzJC0jffDvWTjuLyNdmgnSvF7PzfufS1pMB4CI\n", - "OBfYmjRHzwn1wUXEStIqeW+U9AJgekTcmu97BpgiadMGr+u+iLgu376ANMdYzUX59/7AC4Gf59d2\n", - "JLAz6QP9N7HxEtoFNJ4C/dXkdTUiYn1E/LlJu5oD8rGIiDtISWN30vTYV0TEE/k13cbGv71NUn07\n", - "NbpNes8Ubq8nTbZWu138vz086tZckLQQeCgi3iVpKvB0k+OuqzvWhg/WPNPqbNIH57OAlQ1iPIe0\n", - "Pspy4Gt194nGaxJEizbF57g8It4+5IDS3g2eo5nRrqfRrH3932vqKI9rE4zPNGw8uww4rrYhaZ98\n", - "cyvg4Xz7SMp90P0W2KGwfRrwX8AppDU2as9xhaQdASLil6TE8nbSTKK1NjOAdfnbeb2d8/TT5Mdd\n", - "06DN9cABtUqu3HezG2kK7l0kPS+3G9Zvkl0BfCg/dqqkrYAnSMmvkWuAd+T2u5POam6ncSLpp8Wd\n", - "rAJOGtav6r+lR4Pb/wJMzx24twCfzvu/Arxb0lLSJZ0nGzy23s+AvwKQdBBpUaPTIuIbwGpJ785V\n", - "TXNJU6jXfAv4WWxcXxzS0rzX0dgdwP+SdBvp8tew5Vkj4g+k/oRvSrqJ1PeyR05CHwAuyR3hjxQe\n", - "F4XbxwOvzpfnlgB7RsSjwLWSbs4d2sX2XyFdTltGWgP73ZHWwy622RBek9dlk4SnRjcD8rf3MyPi\n", - "9S3a7AW8JyJOKOy7GPi3iLiysO9zpM7379c9fhfg4oh4UYfDN+sZn2mYARFxD/BEq8F9uWP+BABJ\n", - "MyXdATxVlzBmkDq3my3P629pNq75TMPMzErzmYaZmZXmpGFmZqU5aZiZWWlOGmZmVpqThpmZleak\n", - "YWZmpf1/HOhEFZUoXMwAAAAASUVORK5CYII=\n" + "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJztnXu8HFWV778rIUDCG2MQwlMSFVACOgZGQKJ4JUSFGRW5\n", + "qODrCqMDCTqOoBcl+Bx0rgzoDAKCSBAiKM6AYhgVEhkFhBmICGEmCc88iBACggEhsO4fe3dSp9LV\n", + "Xd2n69F9ft/P53xOV9euqlW7q/baa6+19zJ3RwghhGgwqmoBhBBC1AspBiGEEEOQYhBCCDEEKQYh\n", + "hBBDkGIQQggxBCkGIYQQQ5BiGGDM7Ckz273E6802szllXa+fMbMvmdmjZraiwGuMNbNrzewJM/tB\n", + "kdc1s8+Y2YW9PGevMbMPmtlNFV17dzN70cxGxe3rzOy4Eq7b1TvZF4rBzB4ws8MquvYrzOyq+DI9\n", + "YWYLzewTjR+4zrj7Vu7+QJmX7PbAkaRUzGxX4JPAq9x9pwIv9W5gArC9ux/Tq+ua2TQzezj5nbt/\n", + "1d0/OjxxRw7uPsPd2z7vse1783Au1c1BtW/cIs4wGp1uMbM9gVuBB4FXu/u2wNHA64CtypYnL2a2\n", + "SVWXrui6/cauwGp3X13wdXYD/sfdXyz5ugOPmY0u6VJOFe+Vu9f+D7gfeHP8/EHgP4CvA48D9wHT\n", + "475jgNtSx34C+Lcur3sZcG2bMkcCdwNrgBsJvbHGvgeATwG/A54CLgJ2AH4GPAn8HNg2lt0deBH4\n", + "KLAcWAH8XeJcU4Gb43VWAN8ExiT2vwh8HFgMLE189/L4eUaU84/AstS5PxqPWw38G7Bj6rwnAv8T\n", + "r/2tFnVxBnAVMDde5z+BfRP7dwJ+BPwh/m4nx++nA38Gnov1dAcwDbgrcezPgd8mtm8Cjmx13rjP\n", + "gNOAJcBjwA+A7VJ1fjxB+T8KfDbj3jaNcp0Ut0cDvwZOzyi/DXBplOkB4P9GWd4CrAVeiPd6cZNj\n", + "xwM/ifW9GvgVYBnXeVWsm9XAvcDR8fszU3V6QrPrAgcCv4nXuhM4NHHu7YHvEp7Hx4GrgXHAM4nz\n", + "/BHYEZgNzInH/Qz425ScC4G/aiVzxv19CLgnXmcpcEJi3zTCs/xJYBXhvfhgYv9LgGsI79qtwBeB\n", + "mzKu03gWst6/2cAPgTnxfB+Ov/FFseyyeP5Rsfwo4B/jM7UU+Nt4/sb++cBHUu9g4z7vBvaP13oh\n", + "/m5PAZ/K8ZvtASyI5/l3Qjsxp+O2r5sGs+w/NlYMzwEfIbxofwMsj/vGxQqZlDj2NuA9XV53JfCB\n", + "FvtfATwNHEZoKP6e0MBukpD7N8BLCY3XKuC/gCnAZsAvgc+nHszvA2OBVxMalcPi/tcSlMMoQk/w\n", + "HmBWQpYXgeuBbYHNEt+9PHEvB/mGRmv/+PnN8eHdj9D4nQssSJ33GmBrYJco0+EZ9TE7/jbvjPXx\n", + "d4SGenSU+z+B04FN4gO8FHhrPPYM4NLEucYSGqDtgTGx7h4Gtoj71gLb5TjvrPgb7BTP823g8lSd\n", + "nx9/j32BZ0ko99T97UNoIF9FaOh/Q3aDfSnw4yjvbsB/Ax+O+w4FHm7xXH0VOC/W2+jG79ak3Bax\n", + "Tj4Q62G/+FvulVGnQ64LTCQoy0bH6i1x+yVx+6fAFfF52QQ4JEv+5LWA44D/SOzbm9CIjWknc5N7\n", + "nAHsET+/EfgTG57dacDzhOduNHBE3L9N3D83/o2Nv90y4FcZ12k8C1nv32zCs93ojGwef9/zYvmX\n", + "EpTPCXH/3wCLYh1vR+g0vsAGxXBj4nk4Osr2uri9J7Bruu3L+ZvdTFBIY4BDCO3hpc3uuWXb102D\n", + "WfYfGyuGxYl94+IPOiFuzwE+Fz9PjhWzeZfXfY7YwGTs/xwwN7Ft8Qd+Y0LuYxP7fwj8c2L7JODH\n", + "qQfzFYn9ZwHfybj2KcDVie0XgWmpMknF8CCh17h1qsxFwD8ktreI971r4hxvSOz/AXBqhkyzgd+k\n", + "6mMFcDBwAPBgqvxn2NBznU2qZ0PoKf81oYd0PeElPxx4E7Awlml33kWpF2vHeH+jEnW+U2L/rcAx\n", + "LX7zTxIa+dXAnhllRhN660nr8QTgxvh5Gq0Vw5nAv2adP1HuGFINHUHJNTobQ+o0fV3gVFKNBjCP\n", + "YEHtSGjItmly3Y3kZ6jFsBWhw7RL3P4y8TluJ3OOd/LHwMyEHGuJjW38bhWhAzU6/s7J9+nLtLcY\n", + "mr5/8f7mJ/btQOhEbJ747ljghvj5BoZaN/+LoRZDUjFcT8LKTcmVVgytfrNdCYpybGLf9+nCYugX\n", + "H0OaRxof3H1t/Lhl/H854QcCeC+h4X02fQIzOyRG7TxlZndlXGc1oaeZxY7AQwlZnNAbmpgosyrx\n", + "+ZnU9rMJuRsknXoPNa4fneA/MbOVZvYk4SF/SYtj07yL0Pt6wMzmm9mBiXt4MHEPfyLcd/IeHkl8\n", + "XttE5iTLEufyuL0T4aHdyczWNP4IDfiEFudaQHj5D4mfFxB6q28kmOIQeuOtzrsb8OPEvnuAdYQX\n", + "O+v+tmgh06XxXq5z96UZZcYTemwPJr57iKF12oqvE4a+/t3MlprZqRnldgMOSN37exl6b63YDTg6\n", + "dfxBwMsI1uHj7v5kznOtx92fIlgbjffwfxMaqI5lNrMjzOwWM1sdy85g6HO/2jf4UGDD8/lSgpWT\n", + "fp/a0fT9iyxLfN6N8BuvTNzHt+N1IbxXea+9M8HKzUOr32wnYI27P5Mo/2Czk7SjKidlkfwCeKmZ\n", + "TSE8kKc0K+TuN9HegfwLQoN6Scb+FcBrGhtmZoQXanmLc7ZzJO1K6JE2PjfOdR5hyOQYd/+TmZ0S\n", + "ZUviWSd199uBv4pOs5OBK+P5VxB6S4172ILw4rW6h1bskjjXKMJDv5zQ+7zf3V+RcdyLTb5bAHyD\n", + "8HB/FXgC+A5BoX4rlnm4zXkfAj7k7jend3QZyvsvhPH/6WZ2kLv/ukmZxwg9t90JFguEul7WpOxG\n", + "uPvTBN/Up8xsH+AGM7vN3W9IFX2IMOz31qxTtbnUQ4Te5AnpHWa2I7C9mW3TRDk0O2/6uyuAM2J4\n", + "6ObufmNOmZMybEbwHb2f4Cd8wcx+TD5n7KOEDkD6fWpH1vsHQ+/xYYJV+JKUYmqwMnW9Vtd+GJiU\n", + "sS9dr61+s92A7cxsXKLDvBvh3euIfrUYMnH35wkO0H8kjO39fBinOwN4g5l9zcx2ADCzSWY2x8y2\n", + "JjSubzOzN5vZGMKY+rOEseduOT3Gn+9DGDb7Qfx+S4IDaq2ZvQr4WN4TmtkYM3tffMkbTsPGw3IF\n", + "8CEzmxJfxK8At7h7Vg+n3Uv5OjP76xgZdQqhPm4h+HqeMrNPx/sbbWavNrO/iMetAnaPyrXBb4BX\n", + "Aq8nOJ7vIfY4CcNMEIZ+Wp3328BXYqgmZvZSMzuyzT00vccYd74/YXx8JvC9qEiHEOv4SuDLZrZl\n", + "fGE/QQhmaIuZvS0+Z0YYCn2B5i/3T4BXmNn74288xsxeH5+PzPtIcBnwDjN7a6y3zWMo6kR3X0lw\n", + "Iv+LmW0bz/3GeNwq4CXxHVgvdurc1xF+qzMJQ4B5ZU6yafx7DHjRzI4A2ioUWP8bXA3Mjs/F3oTf\n", + "rZ2yzHr/0udfSXDufsPMtjKzUWa2Z6KOrgRmmtlEM9uOEACRxXcInYDXWmBS43kl1PWeibKtfrMH\n", + "gduBM2O9Hgy8vc39NqUfFYOz8Y+b3r6c4BC+KkOb57uQ+33AXxJ6fneb2RMEP8FtwNPu/j+E3sw3\n", + "CT2UtwHvcPd1beRPfk7LvoAwjPAL4Ovu/ov4/acIJvcfgQsIL1v6XK2u9X7gfgvDUCcA74v3+EuC\n", + "r+RHBOthD4KllXXeZjIn9/0rYRz58XiNd7r7C/FFfTvB2Xgfob4uIDi1IShzgNVmdnuUbS3BSro7\n", + "Uae/AR5w98dimRfbnPccgvP8383sjwTn3NQW99f0u/iing0c7+5r3f0Kwkv4jYy6OJngCL2PEEH1\n", + "fUKET6vrNphM6NA8Fe/3n919wUZCBsvirYTfazmhl/pVQmPauEbmu+Luy4CjgM8SHK0PETo3jXbh\n", + "OILlcy+hgZoZj7uX0KG4z8wej9aFp879HKFhPozwPuaVOXl/T8VrXkl4no4lRM01vZ8mnEToUD0C\n", + "XBz/2pH1/jWry+Oj3PdE+a4iDOkAXEjwHSwkPCc/ypLV3X9IGBq+nPB+X03o1EKom9PjsNEnc/xm\n", + "7yV0nB4HPg98L8c9b4RFB0UhmNnFhMbyD+7+mowy5xKiCdYSQs3uKEygGhOHNe4jRDR1rcyEEJ2j\n", + "928oRVsM3yXEqDfFzGYQQksnE3qx5xUsjxBCiDYUqhiig3dNiyJHEk0dd78V2LYxlj9CKc58E0K0\n", + "Q+9fpGofw0SGhnQtI0SxjDjc/QF3Hy0zVojy0fs3lKoVA2wczSCtLYQQFVL1PIblJOLe2RDzPgQz\n", + "k7IQQogucPeOF+GrWjFcQwgpm2thJu4T7r6qWcFubm4QMbPZ7j67ajnqgOpiA6qLDYzIujCbTAjH\n", + "PTh+cxkwy8IqBh1TqGIwsysISxiMt7B++xmEaeS4+/nufp2ZzTCzJYSY7w8VKY8QQgwUYXWBmYSJ\n", + "qWMJczZOxP2auL+r0xaqGNz92BxlTipSBiGEGEgyrATcHx/uqevgfBadMb9qAWrE/KoFqBHzqxag\n", + "RsyvWoBCMRtFWCttIUEpPAIchftxvVAKUPDM515hZi4fgxBixNOhldBt2ymLQQgh6k4JVkISKQYh\n", + "hCiIGFwzz0IOlHlxGaCOjt/f7Fd3hEXxziY4mC8D9lnvYC6AqsNVhRBiIIlK4ByG5lrY08xw9+va\n", + "Hb+Z2ds+A5ecDuPHEZahPQVWXglXeAFWQhL5GIQQogDMbB4hFW2aee5+RJuDJy+EW6fE5bfnEJKX\n", + "r8l7/AYZ5GMQQogasXnG92Mzj0j4EqbAdisJK40ez5DVSLOP7xFSDEKIEc9wfQEZbJRrPvJM029D\n", + "xNECoi/hp7BiH+DavMf3EPkYhBAjmuH6AlpwLiEtZ/K8SwkZHxvXnTkKNv8C7HAa7DEaNiPOXn57\n", + "yFmdlmv98UUixSCEGBgajS1hGOdZ4NwcjftMhja+xO2TCbmruyIu+UM8z1hCT/+bjaWAgHMmwaSL\n", + "gUPiMYvhhslwNO6Pe7ifpsd3K1NepBiEEAPBMHr+nfsCchKvu9G1R8HMk2HSV4BGxNGJwLXwXDLi\n", + "KOv4opGPQQgxKLTq+beiM1/AcDGbfDsc+E8EpTAHSPgSCncs50GKQQgxhIIcsWXQbc//XGBJ6rve\n", + "j+UnIo72h20yIo4KdyznQUNJQoj1FOiILYOuev6tfAE9kyy1xtFiuOENsPtj8PJEqVIcy3nQBDch\n", + "xHqGNSmrYjKU2lJgZmVKrUW+hChvoY7lbttOWQxCiCSFOWKLppSefye0WQm1KsdyHqQYhBBJynXE\n", + "9phaNLbtsqr1AXI+CyGSlOOIHVRSs5cpYSXUIpDFIIRYT+2GY3LS5cS2XgpQCyuhST10dx45n4UQ\n", + "/UyG03kJMKsU5VBg7uXOxGhaD2h1VSHESKTbiW3Do+SsajloVg9doaEkIUS/U34kVU2shBRZ9dAx\n", + "shiEEP1OeZFU9bMSknTtU0gjxSCE6HfKWtKi7hFHzeqhKzSUJIToawqPpKpJxFE7MuphejfnUlSS\n", + "EEJkUU9fQm6U81kIIXpFvX0JhSPFIIQQSQr0JfTLkubyMQghCqXyWcl5KdiX0E9LmksxCCEKo28a\n", + "w3J8CYXkli4CDSUJIYqkmlnJeenAl9CDYaC+WdJcFoMQfUwfDNPUtzHswErokeXTN0uaSzEI0af0\n", + "yTBN/RrD7nwJvRgGOhfYk40zzNVuSXMpBiH6l34Ys65XY9i9L2HYlk+vJ+IVaS1KMQjRv9R3mCZS\n", + "m/wOw4846onl06sMc0Vbi1IMQvQv9RumaULl6TZ7E3FUL8unYGux0KgkM5tuZvea2WIzO7XJ/vHR\n", + "u3+nmf3ezD5YpDxCDBhKw9mKHs5ejsptFjCPMPltHjCzQl9OodZiYWslmdlo4L+BtwDLgduAY919\n", + "UaLMbGAzd/+MmY2P5Xdw93Wpc2mtJCGaEIcU+ioNZyn0+RpH7TCzecDhTXbNc/cjEuW6ajuLHEqa\n", + "Cixx9wcAzGwucBSwKFFmJbBv/Lw1sDqtFIQQ2VQ+TFM3+mQl1B5Q6NBWkYphIvBwYnsZcECqzIXA\n", + "DWa2AtgKeE+B8gghBpkBtxKSFO3UL1Ix5Bmj+ixwp7tPM7M9gZ+b2RR3fypdMA47NZjv7vN7I6YQ\n", + "oq8ZOVbCEJpZi2Y2DZg23HMXqRiWA7sktnchWA1J3gB8GcDdl5rZ/cArgdvTJ3P32cWIKYToW0aQ\n", + "lZCH2GGe39g2szO6OU+RUUm3A5PNbHcz2xQ4Bkhr8HsJzmnMbAeCUrivQJmEEIPACM+XUDSFWQzu\n", + "vs7MTgKuB0YDF7n7IjM7Me4/n2D6fdfMFhKU1KddP6oQohWyEgpHqT2FEP1Byb6EPligsC11DFcV\n", + "QvQ5tWkcS7YS+mSBwsKQYhBCNKUWjWN1EUf9sEBhU1LKvCukGIQQWVTbOFbrS6j9AoXNyFDmHaMM\n", + "bkKILKppHOsRcdQXCxQ2oZky7xgpBiFEFuU3jsFKWACcTVBAlwH7VDBZrV8XKOx6+CiJhpKEEENI\n", + "jFHvBKwFxiV2524cO3JcF+RL6NZ5Xps8Ep2Tpcw7QopBCLGejDHqtQSFsJycjWNHjuuCfAnDdZ73\n", + "6QKFzRbX6xjNYxBCrCfvcs6J8k175LnOU3DEUaf3MiiklmI/VPMYhBDDJbfDuVWPvO15zCb/AX48\n", + "AfYB+CmsmA2fuK23voRKnOdVz/1IWjpm1lXPX4pBCJGkE4dzq3DWpucZBc9gdsoL8A8TYLOVwInA\n", + "tcGf8WUze7qHjWjpzvNazP3oAYpKEkIk6SQap1WPfKPz7AUPrQyrLJ89GjabQzAXrt1QpKFUekUV\n", + "kUWtlGXXmNmMmAZ5fvw/Yzjna4csBiHEejqMxsnskSfPMwrGfgEmnAYvHw27Ao98AB67FF7d5Nie\n", + "DfNUFFnU8+GrKqwQKQYhxBA6iMZpmV7S3a/DbDEh4mivuP8yYNalcDnNFUNPh3kqiCwqYviq9Bno\n", + "GkoSQnRFbHRnAfMIk9LmATOjQmg3e7nnwzxlD7dk0Oy+1gIThyFT6U50WQxCiEzaRdg07ZHnmJfQ\n", + "62Geujh9U/c1kWBRjQNeE/+6kal8J7rmMQghmpHR2C4BZjVt2CrMvVzHOQu9kinjd1hKwzprfazy\n", + "MQghekr+se3qs6rtlPH9xJKu34yeDAFV4USXYhBCZNG+YavQSkixY4ffA4VPRuvZEFDZTnQpBiEG\n", + "hAIaudYNW/VWQpKVwPiM75tSgl+iZdRWnZFiEGIAKKiRO5fgME0O06zcFL4VI46qthKSrCDImmZ5\n", + "i2MKDQPt4xVapRiEGBCKauSGOC5fBaMXwFnENY6o1kpI0k3vvPAw0D5doVWKQYgBoYhGbiZxjN5Y\n", + "70iYMA4mUA8rYT1d9s77NUtb4UgxCDEYFNHIbQ6hC34xcEj88lpY9Y6QVa1qK2EIXfTO+9YHUDRS\n", + "DEIMBj1v5EbBsycTHAnjCF7cuBLqHV4zpdAN/ewDKBopBiEGgJ43cmaTV8LOE+LmHMLaF2sGrEfd\n", + "rz6AotHMZyHEBlLzEp6FNR+D+y+Bp1CPuu/otu2UYhBCBEqal9BsvkXcVVnWs0FFS2IIIbqjxNnL\n", + "GfMt9gWcofMl+i7r2SAhi0FUQtV5cUWk5NnLLRaWa0ZlC+ANCrIYRN9QlyWSRzTVrXGUNd+iGYXl\n", + "GxCtUaIeUQWF5MUVrWkksplidutCeAw4m9D4XkaYl1DGZLWs+RbNGPETzapCikFUQekZqUY6ZjZj\n", + "FJwzCw6/GaZOge3+AC9cAF9IZFUrg2YZzlYS1jpKMlBhsf2GhpJGOBWN9WspgpLZD047FyY1Zi/H\n", + "eQmj18DUE0qUI2u+RdytiWY1QYphBFPhWP+IW4qgMmd79CXcDAdtzpDZyw1Kt9JaTCqTIqgJUgwj\n", + "m0KXHc5ipC1FUJkCTkQcbc6Q2ctJZKWJjSjUx2Bm083sXjNbbGanZpSZZmZ3mNnvzWx+kfKIjahs\n", + "rN/dr3P3I9x9Wvw/kEohUoqzveFcHm02/8tmi16AuwhhqI9cAF84HpaklMJAW2miewqzGMxsNPAt\n", + "4C2EZBm3mdk17r4oUWZb4J+Bw919mZk1y8AkikNj/eVQuAJuWCWTYFJyJdTFcMNkOPoE98dPNLuV\n", + "EWKlieGRSzGY2ThgF3f/7w7OPRVY4u4PxHPMBY4CFiXKvBf4kbsvA3D3xzo4vxg+Az/WX5OJdIUr\n", + "4FEw82SY1GQl1OcaK6FqwTiRl7aKwcyOBL4ObAbsbmb7A2e6+5FtDp0IPJzYXgYckCozGRhjZjcC\n", + "WwHnuPucvMKL4THoY/01mkhXrAI2m3w7HLh/3Ez5EhQCLDomj8Uwm9Cg3wjg7neY2ctzHJdnrY0x\n", + "wGuBwwgdnZvN7BZ3X5zjWNEDBrwXWYlzPU0TBbwFwb/3aTObSbdWTGL28v4wtknEEWhYUHRBHsXw\n", + "vLs/ER/sBi/mOG45sEtiexeC1ZDkYeAxd38GeMbMfgVMATZSDGY2O7E5393n55BBjGxqM5GuoYB7\n", + "ZsWk1jhaDDe8AXZ/DJKdto2skpoMrYmCMLNpwLRhn8jdW/4RHr73ESIcJhMetG/nOG4TwoO5O7Ap\n", + "cCewV6rMq4BfAKMJFsNdwN5NzuXtrqc//aX/gHkEyzX997O+lQlGOZzisNbBHVY6HBnPPQP4GTA/\n", + "/p+RuvYMQqcred3F6XL6G1Jf82J9zuvHeuq27cxjMZwM/F/gz8AVwPXAF9sd5O7rzOykWH40cJG7\n", + "LzKzE+P+89393rja4u8IVsiF7n5PDpmEyEMdnevdWzEpK+GnsOIjcP8q+Dhm67z9sGAthtb6gRr5\n", + "pyqh7bLbZvZad/+vkuTJksFdy24LOh8KieVr41xvsex09hLTTbKqfQCevRJ2TJRaAsxqUxfzgUOb\n", + "7Frg7tPy3cHIoKvfqYYUuez2N8zsZcBVwA/c/fcdSydED+imF5ejF102nVkxTfIl7AE7PQJvTpXM\n", + "0/PXvJX81MY/VQVtZz7HnsSbCMv0nm9md5nZ54oWTIgm9P1y3VFRzSKMWS+I/2dupNjMRmF2CrCQ\n", + "OHsZOAr34x4JQ7PNaNdoNVvZtOqhtdrQmDkeLat9MoqNCCWaa4Kbu68EzjGzG4BTgc+Tw88gRI8Z\n", + "iF5cWyumfVa1rnr+PuDzVoZDhjX6PCGkvsGIUaJ5JrjtDbwHeDewGvgB8MmC5RKiGZUOhRQe6pk/\n", + "q1rXTvUaDq3VhWbW6BjCSMndjDAlmsdiuBiYS1jPaHnB8gjRisqijAqPUukg97J6/oWQZY3ePRId\n", + "820Vg7sfWIYgQrSj4gaxmFDPLnMvq+ffc+SYT5CpGMzsKnc/2szuarLb3X3fAuUSoikVNoi99290\n", + "YCWIwqnjnJfKaGUxzIr/3w6k42DzrIMkxCDRux5ll1aCKI5+Gp4rY1mTPBPcznL3U9t9VySa4Caq\n", + "JsPHsJTwgkLeF1VWghgGGc9h5uTGbtvOPIrhDnffP/XdXe7+mk4v1i1SDKIONJtFHXe1f1FlJYge\n", + "0OmM7J7PfDazjwEfJ0ReJP0MWwG/7vRCQvQ7zfwb8UVt7ZSWlSB6RylzeVr5GC4nrND4D4RJbQ2t\n", + "85S7r+6lEEL0MdkvqqwE0XtKiZ7KVAzu/iTwpJmdA6xx9z8CmNnWZnaAu9/aS0GE6FOavqj7hY7U\n", + "AmQliN5SSvRUHh/DncBr3f3FuD0auD3tdygS+RhEmXQS9ZF2BhpwGjz2RdhqdEiHKytB9JROVgwu\n", + "cnVVGkohfn4hKgchBo5OZzgnwxz3he0vhclTYHzcLStB9Jwy5vK0XV0VuN/MZprZGDPb1MxmAfcV\n", + "KZQQFdLxCq4O8xyuXwivmQLbkVgJVUpB9CN5FMPfAAcRcjgvAw4ETihSKCEqpLOojxBxtAA4O5a5\n", + "DNinX4aOkktNx/8zBuFaYnjkWStpFXBMCbIIUQfyRX2UEHFU9AzXMtNXjvRUmf1GW4vBzF5pZr80\n", + "s7vj9r5mdnrxoglRCe2T2ZRgJSQa0sMJ6TgPJ+RE6WUvu8zER32fZGkkkWco6ULgs8Bzcfsu4NjC\n", + "JBKiQlpmWGuRVa0AX0IZDWmZiY8GIsnSSCFPVNI4d781Rl7g7m5mzxcrlhD56fWQS9Ooj/JnL5fR\n", + "kJa51LSWte4j8iiGR81sfc/FzN4NrCxOJCHyU0ICnapmL5fRkJa51LSWte4j8iiGk4ALgFea2Qrg\n", + "fuB9hUolRH6KSaADVa9xVHhDWuZS0/20rLVoMfPZzGa5+zlmdrC7/4eZbQmMaiyNUSaa+SyyMLP5\n", + "BOdsmgVdp2QswEroZrirkxmuQjSjiJnPHyaY6N8E9nf3p7sVTogC6e2QSwFWQqvhrkhThaH0naIq\n", + "WimGe8xsMTCxSXpPpfYUdaE3Qy7F+hKyhrvOBLZFsf2iZrRcRM/MXgZcDxxJKr2nuz9QqGRD5dBQ\n", + "kshk2EMuBfsSWgx3rSEsoZGmadIVITqliEQ9v3T3w8zsend/cHjiCVEcXQ+5lBdxlDXcldUrU2y/\n", + "qJRWQ0k7mtlBwJFmNpdgMax/kN39v4oWTojCaGIlvB6uvR0+jtkn6e0SFFnDXU8C2zcpr9h+USmt\n", + "FMMZwOeAicD/a7L/TYVIJESRZFgJBusoaD5EVqhm3J2+pmL7ReXkSdTzeXf/QknyZMkgH4MYPi18\n", + "CZ0mWe+dSApJFcXRbduZRzGMIkxo28Pdv2BmuwIvc/ffdidq50gxiGGRw5dQyHwIISqm27YzzyJ6\n", + "/wL8JfDeuP10/E6I+pN/JVSt5SNEJI9iOMDdP058QTyE8I0pVCohhkvnK6G2X25biBFCnrWSnkvm\n", + "eDazlwIvtihfCHEMuKeJSsSA0sW8BK3lI8QG8vgY3g+8B3gd8D3g3cDp7n5l8eKtl6Eh5BJgll7W\n", + "aig6o9iwZYm5Eyh/JVQhaklhzud48r2Aw+LmL919UU6hpgP/BIwGvuPuZ2WUez1wM/Aed7+6yf6k\n", + "kJoV2mMK3cjHAAARqklEQVTyNPgZ6/1UoqibybI3PHgjPD0B9olf9WqNo1ooQiG6oYhF9NYTFUEu\n", + "ZZAQaDTwLeAtwHLgNjO7Jq1UYrmzCL29PDegWaE9pIN8BsUtb90562Ux1psIu40L+3piJShHsRjJ\n", + "5HE+d8tUYIm7P+DuzwNzgaOalDsZ+CHwaM7zKkqkt+RNIVmn1IybQxByAcEkHQdcDU/Qu9zLylEs\n", + "RixFKoaJwMOJ7WXxu/WY2USCsjgvftVuXEtRIr0nb4Nfm3DOUfDsLEK40SGEdIJHAu+CTQ0O7NFl\n", + "6qQIhSiVtorBzPZu8t20HOdu77wInb3TPDg6jNZDSRuSsote0rbBj8Mq49lYCZSvqM0mr4SdG1bC\n", + "HIJT4dqwdxy969FXogjNbIaZzTOz+fH/jCKvV3dUH9WQx8dwpZnNAb5G6C2dBbye9j2z5cAuie1d\n", + "CFZDktcBc2OY4HjgCDN73psPBdwKTDWzqcB8d5+fQ/aBowCHaMt8Bhlj7c8A9wCfL01RJ2YvT4Cx\n", + "j8K6j8Am125cslc9+tJzFMuvMRTVR+fETvu0YZ/I3Vv+AVsQnMi3AL8HPktI8dnuuE0IL9LuwKbA\n", + "ncBeLcp/F3hnxj5vd72R8AfMABYTrLHG32JgRg/O+zNgfvw/I7FvXup6jb+flXbvMNnhJgePf3Ne\n", + "Br8sWq5W9VLQ71t9XdfoT/XRkzr0bo7LYzGsI/QQxxJ6qfe5e9sJbu6+zsxOIiT6GQ1c5O6LzOzE\n", + "uP/8HNcWQykkMshb5zOobqy9xRpHj4Te5K4U2KNvUy9FIL/GUFQfFZFHMfwWuAb4C8Jwz/lm9i53\n", + "P7rdge7+M0JPK/ldU4Xg7h/KIctIp4oXpfSxdjObsR+cdjHsuz9sE78eMi/BB3Omcm0c/DVB9VER\n", + "eRTD/3H32+LnlYTEPccXKJPIpooXpdSx9s3M3vYZuOR0GD+O8MCdAiuvhCs8NVmtgh59T2jhJyrd\n", + "r1FzVB8V0VYxJJRC8rtLixFHtKH0F6XUnrnZ5N/CnCkxD/IcYBawBnakmol0PaedQ3UAraCuUX1U\n", + "R64lMapG+Rg2MJCJXVK+hJXAiawPQW0wEHkRqkoIJEYmhS6JIepDXYZPehY2m1oJ9aew4jjYac3G\n", + "JQdlXFkOVVF7pBhEx/Qkvjwj4ujtzXMvD9K4shyqovZIMYhuGF7YbIt8CQ4M+LiyHKqi9kgxiG7o\n", + "bjgkR+5lqM9wWRHIoSr6ASkG0Q2dD4d0kVVtUClb8SmvhOgUKQbRDfmHQ3JaCaK3JJTBToTfalxi\n", + "t9YbEi1RuKroilxhs7ISKiEjOCCNwmNHAIWm9qwaKYY+Q1ZCpbSYK5FkIOaFiNZoHoOoB7IS6kBW\n", + "cEAShceKTIrM4CZGEmajMDuFkFjtYIKVcBTux0kplE5WcEADhceKlshiEMNHVkLdaBYcsJagEJaj\n", + "8FjRBikGkYumIY8x3SryJdQKzZUQw0XOZ9GWZlEue8ODN8LTE0LKZZCVIETtUFSSKIxklIuxwUSI\n", + "gfGyEoSoKYpKEkWyOQRz4WLgkPjltbDqHbCPrAQhBgtFJYm2jIJnZxHCjQ4hpvELf3dIKQgxeMhi\n", + "6FNKW//GbPJK2HlC3ExkVVPIoxADihRDH9KTfAjtL7J+9vIEGPssrPkY3H8JPIWiXIQYaOR87kMK\n", + "Tw+peQlCDATdtp3yMfQnxaSH1OxlIQRSDP1K79NDBithAXA2QcFcRog46nkYqpnNMLN5ZjY//p/R\n", + "62sIIbpHPob+pHfpIUteCdXMzgA+jfIDCFFb5GPoU3LlQ2h/klJ9CVHmqxiqFBooP4AQPUYT3EYY\n", + "w0oPWV2+hJk0VwowXP+IEKJnyMcw0ijRl9CEVnkClB9A9AUjwUcmi2GkUI+sallO87VospzoA0qZ\n", + "Q1QDZDGMBKq1EpKcCyxJfbcW+NogvVRioJnJxrm0JxH8fQODLIZBpoWVYGYzMCt+SY0EyhMgBoBi\n", + "5hDVDCmGQaVFxFGGOXyImX3N3c8sUqxhOc2FqJ7ezyGqIRpKqhE9cWrlm73czBweB3wuzjMoR1Yh\n", + "+o9mw6EDt6CkLIaa0BOnVv55CVnm8Gjg02Z2W6trjhQHnBBpRspwqCa41YRhLYzXYcRRi2vlumbh\n", + "i/gJIXqCFtGrEV0Os3Tn1Oou4uhcQjRQFu0caSPCASfESKVwxWBm083sXjNbbGanNtn/PjNbaGa/\n", + "M7Nfm9m+RctUJIlhlsOBQ+P/c3Ioh86cWsNYCTWavV8DXujomt3KKoToKwpVDGY2GvgWMB3YGzjW\n", + "zPZKFbsPeKO77wt8EbigSJlKoNs45/xOrR7MS4jRR19kY8shjyNtRDjghBipFO18ngoscfcHAMxs\n", + "LnAUsKhRwN1vTpS/Fdi5YJmKpqthllxOrR7PXnb3M83stpbX7FZWIUTfUrRimAg8nNheBhzQovxH\n", + "6P8Y96xhln3MbEarxrNljH9BK6F2O69A8xGEGFyKVgy5Q57M7E3Ah4GDMvY/AKwjWBUXuvv8HshX\n", + "BM1yJQCMJ/gaOgvprMcaR0KIPsDMpgHThnueohXDcmCXxPYuBKthCNHhfCEw3d3XZJxrt/jfge/3\n", + "Ushekhhm+R5BGSRp+Bp6PS9BCCGIHeb5je28E1bTFB2VdDsw2cx2N7NNgWOAIT1dM9sVuBp4v7un\n", + "HZrNqP2CVdEiuDtjd/uQTuVeFkJUSKEWg7uvM7OTgOsJs2ovcvdFZnZi3H8+8HlgO+C82NN+3t2n\n", + "tjl1P8TLdxfSKStBCFExfTPzOfVV7WfYZiwbsRSY2dTHIF+CEKLHjKTUnn0RL99RSKesBCFEjegn\n", + "i2EBgxYvLytBCFEg3VoMfaMYBm4RPVkJQoiC0SJ6/YIijoQQNacffQz9i6wEIUQfIIuhDGQlCCH6\n", + "CFkMRSMrQQjRZ8hiKApZCUKIPkUWQxHIShBC9DEDaTF0mVqzFxeWlSCE6HsGzmLIWIpiz46Xu+78\n", + "wrIShBADwSBaDN2m1uwOWQlCiAFjEBVDV6k1obMhKDObsb/Zr+6AxxlG7mUhhKgbAzeURJfLXXcy\n", + "BLWZ2ds+A5ecDuPHASuBU2DllXCFy0oQQvQ5g2gxnAukE/7kWZE13xCU2eTfwpyvRKUwB9gHuBJ2\n", + "3KisEEL0IQOnGGLvfhYhe9wawlDPkzkObT0ElfAlTIHtVgJHAsfHiwwp2wWVRVKJgUXPlOiWQRxK\n", + "arAtITMcwPbAOW0ik7KHoFIRRz+FFcfBTk2SU7fOzpZBZZFUYmDRMyWGw8BZDJFuIpM2GoIaBUuv\n", + "h4dIRRy9HT66prvhql7KK0Qr9EyJrhlUi6HjyKR0xrX9wK6Hl0yAE2KR9fMSHMidnW148k40s3lx\n", + "/7PAuertiZx0HZ0nxKAqhtyRSdHknklsfDeFb/4ZJtMmq1psoHvVSGfJuyfwmuS2hgJETrqKzhMC\n", + "BlcxnEtoVJOm9EZDPelx2EnA9+FQNvS2ypq93EzetcC4VLnGUIAUg2hHrndAiGYMpGJIDwuRPdQz\n", + "E5hkbEi8PA42Xw1/fgm8p6yJahnyTmSotdBAQwGiLR28A0JsxIjO+Wxm8yfBoRcDh8Tv5gB/D79+\n", + "xP3gFocWTvQtHN5k1zx3P6JseYQQ/YdyPneK2agvwQ4LCUohOS9hFTxVqWyBbifqCSHEsBiZFkNq\n", + "XsIcwoy4OC9hKTAzr8mddl7Tw8iheG4NBQghuqLbtnNkKQazUWxwJ4wFHrkALjgRptJF45sxiWgJ\n", + "MEsNuBCiaqQY2p+k5/kS5AcQQtQZ+RiyKDZfgiYRCSEGjoEMV11P8VnVNIlICDFwDKbFUF5WtZaR\n", + "Q1rdUgjRjwyexVBi7uVWk4i0uqUQol8ZHOdzk4gjmqxxVBZyTAshqmZkO5+DlbCAEnMv5xgmkmNa\n", + "CNGX9PdQUkVWQs5hopaO6SInxgkhxHDoX8VQoi+hCa2SoDQa98zVLeV/EELUmUKHksxsupnda2aL\n", + "zezUjDLnxv0LzWz/HCctK+KoFW2HiRK5p+cRhrnmsWGpDWXXEkLUlsIUg5mNBr4FTAf2Bo41s71S\n", + "ZWYAk9x9MiFT2nltTlq6LyGDXPMX3P06dz/C3afF/w1roGv/g5lNyy/mYKO62IDqYgOqi+FTpMUw\n", + "FVji7g+4+/PAXOCoVJkjge8BuPutwLZmtkPTs1VvJSQZ7sqnw5kYNy3nNUYC06oWoEZMq1qAGjGt\n", + "agH6nSJ9DBOBhxPby4ADcpTZGVjV5Hxnx/9l+hKa0oMkKMquJYSoLUUqhrwTJNIxtlnHVTovIc1w\n", + "cj4ru5YQos4UNsHNzA4EZrv79Lj9GeBFdz8rUebbwHx3nxu37wUOdfdVqXPVfxaeEELUkG4muBVp\n", + "MdwOTDaz3YEVwDHAsaky1wAnAXOjInkirRSguxsTQgjRHYUpBndfZ2YnAdcDo4GL3H2RmZ0Y95/f\n", + "WFPIzJYAfwI+VJQ8Qggh8tEXayUJIYQoj1qtlVTIhLg+pV1dmNn7Yh38zsx+bWb7ViFnGeR5LmK5\n", + "15vZOjN7Z5nylUXO92Oamd1hZr83s/kli1gaOd6P8XENsztjXXywAjFLwcwuNrNVZnZXizKdtZvu\n", + "Xos/wnDTEmB3YAxwJ7BXqswM4Lr4+QDglqrlrrAu/hLYJn6ePpLrIlHuBuAnwLuqlruiZ2Jb4G5g\n", + "57g9vmq5K6yL2cBXG/UArAY2qVr2gurjEGB/4K6M/R23m3WyGHo7Ia6/aVsX7n6zuz8ZN28lzP8Y\n", + "RPI8FxBCf38IPFqmcCWSpx7eC/zI3ZcBuPtjJctYFnnqYiWwdfy8NbDa3deVKGNpuPtNwJoWRTpu\n", + "N+ukGJpNdpuYo8wgNoh56iLJR+hyTkUf0LYuzGwioWFoLKkyiI6zPM/EZGB7M7vRzG43s+NKk65c\n", + "8tTFhcA+ZraCsGLCrJJkqyMdt5t1Wl211xPi+pnc92RmbwI+DBxUnDiVkqcu/gk4zd3dwszBQQxv\n", + "zlMPY4DXAocB44CbzewWd19cqGTlk6cuPgvc6e7TzGxP4OdmNsXdnypYtrrSUbtZJ8WwHNglsb0L\n", + "QbO1KrNz/G7QyFMXRIfzhcB0d29lSvYzeeridYS5MBDGk48ws+e9JrPke0SeengYeMzdnwGeMbNf\n", + "AVOAQVMMeeriDcCXAdx9qZndD7ySML9qpNFxu1mnoaT1E+LMbFPChLj0i30NcDysn1nddELcANC2\n", + "LsxsV+Bq4P3unl7Qb5BoWxfu/nJ338Pd9yD4GT42YEoB8r0f/wYcbGajzWwcwdF4T8lylkGeurgX\n", + "eAtAHE9/JXBfqVLWh47bzdpYDK4JcevJUxfA54HtgPNiT/l5d59alcxFkbMuBp6c78e9FnKN/w54\n", + "EbjQ3QdOMeR8Jr4CfNfMFhI6wJ/2ChfeLBIzuwI4FBhvZg8DZxCGFbtuNzXBTQghxBDqNJQkhBCi\n", + "BkgxCCGEGIIUgxBCiCFIMQghhBiCFIMQQoghSDEIIYQYghSDEBVgZrPN7O+qlkOIZkgxCFENmkAk\n", + "aosUgxCsT/Kz0Mw2M7MtYnKXvZuU+1xMEHOTmV3e6PWb2X5mdks8x9Vmtm38/qNm9tuYMOaHZja2\n", + "7HsTolOkGIQA3P02wpoyXwLOAuakl5Mws9cD7wT2BY4A/oINPf9Lgb939ynAXYRlCSDkR5jq7vsB\n", + "iwhLpAtRa2qzVpIQNeALhAXaniEk/klzEPCv7v4c8JyZXQtgZlsTsundFMt9D7gqfn6NmX0J2AbY\n", + "EphXoPxC9AQpBiE2MB7YgrAw21hgbWq/M3Rd+6y8D8nvLwGOdPe7zOwDwLSeSCpEgWgoSYgNnA+c\n", + "DlxOGE5K82vgHdEPsSXwNgB3/yOwxswOjuWOA+bHz1sCj5jZGOD9bBh6GsRkQmJAkMUgBGBmxwN/\n", + "dve5ZjYK+I2ZTXP3+Y0y7n67mV1DWNZ6FcGX0Mi7/QHg2zEPwlI2LG38OUJO7kfj/y0bp0ORSaKm\n", + "aNltITrAzLZw9z9FBbAA+Ki731m1XEL0ElkMQnTGBTGMdXPgEikFMYjIYhBCCDEEOZ+FEEIMQYpB\n", + "CCHEEKQYhBBCDEGKQQghxBCkGIQQQgxBikEIIcQQ/j+O30HURJnrpwAAAABJRU5ErkJggg==\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -926,201 +6846,771 @@ { "data": { "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEZCAYAAABrUHmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xm8XHV9//HXmxCWKBA0LWsQSRCRX7G4IArKtWAJqYaW\n", - "FgGpgEvrxtIqLahVgloV+qtK8CcPBORB3XCvidJYilxAQEgsYU2QsCiERUCRVb1JPr8/zneSc+fO\n", - "zD2znpk77+fjcR+Zc+bMmc+9ufd85nO+myICMzOzIjYpOwAzMxscThpmZlaYk4aZmRXmpGFmZoU5\n", - "aZiZWWFOGmZmVpiThlkbJK2XtFvZcZj1ipOGDQ1J90p6RtKT6esJSdt38f1GJb2jat8dkt6c294/\n", - "JZ7qfU9I2kTS8ZKubnD+Z9P38qik70vauVvfjxk4adhwCeCNEbFV+to6Ih7q8vtVj569Enhdbvt1\n", - "wKoa+66NiPUFzv++iNgKmANsAXymrYjNJuGkYUNP0sWS3p8e75Q++b83bc+R9Fju2H+S9ICk+yW9\n", - "vYW3u4rxCeIA4Myqfa9NxxUWEb8Fvg/s1UJMZoU5adiwUY19o8BIenwgcDcbL+IHki7gkuYBHwAO\n", - "Bl6U/m3W1cBekmZK2gR4BfANYGZu32sonjSUYns+cDhwfQsxmRXmpGHDRMB/SvpN+vpu2n8VcIAk\n", - "kX3KPwvYPz13INktJYA3A1+KiNsj4hng9GYDiIhfAL8kS0ovBe6MiN8B1+T2bUaxi7+ARZIeBx4B\n", - "ngu8r9mYzJrhpGHDJIDDImLb9HU4QETcBTwN/ClZ0vgB8ICkF5FdyCtJYwfgvtz5ftliHJVbVPnb\n", - "UD/J7bs+IsYKfj8nRsRMYG/gBcD8FmMyK8RJwyxzJXAEMD0iHkjbxwPbAivSMQ8Cu+Rek3/cjHzS\n", - "qPSMupqJiaQIAUTErcBHgE+nW1xmXeFfLrPMlcAJbLxgj6btq2Pj+gHfBI6XtKekGRS7PTVd0ha5\n", - "r03Te7yMLElck467BdgNeD0Tk4YkbZ4/T533uhiYQZb8zLrCScMscxVZm0Dlgn0NsGVum4hYCnwO\n", - "+DHwc+ByJnaprXYu8Ezu60sRcSfwK+DBiHginTvI2jG2Aq7NvT7IGsafzZ3jaUnTcs9X4hsDzgb+\n", - "uYnv26wpKnMRJklfAv4C+FVE/EmdYxYBh5L9sRwfETf2MEQzM8spu9K4CJhX70lJ84G5EbE78Pdk\n", - "n9rMzKwkpSaNiLga+E2DQxaQ3aclIq4n68u+XS9iMzOzicquNCazE+O7ON4PeG4dM7OS9HvSgIkj\n", - "eMtrhDEzG3Kblh3AJNYAs3PbO6d940hyIjEza0FE1Jpap65+TxqLyfrKXyJpP+DxiHi41oHNfuP9\n", - "RNLCiFhYdhytGOTYwfGXzfGXq5UP3KUmDUlfJ5vbZ5ak+8gGS00HiIjzIuJSSfMlrSab5uFt5UVr\n", - "ZmalJo2IOLrAMSf0IhYzM5vcIDSED4PRsgNow2jZAbRptOwA2jRadgBtGi07gDaNlh1Ar5U6IrxT\n", - "JMUgt2mYmZWhlWunKw0zMyvMScPMzApz0jAzs8KcNMzMrDAnDTMzK8xJw8zMCnPSMDOzwpw0zMys\n", - "MCcNMzMrzEnDzMwKc9IwM7PCnDTMzKwwJw0zMyvMScPMzApz0jAzs8KcNMzMrDAnDTMzK8xJw8zM\n", - "CnPSMDOzwpw0zMysMCcNMzMrrNSkIWmepFWS7pR0ao3nZ0laKmmFpFslHV9CmGZmligiynljaRpw\n", - "B3AwsAZYBhwdEStzxywENo+ID0qalY7fLiLWVp0rIkI9C97MbApo5dpZZqWxL7A6Iu6NiDHgEuCw\n", - "qmMeBLZOj7cGHqtOGGZm1jtlJo2dgPty2/enfXnnA3tJegC4CTi5R7GZmdUnLUEKpPVlh9Jrm5b4\n", - "3kXui30IWBERI5LmAJdJemlEPFl9YLqVVTEaEaOdCdPMLEdaC0yrbCHdRMRLywypKEkjwEg75ygz\n", - "aawBZue2Z5NVG3mvAf4VICLuknQPsAewvPpkEbGwO2GamZFVF/DGqr3rBiVhAKQP06OVbUmnN3uO\n", - "Mm9PLQd2l7SrpM2AI4HFVcesImsoR9J2ZAnj7p5GaWaWVRfVCWMZEWV+8C5Fad9wRKyVdALwI7JS\n", - "78KIWCnpXen584BPAhdJuokswf1zRPy6rJjNbMjUry6GLllUlNbltpPc5dbMOm5820XFMiL2LSOc\n", - "bhi0LrdmZv2n0jNqfMJYR4SmUsJo1dCWWGZmEwxBddEuVxpmZq4uCnOlYWbDzdVFU1xpmNlwcnXR\n", - "ElcaZjZ8XF20zJWGmQ0PVxdtc6VhZsPB1UVHuNIws6nN1UVHudIws6nL1UXHudIws6nH1UXXuNIw\n", - "s6nF1UVXOWmYWakkzQdOArYAfgcsiohLm33d3TDjhfDaqsOGekbabvAst2ZWmnThPxuYm9v9DHBW\n", - "RJxR9HVjZKVF1UXA1cUkWrl2OmmYWc/UqCr+CHhZjUOfAY5IjydUIZKWAod8Gzi8cm6yNaTl6qKw\n", - "Vq6d/sGaTTGt3u7ptjpVxfo6h88AzgBmVh0/RxLAFvnqItLXLbBm74idOxy65ThpmE0hdS7McyTR\n", - "B4njJMbHBY17cM4Btq3aN/drsOio7LkNCWMdMD17/pbBv3fS39zl1mxqqXVhngucWEIsG6Rk1mz7\n", - "woTr/xhwFMxR7oBr2ZAw7gLOaTlIK8SVhtnUskWd/VtWHvT69lWu+qmuGvLWM/5D7F3Ab4HnAfxf\n", - "4P2V86V/18G66XAZ2ff2LHBOH1RTU56ThtnU8rs6+5+F0m5f1ap+qt0IPEIuAaT9Z4/B3Oq2C8Gy\n", - "TSP29a2o3nPSMJtaFpHd789fpPO3bRrdvmo6aRSsWupVP/n4PjrhddKSSLHm2i7WbeqeUaXyD99s\n", - "CkndUSFLArVu20x6+6qoRlVLUkkme9U5xa+BG6h1WymN6s73Ba1UF83GaZ3lpGE2xaQLcL2qoeHt\n", - "qybVq1o+BmxT9dwYG9qrN7zfPVQnDGkJ8Maqc3rcRR8ptfeUpHmSVkm6U9KpdY4ZkXSjpFsljfY4\n", - "RLOpZhGwumrfg8AfSxqVtFTS/PS1NL+vxrnqVS27MTGZTCdr2K4kpy2BlwNnbzh3Vl1UJ4xlThj9\n", - "pbT/DEnTgM8DBwNrgGWSFkfEytwxM4H/BxwSEfdLmlVOtGZTQ43bV88BdmL8qOy9yZoQdsztq9VY\n", - "Xq9qqdc+PYPx1QbA3PfBeUjVA/JcXfSpMiuNfYHVEXFvRIwBlwCHVR3zFuA7EXE/QEQ82uMYzaac\n", - "iLg0Ig6NiBHgMWCHqkN2YHzCgNpjPWpVLXeR3XaqpTph8BhwDlQnDFcXfazM/5idgPty2/cDr6o6\n", - "ZndguqQrgK2AsyPiyz2Kz2wYTNazKW9cY3m9Rvf0dHUD+TgHkQ2wgHGTDLq6GACF/oMkzQBmR8Qd\n", - "HXzvIl2sp5OVzQeRlbbXSfppRNxZI8aFuc3RiBjtRJBmU1y9W0y1TGgsr9fonpLJl0mD8/K+CLyT\n", - "ieMuPCNt90kaAUbaOcekSUPSAuDfgM2BXSXtA5wREQvaeWOydozZue3ZZNVG3n3AoxHxLPCspKuA\n", - "lwITkkZELGwzHrNhVGtcx4NMbNNoaoqOVIUsAw6p7HsesILsXlQlYayFddNdXfRM+jA9WtmWdHqz\n", - "5yjyn7WQ7LbRFelNb5S0W7NvVMNyYHdJuwIPAEcCR1cd833g86nRfPMUx2c68N5mxqS3mOqN9Shq\n", - "Q0I6HfgoWSNq5RaDYNl0VxcDp0jSGIuIx3MDdqD+dMaFRcRaSScAPyKb4fjCiFgp6V3p+fMiYlWa\n", - "N//m9J7nR8Tt7b63mW3UYFxHW9OKRMSlX5c+8gaY+3y83sVUMekiTJK+BFwOnEa23slJwPSIeHf3\n", - "wyvGizCZ9SGv1d33Wrl2FulyeyLZNAC/B74OPAH8Q/PhmVm1goPo+p6k0yU9Iunxf5OeDCkYnzDW\n", - "ESEnjMFXpNJ4WUT8b4/iaYkrDRtEdeZuWg2cPEhTfKfG1A8D06tX00t/lK4u+lRX1ghPU3dsD3wL\n", - "+EZE3NpyhF3ipGGDqLLOdY2nlkbEob2Op1WSHjkVZn2qss2GGWlj0wgv9NbHunJ7Ko0afT3wKHCe\n", - "pFskfaS1EM0sp2MzzpZpLCWM/Gp6ZwPTs1vZNsUU+hQQEQ9GxNnAu4GbyHrPmVl7tqqz/7k9jaJV\n", - "0hKkyN+OWkd2UfnH7Iix0mKzrpk0aUh6iaSFkm4lm2DwWrIpQMysPfXuDff/gnRVM9LmqouKMbLr\n", - "hU0xRfpKf4lsMsFDImJNl+MxGyZP1dn/dE+jSOqtwpffvwh2PgHmVC2OtE7wceAEsrwxBnw+Is7o\n", - "8bdgPTBp0oiI/XoRiNkQ6uSCSG1psArfK4G/BeY26hmVSiMniSFQN2lI+lZEHCHplhpPR0Ts3cW4\n", - "zIbBZOt591K9VfhOOAVmnZV2uGeUNao0Tk7/vpFxsxcDg3DP1azPFVjPu5dq9uQag1n56iKAfwf+\n", - "Ca7yRWA41U0aEfFAevjeiBi3FKukM4Gay7OaWXGTrOfdS+NulV0AvD09zveMyjV09/wWmvWHIuXl\n", - "n9fYN5BTHZhZXRtW4RsjSxj5cRf/zriEUdYtNOsDdUeES3oP8F6ye6535Z7aCrgmIo7pfnjFeES4\n", - "WftWSle/GA6A8TPSChbQH7fQrMM6Oo2IpG2AbYFPk92Kqpz4yYh4rJ1AO81Jw6y4ml1rYTGekXbo\n", - "dGvuqVcDt0XEE2l7a2DPiLi+5Ug7zEnDrLYaCeI6UhdagP8kKyPAa3UPo24ljRXAyyJifdqeBiyP\n", - "iH1ajrTDnDTMJqoz9uIZYAZkbReekXa4dWs9DSoJIz1ex8Qy1sz6T62xFzOOJlsGs2rOKK93YYUU\n", - "SRr3SDpJ0nRJm0k6Gbi724GZWetSlTEhAdwPfJXxPaNuAKbDZb2LzgZZkaTxbmB/YA3Z79x+wN93\n", - "Mygza13uttS2lX2vJqsudmTijLT7uQutNWHSNo1B4DYNm+pSIvg48MK0627go7W6vlYv7nQ/45MF\n", - "wO2w5v9k4zLchXaIdashfA/gC8D2EbGXpL2BBRHxidZD7SwnDZvKUsK4ANih6qkHgL+rvuCn1TYP\n", - "nMfGoeaVhPEHWLe5e0ZZ0q2G8POBDwF/SNu3AEc3GZuZte4kJiYMyAqIE2vs/93jZAkj33bxCfiV\n", - "E4a1q0jSmJEfkxFZaeIVucx6p96ysFC9NKy0ZD0csjUbq4tngE3gro/C27oXog2LIknjEUkbuu1J\n", - "+hvgwU68uaR5klZJulNS3QkQJb1S0lpJh3fifc36jaT5kpZKGk3/5ud3q7fuBuQnDkyr6eWri4/C\n", - "Y8+FpcBJbrewTijSpjEH+CJZB4zHgXuAYyLi3rbeOBskeAdwMFnPrGXA0RGxssZxl5F9YLooIr5T\n", - "41xu07CBVWcQ3mrg5NzKebXaNB4E3hnwHnJLryYe1W2T6mibRhqPAbBDRBwE/DHw4ojYv92EkewL\n", - "rI6IeyNijGxJ2cNqHHci8G3gkQ68p1k/qrcA0omwYfr0dwI/A36dvpaTJYzFkRJGZb2Lu+F2Jwzr\n", - "lka3pyrT6Z8DEBFPVeaf6pCdgPty2/enfRtI2okskZybdg1+/2Czieq1WWxor4iISyPiFRHx/Ih4\n", - "fsBDAT8MmFY97mIObFZ1e8usYxp9Grld0p3ATjWWfO3Ecq9FEsDngNMiIpQtcVa3jJK0MLc5GhGj\n", - "7YVn1jk1Z5bd2MbQ3FrhWdvFhql8gqwUf/PGIypVitswbBxJI8BIO+dotHLf0ZK2B35ENhFmp9sM\n", - "1gCzc9uzyaqNvJcDl6QlMWcBh0oai4jFNeJd2OH4zDqiTpvE3pLemRJHsbXCpSVUtV2sg5he+29z\n", - "yxr7bMilD9OjlW1Jpzd7jrpJQ9LlEXGQpB9FxC9airCx5cDuknYlG6R0JFXjPyJit1w8FwFLaiUM\n", - "sz73cSY2Yu8AfAy4tNBa4VXVRbJseta+cQgTeTlW64pGt6d2kLQ/sEDSJYyfhYCI+N923jgi1ko6\n", - "gaySmQZcGBErJb0rPX9eO+c36yMvnGx/3bXCa1QX5HtGZVXM5FWKWYc0WrnvCOAdZJMVLq9+PiJe\n", - "393QinOXW+tnkn5NbvLAnDHgL+uOn6hTXVRPX55uf3k5Vmtat+ae+mhEfKytyLrMScP6maTlZO1z\n", - "tWwYj5F7QePqwqxDupU0NgGOAV4YER+TtAvZ5IU3tB5qZzlpWD9LlcD5ZHNF1bI0Ig5NBxeqLsw6\n", - "oVsTFn6BbDT4W9L2U2mfmRWQqoi/I2u0rmVLpCVIwfiE4dX0rO8USRqvioj3knpjRMSvgeldjcps\n", - "ikmJY1mt58bgtUy8HbXMt6OsHxVJGn9I8z8BIOmPyBYBM7PmLCJrwwDgs2xYqzv/d+jqwvpakU8y\n", - "5wDfA/5Y0ieBvwH+patRmU1B+fEYY3DINFDVzWS3XVjfK7Tcq6Q9gYPS5uXVM9GWzQ3h1opJpvbo\n", - "1pu6Z5T1jVaunYV+UVOS6KtEYdaOOtORz5FE1xKHe0bZFFCkTcNsKmo4HXlHuWeUTSEuiW1YTTod\n", - "eUe4urAppnClIWkLSZt3MxizHmpuOvJmubqwKarRyn2bSDpc0rckrSFb5vUXktZI+rakv0prXJgN\n", - "onHdX5POTPSX1uqu2utxFzYlNJqw8CrgamAxsCIifp/2bw7sQ7bGxgER8boexVqXe09ZKzo+0Z97\n", - "RtmA6ejcU5I2rySKBm846TG94KRhpXPbhQ2gjs49lassPiNpr0bHmA0tt13YkCnSEL4S+KKkGyS9\n", - "W9I23Q7KbCC47cKG0KRJIyLOj4j9gWOBXYFbJH1NUt8swmTWLknzJS2VNJr+nd/gYFcXNrQKfSJK\n", - "Exa+GNgTeAS4CXi/pHdHxJFdjM+s65oaHe62CxtyRRZh+izwJuDHwAX5xZck3RERe3Q3xMm5Idza\n", - "IWkpcEiNp/KLI7lnlE053Zp76mbgXyLi6RrPvaqZNzPrU41Hh+eqi8pHrM/Aw6fA2yef7tNsapk0\n", - "aUTERfltSTsCj0XE7yPi8a5FZtYBBWeyrTk6/FMwO7VdAFnCGAPStAjbAWd3dYJDsz7USmn9ZbL7\n", - "vd+OiFM6HZBZpzTRVrEImJM/bgyYBrtVtgN4H3Du+LeoTHDopGFDo+lZbiPiILI/posmO9asZIVm\n", - "sk0J5GRg6Sfgl2k1PXI3etdtAldWJYyKzk5waNbnJk0akg6usfutEXFbu28uaZ6kVZLulHRqjeeP\n", - "kXSTpJslXSNp73bf04ZK4ZlsI+LSgDd8GHYR4xJGZdxFdyc4NBsQRSqN0yWdK+k5krZX1otkQbtv\n", - "nLrxfh6YB7wEODqtEJh3N/C6iNgb+DjwxXbf14ZKsQt9sXEX3Zvg0GyAFGnTOBD4ANnYjABOj4iv\n", - "deC99wVWR8S9AJIuAQ4jt0JgRFyXO/56YOcOvK8NjwltFVRf6AuOu8iv702nJjg0G0BFksa2wCvJ\n", - "/th2BnZR6tzb5nvvBNyX276fxl1434EbHK0JDS/0LYy7SAnCv4M21IokjeuAMyPiQkkzgDOBa4DX\n", - "tPnehZNOmrLk7cD+DY5ZmNscjYjRliOzKaPmhd6jum1ISRoBRto6R4ER4S+IiF9U7TswIq5s642l\n", - "/YCFETEvbX8QWB8RZ1YdtzfwXWBeRFTfU64c4xHhNjmP6jYbp6NTo0uaA1CdMNK+K/PHtGg5sLuk\n", - "XSVtBhxJtuBTPoZdyBLG39ZLGGaFSGufTAljPfAd4JvwcycMs+Y0WoTpG8BzyC7ky4EHyXoi7gC8\n", - "gqwH1ZMRcVTLby4dCnyO7FbBhRHxKUnvAoiI8yRdAPwV8Mv0krGocQvBlYbVlaqL9WSfkO4A3kZ2\n", - "z5WsN9TJbsy2YdXRlfvSCecCR5G1Jbwg7f4F8BPg6xFxd4uxdpSThtWUa7tYD3wW+Bcm9MPdOCmh\n", - "2ZDpeNIYFE4aNk6Ntov3MmEKkIorI2Kk6zGZ9aFuzXKLpEqlseH4iPiP5sIz64E6PaPOhV9Te/pz\n", - "j+g2a8KkSUPSV8jmmloBrMs95aRh/WOynlHZ5IWNB/qZ2aSKVBovB17SgcF8Zt1RYNyFR3SbdUaR\n", - "pHErWY+pB7oci1lzmhx34RHdZu0rkjT+CLhd0g3A79O+iIi2Jy00a5lHdZuVokjSWNjtIMwK86hu\n", - "s1K5y60NDlcXZh3V0WlEcid9taRlkp6SNCZpvaQnWg/TrD5J8yUtlTSa/p1fcL0LM+uBIiX958lG\n", - "hX+TbPqQY4E9uhmUDZ60HvdJZKvl/Q5Y1GzPpFprev8BDgnGraQHri7MSlPoPnBE3ClpWkSsAy6S\n", - "tAI4rbuh2aCodbEH5kiiycSxYU3vtwEXVs6/8Xm3XZiVrMgf4NOSNgduknQW8BATPvjZkNtwsc+Z\n", - "SzYm4lIoXIlsAfAHsl9MkS26kioNVxdmfaDIGuHHpuNOAJ4hW73vr7sZlA2cLers3xLGVSKHkC0f\n", - "fAhwdtq/wSdgl/WMTxjrgE1gqROGWX+YNGmkNbwFbB8RCyPi/V7bwqr8rs7+yrxO9SqRizckDmnt\n", - "h+CFlRI2gA8C0z3Vh1lfKdJ7agFwI/CjtL2PpMWNX2VDZhHZ2hR5+Yt9vUpk1onw1Ug9o3LVRWwC\n", - "V54JS4GTPNWHWf8oOrjvVcAVABFxo6TduhmUDZYC8zrVrESeAmbAzHwDmWDZphH7Dv7oIbOpqUjS\n", - "GIuIx9NFoWJ9l+KxATXJvE6LyM0w+ybg++mJSnUh94wyGwhFGsJvk3QMsKmk3SWdA1zb5bhsCkkJ\n", - "5WTg0afIEka+7eIL8KAThtlgKJI0TgT2Ipus8OvAE8A/dDMom3oC3rMeZs1gQs+ou06Ad5YbnZkV\n", - "5bmnrPuktZFr6AY4Hfh41oX7rIg4o7zgzIZXV5Z7lfRK4EPArrnjIyL2bjpCGy65GWnz1cX0jUfM\n", - "APYrITIza1GR+8hfBU4hW4zJDeBWTNWMtAF8GThu4pFb9iwmM2tbkaTxSER4XIYVU2e9i03gf8hG\n", - "gld7tsY+M+tTRRrCz5B0oaSjJf11+jq8E28uaZ6kVZLulHRqnWMWpedvkrRPJ97XuiSrLqoTxrLU\n", - "M2qyAYBmNgCKVBrHkU2Fvinjb099t503ljSNbNr1g4E1wDJJiyNiZe6Y+cDciNhd0quAc/E98P5T\n", - "YDW9AgMAzWwAFEkarwBeHJ3vZrUvsDrNbYWkS4DDgJW5YxYAFwNExPWSZkraLiIe7nAs1qpc20WQ\n", - "Df0+Cn67GH6KND+fFCYZAGhmA6DI7alrgZd04b13Au7Lbd+f9k12zM5diMUKqqys92NpdUgRuYTx\n", - "fbLuUIthG+rMZGtmg61IpfFqYIWke8gG+EFnutwWrVyq+xDXfJ2khbnN0YgYbSEma6AyxfkYzJ3G\n", - "+PUujoDffAe2rXrJuDU1zKxckkaAkXbOUSRpzGvnDRpYA8zObc8mqyQaHbNz2jdBRCzsZHA20RWw\n", - "6MBsDqnqcRdLydopDqzxMnepNesT6cP0aGVb0unNnqPQehq1vpp9oxqWA7tL2lXSZsCRQHXX3sVk\n", - "i0AhaT/gcbdn9FbldtRaKQ6EOfk5o37ChoF6WzL5mhpmNgWUNklcRKyVdALZOh3TgAsjYqWkd6Xn\n", - "z0s9buZLWg08TbZ0tPVAuhX18QNg7ythU1F3VDeknlDkZrJN3KXWbIrx3FM2QaXtYhnMfTkbkwXA\n", - "Gekr5y7SQknpde5SazYgWrl2OmnYBEdJD3wNdshXF7cBf7LxkF8Dt+DEYDbQnDSsfVUz0gbZaMpl\n", - "449aGhGHtnZ6zSdbM3wLsnaQRU46ZuXoyiy3NiRqzEhbVV1UtNxOUbntxfh2jzmScOIwGwyuNKzm\n", - "jLQL4NkfjO8u+yxZHjm91Qu8pKXUnrSw5crFzFrnSsOaU2fOKEVs+oPuNGpvUWe/x3KYDQgnjWFV\n", - "VV0ky4jYF7o2T5THcpgNuCJzT9lUIi1BCsYnjHVEqJIwusjTo5sNOFcaw2SS6qLbPD262eBzQ/gw\n", - "KLDehZkNHzeE20QlVxdmNrW4TWOqKrftwsymKN+emopqVBer4PY9swWtPBLbzADfnrJ64y6yZXPP\n", - "ZvzAOo/ENrOmudKYKhq0XXgktpnV0sq1020ag65Y24VHYptZR/j21CAr3jPKI7HNrCNcaQyi5ntG\n", - "eSS2mXWEK41B08K4C4/ENrNOcUN4H6q5UBG8J6rWu1gH6zb1qG4za5FX7psCai1UNEZWWuTX6l4K\n", - "zM9uOZ3sisHMWuHeU1PDSaSEcSKwnvEJYx3Zf9r87Ni56TAzs57wrY3+swVMrC6CDdVFNXebNbOe\n", - "caXRZ/4ddq5TXTxaI2FArtuspPmSlkoaTf/WeYmZWWtKSxqSnifpMkk/l/TfkmbWOGa2pCsk3Sbp\n", - "VkknlRFrz0hr/xHmVG4wBvCvwPSse+znadBtNtcWcghwYPr3bCcOM+uk0hrCJZ0FPBoRZ0k6Fdg2\n", - "Ik6rOmZ7YPuIWCHpucDPgL+MiJVVxw12Q3jVnFGpuojpcBW57rFqsG63pwoxs2YN2oSFC8g+EQNc\n", - "DIwC45JGRDwEPJQePyVpJbAjMC5pDLQa4y4EyzaN2Lc6nU+ybrenCjGzriuzTWO7iHg4PX4Y2K7R\n", - "wZJ2BfYBru9uWD3S+fUuPFWImXVdVysNSZcB29d46sP5jYgIZRfQeud5LvBtsjEJT9U5ZmFuczQi\n", - "RpsOuFe6s5reImAOufEdeKoQM8uRNAKMtHWOEts0VgEjEfGQpB2AKyLixTWOmw78APiviPhcnXMN\n", - "RptGl9fqbtTmYWZWbaBGhKeG8Mci4kxJpwEzazSEi6y947GI+McG5+r/pOG1us2szwxa0nge8E1g\n", - "F+Be4M0R8bikHYHzI+IvJB1A1oPoZjbOoPHBiFhada7+TRpdri7MzFo1UEmjk/o2abi6MLM+5rmn\n", - "+kXne0aZmfUF3yLpNFcXZjaFudLoFFcXZjYEXGl0gqsLMxsSrjTa4erCzIaMK41WubowsyHkSqNZ\n", - "ri7MbIi50miGqwszG3KuNIpwdWFmBrjSmJyrCzOzDVxp1OPqwsxsAlcatbi6MDOryZVGnqsLM7OG\n", - "XGlUuLqsjutpAAAKMUlEQVQwM5uUKw1XF2ZmhQ13peHqwsysKcNZabi6MDNryfBVGq4uzMxaNjyV\n", - "hqsLM7O2DUel4erCzKwjpnal4erCzKyjpm6l4erCzKzjSqk0JD1P0mWSfi7pvyXNbHDsNEk3SlpS\n", - "8OSuLszMuqSs21OnAZdFxIuAy9N2PScDtwMx6Vmz6uKNVXuXEdHXFZWkkbJjaNUgxw6Ov2yOf/CU\n", - "lTQWABenxxcDf1nrIEk7A/OBCwA1PONgVxcjZQfQhpGyA2jTSNkBtGmk7ADaNFJ2AG0aKTuAXisr\n", - "aWwXEQ+nxw8D29U57rPAPwHrmzx/31cXZmaDqGsXVkmXAdvXeOrD+Y2ICGVVQvXr3wj8KiJubKIE\n", - "XOdkYWbWPYqYvKmg428qrQJGIuIhSTsAV0TEi6uO+STwVmAtsAWwNfCdiDi2xvl6/02YmU0BEdH4\n", - "1n+VspLGWcBjEXGmpNOAmRFRtzFc0oHAKRHxpp4FaWZmE5TVpvFp4A2Sfg78WdpG0o6SfljnNa4m\n", - "zMxKVkqlYWZmg2kgpxHp6uDAHigSv6TZkq6QdJukWyWdVEasuXjmSVol6U5Jp9Y5ZlF6/iZJ+/Q6\n", - "xkYmi1/SMSnumyVdI2nvMuKsp8jPPx33SklrJR3ey/gmU/D3ZyT9rd4qabTHIdZV4HdnlqSlklak\n", - "2I8vIcy6JH1J0sOSbmlwTPG/3YgYuC/gLOCf0+NTgU83OPb9wFeBxWXH3Uz8ZD3P/jQ9fi5wB7Bn\n", - "SfFOA1YDuwLTgRXVsZCNp7k0PX4V8NOyf85Nxv9qYJv0eN6gxZ877sfAD4C/LjvuJn/+M4HbgJ3T\n", - "9qyy424i9oXApypxA48Bm5Ydey6+1wL7ALfUeb6pv92BrDToxuDA3po0/oh4KCJWpMdPASuBHXsW\n", - "4Xj7Aqsj4t6IGAMuAQ6rOmbD9xQR1wMzJdUbf9Nrk8YfEddFxG/T5vXAzj2OsZEiP3+AE4FvA4/0\n", - "MrgCisT/FrLekfcDRMSjPY6xniKxP0jWu5P072MRsbaHMTYUEVcDv2lwSFN/u4OaNLo9OLDbisYP\n", - "gKRdyT4pXN/dsOraCbgvt31/2jfZMf1y4S0Sf947gEu7GlFzJo1f0k5kF7Nz065+aqws8vPfHXhe\n", - "uiW7XNJbexZdY0ViPx/YS9IDwE1kUx8Nkqb+dvt2IFxJgwM7pt34c+d5Ltmnx5NTxVGGoheg6mqu\n", - "Xy5cheOQ9Hrg7cD+3QunaUXi/xxwWvp9Ev1VWReJfzrwMuAgYAZwnaSfRsSdXY1sckVi/xCwIiJG\n", - "JM0BLpP00oh4ssuxdVLhv92+TRoR8YZ6z6VGne1j4+DAX9U47DXAAknzSYMDJf1H1Bgc2A0diB9J\n", - "04HvAF+JiP/sUqhFrAFm57Znk30aaXTMzmlfPygSP6nx+3xgXkQ0Kud7rUj8LwcuyfIFs4BDJY1F\n", - "xOLehNhQkfjvAx6NiGeBZyVdBbwUKDtpFIn9NcC/AkTEXZLuAfYAlvckwvY19bc7qLenFgPHpcfH\n", - "ARMuqBHxoYiYHREvBI4CftyrhFHApPGnT4sXArdHxOd6GFsty4HdJe0qaTPgSLLvIW8xcCyApP2A\n", - "x3O34Mo2afySdgG+C/xtRKwuIcZGJo0/InaLiBem3/dvA+/pk4QBxX5/vg8ckHo7ziBrkL29x3HW\n", - "UiT2VcDBAKktYA/g7p5G2Z7m/nbLbtlvsTfA84D/AX4O/DfZiHLIGop/WOP4A+mv3lOTxg8cQNYW\n", - "swK4MX3NKzHmQ8l6cK0GPpj2vQt4V+6Yz6fnbwJeVvbPuZn4yTpLPJb7Wd9QdszN/vxzx14EHF52\n", - "zC38/pxC1oPqFuCksmNu4ndnFrAk/d7fAryl7Jir4v868ADwB7KK7u3t/O16cJ+ZmRU2qLenzMys\n", - "BE4aZmZWmJOGmZkV5qRhZmaFOWmYmVlhThpmZlaYk4ZZIukbaRqIds6xuaSrJHX9bytNJb4kPX7T\n", - "JFOmbyPpPbntHSV9q9sx2tTjpGEGSJoLPCci7mrnPBHxe+Bq6sy8XDCWpv8uI2JJRJzZ4JBtgffm\n", - "jn8gIo5oJT4bbk4a1nfSlA2rJF0k6Q5JX5X052lxpJ9LemU67jlpgZnrJf2vpAW5118l6Wfp69Vp\n", - "/4ikUUnfkrRS0ldyb3sUaXoISS9I7/N8SZtIulrSwVUxvk3SZ3PbfyfpM2lzMXB0g+/rK5JuT3Fs\n", - "mZ67V9KnJf0MOCJ9v9em+L8p6TnpuHkp9p8Bf5U79/GSzkmPt5P0PWWLAq1I3/+ngTnKFjk6M32P\n", - "t6bjt0g/65vTz3Ekd87vSvqv9PNolJRsWJQ9xN1f/qr+IlvwZgzYi2z2zeXAhem5BcD30uNPAsek\n", - "xzPJpnqYAWwJbJ727w4sS49HgMfJpmsRcC2wf3ruv8hNn0A2Pfo3yabWP7dGjM8hm3ZhWtq+Btgr\n", - "Pd4cWFPn+1oPvDptXwh8ID2+BzglPZ4FXAlsmbZPBT5CNvHmL4E5af83SNPjAMcD5+T2n5Qeb0K2\n", - "xsMLyC3Ck2K5JT3+AHBBerwH8Iv0PRwP3AVslbbvBXYq+/fDX+V+udKwfnVPRNwWEUE2H9H/pP23\n", - "kl3wAP4cOE3SjcAVZBe22cBmwAWSbia78O+ZO+8Nkd2aCbJ5vV6Q9r+AbDEdACLiQmAbsjl6TqkO\n", - "LiKeJlsl702SXgxMj4jb0nO/BzaRtEWN7+u+iLguPf4K2RxjFd9I/+4HvAS4Nn1vxwK7kF3Q74mN\n", - "t9C+Qu0p0F9PWlcjItZHxBN1jqvYP52LiLiDLGm8iGx67Msj4sn0Pd3Oxp+9Dam+nRrdht7vc4/X\n", - "k022Vnmc/709PKrWXJC0EHgwIt4qaRrwuzrnXVd1rg0X1jTT6s5kF86tgKdrxHgB2fooK4EvVT0n\n", - "aq9JEA2Oyb/HZRHxlnEnlF5a4z3qaXY9jXrHV/+8pjV5XptiXGnYIPsRcFJlQ9I+6eHWwEPp8bEU\n", - "u9D9Atght30m8GXgdLI1NirvcbmkHQEi4gayxPIWsplEK8dsDqxLn86r7ZKmnya97uoax1wP7F/p\n", - "yZXabnYnm4J7V0m7peMmtJsklwPvSa+dJmlr4Emy5FfL1cAx6fgXkVU1q6idSPppcScrgZOG9avq\n", - "T+lR4/HHgempAfdW4Iy0/wvAcZJWkN3SearGa6v9BHgFgKQDyRY1OjMivgb8QdJxqVfTHLIp1Cu+\n", - "CfwkNq4vDtnSvNdR2x3A+yTdTnb7a8LyrBHxCFl7wtcl3UTW9rJHSkJ/D/wwNYQ/nHtd5B6fDLw+\n", - "3Z5bDuwZEY8B10i6JTVo54//AtnttJvJ1sA+LrL1sPPHbAivzvdlQ8JTo5sB6dP7ORHxFw2O2Qt4\n", - "W0Scktu3BPhMRFyR2/dJssb371W9fldgSUT8SYfDN+sZVxpmQETcDTzZaHBfapg/BUDSTEl3AM9U\n", - "JYzNyRq36y3P609pNtBcaZiZWWGuNMzMrDAnDTMzK8xJw8zMCnPSMDOzwpw0zMysMCcNMzMr7P8D\n", - "4kiXLbZ2HmUAAAAASUVORK5CYII=\n" + "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEZCAYAAACQK04eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4VNXWxn8rPZDQkRpaAggExYYCUkSlBLALNryKon4W\n", + "vNar3quTY73Wa1fEjqigWFABUQFFBESUKi2hhQ4hQAgJELK/P9aeZDLMJJMeYN7nOc/MnHNmn33a\n", + "2muv8i4xxhBEEEEEEcTxg5Cq7kAQQQQRRBCVi6DgDyKIIII4zhAU/EEEEUQQxxmCgj+IIIII4jhD\n", + "UPAHEUQQQRxnCAr+IIIIIojjDEHBXwaISJ6ItKnA9nuKyIqKar+iISLrROTcqu5HVUBEokXkGxHZ\n", + "LSLj7brHRWSHiGwu52M9KCJjyrPN8oaIXCcis6ro2K3suxpif08WkeGVcNxkERlb0ccpDY4bwW+F\n", + "0H4RybTLXhFpXIX9SRaRQ7Yfe0VkpYi84tknY8wsY8yJAbZVHR8wY5cSw96vvuXcn8rEZcAJQD1j\n", + "zDARaQHcDZxojGla2kZFpI+IpHmuM8Y8ZYwZWbbuHj8wxiQZY4p9X8rhGay2SVLHjeBHb8JgY0ys\n", + "XWoZY7ZWcX8+McbUAuoCFwONgQVVOSBVIxhAqroTZUBLYJUxJs/+bgGkG2PSq7BPxwREJLSSDnW0\n", + "P4N+cTwJfp8QkQ9E5G77vZmdEt5qf8eLSLrHvveJyGYR2SgiI8p6aLtgjDlsjPkbGAbsAO6xxyuk\n", + "3YnIv+yx94rIChHpKyIDgAeBYXYm85fd93oR+dvumyoiN3m008e2c7eIbLPndJ3H9mgRed5qPLtF\n", + "ZJaIRNltZ4nIbyKSISILRaR3MefZVUSWicguEXlXRCI9jjPYtpEhIrNFpLNdPxYVlN/Yc7pPRN4v\n", + "wX3y2a7d1lREJorIdhFZIyJ3eGxLFpEJ9pnYKyJLReQ0vzdQ5EQR+UFE0u39uNyud4CHPe7JTcA0\n", + "oKn9/W5x11JE6onIeyKyyV67L0SkBjDFo529ItLEc8YnIlNE5Davfi4SkYuK6rOf8yvLM1RfRCaJ\n", + "yB4RmQfEF3EctylmpD3fzSJyj9d9+VxExorIHuAfIlJbRN6RgvfxMSkw5YSIyHOiZrVUYJDX8WaK\n", + "yA0ev0d6nOcyETnFxzN4bwD3rLWI/GzbmQY08HfOVQ5jzHGxAGuBc32svx6YZL9fBaQAn9rfI4Av\n", + "7fcBwFagI1AD+BjIA9qUsj/JwFgf6x1grv3eB0iz39sDG4DG9ncL97EBF/ChVztJQGv7vReQBZzi\n", + "0e4h24dQYKDdXttufw2YDjRBlYOzgAigGbATGGD3O8/+buDnHNcBi+3/6gK/Ao/ZbacA24Az0AHw\n", + "WnuPwj3uV99S3Ce/7dpzWQD8BwgDWgOpQD+Pe5Jt77UATwJz/JxbTSAN+Idttws6aHfwdU+A3u57\n", + "aX/7u5b17e/vgE+A2ravPX21430sYDjwq8e2jkCGPf8i++zjHMvyDH1ql2igE7AR+MXPcVqh79I4\n", + "u38isB37vtpjHAQusL+jgC+BN+z+DYF5wE12+y3AcgqeuxnAYSDEbp8BjLDfL7d9O83+jgda+HkG\n", + "i7tnc4Dn7LXuCezF672sLkuVd6DSTlSFUKZ9CTKALzxu9C70RX8DuIkCYfsB8E/7/V3gSY/22lIx\n", + "gv8W1ETgfrncfUlABdq5WOFYXFte+3wJjPJod7/7RbDrtgFdUYGwH+jso41/eT/IwFTgWj/HXOt+\n", + "Ge3vgUCK/f4G8KjX/isoEHDeL12g98lfu72AM4H1XtseBN71uI7TPLZ1BPb7ObdheAkyYDTwiK97\n", + "4nkvi7uW6IB7GCtEvfYp1I73sYBYYB8QZ38/AbwdSJ8DeGYDfYZCUUHdzmPbE8AsP+22Qt8lz/2f\n", + "9uh3MjDTY1sjIAeI8lh3JTDdfp/u9dydb9v3Jfi/B+4o4vn1fAaLumct0IEw2mPbOIp5L6tqOZ5M\n", + "PQa40BhT1y6XABhjUlFNpQs6Sn8LbBaRdqiw+Nn+vwmqLbmxwd+BRKNx3E7kJSXsZzPgCDuwMSYF\n", + "+Cf6EmwTkU9EpEkRfRgoInPtlD4D1d7qe+ySbgrsz6AvcQw6PY1CNWFvtAQut9PcDNtuD9Q34Q/e\n", + "18zt2GwJ3OPVVnOP7YVQgvvkr90mdltTr20Pok5YN7Z5XZMotwnBx7U406utq1ChFAiKupZxwC5j\n", + "zJ4A28qHMSYTnS1caVddgQqgEve5DM9QQ3SWEtD74gF/zwqoVu5GS1Sr3uJxHm/a40IJ3lX02fD1\n", + "rPtCUfesKZBhjMn22H99gO1WOsKqugPVBD+jU75wY8xmEfkZuA6dJi60+2xBR3U3WuAHxphZqOZV\n", + "FIz3CitghqD2YF/tfgJ8IiKxqKb2NKptFGpL1I4+EbgG+NoYc1hEviQwR9VOVJtKQM00ntiAajA3\n", + "HfEv//C+Zps82nrCGPOkn/8dcX0I7D75bVdEzgLWGmPaleCY/rAB+NkY06+Ubfm9lnZArycitX0I\n", + "f1/teq/7BHCJhk9GGWNmBNhnzz6U5RnaAeSi93ulXef3ffGA9/6bPLZ5nmMacAA1sXgOPG4E/K7a\n", + "thL8bPO+rkXds5ZAXRGpYYzZb1e3RGdu1Q7Hk8ZfFH4Gbgd+sb9n2t+zjJ2zAROA60Skg6iTzVXG\n", + "Y+a/QCISJiId0Bf2BOCFI3YWaSfqzI1EH/ocCh6qrUArEXG3GWGXnUCeiAwEin3ZAeyL9C7wgqjj\n", + "MFREuolIBPARMERE+tn1UdbJ16yIc7xN1BlbD/g3MN5uGwPcIiJdRVFTRAaJSIzdvo0jHYKB3Kei\n", + "2v0dyBSR+0Ud2KEikigip3v0N1B8C7QTkWtEJNwuZ4iIO/y2uLb8XktjzBbUifu6iNSxbffyuC71\n", + "RaSWR1vex5qMCh0HtbMH2mdPlOUZOgx8ASTb69wR9SsUNxj+x+7fCR3Qx/vayV6faegzGivqzI33\n", + "uEYTgFH2uasLPFDEMd8G7hWRU+3zkiAaegtHPoNF3bP1wB+AY6/r2cDgYs63yhAU/Ipf0CmqW6DM\n", + "Rp1G7t8YY6YCL6L2w1XAT5QtTtdgoz6A3cDXqKZ0mikcZuo+RiTwlN1nC2qSedBu+8x+povIH3a6\n", + "Pwp9AXah0/6vfRzfH+4FlgDzUbPTU6h9dCNwIfAQ6nzbgEYg+XuODGpmmIZOp1cDjwMYYxYAI4FX\n", + "bR9Xo7MXN55CBUGG2GgeArtPftu1g9pg1Fy0Br2WbwFuIWp8XBef18kYsw8VhFegmukW2+eIQNoK\n", + "4FoOR23GK1ABNMr+bwWqIKwRjfZp4n0sY8xBVPCeiwYhBNpnz/Mr6zN0O3qvtqKKxLtF7OvGz6jT\n", + "/kfgWWPMjx7H8T7Wtbbff9v+fUaByXEMartfhArjif76aoz5HPU/fIw6Y79AZ5Dg9QwGcM+uQv1I\n", + "u4BHUN9TtYQUKEql+LOGpQ0CthtjOvvZ52XUqbcfuM4Y81epDxhEEEEccxCRVuhAHObHdBNEOaOs\n", + "Gv97aOibT4hIEpBgjGmLRmG8UcbjBRFEEEEEUUaUSfBbJ2ZGEbtcgJ3uGGPmAXVEJNCohyCCCOL4\n", + "QVnMpkGUEBVt429G4bCqjWj4VBBBBBEEAMaYdcaY0KCZp/JQGc5d74iD4MgeRBBBBFGFqOg4/k1o\n", + "MoobzSkcmwuAiAQHgyCCCCKIUsAYU2IiuYoW/JPQsK5PbfLMbmPMNl87lqbzRwtEJNkYk1zV/ago\n", + "HOvn11IkZT3EZ0ZA51thzCQ4fw0kwdTJxgys6v55QhypCbRBk5Li7af7e1PU9JqKhk2mAKm8TH9G\n", + "ca9xmeyBIlOnQH/vdqvjuQaCY/3ZLK3SXCbBLyKfoKRRDURZJF1oKjXGmNHGmMkikiQiKWi6/fVl\n", + "OV4QQVQFdsC8kWDGHCRh9Ddw0xDo+QZrNhzklarojzhSh8IC3fOzLhoa6RbuS1COnRRgg3GZQ0e0\n", + "lyynGpdSDaTByyMhfoxHNuuNkLqBqjnXICoGZRL8xpgrA9jn9rIcI4ggqhrZsHoOjEuCO2JSic7a\n", + "TsKEG1ia87qZXBHHE0cEzeD2JdgTUOXKU2ufjUbPpQKbjKv0TtKlxkxOFCEJ7oiB6H2QvQFeWWoq\n", + "5lyDqBqUKYGr3DohYo5xU08fY8zMqu5HReF4Oz9xpB6qSQ81LjO7VG06EoL6vLzNMe7PA3iaYwp/\n", + "7jCu8ntxj+X7V97nliiSFAejYiEqE3LS4OWqHBRLKzuDgj+IIEoBceQSlK+/i3GZHD/7hKOUw760\n", + "9lZoar8vwZ5qXGZ3xZ5BECVFokhSN3jJ0ww2ElLmwJ1VJfyDgj+IICoZ4shnaJ2H9/HtTHVHsRV2\n", + "purnGuPKZ3EMoppDHJFeLzE9uTZ9VtWHbTHwiCUCr0rHd2llZ5CWOYggioE4UpsjtfZ4oB1aVP0y\n", + "YBkq0JcD36ACfp1xmYNV0ecgSgfrOG/na5lzExGPbId26XDizoKCvDFKFHhUISj4gzjuYZ2pDfCt\n", + "tSegL7anOWYeyjqaika13Q1c7CtiJojqB3EkEr2vvgR8TZR917186/5+7tN86ivUdZ+W66w0ePoZ\n", + "SttG0NQTxHEB60xtiv9ImVwKm2I8v2/z50y1g8Z3wG/GZR6v4NMIIkDY+x2H1qr2Fu5N0epYq7yW\n", + "lcAWf/fal43/RkidC6Mqy8bv3QehdDlQQcEfxDEDcSQMLUDiS7C3Bvbg35m6y1ebgURxiCNxwJ9A\n", + "b+Myf1fM2QXhDTvo1se3cE9Aa0n4Eu7rSjs7SxRJalGFoa7uBLu3T4Vz10Cb3UHBf1xDJDEJ4kZB\n", + "bBRk5kDay8YsPeZir8WRKFSI+wqBbIEWF/EW7G5n6r6SHKskURziyC1o1agexmWqZbm90qKqQxht\n", + "NnJbfJtmQlBh7i3cU0p6v48GDBWZ+YnQu9F98Neb0GJv9aRsCKISoEK/20swxqN26Mh4kUSORuEv\n", + "jsTiW2uPRxObNlAg0FejZQpTgbXGZQ6UVz/iYNQYSMgOg/Qa0HwvjIGEJLgDLW/oibfQylajgP+V\n", + "Vx+qGn4Gv/hEEcpT+NvZWit8a+8N0PvrFuwz0ZrTq4Cd5ZnTUN2RCTm/N4NmeyFub+nbCQr+YwJx\n", + "o2BMAs3nQMeJMP0xyB2TAEm+BFSVw07R6+GfdiCWwlr7ArT+aiqQZlwmtzL66XaefZ8Ao0+DKeN0\n", + "va8oDuMyeeLIjcBccWSScZnUyuhjRcM9+L3QDVrsgcv+LnLwKxL2vjfGt3Bvhc7W3ML9b+ArVHtP\n", + "O9ZmUaVFGrx8U0e6Dl6dXx6yVAgK/mMCserd39UWam2EW06Br96DjTFVFmZmX/Im+HemQmFzzAy0\n", + "8HUKRTjYyq1/AZjGMrWgPWduhBsuKAjf8xfFYVwmRRx5Chgjjpx7LGiisRC1owY82RPmjSlYX1QI\n", + "ow1/9RkSiV47T7PMb6hwT/WXCBdEAZYaMzn0AcmI/JJVqfp89i5NO0HBf0wgU1+Y/Q3g80+h4+cw\n", + "7BJICW0hjkS7CbjKG3Z6HofvEMg2wD4K29m/8fi+q6IEY3FCPVDTWD5h2T4Sah6ClHrw9K5iCcte\n", + "BIaiBd/fKv+zq1xkQs5jveHqxRDvUWtvTxg54khHfAv3WAoL98mo+Wu1cZmiKvYFUQzEkWZEU2fB\n", + "VbT/w2VyS8vOGXTuHgPwKchirlrLDZ9vpO6hhsD1xmXmlqptjXlujW+tvQWwHf/O1DJYIUsHP0I9\n", + "Bebc6RbqIgOnwuT+DLkZtneCTV1h6ymQe8lUYyYXysB0R3H8OZzT6q1ic8g8HirOti2OdELt0KcY\n", + "l9lY7idZSRBHQurP4t49XXnqsV8I2RILq+rDrIbkZtXCEMI6jnSqrgI2HwuzneoIa07sa1zmKghS\n", + "NlRLVGY0hAq8po9CbBs4YGDPLpA9nLY/mvMWJZARNommOcN9Tadt1IQ/srAmKIe7rxj3tRU1mygt\n", + "VKhP6U+bH2FrF50FAZCUL9RFhs4k5OPenPQRNJsHzedB/ZWwJzSThplj0QSteaiGmgcgjtzHtsiz\n", + "eeOcyEAip8SRR4CuwJDqLgTFkaJCIpGD7DkhhUP1dnIwLJ3d6cLozRfxfjBhrfIhjnwJTDQu8xEE\n", + "KRuqHSorGqIwWtaGMW6nTz34NyzoDytOhItPHcjBzevEkVftdk8BXwflcHcL9EXAFxTB4V59ERuF\n", + "HIZuL0DcbMhsBut7wvYtLcWRFsZlNkBmDnlhsPA6XQDC90O9Hps4FHsuYVGXU2NPDGctPyyOzAHm\n", + "8dMJZ3LiwXPhzBDN9eoHjC0qcuq/wB/AVWiWb5VCHKmB3mtfAj6MAm19JfCZ/V4HGGsiaLd1fJBX\n", + "qKphZ999UTNi2doKavwVA3eixe4oeOhcdQwaga9qkLatI1NRP6GvhSK2+d/3rW5ns/m3RjT8G5rO\n", + "h3opujT+DurlAHlg8g4TZgTYi5KH7UedbQfLpQ/lt2/p28wOq0te3QgwIAZCciHkEIRlG0Lss27I\n", + "43BICHlRYnMfISXM8MMAyBhf8BzWHQYDJh9GCOGHfsLIqfD0LjgcCfwb6A/y1A8mb0q/I58AEEdO\n", + "R7N6OxuX2e5rn/KERwKbL+HeEB3cvc0yq/BB82yd8zOBD43LvFPRfQ+ieIgj5wGPGpfpnr8uqPFX\n", + "L7hDAcMPQ6J95cXA7GhytnVkAXYsYEVsImlN+pIXFY7kHKL5lh/omLk4f3vxC4Bhb/0OQCNazYC4\n", + "ObArAVYnwboVcOhOyKkPUY8v55Lf/wv8H+qUfQsVAP7bLUkfym+/0u87oVlfdnZ/jLwXW2Pc48Gd\n", + "a6kz9wFuWvMDkIDQjb2hlxB+qCthJoztsRn82OkQGeObEZ6l/zlUAzLGwycDf9KmJ/ZjVxdovEh9\n", + "AjwBPAxxOeeKI39SYB76HVhhXCbPuMwf4sj7qDN4mO8npWSwArkRvoV7a2ArBQJ9OfC1/b6hhCGR\n", + "g9Cs2A/Ko99BlAsGUU7h2UHBX0FwhwLWPAS3zi9Y/w2kLvnFjIZ8R+T9Xo7IKJjzY0kTryR54A1A\n", + "R+bfBvNvK9jQ+g3YOgSy6wNvbDSLzDhx5GNUEL0EvAM4JUl8qtZZwi7GiSRmwHV3QEw07MuGDa+Y\n", + "rFR3/+bb5WUAcaQ5LTN6ElLjOQDip8GFI2DFxbDoWthQI5q8UK1ota431FlnBT9AKKRF/oiWHD0T\n", + "tf/8B2ggjvyBDgJ/AJeKIxcZl/kq0NMQR2rhPyTyAIU19w/s99Ty8LnYmcPTwL8qK2ciiIAwiPJS\n", + "IIKmnopBIIRO+Y7I0AOaa7XxLEjrDjvvmmrMlBLxe/uOZnkIBk+EOZMg/dlUmDuqUFijI43Cd/NF\n", + "mOGkrl+zKnodO4pzQAcSNVN432o6QHgh/14AxGyBzp/AyR9CzHJIbZDDL9OjSG/v9a+L9kPK5Uec\n", + "tyMNUMduV3RA6I6yPn4L/IoOCAuAQ7jpndfWuICcmH7UPhhLnawoog5BCCs40iyz2h+vUHnBRo5c\n", + "A5xT3R3TxwvEkbbAz0Azz3sSjOqphiiO0Elk6EyY0JvwLOjyPsT9pkv0xlyicqeiyS2/AfMDKdqh\n", + "graF1XR3x0CO4f8Wt+PHhL9ZnfOYt4BKFEk6C17q25mEu/rDjX/C5l9InZ/rMTg5EoMKp7ZAAitO\n", + "uJ2oE5tRdy28lAp54ba1pEKhkCUZIKoDfPf3xlR6fPMaJ+25mBg5m4yThUXDYekVcODuXOJ+/pLr\n", + "199pXGaL33aVJbIZ8C5qf89CTTK17C6ZZIbtYmVCfbbeGUt6O0hvB5nJKZi5R1yrio4UsxFeK4FL\n", + "jMv8Xl7tBlE2iCN3or6iGwutDwr+ow+FtExP1O0zgzt/fg3VFLsDJ6Ep7O6B4DfjMmkBHcORb4Ax\n", + "xmUmeW9zO6D3RcDcZvDQebChNhzcybaMVqyicMTPaiCFHztfwKYX25HeFvY2p8C/OvRnYyb0OeLc\n", + "+rhg8TWaVQx4DxDVCYUHTmsicsf+R3YYTPtIF523taDVjvrkyEZq5W6ngAVyHrAWdZx7FvNIQFlB\n", + "U4EuwMeo5r8WFf6nMbr7A2yZ3ZTQA9BgJWw7STsU3m+mOTjtHHf/fM0iR8D+jZAaCptLOgj4GkSW\n", + "JXMKcJJxmRKbFKqazO1YhjgyDXjDuMyXhdYHnbtHI9JehpHxR2iZGTufMy4zGZgIuBkpT0MHgSuA\n", + "l8WRg3gMBMBCP2GXO1GSqyPgdkB3u0EjjhLSoWEWfN+KBsAPKNvkOncsO4AkD+wMfdsd2do+L9uy\n", + "pZGI3AsnfQQzHbu+6mgkioMV8j4FlTmw/Ftx5CdU6HYhgouAHmiWag3UWZ6FXtPDwFKUPO5rYJ7l\n", + "8unHQRnLC33bkFMv3G3+gmargaY0/BuuGQCLh8MMBxof6iGObERNQ/POqcml/80jYU592BcB56+B\n", + "d6HGw9D5MehcknBhn6ZIod2G5dTP7MCpJb12VRO+fHzAzrrPAi4trzaDgr8KYczSySKJqIH/SC0z\n", + "fz9NupptF3dkRxsKZgQjgHhxZAEFA8Ec4zI7KULwux3Qi98o0NsB+tThl5//SW2UJOu6RJHGbk3u\n", + "HMJi/+C8zZn82LTgHzemwgYvGgNLI7HkarhsGMxMRo/iPUBUL4gjofgPiWyEzn7cNvfJqIZ/KvpS\n", + "GuBD1BYbD/QE3mdFbFNp3i2bjF659NtUn3M6nMcU9+UaGQ8r9wCaPfz6UhgwCu5oC6tD0tB8iq7A\n", + "nbPuoHEboH069F6ngh+UlxhKRp7mJl/bWEtZRwHeNrReMZP1v35acoI5d3ufJELjfXDOutKTuQVx\n", + "BM5FlYfM8mowKPirGEVpmX7/4zJGJLE9xF1tHadbqLXmMe5etQcdCG4HPhJHtgKZwA5x5Dtguaf2\n", + "ngZzRkDPd1VjBdQBvXM3z6Ha6jWSy/SQ8zn89XTqRRwGyOU6pm/5ipP+2MOJWf4Gq/zZzOa3EsgL\n", + "h+ZzYeM7PgaIyocdOE/At3BvA2yjcELTN/b7eu+QSGveOCUGNq+LJ3JJP8460Ii7gCXAh7wWP4Wd\n", + "fZ7DvN0K/gNT74FbE2HZMNhwNjAmgXo9N9Gz3R5qt6hN/VVQYwfsD8nllP1N0UiOt4A/erzOozP2\n", + "co73vH59LXT4IfD6r7EQtT8ceozQouE3/KXrG+1kUwkuZaH2AP5oCk2s4C9Jf4IoEuUWxulGUPAf\n", + "hfDpiNw7Mp7k8DuNWeqA1Vw/bnEze5v/m7DIjoRm/U635XniyK/Ab/V/I3dQJMOvO0CNh4FQYCHs\n", + "T4GxHlPzsb3ryYhaA+jTdSR887FygL+PaZLEkkWTzWK/tvqC2cygO1iddyJnXRLC5/VHVaZj1/L6\n", + "t8W3gD9E4WiZsfYzJdCQSLd548VwEmocAkmFkW+QMqsmI1beRyhwLSPXDWbl/jA2/Q9WroWMujD5\n", + "Vegw0Qp+IDasKZ1SdrAxfRvzm+5hcZs09u58geRlM4GHgYeA/2zfx/M3QZynOeUh4HoPRqRA679m\n", + "Qk6NQ/Djh3D+tbA7Cu6ZA9mHKRW/knv2GHMQssIL1ld2PdpjDVZJSQKeK9d2g87dow/5jtMWs9QR\n", + "eKC23eLJR+NjcJAb13LGdx+RtDUydisj8+pRt206dE+Dl6dAqIEkmDrZmHyBPlRk5njo/UUHGLIK\n", + "Iqy+OxR+nmBMn4D660gb1PnZtLzpH8SRCDRKxpdwr406pb3L7602LpNe1mO7neMjh6jgfP07aLi/\n", + "8DWU2CGz6TCgO11fhRrrYNFtmh+wrTP5BjYZMA3X90+gpqGeQDc0s/oXYBZKhPcokNvyI8Z1TOHC\n", + "KGiWB/F3Q41etj8lqf/qaZNPq6XCP3wVGXk/cM2yvJLb5N3tte1Bwo4a8OwPlV+P9liEOHIy8Llx\n", + "mbY+twedu8cTrON0yM0w4TPY4Rb8no5TW5zlxK8gtZ9mopq3W/N70hlm3uSBQ0XO/CiU3n81hiWN\n", + "VOjDkVPzTMgR4NLlhXtQEk3OuMwacWQl3zV5SJIHditpXL9HoXRfwj0O2EiB9v4XWrRlFbDJ07RV\n", + "3nCbN16ZAg+fAyf/nwr/mBUe13BfbmZ+Ul2DsXDSm3DVBMiupwPA0vnryNz4knGZX1BB706gOgno\n", + "BVyCDgbZwNb11/Dsep2dXNwpmb7/hTteLUX916XGTE4UYSDccagm3ep+yebfryEirzsDxZGpJb1u\n", + "7vZmhvHsgdrUWQaLK7se7TGKcjfzQFDwH6WwjtOo3R7aPhRynEZH1GTgNdBkgc4KMtrYDTo4ZEJO\n", + "xGE4c5Mu+S14CfR8TnqvRLRiOOmPxPSGC1l+zr0wLqZgZWEOfHGkLirMvQV8W9SK7WmamWE/1xiX\n", + "OViivpQT3OaNqFzVcC9aAdddBHtOpa04Ule55z0it3YOh+ktYcbz+4nfsZXTn47kvO0NCOV2W7zk\n", + "a+My+2227J92edFO99uhA0E/4B/ATcuSmbNMnb+z0KiuXAg8cW6pMZPtoNoCOJmCJLP3xZERJc3a\n", + "te01AM7f8JkZXqqLGoQ3BgFOsXuVEGUW/CIyAC0+EQq8bYx52mt7A+AjtORaGPCcMeb9sh73+IYV\n", + "JpF7EsipY9cVRNaII724LeJ0/r4R3lqg2n4+dHAIVKC7NbmkIhLRAsLsUzpweFwMoQeg/mqlQa7f\n", + "JoG4SW+JI+tRwRZJYeH+JQWmmUrn9i8O3tewRxp0H82a8TewDFgsjow0xhwZuWU2vGJW5w92NYCL\n", + "UGH+ujjyBRoZNMutddtMzZV2GWP/dz3wLHAzcBPQTByZy6/1txI2pC+57zUr6Knv+ss+qBn2iCP9\n", + "0TDiz8SRK0tRFWsfOoBUOY72vAJLl52IRomVb9tlsfGLSCj6MJ6H2iTnA1caY5Z77JMMRBpjHrSD\n", + "wEqgkTEF2kTQxl9ySHSHIdy/4msevewXyMqGDa+QvOxHIBm4jvl1R/PdpdcckSPgQdtQXGZxufbX\n", + "naXc5kcYOIr8DNWsqavot2QkKuC3HW0UAf6uoTjSF83W/QG4J5CBSxxpitI4/wPNDxgLjDUus8rP\n", + "/rHAY2huRzKwmdfPfonts1oRlg2hBwtmhKEDfjK5U8/z+v8NwLVAn0I0AOo3+QglabvQuMy+QK+H\n", + "HTjuMS793yN2AAAgAElEQVTjk7G0suD2OYwWEtykrCMhZQ7cebQIf3HkKmCYcZkL/e5TRTb+rkCK\n", + "MWad7cSnwIUoK6AbW1B7JWimYrqn0A+idGjdcEXNDYfIvYTPyQRZfArNN2v8/hagi/l213aRxPmQ\n", + "dAdx2eexOeIXDm963lPrsy9AJb0E1jy15jx47W+P9UvXmNmLf6mcPpQ//F1D4zLTxZGTgOeBRdZ0\n", + "MqOotozLbAaeE0eeR00v1wK/iCNr0VnAeE+eHhvX/U9xZBwa8rmDjAbbgFa0+w763Qtfvwtr+0Kz\n", + "A33EkYWoWWgWSh7noNQMxqsfB8WRK4HRwI/iSFIJ+IH2ATHF7lXBiINRr4eQ0PM6eHsSdNh5VOYV\n", + "DEJpvcsdIcXvUiSaodWZ3Nho13liDNBJRDajBT7uLOMxj3skiiSdtp//tthP+HjofeHp9E8/n9dj\n", + "VjIHuMDN/W7M0snGTB7IDTPX8vC026qWIyftZZ1xeMJX4texA+Mye43LjARuBcaKIy9b005x/zPG\n", + "ZRYal7kbaI5q9b2BNeLIRHHkQquVu/efD5wBTKP5Js26/fsy+PZNuOgfOsPaGjYDuAXYgBKwLUWj\n", + "nm4RR64XR+KtLwGATsn0759M81Z/0ix6F+tbtZGrAzztamHqiYWoZ3pArQNw4s6C9UdLXoFNJOxP\n", + "BQ1SZdX4A5mWPwQsNMb0EZF44AcROdmY8stCO94QB6MeiKDliANwwZWwJRYWvUPoXekkTPZtu/Ob\n", + "vVsR8OdcFEmExj1Gk1P7ILtZ5Tvx69iDcZkpVvt/GVgojlxnXOa3AP+bi778k60D+DLgbuBtcWQ8\n", + "OhOYb/d7Tt5ps5PYq14j8+MapAyANxbDBafu454NHWx7z9oaAcvRGUUr1GH8OCDiyKyY1aSf25RB\n", + "X2yhhUyCJ3vCfy/kvbhOEp62rFj/XLXQ+NOaETq9G/w5unBW+lGUV3AmGpVWITWbyyr4N6HhdG64\n", + "Q+s80R2tWoExJlVE1qJRG3947mR9AW7MNMbMLGPfjlnEQtSeKKiXDReuhGsXaXx9EdrMTtReW+Eo\n", + "yB8YngDT0EcsoqdI4jPGLHXEkWuB/xmXqZZEbRUFayq5Rhy5GJgojowFHimJ89S4zB60fsI74khr\n", + "VHMfBxwWRz4EPjIbzPsS0nE7tc55ktrSgYMHt/J9xL3clZcHfCWOvItq+h9bPihQp7Kg+RA9a+Ty\n", + "+PJLaF6/pmbgThwPtQ8Qfs8g3hBH5hmXWX5E5wqQRRULfnEkNPRqGp42ix0t9tDQvb5U0WhVB59m\n", + "HhHpEw0jG8KZEWWQ32UV/H8AbUWkFbAZLRJwpdc+K1Dn72wRcVcOWuPdkDEmuYx9OebgT3POhJzd\n", + "UVD7gFIpu1GENlOJGn/cKBieQOhXcPgF98oaMOJ+kcT5JDMVqC+OJBqXWVo5fao+MC7zpc2efgNY\n", + "II5ca1xmQSnaWQs8Jo48jhJ4XQv8JY4swsWHsLwn+n4/DfyPKY0/YMFJy2mz7xYu+b0OPzV4EFeh\n", + "9gz6Xq4ZKnL9BGi+NQaWNVSN+fbf4W1h3aKBTBdHBhfR5+qg8Y86XINtmb9zTxLcXhnBCxWAQcBt\n", + "3is7QY1u0HWMckFR2oiYMmfuishACsI53zHGPCUiNwMYY0bbSJ730FjhEOApY8zHXm0Eo3q8kK85\n", + "h72cwOFIMCG4+ew7sYzaZ/BeQjNO+MDWdPKXJZkokrT7Ql6LySKv9Y+sruiQNo3eadcbHoczXoeD\n", + "MZqoBLgzi8WRp4E84zIPVlQ/qjushn0F+u68CTxR1nwEW4x7MDoI9EZj8j/kq6ZdWNPrMfZ+EsFl\n", + "wzSvY8mSw5z+00ecvfNG73h9d0ayd/tJMHVKMqNRR/JlNunMuw8hKB1GeEUmz/mDOBKPZol3My6z\n", + "urKPXx4QR5oBi4ETvLmhPO9NZgTUOgilkZ1lde5ijJlijGlvjEkwxjxl1402RssLGmN2GmOGGGNO\n", + "NsZ09hb6QfiDzbzt/hxcnaTEXYxJgBZ3LDVm8qIT+eqHENYPhZ+TYKo/od8NXrpjJ62GCG2mQP9u\n", + "8FKiSFLF9TszJ38iufYcOP9+SJhqt+VnFn8EXG2FxHEJ68D9BDgFpdyeJ450LmObB4zLTLThf22B\n", + "ucDj9NvxKGfGRZD4MbSYDXPvgt2fhrIiYTDwqzhSqLSYzU9I8VznNpPY8pFXAp+Lc+RzZIV9Nh7E\n", + "f5UFO5iOAf57tAp9iyTge181kmMhantNuGUwdLvRxz8DxHH74lV/WFqGXx+ELafAzadCi19xC8+s\n", + "eLZsOYkPJxjTZ7IxA31p8W6q3Ab7Id2+hmMgoYWGtFUQ0l6Gv7Ra2M4OMP4LuHg4NJ2PO3nMuMwS\n", + "IAOlIjiuYUM4h6CO3+niyIM2saqs7e4wLvOqcZmujO21mLww6H8vHIqG00ZDzW2wo9E61Dn8qzgy\n", + "yj0QLzVm8hy4Mwmm+lIsjMv8BFwAvCeOXOHj8FVl5x9pj/tiFRy7POHbvu9I5B/n0bjjbRB9CGa9\n", + "W/oDBAV/tYWNe88Lg5+egm9Hw9DLoN/8xvYFrQ3sLqoFN5dM0mq41yOGpCJD2jRKJ/UZGKHCP607\n", + "THoHru4FF832dGR+hDonj3tY7f89VPPvC8wWR04stwNsCd/FT0/CCxv1OWq8CO5oD8NnngIMQDXM\n", + "YWjMfktQ4T/ZmIH+FAvjMnNR393z4shNXkes9JBOcSQODSIpMdVEdYI1150DTPVYJ+LIRcCytM7s\n", + "6f0+6//3PdQtaU61B4KCv9oi7WW16VusToK3e6+nS1oeyg/fCC3p5xduLpkm+6DjjoL1FR3SptTQ\n", + "v18OSVNh6M+sfHMqm8LeocveQeLkR299Alxqq4sFARiX2YCGVr6PauF3+TKHiSQmiQycKjJ0pn4m\n", + "FmO6s8+SCdFkrq/ehxcuXMPevDeB01GTUCaaVf+HODLCM6a/iP4uQX0JD4oj93tsqlQHr+3rm6gp\n", + "6mgPGOgFLHOzx1p2zp/QcNtbD71gzly5nVvds7HSHiRIy1yN4asGLMnLfkA1m9uBx43LPOnv/z7L\n", + "61UhVa448hxqZnrQuMwLtpTh68ZlJlZ2X6o7rJPyPfvzeuPSqlilLWJfZD1hNde8hgZo7EeDRf4G\n", + "rimqkLxHX5uj1BRfAv8GfgXuNy4zu8QnXgqII9cA9wOnVxVhX3lBHHkR2AG8jSbuXYjScYzxNZMJ\n", + "Fls/ziCOLEIjpR4HXvDHcVOZfDzFwWpmY9EkpDuAXDTT+OKq6E91h83evBN4EHgEeJPkAVNgSn/C\n", + "cqDOWmVdPRxJWYvY24zih1HSt7/QBKII4AOUxK1IygZxpCFqnpiHKhrPG5f5vrT9CRTiSCM0AmaQ\n", + "cZk/itvfF6oTmZs4koJGY12DzvweNy7j16QbFPzHGUTr6yYD/0FLBV5XAj6VKoMVZlPRQuWjUC6b\n", + "1kdD36sK1t7/AbCXVwbEkD7lLOqvgqsGQ+0NsK8x7MvMoPmu8WjhmRT7ubak7Jo2sugttGD8LDSW\n", + "PAq9Z28DU/1p1TazeBKaCHaPcZnPSnXCJevvZyg1979K838/ReIrnczNKkW3oY7pb4H7AolMCgr+\n", + "4wxWMxgIrAf+ixbsGGZcZl6VdiwAiCPRqDmgPcrf9KFxafjv8YhA+PNtpM/95IQlM/WtcBZeBwiE\n", + "5ELt9dDs0j+4bNEHqABraz9bokqB52Dg/lzjb1Cwg/PNKInbGKAe6vzdhNYq/hSNBlrgPdO093Y1\n", + "WjWseylonQOGOHIJ8BTQJdBymd4YKDL1kyj6f9EB9kbCP+fqeu9KdBUJceQUVOC3Bf4yLjMo4P8G\n", + "Bf/xBXFkJ9DRTchmvf5vAU8CL1UlvXGAgqwuSuPdDEg1LpNYJZ2tYpTUZi9nNbmV03JeIOPsSL55\n", + "C/Y1wZtuO39fHSxaUDAQeH66BwXvASEFHRSybSLRyygn/Buo2el3IBUdCA6gA8A44zJpHsd1O433\n", + "orTO5c7LJY7UQ4nmhhqX+bUU/48Ckk5Yw+icpjTou1YLzg+2BNglKS1aWogjjVF/3SDUlHc58JrN\n", + "lQisjaDgP35gp4UHgRjjMgc81rcGJqCMqSOKsg1WWN9KIMisU/CPyC2ccNanLDlhDxlVbWOtbOTX\n", + "Tz75A2g2H1IGaOLbocv92uylxokX0Hf/CyRubcGMhL+ZLw+ZvGUlul52UIjD96DQCtXY3YNBBJoR\n", + "PAcV5j2A69EM3eGowPoLHQS+AFyogzIeTVAbWB41jr36/z6QaVwm4JwUO5PpBVyNzpAXtfuRhnP/\n", + "oJN3aGRFavx20LkLuAet2fAEkIfS3jQpUf2DoOA/fmAdcenGZY6Ix7dxwM+iL+rQ0jq8PFES55fI\n", + "wKmETOpP/dVaV3ZfY7vFt/Ox6ely866+vDnpC+hnSZtHwJbf4cbjQfjnF6iptxo6fKlZzk3nw46I\n", + "3TTf9QRqW1/mawYnjpyOCttlwK3GZXZ471OqPqmAbEHhAeFElBOoLhr6GYEOCh+jM4BmaFx/D9T8\n", + "uBi4Dp2BDgL62WS18ujfADR8M7E4IWmVpC6osL8C5a0aB3xqXCatMiPfbF8uA55BB8r7jcuk2G0X\n", + "AbcZlzm/RG0GBf/xgUSRpPp1uW/uSHr0fYbp/oSwOHIZ8DrwaEeHNS1M6aIWinJ+LVPCtZZAZ9Qc\n", + "kEh6zQuodbgme1rAtOdg1RD7r6E/GzOhj3f7/UQWuOI49eIrYPI4ON2Khn6wYJoxp5fs6hx9yNf4\n", + "PRGRCR17/MlFS+ahfpxwdACYCvzoOZOz2uOjqOZ9q3GZL488RmA1eAPqryNnomGmB9A8oDjU5NIA\n", + "depm2P7WRGcE09FZQk/gPOMyRxA0lvD4tYAlwEjjMtOK2K81Ws3sajRh8WOUkXSZ976VEfkmjpyG\n", + "2vFjgbu8i/KII2PQAb5EWcdBwX8cIFHEFQ/3twujxvwm8GgajC0iAkEciQ/J5vvmG2i0+Atialuj\n", + "UEmiFtykUAdC4ZeWsPQEXcbHsSerIaHoi740f3n/jFvY+HM3cr0nI741/ktFdk2Eul+3h+/awVvf\n", + "2PWwa6IxlUIlXZXwbRorsNlbLbEtmmE7ADgb1abdA8GfxmXyxJEeaPjfXGCUcZkM/+0XH/dfZJ/V\n", + "TPRP4IHwXSwx0XRvuYQtbaaxKqUxH6+9kS7AqSjbZ3d0QAhF63csAhZQ2KeQalwmK8Bjvw5EGpe5\n", + "wce2hsBQVNi3BT5DtfvfqsrnJVpO80mUWO1h4D1vDh57jzc2+xJX50VcVhIFLSj4j3EkiiR1hc/e\n", + "9SC/+jf6NP23CHvk+REyrW0/zp8WDxM+g1NtOk5RNkxP085hOGki1N0bqUVfOm+DxO0wbjd/zRrO\n", + "OZYjPh/FCTLvYw0W2fWtmg8wkE8zO0jY812eqeO9/7GIopKrjthXo2Z6UjAQNEALH0xFI6XuQYu3\n", + "j+yUTMhGzvpgD3Ma0GkCtJoBm8+ATV1h571TzeGpZbJhx3WS6w6fzmu1Y6lRPxuywqHVJDZM78GE\n", + "vYk0MS5zje1zKEpF8QTq9E1FC8EI0MYuu/DtaE5xDwriSG9UkCe6Zz3iSE00yelq1Mw02e4zzbjM\n", + "obKcX1lg79M9qC3/LeAp46fusjjSJeQg3414kv0lDSsNCv5jBHb0j0aFYf7SfhpP3JxHYkY03DEP\n", + "GioTDg8DK4uIQBgqMnMC9B7fCWa1hFftIzQUfv4bnvG23QN4mnb+g2aIeaOogaMkgqyXyB894bQn\n", + "PNY9BEw9gYN/3Upn46fQeBAKcaRlw+nck5DC0MgwGmQbslZ2YcGB+nS56HNCN+/rXetnZkL9leo/\n", + "aPa7OpFrrTlM+OHZaGTVfDRaZ11JNOOBIlMnQ//He8HTPeDMTbCoMchGNu9sx3zjMhf56O9QNER0\n", + "NToT+BzlbVrPkU7mBNRBnIEOFicBX6HCvQHqqO2POp3HAV+VxDFaEbDv7zC0DsLvaPJbkeYtceTf\n", + "TRYzcvMXtEyPhuxwaG6HiOKczFVVbP2oRXnaPX22r7bXul5LvQDW1UOV3wyPZdfeljRcl6HETJ63\n", + "OZSiuXfcfD3Dlunixm6I8WG7j18Vw/5zWpNwbQLcNxv6bdeZhadgLq6Skb2OAV3LXfDIchjzMDQN\n", + "RbOGlsOWTe34FCUN61NWu/CxjE7JdOoGA8codxNAreE76TL1HCKn3EaNiPezNGgzvb0ubtQ8dwb3\n", + "TX8GrdV7JfACECmOuAeB+WhJx23+jh0LUQLc8TuMORVC8yA8FzIaUw/oI4609U5CMi4zQRzZAYxH\n", + "NeJGaFH3SNKi5/LtKc3Z1szYd/J+kpdNRR3Hz6FV5DqjTtrDqPzKQP0JfYE4m9+yGjUfVWp5V3Gk\n", + "K/A/VHEb7qtegR8MarlCebe+6ADzmmuBeKg4QsXjUvD7sXvGiyTiKfxFC1qXRnjXpeCh3EVhIe5e\n", + "1gJ/eq3bBWT4SkYZKDL1JR/FMRbC/qKEsOVWj/eOWshBKZoPhsDYk2FdHViYQMLCBpi6a2FAipK7\n", + "uQniB8OuGrCkvJ1fS42ZnCgyMsfLubZtlpksjqwGfhJHennGiQdRADf1dmYEbI6F9ukwNpu6gyez\n", + "6+1fqPFMgxWMixjG9oPjPf51YypZ2/5nXOYHlGMHwF0A5Ay73AmcLo7spWBGMB9N2toLBUpFnRz4\n", + "dCJcPAze+BauGIRBHbxzxREXyseUX5TFuMwMcWQwmuV7N9CJHxrdQb06DteurkO6aPGev2e1ZdKu\n", + "Z7hgS1fgUvSd+QS43LhMqiWwa0bhGcJV9jNeHNmDf/NRuQ0K9ro9hUY1/RtNSDyCS9/PfxsAnWJX\n", + "MRc46UAYRHkw8lQUoeJxaerJj6SI3QzdnofoDIjeBbWnZ9AkcyMFwjsS30LbnzD3XL+/PB1KvqJr\n", + "rof98+GZpcY4xf3XM2phZVM+qdmKh2q3p/2cOH3Qbv0dklLgmTQyJh9Wm7snKjOT0RPiyF3ArUCv\n", + "QAjDjhdYgXF2y794peEJNF/eEK5YWqApXgoZE63v5DtieIUTyaEmC0Nydu/J23d1ILNbK1jjga4U\n", + "DAhdULPM/JjVZPWZxeDPNxEXeRge6wWvtiXbrOSBHefxb1T470HNNCMs+6hn+4mob+IJkgdcCFP6\n", + "0+156POIWv/Ds8EYQwjZKIncv4zLmEDCi23fm+LbfJSARhr5GxR82uJ9XJ8awL3oIPkmWgCmRAOK\n", + "OHI1cHmnZN7qBi+1707Clhh4flpgYaVBG3+Jjmdjp2vsgC4fQHZdjTk3zy3iyt/+QYHw3leVGbDe\n", + "KG3YmTU7nU2BQ7B5WDbR9XOJeGI6jPirwKnaC/5oD3WqC6MngDjyEOq861NesepHGyzffE/Urt0T\n", + "aA7MaTmHNmOX0/aMzYU1xX6woCXU9ryP/whn65eXEJHZgXeAR0ju1Lek5k5xJBzohB0MQrLpSzit\n", + "amaQVWM7GdsTCDGR/IByyg9AHZttUHPM3cAHnu+UZSH9gXkJIWx9sCWdx0GTPyGtG+yOgw4f5BB7\n", + "IAwNHc2tkcrmi76g/rgsYt1tlJRbxw4KTfCdvBaP0kr7orlIMS6z1/7/SpQq5Td0QFoXyLF99OVj\n", + "YIZxmTGJIkn7BvBiaCiR7b/j70De76DgL9HxfMROA2VlOKwusA6mBPTF64/l+EZD/ToCnWNWMvHy\n", + "8Qx4N+9IAQ9QXRg93RBHHkMrVfU91gnd7P1rR2FBH4OSpv1iPxcZl8ktKgEJjryPy5KZD7xBTsgZ\n", + "jBskpE2KKzhy6cI8reZ7CjoY9EaTB0NRvvj5aCTaVWhc/+/ADcZltrlpE4AbMCSR3g5+egJWD4bc\n", + "KGi0GK4/7RBRua1RW/fIyEzujM8m8tpFcPWSAifoWS3YO28E36B00u5lTUmLsthr754p+JotHEBn\n", + "MgfQLOXpFAwKRdbH8HGsMNQDc5JxmU123WPAIeMyjwbURlDwl+R4JQs5PBogjsRQoGUNQF+U/Fhv\n", + "lL9/OPASSuO8rzpRNhcH+0I+iwrC80v6klUVAuQtCkUjVjwF/QFUyLsF/Yryot4WR4TJHRbSK/0k\n", + "FtwMv/wHDkfYrWVXfsSRYcAnzK/7BIdrDaPR/no02h1LRK4QZgSlJ/gbpYZYCIzj82Z5nJ39Ohsv\n", + "j+S710AM3HTCAXbnjjaf7L3T3fblIjPvbEHvD0+G3+Jg8RsQYuCiKP78+gFeQRUb99IEFcrugWC5\n", + "/VxdUt5+O+P6L+pEfhf1N8RT2Hy0H//moyPoU2zuxWvGZbp4rHsG2Glc5pmA+hUU/CU9ZuAhh9UR\n", + "VhB2pkCr74pqU9+jwn4JKvz/iU6xPwUeKypKo7rDnvMrQJeEl3khYRc3lReHekVEeflNnqo56x7u\n", + "W5lOgaDvDmzBQ6M3LrO+LMcuvm9DZxLzUm/6OPD983DIXSnRd4Z1idp2RFgVc5hJF2Sxb1wMGGj8\n", + "F5w1bA+JKeGE4a66loee91xgPr/XjSIu959k1swlPWo3iRv3E5t7queA504ohMJ5H758UHYm0p7C\n", + "g0FHNNt8LYVnB38DK73ZRG2ewP2o4vQ68LSvkFH7bDbGt/koAXXSeg8K/VDqlXs92nkZjUh6KSBf\n", + "RlDwH/uwjITnUSDsDwBTUEE/w/1A2inkdShf/2/AvwPh9j4aII6EROxgcp1seq37kOhoO5EvC4d6\n", + "RWS3arvWpBiWAy1+hZa/6NJs1mHC8xZRIOh/dbOsVhYq0twpkphE6+hvWTtfqLURhveDsGxYchWs\n", + "nDGLkXMGoJTPt6Hmn7dQ7p+u6MzHoErL4yg3/WI3GWF5cOtYPqt2QAcKDwjxwEYKZgZ1gItRk9W9\n", + "3s5pb/gT1B6Dgrf5aAg6+GVTMCB0ABae8CNL+i1g1Nhs2rjb9/WMBwX/MQT3AxQDUbuiiVx0Nqnp\n", + "PYhHnWq/oIL+e3QKacBDY60Z1oz6O1px2oq1nLznRuMyv1fhqVQI+ofK1AYX0X9XNHz1KUTawLnS\n", + "Rh7lC8Fo6zrIrme3lLGqlTuIoPYGuORq2NAT1veCTW/8avZ/3bO07ZYHKsrcmd9u8/UJbJwGkgfN\n", + "5sHGs1D9vGBGIY6chM5E2wBfJ7zChNZ7uOm3W+h+MJKw3CiyTTib0USvZdiQ0iaTiDr5Ly6KNeVr\n", + "orSO63hU2LsL0OxCHenbKTw7WA4sd5twSlrQxTLTLkTzGBpSMCDcBeTU2En7kFhqRRyGnhv0OYcj\n", + "n/FgAtdRguJMCglN5JoekTz3wQGbkJMNw2dz4vSdPLv5Qs7xVdhCJDGJsDNGk/tuc7IEsoANI6P5\n", + "ck4DXJV3bqVFSUvf1c4j6oOv4NWuBVN9KFmyi7WrdwK6cUXTLjRoD7Fb4JvRsPRKd4tlTJ7J1Hu1\n", + "pwW8N8tj/ctVml0KmmQnkggklbO5M24UjElAetsDhcDGbh7b9+XHpRuXWWwrfv2TPJ5aP5LL+i8m\n", + "JGs//PwadLyQA6nticyLpgPKFtoVGLDlAs7YcgENUd/VYqCGONIS2FDGKLym6Cy5B/AASuqWZ5+V\n", + "VhTMDHoD/wecaPMc/m5yCW1PX0/LWTug4w6on615MklaYtTXNU0Cvrfx/lvt8qtlHv1y0KvcMh56\n", + "b68J22sW/Km8ErqCgr8S4VPLCh0RL+c36MzZ6XWBAWdE0+mDrYTlhMGSE+CMzTB2P3WS/qLnpj+P\n", + "LKwujrSjabd32fxeI3o9DrmR8Nt96DGS/D101QZ+NKX4RBH8Cf9MyAnLK6iW5EZRyS7iSH2UVvgs\n", + "oBsak74VmMOmmjuZ8VkjtncCE+rZYhmTZ9JehpHxR2rVG/wm3FUmvDOsE0WSBopMLZvfJFbt97tu\n", + "RUsFP+Wx7chzt4Lv+V71ZfC+S+nz2hkwYDUcCoWVX1G7xRDSN57GVNShn19wxd7P09H7eC3wKiA+\n", + "Mo93FtdjGxjxACrMX0GjjvJJ42wfU+3yjcf/QtDZQMc6u3l1fjP4oAs02gdf2ny5IgT1IDR72RuR\n", + "wIFMyBGgUZYubpRXQldQ8FcqrDZUZ53ypiRMhVYzEsg8/CD6wN3Wci1PGuh1wwX6j3Ff6Kf3A2Sr\n", + "97iAy9lfZy9xs6HrqzB6gcdeZdVYKx7uzNOFjTVdPW4PXLqXhKU5PCiOzPYVveMvG9mdwVxImy9Y\n", + "mqACYS6aVj/XXRxEkhOT4BUfZo+yCeiK06rLH6UZgH3DznKyhqGX/GEgFKJ+zaPj8vfNgk0+22q0\n", + "C4nMgcuXwpZacNrN8OGX0O0b0j47jSnALHHkfOMyqQD23n1vF7dztTkFiWb3opnH6RTOPP7TwxcW\n", + "gg4aTwAz0BKOAWeI22zkDcCGgSIpb6uZqBB8CWrrY+gDjPDRbBR20C3qGS8rgoK/UmG1oa6vQs3t\n", + "sOxy+OYtyLp9oTETHgYYmCzZyX0gtR7MeL/gn+4HSByJRR/q21Ea3vYcyhnPpVe3ZtIYyGzmcbyy\n", + "aqwVj1h90InM1bC8uc3hs9qwuB6nApvEkTy0oljBkkzaljm8v2wJ/Rulw55wDi7szayMM+gujtyD\n", + "vvhbUPKuOSgPzTJ/afQVKaBLwltUWlihF4nGy9f0+KwZ6Lq619F3bR4ndA+HwwLz3i7WVOEHnrOc\n", + "XuhyYyodlr/DBZtvF0fe8uXIXtyD+jHRMGUchOXB+E4w6CqIWk4z9P7tBn4WRwYYl1nq/X9r4nE/\n", + "I1/Y6xKCOnHdg8HlQGdxZA0qsBPRDN5hvso3lsQEWUJB3RtY6qcqWSRwYKkx0xNFSKqgcOug4K9U\n", + "WG1o2nNe6wsE9G+Xs3RWc85NfYswd8TKjZC6NpzXxZFbURXqJ+A04zLrxBFh5K9RpLbZzaohHjTG\n", + "1cekUBTcfC8ddkLyzIL1SfDLlGSSgNposQ/30gK4eFc32s3pRhO0sIUAZ3JQ9rK1Vjhb6+9iV8QB\n", + "YnesoEf6T8DG4rhTKlJAW8EcRSmFcoDrctE48iyPz6wi1mWiyUNZQFb8Qjr/ay8n1DgENT3IjEtq\n", + "U/Y7iP65abItovKeODLYK3u3qZxD3AXvsiEsjxaghIJfprFu4o1kAPNQzfw+lLvpAuMy84rti2rk\n", + "K7z5dksAACAASURBVOwy1h6rHWoW6obWBmgAfC+OLMGDqbTDY8T3gBcDnQFZzqlABfUg4Ds/3Y7C\n", + "vhP2vxXyTAYFf6WiaJuvONKbTlzb5Btuvz6Li2IgOhOyF57Fn1sH8Dwae5xkXOYvj0ZHUudQDDPM\n", + "dZB0S3U3KXijKE3JuIyRgjKAbpONtzY/B9jK942GsrfTQ9S4pCG106BpGtT7wcVBuZMIU88SdqV5\n", + "LRs9PnfxakISe1rfgtSMJjTzMO2Wf8XFm5dQdqFcA62RHKhQzkI5bjYHsN9+lBeqTNzzA5Pl2vPV\n", + "PFYIpbEpFzGIPoLWDBiFJhIiIZ2S+Efd98z2eru/29wi/ST+3H4ie7L2QfaGvbySW4spwA2oKeYZ\n", + "4EbgG3HkCuMy0wPtk50pPwjcjFbCusi4zH67LYaCzOMkwLXqX7RospGwBzbDNYu1BsUYSBgMYweK\n", + "zPel/QciqK0SMAglnfOFSDRMu0JR5nBOERmAXshQ4G1jzNM+9umD2lXDgZ3Gizv+eArn9Jc4Jo60\n", + "R0M1rzYu8yOAONILfdgjUD6QHwq15UgnYCbQ07jMiso9k/KDO/O0hhC9MY6wZT34a197Yilsm3cL\n", + "+Xm+psj5IZmtZkCrmRC+HyKyoPbnm2i3Yw4FxHu10FlCNPqShQMhrIqBKUmQ4eFvq33FIc6fkkbi\n", + "3vVoWN9OlMelJJp1FiqYA2JrrCpUVu1Zy80zF+hHcqcmdKn/Dt13Nuad3+BAbfzlT4gjrVDTZhia\n", + "SPUiWn7x62KOF4rmtDyGMpE+5KZHKApDYmX2bY3p/nszrQV91kZdn2yX0uaN2BnHdCDOTx3lv1H2\n", + "0SNKRPpsryrCOUUkFJ02nQdsAuaLyCRjzHKPfeqgzHr9jTEbRaRBWY55tMOXNmSZFr9DH8ofLWvh\n", + "U6gN8j/AJ560tvY/0ShF7b+OVqGfH2mTTLdlOridimq5sQRgmy8M6z8JPQQI7G8Iu1tB+m/7aLfj\n", + "M4rRmPn47Ckwvh/hWXD6aJg3CvZ8Gs5v3WuSOKcmWmy8ARoJ5D1z2O2xfrv3vToaUEJTRalh6ZT/\n", + "CXxC7QZbOW9FY6Y9C7d1hBmPwsI3EzBDjvArWLNmX9Tn8BLwNjBaHIk1LvORr2OJVux6Eb3HFxqX\n", + "mR9oP3P3kTkgRenJPfHXCcD2ov0fxfgGBgGTiwg7rRSNv6ymnq5AijHKTCcin6Jl0JZ77HMVMNEY\n", + "sxHAmOLDq44nWKKqr9D6oN+LI++gGX1PAZe5MxZ94Dk0keS9SumoHwTqALOaVyKFI20aU6DNP48f\n", + "bT4wWP9Jaj9d8vHdWjNn4YTi/i3JQyMBCMvRaKv2k2Dix7C5+Qrj0hmqrc/QlMI+h3bAuWhESRxQ\n", + "SxzZjG+TkntJr06sr25UpE3ZE8Zlxokj/Rmy/DIWXwOLh0N6O+h3L5z1Isyq2UwcEe9rZAfUl8SR\n", + "74EP0PDKZ8T5f/bOOzyq6nnjn0mBBAi9SAk1FA1FURREigJCgti+Aip2wW6sP7veXHtHQEXAXhCx\n", + "KwYU6QooXXrvSAk1lACB8/tjziabze5mUyjBvM+zD+TuLWfv3p0zZ+add6Scccw7nv3ElfqortM5\n", + "qNzCyLzeb38hyDuioFQsWsqF//xHCOyo7gRn5mTG+I8lCmr4a6IPsgcbgPN89mkIRIrIBNSTG2CM\n", + "+ayA1z0lYON9HwAeqeF5aPl6I3+iTl7HXQ4kAGedSAMS7CFfmMzf/FL9blY3uIHIkhWJalWGc5Zs\n", + "Jj7td+BP1NCH6M2HgoJy5u3EcaASfD4a2r0It50DY6pl9ji2wl5r7Msv7ETumQQ8r2bo9+X5O0pc\n", + "8Z0MfP/efTJODoWIX6i6+zq+ek7/2ngefDQZmvwICdfUB8aKK//nk88CwDhmiRU4exStdH1GXCmH\n", + "Rh+eRPMAbwLX+WtqFAq8V0DRcN7pUGFsF/h6ZtY+/vIfHnqyAXZHaZMaz+pAXJmC2sccLSm9UCQ8\n", + "/lAezEh0Cd8JTXJNE5HpxmTXjhGRZK8/JxpjJhZwbEUBz6FVgtFoDLmFccyGYAdYlcAh6NL1hCpU\n", + "eh7yIwILqsK0WDhUi7iV9fiaJWUMSzqGkTY8yyta3S+dr6d9fSySzgWnZHpNHCYcJj8Nm/7YRO+x\n", + "9cWVZwE3lEnKVlavsC+/sMlE38mhFSoV4PlbxJVgE8N6f2JhRQHiSnngDVZGv0vpW+5g1whbNSew\n", + "ZNRK1tR9gMeWxAKjxZXfgKd8dXKs3PIL4sovaMjzadTojwSaGcdsgrxXhXvDswJqKpK4L46hZWpS\n", + "8yxbvhWIqumhJ28uAy3uhK2v6Xa7OugMTMvlewvq8dt8acdQxh8MBTX8G9GH1INY9AH1xno0oXsA\n", + "OCAik4EWqChRJowxyQUcS5GB5Re/g3om44EHQ0nm2HDJF8BbxjHTc9v/WMPzkG8rDb17Qpv10HY9\n", + "bJjJovEbLtgBwzXmUnkJpDbhWFcTF4SS6XfiWLFxEJFmNnrPx4or1xrHbC7wOPWH76EZ+oX1YGN9\n", + "Xhd4/y2uHCTIxIDSWPPk8R6rXtTZztu7agMq7Z5nfth5j3SqUorlbS5nfa35sG8/rBtkDixOsffg\n", + "czRUM0dcGQa8RHJ822zj61JpIm23H0Ydp6poFGILFF5R2gJjUkomydJaC9nTG7YGy3946Mmn7YV9\n", + "kZBWAmIOZa4OgtE4PQjq8VuHeKLnbxHJlyhLQQ3/TKChiNRFk3K90c403vgReNsmgkuiS503C3jd\n", + "IgtxpQtq9Ouh7ejyEvZ6ElUzDEmr+1jD+yFf8nbW9h8gFWLU0y+RBjd1hBE/WKGuk7eaONDEIa5c\n", + "jHqUs8SV6/NCI8z3WHQ1txvIUaxkxyRor2ffyaGz1/9riitpBJ4Y1gMbPdr0ofaiziuynbf+71Bj\n", + "OgzudUjebZpIcmpf2qfGAn8aJ7vzZ1sgPiWuvAc8S4asoW2pw0z/sQrl1kGX/4Ma6Z2YW+5Vztz9\n", + "FBpV+AlYKa606gZJb4cTd0cCDEqByKP5K0oTV8pSibNXtafhynHBO8B55wbq7YJVFWDQFlauEQah\n", + "CekcrEev64Sj7MgCUXNDQYEMvzEmQ0TuQcumw4EPjDGLReR2+/4QY8wSERmDiikdBYYZYxYVdOBF\n", + "DeLKWeiX3hClFSZ4aJshHt8O7T3b8mShBgavVkxLAuBQDKQMgstvgvfmQMbJX03sC3u/k8WVP4DP\n", + "rSF64UR+Dzb+v92+5vrbx64sq5B9YqiFrrg9f1e3sgbrubFibbaUqsae12F3LCzsReGs0qxUSYm9\n", + "0KOfCuGlJ9SHxHuNsyBFXLkBmC2ujDOOmeJ7tA1/3iK1WzeiQ/m2XHAahB2GKU/At19GkHFlS/N9\n", + "igF+t6qXM4B125uzvOQ/sKgKfH869LJr6nwInfUCxpsQ2n565wa27qNVn5qsYwtPLXb4F23lGkwe\n", + "vSRw8HjkdgpcwGWMGY1qwntvG+Lz9+soC+U/B8s/fh71Rt5EJWgfyqPRrwh8jopHbToGw8wXglEA\n", + "NWxiY+aLesIZ38DFZ+8iJeykryYOBEu1PQcYDrQTV/ocbx39vMCyYLbY10x/+1gv8zQglgX1PiCy\n", + "bjXKrYeq82Fhb7tXQVdplmpbfRasSNAXANHniTRNNKpZ3w+dVM80jtnp9zTra2fw+Ujo9Bg0HgWN\n", + "f4a1HWB91viMY3aIK02AlJmXcdGtdeG2mTDgvCzDH6goLUg+4Ga0+1ZI8OQGxJX+2+qx0cwyKeLK\n", + "U+Qe5jkujB4ortw9ZrAc9SeBG9Ek0P1Y2qZxzAd5OI+gS8TvjWNye3COOwJRAHPEzH/blkHSkpac\n", + "G5itVBRgHLNJXOmM1vHMtsZ/0gkeVr5hVy0bgY2SnLAeHjgj514FXaVZxtTaDvrKxBkVoOIADSWZ\n", + "UTYMOkxc6enf67XnGfcyjH8Bmn8OV/WGHfubiCsNPd60ccxhcaVr5A5++fx0Lh5fj7D9ETCzBry3\n", + "yX9SNlA+oG4DqcUN1MfHuQ0Rq9DGKqDx/Wdy2f+4MHpAO9cXoxAhrkSLK4+hibsotAzeRYtONqGT\n", + "QV5wO5oPeLQwx3k8YMyCFGNSEowZ2dHsntCZCNMP+Fi0JV6RhXFMhnHMU6iUwAhx5UkbViniWD9Q\n", + "K2e9URiaT/7O+yjQBQ0l1b7Xa2McSnoIfh4TDvNuhEEXHmBDqQwyZKa4MkhcqQK62jlUhcTw7Yzc\n", + "WIL01JIcad+TvVPK8JC/pKyHobY/EtaX1W3DIC42jUeBz00em7ZbrAQa2ALNM9DK/GA4bh7/KfCw\n", + "nhwQV8LFlVuAZWjhSFvjmLvik2l5wdss7zSUHl1dKsQn0y0P52yKUj6vDlLIVWRgHPMtGnJ4/kSP\n", + "pTBgHPMr+l13RZf2VU7wkAoETeBOuw8Sx0CvSfpvwTpyZT/vJTt0ofQ4XP4VdPkZSu7GE0qyVNhr\n", + "gJfEldMDn+fiWXD1AXgaMm6NZtz6mrx1zXa2lKwDLBZXHhdXoo1jzP5h5prDpXn6aAn+PVCBksse\n", + "5hVxpaXvuT0MtZ8aw13ds7ZHRlELlYrID1ahod1uaI4gt99wscdfVCCuiLhyCVp8dROqs3GVccyy\n", + "piKJZ5fgwympNPh9EzFjDJ3bwICmIomBzudphnFFSZkcvZNpMYv4zDhm6fH6PMcB9wJX22R1kYfV\n", + "fbkImIOGfi44wUMqELKt0kxKQmHVXOh5jsxQw/8S/D4NSm2He5pAu3mVbK4B45jFwBPoSirK/3nC\n", + "U2FENJWvhZuegaidsPeLegy+KBJtXH8OsFRcuVFcCTeOeR14FhXKW4/WBzwj2moRyGKodV0Bk+rC\n", + "fvvOfuFAqLo5frAGFRi8hNzj+1Ds8Z98EGmaKJIwRqTXRP23aaK4ch7KqX0FVf7rAPwtrtQRVy7e\n", + "34nBpbtQrdMNcNnVep5hEFdbjV8OeOKMo6HraV1od/kGyvQaSY9gE0VRg5VkuBP4UFwpndv+RQE2\n", + "9ONRfvxGXHn01Aj9FDa8QjV7q8OPH8JX52yg9UoBZlptHYBhaAFcAOqjTRanNoFN58CNF0GpbUCZ\n", + "aOOYZcYx/0NXDrejFNwuxjHD0Bj7Rejz1waYKq6cAZkMtRUV0qHlvzChLlxbhr2r6vFFfj+tXcFs\n", + "RVeEoeQISnKcDH9xs/UQkIPfXHE5dLtwL/U3ZhDBV+iX2xAV8mqEinatq7GYcx9dQ1iTVDh9G8Tu\n", + "0fP1gkkjfRRKARJExoyGrt+dDv/XBWYPgXIH899E/GSGuPIZsMM45r4TPZbChK2s/grYCdyQf+2h\n", + "oodQqmT9qdOSvHA02iTlVWAWqru/C11F3eVLashUYgXAwEVPQ5PvYXiV8WbnxE6Z+ykx4n8oI2cF\n", + "Wgz2EfpbvRINw7xg338rPpmuteHe1RfRcGdlovaFUX5vE2IDsoxCgLgyByhjHNMwhH07AM8Zx7QP\n", + "+fz5tJ3FXkkQ2DBODU6PTKbVWXH06AcP1NblaYMtZUiLjkAVG8PQpVw/VEa4BVAl7lcWJf2lsq4e\n", + "ow+B6WQxEHVU4OULYPi3avSh8Bosn2S4D7jKy8s7JWC0dV8HYCEa+jn/BA/puMB7tToSOoyGrv7C\n", + "mv5CScYxxjhmJMqAmYPy8P8P/T19IK5Uz34172SxwPjnYUnkDu6c0tjy+PVaet5v0MRqCirLvB3V\n", + "xhrO7PKxvNhlMUM6Pc37rbctrF33tHUwqMJiNu2qQ7Wmk9gTn0wbCoYwINRQ7XHz+E9ZOmdeSs9F\n", + "e2A2BBqjXrvn1Rg4QPs1Jdk0WwWk1rWFKd/Cvy3BXDPLmJFX+ZwrCn3Ivtm+i8n9/GicB+qbmQbp\n", + "YQamfqDt5zworAbLJxMs3/oOOcSIztGyoGI6kflv8H1ywTZFecSKcn0vrrwKvHkqi67FQtJQiNtS\n", + "Oqs5eF6rZK28xPPiykfAi2hS9S/gU3Glq0fu2q+8xviMQbQ/2gSYLK5cZBxVDLbnPQQMFFc+QUOy\n", + "ndgeOZPGBx5nbZ9w5t2oO5a/etihhtv3/LE8rXzjdBhsqP6OTl557DucDdXQ/F8oiOI4JXdPScPv\n", + "v/S8bwOpW68cN6/ZQHbD3gStZlxDln7KeLTZw1LjmB26tHy/K2MGwmFvJmJ2frOX2ua/wBMLjDma\n", + "F43zzErYo8emwfLJhvhkjuy/itJNLqLz2/aO5K/B98kJ45ifxZVz0dBPB3HlJuOYHSd6XN4oLG2e\n", + "GIgyAnFJsOHNgq1WbcL8Rnvv3kLVTd9GK9d1H//yGiniSjram7ezb5WslcF4TFzZx86yT1Bdwul2\n", + "v+YKNp4Hu0aEbSnTqnzidTPpsgp+bgTDNuen77DChv1KEfo9KPb4CwZbIl5rGpw9TEXCKi+JI2zP\n", + "JyidcAm6/Jps/7/KBG1dZ5UbD+cq+ZsMNAAu9HgnedE4P17NME4WxELSl6OIaXYnXDsfzl+f3wbf\n", + "Jy+MY9aKdlJ7GQ399DYh9Is9HihMbR7PavWMbbCwqn6XULDVqnHM31Z++V6gv7jSEOhrHLM2yDHv\n", + "WuM/QVy52Dh+5WHeYlKzZzj8JnR7AK64AX5/BZZcRosNpbl8CdTfAU9fBE9PLlCoNRGVIK8X4v7F\n", + "Hn/BYLP+h0vB+jYw52bY3hj23T3VmK875vVsoUj+Wr2RG4DW+dUAh+PXDONkQAxElU+HcZ9CPa/0\n", + "2amW07ChhgfFlclov9gXgQEnPvRjHaTwQ3DNpfD5GPKrzeNZrTbdStwCa/gLY7Vq79FAcWUHMBCd\n", + "PN8FXjaO2RfgmA+tcuk4cSXBOGauz/tp8u4FG9l6Vh0+nqCNd7o8Am3e5NBv27hjJhwKh2WVYEtp\n", + "2Lsv35NXd+B7ggiz+eC4efynaHLXlnZvaQGz+8G6drCvKrAv/95HEH6zTVC+DnQ3jtlS0NH/V+Dh\n", + "TjfarsqJHpyKOQ0A45gfUHXaPsC3Vpf+BMI6SEciof5YEM+XkHdtngXGpEyD+ybuY8kLddiYCGMK\n", + "s1+v0faK36Fh2PooT//6QLRZ45gvgHvQrnatcuwQtfFZyl99BES1g96bC/MP7Z5z9dKjva+CDWWV\n", + "lHHFGWzNz+Rlc30dgW+AcHGlQgiHHTeP/xQ1/Meq9DwnRJukjwSuDbCsLEYAeLjT3ttO5ZwGgHHM\n", + "alRXfwPqvZ5z4kZjHSQEMqK1QT2QX22eBcakrGpH0rrmLE8xJuEYhCjvQ+P9KSj9815gmrjS2t/O\n", + "tlK8L/CLDRllvbd29Yd0GDODCh0WQq9JmB5jmLn32qjVZua0A2xpcjsZv5Zj24x2rMnn5+gA/GNz\n", + "OivREHBuKI7xFwQF78YUGsSnSXphnvu/gP9aTsMDW7qfZEM/KeLKc8Dbxz/049V17HApNfyH7i+o\n", + "g7QAaCZ+euYWFMYx+8SVa4Df0JVTa+A6dPU0EXjUt4OdTbBfh7KrehvHTMh886zdT3LW5EFoTs6I\n", + "K9X2QKM9KlddencsLwE3iSuPA/1tQVao8G664pFu8KuQ6oVij7+gOFal5x5IVpP0b/KitlmM7Fhg\n", + "TEqKMQkjjel4jLzEkxaWY94GlfoYKdp16/hd31ub52haOqX+N6kQtHk2A4J2w/ILf1XwIY9Ze/C+\n", + "gLZbDDeO+RRl560G5okrjq8IoHHMb+gK4StxxVsrawLaI6Sz/fs64AfjmL3GMVuMY25B6wp6AEvE\n", + "lT6hVGRbdl93svIkJ53Hf8oa/mMJX9rmCR5OMYowjGNWon2Xt6LyAjkExI7p9a2DREz6Ku7+454C\n", + "C7Kpl78AaOrv/Swm0eiuMLKD/ttmQF6MP6p0ux1VvcUa6qfQ3t5noEb6Gvs79YxrEtrk/FNx5TKv\n", + "sQ4A7rP73oxW9nrja7Sa+AYgCZghrlyYy/gaASXQ5lOQ5fHnhmKP/yRHMjqD3+ChbRZleITheolM\n", + "TBAZcyppAxUFGMekG8fcjUp2jxFX7vQ2WoWJIN72PpRzXhiYTwDDn8kkqrLQK6eQTZo5V1iDfRMa\n", + "hrnIa/ta45jeQJ+wAzxbZgs7OtaXWZ5n2jhmKkqxHCKu9LSHfQGciza6jwJ8O4CNQj3+KWho6VW0\n", + "mniUR+fHD7oDKV6hrlANf7HHfyIQyhLU0javBy4rCG3zZEGopfbFOPYwjvkK9f5vB74UV8oW5vlz\n", + "8bb3A4UlmhfQ489kEp3/Olz8sNf2vDGJbOezm1APvrL3e/HJxNz0KgyYTvllV9Ky6uV0bVaWt63x\n", + "nwlcDAwQ7Z98AG10lAx87CcvsRAwQLyVgPgKlZYYB0wUV4bmlJTIFuaB0EM9xTz+441Qilm8aJsd\n", + "TybapvUOw9C+x2FB/p9j2/nVeOzhDOIWC9TfCSWPnHpFVEUJxjHLxZU2aMXqTNFuVKGW/OcCD2//\n", + "IETvUIXMTN7+wsL0+Begnef8wDKJfu0Pd5wJjUbBskvID5PIOOY3ceVLVOn1Mo/RjoWkIULcpF2w\n", + "dBC82A6G3UG9Mv/wlrgywTjmH3GlEzDW5uo+AB4DrvZzDSOujEKllRfYbQfRgrKP0VDvAnFlEGob\n", + "wtAVxDiv06xDexuXsDUdgVDM6jn+sD+KhHsh/DDIEZCjcZTeNlRcGQ+UR1sG/QW4Vj88T0b2GL4v\n", + "aJLK8zri82+g/x+Z04fqPQ5D+FH4Zbgafzj1iqiKEqwXeru4ci3aQPxJYFjBWTLW2277GlRZBN8O\n", + "t9vLRKM5hsLy+BcC8eJKWM5QqGUSpQ+L47vPoGcvGNpxDWn5ZhI9CUxF5RzeASsfAdxwBYz5HF4a\n", + "B/1mQ5seVAAWiSuPoPz6jqiBboP2Jb4Y8EfJ/hlw8Om7a1U7/09ceQdNOC8DfgSmGcfs9drvsLiy\n", + "EagDBGu2XuzxH3/YH8W2eP3ThMHOtbAtvjzjm7emz5Q6bA8fT739n5AHw3qc3jf5NQoeKWjf7adq\n", + "EVVRgnHMcHFlFppg7CCu3O5tUPKOtHQqroDWb8GQWV7b9x6gEEM9xjE7xZU9aBOSNdne86ZarysT\n", + "zbLIWvT7ZgdlM/LT0xbjmEOW4jlVXJliHPNPGqRHHoW+s+G9c+CdFHVozv6UmaOTeRXoD9zLr9VG\n", + "MrP5Gm6ceSPLKu3gtC2PiCuDjPYh9sYkoKm4Utk4JtXPGNYAfWxNxk9AmGhzpl/8xPmDGf5ij//4\n", + "wy5BZ95h/54MrIWIlNL07NyQf+6H37fHwbQ9hU0NPZHIFIYLUUG0GMcXxjFLbYHSQLJCP/PzdTJZ\n", + "N5Ae7dvxx6Ol2F3HbswsbOxO4YV6ICvOv8b3DW+BNdEuWNk89rzChsceRvMireLtM+3MJq75nfDK\n", + "73D/IX2mjWMmiCtnszSmPxfsfouaFcOpaGDqP5Upc3MGqyc/g4Pjc/6D4so4IAH4LMhQZqGr76fR\n", + "JPBD4srDxjGzCC3OX8zqOf7wrfb9DXgeLr0V0qrDuBfJK/vgZEKgxLWn1D4RxvSCSYVdan+qoCDc\n", + "84LCOGa/cUxfNJwwXly5JV+sH2dRaapv2cZf437101O3MJO7EDTBmwUrjtgHSA7CkgkFn6Lyx294\n", + "nunb9jAmYjOpLVuz0PuZNo45wpdtGzFwczgxGyEyHc4bCGmfRLCt1v8FuLc/o+yeYDgL2GO7fTVH\n", + "aw1+Fle+QBvz5MbsKfb4jzdyVvseaUbEwYrsrg2TntHQD5AfHZMTjdwS1/8lYbj8oDBVLAsC45jP\n", + "fEI/dwUSKvOFZQj1J+ro1SZjzB9+dinM5C6o4e+c616AccwyceUJ4AtxpbXJvSm5v3MYceVOYI64\n", + "coUx5nu0KrrLtnq8xkW+rQ9jojhYDsa/ABH7odVgOHsozImOQplCN/iET1OAN3NJ0GZW6xrHZABD\n", + "xZXhwMPAQ8C/4soLJnBHL78efyidzfKKYo/fC97VvrB/BhlRMO4l1THJRP50TE4sYpMo0T+OZl+g\n", + "zDQoaquXE1VrIK6UpGzlh6n4SBw1ZkKE5+s/MffP6kGdi36RM8SV+BAPfQ4YYxzjz+hD4Xv8Qbj8\n", + "fvE+sBZ4Pr8XtHr71wLvWS180ORtaZSD7wUb2l3bHlZ2gxE/wqj3oOWqw0Bv4KszIqS755nrlswn\n", + "4fvZguosBYIvjdNTXJaMtoCshIrLPSDa/MkXOTx+D906Bbp+ElF4dOtijz8gvHRMMnFshN6OJcSV\n", + "ZvwvthlxtWFtO1ieCOkeocCisXrxPPzeeYhQGraIKxFAWaAcysoq5/UqH+D/vn9HcNdU2N8N0svD\n", + "yG9gl0de/cTcP+vl3ySu3IRyyR82jvkk0P62GvhqtKo1EPYBdQtxmIuBRuJKhPV+g8J67H1R2YXR\n", + "xjHj83NR45jp4spA4DNxpZNxzBFx5T20wfq0rD39/L5XfbWSkaclc/vqoRiu3HA3l43/gBKn2TXV\n", + "mTPZvqQR96IKodkgrlRB+f2TAwztb7SatzUq03yv1QAa6bWyyOHx14KkqxoQd+5FcMUSeGJK4dCt\n", + "iw1/ABwvobdjAXElGrgKuAOoywE5wOB5sCfWZ8+isXqJhaRhELe1NIytD7ujoH5J4kZX5G1x5TcC\n", + "G/BSwB5gt33t8vq/5+8tKA0v0PsHeLnT6Kzm3t44sffPOOZjcWUm8LWtMbnHOGa/9z6Wdvwe8JgJ\n", + "3vi9UEM9xjH7LYUxDlgSSrjCOCZVXLkF+FhcOdPkv1vZy2iY6XF0BfExsNKblRPw971pVYq40umc\n", + "j2m/5Urq130Anh0P9/8FHy+iUuszuTiAAF03YFygMJBxzC5x5RCwzTjmEiv78Drap+Fh45gp+Hj8\n", + "4kr78rfT+r5IeHYCXOVFNC0o3brY8AdBgPZuJy1EJaJvR3VFZgKvAaNIibkYnvVtRVlkVi8x6gmR\n", + "Wgp+aQTl0qF8OpRRszuPwIZ9b2FIakhy05N29Wccs0BUb34w8Je40jM+mfoeI9u+AlXmXojZ05yA\n", + "KwKLwg71gE3wNhWpH+qKzTjmV3HlO1RWoVd+aMrWy78Olb0eZxwzTVz5EdXieS1zv8C/7wExR7lm\n", + "8iDo1gdGNIX3z4bXfwUTRjgqCrfE55gcYR4/8FA6t1p2USvgGnR1MhcoAxys1k7uO9iEp6PKV7bN\n", + "dQAAIABJREFUUbrmDA7PnZu9BzcUnG4tpoA1ISLSDa0yDAfeN8b47TYjIq3QpVYvY8x3Pu8ZY8wx\n", + "0SY5GVFYfU4BxJUSqM7I7UA88CFa7LMq5zVrF7nVCwSuNUiEMSnGJByPMZzs988yUW6VDN5om8KB\n", + "KbOp5nnvlnDW/X2EOwOFxZqKJIY157lN51C31YfMKKyG96Jy00e7JXPeaOi6IxqiD0O0DfwE+v5s\n", + "Ne0M4A3jmI8LcP3LUNt0Ftpb+3OgUSjOQJtY2TFtAxUywtTojomDB7rCylKkHy7N28Yx/+d1nQi0\n", + "AK6pccymIOMZAfxsm8R4b49CQzevyCFSSx6m4psTCL91Dkw/Ap/B4WEQ6dm/L6z0sJTyazsL5PGL\n", + "SDjaBLkzsBGYISI/GWMW+9nvFWAMynP9z6KwGCLiSj3gNtSLWYQu538IuNQsYqsXbxzLWoNQGRMn\n", + "+/2znvH7rWvLTVsvo+1tNVWAKToDPjxC7UAxYU/+5No9xLlHYTR0LcSG9wuAXp4V213doe06uPdv\n", + "fTNQuMI4Jl1c6YO2TpxiFUzzDOOYH8WVruhv4xogDa2+/zW3Y9fU5N1r9/DQ8D069m4r4KtVrFx1\n", + "B8sozX02nOrY8FkbYE0wo28RSKwtFp2cKLOdiMhyhG8vBRlh0F5LySITIDUGFhZWz4qChnrOBVYY\n", + "Y9YAiMgI4DI0seONe9ES6Zwt0P5zsNIQJdK01d3BcoTa59R6Fpeg3n0rlLvc0TjGd9l5SuFYNWzJ\n", + "b9L4ZEbt9WSMHQpJCbCqAsRv0+2BjKwnf/L3YdhnfcpC1GpaADybplr5PDgNevaEO2Zqq81g4Qqr\n", + "p/MCGgZpH0qCOAAeQlcPN6HhsDsJwfBvTsAZVYd+nX9mTsUDHNoLB9YdZdChqkxAvfsSwGI7xpqE\n", + "dq9WoSJ8AIgrdYBnUJvZH8joOoT5r1Sg/ROd4K+acOEaaA+8DQtHGtMx9I8dHAU1/DWB9V5/b0A7\n", + "42RCRGqiH+wi1Fid4AbTJxpWGuKip+FwtNJFASgTHcj7FFdqoS3k+qKUt/eAK08FddBQcSxqDTxG\n", + "73AYbCwLdXcVfYG6NEiPOQQf/Zh9eyAj6/HGa+6BnoWYPLRYDtReVZZH++2hwbCNxMXtgOHNYMq8\n", + "kFZsA1EZ5Sex2vt5hXHMAXHlarTpShfgZXEl1jhmfS7HHRFXXht3Bi2MY673fk9cmWDPNwB4E22z\n", + "+HgIw1kJ3GDVPJ9AqaeDgYYoCeG5vXCg/k4Y8U32AwtbQqWgPP5QjPhbwGNGkwlCgFCPiCR7vToW\n", + "cFwnMSx/eNoDcM4QKKXSHxGklvGWRx4ldK3ehGGRD8o0tKFDZSDBOKatccxn/yWjf6zgMXqrK0AX\n", + "r592URaoWw8Dr48mGxsmWFjM0/C+Zho88mfW9sIwNDbsuGLZg6z1VIcfmMG8Oy5k39Rw7sttVWVj\n", + "8TcBd1rF0vyOYwEqsvYhWk3bL8RDPwC6+5FdHgVcYhyz0J7roB1jirjSJEjNyQ40pLMQOAycbhzz\n", + "lC3oKgkczK0PtYh09LaVebwVmSiox78RjU95EIt6/d44GxghWgVdGUgQkcPGmJ+8dzLGJBdwLEUE\n", + "lj+8e1gcC3tCmzdh3NaVpzObYRC3pTR8eBYMPRsq76dG/RnsWNaZ2v7EuQozSXyqw99qKtYave3R\n", + "UMnLzBVlgbqFySxbt5iIi79jUvnD+lmChcWOg1bTfKDpAmM+QytpBfhr8dP4K2DKAeOYTbYi93NL\n", + "8UzL5zgGo+qbpYErxJXnrFxEsGvvtAnZOyCbfs8vwEs29JqIyjncAtwjGfyV0YOjX/xO+Yr2Keor\n", + "NKx8sfShLd1Qp+Is45hsxh1r+HMLaxpjJgITPQeJiEN+YIzJ9wudOFaihR8lgLnA6UH2/wi40s92\n", + "U5BxFLUXxCdCwmgqd53O4+GHqFmvd0+YaMC0vwnTtwdmRg2MAdMTJgY+R9/l6G721Xc5xCee6M93\n", + "7O9dtzHQc6L+m/vnjYfEvrDc60aZvrA8Hpy+sPznRpjEa3X7rbAiHorcPdT70nUMt1bcQed6S/Ly\n", + "HMRDYgKM7gkTE2B0YX5+knmCZF7x2XYFycwgWVmF8ZDYDcb0hIndYIzn+tm+62rnr+eSCmMLOJZK\n", + "JLOeZP4hmatCPKYJyWwmmZLZtj8atpzGZ/3FTZVTOff0eZ773bEs4+7ojqn6MObdc7Ket/Ors5Fk\n", + "6pPMMpJz2kiSqU4ym/P+vWPydS8K/sCRACxFlyeP2223A7f72bfY8Of8woeRzPPdYIwBczS7JTcJ\n", + "MNr/fe82BowhfoShwgqvQxL87n8qvPI72V0cxpjlFTHfN8GkRme/t/GQ2Ph8/ql+DZsL2+gd9/sS\n", + "P8JwZzND2KGTxgkgmUtJ5hefbWEks4hkOgealCtQ3cnxXZe7+hCtq71YwPFcSDI7SGZKHo4ZQzI3\n", + "ZrvfXZpt5+IHDI/HGKK3Z95vjwM3rxrm9TZZg/c4cCQzmmQu8XONuiSzNu/fPSY/96HABVzGmNGQ\n", + "XQDJGDMkwL43F/R6pyBeBGYuq8Gd/TblZcltk8TRO+GWC+DLn2BTK4qKDEP+YBlRp82F3bXhQEW8\n", + "GVE2jFAT1YjJfIU9zlld9kLTrdAkNSusUwaibfL8dKDmJmMePDGfq6CITaLk63H0qAO/vg5HIwmV\n", + "KXYcsABo5r3BOOaouPIy8EQsHBoGcTujtChP0AT719S5B4ZVJmonlNirVee7v4xky7kPiSvvGsf4\n", + "hpRDgi2cGoJWzDYJkRE3AHhBXPlUabOxSSx8riK9r4TNLbKew/BuSVtjFlZmFzTfoi8PvMKHgSid\n", + "URwnZU4oFmk74TCOWQ18v+o2muVNHtmrf8CoIdAnUdvYFREZBm+ELnlsJ7uuD8Jpc7I2Vz7SQlz5\n", + "A5W+nYFS+GqiDbLvvvANxq8eAD9/qYbfA68fYyUgm5xB0WpAHxNF97sgPF0FxzJxUjgBa4CK4ko5\n", + "n+1fAvVLRFEFoFdP+NJrehBKK7k0bgzc3AHKr9E3dlXaBHwirhTEdj0DpAJ+HVQ/+BXNDViBtpgo\n", + "/m0J4YdUuVeOQLPhkDS5/dwLybg5Inue08eBC6TLX5LjpMUPxZINJwteBGYsTKb/AidU/riXyNTS\n", + "S2H4KLi24xE2RPgmjU5q5FbQJq7EoBXJTanati5bgfCDkBGVtfuR9F3AU8BC45htvtdomiz9+0Hd\n", + "IKupSmhfVN2/iPD7PQnrVjVLnTUn7gAlv7uFfXtqee1x4p0A690vQr/DqV7bD4srr2+ryNNsslo0\n", + "veCSZVD2IBj2aeJ1wTXaH/imjvDJONjJUtQIP4hq3eRnTIfFld7AZHHlfOOYqbnsf9QKv90HTIG0\n", + "dEwYLOsOTUdAtwfgYAyMaTJ/16LZ5zUVSQxSc7IKuNDPZY6rx19s+E8CGMessloi96PeSO7H+IpM\n", + "bdx7gF8rfcOVGx8TV54Hni54j9bjARu+iUiHykug6gKoWimO2hs/Flf2A1XQgsAFNF36O1NuTiQi\n", + "vTpHPKSQvivZuf1h45iJga4QQgFYZdQD1BFZfv+MGvBQV2icCo22Ezf9AM+JK6uAVbk0zT7m8ExO\n", + "7wlxrRP38/6vkLJ4Iin8wl66c7JoCVl4mrL4GtgPF7Tj2Vu+Yd2HG6h98Up4rj3sHMvKMNZ+Bv2u\n", + "g2FxzLgbTDjc3DyDcRW+AX4H/hZXfjeOmZufARnH/GH1cb4VVxqG0NLyE7TXdh3kjIE07tKMOqtr\n", + "UGYLfDMCln+3Ev5yIdeak0ChnmKP/z+KF1CRrf5BGjVkgz8ZAXHlJ5RnHCuu9DvRBip3HKkBT0HM\n", + "aojcCDGl4VAbmB23ldozLwdWe/dAFWmaSPSqr5BHl0DJ1FA1c3L5MWYL9Xj4/U1SwZ0ASyvDskqw\n", + "uTF1UeperLiyASU1LAOW8kONCiyM78rhcsDeY06t9UxOX50BpQ7DDfPgRlbShht3TOfcv0+EllAQ\n", + "+Qu/3bisgudr3yfSZfPPLAqbQNnP76JVlR28tmPmpiEiTWdkOjYz9x4gLnwZV2x00BDeg8BwceUc\n", + "X0XSPOBp1KAPAG4NtqNxzF5x5RPgJZxFsRxccoQJjf6h0/54NvQfD5vfCvF+rwLqSc5G9MUe/38R\n", + "xjErxZWf0eVkcgHOs81Kvo4AfhFX/mccs6eQhlmo0DDPuQ2QZ2FnmEbo1z+JFqlPXW/m5OA6e8I/\n", + "W+g3/lrjmGCNq/OCbIbfU9QUc0hL5i9co9uXwN8pxiRYYbz6QCOgETMqXM7KDu05PDwrpl6mT1vp\n", + "Wvlnzt+egk4Oy4xjdhXSeDMnp56LoPOqrKrIWLbPn2ZSggrXHYuOTp4VyOAw4jxKkp7wGMnMR6VG\n", + "chxzUSk6TU6i3Z7pTN21jRcyooj7twe9xJWhxs9kLa7MQfXwu6DKrK8C9+Rz2GNQOeou4kpv45iv\n", + "Au1olTRboZILt1Py6Edm2uIj4spoHh33oQkxRGsnkDTgNMBb2+e4evzFyd2TCy8A94gr5QtyEusB\n", + "XYmWzE8RV2oWxuAKH7FJ8GEpzn0b+rWCNm9A2TuBN/fnEqYobO8om+HPrXrSOOaQccwS45ifjGNe\n", + "55fzIG14NDGb4MrrNNm394syzDm9FSrX+x6wQVzZIq5MEVfeF1ceEVcuF1dOD9CNKSg8k1OYyVvx\n", + "mcdAeyrEC6ujk2cF8kgXuPoq2FBW2Tm1Vf4ih8fvGce4/XR6eAYRLVrRvg0MaPIiq9Dw3lX+rmPV\n", + "Oh9Fwz0DgR7i5m/sdiU5GJgDDBJX6vruI640E1d+AL4HvkBXfBFeq9Cf8TOp5QJ/Cd5iVs9/Fbaa\n", + "bxTq9Rf0XBnA3Sh7YqqE3qIvX8hfM3LL0plxlzazr7oQ7mwOfScbkhfWFlcqBziw0JpSWwpoZbwM\n", + "f94b0NvPsfc0KLsezn1HN2+rvtE45hrjmJZADFqu/wzKPKqGai/9COwWV1bakv+3xJW7xJVO4kqs\n", + "L3vFc5+nhp1Tp3dEyWw5nFAqbj0G+oV2sNI2YvMy0PmGZwXy/HhouB3OvANebQvR4ZQCNgPh4kpV\n", + "33EY4O6/Vb/nuTLE1TvE3agH/4a4UsbftYxjPkeZW9+hGj7ve587j/gQXWIOQkNHEQDiSiNx5Utg\n", + "LDAJaGgcMwSVoEmSrIbsvwCJog1vQoW/OH9xjP8/jheAaeLKW7aHaL5hk7sv23j0eLucnVgYg/RG\n", + "JjNHhsRlNaUPRWraUlKPRsCqLvoaNRian7OUWjs7Aq+IK3+ik9cPXuX6fptS5xNlgEPGMdkmkryJ\n", + "wtnPYcKUWnvLBbDkctidxaqx38Um+5rgfbQNHdVDQ0eNgTOBXvb/ZcWV5cAyNkQf4eyWF7I5udqe\n", + "7Y1ISZ/KefTdX41tKzM4stFXmsGfpEdPa6AHngc3zst2EwpE/fSsQEodhucm6Lnv6wbjW3E20Iks\n", + "Pv84yJoo7k2E07dBn/nwVmso8zvRxjGTxZXJqDibX/Ez45gvxZUM1GCnAB+KKz3ySmgwjtkqrozW\n", + "j0AaWRPOpahiZj+fxO8kVGenC/CbccxaceVfVJwyKDvICyfc4y82/CcZjGOWiyspQBLaILswzvm5\n", + "uLIJGCmuJBnHjCiM82YhNonwt+O4oQOkvANbmhNaAZGfvqdH7l7JHPO0mW1SvH6A10Bmm8UvKdwf\n", + "SQ4OP+RVB8nrc6Q2gen3waVt9vN5+ZBYNTYBv9S+fs42DlfK4sklbKryLHVjq9HqNqiwir0Z0fy9\n", + "vVEp9h+tSJOtXwAlxZUzgJUkx3fyR5NNZemezWUyyAhTRU4PCqpP5Kv5E7cDThvOyugefJF+NkOB\n", + "oygPfhxkTRT1dmri/OGpcPZtcOZUPPo5jwD/iCsfGccsC3DfvhZXPOGaHaimzuB8DH8w6vlPRlc+\n", + "n6Eefo6cjHGM8aJ2/mY3e8I9oRr+VejE4Y1ij78YPA/8Ka4MLKjX74FxzHhxpROa8K2FdjfKk3cU\n", + "2BjGRNHlUdhfGbZ4F2kGLyDKra+x9bSGo0vwisD/0DBABDDMLsXH5Sa2lQtyGP68NsvJ8Tmm7k7n\n", + "/M1NcDb5DVXkBTYxPxOYKdLrNviyAVf1hun3w8quUGkZ1EraR5OtVVHD2giow0MrjrI5Nprt92mR\n", + "X+rpwLC42fw184aa8zc130INT6wir6Js/p8D/5TZHT+ZFFul+zXwuGjf2Tfj7URx6XbixtVXSeyy\n", + "q0mb3tsmPJPjz6RixVRKlJwuyQl/B5p4jWO+s8b/A+BFcWWicbI3ggo2bpIX/gX0QFdcc1Cp5FcJ\n", + "HgYfjoq0NbKT0ii0GOyJEG+hv1BPscf/X4dxzDJxZQzqfTxfiOedL66cj0ps1BZXHvCmSgZDljEc\n", + "GkfYEQ3PWGPIWVKWxjNgyGyyq27nXkAUamcro423h4krX6CGejbKfvpUXPkGXQn8mY8eu9k4/Apb\n", + "W1BuLcROhQU1gWpx0PgzkYQZ/oyQ7+ewMsLfiitjQ6Xn5o60dOQo1BsPY1+DtBr6WlNrlZnyz0Ne\n", + "147ki3Z/UPbuc6m0VDnwFrtpsu/P1vPHlE+jUy9Yk9emNtmeg8zv2jMp+g+PWU38V4AaaLeq+QuT\n", + "SSKZ+xbu5bG5VTknESYdXM2P+7vJSxLRdhacdzo7PvA4Dl2DTrzaaSsDGxIUV5r50phzTOYld0P7\n", + "dq3IkAgizBdo7uVM45gR4sp5aN7gf/6cI/t5hqG/z3uBv4HTxJU6xjFrQ7iN/kI9xayeYgBq8O+z\n", + "S/1Cg9U4uQBlWXwt2kIud5Sofj9nnh/Hba3gvAF247A4Ims8QveF9fghfj3pFbwOyH8BUS6J4pJA\n", + "unHMAOOY1kBrVAr8XWCNuPKauNLSK/mWm/yCn1CPTdbG/As13kAr9p8Hvq0Io7tCmwG5Ja+NY6ah\n", + "ycfXgu2XJ5w3dyYNEjNIL69aRYC/+2wcc5jNETtZdglMewi2N/J6d++B/fUouak57khjOqYYk5A3\n", + "KmdsEgyN48ZOUGWh3TYsTvsRB8VCNAx0GfAA8PbCZPpNu41bD5QjbHQyl/47M34dq2tGUrp+S/gg\n", + "Wov6PM578GsYx/yC5kXqomEbP+MeFkfkPmj7CiQ1hNItKzKk7RzjmLvQFrJdRLX3H0NXALcF+Tzv\n", + "An3ElXLWeUohdHbPZiDGJ3ldzOopBhjHLEUtToHYFgHOvRvoBuxH+5oGYs8grsSJK6/zwKSOnPEt\n", + "THgWpj+QtUOVIy2JMM+xds0dkDgGek3Sf6cn5aeAKMszG90VRnbwY2izJXaNY1YZx7xoHNMM1UY/\n", + "hIYVlogrbs2Wclsu9EU/ht8ma/dXhiWlgBeg7kQ49237fkiGDnTp31XcgjcWElcqkrD5FtpPHs3m\n", + "tPW53+f1A6GfTx1E5iTRAuXA5wMxUSAw/xq44kYI80TZcgnr6YotDahtjXRTYBYwDX0OG0FsEhO/\n", + "LU3MVqg+C247G1q963WWXK8xBugDXCOu+DDj7GReZjNUnwMfTYIfPoZt1T3H7mFbyWn8VXsyyT1/\n", + "ZWibvWTIq4HYcMYxG9Hf5y120yhCNPx2Vbqa7OGeYo+/GJnweP0xhX1iuxS+AWUpTBVXMh9CcSVc\n", + "XOlh2Q7TgKN8dO40ho+C5YlkMXcAOXAA6G/MghRjUhKMGdlR/81v1aj1zOQo1J2ANnnLZmgDekbG\n", + "MQuMY55EPcvrgbLbujBw5u3EvdoWNtq76ENf9GP4rdHcXwlMCd20OxY6uBoiAEIRQLPx+XuAoSGv\n", + "rALjTeBbah8IJ37Lg7ndZ90+7T7fyZjkhePQ+7PI33G5w06Ks/vC/kpwwSt2e0i6QPOxfH7jmHTj\n", + "mOeBc1CWzFia7ajBv2fBWSvhugSY8iSMHph1dIldfrv3ecM45hvgCQz9m7aUWZ5VXgSp+u3vbKAS\n", + "C6mnZxu3SNNEfugaT5OjcYQN78CmqRfwW+t00sNGiStRAS43ALjXUjl/A9oGoqD6gW+cv9jjL4bC\n", + "Ssb+Tv4rE3M7/1HjmMdRbvIf4koXceVRtHjpKbT6t7ZxzCNs3fVKDg+yXO8MDmxLKlxNIOuZtfgE\n", + "Onsz+TINba4cfuMYYxzzt3HMA5e+xvQ3f4UVFeFvrzI2L/pijhh/ptE8eO0YIq2h39kAViR4ef2h\n", + "CaAZx/wYuYuttWayIL9Kn+JKN6AjGoduhw8dNOC1/U/GZwArfemrocOzkhD46X04byDUuGx9iGG9\n", + "HIVcxjFr0BXaj1w8N45HqkDF0vDe1TD/WjLzCFHXbyfx70AGOBvik5lfazn7VnSn5a0NdJXXgZmn\n", + "CTf9m31P7zBZbBIbf6zNnlho8ZFu+vvPqmyqEEWAcJ1xzHRgG9qGcQ/wF9A5lDGSM85faLUpoaDY\n", + "8J/8eA544Fh4/ZBZwDQbWIIuXTsBPY1jzjOO+cTY3r7ZPMiIK6dT79xD1P7zMbN9ecAy9/whLZ2S\n", + "e6CTx9vzOHmZhjZPHP59hvQL18DQn+EKL+X1YJLMYI3m0dEJtFq6C+m7BoApT0DrAVDihlWh5i+a\n", + "iiT+70NqpJ9O/aeq5b1S1n7vQ9B4czywwjgmx3jzgAKEeXyegz0PTeLPivO5ftRhkhf+HsLhObT5\n", + "LVYAzYk+fJh1MXs5bQPUOYhGyq5Oh4tncXTmLZy5u7y4kms4JRaSlo2kTPU06NkLRsfB76TVaMoP\n", + "GwOHI63DsbQHXHI3dH5M+wB803YlWh3cI8DlBpBVcBlyuAcvj1+kaSJLq/Tg1+b3h178WDAUG/6T\n", + "HJaaNg6twi00iCulxJVbUargF2hyqiv6w2zpdyxmQQrJoy/lqe/hxhlPmX82vFGYY1KsH0in1rtY\n", + "0RU2nmu3ZUtg5mlJPI8K066hTDa659WUOTyXCtPtn34NfyZOT9tE3NhXIXEMqc9MYvPRzVzz7cRQ\n", + "Q1mxkPTlHuq9MB6cjrotj5WyL6OU1d/QSXlciMcFQgvgn4KcwHslwcVLWxB9dDGhURlzePziSkN0\n", + "UmtChGnB8HK9+TB+Imf9uI2H3jxAj99eJXlsK3Nw8U/oPRsQJPQCaHFYdAb8MEIlnm+8AkY1gibs\n", + "3hc4HGlDWNMfgINloeIyuLcxnLm0LHAdyiir4edy3wCNxZXmqOHv7lttHQCrgPqZOa1DnWqQ9ljj\n", + "UMkDBUWx4S8a8Hj9BeaFiysNxZU3Uf35y9GQTkPjmNeNY8aioYT/E1ee82bGeOEFtFjmGBh9IHnh\n", + "ClouCWPS6vEBEpgly86jVKhNUv7l3DajIt+PbFXifDpGnEMruvILIyL/pXVru0s2uQY/SKXPusWZ\n", + "hq7B9ouptz8x1Ji9p0K172z45Ies7aFUyoor7dHvyEPVLCzDn2+P3xc2zHcbcJe44tdh8MJi1EhG\n", + "iCth4so9aNHT18Ae45g1xixIMdsmX2g+3VyVmIOXcfbO3mjtSZyd/OYB/xfsIp7isBZbYNkgGDUc\n", + "br0U5jWnZuDnxoawMqJgzs2wMw6+brmBC1ZEoqHQUcBnvtIMNlc2GEgyjlmJSg2eHcKts6EeL1ny\n", + "TKnxkMkD+UYxj78IwDhmkbgyAbgLLS7JE+zD2h1dNZyF0t1aGe3+5XutFZbrPwrl+mdKO4sr3YGr\n", + "gZb54MuHiv5EmOfNzol+46o1fqJdh+XUH249x8Nh0Kc8jat0lsGp7dgE1M72eiK8yV7zJzN314aF\n", + "vbVjEgCfeAxvJXLw+LMh1e4DZNZCTAf6oSJhQeEtplbWK0DlWymbo7io7Kr3eJBXgbuNY3aKK6XR\n", + "ldiU3K4ZCHYib04hGn4A45hN4sqDwMfiSivjGL+hOOOYfeLKRlQb50mgFKp2uQp4VFwp6X2sccxY\n", + "60nfD0wXV94DHmdxzAwpcXFnDpc3/qqqvauISx2GczdCky9J/eta6r94mLj/WYaod3OdbEV48zIq\n", + "cvOEM5lW/x5KHfkJLep6GY3DP09OGYkhwDJx5TH0d9MD1WMKhjVAbaT0Jgzwa3844E2HPrbd04o9\n", + "/qKD54CH8uL1iytVxZXH0R/WE8DnaLL2MX9G3wOjXawuBCoAo8SVsuJKLFodea1xTDBDmW+Iqiw2\n", + "ROOmftFoOVcOT6PUo52h1oNQ+kmYfiN1DzbiMZTOWRYNZbwLXMtb7Sfy0h54d6GX0QfYVUYkYQyH\n", + "w2vxcqdhQZbWqeiqwBvPA49ICKqauSl9grfW0S9dkS+Vwto24kN2Rm42jvGsE9oBs4xj9uV2zSCo\n", + "gUonbC7AOQLhC/Q5ezrQDnbi2YMqXf4GXGAcs8wKCq7DT4MSq4T6KqpfFMchmcyyM4XDv7YPQPf1\n", + "K7JXciPrpn9G2N3d4cfGup9vyC0zhLXlt/OIzpjIw8tiLFHgC6AJWrH7qLgyTFwp5TXGbfYz9SNE\n", + "tU6bO0ulkm3Mu6suHPTuTnlsu6cVe/xFBMYxC8WVScCdBCkKsj+u1qh33x0tIrrSOGZWHq+3X1y5\n", + "EvVqJ6P8+AHGMX/k8yMEhRUq6w884Ft16Y0yhpIAt8+Cu2dAjTSIOAq94J+Rxlyb47zJTd+E2+pk\n", + "l1+4+V8oU52I4WcTVhbSx3aG2+oGqAzdjo/hN46ZJa78A9yMSi4HRAjdv8hc7rf4GM74Bv58GOJT\n", + "KzCs7WHeytypM4UU5ilcFpbCatjcAcwTV340jsnm8drCqGFAdeAL45hXfE6xHJ30/cot2MLDq+WM\n", + "s/7mwu2tiO8GowfZ4rSculC+Inu9RCaeuRnGfgrlvNYjQUJug9GQ0uf2+vuA+8WVxWiYs5u48ggw\n", + "wt7PAai33x+oI67UtFz/YFjFWYvHMLZfzezP57Hvnlbs8RctPIt6/aV93xBXSosrfVGGzmf23wbG\n", + "Mbfm1eh7YLKknXeiSd+fgx9RICShNMNfgu2UFs4RgPo7ofZuNfoQWGTMP5995Sb4rgbRO5SLjhAk\n", + "rurP4wddgT0mrkTm9sEWGJOSYkxC4EpZyyj5pw/sqg3Xd4WpD8HuKt7x5JMuvu8L45jNKMPlY08C\n", + "VlwRceVqYC4wi/llP2VVxSv9VGV7DH/wSuvFDffz3lzVKWrd3+vqwUMjnpBbs6363HjZDThyAAAg\n", + "AElEQVQQRJzOE+ps7vMZh6Ce/yJ0Ypgi2gVsHhq3vwxt8BIKu2clbben+qu3ONbd04o9/iIE45gF\n", + "4soU1Ot/HVQ33P59A/AnWm4+thBj8F3Rgp8H0SrfXvHJlC7MDk7iyml23G1z23dRCyZeN4s6n+8j\n", + "U8oiN5GxHDo60msioDo3b3lLq/g1HqloXiT7OR0zTVxZgTI+Pspt3MHhkaeOhH2nQWpjaPsa7K9e\n", + "BsBWVtdHNWEKghaofnxA5E2V1C++QpuouOLKa2jIrSnQneT4qpzWcDBXLa4GI6vp7lbvKZnlQLPc\n", + "G92npXM0EqY96HPZ4KERX/VQCP7cGMdkWD2eO+3LGw+gbLiXgEjgZ1vs+Ak68Q1EK4iHBBsTltlj\n", + "zIL3CVkCvHBQbPiLHp4Fxoora9GY4plo7P1sWwxTaBDt3PUR0NuoRvpSyeCHSmeSPnoup3n2y/7D\n", + "zBdeBD62MhVBse0ilqeUZnLiaCICh05ywrvdYDlax2c6fUdKeO1l4/7Z1BsDevygXv/74spndnWU\n", + "T1hZ56r3xXHuIBW7q3DHBq4bXVdceQpt3TilgCqkoIb/pUBv5lWV1B9syOcutC7kFuBj4AbjmHRJ\n", + "ThjDtq9qU64cRKRDRhRZYZqF/YErYyFpcBhxf9aE89fbtRjEJWosPsWvlHfYLWs5Gjw0ElrILQfe\n", + "BxaKK48ar/alNkl9NVpc2Qbtm/AUGoINQ1fIHcSVUiZ4P2DPCuG4o9jwFyGIK9VQxkBZ9CF7Crg0\n", + "/1WYQa8VgS5p3zGOmQwq7dy6tixcfRVt34iGB6f5+2Hm+TqtgAQ0eRYKonaex9KUFPNwqNfw9SJ/\n", + "YQFXc83hvXzpFaaxcX++86Li9WvAuG3v0GlrJd9zWkxGE6W90eRmntFUJLEbJIXL4gMTL/8o48gf\n", + "Nbak77l9PnvWDSLSzAW+RQ1obt5jUFj6aV0CxNAVXqqk5dfA2g6E0lfBe1JNLUVGiVvhUCUOolIM\n", + "z2Q9nzFRHCkBc2+CqJ2wt7o9Q5lodGV15pw+HKlaS2Wax3wOVW0q2xOLzyGBXeXfmrRZsMn8uDPX\n", + "Zy9vzXUy2Uq/o6u6d33emyeuPIf+Ri4wjnnErhC+R7n9a4CL0JBRIPiTZz4uKI7xn+SwMdK2onLE\n", + "S9AH5WaUWvbdsTD6FslohWw2D7H2ejKmfgCftoCZXuUs+engZAtdBgJPmtD7DuS5tN3T5m9PSR1z\n", + "u5J7GcGoyHK0Sc0W96/0cg0S74ErbrBHDotjaaPLCeDx26Tec8CTIRbtZIN3/9sLWx9t1urgkYg+\n", + "09cfiGf0IGMWpBjHbEKlGioBfcUVXynfvCAebfgeMHEOMVFEpEOvq6Cmd1QpcPzc+zP0bUCHFbfT\n", + "qe5azmk4gLvQ0KOXrLgNaf0y2MvoA7HrWqAyFOXLrmXbgndh9pAsow/ZY/HZCsju/qMFLXfVFu01\n", + "cSwwGLgzQE3LIGArugrHOGY5qnxr0Naa74krzYLkLIoNfzGywyZrb0ObQ3yMxhTrG8f0NY75ChVP\n", + "u/0YXbsLOrlcb3z0+tMgvdYemDkUWm3K2p7PDk590FXnx3k4Js9tFz1FVKvLQ78eUP0h6PvQXuS2\n", + "6ZEkf72c5NHruHlRI265ANLLw+8vZx2cVjGcwKEe0J6saWhz+zzBMyGtqAgvtYP3f4L3TY6q3tPQ\n", + "z/sWKqbn27kpVISQ2E1LJyEJdteBqd4LqsDx81hIGgpx9ybovf3wR1j6E+XidnIbqjF1jbhyAQAx\n", + "q4YReVN2Kmmp63ZRef1rQFVg6cGtvOOkBae/esOGUh5Am6WX8LdPATEBjePnyD/Zif9m4HpxpbPd\n", + "tgslV3wDlCaDKYcuY/hnpfyqw24DSogr5Y/BuIOi2PCfZBBXGosrb6G85u5oC7rGxjH9TfaGHs+i\n", + "FbaFWuhhaXefANcZx2zxfd/DS4/0Sh3ntYOTvU4MWhSTlMdEdJ49fu9KzjlDYO+LMPkjKLWVHSj3\n", + "/3+sj4H+a2H885r09SBqZ0UgWlxp4M+r9/L6nwrgFQaEZ0L6uRE8ORka2G/XZ/XUCZVseAfVm/9U\n", + "XHkor9ciFMPf+88l1PvqMD98RJZGUnBqYQxECdBhLfwzGDqvyvoMVlPoOeB7cWU8Dy37mEt+2ETF\n", + "DouJvOJvSBzD/rl9zOyNL9rCreXrrmVz3hrdA9qwfh3HRsLcoJRd3wSv5/1twI3AJ+JKFbt5IOoI\n", + "pJ75DUu7HqLc6XfDl1aswlM/YM99Qrz+Asf4RaQb6o2EA+8bk52fKyJ9UOMlqGd0pzGmQFohpxps\n", + "PL0HWpnbHE3WtjRBuvkYx8wVV/5Cy+UDFjzlcRzhaMxyiHGMXwXIfCbJ/OEJ1KBNy+Nxefb4vRkd\n", + "m2Jg8Dnw2jkcOXKEbWgF6Th+L50ASdkTm1HXp3L+grVobuBPtHnGCjTZugztkbsMlR0w6Hf4U6jj\n", + "8kxID0zXgz3wWT1l0jiNYyaJdof6ATjLVlWHutJqEWxs4srZnE4ffqp+L4d6X+6vFSbkZP1cSEQM\n", + "ZHCVj8jzpqrUFW0SXwrYBewDqpvvdu0lMJYDDReoDclLLN6IK0noiuhLGyIrTHwCOOJKFWvofa//\n", + "u7jyOfCRaMP3peLKHED21aHxoNFwx0yYdkSTchFAGJzXVCSR5EyVztmFPOagKJDhF5FwtHNNZ2Aj\n", + "MENEfjImW8/LVUB7Y8xuO0kMRQuM/vOwydp+aMhmPfAO8E2gknc/eBbVMRmaBwMQDM+glZ1B2z3m\n", + "NUnmC3ElDv3czXPb1w/yrFu+wJiU0y6QuKp1eHRnHapWXs6mSr/z/MbZZljmTg45+/+mrxtkRu1I\n", + "EVfmo2Gp1SjXvJF9XYx6mY1Qx+YLceVbsk8KKwJ9N94Tkr/+t9arvwi1FwAYx6yzoZNhqJT2FcYx\n", + "6wJ9djXUtZJ4POJ83rngcUluWsKXoSOuVEJDE3eZWZu+JkAi2R/rZyadN90o47d8Ykw1z7ZrypK+\n", + "pDmT0GKmeWgF+D+ohs2kQGNFDX+rIO8HhNF2pUNRSZPr8nOOIOfeKa58jybZfQvPPHgadQ7uQb+/\n", + "AcCgTQ2oALB9mz48L2TtX6EfDPh3Ov/saF30PP5zgRXGKI1QREag9KRMw29MNo/uL6BWAa9ZpODN\n", + "eEiD9HXCwEUOe9DCqARUoOpS45g5eT23ccwccWUGIerGBINNjvVDVxoh9eEtAN4AXs+nZxZyqMeu\n", + "pC4D7qcLddCV6fv/fu2/B26Q/r+pQGXjmH9Qzyybd2YNdDXU898JlEMbwTQC6osrW8i5SlhGMr+S\n", + "zH1BVk9nAAd85TVsVfV1aG3FX+JKbw/zKtu4PIa63FNxHGoNeyZcBP1qe9Mz7SrvC9Th+DroDc1s\n", + "knMEav0FDVNIa7i9xnf/396Zh0lRXvv/c1iHVUCjbKOgLLIIiqCSoIIahTE/NWpcYy4oxng1qLle\n", + "tyxNeeN6jRHUKCIYE5e4xDUCkahIZDEBRUFRBpQru6Cg7DDD+f3xvs30NLN0d1V3z3I+z1PPdFVX\n", + "V71vdc+pt857zvd8RcnSWaxpu4VNu7exZtW3/G7D9HJPgF/7rN7HJJB+GtPKRv3FOF2cTLkNWCyB\n", + "nFDR9QjJQ8AzEsj/VuSa1JjukkAuBOZIIDNxkhSlWw+gyUWt+PzQzXS9DZh+KCxvA5e/51w+S95l\n", + "18zjqhQJzAphDX8n3Eg1zkrg2Cr2v4wcJyrkk8Qwwi1N4Mkj4KbjGNZgJ+v3NOUe4Eo/GRSGAJdA\n", + "8kimET4+gepPuMncbOi4JJ7rVFyEyXkZHqJaV4+fLLsMNxpfhTP4L4aItS8n1JaM99WulUB+iRvx\n", + "DYnLIvibz8GUPSX0wLmEegAHfTSWzz5yN4IPcX83+yfBL6kiW9cf/3f+aeQ5CSQAHiovx+ANdftX\n", + "YF1/v22f8MwY7maaLDxWAT7DuP0HcPqVrhrb1PvZsvK+2bNKnz+xqk9qTP8mgZyDG5H/ZyW7FeOu\n", + "S0b4+Pr/Ah6QQAaEy63Y59j/lkC+xiU0Tq1kn6XixOr+gnu6GU8Dbv5bES9//xl+ArT75ABYkvBL\n", + "2m8nJdRCH3/Kmh8iMgz3qFRhdqaIjE1YnaGqM0K1rAYQj9p4pSeMPAtOXA7PTqXJvZ+zcOoeva/a\n", + "A6SAxvQ9CWQ+brSe8gRr/EmkhVDQejR9d+/h9W2PalhJgCrx8gb3Ab9Iw52VTKWuHnHa7mNwbpmp\n", + "wHka07DZrlC5bEMyz+JuxEPxVbK88fnML9OS2tsMN38QvyEcj7th9cBFkuwBFkkgv6HsiaFYY7o5\n", + "fgyN6evi1FRfxvn9ry67tt5Q778E1sYNP8TDM8UVNRkFDEzNSPpwzDUD4OHEeeLbq0pSSuQ64EMJ\n", + "5AWNaUWFW1YB+0kgrRL7mCbP41yn/0nIp+AKeAg3yVuh4QfQmP5ZAjmN9U2fZ9KQxvxiRofNrVpe\n", + "spGty6Gk3c5G0DTheXp7CZtIw/CLyFDc7ysUYQ3/KqAwYb0QN+ovh4j0w/kkh6tW9pitY0O2pcYR\n", + "j9o4diUseLhMI2RiBjHv1RAAL0sgE1MZ9Sc+idx6Any1Cw79E4P6TpKiMNILKXAV7gkxjOZPOVeP\n", + "d7MMw0n3Dsb9zvp5Ua+o2EeorSI0pqUSyO04f2+15RG973+hX/bSV6TogNZc/87VnNBlNu1Wd6PX\n", + "9s4cgbshdJdANpHsNnKSHb8C3pJAztGYrtlrqGdfn1AUHWDLdj/PMhk4s6LorYqpIGs2DUExjekm\n", + "CeRyXLZzv8RsWP/+Hj953g0Xxpw2fqL358BMCeSZ1PuWEk8Dd0kgB1c1r8KDh73IxWufpuuVjVnQ\n", + "AwZM2n9egyG7Ru55e033htqhqb/FjoZlK53b8zkJpHEqmdl+QDwjvi4isUw6Ejaccx7QXUS6iEgT\n", + "XAZjucgBETkYpxD5Y1VdWsEx6izxqI2DtqYsDJURXoTtfdxosVriTyIzurgIlydfgEn7xo9Hig91\n", + "+yVwbbrqkIkJMK3WMGj/dzhSAimQQC7FTR4+gMuQPERjekvERh9SH/GD85d3kUCq1R2qiPhN+c7W\n", + "DOvzNQ2XzqD3xY8ysM9YHtOY9gda4typ/4MTPivEjUKfxYWm9gA+k0Ce4oT5S2k8ys2j7IknKY9e\n", + "RvPPHsFlBAfpRFVVVsA9HS0fjenfcf7veyrZZa9YW6aoq1r3RyqfiM30uNtwap0/rXLH9d0v57k3\n", + "GvODK2HhxSB72Nz92g4v0XfVhNYse64Jy+Nhqot36ivAGpw7MGeEGvGraomIXI2r1doQmKSqi0Xk\n", + "Cv/+BFykSFvgIXGhx7tV9ZjKjlmXSFcYKiQB8JIE8mh1bpT4k8if+7mqUB39Q3Um2bdpcBvwhP+n\n", + "TJlkuYWjFTa15pavS7hJGzEHuB4nShe51HACG0gx2kRjulsCuRM36h+e7oniN+XbusLJfko3URLD\n", + "Tyyu8Es515xPYDoU5+q6jpPWz2f/F75mwUf7U9qiMWzfypGfrmLApgCniz9PAmmblB9SIWVhnL29\n", + "jtHHd4dQkLwe5/I5zd8IEglt+D234iZ6v6sxnR3B8eI8DMyQQG6tPAu6VQGrjnVCcj1fcdLRg3/P\n", + "N58evvWbQQvfBL5eMrVc2Hs8pHNZhO2sktBx/Ko6lSSflzf48dejgdFhz1MbiTDmvVo0pvMkkA9w\n", + "o/4/VLVv/Enk0VfK0nQg+ieROOJK8p1B6no8e4kbwvc6wLhjYUF7OHsjrQ+azD9nr9KsF6X2pDPi\n", + "Bxf3/Wtx1aiqq8RUjvhNeY/A6UvKtqdyU/aG6BN/7qeAl+j/7d/p/+8BuM93x7nbinCRdw8CPSSQ\n", + "nZR3G8WXpRrTHVGItyW181txEuKTvcsnMcChGDfXEQqN6WZxevkP+O8hkkg1jeknEsjHwA9xSqQV\n", + "4F1ss25wq+t7wRmXg5y8HeeqTB6Y5TyJyzJ3s0z1WuyREuA04qusDBXPvk00+tl6EvE++PHArzOJ\n", + "YGoFBSUN4Ooi6L3e6fDf+hZ0Xk22Sj9WRJVRPcn4J667SYi/T5X4TfnXM8tG/JD+Tdk/WR2LG0m+\n", + "jjM4TXE68UM0pudrTAfiQk+PwCXUzcH18z9wYcabJJDPGb3yT4wocMqhzeKRh+HqwvrJ3b8B9ya9\n", + "FdWIH5xPfjPRS5vEJ3krwdfv1QagDeCDnwB74IJZxbjvIPlJIT7izxmmzlmH0Jj+SwJZRDWVoXL5\n", + "JIKr0dscN5GYNpthR6M9MHuSW394IBSUZO/ppBLSHfGDk/S9WQLpr65IR0pE6R70k6ln4Nwe83BG\n", + "5zKNlc21xUNR/VIu9t2Hoh7C3MNfpOVh+/OdxdAocbAaui7sDTiXz+laVoAnMsPvJ3qvxtWReK6i\n", + "rNsMeQkYJ4H01ph+nPzmPgqibNnOxkY9aF9yKYs7bmZlyyEytu/yhKelz8gwcS1TbMRf9wiAW6ob\n", + "9efiSURcpbC7cXo8GT1qJ9es3dEIbt7D8izNk1RGSlE9ifiInd+R5qi/onqxKWjVVNWOUlys/hag\n", + "FW5yONXPlmhMl7Go7WrmXguv/aG8jlHIurA+ketSYIIEEq80vhanjRSJcJnGdCFOhuT2KI7nj7kb\n", + "J6vys0r3SVQQ5Yv7eWNIAS1LW9BgQHs2/7pvUp1gc/UY4dCYvgt8BIzMc1PAVdX6p4ao05tsCNc3\n", + "oeTfLbkxyy6zZLYAjTMQxHsYOEEC6Z3Oh7JwU74DNxk8BLhNArnLZ+ymiHddlCOaurAa0xm4qL/x\n", + "fl2J1t0D7sb3AwkkyqCSRyhlpBScMr2CMpJJFI5hyZSOaAM4cBGUNCXJVbYMOCwD4b2MMcNfN4mP\n", + "+rMhU5sSEkhXXBLNDWGPlWgIS5uy+7OfVlncInK8MUrLz+8/txWXsHZLNtqVChLIubhSiBd7WZBB\n", + "wECcxlPbKj/siSKMsxpuBo6TQM7y65EafnW1Hm7CTfRGY/PG9jmCzzs1oM8Fp8CzJ8LU05JG8Qm0\n", + "KqC0KSw7BUqaQWn8Ydy5ynxUVSlp/r7CYIa/DqIxnYuL7hiZx2bcA/w+yph6PyJKW50zIjLx84OL\n", + "nDnNZxXnFAmkF24i8lx1Esn4v6fhonr+JYH0SeVYia4L9ze6YuD+BjkK+IO4+sJRj/jBaeTvJsVc\n", + "l+opHMPcR1sw8CHKBAwqm/D2UT5zj4Id66HkWZwHcG2LhJ1yOsFrhr/ukvNRfzzR6nu9ZEGTzYzo\n", + "cS+LIj5FI6A0ByJy5egrUtR6NZ0HP8PjSRWUqsVnpz5ISlo40SGu3sELwI0+wS+xTSUa0+twSWBv\n", + "JYy084Z3Bz6Nm7uJ3PD7/IergN9KIO3CH7FVActOhd0toGVicnBFE94rxsPZq1m+C0p7Q+lonABu\n", + "t0758vOb4a+j+KSVeCp/1oknWr3agNO+HUb/p6fQ7IRv+d90jGQKpC3JHJZ4v4Z/TbtrGtAvqYJS\n", + "qowDzpRAumSnleXxT0aP4eZXKo2m0pj+CRfTP14CGRuZGyRzfgUchRN/jPwJSWO6AKflU6XseGps\n", + "3oE2gMdmwpb2Cdv3nfB2T0db1qJ3uaiokrirZ3IHOPjnIn2LmN/5aOZ0v73quYLoyPcXbWSXQHbx\n", + "29Mayd8rqPcZKfFEq4cHulqpP1xcVmkowtPk3M0T79cB22BDc7ct3X55H+4E4MbstHIf/gs4BCdY\n", + "VyUa03k4v/8pwAsSSOsst62qtmzHuSevIYRKZzX8CjjbJxWGIN0J7zYuP/7pV5zI3V4KOsHgcaz6\n", + "zaEUDOlS9VxBdJjhr8P0Gct+B66h9Xn9OLWCep+R0goKFHjqCBg3rSwjOGIZiLTLLoYlnkl793T4\n", + "aYLDJIN+/R44XwLpFF3r9kUCGYaTRDg3VZluL2R2Ei6Ucm4+5iMS2jIXp7PTwheIifr4G3GaUaEm\n", + "etOf8PZ+/q0HJkzuAmzvABO7sfEwaBtXbAiXHJcKZvjrMIUw5rk3aHbbCbDbf9NZGIUDLtFKgHcm\n", + "Q98vy7ZHnGiV8xF/PJO2xW5IrDOcQSbtepz7JXSUU2VIIJ1xMeuXaBVlOytCY7pLY/oznFvqHQkk\n", + "bZ2hCInholyqyI4NxWM4bbFQbtD0JrwrekIYtQ02u6I0a48sk3gAIkiOqxIz/HWYVlBw/BdO5uDt\n", + "LmXbsyHGFk+0apAglZYFGYic+/iTE8ggVL/uAS7xhW8ixU/iPwfcrzGdnulxNKYTcIXCJ0kgN+Yy\n", + "tjyhDTtw0sP/nY1r5Sd6rwbuiCpRrNpzuieEJ+CsbbS7CNr8GBjVHHocCDNhezsoPj3hE+GS46rD\n", + "DH8dJj5afe1JOOWzsu3ZkDuIOuO0EnLu6omyX04jnydxPviouRdXtevOsAfSmM7C6fycAzztM7Bz\n", + "zbu4qmQPZ+Pm48XzXsVFv+WIwsHwUnP2vxjOWgGcAExuDvcmFbKJJjmuKkyrpw6zV/elNCey0KGL\n", + "sKdAXmL4I+7X3ZTy8bDWMuA7m2m4GXasgPFhbpASyCW4wu+DtIJ6sJmgMV0pgZyAm5SeJYGcpTFX\n", + "WztHFONqDh+Ok5l+IgvnuAX4WAKZpK6ecpbxFdE+PwlaJ6a3NFgGRav26vrwxf1R5klUhBn+OkyO\n", + "xdhyQc5H/FHTZyxH7Pwhe743iJN++6bbdjkc1leETL4XCaQ/brR/ks9QjQyN6Q4JZCQuOmiuBHKh\n", + "xrTaymIRUYxLaBopJbx5Yju57KCNSBQ3yjga0w2+rOUDEsiJWa7pwN4J3pJmMD9RMHTHKtUpI7J7\n", + "7vKY4a/j5GAUnhP6ihQd0Y9bVw+k6wiRaVH98+eaQhjz4AxaD7ocrp8NbXaUL7RS3efjtZJbQcGG\n", + "FpTINfTWJozxYmSR443hOK/6+nTLS+SlIU/QpTUURGmEK6AY6N47oH2jkyltNYKhzzzlosXC3Cgr\n", + "YKI7JBfh3HBZJFzpykhR1bwvrhn5b4ctNXPpA0WjofivvdCzzkcVdDQU94GifLct3eVHMENB//v7\n", + "6OzOri8K+iOYkep1UNBSQX9wIdrz/7ExV9ehcx9GtbmKnSPPRLc3yv73wFg2nLgfb+5siB55Bfpm\n", + "l7LrNQKmRniewYxlFWNpne1rCH2KYMRU+NEM97dPqGuXqe20yV2jxhNPotrZ0GnxQ/bCUrNNfML9\n", + "7ukwOMHNm8qEe/w6ANx2PGxsBh9OoU2urkPfjzh/5SM02dYYRp/htmX5eyguPZC2TUrh7T/CsOVl\n", + "b0QZmaYxncOGJh+xoOMH1StthjxXFjWP0sFcPUaNJ55ENXgldEmo4ZXlGsFZIUyhlfh1WN0KJh8F\n", + "syZDk9LcXYdWUNBiN/zl+bIsZsjq+Zd8eSADKIbWSVP6UUamifQtouW53bjy9S58Z2wX1vcmTGnJ\n", + "2oAZfqPGEx8ld9lU3vDnuApXJISZcI9fh46bYfGDZU8/uboO8fML8J2EAMQsnr/4i94UXD6Lgigq\n", + "klVO4Ri2PNmVt++HE34Lf30K54cvSmnepTZiht+o8URZjrAmkOmEe+J1iBv9XF6HPHwPxTs6caTP\n", + "o8hiZJoPs5x3JSwYlbA9u9mz+cQMv1HjqYNhqRmR7+uQh/MXA92zH5nmwyz3NIJdiZUps5s9m0/E\n", + "zwzntxEiqqo5Tw03jJqKm1wsHONGo5t3wIrxddXfXBm+psBaoGU2Y+zdtR48bt8wy0irjGWFTG2n\n", + "GX7DqGFUbIguXwpzrsm1IUrMG8hy3P4+iPQt4sZPX+SR789no36bzZufu+YH/zyX2bNRkKntNFeP\n", + "YdQ4CsfAxG60WQ6buvhtuZ9sjBehSfTpR5w8VSl7b35ftm3CfjcMZuNQshlp449Z4w19VFgcv2HU\n", + "NA7ZcQAXnAmjjocmmxPeyO1kYwP2u/ULBnY7vtEQhjXvz2u0zGH+hL/5fd0d9l/it2Vfp76+YCN+\n", + "w6gh+KpQMc5v3JcZv4Pnn4GSgoQ9cjfZKNK3qBlFvRfyFAy8DzrPZcXzPYEptGRLDm5APtJm7rWw\n", + "K1EctO5G2uQSM/yGkWf2GnwYCNzJH7pOZsuH90BBHjVdCsds56lmNN4G37sLnpzKMo7kfgbRgHk5\n", + "uAH5SJt1/ZK2191Im1wS2vCLyHDgPlxFm0dV9a4K9hkPjAC2ASNV9f2w5zXqHvmcSMwFyf17/7u8\n", + "tu5UTiFu8OF8jekOYiDSd7fz6edrstGPuNsthcXnuApRwHu03nFgDvIGOvDunEI6HN+Mns230pRP\n", + "GMMWXsyPoFldJKRAUENcdaIuQGNgAdAraZ8iYIp/fSwwNyqhIVvqzpIoQBZfaqsQW3X9m98BPeMC\n", + "tNn1lLT8MQ8xloJ8t204TPsRzBgO0/pAEQyflvBV7F0aMWxePn4LF9J0awfaxvL9Pda0JVPbGfak\n", + "g4FpCes3ATcl7fMwcH7C+ifAQVE03pa6swyHaQr69iHoO4XoknboN03R4RGqMNaE/l13GtrxF+j4\n", + "Y5zCZZQqk5ksld1wO9A2BqOLyxv+y5aGVZNM51oVt0PPvKCsAfm+VjVxydR2hnX1dAJWJKyv9KP6\n", + "6vbpDKwLeW6jDhEXIHuuN8zvCOtawJctYFtDTpVA/g9XVnBdNX83aExL89ODqon372fz4PY3ynR2\n", + "8i00F1f8/LoZXHAu3PM6TFxHtyI2HreGOdfkw90Uv1b/7giNEuqJ5fta1SXCGv5Us7+SEwzynzVm\n", + "1CjiAmD3Ty2//dQm/GP6LVwBHAQcmPC3C3BM0vY2EshGqr9BrAO+1JimNFEYRRZtvH89viq/Pd9C\n", + "c3Ej23Y7XLgQTv4JXDsXms+iuZbmJ7Y9fq3md4SBq8u25/ta1SXCGv5VQGHCeiFuRF/VPp39tnKI\n", + "yNiE1RmqOiNk24xaRGUCYKt3Mc7Xel1e3TEkkEbAAZS/QcT/9kjeLoHsorqbxMsde9J82I1s+/Oh\n", + "ZeOX9BOJaqrQXKLi5qgFcPLnTmt/dj/6SyC9NKaLc92m+LUq7ki3X85022rCtaoJiMhQYGjo43g/\n", + "UaaNaAR8CpwMrAb+BVyoWvZjEZEi4GpVLRKR44D7VPW4pOOommRDvaevSNHBOdFVUYcAAAkCSURB\n", + "VBIAk0AEaE3ZjaCim8VBfFMwgKZNm9N4G7w6IUG9sWhaunVSc9m/dNqUnJ17GSx79kKmbunJBcDd\n", + "wL25dqH1biSnf3ojL58+jrklW9lcE65VTSRvWj0iMoKycM5JqnqHiFwBoKoT/D4PAMOBrcAoVX0v\n", + "isYbRrYROW8GPHsiDXeCaEJC1Xlvqz47NI9Ni4zKbkgSSFdgMq7I/UiN6ZJqDhUZEsjhwGsa08Ny\n", + "dc7aSN60elR1KjA1aduEpPWrw57HMPKDTyQqbZq0ve4kElUme6wx/VwCORm4CpgtgfwPcL/GdE/y\n", + "vlngaGB+Ds5TLzGtHsOokhXjnTJmIrnOos0fGtM9GtP7caHb5wFvSSCH5uDUA4F5OThPvcRkmQ2j\n", + "GmqrZG/USCANgWtx+Tq/ASZka/QvgfwTiGlM38zG8esKpsdvGEZOkEB6AY8D3wKXaky/iPj4DYFN\n", + "QKHGdFN1+9dnMrWd5uoxDCMtfIjnd4E3gPkSyGU+SioqegJrzehnDzP8hmGkjca0RGN6B3ASbvL3\n", + "NQmkU0SHN/9+ljHDbxhGxmhMF+JkWt4F3pdALolg9G+GP8uYHr9hGKHQmO4GAgnkVZzv/xw5tMtz\n", + "fN7rkgxlLgYCL2StwYZN7hqGER0SSFNWNnucdnvOZcofG7LofJwgRGrF4r3sxiago8b021y0uTZj\n", + "k7uGYeQdjelOHj2xDU/ObMiJAQz7jX8n5Xq5vYCVZvSzixl+wzAiplUBq46BCe/D/J8mbK+6Xq5I\n", + "3yJe7/EUS9q3FRkxzeVPGNnAfPyGYUSMl7koKYBvE4V5K5e5cEZ+8DjaNOnGZ92A607LRAXVSA0b\n", + "8RuGETGZyFwUjoGJ3eg4H1YP9NtSdg8ZaWIjfsMwIkV10RSRvqRXvcsXd597LawZkLC9aveQkRlm\n", + "+A3DiBxv5NNw0Xj30KILkrbXHRXUmoS5egzDqAHUbxXUXGNx/IZh1AhMBTV9TJ3TMAyjnmEJXIZh\n", + "GEZKmOE3DMOoZ5jhNwzDqGeY4TcMw6hnmOE3DMOoZ5jhNwzDqGeY4TcMw6hnmOE3DMOoZ5jhNwzD\n", + "qGeY4TcMw6hnmOE3DMOoZ2Rs+EWknYhMF5ElIvK6iLSpYJ9CEXlLRD4SkUUiMiZccw3DMIywhBnx\n", + "3wRMV9UewBt+PZndwHWq2gc4DrhKRHqFOGetRESG5rsN2cT6V7upy/2ry30LQxjDfwbwuH/9OHBW\n", + "8g6qulZVF/jXW4DFQMcQ56ytDM13A7LM0Hw3IMsMzXcDsszQfDcgiwzNdwNqImEM/0Gqus6/Xgcc\n", + "VNXOItIFOAp4N8Q5DcMwjJBUWXpRRKYD7St465eJK6qqIlKpsL+ItASeB67xI3/DMAwjT2RciEVE\n", + "PgGGqupaEekAvKWqh1ewX2Pgb8BUVb2vkmPlvxqMYRhGLSSTQixhiq2/AvwHcJf/+1LyDiIiwCTg\n", + "48qMPmTWcMMwDCMzwoz42wHPAgcDy4HzVHWTiHQEJqrq6SIyBJgJfAjET3Szqk4L3XLDMAwjI2pE\n", + "zV3DMAwjd+Qlc7euJn+JyHAR+UREikXkxkr2Ge/f/0BEjsp1G8NQXf9E5GLfrw9FZJaI9MtHOzMh\n", + "le/O7zdIREpE5Oxcti8sKf42h4rI+/7/bUaOmxiKFH6bB4jINBFZ4Ps3Mg/NzAgRmSwi60RkYRX7\n", + "pGdXVDXnC3A3cIN/fSNwZwX7tAeO9K9bAp8CvfLR3hT71BBYCnQBGgMLktsLFAFT/Otjgbn5bnfE\n", + "/RsM7OdfD68t/Uulbwn7vYkLVjgn3+2O+LtrA3wEdPbrB+S73RH3byxwR7xvwFdAo3y3PcX+HY8L\n", + "hV9Yyftp25V8afXUxeSvY4ClqrpcVXcDfwHOTNpnb79V9V2gjYhUmf9Qg6i2f6o6R1W/8avvAp1z\n", + "3MZMSeW7A/g5Lix5fS4bFwGp9O8i4K+quhJAVTfkuI1hSKV/a4DW/nVr4CtVLclhGzNGVf8JbKxi\n", + "l7TtSr4Mf11M/uoErEhYX+m3VbdPbTGOqfQvkcuAKVltUXRU2zcR6YQzJg/5TbVpciyV76470M67\n", + "V+eJyCU5a114UunfRKCPiKwGPgCuyVHbckHadiVMOGeV1MPkr1QNQXLoam0xICm3U0SGAZcC38te\n", + "cyIllb7dB9zkf6/Cvt9jTSaV/jUGBgAnA82BOSIyV1WLs9qyaEilf7cAC1R1qIgcBkwXkf6qujnL\n", + "bcsVadmVrBl+Vf1+Ze/5iYr2Wpb89WUl+zUG/go8oar75AnUMFYBhQnrhbg7b1X7dPbbagOp9A8/\n", + "oTsRGK6qVT2e1iRS6dvRwF+czecAYISI7FbVV3LTxFCk0r8VwAZV3Q5sF5GZQH+gNhj+VPr3XeA2\n", + "AFVdJiKfAz2BeTlpYXZJ267ky9UTT/6CkMlfNYh5QHcR6SIiTYDzcf1M5BXgJwAichywKcHlVdOp\n", + "tn8icjDwAvBjVV2ahzZmSrV9U9VDVbWrqnbFPYFeWUuMPqT223wZGCIiDUWkOW6S8OMctzNTUunf\n", + "J8ApAN7/3RP4LKetzB7p25U8zVK3A/4BLAFeB9r47R2B1/zrIcAe3Az9+34Znu8Z9mr6NQIXfbQU\n", + "l6gGcAVwRcI+D/j3PwAG5LvNUfYPeBQXLRH/vv6V7zZH+d0l7PsYcHa+2xx1/4DrcZE9C4Ex+W5z\n", + "lP3DPaW96v/vFgIX5bvNafTtaWA1sAv3ZHZpWLtiCVyGYRj1DCu9aBiGUc8ww28YhlHPMMNvGIZR\n", + "zzDDbxiGUc8ww28YhlHPMMNvGIZRzzDDbxiGUc8ww28YhlHPMMNvGBUgIoGIXJOwflttKAZkGKlg\n", + "mbuGUQEicgjwgqoeLSINcPIig7T2CM8ZRqVkTZ3TMGozqvp/IvKViByJkxd/z4y+UVcww28YlfMo\n", + "MApXKGhynttiGJFhrh7DqARfD2IRrqZrd7V/FqOOYCN+w6gEVd0tIm8CG83oG3UJM/yGUQl+Uvc4\n", + "4Nx8t8UwosTCOQ2jAkSkN67s4D9UdVm+22MYUWI+fsMwjHqGjfgNwzDqGWb4DcMw6hlm+A3DMOoZ\n", + "ZvgNwzDqGWb4DcMw6hlm+A3DMOoZ/x+00DEWA9mFZwAAAABJRU5ErkJggg==\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -1128,265 +7618,51 @@ } ], "source": [ - "from explauto import Environment\n", - "environment = Environment.from_configuration('simple_arm', 'low_dimensional')\n", - "\n", - "from explauto.sensorimotor_model import sensorimotor_models\n", - "print 'Available sensorimotor models: {}'.format(sensorimotor_models.keys())\n", - "\n", - "from scipy import spatial\n", - "import numpy as np\n", - "import time\n", - "\n", - "#Environment definition\n", - "from explauto.environment.environment import Environment\n", - "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", - "\n", - "from explauto.sensorimotor_model import sensorimotor_models\n", - "from explauto import SensorimotorModel\n", - "from explauto.utils import rand_bounds\n", - "\n", - "#################\n", - "# FORWARD MODELS#\n", - "#################\n", - "\n", - "# ****\n", - "# *NN*\n", - "# ****\n", - "\n", - "#Creation of the dataset\n", - "random_motors = environment.random_motors(n=1000)\n", - " \n", - "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", - "model = sm_cls(environment.conf, **sm_configs['default'])\n", - "\n", - "for m in random_motors:\n", - " s = environment.compute_sensori_effect(m)\n", - " model.update(m, s)\n", - " \n", - " \n", - "#Test of the model\n", - "test = environment.random_motors(n=50)\n", - "distance = []\n", - "timer = []\n", - "pred_eff = []\n", - "\n", - "for mTest in test :\n", - " start = time.time()\n", - " sTest_pred = model.forward_prediction(mTest)\n", - " end = time.time()\n", - " sTest_eff = environment.compute_sensori_effect(mTest)\n", - " pred_eff.append([np.mean(sTest_pred),np.mean(sTest_eff)])\n", - " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", - " timer.append(end - start)\n", - "# Distance between the predictive and effectiv value\n", - "fwd_comparison = {}\n", - "fwd_comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]\n", - "figure(1)\n", - "for i in pred_eff:\n", - " plot(i[0], i[1], 'ok')\n", - " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", - "title(\"Fwd NN\")\n", - "xlabel(\"mean(x,y) prediction\")\n", - "ylabel(\"mean(x,y) effective\")\n", - "\n", - "\n", - "# *****\n", - "# *WNN*\n", - "# *****\n", - "\n", - "#Creation of the dataset\n", - "random_motors = environment.random_motors(n=10000)\n", - " \n", - "sm_cls, sm_configs = sensorimotor_models['WNN']\n", - "model = sm_cls(environment.conf, **sm_configs['default'])\n", - "\n", - "for m in random_motors:\n", - " s = environment.compute_sensori_effect(m)\n", - " model.update(m, s)\n", - "#Test of the model\n", - "test = environment.random_motors(n=50)\n", - "distance = []\n", - "timer = []\n", - "pred_eff = []\n", - "\n", - "for mTest in test :\n", - " start = time.time()\n", - " sTest_pred = model.forward_prediction(mTest)\n", - " end = time.time()\n", - " sTest_eff = environment.compute_sensori_effect(mTest) \n", - " pred_eff.append([np.mean(sTest_pred),np.mean(sTest_eff)])\n", - " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", - " timer.append(end - start)\n", - "\n", - "# Distance between the predictive and effectiv value\n", - "inv_comparison['WNN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]\n", - "figure(2)\n", - "for i in pred_eff:\n", - " plot(i[0], i[1], 'ok')\n", - " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", - "title(\"Fwd WNN\")\n", - "xlabel(\"mean(x,y) prediction\")\n", - "ylabel(\"mean(x,y) effective\")\n", - "\n", - "\n", - "#******\n", - "#*LWLR*\n", - "#******\n", - "\n", - "#Creation of the dataset\n", - "random_motors = environment.random_motors(n=10000)\n", - " \n", - "sm_cls, sm_configs = sensorimotor_models['LWLR-BFGS']\n", - "model = sm_cls(environment.conf, **sm_configs['default'])\n", - "\n", - "for m in random_motors:\n", - " s = environment.compute_sensori_effect(m)\n", - " model.update(m, s)\n", - " \n", - "#Test of the model\n", - "test = environment.random_motors(n=50)\n", - "distance = []\n", - "timer = []\n", - "pred_eff = []\n", - "\n", - "for mTest in test :\n", - " start = time.time()\n", - " sTest_pred = model.forward_prediction(mTest)\n", - " end = time.time()\n", - " sTest_eff = environment.compute_sensori_effect(mTest)\n", - " pred_eff.append([np.mean(sTest_pred),np.mean(sTest_eff)])\n", - " distance.append(spatial.distance.pdist([sTest_pred,sTest_eff])[0])\n", - " timer.append(end - start)\n", - " \n", - "# Distance between the predictive and effectiv value\n", - "comparison['LWLR'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]\n", - "figure(3)\n", - "for i in pred_eff:\n", - " plot(i[0], i[1], 'ok')\n", - " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", - "title(\"Fwd LWLR\")\n", - "xlabel(\"mean(x,y) prediction\")\n", - "ylabel(\"mean(x,y) effective\")" + "sm_cls, sm_configs = sensorimotor_models['LWLR-CMAES']\n", + "modelCMA = sm_cls(environment.conf, **sm_configs['default'])\n", + "generateFwdDataset(environment, modelCMA)\n", + "inv_CMA = generateInvTest(environment, modelCMA)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inverse models comparisons" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 69, "metadata": { "collapsed": false }, "outputs": [ { - "ename": "ValueError", - "evalue": "angles and lengths must be the same size!", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 15\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mm\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrandom_sensors\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 16\u001b[1;33m \u001b[0ms\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompute_sensori_effect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 17\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ms\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/environment/simple_arm/simple_arm.pyc\u001b[0m in \u001b[0;36mcompute_sensori_effect\u001b[1;34m(self, joint_pos_env)\u001b[0m\n\u001b[0;32m 62\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 63\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mcompute_sensori_effect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mjoint_pos_env\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 64\u001b[1;33m \u001b[0mhand_pos\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mforward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mjoint_pos_env\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlengths\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 65\u001b[0m \u001b[0mhand_pos\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnoise\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mhand_pos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 66\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mhand_pos\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/environment/simple_arm/simple_arm.pyc\u001b[0m in \u001b[0;36mforward\u001b[1;34m(angles, lengths)\u001b[0m\n\u001b[0;32m 16\u001b[0m \u001b[1;33m.\u001b[0m\u001b[1;33m.\u001b[0m \u001b[0mwarning\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mangles\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mlengths\u001b[0m \u001b[0mshould\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mthe\u001b[0m \u001b[0msame\u001b[0m \u001b[0msize\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 17\u001b[0m \"\"\"\n\u001b[1;32m---> 18\u001b[1;33m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mjoint_positions\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mangles\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 19\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.1.1-py2.7.egg/explauto/environment/simple_arm/simple_arm.pyc\u001b[0m in \u001b[0;36mjoint_positions\u001b[1;34m(angles, lengths)\u001b[0m\n\u001b[0;32m 32\u001b[0m \"\"\"\n\u001b[0;32m 33\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mangles\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlengths\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 34\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'angles and lengths must be the same size!'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 35\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 36\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mangles\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mValueError\u001b[0m: angles and lengths must be the same size!" + "name": "stdout", + "output_type": "stream", + "text": [ + "{'max time': 0.010724067687988281, 'mean time': 0.00041047811508178713, 'mean distance': 0.20168292159661327, 'max distance': 0.59686369464621802, 'std time': 0.0010366151892852594, 'std distance': 0.13705465684012169} \n", + "{'max time': 0.033882856369018555, 'mean time': 0.012726972103118897, 'mean distance': 0.23639504162074204, 'max distance': 0.76669268165169346, 'std time': 0.0022641205855169206, 'std distance': 0.14802255009520515} \n", + "{'max time': 0.06476306915283203, 'mean time': 0.037118465900421144, 'mean distance': 0.18990682784894602, 'max distance': 0.67562787551620396, 'std time': 0.010865131486743193, 'std distance': 0.12664684144794416} \n", + "{'max time': 0.07274603843688965, 'mean time': 0.022376320362091064, 'mean distance': 0.2002982591788359, 'max distance': 0.60823034408229959, 'std time': 0.0094409313074482956, 'std distance': 0.12922653395158204} \n", + "{'max time': 0.2664639949798584, 'mean time': 0.14175652027130126, 'mean distance': 0.19038157825142649, 'max distance': 0.62944030876841794, 'std time': 0.018157911349176364, 'std distance': 0.13479678396048539}\n" ] } ], "source": [ - "#################\n", - "# INVERSE MODELS#\n", - "#################\n", - "\n", - "# ****\n", - "# *NN*\n", - "# ****\n", - "\n", - "#Creation of the dataset\n", - "random_sensors = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=10000)\n", - " \n", - "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", - "model = sm_cls(environment.conf, **sm_configs['default'])\n", - "\n", - "for m in random_sensors:\n", - " s = environment.compute_sensori_effect(m)\n", - " model.update(m, s)\n", - "\n", - "#Test of the model\n", - "test_cases = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=50)\n", - "distance = []\n", - "timer = []\n", - "goal_eff = []\n", - "\n", - "for s_g in test_cases :\n", - " start = time.time()\n", - " mTest = model.inverse_prediction(s_g)\n", - " end = time.time()\n", - " s_eff = environment.compute_sensori_effect(mTest)\n", - " distance.append(spatial.distance.pdist([s_g,s_eff])[0])\n", - " goal_eff.append([np.mean(s_g),np.mean(s_eff)])\n", - " timer.append(end - start)\n", - " \n", - "# Distance between the predictive and effectiv value\n", - "inv_comparison = {} #to remove after the first use\n", - "inv_comparison['NN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]\n", - " \n", - "figure(1)\n", - "for i in goal_eff:\n", - " plot(i[0], i[1], 'ok')\n", - " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", - "title(\"Inv NN\")\n", - "xlabel(\"mean(x,y) goal\")\n", - "ylabel(\"mean(x,y) eff\")\n", - "\n", - "# *****\n", - "# *wNN*\n", - "# *****\n", - "\n", - "#Creation of the dataset\n", - "random_sensors = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=10000)\n", - " \n", - "sm_cls, sm_configs = sensorimotor_models['WNN']\n", - "model = sm_cls(environment.conf, **sm_configs['default'])\n", - "\n", - "for s in random_sensors:\n", - " m = environment.compute_sensori_effect(m)\n", - " model.update(m, s)\n", - "\n", - "#Test of the model\n", - "test_cases = rand_bounds(np.array([[0.8,-0.1], [0.9,0.1]]), n=50)\n", - "distance = []\n", - "timer = []\n", - "goal_eff = []\n", - "\n", - "for s_g in test_cases :\n", - " start = time.time()\n", - " mTest = model.inverse_prediction(s_g)\n", - " end = time.time()\n", - " s_eff = environment.compute_sensori_effect(mTest)\n", - " distance.append(spatial.distance.pdist([s_g,s_eff])[0])\n", - " goal_eff.append([np.mean(s_g),np.mean(s_eff)])\n", - " timer.append(end - start)\n", - " \n", - "# Distance between the predictive and effectiv value\n", - "inv_comparison = {} #to remove after the first use\n", - "inv_comparison['WNN'] = [np.mean(distance), np.std(distance) ,max(distance),\n", - " np.mean(timer), np.std(timer), max(timer)]\n", + "print inv_NN, '\\n', inv_WNN, '\\n', inv_BFGS, '\\n', inv_COBYLA, '\\n', inv_CMA" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Distance between $s_p$ and $s$ comparison\n", + "The mean distance is almost the same for each method, that is surprising whereas CMAES was predicted to be better. Some researchs should be done about these results.\n", "\n", - "for m in random_motors:\n", - " s = environment.compute_sensori_effect(m)\n", - " model.update(m, s)\n", - " \n", - "figure(1)\n", - "for i in goal_eff:\n", - " plot(i[0], i[1], 'ok')\n", - " plot([-0.4,0.8], [-0.4,0.8], 'r-', lw=2)\n", - "title(\"Inv NN\")\n", - "xlabel(\"mean(x,y) goal\")\n", - "ylabel(\"mean(x,y) eff\")" + "#### Time processing comparison\n", + "NN is the fastest inverse method and is used to find the first point in BFGS, COBYLA and CMAES look up. CMAES is really long to compute the distance. In this case, as predicted, it is 10 time longer than CMAES." ] } ], From 9b68bc441d0fd1fae6b2a8ac2def3c1c7d415b22 Mon Sep 17 00:00:00 2001 From: Roxane Date: Tue, 23 Feb 2016 14:35:16 +0100 Subject: [PATCH 08/13] Modified the notebook after Sebastien's comments --- ...g_sensorimotor_models_non_parametric.ipynb | 29 ++++++------------- 1 file changed, 9 insertions(+), 20 deletions(-) diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb index 382d248..21efaf0 100644 --- a/notebook/comparing_sensorimotor_models_non_parametric.ipynb +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -294,7 +294,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Forward models using guide\n", + "### Getting started with forward models\n", "\n", "The predicted sensorimotor effect $s_p$ of a command $m$ depending on a given model can be obtained this way after defining the model: " ] @@ -314,7 +314,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In order to test foward models, we are going to generate randomly n $m$ and use one of these models to find out $s_p$. The distance between $s_g$ and the real s plus the time processing are saved in $fwd_comparison$ dictionary." + "In order to test foward models, we are going to generate randomly n $m$ and use one of these models to find out $s_p$. The distance between $s_g$ and the real s plus the time processing are saved in $fwd _ model$ dictionary. " ] }, { @@ -325,7 +325,6 @@ "\n", "To perform a forward prediction, the Nearest Neighbor model looks in the dataset of tuples $(m, s)$ for the nearest neighbor of the given $m$ motor command, and returns its corresponding $s$.\n", "The algorithm comes from scipy library : [scipy.spatial.KDTree.query](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.KDTree.query.html) (with x = $s$, k=1, eps = 0, p = 2, radius = +inf). It returns distance of found nearest neighbors $s_p$.\n", - "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. \n", "\n", "Let's see how to use it : " ] @@ -1805,7 +1804,7 @@ "source": [ "####Locally Weighted Linear Regression forward model\n", "\n", - "The LWLR computes a linear regression of the $k$ nearest neighbors of $m$ and finds the requested $s_p$ given $m$. As before, it is possible to change the number $k$ of nearest neighbors. " + "The LWLR computes a linear regression of the $k$ nearest neighbors of $m$ which is weighted by the distances from $m$ to his neighbors. It finds the requested $s_p$ given $m$. As before, it is possible to change the number $k$ of nearest neighbors. " ] }, { @@ -2508,15 +2507,6 @@ "fwd_LWLR = generateFwdTest(environment, modelLWLR)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Forward models for Non-Stationnary environments\n", - "\n", - "'NSNN' and 'NSLWLR' are modified versions of 'NN' and 'LWLR' where points are not only weighted by distance but also by the number of points that appeared after that one (gaussian with parameter sigma_t=100), to put less weight on old points and allow the learning of Non-Stationnary environments. These models are not finished to be implemented yet." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -2552,7 +2542,7 @@ "source": [ "#### Distance between $s_p$ and $s$ comparison\n", "\n", - "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to his neighbors even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model. So WNN is steadier than LWLR." + "If we look at comparisons values with a 1000 training $(m,s)$, we can easily notice that LWLR is closer to the goal on average than NN or WNN model. NN is really further than the two others which are not so different and the 3 standard deviation is equivalent. And the maximum distance can be sometimes very far away between the prediction and the goal for NN models. With a bigger dataset (10000), NN gets better results and is closest to the two other models even if they are still better. LWLR has still the best average but WNN has a significant better standard deviation and a smallest maximum distance. To conclude, LWLR looks better in average but seems to be less good sometimes than the WNN model for an equal number k of neighbors. " ] }, { @@ -2561,14 +2551,14 @@ "source": [ "#### Time processing comparison\n", "\n", - "NN model is far away better than his neighbor in speed processing in any case : around 4 times better than LWLR model and twice better than WNN with an equal standard deviation. These results were forseeable knowing that LWLR model uses WNN once which himself uses NN search." + "NN model is far away faster than WNN and LWLR in speed processing in any case : around 4 times faster than LWLR model and twice faster than WNN with an equal standard deviation for $n$ = 100. These results were forseeable knowing that LWLR also computes WNN to make its model and WNN uses NN search. These models work sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. In that case, it would be faster to use an approximate nearest neighbor search. The processing time can be accelerated for WNN and LWLR by reducing the number of $k$ neighbors observed but it would also alterate the distance results." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "###Inverse models using guide\n", + "### Getting started with inverse models\n", "\n", "The predicted motor command $m_p$ to reach a goal $s_g$ can be obtained this way :" ] @@ -2598,8 +2588,7 @@ "####Nearest Neighbor inverse model\n", "\n", "\n", - "To perform the inverse inference, the Nearest Neighbor inverse model looks in the dataset of tuples $(m, s)$, the nearest neighbor of the given $s$ motor command, and return its corresponding $m$.\n", - "It works sufficiently well in different typical robotic applications but can be very long if the dataset's size exceed $10⁵$. " + "To perform the inverse inference, the Nearest Neighbor inverse model looks in the dataset of tuples $(m, s)$, the nearest neighbor of the given $s$ motor command, and return its corresponding $m$. " ] }, { @@ -7659,10 +7648,10 @@ "metadata": {}, "source": [ "#### Distance between $s_p$ and $s$ comparison\n", - "The mean distance is almost the same for each method, that is surprising whereas CMAES was predicted to be better. Some researchs should be done about these results.\n", + "The mean distance is almost the same for each method knowing that the training set has 10000 $m,s$ pairs and that we test 100 points. With others parameters, CMAES could have better results.\n", "\n", "#### Time processing comparison\n", - "NN is the fastest inverse method and is used to find the first point in BFGS, COBYLA and CMAES look up. CMAES is really long to compute the distance. In this case, as predicted, it is 10 time longer than CMAES." + "NN is the fastest inverse method and is used to find the first point in BFGS, COBYLA, CMAES and GMR look up. CMAES is almost 4 times slower than Cobyla and BFGS and 10 times slower than WNN to compute the distance for $n$ = 100. " ] } ], From 34a50303794cdf6d5b7ddac634fa0fffd07a9a53 Mon Sep 17 00:00:00 2001 From: Roxane Date: Tue, 23 Feb 2016 23:27:27 +0100 Subject: [PATCH 09/13] V1 of comparing sensorimotor models non parametric notebook --- ...comparing_sensorimotor_models_non_parametric.ipynb | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb index 21efaf0..7034b28 100644 --- a/notebook/comparing_sensorimotor_models_non_parametric.ipynb +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -7651,8 +7651,17 @@ "The mean distance is almost the same for each method knowing that the training set has 10000 $m,s$ pairs and that we test 100 points. With others parameters, CMAES could have better results.\n", "\n", "#### Time processing comparison\n", - "NN is the fastest inverse method and is used to find the first point in BFGS, COBYLA, CMAES and GMR look up. CMAES is almost 4 times slower than Cobyla and BFGS and 10 times slower than WNN to compute the distance for $n$ = 100. " + "NN is the fastest inverse method and is used to find the first point in BFGS, COBYLA, CMAES and GMR look up. CMAES is almost 4 times slower than Cobyla and BFGS and 10 times slower than WNN to compute the distance (for $n$ = 100 observations). " ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] } ], "metadata": { From c010c5bf61ae97fce5623adda98ad25e4ae23c51 Mon Sep 17 00:00:00 2001 From: Roxane Date: Thu, 10 Mar 2016 11:15:19 +0100 Subject: [PATCH 10/13] Created GMR class in gmrinf.py --- explauto/models/gmrinf.py | 262 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 262 insertions(+) create mode 100644 explauto/models/gmrinf.py diff --git a/explauto/models/gmrinf.py b/explauto/models/gmrinf.py new file mode 100644 index 0000000..6859224 --- /dev/null +++ b/explauto/models/gmrinf.py @@ -0,0 +1,262 @@ +import sklearn.mixture +from numpy.linalg import inv, eig +from numpy import ix_, array, inf, sqrt, linspace, zeros, arctan2, matrix, pi + +from .gaussian import Gaussian +import gmr + +def conditional(mean, covar, dims_in, dims_out, covariance_type='full'): + """ Return a function f such that f(x) = p(dims_out | dims_in = x) (f actually returns the mean and covariance of the conditional distribution + """ + in_in = covar[ix_(dims_in, dims_in)] + in_out = covar[ix_(dims_in, dims_out)] + out_in = covar[ix_(dims_out, dims_in)] + out_out = covar[ix_(dims_out, dims_out)] + in_in_inv = inv(in_in) + out_in_dot_in_in_inv = out_in.dot(in_in_inv) + + cond_covar = out_out - out_in_dot_in_in_inv.dot(in_out) + cond_mean = lambda x: mean[dims_out] + out_in_dot_in_in_inv.dot(x - mean[dims_in]) + return lambda x: [cond_mean(x), cond_covar] + + +class GMR(sklearn.mixture.GMM): + def __init__(self, **kwargs): + sklearn.mixture.GMM.__init__(self, **kwargs) + self.in_dims = array([]) + self.out_dims = array([]) + + def __iter__(self): + for weight, mean, covar in zip(self.weights_, self.means_, self.covars_): + yield (weight, mean, covar) + + def probability(self, value): + p = 0. + for k, (w, m, c) in enumerate(self): + p += w * Gaussian(m.reshape(-1,), c).normal(value.reshape(-1,)) + return p + + def sub_gmm(self, inds_k): + gmm = GMM(n_components=len(inds_k), covariance_type=self.covariance_type) + + gmm.weights_, gmm.means_, gmm.covars_ = (self.weights_[inds_k], + self.means_[inds_k, :], + self.covars_[inds_k, :, :]) + gmm.weights_ = gmm.weights_ / gmm.weights_.sum() + return gmm + + def conditional(self, in_dims, out_dims): + conditionals = [] + + for k, (weight_k, mean_k, covar_k) in enumerate(self): + conditionals.append(conditional(mean_k, covar_k, + in_dims, out_dims, + self.covariance_type)) + + cond_weights = lambda v: [(weight_k * Gaussian(mean_k[in_dims].reshape(-1,), + covar_k[ix_(in_dims, in_dims)]).normal(v.reshape(-1,))) + for k, (weight_k, mean_k, covar_k) in enumerate(self)] + + def fres(v): + gmm = GMM(n_components=self.n_components, + covariance_type=self.covariance_type, + random_state=self.random_state, thresh=self.thresh, + min_covar=self.min_covar, n_iter=self.n_iter, n_init=self.n_init, + params=self.params, init_params=self.init_params) + gmm.weights_ = cond_weights(v) + means_covars = [f(v) for f in conditionals] + gmm.means_ = array([mc[0] for mc in means_covars]).reshape(self.n_components, + -1) + gmm._set_covars(array([mc[1] for mc in means_covars])) + return gmm + + return res + + self.in_dims = array(in_dims) + self.out_dims = array(out_dims) + means = zeros((self.n_components, len(out_dims))) + covars = zeros((self.n_components, len(out_dims), len(out_dims))) + weights = zeros((self.n_components,)) + sig_in = [] + inin_inv = [] + out_in = [] + mu_in = [] + for k, (weight_k, mean_k, covar_k) in enumerate(self): + sig_in.append(covar_k[ix_(in_dims, in_dims)]) + inin_inv.append(matrix(sig_in).I) + out_in.append(covar_k[ix_(out_dims, in_dims)]) + mu_in.append(mean_k[in_dims].reshape(-1, 1)) + + means[k, :] = (mean_k[out_dims] + + (out_in * + inin_inv * + (value - mu_in)).T) + + covars[k, :, :] = (covar_k[ix_(out_dims, out_dims)] - + out_in * + inin_inv * + covar_k[ix_(in_dims, out_dims)]) + weights[k] = weight_k * Gaussian(mu_in.reshape(-1,), + sig_in).normal(value.reshape(-1,)) + weights /= sum(weights) + + def p(value): + # hard copy of useful matrices local to the function + pass + + return p + + def inference(self, in_dims, out_dims, value=None): + """ Perform Bayesian inference on the gmm. Let's call V = V1...Vd the d-dimensional space on which the current GMM is defined, such that it represents P(V). Let's call X and Y to disjoint subspaces of V, with corresponding dimension indices in ran. This method returns the GMM for P(Y | X=value). + + :param list in_dims: the dimension indices of X (a subset of range(d)). This can be the empty list if one want to compute the marginal P(Y). + + :param list out_dims: the dimension indices of Y (a subset of range(d), without intersection with in_dims). + + :param numpy.array value: the value of X for which one want to compute the conditional (ignored of in_dims=[]). + + :returns: the gmm corresponding to P(Y | X=value) (or to P(Y) if in_dims=[]) + + .. note:: For example, if X = V1...Vm and Y = Vm+1...Vd, then P(Y | X=v1...vm) is returned by self.inference(in_dims=range(m), out_dims=range(m, d), array([v1, ..., vm])). + """ + + if self.covariance_type != 'diag' and self.covariance_type != 'full': + raise ValueError("covariance type other than 'full' and 'diag' not allowed") + in_dims = array(in_dims) + out_dims = array(out_dims) + value = array(value) + + means = zeros((self.n_components, len(out_dims))) + covars = zeros((self.n_components, len(out_dims), len(out_dims))) + weights = zeros((self.n_components,)) + if in_dims.size: + for k, (weight_k, mean_k, covar_k) in enumerate(self): + + sig_in = covar_k[ix_(in_dims, in_dims)] + inin_inv = matrix(sig_in).I + out_in = covar_k[ix_(out_dims, in_dims)] + mu_in = mean_k[in_dims].reshape(-1, 1) + means[k, :] = (mean_k[out_dims] + + (out_in * + inin_inv * + (value.reshape(-1, 1) - mu_in)).T) + if self.covariance_type == 'full': + covars[k, :, :] = (covar_k[ix_(out_dims, out_dims)] - + out_in * + inin_inv * + covar_k[ix_(in_dims, out_dims)]) + elif self.covariance_type == 'diag': + covars[k, :] = covar_k[out_dims] + + weights[k] = weight_k * Gaussian(mu_in.reshape(-1,), + sig_in).normal(value.reshape(-1,)) + weights /= sum(weights) + else: + means = self.means_[:, out_dims] + if self.covariance_type == 'full': + covars = self.covars_[ix_(range(self.n_components), out_dims, out_dims)] + if self.covariance_type == 'diag': + covars = self.covars_[ix_(range(self.n_components), out_dims)] + weights = self.weights_ + + res = GMM(n_components=self.n_components, + covariance_type=self.covariance_type) + res.weights_ = weights + res.means_ = means + res.covars_ = covars + return res + + def ellipses2D(self, colors): + from matplotlib.patches import Ellipse + + ellipses = [] + + for i, ((weight, mean, _), covar) in enumerate(zip(self, self._get_covars())): + (val, vect) = eig(covar) + + el = Ellipse(mean, + 3.5 * sqrt(val[0]), + 3.5 * sqrt(val[1]), + 180. * arctan2(vect[1, 0], vect[0, 0]) / pi, + fill=False, + linewidth=2) + + el.set_facecolor(colors[i]) + el.set_fill(True) + el.set_alpha(0.5) + + ellipses.append(el) + + return ellipses + + def ellipses3D(self): + from ..utils.ellipsoid import ellipsoid_3d + ellipsoids = [] + for k, (weight_k, mean_k, covar_k) in enumerate(self): + ellipsoids.append(ellipsoid_3d(mean_k, covar_k)) + return ellipsoids + + def plot(self, ax, label=False): + self.plot_projection(ax, range(self.means_.shape[1]), label) + + def plot_projection(self, ax, dims, label=False): + COLORS = self.weights_ / max(self.weights_) + COLORS = [str(c) for c in COLORS] + # COLORS = ['r', 'g', 'b', 'k', 'm']*10000 + gmm_proj = self.inference([], dims, []) + if len(dims) == 1: + x_min, x_max = inf, -inf + for w, m, c in self: + x_min = min(x_min, m[0] - 3. * sqrt(c[0, 0])) + x_max = max(x_max, m[0] + 3. * sqrt(c[0, 0])) + x = linspace(x_min, x_max, 1000) + p = [self.probability(xx) for xx in x] + ax.plot(x, p) + + elif len(dims) == 2: + els = gmm_proj.ellipses2D(COLORS) + for el in els: + ax.add_patch(el) + elif len(dims) == 3: + ellipsoids = gmm_proj.ellipses3D() + for x, y, z in ellipsoids: + ax.plot_wireframe(x, y, z, rstride=4, cstride=4, color='b', alpha=0.2) + else: + print "Can only print 2D or 3D ellipses" + if label: + for k, (w, m, c) in enumerate(gmm_proj): + ax.text(* tuple(m), s=str(k)) + ax.axis('tight') + +#=========================================================================================================== + + + def conditional_GMM(self, in_dims, out_dims, value=None): + """compute the conditional probability of each y given x""" + gmminf = gmr.gmm.sub_gmm(self.n_components) #probably miss a lign distringuish out/in + if in_dims == 6 : #to change !!! + conditional_gmm = local_gmminf.condition([0], value) #gmm de x |y + else: + conditional_gmm = local_gmminf.condition([1], value) #gmm de x |y + return conditional_gmm + + def probility_density(self, in_dims, out_dims, value=None): + proba = self.conditional_GMM(in_dims, out_dims, value).to_probability_density(value) + return proba + + def lse(self, in_dims, out_dims, value=None): + """LSE is the least square estimate in order to compute the most probably value knowing an input value. """ + return self.conditional_GMM(in_dims, out_dims, value).weights.dot(conditional_GMM(in_dims, out_dims, value).means) + + def slse(self, in_dims, out_dims, value=None): + """ SLSE is the S LSE and compute the most probably value of the most important gaussian knowing an input value""" + max_weight = np.max(self.conditional_GMM(in_dims, out_dims, value).weights) + max_ind = np.where(self.conditional_GMM(in_dims, out_dims, value).weights == max_weight)[0][0] + return self.conditional_GMM(in_dims, out_dims, value).weights.means[max_ind] + + def jonathanSampling(self, in_dims, out_dims, value=None): #don't know how to name it + + def stochasticSampling(self, in_dims, out_dims, value=None): + + + From 561ad79ea329f24dc5f7b8bc1b05108bcfcdd2b8 Mon Sep 17 00:00:00 2001 From: Roxane Date: Mon, 14 Mar 2016 21:00:02 +0100 Subject: [PATCH 11/13] V0 of GMR class in gmrinf.py herited from Fabisch gmm librairy and containing regression methods LSE, SLSE, stochastic sampling and optimization --- .../inverse => models}/cma.py | 0 explauto/models/gmrinf.py | 321 +++++------------- .../sensorimotor_model/inverse/cmamodel.py | 3 +- 3 files changed, 78 insertions(+), 246 deletions(-) rename explauto/{sensorimotor_model/inverse => models}/cma.py (100%) diff --git a/explauto/sensorimotor_model/inverse/cma.py b/explauto/models/cma.py similarity index 100% rename from explauto/sensorimotor_model/inverse/cma.py rename to explauto/models/cma.py diff --git a/explauto/models/gmrinf.py b/explauto/models/gmrinf.py index 6859224..0f182f3 100644 --- a/explauto/models/gmrinf.py +++ b/explauto/models/gmrinf.py @@ -1,262 +1,93 @@ -import sklearn.mixture +import numpy as np +import numpy.linalg +import gmr as fabisch_gmr + + from numpy.linalg import inv, eig from numpy import ix_, array, inf, sqrt, linspace, zeros, arctan2, matrix, pi - from .gaussian import Gaussian -import gmr - -def conditional(mean, covar, dims_in, dims_out, covariance_type='full'): - """ Return a function f such that f(x) = p(dims_out | dims_in = x) (f actually returns the mean and covariance of the conditional distribution - """ - in_in = covar[ix_(dims_in, dims_in)] - in_out = covar[ix_(dims_in, dims_out)] - out_in = covar[ix_(dims_out, dims_in)] - out_out = covar[ix_(dims_out, dims_out)] - in_in_inv = inv(in_in) - out_in_dot_in_in_inv = out_in.dot(in_in_inv) +from .models import cma - cond_covar = out_out - out_in_dot_in_in_inv.dot(in_out) - cond_mean = lambda x: mean[dims_out] + out_in_dot_in_in_inv.dot(x - mean[dims_in]) - return lambda x: [cond_mean(x), cond_covar] - -class GMR(sklearn.mixture.GMM): - def __init__(self, **kwargs): - sklearn.mixture.GMM.__init__(self, **kwargs) - self.in_dims = array([]) - self.out_dims = array([]) - - def __iter__(self): - for weight, mean, covar in zip(self.weights_, self.means_, self.covars_): - yield (weight, mean, covar) +class GMR(fabisch_gmr.gmm.GMM): + def __init__(self, n_components): + fabisch_gmr.gmm.GMM.__init__(self, n_components) def probability(self, value): - p = 0. - for k, (w, m, c) in enumerate(self): - p += w * Gaussian(m.reshape(-1,), c).normal(value.reshape(-1,)) - return p - - def sub_gmm(self, inds_k): - gmm = GMM(n_components=len(inds_k), covariance_type=self.covariance_type) - - gmm.weights_, gmm.means_, gmm.covars_ = (self.weights_[inds_k], - self.means_[inds_k, :], - self.covars_[inds_k, :, :]) - gmm.weights_ = gmm.weights_ / gmm.weights_.sum() - return gmm - - def conditional(self, in_dims, out_dims): - conditionals = [] - - for k, (weight_k, mean_k, covar_k) in enumerate(self): - conditionals.append(conditional(mean_k, covar_k, - in_dims, out_dims, - self.covariance_type)) - - cond_weights = lambda v: [(weight_k * Gaussian(mean_k[in_dims].reshape(-1,), - covar_k[ix_(in_dims, in_dims)]).normal(v.reshape(-1,))) - for k, (weight_k, mean_k, covar_k) in enumerate(self)] - - def fres(v): - gmm = GMM(n_components=self.n_components, - covariance_type=self.covariance_type, - random_state=self.random_state, thresh=self.thresh, - min_covar=self.min_covar, n_iter=self.n_iter, n_init=self.n_init, - params=self.params, init_params=self.init_params) - gmm.weights_ = cond_weights(v) - means_covars = [f(v) for f in conditionals] - gmm.means_ = array([mc[0] for mc in means_covars]).reshape(self.n_components, - -1) - gmm._set_covars(array([mc[1] for mc in means_covars])) - return gmm - - return res - - self.in_dims = array(in_dims) - self.out_dims = array(out_dims) - means = zeros((self.n_components, len(out_dims))) - covars = zeros((self.n_components, len(out_dims), len(out_dims))) - weights = zeros((self.n_components,)) - sig_in = [] - inin_inv = [] - out_in = [] - mu_in = [] - for k, (weight_k, mean_k, covar_k) in enumerate(self): - sig_in.append(covar_k[ix_(in_dims, in_dims)]) - inin_inv.append(matrix(sig_in).I) - out_in.append(covar_k[ix_(out_dims, in_dims)]) - mu_in.append(mean_k[in_dims].reshape(-1, 1)) - - means[k, :] = (mean_k[out_dims] + - (out_in * - inin_inv * - (value - mu_in)).T) - - covars[k, :, :] = (covar_k[ix_(out_dims, out_dims)] - - out_in * - inin_inv * - covar_k[ix_(in_dims, out_dims)]) - weights[k] = weight_k * Gaussian(mu_in.reshape(-1,), - sig_in).normal(value.reshape(-1,)) - weights /= sum(weights) - - def p(value): - # hard copy of useful matrices local to the function - pass - + """ + return the probability of x knowing y + """ + proba = 0. + pmc = zip(self.priors, self.means, self.covariances) + for p,m,c in pmc: + proba += p * Gaussian(m.reshape(-1,), c).normal(value.reshape(-1,)) return p - - def inference(self, in_dims, out_dims, value=None): - """ Perform Bayesian inference on the gmm. Let's call V = V1...Vd the d-dimensional space on which the current GMM is defined, such that it represents P(V). Let's call X and Y to disjoint subspaces of V, with corresponding dimension indices in ran. This method returns the GMM for P(Y | X=value). - - :param list in_dims: the dimension indices of X (a subset of range(d)). This can be the empty list if one want to compute the marginal P(Y). - - :param list out_dims: the dimension indices of Y (a subset of range(d), without intersection with in_dims). - - :param numpy.array value: the value of X for which one want to compute the conditional (ignored of in_dims=[]). - - :returns: the gmm corresponding to P(Y | X=value) (or to P(Y) if in_dims=[]) - - .. note:: For example, if X = V1...Vm and Y = Vm+1...Vd, then P(Y | X=v1...vm) is returned by self.inference(in_dims=range(m), out_dims=range(m, d), array([v1, ..., vm])). + + def regression(self, regression_method="slse", in_dims, out_dims, value, **kwargs): + if regression_method == "lse": + return self.regression_lse(in_dims, out_dims, value) + elif regression_method == "slse": + return self.regression_slse(in_dims, out_dims, value) + elif regression_method == "optimization": + return self.regression_optimization(in_dims, out_dims, value, **kwargs) + elif regression_method == "stochastic_sampling": + return self.regression_stochastic_sampling(in_dims, out_dims, value) + else: + raise NotImplementedError + + def regression_lse(self, in_dims, out_dims, value): """ - - if self.covariance_type != 'diag' and self.covariance_type != 'full': - raise ValueError("covariance type other than 'full' and 'diag' not allowed") - in_dims = array(in_dims) - out_dims = array(out_dims) - value = array(value) - - means = zeros((self.n_components, len(out_dims))) - covars = zeros((self.n_components, len(out_dims), len(out_dims))) - weights = zeros((self.n_components,)) - if in_dims.size: - for k, (weight_k, mean_k, covar_k) in enumerate(self): - - sig_in = covar_k[ix_(in_dims, in_dims)] - inin_inv = matrix(sig_in).I - out_in = covar_k[ix_(out_dims, in_dims)] - mu_in = mean_k[in_dims].reshape(-1, 1) - means[k, :] = (mean_k[out_dims] + - (out_in * - inin_inv * - (value.reshape(-1, 1) - mu_in)).T) - if self.covariance_type == 'full': - covars[k, :, :] = (covar_k[ix_(out_dims, out_dims)] - - out_in * - inin_inv * - covar_k[ix_(in_dims, out_dims)]) - elif self.covariance_type == 'diag': - covars[k, :] = covar_k[out_dims] - - weights[k] = weight_k * Gaussian(mu_in.reshape(-1,), - sig_in).normal(value.reshape(-1,)) - weights /= sum(weights) - else: - means = self.means_[:, out_dims] - if self.covariance_type == 'full': - covars = self.covars_[ix_(range(self.n_components), out_dims, out_dims)] - if self.covariance_type == 'diag': - covars = self.covars_[ix_(range(self.n_components), out_dims)] - weights = self.weights_ - - res = GMM(n_components=self.n_components, - covariance_type=self.covariance_type) - res.weights_ = weights - res.means_ = means - res.covars_ = covars - return res - - def ellipses2D(self, colors): - from matplotlib.patches import Ellipse - - ellipses = [] - - for i, ((weight, mean, _), covar) in enumerate(zip(self, self._get_covars())): - (val, vect) = eig(covar) - - el = Ellipse(mean, - 3.5 * sqrt(val[0]), - 3.5 * sqrt(val[1]), - 180. * arctan2(vect[1, 0], vect[0, 0]) / pi, - fill=False, - linewidth=2) - - el.set_facecolor(colors[i]) - el.set_fill(True) - el.set_alpha(0.5) - - ellipses.append(el) - - return ellipses - - def ellipses3D(self): - from ..utils.ellipsoid import ellipsoid_3d - ellipsoids = [] - for k, (weight_k, mean_k, covar_k) in enumerate(self): - ellipsoids.append(ellipsoid_3d(mean_k, covar_k)) - return ellipsoids - - def plot(self, ax, label=False): - self.plot_projection(ax, range(self.means_.shape[1]), label) - - def plot_projection(self, ax, dims, label=False): - COLORS = self.weights_ / max(self.weights_) - COLORS = [str(c) for c in COLORS] - # COLORS = ['r', 'g', 'b', 'k', 'm']*10000 - gmm_proj = self.inference([], dims, []) - if len(dims) == 1: - x_min, x_max = inf, -inf - for w, m, c in self: - x_min = min(x_min, m[0] - 3. * sqrt(c[0, 0])) - x_max = max(x_max, m[0] + 3. * sqrt(c[0, 0])) - x = linspace(x_min, x_max, 1000) - p = [self.probability(xx) for xx in x] - ax.plot(x, p) - - elif len(dims) == 2: - els = gmm_proj.ellipses2D(COLORS) - for el in els: - ax.add_patch(el) - elif len(dims) == 3: - ellipsoids = gmm_proj.ellipses3D() - for x, y, z in ellipsoids: - ax.plot_wireframe(x, y, z, rstride=4, cstride=4, color='b', alpha=0.2) - else: - print "Can only print 2D or 3D ellipses" - if label: - for k, (w, m, c) in enumerate(gmm_proj): - ax.text(* tuple(m), s=str(k)) - ax.axis('tight') - -#=========================================================================================================== + LSE is the least square estimate that computes the most probably value knowing an input value. + It is the computation of the weighted mean of a value for each gaussian of the GMM + """ + conditional_gmm = self.condition(in_dims, value) + assert(len(conditional_gmm)==out_dims) + return conditional_gmm.weights.dot(conditional_gmm.means) - - def conditional_GMM(self, in_dims, out_dims, value=None): - """compute the conditional probability of each y given x""" - gmminf = gmr.gmm.sub_gmm(self.n_components) #probably miss a lign distringuish out/in - if in_dims == 6 : #to change !!! - conditional_gmm = local_gmminf.condition([0], value) #gmm de x |y - else: - conditional_gmm = local_gmminf.condition([1], value) #gmm de x |y - return conditional_gmm + def regression_slse(self, in_dims, out_dims, value): + """ + SLSE is the Single component LSE and computes the most probably value of the most important gaussian + knowing an input value. + """ + conditional_gmm = self.condition(in_dims, value) + assert(len(conditional_gmm)==out_dims) + max_weight = np.max(conditional_gmm.weights) + max_ind = np.where(conditional_gmm.weights == max_weight)[0][0] + return conditional_gmm.weights.means[max_ind] + + def regression_optimization(self, in_dims, out_dims, value, optimization_method="CMAES", + optimization_parameters={"sigma":0.1, "maxfevals":200, "bounds":None}, + x_guess): + """ + This sampling is the obtained by the minimization of the error x knowing y by using an optimization method + as CMAES or BFGS + """ + conditional_gmm = self.condition(in_dims, value) + assert(len(conditional_gmm)==out_dims) + f = lambda x: - conditional_gmm.probablity(x) - def probility_density(self, in_dims, out_dims, value=None): - proba = self.conditional_GMM(in_dims, out_dims, value).to_probability_density(value) - return proba + if optimization_method=="CMAES": + res = cma.fmin(f, x_guess, optimization_parameters["sigma"], + options={'bounds':optimization_parameters["bounds"], + 'verb_log':0, + 'verb_disp':False, + 'maxfevals':optimization_parameters["maxfevals"]}) - def lse(self, in_dims, out_dims, value=None): - """LSE is the least square estimate in order to compute the most probably value knowing an input value. """ - return self.conditional_GMM(in_dims, out_dims, value).weights.dot(conditional_GMM(in_dims, out_dims, value).means) + elif optimization_method=="BFGS": #TODO + raise NotImplementedError - def slse(self, in_dims, out_dims, value=None): - """ SLSE is the S LSE and compute the most probably value of the most important gaussian knowing an input value""" - max_weight = np.max(self.conditional_GMM(in_dims, out_dims, value).weights) - max_ind = np.where(self.conditional_GMM(in_dims, out_dims, value).weights == max_weight)[0][0] - return self.conditional_GMM(in_dims, out_dims, value).weights.means[max_ind] + else: + raise NotImplementedError + # ....... - def jonathanSampling(self, in_dims, out_dims, value=None): #don't know how to name it - - def stochasticSampling(self, in_dims, out_dims, value=None): + return res[0] #index to check, it might be 1 + def regression_stochastic_sampling(self, in_dims, out_dims, value): + """ + This method returns a random value according to the conditional probability + """ + conditional_gmm = self.condition(in_dims, value) + assert(len(conditional_gmm)==out_dims) + return conditional_gmm.sample(n_samples=1)[0] diff --git a/explauto/sensorimotor_model/inverse/cmamodel.py b/explauto/sensorimotor_model/inverse/cmamodel.py index 49ea87f..87251ef 100644 --- a/explauto/sensorimotor_model/inverse/cmamodel.py +++ b/explauto/sensorimotor_model/inverse/cmamodel.py @@ -1,6 +1,7 @@ +import explauto.models.cma from .optimize import OptimizedInverseModel -from . import cma + class CMAESInverseModel(OptimizedInverseModel): From 4a0afffb8cfb44d924ba464c3c0e7a6f19ae9d5f Mon Sep 17 00:00:00 2001 From: Roxane Date: Tue, 19 Apr 2016 16:17:59 +0200 Subject: [PATCH 12/13] Advance --- explauto/models/gmrinf.py | 64 ++-- notebook/GMR class test.ipynb | 331 ++++++++++++++++++ ...g_sensorimotor_models_non_parametric.ipynb | 16 +- 3 files changed, 386 insertions(+), 25 deletions(-) create mode 100644 notebook/GMR class test.ipynb diff --git a/explauto/models/gmrinf.py b/explauto/models/gmrinf.py index 0f182f3..06b197b 100644 --- a/explauto/models/gmrinf.py +++ b/explauto/models/gmrinf.py @@ -1,12 +1,12 @@ import numpy as np import numpy.linalg import gmr as fabisch_gmr +import cma from numpy.linalg import inv, eig from numpy import ix_, array, inf, sqrt, linspace, zeros, arctan2, matrix, pi from .gaussian import Gaussian -from .models import cma class GMR(fabisch_gmr.gmm.GMM): @@ -14,18 +14,49 @@ def __init__(self, n_components): fabisch_gmr.gmm.GMM.__init__(self, n_components) def probability(self, value): + """Compute the probability of x knowing y + + Parameters + ---------- + value : array, shape(n_samples, n_features) + Y + + Returns + ------- + proba : float, + X """ - return the probability of x knowing y - """ + proba = 0. pmc = zip(self.priors, self.means, self.covariances) for p,m,c in pmc: proba += p * Gaussian(m.reshape(-1,), c).normal(value.reshape(-1,)) - return p + return proba - def regression(self, regression_method="slse", in_dims, out_dims, value, **kwargs): + def regression(self, in_dims, out_dims, value, regression_method="slse", **kwargs): + """ Compute a prediction y knowing a value x + + Parameters + ---------- + in_dims : array, shape (n_input_features,) + Indices of dimensions of the input + + out_dims : array, shape (n_output_features,) + Indices of dimensions of the output + + value : array, shape (n_input_features,) + Value of the input + + regression_method : string + + Returns + ------- + y : array, shape(n_output_features,) + Value of the output + + """ if regression_method == "lse": - return self.regression_lse(in_dims, out_dims, value) + return self.predict(in_dims, value)[0] elif regression_method == "slse": return self.regression_slse(in_dims, out_dims, value) elif regression_method == "optimization": @@ -35,14 +66,6 @@ def regression(self, regression_method="slse", in_dims, out_dims, value, **kwarg else: raise NotImplementedError - def regression_lse(self, in_dims, out_dims, value): - """ - LSE is the least square estimate that computes the most probably value knowing an input value. - It is the computation of the weighted mean of a value for each gaussian of the GMM - """ - conditional_gmm = self.condition(in_dims, value) - assert(len(conditional_gmm)==out_dims) - return conditional_gmm.weights.dot(conditional_gmm.means) def regression_slse(self, in_dims, out_dims, value): """ @@ -50,20 +73,18 @@ def regression_slse(self, in_dims, out_dims, value): knowing an input value. """ conditional_gmm = self.condition(in_dims, value) - assert(len(conditional_gmm)==out_dims) - max_weight = np.max(conditional_gmm.weights) - max_ind = np.where(conditional_gmm.weights == max_weight)[0][0] - return conditional_gmm.weights.means[max_ind] + max_prior = np.max(conditional_gmm.priors) + max_ind = np.where(conditional_gmm.priors == max_prior)[0][0] + return conditional_gmm.means[max_ind] - def regression_optimization(self, in_dims, out_dims, value, optimization_method="CMAES", + def regression_optimization(self, in_dims, out_dims, value, x_guess, optimization_parameters={"sigma":0.1, "maxfevals":200, "bounds":None}, - x_guess): + optimization_method="CMAES"): """ This sampling is the obtained by the minimization of the error x knowing y by using an optimization method as CMAES or BFGS """ conditional_gmm = self.condition(in_dims, value) - assert(len(conditional_gmm)==out_dims) f = lambda x: - conditional_gmm.probablity(x) if optimization_method=="CMAES": @@ -87,7 +108,6 @@ def regression_stochastic_sampling(self, in_dims, out_dims, value): This method returns a random value according to the conditional probability """ conditional_gmm = self.condition(in_dims, value) - assert(len(conditional_gmm)==out_dims) return conditional_gmm.sample(n_samples=1)[0] diff --git a/notebook/GMR class test.ipynb b/notebook/GMR class test.ipynb new file mode 100644 index 0000000..1208d91 --- /dev/null +++ b/notebook/GMR class test.ipynb @@ -0,0 +1,331 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy as sp\n", + "import time\n", + "import sys\n", + "sys.path.append('/usr/local/lib/python2.7/dist-packages/gmr-1.1_git-py2.7.egg')\n", + "import gmr as gaussian_regression" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#Environment definition\n", + "from scipy import spatial\n", + "from explauto.utils import rand_bounds\n", + "from explauto.environment.environment import Environment\n", + "from explauto import SensorimotorModel\n", + "from explauto.sensorimotor_model import sensorimotor_models" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from explauto.models.gmrinf import GMR" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", + "model = sm_cls(environment.conf, **sm_configs['default'])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#Creation of the total dataset\n", + "def generateFwdDataset(_environment, _model, _n = 1000):\n", + " random_motors = _environment.random_motors(n=_n)\n", + " \n", + " for m in random_motors:\n", + " s = _environment.compute_sensori_effect(m)\n", + " _model.update(m, s)\n", + "generateFwdDataset(environment, model)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "x_g = environment.random_motors(n=1)\n", + "#Creation fof a local dataset depending on x_g\n", + "l_dist, l_index = model.model.imodel.fmodel.dataset.nn_x(x_g[0], 100)\n", + "l_nn = []\n", + "col1 = []\n", + "col2 = []\n", + "for index in l_index:\n", + " col1.append(model.model.imodel.fmodel.dataset.get_xy(index)[0])\n", + " col2.append(model.model.imodel.fmodel.dataset.get_xy(index)[1])\n", + " l_nn.append(model.model.imodel.fmodel.dataset.get_xy(index))\n", + "lnn_nparray = np.array(l_nn)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_list = model.model.imodel.fmodel.dataset.data" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data_np = np.array(data_list).T" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "data = []\n", + "for i in range(len(data_np)):\n", + " data.append(np.hstack(data_np[i,:]))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "gmr = GMR(n_components=3)\n", + "gmr = gmr.from_samples(np.array(data))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "conditional = gmr.condition([0, 1, 2, 3, 4, 5, 6], [-0.76151596, 0.85728845, 0.0987334 , 0.46247676, -0.16366163,\n", + " 0.27212757, 0.08281898])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.00477281 0.98996846 0.00525874]\n" + ] + } + ], + "source": [ + "print conditional.priors" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "prediction = gmr.predict(np.array([0, 1, 2, 3, 4, 5, 6]), np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", + " [0.27212757], [0.08281898]])))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.8076785 -0.07856919]\n" + ] + } + ], + "source": [ + "print prediction[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.541884810781\n" + ] + } + ], + "source": [ + "proba = gmr.probability(np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", + " [0.27212757], [0.08281898], [0.84411128], [-0.07436732]])))\n", + "print proba" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "reg = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", + " [0.27212757], [0.08281898]])), \"lse\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.8076785 -0.07856919]\n" + ] + } + ], + "source": [ + "print reg" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "slse = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", + " [0.27212757], [0.08281898]])), \"slse\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.8044823 -0.07751704]\n" + ] + } + ], + "source": [ + "print slse" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebook/comparing_sensorimotor_models_non_parametric.ipynb b/notebook/comparing_sensorimotor_models_non_parametric.ipynb index 7034b28..6d547a0 100644 --- a/notebook/comparing_sensorimotor_models_non_parametric.ipynb +++ b/notebook/comparing_sensorimotor_models_non_parametric.ipynb @@ -188,9 +188,9 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": null, "metadata": { - "collapsed": false + "collapsed": true }, "outputs": [], "source": [ @@ -200,7 +200,17 @@ " \n", " for m in random_motors:\n", " s = _environment.compute_sensori_effect(m)\n", - " _model.update(m, s)\n", + " _model.update(m, s)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ " \n", "# Distance between the predictive and effectiv value\n", " \n", From 782640c96fed3c3243a82057459b107f970a08b1 Mon Sep 17 00:00:00 2001 From: Roxane Date: Wed, 20 Apr 2016 10:54:14 +0200 Subject: [PATCH 13/13] Test GMR class notebook + started to write IloGmr sensori motor class --- explauto/sensorimotor_model/ilo_gmr.py | 101 ++ notebook/GMR class test.ipynb | 238 +++- ...n_sensorimotor_models_non_parametric.ipynb | 1210 ----------------- 3 files changed, 288 insertions(+), 1261 deletions(-) create mode 100644 explauto/sensorimotor_model/ilo_gmr.py delete mode 100644 notebook/comparison_sensorimotor_models_non_parametric.ipynb diff --git a/explauto/sensorimotor_model/ilo_gmr.py b/explauto/sensorimotor_model/ilo_gmr.py new file mode 100644 index 0000000..5d3e06b --- /dev/null +++ b/explauto/sensorimotor_model/ilo_gmr.py @@ -0,0 +1,101 @@ +import numpy as np + +from numpy import array, hstack + +from ..exceptions import ExplautoBootstrapError +from .sensorimotor_model import SensorimotorModel +from explauto.models.dataset import Dataset + +from .inverse.cmamodel import CMAESInverseModel as CMAES +from ..models.gmrinf import GMR +from sklearn.linear_model.sgd_fast import Regression + +class IloGmr(SensorimotorModel, GMR): + """GMR adapted to sensori motor models""" + + def __init__(self, conf, n_components=3): #choix methode dans init + SensorimotorModel.__init__(self, conf) + GMR.__init__(self, n_components) + self.n_neighbors = max(100, (conf.ndims) ** 2) # at least 100 neighbors + self.n_neighbors = min(1000, self.n_neighbors) # at most 1000 neighbors + self.min_n_neighbors = 20 # otherwise raise ExplautoBootstrapError + self.m_dims = conf.m_dims + self.s_dims = conf.s_dims + + def infer(self, in_dims, out_dims, value, method="direct", regression="SLSE"): + if method=="direct": + res = self.infer_direct(in_dims, out_dims, value, regression) + elif method=="undirect": + res = self.infer_undirect(in_dims, out_dims, value, regression) + else: + pass + return res + + def update(self, m, s): + self.dataset.add_xy(tuple(m), tuple(s)) + pass + + + def infer_undirect(self, in_dims, out_dims, xq, regression = CMAES): + + cma = CMAES(in_dims, out_dims, fmodel=None, cmaes_sigma=0.05, maxfevals=20) + + def infer_direct(self,in_dims, out_dims, xq, regression = CMAES): + pass + + + #=================================================================================== + #BROUILLON + def predict_direct(self, in_dims, out_dims, xq, method): + """dire ce que fait la fct et d'ou elle vient""" + + #local_gmrinf = (3, local_gmm.priors_, local_gmm.means_, local_gmm.covars_) + + #conditional_gmm = local_gmrinf.condition(xq) + + #def infer_direct(self, in_dims, out_dims, xq, method == 1): + """utilise directement methode sur modele inverse""" + + + + #manque optimisation + + + #faire des fonctions pour chaque méthode i), ii), iii), iv) dans GMR + #faire update et infer ici + #toutes les méthodes (inverse direct et 4 étapes) + 4 méthodes i), ... fonctionnent avec GMM classique et GMM local donc les mettre dans classe GMR + # => mettre les fonctions une classe GMM mais différent de GMMinf avec seulement ce qui est utile (appelé différent : GMR . GMR dans models + #Mettre classe GMR dans models + # sciopt et optimize à aller chercher pour implémenter méthode iii) + #CMAES prend f(x) en entrée qu'on va définir avec GMM(x,y) ou | + #Récupérer code de infer de CMAESInverseModel dans classe GMR après avoir construit le f(x) = GMM(x,y) + #pour l'instant faire que avec CMAES et pas avec BFGS, etc. + #dans inverse, sciopt, sciopt.optimize.minimize de infer_x , on pourra changer algo (plus tard) + + #GMR doit pouvoir faire des GMM conditionnelles (infer ou + #robuste inverse/direct + #CMAES fmin utilisé dans méthode optimilisation (iii) ) + + # Paramètre nombre de gaussienne de GMR + + #ILOGMR + #il faut écrire une fonction par méthode ( 1) 4étapes ou 2) inverse directement. Je sépare comment pour faire inverse et direct ? + #GMR + #j' ai encore du mal a voir différence entre ii) et iii) : + + + + + + + + + + + + + + + + + diff --git a/notebook/GMR class test.ipynb b/notebook/GMR class test.ipynb index 1208d91..2651861 100644 --- a/notebook/GMR class test.ipynb +++ b/notebook/GMR class test.ipynb @@ -40,7 +40,8 @@ }, "outputs": [], "source": [ - "from explauto.models.gmrinf import GMR" + "from explauto.models.gmrinf import GMR\n", + "from explauto.sensorimotor_model.ilo_gmr import IloGmr" ] }, { @@ -84,27 +85,6 @@ "generateFwdDataset(environment, model)" ] }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "x_g = environment.random_motors(n=1)\n", - "#Creation fof a local dataset depending on x_g\n", - "l_dist, l_index = model.model.imodel.fmodel.dataset.nn_x(x_g[0], 100)\n", - "l_nn = []\n", - "col1 = []\n", - "col2 = []\n", - "for index in l_index:\n", - " col1.append(model.model.imodel.fmodel.dataset.get_xy(index)[0])\n", - " col2.append(model.model.imodel.fmodel.dataset.get_xy(index)[1])\n", - " l_nn.append(model.model.imodel.fmodel.dataset.get_xy(index))\n", - "lnn_nparray = np.array(l_nn)" - ] - }, { "cell_type": "code", "execution_count": 7, @@ -156,12 +136,14 @@ "cell_type": "code", "execution_count": 11, "metadata": { - "collapsed": false + "collapsed": true }, "outputs": [], "source": [ - "conditional = gmr.condition([0, 1, 2, 3, 4, 5, 6], [-0.76151596, 0.85728845, 0.0987334 , 0.46247676, -0.16366163,\n", - " 0.27212757, 0.08281898])" + "x_wanted_list = [-0.76151596, 0.85728845, 0.0987334 , 0.46247676, -0.16366163,\n", + " 0.27212757, 0.08281898]\n", + "x_wanted_array = np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", + " [0.27212757], [0.08281898]]))" ] }, { @@ -170,12 +152,23 @@ "metadata": { "collapsed": false }, + "outputs": [], + "source": [ + "conditional = gmr.condition([0, 1, 2, 3, 4, 5, 6], x_wanted )" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 0.00477281 0.98996846 0.00525874]\n" + "[ 1.37649826e-04 2.95463259e-02 9.70316024e-01]\n" ] } ], @@ -185,19 +178,18 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "prediction = gmr.predict(np.array([0, 1, 2, 3, 4, 5, 6]), np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", - " [0.27212757], [0.08281898]])))\n" + "prediction = gmr.predict(np.array([0, 1, 2, 3, 4, 5, 6]), x_wanted_array)\n" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": { "collapsed": false }, @@ -206,7 +198,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ 0.8076785 -0.07856919]\n" + "[ 0.83352573 -0.06368539]\n" ] } ], @@ -216,7 +208,18 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "reg = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), x_wanted_array, \"lse\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, "metadata": { "collapsed": false }, @@ -225,31 +228,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.541884810781\n" + "[ 0.83352573 -0.06368539]\n" ] } ], "source": [ - "proba = gmr.probability(np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", - " [0.27212757], [0.08281898], [0.84411128], [-0.07436732]])))\n", - "print proba" + "print reg" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 23, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "reg = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", - " [0.27212757], [0.08281898]])), \"lse\")" + "slse = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), x_wanted_array, \"slse\")" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 21, "metadata": { "collapsed": false }, @@ -258,29 +258,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ 0.8076785 -0.07856919]\n" + "[ 0.82906377 -0.07093158]\n" ] } ], "source": [ - "print reg" + "print slse" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "slse = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n", - " [0.27212757], [0.08281898]])), \"slse\")" + "stoc_samp = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), x_wanted_array, \"stochastic_sampling\")" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 24, "metadata": { "collapsed": false }, @@ -289,22 +288,159 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ 0.8044823 -0.07751704]\n" + "[ 0.79811269 -0.01681426]\n", + "[ 0.80222399 -0.03754475]\n" ] } ], "source": [ - "print slse" + "print stoc_samp\n", + "print conditional.sample(n_samples=1)[0]" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": { - "collapsed": true + "collapsed": false + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "regression_optimization() takes at least 5 arguments (4 given)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m optim = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), np.transpose(np.array([[-0.76151596], [0.85728845], [0.0987334], [0.46247676], [-0.16366163],\n\u001b[1;32m----> 2\u001b[1;33m [0.27212757], [0.08281898]])), \"optimization\")\n\u001b[0m", + "\u001b[1;32m/home/roxane/Logiciels/anaconda/lib/python2.7/site-packages/explauto-1.2.0-py2.7.egg/explauto/models/gmrinf.pyc\u001b[0m in \u001b[0;36mregression\u001b[1;34m(self, in_dims, out_dims, value, regression_method, **kwargs)\u001b[0m\n\u001b[0;32m 61\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregression_slse\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0min_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 62\u001b[0m \u001b[1;32melif\u001b[0m \u001b[0mregression_method\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"optimization\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 63\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregression_optimization\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0min_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 64\u001b[0m \u001b[1;32melif\u001b[0m \u001b[0mregression_method\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"stochastic_sampling\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 65\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregression_stochastic_sampling\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0min_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout_dims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: regression_optimization() takes at least 5 arguments (4 given)" + ] + } + ], + "source": [ + "optim = gmr.regression(np.array([0, 1, 2, 3, 4, 5, 6]), np.array([7,8]), x_wanted_array, \"optimization\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.76151596, 0.85728845, 0.0987334, 0.46247676, -0.16366163, 0.27212757, 0.08281898]\n", + "[-0.46137381 0.43977351 0.18866761 0.39337473 0.04888891 0.60912177\n", + " 0.15361874]\n" + ] + } + ], + "source": [ + "#1) get x the nearest neighbor of xq in the dataset\n", + "dist, indexes = model.model.imodel.fmodel.dataset.nn_x( x_wanted_list, k = 1)\n", + "x = model.model.imodel.fmodel.dataset.get_x(indexes[0])\n", + "print x_wanted_list\n", + "print x" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.87630398 0.01291787]\n" + ] + } + ], + "source": [ + "#2) get the y associated to x\n", + "y = model.model.imodel.fmodel.dataset.get_y(indexes[0])\n", + "print y" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "#3) Creation fof a local dataset depending on x_g\n", + "_, l_index = model.model.imodel.fmodel.dataset.nn_x(x, 100)\n", + "l_nn = []\n", + "col1 = []\n", + "col2 = []\n", + "for index in l_index:\n", + " l_nn.append(np.hstack(model.model.imodel.fmodel.dataset.get_xy(index)))\n", + "lnn_nparray = np.array(l_nn)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "#4) find the number of gaussians\n", + "from sklearn.cluster import AffinityPropagation\n", + "af = AffinityPropagation(damping=0.988)\n", + "af.fit(l_nn)\n", + "n_clusters = len(af.cluster_centers_)\n", + "print n_clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false }, "outputs": [], - "source": [] + "source": [ + "#5 ) create ilogmr\n", + "local_gmr = IloGmr(environment.conf, n_clusters)\n", + "local_gmr = local_gmr.from_samples(lnn_nparray)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.26908044 0.46998805 0.26093151]\n" + ] + } + ], + "source": [ + "print local_gmr.priors" + ] } ], "metadata": { diff --git a/notebook/comparison_sensorimotor_models_non_parametric.ipynb b/notebook/comparison_sensorimotor_models_non_parametric.ipynb deleted file mode 100644 index 5a13509..0000000 --- a/notebook/comparison_sensorimotor_models_non_parametric.ipynb +++ /dev/null @@ -1,1210 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Comparison between learning sensorimotor models \n", - "## Part 1 : non parametric models" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this notebook, we compare the different sensorimotor models used in explauto in order to help the reader to use the most appropriate model depending on his aim. The notebook is split in two parts : non parametrics models (this notebook) and models based on gaussian mixtures (coming soon). There is also a tutorial explaining how to use the [SensorimotorModel abstract class](http://flowersteam.github.io/explauto/explauto.sensorimotormodel.html#explauto.sensorimotor_model.sensorimotor_model.SensorimotorModel) ([learning_sensorimotor_models](http://nbviewer.ipython.org/github/flowersteam/explauto/blob/master/notebook/learning_sensorimotor_models.ipynb)).\n", - "\n", - "As explained in the [Explauto introduction](http://flowersteam.github.io/explauto/about.html), an important challenge in Developmental Robotics is how robots can efficiently learn sensorimotor mappings by experience, i.e. the mappings between the motor actions they make and the sensory effects they produce. This can be a robot learning how arm movements make physical objects move, or how movements of a virtual vocal tract modulates vocalization sounds.\n", - "\n", - "Let's begin with defining a simple environment that will be used to test the sensorimotor models." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "from explauto import Environment\n", - "environment = Environment.from_configuration('simple_arm', 'low_dimensional')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Sensorimotor models introduction\n", - "\n", - "In Explauto, a sensorimotor model implements both the iterative learning process from sensorimotor experience, i.e. from the iterative collection of $(m, s)$ pairs by interaction with the environment, and the use of the resulting internal model to perform forward and inverse predictions (or any kind of general prediction between sensorimotor subspaces). \n", - "\n", - "Learning sensorimotor mappings involves machine learning algorithms, for which Explauto provides a unified interface through the [SensorimotorModel abstract class](http://flowersteam.github.io/explauto/explauto.sensorimotormodel.html#explauto.sensorimotor_model.sensorimotor_model.SensorimotorModel). \n", - "\n", - "Using the simple arm environment above, it allows to iteratively learn a sensorimotor model which will be able to:\n", - "* infer the position of the end-effector from a given motor command, what is called *forward prediction*,\n", - "* infer the motor command allowing to reach a particular end-effector position, what is called *inverse prediction*.\n", - "* update online from sensorimotor experience" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Decision tree\n", - "\n", - "In order to use the most appropriate model, there are several questions that have to be asked before using the following decision tree. The following paragraphs focus on these questions.\n", - "\n", - "*Add the decision tree*" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Non parametric or gaussian mixture models ? \n", - "\n", - "Each of non parametric model is currently based on the nearest neigbhor look up. They are non paramtric models because they don't rely on assomptions that the data are drown from a given probability while gassian mixture models (GMM) assumes that the data points are generated from a mixture of a finite number of Gaussian distributions with unknown parameters. Thus, the last model can be used only with gaussian distributed data. Readers in this case should refer to the follwing tutorial : *coming soom* ." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Presentation of the different non parametric models\n", - "\n", - "Available non parametric sensorimotor models in Explauto can be accessed using: " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Available sensorimotor models: ['LWLR-BFGS', 'nearest_neighbor', 'WNN', 'LWLR-CMAES']\n" - ] - } - ], - "source": [ - "from explauto.sensorimotor_model import sensorimotor_models\n", - "print 'Available sensorimotor models: {}'.format(sensorimotor_models.keys())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "These 4 models are a combination of a forward and an inverse model:\n", - "* the **nearest neighbor** model searches the nearest point of a given input ($m$ or $s$) in the dataset and returns its corresponding value (respectively $s$ or $m$)\n", - "* the **WNN or weighted nearest neighbor** model searches the $k$ nearest points of a given input ($m$ or $s$) in the dataset and returns the average of the $k$ corresponding values (respectively $m$ or $s$)\n", - "* the **LWLR or The Locally Weigthed Linear Regression (LWLR)** offers two inverses model for the same forward one. The forward computes a linear regression of the $k$ nearest neighbors of $m$ and find the requested $s$ with the given $m$ based on that regression. Both inverse models are optimisation algorithm that minimize the error $e(m) = ||LWLR(m) - s_g||^2$ where $s_g$ is the goal, $LWLR$ is the forward model LWLR, and $m$ is the motor command to be infered.\n", - "\n", - "Let's see which of these 8 *(2 * 4)* possibilities is the best" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Forward or inverse model ?\n", - "\n", - "The forward model uses the dataset for the forward prediction computation, and the inverse model uses the forward model, or directly the dataset to perform inverse prediction. In other words, forward models predict $s_p$ given a $m$ that might have never been observed, using the dataset of observations $(m,s)$ and inverse models infer a motor command $m$ that should be able to reach a given goal $s_g$. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Forward models comparison\n", - "For each model : \n", - "* Output descrptions\n", - "* Processing description\n", - "* When should it (or not) be used\n", - "* Time processing\n", - "* Distance between sg et s" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#DRAFT bac a sable" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "#import numpy as np\n", - "#import scipy as sp\n", - "from scipy import spatial\n", - "#from pylab import *\n", - "\n", - "#Environment definition\n", - "from explauto.environment.environment import Environment\n", - "environment = Environment.from_configuration('simple_arm', 'mid_dimensional')\n", - "\n", - "from explauto.sensorimotor_model import sensorimotor_models\n", - "from explauto import SensorimotorModel" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n", - "[ 0.31524469 -1.00946449 -0.99460699 0.04160849 0.24613563 -0.87940998\n", - " 0.90833414]\n" - ] - }, - { - "ename": "TypeError", - "evalue": "unhashable type: 'numpy.ndarray'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 18\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mm\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mtesting_m\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 19\u001b[0m \u001b[1;32mprint\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[0mtesting_couples\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menvironment\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompute_sensori_effect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 21\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 22\u001b[0m \u001b[0mdistance\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'numpy.ndarray'" - ] - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXl8FPd9//+cPaXVfaETJHGK0xhsThPwgTH4jjF2jC+c\n", - "OE2b9NfmaJv013aYb5tvv06T5vimTXPUkDh2Esf5gcEnjTHGjo1tMJgbBBJC97G6d6U95/fH7Ay7\n", - "q11pJQQS8Hk+HvuQduYzM5/VMa/5vE9JVVUEAoFAIEgE01hPQCAQCARXDkI0BAKBQJAwQjQEAoFA\n", - "kDBCNAQCgUCQMEI0BAKBQJAwQjQEAoFAkDBjKhqSJD0rSVKzJElHBhnzI0mSKiVJ+lSSpOsv5/wE\n", - "AoFAEMlYrzS2AHfE2ylJ0jpgqqqq04AvAj+5XBMTCAQCwUDGVDRUVX0X6BhkyD3AL0NjPwQyJUnK\n", - "vxxzEwgEAsFAxnqlMRTFQG3Y+zqgZIzmIhAIBNc84100AKSo96LuiUAgEIwRlrGewBDUAxPD3peE\n", - "tkUgSZIQEoFAIBgBqqpGP5gPyngXjR3AV4DfSpK0BOhUVbU51sDhfvBEkCRps6qqm0f7vJeSK23O\n", - "V9p8Qcz5cnClzReu2DkP+4F7TEVDkqTfACuBXEmSagEZsAKoqvpTVVVfkyRpnSRJZwAXsGnsZisQ\n", - "CASCMRUNVVU/l8CYr1yOuQgEAoFgaK4ER/hYsmesJzAC9oz1BIbJnrGewAjYM9YTGAF7xnoCw2TP\n", - "WE9gBOwZ6wlcDqSroQmTJEnqpfBpCAQ6kiRtBcpi7DqnquqTl3UyAsEoMZJ753h3hAsE44UyNP+b\n", - "QHBNI8xTAoFAIEgYsdIQCBLAYrHY/X5/3P3CfCW4VhCiIbimSeRmryjKA4WFhTfU1tbGGGZQhjBf\n", - "Ca4BhGgIrmoSEIUyBrnZK4ryb8A3TKYr35IrVkOC0UCIhmBUuRQ3pos8ZxkXtwL4CoDf7/8ErYBm\n", - "UtT+CkmSttpsNofX672IywyfEfxcyhCrIcFFIkRDMNqUMfo3pktxzkTZD9z09NNPK5s3b/5ajHlk\n", - "zJ8//4b29vaK8+fPj9pFhxKE0P77gIxRu6hAkABCNASCwXkbuAlYFWvnnDlzuO+++2Zv2bJltK9b\n", - "xuBCWcboCcZ8SZL2RG0TJitBTIRoCIDLa+8ewbUqYp2nsLDwM4899ljl1KlTfwS8LsvymVGb5AX2\n", - "AP8I3Ax0he8oLy/n/vvvByAYDB4CColjvor3M1QUxQJ8GbgeyAcKgPzS0tLCmpqaWIfMN5lMe+x2\n", - "+0KPxzNgp8lkIhgMRmwL+3nPj/MZM7jIlZzwl1w7CNEQ6JRx+UxAw71W9I0YAJvNJk2dOnUq8CPA\n", - "oyjKPbIs7xrmXM6ZzWZrZmbmxNTU1IkAjY2NH3u93nOh/R8AXuC6lJSU910uFwD5+fk8/PDDmM1m\n", - "jh07xq233jpx69atFgY+/WcA94We5CNuoIqiJAO/RetQmRAmkymjsLBwZVtbW8z9EydOZN26dQsU\n", - "Rfl74HlZlmsY2e+2IsbqA4S/5JpHiIZgUCZOnLhUUZTTQG/oVQ18U5blxljj7XZ7aqwn4AQJN5MM\n", - "+YTa2NjI7t27K2+55ZbTwJ3Ay4qi3C3L8h/Dhp3Tv0lPTy/MysqaDqhWq7VcUZQnN2/e3I72BO7Y\n", - "tm0bTU1NTp/P1w+Upaamvrdu3brJs2fPtgFMmDAhubq6moyMDB599FHsdjtHjx7l448/ZtOmTTmS\n", - "JBGrLI/FYsnw+/0RN1RFUbLQSv/fBLRv3bq1ua+vL99ms6WZTCZrU1NTzM8cDAaprx/QUsZAVVXy\n", - "8/PTgG+jrWCK442NtSoJI4lBRCDGyiLeKkZwlSFEQzAoJpPJBkwL27QCuElRlNWyLFdFjy8oKEgC\n", - "8Pv97sbGxoPBYFDPiDuXwOXCzSThJql+YtjvvV4ve/fubbjlllvuAX4CfBHYoSjKXbIs7waIerJP\n", - "ArYCDwKTgHBHxHsnT550eDyeBcCK2bNns3btWlJTUwkEAqrZbFaqq6vLHQ5H35NPPnl9Wlqao7q6\n", - "mh07djBz5kxcLldMwQAoLi7mwQcfpLm5eZaiKJuAXcCbwGy0kv9mVVVnNjfHbBUzLM6fPx948803\n", - "31uzZs1Kv99fEBLhmDf0wUQjOTnZ0tfXF2uXLuwVaOY0AMxmM4FA4GKnL7gCEKIhGJS6uroP0PqY\n", - "pALpwHeAG4A/KYpyuyzLR8LHb9q0aQPwFpptPhO4M2QiGS7hJqmThN2gopFlOagoyp+jlcX5AvCK\n", - "oihrZVl+ByKfinNycibn5eVJU6ZMYfr06WRkaFq0bdu2m1RVVTMzM7nzzjuZNk3TyfPnz7Nr165D\n", - "tbW1iizLKIryIPAiwPHjxw2/xtmzZ+N+kEAgQGpqKqmpqXnAs4CPUN8YIAXA7/f3AcnRx0qShCRJ\n", - "g60Iomlbs2bNBqDZ4/GYGGS1EC/DfdKkSUiSlBLHp6ILu6EQpaWlBAIB6urqEp2j4Armys9YElxS\n", - "AoGAV5blU7IsH5Bl+W3gFrSIogJgr6Ioy8LHy7J8HFgCHEd7kt6nKMrC4V7X4XBYFUUxDzXOZrM5\n", - "QtcNAn+GtnpIBl5TFOWu0LAytBvdSqfTOfHkyZPSq6++yu9+97setBs4XV1dLFy4UPqLv/gLpk2b\n", - "Rn9/Pzt37mTr1q1YrdbrFUXpVhTlU7Qw19cB7rzzTlatWgVAPHMSQH19Pb/85S/DzUpW/ZpAG7Ct\n", - "p6cn5h1XVVXM5sF/DBkZGRQUFOhvTxISIp/PN+hx8ZAkCa/XO9TBZoCKigoef/zxIecoSdJWSZL2\n", - "xHhtHdEkBWOGEA2BzjngnRivc+GDZFnuAdYB29FWEv+jKMqaqDE1wHIixeWusCHGtSRJivkInZeX\n", - "5wBOKorymCRJNZmZmb2lpaUUFRUFgS6LxeJLSUkhLy/PKOscEo6ngV8CDmCnoii/z8rKssW6htPp\n", - "TNuyZYt127Zt7rVr1wbXrFmDzWbj6NGj/PjHP+bAgQNMnDiRJ554AiANmAc8Aqytra0N+v1+CgsL\n", - "Aejv79dP2wV02Ww2srKyKC4uxuFwUF1dHbEaaWlp4fXXXw8CucD9WVlZ4SZAg8LCQoqKimLtMsjM\n", - "zORLX/oSX/3qV1m/fv00YA1ooiFJEiaTCZPJhM1mQ5KGroJdU1PT3djY6B5qXEZGBvfeey9mszlc\n", - "oLqI/fdTRki4o15lQ05IMK4Q/TQEIyIUKvozYNO2bduCp06d+rS/v787tLsCzbzUP2HCBJKTk/MB\n", - "uru7d7W3t68JO8eSZ5999oNYSXElJSV84Qtf0N9WAZND339TluVnFEX5R+B/Ad+WZfkfwo81m82/\n", - "XLVq1fKlS5eWW61Wk8fj4e233+ajjz6KMPOYTCZWr17N4sWLMZlMdHZ28uqrr1JZWRkxj6eeeoqh\n", - "yoioqkp7e3uvz+fryczMzEpKSjLMa7/4xS/Uuro66dZbb2XFihXGMb29vZ7U1NTHgcJnn332++fP\n", - "nx/wN1xaWkpmZiadnZ309/cTy+9hNpuZMWMGGzZsiNju8/lQVZXnn3+eWKamlJQU9Giw4SJJEk88\n", - "8QRlZWWcOnWK3/zmN/quAFrAhE6/1WrtCwQCE4LBoCPGqd5RVXXViCYhuGhEPw3BZUOWZb+iKJ8H\n", - "+js7O/+8v7//+hjDMlpaWow3BQUFNyiK8jggAUXA32VlZeFyuXA6nREHhkw3OpOB88CXZVl+JbRN\n", - "F6gBDvJgMFi6e/fuKfv372ft2rXMnDmTO+64g/nz5/PKK68YtveFCxeydOlSgsEg+/bt87z11lv2\n", - "aJNOS0uL+vLLL0t6PgbaTXGALUaSJHJyclLRfD8AfrT/L299ff2HwIrU1FRjfF9fH6mpqXbg58Av\n", - "MzMzA5IkRfw/BoNBr8VioaKiwjZt2jQsFgs/+9nPaGhoiLh2IBDg1KlTgZMnTwanTZtm1U1Fhw8f\n", - "Zvfu3bjdkYuGlJQU0tLS6OnpwW634/f7CQQCWK1W3TQV/fEGsHz5csrKyujp6eHll18GUNF+r2bC\n", - "fidFRUUZVqs1pmgNhsj7GL8I0RCMGFmWVUVR/trn8z3GhZtlXOx2ezaa6chg7dq1fW+++WZVZ2en\n", - "MxAIqABLly6dvHLlyolRh28LEwy4kGiXHu963d3d/O53v2P69OmsXbuWgoICPv/5z3PgwAHeeust\n", - "pkyZAsBrr73G/v37+wF79DkKCwul+++//xya8/t3wEFgGbAbiGn2AoJc+N9ylZeXp1ZVVZGWlqbt\n", - "DAax2+00NjZSWFiYHggE/nLq1KnMmzcPv9+vWiyWvwN+JctysyRJW8+ePVtWWFjouO+++260Wq0x\n", - "L1hcXGyuqKgwq6rKkSNH+Oijj8jKymLt2rV8+OGH9Pb2oqoqnZ2duFyumCuMoqIi7r77bn784x/H\n", - "+5Ea426++WYAduzYQVZWFmazWe3p6Yl4YpUkidLS0kFDhAehDJH3MS4R5inBRWOz2T70+XyLhhpX\n", - "XFzsevrpp7eh+USyufB0CtCI5sTORQudBS0n5FvAC6H3N8qy/AmAoij3A/8f8B5wtyzLnfp1QiGh\n", - "ETccq9XKqlWrWLJkCWazGZfLhdVqxWaz8YMf/IDOzs5mNCcyxcXFCy0WS6rb7W72eDz7v/a1r90t\n", - "y7Lxj6IoigQ0oPlrdLrQnrCPA7OiP/vx48eZMGECubm5fPzxx9x4440A1NbWMnGipo+tra3k5eWB\n", - "Zo47BWShic8R4MDLL7/8aG1t7ZJYiX2lpaU88cQTfPTRRxQUFDBp0iTDpFZbW0tJSQlbt24d9Im/\n", - "tLSUNWvW8Oyzz8aMrJIkiblz57J69WpjpZKcnIzFYmHLli3U1NSQnp5Obm4uU6ZMYe7cuaSnpxv7\n", - "4hDTPBXrdzjYeMHIEOYpwZjg8/liBvRH43a7W4Evodm8vcB04AE053UF8PfhpwXmybLcqyjKYuCr\n", - "wC8URbkzlFioJxfeBDQrivIGWnb1zjhzZP/+/Rw8eJC77rqLsrIyQAs7DSUjnlRVdVXoWvsAJ1Am\n", - "y3J/+HlCgvE6FwTDjeZ0100yRcCHwOLQ+zq/318ya9YsI4+jvr6etra24Jo1a0wTJ06ktraW4uJi\n", - "8vLyUFUVSZImc8GHA1qI86Z7772XZ599NuJzFRQUUFFRwbx58zCZTCxZsgTQTFb9/f0kJSUxceJE\n", - "/H4/vb29DIXFYiE7O5twsyJAcnIyWVlZdHV18cc//pH777+ftLQ0VFWlv7+fO++8k4yMDOz2yMVa\n", - "e3s7nZ2dxCHAhczzCLOTJEmmq+GB9mpErDQEF80gT4URWK3W3qKiorc2bdp0b1dXV9/3v//9j/R9\n", - "s2bNcm/YsMEFrA87pB8tCe4t4O/Qspt9aGaiH6CF9D6JVkxQ//33nTlzpvfAgQN5lZWVEU/Mqamp\n", - "xo3z4YcfpqJCyx/ct2/fuTfeeOMdVVWfVBRlS+ic/ybL8t+Gz19RFBPwX2giB/B/gX8BfgHcPchH\n", - "DwKthOWa7N+/v62qqir3vvvuw2az0djYSG5uLrr5qa+vz7d3715/fX19ckFBAaWlpUydOtVwOFdU\n", - "VFBRUUFmZqZxEVVVqaqq4uzZsyxatIjMzEx6enrYt28fBw8eHODb0LHb7eTn55OVlcWCBQvYvXv3\n", - "kCuSTZs2xdzncrloa2ujqamJo0ePMkTjqnC6gEPAuc2bN//bz3/+8w/r6+tTBhkXjvBzjJCR3DuF\n", - "aAguGt1paTKZzEVFRTc0NDQkxUpGKyoqCj722GOB5ORkK0BHRwcnTpzgxIkT1NXVvSPL8h/Q6kgF\n", - "iR0O3oXmw9B/1++hicc+4LPAw2j+BgC8Xm+gurraWVNTk9fY2Cilp6ezfPly9u7d27J69eq0jIwM\n", - "PZnuBVmWNyqKkg3Uo0V+TQsvgBgSDD3rHLRQ0mmyLPtD+x8nyl8TRQeauclAVVV9ZYFegiT8K2j+\n", - "D1VVMZlMRpJfeCSX2+3m/PnzOJ1Oli1bxvbt29W1a9dKSUlJ1NXV8dvf/tYQyuTkZGJleScnJ3Pz\n", - "zTcbK4WsrCzsdjsvvPACsSLbSktLeeSRR/D7/fT399Pd3c3u3btpa2vD4/EMJxFxAKtXr65evnx5\n", - "4ZYtW5KG4TwXJqsRIsxTgoQY7ciU8GMyMzNftVqt62LVn7Jarabk5GRT6BiysrJYtmwZy5Ytw+12\n", - "LwPqgKPAnLDD3gJ6gNUMjJS6KfSqRROPdaExG4CHbTbbwhkzZkyYMWMGhPlP1q9fPyHqPFNCXx9H\n", - "E4xdMQTjp2jZ5jpfCBMMS2h+On7gLDAjbFuEYMCFbO/w9+FfgQGhviaTid7eXlJSUpAkCbvdrlZU\n", - "VBgH3HvvvZLJZKK6upr33nuPyZMnM3PmTCZNmsSuXbvo7Oyko6ODvr4+rFYrqampFBQUsGjRQJdU\n", - "vJwOVVWx2+3Y7XZSUlLIycnBZDLFFKRorFYrqqrG9JlYrVZaWlrKAcxm8xlJkppUVQ2vTTKf2OXg\n", - "o0u7i5XHJUSIxrVJGZcoMqWrqyuWSQHQSmWcPHnSU1FRkfnHP/6R2tpaZs6cycyZM8nMzLQCG0ND\n", - "9UdVE3Ar8H20suOL0IRhHZG1qSYC3wsEAt+tqqpq3bNnz3t1dXU3KIoyFXgIbQUSLkTRTAv5Kr4U\n", - "ev9f+o6QYPwCrZSKHkb7mizLb4Wq1KaFxt+PVkcqJTRGjyH+GfAEFyKzVEB65ZVXuOuuuwgEAuoz\n", - "zzzzXlJS0oyNGzfm5Ofnm4PBIFu3bsXtdvPkk08SHqpbVVVFZWUla9Zo6S5ms1m/swcAsy4y5eXl\n", - "lJeXR3zIe++9F5/Ph81mIxAIYLFo//6BQIDq6mpqa2txOBzccMMNBAIBBis8ef78eZqbm2loaOCu\n", - "u+6KO27ixIncdtttWK1WMjIy2LVrFydPnowpGj6fj9bW1uAPf/jDP3Z0dNi5kO8DIEmSlKZnyDsc\n", - "Dvr7+/Wkwosu7S5IHGGeuga5lJEpVqv1A7/fvyTWvtLSUm699VYmTZrEiy++yPHjx419mZmZgYyM\n", - "DBMXTE/6dr1nRR3web30uaIok3fv3v1GSUnJtMmTJxs3QEA37+xEu9nvlWW5U1GU2WgCsgkoiTG9\n", - "02iO+QagNJSHYg6d40nAE5qbDc0sVojmrNbn6/7Rj370p+Tk5OUWi8Uxffp03/Lly61nzpzpP3Lk\n", - "SFKMPI+60Dx8wMTNmzf/LjU1deU3vvENAE6dOkVvby8LFy7E4/EY2dzBYJD+/n4cjlh5cqNLvKgn\n", - "SZIoKCjAZrNhMpl44okn+OlPf0pj48DCx9H+j2effTamySsM3WexUr/WpEmTmD9/PqWlpaSkpBjO\n", - "9kGisoS5KkGEeUow5uTk5EyLV621q6vrbGpqajlg6ujoiNjX2dnZ29nZOVgnuhLgTUVRqgAZeGnv\n", - "3r0NwDSLxUJZWRnXX389s2fP1sffHXqpiqIcBvaGXjcAvwJujzr/9NDXIqBGUZSzaKGzOaHt4WFB\n", - "N8WYnyMtLW21fhPzeDzW5cuXk52dndTR0RHkgrjoiYG6cFmBVyVJ6vP5fIbPIjc3lxkzZhAIBPD5\n", - "fNjtdsPXcbGCoaoqNTU1+Hw+zGYzFovF+JqUlGQUcczIyNCLFxrH1tfX4/f7sdls3HbbbUZEWKLl\n", - "8BMoY+LQrz1//nyuu+46srOzIwYEAgHcbndCSYiC0UeIhsBAkqSLrkVmNpsHJMiBFqEzceLESRkZ\n", - "GSrAvHnzuqxWa6okSWaA1tbW9FjRPYFAoJ+QiUIPR/V4PM999NFHv8zLywv09fXh9Xo5c+YMZ86c\n", - "obm5mVtuuQU0U9JxNBPHdaHXX4ZOG+6pjeV0Lwq9YnEY+AT4DNpKoxH4IdqT8Vp9UEtLC16vl+zs\n", - "bLxebzWa32R/6Ngvhp3PCyycP39+z2233Wb4MHJyNK0ym82GeSqRulGDEQwG+fTTT3nrrbfiht/q\n", - "K4M333wTp9Pprq+vdxQXF/OFL3wBSZLo6+tj27ZteDweI78EIC0tjfb29gHn8/v9uN1uY3UwmJPc\n", - "arUyc+ZM04IFC5aWlpYan7erq4tPP/2UY8eO0dnZmYhAzR+sW6Lg4hCiITDIycmZMvSoweno6DhD\n", - "jP4N2dnZnQ888IARH7p06dKMpUuXngBeARZv2bLlM7FMDWaz2ajhpN9E7HY7K1asMJ07d87U2tpq\n", - "RPN4vV4sFgsejwe73W5B82NUoj295oS+QqRIDFco54VexhSB24AjPT09s9H6dBAMBmlsbKS0tJQp\n", - "U6boORcNaMJ1BC1KTAJsgUAgePfdd6fFq2/lcrm8SUlJNr08SE9Pj5EjMRwheffdd6mqqjIEKT09\n", - "HavVGhGRpYfwhnwmnS+88IKlra3N5vF4SEpKIjk5mUceeWRAKG146K9OIBAgJycnYmUU6zOazWZu\n", - "vfVWFi5ciN1uNwNmn8/HyZMnOXjwINXV1XF7lcQhAygTpUguDUI0rk3Ohb+x2+2pBQUFCzIzM4tC\n", - "DYxeiXNcXBRFyQOW5uXlmVVV9YaaNxmkpqaa0UpxZAIL0W7iM0Ovjv7+/lYgL/q8wWDQg2YaCs8e\n", - "B+Cxxx6jp6eHzs5OI5onChOREUyXggloonFb9NN2XV0dpaWl4ZV47wE60aq/niLkzDebzQPupE6n\n", - "kz179pCenk5BQYE5zOxmlCMZ7spj5cqVrFw5LH9x0SOPPAJg3LRdLhcOhyNilQEYvdIHE7JYpdrt\n", - "djsbNmwwSrqE6oCxd+/e8MrBI0EPlBAO8lFGiMZVymBPWZs3b/4ntL4Qs4EzwDG0UuZ/DzyrKMpc\n", - "WZbjtpELhZjOBZaGvaYAPPXUU9HD9Zt9GloobCyyworCRmAymYyooyNHjvQEg8H0OXPmGP0b0tLS\n", - "jJvoWBB6Sm9Ec4xHoBdGDJUG0UkG7oh1rvAbblJSEvfff7/+ZG6ONWYYeIlfJ8vg7Nmz+P1+ZsyY\n", - "QTAY5MyZM0ycOJHk5GTjmikpcYPjAKMXBwA2mw2/38/OnTuNrPDW1lajY2BaWhobN26koKCA3t5e\n", - "I5quubmZ/Px8GhsbkSTJKKg4TPLRStIIRhkhGlcvZcR4yioqKlqAFgIaiwDa0/5+RVF+gCYmx9Ai\n", - "hxZzQSBuJNToJww38DHwQeg1Aa2Cazeab2EpWn+Nw8DU0GsyoYZEscwbUdtNc+fOjVucMDR3D9rf\n", - "tBUt/NWLZqqI1yHox2irmKeBzq1btzb19/dPyMvLy87Pzyc3N5eSkpKIkFf9iVu/iYZu6oUAN954\n", - "Y19mZqavq6srPdycMmFCdFpIbMLFIPrm7Pf7sVgsxphhisdggmH4dLq7u3nnnXeYMWMGJpOJ48eP\n", - "D1hR6Gzbti2iPIjJZGLjxo1YLBZefPHFiFVFa2vrgGz0vLw8Nm7cSGZmJk6nk1//+tc8+OCDANxz\n", - "zz2YTCbOnj3L1KlT2b59O4cOaUngen+QREQkOzvbHMvPwsC8DhAmq4QRIbdXKfHCakOOTjda/aT3\n", - "gXK0FcdstBt9olRxQSA+AA7ryW5g1GjaAdwF/A9a8psXmK63fw2FtM5B69s9H815fRBtVVJOVNXZ\n", - "o0ePoqoqc+fOJRAI0NHRQWpqKvFWKQmi145Sa2pqOlpaWrLdbjd9fX243W7cbjcTJkzg9ttvp6+v\n", - "j+TkZOrr6zlw4AC33377YNfuQqv8O2T3wfFCdLb5YMQKd33qqaeYNGkSzz33XETDKbvdHuG8Li0t\n", - "5eGHHyY5OZmmpiZ27NgBwOc//3kj8x2gt7eX1NRUOjo6MJlMhglyqMKLoK1yCgsLh1OSvQvYfq0J\n", - "hwi5FQxJW1vbUWCRLMsD0ncVRckF/hytuZGKtkqwoj2JfogmDvuAD2RZbok+PpxQ2fQvo9WFWg28\n", - "C6z41a9+9dbmzZsjWpuazebuhx9+uHKa1pj7RjQz2TNoT/DXoxUh7D906FCTw+EomTt3rqWnp4ed\n", - "O3fS19fXcs899/hLSkqK0Krh/gjNLJET9pqClqMhoT1ZB7jQo1v30kqlpaXZpaWlcT9TX18fPp+P\n", - "4uJijh8/zh/+8Ac2btwYb/hg4cPDRU8qvKSYTCa8Xq/RVyN8NaN/HwgE4rZ21SOjwldm0cyaNYvP\n", - "fvazWCwWTpw4wSeffMJDDz1khPmGP8Tq58nKikymT6RMSXRyos1mo6SkBKfTGd2rRScDuE9EXQ2N\n", - "EI1rDJfL5YwlGACyLLcB/6woSgrwN0Te+OYCzWg+EOPxOpQxfQNa5nY62pO1/rIAn6L5S1YABAKB\n", - "KVwo20FoG2+99Vb7tGnTKoFpwP8G/hrNYa/foWyPPvroqtC5ns/MzGTTpk39aKsjN5oYPAT8syzL\n", - "H0Z/NkVRPga+hyaA+uP0c2gmrYcJ6wfS0NBAfX29ES2kl9rIzs42TDI333yzntDmKywsjG5yMegq\n", - "o7u7m/T0dOrr68nPz8diseByuUhJSSEQCKhhWd46p7lQbj2m/2Q0cLlcAVVVzTabZs0KFw5dPOIJ\n", - "RlFREWVlZXg8Hk6dOoXD4SA1NZW2tjaSkpLIyclh0aJFXHfddUiSRHd3N6WlpcycOTPiPLoPQ89N\n", - "MZlM+sMBPp8Pn88XM7Q3mgkTJvDwww/j8XiM36EkSWzZsiWeaEAo6irBH9c1ixANwQBkWf6moijP\n", - "ALegrRLWoP0zbQi9UBSlHi0SqIgYdZWGS6hBU3gW1wQizWUmNP/KW2Hb/oRmwgpPtvs5IYEKR5bl\n", - "fw8lBv6BC6LxCFqV2inAA++///6PFi1aZCkqKsJisfD73/+e1tZWkpKS+PrXv47VaiUzMxOfz6da\n", - "rVbpoYce4siRI1a9T3gYcVcZx44dU202m6SHu1osFk6dOkWoPlZ4WZDw/JHw/hzDEoxo30e0Tyac\n", - "lJSUCEXQa1zFOk80ehvbQ4cOsXTpUkpKSpgyZUrc49LTNfeUz+fDZDJFiJHFYonI8L/rrruMMu/6\n", - "jX+oNrU2m81YvQwXEao7OMKncZUymn/4If/EMuDLwM1ENh/SaUC7qbegmbb0F6GvKcCiLVu2TIpl\n", - "Zx6s3HYCuNBMOPpdYhfwZKjvRvRn+RwXmjrpNAPbtmzZ8qX+/n4efPBBcnNz8fl8vPbaa7S3t7Np\n", - "06YGIhOOqWw5AAAgAElEQVT+9Jt6G5FROn1oEVIx2bVrV/Xtt99e7vV6sdls+Hw+9u7dy6233jrc\n", - "zzzqJOJc18eE+zRyc3P5yle+gt/v59VXX+Xee++NeawekeVyuSgqKiI/Pz96iNfj8ah+v9+akpIy\n", - "wLmiXzvcCd/Y2BgzM9xqtTJhwgTV6/VKwWBQDQQCrmAwmOxyucxpaWnYbLYBPUMALBbLPkmSTHGa\n", - "il115UlEafRrmNF+OgoJxQIulONYEDXkONrNNhvNdJWQBzVevaCLEI0WYjvwe4B/An4c7qAHUBTl\n", - "IbSGTZEH9PTw7rvvBpxOp3nx4sXd06dPT4fI7noMIQpDoUdB6Ql6e/bsYd68edGlMl5CM9NdN9Lr\n", - "RDOEkztm33PQVgJWqzXCl3H69GkjO9tisXDLLbdQXFxsrAbCcbvdWCwWQyADgYAxxuPxcOTIERoa\n", - "GrjnnnsS/RxqR0eH2tbWZvJ6vbzxxhtxVx1ms7k/EAgMiFTQ/Vbx/g7j7UOIBiDMU1cTZVxEIpOi\n", - "KJloCVEVaOGxdxH5ZN2H9gS/E3hVluWmqGNvQUtyy0V7CtdfgfD3LpfrTmKbWFTgDbRidfp4C5pp\n", - "LFqwwslB80msQTM32QE+/PDDtOPHj3/f7/d/+5lnnjnd19dXiOaL6QdOfutb3/Lb7XbLSy+9dH79\n", - "+vUlgCktLY1169bpN89HgX8FZoeHnW7bti1Zf8pdunQpFRUVOJ3OYG1trWn+/AGJ8AOwWCxGjoLH\n", - "42HGjBlkZ2dHP+V/luFnqg/KEFFRcSO8/H4/VqvVON7j8WC1Wo1kvnAxSkpKwuv10tTURHt7O/Pn\n", - "z4/I8bBarVitVpxOJ3/60584evSoUWrl9OnTpKWlEW7qi7XyaWlpUU+dOmUqLCxk7ty5HD16FEmS\n", - "aGhooLu7O2JsLMHQP0O8Mip+v3+w7HNRgh2x0rhqiBdim5ub2/CVr3zl79Cin6rQCuVVhL1mhr4O\n", - "sBWgNSR6BU0odsdzoA9znlsJrYgkSTLl5ORMTUlJKQyrZnsSuEeW5Ur9GEVR3iV2kUCdAFq01cto\n", - "PcXv6+rq4oc//GHcSJunn36a4uJinn/++UMbN268B83x/hUicxqq0HJJfGjRVuq+ffukN954A9Ds\n", - "5n/+539OVlbWSJPuhuRSnXcs6OrqIiMjA1VVef311/noI61xY/QqMxAIsHPnTtLS0rj11lv1nIwB\n", - "AQLh/pkh+pBfKq74MF2x0hAMICUlpQgtSggGMUOgrSROhl5H0Z76D8qyPKpPFbH+wRRFmYTmoL4B\n", - "TcBOKYryArBJlmUfWiHAh9GSEmOJhxktTPfv0aK72jMyMrIXLFjA/v37Y87D6XRSXFxMfn5+Llot\n", - "qT1oOSLPhQ3Ta0bpPzNpyZIlZGRksGPHDvr6+vif//kfNmzYEH5jjy53opuzGoCi8O58TU1NgcLC\n", - "QnMss45OvNDXK5Hdu3czffp0Zs+ezbp16+ju7qavr4+MjAy9Xhh6v4z77rvPOC5kFhvwocO7G15M\n", - "t8ChMJvN8ZIJr8loK7HSuEqIt9LIysqq/qu/+qvDwBK01UQTF8Qh/FUry/Kl+89LAEVR7kZrmapH\n", - "Y7nR8i7q0UxUC9GSEBNKmAsGg/zpT3/i8OHDtLa2RuxbtWoVq1at4vDhw8ybNy/OGQai39w6OzvZ\n", - "vn07t99+O0VFAwriniKy5tWAullR6MISr81tBGMlHInkaiRKf38/Xq+XlJSUAedSVRWPx0N3d7fR\n", - "gjbWPLq7u/nZz35Gb2/vgATC0WDSpEksXbrU98EHH1gH6QFyRfs5hCP8Gmaoxkohx3ayLMsD64+P\n", - "AxRFSUfLCl+IVtZjZpyhKprIHUEztd1AjDIZ0Y7faPPF3LlzeeCBBzh37hxlZWUJz/P3v/+9EVKq\n", - "37w6Ojowm81GGOkg6KLgQhO+8OWFbgKLyVgIxWiIQ/jKKhgMYjab436WwT5jMBjk5MmTHD9+nFmz\n", - "ZjFr1ixaW1v5j//4DyB+/3M9wCBWbofNZiM9PZ2MjAwyMjKM79PT08nOzjaSCocwfTWrqhormvCK\n", - "QJinrm3ODbY9ZGYaF4KhKEo2Wqb3Ai6sIKYleLiElsVtBV5Dc1b/B6GS5DomkyniJvT4449z+vRp\n", - "jhw5wunTp3E6tW6soRv9b0LnmxV6udDatSajmSAMUert7WXLli08+uijRjvVnp4eTp8+zW233TbU\n", - "3HUVS0YzFYaTkGBcTvGItQIY7rXD+56Hny8QCOD1evF6vYbYer3eWJWKAe33OWXKFKNtLGiNmr74\n", - "xS+SnZ3N66+/HlELSyczM9PYPmXKFMrLy8nJySE9PZ3k5BEHwYWTG+YcL0HryBjNVeUwFysNwWVF\n", - "UZR/A74RY5cXbfXwSeh1IPR+NVqfbf1pbrCSGh6gFpjicrmk8KJ/4Tc8r9dLbW0tU6ZMMUJggRPA\n", - "NjS/yK/Q+oU/DXydMEHatm0bycnJ3H777UbZDZvNFjPcdCj0sFu4ENqaKCMVj+rqapKSkkhPTx+y\n", - "Yi0MXG0MlhyYCJdK9ILBoOEPef/997nhhhuw2Wy0tbVhsViMwpfhOR6qqhIIBIxOhFOnTqW7u5uu\n", - "ri48Hg9dXV14vV6je2ICdBE7sXPcmrCEeUowrlEU5WZgN9pTtt7F7kDo6zFZlmP271QUxY4WFfUt\n", - "tKd+J1qehZcLq5UB9dEv4gbVghY6HO1fSMjnEGJU60VditWG3++nvb2dtrY20tPTKSmJ1Tp9+PPT\n", - "CQaDdHV1GWaeoeYdK3s9OhDA7XbT09NDfn4+Ho+Ht99+G1VVWbvWaJpIc3MzeXl5EeZJt9tNVVUV\n", - "r7/++pDZ5EOhzykam80WrwWtEI3RQpKkO4AfoNl3f6Gq6jNR+1ehhVFWhTb9QVXVf4lxHiEa4xxF\n", - "UWxodagqgH+SZfmfR3COmcBPuVAm5HXgL4DzwFeB7wIdaEK0gMiyJMBF33APogUTxGsFOypcShPU\n", - "hx9+SGVlJU6nk87OTlRVpbS0lCeeeGJALkf4PPx+Px6PZ9DVicvloqamhrq6Ourq6mhsbKSoqChm\n", - "0qaqqni9XjweD8FgMG5p/HBOnTrFu+++S2trK9/61rdQVZVXXnmFOXPmUFpaGjH/YDCI1+slKSmJ\n", - "9vZ26uvrycrK4o033jD6nIyUeNFUgzjjx21o7hXl0wj1hv4xWkJYPfCxJEk7VFU9ETX0HVVVE0sX\n", - "FYxnvoomGJXAv43kBLIsn1AUZRXweeA7aKG4xwhlfqOVOSlHqz/1xvbt218qKSmZkZ+fn5abm5ue\n", - "lJRkvsib8fUXc3Asos1SwylPPhKOHz8e4dRNTU1l/fr1Ma8ZvrKJrgcVi3fffZd9+/YlNA9JkiK6\n", - "Lfp8PiRJGnCNMPMhM2bMYMaMGREmsrvvvtsY297ezrlz51iwQMsF1c2F2dnZhkP8Yh37gJEhH43H\n", - "44kX0n5VheaOpSN8EXBGVdVzAJIk/Ra4F822HI5YQVzhKIpSinZjB/iKLMsj7uMZCgv+uaIoO9FW\n", - "qQ+hrTD+FtDjal8AzOGx/pcAPYz2OFqk14j+TnXB0PMMLqVgRGMymXjggQfQ29RGlTIxSFRoJ02a\n", - "lLBoRGO1Wgc0dtIJS/yMmI+qqrjdburq6khKSuLw4cN0d3ezYMECw08RTbzmTRaLBb/fH3OfLmb6\n", - "sYO0ob1ieqdcDGMpGsVoTkudOrTucOGowDJJkj5FW418Q1XV45dpfoLR4wdoEU8vyrK8azROGCpj\n", - "8rCiKI1o2dzhVXHNaP6HU2jRY9Vhr3PAZ4B/RiuiOFQORTz0Y8Ir0B5khKuRyy0WhYWF3HbbbZSX\n", - "l6OqalzBGA6TJl0IYDObzaxevZpZs2YNckQknZ2dg2Z19/b2cubMGTo6OigsLGTq1KmkpKQYFYJL\n", - "S0sJBAIqINlsNoLBYERZ94aGhrglQsxmc1zRUFU1UUd4XH/H1cRYikYiP9lPgImqqrolSVoLbAem\n", - "xxooSdLmsLd7VFXdc9EzFFw0iqLchdaPvBf42iifuwjQDeZ6n4kONNFIBz4CnoqRtHggVCZ9O1rE\n", - "VRLx8ySGIwQRzcDDk+H0NqVjzR133EF2dnZEaKskSUaJj5HS19dHamoqOTk5uFwuHn744WHlv+zf\n", - "vz9mngVciNj66KOPaGtrA6ClpYXjx48zY8YMpkyZYpii9FIjgUDA6ALo8/l4+eWX6enpITc31zB3\n", - "hftsGhsHFEQeEeNdMEJ+4lUXdY6x+pCSJC0BNquqekfo/beAYLQzPOqYamChqqrtUduFI3wcoijK\n", - "VLQih+XA12RZ/v4onltCC5G9Fy1f4yHgVbRVhJ5j4UDLKP/rWOVQFEV5CXiAC+VVXiTULySM40Su\n", - "JkDzyySUVxIr6mm0Hd2xzDqpqalMmTLFsO+PFvES/urr6ykuLubjjz9m2rRpZGZm4na72b9/P5/5\n", - "zGcSOvclqIBMS0sL//3f/43H4yEnJ4fHH3+c9PT0AT//9957j8OHD8cslz5KjMsIqivKEY4WcjlN\n", - "kqQytLo8DwGfCx8gSVI+0KKqqipJ0iI0kRu6bZdgzFAUJQntRvwFLjzRHAH+7yhf6kE0wegBviTL\n", - "cq+iKOvQ+pLfgtYgygr8P2irj80xzvGXaIEY+iP2aTTByQkbUxHjuFbgDuBtopIKo5EkaUAORyAQ\n", - "GNKpPBw6OztxOp2Ul5cbr+gWqaOBngcRi+LiYgBuvPFGY5vD4UhYMBK9/nDE9uTJk/zud78znv77\n", - "+vr44IMPSE1NZc6cOTQ3N2O32ykuLuamm26isrJyiDPGJiMjA7fbHW3CUoG9Ye/Pjejk45CxDrld\n", - "y4WQ2/9WVfVfJUn6MwBVVX8qSdKX0XpW+9Gymb+mquoAT5tYaYw9iqLMQxOKR4msHfUiIMuyHLd4\n", - "zwiulYu2AshDE4yfhu1LRjM73Y4mKClouRV/LcvyD2Oc62m05EHQQnf/Jex9PIJoyYYK2t/nkOg3\n", - "vL6+vtHKRDaI9fQfDAbjOoPHK0OtNM6dO0dTUxNOp5P29nb8fj92u52lS5ca2fk6n376Kdu3b8dq\n", - "tTJt2jRmzpzJtGnTYmacP//88zidTsOMGAwG6enpSdjUlJKSgsPhGFDfDE049DL/Ou1oZXB0xjRb\n", - "/IrL0xgthGiMDaFVxWNoYhHe6ewAWtjrb2VZjtuQ+SKu+xyaOL0D3BLtswjN6yXgTrSSIHpywSZZ\n", - "lrdGjTWhrRj0R+Kb0VrKRjsgutH8JDrfRROuZweba1QDpyu6Su2l5vz583R3d+PxePD5fHg8Hrxe\n", - "L1arlVWrVkWMVVUVp9NJamrqgEz8c+fOcfjwYSoqKpg8eXLEqq6pqQmz2Uxe3gX3UzyxSk5ONsqd\n", - "DMZFOr/HtHaVEA3BJSFWV0C73Z46ZcqUKRs2bNCzsrqAXwP/LcvywUs1l5AJ6lW0yrDzZFk+E2ec\n", - "DW2Vcy9a46UktCe+9bIsb4saOwMt38MMvIlWQ2h21CmjS0T0oiUW/mqw+b733nvcdJNWzV0vOTLa\n", - "7N27lxMnThhhu7ooFRUVJdwRbxQZaTTakASDQdxurXyaw+GIG1gQ7Uc6f/48J0+e5OTJk3R0dAzw\n", - "kQy2wlm/fj2HDx+moaGBM2fOGMl7elTWKJRk71JVdejMxkuEEA3BJSFeBd3QP18lWvjqS6PRpGko\n", - "FEU5i9bn4qeyLH9piLFWtJyN9WglR2yhr3fKsvzHqLH/jpaAqKI1dPpmjFN6CHUGDPEbovxw4eih\n", - "mnr4p36TG+0EvpE4kMf7imc05tfT00NXV5fRZtbv9xu5FvpN32Qy0dPTg9vtNsqqtLS04HQ6KSkp\n", - "ifj5RYfwwpAVcA2SkpLi5XdccaIhqtwKRozL5aoH5l+ucuuhiKk2NNH4M0VR8oCvy7J8LtZ4WZZ9\n", - "iqJ8Di2cVv9qA7YrinKbLMvh/rFvAn+GFnG1NM4UvESKxrrB5itJkrGyCBeJoZ6QvV4vTqczovXp\n", - "YMQrwRFv+2hHcamqiqqqoyqEozGvtLQ0oyDkcAkEAkaZFf1nFf759M+8aNEiPB4PTU1NA85htVqN\n", - "v4GhTFxXEmKlIRiSoXp1XM65hIoXfhX4BzRfRT9aWZL/E0+8FEUxA1vQ/C96eG0n8BlZlo+Ejfvf\n", - "aEUR1dC4y/JQpfel1rPD33nnHVasWDEu8jrGgnhi1tbWRkNDA83NzfT09HD33XdjtVqHrBDsdrs5\n", - "fPgwvb29Rv6Gz+cz+nvoL7vdTm5uLhMmTCArKyvmHILBID6fL8KhfpGtZgPAe4yRQ1yYpwSXhPEk\n", - "GjqKohSjmZE2hjbVopVc/32cnAwzWlTUU1yoVtsErND9IoqiZKCF3JoZaIrSGXWbfbizfLybjXT8\n", - "fj8mk2nYwub3+2lubjZCdGOZfOIRno+SlZVltIT95JNPhp2P4vP5aGlpoaGhgV27duHz+UhLSzPE\n", - "Qn9NmzaN3NxcCgsLcTgcA6LUPvnkE958883R6Bo4Jv9LQjQEl4TxKBo6iqIsR0vg0+8asizL/yvO\n", - "WBPwn2hmKP3mfw64SZbl+tCYF9FyQEbKiEqih4vFaHTMu9xcykKLaqj9a0tLC0VFRRHRUKqqcujQ\n", - "IaZOnUpaWlpEFNPFiG9LSwter5eioqKIz+XxeGhsbKS6upqVK1fy8ssvc/LkyYRFY5BIKyEalxMh\n", - "GpeWWNFTIca8I5k+t/z8/FlJSUl5Lpervq2t7Uy8uYX8Ij9ES+wLLzr4GVmWnYqirAHeGOSSQ600\n", - "6tHqqiVMuGC0t7eTmpo67vMr+vv7OXv2LFlZWUaP9J6eHoAh/QhqqPlRuEkuFvqYwRIh29ra2Lt3\n", - "LzNnzmTmzHgdgkdOIBCgqakJh8MRN2Fy27ZtwxKOOHQBh6K2XfL/LyEagmuOkayCQsLxXSJrYX0M\n", - "3IqWkHie+D0zLklIabRZKvR+OE2fLit9fX3Y7fYBbXWHInpF4vF4qKqqIi0tzXiq93q9fPDBB7S2\n", - "trJs2TIKCwsH7R0ea4Xj8Xh44403CAQC5OXlsWzZskFXb9u2baOjowNJknC5XPT39+P3+0lLS+OL\n", - "X/yiUQ7d5/PFLBN/kX6NeFzyHA4RPSUQJIAsy6qiKN9Ai6b6u9DmG9FKkKwDngvbHo1E/OKGwyYY\n", - "DFJfX2/4NPT+EU1NTRQWFo5LwQAistrDcyIG6/MNGCGup06d4vTp0+Tm5rJixQqSk5NRVZWqqir6\n", - "+vpYunRpxGprMGGqra3l7NmzXH/99WRkZBhlW3SnOUBdXR0PPvhg3FVLZ2cn588PLFqQn5+P1Wrl\n", - "0KFDvPnmm9x8880sWrTIMCH29/ezY8eOUSt4GMXw+gdfJsRKQ3BFczH+ltCKQwH+MWzzTuD/BQ4T\n", - "uaoI/z5es51rhpH2/3C5XDidTiRJIi8vz8jmdjqdpKenDzBXDSYWPp+P733ve0b+w1NPPWWUZ1dV\n", - "lePHj3P69GkqKytxu93MmTOH9evXxzxXvJVCcXExDoeDyspKZs2axYYNWj3Lffv2sWTJErq7u/nD\n", - "H/5gVN/Nzc0FtOz2we6tkiThcDjIzc2ltrZ2sCRBvaJCPxfKj4ya2UqYpwTXHKPhpFcU5R+BcOf5\n", - "r9FK8IeXRokXTSUYB+j3sVgCo+dUxCq4qItSPNHQzzdt2jQ2bNiAxWLh448/5vTp02zcuJGWlhb+\n", - "8z//E4hMpnzmmWfilnrXKS4udj/99NOmb3/720mJ9usIMWpOc2GeEghGgCzL/6woig/419Amva5V\n", - "OEIwxgGJdvcLZ7CQ3qF8MXa7neuvv56VK1ca3fuOHTvGnXfeCcDhw4cHHNPb20teXl5Mc1c4FovF\n", - "AVoZ+46OjkHHRjFfkqStYxWEIkRDcKVzbpjbYyLL8v9RFMULfC+0aSUX8jl0xq1j+lohXne/3t5e\n", - "o6eHy+UiJSWFmpoa3nzzTbq7u1m1ahU1NTV0d3cPODZe5jxoPo01a9YY781mM7NnzyYvLw+n08kH\n", - "H3ww4JjU1NRBxSgpKYmSkhLuu+8+VFUlPT19uKIxpj3HhWgIrmhG82lLluV/DwmH3vsjWiCEYIxT\n", - "UlNTjYTBQCCAy+WitLSUp59+2sj8PnLkSNwIJ104UlJSSE9PN15ZWVkRhSZVVWXhwoUAnDlzhuLi\n", - "Ypqbm41wW5fLRUNDQ1zHuN1u55vfjCxrNsISIxUh02w0lzxMV4iGQBCGLMs/Dpmq/mus56LT2dlJ\n", - "W1sb3d3ddHV14XK5sFgsFBYWct1114319MYFugMaID39QgV7SZIG+DH0trTZ2dnk5ORQUlJCWVlZ\n", - "QqHD4aauxYsXs3jxYgC6urpoa2vj7NmzHDx4MK4QSJJEXV0dSUlJOJ1ODhw4QHv7iPrKJRHbl3fJ\n", - "EY5wgSAGiqI8BfyCS1Tmezjs3LkTk8lEUVERRUVF5OXlXbN1qeI5rD/3uc8xY8aMQY999913ueGG\n", - "G4ZsguV2uzGbzezfv5/6+nra2tpwuVz8zd/8DaCtZI4cOYLD4SA7O5vMzMwBobzPP/88lZWVOBwO\n", - "cnJyMJlMtLe3GwmQ0dhsNnw+X8J9OUwmU3cwGEyPsWtYTnLhCBcIRo8twN8Qu93rZeXuu++OeB8M\n", - "Bo3VxmA5EdcKNpuNKVOmDDnupptuMronOp1OowOgJEksXboUu91OR0cHr7zyCo899hjLly/H4/EY\n", - "BRJ1zGYz8+fPH3D+3bt3U11dbRREzM/PN0KKbTbboKuY8JWJXoQxFmlpaSxbtowTJ06kx3G0X3In\n", - "uRANgSCKUCXdc2gtXcecrq4uurq6sFgs5OTkYLfbSUlJGfrAq5Bop3VeXh7Lly+PmbQXCATo6ekh\n", - "LS0Ns9mMJEns3r2bvXv3RowrLS1l5UrN0rNjx46InAm73W7kfgxFV1cXra2tMftmpKWlMW/ePMxm\n", - "MyaTyaisq3+v9/kAOHLkCPX19QPOMWnSJDZt2oQkSXg8Hurr6yOOC3HJneRCNASCMBRFmQScZhyF\n", - "2Kanp5ORcaFpYGtrK5WVlXR1dbF27doxnNnlJ15YbTR9fX3s378fj8fDypUrMZvNnDlzhpqaGkpL\n", - "SyPGZmZmGquAdevW0dHRwYEDBzh37hw+n49ly5YxadIkVFXF7XbHFez7778/rvksOzub1atXJzT3\n", - "xsZGzGbzgB4e4fNctWoV1dXVl6J0yZAI0RAIQiiKshqtWOG4chgEg0Gampqora2lrq7OMJUMFip6\n", - "rZOcnMyKFSsitk2dOpWpU6dGbNN7cehFFPPy8oz+4QsXLjTKugSDQZqbm0fc1CkYDOL1eo1y8vrN\n", - "P5bJKlwYW1tbjaz2qqoqnn/+eYqLiykqKoq1yrgsCNEQCABFUf4WrT/HuMNsNlNcXGyElApGD92s\n", - "JUlShImrubmZvLw8Y5vJZBq0k6IuLi6XK+b+3t7eISv2ghbS29rayoEDB6isrBwQWdXT00NlZWVC\n", - "n+1SIURDcM2jKMpvgYfGeh6CxBjNRlXxzpOfnz/gmoONt1gsqKoaNzAhPT097j69Um8gEOCFF16g\n", - "oaFhyBIkY4kQDcE1S6gp0xFg1ljPRTA44UIxFp0NE7mmJEnk5ubGXE1kZmaiqioul4umpiaCwSDp\n", - "6enk5ORgtVrxeDw899xz1NXVGefKzs5mwoQJxis5OZn6+npqamqoq6sLd7gH0Qpq6twkSVInkUUO\n", - "YZQS/0SehuCaRFGUNLQWsRlDjRVcuVxsR8FwsRrJufTjg8GgEd6bk5MTMaaxsZFdu3bR09NDcnIy\n", - "Pp9vQIiu7r8Kr7vV0NAQNzQ3DgNyOESehkCQAIqizAEOIv7+rxo6OzuN0NpwhrrJD2XqkiSJzs5O\n", - "zp07x7x58xI2jUX3PjeZTEbWut/v5+zZs4aDW6+HpUd1JScns2DBAiZPnkxPTw9tbW10dnayf//+\n", - "mMUao7Hb7aPRszwu4p9GcE2hKMoG4LeMg0xvwfCJd9MeaSRZIgKQmZlpJPM1NTXR29tLSkoKaWlp\n", - "pKamxjxmMLF64YUXqKqqitiWkZHB1KlTmTt3bsRnSUlJoaBASxeqrKxMSDQupWCAEA3BNYSiKN9B\n", - "y/IWXKEM158xmk5zwLiBD/faqqrS19eHw+EwQmUtFgsVFRVcf/31TJ482Rjb2dnJwYMHOXbsGHa7\n", - "nby8PCZPnhzs6+tTGQfNv4RPQ3BNoCjKH9F6gAsEY8rRo0exWq1MmjTJqIPl9/s5efIkVVVVHDx4\n", - "cEANKovFss/v988khg9OkqREa1YJn4ZAMBSKopiBGkAkOQhGjKqqnD9/nqKiooiWtG63m7NnzzJr\n", - "1qwB/pTwY8NXO3PmzDG+b2xs5MiRI1itVhYsWMDHH38cUwCSk5MzbDab1el0Dthns9nimaR8wPth\n", - "788N8TETQoiG4KpFUZQJaIKRNNZzEYxvEnGIh5cfCQaDdHd309/fz/Tp0+MKhn5sOEePHuX06dO4\n", - "XC5mzJjBqlWrjH4dSUlJEQUL7XY7BQUFZGZmzgQMH0owGCQQCBAIBAZr4NQ+Wm1hIz6PME8JrkYU\n", - "RVkGvIdweAtGEb/fj6qqEasNSNx3oo8LBAIR5URqa2t55513OHv2bMRKo7S0lI0bNxqi8tprr3Ho\n", - "0KFEGzd1qao6aISAME8JBICiKF/hQvc9gWBUePvtt9m7dy+qqpKUlERGRgZmsxmv18uXv/xlY1y0\n", - "Azzc56Bvj16Z7N+/n8bGRmw2G6qqEgwGCQaDnD9/nu985zv8wz/8A6CVNxlGp7+B5XZHASEagqsK\n", - "RVGeAx4d63kIrj727dtn3Pz7+/uNjGy73R6xyggXDF00wve7XC4OHz7MoUOH8Pl8WCwWLBYLPp8v\n", - "piCEFyYcpmUoKUZL2IvOChfmKcFVgaIoEnCccdA0SXB1EH3Tf/HFF2lra6OrqwuPx4MkSeTl5TF7\n", - "9myjH0c8M1V3dzeffvopLpeLQCBAfn4+EyZMMKremkwmtm3bRnNzc8y5hEJ1VY/Hc7H3uYgIqpHc\n", - "O4VoCK54FEVJApyAY6znIojNaOdLjCa6OAynREggEECSpJjH6J+1ubmZjIwMo3vfUMTrxTHKXLRo\n", - "CHbEvxgAACAASURBVPOU4IpGUZRy4AzjrAeGIJLxKhjAAPNRIiQSLRVdKVfH4/GMSpve8HmrqorD\n", - "4TBKlTQ1NV2yzHAhGoIrFkVR7gZ2jPU8rlbCnbiJ3lTdbjc1NTWUlZWRnJxMf38/hw4dYs6cOXFL\n", - "box3dGvMJ598YtyMA4EAbrcbm81GeXk5S5YsMRzYelTUyZMnqa6uprW1FafTSXl5OatWrRq15lmq\n", - "qlJUVMSmTZuwWCz4/f5gX1+fr7+/3/vSSy/Zm5ubbaNyoSiEeUpwRSJKgowv9Jvlr3/9a86cOUNK\n", - "Sgr33HMPM2bMAKC+vv6KbyK1bdu2mLWfMjMzB7ShVVWVrVu3DjA3mc1mbrnlFpYsWWK0dH355Zep\n", - "ra3F6/UaZq9AIEBKSgq9vb1DrRh8wPtWq/W81+t9XN8YcoCvjDFe+DRAiMa1hqIonwDXj/U8BANp\n", - "aGjAYrGQnJyMw+EY1IxztRPPR1FQUMADDzxAZmam0Wo23kru2Wef5fz584NdJmYuhiRJW4GyGOMj\n", - "oqeET0NwVROKkOoBUsZ6LoLYFBUVRbwfzw7w0UZ3qMPgPhy9CKGObgLs6+vD4/EYr+7ubpqamoa6\n", - "bKokSVujw2j19zHEoyy0Chlx6K0QDcEVgaIo6UAnIsP7iuJKE4zBRC6WIFRVVTF58mTa29vJzs5G\n", - "kiQ8Hg9vv/32AN+FXvbD4XDQ0dGBxWIhLS2Nnp4e0tLSOH36NNu3bzfG2+12CgsLUVUVt9tNd3d3\n", - "rDwOM/CIJEl3cKFLXwVa6Zz+0NdRbTQmzFOCcY+iKDcCH431PATXDqqq4vf7jQZMn376KfX19ZhM\n", - "JvLz80lPTyctLY3bb78dq9VKTU0NKSkpZGdnR4Thbtu2jfb2djo7O+np6Ym4RmlpKZs2bWL79u2s\n", - "W7cOm83Grl27eP/99yP2h/OTn/wkbi5HLGw2W7wM8ndUVV0lfBqCqw5FURTgn8Z6HgLBSExtg+Ve\n", - "ZGdns2rVKt59910mTJjAgw8+CMBzzz3H+fPnMZlMFBQU0NTURHJyMiUlJfT09CScy6EXWIwzfsSi\n", - "IcxTgnGLoiiVwNSxnodAAKNrarPZbGRkZDB37lyqq6sBOHHiBFOnTsXv9xtVbvUbvsfjweVykZ2d\n", - "jdlsjigtEg9VVYfbQzwhhGgIxiWKovgQf5+CqxSHw8HixYvp6OjgnnvuMQTplVdeweVyxTxGz8kA\n", - "8Hq99Pb28v7777N///6Y44eIuhox4p9SMK4INU3yIRzegkuA3++nr6+PQCBAUlJSwiU+RpuMjAwq\n", - "KrQyacFgEKfTSXt7O9XV1cRqtATg8/no7e0lOTkZm81GdnY2d911F06nk5qaGoLB4FCX7QIOhb4/\n", - "N9K5C9EQjBsURZkOnBrreQiuXvSIpZGQSDhtovj9fj788EMOHz6M2+0mLS2NrKysQc1JDQ0NfPe7\n", - "3wU089a0adO48847jTLqQxAA2kajKdOYikYoTOwHaGFjv1BV9ZkYY34ErAXcwJOqqh68vLMUXA4U\n", - "RfkD8Nmxnofg6sPr9RpNjBLZHot4TvBAIDAggdHr9WI2mzGbzTFLhqiqSlZWFosXL2bx4sUR+7Zs\n", - "2UJ3d3fMOeglSxwOBw6Hg7S0NLq7uxMtl24G6hIZOBRjJhqSJJmBHwO3AfXAx5Ik7VBV9UTYmHXA\n", - "VFVVp0mStBj4CbBkTCYsGFUkSfKj/SEDWt/k9evXj+GMBFcrNpsNl8tFXV0dDQ0NNDY20tDQQE5O\n", - "zoCQ1nDChSLe6qKyspKqqiqsVisTJ06kvLw8ohihXl4k/FzPP/88VquVhoYGCgoKcLlcdHV10dPT\n", - "E1cw7HY7FRUVA8qVDDa3S0Vc0ZAk6XXgL1RVrb5E114EnFFV9Vzoer8F7gVOhI25B/glgKqqH0qS\n", - "lClJUr6qqokHKgvGHdGCAVptotOnTzN9+vQxmpXgasZms9HV1UVNTQ2qqpKTk0NGRsagYbSSJNHV\n", - "1UVjYyMVFRX4fL4BbV4rKioM34TT6eTYsWOUl5eTlZU14FygmaWWLVvGmTNn2LlzJ01NTcZKwW63\n", - "x60zlZ+fz9q1a+nv78dmsxm5IB6PJxHT1Kgy2ErjWeBNSZJ+CXxHVdXRjt0qBmrD3tcBixMYUwII\n", - "0biyGVCQqKOjg507d/L1r399LOYjuMqxWq0sWrSIRYsWDes4l8tlOMujBQPgwIEDZGRkMHHiRHJy\n", - "csjJyRkwRhcmXXTKy8spLy8HtKrA586do66ujjNnztDS0jLgeJvNRlZWVkynvd1uH04fkFFpUBZX\n", - "NFRV/X1otfFPwH5Jkp4D1Au71X+/yGsnmlUY/RgQ8zhJkjaHvd2jquqeEcxJMIYMo/exQDDqqKpK\n", - "IBCgt7cXl8uF3W4nPz8/btFFVVU5fPgwtbW1ZGdnM3fuXFasWIHJZIpp2tJFJ9yh7nA4mDVrFrNm\n", - "zeKWW27h2LFjHD16NOJ/IbyKbjAYxO/3Y7FYDLHIzMxMtH9GriRJbwD7RvgjAob2afiAXrT6JWnA\n", - "aK6D6oGJYe8nMtBREz2mJLRtAKqqbh7FuQnGgMu9zBYIwpEkCcv/396bh7dV3Qn/n6PF8iZbdux4\n", - "iR1n3yGBQFMggAOlDWFrCoWWtmydlk5/3abTTpd5fyPuvNNl2plpp6UttKWBocPShgQSCPuShQCF\n", - "kI2QxFnsxE68yqtkS9Zy3j+uriLJki3vdnI+z6PHuvce3fuVLJ3vPd/VYsHhcKTU80JKyc0330x2\n", - "dnafu/34PiSp+EcsFgtLly5l4cKF7N27l4MHDxIMBnG5XPz4xz9OeFNlONtT/O2YgWVSytVRcjpT\n", - "eWGMnMkOhCOb/gvYDFwgpewe7MkH4D1grhBiBnAauA34bNyYTcDXgCeEEB8F2pU/46wgSAIT1XjF\n", - "zCsmHkbV12PHjjF16tSkXfDGE5PJRE5OTkz0krFakVLGmLMG46xOS0vj4osvZt68ebzxxhvs3buX\n", - "UChEYWEh8+fPp66ujpqaGoCIUhkEw/6RJa09JYTYDnxFSnlguBdJenEhruVMyO1DUsqfCCHuBZBS\n", - "Phgecz+wGvAAd0sp309wHlV7apKRwBku77vvPvU/VIwq9fX1gH6DYrfbsVjGJ4C0Pwf8Sy+9xPnn\n", - "n09xcTEAzc3NVFVVkZ2djcPhID09nc2bN1NX1zeC1jBlvfrqq8kywmP6b4x07akr5ChXM5RSPg88\n", - "H7fvwbjtr42mDIrxQUrZ57unaZoPGJUWlQoFQElJSZ99RtfBRAy2SKGRcW4kEAYCAVpbWyksLOxT\n", - "Un3q1KkxiYahUIjnnnuOY8eO8dZbb7FkyRKuuuoqCgsLY/pvQPIe5bm5uVRUVIxqGK6qcquYUGia\n", - "thO4ZLzlUJydGI2SAoEAUkrS0tKGPcEahQGbmpro6OjAarUmDB1PpIA6Ozupq6ujpKSEvLw8gsEg\n", - "Dz/8MLW1etCo2WzmvPPOw263093dHXmcOnWKQCDQ5xoFBQWUlpayf//+ZEl/w15pKKWhmHBomnYP\n", - "8NB4y6E4d0i2ohitzoPd3d309PSQmZlJRkZGzLH+yqkbJOuTMW3aNBYsWMCrr74qSVy/rVFKWWxs\n", - "KKWhOGvQNK2CYRRVUygmI1JKnn76adrb2wGShtJmZWVht9tpa2vDbDYjhCAYDOL1euOH+oGdUdvD\n", - "7hGulIZiwqJpmg3oQVW8VYww0X4MKSWNjY1UVVXh8Xiw2+0UFxczZ86chFngyRiNVUmyVUd2djYe\n", - "jydiguqnQ1+MOSoepTQUZx2apgn0ks5DK02qUEQRPbH7fD4OHjzI3r17aW5uxu12R8bl5eXxzW9+\n", - "E7fbTXZ29qjLZBCtdDZu3MiRI0cIBAKR/cFgMKEvw8gLSYBSGolQSuPsR9O0d9DrlSlGkVAoFKn+\n", - "atyJGxnIEwm/34/L5aKxsZHOzk4uv/zyYZ3P4/Hgdrsj2eAA559/fkTJDLcsen+rkI0bN9Le3k4o\n", - "FMLr9ZKZmQlAS0tL0oZM8SilMUiU0jg30DTtJ8D3x1uOs5W2tjZOnTqFy+XC7XZTUlLCwoUL+zhq\n", - "FSNLMhNUPyanPvSjNOJ9GgY1Usq7lNJQnPVomnYd8Ox4y3E2kKoNfrQiiAaLUUI8NzeXrKysET13\n", - "f7kaI4XX6+XkyZMcO3YMu93O4sWLycvLS6o0+qt6Owj8QCKnzFYpZaVSGopzAk3TZgNHx1uOsxWv\n", - "10t7ezvBYBC73Y7dbp8QSiMav99PdXU1R44cobu7m09/+tPDOp+UEq/Xi8vlIhQKkZ+fPyq+DCkl\n", - "b7/9Ni+99BJSSkpKSujp6YlES0UzVKVRUFDAmjVrAna73fvMM89k1tXVJdKGQ1Yao6taFYpRwOl0\n", - "HgOygGHfhin0iSwUClFTU4Pb7SY9PZ3i4mJKSkpobGzk9ddfHzM5Uh0jpaS2tpbdu3fHOLCHihCC\n", - "jIwMysrKmD59+ogojOPHj/Puu+8SCAQiZiYhBJdccgnf+c53uPHGG8nJyUmoMICkrV+tVmu/Sjwr\n", - "K4tZs2ZZCgsLs81m84jP8WqloZi0hCOraoDp4yyKYgwwzGRerzdS3LK9vZ3du3ezatWqIZ2zo6Mj\n", - "ojBSDa1NVdb333+fBQsWkJWVxYEDB7DZbEyfPr1Pi9lkFWyFEJSXl/dREAM5yLOysrrnzZu386ab\n", - "bvrBj370o/v9fn98nyJQ5imlNM5lNE17FrhuvOWY7Jw8eRIpJTabLfJIT08fdVv/UDBWR8lqMCV7\n", - "TapmtuFGSw107tdeew2LxcKcOXN47LHHEioBI+w3mueff57q6uqEzZqi2CqlrAQQQrwBXJlsjFIa\n", - "inMWTdM09IZhCkXKGLWojMZJHo+HjIyMPspoOMEAoVAokl/h8/nw+Xzk5uby+OOPc+LECUwmU59+\n", - "GNOmTePWW28lNzcXn8/Hs88+S2NjIz6fj46OjoEuGa00HgZmJBijoqeU0lBomnYT8PR4y6GYXIzm\n", - "qqI/GhoaaGtro6mpCa/XSyAQwO/343A4uPzyyzGbzZw+fZr169fT2tqa6mmD6AphTiqDldJQnPNo\n", - "mrYQ+AAV5KEYQfx+PxaLpU/GdltbW2RfdnY2CxYsYN68edhstmFf86233uKVV14hGAwO9qUdwJ7w\n", - "85haU/EopaFQAJqmOYBaYHTrPygmHB6Ph8zMzEH5Lnp6euju7sZut8dM9slMUqFQCLfbzfr16xM2\n", - "Opo5cyZ33nknGzZsoLm5GavVisViwWq1kp6eTkFBAQUFBUyZMgWHw0F1dXVEKRmZ9/v372fv3r1D\n", - "/BRiiJiqEjHSTZgUikmJ0+lsDyuOw8Ds8ZZHMXZkZGTQ1dVFWlpaSu2DhRBkZmZGSnfEH0uE0eY1\n", - "2XFjZdDR0RHpFNgfU6ZMYdq0aZSXl1NWVhYpltjd3U11dXWfWlOJfCBjiVIairMSp9MZBOZomvYc\n", - "sGa85VGMDcaEDrErhZHKak8lc9y4jsNxpuSTYdExnNnRuFwuXC4X+/btA6CiooK1a9fS29ubsDjh\n", - "eCoMUOYpxTmApmk/An443nIoxodQKERTU1Ok5/ZIkaz8R1lZGV/4whcS+jVSabAEejZ4dnY2Lpdr\n", - "uGKOuHlKOQsVZz1Op/Ofgc+MtxyK8cFkMg1bYQzm5tpsNkcURvzrHA4HFRUVkUcyh7nP56Orqyvh\n", - "sZFMQhwKaqWhOGfQNG0Z8B6QekaYYlITCoXo6ekhLS1tUJNtKuYso6R5PA6Hg7Vr18acKz4RMRgM\n", - "EgwGefTRRzl9+jTp6elkZGSQkZERMX8ly/xOoSaVip4aCKU0FKmiaVohcBwVWTXp8Pv91NfXI6Vk\n", - "2rRpE67HBwysbKL7c/h8PqSUfUrPNzU1UVVVxfbt2xMqh37KoBv0a5KKO5dSGgrFQGiaZgUOAbPG\n", - "WxZF/2zbtg2z2cycOXMoKioa8fNHT+Ijldw32HMFg0GOHz9OVVUVR44cSVrAcBAopTEQSmkoBku4\n", - "2OGLwDXjLYsiOcFgkO3bt7Njxw4yMzOZO3cuc+bMYc6cOeNi29+xYwcrV65MeXx/2ebd3d3U1NSw\n", - "a9cuWlpa8Hq9+P3+VKKjgvRvYlVKYyCU0lAMFU3T/gP4x/GWQ9E/LpeLN998k5aWFtra2igoKODO\n", - "O+8c8etIKQkGgxHTV/yqYaitb6NrXAUCAQKBQCSPpKGhgfXr19PS0jJSjZeU0hgIpTQUw0HTtLuA\n", - "deMth6Iv77//PrNnzyY3NzdmfzAYHFSF22SkYp4abG2q06dPc+TIERYsWEBRUVHSc+/atYvdu3dj\n", - "NpuRUtLd3d1v1FQKBIEdDOD8jkYpDYViiGiatgJ4ExVZdU6Rqv/hwIEDLF68mM7OTjZs2BBRJPGR\n", - "UgDbt29n586d3HLLLcyePZvnnnuOQCDAxRdfTHFxMYcOHWLRokV0dHTwi1/8IvK6iooK7r77bjZt\n", - "2kRTUxOhUIhQKBRZpWRmZnLhhRfyxhtvJCtg2CGldCQ6kAxVRkShGCJOp/MdTdNmAgfRuwIqJgD1\n", - "9fURc0305G6xWCguLh72aiPV1YPdbqelpYWCggJyc3P71IWKXo1cfvnlXHbZZQghCIVCHD9+HJfL\n", - "RWtrK83Nzdxwww2AXl8qEVdffTUvvPACjY2NMX0zhBDU19cnbNg0lqiVhkIRhaZpGeiRVaob4ARC\n", - "ShnTj8Lr9SKEoKSkZMSinnbs2MGRI0ciq4/8/HxuuummyPZbb73FJZdcgsvl4je/+Q2hUCiyOjDK\n", - "i4RCITweD9nZ2TElTGprayOl0K+55hqklPz3f/83nZ2dkesXFxdz7733xryfVDPIw4zJSkMpDYUi\n", - "Dk3TTMAbwOXjLIpihBjIZ2Ece+edd3jllVci/blvvfVWFi1aBBDxOeTl5bFhwwb27dsXURrr169n\n", - "9uzZLF26NNLQSQiBz+cjLS2tz7VdLhf79++nu7sbj8cT+WuxWFixYgUlJSXY7XaeeOIJpTRGA6U0\n", - "FCONpmm/Ab463nIozpBKscB4gsEgQoiUXmecv7m5mY0bN3L69GmmTp3K3//930cmfcMB7/V62bNn\n", - "D1OmTGHu3Ll4vV5sNtuIN3IaxEpjUM2XDJTSUChGAE3TPo6ew2EggS4gZ3wkUkSvBkKhEN3d3QSD\n", - "QbKyskYsM3zTpk1ccsklFBYWEgwG2bp1Kzt27ODzn/88s2YNnAeaqlO9q6uL999/n4yMDDIzMyPl\n", - "Q7KyssjNzeXUqVOcOnUKl8vF3r178Xq9qYifcphtNMoRrlAME03TioD1cbtfAL6J3hEwbcyFmjgM\n", - "lFQ2akRPxiaTiezswVWBiXZUR69YDAVksVhwuVw8+OCDXH311VxyySVcddVVzJs3jwMHDiRUGvFK\n", - "oj+FkWqdqmAwyDPPPBPjAJ9oKKWhUIQJ+zLWA/a4Q884nc4jmqYdBJaOvWQThkkbjhw9oR8+fJi3\n", - "3nqLyspKZs2aRXZ2diQLOxAI8OKLL1JVVcUnP/lJysrKkpYvSaQk4hWJoSwaGhoSJu35/X5aWloQ\n", - "QrBt2zaOHj2asEghEEJf8Y77/0ApDYXiDN8BomtEdAOZwD5N03KBxeMilWJEaWlpIT09nfb2drq7\n", - "u8nMzMRkMsU0TQqFQjz77LOsWLGCOXNSdxPU1NRw5MgR6uvrCQaDNDU19WteOn36NPfff/9Ap42Y\n", - "noQQbwBXpizQKKB8GooJgxDiYWBGgkMpZ7gOFU3TlgPvAsb3yBd+nobuy/j/ge+OpgyKkWOwWdwj\n", - "lWFuYDjGH3744cFEPyUjWmk8zAj+RpRPQzHZmcE43EVpmpaN7viO/vH8APgvoAbdJPCNsZZLMXQG\n", - "UhZSSjweD62trUyZMoWsLD2fMxAIRNquXnjhhRw7doyqqiquvfZajh49yssvv0xubi5XXXVVv42d\n", - "0tPTI3WshsHW8N+aKLnvGs4JRwKlNBQKeAqYErW9GTgdfr4fvVVsfIs1SaySUYwjiSKXPB4PTU1N\n", - "zJw5M2bfu+++y4cffoiUkhtvvJGsrCxCoRC9vb2kp6dz4YUX0tjYCEB5eTnV1dUA9PT00NjYSGNj\n", - "I1VVVSxevJjVq1djt8e7wOCJJ56gqqoqacVah8NBXl5e5NwDMEMI8fBEUBiglIbiHEfTtO8AH4/a\n", - "1QV8hTM5GodJvMropa8iUQyB2tpaMjIyyM/Pj8mnGExfikTjsrKyYhSGsa+yspLKysrIPo/Hw3vv\n", - "vcfJkydxOBxUVlZGnN9paWl87GMfA2DGjBnk5ubS0dEB6PWojh49ypVXXsmsWbNIS0uLdAjs6enp\n", - "t8R5bm4ud955J3/60584efJksmHj6rtIhlIainMWTdNWAj+L2/0PTqfztKZp54e355JYOQw29Fat\n", - "TJJQXl6ecP9gEuUMH0a0j9Z4/UDnycrK4sor9fnZ5/Phdrtpbm4mLy8Pi8USKYdut9txOBwRpWGM\n", - "f+mll1KWE/R2rb29vTQ0NIx4MuBYoJSG4pxE07RpwKvETuSvAX8KPz8v/PfaJKcY7K998s0O44TR\n", - "U1tKGXFODzS5pqogBsJms2Gz6fcIRrhsYWEh119/PRs3boypFWVg1JxKFZ/PR319PQ888MCgM9wn\n", - "AkppKCYSNQAmk8lSVlZ2iRDCFAwGvV6vN6RpmnA6nSMS6qdpmgN4n9jVQjfwJafTKTVNy0F3ygcZ\n", - "eEXhB8a+hdxZjBBiUJFMUko6OjpoaGigp6eHrKysyKogvv92KvT29mIymWhvb+fEiROcOHGCQCBA\n", - "W1sbbW1tfcZbrdYhN04ajLKZKCiloZgwRDv6NE1bBfwGWAisAt7QNO3bTqdz13CuoWlaJrAdmBp3\n", - "6J+dTufx8PMl4b+JbgM9xJZO34K+GknbuHEjJpOJm266ie7ubo4cOcLSpUtHPJzzbKG3t5e0tLTI\n", - "c5/Px5YtW+js7OxTGiRR34q2tja8Xi9Tp07F4XDE5FkY+Hw+Ojo6aG9vR0rJ/Pnz+5XHbDZHZMrJ\n", - "yYk0gHI4HJw+fTrh6waTtmCYuyYzSmkoJiROp/P1sF/hy8C/AlcA72qa9j/AD51OZ+JfcD9ompYG\n", - "bOKMUjB4B/h11LZhmkpk64i/Nfxf4CaA9vb2iOPViM4BDIWhfBpxvP7668yaNYvp06djs9lIS0uj\n", - "u7ubU6dOpfT6vLy8yPPu7m56e3sJBoNMmaIHwkkpSUtLo7CwkKlT4+8R+mIoC4Obb745ZvvYsWMJ\n", - "X2f0tzCZTFit1ohiSLT6MJvNqSoNL/r30qAmlReNBUppKCYsTqczAPxW07THgP+DHsV0J/BpTdN+\n", - "DzwOvJuK2UrTNDPwKHB13CE/8EWn0xkdUH9R1PPoyb6H2FVGB3BD9MkWLFgAwKFDh1i5Mjq5fOIo\n", - "jMFEJY0m11xzDbt27WLjxo3YbDaKi4sT1mdKhMfjiWR2OxwOMjMzyczMjBkz3PfY1dVFS0tLZKXS\n", - "0tKScJzNZuPrX/86FosFIQRWq5VHHnkkYVKfUXJ9AIZUfHCsUEpDMeFxOp3twHc0TXsA+HfgU8C3\n", - "wo/jmqY9ATwJ7E+kQDRNE8DvgFujdofQzU//5nQ6D8S95BNRz6NnnkPABVHbb0Wdsy07OzuvuLgY\n", - "n89HdXV1H3PKRCG6OdB4K4+LL76YZcuW0dnZSXd3N5s2bUrpdVlZWZGEPNAn+K6uLkwmE0VFRX3e\n", - "1+HDh9m7dy95eXlUVFQwY8aMPisLoBX9JmEKwPr161PK5i4uLiY7O5t33nmHqqoqAoEADQ0NCcdO\n", - "Rh9GPEppKCYNTqfzKHCzpmkXAZ8DbgNmoSff/RA4qGna48CTTqezKuqlPwW+FHc6E3ri3k+jd2qa\n", - "NgVIHAMKs+O2e9DDcXcD+Z/85CfzAI4cORKZ1IwQTsNkMpEYisLYuHEjPT09kTv7zMxMzjvvPHJz\n", - "cwd9LpfLRUdHB3PmzGHKlClMmTKlz2ohGX6/n1AohBAiEg6bKMnOMBHOnz+fqVOncujQIU6ePElT\n", - "UxMrV65kw4YN0SG0+cYTw0diZI77fL6IGcpqtVJQUEBPTw9WqzXiS1mxYgUXXXQRtbW1dHR04Ha7\n", - "6erqYt++fXR3dw/685mojEvtKSFEPvqdYQW6re5WKWWfdakQogboRI9i8UspP5LkfKr21DlI2OR0\n", - "OfAZ4BZis7rfB55Anwi+b+yMLlHd0NDwvs/n6wIWhA8fKigomJOVlTUN+jhfvUB6nAhdxFXEraur\n", - "Y+fOnXziE58gNzeX48ePY7PZmDZt2vDf8Agw3NVFoqZAaWlpfOlLX6KwsHDQ5/P5fDz99NM0NzeT\n", - "mZlJc3MzPT09fcaVlJTwuc99btAl0QciWZMjoyNfKq8tLCzk4osvpqysjOLi4j5htCk2UvIDO8PP\n", - "R73WmsGkacIkhPgZ0CKl/JkQ4ntAnpTy+wnGVQPLpZStA5xPKY1zHE3TrOj+is8Aa0nSMOlPf/qT\n", - "PHnyZErflbiJY6DQ2idefPHF2/Lz88Xy5csxmUy43W6sVmsk7n88iVcWQ1Uep0+fZufOnRw6dCjG\n", - "oTt//nw++9nPpiyLgSHD0aNHeeuttyJhs4nMOKlM5INlMEpDSonf74/kj7z11luYzWYWL15Mbm4u\n", - "69ato7m5mdLSUrKzs8nOzsZut/Puu+8m9YdEMS5+jMlUsPBGzqTIP4Lej7mP0gijlIFiQJxOpx+9\n", - "WdILmqZ9Bfg34B/jx4lBzJRxQxMpjL8CLvSyI7d94hOfCBHV72Ck74qHQ/R7GUrbVNAnzdLSUm65\n", - "5RZ6enrYt28f77//Pk1NTSxe3KdqfBuQl+A0CZXVnDlzIiXI6+rqcLvdBAIBgsEggUCAQCAwoOlq\n", - "586duFwuvF4vPT09BINBCgoKuOaaa0hPTycQCERyQDo7O5FSDipcVggR4we5/PIzLeQ7Ojoifpmj\n", - "R4+mesoOYE/4eU3Kgowz46U0iqSUjeHnjUDiLie6U+oVIUQQeFBK+YcxkU4x2bkKvdMenHF4Qwph\n", - "r0IIpk+fzpIlS1iyJD4ytw924D3gAHqvjVSSMcY99HaoCkMIwYkTJ7BarZSWlrJixQpWrFhBEVYc\n", - "4gAAIABJREFUT09PoiS6vESvj6a7u5u6ujpmzpyJ1XpGJ5eVlQ1aPoBLL720j8xerzdSiNBisRAM\n", - "BgkGg+Tk6AvR/u4htm/fTldXF3l5eRQWFhIKhWhrayMQCGCz2cjKyqK9vZ0PP/yQurq6QSmgMHsm\n", - "cpRUMkZNaQghXgYS1Q7+5+gNKaUUQiT7tC+TUtYLIQqBl4UQh6SU25Nc776ozTeklG8MQWzFJEfT\n", - "tNnA+qefftpy1VVXBXJyciwAPT09/oyMDKvb7e4B+sxwpaWlrFy5kvLy8oQO1SSsDj+S8Rx6JFb0\n", - "72zSrJyjJ3rjb0VFBV1dXWzfvp3s7GyWLl2aUtZ19OTc1tZGXl4emZmZzJs3r8/Y1tZWtm3bRiAQ\n", - "wGw2Y7FYsFgsFBQUcPHFFye9Rl1dHUKISM/t6IeBkWRpvLf+opmOHj2a0HQlhIisepJ02RsIY4VR\n", - "M5QXDwchRCVQOZxzjJrSkFJek+yYEKJRCFEspWwQQpQACRviSinrw3+bhRAbgY+gZ/MmGnvf8KVW\n", - "nAVcB2QsWbKkNycnJw0w7oStnZ2dtLa29pJAaVitVhYtWgQQKRlhRPagm1puAwrRk/lS5cJhvpdx\n", - "Jf4u3Jho7XY7l19+eWTb5/NhtVpTXsFs27aNZcuWUVFRETmv2+0mLS0Nm81Gfn4+H/vYx9i8eTO1\n", - "tbWYzWa6u7spKipKqDQMOV5++eWYSd5kMkXyOObOncuqVav6vLfoyrrGSqG3tzfyvhJhRFTZbDam\n", - "Tp06UD9vCQTQy9R40cO2x8zR3UcY/Wb6DWNbCOEc7DnGyzy1CT1J69/Df5+OHyCEyATMUsouIUQW\n", - "evlqbUylVExGrgGYM2dOxPhslKR49tlnycjICGRkZNRmZGRMNZvNEQ+13W6PlPuwWCwUFhZGRwPl\n", - "AYMrZapTMuR3MUGIX20YYa7GAxi0o//GG2+M2TYUUTTZ2dkxjvVQKER9fT3t7e1kZWXFmLOSmZhC\n", - "oRDd3d0Eg0GsVisej4eXXnqJvLw8rrjiCkwmE9deey0vvfQSwWAwEinX2dnJ1q1bOXToUL/vw+fz\n", - "DaQwOqSUfWubTHLGM+T2L8B0okJuhRClwB+klNcJIWYBG8IvsQD/K6X8SZLzqeipcxxN04rRQ2yv\n", - "hDOVUg1zRENDA2lpaeTn50e/7BR6OPf08HafEFr07+du4KOcBUpgMmAoqmiFFe28N6KYrFZrjMJ4\n", - "/fXX2bp1a5/zpaWlRYoXNjQ0YLfb+epXvxqj+Hw+HzabLeY6KYbK9seEVxqTJuR2pDkXlcZ49tOe\n", - "SGialgv8Cvg8UQUGN2/e/OFVV121KDprGKC7uzuUmZn5AHoJkqsYePXahh6JpQHR4VDRDu1xd25P\n", - "Jgbbv9vA7/dTV1dHeXl5n4KGBs3Nzbz77rs0Njbi8/kiTvorr7ySgoICNm/ezKWXXsqCBQvYt28f\n", - "vb29zJo1K/5mAoDq6mo++OADampqcLlcg3+j0CilTN4TdgKglMY5hBDiDRJ39prQdWtGCk3TstD7\n", - "eH+XM+XLfegZ2nu8Xu+S9PR0C5y5c92zZw979uzhrrvuakV3RF41wGWqgL6eWr0dbBPwxX5e24oe\n", - "Avwp+iYFnlMMVUkYzY/iz7Vz504uu+yyIcmyZcsW1qxZQ29vL7/61a9wu90ALF68mFmzZpGbm0tR\n", - "UVEfc1l3dzeNjY2cPHmSN998M5IdHkcQcIefe4EXJvoN3GTK01CMEiaT6az7n0avqiwWi1i5cmXp\n", - "pZdeOjMtLc0IcQ0BDwFH0f1kM9PT0y1SSl555ZXDHo/Hf+ONNy5ZtmwZQggfepZ4IoXh5sxqwkdf\n", - "hWGE795A/3jQlUVr+DpDuds8a1YvyZIKB8oXsVgs9PT0sH79ehYsWMBFF12EEIJLL700pqz622+/\n", - "zfTp0ykqKuq3BH13dzfLli0D4M0334woDAC3282+ffsi5qgpU6Ywc+ZMZsyYwcyZMyOtY2fOnMnx\n", - "48eTma3chKOiJrqyGA5qpTFJSbbSCGeyfgC8CewAnnE6nV1jLN6IIoRoMJlMRcuWLeOqq66KT5rb\n", - "CXzO6XTWaJr2v8DtUce+7HQ6/wCgadp/kCDZbwD6m7gNBRKtaKIJhI85gL+h53FkJRg3HBlGnIlQ\n", - "xDBVDKXT3d0dk/jX09NDWlpaRIFEl44B/T0ayX1msxm32820adOorKzk9OnTfRQK6FFW5eXllJeX\n", - "s2vXLurr6/sTbdKs9pV56hyiH6Uh77777ujPogH4HvBnp9M56Upsappm2rBhQ9eqVasyo/sndHV1\n", - "8eyzz3oOHTqUHTW2gzPlQ34JfBvd1/ETIFnxpx7gCHB+kuMG8bWnoidzF3rdqw4gvnLfccCJXpY9\n", - "VSTQS+Le5NG0ElVkbyJhZFtHt2wdTVpbW9m/fz/79++npaUFk8nEvffeS1FRUVKHtlGOPRqHwxHp\n", - "2DcMzmqlcdaZMs51Tp48uQPd1n8Z8Gn03hCPAH+vado3nE7nu+MpX6qEy5nfBPzfT33qU5HbyGAw\n", - "yLZt23jzzTfJzMw0a5qW7nQ6vZqm/V/OKIyXgZNAC7GTah0QnW7cgR7y/Xg/omxF77dxTNO0m8Nj\n", - "rZxRGA+hF0sEuBm9RM43ol4/C/ifVN93GEEShRF31xxTlXWsSrEnW40Eg0G6urrIzc2NiUwabQ4f\n", - "Pszjj8f+C6WUkcq7iQoggh4xNUzlcE6ilMbkpSbRTilljdPpfBN4M2yS+QJ6+e+PAn/TNG0d8AOn\n", - "09mY6PXjTVhZXIMesRSTyXX48GFeeOGFSJ/mvLy8dKBK07QtwL3hYQHg0vA5DPaiN3GKn7xN6KuQ\n", - "ZCnNv3Q6nf8QJZcjfH4jSaA9/MgFXkMPzf1F+Fj0SmTEZs8U7oJ96KazlJpjD8UclWy82WxO2HJ1\n", - "pK4bTbQ/ZO7cucycORO32x1TJiQ9PZ2uri4CgQAmkykm+9tsNhMMBvucd5BKJEhqpWPOKpR56hxA\n", - "07Qc9PIt/4A+4XWht1D9rdPpnDCF/jVNWwn8CL21a4T29vbQli1bTFVVVTHjS0tL+fKXv9zfKXei\n", - "FxP8EL1UumGCagW2AZ8MbyfyGzwOfN7pdIY0TSsC/sAZB3h0PSvj+f+H7jOZhe4I9xJbqn1EGKAq\n", - "aye6yfKpsBzjilFs0Ej+mwj+Er/fT2trK8899xwnT57sc9wwpSVSKAlIZI4EZZ5STHacTmcn8D1N\n", - "0x4C/gu91MbPge9rmvY74DdOpzNxq7ExQNO05egrC6OOkzGJ+4B/v//+++8NBAJ9ilpmZGRET97R\n", - "uNCjqLYAh9F9CobC8AJL0R3ThtKI/9H0AneHFcZN6AqjEH2S2IzuJzFkNK7/m6jXZzGw01uiK5yR\n", - "vFM1o/uvhqUw6urq2LdvH9OnT2f+/Pkx2deQ+uRvNptj/BnJypIMhDHunXfeobW1FYvFgpSSrKws\n", - "FixYMGCDq+iQX6vVSlFRsvqoKSmLILrZ8xC6qXNPgjE1A51kMqNWGucgmqatAe7jjPmnF72m0i+c\n", - "Tuf+MZRjMfqK51PhXdFK4HngG06n82h8IuPMmTPtlZWVs6dPn56bwqTTy5k8DoBX0ENzv0D/E/te\n", - "oBRdWYCubGyMfCTTfmAuKeZyDKdpUCp4vV7S09NpbGzkscceY968eVx33XWREivJGOwqInp8fX09\n", - "x48f5yMf+YihoFxAlpQyPdE5PR4Pp06d4vTp09TX17NmzRpyc3M5duwYXq+3T7HC6DInoVCIY8eO\n", - "8cQTT6S6moimA3j6bAqnVdFTipQJ2+gvQ48w+iRnJsOX0VcjL8b32x6JLPRws6QV6D6Iz4WvG20b\n", - "PoHe+/uZ6OuH5f0E8E/AKmJ5H704oBe9F/gdjIJpKIp29JVCwn4R9DV3JVsRJRrbL6OtNNavX09l\n", - "ZSUFBQW43W6eeuopVq1axfTp0wd8bXz5j4EUiRFdZTKZ8Pl8BIPBmNDZffv2cf75fYPa4kNoDWw2\n", - "G3PmzCErKwu73U5OTg4bNmygrq4uokCM9ruDmPeC6KHrcBbmXyiloRgS4XLi3wTu4czd94foyuN/\n", - "nU6nF5KH+ZpMps7S0tIqu92eZrfbM0wmk7mzs7Ph1ltvfRAoABYBS4CZ4e1EE2gvusnsx4afRdO0\n", - "UmAlutnqas7UiIqehJ9Ej2B6CXjL6XReGm4D+1ngjwwcttofRmu64Zhx452lyZRESsoj2YQZHz31\n", - "zDPPkJubS2VlZUqTt3F83bp1NDY28ulPf5rZs2cTCATYtGkTxcXFffpVDBav1wtAevrAi6pt27ax\n", - "d+9esrOzueKKK5g9ezaNjY3s3LmTI0eOJOy5nUhxngv1o4aDUhqKYaFpWh7wZfSQ0dLw7mZ0e/1L\n", - "P//5z3/v8Xj6dCYaxl2uG70J1250BTUbPeppOfqKJhW/QDq6A/rHwK/vu+++HGBGSUnJ0rS0NAdA\n", - "IBDwZGdnuz/72c8mN2YPnRB6WK4bXbH1117uJWAZMHUU5IghWhFIKWlsbOSDDz5g+fLlROe7xGNM\n", - "siaTidWrV/ORj3wEgD179rBgwYKUJvw4GbqATmBaZ2cnv/jFL5g7dy4XX3wxc+bM6VeZ+f1+nnnm\n", - "GZqamvjqV7/KQw89RFtbW5/EO4OMjAyWLl2K2+2mq6uLzs7OSKTdMJjw9aOGg3KEK4aF0+lsA/5d\n", - "07RfoOd4/CNwAbr/476CgoKETWeCwSBNTU14PB48Hg8mk4mysrJId7QE+ND7C5iBcnTH7S3JBqNP\n", - "yNXALvS8kyWcWW3Yw/sA3jOZTF8KhUIrjYzd/Px85s6dm7VkyZL+e4UOjQD6iuZK4Kv0XUFF9xX3\n", - "o5f3h76JgiONjG5rK4SguLi4TyJbPNEhqaFQiC1bttDS0sLq1asj5TeSXjCspKK7+AkhqK2ttb/y\n", - "yit2h8PBRRddFKlQm5GREaPUkj2/8MIL2bNnD/X19ZG+68no6enh7bff7lfOIdB/ffRzELXSUCQl\n", - "7Ee4An3lMf2BBx6Y1dDQkFIG8kjZ2MN40LO2g+irkB50v0IJenLe79HNUJ9Yt27dRpvNlmn0nE5U\n", - "vTQZ0b0iUsCLbv76NHq74iC6IosONWoGCpuamnjhhRcoLCz0zJs3T1RUVGQmq9I60gQCgUjCXSpN\n", - "khKZv8rKyli1alXSyrLRPProo5SXl3PZZZdFoq4OHjzIrl27uOWWWwiFQjFd76qqqrjgggsGPK+U\n", - "krq6Ourr69mxYwednZ19xhh+lBTwo4ddRyuEBeG/8UrirPNjRKPMU4phoWlaPvrd8Gp0R7JhWugE\n", - "LL/97W8/39TUVNjPKSLk5OQc+fa3v/00+o/xfKAibohErxR7EHgXeAc9amYqejTRvKi/SZ3aPp8P\n", - "j8dDfn5+K+CQUpriC+QZ3/FUO8sNIZ/Ajb5ySDirHjx4kLKyskjlVMNcVFhYKM1m85h8b41rtrW1\n", - "sXDhwj7H+nNcu1wuWltbmT17NiaTqd/PZ/PmzezatYucnBxuu+02pk3Tq7cYUVmgrwh27tzJwYMH\n", - "+eIXvxjTjvWZZ56hrKyMxYsXJzWFJfNTlJeXs3btWp588kkaGxPmrhrfuQlffXasUOYpxaDQNM2E\n", - "HnV0bfixguRRPpSUlPTpB93Q0JCwLWZeXt5c9LLlBt3oimEHejHFt51OZ0eKcuYDc7ds2fJwZmbm\n", - "gilTpmA8bDabEVKZD31zAaJXDskmu/j9xvO6ujpef/117HY7drudqVOnct555yVyWCcqWBjBmKT9\n", - "fj+hUIi0tDTDVJToxxpt0hoqoa6uLpPdbmf37t0cOHCA2tpafD4fFRUV8UojYspKpgiMzxoGVqiG\n", - "s7uzs5M//vGPfOUrX6GoqCiiAF577TU6OjpYunQpV199dZ/Xt7a2snv3bjZv3ozVaiUzM5OsrCym\n", - "TJmC3W5HSonP5yM/Px+z2YzJZIrkg+Tn55Ofn9+f32XbZEm6m8iolcY5RtjZ/Ql0JbGaWKesH70H\n", - "+xZ0c9AU9KS7UnRzTB26yaUT3R+R85e//GV+V1dXhhDCLISIRAnZ7faeW2655TnOVNvd63Q6/cOR\n", - "PVH0lpHgddFFF+FyuThw4ADNzc2RbGTjMW3aNO66666Y8/n9fk6cOGH0AY9g3BVv27aN1157LbJ/\n", - "hE1u/RIIBCIKJnqf4Q9IBa/Xy2OPPRaZ5FtaWgAoKCgwhkhAGNFJR48epb29HYfDwcyZMyOlNgZR\n", - "cDCwbt06S/QqYOrUqdx7772Rc0gpOXToEM899xy9vb2RkFuLxYLFYiEnJ4ePf/zjZGZm0tHRQVtb\n", - "G21tbezfv5+OjuT3GCaTCavVSnZ2Nm63O1l/70mTqT1WqJWGAkicT2E2m9PKyspy77777pnE1iWq\n", - "RVcSzwOvRZdR1zTtT+gKowq4KFGJdafTGXM9k8lkFkKYgsGg/4MPPvBIKX85ku8tHo/Hw+7du9m1\n", - "a1efYzabjcLCQm9BQYF/xYoV2YTv7I275erqaubNi22Z0dDQwIsvvui+8847s5cuXcrrr78eYyfv\n", - "7e3t9fl8luzsbNNgTFjBYDCy0jB8JzabTVosloQnSeQ/MCbWePoLw73nnnsi7/ehhx6itrY2OphB\n", - "gN4mddu2bcCZz2b79u0xYbwtLS3U1dVRUlJCXl5en1arhojxO5qamnj55Zf5+Mc/jslkQgjBwoUL\n", - "qa6u5m9/+1tknDHJOxwOysvLAWIyvWtra/tVGkII6fP5RBJloRhBlNI4O5lB3B15XPbrVuBZdEXx\n", - "YXwSH4CmaXcDd6M7nW8ZoCdH5HrRETgjjRDClGhlXFRURFtbW8Q0ErV/1z333FMPXG/IZkxcUsqI\n", - "wgiFQlLoUFRUxEc/+tGMjo4OcnNzmTVrFseOHYuc0+PxBLKystJSSV4LIwHx17/+lUOHzvhYi4uL\n", - "uffee5O+WEpJIBDAarXS2dkZiUQzrul2uxFCkJWVlbSIYXT5DEju03G73QmVjnFsx44dvPvuu5Hv\n", - "kFHzK7qzXjAYRAiRsGBhfX09W7Zs4frrr4+sZK6++mqqq6tpbm6OGVtbW8tPfvITgsFg0GKxSIvF\n", - "YrLb7aZAINDnvNEEg8FkJVmMbnpezvLyHmOFUhrnEF6vtxn4hNPp3N3fOE3TzuNMLaWvjmVpkWRo\n", - "mmaeOnXqwkQOzrS0NG6//XYeffRR/H4/hYWFVFZWsnjx4uXhISHAFD1pRvs5TCbTSnQH6TYhRMn8\n", - "+fMjk8/KlStjlEZeXl5m/Dna29upr6+nu7tbLl++/Ch6ZNfFRDVouv76631CCE95eXl+RUUFxcXF\n", - "MWGxYSR6LkeJEOJ8q9VKVVUV+/fv5+abb45RUnGNqBJy6tQpampqmDFjBkBCk01paSkmkymp0vj9\n", - "73/fJ1LJ+B9Em63CzYxCZrP5dHFxcens2bNNZWVlMRneAE8//TQrVqxg4cKF3HHHHRw+fBiXy4XL\n", - "5eL48eMEAgFDTrOhKPoLs02BHcokNbIopXEO0djY+GEKCsMO/BXdhLXO6XQ+PNTrlZSUXKBp2l3A\n", - "X51OZ98EjxQJh/7eX1xcXNDe3h4z+ZlMJjIzM5k+fTq33347XV1dnHfeeQghou+ETYFAICSEMEXb\n", - "1g0n+eOPP76hq6sry2q1ZoPeFjQjI4O8vDzWrl3L3/3d37Fjxw56enoIBAIhi8ViAti9ezcvv/xy\n", - "dHbytk2bNlVqmvZcePsp9JDgYHZ2tu22226Lzk5PtMoQ6KXatxg78vLyyMrScxw7OjpSLj0OMG3a\n", - "NGbMmBFZYcX7JpYsWcJNN93En//854SvDwQCSCmZPn06p06dilmt/vGPf6SkpITrrruOzs5OOjo6\n", - "KC8vN7lcrrITJ07wzjvvALpyKyoqYs6cOVxwwQVIKXnqqaf4whe+QEVFBRdddFHknMPI3g6iB1q8\n", - "n+BYzVBOqEiOUhqKCOHJ+ffAfOAD4GvDOV9aWloOsA74o6ZpH6JnfhuPPalGTwH/Anxl7dq1vvvv\n", - "v39nQUHBRzMzMzPS09OxWq0+i8XiCwQCOTNnzgR0U0lVVRXV1dXBNWvW/A2YZbFYYrLB6+vr24uK\n", - "ihxmsxmv11t0+vTphBfu7e2VZWVl4jOf+QydnZ2BvXv31i9fvry8p6eHTZs2JcsLMKrMGnU94s0m\n", - "0RFY8QUVtwCZLpeLUChEYWEhF154IaDb+wcTDtzY2Mi6deuQUpKXlxcxJQkhWLVqFVdcoVeg93g8\n", - "CSO2vF4vXV1dFBcX+y0Wi9VQGsFgkLq6Os477zwA9u/fz2uvvcb111/fp7+E2+3G7XZz7NgxDh48\n", - "GFHmjzzyCDNnzoxEZhUUFDCQCaof1GpiDFFKQxHNvcBn0M0qtwy310ZbW9thoA34CHBe+HGHcVzT\n", - "tONEKRH06K0p6OGzxt+PoocCA7R/7Wtfu4DYbGobcfWlzGbziYULF/5h4cKFa9AbMoFuMsowxpaW\n", - "lg54yy6l9KelpVnDcrlzcnLyli9fXh4IBMjIyKC0tJRTp05FxmdlZVk1TfslYKReJ0qJDxD7u0uL\n", - "O54JyFdffbXHZDJl3nDDDUydeibAbTDO9+jOdIa/Jj8/P7hs2TJzRUUFoVCIrVu3Hm1pabGjJyj2\n", - "eT1AS0tLnZRyBlGrIyEEixYtAuDAgQMEg0GeeeYZd05OTiN6bk0famtrI3kbRrXZaNNfPxh+iWzO\n", - "waZHEw2lNM5Oaga5H03T0tDDawG+7HQ6Dw/3ep2dnTVOp/MuTdMy0RP8LqiqqvpWXl5eSX5+frbZ\n", - "bJ6Ffld+c4rX6a92VD3wNnq71QrOvBeDaCVxHHhyw4YNN7S3t/eppWVgMpms6ArtVvTqu5/xeDy/\n", - "ywrbixYvXuwrLi4OzZ4921JWVmax2+2XckZJJSPpb+6DDz6gubmZEydOeE+cOOG32Wxs3bqVj3/8\n", - "48leor+xKJNVsrwZgDVr1kB40g0GgyGz2fz9VatWNRw7duxbPT09eTabLc1qtUZWMw0NeouVnJyc\n", - "mfEFAhcsWIDdbqe1tZWoVVpGZ2dnSTI5jQTDIWCmb7OjDs70sqgZykkVQ0PlaSgA0DTtevQGQweA\n", - "8xJFVI0ERq6FyWSisLCQ4uJiSkpKmD59eqi0tHSglO1u9KzxZvT6VdHZ4snKj/vQS0PUoPccBzjf\n", - "6XTuN2TJyspKWFPLyMtwu92++vr6k1ar1ZaVlVVQUFCQOYwOdKeB76OveB6MljmRTX/WrFnccYe+\n", - "OEulWu3DDz88rNLp0ZFazz//PCdOnKCoqIh9+/ZFTHEWi4WSkhJMJhMejyeS/2Gz2ZIqrCEQFEK4\n", - "zGZzXiAQSJTsqHIuRgCVp6EYDp8L/31stBRGNKFQiMbGRhobG9m7dy8VFRWmu+++uwt4dceOHSUt\n", - "LS3Z3d3dQZvNtsjv91tOnz59IBgMHvnud7/bAtxOXDXZjRs3mtrb22UoFAqYTCZrKBTymUwmm8Ph\n", - "sK1du3Yperc+gxc1Tbvc2EhUZtvA7/eTnZ1tmzt37txEx4PBID6fj8zMzDb0FrLb0Is8fh5dYaUR\n", - "6/QuBf6Efvds7JfAevQ6VjEYVWaBSKitETn16quvctlll0UyoAdSZC6XC9DzHzweDx0dHVgsFgoK\n", - "CjCZTLS1tfH8889z3XXXkZuby7XXXsuRI0eCr7322j4pZaRAVCAQoLa2ts/5Q6FQvOltOLSEQqHi\n", - "ZOX4FeOHUhoKNE3L5sxd+GPjIUNTU9Me4CNOp9MfnihWxA1ZXFFRsThquxo9MfEK4GhLS8u0U6dO\n", - "ZXDGoWsD6O3t7UQvvz6HM5N0CXD0a1/7mr+uro4jR45EGvOEQiHMZjPNzc00Nzfz5z//OZJbEAqF\n", - "CAQCzJgxg4qKChYsWEAwGOSRRx55v7GxcT8ww2w23zxt2rQV4QncFk6Q86BXwf2vpqamKYWFhRYj\n", - "z+Po0aNy+/bth0+ePNldUlIS03N64cKFzJ8/P+ZDOHXqVJuUsrGurm7G4cOH02tqarjnnnsiFWaT\n", - "YaxSPB4Pubm5ZGVlcfLkyUhJkc7OTh544IGIH2T58uVceeWVfPDBB2ar1TpQRcEQ0OX3+1OpJNzH\n", - "Wa6YXCiloQC9c18G8KbT6awZDwF6eno6UigzItFNOr9wOp1V4ZpULmBaQ0PDHuCS+BekpaXlbNy4\n", - "Mae9vT2SrHfeeedhNpspKCiwFhQUsGzZMkKhEMePH+fgwYPMmzePnTt3cuLEiYipJzobub6+nnfe\n", - "eYdvfetb5OTksGbNmkVPPPGEqaenZ1kwGOTkyZORsUIICWxED70VDocDIQStra04HA7mzp0rZs+e\n", - "veDYsWP5W7dutYEeRrxq1SpWrlyJECKm2N/8+fPzgLwFCxbwsY99jN7e3sgKIyMjA4fDgd/vj/gZ\n", - "jH15eXmR2kwGhsIIhUJIKbnttttoaWmhvb2d9vZ2/vKXv9De3h5ZofSDib4+h2S4UxyrSpJPUJTS\n", - "UIB+tw4gNE3LGk5OxWgSDAZ7gW85nU7DcN6GvoooMplM5kQ9n10u14etra2mrq6uBaC3EN29ezd3\n", - "3HEHb7/9Nrm5ub1lZWVpDocDo5x6IBBg69atSeUQQjBlyhSeeuopHA4HK1euTJ86deqyEydOYLPZ\n", - "KCsro7y83HgIdFMVoCci7t+/n40bN5Kbm8vKlStZtmwZc+fOnbpjxw7S09O5/fbbmT59esSHsG3b\n", - "togzfOPGjTQ0NASEEBar1RrJ8jZKftx4442YTCZ+9rOf0dPTE3m0tbXx4IMPRhTHJZdcQmZmJj6f\n", - "D5vNRm5ubkSpRrNu3bpUlMZoUjPI/YpRRikNBcCvgE9u3Ljx0qamptP/+q//uj9snzYYyZ4CNYPc\n", - "H8FsNtvQw4J/pWlaOnpOSRFAguxqANxut1GnwuiXwIkTJyINhk6cOJEGkJuby9y5c1m8eDEzZsyI\n", - "9IJIhJQyUv6io6OD9vZ2enp6KCkpIS0tjUAgQFtbG5WVlcZLDJNM6Mknn2w5ePDgVIC2tjY2b97M\n", - "c889h8VikYFAQJjNZv7yl7+Qn58fs4IwaG9vp7Gxsc/v1lhZrFq1CofDwbe//W3q6uoUNeJFAAAM\n", - "MElEQVR49tlng62trWav10t9fT1Gc6qamhq++MUvYjab+c///E/S09PJz8/H4XDEPIZRFsaPHrgA\n", - "egkPY+VQxpmoJ9A7GSZdeagS5hMPpTQUOJ3ODzRNW+lyufbV19fnAJeN1rVGYBL4P5qmvQA8ip7/\n", - "0Q3c0dvb+/XBnGTXrl3k5+dHEus6Ojp47733eO+998jOzk6pXzfovSESleDo7OzkySefpKGhgZyc\n", - "HHMoFOptbm4+4PV6S+PHhkIhent7hfHc7/dHl87oWLRo0YmOjo6K3NzcpJOr3++nubkZh8NBb2+v\n", - "TEtLEzNnziQ7O9ucaKVQW1vL7373O9LT0wkEAhEfziAYyDexM5XoJuXonnwopaEAwOl0Vv3bv/3b\n", - "bvRkuvGmJtHOjIyMRUAheuMmE3ASuNHpdO697777bujnXDMSHWhtbe2hb3Idbre7k9Rt9AkxSnob\n", - "z8PXuQA9vyBlHA5Hy6233voloOSVV1551O/325ONtVqtdHV18eCDDwqz2cyiRYvo7e1NOrkPMWfC\n", - "IFXfxEDUDHK/YpxReRqKCP3c9U2ImHhN076HXpvJ+F+3A/8N/NrpdCY1vCd7X1lZWd0ejydRxE8H\n", - "kDtlyhSys7P7rYeULDfB6EWRgEZinbz9mmemT5/OtGnT6O7uTlrNFvQ6U4sWLeLtt9+mqyumIPFI\n", - "RysZSXVl6P1Vksk/Ib4ziv5ReRqKsxZN074E/DS8+Sx6Ut8lgBP4jqZpDwD/5XQ6ExWRqonfccEF\n", - "FxQcPnx4cYKxmM3m7LVr1zJ//nysVis//vGP6e3tTSiXz+eLCZM1yMzMlF1dXYl+jIeiJ9OBzDNC\n", - "CCorK9m8eXOH2+3uQp+s+2CxWLjsssuYMWMGTzzxRLTiGKzCMJRCSj2zE/VuMcYN8rqKSYJSGooJ\n", - "SfRklJ2dXThlypRFAH6//91Tp07dEC6ueDnwQ/ROhP8IfF3TtPuB7zmdzogjP96PEs5+3/jzn/88\n", - "4bXT09PNS5bo1UWqq6sjCsNkMoWsVqtJShny+/3dUkojyqyP0ujq6krW32FQeDwebDYbq1evTv/d\n", - "7373AUmUhsvloquri7/97W/k5ubi8/mSKroB2DOYFYJyVJ97KPOUIkJ/d41jPTkMxlSmadpy4AfA\n", - "pzZu3CgaGhpam5qaDkgpo0N/aqSUd2madgN69nXar3/96zqXy9VnEi4uLg7OmDHDfOjQoRgnt8lk\n", - "2vYv//IvhcBC0Os3Pf7448Hq6mpLMBhM9fu3NW6l8TB6nkxSE9WcOXPw+/14PB5/S0tLorCuDpvN\n", - "Zp4/f352R0fHUMuLJ5RPcXajzFOKYTFZ7xqdTucu4BZN0y5tbW3d2tjYmI++ColgMpkumDp16urS\n", - "0tKicAvT37hcriUkuHNvaGhoaWho6JNcFgqFaoAvAN8FrjCbzed//vOfN/XTByK6qJ5BTfSGlPKu\n", - "OGXdx0dQXV1t+EfiFYZx/hqfz8fBgwdnZWZmXkxsFeBoguj92kE3P6UTGw7bRz6FIh6lNBRnDU6n\n", - "c+ePf/zj3ehd82IIhUI5zc3NORkZGRLdpPUz4LUkpzo0wN321wGys7N3lJWVXRbf2S6KlEw9cT6C\n", - "N+i/VW+/5x/AR+JWqwjFcFFKQ3FW0dvb228PkPr6+nedTudPAe67775hXcvj8QQOHx5MBfmUqEmw\n", - "r98Iq0HgHXiIQtE/Smkozin8fn90Vb+aJMOS7R91EpkIRzABTtVzUgwbpTQUE5WaQe4fNKPow4n4\n", - "Gkbp/P1Rwxl/RTRelL9CMQIopaGYkAxjQq8J/x0pk04q1+qzf4QVUtLrxO+YrMEMismDCrlVnJVM\n", - "pPBhhWKiMpS5UykNhUKhOEcZytw5UE9mhUKhUCgiKKWhUCgUipQZF6UhhPi0EOKAECIohLiwn3Gr\n", - "hRCHhBBHhBDfG0sZFQqFQtGX8Vpp7AfWAtuSDRBCmIH7gdXAIuCzQoiFYyNeRIbKsbzeSDDZZJ5s\n", - "8oKSeSyYbPLC5JR5KIyL0pBSHpJSVg0w7CPAUSlljZTSDzwB3DT60sVQOcbXGwkqx1uAQVI53gIM\n", - "gcrxFmAIVI63AIOkcrwFGAKV4y3AWDCRfRrTgNqo7brwPoVCoVCME6OW3CeEeBkoTnDoh1LKzSmc\n", - "YvLHAisUCsVZxrjmaQghXgf+UUr5foJjHwXuk1KuDm//AAhJKf89wVilYBQKhWIITMZ+GskEfg+Y\n", - "K4SYAZwGbgM+m2igSuxTKBSKsWG8Qm7XCiFqgY8Czwkhng/vLxVCPAcgpQwAXwNeBD4EnpRSHhwP\n", - "eRUKhUKhc1aUEVEoFArF2DCRo6fGHCFEvhDiZSFElRDiJSGEo5+xZiHEbiFEKk79USMVmYUQ5UKI\n", - "18MJlR8IIb4xDnIOmKgphPhV+PheIcQFYy1jAnn6lVkI8bmwrPuEEG8KIc4fDzmj5EkpGVYIcbEQ\n", - "IiCE+NRYypdEllS+F5Xh39oH4d4i40oK34sCIcQLQog9YZnvGgcxDVn+JIRoFELs72fM4H53Ukr1\n", - "CD/QW4D+U/j594Cf9jP228D/ApsmuszoUWzLws+zgcPAwjGU0QwcRa86a0XvNbEwbswaYEv4+Qrg\n", - "7XH+XFOR+RIgN/x89XjKnIq8UeNeA54Fbp4En7EDOACUhbcLJoHM9wE/MeQFXIBlnOS9HLgA2J/k\n", - "+KB/d2qlEcuNwCPh548An0w0SAhRhv5h/5HkjvyxYkCZpZQNUso94edu4CBQOmYSppaoGXkfUsp3\n", - "AIcQomgMZYxnQJmllG9JKTvCm+8AZWMsYzSpJsN+HVgPNI+lcElIRebbgaeklHUAUsqWMZYxnlRk\n", - "rgdyws9zAJfUfbRjjpRyO9DWz5BB/+6U0oilSErZGH7eCCT78H4BfBcIjYlU/ZOqzACEo9EuQJ/k\n", - "xopUEjUTjRnPSXiwyaVfBLaMqkT9M6C8Qohp6BPc78K7xtuhmcpnPBfID5tX3xNCfGHMpEtMKjL/\n", - "AVgshDgN7AW+OUayDYVB/+4mQsjtmNJP0uE/R29IKWWi/A8hxPVAk5Ry91jVmhmuzFHnyUa/y/xm\n", - "eMUxVqQ6OcWv2sZzUkv52kKIVcA9wGWjJ86ApCLvL4Hvh78ngvFfJacisxW4ELgayATeEkK8LaU8\n", - "MqqSJScVmX8I7JFSVgohZgMvCyGWSim7Rlm2oTKo3905pzSklNckOxZ2GBVLKRuEECVAU4JhlwI3\n", - "CiHWoPdhzhFC/I+U8o5REnkkZEYIYQWeAv4spXx6lERNximgPGq7HP2Opr8xZeF940UqMhN2fv8B\n", - "WC2l7M8MMNqkIu9y4AldX1AAXCuE8EspN42NiH1IReZaoEVK2QP0CCG2AUuB8VIaqch8KfAjACnl\n", - "MSFENTAfPfdsojHo350yT8WyCbgz/PxOoM/kKqX8oZSyXEo5E/gM8NpoKowUGFDm8F3lQ8CHUspf\n", - "jqFsBpFETSFEGnqiZvxEtQm4AyLVANqjzG7jwYAyCyGmAxuAz0spj46DjNEMKK+UcpaUcmb4u7se\n", - "+PtxVBiQ2vfiGWBlOFoxE91Z++EYyxlNKjIfAj4GEPYPzAeOj6mUqTP43914ePQn6gPIB14BqoCX\n", - "AEd4fynwXILxVzL+0VMDygysRPe/7AF2hx+rx1jOa9Gjto4CPwjvuxe4N2rM/eHje4ELJ8D3oV+Z\n", - "0QMhXFGf6d8msrxxY9cBn5ron3F4+zvoEVT7gW9MdJnRV3Gbw9/j/cDt4yjr4+gVNXrRV233DPd3\n", - "p5L7FAqFQpEyyjylUCgUipRRSkOhUCgUKaOUhkKhUChSRikNhUKhUKSMUhoKhUKhSBmlNBQKhUKR\n", - "MkppKBQjTLgU/XEhRF54Oy+8PX28ZVMohotSGgrFCCOlrEUvCvjT8K6fAg9KKU+On1QKxcigkvsU\n", - "ilFACGEBdqFnXn8RvZ9JcHylUiiGzzlXsFChGAuklAEhxD8BzwPXKIWhOFtQ5imFYvS4Fr3uz3nj\n", - "LYhCMVIopaFQjAJCiGXolU4vAf5BCJGoH4pCMelQSkOhGGHCpeh/h97sqhb4OfAf4yuVQjEyKKWh\n", - "UIw8XwJqpJSvhrd/CywUQlw+jjIpFCOCip5SKBQKRcqolYZCoVAoUkYpDYVCoVCkjFIaCoVCoUgZ\n", - "pTQUCoVCkTJKaSgUCoUiZZTSUCgUCkXKKKWhUCgUipRRSkOhUCgUKfP/ABqW6g4LJdxHAAAAAElF\n", - "TkSuQmCC\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#Random dataset\n", - "random_motors = environment.random_motors(n=1000)\n", - "\n", - "%pylab inline\n", - "ax = axes()\n", - "for m in random_motors:\n", - " environment.plot_arm(ax, m)\n", - " \n", - "sm_cls, sm_configs = sensorimotor_models['nearest_neighbor']\n", - "model = sm_cls(environment.conf, **sm_configs['default'])\n", - "\n", - "for m in random_motors:\n", - " s = environment.compute_sensori_effect(m)\n", - " model.update(m, s)\n", - " \n", - "testing_couples = {}\n", - "testing_m = environment.random_motors(n=30)\n", - "for i in range (len(testing_m):#m in testing_m:\n", - " testing_couples[] = environment.compute_sensori_effect(m)\n", - "\n", - "distance = {}" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAFcZJREFUeJzt3Xu0pXV93/H3d2bwgo6OFLkIY8YIMRCNIilBIXpEscPU\n", - "4qXRBGNFSA1NF5AmbeOtqw/PH1kxaZsQZNVSL4iJC6yxtSjjBYQjJI0kqCAqBIgcGCSOBYGCoOHy\n", - "7R/PM7Bnzj7n/M6Zc/Zv7zPv11p77f08z2/2/sxZZ+/Pea47MhNJkkqsqR1AkjQ5LA1JUjFLQ5JU\n", - "zNKQJBWzNCRJxSwNSVKxqqURER+NiO0Rcf08Y86JiJsj4rqIOGKU+SRJO6u9pnE+sHmuhRGxBTgk\n", - "Mw8FfgP44KiCSZJmq1oamXkVcM88Q04ELujHXg1siIj9R5FNkjRb7TWNhRwEbBuYvgM4uFIWSdrj\n", - "jXtpAMQu0173RJIqWVc7wAK+B2wcmD64n7eTiLBIJGkJMnPXP8znNe6lcTFwOnBRRBwN3JuZ24cN\n", - "XOx/vEREnJWZZy33866kScs8aXnBzKMwaXlhYjMv+g/uqqURERcCrwT2jYhtQAPsBZCZ52Xm1ojY\n", - "EhG3AD8CTqmXVpJUtTQy86SCMaePIoskaWGTsCO8punaAZZgunaARZquHWAJpmsHWILp2gEWabp2\n", - "gCWYrh1gFGI1fAlTRORK7NOQpNVsKZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilUtjYjYHBE3RsTNEfGuIcunIuK+iPhGf/sPNXJKkjrrar1wRKwFzgVeA3wP+JuI\n", - "uDgzb9hl6Fcy88SRB5QkzVJzTeMo4JbMnMnMh4GLgNcPGRejjSVJmkvN0jgI2DYwfUc/b1ACL4+I\n", - "6yJia0QcPrJ0kqRZqm2eoiuEhXwd2JiZD0bECcBngJ8ZNjAizhqYnM7M6d1OKEmrSERMAVO79RyZ\n", - "JZ/dyy8ijgbOyszN/fR7gMcy8w/m+Te3Akdm5g93mZ+Z6WYsSVqEpXx21tw8dQ1waERsiognAb8C\n", - "XDw4ICL2j4joHx9FV3I/nP1UkqRRqLZ5KjMfiYjTgS8Ca4GPZOYNEXFav/w84JeB34yIR4AHgV+t\n", - "lVeSVHHz1HJy85QkLd6kbZ6SJE0YS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ5JUzNKQJBWrWhoRsTkiboyImyPiXXOMOadffl1EHDHqjJKkJ1QrjYhYC5wLbAYOB06KiMN2\n", - "GbMFOCQzDwV+A/jgyINqRUTEloj4QkRM9/dbameStLB1cy2IiM8D/zozb12h1z4KuCUzZ/rXuwh4\n", - "PXDDwJgTgQsAMvPqiNgQEftn5vYVyqQR6AviT4BDBmY/PyLIzK2VYkkqMN+axkeBL0bE+yJirxV4\n", - "7YOAbQPTd/TzFhpz8Apk0Widyc6FQT99RoUskhZhzjWNzPxUv7bxH4FrIuJPgXxicf7Rbr52LjwE\n", - "gCj5dxFx1sDkdGZOLyGTRuMpw2but99+R7Zt+1rgy03TPDriTNKqFxFTwNTuPMecpdF7GHiA7k2+\n", - "Hnhsd15sF98DNg5Mb6Rbk5hvzMH9vFky86xlzKaV9eNhM9evX/9s4IvAtrZtPwZ8rGma744ymLSa\n", - "9X9MT++Yjohmsc8RmcP/4I+IzcAfAZ8F2sx8cEkp53rhiHXA3wKvBu4E/ho4KTNvGBizBTg9M7dE\n", - "xNHA2Zl59JDnyszcdY1EY2rYPo01a9bcdtxxx1157LHHHgs8b2D4NN2m0k83TbOsv4PSnm4pn53z\n", - "lcZVwL/KzG8vR7g5XuME4GxgLfCRzPz9iDgNIDPP68fsOMLqR8Apmfn1Ic9jaUyYvjjOAJ4KPAR8\n", - "IDO3tm27BngFcCrwy/1ygPuBC4HzgaubpindvClpDstdGpFzLRwzlsbq1LbtM4G30BXI4BrmDXRr\n", - "H3/aNI1H0klLtKylMUksjdWvbdvDgVOAtwP79bMfBS6hK5CtTdM8XCmeNJEsDa16bdvuBZxAt/bx\n", - "OrpNmwA/AD4OnN80zXcqxZMmiqWhPUrbtgcAb6MrkMGrCVxNt/bxyaZp7quRTZoElob2SG3bBt0V\n", - "Bk4FTqI7PBy6HeyfpiuQrzRNs5yHjEsTz9LQHq9t272BN9EVyKsGFt1Kd+TVBU3T3F4jmzRuLA1p\n", - "QNu2Pw28o7/tOEk0gcvo1j4+0zTN0BMNpT2BpSEN0bbtWuA4urWPNwJP7hfdC3yCbg3k6577oT2N\n", - "pSEtoG3bfej2e5wCHDmw6Jt0ax+faJrmrhrZpFGzNKRFaNv2xXTl8TbgH/WzHwYupiuQLzVN80il\n", - "eNKKszSkJWjb9snAP6MrkM088ZUBd9J9n8v5TdPcXCmetGIsDWk3tW17EN1Z56ey83d+/AXd2sen\n", - "mqZ5oEY2ablZGtIy6c/9OIauPN4CPK1f9CPgf9AVyF+681yTzNKQVkDbtuuBN9MVyDEDi26mK4+P\n", - "N01zZ41s0u6wNKQV1rbtC+jO+zgZOLCf/RjwBboC+WzTNP9QJ520OJaGNCJt264DXku39nEisFe/\n", - "6C7gz+h2nn+zUjypiKUhVdC27bOBX6MrkBcNLPoa3drHhU3T3FMjmzQfS0OqqN95fiTdobtvBTb0\n", - "i34C/C+6AvmyF07UuLA0pDHRtu1TgTfQFchrgB2/n7cDHwM+1jTNrXXSSR1LQxpDbdv+FN2O81OA\n", - "TQOLPgGc3DTNozVySZaGNMbatl0DTNGVx5vpLpz4iqZprqqZS3uupXx2rlupMJJ21u/LuBy4vG3b\n", - "e4AzgOMBS0MTY83CQyStgEv7++OrppAWydKQ6pgGHgGOatt2wwJjpbFhaUgVNE1zP/BVuvfgqxYY\n", - "Lo0NS0Oqx01UmjiWhlSPpaGJY2lI9fwNcB9wSNu2m+pGkcpYGlIl/VfJXtFPurahiWBpSHW5iUoT\n", - "xdKQ6tpRGq9u23Zt1SRSAUtDqusW4DZgH+CIylmkBVkaUkX9d4y7iUoTw9KQ6rM0NDEsDam+LwMJ\n", - "HNO27d61w0jzsTSkypqmuZvuq2GfBLyichxpXpaGNB7cRKWJYGlI48HS0ESwNKTx8H+AB4EXtW17\n", - "QO0w0lwsDWkMNE3zE+DKfvI1NbNI87E0pPHhJiqNPUtDGh+Pl0bbtlE1iTQHS0MaH98Cvg8cCBxe\n", - "OYs0lKUhjYn+kiKX9ZNuotJYsjSk8eJ+DY01S0MaLzvWNF7Ztu2TqiaRhrA0pDHSNM2dwE3A04Cf\n", - "qxxHmsXSkMbPzf39T1VNIQ2xrsaLRsQ+wCfp3hQzwFsy894h42aA/wc8CjycmUeNMKZUy0x/v6li\n", - "BmmoWmsa7wYuzcyfobss9LvnGJfAVGYeYWFoDzLT32+qmEEaqlZpnAhc0D++AHjDPGM9yUl7mpn+\n", - "flPFDNJQtUpj/8zc3j/eDuw/x7gELouIayLinaOJJlU3099vqphBGmrF9mlExKXAsKt1vm9wIjMz\n", - "InKOpzkmM/8+Ip4NXBoRN2bmVXO83lkDk9OZOb2E2NI4mOnvN1XMoFUoIqaAqd16jsy5Pq9XTkTc\n", - "SLev4vsRcSBwRWb+7AL/pgEeyMz/MmRZZqabsbQq9Nedup/usNtnNU0z6yARaTks5bOz1uapi4GT\n", - "+8cnA5/ZdUBE7B0R6/vHTwNeC1w/soRSJf3lRGb6yU31kkiz1SqN9wPHR8RNwHH9NBHxnIi4pB9z\n", - "AHBVRFwLXA18LjO/VCWtNHoz/f2mihmkWaqcp5GZP2TIF81k5p3AP+0ffxd4yYijSeNipr/fVDGD\n", - "NItnhEvjaaa/31QxgzSLpSGNp5n+flPFDNIsloY0nmb6+00VM0izWBrSeJrp7zdVzCDNYmlI4+lu\n", - "4EfAM9u23VA7jLSDpSGNIc/V0LiqcsitpCIzdF/EdEnbtluBrcBlTdPcXzWV9mhVLiOy3LyMiFaj\n", - "tm1fB/x34MCB2Q8DV9EVyFbgxn6tRFq0pXx2WhrSGOuvQ/ViYEt/exk7b1ae4YkCuaJpmgdHnVGT\n", - "y9KQVrm2bfehuw7bFuAEYN+BxT8BrqArkM83TXPL6BNqklga0h6kbds1wC/wxFrIL7Dzl5bdzBNr\n", - "IVc2TfPjkYfUWLM0pD1Y27b7Af+ErkA2A4OH6j5I99XKW4FPNU1z9+gTatxYGpIAaNt2HfCLPLEW\n", - "Mnjxz4eAjwNnN01zY4V4GhOWhqSh2rY9iG7t4810ayM7XAL8MXC5R2HteSwNSQtq2/Yw4N8Abwee\n", - "0s/+Jl15XNg0zU9qZdNoWRqSirVt+2zgNOB0YP9+9nbgXOC/NU1zV61sGg1LQ9KitW37ZOAk4LeB\n", - "n+9n/5huv8d5wG3AfU3TPFInoVaKpSFpyfoTCY8Dfodu5/muHgDuAe7tb4OPfwh8rmmar40mrZaD\n", - "pSFpWbRt+7N0+z2OB55Fd/huyXvsL84999xH7rrrrjXArh8uM5n5jmUNqt1iaUhaEf2JhOvpymMD\n", - "TxTJjtvz6XasP+P888/ntttuG/Y0X8nMqZEEVhFLQ1I1bduuB07+8Ic//Id33HHHU4cMsTTGjKUh\n", - "qbqImAZeOWSRpTFmlvLZ6fdpSKvUCyO2bIQz18NT7ocfb4NzvpW5tXYuTTZLQ1qFXhix5WXwJx+C\n", - "Q3bMeyc8/4URWBzaHZaGtApthDMHCwPgQ3DIFjiD7qKFK2lmkfM1QSwNaRVa/8TlQXbydBi2g3pZ\n", - "eVjt6rZm4SGSJs393RndszzQXeFWWjJLQ1qFtsE574SdvrnvX8Lf3Q4fqJVJq4OH3Eqr1AsjtjwX\n", - "zng6PPUBeOh2+IA7wTXI8zQkScWW8tnp5ilJUjFLQ5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQV\n", - "szQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxaqURkS8OSK+HRGPRsRL\n", - "5xm3OSJujIibI+Jdo8woSZqt1prG9cAbgSvnGhARa4Fzgc3A4cBJEXHYaOI9nmFqlK+3HCYt86Tl\n", - "BTOPwqTlhcnMvBRVSiMzb8zMmxYYdhRwS2bOZObDwEXA61c+3U6mRvx6y2GqdoBFmqodYAmmagdY\n", - "gqnaARZpqnaAJZiqHWAUxnmfxkHAtoHpO/p5kqRK1q3UE0fEpcABQxa9NzM/W/AUucyRJEm7KTLr\n", - "fTZHxBXAv83Mrw9ZdjRwVmZu7qffAzyWmX8wZKwFI0lLkJmxmPErtqaxCHMFvgY4NCI2AXcCvwKc\n", - "NGzgYv/TkqSlqXXI7RsjYhtwNHBJRHy+n/+ciLgEIDMfAU4Hvgh8B/hkZt5QI68kqVN185QkabKM\n", - "89FTIxcR+0TEpRFxU0R8KSI2zDN2bUR8IyJKduqvmJLMEbExIq7oT6j8VkScWSHngidqRsQ5/fLr\n", - "IuKIUWcckmfezBHxa33Wb0bEX0bEz9fIOZCn6GTYiPjHEfFIRLxplPnmyFLyezHVv9e+FRHTI444\n", - "LM9Cvxf7RsQXIuLaPvM7KsTckeWjEbE9Iq6fZ8zi3neZ6a2/AX8I/G7/+F3A++cZ+zvAJ4CLxz0z\n", - "3VFsL+kfPx34W+CwEWZcC9wCbAL2Aq7d9fWBLcDW/vEvAl+t/HMtyfwy4Jn94801M5fkHRh3OfA5\n", - "4J9PwM94A/Bt4OB+et8JyHwW8Ps78gJ3A+sq5f0l4Ajg+jmWL/p955rGzk4ELugfXwC8YdigiDiY\n", - "7of9YebekT8qC2bOzO9n5rX94weAG4DnjCxh2Ymaj/8/MvNqYENE7D/CjLtaMHNm/lVm3tdPXg0c\n", - "POKMg0pPhj0D+HPg/44y3BxKMr8V+HRm3gGQmXeNOOOuSjL/PfCM/vEzgLuz20c7cpl5FXDPPEMW\n", - "/b6zNHa2f2Zu7x9vB+b64f0x8O+Bx0aSan6lmQHoj0Y7gu5DblRKTtQcNqbmh/BiTy79dWDriiaa\n", - "34J5I+Igug+4D/azau/QLPkZHwrs029evSYi/sXI0g1XkvlDwM9FxJ3AdcBvjSjbUiz6fTcOh9yO\n", - "1DwnHb5vcCIzc9j5HxHxOuAHmfmNUV1rZnczDzzP0+n+yvytfo1jVEo/nHZda6v5oVb82hHxKuBU\n", - "4JiVi7OgkrxnA+/uf0+C+mvJJZn3Al4KvBrYG/iriPhqZt68osnmVpL5vcC1mTkVEc8HLo2IF2fm\n", - "/SucbakW9b7b40ojM4+fa1m/w+iAzPx+RBwI/GDIsJcDJ0bEFuApwDMi4uOZ+fYVirwcmYmIvYBP\n", - "A3+WmZ9Zoahz+R6wcWB6I91fNPONObifV0tJZvqd3x8CNmfmfJsBVlpJ3iOBi7q+YF/ghIh4ODMv\n", - "Hk3EWUoybwPuysyHgIci4krgxUCt0ijJ/HLg9wAy8+8i4lbgBXTnno2bRb/v3Dy1s4uBk/vHJwOz\n", - "Plwz872ZuTEznwf8KnD5ShZGgQUz939VfgT4TmaePcJsOzx+omZEPInuRM1dP6guBt4Oj18N4N6B\n", - "zW41LJg5Ip4L/E/gbZl5S4WMgxbMm5k/nZnP6393/xz4zYqFAWW/F/8bOLY/WnFvup213xlxzkEl\n", - "mW8EXgPQ7x94AfDdkaYst/j3XY09+uN6A/YBLgNuAr4EbOjnPwe4ZMj4V1L/6KkFMwPH0u1/uRb4\n", - "Rn/bPOKcJ9AdtXUL8J5+3mnAaQNjzu2XXwe8dAx+H+bNTHcgxN0DP9O/Hue8u4w9H3jTuP+M++l/\n", - "R3cE1fXAmeOemW4t7rP97/H1wFsrZr2Q7ooa/0C31nbq7r7vPLlPklTMzVOSpGKWhiSpmKUhSSpm\n", - "aUiSilkakqRiloYkqZilIS2z/lL0342IZ/XTz+qnn1s7m7S7LA1pmWXmNrqLAr6/n/V+4LzMvL1e\n", - "Kml5eHKftAIiYh3wNbozr3+d7vtMHq2bStp9e9wFC6VRyMxHIuJ3gc8Dx1sYWi3cPCWtnBPorvvz\n", - "otpBpOViaUgrICJeQnel05cBvx0Rw74PRZo4loa0zPpL0X+Q7suutgH/CfjPdVNJy8PSkJbfO4GZ\n", - "zPxyP/1fgcMi4pcqZpKWhUdPSZKKuaYhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaG\n", - "JKnY/wfSP/dwYGt2YAAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#NN TEST\n", - "for m in testing_couples\n", - " \n", - "sTest_pred = model.forward_prediction(mTest)\n", - "distance[\"NN\"] = abs(sTest_pred-sTest)\n", - "\n", - "%pylab inline\n", - "ax = axes()\n", - "environment.plot_arm(ax, mTest)\n", - "ax.plot(*sTest_pred, marker='o', color='red')" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-0.65232833 -0.78444065 -0.07154134 0.98469259 -0.20240519 0.59945435\n", - " -0.5925971 ]\n", - "[ 0.54220714 0.79929109]\n", - "['NN']\n" - ] - } - ], - "source": [ - "sensorimotor_models.keys()\n", - "print mTest\n", - "print sTest\n", - "print distance.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0.56816432 -0.60892505]\n", - "Populating the interactive namespace from numpy and matplotlib\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": [ - "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", - "AAALEgAACxIB0t1+/AAAFbpJREFUeJzt3XuUpHV95/H3dxi8oOjIIiAXM0aIgWgUyRIQIi2Kzsxm\n", - "8bLRBGNEyIUkB8wmuxtve/bh+WNPTHY3QcNZw/GCmHjAGHfdUQYUhBZykQQVRGXCTKRxkDguCCwI\n", - "Gi7f/eN5hqmZqe7+dU93/apm3q9z6lQ9z/Obqs/06apPP9eKzESSpBIrageQJE0OS0OSVMzSkCQV\n", - "szQkScUsDUlSMUtDklSsamlExEciYmtE3DLHmPdHxKaIuDkijh1lPknSjmqvaVwMrJltYUSsA47M\n", - "zKOA3wA+MKpgkqRdVS2NzLweuHeOIacDl/RjbwBWRcTBo8gmSdpV7TWN+RwGbBmYvhM4vFIWSdrr\n", - "jXtpAMRO0173RJIqWVk7wDy+AxwxMH14P28HEWGRSNIiZObOf5jPadxLYz1wLnBZRJwA3JeZW4cN\n", - "XOh/vEREnJ+Z5y/18y6nScs8aXnBzKMwaXlhYjMv+A/uqqUREZcCpwAHRsQWoAH2BcjMizJzQ0Ss\n", - "i4jNwA+As+qllSRVLY3MPKNgzLmjyCJJmt8k7Aivabp2gEWYrh1ggaZrB1iE6doBFmG6doAFmq4d\n", - "YBGmawcYhdgTvoQpInI59mlI0p5sMZ+drmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqSpGKWhiSp\n", - "mKUhSSpmaUiSilUtjYhYExEbI2JTRLxjyPKpiLg/Ir7a3/5zjZySpM7KWi8cEfsAFwKvAr4D/ENE\n", - "rM/MW3ca+sXMPH3kASVJu6i5pnE8sDkzZzLzEeAy4LVDxsVoY0mSZlOzNA4DtgxM39nPG5TAyyLi\n", - "5ojYEBHHjCydJGkX1TZP0RXCfL4CHJGZD0XEWuDTwE8MGxgR5w9MTmfm9G4nlKQ9SERMAVO79RyZ\n", - "JZ/dSy8iTgDOz8w1/fS7gMcz8w/n+De3A8dl5vd3mp+Z6WYsSVqAxXx21tw8dSNwVESsjognAb8I\n", - "rB8cEBEHR0T0j4+nK7nv7/pUkqRRqLZ5KjMfjYhzgc8B+wAfzsxbI+KcfvlFwC8AvxURjwIPAb9U\n", - "K68kqeLmqaXk5ilJWrhJ2zwlSZowloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", - "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", - "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", - "pGKWhiSpmKUhSSpmaUiSilkakqRiloYkqZilIUkqZmlIkopZGpKkYpaGJKmYpSFJKmZpSJKKWRqS\n", - "pGKWhiSpmKUhSSpWtTQiYk1EbIyITRHxjlnGvL9ffnNEHDvqjJKk7aqVRkTsA1wIrAGOAc6IiKN3\n", - "GrMOODIzjwJ+A/jAyINqWUTEuoi4MiKm+/t1tTNJmt/K2RZExBXAb2fm7cv02scDmzNzpn+9y4DX\n", - "ArcOjDkduAQgM2+IiFURcXBmbl2mTBqBviDeBxw5MPv5EUFmbqgUS1KBudY0PgJ8LiLeExH7LsNr\n", - "HwZsGZi+s58335jDlyGLRuvt7FgY9NPnVcgiaQFmXdPIzE/2axv/BbgxIv4cyO2L849387Vz/iEA\n", - "RMm/i4jzByanM3N6EZk0Gk8ZNvOggw46rm3bVwNfaJrmsRFnkvZ4ETEFTO3Oc8xaGr1HgAfp3uT7\n", - "A4/vzovt5DvAEQPTR9CtScw15vB+3i4y8/wlzKbl9cNhM/fff/9nA58DtrRt+1Hgo03TfGuUwaQ9\n", - "Wf/H9PS26YhoFvockTn8D/6IWAP8MfAZoM3MhxaVcrYXjlgJ/CPwSuAu4O+BMzLz1oEx64BzM3Nd\n", - "RJwAXJCZJwx5rszMnddINKaG7dNYsWLFHaeeeup1J5988snA8waGT9NtKv1U0zRL+jso7e0W89k5\n", - "V2lcD/xmZn5jKcLN8hprgQuAfYAPZ+YfRMQ5AJl5UT9m2xFWPwDOysyvDHkeS2PC9MVxHvBU4GHg\n", - "TzNzQ9u2K4CXA2cDv9AvB3gAuBS4GLihaZrSzZuSZrHUpRE528IxY2nsmdq2fSbwJroCGVzDvJVu\n", - "7ePPm6bxSDppkZa0NCaJpbHna9v2GOAs4K3AQf3sx4DL6QpkQ9M0j1SKJ00kS0N7vLZt9wXW0q19\n", - "/Dzdpk2A7wEfAy5umuableJJE8XS0F6lbdtDgLfQFcjg1QRuoFv7+ETTNPfXyCZNAktDe6W2bYPu\n", - "CgNnA2fQHR4O3Q72T9EVyBebplnKQ8aliWdpaK/Xtu1+wBvoCuQVA4tupzvy6pKmab5dI5s0biwN\n", - "aUDbtj8OvK2/bTtJNIGr6dY+Pt00zdATDaW9gaUhDdG27T7AqXRrH68Hntwvug/4ON0ayFc890N7\n", - "G0tDmkfbtgfQ7fc4CzhuYNHX6NY+Pt40zd01skmjZmlIC9C27YvpyuMtwL/qZz8CrKcrkM83TfNo\n", - "pXjSsrM0pEVo2/bJwL+lK5A1bP/KgLvovs/l4qZpNlWKJy0bS0PaTW3bHkZ31vnZ7PidH39Nt/bx\n", - "yaZpHqyRTVpqloa0RPpzP06iK483AU/rF/0A+Eu6Avkbd55rklka0jJo23Z/4I10BXLSwKJNdOXx\n", - "saZp7qqRTdodloa0zNq2fQHdeR9nAs/pZz8OXElXIJ9pmuZf6qSTFsbSkEakbduVwKvp1j5OB/bt\n", - "F90N/AXdzvOvVYonFbE0pAratn028Mt0BfKigUVfplv7uLRpmntrZJPmYmlIFfU7z4+jO3T3zcCq\n", - "ftGPgP9NVyBf8MKJGheWhjQm2rZ9KvA6ugJ5FbDt9/PbwEeBjzZNc3uddFLH0pDGUNu2P0a34/ws\n", - "YPXAoo8DZzZN81iNXJKlIY2xtm1XAFN05fFGugsnvrxpmutr5tLeazGfnSuXK4ykHfX7Mq4Brmnb\n", - "9l7gPOA0wNLQxFgx/xBJy+Cq/v60qimkBbI0pDqmgUeB49u2XTXPWGlsWBpSBU3TPAB8ie49+Ip5\n", - "hktjw9KQ6nETlSaOpSHVY2lo4lgaUj3/ANwPHNm27eq6UaQyloZUSf9Vstf2k65taCJYGlJdbqLS\n", - "RLE0pLq2lcYr27bdp2oSqYClIdW1GbgDOAA4tnIWaV6WhlRR/x3jbqLSxLA0pPosDU0MS0Oq7wtA\n", - "Aie1bbtf7TDSXCwNqbKmae6h+2rYJwEvrxxHmpOlIY0HN1FpIlga0niwNDQRLA1pPPwt8BDworZt\n", - "D6kdRpqNpSGNgaZpfgRc10++qmYWaS6WhjQ+3ESlsWdpSOPjidJo2zaqJpFmYWlI4+PrwHeB5wDH\n", - "VM4iDWVpSGOiv6TI1f2km6g0liwNaby4X0NjzdKQxsu2NY1T2rZ9UtUk0hCWhjRGmqa5C7gNeBrw\n", - "U5XjSLuwNKTxs6m//7GqKaQhVtZ40Yg4APgE3ZtiBnhTZt43ZNwM8P+Ax4BHMvP4EcaUapnp71dX\n", - "zCANVWtN453AVZn5E3SXhX7nLOMSmMrMYy0M7UVm+vvVFTNIQ9UqjdOBS/rHlwCvm2OsJzlpbzPT\n", - "36+umEEaqlZpHJyZW/vHW4GDZxmXwNURcWNE/PpooknVzfT3qytmkIZatn0aEXEVMOxqne8ZnMjM\n", - "jIic5WlOysx/johnA1dFxMbMvH6W1zt/YHI6M6cXEVsaBzP9/eqKGbQHiogpYGq3niNzts/r5RMR\n", - "G+n2VXw3Ip4DXJuZPznPv2mABzPzfwxZlpnpZiztEfrrTj1Ad9jts5qm2eUgEWkpLOazs9bmqfXA\n", - "mf3jM4FP7zwgIvaLiP37x08DXg3cMrKEUiX95URm+snV9ZJIu6pVGu8FTouI24BT+2ki4tCIuLwf\n", - "cwhwfUTcBNwAfDYzP18lrTR6M/396ooZpF1UOU8jM7/PkC+aycy7gH/TP/4W8JIRR5PGxUx/v7pi\n", - "BmkXnhEujaeZ/n51xQzSLiwNaTzN9PerK2aQdmFpSONppr9fXTGDtAtLQxpPM/396ooZpF1YGtJ4\n", - "ugf4AfDMtm1X1Q6zlF4YsW5txJVvipheG3HlCyPW1c6kcpaGNIb21HM1Xhix7kR43xXwmr+EU66A\n", - "15wI77M4JkeVM8KXmmeEa0/Utu1n6Q5BvwvY0N+ubprmgarBdsPaiCuvgNfsPH8dXLkhc22NTHuz\n", - "xXx2VjlPQ1KRPwNeChwK/Fp/e6Rt2+vZXiIb+7WSibA/PGXY/KfDU0edRYvjmoY0xvrrUL0YWNff\n", - "TmTHzcozbC+Qa5umeWjUGRfCNY3xspjPTktDmiBt2x5Adx22dcBa4MCBxT8CrqUrkCuaptk8+oRz\n", - "27ZP44Nw5LZ5vwb/9CV4+9czN9TMtjeyNKS9SNu2K4CfYftayM+w45eWbWL7Wsh1TdP8cOQhh3hh\n", - "xLrnwnlPh6c+CA9/G/7UwqjD0pD2Ym3bHkS36WcdsAYYPFT3IbqvVt4AfLJpmntGn1DjxtKQBEDb\n", - "tiuBn2X7WsjgxT8fBj4GXNA0zcYK8TQmLA1JQ7Vtexjd2scb2XFH9OXAnwDXTNJRWFoaloakebVt\n", - "ezTw74G3sv0Q2K/RlcelTdP8qFY2jZalIalY27bPBs4BzgUO7mdvBS4E/qxpmrtrZdNoWBqSFqxt\n", - "2ycDZwC/C/x0P/uHdPs9LgLuAO5vmubROgm1XCwNSYvWn0h4KvB7dDvPd/YgcC9wX38bfPx94LNN\n", - "03x5NGm1FCwNSUuibdufpNvvcRrwLLrDd0veY3994YUXPnr33XevAHb+cJnJzLctaVDtFktD0rLo\n", - "TyTcn648VrG9SLbdnk+3Y/0ZF198MXfcccewp/liZk6NJLCKWBqSqmnbdn/gzA996EN/dOeddw67\n", - "AKGlMWYsDUnVRcQ0cMqQRZbGmFnMZ6dfwiRJKmZpSJKK+SVMkpbazALna4K4T0OS9lLu05AkLStL\n", - "Q5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScUsDUlSMUtDklTM0pAkFbM0JEnFLA1JUjFL\n", - "Q5JUzNKQJBWzNCRJxSwNSVIxS0OSVMzSkCQVszQkScWqlEZEvDEivhERj0XES+cYtyYiNkbEpoh4\n", - "xygzSpJ2VWtN4xbg9cB1sw2IiH2AC4E1wDHAGRFx9GjiPZFhapSvtxQmLfOk5QUzj8Kk5YXJzLwY\n", - "VUojMzdm5m3zDDse2JyZM5n5CHAZ8NrlT7eDqRG/3lKYqh1ggaZqB1iEqdoBFmGqdoAFmqodYBGm\n", - "agcYhXHep3EYsGVg+s5+niSpkpXL9cQRcRVwyJBF787MzxQ8RS5xJEnSborMep/NEXEt8B8y8ytD\n", - "lp0AnJ+Za/rpdwGPZ+YfDhlrwUjSImRmLGT8sq1pLMBsgW8EjoqI1cBdwC8CZwwbuND/tCRpcWod\n", - "cvv6iNgCnABcHhFX9PMPjYjLATLzUeBc4HPAN4FPZOatNfJKkjpVN09JkibLOB89NXIRcUBEXBUR\n", - "t0XE5yNi1Rxj94mIr0ZEyU79ZVOSOSKOiIhr+xMqvx4Rb6+Qc94TNSPi/f3ymyPi2FFnHJJnzswR\n", - "8ct91q9FxN9ExE/XyDmQp+hk2Ij41xHxaES8YZT5ZslS8nsx1b/Xvh4R0yOOOCzPfL8XB0bElRFx\n", - "U5/5bRVibsvykYjYGhG3zDFmYe+7zPTW34A/An6/f/wO4L1zjP094OPA+nHPTHcU20v6x08H/hE4\n", - "eoQZ9wE2A6uBfYGbdn59YB2woX/8s8CXKv9cSzKfCDyzf7ymZuaSvAPjrgE+C/y7CfgZrwK+ARze\n", - "Tx84AZnPB/5gW17gHmBlpbw/BxwL3DLL8gW/71zT2NHpwCX940uA1w0bFBGH0/2wP8TsO/JHZd7M\n", - "mfndzLypf/wgcCtw6MgSlp2o+cT/IzNvAFZFxMEjzLizeTNn5t9l5v395A3A4SPOOKj0ZNjzgL8C\n", - "/u8ow82iJPObgU9l5p0AmXn3iDPurCTzPwPP6B8/A7gnu320I5eZ1wP3zjFkwe87S2NHB2fm1v7x\n", - "VmC2H96fAP8JeHwkqeZWmhmA/mi0Y+k+5Eal5ETNYWNqfggv9OTSXwU2LGuiuc2bNyIOo/uA+0A/\n", - "q/YOzZKf8VHAAf3m1Rsj4ldGlm64kswfBH4qIu4CbgZ+Z0TZFmPB77txOOR2pOY46fA9gxOZmcPO\n", - "/4iInwe+l5lfHdW1ZnY388DzPJ3ur8zf6dc4RqX0w2nntbaaH2rFrx0RrwDOBk5avjjzKsl7AfDO\n", - "/vckqL+WXJJ5X+ClwCuB/YC/i4gvZeamZU02u5LM7wZuysypiHg+cFVEvDgzH1jmbIu1oPfdXlca\n", - "mXnabMv6HUaHZOZ3I+I5wPeGDHsZcHpErAOeAjwjIj6WmW9dpshLkZmI2Bf4FPAXmfnpZYo6m+8A\n", - "RwxMH0H3F81cYw7v59VSkpl+5/cHgTWZOddmgOVWkvc44LKuLzgQWBsRj2Tm+tFE3EVJ5i3A3Zn5\n", - "MPBwRFwHvBioVRolmV8G/FeAzPyniLgdeAHduWfjZsHvOzdP7Wg9cGb/+Exglw/XzHx3Zh6Rmc8D\n", - "fgm4ZjkLo8C8mfu/Kj8MfDMzLxhhtm2eOFEzIp5Ed6Lmzh9U64G3whNXA7hvYLNbDfNmjojnAv8L\n", - "eEtmbq6QcdC8eTPzxzPzef3v7l8Bv1WxMKDs9+L/ACf3RyvuR7ez9psjzjmoJPNG4FUA/f6BFwDf\n", - "GmnKcgt/39XYoz+uN+AA4GrgNuDzwKp+/qHA5UPGn0L9o6fmzQycTLf/5Sbgq/1tzYhzrqU7amsz\n", - "8K5+3jnAOQNjLuyX3wy8dAx+H+bMTHcgxD0DP9O/H+e8O429GHjDuP+M++n/SHcE1S3A28c9M91a\n", - "3Gf63+NbgDdXzHop3RU1/oVure3s3X3feXKfJKmYm6ckScUsDUlSMUtDklTM0pAkFbM0JEnFLA1J\n", - "UjFLQ1pi/aXovxURz+qnn9VPP7d2Nml3WRrSEsvMLXQXBXxvP+u9wEWZ+e16qaSl4cl90jKIiJXA\n", - "l+nOvP5Vuu8zeaxuKmn37XUXLJRGITMfjYjfB64ATrMwtKdw85S0fNbSXffnRbWDSEvF0pCWQUS8\n", - "hO5KpycCvxsRw74PRZo4loa0xPpL0X+A7suutgD/DfjvdVNJS8PSkJberwMzmfmFfvp/AkdHxM9V\n", - "zCQtCY+ekiQVc01DklTM0pAkFbM0JEnFLA1JUjFLQ5JUzNKQJBWzNCRJxSwNSVKx/w8QfuxjT/fu\n", - "yQAAAABJRU5ErkJggg==\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#KNN TEST\n", - "model = SensorimotorModel.from_configuration(environment.conf, 'WNN', 'default')\n", - "\n", - "for m in random_motors:\n", - " s = environment.compute_sensori_effect(m)\n", - " # compute the sensori effect s of the motor command m through the environment\n", - " model.update(m, s)\n", - " \n", - "sTest_pred = model.forward_prediction(mTest)\n", - "print sTest_pred\n", - "distance[\"WNN\"] = abs(sTest_pred-sTest)\n", - "\n", - "%pylab inline\n", - "ax = axes()\n", - "environment.plot_arm(ax, mTest)\n", - "ax.plot(*sTest_pred, marker='o', color='red')\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -}