{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "[Oregon Curriculum Network](http://4dsolutions.net/ocn/)\n", "\n", "[Home](School_of_Tomorrow.ipynb)\n", "\n", "# Data Visualization (Part One)\n", "\n", "\"Globe\n", "
\n", "Cleveland High School, Portland, Oregon\n", "
\n", "\n", "\n", "## Introduction to Data Science\n", "\n", "In entering the realm of Data Science, we come upon a world concerned with predicting the future, anticipating what's next, based on extrapolation and sometimes interpolation. Many data science practices inherit from the insurance industry, which is about assessing and socializing (spreading the costs of) risk.\n", "\n", "We predict about the past as well. We're often keen to know of events that may have already taken place.\n", "\n", "### Andragogy / Pedagogy \n", "\n", "Statisticians talk a lot about sampling a population, where the latter is what we wish to accurately characterize, but we haven't the means to survey all the data. The algorithms make a distinction depending on whether the entire population and/or samples thereof are being spoken about." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "def pascal(r):\n", " row = [1]\n", " for i in range(r):\n", " row = list([i+j for i,j in zip(row + [0], [0] + row)])\n", " yield row\n", " \n", "for r in pascal(20):\n", " pass" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "plt.bar(range(len(r)), r);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "At the School of Tomorrow, we recommend immersion, as when learning a language, to pick up on correlation, regression, normal distribution, confidence intervals and so on. Absorb the semantics and make connections to some glue language like Python for specific workouts.\n", "\n", "The concept of a vector is especially important, given its embodiment as an almost literal tip-to-tail arrow pointing from the origin to anywhere in an n-D space. Such pointing, with corresponding labeling, is the bread and butter input of supervised machine learning algorithms. \n", "\n", "Up to 3-D we have the visualizable space of polyhedrons.\n", "\n", "### Historical Sidebar\n", "\n", "In coordinated Martian Math segments, on polyhedrons, the School of Tomorrow may introduce quadrays, as a questioning and investigational tool ala Ludwig Wittgenstein. How many basis vectors do we need again? The famous three need their three opposites, rotated 180 degrees. \"What minimum basis might get by without needing opposites?\"\n", "\n", "We guess about this and that, whether this or that happened in the past, or has yet to happen. When making these guesses, we use existing data as evidence. A model that's scoring well is able to correctly predict what we already know to be the case.\n", "\n", "### The Science of Predicting\n", "\n", "Under the heading of \"prediction\" therefore, comes \"the ability to guess correctly\" whether or not we're looking into the future or into the past. Keep in mind that Physics, including Quantum Physics, is just as interested in prediction, in \"guessing with some confidance\" as any discipline.\n", "\n", "A goal, in engineering, is to have some influence over outcomes, and that means looking for trimtabs. \n", "\n", "How might we optimize various distribution networks, such as the internet itself, so that it's less likely to bog down in traffic jams?\n", "\n", "### Historical Sidebar\n", "\n", "\"Data Science\" is a relatively recent invention, for what used to be called Statistics. We still have Statistics, but ever since statistics joined forces with Machine Learning, the term \"data science\" has been in the foreground. The evolution of Machine Learning has been against the backdrop of some professional debates the statisticians have been having. One of these debates has been between so-called \"Frequentists\" and another camp known as \"Bayesians\".\n", "\n", "### Research Project: Recent History of Data Science\n", "\n", "Looking for a research topic? Here's [a place to start](https://www.amazon.com/dp/B0050QB3EQ): *The Theory That Would Not Die: How Bayes' Rule Cracked the Enigma Code, Hunted Down Russian Submarines, and Emerged Triumphant from Two Centuries of Controversy* by Sharon Bertsch McGrayne." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'hypertext transfer protocol'" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import json\n", "with open(\"glossary.json\", 'r') as infile: # context manager syntax\n", " glossary = json.load(infile)\n", "glossary['HTTP']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Programming Interlude: Context Managers\n", "\n", "Since we've chosen Python for a kernel language (many choices exist), we might as well dig into it from time to time. In the code cell above, you'll notice the keyword ```with``` with the optional ```as``` piece, with indented code underneath (as many lines as we like). \n", "\n", "The indented code is the body of our \"context\" which is entered at the top and exited at the bottom. The occassions of entering and exiting a context automatically trigger the ```__enter__``` and ```__exit__``` methods of the object we're using with ```with```." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Content of knight_bag: Holy Grail from Goth Castle\n" ] } ], "source": [ "class Castle:\n", " \"\"\"\n", " Example of a class designed to perform as a \n", " context manager, as triggered by keyword 'with'\n", " \"\"\"\n", " \n", " def __init__(self, name):\n", " self.name = name\n", " \n", " def __enter__(self):\n", " return self # pass forward through as\n", " \n", " def inner_sanctum(self):\n", " # Monty Python allusion\n", " return \"Holy Grail from %s\" % self.name\n", " \n", " def __exit__(self, *oops):\n", " if oops[0]:\n", " # do cleanup\n", " pass\n", " return True\n", " \n", "with Castle(\"Goth Castle\") as castle:\n", " knight_bag = castle.inner_sanctum()\n", " \n", "print(\"Content of knight_bag:\", knight_bag)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "glossary[\"Bayesian\"] = \"inferential methods useable even in the absense of any prospect for controlled studies\"\n", "glossary[\"Pharo\"] = \"a Smalltalk-like language and ecosystem that competes with Python's\"\n", "glossary[\"Sphinx\"] = \"a documentation generator, targeting the web in particular, for use with Python\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Digital Mathematics curriculum\n", "\n", "In [Digital Mathematics: Heuristics for Teachers](http://wikieducator.org/Digital_Math) you will find a way of carving up our mathematical domain into four sections:\n", "\n", "* Martian Math (looking towards the future)\n", "* Neolithic Math (looking towards the past)\n", "* Casino Math (looking at risks)\n", "* Supermarket Math (looking at ecological systems)\n", "\n", "Ready for [Part Two](dataviz2.ipynb)?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## More Tools...\n", "\n", "In addition to Python the language, which is our Kernel, we need to use some add-on 3rd party packages, which usually get installed in a subfolder called ```site-packages``` and associated with the specific Python you're using. \n", "\n", "Three of these packages are: \n", "\n", "* ```numpy``` (a workhorse that works with tensors, or n-dimensional arrays)\n", "* ```pandas``` for encapsulating [tensors](https://www.tensorflow.org/guide/tensors) and adding dictionary-like labeling\n", "* ```matplotlib``` for doing the actual visualizations.\n", "* ```seaborn``` for making matplotlib even prettier.\n", "\n", "### Will I Ever Know Enough?\n", "What you might be asking yourself, perhaps having glanced at some documentation, is:\n", "\n", "1. where to begin? and\n", "2. will I really need to memorize hundreds of commands to control each one of these products?\n", "\n", "Our assumption here is you're involved in \"world game\" meaning thinking globally, acting locally. \n", "\n", "You're on the faculty of a think tank. People look to you for guidance.\n", "\n", "To get a stronger grasp on what's going on, you read a lot, but you also look at data that's sometimes too new to have yet led many, if any, to draw conclusions. You are one of those privileged data analysts with a special vantage point, who will share your sense of what it all means with your peers.\n", "\n", "That's partly why you read, and also write a lot: to keep your communication skills polished. We're learning new language our entire lives. New vocabularies. New \"games\" (language games), some of which are literally games. Learning from data also involves applying the techniques of data science, which may include using machine learning algorithms.\n", "\n", "The data you're studying is not necessarily \"big data\" although it may be. \"Small data\" may still be quite a lot, by 20th Century standards.\n", "\n", "#### Research Project: Apache Foundation\n", "\n", "[The Apache Foundation](https://www.apache.org/) helps fund a number of valuable free and open source products built to work with big data. In order to gain some fluency with the concepts, do some research on these projects.\n", "\n", "\n", "### What's an API?\n", "As for memorization, you're best bet is to stay in the habit of consulting documentation, and deciphering it. What you're often looking for is advice on how to use an \"API\" or Application Programming Interface. You might call it a control panel or dashboard, but unless you're operating a GUI, the API is likely encountered in the thick of some programming language, such as Python, Ruby, or JavaScript.\n", "\n", "#### Reading the Docs\n", "\n", "Looking ahead to the next Notebook: \n", "\n", "* How do I sort a DataFrame by index? [Check here](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.sort_index.html)\n", "* How do I sort a DataFrame by any column? [Check here](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.sort_values.html)\n", "\n", "If you work with these tools on an everyday basis, then you'll become more adept through practice. However what's rewarding about programming is that your code will run extremely fast even if you take a relatively long time to write it, compared to someone else who writes code faster. \n", "\n", "Better to take your time and understand what you're doing, than just cut and paste a lot of code you find on the internet. It's fine to cut and paste code, but plan to spend time getting to understand it in some detail. That way, you'll continue along your learning curve.\n", "\n", "A common misapprehension about \"learning to code\" is that \"real programming\" always involves starting with a blank canvas and writing everything from scratch. Certainly piano players don't do that, when it comes to piano playing. Sometimes that's a good approach. Other times, you best bet is to begin with some existing code, and modifying it to suit your own purposes.\n", "\n", "Without further delay, lets get to know some of our data science tools, each with its own API." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt # done above already\n", "import matplotlib as mpl\n", "import seaborn as sns\n", "\n", "from math import sin, cos, radians # lets plot some trig functions!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that you don't need to import Python itself. That's because Python is the Kernel behind the scenes running all these code cells. One specifies the Kernel upon starting a new Jupyter Notebook." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Numpy version : 1.17.2\n", "Pandas version : 0.25.1\n", "Matplotlib version: 3.1.1\n", "Seaborn version: : 0.9.0\n" ] } ], "source": [ "# Kernel is Python 3.6 or above\n", "print(f\"\"\"\\\n", "Numpy version : {np.__version__}\n", "Pandas version : {pd.__version__}\n", "Matplotlib version: {mpl.__version__}\n", "Seaborn version: : {sns.__version__}\"\"\"\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You probably won't want or need to upgrade each time there's a version change. In fact sometimes you may find yourself in the opposite situation, of needing to lock in an old version of something. Programmers use containers and virtual environments to preserve old ecosystems and keep them from contaminating each other.\n", "\n", "When you do upgrade a package, you may find rerunning the same code results in warnings or outright errors. Packages with stable APIs are less likely to surprise you in this way. It's a good idea to consult documentation to find out what's new, if you actually have a choice about whether to upgrade or not." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Numpy version : 1.17.2\n", "Pandas version : 0.25.1\n", "Matplotlib version: 3.1.1\n", "Seaborn version : 0.9.0\n" ] } ], "source": [ "# if you have an earlier kernel\n", "print(\"\"\"\\\n", "Numpy version : {}\n", "Pandas version : {}\n", "Matplotlib version: {}\n", "Seaborn version : {}\"\"\".format(\n", "np.__version__, pd.__version__, mpl.__version__, sns.__version__)\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The code cell below is quite typical of how we might use ```plt``` (matplotlib.pyplot) together with ```np``` (numpy). Note that ```pd``` (pandas) is not yet involved. We'll be seeing it soon.\n", "\n", "The ```np.linspace``` command is one of the most used, as we so often need a particular number of evenly spaced numbers between a minimum and maximum extreme. ```np.arange``` is the other workhorse. It takes a minimum and maximum extreme, just like ```linspace```, however the third argument is the increment you wish to use. ```arange``` will figure out how many elements you need, up to but not including the limiting value.\n", "\n", "Note that both of these functions return ```np.ndarray``` objects, where the ```ndarray``` type is the star of ```numpy```. An ```ndarray``` is a multi-dimensional array, meaning it has one or more axes. These axes define the coordinate system structure used to address the contained elements. You'll learn more about the ins and outs of ```ndarrays``` from other notebooks." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmwAAAFNCAYAAAC9jTMrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3de5xU9Z3n//ensRu5BAiKQUUabyTiBcygYkzUyCQjxMTNTDQoujrG5eclmZj9zc6YITeTYdf9zf42mjWJIRdjEtZxkk28BWa8TKImZlQQb2BQBwEREARt5WI3dH/2j6pq63Kq+lR3VZ3b6/l48KCr+lTVt6tOfb+fc77fz+eYuwsAAADx1RZ1AwAAAFAbARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAFIHDP7spndHHU7BsvMLjGzZVG3A0ByGHXYAETJzHYW3RwpqVtSb/72/+PuSxr8ej+TdL6knqK7L3H3/9PI1yl6vaMkveDu1oznB5AN+0XdAADZ5u6jCz+b2TpJl7v7/dW2N7P93H3fEF/2v7r714b4HADQMkyJAog1M/t7M7vdzG4zs7ckXZS/78dF2/ylmW0ws9fM7O/MbKOZnVnn6+xnZm5mU4ru+5mZfS3/85+a2Toz+xsz22Zmm8zsPxZtO9LMvplvR5eZPWRmwyU9lP/9zvy/k8zscjP7bdFjP2hmy/OPe8zMTin63e/M7Doze8TM3jKzfzaz8UWv+b/NbLuZvZF/7IH1/N0AkoGADUASfFLS/5Y0VtLtxb8ws+MlfUvSPEmHSpogaWKT2jFJ0ghJh0i6QtJ3zWxM/nfflHSCpFMkjZf0d5L6JJ0u5c4k5v89Xtb+AyX9WtL/L+mA/N+y1MzeXbTZhZIukfQeSaMk/ef8/X+p3DTypPxjr5L0dgP/XgAxQcAGIAl+5+53u3ufu+8p+915ku5w90fcvVvSl0I837X5M1JvmNmWOtrxtqS/d/e97n6XcuvtpprZMEmXSvord9/s7r3u/jt33xviOT8uaZW73+bu+9z9Z5LWSvpY0TY/dPcX3H23pJ9LmpG/f6+kAyUdlX/N5e6+UwBSh4ANQBK8XON3hxT/3t13SXp9gOe73t3H5f/VczbuNXfvLbq9W9Jo5c58dUj69zqeq+AQSevL7luv3NnCguKgsvCakvRjSfdL+icze8XMrjcz1iYDKUTABiAJaqWzb1ZuSlCSZGajJL27+uZVXiCXyNCt3BRjQdhg7lXlsk6PDHrqAR67SVJn2X2TJb0y0Iu6e4+7f83dj5H0QeWmjucP3FwASUPABiDpfi7pP5jZLDPrkPT1ITzXU5Lmm9kwM/uYckHQgPJn3X4s6QYzm5h//Glm1i5pqyQ3syOqPPweScea2afziQ8XSjpK0tKBXtfMzjKz48ysTdKbyk2R9g7wMAAJRMAGINHc/WlJX1AucNskaXv+X/cgnu6vlDtL9YZya+PuquOxX5D0nKQVknZI+q/K1bp8S9J/k/Rofs3czLL2b5P0CUl/m2/3FySd4+47QrzmIZJ+qVywtkq56dHb6mgzgISgcC6AVMlnbb4hqdPda619A4DE4AwbgMQzs0/ka5KNVq48xhMEawDSJNKAzcx+ZGZbzezZKr8/M19I8sn8v6+0uo0AEuGTyk2HbpQ0RdIFkbYGABos0ilRMztd0k5JP3H34wJ+f6akv3b3c1rdNgAAgLiI9Aybuz+k3OJcAAAAVJGENWynmtlTZrbMzI6NujEAAACtFveK2E8ol+m108zmSrpD0tFBG5rZAkkLJGnUqFF/8r73va91rQQAABikFStWvObuE2ptE3lZDzObIumeoDVsAduukzTT3V+rtd3MmTN9+fLlDWkfAABAM5nZCnefWWubWE+J5iuGW/7nk5Vr7/ZoWwUAANBakU6Jmtltks6UdKCZbZT0VUntkuTuN0v6lKQrzWyfpD2S5nnUpwQBAABaLNKAzd1r1kpy95sk3dSi5gAAAMRSrKdEAQAAQMAGAAAQewRsAAAAMUfABgAAEHMEbAAAADFHwAYAABBzBGwAAAAxR8AGAAAQcwRsAAAAMUfABgAAEHMEbAAAADFHwAYAABBzBGwAAAAxR8AGAAAQcwRsAAAAMbdf1A0AAADx1dPTo+eee0579+6VmUXdnEi5u9rb23XMMceoo6Ojpa9NwAYAAKp67rnntGrVKr344oty96ibEykz01FHHaWenh7NnDmzpQEsU6IAAKCqvXv3EqzlubtefPFFmZkefvjhlr42ARsAAKjKzAjWiri7zEzLli1Tb29vy16XgA0AAERu0aJF/T8///zz+ta3vqU33ngjwhYNrKenp2WvRcAGAABiY+3atVq2bJkuuugijRs3LurmxAYBGwAAiIX169frrrvu0oUXXqjx48dLknbt2qXbb79dixcv1uLFi7Vhwwb19fXpW9/6lnbt2iVJ6uvr04033th/O40I2AAAQOR6e3t12223ad68eZowYUL//cuWLdOsWbO0YMECnX/++brrrrvU1tamE044QU8//bSk3Fm5iRMnatSoUVE1v+ko6wEAACLX1tamww47TCtXrtScOXP671+7dq22bdvWf7u7u1vd3d068cQTddttt+nUU0/VypUrNWPGjCia3TIEbAAAIHJmpvPOO08/+clP9NBDD+n000+XlMvKvPzyy9Xe3l6y/fDhwzV69GitXbtWr7zyiv7iL/4iima3DFOiAAAgFjo6OnThhRfqmWee0RNPPCFJOvLII/XYY4/1b7N58+b+n9///vfrl7/8pY499li1taU7pEn3XwcAABJl5MiRuuiii/TQQw/pj3/8o+bMmaNNmzbpO9/5jm666SYtX768f9v3vve96unpSf10qMSUKAAAiIGFCxf2/zx27Fhdc801/bfPO++8wMds2bJFEydOLElSSCsCNgAAkDgPP/ywli9frj//8z+PuiktQcAGAAAS50Mf+pA+9KEPRd2MlmENGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABInDvvvFNbt26NuhktQ5YoAABInHPPPTfqJrRUpAGbmf1I0jmStrr7cQG/N0k3SporabekS939ida2EgAAhPW0ntYDekBd6tJYjdVszdYJOmFIz9nT06Of//znevPNN9XX16czzjhDjz/+uD760Y/q0EMP1aJFizRr1iw9//zz2m+//XTBBRdo9OjR2rVrl+655x51dXVJks4++2xNnjy5EX9my0U9JfpjSWfX+P0cSUfn/y2Q9N0WtCkxljyzRFNumKK269o05YYpWvLMkqibBKRKd/dmrVx5hrq7t9S8L+voi1DwtJ7W3bpbXcoFSF3q0t26W0/r6SE974svvqh3vetduvLKK3X11VfrqKOOKvn93r17NWnSJF155ZXq7OzUihUrJEnLli3TrFmztGDBAp1//vm66667htSOKEV6hs3dHzKzKTU2OVfST9zdJf2bmY0zs4PdfXONx6TSkmeWaOEDC7Wha4Mmj52suUfP1a1P3arde3dLktZ3rdeCuxfo9xt+r6UvLO3fbtHsRZp//PyIWw8kQ3f3Zq1ePU/Tpt2u4cMnat26b6ir63dav/4bmjr125IUeF/549KuuD8aP2K83up5Sz29PZLoi7LuAT2gvdpbct9e7dUDemBIZ9kOOugg3Xvvvbrvvvs0depUdXZ2lvx+2LBhmjp1qiTpkEMO0b//+79LktauXatt27b1b9fd3a3u7m4NHz580G2JStzXsB0q6eWi2xvz96U+YBuoQ7x5+c1yecljdu/dXXI/HSdQn+JgrLPzS3r11Vsk9WnLllvU2fllSV5xX7XALi0GOljcvmd7xWPoi7KrcGYt7P1hHXjggVqwYIFeeOEF3X///TryyCNLft/W1qbcKirJzNTX1ydJcnddfvnlam9vH9Lrx0HUU6IDsYD7POA+mdkCM1tuZsuLo+kkWvLMEi24e4HWd62Xy7V9z/b+YK2gPFirdn+h4yw8V6HjZMoCWVc+tdndvbkkGFu79otyL3T6vVq//htat+4bFfeVP667e0tqpk3L+6LCwWIhWKuFviibxmpsXfeH9eabb6q9vV3Tp0/XBz7wAW3eHO68zZFHHqnHHnus/3bYx8VR3AO2jZIOK7o9SdKmoA3dfbG7z3T3mRMmTGhJ4xqlfP3H55d9PlSHGFZQx7nwgYUNe34giYrPihVuF4Kxvr59evXVn8k9d6Dk3qPNm3+kLVtuKbmvVmBX/NxJtfCBhRV9UbWDxTCC+qJLfnUJa99SZLZmq12lZ7Pa1a7Zmj2k5926dau+//3v67vf/a4efvhhnX766aEeN2fOHG3atEnf+c53dNNNN2n58uVDakeULLc8LMIG5Naw3VMlS/Rjkj6rXJboKZK+5e4nD/ScM2fO9KR8KIUj2MEEaCYr6QDLb4d5PNMSyKLu7s169NEj1Nf3ttraRujEE/+glStnqa/v7RqPKhzf9hXd156/3dt/j9n+kiT33HOfcsraxKxrK5/+XN+1flDPU29fVDCyfaQWf3wx/VHMrFixQvfcc0/o7ZuRJRo355xzjn7xi1/oK1/5ikaMGDHk5zOzFe4+s9Y2kZ5hM7PbJP1B0nvNbKOZfcbMrjCzK/KbLJW0VtKLkr4v6aqImto0QUewYYxsH6krZl6hzrGdMpk6x3bqiplXaGT7yJLtLHBWOYdpCWRF+RRl+dTmc8/N779dXZ9KgzVJ2qviYC33fD1FZ+F6+8+yxX2aNGj6s1r/UX5/e1u7DhhxwKD7ogLO/qfDCTpBX9AX9DV9TV/QF1IXrEUl6izRCwb4vUu6ukXNicSGrg2htmtva9eY4WO0Y8+OmmfFTpt8Ws0FwkEKnSRHtUiroGSC4qnN3btXK2h57KhRM3TSSSurPu/jj5+oXbueLLv3naCuMG3a2fnl2CcmVJv+LD9bNrJ9pC6ZfsmAyQOD6YukXILClBumkJgAlIl7lmjqVZt2OGDEARrdMbruTmv+8fNrdpzVpinoJJFW5UkBvb27Ks6mmbXr4IMvrzuQKg/m1qy5Slu2/LA/GJRyZ9nWrr1W27bdrvLs0qgVT4HWSmTqHNvZ8L6ozdrU670VjzNZf59YmAEoPB+QZXFPOki9RbMXVUwdjGwfqRvn3Kh116xT31f7tO6adUPqrOYfP7//uTrHdgZuU+gkmSZF0g00/bl9+69LAqrc/T3q6npkyK/95pt/CHzu7dvvqUhMCGprK5VPgVbTObazKX3RrZ+8NXDalCQpIBgBW8TmHz9fiz++uGQtWjMX3QYFiHSSSJPiqcfC2bXi6c++vl069dTNOvNML/lXa+ozrJNOWlnxvKeeukl9fbsqsku7u7dEmk0aZv3syPaRWjR7UVNeP6jvqxY4hl06AqQZU6IxEDR10MzXkhQqE4xOEkkTZvqzcIarVevIis/wFbch6mnSWt/vVmWQl/d9U26YEtgfjR8xniUbyDzOsGVQ8bTEumvWVZ0mLXSS1EhCUrRy+jOseqdJm6W83uP4EeMDt+sc29mQ6c/BCJoBaG9r11s9b7FkA0PyyiuvaOnSpVE3Y0g4wwYtmr2oohZcoZMsXHaGxb+Iu1rTn1Eu8A+aai3UgSufJm3WWbbyeo/ru9arva1dHcM6Sq6i0swp0DCCZgB29uysuPwVme2o16GHHqpDDz006mYMCQEb6CSRaIULr++//+GRT3+GVWua9O23X2r4ReSD1qvt7ds76Gz0ZiqfJm27LngiiCUb8dbR8ZaOOeYXWr36U9q7910Nec4nn3xSjzzyiMxM73nPe3TWWWfpzjvv1K5duzRq1Cide+65GjdunFatWqXf/va3amtr0/Dhw3XZZZfppZde0iOPPKL58+frN7/5jbq6uvT666+rq6tLs2bN0qxZsyRJTz31lB599FH19vZq0qRJ+tjHPqa2tnhMRhKwQRKdJJKrsHB/167VkU9/hlVrmnTfvtcbHmRW+97u2LNDr/3Naw17nWaots528tjJEbQGYU2e/KDGjt2gzs4H9eKL5wz5+bZu3aqHH35Yl112mUaNGqXdu3frjjvu0PTp0zVjxgw98cQTWrZsmS644AI9+OCDuvjiizVmzBjt2bMn8Plee+01XXrpperu7tZNN92kk046STt27NCqVav0mc98RsOGDdM999yjp59+WjNmzBhy+xuBgA2B6CSRBMVJBnGY/gyr1jRpM5IQkvx9DlqyMbJ9pOYePZdEhJjq6HhLEyc+KTPXxIlPav36M4Z8lu2ll17StGnTNGrUKEnSyJEj9fLLL+vTn/60JGn69Om67777JEmHHXaY7rjjDh177LE65phjAp9v6tSp2m+//bTffvtp1KhR2rlzp9auXatNmzZp8eLFkqR9+/b1v14cxOM8H2Kn2uLfnT07SUJAbJQnGST5YuuN/FvKEwzmHj03sN5jlOvVwgoq/3HJ9Et061O3kogQU5MnPyizXIkWM1dn54NDfs4w1z03y13+7OMf/7jOOussdXV16eabb9bu3ZXla4YNG1byuL6+3HdvxowZuvLKK3XllVfqc5/7nD784Q8Pue2NQsCGQOWd5AEjDpCZafue7XSQiIWgJINCfbOkaeTfEnRN0FufulWXTL+kZfUeG608s33pC0sr1uRROzIeCmfX2tpyV7Foa+vVxIlPqr39rSE97xFHHKFVq1b1B1+7d+/WYYcdpmeffVaS9PTTT2vy5NwZ4x07dmjSpEk666yzNHLkSHV1dYV6jcMPP1yrV6/Wzp07+1/jjTfeGFK7G4kpUVRVvK5tyg1TSEJA5AoJBtOm3V514X4ckwwGUutv6ez8Uv/fHGaKNCjBYPfe3Vr6wlKtu2ZdI5sdmWpr8lhjG73is2sFhbNsQ1nLdtBBB+n000/XLbfcora2Nk2cOFFz5szRnXfeqd///vf9SQeSdO+992rHjh1ydx1xxBGaOHGi1q1bF+o1zjrrLP30pz+Vu2vYsGGaO3euxo0bN+h2NxIBG0Khg0QcFF8ZoNrC/TgmGQyk1t9S70Xjs/BdTfKavLQbM2Zj/9m1gra2Xo0Zs3HIzz1jxoyKBIBLL720Yrt58+ZV3Hf44Yfr8MMPl6SKac6rr766/+fjjjtOxx133JDb2gwEbAiFDhJRK7+KwSmnrE1EgkEY1S6LNZhEhCx8V6slIiRhTV7aPfHEFVE3IbVYw4ZQql2kng4SrZKmBIOwwvzNaUowCKtaIsLCBxaSFIXUImBDKNUuUi+Jy1eh6dKUYBBWmL85jQkGYRUnIiyavYisUaQeU6IIrby4btDlbrh8FZohTQkGYYX5m7OQYBBGtfeBpKjGcHeZWajSGlkQ1XvBGTYMWq1OEhiq7u7NWrnyDHV3b0lVgkFYtf7mwnvz1u7KtWpSuhIMwshCokWU2tvbddRRR/XXOcsyM9ORRx7ZX/qjlTjDhkGjk0QzFWdHVluUn2a1/uY1a65SV9fvdNXU0fr7VZUDR5oSDMLIQqJFlApXC5g6dWrmgzZ3186dO/vrv3V0dLTstQnYMGh0kmiW8ozQRl6mKemK35sPH9itW0aO0Cu737leYtoSDMIga7S5Ojo6NH36dP3+97/XnXfemfmgTcoFbuecc07JFROajYANg0YniWYJyo5M61q1ehW/N8PMdPMHP6DPPvpipq+pWfh7Fz6wsOR9kMT1RhvoAx/4gCZOnKjt27dnej2bmWn8+PE68sgjW/u6aXzTZ86c6cuXL4+6GZmw5JklgZ1k+X10kgirUHusr+/t/vva2kakqu7aYHV3b9Yjf+iUaW//fX1q12mnbsj8e1OuPClKyh1QpjFjFslnZivcfWatbUg6wJCUX+NPUkWZAdLrUY9a2ZFZd98TF2tv396S+/b17dV9T1wUUYvii6QopA0BGxqKThJDlcWM0LC2v/6QOsp67Y623P0oRVIU0oY1bGgoOkkMVuHC7iecsIzpvSr+8vF9ClrEckDHXp1w8BmhLxCfBSRFIW04w4aGqtYZ0kliIMVlPBCs2vfoyqNH896V4XJ6SBsCNjQUnSQGo7yMR5ovOTUUQd+vQ0eO0FkHdov3rlS1y+mRcICkImBDQ9FJYjCyeGH3wQj6ft38wQ+oLV8Xi/euVHlS1Pzj52vJM0u4/jESibIeaLqg0h8EcCigjEd1A313eO/qQ6kPxBVlPRC5QgdJmQ9UQxmPYGG+O7x39SGLHUlGwIamooPEQCjjESzMd4f3rj5ksSPJKOuBpqKDRJBCCY9p027P5IXdwwjz3an13hW/x0yP5lDqA0nGGTY0FWU+EIQSHgMb6neH97gSWexIMgI2NBUdJMpRwiOcoXx3eI+DkcWOJCNgQ1PRQaIcJTzCGcp3h/e4uqDrH1PmA0lAWQ8ALUMZiuoaVf6G9zg8ynwgLijrgdiieGU2UYYiWCPL3/Aeh0cWO5Ik0oDNzM42szVm9qKZXRvw+0vNbJuZPZn/d3kU7URjUZstuyhDEayRgQPvcXhksSNJIivrYWbDJH1b0kckbZT0uJnd5e6ryza93d0/2/IGomlqDU5MQ6QbJTyCNTJw4D0OjzIfSJIoz7CdLOlFd1/rucPBf5R0boTtQYtwVJst3d2btXLlGWQq1tCq8jd8FqXIYkeSRBmwHSrp5aLbG/P3lfsLM3vazH5hZoe1pmloJmqzZQv1wAbWqsCBz6IUWexIkigDNgu4rzxl9W5JU9z9BEn3S7q16pOZLTCz5Wa2fNu2bQ1sJhqNo9rsoB5YOK0IHPgsgpWX+SBYQ1xFGbBtlFR8xmySpE3FG7j7dnfvzt/8vqQ/qfZk7r7Y3We6+8wJEyY0vLFoHI5qs4N6YOE1O3DgswiPLHbEUWR12MxsP0nPS5ot6RVJj0u60N1XFW1zsLtvzv/8SUl/6+6zBnpu6rAB0aMeWG2NqrsWBp9FeNRmQxRiXYfN3fdJ+qykf5H0nKR/cvdVZvZ1M/tEfrO/MrNVZvaUpL+SdGk0rUUrcFSbLtQDq67VpW34LMKjNhviKrKyHpLk7kslLS277ytFP39R0hdb3S60XvlRbWEAk8RRbUJRD6y6Vpe24bMIjyx2xFWkARtQQG229KEeWHWtDgr4LMKjNhviiktTIRY4qk0Pan0NLE6lbfi8SpHFjrgiYEMsxGkAw9BQ62tgcQoK+LxKkcWOuIosS7SZyBJNHjKz0qE4G5EsxNpamSVaDZ8XEA9hskRZw4ZYKAxUUQ9gGJqgWl9Tp3474lbF0/zj50e+f/N5AcnBGTYADUGtr2Th86pPHM6IIr1iXYcNCIPabMlBra/q4rgf83mF1+q6eUAQAjbEFp1kslDrK1hc92M+r/Aopos4YEoUsTXlhimB9ZA6x3Zq3TXrWt8gYBDYj5Ov7bo2uSrHSpOp76t9AY8A6sOUKBKN2mzxRw2vgSVtP+YzrUTZIcQBARtii04y/qjhNbCk7cd8ppXiVDcP2UXAFhMc1Vaik4y37u7NevXVWyT1acuWW9h3q0jSfsxnGoxiuvGXhTGUgC0mOKqtRCcZb0E1vFApSfsxn2l184+fr3XXrFPfV/u07pp1sfz8siwLYyhJBzFAtXEkDTW80ofPtD7UZYuPNIyhJB0kBEe1SBpqeFUXx5prYfCZhhfXUi1ZlZUxlIAtYoU1I4V6SO49rB2pIamDYdpQwytYkgdyPtPwqMsWH1kaQ7mWaMRqHdVyTb9S5ReILwyGkpiKaLGTTloZdRNiqdZAHvd9lM80vKSVakmzLI2hnGGLGEe14XFUi7hjIM+GpJVqSbMsjaGcYYsYR7XhMRhGq7t7s1avnqdp025P3ILeVpk8dnLgVQ2SPpDz2ZdaNHtRydl+Kb6lWtIuS2MoZ9iQGBzVRisLafNDlaSaa/Xgsy+VpFItSA8CthjLQiHAeqR1MEwCCqqGk8aBnM8+GHXZopPVsZGALcY4qi2VxsEwKbKSNt8IaRvI+ewRN1kdGymcG1NpKASIdKCganbx2deHYrrNl9axkcK5CcZRLeKCgqq1pbk2IJ99eEmuwZckWR4bCdhiKEuFABshzQNmHGQpbb5eaR+k+ezDo+xQ82V9bKSsRwxlqRDgUFFMt/mylDZfryQXyg2Dzz48yg41X9bHRs6wxRBHteFxVIsoMUijgLJDzZf1sZEzbDHEUW14DJjNQaHUcNJaKDcM9pFSFNNtvqyPjZxhQ6JxVNscWU2br1eWawOyj5Si7BCajYAtQbJaLLCWLA+YzUKh1PCyOkizjwRLWw2+uGDsyyFgSxCOaCtldcBspiynzQ9GFgdp9hG0EmNfDoVzEyKtxQIRLxRKxUDYR+pDMd2hycrYR+HcFOGIFq1AodTaqPnHPlKPtNfpawXGvncQsCVA1osFDgYD6+BkPW2+FgbfHPaR8Cg7NDSMfaUo65EAWS8WWC+K6Q5e1tPma0l7kdyw2EfCo+zQ0DD2leIMWwJwRFsfjmrRDAy+qBdlh4aGsa9UpGfYzOxsSTdKGibpB+5+fdnvh0v6iaQ/kbRd0qfdfV2r2xk1jmjrw8BaP4qgDizLRXLDYB+qRDHdoWHsK1X1DJuZLTWzKc16YTMbJunbkuZImibpAjObVrbZZyS97u5HSfqmpP/erPYgPTiqrR9p8wOj5l9t7EOVKDuERqo1JfpjSfea2UIza2/Ca58s6UV3X+u5c57/KOncsm3OlXRr/udfSJptZtaEtiQWBQUrMbDWhyKo4TD4Vsc+VF0W6/QNBWNadVUDNnf/J0knShojabmZ/bWZ/efCvwa89qGSXi66vTF/X+A27r5PUpekAxrw2qnBUW0lBtb6kDYfHoNvMPYhNApjWnUDJR3slbRL0nBJ7yr7N1RBZ8rKq/iG2Sa3odkCM1tuZsu3bds25MYlAUe11TGwhkPaPIaKfQiNwphWW601bGdLelLSSEnvd/evuvt1hX8NeO2Nkg4ruj1J0qZq25jZfpLGStoR9GTuvtjdZ7r7zAkTJjSgefHHUS2GiiKo1VHLLxz2ofqxbwVjTKut1hm2hZLOc/dr3X13je0G63FJR5vZ4WbWIWmepLvKtrlL0iX5nz8l6V89jdfSGgSOautDBxmMtPlgFMkNj32oPuxbwRjTBlJaIjgAABk8SURBVBbptUTNbK6kG5Qr6/Ejd19kZl+XtNzd7zKz/SX9VLm1dDskzXP3tQM9bxqvJVpuzZqrtGXLD0s6SrMOHXzw5ZksKFhLeSFdKZeEwLo2VDPlhimBJTw6x3Zq3TXrWt8gpAb7VrCsj2lhriUaaR02d18qaWnZfV8p+vltSee1ul1JwFFteFSoR72o5YdmYd8Kxpg2MC5NlVAUFAyPDhL1okgumoV9Kxhj2sC4NBVSj0K6pahzNDBq+TUG+1ol9i0MFgFbCtFJlqKDLEWdo4FRy68x2NcqsW+9g7GqPpEmHTRLFpIOalmz5ipt3vw9HXLIFZlYrBnGkmeWaOEDC7Wha4Mmj52sRbMXZbaDfPTRI9TX97ba2kbolFPWct1HNAX7GgbCWPWOMEkHnGFLGQoPBqOQbg51jtAq7GuohbGqfgRsKUMniWqoc4RWYV+rTxbrRDJW1Y+ALUXoJOuTtU6SivS1ZW1/aCb2tfCyWEiXsWpwCNhShE4yvCx2ktQ5qi6L+0Mzsa+FV6tOZFoxVg0OSQcp8vjjJ2rXricr7h81agY1bspQbRzF2B8Qlbbr2uSqHIdNpr6v9gU8IvkYqyrF/koHaKys7uiDQTFdFGN/QFSyWEiXsWpwmBJFJmWlmC51jsLJyv4QB+yTpagTibAI2DKCTrJUVjpJCpeGk5X9IQ7YJ0tlqZAu49DQELBlBJ1kqSx0ktQ5Ci8L+0McsE8Gy0qdSMahoSHpIAOoOJ5Na9ZcpS1bfij3Hpl16OCDL898NXFEi30yuxiHauNKB5BEgcIsos4R4oZ9sj5pqwvIODR0BGwpRydZn7R0ktQ5qi0tn3OSsE+Gl7a6gIxDjUHAlnJ0kuGlqZOkcGl1afqck4R9Mry0FdNlHGoM1rClHAUKw6N4ajbwOSPu0lZMl3FoYBTOBV+GOqSheGp392atXj1P06bdzoLeKtLwOacJ+2yltBXTZRxqDKZEgbw0FE8lbX5gafic04R9thJ1ARGEgC2jKGBYKemdJDWuwkn655wm7LPB0lAXkDGm8QjYMoqj2kpJ7yRJmw8n6Z9zmrDPVpf0YrqMMY1H0kEGUcAwfYo/0wI+W8QZ+2z9ljyzRAsfWKgNXRs0eexkLZq9KJaBHGNM/Sici0Ac1aYPafPVUXMtnthn65OkcjSMMc1BwJYxFDCsT1IGe2pcBUvSIJc17LP1SUptNsaY5qGsR8bUOqrlmn6lCoN9oZMsDPaSYjcNQdp8sFqDXNw+w6xhn61PUsrRMMY0D2fYMoaj2vCSckSL6pIyyAEDSUo5GsaY5uEMW8ZwVBte3Ad7Co4OLG0FSLOCfbvSotmLSs74S/EsR8MY0zycYQOqiPsRLWnzA6PmWjKxb1eiHA0I2NCPQoel4jzYU3A0HAa55GHfri6utdkYO1qDgA39OKotFefBnrT58OI6yCEY+3byMHa0BoVzIYlCh0lCwVGkFft2feJQSJexozEonIvQOKpNDgqOVpeUunkIxr4dXlxqDDJ2tA4BGyh0WKeogwLS5oPFZQDD4LFvhxeHskOMHa1FWQ9Q6LAOcSimS9p8MIrkJh/7dnhxKDvE2NFanGEDR7V1iOqoliysgcVhAEPz8B0oFYeyQ4wdrRXJGTYzGy/pdklTJK2TdL67vx6wXa+kZ/I3N7j7J1rVxizhqDa8qIKC4iwsjlyDUSQ33fgOlIpDIV3GjtaK6gzbtZIecPejJT2Qvx1kj7vPyP8jWIsAR7WlojiqpS5VOHGum4eh4TtQKaqyQ4wJ0YkqYDtX0q35n2+V9B8iagcGQH2dUlEEBWRhhRPnunkYGr4DwaKoMciYEJ1I6rCZ2RvuPq7o9uvu/u6A7fZJelLSPknXu/sdYZ6fOmyNQX2dYK2sfURdKmQd34H6NLN/YkxonkjrsJnZ/Wb2bMC/c+t4msn5P+BCSTeY2ZE1Xm+BmS03s+Xbtm0bcvvBUW01QUe1zSr1QV2q2qIusYLm4zsQXrNL2zAmRKtpAZu7/6m7Hxfw705Jr5rZwZKU/39rlefYlP9/raTfSjqxxustdveZ7j5zwoQJDf97sob6OuE1s5MkC6s66q5lA9+B8JqZxc6YEL2opkT/QdJ2d7/ezK6VNN7d/6Zsm3dL2u3u3WZ2oKQ/SDrX3VcP9PxMiQ7dmjVXacuWH5Z0lGYdOvjgy8nQKjPlhimB2YmdYzu17pp1rW9QRvC+A6XarmuTq3JMN5n6vtoX8IjwGBOaK86Xprpe0kfM7AVJH8nflpnNNLMf5Lc5RtJyM3tK0m+UW8M2YLCGxuCoNrxmlPogE2tg1F0D35NSzcxiZ0yIXiR12Nx9u6TZAfcvl3R5/udHJB3f4qYhj/o64TWj/hc1pwZG3TXwPSnVzNpsjAnR40oHqAtHtJUaXeqDmlPhUHct2/ieVGpGaRv6/PggYENdqMFTqdGdJJlY4VB3Ldv4ngRrdBY7fX58RJJ00GwkHTQHNXiaj5pT1bWy/h3ije9JeIVs6vJp0jAHN/T5rRPnpAMkEEe04Q32iJaaU8Eo4YFifE/CG0qpD/r8eCFgQyjU4AlvKMEFmVjBmllfCsnD9yS8wWZT0+fHTyRZokieWke0ZGeVqhVcBE1BdHdv1urV8zRt2u1kYlVBCQ8Uq/Y9KSyQnzbtdqbu8gabTU2fHz+cYUMoHNGGV29wwaLegTWzvhTSg+9SpcFmU9Pnxw9n2BBKrTM/xWeIOKqt74i2vDRBZ+eXeQ8DNLO+FNKB71Kwwln9MAk7nO2PN86wYcg4qi1VzxEti3rDoYQHBsJ3qbryUh+SApOi6MvjjbIeGBLSvoOFKUFBaYLqKOGBevBdCq9amY8ffOy/69Cu/0JfHhHKeqDpOKoNFqZ45X1PXExpggCU8EC9KPMRXrWkqNUvfJG+POYI2DBopH2HFxSEvLr9X1nUG4ASHqgXC+TDC0p+Gt8hffDdO+nLY46kAwwaad/hFYKQ8R3Sl4+Rvr5aunyFq3NsZ/+aEuRQwgP1IikqvKCkqIsnS21Wuh19efxwhg2DVuuolgsGlyoEGxdPlk4YK/3HztL78Q5KeKCRWEhfqpAUNb5D+uZ06d3t0vFjTe1l0QBnKOOHM2wYtFpHtWvWXNXfSXKElgs23tqzXnMm5o5kz54o/WS9NGYkQUg5SnigUSj1UamQvPPHNVfohLE7dfXU0dq/82adSVJP7HGGDQ1X3klyli0XhFw2ZZgsP+3QZtJlhw8jCMkrTshY+MBCXTL9Ekp4YMhIigr2qaln6SMH7VObSR85qFefmjp70Nc/Rutwhg0NF9RJZv0s26emnqVDtrfJ1CtJ6miT5h7cplf73tCUG6ZkunxFeZmB9V3rdetTtxKkYUiqJUVxlq2yj77viYu04Dd/KPkOLrh7gSTxHYwRzrChocgcDbZu3TfUZqWrek2uFas/n/nyFWSFohko9REsqI/u2POvGi6+g3FHwIaGopN8R3HiRVCChmmf3ju6t+S+LHaSZIWiGUiKChbUR0venwhVjO9gvDAlioaq1km+/vqDWrnyjEyl1hdnpwUlaLRd1yZX5ZVGstZJ1nPtVSAskqJKFcqb7N27vaKP7miTjh1T+Ri+g/HCGTY01EknrdSZZ3rFv3HjTs9Uan2YxAvKV+TUc+1VYKiymhRVOIAcN+6Miv75lQN+pmue4TsYdwRsaLosdpBhstOyGqiUZ6NJ4sLuaJksZo4O1AfPP35+4HdQCr5IPKJBwIamy1oHGTbxIoudZLXrhEqquPYq0GhZTYoK0weXX/9YEtf0jRlzr1xDk3QzZ8705cuXR90MKNdBPvroEerre7v/vra2ETrllLWpW8tWWCOy//6Ha+vW20rWiZh16OCDLx9wvUx5iQspd9YtLWecptwwJXC9GpfoQiusWXOVtmz5YcV386CDLtDbb7+UyjW2g+2D+a62lpmtcPeZtbbhDBuaqlbWaNoytQprRLZv//WgL0Sd9hIXZIQiStWSorZvvydVa2yL+9bBZu7zXY0fskTRVLVS64uzKJOeqVW8RqSvb5dOPXXzoI7U095JkhGKKAVljhbOQKXp8lXFfWutPrgWvqvxQ8CGpqqWWp+2TrJRV3eo1km2WZvarmtL3NUQljyzRAsfWNh/JYe5R8/VrU/dynVCERtpuzJLeYLBYJefBF3Tt72tXTt7diayL0oDpkQRiTQlIjRyIXNQ5qgk9Xpv4hb+BiUY3PrUrVwnFLGRxiSERvWt5UlRB4w4QGam7Xu2J64vSgsCNrRcGjrJRqwRCVLeSQ6zYRXbJGVNW7X1eEtfWEpGKGIhbWtsG923FmeOju4YrZ7e0qnVpPRFaUHAhpZLQyfZiDUi1RR3kn0Vl5DJScKatrSvx0PyhV1jG2fNOngsx/c5eqxhQ8slPRGhUWtEwqi2pm38iPGacsOU/rVhcVlLUrxmrc3a1Ou9FduwaBlxkYY1ts08eCyWtL4ojajDhtgorhcU51ptxbWcwtZXG6ygumztbe0ys5LpiTjUagtqa7k4tBMYSCu/40PRyj4zSX1RElGHDYlSbbFs1NOkxa/f6vV3QVdDGDN8TCzXkgStWZOkYTaMBAMkRq3veNR9UaF9QVOgzU7eSlJflFacYUMs1KrGvW7d17V58/d0yCFXRHKUu2bNVf2v7+6BldJbeQTedl2bXJXfW5Op76vBa96aobxkR9B0SRTtAoai2tUQDj74crl7pH1RoX2bN39P73nPxdq27fZIryJTrS+ScldEYJo0PM6wITGqLZZdu/ball84PuiMWuH1u7oeatoakbCqrQErrCVpxTVIg0p2mKyu9gJxVG0d2OuvP1jRF7X6jFtxf/Tqqz9rWoJBWNW+2yZr6TVIlzyzJLXXXy5G0gFiodYlY8pP+Xd2fkmrV89r2nX/ihfxunvJ648bd4ZOPvnZhr9mPaoVtHyr5y1t37Ndkkouqt6MI9ug6U+Xy2QlR9wUxUXSVEtEyJ15e0HSO32Ruzc1SapwfeJCX1d6YNsrL0vqafXBY1BfVN4HSLlp0s8v+3zJGflGnXUrX1vX7L4vSkyJIraqTZNOmHC+Xn31pw2ZlijvEItf02x/SZJ7/C5cXz4dubNnZ3+wVmyYDVOf9w25gww7/SkxFYL0CeqLivuH4n6hvE8ZiuLlGJ2dXxrURdybrZ6+odhgkxPC9n1Ju0h9mCnRSAI2MztP0tckHSPpZHcPjK7M7GxJN0oaJukH7n59mOcnYEuHoLUkUrukPkm9A3aSQcFY+TbFHeLUqd8ue83CioF3ph3imjFWay1Jwcj2kbpk+iVa+sLSkoBKUsXlo4q3CbqcVNBRtJS8ThIII7gveqd/KO4XyvsUqbIvCrqv1sFj4UB169bbIl0/G8aUG6aEDtrKDyglVZyFK75v/IjxeqvnrYpEhyBJWzsb54DtGOVGwe9J+uuggM3Mhkl6XtJHJG2U9LikC9x99UDPT8CWDo8/fqJ27Xqy6u8H6iSDgrHi2+Ud4okn/kErV84qOYINMmrUjKrTJlEJ20mWB1pBafkDPaba/aTzI60G6oskVfQhxQeUg+mfykuLDBs2Rvv2vVbxunHrj8KU9wkS1BeF6Z+qSdrBY2wDtv4XN/utqgdsp0r6mrv/Wf72FyXJ3f/bQM9LwJZO1aZIgzpJyasGY8XZp8Ud4ogRR2vPnhdifwQbZLCd5FAx/YksqpZJWtyHFPqO4qnMsP1T0MFjHKY/wwo7bdksSTx4DBOwxTnp4FBJLxfd3ijplGobm9kCSQskafJkstLSqFom6XPPza9ITChPFijfZu3aa7Vt2+0ltZZ2714tlZ1JavUi3sEqdEwDXWWgkZJ2BAs0SrUkqeI+pFC/rbd3V939U/Htd56/N9ZXgCk2//j5JcFSsw8oDxhxgEZ3jE79wWPTzrCZ2f2Sgg4FFrr7nfltfqvqZ9jOk/Rn7n55/vbFyq13+9xAr80ZtnSqPi1hKg60gpIFKg2T2bBEnk0LI6iDrDa1GQbTn0BtA625LQjXP5X2aQVxm/6sR5jL1g1GWvqiSM+wufufDvEpNko6rOj2JEmbhvicSLCgjiqokyw/8g0WfUp8M5WfcauWPBBmjUi1ZIWkd5BAIwWddZP2VmwXpn8ya0/NwWNB8Vm3sJe5qnbfmOFjtGPPjsz1RXGeEn1c0tFmdrikVyTNk3RhtE1C3AR3kuEyg5J8tBpG+bSEJJ02+bSaWVhBWaJZ6hCBwQrqS4JnBQbun9J08Bgk6IAyTJZo1vujqLJEPynpf0maIOkNSU+6+5+Z2SHKle+Ym99urqQblCvr8SN3D1WBkylRAACQFLFNOnD3X0n6VcD9myTNLbq9VNLSFjYNAAAgdriWKAAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxFwkAZuZnWdmq8ysz8xm1thunZk9Y2ZPmtnyVrYRAAAgLvaL6HWflfTnkr4XYtsPu/trTW4PAABAbEUSsLn7c5JkZlG8PAAAQKLEfQ2bS7rXzFaY2YKoGwMAABCFpp1hM7P7JU0M+NVCd78z5NOc5u6bzOwgSfeZ2R/d/aEqr7dAUiGo6zazZ+tvNYbgQElMXbcW73nr8Z63Hu956/Get957B9qgaQGbu/9pA55jU/7/rWb2K0knSwoM2Nx9saTFkmRmy929ajIDGo/3vPV4z1uP97z1eM9bj/e89cIkVsZ2StTMRpnZuwo/S/qocskKAAAAmRJVWY9PmtlGSadK+rWZ/Uv+/kPMbGl+s/dI+p2ZPSXpMUm/dvd/jqK9AAAAUYoqS/RXkn4VcP8mSXPzP6+VNH2QL7F48K3DIPGetx7veevxnrce73nr8Z633oDvubl7KxoCAACAQYrtGjYAAADkpDZgM7PPmdma/CWw/r+o25MVZvbXZuZmdmDUbUk7M/sHM/ujmT1tZr8ys3FRtymtzOzsfH/yopldG3V70s7MDjOz35jZc/k+/PNRtykrzGyYma00s3uibksWmNk4M/tFvi9/zsxOrbZtKgM2M/uwpHMlneDux0r6HxE3KRPM7DBJH5G0Ieq2ZMR9ko5z9xMkPS/pixG3J5XMbJikb0uaI2mapAvMbFq0rUq9fZL+X3c/RtIsSVfznrfM5yU9F3UjMuRGSf/s7u9Tbt1+1fc+lQGbpCslXe/u3VKujlvE7cmKb0r6G+WuUIEmc/d73X1f/ua/SZoUZXtS7GRJL7r7WnfvkfSPyh0QokncfbO7P5H/+S3lBrFDo21V+pnZJEkfk/SDqNuSBWY2RtLpkn4oSe7e4+5vVNs+rQHbVEkfMrNHzexBMzsp6galnZl9QtIr7v5U1G3JqMskLYu6ESl1qKSXi25vFMFDy5jZFEknSno02pZkwg3KHXT3Rd2QjDhC0jZJt+SnoX+QrzsbKJKyHo1Q69JXyv1d71buVPpJkv7JzI5wUmKHZID3/O+UK26MBgpziTczW6jcFNKSVrYtQyzgPvqSFjCz0ZL+j6Rr3P3NqNuTZmZ2jqSt7r7CzM6Muj0ZsZ+k90v6nLs/amY3SrpW0perbZxItS59ZWZXSvplPkB7zMz6lLs22rZWtS+Nqr3nZna8pMMlPWVmUm5q7gkzO9ndt7Swiakz0CXezOwSSedIms0BSdNslHRY0e1JkjZF1JbMMLN25YK1Je7+y6jbkwGnSfqEmc2VtL+kMWb2M3e/KOJ2pdlGSRvdvXD2+BfKBWyB0joleoeksyTJzKZK6hAXsm0ad3/G3Q9y9ynuPkW5nfD9BGvNZWZnS/pbSZ9w991RtyfFHpd0tJkdbmYdkuZJuiviNqWa5Y78fijpOXf/n1G3Jwvc/YvuPinfh8+T9K8Ea82VHyNfNrPChd9nS1pdbfvEnmEbwI8k/cjMnpXUI+kSzj4ghW6SNFzSffkzm//m7ldE26T0cfd9ZvZZSf8iaZikH7n7qoiblXanSbpY0jNm9mT+vr9z96U1HgMk0eckLckfDK6V9JfVNuRKBwAAADGX1ilRAACA1CBgAwAAiDkCNgAAgJgjYAMAAIg5AjYAAICYI2ADgCrM7DAze8nMxudvvzt/uzPqtgHIFgI2AKjC3V+W9F1J1+fvul7SYndfH12rAGQRddgAoIb8JZJWKFeQ+z9JOtHde6JtFYCsSeuVDgCgIdx9r5n9F0n/LOmjBGsAosCUKAAMbI6kzZKOi7ohALKJgA0AajCzGZI+ImmWpC+Y2cERNwlABhGwAUAVZmbKJR1c4+4bJP2DpP8RbasAZBEBGwBU958kbXD3+/K3vyPpfWZ2RoRtApBBZIkCAADEHGfYAAAAYo6ADQAAIOYI2AAAAGKOgA0AACDmCNgAAABijoANAAAg5gjYAAAAYo6ADQAAIOb+L5puiuH0b7CZAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "domain = np.linspace(-5, 5, 100) # give me 100 points from -5 to 5\n", "y_sin = np.sin(domain) # do all 1000\n", "y_cos = np.cos(domain) # do all 1000\n", "\n", "def plot_functions():\n", " plt.figure(figsize=(10, 5))\n", " plt.xlabel(\"X\")\n", " plt.ylabel(\"Y\")\n", " plt.title(\"Trig Functions\")\n", " lines = plt.plot(domain, y_sin, 'go', domain, y_cos, 'y^')\n", " # https://matplotlib.org/api/_as_gen/matplotlib.pyplot.legend.html\n", " leg = plt.legend(lines, (\"sine\", \"cosine\"), \n", " title=\"Key\", frameon=True,\n", " shadow=True, facecolor=\"gray\",\n", " borderaxespad=2) \n", " plt.axis([-6, 6, -1.5, 1.5])\n", " plt.show()\n", " \n", "plot_functions()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Historical Sidebar\n", "\n", "Do you live in a dome home? Trigonometric functions prove useful when it comes to computing the vertexes of a geodesic sphere. \n", "\n", "One of the best primers on the topic is [Divided Spheres](http://www.dividedspheres.com/) by [Ed Popko](http://www.dividedspheres.com/?page_id=19). Dome homes became popular in the 1960s onward, as an alternative to the more conventional house.\n", "\n", "\"Divided\n", "\n", "The two videos below, talk about how we might (or might not) want to envision dome homes going forward." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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\n", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import YouTubeVideo\n", "YouTubeVideo(\"QV4m76Om7bk\") # https://youtu.be/QV4m76Om7bk" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEABALDBoYFhsaGRoeHRsfIi8lIyIiIictJSYqLicyMC4tLS01PVBCNThLOS0tRWFFS1NWW11bMkFlbWRYbFBZW1cBERISGRYZLxsbLVc2NTZXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1ddV1dXV1dXV1ddV1dXV//AABEIAWgB4AMBIgACEQEDEQH/xAAbAAEAAgMBAQAAAAAAAAAAAAAABQYCAwQBB//EAEcQAAEDAgMDBwcJBwQCAwEAAAEAAgMEERIhMQVBUQYTU2FxktIXIjKBkaGxBxQVM0JScsHRFiNic4KT4SRDsvA0s0Si8cL/xAAYAQEBAQEBAAAAAAAAAAAAAAAAAQIDBP/EAB8RAQEBAAIDAQEBAQAAAAAAAAABEQISITFBA1EyE//aAAwDAQACEQMRAD8A+foiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIrh5OK3pafvP8AAnk4relp+8/wIKeiuHk4relp+8/wJ5OK3pafvP8AAgp6K4eTit6Wn7z/AAJ5OK3pafvP8CCnorh5OK3pafvP8CeTit6Wn7z/AAIKeiuHk4relp+8/wACeTit6Wn7z/Agp6K4eTit6Wn7z/Ank4relp+8/wACCnorh5OK3pafvP8AAnk4relp+8/wIKeiuHk4relp+8/wJ5OK3pafvP8AAgp6K4eTit6Wn7z/AAJ5OK3pafvP8CCnorh5OK3pafvP8CeTit6Wn7z/AAIKeiuHk4relp+8/wACeTit6Wn7z/Agp6K4eTit6Wn7z/Ank4relp+8/wACCnorh5OK3pafvP8AAsJPk8rW28+A3NsnPy6z5uiCpIrefk5rekpz/W/wr3ycVvS0/ef4EFPRW/yc1vSU/ef4V75OK3pafvP8CCnorePk5rekpx/W/wAKH5Oa3pKc/wBT/AgqCK3+Tit6Wn7z/Ank5rb/AFlP243+FBUEVv8AJxW9LT95/gQfJzW9JTj+t/hQVBFbz8nNb0lOf63+BPJxW9LT95/gQVBFb/JzW9JT95/hTycVvS0/ef4EFQRW8fJzW9JTj+t/hQ/JzW9JTn+p/gQVBFb/ACcVvS0/ef4E8nNb0lP33+FBUEVw8nFb0tP3n+BeD5Oa3pKcf1v8CCoIrefk5rekpz/U/wACeTit6Wn7z/AgqCK3+Tmt6Sn77/Cnk4relp+8/wACCoIrePk5rekpx/W/wofk5rekpz/U/wACCoIrf5Oa3pafvP8AAoPaWxJKaqbSvfG6RxaLtLi0FxyuSAgjEVw8nFb0tP3n+BPJxW9LT95/gQU9FcPJxW9LT95/gTycVvS0/ef4EFPRXDycVvS0/ef4E8nFb0tP3n+BB9PREQEREBERAREQEREBERAREQEREBERAREQEREBERAUPyo2o+jpefYA4te0EHQgnMdSmFF8odlispxA5+BrntJO/I3sOtBs2HteOtgE0YIF7Fp1BGoXZNOyMXe4NB3k2WnZuzoqWFsULcLB6yTxJ4qK5YfUR/j/ACKLJqV+koOmj7wT6Sg6aPvBfO7JZG+j6J9JQdNH3gn0lB00feCosFM1zA4ki7w3Icd60SRYXlnA2v67InWPoP0lB00feCfSUHTR94KjTUTWh9nE4HBpuOPBeS0eHnc782Ru1uriZF6+koOmj7wT6Sp+mj7wVHmog0Ps43YATlkb8FjJRBrS4uyDGu03u3JhkXr6Sg6aPvBPpKDpo+8FR3UGcIB+sHDRYvo7GUX+r6tc0wyL19JQdNH3gn0lB00feCo5oMoziye0nTQgXskNEHBl3EF97ZZC3FMMi8fSUHTR94J9JQdNH3gqHHAwxueS4YbXFhvK8fTtEbXkm7r2FhbIqL1i+/SdP00feCfSVP00feCowoRYeccRjx6ZZblzU8WN7W6Yja6HWPoX0lT9NH3gn0lB00feCocdM10mAE5A3JA3JHSA8zn9YTu0sbIdYvn0lT9NH3gn0lB00feCoUFNikLL2tfPsXlNAHh5JIDW4shqh1i/fSUHTR94J9JQdNH3gqHFTtc17iTZpG4XzWuph5t7mXvbf6rodY+gfSVP00feCfSUHTR94L51ZetGai9H05VLlFyTM1Uyshd54ewvYdCGkZg8bDTqVrj9EdipXKjlLMyujo4xgZjjxO+04OINhwG5VzXdERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBVvl+8t2c5zSQ4SMII1BxKyKN27WQwQtkqG4oxI2+V7G+Rtvsg5uSNTUy0THVQOO5sSLFzdxIWvlh9RH+P8ipqmqGSsEkbg9jsw4G4Kh+Vjbwxi9vP/ACKLPanraKc4MRyv6I3u7BwW9lDID9WXO4Wyz0uVsewxEvkkBk3NBufWdAEb17SG0QuAf3w17Fy1AtO7f55+K8dOdBk29wOsLGSVztTfO/tVEhVm4nyAtI3Tf2ryq/8Ak9rFxSVL3Agu1zOmZSSpe4EE5HXIZ20urqY6qyMl85xEWa2446LZXDFTttq1rSesEWXC+pe4EE5HXIXNtLlefOH/AHvs4fVwTTEmHDm772BpH9TAFpl1quwfFcQlecrk3sLDfbRSVPsud+NzzhDh519T+ianp7Cbst92MOHraQVqpIy5sbTdwIdYi92evrU5Ds+OMA3ubWzF7jhZbXsdkfQbpk0A2U1NV2GhlEMrSwguLbXyvYrOWhlMLG83m29yd1zcWVjsWZjCeuxv7Vo59wcTYcLZ59imnaon5pIGi8ZyhILgL2PBRdG0tnjBBBxDUK0CUk5Waf8Au5MTtHWcB/CCferp2V6ldeoOQGT9OwrKH/4naf8AkpObZ8V8cbix99w463Ci62mniLXHNrfRc0ZD1bk1qXWNH/5Dv6/zWNAbNlOR/d7+0LSKl+LFfPjYb0bUOBJBtcWOQ0TVx0Uzv3Upwg5ty3arXtEfvn+r4Ba+ddZwvk7X1LGR5ccRNyU1Z7YWXrdUK9bqFlp9Jj9EdijNu0dK9rH1GFpa9uB/2g7ELAcbncpNnojsVD5XbLqjtGGozfTh8YFv9vzhe43XO9VwX5ERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBQXLGgkqqIwwtu90jOwZ5k9SnVCcr9oyUlHz0RAe17ddCCcwUG3k1sb5jSiEvxuuXOO653DqWrlQ4CKPFpj//AJOo3rdyc2yK6mE2DAblrhuuOB4Ll5X/AFEf4/yKLEHLtIlha1zndZysOoDIKOceK8BsV64KtZgi8XqiiIvVVeLfSUj5XYWjtJ0HaVlQ0bp3hje0ncBxKtFJDFGwMZYfecdf/wBUZtxooKJkRIjBe62b/ja+i7JC62EAAbwDnbtXj5bOswHMW0WQLrZN9pCMMaeLeDbdxstjo3Oyxeuy0xSOuRbI566rp50geh70GLITqSCetaaokDS5GeRWDqp2ZDtT6I1QTt4H2FBoM+LWze0LVvNnH3gL10gF2ix4dixLThGdwNRkorIu37+BzWTX2ydofZ2LU9rSbAaarwN3XPtQcVbs4Oe4xZfwn8lFuaQbEWI3KcDy031Gi01cYlGmY0dw6iqsqKCxWb2FpIIsQsEbgvRqvF63VRp9Jj9Edir+3uVMVPMymaMcz3NBH2WhxGvXbcrBH6I7FXNvclWVFQyqjdgma5pdf0XhpGvA2CrgsqIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICjdvUEVTC2KZ+FjpG3ztcg5Nv1qSVa+UAE7OcBckyMsBrfFuQT9JSRwRtjiYGMboAoblf9RH+P8itnJGOpZRMFXfnLm2L0g3cD1rXyv8AqGfj/Ios9qitkbC/zWgl24DVYMaSQBmSbDtV02Zs9sDALXefSO8/4Rq3FY+iZ97LdpF1ompnx+m0j4e1XGd4AubAb7qKmq4SC0uDhvGZVZ7K8so4y9wa0XJyCzqo2teQw3bqFL7ApgGPnfwLWdu8hRrfCUpqIQxiNtsRzd19q3MOW4vJ+H5LBsjrF1rX1JWNO25dcm6ObZOAy2839Z4rNjw8cBwOp7VyyjzvN1G85+pYwNxXvrfNRXRM4AhwOizxc5+H4/4XIYw45DIa9a8jiGYIzCDbVMtYjcvJKgBtm+kfctEzbGwvda4Y7ki5BHWiszHYX14rGQNtkMzos5Wua03dlwWg2xeYLZZ3QeYS06nNYSk5XNxw3ra8kixHsWgPBOeVvigxLwCRY2WEj7aHXL1LbO37XtXLJ517blRrqhiaCdRv/VcS6jIbFaJQL3GhRqNaN1RBqjb6VH6I7FROVu2qkbQipReOAvjOX+55wJz4Xysr3H6I7FGbdmpWsYKnCSXt5sfbxYhbD60cUqiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAozb+0mUkAnkZja17bgai5tcdYUmoblXsySspOYjsHOe25OgAOZQSGz6+KpibLC4OY7f+RG4qK5X/AFDPx/kV2bA2OyhpxCxxdmXOcd5PwXHyv+oj/H+RRYruyADVRfiU5tLbOA83EMT9C46D9SqzG8tcHA2IzBW1tRbcFYcpfjoIfKQ6Vxd1bh2LJ0jIxxNtB+a43zuO+3YtaupOH9ZEl7usmwVupKdrWNaBlb3D9Sq7sSIOqGk6M84+rT3qfBcWuOgN+2wUXk2teHBovkBn+i1zTBhuCMxb1oyMOJuLWtksaiO4Nh6Jy7VEI5mgaknsK1GYBxtcA65LpYBgxbrXWmVtmh28G5/RRWbKlgyzHqKxdJicSzhvvqszhDcR0XOGl1zmLjRB7FI3UnMrFzwHh1xbQrdEQWjJa5GtcbWFhrl7kGMj8br/AGRp+qxkbazhu1WDWai5uEkcWjNxsg8mksMtSuYt3rwFxJ4rJ5NrWVGDnWC5A4tPELdNkRc7lzznIH1Kj0uzJAyWpwytvutXOm5APm/FGS2c26KI05oRZeDVZdH0xnojsVI5Vcnp3V8dYz95HjjxN3sAcBkOG9XeP0R2Kr8oeVggqmUkLbyl7A9x0aHEZAbzY+9VxWpERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBQHLWskp6EyxOLXtkZY+tT6jduw074WtqiBEZG3ubAm+QJ4XQaeSu131tI2aRga65abaG28LTyv+oj/H+RU3DG1jQ1gDWgZAaAdShOV31DPx/kUWKivQDa+5eFbwBzWYN8WvqVaal4vV4gmuTgA51x1AsFKkWIbxt/n4KK2GP3bz/FftsBl71Iudd1zc7rDrUYvtsnlDTivutb4LBsww2sT6loqJW5DCRv8A0XjK9mEm9iNx4oM8ZaxpJ83FkLbzotdVPm1ljdzgFpJAfE4/fF1tqifnMVtcWXsKDGWfcQcLP+hdMM7bC9wd+RXLVgCSNm4uAPWLrtrZ2R3LiAEVoMwBIaRnmOrisoyLZEKMm2oy9wC431tks21zDq0j1IjsqDhIPHJcb343dQT5ywuu0jgb3CxDsV3A6ncmDN2RB9S11Mv2Rv1SV5DdVyNkOpF0Vk9mfatMzQMhvW18otfgucned6qubFdYv0v1rFwsStTCcRF7C+/RRXVE+4PaR7Fm3ULVS2wm2YubLaNVG56fTI/RHYoTbvJyCpkZUE83NG5px7nAOGTv1U3H6I7FQeWNVVfSMEbsTaUyR4Lei44he/E33KuL6AiIgIiICIiAvkO2Z5BWVNpHgc/Jo4/fK+vL4/tkf62q/nyf+wqV2/L3XL84k6R/fd+q9+cSdI/vu/VYWXtlHoZfOJOkf33fqvfnEnSP77v1WFl7ZFZ/OJOkf33fqu2gpZpc+ceG8cTs+zNZ7J2ZzxxOBwA+08FaPmwaLAWAVkcf0/TPERYgLRYOd63FaZQ45B7vaVKvhuFyTMw9q04ZVe2g2Zhu2SS3DE79VHSVcwyc+Qf1O/VWSUXyUfVUjS0g6cfunip4W9kSKuTpZO+79V786l6WTvu/Vap6d0Zs7/CxD+KMN/zqXpZO+79U+dS9LJ33fqtdksg2fOpelk77v1XvzqTpZO+79VqwFe4Cg2iqk6STvu/VeGseNZZOzG79VzvfwWpFx0urpSfrX9936q6fJnM981Rie51mN1JO88VQlefkv+uqfwN+JQr6KiIiCrnLyF8mzyxjS57pGAADMm6saiuUm1TRU3P4Q8Ne0EdRNjbrQaeSOz56aiZHUG77kgXvhB0bdY8rfqI/x/kV37H2rFWQCaEnCciDqCNQVwcrfqI/x/kUWKtdgO/3LZhbzeK7vS4DgVz710GN3M47WZjAv6lWmpxYQdcW7IWWpzgNStG0ZCyPEOIUcahzYxIx13XzP3US3Fopq0QQnnAGAuxBz3Bt8twzPuXJJyjvcRBzs/sRE+8n8lDCjPM8/MS6R9sOLOwvr67KzUVe6CnYxuVm52G855qMoip23Ne74pQT95gC0R7czzFu0W/VbdoV3PvdIcT8It6RAACjKmrYHYTG05XuDfXrVFgpdoCRzLaX/JSIkcZY32JwnPJUlkjo3Y47tsVZ4eUbObFywEjMOLr+xoKmjsr5sVjmLH1rgqJ42m73Cw1cScz8T2LRWbcYWHDYuOhBuPeuPZkIdIySUB1z5rTmABnoiu5tY+UWp6aabrsGN9WvxXJJVVANuYItu5w/qpyp268HAwknc1tgB+ir0tSYi7G0EttcYjc34ZIh9LSs9Jjm9tj+S2w7dF/OZcHhl7kh2zE4Wcwj1XC5NoRRelGQOLdPcglhtOJ5BD8P8Lsl0xvBvZVqEN5s47Wvlxutccjmg4CRnu1QlWWZ9wRuAXKG772UbHtWUCxIcOsZ+1bPpBrhYgt+CNa6DK2wFySVold5wHE3PsWJIzde4A3LBrjiQdmzm2j9ZXSNQsKdtmC3b7StgR0j6XH6I7FFbd2tTQ4IprPfI5obHqb4hZ3VY536lKx+iOxU/lLyWkkrWVkJxeewvYdbNIF2+oaI4rkiIgIiICIiAvkO2P8AzKr+fJ/7Cvry+R7YH+sqf58n/sKjt+XuuFegL2yAI9BZbIIi9zWjVxssQFN8lqLnaphIOFt3E9n+bInK9Zqz7O2eGMDQMmiw/VbJYbmw0HvUkWBkZWMUHmX3la14p71GSNwjLVRlVT7zmpyoiyKjqtuSjrEO+Jc0kak3tXM9oRaipIwThcOxR1XQ624ZKdnhuLjUZrVLFiZiCOdiBgIc3SxGRC2YVom/dzHgV4+qt1oy3PIAuVxyyl3UOCxe8uNysU1uTBeL1FFxirz8l/11T+BvxKpFld/kv+uqfwN+JRmvoqIirIonlJso1tNzAcGYntJPAA3NutSyrnLud8Wzy+Nxa9sjCCDYg3QSux9lRUcDYYgcIzJOpJ1JXByt+oj/AB/kVnyR2jPVUTJahtn3IBtbGBo6yw5XfUR/j/IosVeKEO1kYzO1nHM9gGZW2qMLoGx88wPa4FxOO2Tr204LPZwdfE0RizjeR9/Ny3DEFvfI+7rS0hudSBn2+cqWoxwjcDhkjkHUfyKgaqkwzBg9F5FvWbKeAf52JlOP5WnxUZtdtubkH2T/AJHwSnxJbbGZaNA/CB1NFh8FnNmLbrZpWESNxjMOdiH9QumqEcrtnnPA4EOGYOV1yHY7iQXc3lvL7e0KbMWKxwk5a7lmyiGpaD22t7ERByUP7p/nYiAScIyvbipDY3JZs1KZ5XOF/RaPdddu02EUzsP2rMFtLuNgrAYxFRsYNMh7P/xQfNdp0XMSmO97aFSEFjMGHcPyWvlEcUzj129ll3Rta5kdQNcNjb2FFjU6mcH3jIvwOS5quilkcSYyb66e26lS8EX1CCNrhcPI6rmypURBsd7bFwaxoNzicLn2LOaGNxOsj+IyaF3vpmj0mOd1h1/cumSk5uB0rjZoGTSAERWtnUfPS4SThGZKnJtjREAaW0IBBW/khs0PhfK7IudZvWBr71Ny0RGh+IUFLqNjubcteHDrBB9qjnxEagj4e5WPaE/pC+QyHaolzrIuODMaaLcZsQsNTqsoITK42G/Xgpqk2RTss6R7nO1yyag8aLADgFk3cut8ETvq32PAm4XJYh1jqCjpK+lx+iOxU/lLyqkirGUcIwnGwPedbOINm+o6q4R+iOxRO3dkU02CWazHxuaWyaG4cLNPEHS3WjkmEREBERAREQF8n2sP9XU/z5P/AGFfWF8r2s3/AFdT/Ok/5lHb8vrgIXllsLUso9EYBWzka+8xvuiuOAu+35Kqhqt/ImE/vH7rBo9t1Y5/v/lZaoXbbiQPet1sli8XIHXdYS1DWo8zlqm3CjcNwbqR+cgu7Vw7QJif1FV0jiliXJJFZdEtSXEtaLHryWIgvrI2/DMrU4peWOOyUjc3MO4+4rsZQlwJDgbcAuTmpI543Pbha8ZH72YsUzGLZVW27TmOY8FGKe5WxYakH7L2gjt3qBKzUle3XqxS6y3KyXq8uiNPVd/kw+uqfwN+JVIV3+TD66p/A34lE5en0RERVzFG7dlp2QtdVAGISNvcXAN8iRwupJQHLWjkqKExRNLnukYAB2oJyF7XNDmEFpGRbpbqUJyu+oj/AJn5FbuSuyH0VI2GR4c65cbaNvuC08rvqI/x/kUWe0Ds2FxcHNhD7O9NxOFuW8WzXRJDIXOPzemdc64iLrl2fEHPH7l0pxZZgMGX2siuiShGJ19ntOeocLerzVUvtGCnLQ69MyL8DrgLXJT860x73adqzFOGYrU74epzr29y6qBgLnXFyAbdqNfEPsyrwA08uVvRJ3dXYpYtyC0xbLZVS824lpIOFw1Bt8Frm2VX0oOG0sY3j9DoonpJ0seIWuRZSNLTRtBfJoMyXHJVVm06pukFj2f5WOGsrniP12vkLe4IizwSiumxgWpqc+YPvycewBd+1XtZG0WvwHXuWnZETYYo4A2zQMzxOp9pWnlDURswH7V9Bw4pCq5tHZ+IOI1vf26rhoql1M4xSjzHZ/5Cl3VHO+bGDi7Ny11NMTGGTNuBo4ahKR0ikxNDmG4O8aL2i2Lj1kOWoAUNHBU0xvA+7D1/ELpj2vXA3awYuIt+qKtMGzYoBjdYW3uVb2nVHaE4pqYHBe7nDSw1K0yQVNSb1U+FnAHP2KXoa2CljwQM7TvcesoYn4Io4YGRNtgY0AfqoLam0MnMicbWzP5BcVVtB8hzNmncFxPkRcctU/Qetckx809S2zuu++7ctFScrcUR7SvIZYcVjLVkZDzj7lg3EI8uNj1LbBG0tvvQeNqnNcMXu3KXjnx2v6QyP5KDqOClKBhzdxIA9SLx9vqzPRHYqDyxp6v6RgkdiNLzkeC3otOIXv133q/R+iOwKE27yigp5GU5HOTSOaMG4AuGbkZTqIiAiIgIiIC+YbVH+qqP5z/+ZX09fM9qD/VVH81//Mo6/l7cBasCFtcsCFHpjBXXkrM0MwDINZid2k6+4qlq38kwHiQHRzALe39VqfXL9/UTj6i8lsRA4gDPK+pUDU7TxyEMY7Be2JznG/WBwU08h5IcQCDmL20FlzTvjwhuQtuH6qzxXCTY4IKkCTS9s8t/Utm1XOu12eM2dY2Nt9l0bOpGueDa4Hs/ytG3Td9xuTWpPKvVEj8Tgcjc26xuPsWdDI5hxXz6xddLm47cQjYrbyPYtbnpOu+2+nqS25vm43OS1zHE2+8G49t1nHTjXVezMsFm064r3KYiWRgH2Qfhf8lXJG2cRwNlM7Uc6OUuOYPuKh5TdxPE396vL05yeWCIvFhp7de3WK9QlZK8fJh9dU/gb8SqKCrz8l/11T+BvxKi2+H0VERVkUNyq2m+jpOfjAJa9twdCCcwplRnKDZjKuAQPfga57bnebG9h1oPdg7YZXU4mYC3PC5p3EfFc/Kht4Wfj/IqR2fQRU0TYoW4WN3fmTvK5tuRB8bQQD535IKzSMaHC/OG7vRYbB3bmFjNHHideKrGe55sP/spBrAwHz3MGpwA5+xR89bG1xBq6hnVgdl/9VYOOlYw4sJnP8w56dq7qKOzj2LChBc0u550wdo5zS266wwg6KaOfZzS2dhGZvb25K0CwbbX81WqK4ey7XC289inozliKDU7ZcAzczEdwJNvYuCXacUUpjbhaGtyAAF881trq7CwuOm5aNkbMa6F8s7Q502diNG/Z/VBHVe2Y3BzWvF78VEVc4ccQcLjr3Lo2jsMRPLQ0X3EcFEy0xDi2yok6TaUcQ1F95ut822WvadCoBlNd1sO9dEVEdAN6YJTZ1RYAO9B2nUeC73Uo+6Fq2VQY2ujdlffwO4rqopC1xikye027etFaH02WQzXKWqdmYALqGqjmSNFFlckpXLPJl1lbpXLildc33aKK81C5JXXK6HusFyqs11Ux81a6bK4Wts1m2GpW2PIZ6lVBsZfKGjW4VhZThoDRuXNsCiLsUpHUPzU583KjUuLkz0R2Kr8oeSfP1TKuF1pA9he06ODSMwdxsPcrSzQdio/KnlFO2vjo2Dm48ceJ32ngkHI8NyMryiIgIiICIiAvmm1P/KqP5r/APmV9LXzPan/AJNR/Of/AMyjp+bkK1uW5jL5nJo1P5DrWiVwJJAsDoL3smPRL5xgSpPYu1fm7zc2bhJv+XvUSStUoDmkHRJcP049uOPp2x6lk7CcidSOAOYW+tgbh0A7Aq1yBflIHXxOAd/TewVkrz5uSv15ZLxvkoHDA62Vj61FbRaDc3UpSUobH53pE3UTWxB0pYCfarG98ooEXyOYW5hzsViYsJW5oBsqutzW5LVK3JdDTksJBkVGVZ2xQulFm2zO/RVmWMscWuyIVtra20giyOYuO1V3ar2ukJFks8Oe+XCvERZHoCWXiINjWDir18mjAJaix+w34lUIFXr5MDeap/A34lB9EREQFWvlAcRs5xBIIkZYjUHFuVlUbt6uipoWyztxRtkbfK9jfJ1t9kHNyRlqX0THVd+cubF3pFu4nrXRt6d7ImlkRlu6xANsrHNdtJVRzRtkieHsdoRosaxt2jtUvoVdtfJoaSQZcQubarBJC15Y5puG4TbERiAt71Y3RnJR20dnPlwYH2wm9iNTiBGnZ71njRhCcmgQvA7B+q6Q2/2SO0LXJJMxpc4RgNG8uXL9MkEBxiF+Jdb2hZtJLXeYgLGy3Suu22nFcskkhYHHBhNs2klb5X3jHFa4+hEzxc/OGHKNub+zcPWpiSfSwyH/AEKM+cRw4sRu9xvbeo+s2xIThhjxHtC2qcnLZHAusNwUdFsgPkc61w43HYoc01dJmYHn1i3xWqaepjBjcyZh+6A63uQSMWz2iWTTJx3rrFGGnUG6gItnVoGIU8ljnfK/xWz5xWR+nBIR/E38wgskLubN8ItvsubakeIc830m+8KJp9u7ntcy3rXYNoMe0hrh2INoqscV1HVDlsLC1hLfRJ9hXHI25QjkqZdw3rQCs5syStOKwuisJnXPYtTlmdFg7NEbIbAXOq3wxOke1oGbiA0dZWuFzWtz1U5yfgeHfOnMybkwHfxI+CItFJs8RxtY3Rotc7yt5prbwtdFtZkjsJ8x+4HT1Fdcsw45b1MRKt0Ci9uwUrmsdU4QQ9vNu+3ixCwb61KN0VD5W7HqTtCGqzkgD4xl/t+cL5cL53VVfUREBERAREQF8y2oP9VUZ5c8/Ph551X01fL9pvJq5w0G/PPFt5OMqxvhvxzSyXyHojT9T1rQ9y3V8IhABdd32wNGHc2+88eGiiZasn0farY6znxkdLnrRJKDkDmclxlxcczdesfnfgpjPL9t8Re+SDx84cWnJrcDhuAysrdIMTr7gvlmxttOpRJYXL759qvmyNqipp8QPnWs7qKZjF59rtdku1GtDrAuIOguq/Nt3HIf3bmuG8tsrNTxNay1szqo3aFPc5MHaq1xxAvr3E/Vn2LdFM92jLDtW8xG+gWbWcVVuN8J83NYzOs0lAbLi2jL+7cBwPwUYtUitqTJM94OpNuzQLmJXi9UYYovSvFARAvUHivXyXfXVP4G/EqjK8/Jd9dU/gb8SqPoqIigKD5X7OkqqMwxAF7nt10AvmSpxQXLHaElLRGaF1ntkZuuCL5gjgg6OTexhQ0whx4zcucd1zwHBdldIWtFhckri5NbZ+fUomwYHXLXDdccOpdde4ANv97L2FBxXe77Vuxc8sZvmCetdt+sBYyOtbMDXciIqoMjBcOJbvDswtdNJTE2lgiaTo4NFvXwXTVdo6goSozdYAg29X+UvGUlWWqp2thIYA0ZaCw1WqB4wkb1F7C2hmaaU3a7Jt9xtp+i3PxRvLTuWZ4aRu0ReZ3q+C3x0QdGG6HUEbisJG4p77slIU9r29i0ISfaVRTea4Xt1rV+1U3A+1WSuohLC4kZtzBUA7ZrCg1ftTLvDvatNRyhlcLAHPiUqNn4M/srgIF0CMEkudmTquuOkBzG7MrVAwuNhvUqxgY23/SiuinP7i3WVFVTsN/cu/nA2L2/FQtTNiJ4bkRrxBc/FZuKxOiDWSvGRl2gvkSewaleHM5KZ2RC0MFxnKS2/VcAj3goiy8nqOmfRQOMMZfh84loJuDYm56131QFiMuoZacFC8mKnBFLCf8AblcPUTdSM0t9/vREPXx55Zda6qLaJe3C/NwyvxC5qt11y0bmiVpcbNvmRwVrXx9LZoOxVzb3KqOnnZSsbjmc5od91gcRrxNirG3Qdir23eS0VRMypYcEzHNJ+68NI14Gw1URYkREBERAREQF8u21Wtpqio5sh07pZPOGkYLzkP4uJ3aL6ivi23//ADar+fJ/7HLXE1wzTudkSsLZLArO+SqViSuqMYaZzt73hvqaLn3kLjXbU5U8DeOJ3tdYfBZb4/a5mHNSOztqyUsmOM6+k06OH/d6jo1lIVr4w+rbC2vHVxB7MiMnNOoK7a2RuBfLeTu1jSzXP1b7B3VbQq/TVGNgc0hwIyIUblaXgXWBK55JXW00XO6VxWlvJ0STcCo/akuCne7eRYdpW0vDQSTkFXNr7T54hrcmN06zxU9sIo6ovF6oPCvF6vLKAvUXqDxXn5L/AK6p/A34lUZXn5L/AK6p/A34lB9FREUBRu3qOGohbFUOwxmRt87XN8m33XUkq1y/YXbOc1oJJkYABmScSCwU1MyFjY42hjG5BoGQWraBGAX4qO5I09TFRMbVE47mwJu4N3Art2qSGNIF8/yQcnOnK2nWtUmF1na62Wjn8yM1rmkBsbqsvJ5b4cOl7X3/APclwvIcX5jqvutku5keLPMAnIAanj2Lm2hQhrTmcI9561RBzP8AOxNy4do3qzVMjJoopQ4Yi0YhcXz/AMqvfN5ZQHRROkHG2XDVKXk9V4g7AGWN83Bc7WkxIzCMtb3W1tnWIyPVxXBPWNjcY3mxG47v8LKOpcxwLXZO+K0LFTREt8/2fqsQGAEHDcZG9lHM2nIPule1G0wWYQ0g6E3Qcm0Z2PJaxow7zbVQcuzvO80ix4roqdoNY8tsT2LWNps+673IrdT0ZY3Ii51K8lbhF3OC5n7RAyaD2FccspebkoM6ipxZDT4rlecvWvXhaXyi1ggDPNeONxhAuSjGFzgACTuAUvsCNvOljgMWNt3cGi5I9wClG2PY/wA1rKRshB5y2K2gJJFr+xbWQtjkkjBP7uovh/hsbn3Ls5VkPEbw7Nl8wdMwb+5ccc964yZXtcjiQDcevNSVHVR0ZbtGohDxZzBI07j/ANupaTZTukAUC2pDK2meDkA6En+G12E+q3sVlNS0n0hYdaW1EdJs1pAjJ88uPn9gHm29aN5ONNiZnHsAC6nPuGu34nH4LqEu/cVm7VTzRkOxULldtWqG0IabNlOXxkW/3POF7nqOVlfRoovbtXSsaxlThJc9uBv2i7ELEcM966CVREQEREBERAXxblB/5lV/Pl/9jl9pVdquRVFLI+R4kxPcXus82u43OXrVlxK+SFbGROdkAvqX7A0H3ZP7hXRHyOo2iwa/vpqvmMOyz9pbNp0ps0jRjA32ar6d+ytLwf3ljJyRpHNwkSWP8aa1vh8iaV68r6l+wNB92T+4U/YGg+7J/cKusY+Ugqb2Ntp9ObenFvbvHYr3+wNB92T+4UHIGg+7L/cKSqiPnkMgxsfa+6/5LjfUxA5vyVl/YWh4S/3Ch5CUPCX+4Vdg+f7W2gHnCy+FRDivqv7BUH3ZP7hT9gqD7sn9wq9oj5TZF9W/YGg+7J/cKfsDQfdk/uFY1XyleWX1f9gaD7sn9wp+wNB92T+4U0fKLIvq/wCwNB92T+4V5+wNB92T+4UHylXn5L/rqn8DfiVPfsDQfdk/uFSOxuTtPQue6AOBeADidfRNEsiIoCi+UO1G0dOJ3Mxta9oI35m1x1qUUPyp2W+speYYQC57SSdAAcz1oO7Zu0IqqFssLsTD7QeBHFe1zrNHaufYWyI6KnEMZJzuXHUk6lbdpegO1S+hEz14DwwuDCcwXDzSBrnxWmh2qJXkWs3QE73cAezNRe23vY10Y85rvOF2ku7GkDRcrqiZ8zZGsJAt5oY5rbjS44pkxE7FWBriDlYm/HXKy5dobRYWuLNd/X1FZ1Gz3ztDnHmZf4TcEda4JOTsz/TnbbqBSWK7uTM9qc3IAMhwi+7L87qZ5xVpnJrMAzDLcApXZ0DY2EMc5wBIuTqRwWL7HDt+NsksbSLuIsONzp6lw1tM2BhwPcWg5B1t2pHAKSMJlqnHcwWvwvl+o9q6q2mY6M3a3zW5Ze5a9CEmrRHHc2LtAAdTx7FFGrlJvjOamdrSMEEb+bDTz2ECwzaG3+KhJZwQThAvplZOysC6+uq1yOwi59i9EjSeHWjy25uM+vcnYaY3auJXjqjgPauyp80RnCBiZcZa33rSXDCTYZ5DIetNNcxxOOhPYs20jznaw61va8nLQ7v0XnOG9lNGezpMLXG3nXIv1La+UB5c0a69RP8A33rnw4JZGfx/kFiZNetKOwPMge072O+C5RKbMd94591baF376MbnG3tystDXFrQw38249ht+SfEZz5jGM7EZdd1IQ0078xG8g9RAWGytqOgdk1rm7w5v56qbZypglb57HsJaQbG/bY3VzRxGmn5oDAcXO3AuNMPatZjqW28x9ltxUfNXxVGDnPutvfD2+9drOUFPGGhkUjrCwJNr8Lm6mQXWP0R2KlcqOTU76+OsjONmOPE37TQCBccRvV1YbgHqVV5Q8rDDVMo4W/vC9ge86NDiMgN5sfeti2IiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgKv8ALerkgoTLE4se2RhBHarAo3brKd0LRV25rnG3v6N75Yuq6DRyU2rJWUbZZWYX3Lchk628Lu2j6A7V0RNaGgMADbZW0t1Ll2ofMaOJz9il9COxjiPavC8feHrK9DBaxzsvHi3o6nTf61hXovuzWipqHxub+7cWfacNGjrW5pLMsiPfdaqqZxjBjuHONvVvQV3adU5suNhkYJThGLSxNsQG5WGOAxxCOM2sLAn4qD2xTvmZTMxec4G5IAtYE+pTGya4SU0b5HNDrWdcjUG1/csxqo+HZ1UJC7ngwO9LCAS7hrouxlC4DznYzxdi/VdzamNxs17XHqN/gvZ3lrC4NLiBcDite2UJNhcKdhaDZjzhtq4uDBbryK01HJ0P0dZ28DQdS8+dyOqmc1EHEsDbm4wEkl27r1UuyCo0c9jRwYD8SrySKtPydnZoA4dRXFUU7wAS0hw809fA+z4K9Ci4kO7cR/NJqPEwgFoIzFm7xosxVS2yLxUTbZiAX9u9Rb3XOWgyCuHzcTTESABjGtxdudmj1/BZy7Npb+cGjqB84+oLVSKVdbHHEMW8el2cf1Vpk2JC70In9pOEe/Nahyfib5zpA0bwDfJTVQu1GYKuoPYR2uaP1K4QpiriidVvE0hALWFuFt8XmAD3LL6Dxeg2W3FzQPcVeSRF00uF7TwcHDtByWe0Lc/JYFoxE2OouSbe9S8PJ+RpvkcvtH9F0TbBfK4ukkGJ2pAzNk+CtscRosmjU77fFWJvJtu97j6gs2bGbEQ5jS524k5DrtvU8iLFGeb5ovGO+LD/ABW9G/Gy476ZG4NlYG7FGpDrk3138Vvk2dicDzYJ3km1zxIRV0i9FvYPgoXbnJ+nqHsndaOWNzSJL62cLB3FTbNB2L5/yxlq/pGBrsQpecjwW9EnEL4uu66I+goiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgKu8uqd8tAY42l73SMAaNTmrEonlNtV1FTc+1odhe0EHeCbFBr5JbNmpKNsU7rvuTa9w0H7N12bTOTO38ivNjbWjrYBNFexyIOrSNQVhtqQMY0n73XwKl9DgL8J7RkjZLXuN65jM0gnFcg3HHsHqWAlu618zl2dX6lYV1vdiBdlYf9svRG1zRcXtey5HSjUZf93hZRS5AbzoO0qKyfsmBxBLTkLAYjb2LTT7Dp4wMTecP8VvgtNVtTmqswuzbYAkbnHP2Zhdxm4ghLDXSwBos0ADgBZe41x8+veeUHXjWh9fE0SEu+rID9ciQCPiFr51QdU/za/8AmM/4MViJ6XaUTHOBJ80gOIaSG30udywrZmPPzfGWyPaS2172GqiKx4BqD6cZcznW5hzTYWLToRpktdbOPnjZL5xyRs0Ojmuvn2uaqN0uzAx4lnlJaLNwtxDFuAsF2RS0sbbtbbz8BFnYsVr2I10SucwtbjP224fxX833rgjmDG1cjwC6OQv6sQjFrJuiYp6iKQEsAyNjdtjcdq2ucCLHRR9E3m4mN32uTxJzJ9q2l6mjxlDCx+MMGLjwXQ+pAy1J3ZLnDlGTURmle3nCACCdcNtwVJNTThLa9mNHW4FcM8zh6VQ1vY5oURUbKfGbufG7I6kk58MlyRUhDrB2oOgAy7Usn9deMvzikZapmd5XPtwufiuRtYx18F8uJ/RaSxouCb7iSdViZWN0sOwLPXi6zly+uuOtlYRhkc31m3vU7sTazpn81IBe1w4dXEKnPrBoM/euig2jNGTzeROptnbgtY5c7K+tDRQ+3dtU0BZDLZ8kjmhsepzcLOPADX1KXj9EdiqPKPko+WsZWQuu4PYXsPBpGbT2DRdHFcEREBERAREQEXzDyj1vRU/df408o9b0VP3X+NB9PRfMPKPW9FT91/jTyj1vRU/df40H09F8w8o9b0VP3X+NPKPW9FT91/jQfT0XzDyj1vRU/df408o9b0VP3X+NB9PRfMPKPW9FT91/jTyj1vRU/df40H09F8w8o9b0VP3X+NPKPW9FT91/jQfT0XzDyj1vRU/df408o9b0VP3X+NB9PRfMPKPW9FT91/jTyj1vRU/df40H09F8w8o9b0VP3X+NPKPW9FT91/jQfT0XzDyj1vRU/df408o9b0VP3X+NB9PRfMPKPW9FT91/jTyj1vRU/df40H09F8w8o9b0VP3X+NPKPW9FT91/jQfT1Fco9lfPafmMeAOe0k77A3NutUXyj1vRU/df41x7T5b1dTFzbmxR2cHB0YeHAg5WJcUH0/ZOzIqOEQwizRnmbkk6klcvKGN7o2BjS44s7C+4qhQfKHXMYGlsLyBbE5rsR7bOA9yxqOX9ZIAMELbG92iQH/mlIsBophnzL77rNOX+V42KoIw/N5HDcS2xHYdVWRy2rBe2DQj7eVxn9r1rrZ8otaABzdObC1y19/8Ams9WtTtRS1Ba13NPBOTgGkm/Edq3bOgnZK174XkdYzHXwVd8o9b0VP3X+Ne+Uet6Kn7r/GnVNWLYlHN88mllic0PvYuH8WXuWva5rXSvYxkhiBywt1HaoHyj1vRU/df408o9b0VP3X+NaRPQRyv/ANiVp4OYVt+bTdE/2KueUet6Kn7r/GnlHreip+6/xrPWLqx/NZujf7FyybGe4v8AMlAkILwBkSLAbrjQKG8o9b0VP3X+NPKPW9FT92Txp1NTUuxpHl92SgSWxgDI29Vwsn7Je4PBik89wccjqLWt7AoPyj1vRU/dk8aeUet6Kn7snjTqJ6o2fLI0AxSCxDgQMwQbhYfQ7yyRhjlPOG7jbMmwHq0ChPKPW9FT92Txp5R63oqfuyeNMRZfmsvRP9ifNJejd3VWvKPW9FT91/jTyj1vRU/df406iyfNJujd7Fon2XI/Pm5Gu4tHx4qC8o9b0VP3X+NPKPW9FT92Txp1XUhUbFrPsgu/E2xXE7YteT9S62+1lr8o9b0VP3ZPGvfKPW9FT91/jTq1/wBOTOXk5VvIwwuYOvP1rNnJGY/WYz2BafKPW9FT91/jTyj1vRU/df40xnakoeTAZ/svPqK7YtlvZ6MBH9KgPKPW9FT91/jTyj1vRU/df406mvpzdAqZym5USx1sdHCMAxsxvOpDiDZvVY6qE8o9b0VP3ZPGo7afKyWqcx8tPT42ODmva14cLG9r4tFpH2BF8w8o9b0VP3X+NPKPW9FT91/jQfT0XzDyj1vRU/df408o9b0VP3X+NB9PRfMPKPW9FT91/jTyj1vRU/df40FPREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERB/9k=\n", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "YouTubeVideo(\"rnkjVd1h8oE\") # https://youtu.be/rnkjVd1h8oE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The [nbviewer view](https://nbviewer.jupyter.org/github/4dsolutions/School_of_Tomorrow/blob/master/dataviz.ipynb) of this notebook will render the Youtubes in place. Github does not." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Literary Sidebar\n", "\n", "Another author who ventured into the realm of geodesic dome design was [Hugh Kenner](https://en.wikipedia.org/wiki/Hugh_Kenner), better known for [The Pound Era](https://en.wikipedia.org/wiki/The_Pound_Era). \n", "\n", "He also wrote [Bucky](https://www.amazon.com/Bucky-Guided-Tour-Buckminster-Fuller/dp/0688001416) and [Geodesic Math and How to Use It](https://www.amazon.com/dp/0520239318).\n", "\n", "\"By" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def make_table():\n", " keys = pd.Series( list(glossary.keys()), dtype=np.object)\n", " values = pd.Series( list(glossary.values()), dtype=np.object)\n", " df = pd.DataFrame({\"term\":keys, \"definition\":values}).set_index(\"term\")\n", " # create and delete a sorting column, wherein the terms are all uppercase\n", " df[\"sort_column\"] = df.index.str.upper()\n", " df.sort_values(['sort_column'], axis=0, ascending=True, inplace=True)\n", " del df[\"sort_column\"] # now that the df is sorted, delete the sorting column\n", " return df" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "# glossary is an ordinary Python dict, stored as JSON in a text file\n", "glossary[\"matplotlib\"] = \"data visualization package for Python, originally written by John D. Hunter\"\n", "glossary[\"numpy\"] = \"number crunchy goodness, vectorizes computations on n-dimensional arrays\"\n", "glossary[\"pandas\"] = \"wraps numpy arrays in handsome frames with row and column indexes\"\n", "glossary[\"seaborn\"] = \"adds new powers to matplotlib, makes pretty plots\"\n", "glossary[\"API\"] = \"a set of functions that take variable arguments, providing programmed control of something\"\n", "glossary[\"Ruby\"] = \"a programming language somewhat like Python and Perl, invented by Yukihiro Matsumoto\"\n", "glossary[\"ndarray\"] = \"n-dimensional array, the star of the numpy package, a multi-axis data structure\"\n", "glossary[\"DataFrame\"] = \"the star of the pandas package, providing ndarrays with a framing infrastructure\"" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "glossary_df = make_table()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The Python function above has the job of taking our ```glossary``` object, a Python dictionary, and turning it into a pandas DataFrame object. The dict's keys should comprise our index of terms and be sorted in a case-insensitive manner." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\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", " \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", "
definition
term
APIa set of functions that take variable arguments, providing programmed control of something
Bayesianinferential methods useable even in the absense of any prospect for controlled studies
cella Jupyter Notebook consists of mostly Code and Markdown cells
code cellwhere runnable code, interpreted by the Kernel, is displayed and color coded
CSVcomma-separated values, one of the simplest data sharing formats
DataFramethe star of the pandas package, providing ndarrays with a framing infrastructure
DOMthe Document Object Model is a tree of graph of a document in a web browser
HTMLhypertext markup language, almost an XML, defines the DOM in tandem with CSS
HTTPhypertext transfer protocol
JavaScripta computer language, not confined to running inside browsers but happy there
jsonJavaScript Object Notation is a way to save data (compare with XML)
Jupyter Notebook (JN)like a web page, but interactive, stored as json
Kernelan interpreter, e.g. Python, ready to process JN code cells and return results
localhostthe IP address of the host computer: 127.0.0.1
markdown celluses a markup called markdown to format the text cells in a Jupyter Notebook
matplotlibdata visualization package for Python, originally written by John D. Hunter
ndarrayn-dimensional array, the star of the numpy package, a multi-axis data structure
numpynumber crunchy goodness, vectorizes computations on n-dimensional arrays
pandaswraps numpy arrays in handsome frames with row and column indexes
Pascalan early computer language, later commercially available as Delphi from Borland
PGPPretty Good Privacy, RSA before the US patent expired, by Phil Zimmerman
Pharoa Smalltalk-like language and ecosystem that competes with Python's
portinternet services connect through IP:port addresses, JN usually on port 8888
Pythona computer language from Holland (the Netherlands) that went viral
RSApublic key crypto algorithm, named for collaborators Rivest, Shamir, Adleman
Rubya programming language somewhat like Python and Perl, invented by Yukihiro Matsumoto
seabornadds new powers to matplotlib, makes pretty plots
SGMLa parent specification behind what eventually became XML
Sphinxa documentation generator, targeting the web in particular, for use with Python
TLSTransport Layer Security, used to turn HTTP into HTTPS
web browserHTTP client, sends requests, gets responses
web serveraccepts and processes (or rejects) HTTP requests, sends responses
XMLa markup language using pointy brackets, reminiscent of HTML, for structured data
\n", "
" ], "text/plain": [ " definition\n", "term \n", "API a set of functions that take variable arguments, providing programmed control of something\n", "Bayesian inferential methods useable even in the absense of any prospect for controlled studies \n", "cell a Jupyter Notebook consists of mostly Code and Markdown cells \n", "code cell where runnable code, interpreted by the Kernel, is displayed and color coded \n", "CSV comma-separated values, one of the simplest data sharing formats \n", "DataFrame the star of the pandas package, providing ndarrays with a framing infrastructure \n", "DOM the Document Object Model is a tree of graph of a document in a web browser \n", "HTML hypertext markup language, almost an XML, defines the DOM in tandem with CSS \n", "HTTP hypertext transfer protocol \n", "JavaScript a computer language, not confined to running inside browsers but happy there \n", "json JavaScript Object Notation is a way to save data (compare with XML) \n", "Jupyter Notebook (JN) like a web page, but interactive, stored as json \n", "Kernel an interpreter, e.g. Python, ready to process JN code cells and return results \n", "localhost the IP address of the host computer: 127.0.0.1 \n", "markdown cell uses a markup called markdown to format the text cells in a Jupyter Notebook \n", "matplotlib data visualization package for Python, originally written by John D. Hunter \n", "ndarray n-dimensional array, the star of the numpy package, a multi-axis data structure \n", "numpy number crunchy goodness, vectorizes computations on n-dimensional arrays \n", "pandas wraps numpy arrays in handsome frames with row and column indexes \n", "Pascal an early computer language, later commercially available as Delphi from Borland \n", "PGP Pretty Good Privacy, RSA before the US patent expired, by Phil Zimmerman \n", "Pharo a Smalltalk-like language and ecosystem that competes with Python's \n", "port internet services connect through IP:port addresses, JN usually on port 8888 \n", "Python a computer language from Holland (the Netherlands) that went viral \n", "RSA public key crypto algorithm, named for collaborators Rivest, Shamir, Adleman \n", "Ruby a programming language somewhat like Python and Perl, invented by Yukihiro Matsumoto \n", "seaborn adds new powers to matplotlib, makes pretty plots \n", "SGML a parent specification behind what eventually became XML \n", "Sphinx a documentation generator, targeting the web in particular, for use with Python \n", "TLS Transport Layer Security, used to turn HTTP into HTTPS \n", "web browser HTTP client, sends requests, gets responses \n", "web server accepts and processes (or rejects) HTTP requests, sends responses \n", "XML a markup language using pointy brackets, reminiscent of HTML, for structured data " ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pd.set_option('display.max_colwidth', -1) # max width on columns please\n", "glossary_df" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "glossary_df.to_json('glossary2.json')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Slicing a Pandas DataFrame\n", "\n", "We're free to pick out a range of rows based on starting and ending values. using the .loc method with square brackets. The .iloc method assumes a purely numeric index of consecutive integers, whether one is defined or not." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\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", "
definition
term
code cellwhere runnable code, interpreted by the Kernel, is displayed and color coded
CSVcomma-separated values, one of the simplest data sharing formats
DataFramethe star of the pandas package, providing ndarrays with a framing infrastructure
DOMthe Document Object Model is a tree of graph of a document in a web browser
HTMLhypertext markup language, almost an XML, defines the DOM in tandem with CSS
HTTPhypertext transfer protocol
JavaScripta computer language, not confined to running inside browsers but happy there
\n", "
" ], "text/plain": [ " definition\n", "term \n", "code cell where runnable code, interpreted by the Kernel, is displayed and color coded \n", "CSV comma-separated values, one of the simplest data sharing formats \n", "DataFrame the star of the pandas package, providing ndarrays with a framing infrastructure\n", "DOM the Document Object Model is a tree of graph of a document in a web browser \n", "HTML hypertext markup language, almost an XML, defines the DOM in tandem with CSS \n", "HTTP hypertext transfer protocol \n", "JavaScript a computer language, not confined to running inside browsers but happy there " ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "glossary_df.iloc[3:10] # numeric indexing is from 0 and non-inclusive of the outer bound" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\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", "
definition
term
HTMLhypertext markup language, almost an XML, defines the DOM in tandem with CSS
HTTPhypertext transfer protocol
JavaScripta computer language, not confined to running inside browsers but happy there
jsonJavaScript Object Notation is a way to save data (compare with XML)
Jupyter Notebook (JN)like a web page, but interactive, stored as json
Kernelan interpreter, e.g. Python, ready to process JN code cells and return results
\n", "
" ], "text/plain": [ " definition\n", "term \n", "HTML hypertext markup language, almost an XML, defines the DOM in tandem with CSS \n", "HTTP hypertext transfer protocol \n", "JavaScript a computer language, not confined to running inside browsers but happy there \n", "json JavaScript Object Notation is a way to save data (compare with XML) \n", "Jupyter Notebook (JN) like a web page, but interactive, stored as json \n", "Kernel an interpreter, e.g. Python, ready to process JN code cells and return results" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "glossary_df.loc[\"HTML\":\"Kernel\"]" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\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", "
definition
term
Pythona computer language from Holland (the Netherlands) that went viral
RSApublic key crypto algorithm, named for collaborators Rivest, Shamir, Adleman
Rubya programming language somewhat like Python and Perl, invented by Yukihiro Matsumoto
seabornadds new powers to matplotlib, makes pretty plots
SGMLa parent specification behind what eventually became XML
Sphinxa documentation generator, targeting the web in particular, for use with Python
TLSTransport Layer Security, used to turn HTTP into HTTPS
web browserHTTP client, sends requests, gets responses
web serveraccepts and processes (or rejects) HTTP requests, sends responses
XMLa markup language using pointy brackets, reminiscent of HTML, for structured data
\n", "
" ], "text/plain": [ " definition\n", "term \n", "Python a computer language from Holland (the Netherlands) that went viral \n", "RSA public key crypto algorithm, named for collaborators Rivest, Shamir, Adleman \n", "Ruby a programming language somewhat like Python and Perl, invented by Yukihiro Matsumoto\n", "seaborn adds new powers to matplotlib, makes pretty plots \n", "SGML a parent specification behind what eventually became XML \n", "Sphinx a documentation generator, targeting the web in particular, for use with Python \n", "TLS Transport Layer Security, used to turn HTTP into HTTPS \n", "web browser HTTP client, sends requests, gets responses \n", "web server accepts and processes (or rejects) HTTP requests, sends responses \n", "XML a markup language using pointy brackets, reminiscent of HTML, for structured data " ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "glossary_df.loc[\"Python\":] # slice from Python to the end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### A First Look at Seaborn\n", "\n", "[Seaborn](https://seaborn.pydata.org/introduction.html)\n", "\n", "The only change is ```sns.set()``` is run, prior to invoking the very same ```plot_functions```. \n", "\n", "Notice the cosmetic differences, procured for free." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmwAAAFNCAYAAAC9jTMrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3de5xU9Z3n//ensRu5BAiKQUUabyTiBcygYkzUyCQjxMTNTDQoujrG5eclmZj9zc6YITeTYdf9zf42mjWJIRdjEtZxkk28BWa8TKImZlQQb2BQBwEREARt5WI3dH/2j6pq63Kq+lR3VZ3b6/l48KCr+lTVt6tOfb+fc77fz+eYuwsAAADx1RZ1AwAAAFAbARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAFIHDP7spndHHU7BsvMLjGzZVG3A0ByGHXYAETJzHYW3RwpqVtSb/72/+PuSxr8ej+TdL6knqK7L3H3/9PI1yl6vaMkveDu1oznB5AN+0XdAADZ5u6jCz+b2TpJl7v7/dW2N7P93H3fEF/2v7r714b4HADQMkyJAog1M/t7M7vdzG4zs7ckXZS/78dF2/ylmW0ws9fM7O/MbKOZnVnn6+xnZm5mU4ru+5mZfS3/85+a2Toz+xsz22Zmm8zsPxZtO9LMvplvR5eZPWRmwyU9lP/9zvy/k8zscjP7bdFjP2hmy/OPe8zMTin63e/M7Doze8TM3jKzfzaz8UWv+b/NbLuZvZF/7IH1/N0AkoGADUASfFLS/5Y0VtLtxb8ws+MlfUvSPEmHSpogaWKT2jFJ0ghJh0i6QtJ3zWxM/nfflHSCpFMkjZf0d5L6JJ0u5c4k5v89Xtb+AyX9WtL/L+mA/N+y1MzeXbTZhZIukfQeSaMk/ef8/X+p3DTypPxjr5L0dgP/XgAxQcAGIAl+5+53u3ufu+8p+915ku5w90fcvVvSl0I837X5M1JvmNmWOtrxtqS/d/e97n6XcuvtpprZMEmXSvord9/s7r3u/jt33xviOT8uaZW73+bu+9z9Z5LWSvpY0TY/dPcX3H23pJ9LmpG/f6+kAyUdlX/N5e6+UwBSh4ANQBK8XON3hxT/3t13SXp9gOe73t3H5f/VczbuNXfvLbq9W9Jo5c58dUj69zqeq+AQSevL7luv3NnCguKgsvCakvRjSfdL+icze8XMrjcz1iYDKUTABiAJaqWzb1ZuSlCSZGajJL27+uZVXiCXyNCt3BRjQdhg7lXlsk6PDHrqAR67SVJn2X2TJb0y0Iu6e4+7f83dj5H0QeWmjucP3FwASUPABiDpfi7pP5jZLDPrkPT1ITzXU5Lmm9kwM/uYckHQgPJn3X4s6QYzm5h//Glm1i5pqyQ3syOqPPweScea2afziQ8XSjpK0tKBXtfMzjKz48ysTdKbyk2R9g7wMAAJRMAGINHc/WlJX1AucNskaXv+X/cgnu6vlDtL9YZya+PuquOxX5D0nKQVknZI+q/K1bp8S9J/k/Rofs3czLL2b5P0CUl/m2/3FySd4+47QrzmIZJ+qVywtkq56dHb6mgzgISgcC6AVMlnbb4hqdPda619A4DE4AwbgMQzs0/ka5KNVq48xhMEawDSJNKAzcx+ZGZbzezZKr8/M19I8sn8v6+0uo0AEuGTyk2HbpQ0RdIFkbYGABos0ilRMztd0k5JP3H34wJ+f6akv3b3c1rdNgAAgLiI9Aybuz+k3OJcAAAAVJGENWynmtlTZrbMzI6NujEAAACtFveK2E8ol+m108zmSrpD0tFBG5rZAkkLJGnUqFF/8r73va91rQQAABikFStWvObuE2ptE3lZDzObIumeoDVsAduukzTT3V+rtd3MmTN9+fLlDWkfAABAM5nZCnefWWubWE+J5iuGW/7nk5Vr7/ZoWwUAANBakU6Jmtltks6UdKCZbZT0VUntkuTuN0v6lKQrzWyfpD2S5nnUpwQBAABaLNKAzd1r1kpy95sk3dSi5gAAAMRSrKdEAQAAQMAGAAAQewRsAAAAMUfABgAAEHMEbAAAADFHwAYAABBzBGwAAAAxR8AGAAAQcwRsAAAAMUfABgAAEHMEbAAAADFHwAYAABBzBGwAAAAxR8AGAAAQcwRsAAAAMbdf1A0AAADx1dPTo+eee0579+6VmUXdnEi5u9rb23XMMceoo6Ojpa9NwAYAAKp67rnntGrVKr344oty96ibEykz01FHHaWenh7NnDmzpQEsU6IAAKCqvXv3EqzlubtefPFFmZkefvjhlr42ARsAAKjKzAjWiri7zEzLli1Tb29vy16XgA0AAERu0aJF/T8///zz+ta3vqU33ngjwhYNrKenp2WvRcAGAABiY+3atVq2bJkuuugijRs3LurmxAYBGwAAiIX169frrrvu0oUXXqjx48dLknbt2qXbb79dixcv1uLFi7Vhwwb19fXpW9/6lnbt2iVJ6uvr04033th/O40I2AAAQOR6e3t12223ad68eZowYUL//cuWLdOsWbO0YMECnX/++brrrrvU1tamE044QU8//bSk3Fm5iRMnatSoUVE1v+ko6wEAACLX1tamww47TCtXrtScOXP671+7dq22bdvWf7u7u1vd3d068cQTddttt+nUU0/VypUrNWPGjCia3TIEbAAAIHJmpvPOO08/+clP9NBDD+n000+XlMvKvPzyy9Xe3l6y/fDhwzV69GitXbtWr7zyiv7iL/4iima3DFOiAAAgFjo6OnThhRfqmWee0RNPPCFJOvLII/XYY4/1b7N58+b+n9///vfrl7/8pY499li1taU7pEn3XwcAABJl5MiRuuiii/TQQw/pj3/8o+bMmaNNmzbpO9/5jm666SYtX768f9v3vve96unpSf10qMSUKAAAiIGFCxf2/zx27Fhdc801/bfPO++8wMds2bJFEydOLElSSCsCNgAAkDgPP/ywli9frj//8z+PuiktQcAGAAAS50Mf+pA+9KEPRd2MlmENGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABInDvvvFNbt26NuhktQ5YoAABInHPPPTfqJrRUpAGbmf1I0jmStrr7cQG/N0k3SporabekS939ida2EgAAhPW0ntYDekBd6tJYjdVszdYJOmFIz9nT06Of//znevPNN9XX16czzjhDjz/+uD760Y/q0EMP1aJFizRr1iw9//zz2m+//XTBBRdo9OjR2rVrl+655x51dXVJks4++2xNnjy5EX9my0U9JfpjSWfX+P0cSUfn/y2Q9N0WtCkxljyzRFNumKK269o05YYpWvLMkqibBKRKd/dmrVx5hrq7t9S8L+voi1DwtJ7W3bpbXcoFSF3q0t26W0/r6SE974svvqh3vetduvLKK3X11VfrqKOOKvn93r17NWnSJF155ZXq7OzUihUrJEnLli3TrFmztGDBAp1//vm66667htSOKEV6hs3dHzKzKTU2OVfST9zdJf2bmY0zs4PdfXONx6TSkmeWaOEDC7Wha4Mmj52suUfP1a1P3arde3dLktZ3rdeCuxfo9xt+r6UvLO3fbtHsRZp//PyIWw8kQ3f3Zq1ePU/Tpt2u4cMnat26b6ir63dav/4bmjr125IUeF/549KuuD8aP2K83up5Sz29PZLoi7LuAT2gvdpbct9e7dUDemBIZ9kOOugg3Xvvvbrvvvs0depUdXZ2lvx+2LBhmjp1qiTpkEMO0b//+79LktauXatt27b1b9fd3a3u7m4NHz580G2JStzXsB0q6eWi2xvz96U+YBuoQ7x5+c1yecljdu/dXXI/HSdQn+JgrLPzS3r11Vsk9WnLllvU2fllSV5xX7XALi0GOljcvmd7xWPoi7KrcGYt7P1hHXjggVqwYIFeeOEF3X///TryyCNLft/W1qbcKirJzNTX1ydJcnddfvnlam9vH9Lrx0HUU6IDsYD7POA+mdkCM1tuZsuLo+kkWvLMEi24e4HWd62Xy7V9z/b+YK2gPFirdn+h4yw8V6HjZMoCWVc+tdndvbkkGFu79otyL3T6vVq//htat+4bFfeVP667e0tqpk3L+6LCwWIhWKuFviibxmpsXfeH9eabb6q9vV3Tp0/XBz7wAW3eHO68zZFHHqnHHnus/3bYx8VR3AO2jZIOK7o9SdKmoA3dfbG7z3T3mRMmTGhJ4xqlfP3H55d9PlSHGFZQx7nwgYUNe34giYrPihVuF4Kxvr59evXVn8k9d6Dk3qPNm3+kLVtuKbmvVmBX/NxJtfCBhRV9UbWDxTCC+qJLfnUJa99SZLZmq12lZ7Pa1a7Zmj2k5926dau+//3v67vf/a4efvhhnX766aEeN2fOHG3atEnf+c53dNNNN2n58uVDakeULLc8LMIG5Naw3VMlS/Rjkj6rXJboKZK+5e4nD/ScM2fO9KR8KIUj2MEEaCYr6QDLb4d5PNMSyKLu7s169NEj1Nf3ttraRujEE/+glStnqa/v7RqPKhzf9hXd156/3dt/j9n+kiT33HOfcsraxKxrK5/+XN+1flDPU29fVDCyfaQWf3wx/VHMrFixQvfcc0/o7ZuRJRo355xzjn7xi1/oK1/5ikaMGDHk5zOzFe4+s9Y2kZ5hM7PbJP1B0nvNbKOZfcbMrjCzK/KbLJW0VtKLkr4v6aqImto0QUewYYxsH6krZl6hzrGdMpk6x3bqiplXaGT7yJLtLHBWOYdpCWRF+RRl+dTmc8/N779dXZ9KgzVJ2qviYC33fD1FZ+F6+8+yxX2aNGj6s1r/UX5/e1u7DhhxwKD7ogLO/qfDCTpBX9AX9DV9TV/QF1IXrEUl6izRCwb4vUu6ukXNicSGrg2htmtva9eY4WO0Y8+OmmfFTpt8Ws0FwkEKnSRHtUiroGSC4qnN3btXK2h57KhRM3TSSSurPu/jj5+oXbueLLv3naCuMG3a2fnl2CcmVJv+LD9bNrJ9pC6ZfsmAyQOD6YukXILClBumkJgAlIl7lmjqVZt2OGDEARrdMbruTmv+8fNrdpzVpinoJJFW5UkBvb27Ks6mmbXr4IMvrzuQKg/m1qy5Slu2/LA/GJRyZ9nWrr1W27bdrvLs0qgVT4HWSmTqHNvZ8L6ozdrU670VjzNZf59YmAEoPB+QZXFPOki9RbMXVUwdjGwfqRvn3Kh116xT31f7tO6adUPqrOYfP7//uTrHdgZuU+gkmSZF0g00/bl9+69LAqrc/T3q6npkyK/95pt/CHzu7dvvqUhMCGprK5VPgVbTObazKX3RrZ+8NXDalCQpIBgBW8TmHz9fiz++uGQtWjMX3QYFiHSSSJPiqcfC2bXi6c++vl069dTNOvNML/lXa+ozrJNOWlnxvKeeukl9fbsqsku7u7dEmk0aZv3syPaRWjR7UVNeP6jvqxY4hl06AqQZU6IxEDR10MzXkhQqE4xOEkkTZvqzcIarVevIis/wFbch6mnSWt/vVmWQl/d9U26YEtgfjR8xniUbyDzOsGVQ8bTEumvWVZ0mLXSS1EhCUrRy+jOseqdJm6W83uP4EeMDt+sc29mQ6c/BCJoBaG9r11s9b7FkA0PyyiuvaOnSpVE3Y0g4wwYtmr2oohZcoZMsXHaGxb+Iu1rTn1Eu8A+aai3UgSufJm3WWbbyeo/ru9arva1dHcM6Sq6i0swp0DCCZgB29uysuPwVme2o16GHHqpDDz006mYMCQEb6CSRaIULr++//+GRT3+GVWua9O23X2r4ReSD1qvt7ds76Gz0ZiqfJm27LngiiCUb8dbR8ZaOOeYXWr36U9q7910Nec4nn3xSjzzyiMxM73nPe3TWWWfpzjvv1K5duzRq1Cide+65GjdunFatWqXf/va3amtr0/Dhw3XZZZfppZde0iOPPKL58+frN7/5jbq6uvT666+rq6tLs2bN0qxZsyRJTz31lB599FH19vZq0qRJ+tjHPqa2tnhMRhKwQRKdJJKrsHB/167VkU9/hlVrmnTfvtcbHmRW+97u2LNDr/3Naw17nWaots528tjJEbQGYU2e/KDGjt2gzs4H9eKL5wz5+bZu3aqHH35Yl112mUaNGqXdu3frjjvu0PTp0zVjxgw98cQTWrZsmS644AI9+OCDuvjiizVmzBjt2bMn8Plee+01XXrpperu7tZNN92kk046STt27NCqVav0mc98RsOGDdM999yjp59+WjNmzBhy+xuBgA2B6CSRBMVJBnGY/gyr1jRpM5IQkvx9DlqyMbJ9pOYePZdEhJjq6HhLEyc+KTPXxIlPav36M4Z8lu2ll17StGnTNGrUKEnSyJEj9fLLL+vTn/60JGn69Om67777JEmHHXaY7rjjDh177LE65phjAp9v6tSp2m+//bTffvtp1KhR2rlzp9auXatNmzZp8eLFkqR9+/b1v14cxOM8H2Kn2uLfnT07SUJAbJQnGST5YuuN/FvKEwzmHj03sN5jlOvVwgoq/3HJ9Et061O3kogQU5MnPyizXIkWM1dn54NDfs4w1z03y13+7OMf/7jOOussdXV16eabb9bu3ZXla4YNG1byuL6+3HdvxowZuvLKK3XllVfqc5/7nD784Q8Pue2NQsCGQOWd5AEjDpCZafue7XSQiIWgJINCfbOkaeTfEnRN0FufulWXTL+kZfUeG608s33pC0sr1uRROzIeCmfX2tpyV7Foa+vVxIlPqr39rSE97xFHHKFVq1b1B1+7d+/WYYcdpmeffVaS9PTTT2vy5NwZ4x07dmjSpEk666yzNHLkSHV1dYV6jcMPP1yrV6/Wzp07+1/jjTfeGFK7G4kpUVRVvK5tyg1TSEJA5AoJBtOm3V514X4ckwwGUutv6ez8Uv/fHGaKNCjBYPfe3Vr6wlKtu2ZdI5sdmWpr8lhjG73is2sFhbNsQ1nLdtBBB+n000/XLbfcora2Nk2cOFFz5szRnXfeqd///vf9SQeSdO+992rHjh1ydx1xxBGaOHGi1q1bF+o1zjrrLP30pz+Vu2vYsGGaO3euxo0bN+h2NxIBG0Khg0QcFF8ZoNrC/TgmGQyk1t9S70Xjs/BdTfKavLQbM2Zj/9m1gra2Xo0Zs3HIzz1jxoyKBIBLL720Yrt58+ZV3Hf44Yfr8MMPl6SKac6rr766/+fjjjtOxx133JDb2gwEbAiFDhJRK7+KwSmnrE1EgkEY1S6LNZhEhCx8V6slIiRhTV7aPfHEFVE3IbVYw4ZQql2kng4SrZKmBIOwwvzNaUowCKtaIsLCBxaSFIXUImBDKNUuUi+Jy1eh6dKUYBBWmL85jQkGYRUnIiyavYisUaQeU6IIrby4btDlbrh8FZohTQkGYYX5m7OQYBBGtfeBpKjGcHeZWajSGlkQ1XvBGTYMWq1OEhiq7u7NWrnyDHV3b0lVgkFYtf7mwnvz1u7KtWpSuhIMwshCokWU2tvbddRRR/XXOcsyM9ORRx7ZX/qjlTjDhkGjk0QzFWdHVluUn2a1/uY1a65SV9fvdNXU0fr7VZUDR5oSDMLIQqJFlApXC5g6dWrmgzZ3186dO/vrv3V0dLTstQnYMGh0kmiW8ozQRl6mKemK35sPH9itW0aO0Cu737leYtoSDMIga7S5Ojo6NH36dP3+97/XnXfemfmgTcoFbuecc07JFROajYANg0YniWYJyo5M61q1ehW/N8PMdPMHP6DPPvpipq+pWfh7Fz6wsOR9kMT1RhvoAx/4gCZOnKjt27dnej2bmWn8+PE68sgjW/u6aXzTZ86c6cuXL4+6GZmw5JklgZ1k+X10kgirUHusr+/t/vva2kakqu7aYHV3b9Yjf+iUaW//fX1q12mnbsj8e1OuPClKyh1QpjFjFslnZivcfWatbUg6wJCUX+NPUkWZAdLrUY9a2ZFZd98TF2tv396S+/b17dV9T1wUUYvii6QopA0BGxqKThJDlcWM0LC2v/6QOsp67Y623P0oRVIU0oY1bGgoOkkMVuHC7iecsIzpvSr+8vF9ClrEckDHXp1w8BmhLxCfBSRFIW04w4aGqtYZ0kliIMVlPBCs2vfoyqNH896V4XJ6SBsCNjQUnSQGo7yMR5ovOTUUQd+vQ0eO0FkHdov3rlS1y+mRcICkImBDQ9FJYjCyeGH3wQj6ft38wQ+oLV8Xi/euVHlS1Pzj52vJM0u4/jESibIeaLqg0h8EcCigjEd1A313eO/qQ6kPxBVlPRC5QgdJmQ9UQxmPYGG+O7x39SGLHUlGwIamooPEQCjjESzMd4f3rj5ksSPJKOuBpqKDRJBCCY9p027P5IXdwwjz3an13hW/x0yP5lDqA0nGGTY0FWU+EIQSHgMb6neH97gSWexIMgI2NBUdJMpRwiOcoXx3eI+DkcWOJCNgQ1PRQaIcJTzCGcp3h/e4uqDrH1PmA0lAWQ8ALUMZiuoaVf6G9zg8ynwgLijrgdiieGU2UYYiWCPL3/Aeh0cWO5Ik0oDNzM42szVm9qKZXRvw+0vNbJuZPZn/d3kU7URjUZstuyhDEayRgQPvcXhksSNJIivrYWbDJH1b0kckbZT0uJnd5e6ryza93d0/2/IGomlqDU5MQ6QbJTyCNTJw4D0OjzIfSJIoz7CdLOlFd1/rucPBf5R0boTtQYtwVJst3d2btXLlGWQq1tCq8jd8FqXIYkeSRBmwHSrp5aLbG/P3lfsLM3vazH5hZoe1pmloJmqzZQv1wAbWqsCBz6IUWexIkigDNgu4rzxl9W5JU9z9BEn3S7q16pOZLTCz5Wa2fNu2bQ1sJhqNo9rsoB5YOK0IHPgsgpWX+SBYQ1xFGbBtlFR8xmySpE3FG7j7dnfvzt/8vqQ/qfZk7r7Y3We6+8wJEyY0vLFoHI5qs4N6YOE1O3DgswiPLHbEUWR12MxsP0nPS5ot6RVJj0u60N1XFW1zsLtvzv/8SUl/6+6zBnpu6rAB0aMeWG2NqrsWBp9FeNRmQxRiXYfN3fdJ+qykf5H0nKR/cvdVZvZ1M/tEfrO/MrNVZvaUpL+SdGk0rUUrcFSbLtQDq67VpW34LMKjNhviKrKyHpLk7kslLS277ytFP39R0hdb3S60XvlRbWEAk8RRbUJRD6y6Vpe24bMIjyx2xFWkARtQQG229KEeWHWtDgr4LMKjNhviiktTIRY4qk0Pan0NLE6lbfi8SpHFjrgiYEMsxGkAw9BQ62tgcQoK+LxKkcWOuIosS7SZyBJNHjKz0qE4G5EsxNpamSVaDZ8XEA9hskRZw4ZYKAxUUQ9gGJqgWl9Tp3474lbF0/zj50e+f/N5AcnBGTYADUGtr2Th86pPHM6IIr1iXYcNCIPabMlBra/q4rgf83mF1+q6eUAQAjbEFp1kslDrK1hc92M+r/Aopos4YEoUsTXlhimB9ZA6x3Zq3TXrWt8gYBDYj5Ov7bo2uSrHSpOp76t9AY8A6sOUKBKN2mzxRw2vgSVtP+YzrUTZIcQBARtii04y/qjhNbCk7cd8ppXiVDcP2UXAFhMc1Vaik4y37u7NevXVWyT1acuWW9h3q0jSfsxnGoxiuvGXhTGUgC0mOKqtRCcZb0E1vFApSfsxn2l184+fr3XXrFPfV/u07pp1sfz8siwLYyhJBzFAtXEkDTW80ofPtD7UZYuPNIyhJB0kBEe1SBpqeFUXx5prYfCZhhfXUi1ZlZUxlIAtYoU1I4V6SO49rB2pIamDYdpQwytYkgdyPtPwqMsWH1kaQ7mWaMRqHdVyTb9S5ReILwyGkpiKaLGTTloZdRNiqdZAHvd9lM80vKSVakmzLI2hnGGLGEe14XFUi7hjIM+GpJVqSbMsjaGcYYsYR7XhMRhGq7t7s1avnqdp025P3ILeVpk8dnLgVQ2SPpDz2ZdaNHtRydl+Kb6lWtIuS2MoZ9iQGBzVRisLafNDlaSaa/Xgsy+VpFItSA8CthjLQiHAeqR1MEwCCqqGk8aBnM8+GHXZopPVsZGALcY4qi2VxsEwKbKSNt8IaRvI+ewRN1kdGymcG1NpKASIdKCganbx2deHYrrNl9axkcK5CcZRLeKCgqq1pbk2IJ99eEmuwZckWR4bCdhiKEuFABshzQNmHGQpbb5eaR+k+ezDo+xQ82V9bKSsRwxlqRDgUFFMt/mylDZfryQXyg2Dzz48yg41X9bHRs6wxRBHteFxVIsoMUijgLJDzZf1sZEzbDHEUW14DJjNQaHUcNJaKDcM9pFSFNNtvqyPjZxhQ6JxVNscWU2br1eWawOyj5Si7BCajYAtQbJaLLCWLA+YzUKh1PCyOkizjwRLWw2+uGDsyyFgSxCOaCtldcBspiynzQ9GFgdp9hG0EmNfDoVzEyKtxQIRLxRKxUDYR+pDMd2hycrYR+HcFOGIFq1AodTaqPnHPlKPtNfpawXGvncQsCVA1osFDgYD6+BkPW2+FgbfHPaR8Cg7NDSMfaUo65EAWS8WWC+K6Q5e1tPma0l7kdyw2EfCo+zQ0DD2leIMWwJwRFsfjmrRDAy+qBdlh4aGsa9UpGfYzOxsSTdKGibpB+5+fdnvh0v6iaQ/kbRd0qfdfV2r2xk1jmjrw8BaP4qgDizLRXLDYB+qRDHdoWHsK1X1DJuZLTWzKc16YTMbJunbkuZImibpAjObVrbZZyS97u5HSfqmpP/erPYgPTiqrR9p8wOj5l9t7EOVKDuERqo1JfpjSfea2UIza2/Ca58s6UV3X+u5c57/KOncsm3OlXRr/udfSJptZtaEtiQWBQUrMbDWhyKo4TD4Vsc+VF0W6/QNBWNadVUDNnf/J0knShojabmZ/bWZ/efCvwa89qGSXi66vTF/X+A27r5PUpekAxrw2qnBUW0lBtb6kDYfHoNvMPYhNApjWnUDJR3slbRL0nBJ7yr7N1RBZ8rKq/iG2Sa3odkCM1tuZsu3bds25MYlAUe11TGwhkPaPIaKfQiNwphWW601bGdLelLSSEnvd/evuvt1hX8NeO2Nkg4ruj1J0qZq25jZfpLGStoR9GTuvtjdZ7r7zAkTJjSgefHHUS2GiiKo1VHLLxz2ofqxbwVjTKut1hm2hZLOc/dr3X13je0G63FJR5vZ4WbWIWmepLvKtrlL0iX5nz8l6V89jdfSGgSOautDBxmMtPlgFMkNj32oPuxbwRjTBlJaIjgAABk8SURBVBbptUTNbK6kG5Qr6/Ejd19kZl+XtNzd7zKz/SX9VLm1dDskzXP3tQM9bxqvJVpuzZqrtGXLD0s6SrMOHXzw5ZksKFhLeSFdKZeEwLo2VDPlhimBJTw6x3Zq3TXrWt8gpAb7VrCsj2lhriUaaR02d18qaWnZfV8p+vltSee1ul1JwFFteFSoR72o5YdmYd8Kxpg2MC5NlVAUFAyPDhL1okgumoV9Kxhj2sC4NBVSj0K6pahzNDBq+TUG+1ol9i0MFgFbCtFJlqKDLEWdo4FRy68x2NcqsW+9g7GqPpEmHTRLFpIOalmz5ipt3vw9HXLIFZlYrBnGkmeWaOEDC7Wha4Mmj52sRbMXZbaDfPTRI9TX97ba2kbolFPWct1HNAX7GgbCWPWOMEkHnGFLGQoPBqOQbg51jtAq7GuohbGqfgRsKUMniWqoc4RWYV+rTxbrRDJW1Y+ALUXoJOuTtU6SivS1ZW1/aCb2tfCyWEiXsWpwCNhShE4yvCx2ktQ5qi6L+0Mzsa+FV6tOZFoxVg0OSQcp8vjjJ2rXricr7h81agY1bspQbRzF2B8Qlbbr2uSqHIdNpr6v9gU8IvkYqyrF/koHaKys7uiDQTFdFGN/QFSyWEiXsWpwmBJFJmWlmC51jsLJyv4QB+yTpagTibAI2DKCTrJUVjpJCpeGk5X9IQ7YJ0tlqZAu49DQELBlBJ1kqSx0ktQ5Ci8L+0McsE8Gy0qdSMahoSHpIAOoOJ5Na9ZcpS1bfij3Hpl16OCDL898NXFEi30yuxiHauNKB5BEgcIsos4R4oZ9sj5pqwvIODR0BGwpRydZn7R0ktQ5qi0tn3OSsE+Gl7a6gIxDjUHAlnJ0kuGlqZOkcGl1afqck4R9Mry0FdNlHGoM1rClHAUKw6N4ajbwOSPu0lZMl3FoYBTOBV+GOqSheGp392atXj1P06bdzoLeKtLwOacJ+2yltBXTZRxqDKZEgbw0FE8lbX5gafic04R9thJ1ARGEgC2jKGBYKemdJDWuwkn655wm7LPB0lAXkDGm8QjYMoqj2kpJ7yRJmw8n6Z9zmrDPVpf0YrqMMY1H0kEGUcAwfYo/0wI+W8QZ+2z9ljyzRAsfWKgNXRs0eexkLZq9KJaBHGNM/Sici0Ac1aYPafPVUXMtnthn65OkcjSMMc1BwJYxFDCsT1IGe2pcBUvSIJc17LP1SUptNsaY5qGsR8bUOqrlmn6lCoN9oZMsDPaSYjcNQdp8sFqDXNw+w6xhn61PUsrRMMY0D2fYMoaj2vCSckSL6pIyyAEDSUo5GsaY5uEMW8ZwVBte3Ad7Co4OLG0FSLOCfbvSotmLSs74S/EsR8MY0zycYQOqiPsRLWnzA6PmWjKxb1eiHA0I2NCPQoel4jzYU3A0HAa55GHfri6utdkYO1qDgA39OKotFefBnrT58OI6yCEY+3byMHa0BoVzIYlCh0lCwVGkFft2feJQSJexozEonIvQOKpNDgqOVpeUunkIxr4dXlxqDDJ2tA4BGyh0WKeogwLS5oPFZQDD4LFvhxeHskOMHa1FWQ9Q6LAOcSimS9p8MIrkJh/7dnhxKDvE2NFanGEDR7V1iOqoliysgcVhAEPz8B0oFYeyQ4wdrRXJGTYzGy/pdklTJK2TdL67vx6wXa+kZ/I3N7j7J1rVxizhqDa8qIKC4iwsjlyDUSQ33fgOlIpDIV3GjtaK6gzbtZIecPejJT2Qvx1kj7vPyP8jWIsAR7WlojiqpS5VOHGum4eh4TtQKaqyQ4wJ0YkqYDtX0q35n2+V9B8iagcGQH2dUlEEBWRhhRPnunkYGr4DwaKoMciYEJ1I6rCZ2RvuPq7o9uvu/u6A7fZJelLSPknXu/sdYZ6fOmyNQX2dYK2sfURdKmQd34H6NLN/YkxonkjrsJnZ/Wb2bMC/c+t4msn5P+BCSTeY2ZE1Xm+BmS03s+Xbtm0bcvvBUW01QUe1zSr1QV2q2qIusYLm4zsQXrNL2zAmRKtpAZu7/6m7Hxfw705Jr5rZwZKU/39rlefYlP9/raTfSjqxxustdveZ7j5zwoQJDf97sob6OuE1s5MkC6s66q5lA9+B8JqZxc6YEL2opkT/QdJ2d7/ezK6VNN7d/6Zsm3dL2u3u3WZ2oKQ/SDrX3VcP9PxMiQ7dmjVXacuWH5Z0lGYdOvjgy8nQKjPlhimB2YmdYzu17pp1rW9QRvC+A6XarmuTq3JMN5n6vtoX8IjwGBOaK86Xprpe0kfM7AVJH8nflpnNNLMf5Lc5RtJyM3tK0m+UW8M2YLCGxuCoNrxmlPogE2tg1F0D35NSzcxiZ0yIXiR12Nx9u6TZAfcvl3R5/udHJB3f4qYhj/o64TWj/hc1pwZG3TXwPSnVzNpsjAnR40oHqAtHtJUaXeqDmlPhUHct2/ieVGpGaRv6/PggYENdqMFTqdGdJJlY4VB3Ldv4ngRrdBY7fX58RJJ00GwkHTQHNXiaj5pT1bWy/h3ije9JeIVs6vJp0jAHN/T5rRPnpAMkEEe04Q32iJaaU8Eo4YFifE/CG0qpD/r8eCFgQyjU4AlvKMEFmVjBmllfCsnD9yS8wWZT0+fHTyRZokieWke0ZGeVqhVcBE1BdHdv1urV8zRt2u1kYlVBCQ8Uq/Y9KSyQnzbtdqbu8gabTU2fHz+cYUMoHNGGV29wwaLegTWzvhTSg+9SpcFmU9Pnxw9n2BBKrTM/xWeIOKqt74i2vDRBZ+eXeQ8DNLO+FNKB71Kwwln9MAk7nO2PN86wYcg4qi1VzxEti3rDoYQHBsJ3qbryUh+SApOi6MvjjbIeGBLSvoOFKUFBaYLqKOGBevBdCq9amY8ffOy/69Cu/0JfHhHKeqDpOKoNFqZ45X1PXExpggCU8EC9KPMRXrWkqNUvfJG+POYI2DBopH2HFxSEvLr9X1nUG4ASHqgXC+TDC0p+Gt8hffDdO+nLY46kAwwaad/hFYKQ8R3Sl4+Rvr5aunyFq3NsZ/+aEuRQwgP1IikqvKCkqIsnS21Wuh19efxwhg2DVuuolgsGlyoEGxdPlk4YK/3HztL78Q5KeKCRWEhfqpAUNb5D+uZ06d3t0vFjTe1l0QBnKOOHM2wYtFpHtWvWXNXfSXKElgs23tqzXnMm5o5kz54o/WS9NGYkQUg5SnigUSj1UamQvPPHNVfohLE7dfXU0dq/82adSVJP7HGGDQ1X3klyli0XhFw2ZZgsP+3QZtJlhw8jCMkrTshY+MBCXTL9Ekp4YMhIigr2qaln6SMH7VObSR85qFefmjp70Nc/Rutwhg0NF9RJZv0s26emnqVDtrfJ1CtJ6miT5h7cplf73tCUG6ZkunxFeZmB9V3rdetTtxKkYUiqJUVxlq2yj77viYu04Dd/KPkOLrh7gSTxHYwRzrChocgcDbZu3TfUZqWrek2uFas/n/nyFWSFohko9REsqI/u2POvGi6+g3FHwIaGopN8R3HiRVCChmmf3ju6t+S+LHaSZIWiGUiKChbUR0venwhVjO9gvDAlioaq1km+/vqDWrnyjEyl1hdnpwUlaLRd1yZX5ZVGstZJ1nPtVSAskqJKFcqb7N27vaKP7miTjh1T+Ri+g/HCGTY01EknrdSZZ3rFv3HjTs9Uan2YxAvKV+TUc+1VYKiymhRVOIAcN+6Miv75lQN+pmue4TsYdwRsaLosdpBhstOyGqiUZ6NJ4sLuaJksZo4O1AfPP35+4HdQCr5IPKJBwIamy1oHGTbxIoudZLXrhEqquPYq0GhZTYoK0weXX/9YEtf0jRlzr1xDk3QzZ8705cuXR90MKNdBPvroEerre7v/vra2ETrllLWpW8tWWCOy//6Ha+vW20rWiZh16OCDLx9wvUx5iQspd9YtLWecptwwJXC9GpfoQiusWXOVtmz5YcV386CDLtDbb7+UyjW2g+2D+a62lpmtcPeZtbbhDBuaqlbWaNoytQprRLZv//WgL0Sd9hIXZIQiStWSorZvvydVa2yL+9bBZu7zXY0fskTRVLVS64uzKJOeqVW8RqSvb5dOPXXzoI7U095JkhGKKAVljhbOQKXp8lXFfWutPrgWvqvxQ8CGpqqWWp+2TrJRV3eo1km2WZvarmtL3NUQljyzRAsfWNh/JYe5R8/VrU/dynVCERtpuzJLeYLBYJefBF3Tt72tXTt7diayL0oDpkQRiTQlIjRyIXNQ5qgk9Xpv4hb+BiUY3PrUrVwnFLGRxiSERvWt5UlRB4w4QGam7Xu2J64vSgsCNrRcGjrJRqwRCVLeSQ6zYRXbJGVNW7X1eEtfWEpGKGIhbWtsG923FmeOju4YrZ7e0qnVpPRFaUHAhpZLQyfZiDUi1RR3kn0Vl5DJScKatrSvx0PyhV1jG2fNOngsx/c5eqxhQ8slPRGhUWtEwqi2pm38iPGacsOU/rVhcVlLUrxmrc3a1Ou9FduwaBlxkYY1ts08eCyWtL4ojajDhtgorhcU51ptxbWcwtZXG6ygumztbe0ys5LpiTjUagtqa7k4tBMYSCu/40PRyj4zSX1RElGHDYlSbbFs1NOkxa/f6vV3QVdDGDN8TCzXkgStWZOkYTaMBAMkRq3veNR9UaF9QVOgzU7eSlJflFacYUMs1KrGvW7d17V58/d0yCFXRHKUu2bNVf2v7+6BldJbeQTedl2bXJXfW5Op76vBa96aobxkR9B0SRTtAoai2tUQDj74crl7pH1RoX2bN39P73nPxdq27fZIryJTrS+ScldEYJo0PM6wITGqLZZdu/ball84PuiMWuH1u7oeatoakbCqrQErrCVpxTVIg0p2mKyu9gJxVG0d2OuvP1jRF7X6jFtxf/Tqqz9rWoJBWNW+2yZr6TVIlzyzJLXXXy5G0gFiodYlY8pP+Xd2fkmrV89r2nX/ihfxunvJ648bd4ZOPvnZhr9mPaoVtHyr5y1t37Ndkkouqt6MI9ug6U+Xy2QlR9wUxUXSVEtEyJ15e0HSO32Ruzc1SapwfeJCX1d6YNsrL0vqafXBY1BfVN4HSLlp0s8v+3zJGflGnXUrX1vX7L4vSkyJIraqTZNOmHC+Xn31pw2ZlijvEItf02x/SZJ7/C5cXz4dubNnZ3+wVmyYDVOf9w25gww7/SkxFYL0CeqLivuH4n6hvE8ZiuLlGJ2dXxrURdybrZ6+odhgkxPC9n1Ju0h9mCnRSAI2MztP0tckHSPpZHcPjK7M7GxJN0oaJukH7n59mOcnYEuHoLUkUrukPkm9A3aSQcFY+TbFHeLUqd8ue83CioF3ph3imjFWay1Jwcj2kbpk+iVa+sLSkoBKUsXlo4q3CbqcVNBRtJS8ThIII7gveqd/KO4XyvsUqbIvCrqv1sFj4UB169bbIl0/G8aUG6aEDtrKDyglVZyFK75v/IjxeqvnrYpEhyBJWzsb54DtGOVGwe9J+uuggM3Mhkl6XtJHJG2U9LikC9x99UDPT8CWDo8/fqJ27Xqy6u8H6iSDgrHi2+Ud4okn/kErV84qOYINMmrUjKrTJlEJ20mWB1pBafkDPaba/aTzI60G6oskVfQhxQeUg+mfykuLDBs2Rvv2vVbxunHrj8KU9wkS1BeF6Z+qSdrBY2wDtv4XN/utqgdsp0r6mrv/Wf72FyXJ3f/bQM9LwJZO1aZIgzpJyasGY8XZp8Ud4ogRR2vPnhdifwQbZLCd5FAx/YksqpZJWtyHFPqO4qnMsP1T0MFjHKY/wwo7bdksSTx4DBOwxTnp4FBJLxfd3ijplGobm9kCSQskafJkstLSqFom6XPPza9ITChPFijfZu3aa7Vt2+0ltZZ2714tlZ1JavUi3sEqdEwDXWWgkZJ2BAs0SrUkqeI+pFC/rbd3V939U/Htd56/N9ZXgCk2//j5JcFSsw8oDxhxgEZ3jE79wWPTzrCZ2f2Sgg4FFrr7nfltfqvqZ9jOk/Rn7n55/vbFyq13+9xAr80ZtnSqPi1hKg60gpIFKg2T2bBEnk0LI6iDrDa1GQbTn0BtA625LQjXP5X2aQVxm/6sR5jL1g1GWvqiSM+wufufDvEpNko6rOj2JEmbhvicSLCgjiqokyw/8g0WfUp8M5WfcauWPBBmjUi1ZIWkd5BAIwWddZP2VmwXpn8ya0/NwWNB8Vm3sJe5qnbfmOFjtGPPjsz1RXGeEn1c0tFmdrikVyTNk3RhtE1C3AR3kuEyg5J8tBpG+bSEJJ02+bSaWVhBWaJZ6hCBwQrqS4JnBQbun9J08Bgk6IAyTJZo1vujqLJEPynpf0maIOkNSU+6+5+Z2SHKle+Ym99urqQblCvr8SN3D1WBkylRAACQFLFNOnD3X0n6VcD9myTNLbq9VNLSFjYNAAAgdriWKAAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxBwBGwAAQMwRsAEAAMQcARsAAEDMEbABAADEHAEbAABAzBGwAQAAxFwkAZuZnWdmq8ysz8xm1thunZk9Y2ZPmtnyVrYRAAAgLvaL6HWflfTnkr4XYtsPu/trTW4PAABAbEUSsLn7c5JkZlG8PAAAQKLEfQ2bS7rXzFaY2YKoGwMAABCFpp1hM7P7JU0M+NVCd78z5NOc5u6bzOwgSfeZ2R/d/aEqr7dAUiGo6zazZ+tvNYbgQElMXbcW73nr8Z63Hu956/Get957B9qgaQGbu/9pA55jU/7/rWb2K0knSwoM2Nx9saTFkmRmy929ajIDGo/3vPV4z1uP97z1eM9bj/e89cIkVsZ2StTMRpnZuwo/S/qocskKAAAAmRJVWY9PmtlGSadK+rWZ/Uv+/kPMbGl+s/dI+p2ZPSXpMUm/dvd/jqK9AAAAUYoqS/RXkn4VcP8mSXPzP6+VNH2QL7F48K3DIPGetx7veevxnrce73nr8Z633oDvubl7KxoCAACAQYrtGjYAAADkpDZgM7PPmdma/CWw/r+o25MVZvbXZuZmdmDUbUk7M/sHM/ujmT1tZr8ys3FRtymtzOzsfH/yopldG3V70s7MDjOz35jZc/k+/PNRtykrzGyYma00s3uibksWmNk4M/tFvi9/zsxOrbZtKgM2M/uwpHMlneDux0r6HxE3KRPM7DBJH5G0Ieq2ZMR9ko5z9xMkPS/pixG3J5XMbJikb0uaI2mapAvMbFq0rUq9fZL+X3c/RtIsSVfznrfM5yU9F3UjMuRGSf/s7u9Tbt1+1fc+lQGbpCslXe/u3VKujlvE7cmKb0r6G+WuUIEmc/d73X1f/ua/SZoUZXtS7GRJL7r7WnfvkfSPyh0QokncfbO7P5H/+S3lBrFDo21V+pnZJEkfk/SDqNuSBWY2RtLpkn4oSe7e4+5vVNs+rQHbVEkfMrNHzexBMzsp6galnZl9QtIr7v5U1G3JqMskLYu6ESl1qKSXi25vFMFDy5jZFEknSno02pZkwg3KHXT3Rd2QjDhC0jZJt+SnoX+QrzsbKJKyHo1Q69JXyv1d71buVPpJkv7JzI5wUmKHZID3/O+UK26MBgpziTczW6jcFNKSVrYtQyzgPvqSFjCz0ZL+j6Rr3P3NqNuTZmZ2jqSt7r7CzM6Muj0ZsZ+k90v6nLs/amY3SrpW0perbZxItS59ZWZXSvplPkB7zMz6lLs22rZWtS+Nqr3nZna8pMMlPWVmUm5q7gkzO9ndt7Swiakz0CXezOwSSedIms0BSdNslHRY0e1JkjZF1JbMMLN25YK1Je7+y6jbkwGnSfqEmc2VtL+kMWb2M3e/KOJ2pdlGSRvdvXD2+BfKBWyB0joleoeksyTJzKZK6hAXsm0ad3/G3Q9y9ynuPkW5nfD9BGvNZWZnS/pbSZ9w991RtyfFHpd0tJkdbmYdkuZJuiviNqWa5Y78fijpOXf/n1G3Jwvc/YvuPinfh8+T9K8Ea82VHyNfNrPChd9nS1pdbfvEnmEbwI8k/cjMnpXUI+kSzj4ghW6SNFzSffkzm//m7ldE26T0cfd9ZvZZSf8iaZikH7n7qoiblXanSbpY0jNm9mT+vr9z96U1HgMk0eckLckfDK6V9JfVNuRKBwAAADGX1ilRAACA1CBgAwAAiDkCNgAAgJgjYAMAAIg5AjYAAICYI2ADgCrM7DAze8nMxudvvzt/uzPqtgHIFgI2AKjC3V+W9F1J1+fvul7SYndfH12rAGQRddgAoIb8JZJWKFeQ+z9JOtHde6JtFYCsSeuVDgCgIdx9r5n9F0n/LOmjBGsAosCUKAAMbI6kzZKOi7ohALKJgA0AajCzGZI+ImmWpC+Y2cERNwlABhGwAUAVZmbKJR1c4+4bJP2DpP8RbasAZBEBGwBU958kbXD3+/K3vyPpfWZ2RoRtApBBZIkCAADEHGfYAAAAYo6ADQAAIOYI2AAAAGKOgA0AACDmCNgAAABijoANAAAg5gjYAAAAYo6ADQAAIOb+L5puiuH0b7CZAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_functions()" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "sns.set()" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_functions()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What does more advanced seaborn look like? [Click here](https://towardsdatascience.com/3-awesome-visualization-techniques-for-every-dataset-9737eecacbe8) for an example on *Medium*." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Anatomy of a pandas Series\n", "\n", "I am a Series, what are my parts? Am more than just a numpy array, but you could say I have a numpy array as payload.\n", "\n", "#### What does it eat?\n", "\n", "How might I be [initialized](https://pandas.pydata.org/pandas-docs/stable/reference/series.html#constructor)? Let's try me." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "from pandas import Series" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "data = {'a':1, 'b':2, 'z':22}\n", "test1 = Series(data)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "a 1 \n", "b 2 \n", "z 22\n", "dtype: int64" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "OK, so a dictionary works. You could decompose (deconstruct) a dict into its values and keys, using the corresponding methods, and feed those in separately, with keys the index, but why bother? Still, it's nice to know that we can." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "a 1 \n", "b 2 \n", "z 22\n", "dtype: int64" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test1a = Series(data=list(data.values()), index=data.keys())\n", "test1a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Why was it necessary to feed ```data.values()``` to the list type, instead of just using it directly? \n", "\n", "Modify the code and see. \n", "\n", "The object returned by ```data.values()``` is interpreted as a single tuple to be repeated over and over, for each index row. Atom smash it with list( ) into component particles and you're set." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "from string import ascii_lowercase as letters\n", "test2 = Series(np.arange(10), \n", " index=list(letters)[:10], # just as many as needed\n", " name = \"Labeled\", dtype=np.int8)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "a 0\n", "b 1\n", "c 2\n", "d 3\n", "e 4\n", "f 5\n", "g 6\n", "h 7\n", "i 8\n", "j 9\n", "Name: Labeled, dtype: int8" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test2" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "payload = test2.values # extract the numpy array nutty goodness" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "numpy.ndarray" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(payload) # or tolist() if you wish a Python list" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int8)" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "payload" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "def digitrange(minlen, maxlen, base=2):\n", " \"\"\"Generator producing all lists of digits to a given base.\"\"\"\n", " digits = [0] * maxlen\n", " loop = True\n", " if minlen > 0: \n", " digits[minlen] = 1\n", " while loop:\n", " yield tuple(reversed(digits))\n", " digits[0] += 1\n", " i = 0\n", " while digits[i] >= base:\n", " if ((i+1) >= maxlen):\n", " loop = False\n", " break\n", " digits[i] = 0\n", " digits[i+1] += 1\n", " i += 1" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_values([1, 5, 10, 10, 5, 1])\n" ] } ], "source": [ "gen = digitrange(0, 5, base=2)\n", "from collections import defaultdict\n", "tally = defaultdict(int)\n", "for p in gen:\n", " tally[p.count(1)] += 1\n", "print(tally.values())" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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\n", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "YouTubeVideo(\"WWv0RUxDfbs\")" ] } ], "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": 4 }