WidgetsAndMagics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## some useful widgets, magics and tricks in notebooks\n",
    "\n",
    "but they are not working\n",
    "references:\n",
    "https://blog.dominodatalab.com/interactive-dashboards-in-jupyter/\n",
    "https://github.com/jupyter-widgets/ipywidgets/issues/2220\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "### pass variables between notebooks with %store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stored 'data' (str)\n"
     ]
    }
   ],
   "source": [
    "data = \"this is some data that is passed to other notebooks, maybe even with different language\"\n",
    "%store data\n",
    "\n",
    "# delete data variable in this notebook\n",
    "del data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### save code and retrieve in another notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing _imports.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile _imports.py\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import pylab as pl\n",
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to retrieve the code saved to _imports.py, use %pycat _imports.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipywidgets import widgets\n",
    "from IPython.display import display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3941448cee084c58b775bb18cc26bc55",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "text = widgets.Text()\n",
    "\n",
    "display(text)\n",
    "\n",
    "def handle_submit(sender):\n",
    "    print(text.value)\n",
    "\n",
    "text.on_submit(handle_submit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "24d0b192d5b141b2876b094862158b5b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Click me!!!', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you clicked the button\n",
      "123\n",
      "you clicked the button\n",
      "123\n",
      "you clicked the button\n",
      "123\n"
     ]
    }
   ],
   "source": [
    "button = widgets.Button(description = \"Click me!!!\")\n",
    "display(button)\n",
    "a = 123\n",
    "def on_button_clicked(sender):\n",
    "    print(\"you clicked the button\")\n",
    "    print(a)\n",
    "    \n",
    "button.on_click(on_button_clicked)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook \n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display\n",
    "from ipywidgets import widget, Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e5709b910f28453aa40fbaebcb2849fe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='', description='Domain to ping')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Domain gave error on pinging\n"
     ]
    }
   ],
   "source": [
    "plt.style.use('ggplot')\n",
    " \n",
    "NUMBER_OF_PINGS = 4\n",
    " \n",
    "# displaying the text widget\n",
    "text = widgets.Text(description=\"Domain to ping\", width=200)\n",
    "display(text)\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# preparing the plot \n",
    "data = pd.DataFrame()\n",
    "x = range(1,NUMBER_OF_PINGS+1)\n",
    "plots = dict()\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlabel('iterations')\n",
    "plt.ylabel('ms')\n",
    "plt.xticks(x)\n",
    "plt.show()\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "30453899cef948fdb0850fd4849af236",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# preparing a container to put in created checkbox per domain\n",
    "checkboxes = []\n",
    "cb_container = widgets.HBox()\n",
    "display(cb_container)\n",
    " \n",
    "# add button that updates the graph based on the checkboxes\n",
    "button = widgets.Button(description=\"Update the graph\")\n",
    " \n",
    "# function to deal with the added domain name\n",
    "def handle_submit(sender):\n",
    "    # a part of the magic inside python : pinging\n",
    "    res = !ping -c {NUMBER_OF_PINGS} {text.value}\n",
    "    hits = res.grep('64 bytes').fields(-2).s.replace(\"time=\",\"\").split()\n",
    "    if len(hits) == 0:\n",
    "        print(\"Domain gave error on pinging\")\n",
    "    else:\n",
    "         # rebuild plot based on ping result\n",
    "        data = hits\n",
    "        data = data.astype(float)\n",
    "        plots, = ax.plot(x, data, label=text.value)\n",
    "        plt.legend()\n",
    "        plt.draw()\n",
    "        # add a new checkbox for the new domain\n",
    "        checkboxes.append(widgets.Checkbox(description = text.value, value=True, width=90))\n",
    "        cb_container.children=[i for i in checkboxes]\n",
    "        if len(checkboxes) == 1:\n",
    "            display(button)\n",
    " \n",
    "# function to deal with the checkbox update button       \n",
    "def on_button_clicked(b):\n",
    "    for c in cb_container.children:\n",
    "        if not c.value:\n",
    "            plots.set_visible(False)\n",
    "        else:\n",
    "            plots.set_visible(True)\n",
    "    plt.legend()\n",
    "    plt.draw()\n",
    " \n",
    "button.on_click(on_button_clicked)\n",
    "text.on_submit(handle_submit)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## magic commands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'LC_ALL': 'en_US.UTF-8',\n",
       " 'LANG': 'en_US.UTF-8',\n",
       " 'JUPYTER_ENABLE_LAB': 'yes',\n",
       " 'HOSTNAME': '6d2d935fcbcc',\n",
       " 'JULIA_DEPOT_PATH': '/opt/julia',\n",
       " 'JULIA_PKGDIR': '/opt/julia',\n",
       " 'NB_UID': '1000',\n",
       " 'CONDA_DIR': '/opt/conda',\n",
       " 'PWD': '/home/jovyan',\n",
       " 'HOME': '/home/jovyan',\n",
       " 'DEBIAN_FRONTEND': 'noninteractive',\n",
       " 'NB_USER': 'jovyan',\n",
       " 'JULIA_VERSION': '1.0.0',\n",
       " 'SHELL': '/bin/bash',\n",
       " 'TERM': 'xterm-color',\n",
       " 'SHLVL': '0',\n",
       " 'LANGUAGE': 'en_US.UTF-8',\n",
       " 'XDG_CACHE_HOME': '/home/jovyan/.cache/',\n",
       " 'NB_GID': '100',\n",
       " 'PATH': '/opt/conda/bin:/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',\n",
       " 'MINICONDA_VERSION': '4.5.11',\n",
       " 'JPY_PARENT_PID': '7',\n",
       " 'CLICOLOR': '1',\n",
       " 'PAGER': 'cat',\n",
       " 'GIT_PAGER': 'cat',\n",
       " 'MPLBACKEND': 'module://ipykernel.pylab.backend_inline'}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "%env\n",
      "%history\n"
     ]
    }
   ],
   "source": [
    "%history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available matplotlib backends: ['tk', 'gtk', 'gtk3', 'wx', 'qt4', 'qt5', 'qt', 'osx', 'nbagg', 'notebook', 'agg', 'svg', 'pdf', 'ps', 'inline', 'ipympl', 'widget']\n"
     ]
    }
   ],
   "source": [
    "%matplotlib --list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1234567\n"
     ]
    }
   ],
   "source": [
    "%precision 2\n",
    "print(0.1234567)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/jovyan/work'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "IPython -- An enhanced Interactive Python - Quick Reference Card\n",
       "================================================================\n",
       "\n",
       "obj?, obj??      : Get help, or more help for object (also works as\n",
       "                   ?obj, ??obj).\n",
       "?foo.*abc*       : List names in 'foo' containing 'abc' in them.\n",
       "%magic           : Information about IPython's 'magic' % functions.\n",
       "\n",
       "Magic functions are prefixed by % or %%, and typically take their arguments\n",
       "without parentheses, quotes or even commas for convenience.  Line magics take a\n",
       "single % and cell magics are prefixed with two %%.\n",
       "\n",
       "Example magic function calls:\n",
       "\n",
       "%alias d ls -F   : 'd' is now an alias for 'ls -F'\n",
       "alias d ls -F    : Works if 'alias' not a python name\n",
       "alist = %alias   : Get list of aliases to 'alist'\n",
       "cd /usr/share    : Obvious. cd -<tab> to choose from visited dirs.\n",
       "%cd??            : See help AND source for magic %cd\n",
       "%timeit x=10     : time the 'x=10' statement with high precision.\n",
       "%%timeit x=2**100\n",
       "x**100           : time 'x**100' with a setup of 'x=2**100'; setup code is not\n",
       "                   counted.  This is an example of a cell magic.\n",
       "\n",
       "System commands:\n",
       "\n",
       "!cp a.txt b/     : System command escape, calls os.system()\n",
       "cp a.txt b/      : after %rehashx, most system commands work without !\n",
       "cp ${f}.txt $bar : Variable expansion in magics and system commands\n",
       "files = !ls /usr : Capture system command output\n",
       "files.s, files.l, files.n: \"a b c\", ['a','b','c'], 'a\\nb\\nc'\n",
       "\n",
       "History:\n",
       "\n",
       "_i, _ii, _iii    : Previous, next previous, next next previous input\n",
       "_i4, _ih[2:5]    : Input history line 4, lines 2-4\n",
       "exec _i81        : Execute input history line #81 again\n",
       "%rep 81          : Edit input history line #81\n",
       "_, __, ___       : previous, next previous, next next previous output\n",
       "_dh              : Directory history\n",
       "_oh              : Output history\n",
       "%hist            : Command history of current session.\n",
       "%hist -g foo     : Search command history of (almost) all sessions for 'foo'.\n",
       "%hist -g         : Command history of (almost) all sessions.\n",
       "%hist 1/2-8      : Command history containing lines 2-8 of session 1.\n",
       "%hist 1/ ~2/     : Command history of session 1 and 2 sessions before current.\n",
       "%hist ~8/1-~6/5  : Command history from line 1 of 8 sessions ago to\n",
       "                   line 5 of 6 sessions ago.\n",
       "%edit 0/         : Open editor to execute code with history of current session.\n",
       "\n",
       "Autocall:\n",
       "\n",
       "f 1,2            : f(1,2)  # Off by default, enable with %autocall magic.\n",
       "/f 1,2           : f(1,2) (forced autoparen)\n",
       ",f 1 2           : f(\"1\",\"2\")\n",
       ";f 1 2           : f(\"1 2\")\n",
       "\n",
       "Remember: TAB completion works in many contexts, not just file names\n",
       "or python names.\n",
       "\n",
       "The following magic functions are currently available:\n",
       "\n",
       "%alias:\n",
       "    Define an alias for a system command.\n",
       "%alias_magic:\n",
       "    ::\n",
       "%autoawait:\n",
       "    \n",
       "%autocall:\n",
       "    Make functions callable without having to type parentheses.\n",
       "%automagic:\n",
       "    Make magic functions callable without having to type the initial %.\n",
       "%autosave:\n",
       "    Set the autosave interval in the notebook (in seconds).\n",
       "%bookmark:\n",
       "    Manage IPython's bookmark system.\n",
       "%cat:\n",
       "    Alias for `!cat`\n",
       "%cd:\n",
       "    Change the current working directory.\n",
       "%clear:\n",
       "    Clear the terminal.\n",
       "%colors:\n",
       "    Switch color scheme for prompts, info system and exception handlers.\n",
       "%config:\n",
       "    configure IPython\n",
       "%connect_info:\n",
       "    Print information for connecting other clients to this kernel\n",
       "%cp:\n",
       "    Alias for `!cp`\n",
       "%debug:\n",
       "    ::\n",
       "%dhist:\n",
       "    Print your history of visited directories.\n",
       "%dirs:\n",
       "    Return the current directory stack.\n",
       "%doctest_mode:\n",
       "    Toggle doctest mode on and off.\n",
       "%ed:\n",
       "    Alias for `%edit`.\n",
       "%edit:\n",
       "    Bring up an editor and execute the resulting code.\n",
       "%env:\n",
       "    Get, set, or list environment variables.\n",
       "%gui:\n",
       "    Enable or disable IPython GUI event loop integration.\n",
       "%hist:\n",
       "    Alias for `%history`.\n",
       "%history:\n",
       "    ::\n",
       "%killbgscripts:\n",
       "    Kill all BG processes started by %%script and its family.\n",
       "%ldir:\n",
       "    Alias for `!ls -F -o --color %l | grep /$`\n",
       "%less:\n",
       "    Show a file through the pager.\n",
       "%lf:\n",
       "    Alias for `!ls -F -o --color %l | grep ^-`\n",
       "%lk:\n",
       "    Alias for `!ls -F -o --color %l | grep ^l`\n",
       "%ll:\n",
       "    Alias for `!ls -F -o --color`\n",
       "%load:\n",
       "    Load code into the current frontend.\n",
       "%load_ext:\n",
       "    Load an IPython extension by its module name.\n",
       "%loadpy:\n",
       "    Alias of `%load`\n",
       "%logoff:\n",
       "    Temporarily stop logging.\n",
       "%logon:\n",
       "    Restart logging.\n",
       "%logstart:\n",
       "    Start logging anywhere in a session.\n",
       "%logstate:\n",
       "    Print the status of the logging system.\n",
       "%logstop:\n",
       "    Fully stop logging and close log file.\n",
       "%ls:\n",
       "    Alias for `!ls -F --color`\n",
       "%lsmagic:\n",
       "    List currently available magic functions.\n",
       "%lx:\n",
       "    Alias for `!ls -F -o --color %l | grep ^-..x`\n",
       "%macro:\n",
       "    Define a macro for future re-execution. It accepts ranges of history,\n",
       "%magic:\n",
       "    Print information about the magic function system.\n",
       "%man:\n",
       "    Find the man page for the given command and display in pager.\n",
       "%matplotlib:\n",
       "    ::\n",
       "%mkdir:\n",
       "    Alias for `!mkdir`\n",
       "%more:\n",
       "    Show a file through the pager.\n",
       "%mv:\n",
       "    Alias for `!mv`\n",
       "%notebook:\n",
       "    ::\n",
       "%page:\n",
       "    Pretty print the object and display it through a pager.\n",
       "%pastebin:\n",
       "    Upload code to dpaste's paste bin, returning the URL.\n",
       "%pdb:\n",
       "    Control the automatic calling of the pdb interactive debugger.\n",
       "%pdef:\n",
       "    Print the call signature for any callable object.\n",
       "%pdoc:\n",
       "    Print the docstring for an object.\n",
       "%pfile:\n",
       "    Print (or run through pager) the file where an object is defined.\n",
       "%pinfo:\n",
       "    Provide detailed information about an object.\n",
       "%pinfo2:\n",
       "    Provide extra detailed information about an object.\n",
       "%pip:\n",
       "    \n",
       "%popd:\n",
       "    Change to directory popped off the top of the stack.\n",
       "%pprint:\n",
       "    Toggle pretty printing on/off.\n",
       "%precision:\n",
       "    Set floating point precision for pretty printing.\n",
       "%prun:\n",
       "    Run a statement through the python code profiler.\n",
       "%psearch:\n",
       "    Search for object in namespaces by wildcard.\n",
       "%psource:\n",
       "    Print (or run through pager) the source code for an object.\n",
       "%pushd:\n",
       "    Place the current dir on stack and change directory.\n",
       "%pwd:\n",
       "    Return the current working directory path.\n",
       "%pycat:\n",
       "    Show a syntax-highlighted file through a pager.\n",
       "%pylab:\n",
       "    ::\n",
       "%qtconsole:\n",
       "    Open a qtconsole connected to this kernel.\n",
       "%quickref:\n",
       "    Show a quick reference sheet \n",
       "%recall:\n",
       "    Repeat a command, or get command to input line for editing.\n",
       "%rehashx:\n",
       "    Update the alias table with all executable files in $PATH.\n",
       "%reload_ext:\n",
       "    Reload an IPython extension by its module name.\n",
       "%rep:\n",
       "    Alias for `%recall`.\n",
       "%rerun:\n",
       "    Re-run previous input\n",
       "%reset:\n",
       "    Resets the namespace by removing all names defined by the user, if\n",
       "%reset_selective:\n",
       "    Resets the namespace by removing names defined by the user.\n",
       "%rm:\n",
       "    Alias for `!rm`\n",
       "%rmdir:\n",
       "    Alias for `!rmdir`\n",
       "%run:\n",
       "    Run the named file inside IPython as a program.\n",
       "%save:\n",
       "    Save a set of lines or a macro to a given filename.\n",
       "%sc:\n",
       "    Shell capture - run shell command and capture output (DEPRECATED use !).\n",
       "%set_env:\n",
       "    Set environment variables.  Assumptions are that either \"val\" is a\n",
       "%store:\n",
       "    Lightweight persistence for python variables.\n",
       "%sx:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "%system:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "%tb:\n",
       "    Print the last traceback.\n",
       "%time:\n",
       "    Time execution of a Python statement or expression.\n",
       "%timeit:\n",
       "    Time execution of a Python statement or expression\n",
       "%unalias:\n",
       "    Remove an alias\n",
       "%unload_ext:\n",
       "    Unload an IPython extension by its module name.\n",
       "%who:\n",
       "    Print all interactive variables, with some minimal formatting.\n",
       "%who_ls:\n",
       "    Return a sorted list of all interactive variables.\n",
       "%whos:\n",
       "    Like %who, but gives some extra information about each variable.\n",
       "%xdel:\n",
       "    Delete a variable, trying to clear it from anywhere that\n",
       "%xmode:\n",
       "    Switch modes for the exception handlers.\n",
       "%%!:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "%%HTML:\n",
       "    Alias for `%%html`.\n",
       "%%SVG:\n",
       "    Alias for `%%svg`.\n",
       "%%bash:\n",
       "    %%bash script magic\n",
       "%%capture:\n",
       "    ::\n",
       "%%debug:\n",
       "    ::\n",
       "%%file:\n",
       "    Alias for `%%writefile`.\n",
       "%%html:\n",
       "    ::\n",
       "%%javascript:\n",
       "    Run the cell block of Javascript code\n",
       "%%js:\n",
       "    Run the cell block of Javascript code\n",
       "%%latex:\n",
       "    Render the cell as a block of latex\n",
       "%%markdown:\n",
       "    Render the cell as Markdown text block\n",
       "%%perl:\n",
       "    %%perl script magic\n",
       "%%prun:\n",
       "    Run a statement through the python code profiler.\n",
       "%%pypy:\n",
       "    %%pypy script magic\n",
       "%%python:\n",
       "    %%python script magic\n",
       "%%python2:\n",
       "    %%python2 script magic\n",
       "%%python3:\n",
       "    %%python3 script magic\n",
       "%%ruby:\n",
       "    %%ruby script magic\n",
       "%%script:\n",
       "    ::\n",
       "%%sh:\n",
       "    %%sh script magic\n",
       "%%svg:\n",
       "    Render the cell as an SVG literal\n",
       "%%sx:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "%%system:\n",
       "    Shell execute - run shell command and capture output (!! is short-hand).\n",
       "%%time:\n",
       "    Time execution of a Python statement or expression.\n",
       "%%timeit:\n",
       "    Time execution of a Python statement or expression\n",
       "%%writefile:\n",
       "    ::\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%quickref"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
      "Wall time: 8.82 µs\n"
     ]
    }
   ],
   "source": [
    "%time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interactive namespace is empty.\n"
     ]
    }
   ],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyUAAAH0CAYAAAAjaYI8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3Xd8VuXdx/HPlbCnIoo4AQVBRTEBrOijdbXaOqrFLaLUVWcdVVutra21rbNVq7YunMVti1Vr1VpUKiNhqCiIgooMGTJDEpJczx/3yU2MCQYETsbn/Xr5untd9/md8wv26ZMv51znCjFGJEmSJCktOWk3IEmSJKlpM5RIkiRJSpWhRJIkSVKqDCWSJEmSUmUokSRJkpQqQ4kkSZKkVBlKJEmSJKXKUCJJkiQpVYYSSZIkSakylEiSJElKlaFEkiRJUqoMJZIkSZJSZSiRJEmSlCpDiSRJkqRUGUokSZIkpcpQIkmSJClVzdJuQOtfCGEG0AGYmXIrkiRJaty6AUtjjN2/yUkMJY1Th9atW3fq06dPp7QbkSRJUuP13nvvsXLlym98HkNJ4zSzT58+nQoKCtLuQ5IkSY1Yfn4+hYWFM7/peVxTIkmSJClVhhJJkiRJqTKUSJIkSUqVoUSSJElSqgwlkiRJklJlKJEkSZKUKkOJJEmSpFQZSiRJkiSlylAiSZIkKVWGEkmSJEmpWi+hJIQwOIRwWwjh9RDC0hBCDCE8/DU1g0IIz4cQFoUQikIIk0MIPwkh5K6h5rAQwmshhCUhhOUhhDEhhKFfc52hIYSxyfFLkvrD1nB8btLH5BDCyqS/50MIg9ZQ0zqEcE0IYWoIoTiE8HkI4fEQQp811HQKIfwxhDAzhFASQpgdQrgvhLDNmn4eSZIkqbFZX3dKrgLOA/oBn33dwSGEI4FRwL7AM8CfgRbALcCIWmrOA0YCuwIPA3cDWwHDQwg31lJzIzAc6Joc/zDQFxiZnK/68SG5/i1JP7cn/e0LjEr6rl7TEvg3cDWwFPgT8DJwFDA+hLBnDTWbAf8DLgQ+TK43FjgNKAgh9Kjp55EkSZIao2br6TwXAbOA6cB+wH9qOzCE0IFMQCgHvh1jHJ/M/wJ4FRgcQjg+xjiiSk034EZgEdA/xjgzmf81MA64JITwVIzxf1VqBgGXkPmlf0CM8Ytk/gagALgxhPBc5bkSxwODgdHAgTHG4qTmLuAN4O4QwqsxxmVVai4G9gaeBI6LMVYkNY8BzwL3hRD6Vs4nrgN6AbfEGC+u0vMFZELNHcAhtf0ZSpIkSY3JerlTEmP8T4zxgxhjrMPhg4HNgRGVgSQ5RzGZOy4AP65WMwxoCdxeNUQkQeO6ZHh2tZrK8W8rA0lSM5PMnZmWZO5MVFV53asqA0lSMw54LOl7cOV8cmel8jqXVQ0eMca/A68DO5MJapU1bYEhwArgl9WufzswE/iud0skSZLUVKSx0P2A5PPFGr4bBRQBg5LHoupS80K1Y9apJrneoOT6r9fxOjsA2wHTYowz6lizF9AaeLPaHReSUPNSMty/hvNJkiRJjU4aoWSn5HNa9S9ijGXADDKPlfWoY80cMncdtgkhtIHs3YitgeXJ99V9kHz2qjK3I5ALfJT0UZeaWvtazzWSJElSjUrLKniyYBZ1e2ipflpfa0rWRsfkc0kt31fOb7KWNW2T44o24DXSqqlRCKGglq96f12tJEmSGofrnn+P4aNn8tK7c7nx2N3p0Kp52i2ttfq4T0lIPtcm6q1Lzca4xsb8WSRJktTE/GPSbIaPngnAS1PmMXLS7HQbWkdp3CmpvBPQsZbvO1Q7rvI/d05qFq6hZmkdr1HT3Yp17Wtj1NQoxphf03xyByXv6+olSZLUcH0wbxlXPDU5Oz5kly05ceB2KXa07tK4UzI1+fzKmokQQjOgO1AGfFTHmq5kHt2aFWMsAogxriCzX0q75PvqeiafVdd1TCfzmuIeSR91qam1r/VcI0mSJGUtLynj7IcLKCotB6B757bccMxuZF4O2/CkEUpeTT5r2odjX6ANMDrGWFLHmkOrHbNONcn1RifX/786XudD4BOgVwihex1r3gJWAnuHENpXPTiEkAN8JxnWuteLJEmSmq4YI5c/OZkP568AoFXzHO48OY/2DXAtSaU0QsmTwALg+BBC/8rJEEIr4NpkeGe1mvuBEuC8ZCPFyppNgZ8nw7uq1VSOr0yOq6zpBpybnO/+ajWV17026aeyZgBwHDAfeKpyPtmXpfI61yehorLmSDLhZgrw3yo1y4GHyNzd+VW1658HdAP+FWP8CEmSJKmae9+YwT/fXv2C2euO6kvvLTusoaL+Wy9rSkIIPwB+kAy3TD73CiEMT/7zghjjpQAxxqUhhDPIhJPXQggjyOzUfgSZ1+U+SWajwqwY44wQwk+BW4HxyW7ppWQ2MtwGuKnqbu5JzegQws1kdlyfHEJ4EmhBJlx0As6vtps7wAjg6OS8E0III4HNkppc4IwY49JqNTcDhyU1Y0IIr5DZu+QYMm8CG1ZtN3fIBKlvAxeHEPoBY4E+wJHA52RCkyRJkvQlb320kN+98H52PORb23N03jYpdrR+rK+F7v2AodXmerB6r5GPgUsrv4gxPhtC2A+4Evgh0IrMmo6LgVtr2hk+xnhbCGFmcp5TyNzlmUJm9/UHamoqxnhJCGEymTsQZwIVQCFwQ4zxuRqOjyGEE8g8xjUMOB8oJrOp47UxxtE11JSEEA4CrgBOBC4is+D+WeCXMcYpNdQsDCHsRWZH9x+QuaOykMydm6tjjLNq+nkkSZLUdM1dUsx5jxZSXpH5VXmP7TbhF4ftnHJX60doyJusqGYhhIK8vLy8goLatjGRJElSQ1JaVsEJd79FwcdfALBZ2xY8d8E+dO3YOtW+8vPzKSwsLKztrbB1VR/3KZEkSZJUxXXPv5cNJDkBbjtxj9QDyfpkKJEkSZLqsWcnfJbdIBHg8kN6M2iHzuk1tAEYSiRJkqR66r05S7ni6S9vkHjmvj3WUNEwGUokSZKkemjJylX8+OECildlXuTaY/OGvUHimhhKJEmSpHqmoiJyyeMTmbmwCIA2LXL5y8n5DXqDxDUxlEiSJEn1zJ3//ZCX3/s8O75+8G707NI+xY42LEOJJEmSVI+MmjafG1+amh2fvk93DtttqxQ72vAMJZIkSVI9MeuLIi4cMYHKrQQHdu/E5Yf2TrepjcBQIkmSJNUDxavKOeeRQr4oWgXAFu1bcvuJe9A8t/H/yt74f0JJkiSpAbhm5LtMnrUEgGY5gTtOymOL9q1S7mrjMJRIkiRJKXts3Cf8beyn2fFV3+9D/26dUuxo4zKUSJIkSSma9OlifvH3d7PjI/ttxdBB3dJrKAWGEkmSJCklC5aXcPbDBZSWZTZI3KlLe353dN9GuUHimhhKJEmSpBSsKq/gnEcKmbOkGIAOrZrxlyH5tGnRLOXONj5DiSRJkpSC3/7zPcbOWARACPCnE/agW+e2KXeVDkOJJEmStJE9VTCL4aNnZseXfmcn9t9pi/QaSpmhRJIkSdqI3p61hJ8/83Z2fMguW3LOt3dIsaP0GUokSZKkjWTh8hLOemg8JcnC9p5btOPGY3dvcgvbqzOUSJIkSRtBWXkF5z5ayOxkYXv7Vs346yn9adey6S1sr85QIkmSJG0E1z3/Pm99VGVh+/H96N5EF7ZXZyiRJEmSNrBnJszivjdnZMcXH9SLA3p3SbGj+sVQIkmSJG1A73y2hCueWr2w/Ts7d+Hc/XdMsaP6x1AiSZIkbSCLVpRy1kMF2YXtO2zelpuO3Z2cnKa9sL06Q4kkSZK0AZSVV3Deo4V8tnglAO1bZha2t2/VPOXO6h9DiSRJkrQB/P6F9xn94cLs+Jbj+rHD5u1S7Kj+MpRIkiRJ69nfJ37GPW+sXtj+k4N6ctDOLmyvjaFEkiRJWo/enb2Ey5+anB0f1KcLFxzQM8WO6j9DiSRJkrSeLFxewpkPFlC8KrOwvcfmbbn5OBe2fx1DiSRJkrQerCqv4JxHVi9sb9eyGX8d0p8OLmz/WoYSSZIkaT349cgpjJmxesf2W47rx45buLC9LgwlkiRJ0jf06JhPeOitj7PjSw7uxcEubK8zQ4kkSZL0DYydsYir//5Odvz93bq6Y/taMpRIkiRJ62jWF0X8+OECyioiADt37cANg3cjBBe2rw1DiSRJkrQOikrLOPPBAhauKAVgs7YtuHtof9q0aJZyZw2PoUSSJElaSzFGfvrEZKbMWQpA89zAnSfns/UmrVPurGEylEiSJElr6Y7XPuSfb8/Jjq85YlcGdu+UYkcNm6FEkiRJWgsvT5nHjS9NzY6HfGt7TtxzuxQ7avgMJZIkSVIdfTBvGT95bCIxs66db/XoxNWH75xuU42AoUSSJEmqg8VFpZz+4HiWl5QBsM2mrbnjpHya5/or9Tfln6AkSZL0NcrKKzjv0Ql8vLAIgDYtcrn7lP50atsi5c4aB0OJJEmS9DWue/593pi+IDu++djd6dO1Q4odNS6GEkmSJGkNnhj/Kfe9OSM7vvDAnhyya9cUO2p8DCWSJElSLQo/+YIrn3knO/7uLl248MCeKXbUOBlKJEmSpBrMXrySMx8soLS8AoDeW7bn5mP7kZMTUu6s8TGUSJIkSdWsKCnjRw+MZ8HyEgA2bdOcu0/pT9uWzVLurHEylEiSJElVVFRELnpsIu/NWQpA89zAXSfns22nNil31ngZSiRJkqQqbvr3VF6aMi87vvYHu7Jnj81S7KjxM5RIkiRJiWcmzOLP//kwOz59n+4cN2C7FDtqGgwlkiRJElDw8Rdc/uTb2fH+O23Oz77XJ8WOmg5DiSRJkpq8WV8UcdZD47Nv2urVpR23nrAHub5pa6MwlEiSJKlJW1FSxukPjGfB8lIAOrVtwT2nDKB9q+Ypd9Z0GEokSZLUZFVURC4cMZH35y4DVr9pa7vNfNPWxmQokSRJUpN1/b+m8vJ7q9+09dsf9GVg904pdtQ0GUokSZLUJD1VMIu7/rv6TVtn7tuDYwdsm2JHTZehRJIkSU3O+JmL+NnTq9+0dWDvLbj8kN4pdtS0GUokSZLUpHy6qIizHirIvmlrpy7t+ePx/XzTVooMJZIkSWoylpeUccaD41m4osqbtob2901bKTOUSJIkqUkor4hc+LcJX3rT1l+G5LNtJ9+0lTZDiSRJkpqE37/wHq+8/3l2fN1RfRnQzTdt1QeGEkmSJDV6j4z5mLtfn5Edn7VvD47p75u26gtDiSRJkhq1UdPmc/Xf382OD965C5f5pq16xVAiSZKkRmvq3GWc+0gh5RURgF237sCffNNWvWMokSRJUqM0f1kJw4aPY1lJGQBdO7bi3qEDaNOiWcqdqTpDiSRJkhqd4lXlnP7geD5bvBKAti1yuXfoALp0aJVyZ6qJoUSSJEmNSkVF5OLHJzLp08UA5AS4/cQ8dt6qQ8qdqTaphpIQwvdDCC+FEGaFEFaGED4KITwRQtirluMHhRCeDyEsCiEUhRAmhxB+EkLIXcM1DgshvBZCWBJCWB5CGBNCGPo1fQ0NIYxNjl+S1B+2huNzkz4mJz/HoqTPQWuoaR1CuCaEMDWEUBxC+DyE8HgIoc+aepMkSdKa3fDSVJ5/e252/MvDd2H/3luk2JG+TmqhJITwB+A5IA94EfgTUAgcCbwZQji52vFHAqOAfYFngD8DLYBbgBG1XOM8YCSwK/AwcDewFTA8hHBjLTU3AsOBrsnxDwN9gZHJ+aofH5Lr35L0c3vS377AqKTv6jUtgX8DVwNLk5/9ZeAoYHwIYc+aepMkSdKaPT7uU+587cPs+NRB3Rg6qFt6DalOQoxx4180hC2Bz4D5wG4xxs+rfLc/8CowI8bYI5nrAEwHOgJ7xxjHJ/OtkmP3Ak6IMY6ocp5uwPvACiA/xjgzmd8UGAfsAAyKMf6vSs0g4E3gQ2BAjPGLKucqANoCvSvPlXx3AvAoMBo4MMZYnMwPAN4AlgA7xBiXVan5GXAd8CRwXIyxIpk/EngWmAL0rZxfWyGEgry8vLyCgoJ1KZckSWqQRk9fwCn3jaUsedPWAb234O5T+vumrQ0oPz+fwsLCwhhj/jc5T1p3SrZPrj2maiABiDH+B1gGbF5lenAyHlEZSJJji4GrkuGPq11jGNASuL1qiEiCxnXJ8OxqNZXj31YGkqRmJpk7My2B06rVVF73qspAktSMAx5L+h5cOZ/cWam8zmVVg0eM8e/A68DOwH5IkiSpTqZ/vpyzHy7IBpI+XTtw6wl7GEgaiLRCyQdAKTAwhNC56hchhH2B9mQeZ6p0QPL5Yg3nGgUUAYOSx6LqUvNCtWPWqSa53qDk+q/X8To7ANsB02KMM75aUmtvkiRJqsHC5ZlX/y4tzrz6d4v2Lbnv1P60a+mrfxuKVP5NxRgXhRAuB24GpoQQngUWkvmF/Qgy6y3OqlKyU/I5rYZzlYUQZgC7AD2A9+pQMyeEsALYJoTQJsZYFEJoC2wNLI8xzqmh7Q+Sz15V5nYEcoGPYoxldaypta811NQohFDb81luUSpJkpqE4lXlnPlQAZ8sKgKgdfPMq3+7dmydcmdaG6nFxxjjH0MIM4H7gDOqfDUdGF7tsa6OyeeSWk5XOb/JWta0TY4r2oDXWB81kiRJqibGyGVPTqbg48xT9yHAn47vR99tOn5NpeqbNN++dRmZhd7DydwhaQvkAx8Bj4QQrl+b0yWfa7Nqf11qNsY16lwTY8yv6R8yC/wlSZIatVte/oB/TJqdHV/5vT58Z5ctU+xI6yqVUBJC+DbwB+AfMcaLY4wfxRiLYoyFZF6L+xlwSQihR1JSefegttjbodpxa1OztI7H13SHY0P2VdudFEmSpCbvyYJZ3PrKB9nxSXtux4/26Z5iR/om0rpTUrkR4X+qfxFjLALGkultj2R6avL5lXUWIYRmQHegjMxdFupQ05XMnZlZyfWIMa4gE4baJd9X1zP5rLoWZDpQDvRI+qhLTa19raFGkiRJiTc+WMAVT03OjvfttTnXHLELmZecqiFKK5RUviVr81q+r5wvTT5fTT4PqeHYfYE2wOgYY0mV+TXVHFrtmHWqSa43Orn+/9XxOh8CnwC9Qgg1xfnaepMkSWry3p+7lB9XefVv7y3b8+cT96BZbmqrErQepPVvr/L1uWeGELau+kUI4VBgb6CYzC/8kFl7sgA4PoTQv8qxrYBrk+Gd1a5xP1ACnJdsflhZsynw82R4V7WayvGVyXGVNd2Ac5Pz3V+tpvK61yb9VNYMAI4js0HkU5XzMbNbZeV1rg8h5FSpOZJMuJkC/BdJkiRlzV1SzGn3j2NZSealp1t2aMX9pw2gfavmKXembyqtt289SWYfkoOA90IIzwBzgT5kHu0KwBUxxoUAMcalIYQzkrrXQggjgEVkXh+8UzL/WNULxBhnhBB+CtwKjA8hPEbmzstgYBvgpqq7uSc1o0MINwMXA5NDCE8CLciEi07A+VU3YkyMAI5OzjshhDAS2CypyQXOiDEurVZzc/JzDgbGhBBeIbN3yTFk3gQ2bF13c5ckSWqMlhWv4rTh45izJLNXdbuWzbj/NF/921iktU9JRQjhe2TuPhxPZnF7GzJB43ng1hjjS9Vqng0h7AdcCfwQaEVmTcfFyfFfeVtVjPG25LXDlwKnkLkzNIXM7usP1NLbJSGEycB5wJlABVAI3BBjfK6G42MI4QQyd3WGAeeTucszCrg2xji6hpqSEMJBwBXAicBFZBbcPwv8MsY4pbY/O0mSpKZmVXkF5zxSyHtzMn/P2ywncOfJefTp2uFrKtVQhBp+l1cDF0IoyMvLyysoqG1vRUmSpIYhxsjlT03m8fGzsnM3DN6NY/pvm2JXqpSfn09hYWFhsi3FOnNFkCRJkuqt216d/qVA8pODehpIGiFDiSRJkuqlpwpmcfO/V++SMDh/Gy48sOcaKtRQGUokSZJU77w5fQGXV9mLZJ8dO3PdUX3di6SRMpRIkiSpXpk6dxlnP/TlvUjuODmPFs381bWx8t+sJEmS6o25S4o59f6xX9mLpIN7kTRqhhJJkiTVC8tLyr6yF8l9p7oXSVNgKJEkSVLqatqL5I6T8th5K/ciaQoMJZIkSUpVjJGrnnmHUdPmZ+euO7ov+/baPMWutDEZSiRJkpSqP778AY+N/zQ7vuDAnhzrXiRNiqFEkiRJqXl0zCf86ZUPsuOj87bmooPci6SpMZRIkiQpFS+9O5ernn07O9631+b84Ye7uRdJE2QokSRJ0kZX8PEizv/bBJKtSOi7dUfuPCmP5rn+etoU+W9dkiRJG9X0z5fzowfGU1JWAcD2m7XhvlMH0LZls5Q7U1oMJZIkSdpo5i0tZuh9Y1lctAqAzdq24MFhA9m8fcuUO1OaDCWSJEnaKJYWr2LofWP5bPFKANq0yOX+0waw/WZtU+5MaTOUSJIkaYMrKSvnzAfH8/7cZcDqzRF322aTlDtTfWAokSRJ0gZVURG5+PFJvPXRouzc73+4G9/eaYsUu1J9YiiRJEnSBhNj5Df/nMI/J8/Jzl12yE4Mzt8mxa5U3xhKJEmStMH8ddRH3P/mzOx46F7b8+P9dkivIdVLhhJJkiRtEM9MmMXvXng/O/5e3y25+vBd3BxRX2EokSRJ0nr3+gfz+ekTk7Pjgd07cfOx/cjNMZDoqwwlkiRJWq/enrWEsx8qoCzZrr1Xl3bcPaQ/rZrnptyZ6itDiSRJktabj+Yv59T7x7KitByArh1b8cCwgXRs0zzlzlSfGUokSZK0XsxdUsyQe8eycEUpAB1bN+eBYQPp2rF1yp2pvjOUSJIk6RtbXFTKKfeNye7W3rp5LvedOoBeXdqn3JkaAkOJJEmSvpGi0jKGDR/HtHnLgcxu7XeenEf+9pum3JkaCkOJJEmS1tmq8grOeaSQwk8WZ+duOnZ3d2vXWjGUSJIkaZ1UVEQufWISr02dn5371eE7c2S/rVPsSg2RoUSSJElrLcbIr5+bwt8nzs7OXXDAjpy6d/cUu1JDZSiRJEnSWvvzf6YzfPTM7PjEPbfjooN7pdeQGjRDiSRJktbKI2M+5saXpmXH3+u7Jb85cldCcLd2rRtDiSRJkurs+bfncNWz72TH++zYmVuO60dujoFE685QIkmSpDoZPX0BPxkxkRgz49226chdQ/Jp2Sw33cbU4BlKJEmS9LUmz1rMGQ+Op7S8AoAem7fl/lMH0K5ls5Q7U2NgKJEkSdIafTh/OafeP44VpeUAbNmhFQ/9aE82a9cy5c7UWBhKJEmSVKvPFq9kyD1jWLSiFICOrZvz0I8GsvUmrVPuTI2JoUSSJEk1mr+shJPvGcPsJcUAtG6ey/2nDaBnl/Ypd6bGxlAiSZKkr1hStIoh945hxoIVALTIzeHuU/qTt92mKXemxshQIkmSpC9ZUVLGacPH8v7cZQDk5gRuPWEP9unZOeXO1FgZSiRJkpRVUlbOWQ8VUPjJ4uzc9T/cjUN23TLFrtTYGUokSZIEQFl5BRf8bQJvTF+QnbvmiF34Yf42KXalpsBQIkmSJCoqIpc9NZl/vTsvO3fpd3oxdFC39JpSk2EokSRJauJijFwz8l2eLvwsO3fmvj04d/8dU+xKTYmhRJIkqYm7+d/TeOB/H2fHJwzclp8d2psQQopdqSkxlEiSJDVhfx31Ibe9Oj07Pmy3rlz7g74GEm1UhhJJkqQm6m9jP+G659/PjvffaXNuPrYfuTkGEm1chhJJkqQmaOSk2fz8mbez44HdO3Hnyfm0aOavh9r4/G+dJElSE/Pq+/O46LGJxJgZ77ZNR+4d2p9WzXPTbUxNlqFEkiSpCXlz+gLOfriQsopMIum5RTuGnzaQ9q2ap9yZmjJDiSRJUhMxdsYiTn9gPKVlFQBs26k1D/1oTzq1bZFyZ2rqDCWSJElNwMRPFzNs+DhWrioHoGvHVjx6+rfYsmOrlDuTDCWSJEmN3ruzl3DKvWNYXlIGwObtW/LoGd9i205tUu5MyjCUSJIkNWIfzFvGkHvHsrQ4E0g6tW3BI6fvSffObVPuTFrNUCJJktRIzViwghPvGcOiFaUAdGjVjAeHDaRXl/YpdyZ9maFEkiSpEfp0UREn3f0W85eVANCuZTMeGDaQXbfumHJn0lcZSiRJkhqZuUuKOemeMcxeUgxAq+Y53HfqAPbYbtOUO5NqZiiRJElqROYvK+HEe97ik0VFALRolsM9pwxgYPdOKXcm1c5QIkmS1Eh8saKUIfeO4aP5KwBolhO486Q89unZOeXOpDUzlEiSJDUCS1au4pT7xvL+3GUA5AS47YQ9OLBPl5Q7k76eoUSSJKmBW1FSxmn3j+Xtz5YAEALcdOzuHNq3a8qdSXVjKJEkSWrAikrLGDZ8HIWfLM7O/e6ovhy1xzYpdiWtHUOJJElSA7WytJwfDR/PmBmLsnO/Onxnjh+4XYpdSWvPUCJJktQAFa8q54wHx/O/jxZm5352aG9O3bt7il1J68ZQIkmS1MBUBpI3pi/Izl12yE6ctd8OKXYlrbvUQ0kI4f9CCE+FEOaEEEqSz5dCCN+r4dhBIYTnQwiLQghFIYTJIYSfhBBy13D+w0IIr4UQloQQlocQxoQQhn5NT0NDCGOT45ck9Yet4fjcpI/JIYSVSX/PhxAGraGmdQjhmhDC1BBCcQjh8xDC4yGEPmvqTZIkNW0lZeWc/XABr3+wOpBc+p1enPPtHVPsSvpmUg0lIYSrgFHAvsCLwE3ASGBT4NvVjj2yyrHPAH8GWgC3ACNqOf95yfl2BR4G7ga2AoaHEG6speZGYDjQNTn+YaAvMDI5X/XjQ3L9W5J+bk/62xcYlfRdvaYl8G/gamAp8CfgZeAoYHwIYc+aepMkSU1bSVk5P364kNemzs/OXXRQL847oGeKXUnfXIgxpnPhEI4BHifzy/jRMcZl1b5vHmNclfznDsB0oCOwd4xxfDLfCngV2As4IcY4okp9N+B9YAWQH2OcmcxvCowDdgAGxRj/V6VmEPAm8CEwIMb4RZVzFQBtgd6V50q+OwF4FBgNHBhjLE7mBwBvAEuAHar+fCGEnwHXAU8Cx8UYK5L5I4HXdpiWAAAgAElEQVRngSlA38r5tRVCKMjLy8srKChYl3JJklQPlZZVcM4jhbz83rzs3AUH7MjF39kpxa7U1OXn51NYWFgYY8z/JudJ5U5JCCEH+ANQBJxYPZAAVAaSxGBgc2BEZSBJjikGrkqGP652imFAS+D2qiEiCRrXJcOzq9VUjn9bGUiSmplk7sy0BE6rVlN53asqA0lSMw54LOl7cOV8cmel8jqXVQ0eMca/A68DOwP7IUmSBKwqr+D8v305kJy7/w5cdHCvFLuS1p+0Ht8aBHQHnge+CCF8P4RweQjhwhDCXjUcf0Dy+WIN340iE24GJY9F1aXmhWrHrFNNcr1ByfVfr+N1dgC2A6bFGGesRW+SJKkJWlVewQV/m8C/3l0dSM7ebwcu/c5OZP6uU2r4mqV03QHJ5zygkMyajawQwihgcIyx8oHJyvuS06qfKMZYFkKYAewC9ADeq0PNnBDCCmCbEEKbGGNRCKEtsDWwPMY4p4aeP0g+q/6VxI5ALvBRjLGsjjW19rWGmhqFEGp7Pqv319VKkqT6r6y8gp+MmMgL78zNzp25bw8uP8RAosYlrTslWySfZwOtgYOA9mQWpP+LzCLxJ6oc3zH5XFLL+SrnN1mHmo7VPjfENb5pjSRJamLKyiu46PFJ/PPt1X9XOmzv7vzs0N4GEjU6ad0pqXyFbyBzR2RSMn43hHAUmbsI+4UQ9qq6EH0NKv8vc21W7a9Lzca4Rp1raltQlNxByVuLa0qSpHqkvCJy6ROTGDlpdnbu1EHd+MVhfQwkapTSulNSuYj8oyqBBIAY40oyd0sABiaf1e9qVNeh2nFrU7O0jsfXdIdjQ/ZV250USZLUiJVXRH765CSenbg6kJyy1/b88vCdDSRqtNIKJVOTz8W1fF8ZWlpXO/4r6yxCCM3ILJovAz6q4Ro11XQl83rfWTHGIoAY4wrgM6Bd8n11lS8Ar7oWZDpQDvRI+qhLTa19raFGkiQ1AWXlFVzy+ESeLvwsO3fSnttxzRG7GEjUqKUVSkaRCRE9Qwgtavh+1+RzZvL5avJ5SA3H7gu0AUbHGEuqzK+p5tBqx6xTTXK90cn1/6+O1/kQ+AToFULovha9SZKkRqxyDUnVOyQnDNyW3xy5q4FEjV4qoSTGuIDMHh4dyexqnhVCOBj4LpnHlypfzfsksAA4PoTQv8qxrYBrk+Gd1S5zP1ACnJdsflhZsynw82R4V7WayvGVyXGVNd2Ac5Pz3V+tpvK61yb9VNYMAI4D5gNPVfnZY5XrXJ/s2VJZcySZcDMF+C+SJKlJWFVewYWPTfzSGpKT9tyO3/6gLzk5BhI1fmktdAe4GNiTTADYFxgLbA8cReaRqDNijIsBYoxLQwhnkAknr4UQRgCLgCPIvGL3STIhJyvGOCOE8FPgVmB8COExoJTMRobbADdVX0QfYxwdQrg56W1yCOFJoAWZcNEJOL/qRoyJEcDRyXknhBBGApslNbnJz7G0Ws3NwGFJzZgQwitk9i45hsyeJ8PWdTd3SZLUsFTuQ1L1tb9DvrU9vz7SR7bUdKQWSmKMn4cQ9iSzI/tRwLeAZcA/gd/FGN+qdvyzIYT9gCuBHwKtyKzpuBi4NbkDUf0at4UQZgKXAqeQuTM0hczu6w/U0tclIYTJwHnAmUAFmb1UbogxPlfD8TGEcAKZx7iGAecDxWQeUbs2xji6hpqSEMJBwBXAicBFZBbcPwv8MsY4pdY/OEmS1GiUllVw3qOFvDRl9caIpw7q5qJ2NTmhht/l1cCFEAry8vLyCgpq21tRkiSlraSsnHMfKeTl9z7Pzv1on+5c9X1f+6uGIz8/n8LCwsLatqqoqzQf35IkSWqSileVc84jhbz6/upAcua+PdwYUU2WoUSSJGkjKl5VzlkPFfDfafOzc2fvtwOXH7KTgURNlqFEkiRpIyleVc4ZD47n9Q8WZOfO239HLvlOLwOJmjRDiSRJ0kawsrSc0x8cx5vTF2bnLjiwJxcd1NNAoibPUCJJkrSBFZWW8aPh4/nfR6sDyUUH9eLCg3qm2JVUfxhKJEmSNqDlJWX8aPg4xsxYlJ279Du9OO8AA4lUyVAiSZK0gSxZuYpT7x/LhE8WZ+cuO2Qnzvn2jil2JdU/hhJJkqQNYNGKUobcO4Z3Zy/Nzv3s0N6ctd8OKXYl1U+GEkmSpPXs82XFnHzPGKbNW56du+aIXRg6qFt6TUn1mKFEkiRpPZq9eCUn3TOGGQtWABAC/P7ovhw3YLuUO5PqL0OJJEnSevLJwiJOvOctZn2xEoDcnMDNx+7Okf22TrkzqX4zlEiSJK0HH85fzkl3j2Hu0mIAmucGbjthDw7ZtWvKnUn1n6FEkiTpG3p/7lJOvmcMC5aXAtCiWQ5/OTmf/XtvkXJnUsNgKJEkSfoG3p61hCH3jWFx0SoAWjfP5Z6h/dl7x84pdyY1HIYSSZKkdVTw8SJOvW8cy0rKAGjXshnDTxtA/26dUu5MalgMJZIkSetg9IcLOP2B8RSVlgPQsXVzHhw2kN233STlzqSGx1AiSZK0ll6b+jlnPVRASVkFAJu1bcHDp+9Jn64dUu5MapgMJZIkSWvhxXfmcMHfJlJangkkXTq05JHTv8WOW7RLuTOp4TKUSJIk1dET4z/l8qcmUxEz4603ac2jZ+zJ9pu1TbcxqYEzlEiSJNXBvW/M4DfPTcmOe3Ruy0On78nWm7ROsSupcTCUSJIkrUGMkVte/oBbX/kgO7dz1w48+KOBdG7XMsXOpMbDUCJJklSLiorIr5+bwvDRM7Nz/bfflHtPHUDH1s3Ta0xqZAwlkiRJNSgrr+CypybzdOFn2bn9em3OXSfn07pFboqdSY2PoUSSJKma4lXlXPC3Cbw0ZV527vt9u3LLcf1o0Swnxc6kxslQIkmSVMWKkjLOfGg8b05fmJ07fsC2/PaovuTmhBQ7kxovQ4kkSVJicVEpp94/jomfLs7OnbVvD644tDchGEikDcVQIkmSBHy+tJgh945l6rxl2bmffncnzvn2DgYSaQMzlEiSpCbv00VFnHTPGD5ZVJSd+82RuzBkr27pNSU1IYYSSZLUpE2bt4wh945h3tISAHJzAjcdszs/2GPrlDuTmg5DiSRJarIKPl7EsOHjWbJyFQAtmuVwx4l5HLRzl5Q7k5oWQ4kkSWqSXnlvHuc+WkjxqgoA2rbI5Z6hA9hrh81S7kxqegwlkiSpyXli/Kdc8fTblFdEADq3a8Hw0way69YdU+5MapoMJZIkqcmIMfKXUR/x+xfez85t26k1Dw3bk26d26bYmdS0GUokSVKTUFERue7597jnjRnZuT5dO/DAaQPYokOrFDuTZCiRJEmN3qryCi57cjLPTPgsO7dn907cPbQ/HVo1T7EzSWAokSRJjVxRaRk/friQ/06bn507ZJct+ePx/WjVPDfFziRVMpRIkqRG64sVpZw2fBwTP12cnTth4HZc+4Ndyc1xl3apvjCUSJKkRumzxSs55d4xfDh/RXbuggN25KKDexGCgUSqTwwlkiSp0Zk2bxlD7xvLnCXFAIQAvzp8F4YO6pZuY5JqZCiRJEmNyriZizj9gdW7tDfPDdxyXD8O222rlDuTVBtDiSRJajReeHsOFz42kdKy1bu0/2VIf/bp2TnlziStiaFEkiQ1Cve9MYPf/HMKMbNJO53bteD+UwfSdxt3aZfqO0OJJElq0GraFLFH57YMP20g223WJsXOJNWVoUSSJDVYJWXlXPL4JJ6bPCc7l7fdJtwzdACd2rZIsTNJa8NQIkmSGqQlRas486HxjJmxKDv3nZ27cOsJe7gpotTAGEokSVKD89nilZx631g++Hx5du6Uvbbnl4fv4qaIUgNkKJEkSQ3KlNlLOW34WOYtLcnOXXFob87at4ebIkoNlKFEkiQ1GG9OX8BZDxWwvKQMyOxBcuMxu3Nkv61T7kzSN2EokSRJDcIzE2bx0ycmU1aReedv+5bN+MuQfAbt6B4kUkNnKJEkSfVajJE7XvuQG/41NTu3ZYdWDB82gN5bdkixM0nri6FEkiTVW6vKK7jymbd5fPys7FyvLu0YftpAttqkdYqdSVqfDCWSJKleWrJyFec8UsCb0xdm577VoxN/GdKfjq2bp9iZpPXNUCJJkuqdTxcVcdrwcUyv8srfwfnbcN1RfWnRLCfFziRtCIYSSZJUr0z45AvOeHA8C5aXZucuObgX5x2wo6/8lRopQ4kkSao3Xnh7Dj95bCIlZRUAtMjN4YZjdvOVv1IjZyiRJEmpizHy11Ef8fsX3ydm3vjLJm2ac/cp/RnQrVO6zUna4AwlkiQpVWXlFVz9j3d5dMwn2blum7Xh/tMG0r1z2xQ7k7SxGEokSVJqlhWv4txHJzBq2vzs3IBum/LXIf3ZtG2LFDuTtDEZSiRJUipmL17JsOHjeH/usuzckf224vrBu9GyWW6KnUna2AwlkiRpo5v06WLOeHA8ny8ryc5dcGBPLjqop2/YkpogQ4kkSdqoRk6azaVPTMq+Yat5buB3R+/G4PxtUu5MUloMJZIkaaOIMfLHlz/gT698kJ3r2Lo5d56cx6AdOqfYmaS0GUokSdIGt7K0nEufnMQ/J8/JzvXo3JZ7Tx3gG7YkGUokSdKGNW9pMWc8OJ7Js5Zk5/bZsTN/PjGPjm2ap9iZpPoiJ+0GKoUQhoQQYvLP6bUcc1gI4bUQwpIQwvIQwpgQwtCvOe/QEMLY5PglSf1hazg+N4TwkxDC5BDCyhDCohDC8yGEQWuoaR1CuCaEMDWEUBxC+DyE8HgIoc8aajqFEP4YQpgZQigJIcwOIdwXQvCBWklSo/H2rCUccfsbXwokp+y1PcNPG2AgkZRVL0JJCGFb4DZg+RqOOQ8YCewKPAzcDWwFDA8h3FhLzY3AcKBrcvzDQF9gZHK+6scHYARwC9ACuB14BtgXGBVCOLKGmpbAv4GrgaXAn4CXgaOA8SGEPWuo2Qz4H3Ah8GFyvbHAaUBBCKFHbX8OkiQ1FM+/PYdj/jKaeUszb9jKzQn85shd+PWRu9Ist178CiKpnkj98a0kCNwPLASeBi6t4ZhuwI3AIqB/jHFmMv9rYBxwSQjhqRjj/6rUDAIuIfNL/4AY4xfJ/A1AAXBjCOG5ynMljgcGA6OBA2OMxUnNXcAbwN0hhFdjjMuq1FwM7A08CRwXY6xIah4DngXuCyH0rZxPXAf0Am6JMV5cpecLyISaO4BD6vLnJ0lSfRNj5PZXp3PTv6dl5zq0asYdJ+WzT08XtEv6qvrw1xQXAAeQuUuwopZjhgEtgdurhogkaFyXDM+uVlM5/m1lIElqZgJ/Ts53WrWaHyefV1UGkqRmHPAYsDmZ0AJkA1XldS6rGjxijH8HXgd2BvarUtMWGJL8rL+sdv3bgZnAd71bIklqiIpXlXPhiIlfCiTdO7flmXP3NpBIqlWqoSRZc/F74E8xxlFrOPSA5PPFGr57odox61STPIY1CCgiEybqcp0dgO2AaTHGGXWs2QtoDbxZ7Y4LSah5KRnuX8P5JEmqtz5fWsxxf32Lf0yanZ0btMNmPHPOIHbYvF2KnUmq71J7fCuE0Ax4CPgE+PnXHL5T8jmt+hcxxjkhhBXANiGENjHGouRuxNbA8hjjnOo1QOUL0ntVmdsRyAU+ijGW1bGm1r7Wc02NQggFtXzV++tqJUlanyZ9upizHipg7tLsgwactOd2/OqIXWju+hFJXyPNNSVXA3sA+8QYV37NsR2TzyW1fL8EaJscV1TH4wE2WctrpFUjSVK99XThLK54+m1Kkx3acwL88vBdOGWv7ck86SxJa5ZKKAkhDCRzd+SmqovTv8kpk8+4lnVrc/y6XGOD1sQY82s8QeYOSt5aXFOSpLVWVl7B7194n3veWP0Ec4dWzbj9xDz27bV5ip1Jamg2eiip8tjWNOAXdSxbAnQmc5dhYQ3fd0g+l1Y5HlbflaiuprsVX1fTodpxG7NGkqR6ZXFRKef/bQKvf7AgO9dzi3bcfUp/urlDu6S1lMZDnu3IrJfoAxRX2TAxsvptVHcnc39MxlOTz6+sswghdCXz6NasGGMRQIxxBfAZ0C75vrqeyWfVdR3TgXKgRxKc6lJTa1/ruUaSpHpj6txlHHH7m18KJAfv3IVnzt3bQCJpnaTx+FYJcG8t3+WRWWfyBplf3isf7XqVzF4gh1SZq3RolWOqepXMq3cPIbMPyhprYowlIYTRwP8l//ynDtf5kMxC/V4hhO41vIGrppq3gJXA3iGE9lXfwBVCyAG+kwyrX1+SpNS9+M5cLn58IkWl5dm5Cw7syU8O7ElOjutHJK2bjX6nJMa4MsZ4ek3/AP9IDnsgmXssGd9PJsycl2ykCEAIYVNWv7nrrmqXqhxfmRxXWdMNODc5X/WwcmfyeW0IoVWVmgHAccB84KkqP0uscp3rk1BRWXMkmXAzBfhvlZrlZB5fawv8qtr1zwO6Af+KMX6EJEn1REVF5I8vT+PshwuygaRNi1zuOjmPiw/uZSCR9I2kvqN7XcQYZ4QQfgrcCoxPdksvJbOR4TbUsGA+xjg6hHAzmR3XJ4cQngRakAkXnYDzq+3mDjACODo574QQwkhgs6QmFzgjxri0Ws3NwGFJzZgQwitk9i45hsybwIZV280dMkHq28DFIYR+wFgyj7MdCXxOJjRJklQvLC8p4+LHJvLSlHnZuW07tebuU/rTe8sOa6iUpLppEKEEIMZ4WwhhJnApcAqZuzxTyOy+/kAtNZeEECaTuQNxJlABFAI3xBifq+H4GEI4ARhNZhf584FiYBRwbYxxdA01JSGEg4ArgBOBi8gsuH8W+GWMcUoNNQtDCHuRWUPzAzJ3VBaSuXNzdYxxVp3/YCRJ2oA+XriCMx4cz7R5y7Nze++4GbefkMembVuk2JmkxiRknkBSYxJCKMjLy8srKKhtb0VJkr7ef6fN54K/TWDJylXZuWF7d+fn3+tNMzdElATk5+dTWFhYWNtWFXXVYO6USJKkjaOiInLHa9O56d/TqPy7yxbNcrjuqL4Mzt8m3eYkNUqGEkmSlLW0eBUXPzaJl99bvX6kS4eW3HVyPntst+kaKiVp3RlKJEkSkNl/5OyHC5ixYEV2bs/unbj9xDw2b98yxc4kNXaGEkmSxMhJs7nsycmsXLV6/5HT9+nO5Yf2prnrRyRtYIYSSZKasFXlFfz+hfe5943V+/+2bp7L9YN34/Ddt0qxM0lNiaFEkqQmav6yEs57tJAxMxZl57p3bstdJ+ez05btU+xMUlNjKJEkqQkq/OQLfvxwAfOWlmTnDurThZuP250OrZqn2JmkpshQIklSExJj5OExn/Drke+yqjzzvt8Q4JKDe3HOt3ckJyek3KGkpshQIklSE7GytJyrnn2HpwpnZec6tm7OrSfswX69Nk+xM0lNnaFEkqQm4MP5yznn4UKmzluWndu5awf+MiSfbTu1SbEzSTKUSJLU6I2cNJsrnprMitLVr/v9Yd42/PaoXWnVPDfFziQpw1AiSVIjVVJWzm//+R4P/u/j7FyLZjn8+ohdOG7AtoTg+hFJ9YOhRJKkRujTRUWc92ghk2Ytyc5tv1kb7jgpj1226phiZ5L0VYYSSZIamVfem8fFj09iycpV2blDdtmS64/Zzdf9SqqXDCWSJDUSZeUV3PDSVP7y34+yc81yAj/7Xh+G7d3Nx7Uk1VuGEkmSGoF5S4s5/9EJjJ25enf2rh1bcfuJeeRvv2mKnUnS1zOUSJLUwI2evoALRkxgwfLS7Nx+vTbnluP60altixQ7k6S6MZRIktRAlVdEbnv1A2595QMqMpuzkxPgYndnl9TAGEokSWqA5i4p5sIRExgzY/XjWp3bteDW4/dg0I6dU+xMktaeoUSSpAbm1ffncekTk1m0YvXjWnt278StJ+xBlw6tUuxMktaNoUSSpAaitKyC6198n3vemJGdywlw/gE9ueDAnuT6uJakBspQIklSA/DxwhWc/7cJTK6yGWKXDi3543F7sNcOm6XYmSR9c4YSSZLquZGTZvOzp99meUlZdu6A3ltw4zG7+3YtSY2CoUSSpHpqZWk514x8lxHjPs3ONc8NXH5Ib360T3c3Q5TUaBhKJEmqh6bOXcZ5jxbywefLs3PbdWrDbSfswe7bbpJiZ5K0/hlKJEmqR2KMjBj3Kb/6x7uUlFVk5w/ffSuuO2pX2rdqnmJ3krRhGEokSaonvlhRyhVPT+Zf787LzrVqnsM1R+zCsf239XEtSY2WoUSSpHrgzekLuPjxicxbWpKd69WlHbefmEevLu1T7EySNjxDiSRJKSopK+eml6bx11EffWl+yLe25+ff60PrFrkpdSZJG4+hRJKklEz/fBkXjpjIu7OXZuc2a9uC6wfvxoF9uqTYmSRtXIYSSZI2shgjj4z5hGv/OYXiVasXs+/Xa3NuOGY3tmjfKsXuJGnjM5RIkrQRLVxewuVPvc3L761ezN6iWQ4/O7Q3Q/fqRk6Oi9klNT2GEkmSNpJR0+ZzyROTmL9s9WL2nbq0508n9KP3lh1S7EyS0mUokSRpAyteVc71L07lvjdnfGn+1EHduOLQ3rRq7mJ2SU2boUSSpA3o3dlLuPixSUydtyw717ldS244Zjf232mLFDuTpPrDUCJJ0gZQVl7BX0Z9xB9fnsaq8pidP7D3Fvxh8G50btcyxe4kqX4xlEiStJ7NWLCCix+fyIRPFmfnWjXP4crv9eHkb23vzuySVI2hRJKk9STGyMNvfcx1z7/PylXl2fk9ttuEm4/tR/fObVPsTpLqL0OJJEnrwZwlK7nsycm8/sGC7FyznMBFB/firH170Cw3J8XuJKl+M5RIkvQNxBj5x6TZ/OLZd1haXJad79WlHTcf249dt+6YYneS1DAYSiRJWkdfrCjlqmff4Z9vz8nOhQBn/l8PLjq4l6/6laQ6MpRIkrQOXnlvHlc8/faXNkLctlNrbjqmHwO7d0qxM0lqeAwlkiSthcVFpfx65BSenvDZl+ZPGLgtV35/Z9q19P+1StLa8n85JUmqo39PmcfPn/ny3ZHO7Vryhx/25cA+XVLsTJIaNkOJJElfY3FRKb/6x7s8O3H2l+aP7LcVvzp8FzZt2yKlziSpcTCUSJK0Bi+9O5efP/MOC5Z/+e7Ib4/ale/usmWKnUlS42EokSSpBl+sKOVXI9/l79Xujhy1x9b88vCd2aSNd0ckaX0xlEiSVM2L78zlqme/fHdk8/Ytue6ovhy8s2tHJGl9M5RIkpRYtKKUX/7jXUZO+vLdkaPztubqw7w7IkkbiqFEktTkxRj5+8TZ/Pq5KSxaUZqd36J9S353tG/WkqQNzVAiSWrSZn1RxJXPvMN/p83/0vzg/G34xfd3pmOb5il1JklNh6FEktQklVdEHhg9kxtfmkpRaXl2fquOrfjtUX3Zv/cWKXYnSU2LoUSS1ORMnbuMy5+azMRPF2fnQoChe3Xj0u/u5K7skrSR+b+6kqQmo6SsnD+/Op07XvuQsoqYne+5RTt+/8PdyN9+0xS7k6Smy1AiSWoSxs1cxBVPTebD+Suycy1yczh3/x358bd3oEWznBS7k6SmzVAiSWrUlhav4voX3+fhtz750nz+9pvy+6P70rNL+5Q6kyRVMpRIkhqlGCPPTZ7Dr5+bwvxlqzdBbNsilysO7c1Je/5/e3ce51dd33v89ZlJMpNtspJ9h0ACEYUASrjsFqGGqhTr0kupVlpbURG92mtdWq+1VtG6QOtDvZXr1V6oKFARRJSwSFgTIATIRjJk35NJMslMMjPf+8c5A7+ZzGTPnFlez8fjPM78zjnf3/nO7zu/M7/375zz/U6krCwKrKEkqZmhRJLU7by6pZbP3/0ij7Tq5vfSaSP4X++cwZjBfQuqmSSpLYYSSVK3Ud/QyPcfXs7Nc5ZR39D02vIRAyv4wpWn8vY3jCbCsyOS1NkYSiRJ3cLcVzbzubsWsrzkRvbmbn5vvOxkqiodBFGSOitDiSSpS9u8q56v/OplfvHsmhbLZ4yt4ivvegOnjxtcUM0kSYfKUCJJ6pKamhK3P7OKr963iJo9+15bPqCiF5+67GSuOXcS5d7ILkldgqFEktTlvLi2hi/c/SLzXt3WYvnbTx/NF2afysiqyoJqJkk6EoYSSVKXUbN7H994YDE/eeJVSgZkZ8LQfnzpHadx0SkjiqucJOmIFTJ8bUQMi4gPRcSdEbEsIvZERE1E/D4i/iIi2qxXRMyKiHsjYmtE7I6IBRFxQ0SUH2BfsyPiofz5d0XEkxFx7UHqd21EPJVvX5OXn32A7cvzeizIf5eteT1nHaBM34j4h4hYHBF1EbExIv4zIqYfqG6S1BM1NSVue2olF3/jIX78+OuBpHd5cP3FJ/GbT1xgIJGkLqyoMyXvBv4NWAfMAVYCI4GrgB8CV0TEu1NKr30PFhHvAH4O1AG3A1uBK4F/Ac7Ln7OFiLge+C6wBfgJsBe4Grg1It6QUvpUG2VuAj4JrAZ+APQB3gv8MiI+mlK6udX2AdyWP+9i4GZgKPAe4JGI+OOU0t2tylQAD+T1fgb4NjA+/x3eHhGXpJSePPjLKEnd33OrtvPFuxfy/OqaFsvPnzqcL155GieNGFBQzSRJx0qUfO7vuJ1GXAL0B36VUmoqWT4KeIrsA/rVKaWf58urgGXAIOC8lNIz+fJK4EHgXOB9KaXbSp5rErAIqAVmppSq8+VDgKeBE4FZKaXHS8rMAh4DXgHOTiltK3mueXmdpzU/V77ufcB/AHOBS1NKdfnys4HfAzXAiSmlnSVl/ifwFeAO4D3Nr0EevO4CXgLeUPraHI6ImHfmmWeeOW/evCMpLkmdwpZd9Xzt14u5/ZlVLZaPHdyXz88+lbedNtIxRySpYDNnzmT+/PnzU0ozj+Z5Crl8K6X0YErpl60/dKeU1gPfyx9eVLLqauAE4LbmQHfdvjYAAB2HSURBVJJvXwd8Ln/4161280GgAri5NETkQeMr+cMPtyrT/PgfmwNJXqYauCV/vg+0KtO83881B5K8zNNkZ3ROyOsPvHZmpXk/ny59DfIzKo8CpwIXIkk9UENjEz9+vJqLb3qoRSDp06uMj11yEr+98UIunzHKQCJJ3UghoeQgmvt1bChZdkk+/3Ub2z8C7AZm5ZdFHUqZ+1ptc0Rl8v3Nyvf/6CHu50RgArAkpbTiMOomSd3e09VbufLmx/jC3S+yo+71fwNvnT6S337iQm687BT69mn3NkJJUhfVqXrfiohewJ/lD0uDwSn5fEnrMimlhohYAZwGTAFePoQy6yKiFhgXEf1SSrsjoj8wFtiVUlrXRvWW5vOTS5adBJQDy1NKDfsXabNMu/U6QBlJ6tbWbN/DP9+3iP96fm2L5ZOG9eOLV57GxdO8iV2SurNOFUqArwIzgHtTSveXLB+Uz2v2L9JieemwvYdSpn++3e7juI9jUaZNEdHeTSPTDlZWkjqD2voGvvfwK3z/keXUN7x+RW/f3uVcf8lJfOj8yVT08syIJHV3nSaURMTHyHq9WgRcc7jF8/nh3LV/JGU6Yh9HWi9J6jKamhJ3PruGr92/iA076luse/vpo/nsH05n7OC+BdVOktTROkUoiYiPkHWL+xJZD1ZbW23SfPZgEG2rarVd88/D8zJbDlBmxyHuo60zHEdar8Mt06b2ejnIz6CcebDyklSEZ6q38qV7XmJBqy5+3zB2EJ+ffSrnTB5aUM0kSUUpPJRExA1kY40sJAskG9vYbDFwFtl9Fi0uWcrvQ5lMdmP88lZlhudlHm9VZjTZpVurU0q7AVJKtRGxBhgbEaPbuK9kaj4vvRdkGdAITImIXm3cV9JWmcX5vL17RtoqI0ld3uptu/nqfYu4Z0HLw+uIgRV8+vJpXHXGWMrK7FFLknqiQnvfiojPkAWS54CL2wkkkI1FAnB5G+suAPoBc1NKpdcAHKjMFa22OaIy+f7m5vs//xD38wrZYJEnR8Tkw6ibJHVJtfUN3HT/Yi79xsMtAkmfXmVcf/FJzPnURVw9c5yBRJJ6sMJCSUR8nuzG9nlkZ0g2H2DzO4DNwHsj4qyS56gEvpw//LdWZX4E1APX54MfNpcZAnw2f/i9VmWaH/9dvl1zmUnAR/Ln+1GrMs37/XJen+YyZ5ON6r6JbCR6APJR6pv387WIKCsp8w6ycPMS8DCS1IU1NiVuf3olF9/0EDfPWdbiRvbZp4/mwU9eyKfedgr9Kwo/aS9JKlgh/wki4lrgS2SXPj0KfKyNQbCqU0q3AqSUdkTEdWTh5KGIuA3YCvwRWRe7d5ANVPialNKKiPgfwHeAZyLidmAv2UCG44BvlI7mnpeZGxHfBG4EFkTEHUAfsnAxFPho6UCMuduAq/LnfTYifgkMy8uUA9ellHa0KvNNYHZe5smI+B3Z2CXvJusJ7INHOpq7JBUtpcScxRv56n2LWLJhV4t1p48bxBdmn8pZk7xvRJL0uqK+nmq+bKkcuKGdbR4Gbm1+kFK6KyIuBP4O+GOgkuyejhuB7+RnIFpIKX03IqqBT5GNf1JGdhbicyml/9PWTlNKn4yIBcD1wF8CTcB84OsppXva2D5FxPvILuP6IPBRoI5sUMcvp5TmtlGmPiLeCvwt8H7gE2Q33N8FfDGl9FI7r4kkdWoLVm/nK/e+zBPLW/ZXMmJgBZ+5fBrv8r4RSVIboo3P8uriImLemWeeeea8ee0NYyJJx9aqrbv5+v2L9xv8sH+fcj584Yn8xfmT6dfHy7QkqbuZOXMm8+fPn99er7CHyv8QkqQjtq12LzfPWcaPH69mX+PrX3L1Kgve/+YJfOzSqQwfUFFcBSVJXYKhRJJ02Or2NXLr3GpumbOMnXUte0O//LRRfPryU5hywoCCaidJ6moMJZKkQ9bQ2MQvnl3Dtx5YwtqauhbrZk4cwmf/cBozJ3oTuyTp8BhKJEkH1dSUuG/her7xwGKWb6ptsW7y8P585vJpvO20kbTRk6IkSQdlKJEktSulxENLNnHT/Yt5cW3L3s2H9e/DDW+dynvPmUDv8kLH4pUkdXGGEklSm55asZWv37+Ip6u3tVg+sKIXf3nBFD7w3yYzwIEPJUnHgP9NJEktLFxTw02/WcxDize1WF7Zu4w/nzWZD184hcH9+hRUO0lSd2QokSQBsGzjLv7lgSX86oV1LZb3Lg/ed84Err/4JEZUVRZUO0lSd2YokaQebvmmXdz84DLuem4NTSXj6ZYFvOuMcdzw1qmMH9qvuApKkro9Q4kk9VDthRGAK2aM4sY/OJmpIwcWUzlJUo9iKJGkHmbF5lq+++BS7np2/zBywckn8KnLTub0cYOLqZwkqUcylEhSD3GwMPLxS6cyc+KQYionSerRDCWS1M0ZRiRJnZ2hRJK6qWUbd/GvDy1rM4ycP3U4N7x1KjMnDi2mcpIklTCUSFI3s3BNDf/60DLuW7ieZBiRJHUBhhJJ6iaeWrGVW+Ys4+Elm/Zbd/7U4Xz80qmcNckwIknqfAwlktSFpZR4eMkmbpmzjKert+23/tJpI/ibi0/0zIgkqVMzlEhSF9TUlPj1i+u5Zc4yXly7o8W6CHj7G0bzNxedxKljqgqqoSRJh85QIkldyN6GJu5+bg3fe/gVXtlU22Jd7/LgqjPG8VcXTmHKCQMKqqEkSYfPUCJJXUDNnn38v6dW8qPHVrBhR32LdZW9y3jfORO47vwpjBnct6AaSpJ05AwlktSJrd62mx89Vs1tT62kdm9ji3UDK3rxZ7Mm8oHzJjN8QEVBNZQk6egZSiSpE1q4pobvP7KcX72wjsZWg4ycMLCCP581iWvOnUhVZe+CaihJ0rFjKJGkTiKlxENLNvGDR5Yz95Ut+62fOmIA110whXe8aQwVvcoLqKEkSceHoUSSCla3r5H/em4tP3h0OUs37tpv/awTh3HdBVO46OQTiIgCaihJ0vFlKJGkgqyvqeMnT7zKfzy1kq21e1usKy8LZp8+muvOn8KMsYMKqqEkSR3DUCJJHSilxPyV27l1bjX3vbCOhlb3i/TvU857z5nAB//bZMbak5YkqYcwlEhSB6hvaOTeF9bxo8eqWbC6Zr/1Ywf35ZpzJ/K+cyYwqK83r0uSehZDiSQdRxt31vHTJ1by0ydXsnlX/X7rz5k8lA+eN4m3Th9Jr/KyAmooSVLxDCWSdIyllHhqxVZ++uRK7lu4jn2NLS/R6tOrjHe+aQzXzprEaWO8X0SSJEOJJB0jO+r2cef8Nfz0yVdZsmH/XrRGVVVyzbkTee/Z4xnmYIeSJL3GUCJJR2nhmhp+8sSr3P3cWvbsa9xv/ZkTBvOB8yZz+YxR9PYSLUmS9mMokaQjsGdvI79csJafPrmS51dt3299vz7lvPOMsfzpmyd4iZYkSQdhKJGkw7Bo/Q5uf3oVP5+3mh11DfutnzZqIH/6lom8801jGFhpL1qSJB0KQ4kkHcSOun388vm1/OfTq3i+je58+5SX8fbTR/Onb57AzIlDHHVdkqTDZCiRpDY096B1+zOruPeFddTta9pvm4nD+vH+cybw7rPGM7R/nwJqKUlS92AokaQSG3fUccf81fzsmdWs2Fy73/o+5WW8bcYo3nPWeGadOIyyMs+KSJJ0tAwlknq8un2NPLhoI7+Yv5o5izfR2JT222b66Crec9Y43nnGWAb386yIJEnHkqFEUo+UUuLp6m3c+exq7lmwjp1t3LQ+sKIXf/SmMbz37AnMGFvlvSKSJB0nhhJJPcqKzbXcOX81dz63hlVb97S5zZsnD+U9Z4/nihmj6dunvINrKElSz2MokdTtbavdyz0L1vKLZ9fw7Mr9xxQBmDC0H+86YyzvOmMsk4b37+AaSpLUsxlKJHVLu+ob+O1LG7hnwVoeXrKJfY373ydSVdmL2W8cw1VnjLUrX0mSCmQokdRtNN+wfs+Ctfzu5Y3UN+zfjW/v8uCiU0Zw1RljuXjaCCp7e3mWJElFM5RI6tL2NjTx6NJN/PL5tTzw0gZq9za2ud2bxg/mqjPHMvv0MY4pIklSJ2MokdTl7G1o4vHlW/jVgrX8euF6drTRcxbAtFEDufKNY5h9+mgmDvM+EUmSOitDiaQuYc/eRh5Zuon7F67nty9vaDeITBnen9lvHMOVp49m6siBHVxLSZJ0JAwlkjqtHXX7mLNoI79euJ6HFm9iz762L80aN6Qvs08fw5VvHM2pox1PRJKkrsZQIqlT2bKrngde2sCvX1zPY8s2t9lrFsDYwX25fMYoZp8+mjeNH2wQkSSpCzOUSCpUSoklG3bx25c38OCijcxfuY3Udg7hpBEDuPy0UVw+YxSnjfGMiCRJ3YWhRFKHq29o5InlW3nw5Q38btFGVm9re2R1gBljq7hixmjedtpIThrhPSKSJHVHhhJJHWLjzjoeWrSJ3y3awKNLN7O7na57ywLOnDCEy2eM4m2njWL80H4dXFNJktTRDCWSjou9DU3MX7mNR5Zs4tGlm3lhTU272w6s6MUFp5zApdNGcNEpIxxHRJKkHsZQIumYqd5cyyNLN/HIkk08/sqWdgcyBJg0rB+XTh/JpdNGcNakofTpVdaBNZUkSZ2JoUTSEdtZt4+5r2zh0aWbeGTJZlZu3d3utuVlwVkTh3Dp9BFcOn0kU4b390Z1SZIEGEokHYbdext4unobj7+yhceXb2Hhmhoam9rpKots/JALTj6BC6aewKyThlFV2bsDaytJkroKQ4mkdtXta2Teq6+HkOdXbafhACGkX59yzp0yLAsiJ5/ApGH9PBsiSZIOylAi6TW19Q08u3I7T1dv5fHlW3hu5Xb2Nja1u30EnDamivOnZmdDZk4c4r0hkiTpsBlKpB5sfU0dz7y6lWeqt/HMq1t5ed3OA16OBTBt1EDeMmUY5544jDdPHsrgfvaUJUmSjo6hROohGpsSSzbs5JlXtzGveitPV29jzfb2By1sdtKIAZxbEkKGDajogNpKkqSexFAidUMpJdbW1PH8qu3ZtHo7L6yuOWAXvZBdjnXKyIGcNWkI50wexlumDGXEwMoOqrUkSeqpDCVSN7B9916eX13DgjyAPLeqhs276g9arrJ3GWeMH8JZk4Ywc+IQzpw4xB6yJElShzOUSF1ISon1O+p4ae2ObFq3gxfX7jjg+CClRgysYObELICcPWkop46pone5N6ZLkqRiGUqkTmpfYxPLN9Xy0rqa1wLIS2t3sG33vkMqP6CiF6ePG8Qbxw/mjeMG88bxgxhVVWkXvZIkqdMxlEgFa2hsonrLbpZt3MmSDbtYunEXSzfsZPmm2gN2x1uqd3lw6uiqFgFkyvABlJUZQCRJUudnKJE6SN2+Rl7dspvlm3bl4WMnSzfsYsXmQw8fAAMrejF9TBWnjq7i1Hw+deQAKnqVH8faS5IkHT+GEukYqtvXyMqtu1mxuZbqzbVUb9mdz2tZV1N32M83ZlDla8Hj1DFVnDZmEOOG9PUSLEmS1K0YSgoUEeOALwGXA8OAdcBdwD+klLYVWTe1bW9DE+tq9rBm2x5Wb8/n2/awZvtuVm7ZzboddaQDjz3YplFVlUwdOYCpIwZy8sgBTB05gJNGDGRQX3vCkiRJ3Z+hpCARcSIwFxgB3A0sAs4BPg5cHhHnpZS2FFjFHqduXyObdtazcWcdG3bUs3FHHRt21rNm2x7WbN/D6m272biz/ohCB0B5WTBuSF8mDuvP1BEDODkPHlNHDrAbXkmS1KMZSorzr2SB5GMppe82L4yIbwKfAP4R+HBBdesWUkrsrG9gW+1ettbuZdvuvWyr3ce23XvZvGsvG3fWsXHH6yGkZs+h9Wp1IGUBY4f0ZdKw/kwe3p+Jw/ozeXg/Jg3rz7gh/ejTy+53JUmSWjOUFCAipgCXAdXALa1WfxH4S+CaiPhkSqm2g6tXuJQSexubqNvXRH1DI3V7m9hV35BP+9hZl/28s66BXaU/1+9j++4sdGyt3cf23XtpaDrC0xrtiICRAysZO6QvYwf3ZdyQviU/92P80L7ecC5JknSYDCXFuCSf/yal1KLbpZTSzoh4jCy0vAX4XUdX7kj98NHlzF+5jcamRGMTNKVEU0o0NpXOoakp0ZgSDY0pCx3N4SOf1zc0HfElUkejvCwYMbAim6oq858rGTM4CyHjBvdj1KBKz3ZIkiQdY4aSYpySz5e0s34pWSg5mQOEkoiY186qaUdetSM379Vt3LdwfRG7ble/PuUM6deHof37MKR/H4b2653P+zCi6vXwMbKqkqH9+jiuhyRJUgEMJcUYlM9r2lnfvHxwB9TlmDmWH+h7lwcVvcqp7F1GRa9yBlT0YkBlr9fmAyt6MbCyFwMqer/2eEBlL6oqezO0fxZCBvfrTWVvL6WSJEnq7AwlnVPzp/sDXsSUUprZZuHsDMqZx7pSB/PB8yZxxYxRlEdQVhb5HMoiKH/tceSPobysjMreZVT2KqciDx/NIaTcMxaSJEk9hqGkGM1nQga1s76q1XZdwsyJQ4uugiRJkrog79gtxuJ8fnI766fm8/buOZEkSZK6DUNJMebk88siokUbRMRA4DxgD/BER1dMkiRJ6miGkgKklF4BfgNMAj7SavU/AP2BH/fEMUokSZLU83hPSXH+BpgLfCciLgVeBt4MXEx22dbfFVg3SZIkqcN4pqQg+dmSs4BbycLIJ4ETge8A56aUthRXO0mSJKnjeKakQCmlVcAHiq6HJEmSVCTPlEiSJEkqlKFEkiRJUqEMJZIkSZIKZSiRJEmSVChDiSRJkqRCGUokSZIkFcpQIkmSJKlQhhJJkiRJhTKUSJIkSSqUoUSSJElSoSKlVHQddIxFxJa+ffsOnT59etFVkSRJUjf28ssvs2fPnq0ppWFH8zyGkm4oIlYAVUB1Abufls8XFbBvdRzbuWewnbs/27hnsJ17hqLaeRKwI6U0+WiexFCiYyoi5gGklGYWXRcdP7Zzz2A7d3+2cc9gO/cMXb2dvadEkiRJUqEMJZIkSZIKZSiRJEmSVChDiSRJkqRCGUokSZIkFcretyRJkiQVyjMlkiRJkgplKJEkSZJUKEOJJEmSpEIZSiRJkiQVylAiSZIkqVCGEkmSJEmFMpRIkiRJKpShRMdERIyLiH+PiLURUR8R1RHxrYgYUnTd1FJEDIuID0XEnRGxLCL2RERNRPw+Iv4iIto8LkTErIi4NyK2RsTuiFgQETdERPkB9jU7Ih7Kn39XRDwZEdcev99OBxIR10REyqcPtbPNYbdZRFwbEU/l29fk5Wcfn99C7YmI8yPi5xGxLj8Or4uI30TEH7axre/nLiYi3p635+r8uL08In4WEee2s71t3ElFxNUR8d2IeDQiduTH5J8cpEyHtGehx/OUkpPTUU3AicAGIAF3AV8FHswfLwKGFV1Hpxbt9eG8bdYCPwX+Cfh3YHu+/A7ygVVLyrwDaAB2Af8b+Hretgn4WTv7uT5fvxm4BfgXYFW+7KaiX4eeNgHj8zbembfBh45FmwE35etX5dvfAmzJl11f9O/dUybgc/lrvgn4EfAV4PvA08DXWm3r+7mLTcA/l7z+P8z/z94B7AWagP9uG3edCXguf113Ai/nP//kANt3SHsWfTwvvGGcuv4E3J//wX601fJv5su/V3QdnVq0yyXAlUBZq+WjgJV5m/1xyfIqYCNQD5xVsrwSmJtv/95WzzUJqMsPZpNKlg8BluVlzi36tegpExDAb4FX8n9m+4WSI2kzYFa+fBkwpNVzbcmfb9Lx+r2cXnu93523wwPAwDbW9y752fdzF5vyY3MjsB4Y0Wrdxfnrv9w27jpT3m5T82PzRRwglHRUe3aG47mXb+moRMQU4DKgmixRl/oiUAtcExH9O7hqakdK6cGU0i9TSk2tlq8Hvpc/vKhk1dXACcBtKaVnSravI/t2FuCvW+3mg0AFcHNKqbqkzDayb3AhO2OjjvExsjD6AbL3ZFuOpM2aH/9jvl1zmWqy40FFvk8dJ/nllv8M7Aben1La2XqblNK+koe+n7ueiWSX2z+ZUtpYuiKlNIfs2/YTShbbxp1cSmlOSmlpyj/1H0RHtWfhx3NDiY7WJfn8N218yN0JPAb0A97S0RXTEWn+8NJQsqy5jX/dxvaPkH0YmhURFYdY5r5W2+g4iojpZJd6fDul9MgBNj2SNrOdizcLmAzcC2zL7zv4TER8vJ17DXw/dz1LyS7TOicihpeuiIgLgIFkZ0Kb2cbdS0e1Z+F/A4YSHa1T8vmSdtYvzecnd0BddBQiohfwZ/nD0oNSu22cUmoAVgC9gCmHWGYd2bf14yKi31FWWweQt+n/Jbss77MH2fyw2iw/+zkW2JWvb833fsc4O59vAOYD95CF0G8BcyPi4Ygo/Rbd93MXk1LaCnwGGAm8FBHfj4h/ioj/BH5DdtneX5UUsY27l+Penp3leG4o0dEalM9r2lnfvHxwB9RFR+erwAzg3pTS/SXLj6SND7XMoHbW69j4AnAG8OcppT0H2fZw28z3fucwIp9/GOgLvJXsm/MZZPf7XQD8rGR7389dUErpW8BVZB8+rwP+luxeolXAra0u67KNu5eOaM9OcTw3lOh4i3x+KNdNqiAR8THgk2S9eVxzuMXz+eG0sX8Xx1lEnEN2duQbKaXHj8VT5vPDbTPb+Phq7g40gKtTSr9LKe1KKb0IvAtYDVzYXrexbfD93AlFxKfJetu6lazHy/7ATGA58NOI+NrhPF0+t427h45sz+Pa/oYSHa2DfXtS1Wo7dTIR8RHg28BLwMX5pQKljqSND7XMjsOoqg5RyWVbS4DPH2Kxw22zg21/sG/edGw035C6PKX0fOmK/OxY81nPc/K57+cuJiIuIuvM4L9SSjemlJanlHanlOaTBc81wCfzjmfANu5uOqI9O8Xx3FCio7U4n7d3neHUfN7ePScqUETcANwMLCQLJOvb2KzdNs4//E4muzF++SGWGU32Ld/qlNLuI6+9DmAA2Ws/HagrGTAxkfWKB/CDfNm38seH1WYppVqyD0MD8vWt+d7vGM3ttr2d9c2hpW+r7X0/dx3NA9fNab0if82fIvs8d0a+2DbuXo57e3aW47mhREer+SB5WbQaCTwiBgLnAXuAJzq6YjqwiPgM2eBIz5EFko3tbPpgPr+8jXUXkPWuNjelVH+IZa5otY2OvXqyAbbamp7Nt/l9/rj50q4jaTPbuXiPkH0gmRoRfdpYPyOfV+dz389dT3OvSie0s755+d58bht3Lx3VnsX/DRzPQVCcesaEgyd2uYnskp4EPAMMPci2VWSjRB/OwE2TcSCuTjkBf0/bgycedpvRCQbbckoAP8nb4cutlv8B2Wjf24HB+TLfz11sAv4kf43XA2Nbrbsib+M9wDDbuOtNHNrgice9PTvD8TzyHUpHLCJOJHtjjADuBl4G3kw2YukSYFZKaUtxNVSpiLiW7GbJRuC7tH2NaHVK6daSMu8ku8myDrgN2Ar8EVm3g3cAf5JaHUwi4qPAd8gOZreTfYt3NTCO7ObrTx3L30uHJiL+nuwSrutSSj9ste6w2ywivgHcSHZD9R1AH+A9wDCyLypuPm6/jACIiBFkY0KdBDxKdjnPRLL7DRLZoIo/K9ne93MXkl+FcD9Zz2o7gTvJAsp0sku7ArghpfTtkjK2cSeWt88784ejgLeRXX71aL5sc+nr3VHtWfjxvOiE6NQ9JmA88CNgXf6H/yrZzdMH/BbeqZC2+nuyDyoHmh5qo9x55AO0kX0r9wLwCaD8APu6EniY7B9pLfA0cG3Rr0FPnmjnTMnRtBlwbb5dbV7uYWB20b9rT5qAoWRnp1fkx+AtZF8SvaWd7X0/d6EJ6A3cQHYp9A6yS/Y2ko1Lc5lt3LWmQ/g/XF1UexZ5PPdMiSRJkqRCeaO7JEmSpEIZSiRJkiQVylAiSZIkqVCGEkmSJEmFMpRIkiRJKpShRJIkSVKhDCWSJEmSCmUokSRJklQoQ4kkSZKkQhlKJEmSJBXKUCJJkiSpUIYSSZIkSYUylEiSJEkqlKFEkiRJUqEMJZIkSZIKZSiRJEmSVChDiSRJkqRC/X8R7kuoZST6PAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 250,
       "width": 402
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np  # useful for many scientific computing in Python\n",
    "import pandas as pd # primary data structure library\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = range(1000)\n",
    "y = [i ** 2 for i in x]\n",
    "plt.plot(x,y)\n",
    "plt.show(); \n",
    "\n",
    "%config InlineBackend.figure_format ='retina'\n",
    "plt.plot(x,y)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}