Day 1 - Python Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Computational Memory Lab Python Bootcamp\n",
    "\n",
    "### Introduction\n",
    "Welcome to the Computational Memory Lab (CML) Python Bootcamp! In this Jupyter Notebook, we'll walk through the course structure, learn about Jupyter, and review the basics of Numpy. By the end of this lesson, you'll be able to start writing your own code in Jupyter Notebooks.\n",
    "\n",
    "### Python for Data Science\n",
    "For the sake of time, this bootcamp will assume you have a basic working knowledge of Python (e.g. data types, functions, loops, etc.). If you're looking for a refresher, check out some of these resources: \n",
    "* Codecademy (https://www.codecademy.com/learn/learn-python-3)\n",
    "* Coursera (https://www.coursera.org/learn/python-data-analysis)\n",
    "* Python Data Science Handbook (https://github.com/jakevdp/PythonDataScienceHandbook)\n",
    "\n",
    "Though this list is by no means exhaustive!\n",
    "\n",
    "### Basic course structure\n",
    "\n",
    "The Computational Memory Lab's Python Bootcamp will run June 3 - June 14, Monday through Friday, from 9 a.m. to noon each day. Our goal is to familiarize you with basic Python tools for data science, and the libraries developed by our lab to facilitate EEG analyses. To that end, the course outline is as follows: \n",
    "\n",
    "<ul>\n",
    "    \n",
    "Day 1 (M, June 3)\n",
    "<b>Python basics, Jupyter Notebooks, numpy, plotting</b>\n",
    "\n",
    "Day 2 (T, June 4)\n",
    "<b>Pandas, Data loading, experimental events</b>\n",
    "    \n",
    "Day 3 (W, June 5)\n",
    "<b>Analyzing EEG data I (MNE, electrodes, referencing, ERPs)</b>\n",
    "    \n",
    "Day 4 (Th, June 6)\n",
    "<b>Analyzing EEG data II (signal processing, time-frequency decomposition)</b>\n",
    "    \n",
    "Day 5 (F, June 7)\n",
    "<b>Analyzing EEG data III (univariate statistics)</b>\n",
    "    \n",
    "Day 6 (M, June 10)\n",
    "<b>Analyzing EEG data IV (multiple comparisons, non-parametric tests)</b>\n",
    "\n",
    "Day 7 (T, June 11)\n",
    "<b>Connectivity (circular data, phase-locking, coherence, graph theory)</b>\n",
    "\n",
    "Day 8 (W, June 12)\n",
    "<b>Machine Learning I (big concepts, sklearn, regression/classification)</b>\n",
    "\n",
    "Day 9 (Th, June 13)\n",
    "<b>Machine Learning II (cross-validation, feature selection, other classifiers)</b>\n",
    "\n",
    "Day 10 (F, June 14)\n",
    "<b>Parallel computing & wrap-up/Q&A</b>\n",
    "    \n",
    "</ul>\n",
    "\n",
    "By the end of this course, you should be able to carry out EEG/iEEG/ECoG analyses, like computing spectral power and phase, and compute statistics or apply machine learning models to those data. Note that insights into behavioral analyses will organically come along with this course, but the emphasis is on electrophysiology. \n",
    "\n",
    "### Jupyter Notebooks for Data Science\n",
    "The Jupyter Notebook (and Jupyter Lab) is a powerful interface to IPython for data science. The notebook structure keeps figures and outputs organized with their generating code, and supports integration with text and images. This lets data scientists (like you!) keep a full log of everything that went into an analysis or manuscript. The cell-based structure of Jupyter Notebooks -- as you'll see soon -- makes it easy to tweak analyses without needing to re-run your whole pipeline, saving lots of time. \n",
    "\n",
    "In the Computational Memory Lab, we run Jupyter Notebooks on a server (Rhino2), letting you access your analyses from anywhere (see referenced tutorial). This also makes it easy to load large amounts of EEG data and run parallel processes. But if you'd like, feel free to install Jupyter Notebooks on your computer and run them locally (Jupyter Lab comes with all default Anaconda installations). \n",
    "\n",
    "If you already have an account on Rhino2, you've already got access to Jupyter Lab -- congratulations! Instructions for this are in the Rhino_Usage.ipynb file.\n",
    "\n",
    "Jupyter Notebooks can do some amazing things, but we don't have the time to discuss them all. Check out this list for some inspiration: https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/\n",
    "\n",
    "### Setting up JupyterLab\n",
    "\n",
    "1. You'll need to follow a few simple steps to get your account set up with all the important Python tools for data analysis. If you have installed JupyterLab on your own computer, open a terminal window there.  If you are using it on a server, log into that server, and follow these setup instructions.  First create a conda environment:\n",
    "\n",
    "<code>conda create -y -n environmentname python=3.7</code>\n",
    "<code>source activate environmentname</code>\n",
    "\n",
    "2. Next, you'll need to install a suite of tools for EEG analysis. First, install MNE by typing the following (be sure you're in the Anaconda \"environment\" you just created in Step 1, by typing \"source activate environmentname\"). Note that this may take a while, because MNE has a lot of dependencies: \n",
    "\n",
    "<code>conda install -c conda-forge mne</code>\n",
    "\n",
    "Next, install PTSA, which is another set of EEG tools developed by the CML:\n",
    "\n",
    "<code>conda install -c pennmem ptsa</code>\n",
    "\n",
    "3. Finally, you'll need to link JupyterLab with your specific Python installation. While still logged in to your rhino account and in your Anaconda \"environment\", type: \n",
    "\n",
    "<code>conda install ipykernel</code>\n",
    "\n",
    "and once that's done:\n",
    "\n",
    "<code>python -m ipykernel install --user  --name environmentname --display-name \"environmentname\"</code>\n",
    "\n",
    "\n",
    "You should be all set! Next time you log in to your JupyterLab account, you should see an option to launch a new notebook with \"environmentname\" as your Python environment. If you've been logged in to JupyterLab this whole time, you may need to log out and log back in again to see this change take effect. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy: The MATLABification of Python\n",
    "If you've used Python before, you're likely familiar with the numpy module, which essentially gifts Python with all of othe useful array operations you might have used in MATLAB. Numpy lets you efficiently perform operations on large amounts of multidimensional data, unlike Python lists, which would require lots of for-loops. Let's explore some of Numpy's functionality. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  7,  9, 12])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#First, the import statement\n",
    "import numpy as np\n",
    "\n",
    "#Make an array from an existing list\n",
    "np.array([0, 1, 7, 9, 12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Make a sequential array\n",
    "np.arange(0, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Make a matrix of zeros\n",
    "np.zeros((3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.939771  , 0.47629402, 0.94029578, 0.14346379],\n",
       "       [0.16479236, 0.65284131, 0.57763281, 0.0464016 ],\n",
       "       [0.6394855 , 0.31654039, 0.19086157, 0.05679364]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Make a matrix of random floats from 0 to 1\n",
    "np.random.random((3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [0, 0, 0],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Note that data types can be specified, e.g.\n",
    "np.zeros((3, 3), dtype='int')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with arrays\n",
    "These concepts will be very familiar to MATLAB users."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)  # seed for reproducibility\n",
    "\n",
    "x1 = np.random.randint(10, size=6)  # One-dimensional array\n",
    "x2 = np.random.randint(10, size=(3, 4))  # Two-dimensional array\n",
    "x3 = np.random.randint(10, size=(3, 4, 5))  # Three-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x3 ndim:  3\n",
      "x3 shape: (3, 4, 5)\n",
      "x3 size:  60\n",
      "x3 dtype: int64\n"
     ]
    }
   ],
   "source": [
    "#Get some array attributes\n",
    "print(\"x3 ndim: \", x3.ndim)\n",
    "print(\"x3 shape:\", x3.shape)\n",
    "print(\"x3 size: \", x3.size)\n",
    "print(\"x3 dtype:\", x3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 0, 3, 3, 7, 9])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Remember that Python is zero-indexed!\n",
    "x1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can index into arrays in reverse order\n",
    "x1[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 5, 2, 4],\n",
       "       [7, 6, 8, 8],\n",
       "       [1, 6, 7, 7]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Indexing goes by row, column\n",
    "x2[1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3  5  2  4]\n",
      " [ 7  6 99  8]\n",
      " [ 1  6  7  7]]\n"
     ]
    }
   ],
   "source": [
    "#You can reset values with the same notation\n",
    "x2[1, 2] = 99\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array slicing\n",
    "How to access sub-arrays. The general notation is as follows: \n",
    "\n",
    "<code>\n",
    "subarr = x[start:stop:step]\n",
    "</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:5] #the first five elements "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[5:] #elements after index 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[3:7] #elements from index 3 to 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::2] #every other element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::-1] #array in reverse!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-3:] #last three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  5,  2],\n",
       "       [ 7,  6, 99]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[:2, :3]  # two rows, three columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[47  3 76 52 78 15 20 99 58 23]\n"
     ]
    }
   ],
   "source": [
    "#\"Fancy indexing\" lets us use arrays/lists to access multiple elements of an array\n",
    "x = np.random.randint(100, size=10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([52, 99, 78])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ind = [3, 7, 4]\n",
    "x[ind]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[52, 99],\n",
       "       [78, 15]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#One thing to note is that fancy indexing yields an array with the shape of the index, not the original array. Watch how we create a 2D array by indexing into a 1D array.\n",
    "ind = np.array([[3, 7],\n",
    "                [4, 5]])\n",
    "x[ind]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Operations\n",
    "Boolean operations are a key way to filter data by their values (called \"masks\"). The syntax is pretty simple (and almost identical to MATLAB):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False,  True,  True,  True,\n",
       "        True])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.arange(5, 15, 1)\n",
    "y > 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 12, 13, 14])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Index according to a boolean operation\n",
    "y[y > 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False False  True  True  True False False False]\n",
      "[ True  True  True False False False False False  True  True]\n"
     ]
    }
   ],
   "source": [
    "#Multiple operations can be combined \n",
    "print((y > 8) & (y < 12))\n",
    "\n",
    "print((y > 12) | (y < 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that <code>and</code> and <code>or</code> are also used to make Boolean comparisons in Python, but these refer to the entire object, not to bits within the object. So for most array manipulations and masking purposes, you should use \"&\" and \" | \""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numpy Recarrays\n",
    "Numpy arrays can store more than numerical data in rows and columns. They can also be given attributes (like column headers), such that each column corresponds to a different kind of information. These kinds of arrays are called structured arrays or recarrays (\"record arrays\"). You'll see them pop up a few times in CML datasets, though typically you'll be using pandas (covered tomorrow). So, we'll touch on them very briefly.\n",
    "\n",
    "Imagine that we have several categories of data on a number of people (say, name, age, and weight), and we'd like to store these values for use in a Python program. It would be possible to store these in three separate arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('name', '<U10'), ('age', '<i4'), ('weight', '<f8')]\n"
     ]
    }
   ],
   "source": [
    "name = ['Alice', 'Bob', 'Cathy', 'Doug']\n",
    "age = [25, 45, 37, 19]\n",
    "weight = [55.0, 85.5, 68.0, 61.5]\n",
    "\n",
    "# Use a compound data type for structured arrays\n",
    "data = np.zeros(4, dtype={'names':('name', 'age', 'weight'),\n",
    "                          'formats':('U10', 'i4', 'f8')})\n",
    "print(data.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here 'U10' translates to \"Unicode string of maximum length 10,\" 'i4' translates to \"4-byte (i.e., 32 bit) integer,\" and 'f8' translates to \"8-byte (i.e., 64 bit) float.\" We'll discuss other options for these type codes in the following section.\n",
    "\n",
    "Now that we've created an empty container array, we can fill the array with our lists of values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Alice', 25, 55. ) ('Bob', 45, 85.5) ('Cathy', 37, 68. )\n",
      " ('Doug', 19, 61.5)]\n"
     ]
    }
   ],
   "source": [
    "data['name'] = name\n",
    "data['age'] = age\n",
    "data['weight'] = weight\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy also provides the np.recarray class, which is almost identical to the structured arrays just described, but with one additional feature: fields can be accessed as attributes rather than as dictionary keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([25, 45, 37, 19], dtype=int32)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_rec = data.view(np.recarray)\n",
    "data_rec.age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For anything more complicated than this, you're much better off using pandas! (To be covered tomorrow.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting (matplotlib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll be plotting often in data science, especially with the ease-of-use of the Jupyter notebook. As with other Python topics, we're going to assume some level of familiarity with basic plotting functionality and the matplotlib library. These functions should also be very familiar to those of you coming in with a MATLAB background. But let's walk through a few examples, just to re-orient ourselves. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This 'magic' command tells the notebook how to display plots. We'll use 'inline' throughout this course.\n",
    "%matplotlib inline\n",
    "\n",
    "#import statement -- many opt for 'import pylab as plt', but I find it easier to just 'from pylab import *'\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": [
    "#Basic line plotting examples\n",
    "import numpy as np\n",
    "x = np.linspace(0, 10, 100)\n",
    "\n",
    "fig = plt.figure()\n",
    "plt.plot(x, np.sin(x), '-')\n",
    "plt.plot(x, np.cos(x), '--');\n",
    "\n",
    "#And always be sure to label your axes!\n",
    "plt.xlabel('My X Values')\n",
    "plt.ylabel('My Y Values')\n",
    "\n",
    "#Saving figures is pretty easy\n",
    "fig.savefig('my_figure.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "matplotlib also gives us access to a set of styles, which are kinda fun. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Y Vals')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEUCAYAAAA1EnEjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOydd3hUVfr4PzOTXkmdBEIKCaSR0HsTEhJgBaNSVSworqvrrh3LT8VF0bWvrLpfZV0VG9Kkk4B0CC20kIRAKCGE9EJ6MpmZ3x9jhgRIn5k7N7mf58nzzJl7zznvncyd9573vEWm1Wq1SEhISEhININcaAEkJCQkJMwbSVFISEhISLSIpCgkJCQkJFpEUhQSEhISEi0iKQoJCQkJiRaRFIWEhISERItIikJCoguxdu1aRowYIbQYEl0MSVFIdDkmTZrEwIEDqaysvOXYli1bCA4OZtmyZe0ed+3atQQHB/Ptt9/ecuzll1/u0JjtYdmyZYSEhBAREUFERASRkZHExMSwbNky6urqOjTm2rVrKSoqMrCkEl0NSVFIdEns7OxISEi45f2NGzfi5ubW4XF79OjBZ599Rl5eXmfE6zBhYWEkJyeTnJzMyZMn+fjjj1m3bh2ff/55u8fSaDS8++67kqKQaBVJUUh0SSZMmMD69eubvFdaWsqxY8cYPnw4ANeuXSMkJITU1NQm502fPp3ly5ffdtx+/foRHR3N0qVLW5w/Pj6euLg4Bg4cyKRJk1izZg0An3zyCU8++aT+vM2bNxMcHMzp06f178XFxenPbwm5XE7//v154IEH2L59+23PuXDhAo888gjDhw/njjvuYNGiRZSXlwMwePBgysrKuOeee/j0009bnU+i+yIpCokuSVRUFCdPnmzy5L9161ZGjx6NjY0NAD179mTEiBFNFEpmZiYZGRlMnz692bEXLVrEwYMH2b9//22PnzlzhkWLFvHss8+SlJTERx99xLvvvsu+ffsYOXIkx48f15979OhRAgICSEpKAqCiooL09HRGjRrV5mtVq9UoFIpb3q+rq2PBggUEBwezZ88efv75Z9LT01myZAkAmzZtAnTmp2eeeabN80l0PyRFIdElcXR0ZOLEiWzYsEH/3saNG7nrrruanHf33XezefNm1Go1oFsJDB8+HKVS2ezYbm5uPPPMMyxZsuS2ewNr1qxh/PjxTJgwAYVCwaBBg4iLi2PdunUMHjyYqqoqLl26BOgUxX333cexY8cASEpKwtfXl549e7Z6jWq1muTkZH766afbKra9e/dSVlbGM888g62tLd7e3jz66KPNrj4kJJpDUhQSXZa4uDi9orh69SqXL19m/PjxTc6JiYmhsrKSxMREABISEm5RJrdj3rx5ODg48NVXX91y7MqVK+zYsUO/6RwREcEvv/xCbm4u1tbWDBw4kOPHj1NcXMz169eJi4vj5MmTgE5RjBw5stl5U1NT9WMOHjyYl156iXnz5vHoo4/ecu7Vq1fx8fHRr6AA+vTpQ1VVFaWlpa1eo4REAxZCCyAhYSzGjh3La6+9RlpaGnv27GHatGlYWDT9ytvZ2REbG8umTZvo06cPGRkZxMTEtDq2XC5n8eLFzJ8/nxkzZjQ5ZmNjw6xZs3jrrbdu27fB/OTo6MjgwYNxcnLCxcWFCxcucOzYMR566KFm5w0LC2Pt2rVtuHodMpnstu+rVKo2jyEhIa0oJLosCoWCO++8ky1btrBly5ZbftAbiIuLY+fOnWzatImJEyfi4ODQpvEjIiKIi4vjH//4R5P3fX19SU9Pb/JeXl6e/se5QVEcOXKEIUOGADBo0CAOHTpESkqKweIgevfuzdWrV6mtrdW/d/HiRezt7Tvl+SXR/ZAUhUSXJi4ujs2bN6NSqYiMjLztOSNGjNCbkZpTJs3x3HPPkZqayoEDB/TvzZ49m9OnT7Ny5Urq6urIyMhg3rx5+k3zyMhI8vPz2bdvH0OHDgV0iuKnn34iMDCQHj16dPBqmzJu3DicnJz49NNPqaur4+rVq3z11VfExcUhl8v1JqnLly9TUVFhkDkluiaSopDo0oSEhODk5NTivoNMJmPGjBlYWFgwbty4do3v5OTESy+9RH5+vv69gIAAPvnkE7777juGDBnC448/zuzZs5k5cyYAFhYWDBkyhIKCAkJCQgCdq2pGRka7vJ1aw8rKimXLlpGcnMzo0aOZP38+48aN4+WXXwbA3d2d2NhYnnvuOT788EODzSvR9ZBJFe4kJODVV1/F2dmZRYsWCS2KhITZIW1mS3R7du/ezfbt25u40kpISNxAUhQS3ZopU6ZQV1fH+++/j7e3t9DiSEiYJZLpSUJCQkKiRaTNbAkJCQmJFpEUhYSEhIREi3S5PYqG5GoSEhISEu2jIQD0ZrqcooDmL7Y10tLSCA0NNbA05o10zd0D6Zq7B5255pYesiXTk4SEhIREi0iKQkJCQkKiRSRFISEhISHRIpKikJCQkJBoEUEVxblz54iOjuaHH3645djBgweZOXMmc+bMaVI4funSpcyZM4e5c+c2qTMsISEhIWEcBPN6qqqqYsmSJc1my3z77bf573//i1Kp5L777iM2Npbi4mIyMzNZuXIlGRkZvPLKK6xatcrEkktISEh0LwRTFFZWVnz99dd8/fXXtxzLysrC2dlZn3tnwoQJJCYmUlxcTHR0NABBQUGUlZVRUVHR5kIzrbG3cC9f7fqK3o69GawczEjvkdhY2LTeUUJCZKg0Kg7nHOZE/gkulF6gUlWJpdySng49GeAxgLG9xuJi4yK0mBJmgmCKwsLC4paylA0UFBTg6uqqb7u7u5OVlUVJSQnh4eH6993c3CgoKDCYorhQeYEdeTsA+F/K/3CycuLuoLt5NOJRs7tp6tUa9p4vYEtyLieulHCttIbaejXuDtb0VTowvq8HcYN6oXSSFJ3EDcrryvku5TtWnVtFcU3xbc9Zmb4SVxtXdszagaXc0sQSto5Wq+X01etsOHWNY5klXMivoFqlxsHaAn93e8YEunFnZE9uXwRWoiOYZcDd7fIUymSyW97XarW3rQmclpbWoXlLakuatMvqyvgu9TtWpa/iPp/7mOw5udkaxKZCo9Wy62IFK06WkFdRj6O1nDAPGwb0dcBSIaO4up7zReW8m1HEB/FnmdTHkYcHu+Bie/t/dU1NTYc/L7HSXa/5mwPf8PWlr6lQt17NbrzLeDLSM0wgWftIya/hf0nFpOTXYCmXEeppzaQAO2wt5VTUacgsqeE/ey7wxe4LRCqtWFhUS5CbtdBimwxjfbfNUlEolUoKCwv17by8PDw8PLCwsGjyfn5+Pu7u7rf072hk4j2V93BP5D2kFqWyPXM72RXZAFSpq1ieuZwMTQbvjH0HJyunDo3fWa6VVvPi6lMcyCgivKcTb8X1ZVKIJ1YWt/okXC6s5NuDl/nxcCaJWdX8Iy6cuwf53HKeFL3aPUhLS8PFwYWKjBtKwtPOkxi/GMLdw3G1dqW6vpqM0gwOXjvI02OfxtPOs8kY9Zp6LOTC/GRU16l5b2sa3yVew9PRmrdmhBM3qBfOtreueEqr6vjlaBZf7jrH3zdns3B8H16ICcZS0fWdPI0VmW2WisLHx4eKigquXr2Kl5cXu3bt4sMPP6SkpIRly5Yxd+5cUlNT8fT0NJjZCcDf3p/QgFCmBkzl2SHPsitrF58mfcrlsssA7M7azcPbHubLqC9R2isNNm9bSMosYeH3x6hRqVl6dwRzh/VGLm9+dePvbs/iGeE8OMqPl9ck8+zKUxy7XMJbM8Kx6AY3jMStxAXF8fuV3zlfcp6nBz/NVP+pKOSKJudE+UXx5wF/vqVvQVUBC+IX8NbotxisHGwqkQHIK6vhse+OkZx9nQVjAngxNhhbK0Wz5/ews+KJCYEMdq5m7QUN/7fnIsczS/jPA0Nwc+g+qwtDIpiiOHPmDP/85z/Jzs7GwsKC+Ph4Jk2ahI+PD5MnT2bx4sU8//zzAEybNo2AgAACAgIIDw9n7ty5yGQy3nzzTaPJJ5fJifKNYmyvsXya9Ck/pOlceM+XnOfRhEdZN2MdlgrT2G/jU3L5288n8Ha2YfUTo+jj0Xbl2MfDgZ8WjuCDhHT+b89FCspr+WzeIGwsm7/RJLomMpmMJWOWYKWwwt7Svs396jX1vLj3RS6XXebP2//MpxM/ZUyvMUaU9AYZ+RXM/+9hrler+O9DQ4kKbfsDmqO1gvfu7c+oQDcWrTnN7P9L5IfHRuDtbGtEibsmgimK/v37s2LFimaPDxs2jJUrV97y/gsvvGBMsW7BWmHNouGLCHML440Db2CpsOTVEa+aTEnsPJvHUz8eJ8LHmf8+NAxXe6t2j2GhkPPK1FC8nGx4a2Mqj69IYvmDQ29rspLoGlyvvc5PaT+xMHJhE3NRR5wy8qvyuXz9MgA16hqe2fUMX8d8zUDPgYYS97ZkFlVy//JDqDWw6olRhPd07tA4dw3shbezLQu+Pcqs/ySy+onReDlLTh7tQfqlaCPTA6fz76h/szxmOaN7jjbJnIcvFvHED8cJ9XbiuwXDO6QkGvPImADeuyeCvecKWLTmNBqNVNywK6LSqHh297N8ceoLXt73MiqNqlPj9XToyXdTv8PbXueuXqOu4emdT3Pp+iVDiHtb8struO/rw9TVa/jxsREdVhINDA9w5aeFIyitUvHw/45QVtO5z6S7ISmKdjCm1xgiPSJNMtfVkir+8uNxfFxs+W7BcJxsDLOCmTvcl+cn92PdiWw+2XHOIGNKmBfvH3mfo7lHAYi/HK9/3Rn8nPz4OuZrXKx1K5LS2lL+tvNvVKoqOz32zdTWq3liRRLFlXV8v2AEwV6OBhk30qcHXz4wmIz8Cv7yQxL1ao1Bxu0OSIqikxTXFLMjc4dBx6yuU/P490mo1BqWPzi00yuJm/nrpCBmDfFh2c4MDmcZ/kaXEI4NFzbwS/ov+vbTg5422ArYz8mPz6M+x9ZCZ+O/XHaZNw++eVt39s7w+m9nOH6llI9nDyDCp3MriZsZ19eDpfdEcCCjiI+3Sw9KbUVSFJ0gpTCFOZvm8OLeFzlbfNZg4769OZW03DI+mzeoXRvXbUUmk7Ekrj9h3k58uL+ArOIqg88hYXqyyrN459A7+nasfywLIxYadI4IjwjeGPWGvh1/OZ5f03812PjrT2bz67GrPD0piKkR3gYbtzGzh/Zm3vDefLH7Ar+n5Rlljq6GpCg6iFar5YNjH5BbmUu9pp5X9r1Cnbqu0+P+npbHj4evsHBcHyYGe7beoYPYWCr4zwND0Gi1vLDqlLRfIXLqNfW8uu9Vqup1St/fyZ9/jP6HUQJE7+xzJ7P7zda3P0r6iKzyrE6Pe7Wkiv+37gxD/Fz4e1TfTo/XEm9ODyfM24mXVp+mqKLWqHN1BSRF0UFkMhmLRy3GRqHznsgozeDzk5+30qtlCitqWbTmNCFejjwf088QYraIr5sdjw9z4/ClYr5PvGz0+SSMx7cp33Ky4CQAFjIL3hv3HnaWdkab76XhLxHUIwiA6vpqPj72cafG02i0PPfrKbTAJ7MHGj3Wx8ZSwSdzBlJeU88b61OMOldXQFIUncDf2Z9nhzyrb3+b8i2pRakdHm/JplTKquv519xBWFuYJs4hJsiRO4I9+Oe2dC4XSvsVYiSrLIv/nPqPvv2XgX8h3D28hR6dx1phzdtj3kYhUxDrH8vro17v1Hg/HbnCkUvFvDE9DF834ym4xgR7OfL36L5sTs5h0+lrJplTrEiKopPMDZnLCO8RAGi0Gt459A4abfu9KfafL2T9yWs8cUegwbw82oJMJuO9eyKxUMj4f7+dMfjGpIRx0Wq1vHPkHWrVOvNJqGsoC/ovMMnc4e7hrJ6+mg8nfIirjWvrHZqhoLyWf247y+hAN2YNuTXNjDH58/g+RPo48+b6FK5XSy6zzSEpik4il8l5feTr+iybpwtP81vGb+0ao0al5vX1Z/Bzs+PJOwKNIWaLeDnb8EJMMPszColPyTX5/BIdJ68qj7QiXRI4GTLeGPWGSfMxBbkEdXqMdzanUqvSsCSuv8mTbloo5Cy9O4Liqjo+ldzFm0VSFAbAz8mPh8Mf1rc/SfqE67XX29x/+b6LXCqsZMld/QVLrXH/CF9CvBxZsimN6jq1IDJItB8vey82xG1gdr/ZzAuZR3/3/kKLRL2mvs3nHr5YxG9/rKQDjeDh1xb693Jm3nBfvk/MJD23XBAZzB1JURiIhZEL6WnfE9AFIy1PXt6mfgXltXy5+wIxYUrG9/MwpogtYqGQ89aMcLJLq/lyt/mll5ZoHmdrZ14f9TovD39ZUDnK68p5/+j7PLLtkTaZMDUaLUu3pNHT2UaQlXRjXowJxsHagsUbUiTz622QFIWBsLWw5bmhz+nbP6X9RE5FTqv9Pvv9PDX1GhZNDTGmeG1iRB83/hTpzdf7LpFfXiO0OBLtRMhaKSq1ilkbZ7EidQUnC06y40rrQaibk3M4dfU6z8cEC56k0sXeiucm9yPxYhG7zxUIKos5IikKAxLjF0OEewSOVo48NeipVhOwXSyo4OcjV5g3vLdgy+6beSEmmDq1hs93SqsKc6aoukhoEZpgqbAk2jda3152YlmLJqjaejXvx58l1NuJuEG9TCFiq8wb7ktvV1s+2JYuxRXdhKQoDIhMJmPp2KVsvWcrC/ovaLXe9gfx6VhZyPl7lPFjJtpKgLs9s4f25qcjV6SIbTPlWsU1YtfE8v/2/z9yK83H+eDRiEf16csvXb/Exgsbmz33h0NXyCqu5pWpIShaqKtiSqws5Dw3uR+pOWVsTm7dGtCdkBSFgfF39sfZuvX8NGeyr7P1TC4Lx/XBw9G8iqn8PaovcpmMT6RcOGbJf5P/S626lvUX1vPa/teEFkePi40LD4U/pG9/eerL22YrqK5T8+XuDEYHugm6L3c7ZgzoRbDSkY+3n0MlJQ3UIykKgfj3zgwcbSx4dFyA0KLcgpezDQ+P9mfdyWwy8iUvEHMitzKXdRnr9O2FkYbN5dRZHgx7UB9TkVOZw9rza28556cjVyisqOOZaPNZSTegkMt4PqYflworWXv8qtDimA2CKYqlS5cyZ84c5s6dy+nTp/Xv5+XlMX/+fP3fHXfcwcaNGzlz5gzjx4/Xv79kyRKhRG8XF0svsvJs0wJM6bnlbEvJ5ZHR/gZLH25oHh/fB2sLOV/uvii0KBKN+N+Z/+nrSwz0GMgIrxECS9QUe0v7JgF/36Z822Svokal5v/2XGBUHzeGB3Q8SM+YTA5TEtHLmS93X0At7VUAAlW4O3LkCJmZmaxcuZKMjAxeeeUVVq1aBYBSqdRXvquvr2f+/PlMmjSJlJQUYmNjee0181lqt4RKreLlfS+zPXM7MpmMkT1H4ufkB8Cyneext1KwYKz5rSYacHOw1vuWPxPdl96upkmrINE8BVUFrD63Wt9+YsATgno6NcesfrNYnryc0tpSsiuy2XppK9MDpwPw67Es8str+dfcQQJL2TwymYwn7wjkLz8eZ0tyDtMH9BRaJMERZEWRmJhIdLTOQyIoKIiysjIqKipuOW/dunXExsZib29PZaW48hBZKiypVFWiRYtGq+Hr018DuhrAm5NzeHC0Pz3sDFtnwtAsHNcHuQy+2iutKsyB71K+o06js/lHuEeYrNJie7GztOOB0Af07f8m/xeNVkNdvYYvd19guL8rI/uY52qigdhwLwI97Pl8V4YUV4FAK4rCwkLCw28kLXNzc6OgoAAHh6YuoqtWreKbb74BoKqqiqSkJB577DGqq6t5+umnGTly5G3HT0tL65BcNTU1He57O2KdYzlw7QAAmy5uYqrjVL4/psZKLmO8st6gc3WU1q55Uh8HfjlyhSm+WlxtBSuxblAM/X82BVX1Vfx69kbdh2ku0zh7tu01UEx9zYPlg7GV21KtqebC9Qv8mPgjpcXB5Fyv4alhPdole0fp7DXf1c+Ojw8U8P2O4wz3EceK2lj/Z0Hu/Js1tFarvWUJfeLECfr06aNXHiEhITz11FNERUVx6dIlHnnkERISErCyuvWpPDQ0tENypaWldbjv7QgllHVF6ziRfwK1Vs2+6sPsuhTKrKG9GTVI+FQL0Po1v+zhy/aPdrM/35JFU4QPCjQEhv4/m4LvUr6jWlMNQB/nPtw/6v52mZ2EuOZ5dfPYnrmdBf0XML3PdO7692GClY7cHzXYJCazzl5zUD8NK1N2szGjlocmDzGgZMajM9eclJTU7DFBTE9KpZLCwkJ9Oz8/H3d39ybn7N69m1GjRunbgYGBREVFARAQEIC7uzt5eeZfnerBsAf1r1efW0Wdusas9yZuJsDdnthwL346fEXKASUQ9Zp6fkz7Ud+eHzbfLPcmbubPkX9mQ9wGZvabybHL5ZzNLefRcQGikB3AUiHn0bEBHMss4VRWqdDiCIogimLMmDHEx8cDkJqaiqen5y1mp+TkZEJCbjzBrl69mu+//x6AgoICioqKUCqVphO6g0zsPZFeDrrI01ptBRHB580mCrutPDImgOvVKtaekNwFhWBP1h5yKnUBYC7WLtzZ506BJWobdpZ2+ky2y/ddxN3BmrsGimtjeNZQHxysLfjfgUtCiyIogiiKwYMHEx4ezty5c1myZAlvvvkma9euZfv27fpzCgoKcHNz07cnT57Mvn37uP/++3nyySdZvHjxbc1O5oZCrmiysVdtt7tD9SqEZJi/C+E9nfj2wGVpY08A7uh9B59O/JTBnoOZEzKn1Yh/cyMjv5xd6QU8OMrPZAW5DIWjjSUzh/iwOTmH/LLum/9MsN3JF154oUm78eoBYOPGpuH/zs7OfP3110aXyxjEBcXx/uF/oZXXkFedxd6re7mj9x1Ci9VmZDIZC8YE8PyqU+zPKGRcX/OKpu3qKOQKonyjiPKNQq0Rn/nvv/svYW0hIzKwmG2XtzHFf4rQIrWLh0f7813iZX44lMlzMcFCiyMIUmS2CTiZWUNtyXB9+5ezvwgoTce4c4A37g7W/O/AZaFF6dYo5OJ6Ir9epWLd6RQ8gv/D03seY+mhpfpqfGLB392eScGe/Hj4CjUq8SlqQyApChPw4+FM7GrGI0O3iVdcUyy6m8XaQsEDI33ZeTafiwW3xrxISNyONcevUlNjj6WVLsFkSW0JWy5uEViq9vPImACKKuvYeKp71taWFIWRySurISE1j1kDI3l+6PP8MO0HVt65EmuFeSUCbAv3jfDFQi7j5yNXhBalW7Ajcwc7r+xsV8U4c0Kr1fLj4UwG9nbjwfD79e83ji4XC2OC3Ojr6cAPh7vnd19SFEbm16NZqDVa5g335aHwhxjgMUA07oE34+loQ0y4ktVJV6mt755LcFOh0Wr4OOlj/r7r70xZM4X04nShRWo3hy8Vc6GgkgdG+hEXFNekrrzYrkcmkzFvuC+nskpJudb2MsddBUlRGBG1RsvPR64wNsidAHd7ocUxCPOG+1JSpSI+xfxjWMTMoWuHyCrPAnRR2b5OvgJL1H5+OJSJk40Fd0Z642LjQrTfjcJGYlxV3DO4F1YWcn45kiW0KCZHUhRGZHd6Pteu13D/iNvf5GJ0NR0T6E5vV1t+7qZLcFPx67kb6TruCrwLWwtbAaVpPwXltcSn5DJzSG99mdNZ/Wbpj2+6uInq+mqhxOsQPeys+FOEN7+dyKaqTpzmwI4iKQoj8uPhK3g4WhMd1jQwsKKugl/O/sK9G+8lo0RcJUflchlzh/mSeLFI2tQ2EnmVeezO2q1vzwqe1fzJZsqqpCxUai33j7zxkDRUOVSfQblCVcG2S9uEEq/DzBvuS3ltPZtOd68KeJKiMBJXS6rYlZ7P3GG9sVQ0/ZiXHFrCO4ff4XzJ+SZFaMTCrKE+WMhl/HK0+y3BTcFvGb+h1ur2gIZ5DaOPcx+BJWofmj9MrqP6uDXJQiCTyZjZd6a+vfq8+MxPw/xdCPSw73YOHZKiMBJrj2ej1cLsob1vOdaQmx90S/CGQjRiwdPRhuhQaVPbGGi1WtZfWK9vN/5hFQuHLxWTVVzN3OG3fvdnBM3Qp/U4XSDeTe0TV0pJyykTWhyTISkKI6DValmddJXRgW63LfgzynsUnraegC6mYt/VfaYWsdPcN8KX4so6tqdKm9qG5ET+Cf0mtqOlI5N8JwksUftZnXQVR2sLYsK8bjnmauNKtO+NTe3Ea4mmFM0g3DvYByuFnF+60apCUhRG4OjlEq4UVzFziM9tjyvkiiarit8yfjOVaAZjTJA73s42rEmSEgUaksariSkBU0SX16mytp6tZ3K4c4A3tla3jyK/L/Q+FkYsZH3ceh7u/7BpBTQALvZWxIQrWX/qGnX14srb1lEkRWEEVidlYW+lYEr/W5+oGogLitO/3nd1H0XVRaYQzWAo5DLuHtSLvecLyS/vvsnSDEmVqor4y/H69l1BdwkoTcfYnJxDVZ2amUNuNTs1MMhzEH8b/DfR7b005t4hPpRWqdh5Nl9oUUyCpCgMTFVdPZtP5/CnSG/srJrPuejv7M9Aj4EA1Gvr2Xxxs6lENBj3DPZBrdGy4WT3TGtgaM4UnqG2Xpfaxd/Jn0j3SIElaj+rk67Sx92ewb49hBbFqIwLcsfdwZq1x7vHilpSFAZm25lcKlt5omqg8aritwu/iS6uIsjTgQG9e7BaMj8ZhOHew9kxawcvDXuJhZELRRfBn1lUyZFLxdw7xEd0srcXC4WcuIE92ZWeT3FlndDiGB1JURiY1UlX8XW1Y5i/S6vnxvrHYqPQ2aDPl5wntTjV2OIZnHsH9+Jsbjmp17qPB4gxcbN1Y37YfGYEzhBalHaz5ng2Mpkugrmt5Fbmsjx5eROTm1i4d4gPKrW2WyQKlBSFAblaUsXBC0XMbOMTlYOVA5P9Juvbmy5sMqZ4RmF6ZE8sFTLWdJMluMTt0Wi0rEm6ytggd7yd2xZFviNzBzGrY/jX8X/xfcr3RpbQ8IR6OxHq7dQtzE+CKYqlS5cyZ84c5s6dy+nTp5sci4uLY/78+fq/htrYLfUxB9Yezwba90R1Z6CurGUP6x44WImrRCroPEAmhXiy/mQ29eru4QEicSuHLxWTXVrdrKff7SX+EBQAACAASURBVBiiHKKvr3G68DSXrouv3Oi9g3tx6up1MvLLhRbFqAiiKI4cOUJmZiYrV67k7bffZsmSJbecs2LFCv2fUqlsUx8h0Wq1/HYymxEBrvi43Bo70RzDvYbzRdQX7Jy9k6cGPmVECY3HvYN9KKyoY+/5AqFFESXpxel8dOwjUotSRbdP1cCGU9nYWSluGzvRHC42LozvNV7f3nhhYwtnmyczBvZEIZex5o+HxK6KIIoiMTGR6Ghd0E1QUBBlZWVUVNzIG1RZWdnuPkKTcq2MiwWV3DWw7asJAAu5BeN8xulTMIuRO4I9cbW36vI3i7FYf2E936Z8y5xNc/gk6ROhxWk3dfUatiTnEhOmbDZ2ojlmBN3Yi9l0cZPo6sl7Otowvq87645no9aIU8m3BUFqZhcWFhIeHq5vu7m5UVBQgIODzvRSWlrK888/T3Z2NiNGjOCZZ55ptU9j0tLSOiRXTU1Nh/v+71gRChkEWpV1eAwh6Mw1N2a0jw3bU3I5fjoFW0vz3voy1DUbAo1Ww6bzN/ametb3NIpsxrzmQ1mVXK9WMchN0+45PDWeOCgcqFBXkFOZw4ajGwh2NExdalP9n4crZexKr2H1nhNEegmb5ddY1yyIorh5ea3Vapts/j777LPMmDEDa2trnnzySRISElrt05jQ0NAOyZWWltahvhqNloO/7WRCsCcjBvXv0NyNaenaDE1Hr/lmHrQpZlN6IlmaHtwV2r5Vlakx1DUbgiM5RyhRlQC69BYzh8/U50IyJMa85i9OnsDFzpL7Jg26JQFmW4i9Hsua82sASNWmEhca10qPtmGq/7NfYD2fJe7gdKklcyYK+73qzDUnJSU1e0yQRz+lUklhYaG+nZ+fj7u7u75933334eDggKWlJXfccQfp6emt9hGSY5kl5Fyv4a6BPTs8Rq26lu2Z23lm1zMs2rvIgNKZhqF+Lng723QLV0FDsuXSjfrRsf6xRlESxqSytp4dqXlMi/DukJIAmBowVf86/nK86Eq/2llZEB2mZEtyDqou6tAhiKIYM2YM8fE6v+nU1FQ8PT31JqTi4mIWLlyISqXLqHr06FH69u3bYh+hWX8yGxtLOdGhytZPboacihye2/0cv1/5nR1XdnC9VlzlFuVyGXdGerPnXAGlVV0/AMkQ1Knr2J65Xd+eFjBNQGk6xo60PKpV6nbvzTVmqHIo7ra6h77immKO5R0zlHgmY3qkNyVVKg5kFLZ+sggRRFEMHjyY8PBw5s6dy5IlS3jzzTdZu3Yt27dvx9XVlREjRujdYF1dXYmNjb1tH3NApdawJTmH6FAl9tYdfxr0d/Yn3E23B6PSqJr8gIiF6QN6olJriU/JFVoUUXAg+wBldbpAxV4OvRjgMUBgidrPhpPX8Ha2Yahf6wGmzaGQK4j1j9W3t17aagjRTMqEYA8cbSzYeKprFjQSbJ37wgsvNGmHhIToXz/22GM89thjrfYxB/afL6SkStWpJ6oGpgVMI6UoBdDdLDP7iasWQUQvZ/zd7Nhw6hpzhomvxrOpafyDOMV/iujSXpRU1rHnXAGPjg1ALu+c7FP8p/Bj2o+Ark6FKffpDIG1hYIp4V5sO5NLjaq/vvxrV8G83VNEwIZT13CysWB8v87vl0wJmIIM3c1xLO8YhdXiWsbKZDKmD+hJ4oUiKaNsK1SpqtiVtUvfntZHfGanLWdyqNdomT6g43tzDQzwGMCC/gv4JvYbVk9fLSol0cD0AT0pr61nd3rXiyeSFEUnqK5Tk5CSy9T+3lhbdP4JwtPOk0GegwCd2+Tvmb93ekxTM2NATzRa2NLNagq3l11Zu6hR65RpUI8g+rn0E1ii9rPh5DUCPewJ7+nU6bFkMhnPDnmWYV7D9NHaYmN0oBtu9lZsPN31HDokRdEJdqfnU1mnZkYnvJ1uJsY/Rv86ITPBYOOair5KR0K8HNkoKYoWOZF/Qv+6sdePWMgvq+HI5WLujOwpyqd/Y2ChkDMtwpvf0/KorBWX51ZrSIqiE2xOzsHN3ooRAa4GG3Oy32RRm59AtwRPyizhakmV0KKYLa+NeI11M9bxlwF/Yaq/+BRFfEouWi38KdJbaFHMiukDelKj0rAjrWuVCJYURQepUanZeTafmHAvLDroP347uoL5aXqkboW1JVlaVTSHTCYjyCWIJwc+SW+n1muXmBtbknMJ8nSgn9LR4GOX15Wz8cJGvj3zrcHHNjZdNZ5IUhQdZM+5Aqrq1EyLaHsStLbS2FVQjOYnXzc7+vdyYusZyU22K1JYUcvhS0VMa6HUb0fJrcxl/MrxvLr/Vb449QXV9dUGn8OYyOUypvT3Yu/5Qiq6kPlJUhQdZGtyDj3sLBnZx83gYzeYnyzlljhYOqDWqA0+h7GZ2t+bE1dKuVYqrhtdonXiU3LRaGFqhOHNTl72Xvg66lyrq+urOZB9wOBzGJtpEd7U1Wu6VD1tSVF0gNp6NTvS8okJU3Y4bUFLeNh58O+of7N7zm7+NelfovQCmfrH0+Y2aVXRhKO5R/kh9QdyK8X7uWxNziXA3Z4QL8ObnQCi/aL1r8UYeDrE1wUPR2u2diHTq6QoOsD+P5aV04zwRNXAeJ/xOFl13u1QKPp4OBDi5Sgpipv4Nf1X/nn0n0xePZlV51YJLU67Ka6sI/FiEdMivIzm7RTjd8Pzb8/VPdSqa40yj7GQy2VMCfdid3oBVXVdw/wkKYoOsDk5BycbC0YHmkdSQnNlan9vjmYWk18mBd8B1NTXsOfqHn17oMdAAaXpGAkpuag1Wqb2N95DUj+XfnrzU6WqksRriUaby1hMjfCiWqVmTxcJvpMURTupq9ewPTWPyWFeWFlIH19LTI3wQqtFyv30BweyD+g3ZwOcAwjqESSwRO1ny5lcfF3tDBJk1xwymUz05qfh/q642lt1GYcO6ZeunRy4UEh5Tb1RvJ1uRq1RczT3KO8ceoeX9r5k9PkMTV9PBwI97LvMzdJZGnuwTfabLLpAtdKqOg5mFDLViGanBhqbn3Zl7UKlVhl1PkNjoZATG67k97Q8alTic0a5GUlRtJOtyTk4WFswtq/xzU5FNUUsiF/AL+m/kHA5gZKaEqPPaUhkMhnTIrw5dLGIogpx2ZkNTa26tonZqfEPoVhISM2jXqPlT0bcm2sgzC2Mnva6eJzyunKO5B4x+pyGZkp/byrr1Ow/L76g2ZuRFEU7UKk1JKTmER3qaZDcTq3haedJpEckAGqtmt1Zu40+p6GZ0t8LjVb3I9OdOZh9kEqVrha8r6OvKHM7bU3OoVcPWyJ6ORt9rq5gfhod6IazrSVbzojf+0lSFO3g0MUiSqtURvV2uplo3xs3y84rO002r6EI83bCz82u25ufGv/QxfjHiM7sdL1axf6MQqN6O93MZL/J+tf7s/ffUg7Z3LFU6IqZ7UjNo65e3JXvBFMUS5cu1RcnOn36dJNjhw4dYvbs2cydO5dXXnkFjUbDmTNnGD9+PPPnz2f+/PksWbLE5DJvSc7B3krB+H4eJpszyjdK//rgtYNUqcSVP0km00WqHswo7LaV71RqVZPVYOMfQLHwe1oeKrXWKEF2zRHpEcm9fe/lg/EfsD5uveiUK8C0CC/Kauo5eEHc5idBFMWRI0fIzMxk5cqVvP3227f86L/xxht89tln/PLLL1RWVrJv3z6qqqqIjY1lxYoVrFixgtdff92kMqs1Wran5jExxNOkRUl8nXzp69IXgDpNHfuy95lsbkMxrb839X98ft2Ro7lHKVeVA7pKdqGuoQJL1H7iU3LxcrJhoE8Pk80pl8lZPHoxUwKmYG9pb7J5DcnYvu44WFuIPp5IEEWRmJhIdLTOpBIUFERZWRkVFRX642vXrsXLS+dV5OrqSklJCZWVlUKIqufElRIKK+qIDTe+t9PNNF5V/H5FfEkCI32c6dXDVvQ3S0fZm71X/3qS7yTRPRlX16nZc66AyWHKTley625YWyiICvUkPiWXerV4zU+CKIrCwkJcXG7U2HVzc6Og4EZgioODAwD5+fkcPHiQCRMmUFVVRVJSEo899hj3338/hw4dMqnMCal5WCpk3BFsOrNTA40Vxb6r+6hTi8uEI5PJmBymZF9GYZfL098Wnh/yPF9N/oq5wXOZ4j9FaHHazf6MQmpUGmLClUKLIkpiw70oqVKRlCkur8XGCFIz++ZNqdvVxy0qKuKJJ57gjTfewMXFhZCQEJ566imioqK4dOkSjzzyCAkJCVhZWd0yflpaWofkqqmpuW1frVbLxhNZDPCy4eqljA6N3Rm0Wi2e1p7k1+ZToapg9ZHVDOoxyCBjN3fNhibEoZa6eg0/7zrJGD9hzQimuubG9KAH9zjfA4WQVmjauaFz1/zrwXzsLeU41xaQliaMrb1eU09aeRo1mhqGuQxrUx8h/s+3Q6nVYCmX8cv+NJxqDZ9EtDHGumZBFIVSqaSw8MYXLj8/H3f3G3EJFRUVLFy4kL///e+MHTsWgMDAQAIDAwEICAjA3d2dvLw8eve+NZd/aGjHbMBpaWm37Xsur5yc8kv8NTqE0FC/Do3dWaZUTuH71O918mjPcV/ofQYZt7lrNjR9+2l4b38hqdcteMwE87WEqa7ZnOjoNas1WpJWXyUqzIvI/mFGkKx1zhaf5c/xf6a8rhw/Jz/mj5rfJvOdOf2fxx2v4lhuOR+HhBjV9NiZa05KSmr2mCCmpzFjxhAfHw9Aamoqnp6eenMTwHvvvcdDDz3EhAkT9O+tXr2a77/X/VAWFBRQVFSEUmmapXDCHykookOFW3o3Nj/lVonP1m+hkBMVouT3s/moRGyr7W4kZZZQXFknqNnJ38mfeo3OZJlZlsml65cEk6WjxIYrySqu5mxuudCidAhBVhSDBw8mPDycuXPnIpPJePPNN1m7di2Ojo6MHTuW3377jczMTFavXg3AnXfeyZQpU3jhhReIj4+nrq6OxYsX39bsZAwSUvMY2LsHSicbk8x3OwZ4DOCV4a8wofcEejn0EkyOzhATrmTN8ascuVTMmKCun1AxpyKH04WnGdtrrGi9dhJScrFSyJlgQpfwm7GxsGFsr7H6WJSdWTvp06OPYPJ0hKhQJTJZMvEpuYR6iy8rtCCKAuCFF15o0g4JCdG/PnPmzG37fP3110aV6XZcK63m9NXrvDQl2ORzN0YhVxjM3CQU4/t6YGMpJyElt1soiq2Xt/JJ0idYyi15YsATPB75uNAitQutVktCah6jg9xwtLEUVJaJvSfeUBRXdvJYxGOCytNe3B2sGernQkJKHs9Eiy8qX4rMboWGIukxYaZ3i+1q2FopGNfXg4TUPNFF2XaEhkh6lUaF0k58HkPn8iq4UlxlFt/98T7jsZDpnmuTC5PJqxRfTE5MmBepOWVkFYsraBYkRdEq21Pz6ONhT5CnQ+snS7RKTJiSnOs1nMkuE1oUo1JYXcjpAl3GAblMzgSfCa30MD9u7M15CiwJOFs7M9RrqL4txrxnk8N0DwtiDDyVFEULXK9WkXihyCyeqBpzsfQiX53+ijXn1ggtSruJClUil0FCqvg25NvD7qzdaNGtmoYoh9DDxnQRzYYiITWPQb498BRwb64xk3wn6V+LMfDU392eYKWjKL/7bVIUjV1ZExMTSUwUX8WpjrA7PZ96jdasAo32Xt3LXevvYtmJZfyQ9oPQ4rQbV3srhvm7kpAivqeq9tA4geOk3pNaONM8uVZaTXL2dbN6SJrYe6L+9dHco5TViW9VGhOu5MilYkoqxRU026qi+PTTT3n33XcBWLZsmT4P0wcffGB04YQmISUPD0drk+a3aY2hyqFYK6wByCjN4ErZFYElaj8x4V6k55VzuVDYtCzGolJVyaGcG5kDJvpObOFs80S/N2dGD0le9l6Eu4UDUK+tZ99V8eU9iwnTpd3//Wy+0KK0i1YVxZYtW1i6dCkajYaffvqJ5cuX88MPP7Bzp/hSXreHGpWa3en5Zpffxs7SjlHeo/RtMaYej/nDVivGJXhb2J+9H5VGV5EtxDVElO7MCSl5BHrYE+hhXntzjc1PYvzu9+/lhLezjX7/Ryy0qiisrKywtrbmxIkTeHh44Ofnh0KhEF1is/aSeKGIyjq1fgPKnGhys2SJ72bp7WpHmLdTlzU/id3sdL1KxaGLRcQIkACzNaJ8oxjmNYxFwxbx3NDnhBan3chkMmLClOw9X0B1nXhKpLaqKNzd3fn888/58MMPmT59OgAHDx7E3l6cAURtJSE1F3srBaMDjZubpSNM6D0BuUz3rzuZf5LCavHluo8JV5J0pYSC8q5VIlWlVjUxiYjR7LTrj705c3xICuwRyDex3/BA2AOiXKmBzvRao9Kw73xB6yebCa0qivfff5/Kykqio6N59NFHAdi2bRv/+Mc/jC6cUGg0Wran5nNHiGlKnrYXVxtXBnnqkgJq0bIna08rPcyPmDAvtFpdQZyuxNG8G7Unetr3JNhF2EDNjrA91fz25roSwwNccbKxIF5EK+pWI7M9PT156aWXmrzXlZUEwImsUgoravW2dHNkUu9JJOXpknj9fuV37u13r8AStY9Qb0d8XGxJSM1j7nBfocUxGP3d+7N07FJ2XtmJv7O/6Ey0DXtzdw3qZVZ7c10JS4WcqFAlv5/No16twUJh/lEKzSqK8PDwVr/kzaXaEDsJqblYKmRMDBE+0Kg5JvlO4oNjOs+zQzmHqFRViiqfkM5W68UPhzOpqK3HwVqwbDIGxcnKiemB05keOF1oUTpEw96cOT8kNaDVarlQegE7Szt6OvQUWpx2EROmZN2JbI5eLmGUGZq3b6bZuzMhIaHFjtXV1QYXxhzQarUkpOQxso8bTgLnt2kJH0cfgl2CSS9JR6VRsT97P7H+sUKL1S5iwpV8c+ASe9IL+FOk6WoxSzRPQmouDtYWZv/jtT1zO/86/i8yyzJ5KOwhXhj2QuudzIjx/TywspCTkJpr9p81tLBH0atXL/2fl5eX3tNJJpNRVVWl36/oalwoqOBSYaVZenzcTGPvp8Z++2JhqJ8LLnaWbO+ibrJio2FvbkKwh1nuzTXGWmFNZlkmALuydokud5i9tQXjgtxJSBFH3rNW1/ubN2/mtddeo7b2hneKlZWVvuZ1V6Nhg2mygLUn2kqsfyy16lom+U4iwj1CaHHajcUfttr4lFxUag2WIrDVtsSZwjOEuoaikJv3j2xziGFvroER3iOws7Cjqr6KK+VXuHj9IoE9AoUWq13EhOvqs6TmlBHe01locVqk1Tvzs88+Y/ny5aSkpODv78+pU6f461//ypQp4qv92xYSUvMY0LsHXs7mkd+mJQJ7BPLskGcZ4DFA7y4rNmLClJTX1HP4YrHQonSKzLJM5m2ex6RVk3j38LtCi9MhxLA314C1wpqxvcbq22IMvtPVqEAU8USt/rooFAqGDh2KXC5Hq9ViZWXFwoUL+fLLL00hn0kpqqrnVFapKJ6ougrjGmpUiNz8tOvKLgCKa4rJqcwRWJr2I5a9ucaIPUrb3cGaIb4uosgm26qi6NGjB8uXL0ej0eDi4sK+ffsoKioiJ6dzN8PSpUuZM2cOc+fO5fTp002OHTx4kJkzZzJnzhw+//zzNvUxBIeydHniJUVhOmytFIzv68F2kdeoaBwh3/gHTCyIaW+ugXE+4/Q1Ks4UnSG3UnwPGzHhSlHUqGhVUbz99tscO3YMuVzOE088wd/+9jfGjh3LzJkzOzzpkSNHyMzMZOXKlbz99tssWbLkljmXLVvGzz//zL59+8jIyGi1jyFIvFJJgLs4a08U1xSz7vw6LpReEFqUdjNZ5DUqCqsLOZl/EhBx7YlU8ezNNeBk5dQFalToFLO5ryqaVRRZWVkA9OnTh//85z8ATJgwgaNHj3LkyBGef/75Dk+amJio3wwPCgqirKyMiooK/bzOzs54e3sjl8uZMGGCPrV5c30MQVmNilO51cSEKUUXJLU8eTkTf53IGwffYOOFjUKL027EXqNiT9Yefe2JwZ6DcbFxEVii9pOQkscAH2dR7M01RuzmpwB3e/opHcz+u9+sopg+fToPPPAAa9asaRIzYWFhgaOjY6cmLSwsxMXlxs3k5uZGQYEu70lBQQGurq76Y+7u7hQUFLTYxxCk55ZTr4HY/uJZejcQ6ByIRqsBxFnQRew1KhqbnRrXTBALeWU1nMwqFZXZqYEuUaMizMvsa1Q06x67f/9+tm3bxvr161m6dCnR0dHcfffdjBw5stOT3myL1mq1+qf429mpZTJZi31uJi0trd0y2Wq0fBzjgW1lLmlp5q3db8ZV44q13JpaTS2Xyy6z4/gOetm2LWFaTU1Nhz4vQzPAXcZXR8v5/fBpejoZdzPVkNdco64hMftGIS8/lZ9ZfJ4309I1b07X/bgG2lSapeytEWgfyIXKC9Rr61l5ZCVj3XTeUOby3W6NILsaNFr4YddJogM79xBurGtuVlE4ODgwc+ZMZs6cSW5uLhs2bOCdd96hsrKSuLg47r77bnr37t2hSZVKZZOqefn5+bi7u9/2WF5eHh4eHlhYWDTb52ZCQ0M7JJdCntbhvkIzLn8cO67sAOCy5WWiQ9sW55KWZh7X7KCs4quju7hU50BUaB+jzmXIa96euR2VVld7op9LPyYMNM/9iZau+b3EIwS42xM7MlJ0ZleAqXVT2XxpM5N6TyIqKIo+zrrvj7l8t1sjWKPlvX3FnCmR83Qn5e3MNSclJTV7rE3O915eXjz++ONs3LiRL774ghMnThATE9MhYQDGjBlDfHw8AKmpqXh6euLgoNtA9vHxoaKigqtXr1JfX8+uXbsYM2ZMi30kmtpqG1w1xURvVztCRVijorFdXIxmp/IaFQcvFDJZhHtzDTwa8Sgb4jbwzJBn9EpCTMjlMiaHKdlzznxrVLQ5E9uJEyfYsGED8fHx+Pn5dSqD7ODBgwkPD2fu3LnIZDLefPNN1q5di6OjI5MnT2bx4sX6zfJp06YREBBAQEDALX0kbjDeZzwKmQK1Vs3pwtPkVeahtBePBwvovJ/+vfM8hRW1uDtYCy1Oq6g0KvZe3atvi9Etdnd6ASq1edaeaCsWcvEnlIwJV7LiUCb7MwrN8n/R4iecmZnJhg0b2LBhA2q1munTp/Pzzz/j5+fX6YlfeKFpEq+QkBD962HDhrFy5cpW+0jcwNnamaFeQzmccxjQuQrOCZkjsFTtIyZMyWe/n2dnWj6zh3XMrGlKVGoVj0Y8ys4rOymoKiDU1fzNHDeTkJqHu4MVg33F56nVlRgR4IajtQXbU3PFpShmz57N+fPniY6O5q233mLUqFGiXZp2F6J8o/SKYmfWTtEpivCeTvTqYUtCaq4oFIWdpR0L+i9gQf8F1NTXiO7+qKvXsPtsPn+K9EbRhWpPFNcU08NaXEWXrCzkTAzxZEdaPmqN1uz+H83uUcyaNYt9+/bxwQcfMHr0aNHdBN2RxjbyIzlHROcqKJPpbLX7zhdSVVcvtDjtwsZCXPEHAIcuFlFeW2+WT7AdYe35tTy09SEm/jqR5MJkocVpNzHhSoor60jKLBFalFtoUVFIm8Xiwsvei3C3cADqtfVNajeLhZhwJbX1GvaeE18dcLGRkJqLnZWCMUG39x4UG6cKTnE8/zgarUaUwXcT+nlgpZCTkGJ+7vniTDkq0SwzAmcwI3AGn078VJReOMP9XXG2tTT7SNVKVaXQInQKXe2JPCb088DGUpxp0W+m8fddjIrC0caS0UFuJJhh3jPxuwtINOG+0PuEFqFTWCjkRIV48ntavlnXE35o60OotWom9p7Ig2EP0sNGXDbx09nXySurJSa8a5idAEZ6j8TWwpbq+moul10muzqbUMTlYDA5TMlr685wLq+CYK/OBd8Zkmbvwi+++AKVSmVKWSQkAJ356Xq1iiOXzbNGRXZFNukl6WSUZvBtyreidM9MSMlFIZcxMdj8a0+0FRsLG8b0HKNvHy05KqA0HaMhKaO5mZ+aVRTHjh3jzjvv5MCBA6aUR0KC8f08sLaQm21GzcZZSod7D8fBSnx7edtT8xgR4EoPOyuhRTEojWNZxKgoPJ1sGOTbQ5/N11xoVlF88803vPjiiyxevJi//e1v5OWZl+ASrVOnrmN/9n7UGvOM9mwOOysLxvU133rCje3fk3qLL8juYkEF5/MrumTdlYbAU4DzlecpqDJc4lBTERPmRXL2da6VVrd+solo0QAcHR3N5s2bCQsL4+677+aVV17h9ddf1/9JmC/vHn6X8SvH85cdf+FUwSmhxWk3MWFeZJdWk5pjXi6+12uvk5R3IyfOHb3vEE6YDtKwUpsswmyxreFs7cwQ5RB9e1eW+NLZNOwb7Ugzn4fzVncKKysruXbtGhYWFnh6eqJUKvV/EuZLnaZO75kjRg+QqFBPXY0KM8v9tPfqXtRa3Qot0j0STzvx2fgTUvPo30sX3NgVaVKjIkt83/1ADwf6eNib1Xe/WUWh0Wj4/vvvmTZtGjY2NmzZsoVnn32Wv/71r/o/CfOlsUlkZ9ZOszThtISbgzVD/FzMzlbb+Al1oq/43I8Lyms5fqWEyaFdbzXRQGM32cM5h6moM1yBM1MRE+bFoYtFXK8yD4eiZhXFjBkzSEhI4Ntvv+XVV1+Vgu9ExgjvEdhb2gOQVZ5FRmmGwBK1n5gwL9LMqJ5wrbqW/dn79W0x7k/8npaHVkuXcou9mZ4OPQl1DcXRwpFpAdNEGfMSE66kXqNlV3q+0KIALSiKxx57jB9++IHg4GBTyiNhIKwUVozrNU7fFmPlu4bUEubi/XQ45zDV9boNRj8nPwKcAwSWqP0kpObR29WWEDPy0TcGn036jK8GfcU7Y98RXRZlgIE+PfBwtDab736ziiIuLs6UckgYAbHXE/Z3tydY6Wg2Udo3ezuJLf9ZRW09+zMKiQnzEp3s7cXL3kvv/SRG5HIZ0aFKdqfnylf6EQAAIABJREFUU6MS3mvRPMNeJQzC2F5j9cFgacVp5FTkCCxR+4kJV5pNPWFve296OehKzIpxf2LvuQLq6jVdJglgVycmXEllnZrEC0VCiyIpiq6Mo5UjI7xH6Nti9ACJCfNCo4Xfzwpvq/3zgD+z9Z6trJ6+mkj3SKHFaTcJKbm42Fky1K/71Z4QmzMHwOhAN+ytFGaxohZEUahUKp5//nnmzZvHAw88QFZW1i3nbNmyhZkzZzJ79mw++eQTAOLj45k8eTLz589n/vz5fPnll6YWXXQ08X4Sofmpfy8nvJ1t2G4GNwvoUqEHuwajkIvLrFGv0bLzbD5RoUqzzZ9laOo19Wy5uIUX9rzAXevvQqPVCC1Su7C2UHBHiCfbU/PRaIRVdIJ8YzZt2oSTkxM///wzCxcu5KOPPmpyvLq6mg8//JBvv/2WlStXcvDgQTIyMqiqquL+++9nxYoVrFixgr/85S9CiC8qJvaeiAydPTopL4nSmlKBJWofDTUqzLmesBhIzquhrKa+S0ZjN4dMJuPdI+8SfzmeS9cvkVKYIrRI7SYmTElhRS0nsoS9bwVRFImJiUyePBmAsWPHkpSU1OS4ra0tGzZswMHBAZlMRo8ePSgtLaWyUnxubkLjYefBYOVgRvcczasjXhVlAruYMC9qVBr2ZwhTo0KMZoubSbxSiY2lnHF9PYQWxWQoZAom+EzQt8Voer0j2BMLuUxw85MgvxqFhYW4uroCoFAokMvl1NXVYWV1I0FZQ9zGuXPnyM7OZsCAARw/fpw9e/awd+9etFotixYtalJru4G0tLQOyVVTU9PhvubMi74vIpfJQQNZF5qa+cRwzc4aLfaWcn49eBYfWeczyrb3mldnryatPI3hLsMZ6ToSZ0vnTstgSjRaLQcyKxjsbcPlC+eEFsdk1NTU0E/eT9/elrGNGNsYASXqGBFKGzadyOIuP22r3mrGup+NrihWrVrFqlWrmrx36lTT3ENa7e0/gMuXL/P888/z0UcfYWlpyciRI4mMjGTkyJEcO3aMF198kY0bN97SLzS0Yzno09LSOtxXrIjlmieH17L3fCH9gkM6XU+4vdd8/NxxMsoySC5LJsw/jJH+Izs1v6lJyiymuPoSs0f1IzS0l9DimIy0tDRmRcxi2cVl1KhruFp9Fduetvg7+wstWru4p9SW19enYOXemyDPluNfOnM/32zZaYzRTU+zZs3i119/bfJ39913U1Cgy+qoUqnQarVYWlo26Zebm8tTTz3Fe++9p7/wBiUBMHToUIqLi1GrJbt1dyAm3EuQesKXrl/SR7XbKGwY22usSec3BFuTc7GQw6RQ8eWl6iy2FraM6jlK3xZjksDoP/aVhExnI8gexZgxY9i2bRsAu3btYsSIEbec89prr7F48WLCw8P1733++efEx8cDOpOUq6srCoW4vE+ERqvVkltpHh5E7WG8QPWEG0e0j+k1BjtLO5PO31m0Wi1bz+QyyNsWJxvL1jt0QcQeeOrtbEukj7OgSQIF2aOYNm0aBw8eZN68eVhZWfHee+8B8NVXXzFs2DB69OjBsWPH+Oyzz/R9Hn74Ye666y5eeeUVVqxYQX19Pe+8844Q4ouSKlUVy04sY+eVnVTWV7J79m5RbWw7WFswJsiN+NRcXvtTqMkii7dnbte/jvKNMsmchuRMdhnZpdXMDus+m9g3M8FnAnKZHI1Ww6mCUxRWF+Ju6y60WO0iNtyLD+LTyblejbez6bP+CvJLoVAoePfdd295//HHH9e/vnkfo4EVK1YYTa6ujI2FDQmZCeRX6QLXTuSfYJjXMIGlah+x4V7sWptMyrUy+vcy/oZydkU2qUWpAFjILZjQe0IrPcyPrWdyUMhljOwtrpWQIXGxcWGQ5yCS8pLQomXnlZ3MDp4ttFjtYmp/naLYmpzLgrGmzzHWPSJvJJDL5E3SL4sxSWBMuBcKuYytZ0yTiuT3zBuf0UjvkThZOZlkXkPRYHYa1ccNJ5vubaKd7DdZ/zrhcoKAknSMPh4OhHg5siVZmDQ8kqLoRtxsqxVbfICrvRWjA93YkpxrEtl3XNmhfx3tG230+QxNel45lwormdK/69aeaCuT/SYjQ4aF3AJbS1vRlQcGmBbhzbHMEnKv15h8bklRdCOGeQ3D0VLnXpdTmcPZ4rMCS9R+pvb35lJhJWk55Uadp6CqgJP5J4E/VmMiTAK4NTkXmaxr155oK552nvw76t/smbOHZZOWiS4FC8C0CJ3C32aiFXVjJEXRjbCUWzK+93h9W4zmp9hwJQq5zOhL8J1XdqJFt2oZohyCq42rUeczBtvO5DLM3xVPRxuhRTELxvuMF535sDFBno70UzqwJdn0XouSouhmNPbcEWNKAzcHa0b2cWVLco5RzU+V9ZX61ZcYzU4XCypIzytnqmR26lJMi/DmaGYx+WWmNT9JiqKbMabnGKzkulQp50vOk1sjvpiKqf29uVhYSXqe8cxPC/ovYM+cPXwR9QWx/rFGm8dYbD2j+79K+xNdi2kR3mi1sM3E8USSouhm2FnaNYlUPVR8SEBpOsaU/l7IZbDltHHNT5YKS8b5jMPN1s2o8xiDrWdyGNi7hyA+9+aMWqPmWO4xlh5eymv7XxNanHbTT+lIkKeDyb2fJEXRDWn8hJxYnCigJB3D3cGaEQFubDkjvtWQKcgqruJMdpl+81PiBgXVBTwS/wg/n/2ZzRc3iy7tPuhWFUcuFVNQXmuyOSVF0Q2Z2HsiVnIr+rr0ZYTrCJG6CnqRkV/B/2/vzuOiKvv/j79mAZFVdgRFVFQIRTB3yXBL3LdIMcz20sq889tXK837981KvaWsO2/LXEpcMsENTHEJywU1NwhlUUgRUAFRkR1m5vcHd2MEosDMHEau5+PB4zFnzpwz74FhPnOuc67rStVj85Oxiv7vkdaIrq0lTtL0uFi44OtYNTuhSqMyyvN0I7tVzfpoyOYnUSiaIUtTS3ZP3M22sduY6DrRKC8VHN7VBZkMduu4+Wn7xe28+8u7HLxykDKV4b6x6VJUfDb+7q1oa9d8e2PX5al294YaN8bOd12crejgaMEeAzY/iULRTLlYGHezhJOVGb097HTeVrvj0g72Xt7L7EOz2XFxh073bQiXcgq5cK2AMb6uUkdpsv5aKE5cO8GdsjsSpqk/mUzGyK6tOZ5+k7xCw3yZEYVCMFqjfFtzMaeQizpqfrpRdIOzOWeBqk52Q9oZ3yCA0QnZyGRVvxuhdq0tW+PrUNX8VKmpNMoRZUd2a41aAzEGan4ShUIAoKjC+KaZ/fPqp6j4bJ3sb9+VfdpOdr1cehndCKMajYao+Gz6tLfD2Vp0sqvLUx73jip++uMnCZM0jHdrKzo4WOjsvf8golA0Y8UVxURdiyIkOoRnop4xurGfnKzMGODpwM74bJ1k33t5r/b2CI8Rjd6foSVdu0tabhFjuotmpwcZ7jEcGVVD1Z+8fpLc4lyJE9WPTCZjrJ8rJ/7I59qdEr0/nygUzZhCriAiK4LEm4lk3M3gQv4FqSPV29jurly5WUx8ZuPambMKs0jITQBAKVMytJ3x9caOSshGIZeJq50egouFCz1degKg1qiJuRwjcaL6G9vdFY0GouP1f1JbkkJRUVHBnDlzCAkJITQ0lKtXr9Z4TEBAANOmTdP+qFSqh9pOeHgtFC3oZXtvToqYP4zvn2V4VxdMlXJ2nstq1H7++kHR17UvNi30P9+FLmk0GqITsgnwdMDOwlTqOEZhZPuR2tvG2PzUwdES3zY27Ixv3Hv/YUhSKKKjo7G2tmbz5s288sorhIWFVVuv0WhwcnIiPDxc+6NQKB64nVB//e37a2/vvbzX6JqfrM1MGNzFiaj4a6jUDc++9497zU5BHkG6iGZQ8Zl3uJpfwmhxEvuhDWs3TDvLowwZJZX6b8LRtbHdXUnMKuBSTqFen0eSQhEXF8ewYVUTiQQEBHD69Olq64uLi1GpanYCe9B2Qv35WvtqR9S8VnSN+NzaZxZsysb5uZJXWEZc2s0GbX/p1iWS8pMAMJWbVpu3w1hExWdjqpDzlI9xX/ZsSDYtbPgk4BN+mvATG0dtpKXS+IY7GdPdFZkMdun5pLYkhSIvLw87u6phmxUKBXK5nPLycu364uJibt68yaxZs5gyZQrr169/qO2E+lPKldVm/4pKi5IwTcMM8nLCqoWywc1P0enR2tuBbQOxMrXSVTSDUKmrrnZ6sosjNi1NpI5jVEa0H0Fb67ZSx2gwZ2sz+ne0Z9e5LL22Buh9zuytW7eydevWavf9fT5sjUaDTCbTLrds2ZK3336bcePGUVFRQWhoKD169Kjxi/j7dn9KSkpqUNbS0tIGb2usSktL6aboRiSRAOxO280463GYyI3rA6dvGzN2J2QR6q3EVFH395+//52v5lxFIVOg0qjwM/UzuvfA6axicu6W0dtJc9/szfW93Rxecy8nGUcvFbPz8DnaWTX8868uei8UwcHBBAcHV7tv3rx55Obm4uXlRUVFBRqNBhOTex9MlpaW2m1MTU3p168fKSkpODs717ndn7y9vRuUNSkpqcHbGqukpCQm+E3g28xvySrMokhVRI5ljtFd9fOc0oH9a05yDTuCvOtup//73znMO4xbpbfYf2U/EzwnYKIwriL5TfxZrM2UPDe0By2UtQ/H0lzf283hNbt6VPCfEweIv2NKF0d5g19zXU35kjQ9DRgwgL17q04exsbG0qdPn2rrU1JSmDt3LhqNhsrKSs6cOUOnTp0euJ3QMHKZnFEdRmmXjbH5qV8HexwsW7DjbMPaam3NbHmmyzNGVyQKyyqJOX+D0d1d71skhAe7WnCVb+K/4eWYl41ukEybliYM8nJs9AUdddH7EUVtRo4cybFjxwgJCcHU1JTFixcDsGrVKnr16oW/vz+tWrUiODgYuVzOoEGD8PX1xcfHp9bthMYb02EMqxJWAfBr1q/cLr1NK7NWEqd6eEqFnDHdW7PxeAa3i8tpZd48LhHdm3idkgoVk3q4SR3FaKnUKkL3hJJfmg9UdcD765wtxmCcnxsx528Qf72Erj66378khUKhUPDpp5/WuP/VV1/V3n7vvfceejuh8TxsPPB18CWzMJOR7UdSqamUOlK9TerRhnVHL7MrPpvn+nlIHccgtp3JpJ29OT3cbaWOYrQUcgUj2o9gY9JGoGpgSGMrFIO9nGhr15K8Iv0cDUlSKISmKSwwDIeWDtpry41NVzcbvFtbs/VU5kMVigVHF2CuNGdMxzH42PvUemFEU5Z1u4S49JvMHtLZ6LI3NeM9x2sLxcGMgxSUF2gvGzcGZiYKfp4TyKXUFL3sXwzhIWi5WLgYbZH4U/Djbfg96w7J1wvqfNzNkptEp0WzKXkTIbtDyCrUf+9WXdtxNguNBib4i2anxvKy88LLzguAMlVZtQ6YxsLkAVf7NYYoFMIjZby/GyYKGRGnMut8XHR6tLZ5zc/RjzZWbQwRT2c0Gg3bz2bRy8MWd3sxQZEujPccr72989JOCZM0PaJQCPeVU5xjdFeA2FmYMtjLiR3nsqhQqWt9jEajIfJipHZ5YqeJhoqnM/GZd7iUU8gEf+MqcE3ZyPYjtUfUCXkJpN9OlzhR0yEKhVBDXHYcbx18i2ERwziafVTqOPUW/Hhb8grLOZRS+9DRKYUp/HHnDwDMleYM9xhuyHg68cPJDFqaKBjTXYztpCu2ZrYEtgnULu9IM74ZDvVFFAqhhrhrcRzKPIRaoyYiNULqOPUW2MURB8sWbD1V++jCP+fem9FsRPsRmJsYV9NNYVklu+KzGe3bGisz4+r30dT9tfkpKi2KSrXxXf2nD6JQCDVM9LzXFPNr5q9GN6mLUiFnYg83fk7OqTGncGF5IXH5cdplY2x2iorPprhcRUgfd6mjPHIGuA3QzmyYV5LHsexjEidqGkShEGrwsPGgp3PVpC4qjYqdacZ3Yu+Znm2oVGuIOF39pPaey3soU1cVD89WnnRz6CZFvEbZfDKDLs5W+Lc1ng6RxkIpVzKmwxgA3K3cxRHFf4lCIdRqUudJ2tuRqZGoNbWfGG6qPJ2s6N3ejk0nMlD/ZViDbanbtLcndZpkdP0PzmffISHzDlN6tzW67MZiitcUvhn2DVETooxyyHl9EIVCqNVQ96Ha4bYzCzM5ef2kxInqL7RvOzLyi/n1YlXTWXJ+Mok3EwEwkZswusNoKeM1yA8nr2KqlIu+E3rkaulKf9f+yGXi4/FP4jch1MpMaaY9BAfYmrK1jkc3TUE+LjhYmrLh+BUAylXl9HDqAVQVQmMaywqgpFzFjnNZjOrWutmMZSU0DaJQCPf1dOentbcPZhzketF1CdPUn6lSzuRebfk5OYes2yX4Ovry/YjvWeqzlNf9Xpc6Xr3tis/ibmklU3oZ70Q7xqq4oljqCJIShUK4r062nejl0guoOqn9Y8qPEieqv5De7miAzScytPd5WHjQwaaDdKEaQKPRsO7oZbxcqs69CPpXpiojKi2KZ396lpkHZ0odR1KiUAh1muo1VXs7IjWCMlVZHY9uetrYmjO4ixM//HaV8krjOiH/V8fT80m+fpcXB7QXJ7EN5E7ZHRYcXUBCbgKnb5zm0q1LUkeSjCgUQp0C2wbSxrINw9oN4/NBn2MqN7628XGP25BXWMKexGtSR2mw7479ga25CWP9XKWO0mw4mTtVu+ppU/ImCdNISxQKoU5KuZId43fwWeBnPO78uFF+m919PQybzp8RduJbCsrqHlW2KbqaX8z+CzcI6e2OmYmYxc6QQrxCtLd3pe3STm7U3EgypnRFRQXz5s0jOztbOxlR27b3TtAlJiayZMkS7fKlS5dYsWIFubm5LFu2DBcXFwD69+/PjBkzDJ6/uWmhaCF1hAZLvZVa1btWAfnybfyS9jSeMuP6sN1w/AoymYzQvu2kjtLs9HTuibedN0n5SZSpytiSsoUZ3ZvfZ44kRxTR0dFYW1uzefNmXnnlFcLCwqqt79q1K+Hh4YSHh7NixQo6dOiAn58fxcXFPPvss9p1okgID/L9+e+1t+Ul3dj5W4mEaeqvsKySzSczCPJxwbVVS6njNDsymYznfZ7XLv+Q/AOllaXSBZKIJIUiLi6OYcOGARAQEMDp06fv+9g1a9bw/PPPI5fLKSoqMlRE4T6KK4rZmLSRtNtpUkd5oOtF1/kp/Sft8ij3EA4k5XD1TrmEqepn84kMCkorefmJ9lJHabaGeQzDxaKqFSO/NJ+o9CiJExmeJIUiLy8PO7uqS/wUCgVyuZzy8pr/vKWlpRw5coQhQ4YAUFxczP79+3nxxRd54YUXSE5ONmju5m7f5X0MjxzO4pOLWfP7GqnjPFD4hXDt5ESPOz/OnCeHYaqUs/3CHYmTPZyyShWrj6TTr4M9/mJObMmYyE0I9Q7VLq8/v97ohrRpLL2fo9i6dStbt1bv1RsfH19tWaPR1HqS9MCBAwQGBiKXV9Wzvn374uvrS9++fTl16hTvvvsuUVE1q3tSUlKDspaWljZ4W2NVn9dcUljC7bLbAOxO302QVRCOLRz1Ga/BCisL+TH5Xr+PYTbDyL2azuD2FhxMu8vRM79j17JpT/u6N7WAGwVlzOpj2+j3pXhvN05XTVdaKlpSoirhcsFlwo+F09uut072rUv6+jvr/T8lODiY4ODgavfNmzeP3NxcvLy8qKioQKPRYGJSc1z92NhYQkLuXXXg6+urvd2zZ0/y8/NRqVQoFNVPTnp7ezcoa1JSUoO3NVb1ec3eeLMzfye/Xf8NNWqOlB3hfb/39ZywYVaeW0mpuqot2bOVJyF9Q5DL5MxzdGdf2CFisxXMH910/9YqtYaZu3+hq5s1Uwf3aPTVZuK93XhTyqawLnEdADG3Y5g+YLrO9q0rjXnNdZ0CkKTpacCAAezdWzV5eWxsLH369Kn1cYmJiXh5eWmXV6xYQUxMDACpqanY2dnVKBKCfr3c9WXt7W0Xt5FXkidhmtrdKbvD+gvrtcsvdn1RO8Cbh4MFgzpYsuHEFXLvNt3Og3sSr/FHXhEzAz2N8pLkR9H0x6ZjbWrN5C6TCXsy7MEbPEIkKRQjR45ErVYTEhLCxo0bmTNnDgCrVq3i7Nmz2scVFBRgaWmpXR43bhwbNmwgNDSUDz/8kI8//tjg2Zu7fq798Lar+sZSpirj24RvJU5UU/iFcAorCgHwsPZgRPsR1daH+NpSXqlm1a9N84S8Sq3h8/2peDpZMtzHReo4wn/Zt7Rn/9P7md93Pq0tm9cUtJI00v7Zd+LvXn311WrLcXFx1ZbbtGlDeHi4XrMJdZPJZLzp/yZvHHwDgB9Tf2S6z3RcLZtGj+FKdSW70nZpl2d0n4FSXv1t7mZtwjg/N8KPX+G1JzviYNm0+olsP5tFWm4RK5/tgUIujiaaEmObNldXRM9sod6ecHsCP0c/oOqDeWX8SokT3aOUK4kYG8HM7jPp7tid4R7Da33cm4M9Ka9U85/YpnVUUV6pZvmBVLq6WRPUVRxNCE2DKBRCvclkMmb1mKVd3pW2i/Q76RImqs7a1JoZfjMIHxGOQl77OayOjpY807Mt4ccvc+Vm0+mfs+W3DDJvlTDnqS7i3EQTd7PkJouOL2L7xe1SR9E7USiEBunl0ov+rv0BUGvUfH7qc4kT1fSgD9p3hnXGRCFn6d4UAyWqW2FZJV/+fIme7WwJ7Nw0LzsWqpzLOceo7aPYkrKFL858QVGFtF82bpfe1uv+RaEQGuzPowo7MzsGuQ9Co9E8YAv9aciwCk7WZrw2sCO7f7/G6Su39JCqfv7980Vy75bxwShvcTTRxHWx64KFiQUAN0tvsjZxrWRZCssLmbBrAu/+8i55Zfq5ClEUCqHBfOx9WDpwKVETopjYaaJkH25qjZpX9r3CO4fe4erdq/Xa9pWB7XGyasGi3RdQq6UrdH/kFbH2yB9M6tFG9MI2Ai2VLZnlf6/5df359WTezZQky9fxX5NXksfey3v5KPkjvfQaF4VCaJQR7UdgbWotaYaI1AjO5Z5j/5X9PL3raQrKH34ocXNTJXODvDibcZsffqtfkdGlRdEXMFXImRvURbIMQv2M6ThGe6l4qaqURScWGfyo+kbRDTYmb9QuB7sFa/sM6ZIoFIJRyynO4fPT986PPOv9bL0L18QebvTrYM+ne5LIuWv4kUF3J1zjYHIOs4Z0wsnazODPLzSMXCZnft/5yKg6kj6adZS9l/caNIOzhTNfDvoSZ3Nnejj1YID9AL08jygUgk6dvHaS9w6/Z5BB0zQaDYtPLtZ2rmtn3Y7Xur9W7/3IZDI+ntCVsko1/xd1Qdcx65RfVM6HOxPp5mbDSwFihFhj4+voyxSvKdrlxScX6/3E8t890eYJdozbweInFuut+VcUCkEn/vzQfmnfS0SnR7MpSf/TRkalR7H/yn7t8od9P2zwJEsdHC15a5An0QnXiE7I1lXEB/p/UecpKK3gX8G+KBXi39EYzfKfhZO5E1A1DPmHxz40eBOUpamlXnuLi3emoBMymUx7FQjAZ6c/4/zN83p7voyCDD4+fm8Il0mdJtG7deNG83w9sCP+7q14b9vvZN4qbmzEB9p5Loud57KZGeiJl4u053mEhrM0tWRhv4Xa5dirsfyY8mMdWzROSWUJOcU5ett/bUShEHTmNd/X6GJbdTK2Ql3BnENzuFOm+7kfSipL+J9f/ofiyqoPcw9rD/631/82er8mCjlfTPZHo4HZP5yjUqW/5rP03ELe3/Y7PdvZ8uZgT709j2AYA9sMrDa/9sXbF/X2XEtOLuHpXU9zNOuo3p7j70ShEHTGVGFKWGAYliZVAzlmFWbx3uH3qFRX6uw5NBoN84/MJym/asx9pVzJkoFLdDYGj7u9OYvGd+XUlVss2q2f+RsKyyqZufEMpko5/57qj4locnokzOk5hx5OPVg6cCnz+87Xy3NsTNpI5MVIbpXd4vUDr5OYl6iX5/k78Q4VdKqddTs+GvCRdvlw1mEWHdfdZYP7r+xn35V92uX3er/HY/aP6WTffxrv78ZLAe357thlNhy/otN9V6rUvLHxDBdzCvliij+tbcQ82I+KFooWfBf0XY3RinXl0NVDLP1tqXZ5RPsR+Nj76OW5/k4UCkHnhrYbysvd7s1bEXkxks9Of6aTYjG03VCCO1dNhBXiFcIzXZ5p9D5r8/5IbwZ1cWThrvPsTrimk32q1Ro+2J7IL6m5fDSuKwPFMB2PnNquOiqqKKK4onHnvA5nHmbOoTnaqwl9HXz5v/7/Z7BOrk17LkjBaM3yn0VOcY52yO/vzn/H3fK7LOi74L4D9T0MuUzOgr4LeMz+McZ5jtNV3BoUchlfTe3B9LUnmfXDWeQyGNGt4VeVqNQa5kYmEHE6k7cGezK1j7sO0wpNVWF5ITMPzgRg+aDl2JnZ1Xsf+6/sZ+6vc6lQVwDgZunGl4O/xExpuD434ohC0AuZTMY/+/+TQW0Hae/bf2V/vWfEu116m9zi3Br7frrz05jIa06fq0sWLZR892JvurexYeamM6z6Na1BR0WFZZXM2HCaiNOZ/GNoZ94Z1lkPaYWmpkJdwYwDMzibc5azOWcJiQ7hws2H76dTqa7kq7Nf8c6hd6oVidVPrca+pb2+YtdKskJx8uRJ+vXrR2xsbK3rd+3axaRJkwgODiYiIgKAiooK5syZQ0hICKGhoVy9Kt2QC8KDmchNCAsMY0yHMQB8HPAxzhbOD7WtSq0iKi2Kibsm8t4Rw3Tgq41lCyUbXu7DiK4ufPJTMm9uPsvNwoefQvVsxi3GfXWEg8k5LBzzGG8P7SQG/GsmTOQmPOXxlLbndnZRNlN3T+Xz058/8GrAjIIMpu6eyjcJ32jvc7dyZ93wdbSxaqPX3LWRpOkpIyODdevW8fjjj9e6vri4mBUrVhAREYGJiQnjx49n6NChxMbGYm1tTVhQaSKIAAAKmElEQVRYGL/88gthYWEsX77cwOmF+jCRm7AoYBGjOoxigFv14QUq1BWs/n01/k7+tLGsevNfK7rGqeuniE6PJuNuBgC5JblsTNrItMemGTw/VI0H9VVID1a6prH8QCrHLuXx+pMdCe3bDosWtf8LXblZxMpDaWw5dRVnKzPCX+pN/44OBk4uSG3aY9Nwt3Jn7uG5FFUUodKoWJu4li0pWwjyCOKJNk/Q0aYjNi1ssDW7NxikuYl5tTle+rbuy78G/otWZq2keBnSFApHR0e++uorPvjgg1rXx8fH061bN6ysrADo2bMnZ86cIS4ujvHjxwMQEBDA/Pn6uQRN0C25TF6jSADsv7yf/5z7zwO3tzOzw91K2jZ9uVzGG4M8GertzKLdF/h0TzKfH0jlyc6O+LZphbO1GSq1moz8YuLSbnL26m1MFHKe7+/BO8M6Y2Wm32Yyoel6su2TbBm9hYXHFnL6xmmg6gR35MVIIi9GAhDkEcS/nvyXdhuHlg5M6jSJyIuRzOg+g+k+02tM6WtIkjxzy5Z1XxKYl5eHnd29kz4ODg7k5uZWu1+hUCCXyykvL8fU1LTa9klJDbv+vbS0tMHbGispX/Pq86vrXG+uMCfIOYixrcdiXmius5yNfc3v97cmuZMpB9MKOXn5JjHnb2jXyWXQ0c6Uad1tGd7JCjtzOZl/XNJF7EYR723pvev+LkctjrItextZpVnV1hUUFNTIGmgWSF+fvrgoXbiY8nAd+PT1mvVeKLZu3crWrVur3ffWW2/xxBNP3Hebv58w1Gg0yGSy+97/d97e3g3KmpSU1OBtjZVUr1mj0TDTfCZHs4+Smp9KTkkOcuTYtLDhMfvH6O3Sm8Hug/VyZYcuXrO3N0wYWHW7oLSC20UVyGTgYmPWJDvQifd20+CDDy9rXiY+N56DVw6SnJ9MZmEmbR3b6iRrY17z6dOn77tO74UiODiY4ODgem3j7OzMoUOHtMs5OTn4+fnh7OxMbm4uXl5eVFRUoNFoMDERh/TGSCaTMbTdUIa2Gyp1lEazNjPBWjQtCQ9JLpPj7+SPv5O/1FEeWtP76gN0796d33//nYKCAoqKijhz5gw9e/ZkwIAB7N1bNd57bGwsffr0kTipIAjCo0+ScxSHDh1izZo1pKenc/78ecLDw1m7di2rVq2iV69e+Pv7M2fOHF566SVkMhlvvPEGVlZWjBw5kmPHjhESEoKpqSmLFy+WIr4gCEKzIkmhCAwMJDAwsMb9r776qvZ2UFAQQUFB1dYrFAo+/fRTfccTBEEQ/qJJNj0JgiAITYcoFIIgCEKdRKEQBEEQ6iQKhSAIglAnmcbQs4DrWV2dRgRBEIT7u9/4e49coRAEQRB0SzQ9CYIgCHUShUIQBEGokygU//XJJ58wefJkpkyZQkJCgtRxDGLp0qVMnjyZSZMmsW/fPqnjGExpaSlDhgxh27ZtUkcxiF27djF27FgmTpzIL7/8InUcvSoqKuLNN99k2rRpTJkyhcOHD0sdSa9SU1MZOnQoGzZsAODatWtMmzaNqVOn8vbbb1NeXq6T5xGFgqrZ9q5cucKWLVtYtGgRH330kdSR9O748eNcvHiRLVu2sHr1aj755BOpIxnMypUradVKmglgDO3WrVusWLGCTZs28fXXX3PgwAGpI+nV9u3bad++PeHh4XzxxRd8/PHHUkfSm+LiYj766CP69eunve/LL79k6tSpbNq0CTc3N+3soI0lCgUQFxfH0KFVo5h6enpSUFBAYWGhxKn0q1evXnzxxRcA2NjYUFJSgkqlkjiV/qWlpXHp0qVah5B5FMXFxdGvXz8sLS1xcnJ65L8E2dracvv2baBqjgdbW9sHbGG8TE1N+fbbb3FyctLed+LECYYMGQLAkCFDiIuL08lziUJB1URJf31D2dvbk5ubK2Ei/VMoFJibmwNVc4YMHDgQhUIhcSr9W7JkCfPmzZM6hsFkZmai0WiYPXs2U6dO1dkHR1M1atQosrOzGTZsGKGhocydO1fqSHqjVCoxM6s+X0tJSYl2IjdHR0edfY5JN7deE/KwEyI9ig4cOEBERARr166VOore7dixAz8/P9q2bSt1FIO6ceMGX331FdnZ2Tz33HPExsY+su/vnTt34urqypo1a0hOTuaDDz4gMjJS6lgG89e/qy57PohCQdVESXl5edrlnJwcHBwcJExkGIcPH+brr79m9erV2vnJH2WHDh3i6tWrHDp0iOvXr2NqaoqLiwv9+/eXOpre2Nvb4+/vj1KpxN3dHQsLC/Lz87G3t5c6ml6cOXOGgIAAALy8vLhx4waVlZUolc3jo65ly5aUlpZiZmbGjRs3qjVLNYZoegIGDBhATEwMABcuXMDJyQlLS0uJU+nX3bt3Wbp0Kd98802zObG7fPlyIiMj+fHHHwkODmbmzJmPdJEACAgI4Pjx46jVavLz8ykuLn6k2+3btWtHfHw8AFlZWVhYWDSbIgHQv39/7WfZvn376pxyuj6az2+wDj169MDHx4cpU6Ygk8lYuHCh1JH07qeffuLWrVvMnj1be9+SJUtwdXWVMJWga87OzgwfPpzp06dTUlLC/Pnzkcsf3e+HkydP5v333yc0NJTKykr++c9/Sh1JbxITE1myZAlZWVkolUpiYmJYtmwZ8+bNY8uWLbi6ujJ+/HidPJcYwkMQBEGo06P71UIQBEHQCVEoBEEQhDqJQiEIgiDUSRQKQRAEoU6iUAiCIAh1EoVCEOrp2LFjTJs2Tbt848YNhg8fXm18sM2bN7No0aJq26WnpzN27Nj77nfw4MEUFRXpPrAgNJIoFIJQT/3796d169bs2LEDgMWLF/OPf/yjWifNoKAgDh48iFqt1t63Z88eRo8ebfC8gtBYosOdIDTAvHnzCA0NxdLSkqKiIoKCgqqtt7W1pXPnzvz222/06dMHgJiYGFauXElhYSFz5syhuLiY0tJSFixYgK+vr3bbI0eOsHz5cszMzLC3t2fZsmWYmJgY9PUJwl+JIwpBaAA7OzteeOEFZs+ezYIFC2p9zOjRo9mzZw9QNby5paUlbm5u5ObmEhwcTHh4OO+88w7ffvttte02bNjAvHnz2LBhA6NGjdIOmy0IUhGFQhAaKCUlBTc3NxITE2tdP2TIEA4fPoxKpWLPnj2MGjUKAAcHB2JiYggJCWHZsmU1CkFQUBALFy7k66+/xtvbG0dHR72/FkGoiygUgtAACQkJpKamsn79er788staT0Kbm5vj5+fHyZMnOXDgACNGjADg+++/x9nZmc2bN9c6FtH48eNZv349tra2zJgxg7S0NH2/HEGokygUglBPfw42t2DBApydnZk0aRL//ve/a33s6NGj2bhxI05OTtjZ2QFV05O6u7sDVfOBVFRUVNtmxYoVKJVKJk+ezMiRI0WhECQnCoUg1NPatWvp3bs3nTp1AmD69OkcPXqUlJSUGo8NCAjg1KlT2mYngHHjxrFu3TpefPFFfH19yc3NrTa5jqurKy+88ALPP/88ycnJOhsqWhAaSoweKwiCINRJHFEIgiAIdRKFQhAEQaiTKBSCIAhCnUShEARBEOokCoUgCIJQJ1EoBEEQhDqJQiEIgiDUSRQKQRAEoU7/H2VDVTOBKb6OAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('seaborn-whitegrid')\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = plt.axes()\n",
    "\n",
    "x = np.linspace(0, 10, 1000)\n",
    "ax.plot(x, np.sin(x));\n",
    "\n",
    "#Try playing around with colors and styles!\n",
    "ax.plot(x, np.cos(x), color='C2', linewidth=3, linestyle='--')\n",
    "\n",
    "plt.title('My New Plot', fontsize=14)\n",
    "plt.xlabel('X Vals'); plt.ylabel('Y Vals', fontsize=12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Histograms are also incredibly useful in data science."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Count')"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO4AAADMCAYAAAB0ip8fAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAPUUlEQVR4nO3df0zU9R8H8OcBXgPxixYnQfp1DFPJEstc/hjmN0CnYhMav26waqNsMsi25gBhWa4UsrnMKYRKmlnsrs1ao0CmMGV6LWYaBAnWkm8p3iWGwDE8vO8ffb1C4Lhfn8/x/tzz8Refzz4/Xgc+fX/u8+ulslqtVhCRUPy8XQAROY/BJRIQg0skIAaXSEAMLpGAArxdwL2ampq8XQLRhLFo0aJR50+44AJjF+uO1tZWREdHe3y7E4XSPx+g/M947+ezN4jxUJlIQAwukYAYXCIBMbhEAmJwiQTE4BIJaEJeDqL/O7XD4UVDTUbgmsb9ff6nwP1tkOQ44hIJiMElEhCDSyQgBpdIQAwukYAYXCIBMbhEAmJwiQTE4BIJiMElEhCDSyQgBpdIQHzIgGS1+8Qll9Z7LWGOhysRG0dcIgExuEQCYnCJBCTpd9zS0lI0NTXBYrFg48aNeOyxx7BlyxYMDQ1Bo9Hg3XffhVqtlrIEIkWSLLjnzp1De3s7qqqq0N3djaSkJCxduhRarRZr1qxBaWkp9Ho9tFqtVCUQKZZkh8qLFy/G+++/DwAICQmB2WyGwWBAXFwcACAuLg5nz56VavdEiibZiOvv74+goCAAgE6nw4oVK3DmzBnbobFGo4HRaBx13dbWVo/XMzAwIMl2pRRqGv33MxqLxQKjE8uPxSTx78hkuuHSeq2tQ0L+DZ3hzOeT/DpuXV0d9Ho9Dh06hNWrV9vmW63WMdeRoj+MkH1nnHj5m9FkhCbU/ZfFaST+HYX+17XruNHRc8T8GzphwvQOOn36NMrKylBRUYEpU6YgMDAQAwMDAICuri5Mnz5dyt0TKZZkwb116xZKS0tRXl6OqVOnAgCWLVuGmpoaAEBtbS1iY2Ol2j2Rokl2qFxdXY3u7m5s3rzZNm/nzp0oKipCVVUVIiIisGHDBql2T6RokgU3LS0NaWlpI+ZXVlZKtUsin8E7p4gExKeDyGWuPulD7uOISyQgBpdIQAwukYAYXCIBMbhEAmJwiQTE4BIJiMElEhCDSyQgBpdIQAwukYAYXCIBMbhEAuLTQVI7tcPbFZACccQlEhCDSyQgBpdIQAwukYAYXCIBMbhEAmJwiQTE4BIJiMElEpCkwb106RLi4+Nx9OhRAMD27duRnJyMrKwsZGVlob6+XsrdEymWZLc89vf3Y/v27Vi6dOmweW+//baiWyUSyUGyEVetVqOiomJYK82+vj6pdkfkUyQbcQMCAhAQMHzzfX192Lt3L3p6ehAWFoaioiJbC85/UlJHeme6yrvD3Y70F6+ZAQAnrzV6qiSPYkf64WR9Oig9PR2zZ89GZGQk9u/fjw8++ADFxcUjllNUR3onusq7w92O9EE9fwAAQj3Q1V4K7Eg/nKxnlRMSEhAZGWn7+aeffpJz90SKIWtwX3nlFfz+++8AAIPBgIcffljO3RMphmSHys3NzSgpKcFvv/2GgIAA1NTUICMjA7m5uQgKCkJgYCB27OBD5kSukCy4jz76KD7++OMR89euXSvVLol8Bu+cIhIQg0skIAaXSEAOBffUqVMj5n311VceL4aIHGP35NTFixfxww8/4MiRI7bLOAAwODiIyspKJCYmSl4gEY1kN7gajQZBQUG4ffs2uru7bfNVKhV27twpeXFENDq7wQ0PD0dSUhKefvppqNVq3Lp1C1arVa7aiGgMDl3H3b17NxoaGmxP+litVqhUKuj1ekmLI6LRORTclpYWNDQ0QKVSSV0PETnAobPK8+bNG/Ydl4i8y6ERt7OzE/Hx8Zg1axb8/f15qEzkZQ4Fl2eQiSYWh4K7d+/eUefz6R4i73AouKtXr7b9bLFY0NTUhEmTJklWFBHZ51BwV65cOWw6Pj4eL730khT1EJEDHApuQ0PDsOnr16+js7NTkoKIaHwOBfebb74ZNh0cHIxdu3ZJUhARjc+h4O7YsQOdnZ1oa2uDn58fHnnkEYSHh0tdGxGNwaHgHjhwANXV1YiJicHQ0BD27t2LlJQUaLVaqesjolE4FNy6ujrodDr4+/sD+OvMcmZmJoNL5CUOvwHDz89v2M+8b5nIexwacdesWYPnnnsOMTExsFqt+P7775Gamip1bUQ0BrvBHRwcxL59+5CTk4O4uDi0traivb0dc+fO5WEykRfZPVQuLS1Fb28vrFYrZsyYgYSEBGRnZyMkJGTM2yCJSHp2g3v+/HkUFRVBrVbb5qnVauTn56OxcWJ2dSPyBXaDe/cs8oiV/Pxw+/btcTd+b0f6q1evIisrC1qtFq+++ioGBwddKJmI7AZ32rRp+O6770bMr6+vh0Zjvx3jaB3p9+zZA61Wi2PHjuGhhx7i87xELrJ7cqqwsBC5ubmIiopCdHQ0hoaGcOHCBVy9ehUHDx60u+G7HekrKips8wwGA958800AQFxcHD766COe5CJygd3gzpo1C8ePH0djYyN+/vlnAEBmZiaWL18+7nXc0TrSm81m2/dljUYDo3H0DursSO+8f3akv9td3hUmmep11tZPjbBYLAj4/obD62QuvF/CijzPox3p/fz8EBsbi9jYWLcL+2fY7b3mlR3pnffPjvR3u8u7YqJ2pAf++k/Fmfqio+dIWI3nTdiO9IGBgRgYGAAAdHV12V73SkTOkTW4y5YtQ01NDQCgtrbWI6M4kS+StSP9rl27kJ+fj6qqKkRERGDDhg1S7Z5I0WTvSF9ZWSnVLol8BvvjEglIshF3Qjrlxutk/1PguTomsCVXPnRpvXP/ftnDlbhv94lLTq/zWoIYZ6I54hIJiMElEhCDSyQgBpdIQAwukYAYXCIBMbhEAmJwiQTE4BIJiMElEhCDSyQgBpdIQAwukYAYXCIBMbhEAmJwiQTE4BIJiMElEhCDSyQg33rnFEnG1XdVOaO/vw9B/ZNt0xPxPVdy4YhLJCAGl0hADC6RgGT9jtvc3IxNmzZh1qxZAIA5c+aguLhYzhKIFEHW4Pb392P16tXYunWrnLslUhxZD5X7+vrk3B2RYsk+4jY1NSE7Oxtmsxm5ublYsmTJiOWk6khvdKPbusnFmtztSO9od/k7d+7Az41O9CK4c+cO+vv//s/f5ObvdjRbP3V+m57qfO/RjvSeNG/ePOTk5CAuLg6//PILXnzxRdTW1kKtVg9bTqqO9Bo3uq1rXK3JzY70jnaX7+/vQ1DQ5PEXFNi9n9GZ7vRS8lTne2c60ssa3KioKERFRQEAIiMjERoaiq6uLsycOVPOMoiEJ+t3XL1ejyNHjgAAjEYj/vjjD4SFhclZApEiyDriJiQk4PXXX0dNTQ0GBwexbdu2EYfJRDQ+WYMbEhKCiooKOXdJpEi8c4pIQAwukYAYXCIBMbhEAmJwiQTE4BIJiMElEhDfOeWoUzvc3sTZnx2775jEsvvEJafXeS3BvfubOeISCYjBJRIQg0skIAaXSEAMLpGAGFwiAYl5OciFSzOhJiMwQV51Qp7hatsTJbQu4YhLJCAGl0hADC6RgBhcIgExuEQCYnCJBMTgEgmIwSUSEINLJCDZ75x65513cOHCBahUKhQWFmLBggVyl0AkPFmD++233+LXX39FVVUVOjo6UFBQAJ1OJ2cJRIog66Hy2bNnER8fDwCYPXs2enp60NvbK2cJRIog64hrMpkwf/582/QDDzwAo9GI4ODgYcvZ6wsKAPjXKud3/i/givNreZR6oYTblm7TE4anPuMK3PLQllw31r/xcf/t/5+swbVarSOmVSrVsHmLFi2SsyQiIcl6qBwWFgaTyWSbvn79OkJDQ+UsgUgRZA3u8uXLUVNTAwD48ccfMX369BGHyUQ0PlkPlZ944gnMnz8f6enpUKlUeOONN+TcPZFiqKz3fvFUIIvFgq1bt6KzsxMWiwVbtmzBk08+6e2yPEbp18ZLS0vR1NQEi8WCjRs3YtUqF05OCmBgYADr1q1DTk4OkpOT7S4r5qtrnPTFF18gMDAQx44dQ3t7OwoKCqDX671dlkco/dr4uXPn0N7ejqqqKnR3dyMpKUmxwd2/fz+mTp3q0LI+Edxnn30WiYmJAID7778fN2/e9HJFnjPWtXGlnDtYvHix7QgiJCQEZrMZQ0ND8Pf393JlnnX58mV0dHRg5cqVDi3vE/cqT5o0Cffddx8A4PDhw7YQK4HJZMK0adNs03evjSuFv78/goKCAAA6nQ4rVqxQXGgBoKSkBPn5+Q4vr7gRV6fTjThUzM3NRWxsLD755BO0tLSgrKzMS9V5niPXxpWgrq4Oer0ehw4d8nYpHnf8+HEsXLgQM2fOdHgdxQU3JSUFKSkpI+brdDqcPHkS+/btw6RJk7xQmTR84dr46dOnUVZWhgMHDmDKlCneLsfj6uvr0dnZifr6ely7dg1qtRoPPvggli1bNvZKVh9w5coVa3JysrW/v9/bpXhcU1OT9YUXXrBarVZrS0uLNT093csVeVZPT481MTHRajKZvF2KLPbs2WP9/PPPx11OcSPuaHQ6HW7evImXX/77RdgHDx6EWi3+Hb5KvzZeXV2N7u5ubN682TavpKQEERERXqzK+3ziOi6R0vjEWWUipWFwiQTE4BIJiMElEhCDSyQgBtcHpKamoqWlZdi89957D5WVlSOWNRgMyMvLk6s0chGD6wMSExNRXV09bF5tbS3Wrl3rpYrIXQyuD1i7di1OnDhhm25ubkZYWBguX76MtLQ0ZGZmYtOmTRgcHBy23lNPPWX7OS8vDwaDAb29vcjLy8Pzzz+PzMxMtLW1yfY56G8Mrg8IDQ3FjBkzcPHiRQDA119/jfXr1+PPP//Erl27cPToUQQHB+PMmTPjbuvw4cOIjY3F4cOHsW3bNpSUlEhdPo3CJ255pL8PlxcsWICTJ0/is88+Q1tbG4qKijA0NITOzk4sWbIEkydPtrud8+fP48aNG/jyyy8BAGazWY7y6R4Mro9YtWoVysvLsW7dOkRGRiIkJASFhYX48MMPERUVhbfeesvu+rdv3wbw17PNxcXFePzxx+Uom8bAQ2UfERwcjLlz56K8vNz2IoHe3l6Eh4ejp6cHBoPBFs67VCoVzGYzzGYzWltbAQAxMTGoq6sDAHR0dIx6Zpqkx+D6kPXr16OxsRHPPPMMAECr1SIjIwPFxcXIzs5GeXn5sLdnZGRkIDU1FQUFBbYOFJmZmbhy5Qq0Wi2KiooU9dI9kfDpICIBccQlEhCDSyQgBpdIQAwukYAYXCIBMbhEAmJwiQT0Py/JYfJJU+oyAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 252x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(3.5, 3))\n",
    "ax = plt.subplot(111)\n",
    "\n",
    "#Let's look at some synthetic distributions\n",
    "a = np.random.randn(100)+1.5\n",
    "b = np.random.randn(100)\n",
    "\n",
    "#alpha values let us set the transparency of plotted objects\n",
    "plt.hist(a, color='C0', alpha=0.5)\n",
    "plt.hist(b, color='C1', alpha=0.5)\n",
    "plt.xlabel('Value'); plt.ylabel('Count')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#The matshow function is incredibly useful for plotting time-frequency information, or anything 2D\n",
    "fig = plt.figure(figsize=(6, 3)); ax=plt.subplot(111)\n",
    "\n",
    "#Generate some fake 2D data\n",
    "mydata = np.random.randn(30, 60)\n",
    "\n",
    "#I like the RdBu_r colormap! It's often useful to set the range to be symmetrical\n",
    "plt.matshow(mydata, fignum=0, aspect='auto', cmap='RdBu_r', vmin=-3.5, vmax=3.5)\n",
    "plt.colorbar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise: Load power T-stats from an example subject (\"R1001P_powers.npy\") and create a time-frequency plot of electrode 70**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the data:\n",
    "# The os.path.join command concatenates the npy_files subdirectory with the filename\n",
    "# in an OS-independent manner.\n",
    "# Resulting data dimensions in t are [frequencies, electrodes, time bins].\n",
    "t = np.load(os.path.join('npy_files', 'R1001P_tstats.npy'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise: Create a time-frequency plot where only power values exceeding a T-stat of 2 are shown**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Brain Plotting\n",
    "\n",
    "There is a frequent need to plot electrodes on a 3D brain rendering, but unfortunately, such rendering is currently not possible in the online JupyterLab interface. However, it can be accomplished on your local machine with an Anaconda install and a few key toolboxes. See below for sample code that can plot electrodes on a brain, plot connections between them, and arbitrarily color elements. \n",
    "\n",
    "Toolboxes to install (both available through conda install): \n",
    "\n",
    "* mayavi\n",
    "* vtk\n",
    "\n",
    "Mayavi is actually an API wrapper around VTK, enabling easy 3D rendering of objects with a Python interface. Other packages, such as pysurfer ( https://pysurfer.github.io/ ), are themselves wrappers around mayavi. \n",
    "\n",
    "For 2D renderings, nilearn ( https://nilearn.github.io/auto_examples/index.html ) is a powerful visualization tool that will work in online Jupyter notebooks. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### NOTE: This code will not run in the rhino2 Jupyter notebooks! Please run on a local Anaconda install ###\n",
    "\n",
    "import os\n",
    "from mayavi.core.api import Engine\n",
    "from mayavi.sources.vtk_file_reader import VTKFileReader\n",
    "from mayavi.modules.surface import Surface\n",
    "\n",
    "# Define the path location for each side of the Freesurfer brain. Feel free to access them in /home1/esolo/\n",
    "vtkFile_l = 'lh.vtk'\n",
    "vtkFile_r = 'rh.vtk'\n",
    "\n",
    "# Create the MayaVi engine and start it.\n",
    "engine = Engine()\n",
    "engine.start()\n",
    "#scene = engine.new_scene()\n",
    "\n",
    "# Read in VTK file and add as source\n",
    "surface1 = Surface()\n",
    "reader1 = VTKFileReader()\n",
    "reader1.initialize(vtkFile_l)\n",
    "engine.add_source(reader1)\n",
    "engine.add_filter(surface1, reader1)\n",
    "\n",
    "surface2 = Surface()\n",
    "reader2 = VTKFileReader()\n",
    "reader2.initialize(vtkFile_r)\n",
    "engine.add_source(reader2)\n",
    "engine.add_filter(surface2, reader2) \n",
    "\n",
    "from mayavi import mlab\n",
    "import numpy as np\n",
    "\n",
    "coords = np.load('electrode_xyzs.npy')   # Nx3 array of that give electrode XYZ coordinates\n",
    "mycolors = np.load('electrode_colors.npy')*-1   #array of values that correspond to electrode colors\n",
    "coords = coords[np.isfinite(mycolors), :]   #not plotting electrodes with NaN values\n",
    "\n",
    "#Instantiating the Mayavi scene object\n",
    "figure = mlab.figure(1, bgcolor=(1.0, 1.0, 1.0))\n",
    "figure.scene.disable_render = True\n",
    "\n",
    "#Plot the electrodes\n",
    "pts = mlab.points3d(coords[:, 0], coords[:, 1], coords[:, 2],\n",
    "                        mycolors[np.isfinite(mycolors)], vmin=-2, vmax=2,\n",
    "                        scale_factor=4 ,\n",
    "                        scale_mode='none',\n",
    "                        colormap='RdBu',\n",
    "                        resolution=40)  \n",
    "\n",
    "figure.scene.disable_render = False\n",
    "\n",
    "#Make things look pretty.\n",
    "scene = engine.scenes[0]\n",
    "scene.scene.background = (1.0, 1.0, 1.0)\n",
    "surface = engine.scenes[0].children[0].children[0].children[0]\n",
    "surface.actor.property.opacity = 0.2\n",
    "surface = engine.scenes[0].children[1].children[0].children[0]\n",
    "surface.actor.property.opacity = 0.2\n",
    "\n",
    "mlab.show() # Launch an interactive window"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://github.com/esolomon/PythonBootcamp2019/blob/master/figures/mayavi.png?raw=true\" width=650>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pre-rendered brains\n",
    "\n",
    "Simply visualizing the electrode layout on any subject's brain is easy. 3D renders have been precomputed and are available via rhino:\n",
    "\n",
    "http://memory.psych.upenn.edu/public/reports/r1/subjects/001/reports/iEEG_surface/iEEG_surface.html\n",
    "\n",
    "Just modify the subject code in the middle of the url (i.e. R1111M becomes 111) to navigate to the desired subject."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If time allows, include a discussion of Seaborn functionality here. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "environmentname",
   "language": "python",
   "name": "environmentname"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}