Lect0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 0\n",
    "\n",
    "## Outline of Topics\n",
    " - Basic variables\n",
    " - Conversions\n",
    " - \"Collection\" data types\n",
    "    - lists\n",
    "    - tuples\n",
    "    - sets\n",
    "    - dictionaries\n",
    " - Control statements\n",
    " - The math package\n",
    " - The NumPy package\n",
    " - Plotting\n",
    " \n",
    "For more detail on python please see the Purdue DataMine web link: <a href=\"https://thedatamine.github.io/the-examples-book/python.html\" target=\"_blank\">Data Mine on Python</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic variables\n",
    "\n",
    "Python uses something called **dynamic typing**, which means that a variable is created when a value is assigned to it. The type can be changed after originally set. There are a few rules on variable names:\n",
    "\n",
    "* Must start with a letter or underscore\n",
    "* Names are case-sensitive\n",
    "\n",
    "A python variable is more than just its value. It must also contain information about the type of the value. There is overhead associated with such flexibility. The code below illustrates three of the variable types: **integer, float, and string**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'int'>\n",
      "The value of x is:\n",
      "4\n",
      "\n",
      "The type of x is:\n",
      "<class 'float'>\n",
      "The value of x is:\n",
      "4.0\n",
      "\n",
      "The type of x is:\n",
      "<class 'str'>\n",
      "The value of x is:\n",
      "four\n"
     ]
    }
   ],
   "source": [
    "# Integer, i.e., whole numbers both positive and negative. Later on \n",
    "# we will illustrate formatting the print command.\n",
    "x = 4;\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print('The value of x is:')\n",
    "print(x)\n",
    "print() # Just to give a space.\n",
    "\n",
    "# Floating point, i.e., computer representation of real numbers.\n",
    "x = 4.0;\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print('The value of x is:')\n",
    "print(x)\n",
    "print() # Just to give a space.\n",
    "\n",
    "# Strings. A string is a sequence of characters. They can be delimited\n",
    "# by single quotes ('blah') or double quotes (\"blah blah\")\n",
    "x = \"four\"\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conversions\n",
    "Python has a built-in command `float()` that can convert integers and certain strings to floating point numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'int'>\n",
      "The value of x is:\n",
      "4\n",
      "\n",
      "The type of x is:\n",
      "<class 'float'>\n",
      "The value of x is:\n",
      "4.0\n",
      "\n",
      "The type of x is:\n",
      "<class 'str'>\n",
      "The value of x is:\n",
      "1.67\n",
      "\n",
      "The type of x is:\n",
      "<class 'float'>\n",
      "The value of x is:\n",
      "1.67\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Start with an int.\n",
    "x = 4;\n",
    "\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print('The value of x is:')\n",
    "print(x)\n",
    "print()\n",
    "\n",
    "# Convert to float\n",
    "x = float(x)\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print('The value of x is:')\n",
    "print(x)\n",
    "print()\n",
    "\n",
    "# Can also convert strings representing floating point numbers to\n",
    "# float.\n",
    "x = '1.67'\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print('The value of x is:')\n",
    "print(x)\n",
    "print()\n",
    "\n",
    "# Note that when we print the string version of x it prints it just\n",
    "# as if it were a floating point number, i.e., we can't tell from the\n",
    "# output.\n",
    "x = float(x)\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print('The value of x is:')\n",
    "print(x)\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also a python command `int()`, which can covert floats to integer and certain strings to integer, and a command `str()`, which converts numbers to strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean type\n",
    "A Boolean value has a python type **bool**. The possible values a Boolean variable can take are: **True** and **False**. These are typically used to hold the results of logical tests, which in turn can be used to control the flow of a python program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'bool'>\n",
      "The value of x is:\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = True;\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collection data types\n",
    "There are four **collection** data types: **lists**, **tuples**, **sets**, and **dictionaries**. (Some say that a **string** is a collection data type since it is a ordered set of characters)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lists** are ordered, changeable, and allow duplicate members:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of Coloradothings is:\n",
      "<class 'list'>\n",
      "The length of Coloradothings is:\n",
      "5\n",
      "The value of Coloradothings is:\n",
      "['wheat', 'corn', 'sugar beets', 'pinto beans', 1959]\n"
     ]
    }
   ],
   "source": [
    "# Create a list with 5 elements.\n",
    "Coloradothings = [\"wheat\", \"corn\", \"sugar beets\", \"pinto beans\", 1959]\n",
    "print('The type of Coloradothings is:')\n",
    "print(type(Coloradothings))\n",
    "print('The length of Coloradothings is:')\n",
    "print(len(Coloradothings))\n",
    "print('The value of Coloradothings is:')\n",
    "print(Coloradothings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For Coloradothings[3] ...\n",
      "pinto beans\n",
      "<class 'str'>\n",
      "\n",
      "For Coloradothings[4] ...\n",
      "1959\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# The elements inside of Coloradothings may be of differing\n",
    "# types ...\n",
    "print('For Coloradothings[3] ...')\n",
    "print(Coloradothings[3])\n",
    "print(type(Coloradothings[3]))\n",
    "print()\n",
    "print('For Coloradothings[4] ...')\n",
    "print(Coloradothings[4])\n",
    "print(type(Coloradothings[4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['wheat', 'corn', 'sugar beets', 'pinto beans', 1959, 'Amherst']\n",
      "\n",
      "['wheat', 'corn', 'sunflowers', 'sugar beets', 'pinto beans', 1959, 'Amherst']\n"
     ]
    }
   ],
   "source": [
    "# We can append to a list and insert in a list\n",
    "\n",
    "Coloradothings.append(\"Amherst\")\n",
    "print(Coloradothings)\n",
    "print()\n",
    "Coloradothings.insert(2, \"sunflowers\")\n",
    "print(Coloradothings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tuples** are ordered, unchangeable, and allow duplicate members."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "\n",
      "('Basketball', 'Corn')\n"
     ]
    }
   ],
   "source": [
    "# Make a tuple.\n",
    "Indianathings = (\"Basketball\", \"Corn\")\n",
    "print(type(Indianathings))\n",
    "print()\n",
    "print(Indianathings)\n",
    "#Indianathings.append(\"Wall street\") # uncomment this to see an error\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples can contain a single item but to do this we must specify them with a comma after the first and only element, e.g., `Indianathings = (\"Basketball\")` is not a tuple (it's a string), while `Indianathings = (\"Basketball\",)` is a tuple.\n",
    "\n",
    "Tuples cannot be changed. For example, if Indianathings is a tuple then `Indianathings.append(\"Wall street\")` will cause an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sets** are unordered, changeable (in the sense that we can add and remove items from sets). Sets do not allow duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "{'Horses', 'Bluegrass', 'Wildcats', 'Basketball', 'Bourbon', 'Mountains and Western KY'}\n",
      "\n",
      "Horses\n",
      "Bluegrass\n",
      "Wildcats\n",
      "Basketball\n",
      "Bourbon\n",
      "Mountains and Western KY\n",
      "\n",
      "True\n",
      "\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Make a set for UKY\n",
    "UKYthings = {\"Wildcats\", \"Basketball\", \"Bourbon\", \"Horses\", \"Bluegrass\", \"Mountains and Western KY\"}\n",
    "print(type(UKYthings))\n",
    "print(UKYthings) # Note the order it prints\n",
    "print()\n",
    "\n",
    "for x in UKYthings: # Note the order with which the for loop executes\n",
    "    print(x)\n",
    "\n",
    "print()\n",
    "print(\"Basketball\" in UKYthings)\n",
    "\n",
    "print()\n",
    "print(\"Football\" in UKYthings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "{'Engineering', 'Airmen', 'Golden tigers', 'TU', 'Booker T. Washington', 'Veterinary Medicine'}\n",
      "\n",
      "Engineering\n",
      "Airmen\n",
      "Golden tigers\n",
      "TU\n",
      "Booker T. Washington\n",
      "Veterinary Medicine\n",
      "\n",
      "False\n",
      "\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Make a set for Tuskegee\n",
    "Tuskegeethings = {\"Golden tigers\", \"TU\", \"Booker T. Washington\", \"Veterinary Medicine\", \"Engineering\", \"Airmen\"}\n",
    "print(type(Tuskegeethings))\n",
    "print(Tuskegeethings) # Note the order it prints\n",
    "print()\n",
    "\n",
    "for x in Tuskegeethings: # Note the order with which the for loop executes\n",
    "    print(x)\n",
    "\n",
    "print()\n",
    "print(\"Basketball\" in Tuskegeethings)\n",
    "\n",
    "print()\n",
    "print(\"Engineering\" in Tuskegeethings)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "{'Gene Keady', 'study sessions', 'Ag and Bio Engineering', 'professors', 'students', 'Ross-Ade Stadium'}\n",
      "\n",
      "Gene Keady\n",
      "study sessions\n",
      "Ag and Bio Engineering\n",
      "professors\n",
      "students\n",
      "Ross-Ade Stadium\n",
      "\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Make a set.\n",
    "Purduethings = {\"Ag and Bio Engineering\", \"Ross-Ade Stadium\", \"students\", \"professors\", \"Gene Keady\", \"study sessions\"}\n",
    "print(type(Purduethings))\n",
    "print(Purduethings) # Note the order it prints\n",
    "print()\n",
    "\n",
    "for x in Purduethings: # Note the order with which the for loop executes\n",
    "    print(x)\n",
    "\n",
    "print()\n",
    "print(\"Ag and Bio Engineering\" in Purduethings)\n",
    "print(\"Medical School\" in Purduethings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the code output above we note:\n",
    "1. The order in which we included the set items when defining it is not the order that python used to enumerate the items when printing. Just FYI.\n",
    "2. The statement in the last print command: `\"Ag and Bio Engineering\" in Purduethings` is a Boolean variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform classical set operations (**union**, **intersection**, **difference**, **test subset**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Purduethings union IUthings equals:\n",
      "{'study sessions', 'Bobby Knight', 'Ag and Bio Engineering', 'professors', 'Hoosiers', 'Gene Keady', 'parties', 'students', 'Ross-Ade Stadium'}\n",
      "\n",
      "Purduethings intersection IUthings equals:\n",
      "{'students', 'professors'}\n",
      "\n",
      "IUthings not also in Purduethings equals:\n",
      "{'parties', 'Bobby Knight', 'Hoosiers'}\n",
      "\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Make another set ...\n",
    "IUthings = {\"Hoosiers\", \"Bobby Knight\", \"students\", \"professors\", \"parties\"}\n",
    "print('Purduethings union IUthings equals:')\n",
    "print(Purduethings.union(IUthings))\n",
    "print()\n",
    "print('Purduethings intersection IUthings equals:')\n",
    "print(Purduethings.intersection(IUthings))\n",
    "print()\n",
    "print('IUthings not also in Purduethings equals:')\n",
    "print(IUthings.difference(Purduethings))\n",
    "print()\n",
    "print({\"Gene Cernan\",}.issubset(Purduethings))\n",
    "Purduethings.add(\"Gene Cernan\")\n",
    "print({\"Gene Cernan\",}.issubset(Purduethings))\n",
    "\n",
    "#print(Purduethings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionaries** are unordered, changeable, and indexed. Written with \"{}\" but made up of key-value pairs. A key-value pair is a pair of strings separated by a colon. Different key-value pairs are separated by commas. It looks like `{\"key1\": \"value1\", \"key2: \"value2\"}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{'brand': 'JD', 'model': '7720', 'year': 1978, 'color': 'green'}\n"
     ]
    }
   ],
   "source": [
    "# Make some dictionaries of farm equipment.\n",
    "OldCombine = {\"brand\": \"CASE\", \"model\": \"7130\", \"year\": 2014}\n",
    "NewCombine = {\"brand\": \"CASE\", \"model\": \"8240\", \"year\": 2016}\n",
    "Tractor1 = {\"brand\": \"CASE\", \"model\": \"290\", \"year\": 2013}\n",
    "Pickup = {\"brand\": \"CHEVY\", \"model\": \"Silverado\", \"year\": 2005}\n",
    "FavoriteOldCombineEver = {\"brand\": \"JD\", \"model\": \"7720\", \"year\": 1978, \"color\": \"green\"}\n",
    "\n",
    "print(type(FavoriteOldCombineEver))\n",
    "print(FavoriteOldCombineEver)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries can contain dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C1': {'brand': 'CASE', 'model': '7130', 'year': 2014}, 'C2': {'brand': 'CASE', 'model': '8240', 'year': 2016}, 'T1': {'brand': 'CASE', 'model': '290', 'year': 2013}, 'P1': {'brand': 'CHEVY', 'model': 'Silverado', 'year': 2005}, 'C3': {'brand': 'JD', 'model': '7720', 'year': 1978, 'color': 'green'}}\n"
     ]
    }
   ],
   "source": [
    "# Create a dictionary of farm equipment from the dictionaries of\n",
    "# individual machines.\n",
    "\n",
    "FarmEquipment = {\"C1\": OldCombine, \"C2\": NewCombine, \"T1\": Tractor1, \"P1\": Pickup, \"C3\": FavoriteOldCombineEver}\n",
    "print(FarmEquipment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control statements\n",
    "There are three methods of program control that we consider here:\n",
    "1. If/else statement\n",
    "2. For loops\n",
    "3. While loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than b\n"
     ]
    }
   ],
   "source": [
    "# Example if/else statement\n",
    "\n",
    "a = 5;\n",
    "b = 3;\n",
    "if b > a:\n",
    "    print(\"b is greater than a\")\n",
    "elif a == b:\n",
    "    print(\"a and b are equal\")\n",
    "else:\n",
    "    print(\"a is greater than b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# While loop: Execute while condition is true.\n",
    "\n",
    "i = 1\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "a\n",
      "n\n",
      "a\n",
      "n\n",
      "a\n",
      "\n",
      "\n",
      "Try continue command\n",
      "\n",
      "\n",
      "b\n",
      "a\n",
      "a\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "# For loop: Iterate over a sequence. Also, have break (stop a loop where it is \n",
    "# and exit) and continue (move to the next iteration of loop).\n",
    "\n",
    "for x in \"banana\":\n",
    "    print(x)\n",
    "    \n",
    "print(\"\\n\")    \n",
    "print(\"Try continue command\")\n",
    "print(\"\\n\")\n",
    "\n",
    "for x in \"banana\":\n",
    "    if x == \"n\":\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The math package\n",
    "Python provides many modules designed for specialized programming tasks. See: <a href=\"https://pypi.org\" target=\"_blank\">The Python Package Index</a>.\n",
    "\n",
    "The math package contains trigonometric, exponential, logarithmic, hyperbolic, and special functions. It also contains a number of useful constants such as `pi` and `e`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "P = math.pi;\n",
    "print(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the math package to create something interesting. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 0.0\n",
      "0.12566370614359174 0.12533323356430426\n",
      "0.25132741228718347 0.2486898871648548\n",
      "0.37699111843077515 0.3681245526846779\n",
      "0.5026548245743669 0.4817536741017153\n",
      "0.6283185307179586 0.5877852522924731\n",
      "0.7539822368615503 0.6845471059286886\n",
      "0.8796459430051421 0.7705132427757891\n",
      "1.0053096491487339 0.8443279255020151\n",
      "1.1309733552923256 0.9048270524660196\n",
      "1.2566370614359172 0.9510565162951535\n",
      "1.382300767579509 0.9822872507286886\n",
      "1.5079644737231006 0.9980267284282716\n",
      "1.6336281798666925 0.9980267284282716\n",
      "1.7592918860102842 0.9822872507286887\n",
      "1.8849555921538756 0.9510565162951536\n",
      "2.0106192982974678 0.9048270524660195\n",
      "2.1362830044410597 0.844327925502015\n",
      "2.261946710584651 0.7705132427757893\n",
      "2.3876104167282426 0.6845471059286888\n",
      "2.5132741228718345 0.5877852522924732\n",
      "2.6389378290154264 0.4817536741017152\n",
      "2.764601535159018 0.36812455268467814\n",
      "2.8902652413026093 0.24868988716485524\n",
      "3.015928947446201 0.12533323356430454\n",
      "3.141592653589793 1.2246467991473532e-16\n",
      "3.267256359733385 -0.1253332335643043\n",
      "3.3929200658769765 -0.24868988716485457\n",
      "3.5185837720205684 -0.3681245526846779\n",
      "3.6442474781641603 -0.4817536741017154\n",
      "3.7699111843077513 -0.5877852522924727\n",
      "3.895574890451343 -0.6845471059286884\n",
      "4.0212385965949355 -0.7705132427757894\n",
      "4.1469023027385274 -0.8443279255020153\n",
      "4.272566008882119 -0.9048270524660198\n",
      "4.39822971502571 -0.9510565162951535\n",
      "4.523893421169302 -0.9822872507286887\n",
      "4.649557127312894 -0.9980267284282716\n",
      "4.775220833456485 -0.9980267284282716\n",
      "4.900884539600077 -0.9822872507286887\n",
      "5.026548245743669 -0.9510565162951536\n",
      "5.15221195188726 -0.9048270524660199\n",
      "5.277875658030853 -0.8443279255020151\n",
      "5.403539364174444 -0.7705132427757896\n",
      "5.529203070318036 -0.684547105928689\n",
      "5.654866776461628 -0.5877852522924732\n",
      "5.780530482605219 -0.4817536741017161\n",
      "5.906194188748811 -0.3681245526846778\n",
      "6.031857894892402 -0.24868988716485535\n",
      "6.157521601035994 -0.12533323356430467\n"
     ]
    }
   ],
   "source": [
    "# This short program will print a table with 50 rows where\n",
    "# each row contains an argument and the sine of the argument.\n",
    "# The sine function will trace on complete period of length\n",
    "# 2*pi.\n",
    "N = 50;\n",
    "for k in range(N):\n",
    "    t = 2*P*k/N;\n",
    "    print(t, math.sin(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The table above is difficult to read because it is not well formatted. Python has tools to simplify formating with the print command. There is a nice explanation in the Data Mind notes mentioned in the introduction. One prefered method uses `f-strings`, which stands for **format string**. They are indicated by preceeding the string with `f` or `F`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is approximately 3.141592653589793\n",
      "\n",
      "The value of pi is approximately 3.142.\n"
     ]
    }
   ],
   "source": [
    "# Compare two ways of printing pi\n",
    "print('The value of pi is approximately', P)\n",
    "print()\n",
    "print(f'The value of pi is approximately {math.pi:.3f}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make a prettier (more readable) sinewave table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0.00     0.000\n",
      " 0.13     0.125\n",
      " 0.25     0.249\n",
      " 0.38     0.368\n",
      " 0.50     0.482\n",
      " 0.63     0.588\n",
      " 0.75     0.685\n",
      " 0.88     0.771\n",
      " 1.01     0.844\n",
      " 1.13     0.905\n",
      " 1.26     0.951\n",
      " 1.38     0.982\n",
      " 1.51     0.998\n",
      " 1.63     0.998\n",
      " 1.76     0.982\n",
      " 1.88     0.951\n",
      " 2.01     0.905\n",
      " 2.14     0.844\n",
      " 2.26     0.771\n",
      " 2.39     0.685\n",
      " 2.51     0.588\n",
      " 2.64     0.482\n",
      " 2.76     0.368\n",
      " 2.89     0.249\n",
      " 3.02     0.125\n",
      " 3.14     0.000\n",
      " 3.27    -0.125\n",
      " 3.39    -0.249\n",
      " 3.52    -0.368\n",
      " 3.64    -0.482\n",
      " 3.77    -0.588\n",
      " 3.90    -0.685\n",
      " 4.02    -0.771\n",
      " 4.15    -0.844\n",
      " 4.27    -0.905\n",
      " 4.40    -0.951\n",
      " 4.52    -0.982\n",
      " 4.65    -0.998\n",
      " 4.78    -0.998\n",
      " 4.90    -0.982\n",
      " 5.03    -0.951\n",
      " 5.15    -0.905\n",
      " 5.28    -0.844\n",
      " 5.40    -0.771\n",
      " 5.53    -0.685\n",
      " 5.65    -0.588\n",
      " 5.78    -0.482\n",
      " 5.91    -0.368\n",
      " 6.03    -0.249\n",
      " 6.16    -0.125\n"
     ]
    }
   ],
   "source": [
    "# Prettier sine wave table.\n",
    "N = 50;\n",
    "for k in range(N):\n",
    "    t = 2*P*k/N;\n",
    "    print(f'{t: 1.2f}', '  ', f'{math.sin(t): .3f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## People actually used to plot graphs like this on line printers ... (1980s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                             +\n",
      "                                 +\n",
      "                                     +\n",
      "                                         +\n",
      "                                            +\n",
      "                                               +\n",
      "                                                  +\n",
      "                                                     +\n",
      "                                                       +\n",
      "                                                         +\n",
      "                                                          +\n",
      "                                                           +\n",
      "                                                           +\n",
      "                                                           +\n",
      "                                                           +\n",
      "                                                          +\n",
      "                                                         +\n",
      "                                                       +\n",
      "                                                     +\n",
      "                                                  +\n",
      "                                               +\n",
      "                                            +\n",
      "                                         +\n",
      "                                     +\n",
      "                                 +\n",
      "                              +\n",
      "                          +\n",
      "                      +\n",
      "                  +\n",
      "               +\n",
      "            +\n",
      "         +\n",
      "      +\n",
      "    +\n",
      "  +\n",
      " +\n",
      "+\n",
      "+\n",
      "+\n",
      "+\n",
      " +\n",
      "  +\n",
      "    +\n",
      "      +\n",
      "         +\n",
      "            +\n",
      "               +\n",
      "                  +\n",
      "                      +\n",
      "                          +\n",
      "                             +\n",
      "                                 +\n",
      "                                     +\n",
      "                                         +\n",
      "                                            +\n",
      "                                               +\n",
      "                                                  +\n",
      "                                                     +\n",
      "                                                       +\n",
      "                                                         +\n",
      "                                                          +\n",
      "                                                           +\n",
      "                                                           +\n",
      "                                                           +\n",
      "                                                           +\n",
      "                                                          +\n",
      "                                                         +\n",
      "                                                       +\n",
      "                                                     +\n",
      "                                                  +\n",
      "                                               +\n",
      "                                            +\n",
      "                                         +\n",
      "                                     +\n",
      "                                 +\n",
      "                              +\n",
      "                          +\n",
      "                      +\n",
      "                  +\n",
      "               +\n",
      "            +\n",
      "         +\n",
      "      +\n",
      "    +\n",
      "  +\n",
      " +\n",
      "+\n",
      "+\n",
      "+\n",
      "+\n",
      " +\n",
      "  +\n",
      "    +\n",
      "      +\n",
      "         +\n",
      "            +\n",
      "               +\n",
      "                  +\n",
      "                      +\n",
      "                          +\n"
     ]
    }
   ],
   "source": [
    "# An old fashioned sine wave plot.\n",
    "N = 50;\n",
    "for k in range(2*N):\n",
    "    t = 2*P*k/N\n",
    "    s = 1 + math.sin(t)\n",
    "    n = math.ceil(30*s)\n",
    "    x = ''\n",
    "    i = 1\n",
    "    while i < n:\n",
    "        x = x + ' '\n",
    "        i += 1\n",
    "    x = x + '+'\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mercifully there have been improvements in plotting software and other python packages are available."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The NumPy Package"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All data manipulated by a computer is represented in binary. In otherwords, via one method or another, all data -- temperature sensor readings, hourly barometric pressure from your Davis weather station, an audio file, images from your Bushnell game camera, a yield map -- are represented as arrays of numbers.\n",
    "\n",
    "**NumPy (Numerical Python)** provides an efficient interface to store and compute on dense data buffers. NumPy arrays are much more efficient than Python's built-in list data type.\n",
    "\n",
    "See: <a href=\"http://www.numpy.org\" target=\"_blank\">The Numpy Package</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the numpy package. This command allows us to refer to numpy\n",
    "# commands using the shorthand \"np\".\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting examples with Matplotlib\n",
    "A better way to plot. Who says there has been no progress in the world since 1970?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import matplotlib and define a shorthand\n",
    "import matplotlib as mpl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  1,  6,  5,  4, 11, -1,  1,  2,  6])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n",
    "y = np.array([3, 1, 6, 5, 4, 11, -1, 1, 2, 6]);\n",
    "\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['seaborn-dark',\n",
       " 'seaborn-darkgrid',\n",
       " 'seaborn-ticks',\n",
       " 'fivethirtyeight',\n",
       " 'seaborn-whitegrid',\n",
       " 'classic',\n",
       " '_classic_test',\n",
       " 'fast',\n",
       " 'seaborn-talk',\n",
       " 'seaborn-dark-palette']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.style.available[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEaCAYAAAACBmAUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd5xU1fnH8c8jIFJUrMQSWcWGiKyCYiWroqixI5YYBWOLvUUlavIj1lgiKMVYWYNEsVBsaKIyBjUWoouKgoCCgmJB6SwgPL8/zqysy5Y7M/fOOTP7vF+vfSVz987M15llnrnnOfdcUVWMMcaYhqzjO4AxxpjCYAXDGGNMJFYwjDHGRGIFwxhjTCRWMIwxxkRiBcMYY0wkVjCMSZiI9BeR6Xl4njIRURHZOunnMo2TFQwTNBEpT38I1vxZ7DtbvonIzGr//ZUiMkVErhKRrP8di8h1IjIzxpimiDX1HcCYCCYAJ9bYttpHkADcCgwEWgDHAHcCCtzuM5RpHOwIwxSCFao6t8bPNwAisomIfCEid1XtLCKbi8hXInJr+raIyP0iMkNElonIpyJys4g0r3af/iIyXUROFJFpIrJURMaIyAYicryITBWRRSLypIhsWO1+5SLykohcLiJz0vd7SkQ2re8/SEQOEZHX03nmiMgwEdkkwmuxOP3f/5mqDgReBo6v53n2FpH/pJ/nBxH5p4hsnv5dX+AGoF21I5f+ETKYRsoKhiloqjoPOBU4X0SOEhEBhgOzgOvSuwnwNfAboANwKXAGcE2Nh9sC6AP0Ag4H9gOeBM7CHeEcARxQy/32AsqAw9L77AY8VFdmETkIGAs8lt73WKAEGJ3On4llQLM6nucXwL+A2emMRwG7Ak+ldxmJO2KZjftv3wK4I8PnN42IDUmZQlBWS89ivKoeBaCq/xGRG4FhwMNAN2B3VV2Z/v1q1hQPgJki0h44H/i/atubA31U9TsAEXkc+D3wC1X9Nr3tMeDgGlnWAU5T1QXpfS4AXhSRHVR1Wi3/PX8G7lbVQVUbRKQPrsh1BioaekHSfYvDgZ7AgDp2uwBYCPRV1RXp+50GVIhI9/TrthhYpapzG3pOY6xgmELwFu6bf3VLa9y+AffheTlwsqp+Vv2XInI27kihBGiF+9uveYQ9p6pYpM0F5lYVi2rbNq9xv4+qikXa6+n/7QDUVjD2BPYWkQtr+d0O1F8w/iQi/YB1cb2Lh4H+dezbEXizqlgAqOokEVmQ/t1/6nkeY9ZiBcMUgmWq2tC01C2AHYFV6f/9iYj0BoYA/YBXcd+6ewM31XiMlTVuax3bch3KXQc3FDS8lt819E1/CDAUqAS+TB891aeu5ahtmWqTMSsYpuClh2ceASbjhmeeEJHxqvpaepfuwHuqeme1+5TEGKGDiGygqgvTt/dN/+/Hdew/EegYoQjW5vsM7jcZOENE1q02JNUZ2DD9O4AVQJMscphGyJrephCsKyK/qOWnqkF8LdAJOFVVxwB/B0aIyEbp308FOonIMSLSXkQuoZ6ZRVlQ4B8isquIdMcdBTxXR/8CXA/jGBEZICKl6UyHiciDItIixlyDgQ2A8nS2/XFHNa+p6oT0Pp8BvxCRfURkUxFpGePzmyJjBcMUggOAr2r52URE9sV9AP9OVWen9/8DMB94IH37XtwH5TDgPVxTvH+M+d4GXgP+DbxI+pt9XTur6njgIFyRmwC8jzsyWsTaQ2BZU9WvgUOBrYF3gGeBD3GzwKqMAZ4AngO+Ba6K6/lN8REfV9xLN/v64v7BPKqqfdPb98Y1L7vgxqJTwMWq+lXeQxoTgYiUA1urag/fWYxJmq8jjC+BG1l7rvpGwH24mSztcN+4huU1mTHGmFp5aXqr6igAEemKO1yu2j6u+n4iMhg3q8UYY4xnoc+S6s6a2RzGBKdqONWYxiDYgiEiu5GeTVLPPjaX3BhjsqCqmS5DE+YsKRHZHhgHXFJt+l+tVDWonz59+njPYJmKK5dlskxx/2QruIIhIu2Al4AbVLW2M2GNMcZ44GVISkSapp+7CdBERNYDfgTaAq8AQ1T17z6y5aqkpMR3hLVYpuhCzGWZorFMyfPVw7iOn68S+lvgL7gzZrcD/k9Efvq9qrbOb7zslZWV+Y6wFssUXYi5LFM0lil5vqbV9qfuM23/kr8kxhhjogquh2GMMSZMXpYGiYuIaCHnN8YYH0QELZZptcYYY8JjBSNmqVTKd4S1WKboQsxlmaKxTMmzgmGMMSYS62EYY0wjYz0MY4wxibKCEbMQxywtU3Qh5rJM0Vim5FnBMMYYE4n1MIwJ2MiR0LUrtG/vO4kpJtbDMKbIrFoFl1wCo0b5TmKMYwUjZiGOWVqm6ELK9eqr8M03MG5cyneUtYT0OlWxTMmzgmFMoEaOhNNOg6lTfScxxrEehjEBWrkSttgC3noLOneGOXNgww19pzLFwnoYxhSRl1+GHXZwze7SUnj3Xd+JjLGCEbsQxywtU3Sh5HrsMTj5ZPf/27ZNMXGi3zw1hfI6VWeZkmcFw5jAVFbC2LHQu7e7veOO8L//+c1kDFgPw5jgjB0LAwZA1ZfTyZPh2GNh2jSvsUwRsR6GMUXiscfgpJPW3N55Z/jqK1iwwF8mY8AKRuxCHLO0TNH5zrVkCYwbB716rdk2YUKKzp3Danz7fp1qY5mSZwXDmIA89xx06wabb/7z7V26WB/D+OelhyEiFwJ9gU7Ao6rat9rvDgaGANsAbwF9VXVWHY9jPQxTVI4/Ho48En73u59vf/hheOEFePRRP7lMcSm0HsaXwI3AQ9U3isimwCjgT8DGwERgZN7TGePBwoXu/Ivjjlv7d3aEYULgpWCo6ihVHQPMq/Gr44HJqvqEqlYC/YHOIrJzvjNmK8QxS8sUnc9cY8dC9+6w0UY/355Kpdh5Z/jyy3Aa3yG+f5YpeaH1MDoCk6puqOoSYEZ6uzFFbeTINSfr1dS0qVsi5L338pvJmOqa+g5QQ2vg2xrbFgDr13WHvn37UlJSAkCbNm0oLS2lrKwMWFPd8327iq/nL4TbZWVlQeWpfrtKPp//++9h/PgU558PUPv+bdumGDnS/+sT6vtXtS2UPCF9HqRSKcrLywF++rzMhtcT90TkRmDrqqa3iNwFNFPV86vt8wHQX1WfquX+1vQ2ReGBB1xT+8kn697HGt8mLoXW9K7LZKBz1Q0RaQW0T28vCDW/VYTAMkXnK1d9w1FVmUJqfIf4/lmm5HkpGCLSVETWA5oATURkPRFpCowGdhWRXunf/xl4X1Wn+MhpTD58/TW88w4ccUT9+4XW+DaNj6/zMPoD/1dj819Utb+I9AAGA+1Ycx7GzDoex4akTMEbOhRefx1GjGh43333hZtvhmrD9sZkLNshKVt80BjPuneHK6+Eo45qeN+LLoKSErjiisRjmSJWLD2MghfimKVlii7fuWbPhg8/hEMPrXuf6plC6WOE+P5ZpuRZwTDGoyeecEuXN28ebf9QCoZpnGxIyhiPunWD66+Hnj2j7f/jj+7a3l99BRtskGw2U7xsSMqYAvPZZ+7noIOi36dpU9htNzvj2/hhBSNmIY5ZWqbo8plr5Eh33Ytmzerfr2amrl39D0uF+P5ZpuRZwTDGk5pX1ouqSxeYODH+PMY0xHoYxngwZYobivriC2jSJLP7fvABnHACTJ2aTDZT/KyHYUwBGTkSevfOvFgAdOjgpuMuXBh/LmPqYwUjZiGOWVqm6PKRS9UNR9W1dlRNNTOF0PgO8f2zTMmzgmFMnn3wASxbBnvvnf1j2PkYxgfrYRiTZ9dc486nuO227B9j2DB46aVo608ZU5P1MIwpAKr1L2UelR1hGB+sYMQsxDFLyxRd0rkmToR11oHdd49+n9oy7bKLm2G1aFF82TIR4vtnmZJnBcOYPKo6upCMBwN+rmlT6NTJzvg2+WU9DGPyZPVqaNfOXWa1Y8fcH+/CC6F9e7jsstwfyzQu1sMwJnBvvOEWDoyjWICd8W3yzwpGzEIcs7RM0SWZK9tmd12ZfDa+Q3z/LFPymvoOYExjsGqVu/bFhAnxPWb1xvf668f3uMbUxXoYxuTBK6+4y7DGfUSw997ufI7u3eN9XFPcrIdhTMAyWQokE3Y+hsknKxgxC3HM0jJFl0SulSth1Cg48cTs7l9fJl8FI8T3zzIlL8iCISIlIvK8iPwgInNFZLCIWL/FFKSXXoIdd3RTauNmRxgmn4LsYYjI88A3wO+BNsC/gftV9e4a+1kPwwSvTx/YYw+45JL4H3vlSmjTBubOtca3ia7YehjbAo+raqWqzgVeAGKavW5M/lRWwtNPu2tfJKFZM9h1V6ioSObxjaku1IJxF3CyiLQUka2Aw3FFI3ghjllapujizvXCC1BaCltumf1jNJTJx7BUiO+fZUpeqH2BV4GzgYVAE+BhYExtO/bt25eSkhIA2rRpQ2lpKWVlZcCaNyuftysqKrw+f223q4SSJ+Tbcb9/d98NJ52U2+NVqev3XbuW8corYbx+Pm9XpA+zQskT0udBKpWivLwc4KfPy2wE18MQkXWAmcC9wB1Aa+AhYKqqXlVjX+thmGAtWeKOLKZPh802S+55Jk1yU3Y//ji55zDFpZh6GBsDvwQGq+pyVZ0HDAOO8BvLmMw8+6w7sS7JYgHujO/PP/e31LlpPIIrGKr6HfAZcJ6INBWRNkAfYJLfZNHUHEYIgWWKLs5ccVwoCRrO5KPxHeL7Z5mSF1zBSDseOAz4FpgO/AjYIs6mYCxcCC+/DMcdl5/ns/MxTD4E18PIhPUwTKiGD3eLDT79dH6e78EHIZVyz2tMQ4qph2FMwUtq7ai62BGGyQcrGDELcczSMkUXR6558+C11+Coo3LPA9EydewIs2bB4sXxPGdDQnz/LFPyrGAYE7PRo+HQQ/O7VEezZq5o2BnfJknWwzAmZj16wHnnQa9e+X3e886DnXdOZs0qU1ysh2FMAL7+2l1n+wgPZw1ZH8MkzQpGzEIcs7RM0eWa68kn4cgjoUWLePJA9Exdu7pilQ8hvn+WKXlWMIyJ0WOPwUkn+XnufDe+TeNjPQxjYjJ7NnTuDF9+Cc2b+8mw115w552w//5+nt8UButhGOPZ44/Dscf6KxZgfQyTLCsYMQtxzNIyRZdLrpEjkxmOyiRTvgpGiO+fZUqeFQxjYvDpp/DZZ3DQQX5z2BGGSZL1MIyJwS23uCXG77nHb44VK9w1vr/9Flq18pvFhMt6GMZ4FNdS5rlad10749skxwpGzEIcs7RM0WWTa8oU940+qZlJmWbKx7BUiO+fZUqeFQxjcjRyJPTuDU2a+E7iWB/DJMV6GMbkQNVdInXYMHc51hC89x789rcwebLvJCZU1sMwxoP334dly6BbN99J1ujY0c3YWrLEdxJTbKxgxCzEMUvLFF2muarOvZCMv6tFl2mmfDS+Q3z/LFPyrGAYkyXV/F9ZLyrrY5gkWA/DmCy98w6ceipMnZrsEUY27r/fXfXv4Yd9JzEhsh6GMXlWdXQRWrEAO8IwyQi2YIjIySLysYgsEZEZInKA70xRhDhmaZmii5pr9Wq32GA+ljLP5rXadVe3XElSje8Q3z/LlLwgC4aIHALcCpwBrA90Bz71GsqYat54wy3B0bGj7yS1W3ddN9130iTfSUwxCbKHISJvAA+q6oMN7Gc9DOPFhRfCFlvAtdf6TlK3c891RxoXXeQ7iQlN0fQwRKQJ0BXYTESmi8hsERksIjFe9NKY7P34o7sUq68r60VlfQxTmxUrsr9vcAUDaAs0A04ADgBKgd2B63yGiiq0Mctx42CbbVLceit8953vNGuE9jpViZLr1Vdh661h++2TzwPZv1ZduiR3je8Q3z/L1LDFi3MbRm0aX5TYLEv/7yBV/QpARO7EFYy1BgD69u1LSUkJAG3atKG0tJSysjJgzZuVz9sVFRVen7/67fHjU1x2GRx6qFsgr6QkxX77wQ03lLHXXv7zhXg7yvs3cmQZJ52Uv3xVMr3/vHkppk2DJUvKaNUqjNc3ydsV6TMVQ8kT0udBKpWivLyc//0PWrQoIVuh9jC+AK5V1X+kb/cCrlPV3WvsZz2Mevz733DxxW5NoXXWgXnz4KGH3DUbNtkEzj/fTQttYYN9ka1YAVtu6YZ62rXznaZhXbvC3XfDvvv6TmJ8mzrVraj8/vuw5ZZF0sNIGwZcJCKbi8hGwKXAs54zFZybb4Y//tEVC3BF4sorYdo06N8fnngCttnGbfvU5qBF8tJLsNNOhVEswPoYxlF1kx+uvdZN1shWqAXjBuAd4BPgY+A94CaviSKqOYzgyxtvwMyZcMopa2dq0gR+/Wt4/nl48023rVu3NdtWr04+XyivU00N5Urqut31yeW1SqpghPj+Waa6PfUUfPWVm92XiyALhqquVNXzVbWNqv5CVS9W1UrfuQrJTTfB1VdDs2b179e+Pdx+u7u86AknwJ//7Jq5t9/uhrDMGpWV8PTT7toXhcKOMMySJXD55TBkCDTNsWsdZA8jKuth1K6iAo44wg0zrbdeZvdVhbffdn9cTz8Nxx0HF1zgxsIbuzFj4K67YPx430miW74cNtrIzZBr2dJ3GuPDNdfArFkwYsSabUVzHobJ3c03wxVXZF4swK2L1K0b/OMfrtex007uyKNqW2UjPs4LdWXa+jRvDh062BnfjdUnn7iFKG+/PZ7Hs4IRM99jllOnum/A5567Zlu2mTbbDPr1gxkzXLNsxAjXJO/Xz/VHcuH7dapLXbmWLHHntPTqld88kPtrlcSwVIjvn2X6uapG9x//6Gb2xcEKRpH561/dH0nr1vE9ZpMmcPTR8OKL8Prrbmpp165u2wsv5KdJ7tuzz8I++8Cmm/pOkjnrYzROo0fDnDnxLg1jPYwiMmsW7LEHTJ/uxq2TtGQJPPqo63UsXgznnQdnnJH88/py3HFwzDHQt6/vJJmbOBF+9zs3/940DkuWuMUnH34Y0ufx/Uy2PQwrGEXkwguhVSu49db8Pacq/Pe/rnA8/7wbsrngAth994bvWygWLHBDcbNmuRVqC401vhufa69113X/5z9r/701vQPha8xy7lz3x3H55Wv/LslMIu4s4hEj3PIj227rhqr23RceecR9WNUmxPFmqD3X2LHuW5qvYpHra5VE4zvE988yOdOmwb33wh13xP/YVjCKxJ13usuFtm3rL0Pbtmu+2Vx5pTsc3mYbN63v88/95cpVIc6Oqsn6GI2DqlsOqF+/+Brd1UUekkovAPgPVa2IP0Z2bEjK+f57d7JdRYX7gA7JlClu7apHHoEDDnDDVQcfvGa5ktDNmwfbbeeah3FOJMi3e+91Z/UPG+Y7iUnSmDHuS1tFRf0n7eZjSKoZ8KKIfCgiV4vI1pk+mUnGoEFw7LHhFQuAnXd2J7vNmgWHH+7OD+nQwW2bP993uoaNGgU9exZ2sQA7wmgMli6FSy+FwYMbXuEhW5ELhqpeBGwJ9MNdo+JjEXlJRE4XkQL/5xSffI9ZLlrk/kD69at7nxDGdlu3dueGTJoEDzwAY8em2HZbty2k2Ts1Xysfa0fVFMf716mTmz23bFnD+0YRwt9UTY090y23wN57w4EHJvccGQ0MqOoqVX1WVU8B9gY2A8qBuSLygIhslUBGU49774WDDoIdd/SdJBoRNzT15z/DRx/BVlu5I4/993fTdHO5Gljc5s51U1KPOMJ3ktw1b+6O9uyM7+I0fbob+k2i0V1dRtNqRWQDoDfwW2A34CngYeBz4ArgIFXdLYGcdeVp1D2Myko3vj5uHHTu7DtN9laudOtWDRkCH38MZ53ljjy29jzoOXgwvPUWDB/uN0dczj4bSktdH8kUD1W30vSBB7rJJlEk3sMQkSeBOcDxwN+BLVX1HFV9XVW/AC4Hts00gMnesGHuRL1CLhbgxlt79YJXXoGXX4YffoDddluzzdd3ghCGo+JkfYzi9PTTbmbiJZck/1yZDEm9Ceygqr9W1ZGq+rMZ9qq6Gnc97kYtX2OWK1e6E/SuXeuitWsrpLHdXXZx3+xnzXKzqS66yF2DePBgWLgwf7m++MINmR16aPLP2ZC43r84C0Yh/U35lHSmZcvWNLrXXTfRpwIya3rfoapzG9hnae6RTBT//KcbjtpnH99JkrH++u4Ssh9+6MZm//Mfd5W7885z25L2xBNu5lk+/hHmS6dObvXSuBrfxr+//hX22st9ucoHWxqkAK1ateZbd48evtPkz5dfwn33uZ8ddnBj8ccdl8wUwr32chehOuSQ+B/bpz32gKFD3WwaU9hmzHCXHaioyLzfZ0uDNCKjR8OGG+bvW0UottzSXYt81ixXLIYMcUcd/fu7YhKXGTPccyQ5PdEX62MUj0sucU3ufE4OsYIRs6THLFXdBZKuvdZNUQ0hUzZyydSsGZx4Irz6qlty/euv3RFX796QSuXWJE+lUjz+uGu453o5y7jE+f7FVTCK7W8qKUlleuYZN5X2sssSefg6WcEoMC+84BreRx7pO0kYOnVyPY6ZM+FXv3I9jk6d3LDLokXZPWYxrB1VFzvCKHzLlrmji0GD8t9jsx5GAVFdsx7TKaf4ThMmVXfFwSFD3P/+5jeueb7LLtHu//HHri/0xReFs95VJiorYeON3RpZLVr4TmOy0b8/TJ7sJmZkqyh7GCKyg4hUisgjvrOEYMIEd/Zx796+k4RLxJ35/tRTbsmRjTZyvZ6qbT/+WP/9R450w13FWCzAXed9p53CWo7FRPfpp26yy513+nn+0P9ZDAHe8R0iE0mOo950k1szKtOx9cY0tlvd1lvDDTe4BvY558DAgVBS4rbNrWWCuCo89FAquOGouF+rOIalGuvfVKbiznTppfCHP8Avfxnrw0YWbMEQkZOB+cDLvrOE4J133Ilkp5/uO0nhWXdd15OYMAGeew5mz3Yr5lZtqxrVfP99t5bVXnv5zZs062MUpmefhalTa79IWr4E2cNIr1k1ETgYOBPYXlV/W8t+jaaHcfzxrqmbj9P/G4P5890FnoYOdcM055/vCnKLFu5kqGL29tvuiKsimCvbmIZUVrqZgPfcE8/qA0V1TW8RuQv4UlVvFZH+NPKCMXmyG4f/9FO7JnPcVq9261UNGeK+wU2cWPhrczWkstL1dr7/3hrfheL6691Kw089Fc/jZVswAplpvoaIlAI9gN2j7N+3b19KSkoAaNOmDaWlpZSVlQFrxg/zebuiooJLL7001sd/4IEyLrkE3n47u/tXbfPxetR1u2Y2n3l69CijRw944YUU48dX0LlzvO9frrertsX5+DvvDMOGpdhll8J//6puDxw40Pu//5q34/g8aNeujLvvhiFDUqRS2b9f5eXlAD99XmZFVYP6AS4FlgBz0z+LgWXAu7Xsq6EZP358rI83Y4bqJpuozp+f/WPEnSkOIWZSDTNXEpnOPFN1yJDs799YXqdcxZHp6KNVb7op9yzVpT87M/58Dm5ISkRaAhtU2/QHoAQ4T1W/rbGvhpY/bueeC5ttBjfe6DuJKSb33OOG3x580HcSU5/nn3czoz74wF0EKy5FMySlbsXbn1a9FZHFQGXNYtEYzJnjTs755BPfSUyx6dLFXa3RhKuyEi6+2J13EWexyEWw02qrqGp/raXhHarqY7u5+tvfoE8f2HTT3B4nzkxxCTEThJkriUy77ea+iFRWZnf/xvI65SqXTLff7t6nww6LL0+ugjvCMM5330F5uTsUNSZu663nrgP//vvFf95JIZo5E+66K7zzZYLrYWSimHsYf/qTW4X1vvt8JzHF6swzoWtXt2CjCctxx7lhw+uuS+bxi6aHYWDBAteUfOst30lMMbMzvsM0bpy7quSjj/pOsrbgexiFJo5x1KFD3bhl+/a554HiG9tNUoi5ksqUS8FoTK9TLjLNtHy5a3TffbcbNgyNHWEEZulSN3b50ku+k5hit9tubm2iysowP5waozvucEuAHH647yS1sx5GYO6+213HYfRo30lMY9C5M9x/vzW+QzBrljvqmzjRraqcpKK8HkZjs2KFm0p3zTW+k5jGomtX62OE4rLL3OKiSReLXFjBiFku46jDh7tlt/fcM748UBxju/kSYq4kM2Xbx2hsr1O2omZ68UU3xfnKK5PNkysrGIH48Ue3rPa11/pOYhoTmynl3/LlcNFFrncZei/JehiBeOwxtwTAhAnuMqPG5MOyZbDJJm6p89A/rIrVLbfAm2/C2LH5e85G28OYPNl3gtytXg033+x6F1YsTD61aAE77GArCvjy+eduCaCBA30niabgC8aBB7oVHUORzTjqs89CkybJTaUr5LHdfAsxV9KZshmWaoyvUzYaynT55W44attt85MnVwVfMMaMgbPOggED1lybuZCowk032dGF8cf6GH7861/w3ntw1VW+k0RXFD2MWbPgqKOgWzd3qc111/WdLLqXX4YLLnBDa02a+E5jGqM333TXNH/3Xd9JGo/ly92Jk3/7Gxx5ZP6fv9H2MADatYPXX4dvvnEXSP/uO9+Jorv5ZvjjH61YGH86d4YpU7Jf6txkbsAAt1qwj2KRi6IoGADrrw+jRrmjjG7d4KOP/OTIZBz1zTdhxgz4zW+SywOFObbrS4i5ks7UogVsv31mje/G+Dplo7ZMX3zhlgC5667858lV0RQMcN/Sb73VLQ1eVgYvvOA7Uf1uusmNXzZr5juJaezsjO/8ueIKuPBC2G4730kyVxQ9jNq89hr07u2Gey66KLyG8qRJblbUp5/a/Hfj35AhUFHh1pUyyXnpJTjnHNezbNHCX45G3cOozf77wxtvuH8Av/89rFzpO9HP3XKLWzvGioUJgc2USt6KFe7IYuBAv8UiF0VbMMDNbX79dZgzB3r2dGezJi3KOOonn7jZUb//ffJ5oHDGdkMQYq58ZKpqfC9fHm3/xvo6Zap6poEDXa/oqKP85clVURcMgA02cKfcd+nimuFTpvhO5PosF1zgGvXGhCCbxreJbvZsuO021+gObXg8E8H1MESkOTAU6AFsDEwHrlHVcbXsm9FaUg89BP36wSOPuOm3Pnz+Oey+O0ybBhtv7CeDMbU54wzYe28491zfSYrPSSfBTt4CDekAABFNSURBVDvB9df7TuIUUw+jKfAF8CtgQ+BPwOMiUpLrA//ud/Dkk3D66W6hPx9uvx3OPNOKhQmP9TGS8fLL8Pbb7stqoQuuYKjqElXtr6ozVXW1qj4LfAZ0iePxu3d3zfB77nFnt8bdDK9vHPXrr2HECNfszqfQx3ZDEmKufGXKpGA05tcpE//+d4qLLnL9i5YtfafJXXAFoyYRaQvsCMS2Lu1228F//wszZ7qprT/8ENcj12/AADjlFNhii/w8nzGZ6NwZPv44euPbNOypp9wV9I4+2neSeATXw6hORJoB44AZqrrWyGqu18NYtcpd4eq55+CZZ9yp+kn54QfXVHz3XbeUiTEh6tQJysvd0YbJ3tdfuyn9AwbAW2+5f/shybaH0TSJMHEQkXWA4cAK4MK69uvbty8l6YvgtmnThtLSUsrKyoA1h6h13Z4wIcXRR8Muu5RxwAFw1VUpunSpe/9cbg8eDHvumeKzz6Bdu/gf327b7Thub7UVTJxYRpcuYeQppNvjx6f48EP473/LGDcO9tsvxe23w/bb+8+XSqUoLy8H+OnzMiuqGtwPIMAwYDzQop79NC7jx6u2bas6dGiujzN+rW2LFqlutpnqlCm5PXa2asvkW4iZVMPMlc9Mgwapnn12w/s19tepusWLVe+9V7VzZ9UddlAdMED1hx/8ZmpI+rMz48/mUI8w7gE6AD1UdVk+nrCszC0nctRR7rT9gQOhaUyvzn33ucffaad4Hs+YpHTpAsOG+U5RGD75BIYOheHD3coSt90GPXrAOsF3hrMXXA9DRNoBM4HlwI/VfnWuqo6osa/GnX/BAjdnevVqePxxaNMmt8errIT27d1V9XbfPZ6MxiRl6VLYdFPXc2ve3Hea8Kxa5f4tDxni1oM780x33kqh9SWL5jwMVZ2lqqKq66lq62o/Ixq+d+423ND9QXTo4E5imjYtt8crL4fSUisWpjC0bOm+4Hz4oe8kYfn2W7f+23bbwV//6s7l+vxzdz2bQisWuQiuYISgaVN3Cv9ll7lDzfHjo9+3qtEE8OOPbhmQa66JP2MmqmcKRYiZIMxc+c4U5XyMxvA6qbrp96ed5mZQTp8Oo0e7bb/9bbQjsBBfp1xYwajHuefCo4/CySfDvfdmfv9HH3XfPvbbL/5sxiSlsZ/xvXQpPPigex1OO82NDsyY4bbtsYfvdH4F18PIRBI9jNpMm+aa4Ycd5q6UFaUZvno17LqrO1I55JDEIxoTmzfegIsvhokTfSfJr+nT3QoQDz8M++zjFgg99NDibGIXTQ8jRDvs4C6n+tFH7hq8CxY0fJ8xY6BVKzdrwphCUlrq/tZXrPCdJHmrVrmTdg8/HPbd130ZfOcdt+2ww4qzWOTCXo6I2rSB5593xWOffdwham1SqRSq7vKr114bxlLGIY6jhpgJwsyV70wtW7rmbn2N70J/nb77zvUXt98ebrzRLdnz+edu27bb+slUCKxgZKBpUxg0yF01a7/94NVXa9/vX/9y6/EUy/oxpvHp0qU4h6Tefhv69HFf/KZMgSeecEt3nH66Xf0yCuthZOmll+DUU92RxFln/fx33bu7hvmpp3qJZkzOBg1yRxjZTPYIzbJl8Nhj7iS7efPgvPPcpQ422cR3Mn+Kbi2p0PXoARMmuJ7GRx+561w0aeK2zZnjTv4zplB16eKav4Xs009dE7u8HPbaC/r3d32JJk18JytcNiSVgx13dIez77/vhp8WLoQrrkhx9dXxLSsShxDHUUPMBGHm8pGpocZ3qK/T6tWu1/jrX7tLMoObsPLcc25bvotFiK9TLgL6WCtMG20E48bBJZe4+doLF7oxUmMKWfXGdyGce7BkCYwc6Zbq2GgjNyX2ySfdtcpNfKyHEaP773eXXu3Vy3cSY3LXp49b6eDss30nqd/s2e4Iv6QErr7aDT+FMDsxZHYeRgDOPtuKhSkehXDG99tvuzXfTj7ZXd2uWzcrFkmyghGzEMcsLVN0Iebylam+ghHC6/TYY64vMXQoXHUVvPqq/0w1hfA6xcl6GMaYWpWWumvDrFgB667rO80aq1fDX/7iZnG9/DLstpvvRI2H9TCMMXXq2BEeeSSc5fmXLnW9lTlz3Mqxbdv6TlSYrIdhjIldSGd8z5njTopt0QJeecWKhQ9WMGIW4pilZYouxFw+M9XVx8h3pokTXUP7hBPcUFRty3jYe5c8KxjGmDp17ep/ptTjj7vVZAcNgn79bBaUT9bDMMbUackS2GwzmD8//41vVbj+enjoIRg71jXhTTxsLSljTOxatXLLfU+enN/G97JlcMYZMHOmW37nF7/I33ObutmQVMxCHLO0TNGFmMt3ptr6GElm+vJL+NWv3LpPqVT0YuH7dapNiJlyEWTBEJGNRWS0iCwRkVki8hvfmYxprPJ5xve777rm9jHHuOm8do2KsATZwxCRR3HF7EygFHgO2FdVJ9fYz3oYxiTstdfg8svdMhxJevJJd62Kv//dlthJWrY9jOAKhoi0An4AdlXVT9LbhgNzVLVfjX2tYBiTsMWL3TkP8+dDs2bxP37VJY3vuw/GjCmM1XELXTGduLcjsKqqWKRNAjp6ypOREMcsLVN0Iebynal1a2jXzjW+q8SVadkyd2XKZ55xze1cioXv16k2IWbKRYgFozWwoMa2BcD6HrIYY0imjzF3Lhx4oDvCSKVgiy3ifXwTvxCn1S4GNqixbQNgUW079+3bl5KSEgDatGlDaWkpZWVlwJrqnu/bVXw9fyHcLisrCypP9dtVQskTwu0uXWDs2BTt28fz/r33HvTsmeLII+HBB8sQyT1v1bYQXq/qt6tn85UnlUpRXl4O8NPnZTZC7mF0VNVp6W3/AL60HoYxfsTZ+B49Gs45xy1L3rt37o9nMlc0PQxVXQKMAq4XkVYish9wDDDcb7Joan6rCIFlii7EXCFkqlrqfOVKdzubTKpw881w8cXussZxF4sQXqeaQsyUixCHpADOBx4CvgHmAefVnFJrjMmf6o3vbJboqKyEs86CqVPhzTdhq63iz2iSF9yQVCZsSMqY/DntNCgrgzPPzOx+X38Nxx4L22wDw4ZBy5aJxDMZKJohKWNMmLKZKTVpkjtzu2dPd0lVKxaFzQpGzEIcs7RM0YWYK5RM1QtGlExjx8Ihh8Ctt0L//skvSx7K61RdiJlyEWoPwxgTmN13hw8/XNP4rosq3Habu37Fc8/BnnvmJ59JnvUwjDGRdejghpY6d67998uXuymzH37ojjC23jq/+Uw01sMwxiSuvj7GN9/AwQfD0qXwn/9YsShGVjBiFuKYpWWKLsRcIWXq0sVdX7tmpg8+cM3tgw6CkSPdhZfyLaTXqUqImXJhBcMYE1ltRxjPPOOOLG66yV1SdR37VCla1sMwxkS2aJG7At78+dC0KdxxBwwcCKNGuSMMUxjsmt7GmMStv747Aa+iwq0FVVHhztz+5S99JzP5YAePMQtxzNIyRRdirtAydekCPXqkWLDALUoYSrEI7XWCMDPlwo4wjDEZOflkaN4c7r/f+hWNjfUwjDGmkbHzMIwxxiTKCkbMQhyztEzRhZjLMkVjmZJnBcMYY0wk1sMwxphGxnoYxhhjEmUFI2YhjllapuhCzGWZorFMybOCYYwxJhLrYRhjTCNjPQxjjDGJCqZgiEhzEXlQRGaJyCIReU9EDvedK1MhjllapuhCzGWZorFMyQumYODWtfoC+BWwIfAn4HERKfGYKWMVFRW+I6zFMkUXYi7LFI1lSl4wiw+q6hKgf7VNz4rIZ0AXYKaPTNmYP3++7whrsUzRhZjLMkVjmZIX0hHGz4hIW2BHYLLvLMYYYwItGCLSDBgBPKyqU3znycTMmTN9R1iLZYouxFyWKRrLlLy8TasVkRSuP1Gb11V1//R+6wD/BDYAjlHVlfU8ps2pNcaYLGQzrTao8zBERICHgBLgCFVd5jeRMcaYKsE0vdPuAToAPaxYGGNMWII5whCRdrjZUMuBH6v96lxVHeEllDHGmJ8EUzCMMcaELchZUsYYY8JTcAVDRC4UkYkislxEyn3ngXCXNRGRR0TkKxFZKCKfiMhZvjNVEZEdRKRSRB7xnQXcLL50nsXpn6m+MwGIyMki8rGILBGRGSJygMcsi2v8rBKRQb7yVMtVIiLPi8gPIjJXRAaLiNf+rIh0EJFXRGSBiEwXkeM8ZKjzs1JEDhaRKSKyVETGp1sCDSq4ggF8CdyIm00VilCXNbkFKFHVDYCjgRtFpIvnTFWGAO/4DlHDharaOv2zk+8wInIIcCtwBrA+0B341Feeaq9Na6AtsAx4wleeaoYC3wBbAKW4f4fn+wqTLlZjgWeBjYFzgEdEZMc8R6n1s1JENgVG4T6nNgYmAiOjPGDBFQxVHaWqY4B5vrNUUdUlqtpfVWeq6mpVfRaoWtbEZ67Jqrq86mb6p73HSID71gzMB172nSVwfwGuV9U3039Xc1R1ju9QaSfgPqQn+A4CbAs8rqqVqjoXeAHo6DHPzsCWwABVXaWqrwCvA6flM0Q9n5XHA5NV9QlVrcQtydRZRHZu6DELrmAUgpCWNRGRoSKyFJgCfAU87znPBsD1wBU+c9ThFhH5TkReF5Eyn0FEpAnQFdgsPaQxOz3U0sJnrmr6AP8I5II0dwEni0hLEdkKOBxXNHyp7YQ4AXbNd5A6dAQmVd1Ir+M3gwhF1gpGzEJb1kRVz8cNZxyAOwxdXv89EncD8KCqfuE5R01XA9sBWwH3Ac+IiM+jsbZAM9w3+QNwQy27A9d5zASAiGyDG/Z52HeWtFdxH3YLgdm4IZYxHvNMwR19XSkizUTkUNzr1dJjpupaAwtqbFuA+5yolxWMGKWXNRkOrAAu9BznJ+nD4teArYHzfOUQkVKgBzDAV4a6qOpbqrpIVZer6sO4IYQjPEaqOnF1kKp+parfAXd6zlTldOA1Vf3Md5D0v7kXcV+GWgGbAhvhej9epJczOhb4NTAXdzT9OK6YhWAxbuml6jYAFjV0RysYMUkva/Ig7pthr/rWwPKoKX57GGW4ZV8+F5G5wB+AXiLyrsdMdVFqH1rIz5Or/oD7gAlhyKem0wnn6GJj4JfA4HSxnwcMw3NhVdX3VfVXqrqJqvbEHb2+7TNTNZOBzlU3RKQV7nOhwSH0gisYItJURNYDmgBNRGQ931Po0qqWNTkqhGVNRGTz9JTM1iLSRER6AqcAr3iMdR/uD7M0/fN34Dmgp8dMiEgbEelZ9bckIqfiZiS96DMX7oPvovR7uRFwKW7mjTcisi9u2C6E2VGkj7w+A85Lv3dtcP2VSfXfM1kislv676mliPwBN4OrPM8Z6vqsHA3sKiK90r//M/B+pCF0VS2oH1xHX2v89PecqV06RyXucK/q51SPmTbDje3Ox43tfgCc7fv9q+W9fCSAHJvhpvguSr9ebwKHBJCrGW7K6Hzc0MbdwHqeM90LDPf92tTIVAqkgB+A73DFbHPPmW5P51kMjAO295Chzs9K3NDwFNzQZwo3/b7Bx7SlQYwxxkRScENSxhhj/LCCYYwxJhIrGMYYYyKxgmGMMSYSKxjGGGMisYJhjDEmEisYxhhjIrGCYYwxJhIrGMYYYyKxgmGMMSYSKxjGxERE2ovI9yKyR/r2lukLMpV5jmZMLGwtKWNiJCJnA5fjLs87GvhAVf/gN5Ux8bCCYUzMRORp3HWmFdhT11xX3ZiCZkNSxsTvftz1mwdZsTDFxI4wjImRiLTGXbxnPHA40ElVv/ebyph4WMEwJkYi8iCwvqqeKCL3AW1U9UTfuYyJgw1JGRMTETkGOAz4fXrT5cAe6Uu+GlPw7AjDGGNMJHaEYYwxJhIrGMYYYyKxgmGMMSYSKxjGGGMisYJhjDEmEisYxhhjIrGCYYwxJhIrGMYYYyL5f9wj41FyDBCoAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "plt.style.use('classic')\n",
    "plt.plot(x, y)\n",
    "plt.title(\"Example Plot\")\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x113fb45d0>]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAGpCAYAAABBIAYhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAMTQAADE0B0s6tTgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdZ1hUZ9oH8P8wdJCm2OgwVAWliPTeNfZEjVETExOzpm7qJrubZHfflE3Z9GTTqxp7R6RKtyGi0jsiIipIbzO8HwiuUVHOMDPPnJn7d135EBzO+VtmuM9T7keQnp4+BEIIIYQQJafBOgAhhBBCyFhQ0UIIIYQQXqCihRBCCCG8QEULIYQQQniBihZCCCGE8AIVLYQQQgjhBSpaCCGEEMILVLQQQgghhBc05XHRzMxM7N69G+Xl5ejq6kJKSgqEQuGor+/p6cHHH3+MzMxMaGpqIiYmBhs2bLjj9xBCCCFEvchlpKWvrw9eXl5YuXLlmF7/4Ycfori4GO+++y5ee+01pKen48cff5RHNEIIIYTwlFxGWqKjowEAhYWFd31tR0cHUlJS8M4778DNzQ0AsG7dOvz3v//F2rVrabSFEEIIIQCUYE1LeXk5AGD27NnXv+bl5YX29nY0NjayikUIIYQQJcO8aGltbYWhoSE0Nf836GNiYgIAaGtrYxWLEEIIIUpGLtNDXAwN3XrItEAgGPX1EokEV65cgZ6e3h1fRwghhBDlMTQ0hJ6eHkycOBEaGtKNmTAvWszMzNDZ2YnBwcHroy2tra0A/jficqMrV67gvvvuU2hGQgghhMjG1q1bYW5uLtX3Mi9aHB0dAQCnT5+Gt7c3AODUqVMwMjKChYXFLa/X09MDADQ0NMDIyAgAcL7tAt44/B4OlKXg2eANeDJwHXS1dBX0O2BvcFCMd7/MwRc/n8D0KRPw8ApPLL9nJowmjP5n0Nc3iENHKrFpVxFScqqxcoE7/v1qNPT1tDnd+5VXXsGbb7453t8CkQH6u1Aet/u76B/sx/tHvsBHOd/goTkrsWRGPDwt3KEpHP1jeEA8gE2nduLdjM+gr62HF8OexJKZCVI/pfJR48Vr+Ojbo/hxeyHC/GzxwoZA+My69WfDjS5f7UJKVjV+2FaIs8c2Y8svXyDI10ZBiclo2tvbYWVldf3nuDTkUrS0t7fj0qVL1xfSVlZWQigUwsLCAp2dnXjuuefwl7/8Ba6urjAyMkJkZCQ++eQTvPTSS+jt7cV3332HhQsX3nbn0MiUkJGR0fWixc3ICL898g2ya47i6T1/xabinXh//htYOCNO5aeQrrR2Y8UTu9F4sR37fngIQb7WY/49r17mi9XLfFHf2IaVT+xAzANbse3L++DsMGnM99fW1r7+90DYor8L5XHz30XB+SKs2/YMACD7mX3wsvQY87WejFiPx0LW4vsTW/BG2vv47MT32LX2e1ibWso8t7LZsucM1j2/B/HhjsjdsxGeM6eN6fuMjIzwqO00PLLKH5Fx2bhv416sX+mNN1+KhJ6elpxTk7sZz89luZTrubm5WL9+Pd577z0AwIYNG7B+/XqUlZVBLBajoaEBfX1911//7LPPwsXFBc8//zxee+01hIaGYu3atZzvG2Q3F8eeOoSXw5/C+u3P4bn9r992zYyqOHW2CT7zvoKRoQ6O7l2P4Lk2Uv1jsLYwQcbWBxEbKsKc+V/ht71n5ZCWEPUzIB7A35LeQfAXC7FoRjyOPXmIU8EyQltTG4/5rUH5i7mYY+WJgM/mo6ipWA6JlcPQ0BDe+Twbj768Dzu+Wo4dXy0fc8FyIw0NDXjOnIaCxMeQf+o8POO/xNFT5+WQmCiKID09nVc/1bu6ujB//nxcu3btjk+VVVdqEfnfpUhwjcKnC99SueHUX3cV4bGX9+HVJ0Pw8sYgmY0o7T1cirV/3o37F7rjg7/HQkfnzoNxSUlJiI2Nlcm9yfjQ34XySEpKQmRUJFZtfhznmsvwy8rPMXv6TJlce2hoCG+mfYT3jnyOnWu+Q7goSCbXVRaDg2I88beD2Hu4DAd+XCVVsXKjkfeFWCzB+1/l4o3/HMGmT5ZiYayLjBKTsWpvb4exsTH2798PAwMDqa6hskULANS1NiDqq3sRYu+Pr5a+B6GGajSqe+XtFHzxywls/mQp4sIdZX792oZWLHtsKyymGmHn18shFKpWwUeIvEkkEqzb9jROnD+N9Md2wtxw7FOuY/XDiS14Ytdf8M29/8GK2Ytkfn0WOrv6sPxP21F3vg0Hf1oFa4tbN2OM1+5DJXjg6Z3Y/c0KRAU7yPz6ZHSyKFpU+qeRjakVMjbsQl7dCazd8iQGxYOsI43bJ98fxTdbCnB07yNyKVgAwNbKFMmb1qCy7iqe/NtBlZ5iI0TWhoaGsHH3y8itPYHk9dvkUrAAwIM+K7Bt9Td4bMfz+DDrK7ncQ5HarvUg9N4f0NM7gOyd6+RSsADAojhXfPnWfCxe/xtyT9TL5R5EflS6aAEAC+NpSH9sJ85cLMHKTY+hf7CfdSSpHUwrx1/eTsGeb1fCyV4+H4QjTE30cPDHVdiVVIp/f5Ej13sRoiqGhobwwoE3kFiaipRHt2Ga0RS53i/eJRKpj27H68nvYseZ/XK9lzxJJBKsemonpkwywKGfH4CJsfS7S8bigSWz8O9XojHvwU0oPNck13sR2VL5ogUApkwwR9pjO1BxuQYvHPgH6zhSKSq5iBUbt+PbdxfC39tKIfe0sTTBwR9X4f8+ycSmXUUKuSchfPZ68rvYfGoXUh7drrDdPT5Ws/Hj8k+wbuszKG4uU8g9Ze219zNQUXMFmz5ZCm1txXTieHzNHPxlYxBiVv2M0soWhdyTjJ9aFC0AMNHADNtXf4sfT/6GXWcPso7DSVNzB+Y/uAkvPR6E5Qtks5hvrDxnTsO2L+7D+pf2IT23RqH3JoRPfjixBV/k/YDkR7dCNMlOofdeOCMOTwWtx5If1+FaT7tC7z1eOxOL8dF3+dj9zQq5j7Dc7MXHg7B+pTeiVv6ES5c7FXpvIh21KVoAQDTJDl8tfQ8Pb3sWtVf5MZfZ3dOPBes2IzzADq88GcwkQ2yYCJ/+MwGL129BcfklJhkIUWZVV2rx9J6/4qcVn8JtijOTDK9HPw/7idZY+9uTkEgkTDJwVVx+CQ/+eTd+/GAx3JwmM8nwrxcjEOBjhUde2Evr93hArYoWALhv1kKsmL0IK37lx/qWR17YC309LXz19j1MG+U9tNwTGx7wwaqndmJgQMwsByHKZlA8iNWbN2Ktz3LEOUcwyyHUEOKXlZ/j7MVSvJn+EbMcY9V2rQeLHtmCp9f5YXG8K7McAoEAX745HyfPNOGbzQXMcpCxUbuiBQA+mP8G+sUD+Evi/7GOckc7E4txOLMK27689679UhThH8+FQyyW4O3PsllHIURp/Cv1P+jo68Q7CX9lHQVm+qbYseY7vJP+CRJLU1nHGdXIwlsn+4l447kw1nFgZqqPHz5YhD//IwmVNVdYxyF3oJZFi66WLn5b9RW+OfYr9hUfZh3ntlrbevCnVw/gozfiMXmSIes4AABtbU18//4ivPVZFopKLrKOQwhzeXUn8N6Rz/HLys+hp6XY9RijmTV9Br5c8i4e2LwRlzqVc4Hp15sKUFzRgl8+WqI0jT+jQxywbrknHnh6JwYHaTRZWSnHvxYGHM3t8eWSd/Hgb0+hoa2RdZxbPPfPJHi7T8f9i9xZR/kDb4/p+PN6fzz45900TUTUWkdvJ1Zv3og3Yl7ErOkzWMf5g1VeSxHmEIAXlXC3ZHNLJ15+OwWf/StB4Qtv7+btl6PQ0dWPNz/NYh2FjEJtixYAWOm5GPNdo/D8/tdZR/mDw0cqsSOxBF++NV8pD3z829OhGBigaSKi3p7e+yrszKzxbPBjrKPc1ocL/omdZw7iSFUu6yh/8Od/JCEqyB4JEU6so9xCT08Lv3y0BG9/lo1jdEaRUlLrogUA3pn3dxwqS0dapXL8AO7s6sOjL+/DO3+JgtV0Y9ZxbktHRxPfv7+QpomI2jpQkow955Lw/X0fKc30xs2sTCzwWvTz+NOul5Rm00FKVhX2p5bjo9fjWEcZlefMafj7M6F44Omd6OkZYB2H3EQ5320KNHXCZPw96jk8vedVDIjZ/wN95Z1U2FiY4NFV3qyj3JHPLAs8+4g/HnpuD00TEbXSP9iP5/a9jn/FvQxLk+ms49zRU0GPQFNDEx9k/Zd1FPT2DuBPrx7Av16IwPSpdz43jrUXNgRigqEOPvw2n3UUchO1L1oA4MnAhyEekuCLvB+Z5sg5Xo9vt5zCN+8uUNqntxv9/ZlQ9PUN0hubqJUv83+CplCI9b4PsI5yV1pCLXy+5B38K+UD1FytY5rlrc+yYWSogz+tmcM0x1gIhRr44G+xeOuzLGo6p2SU/yejAmhrauPDBf/Ea4f/zWy1vVgsweOv7MffnwmFo91EJhm40tHRxIevx+HNT7NwtbWbdRxC5O5qdyveSH4P781/HZpC9m0IxiLQ1hcrPZfg6T1/ZdY8razqMt79Mgf/ffse3pwaH+pvi8hAe7z2fgbrKOQG/PjXowAxTmEIdwjEK4lvMbn/5j1n0N7Zh2ce9mNyf2lFBTvAd5YF3v5cOdYEESJP/0j5AHOtPZk2kZPG2/GvIr/+JPacO6Twew8NDeHxV/Zj/f3e8PZQ7um0m73zShR+2FaIc2XUCVxZUNFyg/fmv47NhbtwvOGUQu/b3z+Iv7+fjn88F64UTeS4evsvUfj0h2NouHCNdRRC5Ka8pQpf5f+Md+e9xjoKZxMNzPBOwt/wzN6/onegV6H33nu4DMUVLfjn8+EKva8sONlPwmMPeOOF/1POfl7qiIqWG9hPtMFzIRvw1J5XFXp2x9ebCqCvq4VViz0Udk9Z8pw5DYvjXPHa++msoxAiNy8e+AcenLMcM6a6sI4ilbXey2Gsa4Rvjv2qsHtKJBL8/f10vPJEMIwm6CrsvrL096dDkVdwHoePVLKOQkBFyy1eDn8SF9qb8dvpPQq5X1d3P/758RH834uRvJnrvZ1/Ph+OzXvO4mxpM+sohMhcWmU2jlTn4Y3oF1hHkZqGhgZej3kBb6d/gp6BHoXcc8fBElxp7caj9yv3bsg7MTPVx9+fDsVz/zwMsZgfB1GqMv7+lJQTfW19vBLxNP6V+oFCRls++jYfdlamWBDD5mRYWbG3McOjq7zxyjvKe94JIdIQS8R4bt9reDXyGZgbTmIdZ1wWzYjHZMNJ+OroL3K/l1gswWsfpOPVJ0Ogq6sl9/vJ08a1c9DTO4DvflPs0gFyKypabuNBn+Xo6OvCjrP75Xqfq63d+PeXOXjr5Uil7HzL1V+fCkFGfi2yjrLdWkmILG0u3IX2vg48Gfgw6yjjJhAI8Hr0C3g77WN098t3x99ve8+iu2cAD6/wlOt9FEFbWxP/fjUaf3svDV3dytGoT11R0XIbOpo6eDFsI/4v9UO5jra880UO5s62RJi/ndzuoUjmEw3wwmOBeOmtZGZbKwmRJYlEgrfTP8bL4U9BR1OHdRyZuMctBpbG0+Tal2pwUIzX/5OBvz0dCm1t/m0uuJ3Fca6wmmaMrzedZB1FrVHRMopHfFehpfMK9hYnyeX6jU3t+OT7o3jzpUi5XJ+VZ9f7obq+FXuSSllHIWTc9pUcRltPO9Z438s6iswIBAK8EfMi/p3xKbr6u+Ryj192FkEsHsKapbPkcn0WBAIB/vJEEN7/Kg/9/YOs46gtKlpGoauli+dD/4R/pf5HLqMG//o4E/OjnHjXt+BuDA108PKfgvDWZ9k02kJ4bWhoCG+lfYQ/h2xQmVGWEfEukbCfaIPPcr+X+bUHBsT4x0dH8NqzodDSEsr8+iwtinWBgb4Wft11hnUUtUVFyx085rca569dQGKpbBeXXrzUgR+2FeL1Z8Nkel1l8chKL5TXXKG1LYTX0qtyUHmlFo/OXc06isyNrG15N+NzdPTKtk3991tPQVtLiPsXucv0uspAQ0MDLz0ehHe+yKadRIxQ0XIH+tr6+HPIBvwz9QOZjhp89uNxRATawc1pssyuqUwMDXTw+AM+ePe/uayjECK1t9M/xhMB62CoY8A6ilzEOIXB2dwBn+R+K7Nr9vUN4l8fZ+K1Z8KgqalaoywjVi12R1f3APYcpilwFqhouYs/+T+Eysu1SKnIlMn1unv68flPx/Hco/4yuZ6yevKhuUjJqkZxObW/JvxzvOEU8upOqMSOodEIBAK8HvMCPsj8UmZrW7bsPQs9XS3cd88MmVxPGWlra+K5R/3x1qc0Bc4CFS13YahjgGeCH8U/U2Qz2vLD1kLYWBojPEA1dgyNZtqUCVi12B3vf5XHOgohnL2d/gkenbsaEw3MWEeRq0hRMKxNLPBLwY5xX2toaAgffpuPZx7243WjzLFYf783ahpakZpdzTqK2lHtf1ky8kTAOpxtLkVm9fh+AIvFEvznm3w892iASvRluZvnHg3Ar7uL0NTcwToKIWNW3FyGxNI0/DlkA+socicQCPB00Hp8nP31uB/Kso7WofZ8G9YsU50dQ6Mx0NfGU+vm0kGxDFDRMgbGekZ4dO5qfJIzvrnffcll6O0bxH3zVXfo9EaujuaICXbAx98fZR2FkDH7d8aneMBrGSyMp7GOohArZi/Cle5WJFccGdd1Pvw2H4/e7w0DfW0ZJVNuT6z1RX7BeRwvbGQdRa1Q0TJGG/zWYH9JMupbz0t9jfe+ysXT6+aq3DbAO3lhQyC++Pk4Ojr7WEch5K7qWhvw2+m9eDFsI+soCqOjqYPH/Nbgo6yvpL5Gdd1VHEirwMa1c2SYTLmZmerjsVU+eOuzLNZR1AoVLWNka2aNeJcIfJn/k1Tff/TUeRSVNGM9jw8Ok0aQrzVcHCbhm80FrKMQclef5/2A+a5REE1S7TVnN3vc/0GkVeWg7JJ0Jxl/+sMxLIpxgbWFiYyTKbc/r/fHwfQKVNRcYR1FbVDRwsETAQ/jm2O/oHegl/P3vv9VLh5Z4QVjI34ezy4tgUCAFzYE4j/f5GFgQMw6DiGj6h3oxffHN+Nx/4dYR1G4qRMm4z6Pe/Bxzjecv7e9oxffbCnAs+v95JBMuVlMM8KiGBf895cTrKOoDSpaOIgQBcHcYCK2Fu3l9H019a3Yc7gMTz+sfm9qYLiLpI62JrbtP8c6CiGj2n5mPybqmyHcIZB1FCaeClqPn05uRWt3G6fv+2FbIdwczeHnZSWnZMrt8dVz8P3WQvT0DLCOohaoaOFAIBBgY8A6fJrzLaeV9h9+m48lca6wsVSvodMRQqEGnnjQF1/8TE8jRHl9kfcDHvd/UC129t2Ot+UseE53x7fHN435e8RiCT7+7iieUdMHMgAI8bPB1MmG2HaAHsoUgYoWjlZ73Yuyliocazg1ptd3dffjh22FePrhuXJOptxWL/HAiaILOFdGzeaI8im8cBanL5xTqYMRpfF08Hp8lvsdBsVjOxDwQGo5evsGsTTBTc7JlJdAIMCGB3zooUxBqGjhaIKuIdb6LMdnud+N6fVb952DjYUx5npayjmZcjMz1ce9893w9WY61p0ony/yfsRKzyUw0TNmHYWphW5xGBoaGvPp9h9+m48nHvRVqx2Rt7Nm6SwUlTSj8FwT6ygqj4oWKWz0fwjbivahuaPlrq/9evNJrL/fW22HnG/06P3e+HH7aZr7JUrlWk87fi3Yjsf91rKOwpymUBMbA9bho+yv7/ras6XNyC84r3Y7Im/H2EgX9y9yp9EWBaCiRQrOk0UItffH18d+uePrzpVdwqmzF/HAYg8FJVNugXOsMX3KBGw/WMw6CiHX/VSwFe7TXOFlSe9TAHjEdxWONxSipLn8jq/7dsspLJvnhomm+gpKptweX+2DX3cVob2D++5SMnZUtEjpiYB1+G/+TxgQjz5q8PXmk7h3vhtMTfQUmEx5CQQCPHq/N/77Kz2NEOUwNDSEL/N+xAYaZbnOVN8Ei2fG47vjm0d9TV/fIH7eeRoPL/dSYDLl5uU+HTOcJuPnHUWso6g0KlqkFO8SCW2h1qhzv729A/hp+2msX0lDpzdavcQDJ4uaaEEuUQpHqnPR3HkZ981awDqKUlk35378XLBt1IeyvcllMDHSRYifjYKTKbc/rZmDL34+Tqc/yxEVLVISagjx0JyV+OH4ltv++o7EEkwxN0SQr7WCkym3kQW5X22iBbmEvS/yfsBDPiugp0WjoTcKdwiEnpYuDpSk3PbXv91SgHXLPWmt3k3umz8DF5o7kH2snnUUlUVFyzis8boXhyuOoKm9+ZZf+3rTSTyywove1Lfx2Cof/LSDFuQStpram7HnXBIe81vDOorS0dDQwIM+K/D9baaI6hvbkJZbg7XLZjNIptz09LTw0H2e+OLn46yjqCwqWsbB2tQSIXZ++PXUjj98vazqMvIKzmPtvap/RLs0AnysMH3KBGrGRJj66eRWhNj7qd05Q2P1oM9yHCpPv+Wh7IdthYgJcYDFNCNGyZTbhtU+2JFYgpYrXayjqCQqWsbpQZ8V+PHEb3+Yw/xmcwEWx7pgkpkBw2TKSyAQ4LFV3jRFRJgZGhrCzwXbsNZ7OesoSsvG1Aph9gH46eTW61+TSCT4fmshLcC9A0e7ifDztMSWvWdZR1FJVLSM0+KZ8ahva8SJ84UAgP7+Qfy4vZB6F9zFA4tpQS5hp6CxCPWtjVg0M451FKW2bs5KfH98y/WHsrScGnT3DGB+lBPjZMpt9VIP/LT9NOsYKomKlnHS19bHfbMW4ocTvwEA9hwuwwQDHYQH2LINpuTMTPWxbJ4bvtlcwDoKUUM/ntyKZR7zYaBNo6F3snBGHFq6riCn9hiA4d4sa5bOUvsOuHdz77wZOFt2CcXl9FAma1S0yMBDPiuwpXA3egd6hxfgrvSChgb90d7N2mWzsGXfWQwOillHIWqkf7AfWwp3YbWXep8zNBa6Wrq433MJvju+GVdbu7ErqQQPr/BkHUvpGRvpYmGMM37eST1bZI1+ssqAv40PJhmY4ae8vUjPq8WapbQAdyzCA+wgwPCQMyGKcqgsHfpaegi1D2AdhRce9r0f24r24tsdR+HtPh0uInPWkXhhzbJZ+GVnESQSCesoKoWKFhkQCARY67McH6b9gGBfa1pVP0ZCoQZWLnTHL7voaYQozs8FW/GA1700GjpGs6fPhNMke3ySugkPL6dRlrGKCXFA/4AYGXm1rKOoFHrXyshqr2Uo6zyNefMsWEfhlQeWeGBnYgm6uvtZRyFq4Gp3K/YVJ2O11zLWUXglxmo+Lhgcx333zGAdhTc0NYVYtcidFuTKGBUtMtJ1WRtomY6uybTNjYvZM6bCxtIEe5JKWUchauC303vgZeEO58ki1lF4pbPYGjC9jObeJtZReGX10lnYfrCYHspkiIoWGfl11xl4G4bjt7M76dwJDgQCAR5Y7EFTREQhfj65Dau9aQEuFxKJBHv218Jnsi+2FO5mHYdXZs+YCjsrU+w6VMI6isqgokUGhoaGsGn3GTwbvxKN7RdxrOEU60i8cv8idyRnVePS5U7WUYgKK2+pQkHjGSyftZB1FF7JOd6A7p4BbAy/H1sKd7GOwysCgQBrls2iKSIZoqJFBvILzuNKWzcWR83EMvd7sJne2JzYWJogwNsKv+2jtv5Efn46uQ3zXaNhpm/KOgqvbN5zBsvmuWGxezyqr9bjTBONGnCxapE70vNq0djUzjqKSqCiRQZ+3VWEZQlu0NXVwvJZC7Ht9F6IJdR7hIsHlnjgF+ppQOREIpHgl4JtWON9H+sovDIwIMa2A8VYucAdhjoGWOAWQw9lHE2faoSIADts2nOGdRSVQEXLOA0MiPHbvnNYtdgDwPCR7oOSQWTXHGWcjF+WJbihsPgiyqsvs45CVFBmTR66B3oQ5xzOOgqvpGRXQ0dbiOC51gCAFbMX47fTu2ndHkdrls3Cj9sK6c9NBqhoGafkrCroaAsR6mcDANAUamKpx3z8VrSHcTJ+MTXRw/xIJ/y6i55GiOz9dnoPlnncA21NbdZReGXznjNYsWDm9Z42cc7haO25hqP1dPwGF4tiXVB7vg1FJc13fzG5IypaxunXXWewcqH7HxpVLfdYiB1F+zEoHmSYjH8eWDw8RURPI0SWBsWD2HnmAO7zWMA6Cq909/Rj16FSrFzofv1rOpo6WDwzgaaIODLQ18Y9Uc7Ytp/W7Y0XFS3j0NnVh91JpVi12P0PXw+ymwstoRbSq3IYJeOnhAhHXL3Wg/yC86yjEBVypDoPGgINBNv5sY7CKwdSKzB9ygR4uU/7w9dXzl6Mraf30Lo9ju6d74at+8/RQ9k4UdEyDnsOl8HWygSz3Kb+4etCDSGWedyDLaeppwEXOjqauHeeGzbtpikiIjvbivZhqcd8CDXoZGIuNu85g5ULZ0IgEPzh6+EOgQBAD2UcxYc54kJzB04XX2QdhdeoaBmHTbvPYNUi91ve1ACwfNZC7Dp7EP2D1AmRi3vnzcCOg8V0yBiRiUHxIHae3U9TQxy1XevBgbSKP0wNjRBqCHHvrAU0RcSRnp7W71NExayj8BoVLVJqbetBclYVlt8z87a/7mftDWPdCUiuOKLgZPwW5m+L/gEx8k7SFBEZv4zqXGhpaCHQ1pd1FF7ZdagUM50nw9lh0m1/feXsxdh55gD6BvsUnIzf7ps/g6aIxomKFintSynDTOfJcLA1u+2vCwQC3OuxAL+dpl1EXGhpCbEo1gXbD9DTCBm/raf30tSQFDbvOYOVC27/QAYMP5SZ6hnjUFm6AlPxX1yYCBdbOlF4jqaIpEVFi5S2HyjG0ni3O75m+ayF2HPuEHoGehSUSjUsS3DDdpoiIuM0IB7ArrMHaWqIo+aWTqTn1WL5HYoWgUCA5bMXUVt/joaniJxoF9E4UNEihY7OPhzOqsKyeXcuWrwsPDDF0ByJpWkKSqYaIgLt0Nndj2OFjayjEB5Lr8qBjqY2AmzmsI7CK7uTSuE72wJW043v+LqVsxdjb/FhdPd3KyiZaqApovGhokUKB1LLIbIxG3W+d4RAIMB9sxZiK00RcaKtrYmF0c40RUTGZevpvVjqPnaAo7AAACAASURBVP8PPZTI3e1MLMHSeNe7vs59qissjachqTxD/qFUSGyoCM2Xu2iKSEr0bpbC9oPFdx1lGbFi9kLsK0lGZ1+XnFOplnvnz8D2g8X0NEKkcn1qaBZNDXHR2taDtNwaLI67e9EiEAiweGYCdp09qIBkqkNPTwsLop2xlaaIpEJFC0dd3f1ITK/EsoSxFS0zp7rCzswKB0qS5ZxMtUQF2aP1Wi9OFl1gHYXwUGplFvS19eBv7cM6Cq/sSymDu8tk2FmP7STsJTMTsK/4MLV24OjeeW7Yuo+miKRBRQtHhzIqYTnNCDOcJ4/5exbPnIfd5xLlmEr16OhoYkG0M7bRFBGRwtbTe7HM/R6aGuJoeGpobA9kAOBjORsTdAyp0RxHcWEiXLrShVNnm1hH4R16R3O042AxliW43bah3GgWz4jHwdJU6mnA0bIEN2w/QFNEhJv+wX7sPpdIU0McdXb1IelIFZaMYT3LCA0NDSyaGY+dNEXEia4uTRFJi4oWDnp7B7AvpRxLE8b+pgYATwt3mOmbILUiS07JVFNMiAMuXaEFa4Sb1MosTNAxxFwrL9ZReOVQRiVsrUzg6mjO6fuWzEzAnnOJdBYRR/fNn4Ft++mhjCsqWjhIzqqG+UR9eM6cdvcX30AgEGDhjHjsoikiTkZ6GtAuIsLFrrOJWDQjnqaGOBrrrqGbBdnOhWRIgty643JIpbpiQx1oikgK9K7mYPvB4YZyXKaGRiyeEY+95w7R0whHy+a5YdsBWrBGxkYikWBfcRIWzYhjHYVX+voGsT+1nNPU0AhNoSYWuMVh5xmaIuJCV1cL8eEi7DlcxjoKr1DRMkb9/YPYm1w25q3ONwu09YVkaAh5dSdknEy1xYWJ0HixA2dKm1lHITxwtKEA/eIBBNv5sY7CKynZ1TAz0eM8ijxiycwE7Dp7gB4uOFoU44I9h0tZx+AVKlrGKC2nBhMMtOE720Kq79cUauIetxjqacCRvp425kU6YsfBEtZRCA/sOXcI812joCnUZB2FV3YmlmBJnKtUo8gAEOkYjNaeayhoLJJxMtWWEOGIc+UtqKlvZR2FN6hoGaMdiSVYEi/9mxoAFs9MwO5zifQ0whE9jZCx2nPuEBbOiGcdg1cGB8XYc7gUS8fYe+p2dDR1MN81mnYRcWRirIcwf1vsTaYporGiomUMxGIJ9hwuxZIxdIm8k2jHEFzqvIyiJlpYykV8+PDTSN35NtZRiBIrvVSB2tYGxDiFsY7CK1nH6qGlJYS/t+W4rkPdcaWzMMYZu5PooWysqGgZg6OnzkMiGUKAj9W4rqOrpYt45wh6Y3NkaqKHkLk22JdCTyNkdHvOHUK0YwgMdQxYR+GVHQeLsSjGZdy7reKcI1B7tQElzeUySqYeFkQ7I+tYHa600sGTY0FFyxjsTS7DvEgnaGoKx32tRb9PERFuFkQ70yp7ckc0NcSdRCLBrkOlUu0aupmhjgFincNoiogjawsTzHKbigOpVOyNBRUtY7A3uQwLop1lcq0El0iUXKpA9ZU6mVxPXSyIdsaR/Fpca+9lHYUooab2Zhw/X4j5rtGso/DK8dMX0N07gDB/W5lcb/HMBOw8c0Am11InC2PooWysqGi5i4qaK6iqa0VMiINMrmeiZ4xwh0AabeHIztoULg6TkJhewToKUUL7ig/Dz9obUyZw6+aq7vYllyEh3BFaWuMfRQaA+a7RKLpYjPrW8zK5nrpYFOuCQxmV6OkZYB1F6VHRchf7kssQ7m+LCYY6Mrvmohnx2H2WihauFkQ70yp7clt7ziViITWU42xfSjnuiXKS2fXM9E0RaDMHB0pTZHZNdeDuMgWTJxkgNaeadRSlR0XLXexLKZfZ1NCIhTPikFd/As0dLTK9rqpbGOOCg+kVGBigrsLkfzp6O5FamY2FblS0cFF3vg3FFS2ICxPJ9Lrz3WKwv/iwTK+p6gQCARbFuNAuojGgouUOrrZ2I/t4Pe6RcdEyzWgKfK08sY/e2Jx4e0yDvq4WMo/SeiDyP4fK0yCaZAtHc3vWUXhlf0o5guZYw8RYT6bXvcc1BmlVOejq75LpdVXdwlhn7Esph1gsYR1FqcmtaNm0aROWLVuGuLg4vPrqq7h69eqor12xYgXCw8P/8F92dra8oo1ZYkYl3F0mw2q6scyvPc81GgdpCJUTDQ0N3ENTROQme87SriFp7Espk+nU0AjnySJYm1gghU615yRojjUGByXIL6D1QHcil6IlMTERP//8M5566il8+umn6OrqwhtvvHHH73n88cexY8eO6//5+vrKIxonew/LbtfQzea7RiO54gh6B2g3DBcLY4aLFuoqTABgQDyAA6UpWOgWyzoKr3R09iE9r1bmo8gj5rlG00gyR5qaQsyPcqLu33chl6Jl165dWLp0KUJCQiASifDiiy+iqKgIlZWVo36PgYEBzMzMrv+nra0tj2hj1t8/iMSMCrkVLe5TXWGmb4oj1Xlyub6qigiwQ8uVLjpAkQAAjlTnwUBbHz6Ws1lH4ZWUrGrYWZnA0W6iXK5/j2s0DpQkQyKhqQ4uRta10EPZ6GRetPT396Oqqgqenp7XvzZ9+nRMnToVxcWjt6//7rvvsGjRIjz++OM4dOiQrGNxdiS/DkaGOlKfeno3AoEA81yjaJU9R7q6WogNFWEv9TQgAPaXJGOea/S4u7mqm+GpIfk8kAFAkN1c9A724cT5QrndQxXFhDqg/sI1lFVdZh1Facn8nd7e3g6JRAJTU9M/fN3ExARtbbc/O2bZsmV4/fXX8d577yEsLAwffPABDhxg26BopKHceA5IvJv5LsNPI1RVc0PdccmIgyUpmOcSxToGr0gkEhxIq5DLepYRWkItxDmHY39JstzuoYoM9LUR7m+HA6nUj2o0Mi9apPkBvGzZMri7u0MkEmH58uVYsWIFtm/fLutoYzY0NIS9yWVym+8dES4KxMWOFpRcovbNXMyLdMSpc01obGpnHYUwVN5ShYZrFxDpGMQ6Cq8cK2zEwIB43Gep3c181xgqWqQwL9IRB9LoZ8JoNGV9QWNjY2hoaKC1tfUPX29ra4OJicmYruHk5IRt27bd8TWvvPLK9XUvsbGxiI2V3UK8opJmXGntRriMWluPRk9LD5GiIOwvSYbbFPkWSKpkkpkBArytsC+lDBtWz2EdhzByoCQFYfYBMNCmAxK52JdcjvhwR5mcpXYn8S4ReHDrU2hoa4SViYVc76VK5kU44dk3knCtvRfGRrqs44xbUlISkpKSAAwvHxkvmRct2tracHBwQGFhIby9vQEATU1NuHjxItzc3MZ0jaqqKkyZMuWOr3nzzTdhZGQ07ry3s/dwGWJDRdDV1ZLL9W80zzUam07txIthT8j9XqpkfpQTDqZVUNGixg6WpmDBDNo1xNW+lDK88kSw3O9zvTtuSQo2+K+V+/1UhZ21KRztzJCcVYVl82awjjNuNw4qtLe347PPPhvX9eSyem3RokXYsWMHsrKyUFlZiXfffRceHh4QiUQoKSnBmjVr0NIy3A323Llz2LlzJ6qqqtDY2Ii9e/diy5YtWLx4sTyijYm8+hfczjyXKOTWHcfV7ta7v5hcNy/CCak5NejtpbM61FFHbycya/Ixz4UOSOSi7nwbSiovy7wL7mjmuUZjfwltfeZqXsTwQxm5lcxHWgAgISEBra2t+PDDD9HZ2Qlvb288//zzAIC+vj40NDRALB5uxa6lpYXk5GR8++23kEgkmD59OjZu3Ih58+bJI9pdNbd04uSZJiREOCrkfpYm0+E+1RVJZRlY6cmuUOMbNydzTDLTR+bROsSEKuYDmCiP5IojcJhoC/uJNqyj8Mq+lDIE+8q+C+5o7nGLwd8P/xtd/V00jcfBvEhHrNi4HRKJhHbG3UQuRQsArFq1CqtWrbrl67Nnz0Z6evr1/3dycsIXX3whrxicJR2phLf7NEyeZKiweya4ROFASTIVLRwIBAIkhDviYHoFFS1q6EBpChJcIlnH4J19yeVy3ep8M2dzEayMpyO1Ipum8jgI9LFGT+8gCs40wWcWrQe6EZVwNzmYVoH4cMWMsoyY7xqNxLI0DIoHFXpfvkuIcKQhVDUkkUiQWJpKW5056ujsQ0Z+rcKmvoGRflTR2EdTRJxoaQkRE+KAA/T5dgsqWm4wOCjG4cwqhU0NjZhjNRuaGkLk1Z9Q6H35LiLQDnWN11BRc4V1FKJApy6cQfdAD4Ls5rKOwiup2dWwtTSBSE5dcEdzj1sMdceVwrwIRxxIpa3PN6Oi5QZHTzVCQ0MAH4/pCr2vUEOIBJdI6mnAkYG+NsL8bJGYTk8j6uRASQpiHEOhJZT/7j5VkphRiQQFjyIDQLDdXHT1d+N00zmF35vP4sMdcfJME5pbOllHUSpUtNzgYFoF4sJEEAoV/8cyzzUaB0uopT9XNEWkfg6WpiDBlaaGuBgaGkJiegXiwxW//ktLqIUoxxAklqUp/N58NsXcEN7u03AoY/Qz+9QRFS03SMyoYPIkAgAxTmEov1yNmqt1TO7PVwkRjsjIr0VX9/ibFhHld6mzBScbixDvTItwuSgub8GV1h6EzGWz2yrWKRyHSqlo4Sohgrrj3oyKlt81NXfgdHEzYkIdmNzfSHcCgu3m4gCNtnDiaDcRVtOMkZ5bwzoKUYDE0jR4WbhjygRz1lF4JTG9AuEBtgppmHk78S4RyKs/gbaea0zuz1fzIpyQdKQKAwNi1lGUBhUtvzuUUQnf2RaYZMaul0CccwQOl2cwuz9f0RSR+jhYmoIE2jXEWWJGJeLD2IwiA4CViQVczEVIqchkloGPvD2mQU9XEzkn6llHURpUtPzuYDq7qaERcc7hSKvMRt9gH9McfDPSr4VOy1ZtA+IBJJVn0FZnjjo6+5B1rI7JepYbxTlH0LoWjjQ0NBAfRg9lN6KiBcDAwPBWZ9Zv6hlTXGCqb4LsmmNMc/BNqJ8NLl3uQklFC+soRI5ya49DT1MXXhYerKPwSlpODWwtTWBvY8Y0R7xLJJLK0unhgqPhU5+paBlBRQuAvJMN0NXRhJf7NKY5BALB8II1ehrhRFdXC5FB9vQ0ouISy9IQ5xxObc05SsxQfMPM2wm0nYNrve0oaipmHYVXooMdUF59BbUNdD4dQEULgOGpofgwkVJ8GMY5hyOpPP3uLyR/MDJFRFTX4fIMxDpHsI7BK8NbnSsRr6ADEu9ER1MHkaJgmiLiyNhIFwHeVkg6UsU6ilJg/1NaCbBo3T+aKMcQlFyqQENbI+sovBIfLkLWsXq0d/SyjkLk4GLHJRQ1FSPaMYR1FF4pqWjBpctdCPWzZR0FwPC6liQqWjiLDXWgfi2/U/ui5XzTNRRXtCAmhM1W55uZ6BnDz9obSWUZrKPwiq2VKZzsJyIlu5p1FCIHh8sz4GM5CxMN2K7L4JvE9EqEB9hCT085ugfHOYcjp/Y42ns7WEfhlbgwEVJzqmnrM6hoQWJ6Jfy8LGFqopij2sci1jkcSeX0NMJVfJgIien0NKKKksrSEeMUxjoG7yjLepYRtmbWEE2yo63PHM2eMRW6OprILzjPOgpzal+0HExjv9X5ZnFO4UiuyMSAeIB1FF6JDRUh6Ugl7U5QMWKJGIfLjyCO1rNw0tnVh6xj9UqxnuVGtPWZOw0NDcSE0BQRoOZFy8CAGKk51YhTsje1l4UHdITaOFpfwDoKrwT7WuPy1W6UVl5mHYXIUEFjEQYlg/C18mQdhVfScmpgPd1Y4ac63028cwRtfZZCXNjwQ5m6U+uiJb/gPHR1NDF7xlTWUf5AQ0MDsc7hOFRGu4i40NXVQqifLb2xVUxSeQaiHUOgKdRkHYVXEtMrmfeeup1gu7m42t2Kc82lrKPwSkyIA06du4hLl9X71Ge1LlqSjlQiJsRBKbY63yzWKZxW2UshJsQBhzNpa6AqGV7PEs46Bq8MDQ0p3XqWEbpaugh3CEQiHaDIyeRJhpjlNgXJWeq92UD5flor0OHMKqXZNXSzGKdQnLpwFpc6qcsrF7GhDsjIq0VvL60HUgVtPdeQX38Ssc5hrKPwSlnVZTS3dCFMSbY63yzOJYKaaEohLpSmiNS2aLl8tQsnzzQhOlg5ixZzw0nwsnCnrc8cuTqaY6KpPrKP0wFjqiC1MgvO5g6wMrFgHYVXko5UIdTPRmm2Ot8s3jkS2bXH0NnXxToKrwxvNqiCRCJhHYUZtS1aUrNrMNN5MqZNmcA6yqhif1+wRsZOIBAgNtSBukeqiKSyDMTS1BBnyjyKDAD2E21gY2KJI9W5rKPwir+3Jbp7BnC6uJl1FGbUtmhJOlKJ2FDlfVMDIy39MyCWUEMhLmJpCFUlDA0NIak8HbHOVLRw0dc3iIy8WqUuWgAgyikEh8uPsI7BK9ramogMtFPrzze1LFqGhoaU/kkEAOZaeUE8JEZBYxHrKLwSGWiHc+UtaGqmrpt8VnqpApe7riLEzo91FF7JK2iA8QQdzHCezDrKHcU4hiG5gooWrmJDRWrdr0Uti5bi8hZcbetB0Bxr1lHuSFOoiShRMJLKM1hH4RUzU33MmTWddhHx3KGydITa+0FXS5d1FF45fGT4gUwgELCOckfhDoGouFyN+lbq8spFbKgDck40oKOzj3UUJtSyaDmcWYVQP1vo6irnIrUbRTmGIoWGUDmjKSL+O1yeQVudpcCHUWQAMNYzgp+1N5KppT8n9jZmsLMyQVpODesoTKhl0cKH9Swjop1CkFt3Ah296t1QiKvYUAckZ1Wr9Sp7PusZ6MGR6jzE0XoWTlqudOHUuYuICrZnHWVMoh1DkUwjyZyp80OZ2hUtvb0DOJJfx4snEQCwM7OBrakVrbLnyHe2BQYGxSg408Q6CpFCZnU+JhtOhLO58nV0VWap2dWY5TYFkycZso4yJjFOYUipzKLNBhzFhjrgkJqes6Z2RUvWsXpMMtOHq6M56yhjFuUUgsO0YI0TTU0hIgPtaeszTx0uz0C0U5jSr8tQNnyZGhrhYzkLkiEJbTbgKMzfFo0XO1BZe5V1FIVTu6Jl5E3Npw/DGMcwOspdCrGh1NKfr1IqMhHtGMI6Bq/wZVfkjTSFmogUBdHWZ44MDXQQ4G2FZDX8fFO7ooVP61lGjKyyb2hrZB2FV2JDRcg92YD2jl7WUQgHFzsu4VxzGSJFwayj8EpJxfCuyEAf5d4VebNoxzBa1yKF6GB7tTyHSK2KlqbmDpwrb0FkED8WqY0w1jPCXCsv6mnAkY2lCRxsTJGeW8s6CuEgpSITntNnYqKBGesovHI4swph/rbQ0eHXadi02UA60cEOSMutweCgeq0HUqui5XBmFXw8pmOiqT7rKJxFOYYgpZymiLiiU5/5J6XiCKKcQlnH4B2+TQ2NGNlskEGbDTjxcp8GoYYAJ4ousI6iUGpVtCQdqeTlmxoAop1CkVKZSVt4OYoOdkBKtvoNofLV0NAQksszEe1IRQsXfGndP5pop1AaSeZIKNRAZJA9kjPV6/NNbYoWiUSClOxq3r6pfa080S8eQOGFs6yj8EqYvy2q61tR39jGOgoZg+LmMrT1tiPQdg7rKLySc6IeZiZ6vNoVeaMYpzAk02JczobXtajXSLLaFC1nSi+hp3cQfl6WrKNIRUuohXCHQNr6zNEEQx3M9bRQywVrfJRckYkQOz/oaOqwjsIrfNwVeaNwh0BUXalFXWsD6yi8Eh3sgLyC82rV0l9tipbkzCqE+tlAS0vIOorUoh1DkUJFC2fRwQ5IoaKFF1IqjiCKtjpzxtf1LCOMdCcMt/SndXuc2FmbwsbCGEfya1lHURi1KVpSsqsRHczfNzUwXLRk1xxDd3836yi8EhVkj5Rsaumv7PoH+3GkOg/RtAiXk0uXO3G6uJk3rftHM7yuJYN1DN6JDnZQq5FktSha+voGkXm0DlE82+p8M9EkO0w3moLMmnzWUXjFd7YF+voHUVTSzDoKuYO8uhMw1DaA+1RX1lF4JTW7BrPcpmCSmQHrKOMS4xSGlApq6c9VdIh6rWtRi6Il92QDTIx04ebEz0VqIwQCAaIcQ6l7JEdaWkKE+dmq1dMIHyVXZCLKMYS36zJYUYVRZOB/Lf1PNZ5hHYVXIgLsUFZ1BeebrrGOohBqUbSkZFUjKtheJT4Mo51CaF2LFKJDaF2LsqP1LNwNDQ0hOauK96PIACDUECJCFISUyizWUXjFxFgPc2ZNV5vPN/UoWrKrVeJNDQCRomAUN5ejqZ2mOriICrJH5tE69PYOsI5CbqO1uw0nzp+mooWjytqruHSlC0Fz+NW6fzSRomCk0jlrnKnTuhaVL1pa23pwouiCyhQtZvqm8Lb0oEZMHLmIJmGiqR5yT9KWSmWUVpUNl8kiWBhPYx2FV1KyqhHoYw09PS3WUWQiUhSM7Npj6BnoYR2FV6KD1WezgcoXLel5NXARTcL0qUaso8hMpCgEaTSEyolAIEBUkHoeMMYHyeWZiKIuuJyp0igyADiZO8DcYCJyao+zjsIrfl6W6Orux9myS6yjyJ3KFy0pWar1pgZ+P4eoIgtDQ0Oso/AKrWtRXikVRxBNU0OciMUSpOXWqNTn2/Bmg2Ck0BQRJ9ramgjzt1WLlv4qX7QkZ1Ujmuf9C24WYOODq91tKL1UwToKr0QG2qHgbBOutFKfG2VSfaUODdcuINQ+gHUUXik40wRg+OA8VRIpCqF1LVIYXtei+lufVbpoqW1oRe35NoT62bKOIlO6WroIsvNFKk0RcTJ18gS4OZojPbeGdRRyg5SKTPhbe8NQh999RhQtJbsaEQF2EApV62M80jEYpy6cxZWuq6yj8Ep0sHpsNlCtf+03Sc2pgZ+nJSYYqt45JpGiYCpapDB8wJjqD6HySWplJiJpaogzVVvPMmLqhMlwm+KE9Koc1lF4xdXRHKbGqr/ZQKWLluTMKt63th5NpCgYGVW5GBQPso7CK1HB9rSuRYlIJBKkVeYgUhTMOgqvdPf0I/t4vQp/vg2v2yNjJxAIEBlkh9Rs1R5JVtmiRSKRIDVHtRap3cjTwh0aAg2cbCxiHYVXQubaoKHpGqrraOhZGRRdLEa/uB9zrGazjsIrOccbMNXcECJbM9ZR5CLKMRiplbSuhavIQHuk5qj2Q5nKFi1FJc3o6x+E72wL1lHkQqghRLhDIK2y58jQQAf+XlY0RaQkUioyEWrvDy2havQZUZSRqSFV6PJ9OyF2/qhrPY/aq/Wso/BKZJAdThRdwLX2XtZR5EZli5bkrGqE+dlCS0vIOorcRDoGU78WKUQFqf7TCF+kVWYhgqaGOFPV9SwjJugaws/aG6mV2ayj8IrlNGM42JjhSH4t6yhyo7JFy8h5Q6osShSCnNrj6O6nLbxcRAbZIS2nRi26Ryqz/sF+ZFbn03oWjq60dqPw3EVEBNqxjiJXkY7U0l8aUUHD3XFVlUoWLX19g8g6VqfSTyIAIJpkhykTzKl7JEdzZlmgr1+MohI6v4ml/PqTMNQxwMypLqyj8Ep6bg1mOJljirkh6yhyFeUYgtTKLHq44CgyyA6pOaq7GFcli5a8ggaYGOnC1dGcdRS5EggEiBQFI4UWrHGipSVEmL8t7SJiLLUyC5GiYJVdlyEvqj41NMLXyhM9A704c7GEdRReCfOzRWnlZTQ1d7COIhcqWbSkZtcgItBOLT4Mh09FpXUtXEUGqvbTCB+kVWbTehYpqMPUNwBoCbUQ5hBAmw04MjPVh9fMaUhT0SaaKlm0pOXWIDJQ9d/UwPC8byF1j+QsMnC4e2R/P/W5YaGjtxNH6wsQ5UhFCxc19a2oa7yGkLk2rKMoRKRjCG19lkJkkJ3KjiSrXNHS0dmHY4WNKr9IbQR1j5TOTJfJMDTQxtFTjayjqKXMmjzYmFrCxtSKdRReSc2php+nJQwNVK/L9+1EiYKRWZ2PvsE+1lF4ZaRfiyoeqqtyRUvm0TrYWBjDxtKEdRSFiRAFU/dIjgQCASIC7GjrMyOpNDUkldTsGkQGqccDGQC4TXHGBB1DHK0vYB2FVwLnWKH5chcqa1VvBF7lipbU7GpEqsEitRtFiahfizTUoeW1skqtyKSpIY6GhobUauob+P3hQhRE56xxpK+njUAfK6Sq4NZn1StacmoQqSZTQyNC7P1R01qPulbVPihL1iID7ZF/6jw6u2joWZEudbbgXHMZwh0CWUfhlXNll9DZ1Y+5nqrZ5Xs0EaJgpFGTOc4iA1WzX4tKFS2XLnfibNklhAeoV9FipDsBc628aIqIIztrU1hNN0LWMWoVrkhplTnwmOaGSQYTWUfhldScGgT7WkNbW5N1FIWKFAXhaH0BOvu6WEfhlcggO6Tn1qpcnxuVKlrSc2vh7jIZ5hMNWEdRuAhRENLpaYSzyEB7lRxCVWYpFZnUBVcK6jj1DQC2ZtawMpmOrJp81lF4xcdjOgbFEhSeu8g6ikypVNGSmlOtVvO9N4oQBSGtKlslV4vLE/VrUby0yixE0noWTgYHxThytE7tpr5HRIiCaV0LR5qaQoT52arc55tqFS1qtrL+Rv42PmjraUfJpXLWUXglItAORSXNuHyVhp4VofpKHRrbLyLYbi7rKLxy8kwThBoCzJ4xlXUUJiJFwUivpLYOXA1vNlCtkWSVKVpqG1pRf0F9mi7dTEdTB0F2vrRgjaPJkwwxw8kc6bm1rKOohZSKTPhZe8NAW/2mcMcjNbsa4QF20NBQmY9sTsIdAnG66Rw10eRopIlmX5/qNNFUmXdAWk4N5npaqE3TpduhVfbSGWnEROQvvSobEaIg1jF4Rx13Rd5oygRzaqIpBTcncxgb6SK/4DzrKDKjMkXL8JtaPdezjIgUBSGjOhdiiZh1FF6hfi2KMTQ0hLTKbFqEy1Fv7wByTtSr5SLcG0WIgpFWRQ9lXIw00VSlc4hUomgZaboUoWZbnW/mZeGBoaEhnGo8wzoKr4T62aL2DKzdpQAAIABJREFUfBvqG9tYR1FpZy+Woqu/G75Wnqyj8EruyQZMMtWHk716bxGPcAhCWgUVLVxFBNohTYUW46pE0VJc3oJr7b3w87JkHYUpoYYQYQ4B9DTC0QRDHfjOtqDRFjlLq8pGsJ0ftDW1WUfhFXU6tf5OQu39UXW1FufbLrCOwiuRgXYq1URTJYqW1JxqBPvaQEdHvZou3U64QxCta5HC8NZnWtciT+mVtJ5FGurcyuFGxnpG8LGcRVufObK1Gm6ima0iTTRVo2hR463ON4sUBSGr5ij6B/tZR+GVkSFU6nMjH4PiQWRU51LRwtG19l6cKLpAn2+/C3cIQjqNJHOmSutaeF+0DDddqlX79Swj3KY4w0jHEPn1J1lH4RU/T0u0XutFWdVl1lFUUkFjEYQCIWZPn8k6Cq9kHq2Dg40ZLKcZs46iFCJFwUitpCaaXA3vkKSiRSmcOnsRAoEAnjOnsY6iFEZORaUpIm50dbUQ5GtN61rkJLUyG2EOARBqCFlH4ZXUnGp6ILtBgK0PLnddRXlLFesovBIeYIvCcxdxtbWbdZRx433RkppTjXB/WwiFvP+tyAyta5GOKg2hKpv0qmw61VkKNPX9R3paegiw8aHNBhxNnTwBrqJJyMivZR1l3Hj/kz4tZ3hlPfmfSMcg5NefRFc/tabnIiLQDum5NSp3KiprfYN9yK45Rv1ZOGpu6URxRYvanVp/N8NNNGkxLleqsvWZ10VLX98gso/X0/DpTezMbH4/FfUo6yi84u0+DWLJEE4XN7OOolLy6k7AVM8YLpMdWUfhlfTcGni4TsFEU33WUZRKpCgY6VW59HDBkaqMJPO6aDl66jyMjXTh6mjOOorSoSki7jQ1hQida6NyB4yxlvb7Vmd17zPCVVquerfuH42P5SwMiAdwuukc6yi8EuZvi7KqK7hwsZ11lHHhddGSmjPcBZc+DG8VSecQSSUiUDWeRpRJelUOwkW0noUrmvq+PU2hJkLt/enzjSMTYz14zZyG9Lxa1lHGhddFC72pRxcuCkThhbO42t3KOgqvRATaIfNoHQYG6PwmWejs68LR+gJaz8JR3fk21DVeQ7Cvep5afzfUr0U6w+es8XskmbdFS1d3P/JPnaf1LKOYOmEyXCc7IqMql3UUXpnpPBl6ulo4VtjIOopKyKrJh7WJBWxMrVhH4ZW0nBr4zrbABEP1PbX+TiJEQciszseAeIB1FF6JCLBDKs+baPK2aMk90QDLaUawszZlHUVphYuCaGsgRxoaGsML1lRglb0ySK3MQjh1weWMDoC9M/eprtDR1MGJ86dZR+GVIF9rNF3qQE09f0fgeVu0ZB6tpUVqdxEpCkY6zftyRutaZCe9MoemhjgaGhqiqe+70NDQQLhDAJ1DxJG+njb8vax43R2Xv0VLfh09idxFqL0/ylqq0NROW3i5iAi0Q+7JBnT30PlN43Gl6ypON52jpnIclVdfwZW2bvir+an1dxNBD2VS4Xu/Ft4WLadLm6np0l2Y6BnDy8KdVtlzJLI1w+SJBsg90cA6Cq9lVOfCdbIjpkyglgRcpOXUINDHGrq6WqyjKLUIURBy606gZ6CHdRReifx9JJmv61p4W7Q42plh2pQJrGMoPVrXwp1AIBh+Y/P4aUQZDPdnoakhrui8obFxnGSPSQZmyKujw2G58J1tgc6ufpwtvcQ6ilTkVrRs2rQJy5YtQ1xcHF599VVcvXp11NdevXoVf/3rXxEXF4elS5fil19+uev1w/zoTT0WEQ5BNIQqhYhAO17P+yqD9KocRNAiXE4kEgnSc2vpvKExEAgEiHAIpJFkjrS1NRHsa430PH5+vsmlaElMTMTPP/+Mp556Cp9++im6urrwxhtvjPr6N954Ax0dHfj000/xzDPPYNOmTTh48OAd7xEyl/oXjEWQnS/OX2tCzdU61lF4JTzADieKLuBaey/rKLx04dpFlLdUIdTen3UUXikqacbAoBg+HtNZR+GFcBH1a5FGZJA9b0eS5VK07Nq1C0uXLkVISAhEIhFefPFFFBUVobKy8pbXVlVVoaioCM8//zxEIhGCg4OxbNky7Ny58473CPShvg9jYaBtAD9rb6RV5rCOwitW043hYGOKzKNU7EkjvSoH3pYeMNEzZh2FV9JyahAy1waamkLWUXghwiEIxxpOob23g3UUXokIsENGfi3EYv6d3yTzoqW/vx9VVVXw9PS8/rXp06dj6tSpKC4uvuX1paWlMDc3h5XV/4oQLy8v1NTUoK+vb9T7mNEhYmMWLgqkKSIpRAbaIzWH390jWUmtzEK4A00NcUX9WbixNrWEnak1smryWUfhldkzpkIgEKDgTBPrKJzJvGhpb2+HRCKBqekfm76ZmJigra3tlte3trbCxMTkltdKJBJcu3ZN1vHUUqQoGGlV2bxdLc4K37cGsjI0NIS0yixaz8LRwIAYR/LrqD8LR+EiOhyWK6FQA2F+trzsRyXzooV+MCqfudZeuNbbgZJL5ayj8EqYvy3Oll3CpcudrKPwSs3VejR1XEKg7RzWUXjlRNEF6GgL4eE6hXUUXolwCER6FU1/c8XXhzJNWV/Q2NgYGhoaaG39Y5vgtra2W0ZUAMDU1PSWEZi2tjZoaGjA2Hj0+fBXXnkF2traAIDY2FjExsbKIL1q0tHUQZCtL9Iqs+E2xZl1HN4wn2gAd5cpyMirxX33zGQdhzfSKrPhZ+0NA20D1lF4JS2nBuEBdtDQ4G0nCibCRYFYtflPuNJ1FRMNzFjH4Y2IADu89GYy+vsHoa0t81LguqSkJCQlJQEYXj4yXjJPqq2tDQcHBxQWFsLb2xsA0NTUhIsXL8LNze2W17u4uKClpQXnz5+HpeVwB8hTp07Bzs4OOjqjHxb25ptvwsjISNbxVdbwKvscPBH4MOsovDLSiImKlrFLr8qmqSEppOXWYFnCrZ+R5M4mG5pjxhRnZFTnYqn7fNZxeMPNyRxGE3Rw9FQjguW4G/fGQYX29nZ89tln47qeXEr6RYsWYceOHcjKykJlZSXeffddeHh4QCQSoaSkBGvWrEFLSwsAwMHBAR4eHnjvvfdQWVmJ7OxsbN++HUuWLJFHNLUV4RCIjKpciCVi1lF4ha9DqKwMr2ehooWr3t4B5Jyop/UsUqJ1LdwJBILfT33m12YDuRQtCQkJWLVqFT788ENs3LgRurq6eO211wAAfX19aGhogFj8vx+er732GgwMDPDEE0/ggw8+wMqVK5GQkCCPaGrLy8ID4iExCi+cZR2FV0Lm2qC6/v/bu++wqK78f+DvmQGkSa+i9CoIIooovYM9Gk000STGxOxuYoqJG9OTTWJMMc24xphNjJoYY2+IVKkqFlQE6U0EQVGa1GF+f7D6W7827jAzZ+7M5/U8eZ51mLn3nbDg59xzzudcR+1lWhQ+GIVXitHa3Y6Jo8axjsIrOadqYWqkC1dHU9ZReCnCiYoWafBxUCa3iawnnngCTzzxxF2vjx07FmlpaXe8ZmJigk8++UReUQgADZEGQh0mIbUsC34jfVjH4Q2D4doY7z0CqdmVeGruWNZxlF5qeRaCHSZCS0OLdRReuXWqs0AgYB2Fl0IdJ6HsWiXqWuphY2jNOg5vREx2wN/fPoiOmz3Q0+XHzyyt+FIjES7B1D1SCpGBjrzcGshCWlk2neoshdScSkTS1JDUDHUM4GfjTbuIOHKwNcYIy+HIzqthHWXQqGhRIxFOQcisPI6evqGv4FYntx6h0nb+BxP3i5FekYNIOiSRk9a2LpzIr6NT64doYF1LJusYvHJrXQufBmVUtKgRT0s36GrqIO9SPusovDLZbxQar3WgrOr+h34S4EzdeUgkEvjajGEdhVcyT9TAfqQR7Ebe3RKCDN6tdS00uOAmItABKVlUtBAlJBQKEe4UiJRSGo1woaOjicl+o3i3YE3RUsuzEOY0GSIhnZvDRWp2JSKDHFnH4L1A+wloaGtCBR0Oy0nEZAecLqjH9RudrKMMChUtaoZORZVOZCD/tgYq2sB6FtrqzFVKdgWdNyQDulq6mGTnR4MyjkZYGcDV0ZQ3h8NS0aJmIp2DkVt9Cjd7brKOwisRgQ5Iy6lCfz//TkVVhJ6+HmRWHkOEMy3C5eJqcwfOFV1B+GR71lFUQrgTDcqkwad1LVS0qBknU3tYDjdHdlUe6yi8MsHHBp1dvSgobmQdRSmdqD0D/WF68LR0Zx2FV9Jzq+DlZgELM33WUVRCxH+bzNHgghs+9WuhokXNCAQCRDoHIZVGI5xoaooQMtGONz/YipZSlolwp0DqM8LRrf4sRDb8R/niZm8nLlwpZh2FV8Im2aOwtAlXmpT/cFgqWtRQuBNtDZRGZKAjFS33MdC6n7Y6c5WSXUnrWWRIS0MLwQ4TaVDGkamxLrw9LJHGgykiKlrUUIRzEE5dOocbndSanouIQAccPV6Nvj46v+l/dfR04FjNKerPwtGl+haUVTUjNMCedRSVEu4UhFRajMvZwGYDKlqIErIxtIaLmSOOVuSyjsIrPqMtIRIKcOp8PesoSiWr8gRGGFjCwcSWdRReScupwnjvETA00GYdRaVEOgfjaGUu+sR9rKPwCl/WtVDRoqYi6FRUzoRCIcInOyAli7Y+/6/U8oGpIVrPwk1KVgWtZ5EDnxGeEAlEOFV3jnUUXgmZaIeayy2oqr3OOsoDUdGipiKo5bVUIgP5szVQUVJLM2lqiCOJRELnDcmJSChCmNNkGpRxpK83DBN9bZR+ioiKFjUV5jgZRY2luNLWxDoKr0QEOiA7rxZdXb2soyiF6zdv4MzlAjokkaPyqmZcudqByeNHsY6ikiKoiaZUIiYr/xQRFS1qylTPBD7WnjQa4cjNyQwmRjrIOVXLOopSSK/IgbuFM6wNLFlH4ZWU7EpMGjcSujparKOopAinIGRVnkBXbxfrKLxy60R7ZT6/iYoWNRZB/Vo4EwgEiAxS/tGIogz0Z6HW/VylZlciMpDOG5IXdwsXGOsY4ljNKdZReCVg3Ei0tHahsER5n8BT0aLGIpyDkEZPWjiLDHRU+nlfRUkry6L1LBz19/cjLZeaysmTQCCgzQZSGDZMA0ETbJV63R4VLWos2CEANTfqUNVcwzoKr0QGOSDvbB1a29T70fPllgYUN5Uj1HES6yi8UlDciJudvZjgM4J1FJUW7hxIRYsUIoMclXqHJBUtakx/mB4m2o6jKSKORlobwsnOBEeP8eNUVHlJK8/GOJsxMNY1Yh2FV1KyKhEy0Q5aWhqso6i0CKcgnKg9g7Yu5W9Nr0wiAx2QfqwKYrFynt9ERYuai3AOQmopFS1cRUx2QEq28o5GFCGlLJNa90shJbuC1rMogL2JLWyNbJBRSU00ufD1soZAIMBpJW2iSUWLmotwGliMq8yrxZVRZJADUrKUd95X3iQSCVLLMhHhTItwuejtFePosWpEBtF6FkWIcA5GCk0RcSISCREWYK+0gzIqWtRcgJ0fWrraUNRYwjoKr4RPduDNqajyUNFcjfq2RgTZ+7OOwit5Z+ugPUwD3h60RVwRIqmJplSUeYckFS1qbpjGMATZ+yOFfrA5MTXWhc9ofpyKKg8ppZmYZOsHXS1d1lF4JSVr4FRnoZB+9SpChHMQChouorFdebfwKqOIyQ7IyqtBd7fynd9EPzmEtgZKSZ23Pqf997whwk1yVgVNDSmQub4Zxlh5IK0sm3UUXvFwMYeRgTZyTytfE00qWgiiXEKQXp5Dp6JyNHCUu3LO+8pTf38/UsuyEOlCRQsXHTd7kHu6lhbhKliEcxCta+FIIBAo7anPVLQQjB3hBaFASKeichTkb4vay62orFHuU1Fl7cKVYtzs7cSEkWNZR+GVrBM1GGE5HI52xqyjqJVI52CklGWwjsE7AzskqWghSkgkFCHCOZDWtXCkrzcMAb4j1e5pS0pZJoIdJkJLg87N4eLWVmeBQMA6iloJcZyE2huXUdms3n2VuIoMcsSJ/Dq0tXezjnIHKloIgP9uDSyl0QhX6rj1OaU0A1Euoaxj8E5KdiUiqXW/wukP00OArR9SqB8VJ3YjjWBnY4iM48pV7FHRQgAAUc4hyK7Kw82em6yj8AofTkWVpV5xL45W5NJ5Qxxdu34T+RcaEBlE61lYiKCtz1KJCla+lv5UtBAAgLOZAyyHmyO7Ko91FF6Z6GuD9o4eXChuZB1FIU7UnoGOpjbGWHmwjsIraTmVGO1iDktzfdZR1FKkSzBSyjLR36+cremVVVSQI5KpaCHKSCAQ/HfBGo1GuNDS0kDIRDulXLAmD8mlGYh0DqY+IxylZFXSVmeGJo4ah46emyi4cpF1FF4Jn+yACyVNaGhsYx3lNvrNQ26LpHUtUokMdFC60Yi8pJRmItIlhHUM3qHzhtjS0tBCqOMkpJTSoIwLU2NdjPW0Uqqtz1S0kNsiXYJx5nIBmm+q1xbeoYoKdsTRY1Xo7RWzjiJXbV3tOFZzCpF03hAntZdbUFFzHaEBdqyjqLUI52Ba1yKFqCDlaqJJRQu5zWq4BTwsXJBWTt0jufD2sMQwLQ2cyK9jHUWuMipzYWc8EvYmtqyj8EpKVgUm+NjAYLg26yhqLdIlGEcrctEr7mUdhVeighyRlFmuNJsNqGghd4igdS2cCYVCtZgiSinLQqQzTQ1xlZxVgSjaNcSct9VoaGsOQ15tPusovBI0wRaN1zpQVtXMOgoAKlrI/xHlEkLzvlKICnZEcqaKFy2lGYii1v2cSCSSgf4stAiXOaFQiHCnQCTTuj1OdHQ0ETjeVml+v1HRQu4Q6jgJFc3VqLl+iXUUXokOdsKxM5eUrnukrDS0NeLClWKEOwWyjsIrRaVNaGntwqRxo1hHIQAinUNoXYsUlGnrMxUt5A4G2sPhP8qXpog4shtpBPuRRkrXPVJWUsuyMHaEF0z1TFhH4ZXkrAoE+9th2DAN1lEIBta15NacQkdPB+sovBIZ6IC0nEqIxez73FDRQu4ysMqeWl5zFRWkulNEyaUZdKqzFJIyKxAdTOtZlIWjiR1sDKyQWXmcdRRe8fMegX6JBGcK6llHoaKF3C3qv4txlWW1OF9EBSvPI1RZkkgkSCnLRBQtwuWkt1eM9NwqRFHRojQEAgGiXEKRVHKUdRReEYmEiJisHJsNqGghdwmw80NLVxsKrxSzjsIr4ZPsUVjahPorytM9UhbKrlbiSlsTAu0nsI7CK8fPXIKOtga8PSxZRyH/I9o1hBbjSkFZ1rVQ0ULuMkxjGEIcApBEP9icmBjrYpyXNVKy2f9gy1JyWQYC7SdAV0uXdRReScoc2OpMRx4olwinIFy4UoyGNvU4L0xWooIdkZVXg85Otn1u6KeJ3FOkC7X0l4Yqbn2m1v3SScosp/4sSshUzwS+I7zoaQtHLg6msDDVQ86pWqY5qGgh9xTjGob0ihz09PWwjsIrtx6hqsp6IHG/GGnl2YhypkW4XLS0duFEfh2tZ1FSUa6hNCjjSCAQIDKQ/RQRFS3knsZYeUBfSw+51SdZR+GVwPGjcO16J4rLr7KOIhNn6s6jX9IPv5E+rKPwSnpuFZzsTGBrY8Q6CrmHaJdQJJVmqMzgQlGU4UkyFS3kngZW2YfQuhaOtLU1Eexvy3w0IitJpRkIdwqESChiHYVXkjLLaauzEptsNx7XO1tQ1FjCOgqvRAY64HRBPZqv32SWgYoWcl9RLiFILqWtgVwpw2hEVpJLjyLaNZR1DN5JzqpAdLAT6xjkPrQ1tRHsMJEGZRxZWQzHaBdzpOawO/WZihZyX9EuoTh56Syu37zBOgqvRAU5Ii23Cn19YtZRhqSjpwNZVScQ4xrGOgqv1F5uQVlVM8Im2bOOQh5g4Jw1Klq4iglxQhLDQRkVLeS+RhhawcPCBanl1B2Xi7GeVtAQCZF39jLrKENytDwXIw2t4WRqzzoKryRllMN/rA0MDbRZRyEPEO0SivTyHPSK2W7h5ZuYECckHi1jth6IihbyQFEuoThC3SM5EQqFiAxyQFJmOesoQ5JUmoFolzDWMXiHpob4YYyVB3S1dHCs5hTrKLwSPNEW9Y3tKKtqZnJ/KlrIA0XTuhapRAc78X5dS1JpOmJoPQsn/f39SM6qoP4sPCAUChHlHEIt/TnS1dFCsL8tjhxlMyijooU8UKjTJFxqqUf5tSrWUXglOtgRuacvobWti3UUqVy6cRkXG8sQ4RzEOgqvnCu6gs6uPgSMG8k6ChmESJdgajInhZgQJxzJoKKFKCE9LT0E2k2g0QhH9qOM4WhrjLScKtZRpJJclgH/Ub4w0jFkHYVXkjMrEDbJHpqatEWcD6JdQpF3KR8tna2so/BKTIgT0nIr0dur+M0GVLSQh4pyDaXRiBRiQ9mNRoYqqYS2Okvj1nlDhB9GGo2Ai5kj0sqzWUfhFW8PS+hoa+L4mUsKvzcVLeShol1CkFKWiT5xH+sovMLyEepQ9Pf3I7k0A9EuVLRw0dXVi4zj1dRUjmcGmmjSk2QuhEIhooIcmfx+o6KFPNQ4G28IBUKcvHSWdRReCZtkj+q6G6ioZrPKXlpn6y+gq68bE23HsY7CK9kna2FipAMPF3PWUQgH0S70JFkarAZlVLSQhxIJRYhyCabRCEf6esMw2W8U7562HClJR4RzEDRFmqyj8Eri0TLEhDhBIBCwjkI4CHWchMrmGlQ117COwivRwY7IO3sZ1290KvS+VLSQQYmi0YhUYkOdeVe0JJdmIMolhHUM3kk8Wo7YUOrPwjcG2sMx2W489aPiaISVAZOW/lS0kEGJdglBbvVJtHW1s47CKzEhTkjJruRNS/+bPTeRWXkcMdRUjpP6K20oKG5EdAgVLXwU4xaOxJI01jF4JzpY8etaqGghg2JvYgt741FIr8hhHYVXfL2soKUpwvEzdayjDEpG5TGMMLCEs5kD6yi8ciSjHH5jrGFqrMs6CpFCrGsYUsoyqaU/Ryxa+lPRQgYt2jUUR0rSWcfgFaFQyGQ0Iq2kkqOIcgmldRkcJR4tQ2yoM+sYREq+I8ZgmEgLx2tOs47CKyEBdgpv6U9FCxm0OLcIJBbTI1Su+LT1Oan0KLXu56i/vx9JmRW0noXHhEIhol1CkUiDMk5utfRPUuDvNypayKCFOwWi+sYlaunPUXSwE/LO1il8lT1Xl1saUHilhFr3c3T6fD16+8TUup/nYt3CcYTWtXAWHazYQRkVLWTQ9IfpIdhhIj1t4cjG2gDuTmZIyVbuAxSTyzIwfqQPTHSNWUfhlcSj5YgMdISGBrXu57MY1zCcunQOVzuusY7CKzEhTkjNUVxLfypaCCexruFUtEiBD1ufE4vTEOMaxjoG7wysZ6GpIb6zHG4Ob+vRSCqh1g5c+Iy2hPYwDRw7rZiW/lS0EE5i3cKRWp6F7r5u1lF45da6FkWusudC3C9GYkk64t0jWUfhlda2LuSevkSLcFVEjGsYTRFxJBQKERvqjMPpZYq5n0LuQlTGGCsPGAwbjuyqPNZReCV4oi0amtpRWqmcj55PXjoLiUQC/1G+rKPwSmp2JZzsjGE30oh1FCIDsa5hSCxJV9rBhbKKC3PG4aNUtBAlJBAIEEuNmDgbWGVvh8SjyjlFlHAxBTGuoRAJaV0GF4dpq7NKCbT3R1t3O87VF7KOwisxIU7Iv9CAhsY2ud+LihbCWZwbrWuRRmyIk8IeoXKVWJKGWLdw1jF4RSKRUOt+FaOloYUIpyAalHFkbqoHvzHWChmUUdFCOItyCUFBw0VcbmlgHYVX4sNdkJZTia4u5eq6ebXjGvJq8xHrSkULF6WV13D5ShtCA+xZRyEyFOMWRk00pRAf7qKQQRkVLYQzE11j+I/ypdEIR6NdzWFmooujx6pZR7lDUkkGvK1Hw9rAknUUXkk8Wo5gf1vo6WqxjkJkKNY1HFmVJ9De3cE6Cq/Ehw/skBSL++V6HypaiFQGGjGls47BKwKBAFMiXJCQXso6yh0SS1JpakgK1LpfNTmbOWCkoTXSy7NZR+GVCT42AIC8s/I9Z42KFiKVOLcIHCk5CnE/P04vVhbxYS5ISFOedS39/f04XJyGeLcI1lF4pbu7D2k5VbSeRUXFuIVRS3+ORCIhYkKc5P77jYoWIpXxI30gEAiQV5vPOgqvRAQ6oLL2OsoVeMDYg+RfLkBXXzcm2Y1nHYVXsk/WwHD4MIxxpyk1VRTnGkFPkqUQFyb/fi1UtBCpiIQiRLuE4HBxKusovDJcfxiC/e2UZooooTgVUc4h0BRpso7CK4dSSxEf7kKnYauocKdAVF2vpXPWOIoNdcLJc5fRdE1+64GoaCFSo34t0pkSrjxTRInFtNVZGgdTSzElwoV1DCInw7X1EewwEYcuJrOOwitWFsPhM9pSrkeWUNFCpBbrGo6Tl87iWodyTHXwRXy4M1KzK9HZyXbr843OFuTWnEQcFS2cVFQ3o6yqGdHBjqyjEDma4h6FhIsprGPwTnyYfLc+U9FCpGZtYAkvS3ckldIBY1x4uJjDwkwPR49VMc2RXJoBd3NnjDKyYZqDbxLSyhDsbwuD4dqsoxA5muIeibTyHHT00NZnLuLDnZF4tAz9/fLZ+kxFCxmSOPcIJNAjVE4EAsHAFBHj7riHaWpIKgdTSzA1wpV1DCJnbubOsDGwQloZbX3mImDcSPT0inH6fL1crk9FCxmSqe5RSChOpa3PHMWHOyMhjd1iXIlEgsSSNMS70anOXNzs7EFaThWtZ1EDAoEAUzyicJAGZZxoaIgQHSy/rc9UtJAhCbD1Q79EQlufOYoIdEB1XQvKGJ36XNBwETc6WxDk4M/k/nyVllMFa0t9uDubsY5CFGCKeyQSLqbQqc8cxYU5y22HJBUtZEg0RBqIcw3HgaIk1lF4RV9vGIL9bZlNESUUpyDcKRDDNIYxuT9fHUotxRTa6qw2whwno6mjGReuXGQdhVfiQp1xIr8Ozdd6W99yAAAgAElEQVRvyvzaVLSQIZviEUVbA6UwsPWZzRTRwaJkTPWIZnJvvpJIJDiUVoqpkbSeRV1oa2oj0jkIB4vo9xsXNtYG8HS1kMupz1S0kCGLcwvH+YYiXLpxmXUUXhk49blK4Vufr3U0I6c6D9OoaOGkqLQJV5raEUanOqsV2vosnWmRrjiQUiLz61LRQobMRNcYk2zH4xD9YHPi7mwGS3M9pCt46/Ph4jR4W42GjaG1Qu/Ld4dSSxER6AAdHeoerE6muEciuzoP12/eYB2FV6ZHuyIhrRR9fbLdpCHzoiUhIQELFixAbGwsXn75ZdTW1j7w/a+88grCw8Pv+GfHjh2yjkXkjKaIuBMIBIgPc8GhVMVOER0sSsJUjyiF3lMVHPzvehaiXmyNR8LDwgVJpUdZR+GVCT420NAQIufkg2sArmRatJw+fRpfffUVFixYgPXr18PExAQrV65Eb++DH38/+uij2Llz5+1/pk2bJstYRAGmeUQhuTQDXb1drKPwyrSogUeoitqd0CvuRUJxKk0NcdTS2oWsvBra6qym4t0jaVDGkUgkxNQI2U8RybRo2bNnD8LCwjBt2jQ4ODhgxYoVuHr1Ko4fP/7Az2lra8PExOT2P9ra1GmSbzwt3WGmZ4L0ihzWUXglYrIDGq924EJxo0Lul111AtoawzB+5FiF3E9VJGdVwNXRFPajjFlHIQxMdY9CwsVUuXV5VVW3BmWyJNOipaioCL6+vrf/rKOjAw8PDxQVFT3wcwcOHMDMmTOxZMkSbN++HWIxNSrjG4FAgKke0bT1mSMdHU1EBztiX1KxQu53oCgJUzyiIBTScjYuDqaU0NSQGptsNwE94l6cvET9qLiIDnZEWVUzyqtkdz6dTH9z3bhxA8bGd45EDA0Ncf369ft+Jjo6Gu+++y6+/vprzJo1C1u2bMGmTZtkGYsoyFT3KBwqSqZGTBzNiHbD/mTZr7K/l4NFyTQ1xFF/fz8S0sswNZKKFnWlIdJArGsYdcflyGC4NsIC7GX6tEVjMG9as2YN9u/ff9+v+/j44JtvvpEqwNSpU2//b0dHRwiFQqxduxbPPPMMNXDimXDnQFxpv4qixhKMtnRjHYc3pka64vk39+NKUzsszfXldp/SpgpUNtcg2iVUbvdQRWcKGnCzsxeB421ZRyEMTfGIwtrsn/FhzArWUXhlWpQr9iUV4+VnA2RyvUEVLc8//zwWLlx4369rag5sATQyMrrrqUpLSwtsbAZ/iqyrqys6OzvR0tICIyOj+77vrbfegpaWFgAgNjYWsbGxg74HkQ8dTR1EOgfhQFESFS0cWJrrY7z3CBxMKcHix8fJ7T4HipIQ7hQI/WF6cruHKtqXVIzYUCdoaopYRyEMxbmFY/H2V1DfegXWBpas4/CGgcYlpB36ES++eArA0NcEDWp6SF9fH+bm5vf951Zx4eHhgfz8/z/n19XVhaKiInh4eAw6UHl5ObS1tWFoaPjA93366adYs2YN1qxZQwWLEpny3ykiwo0ipogOXqStztLYe+QiZsa4s45BGLPQN8dE23G0bo+jpxc9CvfxTyA0bik+/fTTIV9PpmtaZs6cibS0NBw8eBCVlZX4/PPPYWpqiokTJwIAmpqasGjRotsLc+vq6rBlyxaUlJSgvr4eqampWL9+PWbNmkVTQzw11SOKGjFJYXqUG45klKOrSz7dcVs6W5FRcYzWs3BUVXsdF0qaaBEuAQDMGB2LfRcOs47BO9NluItIpkWLn58fXnvtNWzevBlLly7FtWvXsGrVqtvTR2KxGLW1teju7gYwMK2Ul5eH5cuX4+mnn8amTZswb948PPvss7KMRRRolJENPC3dkFiSzjoKr3i5W8DCTA+pOZVyuX5iSRrcLZxhb0LrMrjYn1yCkIl2MDbSYR2FKIGZnnFILstEe3cH6yi8Mi3SFYdSSyEWD316aFBrWriYMmUKpkyZcs+vWVlZIS0t7fafLSws8O2338o6AmFsmkcM9hcm4vGxs1hH4Q2BQIDp/12wNiVC9gfyDXTBpacsXA1MDdH6LDLA3cIF9sajcKQkHbPHTH34BwgAIGDcSPT3S3DybN2Qr0XNGojMzfKMw8GLyejp62EdhVemR7nhQLLsu+OK+8U4dJG64HJ1o6UTR49V03oWcocZnrHYeyGBdQxe0dAQYUqECw6nlw35WlS0EJnzG+kDg2HDkVaezToKr4QG2KG1vRtnCuplet3jNacBAAG2fjK9rqo7lFoKT1dz2I28/y5Gon5mjo7DwYsp6BP3sY7CK9MiXZFARQtRRgKBADM947CHRiOcaGlpIC7MWebdcfcWHsYU9wiIhLRll4u9R4rpKQu5y0TbcdAQipBV9eDjacidYkOdUFJ5bcjXoaKFyMUsz3jsu5BIZ3VwJOutzxKJBHsKEjDL697rzMi9dXf3ISG9lNazkLuIhCJM84jB3guJrKPwipGhDlb+I3jI16GihchFiGMAOvu6cKL2DOsovBIf7oKzhQ24VN8ik+sVXinGpZZ6xLqGyeR66iI9twqGw7Xh62XNOgpRQjM947Cv8DAdWcLRGy8EDvkaVLQQudAUaWKaRzRNEXFkaqyLwPG2OCCjpy27Cg4hzi0culq6Mrmeuth75CJmRLtRvyhyT1EuwbjS1oSChouso6gdKlqI3MzyjMdeasTE2YxoN+xJlM0vwz0FCZjlGS+Ta6kLiUSCfUnFNDVE7ktHUwexbuHYW0i/3xSNihYiN7FuYai+fgkXG0tZR+GV2fEeSM2pxI2WziFdp6q5BucbimirM0enzl1GW0cPwibZs45ClBh1x2WDihYiN3paeoh2CcEe+sHmxMHWGF5uFkNekLu7IAHhToEw1qUtu1zsPVKM+DBnaGnJvPcmUSFTPaJw5nIB6lpk26KAPBgVLUSuZnrFYU/BIdYxeGdO/GjsPFQ4pGvsuZCAWV40NcTVwNQQbXUmD2amZ4pAuwnYV0i7iBSJihYiV9M9YnCq7hyNRjiaHe+BxKPlaO/olurzV9qakFOdR+tZOKqqvY6isibEhzuzjkJ4YIZnHPbR1meFoqKFyJW5vhkm02iEMw8XczjYGuFQqnTrgfYVJsJ/lC+sDSxlnEy17UooQliAPYwM6YBE8nAzPeOQWp6Fls5W1lHUBhUtRO5oF5F0BqaIiqT67J6CQ/SURQp/HSzE3GmerGMQnnAytcdoC1ccKEpiHUVtUNFC5G6mZxzSyrNxo1M2DdPUxZwpHjiYWoLOzl5On2vpbEVyWSYeoS64nNRebsHJc5cxK5bWs5DBe9R7Ov46t491DLVBRQuRO0dTO3hYuOBgUTLrKLziM9oKlmb6OJJRzulzhy6mwN3cGc5mDnJKppp2HCxEaIAdzE31WEchPDLXezoSS9LR2tXGOopaoKKFKMQjXlOw8/wB1jF4RSAQYM4UD+xM4LaLaHfBQXrKIoW/Dl7A3Kk0NUS4cTV3gpu5E/YXHmEdRS1Q0UIU4jGfmUgoTqXRCEez4z2wL6kYPT19g3p/Z28nEopTqWjhqPZyC/LOXsYjcTQ1RLh71Hs6dpzfzzqGWqCihSiEu4UL3MydaBcRR/5jbaCvq4XU7MpBvT+5NBOW+ubwth4t52SqZVdCEUIm2sHCTJ91FMJDc8dMx+HiNBqUKQAVLURh5nrPwPaze1nH4BWhUIjZ8R7YdXhwu4j+OrcPj3hNoYP+OBqYGqJCj0jHzcIZrmaONEWkAFS0EIV5zGcmjpQcpV1EHM2JH409iRchFvc/8H2dvZ3YU5CA+WMfUVAy1VBX34rjZ+owO96DdRTCY3N9ZtAUkQJQ0UIUxtnMAV5W7thzIYF1FF4J8reFQCBA5onqB77v0MUUWBtYwtdmjIKSqYadCYUI9relqSEyJDRFpBhUtBCFmus9HX+dpZ4GXIhEQsyKdceOgw/eRfRn/h485jOTpoY4+utAIe0aIkN2a4qIGs3JFxUtRKHm+cxAclkmrnU0s47CK49N98RfBwvR1ye+59fbutpxoCgZj4+dpeBk/Ha5oRXHzlyiqSEiE9RoTv6oaCEK5WBiB98RXthdQFNEXIQG2EMkFNx3F9G+wkS4mjtitKWbgpPx286EIgRNsIWlOU0NkaGb601TRPJGRQtRuLneM2g0wpFIJMTjM7ywdc/5e359W/5uPOZDT1m42nGwkHYNEZlxt3CBi5kDTRHJERUtROHm+cxAWnk2mtqvso7CKwtmjcGuhKK7ziJqvnkdR0qP4jGfmYyS8VP9lTbknKqlqSEiU4+OmY4d52gXkbxQ0UIUbpSRDfxH+WLn+YOso/CKn/cIjLAcjgMpJXe8vuv8IfiO8IKjqR2jZPy0/cAFBI4fBSuL4ayjEBUy13s6df+WIypaCBNzfWiKiCuBQIAFs8bg9/8zRfTn2T14nHqzcLZl1zksnOPDOgZRMR6WrnA3d8auAhqUyQMVLYSJuWOmI7PyOBraGllH4ZX5M71wKK0U1290AgAa2hpxtCIXc72nM07GLxfLmlBQ3IhHp9B6FiJ7C/3mYvOpv1jHUElUtBAmRhhaYbLdeHrawpGroxm83S1vt/X/69w+BNpPgI2hNeNk/LJ55znMiHaDoYE26yhEBc0f+wgyK4+j9kYd6ygqh4oWwswC3znYcnoH6xi8s2DWGGzdfQ4A8Gf+Xto1xFF/fz+27D6HJ2d7s45CVJS1gSUinYOx9cwu1lFUDhUthJl5PjNwvv4iiq6UPPzN5LbHZ3gh80QNjhcX4UTtGcwZM5V1JF7JPF6Dm529iAtzZh2FqLCBKaLtkEgkrKOoFCpaCDNGOoaY6RmLTae2s47CK9aWwxEaYId/7fkZkc7BMNc3Yx2JVzbvOovHZ3hBU1PEOgpRYbM841B74zJO151jHUWlUNFCmHpq/GPYcnoHxP33bk9P7m3+DC+k1B3GIr95rKPwSmdnL/46WIiFNDVE5ExXSxdzxkzFZpoClykqWghT0S6hkEgkSC7NYB2FV0Z5d6Fb2IrRuhNYR+GV/cnFsDLXx4SxNqyjEDXw5Li52Ja/G73i3oe/mQwKFS2EKZFQhCfGzcFvNEXEyY6i3bCXjMeuA6Wso/DK5l3nsHC2N52ETRQizGkytERaOFKSzjqKyqCihTD3lN887C5IQEtnK+sovHCz5yb+PLsHfwtciE078tHf3886Ei80XetA4tEy2jVEFEYkFGGB72zaJSlDVLQQ5jyt3OFl5Ybt1LNlUHaePwhbIxu8PGs6urr7kJxZwToSL/y5vwABviNhP8qYdRSiRhaOexR7LyTSoExGqGghSmGR3zyaIhqkX09uw9PjH4eWlgaenjsWG7edZh2JFzbvpN4sRPE8rdzhYeGCHecPsI6iEqhoIUph/thHkFebj7KrlayjKLXK5mpkVZ3Ak+MeBQA8+/g47D1SjKZrHYyTKbfi8qs4W9SAuVM9WUchamih31xsOU1t/WWBihaiFEz1TDDNI5p6tjzEryf/xBT3SFgONwcAuDiYYtK4kdi88yzjZMrt522nMTPaHcZGOqyjEDU0f+wjyKk+icrmatZReI+KFqI0FvnNw+ZT22lh6X309/dj08k/8fT4x+94fcn8cdi47TR13ryP7u4+/LI9Hy8sHM86ClFTlsPNMc0jGj8d38o6Cu9R0UKURrx7BDp7u3C0Iod1FKWUWp6Frr5uTHGPvOP1OfGjcflKG3JP1TJKptx2JRTBxEgHYZPsWUchamxpwCL8J+939PT1sI7Ca1S0EKWhKdLEE+MexcYTNBq5l1/ztuHJcY9CU6R5x+s6Opp48hFvbPyDFuTey/otJ7H0CT/qzUKYinIOwfBh+thdcIh1FF6jooUolb8FPIWd5w/iSlsT6yhK5UZnC3YVHMIz/2dq6JYl88fhz/0X0NrWpeBkyq2wpBEn8uvw1NyxrKMQNScUCvH8xIX48dhvrKPwGhUtRKm4mDsizGkyfjqxhXUUpfJH/m54W3vA08r9nl8f62kND2czbNtXoOBkyu3Hracwd9pomBrrso5CCJ4e/xhya07hYiN1spYWFS1E6fx90jPYcGwz+sR9rKMoBYlEgnU5v+D5gIUPfN9zC/zw0+80RXTLzc4ebNqRjxeepAW4RDmY65thjtdU/HhsM+sovEVFC1E6Uz2iIBIKsa8wkXUUpZBWno2GtibMH/vIA983f6YXCkubkH+hXkHJlNv2/RcwytoQk/xGsY5CyG0vTHoKm079iZs9N1lH4SUqWojSEQlFWBrwFNbl/sI6ilL4Pnsjnpv4JHQ0H9xjxGC4NuZN86SnLf+1fstJvPDkeFqAS5RKoL0/bAys6NgSKVHRQpTSsxPmI7sqD0VXSlhHYaqyuRoJF1Pxt0lPDer9f180AZt25ONGS6eckym3MwX1OH+xkdr2E6UjEAiwNGARLciVEhUtRCmZ65thnvd0rMv9lXUUpn7I+QUzPWMxyshmUO+fMNYGvp7W+EnNtz//uPUk5s/0gqGBNusohNxl4bi5OF9fhDN151lH4R0qWojS+vvkxfjt1Ha0dbWzjsJER08H/pP3B14MfJbT5159LgDf/3Icvb1iOSVTbm3t3di6+zwtwCVKy1DHAPN9Z9OCXClQ0UKUlv8oX7iaOWLLmR2sozCx5fRO2BuPQpD9RE6fmxnjDg0NIXYeKpRTMuW2aUc+3BxNMd5ncE+nCGHhhYBF2HpmB1o6W1lH4RUqWojSEggE+PvkZ7Au5xe1O1dHIpHg++yNeCnwWc4LSUUiIV55NgBrfspVu/9ufX1ifLUhF68vncw6CiEP5DfSBz7WnthwnJ62cEFFC1Fqj4+dhfq2RmRU5LKOolCpZVlobL/60G3O9/PMPF8UV1xDzkn1Oo9o+/4LEAiAR6eOZh2FkIdaEfYivs78EV291Ml6sKhoIUpNR1MHz/ovwJqM9ayjKNTANueF0NaUbiHpcP1heH6BH9b8pD7FnkQiwefrs/H685OhoSFiHYeQh5rmEQ0TXSNsPq2eU+DSoKKFKL1Xg5ciuSwT5+rVY41GxbVqJBSn4m8Bg9vmfD8vPeOPAyklqKhullEy5XbkaDkuX2nDM/N8WUchZFCEQiFWhL2IL4+ug7hfPRfOc0VFC1F6VsMt8MyEx7Eq9VvWURTim6wNmOUZh5FGI4Z0HVsbI8yO88B3vxyXUTLltvrfWXjp6YnQ0dF8+JsJURLzxz6Crr5uOv15kKhoIbywIvQf2HPhMIoby1hHkavLLQ3YeHwrVka8LJPrvbokAD9vO4OWVtWeM8/Lr8OJ/Dr846kJrKMQwommSBOvhbyAz9PXqvzCeVk8TaKihfCCrfFILPCdjdXp37OOIler09ci3j0CY0d4yeR6/r4j4TPaEj/9fkom11NWn6/PxnPz/WBCpzkTHlrivwAVzTVILctiHUVuxP1ihK+fPeTrUNFCeOPNsJfwR/4eVDXXsI4iF/WtV7DxxFa8G/WaTK+74oVAfPVTLm529sj0usqitPIa9icX47XnJ7GOQohU9LT08FLgs/g8fS3rKHKz9cxOtHQNvScNFS2EN1zMHTHbawo+P/oD6yhysTp9LWJdw2T2lOWW6dFuGGVtgLW/npDpdZXFlz/m4LHpXhg1wpB1FEKk9uLkxciuOoFTl86yjiJzveJefJj0Jd4Mf2nI16KihfDKyohl+DXvT1xuaWAdRabqW6/gp+NbZP6UBRho0vfxGxFYvS5b5da2NDS24bcdZ/EGNZMjPGeqZ4IlE59Uyactv+RtwzCNYZjnM3PI16KihfCKl5UH4tzC8VXGv1lHkanP039AjGsofG3GyOX60SFO8HKzULm+LZ+uzURMiBO83C1ZRyFkyF4LXop9hUdU6nT7rt4ufJzyNT6Ifh0i4dD7J1HRQnjnrYiX8eOx33C14xrrKDLR0NaIDcc3472o5XK7h0AgwCcrIvD1xlxcbe6Q230UqbTyGn76/TRWvRnJOgohMmFrPBJL/J/AyoRPWEeRmQ3Ht8BE1wiPjpkuk+tR0UJ4Z/yosQh2CMDn6aqxtuXz9B8Q7RIit6cstwT52yFwvC1Wr8uW630UZeVnyVg4xxujXS1YRyFEZt6Leg3pFTlIL+f/z2lHTwdWpX6Lj2L+CaFQNuUGFS2Elz6Nfws/5PyC8mtVrKMMSUNbI3489ptcn7L8r4/fiMAPm07gcgO/T5bNPVWLw+ll+PC1cNZRCJEpc30zvBm+DG8c+BD9/f2s4wzJDzm/wNbYBtNHx8jsmlS0EF7ytRmDBb6z8caBD1lHGZKPU75GtEsIxo30Vsj9/LxHID7cBZ98n6mQ+8mDRCLB6x8fwetLJ8PacjjrOITI3MtBS9DYcQ1/5O9mHUVqrV1t+Dz9B/wr9k3OJ9U/CBUthLc+jn0TqeVZSCnl51/AZ+rO45e8bfh86nsKve9Hy8Px85+nUVV7XaH3lZXdh4tQXt2M12nHEFFROpo6+CRuJd4+/Ck6eztZx5HKN5kb4GnphmiXUJlel4oWwluWw83xTuSreHX/u+gT97GOw0l/fz9e3LMSrwQ/D1dzJ4Xe29PNAnOneuKdL1IVel9Z6O0V481VyfjwtXDo6w1jHYcQuVkwdjbM9EzxXdZG1lE4u3TjMr7K+Dc+jpPtUxaAihbCc8sCl6C7rwc/ndjCOgonm079ibqWerwVsYzJ/T/9ZyT2JRUjJauCyf2ltWHrKWhoCPHs43SSM1FtQqEQX0x9D6vSvuPdTslle9/GI17xCHYIkPm1qWghvKaloYUvp32A9xI/x/WbN1jHGZTrN2/gn4f+ha9n/At6WnpMMowaYYhPVkRi6Zv70dnZyyQDV61tXfjwm3SsXhkNDY2h93sgRNmFOwchxCEAHyWvYR1l0PYUJCCz8ji+nPaBXK5PRQvhvWke0fAb6Y0Pk79iHWVQ3j2yGuNH+mCWZzzTHH9fNAFmJrr46NujTHMM1lurU+DpaoFpUa6soxCiMKunvIuNx7eioKGIdZSHau1qw0t738KX096HmZ6pXO5BRQvhPYFAgDXTP8SGY5uVvpPk6Uvn8EveNnw74xOZz/VyJRIJ8dPqGfj252M4V6TcxyIkZ5Zj046z2Pj5DOb/3QhRJA9LV7washSLtr2Enj7lPvT0ncTP4GrmiEV+8+R2DypaiEoYbemGpQGL8Oxfr6JXrJzTHbcW374W8gJczB1ZxwEAjPGwxKtLJmHJG/sgFitnT4iW1i4sfn0vvng7Gk72JqzjEKJw70cth0QiUeqnySdqTuPnE7/j37M/l+vAgooWojI+jV+J9p4OfJiknD/YG09sRX3bFayUwUmnsvTOshBcb+nCD5uU8xTol99PgIezOZY+OZ51FEKY0NLQwub5a/Ft5gbkVp9kHecuveJeLN35Bt4Mf0nuuyGpaCEqQ0dTB38sWI9vszYgrSyLdZw7nL18AcsPvI+fHl0DXS1d1nHuoKOjiR8/m4a3P09FTZ1yLWbem3gRe45cxM9f0rQQUW9eVh74IOYNPLXtJXT0KNf5Yd9kbkCPuAf/DHtR7veiooWoFE8rd3w57QMs3Pai0mwTbOlsxdzNS7Ai7EVEuYSwjnNPEYGOmDt1NBa/vhd9fWLWcQAATdc68Pyb+/H9R1Mw0tqQdRxCmHs1eCmsDSzxxsGPWEe57UTNaXyU/BV+nPMltDS05H4/KlqIynl+4kIE2Prh2e2vQiKRMM0ikUjw7F+vwtnMHm9HvMI0y8N880EcGhrb8frHR1hHgUQiwd/eOoDA8aPw5GzFHHFAiLITCUX49bFvsfX0ThwuZt8csr71Cmb/thgfxqxAkMNEhdyTihaicgQCATY8+iXOXC7ADzn/YZplTcZ6nLyUj82P/yCzU07lxWC4Nvb9Zz627DqHn7edZpplw9ZTyDhejfWrptG0ECH/w8HEDmumf4Rnt7+KK21NzHJ09XZh9m/PIMolGK8GL1XYfZX7tyghUjLRNcaW+T/gzUMfI/9yAZMMWZXH8f6Rz7H9yZ9gqsePXS+OdibY8eM8LHsvAZnHq5lk2J1QhOX/SsSO9fNgYabPJAMhymzxhPmIcA5C/M/z0dKp+BPbJRIJ/r77n5BIJFg/+wuFDiyoaCEqK8RxEt6KfAVTfl6A4sYyhd77SlsTHtvyPFZPfRf+tuMUeu+hCpvkgK/ejcHs5/9U+KGKR3OrsPCVXdj63RyEBNgr9N6E8IVAIMB/5n0D6+EWmPHrIoUfqvhd9kYkFqdj16JfoK2prdB7U9FCVNrK8GV4avxjiPhxDkqayhVyz4a2RsRtfBwRzkH4+6RnFHJPWXth4QQ8Nt0TM5/dhvaOboXc82xhA2Yu+QPffBCHmbHuCrknIXylKdLEXws3ol/Sj8e3LFVYf6rk0gy8c3gVdj31C0YYWinknv+Lihai0gQCAT6NewsL/eYi4sc5KG2S7wGBlc3VCF43A2OsPfCfed/wej3G1+/HwcxEF7Of+xOtbV1yvVdFdTNin9yMFS8EYsl8P7neixBVoauli/3PbEb1jUtY8ter6O+Xb4PIIyXpmLt5CX545DNMZPQEmYoWovIEAgFWxb+NJ8bNQfiPs+VWuFxouIjgdTMR7x6JX+d9B02RplzuoyiamiLs2vAYhEIBJs/6GRXVzXK5z+WGVsQ8sRmPTffCyheD5XIPQlSVkY4hDi/Zhpzqk3jtwPty2zG5PncTZm96BmtnrZJrm/6HkWnRcvbsWbz55puYNWsWwsPDUVdX99DPiMVi/PDDD5g5cyamTJmCVatWobNTsfNzRPUJBAJ8Fv8O5o99BBEb5sh8jcvxmtMIXf8Inpv4JL6d8bHS7xQaLEMDbRz4dQEigxwxccZGmS/OPZBcDJ/Y9QibZI+v34/l9ZMpQlixGm6BI8/9iV3nD2LOb4tl2qNK3C/Ga/vfx7uJq3F4yTY8MW6OzK4tDZn+Zu3q6oKrqyuWLFky6M/89ttvSElJwXvvvSEe6rgAAAsQSURBVIevvvoKxcXF+Prrr2UZixAAA4XL51PfwyK/eRj/XQw+S/t+yPPAEokEO87tR8xP8/Be1HK8H/26yv3Fq6EhwrcfxuPjNyIQt3AL/iOD7dBdXb146d1DWPDSTnz9fiw2fjFTZQo9QlhwMLHD6VeSIBQI4b0mHAkXU4Z8zfbuDsze9AwSLqbg2EuHFNaL5UFk+lti4sSJWLx4McaPH9wZIf39/di7dy8WL14MPz8/eHh4YNmyZUhJSUFLS4ssoxE5SUxMZB2BE4FAgE/iViJxyZ/4/cxO+H0bjZyqPKmulVOVh+B1M/DinpXYMOdLLAsafLEuD/L+Xix9cjwO/LoAb3yShOdW7ENljXQ7iwouXsGEaT8h72wd8g+/gCdn+8g4KXt8+7lQZer0vTDTM8VfCzfik7iVeHzrUry4ZyVu9tzkfB1xvxh/nduHgLXx6Oi9iZx/HICTqb3sA0uB6dCmvr4eLS0t8PX1vf2aj8/AL7Di4mJWsQgHfP2FMNl+Ak69nIQnfOcg5qd5eH7H66hvvTKozxY3lmHOb4sRu/ExRLmEoHTFMTw2dpacEz+cIr4X4ZMdcGL/c2hr74Z7+FrMfWE7jp2ufejnxOJ+pOdW4h9vH0TAzI2YFeuOzJ2L4WjHj/41XPH150IVqdv3QiAQ4JkJ83HmlRTk1xXA79sY/JDzH1y6cfmhn+3q7cKGY5vh8UUQXj/wIZ6buBCHFv8OY10jBSQfHA2WN79+fWCkZmxsfPs1kUgEAwMD3LihXAe3EdWjKdLEP8NfwjyfGVi2522M/GQsnE0dEGjvjyAHfwTbB2C4tj4uNpbiYmMZLjaVoehKCTIrj+Op8fNQ+s9jsBpuwfpfQ+Gc7E2wbd1cVF+6gW9/PoaYJzZjjLslFswcA1NjHRgZaMPQQBuGw4ehvrEdOw4WYtfhIgDA7DgPpG57Cv6+Ixn/WxCi2hxN7ZD+wm5sPLEV28/uxav73oOvjRdmesZjmkc0NIUauHqzGVc7mnGt4zqqrtfi5xNbYaZngnejXsPjY2cp5WaCQRUta9aswf79++/7dR8fH3zzzTecby7NKudbn2ltVXwXQHK3np4e3n8vTDWMsfXRdbh+8wZO1J5Gbs0pbMzYgr/9sQI94h7YGtnA1cwJzuaOiHUIw2eRb8HJzAGQKNf/DxX9vTA2EOKDVyfj1WfHYdNf+diTcBYt7V1obe9GS2s3Wtu6oK8/DDOi3PCfL2Ix2c8WItHAw11l+u8mD6rwc6Eq1P17scDzESzwfATXOppxuDgVB4qS8K+DX0EkFMJExwimeiYw0TGCmZ4pvo37CDGu4RAKhejs6EQnZLsp5tb3YSg7nARpaWkP/XR7e/sDd/RoamrCyOj/Pz5qaGjA/PnzsWXLFtjY2Nz3c3V1dXjyySfveJ9YLEZMTAxWrVoFf3//uz7T1NSEefPYbbcihBBCiPS2b98Oc3NzqT47qCct+vr60NeX/Rkg1tbWMDQ0RH5+/u2i5dy5cwAANze3e37G1NQU27dvh46Ojsrt0iCEEEJUlUQiQWdnJ0xNTaW+hkzXtHR2dqKurg5Xr14FAFRXV6OzsxMWFhYwMDAAACxatAjPPfccgoODIRQKMWPGDPzyyy+wtraGjo4Ovv/+e0RGRsLQ0PCe9xAKhVJXaIQQQghhZ6gPQGRatBQXF+PVV1+9/ee3334bAPDPf/4TcXFxAIDa2lp0dHTcfs9TTz2Fzs5OfPjhh+jt7UVQUNAd1yCEEEIIAQa5poUQQgghhDWmW565+v3337Fr1y60t7fDz88Py5cvh4mJavZ5UGZbtmxBRkYGamtroaurC39/fyxduvSOxdiEjXfeeQfZ2dn48ssv4edHBw+yUFJSgvXr16OwsBCamprw8/PDBx98wDqW2mlvb8e6detw7NgxdHZ2wsnJCc8999ztXmBEfjIyMrBnzx6UlJSgo6MDycnJEIlEt79eW1uLNWvWoLCwEMbGxli0aBGmTJkyqGvzpm92QkICNm/ejGXLlmHt2rXo6OjAhx9+yDqWWiooKMDcuXPx448/4uOPP0ZVVRU++ugj1rHUXkJCArq7u1nHUGvV1dV47bXXMGbMGPz73//G2rVrERERwTqWWvrhhx9QXFyMjz/+GBs3boS7uzveeusttLW1sY6m8rq7uzFu3DjMnz//rq/19fVh5cqVMDQ0xPr167Fw4UKsWbMGp06dGtS1efOkZffu3ZgzZw5CQkIAACtWrMATTzyBsrIyODs7M06nXj777LM7/vziiy/ixRdfRHt7u1x2mZGHa2howK+//oq1a9dSSwCGfv75ZwQHB+OZZ565/ZqdnR3DROqrqKgI06ZNw+jRowEAixcvxs6dO1FbW3v7NSIf0dHRAID8/Py7vnb8+HE0NjZiw4YN0NXVhYODA86ePYvdu3cP6ukwL5609PT0oLy8/I52/yNGjICVlRUKCwsZJiMA0NLSAi0tLejo6LCOopb6+/vx2Wef4emnn6addQyJxWLk5eXBysoKr7zyCmbPno3XX38d5eXlrKOpJU9PT2RnZ6OlpQVisRiHDh2CmZkZHBwcWEdTaxcvXoS7uzt0dXVvvzZu3DgUFRUN6vO8KFpaW1vR399/R7t/ADAyMqJ2/4z19PTgt99+Q2xs7B1zlkRxduzYAR0dHcTHx7OOotZaWlrQ1dWFP//8ExEREfjss89gbm6O5cuXo729nXU8tbNs2TIYGhpi1qxZiImJwe+//45Vq1bR4Iqx69ev37X+kcvf5bwoWobS8pfIj1gsxqeffgoA+Nvf/sY4jXqqrq7G9u3bsXz5ctZR1F5/fz8AIDQ0FDNmzICrqyuWL18OgUCAnJwcxunUz86dO3Hp0iV8+eWXWL9+PSIjI/H222+jpaWFdTQyBLxY02JoaAihUHj7gMVbbty4QTtWGOnv78fq1atRU1ODb775hkYvjBQVFaG5uRmPPfbYHa+vWLEC4eHheOeddxglUz+3fk+NGjXq9msaGhqwtrZGY2Mjw2Tqp7u7G7/88gu+/PLL27uFXFxccOzYMaSkpGD27NmME6ovY2Nj1NTU3PEal7/LeVG0aGlpwcnJCfn5+bcX6tTX16OhoYEWVDEgkUjwxRdfoLCwEN99993tbsdE8YKCgu468mLx4sV47bXX7nl2F5EfTU1NuLi4oK6u7vZrYrEYDQ0NsLS0ZJhM/fT19aGvrw9C4Z2TCQKB4PYTMcKGu7s7tm/fjs7OztuD3TNnzsDDw2NQn+dF0QIAs2bNwtq1a+Hq6gpra2usW7cO3t7etHOIgTVr1iA3NxerVq0CADQ3NwMYGGnSuhbFut+5YFZWVrQol4FHH30UX3zxBcaOHQt3d3fs2rULADB58mTGydSLnp4evLy8sG7dOrz00kswNDTE4cOH0dDQgAkTJrCOp/JaW1vR2Nh4u4AvKyuDSCSCjY0N/P39YWZmhtWrV+Opp55CUVERUlNT79qVej+86oi7devWO5rLvf7669RcjoHw8PB7vv7HH3/AyspKwWnI/xUeHk7N5RjasWMH/vrrL7S1tcHNzQ3Lli2jHSsMNDU1Yf369Thz5gw6OzthZ2eHp59+GgEBAayjqbzDhw9j9erVd73+9ddfY+zYsaipqbndXM7ExAQLFy7E1KlTB3VtXhUthBBCCFFfvNg9RAghhBBCRQshhBBCeIGKFkIIIYTwAhUthBBCCOEFKloIIYQQwgtUtBBCCCGEF6hoIYQQQggvUNFCCCGEEF6gooUQQgghvEBFCyGEEEJ44f8BkxE1ppFeNGQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 100)\n",
    "fig2 = plt.figure()\n",
    "plt.style.use('seaborn-dark-palette')\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.plot(x, np.cos(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.random.randn(1000)\n",
    "y = np.random.randn(1000)\n",
    "\n",
    "plt.hist2d(x, y, bins=30, cmap='Blues');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will do for Lecture 0. In order to have more interesting data to process and visualize we need to learn to read such into python.\n",
    "\n",
    "**This will be the subject of Lecture 1**"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}