notebooks/Mini-Tutorial Git Log Analysis with Python and Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "This notebook is a simple mini-tutorial to introduce you to basic functions of Jupyter, Python, Pandas and matplotlib with the aim of analyzing software data. Therefore, the example is chosen in such a way that we come across the typical methods in a data analysis. Have fun!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Jupyter Notebook System\n",
    "First, we'll take a closer look at Jupyter Notebook. What you see here is Jupyter, the interactive notebook environment for programming. We see below a cell in which we can enter Python code. Let's just type in a string called `\"Hello World\"` here. With the key combination `Ctrl` + `Enter` we can execute this cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is immediately visible under the cell. Let's create another cell! This works by pressing the `ESC` key followed by the letter `b`. Alternatively, at the end of a notebook, we can run a cell with `Shift` + `Enter` and create a new cell right away.\n",
    "\n",
    "Here we see an important feature of Jupyter: The distinction between command mode (accessible via the `Esc` key) and input mode (accessible via the `Enter` key). In command mode, the border of the current cell is blue. In input mode, the border turns green. Let's go to the command mode and press `m`. This changes the cell type to a markdown cell. Markdown is a simple markup language that can be used to write and format texts. This allows us to directly document the steps we have taken."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A quick Introduction to Python\n",
    "Let's take a look at some basic Python programming constructs that we will need later when working with Pandas.\n",
    "\n",
    "First, we save our text \"Hello World\" into to a variable called `text` by assigning it with the `=` symbol. We write `text` again in the row below, execute the cell and see the result displayed under the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World!'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"Hello World!\"\n",
    "text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By using the array notation with the square brackets `[` and `]`, we can access the first letter of our text with a 0-based index (this also works for other types like lists)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can output the last letter with a `[-1]` as selector because negative numbers in parentheses represent the indexing from behind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'!'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also work with so-called \"slices\". This allows us to output any range of values from the content in our `text` variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'llo'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following slice `[:-1]` is an abbreviation for a 0-based slice `[0:-1]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we take a look at how to reverse a text (or even a list). This works with the `::` notation and the specification of `-1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'!dlroW olleH'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can explore the further functionality of a library (or an object stored in a variable) by looking at the methods and attributes of a class or object. When we write the beginning of a command, like `text.` in our string example, we can use the integrated autocompletion of Jupyter with the tab key `Tab` to see which methods the currently used object offers. We can then select a method that we want with the arrow key `down` or narrowing our search by pressing e.g. the first letters of `upper`. If we press `Enter` on the selected item and then `Shift`+ `Tab`, the signature of the corresponding functionality and the section of the help documentation appears. Pressing `Shift` + `Tab` twice will display the full help. So in our case, by calling `upper()` on our `text` variable, we can have our text written in capital letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function str.upper>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text.upper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The interactive source code documentation also helps us to find out which arguments we can add in a method in addition to the obligate parameters. This can be easily observed when using the `split` method on our `text` variable and the integrated help functionality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'World!']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text.split(maxsplit=2, sep=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Git history analysis\n",
    "OK, let's start the analysis!\n",
    "\n",
    "In this notebook, we want to take a closer look at the development history of the open source project \"Linux\" based on the history of the corresponding GitHub mirror repository.\n",
    "\n",
    "A local clone of the GitHub repository https://github.com/torvalds/linux/ was created by using the command  \n",
    "\n",
    "```\n",
    "git clone https://github.com/torvalds/linux.git\n",
    "```\n",
    "\n",
    "The relevant parts of the history for this analysis were produced by using\n",
    "\n",
    "```\n",
    "git log --pretty=\"%ad,%aN\" --no-merges > git_demo_timestamp_linux.csv\n",
    "```\n",
    "\n",
    "This command returned the commit timestamp (`%ad`) and the author name (`%aN`) for each commit of the Git repository. The corresponding values are separated by commas. We also indicated that we do not want to receive merge commits (via `--no-merges`). The result of the output was saved in the file `git_demo_timestamp_linux.csv`.\n",
    "\n",
    "_Note: For an optimized demo, headers and the separator has been changed manually in the provided dataset to get through this analysis more easily. The differences can be seen at https://www.feststelltaste.de/developers-habits-linux-edition/, which was done with the original dataset._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting to know Pandas\n",
    "Pandas is a data analysis tool written in Python (and partly in C), which is ideally suited for the evaluation of tabular data due to the use of effective data structures and built-in statistics functions.\n",
    "\n",
    "## Basics\n",
    "\n",
    "We import the data from above with the help of Pandas. We import `pandas` with the common abbreviation `pd` using the `import... as..` syntax of Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check whether the import of the module really worked by checking the documentation of the `pd` module. To do this, we append the `?` operator to the `pd` variable and execute the cell. The documentation of the module appears in the lower part of the browser window. We can read through this area and make it disappear again with the `ESC` key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We read the compressed CSV file `git_demo_timestamp_linux.gz` with the `read_csv()` method and the parameter `URL` which defines the location of the file. Since the file is a `gzip`-packed file and we get this file over the web, we have to specify the used compression algorithm using `compression='gzip'`. \n",
    "\n",
    "The result of our execution is stored in the variable `git_log`. We've just loaded data into a so-called **DataFrame** (something like a programmable Excel worksheet), which in our case consists of two **Series** (= columns). \n",
    "\n",
    "We can now perform operations on the DataFrame. For example, we can use `head()` to display the first five entries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>timestamp</th>\n",
       "      <th>author</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2017-12-31 14:47:43</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2017-12-31 13:13:56</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2017-12-31 13:03:05</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2017-12-31 12:30:34</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2017-12-31 12:29:02</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             timestamp          author\n",
       "0  2017-12-31 14:47:43  Linus Torvalds\n",
       "1  2017-12-31 13:13:56  Linus Torvalds\n",
       "2  2017-12-31 13:03:05  Linus Torvalds\n",
       "3  2017-12-31 12:30:34  Linus Torvalds\n",
       "4  2017-12-31 12:29:02  Linus Torvalds"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "URL = \"https://raw.githubusercontent.com/feststelltaste/software-analytics/master/demos/dataset/git_demo_timestamp_linux.gz\"\n",
    "git_log = pd.read_csv(URL, compression=\"gzip\")\n",
    "git_log.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we call `info()` on the `DataFrame` to get some basic data about the read in data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 723214 entries, 0 to 723213\n",
      "Data columns (total 2 columns):\n",
      "timestamp    723214 non-null object\n",
      "author       723213 non-null object\n",
      "dtypes: object(2)\n",
      "memory usage: 11.0+ MB\n"
     ]
    }
   ],
   "source": [
    "git_log.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the individual Series / columns by using the `['<column name>']` or (in most cases, i.e. as long as the column names do not overlap with the method name offered by the `DataFrame` itself) by directly using the name of the `Series`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    Linus Torvalds\n",
       "1    Linus Torvalds\n",
       "2    Linus Torvalds\n",
       "3    Linus Torvalds\n",
       "4    Linus Torvalds\n",
       "Name: author, dtype: object"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "git_log.author.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also perform various operations on a `Series`. For example, with `value_counts()`, we can count the values contained in a `Series` and let them sort according to their frequency. The result is again a `Series`, but this time with the totaled and sorted values. We can additionally call `head(10)` on this `Series`. This gives us a quick way to display the TOP-10 values of a `Series`. We can then record the result in a variable `top10` and output it by writing the variable to the next cell row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Linus Torvalds           24259\n",
       "David S. Miller           9563\n",
       "Mark Brown                6917\n",
       "Takashi Iwai              6293\n",
       "Al Viro                   6064\n",
       "H Hartley Sweeten         5942\n",
       "Ingo Molnar               5462\n",
       "Mauro Carvalho Chehab     5384\n",
       "Arnd Bergmann             5305\n",
       "Greg Kroah-Hartman        4687\n",
       "Name: author, dtype: int64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top10 = git_log.author.value_counts().head(10)\n",
    "top10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First visualizations\n",
    "Next, we want to visualize or plot the result. To display the plotting result of the internally used plotting library `matplotlib` directly in the notebook, we have to execute this magic command in our notebook\n",
    "\n",
    "```\n",
    "%matplotlib inline\n",
    "```\n",
    "\n",
    "before calling the `plot()` method.\n",
    "\n",
    "By default, when `plot()` is called on a `DataFrame` or `Series`, a line chart is created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x26fec3f0160>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x26feb9c92e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "top10.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That doesn't make much sense here, so we use a sub-method of `plot` called `bar()` to create a bar chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x26fec48d550>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x26fec27d0b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "top10.plot.bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This data can also be visualized as a pie chart. For this, we call the `pie()` method instead of `bar()`. We can also add a semicolon `;` after the `plot` command to avoid printing the text of the reference. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdIAAADuCAYAAACNr4ZUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xd8U9f5+PHPI1leGGT2MmBmMGAwI2wImGwym9W0TZO2SZqWNl1pStvvt1W/7a+lbbqbhGaTNM1Os5xmNIS9N0lMmGYTto3BlmTp+f1xrxPH8ZIt6UrmvF8vv7Cke+95DEaPzrnnPEdUFcMwDMMwmsfldACGYRiGkcxMIjUMwzCMFjCJ1DAMwzBawCRSwzAMw2gBk0gNwzAMowVMIjUMwzCMFjCJ1DAMwzBawCRSwzAMw2gBk0gNwzAMowVMIjUMwzCMFjCJ1DAMwzBawCRSwzAMw2gBk0gNwzAMowVMIjUMwzCMFjCJ1DAMwzBawCRSwzAMw2gBk0gNwzAMowVMIjUMwzCMFjCJ1DAMwzBawCRSwzAMw2gBk0gNwzAMowVMIjUMwzCMFjCJ1DAMwzBawCRSwzAMw2gBk0gNwzAMowVMIjUMwzCMFjCJ1DAMwzBawCRSwzAMw2gBk0gNwzAMowVMIjUMwzCMFkhxOgDDSFS5s4vcQLb91b7Gn5lAGAgBVfaftb9v6LUK4BhwvGTOTI3fT2QYRiyIqvl/bJwdcmcXdQEGAH2Bjnw6OdaVMLMAiWFIIeAEcLTW10fAAWC//XUAOFQyZ2Y4hrEYhtFMJpEarUru7KJOwECshDmwxtcAwOtgaC0VAg5hJdadwPvAe/bXTpNkDcM5JpEaSSd3dlFbYAh1J8xsB0NzyhmgGCupbrb/fK9kzsz9jkZlGGcJk0iNhJY7uygFGA6MBcbZX+dgJso1xQk+3XN9D9hUMmfmCUejMoxWxiRSI7H4vJ2BKbMCdw4pCo+/GBgFZDgcVWuiWAl1vv21sGTOzFJnQ2qYiJSralat5+4Azqjq4zFo76fAdfbDfKxePsAjqvrXaLdnt3krMExVv1vr+RTgqKqejSMtScMkUsNZPm8fYKr9NQWrt8kJzdow0v9AgZOhnSVCwFo+SaxLSubMrHA2pE+rK5EmctsikqKqVRGeYxJpEjOJ1Igvn9cNTAQut78G13fo9wLfWPPv8JQx8QrNACAArOCTxLqiZM7MoJMB1dMj9QHlqnqPiCwAVgLTse6Rf01VF4vILcAYVf2Wfc5rwD3AYuBhYAxWD/0RVf1TU9oWkb7AI1izvj8CvqKq+0Tkn/bjUcAa4HogX1XLRESAHVi3JyYBPwFSgSPAl1T1cM1EKiL9gX9h3b54E/iWqmaLSE/gGazZ5CnA7aq6rHl/q0Y0mXWkRuz5vNnAxcBlwCVAh6ac9mvPw+1e8k8KKy5zPzR+UvlkhMAHnM6dXbQUK6m+UTJn5kYHY2tIiqqOFZFLgZ8D5zdwbAHQU1WHAYhIJL29+4CHVPVJEbkd+DNwrf1af2CGqoZFJBO4EngC64PjVlU9KiKLgFdUVe3h6R8AP6rVxt+Av6jqv0TkOzWe/xLwqqr+VkTcmFseCcMkUiM2fN6BWD3Oy7CGbCP+XcuQwKBvul9Zcm/oqsnRDs9osjbAhfbXnNzZRcXAU8C/SubM3OFoZJ/2ov3nWiC3kWN3Av1E5G9AEfBWBO2Mw/qdBngc+GWN155T1eplSM8Ad2Ml0s/bjwF6A8+KSDcgDdhaRxsTsP7vYJ//C/v71cA/RCQdeElVE/VDzVnHfNI3osfnHYjP+yt83i1YbxB/wBpua/YHtu+lPN83laA/WiEaLZYH/B+wPXd20Yrc2UV35s4u6up0UED170iIT37fqvj0e1w6gKqeAEYAC4BZwENRiuF0je8XA0NEpCNwBfBv+/l7gT+paj7wzeqYalH769NPqs4HpgEHgSdF5ItRittooaRKpCISEpENIvK+iGwUke+LSLN+BhEZIyJ1zsATkRIR6VTH818Vkc0isklE3hORKxtpY5qIqIh8rcZzI+3n7rIf/5+InG9/v0BExjQUQ8Lxedvi834Nn3cJVvL8KfaEoWhIkXDPn6fMWxGt6xlRNQ74C7A/d3bRm7mzi2621/gmihKgQERcItIL6x4l9v8rl6q+APwv1n3NplqBdf8TrKHWRXUdpNbkk5exhn43qupJ+yUvsN++b3pzE9r4OFmKSB/gkKo+ADwGjIwgbiOGkm1ot0JVCwBEpAvWDXkv1j2RiKjqGqxJAU0iIjlYSWKUqpaKSBbQuQmnbgZuwJrcANYwz8dDMqr6syYH3XB8blUNReNajfJ5Baun+RXgc1i1Z2PmRvf84b+t+nxpGVnJXJmoNXPzyfDv3NzZRa9h/d98vWTOzGiMJmSKyL4aj//YxPOWArv4pEjFOvv5nsCjNT6E/ziCWL4FPCwiP8aebNTAsc8Ay7ESbjUfVu90H7AK6F7HeXdi9Ti/zyc9WYAZwPdFJAiU17qu4aCkmrVbxwy6flj3DToBfbDuJ7SxX/6Wqi4TkWeAear6un3OY8CrWEXD71LVy+zhl6ewEuMqrIkxo1X1aI22RmHN1hvd1IQlItOAu4B2WOvSDgMbgNeBY/aMw8eA11T1eXv24V2qukZESrBmHB4VkS9h/edKxZqd+E1VDYlIOdabykXAD1R1SRP/KpvH5+0L3IL1SbpPTNuqZX6oYOFXg3efF882jRY7CbwAzCuZM3Ox08EYRqwk1dBubaq6E+tn6IKVpC5Q1VFYPcDqYdun7ceISCrWp7rXa13q58ASVR0JvII1IaC2jVifQHeJyKMicnkdx9TneaxEOhHrU3GTP6WLSJ4d/yS7Nx7ik+GeNsB7qjouZknU53Xh816Lz7sAawr/z4hzEgWY7towtgdHD8a7XaNFsoGvAYtyZxetzZ1ddFPu7CKP00EZRrQldSK1Ve/O4QEeFJHNwHNYtVgB/gMUikga1tKLRapae8H5VOCfAKpahFVa7VPsXujFWFPdtwJ/steyNcWzWIn0RqyebyRmAKOB1SKywX7cz34thPWJP/p83nR83juAD7H+Ps8jtjuhNEiEjH+k/nG7U+0bLTYKa5br7tzZRT/NnV3U0emADCNakjqR2kO7Iaze6PeweowjsBZapwKoaiXW7LyLsHp2T9dzuUbHuNWySlV/g3Wv85qmxKmqh4AgcAHwTlPOqUGwhqYL7K9zVNVnv1YZ9fuiPm97fN6fYk3UuB+rKHxCGCYlE4dISSItuTAi1x34FbA3d3bRP3JnFw10OiDDaKmkTaQi0hmYC/zdniHnBQ7a67huwpoAUe1prEkBU7AqhdS2CHu4VEQuwdqLsnZ7Pez7pNUKgN0RhPwz4EfNSHzvANfak6sQkQ727L3o8nlz8Hn/COzBeqNLhCUNnyKC+4HUPx5zOg4jKjKA24EtubOLns6dXTTc6YAMo7mSbdZuhj286cFaI/YEn8zguw94QUSuA97l02u63sIaVnpFVQN1XPcXwFMisg5YiJVMavMA94hID6ASq7zXHfBxAW1UdW59gTe3lJeqfiAi/wO8Zc8yDGKtfYskidfP5x2KtXD8RqyfMaHlyNGxU10bNy0KjzBvvK2DC2uk6Hp7tu//K5kzc6XDMRlGRJJq1q4RRT7vOcCvgatx8N5nc5Rq5uYR/ofynY7DiJn5wC9K5sysc42mYSQak0jPNj5vN6y1bF8j+UYkPvbj4NdWPRWaMdbpOIyYeg74QcmcmXudDsQwGmIS6dnC580CfohVJLtNI0cnPL96duT5H80N43I3frSRxM4AvwF+H6XiDoYRdUk72choIp9X8Hm/jLWM5We0giQKkCbB/t9Pec5sIdX6ZWIVhv8gd3ZRgyU5DcMppkfamvm8Y7FqoY53OpRYCKkcGup/xFtJmtlO6uzxJvCdkjkzP3Q6EMOoZhJpa+TzdsDaeeVmkmwiUaReCE1Z+IPgN0zpwLNLEOsD4v+VzJl5yulgDMMk0tbG570MeBDo5nQo8aBK6Sj/3NAJ2jVps3CjVTkIzAaeKJkz07yRGY4x90hbC5+3HT7vo1gF+c+KJAoggvfvnr9tdjoOwxHdgXnAElPQwXCSSaStgc87A2urqFscjsQRE13vj+8tH+1r/EijlZoIrMqdXfQtpwMxzk5maDeZ+bxtgN8B36CV3wttzIfhnKUXBX43yek4DMe9DHy1ZM7M404HYpw9TI80Wfm8k7D2Nv0mZ3kSBRgk+yYUyHYzk9O4EtiQO7toitOBGGcP0yNNNj6vC6uo/I8wH4Q+5SPNXjPOf98Yp+MwEkIIa/3pL0vmzAw7HYzRupk34mTi83qB14AfY/7tPqOrnBxzoWv1eqfjMBKCG6sU5ju5s4t6OhyL0cqZN+Nk4fMOBFZgbU5u1OOPnvvTwAyzGB+bBmzMnV10odOBGK2XSaTJwOe9EFgFDHY6lESXJZVDbnG/ucLpOIyE0hF4PXd20SynAzFaJ3OPNNH5vN8Dfs+nNyo3GhBQ9+4h/kd7VJGS8PurGnF3L1aJwZDTgRith+mRJiqfNxWf9xGsjctNEo1AqoT6/Cjl6eVOx2EkpFlAUe7sonZOB2K0HqZHmoh83i7Av7EWmhvNEFI5Mtz/UMZpMrKcjsVISB8Al5TMmbnH6UCM5Gd6pInG2nh7ESaJtohbtPNvPQ+udToOI2ENARbnzi4a4HQgRvIziTSRWEl0AXCOw5G0CjNdK0Z34uQRp+MwElZvYFHu7KIhTgdiJDeTSBOFlUTfxSTRqBEh6/7UvxQ7HYeR0LoDC3NnF410OhAjeZlEmgg+SaJmeUuUjZEPJ/STA7udjsNIaJ2A+bmzi8Y7HYiRnEwidZqVROdjkmhMiOB5yPOH/U7HYSS8bOCN3NlFI5wOxEg+JpE6yeftipVE85wOpTXrKwcnjJXiD5yOw0h4Xqxk2s/pQIzkYhKpU3zezljDuSaJxpgIcn/qn/1Ox2EkhW7AW7mzi7o5HYiRPEwidYLPmwa8hEmicdNRTo283LVsjdNxGEmhP1bP1Ot0IEZyMInUGQ9i1onG3W89D7Q1Be2NJhoBvJQ7u8iUmTQaZRJpvPm8PwZucjqMs1GmBM65w/2qKR1oNNU04C9OB2EkPpNI42jco0Mv/WXH9hceSHEfdDqWs9UPUp7rnUrQ3C81muobubOLbnc6CCOxmVq7cZI/L38AsAbwoqptw7r5ivLyE18tPZXXJRTq4nR8Z5Mnqs5f+L9VXz3P6TiMpBEAppTMmbnK6UCMxGQSaRzkz8vPBJYDwz/zomo4OxzedNWp06duKS3L6xgOd4p7gGeZsMrx4f4HU8rJNDuAGE21FxhVMmfmUacDMRKPGdqNj99TVxIFEHGddLsLHstuN2Va757tz+vdc93fsr2LT7pcJ+Ib4tnDJdrhT5771zsdh5FUegEPOR2EkZhMjzTG8uflzwDeBiSiE1WDnUOhjdefKq+8sexUvjesZip+FKlyZqL/b2UH6WjWCxqRuKVkzsx5TgdhJBaTSGMof15+W+A9rF0mmk810C0U2vD5svKqG8pO5Wepto1KgGe5jeF+i68M/GqK03EYSaUUyC+ZM3Ov04EYicMk0hjKn5f/IHBrVC+qWtmzKrThi2WnwtecKh+Rqdomqtc/i6gSujgwZ8+H2ruv07EYSeW/wIUlc2aaN08DMIk0ZvLn5V8CvB7TRlTP9K6q2nhT6Sm5qvz0iHTVjJi21wrtCXdeMTXwF7PrhxGpWSVzZt7ndBBGYjCJNAby5+W3AT4EesatUdXyfsGqjTeXlnkuKz89IhXS4tZ2kvtS4Mebl4Tz852Ow0gqJ4GBZhavAWbWbqzcRTyTKIBI1s5Uz6Sfd+44dnRur8rP9ey25JWszNVBCMY1jiT0d89fw07HYCSdbOCXTgdhJAbTI42y/Hn53YDtQELcuxTVE4MDwfe+WlrW5vzTZ4anQIrTMSWiHwZvX/VcaNpYp+MwkkoIa23pJqcDMZxleqTR90sSJIkCqEj74rTUKT/s0mnUqNxepV/o3nXRfzMzNoTB9MJq+GXKox1chENOx2EkFTfwZ6eDMJxneqRRlD8vfyiwEes/WEIT1SMFfn/xrSfLvFMqKodLpOtcW6E/V31uyZ+rrp3sdBxG0rmqZM7Ml50OwnCOSaRRlD8vvwi41Ok4IuVSPTi60r/t1pNl7SdUVg47W5NqlboODvM/nF1Jmpn9bERibcmcmWOcDsJwjkmkUZI/L38MsNrpOFrKrbp/XEXl9ttKyzqPqfQPcTqeeHu26ryFd1d93RS0NyJ1YcmcmW87HYThDHOPNHq+63QA0RAS6bksM+O8r3TvOmRkbq89s7p2XrAxLfVDp+OKl+vcCwu8lJ90Og4j6fzY6QAM55geaRTkz8vvDuwGPE7HEise1V1Tz1Tsvv1kac6QQHCA0/HE0sLQ8IU3B2ebXqkRqfElc2audDoII/4a7ZGKiIrIEzUep4jIERF5LZKGRGRaY+fYx5SKyAYR2SQi/xWRZNircxatOIkCBEX6vtMmc9oNPbsPGN2n144fdu64YKvHs8vpuGJhqmvTuBw5csDpOIykc7fTARjOaMrQ7mlgmIhUT8C4ANgfSSMiEsnaxcWqWqCqw7HuOc5q4fViKn9efjrwdafjiKeAS/q/kdVm2jU53fue2ydn6487d1ywy5Oy2+m4okWE9Ac8f2iVHxKMmLoid3ZRMnzwN6KsqfdI/wPMtL+/EXiq+gURGSsiy0Rkvf3nOfbzt4jIcyLyKvBWzYuJyLn28f3qa1BEBGgLnLAf+0TkARF5C3hcRNJF5FER2Wxfa7p93OsiMtz+fr2I/Mz+/pcicqvd610gIs+LyBYRedJuq7m+CJy1m3FXulyDXstqM+2KnB59xvXJKf55pw4L9qak7HM6rpbKkz0T8mXnNqfjMJJKCtb7gXGWaWoifRr4vIikY21QXfM+wBZgqqqOBH4G/LrGaxOAm1W1sPoJEZkIzAWuVNWddbQ1RUQ2AHuA84FHarw22j7vC9g9VVXNx0ru8+z4FtnXaAdUAZPscycDi+3vR2JNDhoC9KtxTHPc1IJzW5UzLlfei22zpl3aq0fO+D457/+qY/uFB1LcB52OqzlEcD2Q+kcz6ciI1C1OB2DEX5MSqapuAnKxElbtHU28wHMi8h7wJ2BojdfeVtXjNR7nAQ8Al6vqnnqaqx7a7QU8CvyuxmuvqGqF/f1k4Ak7vi1Yk30GYSXLqfbrRUCWiGQCuapaPft0laruU9UwsMH+2SKWPy+/B2D2s6zDaZdr6DPt2p53UU6PbpN699z02w7Ziw673YedjisS3eX4uTNcazc4HYeRVIbnzi4a6XQQRnxFsvzlFeAeagzr2n4JvKuqw4DLgfQar52udexBoBKrR9jUNqfWc736hmNXA2OwEtwiYD1wG7C2xjH+Gt+HaH792eswS4gaJiJlbvfwf3rbTZ3Rq0enKb17bvhj++xFx1yupNg148+e+1r1JDIjJswo1VkmkiTwCPB/qrq51vNePpl8dEsj1ziJda/11yIyrQltTgZ21PPaIuz7ESIyCOgNfKiqAWAvcD2wAquHehefDOtG01UxuGbrJeI66XYXPJrdbuq03j3bT+vdc93fsr2LT7pcJ5wOrT5tpWLoTe63Vjgdh5FUZjZ+iNGaNDmR2kOhf6njpd8BvxGRpTShxqyqfoTVc71XRMbVccgUe/nLRqxPdj+o51L3AW4R2Qw8A9yiqtU9zcXAR6p6xv4+hygn0vx5+R0ww7rNJ+I+5naPeqC9d8qU3j2zCnv1WDM3u93SMpeUOh1abf+b8s+ubkJVTsdhJI1BubOLcp0OwogfU5ChmfLn5d8I/MvpOFod1UC3UGjDjWWngteXlQ/PUm3rdEgA91ddvvi3VTeaD05GU91RMmfmP5wOwogPc3+v+Voy09eoj0jqoZSUsX/q0H7ShD45notzeqx4ol3bZWdEzjgZ1u3u187JpLL2PX/DqM/FTgdgxI9jiVRE3CLyX6faj4LxTgfQ6omk7/ekjP9dx/YTx/XJ4bKc7sufaZu1wi9UxjsUt2iX33geXBPvdo2kVZg7uyjht1M0osPRoV0ReQW4SVUT7r5YQ/Ln5WcApbTysoAJS7W8X7Bq482lZZ7Lyk8XpEJqfJrl1Gj//YHjeDvGoz0j6Q0pmTOz2OkgjNhzemi3EtgsIg+LyF+rvxyOqSlGY5Koc0SydqZ6Jv28c8exo3N7VVzTo9uSV7My1wQhGNtmaXtf6l/fj2UbRqsywukAjPhwumZtkf2VbMywbqIQ8W5NS538k86d+GknPTE4EHzvq6Vlbc4/fWZ4Sgx+v8dJ8fhcObi3RLv3iva1jVanAKsqnNHKOZpIVXWeiKRiVSQCax1oTHsVUWIqlyQgFWlfnJY65YddOiGqx4b5A+9/rbSs7fQzFSNcURp9ESH1Ic8f9p4fuMckUqMxpkd6lnA0kdpFGeYBJViVinqJyM2qusjJuJqgt9MBGA1TkY6b09Omfje9My7VwyP8/i23nizzTqmoHC71V8Vqkv5yYMIo2bplnQ4aHK14jVbJJNKzhNOTjdYCX6iugWtXKHpKVUc7FlQT5M/LLwH6OB2HETmX6sExlf6tt50s7Ti+0j+sudc5ot615/rvT+jfU8NxCqSXzJkZcDoQI7acvkfqqVFIHlXdKiIJPYknf16+C+jpdBxG84RFuq/KSO++KiMdt+q+cRWVO24rLes8ptI/JJLrdJbS0TNdK9YVhcePilWsRtIToAuQ9NsKGg1zOpGuEZGHsXdxwaqdu7aB4xNBN5z/ezOiICSSsywzI2dZZgYpqrsnVVTsuu1kWY8R/sCgxs+G33n+kVHkH6fQov1sjdatGyaRtnpOL3/5BvA+cCfwHeAD4A5HI2pcjtMBGNFXJdJnYWbmtC/16DZoVG6vXd/t0mnBB6me7Q2d00b8ebe5X18erxiNpNTN6QCM2HN61q4f+KP9lSw6OR2AEVtBkb7vtMns+06bTNLC4e3Tz1Tsv+1kWe9BwWDf2sfenfJ0r8dCFwWCpMSlKISRdLo6HYARe472SEVkkoi8LSJbRWRn9ZeTMTWBKft1FvG7XAPeyGpz3jU53fue2yfnw5906rBglydld/XrHgn1+knKk2abNaM+7ZwOwIg9p+/1PQx8D+u+aMjhWJrK6eFwwyGVLtc5r7bNOufVtllkhsPFF58+89GtJ8sG3KxvDbmn6vpTp8lIiJ1qjITi9HusEQdO/yOXqup/HI4hUiaRnkVENZwe4HR6gMr0ABUZAfyZfg1k+gke92dm/r0yc0+/M55jN3Zaceb1gcM77vH09aiZfGTYJBAqdzoGI/YcSaQiUr1k4F0R+T3wIlC9KTequs6JuJrIJNIEklKl/vQAFelBKjL8VNqJLpjpJ5jhJ9jGTyjTr6HMSjTTTzgjgGQEID2grrQgrrQgKZ4qUjwhUlNCeNxh0lxh0l1KBpAhkAa0tb8+pbRt7ofbBlxz+ERaafZ0f3aG9/TyjK5D/56xIWVUcDmT/TsY2C1A6kDEJNaz2KtOB2DEnlM90j/UejymxvcKFMYxlkiZRNpUqpoW5Ex6gIr0AJWZAfwZ/o8TXSDTTyjTT1VmpYYz/WimHzICaHpAXelWknOnBnGnVn2c5FLdYdJcSoYo6UCmnejSgOx4/Eghl6diT68Z6/b0Oj87lJIxNBTcWRksf3dQ+w63rh90dIqsWN45f/g5S5YVdn57ggipZbQ9vkonbFvOZP9OBnQPkDrAJNazir/xQ4xk50giVdXpACLST1U/NblIRPo5EVME4r4XZqy4Qxq0e3NnMgL40/34MwLqb+OnKsNPsE0lVZl+DdlJLpzht3pzGZ/05tyeKlI8nyS6NHeYNFEyxOrNZQBt7K+kdqpNzx3bBly772T2wBGITAIIVx3cGix/KRfISHNnthka6jhiXXjXhi1bpp7XZt+x7cOHv+1vl3Jq6Pm8Ne583gKgjHbHVlqJNbCT/t2DJrG2dqaq0VnA6XukzwO1K8M8h7VNWaI6Gq+GUoNaUWPY0l9j2DKQWUlVpp9QG7+GM/yEM/2Q4UczrN6cpAVwp1aRklqFJyVESkrISnIuJd3uzbURays4D2ZmYZ3C4g7s63nempI+F7Wp8mSNAPp//FroxN7Aqae9gBfA40rNBrg4UNDm5dTVodPlHQcsX3ZDuP+AVQu7d996rgiZAO0o63gBb3a8gDcBKMV7dKVO2L6cyYFd9O8RxNPfJNZWpcLpAIzYc+oe6WBgKOAVkc/VeKkdkO5ETBE4CuAKa6h62DLDmojy8SQUO9GFrKFLDWdaia763pykB3GlBklJDeL2hEj1hPC4Q6S51Lo/Z/fkMu0/M5z9cc8+pzO67t424JqS4x3yhiKuibVf1/DpI4GyeWHQj9cICq6uAJ213cAu6l10WEqngrh2bB933oH9g/cMH/HmsdRU/2d2DfJS2ulC3uh0IW8A1Yl14rblTA7uol/PoKT2r32OkVR2N36IkewcKVovIlcCVwFXAK/UeOkU8LSqLot7UE20cmRem7YVHLPvzRmtRFhcVQe6T1pbknupJ+BpO7K+XqGqv8x/8oEDEPx455dUV/qJq/t8p33140oCJ/6ZthiE9jXP7ZO7fnGvXu8NF7F6sU1xkuwjK5m4fTmTgiUmsSajnEPTC/Y7HYQRW07v/jJBVZOuxFrx4LyT0PQ3QyNxVaR3OLC9/zVbj3QaPhhxNVjOTbXK7y998AO04lM9y/ap3bZd2PPmgTWfW5GyddF7KXun1r5GaurpQyMK3tyTnn56bHPiPUH2kZVM2r6cSVUl9O1ZJamJPqfgbHYGyDo0vcC5N1kjLpxOpI9izdL9FFX9qgPhNFnx4LxNQL7TcRjNo0j4UNexa3f2vQx/WvtRiDRarUpVw4GyR1ZpuHR87dd6txmyZkKXy2vOPCeMhualLdgZkvDA2scD9Oz5wfK+/dYOFGlZyckTZB9ZweRty5kU2k3fnCrxfKaMoeGYzYemFwx3Oggj9pyebPRaje/TgauBAw7FEon3MYk06fhTvYe397/qg8OdRw9Ql/vcSM4NnHpqqYZLp9TG8BR6AAAgAElEQVT1WjtPh89MKHEh7unBoeX/Td1c5/X27x8y4fDhfseGD39rWWab0s/ch22q9pzsfAmvdb7E/q90QtsfXs7k7SuYFNpNrkmszmpw0wOj9XC6aP0LNR+LyFPAfx0KJxLrgM87HYTROAU90nnkhh39rvRXpHcag8i0SK8RKH95oYYOnVff6209Heosb5kb7jKybThjxSlXxWd6sQDBYHrHtWuvmNil6/ZVgwat6CWi3SONrbb2nOhyKa92udSuA3BcO3y0nMk7VjAxtIfcXlXiyW1pG0aTmUR6lnC6R1rbQKC300E0QSJXXjKAgCfr2I6+V7x3qNu4XHWlfGa2bFMFz8xfGA7uqDeJArTxeOsdGr44WJDzXOrySqT+2eiHPxow9tjR3mXD8t9Z1Lbt0SkiRG35SweOd53JK11n2nP6jmnHQ8uZtHMlk0K76dM7JJ4+0WrL+IxtTgdgxIejiVRETvHJPVIFPgLudi6iJlvvdABG3Y52GLppe/+ry89kdhuNSIMJsDFVlauXhvwbPjNhqLYMd1a9SdKrmTm54c4LStxHpjV0jVAotd3GDZdM7dBx74a8vEXtXa5wTBJcR451u4xXul1mJ9aj2ungcibtWmn1WPuEJCUZPsgmiw+dDsCID0cnGwGISAesnmj1m5Gq6iIHQ2qS4sF5JYD5NJ8AgikZpbtyZ2480H1yz7DbE5XlIaHAljXB06+PwCpY0aBr+nzvwxRX6jn1xkfozONpC06q0KMpbbtcVRVDhi5YlZ19cLJIfLftO0LnjxPrXvqYxNp8lUD7Q9MLWk0lNKN+Ts/avRX4DpADbADGA8tVNZFr7QJQPDjvCeBLTsdxNjuRPfD9bf2vOVGelTMKkcxoXTcU3PN+sPz5XJpY2vD63LuPikiDs283u/csW+nZFtGkIq/30AdDh833uN2hOmf+xsMROh9YzuRdK5kY3kvv3JCk9HIqliTzzqHpBedHepKIdAX+hPVeeAKrxODvVPXfUY4PEfEB5ap6j4ikYxXYX6Kqv4jCtUuAMaraYCU4EVkA3KWqa+zHucBrqjosgraygS+o6n3NjbelnL5H+h3gXGCFqk63Kx61+B8xTv6DSaRxV+VOK9/d+6L1e3OmdQ6704ZG+/rhqsM7guXPd6eJSdSFKwB0bOy4/FDviRtSdm30S9WIpsZSWtptyPJlnw+eM3jJgk6ddk8UIbWp50ZLZ470uIJ/97gC6338sHbZv5zJJSuZqPvolRuSlJx4x5Qk3on0BLGKgLwEzFPVL9jP9cEqXFP72BRVrWpxlNa1UoEXgLW1k6gdk6hqOBptRZtYS9eygW8CZ20irVTVShFBRNJUdYuI1DtElmDeAMKY3WDionrLsrJ2fQsQqXMZSkuFQ6UHAqeezAA6NPWczJR2h0WkScnkwkBB+qupa8JI039nVF2eLcVTp2VlHduWP/ztQEpKMOofHiLRhcM9r+TFnlfyIgAfadd9y5m8eyUTdB+9c8PiNonV8nYzzikEAqo6t/oJVd0N/A1ARG4BZmLdBmsDFIrID4HrsSqt/VtVf24f+7/AF4G9WGVN16rqPXW0mQI8DWxT1dn2ublYHYV3gQnAVSIyEfgJIECRqv7IPvZ+rM5QBvB8dfu2b4vI5Vi3R65T1S2R/GXYcTzBJx9qv6Wqy8Saef9z4CBQAGwC+ovIBqy/9yKsDtlH9usvApuxOm4ZwFWqusOO7X+AVOAY8EVV/cjuqfcG+tl//llV/9pQrE4n0n12t/wl4G0ROUFyrCMlb0vx8eLBeSuAZq8BNBpWe8syIGYfsjR85nig7LFK0IgqBWV52h/HujXRqK7qPaeTtl18VE5F/EGgvLzjwOXLbggPGLByYbfu2z4ugu+0rnyUcxUv5FyFtZLtkHbbv5zJJauYoPvo1Tcs7p4Oh+iEA8DaZpw3lMZXBEwAhqvqcRG5EGt+yVisBPeKiEzFqqh0DTAS6z1+XQPx3A38V1W/W+v5c4CvqOo3RaQH8FuszUROAG+JyFWq+hLwUzsWN/COiAxX1U32NY6q6igR+SZwF3BrPTE8KSLVa7FTsTooAIeBC+zO1kDgKT7ZcnMsMExVd9kJd5iqFgDYiXYEkAccB3YCD6nqWBH5DvBt4LvAEmC8qqp9m/Fu4Af29QcD07H2If5QRO5X1WA98Tu+jvRq+1ufiLyLVXbvDQdDitTrmEQadeVteuzcOuC6fSezBw6v3rIsllQDp/2ljxyEUMS9vbaeDqcjOf6iQEHek2mLS4mg3u4nxLV9+/jz9u/P2z1ixJvHPXUUwXdaNw71vJrne17N8wAc0u77llmJlf3k9AuLu0kTrpLcK9EoCygi9wKTsXqp1QVE3lbV4/b3F9pf1asIsrASa1vgZVWtsK/T0ObiS4AJIjJIVbfWeH63qq6wvz8XWKCqR+zrPQlMxeoAXS8it2Plku7AEKweImAPW1hJvObmJLV9sfY9Uvt5D/B3ESkAQsCgGuesUtVdDVxztaoetK+5A+x9DK2e6XT7+xzgGRHpjpXAa16vSFX9gF9EDgNdgX31NeZ0j/RjqrrQ6Ria4SXgV04H0RrUsWVZXGrIqoaC/tJHtkCgWVv3tfN0iGi/yQxSO+WFchYWp+xr9tKcigpvnxUrruvdJ3fD4l693hshkrjb4HXjYM7neC7nczwHwEHtvncZU3avYrwcsBJri4tQJKCXmnne+1g9SQBUdZY9iW1NjWNqfnAT4Deq+o+aFxGR70XQ5iJgHvAfEZmiqtUjgrXb+QwR6YvV0zxXVU+IyGN8eveu6k3NQ9i5RkTexEpKa1S1vh5qte9hDc+OwLqFVnMGdGMfYGtuqB6u8TjMJ3nvb8AfVfUVuxfrq+f8EI3kyoRJpMkob0vx+8WD81ZhDTMYzWBvWbbreIe8YXVtWRZLqqqBssdXo2ea3W6Wp33jB9UyoWrgpK3uAztCEm7BUh2R3SUjpxw6OOjgiBFvbElLP5MUv4PdOdjrGp7tdQ3PAnBAe+xZxpQ9qxkvB+jZGhLrMWB+M8+dD/xaRL6hqvfbzzU0hP8m8EsReVJVy0WkJxDE6mX+Q0R+g/UePxN4sL6LqOoLItIZeMMeGq5tJfAXO6mfAG7ESkLtsBJaqT3b+BJgQUM/oKpe1NDrtXiBfaoaFpGbod6lYKeweuGR8gLVO/Pc3IzzP2YSacs9hEmkEaljyzJH1uMGyp9dpOETLSrakOlu1+g609pcuFKmBoecfDf1vZY0DYDf36b7qlXXdO/Z84NlffutPUek8RnEiaQHB3pfyzO9r+UZAPZrz48T60F6JGNi/ceh6QX13ktriH2v7irgTyJyN3AEK1H9qJ7j3xKRPGC5vetfOfAlVV0tIq8AG7H2Q10DlDbS9lwR6Ya1reXttV47KCI/xpp8JMDrqvoygIisx+pJ7wSWNufnbsB9wAsicp3ddp29UFU9JiJLReQ9rElSRU28vg94TkT2AyuAZteldrwgQ7IrHpyXhTV7LMvpWBKdtWXZ57Yd6TTinMa2LIu1QHnRwnDwwxYlUYCret+5Mc2d0eQlLTU9lbZ01WmpjNqHMI+n8tjwEW9+mJlZ1mru2+8jZ/cypuxZwzj3AXr0U3E7+nvTiCDQNxH2HxWRLLuXmok1fHu7qprSpjFiEmkUFA/OexhI6K3fnNKcLctiLXhm8aKQf3Wjpf+a4rrcu/a4xN2s6j8n5fTu51NXdEOiu0l8167bVw2MUhH8RLOXXiXLmLJ3DePcB+nRX8XV1emYanjq0PSCLzgdBICI/Atr4k861rrU3zgcUqtmEmkUFA/OG4t1H8Gw+VO9h7f3u6r4cJfR/dWVOGsLqyo3rKiqmD+WKK3/vT737kq7KkyzvOnZsGCv+9i0aMRSk9sdKM0f/t9NWVnHJkezCH6i2UvvXUuZsm8NY92H6DFAxdXFwXDGHppesNrB9g2HmEQaJcWD8xZiTQk/a9Xasmw0IhHfP4ylUGDb+uDpV4dAdHqAqa6M41f3ubPJxRvqEqSq/PG0heUqxGTIsmPHPesH5y3uEKsi+IlmD312LWXKvrWMTTlE9/5xTKzLD00vaDVD6kZkmpRIRaQjn5S86oY1HfiI/XisqgZqHZ+CtRg3u0XBiezDWmh7stbzVwMDVPX3tZ6/1T6+9uLiSNocB3xeVSOZQk7x4LyLSK41sFET8GQd29n3ivcOdhvXR10puU7HU5dw1f7iwKlncmje7L46dUjtvvWCnl8e1PiRDdvgLlm6xrMjZutlXa6qM0OGvrs6O/vQFImgqlJrsJvcnUuZsn8tY1M+otsAFVfnGDV1w6HpBc/G6NpGgou4R1qz0HEDx8Q0kTZwfIsTaUvYlY7GOdG2E2ptWRbV+3zRFA4dKwmUzWsDRPVNtE+bIWvGd7l8TONHNkxRfTxt4ftBCTW5UHdzeL2H3h86bH6a2x0aEMt2ElkJuTuWMnX/Ws71HI5eYt0L9Ds0vSAqtW+N5NPi5S921YweWDe1/6SqD9V6vTNWpYqfA8uwFitn223/RFVfE5G2wLP2ddyAT1Wfty/xXRG50n7+WlXd2ljCtBP5VlXtZ699OgxMtus0LsdaB9UNa5eFdKySWreo6jYROR+rpuNVzfjr+BnW2q5WK+jOKN3V9+Mty4Y7HU9jNHzqo0DZEylEOYkCtPV0rGj8qMYJIhcGRriKUtcpMbyfWVrabejyZTcErCL4eyaJNL5FXGuTS0n/XEr6f5HHASjRvjuWMHX/Os5NPUzXASquBnfxqcdvTRI9u0VjHenNdq3FTGCNiLyAtUAWu/TSK8CPVHW+WPfMrlTVUyLSBWvd0WvApUCJql5in1ezfNpHqjpSRO4Evg/c0VhAqlolIjvtAvh5WCWqpthrnrqoaold13eyqoZE5GKsCkU3tOQvIm9L8VvFg/MW0QrvlZ7IHvjBtv7XHLe3LEuKn0/DlaX+0kfLIByTbcjaetqHonWt7tp+SEfNWnJMyidH65p1UXWnbik+b1pW1tFt+cPfDqakVA2JZXuJLpdd/XPZ1f9LzENBS7Tv9iWcd2Ad56YeoctAFVdj63KLgX80cozRykUjkX5PRKq3+ckB+mPtLZoK/Bf4uqousV8X4LciMhmrVFMvu8e4CZgjInOAV1W15sLemvUaL40grsVYCS0P+A3W8pSVfDK7Nht4XESishF0Dd8FVlN/FY6kUb1l2b6caZ1C7rSkesNVDVb4yx7eDVUx6zW38WRH9d/4okDBOf9KW1JGHEr+lZd3Grh82Q2hAQNXLuzWbftYETJi3WaiE5C+7BrQl10DbuIxFHSX9tu2lPMOrmNMfYn1B6Y3arQokdrDoFOxKuhXiMgSPqm1GMRKqBdilawC+DJWWaZRdq9xH5CuqsUiMgYrUf5eRF5T1V/b53ymXmMTLQZuAXKB2ViV/adiLU4G+H/Am6p6n4gMIEoThfK2FK8vHpw3F5gVjes5oaxtn61bB1z7USy3LIsl1XCVv/TRzag/phWnMtxZzV72UpdM0jqfE+qx8MOUAy0uFNE0Lvf2bRPO279vyO4RBW+e8Hj8BfFpNzkISD92DuzHzoE38aidWPtvW8LUA+s4N/0E7fftKxz7H6fjNJzX0h6pFzhuJ9GhWLsEVFOs+oUviMhd9uQkL3DYTqIXAD0B7BqRR1X1CXs7nc+3MC6A5cCjWPvsBURkM3AbcHGN2KsrkNwShfZq+h/gOsDJNW0RqbFlmTeUkjGMT++0kDRUVQOn/rkCje0QKUCqKz3qPcdJVedM3OY+uCss2uxyZZGqqPD2WbH8ut65uesX5fR6vyCRi+A7yUqsOwb2Y8fAL/NoJXAT7HA6LCMBtHQqfBGQKSIbsSbafKoogb2D+/XAxSLydaxNWieKyBqsRLPNPnQEsNremPVu4Ne0kL2F0AGsCU5g9VAzgQ/sx7/F6v1Guz4keVuKT1JPfcxEU96mx851I76zaOGUP/l39b18kp1Ek1aw/MVFGjoa8yQK4JaU5kxMaZALl2dKMO9otK/bOJGSklFTV6+6+rTfn2mKCjTu1zMKd2xr/DDjbGAKMsRI8eA8wRpGjsubeiSqtyzb3eeizKAnq9UM5wVPv7UwFHgvLsOiLtz+6/reFbMlP/9KW7L6jPjPbfzI2OiZ8/7Svn3XDU62IvhxUgwUzCjcEdEWekbrZRJpDBUPzuuHdZ84akUAWuJMRpc9Wwdcu+t4h7yhNG+af8Kqqli+pKpy+STq2Tsx2rJS2u+d2ev2XrG6/nEp3/Vi6socHFyi4vFUHB0+4q1tmZllE5yKIQEpcN6Mwh2LnQ7ESBwmkcZY8eC8L2NtnOuIj7cs63NJSiC13Sjs/ZZakyr/e6uqzrw1ijhuC9gto9+m87pdF9N1tP/xrF+43308ThOP6te127ZVAweu7C2iibzzSrz8YUbhjrucDsJILCaRxkHx4LyniM4EqiZLpC3LYikU3LUpWP7vgRDf5RuD2o1ZNrLjjJjWVg1QVfZ42kI/Ev1iEpGqLoLftu2xpJvFHUXvAhfMKNwRtfXDRutgNvaOjzuACUBMC4fXsWVZj1i257Rw1aFtwfJ/9yHOSRSgradDszZvjkQqKe1GhvouXp+yy/FEGgqlejesv3SKVQR/UUeXS5u1dVwS2wfcYJKoURfTI42T4sF5k7E+0Ub9w0uiblkWS+HQiX2Bssc8oI7sR3let+sXdsvoG/NhV7sOb3FQQglTEMPlqjozdOi7q71nTxF8PzB1RuGOVU4HYiQmk0jjqHhw3teBudG4VqJvWRZLGj59xF/64GkI5zoVwyU9b13WLrVjXLbN2uc6tvkNz4ZhsazD2xze7IPvDx367tlQBP/2GYU7HnQ6CCNxmUQaZ8WD8/4KfLu55wc8bY7v7HvF5oPdxifslmWxpOo/5T/5wD4I5jkZx1W979yY5s4YEa/2XkhdsfSE63TMtlprLpFQYPDgJcs6tt4i+A/NKNxxm9NBGInN3CONv+8B52CVTmyyWluWOT6T0wmqVX5/6SM7IOj42lePK7V9PNu7KFDQ/+m0peUIWfFstzGq7tTi4vOmZbU9ujU//+2qVlYEfzXwLaeDMBKf6ZE6oHhwXjawAiuh1svesmzDge6Teobdqa19+KxBqhoOlD2ySsOl452OBeD63LsrRSSqtXYbs8Dz/oLt7kPT4tlmZMKhgQNXLunaOorgHwFGzyjcsdfpQIzEZxKpQ4oH5w3AKub/mckytbYsy4x/dInHX/avRRo6lBDbt6W6Mo5f3efODvFuN0TYPy9twaGwaExnf7dUZubJkuEj3iz1eAJxG/qOstPARTMKd0S9fKjROplE6qDiwXkjgAVAdq0tyxy9/5doAuWvLAwHtyfMcHaH1O5bL+j5ZUeK+m9x71+5xLNlnBNtR0a1b991S3rmfFAgkhiVvZqoEpg5o3DHfKcDMZKHSaQOKx6cN2H9iDt/cSJ70HhEkukNJy6CZ95dGPKvT5gkCtCnzZA147tcPsap9p9MW7y2QgKjnWo/Emlp5QdGFLyxPy2twrG6wREIAFfNKNxhtkYzInI2rAFLaHlbipefaH/OrxBJ+o3Ao62qcs2ykH99Qgzn1tTW07HCyfYvChRkoyTFZtJ+f1aPVSuvPXfXzpHLVDnudDwNqMIquGCSqBExk0gTwKy5hYuAy4AzTseSKEKBLWuqKhadS5yK0Eeirae9o9VtOmnb/t3D2Ul1/27fvmETV664NnzmTLtljR8ddwGsJPqS04EYyckk0gQxa27hu8AFwAmnY3FaKLjn/eDp1/MgMdcltvFkOz56cH5weAHKMafjiEQwmNFp7ZorJ27bOn6lqnzkdDy2SuDqGYU7XmzOySJytYioiAxuaSAikisi79XzfIWIbBCRjSKyTEQanPFvxJdJpAlk1tzCZcBUrA3Jz0rhqiM7g+XPdwfaOB1LfTLcWXFd9lKXNDzeEaE+HzR+ZOI5dGjguBXLr0s/darDEodDOY01sej1FlzjRqzZ93VuSiHRu2WzQ1ULVHUE1m5SP2nqiVGMwaiHSaQJZtbcwveAicBWp2OJNw2VHQyc+mc6EPelJZFIdaW3czoGgDFV/SelqGuL03E0R1VVmnfD+pmTP/hg6rpwWJxYq1mKtcSl2bNzRSQLmAR8jRqJVESmici7IvIvYLPdoywWkQdF5H0ReUtEMuxjR9u9zOXArCY23Q575EpE3CLyexFZLSKbROTrdcVgP/e/IrJFRN4WkadE5C77+QUi8icRWWTHea6IvCgi20TkVzV+rpdEZK39M9xe4/lyEfl/9s+xQkS62s8/JiJ/tXvQO0Xk2ub+XSc6k0gT0Ky5hbuBycBap2OJFw1XnPCXPXoGNOF3rHFLSkJsii6Ia0YwP+B0HC1x7GifUcuX3dDh5Mmui1QJx6nZYmBsFNaJXgW8oapbgeMiMqrGa2OBn6pqdaWngcC9qjoUOAlcYz//KHCnqja2eXp/e2h3B/B94I/2818DSlX1XOBc4DYR6Vs7BhEZY7c5EvgcUHvWeUBVp2LVAn8ZK6kPA24RkY72MV9V1dH2uXfWeL4NsMLuLS8CapZU7I71XnYZMKeRnzFpmUSaoGbNLTwCnAc863QssaYaOO0ve3g/hPo7HUtjXLj9Nd5AHNcr3Gm4N5yZiBN4miwc9rTZvOnCqe9tPv+DcNi1I8bNvQyMm1G4IxojPjcCT9vfP20/rrZKVXfVeLxLVTfY368FckXEC2Sr6kL7+ScaaKt6aLc/8F3gAfv5C4Evi8gGYCXQEStp145hMvCyqlao6ing1VrXf8X+czPwvqoeVFU/sBPoZb92p4hsxKrK1qtGOwHgtZo/W43rvqSqYVX9gDqKz7QWJpEmsFlzC0/Pmlt4A/BDoFXug6gaCvpLHy1GA8OcjqUpMlPaHXY6htouDhT0RZN/xvfJk92HLVv6+V5Hj/ZaqEq093tV4OdYE4tOtfRi9oepQuAhESnB+j96g4hUzzI/XesUf43vQ1h1zsWOK1KvYM2lwL7Gt+0kW6CqfVX1rTpiaGz2e3V84VqxhoEUEZkGnA9MsHue64HquQJB/aQgQfXPVvu6TYkhaZlEmgRmzS28B7gIOOp0LNGkqhooe2IVetqx4gaRyvK0T7hZ1W3J6N4v3LVV7JWp6k4t/mDaeRs3XLwzFEopjtJly4ArZxTu+L8ZhTuiVYHmWuBxVe2jqrmq2gvYhdXzaxJVPQmUikj1OV9s4qmTgeqe+5vAN8TeRlFEBolIXRP1lgCXi0i6fW93ZlPjtHmBE6p6xp6hnBA1rxOFSaRJYtbcwneA0bSi+6aB8ucWafh4wm0N1pB2ng7lTsdQl6nBvPGiss/pOKLl1KnO5yxbesOgQ4f6L1ClsgWX2oJ1P7T2UGZL3Qj8u9ZzLwBfiPA6XwHutScbNVToo/oe6Ubg18Ct9vMPAR8A6+ylM/+gjl29VHU1Vk92I/AisAZrwlVTvYHVM90E/BJreNewmRKBSebeO+anA/cDtzgcSosETv9nYThQnFCl/5pidMcLFw5oNzIh437fvXf5cs/WxiatJJ0WFMF/GfjyjMIdZbGIK9mISJaqlou1EcYi4HZVXed0XK2B6ZEmmVlzCytnzS38CvBNiPp9pLgIVixZnIxJFCDLE9dtSCMyNNRrQpp6NjR+ZHI5cyY7d8Xy64fv2ztkkSpNub8ZBnxY90NNEv3EA/akpHXACyaJRo/pkSaxe++YPwpr+vxwp2Npqir/xhVVZ945F0jKReKX5Ny2rJ2nw0Sn46jPESnb9nLq6n5Icv79NiY9/dT+4SPePJiWVlHfffXtwC1mCzQjnkyPNInNmlu4DmtN1y9Igt5pKLB9Q9WZd0aSpEkUIN2VkeV0DA3prO0GdlFvq00ilZVte65aee2YXbtGLq1VBF+BvwIjTBI14s30SFuJe++YPwKrdzrS6VjqEq46sCVw6ukeWFVZktZ1uXftdYm7V+NHOqeSwIl/pi0GIXHHoaPA46k4MqLgze0ZGae6Al+dUbhjYaMnGUYMmB5pKzFrbuFGrEom/8On1245Lhw6tjtw6umOJHkSBRBcXZyOoTHppLYfFuq12ek4Yi0YzOiwZvVVy3ftHJVvkqjhJNMjbYXuvWP+QOBerN1kHKXhUx/5Sx8OQDihe3FNkebKPHZVn28nTFWjhoTR0Ly0BTtDEh7Y+NFJaTXwdZ/Pt97pQAzD9EhboVlzC7fNmlt4IXADDu4ko+HKUn/po6WtIYkCtPF4k6YghgtxTw8OTcg1ry10CvgOMN4kUSNRmETaDHXtQdjAXoK7au8dKCJ/FpG7RWSMiPw1VnHOmlv4LDAY+DNxLjGoWlXpL3ukBKoGxbPdWGrr6ZBUSylyw11Gtg1ntJaF8yHgMSDP5/P91efzxavAvWE0ygztNoOIPIu1q8E7quqzn8sFXlPVYbWO/Q1Qqaq/sB+7gD3AJFXdXc/1U1S1Kpox33vH/OHAr4DLo3nduqiGQ/6yh9cSPjU21m3FU377KYuHZE+c4nQckSiVM/ueS13eCcHxPVSbSbEqBv2vz+dLyi3jjNbP9EgjVN8ehA14qtZxU4ESVd1t7xn4mn1dn4g8ICJvAY/bNTEfFZHNIrJeRKa3JO5Zcws3zZpbeAVWmcFXGju+JQKnnlze2pIoQFtPh6TbOMCrmTm54c7J2it9Axjj8/muM0nUSGSfqcloNOrjPQhF5LiIjGqoQoiqbhKRsIiMUNWNWEn1qXoOHw1MVtUKEfmBfX6+PYT8logMUtWW1B2tXnt6pV3M4efAFS25Xm2BUy8u1NCRpKxa1Jg2Kd6kXP96XnDo2N2uBQdUSPi9Xm1LgJ/4fL7FTgdiGE1heqSRa2gPwvo8BXxeRFKAK4Hn6jnuFVWtLlw9GXt/QlXdAuwGona/cdbcwnWz5hZeCYzCqknaYsHTby8MV5W0yiQKkO7OynA6hubw4M7naSYAAA9ASURBVM4cWzWwxOk4mmA9MNPn800xSdRIJiaRRqAJexDW5yngeqz9/Dapan17Wkayf2BUzJpbuH7W3MKraGFCrapYuSQU2Dy18SOTV6orPWnXweaHek9M05SNTsdRjw+xZpiP9vl8rzsdjGFEyiTSyDRrD0JV3QEcA+ZQ/7BubYuw9ycUkUFAb6w3nJiokVBHAi8RwYbDVf73V1VVLh1PK964F8AtKZ2cjqElLgwUpKMk0mzXZVgfMIf6fL5nfT6fmfloJCVzjzQyN2Ilw5qq9yD8bSPnPgX8hs/uYVif+4C5IrIZqAJuUdWYVyyaNbdwA3D1vXfMLwB+AlxNA78noeCuTVVn3sxv6JjWwCXuShHp4HQcLdFVved01naLj0iZkzOPg8CzwJ99Pt8aB+MwjKgxy1+MBt17x/xuwFeB24Dcmq+Fqw5tC5z6VxfA60BocdU2pf2eS3vd3tvpOFqqgsCxJ9MWpyBx/zf7CHgQuM/n8x2Mc9uGEVMmkRpNcu8d813AhcDXgcvDoRMHA2WPpYB2czi0uOie0W/j1G7XRbqxdEJalvLhwg9S9sVjUpgC7wD/AF72+XwJv0ORYTSHSaRGxO69Y34Pf9nj12ro6CyiOJM4kQ1qN2bZyI4zEnYf0kiECVfNS1u4OyTh/jFq4gjWTkQP+ny+7TFqwzAShkmkRov84YbLxgNfxlof22q37RrT8aKF/dsVtJqlPTtcH619N/W90VG85AmsQh/PA2/5fL5AFK9tGAnNJFIjKv5ww2WpWOUHvwxcDKQ6G1F0Tet2w8KuGbmtJpECPJW2dNVpqWxJBaqjWDO8XwDeaenQrYgo8E9Vvcl+nAIcBFaq6mUtuXYzYrkLuBVrol8I+IOqPh7D9nxAuareIyILgLtUtVmTsexZ/n/GGi0KApuBbwOXAGNU9VsRXKvEPqdJGzaIyC2RttEatOqZlkb8/OCZ1wJYb6gv/OGGy7Kw1sxeivWfN8fJ2KIhM6Vdq/pgAHBJoKDr86kr/AhpEZz2EdbM8+eBBT6fL5plE08Dw0Qkwy5McgGwP1oXFxG3qjYar4jcYbc9VlXLRMSLVdGsqe1EvVZ2BG2nA0XA91X1Vfu56UBnJ+I5W5hEakTdD555rRyrp/ISwB9uuGw4VlK9FJhAEv7epbky2zgdQ7Rla5s+vcIdF+x1H5vWyKEHgBexkufiGO+88h9gpt3WjVjLxqYAiMhYrJ5WBlABfEVVP6zdC7LrV9+jqgtEpBz4I3AR8AMRSQPuwfodXA18o45lZT8BpqtqGYCqlgLz7Gv/DGvkJQNrHezXVVXtXuQyrDrc80XkK0A/VQ2LSCbWGvB+wC3A7VgjNtuBm1T1TB1/D9eJyH1ANvA1VV1sJ8n7gTFYPeXvq+q7tc77AvD/2zv/ICurMo5/vuDmCMuPdNSZQl0Bs8wUcTElwFXUUVwnS40aNdQy08apxNSyGLRSRocJx9TMBvEXtmo64+CkOQGGJoICLuKQPwCVzEnwJwok8vTHc677cnnfuwuX/enzmbmz9573vOc9d+/u/b7nnOd8nydLIpr6Pyf1vR74nKSHgSHAA2Z2STp2HHAFsDPwcvrdltLwXSjpJKAGOM3Mlhd9Fqn+Xuka+wIzSwk7ejLd7gst6H5MbJrVDDQDU6aObxyIR/+Ow6eA9+zMvrWVnXrVdOs9pEUc/dGB9bf3euwNE9no643AfGA28CgwvwPNEv4MTEpieBAwnSSkwHJgjJltknQMcBVwSivt9QWeM7NJSYheBMYmr+zbgfNxQQBAUj+gXzJRyeP3ZnZlqnsH0AiURGugmR2Zjg0HjgTm4ML7iJl9JOl+M7sl1fkNnvzi+pzr7GRmh0kah3tiHwP8CFr13z4QeKbC72MYbrqyEfiXpOtxIfwlcIyZfSDpUuAi4Mp0zhozGy7pAqA05V3pszgs9eNDYKGkh7Z3mrq7EEIadCgTm2a9g2/Iv2fq+EbhRv3j8FFIPV3TbctErz06uxPtQQ071dZvGrJ4Yc3Lr+DCORt4YvLkyetbObVdSEke6vDRaLld4ADgNkn74VtratrQ5Mf4kgPA/sBKM3shvb4NF6dpmfqisqvXUZIuAfoAuwLLaBHSpky9Jtz2cA4eiHdjKj8wCehAoBZ4pOA696efz9Cyf3sUSXTTqLDkv91cob/l/D2NsJH0PLBP6ssBwBPJ7fQzwJMFfflmel7ps3jUzNama9yf+h1CGgTtwcSmWYb/gz0NXJlGqyOAw4Gvpken2/Lt3KvPWkmd3o8dyPv4iPMJ4PGDP6576sTfnrmulXM6kgfx6dcGYLdM+a+BOWb2jSS2c1P5Jra8AcvmXt2QWRdt1cIyrYl+IGmwma3IHksj2hvxaeTXUoBQ9lpZr+wHgauTG9ah+A0KeHLyk83s2TQl3VDQldJ088e0fE+3xYJzGT4SLiI7jV1qW7j4FSXgyOtL0WcBW9+I9PiI1hDSoMuQRquPpgcAU8c3DqFFVIcDBwP9OrJftTUD19IFBH07WQc8j3/BLsLFs3nQlNFdObfqdOBdM1sqqSFTPoCW4KOzMuWrgAsk9QI+j08t5rEcqJM01MxeAs4EHsupdzVwg6TxSVj746PKe9LxNSkv8an4Wu5WmNk6SQuA64BZGTHvB/xHUg3upb0twVQl/+3ZFfy3ZwI/l3SimT0EIOn4Vq4zP73foWb2UlrTHZQZuedR9FkAHJtuINbjQVrntP7WujchpEGXZmLTrJfx4IeZAGk6eAi+1lNa7xkG7Zdrs1/Nru+1V9s7kA9pEczs49VBU0Z3qxGBma3GBaica/DpxItoGeGB3xysxLd5PIffMOS1uyEFAd2bttYsBP6QU/UmfNp1oaSP8C0kU83sHUm3pOusSudXoglPmdiQKfsV8BSeFnEp23ZT2Kr/dspl3AhMkzQt9b0Z+HFRo2b2Zhod352CscDXTCsJadFnAZ5P9g5gKB5s1KOndSH2kQY9hDQtXIev+ZQ/6qhiRPmVz46Zd8DAIzrT6D3LO7holAvmyu4mmEHQUwghDT4VTB3f2Idikd0bd2XK3eIyco+T5+7Vd/+GduyeAW/h1npvAv8F3sCnzlanx7+B1YOmjM7bKhEEQScSQhoEianjG3sD/fH1nwGl54fvflLNPrUH7IoHluySfpae74xPs/0PD8oo+plX9h4ummsHTRndKRv4gyConhDSNiJpnZnVZl6fRY4VVl759lh+pXb+Zmavb28bBe024hF3vfCQ9evM7OZq2iy4Th0w0sxm7ui2gyAIuhJdcc/epx5JvfFIuB0aQJMiBf8InGRmB+OBOnN35DUy1OEuK0EQBD2aENIORtJNkp6WtEzSFZnyVZImSXoc34xeD9wlaYmkXcraOE7Sk5IWSbpXUq2ksZIeyNQ5Nm2GztIPj9ReC2BmG5PFWm9JK+QMlLRZ0pjUzjxJQyX1lTRd0kJJiyV9PR3vLenaVN4s6bx0rSnA6NT/nxbVk9Qgaa6k+yQtl3SX0q7wIAiC7kAIadvZJYnCEklLaLHPymN8Wd36zLHLzawetz87UtJBmWMbzGyUmd2JmxScbmbDkoE3AMkYoGTnNTzVK4Wgf0lSyZz6bDwn5CeY2Vv4RvFXJN0t6XRJvdIetxdwd5NRuIPJ6BQKPyjtubscmG1mI4CjgGsl9cUtzt5N5SOAcyXtC1wGzEv9/12FeuAj45+k6w/G/UqDhNwvtj3bb5Bkkr6XKTsklV3cyrkzJJ3anv0Lgq5OCGnbWZ9EYZiZDQMmVajbVFY3u675LUmLgMXAl3Hx+OS8NvTjcFrsvJYAE4B9zBe77wDOkDQQN4f/a/nJZvZ9YCywAPfNnJ4OzQPGpMfVuKCOoGWv3HHAZemac/Fgm71T+XdT+VO4E81+Of2uVG+Bma02s83AElos0YKOYyluaVfi28CzHXXxtK8zCLol8cfbgaQR2MXACDN7W9IMii3GCpuh2M7rVtz3cwNwb1EqJzNbCiyVm26vxNdj5wE/xNdlJwE/wzeS/yNz3VMyGR5K70nAhWb2SFl5Q06/i+rl2ZYFZaTf1WQ8D2jJnPyMlH1kHJ7lZA1uSDDYzBqTw8x0fKT/IfADM8vzZn0V6C9pTzyS+HgyXreShuHmBX1wg4xzzOztsv6twv1r25QpJAXUnYj/D/QFjq7m9xMEnUWMSDuW/rhYvpu+sE6oUPd98l1P5gNfkzQUQFIfuV0YKcL3dXzqd0b5iWkttSFTNAx3WAEfJY4ENqdsEkuA83CBBTfXvrC0finpkEz5+SmQCUlfSFO+5f0vqhdsG1tNg8s9YG8GTjCzUWyZe/IKYLGZHYSnB6uUnPo+4DT872ARW97g3A5cmtpZimckyWNNWnK4Cb9phJZMIYfgN2lXZeofAUwwsxDRoNsSd/4dSDKqXow70azArc2KmIHbga3Hv2xKbbRm53UXsLuZPZ/TpoBLJN2Mjww+IPlkmtlGSa/hQg0uoN/BvzTBt8xMA5qTmK7CU0j9CZ+KXZTK38T9NZuBTZKeTe/luoJ6wbaxIFnokabJ63A/3RVmtjLVuRvPeQk+RX8KgJnNlrSbpAGlDCBl3IMvL3wxtTEyXWcAniKs5Et7G259l8f2ZAp5qy1vPAi6KiGkbSS7hzS9nkHOqC+v3MwaMs/PKmi/ruz1X2hJ/wQZv04zm42vX+YxCril4Brv4ynLcjGz0ZnnM0n+tun1enyEWn7OZnyk84ucJseWvc6rN5fMFpzyfbnBVhRl7ygi71ju5nEze0PuLXss7s06sor+tTVTSFuWM4KgSxNTuz0ISc/g0cB3dnZfgg5lOTA4iRRsGTRUyhhSWmNdY2aVTPgn4VO4n2SHSaPXtyWVbrSKsqYUUSlTSBB0e2JE2oMws0M7uw9Bx5MyflwAPCxpDR6RXWIycKukZjzYaEIrbf2z4NAEfKmhD74scfY2dLFSppAg6PaERWAQ9AAk1aYcmAJuAF5M+3eDIGhnYmo3CHoG56bgo2X4VOoO908OgiCfGJEGQRAEQRXEiDQIgiAIqiCENAiCIAiqIIQ0CIIgCKoghDQIgiAIqiCENAiCIAiqIIQ0CIIgCKoghDQIgiAIqiCENAiCIAiqIIQ0CIIgCKoghDQIgiAIqiCENAiCIAiqIIQ0CIIgCKoghDQIgiAIqiCENAiCIAiqIIQ0CIIgCKoghDQIgiAIqiCENAiCIAiqIIQ0CIIgCKrg/4tI9XWCPemjAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x26fec57eb38>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "top10.plot.pie();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the diagram does not look very nice here.\n",
    "\n",
    "With the optional styling parameters, we can achieve that we get a nicer graphics. We use\n",
    "* `figsize=[7,7]` as size\n",
    "* `title=\"Top 10 authors\"` as title\n",
    "* `labels=None` to avoid displaying the superfluous label on the left."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaIAAAExCAYAAAA++aaCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xd8XNWVwPHfmRlVyxr3XuSGbWy52xh3ZLpDhwTiEEggJFkTEkjTpirdJCTZTQIxbDaEZJNAwIQACjXBvXfjAtjGxoArruqambN/vCcQssqMNDNvJJ/v56OPpTdv7j2SpTlz37v3XFFVjDHGGK/4vA7AGGPM2c0SkTHGGE9ZIjLGGOMpS0TGGGM8ZYnIGGOMpywRGWOM8ZQlImOaSUSGiUjI6ziMae0sEZmYiUhJrY+IiJTX+npunPuaKyIr3T6er+fxiSKySUTKRGSNiIyMos1HRaRKRLrEGMtBEZkWy3OMMU2zRGRipqo5NR/AW8AVtY79Oc7dvQf8HPhF3QdEJAv4B/AQ0BF4HPi7iAQaakxEgsBVwGngpjjH2myNxWxMW2eJyMSdiGSJyP0ickBE3haRn4lImvvYpSKyS0S+JyLHRGSPiNzQUFuq+ryqPgEcqOfhi4AKVX1AVStxElZ7oLFRy8eAd4B7gVvqxP2oiHyr1teXisgu9/PHgW7Ai+7I765a533K/T6PiMhXY/w5fFtEDgG/FZEeIvK8iJwQkfdE5N+NfB/GtBmWiEwifA8YBeQD44FZwNdqPZ4HpAM9gDuAR0RkQDP6GQFsrvlCVSPAq+7xhtwC/AX4KzBORBo7932qegNwGLjYHfn9yn3ID0wABgOXAz8SkYHuY9H8HNKAvsBdwNeB14AuQE+gKJrYjGntLBGZRJgLfFdVj6rqIeCHwM21Hg8B31PVKlV9GXgZuL4Z/eQAJ+scO4kzKjqDiAwGpgB/UdX9wFLgk83ot67vqmqFqq4FduIkH2j651AJ/MD9OZQD1UAvoJ97bEkcYjMm5VkiMnElIoIz0tlX6/A+oHetr4+oakWdx3s1o7sSILfOsVyc+z/1uQXYoKo73a//DHxCRFrydxBW1aO1vi4DcqL8ORxU1epaX/8IeBd4xb1sd08L4jKm1bBEZOJKnXLuB4H+tQ73w7kvU6OLiGTWefzdZnS3DRhd84WbUEa6xz/ETQw3A8Pd2W8HgR/jJMAL3dNKgexaT+tRp5moS9VH+XPQOs85qapfVNX+wHXAt0RkarR9GtNaWSIyifBX4Lsi0llEugHfBP6v1uNpwLdFJF1ECnAmHSysryER8btJKwD4RCSz1gyzl4AsEfmciGQAd+Mkk2X1NDUL577LOGCM+zHS7bdm0sIm4CMi0kFEegNfqNPGIWAg0Wvq51D3e71SRAa4SfMkEHY/jGnTLBGZRPgOsB1nZLIJWA78tNbje3HuEx0Efg98SlX3NNDWZ4By4Jc4Casc+A2Ae1/lKuBzwAngRuBqVa1vkektwBOqulNVD9Z8AL8CrhGRXDeWXThT0p/FSSS1/QhnMsIJEbkzDj+HuoYDi3AuLS4B7lPVVVH0Y0yrJrYxnkkmEbkU+I2qDvY6FmNMarARkTHGGE9ZIjLGGOMpuzRnjDHGUzYiMsYY4ylLRMYYYzxlicgYY4ynLBEZY4zxlCUiY4wxnrJEZIwxxlOWiIwxxnjKEpExxhhPWSIyxhjjKUtExhhjPGWJyBhjjKcsERljjPGUJSJjjDGeskRkjDHGU5aIjDHGeMoSkTHGGE9ZIjLGGOMpS0TGGGM8ZYnIGGOMpywRGWOM8ZQlImOMMZ6yRGSMMcZTloiMMcZ4yhKRMcYYT1kiMsYY4ylLRMYYYzxlicgYY4ynLBEZY4zxVMDrAIyJh7zC4mygA5Bdz0cGEAaq3Y+qWp+XAu8BR/fOnxNKfuTGGFFVr2MwplF5hcUZwBBgGDAQ6AX0BHq4//YEcuLQ1UngqPtxBHgbeBPYC+wC3tg7f87pOPRjjKnFEpFJGXmFxT5gODAJGImTeIYBeaTOZeRDwA5gI7DB/di5d/6ciKdRGdOKWSIynskrLO4OnOd+TAYmALmeBtU8pcBmYD2wHPj33vlzjngbkjGthyUikzR5hcWZwEzgEvfjXG8jShgFtgH/Bv4FLN47f85Jb0MyJnVZIjIJlVdYfA4wB7gUmAFkehuRJ8LAGuDvwMK98+fs8TgeY1KKJSITd1/+xteHLIzMuAm4Hsj3Op4UtAVYCDy5d/6cV70OxhivWSIy8VEU7AHcBHyiQtNyh1U+MtjrkFqJ14BHgD/snT/ngNfBGOMFS0Sm+YqCAeA64NPAbMBf89C1lUWvbdBzhnoVWisUBv4J/C9Q7MWaJhEpUdWcOsc+B5Sp6h8T0N83gRvcL/OBre7nv1fVX8W7P7fP24GRqvqlOscDwFFV7ZCIfk3jLBGZ2BUFc4HPAHcB/eo7ZWl45OKbq78xM6lxtR0HcUZJD+ydP+etZHVaXyJK5b5FJKCqMSVsS0SpKVXWZpjWoCjYj6Lgz4H9wH00kIQApvi2DfMRCScttralB/B1YHdeYfGf8wqLx3gViIgUichX3M8Xici9IrJGRF4Xkenu8VtF5De1nvOsiMwSEb+I/EFEXhWRrSJydwz9DhCRV0Rki4i8JCJ93OP/JyI/F5FXgJ+IyD4RyXUfExHZIyJdROQqEVktIhtF5EUR6VZPH4Pcc9YCRbWO9xaRZSKyyY19SjN/fCZKlohM04qCEykKPgrsBu4hirU+ftHul/tWb054bG1bAPg4sDGvsPjlvMLiS7wOCAio6iTgS8B3mzh3DNBbVUeqaj7wcAz9PAD8TlVHAY8D/1XrsUHAbFX9KvAscJV7fArwuqoeBZYAk1V1LPAk8OV6+vg18N+qOhGnkkaNTwDPqOoYYDTO5BKTQJaITP2KgkJR8CqKgktwph5/jBhrE94ZeKo8IbGdnWYDz+cVFm/OKyy+xsM4nnT/XY9T8aIxe4CBIvJrEbkUOBVDP+cBj7qf/xGYXuuxx1W1ppLFYzi/mwA3ul+DM1p/UUS24rx5GlFPH+fXOv9PtY6vBW4Xke/iXMYriSFu0wyWiMyZioJTgJXAU3z4BSAmQ2X/6Cwqy+IWlwEYBTyZV1i8Oq+wuMCD/ivdf8N88MYkxIdfSzIBVPU4zohiETAP+F2cYiit9flS4FwR6QxcibNWC+B+4JfuSOw/qH/9mrofHz6o+m9gFnAA+LOIzI1T3KYBlojMB4qCeRQFH8MpU3NeS5sTIedm/0sbWx6Yqcck4F95hcUv5RUWT/A4lr3AGBHxiUhfnNgQkS6AT1UXAt8GxsXQ5irgo+7nn8C51HYGdWZb/QPn0t1mVT3hPhQE3hERAW6Joo/3k42I9AcOqupDwB+AsTHEbZohpRKRiITdG4TbRGSziNwjIs2KUUQmiEi9U0BFZK/7R1L3+Kfdm6pb3JuUV9X3/FrnzxIRFZHbah0b6x6rucH7fRG50P18kYhMaCwGTxQF21MU/AlOMc+PNnV6LG4L/DMjnu2ZM1wIrM0rLH48r7C4fwvbyhaRt2t93BPl85bjVCnfijOJZYN7vDewSEQ24byg/2cMsdwJ3CEiW3AuvTU20eExnGT1WK1jRTijo8U4hWrrcxdwt4is4cPV22cDm0VkI879p1/HELdphpSavl17Cqc7y+UvwHJVbeqmaKz97AUmuDc1a471wfmlHaeqJ0UkB+iqqm820s4s4Fc4754udo/di1NH7f9U9b465y8CvqKq6+qLoYmY/aoa31loRUE/cBvwA+CMWUXxoEp4YuUDx47SoWsi2jcfUgb8EPj53vlzqrwOxphopdSIqDZVPQzcAdzpTsvME5GlIrLB/ZgCICKPicjlNc9zp4te545WnnWPdXancG4UkQcBqafLbsBpoMTtv6SxJFTLW0CmiHR3LwNcCjxXJ57rG2tARD7hTondJCIPiojfPV7ijqhW49xYjZ+i4IU4Wxk8SIKSEIAI/jsDT+1IVPvmQ7KBHwNb8gqLZ3sdjDHRStlEBKCqe3Bi7AYcBi5S1XE4Q/Way26Pul8jIuk4w+p/1mnqu8Aydyrn09S//mUzzhD+TRF5WESuiCHUJ3BWiE/BuSxR2fjpHxCR4W78U93pomE+uF7dDnhVVc9T1WUxxNOwomAuRcE/Ai+RpDpw1/uXpMYlyLPHUODlvMLiR/MKi3t6HYwxTUnpROSqGb2kAf/jTsd8nA+2EHgOKBCRDOAyYImq1p02PAP4PwBVLQaO1+3Evex1KU6hzteBX4pIUZQx/g0nEd0E/DXK59SYDYwH1rrX0mfj7EIKTlJaGGN7DSsKzsRZE3Fz3NqMQo5UnDtU3opmdGni62PAtrzC4k94HYgxjUnpRCQiA3FejA/j3Kw8hDMddAKQDqCqFTjTQy/B+cN7tL62qGea5hknONao6k9w1iRcF02cqnoQqAYuwtl/JhYCPKKqY9yPoapa5D5WEZf7QkXBDIqC9+Hsj9PSG9rNck/g8aSVqjEf0hH4U15h8d/zCovtPp1JSSmbiESkK7AA+I07RTMIHHAXst1MrQKbOMnnUzhrXl6op7kluJe7ROQynD/Ouv31EpHa00vHAPtiCPk7wNebkTj+BVxfU4JERDq500fjoyg4GmeB3pfx8P+7wLdpIKTQzJizz9XA1rzC4jleB2JMXTGtlE+CLPfyVBrOIrk/Ab9wH3sAWCgiNwCv8OFFbS/irL5+WlXrmy30PeCvIrIBZ2Zcfe/O04D7RKQXUIFT8uNz8H4FYlR1QUOBq+qKaL/JOs/bLiLfwlkF7sMZWc0jtiR4pqKgD/gq8H3c0aOX0iTcd6Zv89bFkTG2P5F3ugPP5hUW/xa4e+/8OVHfyzQmkVJq+raJk6JgHmeWRfHcxsjgpddUfT+lYjqLrQOu3zt/Tsve8BgTByl7ac40kzMtewMploQARsuukWmEbH1LapgArM8rLL7I60CMsUTUlhQFvwQ8Tz33wFKBT+h4g3+RlfxJHZ1xCql+I6+wuL61dcYkhV2aawuKguk4Ezs+5XUoTdkX6bZqZtV/TfY6DnOGfwA3750/57TXgZizj42IWruiYGecadkpn4QA+snhsbmUnPQ6DnOGq4DFtgDWeMESUWtWFByMU0F4qtehREuEjDsCxbbRWGoaC6zMKywe7nUg5uxiiai1+mDPoMFehxKruf6Xg17HYBrUH1ieV1iccpNdTNtliag1Kgpeg7MQtlXWcOtAaX4/OfS213GYBnUEXsorLL7B60DM2cESUWvjJKG/Uf+Ok62CCPKlwMLdXsdhGpUBPJZXWHxbk2ca00KWiFqTouAVOJt/pVpFjJjN8a3u43UMpkkC/E9eYfHtXgdi2jZLRK1FUfAynO0m0rwOJR4ypHrQBHnN9ilKfQI8lFdY/BmvAzFtlyWi1qAoeDHwJClQMy6e7gk8ftjrGExUBHgwr7D4s14HYtomS0SprihYADxFK74n1JDzfDuG+4jEd/tzkygC/NaSkUkES0SpzNnI7hkgy+tQEsEv2m2Ob9Umr+MwURPggbzC4mu9DsS0LZaIUlVRcBrwLJDtdSiJdGfgqQqvYzAx8QF/zissnuZ1IKbtsESUioqCQ3BGQjleh5Jo58jbY7KpKG36TJNCMoGn8wqLz/U6ENM2WCJKNUXBXJwClB28DiUZRGj3Sf+Lm72Ow8SsI07l7t5eB2JaP0tEqcTZVfXPwFlV6+tTgeczvI7BNEtf4Lm8wuI2P3I3iWWJKLX8APiI10EkWzdOjOnG8SNex2GaJR/4g9dBmNbNElGqKAp+FPiG12F4QQT/nYGntnsdh2m26/IKi7/udRCm9bJElAqKgqOBh70Ow0vX+Zd09zoG0yI/sm3HTXNZIvJaUbALzoLVNj1NuyntpHLYcNlnhVBbLz/w17zC4jyvAzGtjyUiLxUFA8DjQJ7HkaSEewJP2NYQrVtn4Mm8wmKbfGJiYonIW98GZnkdRKqY5ds0CFS9jsO0yFjgx14HYVoXS0ReKQqO5SydnNCQNAn3ucC3ybYRb/3uzissvsDrIEzrYYnIC0XBNJzJCa1+X6F4+1Jg4SmvYzAtJsAjeYXFtiW8iYolIm98CxjtdRCpaJTsGZVOdaXXcZgW6wvc73UQpnWwRJRsRcExwH96HUaqEiF4g3+xVeRuG+bmFRZ/1OsgTOqzRJRMziW5P9BGdllNlM/6n/E6BBM/9+cVFnfyOgiT2iwRJdc3sUtyTeorR8YGKTnhdRwmLroA870OwqQ2S0TJ4lySs1lyURAh/bOBZ7d6HYeJm9vzCosnex2ESV2WiJKhKOjHmSVnl+Si9HH/v2zGVdtRs8243+tATGqyRJQctwFjvA6iNQlSmt9fDlqlhbZjDPAFr4MwqckSUaIVBXOA73sdRmsjgnwpsHCX13GYuPp+XmFxT6+DMKnHElHifR2wytLNcLlvdT+vYzBx1R4o8joIk3osESVSUbA3cI/XYbRWGRIaOEl27PA6DhNXt+UVFg/zOgiTWiwRJdD5/ft87btdOq0tFynzOpbW6u7AQtu5tW3xY0VRTR2iVuw4IfIfyR8CbAcConrkY6dLtn/l2PHzMpRMr2NrTcIqR4ZU/qlTBJ/NuGpbJu6dP2ed10GY1GAjosT5Hm5RUxXp+mhu+5mT+vc98dNOHZZUgdVSi5JftOsVvpUbvY7DxN0PvQ7ApA4bESVA/iP55wKv4qyfOINf9d1bTp7efefxE5PTbG1Rk96I9F5xUdXPpngdh4m7KXvnz1npdRDGezYiSowv00ASAgiL9Pp9h9zpE/P6Hrq/Q3BZCEJJjK3VGSzvjGlHeYnXcZi4+5rXAZjUYIkozvIfye8OzI3m3LBInwUdg9Mm5vV958Fg7vIwhBMcXqskQvYn/S9u9joOE3dX5hUWn+N1EMZ7loji704gI5YnhET6/6ZTh6kT8/q+9XCw/fIIRBIUW6v1qcDzNsmj7fFhyxsMdo8orvIfyc8G3gI6t6Sd9Ijuvvv48cNzT5VMlkYu8Z1NVAlPrvzNe4fo1M3rWExcVQD9986fc9jrQIx3bEQUX7fSwiQEUOWTQfd27nT+xP59dj3WPme1wln/bkEE/xcCf7fFrW1PJs5VBHMWsxFRnOQ/ku8DXgMGx7vtrEhkZ+F7x09dW1I6Kd5ttyalmrFzROXDtiq/7TkK9N47f06V14EYb9iIKH4uIQFJCKDc5xv23a6dJ03u32f7s+2yz9pFgO2kcti5sne313GYuOsCXOV1EMY7loji55ZEd1Dq8537n926TDi/X5+tL7TL3pDo/lLRPYHH93sdg0mIT3sdgPGOXZqLg/xH8oPAQUhu+Z7ccHjzD44e04Ky8rNmr6OQ+t4ZXPmnXiA2iaNtieBMWrA9qM5CNiKKj4+S5CQEcMrvH/3F7l3HzOjXe9OyrMwtye7fCwGJ9J7t23BWfK9nGR/OZB9zFrJEFB+f9LLz437/mM/36DZqVt/eG1ZlZrzqZSzJ8MXAk6e8jsEkxK15hcU20j0LWSJqofxH8gcC07yOA+C9gH/cZ3p2Hzm7b6916zIztnsdT6Lky5uj0qm2wrFtzyBS5G/JJJclopbzdDRUn8OBwIRP9ex+7sV9e63ZnJH+mtfxxJsIwY/5X7GK3G3TtV4HYJLPElHLfczrABpyIBCY9Ime3c+5rE/PVdvS09/wOp54+mzgWfvdbZuu9joAk3w2a64F3MtyrWNdi6r2D4VW/vzQ0R5Dq6sHeh1OS6lSNbbywdITtO/odSwm7sbunT9nk9dBmOSxd5Utc7nXAURNRPalpU25vnePvKt791ixOy2w1+uQWkKE9M8Gnm3zEzPOUtd4HYBJLktELTPH6wBiJuLbnZ4+5erePfte16vH8r2BwFteh9RcH/f/K+h1DCYh7PLcWabJRCQiKiJ/qvV1QESOiMizsXQkIrOaeo57zkkR2SQiW0TkZRFJyWrLbqXtWV7H0Wwi/tcz0qde0adnrxt7dV+6PxBodQsJg1I2Kk8OWKWFtmdUXmHxAK+DMMkTzYioFBgpIlnu1xcB78TSiYgEYjh9qaqOUdVRwFpgXgvbS5QCPFjEGncigW0ZGdMv79Oz29ye3Ze+G/Af8DqkWNwdeGKP1zGYhCjwOgCTPNFemnuODy5D3QT8teYBEZkkIitEZKP771D3+K0i8riIPAO8WLsxEZnont/gTXMREaA9cNz9ukhEHhKRF4E/ikimiDwsIlvdti5wz/uniIxyP98oIt9xP/+BiNzujroWicgTIrJTRP7s9hWr1ndZrjEi6VsyM6Zf0qdXp1t6dltyyO8/5HVI0bjUt7af1zGYhJjldQAmeaJNRI8CN4pIJjAKWF3rsZ3ADFUdC3wH+HGtx84HblHV99/diMgUYAFwlarW9252uohswtlg7kLg97UeG+8+7+O4IyVVzcdJjo+48S1x28gFQsBU97nTgKXu52OBLwHnAgNrnROLi5rxnNQnkrEhM3PGhX17BW/v0W3xUb/viNchNSZDQgPOk+1tdvHuWWym1wGY5IkqEanqFiAP5wX/n3UeDgKPi8irwC+BEbUee0lVj9X6ejjwEHCFqjZ0k7zm0lxf4GHgp7Uee1pVy93PpwF/cuPbCewDzsFJNjPcx4uBHBHJBvJUtWZx5xpVfVtVI8Am93uLWv4j+T1wVoG3XSKZq7MyZ17Qt3e7z3XvuviYz/ee1yE15O60hSmdLE2z9M0rLG7bf2PmfbHMmnsauI9al+VcPwBeUdWRwBV8+L5JaZ1zD+BsDTw2hj5nNNBeQ5fT1gITgOk4o6ONwGeA9bXOqV0eJgzEes+pOSOo1kkke3l21syZ/Xpn3Nm9y+ITPt9xr0Oqa5LsPNdPOOR1HCbuZnkdgEmOWBLR74Hvq+rWOseDfDB54dYm2jiBc2/lxyIyK4o+p9HwgtElwFwAETkH6Ae8pqpVwH6citircEZIX+GDy3LxcPYkohoiOYuzs2dO79fbf0+3LotP+eSk1yHV8Il2vdK3whZAtj2zvA7AJEfUici9lPXf9Tz0U+AnIrIc8EfRziGckdP9InJePadMd6dvbwZuBr7cQFMPAH4R2Qo8BtyqqjUjnaXAIVUtcz/vQ3wTUX1xnx1Ecl9qlz1zar8+fK1r58UlIqe9DglgXuAfts102zPJ6wBMcliJnxjlP5LvB04DWU2dezYQ1WNXlJRu+eZ7xydmq7bzKg5VykZW/m+klKwcr2IwcRcB2u+dP6fM60BMYlllhdiNwJLQ+1Sk09Ptc2ZN7t+nvKhzp8UVIuVNPyv+RMi+1f+CXZ5rW3w4s3RNG2eJKHbjvA4gFalIl4W5OTPP69/n9I86d1xSKVQkO4ZbAy9kJ7tPk3CjvQ7AJJ4lotgN8zqAVBYR6fZobvsZk/r3PfHTTh2WVEHS7t104eSYHhxrFQtxTdTGeB2ASTxLRLEb4nUArUFEpMefgrkzJuX1PfpfHYNLq6E60X2K4PtC4Mmdie7HJJUlorOAJaLYWSKKQVik1/92CE6fmNf30P0dgstCTrWLhLnGv7xHIts3SXeu1wGYxLNEFIP8R/IFGOx1HK1RWKTPgo7BaRPz+r7zP8Hc5WFnIXHcZUvl0HzZ06Z2oz3L5eYVFtvmh22cJaLY9MFmzLVISKT/rzp1mDoxr+9bDwfbr4g4U3Tj6u7AE+/Gu03jqTyvAzCJZYkoNnZZLk6qRQb8olPHKRP7933z/3JzVirEbUHbDN+WIWAL5NqQ/l4HYBLLElFsLBHFWZVPBt3budP5E/v32fW39jmr4tFmQCK9LvSt3xKPtkxKyPM6AJNYlohi09PrANqqSp9vyA+6dJo8qX+fHX/Pabe2pe19MfDkqXjEZVJCntcBmMSyRBSbzl4H0NaV+3zDv9O188TJ/ftsf7Zd9rrmtjNS9o7KoCrpi2pNQtjmh22cJaLYWCJKklKf79z/7NZlwpR+fba+mJ21MdbnixC80f+KlfxpG7p4HYBJLEtEsbE/iCQ77fflf7l717HT+vXevCg7K6bE8plAsf1+tw1BrwMwiWV/qLGxEZFHTvr9o7/QveuYGf16b1qWlRnVRITeHB3bkVPHmj7TpLgOXgdgEssSUWwsEXnsuN8/5vM9uo26oG/v9aszM7Y1dq4IaZ8LPPNqsmIzCWOJqI2zRBQbS0Qp4mjAP/72nt1HzO7ba+36jIwdDZ13k/+VTsmMyyRE+7xCu8zaltl/bmxs07UUczgQmHhrr+7DL+7ba82WjPTX6j6eK2UjB8i7b3kRm4kbAXK9DsIkjiWiKOU/km8/qxR2IBCYNLdn93Mu69Nz1fb0tF21H7s7sPBNr+IycePZ7r8m8ezFNXridQCmCSLydlra5I/16jHwit49V76WlrYH4FLfWisR0/r5vQ7AJI4loujZz6q1EPHtTU87//rePfKu7t1jxf50ON+3rdGJDSbl2d9fGxbwOoBWxEZEKSqzSktzyjmdW0ZJ+zItC5ZR2aGU6mCphoKl/shiHfT66KGHD+8f13Pv7rShufY/2fpISbUVsW3DLBFFz16+EkBUI9kVnM6poCS3jNJgqZbnllHRoZRQsFTDuWVEcsuQnAr1Z1eQlllNeno1WWlhsn0R2gu0F+f+Qb33EPb2u3j57r4TgueVlNHl5NNZ6QMP9f6bzN2/gQmDI+LvneRv1zSTBtMtEbVhloiiZ5cG6uEPa3W7Ck61L6c0t4zSYJlW5JZS2aFUQ8FSwrll0L5cyakgkFVJWmYVmekhMgNh2vmU9jiJJEicV8+fzum7a9PoO0uq03KmVp747cbOuR/N3rx/omTphkNfGvTTKQiBtTp5wxN8rOId+o5FxPaZSm0J3dnXeMsSUfTa5Duy9GqtyKngVE45JbllWh4spaJDKVXBUq0OlqG5ZdC+TH3tKvFnVZKeUU1mWogsf4R2PiVXIBtnfVVKrLEK+9JLt478zNpjHYdPRSQtVLFuBVo+Jd2XuXpCaFD6y++WjY1E/GuGDFk1ZpKsGjeJVZSRfepZvWrdS1zaoUxy8r3+Hky9LBG1YaK2f1jU8h/JD5Fis3eyKrUkp5zT7T9IJB/cHykj0r4MaV+uvuxKAllVZKRXk5l9SUFGAAAgAElEQVQWJtsfoZ04iSTD6+8hXt7uNX3V60Nu6If4ewGoVp6qPPFABWi3q/t9YXO6P2vUwxmv7I+I9uvabc+6oUOXjxQhs3Yb++n75mPMfWsz486JiN+2/UgdnQ9eMMbKNbVRNiKKzWniWG5EVCPt3h+NUOomkio3kTj3R8qRnHL1ZzuXtdLTQ2QFwrTzR96/rJXDWb7QtjSr+76NY+46UpXRYXLt41UlT20CnQHgl7RsQWRApNubu/2H+h05PHCCRnzrhw1feq7IB9u/92X/gK8wf0AEiazWKesX8tHKA/Qeh0hm3X5NUtmWHm2YJaLYfCgR+cNanVPByffvj5S+f38kHCwjnFvq3B9pV0Egu5L0zGoy0txE4t4fyRGnPaul1QxhX6Bix7BbVh/uOvY8RD60VigSenenht6ZWvO1T/ztASZWDz5nt+9QGMF/9Gje+O3b/ZvOPXfREJEPT3bwob7zWT7+fJZTSruTT+s1a//FJZ3KJXtEcr47U0vpwQvGlHkdhEkcuzQXgxXjhz/TroLhgQg57mUtu8HtkYPdJqzbMezmruoLnLFYVVW18sT926Hq/aTx0byvlYs7IeEvGcvWlknlxJrHOnZ8Z8uIkf8eIEL7pvrdR97ux5j79hbGDFPxdY/X92MatfvgBWMGex2ESRwbEcWgYyk5wCCv4ziblWd0OrBxzF37KrK6Tm7onFDF8mVQNb3ma5/4K6TWrLixobzI8rQPytIdP9571NatF27Lz3+5j0jjs/f6s3fQ1/jRoAi+8Aqdtu5Jbqg+RM9xiLSZe20p6IDXAZjEsinJsXnP6wDOVhHxVe8YOnfxysnfz20sCWmk7L1wxZqRtY9l+LJP1v56aLjXOJQjtY+dPNFzxJbNF7+ryvFo4vER8U9jyYRf8IXzF/Cpssv06SWZWr49lu/JRO2g1wGYxLJEFJsjTZ9i4u1o55Gbl0z7+b4DPafMRKTR4pdVJQt3AB1rH8v0Z5+u/bUPX1rvSKczksapU92Hb9506WHV2N5wtOd0x0/wyIz/5RPn/lC/sitfNy0WjdjvSvxYImrj7NJcbGw7gSSqTM89smn0F14vbddratNnQ7j6zS0aPnLGuZn+nDNudE8KDe77d/+aM9o4fbrr0I0bL981duw/IyJ0jTXmAbw5uJAfDA7jCy3XGWv/zg3hw3Qfh0h6rG2Z91kiauMsEcXGthNIAkUiuwZds2x/n4LRiESVhFQjoeqSZ7KopxRTViDnjKm/nbX9wHQNbKmS0Ki6j5WWdB68ccNH9owdVxwW0R7N+R78RAIzWDRxBos4RftjT+n1WxdxYfdKyRzWnPbOcnaPqI2zS3OxsUSUYMeDQ7YvmXbfa/v7zp6BSNRlf0Jl/14OoSH1PZblz6mq7/jIUN9TDbVXWtpx4Pp1V1SqyrvRxtCQXE53+iQPz/w9c4d9X7/++gjdslg0crSl7Z5FbETUxtmIKDaWiBKkOpB9YvOo/9h6qn3eVERieoOkkVMHwlVbxjX0eJY/J1zf8fxwv7EbAm+epoFp2+Xlwf7r1l25f/z4p9/2+bRPLDE1ZBC7zvkG3zsnhL96qV6w+imuk6N0HYtIWjzab6MsEbVxNiKKwfCdOw4DpV7H0ZYo6Jv9L1u2dOq9oVO5A6bHmoQAqk4/sRcaXgOUGah/fkMagXZdtP2mxtquKM/tu37dVRKJ+PbFGldjAoTTLuDl8/6bz096gNtOXqjPLU7Xytfj2Ucb8rbXAZjEsgWtMdoxbPirgK2uj4NT7fu9sWnUneWhtHZn3KeJVrhq5/rq0n+Ob+ycC3vevLRzZq/p9T32ru/Ytn+mb2zy/zMjo/TAhIlPVfh8kQHNjTUarzP0tceYe/A1huer+Dolsq9W4sjBC8Z08zoIk1h2aS52r2OJqEVC/oySrSPuWH+849CpiDT7d1A1VFld+nyTVb/T/ZkN9tEr0mmEX327whJpdOV+ZWW7nmvXXHN44qS/7/b5Iglb1HwOrw39Nt8ZGiJQtUhnr/oH1/qP0XlsS35OrdxWrwMwiWeX5mLX6KUc07j9vWetXDLtvtPHOw2b2dIX1+rS51dCJK+p89J8GY0WLD0n3POdaPqrqsrutmb1tcFw2J/wS2gBQukX8sLkX/PZib/h9uMF+uLiNK18I9H9pqCYEpGIdBeRv4jIHhFZLyIrReSaRAQmIkUi8hX380wReUlEvhuntveKSJcozlskIhNqfZ0nIq/G2FcHEfmP5sQZL5aIYrfB6wBao9LsHnuXTfnJ+jeG3HA+4mvx9gqR8LF9kerXG6ywUFtA0hqtCTguNDAfpd6ZdXVVV2d1WbP62q7hcGBHNOfHQ0dOdL2NB2f+gY8P+bZ+a8c5umMJqlFVgGgDok5EIiLAU8ASVR2oquOBG4EzJppIHEeY4qwRWwisV9Xv1Y1JmnHfM1lExI9TdNkSUStjiSgGYV9a+ZYRn1m8euK3elal5zZ6LycWVacfPwJEtTVDTeXthmSR3ilXs9ZH23colNlxzepre4VCaduifU68DGPH8O/yrRl/4MbsT+rvVnXU99aiWu+swDZiSwznFgBVqrqg5oCq7lPVXwOIyK0i8riIPAO86B77qoisFZEtIvJ+EhGRb4vITneU89eakU89AsCjwBuqWug+N09EdojIAzivF31F5CYR2Soir4rIvbX6+a2IrBORbbX7d31BRDa4z4t5/Zkbx1K3jQ0iMsU9PktEXhGRv+Ak+vnAIBHZJCI/cx9fLCJ/E5HXRWS+iMwVkTVuLIPcdq4QkdUislFEXhaR7u7xIhH5vTta2yMidzUV69l63bnZhu/c8e6OYcMPAVZ5uQkHup+3dufQuT3U558Zz3ZDFZtWoaVRjYYABF9uU+eMDw1MfyU9+rwSCmUE16y+Viad9+TWQKA66bu6phHKuITnJl/Ccxyj06En9MadK5jep1rS21JR3ipgcwznj6DpN4rnA6NU9ZiIXAwMASbhLIR+WkRmAGXAdcBYnNfIDUBDb1S+Brysql+qc3wo8ClV/Q8R6QXcC4wHjgMvisjVqvoU8E03Fj/wLxEZpao1yfeoqo5zL5t9Bbi9gRj+LCLl7ufpQMT9/DBwkapWiMgQ4K9AzWW8ScBIVX1TRPLcz8eAk6iA0cBw4BiwB/idqk4SkS8CXwC+BCwDJquqisjt7s/iy277w4ALcGazviYiv1XV6gbitxFRM230OoBUVp7Z+Z0Vk7+/ZsfwT05Un79vPNtWrSoJlb9yxtYPDREkJCJNbu8wMNJ9rKhEda+oRjicnrtm9XUDqqszPL1v2Ilj3e/ggZl/4KZB39Dvbhusry1F9WTTz0x5Ww5eMCaqS6b1EZH7RWSziKytdfglVa3Z6fVi92MjTrIZhpOYpgH/UNVyVT0NPNNIN8uA80XknDrH96nqKvfzicAiVT2iqiHgz8AM97GPisgGN4YRwLm12njS/Xc9kNdIDHNVdYybSC6vdTwN+B8R2Qo8XqftNara2LrItap6QFUrgd24I0icEVRNLH2AF9z2v8qHJ3EVq2qlqh7FSYiNvnG3RNQ8dnmuHhHxVW8fdvPiled9r2NFZudJieijuuSZ9aBR32PK8GefiOY8QXx5ka4xTwYIh9Ny1qy+9pyqqsyU+J0Ywasjvsc3pj/MTRlz9eGVHfT4OlQjTT8zJa1t+pQP2Qa8v7BZVecBs+FDNQNrrwMU4Cc1L+KqOlhV/5d6ykQ1YgnO6OA5d+TTUD9nEJEBOCOd2ao6Cijmw5ebK91/w7hXr0TkBfcS2u+iiO1u4BDO6GYCzmipvvjqU1nr80itryN8cCXt18BvVDUf+GwDsX8o/oZYImqeZV4HkGqOdBm1ccn0X7x1sMfkmYhkJ6KPSOjQrkhoX1S152pk+D5cebsxE0ODBqPE/KIdiQSy16y55tyqyqx1sT43UdKpzrycZ8+/n9sn/DefOzRdX1kc0OrWVhnkzKq0jfs3kCkin691rLHfxReAT4tIDoCI9BaRbjh/31e4M+FygDmNdaqqC4GfAc+LSH27La8GZopIF/cS3E3AYiAXJyGcdO+vXNbUN6iql7hJs6HLdLUFgQPqvBG5GfA3cN5pGlkQ3kT7NVcRbmnG899n94iaZwlQjTP0PatVpgcPbxx9166ydj2mJLqvqpKFpcT4O5sZaBd1JYxcze6TRfqGcqoaLBfUEI0EMtesuSZ/4sSn1mRkliVkNNhcXTja83P8pufn+A1bdPSrj3PT8T0MHo1Ik/fOPLY8lpPdexVXA78Uka/hbNtSCny9gfNfFJHhwEpnwh0lwCdUda2IPI1zf2ofsA5o9FKnqi4QkR7A08AddR47ICL/CbyCMzr6p6r+A0BENuKM5PbE+v1G4QFgoYjc4PZd79+Cqr4nIsvdad/P4YzMolEEPC4i7wCrgGYv9rbKCs20Y9jwZUBM787bEkXCbwy+ftnbvWeOTcYLWqh81fJQxYqYf955OSPXntd1zsSmz3S86n9r5aq0N86PtZ8aIpHq8RP+sT4rqyTqyRReqCS9/EUu2/hPrsw8RXBMc0orJdiugxeMqbeIbTKISI6qlogzul8C3KGqKXH5tS1KtV++1uRfXgfglWMdhr66ePrPd73dZ9bMZCQhjZSfCFWsqHszOCoNVd5uyPBwn/Eox5o+s36qvrR1a6+aUFaWu6K5bSRDBlVZV/CPKb/ltnG/5D8OTNEli/1aHdd6ei30T4/7f0hENuHcD15oSSixbETUTDuGDZ+Bc533rFGV1u7Y5lHztp3O6TcN91pGMlSe+utSDR+ot1ZcU8Z1vmjJkNxxM5o+8wPFaRuWHPAfj+k5Z4qEx41/dlW7didb1ah5I+O2PMFNp/YyYDRRzDZMoEsOXjDmxaZPM22BjYiabxXOeoM2T0H35H1k2bIp93K6ff/pyUxCker92zV8oNkv5pn+djG/05oUGtziyg/g829Yf8X5JSUdW9XElrFsGPUjvjrt98z1f1T/vLy9ntxE8t+tlnKWvck721kiaqbhO3dUcRb8sZzMHfDa0mk/e3Vv3mXTEElqNWhVjVSVPCW04Pc0058dc9LsqrlD0tQfh6oJ4tu4Yc7UU6e6LGl5W8mVQWX2VTw5dQGfHvNz7nznPF2+2K+h/Unq/l8HLxhT2fRppq2wWXMt8xRRTLlsjUL+zFNb8j+76URwyFScKafJj6F8yTKobtElsgxfVrN+x88N9zm2ORCPWyYimzddNmPUqBcWBzscjmuFiWTpwcE+d/GLPgq6QSdseoKbSt+i/xhE6t/oqeWinbVl2gi7R9QCO4YN7w68SxsbWe7rO3vF7oFXD0J8npUx0kjJkcqTD6XjrFVotiv7zlufFciJucZdFaHTf8xY7EOI24vtyPyXF3fseKBVJqO6yskseY4rNr3AnPYl5IyK8+XavgcvGGOb4Z1FmnwBFZHO7kreTSJyUETeqfV1ej3nB0QkqtXsTfT7dn2Lw0TkGhH5aj3HbxeR/2phn+eJyC+jPX/4zh2HgJSeHRWLkna99iydMn/j7kHXTvEyCQFUnV74Oi1MQgABX+OVtxuSTqB9J82JaymnV7deOPO99/osimebXsmiIudaHp/2ILeOvo+79k/UVYt9Go5H8thiSejs0+RlC1V9D6gphlcElKjqfQmOq7F4/p7AtlfjrIKOxd9walO1WmFfetmr53567XudR56PyEDP46navUkj78VltplfAjnNfe7E0KDcF9JjqbnZtO3bLpg1bPiSRV277psV14Y91JN3+32Jn/VT0HV63sYnuLHsbfqObWaFDbssdxZq0SUlEXlGnM2ntrnVV+s+3tUtE36piOSKyL/dcuRbROQj7jntReQ5tzjhqyJyfa0mvuSWGN9SU1SwqZGPOyLb437eRUQitcqfrxSnNPpk9/ON7oriIe7jF4rIUzH+GJ6A2MvCpIp3e05ZvWTafcfe65I/k3pGuMmmGq6uLn02btOGo6m83ZC+kS6jfCpxL4uzc8eMWYcODVwU73a9JiATWT32Xu6e+jtuDl+jf1vaTkti3WH10YQEZ1JaS+9t3OJuPjURuEdEOtY8ICI9cRal/aeqPg+UA1ep6jjgQqDmEtjlwF5VHa2qI4GXarV/SFXHAr8D7okmILe67R4RGYozUlkPTBeRLKCbqu4FdgDT3LZ/APywed8+DN+54wCtcPZcWVbX/csn/3DNzqFzz1Of/4yNw7wSKnt5BYTjtZVBBKeeV7MNCfdMyCLP11+bOuvAgSGt7vcmWlmUt7+ex6Y/xC359+oX947TNYt9Gn63iadtOHjBmFj2HzJtREtnzd0tIle6n/cBBuFspZ0OvAx8VlVr1lEIcK+ITMN5gegrzla4W4D5IjIfeEZVa9dbql0GvXZ586YsxSmzPhz4CfBpnEtuNZfdOgB/FHeDpzh4GGfvjZQXEX/VjmE3rzjUbcJ5iMR1i4aWioRPvhOu2jah6TOjk+7LPNVAEcqojQ8NHPGa/90QEv8ZprvemDwzEvEv7t17Z5uYwNCQPryd92XuzYsgkTV6/vqFfKzyXXqPxXlzWNvDngRoPNfsEZGIXIjzYj9ZVUfjJJSaMuDVOAnp4lpP+STOzedx7r4ZR4FMVd2BU6J8G/AzEflGreecUQY9SkuB6W67zwJd3Fhr1nP8CHjBHYFdTZQ7fTbicWh+WZhkOdR13PrF03/xzqHuE2fV8yLgueqSx9+G+M1Sy/C3O9XSNrLJ6JqjmVHv3hqrPbsnztz/1oglqrT56as+1DeZFeN/xhenPMQnq67UhUuztbTm0l0l8Bcv4zPeacmluSBwTFXLRWQEzuW5GopTFny0fLDFbhA4rKohEbkI6A1O6XWcCRB/An5Brf1EWmAlMBNn2+AqnM2cPoOToGpiqSlffmtLOxu+c0cF8MeWtpMoFRkdDq6c9N2V20bcNl59gWZXyE2kcOW2tRo5dV4828zytyuJRzvjQgMTOj1/795xM97aN2q5NmMLitaqHWXBj/GX6f/DJ/Pn691vTtEl9x+8YEzKv5kzidGSP7BiIFtENgPfoc5sM/dezUeBS0Xks8CfgCkisg64AajZhGw0sNYtMPg14MctiKmm73Kc9T01U6uX4uxLst39+l6c0Vc8y64/GMe24iIivtDOITcuXjH5h+3Ks7s1u6J0oqlWl1eXvdQj3u1m+tuVN31W0wZHeowT5WA82mrIW2+NnrZ379iVqoQT2U8q6stbA+bx343tgmraOFvQGkc7hg1fzAdbAHvqvY7Dt2wdeUdWxJ/uWSn9aFWVPL04Ur0r7vdJhgYnrRjT6YK47JP0YtrmRW/5j86KR1uN6dV7x4qBA9dNkgTck0ph22cX7B7R9GmmrTqbftmT4SE8TkRVae2Pbhp1586SnN5Tk1mctLki4aNvRqp3JWTvnix/TihebU0KDR7wlu+oIjFtIx2zd98ZPkUjvlWDBq8ZL3LWbLz4gNcBGG+1qdI0KeBxPrj3lFSKRHYNvGrpsik/CZS075PUbRpaour0E8eAjES0neXPidtwv4O2659J2qZ4tdeYAweGTn799fM3qnI2FP48TQrfXzXJYYkojtyK3L9Idr8ncgfuWDLtZzve6nfxdFo4XTmZQhUbVqJlMdeBi1ZGMypvNyY/1D9p234cPjR40ms7p21VpSJZfXrkT7MLdp/2OgjjLUtE8fcg8F4yOqoOZJ1cP/aeJRvG3jM0HMhqVdfYVStPh8oXJ3QGX4Y/O65Vw0c4u7eejGebjTlyZMCEHTtmbFdts/teVQE/9ToI4z1LRHE2fOeOUuDXie5nb7+Lly+d+tOqk8FBMxBpdf+P1SVPbwCN+0y52tJ9GXEtWRTAn9ldg/EtPteE9472H7d92wVvqBKXqegp5sHZBbtTaXty45FW9wLWSvwKEvPCcTqn766lU+/dtGfgVVMRX9dE9JFokdCB1yKh/QkvFBuQ9Lgv2p1UPbhbvNtsyrFjfUa/+ursN1Vp8QLdFFJKC0prmbbFElECDN+54ziwIJ5thn3ppZtGzVu0dvzX+1en5YyJZ9vJpKpaVfJkFZDwzfb8vkDcN27rrh2GBdS/M97tNuXE8V75W7dctF+TeGkwwf57dsHuw14HYVKDJaLEuY84jYre7jV91eLp95081uncWYi06im9oYqVy9HK/GT05cMftyretQ0P9/bkBfTkyR4jNm++5IBq6peTasJx4GdeB2FShyWiBHE3zWvRjdjSrO77lp3/o3Wvn3PjZMTfK06heUYjZcfCFavOTWKXCZlBOCaUNxqPZrOdPtVt2KZNlx1V5agX/cfJT2cX7G7x5pmm7bBElFg/pxnrisK+QMWr5962ePWkb3evyugQt2rUXqsq+fs2oFMy+kqT9NMikpAF2xmkBTtou4QVQm1Kyeku52zcMOekKq3x0tZBnHuoxrzPElECDd+5owz4VizPOdhtwrol035+6HC3cTMRaWlV8JQRrt73qoYPJW0n2wx/dkJv7E8IDYr7/adYlJZ2GrRh/RWlqnLAyzia4YezC3a31enoppksESXeH3G2xGhUeUanAyvOK1q1/dxPTVBfoH8S4koa1Ui4uuQfaZDY8ji1ZfrbJXSRZP9Il9E+FU+nHpeVdRiwft0VVariSTWPZngTpwyWMR9iiSjBhu/cEQG+0tDjEfFV7xg6d/HKyd/PrcjqmpCaa14LlS9aDqGhyewz058Tl8rbDRFEBka6x30b8ViVlwf7r1t7pUYist/rWKJQNLtgd7XXQZjUY4koCYbv3PEvPtht9n1HO4/cvGTaz/cd6DllJiKeXupJFI2cPhSu3JT06eZZgZyETyaYUD1oGCmwbUNFRW6fdWuv9kcivlReHLocZysYY85giSh57sIp8Ehleu6R1RO/uXxL/udHR/zpgz2OK6GqTj+xG8hNdr/xrLzdkBwye7Qjw7NJC7VVVub0Wrvm6oxIxLfH61jqUQl8ZnbBbttzxtTLElGSDN+5452I+L7xxqBrlyw//8fppe16TfU6pkQLV72+QSPH47IfUKyy/DlJ2e10bGhAyry4VlW167FmzTXtw2H/Lq9jqeNHswt27/A6CJO6LBEl0aKZv35gf9/ZaYgEvY4l0VTDVdWlz3X0qv9Mf3KudJ4T7jke5UhSOotCdVV217Vrru0YDvtf8zoW11ZgvtdBmNRmiSiJ5i0oiACfhra/z0x12YsrIZzQ6tqNiXfl7Yb48AX6RDpvS0Zf0aquzuy8ZvW13cLhgNejkDBwu01QME2xRJRk8xYU7ASKvI4jkSLh429HqnZM8jKGdF9mXCtvN2ZSaHDKTbcPhTI7rl51Xa9QKO1VD8O4d3bB7jUe9m9aCUtE3vgpsNjrIBKl6vTj7wJxr3wdi4AvPWmLgTtpzoB0DWxJVn/RCofTg2tWX9e/ujrdi9g2EOMbLhG5RkRURIa1tHMRyRORM5Kwe7xcRDaJyGYRWSEiSV1aYM5kicgD7iW6uSRpA71kClVuXYOWeDoaAghIIDuZ/eWH+qXkLqPhcFr7NauvHVRdnZGUbc5dFcAnmnFJ7iZgGXBjfQ+KSLwut+5W1TGqOhp4BPhGtE+MYwymFktEHpm3oOAdnPtFbYZqdVmo7OWUKM7qk8RU3m7IyHC/saTofkGRSFq7NauvHVpVlZmsqeaFsc6SE5EcYCpwG7USkYjMEpFXROQvwFZ3RLNDRP5HRLaJyIsikuWeO94d5awE5kXZdS5ONXBExC8iPxORtSKyRUQ+W18M7rFvi8hOEXlJRP4qIl9xjy8SkV+KyBI3zoki8qSIvCEi7++/JCJPich693u4o9bxEhH5kft9rBKR7u7xP4jIr9wR3B4RuT6Wn2+qs0TkoXkLCp4GfuN1HPFSXfrsWtA+XsfhSO7MxDT82V01N6m7t8YiEglkrVlzzYjKyqx1Ce7qOZpX1PRq4HlVfR04JiLjaj02CfimqtZUbh8C3K+qI4ATwHXu8YeBu1T1/Cb6GuRemtsN3AP8wj1+G3BSVScCE4HPiEjNhJv3YxCRCW6fY4FrgbqFiatUdQbOnmT/wEmKI4FbRaSze86nVXW8+9y7ah1vB6xyR2tLgM/UarcnMA34CG1sJqIlIu99BUjZF7BoRUKHd0eq3/RkzVBdfgmUiwcFYyeGBndu+izvaCSQuXbNNaMqKtolagLBDuCmZi5cvQl41P38UffrGmtUtXY5pTdVteZS43ogT5wlER1Utebea2NVHGouzQ0CvsQH9e8uBj4pIpuA1UBnnKRXN4ZpwD9UtVxVTwPP1Gn/afffrcA2VT2gqpXAHqCv+9hdIrIZWOUeq+mnCni29vdWq92nVDWiqtuB7o18f62OJSKPzVtQUInz7qpVb3ZWVbLwFJASm/Zl+LI92cW0V6TjuX71veFF39FS9aevW3v12PLy9ivj3PR7wBWzC3bH/LN3RwMFwO9EZC/wVeBjIlJTJLe0zlNqL38IAwGcgrrNSYBPAzNqQgG+4CapMao6QFVfrCeGpor31sQXqRNrBAiIyCzgQuB8d+SzEah541StqjXfR833VrfdaGJoVSwRpYB5Cwp2AzcACS9LkwihirUr0PKxXsdRI9GVtxszNNzrXa/6jpaqL23d2isnlZXlrohTk9XA9bMLdu9u5vOvB/6oqv1VNU9V++JU6o562xBVPQGcFJGa58yN8qnTgJq4XwA+L+4uyCJyjtRfA3IZcIWIZLr3tuZEG6crCBxX1TJ3hmCbLHYcC0tEKWLegoJ/A1/0Oo5YaaTiZKh8WUrVy8sMtPNsv5uxoQH5aGtYsOzzr1935eTSkg7L4tDYnbMLdi9qwfNvAv5e59hC4OMxtvMp4H53skJj1ddr7hFtBn4M3O4e/x2wHdjgTv1+kA+PSABQ1bU4I6nNOMWM1wGxjASfxxkZbQF+gHN57qwmH4wCTSq4/3P/fgD4vNdxRKvy9GNLNPTOjKbPTMnZLi0AABS9SURBVJ5B7cesntDlkvO86v/x9JUrTvrKUuJ+WdM0MmbsP5e3b39sejMb+NXsgt2t7g1US4lIjqqWiEg2zqSCO1R1g9dxtVY2Iko9dwGveB1ENCKhd3Zo6J2UK96a5W/vaUmZ8aGBGV72Hxvxbdp4+bRTJ7suacaTX8CZdXY2esid1LABWGhJqGUsEaWYeQsKQjiTF7Z6HUtjVDVSdfrvESDlFvhlBdp5ukfQgEi3caLytpcxxEZk8+ZLZ5w40T2Wah87gY/NLtjt+X5MXlDVj7sTGoap6k+8jqe1s0SUguYtKDiOM5W0uTd/Ey5Uvmw5VI3wOo76ZPpzPO1fEMmLdE3Z/7uGbN1y8cxjx3otiuLUYzRzhpwx9bFElKLmLSg4CFwEpNwsLI2UHg1Xrh3pdRwNyfBne/57PSk0eAhKUvZEiqdtr86edfRo30WNnFIKXDW7YHeq7XlkWjHP/2BNw+YtKHgTZ2SUUmuMqkqe3Al4ttdQU9J9mZ6vZ2qvWb2ySG+V9w12bJ816/DhvPou05UCl88u2B2PmXbGvM8SUYqbt6BgG3AZUOJ1LADh6je3aPhIyk1QqC3Nl5H0qgr1GRPKa5XrwgBe2zl95sGDgxbVOlQGzJldsLs5kxqMaZQlolZg3oKCNcAl4G1RTdVIqLrkmSxSfFV3QNKSWnm7IcPCvcehrbfC+huvT5n17rvnLMZJQh+ZXbC7zW5dYrxliaiVmLegYAVOWZDjXsUQKvvXcggNafpMb/nE49kKLj++9F6Rjl5uTNdiu3edN373rgmXzC7Y3SqWFJjWyRJRKzJvQcFa4ALgcLL71sipA+GqreOT3W9zSJIrbzdmUmhwb69jaIFjwOw77njM7gmZhLJE1MrMW1CwGac+1r5k9lt1+ol9QEqMNBrjw1fVQH0wT3TR3MFp6m+No6KDwKyioiLb6tsknCWiVmjegoI3cJJRUraADlftXKeRE62iMGO635vK240ZEe7r2eXUZtoHTC8qKkrpRdWm7bBE1ErNW1DwNk4yKk5kP6qhyurS57smso94yvRnp9wuqaNC/cegZ2xlkKrWAdOKiopsnZBJGktEDRCRa0RE3TLtNcfy3Kq8dc99U0SG1jn2XyLyNRGZICLN2bGySfMWFJwGrgT+KxHtA1SXPr8KIv0T1X68Zfq9q7zdkHQC7Ttrzkav44jC/+IkoVZUnsi0BWeUODfvuwln35EbgaImzn3UPe97ACLiw9ljZaqq7sN5l/khIhJQ1RavM5m3oCAC3H3/5/69E2fb8bj9n0bCx/ZFql/3rIp1c2T52zdW/t8zE0ODg8+nb2r6RG9UAV8oKip6qMkzjUkAGxHVw93sairOHvY3RvGUv9Y5bwawV1X3icgsEXnWbbdIRB4SkReBP7obaz0sIltFZKOIXNDcmOctKHgQuJw4VmGoOv34ET7YObJVyArkeFp5uyF9Ip3zfSp7vI6jHm/j3A+yJGQ8Y4moflcDz6vq68AxERnX2MmqugWIiMho99CNOMmpPuOBq1T148A89/n5OCOwR0Sk2S/88xYUvASMAVq8DXSoYtMqtHRCS9tJtix/TspWMxgS7rnf6xjqeAUYZzPjjNcsEdXvJpzLbbj/3hTFc/4K3CgiAeAq4PEGzntaVWsuH00D/gSgqjtxZiud09ygAeYtKNiPMyL7KdCsXQ9Vq0pC5a+0mvtCtWX6U2bm9hkmhAaNQEmVEdvPgIuKior+v717D6+rKvM4/v0lTe+1iIgMpjRCBYROuQzU4VIohTqikXEQiDIzUhAQYXgUUi4OiBsv0HHIg6BAEYWKA50IFB6IDJehLbcKRQokLRStUARRplRbCFBomnf+WOu0u+k5J0lzkn0OeT/Pk6fn7LP32itJc96z9trrfVdl3RHnfI6oC0kfAqYBEyUZod6OSTq3m0PnAvcBDwKtZlZo0Wn67ql+SZUTaxqdd9Vp8x8EbgQ+1Jvj17ff9STYof3Rt/42vHpU2aYfGsHQ7cbY8Mfe1Losb4VvB05MkuTWDPvg3GZ8RLSlY4AbzWy8mdWZ2TjgRcLopSAz+z2wGphF4ctyXT0E/DOApF2BnYDnt7bjXZ0xe9rdhEt1C3t6TGfHays6O14q66SmxZRD5u1i9u3YOcsPf63AZA9Crtx4INrSl4Dbu2y7DTi+B8fOBXbPc3whVwPVktqAZmCGmb3b0472RFxvNI0wH9VtBu/32m97iwoeKddUDSvrMt0TOnfYV8afBvi07wHfBvZLkuS5AT63c92S2VZNI7gKdNVp8+uAnwKH53u9453HHu1Yt6hiR0MAR48/67maqqGfyLofxdxf07rwpepVUwfodIuBk5IkWTZA53Ou13xENIicMXvayjNmTzsCOJUuJSWs8501HesW9elGiXJQXSaZt4uZ3DFhF2zrbiTphbeBc4ADPQi5cueBaBA6Y/a064A9gV/mtr3XfkcbUDGpfAoRVWWTebuQsTZy3HBq+nN16x3AHkmSXJYkyYZ+PI9zJeGX5ga5q06bf9iG9SvPXt8+7zNU+AcToQ3H1p1TJals75zLaa1+adHimhUHlrjZFwgZEu4ucbvO9auKfuNxfXfG7GkL1rfP+zxwOvBa1v3pi6FVI9ZWQhAC2GND7b4Ya0rU3NuENFR7ehBylchHRG6jpob60cC5QCNQFuW2e+MDNdutPLL2K3VZ96On7hr65EOvVa05pA9NtBPuvLzMF6a6SuaByG2hqaF+R+A7wIlU0Kh5++Hjlx32N1/cM+t+9NT/ae3zdw77zW7d77mFN4AfAZcnSbK6xN1ybsBVzJuMGziNzS2vNja3nAzsBlwJvJlxl3pkxJDRZZl5u5DtbexuQ6y6N+t61hAyvI9PkuTCvgShWOLkF6nnQyStyiXoHUiSZkpaLmmppGckfbmfz5dImhkfL5S01TkVJe0q6W5JKyQ9J+mXkj4iaYakH/eyrZWStuvF/r0+R7mq2IWLrv81NresAL7e1FD/LcLo6Exgl2x7VdiI6tHvZd2H3vrEho++3jbkD93tthq4HPhRkiSlKvz3FiGN1YiY+3A68McStY2kajPr9o49SafFc082szckjSUkHe7peUpSTmVrxATFvwLONrO74rbDeB/cfTrQfETkutXY3PJGY3PLFYSErEcBD2TcpbzKOfN2IXt31E3CKDSSWwWcD9QlSfL9EgahnP8BPhsff4lUaipJkyUtiuVJFuUKP3b9FC6pRdLU+Lhd0nckPQ4cIOnweHybpOsl5ct68e/A6Wb2BoCZrTWzn8f2LpL0RBwp/SR3I0ocxVwi6UHggjiSqIqvjZT0sqQaSafE45+RdJukQvOex0paLOm3kqbEdnpSouV44Ne5IBT7v8DMcsUzd5R0j6TfSfpB6mf2KUm/lrRE0i2x7EzOmXF7W64oZ6HfRTQunuN5Sd8u8P2VPQ9Erscam1s6G5tb7mpsbjkC+FvgOij4JjrgRgwZXXETnsOoGftBG7UktckIgf54YFySJP+RJEm3qZm20n8TMsYPByYBj6deWw4cYmb7ABcBl/SgvVHAUjP7JKEY5BygIZY5GQJ8Lb2zpDHAmJinMZ8fm9n+ZjYRGAHUp17bxswONbOLgWeAXJLezwH3mtl6YF48fi/gOUJ9sXyGmNlk4BuEVEjQsxItE4EnC7QJIc9jA+FvpUHSuHjp7ULgCDPbl/BzOjt1zOtx+zXAzLit2O9iMiFf5d6EgFpxpVvAL825rdTY3LIUOLWpof6bwCmEP9zaLPs0rGpkRdy63dV+HbuMun9o6yuEN+7rkyR5cSDOa2atkuoIb7Rdb/seS3jz/TghOPYkmewGQl5GCPOLL8aaXgA/J/wfSZe1F8VLlRwWs96PBLYFlgG50Udzar9mwhv+AkItsKvj9omSvgdsA4wG7i1wnnnx3yeBuvj4YMINIZjZckm5Ei2tRfrb1QNmthZA0rPA+NiXPYBH4wBvKJvXD0v35ej4uNjv4n4zWx3PMS/2e4uK0OXOA5Hrk8bmltXArKaG+suATxOylx8FfHCg+zKsemSl/X9eA8wb3/nhucD8JEk6M+jDncBlwFQ2LxfyXWCBmf1TDFYL4/YONr+Skh4lrEvNC3X7oSDOCb0laWcz26x6bRx9XA3sZ2YvS0q6nCtdTuVO4FJJ2xIKT86P2+cAnzezZyTNiN9jPrlEwxvY9J7Ykw81y9g0EivWbrptEYJHoRpn+fpS6HcBWwbyirsqAB6IXIk0Nrd0AC1AS1NDfQ1wGPAFwsTz9gPRh5qqYUMH4jx99DbhU/1c4J7aWVPeBUiYklV/rgfWmllbbq4nGsummxdmpLavBE6PczIfJVwaymc5UCdpgpmtAP6VUKurq0uBqyQ1xMD0AcKoJpd+6vU4h3IMkLd8hZm1S1oMXAG0pILhGOBPkmoIl696czNGrkTLfBUu0XIz8E1JnzWzXwFI+nQ353ksfr8TzGxFnLeqTY0c8yn0uwCYHgPwO4S/tZO6/9bKjwciV3KNzS3rCUUC72tqqD8dOAg4kjBi2ot+Kgg4pGroiP5ot486CJdZFhA+yT5SO2vKW0WPGEBm9grhDbyrHxAuB53NphEGwKOE+lxtwFJgSZ5jMbN1kk4EblGoWvwEMDvPrtcQLps9IWk9sB5oMrM1kq6L51kZjy+mmVAVeWpq27cI814vxXbGdNNG2tXAbIUSLR3kKdFiZu9Iqgd+KOmHse+twNcLNWpmq+LobG7q5o0LgWKBqNDvAuARQpXnCcDNZlZxl+XAF7S6AdbUUL8D8A+EwDSdcO2/JI6pa1xZrSF1pWpvK20AniIEngWEwFMR67Ccy4oHIpeZpoZ6ESaH94pfk+K/O7MVo6bj6s79S7xMMZA6CXdt5UY8D9XOmrJ2gPvgXEXzQOTKTlND/RjCLa+5wLRXfF6s1pAdV3dup6TqfupWB/B7wm3Az8Z/nwOWl9OlNucqkQciVxHi6GlnQh2lHQg3QGz8qtGwUUfXfaOWEKxGU3yNXAdhcvft1Ff6+Z8J8xLpr1dqZ03x2j7O9QMPRO596ZXzHx5JmJzOjaI2Bp3aWVPWZ9Yx59wWBk0gktRuZqNTz2cQ1ij8W5f9ttguaSEwszd3pMR27jOzV7e2jQLt1hPWFVQRFrZdYWbX9qXNAuepAw40s5tL3bZzzqV5ip9+EOcpZgA7lrjdGuAnwOdi2pJ92HxxWynVEdLMOOdcv/JA1EuSrpH0G0nLJF2c2r4yJml8hJAyZT/gJklPSxrRpY0tkh4qJIi8PbXP9JiyI20MYe3XagAze9fMnpdULekFBdtI6pR0SGznYUkTJI1SSDz5REye+I/x9WpJ/xm3t0r6ajzXLGBK7P9ZhfaTNFUhCeWtCqn8b5Iqo0qqc648DKYFrSMkPZ16vi0hNUg+DZIOTj2fkHp8gZn9JY56HpA0ycxy+afWmdnBAJJOJnUpLvfe3CXp4VuSziMkPfwuYcX1h81sFaHswg3pTsXz3gm8JOkBQiaDuWa2QdJvCTmsPkZYQDlFIQtybVzBfQkw38xOkrQNsFjS/xJWj681s/3jArtHJd1HyPo808zqY79PLbAfhJHZnsCrhAWPBxEW2jnnXLcG04joHTPbO/dFyGJbSHOXfdPzOsdJWkJYtLgn4c1/43E96Mffsynp4dPACcB4C5N1vwD+JQaKAwhp+jdjZicDhwOLCdl5r48vPQwcEr8uJSQ/3J9NK9I/BZwfz7mQkLdrp7j9y3H744R8Yx/P0+9i+y02s1fMrBN4mk2JI9+XJPVXNuxc+1MVCtd9JbVtn7htZjfHzpF0TH/2z7lSG0wjoj6T9DHCm//+ZvZXSXMonIixYDMUTnp4AyEP2TrglkIFv8ysDWhTqLD5ImE+6mHgNMK81EXAOYR0Jw+lzvsFM9ssX1a8jHammd3bZfvUPP0utF++5I6ub9oIGaV/Fp9/kbBwdkAow4JzbvAZTCOiUvgAIdislfQRQpqaQt4kf26rx4CDJE2AjYW8dgWId9i9Srh0N6frgXEuaWpq096EPFoQRikHAp1mto4wMvkqIUBBSIF/Zm7+RtI+qe1fizdC5Eofj8rT/0L7DVrF5sckfSZue0TSlYoluCVtK+mOOM/2mKRJBZr/AzBcoey0CHn6No6QJe0dj2+VdLukLbKdK8xbXqweFlpTKHp3i6S7CLkCnRsQHoh6wcyeIVySW0a4JPZokd3nEJImbnazQpz/mUFIethKCEy7p467CXjZzJ7N06aAcxWqMT4NXBzbIiZkfDm2ByEAjSF8soYwB1UDtEpaGp8D/JSQKWBJ3H4tYUTTCnQoVLc8q8h+g90+hIJqexAW3B6kUMLgWuDIOGeYLh19MfCUmU0iVCe9sUjbtwLHEj5gLGHzkeeNwHmxnTY2FXTrqreF1g4ATjCzaUW/a+dKaNCsI6oUCmWYnzKzn3W7s8uE4pq0ODq9wMymx+3XED6cLCWs7zo0bj8KONXM6iU9RbhE+kJ87WVgYq6AWtw2lRA0TibMO7YRbqw5EGgnVMZtM7Od4v67EC7l7hsvF7eY2a2SVgIHmdkfJX0S+L6ZHSFpHHAlYY7PgBoz211h7duhZnZi//zknMvPR0RlRNKThPxq/5V1X1yPFSp+Vki+1/J+GjSzPxNKC0wnlA/vS//yFVqbSCit3dt5TudKygNRGTGzvzOzQ7rWPXEVZzmws0J2Cgg3HeTkCq7lRj6vm9kbRdq6iHAJbmOeuzh6+qukXDW9QkXnCilWaM25AefX+J0rsVgw7XTgHkmvE261z0mAG+L84NuE2/eLtbWowEsnEOYgRwIvENad9VSxQmvODTifI3KuH0gaHUtYC7gK+J2ZXZ51v5wrR35pzrn+cUq8s3EZ4VJYyRPTOvd+4SMi55xzmfIRkXPOuUx5IHLOOZcpD0TOOecy5YHIOedcpjwQOeecy5QHIuecc5nyQOSccy5THoicc85lygORc865THkgcs45lykPRM455zLlgcg551ymPBA555zLlAci55xzmfJA5JxzLlMeiJxzzmXKA5FzzrlMeSByzjmXKQ9EzjnnMuWByDnnXKY8EDnnnMuUByLnnHOZ+n/pFNX62yQwNwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x26fec5d3a20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "top10.plot.pie(\n",
    "    figsize=[5,5],\n",
    "    title=\"Top 10 Authors\",\n",
    "    label=\"\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with dates\n",
    "Now let's look at the timestamp information. We want to find out at what time of day the developers commit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2017-12-31 14:47:43\n",
       "1    2017-12-31 13:13:56\n",
       "2    2017-12-31 13:03:05\n",
       "3    2017-12-31 12:30:34\n",
       "4    2017-12-31 12:29:02\n",
       "Name: timestamp, dtype: object"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "git_log.timestamp.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we can enter the world of time series processing, we must first convert our column with the dates into the appropriate data type. At the moment our column `timestamp` is still a string, i.e. of textual nature. We can see this by using the helper function `type(<object>)` to display the first entry of the `timestamp` column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(git_log.timestamp[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, Pandas also helps us to convert data types. The function `pd.to_datetime` takes as first parameter a `series` with dates and converts them. The return value is a `Series` with values of the data type `Timestamp`. The conversion works for most textual dates mostly automagically [sic!], because Pandas can handle different date formats. We also write the result back into the same column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>timestamp</th>\n",
       "      <th>author</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2017-12-31 14:47:43</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2017-12-31 13:13:56</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2017-12-31 13:03:05</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2017-12-31 12:30:34</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2017-12-31 12:29:02</td>\n",
       "      <td>Linus Torvalds</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            timestamp          author\n",
       "0 2017-12-31 14:47:43  Linus Torvalds\n",
       "1 2017-12-31 13:13:56  Linus Torvalds\n",
       "2 2017-12-31 13:03:05  Linus Torvalds\n",
       "3 2017-12-31 12:30:34  Linus Torvalds\n",
       "4 2017-12-31 12:29:02  Linus Torvalds"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "git_log.timestamp = pd.to_datetime(git_log.timestamp)\n",
    "git_log.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check if the conversion was successful, we can check the first value of our converted column `timestamp_local` by calling `type()` again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas._libs.tslib.Timestamp"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(git_log.timestamp[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now also access individual parts of the date values. For this, we use the `dt` (\"datetime\") object with its properties like `hour`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    14\n",
       "1    13\n",
       "2    13\n",
       "3    12\n",
       "4    12\n",
       "Name: timestamp, dtype: int64"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "git_log.timestamp.dt.hour.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Together with the `value_counts()` method that I've already introduced above, we can now count values again after their occurrence. However, it is important that we also set the parameter `sort=False` to avoid sorting according to keep the order of the hours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    19533\n",
       "1    15044\n",
       "2    10420\n",
       "3     7000\n",
       "4     6068\n",
       "Name: timestamp, dtype: int64"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "commits_per_hour = git_log.timestamp.dt.hour.value_counts(sort=False)\n",
    "commits_per_hour.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can display the result by means of a bar chart and thus get an overview of how many commits occured for each hour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x26fec64e7f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "commits_per_hour.plot.bar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now additionally label the plot. To do this, we store the return object of the `bar()` function in the variable `ax`. This is an `Axes` object of the underlying plotting library `matplotlib`, through which we can customize additional properties of the plot. We set here\n",
    "\n",
    "* the title via `set_title(\"<titel name>\")`\n",
    "* the label of the X-axis with `set_xlabel(\"<X-axis label>\")`\n",
    "* the label of the Y-axis with `set_ylabel<\"Y-axis label>\")`\n",
    "\n",
    "The result is a more meaningful, labeled bar chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Number of Commits')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x26fec73b320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = commits_per_hour.plot.bar()\n",
    "ax.set_title(\"Commits per Hour\")\n",
    "ax.set_xlabel(\"Hour of Day\")\n",
    "ax.set_ylabel(\"Number of Commits\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also analyze the commits per weekdays. To do this, we use the `weekday` attribute of the datetime attribute `dt`. The values here are 0-based with Monday as the first day of the week. As usual, we count the values using `value_counts` and do not sort the values by size but keep the sorting by weekday."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    124296\n",
       "1    131690\n",
       "2    131019\n",
       "3    127097\n",
       "4    117635\n",
       "5     44877\n",
       "6     46600\n",
       "Name: timestamp, dtype: int64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "commits_per_weekday = git_log.timestamp.dt.weekday.value_counts(sort=False)\n",
    "commits_per_weekday"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result in `commits_per_weekday` can be output as a bar chart using `plot.bar()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x26fec583320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "commits_per_weekday.plot.bar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Displaying the commit history\n",
    "In the following, we want to see the progress of the number of commits over the last years by using a `DatetimeIndex` based DataFrame. To do this, we set the `timestamp` column as index using `set_index('<columnname>')`. Furthermore, we select just the `author` column. Thus we work continuously on a pure `Series` instead of a `DataFrame`. \n",
    "\n",
    "Side note: The usage of a `Series` is almost similar to a `DataFrame` with regard to the statistical functions. However, a `Series` is not beautifully formatted in a table, which is why I personally prefer using a `DataFrame`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "timestamp\n",
       "2017-12-31 14:47:43    Linus Torvalds\n",
       "2017-12-31 13:13:56    Linus Torvalds\n",
       "2017-12-31 13:03:05    Linus Torvalds\n",
       "2017-12-31 12:30:34    Linus Torvalds\n",
       "2017-12-31 12:29:02    Linus Torvalds\n",
       "Name: author, dtype: object"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "git_timed = git_log.set_index('timestamp').author\n",
    "git_timed.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `resample(\"<time unit>\")` function of the `DataFrame`, we can now group values according to certain time units such as days (`D`), months (`M`), quarters (`Q`) or years (`A`). We use a `resample(\"D\")` for counting per day. We also specify how the individual values should be combined per time unit. For this, we select the `count()` function to count the number of commits for each day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "timestamp\n",
       "2005-04-16    199\n",
       "2005-04-17     30\n",
       "2005-04-18     73\n",
       "2005-04-19     28\n",
       "2005-04-20      8\n",
       "Freq: D, Name: author, dtype: int64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "commits_per_day = git_timed.resample(\"D\").count()\n",
    "commits_per_day.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To show the commit history over the years, we calculate the cumulative sum of all daily entries using `cumsum()`. All values get summed up one after the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "timestamp\n",
       "2005-04-16    199\n",
       "2005-04-17    229\n",
       "2005-04-18    302\n",
       "2005-04-19    330\n",
       "2005-04-20    338\n",
       "Freq: D, Name: author, dtype: int64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "commits_per_day_cumulative = commits_per_day.cumsum()\n",
    "commits_per_day_cumulative.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is plotted as a line diagram and the number of commits is shown over the years."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x26fedb28f28>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x26fec75a7b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "commits_per_day_cumulative.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The End\n",
    "OK, that's it for now!\n",
    "\n",
    "You've learned some basics about Pandas and its usage with software data. This will hopefully get you started in your daily work. Other important topics that are still missing are:\n",
    "\n",
    "* Reading in complicated or semi-structured data structures\n",
    "* Merging different data sources with `pd.merge` and `join`\n",
    "* Grouping similar data using `groupby`\n",
    "* Transforming data with `pivot_table`\n",
    "\n",
    "But with the features shown, you are on a good way to become a Software Development Analyst that can leverage Data Science to fix problems in software systems!\n",
    "\n",
    "If you want to dive deeper into this topic, take a look at my [other blog posts on that topic](http://www.feststelltaste.de/category/software-analytics/). I'm also [offering training for companies](http://markusharrer.de/) who want to fix their problems using data analysis in software development.\n",
    "\n",
    "I'm looking forward to your comments and feedback!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}