{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Jupyter Notebooks and Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`````{admonition} Try it yourself with the Jupyter notebook\n",
    ":class: tip\n",
    "Note that exercises such as this one correspond to a Jupyter Notebook that you can run yourself (rather than just looking at the static version shown here). You are highly encouraged to download the source files of the lecture notes such that you can perform the exercises interactively.\n",
    "`````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Jupyter Notebook is a powerful tool for interactively developing and presenting data and computational science projects. Jupyter Notebooks integrate markdown text notes, mathematical equations, interactive code cells and their output into a single document. \n",
    "\n",
    "This step-by-step workflow promotes fast, iterative development since each output of your code will be displayed right away. That’s why notebooks have become increasingly popular in data science and for explorative computational projects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For serious code development projects, however, the Jupyter Notebook format does have some serious drawbacks and should be avoided."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This exercise offers a tour of the use of Python in Jupyter notebooks to get started doing data analysis.  You'll learn more features and details as you proceed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`````{admonition} The Jupyter notebook Help menu\n",
    ":class: tip\n",
    "You can find valuable documentation under the Jupyter notebook Help menu. The \"User Interface Tour\" and \"Keyboard Shortcuts\" are useful places to start, but there are also many other links to documentation there.\n",
    "`````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code and Markdown cells\n",
    "\n",
    "The notebook consists of *cells*, of which two types are relevant for us:\n",
    "* Markdown cells: These have headings, text, and mathematical formulas in $\\LaTeX$ using a simple form of HTML called markdown.\n",
    "* Code cells: These have Python code (or other languages, but we'll stick to Python).\n",
    "\n",
    "Either type of cell can be selected with your cursor and will be highlighted in color when active.  You evaluate an active cell with shift-return (as with Mathematica) or by pressing `Run` on the toolbar.  Some notes:\n",
    "* When a new cell is inserted, by default it is a Code cell and will have `In []:` in front.  You can type Python expressions or entire programs in a cell.  How you break up code between cells is your choice and you can always put Markdown cells in between.  When you evaluate a cell it gets the evaluation number, e.g., `In [5]:`.\n",
    "* The output of an evaluated cell will be presented in an **Output cell** that is preceeded by, e.g., `Out [5]:` where `5` is the evaluation number. This cell cannot be edited. It will be updated if the cell is evaluated again.\n",
    "* On the menu bar is a pulldown menu that lets you change back and forth between Code and Markdown cells.  Once you evaluate a Markdown cell, it gets formatted (and has a blue border).  To edit the Markdown cell, double click in it. \n",
    "\n",
    "**Try double-clicking on this cell and then shift-return.**  You will see that a bullet list is created just with an asterisk and a space at the beginning of lines (without the space you get *italics* and with two asterisks you get **bold**).  \n",
    "\n",
    "**Double click on the title header at the start of this exercise Notebook and you'll see it starts with a single #.**  Headings of subsections are made using ## or ###."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`````{admonition} The Markdown language\n",
    ":class: tip\n",
    "See this [Markdown cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) for a quick tour of the Markdown language (including how to add links!).\n",
    "``````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Now try turning the next (empty) cell to a Markdown cell and type:** `Einstein says $E=mc^2$` **and then evaluate it.**  This is $\\LaTeX$! (If you forget to convert to Markdown and get `SyntaxError: invalid syntax`, just select the cell and convert to Markdown with the menu.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Jupyter Notebook menu and shortcuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The menus enable you to rename your notebook file (always ending in `.ipynb`) or `Save and Checkpoint` to save the changes to your notebook.  You can insert and delete cells (use the up and down arrows in the toolbar to easily move cells).  You will often use the `Kernel` menu to `Restart` the notebook (and possibly clear output). The buttons below the menu allow quick access to several useful commands. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The help menu gives you direct access to important documentation. You’ll be able to learn about all the Jupyter Notebook shortcuts to speed up your workflow. You also get convenient links to the Notebook and Markdown help pages, and to the documentation of some of the most important Python libraries including `Numpy`, `Scipy`, `Matplotlib`, and `Pandas`!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you get more proficient working with notebooks, you will certainly start using the shortcut keys from the command mode of cells. A cell that is marked in blue implies that you are in command mode. You can start editing the cell by hitting `Enter` (or by clicking inside it). You can exit from edit mode into command mode by hitting `Esc`. A list of shortcut keys can be seen when opening the command palette by clicking on the keyboard button."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``````{admonition} Useful Notebook shortcuts\n",
    ":class: tip\n",
    "In addition to the `Esc` and `Enter` keys, the use of `A` and `B` to insert new cells *above* or *below* the current one, or the use of `Y` and `C` to switch between *code* and *markdown* cell types, are some particularly useful shortcuts.\n",
    "``````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python expressions and strings\n",
    "\n",
    "We can use the Jupyter notebook as a super calculator much like Mathematica and Matlab.  **Try some basic operations, modifying and evaluating the following cells, noting that exponentiation is with** `**` **and not** `^`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " 1 + 1  # Everything after a number sign / pound sign / hashtag) \n",
    "        # in a code cell is a comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.081600000000002"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.2 * 4.713"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that if we want a floating point number (which will be the same as a `double` in C++), we *always* include a decimal point (even when we don't have to) while a number without a decimal point is an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define integer, floating point, and string variables, perform operations on them, and print them.  Note that we don't have to predefine the type of a variable and we can use underscores in the names (unlike Mathematica).  **Evaluate the following cells and then try your own versions.** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5.\n",
    "print(x)\n",
    "x   # If the last line of a cell returns a value, it is printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y =  72.0\n"
     ]
    }
   ],
   "source": [
    "y = 3.*x**2 - 2.*x + 7.\n",
    "print('y = ', y)           # Strings delimited by ' 's"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several ways to print strings that includes variables from your code. We recommend using the relatively newly added `fstring`. See, e.g., this [blog](https://towardsdatascience.com/a-simple-guide-to-string-formatting-in-python-using-f-strings-39e5c39589c3) for examples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 72\n",
      "y = 72.00\n"
     ]
    }
   ],
   "source": [
    "print(f'y = {y:.0f}')      # Just a preview: more on format later \n",
    "print(f'y = {y:.2f}')      # ...showing more decimals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `fstring` will be used predominantly in this course, but you might also encounter older formatting syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 5.00  y = 72.00\n",
      "x = 5.00  y = 72.00\n",
      "x = 5.00  y = 72.00\n"
     ]
    }
   ],
   "source": [
    "print('x = %.2f  y = %.2f' %(x,y)) \n",
    "print('x = {0:.2f}  y = {1:.2f}'.format(x, y)) \n",
    "print(f'x = {x:.2f}  y = {y:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Emilia Student\n",
      "Emilia Student\n"
     ]
    }
   ],
   "source": [
    "first_name = 'Emilia'     # Strings delimited by ' 's\n",
    "last_name = 'Student'\n",
    "full_name = first_name + ' ' + last_name  # you can concatenate strings \n",
    "print(full_name)\n",
    "# or\n",
    "print(f'{first_name} {last_name}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mathematical functions with `numpy`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, how about square roots and trigonometric functions and ... \n",
    "\n",
    "*(Note: the next two cells will give error messages --- keep reading to see how to fix them.)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sqrt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-66e338417901>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'sqrt' is not defined"
     ]
    }
   ],
   "source": [
    "sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sin' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-69d9a90af4a5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'sin' is not defined"
     ]
    }
   ],
   "source": [
    "sin(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to `import` these functions through the NumPy library. There are other choices, but NumPy works with the arrays that we often will use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``````{admonition} Always import libraries into their own namespace\n",
    ":class: tip\n",
    "*Never* use \n",
    "`from numpy import *` \n",
    "as it will eventually lead to conflicts in your namespace of functions. \n",
    "\n",
    "Instead you should import libraries into their own namespace through \n",
    "`import numpy as np` \n",
    "Here `np` is just a abbreviation for numpy (which we can choose to be anything, but `np` is conventional).\n",
    "``````"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(np.cos(0.))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now functions and constants like `np.sqrt` and `np.pi` will work.  Go back and fix the square root and sine."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging aside . . .\n",
    "\n",
    "Suppose you try to import and it fails \n",
    "\n",
    "*go ahead and evaluate the cell*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you get a `ModuleNotFoundError`, the first thing to check is whether you have misspelled the name. Try using Google, e.g., search for \"python numpie\". In this case (and in most others), Google will suggest the correct name (here it is numpy).  If the name does exist, check whether it sounds like the package you wanted.\n",
    "\n",
    "If you have the correct spelling, check whether you have installed the relevant package.  If you installed Python with `conda`, then use `conda list`, e.g., `conda list numpy` in a Terminal window (on a Mac or Linux box) or in an Anaconda Prompt window (on a Windows PC)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `numpy` arrays\n",
    "\n",
    "The NumPy library is extremely useful and its linear algebra features will be covered in more depth in a separate exercise Notebook. However, here we already introduce `numpy` *arrays*, which will be featured extensively.  They are similar to Python `list`s but much more powerful for scientific computations. Here, as an example, we construct them with `np.arange(min, max, step)` to get an array from `min` to `max` in steps of `step`. Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1, 1.2,\n",
       "       1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. , 2.1, 2.2, 2.3, 2.4, 2.5,\n",
       "       2.6, 2.7, 2.8, 2.9, 3. , 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8,\n",
       "       3.9, 4. , 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5. , 5.1,\n",
       "       5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6. , 6.1, 6.2, 6.3, 6.4,\n",
       "       6.5, 6.6, 6.7, 6.8, 6.9, 7. , 7.1, 7.2, 7.3, 7.4, 7.5, 7.6, 7.7,\n",
       "       7.8, 7.9, 8. , 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9, 9. ,\n",
       "       9.1, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 9.8, 9.9])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t_pts = np.arange(0., 10., .1)\n",
    "t_pts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we give a `numpy` array to a function, each term in the list is evaluated with that function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3. 4.]\n",
      "[ 1.  4.  9. 16.]\n",
      "[1.         1.41421356 1.73205081 2.        ]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(1., 5., 1.)\n",
    "print(x)\n",
    "print(x**2)\n",
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can pick out elements of the list.  Why does the last one fail? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "4.0\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "index 4 is out of bounds for axis 0 with size 4",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-1537e26dd1f1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: index 4 is out of bounds for axis 0 with size 4"
     ]
    }
   ],
   "source": [
    "print(x[0])\n",
    "print(x[3])\n",
    "print(x[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``````{admonition} Zero-based numbering\n",
    ":class: tip\n",
    "Note the use of zero-based numbering in Python.\n",
    "``````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting help\n",
    "\n",
    "You will often need help identifying the appropriate Python (or NumPy or SciPy or ...) command or you will need an example of how to do something or you may get an error message you can't figure out.  In all of these cases, Google (or equivalent) is your friend. Always include \"python\" in the search string (or \"numpy\" or \"matplotlib\" or ...) to avoid getting results for a different language. You will usually get an online manual as one of the first responses if you ask about a function; these usually have examples if you scroll down. Otherwise, responses to *Stack Overflow* queries are your best bet to find a useful answer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "There are many Python language features that we will use eventually. We will definitely need to be able to create functions. Note that these are usually referred to as *methods* in Python to stress that they don't need to correspond to mathematical operations that return some output that is computed given some input. Sometimes a *method* just performs some tasks such as creating and saving a figure. We will use both names (functions and methods) in these notes.  \n",
    "\n",
    "When defining functions (methods), we note the role of *indentation* in Python as opposed to {}s or ()s used in other programming languages.  We'll always indent four spaces (never tabs!).  We know a function definition is complete when the indentation stops. The Jupyter Notebook also works as some sort of IDE (integrated development environment) as it will assist you with proper indentation and formating. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``````{admonition} Shift-Tab help text\n",
    ":class: tip\n",
    "To read the manual (docstring) of a Python function, put your cursor on the function name and hit `Shift+Tab` or `Shift+Tab+Tab`. **Go back and try it on `np.arange`.**  \n",
    "``````"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.0\n",
      "[ 1.  4.  9. 16. 25. 36. 49. 64. 81.]\n"
     ]
    }
   ],
   "source": [
    "# Use \"def\" to create new functions.  \n",
    "#  Note the colon and indentation (4 spaces).\n",
    "def my_function(x):\n",
    "    \"\"\"This function squares the input.  Always include a brief description\n",
    "        at the top between three starting and three ending quotes.  We will\n",
    "        talk more about proper documentation later.\n",
    "        Try shift+Tab+Tab after you have evaluated this function.\n",
    "    \"\"\"\n",
    "    return x**2\n",
    "\n",
    "print(my_function(5.))\n",
    "\n",
    "# We can pass an array to the function and it is evaluated term-by-term.\n",
    "x_pts = np.arange(1.,10.,1.)\n",
    "print(my_function(x_pts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 5 and y is 6\n",
      "The sum is  11\n",
      "x is 5 and y is 6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Two variables, with a default for the second\n",
    "def add(x, y=4.):\n",
    "    \"\"\"Add two numbers.\"\"\"\n",
    "    print(\"x is {} and y is {}\".format(x, y))\n",
    "    return x + y  # Return values with a return statement\n",
    "\n",
    "# Calling functions with parameters\n",
    "print('The sum is ', add(5, 6))  # => prints out \"x is 5 and y is 6\" and returns 11\n",
    "\n",
    "# Another way to call functions is with keyword arguments\n",
    "add(y=6, x=5)  # Keyword arguments can arrive in any order.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How do you explain the following result?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 2 and y is 4.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging aside . . .\n",
    "\n",
    "There are two bugs in the following function.  **Note the line where an error is first reported and fix the bugs sequentially (so you see the different error messages).**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-24-da90ff702907>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-24-da90ff702907>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def hello_function()\u001b[0m\n\u001b[0m                        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def hello_function()\n",
    "    msg = \"hello, world!\"\n",
    "    print(msg)\n",
    "     return msg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting with Matplotlib\n",
    "\n",
    "Matplotlib is the plotting library we'll use.  We'll follow convention and abbreviate the module we need as `plt`.  \n",
    "\n",
    "The `%matplotlib inline` is a Jupyter Notebook built-in *magic* command that produces inline plots, i.e. the plot is shown in the Output cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Procedure we'll use to make the skeleton plot:\n",
    "\n",
    "1. Generate some data to plot in the form of arrays.\n",
    "1. Create a figure;\n",
    "1. add one or more subplots;\n",
    "1. make a plot and display it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff4c6b6ad10>]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "t_pts = np.arange(0., 10., .1)     # step 1.\n",
    "x_pts = np.sin(t_pts)  # More often this would be from a function \n",
    "                       #  *we* write.\n",
    "\n",
    "my_fig = plt.figure()              # step 2.\n",
    "my_ax = my_fig.add_subplot(1,1,1)  # step 3: rows=1, cols=1, 1st subplot\n",
    "my_ax.plot(t_pts, x_pts)           # step 4: plot x vs. t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTE: When making just a single plot, you will more usually see steps 2 to 4 compressed into `plt.plot(t_pts, np.sin(t_pts))`.  Don't do this.  It saves a couple of lines but restricts your ability to easily extend the plot, which is what we want to make easy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can always go back and dress up the plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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": [
    "my_fig = plt.figure()\n",
    "my_ax = my_fig.add_subplot(1,1,1)  # nrows=1, ncols=1, first plot\n",
    "my_ax.plot(t_pts, x_pts, color='blue', linestyle='--', label='sine')\n",
    "\n",
    "my_ax.set_xlabel('t')\n",
    "my_ax.set_ylabel(r'$\\sin(t)$')  # here $s to get LaTeX and r to render it\n",
    "my_ax.set_title('Sine wave')\n",
    "\n",
    "# here we'll put the function in the call to plot!\n",
    "my_ax.plot(t_pts, np.cos(t_pts), label='cosine')  # just label the plot\n",
    "\n",
    "my_ax.legend();  # turn on legend\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now make two subplots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAEvCAYAAADmeK3JAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB4/0lEQVR4nO3dd3ydddn48c+VvXfSZnTvdKVtOmgZhTLKkIIMQYWiIrIU8VEB9XkUBUUflUdEQJbAT/aSVfZu6d57rzRpk2bvcc7398d9Tpum2Tnn3HeS6/16xST3uceVGr7nyndcXzHGoJRSSimlAi/I7gCUUkoppforTcSUUkoppWyiiZhSSimllE00EVNKKaWUsokmYkoppZRSNtFETCmllFLKJiF2B9AdKSkpZujQoXaHoZQKoNWrVx81xqTaHUdPafulVP/TXvvVKxOxoUOHsmrVKrvDUEoFkIjstzsGX9D2S6n+p732S4cmlVJKKaVsoomYUkoppZRNNBFTSimllLJJr5wjppRSfUljYyN5eXnU1dXZHUq/EhERQVZWFqGhoXaHovoxTcSUUspmeXl5xMbGMnToUETE7nD6BWMMxcXF5OXlMWzYMLvDUf2YDk0qpZTN6urqSE5O1iQsgESE5ORk7YVUttNETCnVJ4nIIBH5VES2ishmEbnNczxJRD4UkZ2ez4nNrrlLRHaJyHYROa/Z8WkistHz2gPiyZhEJFxEXvQcXy4iQ3sQbw9+WtUd+m+unMAniZiIPCkihSKyqY3XxdN47RKRDSIytdlr8z2N3i4RudMX8SilFNAE/JcxZhwwC7hFRLKBO4GPjTGjgI893+N57SpgPDAfeEhEgj33ehi4ARjl+ZjvOf49oNQYMxK4H/hjIH6w/qysrIyHHnro2Pf5+flcfvnl7V6zb98+JkyY4O/QlOoWX/WIPcXxhqk153O8AbsBq1HD08j9w/N6NnC1pzFUSqkeMcYUGGPWeL6uBLYCmcAC4GnPaU8Dl3i+XgC8YIypN8bsBXYBM0QkHYgzxiw1xhjgmRbXeO/1CjBPtJvFr1omYhkZGbzyyis2RqRUz/gkETPGfAGUtHPKAuAZY1kGJHgatxnALmPMHmNMA/CC51yfKK1u4Jml+9hdVIXVftrryBFYvhz+8x/Iy7M7GtUZxhgKK+v4cmcRn2w7Ql2jy+6QqKqCpUvh88/h4EG7o+kdPEOGU4DlwABjTAFYyRqQ5jktE2j+L5rnOZbp+brl8ROuMcY0AeVAcivPv0FEVonIqqKiIh/9VL7373//mxkzZpCTk8MPfvADli9fzqRJk6irq6O6uprx48ezadMmPvvsM04//XQuvfRSsrOzufHGG3G73QA8//zzTJw4kQkTJnDHHXccu3dMTAy//OUvmTx5MrNmzeLIkSMAFBUVcdlllzF9+nSmT5/OkiVLAPjNb37Dd7/7XebOncvw4cN54IEHALjzzjvZvXs3OTk5/OxnPzuht2vfvn2cdtppTJ06lalTp/LVV18F8p9P9RMHS2p4fsUBSqobfHK/QK2abK+Ba3l8Zms3EJEbsHrTGDx4cKceumJfCf/zxmYA0uMjuOH04Vw3O/CrkgoL4fbb4bnnjh/70Y/gb38LaBiqizYdKuenL69n2+HKY8diw0M4f+JAfnbeWFJjwwMaT2MjPPoo3H03eN/L//pX63fL5QIRCNJZnycRkRjgVeDHxpiKdv77b+0F087x9q458YAxjwKPAuTm5tr/V2Ertm7dyosvvsiSJUsIDQ3l5ptvZvv27Vx88cX86le/ora2lm9/+9tMmDCBzz77jBUrVrBlyxaGDBnC/Pnzee2115g9ezZ33HEHq1evJjExkXPPPZf//Oc/XHLJJVRXVzNr1izuvfdefv7zn/PYY4/xq1/9ittuu43bb7+dU089lQMHDnDeeeexdetWALZt28ann35KZWUlY8aM4aabbuK+++5j06ZNrFu3DrCSL6+0tDQ+/PBDIiIi2LlzJ1dffbVuJ6V8bs2BUu56bSPThyaSFB3W4/sFKhHrTgN34sFuNGTnjR/IFz87k8W7jvL2hnzufmsL6w6Wcd/XJxEZFtzxDXzAGLjgAtiwAe68E+bMgaQk8O75u24d7NsHl1wSkHBUJxhj+OcXe/jLB9tJig7jVxeOIzs9jka34c11+byxLp+le4p56jszGJEaE5CYGhth5kxYuxbmzoXbboP4eBg1ynr9qafgvffg+echRIvSHCMioVhJ2LPGmNc8h4+ISLoxpsDTM1/oOZ4HDGp2eRaQ7zme1crx5tfkiUgIEE/7owMduvutzWzJr+jJLU6SnRHHr782vt1zPv74Y1avXs306dMBqK2tJS0tjf/5n/9h+vTpREREHOuVApgxYwbDhw8H4Oqrr2bx4sWEhoYyd+5cUlOtvY2/9a1v8cUXX3DJJZcQFhbGRRddBMC0adP48MMPAfjoo4/YsmXLsftWVFRQWWn98XPhhRcSHh5OeHg4aWlpx3rR2tLY2Mitt97KunXrCA4OZseOHV35Z1KqUwor6gFIjY3wyf0C1WS31cCFtXHcZwYnR/HN5MFcNX0QD322i798uIN9xTW8eMMsIkL9n4yJWD1fCQkwvpV28Ne/hnfegX/9C665xu/hqE74x6e7+PMHOzh/wkB+f+lEEpv9xXPG6FSuPWUI331qJZc9/BVPXjedqYMT27mbb4SGws9/DmFhcOml1u9Vc3V18Mor1uvPPAPBgfk7w9E8c7WeALYaY/7a7KU3gYXAfZ7PbzQ7/pyI/BXIwJrTusIY4xKRShGZhTW0eS3w9xb3WgpcDnxinDAPohuMMSxcuJA//OEPJxw/fPgwVVVVNDY2UldXR3R0NHDyikMRaXcKSGho6LFrgoODaWpqAsDtdrN06VIiIyNPuiY8/Hivc/Nr2nL//fczYMAA1q9fj9vtJiLCN2+USjVXWFlHRGgQcRG+SaEClYi9CdwqIi9gDT2We/4aLQJGicgw4BDWiqVv+iOAoCDh1rNGMSI1hpueXcPdb23mD1+f5I9HAbBzJ7z8Mtx1l9UL1pZnn4UFC2DhQsjMhLPO8ltIqhM+2HyYP3+wg0tyMrj/GzmtDmNPHpTA6zfP4dtPLOfG/7ea9358uk+6p1tTXw9r1sApp8BVV7V93i23QGWl9fsWEwP//Kdfwult5gDXABtFZJ3n2C+wErCXROR7wAHgCgBjzGYReQnYgrXi8hZjjHdS4E1Yi5IigXc9H2Alev9PRHZh9YS18/9S53TUc+Uv8+bNY8GCBdx+++2kpaVRUlJCZWUlP/zhD/nd737H3r17ueOOO3jwwQcBWLFiBXv37mXIkCG8+OKL3HDDDcycOZPbbruNo0ePkpiYyPPPP88Pf/jDdp977rnn8uCDD/Kzn/0MgHXr1pGTk9Pm+bGxscd6zFoqLy8nKyuLoKAgnn76aVwu++d0qr6nsLKetNgIn01z8kkiJiLPA3OBFBHJA34NhAIYYx4BFgEXYK1CqgG+43mtSURuBd4HgoEnjTGbfRFTW86fmM5Nc0fw8Ge7mT40ia9Pzer4oi6qrYWLLoKSEvjOdyA9ve1zY2LgrbdgyhTr3A0brCEnFXg7j1Ry+4vrmJQVz32XTWr3P7LByVE8/O2pXPqPr7jj1Q08es00v8w9/N3v4H//F3bvhqwOflXvvBNKS+FPf4ILL4SLL/Z5OL2KMWYxrU9/AJjXxjX3Ave2cnwVcFL9A2NMHZ5ErrfLzs7mnnvu4dxzz8XtdhMaGsqCBQsICQnhm9/8Ji6Xi9mzZ/PJJ58QFBTEKaecwp133snGjRuPTdwPCgriD3/4A2eeeSbGGC644AIWLGh//dUDDzzALbfcwqRJk2hqauL000/nkUceafP85ORk5syZw4QJEzj//PO55ZZbjr128803c9lll/Hyyy9z5plnHuu9U8qXjlTUkebLOcLGmF73MW3aNNMTjU0uc+UjX5mxv3rX7C2q6tG9WvM//2MMGPPRR52/ZtkyY4KCjPntb30ejuoEt9ttvv7QEjP1tx+YgrLaTl/32Be7zZA73jb/XrbP5zFt3GhMSIgx117b+Wvq642ZOtWYv/zF5+HYDlhlHND+9PSjtfZry5YtPf8HCqBPP/3UXHjhhXaH4RO97d9e2e/MP39qbv736i5d01771S/XWIUEB/HA1VMQgT+9v82n9969G/74R7j6apjX6t/crZs5Ez7+2BpaUoH35vp8Vu8v5Y75YxkY3/l5Jd+dM4zTRqVwz9tbKaz03VYpbjf84AdW7+hf/tL568LCYNky+MlPfBaKUkqpZooq6n26ar5fJmIAA+KschaLNh5m9f5Sn9339tutidV//nPXr50711rxVlVlvRGrwKhpaOK+d7cxMTOey6d1bag6KEj47YIJNLjcPPTpbp/F9MQT8NVXVhKWktK1a0NDrdW6H3xgDXUr5Wtz587l7bfftjsMpQKupqGJyvom0uI0EfOJ7582nNTYcP6waKvPCr7+8pdWraeMjO5dv2MHDB9uTfRXgfHI53soKK/j11/LJiio6/O8hqVEc2VuFs8u38/BkhqfxFReDvPnw7XXdu/6mhqrV/aXv/RJOEoppTheumKAj0pXQD9PxKLDQ7j97NGs2l/K+5vbr0/TWTNnWm+A3TVyJKSlwW9+YxXpVP5VXtPI41/u4cJJ6eQOTer2fX40bxQiwt8+3umTuH76U1i06OQyFZ0VHW31zr79tlV7TDmfr/4YVJ2n/+aqqworrURMe8R86MrcLIalRPPw5z0bVlq5Em688XjF8+4KCrIqp2/bZhXnVP713IoD1DS4uGXuyB7dJz0+kmtnDeG1NXnsLqrq9n1cLmuuoDHdT8K8fvhDa47Z737Xs/so/4uIiKC4uFgTgwAyxlBcXKy1xlSXHKmw5gKn+bBHrN/X4A4JDuK62UP59ZubWXuglCndLM75xz/CRx9ZpQZ66tJLYfJkuPde+Na3ev6GrFrX0OTmqa/2MmdkMtkZcT2+341zR/DM0v08/dU+frvgpEoHnfLSS/DNb8L778O55/Ysnvh4ayut3/0ONm6EiRN7dj/lP1lZWeTl5eHkfSj7ooiICLI6qgujVDPeHrEBPuwR6/eJGMBl07L48/vb+deSfd1KxHbuhNdes+o4xcb2PJ6gIGvV28KF1ubOs2f3/J7qZG9vyOdIRT33Xeabwr4pMeFcNCmd19Yc4ufzxxIT3rX/vIyBP/wBsrPh7LN9EhI//jG8+irs2aOJmJOFhoYybNgwu8NQSnWgsKKOsJAg4iNDfXbPfj80CRATHsKV0wexaGMBh8u7XoLg/vutsgE/+pHvYrriCliyxKqornzPGMNjX+5lVFoMc0en+uy+15wyhKr6Jl5fk9fla5cts3qubr/dd5t3JyXBpk3W7g1KKaV6prCyntSYcJ8W8NZEzGPhKUNxGcO/l+3v0nW1tfDcc3DllTBwoO/iiYy0esJ0WNI/Vu0vZWtBBdefNsyn/0HlDEpgYmY8zyzd3+X5Po8/bu200N5WRt0hYm0avm+fb++rlFL9TWFlnU+HJUETsWMGJ0cxb+wAXlh5gEZX54t4VVdbc3q+/33fx+RywU03WT1uyrdeWZVHdFgwX5vczTojbRARrj1lCDsLq1i6p7jT17lc8MUXVhIWE+PTkABry61LLrGGP5VSSnXPkYp6n07UB03ETnBlbhZHqxpYvPNop69JSYGHHoLTTvN9PMHBsGsX/N//aSkLX6ptcPHOxgLOn5hOVJjvp0l+bXIGCVGhPL/iYKevCQ6GLVusfSL94ZJLYP16WLXKP/dXSqn+oLCizqelK0ATsRPMHZNGQlQor6891KnzDx+25nH5s5fhhhvgwAH49FP/PaO/+WDLYarqm7jMDxu+A0SEBnPRpHQ+2nKE6vqmTl3jdlsV8RO7t2i3Q9/8JkRFwWOP+ef+SinV19U1uqioa2JAnPaI+U1YSBAXTUo/9kbdkcceg1NPhYOd7/jososuslZivvCC/57R37yyOo/MhEhmDut+AdeOLMjJpLbRxYdbOi4UvGkTDBlirZD1l/h4ax7jCy9Ane+2xFRKqX7DW1Xfl/tMgiZiJ7l0SiZ1jW7e23S43fOMgaeegrPOgsGD/RdPZKQ1rPTqq1Bf77/n9BeHy+tYsusol03N7NZ2Rp01bXAimQmRvLGu497VF1+E/HwYMcJv4QDW/LPKSqvenVJKqa4prPQWc9VEzK+mDk5kcFIU/+lgeHL1aqs207e/7f+YrrvOKuxaXe3/Z/V1b6w7hNvA1/00LOkVFCR8bXIGX+w8SnFV2xm0MVYR17lzra2t/Omss6wFARdc4N/nKKVUX3S8mKsOTfqViHDJlEyW7D56bCuD1rz6KoSEBKY+01lnwYMPWjWhVM8s2nSYSVnxDE2J9vuzFuRk4HIbFrXTu7pxo7XR+xVX+D0cQkOtRSW+qlGmlFL9yfHtjbRHzO8unpyOMfDB5rbfQD/6CM48M3DJkdttLQyoqQnM8/qigvJa1h8s47zxPiz41o6xA2MZPSCGN9sZnnz5ZSsx+vrXAxIS5eVw223WFkpKKaU6r7CynpAgITEqzKf31USsFSPTYhmeEs0H7Uy0XrIEnnwycDEtXmwtDHj77cA9s6/5YLP1/+f8CYFJxESEiyZlsGp/6bG5BS3Nmwf33OP/YUmv6GirAPFTTwXmeUop1VcUVtSTGhvu8/nFmoi14ZzxA1i6u5jy2sZWXw8Lg0DuFTtnDqSmwn/+E7hn9jXvbTrMyLQYRqT6oWJqG87JHoAx8Om2wlZfnzsX7rorYOEQEgKXXQZvvWXtCqGUUqpzjlTUMTDet/PDQBOxNp2bPZAmt+Gz7Se/gX796/CvfwU2nuBga5L1u+9a29WorimpbmDFvhLmB2hY0mvswFgyEyL5cMvJv0effQabNwc0HAAuv9xa+PHhh4F/tlJK9VYF5bWkayIWOFMGJZASE37S8OSOHfD661YZgED72tegrMwaFlVd89HWI7jcJmDzw7xEhHOyB7B4VxG1DSduj/Bf/wU33hjQcAA4/XSrNt077wT+2Uop1RsZYygor2NgXKTP7+2TRExE5ovIdhHZJSJ3tvL6z0Rknedjk4i4RCTJ89o+Ednoec0xG7AEBQnnZKfx2bZC6puOv4G+9Zb1+ZJLAh/TuedaQ6KLFgX+2b3d+5sOk5kQyYTMuIA/++xxA6hrdLNk1/GtswoKYM0auPDCgIdDWJhVaT8+PvDPDjQReVJECkVkU7NjLzZrj/aJyDrP8aEiUtvstUeaXTPN007tEpEHxLNTvIiEe+63S0SWi8jQQP+MSin/q6xvoqbB5cweMREJBv4BnA9kA1eLSHbzc4wx/2uMyTHG5AB3AZ8bY0qanXKm5/XcnsbjS+dmD6S6wcVXu49v3rxoEYwf798irm2JjbV6w373u8A/uzera3SxZPdRzskegOf9M6BmDEsiNjyEj7Ye7119913rs101vR55xH/7WjrMU8D85geMMd9o1h69CrzW7OXd3teMMc37Kx8GbgBGeT689/weUGqMGQncD/zRLz+FUspWh8utBVdOnSM2A9hljNljjGkAXgDaq651NfC8D57rd6eMSCYqLJiPPW+glZXw5Zdw/vn2xZSbC+G+LWHS563YW0Jdo5szxqTa8vywkCDOGJPKR1sLcbutjUnfecda7DFxoi0hAVYx2dJS+54fCMaYL4CS1l7z9GpdSQftkYikA3HGmKXGGAM8A1zieXkB8LTn61eAeWJHtq+U8qsCTyLmyB4xIBNovttinufYSUQkCusvyVebHTbAByKyWkRu8EE8PhMRGswpw5P5Yoc1pFRWZg1JBqKIa1tcLvjFL+DZZ+2Lobf5fEcRYSFBzBqWbFsM52QP4GhVPevyynC5jle4t/Mt++tf7/dV9k8DjhhjdjY7NkxE1orI5yJymudYJla75tW8jTvW/hljmoBy4KRfNBG5QURWiciqoqIiX/8cSik/O1xuLTN3ao9Ya28lpo1zvwYsaTEsOccYMxVraPMWETm91YfY1JCdPjqVAyU17DtazaBB1nY0p54asMefJDjYqiX2+OP2xdDbfL6jiJnDkogMC7YthtNHpSICX+44SnAw7N0Ld99tWzgA5OTA8uXQj/OClr3zBcBgY8wU4CfAcyISR/ttXKfaP2PMo8aYXGNMbmqqPT2zSqnuKyivQwTSYp2ZiOUBg5p9nwXkt3HuVbQYBjDG5Hs+FwKvYw11nsSuhuz00dazPt9RxP79AXtsu+bPt+aKVVXZHYnz5ZXWsKuwirljAlQxtQ2J0WFMzIxn8S4r64mJgYGBXcB5kosusoYn33vP3jjsICIhwNeBF73HjDH1xphiz9ergd3AaKw2rnnVwOZt3LH2z3PPeNoYClVK9V6Hy+tIiQknLMT3xSZ8cceVwCgRGSYiYVjJ1pstTxKReOAM4I1mx6JFJNb7NXAusKnltXYamhzFoKRI3l1zlKFDrarkdjvnHKuW2Jdf2h2J83mHlc8YbX8vxGmjUlhzoIwrv9XI8w6YJTllCgwY0G+3Ozob2GaMOTbkKCKpnsVHiMhwrEn5e4wxBUCliMzyzP+6luPt2JvAQs/XlwOfeOaRKaX6kPzyOr/MDwMfJGKeeRG3Au8DW4GXjDGbReRGEWm+6uhS4ANjTHWzYwOAxSKyHlgBvGOMcdTf5yLC6aNSWX3oKAS5Oe20jq/xt1NPtSbsa0HOjn2+o5DMhEhGpPp/k++OnDoyFZfb8PaKYgoK7I7G2uPyrLOsfVP7auogIs8DS4ExIpInIt/zvHRS7zxwOrDB0x69AtzYbBrFTcDjwC6snjLPuleeAJJFZBfWcOZJ5XuUUr3f4fJaBsb5JxEL8cVNjDGLgEUtjj3S4vunsJaSNz+2B5jsixj86fTRqTy7/ABj5pQyaJB9E769IiOtYSVdm9W+hiY3S3YVc3FOhi1lK1qaOiSBMAkmYuhR5s2zeVzS45ZbrEn7Lpe1/VFfY4y5uo3j17Vy7FVOXEjU/LVVwIRWjtcBV/QsSqWU0xWU13HKcP+8//fBptf3cgclY9zCoOlFtLIgyhavvGJ3BM63Pq+MqvomTh9l/7AkQHhIMDG1SdSNPGpr2Yrm5syxOwKllHK2qvomKuuaGBjv+6r6oFscdcqW9aHUH0qgLuFoxycHmO472bavdhUjgt/+iukqY6BoYypB8dUcKquxO5xjNm+G117r+DyllOqPvMVcMxIcOkesPxg/Hi6YlkJedTnltc7JfObOheuvtzsK51q65yjjM+KIjwq1OxTAKgg8KjYFgMW7nJPU//3vcN110NRkdyRKKeU8x6rq+2mOmCZinZCUBDdckowBVu51zsr0gQP79kTrnqhrdLHmQJljesMA4uLg49djGBgX4ahE7OyzrSRx5Uq7I1FKKecp8BRzTdehSXvU1Fg9BmnBCYSHBLF0T3HHFwXIvHmQnw/bttkdifOs2V9KQ5ObU0Y4JxGrqbFW4c4cnsTyPSU4pcrBmWdaCz8++sjuSJRSynm8PWJpcf7ZX1ATsQ4sWQI/+hHs2BrM1MGJLHNQIjZ3rvX5889tDcORlu4pJjhImD40ye5QAGtV4qBB8Otfw6zhyRytqmfP0eqOLwyA5GSrppgmYkopdbKCijqSo8OICPXP7iyaiHXgk0+sZf2nnmq9gW4pqKC8xhnzxEaOhPR0a99CdaKlu4uZmBlPbIQz5oetXQslJTBmDMwcZiWHTkrqzzoLVq/WxR9KKdXS4fI6v+wx6aWJWAc++QRmzrS2pJk1PAljYMU+Z8wTE4H//m9rI3J1XHV9E+sOljlqWNKbLM+dC8NSokmNDWf5Hmf8HgHccQccPgyhzshblVLKMQr8WFUfNBFrV2UlrFp1fAgwZ7Bnnthu5/Rk3HQTXHml3VE4y6r9pTS5jaMm6n/5JQwfDhkZ1jyxWcOTWb632DHzxFJSrD82lFJKnehwea32iNllwwZrReLpp1vfh4cEM22Is+aJGQM7d8L27XZH4hzL9hQTEiTkDk20OxQA3G4rEfP+HoE1PHmkop79xc6pJ/bPf8LPfmZ3FEop5Ry1DS5Kaxr9tmISNBFr15w5UFoKZ5xx/Nis4clsPVxBWU2DfYG1MGcO/P73dkfhHKv2lTAhM56oMGdsHNHUBL/7HSxcePzYrOHOmye2cSM8/LDOE1NKKS9v8e3MBE3EbBMfb22w7TVzmDVPbNW+UvuCakbE6mnRlZOWukYX6w+WM90hvWEAYWHWELJ3iBtgRGoMKTFhLHdQXbrTT4fqamthgVJKKThUZpWuyEzURCzgGhqsjbU/+ODE45MHJRAaLKza74xEDKw30P37rY/+btOhchpcbseUrQBYvBgOHDjxmIgwc1gyyx3UI3baadbnL7+0Nw6llHKKQ6VWMVftEbPB6tXwzjvWhP3mIkKDmZAZz+r9zunJ8A6daq8YrPT0VE4b4oweMWPg6qtbn3uVOzSR/PI68stqAx9YK9LTYdQoLYeilFJeh8pqCAkSBvhpeyPQRKxNixdbn0899eTXcocksj6vnPomV2CDasPEidYQ6ldf2R2J/VbtK2FEajTJMf6pgNxV+/dDXt6JE/W9codYvXZO6l294AKI9N8ffkop1ascKrVWTAYHid+eoYlYG778EkaPhgEDTn4td2gSDU1uNh0qD3xgrQgKgrffhrvvtjsSe7ndhlX7Sx01LOkd5vMO+zU3Lj2WyNBgVjukLh3A//0fvPCC3VEopZQzHCqr9euwJGgi1iq329raqLXeMDg+7LXSIRP2wYq1taSxP9lZWEV5bSO5DkvEEhJgwoSTXwsJDiJnUAKrDzjn98jLIeXNlFLKVodKa/06UR80EWtVaSlMmgRnn9366ykx4QxPiXbMykmA8nL4y1/694q3lZ6eJSetmFy6FGbNsnotW5M7NJGtBZVU1zcFNrB2nH02XH+93VEopZS9Gl1uDlfUkeXnHjFnFFpymORk+PTT9s+ZNiSRj7YewRiDiP/GjjsrKAh+/nP41a+sDZz7o1X7SkiNDWdwUpTdoRyzaNHJCz6amzYkEZfbsO5gGXNGpgQusHZERx+fI6mUUv3V4fI63Ma/pStAe8Ra5erEHPzcoYmU1jSyu6ja/wF1Qmys1YvXnyfsr9pfSu6QREckxl6DBkF2dtuvTxmciAisdtCE/dmzYccOOHrU7kiUUso+h8q8pSv8+8e9JmKtmDIFfvzj9s/xzkNyUhmLOXNg2bLOJZJ9TWFlHXmltUwd7JxhyddegwcfbH++VXxkKKPTYh21cvKUU6zPy5bZG4dSStnpWA0x7RELrJISa6uXtLT2zxueEk1iVChr9pcFJK7OmD0bqqpg0ya7Iwm8dQfKAJgyOMHWOJp79FHro6MOumlDE1m7vxSX2xkz5HNzISSkf/euKqWUt0cs3Y8bfoOPEjERmS8i20Vkl4jc2crrc0WkXETWeT7+p7PXBtqKFdbnWbPaP09EyBmUwNqDzunJmD3begPtjxuArz1YRmiwMCEz3u5QAGvl7bJlx3uX2pM7JJHK+iZ2HGlnMlkARUVZ8w1nzLA7kp4TkSdFpFBENjU79hsROdSsPbqg2Wt3edqi7SJyXrPj00Rko+e1B8Qz/i0i4SLyouf4chEZGtAfUCnlN4dKa0mNDSciNNivz+nxZH0RCQb+AZwD5AErReRNY8yWFqd+aYy5qJvXBszSpdbE9+nTOz53yuBEPttRRGVdI7ERof4PrgNDhlirJ6OcM1c9YNYeKCU7Pc7v/8F01tat1v8XnUnEvMOpaw+UMS49zs+Rdc6999odgc88BTwIPNPi+P3GmD83PyAi2cBVwHggA/hIREYbY1zAw8ANwDJgETAfeBf4HlBqjBkpIlcBfwS+4b8fRykVKIGoIQa+6RGbAewyxuwxxjQALwALAnCtXyxbZtV8io3t+NycQQkYAxvynFHYVaR/JmFNLjcb8sqZ4qD5YUuXWp87k4gNSY4iMSqUdQ7qXTXG2h+z2DlbYXaLMeYLoLMTORcALxhj6o0xe4FdwAwRSQfijDFLjTEGK6m7pNk1T3u+fgWY5+0tU0r1br0pEcsEDjb7Ps9zrKVTRGS9iLwrIuO7eG3AfP3rcOutnTt38qAEwOqNcYrPP4czz+xfK962H6mkpsHlqPlhBw9a8wxHj+74XBFh8qAE1h0s83tcnZWXZ/WwPv+83ZH4za0issEzdOnN4NtqjzI9X7c8fsI1xpgmoBxIbvkwEblBRFaJyKqioiLf/iRKKZ9zu42ViPl5oj74JhFr7a+/lrOO1wBDjDGTgb8D/+nCtdaJAWrIfvAD+P73O3dufGQoI1KjWeuZKO4Un312fK5bf+D993fSism777Z6lDrbN5IzKIGdhVVU1jX6N7BOysqCjAxYvtzuSPziYWAEkAMUAH/xHG+rPWqvnepUG2aMedQYk2uMyU1NTe1ywEqpwDpaXU9Dk7vX9IjlAYOafZ8F5Dc/wRhTYYyp8ny9CAgVkZTOXNvsHn5vyPbvh4KCrl0zZXAi6w6WYRyyJ8y0adYctz76BtqqtQfKSIkJIysAf7l0RXgX9h33DnNvdNAw94wZffP3yBhzxBjjMsa4gcewpkhA2+1RnufrlsdPuEZEQoB4Oj8UqpRyqGOlK3pJIrYSGCUiw0QkDGuy65vNTxCRgc1WGc3wPLe4M9cG0j33wPjxXdtnb8rgBIqrGzhYUuu/wLogJsb6GfriG2hb1h4sJWeQcwq5fvklnHMO7NrV+WtyvMPcDhqenDEDdu60Srr0JZ45X16XAt4VlW8CV3lWQg4DRgErjDEFQKWIzPK0Y9cCbzS7ZqHn68uBT4xT/ipTSnXbsWKuAfgDv8erJo0xTSJyK/A+EAw8aYzZLCI3el5/BKuBuklEmoBa4CpPY9XqtT2NqbtWrLDefLryfn78DbSUwcnOmCk/cya8+qqVUDokN/GbspoG9hRVc9nUrI5PDpDFi+GjjyCpC3uPJ0SFMTzFWcPc3vIVq1bBuefaG0t3icjzwFwgRUTygF8Dc0UkB2sIcR/wAwBPu/USsAVoAm7xrJgEuAlrBWYk1mrJdz3HnwD+n4jswuoJu8rvP5RSyu/2F9cABGTLPJ/sNekZblzU4tgjzb5+EGsJeaeutUN1tVUIdUEX12yOGRBLZGgwaw+UsSDH1nUGx5x1ljXZurwcEhLsjsa/1nuG8qZ4EmInWLkSRo3qWiIGVlL/xc6jjtm/dMYMeO653r13qTHm6lYOP9HO+fcCJxXvMMasAia0crwOuKInMSqlnOdgSQ0pMWFEh/t/S26trO+xZo1VhLOrRSxDgoOYmBXvqJWTV18N777b95MwgA0HyxCBCVnOKOQKx3tWuypncAJHq+qPdYnbLTbW+l3SueVKqf7mQEkNgwLQGwaaiB2zcqX1uTOFXFvKGZTA1oJKGprcvg2qh5qa7I7A/9bnlTM8JZo4BxTUBTh0yProViLm6dVzUhmL3bvhsce6Nm9SKaV6uwMlNQzRRCywrrgCXnwRBgzo+rWTsuJpcLnZdrjC94F103e+A6eeancU/mWMYX1eGZOzEuwO5ZiKCjj7bGsD9q4aOzCO8JCgY/tmOsEHH8ANN1ilOJRSqj9odLnJL6sNyPww0ETsmEGD4Moru3etNxFY75DSA2AVE12zBurq7I7Efw5X1FFUWX+ssK4TjBsHH35olRHpqrCQILIz4hyzUwMc79nrT6twlVL926HSWtwGHZoMpNJSePTRrtcQ88pKjCQxKpQNDhpSmjEDGhth40a7I/Gf9Z5/70kOmh/W0NCz6ydnJbApvxyX2xljgRMnWvXQ+lOBYKVU/3agJHArJkETMcDaX/IHP4Dt27t3vYgwKSvBUT0ZubnW51Wr7I3Dn9bnlRMSJI7ZKNvthoEDrXp03TUxM56aBhe7i6p8F1gPhIXB1KnaI6aU6j+8idiQ5OiAPE8TMay/9kW6N5zkNTkrnp2FldQ0OGOG/ODB1mo37yKEvmhDXhnj0uOICA22OxTASuRLS63tgbpr8iCrd89pSf26dVaiqZRSfd3BkhrCQoJIi+3C9ig9oIkYVrIybpy1XL+7JmUl4DawOd8ZE/ZF4M474bzz7I7EP9xuw4aD5Y4alvT2Pnp7I7tjWEoM0WHBbMwr80lMvvDLX1p16YK0tVBK9QP7i2sYlBhJUFBg6jn6v1KZwxlj9YhdcEHP7jPJ05Ox/mAZ04d2sZKnn/zkJ3ZH4D97i6uprG9y1IrJVasgKspK6rsrOEiYkBnvqIUf3VlJrJRSvdWBkpqAzQ8D7REjPx+KirpXP6y5tNgI0uMjHDWkZAzs2WP9fH3NBk+PkZNWTK5aZc2nCu7hSOmkrHi2FFTQ6HLOWOCf/mQtaFFKqb7MGMPBkpqAzQ8DTcTIzITiYvj2t3t+r0lZ8ccSBCc4fBhGjLC2qelr1h8sJzI0mJFpMXaHcsy118KNN/b8PpOyEmhocrP9cGXPb+Yjb78NTz1ldxRKKeVfZTWNVNY3Bax0BWgiBlh7Asb7YKrRpKwE9hXXUF7T2POb+UB6OmRk9M2Vk5sOlTM+I47gAI3hd8YPfgDf+lbP7+Od97bxkHN6V3NzYe3a/rFbg1Kq/9of4NIVoIkYv/0tPP64b+7l1DfQvpaIudyGzfkVTMh0zkT9AwesD19sBTQ4KYr4yFBH9a7m5lrFgbdssTsSpZTyn0DXEIN+nogZA3//Oyxd6pv7TchwZiK2fbu19U5fsaeoitpGFxMdlIj96U8wfrxvSjxYdeniWX/QWb9H0PeSeqWUau6gJmKBdfAgHD3as/phzSVGh5GVGMkmByVi06dbCeeaNXZH4jveRHeiw0pX+GKivtfEzHh2HKmkrtHlmxv20MiR1nzK0lK7I1FKKf85UFxDSkw4kWGBq0/Zr8tX+KLuU0sTM+PZlO+cRGzWLHjpJWurmr5iQ541UX9EqjMm6jc2wvr1cPPNvrvnxMx4mtyGHUcqmeSAEh1BQdYfLuKcKXlKKeVze4urGZYSuN4w6Oc9YqtXQ0gITJrku3tOyIxnf3EN5bXOmLCfkABXXAHJyXZH4jubDpWT7aCJ+lu2WPOnfJnQe+e/OWmYW5MwpVRft/doNcNSAle6Avp5IlZTY22OHRHhu3t630A3O+gNdOtWePppu6PwDe9EfSfND/NHz2pWYiTxkaGOGuZetcr6GdevtzsSpZTyvcq6Rooq6xmWEtjRln6diN1/Pyxe7Nt7TnRgT8arr8J11/WNCftOnKh/wQXwwgtWzTZfEREmZMax6ZBz/k+Lj7d6kXXCvlKqL9p31Jqorz1iAebr4Zak6DAyEyIdlYhNnWp9XrfO1jB8wokT9dPT4Rvf8P1ejBMy49l+uJKGJmdU2B8xAuLi+tbCD6WU8tpztAqA4amaiAXEW29ZE9kPHPD9va2eDOclYn3hDdRpE/WbmuCRR2DfPt/fe2JmPA0uNzuOOKPCflAQTJnSN36PlFKqpX1HaxAJbOkK6MeJ2PLl1hBLaqrv7z0xM559xTVU1Dljwv7AgVavTV94A3XaRP1t2+Cmm2DJEt/f21uXzmlJ/fr1WmFfKdX37D1aRUZ8JBGhgStdAT5KxERkvohsF5FdInJnK69/S0Q2eD6+EpHJzV7bJyIbRWSdiARs9smaNZCdDZGRvr/38Qn7zpnfM21a70/EXG7DloIKJmTE2R3KMd5/U2+voy8NSY4iNiLEUcPcZ54JF10E5c4JqV0i8qSIFIrIpmbH/ldEtnnao9dFJMFzfKiI1HraonUi8kiza6Z52qldIvKAiDWpQUTCReRFz/HlIjI00D+jUso39h6tDviwJPggERORYOAfwPlANnC1iGS3OG0vcIYxZhLwO+DRFq+faYzJMcb4cN1Z24yxJh37480Tjk/Yd1JPxkMP+W4HAbvsK66mpsHlqK2N1qyBqCgYPdr39xYRxmfEsSnfOQn9175m1aXrReVQngLmtzj2ITDB0x7tAO5q9tpuT1uUY4xpvoX7w8ANwCjPh/ee3wNKjTEjgfuBP/r+R1BK+Zsxhj02lK4A3/SIzQB2GWP2GGMagBeABc1PMMZ8ZYzx1uReBmT54LndVlAAhYX+S8SSY8JJj49wVGHXQYMgNtbuKHrGm9iOz3BWIpaT47uK+i1NzIxna0EFjS5nTNj3qq21O4LOMcZ8AZS0OPaBMcY7uNpheyQi6UCcMWapMcYAzwCXeF5eAHiLw7wCzPP2limleo/i6gYq65p6bSKWCRxs9n2e51hbvge82+x7A3wgIqtF5AYfxNOhmhq49FI45RT/PWN8RhybHdST0dgIv/qVtUiht9qcX0FYcBCjBjhjor7bbc2X8ldCD9Ywd0OTm51Hqvz3kC5asADOO8/uKHzmu5zYHg0TkbUi8rmInOY5lonVrnk1b+OOtX+e5K4cOKm/UERuEJFVIrKqqKjI1z+DUqqH9h6tBgJfugJ8s8VRa3/9mVZPFDkTKxE7tdnhOcaYfBFJAz4UkW2ev2JbXnsD1tAAgwcP7lHAI0fCa6/16BYdGp8Rz8fbCqlpaCIqzP6dpEJC4LHHID/fGl7qjTbnlzM2PZbQYGesMQkKslbd1tX57xnH5hvmW4sUnGDwYPjkEysR9XXJjkASkV8CTcCznkMFwGBjTLGITAP+IyLjab+N61T7Z4x5FM+UjNzc3FbbR6WUfexMxHzRjOYBg5p9nwXktzxJRCYBjwMLjDHF3uPGmHzP50LgdayhzpMYYx41xuQaY3JTe7jUsaamR5d3yviMOIyBrQXOKD0gYvXcrF5tdyTdY4xh06EKxjskGfGKj4cBA/x3/2HJ0USFBTuqd3XqVKiqgl277I6k+0RkIXAR8C3PcCPGmHpv22SMWQ3sBkZjtXHNhy+bt3HH2j8RCQHiaTEUqpRyvr1HqwkNFjIT/LCCrwO+SMRWAqNEZJiIhAFXAW82P0FEBgOvAdcYY3Y0Ox4tIrHer4FzgU34WXY23HKLf5/RvCfDKaZMsfZFrK+3O5Kuyyutpby20VHzw556Cn7/e/8+IyhIGJce56jfo2nTrM+9dRWuiMwH7gAuNsbUNDue6ll8hIgMx5qUv8cYUwBUisgsz/yva4E3PJe9CSz0fH058Ik3sVNK9R57i6oZnBRFiA0jLj1+omdexK3A+8BW4CVjzGYRuVFEvKuO/gdr3sRDLcpUDAAWi8h6YAXwjjHmvZ7G1J7iYti/H4YO9edTID0+gsSoUEeVsJgyxar/tMnvqa7veXuEnLRi8t//htdf9/9zxmfEsSW/ArfbGe/v48ZBeHjv6F0VkeeBpcAYEckTke8BDwKxWFMhmpepOB3Y4GmPXgFuNMZ4e7duwurR34XVU+adV/YEkCwiu4CfACeV71FKOZ+12bc98499MnnJGLMIWNTi2CPNvr4euL6V6/YAk1se96e1a63P/pxgDd69AuMdtXJyyhRri5r8/OO9Gr3F5vxygoOEsQOdsfTTGKtH6PLL/f+sCRnxPLN0P/tLamyZv9BSaCj89rcwOaD/5XaPMebqVg4/0ca5rwKvtvHaKmBCK8frgCt6EqNSyl4ut2FfcTWnj06x5fn2zyIPMO9wypQp/n9WdkYcTy7eS0OTm7AQ+2c1jxgBpaW9c4L1pkPljEyNCXjF47YcOGD9W/o7oQeOTdLfdKjcEYkYwM9/bncESinlG3mlNdQ3uRmVZs8f+r3wLbln1qyBIUMgKcn/z5qQEU+jyzhmr0CR3pmEgTU0OT7TORP1vT2rgUjoRw+IJTRYHDVhv7ERNmyACueEpJRS3eItDzTSptJIvfRtufuuuAJ+8YvAPMu7ws9JE62ff96qn+Zy2R1J5xVW1lFYWe+oifpHj1orJidO9P+zwkKCGD0g1lG/R6tWWUOTn35qdyRKKdUzu4o8iViaJmIBcdllcENAysbC0ORooh1WeqChAZYtgx07Oj7XKbz/fk4qXXH99VBSYm1vFAjeCftOWZA3aZLVw+rtGVRKqd5q55EqBsSFExcRasvz+1UiVlgImzcHrjcoKEjIzohz1J6T3qG03vQGusWTiDmloKlXIId5x2fEU1zdwOEKP1aP7YLoaBgzpnf9HimlVGt2FVbaNj8M+lki9vLLMGGCtddkoIzPiGfb4UpcDis90JveQLfkVzA4Kcq2v1ZaOnoUpk+HDz4I3DOPDXM7rBxKb/o9Ukqplowx7Cyssm1YEvpZIrZ2LaSkQGZ7O2H6WHZGHDUNLvYVVwfuoe0IDbXmNfWmN9DN+eWOGpZcu9aaI+Wvjb5bMy49DhEcNcw9ZQocPGjV5lNKqd4ov7yOmgaXJmKBsnYt5ORYc1sC5fiEfee8gV50EYwaZXcUnVNZ18i+4hqy052ViEFgVkx6RYeHMCwl2lET9i+/HN591xqmVEqp3mhXoTVRf5SNiVi/qSPW2GhVlL/ttsA+d1SaVXpgS34FF0/OCOzD2/DrX9sdQedtO2yV/nBa6YrBgwNTAqW57PQ41h0sC+xD2zFsmPWhlFK91U5PealRA3SOmN9t2WKtGAxkLwZYpQdGpTmr9IBXU5PdEXRss2ehg5NKV6xdG/jfI7D+DfJKaymvaQz8w9vwxRfwxhsdn6eUUk60q7CK5OgwkqLDbIuh3yRiw4fD22/DWWcF/tlOKz3Q2GjNk7vnHrsj6djm/AqSo8NIiw23OxQA3G6rfta55wb+2d5Vo5sLnJPU//WvcMcddkehlFLds7OwihE2DktCP0rEYmPhwgthwIDAPzs7I47i6gYKK+sD//BWhIZae06uW2d3JB3bnF9BdkYcEsiJfe0ICoIXX4Sbbw78s73z5LY4aL7hlClWTbpqZ6xFUUqpTjPGsPNIpa3zw6AfJWLPPw8rV9rzbO+wmpOGJ3NynL9ysqHJzc7CSkcNS9o5nJsaG05abLijErGcHGsD9I0b7Y5EKaW6pqiynoq6Jk3EAsHthhtvhH/9y57nj0u3JgE66Q10yhRr4+qSErsjadvOwkoaXcZRpStuuskamrTL+Iw4thQ45/coJ8f63Bt6V5VSqrmdhd6tjeybqA/9JBHbt8/anNiOCdYAsRGhDE2OclQJi97wBrrZgRX1162D1FT7np+dEcfOwirqGp2xWejgwZCY6OzfI6WUao13Vf6YgZqI+Z33TcKuRAysN1AnJWJTp8KPf2zPnLnO2pJfQVRYMEOTnVGoqqnJGoLzJrF2GJ8Rj8tt2Hmkyr4gmhGxhvwfeMDuSJRSqmu2FVSQEhNGqs2LwfpFIrZ2rVUFffx4+2IYnxHPgZIaKuqcUXogJQXuv9/ef5OObCmoYOzAWIKDnDFRf9s2qK+3OxHzFgh2znzDESMgzL6V30op1S3bDlcydqD9Iy79IhFbvx7GjoXISPti8A6vbXVQr1h9vVVfzYncbsPW/ApHTdR3Qs/qoMQoYsJDHDVPbPduq1Dynj12R6KUUp3T5HKz40glY20eloR+koi9/DK88469MYz3lh5w0BvoPffApElQW2t3JCfLK62lsr7JUfPDRo+GH/0IxoyxL4agICE73VnD3DU11tDksmV2R6KUUp2zr7ia+iY34xywfV6/SMTCw2HIEHtjSI0NJyUmzFErJ3NywOWCzZvtjuRk3qE3J+0xOWMG/O1vEGLzxmDZGXFsLajA7XZGgeCxY63/xpxeDkUppby2FlgT9cema4+Y361eDT/5CRw+bG8cIkJ2RryjesS8c52c+Aa6paCC4CCxfTWLl7dWVqMDpvhlp8dR0+Bif0mN3aEAVoHgCRN05aRSqvfYdth6jxlpcw0x6AeJ2KefWpPSQ0PtjsR6A91xpJKGJrfdoQDWhs2xsc58A92SX8GI1GgiQoPtDgWAgwetYdzHHrM7kmZbHTlown5OjvV75JBdvJRSql3bCioZkRpNeIj97zE+ScREZL6IbBeRXSJyZyuvi4g84Hl9g4hM7ey1PbV2LQwaBMnJvr5z12VnxNHoMuwqdEbpgaAgqzipExOxzfkVjhqWdMJEfa9RA2IICRJHDXNPmWKtnCwttTuSE4nIkyJSKCKbmh1LEpEPRWSn53Nis9fu8rRF20XkvGbHp4nIRs9rD4hnzy0RCReRFz3Hl4vI0ID+gEqpbtlaUOGIFZPgg0RMRIKBfwDnA9nA1SKS3eK084FRno8bgIe7cG2PrFtnb7mB5rIdOGH/N7+Be++1O4oTFVfVc7iizlErJteutWpmTZxodyQQHhLMyLQYR/0e3XQTHDoESUl2R3KSp4D5LY7dCXxsjBkFfOz5Hk/bcxUw3nPNQ542Cqw26waOt2Pee34PKDXGjATuB/7ot59EKeUT5TWN5JfXOWKiPvimR2wGsMsYs8cY0wC8ACxocc4C4BljWQYkiEh6J6/tttpaq/aTE3oxAIalRBMZGuyonox582DuXLujOJF3EqWTVkyuWwejRkGM/dMJAKsunZN+j4IcOsnBGPMF0HIjrwXA056vnwYuaXb8BWNMvTFmL7ALmOFpq+KMMUuNMQZ4psU13nu9Aszz9pYppZxp22Gr7XTCRH3wTSKWCRxs9n2e51hnzunMtd128KBVuNQpPWLBQcLY9FhHze1paIBFi5xVT8z77+OUv1bASsScktCDlaQWVtZTVFlvdyjH/OQnVj2xXmCAMaYAwPM5zXO8vXYqr5XjJ1xjjGkCyoGTJkKIyA0iskpEVhUVFfnwR1FKdZV3a6NxfWVoEmjtr7+WU3bbOqcz11o36EZDNno0HDkCC3zWx9Zz2enWps3GIbOajbH+ff79b7sjOW5LQQXp8REkRTunXPtDDzkryXDiMHdeHrz9tt1R9Eh32qlOtWHGmEeNMbnGmNxUOzcrVUqxtaCChKhQBsTZu7WRly8SsTxgULPvs4D8Tp7TmWuBnjVkTho2yc6Io7KuibxSZ1RRDQ+H7GxnTdh32kR9gPPPh1NOsTuK444lYg4anszJsarrlzunw7ctRzzDjXg+F3qOt9dOZbVy/IRrRCQEiOfkoVCllINsyi9nfEYcTplF4IsUZSUwSkSGiUgY1mTXN1uc8yZwrWf15Cyg3DMk0Jlr+xTvBHQn9WTk5Dinllhtg4s9RVXH9lR0glWr4P33nVWaIT4qlKzESEf9HnmHbtevtzeOTngTWOj5eiHwRrPjV3lWQg7DmpS/wtNWVYrILM/8r2tbXOO91+XAJ8Yp3d1KqZPUN7nYfriSCZnOWQzW40TMMy/iVuB9YCvwkjFms4jcKCI3ek5bBOzBmvz6GHBze9f2NCYnGzMgliDBUVvUTJliFby1u+gtwPYjlbgNZDtoxeSDD8J111mrJp3E2urIOd1P3rmYTupdFZHngaXAGBHJE5HvAfcB54jITuAcz/d42p6XgC3Ae8AtxhiX51Y3AY9jtWG7gXc9x58AkkVkF/ATPCswlVLOtONwFY0uw0QHJWI+2azFGLMIK9lqfuyRZl8b4JbOXtuXRYYFMzw1xnFDSmD1ZAwcaGsoxxILJ/WIOakESnPZGXF8uPUINQ1NRIXZvO8S1u/O2WdbRYKdwhhzdRsvzWvj/HuBkwq6GGNWARNaOV4HXNGTGJVSgbPxkPUe0+cSMdU14zPiWLnXOdNIZs60tu+xczNrry35FcRGhJCVGGl3KADU11t7cV5wgd2RnCw7PQ5jrHIf04YkdnyBn4nAhx/aHYVSSrVt46Fy4iJCGJwUZXcoxzhoGnv/kZ0eR355HaXVDXaHAkBkpLVXoBO2gdpSYE3Ud8okyi1boKnJmT1i4zOdN98QwO22PpRSymk2HSpnQma8Y95jQBMxW3gn7G910Bvoxx/D3XfbG4PLbdhWUOm4Qq7grBpiXhnxEcRHhjpqmPvDDyEhwephVUopJ6lvcrHtcAUTs5wzLAmaiNlinKear5Mm7C9ZYiViVTZug7n3aDW1jS5HbW30rW9ZK0pHjLA7kpOJCOMz4tjioAn7gwZBZaWzJuwrpRQ4c6I+aCJmi+SYcAbGRThqSCknxyrPsGGDfTF4/z2cVEMsLMz6t3FSLbrmstPj2Ha4kiaXM8YCR42CqCjnlENRSikvJ07UB03EbDM+w1mlB7xDb3b2ZGzOLycsOIiRac7Y0NHthp/+FJYtszuSto3PjKO+yc2eo9V2hwJAcDBMmqSJmFLKeZw4UR80EbNNdkYcu4uqqWt0dXxyAGRlQVKSvW+gW/IrGDUghrAQZ/xa7tkDf/kLbNpkdyRty063/rJzWlK/bp2zCuAqpZQTJ+qDJmK2GZ8Rh8tt2O7ZfNRuItYQXH6rG0z5nzGGLQ7b2sjJE/W9RqRGExYS5KgJ+wsWwI9+ZJX+UEopJ/BW1HfasCRoHTHbeHsythRUMHlQgr3BeCxaZO09aYfCynqKqxsctWJy7VprqG38eLsjaVtIcBBjB8Y6auHHeedZH0op5RSb8ytocLmZMjjB7lBOoj1iNslKjCQ2PMRRPRl2JWHQvKK+c/5aWbvW2hA9IsLuSNqXnR7HloIKnLTFYUUFHDhgdxRKKWVZe6AMgCmD7S9+3ZImYjYJChLGOWzCfkkJXHYZvGnDtuubD1kJqbe0hxMcPuzMQq4tjc+Io6ymkfzyOrtDOebUU+Hmm+2OQimlLGsOlJKZEMmAOOf9Za2JmI2y0+PYWlCJy+2Mnoy4OGt48vPPA//szfkVDE2OIjbCAeX9PdasgccftzuKjnmHc53Uu5qToysnlVLOse5AGTkOHJYETcRsNT4jjtpGF3sdUnogJAQmTrTnDXRzQbmjhiW9wsLsjqBjYwfGIeKslZPehR+FhXZHopTq745U1HGorJapDhyWBE3EbOVNPJz0BmpH6YHy2kYOltQ6aqL+E0/AN75h7TPpdNHhIQxLiXbUhH0n1KVTSimAtQdKARw5UR80EbPVqAExhAU7q/TAlClQWgr79wfumd6ff7yDErEPPoAVK6xewt5gfEa8o36PJk+2PuvwpFLKbmsPlBEWHOSo95jmNBGzUWhwEKMHxjiqJyM3F2bMgLKywD3Tu7WRk4Ym1651dv2wlsZnxHGorJbS6ga7QwGs4sD/+hdccondkSil+rs1B0oZnxlHeEiw3aG0ShMxm41Pj2dzfrljSg/k5sLy5YFdLbg5v5y02HBSY22sn9FMZSXs2tX7EjFw1kby110HY8bYHYVSqj9rdLnZkFfOlEHOnB8GmojZbkJmHKU1jRQ4qPQABHaO2Jb8CkfND9uwwfr5e1ci5rz5hkVF8NJLUO2MtShKqX5oa0EF9U1upg5JsDuUNmkiZrPsY2+gzunJuPtuGDs2MM+qa3Sxs7DKUWP39fUwdWrvSsSSosPIiI9w1O/R8uXWggedsK+UssvKfdZE/WlDtEdMtWFceiwi1makThEbCzt2BKb0wI4jVh01J80PO+ssWL0aMjPtjqRrsjPiHdUj5k1k16yxNw6lVP+1Ym8xg5OiSI+PtDuUNmkiZrOosBCGO7T0QCBWvG124IpJh0zX67IJmXHsOVpNdb0zam5kZEBamq6cVErZw+02rNhbwoxhSXaH0i5NxBzAKj3gvJ6MwCRi5cSGhzAoMcr/D+uE+npISYF//tPuSLpufEY8xsC2w85I6kWs3yXtEVNK2WFXURWlNY3M7MuJmIgkiciHIrLT8/mkQVgRGSQin4rIVhHZLCK3NXvtNyJySETWeT4u6Ek8vdX4jDjyy+scU3ogIQGGDQvMG+imQxWMz4wjKEj8/7BO2LTJ2nMzOdnuSLrOiSsnp06FzZutBNdJRGRMs3ZnnYhUiMiP22uTROQuEdklIttF5Lxmx6eJyEbPaw+IiDN+mZXq55bvKQZg5jBnN+g97RG7E/jYGDMK+NjzfUtNwH8ZY8YBs4BbRCS72ev3G2NyPB+LehhPrzQh03kT9n/wAzjjDP8+o8nlZmtBBRMcND/Mm3z2pon6XunxESRGhR7bQN0JbrkFdu503lZRxpjt3nYHmAbUAK97Xj6pTfK0WVcB44H5wEMi4i1K9DBwAzDK8zE/cD+JUqoty/eWkB4fwaAk584Pg54nYguApz1fPw1c0vIEY0yBMWaN5+tKYCvQy6ZB+5e3J2Ojgybs33GH9SbqT7uLqqlvch9LRJ1g7VqIj4fhw+2OpOtEhAmZ8Wxy0DB3ZiYMHWoNUzrYPGC3Maa9/SQWAC8YY+qNMXuBXcAMEUkH4owxS41VDPAZWmkHlVKBZYxhuWd+mNM7qXuaiA0wxhSAlXABae2dLCJDgSnA8maHbxWRDSLyZGtDm/1BQlQYWYmRjnoDBau6vj8r7HtXik7IdM5E/TVrrGK2Dv/vtk3jM+LZcaSShia33aEc89hj8MwzdkfRrquA55t931qblAkcbHZOnudYpufrlsdPICI3iMgqEVlVVFTk2+iVUifZV1xDUWW94yfqQycSMRH5SEQ2tfKxoCsPEpEY4FXgx8YY79jJw8AIIAcoAP7SzvV9uiGbkBHPZgf1iBUWQmIiPPWU/56xKb+cyNBghqXE+O8hXXTxxXDNNXZH0X0TMuNodBl2HKm0O5Rjnn0WHn7Y7ihaJyJhwMXAy55DbbVJraXmpp3jJx4w5lFjTK4xJjc1NbWnYSulOtBb5ocBdLilsTHm7LZeE5EjIpJujCnwdNG3WnlKREKxkrBnjTGvNbv3kWbnPAa83U4cjwKPAuTm5vbSAgNtm5gVz3ubD1NR10hcRKjd4ZCWBunp/p2wv/mQVVE/2CET9QF+8Qu7I+gZ73y7TYfKHTPkO2WKtQq1qcmRm6ifD6zxtkXttEl5wKBm12UB+Z7jWa0cV0rZaPneElJiwhiRGm13KB3q6dDkm8BCz9cLgTdanuBZQfQEsNUY89cWr6U3+/ZSYFMP4+m1jq14c9BE62nTrMKm/uB2GzbnlzPBQfXDioqgwjn//N0yJDmK2IgQR803nDoVamth2za7I2nV1TQblmynTXoTuEpEwkVkGNak/BWeKRmVIjLL09ZdSyvtoFIqcIwxLN51lNkjUhw/Pwx6nojdB5wjIjuBczzfIyIZIuJdATkHuAY4q5Ul4X/yLPveAJwJ3N7DeHqt4ysnnfUGum2bf/YK3FdcTXWDi/EO6bUB+P3vrV5Al8vuSLpPRBifEccmB63AnTbN+uy0emIiEoXVbr3W7HCrbZIxZjPwErAFeA+4xRjj/U25CXgcawL/buDdwPwESqnWbD9SSVFlPaeOTLE7lE7p0UCBMaYYa8VRy+P5wAWerxfT+jwKjDG9eDaOb6XEhJMeH+GorY6mTQO3G9avh9mzfXvvTQ6sqL96NUyeDMHBHZ/rZBMz43l66X4aXW5Cg+2v2TxmDMTFQV5ex+cGkjGmBkhucazNNskYcy9wbyvHVwETfB6gUqpbFu88CsCpo/pBIqZ8a3xGvKOGlGbPhkce8U8ph82HygkLDmJUWqzvb94NbrdVuuK66+yOpOcmZMbT0ORmV2EV49LtT3SDg63FH+HhdkeilOoPvtx5lOGp0WQkOLt+mJf9fy6rY5y2V2BKilXYdeBA3997U345YwbGEhbijF/BHTugqur4MFpv5h3mdlJSr0mYUioQ6ptcLN9bzGm9ZFgSNBFzlAmevQK3Fjhnfs+BA/B2m2tZu8cYw8a8ckfVD/MuSugLidiw5Giiw4IdVQ5l7Vo491wr4VVKKX9Zvb+UukY3p47qPWViNBFzkIlZzuvJeOwxuOQSa9WbrxwoqaGirolJWQm+u2kPzZ4NDz4I48bZHUnPBQWJ44a5Q0Phww9hxQq7I1FK9WWLdx4lOEiYNdz5hVy9NBFzkLTYcFJjwx31BjptmrWKcMMG391zQ57180100IrJYcOsLZ0cWOeqW8ZnxrGloAKX2xkl98aOhchI/5VDUUopgCW7jpIzKIFYB9Tj7CxNxBxERJiUGc/GPOckYlOnWp99+Qa6yTNRf/QA50zUf+klOHzY7kh8Z0JGPHWNbnYXVdkdCmAluDk5sGqV3ZEopfqqo1X1bDhUzmm9ZLWklyZiDjMxK55dRVWOmbA/aJA1ad+XidiGvHLGpTtrov43vgHvvWd3JL4zyTPMvcFBSf20adZcsd5cp00p5VyfbS/CGJg3doDdoXSJM94J1TGTsqwJ+5sdUpBTxLcV9t1u46jtd6BvTdT3Gp4aQ1RYMBvzyuwO5ZjTToOZM6G01O5IlFJ90SfbjjAgLtxRC8E6o4/MiOk7vAnKhrwyx+waf//9EOujUcT9JTVU1jcd67FxgtWrrflLfWGivldwkDAhM54NDppveOWV1odSSvlaQ5ObL3Yc5WuT03vFtkbNaY+Yw6TFRjAwLsJRE/bHjYOsrI7P64wNnh6aiZkJvrmhD3gr6veVifpekzLj2ZJfQaPLbXcoJ3A7KxylVB+wcl8JVfVNnNXLhiVBEzFHmpjlrNIDLhf89a++mUO16VA5YSFBjBoQ0/Ob+YDLZe2B2JeGJb0mZsVT3+Rmx5FKu0M55rrr4Kyz7I5CKdXXfLy1kLCQIOaMTO74ZIfRRMyBJmXGs6eomsq6RrtDAawtav7yF3j22Z7fa0NeOdnpcY7YAxEgKAg2boSf/czuSHxvsqdOm5NW4SYkWLXEmpyxFkUp1QcYY/h42xFmj0gmKqz3DW04491QncBb2HXTIWdM2AfIzYWVK3t2D7fbsDm/wlHzw0Rg6FAYMsTuSHxvSHIUsREhrHdQIjZ9ulUceMsWuyNRSvUVe45Ws7+4hnnjet+wJGgi5kgTj+0VWGZvIM1Mnw7bt0NFD3LDPUerqapvctSKyWeegccftzsK/xARJmXFO+73CHqe1CullNd7m6wikPPGptkcSfdoIuZAyTHhZCZEOqoGVG6u9bknZSzWHywDIGdQQo/j8ZUHH4TnnrM7Cv+ZlJXA9sOV1DU6o3jXyJEQH6+JmFLKd97dVMCUwQlkJETaHUq3aCLmUJOy4h2XiIWEwJ493b/H+rwyosOCGZHqjIn69fWwfv3xXpq+aFJmPI0uw7bDzpiwHxQEP/85nHGG3ZEopfqCA8U1bDpUwQUT0u0Opdt636y2fmLyoATe3XSYkuoGkqLD7A6HlBSorISIiO7fY/3BMiZmxRMc5IwaLxs2QENDH0/EPL2PG/PKHNMT+Ytf2B2BUqqvWLSpAID5EwbaHEn3aY+YQ3nfNL3DeU7QkySsvsnFloIKJjskGYDjw2N9ORHLiI8gJSaMdQed07tqDOTlQXGx3ZEopXq7dzcWMDkrnkFJUXaH0m2aiDnUxMx4ggTWOSgR+/xzmDcPjh7t+rVbCyppdBlyPCUVnODQIUhPh8GD7Y7Ef0SEyVkJrDvonH2FDh2y9jDty3PzlFL+l1daw/q8cs6f2HuHJUETMceKDg9h9IBYRyViAJ98YtWB6ipvz56TesTuvRf27bNKWPRlOYMS2F1UTXmtM+rSZWbCgAE6YV8p1TPvbrRWS57fi4clQRMxR5uclcD6vDKMMXaHAljV54OCYNmyrl+7/mAZqbHhpMf3YHzTD8Lsn37ndzmDE4Dj20vZTcRKgr/5TbsjUUr1Zm+sP8SEzDiGJEfbHUqPaCLmYJMHJVBW08iBkhq7QwEgJgYmTIDly7t+7bq8MiZnJThmM9alS+G882DnTrsj8b9JnuFgJ803/N73YP58u6NQSvVWO49UsulQBZdO8dFGyDbqUSImIkki8qGI7PR8TmzjvH0islFE1onIqq5e3195J+w7aXhy1ixraLIrGzdX1DWyp6ianEHOKeT6xRfwwQeQlGR3JP4XHxnKiNRoR/0eOUFr7VJ7bZKI3CUiu0Rku4ic1+z4NM99donIA+KUvzaU6sNeW3uI4CDh4skZdofSYz3tEbsT+NgYMwr42PN9W840xuQYY3K7eX2/M3pADJGhwY56Az3rLJgxA8q7sAjPu9ehk+aHLVsGo0ZBcu/bH7ZbJg9KYN1B5wxzO0jLdqnVNklEsoGrgPHAfOAhEQn2XPMwcAMwyvOhfX1K+ZHbbXhj7SFOG5VCamy43eH0WE8TsQXA056vnwYuCfD1fVpIcBATM+MdlYh94xvw/vuQ2IW+S2/8kzIT/BJTVxljJWKzZtkdSeBMGZTA0aoG8kpr7Q7F6dpqkxYALxhj6o0xe4FdwAwRSQfijDFLjZXlPoO2Y0r51bK9xeSX13HplEy7Q/GJniZiA4wxBQCez21t9GSAD0RktYjc0I3r+63Jg+LZnF9BQ1MXxgIDoKmp8+eu2V/KiNRo4qNC/RdQFxw4AIcP969ELGeQlTk7Kal3gNbapbbapEzgYLNr8zzHMj1ftzx+AhG5QURWiciqoqIiH/8YSvUvr685REx4COdm9+7Vkl4dJmIi8pGIbGrlY0EXnjPHGDMVOB+4RURO72qg/bUhyxmUSEOTm60FPdht28e+/3045ZTOnWuMYe3BMqYOds70v4oKa4h1zhy7IwmcsemxhIcEaSJ2oq60S63N+zLtHD/xgDGPGmNyjTG5qamp3YtWKUV1fRPvbjrM/AkDiQwL7viCXqDDLY6MMWe39ZqIHBGRdGNMgaeLvrCNe+R7PheKyOvADOALoFPXe659FHgUIDc3t99MdJk6JAGANQdKHTPHKi0N1q6FmhqI6qCY8b7iGkqqG5g6xDmJ2MSJ8PHHdkcRWKHBQUxw2DC33dpol9pqk/KAQc0uzwLyPcezWjmulPKDt9bnU1XfxFXTB3V8ci/R06HJN4GFnq8XAm+0PEFEokUk1vs1cC6wqbPX93fp8ZFkxEewer9zKqPPnAkuF6xZ0/G5azxxO6lHrL7e7gjsMWVQAhsPlTtumNsO7bRLbbVJbwJXiUi4iAzDmpS/wjN8WSkiszyrJa9F2zGl/Oa5FQcYPSCGaQ76476nepqI3QecIyI7gXM83yMiGSKyyHPOAGCxiKwHVgDvGGPea+96daKpQxKPJTRO4J1btXRpx+euOVBKbHgIo9Ji/BtUJ9XXWyUr/vpXuyMJvNyh1jD3pnzn7Dtpo7bapVbbJGPMZuAlYAvwHnCLMcbluddNwONYE/h3A+8G8gdRqr/YdKicDXnlfHPGYMfUpPSFDocm22OMKQbmtXI8H7jA8/UeYHJXrlcnmjYkkbc3FFBQXkt6fKTd4ZCWBiNGwFdfdXzumgNl5AxOICjIGf/ReIdUhw61O5LA8/ZKrtlf6qgeSju01S611yYZY+4F7m3l+Cpggq9jVEqd6LkVB4gIDeLSqb2/iGtzWlm/Fzj+BlpmbyDN/PSncOml7Z9TVd/E9sMVTHHQm753e6b+tGLSKy0ugkFJkY4a5lZKqc6oqm/ijbWHuGhSBvGRzliB7ys96hFTgZGdEUdEaBCr95dy4SRn7DJ/440dn7P+YBluA1M9ex06wZIlMHgwZPT+YszdMm1wIkt2F2OM6VNd+0qpvu21NXlUN7j45szBdofic9oj1guEBgcxKSuB1Qec05NhDOzfD3v3tn2Od17blEHO6BEzBhYvhtNOszsS+0wbmkRRZb0WdlVK9Rput+HJxXvJGZTAFIdUD/AlTcR6iWlDEtmSX05do6vjkwPAGJgyBX7/+7bPWXOglJFpMY4p5NrUBHfcAddea3ck9pnmGSbW4UmlVG/x8bZC9hXXcP1pw/pkT74mYr3E1MGJNLoMGw85Y8VbUJBV1LWtCftut2H1/lJyHbTEODQUfvxjOPdcuyOxz5iBsUSHBbNqf4ndoSilVKc8/uUeMhMimT++b1TSb0kTsV7CO89q1T7n9GTMmQNbtkBJK+/p249UUlHXxPShSYEPrA2rV0NBgd1R2Cs4SJgyOJHVDlr4oZRSbdl0qJzle0u4bvZQQoL7ZsrSN3+qPig5JpwRqdGs3OecnozZs63PrdUT88Y5Y5hzErFrrrG2Z+rvpg1JZPvhCirrGu0ORSml2vXPL/YQHRbMN2b0nUr6LWki1ovMGJbMyn0luNzO2OFpxgwICbFWIra0Ym8J6fERZCXaX/cM4OhR2Lq1f+0v2ZbcoYm4jVXjTSmlnGp3URVvb8jn26cMIS7CGXON/UETsV5k5rAkKuua2HbYGRuAR0XBm2/CLbeceNwYw4q9JUwfmuSYiZXeuWynnmpvHE4wdXAiwUHCir3FdoeilFJt+senuwgPCeL7pw23OxS/0kSsF/EO863Y65zhyfPPh8zME48dKKmhsLKe6Q4ally8GMLCYPp0uyOxX3R4CBMz41m+xzm/R0op1dz+4mreWJfPt2cOISUm3O5w/EoTsV4kIyGSrMRIRyViFRXw4IOwcePxY974Zjhoov7ixZCbCxERdkfiDDOHJ7E+r4zaBmeUQ1FKqeYe+nQ3IUHCDaf37d4w0ESs15kxLIkVe0swxhnzxIyB226DV189fmzF3hISokIds9E3wLPPwt/+ZncUzjFrWDKNLsNaBxUJVkopgD1FVbyyJo+rZwwmLa7v//WsiVgvM3NYEsXVDewuqrY7FADi463Crp9/fvzYyn0l5A5JcsxG3wDDhlk9YsqSOzSRIIFlDupdVUopgP99fzsRIUHcetZIu0MJCE3EepkZw5IBZ80TO+MMq4RFXR0UVtSxr7iGGcOcU8j1hRfgX/+yOwpniY0IZXxGPMv36IR9pZRzrDlQyrubDvP904f3+blhXpqI9TJDk6NIjQ131Iq3uXOhvh6WL4evdltxnTI8xd6gmrn/fnjiCbujcJ6Zw5JYe7DMMdtmKaX6N2MM9727jZSY8D6/UrI5TcR6GRFh5rAklu4pdsw8sdNOs+qJbdkCS3YdJT4ylOyMOLvDAqzFBKtXw5ln2h2J88wcnkxDk5sNec7YNksp1b99sOUIK/aWcNvZo4gOD7E7nIDRRKwXOnVkCkcq6tldVGV3KAAkJFjbHN14o+Gr3cWcMjyZYIfMD/vyS3C5NBFrzYyhSYjAMh2eVErZrLbBxW/f2sKYAbFcPb3vVtFvjSZivdCckdaw3+KdR22O5LjYWKt+2KGyWmaPTLY7nGM+/dSqH3bKKXZH4jzxUaGMz4hj8S7n/B4ppfqnhz/bxaGyWn67YHyf3VOyLf3rp+0jBiVFMSQ5iiW7ndOTsWcPXHGrFc/sEc6ZH5aXZ+2JGemMnZYc59SRqaw9UEp1fZPdoSil+ql9R6t55PM9XJKTwczhzvlDPlA0Eeul5oxMYdnuYppcbrtDASAtDfbXHSUSa3Nyp3jhBXj/fbujcK7TRqXQ6DIsd9DiD6VU/2GM4Zf/2UhYSBC/uGCc3eHYQhOxXmrOiBQq65vYcMgZE62jogzRw4tx5ac4Zn9Jr7AwuyNwrmlDEgkPCeJLBw1zK6X6j+dXHGTJrmLuPH9svyje2hpNxHqpU0YkIwJLHPIGuv1IJe7QBvLXplBYaHc0lttvh29/2+4onC0iNJgZw5IcNd9QKdU/HCqr5feLtjJ7RDLfnDHY7nBs06NETESSRORDEdnp+XxSFU8RGSMi65p9VIjIjz2v/UZEDjV77YKexNOfJEWHOWqi9RJPHHX7k/noI5uDwdp66dVXobbW7kic77RRKewsrOJweZ3doQSMiAwSkU9FZKuIbBaR2zzH22yTROQuEdklIttF5Lxmx6eJyEbPaw+I07qElXIgt9tw56sbcBvDHy+b5KidWAKtpz1idwIfG2NGAR97vj+BMWa7MSbHGJMDTANqgNebnXK/93VjzKIextOvzBmZwpoDpdQ02D/R+tPthYxKi+H8MyKJjbU7Gti6FQ4ehPnz7Y7E+U4dmQrgmKQ+QJqA/zLGjANmAbeISLbntZPaJM9rVwHjgfnAQyIS7Dn/YeAGYJTnQ3/rlOrAE4v38uXOo9x1wTgGJUXZHY6tepqILQCe9nz9NHBJB+fPA3YbY/b38LkKOH1UKo0uw1e77J1oXVXfxIq9JZw1No233oKvfc3WcAB47z3r83nntX+egrEDY0mJCWPxziK7QwkYY0yBMWaN5+tKYCuQ2c4lC4AXjDH1xpi9wC5ghoikA3HGmKXGqrD8DB23g0r1a+sPlvGn97dxbvYAvj2z/w5JevU0ERtgjCkAq2ED0jo4/yrg+RbHbhWRDSLyZGtDm6pt04cmERMewsfb7J2UtWTXURpdhrljrP/7Kyqg3OY1BO+9B+PGwWD9b7xDQUHCqSNT+HLnUVxuZ+zWEEgiMhSYAiz3HGqtTcoEDja7LM9zLNPzdcvjLZ9xg4isEpFVRUX9J+FVqqXKukZ+9MJaUmPC+dPlkxy3uMsOHSZiIvKRiGxq5WNBVx4kImHAxcDLzQ4/DIwAcoAC4C/tXK8NWQthIUGcPjqFT7cV2rrd0afbCokNDyF3aCJFRZCcDI8+als4gLX/5U032RtDb3Lm2DSKqxtYd7DM7lACSkRigFeBHxtjKmi7TWrt3cK0c/zEA8Y8aozJNcbkpqam+iJ0pXodt9tw+4vryCut5W9XTyEhSpe0QycSMWPM2caYCa18vAEc8XTN4/ncXtfM+cAaY8yRZvc+YoxxGWPcwGPAjHbi0IasFWeOSeNwRR1bCipseb4xhk+3F3La6BRCg4NITYUJE+DNN20J55hf/AJ++EN7Y+hN5o5OIzhI+HjrkY5P7iNEJBQrCXvWGPMatNsm5QHN913JAvI9x7NaOa6UauH+j3bw0dZC/ueibKYPTbI7HMfo6dDkm8BCz9cLgTfaOfdqWgxLepM4j0uBTT2Mp9+ZOyYNEfhkqz3Dk1sLKjlSUX9sWBLg4ovhq6/Aro7LTZt0tWRXxUeFMmNoEh/1k0TMs7LxCWCrMeavzY631Sa9CVwlIuEiMgxrUv4Kz5SMShGZ5bnntbTfDirVL72zoYC/f7KLK3OzuPaUIXaH4yg9TcTuA84RkZ3AOZ7vEZEMETm2AlJEojyvv9bi+j95ln1vAM4Ebu9hPP1Oamw4k7MSbJsn9ul267lzRx/vpVywANxueOedwMfjdlsrJa+7LvDP7u3mjUtjx5EqDpbU2B1KIMwBrgHOalGqotU2yRizGXgJ2AK8B9xijHF57nUT8DjWBP7dwLuB/VGUcrYVe0u4/aV1TBuSyO8umaDzwloI6cnFxphirJWQLY/nAxc0+74GOGkDKWPMNT15vrKcNTaN+z/awdGqelJiwgP67I+3HmFCZtwJFZGnTIGsLHjjjcAnRKtWwaFDcNFFgX1uX3D2uAHc885WPtp6hO/MGWZ3OH5ljFlM6/O72iyhY4y5F7i3leOrgAm+i06pvmPHkUquf3olWYmRPH5tLuEhwR1f1M/0KBFzksbGRvLy8qir6z9FKb3OSHMz7mvp7Nu1g6LwECIiIsjKyiI0NNSvzz1cXseaA2X81zmjTzguAk88Yc+Kxddfh5AQTcS6Y2hKNCNSo/tFIqaU8r99R6u59okVhIcG8/R3ZpAYrZPzW9NnErG8vDxiY2MZOnRov+v2NMaw/XAlEaHBDEmOori4mLy8PIYN8++b6XubCgC4YFL6Sa+de65fH90qY+C116wVk4laCKVbzs4ewBNf7qWirpG4CP8m8kqpvutAcQ1XP7aM+iYXz31/Vr8v2tqePrPXZF1dHcnJyf0uCQMQEeKjQqmsb8LlNiQnJwekZ3DRxsOMGRDLiNSYVl9/6y148km/h3HM9u2wYwdcemngntnXnJs9kCa34cPN/WPSvlLK9/YXV3P1Y8uobXTx7+tnMi49zu6QHK3PJGJAv0zCvOIjQzHGUFHXFJB/h8KKOlbuL+GCiSf3hnk99xz8/OfQ2Oj3cAAYMwZWroQrrwzM8/qiqYMTyEyI5K0NWoFBKdV1m/PLuezhpdQ0NPHv781kfEa83SE5Xp9KxJzo+uuvZ8uWLX5/TmRoMGEhQZTXBibreW/zYYyBCyYObPOcb34Tiovhgw8CEhIikJsLKSmBeV5fJCJcNDmdxTuPUlLdYHc4SqleZOnuYq765zLCgoWXbzyFCZmahHWGJmJ+9vjjj5Odnd3xiT0kIsRHhlJV10STy+335y3aWMDItBhGDWh7h+/zzoOkJHj2Wb+Hw5YtcP311kbfqmcunpxBk9uwaGOB3aEopXqJ55Yf4JonljMwPoJXbprNyLS23xvUiTQR86Hq6mouvPBCJk+ezIQJE3jxxReZO3cuq1atAiAmJoZf/vKXTJ48mVmzZnHkiDUPp6ioiMsuu4zp06czffp0lixZ0q3nJ0SGYjCU1/m3V6ywoo4Ve0u4YELbvWEAYWHWMOEbb0BVlV9D4umn4amnIDyw1Tv6pOz0OEakRvPmeh2eVEq1r6HJza/f2MQvXt/IqaNSePXm2WQkRNodVq/SZxOxuXNP/njoIeu1mprWX3/qKev1o0dPfq0z3nvvPTIyMli/fj2bNm1i/vz5J7xeXV3NrFmzWL9+PaeffjqPPfYYALfddhu33347K1eu5NVXX+X666/v1s8cERpMeEgw5TX+TcReWZOH28AlU07a2/gk3/wmDBwIe/b4Lx6XC/79bzj/fEjraNt51SER4eLJmazcV0JBuW5RoJRq3cGSGq545CueXrqf7582jCcWTtfV1t3QZxMxO0ycOJGPPvqIO+64gy+//JL4+BPHx8PCwrjIU+Bq2rRp7Nu3D4CPPvqIW2+9lZycHC6++GIqKiqorKzs8vNFhISoUKrq/Tc8aYzh5VV5zBiaxPA2Vks2d+qpsGsXTJrkl3AA+OQTyM+Ha6/13zP6m4tzMjAG3tJeMaVUC8YY/rP2EBc+8CV7jlbzyLen8csLswkO6r8L5nqiz9QRa+mzz9p+LSqq/ddTUtp/vS2jR49m9erVLFq0iLvuuotzWxTTCg0NPbaiMTg4mKamJgDcbjdLly4lMrLn3blJ0WEUVtRT3eDq+ORuWLG3hL1Hq7n1zJGdOt+7gLOuzlo9GeuHaQNPPw0JCfC1r/n+3v3VsJRopg1J5PkVB7n+1OEEaQOrlAKOVtXzq9c38d7mw0wdnMDfrpqiNcJ6SHvEfCg/P5+oqCi+/e1v89Of/pQ1a9Z06rpzzz2XBx988Nj369at63YMocFBxEaEUNPQREOT73vFXlx1kNjwkHbLVrRUUQFDhsBf/9rxud2RlQU33QQRER2fqzrvmllD2Hu0mq92F/v83uW1jbjcxuf3VUr5h9tteHb5fs7682d8sq2Qu84fy8s3ztYkzAc0EfOhjRs3MmPGDHJycrj33nv51a9+1anrHnjgAVatWsWkSZPIzs7mkUce6VEcSTFhuNzw4RbfFuWsqGtk0cYCvpaTQWRY5/cLi4uzyko88gg0+KEiwn33we9/7/v79nfnTxxIUnQY/2/ZPp/f+7//s4lL/rEEYzQZU8rpVuwt4dKHlvDL1zcxPiOeRbedxg/OGKFDkT7SZ4cm7XDeeedx3nnnnXDss2ZjnFXNlg5efvnlXH755QCkpKTw4osv+iyO2PAQQoKEp1cc4MJWth/qrv+sPURdo5tv5A7q8rW33goXXGBtQXTVVb6Jx+WCL76wFlP041q+fhMeEsyVuYN47Ms9FJTXkh7vm5VQB0tqeGdjAd+d0/+2I1OqN9lxpJK/fLCd9zcfYWBcBP/3jRwW5GTof7c+pj1ifZCIEBUezOJdR9lV2PVJ/61pdLl59Is9TBmcwKSsrhfpO+88GDEC/v53n4QDWGUxzjoL3n3Xd/dUJ/rWzMG4jeH5Fb4r0PbE4r0I6MbiSjnU1oIKbnluDef93xcs3nmU/zpnNJ/+dC6XTMnUJMwPNBHro2LCQogKC+bvn+zyyf3eWp9PXmktt8wd2a3/EIOC4JZb4KuvYNs2n4TEX/8Kw4ZZSZ7yj0FJUcwdncqzy/ZT09DU4/uV1TTw4sqDXDw5Q2sNKeUgbrfhix1FXPvkCs7/25d8tq2Qm+eOYPEdZ/HDeaO6NB1FdY0OTfZRQUHCNbOG8NiXe/jRvFFtbszdGW634eHPdjN2YCxnje1+oa7vfAcmT4axY7t9i2OWL4clS+Bvf4NgbR/86tazRnLZw0t5+qv93DR3RI/u9e9l+6ltdPH904f7KDqlVE8crarn9TWHeHb5fvYV15ASE87PzhvDt2YOJiEqzO7w+gVNxPqw758+nKeX7uMfn+zir9/I6fZ9Ptx6hJ2FVfztqpwelTFISLCGEgHcbquXrDuMgf/+b0hMtJI75V/ThiRx5phUHvl8N9+aNbjbBRur65t46qv9nD46lXHpcT6OUinVWTUNTXyyrZD/rM3ns+2FNLkN04Yk8uOzR3P+xIGEh+hft4GkiVgflhITzrdnDuHJJXv54bxRDEuJ7vI9mlxu7v9wB4OToriwCyUr2nPPPdYk+/ff794k+yNHrL0lf/1r/9QlUyf7yTlj+NqDi3ly8V5+fPbobt3jH5/u4mhVPbfN61wNOqWU75RWN/Dp9kI+3HKET7cXUtfoJi02nO+dOozLpmUxup19g5V/aSLWx91wxnCeXX6Au9/azL+um97l+V1PfbWPbYcrefhbUwkJ9s2UwqQk+PBDa5L9BRd0/fqBA2H7dmsvSxUYE7PimT9+II9/uZdvzxpCSkzXNvXcd7Sax7/cy9enZDJtSJKfolRKedU3uVh3oIwlu4v5YkcRG/LKcBtIiw3nsqlZXDQpgxnDkrQEhQNoIuYQq1at4plnnuGBBx7w6X3TYiP4+fwx3P3WFl5bc4jLpmV1+tpDZbX85YMdnDU2jfkdbPDdFd//vjXR/rbb4LTTutartWYNTJgA0V3v3FM99NPzRluFHF/byKPXTOtSUv/bt7cQFhLEnef7YIKgUuokRZX1bMgrY/X+UlbvL2XdwTLqm9wECUzKSuDWs0Yxb2waEzPjdacMh9FEzCFyc3PJzc31y70XnjKUdzYUcPdbmzltVAppcR2XoDfG8Os3NmMw3H3xeJ8uWQ4NhSefhDPPtOqLPf10567buNFK3K66Cp54wmfhqE4amRbLz+eP4Z53tvLyqjyunN65enJvrs/nk22F/OKCsZ363VNKta3R5WZ/cTU7jlSxraCCLQUVbM6voKC8DoCQICE7I45vzRzCKSOSmTE0ifgo3YjbyTQR86FnnnmGP//5z4gIkyZN4p577uG73/0uRUVFpKam8q9//YvBgwfz8ssvc/fddxMcHEx8fDxffPEFn332GX/+8595++23+c1vfsOBAwfYs2cPBw4c4Mc//jE/+tGPAPj3v//NAw88QENDAzNnzuShhx4iuINlg0FBwh8vn8T5f/uS/3p5PU8snE5YSPvDjA9+souPth7hrvPH+mULi9NPtybc33cf/OpXMGpU++eXlMAll0B8vDXHTNnju3OG8fHWQu5+azMzhycxJLn9rsl1B8v42cvrmTYkketma90wpTqjrtFFXmkteaU1HCypYX9xDfuKa9hztIoDxTU0ebYHCxIYnhrD9KFJTMqKZ1JWAhMz47XURC/To0RMRK4AfgOMA2YYY1a1cd584G9AMPC4MeY+z/Ek4EVgKLAPuNIYU9qTmADufmszW/IrenqbE2RnxPHrr41v8/XNmzdz7733smTJElJSUigpKWHhwoVce+21LFy4kCeffJIf/ehH/Oc//+G3v/0t77//PpmZmZSVlbV6v23btvHpp59SWVnJmDFjuOmmm9i1axcvvvgiS5YsITQ0lJtvvplnn32Wa6+9tsP4R6TGcPfF47nrtY3c8twaHvrWVELbmPP13PID/OXDHXx9SibfP81/ZQZ+9Surd6ujJKyuDq6+Gg4ehM8/h3TfbRaguigoSPjzlZM5//++4JuPLeeZ781oszTKobJarn96FWlx4Tx6zbQOk//erK02Tikvl9tQXttIaU0DxVUNFFfVc7SqnqKqBooq6zhSUc/h8joKymsprWk84drwkCCGJEcxOi2W+eMHMmpADKPSYhmZFkNEqCZdvV1Pe8Q2AV8H/tnWCSISDPwDOAfIA1aKyJvGmC3AncDHxpj7ROROz/d39DAmW3zyySdcfvnlpKSkAJCUlMTSpUt57bXXALjmmmv4+c9/DsCcOXO47rrruPLKK/n617/e6v0uvPBCwsPDCQ8PJy0tjSNHjvDxxx+zevVqpk+fDkBtbS1paZ2v63X1jME0NLn59ZubufnZNdx76QTSYo8PFdU1unjsiz3c/9EOzhyTyh8vn+TXuQQhIcdriv3971Y9sJtvPvm8666DDz6Axx6DU07xWziqkzITInnu+7NY+OQKrnxkKY8vzGXK4MQTzvloyxF+8fpG6htdPPf9mSR3cXJ/b9JBG6d6qSaXm/omN3WNLuo8n2sbXNQ1uqhpcFHb6KKmoYmaBhfV9U1U1buoqmuiqr6RyromKuuaqKhrpKymkfLaRirqGmlta1URSI4OY0BcBAPjI5gyOIH0+AiyEqPITIxkUGIUabHhOq+rD+tRImaM2Qp0NH9oBrDLGLPHc+4LwAJgi+fzXM95TwOf4YNErL2eK38xxnQ4j8r7+iOPPMLy5ct55513yMnJYd26dSedGx5+/I0rODiYpqYmjDEsXLiQP/zhD92Oc+HsoRhj+O3bW/hiRxFX5g5iSHIUlXVNvLI6j0NltZw/YSB/uXJymz1mvmYMfPyxtWXRww/DFVdYQ5CzZ8P06fCLX8A118CFFwYkHNUJEzLjefnGU7jmiRVc+tBXzBiWxIUT06mobWR9XjkfbT3C2IGx/Pm6yf1hWXx7bVyPfL6jiIYmN8BJG6S3tl1663uomzZf8x7yvmaa3dUY6/Xmz215njEnn2c8/2MwGANu0/J86zu32/PZe8yA2xjcns94znEbcBmDMQa3MbjceD5b37vdhibP100ug8vzWpPb4HJZn5vcblxuQ6PLTZPL0Og2NLncNDS5aXS5aXQZ6pvcNDS5aPAcd3djP/rosGBiI0KJiQghPjKUpOgwhqdEEx8ZSnxUGIlRoSRGhZEcE0ZSdBipMeEkRYf5bEW66p0CMUcsE2i+UV0eMNPz9QBjTAGAMaZARNrs3hGRG4AbAAYPHuynULtv3rx5XHrppdx+++0kJydTUlLC7NmzeeGFF7jmmmt49tlnOfXUUwHYvXs3M2fOZObMmbz11lscPNi5ffzmzZvHggULuP3220lLS6OkpITKykqGDBnSpVivmzOMuWPSePiz3Ty/4sCx+QbZ6XH87xWTmD0ipWs/fA+JwKuvWj1ezz0Hv/mN1WD/7ndWIjZpkvWhnGV4agxv//BUXlh5kBdWHuDXb24GYGBcBLfNG8UtZ47s08ORzbTXxgHdb7/+66X1HK2q90GIvV+QWH/MBosQFITnsxAkQkiQ9XWI9/tgIdjzfUhQkPV1sBAaFERYSBBRwUGEBglhIUGEBgcd+xweEkRosHU8IiTY+hwaTESo93MwkaHBRIVZX0eHhxAdZn2ODA3WXivVLR0mYiLyEdBa7YJfGmPe6MQzWvvN7PLfGsaYR4FHAXJzc7vxt4p/jR8/nl/+8pecccYZBAcHM2XKFB544AG++93v8r//+7/HJusD/OxnP2Pnzp0YY5g3bx6TJ0/m888/7/AZ2dnZ3HPPPZx77rm43W5CQ0P5xz/+0eVEDGBoSjR/vHwS//21bFxuQ1RYcMB6wFoTHAw33mh9FBaCy6VzwXqDxOgwbpo7gh+cPpxDZbWkxob3xzkrHbZx3W2//t/3ZuBqp2umtU54aSUc73ntnX/snJOukxNe8/bsS7NzpNk5x46JWMmT57Xj51vfB4n15CDPiyKe5Mrz+snfa5Kj+iZp2d3drZuIfAb8tLXJ+iJyCvAbY8x5nu/vAjDG/EFEtgNzPb1h6cBnxpgxHT0vNzfXrFp14qO2bt3KuHHjevyz9BX676H6GhFZbYzxT42XHmivjWvt/NbaL6VU39Ze+xWILpCVwCgRGSYiYcBVwJue194EFnq+Xgh0podNKaWcpL02Timl2tWjRExELhWRPOAU4B0Red9zPENEFgEYY5qAW4H3ga3AS8aYzZ5b3AecIyI7sVYc6ZJvpVSv0kEbp5RS7erpqsnXgddbOZ4PXNDs+0XAolbOKwbm9SQGpZSyW1ttnFJKdaRPLWnyxXy3vkD/HZRSSqneoc8kYhERERQXF/f7JMQYQ3FxMRERuqefUkop5XR9Zq/JrKws8vLyKCoqsjsU20VERJCVlWV3GEoppZTqQJ9JxEJDQxk2TDcVVkoppVTv0WeGJpVSSimlehtNxJRSSimlbKKJmFJKKaWUTXyyxVGgiUgRsL+Tp6cAR/0Yjj9p7IHXW+OG3ht7Z+MeYoxJ9Xcw/tbF9gv6/v+vTqSxB15vjRs6F3ub7VevTMS6QkRWOXF/us7Q2AOvt8YNvTf23hp3oPTWf5/eGjdo7HborXFDz2PXoUmllFJKKZtoIqaUUkopZZP+kIg9ancAPaCxB15vjRt6b+y9Ne5A6a3/Pr01btDY7dBb44Yext7n54gppZRSSjlVf+gRU0oppZRypD6diInIfBHZLiK7ROROu+PpLBEZJCKfishWEdksIrfZHVNXiEiwiKwVkbftjqUrRCRBRF4RkW2ef/tT7I6pM0Tkds/vySYReV5EHLvju4g8KSKFIrKp2bEkEflQRHZ6PifaGaNTaPtlD22/Aq+/t2F9NhETkWDgH8D5QDZwtYhk2xtVpzUB/2WMGQfMAm7pRbED3AZstTuIbvgb8J4xZiwwmV7wM4hIJvAjINcYMwEIBq6yN6p2PQXMb3HsTuBjY8wo4GPP9/2atl+20vYrgLQN68OJGDAD2GWM2WOMaQBeABbYHFOnGGMKjDFrPF9XYv0HlWlvVJ0jIlnAhcDjdsfSFSISB5wOPAFgjGkwxpTZGlTnhQCRIhICRAH5NsfTJmPMF0BJi8MLgKc9Xz8NXBLImBxK2y8baPtlm37dhvXlRCwTONjs+zx6SWPQnIgMBaYAy20OpbP+D/g54LY5jq4aDhQB//IMSzwuItF2B9URY8wh4M/AAaAAKDfGfGBvVF02wBhTANabOJBmczxOoO2XPf4Pbb8CStuwvp2ISSvHetUSURGJAV4FfmyMqbA7no6IyEVAoTFmtd2xdEMIMBV42BgzBaimFwyReeYiLACGARlAtIh8296olA9o+xVg2n7ZQ9uwvp2I5QGDmn2fhYO7O1sSkVCsRuxZY8xrdsfTSXOAi0VkH9ZQylki8m97Q+q0PCDPGOP9y/0VrIbN6c4G9hpjiowxjcBrwGybY+qqIyKSDuD5XGhzPE6g7Vfgaftlj37fhvXlRGwlMEpEholIGNbkvzdtjqlTRESwxvq3GmP+anc8nWWMucsYk2WMGYr17/2JMaZX/GVjjDkMHBSRMZ5D84AtNobUWQeAWSIS5fm9mUcvmaTbzJvAQs/XC4E3bIzFKbT9CjBtv2zT79uwEJ+H4xDGmCYRuRV4H2sVxpPGmM02h9VZc4BrgI0iss5z7BfGmEX2hdQv/BB41vPGtwf4js3xdMgYs1xEXgHWYK1WW4uDK1SLyPPAXCBFRPKAXwP3AS+JyPewGuUr7IvQGbT9Ut3Q69ov0DYMtLK+UkoppZRt+vLQpFJKKaWUo2kippRSSillE03ElFJKKaVsoomYUkoppZRNNBFTSimllLKJJmJKKaWUUjbRREwppZRSyiaaiCmllFJK2eT/A5z6vUmlIUfmAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pts = np.exp(t_pts)         # another function for a separate plot\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))  # allow more room for two subplots\n",
    "\n",
    "# call the first axis ax1\n",
    "ax1 = fig.add_subplot(1,2,1)  # one row, two columns, first plot\n",
    "ax1.plot(t_pts, x_pts, color='blue', linestyle='--', label='sine')\n",
    "ax1.plot(t_pts, np.cos(t_pts), label='cosine')  # just label the plot\n",
    "ax1.legend()\n",
    "\n",
    "ax2 = fig.add_subplot(1,2,2)  # one row, two columns, second plot\n",
    "ax2.plot(t_pts, np.exp(t_pts), label='exponential')  \n",
    "ax2.legend();\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving a figure\n",
    "Saving a figure to disk is as simple as calling [`savefig`](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.savefig) with the name of the file (or a file object). The available image formats depend on the graphics backend you use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us save the figure (named 'fig') from the previous cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig(\"sine_and_exp.png\")\n",
    "# and a transparent version:\n",
    "fig.savefig(\"sine_and_exp_transparent.png\", transparent=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`````{admonition} Further examples with matplotlib\n",
    ":class: tip\n",
    "The [matplotlib gallery](https://matplotlib.org/gallery.html) is a good resource for learning by working examples.\n",
    "`````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced feature: Widgets for graphical exploration\n",
    "\n",
    "A widget is an object such as a slider or a check box or a pulldown menu.  We can use them to make it easy to explore different parameter values in a problem we're solving, which is useful for building intuition.  They act on the argument of a function. \n",
    "\n",
    "The set of widgets we'll use here (there are others!) is from `ipywidgets`; we'll conventionally import the module as `import ipywidgets as widgets` and we'll also often use `display` from `Ipython.display`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest form is to use `interact`, which we pass a function name and the variables with ranges.  By default this makes a *slider*, which takes on integer or floating point values depending on whether you put decimal points in the range. **Try it! Then modify the function and try again.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "16412c877f5b4973b0c35ddeaabfbfff",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=5.0, description='x', max=10.0), Output()), _dom_classes=('widget-inte…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We can do this to any function\n",
    "def test_f(x=5.):\n",
    "    \"\"\"Test function that prints the passed value and its square.\n",
    "       Note that there is no return value in this case.\"\"\"\n",
    "    print ('x = ', x, ' and  x^2 = ', x**2)\n",
    "    \n",
    "widgets.interact(test_f, x=(0.,10.));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5d51fd0c19f6448b9280b5ddefd3b0be",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=10.0, description='x', max=30.0, min=-10.0, step=1.0), Output()), _dom…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Explicit declaration of the widget (here FloatSlider) and details\n",
    "def test_f(x=5.):\n",
    "    \"\"\"Test function that prints the passed value and its square.\n",
    "       Note that there is no return value in this case.\"\"\"\n",
    "    print ('x = ', x, ' and  x^2 = ', x**2)\n",
    "    \n",
    "widgets.interact(test_f, \n",
    "                 x = widgets.FloatSlider(min=-10,max=30,step=1,value=10));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example with some bells and whistles for a plot.  **Try making changes!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0b59f51a94a849498b0eaf6644f08652",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=1.0, description='freq', max=2.0, min=0.1), Dropdown(description='colo…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_it(freq=1.0, color='blue', lw=2, grid=True, xlabel='x', function='sin')>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_it(freq=1., color='blue', lw=2, grid=True, xlabel='x', \n",
    "            function='sin'):\n",
    "    \"\"\" Make a simple plot of a trig function but allow the plot style\n",
    "        to be changed as well as the function and frequency.\"\"\"\n",
    "    t = np.linspace(-1., +1., 1000)  # linspace(min, max, total #)\n",
    "\n",
    "    fig = plt.figure(figsize=(8,6))\n",
    "    ax = fig.add_subplot(1,1,1)\n",
    "\n",
    "    if function=='sin':\n",
    "        ax.plot(t, np.sin(2*np.pi*freq*t), lw=lw, color=color)\n",
    "    elif function=='cos':\n",
    "        ax.plot(t, np.cos(2*np.pi*freq*t), lw=lw, color=color)\n",
    "    elif function=='tan':\n",
    "        ax.plot(t, np.tan(2*np.pi*freq*t), lw=lw, color=color)\n",
    "\n",
    "    ax.grid(grid)\n",
    "    ax.set_xlabel(xlabel)\n",
    "    \n",
    "widgets.interact(plot_it, \n",
    "                 freq=(0.1, 2.), color=['blue', 'red', 'green'], \n",
    "                 lw=(1, 10), xlabel=['x', 't', 'dog'],\n",
    "                 function=['sin', 'cos', 'tan'])\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}