DataCamp.Course_048_Introduction to Importing Data in Python.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **DataCamp.Course_048_Introduction to Importing Data in Python**\n",
    "\n",
    "### **Course Description**\n",
    "\n",
    "As a data scientist, you will need to clean data, wrangle and munge it, visualize it, build predictive models, and interpret these models. Before you can do so, however, you will need to know how to get data into Python. In this course, you'll learn the many ways to import data into Python: from flat files such as .txt and .csv; from files native to other software such as Excel spreadsheets, Stata, SAS, and MATLAB files; and from relational databases such as SQLite and PostgreSQL."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Introduction and flat files (Module 01-048)**"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Welcome to the course!**\n",
    "\n",
    "1. Import data\n",
    "\n",
    "- Flat files, e.g. .txts, .csvs\n",
    "- Files from other software\n",
    "- Relational databases\n",
    "\n",
    "- Flat file\n",
    "ej:     Plain text files\n",
    "        Table data: titanic.csv\n",
    "\n",
    "2. Reading a text file\n",
    "filename = 'huck_finn.txt'\n",
    "file = open(filename, mode='r') # 'r' is to read\n",
    "text = file.read()\n",
    "file.close()\n",
    "\n",
    "3. Printing a text file\n",
    "print(text)\n",
    "\n",
    "4. Writing to a file\n",
    "filename = 'huck_finn.txt'\n",
    "file = open(filename, mode='w') # 'w' is to write\n",
    "file.close()\n",
    "\n",
    "5. Context manager **with**\n",
    "with open('huck_finn.txt', 'r') as file:\n",
    "print(file.read())\n",
    "\n",
    "6. In the exercises, you’ll:\n",
    "- Print files to the console\n",
    "- Print specific lines\n",
    "- Discuss flat ,les"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exploring your working directory**\n",
    "\n",
    "In order to import data into Python, you should first have an idea of what files are in your working directory.\n",
    "\n",
    "IPython, which is running on DataCamp's servers, has a bunch of cool commands, including its *magic commands*. For example, starting a line with ! gives you complete system shell access. This means that the IPython magic command ! ls will display the contents of your current directory. Your task is to use the IPython magic command ! ls to check out the contents of your current directory and answer the following question: which of the following files is in your working directory?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "'ls' is not recognized as an internal or external command,\n",
      "operable program or batch file.\n"
     ]
    }
   ],
   "source": [
    "! ls"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing entire text files**\n",
    "\n",
    "In this exercise, you'll be working with the file moby_dick.txt. It is a text file that contains the opening sentences of Moby Dick, one of the great American novels! Here you'll get experience opening a text file, printing its contents to the shell and, finally, closing it.\n",
    "\n",
    "STEPS\n",
    "    Open the file moby_dick.txt as read-only and store it in the variable file. Make sure to pass the filename enclosed in quotation marks ''.\n",
    "    Print the contents of the file to the shell using the print() function. As Hugo showed in the video, you'll need to apply the method read() to the object file.\n",
    "    Check whether the file is closed by executing print(file.closed).\n",
    "    Close the file using the close() method.\n",
    "    Check again that the file is closed as you did above.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xx MOBY-DICK \n",
      "\n",
      "' \" My God ! Mr. Chace, what is the matter ? \" I answered, \n",
      "\" We have been stove by a whale.\" ! \n",
      "\n",
      "Narrative of the Shipwreck of the Whale Ship \n",
      "Essex of Nantucket, which was attacked and \n",
      "finally destroyed by a large Sperm Whale in \n",
      "the Pacific Ocean. By Owen Chace of Nan- \n",
      "tucket, first mate of said vessel. New York, \n",
      "1821. \n",
      "\n",
      "' A mariner sat in the shrouds one night, \n",
      "\n",
      "The wind was piping free ; \n",
      "\n",
      "Now bright, now dimmed, was the moonlight pale, \n",
      "And the phospher gleamed in the wake of the whale, \n",
      "As it floundered in the sea.' \n",
      "\n",
      "Elizabeth Oakes Smith. \n",
      "\n",
      "' The quantity of line withdrawn from the different boats \n",
      "engaged in the capture of this one whale, amounted alto- \n",
      "gether to 10,440 yards or nearly six English miles. * * * \n",
      "\n",
      "t Sometimes the whale shakes its tremendous tail in the \n",
      "air, which, cracking like a whip, resounds to the distance of \n",
      "three or four miles.' Scoresby. \n",
      "\n",
      "1 Mad with the agonies he endures from these fresh attacks, \n",
      "the infuriated Sperm Whale rolls over and over ; he rears his \n",
      "enormous head, and with wide expanded jaws snaps at every- \n",
      "thing around him ; he rushes at the boats with his head ; \n",
      "they are propelled before him with vast swiftness, and some- \n",
      "times utterly destroyed. \n",
      "\n",
      "* * * It is a matter of great astonishment that the \n",
      "consideration of the habits of so interesting, and, in a com- \n",
      "mercial point of view, of so important an animal (as the Sperm \n",
      "Whale) should have been so entirely neglected, or should have \n",
      "excited so little curiosity among the numerous, and many of \n",
      "them competent observers, that of late years must have \n",
      "possessed the most abundant and the most convenient oppor- \n",
      "tunities of witnessing their habitudes. 5 \n",
      "\n",
      "Thomas Beale's History of the Sperm Whale. 1839. \n",
      "\n",
      "' The Cachalot ' (Sperm Whale) ' is not only better armed \n",
      "than the True Whale ' (Greenland or Right Whale) ' in possess- \n",
      "ing a formidable weapon at either extremity of its body, \n",
      "but also more frequently displays a disposition to employ \n",
      "these weapons offensively, and in a manner at once so artful, \n",
      "\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "filename = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\moby_dick.txt'\n",
    "\n",
    "# Open a file: file\n",
    "file = open(filename, mode='r')\n",
    "\n",
    "# Print it\n",
    "print(file.read())\n",
    "\n",
    "# Check whether file is closed\n",
    "print(file.closed)\n",
    "\n",
    "# Close file\n",
    "file.close()\n",
    "\n",
    "# Check whether file is closed\n",
    "print(file.closed)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing text files line by line**\n",
    "\n",
    "For large files, we may not want to print all of their content to the shell: you may wish to print only the first few lines. Enter the `readline()` method, which allows you to do this. When a file called file is open, you can print out the first line by executing `file.readline()`. If you execute the same command again, the second line will print, and so on.\n",
    "\n",
    "In the introductory video, Hugo also introduced the concept of a **context manager**. He showed that you can bind a variable `file` by using a context manager construct:\n",
    "\n",
    "`with open('huck_finn.txt') as file:`\n",
    "\n",
    "While still within this construct, the variable file will be bound to open('huck_finn.txt'); thus, to print the file to the shell, all the code you need to execute is:\n",
    "\n",
    "`with open('huck_finn.txt') as file:`\n",
    "`    print(file.readline())`\n",
    "\n",
    "You'll now use these tools to print the first few lines of `moby_dick.txt`!\n",
    "\n",
    "STEPS\n",
    "    Open moby_dick.txt using the with context manager and the variable file.\n",
    "    Print the first three lines of the file to the shell by using readline() three times within the context manager."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xx MOBY-DICK \n",
      "\n",
      "\n",
      "\n",
      "' \" My God ! Mr. Chace, what is the matter ? \" I answered, \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Read & print the first 3 lines\n",
    "with open(filename) as file:\n",
    "    print(file.readline())\n",
    "    print(file.readline())\n",
    "    print(file.readline())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **The importance of flat files in data science**\n",
    "\n",
    "1. Flat files\n",
    "titanic.csv\n",
    "\n",
    "- Text files containing records\n",
    "- That is, table data\n",
    "- Record: row of fields or a\n",
    "- Column: feature or attribute\n",
    "- Header\n",
    "\n",
    "2. File extension\n",
    ".csv - Comma separated values\n",
    ".txt - Text ,le\n",
    "commas, tabs - Delimiters\n",
    "\n",
    "3. Tab-delimited file\n",
    "MNIST.txt\n",
    "\n",
    "4. How do you import flat files?\n",
    "- Two main packages: NumPy, pandas\n",
    "- Here, you’ll learn to import:\n",
    "Flat files with numerical data (MNIST)\n",
    "Flat files with numerical data and strings (titanic.csv)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Why we like flat files and the Zen of Python**\n",
    "\n",
    "In PythonLand, there are currently hundreds of Python Enhancement Proposals, commonly referred to as PEPs. PEP8, for example, is a standard style guide for Python, written by our sensei Guido van Rossum himself. It is the basis for how we here at DataCamp ask our instructors to style their code. Another one of my favorites is PEP20, commonly called the Zen of Python. Its abstract is as follows:\n",
    "\n",
    "    Long time Pythoneer Tim Peters succinctly channels the BDFL's guiding principles for Python's design into 20 aphorisms, only 19 of which have been written down.\n",
    "\n",
    "If you don't know what the acronym BDFL stands for, I suggest that you look here. You can print the Zen of Python in your shell by typing import this into it! You're going to do this now and the 5th aphorism (line) will say something of particular interest.\n",
    "\n",
    "The question you need to answer is: what is the 5th aphorism of the Zen of Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Importing flat files using NumPy**\n",
    "\n",
    "1. Why NumPy?\n",
    "\n",
    "- NumPy arrays: standard for storing numerical data\n",
    "- Essential for other packages: e.g. scikit-learn\n",
    "loadtxt()\n",
    "genfromtxt()\n",
    "\n",
    "2. Importing flat files using NumPy\n",
    "import numpy as np\n",
    "filename = 'MNIST.txt'\n",
    "data = np.loadtxt(filename, delimiter=',')\n",
    "data\n",
    "\n",
    "3. Customizing your NumPy import\n",
    "import numpy as np\n",
    "filename = 'MNIST_header.txt'\n",
    "data = np.loadtxt(filename, delimiter=',', skiprows=1)\n",
    "print(data)\n",
    "\n",
    "import numpy as np \n",
    "filename = 'MNIST_header.txt'\n",
    "data = np.loadtxt(filename, delimiter=',', skiprows=1, usecols=[0, 2])\n",
    "print(data)\n",
    "\n",
    "data = np.loadtxt(filename, delimiter=',', dtype=str)\n",
    "\n",
    "4. Mixed datatypes\n",
    "titanic.csv\n",
    "\n",
    "-do not work with Numpy"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using NumPy to import flat files**\n",
    "\n",
    "In this exercise, you're now going to load the MNIST digit recognition dataset using the numpy function `loadtxt() `and see just how easy it can be:\n",
    "\n",
    "    The first argument will be the filename.\n",
    "    The second will be the delimiter which, in this case, is a comma.\n",
    "\n",
    "You can find more information about the MNIST dataset here on the webpage of Yann LeCun, who is currently Director of AI Research at Facebook and Founding Director of the NYU Center for Data Science, among many other things.\n",
    "\n",
    "STEPS\n",
    "\n",
    "    Fill in the arguments of np.loadtxt() by passing file and a comma ',' for the delimiter.\n",
    "    Fill in the argument of print() to print the type of the object digits. Use the function type().\n",
    "    Execute the rest of the code to visualize one of the rows of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import package\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Assign filename to variable: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\mnist_kaggle_some_rows.csv'\n",
    "\n",
    "# Load file as array: digits\n",
    "digits = np.loadtxt(file, delimiter=',')\n",
    "\n",
    "# Print datatype of digits\n",
    "print(type(digits))\n",
    "\n",
    "# Select and reshape a row\n",
    "im = digits[21, 1:]\n",
    "im_sq = np.reshape(im, (28, 28))\n",
    "\n",
    "# Plot reshaped data (matplotlib.pyplot already loaded as plt)\n",
    "plt.imshow(im_sq, cmap='Greys', interpolation='nearest')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Customizing your NumPy import**\n",
    "\n",
    "What if there are rows, such as a header, that you don't want to import? What if your file has a delimiter other than a comma? What if you only wish to import particular columns?\n",
    "\n",
    "There are a number of arguments that `np.loadtxt()` takes that you'll find useful:\n",
    "\n",
    "    delimiter changes the delimiter that loadtxt() is expecting.\n",
    "        You can use ',' for comma-delimited.\n",
    "        You can use '\\t' for tab-delimited. \n",
    "    skiprows allows you to specify how many rows (not indices) you wish to skip\n",
    "    usecols takes a list of the indices of the columns you wish to keep.\n",
    "\n",
    "The file that you'll be importing, `digits_header.txt`, has a header and is tab-delimited.\n",
    "\n",
    "STEPS\n",
    "    Complete the arguments of np.loadtxt(): the file you're importing is tab-delimited, you want to skip the first row and you only want to import the first and third columns.\n",
    "    Complete the argument of the print() call in order to print the entire array that you just imported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [1. 0.]\n",
      " [4. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]\n",
      " [7. 0.]\n",
      " [3. 0.]\n",
      " [5. 0.]\n",
      " [3. 0.]\n",
      " [8. 0.]\n",
      " [9. 0.]\n",
      " [1. 0.]\n",
      " [3. 0.]\n",
      " [3. 0.]\n",
      " [1. 0.]\n",
      " [2. 0.]\n",
      " [0. 0.]\n",
      " [7. 0.]\n",
      " [5. 0.]\n",
      " [8. 0.]\n",
      " [6. 0.]\n",
      " [2. 0.]\n",
      " [0. 0.]\n",
      " [2. 0.]\n",
      " [3. 0.]\n",
      " [6. 0.]\n",
      " [9. 0.]\n",
      " [9. 0.]\n",
      " [7. 0.]\n",
      " [8. 0.]\n",
      " [9. 0.]\n",
      " [4. 0.]\n",
      " [9. 0.]\n",
      " [2. 0.]\n",
      " [1. 0.]\n",
      " [3. 0.]\n",
      " [1. 0.]\n",
      " [1. 0.]\n",
      " [4. 0.]\n",
      " [9. 0.]\n",
      " [1. 0.]\n",
      " [4. 0.]\n",
      " [4. 0.]\n",
      " [2. 0.]\n",
      " [6. 0.]\n",
      " [3. 0.]\n",
      " [7. 0.]\n",
      " [7. 0.]\n",
      " [4. 0.]\n",
      " [7. 0.]\n",
      " [5. 0.]\n",
      " [1. 0.]\n",
      " [9. 0.]\n",
      " [0. 0.]\n",
      " [2. 0.]\n",
      " [2. 0.]\n",
      " [3. 0.]\n",
      " [9. 0.]\n",
      " [1. 0.]\n",
      " [1. 0.]\n",
      " [1. 0.]\n",
      " [5. 0.]\n",
      " [0. 0.]\n",
      " [6. 0.]\n",
      " [3. 0.]\n",
      " [4. 0.]\n",
      " [8. 0.]\n",
      " [1. 0.]\n",
      " [0. 0.]\n",
      " [3. 0.]\n",
      " [9. 0.]\n",
      " [6. 0.]\n",
      " [2. 0.]\n",
      " [6. 0.]\n",
      " [4. 0.]\n",
      " [7. 0.]\n",
      " [1. 0.]\n",
      " [4. 0.]\n",
      " [1. 0.]\n",
      " [5. 0.]\n",
      " [4. 0.]\n",
      " [8. 0.]\n",
      " [9. 0.]\n",
      " [2. 0.]\n",
      " [9. 0.]\n",
      " [9. 0.]\n",
      " [8. 0.]\n",
      " [9. 0.]\n",
      " [6. 0.]\n",
      " [3. 0.]\n",
      " [6. 0.]\n",
      " [4. 0.]\n",
      " [6. 0.]\n",
      " [2. 0.]\n",
      " [9. 0.]\n",
      " [1. 0.]\n",
      " [2. 0.]\n",
      " [0. 0.]\n",
      " [5. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# Import numpy\n",
    "import numpy as np\n",
    "\n",
    "# Assign the filename: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\mnist_kaggle_some_rows.csv'\n",
    "\n",
    "# Load the data: data\n",
    "data = np.loadtxt(file, delimiter=',', skiprows=1, usecols=[0, 2])\n",
    "\n",
    "# Print data\n",
    "print(data)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing different datatypes**\n",
    "\n",
    "The file `seaslug.txt`\n",
    "\n",
    "    has a text header, consisting of strings\n",
    "    is tab-delimited.\n",
    "\n",
    "These data consists of percentage of sea slug larvae that had metamorphosed in a given time period. Read more *here*.\n",
    "\n",
    "Due to the header, if you tried to import it as-is using `np.loadtxt()`, Python would throw you a `ValueError` and tell you that it `could not convert string to float`. There are two ways to deal with this: firstly, you can set the data type argument `dtype` equal to `str` (for string).\n",
    "\n",
    "Alternatively, you can skip the first row as we have seen before, using the `skiprows` argument.\n",
    "\n",
    "STEPS\n",
    "    Complete the first call to np.loadtxt() by passing file as the first argument.\n",
    "    Execute print(data[0]) to print the first element of data.\n",
    "    Complete the second call to np.loadtxt(). The file you're importing is tab-delimited, the datatype is float, and you want to skip the first row.\n",
    "    Print the 10th element of data_float by completing the print() command. Be guided by the previous print() call.\n",
    "    Execute the rest of the code to visualize the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Time' 'Percent']\n",
      "[0.    0.357]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Assign filename: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\seaslug.txt'\n",
    "\n",
    "# Import file: data\n",
    "data = np.loadtxt(file, delimiter='\\t', dtype=str)\n",
    "\n",
    "# Print the first element of data\n",
    "print(data[0])\n",
    "\n",
    "# Import data as floats and skip the first row: data_float\n",
    "data_float = np.loadtxt(file, delimiter='\\t', dtype=float, skiprows=1)\n",
    "\n",
    "# Print the 10th element of data_float\n",
    "print(data_float[9])\n",
    "\n",
    "# Plot a scatterplot of the data\n",
    "plt.scatter(data_float[:, 0], data_float[:, 1])\n",
    "plt.xlabel('time (min.)')\n",
    "plt.ylabel('percentage of larvae')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Working with mixed datatypes (1)**\n",
    "\n",
    "Much of the time you will need to import datasets which have different datatypes in different columns; one column may contain strings and another floats, for example. The function `np.loadtxt()` will freak at this. There is another function, `np.genfromtxt()`, which can handle such structures. If we pass `dtype=None` to it, it will figure out what types each column should be.\n",
    "\n",
    "Import `'titanic.csv'` using the function `np.genfromtxt()` as follows:\n",
    "\n",
    "`data = np.genfromtxt('titanic.csv', delimiter=',', names=True, dtype=None)`\n",
    "\n",
    "Here, the first argument is the filename, the second specifies the delimiter `,` and the third argument `names` tells us there is a header. Because the data are of different types, `data` is an object called a *structured array*. Because numpy arrays have to contain elements that are all the same type, the structured array solves this by being a 1D array, where each element of the array is a row of the flat file imported. You can test this by checking out the array's shape in the shell by executing `np.shape(data)`.\n",
    "\n",
    "Accessing rows and columns of structured arrays is super-intuitive: to get the ith row, merely execute data[i] and to get the column with name '`Fare`', execute `data['Fare']`.\n",
    "\n",
    "After importing the Titanic data as a structured array (as per the instructions above), print the entire column with the name `Survived` to the shell. What are the last 4 values of this column?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mcaba\\AppData\\Local\\Temp\\ipykernel_5888\\804724302.py:4: VisibleDeprecationWarning: Reading unicode strings without specifying the encoding argument is deprecated. Set the encoding, use None for the system default.\n",
      "  data = np.genfromtxt(file, delimiter=',', names=True, dtype=None)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1,\n",
       "       1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1,\n",
       "       1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1,\n",
       "       1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n",
       "       1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0,\n",
       "       0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0,\n",
       "       0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0,\n",
       "       1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0,\n",
       "       1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1,\n",
       "       0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "       0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,\n",
       "       1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n",
       "       0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n",
       "       1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,\n",
       "       0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0,\n",
       "       0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,\n",
       "       0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0,\n",
       "       1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,\n",
       "       1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,\n",
       "       1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0,\n",
       "       0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1,\n",
       "       1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,\n",
       "       1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0,\n",
       "       0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1,\n",
       "       0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0,\n",
       "       0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0,\n",
       "       1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1,\n",
       "       0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0,\n",
       "       0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0,\n",
       "       1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1,\n",
       "       0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0,\n",
       "       0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1,\n",
       "       0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1,\n",
       "       1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1,\n",
       "       1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign filename: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\titanic_sub.csv'\n",
    "\n",
    "data = np.genfromtxt(file, delimiter=',', names=True, dtype=None)\n",
    "\n",
    "data['Survived']"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Working with mixed datatypes (2)**\n",
    "\n",
    "You have just used `np.genfromtxt()` to import data containing mixed datatypes. There is also another function `np.recfromcsv()` that behaves similarly to `np.genfromtxt()`, except that its default `dtype` is `None`. In this exercise, you'll practice using this to achieve the same result.\n",
    "\n",
    "STEPS\n",
    "    Import titanic.csv using the function np.recfromcsv() and assign it to the variable, d. You'll only need to pass file to it because it has the defaults delimiter=',' and names=True in addition to dtype=None!\n",
    "    Run the remaining code to print the first three entries of the resulting array d."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 0, 3, b'male', 22., 1, 0, b'A/5 21171',  7.25  , b'', b'S')\n",
      " (2, 1, 1, b'female', 38., 1, 0, b'PC 17599', 71.2833, b'C85', b'C')\n",
      " (3, 1, 3, b'female', 26., 0, 0, b'STON/O2. 3101282',  7.925 , b'', b'S')]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mcaba\\AppData\\Roaming\\Python\\Python310\\site-packages\\numpy\\lib\\npyio.py:2500: VisibleDeprecationWarning: Reading unicode strings without specifying the encoding argument is deprecated. Set the encoding, use None for the system default.\n",
      "  output = genfromtxt(fname, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "# Assign the filename: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\titanic_sub.csv'\n",
    "\n",
    "# Import file using np.recfromcsv: d\n",
    "d = np.recfromcsv(file, delimiter=',', names=True)\n",
    "\n",
    "# Print out first three entries of d\n",
    "print(d[:3])\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Importing flat files using pandas**\n",
    "\n",
    "1. What a data scientist needs\n",
    "Two-dimensional labeled data structure(s)\n",
    "Columns of potentially di(erent types\n",
    "Manipulate, slice, reshape, groupby, join, merge\n",
    "Perform statistics\n",
    "Work with time series data\n",
    "\n",
    "2. Pandas and the DataFrame\n",
    "Wes McKinney\n",
    "DataFrame = pythonic analog of R’s data frame\n",
    "¨A matrix has rows and columns. A data frame has observations and variables¨ Hadley Wickham\n",
    "\n",
    "3. Manipulating pandas DataFrames\n",
    "Exploratory data analysis\n",
    "Data wrangling\n",
    "Data preprocessing\n",
    "Building models\n",
    "Visualization\n",
    "Standard and best practice to use pandas\n",
    "\n",
    "4. Importing using pandas\n",
    "import pandas as pd\n",
    "filename = 'winequality-red.csv'\n",
    "data = pd.read_csv(filename)\n",
    "data.head()\n",
    "data_array = data.values\n",
    "\n",
    "5. You’ll experience:\n",
    "Importing .at ,les in a straightforward manner\n",
    "Importing .at ,les with issues such as comments and missing\n",
    "values"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using pandas to import flat files as DataFrames (1)**\n",
    "\n",
    "In the last exercise, you were able to import flat files containing columns with different datatypes as `numpy` arrays. However, the `DataFrame` object in pandas is a more appropriate structure in which to store such data and, thankfully, we can easily import files of mixed data types as DataFrames using the pandas functions `read_csv()` and `read_table()`.\n",
    "\n",
    "STEPS\n",
    "    Import the pandas package using the alias pd.\n",
    "    Read titanic.csv into a DataFrame called df. The file name is already stored in the file object.\n",
    "    In a print() call, view the head of the DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   PassengerId  Survived  Pclass     Sex   Age  SibSp  Parch  \\\n",
      "0            1         0       3    male  22.0      1      0   \n",
      "1            2         1       1  female  38.0      1      0   \n",
      "2            3         1       3  female  26.0      0      0   \n",
      "3            4         1       1  female  35.0      1      0   \n",
      "4            5         0       3    male  35.0      0      0   \n",
      "\n",
      "             Ticket     Fare Cabin Embarked  \n",
      "0         A/5 21171   7.2500   NaN        S  \n",
      "1          PC 17599  71.2833   C85        C  \n",
      "2  STON/O2. 3101282   7.9250   NaN        S  \n",
      "3            113803  53.1000  C123        S  \n",
      "4            373450   8.0500   NaN        S  \n"
     ]
    }
   ],
   "source": [
    "# Import pandas as pd\n",
    "import pandas as pd\n",
    "\n",
    "# Assign the filename: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\titanic_sub.csv'\n",
    "\n",
    "# Read the file into a DataFrame: df\n",
    "df = pd.read_csv(file)\n",
    "\n",
    "# View the head of the DataFrame\n",
    "print(df.head())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using pandas to import flat files as DataFrames (2)**\n",
    "\n",
    "In the last exercise, you were able to import flat files into a `pandas` DataFrame. As a bonus, it is then straightforward to retrieve the corresponding `numpy` array using the attribute `values`. You'll now have a chance to do this using the MNIST dataset, which is available as `digits.csv`.\n",
    "\n",
    "STEPS\n",
    "    Import the first 5 rows of the file into a DataFrame using the function pd.read_csv() and assign the result to data. You'll need to use the arguments nrows and header (there is no header in this file).\n",
    "    Build a numpy array from the resulting DataFrame in data and assign to data_array.\n",
    "    Execute print(type(data_array)) to print the datatype of data_array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Assign the filename: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\mnist_kaggle_some_rows.csv'\n",
    "\n",
    "# Read the first 5 rows of the file into a DataFrame: data\n",
    "data = pd.read_csv(file,header = None,nrows=5)\n",
    "\n",
    "# Build a numpy array from the DataFrame: data_array\n",
    "data_array = np.array(data)\n",
    "\n",
    "# Print the datatype of data_array to the shell\n",
    "print(type(data_array))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Customizing your pandas import**\n",
    "\n",
    "The `pandas` package is also great at dealing with many of the issues you will encounter when importing data as a data scientist, such as comments occurring in flat files, empty lines and missing values. Note that missing values are also commonly referred to as `NA` or `NaN`. To wrap up this chapter, you're now going to import a slightly corrupted copy of the Titanic dataset `titanic_corrupt.txt`, which\n",
    "\n",
    "    contains comments after the character '#'\n",
    "    is tab-delimited.\n",
    "STEPS\n",
    "    Complete the sep (the pandas version of delim), comment and na_values arguments of pd.read_csv(). comment takes characters that comments occur after in the file, which in this case is '#'. na_values takes a list of strings to recognize as NA/NaN, in this case the string 'Nothing'.\n",
    "    Execute the rest of the code to print the head of the resulting DataFrame and plot the histogram of the 'Age' of passengers aboard the Titanic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   PassengerId  Survived  Pclass     Sex   Age  SibSp  Parch  \\\n",
      "0            1         0       3    male  22.0      1      0   \n",
      "1            2         1       1  female  38.0      1      0   \n",
      "2            3         1       3  female  26.0      0      0   \n",
      "3            4         1       1  female  35.0      1      0   \n",
      "4            5         0       3    male  35.0      0      0   \n",
      "\n",
      "             Ticket     Fare Cabin Embarked  \n",
      "0         A/5 21171   7.2500   NaN        S  \n",
      "1          PC 17599  71.2833   C85        C  \n",
      "2  STON/O2. 3101282   7.9250   NaN        S  \n",
      "3            113803  53.1000  C123        S  \n",
      "4            373450   8.0500   NaN        S  \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import matplotlib.pyplot as plt\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Assign filename: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\titanic_sub.csv'\n",
    "\n",
    "# Import file: data\n",
    "data = pd.read_csv(file, sep=',', comment='#', na_values='Nothing')\n",
    "\n",
    "# Print the head of the DataFrame\n",
    "print(data.head())\n",
    "\n",
    "# Plot 'Age' variable in a histogram\n",
    "pd.DataFrame.hist(data[['Age']])\n",
    "plt.xlabel('Age (years)')\n",
    "plt.ylabel('count')\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Importing data from other file types (Module 02-048)**"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Introduction to other file types**\n",
    "\n",
    "1. Other file types\n",
    "Excel spreadsheets\n",
    "MATLAB files\n",
    "SAS files\n",
    "Stata files\n",
    "HDF5 files\n",
    "\n",
    "2. Pickled files\n",
    "\n",
    "- File type native to Python\n",
    "- Motivation: many datatypes for which it isn’t obvious how to store them\n",
    "- Pickled filesare serialized\n",
    "- Serialize = convert object to bytestream\n",
    "import pickle\n",
    "with open('pickled_fruit.pkl', 'rb') as file:\n",
    "data = pickle.load(file)\n",
    "print(data)\n",
    "\n",
    "`{'peaches': 13, 'apples': 4, 'oranges': 11}`\n",
    "\n",
    "3. Importing Excel spreadsheets\n",
    "import pandas as pd\n",
    "file = 'urbanpop.xlsx'\n",
    "data = pd.ExcelFile(file)\n",
    "print(data.sheet_names)\n",
    "\n",
    "`['1960-1966', '1967-1974', '1975-2011']`\n",
    "\n",
    "df1 = data.parse('1960-1966') # sheet name, as a string\n",
    "df2 = data.parse(0) # sheet index, as a float\n",
    "\n",
    "4. You’ll learn:\n",
    "How to customize your import\n",
    "Skip rows\n",
    "Import certain columns\n",
    "Change column names"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Not so flat any more**\n",
    "\n",
    "In Chapter 1, you learned how to use the IPython magic command `! ls` to explore your current working directory. You can also do this natively in Python using the *library* `os`, which consists of miscellaneous operating system interfaces.\n",
    "\n",
    "The first line of the following code imports the library `os`, the second line stores the name of the current directory in a string called `wd` and the third outputs the contents of the directory in a list to the shell.\n",
    "\n",
    "`import os`\n",
    "`wd = os.getcwd()`\n",
    "`os.listdir(wd)`\n",
    "\n",
    "Run this code in the IPython shell and answer the following questions. Ignore the files that begin with `.`.\n",
    "\n",
    "Check out the contents of your current directory and answer the following questions: (1) which file is in your directory and NOT an example of a flat file; (2) why is it not a flat file?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['DataCamp.Course_001_Introduction_to_R',\n",
       " 'DataCamp.Course_002_Intermediate_R',\n",
       " 'DataCamp.Course_003_Introduction_to_the_Tidyverse',\n",
       " 'DataCamp.Course_004_Importing_Data_in_R_pt1',\n",
       " 'DataCamp.Course_005_Importing_Data_in_R_pt2',\n",
       " 'DataCamp.Course_005_Cleaning_data_in_R_pt2.Course_006_Cleaning_Data_in_R',\n",
       " 'DataCamp.Course_007_Importing_&_Cleaning_Data_in_R_Case_Studies',\n",
       " 'DataCamp.Course_008_Introduction_to_Function_Writing_in_R',\n",
       " 'DataCamp.Course_009_Data_Manipulation_with_dplyr_in_R',\n",
       " 'DataCamp.Course_010_Joining_Data_with_dplyr_in_R',\n",
       " 'DataCamp.Course_011_Intro_to_SQL_for_Data_Science.sql',\n",
       " 'DataCamp.Course_012_Data_Visualization_with_ggplot2_pt1',\n",
       " 'DataCamp.Course_013_Data_Visualization_with_ggplot2_pt2',\n",
       " 'DataCamp.Course_014_working with dates and times in R_pt2.Course_014_Working_with_Dates_and_Times_in_R',\n",
       " 'DataCamp.Course_015_Introduction_to_Data_in_R',\n",
       " 'DataCamp.Course_016_Exploratory_Data_Analysis_in_R',\n",
       " 'DataCamp.Course_017_Exploratory_Data_Analysis_in_R_Case_Study',\n",
       " 'DataCamp.Course_018_Correlation_and_Regression_in_R',\n",
       " 'DataCamp.Course_019_Cluster_Analysis_in_R',\n",
       " 'DataCamp.Course_020_Supervised_Learning_in_R_Classification',\n",
       " 'DataCamp.Course_021_Unsupervised_Learning_in_R',\n",
       " 'DataCamp.Course_022_Joining_Data_in_SQL.sql',\n",
       " 'DataCamp.Course_023_Intermediate SQL.sql',\n",
       " 'DataCamp.Course_024_PostgreSQL_Summary_Stats_and_Window_Functions.sql',\n",
       " 'DataCamp.Course_025_Functions_for_Manipulating_Data_in_PostgreSQL.sql',\n",
       " 'DataCamp.Course_026_Exploratory_Data_Analysis_in_SQL.sql',\n",
       " 'DataCamp.Course_027_Data_Driven_Decision_Making_in_SQL.sql',\n",
       " 'DataCamp.Course_028_Applying_SQL_to_Real_World_Problems.sql',\n",
       " 'DataCamp.Course_029_Data_Analysis_in_Excel.txt',\n",
       " 'DataCamp.Course_030_Introduction to Power BI.txt',\n",
       " 'DataCamp.Course_031_Analyzing_Business_Data_in_SQL.sql',\n",
       " 'DataCamp.Course_031_Analyzing_Business_Data_in_SQL_1.sql',\n",
       " 'DataCamp.Course_032_Reporting_in_SQL.sql',\n",
       " '.git',\n",
       " 'README.md',\n",
       " '.gitattributes',\n",
       " 'DataCamp.Course_036_Joining_Data_with_pandas.ipynb',\n",
       " 'DataCamp.Course_041_Introduction to Statistics in Python.ipynb',\n",
       " 'DataCamp.Course_035_Data_Manipulation_with_pandas.ipynb',\n",
       " 'DataCamp.Course_034_Intermediate Python.ipynb',\n",
       " 'DataCamp.Course_033_Introduction to Python.ipynb',\n",
       " 'datasets',\n",
       " 'DataCamp.Course_042_Introduction to Data Visualization with Matplotlib.ipynb',\n",
       " 'DataCamp.Course_043_Introduction to Data Visualization with Seaborn.ipynb',\n",
       " 'DataCamp.Course_044_Introduction to NumPy.ipynb',\n",
       " 'DataCamp.Course_045_Python Data Science Toolbox Part 1.ipynb',\n",
       " 'DataCamp.Course_046_Python Data Science Toolbox Part 2.ipynb',\n",
       " 'DataCamp.Course_047_Intermediate Data Visualization with Seaborn.ipynb',\n",
       " 'DataCamp.Course_048_Introduction to Importing Data in Python.ipynb']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "wd = os.getcwd()\n",
    "os.listdir(wd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loading a pickled file**\n",
    "\n",
    "There are a number of datatypes that cannot be saved easily to flat files, such as lists and dictionaries. If you want your files to be human readable, you may want to save them as text files in a clever manner. JSONs, which you will see in a later chapter, are appropriate for Python dictionaries.\n",
    "\n",
    "However, if you merely want to be able to import them into Python, you can *serialize* them. All this means is converting the object into a sequence of bytes, or a bytestream.\n",
    "\n",
    "In this exercise, you'll import the `pickle` package, open a previously pickled data structure from a file and load it.\n",
    "\n",
    "STEPS\n",
    "    Import the pickle package.\n",
    "    Complete the second argument of open() so that it is read only for a binary file. This argument will be a string of two letters, one signifying 'read only', the other 'binary'.\n",
    "    Pass the correct argument to pickle.load(); it should use the variable that is bound to open.\n",
    "    Print the data, d.\n",
    "    Print the datatype of d; take your mind back to your previous use of the function type()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Import pickle package\n",
    "import pickle\n",
    "\n",
    "# Open pickle file and load data: d\n",
    "with open('data.pkl', 'rb') as file:\n",
    "    d = pickle.load(file)\n",
    "\n",
    "# Print d\n",
    "print(d)\n",
    "\n",
    "# Print datatype of d\n",
    "print(type(d))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Listing sheets in Excel files**\n",
    "\n",
    "Whether you like it or not, any working data scientist will need to deal with Excel spreadsheets at some point in time. You won't always want to do so in Excel, however!\n",
    "\n",
    "Here, you'll learn how to use `pandas` to import Excel spreadsheets and how to list the names of the sheets in any loaded .xlsx file.\n",
    "\n",
    "Recall from the video that, given an Excel file imported into a variable `spreadsheet`, you can retrieve a list of the sheet names using the attribute `spreadsheet.sheet_names`.\n",
    "\n",
    "Specifically, you'll be loading and checking out the spreadsheet '`battledeath.xlsx`', modified from the Peace Research Institute Oslo's (PRIO) *dataset*. This data contains age-adjusted mortality rates due to war in various countries over several years.\n",
    "\n",
    "STEPS\n",
    "    Assign the spreadsheet filename (provided above) to the variable file.\n",
    "    Pass the correct argument to pd.ExcelFile() to load the file using pandas, assigning the result to the variable xls.\n",
    "    Print the sheetnames of the Excel spreadsheet by passing the necessary argument to the print() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2002', '2004']\n"
     ]
    }
   ],
   "source": [
    "# Required to run [[[[pip install openpyxl]]]] on TERMINAL for Python current version\n",
    "# Import pandas\n",
    "import pandas as pd\n",
    "\n",
    "# Assign spreadsheet filename: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\battledeath.xlsx'\n",
    "\n",
    "# Load spreadsheet: xls\n",
    "xls = pd.ExcelFile(file)\n",
    "\n",
    "# Print sheet names\n",
    "print(xls.sheet_names)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing sheets from Excel files**\n",
    "\n",
    "In the previous exercises, you saw that the Excel file contains two sheets, '`2002`' and '`2004`'. The next step is to import these.\n",
    "\n",
    "In this exercise, you'll learn how to import any given sheet of your loaded .xlsx file as a DataFrame. You'll be able to do so by specifying either the sheet's name or its index.\n",
    "\n",
    "The spreadsheet '`battledeath.xlsx`' is already loaded as `xls`.\n",
    "\n",
    "STEPS\n",
    "    Load the sheet '2004' into the DataFrame df1 using its name as a string.\n",
    "    Print the head of df1 to the shell.\n",
    "    Load the sheet 2002 into the DataFrame df2 using its index (0).\n",
    "    Print the head of df2 to the shell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  War(country)      2004\n",
      "0  Afghanistan  9.451028\n",
      "1      Albania  0.130354\n",
      "2      Algeria  3.407277\n",
      "3      Andorra  0.000000\n",
      "4       Angola  2.597931\n",
      "  War, age-adjusted mortality due to       2002\n",
      "0                        Afghanistan  36.083990\n",
      "1                            Albania   0.128908\n",
      "2                            Algeria  18.314120\n",
      "3                            Andorra   0.000000\n",
      "4                             Angola  18.964560\n"
     ]
    }
   ],
   "source": [
    "# Load a sheet into a DataFrame by name: df1\n",
    "df1 = xls.parse('2004')\n",
    "\n",
    "# Print the head of the DataFrame df1\n",
    "print(df1.head())\n",
    "\n",
    "# Load a sheet into a DataFrame by index: df2\n",
    "df2 = xls.parse(0)\n",
    "\n",
    "# Print the head of the DataFrame df2\n",
    "print(df2.head())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Customizing your spreadsheet import**\n",
    "\n",
    "Here, you'll parse your spreadsheets and use additional arguments to skip rows, rename columns and select only particular columns.\n",
    "\n",
    "The spreadsheet '`battledeath.xlsx'` is already loaded as `xls`.\n",
    "\n",
    "As before, you'll use the method `parse()`. This time, however, you'll add the additional arguments `skiprows`, `names` and `usecols`. These skip rows, name the columns and designate which columns to parse, respectively. All these arguments can be assigned to lists containing the specific row numbers, strings and column numbers, as appropriate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               Country  AAM due to War (2002)\n",
      "0              Albania               0.128908\n",
      "1              Algeria              18.314120\n",
      "2              Andorra               0.000000\n",
      "3               Angola              18.964560\n",
      "4  Antigua and Barbuda               0.000000\n",
      "               Country\n",
      "0              Albania\n",
      "1              Algeria\n",
      "2              Andorra\n",
      "3               Angola\n",
      "4  Antigua and Barbuda\n"
     ]
    }
   ],
   "source": [
    "# Parse the first sheet and rename the columns: df1\n",
    "df1 = xls.parse(0, skiprows=[True], names=['Country','AAM due to War (2002)'])\n",
    "\n",
    "# Print the head of the DataFrame df1\n",
    "print(df1.head())\n",
    "\n",
    "# Parse the first column of the second sheet and rename the column: df2\n",
    "df2 = xls.parse(1, usecols=[0], skiprows=[True], names=['Country'])\n",
    "\n",
    "# Print the head of the DataFrame df2\n",
    "print(df2.head())\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Importing SAS/Stata files using pandas**\n",
    "\n",
    "1. SAS and Stata files\n",
    "SAS: Statistical Analysis System\n",
    "Stata: “Statistics” + “data”\n",
    "SAS: business analytics and biostatistics\n",
    "Stata: academic social sciences research\n",
    "\n",
    "2. SAS files\n",
    "Used for:\n",
    "Advanced analytics\n",
    "Multivariate analysis\n",
    "Business intelligence\n",
    "Data management\n",
    "Predictive analytics\n",
    "Standard for computational analysis\n",
    "\n",
    "3. Importing SAS files\n",
    "import pandas as pd\n",
    "from sas7bdat import SAS7BDAT\n",
    "with SAS7BDAT('urbanpop.sas7bdat') as file:\n",
    "    df_sas = file.to_data_frame()\n",
    "\n",
    "4. Importing Stata files\n",
    "import pandas as pd\n",
    "data = pd.read_stata('urbanpop.dta')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing SAS files**\n",
    "\n",
    "In this exercise, you'll figure out how to import a SAS file as a DataFrame using `SAS7BDAT` and `pandas`. The file '`sales.sas7bdat`' is already in your working directory and both pandas and `matplotlib.pyplot` have already been imported as follows:\n",
    "\n",
    "`import pandas as pd`\n",
    "`import matplotlib.pyplot as plt`\n",
    "\n",
    "The data are adapted from the website of the undergraduate text book *Principles of Econometrics* by Hill, Griffiths and Lim.\n",
    "\n",
    "STEPS\n",
    "    Import the module SAS7BDAT from the library sas7bdat.\n",
    "    In the context of the file 'sales.sas7bdat', load its contents to a DataFrame df_sas, using the method to_data_frame() on the object file.\n",
    "    Print the head of the DataFrame df_sas.\n",
    "    Execute your entire script to produce a histogram plot!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     YEAR     P           S\n",
      "0  1950.0  12.9  181.899994\n",
      "1  1951.0  11.9  245.000000\n",
      "2  1952.0  10.7  250.199997\n",
      "3  1953.0  11.3  265.899994\n",
      "4  1954.0  11.2  248.500000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sasfile = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\sales.sas7bdat'\n",
    "# RUN ON TERMINAL [[[[pip install sas7bdat]]]]\n",
    "# Import sas7bdat package\n",
    "from sas7bdat import SAS7BDAT\n",
    "\n",
    "# Save file to a DataFrame: df_sas\n",
    "with SAS7BDAT(sasfile) as file:\n",
    "    df_sas = file.to_data_frame()\n",
    "\n",
    "# Print head of DataFrame\n",
    "print(df_sas.head())\n",
    "\n",
    "# Plot histogram of DataFrame features (pandas and pyplot already imported)\n",
    "pd.DataFrame.hist(df_sas[['P']])\n",
    "plt.ylabel('count')\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using read_stata to import Stata files**\n",
    "\n",
    "The pandas package has been imported in the environment as pd and the file disarea.dta is in your working directory. The data consist of disease extents for several diseases in various countries (more information can be found here).\n",
    "\n",
    "What is the correct way of using the read_stata() function to import disarea.dta into the object df?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  wbcode               country  disa1  disa2  disa3  disa4  disa5  disa6  \\\n",
      "0    AFG           Afghanistan   0.00   0.00   0.76   0.73    0.0   0.00   \n",
      "1    AGO                Angola   0.32   0.02   0.56   0.00    0.0   0.00   \n",
      "2    ALB               Albania   0.00   0.00   0.02   0.00    0.0   0.00   \n",
      "3    ARE  United Arab Emirates   0.00   0.00   0.00   0.00    0.0   0.00   \n",
      "4    ARG             Argentina   0.00   0.24   0.24   0.00    0.0   0.23   \n",
      "\n",
      "   disa7  disa8  ...  disa16  disa17  disa18  disa19  disa20  disa21  disa22  \\\n",
      "0   0.00    0.0  ...     0.0     0.0     0.0    0.00    0.00     0.0    0.00   \n",
      "1   0.56    0.0  ...     0.0     0.4     0.0    0.61    0.00     0.0    0.99   \n",
      "2   0.00    0.0  ...     0.0     0.0     0.0    0.00    0.00     0.0    0.00   \n",
      "3   0.00    0.0  ...     0.0     0.0     0.0    0.00    0.00     0.0    0.00   \n",
      "4   0.00    0.0  ...     0.0     0.0     0.0    0.00    0.05     0.0    0.00   \n",
      "\n",
      "   disa23  disa24  disa25  \n",
      "0    0.02    0.00    0.00  \n",
      "1    0.98    0.61    0.00  \n",
      "2    0.00    0.00    0.16  \n",
      "3    0.00    0.00    0.00  \n",
      "4    0.01    0.00    0.11  \n",
      "\n",
      "[5 rows x 27 columns]\n"
     ]
    }
   ],
   "source": [
    "statadata = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\disarea.dta'\n",
    "df = pd.read_stata(statadata)\n",
    "print(df.head())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing Stata files**\n",
    "\n",
    "Here, you'll gain expertise in importing Stata files as DataFrames using the `pd.read_stata()` function from `pandas`. The last exercise's file, '`disarea.dta`', is still in your working directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  wbcode               country  disa1  disa2  disa3  disa4  disa5  disa6  \\\n",
      "0    AFG           Afghanistan   0.00   0.00   0.76   0.73    0.0   0.00   \n",
      "1    AGO                Angola   0.32   0.02   0.56   0.00    0.0   0.00   \n",
      "2    ALB               Albania   0.00   0.00   0.02   0.00    0.0   0.00   \n",
      "3    ARE  United Arab Emirates   0.00   0.00   0.00   0.00    0.0   0.00   \n",
      "4    ARG             Argentina   0.00   0.24   0.24   0.00    0.0   0.23   \n",
      "\n",
      "   disa7  disa8  ...  disa16  disa17  disa18  disa19  disa20  disa21  disa22  \\\n",
      "0   0.00    0.0  ...     0.0     0.0     0.0    0.00    0.00     0.0    0.00   \n",
      "1   0.56    0.0  ...     0.0     0.4     0.0    0.61    0.00     0.0    0.99   \n",
      "2   0.00    0.0  ...     0.0     0.0     0.0    0.00    0.00     0.0    0.00   \n",
      "3   0.00    0.0  ...     0.0     0.0     0.0    0.00    0.00     0.0    0.00   \n",
      "4   0.00    0.0  ...     0.0     0.0     0.0    0.00    0.05     0.0    0.00   \n",
      "\n",
      "   disa23  disa24  disa25  \n",
      "0    0.02    0.00    0.00  \n",
      "1    0.98    0.61    0.00  \n",
      "2    0.00    0.00    0.16  \n",
      "3    0.00    0.00    0.00  \n",
      "4    0.01    0.00    0.11  \n",
      "\n",
      "[5 rows x 27 columns]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABA10lEQVR4nO3deViU9f7/8degMKCChAtL4ZLmmrtppJYLilqm5jezOKYe00rMhX65nHLNMj1WpplmpVZfPXUsNTNDiVLT3JXcyL2so2iGiLjgCPfvDy/meybQGJgZmNvn47q4Ludzf+4P73mL+vLexmIYhiEAAACT8inuAgAAANyJsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAOgxJk4caIsFov9dbVq1dS/f//iKwiAVyPsALilZWZmasKECercubNCQkJksVi0aNGiG85PSUlR586dVa5cOYWEhKhv3776/fffPVcwAKeVLu4CAOCvHDx4UD4+7vm/2dmzZzV58mRVqVJFjRo10rp1624497ffftP999+v8uXL69VXX1VmZqZmzJihvXv3atu2bfLz83NLjQCKhrADoMSzWq1uWzs8PFynTp1SWFiYduzYoXvuueeGc1999VVdvHhRO3fuVJUqVSRJLVq0UMeOHbVo0SINHjzYbXUCKDxOYwEoVhs3btQ999wjf39/1ahRQ++++26eOX++Zsdms2nSpEm666675O/vrwoVKqh169ZKTEy0z9mzZ4/69++vO++8U/7+/goLC9Pf//53/fHHHw5rW61WhYWFFajWzz//XA899JA96EhSdHS0atWqpX//+99OvnMAnsKRHQDFZu/everUqZMqVaqkiRMn6tq1a5owYYJCQ0Nvut/EiRM1depUPfXUU2rRooUyMjK0Y8cO7dq1Sx07dpQkJSYm6tixYxowYIDCwsK0f/9+zZ8/X/v379eWLVscLoAuiP/85z86c+aMmjdvnmdbixYttHr1aqfWA+A5hB0AxWb8+PEyDEPff/+9/WhJr1691KBBg5vu99VXX6lr166aP3/+DecMGTJEzz//vMPYvffeq8cff1wbN25UmzZtnKr11KlTkq6f9vqz8PBwpaWlKSsry62n3AAUDqexABSL7OxsrVmzRj169HA4LVS3bl3FxMTcdN/g4GDt379fhw8fvuGcgIAA+6+vXLmis2fP6t5775Uk7dq1y+l6L1++LCn/64f8/f0d5gAoWQg7AIrF77//rsuXL+uuu+7Ks6127do33Xfy5MlKT09XrVq11KBBA73wwgvas2ePw5y0tDQNHz5coaGhCggIUKVKlVS9enVJ0vnz552uNzc8ZWVl5dl25coVhzkAShbCDgCvc//99+vo0aNasGCB7r77br3//vtq2rSp3n//ffuc3r1767333tMzzzyjZcuWae3atUpISJAk5eTkOP09c09f5Z7O+m+nTp1SSEgIp7CAEoprdgAUi0qVKikgICDfU1EHDx78y/1DQkI0YMAADRgwQJmZmbr//vs1ceJEPfXUUzp37pySkpI0adIkjR8/3r7PzU57/ZXbb79dlSpV0o4dO/Js27Ztmxo3blzotQG4F0d2ABSLUqVKKSYmRitWrNCJEyfs4ykpKVqzZs1N9/3z7ePlypVTzZo17aeYSpUqJUkyDMNh3syZM4tUc69evbRq1Sr9+uuv9rGkpCQdOnRIjz76aJHWBuA+HNkBUGwmTZqkhIQEtWnTRkOGDNG1a9c0e/Zs1a9fP881OP+tXr16atu2rZo1a6aQkBDt2LFDn332mYYOHSpJCgoK0v3336/p06fLZrPp9ttv19q1a3X8+PF813v77beVnp6ukydPSpK+/PJL/fbbb5Kk5557TuXLl5ck/eMf/9DSpUvVrl07DR8+XJmZmfrnP/+pBg0aaMCAAa5sDQBXMgCgGK1fv95o1qyZ4efnZ9x5553GvHnzjAkTJhj//ddT1apVjX79+tlfT5kyxWjRooURHBxsBAQEGHXq1DFeeeUV4+rVq/Y5v/32m9GzZ08jODjYKF++vPHoo48aJ0+eNCQZEyZMcKihatWqhqR8v44fP+4wd9++fUanTp2MMmXKGMHBwUZsbKyRmprqjtYAcBGLYfzpOC8AAICJcM0OAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNR4qqOufk3Py5EkFBgbKYrEUdzkAAKAADMPQhQsXFBERIR+fGx+/IexIOnnypCIjI4u7DAAAUAi//vqr7rjjjhtuJ+xICgwMlHS9WUFBQS5b12azae3aterUqZN8fX1dti4c0WfPodeeQZ89gz57hjv7nJGRocjISPu/4zdC2JHsp66CgoJcHnbKlCmjoKAg/iC5EX32HHrtGfTZM+izZ3iiz391CUqxXqC8YcMGdevWTREREbJYLFqxYsUN5z7zzDOyWCx5PrU4LS1NsbGxCgoKUnBwsAYOHKjMzEz3Fg4AALxGsYadixcvqlGjRpozZ85N5y1fvlxbtmxRREREnm2xsbHav3+/EhMTtWrVKm3YsEGDBw92V8kAAMDLFOtprC5duqhLly43nfOf//xHzz33nNasWaMHH3zQYVtKSooSEhK0fft2NW/eXJI0e/Zsde3aVTNmzMg3HAEAgFtLib5mJycnR3379tULL7yg+vXr59m+efNmBQcH24OOJEVHR8vHx0dbt25Vz5498103KytLWVlZ9tcZGRmSrp9XtNlsLqs/dy1Xrom86LPn0GvPoM+eQZ89w519LuiaJTrsTJs2TaVLl9awYcPy3Z6amqrKlSs7jJUuXVohISFKTU294bpTp07VpEmT8oyvXbtWZcqUKVrR+UhMTHT5msiLPnsOvfYM+uwZ9Nkz3NHnS5cuFWheiQ07O3fu1FtvvaVdu3a5/EF/Y8eOVXx8vP117q1rnTp1cvndWImJierYsSNX+rsRffYceu0Z9Nkz6LNnuLPPuWdm/kqJDTvff/+9zpw5oypVqtjHsrOz9fzzz2vmzJn6+eefFRYWpjNnzjjsd+3aNaWlpSksLOyGa1utVlmt1jzjvr6+bvmBd9e6cESfPYdeewZ99gz67Bnu6HNB1yuxYadv376Kjo52GIuJiVHfvn01YMAASVJUVJTS09O1c+dONWvWTJL07bffKicnRy1btvR4zQAAoOQp1rCTmZmpI0eO2F8fP35cycnJCgkJUZUqVVShQgWH+b6+vgoLC1Pt2rUlSXXr1lXnzp01aNAgzZs3TzabTUOHDlWfPn24EwsAAEgq5ufs7NixQ02aNFGTJk0kSfHx8WrSpInGjx9f4DUWL16sOnXqqEOHDuratatat26t+fPnu6tkAADgZYr1yE7btm1lGEaB5//88895xkJCQrRkyRIXVgUAAMykWI/sAAAAuBthBwAAmBphBwAAmBphBwAAmFqJfc6Omdw9cY2ysl37FGh3+vm1B/96EgAAXoIjOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNSKNexs2LBB3bp1U0REhCwWi1asWGHfZrPZNHr0aDVo0EBly5ZVRESEnnzySZ08edJhjbS0NMXGxiooKEjBwcEaOHCgMjMzPfxOAABASVWsYefixYtq1KiR5syZk2fbpUuXtGvXLo0bN067du3SsmXLdPDgQT388MMO82JjY7V//34lJiZq1apV2rBhgwYPHuyptwAAAEq40sX5zbt06aIuXbrku618+fJKTEx0GHv77bfVokULnThxQlWqVFFKSooSEhK0fft2NW/eXJI0e/Zsde3aVTNmzFBERITb3wMAACjZijXsOOv8+fOyWCwKDg6WJG3evFnBwcH2oCNJ0dHR8vHx0datW9WzZ89818nKylJWVpb9dUZGhqTrp85sNpvL6s1dy+pjuGxNT3BlDzwht15vq9sb0WvPoM+eQZ89w519LuiaXhN2rly5otGjR+vxxx9XUFCQJCk1NVWVK1d2mFe6dGmFhIQoNTX1hmtNnTpVkyZNyjO+du1alSlTxrWFS3q5eY7L13Sn1atXF3cJhfLnI4FwH3rtGfTZM+izZ7ijz5cuXSrQPK8IOzabTb1795ZhGJo7d26R1xs7dqzi4+PtrzMyMhQZGalOnTrZg5Qr2Gw2JSYmatwOH2XlWFy2rrvtmxhT3CU4JbfPHTt2lK+vb3GXY2r02jPos2fQZ89wZ59zz8z8lRIfdnKDzi+//KJvv/3WIYyEhYXpzJkzDvOvXbumtLQ0hYWF3XBNq9Uqq9WaZ9zX19ctP/BZORZlZXtP2PHWP/Tu+v1DXvTaM+izZ9Bnz3BHnwu6Xol+zk5u0Dl8+LC++eYbVahQwWF7VFSU0tPTtXPnTvvYt99+q5ycHLVs2dLT5QIAgBKoWI/sZGZm6siRI/bXx48fV3JyskJCQhQeHq7/+Z//0a5du7Rq1SplZ2fbr8MJCQmRn5+f6tatq86dO2vQoEGaN2+ebDabhg4dqj59+nAnFgAAkFTMYWfHjh1q166d/XXudTT9+vXTxIkTtXLlSklS48aNHfb77rvv1LZtW0nS4sWLNXToUHXo0EE+Pj7q1auXZs2a5ZH6AQBAyVesYadt27YyjBvfln2zbblCQkK0ZMkSV5YFAABMpERfswMAAFBUhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqxRp2NmzYoG7duikiIkIWi0UrVqxw2G4YhsaPH6/w8HAFBAQoOjpahw8fdpiTlpam2NhYBQUFKTg4WAMHDlRmZqYH3wUAACjJijXsXLx4UY0aNdKcOXPy3T59+nTNmjVL8+bN09atW1W2bFnFxMToypUr9jmxsbHav3+/EhMTtWrVKm3YsEGDBw/21FsAAAAlXOni/OZdunRRly5d8t1mGIZmzpypl156Sd27d5ckffTRRwoNDdWKFSvUp08fpaSkKCEhQdu3b1fz5s0lSbNnz1bXrl01Y8YMRUREeOy9AACAkqlYw87NHD9+XKmpqYqOjraPlS9fXi1bttTmzZvVp08fbd68WcHBwfagI0nR0dHy8fHR1q1b1bNnz3zXzsrKUlZWlv11RkaGJMlms8lms7nsPeSuZfUxXLamJ7iyB56QW6+31e2N6LVn0GfPoM+e4c4+F3TNEht2UlNTJUmhoaEO46GhofZtqampqly5ssP20qVLKyQkxD4nP1OnTtWkSZPyjK9du1ZlypQpaul5vNw8x+VrutPq1auLu4RCSUxMLO4Sbhn02jPos2fQZ89wR58vXbpUoHklNuy409ixYxUfH29/nZGRocjISHXq1ElBQUEu+z42m02JiYkat8NHWTkWl63rbvsmxhR3CU7J7XPHjh3l6+tb3OWYGr32DPrsGfTZM9zZ59wzM3+lxIadsLAwSdLp06cVHh5uHz99+rQaN25sn3PmzBmH/a5du6a0tDT7/vmxWq2yWq15xn19fd3yA5+VY1FWtveEHW/9Q++u3z/kRa89gz57Bn32DHf0uaDrldjn7FSvXl1hYWFKSkqyj2VkZGjr1q2KioqSJEVFRSk9PV07d+60z/n222+Vk5Ojli1berxmAABQ8jgddnbt2qW9e/faX3/xxRfq0aOH/vGPf+jq1atOrZWZmank5GQlJydLun5RcnJysk6cOCGLxaIRI0ZoypQpWrlypfbu3asnn3xSERER6tGjhySpbt266ty5swYNGqRt27Zp06ZNGjp0qPr06cOdWAAAQFIhws7TTz+tQ4cOSZKOHTumPn36qEyZMlq6dKlGjRrl1Fo7duxQkyZN1KRJE0lSfHy8mjRpovHjx0uSRo0apeeee06DBw/WPffco8zMTCUkJMjf39++xuLFi1WnTh116NBBXbt2VevWrTV//nxn3xYAADApp6/ZOXTokP2amaVLl+r+++/XkiVLtGnTJvXp00czZ84s8Fpt27aVYdz4tmyLxaLJkydr8uTJN5wTEhKiJUuWFPh7AgCAW4vTR3YMw1BOzvVbqb/55ht17dpVkhQZGamzZ8+6tjoAAIAicjrsNG/eXFOmTNHHH3+s9evX68EHH5R0/XqbPz8TBwAAoLg5HXZmzpypXbt2aejQoXrxxRdVs2ZNSdJnn32m++67z+UFAgAAFIXT1+w0bNjQ4W6sXP/85z9VqlQplxQFAADgKoV6zk56erref/99jR07VmlpaZKkAwcO5HnAHwAAQHFz+sjOnj171KFDBwUHB+vnn3/WoEGDFBISomXLlunEiRP66KOP3FEnAABAoTh9ZCc+Pl4DBgzQ4cOHHZ5307VrV23YsMGlxQEAABSV02Fn+/btevrpp/OM33777Tf9pHEAAIDi4HTYsVqt+X7K6KFDh1SpUiWXFAUAAOAqToedhx9+WJMnT5bNZpN0/SnHJ06c0OjRo9WrVy+XFwgAAFAUToed119/XZmZmapcubIuX76sBx54QDVr1lRgYKBeeeUVd9QIAABQaE7fjVW+fHklJiZq48aN2rNnjzIzM9W0aVNFR0e7oz4AAIAicTrs5GrdurVat27tyloAAABcrkBhZ9asWRo8eLD8/f01a9asm84dNmyYSwoDAABwhQKFnTfffFOxsbHy9/fXm2++ecN5FouFsAMAAEqUAoWd48eP5/trAACAks6pu7FsNptq1KihlJQUd9UDAADgUk6FHV9fX125csVdtQAAALic08/ZiYuL07Rp03Tt2jV31AMAAOBSTt96vn37diUlJWnt2rVq0KCBypYt67B92bJlLisOAACgqJwOO8HBwXwsBAAA8BpOh52FCxe6ow4AAAC3cPqanfbt2ys9PT3PeEZGhtq3b++KmgAAAFzG6bCzbt06Xb16Nc/4lStX9P3337ukKAAAAFcp8GmsPXv22H994MABpaam2l9nZ2crISFBt99+u2urAwAAKKICh53GjRvLYrHIYrHke7oqICBAs2fPdmlxAAAARVXgsHP8+HEZhqE777xT27ZtU6VKlezb/Pz8VLlyZZUqVcotRQIAABRWgcNO1apVJUk5OTluKwYAAMDVnL71XJIOHz6s7777TmfOnMkTfsaPH++SwgAAAFzB6bDz3nvv6dlnn1XFihUVFhYmi8Vi32axWAg7AACgRHE67EyZMkWvvPKKRo8e7Y56AAAAXMrp5+ycO3dOjz76qDtqAQAAcDmnw86jjz6qtWvXuqMWAAAAl3P6NFbNmjU1btw4bdmyRQ0aNJCvr6/D9mHDhrmsOAAAgKJyOuzMnz9f5cqV0/r167V+/XqHbRaLhbADAABKFKfDzvHjx91RBwAAgFs4fc0OAACAN3H6yM7f//73m25fsGBBoYsBAABwNafDzrlz5xxe22w27du3T+np6fl+QCgAAEBxcjrsLF++PM9YTk6Onn32WdWoUcMlRQEAALiKS67Z8fHxUXx8vN58801XLGeXnZ2tcePGqXr16goICFCNGjX08ssvyzAM+xzDMDR+/HiFh4crICBA0dHROnz4sEvrAAAA3stlFygfPXpU165dc9VykqRp06Zp7ty5evvtt5WSkqJp06Zp+vTpmj17tn3O9OnTNWvWLM2bN09bt25V2bJlFRMToytXrri0FgAA4J2cPo0VHx/v8NowDJ06dUpfffWV+vXr57LCJOmHH35Q9+7d9eCDD0qSqlWrpn/961/atm2b/XvPnDlTL730krp37y5J+uijjxQaGqoVK1aoT58+Lq0HAAB4H6eP7Ozevdvha8+ePZKk119/XTNnznRpcffdd5+SkpJ06NAhSdKPP/6ojRs3qkuXLpKuP/MnNTVV0dHR9n3Kly+vli1bavPmzS6tBQAAeCenj+x899137qgjX2PGjFFGRobq1KmjUqVKKTs7W6+88opiY2MlSampqZKk0NBQh/1CQ0Pt2/KTlZWlrKws++uMjAxJ1+8ss9lsLqs/dy2rj/EXM0sWV/bAE3Lr9ba6vRG99gz67Bn02TPc2eeCrul02Mn1+++/6+DBg5Kk2rVrq1KlSoVd6ob+/e9/a/HixVqyZInq16+v5ORkjRgxQhEREUU6ZTZ16lRNmjQpz/jatWtVpkyZopScr5eb57h8TXdavXp1cZdQKImJicVdwi2DXnsGffYM+uwZ7ujzpUuXCjTPYvz3rU0FcPHiRT333HP66KOPlJNz/R/xUqVK6cknn9Ts2bNdGhYiIyM1ZswYxcXF2cemTJmi//3f/9VPP/2kY8eOqUaNGtq9e7caN25sn/PAAw+ocePGeuutt/JdN78jO5GRkTp79qyCgoJcVr/NZlNiYqLG7fBRVo7FZeu6276JMcVdglNy+9yxY8c8H0wL16LXnkGfPYM+e4Y7+5yRkaGKFSvq/PnzN/33u1AXKK9fv15ffvmlWrVqJUnauHGjhg0bpueff15z584tfNV/cunSJfn4OF5WVKpUKXvIql69usLCwpSUlGQPOxkZGdq6daueffbZG65rtVpltVrzjPv6+rrlBz4rx6KsbO8JO976h95dv3/Ii157Bn32DPrsGe7oc0HXczrsfP755/rss8/Utm1b+1jXrl0VEBCg3r17uzTsdOvWTa+88oqqVKmi+vXra/fu3XrjjTfsH1lhsVg0YsQITZkyRXfddZeqV6+ucePGKSIiQj169HBZHQAAwHs5HXYuXbqU54JgSapcuXKBz50V1OzZszVu3DgNGTJEZ86cUUREhJ5++mmNHz/ePmfUqFG6ePGiBg8erPT0dLVu3VoJCQny9/d3aS0AAMA7OR12oqKiNGHCBH300Uf2QHH58mVNmjRJUVFRLi0uMDBQM2fOvOkt7RaLRZMnT9bkyZNd+r0BAIA5OB123nrrLcXExOiOO+5Qo0aNJF1//o2/v7/WrFnj8gIBAACKwumwc/fdd+vw4cNavHixfvrpJ0nS448/rtjYWAUEBLi8QAAAgKIo1HN2ypQpo0GDBrm6FgAAAJdz+uMipk6dqgULFuQZX7BggaZNm+aSogAAAFzF6bDz7rvvqk6dOnnG69evr3nz5rmkKAAAAFdxOuykpqYqPDw8z3ilSpV06tQplxQFAADgKk6HncjISG3atCnP+KZNmxQREeGSogAAAFzF6QuUBw0apBEjRshms6l9+/aSpKSkJI0aNUrPP/+8ywsEAAAoCqfDzgsvvKA//vhDQ4YM0dWrVyVJ/v7+Gj16tMaOHevyAgEAAIrC6bBjsVg0bdo0jRs3TikpKQoICNBdd92V7wdrAgAAFLdCPWdHksqVK6d77rnHlbUAAAC4nNMXKAMAAHgTwg4AADA1wg4AADC1AoWdpk2b6ty5c5KkyZMn69KlS24tCgAAwFUKFHZSUlJ08eJFSdKkSZOUmZnp1qIAAABcpUB3YzVu3FgDBgxQ69atZRiGZsyYoXLlyuU7d/z48S4tEAAAoCgKFHYWLVqkCRMmaNWqVbJYLPr6669VunTeXS0WC2EHAACUKAUKO7Vr19Ynn3wiSfLx8VFSUpIqV67s1sIAAABcwemHCubk5LijDgAAALco1BOUjx49qpkzZyolJUWSVK9ePQ0fPlw1atRwaXEAAABF5fRzdtasWaN69epp27ZtatiwoRo2bKitW7eqfv36SkxMdEeNAAAAheb0kZ0xY8Zo5MiReu211/KMjx49Wh07dnRZcQAAAEXl9JGdlJQUDRw4MM/43//+dx04cMAlRQEAALiK02GnUqVKSk5OzjOenJzMHVoAAKDEcfo01qBBgzR48GAdO3ZM9913nyRp06ZNmjZtmuLj411eIAAAQFE4HXbGjRunwMBAvf766xo7dqwkKSIiQhMnTtSwYcNcXiAAAEBROB12LBaLRo4cqZEjR+rChQuSpMDAQJcXBgAA4AqFes5OLkIOAAAo6Zy+QBkAAMCbEHYAAICpEXYAAICpORV2bDabOnTooMOHD7urHgAAAJdyKuz4+vpqz5497qoFAADA5Zw+jfW3v/1NH3zwgTtqAQAAcDmnbz2/du2aFixYoG+++UbNmjVT2bJlHba/8cYbLisOAACgqJwOO/v27VPTpk0lSYcOHXLYZrFYXFMVAACAizgddr777jt31AEAAOAWhb71/MiRI1qzZo0uX74sSTIMw2VFAQAAuIrTYeePP/5Qhw4dVKtWLXXt2lWnTp2SJA0cOFDPP/+8ywsEAAAoCqfDzsiRI+Xr66sTJ06oTJky9vHHHntMCQkJLi0OAACgqJwOO2vXrtW0adN0xx13OIzfdddd+uWXX1xWWK7//Oc/+tvf/qYKFSooICBADRo00I4dO+zbDcPQ+PHjFR4eroCAAEVHR/PQQwAAYOd02Ll48aLDEZ1caWlpslqtLikq17lz59SqVSv5+vrq66+/1oEDB/T666/rtttus8+ZPn26Zs2apXnz5mnr1q0qW7asYmJidOXKFZfWAgAAvJPTYadNmzb66KOP7K8tFotycnI0ffp0tWvXzqXFTZs2TZGRkVq4cKFatGih6tWrq1OnTqpRo4ak60d1Zs6cqZdeekndu3dXw4YN9dFHH+nkyZNasWKFS2sBAADeyelbz6dPn64OHTpox44dunr1qkaNGqX9+/crLS1NmzZtcmlxK1euVExMjB599FGtX79et99+u4YMGaJBgwZJko4fP67U1FRFR0fb9ylfvrxatmypzZs3q0+fPvmum5WVpaysLPvrjIwMSdc/+8tms7ms/ty1rD7edaeaK3vgCbn1elvd3oheewZ99gz67Bnu7HNB17QYhbhn/Pz583r77bf1448/KjMzU02bNlVcXJzCw8OdLvRm/P39JUnx8fF69NFHtX37dg0fPlzz5s1Tv3799MMPP6hVq1Y6efKkw/fu3bu3LBaLPv3003zXnThxoiZNmpRnfMmSJfmeogMAACXPpUuX9MQTT+j8+fMKCgq64bxChR1P8fPzU/PmzfXDDz/Yx4YNG6bt27dr8+bNhQ47+R3ZiYyM1NmzZ2/aLGfZbDYlJiZq3A4fZeV4z9Ol902MKe4SnJLb544dO8rX17e4yzE1eu0Z9Nkz6LNnuLPPGRkZqlix4l+GHadPY0nXLxz+4IMPlJKSIkmqV6+eBgwYoJCQkMJVewPh4eGqV6+ew1jdunX1+eefS5LCwsIkSadPn3YIO6dPn1bjxo1vuK7Vas33YmpfX1+3/MBn5ViUle09Ycdb/9C76/cPedFrz6DPnkGfPcMdfS7oek5foLxhwwZVq1ZNs2bN0rlz53Tu3DnNmjVL1atX14YNG5wu9GZatWqlgwcPOowdOnRIVatWlSRVr15dYWFhSkpKsm/PyMjQ1q1bFRUV5dJaAACAd3L6yE5cXJwee+wxzZ07V6VKlZIkZWdna8iQIYqLi9PevXtdVtzIkSN133336dVXX1Xv3r21bds2zZ8/X/Pnz5d0/U6wESNGaMqUKbrrrrtUvXp1jRs3ThEREerRo4fL6gAAAN7L6bBz5MgRffbZZ/agI0mlSpVSfHy8wy3prnDPPfdo+fLlGjt2rCZPnqzq1atr5syZio2Ntc8ZNWqULl68qMGDBys9PV2tW7dWQkKC/eJmAABwa3M67DRt2lQpKSmqXbu2w3hKSooaNWrkssJyPfTQQ3rooYduuN1isWjy5MmaPHmyy783AADwfgUKO3v27LH/etiwYRo+fLiOHDmie++9V5K0ZcsWzZkzR6+99pp7qgQAACikAoWdxo0by2Kx6L/vUh81alSeeU888YQee+wx11UHAABQRAUKO8ePH3d3HQAAAG5RoLCTe6s3AACAtynUQwVPnjypjRs36syZM8rJyXHYNmzYMJcUBgAA4ApOh51Fixbp6aeflp+fnypUqCCL5f+eDGyxWAg7AACgRHE67IwbN07jx4/X2LFj5ePj9AOYAQAAPMrptHLp0iX16dOHoAMAALyC04ll4MCBWrp0qTtqAQAAcDmnT2NNnTpVDz30kBISEtSgQYM8nzj6xhtvuKw4AACAoipU2FmzZo394yL+fIEyAABASeJ02Hn99de1YMEC9e/f3w3lAAAAuJbT1+xYrVa1atXKHbUAAAC4nNNhZ/jw4Zo9e7Y7agEAAHA5p09jbdu2Td9++61WrVql+vXr57lAedmyZS4rDgAAoKicDjvBwcF65JFH3FELAACAyzkddhYuXOiOOgAAANyCxyADAABTc/rITvXq1W/6PJ1jx44VqSAAAABXcjrsjBgxwuG1zWbT7t27lZCQoBdeeMFVdQEAALiE02Fn+PDh+Y7PmTNHO3bsKHJBAAAAruSya3a6dOmizz//3FXLAQAAuITLws5nn32mkJAQVy0HAADgEk6fxmrSpInDBcqGYSg1NVW///673nnnHZcWBwAAUFROh50ePXo4vPbx8VGlSpXUtm1b1alTx1V1AQAAuITTYWfChAnuqAMAAMAteKggAAAwtQIf2fHx8bnpwwQlyWKx6Nq1a0UuCgAAwFUKHHaWL19+w22bN2/WrFmzlJOT45KiAAAAXKXAYad79+55xg4ePKgxY8boyy+/VGxsrCZPnuzS4gAAAIqqUNfsnDx5UoMGDVKDBg107do1JScn68MPP1TVqlVdXR8AAECROBV2zp8/r9GjR6tmzZrav3+/kpKS9OWXX+ruu+92V30AAABFUuDTWNOnT9e0adMUFhamf/3rX/me1gIAAChpChx2xowZo4CAANWsWVMffvihPvzww3znLVu2zGXFAQAAFFWBw86TTz75l7eeAwAAlDQFDjuLFi1yYxkAAADuwROUAQCAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqXlV2HnttddksVg0YsQI+9iVK1cUFxenChUqqFy5curVq5dOnz5dfEUCAIASxWvCzvbt2/Xuu++qYcOGDuMjR47Ul19+qaVLl2r9+vU6efKkHnnkkWKqEgAAlDReEXYyMzMVGxur9957T7fddpt9/Pz58/rggw/0xhtvqH379mrWrJkWLlyoH374QVu2bCnGigEAQElR4IcKFqe4uDg9+OCDio6O1pQpU+zjO3fulM1mU3R0tH2sTp06qlKlijZv3qx777033/WysrKUlZVlf52RkSFJstlsstlsLqs7dy2rj+GyNT3BlT3whNx6va1ub0SvPYM+ewZ99gx39rmga5b4sPPJJ59o165d2r59e55tqamp8vPzU3BwsMN4aGioUlNTb7jm1KlTNWnSpDzja9euVZkyZYpc85+93DzH5Wu60+rVq4u7hEJJTEws7hJuGfTaM+izZ9Bnz3BHny9dulSgeSU67Pz6668aPny4EhMT5e/v77J1x44dq/j4ePvrjIwMRUZGqlOnTgoKCnLZ97HZbEpMTNS4HT7KyvGezxXbNzGmuEtwSm6fO3bsKF9f3+Iux9TotWfQZ8+gz57hzj7nnpn5KyU67OzcuVNnzpxR06ZN7WPZ2dnasGGD3n77ba1Zs0ZXr15Venq6w9Gd06dPKyws7IbrWq1WWa3WPOO+vr5u+YHPyrEoK9t7wo63/qF31+8f8qLXnkGfPYM+e4Y7+lzQ9Up02OnQoYP27t3rMDZgwADVqVNHo0ePVmRkpHx9fZWUlKRevXpJkg4ePKgTJ04oKiqqOEoGAAAlTIkOO4GBgbr77rsdxsqWLasKFSrYxwcOHKj4+HiFhIQoKChIzz33nKKiom54cTIAALi1lOiwUxBvvvmmfHx81KtXL2VlZSkmJkbvvPNOcZcFAABKCK8LO+vWrXN47e/vrzlz5mjOnDnFUxAAACjRvOKhggAAAIVF2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZWosPO1KlTdc899ygwMFCVK1dWjx49dPDgQYc5V65cUVxcnCpUqKBy5cqpV69eOn36dDFVDAAASpoSHXbWr1+vuLg4bdmyRYmJibLZbOrUqZMuXrxonzNy5Eh9+eWXWrp0qdavX6+TJ0/qkUceKcaqAQBASVK6uAu4mYSEBIfXixYtUuXKlbVz507df//9On/+vD744AMtWbJE7du3lyQtXLhQdevW1ZYtW3TvvfcWR9kAAKAEKdFh58/Onz8vSQoJCZEk7dy5UzabTdHR0fY5derUUZUqVbR58+Ybhp2srCxlZWXZX2dkZEiSbDabbDaby+rNXcvqY7hsTU9wZQ88Ibdeb6vbG9Frz6DPnkGfPcOdfS7omhbDMLziX+KcnBw9/PDDSk9P18aNGyVJS5Ys0YABAxyCiyS1aNFC7dq107Rp0/Jda+LEiZo0aVKe8SVLlqhMmTKuLx4AALjcpUuX9MQTT+j8+fMKCgq64TyvObITFxenffv22YNOUYwdO1bx8fH21xkZGYqMjFSnTp1u2ixn2Ww2JSYmatwOH2XlWFy2rrvtmxhT3CU4JbfPHTt2lK+vb3GXY2r02jPos2fQZ89wZ59zz8z8Fa8IO0OHDtWqVau0YcMG3XHHHfbxsLAwXb16Venp6QoODraPnz59WmFhYTdcz2q1ymq15hn39fV1yw98Vo5FWdneE3a89Q+9u37/kBe99gz67Bn02TPc0eeCrlei78YyDENDhw7V8uXL9e2336p69eoO25s1ayZfX18lJSXZxw4ePKgTJ04oKirK0+UCAIASqEQf2YmLi9OSJUv0xRdfKDAwUKmpqZKk8uXLKyAgQOXLl9fAgQMVHx+vkJAQBQUF6bnnnlNUVBR3YgEAAEklPOzMnTtXktS2bVuH8YULF6p///6SpDfffFM+Pj7q1auXsrKyFBMTo3feecfDlQIAgJKqRIedgtwo5u/vrzlz5mjOnDkeqAgAAHibEn3NDgAAQFERdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKmVLu4CAABAwVUb81Vxl+AUaylD01sUbw0c2QEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZWurgLQMlTbcxXxV2CU6ylDE1vUdxVAABKKo7sAAAAUyPsAAAAUyPsAAAAUyPsAAAAU+MCZaCYeNuF4JL3Xgzubb321j4DJRVHdgAAgKkRdgAAgKmZ5jTWnDlz9M9//lOpqalq1KiRZs+erRYtOA4MALi5uyeuUVa2pbjLgBuZ4sjOp59+qvj4eE2YMEG7du1So0aNFBMTozNnzhR3aQAAoJiZ4sjOG2+8oUGDBmnAgAGSpHnz5umrr77SggULNGbMmGKuDp7C/85gNvxMuxcXgt86vP7IztWrV7Vz505FR0fbx3x8fBQdHa3NmzcXY2UAAKAk8PojO2fPnlV2drZCQ0MdxkNDQ/XTTz/lu09WVpaysrLsr8+fPy9JSktLk81mc1ltNptNly5dUmmbj7Jz+N+Zu5TOMXTpUg599oDcXv/xxx/y9fUt7nIKrPS1i8VdglP4mfYM+uwZ7vx748KFC5IkwzBuXoNLv6uXmDp1qiZNmpRnvHr16sVQDVzhieIu4BZCrz2DPnsGffYMd/f5woULKl++/A23e33YqVixokqVKqXTp087jJ8+fVphYWH57jN27FjFx8fbX+fk5CgtLU0VKlSQxeK6dJ+RkaHIyEj9+uuvCgoKctm6cESfPYdeewZ99gz67Bnu7LNhGLpw4YIiIiJuOs/rw46fn5+aNWumpKQk9ejRQ9L18JKUlKShQ4fmu4/VapXVanUYCw4OdluNQUFB/EHyAPrsOfTaM+izZ9Bnz3BXn292RCeX14cdSYqPj1e/fv3UvHlztWjRQjNnztTFixftd2cBAIBblynCzmOPPabff/9d48ePV2pqqho3bqyEhIQ8Fy0DAIBbjynCjiQNHTr0hqetiovVatWECRPynDKDa9Fnz6HXnkGfPYM+e0ZJ6LPF+Kv7tQAAALyY1z9UEAAA4GYIOwAAwNQIOwAAwNQIOwAAwNQIO0U0Z84cVatWTf7+/mrZsqW2bdt20/lLly5VnTp15O/vrwYNGmj16tUeqtS7OdPn9957T23atNFtt92m2267TdHR0X/5+4LrnP15zvXJJ5/IYrHYH+yJv+Zsr9PT0xUXF6fw8HBZrVbVqlWLvz8KwNk+z5w5U7Vr11ZAQIAiIyM1cuRIXblyxUPVeqcNGzaoW7duioiIkMVi0YoVK/5yn3Xr1qlp06ayWq2qWbOmFi1a5N4iDRTaJ598Yvj5+RkLFiww9u/fbwwaNMgIDg42Tp8+ne/8TZs2GaVKlTKmT59uHDhwwHjppZcMX19fY+/evR6u3Ls42+cnnnjCmDNnjrF7924jJSXF6N+/v1G+fHnjt99+83Dl3sXZPuc6fvy4cfvttxtt2rQxunfv7plivZyzvc7KyjKaN29udO3a1di4caNx/PhxY926dUZycrKHK/cuzvZ58eLFhtVqNRYvXmwcP37cWLNmjREeHm6MHDnSw5V7l9WrVxsvvviisWzZMkOSsXz58pvOP3bsmFGmTBkjPj7eOHDggDF79myjVKlSRkJCgttqJOwUQYsWLYy4uDj76+zsbCMiIsKYOnVqvvN79+5tPPjggw5jLVu2NJ5++mm31untnO3zn127ds0IDAw0PvzwQ3eVaAqF6fO1a9eM++67z3j//feNfv36EXYKyNlez50717jzzjuNq1eveqpEU3C2z3FxcUb79u0dxuLj441WrVq5tU4zKUjYGTVqlFG/fn2Hsccee8yIiYlxW12cxiqkq1evaufOnYqOjraP+fj4KDo6Wps3b853n82bNzvMl6SYmJgbzkfh+vxnly5dks1mU0hIiLvK9HqF7fPkyZNVuXJlDRw40BNlmkJher1y5UpFRUUpLi5OoaGhuvvuu/Xqq68qOzvbU2V7ncL0+b777tPOnTvtp7qOHTum1atXq2vXrh6p+VZRHP8WmuYJyp529uxZZWdn5/lIitDQUP3000/57pOamprv/NTUVLfV6e0K0+c/Gz16tCIiIvL84cL/KUyfN27cqA8++EDJyckeqNA8CtPrY8eO6dtvv1VsbKxWr16tI0eOaMiQIbLZbJowYYInyvY6henzE088obNnz6p169YyDEPXrl3TM888o3/84x+eKPmWcaN/CzMyMnT58mUFBAS4/HtyZAem9tprr+mTTz7R8uXL5e/vX9zlmMaFCxfUt29fvffee6pYsWJxl2N6OTk5qly5subPn69mzZrpscce04svvqh58+YVd2mmsm7dOr366qt65513tGvXLi1btkxfffWVXn755eIuDUXEkZ1CqlixokqVKqXTp087jJ8+fVphYWH57hMWFubUfBSuz7lmzJih1157Td98840aNmzozjK9nrN9Pnr0qH7++Wd169bNPpaTkyNJKl26tA4ePKgaNWq4t2gvVZif6fDwcPn6+qpUqVL2sbp16yo1NVVXr16Vn5+fW2v2RoXp87hx49S3b1899dRTkqQGDRro4sWLGjx4sF588UX5+HB8wBVu9G9hUFCQW47qSBzZKTQ/Pz81a9ZMSUlJ9rGcnBwlJSUpKioq332ioqIc5ktSYmLiDeejcH2WpOnTp+vll19WQkKCmjdv7olSvZqzfa5Tp4727t2r5ORk+9fDDz+sdu3aKTk5WZGRkZ4s36sU5me6VatWOnLkiD1QStKhQ4cUHh5O0LmBwvT50qVLeQJNbsA0+BhJlymWfwvddunzLeCTTz4xrFarsWjRIuPAgQPG4MGDjeDgYCM1NdUwDMPo27evMWbMGPv8TZs2GaVLlzZmzJhhpKSkGBMmTODW8wJwts+vvfaa4efnZ3z22WfGqVOn7F8XLlworrfgFZzt859xN1bBOdvrEydOGIGBgcbQoUONgwcPGqtWrTIqV65sTJkypbjegldwts8TJkwwAgMDjX/961/GsWPHjLVr1xo1atQwevfuXVxvwStcuHDB2L17t7F7925DkvHGG28Yu3fvNn755RfDMAxjzJgxRt++fe3zc289f+GFF4yUlBRjzpw53Hpe0s2ePduoUqWK4efnZ7Ro0cLYsmWLfdsDDzxg9OvXz2H+v//9b6NWrVqGn5+fUb9+feOrr77ycMXeyZk+V61a1ZCU52vChAmeL9zLOPvz/N8IO85xttc//PCD0bJlS8NqtRp33nmn8corrxjXrl3zcNXex5k+22w2Y+LEiUaNGjUMf39/IzIy0hgyZIhx7tw5zxfuRb777rt8/87N7W2/fv2MBx54IM8+jRs3Nvz8/Iw777zTWLhwoVtrtBgGx+YAAIB5cc0OAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOANObOHGiQkNDZbFYtGLFigLts27dOlksFqWnp0uSFi1apODgYLfVCMB9CDvALap///6yWCx5vjp37lzgNdq2basRI0a4pT5ngsnNpKSkaNKkSXr33Xd16tQpdenSpVDrPPbYYzp06FCR6wHgeXzqOXAL69y5sxYuXOgwZrVai6ka9zh69KgkqXv37rJYLIVeJyAgwG2fyAzAvTiyA9zCrFarwsLCHL5uu+02SddP4/j5+en777+3z58+fboqV66s06dPq3///lq/fr3eeust+1Ghn3/+WZK0b98+denSReXKlVNoaKj69u2rs2fP2tdp27athg0bplGjRikkJERhYWGaOHGifXu1atUkST179pTFYrG/zs/evXvVvn17BQQEqEKFCho8eLAyMzMlXT991a1bN0mSj4/PTcPO6tWrVatWLQUEBKhdu3b295Lrz6exfvzxR7Vr106BgYEKCgpSs2bNtGPHDvv2jRs3qk2bNgoICFBkZKSGDRumixcv2rd//PHHat68uQIDAxUWFqYnnnhCZ86csW8/d+6cYmNjValSJQUEBOiuu+5yCKa//vqrevfureDgYIWEhKh79+55agZwHWEHQL5yT1H17dtX58+f1+7duzVu3Di9//77Cg0N1VtvvaWoqCgNGjRIp06d0qlTpxQZGan09HS1b99eTZo00Y4dO5SQkKDTp0+rd+/eDut/+OGHKlu2rLZu3arp06dr8uTJSkxMlCRt375dkrRw4UKdOnXK/vrPLl68qJiYGN12223avn27li5dqm+++UZDhw6VJP2///f/7AEht8b8/Prrr3rkkUfUrVs3JScn66mnntKYMWNu2p/Y2Fjdcccd2r59u3bu3KkxY8bI19dX0vWjSZ07d1avXr20Z88effrpp9q4caO9Lkmy2Wx6+eWX9eOPP2rFihX6+eef1b9/f/v2cePG6cCBA/r666+VkpKiuXPnqmLFivZ9Y2JiFBgYqO+//16bNm1SuXLl1LlzZ129evWmdQO3JLd+zCiAEqtfv35GqVKljLJlyzp8vfLKK/Y5WVlZRuPGjY3evXsb9erVMwYNGuSwxgMPPGAMHz7cYezll182OnXq5DD266+/GpKMgwcP2vdr3bq1w5x77rnHGD16tP21JGP58uU3fQ/z5883brvtNiMzM9M+9tVXXxk+Pj5GamqqYRiGsXz5cuOv/qobO3asUa9ePYex0aNHG5Lsn3i9cOFCo3z58vbtgYGBxqJFi/Jdb+DAgcbgwYMdxr7//nvDx8fHuHz5cr77bN++3ZBkXLhwwTAMw+jWrZsxYMCAfOd+/PHHRu3atY2cnBz7WFZWlhEQEGCsWbPmpu8VuBVxzQ5wC2vXrp3mzp3rMBYSEmL/tZ+fnxYvXqyGDRuqatWqevPNN/9yzR9//FHfffedypUrl2fb0aNHVatWLUlSw4YNHbaFh4c7nMYpiJSUFDVq1Ehly5a1j7Vq1Uo5OTk6ePCgQkNDC7xOy5YtHcaioqJuuk98fLyeeuopffzxx4qOjtajjz6qGjVqSLregz179mjx4sX2+YZhKCcnR8ePH1fdunW1c+dOTZw4UT/++KPOnTunnJwcSdKJEydUr149Pfvss+rVq5d27dqlTp06qUePHrrvvvvs6x85ckSBgYEONV25csV+jRKA/0PYAW5hZcuWVc2aNW8654cffpAkpaWlKS0tzSFY5CczM1PdunXTtGnT8mwLDw+3/zr3lE8ui8Vi/wffG0ycOFFPPPGEvvrqK3399deaMGGCPvnkE/Xs2VOZmZl6+umnNWzYsDz7ValSxX76LSYmRosXL1alSpV04sQJxcTE2E9DdenSRb/88otWr16txMREdejQQXFxcZoxY4YyMzPVrFkzhzCVq1KlSm5/74C3IewAuKGjR49q5MiReu+99/Tpp5+qX79++uabb+Tjc/1yPz8/P2VnZzvs07RpU33++eeqVq2aSpcu/F8xvr6+edb+s7p162rRokW6ePGiPYRt2rRJPj4+ql27doG/V926dbVy5UqHsS1btvzlfrVq1VKtWrU0cuRIPf7441q4cKF69uyppk2b6sCBAzcMknv37tUff/yh1157TZGRkZLkcHFzrkqVKqlfv37q16+f2rRpoxdeeEEzZsxQ06ZN9emnn6py5coKCgoq8PsEblVcoAzcwrKyspSamurwlXvXVHZ2tv72t78pJiZGAwYM0MKFC7Vnzx69/vrr9v2rVaumrVu36ueff9bZs2eVk5OjuLg4paWl6fHHH9f27dt19OhRrVmzRgMGDPjL8PLfqlWrpqSkJKWmpurcuXP5zomNjZW/v7/69eunffv26bvvvtNzzz2nvn37FvgUliQ988wzOnz4sF544QUdPHhQS5Ys0aJFi244//Llyxo6dKjWrVunX375RZs2bdL27dtVt25dSdLo0aP1ww8/aOjQoUpOTtbhw4f1xRdf2C9QrlKlivz8/DR79mwdO3ZMK1eu1Msvv+zwPcaPH68vvvhCR44c0f79+7Vq1Sr7+rGxsapYsaK6d++u77//XsePH9e6des0bNgw/fbbbwV+38Ato7gvGgJQPPr162dIyvNVu3ZtwzAMY9KkSUZ4eLhx9uxZ+z6ff/654efnZyQnJxuGYRgHDx407r33XiMgIMCQZBw/ftwwDMM4dOiQ0bNnTyM4ONgICAgw6tSpY4wYMcJ+QW1+FzZ3797d6Nevn/31ypUrjZo1axqlS5c2qlatesP3sWfPHqNdu3aGv7+/ERISYgwaNMh+ka9hFOwCZcMwjC+//NKoWbOmYbVajTZt2hgLFiy44QXKWVlZRp8+fYzIyEjDz8/PiIiIMIYOHepw8fG2bduMjh07GuXKlTPKli1rNGzY0OHi7yVLlhjVqlUzrFarERUVZaxcudKQZOzevdswjOsXetetW9cICAgwQkJCjO7duxvHjh2z73/q1CnjySefNCpWrGhYrVbjzjvvNAYNGmScP3/+L98rcKuxGIZhFFvSAgAAcDNOYwEAAFMj7AAAAFMj7AAAAFMj7AAAAFMj7AAAAFMj7AAAAFMj7AAAAFMj7AAAAFMj7AAAAFMj7AAAAFMj7AAAAFMj7AAAAFP7/xSbNiW+iEi/AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import pandas\n",
    "import pandas as pd\n",
    "\n",
    "# Load Stata file into a pandas DataFrame: df\n",
    "df = pd.read_stata(statadata)\n",
    "\n",
    "# Print the head of the DataFrame df\n",
    "print(df.head())\n",
    "\n",
    "# Plot histogram of one column of the DataFrame\n",
    "pd.DataFrame.hist(df[['disa10']])\n",
    "plt.xlabel('Extent of disease')\n",
    "plt.ylabel('Number of countries')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Importing HDF5 files**\n",
    "\n",
    "1. HDF5 files\n",
    "Hierarchical Data Format version 5\n",
    "Standard for storing large quantities of numerical data\n",
    "Datasets can be hundreds of gigabytes or terabytes\n",
    "HDF5 can scale to exabytes\n",
    "\n",
    "2. Importing HDF5 files\n",
    "import h5py\n",
    "filename = 'H-H1_LOSC_4_V1-815411200-4096.hdf5'\n",
    "data = h5py.File(filename, 'r') # 'r' is to read\n",
    "print(type(data))\n",
    "<class 'h5py._hl.files.File'>\n",
    "\n",
    "3. The structure of HDF5 files\n",
    "for key in data.keys():\n",
    "    print(key)\n",
    "\n",
    "`meta`\n",
    "`quality`\n",
    "`strain`\n",
    "\n",
    "print(type(data['meta']))\n",
    "<class 'h5py._hl.group.Group'>\n",
    "\n",
    "4. The structure of HDF5 files\n",
    "for key in data['meta'].keys():\n",
    "    print(key)\n",
    "\n",
    "`Description`\n",
    "`DescriptionURL`\n",
    "`Detector`\n",
    "`Duration`\n",
    "`GPSstart`\n",
    "`Observatory`\n",
    "`Type`\n",
    "`UTCstart`\n",
    "\n",
    "print(np.array(data['meta']['Description']), np.array(data['meta']['Detector']))\n",
    "\n",
    "`b'Strain data time series from LIGO' b'H1'`\n",
    "\n",
    "5. The HDF Project\n",
    "Actively maintained by the HDF Group\n",
    "Based in Champaign, Illinois"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using File to import HDF5 files**\n",
    "\n",
    "The `h5py` package has been imported in the environment and the file `LIGO_data.hdf5` is loaded in the object `h5py_file`.\n",
    "\n",
    "What is the correct way of using the h5py function, `File()`, to import the file in `h5py_file` into an object, `h5py_data`, for reading only?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'h5py._hl.files.File'>\n"
     ]
    }
   ],
   "source": [
    "import h5py\n",
    "filename = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\L-L1_LOSC_4_V1-1126259446-32.hdf5'\n",
    "h5py_data = h5py.File(filename, 'r') # 'r' is to read\n",
    "print(type(h5py_data))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using h5py to import HDF5 files**\n",
    "\n",
    "The file `'LIGO_data.hdf5'` is already in your working directory. In this exercise, you'll import it using the `h5py` library. You'll also print out its datatype to confirm you have imported it correctly. You'll then study the structure of the file in order to see precisely what HDF groups it contains.\n",
    "\n",
    "You can find the LIGO data plus loads of documentation and tutorials here. There is also a great tutorial on Signal Processing with the data here.\n",
    "\n",
    "STEPS\n",
    "    Import the package h5py.\n",
    "    Assign the name of the file to the variable file.\n",
    "    Load the file as read only into the variable data.\n",
    "    Print the datatype of data.\n",
    "    Print the names of the groups in the HDF5 file 'LIGO_data.hdf5'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'h5py._hl.files.File'>\n",
      "meta\n",
      "quality\n",
      "strain\n"
     ]
    }
   ],
   "source": [
    "# Import packages\n",
    "import numpy as np\n",
    "import h5py\n",
    "\n",
    "# Assign filename: file\n",
    "file = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\L-L1_LOSC_4_V1-1126259446-32.hdf5'\n",
    "\n",
    "# Load file: data\n",
    "data = h5py.File(file, 'r')\n",
    "\n",
    "# Print the datatype of the loaded file\n",
    "print(type(data))\n",
    "\n",
    "# Print the keys of the file\n",
    "for key in data.keys():\n",
    "    print(key)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Extracting data from your HDF5 file**\n",
    "\n",
    "In this exercise, you'll extract some of the LIGO experiment's actual data from the HDF5 file and you'll visualize it.\n",
    "\n",
    "To do so, you'll need to first explore the HDF5 group '`strain`'.\n",
    "\n",
    "STEPS\n",
    "    Assign the HDF5 group data['strain'] to group.\n",
    "    In the for loop, print out the keys of the HDF5 group in group.\n",
    "    Assign the time series data data['strain']['Strain'] to a NumPy array called strain.\n",
    "    Set num_samples equal to 10000, the number of time points we wish to sample.\n",
    "    Execute the rest of the code to produce a plot of the time series data in LIGO_data.hdf5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strain\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkMAAAHACAYAAACh9WxwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAACYGUlEQVR4nO2dd3gU1frH3/QCKRACIRAISYTQDVUiLYqAIioqem1XvF6wYAMLYMMCgooVvbbrBf3pFa8FREGkgwiIIKEmgRBCIBBKAimE9Pn9gbt7Znb6nDNl9/08Dw/Z3SlnZ2fOec973vf7BnAcxwGCIAiCIIifEmh1AxAEQRAEQawEjSEEQRAEQfwaNIYQBEEQBPFr0BhCEARBEMSvQWMIQRAEQRC/Bo0hBEEQBEH8GjSGEARBEATxa9AYQhAEQRDEr0FjCEEQBEEQvwaNIQRBEARB/Bo0hjSwceNGGDt2LCQmJkJAQAAsWbLE8vNVVVXBQw89BO3bt4eIiAjo1q0bfPjhh0zbhSAIgiC+BBpDGjh//jz07t0b3n//fducb+rUqbBixQr44osvICcnBx577DF46KGHYOnSpaa0EUEQBEGcDhpDGrj66qth1qxZMG7cONHPa2tr4YknnoB27dpBs2bNYODAgbB+/Xpm5wMA2Lx5M9x9990wfPhwSE5OhkmTJkHv3r1h27Ztus+LIAiCIP4EGkMUeeihh2DLli2waNEi2L17N4wfPx5Gjx4NBw8eZHbOzMxMWLp0KRQXFwPHcbBu3To4cOAAjBw5ktk5EQRBEMSXCLa6Ab5CUVERLFiwAIqKiiAxMREAAJ544glYsWIFLFiwAF555RUm550/fz5MmjQJ2rdvD8HBwRAYGAiffPIJDB06lMn5EARBEMTXQGOIEnv27IHGxkbo3Lkz7/3a2lqIi4sDAIDc3Fzo2rWr7HGmTZsGc+fOVX3e+fPnw9atW2Hp0qXQsWNH2LhxI0yePBkSExNhxIgR2r8IgiAIgvgZaAxRoqqqCoKCgmDHjh0QFBTE+6x58+YAAJCSkgI5OTmyx3EZTmq4cOECPP3007B48WIYM2YMAAD06tULsrOzYd68eWgMIQiCIIgK0BiiREZGBjQ2NsKpU6dgyJAhotuEhoZCeno6tXPW19dDfX09BAbyQ7+CgoKgqamJ2nkQBEEQxJdBY0gDVVVVkJ+f7359+PBhyM7OhpYtW0Lnzp3hjjvugL///e/wxhtvQEZGBpw+fRrWrFkDvXr1cntuaJ2vQ4cOEB0dDcOGDYMnn3wSIiIioGPHjrBhwwb4/PPP4c0336TynREEQRDE1wngOI6zuhFOYf369ZCVleX1/t133w0LFy6E+vp6mDVrFnz++edQXFwMrVq1gssuuwxefPFF6NmzJ/XzAQCUlJTAjBkzYOXKlVBWVgYdO3aESZMmwZQpUyAgIEDzOREEQRDE30BjCEEQBEEQvwZ1hhAEQRAE8WvQGEIQBEEQxK/BAGoFmpqa4Pjx4xAVFYUxOAiCIAjiEDiOg8rKSkhMTPTKuhaCxpACx48fh6SkJKubgSAIgiCIDo4ePQrt27eX3QaNIQWioqIA4OLFjI6Otrg1CIIgCIKooaKiApKSktzjuBxoDCngWhqLjo5GYwhBEARBHIaaEBcMoEYQBEEQxK9xjDE0e/ZsyMzMhMjISIiNjVXcvr6+HqZNmwY9e/aEZs2aQWJiIvz973+H48ePs28sgiAIgiCOwTHGUF1dHYwfPx4eeOABVdtXV1fDn3/+Cc899xz8+eef8P3330NeXh5cd911jFuKIAiCIIiTcJwC9cKFC+Gxxx6Dc+fOad73jz/+gAEDBsCRI0egQ4cOqvapqKiAmJgYKC8vx5ghBEEQBHEIWsZvx3iGaFBeXg4BAQGqltkQBEEQBPEP/CabrKamBqZNmwa33XabrIVYW1sLtbW17tcVFRVmNA9BEARBEIuw1DM0ffp0CAgIkP2Xm5tr+Dz19fVwyy23AMdx8MEHH8huO2fOHIiJiXH/Q8FFBEEQBPFtLI0ZOn36NJSWlspuk5KSAqGhoe7XWmOGXIZQQUEBrF27FuLi4mS3F/MMJSUlYcwQgiAIgjgILTFDli6TxcfHQ3x8PLPjuwyhgwcPwrp16xQNIQCAsLAwCAsLY9YmBEEQBEHshWMCqIuKiiA7OxuKioqgsbERsrOzITs7G6qqqtzbpKenw+LFiwHgoiF08803w/bt2+HLL7+ExsZGKCkpgZKSEqirq7PqayAIgiAIYjMcE0D9/PPPw2effeZ+nZGRAQAA69atg+HDhwMAQF5eHpSXlwMAQHFxMSxduhQAAC699FLesch9EARBEATxbxynM2Q2qDOEIAiCIM4DdYYQBEEQxEepbWiExib0Y9AEjSEEQRAEcQg19Y3Q56VVcNVbG6xuik+BxhCCIAiCOIRth8vgfF0jFJw+D0Wl1VY3x2dAYwhBEARBHML073a7/57zc46FLfEt0BhCEARBEIdwvLzG/feZqlqZLREtoDGEIAiCIA7kj8KzVjfBZ0BjCEEczvnaBqubgCAI4mjQGEIQBzPm3V+h+8xf4IWl+6xuCoIgiGNBYwhBHArHcbDveAUAACzcXGhtYxAEYc7uY+esboLPgsYQgjiUX/aVWN0EBEFMJLek0uu9kxU1IlsiWkFjCEEcyv9tPcJ7XVPfaFFLEAQxgwCR9+obm0xvhy+CxhCCOJTSqjre6+2YWYIgfgdWF6UDGkMI4lCELvP6JpwhIogvc6Icl8RYgcYQgiAIgjiAN1cd8HqvtgGXx2mAxhCC+AinK1GNFkH8jdd/ybO6CT4BGkMI4kCamrwDBZ76drfIlgiC+DLr8k5b3QSfAI0hBHEgtQ0YH4QgCABgADUV0BhCEAfy2ZZCq5uAIAjiM6AxhCAOZG3uKaubgCCIDeDQNUQFNIYQxIE0isQMIQjif6DOEB3QGEIQB4LGEIIgAAAN2BdQAY0hBHEg2UfPWd0EBEEQnwGNIQRBEARB/Bo0hhAEQRAE8WvQGEIQxFGUVtXC4TPnrW4GgiA+BBpDCII4hpr6Rug7azVkzVsP/7f1iNXNQRDT2FpQanUTfBo0hhAEcQz7T1S4/35uyV4LW8IeDnOmEQLUFmMLGkMIdTDtmy2VNfWSn/n6AHrjvzbzXl+o882K3Q98sQM6zVgOP2QXW90UxCYEWN0AHweNIYQqLyzdB6lPL4fnf/DtWbuVlJ2vk/xsU/4ZE1tiPQVnqqxuAnU4joOf95YAAMCji7KtbQxiG3x7mmM9aAwhVFm4uRAAAD7fcgRq6n1z1m43IkOD3H8fLbtgYUvMJ8AH58ubD2FsCKIN7GuNg8YQQo3TlbW817OX5VjUEv9hyCWtoJpYKgoJ8j3jwMWxs9Ve75ExRL5CgSBTzteXPhHjbEED2jBoDCHUeG1FLu81ZvuwgfSG3DagA++zipoGs5tjGjknKr3ee+KbXRa0hC1Cc/aH7OOWtAOxFwdOet//CD3QGEKoUViK2i9mEECMlk0Cr8F/f/ddA7SozNsz5IsUn+MvdWIWEQIAsD7vtORnWLneOGgMIdT4o/Cs1U3wC0j7R5i5FxYcBL7Kyz/tt7oJpvDB+kO81xhDhCDsQWMIYUpuie/FdFjNZ1sK3X83cRzPUxQWgo+0r3GmqlZ5IwRBDIE9J8KUpRjvQJ1PNx12/93YBPDRnX3dr8OC8ZFGEH8DY+yNgz0nQoUmCaHFXcfOmdsQP6OpiYP0hGj365LyGgtbgyCIFaAxZBw0hhAq1DU2ib7/Wz7GO7CkfcsI3uvCUv8IMkYQBKEJGkMIFTCuwRoyU1tBI04LfZ7aBraieg2NTVB+QbrMC2JvsAcwDhpDCBVe/yXP6ib4Lf5QC05McNGFP+ivsDRUOI6DtGd+ht4vroQi9Cw6kpIKXB43ChpDCBWO+okGjB0Rag35Ij/uOiH5WY4PqlB7wfAnXrrLk+Qw9PV17E6EMOO5JVgL0ihoDCFU+LPonNVN8Fv8wRiSIyDAd0uQuGD5CwuLwV6owzpXiP+BxhDCHKytxBZ/WCZrbBIP0AfwLl/hZDYeEFcZFqpSs+SdNQdNOxeC2AXHGEOzZ8+GzMxMiIyMhNjYWM3733///RAQEABvv/029bYh8jT4wWBtJREhvqs67WLeygOSnwX6kGdoTc5J0fenfbvbtDZ8uOGQ8kYI4mM4xhiqq6uD8ePHwwMPPKB538WLF8PWrVshMTGRQcsQpVnrom1FJrXEP0mJb251EyzFh2whySW/05it6degd509jjGGXnzxRZgyZQr07NlT037FxcXw8MMPw5dffgkhISGMWufflFXVyX6+OgcLTSLs+O/vvmNsSxl2Zo+FOPjaC/w52BNsdQNY0tTUBHfddRc8+eST0L17d1X71NbWQm2tZxZWUeEHmSoGCQ6Sn5r7e4AvwpZN+WesbgI1AkyOgEJtIQS5iGM8Q3p49dVXITg4GB555BHV+8yZMwdiYmLc/5KSkhi20D/whwBfBKFBoIQtxEp08Z3V4sHSNfXSAeuI+WAPyh5LjaHp06dDQECA7L/c3Fxdx96xYwe88847sHDhQk2ptzNmzIDy8nL3v6NHj+o6vz/x9R/y12jX0XPmNARBHI5UV8XKOJGKRXp3LWaU2YmNB8WzDBF6WLpM9vjjj8OECRNkt0lJSdF17F9//RVOnToFHTp0cL/X2NgIjz/+OLz99ttQWFgoul9YWBiEhYXpOqe/snBzoezn51G3hBoYy+HbkAKIVrKz6KzVTUAI/rPpsNVN8HksNYbi4+MhPj6eybHvuusuGDFiBO+9UaNGwV133QX33HMPk3MiCGtQ3NK3OVlhj6wxtLkRf8MxAdRFRUVQVlYGRUVF0NjYCNnZ2QAAkJaWBs2bX0wtTk9Phzlz5sC4ceMgLi4O4uLieMcICQmBhIQE6NKli9nNRxAqlF+Qz9zzReoaMH6FFT9KeKJ+P1xmcksQrbRqHgpnFDJ5EfU4JoD6+eefh4yMDJg5cyZUVVVBRkYGZGRkwPbt293b5OXlQXl5uYWtRBC2+EPpCSGfbym0ugkIYilCT11iTDg8NTrdmsb4KI7xDC1cuBAWLlwou41SPIVUnBCCOAX/M4UA8k9VWd0EBLEdg1LilDdCVOMYzxCCIL5VekItgVL55ghT6htxedIucJhczxw0hhBTOFeNa9s0II2hd/52qfvvrm2jLWiNOZwsr7G6CbbgaFm1qecrOH3e1PMh0vyWX8p7zYFvlaGxA2gMIaZQWdNgdRN8AtJJktQy0v13VJhjVrw1syaXX86lZ7sYi1piLWYbQzjY2pfE2Ai/jB9kCRpDiCGUirS6wFRdShD9H3lN/cmNHhPhmzUGlWIezRZyx6HWvrwyrif+PpRBYwgxxGYfqgvlBPilTTx/+1PFkxeuU1dn0Gko/Ya0Dd6y8/JL1/50TzmN1lFhpk5//EHsFY0hxBBqA3r9yXPBkjnLPeVpyMGK7Kx8veNqFxsBQT4YVK30u9H+WRua5AOkP9xwiO4J/+L4uQvwwtJ9kHPC94tgV9c1MHse45qFMjkuydnzdZA8fRl0mrEcdhzxbVVyNIYQQ6gdlHx8fDaN/cQA0kRYQ+TlrW/0nYt9QaSUS3BQALx966XmN4YxSr+a2dldi3cWUz9mbUMjZM5dCws3F8LV7/xK/fh24tDpKuj2/C/QacZy6gZRQABAeEgQ1WOKQZZauumDzczPZyVoDCGGUBvDt2JfCduG+CFS3etX24pMbQdLxDyKIUGBENecPyvecqjUazunoTRevrYiz5yGMOTs+Xqrm2AapBfXqV6VwlJ+RqEvq8GjMYSYwrxfnN+R240midEzt6TS5JawQ9JAELz/pw8UFlVaSs47Sfd3DbAgBHfjAX719ZMVviubsDrnpPtv2tm0Znnaf8jml2vxZTV4NIYQQwgfFrNpauLgp93H4SDlgcIR8GKGyL99Z5lMyuALDuJ3Xb4gRulDP5skc37O4b02Wy7AKqTuY71EhVsjpXHIh7Wn0BhCDLFWoAHj4qGsNN5rFv18fWMTpDy9HB7670646q2NsDb3pPJOPkSrqDD337Q7W7twvtY7ZggAoF/HFrzXPmALmc66PPFnlyVnq/nLZDX1vrns0ihIxXt1Ra7ElspU1Xp7lYSTAantaJN/yncnnWgMIUx4fGRn3mth50CDZxfv5b3+x8LtElv6Jp3bRLn/bvChoGmSuQJPwqjubQDAu0SHL9hCZtuzr9tg6fqln/ZZ3QQeHMfB6cpaw8cRBrsfOKm/vp7a9iyiHCsodt4/Cp2/HC0FGkMIE8xQR/16+1Gv984qaKf4Ko9c6fHE+ZKXZNexct5rqeUwX/jONAZhp2HESGBBpxnLof/s1bCEQSadXtTe2g2UJ5xzf9bvzXIiaAwhjqRJ4sF/e/UBU85fU99oiltaLZlpraxugimEiCwPAPhGzNCsZftNPZ+aK+ZL8WdKkLpHj32dbV1DdEL7pyq/4F8TSzSGEEeycr94fNBnW44wP/fRsmpIf24F9Jj5C+wReC6swvcWjcT555BOVjeBGUqK0LRRM3ZupihZYPckh1eW85dka+rF49XUYIUNSVvYdnWOeEyZketiZ9AYQqjz+FWdlTcyyKHT1rnXh7y2zv332Pc2WdYOEnJZ0pfEmQ+f4WevdE8UL9LqC0UrhXFQrFEzYJ+tpmegnayw9zLgrwf5pYXI1Hit0Lxucj9TclykzKeIFtAYQqjjGpduG9CB2TmsCv4UU0QeShhHVkEOoz5gF0hC2gutmnuy6fYcO2d+Y/wAmlpETrsvqwxoA80WeJlYQU4C/GhFkwloDCHU6Z/cEgC805/NQiqeiAa7RAbdorJq+CHb2oBLcqDxhfgZKcjOn/yaSyzWu3Imys/JAYpLW04brKd/v0f3vocp6vEIn+asLvGSn9FCLhGl1kdVqNEYQqgzMCXO0vP/uJvdwPjij+JBro8uymZ2Tq34rinEx1++JyvOVCkv5byz5iC1870rcSw7BGnTzkKlqft1QRCjE0/oixWcYSOCeO6CdNmUf63PZ3JOq0FjCGEGqy5OKRDzIMN0XbtW2iaXM3whfsYvsd4mYMq2wjLR99cLSnRYAc0YHwBxY0hv9qkwsJuh41sVvx44o7yRA0FjCGEGq+WqHIXaW2ZX93ZhZX0s0v6xMricJkWl/lGqwd8pKbe+PlkQ5eD1o2UXvN77+g9vXTQ1CAO7SQZ0aun+m6aHbeFvh6kdyymgMYQwg1X9nEe+2in7+UcbC5icVyx4muTGf21mcl6tyHWeTqK+Sd6o/cdgemn2fxadheTpy2CKzfVlaMbwCHn5hh7Mji2HDVbJqE+ghEtbAPQmh+T1CiV0t2heRzmJEhv8XExAYwhhxsjuCVY3gSp2rrDtjytjt/RLonYslyG7eGcxFFjkWasTDMhTRnhLVGyhqPsj5M6B7LI/7c5bq+jFRklBSzqB9AB1IFLrzTJS7BDjxQI0hhDd/CERA+BC6HpmUZ/MTI6d9XZ9C6ljmGmx77hH4LFZaBDvM5op0P6GcMb+6SZrlgiyj57jvSYDZc3AqlizPcXnLDkvySoJEdf9x+nFCAZRurztW3oMILIgtlnFmnMVwhScChpDiG7Wa6x6vfmQ8eUbKw2qx7/JVtymQWFpxwgbZQIXaavP2pH7h6XyXtOaoX674xjv9Ze/0y14qRcx28QXZ+VfbdMXS0OTQImRcOX+EmrnoBWX9ADxHDQL9YQiFFBM5/dH0BjyAS7UNULy9GWQPH2ZqUs5wSI9yCNXpIlseREa6/JW6vmoUdBdxLBjl+tLQyVqdjmZPMEMVGjw0TILVhlQGmbJYJF6c75nCtmDmnr2SRd6PW/C5z6C9AoTny3dRUdShKVOm53xvR7UD3mZKPB4zTu/mnZesUemm0S5BFocP6e8VGUlL/3ErtimXF/qi+n0jy6SD5Sn5SSRWiKxkpv6tIeklt6lFqxwDPnr4AhA93pX1+lLrZe7/CwquPxGwYPvRNAY8gH+S7j1S00u9mg281aqq0rvi8sJZsQFnamqtU1qfn2j4DcUvmT4G5+psraOVliIeNdsxTLxEovV1a3kVCW9++CV5bnUjuWCxSSoWiFr1ldBY8jhWKWpY3dOUNYuscPsmLXzp/xCPfSbtRqufGMD7LZhrS/hLxATGcLsXB+uP8Ts2GqQsvNo1bxqEPQbj424RHLbIxT0nopt7tGV4qtt9ogfk4KFZ+jnPSfoH9QBoDHkcMQynIQdnZkktYyw7Nwkc36mOwvbUsAupdkuzCOK31733m8WtkSckd3a8F6HBQdJbKmeGhE9GACAihrpcgTmwNb4/qOQLxDqsvUTY8K9tqVhhO+0UJDUbMz0rLKoQ6imzp8vet7RGPJBzIqBOHTK+6HvLhMzZGb6d7VO6XvJ42lwHbOaBfOLlNK/lv+3VVpozQ70S26pvJFGpIye/20/Jvq+WbAea7yyD/86oZiQ5fZC44aMnaUfTlFOOlESZ6VJMAvXkAryGIp/WgUaQw5nyU7v9fyaBnMexmVa3akmPreNlEcTLTMh2kUfXZwj6ie1iTZXg8YJ+NJs9eqebZkeX2icyF25TfnGA2rtHN+/j6KWkNnQLiOilvoG33nWXKAx5HDEqkrPpbxERAujj62WOBbaBomYvL7ZzF/rqRY958ZeVI8tZkgoiWraDdq2kJXG1bDO8UyPLzROIkKNLznKno/p0Y1B21Az87ah7SFWKxprZ+NWL2gM+SBq9HCswGhdpc82q1/G2XWsXHkjDTyzeK/qbfNFlg9p064F3dgssQ786e/3UD0Ha/SMQQdKpH8rG8TMM0MYa3L3oGQAAIgOZxOUvvGg9ZXpEWWEAqT+BBpDfsq/fy2AdbnaFKT1QNZXMppaaqXKcpWGGKTHTCj2SXtiJqyLBQBw0ASjjiZ6PDlPfLNL8rNak5abAaRT+Z8d05XJ+cIFqfvNwi4qGd+Q0Y7J+eygMm0WTlaDLz6nLnMQPUOIT7A29yTMWpYD9yz8g/m5hneh5+730p3xY2hnkXy8sYDq8axAjydHTpri/XX5kp/RprpW3PAalBrH5HxS909osDVDgpmGp5D9J5wbM0Sb99epk5Swc0C8XtAY8kP+sXC7aeeiab78SEluniY3921vyXlpz8y2HRaPD7JqkFLr5emf3MKzD+UZ+edbzMuu88WZthY+21xo2blfW5En+7mR2LHR3RN07wtgD30zMcovWC09QR80hvwM4Ux44wG2a/m+lOEjxovXdbfkvEqDp1YjRiorZeFvhZqOQwuhDo4UraM8ujh6bjW5rMPKGrryDHIEmpwVZDfjq6TcnnGOAAAHTmpbLl5APDPdEqMNnZtGJp9atJQLeXaJs+IJ1YDGkJ8h9K786sOBjXprAWnBFWthNkpuaq1lG6S21pN2vOdYOSRPXwav/6I/RqxMZTYg6Q1q0mENnau2xwxX6tdktRwh5Qm0CjvF2QiFY1//Rd5zJGQxIXfSYNCzIyUKyoJ/qVwiAwA4dPo8w5ZYAxpDPopUimRRGT9A7teD9GYer97U0+s9K7s4tQOqE1Ga2WuNr/pNYgaqpxL22Pc2AcDF+AO9auh6PBf/+4N+kK7VNcpaNGOT3fXij9oKCu86eo5JO+zIXZd15L1enaNfxLZ1lDE9MGHqfJc2UYaOJ8diEc06fwKNIQcjtwQlVVPn7dV8XaLcEnpKomIKwbRWyczw8ujljoEdTD+n4nXVeN1pFQAVGqBnTfS8sCiZQqMulxqkrn7bGHuUt/loo7W12sykRWQo73VKq2a6j9WhZaTR5vAY349djKJT68fRAo0hB/OnTL2f0xSrLYuhPhaIziCrVgyMBVKu6idHdQEA8RIkrGOlxDwnk7NSmZ5TDcLll9dW6Fsqs0tIy00fbDblPFruFyuCalmUfyGxU2jhuIx2EB3uWf4eckkr3cfq2tZYzJBZz4FSwW8yUcFXcYwxNHv2bMjMzITIyEiIjY1VvV9OTg5cd911EBMTA82aNYP+/ftDUZG9KxGrpbRKehmIdYCk2v6YRjFNAH2dJa0O9pvt4ssv4SEXv9t1lyZ6fcY68FEsNToy1NOB04zB0DJQv/wTf/nlG0oibj3aKQ8qrOJrkqcvg+Tpy+DOf//O5PgA2u7V7/40XxiP9aBcaqMl7eCgQMjo4Bn8vzKw/BpvcJlMCCujsfCMfAxQz3axMIBBbUA74RhjqK6uDsaPHw8PPPCA6n0OHToEgwcPhvT0dFi/fj3s3r0bnnvuOQgP967M7GucKKdbfFCI2gGyu8FsCjX0aBcNh+dc4/U+rfTPSgnBxdsGJAEAQHORIGo5Q5UGUeHe5yR/E5qdppggoxSsXO0TMr0LiJrNpvwzcJ5yAWAXWn6vXRrK0uhhRNc2Xu/9tFtjHUKN2E02g0zus9IrLYRVoPnMpftkPw8KFJ/0+RKOMYZefPFFmDJlCvTs6R2kK8UzzzwD11xzDbz22muQkZEBqampcN1110Hr1q0ZttQeiMmqSxkweh52sSOJBQvScq8LA79Jlk4eDAEBATCqO78Tf/FH+QfcKKQnxmxCgrwfXVazxlMWlHd5TyB4KHXvxgriO1hz72dshErtlE3190EdlTfycaIYlSXRirD7ZPWMbz4kH293dc+2zO7QsvN18M32o5bHhTrGGNJKU1MTLFu2DDp37gyjRo2C1q1bw8CBA2HJkiWy+9XW1kJFRQXvn13RGjogNbtraNJhDImcm2UHMkOmTpZLo2XSUH7MzK6jdOqT6emAzEyJdUHeD1qarGQMz1qmLfOIBrtV1pabelVn5Y0k0OM53FpQRi3YnGR1DvvSOFLERrId+K0e5PQw/ep0Jsct0eixF9aZtMpk7tOhBTNL7O//+R2e/HY3PLeE7eRVCZ81hk6dOgVVVVUwd+5cGD16NKxcuRLGjRsHN954I2zYsEFyvzlz5kBMTIz7X1JSkomt1sbbqw9o2n6rRLaNrngckx/Lihrxgeu7Bwa5/+7bkR/kp0d3Row9Ooq+Tre4yKmWOJ+iMvl4gaIy+2aZtCQ8Q1qdkPuO6zOWWaTbk7FWQuMkIZrtsv4LY9kKh3651b4xmjslklBYXfM3V2nTLHp6Mb8fEXusyQBvlokbMYy8sHuLLzocftpt7VKppcbQ9OnTISAgQPZfbq6+bJSmv7wd119/PUyZMgUuvfRSmD59Olx77bXw4YcfSu43Y8YMKC8vd/87etS+BQa1psWfrBCfleh5fMyuEyaVQdO3o3RQn1HBMxcr9pVQOQ5r9Bp/YktuJDkqazdJzXpLKRgPUt/MCiXl//5Of3AnY1TI4sYA7JdKhOrjtJ/s6jr6XtJ1uacgefoyXTpYJFJ1yVjdVzplt9yIPeNJRPq+nntDrYd0TM+22g+uAaszCi01hh5//HHIycmR/ZeSkqLr2K1atYLg4GDo1q0b7/2uXbvKZpOFhYVBdHQ075+vIOWKL9MR7Pv5lkKDrdGG3Ur0vHZzL97rt27tzfR85Sr0ejiJv83i573iy7A0gqrDJAqIsk75FuOdNQeVN9IImR0onN0Lv+GXDIwxklAJ41jvcldwEP3fyFVk+pGvdlI9bmLMRY8QzfsqrXVz999GD9tfJKMriLx3dBxTrYdUqmQPLWh58vViXQQoAMTHx0N8PL2q5iShoaHQv39/yMvjuyUPHDgAHTtigCDJK8tz4MO7+mraJ+cEPbFGNZSIeLWWTL7c1DaQtBS4jBOi2YrjqRqAGWWTqaUZw4Dya1TMSq3uTI0QGBggafEz1/gRvB7YSdzbWlvfBCzj1TmOU/VdzwrS8NXuJ4ZQjuEFBrUGAyT+1sMAkd+GtFGaOA6CNJ7FLhXorX56HRMzVFRUBNnZ2VBUVASNjY2QnZ0N2dnZUFXlKaKXnp4Oixcvdr9+8skn4euvv4ZPPvkE8vPz4b333oMff/wRHnzwQSu+gm05ela7yq4dqilfmhTr9d4z13Q15dzCby+WXk8TNa5suaKjZpAtkfJNo1lKS3kAAL/s01g2wUC7aMdmyM3uWRt5wu8iVTRWTNuKbjvUbbcml+/h/pFi2n+ohAfSCKydl6QhqOde+WaHPUJBrJ7MOMYYev755yEjIwNmzpwJVVVVkJGRARkZGbB9+3b3Nnl5eVBe7nH5jRs3Dj788EN47bXXoGfPnvDvf/8bvvvuOxg8eLAVX8FS5BSp9dyDwhv3shR7CHJ1MiCdrwWhKq0aUUDW8LPJNCgaq9j0SKlyYUapWJoLFmTWsWZtLt3sL3LAFD6Pg9P0KyDbkVk39IDIUG8xVrV37HHBsutPBuKGhM+JVBtoGb8s5pD8JVbt+3//p3xNMqP11ZS4pmcCAAA8euUlTM+jhGOMoYULFwLHcV7/hg8f7t6G4ziYMGECb79//OMfcPDgQbhw4QJkZ2fD9ddfb27DbYLc7ESPRS7cR87VGhFCR4VaDbRnF1KdYLjgO7FfylD+XrymargMC347rLiNkSDYV5bn6N6XJYcUVHfleOi/dGNVOJ4hy2fqSP3yAVrPLbsdpYWMPh1aQPsW3svKag2ON1fxs2hX7tdfSHXuz/wEHak2rD9wWvc5yEQOqYxeI5BOUxbOlYcljBRaEhOuvlTYp5qNY4whRDtkSjhtF7fwOQi0yZ00tDPdGDQnhaGQHXneSfUxXZ9vOaK4jZF0crWaQWbz3JK9uvel7e0ijXjhgBxOqaSNFImx6uLdlDwIUny2udDrPbHJkxWPWmUNPyhcKjv15z36l+ImD09z/81CcynQ4DKZEkESY8fvlAw7l/6d1ZFLNhnCEBa8t84TdLsmR//sSQyvOAMZY4uFJpGrFIYQ2rMLB9lCvI7wWQ0DvRo7efp31uomIewQC8oVi4H7dJOyB1GMU4Il+sjQIBgsUvzUDhOPmAhxAcoL9fpz4kd08yjjs1gmMxozpESwRAwZrQmBS/T10OkqhS3ZgsaQD0POvt5aJS3QqFWvCMC743ru2m7iG1LgsMhyhlmxQVpiBaQ6UtqI1Y4C4Gs/NWjQgVLzFZXS461Q3PYlyJ9gfF9loVelKuMsoOX9TW7VDCZnpXm9b2QgZyk2CABQ16D//iYnG7TqJZKQtoqW514tvZJiJM5L15dzVoV8CEvQGPJhSI8M7ZgWoRWfGt9cYkv+YHuuWrumkdgSzd8HJavat8HgoKGla2Gpw0EaG1KnMctAFINWdXonQXPJgyyJEiNQoBbLErQi84bmKcWytvJP6fcM1DIupqpWZPZEuWfS0OKv35H18g/Z73ymUf9NqVo9AEB6gnhyiFTWoV6s9gyiMeTDkKnGtKuJF5by0/HlHgvyHv9qG500TrXLYVsLygydR0sRW2HfsL3Q2LlJlu/xqGBL2bW3D+yguA0rqhlVc7cz35lkAFohYyHmaZHLSNWK2O35gkLldDkKTusPhpdicpan1qHauLdthz3P/Bu3sBVidUFOdPcWa4vP+/WgtsDwK9I9Rc6lYon0g6n1iA+g9rnQEz9kZMZgVHvnk18LvN6T+q6vj+d3fuvyzC2+SWrxmG0M0ezGaJTvMAMWBVvFiBZZfmU9i35iVBev92h6X8TuTzVfSSqQf/Zy+sWEyTADtQkEpGHSJpq+mrUYqfEej7DWEkRa20Yub9J2hKNnCPEJZB8qMm3YhBue1DAxOnvZccS7kOO7f8sQ3bZ7It+dzErZVc1xWQvkCVluINtGyFfb7FvYk8SsLDkxLyjr52hU9wSmxxcr+aEm7kcqiPsCg/pneiANBNczyPpJHNsr0f23VgO9VEcpJhfUl8moHk07aAw5FC3LN2IByGZCeoP0DNJagyOfJGa1Rp9Xsfb2bCceUGgXWXsANh2w3DIJTcPAinpjevh+p75UcxpYrdZrlGAxY0jFflJfu45CQLmw/p2e25DsA9zGEOPbmTRKtN4Xb62WTqwRg+yLzZ5wsQaNIYfyrcp4haYmDorP0o0X0srY3p6Zix7jRGsKZ0aHFp7zGbSGxLoWqT5A+D6rvkJNVg8Lg4KMh0CsxUj2ntGkAiN0bSut1K7GqSF1W+8tFq8+rwXhsfUkRPA9Q67/zTMamhj/tORvRDszjnEdWOXzW3t6RC9nBVlZCyb0F92u+NwFVWm4LN3MD1/hUTDV08G89CM/HqBFpHwKOzk7Kin3LvCqBS1eKWGnJwwyp4UaQ4dF/+t0b4Qv8a6awr0SqDFqYxWeMb3IJlqouL9Y3oLC53dCZrLmY5DPputvM5WVaT+j7QSCnORv9MQ3u6iey2rZRTSGLKKuoQk+3XQYDmhQCpYjJV46rfq5H5QF+IrPsRm4AQBCgrw7CC0UCJb5po1Ol92efGAf+zpb8/mUEHYQLlo245f0/tFAzSQ51Mw0WXQr6yjX41LLYyOsrVlkR/4o9I5lU0utislRZKh44WGjGWVyXk018Ssfbjhk6PxyCJ+Z2MhQ0e3k4AsUGjNMKmu0e15oG0MvXd+d95o8Og3PULnF2kIkaAxZxMLNh+Hln/bDyLc2UjlexzhxYyggAOCYimUytToaeiANIBquUCXvEs0kn1MV3p2/WLyDmUSFiw9UJCyWyYzEyGhJDxc2XVgUF7Eu2PS8QQkFMqYmXlAAlLb8h1amXS0/yVJDBJG8caHO2JqVVOFjOWgnOAqNYjk9OT28vUZbzBJL0BiyiOyj5wztT3usY7msTR6axvp5O5EijyTdZOIStKKlxhcrKgQzxMdUVHe2ev1dyGoN5WCEgehKk91owjg0Eg8z58aemvcxK71eCGvFZSmMeh56tfckH1yeGme0OTy0/vZCz8boHvIZdGquOekZMlquQmuaPAD9+4L06gN4G7BGIb2BVsdjozFkEWZlHv2fiiKcrCFvchrpmINS5DvRZiJ1lZyM0KsS11y5QzIzs01NTJqwIKYcGw5oW46747KO7r+NZBXd2Ked5n2+/sO4iKiapYJre7XlvbYqfMvoaadc1dn9N23vZUmFtvhAYQFZpWdGjXFCbtG1bZSm9ijxyjhlY522bZ7Wmq4nSIjVBhAJGkNWYfAmIB/caJllE7WaLVo8NsJga6G+jhB+uqnq00gfz05PkAWo+fZmXqIvttI1uIWq4UrfhRSbrG/QPxqE6agOv++4cUmBU5Xag/zN8Fj27djC6z2t5XSEnopmxLIL7XtU61K/MCNPqT1qjP5V+z0e0Khw8SB0vZmAbWPDFbehHTOkJ25KCwESf1sBGkMWYXS5iNzddf/HNfO+cStUzsi1tEY4+5YqHOo+NnHw7KJzGs7kPLq0oTsbFEPNraPWYCygUCl6/3Hjac3yyH8X0sA2O+PNl+3yeBEP5LNLtJXMEP4cPC8x5YundYlI652iZklUShSSRLcsgooGOy3jk599Z2FDAI0hyzD6u68mZiCmPwAaT0e2z+kFPQenyQfztolRnr1pRei+V5Var/LYWpcWxFBT8oTlHUoOqkbPQ9ZeUkPFBXNqstlliMs5oc3wFbabvHWttiO9DDWF7WktQaldwhY+5mpKGWnRGbIq3k0Kq0Vr0RiyCKNW8HaiTISrArSRW1tLe4QPpdK+NnvmDKEU8xTE4nnWccz9agctjb+NmPI56/RYpfuL/FjtxEDKi6A1+H4pBfkEVS224Bnq36ml4WMI7xdywPvbgA7CzWVR8vyoFaJ1H09wUZsrZGlSC07W2UeoOb2WibFZhYadAhpDPoCrOvJz13ZVvc+lSbG812cNDGhKFr0VVbdZ0UuiFIeLIDXy0Bo5WsZOA0orX//hHYO2RqA/lNJKWvNKD2J1rEjIu0vtYPDrwTOi798/PFX0fZaoaXJcc3qxG2rH4rsHdVTeSIFPN/ELHZOGbYagDwKQN6yF3YhQW+1f67VpEH20gd82pZgxs7sxrVmVANqMIaUJU4eWkaqP5QugMWQRNB0I3RMvDtCXp6rXY2krWM7RoiYqfN6U3LdOW8d2IUxpBwB4MEt+sAxmkNM+/fvd1I+pl9MqhPFeuK6713tGBBuVAvR5qLzVCkvF6/U1t2km4lQiC8soZGbfvPG9Jbejoae1S1CzjhcwK/KoyC3bCvuRb+4bZKRpmik7r7+oaec2RFaWyntUT7+ZnqD+WVHyuD5owsSA9LZhzBBiGD33kHA54IiG0hHCRzREodN06gzjlEjHHK4we2wTTVeHA8B4SRGaVKkIyBcTSVxmoKq9luzBap1lZTQZXJRREwsiltWjtwDzU996jGuposOsIA0ssd9V7lqszzvNe80600nI7GX7lTeSgCzJoeb3BgB4/Zc83ms1e2lZtlUKYL+qm3hijFiijl7IfgGNIYTaWrSWul8Th6boPo+wvVld5INOaabC33WZcde9WsQ6C6WvMkUwg7dKHE8tWlv3n9+Us2WslD745NcC5Y1EmDJCv+fFSNFUIQnR6gPw9apBk2KAagdmvWi9/eW2F0o4mC0sevCU8cxLAP0aUd1MNtilaqrRvGNYVj7QChpDFkEOGLklxjRDXNk8asT4XNAsHmjmQzpOhzCeXsSMS6WBPiaCry1Cwxaysz1V2yBuCFx/aaLJLbnIcZ0lHcgliVYaniPavHJjD8vObXeEj6PZRjet51Bv2IBUTUS9KF09KfFaVllomE2G6Hbtu2gw2bq2cmzW87hIDdjK59J+NmEH/WeR/oKaZiAU0NSKWHYZgLnGUDCRwqf3USB3ExanVMLomHzolGe5KyLEnjFL+tGo/SOzudV5GGqMgFSZgtku7DK32aGzb2KWEIPLZP6JIE/A0LEiQ/V5eZ4doz77jOSHbDbV2MXQm0lFllbYdrhMZku2fKAxw8Vsnvthr6H97aAGfiexdNqoRWiFgByER3eXr1ElpFbCIFTLw1/96WmHbYZKa5D7/iyvjJSK/1Oju7j/VqOn5QqyfviKNN77YcGeodYunt6dMgK4chmcrJrPIvlEC2gM2QCjD4eW5TH+fvoC4T7VGZehh/UH+EGTagdfMhPCaverUUoNZLEoccJgcLYwuHvikE4AYG6HH02UPVAbgyAWuutCa/28f60zZvDyJtoarttOg8WeAZR/J60ilEaRMyw3CvoCmgySKBpLLpmq8Qy5JEpW7C3hvd+ng6e0id3jCAEAdr8wUvIzVvOfYAayJFpAY8gqeCUErGmC3mfSzPbWCoJTm6n0gtHQ+6lrpBcY60tUEpIDLywVL89gVWCk2srlwtYJg+WXPTJY9Tm3FJSq3lYJLVftuSXGvHoAyn1AD5F4QKmlURq8sTJPeSMA+Fv/JEPnES71SGVWke9qiZU5VVkreaBFFIr7suSXx4bKxpTSzCYjCQ1Gz5DfQ3OmoFQnjH9efeewUjfoEpW1v8iO66TOkhNvrjqgaz8S+88BxZGLfSCvy/FyfsDyqL+WmIZ3iWfTMAX0GmFZAg+IS7vL3xG7mlqWnVfnePSlkuOUJTZ+y1dnWLqWnWaO7aa6LSTCPkzSGCLeL79gQGmdON3nW+gWNqbJuieGQ5cE+T527k29mJwbPUMI1QEzPET9T6r3vM4QUfS08XENgpIky/eUKG+kAMslLlaMy2jHi8MRUiijb9Mv+WIJB1rZimSshRrUVBYHAPijkB88KqaVVfDKNfDdA4Mg56XRsPHJLE3t0Iv5ZQblT3j7QO+SGQ0647IuSxFfitKDaylTKB57qlLdxMfLMyixNKrXVyE8XJRCqQ+70EmFenxHwqil6SXUIg3DAjSGLMIOcSx6jRqrszrUwGJQGdOrreZ9dlGI6zCbdrERvBgHIesI8buC0/qE/9QSLZAqUELtUsaPKsTpAgMDoG/HlhARGgQdZLwaNH9jswOolZ6TtjHe6dx6+w2asSaxEaF/tYX//r7j6mryCb+DVE06Wm2+5/JO7r/PVNXKbGkd1/VWlwEaRFwUI7X5hDpZSiKQrEFjyCLITo/mwK3mUP8cfPHBHNZZ31KG3aodi6FUdFENwplKe8o6H3ala9to6C1SN8oMhEvGWrtHZ3gtpZFrvrCeIA1aMor/EEMs+eHGDH26Yf+UCNRXKzMi3O8fg5NFt9M7QAu7SCnNHjshFIyVgvwdL9TpE/4EADhfJzSGdB+KCmgM+RhPjuyiuI3rwWyjQe2WxAkDjtiM1jAWPKzCWeSVJmT3XNNTObW8Sqf6sRK/7DvJe631TmN5a9IoXKqEXPOVlN71kKjDwNd7jcUGOzXLMgDedcFcfVhSS33P+bLd/PIwUqnkep0VtPvICIoiuQDiy8lqYroA+JNEpVJMcggNTatVOtAYsgG7jp2jdqxkyhXDxdDznF/dQ5t2i4u9xeXKG9mM/snSS0xa2XGEH9viislhiRr5grPn63SrPcvx817+IKW1fxTONmkilX5Nky4qEwRcMBPAY4CR0AAp4dRe7WN1HU9YK0/qnh96ic5EAJv/LGJ9uFrZEtKo1SpDwTuf13Fxmcw/IW7GuT/natuVuJO1ZI+5GKVRVE6InlkPuYuW7LklJgo8CvFeslH3sA6iGCgaEmRdByEnyvn26oPw7Y5jsvvrCYgU7qH1GCcr2MVjmDHRSIiR9taKxROtP3BKZEu26BWZNDLWBancWW3fojbwt4XOZUS7e89ptc+IAeNlfKFnCNEK2RnpScs3WktMlzFEIUZKrUudFsJmmi1AB+DdYZgZYCsXo/Ldn8e8pAeEy2s0+jarZ4sk6QnSzw0LL5kQseemsoadJ0yK2ctyqB2L9t184KS6Oo+sjRXaDjvWz/1QDfGj5Hczch2FT/a1Pa2pZ+gCjSGLMHJrf7a50P23FTOQmnrtM0PyAdLbYrPHReGlHdBJ5RIVxYYaOZLaNHMptGrtCFOn9VwGofFndbqtWkqr2EsoWOVrSBFMQop1Gn63GhBKVPvd561Upw3GIglkNxHu8NiIS6gfX47HVQY/uxCOG+kK2kIkpEyAVBkTNQj7hx7tzCv4LQYaQxZhRGhxL5E+SlPol6VMvN5lMhI7eQnkENbY0Sv6CABQIZj5a4m72H3MWLxVhMaadzQMF+ERZlydbviYZqBXe0cLYsbEf34rZH7exzQOtFKIGddqDXa1Hh+16J1EHjsrXStxO6FddXUPaRkOPc+JUnN7/eXF7a7S6y+0BSdnpYlvKEJIUKDbQDZSm1DYBqvrHKIx5HBoGjB7i9VpdOiBbKduz5CB8xutzq4FYVq6EWGyqV9n815r6S/MroHUsx1/sBPOvvW0p79ab5zFfLiBfUHediKZX2boWOl97tTo6dzUp72qYz22KFtnK8SRK1IqR5FM4Wjy2ZR7TqU0jeRQ8ty47Cu1OkvCZ7G5xtR/V11LIwH8/2czJW40hiyC1jBFc7zTIzevVquIV4tSZ5u1qri2iPQI9gmzR1gy9JJW1I7VYKCzoTHT0qJtI8zsEQYcr9zPT5tXgzN8gd6SAL6E3jtQjddHbVB6RY2BUhgi6H6uZHYj71W5LKs9KjJkhcbK7HE9ZbevJiZ7NfXKEz/hsq5Wb5VLwX2VjmfaxZe/ozGEgMFBjvj7kjbNjTfmL+p1uPrH91M3s2vieYb0ffdZN8h3CELIYq1G42e0wNLd26u9fBwPWVNMz6rVPZcn816/eF137Qf5i9cENYyyVXgxGoUZfDZbGn3uWn21sJyM3tVPvan0YvE8Nk/OAgD+vao2+02KHwRZtEpZbaQBVKsipnP2cjpB8N/vLNa9r80ebTSGrMLIEgbZOT18Bb1APZbLKmT/plYlVohcSQQxQom0dCd0pmrITJX3Oj07xjNY64mxEhpbHTVecxI9op7CQcBm/SUM60zP6+cU9Mh3AOgf7NblessFkMeyaxwZ6Q0yGj63Lo9/DZT6ZtKzoyYe6qjMcp+/gsaQRRjJZiAHuUiRIFctmQFGUTv7Ix/m/9uqzz2qtYMJJtRRz1Y7r2CqHkivmz6dH/4+WmMJaGM3G9aIR9ep6C26q9ceuCCyzFNPTKCsTKSQ+/VJb5BRj6bwOyrZN2TShtC7KobdPK52wDHG0OzZsyEzMxMiIyMhNjZW1T5VVVXw0EMPQfv27SEiIgK6desGH374IduGqqRfRwOBoaQCqMhNPVpG7VmsCrUR1D5T5GzlSKk5s5JgwjP0+i95ppxTDNrxDnKQK536Utv5r4MNyO37ItHh2grH+jWMSlnYVdCQp8xs0NYQ7q78lbWd0A6mkB2KlZM4pqerq6uD8ePHwwMPPKB6n6lTp8KKFSvgiy++gJycHHjsscfgoYcegqVLlzJsqTpUa9aIEMibgWjbN1OmpADLm5P0hBnJrtJCSKD+25vmkuGLS/dTO5YS5EChZwYd3zyMZnN46Lm7jMZe0Eaulpceby+N++ycBq8nGVvSiuFvbQSlSyK8zO/87VJmbdFCgMIkVdvB+C+1xFna1Fa0PY4xhl588UWYMmUK9OypPoh28+bNcPfdd8Pw4cMhOTkZJk2aBL1794Zt27YxbKk6jDwrpNYFVZexjkOpXYoZlOKJtTBrZjdpaIruff8gNEOMkk2x9pwS5EChdGuIpT6L1d9SU1lcLLBYuKSk61c3wRYSBnrr5feCUs37bDmkfR8hi/44qnrbH7I9Aa+s9SxZTa4iQvjDlpwyuBruH5ZqaH8X5Pc13MMZOIAaA5vsGzq01B4X6Co51Lej/jqMJQb011jgGGNID5mZmbB06VIoLi4GjuNg3bp1cODAARg5cqTVTTPE1oIy999iHVpnmWKPwg5qbG+PBLoezRK1M/d7BicTbdCHVGVpKa7sqr98RqkKjRQ7wmnwDC0XkRsQiyUYoiJouE20t5ehdZRxz4MZAtR9DHToJLU6Mha1yllMFRFA1OKRqrNJ7I0Rbu3PX+rX+jWEqefREerj4j7fUij52Zfbitx/01a41jJ/1Hrqsb2lBSKlGNX9YlC9XC09p6E7OvLgwYOwbt06OHXqFDQJUrKff/55ww2jwfz582HSpEnQvn17CA4OhsDAQPjkk09g6NChkvvU1tZCba1nIKyoYCdESAOxwUuuQvxggQbOfUNT4MddFzN43l59EB4boU1tNrmVulmFVkNGDK3xK4YqKtMcKEx0W7OI772+dzuY8vUu2W2EqtsAAM0oBF/rDd7VBp2LlldSCVldtBngWs9suD4fz1g2dijFU+m8rm+syoMbCG+k0NMhVEbX6miuqtWv6i6nJ0VOJmMi6MaWtY2VNzrI7kqN553cRI9RHPRXX6xlidbu6BqhPvnkE+jatSs8//zz8O2338LixYvd/5YsWaL6ONOnT4eAgADZf7m52iq6k8yfPx+2bt0KS5cuhR07dsAbb7wBkydPhtWrV0vuM2fOHIiJiXH/S0rSX09HDpbxOXIDOe2HNK21jsw1kyakYgO0WmgOFHoHBT3xJCwKOqoxKuViaVwcOlWl+dwhOoxorTFpWi9zRodY0ffn/qy/rzLCb/lndO3HOqOopFzfMsjRMn7tsz+L6C1ZA3j/3iwuQ2iwwcmfoE1hweonBWqMof0nPJN8PffBib/q0/2Wb3yZ1y7omrrNmjULZs+eDdOmTTN08scffxwmTJggu01Kir64jwsXLsDTTz8NixcvhjFjxgAAQK9evSA7OxvmzZsHI0aMEN1vxowZMHXqVPfriooKZgaRE9GbGcWTqjfJGjKyDCDsIJ65pqvuY+kNkdpw4LTmfUj3vJmBlEL1aTH0KFCrpV/HFrD9yMVBU2tMmtPjTTdriTvSmXzx3LXd4OWftCUCfLShQNP2UigtJQq/x+5j52TvR+GEwcikiRmGYoa0ba/n27ueNV9ClzF09uxZGD9+vOGTx8fHQ3y8unIOWqmvr4f6+noIFGQUBQUFeS3rkYSFhUFYGPssC7umhypx8KT22T2ANWmURgqHCveMjdTvUdOrTaO2zhCJQ28rw1x/aaLuDlrrszimZ1vdta2EaL1DDWuIEd9VizE0rHM8vEy8zj56TrFUy/YjZbKfq0VpUiOs2fZ7QZm8cS74ue0Y96JV2Zm8Rlrv578P6qhpewCbGpAG0eXLGz9+PKxcuZJ2W2QpKiqC7OxsKCoqgsbGRsjOzobs7GyoqvIMzunp6bB48WIAAIiOjoZhw4bBk08+CevXr4fDhw/DwoUL4fPPP4dx48aZ2nYx7GIMaW+Gvnbz007V7VPbYKy4qpUP7D8HdzJ8DD3GnJayJ1p+ezFxT9pU1zUobyQBWXpF6XsJl9G0PgN3XqZ98FCDmp/7EpnkCK1omaAIl2y3HVb2RtHq4pSeA2FsmtLkQ/jxNTIV5gEAwkPo5xkZKXAqBnmFtB46TofEAu3g+7Y2MEh1eYbS0tLgueeeg61bt0LPnj0hJIQ/a37kkUeoNI7k+eefh88++8z9OiMjAwAA1q1bB8OHDwcAgLy8PCgv9xTBW7RoEcyYMQPuuOMOKCsrg44dO8Ls2bPh/vvvp94+rdjDFNIeY0LjGVb7HBmtakwzJkLrsYSV6/WgR2OH/H1o2tsf3tkX/v4ftpIUF+r0G79kaJHSREOYEaT1OtEcCMhTG/Fk6kHL6YSXSE3inNrLOjitFWySiXvSer0VJwGCz5Vi4t75Wwbc9387NLVBiexj56BPBzpZjAAAaa09NSrNmGgbfQSEgdfCmohWoMsY+vjjj6F58+awYcMG2LBhA++zgIAAJsbQwoULYeHChbLbCGcvCQkJsGDBAuptoUFHgbZD8bkLXu5eMzDLQRXA+1vdk3Ts7AXljRgh1OCxwsekJxuOVX25IZewr8llxHglB0ylcgSHz5znvdY6IZDbfnthGfRL1ieoelmKtCAqC7QYGXpuK7X73NinnawxRLvIslYJEVr98tU9EuDnvSUAQD/1PpnIMmRZY5IWwhAAOzRZl//v8OHDkv8KCugEzfk6Qtfkbwf1ZYRo4aXrvSuQaw421XnTkgPdNzvUicTRfqgLBYOgHNO/38N7bYUkS16JsZghPTFHUsgZKndQLvGiB9KrovW20bp9sIyy+a5j5ZKfKfHMGP1B+noQymzIQZa2AaCbtahkGMxaRqfCuotp3+1R3ogBPdp5iiCz6E7i/qpsb0b5vMdGeAqE6+mnhd/fDppXPi266CRop0S/MNZbEXhgJ++ZZ7dEbeqteg0UPWva5AxfTjtJLV/oLBALADCim7bK3TQe7v9tP8Z7rUariTRuZ/6w13Ab1CBX765/Mr2lADl4AaQKN5jwp9FajFZuOUtrWj8pfGl2UVwtysspBvWNhnWWTpRR6lLyNUoy5J6olP3cLvGatHFNWGh7ncRIi/fEruk6n+ARsoEtpH6ZbOrUqfDyyy9Ds2bNeKnnYrz55puGG+ZvqH0+1cZVtI5WF5CmRb/CCHpudtI7rkdvRoiRiuNaC3SyqG869yblUjSkAXle4V7Rati2bBYKZee9RdbkDD8tQbpG+sNAjVW7SZKNChkSvLoiFx4Yrt7I+Gm3xxgyskx4oa7RS4xQDPLKhGnQwtHXNs/ZsrpIG0O0jZOlu47Du7dlSG9gkS1EXkIWTXAt7Z8VeUZpE0R4ChuaONA6jAj7hU35Z+CfQ/SXT6KBamNo586dUF9f7/5bCtZCXr6K2oeDnHmO6alNRr1jnPYaNEL0PsR67gt+aQmdJyYwY8bkol2s8WstRI2is5YslbdWH+S9dknsS/Hg8FTRJQvZshsmdQfk/eHUmb/aS9UuNgKKz/Hj6T7aeEiVevy2w2QpH/0/zvq80/Dg8DTZbcifQe4XMfGx/Ot81twfvOuhoQla4/Ve+HEfrJwyTPJzGjFYZKbuuep6SIgxNqmmMdk1impjaN26daJ/I3RQ+3AEEPeMXJG8fiKf0ShtYGY/YrQCuxAjniGt9Gwfw3tdcLoKUuKbS2ytDjXXXounTyhmp7RsIrWMI5eaa8SIvbaX9ppJAAAyMmIAQEfz6tKkWMjWUctPDrV356xxPeCeBX/w3isqq5bYmg/piTLyTJFGlRSlhIdC7t4VM05q6htF+6tb+4kL4HZtGw05J9TFyGn1HNKa39cSE1lhDBZNDiosK4p5d7VC3jufbiqAZ8Z4h2XIcaqSr05OQ4rEKNabYwgAqI8ZIp9juRmO2mUyrbAo9yAFvwK7vs6jRztPTJTazpIFhaXqg7elUGNYXHdpovJGkseXP8G4PsrV64VoWiYzMD6Q5zFj5t+zXYzyRhpR+/Wjw72NUl1f2SZOfDFPxX9/LxLZEuAaCQNZi9GtZCwbpZnEcqUrwBlAftndaOKI0u40fnbSM6S0HC/Go4uyea8HmpxJKYbuiL3t27fD//73PygqKoK6Or6l+f333xtumL+hdtAgHxQtnf6CCf01t0mMigv6hfG00kRhmSw9IRr2Fl80gmjP5LVAwxuhxiA04v1TMobEvE6ksSl6TAumW2Yuh4pRUl7DVNVYbJVDzwBqpqyRXOtuzGgPL/7IL/UhVQBUqs/T4uXS7BnS+OwO6CQurcArSSRzyHPVfI8t7dATGscjY/QaKEsfWIWurmrRokWQmZkJOTk5sHjxYqivr4d9+/bB2rVrISaG/owJ8UD280rLPpOzPMseWenaqmlL8bxJGUoAAEdKPa5/LWnAJHaRjafRn7H+KnraeGt/+bR6LbPw/QLPnZZOm9x0xV9aLmq21Ytc9fh31x6U/IwGYtlsS7KPaz6OmenMcvdujEipG6muTcro0/JsaDWWWzTTljwhdd+qjRkKEiyh2aMHk8ZHbCF9xtArr7wCb731Fvz4448QGhoK77zzDuTm5sItt9wCHTpYrzniy5Azo8ZG+Yf6iZFdYNkjg+HArKupnf9UZa3yRpTYQdSaGttL3/KP2aq+UtAYeDIoKtbq5ZEr+EGzdwyQf97bRKuX+n/q29262gTAv77/3sRe6+wumXpOWvSsSNQO0RkU1M0BtN+Tvdrrn+hqvfulPEBSxjXLxJ22MdpEF6Vawv9O0r82ayOVtn5bCMP4JzPRZQwdOnTIXQk+NDQUzp8/DwEBATBlyhT4+OOPqTbQX1ibq66iN/lA1SvqqQRA98QYCNWQQmtX9KgxAzjXMyTWYbUkYg5YoKaNU0d2cQdS/3NwJ8Xf5anR6bzXch2x8CMtP11Wuid124yZqlz2i6Yq8jrQ+ywI0XpP0pI+UINW700yhUxZtSjJm0hdV/I7FZ+rEd8I2CtIk5f2Rh1xgELkEnmchK5RskWLFlBZeVHYql27drB378Wlk3PnzkF1tbqsBoTP6pxTqrYjnxNfWatliV2kHrTGHai9H2iSnqBOgHPvi6Og4JVr4NlrlTNIhAacln5eywyZjGdSiqUTxmTYhQRGSQ92oH0Lbd6VjzaKe/eGdBZfLp92dbro+yxYrFBRXur265LgESp8dom0CrZwdxoGCwn5fBgps3PFX6EXTpWyEKLLGBo6dCisWrUKAC5WsH/00Udh4sSJcNttt8GVV15JtYG+TEyEtrVoAIC8Eo+6qpyqK3IRrQrbrNBqk20/opy6TBstS4p6vRNauk29dqySV2HpLu3xNbTbIIbZS7qar6+BiUVWF30xi6cq+B4UKemI2Ah9XtOnRnfRvE+DznS0wWkew+NomXTdRaFtca3OEAEpaCUYuLzu9QrhGk5BlzH03nvvwd/+9jcAAHjmmWdg6tSpcPLkSbjpppvg008/pdpAX0ZP3zKDqJlFKx0xPMRzG2hx0U69SlnkzWpu7tOe99qqIoarc9Qtg7rQU7Hejgi/hpbrr/caaBGeZIXeAVMtYp4Wter0LrRe3zsN1KDT66H9QWVguN7HpXPrKOWNBNCozyh/AsF++k4nyckK6SU6LbiWin1lhUKzMdTQ0AA//fQTBAVdtNADAwNh+vTpsHTpUnjjjTegRQvfWD80Az03uVB5lgbNwzweKrnq0UKu0livywqEHoxqHZoYNFjwW6Gm7bcXnlXeyAEIlwe1jCM3CgxZtWhx27PQCwIA+OMw299P7CtqXa4I1qj6S9tDoYbmIppKYugNOqY15yC9LUZNcaGWG+150dOL6RSqPXT6orjjKo0TPbui2RgKDg6G+++/H2pq6FiX/oxt4lmIZhSfVW9sGWm+HWbvdmZbofnLZCwQrvxoGa8HperzfGrRkWG1MjXx8+1sDvwXQ0WWyLXq52hFy/NeU09n0hGpot4agPq2VdXyddL0GFFi3s2v/zgq+7kWTpTzx1at44TS5qRkiRFy/wrZ+C1fW8KAVd55JXQtkw0YMACys7MpN8X/0NMRd21LPwaGbIemmA4DDtyaBms8NGby6JWXWN0EyxF25GYomGuJiTDSmolDpEsIXKBkDEghdm/VMPZ6ahmTzfZsCo0aqfpbe46V817Tmo/uoijo+uwSfVpuroy6f1wuX9qCvOfN1JpysfGg+tUHM9FlDD344IMwdepUeO+992DLli2we/du3j9ELfbwDJEPhFlGu1UqwXrOeq/OujlSSrT+hPAOP1XBXqfKrBp0RmvNGUFM22X+2nym59QycNLQnuE4DhZtO6q8IXhPLP9vyxHxYwp6ABbGgNG777ROLbcr0i+GLShKqRANtMIY0qvDxRpd5ThcwdOPPPKI+72AgADgOA4CAgKgsdH3Z/00sMkqGd8Y0vAoG2l/g0UZCFU1DZIFR10Iy3boLRiq17C0qxtZD8J75K3VB+DNWy4V3ZZWPJxdDPqy83XMtKHETv3bIbYzbuHA6ervxaARAtDYxMGWAnVLMMLz7TsuXodQeG+w6IP/LiPIqea8erXRXLspxY6Rn4/oan7cp13GPSG6PEOHDx/2+ldQUOD+H1GHHe8JTYU1NR47k4gBUXpgWRkEr63IVdxmQ95p3mu9HbveJSEfsoW8rl1VjXm17VhD6saIUVrFzgsWIRZLw/i+ET4Fcrag1kdGtPistkPw95V4iIRvD+ykPS7tz6Jz3sclWqvmmHIGj16JBdd+Sv0HGVsmeh+pZFT3i4aUVuPtfK09nSW6jKEjR45Au3btoGPHjrx/7dq1gyNHxN2TiDed22hP60zQUN5ALWTHxTKm4zJCCkDpLKwMguxj5xS3oRVUq/c7FJyp8nrPiDiaGlpH0b+vxLCbnWfkPuufLL8Mmktogomx2YAnR8y7yfraCjMzaYrtzRvf2+s9pRpzcki1Tdi/qVXnbxfrkTJQ0qlSs/Qkp82jPzPu4n5KXndaP9vIbgkAAJCZpq1velXFhNQKdBlDWVlZUFbmne1SXl4OWVlZhhvlLzx7bVfN+3RqdTFOoZkBi14IzxjSohCs0WrQcmxWqqZqstiE30uvbVTXoE9/4/11h7zemzaarcJuWIg5JVvstgTI0vh/+Kudsp/voBxkXHHBXGVtudgWrc9MbKT3cuI3O45pPIoHKXtAv0aQ/OfkcY0uA+m9J3f/NdH7z2+HjTVAJS5PlK9kBuvqAaXWiktLS6FZM+lqzggfPaqprhv9PMXMkehw7UrYAAAhgdpuH/IhV+qUWD1fao5La01bb1Hbs9V1Xu+FMzZWzBJ59JF+kwqk0Z0YY7wUR+l57/uGJW+vPiD5GY3baeMB/nK1Fu+l1ACt9/bT8n2sCEoGYF8TT4jr/tWiTSfGy9d3p9Ecw2gKoL7xxhsB4KI7bsKECRAW5rk5GxsbYffu3ZCZmUm3hT6MXQLJZt3QA8b9azMAaPPIJGjswMlDK81+WHmG1GSxCeOm9P5O4/u11yVwtl4QswTAPo7IrA7cbnWM7NKcaB2leZLjIqGQkmaMHmhOyNR4DF8XWUqToqhM/LocPCm/dCmFlsmC0WX2Aye9l8ntSP4pOu1s2cycJXolNE03Y2JiICYmBjiOg6ioKPfrmJgYSEhIgEmTJsEXX3zBqq0+h01sIejQ0lPxedZPOar3U7veLopC38dqkGKh4C2FXGVzrdCqVC6FWYa5XYwPs9gvkdUEwL/meozRS5NidbSIHo0UM0LVHEmL92xPcbno+7OWqe/fSJR+H6u1e6yADAMwsvxthvaYGjR5hhYsWAAAAPHx8fDCCy9AZOTFQbSwsBCWLFkCXbt2hVat2AZ6+hQ2eWbIJc86hnVmOIm/xbCTB8FKPRkXrJexzOrArf5VhWJ8TzGOxTp2tlpVsWCNK84AYP21lH9G6d9PVtoYSuf+lohv8hNbiOcBq2/kIDRY+YuLeebt0tXrmrru3LkTPv/8cwAAOHfuHFx22WXwxhtvwA033AAffPAB1QYi7DGtWDZx1yvHDHk2IDM59NBb4wxa2Jkp6RLRpEwi7qM1gyxCErMqplsdQC0cwPt1NFZL8b5hKbKff7xRWmqEXI7VY+y2EAk6Voven/vWfknuv+WMoYLT2pZQlDLzLiLfaFaaTgDaJgt2KbPEml1EZq7ayev/tnuLaNrEFtJvDA0ZMgQAAL799lto06YNHDlyBD7//HN49913qTbQpxHcBSx1SeQwUlZDC+TX3XDglOy25ATijsv0V8sGAPhb/yTljQj+/SsbrSw1hkB1nbgOT2QoW4OMRZkXMX61WIqf9r0+UqFY8fYjKjPGdAygj43QX+7FlRatFbJwqlz83ZPfaqtEoMYYV7pEesVR1eAn9o0m7hzoEZdUO8cRWza2eoLkQpcxVF1dDVFRFzVyVq5cCTfeeCMEBgbCZZddhjpDBvhIZhbJkgBzsqp5D8wP2fJaHeQDYvYa/JkqNlk5arIuDp22Rqr+iVFdLDmvC6s6RKO3lpFV5SOlnt9aT/UKsXR0uaDW80SRUj3LcgB8j5LZmYFK2ass+wl/iQPSQlZ6a/ffaosEr9inXzuKNboeibS0NFiyZAkcPXoUfvnlFxg5ciQAAJw6dQqio82ZYfoiWkpUPH9tN2rnNesxJ12plQpKxKRgna90Q1IZLiTPLtGefaaHbYf5OmHNGXqexqiYse+kWOhSDmGwplFPUbCBGlyLiErntJYpL8hkeJGTLb1LOeR+wgrwrElqKb9cztJeGds7kd3BZXhweKol51UDaSCqXSYT06ZqG2MsDIIWuoyh559/Hp544glITk6GgQMHwqBBgwDgopcoIyODagN9GWE2ltIN1UBMQzu1oqfnZNYaNzl7UEpxf+nH/e6/aTfPKi+EmriQo2XmZLv9Z5NAmI3hLUBmK0qhV6BSK7RrU2VQyugyI2brdGWN+2+9ng5ywrZD7RIgJayMxbl9gLGlerUIA/ztDM9LKNOfcxwH7609CMv3nBD93C4FrXVNB2+++WYYPHgwnDhxAnr39mg/XHnllTBu3DhqjfN1xNzcctQQA8ZpC+KLjBoR7YlAaCuzyfJOVkJ6gvkeTDu52oVNYdk0NYe2z5XRhpoBev/xCsWMsoRo46KLF9sj/VkTMc7qtb1SWztHVLemvhHCQ+go9bOQthATLyaXTgHsE1wsBtmf/by3BG6TMBg7zVhuVpMMoTtaJCEhATIyMiCQWMcdMGAApKezTVX1ZZQMANKbYsXAalTh9G/Ew6LFsKJtF9XUWzP7Upb0F/+iZsycrDZGfDkDZ1O+t4imkMdHso/ZIpcI9fYfZDaZWoZ2jle1XVuDKtzCJU8l77MWbxwLx52aZXMtdFch4UAT0kD8VqJ0ynETdd2MYlLoLKIGpeeNfLgp6vmpJueEtICcGkgRQiUDh/zc6BKC0JiwLlhX/nvsOiYuFGdGqQyWxoid7Bzay2QAyvfnoVPKQfEtKKWFby/0rhnpglyB0fu9g3V0PPdcnqxqO6M/RZcEvh6Y0lP+6k29VB+bxfMh3g0FqNhGnGeu0V7rkhZSE/nMuWtNbol+0BhyEA1NbDwaYTqUpGMj9dUzc6GlHIeamBM5Ug2IJrZvQS+4T06NGEA6XoBFPImwb2dpcKnp0O1kMGmlY5z8/fm1iLaKEFpf/wUi1k5Ik4UZmmZwc1++10pp0tOnQ6zqYwsfwQadsT2kFhLtKZlL9kBOqftURY3kZ0bYWXSOyXHNBI0hG1GrEERKeoZoOjf0lI1oaUDwDUCb6OJVClouWpHLuBFCc9BQqiZ9QKJu0iVt9Btz5yUyfmjVX7MrUgMh7WwyAIDZN/Q0fAwzjBPymbLjz90gs6ylZglIOGlQ6iK1eHuEv89X24rcf9c2qO9PXtPgjQLQVyBWbnXQzLpndtEPUgsaQzaCTLUVg8zkiNJZaZ4WRvtupceE/Jy2i/qln6Rnz0JMU+cGgGcW7xV9/7ErO+s+ptRavhC7eQoyNMzaxZDq9IX9M426SOkJUYaPoffy39inneptrY45VCKttbTRH6zjQVQai41cAfL+0jLmk6KVYucX/iz/HNxJ9bFdv6mc5g95GaUCnvXw6JXeAqCr9p+kdnwzQGPIQZAzpysJwSsrMNqZKgWLs5xUkBpGSthh0GgWRicjhkRoBBgququAsHMWWw4UXmU93sBZN/SQPQeAtzaOkpCfGmjE++i9zTrFqc/uIp85WjFKqlD5LL90fXfJz/TEKq3N5Q/GwngqLc82rX6AfBTELovQax3XXH0ZHtetLOeRISeWNOQCrul5Ucm8VXPv+2ltrnyVAbuBxpCD+GKrR92bdRVzJQx7hjQsk1mJDWwhQzFDUveJmZdXqEHCKsNEjYfm1RW5vNdmPUc19fJLKaYskxH24QPD6Ij5yenLaEWu1lqcDuNt/tp83mthAogWO5jWz6PkiZy9LEf3sV1xf3JZdOT3oPGdXMkBC34r9Pos2yQhVVqgMeQglEpYsIYcQI123ofPyGfY2MQWMvw9tbi5pTCyTCgVGG3m9ZVb/nDx4y5z7u08DV5BLYgtE5B8KhS5FKA3gF3Lz3ieqHsXHUFHcbyOokig3Hd5dox2xX3hPS60EYxMMkijRtPEjfQMiey3pUC/fImrnzhbXS9pENE2uvP+inMsEOnPtXjg7QAaQw6CVTaZWsgOgLUuDG0NDr1MHCpflVyJcRpiOlhgsQMRALyzfMT4bAu/pqEeY81KL55S9XqhmJ4QvR4qLQM6WSSX1vOrpOUDoD4uS+5YraPVLxe5zyu4iYSvm4epNwiFSSa85S59thD1bDLyXiArypPYwdNtV9AYchBaapexxl+eKaWq5Eqo7Sj/kNGHMYLUTNDMgolmlJq4iPJ5WA0GkQxru8lBVg63ArkMMK3IGUO6AqgVXhtJQtl40COkqfcKLP6zWPf5xSAvkdWZXGrPr2f5kxVoDFmMUvFBEss9Q8T9HcIw4NZOGE29VutCZ7V8Y8eZII10djsi9yz/b7u6rD6txBjU+zIMxTG3pczAqMegFhpXNO0DsoYgOfCP6Co/eSLb8N66fOkNdaBmCYzcgqW9pFbl/41beitvZBL+MaLZmGQN2SBWe4aOnvUsXU22cTVlIwizkAIMPiFqOxyaa/k3923P5Lh2x+qv+vatl6re9owFtQVZoGYJ7NKkFqqOJVdHTM+y3rGz/ED9eSvzNB9DDWT8o1INOhpSDmqQ6nfIy2hWW+RoHUWnJh8NHGEMFRYWwr333gudOnWCiIgISE1NhZkzZ0JdXZ3sfjU1NTB58mSIi4uD5s2bw0033QQnT9pb+0AuO4Nl+rMavtjqERqzS6Vh2iwUZEUYVWaW0/wg+XRTgej7eq7zJCLOiULmuCWwWlpj6ZXq21H9b/XGygPM2sGavh09xo2aVTI5j4+ZVGsQW9XCcz/s87xQeN5pLivqw5wZw+lKdca+HQwyF47oKnNzc6GpqQk++ugj2LdvH7z11lvw4YcfwtNPPy2735QpU+DHH3+Eb775BjZs2ADHjx+HG2+80aRWq0M445F7WFg9zHrw1aWO3cX8+mBGvQ1qAkwBAA6dFg+w1SM+SDbZqZ4hOwR+s0Sod+Qkbu3vCYgXiw2hmW7vBGpJ2QSF583qGBmyrTT68MdGeLIoz573OCeeXyouICvELlnDAA4xhkaPHg0LFiyAkSNHQkpKClx33XXwxBNPwPfffy+5T3l5OXz66afw5ptvwhVXXAF9+/aFBQsWwObNm2Hr1q0mtl4e4e2odvBkiRodGKPLR2YzLkNdVlcQ5UFYqJ2iNbDRqcaMHGq+UrSO4Faz4iHkmDY6XfKzypp699+07zMSclBiAdl0scnbLwaC81Pj1YcNOJFe7WNNOY/U7T9zqceL1VJEKFErl7T2aHuRBv7JCnWeoTbRuExmmPLycmjZUtotvWPHDqivr4cRI0a430tPT4cOHTrAli1bJPerra2FiooK3j+WCAcGq8QGs7rEu/9W0kQBcF422e0D+WqrQgE2KYzOnoQaO6tztKmyXn9pouZzkveUGmOqSxvj5SS0cLZaebC+sU97xW3ksMr9LlehnWVaNcm6PLbKv6Q3+9+/ei/vlhowxrolxuje1ypYy4zoQWoYOXjKU0akXazxItSl5z1Gj56JfHyUdskEVjjSGMrPz4f58+fDfffdJ7lNSUkJhIaGQmxsLO/9Nm3aQEmJ9Mxlzpw5EBMT4/6XlKSskWIEuzxG5KCpxiBzusdin0QFeeE3jwilWwpDWBJAifQE5QKVQrSKY3ahUFtLC88uUXah64mPIwel7YVnJbbRfFhNyAUBk9hpecAIYvWnjFxjMc/QvQaES6U8sTTqybmSLaxOYxfDrBUGqWr1aiebdsJSY2j69OkQEBAg+y83ly+fX1xcDKNHj4bx48fDxIkTqbdpxowZUF5e7v539Kh88VSjKGlhmAU5kKh5tp1mC6mNQWHdr5nRSZFnUPO9zf4t90sYojTRUoyXNlJLPXuPeeLRdkuI4tGA9e9JHl7sdjbiTb1vqHeWqpFgepdCspAwlUarHGKTRisNI9LTExZiztCe1DLS/bd5emJssNQYevzxxyEnJ0f2X0qKJzPm+PHjkJWVBZmZmfDxxx/LHjshIQHq6urg3LlzvPdPnjwJCQkJkvuFhYVBdHQ07x9LhJ0JK/E9Jcj72Bc9Q2r7KCu6sroGuvpR5O+nxoVv9i/J6tZRI8x3iohlmDjEeKkUMV67uZfo+2S8RmEpO4V11skNwUHyXmQjv6+YJ1aLsOSzY7ryXkvp3dCM2SLLThixhfYKkje0EhgYAB3jIv9qhzk9WSRlz7mVWCOb+hfx8fEQHx+vvCFc9AhlZWW5A6EDFXKG+/btCyEhIbBmzRq46aabAAAgLy8PioqKYNCgQYbbTgvhTfvumoOQ1cX8ivSkVW9W3FJlTb2oCmwxo0KeJFKdBetORKzswv8RBXhpQGpzOnyypgk1Sx8lFTXuv1n91EktIpU3IrhBR1yYVhoo1hC7ilBlF7uGtG+5DnHqr6fQmJJqix4vxq39kuDr7fIrBUaet6MUShB5irUaPpQqyOy4g6cqeZ4iJdq3MB6zRBNHxAwVFxfD8OHDoUOHDjBv3jw4ffo0lJSU8GJ/iouLIT09HbZt2wYAADExMXDvvffC1KlTYd26dbBjxw645557YNCgQXDZZZdZ9VW8EN4QUsKKhYSw16s39aTeDn7MkPL2NFyiUuc5b0La8btrD4q+/9PuE0zP+/FG74BTGp0gCWnMbjhwWmbLi9gxAFQPwUHaujNWZm9riQwZMniVRG2ckRR3CJIDxH5OtXpXaiBLj4hNHux0O0l9a2GtMTUIv5fYJdVbY06MG3XUNXSd36yYITJL997PtgMAwKnKGqnNedgpeBrAIcbQqlWrID8/H9asWQPt27eHtm3buv+5qK+vh7y8PKiu9gwsb731Flx77bVw0003wdChQyEhIUE2Hd8KHh/ZhfdaSmeITFtUUwVcKzxlUhXPkZ7ORIiUHgmLvrS7IEuFlNO3GqnB47YBHcQ/UID8/b78vUh6Q9f5dZ1FP3aJN7VLO4wOoEMuaUWpJb6Ha2JVQcgaAOirJSecNPxPxEt096BkzceVYnCa9t/V5Rkya5mMnIC4Tll8Vl3fOqq7dLiKFTjCGJowYQJwHCf6z0VycjJwHAfDhw93vxceHg7vv/8+lJWVwfnz5+H777+XjReygpgI/jKR1E0cqDHAWSv8GCBzHiQpw49syrDO6pZRlaCdFUYTqYDiAZ3UlTEQorTMeU6Y2m6yNWQTG4Rp+r0WvRzaS5m7jnrHnrAaG8UO+/Zqca+rWt661VOv6u5B2grRCuOlnvsrc/GjDYd478+4RloPSgrh7/SdSKHVFgZEFWl41FzHoOkJZAVNw5EGjjCGfBm19z9r1zMvgNqk9WZhHTAPnsZMyEw2pS1W8vth8aB5paKPUigZQ0Ilcz0VwX0BluNFp1bSxpDQGDVa8kXIf37z1glj9V1PlHsviYi9p4Xre7eD5LhI6NAyEp67tpuhYxX8FV5QWcNfek+M0R6v4pU0wtjg0HP4IJOXycT4RER7Sgy7ZZ+hMWQxQtdrrkT1cvJBZGEY8TxPJs3daylnUdGGVmCr3MAoh1hwuRq09oNaY22MYgeVddZIDeJi6u5Gl8nUDJpWibnqITAwANY/mQUbn8rSfG9K9Y3Cr6+nDzU7FkrPL+bST8uXiE8zg+V71CmQW11rU4i9WuOHqH2+Ghi7a4YRCtT/236M2Xlevr67+28pz5BdKivTCiw2W3tE6XzCr/VQVhrD1tgXlr9LbIT4cklFTb3XfWWGZ85JxpARyEw3EmHGJg1pkF3Hyg1nvpJZfjQNmFnLcqgdy19AY8hi1D6Tr67II/ah33mO6dlWeSMKxDX3ZBBI9c92qDEFQG8mKOcIkRqQ++go0OpCyfMijKtoG2NtfaBDp62ZxbK8taRiNsqr671ixPTUYSPp0U65hIUfOOMAAKBVc3UZSrTsz9IqdTW4pPj14Bn33/NWHjDaHNuSIMiwnDe+t8SW1mGpzhCi3rDZSKRIt2aQkmjW+i05Rkh5fXg1nCzsxGnN2IXfs6mJU0yBfUYgHqcFrQOf1an1v+WfUd6IASzvLWFihItbP97qJadxj4FyEwCgTtvFT4whtehZGhaTQDAqcCkdN8mWEJaVgkXY+vSVsGRnMTz2dTYM6NQSbu5rrPYgC9AYciDtNYq6qcGKAVFq5U8q5Z41ZYICk7QMROGg29DEQehfx5b6pkIpAG3nc9bIZ5UpxnIJVu7eEd7fzcPYd8P+skwmBi3ByQeGpXrphLHsNjNT45gdm9XtUCmQMAAAeGD4xRIrN2S0gxsytGsnmQUukyGWIfbgAAD8+1dPNgzNZzZUYTYozOrp00FfarsQYcdDDkxSApNGhPj6Jsu3206ieABgWYOssg+OG8y20sMZYjlnVHd9WYpOZXWOdzFZPYilzasVGJRC7hZMpFBV3my2Fnhnxl7dw15yNlKgMWRDhB4KX4Kcjb/yc67oNqTkPU0vR51ghugVqyIYk2/qQ8eV++QovrAmGShpVJNFjLBg+2kqPS+TIm2VbXaHhppXTudlIqB2KCXtLqewiyiQS5t/LNxuaH+rDHJWtSU3H/Je8u7VPpbJuWiDxpANMTrbcAr7jyt3UjSUrqXwUpAVdEy0pPWFtebm/OwZmHJL2FdwtwNR4dJLQWY5hmrq+fpK3RLZFmHWoyDMiuKzHmV+1oVc7cYH6w8pb+RnsHrmrCo0TgM0hmyIVH0yuzC2Nx39HTV6M4NNLDXALK5C0PGQ31sogAgAEGGwVpXG5vgNZmetsUh00At5a9MeCEssWPbzHazp62neA2N6eTKR9xY7d3KHxhCiiq0Fpe6/jThMyE5ZTZw0Tc/QiK6tZT9n1S0JO56iUs8sfbeIC3+cjgKNWrCbVL9ZngpWSwNS2Okqk7857avgy8v6LCD7oY9ECjfToGtbea8nzWdhbC9pWRYjEiFmg8YQoooVez2qorTLB5jF9Kv56epbD5XyXm84cIrJeYW2h1IA7f1DU5m0w8WnRIC6WcgZBka1WtRitjFkJ1iqfstlzk2/WnsNMF/nCSKGcGfROarHfviKiwKq/RWSKGg+C3Jzq6dGO+f3R2PIhohVQ7YacgmJViyN2Qi1X4SBlXMlArqNolUqIIixBsg3O9gpjKtlHxEv9sYqc8TmzL5tH73yEnNPKAN5D9K2CeWct1KK0P4My2Vwl5GjKLxK8R6QO1NvhwRPA6AxZEs+33JEeSPGCLO4yIfLyKASLSFGZwZKHQCrLCypWKQT5eJS/qzHbEtsWcElOHFO2jvWJppNrI3ZWlrJOmvSsYAcG2kvS8pdV5utyAIAwO0DO1h6fjGvDC3xRZeXTin+kWb4gZxxFxFqv8xWKdAYcgCnK81ZRiCR08Yx4mK1MsNGqdXBjDwyzSRE9cSKdgIAtIlmWx7DCoFNLQKHz1/bXXkjRJYCQbA4b3Ck8PM/ONyzlCu/bG4/a4h1goISYpfrW0reWrmq9aT4pDDD1Qi+ItWAxpADWENJNEwLwiBbnmfIgGvBrLIfYigacYz6bTEBxYqaenjpx/2i27O+Rlb8BFqqhrMqFeBPIUM/7+VXDr9AyArQuAzpRIAueV2PllWLbG0vuiREWXp+sckIrQmvZ5nM+7Ofdp9w/32vwRIwJFb26TRBY8gBkDebGRWuAbzdrA2EMeTUAGopD40LM+ewZyprmYrByePM3w+RZv5tGbzXwmXuyhqP0jkNzyB5fPJU/xJo+lixTDawU0vZz8f2oiMNohexq0/riXStfoktk52t9mT9hQaz7wOu6ekM5WkXaAzZgPuGpch+ThpDr97Ui3VzAMC7bhgZgHmlQoq6XQkNlr/dzazp5W/pyFKFS8VgJnHA6Lh2IF2Dt+PSJP1171yQnuLtR866/zZrsibHoyPkA9cDGY167VSWz2A5l5QLoCZPa8ZS+Zie1hqdWkFjyAYodSBkhWWzXLzCmQWpAznkEt9YIxZSWGqei3/yf/807VzemD9dH9ndnFmi3KNkRayUHUlrbbwPIcfaJ77Z5f5buGRiRcSQkuc6mJE19PjIzqq2ExPVpXVrukRcl+46LrudGU+CDexiTaAxZAOUHBJHzpx3/22WVoqwSY2Eq8hpN7kcVlV4P1khHiMw0pRUZPN/QOEgyeo2Jp8PrZIGVnBpUqzVTdCFna+tktHLKsZF7XHFMmrfXZPPe/3azfpWAL7YKp2JTF4XMyYGWenOWkFAY8gBmKXDQiL0DNU1eIwhX5ph7yBc/CSTs9gKH0rhQ5dWlk83sRF+JIP71wtENK1IRJiQmSz7OatMnMraBuWNDNAgYQwJ718r5hp2f4bEloyFRaS7KShISyGnL0ReF9rLmZeleMdpiSWO2Bk0hmyA2O17rlo8pqRBGMzDCE5wmtU5bNSZrea9dfmi7ysFW7PiEgpLGE7gt/xS5Y10QPbxZNAwAMAsonK7WcQr1SejZC0IDYCPNrAp8+BCbR0/LZIKTkfvT7nr6DlqbVA7UaXtHXvmmm5Uj2cFaAzZlI0Hz4i+X29SEVd/6cSkZlK0helu6dde1XaTs9KonteJODVbUQ+0nrKWzcwtCitlDC34rZD32grjPpKh0N/EIfRS0l1sPuQ9MdBrWKnVUqStqZYQw9dGi2sWSvX4ZoDGkA0Qu/EbJTxAzCqrC9gi8oD6AhmCwoG/ShidtI1BtSEWZii2njGpFphejMS3Oi0Gh9bj3NLkwUdtmQUrNGj0LjGpoX2LSGbHJtHb/8hNJMg4rxDKQeRCD+hbt15K9fhmgMaQDRC78aU8E9Hh5pSzkFo+cjq5JypF3y+vrue9ph2obnbsRIrKUhD9OsoXdLQCI/f409d0Vd7IRJQU153qge1tY6OTZUyj3KH1/pZi++n2DMl4fMhFBRZq+6OJjFEn1SRzgcaQDfjH5d6u10MCOX0XLFPrHyAk9m2cLGIIUomXpKKGbwwNSomjel6zs9bUnm10D/sJo/U1YKCRhpQdAv2VjAYzskNPVUrXgfM3lDTdjKD3EX9tRZ7Xe4kqNYuEqPYMUaxN5uLDu/rCfycOhGWPDIaYSOtqUOoFjSEbIFaLav5a8z0z5DqvVSnnViD0CgHQn/na9Wpa/TPXiBinRowY0riw3hRSRmwiRJszlf4l8CmH0ftd7p6iWehZMfBegpv6SMcmkhPsUAbGEABAZmor6J5oXNTTCtAYQkQxKzZJyP7jFUyPL9YJlFXXUasaLYUWBWYaqDVmrfqdXdBOsbeBM0gTLRwYaOpkWE7yrjJFI0yea3q1BQDx1PlFfxx1/22kvqSvgsYQIoqUjghthNW1T1Z4XPrR4fTT29c8Pkz0/Q8ENZVo85hCiQCWkNdUiNXLoXJt0wN28tYh5uWzG4b7NRlrW6ncD0lzRtIdLiMoTENbkIvgFbM5tQ0WdTAmDZJnBUtUZDAhi4wEsbXs6roG+HG3vHy9UWIjrfMAvLPmoORnTg3glYK0hZzmJXI6VnsZ1TC+b5Kh/a+kpKrctS2b2E93bTIH/BZ2A40hm/Pl1iJLzmuHR6ljHP00VrE+Ys7yXNF6QWbzEEWNIfLbyJVOsLrPpG2vkAGkNfXmCJTahdY640xoYVapIDVIFU3tlmgs7V5vYLMQ1iVBTNLm9SnQGLIxFTX1cNoiTRhSjNDMOkTk4MyicxWLGdiUf8a0ZUE5aH5d8mvKBSRbHShPO+OLPN6M73dTPbZe7rysgynnaddCfKD2Ne+fGlhVpqcFq2KxrmUysyoV+BI2v2X8m//bcoR6DRm1FJV5KrizdbnK1dKh/91tYPOYjtwtZLVniDbkLSOn1h5hYt2koZewqT8mRDh5MHMSs+94ua3upXCKmV0skOvaOrdprvu4rpi5Js76iY7TQGPIxtTWN8L/tnsyABJEUvDNQK74n1HMfl5b2Fj/4tb+xuIZSEhvgJyHzWrjcOHmQkvO+9y1zq+lJERo9H6z42LfUXimWmRruvyytwT+KCzjvWe2KjbJnBt7WnZuNchN9IyUAiKXiUvPo6SCFtAYsjH/Wn8ITlZ4lsmsCopjeVrhYMxb3mFwPjsI8UnBSupf7is7IejV6ZhVvVs4iG4vPAsAAA999Sfzc8dGhsLcn3N57yUziPlTS2q8fu+KGXRuLd0+I10UqUD9894S/QfyQ9AYsjHCOBbWbs8siUwJlkaYcDBmrffjL5CX9bf8M8T7/OstFWhqBk5IxaaBUkkOWgjr2rm6DzPs3c5tvLOjrJx42HjOAwAAD18hLbVh5LqRniFcJtMGGkMOgvW9LTWbIpfJxvRsS/WcwriGuStyJbZEtEDeK+UXPPIFO46c5W13U19pxVrWLN1FX87AjmOgWdpHM8fyl/7MHAztZtiKZWvZSXunWZi0t/CVcT10H5f83mbGjPkC9rk7EEWsWtIgH6reScal1idneWqg7Sku5312pNQT32DV7I6VQOLVFtUBI2+b6jr+oGVFVXEXLAZQtUtSdsiwmpCZTPV4wmVWMY/uU6O7UD2nizk/58D+E2zV47UQJVLsd9rodAtaIo6c98dI/UnyebaBWoijQGPIJoSHKP8Ul1pUKfpstScQj0a6O1k/Z87P0p4gqwIwO6ms+K4VM38/0nDu3s5jwNpJC4bFzLWZSmVfO6wgZHSIpXo84U+7bPcJr216MKobdej0eSbHpcnwLuZk9alBbg5i5Bkll8nQM6QNNIZswkvXK7tGrcqAeZXy0pXaNXGx2R0NBiS3ZHJcJczsm0hjaECypwq8ldUqpl/Nn5lbOXO1wzBB2yATDqJ20M6yEymUgqppyDKwiqcil2SlVhKszPKzM2gM2QQ1ekKs6tkoQTs112rfRFJLa7Jc5JZmHhieKvmZHiYOSRF938qg1gGd+Ebo+rxTFrUETHcN3TbAWzahDWWpDKufK7vx+FWdmRz3jVt6e713M8XYO1qPqNSScXeDKty+ChpDTsLk3u74uQsA4Ht1bqyKF5G7jOkG4gTEuJFYijxPxAlZuUom/P6/HjwjvqEJmH0H3DvY2zi9LIWuh1LNb0vze98/TN6Ap1leRg8Th3qu+Yd39qV23FgRrbJb+tHTCAsNojMsS5UzsrO8iJU4whgqLCyEe++9Fzp16gQRERGQmpoKM2fOhLo6aVGpsrIyePjhh6FLly4QEREBHTp0gEceeQTKy8sl97ESNfaG2fEe1XUNAEB/7dnqZ1HpWl/Smk0RxXEZ7SQ/YxWnBADwwfpD7r/9tRvMP1Vl6fmjwr29uixLkUhBc5n0yq7yRUsHpcbRO5kOwkOCYMezI2Djk1kwmmLyghFRRFXHN3hf9G5/MS4MNcS0Yc26i0Zyc3OhqakJPvroI0hLS4O9e/fCxIkT4fz58zBv3jzRfY4fPw7Hjx+HefPmQbdu3eDIkSNw//33w/Hjx+Hbb781+RsoY+fblow9YCUMaCbDu8TD4p3Fkp8bLeYohVyRx17tY6meS6o7tfuskFXzhJlOZo8TtJfE1FLXwNftojmQK11DO9xqcc3DII6y/qLY97KTpo8ro0yq+LQNfhZb4ghjaPTo0TB69Gj365SUFMjLy4MPPvhA0hjq0aMHfPfdd+7XqampMHv2bLjzzjuhoaEBgoPt9dX7UM4soQmpMzSqexsLW0KH63onwqOLsq1uhiXYYYCSg5X3M0TgErF68EqNZ+cJJKlt4MsX0C0GbB8DwEy6tvWeLJmlJaUGVxFYqTJKdu8DrMIRy2RilJeXQ8uW2tbcy8vLITo62naGEIC6TAczi0uSkBWQ7e5ZUIMvfAclpL6i3b/5wE5sMv2Ev7kVQfRvEoG3/3fvQNPPD0D391cyhVgvJ1lFTIR3zFCfDi1EtpRHKqbHKG7PEGYTasJ+VoEK8vPzYf78+ZJeITHOnDkDL7/8MkyaNEl2u9raWqit9dQDq6iwj5CYWg0V2pD10Wjgq52kE7DWDlTunJ++pqsJ7QC4QqL0DEvGZbSDmIgQSG7VTHbJlCbCWClSc8ooTlgmMws94qXX9moL7687pLyhzrawLLDti1jqGZo+fToEBATI/svN5WvcFBcXw+jRo2H8+PEwceJEVeepqKiAMWPGQLdu3eCFF16Q3XbOnDkQExPj/peURC9LwGmw8oL7UyepBrGZplGkDM7//n6U+rnUouZ+YmXwC+85K7yDAQEBcGXXNqYWERUqvNO815SyMvExl0fsebjzsg6Gj7v3+MXffFthmfs9Mglmfd5pw+fwRSz1DD3++OMwYcIE2W1SUjzpkcePH4esrCzIzMyEjz/+WNU5KisrYfTo0RAVFQWLFy+GkBD5zmDGjBkwdepU9+uKigq/NYhYjRfxUWFsDuwArkxvDWty+fo6b//tUtPO/92fx0w7l53w14H5P5sOMzu2smfId696XLNQKD0vnc2shlCRWmnNw4wbq+eqL9Yi/O/vRfDKuJ4AAPDDLk/CyCWtzTPGnYSlxlB8fDzEx6uTSC8uLoasrCzo27cvLFiwAAIDlZ1aFRUVMGrUKAgLC4OlS5dCeLhyRkdYWBiEhfnvYE2ybHcJPDqCfpq5mvpR7VtYV02dJbf0T/IyhpjEyTh0HPLXoFxajOnVlleGo7CUrmAqiVXlgexAv+QW8Mu+kwAA0DZGX6bgPZd3grdXH+S9R0liyItthz1eooevZFN70ek4IoC6uLgYhg8fDh06dIB58+bB6dOnoaSkBEpKSnjbpKenw7Zt2wDgoiE0cuRIOH/+PHz66adQUVHh3qex0V4Vlu3KW6sPWHZuNYrcTkSs44wMpT8nseOkvDujulhCxAQsfdlLQdLaRK+r0pKmlUWAWUOWT9Jb2FlsybInxZguPp7fYuglrRidw9k4IoB61apVkJ+fD/n5+dC+PV/23DWTrK+vh7y8PKiuvjgT+vPPP+H3338HAIC0NL4S6uHDhyE5OZl9wxFNkFXMWXek3ROjYd9x7+D4RJ2zPLXQ1hNyEhGhyh5BGn4hMcOntIpuEoBdweQEc2gTHQ5v3dobjp+rgVv7G4/zcTGqOz1xSBLykfCXiYFWHOEZmjBhAnAcJ/rPRXJyMnAcB8OHDwcAgOHDh0vug4aQPVlCCCGyNobG9Gor+v5rN3vXHaJNf6JwasEr1zA5h1NXm2j/6hsOXAwWnf79HspHtic4zpnHuIz2MJlyyRFWhgrZH/iww84QjvAMIQCd21gT9OYqyWEGtYRaLuvSI1LGQlxz9hWdv5p4Gfxv+zEY0KklM7E22iVUzCJYRSygEuQV3Xa4FIZ1VheXiCBm0y42Aor/qgFpFugZEscRniF/YbxM5eMuCeZUGn795l6818fP1TA/p8vDR3r6goOseWDN8KgEBwXC7QM7QBrDrA6nFtfFftoYvdqbE5eF0GHOjT2pH3N4l4vGv1T8EXqGxEFjyEbcNaij5Gdm2QatBAGYZjw4rurl5PDdgbFCsJS3oEUz+po/VtBcENwqLMtgV9RkGirBi4/wsxiasb0SrW4CooEhl7Ry97FfUFIlH/5X3yZZtd7Pngm14DKZQ7Cq9g3r5SoAgBPlF93EpGLqk6PSmZ6zh8SsqW2Mb6T0C42K+kYOLBIw1wQNDSp/9i7ZqUYWokxAQAAUzBlD9ZjBf+Xn1zc2iX7uz8+HHOgZshFyKxtmCRUKnxMzHhzX924iLkCLSN/w0NiFIOwBEQa0ao6abHYj9C9jiF+13vO3GRNcJ4LGkI2ICpeeutPOWrAjZGFBDPJD9ILLANZz7+BOVjfBb3HFW9YRnqGvtnnK8GDXKg4aQzZCrnJ9dLg1npKCM+fdfz87hl4RzTbR3jPKb7d7SkX4smCbXbhjID19FDuBnb04LJ4pqWvt0Ph9nyBE1DPkAT1D4qAxhPAQemSmfp3t/jslvhm185B1eVyPLGl4mbGsM+NqflxSv44tJLZ0PmJFNTNTzVeibWdCtXZyIH5vXT7z8zmF63ubF1ytVMQVYYfL2NlSUCr6OU40xUFjCOERInhQzv5V9A+A7vIDqSfTJDKNpCA3o0inVnzjbqif6dFYMWCZMSnNSm/N/iQO5L5hqVY3ATGBTflnrG6CI0FjCOExMCVO8jOaAxk5O3EVPOR9bsKoKTR+Jg5JYX5OqxBbtrBCl9EMY+j2Ab65/GcUFh6Bm/qIa6PhMpl1NDaJZ5Eh8qAxZDO6tTVHXFEKs1yoZCHWjX+VTOB9zqp8M4Ew/Tw8xHcfB7GxyYoK8WYEN+MygHn84/Jk0fdTKS6pI9owo+/0RRygPOJfmLE8ZAfsMmDlvjwavtl+FK7s2gYz2EzAjEuMP6M4IQyUW6V0jW5D75xlhBLGUGMTZ5u+1u74ydDrHMb3TbK6CZIIY2yMYJcHNDwkCO4alAyJJgT2WokVXiAxzPjV7XFn2Y8QBh4DqdsKvRPWMSjVE+qQf6rKwpY4C7xjbcbNMvXJrKZjnO8ZQ/5C4Zlqq5ugyCCZeDUtoIdPnAgKpU6EYNaY/SBrHlpV49GJoDFkM8T68d4+WHyRppcJUebZJXtgsyDLxG5GA63mCA9zurKWzoEdwoPDxbPGWjQLNbkliBWQ939gQIBkWQ6EDxpDNkPMYzKmV1sLWsKWJ0d1sboJfsXhM+dh/4kKq5sBfUzQchIaVcv3nGB+TjthVukeAIDIUAw7tRvJhAc/MIBf8xGRBo0hmxEW7O3K9sXyAlYpavsrFTUNXp6gpBbmx0k9MVLaCKaljCt8XqpqG3iv77qsI5Xz2BUzw8OaO6H6r58RGBjgLu2EhpB60BhyAFd1a2N1E6gjHPiEAxZinCGX8BWmhaZGRgfzFbcjQ6XjVqit2ikc51of9LSS4PCHuFYYmjiOJ2p7SWvpkk/+DhpDNkTYWSebHF9jRiiJUELg4w2H3H9HyxSsRdTTNiac99ruMeu0guqF968wk87XjQW7ZA4i1uESrW1s4nsKr+zqexNrWqAxZEOGWVwWwoxCfsJznK7yBLmO7pHA/Pz+iB0CpuWWfOktk/Gpa/CvAFKxciRJLX1bOgLhU3q+DgAADp2u4nmGMPtPGjSGbAgpcb/nhZGmn98MD4Kw3EZdg+chZaGHgthfjDA9IYrKcYQepnfX+lex1tR4c5dChEsvKLhoHyb/90+e+YNOQ2lwPcKGBAYGQOHcMZad/6IHge1TIxyYNx/ypH2jMUSfAZ1awhmbp5g/IJESrhWlDCd/HBBYfueubaPhICHu16OdtSWFEA8cB7B6/0nitR/e/CrBUQfxYnBaK6/3aKfCC5dsTpTXuP8OtntwiwPZdrjMFh6SMJn6b8Jacazwx6UCuSw+owzo1JLZsRHjfLD+kPJGCBpDiDfTRqd7vdfPBH0YF2YNir6OHSUZ8Le1hsw0OureYgiXxa6/tB2zcyHaIeedmGkvDRpDiBdi6c/VdY2mnf/GPtiZ+iPCODJm+OOAwPA7C2O0UHvIXpCTInS6S4PGEOKF2Jh0psq8eJMUkwNAEXuAthA7/PE7Ixchn6uWzcxTJ3caaAwhXoilYI/tnWhBSxB/wqzUf3+oi/fIFWm817GRbBXfD86+Gj6+qy/kvDSa6XkQdbRq7jF66ojaZHcN8m31dSOgMYR4ESUieoixHs7DHwOF1ZAY6/uaO8O68LXKxMr80CQkKBBGdk+ACBmFccQ8SE9+wenz7r9xCVMaNIYQL7BumG/Q0IjGkL/SuQ0dzSYE8RfQGEIQH6Vvsvm1xxB7EBUeAnHNQgEA4MM7+1rcGgSxP2gMIZZxw6UYh8SSv/W3pxLw5QzTvBEPG57Kgh8fGgyjumM9KgRRAo0hRJQoE9aWMbOBLbQKn9ImAuPPTKF5WDD0bB9ji5p0CGJ30BhCROlPqMqmxrPJvgkOwk7aP2H/u4cGY9eGIIh6sMdARHn0ykvcf78+vjeTc6Ap5J+Y4bDCJVjEn8GsMe3gFUNE6Z0UC49ckQYBAQHQpwObQNwWfwV4Iv4FlgRAELZclhIHq3NOKm+IuEHPECLJ1JFdYMpVnZkd/+5ByV7vTb/auy4a4ls8Ndq7aOhNfdpTPQcW50b8mYcFopuIMmgMIZYhJtDWEr1FPk+aSLmVNtF0g+nRFkL8GbH6kog8aAwhtuLytFZWNwFhjFhyUyDljKcmdA0hfsypSvNqSfoKaAwhtqKdH5RKsAOThqZYdm6xVG/q2d8StlDbmHDKJ0IQ+1FZ02B1ExwHGkMI4ofc2Ked1U3g0T0xmurxpPxCmMGI+AMd4yKtboLjQGMIQfwQu60ijeqeQPV4nN2+IIKYSFpr77g8RB40hhDED7GbrUBbJRnT9xF/JlhEzIvUjkO8QWMIsZQ7Btqzfpavw/l4vpXUMqBvf2sEuYjY5KJ9C4zHlMMRxlBhYSHce++90KlTJ4iIiIDU1FSYOXMm1NXVqdqf4zi4+uqrISAgAJYsWcK2sYgm/jG4k/vvaaNRY8gs7OYZos3wLq1F3/f1740gUmCGpTyOUKDOzc2FpqYm+OijjyAtLQ327t0LEydOhPPnz8O8efMU93/77bexWKFNSY1vDv8c3Al2HTsH91yebHVz/AarH4fhXeJhfd5p08/r6x4xBJECl47lcYQxNHr0aBg9erT7dUpKCuTl5cEHH3ygaAxlZ2fDG2+8Adu3b4e2bduybiqig2ev7WZ1E/yOAIvzqnq3j7XEGHr9ZjZ19hDE7gSZURTQwThimUyM8vJyaNmypew21dXVcPvtt8P7778PCQnqslVqa2uhoqKC9w9BfA2rPUP/HOJZHp2QmWzaeWmn8COIU7iuNxYvlsORxlB+fj7Mnz8f7rvvPtntpkyZApmZmXD99derPvacOXMgJibG/S8pKclocxHEdlitQxIVHgIbn8yCBff0hxeu627aeXGlAPEXxvTkr4SEh2CJDjksNYamT58OAQEBsv9yc3N5+xQXF8Po0aNh/PjxMHHiRMljL126FNauXQtvv/22pjbNmDEDysvL3f+OHj2q56shiK2JDLV+hbxDXCRkSQQ6swJjSBF/ISrc+mfcSVh6tR5//HGYMGGC7DYpKZ6yAcePH4esrCzIzMyEjz/+WHa/tWvXwqFDhyA2Npb3/k033QRDhgyB9evXi+4XFhYGYWF0i0YiCGIPMIAa8Reuv7QdLPoDJ/NqsdQYio+Ph/j4eFXbFhcXQ1ZWFvTt2xcWLFgAgYHyTq3p06fDP//5T957PXv2hLfeegvGjh2ru80I4iTuHtQRPttyxOpmIAhiMoNS46xugqNwhB+tuLgYhg8fDh07doR58+bB6dOeLBRXYHRxcTFceeWV8Pnnn8OAAQMgISFBNGi6Q4cO0KlTJ6/3EcQX6RDXzOom2IogqyPHEcQC3r0tw+om2B5HGEOrVq2C/Px8yM/Ph/bt2/M+c9Ugqq+vh7y8PKiurraiiQhiS7BGF5+45rgEjvgPhXPHwIW6RogIxeBpJRxhDE2YMEExtig5OVmx48eBAUEQBPEn0BBShyNT6xEEQRAEQWiBxhCCIAiCIH4NGkMIgiAIgvg1aAwhiA/Tp2MLr/e6tvWPkhStmoda3QQEQRwCGkMI4sNkJMV6vecviQSThqbwXndqhTIDCIKIg8YQgvgwASK6Ov5SvVpo8w3vok7gFUEQ/wONIQTxM/xFd7BRYA0FgJ98cQRBNIPGEIL4GYF+Yg01NfnHciCCIMZBYwhB/Izpo9OtboIpdE+M4b2+pqd3eR4EQRAANIYQxO/oJRJU7YsIY4T6Jbe0qCUIgtgdNIYQBPFJxILHEQRBxEBjCEH8jGA/ySZDEARRCxpDCOJn+JMxNKJrGwAA6O0nS4MIgujDEVXrEQShh7/oDAEAfHhnH9hdXA4928Uob4wgiN+CniEE8XHCgvmPuT/F0gQHBUKfDi0gJAi7OgRBpMEeAkF8nNdu7mV1ExAEQWwNGkMI4uO0iPQULI2NDLGwJQiCIPYEjSEE8XEuT2vl/nvt48OtawiCIIhNwQBqBPFxggIDoHDuGKubgSAIYlvQM4QgCIIgiF+DxhCCIAiCIH4NGkMIgiAIgvg1aAwhCIIgCOLXoDGEIAiCIIhfg8YQgiAIgiB+DRpDCIIgCIL4NWgMIQiCIAji16AxhCAIgiCIX4PGEIIgCIIgfg0aQwiCIAiC+DVoDCEIgiAI4tegMYQgCIIgiF+DxhCCIAiCIH5NsNUNsDscxwEAQEVFhcUtQRAEQRBELa5x2zWOy4HGkAKVlZUAAJCUlGRxSxAEQRAE0UplZSXExMTIbhPAqTGZ/JimpiY4fvw4REVFQUBAANVjV1RUQFJSEhw9ehSio6OpHhvxgNfZHPA6mwNeZ3PA62werK41x3FQWVkJiYmJEBgoHxWEniEFAgMDoX379kzPER0djQ+bCeB1Nge8zuaA19kc8DqbB4trreQRcoEB1AiCIAiC+DVoDCEIgiAI4tegMWQhYWFhMHPmTAgLC7O6KT4NXmdzwOtsDnidzQGvs3nY4VpjADWCIAiCIH4NeoYQBEEQBPFr0BhCEARBEMSvQWMIQRAEQRC/Bo0hxrz//vuQnJwM4eHhMHDgQNi2bZvs9t988w2kp6dDeHg49OzZE5YvX25SS52Nluv8ySefwJAhQ6BFixbQokULGDFihOLvglxE6/3sYtGiRRAQEAA33HAD2wb6CFqv87lz52Dy5MnQtm1bCAsLg86dO2PfoQKt1/ntt9+GLl26QEREBCQlJcGUKVOgpqbGpNY6k40bN8LYsWMhMTERAgICYMmSJYr7rF+/Hvr06QNhYWGQlpYGCxcuZN5O4BBmLFq0iAsNDeX+85//cPv27eMmTpzIxcbGcidPnhTd/rfffuOCgoK41157jdu/fz/37LPPciEhIdyePXtMbrmz0Hqdb7/9du7999/ndu7cyeXk5HATJkzgYmJiuGPHjpnccmeh9Tq7OHz4MNeuXTtuyJAh3PXXX29OYx2M1utcW1vL9evXj7vmmmu4TZs2cYcPH+bWr1/PZWdnm9xyZ6H1On/55ZdcWFgY9+WXX3KHDx/mfvnlF65t27bclClTTG65s1i+fDn3zDPPcN9//z0HANzixYtlty8oKOAiIyO5qVOncvv37+fmz5/PBQUFcStWrGDaTjSGGDJgwABu8uTJ7teNjY1cYmIiN2fOHNHtb7nlFm7MmDG89wYOHMjdd999TNvpdLReZyENDQ1cVFQU99lnn7Fqok+g5zo3NDRwmZmZ3L///W/u7rvvRmNIBVqv8wcffMClpKRwdXV1ZjXRJ9B6nSdPnsxdccUVvPemTp3KXX755Uzb6UuoMYaeeuoprnv37rz3br31Vm7UqFEMW8ZxuEzGiLq6OtixYweMGDHC/V5gYCCMGDECtmzZIrrPli1beNsDAIwaNUpye0TfdRZSXV0N9fX10LJlS1bNdDx6r/NLL70ErVu3hnvvvdeMZjoePdd56dKlMGjQIJg8eTK0adMGevToAa+88go0Njaa1WzHoec6Z2Zmwo4dO9xLaQUFBbB8+XK45pprTGmzv2DVOIi1yRhx5swZaGxshDZt2vDeb9OmDeTm5oruU1JSIrp9SUkJs3Y6HT3XWci0adMgMTHR6wFEPOi5zps2bYJPP/0UsrOzTWihb6DnOhcUFMDatWvhjjvugOXLl0N+fj48+OCDUF9fDzNnzjSj2Y5Dz3W+/fbb4cyZMzB48GDgOA4aGhrg/vvvh6efftqMJvsNUuNgRUUFXLhwASIiIpicFz1DiF8zd+5cWLRoESxevBjCw8Otbo7PUFlZCXfddRd88skn0KpVK6ub49M0NTVB69at4eOPP4a+ffvCrbfeCs888wx8+OGHVjfNp1i/fj288sor8K9//Qv+/PNP+P7772HZsmXw8ssvW900hALoGWJEq1atICgoCE6ePMl7/+TJk5CQkCC6T0JCgqbtEX3X2cW8efNg7ty5sHr1aujVqxfLZjoerdf50KFDUFhYCGPHjnW/19TUBAAAwcHBkJeXB6mpqWwb7UD03M9t27aFkJAQCAoKcr/XtWtXKCkpgbq6OggNDWXaZiei5zo/99xzcNddd8E///lPAADo2bMnnD9/HiZNmgTPPPMMBAaib4EGUuNgdHQ0M68QAHqGmBEaGgp9+/aFNWvWuN9ramqCNWvWwKBBg0T3GTRoEG97AIBVq1ZJbo/ou84AAK+99hq8/PLLsGLFCujXr58ZTXU0Wq9zeno67NmzB7Kzs93/rrvuOsjKyoLs7GxISkoys/mOQc/9fPnll0N+fr7b2AQAOHDgALRt2xYNIQn0XOfq6movg8dlgHJY1Yoalo2DTMOz/ZxFixZxYWFh3MKFC7n9+/dzkyZN4mJjY7mSkhKO4zjurrvu4qZPn+7e/rfffuOCg4O5efPmcTk5OdzMmTMxtV4FWq/z3LlzudDQUO7bb7/lTpw44f5XWVlp1VdwBFqvsxDMJlOH1utcVFTERUVFcQ899BCXl5fH/fTTT1zr1q25WbNmWfUVHIHW6zxz5kwuKiqK++qrr7iCggJu5cqVXGpqKnfLLbdY9RUcQWVlJbdz505u586dHABwb775Jrdz507uyJEjHMdx3PTp07m77rrLvb0rtf7JJ5/kcnJyuPfffx9T632B+fPncx06dOBCQ0O5AQMGcFu3bnV/NmzYMO7uu+/mbf+///2P69y5MxcaGsp1796dW7ZsmcktdiZarnPHjh05APD6N3PmTPMb7jC03s8kaAypR+t13rx5Mzdw4EAuLCyMS0lJ4WbPns01NDSY3GrnoeU619fXcy+88AKXmprKhYeHc0lJSdyDDz7InT171vyGO4h169aJ9reua3v33Xdzw4YN89rn0ksv5UJDQ7mUlBRuwYIFzNuJVesRBEEQBPFrMGYIQRAEQRC/Bo0hBEEQBEH8GjSGEARBEATxa9AYQhAEQRDEr0FjCEEQBEEQvwaNIQRBEARB/Bo0hhAEQRAE8WvQGEIQBEEQxK9BYwhBEARBEL8GjSEEQfyOhQsXQmxsrGXn//TTT2HkyJGqtv3www9h7NixjFuEIP4NGkMIgjChpKQEHn30UUhLS4Pw8HBo06YNXH755fDBBx9AdXW1e7vk5GQICAiAgIAAaNasGfTp0we++eYb9+fV1dUwY8YMSE1NhfDwcIiPj4dhw4bBDz/8IHre4cOHu48n9m/48OFw6623woEDB5hfAzFqamrgueeeg5kzZ6ra/h//+Af8+eef8OuvvzJuGYL4L8FWNwBBEN+joKAALr/8coiNjYVXXnkFevbsCWFhYbBnzx74+OOPoV27dnDddde5t3/ppZdg4sSJUFFRAW+88Qbceuut0K5dO8jMzIT7778ffv/9d5g/fz5069YNSktLYfPmzVBaWip67u+//x7q6uoAAODo0aMwYMAAWL16NXTv3h0AAEJDQyEiIgIiIiLYXwgRvv32W4iOjobLL79c1fahoaFw++23w7vvvgtDhgxh3DoE8VOYl4JFEMTvGDVqFNe+fXuuqqpK9POmpib33x07duTeeust9+v6+nouMjKSmz59OsdxHBcTE8MtXLhQVzsOHz7MAQC3c+dO3vsLFizgYmJi3K9nzpzJ9e7dm/v000+5pKQkrlmzZtwDDzzANTQ0cK+++irXpk0bLj4+nps1axbvOGfPnuXuvfderlWrVlxUVBSXlZXFZWdny7ZpzJgx3BNPPMF7b926dVz//v25yMhILiYmhsvMzOQKCwvdn2/YsIELDQ3lqqurdV0HBEHkwWUyBEGoUlpaCitXroTJkydDs2bNRLcJCAiQ3D84OBhCQkLc3p2EhARYvnw5VFZWMmmvi0OHDsHPP/8MK1asgK+++go+/fRTGDNmDBw7dgw2bNgAr776Kjz77LPw+++/u/cZP348nDp1Cn7++WfYsWMH9OnTB6688kooKyuTPM+mTZugX79+7tcNDQ1www03wLBhw2D37t2wZcsWmDRpEu8a9evXDxoaGnjnRhCEHrhMhiAIVfLz84HjOOjSpQvv/VatWkFNTQ0AAEyePBleffVVr33r6urgjTfegPLycrjiiisAAODjjz+GO+64A+Li4qB3794wePBguPnmm1UvM6mlqakJ/vOf/0BUVBR069YNsrKyIC8vD5YvXw6BgYHQpUsXePXVV2HdunUwcOBA2LRpE2zbtg1OnToFYWFhAAAwb948WLJkCXz77bcwadIkr3OcO3cOysvLITEx0f1eRUUFlJeXw7XXXgupqakAANC1a1fefpGRkRATEwNHjhyh+p0RBLkIeoYQBDGFbdu2QXZ2NnTv3h1qa2t5n02bNg2aN28OkZGR8Oqrr8LcuXNhzJgxAAAwdOhQKCgogDVr1sDNN98M+/btgyFDhsDLL79MtX3JyckQFRXlft2mTRvo1q0bBAYG8t47deoUAADs2rULqqqqIC4uDpo3b+7+d/jwYTh06JDoOS5cuAAAAOHh4e73WrZsCRMmTIBRo0bB2LFj4Z133oETJ0547RsREcELPEcQhB7oGUIQhCppaWkQEBAAeXl5vPdTUlIAAEQDl5988kmYMGECNG/eHNq0aeO1jBYSEgJDhgyBIUOGwLRp02DWrFnw0ksvwbRp0yA0NJRKu0NCQnivAwICRN9ramoCAICqqipo27YtrF+/3utYUmn7cXFxEBAQAGfPnuW9v2DBAnjkkUdgxYoV8PXXX8Ozzz4Lq1atgssuu8y9TVlZGcTHx+v4ZgiCKIGeIQRBqBIXFwdXXXUVvPfee3D+/HlV+7Rq1QrS0tIgISFBNp7IRbdu3aChocG97GYFffr0gZKSEggODoa0tDTev1atWonuExoaCt26dYP9+/d7fZaRkQEzZsyAzZs3Q48ePeC///2v+7NDhw5BTU0NZGRkMPs+COLPoDGEIAh1/vWvf0FDQwP069cPvv76a8jJyYG8vDz44osvIDc3F4KCglQfa/jw4fDRRx/Bjh07oLCwEJYvXw5PP/00ZGVlQXR0NMNvIc+IESNg0KBBcMMNN8DKlSuhsLAQNm/eDM888wxs375dcr9Ro0bBpk2b3K8PHz4MM2bMgC1btsCRI0dg5cqVcPDgQV7c0K+//gopKSnumCIEQeiCy2QIglAnNTUVdu7cCa+88grMmDEDjh07BmFhYdCtWzd44okn4MEHH1R9rFGjRsFnn30GTz/9NFRXV0NiYiJce+218PzzzzP8BsoEBATA8uXL4ZlnnoF77rkHTp8+DQkJCTB06FBo06aN5H733nsv9OvXD8rLyyEmJgYiIyMhNzcXPvvsMygtLYW2bdvC5MmT4b777nPv89VXX8HEiRPN+FoI4pcEcBzHWd0IBEEQf2L8+PHQp08fmDFjhuK2+/btgyuuuAIOHDgAMTExJrQOQfwPXCZDEAQxmddffx2aN2+uatsTJ07A559/joYQgjAEPUMIgiAIgvg16BlCEARBEMSvQWMIQRAEQRC/Bo0hBEEQBEH8GjSGEARBEATxa9AYQhAEQRDEr0FjCEEQBEEQvwaNIQRBEARB/Bo0hhAEQRAE8WvQGEIQBEEQxK/5f9Ac57BtiDhLAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get the HDF5 group: group\n",
    "group = data['strain']\n",
    "\n",
    "# Check out keys of group\n",
    "for key in group.keys():\n",
    "    print(key)\n",
    "\n",
    "# Set variable equal to time series data: strain\n",
    "strain = np.array(data['strain']['Strain'])\n",
    "\n",
    "# Set number of time points to sample: num_samples\n",
    "num_samples = 10000\n",
    "\n",
    "# Set time vector\n",
    "time = np.arange(0, 1, 1/num_samples)\n",
    "\n",
    "# Plot data\n",
    "plt.plot(time, strain[:num_samples])\n",
    "plt.xlabel('GPS Time (s)')\n",
    "plt.ylabel('strain')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Importing MATLAB files**\n",
    "\n",
    "1. MATLAB\n",
    "“Matrix Laboratory”\n",
    "Industry standard in engineering and science\n",
    "Data saved as .mat \n",
    "\n",
    "2. SciPy to the rescue!\n",
    "scipy.io.loadmat() - read .mat files\n",
    "scipy.io.savemat() - write .mat files\n",
    "\n",
    "3. Importing a .mat file\n",
    "\n",
    "import scipy.io\n",
    "filename = 'workspace.mat'\n",
    "mat = scipy.io.loadmat(filename)\n",
    "print(type(mat))\n",
    "\n",
    "<class 'dict'>\n",
    "\n",
    "- keys = MATLAB variable names\n",
    "- values = objects assigned to variables\n",
    "\n",
    "print(type(mat['x']))\n",
    "\n",
    "<class 'numpy.ndarray'>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loading .mat files**\n",
    "\n",
    "In this exercise, you'll figure out how to load a MATLAB file using `scipy.io.loadmat()` and you'll discover what Python datatype it yields.\n",
    "\n",
    "The file '`albeck_gene_expression.mat`' is in your working directory. This file contains *gene expression data* from the Albeck Lab at UC Davis. You can find the data and some great documentation *here*.\n",
    "\n",
    "STEPS\n",
    "    Import the package scipy.io.\n",
    "    Load the file 'albeck_gene_expression.mat' into the variable mat; do so using the function scipy.io.loadmat().\n",
    "    Use the function type() to print the datatype of mat to the IPython shell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "# Import package\n",
    "import scipy.io\n",
    "\n",
    "# Load MATLAB file: mat\n",
    "filename = r'G:\\My Drive\\Data Science\\Datacamp_Notebook\\Datacamp_Notebook\\datasets\\ja_data2.mat'\n",
    "mat = scipy.io.loadmat(filename)\n",
    "\n",
    "# Print the datatype type of mat\n",
    "print(type(mat))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The structure of .mat in Python**\n",
    "\n",
    "Here, you'll discover what is in the MATLAB dictionary that you loaded in the previous exercise.\n",
    "\n",
    "The file '`albeck_gene_expression.mat`' is already loaded into the variable `mat`. The following libraries have already been imported as follows:\n",
    "\n",
    "`import scipy.io`\n",
    "`import matplotlib.pyplot as plt`\n",
    "`import numpy as np`\n",
    "\n",
    "Once again, this file contains *gene expression data* from the Albeck Lab at UCDavis. You can find the data and some great documentation *here*.\n",
    "\n",
    "STEPS\n",
    "    Use the method .keys() on the dictionary mat to print the keys. Most of these keys (in fact the ones that do NOT begin and end with '__') are variables from the corresponding MATLAB environment.\n",
    "    Print the type of the value corresponding to the key 'CYratioCyt' in mat. Recall that mat['CYratioCyt'] accesses the value.\n",
    "    Print the shape of the value corresponding to the key 'CYratioCyt' using the numpy function shape().\n",
    "    Execute the entire script to see some oscillatory gene expression data!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['__header__', '__version__', '__globals__', 'rfpCyt', 'rfpNuc', 'cfpNuc', 'cfpCyt', 'yfpNuc', 'yfpCyt', 'CYratioCyt'])\n",
      "<class 'numpy.ndarray'>\n",
      "(200, 137)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.io\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Print the keys of the MATLAB dictionary\n",
    "print(mat.keys() )\n",
    "\n",
    "# Print the type of the value corresponding to the key 'CYratioCyt'\n",
    "print(type(mat['CYratioCyt']))\n",
    "\n",
    "# Print the shape of the value corresponding to the key 'CYratioCyt'\n",
    "print(mat['CYratioCyt'].shape)\n",
    "\n",
    "# Subset the array and plot it\n",
    "data = mat['CYratioCyt'][25, 5:]\n",
    "fig = plt.figure()\n",
    "plt.plot(data)\n",
    "plt.xlabel('time (min.)')\n",
    "plt.ylabel('normalized fluorescence (measure of expression)')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Working with relational databases in Python (Module 03-048)**"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Introduction to relational databases**\n",
    "\n",
    "1. What is a relational database?\n",
    "Based on relational model of data\n",
    "First described by Edgar “Ted” Codd\n",
    "\n",
    "2. Example: Northwind database\n",
    "- Orders table\n",
    "- Employees Table\n",
    "- Customers table\n",
    "\n",
    "Tables are linked\n",
    "Primary Key\n",
    "\n",
    "3. Relational model\n",
    "\n",
    "- Widely adopted\n",
    "- Codd’s 12 Rules/Commandments\n",
    "    - Consists of 13 rules (zero-indexed!)\n",
    "    - Describes what a Relational Database Management\n",
    "    System should adhere to to be considered relational\n",
    "\n",
    "4. Relational Database Management Systems\n",
    "- PostgreSQL\n",
    "- MySQL\n",
    "- SQLite\n",
    "- SQL = Structured Query Language"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Creating a database engine in Python**\n",
    "\n",
    "1. Creating a database engine\n",
    "\n",
    "- SQLite database\n",
    "    Fast and simple\n",
    "\n",
    "- SQLAlchemy\n",
    "    Works with many Relational Database Management Systems\n",
    "\n",
    "from sqlalchemy import create_engine\n",
    "engine = create_engine('sqlite:///Northwind.sqlite')\n",
    "\n",
    "2. Getting table names\n",
    "\n",
    "from sqlalchemy import create_engine\n",
    "engine = create_engine('sqlite:///Northwind.sqlite')\n",
    "\n",
    "table_names = engine.table_names()\n",
    "print(table_names)\n",
    "\n",
    "`['Categories', 'Customers', 'EmployeeTerritories',`\n",
    "`'Employees', 'Order Details', 'Orders', 'Products',`\n",
    "`'Region', 'Shippers', 'Suppliers', 'Territories']`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Creating a database engine**\n",
    "\n",
    "Here, you're going to fire up your very first SQL engine. You'll create an engine to connect to the SQLite database '`Chinook.sqlite`', which is in your working directory. Remember that to create an engine to connect to '`Northwind.sqlite`', Hugo executed the command\n",
    "\n",
    "`engine = create_engine('sqlite:///Northwind.sqlite')`\n",
    "\n",
    "Here, '`sqlite:///Northwind.sqlite`' is called the connection string to the SQLite database `Northwind.sqlite`. A little bit of background on the Chinook database: the *Chinook database* contains information about a semi-fictional digital media store in which media data is real and customer, employee and sales data has been manually created.\n",
    "\n",
    "Why the name Chinook, you ask? According to their *website*,\n",
    "\n",
    "    *The name of this sample database was based on the Northwind database. Chinooks are winds in the interior West of North America, where the Canadian Prairies and Great Plains meet various mountain ranges. Chinooks are most prevalent over southern Alberta in Canada. Chinook is a good name choice for a database that intends to be an alternative to Northwind.*\n",
    "\n",
    "STEPS\n",
    "Import the function create_engine from the module sqlalchemy.\n",
    "Create an engine to connect to the SQLite database 'Chinook.sqlite' and assign it to engine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# [[[pip intall sqlalchemy]]]\n",
    "# Import necessary module\n",
    "from sqlalchemy import create_engine\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What are the tables in the database?**\n",
    "\n",
    "In this exercise, you'll once again create an engine to connect to '`Chinook.sqlite'`. Before you can get any data out of the database, however, you'll need to know what tables it contains!\n",
    "\n",
    "To this end, you'll save the table names to a list using the method `table_names()` on the engine and then you will print the list.\n",
    "\n",
    "STEPS\n",
    "    Import the function create_engine from the module sqlalchemy.\n",
    "    Create an engine to connect to the SQLite database 'Chinook.sqlite' and assign it to engine.\n",
    "    Using the method table_names() on the engine engine, assign the table names of 'Chinook.sqlite' to the variable table_names.\n",
    "    Print the object table_names to the shell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Engine(sqlite:///Chinook.sqlite)\n"
     ]
    }
   ],
   "source": [
    "# Import necessary module\n",
    "import sqlite3\n",
    "import pandas as pd\n",
    "from sqlalchemy import create_engine\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite', echo=True)\n",
    "\n",
    "print(engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The file exists.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "if os.path.exists('Chinook.sqlite'):\n",
    "    print(\"The file exists.\")\n",
    "else:\n",
    "    print(\"The file does not exist.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Album', 'Artist', 'Customer', 'Employee', 'Genre', 'Invoice', 'InvoiceLine', 'Track', 'MediaType', 'Playlist', 'PlaylistTrack']\n",
      "Engine(sqlite:///Chinook.sqlite)\n"
     ]
    }
   ],
   "source": [
    "# Import necessary module\n",
    "from sqlalchemy import create_engine\n",
    "from sqlalchemy import MetaData\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "metadata = MetaData()\n",
    "metadata.reflect(bind=engine)\n",
    "\n",
    "table_names = [table.name for table in metadata.tables.values()]\n",
    "\n",
    "print(table_names)\n",
    "\n",
    "print(engine)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Engine' object has no attribute 'table_names'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [18], line 8\u001b[0m\n\u001b[0;32m      5\u001b[0m engine \u001b[39m=\u001b[39m create_engine(\u001b[39m'\u001b[39m\u001b[39msqlite:///Chinook.sqlite\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m      7\u001b[0m \u001b[39m# Save the table names to a list: table_names\u001b[39;00m\n\u001b[1;32m----> 8\u001b[0m table_names \u001b[39m=\u001b[39m engine\u001b[39m.\u001b[39;49mtable_names() \n\u001b[0;32m      9\u001b[0m \u001b[39m# Get: AttributeError: 'Engine' object has no attribute 'table_names'\u001b[39;00m\n\u001b[0;32m     10\u001b[0m \u001b[39m# SADeprecationWarning: The from_engine() method on Inspector is deprecated\u001b[39;00m\n\u001b[0;32m     11\u001b[0m \u001b[39m#  and will be removed in a future release.  Please use the sqlalchemy.inspect()\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     15\u001b[0m \n\u001b[0;32m     16\u001b[0m \u001b[39m# Print the table names to the shell\u001b[39;00m\n\u001b[0;32m     17\u001b[0m \u001b[39mprint\u001b[39m(table_names)\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Engine' object has no attribute 'table_names'"
     ]
    }
   ],
   "source": [
    "# Import necessary module\n",
    "from sqlalchemy import create_engine\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Save the table names to a list: table_names\n",
    "table_names = engine.table_names() \n",
    "# Get: AttributeError: 'Engine' object has no attribute 'table_names'\n",
    "# SADeprecationWarning: The from_engine() method on Inspector is deprecated\n",
    "#  and will be removed in a future release.  Please use the sqlalchemy.inspect()\n",
    "#  function on an Engine or Connection in order to acquire an Inspector. \n",
    "# (deprecated since: 1.4)\n",
    "\n",
    "\n",
    "# Print the table names to the shell\n",
    "print(table_names)\n",
    "\n",
    "# To get a list of declared tables, use accepted answer: metadata.tables.keys()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Querying relational databases in Python**\n",
    "\n",
    "1. Basic SQL query\n",
    "\n",
    "SELECT * FROM Table_Name\n",
    "\n",
    "- Returns all columns of all rows of the table\n",
    "- Example:\n",
    "SELECT * FROM Orders\n",
    "\n",
    "- We’ll use SQLAlchemy and pandas\n",
    "\n",
    "2. Workflow of SQL querying\n",
    "\n",
    "-1- Import packages and functions\n",
    "-2- Create the database engine\n",
    "-3- Connect to the engine\n",
    "-4- Query the database\n",
    "-5- Save query results to a DataFrame\n",
    "-6- Close the connection\n",
    "\n",
    "3. Your first SQL query\n",
    "\n",
    "from sqlalchemy import create_engine\n",
    "import pandas as pd\n",
    "engine = create_engine('sqlite:///Northwind.sqlite')\n",
    "con = engine.connect()\n",
    "\n",
    "rs = con.execute(\"SELECT * FROM Orders\")\n",
    "df = pd.DataFrame(rs.fetchall())\n",
    "con.close()\n",
    "\n",
    "4. Printing your query results\n",
    "print(df.head())\n",
    "\n",
    "5. Set the DataFrame column names\n",
    "\n",
    "from sqlalchemy import create_engine\n",
    "import pandas as pd\n",
    "engine = create_engine('sqlite:///Northwind.sqlite')\n",
    "con = engine.connect()\n",
    "\n",
    "rs = con.execute(\"SELECT * FROM Orders\")\n",
    "df = pd.DataFrame(rs.fetchall())\n",
    "df.columns = rs.keys()\n",
    "con.close()\n",
    "\n",
    "6. Set the data frame column names\n",
    "print(df.head())\n",
    "\n",
    "7. Using the context manager\n",
    "\n",
    "from sqlalchemy import create_engine\n",
    "import pandas as pd\n",
    "engine = create_engine('sqlite:///Northwind.sqlite')\n",
    "\n",
    "with engine.connect() as con:\n",
    "    rs = con.execute(\"SELECT OrderID, OrderDate, ShipName FROM Orders\")\n",
    "    df = pd.DataFrame(rs.fetchmany(size=5))\n",
    "    df.columns = rs.keys()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The Hello World of SQL Queries!**\n",
    "\n",
    "Now, it's time for liftoff! In this exercise, you'll perform the Hello World of SQL queries, SELECT, in order to retrieve all columns of the table Album in the Chinook database. Recall that the query SELECT * selects all columns.\n",
    "\n",
    "STEPS\n",
    "    Open the engine connection as con using the method connect() on the engine.\n",
    "    Execute the query that selects ALL columns from the Album table. Store the results in rs.\n",
    "    Store all of your query results in the DataFrame df by applying the fetchall() method to the results rs.\n",
    "    Close the connection!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   AlbumId                                  Title  ArtistId\n",
      "0        1  For Those About To Rock We Salute You         1\n",
      "1        2                      Balls to the Wall         2\n",
      "2        3                      Restless and Wild         2\n",
      "3        4                      Let There Be Rock         1\n",
      "4        5                               Big Ones         3\n"
     ]
    }
   ],
   "source": [
    "# Import packages\n",
    "from sqlalchemy import create_engine\n",
    "from sqlalchemy import text\n",
    "import pandas as pd\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Open engine connection: con\n",
    "con = engine.connect()\n",
    "\n",
    "# Create an SQL expression: stmt\n",
    "stmt = text(\"SELECT * FROM Album\")\n",
    "\n",
    "# Perform query: rs\n",
    "rs = con.execute(stmt)\n",
    "\n",
    "# Save results of the query to DataFrame: df\n",
    "df = pd.DataFrame(rs.fetchall())\n",
    "\n",
    "# Close connection\n",
    "con.close()\n",
    "\n",
    "# Print head of DataFrame df\n",
    "print(df.head())\n",
    "\n",
    "# Have to import text from sqlalchemy, I was getting an error.\n",
    "# This error is occurring because the statement you are trying \n",
    "# to execute is a plain string, not an SQL expression object. \n",
    "# To fix the issue, you need to use the text() function from \n",
    "# the sqlalchemy package to create the expression."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Customizing the Hello World of SQL Queries**\n",
    "\n",
    "Congratulations on executing your first SQL query! Now you're going to figure out how to customize your query in order to:\n",
    "\n",
    "    Select specified columns from a table;\n",
    "    Select a specified number of rows;\n",
    "    Import column names from the database table.\n",
    "\n",
    "Recall that Hugo performed a very similar query customization in the video:\n",
    "\n",
    "engine = create_engine('sqlite:///Northwind.sqlite')\n",
    "\n",
    "with engine.connect() as con:\n",
    "    rs = con.execute(\"SELECT OrderID, OrderDate, ShipName FROM Orders\")\n",
    "    df = pd.DataFrame(rs.fetchmany(size=5))\n",
    "    df.columns = rs.keys()\n",
    "\n",
    "Packages have already been imported as follows:\n",
    "\n",
    "from sqlalchemy import create_engine\n",
    "import pandas as pd\n",
    "\n",
    "The engine has also already been created:\n",
    "\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "The engine connection is already open with the statement\n",
    "\n",
    "with engine.connect() as con:\n",
    "\n",
    "All the code you need to complete is within this context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "  LastName                Title\n",
      "0    Adams      General Manager\n",
      "1  Edwards        Sales Manager\n",
      "2  Peacock  Sales Support Agent\n"
     ]
    }
   ],
   "source": [
    "from sqlalchemy import create_engine\n",
    "from sqlalchemy import text # Have to import text from sqlalchemy\n",
    "import pandas as pd\n",
    "\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Open engine in context manager\n",
    "# Perform query and save results to DataFrame: df\n",
    "with engine.connect() as con:\n",
    "    stmt = text(\"SELECT LastName, Title FROM Employee\") # Again write query inside text()\n",
    "    rs = con.execute(stmt)\n",
    "    df = pd.DataFrame(rs.fetchmany(size=3))\n",
    "    df.columns = rs.keys()\n",
    "\n",
    "# Print the length of the DataFrame df\n",
    "print(len(df))\n",
    "\n",
    "# Print the head of the DataFrame df\n",
    "print(df.head())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Filtering your database records using SQL's WHERE**\n",
    "\n",
    "You can now execute a basic SQL query to select records from any table in your database and you can also perform simple query customizations to select particular columns and numbers of rows.\n",
    "\n",
    "There are a couple more standard SQL query chops that will aid you in your journey to becoming an SQL ninja.\n",
    "\n",
    "Let's say, for example that you wanted to get all records from the `Customer` table of the Chinook database for which the `Country` is '`Canada`'. You can do this very easily in SQL using a `SELECT` statement followed by a `WHERE` clause as follows:\n",
    "\n",
    "`SELECT * FROM Customer WHERE Country = 'Canada'`\n",
    "\n",
    "In fact, you can filter any `SELECT` statement by any condition using a `WHERE` clause. This is called filtering your records.\n",
    "\n",
    "In this interactive exercise, you'll select all records of the `Employee` table for which `'EmployeeId'` is greater than or equal to `6`.\n",
    "\n",
    "Packages are already imported as follows:\n",
    "\n",
    "`import pandas as pd`\n",
    "`from sqlalchemy import create_engine`\n",
    "\n",
    "Query away!\n",
    "\n",
    "STEPS\n",
    "    Complete the argument of create_engine() so that the engine for the SQLite database 'Chinook.sqlite' is created.\n",
    "    Execute the query that selects all records from the Employee table where 'EmployeeId' is greater than or equal to 6. Use the >= operator and assign the results to rs.\n",
    "    Apply the method fetchall() to rs in order to fetch all records in rs. Store them in the DataFrame df.\n",
    "    Using the rs object, set the DataFrame's column names to the corresponding names of the table columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   EmployeeId  LastName FirstName       Title  ReportsTo            BirthDate  \\\n",
      "0           6  Mitchell   Michael  IT Manager          1  1973-07-01 00:00:00   \n",
      "1           7      King    Robert    IT Staff          6  1970-05-29 00:00:00   \n",
      "2           8  Callahan     Laura    IT Staff          6  1968-01-09 00:00:00   \n",
      "\n",
      "              HireDate                      Address        City State Country  \\\n",
      "0  2003-10-17 00:00:00         5827 Bowness Road NW     Calgary    AB  Canada   \n",
      "1  2004-01-02 00:00:00  590 Columbia Boulevard West  Lethbridge    AB  Canada   \n",
      "2  2004-03-04 00:00:00                  923 7 ST NW  Lethbridge    AB  Canada   \n",
      "\n",
      "  PostalCode              Phone                Fax                    Email  \n",
      "0    T3B 0C5  +1 (403) 246-9887  +1 (403) 246-9899  michael@chinookcorp.com  \n",
      "1    T1K 5N8  +1 (403) 456-9986  +1 (403) 456-8485   robert@chinookcorp.com  \n",
      "2    T1H 1Y8  +1 (403) 467-3351  +1 (403) 467-8772    laura@chinookcorp.com  \n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sqlalchemy import create_engine\n",
    "from sqlalchemy import text # Have to import text from sqlalchemy\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Open engine in context manager\n",
    "# Perform query and save results to DataFrame: df\n",
    "with engine.connect() as con:\n",
    "    stmt = text(\"SELECT * FROM Employee WHERE EmployeeId >= 6\") # Again write query inside text()\n",
    "    rs = con.execute(stmt)\n",
    "    df = pd.DataFrame(rs.fetchmany(100))\n",
    "    df.columns = rs.keys()\n",
    "\n",
    "# Print the head of the DataFrame df\n",
    "print(df.head())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ordering your SQL records with ORDER BY**\n",
    "\n",
    "You can also order your SQL query results. For example, if you wanted to get all records from the `Customer` table of the Chinook database and order them in increasing order by the column `SupportRepId`, you could do so with the following query:\n",
    "\n",
    "`\"SELECT * FROM Customer ORDER BY SupportRepId\"`\n",
    "\n",
    "In fact, you can order any `SELECT` statement by any column.\n",
    "\n",
    "In this interactive exercise, you'll select all records of the `Employee` table and order them in increasing order by the column `BirthDate`.\n",
    "\n",
    "Packages are already imported as follows:\n",
    "\n",
    "`import pandas as pd`\n",
    "`from sqlalchemy import create_engine`\n",
    "\n",
    "Get querying!\n",
    "\n",
    "STEPS\n",
    "    Using the function create_engine(), create an engine for the SQLite database Chinook.sqlite and assign it to the variable engine.\n",
    "    In the context manager, execute the query that selects all records from the Employee table and orders them in increasing order by the column BirthDate. Assign the result to rs.\n",
    "    In a call to pd.DataFrame(), apply the method fetchall() to rs in order to fetch all records in rs. Store them in the DataFrame df.\n",
    "    Set the DataFrame's column names to the corresponding names of the table columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   EmployeeId  LastName FirstName                Title  ReportsTo  \\\n",
      "0           4      Park  Margaret  Sales Support Agent        2.0   \n",
      "1           2   Edwards     Nancy        Sales Manager        1.0   \n",
      "2           1     Adams    Andrew      General Manager        NaN   \n",
      "3           5   Johnson     Steve  Sales Support Agent        2.0   \n",
      "4           8  Callahan     Laura             IT Staff        6.0   \n",
      "\n",
      "             BirthDate             HireDate              Address        City  \\\n",
      "0  1947-09-19 00:00:00  2003-05-03 00:00:00     683 10 Street SW     Calgary   \n",
      "1  1958-12-08 00:00:00  2002-05-01 00:00:00         825 8 Ave SW     Calgary   \n",
      "2  1962-02-18 00:00:00  2002-08-14 00:00:00  11120 Jasper Ave NW    Edmonton   \n",
      "3  1965-03-03 00:00:00  2003-10-17 00:00:00         7727B 41 Ave     Calgary   \n",
      "4  1968-01-09 00:00:00  2004-03-04 00:00:00          923 7 ST NW  Lethbridge   \n",
      "\n",
      "  State Country PostalCode              Phone                Fax  \\\n",
      "0    AB  Canada    T2P 5G3  +1 (403) 263-4423  +1 (403) 263-4289   \n",
      "1    AB  Canada    T2P 2T3  +1 (403) 262-3443  +1 (403) 262-3322   \n",
      "2    AB  Canada    T5K 2N1  +1 (780) 428-9482  +1 (780) 428-3457   \n",
      "3    AB  Canada    T3B 1Y7   1 (780) 836-9987   1 (780) 836-9543   \n",
      "4    AB  Canada    T1H 1Y8  +1 (403) 467-3351  +1 (403) 467-8772   \n",
      "\n",
      "                      Email  \n",
      "0  margaret@chinookcorp.com  \n",
      "1     nancy@chinookcorp.com  \n",
      "2    andrew@chinookcorp.com  \n",
      "3     steve@chinookcorp.com  \n",
      "4     laura@chinookcorp.com  \n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sqlalchemy import create_engine\n",
    "from sqlalchemy import text # Have to import text from sqlalchemy\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Open engine in context manager\n",
    "with engine.connect() as con:\n",
    "    stmt = text(\"SELECT * FROM Employee ORDER BY BirthDate\") # Again write query inside text()\n",
    "    rs = con.execute(stmt)\n",
    "    df = pd.DataFrame(rs.fetchmany(100))\n",
    "\n",
    "    # Set the DataFrame's column names\n",
    "    df.columns = rs.keys()\n",
    "\n",
    "# Print head of DataFrame\n",
    "print(df.head())\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Querying relational databases directly with pandas**\n",
    "\n",
    "1. The pandas way to query\n",
    "\n",
    "from sqlalchemy import create_engine\n",
    "import pandas as pd\n",
    "engine = create_engine('sqlite:///Northwind.sqlite')\n",
    "with engine.connect() as con:\n",
    "rs = con.execute(\"SELECT * FROM Orders\")\n",
    "df = pd.DataFrame(rs.fetchall())\n",
    "df.columns = rs.keys()\n",
    "\n",
    "\n",
    "df = pd.read_sql_query(\"SELECT * FROM Orders\", engine)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pandas and The Hello World of SQL Queries!**\n",
    "\n",
    "Here, you'll take advantage of the power of `pandas` to write the results of your SQL query to a DataFrame in one swift line of Python code!\n",
    "\n",
    "You'll first import `pandas` and create the SQLite '`Chinook.sqlite`' engine. Then you'll query the database to select all records from the `Album` table.\n",
    "\n",
    "Recall that to select all records from the `Orders` table in the Northwind database, Hugo executed the following command:\n",
    "\n",
    "`df = pd.read_sql_query(\"SELECT * FROM Orders\", engine)`\n",
    "\n",
    "STEPS\n",
    "    Import the pandas package using the alias pd.\n",
    "    Using the function create_engine(), create an engine for the SQLite database Chinook.sqlite and assign it to the variable engine.\n",
    "    Use the pandas function read_sql_query() to assign to the variable df the DataFrame of results from the following query: select all records from the table Album.\n",
    "    The remainder of the code is included to confirm that the DataFrame created by this method is equal to that created by the previous method that you learned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   AlbumId                                  Title  ArtistId\n",
      "0        1  For Those About To Rock We Salute You         1\n",
      "1        2                      Balls to the Wall         2\n",
      "2        3                      Restless and Wild         2\n",
      "3        4                      Let There Be Rock         1\n",
      "4        5                               Big Ones         3\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Import packages\n",
    "from sqlalchemy import create_engine\n",
    "import pandas as pd\n",
    "from sqlalchemy import text # Have to import text from sqlalchemy\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Create a connection object: conn\n",
    "#Have to create conection, pd.read_sql_query do not work without it\n",
    "conn = engine.connect() \n",
    "\n",
    "# Create an SQL expression: stmt\n",
    "stmt = text('SELECT * FROM Album')\n",
    "\n",
    "# Execute query and store records in DataFrame: df\n",
    "df = pd.read_sql_query(stmt, conn)\n",
    "\n",
    "# Close connection\n",
    "conn.close()\n",
    "\n",
    "# Print head of DataFrame\n",
    "print(df.head())\n",
    "\n",
    "# Open engine in context manager and store query result in df1\n",
    "with engine.connect() as con:\n",
    "    stmt = text(\"SELECT * FROM Album\") # Again write query inside text()\n",
    "    rs = con.execute(stmt)\n",
    "    df1 = pd.DataFrame(rs.fetchall())\n",
    "    df1.columns = rs.keys()\n",
    "\n",
    "# Confirm that both methods yield the same result\n",
    "print(df.equals(df1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   AlbumId                                  Title  ArtistId\n",
      "0        1  For Those About To Rock We Salute You         1\n",
      "1        2                      Balls to the Wall         2\n",
      "2        3                      Restless and Wild         2\n",
      "3        4                      Let There Be Rock         1\n",
      "4        5                               Big Ones         3\n"
     ]
    }
   ],
   "source": [
    "#Another way to do it it's by incluiding pd.read_sql_query in a Context Manager\n",
    "\n",
    "# Import packages\n",
    "from sqlalchemy import create_engine\n",
    "import pandas as pd\n",
    "from sqlalchemy import text # Have to import text from sqlalchemy\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Create a connection object: conn\n",
    "stmt = text('SELECT * FROM Album') # Again write query inside text()\n",
    "\n",
    "with engine.connect() as conn:\n",
    "    df = pd.read_sql_query(stmt, conn)\n",
    "\n",
    "# Print head of DataFrame\n",
    "print(df.head()) "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pandas for more complex querying**\n",
    "\n",
    "Here, you'll become more familiar with the pandas function read_sql_query() by using it to execute a more complex query: a SELECT statement followed by both a WHERE clause AND an ORDER BY clause.\n",
    "\n",
    "You'll build a DataFrame that contains the rows of the Employee table for which the EmployeeId is greater than or equal to 6 and you'll order these entries by BirthDate.\n",
    "\n",
    "STEPS\n",
    "    Using the function create_engine(), create an engine for the SQLite database Chinook.sqlite and assign it to the variable engine.\n",
    "    Use the pandas function read_sql_query() to assign to the variable df the DataFrame of results from the following query: select all records from the Employee table where the EmployeeId is greater than or equal to 6 and ordered by BirthDate (make sure to use WHERE and ORDER BY in this precise order)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   EmployeeId  LastName FirstName       Title  ReportsTo            BirthDate  \\\n",
      "0           8  Callahan     Laura    IT Staff          6  1968-01-09 00:00:00   \n",
      "1           7      King    Robert    IT Staff          6  1970-05-29 00:00:00   \n",
      "2           6  Mitchell   Michael  IT Manager          1  1973-07-01 00:00:00   \n",
      "\n",
      "              HireDate                      Address        City State Country  \\\n",
      "0  2004-03-04 00:00:00                  923 7 ST NW  Lethbridge    AB  Canada   \n",
      "1  2004-01-02 00:00:00  590 Columbia Boulevard West  Lethbridge    AB  Canada   \n",
      "2  2003-10-17 00:00:00         5827 Bowness Road NW     Calgary    AB  Canada   \n",
      "\n",
      "  PostalCode              Phone                Fax                    Email  \n",
      "0    T1H 1Y8  +1 (403) 467-3351  +1 (403) 467-8772    laura@chinookcorp.com  \n",
      "1    T1K 5N8  +1 (403) 456-9986  +1 (403) 456-8485   robert@chinookcorp.com  \n",
      "2    T3B 0C5  +1 (403) 246-9887  +1 (403) 246-9899  michael@chinookcorp.com  \n"
     ]
    }
   ],
   "source": [
    "# Import packages\n",
    "from sqlalchemy import create_engine\n",
    "from sqlalchemy import text\n",
    "import pandas as pd\n",
    "\n",
    "# Create engine: engine\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Create a connection object: conn\n",
    "conn = engine.connect() \n",
    "\n",
    "# Create an SQL expression: stmt\n",
    "stmt = text('SELECT * FROM Employee WHERE EmployeeId >= 6 ORDER BY BirthDate')\n",
    "\n",
    "# Execute query and store records in DataFrame: df\n",
    "df = pd.read_sql_query(stmt, conn)\n",
    "\n",
    "# Close connection\n",
    "conn.close()\n",
    "\n",
    "# Print head of DataFrame\n",
    "print(df.head())\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Advanced querying: exploiting table relationships**\n",
    "\n",
    "1. Tables are linked\n",
    "\n",
    "2. JOINing tables\n",
    "\n",
    "3. INNER JOIN in Python (pandas)\n",
    "\n",
    "from sqlalchemy import create_engine\n",
    "import pandas as pd\n",
    "\n",
    "engine = create_engine('sqlite:///Northwind.sqlite')\n",
    "\n",
    "df = pd.read_sql_query(\"SELECT OrderID, CompanyName FROM Orders\n",
    "INNER JOIN Customers on Orders.CustomerID = Customers.CustomerID\", engine)\n",
    "\n",
    "print(df.head())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The power of SQL lies in relationships between tables: INNER JOIN**\n",
    "\n",
    "Here, you'll perform your first `INNER JOIN`! You'll be working with your favourite SQLite database, `Chinook.sqlite`. For each record in the `Album` table, you'll extract the `Title` along with the `Name` of the `Artist`. The latter will come from the `Artist` table and so you will need to `INNER JOIN` these two tables on the `ArtistID` column of both.\n",
    "\n",
    "Recall that to `INNER JOIN` the `Orders` and `Customers` tables from the Northwind database, Hugo executed the following SQL query:\n",
    "\n",
    "`\"SELECT OrderID, CompanyName FROM Orders INNER JOIN Customers on Orders.CustomerID = Customers.CustomerID\"`\n",
    "\n",
    "The following code has already been executed to import the necessary packages and to create the engine:\n",
    "\n",
    "`import pandas as pd`\n",
    "`from sqlalchemy import create_engine`\n",
    "`engine = create_engine('sqlite:///Chinook.sqlite')`\n",
    "\n",
    "STEPS\n",
    "    Assign to rs the results from the following query: select all the records, extracting the Title of the record and Name of the artist of each record from the Album table and the Artist table, respectively. To do so, INNER JOIN these two tables on the ArtistID column of both.\n",
    "    In a call to pd.DataFrame(), apply the method fetchall() to rs in order to fetch all records in rs. Store them in the DataFrame df.\n",
    "    Set the DataFrame's column names to the corresponding names of the table columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                   Title       Name\n",
      "0  For Those About To Rock We Salute You      AC/DC\n",
      "1                      Balls to the Wall     Accept\n",
      "2                      Restless and Wild     Accept\n",
      "3                      Let There Be Rock      AC/DC\n",
      "4                               Big Ones  Aerosmith\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sqlalchemy import create_engine\n",
    "from sqlalchemy import text\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Open engine in context manager\n",
    "# Perform query and save results to DataFrame: df\n",
    "with engine.connect() as con:\n",
    "    stmt = text('SELECT Title, Name FROM Album INNER JOIN Artist on Album.ArtistID = Artist.ArtistID')\n",
    "    rs = con.execute(stmt)\n",
    "    df = pd.DataFrame(rs.fetchall())\n",
    "    df.columns = rs.keys()\n",
    "\n",
    "# Print head of DataFrame df\n",
    "print(df.head())\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Filtering your INNER JOIN**\n",
    "\n",
    "Congrats on performing your first `INNER JOIN`! You're now going to finish this chapter with one final exercise in which you perform an `INNER JOIN` and filter the result using a `WHERE` clause.\n",
    "\n",
    "Recall that to `INNER JOIN` the `Orders` and `Customers` tables from the Northwind database, Hugo executed the following SQL query:\n",
    "\n",
    "\"`SELECT OrderID, CompanyName FROM Orders INNER JOIN Customers on Orders.CustomerID = Customers.CustomerID`\"\n",
    "\n",
    "The following code has already been executed to import the necessary packages and to create the engine:\n",
    "\n",
    "`import pandas as pd`\n",
    "`from sqlalchemy import create_engine`\n",
    "`engine = create_engine('sqlite:///Chinook.sqlite')`\n",
    "\n",
    "STEPS\n",
    "Use the pandas function read_sql_query() to assign to the variable df the DataFrame of results from the following query: select all records from PlaylistTrack INNER JOIN Track on PlaylistTrack.TrackId = Track.TrackId that satisfy the condition Milliseconds < 250000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   PlaylistId  TrackId  TrackId              Name  AlbumId  MediaTypeId  \\\n",
      "0           1     3390     3390  One and the Same      271            2   \n",
      "1           1     3392     3392     Until We Fall      271            2   \n",
      "2           1     3393     3393     Original Fire      271            2   \n",
      "3           1     3394     3394       Broken City      271            2   \n",
      "4           1     3395     3395          Somedays      271            2   \n",
      "\n",
      "   GenreId Composer  Milliseconds    Bytes  UnitPrice  \n",
      "0       23     None        217732  3559040       0.99  \n",
      "1       23     None        230758  3766605       0.99  \n",
      "2       23     None        218916  3577821       0.99  \n",
      "3       23     None        228366  3728955       0.99  \n",
      "4       23     None        213831  3497176       0.99  \n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sqlalchemy import create_engine\n",
    "from sqlalchemy import text\n",
    "engine = create_engine('sqlite:///Chinook.sqlite')\n",
    "\n",
    "# Create a connection object: conn\n",
    "stmt = text('SELECT * FROM PlaylistTrack INNER JOIN Track on PlaylistTrack.TrackId = Track.TrackId WHERE Milliseconds < 250000')\n",
    "\n",
    "# Execute query and store records in DataFrame: df\n",
    "with engine.connect() as conn:\n",
    "    df = pd.read_sql_query(stmt, conn)\n",
    "\n",
    "# Print head of DataFrame\n",
    "print(df.head())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Final Thoughts**\n",
    "\n",
    "1. What you’ve learned:\n",
    "Relational databases\n",
    "Queries\n",
    "SELECT\n",
    "WHERE\n",
    "JOIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "END\n"
     ]
    }
   ],
   "source": [
    "print('END')"
   ]
  }
 ],
 "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.10.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}