Introduction to notebooks and python fundamentals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to python and notebooks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notebooks are handy when exploring datasets and prototyping. \n",
    "\n",
    "You can comment along the way by changing the element type to markdown. Then you are free to make comments and write about the project. \n",
    "\n",
    "Seach for Markdown Cheatsheet or click [Here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) if you want nice examples of how to style your comments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing libraries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np # makes numerical work a lot faster\n",
    "import pandas as pd # A library a litte similar to excel\n",
    "import time as ti # Used to compare different algorithms\n",
    "import seaborn as sns # a visualizaion library\n",
    "from matplotlib import pyplot as plt # The \"original\" vizualisation library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# List, dicts and tuples\n",
    "List, tuples and dictionaries are commonly used classes when working with python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "Lists is a class where items are placed in a order. The list class contains some common methods that are frequently used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'a']\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,'a']\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First element:  1\n",
      "First element from end:  a\n"
     ]
    }
   ],
   "source": [
    "# Python starts to count from 0\n",
    "print('First element: ' , l[0])\n",
    "\n",
    "# Last element in a list can be reached as element -1\n",
    "print('First element from end: ' , l[-1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'a']\n",
      "[1, 3, 'a']\n"
     ]
    }
   ],
   "source": [
    "#The second element in a list can be replaced by\n",
    "print(l)\n",
    "l[1] = 3\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of l: <class 'list'>\n",
      "Methods available in the list class: ['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n"
     ]
    }
   ],
   "source": [
    "# List is an object with a lot of methods\n",
    "\n",
    "print('Type of l:',type(l))\n",
    "print('Methods available in the list class:',[ list_methods for list_methods in dir(l) if not list_methods.startswith('__')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 'a', [0], 1]\n"
     ]
    }
   ],
   "source": [
    "# We can add stuff to the end of the list with the append method \n",
    "l.append([0])\n",
    "l.append(1)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counted 1 in l: 1\n",
      "1\n",
      "3\n",
      "a\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print('Counted 1 in l: %d'%(l.count(1)))\n",
    "# We can loop over lists\n",
    "test=1\n",
    "for value in l:\n",
    "    print(value)\n",
    "print(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[1, 3, 'a', [0], 1]\n",
      "List is changed, integer is not: [7, 3, 'a', [0], 1] 3\n"
     ]
    }
   ],
   "source": [
    "# But lists might be tricky, sometimes the memory reference i passed to the function, sometimes a copy of the value\n",
    "def f(a_list, a):\n",
    "    a_list[0] = 7\n",
    "    a = 4\n",
    "    return 1\n",
    "\n",
    "a = 3\n",
    "print(a)\n",
    "print(l)\n",
    "\n",
    "f(l,a)\n",
    "print('List is changed, integer is not:',l,a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "Tuples are immutable lists that lacks some of the methods of lists. Therefore they become a little more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "Methods available in the tuple class: ['count', 'index']\n"
     ]
    }
   ],
   "source": [
    "t = ('a','b',3)\n",
    "print(type(t))\n",
    "print('Methods available in the tuple class:',[ tuple_methods for tuple_methods in dir(t) if not tuple_methods.startswith('__')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "First element in tuple: a\n",
      "0\n",
      "You are not allowed to change tuples\n"
     ]
    }
   ],
   "source": [
    "print(t.count('a'))\n",
    "print('First element in tuple:',t[0])\n",
    "print(t.index('a'))\n",
    "try:\n",
    "    t[0]=1\n",
    "except:\n",
    "    print('You are not allowed to change tuples')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dicts (Dictionarys)\n",
    "Dicts is a more structured way to store data then lists. Each item inside a dictionary is connected to a keyword. That means that the element can be directly reached by the keyword instead of looping over a list for a given keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# A dict is created by {} around the type instead of [] as in lists.\n",
    "# One can also use dict() to create it\n",
    "a={}\n",
    "b=dict()\n",
    "print(a==b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Erik': {'age': 19, 'sex': 'm'}, 'Sven': {'age': 25, 'sex': 'm'}, 'Anna': {'age': 25, 'sex': 'f'}, 'Sara': {'age': 25, 'sex': 'f'}}\n"
     ]
    }
   ],
   "source": [
    "# Declare a dictionary\n",
    "persons={'Erik':{'age':19,'sex':'m'},\n",
    "        'Sven':{'age':25,'sex':'m'},\n",
    "        'Anna' :{'age':25, 'sex':'f'},\n",
    "        'Sara':{'age':25, 'sex':'f'}}\n",
    "print(persons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'age': 19, 'sex': 'm'}\n"
     ]
    }
   ],
   "source": [
    "print(persons['Erik'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erik {'age': 19, 'sex': 'm'} 19\n",
      "Sven {'age': 25, 'sex': 'm'} 25\n",
      "Anna {'age': 25, 'sex': 'f'} 25\n",
      "Sara {'age': 25, 'sex': 'f'} 25\n",
      "Methods available in the dict class: ['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']\n"
     ]
    }
   ],
   "source": [
    "for key,item in persons.items():\n",
    "    print(key, item, item['age'])\n",
    "    \n",
    "print('Methods available in the dict class:',[ dict_methods for dict_methods in dir(persons) if not dict_methods.startswith('__')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Sven': {'age': 25, 'sex': 'm'}, 'Anna': {'age': 25, 'sex': 'f'}, 'Sara': {'age': 25, 'sex': 'f'}, 'Pete': {'age': 36, 'sex': 'm'}}\n"
     ]
    }
   ],
   "source": [
    "# Items can be added to the dict as\n",
    "persons['Pete']={'age':36,'sex':'m'}\n",
    "\n",
    "# Deletad as \n",
    "persons.pop('Erik')\n",
    "print(persons)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10 {}\n"
     ]
    }
   ],
   "source": [
    "def my_first_function(a):\n",
    "    a*=5\n",
    "    print(a)\n",
    "    return a\n",
    "    \n",
    "b=my_first_function(2)\n",
    "print(b,a)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyClass():\n",
    "    a=3\n",
    "    b=1\n",
    "    def add_b(self):\n",
    "        self.b+=1\n",
    "\n",
    "a=MyClass()\n",
    "print(a.a)\n",
    "print(a.b)\n",
    "a.add_b()\n",
    "a.b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is a library used to make python faster by offering a linear algebra package to python. In normal python operations on lists are not allowed and loops are neccesary.\n",
    "\n",
    "The example below shows a speedup of 50 when iterating over a list.\n",
    "\n",
    "But numpy is more then just speedup. It makes life a lot easier when processing data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "72.3 ms ± 1.85 ms per loop (mean ± std. dev. of 7 runs, 5 loops each)\n",
      "2.85 ms ± 594 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)\n"
     ]
    }
   ],
   "source": [
    "def pylistitteration(pl):\n",
    "    for i in range(len(pl)-1):\n",
    "        pl[i]*2\n",
    "    return pl\n",
    "\n",
    "def npitteration(nl):\n",
    "    nl*2\n",
    "    return nl\n",
    "\n",
    "py_list= list(range(1000000))\n",
    "%timeit -n 5 pylistitteration(py_list)\n",
    "np_list=np.arange(1000000)\n",
    "%timeit -n 50 npitteration(np_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linear algebra\n",
    "Solve the linear system $Ax=b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.50451765 0.49160627 0.12475029 0.11550197 0.39808908]\n",
      "x= [-0.23750015  0.73050286  0.34484516 -1.07718907  0.18362779]\n",
      "err1= [-1.11022302e-16  0.00000000e+00 -1.94289029e-16  0.00000000e+00\n",
      "  0.00000000e+00]\n",
      "err2= [-1.11022302e-16  0.00000000e+00 -1.94289029e-16  0.00000000e+00\n",
      "  0.00000000e+00]\n"
     ]
    }
   ],
   "source": [
    "A=np.random.random((5,5))\n",
    "b=np.random.random((5))\n",
    "print(b)\n",
    "x = np.linalg.solve(A,b)\n",
    "print('x=',x)\n",
    "# Check the error\n",
    "print('err1=',np.matmul(A,x)-b)\n",
    "print('err2=',A@x-b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Make a plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next steps we are going to visualize the function $y=3x^2+2x-0.5$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create the functions\n",
    "x1 = np.arange(-10,10.01,5)\n",
    "y1 = x1**3 + 3*x1**2 - 0.5\n",
    "x2 = np.arange(-10,10.1,0.1)\n",
    "y2 = x2**3 + 3*x2**2 - 0.5\n",
    "\n",
    "plt.plot(x1,y1)\n",
    "plt.plot(x2,y2)\n",
    "plt.title(r'$y=3x^2+2x-0.5$')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas is a greate tool for working with data in the exploratroy phase of an AI/ML project. It wraps up some commonly used python packages working upon as an excel dokument. \n",
    "\n",
    "The following is a basic example that contains some lines that describes the basics and gets you started with pands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>serie</th>\n",
       "      <th>val1</th>\n",
       "      <th>val2</th>\n",
       "      <th>Test</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>1.10</td>\n",
       "      <td>1.10</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>a</td>\n",
       "      <td>1.30</td>\n",
       "      <td>1.30</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>b</td>\n",
       "      <td>1.35</td>\n",
       "      <td>3.35</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>b</td>\n",
       "      <td>1.10</td>\n",
       "      <td>4.10</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>c</td>\n",
       "      <td>1.05</td>\n",
       "      <td>7.10</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>c</td>\n",
       "      <td>1.10</td>\n",
       "      <td>7.90</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>c</td>\n",
       "      <td>1.30</td>\n",
       "      <td>9.90</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  serie  val1  val2  Test\n",
       "0     a  1.10  1.10   NaN\n",
       "1     a  1.30  1.30   NaN\n",
       "2     b  1.35  3.35   NaN\n",
       "3     b  1.10  4.10   NaN\n",
       "4     c  1.05  7.10   NaN\n",
       "5     c  1.10  7.90   NaN\n",
       "6     c  1.30  9.90   NaN"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Initialize a pandas dataframe\n",
    "df = pd.DataFrame({'serie':['a','a','b','b'],\n",
    "                   'val1': np.array([1.1,1.3,1.35,1.1]), \n",
    "                   'val2': np.array([1.1,1.3,3.35,4.1])},\n",
    "                   columns=['serie','val1', 'val2'])\n",
    "\n",
    "# Append data to the dataframe\n",
    "df = df.append(pd.DataFrame({'serie':['c','c','c'],'val1':np.array([1.05,1.1,1.3]),'val2':np.array([7.1,7.9,9.9])}),ignore_index=True)\n",
    "\n",
    "# Insert a column to the dataframe and set default value to nan\n",
    "df.insert(df.columns.size,'Test',np.nan)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>serie</th>\n",
       "      <th>val1</th>\n",
       "      <th>val2</th>\n",
       "      <th>Test</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>1.10</td>\n",
       "      <td>1.10</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>a</td>\n",
       "      <td>1.30</td>\n",
       "      <td>1.30</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>b</td>\n",
       "      <td>1.35</td>\n",
       "      <td>3.35</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>b</td>\n",
       "      <td>1.10</td>\n",
       "      <td>4.10</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>c</td>\n",
       "      <td>1.05</td>\n",
       "      <td>7.10</td>\n",
       "      <td>1.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>c</td>\n",
       "      <td>1.10</td>\n",
       "      <td>7.90</td>\n",
       "      <td>0.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>c</td>\n",
       "      <td>1.30</td>\n",
       "      <td>9.90</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  serie  val1  val2  Test\n",
       "0     a  1.10  1.10   0.0\n",
       "1     a  1.30  1.30   0.0\n",
       "2     b  1.35  3.35   0.0\n",
       "3     b  1.10  4.10   0.0\n",
       "4     c  1.05  7.10   1.3\n",
       "5     c  1.10  7.90   0.9\n",
       "6     c  1.30  9.90   0.5"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set the values of Test columnt to 0\n",
    "df.Test=0\n",
    "df.loc[df.serie=='c','Test']=8*df.loc[df.serie=='c','val1']-df.loc[df.serie=='c','val2']\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  serie  val1  val2  Test\n",
      "0     a  1.10  1.10   0.0\n",
      "1     a  1.30  1.30   0.0\n",
      "2     b  1.35  3.35   0.0\n",
      "3     b  1.10  4.10   0.0\n",
      "4     c  1.05  7.10   1.3\n",
      "5     c  1.10  7.90   0.9\n",
      "6     c  1.30  9.90   0.5\n",
      "  serie  val1  val2  Test\n",
      "0     a     1  1.10   0.0\n",
      "1     a     1  1.30   0.0\n",
      "2     b     1  3.35   0.0\n",
      "3     b     1  4.10   0.0\n",
      "4     c     1  7.10   1.3\n",
      "5     c     1  7.90   0.9\n",
      "6     c     1  9.90   0.5\n"
     ]
    }
   ],
   "source": [
    "# Instead we must do a copy\n",
    "\n",
    "df_temp=df#.copy()\n",
    "df_temp\n",
    "df_temp.val1=1\n",
    "print(df)\n",
    "print(df_temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvwAAALICAYAAAADsyQ0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd0nNd55/HvnRn03gGCRCEIgiRYRZBqVJcluciy7CS21hvHthwlsbNOck7i3fXZ3WTjxHF2194Tx3YkF61LFMeSrF4pkSIpiUXsBAGwggQBAiB6B6be/QOkREkswMw7g/b7nINDcd557/PwnNfjZy6ee6+x1iIiIiIiIrOTa6oTEBERERGR6FHBLyIiIiIyi6ngFxERERGZxVTwi4iIiIjMYir4RURERERmMRX8IiIiIiKzmAp+EREREZFZTAW/iIiIiMgspoJfRERERGQW80x1Ak6655577CuvvDLVaYiIxIqJVSB9vorIHBOzz9dYmFUz/F1dXVOdgojIrKTPVxGRmWtWFfwiIiIiIvJ+KvhFRERERGYxFfwiIiIiIrOYCn4RERERkVlMBb+IiIiIyCymgl9EREREZBZTwS8iIiIiMoup4BcRERERmcVU8IuIiIiIzGIq+EVEREREZjEV/CIiIiIis1jUCn5jzKPGmA5jzOHLXL/PGHPIGHPAGLPHGLPhomvB868fMMY8F60cRURERERmO08Ux/458APgl5e5vgl4zlprjTErgceBJeevjVprV0cxN5nmrLUEbRCPK5qPqIiIg0IhGOmEgA888ZCcBy79Il1Epl7Uqilr7TZjTNkVrg9d9NcUwEYrF5kZTvef5uFDD9PQ3cDZobMArC9czy3zb+HjCz9OanzqFGcoInIZoRB01MO/PwB9ZyCzBD73a8hfpqJfRKbclH4KGWPuN8YcAV4EvnzRpcTzbT47jTGfmqL0JEZG/CN8b8/3uP+5+9l8ZjMZCRncMv8WNhRv4GjvUf5u19/x6ec+ze723VOdqojIpY10vlfsw/if//7A+OsiIlNsSvslrLVPA08bY24GvgXcef5SibW21RizENhsjKm11p681BjGmIeAhwBKSkpikbY4aMQ/wkOvPcTBzoNsKN7AZyo/Q0ZCxrvXrbWc6DvBo4cf5cFXH+TBFQ/y9TVfxxgzhVmLzA36fJ2EgO+9Yv+CvjPjr4uITLFp8XtGa+02oMIYk3v+763n/2wEtgBrrnDvj621Ndbamry8vFikKw4ZC4zxp5v/lNrOWr666qt8efmX31fsAxhjqMyq5G+u/xs2FG/gp7U/5bt7vou16gATiTZ9vk6CJ368jedimSXjr4uITLEpK/iNMYvM+WlaY8w1QDzQbYzJMsYknH89F7gRqJ+qPCU6QjbEX279S/a07+HBFQ9SU1hzxfcneBL4YvUXuaPkDn5R/wseOfRIjDIVEZmA5Lzxnv0LRf+FHv5kfVESkakXtZYeY8yvgVuBXGNMC/DXQByAtfZh4DPAF4wxfmAU+Oz5HXuWAo8YY0KMfyH5jrVWBf8s8/jRx9naspUHljzA9fOun9A9xhgeWPIAY4Exfnjgh+Qn5/Ppyk9HOVMRkQlwucYX6H7lde3SIyLTTjR36XngKtf/EfjHS7y+HVgRrbxk6p0dOsv39n6P6pxq7iy58+o3XMRlXHyx+ov0efv49q5vsypvFRWZFVHKVERkElwuSC2Y6ixERD5EUw8SU9Za/mb732Ct5YvVXwxr8a3b5ebBFQ+S4E7gG9u+gTfojUKmIiIiIrODCn6JqedOPsfOtp38btXvkpOUE/Y4mQmZfHn5lznWe4zv7fmegxmKiIiIzC4q+CVm/EE/PzzwQ8ozyrll/i0Rj7cybyV3lNzBvx35Nw52HnQgQxEREZHZRwW/xMyzJ5+lbbiN+yruw2WcefQ+XflpshKy+Pudf08wFHRkTBEREZHZRAW/xIQ/6OeRQ4+wMGMhK3KdW5Od5Enis1WfpaGngSePPenYuCIiIiKzhQp+iYmnTzxN+3A791Xc5/gpuesK17E0eyn/tP+f6B7tdnRsERERkZlOBb9EXSAU4Ce1P6Eio4LlucsdH98Yw+eXfp4R/wgPH3zY8fFFREREZjIV/BJ1W1u20j7czkfLP+r47P4F81LncVPxTTx5/ElaBluiEkNERERkJlLBL1H3+JHHyUrIYlXeqqjGubfiXgyGHx34UVTjiIiIiMwkKvglqpoHmtnetp2b59+M2+WOaqysxCzuKLmDFxpf4Hjv8ajGEhEREZkpVPBLVD1x7AlcxsXN82+OSbyPlX+MRE8i/7z/n2MST0RERGS6U8EvUeMNennqxFOsyVtDVmJWTGKmxqdyd+ndvNH8Bkd7jsYkpoiIiMh0poJfoub1ptfp9/Zz64JbYxr3jtI7SPIk8ZPan8Q0roiIiMh0pIJfouaFxhfIScxhac7SmMZNiUvh1gW3svH0Rk71n4ppbBEREZHpRgW/REXvWC87WnewvnA9LhP7x+yu0rvwuDz8rPZnMY8tIiIiMp2o4JeoeK3pNYI2yLVF105J/IyEDG6efzMvNL5A61DrlOQgIiIiMh2o4JeoeOXUKxSlFLEgbcGU5fDRso8C8Kv6X01ZDiIiIiJTTQW/OO7c8Dn2nNvD+sL1UTtZdyKyk7JZV7iOp44/xYBvYMryEBEREZlKKvjFcRubNmKxrC9aP9WpcHfZ3YwERnjy2JNTnYqIiIjIlFDBL457qfElStNLKUopmupUKE0vZWn2Uh5reAx/0D/V6YiIiIjEnAp+cVT7cDuHuw9TU1Az1am86+6yu+kY6eCV069MdSoiIiIiMaeCXxy1rWUbAKvzV09xJu9ZnruceSnz+EXdL7DWTnU6IiIiIjGlgl8ctaV5C/nJ+cxLmTfVqbzLZVzcWXonR3uPsq9j31SnIyIiIhJTKvjFMSP+EXa17WJV3qop3Z3nUq6fdz0pcSk81vDYhN7vD4Y41TXM3qYe9jb1sP9MLx2DY/oNgYiIiMw4nqlOQGaPHW078IV8rM6bPu08FyS4E7i5+GY2Nm2kbaiNotT3LygOhiw7Tnaz5WgHW4910tg5TPASxX1yvJs1CzK5pSqPO5cWsDAvNVb/BBEREZGwqOAXx2xp3kKyJ5nKrMqpTuWSbiu5jVdPv8pvjv6GP1/75wD0j/r593fO8KsdTbT0jRLnNiwpTOfeVfMozEgkMykOYyAQtHQOeWntG6WhfYBvv3SEb790hBsX5fClG8q5Y2n+tPuthoiIiAio4BeHBENBtjZvZUXuCjyu6flY5SblsiZ/DU8ce4KvLH+Ip/d18N3XjtE34mdZURp/traS1QsySYxzX3Ws7iEvbx7v4vWGc3zll3tYsyCTv/5kNasXZMbgXyIiIiIycdOzMpMZp7arll5vL6vyV011Kld0Z+md7O3Yy8ce/SfONK1kWVEaf3VX1aRbc3JSE/jUmmLuXTWPbcc7eXxPM5/64dt8/toS/tvHl5EUf/UvDSIiIiKxoIJfHPHm2TdxGRcrcldMdSqXZa3l1Jn5hLyF9Lq38Gd3fJpry3MiasVxuwy3VeVzXXkOT+5r4bFdZ9h1qod/fmANS4vSHcxeREREJDzapUccsaN1B+UZ5aTEpUx1KpcUCFoe2TTIz7YMkxG4ARJaycttd6zvPineze9fV8o3P7aU7iEv9//wbTbWtTsytoiIiEgkVPBLxPq9/dR111GdUz3VqVzSiDfEd57rY9PhMW5e6uYPataR4ErijbanHY+1ojiDb9+/gvnZyfzRr/by87dPOR5DREREZDJU8EvE3ml/h5ANTcuCf8Qb4ltP9VF7xs8nazzcvtxDgjuR6qx17O3aSr+v2/GYmcnx/LePL2VtaRZ/83w9P9h83PEYIiIiIhOlgl8itr11O0meJMozyqc6lfcZ9YX4+2f6aOwI8HvXe7im/L2FtKuzNxC0Ad5sfzEqsRM8bv7izsVsWJTL/9l4jEe2noxKHBEREZGrUcEvEdvRuoOqrKpptR2nP2D5zrP9nGgP8JnrPCwpfv+uOVkJeZSlLmFr+7MEQoGo5OByGf74lgquW5jNP7x8hF/tOB2VOCIiIiJXooJfItI80MzZobNU506fdh5rxxfo1p/1c986D9XzL71F5ursG+n3dXOw562o5eJ2Gb522yKuKcnkr5+rY8vRjqjFEhEREbkUFfwSke2t2wGmVf/+M7tH2Nowxq3L3Kwqvfx++OVpy0iPy2ZL2zNRzcfjcvGfbq9kQXYyX/u3fRxtH4xqPBEREZGLqeCXiOxo20FOYg4FyQVTnQoAexu9/Nv2YZYvcHHLsisffuUyLlZmX8/R/gO0jpyOal6JcW7+6q4q4t0uHvzFbvpH/VGNJyIiInKBCn4JWzAUZFfbLpblLHNsP/tIdA0G+cGrAxRmGu5b55lQTiuyrsNtPFGf5Yfx03n/4s7FtPWP8Y0nD2KtjXpMERERERX8ErajvUcZ8g+xJHvJVKdCIGj5vy/14wtafvc6D3HuiX0BSfakUpWxmh0drzIWGIlyllBZkMbn1i3g1bpz/HJHU9TjiYiIiES14DfGPGqM6TDGHL7M9fuMMYeMMQeMMXuMMRsuuvYHxpjj53/+IJp5Snj2tO8BoCq7aoozgSd3DXOsLcC9az3kpE3usV6dvQFvcJSdnRujlN37fWxFEWtKMvm7F+upbx2ISUwRERGZu6I9w/9z4J4rXN8ErLLWrga+DPwUwBiTDfw1cC2wHvhrY0xWdFOVydp9bjf5yflkJ2ZPaR4nz/l5evcIq0pdrCi5ct/+pRQmlVCQtIA3Wp+OSZuNy4xv15kS7+EvnziIPxiKekyR6S4UsnQOejnbO0LnoJdQSC1vIhMVsiG6RrtoHWqla7SLkNX/r8j7RbXgt9ZuA3qucH3IvldhpQAX/vtu4DVrbY+1thd4jSt/cZAYC9kQ+87toypramf3/QHLDzcOkJII96wO7xwAYwyrszfQNtrE0f4DDmd4aemJcXz5xnLq2wb4ly06lEvmtlDIcvTcIPf/6G1u/Mc3uP9Hb3P03KCKfpEJCNkQx3uP8/kXP8/dv72bz7/4eY73HlfRL+8z5T38xpj7jTFHgBcZn+UHKAaaL3pby/nXZJo43nucAd/AlLfz/PadYZq7g9y71kNSfPgLh6syVpPoTmFL29MOZndl68qzuaEih+9vOk5Dm1p7ZO7qHvbxh7/cQ0vvKAAtvaP84S/30D3sm+LMRKa/nrEevr7567QOtwLQOtzK1zd/nZ6xy863yhw05QW/tfZpa+0S4FPAt86/fKnK7ZJTPcaYh873/+/p7OyMVpryAbvbdwNM6Qx/c3eAZ/aMt/IsLpp8K8/F4lzxrMi6lgPdb9Hrjd3hWH9wQxnJCW6++VStZjNl2onV56svEHy32L+gpXcUXyAYtZgis4Uv6Hu32L+gdbgVX1BfmOU9U17wX3C+/afCGJPL+Iz+gosuzwdaL3Pfj621Ndbamry8vBhkKgB7zu0hLymPnKScKYlvreXRNwaJc8Ndq8Jr5fmgVdk3EMKyrf15R8abiPTEOP7D+lL2N/fx5L6WmMUVmYhYfb7Ge9zMz0p632vzs5KI90T2RV5kLoh3xzMvZd77XpuXMo94d/wUZSTT0ZQW/MaYReb8ZunGmGuAeKAbeBW4yxiTdX6x7l3nX5NpIGRD7G7fPaXtPNuPeTnc4ueOFR5SEpw5AyAjPoeFacvY2vYc/lDsZkZuqsylqiCNf3ipgf4RHcglc09OSjw/+ULNu0X//KwkfvKFGnJSVLCIXE12Yjbfv/377xb981Lm8f3bvz/lG2rI9OLM1OhlGGN+DdwK5BpjWhjfeScOwFr7MPAZ4AvGGD8wCnz2/CLeHmPMt4Dd54f6W2utmtGmiRN9J8b796eonWfUF+IX24YoyjKsXejsd9Y12Rv4bdMj7OnawvX5dzk69uW4jOFLN5bxzadr+e5rR/nb+5bHJK7IdOFyGaoK0nj6qzfiCwSJ97jJSYnH5Zr6A/1EpjuXcVGZVcljH38MX9BHvDue7MRsXGbaNHHINBDVgt9a+8BVrv8j8I+XufYo8Gg08pLI7D23F5i6/fef2ztC73CIB6+Nw+XwCb+lqYvJTshnc+tvY1bwA5TmpHDn0gL+dWcTX7i+lEX5aTGLLTIduFyGvLSEqU5DZEZyGRe5SblTnYZMY/r6J5O2/9x+shKyyEmMff9+73CQ5/aOUD3fxYIc5x9fY1yszr6JpqGjNA7WOz7+lXzmmvkkxrn5zstHYhpXREREZjcV/DJp+zr2UZlViXF4dn0intg5TDAEd6yI3i+nqjNriHclsrn1qajFuJT0pDjuXTWP1xs6eOeUOthERETEGSr4ZVLah9s5N3KORZmLYh67pSfApsNj1Cx0k50avS8b8e5EqrPWsbdrC32+7qjFuZSPLi8kOyWeb7/UEJNTf0VERGT2U8Evk7K/Yz8AlVmVMY/979uHiXPDzcuiv1XfmuybCNog29qei3qsiyV43Pzu2vkcaO7j1bpzMY0tIiIis5MKfpmUfef2keBOYH7q/JjGbeoMsOuEl+sWux3bhvNKshLyxrfobH8Wf8gb9XgXu6kyj6KMRL6/6bhm+UVERCRiKvhlUvZ37GdhxkLcrtgeiPPErmES4uC6ytjFvSbnZgb9fezu3ByzmABul+H+NcXUtw1oll9EREQipoJfJmzYP8zxvuMxb+c53ekfn92vdJMUH7uFwiUpleQmFPF665Mxn2m/oSKXooxE/mnTMUIhzfKLiIhI+FTwy4Qd7DxIyIZivmD3yV0jMZ/dBzDGcE3OzbQMn+RY/4GYxr4wy9/QNsjG+vaYxhYREZHZRQW/TNiBjgO4cFGRWRGzmC0947371y6K7ez+BUsyryHJncrrrU/EPPYNFbkUpifywzdOqpdfREREwqaCXyZsf8d+itOKSfIkxSzmc3tHiHPDtTGe3b8gzhXPquwbONSzg/aRMzGN7XYZPrGyiNqz/exojO32oCIiIjJ7qOCXCQmGghzqPBTTdp7uoSDbGsZYXeaKyc48l7M6ZwMu456SWf6bKvPISIrj4S0nYx5bREREZgcV/DIhJ/tPMhIYiWk7z0v7R7EWbqiK3qm6E5HiSWNZZg07zr3KoL8vprHjPS7uqS5k2/Eu6lsHYhpbREREZgcV/DIhtZ21AFRkxKbgH/aG2HholGXzXWSlTN3s/gVrc2/Fb31saXsm5rHvXFZAUpyLR7Zpll9EREQmTwW/TMihrkOkxqWSn5wfk3ib68YY81turJqa3v0PykkoYGFaNW+0Po0vGNuDuFITPNxWlc8LB9to6x+NaWwRERGZ+VTwy4Qc7DhIeUY5xkR/tj0Ysrx8YITSPENR1vR5RGtyb2Uo0M/2jldiHvvu6kJC1vKvO5tiHltERERmtulTTcm0NeQborG/MWbtPPtO+egcCHHtoukxu3/B/OQKipLKeLXl1wRtIKax89MTWVuaxWO7zjDmD8Y0toiIiMxsKvjlqg53H8ZiWZi5MCbxXtw/QkYyVM2bXo+nMYb1ebfT7W1nb9fWmMe/Z3khfSN+njvQGvPYIiIiMnNNr4pKpqVDnYcAWJgR/YK/qStAXYufdRVu3K6pX6z7QRVp1eQkFPBy82MxPwxrWVE6C7KT+H/bT+kgLhEREZkwFfxyVYc6D1GUUkRyXHLUY71yYPygrWsWTq92nguMcbEu93bOjjRyuPedGMc23FNdREPbILtP98Y0toiIiMxcKvjliqy1HOw8GJPZ/RFviDePjFG9wEVy/PSb3b9gScY1pMVl8XLLv8Z8pv3GRTmkxLt5bJcW74qIiMjEqOCXK2oZaqHP2xeTA7feOurFG4Caiuk5u3+B2+WhJvdWTgzUcqz/QExjJ3jcbKjM46XaNnqGfTGNLSIiIjOTCn65olj171tr2XhohMJMQ3HW9J3dv2BF1nWkeNJ4ofmXMY99x5J8/EHLk3ubYx5bREREZh4V/HJFh7sOE++Kpzi1OKpxjrcHaOoKUrPQHZO9/iMV54qnJvc2jvbv5+TA4ZjGXpCdzJLCNB7bdYZQSIt3RURE5MpU8MsVHe46TGl6KW5XdNtsXqsdJd4DK0pmziO5KvsGktypvHAm9rP8ty/Jp6l7hB2N3TGPLSIiIjPLzKmuJOb8IT/1PfWUZ5RHNc6wN8T2Y2OsKHGREDf9Z/cviHMlsDb3Fur63uHUYENMY19bnkNagod/e+dMTOOKiIjIzKOCXy7rZN9JfEEfZRllUY2z/ZgXXwDWlE/vxbqXsiZ7A0nuFJ4/8/OYxo33uLhhUS4b69rpG9HiXREREbk8FfxyWbVdtUD0F+xuPjxKfsbMWKz7QfHuRGpyb+Nw7y4aB+piGvvWqjz8QcuzOnlXRERErkAFv1xWXVcdqXGp5CXlRS1Gc3eAE+cCrC5zzYjFupeyOnsDyZ5Unjvz/2IatywnhfLcFB7fo916RERE5PJU8Mtl1XbVUppeGtVC/I36MVwGVpbMvHaeC+LdCazLvZ36vj0c7z8U09g3V+ZR1zpAXWt/TOOKiIjIzKGCXy5pNDDKyb6TUV2wGwhattaPsrjIRWrizJzdv2BV9o2keNJ4tunRmJ6+e+OiHDwuwxN7WmIWU0RERGYWFfxySUd6jhC0wagW/AeafAyMWlaXz7DH0IZI8A2SMdhMdn8j2f2NFAy2cFP6eo4NHKChf2/MUklLjGNtaRbPHDiLLxCKWVwRERGZOTxTnYBMT7Wd4wt2o1nwb2sYIzkBKgunb8HvCYxR0F1HXt8JsgaayBo4TepoFy4b/NB77wEOLpjHa3v/jN8by2E0aynDWUsYKLiWkawlYKLz77y5Mo9dp3rYeqyTjywriEoMERERmblU8MslHe4+THZiNpkJmVEZf9gbYk+jlzXlLtyu6dXOk+jtp/zsm5S07ya/5whuGyCEYSgph/7kAs5mLWYsPo2xuBSCrrjzd1niA2Pc6z/Ljz3tbA34uaf5VfJPPgGALzGH/qKb6Cr7OP3zbsa+e1/kVi7IID3JwzP7z6rgFxERkQ9RwS+XdLjrMGXpZVEbf+dxL/4grCydJot1bYj5HfuoatpIccd+XDZEX3IBx4uu5VzWIrrSSgi64686TJ5dTW7nb/lBZjylK/878d5eUnrqSO0+RFbL6+SdegZ/Qjad5ffRvuQLeNNKI07d43Jx/cJcXqs/R/+on4wk575MiIiIyMyngl8+pN/bT/NgM+sL10ctxraGMXLSpn7vfVfIz8Kzb1J94lmyhloYiU/n2LwbOJ23moGUyc+Wu4yLW9LW8tveTWwb3Met6TX0z7uZ/nk3Y0IBUrsOktH2JoVHf0XR0V/QXXIPrdUPMZyzMqJ/x4ZFubxa187LtW18bn1JRGOJiIjI7KKCXz6koacBIGoz/J0DQerP+rmt2j11e+9bS0n7O6xt+BUZw230JReys/J3aM5djnVF9luHpYnlzIvL4/HujdyQuor48+071uVhMH8tg/lr8Yz1kt38Ctktm8hteomu0o9xZs038KaFV6xX5KUwLyORp/efVcEvIiIi76OCXz6krmv8xNjS9MjbTS7lrSNjwNS182QONHFd7U8p7KmnPymPN5d+nrasKnDoy4cxhjvS1/Or7hd5tX8H92bd/KH3BBKz6Kh8gK7y+8hpeoncphfJbn6N9iVfpHnlnxGKS550zBsX5fLE3hZaekeYnzW5+0VERGT2mr7bo8iUqe+uJy8pj9T41KiM/9bRMRbkGLJSYju77wr5WXX0ce7d9ldkDjaxd+G9bFzzNdqylzhW7F9QljCPRQkLeKb3DYaCI5d9X8iTTGfF73D8hu/SX3gD8+p/wqoXPkp6+45Jx9ywKBeAFw61hZ23iIiIzD4q+OVD6rrroja739wd4Ex3kOUxPlk3c+AMn9j2DdYc+w0tOdW8suY/cbJoPdZEL4/b0tcxEhrl2d6tV31vIDGb1uo/4lTNf8eE/FS/9nnKd/13XIGxCcfLT09kUX4qzx1ojSRtERERmWWiVvAbYx41xnQYYw5f5vrnjTGHzv9sN8asuujaaWNMrTHmgDFmT7RylA/rG+vj7NDZqO2///bRMYyB6vmx+6656MxmPvHmfyZprIe3lvwHdlX9Lr64lKjHLYzLYXnSIl7uf4suf9+E7hnJWsrJ6/6BrpKPUXjsMZa//GkSBxonHPP6hTnUtw1womMo3LRFRERklolm1fVzxs8iupxTwC3W2pXAt4Aff+D6bdba1dbamijlJ5dQ310PRGfBrrWWt46OUZ5vSE2MfjuPO+jlxgM/YMPBH9KdVsxrq79Ka87SqMe92G1p68DCb3penfA91p3Auar/SNOab5Aw3MLKFz9JdtNLE7r3uoU5GOD5g5rlFxERkXFRK/ittduAnitc326t7T3/153A/GjlIhNX1x29BbuNHQHO9YdYviD67TwJ3n7u3vE3VDa/Qd38W9lW/UXG4tOiHveDMjyprE9dzluD+znlPTupe4dyV3Pyun/Am1JM1bY/pbj2h2DtFe/JTolnaVE6zx9sxV7lvSIiIjI3TJce/geBly/6uwU2GmP2GmMemqKc5qT67noKkgtInuQuMRPx1tEx3C5YWhzdxy5jsIVPvPVfye5v5O2qz1FXegfWTN2jfmPqapJciTzW9dKki/BAYg6na/4bfYU3UnLgu1Ts+AYm6LviPTdU5NDYNUxd60AkaYuIiMgsMeUFvzHmNsYL/v980cs3WmuvAT4KfM0Y8+F9Dd+7/yFjzB5jzJ7Ozs4oZzv7He4+HJXZ/ZC1bD/mpaLARVJ89Np58nqP8bG3v0mcf5gty7/M2dzqqMWaqERXPDelruHw6EkOjByd9P3WFcfZ5V+lY+GnyT/5W5ZsfhCX//I7/6wvz8btMjx/SG09Ehl9voqIzA5TWvAbY1YCPwXus9Z2X3jdWtt6/s8O4Gngske+Wmt/bK2tsdbW5OXlRTvlWa17tJv24XbKMsocH/t4W4CeoRDVC6L3yBV013HXjv+Jz53AppUP0ZO2IGqxJmttylJy3Bn8a9dLBG1w8gMYQ2fF73C2+o/IaN/B0s1fwu0bvORb0xLjWD4vnRfD1vLJAAAgAElEQVQPtamtRyKiz1cRkdlhygp+Y0wJ8BTw+9baYxe9nmKMSbvw38BdwCV3+hFnRXPB7o7j4+08VfOi88jN6zjAR3b+HaPxabyx/EGGE7OiEidcbuPmtvR1nPV3sGVgb9jj9M27hZaVf0pa5z6Wvv77eLyX3v3n2vIcWnpHOXxWbT0iIiJzXTS35fw1sAOoMsa0GGMeNMb8sTHmj8+/5X8AOcCPPrD9ZgHwljHmIPAO8KK19pVo5SnvuVDwl6SVODpuyFp2HB9v50mMc76dp6jzEHfs/g5Didm8sfzLjCWkOx7DCUsSy1gQX8DjPRsZC3nDHmeg4DqaV/45Kb31LH39C5ec6a8py8Jl4MVaHcIlIiIy10Vzl54HrLVF1to4a+18a+3PrLUPW2sfPn/9K9barPNbb767/aa1ttFau+r8T7W19u+jlaO8X313PYXJhY4v2I1mO09u7zFu3/0dBhOz2bL8S3ijdDqwE4wxfCT9OvqDQzw3gcO4rmQwfy3NK/+ClN4GlrzxlQ8d0JWWGMeK4gxerNVuPSIiInPdlC/alemjvqeeknRnZ/cheu08mQNn+Miuv8Mbl8K26j/AF4WdhZxWHJ/PssSFvND3Jj2B/ojGGspbQ8vyPyGtYw+Lt30NE/K/7/q15Tk094xqtx4REZE5TgW/ANA71ju+YNfh/v2Qtew87mVRobPtPMmjXdy1828JGjdbp2iP/XDdnr6OoA3yePdrEY81UHgDbUu/TNbZN6jY8V/et0+/2npEREQEVPDLeRf6953ekvNEe4DuoRDL5jv3qHkCo9y569t4AqNsW/aFabdA92qyPOmsS6lm6+AemryRF+O98++go+J3yGt8evxwrvPSEuNYXpyh3XpERETmOBX8AkBDTwPgfMG/64QXtwsWFznzqJlQkFv2fo/MoWZ2VP0eAykFjowbaxvS1pBoEnis6yVHxussv5++og2UHPweOaeee/f19eXZnOkZ4Uj7pbfwFBERkdlPBb8A4zP8+cn5ji7Ytday68QY5fnGscO21tX/ggUd+9hf/nHOZVU6MuZUSHIlsCFtDYdGj3Nw5NjVb7gaY2hd9ocMZy1l0fZvkNq5D4C1JVkY4JXD7ZHHEBERkRlJBb8AUNdV5/js/pmuIOf6Qywpdjsy3sLmLSw79SLHiq7nZNFlz2KbMWpSlpHlTuPful4mZEMRj2ddcTSv/HP8CVlUbf0T4kY7yUyOp6owTQW/iIjIHKaCX+j39tM63EppmtPtPGMYYIkDu/Nk95/ihkMP05FRzsHyuyNPbhrwGDe3ptXQ5GvjrcEDjowZjE+jedVf4PH2s3jbn2JCftaVZXP03CCnu4YdiSEiIiIziwp+eW/Bbobz/fsluYbUxMjaeeJ9Q9y253/j8ySxY/HvYY0zvzGYDqqTKiiKy+U3Pa/i+8C2muHyppXQuuwrpHfspmTf/2JdWTYAr9Zpll9ERGQuUsEv7xX8Ds7wt/UFONMdZElxhI+Ytdx04Pskj3axfcnnpvXBWuEwxnBH+nq6A/282r/dsXH7izbQveBu5jX8jKqeTSzMTVFbj4iIyBylgl9o6GkgLymPVAeL6XdOeAFYGmH//tJTL7Hg3F4Olt1DT9oCJ1KbdsoTiqlIWMAzvVsYDo46Nu65xZ9nJGMRFTv+Kx+Z52N/cx/t/WNXv1FERERmFRX8Ql1XneMn7L5zwktRliEzJfx2nuz+U9TU/5Kz2Us4UXStg9lNP7el1zAcGuX5vm2OjWldHlqWfw1jA/xh57dxE+S1es3yi4iIzDUq+Oe4Ad8ALUMtjp6w2zsc5Hh7IKLFup7AGDfv+7/44pLYvehTYJw7pXc6KorLpTqpgpf63qI3MODYuP7kAtqWfInc3v18M+V5Ntafc2xsERERmRlU8M9xR3uOAs4euLW30YeFiPr319X/goyhVnZVfgZfXIpjuU1nt6atJWCDPN272dFx+4s20Fe0gS8Fn8TbuJ3+UWcWB4uIiMjMoIJ/jruwYNfJlp53TnrJSjHkp4c3Kz+vYz9VTRs5Ou8GOjIrHMtrusv2ZLAmuYpN/e9wzt/t6NhtS77ESEIu/8v9L7xZd9rRsUVERGR6U8E/x9V315OTmEN6fLoj4436QtSe8VE1z4UJow0n3j/MjQd/RH9yPodL73Akp5nkprQ1GAy/7dnk6LghTxLnqh+izHWO1Lf+3tGxRUREZHpTwT/H1XfXOzq7f6DJRyAUfjvPurr/R5K3j3cW3U/IFedYXjNFmjuFmpRlvDm4n1Zfp6Njj+UsY1PS3dza9zS+E1scHVtERESmLxX8c9iIf4SmgSZH99/ffdJLcjwsyJn87P78c3uobH6DI8U30Zs237GcZpobUlcRZzw82fO642O3VnyWU6ECgk9/FbyDjo8vIiIi048K/jnsSM8RLNaxGf5A0LL3lI/KIhdu1+QK/jj/CNcfeoS+5ELqF9zqSD4zVYo7iXUp1ewYOsgZr7PbaC7PT+SboT8mYbgVNqu1R0REZC5QwT+HNfQ0AFCWUebIeEda/Yx4bVjtPGuO/prksV72LPokIZfHkXxmsutTVxBv4nmy5zVHx413g8mt4inuxO56GFr2Ojq+iIiITD8q+Oew+u56MhMyyUzIdGS8PY1ePC5YWDC5xyq39xhLT73MiaJrZ+1pupOV5EpkfUo17wzX0ezwLP+1hfA/xz5LIDEbnv86BLVNp4iIyGymgn8Oq++upyTNmXYeay17Gr2U57tI8Ey8nceEAtxw8F8YjU+jtmTu7cpzJdemLifexPGUw/vyr8uHIZJ5Oe/LcO4w7PyRo+OLiIjI9KKCf44aDYzS2N/oWP9+S0+Qc/0hFk/ydN3qxufJHjzDvoWfIOBJdCSX2SLJlci6lGp2Dh3irK/DsXEzEmBpNjzSsxZKroc3vg29px0bX0RERKYXFfxz1PHe44RsyLETdvc2egFYXDTxRyp5tJtVx57gbPYSWnOWOpLHbHNdygriTBxP9Tg7y39tAdR1hzhX/YfjL7z6TUfHFxERkelDBf8c1dA9vmDXqYJ/d6OXoixDRvLE23nW1f8cY4McKP+YIznMRsnuRNYmL2X70EHafF2Ojbu+YPzPjZ2ZsPJzcORFOO78NqAiIiIy9VTwz1H1PfWkxqWSk5gT8Vj9IyGOtwWomsTsfmFXLeWt2zlSfBPDiVkR5zCbXZe6Ajcunu/b5tiYC1JhXgq83uSHZfdB+nx4+S8h4HUshoiIiEwPKvjnqPruekrTSzFm8gdkfdD+014sTLh/34QCXFv7U4YSszhafFPE8We7VHcyq5IXs21gLz2BAUfGNGZ8ln/72SDDIQ+sfwh6TsGOHzgyvoiIiEwfKvjnIF/Qx4m+E44t2N3T6CMtCYoyJ/blYenpV8gaauFA2UcJuuMcyWG2uz51JUFCvNT3lmNjri8AfwjeaglA8TXjC3i3/W/oP+tYDBEREZl6KvjnoON9xwmEApSll0U8lj9oOdjkZXGRa0K/LUjwDbLq6OO0ZVbSmr0k4vhzRZYnneqkhbzev5Oh4IgjY1ZnQ7IHNp8JjL+w7isQCsKmv3VkfBEREZkeVPDPQU4u2G0462fMP/HdeVYf/Q1xwVEOlt893lciE3ZD6mrGrI9X+3c4Mp7HBWvzYXNTgJC1kFoASz8Jh/4dzu5zJIaIiIhMPRX8c1BDdwPJnmTykvIiHmtvoxePG8rzr/4oZQy2UNX0Ko0FNQwkF0Qce64piMtmUcICXu3fji/kzOm46wugc9RyuCs0/sKK34PETHjlv4K1jsQQERGRqaWCfw6q7xk/YTfSBbsXTtddmO8ifgKn69bU/4KAK566ktsjijuXXZe6goHgMG8NHXBkvLV54x8Cr58+/wUiPhnW/Edo3gn1zzoSQ0RERKaWCv45xh/yc6znGKUZkbfznO0N0jEQonIC7TxFnQdZ0LGPhgW34I1LiTj2XFUWP4+CuBxe7H0T68AMfEYCLMmGTRf6+AEWfQSyyuC1/6FtOkVERGYBFfxzTGNfI76Qj9K0yAv+CZ+ua0PU1P+SoYQsjhddF3HcucwYw3UpKzjr7+DAyDFHxlyXD3VdIdqHz7f1uNyw9svQ1wR7HnUkhoiIiEwdFfxzTEOPcwt29zb6KMy8+um65WffJmfgNIdL7yDk8kQcd66rTlpImiuFFx06iOvCqbtvXDzLX3wNFK2Grf8LxvodiSMiIiJTQwX/HFPfXU+iO5GClMgWzQ6NhTja5qey8MqPkCvo55ojj9GbUsSZ3BURxZRxbuNmXcoyDo+e5Iy3PeLxStMgP+mi7TkvWPtFGO2Bt78fcQwRERGZOmEV/MaYjzidiMRGQ3cDC9IW4DKRfdc72OQjZLlq/35V06ukjXZyqPQuiDCmvGdNyhI8uHmlf3vEYxkDNfnwdkuAscBF6wJyFkHZzeOn7w5G/sVCREREpka4FdjPHM1CYiIYCnKk54gz7TynvCTHw/ycy7fzxPlHWHXsCc5lLORcZkXEMeU9ya5EViQv4q3B/Y4cxLW+AEYCsKst+P4L13wBQgHY8g8RxxAREZGpcdmC3xjz3GV+ngdyYpijOOT0wGnGgmMRF/zBkGX/aR+LCl24rrC1Z3Xj8yT6h87P7uuQLaetS6nGZ/28MbA74rFW5kKC+wN9/ABphbD4o7DvV9B9MuI4IiIiEntXmuG/CXgE+O4lfoain5o4rb67HoCyjLKIxjnRHmBozF6xnSfBN8iyxudoyVlGb1pxRPHk0griciiNL2Jj/w5CNhTRWAluWJkDm5r8H97uc+XvgcsDW74TUQwRERGZGlcq+HcCI9barR/42QIcvdrAxphHjTEdxpjDl7n+eWPMofM/240xqy66do8x5qgx5oQx5r9M9h8ll1bfXU+8K57C5MKIxtl32ovLwKIrLNhdfuJp4gJeDuuQrahal1JNZ6CPvcMNkY9VAM2DlpN9H/jykJQFS++F2ifgXH3EcURERCS2LluxWWs/aq194zLXbp7A2D8H7rnC9VPALdbalcC3gB8DGGPcwA+BjwLLgAeMMcsmEE+uor67ngXpC3C73BGNs7fRy4JcQ1L8pdt0ksZ6WXrqZZryVjKQHNluQHJlVYmlpLtT2Ni/I+Kx1uWP//mh3XoAln8G4pLhjb+POI6IiIjEVtS2TbHWbgN6rnB9u7W29/xfdwLzz//3euCEtbbRWusD/h24L1p5zhUhG+JIzxHK0ssiGqd7KEhTV/CK23GuPP5bXDZA3QLN7keby7hYk7yE2tETtPu6IhorPxnK0i/Rxw+QkAbVn4IjL8DZfRHFERERkdi60qLdQWPMwCV+Bo0xAw7n8SDw8vn/LgaaL7rWcv41icDpgdOMBEYiXrC7/5QPuPx2nCkjnSxu2sip/GsYTsqOKJZMzJrkKlwYXh94J+KxavJhd1uQAa/98MWl90FCOmz+u4jjiIiISOxcqaUnzVqbfomfNGttulMJGGNuY7zg/88XXrpUOle4/yFjzB5jzJ7Ozk6n0pp1GrqdOWF332kvGcmG/PRLt/OsPPEUAPULbo0ojkxcmjuFxYllbBnYgy/kj2isdfkQsPD22UvM8scnw/JPw8lN0Bz5lwuZ/vT5KiIyO0y4pccYk2+MKbnw40RwY8xK4KfAfdba7vMvtwALLnrbfKD1cmNYa39sra2x1tbk5eU5kdasVN9dT5wrjnkp88Iewx+wHGryUVloMJfYZjNlpINFZzZxqmAtowkZkaQrk7Q2ZSlDoRHeGb7kGvkJW5oFqXGX6eMHqPoEJGZox545Qp+vIiKzw1ULfmPMJ40xxxlfZLsVOM177TdhO/+l4Sng9621xy66tBuoNMaUG2Pigc8Bz0Uab66r765nQVpkC3YbWv14A5dv51l54unx982fyJpucVJ5/Dxy3Bls7N8Z0ThuF1yTB1vOBAh9cHtOgLhEqNYsv4iIyEwykRn+bwHXAcesteXAHcDbV7vJGPNrYAdQZYxpMcY8aIz5Y2PMH59/y/9g/ACvHxljDhhj9gBYawPAnwKvAg3A49bausn+w+Q9IRuioach8naeU148LijP//Bjo9n9qWWMYU3KEo6NNdHsPRfRWDX50Dlqqeu6zN7+VR/XLL+IiMgMMpGC33++3cZljHGd36pz9dVustY+YK0tstbGWWvnW2t/Zq192Fr78PnrX7HWZllrV5//qbno3pestYuttRXWWu0DGKHmwWaG/cMOFPw+yvIN8Z4Pt/OsPD7eu6/Z/amzMqkSN66IT95dmz++kOaSu/WAZvlFRERmmIkU/H3GmFTgTeAxY8w/AZepBGQ6eveE3Qi25GzrC9DWF6Sy8MMtQSkjHVQ2b9bs/hRLcSexOLGUbYP78Nvw/yeamQCVmbD5zBUWAGuWX0REZMaYSMG/DcgE/gx4BTgJ3BvNpMRZ7y7YTQ1/we6VtuNcfvJZLHBk/k1hjy/OWJO8hKHQCHuGIjsRd10BHOwI0T16mbaeuERYdv/4LP/ZvRHFEhERkeiaSMFvGO+n3wKkAr+5aEcdmQHquupYkLYAj8sT9hj7TnvJTTNkp76/nSdprIfFZzZxOn8NIwmZkaYqEVqYUEymO41NEe7Jvy5/fC/cbc1X+E3Bko+NH8i17X9HFEtERESi66oFv7X2f1prq4GvAfOArcaY16OemTgiZEPUdddF1L8/5rfUtfhZdInTdZeffBZjg5rdnyaMMaxKXszh0RN0+C970PVVVWRAVsIVtucEiEuGpZ+Eoy9De23YsURERCS6JrwPP9ABtAPdQH500hGnNQ00MRIYoSyjLOwxDjf7CARh8QfaeRK8/VSd3siZ3JUMJ+pU3eliVfLi8UW3A3vCHsNlxhfvbmsOEAhd9tw7WHLveOH/5nfDjiUiIiLRNZF9+P/EGLMF2ATkAn9orV0Z7cTEGU4s2N13yke8B0py39/OU934PO6QXzvzTDMZ7lQWJsxn2+BeQvYyPfgTUJMP/T440BG8/JsSUmHJJ6DuGeg8GnYsERERiZ6JzPCXAn9ura221v61tTay1YASU3XddRGdsGutZd9pLwvzXXjc7xX88b4hlpx+mebcagaTdQLndLMyeTHdgX7qRhvDHmNN3vhM/2W357xg2X3gSYA3vxd2LBEREYmeifTw/xdr7YFYJCPOq+uqoyStJOwTdpu7g3QPhj60O8+S068QHxijYf4tTqQpDluSWEqiiWfrYPg76KTGwbLsq/Txw/j2nIvvhtonoLcp7HgiIiISHZPp4ZcZJhgKcqTnSET9+/tPe4H3b8fpCYyxrPF5WrOq6E8pjDRNiQKP8VCdVME7Q7WMhMbCHmddPjR0h2gbukpr0LL7wRjY/v2wY4mIiEh0qOCfxd5dsBth/35BhiE96b12nsozr5PoH1Lv/jS3KnkxPhtg5+ChsMeoOb88f+uVtucESMmFitth369g8FzY8URERMR5KvhnsbruOoCwt+QcHgtxpNX/vtl9V8jP8pPP0pFeRnd6iSN5SnTMi8sj15PFlgjaekrTIC9pAm09AMs/AyE/7PxR2PFERETEeSr4Z7G67joS3AkUpRSFdf+hMz5C9v3bcS5s2UbKWA9HNLs/7RljWJVUybGxJtp9XWGOMd7W81ZLAG/wCttzAqQXQ+mNsPunMNoXVjwRERFxngr+WezCCbvhLtjdd9pHUjwUZ4+38xgbZMWJp+lNKaI9c5GTqUqULE+uwABvDu4Pe4yafBgJwJ62K2zPecGK3wXfEOz+SdjxRERExFkq+GepQChAQ09D2P37IWvZd8pLRYELt2u84C9pe4eM4TYa5t80PvUr0166O5WyhGLeHNyPtVeZob+MVbkQ55pgW0/2QiiugZ3/Av7RsOKJiIiIs1Twz1In+07iDXopzygP6/5THQEGRu17/fvWsvzE0wwmZnM2p9rBTCXaViQtoiPQw7Gx8LbMTPTAypwJ7Md/wfLPwEg3HHgsrHgiIiLiLBX8s9ThrsMAYRf8+075MMCiwvFHpLD7MHn9JzlavAFr9NjMJEsSy4gznojbehr7QzT1T+Dk3oLlkLcEtv8zBCf4JUFERESiRpXbLHW4+zDJnmTyk/PDun/fKS/F2YaUhPHWnRUnnmE0LpXT+audTFNiIMEVT1ViKTuGDuG34RXgNQXjf75xte05Ybzda/lnoPc0NDwbVjwRERFxjgr+Wepw12FK00txhTEb3z8S4uS5AIvOt/Nk9zdS3HmA4/OuI+SKczpViYEVSZUMh0bZP3wkrPvnpcD8FNjc5J/YDQuuhYwF8Nb/hTDXDoiIiIgzVPDPQt6gl+O9x8Nu5zlw2ovlve04l594Br87gZOF6x3MUmJpYUIxqa6kiNp61ubDzrYgI/4JFPDGBdX3Q3stnNwcdkwRERGJnAr+WehIzxGCNhh2wb/3lI/URCjMNKSOnKOsdTuNBTX4PUkOZyqx4jIuliVVsH/4CMPB8HbPWVcAviBsPzvBtqCFt0FyDrz9T2HFExEREWeo4J+F3l2wmz75gj8QtBxs8lFZ6MJlDMsaX8AaF8fmXe90mhJjK5IWESDIruHDYd2/PAeSPBPcnhPAHQdLPwmntkLrgbBiioiISORU8M9CdV11ZMRnkJWYNel7j7b5GfGNb8eZ4Buk8swmzuStZDQhIwqZSiwVxeWS7U7nrYHw2nriXLA6d7zgn/Ce/ovvgbhk2P79sGKKiIhI5FTwz0K1XbWUZZRhwjgca98pH24XLCxwUXX6FeKCXo7OuzEKWUqsGWNYnrSIhrFGegL9YY2xLh/ahy1HeiawPSdAfMp40V/3zPiuPSIiIhJzKvhnmSHfEE0DTWG188D4dpwluYYUl4+lp16iNWsxAykFDmcpU2V5cgUW2D54MKz7392ec6JtPTDe1mMM7PhRWDFFREQkMir4Z5n67noslrKMsknf2zkQpKUnSGWRi0XNW0jyDXC0eIPzScqUyfFkMi8uj7cGw+upz0mEioxJ9PEDpORC+a2w/5cw0hNWXBEREQmfCv5ZprarFoCFGQsnfe++U14Aqgot1Sefozu1mM70MifTk2mgOqmC075WWn2dYd2/Lh/2nQvSNzaJ/fWr7wf/KOz+aVgxRUREJHwq+GeZ2q5a8pPzSY1PnfS9ext95KQa1gztIX2kfXx2P4x1ADK9VSctxABvhznLv64AQha2TuTU3QuySmF+DbzzCPjHwoorIiIi4VHBP8sc6jwU1uz+mN9yuMVHZZGL5Y3PMZSYxdmcpVHIUKZamjuFkvgitg8dnPhuOxdZnAmZ8bDpzARP3b1g2adhuAsO/nrSMUVERCR8KvhnkfbhdjpHO8M6cOtwsw9/EG5PPU5+7zGOzbsBa9xRyFKmg+VJFbT5uzjta530vS4zfuru1jMBAqFJfGEoXAE5lbD9nyE0wV1+REREJGIq+GeRSPr39zZ6iffAXT3P4fUkcyr/GqfTk2lkSVI5Llxh79azvgD6feO9/BNmDFR/CnpOwrGXw4orIiIik6eCfxap7azF4/JQkl4yqfustew95ePm3HZKz+3mZOE6gu74KGUp00GyK5GFCcVsHzpIyE5+tv2aPHCbSe7WA1C6AVIL4G0dxCUiIhIrKvhnkUNdhyhJKyHOFTep+053BugdDvFF18uEjIvjRddFKUOZTqqTKugO9HN87Myk702Og+U5sKlpkgW/yz2+L3/zTmjePem4IiIiMnkq+GeJQChAXVddWP37+075yGaA6/q20JS/Gm8YO/zIzFOVWIoHN28PhdfWsy4fjveGaB6Y5G8IKu+C+FTY8c9hxRUREZHJUcE/S5zsO8lYcCys/v09jV6+mvYanpCfo/NujEJ2Mh0luOKpTCxh59AhgnYSvfjnrT9/6u6k23rikmDxPdDwPPQ0TjquiIiITI4K/lki3AW7fcMhWs6N8NngRs5mL2EwOS8a6ck0tSxpIQPBYepHT0363uJUmJ8KrzdNcntOgKX3gnHBzn+Z/L0iIiIyKSr4Z4narlpS41LJT86f1H37Tnv5tPtN0kKDmt2fgyoTSog3cewYOhTW/esLYGdrkCHfJPfzT86B8lth/69gpCes2CIiIjIxKvhniYMdBynLKMNM8mTcvSdH+aO4F+lOLaYrvTRK2cl0FefysDixhF1DtQTCaevJB38I3myZZFsPjG/R6R+FPT+b/L0iIiIyYSr4Z4FB3yCN/Y0sylw0qft8AUtu805Kaedo8Y3j+6TLnLMsqYLh0Ci1Iycmf282pMWFsVsPQFYZFNfArkfAPzb5+0VERGRCVPDPArWdtVgsFZkVk7qvrsXHF82L9MZlczZnWZSyk+muImE+iSaeHWHs1uN2jZ+6u/lMgOBkTt29oPp+GO6EQ7+Z/L0iIiIyIVEr+I0xjxpjOowxhy9zfYkxZocxxmuM+csPXDttjKk1xhwwxuyJVo6zxYHOAxjMpBfs9tTVst51lBPF12ONO0rZyXTnMW6qEsvYPVSHLzT5BbjrC6BnzHKgY/ItQRSuhOwK2PEDCE3+ADARERG5umjO8P8cuOcK13uArwP/5zLXb7PWrrbW1jid2GxzsOMg89Pmk+RJmvA91lpqWp5ikGSaC9dEMTuZCZYlLWTUejk0cmzS916TBy4TZluPMeOz/F3H4PjGyd8vIiIiVxW1gt9au43xov5y1zustbuBMPb0kwtCNsTBroNUZEyunafz1BluD+3mnYwbCbgTopSdzBTlCcUkuxLZHsZuPWnx46fuvhZOwQ/8f/buPDzO6r77//vMjEYzGlm7bEs23vcFjDHYZjUmYCBAQhaaxNmahaZp4zSh7a9LmvRpm+Tpk9AkbhsamgUSzBbIYsJqsB3AC3jDNt4N3mTJlmRJ1q7Zzu+PkYRlS5ZGumeR9HldF5esmfvc85Vtxh8dfc85TLgWAsWwcWX/xouIiMhFpWsPvwVeMsZsM8bcm+pi0tk7de/QFJ+tApAAACAASURBVGqKu38/f/tThHBTOeGKBFUmg4nbuJjum8C2pn20RYNxj180Knbq7rGz/WjLcXlg5l1wbAOc3Bb/eBEREbmodA3811hr5wO3AX9hjLm+pwuNMfcaY7YaY7ZWVVUlr8I0sbMqttAynsDvaTnL/OpXeNm9CHd2IFGlySAz2z+JNhtkR/OBuMd2nLq7pj+HcAFMWwbeAGz8r/6Nl4QY7u+vIiJDRVoGfmttefvHSuC3wFUXufZBa+0Ca+2C4uLhd0rszqqdZGdkMyprVJ/HZO/4HT6CbCvq8fsoGYbGe0sIuPxsaoi/rackABNGwMv9bevJyIJpt8Le30Ht0f7dQxw33N9fRUSGirQL/MaYgDFmRMevgVuAbnf6EXir8i0m503u84FbJtxG6d7fszYyj4LSnARXJ4OJy7iY6ZvIjuZ9tEbb4h6/cDRsqYhQ19qP7TkBZtwJxgWbH+jfeBEREelWIrflfAzYBEw3xpQZYz5vjPmSMeZL7c+PNsaUAV8HvtF+TQ4wCnjdGLMTeBN41lr7QqLqHMzqWus4Wn80rnaeooNrCITrecKzjOIsrZeWrmb5JxG0YbY37Y977MJRELGw7ng//14FimDiDbD9YWjucb2/iIiIxMmTqBtbaz/ey/OngLHdPFUPXJaQooaYXdWx1os+79ATjTDyrV+zKzqJllHjMEahSroa5x3NCFeATY07uXpEfP8bTs2DAl9st567p3n7V8Dsu+GdV2Drz+D6v+nfPURERKSLtGvpkb7bfno7buNmUl7fDtzKO7aJrPqT/CR8B7OKmxNcnQxGxhhm+ieyo/kAzdHWuMa6DFw1EtYfD9Ma7mdbT/4EGHMFvPETCMX3+iIiItI9Bf5BbHvldsbnjCezj/vol7z1JJXuIl53z2dCnsKUdG+2fxJhG2Fr4964xy4eDc1h2FTez8W7ALM/BE1VsOvx/t9DREREOinwD1JtkTbern6bqflT+3R9dsXbZJ/ey0+CtzOtuBVX39b4yjA0JmMkue5sNjXujHvsZUWQ5YEXjwwg8I++FAqnwMb/hGg/9vUXERGRLhT4B6k91XsIRUNMzetb4B+980laPQEeDS1hdnFTgquTwcwYwyzfJHY1H6IxEl/rV4YbFoyENUfDRKL9bOsxJtbLf+YwHHy+f/cQERGRTgr8g9T2yu0ATMmf0uu1vtrj5B/dyBr/UiJuL1PzWxJdngxys/yTiBBlS9OeuMcuHg1nWi3bT0f6X8D4ayF7FLz+w/7fQ0RERAAF/kFrR+UOSgIl5Hh730t/9M5fE3Vl8B8NtzK9sJkMdz9nXmXYKMkoIt+d069DuBaMBI+Bl44OoK3H5YZZH4SyN+H45v7fR0RERBT4B6OojbLj9I4+tfNkNFVTeHANh0Yu4khrvtp5pE+MMczyT+LtlsPURxrjGpuVAZcVwwtHQlg7gG8up9wMmTmwQbP8IiIiA6HAPwgdrjtMQ6ihTwt2R+3+LcZGeMK9DJexzCzUdpzSN7P9k4hieaMx/oOuF4+GEw2W/TUDWHSb4YMZd8CB56Ey/oPAREREJEaBfxDacXoHQK+B393WSPGeZ6gpuYxnT41jSkEL/gzteiJ9M9JTQJEnn40N8e/Ws2g0GGKz/AMy4/3gzozt2CMiIiL9osA/CG2v3E5eZh7F/uKLXle891k8oWZ2jHofp5s8zC2OrzVDhrdYW89E9rceoSZcH9fY/EyYXQjPvzuAPn4AXy5MvRl2PQFnTw7sXiIiIsOUAv8gY61l6+mtTMmbgjE9b6ZvwkFG7XqKs8XTeP7sNAyW2TpdV+I02zcZC2xujH/x7tWj4WBtlHfrBrBbD8S26LRR2Pzjgd1HRERkmFLgH2TKGsqobK5kZsHMi15XeHAN3pZaKqYu5Y2yTCbmtZLtHWDwkmGnKCOPURmF/dqt5+qS2MfnB3IIF8S255x4PWz9OTTXDOxeIiIiw5AC/yCz5fQWAKYXTO/5omiEkreeoCnvEvZ7Z1BWn8HckWrnkf6Z7ZvEobbjVIVq4xpX7IdpeQ708QPM+TCEmmHLTwd+LxERkWFGgX+Q2XJqCzneHEoCJT1ek3/kdXz15bHZ/ZN+AOZoO07pp1n+SQBs6kdbzzUlsLsqSlnDABeL50+AsVfB5gcgqL/LIiIi8VDgH0SstWw5tYVp+dN67t+3lpIdj9GSPZLakrlsLvMxLreVXJ/aeaR/8j05jMkoZkPDW3GPvab9+1JHZvnnfgRaamDHIwO/l4iIyDCiwD+IlDWWcbr5NDMKZvR4TU7ZNgLVhzk1ZQmnmjI4Upuh3XlkwGb7J3MsWMHJYGVc40oCMCkXnnvXgcA/chaMnA0bfgTh4MDvJyIiMkwo8A8iW09tBS7ev1+yfRVBXx5nxi5g0wkfAJeOVAuEDMws/yQM9GtP/utKYPvpKCcH2tYDsVn++pOw+9cDv5eIiMgwocA/iHT075cGSrt9PrtiNzkVuzk15Qas28PG4z7G5bSS7x/gLiky7I1wBxjvLWVD41tYa+Mae237X9fnnWjrGbMACibBa/dDVG1qIiIifaHAP0hYa3nz1JsX7d8v2f4oIW82VeMXUdHg5mhdBpeOUjuPOGO2fzKnQmc40hbfAVilAZicC8++40DgNwbm3gM178C+1QO/n4iIyDCgwD9InGw8yenm0z2282RVHyLvxBZOT7qOqCeTze3tPHPVziMOmemfgBsXGxrjb+u5tgR2VDqwWw/AuMWQOzY2yx/nTxtERESGIwX+QeKNijcAelywW7L9McIeH5WTrgVg44nY7jz5PrXziDP8Lh+TfGPZ2LCTqI0vuF/X0dbjxOJdlxvmfARO7YZDawZ+PxERkSFOgX+Q2FyxmfzM/G779321x8l/9zUqJ15DJMNPeUc7jw7bEofN8U2mNlLPvpYjcY0rCcCUXHjGibYegElLIDASXv2eZvlFRER6ocA/CERtlM0Vm5lZOLPb/v2S7Y8SdWdwevINAGw47sNgFfjFcdN84/GaDDY0xr8n/3WlsKsqyrGzDrT1uDyx03fL3oQjrw78fiIiIkOYAv8gcLD2IHVtdcwsmHnBc5l1ZRQeXkvVhKsJZ2ZjLbx+zM/EvFbydNiWOMzrymC6bzybG3cTsvG1i13f/sMpx2b5p94MWYXwx3935n4iIiJDlAL/ILC5fDMAswpnXfBcyY7HsMZNxZQlAByt81De4OEy7c4jCTLXP4XmaCs7mvbHNW5kFswqgN8fdijwu72xWf5jG+DoBmfuKSIiMgQp8A8Cmyo2URooJd+X3+Vxb30FRQfXUDlhEWFfDhBr53EZtfNI4kzMHEPA5ef1hvjbem4YA4dqo+w/49BPn6YuA38+vPr/nLmfiIjIEKTAn+aCkSDbTm9jZuGF7TwlOx7HGhenpiwFIGpjgX9aQTMBrwN90iLdcBkXs/2T2N68j+ZIa1xjrysBl4HVTs3yezJh9t3w7no4/oYz9xQRERliFPjT3M6qnbRF2i5o5/E2nKbowItUjV9IyJ8LwIHqDKqbPcxTO48k2Bz/FMI2wuam3XGNy82Ey4tigT/eE3t7NO128OWql19ERKQHCvxpblP5JlzGxfT8rgdulWx/FIBTU5d2Pvb6MT8ZriizinXYliRWaUYxhZ5cXqvfHvfY68dAWaNl+2mH2noyfLFZ/ndegRNvOnNPERGRIUSBP81tLN/IxNyJZGVkdT7mrT9F0f4XqBq/kKA/1tcfisQO25pV3ITPo33JJbGMMcz1T2Ff6xEqQzVxjb26BDLd8JtDDrX1AEy/A3x5sO47zt1TRERkiFDgT2NnWs6w58we5hbN7fJ46fZVYAwVU2/qfGxHRSaNQRfzR6udR5Jjrn8qABviXLyb5YFFo+EPh0O0RRz65jTDB3M+BO+ug2ObnLmniIjIEKHAn8Y2lm8E6BL4M+vLY737ExYT8ud1Pv7qMT/Z3jDTCpqTXqcMT3meEYz3lvDHhu1x9+MvHQNng7DueHx7+V/U9NtjO/as1yy/iIjIuRT409hrJ18jx5vD+JzxnY+VbFsV23f/nNn9xqBhW3km80Y14tafqCTRpVlTORWq5nDbibjGXV4M+Znw24MOtvV4fDD7w7GTd4++7tx9RUREBjnFwzQViUbYWL6R2UWzcZnYH1NmXVn7vvuLCbXvuw+w6biPcNQwf3RDqsqVYWqmbyIe3LzWEN/iXbcrtif/K8fD1LU6uOZk+m2x03fX/hs4tQuQiIjIIKfAn6b2nNnD2bazXdp5xmx9mKgrg4ppN3W59o/H/IwKBBkzIpjsMmWYy3R5me6fwIaGnYRsfO05S8dCOArPvOPkLH8mzL0Hjm+K7dojIiIiCvzp6vWTr+PCxZzCOQD4q9+h8PA6Tk++nnDmiM7ryhvcHKj2Mn90A8akqloZzi7zT6Up2sK2pr1xjZuUAxNGwFMHHP5GdeotkD0KXvkXzfKLiIigwJ+2Xjv5GhNzJ5LtzQZg7Ju/IJyRxakpS7pct/6IH5exXFGidh5JjYmZY8hxB1hfvzWuccbA+y6BnVVRDtY4tCc/gDsD5n0CKnbCvtXO3VdERGSQUuBPQzWtNeypfm87zuxTe8g7vpmKqTcSyfB3XheJxgL/9MJmcjIdDEwicXAZF5f6p7Kz+RA14bNxjV06FtwGfn3AwbYegIlLIHccvPKvENX/GyIiMrwp8Keh18pew2KZWzwXrGXMGz8jmJlD5cRru1y385SX2lY3CzS7Lyl2WdY0LJZX4zx5NzcTrhoFTx8MEXJqT34Alxsu/yScOQQ7H3fuviIiIoNQwgK/MebnxphKY8zbPTw/wxizyRjTZoz56/Oeu9UYc8AYc9gY83eJqjFdrTuxjvzMfCbkTCD3+JvkVOyiYtr7iHoyu1y39kgWgYwIM4uaUlSpSEyBJ5dx3tGsb9ga9578t4yDmlbLWif35AcYtxiKpsK6b0Oo1dl7i4iIDCKJnOF/CLj1Is/XACuA75/7oDHGDfw3cBswC/i4MWZWgmpMO63hVjac3MC8kfMwNsrYzf9La6CYqgmLu1xX32bYejKT+aMb8OjnNJIG5mVN51ToDAdaj8U17opiKMiEJ51evGsMzP9TqD8Jb/7E2XvLgESjlqqGNk7WNlPV0EY0qsXVF4hGofE01J2IfYxGU13RkBa1UapbqilvLKe6pZqo1e+3DC0Ji4rW2leJhfqenq+01m4Bzm/evQo4bK1911obBB4HPpCoOtPNGxVv0Bpp5fKRl1N0cA1ZtUcpm3U71uXuct0fj/iJWMOVpWrnkfQw0zcRr8lgbf2bcY1zu+CmS2D98Qinmhz+R7bkUhi7AF67H5p7fDuSJIpGLQdON3D3jzdwzb+v4+4fb+DA6QaF/nNFo1C5F376PvjhnNjHyr0K/QkStVEO1R5i+bPLWfb0MpY/u5xDtYcU+mVISce54THAucd2lrU/NiysO7EOv8fPjJwJjNnyEI3546ktubTLNdbCmneyGJ/bwuhs7b0v6cHrymCOfzKbG3fRFGmJa+yycRCx8MR+hxfvAsz/LLTWx0K/pNyZpiBf/OVWympjf0fKalv44i+3cqZJ72Wdmqvg8Y9D3fHY53XHY583V6W2riGqprWGFWtXUN5UDkB5Uzkr1q6gplWTBDJ0pGPg7243+R6nfowx9xpjthpjtlZVDe43w6iNsv7EeuYUzWHsnj/gbarmxKw7OH+D/T2VXioaPSwaU5+iSkW6Nz9rBkEb5vWGt+IaVxKAy4vh8X1BIk7P9OZPgMk3wZsPQm187UbDXSLeX4PhSGfY71BW20IwrN2UOoWD74X9DnXHY4+L44KRYGfY71DeVE4wot9vGTrSMfCXAZec8/lYoLyHa7HWPmitXWCtXVBcXJzw4hJpV9UuzrSe4Yq8aZRsf5S6UbNoLJp8wXVr3vGT5Ylw6Ugt1pX0UuItpiSjiFfq34h78e5t46CiybL+hMOLdwEuXx77+Mq/OH/vISwR769ej5ux+f4uj43N9+P1uHsYMQx5vJA3rutjeeNij4vjvG4vpYHSLo+VBkrxuvX7LUNHOgb+LcBUY8xEY4wX+BgwLE7PWXdiHW7j5rajb+EKt3Ji9p0XXHO21cUbZT7mlzSQ4VbPq6Sfy7Omczx4infayuIat3B0bPHuqr0JmFULFMPsu+Htp+BEfGsMxFmFAS//++kFnaF/bL6f//30AgoDCledsorhY4+9F/rzxsU+zxrck1rpqsBXwMqlKztDf2mglJVLV1LgK0hxZSLO8STqxsaYx4AlQJExpgz4FpABYK39H2PMaGArkANEjTF/Bcyy1tYbY/4SeBFwAz+31u5JVJ3pwlrLmmNrmDViHBN3vUjlxGtoHTHqguvWtS/WXah2HklTc/xTWFP/Bq/Uv8EU3yW9D2jnccVO3n3qnQgnG6KMGeHwfMScj8DhNfDC38Pn14ArHec7hj6XyzB91Ah+++VrCIYjeD1uCgNeXK7uujmHKZcLRs6CL7wca+PxeGNhX39nE8JlXEzNn8qq968iGAnidXsp8BXgMvr9lqEjYYHfWvvxXp4/Raxdp7vnngOeS0Rd6Wp/zX5ONJzgE+FsIh4fJ6ffcsE1kSi8eNjPpLwWRgUSsLhRxAGZLi+z/ZPZ0LCTTxa+n4Db3/ugdreNh6cOwyN7g/x/C33OFpbhh8s/DRt+CG8/DZd+1Nn7S5+5XIbiEZm9XzicuVyQfeGkjySGy7go8helugyRhNG3r2nixaMv4sJwx8n9nJx+CxFv4IJrtpVnUt3s4ZpLzqagQpG+W5A1i6AN8ceGbXGNG5kVa+15bF+Q1nACWtYmL4XCKbDmmxBsdv7+IiIiaUiBPw1Ya3nx6AtcFYySmVVE1cRrur3u+UNZ5PnCzNLJupLmSrxFjM0YyUtnN8e9l/WdE6GuDVYfTsBPsYwLFnwBGsphw4+cv7+IiEgaUuBPA3tr9lLWeJLbz9ZwfO7dFxyyBXDirIe3KzNZNOYsbv2pySBwRWAWp0LVvN3yTlzjLi2E8SPg4beDce/00yej58CE6+H1H0DNEefvLyIikmYUHdPAi/ufwmMt80dMoH7k9G6vef5QFh6XZWGpFuvK4DDLP4mAy89LdZviGmcM3DEB9pyJsu10gvZmX/C52Au9+PeJub+IiEgaUeBPMWstL76zmoWtbdTNubvbaxraDK8e9TFvVAMBr476lsHBY9zMy5rOtuZ9VIVq4xq7dCxkZ8DPdyfo4JtAEVz2MTjwPBx8KTGvISIikiYU+FNs11u/oNwGuWrEJIJZ3e/5u+adLNoiLq4bp8W6MrhckTUTA7x0dnNc43weuHU8vHAkzPH6BH2TO/MDkHsJPP+3EGpNzGuIiIikAQX+VAq18syWH5FpLVOm3N79JRF47mAW0wqbKcnWMd8yuOR6spnhm8gr9W/QGm2La+ydE2JvUAmb5XdnwFV/BrVHYlt1ioiIDFEK/CkUfO17PO8JcaW/FL83u9trXjvm52ybmxvG1SW5OhFnLMyeQ3O0lfX18W3RWeSHG8bAE/uD1LUm6FTp0nkw8QZ47X6oOpiY1xAREUkxBf5UqTrAq9t+Qr3bzZUlC7u9JGph9f4sSrPbmJLfkuQCRZwx1juKsRkjef7shri36PzQZGgJw6q9Cfzp1pVfALcX/vBXkIhdgURERFJMgT8VolF45qusHhEgz53FrOxx3V62vTyTkw0ZXDeuDqNT52UQW5g9l9OhM2xv2hfXuAk5cEUx/OLtBB3EBeDPhyv+FI5tgB2PJOY1REREUkiBPxV2/Irasjd41Z/JwvwZuM2FfwzWwtN7AxT4Qswb1ZiCIkWcM8M3gTz3CP5Q91rcYz86BapbLE/sT8BBXB2m3gyjZsNL34DGysS9joiISAoo8Cfb2TJ46R95vmQKESzX5M/q9rLdp70crvGyZHydDtqSQc9lXFwVmM3+1qMcbDkW19g5hTC7AB54q41gJEGz/MYFi/8SQs3w7H1q7RERkSFFUTKZrIVnvoqNhHg6J5fx/pGM9Rd1e+nTewPkZIZZoIO2ZIi4PGsGWS4fv6tdH9c4Y+BPpsKpJstvDiZwlj/3ErjsE7BvNez5beJeR0REJMkU+JPprVVw+GV2z/0AB1tPc0PBnG4v21+Vwd6qTJaMq8OjPyEZIryuDK4MzGZ78z6Ot52Ka+z8YpiaBz9+q41wNIGz77PvhqLp8Nx90FiVuNcRERFJIsXJZDl7El74exg1hyczo/hcXhbmzej20if3ZJOdEeGqMZrdl6HlysAsvCaD3/dzlv94veW3hxI4y+9ywzVfhdaGWOgXEREZAhT4kyEahd//BUSCnL3qXp6v2saivOn43d4LLn37tJfdpzO5cUItXrf6iGVo8bt8zM+awcbGnZwOnYlr7KJRMDUXfrQ1gb38AHnjYN4nYO/vYdeTiXsdERGRJFHgT4Y3HoB318GCz/NMy1GC0TA3FM694DJr4bHd2eRmhlmk2X0ZohZlz8WNi9/WrItrnDHwyRlQ1pjgHXsAZn8IRs6CZ78OtfEtMhYREUk3CvyJduptePmf4ZKF2KnLeLL8dSZljWa8f+QFl+6o8HLwjJebJtSSodl9GaJGuAPMD8zk1YZtnApWxzX2iuLYjj3/ub0tcfvyQ6y159qvQzQCv/2z2EcREZFBSoE/kUKt8PQXwBuAq1fwxtmDHGk5xZKCC2f3oxYe2z2CAn9IO/PIkHdN9mW4jZvf1K6Na5wx8KnpUNls+eWeBJ6+CzBiNCz8EhzfBK//ILGvJSIikkAK/In00j9C1T64+qvgy+WhspfJ9WSxMG/6BZe+dtTH0boMbplUo515ZMjLdmdxRdZMXmvYwclgfAddzS2CBSPhv7a3UdsaTVCF7SbdCBOug/XfhRNvJva1REREEkTRMlHefhq2/BRm3Q1jF3CoqZwNtXtZWngZGS5Pl0vbwvDo7hGMzWnVqboybFydfRke4+bpmlfiHvu5WdAYhB9tS/AsvzGw+C8gqwie/Aw0xbfQWEREJB0o8CdC9WFY/RUonglXfAaAX5a9gtd4uLHw0gsu/8OBADUtbu6ccgaXSXaxIqkRcPu5KjCHjY07ebe1LK6x40fALePgkT1B3q1LcH+9NxuW/B00VbX38yf4pwoiIiIOU+B3WqgFfv1pMG644W/B5aE6eJZnK9/kmoJZZHv8XS6vbXHxu/0B5hQ3MjG/NUVFi6TG1dmXkeXy8Uj1c1gb3yLcT86ADDd89422BFV3jsIpcOUX4fAa2KB+fhERGVwU+J1kLTzzVTi9B679GgSKAXj05HrCNsItRfMvGPKrnSMIRQy3T1GrgAw/PpeX67IvZ2/ru7zVfCCusfmZcM8UWHM0zPrj4QRVeI7pt8GE62Htv8Hh+NuQREREUkWB30mb/ht2PQHzlsPYKwE4G2piVfl6rsidyqjMvC6X76n08toxP0vG11KUlYTAIpKGrgjMpMCdw6rq54jY+Npz7p4MY7PhmxtaErtNJ8T6+a/+Suxgrqc+BzXvJvb1REREHKLA75R31sKaf4LxV8Olf9L58MNlL9MSaeOuUQu7XB6Owk+3jaDAF+LGCXXJrlYkbbiNm6U5V1EWquSV+i1xjc1wwZfmwPF6y092JngBL0CGH278BtgoPPZxaGtI/GuKiIgMkAK/E868A7/+U8gdB9d8DUzst7U21Miqk+tZkDuVsb6iLkOePRCgrD6Du6ZV49UhWzLMzfBNYIK3lCfOvEh9pCmusZcXw3Wl8OMdbRw9m4QFtSNGx9bnVB+C39yrQ7lERCTtKfAPVFM1PPJhwMLSb8RmANs9XPYyLdE27hq1qMuQ8gY3T7ydzeziRmYVNye5YJH0Y4xhWe5iWqJtPH7mhbjHf2EWuA383R9biMa5+LdfSubBlV+AA8/BS99I/OuJiIgMgAL/QIRa4NGPQf1JWPpPsZm/dmeCDTx6cj1X5k5jjK+w8/GohQfezMXjinL39OpUVC2SlkZmFHBVYDZr67dwqPV4XGOL/PCF2bC5IsKj+0IJqvA8M++EmXfB5h/D5geS85oiIiL9oMDfX9FI7Mf5J7fCdX8NxTO6PP3fx54hGA3zwdGLuzz+4uEs9ld7uXPaGXIy1Qogcq7rR8xnhCvAzyp/RzjOBby3XALziuA7m1opa0jSXvkLPg/jFsMLfw/7nknOa4qIiMRJgb8/rIVnvw77Vsf+wR9/dZenDzad5OmKDdxYdCmjM/M7Hz9Z72bVzmymFzZzxWgt9hM5X6bLy7LcxRwNlvNM7atxjTUGVlwW+yna36xvIRJNQmuPyw3X3QdF0+Cpz8O7f0z8a4qIiMRJgT9e1sZ6drc9BHPvgdkfPO9py/ffeRq/O5O7Rr7Xux+KwA835eFxWT4ysxKjE3VFujXTP5GZvok8XfMyZcHTcY0dlQV/Ngc2lUd4cFcSdu0B8Pjgpm/FWvoe+xiciG+nIRERkURT4I/Xq9+DTf8FM+6Ayz91wdOv1bzNprr93DVqIdkeX+fjj+0ewdG6DD4ys5JctfKIXNStuVfjdWXwP6efImrja8+5+RK4tgTuf7ONnZVJ+n/NlwM3/yv4cmHVh+HU7uS8roiISB8o8Mfjj9+Ddd+GyUvhqns5f5q+OdLGdw4/SUlmPjcWXtr5+I4KL88cCLBozFlma1cekV5lu7O4JWcxh9tO8Pva9XGNNQb+8lLI98FXXmnmbFuStr3NKoBbvg1uLzx8F1TsSs7rioiI9EKBvy+shbXfhnX/BpNuhKu/2rnX/rl+fOwPnGw7w6fH3ITHuAE43ejmh5vyKM1u446pZ5JducigNcc/mdn+yfy6Zg0HW47FNXaEF/52PpxssHx9XXNytuoEyB4ZC/0uNzx8J5zcnpzXFRERuQgF/t5YCy9/C179fzDlZrjmr2L/mJ9nT8MxflW2liUFc5mePRaAtjB8f0Me1lo+NfeUDtgSiYMx+V9yTwAAIABJREFUhttzryXHnc3K04/RFGmJa/ysgthWna8ci/DfO5LUzw+QUwrLvgueTPjlXXDizeS9toiISDcU+C8mEoLVfwkbfgTTboOrv9Jt2A9Fw3zz4CPkeLL4SMm1QPt++1tyOVbn4WOzKynMCie7epFBz+fycnf+jdSEz/Jg5W+wcc7U3zkBloyB/9jSxpqjSdqfH2ILeJd9FzJHxGb6D8R/mJiIiIhTFPh7EmyCxz8BOx6BSz8Gi77cbRsPwH8eXc3BppN8asxSstyZADy+O5sNx/3cOrmGmUXq2xfpr7HeUdyYcyVvNO1mdV18214aA1+5FKbmwYpXWthdlcQF89kj4dZ/h9xLYu8l23+ZvNcWERE5hwJ/d+or4KE74PDLsOgv4PJPXrBAt8PGmr38ouxllhTM5fLcyQCsfdfPb/dlc1VpPUvG1yWzcpEhaXHgUmb7J/P4mRfY0XQgrrE+D3zzKsjJgM8935y8Q7kA/Pmw7DtQchms/gqs/TeIJvH1RURESGDgN8b83BhTaYx5u4fnjTFmpTHmsDFmlzFm/jnPRYwxb7X/tzpRNXarbCs8eANU7oUl/wjTb+vx0upgPf9w4GHG+Ar5WOkNQKxv/8m3s5lW0Mzd06u0376IA4wx3Jl7PaMyCll5+jFOBivjGp+fCf+8EFrClp/vTmI/P0CGH276Jky9Jbat7xPLoU0H74mISPIkcob/IeDWizx/GzC1/b97gQfOea7FWjuv/b+7ElfieXasgl/cDhi4/fswbmGPl4aiYf5m30+pD7fwZ+Nuw+vyAJDpgW/eWM3yuadx6+cnIo7JcHn4aP7NuDF8p/xn1ITPxjV+3Aj4zyUu/mFRZoIqvAiXBxZ/Jbad78EX4afvgzPvJL8OkSEiaqNUt1RT3lhOdUt13Od1iAw3CYuk1tpXgZqLXPIB4Jc2ZjOQZ4wpSVQ9FxVsgt99GX7/ZRg5A97/H5A/ocfLrbV8+/ATbD17mM+OfR9jfUVdni8ORPB79OYj4rQ8zwg+VngrjZFmvlP+cxoj8a2PmZBj8LhS9GM3Y2DmXXDz/4H6cvjJ9bD7qdTUIjKIRW2UQ7WHWP7scpY9vYzlzy7nUO0hhX6Ri0jlHPQY4MQ5n5e1PwbgM8ZsNcZsNsZ8MKFVnN4DP7kB3noULvs4vO9fYqdmXsQjJ9fx9KkN3DHyKhbnz0hoeSLSVUlGER8tuJmKYBX/Xv4QzdHWVJcUn5J5cMcPIe8SePrzsHoFBLWwX6SvalprWLF2BeVN5QCUN5WzYu0KalovNscoMrylMvB3N83WsefeOGvtAuATwA+NMZN7vIkx97Z/c7C1qqoqvgqsjc3sN5+BW/4N5i3vdtvNcz1XuYXvvfs083Mm88FRi+N7PRFxxMTMMdydv5R32sr4zsmfxb1Hf8plj4xt2zn3o7D9Ydjxq1RX1K0Bvb+KJEgwEuwM+x3Km8oJRpK8PkdkEEll4C8DLjnn87FAOYC1tuPju8B64PKebmKtfdBau8Bau6C4uDi+CoyBD/8M7vxRbBeNXrxS/Rb/sP9hpgXG8MVxt+LSilyRlJnpn8hH8m/iSNtJvl3+U+ojTakuKT4uD8z/DHzop3DlF1JdTbcG9P4qkiBet5fSQGmXx0oDpXjd3hRVJJL+Uhn4VwOfbt+tZxFw1lpbYYzJN8ZkAhhjioBrgL0Jq6JoSmzrvF6sP7OLv973MyZkjWLFhLvIdGUkrCQR6Zvp/gl8pOB9HG87xTfLfsypYHWqS4pfyWW9/mRRRN5T4Ctg5dKVnaG/NFDKyqUrKfAVpLgykfTlSdSNjTGPAUuAImNMGfAtIAPAWvs/wHPA7cBhoBn40/ahM4GfGGOixL4h+b/W2sQF/j747amN/J+DjzLOX8zXJn4Av2YRRNLGNN94Pll4O0/WruGfyn7MX5d8hun+8akuS0QSxGVcTM2fyqr3ryIYCeJ1eynwFeDq4XBMEUlg4LfWfryX5y3wF908vhGYm6i64mGt5cHjL/Bfx55hdvY4vjz+DoV9kTR0SeZoPlt0F4+feYF/OfkTlhfdzm2512DUdicyJLmMiyJ/Ue8Xigigk3Z71BBu4Wt7/5f/OvYMi/Jm8NUJmtkXSWeFnlw+V/xBJvsu4ZfVf+AHp1bFvW2niIjIUJSwGf7B7GDTSb6250HKWqu5p+Q6lhXN10yhyCDgd2VyT/7NbG7azdr6LRw4fpQvjvwQCwKzUl2aiIhIymiGvxsvVG6lIdLC307+CLcWX6GwLzKIGGNYnH0pnyv+AD5XJt+v+CU/PPUo1aG6VJcmIiKSEprh78aXJ9zBlbnT8GjnDJFBqySjiM8XfYANjTvZ0PAW25r28qHCJXw9//1kuTNTXZ6IiEjSaIa/Gx7jJjcjkOoyRGSA3MbN9SPm8+WR9zDNN54nq1/mSPOpVJclIiKSVJrhF5EhL9eTzYfyl/LJkbcwe4S27BQRkeFFM/wiMmyM8upgHhERGX4U+EVEREREhjAFfhERERGRIUyBX0REREQkDRhjvmSM+bTT99WiXRERERGRFDPGeKy1/5OIeyvwA2RduJBvBEE8kWC/bheORGmLtg60KhFxWI6/qNv/31PKqy2ARUSGEmNMAHgSGAu4gX8FDgP/AWQD1cBnrbUVxpj1wEbgGmC1MWYE0Git/b4xZjLw30Ax0Ax80Vq7v181WWsH9lWlEWNMFXAsAbcuIvaHM1zp69fXr68/PVVba29Nxgsl8P01EdL5z6wvBnv9MPi/hsFePwz+ryHV9ff7/dUY82HgVmvtF9s/zwWeBz5gra0yxvwJsMxa+7n2wL/XWvvl9mv/mfcC/yvAl6y1h4wxC4HvWmuX9qemITXDb60tTsR9jTFbrbULEnHvwUBfv75+ff3D9+vvkKj310QY7H9mg71+GPxfw2CvHwb/1zDI698NfN8Y8+/AH4BaYA6wxhgDsVn/inOuf+L8GxhjsoGrgV+3jwHo9zHxQyrwi4iIiIikkrX2oDHmCuB24LvAGmCPtXZxD0OaunnMBdRZa+c5UZN26RERERERcYgxphRottY+AnwfWAgUG2MWtz+fYYyZfbF7WGvrgSPGmI+2jzHGmMv6W5Nm+PvmwVQXkGL6+oc3ff0y2Az2P7PBXj8M/q9hsNcPg/9rGMz1zwW+Z4yJAiHgz4EwsLK9n98D/BDY08t9lgMPGGO+AWQAjwM7+1PQkFq0KyIiIiIiXamlR0RERERkCFPgFxEREREZwhT4RURERESGMAV+EREREZEhTIFfRERERGQIU+AXERERERnCFPhFRERERIYwBX4RERERkSFMgV9ERERExGFt4cjik7UtG4+daTpysrZlY1s4stiJ+xpjfmeM2WaM2WOMubdPY3TSroiIiIiIc9rCkcUHTzeu/vNHthWV1bYwNt/PA5+8onraqOy7Mj3uTQO5tzGmwFpbY4zxA1uAG6y1Zy42RjP8IiIiIiIOqm4I3t8R9gHKalv480e2FVU3BO934PYrjDE7gc3AJcDU3gZ4HHhRERERERFpF45GSzrCfoey2hbC0WjJQO5rjFkCvA9YbK1tNsasB3y9jdMMv4iIiIiIgzwuV8XYfH+Xx8bm+/G4XBUDvHUuUNse9mcAi/oySIFfRERERMRBRSO89z3wySuqO0J/Rw9/0QjvfQO89QuAxxizC/hXYm09vRpSi3ZvvfVW+8ILL6S6DBGRZDHJeiG9v4rIMDPg99e2cGRxdUPw/nA0WuJxuSqKRnjvG+iC3f4aUj381dXVqS5BRGRI0vuriEh8Mj3uTWPy/Venug5QS4+IiIiIyJCmwC8iIiIiMoQp8IuIiIiIDGEK/CIiIiIiQ5gCv4iIiIjIEKbALyIiIiIyCBhjJhhj3o53nAK/iIiIiMgQlvLAb4z5uTGm8tzvVowxBcaYNcaYQ+0f81NZo4iIiIhIXMJti6k7sZGaI0eoO7GRcNtih+7sMcY8bIzZZYx5yhiT1duAlAd+4CHg1vMe+zvgFWvtVOCV9s9FRERERNJfuG0xlftW89Dti1k5bwIP3R773JnQPx140Fp7KVAPfLm3ASkP/NbaV4Ga8x7+APBw+68fBj6Y1KJERERERPqrsfJ+nvxUEXXHY5/XHYcnP1VEY+X9Dtz9hLV2Q/uvHwGu7W1AygN/D0ZZaysA2j+OTHE9IiIiIiJ9Ew2XdIb9DnXHY48PnO3l8wuka+DvM2PMvcaYrcaYrVVVVakuR8QxURuluqWa8sZyqluqidpoqkuSYUbvryIi/eTyVJA3rutjeeNijw/cOGNMR2vQx4HXey3HgRdNhNPGmBKA9o+VPV1orX3QWrvAWruguLg4aQWKJFLURjlUe4jlzy5n2dPLWP7scg7VHlLol6TS+6uISD9lj7yPe35V3Rn688bBPb+qJnvkfQ7cfR/wGWPMLqAAeKC3AR4HXjQRVgOfAf5v+8ffp7YckeSqaa1hxdoVlDeVA1DeVM6KtStY9f5VFPmLUlydiHPuf+kAz+2uYPVfXksgM13/SRIRiZMncxMjZ97FZ5+7n2i4BJenguyR9+HJ3DSQ21prjwKz4i5nIC/qBGPMY8ASoMgYUwZ8i1jQf9IY83ngOPDR1FUoknzBSLAz7HcobyonGAmmqCIR51lr+c+1hwF4/XA1y2aPTnFFIiIO8mRuIu+Sq1NdBqRB4LfWfryHp25KaiEiacTr9lIaKO0S+ksDpXjd3hRWJeKs0/Vtnb/eV1GvwC8ikiDp2sMvMqwV+ApYuXQlpYFSIBb2Vy5dSYGvIMWViTjn2Jmmzl8fr2lOYSUiIkNbymf4ReRCLuNiav5UVr1/FcFIEK/bS4GvAJfR9+gydFScbQVgRKaH8rqWFFcjIjJ0KfCLpCmXcWmBrgxplQ2xwD+xKEBlQ1svV4uISH9pulBERFKiujGI1+1idK6PagV+EZGEUeAXEZGUqGkKkuP3MMKXQX1rmHBE50yIiCSCAr+IiKREbVOQ7EwPOb5Yd2ltcyjFFYmIDE0K/CIikhJ1LSECmZ7OA7fOtijwi8jQEYwEF1c0Vmw80XDiSEVjxcZgJLjYifsaYz5tjNlljNlpjPlVX8Zo0a6IiKREXXOQwuxMApluQIFfRIaOYCS4+HDd4dVfW/e1ovKmckoDpRN+cOMPVk/Jm3KX1+3t92m7xpjZwD8C11hrq40xfdqvWzP8IiKSEvWtYQJeNwFvbO6pXoFfRIaIMy1n7u8I+wDlTeV8bd3Xis60nLl/gLdeCjxlra0GsNbW9GWQAr+IiKREY2sYv9dDVnvgb2gLp7giERFnhG24pCPsdyhvKidswyUDvLUBbLyDFPhFRCTpQpEoLaEIWV43fm+spaehVTP8IjI0eIynojRQ2uWx0kApHuOpGOCtXwHuMcYUAqilR0RE0lZT+2y+P8NNVmfg1wy/iAwNhf7C+35w4w+qO0J/aaCUH9z4g+pCf+F9A7mvtXYP8G3gj8aYncB/9GWcFu2KiEjSNXYEfq+bTI8LAzSrpUdEhgiv27tpSt6Uux669aH7wzZc4jGeikJ/4X0DWbDbwVr7MPBwPGMU+EVEJOma2iJAbIbfGIMvw01j+2MiIkOB1+3dVJJdcnWq6wC19IiISAp0zPD7MmLtPH6vu7PNR0REnKXALyIiSdccfK+HH8CX4aIpqMAvIpIICvwiIpJ0HS09mRmxf4YyPW6ag2rpERFJBAV+ERFJuo4Zfp8nNsOf6XGppUdEJEEU+EVEJOk6ZvM7Zvh9GW619IiIJIgCv4iIJF1LR+D3uDo/tqilR0QkIRT4RUQk6Tpn+NtberwK/CIiCaPALyIiSdcSiuBxGdwuA8SCf0tIgV9EJBEU+EVEJOlaQ5HO/n2ItfS0hqIprEhEZOhS4BcRkaRrCUY623mgvYc/FMFam8KqRESGJgV+ERFJupZQBK/nvX+COn7dFtYsv4iI0xT4RUQk6VpDEbzuri09HY+LiIizFPhFRCTpzp/hz2j/tRbuiog4T4FfRESSri0UPW+GP9bPr605RUScp8AvIiJJd0EPv1s9/CIiiaLALyIiSXd+D7/XYzofFxERZynwi4hI0rWGIp19+wAZ7o5Fu5rhFxFxmgK/iIgkXWu4aw9/x69bw5rhFxFxmgK/iIgkXVtP+/CrpUdExHEK/CIiknRt4SgZbtP5eYYW7YqIJIwCv4iIJJW1lrZwtIcZfgV+ERGnKfCLiEhSBSOxUJ/hvnDRbpt6+EVEHKfALyIiSdXRtuPtEvhNl+dERMQ5CvwiIpJUHW075/bw6+AtEZHEUeAXEZGk6mjb8Zwzw+92GQw6eEtEJBEU+EVEJKm6a+kxxpDhdhHUDL+IiOMU+EVEJKk6Qr3nnJYeiLX4qKVHRMR5CvwiIpJUHaH+3F16Oj5X4BcRcZ4Cv4iIJFWwh8DvcRu19IiIJIACv4iIJFXHot2M81p6vG6X9uEXEUkABX4REUmqnmf41dIjIpIICvwiIpJUHaHe4+o6w6+WHhGRxFDgFxGRpAp2sy0noG05RUQSRIFfRESS6r1tOc8L/C5DMKLALyLiNAV+ERFJqrZIRw//+S09WrQrIpIICvwiIpJUPc7wq4dfRCQhFPhFRCSp3tulp7sZfgV+ERGnKfCLiEhSdQZ+14U9/CEFfhERxynwi4hIUgUjEVwGXOdty5nhdmnRrohIAijwi4hIUoUi9oJDtyDW0qPALyLiPAV+ERFJqmA4iue8/n2IHcQVCtsUVCQiMrQp8IuISFK1haMX9O+DdukREUkUBX4REUmqUKT7GX63y0XEWiJRzfKLiDgprQO/MeZrxpg9xpi3jTGPGWN8qa5JREQGJtbS0/0MP8S+IRAREeekbeA3xowBVgALrLVzADfwsdRWJSIiAxWKRMlwXTjD37GQVwt3RUSclbaBv50H8BtjPEAWUJ7iekREZIBiLT3d7NLT/k2A9uIXEXFW2gZ+a+1J4PvAcaACOGutfSm1VYmIyEC1haO4u5nhd7e39GiGX0TEWWkb+I0x+cAHgIlAKRAwxnyym+vuNcZsNcZsraqqSnaZkkBRG6W6pZryxnKqW6qJWoUAkWRK1PtrKBLtnM0/l6d95x5tzSki4qy0DfzA+4Aj1toqa20I+A1w9fkXWWsftNYusNYuKC4uTnqRkhhRG+VQ7SGWP7ucZU8vY/mzyzlUe0ihXySJEvX+GorYiy7a1Qy/iIiz0jnwHwcWGWOyjDEGuAnYl+KaJElqWmtYsXYF5U2xZRvlTeWsWLuCmtaaFFcmIgPVFo5cdIZfe/GLiDgrbQO/tfYN4ClgO7CbWK0PprQoSZpgJNgZ9juUN5UTjARTVJGIOCUUtj0Efs3wi4gkgifVBVyMtfZbwLdSXYckn9ftpTRQ2iX0lwZK8bq9KaxKRJwQjEQ7t+A8V8dhXGEFfhERR6XtDL8MbwW+AlYuXUlpoBSIhf2VS1dS4CtIcWUiMlA9LtrVPvwiIgmR1jP8Mny5jIup+VNZ9f5VBCNBvG4vBb4CXEbfo4oMdrF9+Htu6QlFtEuPiIiTFPglbbmMiyJ/UarLEBGHhSIWt0sHb4mIJIumS0VEJKl6nOFvb+kJqaVHRMRRCvwiIpJUwXBPB29plx4RkURQ4BcRkaSKLdrtuaVH+/CLiDhLgV9ERJImErVELRdt6dEMv4iIsxT4RUQkaTr68y/W0hPWLj0iIo5S4BcRkaR5L/D3fPCWFu2KiDhLgV9ERJKmY4/97vfhd3W5RkREnKHALyIiSdOXlh7N8IuIOEuBX0REkqZjBx53N4Hf5TIYFPhFRJymwC8iIkkTjna09HT/z4/HbdTSIyLiMAV+ERFJmou19MQed2mGX0TEYQr8IiKSNBdr6YHYNwI6eEtExFkK/CIikjS9zvC7DeGoAr+IiJMU+EVEJGl66+F3u9TDLyLiNAV+ERFJmlCvLT3q4RcRcZoCv4iIJE2oY4b/Yi09muEXEXGUAr+IiCRNbzP8bpchqBl+ERFHKfCLiEjSdCzI7XlbTkNYgV9ExFEK/CIikjTBSEdLT/f//Li0aFdExHGeVBcgQ1fURqlprSEYCeJ1eynwFeAy+h5TZDjrfdGuWnpERJymwC8JEbVRDtUeYsXaFZQ3lVMaKGXl0pVMzZ+q0C8yjHW29Lh76uF3qaVHRMRhSl6SEDWtNZ1hH6C8qZwVa1dQ01qT4spEJJVCkV526dEMv4iI4xT4JSGCkWBn2O9Q3lROMBJMUUUikg469ti/WEuPtuUUEXGWAr8khNftpTRQ2uWx0kApXrc3RRWJSDoI97JoV9tyiog4T4FfEqLAV8DKpSs7Q39HD3+BryDFlYlIKgU1wy8iknRatCsJ4TIupuZPZdX7V2mXHhHpFO6th9/t6mz7ERERZyjwS8K4jIsif1GqyxCRNBKORnGZ2H773XFrH34REcdpulVERJImGIn22M4DsZl/zfCLiDhLgV9ERJImHLE9LtiF2Ax/x179IiLiDAV+ERFJmlAk2mP/PrQHfrX0iIg4SoFfRESSJhSxPZ6yC7HtOtXSIyLiLAV+ERFJmnAvPfxulyFqIRrVLL+IiFMU+EVEJGlCfVi0CxBSH7+IiGMU+EVEJGlC0Ysv2u1o91Efv4iIcxT4RUQkafrS0gOoj19ExEEK/CIikjShiO1j4NcMv4iIUxT4RUQkaXrr4e94Tnvxi4g4R4FfRESSJtzLDH/Hol318IuIOEeBX0REkqa3g7c6FvQG1cMvIuIYBX4REUmaPrf0aIZfRMQxCvwiIpI04ai96Ay/dukREXGeAr+IiCRN3xftaoZfRMQpCvwiIpI0vW3L+d6iXc3wi4g4RYFfRESSJnbwVs//9GgffhER5ynwi4hI0oQiF+/h79ilRz38IiLOUeAXEZGkCUcvvi2nDt4SEXGeAr+IiCRNbz38aukREXGeAr+IiCRNOHrxXXp00q6IiPMU+EVEJGnCfZzhV0uPiIhzFPhFRCRpwr0u2lVLj4iI0xT4RUQkKay1RGwfZ/i1S4+IiGMU+EVEJCk6Zu37tA+/TtoVEXGMAr+IiCRFR1/+xRftxv5Z0gy/iIhzFPhFRCQpQuHYrH1f9uHXwVsiIs5J68BvjMkzxjxljNlvjNlnjFmc6ppERKR/Qu0z/BddtOvWol0REad5Ul1AL34EvGCt/YgxxgtkpbogERHpn3BnD39fFu0q8IuIOCVtA78xJge4HvgsgLU2CARTWZOIiPRfR5vOxQK/yxhcRvvwi4g4KZ1beiYBVcAvjDE7jDE/NcYEUl2UiIj0Tzja+wx/x/Nq6RERcU46B34PMB94wFp7OdAE/N35Fxlj7jXGbDXGbK2qqkp2jSIiQ5bT768dO+9crIc/9rxLu/SIiDgonQN/GVBmrX2j/fOniH0D0IW19kFr7QJr7YLi4uKkFigiMpQ5/f7al334Y8+bzp8GiIjIwKVt4LfWngJOGGOmtz90E7A3hSWJiMgAhPo4w+92GYKa4RcRcUzaLtpt9xVgVfsOPe8Cf5riekREpJ/6cvAWxL4hUEuPiIhz0jrwW2vfAhakug4RERm4UB+25ex4Xttyiog4J21bekREZGjpCPF9aekJqYdfRMQxCvwiIpIUoT629LjV0iMi4igFfhERSYq+nLTb8bz24RcRcY4jgd8Yk2OMmdzN45c6cX8RERn8wn04aRfaF+3qpF0REccMOPAbY+4B9gNPG2P2GGOuPOfphwZ6fxERGRo6+vI9vezD79KiXRERRzkxw/8PwBXW2nnEts38lTHmQ+3PXXwaR0REho2+zvC7jencs19ERAbOiW053dbaCgBr7ZvGmBuBPxhjxgKaohEREaDvPfwenbQrIuIoJ2b4G87t328P/0uADwCzHbi/iIgMAfHs0qMZfhER5zgxw//nnPeNg7W2wRhzK3CPA/cXEZEhoO/78LtoCYWTUZKIyLAw4MBvrd3Zw+MhYNVA7y8iIkNDKJ5derRoV0TEMQMO/MaYBrrv1TeAtdbmDPQ1RERk8Ovoy+/TwVvq4RcRcYwTM/wjnChERESGto5denpv6VEPv4iIk5zo4e/CGDMS8HV8bq097vRriIjI4BOM66RdBX4REac4ctIugDHmLmPMIeAI8EfgKPC8U/cXEZHBLRyJ4jJgjHr4RUSSybHAD/wrsAg4aK2dCNwEbHDw/iIiMoiFo7bXU3ahfYY/qhl+ERGnOBn4Q9baM4DLGOOy1q4D5jl4fxERGcRCkSged+8HsGuGX0TEWU728NcZY7KB14BVxphKQBspi4gIENuH//9v787jo7rPe49/npnRigAJEJIQiM2AMZhVLLYTHO92jJckbho3cZZmabqkSdt7m6RNbtrcV9P4FSe3dXttN1uzOSG5thMvcWJsx3YItgmYxQs7mEVmkQwSiwQazczv/nFmhGOzzIzmzJkZfd+vFy8JMTrnOQLOPPPM83t+5+rfh+SUHiX8IiI5k8sK/2+BWuDTwK+BHcANOTy+iIgUsVgicc4JPeBtvBVTS4+ISM7kMuE34DHgaaAG+GmyxUdERIS+DCr8CQcJzeIXEcmJnCX8zrl/ds7NAP4SGAM8Y2ZP5Or4IiJS3GLxRFoJf+pdAC3cFRHJjVxW+FPagQPAIWC0D8cXEZEi1JdIv8IPqI9fRCRHcjmH/8/N7GngSWAU8HHn3KxcHV9ERIpbLJ5uD78SfhGRXMrllJ7xwGecc+tzeEwRESkRXg//uetMqdGdUe22KyKSEzlL+J1zn8vVsUREpPT0pdnD31/hVw+/iEhO+NHDLyIi8hbpzuGPqKVHRCSnlPCLiEhe9CUShC29OfzgvSMgIiIDp4RfRETyIhZ36S3atVRLjyr8IiK5oIRfRETyIt0e/v45/Krwi4jkhBJ+ERHJi0wX7faph19EJCeU8IuISF70xV3/yM2zST0mpgq/iEhOKOEXEZG8iMUTac3hV4VfRCS3lPCLiEhexBJpLtqnRyf/AAAgAElEQVTVHH4RkZxSwi8iInnRpzn8IiKBUMIvIiJ5EUuku2hXc/hFRHJJCb+IiORFujvtnmrpUYVfRCQXlPCLiEhexBKJjHr4VeEXEckNJfwiIpIXfbH0Fu1GNKVHRCSnlPCLiIjvnHPEXaaLdlXhFxHJBSX8IiLiu1S1PqM5/OrhFxHJCSX8IiLiu9RM/YwW7arCLyKSE0r4RUTEd6kKf0Ybb6mHX0QkJ5Twi4iI71ITd9JbtOs9NUVV4RcRyQkl/CIi4rtYfw+/dtoVEck3JfwiIuK7VIU/nYQ/FDKMU33/IiIyMEr4RUTEd6ldcyPh9J52ImHTHH4RkRxRwi8iIr7rr/DbuSv84PXxa6ddEZHcUMIvIiK+y2TRLnitPxrLKSKSG0r4RUTEd/0bb4XTrfAbUbX0iIjkhBJ+ERHxXUwVfhGRwCjhFxER32Wy8RZ4i3ZTC31FRGRglPCLiIjvTo3lTO9pJxwybbwlIpIjSvhFRMR3qZn6kbR7+ENq6RERyREl/CIi4rtoLP2ddlOP0xx+EZHcUMIvIiK+S1X4053D7yX8qvCLiOSCEn4REfFd/xz+DMZyKuEXEcmNSNABiJxRIgE9HRCLQqQcqushzQV/IlJYMp3S443lVEuPiEguKOGXwpRIQPtGWHYrdO2B2hZ4309g9AVK+kWKUKZTeiKa0iMikjPKnKQw9XScSvbB+7jsVu/rIlJ0YhlX+ENq6RERyZGCT/jNLGxm68zskaBjkTyKRU8l+ylde7yvi0jRybiHP6yWHhGRXCn4hB/4NLAp6CAkzyLlXhvPG9W2eF8XkaKT6uHPbCynKvwiIrlQ0Am/mY0Frge+HXQskmfV9V7PfirpT/XwV9cHG5eIZCXW38Of/pQe9fCLiORGoS/a/Tfg74GhZ3qAmX0C+ARAS0vLmR4mxSYU8hbofuwJTekRCUgu76/9i3bTnMMf0ZQeEZGcKdjsycyWAu3OuRfO9jjn3Dedc63Oudb6elV/S0ooBDUNUDvO+6hkXySvcnl/7Us4IiHD0t54K0QsoYRfRCQXCjmDugS40cx2AcuAy83sR8GGJCIi2eiLJSgLp/+UEwmrh19EJFcKNuF3zn3eOTfWOTcBeB/wG+fcBwIOS0REstAXT6Tdvw/aaVdEJJcKNuEXEZHSkWrpSZd6+EVEcqfQF+0C4Jx7Gng64DBERCRLfbHMKvzhkBFLOBIJRyiD7xMRkbdShV9ERHzXF0+kvekWQCS5SL8vobYeEZGBUsIvIiK+60u4zHr4ky8O+tTWIyIyYEr4RUTEdxlP6Um+OIhp4a6IyIAp4RcREd/1xRMZLdoNJ1t6tNuuiMjAKeEXERHf9cXV0iMiEhQl/CIi4rtoFnP4wWsFEhGRgVHCLyIivuuLJfon76SjP+FXS4+IyIAp4RcREd9FM+zhj6iHX0QkZ5Twi4iI7zKdwx9WD7+ISM4o4RcREd9lvGhXLT0iIjmjhF9ERHwXjSUoy6SHPzmzX4t2RUQGTgm/iIj4LtOWnlSFXz38IiIDp4RfRER81xdP9G+mlY5TLT3q4RcRGahI0AGIiE8SCejpgFgUIuVQXQ8ZJFwiudQXd5lV+FMtParwi4gMmBJ+kVKUSED7Rlh2K3TtgdoWeN9PYPQFSvolEH0Zj+XUol0RkVzRM79IKerpOJXsg/dx2a3e10UC0BdPUBZO/ymnLPluQFSLdkVEBkwJv0gpikVPJfspXXu8r4vkWTzhSDgyGssZ1sZbIiI5o4RfpBRFyr02njeqbfG+LpJnqbacskxaepIV/pgW7YqIDJgSfpFSVF3v9eynkv5UD391fbBxyaDUm2zLiWTQ0tM/llMtPSIiA6ZFuyKlKBTyFuh+7AlN6ZHApSr8mS3aVUuPiEiuKOEXKVWhENQ0BB2FyKmEP5MKf1hTekREckXlPhER8VVfzOvDz6TCHzIjHDIl/CIiOaAKv4iI+CoajwNktPEWeC8QSq6H/8BLsP0J6H4dhjbB1Gtg1JSgoxKREqeEX0REfBXtr/Bn9qZyWThUOgn/kTZ4+DOw/XHv95FKiJ2E5f8IM98D77wDqkcEG6OIlCwl/CIi4qtofw9/FhX+UhjLuW8d/Og90NcD8z8M510FlcO9Kv+WX8ErD8De1fDBX8DIyUFHKyIlSD38IiLiq/45/Bks2gXvBULRV/g7tsIP3wWhCFz/DZh5i5fsAwwZBfNug2u/Cr1H4Ps3wNH9wcYrIiVJCb+IiPgqlbRnsmgXvKk+Rb1ot/c4LLsVnIOr/wWGjzv94+qnwZVfhp5D8LPbIN6X3zhFpOQp4RcREV+lEv6yDFt6yop90e7jX4RDO2DJ38PQxrM/duRkuPhT0LYaVnwjP/GJyKChhF9ERHwVzWIOf+rxRbvx1p5VsOa7cMFN0DQrve+ZeClMWAIr7oDXt/sbn4gMKkr4RUTEV/0V/gyn9BRtD38iAb/+LFSPgjkfyOx7F37c6/df/g/+xCYig5ISfhER8VV/D/9gmcO/6SFvMs/c26CsMrPvraqDC/8Itj4Ge573Jz4RGXSU8IuIiK/6W3oyXLRbFgrRG4v7EZJ/Egl4+qswvAUmvSO7Y0y/wUv8n7k9l5GJyCCmhF9ERHx1atFuFj38xVbh37YcOjbBhbdAKJzdMSKVXu//jt947xSIiAyQEn4REfFVti09ZWGjt9gW7T73n958/YlLBnacqddBWRU8d1du4hKRQU0Jv4iI+Cqa9cZbRVbhb98Eu1bAtKXewtuBKB8C510Jr/wcjrfnJj4RGbSU8IuIiK96s9x4q+jm8K/5LoTKYMpVuTnetOsh0Qfrfpib44nIoKWEX0REfBWNJYiEDLMS3mm37wS8+FMYfzFUDs/NMYePhYYLYe0PvcXAIiJZUsIvIiK+isYSGbfzAJSHrf/dgYK3+Zdw8kjuqvspU66Czldhz7O5Pa6IDCpK+EVExFe9sTjlkcyfboqqh3/DMhhSD41p7qqbrpaLvak9G5bl9rgiMqgo4RcREV+lWnoyVRY2YglHIuF8iCqHul/3RmhOvBQsx0+rZZVem9DGByHWm9tji8igoYRfRER81RtLUJZFhT/VBhQt9D7+V34OLu4l/H6YeCn0HoVtj/tzfBEpeUr4RUTEV9FYgrKsKvzeU1TB9/G//IC3s27dBH+O3zTHWwj8ys/9Ob6IlDwl/CIi4qtoPEEki0W7qY26CrqP/9hB2PMcTLgEMpxClLZQGMYthq2/8qYBiYhkSAm/iIj4qjcWz3iXXThV4T/ZF891SLmz+RHAwfhL/D3P+Esg2g07n/b3PCJSkpTwi4iIr3r7EpRnNZazCHr4Nz0Mw5qhdry/52m8EMprYOND/p5HREqSEn4REfFVb5Zz+PsX7RZqS8+JLti1AloW+9fOkxIug7ELvLaeeMzfc4lIyVHCLyIivuqNxbOq8Jcl24AKdtHu9icgEfP66/Nh3CI40Ql7V+XnfCJSMpTwi4iIr7wK/wCm9BRqD/+WX0FlLYyamp/zNc+DUBlseTQ/5xORkqGEX0REfNXbl11LT2p33pOFWOGP98H2x6G51Zuikw9l1V4v/5Zf5ed8IlIylPCLiIivemPxgW28VYgJ/95VcPIIjFuY3/OOXQCHd8ChHfk9r4gUNSX8IiLiq5OxgU3pKcixnNuWQygCY+bk97xjF5w6v4hImpTwi4iIb5xz9PbFs5zS4/X9F2TCv/UxaJjhtdnk09BGGD7OO7+ISJqU8IuIiG9iCUfCnerHz0TqewpuSs+RNujYDM3zgzl/83zYvdLbiEtEJA1K+EVExDep6vxApvQUXIV/2+Pex+bWYM7f3ArxKLy6Ipjzi0jRUcIvIiK+OdnnVeezm8NfoBX+7U/AkNFea00QGmZApNKbEiQikgYl/CIi4pv+Cn9WU3oMo8Aq/LEo7HzKm4nv9+66ZxIug8ZZ3jsNzgUTg4gUFSX8IiLim96Yl6xnU+E3M8oiocJK+Peu8nrng+rfT2meD127NZ5TRNJSsAm/mY0zs6fMbJOZvWJmnw46JhERyUx/S08WFX6AinCo/xgFYfsT3kZbjbODjSP1gmPHk8HGISJFoWATfiAG/J1zbjqwGPhLM7sg4JhERCQDqep8NhV+8F4oFFSFf8eTUH8BlOd5HOebDW2EYWO8FyAiIudQsAm/c26/c25t8vNjwCagOdioREQkEwOt8JdHQpwslEW7xw7CgZegeW7QkXia5sKuFRDrDToSESlwBZvwv5GZTQDmAqtO82efMLM1Zramo6Mj36GJiJSsXNxfU9X5ioEk/IVS4d/5lPdxzLxg40hpngd9J2DPc0FHIiIFruATfjOrAe4HPuOcO/rmP3fOfdM51+qca62vr89/gCIiJSoX99cTqZaebBP+cAEl/NufhMpaGDEp6Eg8jbMgFFFbj4icU0En/GZWhpfs3+uceyDoeEREJDO5qPCfKISEP5GAHU/AmLlgBfLUWVYFoy/wXoiIiJxFgdy13srMDPgOsMk5942g4xERkcz1L9qNhLP6/opIiBPRAkj4D2yAnsOF086TMmYetG+Eo/uDjkRECljBJvzAJcBtwOVmtj75651BByUiIunriQ68wt9TCAl/qm1mTIEs2E1pTr4A0XhOETmLSNABnIlz7ndAQNsYiohILgy0h78iEi6MHv7tT8LIKVBVG3Qkf6huIlSN8F6QzP1A0NGISIEq5Aq/iIgUuRPROOXhECHLrn5TUQgV/hNdsPf3hVfdBzDz2np2PAXxWNDRiEiBUsIvIiK+6YnGqSjL/qmmIHr4dz4NLn5qd9tC0zwPTnbBay8EHYmIFCgl/CIi4pueaDzr/n3wFvtG4wniCZfDqDK0/XEoHwL15wcXw9mkJgdtfzzoSESkQCnhFxER35zoi1FZlt2EHoDK5LsDPdGA2lWcg22Pe20zoeyvw1cVQ70XI9uU8IvI6SnhFxER3wy0wl+RHOcZWFvPgRfh+MHCbedJaW6F/evh2MGgIxGRAqSEX0REfNPdG8t6Qg+cqvB3B5Xwb13ufSz0hH9sq/dRbT0ichpK+EVExDc90TiVWW66BfR/b3dvQC09Wx+DUVOhqi6Y86erbiIMqYetvw46EhEpQAU7h19ERIpfd2+MYbVVWX9/ZbmX8AcymvN4B7y2Bmbfmv9zZ8rMexdix28g1guRiqAjKhhHo0dpO9ZGR08Hh08epruvmxOxEzi8heAV4QqqIlXUVtRSV1lHQ3UDjUMaKQ+XBxy5SO4o4RcREd90D7jCn2rpCaDCv+0xwMG4Rfk/dzbGLfIq/Lt+B+ddEXQ0gTjSe4Q1B9ewoX0DGw9tZGvnVjp7O7M6VkN1AxOHT2Ry7WSm1k1l2ohpTK2dSlm4LMdRi/hPCb+IiPimuzdG1QDm8Kcm/ATS0rPlV16bzIhJ+T93NhpnQaTSi3uQJPzOObZ2buU3e3/DM3ufYeOhjTgckVCEsTVjmTlqJk1Dmqivrqeuoo5hFcOoilRRHi7H8DaDi8aj9MZ7Od53nKPRo3Se7OTQiUO097Szv3s/69rX0RvvBSASijC1bipz6ucwu342c0fPpammKcgfgUhalPCLiIgvEgnn9fCXZ1/hryoPKOGP9sD2J2DyFV67TDGIVHgz+Tc/Au/8WvHEnYX2nnYe2vEQD+94mJ1HdmIYk4ZP4qbJN3H+yPOZOHwiZaH0KvGRUITqsmrqKk+/TiPhEnT0dLDn2B52HdnFq0de5f5t9/PjzT8GvHcCWhtbaW1oZUHjAlqGtmAl/LOX4qSEX0REfJFqw6kawBz+1PceO5nnhH/nUxA7CS2L83vegWpZDHueg9fWwtgCnyyUIeccqw+s5t5N9/JM2zPEXZwptVO4bfptzGuYx/CK4b6cN2QhGoY00DCkgQWNCwCIJ+K0HW9jW+c2tnZu5Xdtv+OXO38JQH1VPQsaF7CwcSELGhcwbug4vQCQwCnhFxERX3T3egttqwZS4e9v6cnzot1ND3sbWjVemN/zDtTYhd4GYZsfLpmEP5aIsXzXcr7z8nfY2rmVmrIarp5wNUual9AwpCGQmMKhMOOHjWf8sPFcOf5KnHMc6D7Als4tbD68mZX7VvLoq48C3jsACxoXeL8aFjB26Fi9AJC8U8IvIiK+OHayDxhYhT8UMirLQv3HyotYFLY8CmMXQKjIniYrhnq9/Bt/AVd8qajbemKJGI/sfIT/evG/aDvWxpghY/jIjI+wqGlRwU3QMTOaappoqmniHePe0f8CYPPhzWw6vInftv2WR3Y+ApxqAZrfMJ/WhlYmDJugFwDiuyK7k4mISLE4mmzDqS4f2FNNdXkkvy09O5+Ck0dgwtvzd85cGn8JPPefcOAlaJoVdDQZS7gEj+16jP9Y9x/sPbaX8cPG81dz/oo5o+cQsuLYPuiNLwAua7kM5xz7uvex9fBWNndu/oMWoBGVI5jfMJ/5DfOZN3oeU+umEg5l/yJZ5HSU8IsUqETCcag7SjQWpzwSZuSQckIhVYGkeKSq8tUDaOlJff+x3jxW+F++H8proGlO/s6ZSy0Xwaq7vesosoT/+f3P8/U1X2fz4c2MrRnLp+Z+ijn1c4q+Am5mNNc001zT3P8C4EDPAbZ1bmPL4S2sa1/H47u9XZKrI9XMGT2n/wXAhfUXUhHWvgoyMEr4RQpQIuHYcvAYH//BGto6TzC2ropvfbCVaQ1DlfRL0YjFHUMrIwwZYIW/tqqMUL4Svr4T3pSb8ZdAsc5brxwOTXO9hP+KL0Go8KviO7t2cseaO1jx2gpGVY3i4xd+nEVNi4qmop8pM6NpSBNNQ5pYMnYJAIdOHPIWAXdtZXvndp7d9ywAZaEyZoyc0T8JaM7oOQwpGxJk+FKEzDkXdAw509ra6tasWRN0GCID1nGsl3fdtZK2zhP9XxtbV8XP/+IS6oeq0iP98vbqL9v7667Xu9l/5OSAzh0OGQsnjhjQMdL28v1w35/C1f8CTbPzc04/7HgKfvd1+MivYfxFQUdzRkd6j3D3hrtZtnkZFeEKlk5ayhUtV2hzK+B49Djbu7aztXMr2zq3sevoLuIuTtjCTB85nYWNC1nYuJB5DfOoimS/m7WcUUlV11ThFylA0Vj8D5J9gLbOE0RjeZ5UIjLYbFjmbbZVbNN53qzlIm8Trg0/LsiEP56Ic/+2+7lz3Z0c6z3GknFLuPm8mxlWPizo0ApGTXkNc0bPYc5or7XsZOwkO7p2sKVzC1sOb+H7r3yf7778XcpCZcypn8NFYy7i4jEXM33k9JJ9Z0Syp4RfpACVR8KMrat6S4W/PKKFXCK+Obrf22xr5nug2BOmskoY/zZ4+QG49qtQXjgtIGsPruUrq77Cls4tTKubxt/O/1vGDR0XdFgFrzJSyYxRM5gxagYAvbFetnVtY+OhjWw8tJE7193JnevupK6ijrc1v40l45ZwyZhLGFo+NODIpRAo4RcpQCOHlPOtD7a+pYd/5JDCGkUnUlLW3wsuAeddFXQkuTHlStjxBLzyC5j7/qCjoaOng2+88A0e2fkIIypH8MlZn2RB44KiX5AblIpIBTNHzWTmqJmA1x618dBGXnr9JZ7a+xQP73yYsIVpbWjl8pbLubzlchqHNAYctQRFPfxSsAb7lJrBfv2SFvXw50oiDv8+B6pq4Zqv+HuufHEOHvxzqGmCjz8RWBh98T5+tOlH3LPhHqKJKNdOuJbrJ15PRUTrkfyScAl2du1kfcd61revZ1/3PgBmjZrF1ROu5urxV9NU0xRwlAWvpJ5wVeGXgqQpNd6GQ1qgK5In25bDkT0w50+CjiR3zGDqdbD6W7BvHYyZm/cQVrSt4PbVt7P76G5m18/m1vNvZXT16LzHMdiELMR5dedxXt153DL1FvZ37+eFgy/wwsEXuGPNHdyx5g5m18/muonXcc2EaxhVNSrokMVnqvBLQdKUGpG0qMKfK9+/Ado3wbu/VXy7655NtBvu+zBMvxHe/c28nfbVI6/ytdVfY8VrK2gc0sj7pr2PWfXFtSdAqTrYfZDVB1fz+/2/p+14G2ELs7hpMTdMvoHLWy7XxJ9TSqq6WEJ3NSklmlIjInmzbx28+luY/+HSSvbBW6x73lXeuNHLvwi1/i6O7TrZxd0b7uanW35KebicP572x1zRcgWRUvu5FrGGIQ0snbSUpZOW8trx13h+//M8v+95Vu5bSXWkmqvGX8VN593E/Ib5mvZTQvQ/UAqSptSISN6s+DqUDfHaX0rRBTfDll/Cyn+H6+/w5RQnYye5d9O9fPulb9PT1+ON2Zx8M8MqNGazkDXXNPOeKe/hXee9i22d21i5byXLdy/nwR0PMmbIGG467yZunHwjY4eODTpUGSAl/FKQNKVGRPJi/4uw6WGYfWtBja7MqZrRMPkKWPt9eNtnYHjukre+RB8Pbn+QuzfcTXtPO7PrZ3PL1FtormnO2TnEfyELMW3ENKaNmMb7p7+ftQfX8uy+Z7lnwz3cveFuWhtaufm8m7lq/FVUl1UHHa5kQT38UrA0pUbknNTDP1A/fDe0/d7r3S+v8eccheB4O/z8z2DWe+HmuwZ8uFgixqOvPso9G+5h77G9TB4+mfdMfQ/njzg/B8FKoTh84jAr963k2X3PcrDn4GBr+SmphEMVfilYmlIjIr7a+hjseBJaP1bayT54Vf7pN8D6H8OCj0HzvKwOE41HeXjHw3zn5e+w99hexg8bz1/P/Wtm18/WPP0SNKJqBDdMvoGlk5ayrWsbK19byWO7HuPBHQ/SXNPMDZNv4IZJN9AyrCXoUOUcVOEXESleqvBnq/c43LUYMLjxztJbrHs60R74xSe9hbsf+w2E07/mI71HuG/rfdy76V46TnQwYdgElk5aytzRc5XoDzK9sV7Wtq9l5b6VbDq0CYdj1qhZXD/peq6ZcA0jq0YGHWKulNQ/7EFwhxMREXmT5V+AI21w7VcHR7IPUF4NCz8Bz3wVVtwB7/jcOb9la+dWlm1exsM7HuZk/CQXjLyA2y64jRkjZyjRH6QqIhVcNOYiLhpzEYdPHmbV/lU8v/95/vX3/8rtq29nUeMirp14LZePu5zaytqgw5WkQXKXExERSXrpPnjhv2HGu6FhRtDR5NeEt8Hey+CZ26HlIph06VsecjR6lOW7lvPAtgd46fWXKAuVsahpEVe2XKnWDfkDIypHcN3E67hu4nW0HWtj1YFVrN6/mi89+yW+bF9mQeMCrmy5kstaLtOGawFTS4+ISPFSS0+mDrwE374SRkyCa74yeKr7b9TXA7/8HxA9Bn/2W6htoaevhxWvreCxXY/xzN5niCaiNNc08/bmt3PxmIupKfU1DpIzzjl2H93N6oOrWXtwLQd7DgIwfcR0Lh13KW9rfhszR84kHCr4Mdsl9RaWEn4RkeKlhD9T0R549H/C1GuhahC3Gxzdx4Hdv2Pl1Lfz9L4VPLfvOXrjvQwrH8bCxoUsblrMxOET1bYjA+KcY1/3Pta3r2d9x3p2du3E4RhWPoxFTYtY1LiI1sZWJg2fVIj/1gouoIEYhKUNEREZtMqr4fIvwKHtQUeSd+29Xaw9uoMXjmxnVecWXj1xAFY9zcjKkVwy5hJaG1uZWje11EctSh6ZGc01zTTXNHP9pOs5Hj3Oy4deZuOhjaw9uJbHdz8OQG1FLXNGz2F2/WxmjZrFBSMv0LtKOaaEX0REpIQkXIL9vZ1s797H5uNtbO7ey0tHd3Ew2gVARaiMKdVjeO+kG5nZ2EpzTXMhVlelBNWU17C4aTGLmxbjnKPjRAebD29mW+c2Nh/ezNN7n+5/7Lih4zh/xPlMqZvClNopTBw+kXFDx1Ee1gac2VDCLyIiUkScc3TFuumIHuFAbycHTnbyWu8h2k68zu4T7ew+0c7JRLT/8Y3ldYyvGs3lo2YzubqJ8VWjCVsIasdD1fAAr0QGMzNjdPVoRlePZsnYJQAcjx5n19FdvHrkVfYc28OGjg08sfsJHF77echCNFY30jKsheaaZsbUjKFxSKN3nKrRjKwaybDyYXoBexpK+EVERArcpuN7+eKWH3AoeoyuWDcxF/+DPw9biFFlwxhdUcvbR8ygqaKOsZWjaK4cSVVYGxhKcagpr2HmqJnMHDWz/2u9sV72de/jQPcBDnQfoL2nnfaedjYe2sjR6NG3HCMSilBXUUdtZS21FbVMq5vGZxd+Np+XUZCU8IuIiG/KIyFqKgb2VJPzYl24DCqKqz94SHwEIyvqGFPdwLBINbXlQ6ktq2Fk+XBGlg+jrnxo5r335UOhrNqfgEVypLqsmrqqOmaMeusI3d54L4dPHObwycN09XbR1dvFkd4jHI0e5Xj0OMeix+js7Qwg6sJTUlN6zKwD2O3DoUcBr/tw3GKh69f16/oL0+vOuWvzcSIf769+KOS/s3QUe/xQ/NdQ7PFD8V9D0PHn7f6aDyWV8PvFzNY451qDjiMoun5dv65/8F5/MSr2v7Nijx+K/xqKPX4o/mso9vgLjWZviYiIiIiUMCX8IiIiIiIlTAl/er4ZdAAB0/UPbrp+KTbF/ndW7PFD8V9DsccPxX8NxR5/QVEPv4iIiIhICVOFX0RERESkhCnhfwMzu9bMtpjZdjP73Gn+vMXMnjKzdWb2opm9M4g4/WJm3zWzdjN7+Qx/bmZ2Z/Ln86KZzct3jH5J49rfn7zmF83sWTObne8Y/XSu63/D4xaYWdzMbslXbPmQzvWb2TvMbL2ZvWJmz+QzPjk3MxuXvD9vSv4dfTromLJhZuHkc8wjQceSDTOrNbP7zGxz8u/ioqBjypSZ/U3y39DLZvYTM6sMOqazOd39y8xGmNnjZrYt+bEuyBjP5QzX8LXkv6MXzeznZlYbZIzFTgl/kpmFgf8LXAdcANxqZhe86WFfAH7mnJsLvA+4K79R+u57wNlmzl4HTEn++gRwdx5iypfvcfZrfxW41Dk3C/jflF5v4fc4+0C+vOsAAAafSURBVPWn/o/cDjyWj4Dy7Huc5fqTTzR3ATc652YAf5SnuCR9MeDvnHPTgcXAX57mHl4MPg1sCjqIAfh34NfOufOB2RTZtZhZM/DXQKtzbiYQxnu+L2Tf4633r88BTzrnpgBPJn9fyL7HW6/hcWBm8nl3K/D5fAdVSpTwn7IQ2O6c2+mciwLLgJve9BgHDEt+PhzYl8f4fOec+y1w+CwPuQn4gfM8D9SaWVN+ovPXua7dOfescy61Xd/zwNi8BJYnafzdA3wKuB9o9z+i/Erj+v8EeMA5tyf5+JL7GRQ759x+59za5OfH8BLN5mCjyoyZjQWuB74ddCzZMLNhwBLgOwDOuahzrivYqLISAarMLAJUU+DP9We4f90EfD/5+feBm/MaVIZOdw3OueXOuVjytyX3vJtvSvhPaQb2vuH3bbz1yeKfgA+YWRvwKF4CNJik8zMaDD4K/CroIPIpWfV6F3BP0LEEZCpQZ2ZPm9kLZvbBoAOSMzOzCcBcYFWwkWTs34C/BxJBB5KlSUAH8N/JtqRvm9mQoIPKhHPuNeAOYA+wHzjinFsebFRZaXDO7QfvxTAwOuB4BupPGWTPu7mmhP8UO83X3jzC6Fbge865scA7gR+a2WD6GabzMyppZnYZXsL/2aBjybN/Az7rnIsHHUhAIsB8vOrrNcAXzWxqsCHJ6ZhZDd47UZ9xzh0NOp50mdlSoN0590LQsQxABJgH3J1sfe2m8FtJ/kCy1/0mYCIwBhhiZh8INqrBzcz+Ea9l796gYylmgylZPZc2YNwbfj+Wt76N91HgZwDOueeASmBUXqIrDOn8jEqWmc3Ce6v9JufcoaDjybNWYJmZ7QJuAe4ys4J+izjH2vD6krudc68Dv8XrT5YCYmZleMn+vc65B4KOJ0OXADcm/48tAy43sx8FG1LG2oA251zqnZX78F4AFJMrgVedcx3OuT7gAeDigGPKxsFUy23yY1G2IZrZh4ClwPud5sgPiBL+U1YDU8xsopmV4y3SeehNj9kDXAFgZtPxEv6OvEYZrIeADyan9SzGe6tzf9BB5YOZteDd+G9zzm0NOp58c85NdM5NcM5NwHsS/wvn3C8CDiufHgTebmYRM6sGFlFkixFLnZkZXu/4JufcN4KOJ1POuc8758Ym/4+9D/iNc66oKsvOuQPAXjOblvzSFcDGAEPKxh5gsZlVJ/9NXUFx/l9/CPhQ8vMP4d3DioqZXYv3bvqNzrmeoOMpdpGgAygUzrmYmf0V3gSSMPBd59wrZvZlYI1z7iHg74Bvmdnf4LWyfLiUXnGa2U+AdwCjkusUvgSUATjn7sFbt/BOYDvQA3wkmEhzL41r/1/ASLzKNkDMOdcaTLS5l8b1l7RzXb9zbpOZ/Rp4Ea+/+tvOubOOMJW8uwS4DXjJzNYnv/YPzrlHA4xpMPoUcG+ycLaTInuecM6tMrP7gLV4bSTrKPCpbGe4f30V+JmZfRTvRUxBTxY7wzV8HqgAHk8+7z7vnPtkYEEWOe20KyIiIiJSwtTSIyIiIiJSwpTwi4iIiIiUMCX8IiIiIiIlTAm/iIiIiEgJU8IvIiIiIlLClPCL5IiZHX/D5782sy4zeyTImERESkHq/mpmc8zsOTN7xcxeNLM/Djo2kWKgsZwiOWJmx51zNcnPrwCqgT9zzi0NNjIRkeKWur+a2VTAOee2mdkY4AVgunOuK+AQRQqaNt4SOQMzux3Y7Zy7K/n7f8LbcG0JUIe3MdMXnHNv2cHQOfekmb0jf9GKiBSPbO+vb9zp3Dm3z8zagXpACb/IWailR+TMlgFvfLv4vcB/A+9yzs0DLgO+ntx+XURE0jfg+6uZLQTKgR1+BipSClThFzkD59w6MxudfNu4HugE9gP/x8yWAAmgGWgADgQXqYhIcRno/dXMmoAfAh9yziXyF7lIcVLCL3J29wG3AI14Fan34z05zXfO9ZnZLqAyuPBERIpWVvdXMxsG/BKv5ef5/IUrUryU8Iuc3TLgW8Ao4FK8t53bk09GlwHjgwxORKSIZXx/NbNy4OfAD5xz/y+fwYoUMyX8ImfhnHvFzIYCrznn9pvZvcDDZrYGWA9sPt33mdkK4HygxszagI865x7LW+AiIgUuy/vre/EW9o40sw8nv/Zh59z6vAQtUqQ0llNEREREpIRpSo+IiIiISAlTwi8iIiIiUsKU8IuIiIiIlDAl/CIiIiIiJUwJv4iIiIhICVPCLyIiIiJSwpTwi4iIiIiUMCX8IiIiIiIl7P8DBmt9w/rNIT0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 762.25x720 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualizing the data with seabourne\n",
    "sns.pairplot(vars=[\"val1\",\"val2\"], data=df, hue='serie', height=5)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>serie</th>\n",
       "      <th>val1</th>\n",
       "      <th>val2</th>\n",
       "      <th>Test</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1.10</td>\n",
       "      <td>1.10</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1.30</td>\n",
       "      <td>1.30</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1.35</td>\n",
       "      <td>3.35</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>1.10</td>\n",
       "      <td>4.10</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>1.05</td>\n",
       "      <td>7.10</td>\n",
       "      <td>1.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1</td>\n",
       "      <td>1.10</td>\n",
       "      <td>7.90</td>\n",
       "      <td>0.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1</td>\n",
       "      <td>1.30</td>\n",
       "      <td>9.90</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   serie  val1  val2  Test\n",
       "0      1  1.10  1.10   0.0\n",
       "1      1  1.30  1.30   0.0\n",
       "2      1  1.35  3.35   0.0\n",
       "3      1  1.10  4.10   0.0\n",
       "4      1  1.05  7.10   1.3\n",
       "5      1  1.10  7.90   0.9\n",
       "6      1  1.30  9.90   0.5"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This cell shows the problem with a new variable \n",
    "# being the memory pointer and not a new copy\n",
    "df_temp=df\n",
    "df_temp\n",
    "df_temp.serie=1\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming tasks\n",
    "Programming tasks:\n",
    "1. Write a function that prints \"Hello world\"\n",
    "2. Calculate and show the square of the first 10 integers. $N^2$\n",
    "3. Estimate pi (throw some arrows)\n",
    "4. Show the line $2*x^2+2$ from x=-5 to x=20\n",
    "4. Estimate area under curve \n",
    "5. Estimate the slope of curve $2*x+1$\n",
    "6. Estimate the slope of the curve $2*x^2+2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}