class 02 Intermediate Python/class 02 Intermediate Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What we'll learn today ?\n",
    "\n",
    "- `Visualization` with matplotlib\n",
    "- `Data Sturctures` with Dictionaries & Pandas.\n",
    "- `Contro structures` i:e, Loops & conditional statments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \"./media/matplotlib.svg\" width=500>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data visualization\n",
    "- Very important in Data Analysis\n",
    "- Explore data\n",
    "- Report insights\n",
    "\n",
    "- `Source: GapMinder, Wealth and Health of Nation`\n",
    "\n",
    "<img src=\"./media/grapsh.png\">\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic plots with Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### line plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Importing Matplotlib package\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# defining X & Y axis\n",
    "year = [1950, 1970, 1990, 2010]\n",
    "pop = [2.519, 3.692, 5.263, 6.972]\n",
    "\n",
    "#making a plot\n",
    "plt.plot(year, pop)\n",
    "\n",
    "#showing that plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concept Building\n",
    "\n",
    "<img src= \"./media/plot2.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scatter plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAONklEQVR4nO3df2zc913H8ee7Trq53abQ1p2adOBW2ixVsDadVTYNutHSmW5QgmCi3So2hhSQKtQB8lQL/kEIBAtCAxUxqrFpUrdWrKRhm1jNKHQCxlqcJl36yxutui1OWVwNq+tmtWn25o/7Orl45+Qu8dlv28+HZPnrz/dz33u/c3evnD/f7yWRmUiS6jprtQuQJJ2cQS1JxRnUklScQS1JxRnUklTcpn4c9IILLsjh4eF+HFqS1qW9e/c+l5lDnfb1JaiHh4eZmprqx6ElaV2KiG8stc+lD0kqzqCWpOIMakkqzqCWpOJOGdQRMRIR+9u+no+ID65AbZIkurjqIzOngSsAImIAmAHu7W9ZkrR27Nk3w67JaQ7NzbN1yyDjYyPs2L5t2Y7f6+V51wJPZeaSl5FI0kayZ98ME7sPMH/kKAAzc/NM7D4AsGxh3esa9Y3AXZ12RMTOiJiKiKnZ2dkzr0yS1oBdk9PHQnrB/JGj7JqcXrb76DqoI+Js4AbgM532Z+YdmTmamaNDQx0/XCNJ686hufmexk9HL++orwcezsxvL9u9S9Iat3XLYE/jp6OXoL6JJZY9JGmjGh8bYXDzwAljg5sHGB8bWbb76OpkYkScA1wH/Oay3bMkrQMLJwxX/aqPzPw+cP6y3askrSM7tm9b1mBezE8mSlJxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxBrUkFWdQS1JxXQV1RGyJiHsi4smIeCIi3tLvwiRJLZu6nPeXwH2Z+SsRcTZwTh9rkiS1OWVQR8RrgKuB9wNk5kvAS/0tS5K0oJulj0uBWeATEbEvIj4WEecunhQROyNiKiKmZmdnl71QSdqougnqTcCVwN9k5nbge8Btiydl5h2ZOZqZo0NDQ8tcpiRtXN0E9UHgYGY+2Px8D63gliStgFMGdWb+L/CtiBhphq4FHu9rVZKkY7q96uO3gU81V3w8Dfx6/0qSJLXrKqgzcz8w2t9SJEmd+MlESSrOoJak4gxqSSrOoJak4gxqSSrOoJak4gxqSSrOoJak4gxqSSrOoJak4gxqSSrOoJak4gxqSSrOoJak4gxqSSrOoJak4gxqSSrOoJak4gxqSSrOoJak4gxqSSrOoJak4gxqSSrOoJak4jatdgGSerNn3wy7Jqc5NDfP1i2DjI+NsGP7ttUuS31kUEtryJ59M0zsPsD8kaMAzMzNM7H7AIBhvY659CGtIbsmp4+F9IL5I0fZNTm9ShVpJRjU0hpyaG6+p3GtDwa1tIZs3TLY07jWB4NaWkPGx0YY3Dxwwtjg5gHGx0ZWqSKtBE8mSmvIwglDr/rYWAxqaY3ZsX2bwbzBuPQhScUZ1JJUnEEtScUZ1JJUXFcnEyPiGeC7wFHg5cwc7WdRkqTjernq42cy87m+VSJJ6silD0kqrtugTuCfI2JvROzsNCEidkbEVERMzc7OLl+FkrTBdRvUb83MK4HrgVsi4urFEzLzjswczczRoaGhZS1SkjayroI6Mw813w8D9wJX9bMoSdJxpwzqiDg3Il69sA28A3i034VJklq6uerjtcC9EbEw/9OZeV9fq5IkHXPKoM7Mp4HLV6AWSVIHXp4nScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScUZ1JJUnEEtScV1HdQRMRAR+yLi8/0sSJJ0ol7eUd8KPNGvQiRJnXUV1BFxMfAu4GP9LUeStFi376g/AnwI+MFSEyJiZ0RMRcTU7OzsctQmSaKLoI6InwcOZ+bek83LzDsyczQzR4eGhpatQEna6Lp5R/1W4IaIeAa4G7gmIu7sa1WSpGNOGdSZOZGZF2fmMHAj8K+ZeXPfK5MkAV5HLUnlbeplcmY+ADzQl0okSR35jlqSijOoJak4g1qSijOoJak4g1qSiuvpqg9tLHv2zbBrcppDc/Ns3TLI+NgIO7ZvW+2ypA3HoFZHe/bNMLH7APNHjgIwMzfPxO4DAIa1tMJc+lBHuyanj4X0gvkjR9k1Ob1KFUkbl0Gtjg7Nzfc0Lql/DGp1tHXLYE/jkvrHoFZH42MjDG4eOGFscPMA42Mjq1SRtHF5MlEdLZww9KoPafUZ1FrSju3bDGapAJc+JKk4g1qSijOoJak4g1qSijOoJak4g1qSijOoJak4g1qSijOoJak4g1qSijOoJak4g1qSijOoJak4g1qSijOoJak4g1qSijOoJak4g1qSijOoJak4g1qSijOoJak4g1qSijtlUEfEKyPioYh4JCIei4g/XInCJEktm7qY8yJwTWa+EBGbgf+IiC9k5lf6XJskiS6COjMTeKH5cXPzlf0sSpJ0XFdr1BExEBH7gcPAFzPzwb5WJUk6pqugzsyjmXkFcDFwVUT8+OI5EbEzIqYiYmp2dnaZy5Skjaunqz4ycw54APi5DvvuyMzRzBwdGhpanuokSV1d9TEUEVua7UHgZ4En+1yXJKnRzVUfFwGfjIgBWsH+95n5+f6WJUla0M1VH18Ftq9ALZKkDvxkoiQVZ1BLUnEGtSQVZ1BLUnEGtSQVZ1BLUnEGtSQVZ1BLUnEGtSQVZ1BLUnEGtSQVZ1BLUnEGtSQV180/c7oi9uybYdfkNIfm5tm6ZZDxsRF2bN+22mVJ0qorEdR79s0wsfsA80eOAjAzN8/E7gMAhrWkDa/E0seuyeljIb1g/shRdk1Or1JFklRHiaA+NDff07gkbSQlgnrrlsGexiVpIykR1ONjIwxuHjhhbHDzAONjI6tUkSTVUeJk4sIJQ6/6kKQfViKooRXWBrMk/bASSx+SpKUZ1JJUnEEtScUZ1JJUnEEtScVFZi7/QSNmgW+c5s0vAJ5bxnJW03rpZb30AfZS0XrpA86slx/LzKFOO/oS1GciIqYyc3S161gO66WX9dIH2EtF66UP6F8vLn1IUnEGtSQVVzGo71jtApbReullvfQB9lLReukD+tRLuTVqSdKJKr6jliS1Maglqbi+B3VEfDwiDkfEo21jl0fEf0XEgYj4XES8phkfjoj5iNjffH207TZvaub/T0T8VUREv2s/k16afW9s9j3W7H/lWuwlIt7b9pjsj4gfRMQVFXrpsY/NEfHJZvyJiJhou81ae0zOjohPNOOPRMTbq/QSEa+LiH9r/owfi4hbm/HzIuKLEfH15vuPtN1moql3OiLG1movEXF+M/+FiLh90bFOv5fM7OsXcDVwJfBo29h/A29rtj8A/FGzPdw+b9FxHgLeAgTwBeD6ftd+hr1sAr4KXN78fD4wsBZ7WXS7nwCervK49PiYvAe4u9k+B3gGGK7Qx2n0cgvwiWb7QmAvcFaFXoCLgCub7VcDXwMuAz4M3NaM3wb8WbN9GfAI8ArgEuCpKq+V0+jlXOCngN8Cbl90rNPuZaWaHV705Hue4ycyXwc83mneoj+sJ9t+vgn425V8wE6jl3cCd66HXhbd5k+AP67USw+PyU3A52j9JXp+86I7r0ofPfby18DNbfPuB66q1EtbDf8IXAdMAxe1PXemm+0JYKJt/mQTaGuul7Z576ctqM+0l9Vao34UuKHZfjetJ+CCSyJiX0R8KSJ+uhnbBhxsm3OwGatgqV7eAGRETEbEwxHxoWZ8LfbS7leBu5rtqr0s1cc9wPeAZ4FvAn+emd+hbh+wdC+PAL8YEZsi4hLgTc2+Ur1ExDCwHXgQeG1mPgvQfL+wmbYN+FbbzRZqXou9LOWMelmtoP4AcEtE7KX168RLzfizwI9m5nbgd4FPN2tyndZyqlxXuFQvm2j9CvTe5vsvRcS1rM1eAIiInwS+n5kLa6hVe1mqj6uAo8BWWr9i/15EXErdPmDpXj5O68U+BXwE+DLwMoV6iYhXAf8AfDAznz/Z1A5jeZLxFddDL0seosNY172syn/FlZlPAu8AiIg3AO9qxl8EXmy290bEU7TemR4ELm47xMXAoZWseSlL9UKr5i9l5nPNvn+itf54J2uvlwU3cvzdNBR9XE7Sx3uA+zLzCHA4Iv4TGAX+nYJ9wElfKy8Dv7MwLyK+DHwd+D8K9BIRm2kF26cyc3cz/O2IuCgzn42Ii4DDzfhBTvztbaHmEs+vHntZyhn1sirvqCPiwub7WcAfAB9tfh6KiIFm+1Lg9bROXD0LfDci3tycKf01WmtFq26pXmits70xIs6JiE3A22itL67FXhbG3g3cvTBWtZeT9PFN4JpoORd4M611w5J9wElfK+c0PRAR1wEvZ2aJ51dzv38HPJGZf9G267PA+5rt97XV9Vngxoh4RbOM83rgoTXaS0dn3MsKLL7fRWtJ4witv1V+A7iV1omcrwF/yvGTJb8MPEZr/e1h4BfajjNKa73uKeD2hdus8ImErntp5t/c9PMo8OE13svbga90OM6q9tLj8+tVwGeax+RxYLxKH6fRyzCtE1pPAP9C65/ILNELraW+pHXV0/7m6520TuDeT+ud//3AeW23+f2m3mnaroZYo708A3wHeKF5HC870178CLkkFecnEyWpOINakoozqCWpOINakoozqCWpOINakoozqCWpuP8Hb227vQmc+k8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "year = [1950, 1970, 1990, 2010]\n",
    "pop = [2.519, 3.692, 5.263, 6.972]\n",
    "\n",
    "plt.scatter(year, pop)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Histogram\n",
    "- Explore dataset\n",
    "- Get idea about distribution\n",
    "\n",
    "<img src = \"./media/histogram.png\" width = 500, height= 500>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function hist in module matplotlib.pyplot:\n",
      "\n",
      "hist(x, bins=None, range=None, density=False, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, *, data=None, **kwargs)\n",
      "    Plot a histogram.\n",
      "    \n",
      "    Compute and draw the histogram of *x*.  The return value is a tuple\n",
      "    (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*, [*patches0*,\n",
      "    *patches1*, ...]) if the input contains multiple data.  See the\n",
      "    documentation of the *weights* parameter to draw a histogram of\n",
      "    already-binned data.\n",
      "    \n",
      "    Multiple data can be provided via *x* as a list of datasets\n",
      "    of potentially different length ([*x0*, *x1*, ...]), or as\n",
      "    a 2-D ndarray in which each column is a dataset.  Note that\n",
      "    the ndarray form is transposed relative to the list form.\n",
      "    \n",
      "    Masked arrays are not supported.\n",
      "    \n",
      "    The *bins*, *range*, *weights*, and *density* parameters behave as in\n",
      "    `numpy.histogram`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    x : (n,) array or sequence of (n,) arrays\n",
      "        Input values, this takes either a single array or a sequence of\n",
      "        arrays which are not required to be of the same length.\n",
      "    \n",
      "    bins : int or sequence or str, default: :rc:`hist.bins`\n",
      "        If *bins* is an integer, it defines the number of equal-width bins\n",
      "        in the range.\n",
      "    \n",
      "        If *bins* is a sequence, it defines the bin edges, including the\n",
      "        left edge of the first bin and the right edge of the last bin;\n",
      "        in this case, bins may be unequally spaced.  All but the last\n",
      "        (righthand-most) bin is half-open.  In other words, if *bins* is::\n",
      "    \n",
      "            [1, 2, 3, 4]\n",
      "    \n",
      "        then the first bin is ``[1, 2)`` (including 1, but excluding 2) and\n",
      "        the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which\n",
      "        *includes* 4.\n",
      "    \n",
      "        If *bins* is a string, it is one of the binning strategies\n",
      "        supported by `numpy.histogram_bin_edges`: 'auto', 'fd', 'doane',\n",
      "        'scott', 'stone', 'rice', 'sturges', or 'sqrt'.\n",
      "    \n",
      "    range : tuple or None, default: None\n",
      "        The lower and upper range of the bins. Lower and upper outliers\n",
      "        are ignored. If not provided, *range* is ``(x.min(), x.max())``.\n",
      "        Range has no effect if *bins* is a sequence.\n",
      "    \n",
      "        If *bins* is a sequence or *range* is specified, autoscaling\n",
      "        is based on the specified bin range instead of the\n",
      "        range of x.\n",
      "    \n",
      "    density : bool, default: False\n",
      "        If ``True``, draw and return a probability density: each bin\n",
      "        will display the bin's raw count divided by the total number of\n",
      "        counts *and the bin width*\n",
      "        (``density = counts / (sum(counts) * np.diff(bins))``),\n",
      "        so that the area under the histogram integrates to 1\n",
      "        (``np.sum(density * np.diff(bins)) == 1``).\n",
      "    \n",
      "        If *stacked* is also ``True``, the sum of the histograms is\n",
      "        normalized to 1.\n",
      "    \n",
      "    weights : (n,) array-like or None, default: None\n",
      "        An array of weights, of the same shape as *x*.  Each value in\n",
      "        *x* only contributes its associated weight towards the bin count\n",
      "        (instead of 1).  If *density* is ``True``, the weights are\n",
      "        normalized, so that the integral of the density over the range\n",
      "        remains 1.\n",
      "    \n",
      "        This parameter can be used to draw a histogram of data that has\n",
      "        already been binned, e.g. using `numpy.histogram` (by treating each\n",
      "        bin as a single point with a weight equal to its count) ::\n",
      "    \n",
      "            counts, bins = np.histogram(data)\n",
      "            plt.hist(bins[:-1], bins, weights=counts)\n",
      "    \n",
      "        (or you may alternatively use `~.bar()`).\n",
      "    \n",
      "    cumulative : bool or -1, default: False\n",
      "        If ``True``, then a histogram is computed where each bin gives the\n",
      "        counts in that bin plus all bins for smaller values. The last bin\n",
      "        gives the total number of datapoints.\n",
      "    \n",
      "        If *density* is also ``True`` then the histogram is normalized such\n",
      "        that the last bin equals 1.\n",
      "    \n",
      "        If *cumulative* is a number less than 0 (e.g., -1), the direction\n",
      "        of accumulation is reversed.  In this case, if *density* is also\n",
      "        ``True``, then the histogram is normalized such that the first bin\n",
      "        equals 1.\n",
      "    \n",
      "    bottom : array-like, scalar, or None, default: None\n",
      "        Location of the bottom of each bin, ie. bins are drawn from\n",
      "        ``bottom`` to ``bottom + hist(x, bins)`` If a scalar, the bottom\n",
      "        of each bin is shifted by the same amount. If an array, each bin\n",
      "        is shifted independently and the length of bottom must match the\n",
      "        number of bins. If None, defaults to 0.\n",
      "    \n",
      "    histtype : {'bar', 'barstacked', 'step', 'stepfilled'}, default: 'bar'\n",
      "        The type of histogram to draw.\n",
      "    \n",
      "        - 'bar' is a traditional bar-type histogram.  If multiple data\n",
      "          are given the bars are arranged side by side.\n",
      "        - 'barstacked' is a bar-type histogram where multiple\n",
      "          data are stacked on top of each other.\n",
      "        - 'step' generates a lineplot that is by default unfilled.\n",
      "        - 'stepfilled' generates a lineplot that is by default filled.\n",
      "    \n",
      "    align : {'left', 'mid', 'right'}, default: 'mid'\n",
      "        The horizontal alignment of the histogram bars.\n",
      "    \n",
      "        - 'left': bars are centered on the left bin edges.\n",
      "        - 'mid': bars are centered between the bin edges.\n",
      "        - 'right': bars are centered on the right bin edges.\n",
      "    \n",
      "    orientation : {'vertical', 'horizontal'}, default: 'vertical'\n",
      "        If 'horizontal', `~.Axes.barh` will be used for bar-type histograms\n",
      "        and the *bottom* kwarg will be the left edges.\n",
      "    \n",
      "    rwidth : float or None, default: None\n",
      "        The relative width of the bars as a fraction of the bin width.  If\n",
      "        ``None``, automatically compute the width.\n",
      "    \n",
      "        Ignored if *histtype* is 'step' or 'stepfilled'.\n",
      "    \n",
      "    log : bool, default: False\n",
      "        If ``True``, the histogram axis will be set to a log scale. If\n",
      "        *log* is ``True`` and *x* is a 1D array, empty bins will be\n",
      "        filtered out and only the non-empty ``(n, bins, patches)``\n",
      "        will be returned.\n",
      "    \n",
      "    color : color or array-like of colors or None, default: None\n",
      "        Color or sequence of colors, one per dataset.  Default (``None``)\n",
      "        uses the standard line color sequence.\n",
      "    \n",
      "    label : str or None, default: None\n",
      "        String, or sequence of strings to match multiple datasets.  Bar\n",
      "        charts yield multiple patches per dataset, but only the first gets\n",
      "        the label, so that `~.Axes.legend` will work as expected.\n",
      "    \n",
      "    stacked : bool, default: False\n",
      "        If ``True``, multiple data are stacked on top of each other If\n",
      "        ``False`` multiple data are arranged side by side if histtype is\n",
      "        'bar' or on top of each other if histtype is 'step'\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    n : array or list of arrays\n",
      "        The values of the histogram bins. See *density* and *weights* for a\n",
      "        description of the possible semantics.  If input *x* is an array,\n",
      "        then this is an array of length *nbins*. If input is a sequence of\n",
      "        arrays ``[data1, data2, ...]``, then this is a list of arrays with\n",
      "        the values of the histograms for each of the arrays in the same\n",
      "        order.  The dtype of the array *n* (or of its element arrays) will\n",
      "        always be float even if no weighting or normalization is used.\n",
      "    \n",
      "    bins : array\n",
      "        The edges of the bins. Length nbins + 1 (nbins left edges and right\n",
      "        edge of last bin).  Always a single array even when multiple data\n",
      "        sets are passed in.\n",
      "    \n",
      "    patches : `.BarContainer` or list of a single `.Polygon` or list of such objects\n",
      "        Container of individual artists used to create the histogram\n",
      "        or list of such containers if there are multiple input datasets.\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    **kwargs\n",
      "        `~matplotlib.patches.Patch` properties\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    hist2d : 2D histograms\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    For large numbers of bins (>1000), 'step' and 'stepfilled' can be\n",
      "    significantly faster than 'bar' and 'barstacked'.\n",
      "    \n",
      "    .. note::\n",
      "        In addition to the above described arguments, this function can take\n",
      "        a *data* keyword argument. If such a *data* argument is given,\n",
      "        the following arguments can also be string ``s``, which is\n",
      "        interpreted as ``data[s]`` (unless this raises an exception):\n",
      "        *x*, *weights*.\n",
      "    \n",
      "        Objects passed as **data** must support item access (``data[s]``) and\n",
      "        membership test (``s in data``).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "values = [0,0.6,1.4,1.6,2.2,2.5,2.6,3.2,3.5,3.9,4.2,6]\n",
    "plt.hist(values, bins=3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data visualization\n",
    "- Many options\n",
    "    - Different plot types\n",
    "    - Many Customization\n",
    "- Choice Depend on\n",
    "    - Data\n",
    "    - story you want to tell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "years = [1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100]\n",
    "pop = [2.53, 2.57, 2.62, 2.67, 2.71, 2.76, 2.81, 2.86, 2.92, 2.97, 3.03, 3.08, 3.14, 3.2, 3.26, 3.33, 3.4, 3.47, 3.54, 3.62, 3.69, 3.77, 3.84, 3.92, 4.0, 4.07, 4.15, 4.22, 4.3, 4.37, 4.45, 4.53, 4.61, 4.69, 4.78, 4.86, 4.95, 5.05, 5.14, 5.23, 5.32, 5.41, 5.49, 5.58, 5.66, 5.74, 5.82, 5.9, 5.98, 6.05, 6.13, 6.2, 6.28, 6.36, 6.44, 6.51, 6.59, 6.67, 6.75, 6.83, 6.92, 7.0, 7.08, 7.16, 7.24, 7.32, 7.4, 7.48, 7.56, 7.64, 7.72, 7.79, 7.87, 7.94, 8.01, 8.08, 8.15, 8.22, 8.29, 8.36, 8.42, 8.49, 8.56, 8.62, 8.68, 8.74, 8.8, 8.86, 8.92, 8.98, 9.04, 9.09, 9.15, 9.2, 9.26, 9.31, 9.36, 9.41, 9.46, 9.5, 9.55, 9.6, 9.64, 9.68, 9.73, 9.77, 9.81, 9.85, 9.88, 9.92, 9.96, 9.99, 10.03, 10.06, 10.09, 10.13, 10.16, 10.19, 10.22, 10.25, 10.28, 10.31, 10.33, 10.36, 10.38, 10.41, 10.43, 10.46, 10.48, 10.5, 10.52, 10.55, 10.57, 10.59, 10.61, 10.63, 10.65, 10.66, 10.68, 10.7, 10.72, 10.73, 10.75, 10.77, 10.78, 10.79, 10.81, 10.82, 10.83, 10.84, 10.85]\n",
    "\n",
    "# Make a line plot: year on the x-axis, pop on the y-axis\n",
    "plt.plot( years, pop)\n",
    "\n",
    "# Display the plot with plt.show()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Axis labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "years = [1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100]\n",
    "pop = [2.53, 2.57, 2.62, 2.67, 2.71, 2.76, 2.81, 2.86, 2.92, 2.97, 3.03, 3.08, 3.14, 3.2, 3.26, 3.33, 3.4, 3.47, 3.54, 3.62, 3.69, 3.77, 3.84, 3.92, 4.0, 4.07, 4.15, 4.22, 4.3, 4.37, 4.45, 4.53, 4.61, 4.69, 4.78, 4.86, 4.95, 5.05, 5.14, 5.23, 5.32, 5.41, 5.49, 5.58, 5.66, 5.74, 5.82, 5.9, 5.98, 6.05, 6.13, 6.2, 6.28, 6.36, 6.44, 6.51, 6.59, 6.67, 6.75, 6.83, 6.92, 7.0, 7.08, 7.16, 7.24, 7.32, 7.4, 7.48, 7.56, 7.64, 7.72, 7.79, 7.87, 7.94, 8.01, 8.08, 8.15, 8.22, 8.29, 8.36, 8.42, 8.49, 8.56, 8.62, 8.68, 8.74, 8.8, 8.86, 8.92, 8.98, 9.04, 9.09, 9.15, 9.2, 9.26, 9.31, 9.36, 9.41, 9.46, 9.5, 9.55, 9.6, 9.64, 9.68, 9.73, 9.77, 9.81, 9.85, 9.88, 9.92, 9.96, 9.99, 10.03, 10.06, 10.09, 10.13, 10.16, 10.19, 10.22, 10.25, 10.28, 10.31, 10.33, 10.36, 10.38, 10.41, 10.43, 10.46, 10.48, 10.5, 10.52, 10.55, 10.57, 10.59, 10.61, 10.63, 10.65, 10.66, 10.68, 10.7, 10.72, 10.73, 10.75, 10.77, 10.78, 10.79, 10.81, 10.82, 10.83, 10.84, 10.85]\n",
    "\n",
    "# Make a line plot: year on the x-axis, pop on the y-axis\n",
    "plt.plot( years, pop)\n",
    "\n",
    "#axix label\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "\n",
    "# Display the plot with plt.show()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "years = [1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100]\n",
    "pop = [2.53, 2.57, 2.62, 2.67, 2.71, 2.76, 2.81, 2.86, 2.92, 2.97, 3.03, 3.08, 3.14, 3.2, 3.26, 3.33, 3.4, 3.47, 3.54, 3.62, 3.69, 3.77, 3.84, 3.92, 4.0, 4.07, 4.15, 4.22, 4.3, 4.37, 4.45, 4.53, 4.61, 4.69, 4.78, 4.86, 4.95, 5.05, 5.14, 5.23, 5.32, 5.41, 5.49, 5.58, 5.66, 5.74, 5.82, 5.9, 5.98, 6.05, 6.13, 6.2, 6.28, 6.36, 6.44, 6.51, 6.59, 6.67, 6.75, 6.83, 6.92, 7.0, 7.08, 7.16, 7.24, 7.32, 7.4, 7.48, 7.56, 7.64, 7.72, 7.79, 7.87, 7.94, 8.01, 8.08, 8.15, 8.22, 8.29, 8.36, 8.42, 8.49, 8.56, 8.62, 8.68, 8.74, 8.8, 8.86, 8.92, 8.98, 9.04, 9.09, 9.15, 9.2, 9.26, 9.31, 9.36, 9.41, 9.46, 9.5, 9.55, 9.6, 9.64, 9.68, 9.73, 9.77, 9.81, 9.85, 9.88, 9.92, 9.96, 9.99, 10.03, 10.06, 10.09, 10.13, 10.16, 10.19, 10.22, 10.25, 10.28, 10.31, 10.33, 10.36, 10.38, 10.41, 10.43, 10.46, 10.48, 10.5, 10.52, 10.55, 10.57, 10.59, 10.61, 10.63, 10.65, 10.66, 10.68, 10.7, 10.72, 10.73, 10.75, 10.77, 10.78, 10.79, 10.81, 10.82, 10.83, 10.84, 10.85]\n",
    "\n",
    "# Make a line plot: year on the x-axis, pop on the y-axis\n",
    "plt.plot( years, pop)\n",
    "\n",
    "#axix label\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "\n",
    "#title\n",
    "plt.title('World Population Projections')\n",
    "\n",
    "# Display the plot with plt.show()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ticks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "years = [1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100]\n",
    "pop = [2.53, 2.57, 2.62, 2.67, 2.71, 2.76, 2.81, 2.86, 2.92, 2.97, 3.03, 3.08, 3.14, 3.2, 3.26, 3.33, 3.4, 3.47, 3.54, 3.62, 3.69, 3.77, 3.84, 3.92, 4.0, 4.07, 4.15, 4.22, 4.3, 4.37, 4.45, 4.53, 4.61, 4.69, 4.78, 4.86, 4.95, 5.05, 5.14, 5.23, 5.32, 5.41, 5.49, 5.58, 5.66, 5.74, 5.82, 5.9, 5.98, 6.05, 6.13, 6.2, 6.28, 6.36, 6.44, 6.51, 6.59, 6.67, 6.75, 6.83, 6.92, 7.0, 7.08, 7.16, 7.24, 7.32, 7.4, 7.48, 7.56, 7.64, 7.72, 7.79, 7.87, 7.94, 8.01, 8.08, 8.15, 8.22, 8.29, 8.36, 8.42, 8.49, 8.56, 8.62, 8.68, 8.74, 8.8, 8.86, 8.92, 8.98, 9.04, 9.09, 9.15, 9.2, 9.26, 9.31, 9.36, 9.41, 9.46, 9.5, 9.55, 9.6, 9.64, 9.68, 9.73, 9.77, 9.81, 9.85, 9.88, 9.92, 9.96, 9.99, 10.03, 10.06, 10.09, 10.13, 10.16, 10.19, 10.22, 10.25, 10.28, 10.31, 10.33, 10.36, 10.38, 10.41, 10.43, 10.46, 10.48, 10.5, 10.52, 10.55, 10.57, 10.59, 10.61, 10.63, 10.65, 10.66, 10.68, 10.7, 10.72, 10.73, 10.75, 10.77, 10.78, 10.79, 10.81, 10.82, 10.83, 10.84, 10.85]\n",
    "\n",
    "# Make a line plot: year on the x-axis, pop on the y-axis\n",
    "plt.plot( years, pop)\n",
    "\n",
    "#axix label\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "\n",
    "#title\n",
    "plt.title('World Population Projections')\n",
    "\n",
    "#ticks\n",
    "plt.yticks([0, 2, 4, 6, 8, 10])\n",
    "\n",
    "# Display the plot with plt.show()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAqTklEQVR4nO3dd3xV9f3H8deHvRJm2CMge8gQBXFrhwNHrbWuVtQWW3eHs7au1lqttrbWKj+3IoqoP+uoi5+AKKJsZe8ZSAAhCZBAks/vj3NyucYAl5A7kryfj0ceufeMe9/3Jud+7vl+z/kec3dEREQAaiU7gIiIpA4VBRERiVBREBGRCBUFERGJUFEQEZEIFQUREYlQUZCEMLM7zeyF/cxfZWbfSWSm/TGzUWY29RDW/6+ZXVqZmSpbvDJWhdcu+6aiIACY2a1m9k6ZaUv3Me2CBGd7xsx2m1m+mW01sw/MrHciM+xPeQXP3U9z92fj8FyV9l5URsZEvnZJDBUFKTUFOMbMagOYWVugLjCkzLTu4bIxM7M6lZDvfndvAnQEsoFnKuExq6oDvhcW0PYtB03/NFLqC4IiMCi8fzzwEbC4zLTl7r7BzNqb2X/Cb6vLzOznpQ8UfnucYGYvmFkuMKrsk5nZT8xstZltMbPfxRrS3XcCLwL9w8fpY2aTzGybmc03s7OinuMZM3ss/DadZ2aTzaxLOC/TzDy6YIWP87PyntfMHjaztWaWa2Yzzey4cPqpwG3Aj8Nv73PLPpaZ1TKz28PXm21mz5lZ0zI5LjWzNWa2Odb3o5z3YpKZ/cnMPgF2At3MbISZfWFm28PfI/b1es3scjNbaGZfm9l7pe9VOK9f+D5uNbNNZnZbvF+7mR1lZjPC93yTmT0Uy/sih0ZFQQBw993AdIIPfsLfHwNTy0wr3UsYB6wD2gPnAfea2SlRD3k2MAFoBoyNfi4z6wv8G/hJuH5Lgm+9B2RmTYCLgdlmVhd4E3gfaA1cC4w1s15Rq1wM3AO0AuaUzXIQviAoji0IPohfMbMG7v4ucC/wsrs3cfeB5aw7Kvw5CegGNAEeKbPMsUAv4BTgD2bW50CBot+LqMk/AUYDaUAe8DbwD4L3+CHgbTNrWc5jnUPwAX8ukEHwtx8XzksDPgTeJfh7dQcmJuC1Pww87O7pwGHA+AO9J3LoVBQk2mT2FoDjCD4YPi4zbbKZdSLYkG929wJ3nwM8QfCBVGqau/+vu5e4+64yz3Me8Ja7T3H3QuD3QMkBsv3WzLYBywg+WEYBw8Pb97n7bnf/P+At4MKo9d6Oep7fAUeH+Q+Ku7/g7lvcvcjdHwTqE3yQxeJi4CF3X+Hu+cCtwAVlmtXucvdd7j4XmAuU9wFbqrz3otQz7j7f3YuA7wFL3f35MPc4YBFwZjmPeSXwZ3dfGK57LzAo3FsYCWx09wfDv3eeu09PwGvfA3Q3s1bunu/un8X4nHIIVBQk2hTgWDNrDmS4+1LgU2BEOK1/uEx7YKu750WtuxroEHV/7X6ep330fHffAWw5QLa/unszd2/r7me5+/LSx3H36IKyzxzhh9LWcL2DYma/CZtWtocfyE0J9j5i0T7MFZ2xDtAmatrGqNs7CT7s96W896JU9Pte9nlLn7sD39YFeDhshttG8D5ZuGwnYHk568TiUF77FUBPYFHY9DWyghnkIKgoSLRpBB92o4FPANw9F9gQTtvg7ivD+y3CZoVSnYH1Uff3N/xuFsEHDQBm1oigeeNgbQA62Tc7VMvmiH6eJgTNPxuAHeHkRlHLti3vScL+g5uB84Hm7t4M2E7woQn7f62lObtE3e8MFAGbDrBeRURnKfu8pc+9nm9bC1wZFpvSn4bu/mk477AYnq88FX7t7r7U3S8kaBr8CzDBzBofaD05NCoKEhE288wAfk3QbFRqajhtSrjcWoI9iD+bWQMzO5zgW12s7fUTgJFmdqyZ1QPupmL/i9MJPtxvMrO6ZnYiQdPIS1HLnB71PPcA0919rbvnEHw4XmJmtc3scvb9wZdG8EGWA9Qxsz8A6VHzNwGZtu+jfcYBvzKzrmFhKm2HL6rAaz4Y7wA9zewiM6tjZj8G+hI0sZX1GHCrmfUDMLOmZvajcN5bQFszu8HM6ptZmpkNC+fF7bWb2SVmlhHuCW4LJxcf+GXLoVBRkLImE3wziz5x6+NwWvShqBcCmQTfBF8H7nD3D2J5AnefD1xN0GGbBXxN0Gl9UMLO8bOA04DNwKPAT919UdRiLwJ3EDSHHEHQxl3q58CNBE1X/QgKXXneA/4LLCFo/ijgm800r4S/t5jZrHLWfwp4nuD9Wxmuf21ML/IQuPsWgv6A3xC8xpuAke6+uZxlXyf4Nv6SBUeMfUXwvhI2E36XoOBuBJYSdBxDfF/7qcB8M8sn6HS+wN0LYlxXKsh0kR2prszsGWCdu9+e7CypyMymAE+4+3PJziKpQ3sKIjVQ2I/TjeDbu0iEioJIDWNmrQmagSbzzWZCETUfiYjIXtpTEBGRiMoYqCypWrVq5ZmZmcmOISJSpcycOXOzu2eUnV7li0JmZiYzZsxIdgwRkSrFzMqe7Q6o+UhERKKoKIiISISKgoiIRKgoiIhIhIqCiIhEVPmjj0REaoLiEmfrjt1k5xWQk1dIdl4hZwxoR+P6lfsxrqIgIpICdu0uJjuvgLVbd7EgazvLsvPJziuMFIAt+YWUlBmAYlCnZvRsk1b+A1aQioKISIKUlDjrt+1i/obtzN+Qy4INuazYvIOcvELyC795iYlWTerTtml92qQ3oH/7pmSk1ad1en0ymtQPbqc1oF2zBpWeUUVBRKSS7SkuYemmfBZk5UYKwOotO9icv5vi8Ot+LYPurZvQt106rXsFH/IZafVp17QBfdql06JxvaRkV1EQEamg/MIiFmYF3/jXbN1Jdl4hKzfns2RjPruLg0uHN6xbm97t0ji+Rwat0+vToVkj+rZPp3fbNBrUrZ3kV/BtKgoiIjHIzitgwYbcSLPPgqxcVm3ZQelA0w3r1qZ1en06NW/EZcdk0rd9Ov3aN6Vrq8bUrmX7f/AUoqIgIlJGcYkzd902Ji/OYe66bczfkEtOXmFkfqcWDenXrik/GNyBfuGHf5v0+phVnQ//fVFREJEabXdRCUuz876xF7AwK5e8wiJqGfRsk8ZxPVrRr31T+rZLp2/7dJo2rJvs2HGjoiAiNUp+YRHz129n6rLNTFmSw8KsvG+0//dpl8bZg9tzZGYLju+RQfMkdfgmi4qCiFRrm/ML+XLddiYvyeHjpTms2Bz0A9SuZQzu1IzLjs2M7AVUtfb/eFBREJFqw91Zu3UXc9dtY8qSHKYu20zW9gIA6tepxfBuLTl7UNAPMLRLC5o2qr7NQBWloiAiVdqm3AImLc5m0uIcPlm2mdyC4CSw9AZ1OK5HBoM7N6Nf+6YM7twsJQ8BTTUqCiJSpewpLmHW6q+ZtCSHSYtzWJiVC0Cb9Pqc2r8tgzo1p3+HdPq2S6dObY35ebBUFEQk5W3cXsDkJcHewNSlm8krLKJOLeOILs25+dTenNgrg95t06rFIaHJpqIgIilpwYZc3py3gY8WZbNoYx4AbdMbcMbh7TixVwYjurcivYH6BCpb3IqCmT0FjASy3b1/OK0F8DKQCawCznf3r83sROANYCXBNR6ygYvcPTte+UQktZSUOAuycpm0OJv/frWR+RtyqVPLGJrZnFtOC/YGerXR3kC8xXNP4RngEeC5qGm3ABPd/T4zuyW8f3M472N3HwlgZn8GrgbuiGM+EUmy4hJnytIc3pqbxeQlOWzOD84aHtixKXed1Y+zBravcecJJFvcioK7TzGzzDKTzwZODG8/C0xib1EAwIKvAWnAsnhlE5HkKSwq5tNlW5i0OJt3529kU24h6Q3qcHzPDE7q1Zrje2aQkVY/2TFrrET3KbRx9ywAd88ys9ZR844zszlAS2AHcNu+HsTMRgOjATp37hy/tCJSKdyd+RtyeWXGWv53zga279pDw7q1OaZ7K+48swOn9GlDvTo6UigVpFJHc3Tz0c3A/cAvylvQ3ccAYwCGDh3q5S0jIslVWggmL8nhrXlZLMzKpV6dWpzary3nDunA8G4tdd5ACkp0UdhkZu3CvYR2BB3K5fkP8GoCc4lIJVm/bRevzlzHhJnrWLN1JwADOzXjnnP6c9bh7XUWcYpLdFH4D3ApcF/4+419LHcssDxRoUTk0BTsKeb9BZt4ZcZapi7bjDsc3a0l15zcnRN7ZdA6rfIvGynxEc9DUscRdCq3MrN1BEcS3QeMN7MrgDXAj6JWKe1TMGA78LN4ZRORyrFxewH/8/EKXpmxltyCIjo0a8h1J/fgvCM60qlFo2THkwqI59FHF+5j1inlLDsJaBqvLCJSeUpKnOkrt/LKjLW8OW8DJQ6nD2jHBUd24uhuLalVw0cZrepSqaNZRFJY1vZdvDJjb19BWv06XHhUZ35+XDftFVQjKgoisl8rcvJ5bPJyXp+9nj3FzojDWvLr7/bk+/3a0rCejh6qblQURORb3J1567YzZsoK3vkqi3q1a3HxsC5ccWxX7RVUcyoKIhKxa3cx42esZdzna1i0MY+0+nX45QmHcfmxXWnVRGcZ1wQqCiLC9l17eH7aKp76ZBVbd+xmYMem3HNOf84e1F4jkdYwKgoiNVhOXiFPfbKS56etJr+wiJN6ZXDVSd05MrNFsqNJkqgoiNRA677eyZgpK3j5i7XsLi7h9AHtuOrEw+jXXkeG13QqCiI1yMbtBTz4/mJen70eMzh3cEeuPKEb3TKaJDuapAgVBZEaYPuuPTz9yUoen7yC4hLnkuFdGH18N9o3a5jsaJJiVBREqrHcgj08Nmk5z4V9BqcPaMutp/XRYaWyTyoKItXQ7qISxs9Yy98+WMLWnbvVZyAxU1EQqUYKi4p5cfoaxkxZQdb2Ao7KbMGzZ/alfwcVA4mNioJINeDuvL9gE/e+s5DVW3ZyVNcW3PfDwzm+Rytd6F4OioqCSBW3MCuXu99cwLQVW+jeugnPXn4UJ/TMSHYsqaJUFESqqM35hTz4/hJe/mIN6Q3rcvfZ/bjoqM7Uqa1rHUvFqSiIVDGFRcU888kq/vl/yyjYU8yoEV25/pQeusylVAoVBZEqwt15b37Qb7Bm605O6d2a287ow2E68UwqkYqCSBUwf8N27nlrAZ+t2ErPNk147vKjOF79BhIHKgoiKSwnr5CHPljMS1+spVnDutxzdj8uVL+BxJGKgkgKKiwq5ulPVvFI2G9w+TFdue5k9RtI/KkoiKSQoN9gI/e+syjSb/C7M/powDpJGBUFkRSxKbeA2177komLsunZpgnPX3EUx/VQv4EkloqCSJK5O6/NWs9db86nsKiE28/ow6gRmeo3kKRQURBJovXbdvGH//2KiYuyGdqlOQ/8aCBdWzVOdiypwVQURJJg1+5i/j1pGY9PWYEZ3H5GHy47piu1a2mcIkkuFQWRBJu+Ygs3vTqP1Vt2ctbA9tx8Wm866GI3kiJUFEQSZOfuIu5/dzHPfLqKzi0aMe7nwzn6sJbJjiXyDSoKIgkQvXdw6dFduPm03jSqp81PUo/+K0XiqOzewUujhzO8m/YOJHUlpSiY2a+AnwEOfAlcBjwGnABsBxoA49z9rmTkE6kMn63Ywk0T5rFm605GjcjkplN7ae9AUl7C/0PNrANwHdDX3XeZ2XjggnD2je4+wcwaAAvM7Dl3X5nojCKHQnsHUpUl62tLHaChme0BGgEbysxvEP7ekdBUIodIewdS1SX8lEl3Xw/8FVgDZAHb3f39cPYDZjYHWAe85O7Z5T2GmY02sxlmNiMnJycRsUX2a+fuIu544ysuGPMZAC+PHs6dZ/VTQZAqJ+FFwcyaA2cDXYH2QGMzuyScfaO7DwLaAqeY2YjyHsPdx7j7UHcfmpGhsWEkuaYt38Kpf/+YZ6etZtSITN694TiGqblIqqhkfI35DrDS3XMAzOw14Bsf/u6eb2aTgGOBTxOeUCQGu4tKuP/dRTwxdSVdWjbi5dHDVQykyktGUVgDDDezRsAu4BRgBnBE6QJmVgcYBvwzCflEDmj9tl1c8+IsZq/Zxk+Gd+HW03XegVQPCf8vdvfpZjYBmAUUAbOBMcDjBH0KtwP1gInAa4nOJ7I/7s74GWv541sLceBfFw3hjMPbJTuWSKVJylcbd78DuKPM5FFJiCISs207d/Ob8XOZuCibYV1b8MB5A+ncslGyY4lUKu3visRgztptXD12Ftl5BfxhZF9GjciklkY0lWpIRUFkP9ydZz9dxZ/eWUjrtAa88osRDOrULNmxROJGRUFkH/IK9nDLq1/y9pdZnNK7NQ+eP5BmjeolO5ZIXKkoiJRjYVYuV42dxZqtO7n51N5ceXw3NRdJjaCiIFLG+C/W8vs3vqJpw7q8+LNhOvdAahQVBZHQrt3F/P6Nr5gwcx0jDmvJwxcMJiOtfrJjiSSUioIIsDwnn6vHzmLxpjyuO7k713+np66XLDWSioLUeG/N28DNE+ZRr04tnh51JCf2ap3sSCJJo6IgNVZhUTH3vr2QZ6etZkjnZjxy0RDaN2uY7FgiSaWiIDXS2q07uebFWcxdt50rju3KLaf1pm7thA8aLJJyVBSkxpm4cBO/Hj+XkhLnsUuO4NT+bZMdSSRlqChIjVFUXMJf31/CY5OX0699Oo9ePIQuLRsnO5ZISlFRkBphU24B1744m89XbeXCozpzx5l9aVC3drJjiaQcFQWp9j5ZtpnrX5rNjsJi/vbjgfxgcMdkRxJJWSoKUm25O//6aBkPfrCEwzKaMO7nQ+jRJi3ZsURSmoqCVEsFe4q5+dV5vDFnA2cPas+9PxhA4/r6dxc5EG0lUu1syi3g6rGzmLH6a278fi+uOvEwzHR2skgsYioKZlYf+CGQGb2Ou98dn1giFRPdf/DIRYMZeXj7ZEcSqVJi3VN4A9gOzAQK4xdHpGJKSpxHPlrG3z5U/4HIoYi1KHR091PjmkSkgrbkF/Kr8XOZsiSHcwa150/qPxCpsFi3nE/NbIC7fxnXNCIHaebqrVw9djZbd+7m3h8M4MKjOqn/QOQQxFoUjgVGmdlKguYjA9zdD49bMpH9cHeenLqS+/67iPbNGvLaL0fQv0PTZMcSqfJiLQqnxTWFyEHYumM3t7w6j/cXbOL7/dpw/3kDadqwbrJjiVQLMRUFd19tZgOB48JJH7v73PjFEinfu19l8bvXvyK3YA+3n9GHK47tquYikUoU6yGp1wM/B14LJ71gZmPc/Z9xSyYSpWBPMXe/tYAXp6+hf4d0XjhvGH3apSc7lki1E2vz0RXAMHffAWBmfwGmASoKEnert+zgqrGzmL8hlytP6MZvv9dL1z4QiZNYi4IBxVH3i8NpInH17lcbuXHCXGqZ8cRPh/Kdvm2SHUmkWou1KDwNTDez18P75wBPxiWRCLCnuIS//HcRT0xdyeEdm/Kvi4bQqUWjZMcSqfZi7Wh+yMwmERyaasBl7j47nsGk5lqzZSe/Gj+Hmau/5tKju3DbGX2oX0fXPhBJhP0WBTNLd/dcM2sBrAp/Sue1cPet8Y0nNUlJifPC9NXc999F1DbjnxcO5syBGrtIJJEOtKfwIjCSYMwjj5pu4f1uFXlSM2sGPAH0Dx/ncuBK4ASCMZYaAOPc/a6KPL5UPdt37uE3r8zhw4XZHN8zg/vOHUD7Zg2THUukxtlvUXD3keHvrpX8vA8D77r7eWZWDyhtLL7R3SeYWQNggZk95+4rK/m5JcV8sWorv3p5DptyC7jjzL6MGpGpcw9EkiSm4/rMbGIs02J8rHTgeMKOanff7e7byizWIPy9oyLPIVVDwZ5i7n5zAec/Pg0zGH/l0Vx2jE5GE0mmA/UpNCD4Ft/KzJqz9zDUdKCijb3dgBzg6fAs6ZnA9eG8B8zsdqA78A93z95HrtHAaIDOnTtXMIYk08rNwbkHC7NyufToLtx0am+NbCqSAg60FV4J3EBQAGaytyjkAv86hOccAlzr7tPN7GHglnBeafNRE2CimY1w90/LPoC7jwHGAAwdOtTLzpfU9s6XWdw0YR51ahtPX3YkJ/VqnexIIhI6UJ/Cw8DDZnZtJQ5psQ5Y5+7Tw/sTCIpCTtTz5kcdAvutoiBV0+6iEu59ZyHPfLqKwZ2b8chFQ+igzmSRlBLreQr/NLP+QF/2tvfj7s8d7BO6+0YzW2tmvdx9MXAKsADIKF3GzOoAw9AwGtXG+m27uHrsLOas3cblx3TlltN6U6+OhqoQSTWxDoh3B3AiQVF4h2Ao7anAQReF0LXA2PDIoxXAZcDf2NunUA+YyN4B+KQK+2hRNr8aP4fiYuffFw/htAHtkh1JRPYh1p6984CBwGx3v8zM2hCcZ1Ah7j4HGFpm8qiKPp6kpqLiEh76YAmPTlpOn3bp/PviIWS2apzsWCKyH7EWhV3uXmJmReEhpdlU8MQ1qRmycwu47qXZfLZiKxcc2Yk7z+pHg7oaqkIk1cVaFGaEZyH/D8FRSPnA5/EKJVXbF6u28ssXZpFfuIcHfzSQHx7RMdmRRCRGsXY0XxXefMzM3gXS3X1e/GJJVfW/s9dz04R5dGjekLE/G0avtmnJjiQiB+FAJ68N2d88d59V+ZGkKoruPxjerQWPXXIEzRrVS3YsETlIB9pTeHA/8xw4uRKzSBWVnVfAtS/OZvrKrVx4VCfuOqu/DjcVqaIOdPLaSYkKIlXToo25XP70F2zduZuHzh/IuUPUfyBSlcV6nsJPy5tekZPXpPqYtDiba16cTeP6tZnwixH079A02ZFE5BDFevTRkVG3GxCchTyLip+8JlXc85+t5s7/zKdXmzSeHDWUdk01XIVIdRDr0UfXRt83s6bA83FJJCmtuMS5952FPDl1JSf3bs0/Lxys0U1FqpGKbs07gR6VGURS387dRVw3bg4fLtzEqBGZ/H5kX2rX0rUPRKqTWPsU3mTv5ThrA32A8fEKJalnU24BVzz7BQs25HLnmX0ZdUxlX4xPRFJBrHsKf426XQSsdvd1ccgjKWhhVi6XP/MF23ft4YlLh3Jy7zbJjiQicRLTweTuPhlYDDQFWhAUBqkBZq35mh8/Pg13eOUXR6sgiFRzsV6j+WcEYx2dSzBi6mdmdnk8g0nyfbp8Mz95YjrNG9djwi+Ppl97HXIqUt3F2nx0IzDY3bcAmFlLgiuiPRWvYJJcE2au49bX5pHZsjFjfzaM1ukNDrySiFR5sRaFdUBe1P08YG3lx5FkKyou4a/vL+Gxycs5pntLHr34CJo2rJvsWCKSILEWhfXAdDN7g+AopLOBz83s1wDu/lCc8kkCZecVcN244BoIFx7VmbvP7kfd2hrDSKQmibUoLA9/Sr0R/ta4yNXE/A3bueKZGWzbtVvXQBCpwWI9o/kuADNLC+56flxTSUJ9uGAT1700m6YN6/LaL4+hb/v0ZEcSkSSJ9eS1/gTDWrQI728Gfuru8+OYTeIs+hoIAzo05YlLh9JGHcoiNVqszUdjgF+7+0cAZnYiwaU5R8QnlsRbdm4B147bew2EO87UNZRFJPai0Li0IAC4+yQzaxynTBJnny7fzHXj5rCjsEjXQBCRb4i1KKwws9+zd2TUS4CV8Ykk8VJS4jw6aRkPfbCErq0a8+LPh9GzjY4VEJG9Yi0KlwN3Aa+F96cAl8UlkcTF1zt286vxc5i0OIezB7Xn3h8M0JDXIvIt+/1UMLMGwC+A7sCXwG/cfU8igknlmbXma64ZO4vN+bv54zn9uXhYZ8w05LWIfNuBvio+C+wBPgZOIxgy+4Y4Z5JKUlhUzN8/XMrjk5fToXlDXv3lCAZ01PhFIrJvByoKfd19AICZPUkwKJ5UAcuy87l67CwWb8rj/KEduX1kX9IbaLgKEdm/AxWFSFORuxepyaFqeGPOem577Uvq163N06OO5KTerZMdSUSqiAMVhYFmlhveNqBheN8IzmzWqa8pZHN+IX944yve+XIjQ7s055GLhtC2qU5GE5HY7bcouHvczmYys9rADGC9u480s2eAE4DtQANgXOnwGnJgU5du5vqXZpNXUMRNp/Zi9HHdqKPB7ETkICXzmMTrgYVA9N7Gje4+ITzqaYGZPefuOh9iP4qKS3jko2U8PHEp3TOaMG70cJ17ICIVlpSiYGYdgTOAPwG/LmeR0jaPHQkLVQUt3pjHb1+Zy5frt3Pu4A788Qf9aVRP5x6ISMUl6xPk78BNfHvo7QfM7HaC8yL+4e7ZiQ5WFbg7L36+hrveXEBa/To8evEQTh/QLtmxRKQaSHhRMLORQLa7zwwH1otW2nzUBJhoZiPc/dNyHmM0MBqgc+fO8Y6cUnYUFnHb61/yxpwNnNAzg4fOH0jLJvWTHUtEqolk7CkcA5xlZqcTNBOlm9kLQFHpAu6eb2aTgGMJrgX9De4+hmDkVoYOHeqJCJ0KlmzK45cvzGTl5h389ns9uerE7tSqpcOERaTyJPzwFHe/1d07unsmcAHwf+5+SfQyZlYHGMY3r/ZWY5WUOE9NXclZj0xl+64iXrhiGNec3EMFQUQqXar1Spb2KdQDJrJ3AL4aa8O2Xdzw8hw+X7mVk3pl8JcfHk5rXQhHROIkqUXB3ScBk8Lbo5KZJRVNXpLDDS/NZndRCQ+cdzjnHdFRA9mJSFyl2p6CEHQm3//uIp6dtprebdN49OIhdMtokuxYIlIDqCikmLlrt3HtuNms/Xonlx2TyU3f703DerpMpogkhopCinB3npu2mj++vYDWaQ14efTRHNW1RbJjiUgNo6KQAjZs28Utr33JlCU5nNy7NQ+dP5BmjeolO5aI1EAqCknk7oyfsZY/vrWQohLn7rP7ccmwLjrUVESSRkUhSaL3DoZ1bcED5w2kc8tGyY4lIjWcikKCuTsvf7GWP769kBLX3oGIpBYVhQRav20Xt7w6j4+XbmZ4txbc/0PtHYhIalFRSIDdRSU8N20Vf/9wKSXu3HN2Py7W3oGIpCAVhThydz5cmM2f3l7Aqi07OaFnBn88pz+dWmjvQERSk4pCnCzamMs9by3gk2VbOCyjMU9fdiQn9Wqd7FgiIvulolDJNuUW8I+JSxn3+RrSGtTlzjP7cvHwLtTV9ZJFpApQUagkG7bt4pGPljFhxjqK3fnp0Znc8J0eOglNRKoUFYVDtKOwiDFTVvD4lOWUlMB5Qzty5fHd6NKycbKjiYgcNBWFCtq+aw9Pf7KSZz5dxbadexh5eDtuOa03HZurE1lEqi4VhYNUVFzCuC/W8tD7i/l65x6+06cNV590GIM7N092NBGRQ6aiEKOCPcW8Omsdj01eztqtuxjWtQW/H9mX/h2aJjuaiEilUVE4gPzCIl6cvpr/+XglOXmFDOzUjD+M7Md3+rTWVdBEpNpRUdiHLfmFPDdtNc98uortu/ZwTPeWPPzjQRx9WEsVAxGptlQUorg7nyzbwvOfrWLiwmyKSpzv9m3DVSeqz0BEagYVBaCkxHl/wSb+PWkZc9dtp2XjeowakcmPj+xEjzZpyY4nIpIwNboo5BXs4e15WTw5dSVLs/Pp0rIRfz53AOcO6UD9OrousojUPDW2KNzz1gJenL6GXXuK6d02jYcvGMQZA9pRR8NRiEgNVmOLQuN6tTlncAfOH9qRQZ2aqfNYRIQaXBR+/b1eyY4gIpJy1FYiIiIRKgoiIhKhoiAiIhEqCiIiEqGiICIiEQkvCmbWycw+MrOFZjbfzK4Ppz9jZivNbI6ZLTKzOxKdTUSkpkvGIalFwG/cfZaZpQEzzeyDcN6N7j7BzBoAC8zsOXdfmYSMIiI1UsKLgrtnAVnh7TwzWwh0KLNYg/D3jkRmExGp6ZLap2BmmcBgYHo46QEzmwOsA15y9+x9rDfazGaY2YycnJyEZBURqQmSVhTMrAnwKnCDu+eGk29090FAW+AUMxtR3rruPsbdh7r70IyMjMQEFhGpAZJSFMysLkFBGOvur5Wd7+75wCTg2ARHExGp0ZJx9JEBTwIL3f2hfSxTBxgGLE9kNhGRmi4ZewrHAD8BTg4PP51jZqeH80r7FOYBXwLf2osQEZH4ScbRR1OB8sapfifRWURE5Jt0RrOIiESoKIiISISKgoiIRKgoiIhIhIqCiIhEqCiIiEiEioKIiESoKIiISISKgoiIRKgoiIhIhIqCiIhEqCiIiEiEioKIiESoKIiISISKgoiIRKgoiIhIhIqCiIhEqCiIiEiEioKIiESoKIiISISKgoiIRKgoiIhIhIqCiIhEqCiIiEiEioKIiESoKIiISISKgoiIRKgoiIhIhIqCiIhEqCiIiEhEyhUFMzvVzBab2TIzuyXZeUREapKUKgpmVhv4F3Aa0Be40Mz6JjeViEjNkVJFATgKWObuK9x9N/AScHaSM4mI1Bh1kh2gjA7A2qj764BhZRcys9HA6PBuvpktTkC2WLQCNic7xAGkesZUzwfKWBlSPR+kfsZDzdelvImpVhSsnGn+rQnuY4Ax8Y9zcMxshrsPTXaO/Un1jKmeD5SxMqR6Pkj9jPHKl2rNR+uATlH3OwIbkpRFRKTGSbWi8AXQw8y6mlk94ALgP0nOJCJSY6RU85G7F5nZNcB7QG3gKXefn+RYByPlmrTKkeoZUz0fKGNlSPV8kPoZ45LP3L/VZC8iIjVUqjUfiYhIEqkoiIhIhIrCAZjZU2aWbWZfRU0baGbTzOxLM3vTzNKj5h0ezpsfzm8QTj8ivL/MzP5hZuUdfhvXfGZW18yeDacvNLNbo9aJV75OZvZR+Hzzzez6cHoLM/vAzJaGv5tHrXNrmGOxmX0/1TKa2XfNbGaYZaaZnZxqGaPW62xm+Wb223hmrODfOdHbysH+nRO6vewn34/C+yVmNrTMOpW/rbi7fvbzAxwPDAG+ipr2BXBCePty4J7wdh1gHjAwvN8SqB3e/hw4muBcjP8CpyUh30XAS+HtRsAqIDPO+doBQ8LbacASgiFM7gduCaffAvwlvN0XmAvUB7oCyxPwHh5sxsFA+/B2f2B91GOlRMao9V4FXgF+G8+MFXgPk7GtHGzGhG4v+8nXB+gFTAKGRi0fl23lkN/omvADZPLND91c9nbSdwIWhLdPB17Yxx97UdT9C4HHk5DvQuDNcINsGf7TtYh3vjJZ3wC+CywG2kW9P4vD27cCt0Yt/174z50yGcssa8CWcMNMqYzAOcADwJ2ERSFRGWP4OydlWznIjEndXkrzRd2fxDeLQly2FTUfVcxXwFnh7R+x94S7noCb2XtmNsvMbgqndyA4Ma/UunBaovNNAHYAWcAa4K/uvjVR+cwsk+Bb9nSgjbtnAYS/W4eLlTfUSYcUyxjth8Bsdy9MpYxm1hi4GbirzOpxzxjje5jUbSXGjEnbXsrk25e4bCspdZ5CFXI58A8z+wPByXW7w+l1gGOBI4GdwEQzm0nwzb2seB4LvK98RwHFQHugOfCxmX1IjMOLHAoza0LQlHGDu+fup4lzX1lSKWPp8v2AvwDfK52UQhnvAv7m7vlllolrxoPIl7Rt5SAyJmV7KZtvf4vuI8ch5VNRqAB3X0T4QWBmPYEzwlnrgMnuvjmc9w5Be/8LBEN2lIrr8B37yXcR8K677wGyzewTYCjwcTzzmVldgn/yse7+Wjh5k5m1c/csM2sHZIfT9zXUyboUyoiZdQReB37q7sujsqdKxmHAeWZ2P9AMKDGzgnD9uGSswN854dvKQWZM+Payj3z7EpdtRc1HFWBmpbvotYDbgcfCWe8Bh5tZIzOrA5xA0J6fBeSZ2fDwKICfErQXJjrfGuBkCzQGhhO0PcYtX/h4TwIL3f2hqFn/AS4Nb18a9Xz/AS4ws/pm1hXoAXyeShnNrBnwNkF77ielC6dSRnc/zt0z3T0T+Dtwr7s/Eq+MFfg7J3xbqUDGhG4v+8m3L/HZVuLRgVOdfoBxBG2Kewgq8BXA9QSdTkuA+wg7dcPlLwHmE7Tr3x81fWg4bTnwSPQ6icoHNCE4EmU+sAC4MQH5jiXYdZ0HzAl/TifouJsILA1/t4ha53dhjsVEHTWRKhkJCu2OqGXnAK1TKWOZde/km0cfVXrGCv6dE72tHOzfOaHby37y/YBg2y4ENgHvxXNb0TAXIiISoeYjERGJUFEQEZEIFQUREYlQURARkQgVBRERiVBREDlI4XHrU83stKhp55vZu8nMJVIZdEiqSAWYWX+CY9gHE1w6dg5wqu89u/lgHqu2uxdXbkKRilFREKmgcAiJHUDj8HcXYADB8DF3uvsb4cBmz4fLAFzj7p+a2YnAHQQnHg5y976JTS9SPhUFkQoKhz6YRTDg4FvAfHd/IRwG43OCvQgHSty9wMx6AOPcfWhYFN4G+rv7ymTkFymPBsQTqSB332FmLwP5wPnAmbb3CmcNgM4EA5E9YmaDCEbc7Bn1EJ+rIEiqUVEQOTQl4Y8BP3T3xdEzzexOgvFqBhIc2FEQNXtHgjKKxExHH4lUjveAa8NRKTGzweH0pkCWu5cAPyHolBZJWSoKIpXjHqAuMM/MvgrvAzwKXGpmnxE0HWnvQFKaOppFRCRCewoiIhKhoiAiIhEqCiIiEqGiICIiESoKIiISoaIgIiIRKgoiIhLx/yk0dmqwmi0+AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "years = [1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100]\n",
    "pop = [2.53, 2.57, 2.62, 2.67, 2.71, 2.76, 2.81, 2.86, 2.92, 2.97, 3.03, 3.08, 3.14, 3.2, 3.26, 3.33, 3.4, 3.47, 3.54, 3.62, 3.69, 3.77, 3.84, 3.92, 4.0, 4.07, 4.15, 4.22, 4.3, 4.37, 4.45, 4.53, 4.61, 4.69, 4.78, 4.86, 4.95, 5.05, 5.14, 5.23, 5.32, 5.41, 5.49, 5.58, 5.66, 5.74, 5.82, 5.9, 5.98, 6.05, 6.13, 6.2, 6.28, 6.36, 6.44, 6.51, 6.59, 6.67, 6.75, 6.83, 6.92, 7.0, 7.08, 7.16, 7.24, 7.32, 7.4, 7.48, 7.56, 7.64, 7.72, 7.79, 7.87, 7.94, 8.01, 8.08, 8.15, 8.22, 8.29, 8.36, 8.42, 8.49, 8.56, 8.62, 8.68, 8.74, 8.8, 8.86, 8.92, 8.98, 9.04, 9.09, 9.15, 9.2, 9.26, 9.31, 9.36, 9.41, 9.46, 9.5, 9.55, 9.6, 9.64, 9.68, 9.73, 9.77, 9.81, 9.85, 9.88, 9.92, 9.96, 9.99, 10.03, 10.06, 10.09, 10.13, 10.16, 10.19, 10.22, 10.25, 10.28, 10.31, 10.33, 10.36, 10.38, 10.41, 10.43, 10.46, 10.48, 10.5, 10.52, 10.55, 10.57, 10.59, 10.61, 10.63, 10.65, 10.66, 10.68, 10.7, 10.72, 10.73, 10.75, 10.77, 10.78, 10.79, 10.81, 10.82, 10.83, 10.84, 10.85]\n",
    "\n",
    "# Make a line plot: year on the x-axis, pop on the y-axis\n",
    "plt.plot( years, pop)\n",
    "\n",
    "#axix label\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "\n",
    "#title\n",
    "plt.title('World Population Projections')\n",
    "\n",
    "#ticks\n",
    "plt.yticks([0, 2, 4, 6, 8, 10],['0','2B','4B','6B','8B','10B'])\n",
    "\n",
    "# Display the plot with plt.show()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add historical data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "years = [1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100]\n",
    "pop = [2.53, 2.57, 2.62, 2.67, 2.71, 2.76, 2.81, 2.86, 2.92, 2.97, 3.03, 3.08, 3.14, 3.2, 3.26, 3.33, 3.4, 3.47, 3.54, 3.62, 3.69, 3.77, 3.84, 3.92, 4.0, 4.07, 4.15, 4.22, 4.3, 4.37, 4.45, 4.53, 4.61, 4.69, 4.78, 4.86, 4.95, 5.05, 5.14, 5.23, 5.32, 5.41, 5.49, 5.58, 5.66, 5.74, 5.82, 5.9, 5.98, 6.05, 6.13, 6.2, 6.28, 6.36, 6.44, 6.51, 6.59, 6.67, 6.75, 6.83, 6.92, 7.0, 7.08, 7.16, 7.24, 7.32, 7.4, 7.48, 7.56, 7.64, 7.72, 7.79, 7.87, 7.94, 8.01, 8.08, 8.15, 8.22, 8.29, 8.36, 8.42, 8.49, 8.56, 8.62, 8.68, 8.74, 8.8, 8.86, 8.92, 8.98, 9.04, 9.09, 9.15, 9.2, 9.26, 9.31, 9.36, 9.41, 9.46, 9.5, 9.55, 9.6, 9.64, 9.68, 9.73, 9.77, 9.81, 9.85, 9.88, 9.92, 9.96, 9.99, 10.03, 10.06, 10.09, 10.13, 10.16, 10.19, 10.22, 10.25, 10.28, 10.31, 10.33, 10.36, 10.38, 10.41, 10.43, 10.46, 10.48, 10.5, 10.52, 10.55, 10.57, 10.59, 10.61, 10.63, 10.65, 10.66, 10.68, 10.7, 10.72, 10.73, 10.75, 10.77, 10.78, 10.79, 10.81, 10.82, 10.83, 10.84, 10.85]\n",
    "\n",
    "# Add more data\n",
    "year = [1800, 1850, 1900] + years\n",
    "pop = [1.0, 1.262, 1.650] + pop\n",
    "\n",
    "# Make a line plot: year on the x-axis, pop on the y-axis\n",
    "plt.plot( year, pop)\n",
    "\n",
    "#axix label\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Population')\n",
    "\n",
    "#title\n",
    "plt.title('World Population Projections')\n",
    "\n",
    "#ticks\n",
    "plt.yticks([0, 2, 4, 6, 8, 10],['0','2B','4B','6B','8B','10B'])\n",
    "\n",
    "# Display the plot with plt.show()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Before & After"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \"./media/before & after.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case Study:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "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>Unnamed: 0</th>\n",
       "      <th>country</th>\n",
       "      <th>year</th>\n",
       "      <th>population</th>\n",
       "      <th>cont</th>\n",
       "      <th>life_exp</th>\n",
       "      <th>gdp_cap</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>11</td>\n",
       "      <td>Afghanistan</td>\n",
       "      <td>2007</td>\n",
       "      <td>31889923.0</td>\n",
       "      <td>Asia</td>\n",
       "      <td>43.828</td>\n",
       "      <td>974.580338</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>23</td>\n",
       "      <td>Albania</td>\n",
       "      <td>2007</td>\n",
       "      <td>3600523.0</td>\n",
       "      <td>Europe</td>\n",
       "      <td>76.423</td>\n",
       "      <td>5937.029526</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>35</td>\n",
       "      <td>Algeria</td>\n",
       "      <td>2007</td>\n",
       "      <td>33333216.0</td>\n",
       "      <td>Africa</td>\n",
       "      <td>72.301</td>\n",
       "      <td>6223.367465</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>47</td>\n",
       "      <td>Angola</td>\n",
       "      <td>2007</td>\n",
       "      <td>12420476.0</td>\n",
       "      <td>Africa</td>\n",
       "      <td>42.731</td>\n",
       "      <td>4797.231267</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>59</td>\n",
       "      <td>Argentina</td>\n",
       "      <td>2007</td>\n",
       "      <td>40301927.0</td>\n",
       "      <td>Americas</td>\n",
       "      <td>75.320</td>\n",
       "      <td>12779.379640</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Unnamed: 0      country  year  population      cont  life_exp       gdp_cap\n",
       "0          11  Afghanistan  2007  31889923.0      Asia    43.828    974.580338\n",
       "1          23      Albania  2007   3600523.0    Europe    76.423   5937.029526\n",
       "2          35      Algeria  2007  33333216.0    Africa    72.301   6223.367465\n",
       "3          47       Angola  2007  12420476.0    Africa    42.731   4797.231267\n",
       "4          59    Argentina  2007  40301927.0  Americas    75.320  12779.379640"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('./dataset/gapminder.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEaCAYAAAAWvzywAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAu30lEQVR4nO3debgcZZn38e8vhwMc1oAEhkRDcERQFBKNOorOsCjooJBBBlxQXNEZRwdUMDq+LC5DHByXcccNVEAQNYD4Cr5EFFHBxAQBkUEJCCeRzSRsRwjJ/f5R1aHS6aW6T1Wvv891neuc7q6qfrrTufup57nrfhQRmJnZ8JjS7QaYmVlnOfCbmQ0ZB34zsyHjwG9mNmQc+M3MhowDv5nZkHHgt0JJOlXStxo8fpukF3eyTXk0a3e/knSjpP273Q7rLQ78Q0bS+yX9sOq+W+rc96oOt+0sSY9KeiD9uUHS6ZK272Q7+kWeL6uI2Dsirmzj2DtLOk/SCklrJF0t6XlV27xG0u2SHpK0UNKOmce2kPQ1SfdL+rOkd2cee5GkB6t+QtIrW22ntceBf/j8DNhP0giApL8BRoFnVd33lHTb3CRtVkD7/isitgWmAW8E/g64WtLWBRzb8tsG+DXwbGBH4GzgUknbAEjaG/gS8DpgF+Bh4POZ/U8F9gB2Aw4ATpL0UoCIuCoitqn8AC8HHgR+1IHXZTjwD6NfkwT62entvwd+Atxcdd8fI2KFpOmSLpb0F0l/kPTWyoHSHueFkr4l6X7gDdVPJul1aa/wPkn/kbeREfHXiPg1cBjwBJIvgcox3yTpJkmrJF0mabf0/i9K+njV819U6W2mr+W7ku6RtFzSu+o9v6TD0mGS1ZKulPS0zGO3pWdOv0vb8HVJW6aP7S/pTkknSbpb0kpJ8yT9o6T/Td/HD2SONUXSfEl/TN+jCyo9Z0mz0p7wsZL+JOneynuYBtEPAEenPebr6ryODUNr6b/XBZK+kZ5R3Shpbp33/9aI+ERErIyIdRFxJrA5sGe6yWuBSyLiZxHxIPB/gCMkbZs+/nrgwxGxKiJuAr5Mjc9H6ljgwoh4qN6/hxXLgX/IRMSjwDUkwZ3091XAz6vuq/T2zwPuBKYDRwL/KemgzCEPBy4EpgLnZJ9L0tOBL5D0CqeTBPAnttjeB4AfAy9KjzmPJOAdQXJWcFXaRoBzSQKh0m13AA4Gvi1pCnAJcB0wAzgIOF7SIdXPKemp6TGPT5/jh8AlkjbPbPZa4BDgb4GnAh/MPPY3wJbp85xMEvSOIek9vwg4WdKT023fBcwD/iF9j1YBn6tq0gtJAu5B6b5Pi4gfAf8JnJ/2nPet/y5u5DDg2yT/XhcDn82zk6TZJIH/D+lde5O8lwBExB+BR4Gnpu/79Ozj6d971zjuViSfq7Nztt8K4MA/nH7K40H+RSTB86qq+34q6UkkQed9aQ98GfAVkkBe8cuIWBgR6yNioup5jgR+kPYKHyHpFa5vo70rSIYbAN4GnB4RN0XEYyTBb3ba678KiLT9lef/ZUSsAJ4DTIuID0XEoxFxK0lArjWPcTRwaUT8OCLWAh8HxoAXZLb5bETcERF/AT4KvDrz2Frgo+m+3wZ2Aj4dEQ9ExI3AjcA+mdfzHxFxZ/oenQocWTVsdlpETETEdSQBNG+Qr+XnEfHDiFgHfDPPsSRtl257WkSsSe/eBlhTtekaYNv0MaoerzxW7ZXAvSSfSesQB/7h9DPghWnPbFpE3AL8AnhBet8z0m2mA39Je90Vt5P0ZCvuaPA807OPp6fy97XR3hnAX9K/dwM+nQ7BrE7vFzAjkoqD3+bxIPwaHj8L2Q2YXtkv3fcDJOPTtdp9e6bd69PXUe91357uU3FfGlgBKl+Gd2Uen+Dx4Lgb8P1Mm24C1lW168+Zvx/O7NuO6mNt2WhuRtIYyZnSryLi9MxDDwLbVW2+HfBA+hhVj1ceq3Ys8I1wtciOcuAfTr8EtgeOA64GiIj7SXrWxwErImJ5envHzLgtwExgPHO70X/YlcCTKjfS0/ontNLQdDLxxSS9eUgC7tsiYmrmZywifpE+fh5Jj3k34HnAdzP7La/ab9uI+McaT7uCJCBX2qD0dWRf95Myf89M92nHHcDLqtq1ZUSMN92z8Xs/aZK2ABaSvO63VT18I5mzhXToagvgfyNiFcm/ffZsYt90n+zxnwTsD3yj4KZbEw78QygdklkMvJvHAyok4/zvJh3fj4g7SM4ETpe0paR9gDdTNZbfwIXAyyW9MB0f/xA5P3NK0gGfTRJ4VgFfTx/6IvD+NKsESdtL+ufMa1sK3EMyJHVZRKxOH7oWuF/S+ySNSRqR9AxJz6nx9BcAh0o6SNIo8B7gkfS9qHiHpCemE7EfAM7P87pq+CLw0cwE9TRJh+fc9y5gVjp/Uaj0dV9Icnby+vSsJ+sc4BVKUjO3Jvm3/V7m7PAbwAcl7SBpL+CtwFlVx3gd8It0fsA6yIF/eP0U2Jkk2Fdcld6XTeN8NTCLpEf7feCUiPhxnidIx7PfQTLpupIkgN/ZZLeTJD1AMoTzDWAJ8IJKxkdEfB/4GMmE7f3ADcDLqo5xHslZwrmZtqwDXkGSubScZFz5KyRnPtXtvplkMvYz6XavAF6RToxXnAtcDtya/nykyeuq59Mkk6yXp6/7VyRnKnl8J/19n6TftPn89byAJM3yYGC1Hs+3fxFs+Ld9O8kXwN0k4/f/mtn/FOCPJMNgPwXOSCeks16PJ3W7Qh5aM2uNpNuAt0TE/+t2W8za4R6/mdmQceA3MxsyHuoxMxsy7vGbmQ0ZB34zsyFTRDXF0u20004xa9asbjfDzKyvLFmy5N6ImFZ9f18E/lmzZrF48eJuN8PMrK9Iur3W/R7qMTMbMg78ZmZDxoHfzGzIOPCbmQ2ZvpjcNTPrBQuXjnPGZTezYvUE06eOceIhezJvzozmO/YYB34zsxwWLh3n/d+7nom1yRo746sneP/3rgfou+DvwG9mlsMZl928IehXTKxdxxmX3dw08PfamYIDv5lZDitWVy8p3fj+il48U3DgNzPLYfrUMcZrBPnpU8c2/F2rZz+ZM4WyOKvHzCyHEw/Zk7HRkY3uGxsd4cRD9gQe79mPr54gSHr2x5+/rOaXBTQ/UyiTe/xmZjlUeuf1xupr9ewbyZ4pdJoDv5lZTvPmzNhkeKYyvFOvZ19L9kyhGxz4zcxqyJOJ88GF13POr/5E3uWsBD2R1dMXK3DNnTs3XJ3TzIpWL7hXZ+JAErQDmJFuB3DC+ctyB/0ZU8e4ev6Bhb+GRiQtiYi51fe7x29mQ6lRmuVpl9y4yXh9JcBXtttydEruoD86oq4O7VRz4DezoXTqxZsG94m16zj14htZPbG24b4Ta9e1NJG79eab9dTVvaUGfkknAG8h+bK8HngjsBVwPjALuA04KiJWldkOM7OshUvH6wb3ZkG/HWvaOGaZV/uWFvglzQDeBTw9IiYkXQC8Cng6cEVELJA0H5gPvK+sdpiZVTvjspsnfYypY6M88tj6XD3/vKmb2QyhypwCFH+1b9kXcG0GjEnajKSnvwI4HDg7ffxsYF7JbTAz20iji6d22Gq06f5joyOcetjenH7EM5kxdQyl+9UKqFNErvH97AVgwCbzB5WrfYtQWo8/IsYlfRz4EzABXB4Rl0vaJSJWptuslLRzrf0lHQccBzBz5syymmlmQ6he+YWtNx+hVqLj6IjYevPNWDOxlu3HRpHg+POXMUWwPt1+9cNra072rs85A5znArCirvYtrccvaQeS3v3uwHRga0nH5N0/Is6MiLkRMXfatE0WiTcza1ut8gujI+LRx9ZvMsa/w1ajnHHkviw75WA+efRsHnlsPaseTrbJBvVG8T1PTz1PUC/qat8yh3peDCyPiHsiYi3wPeAFwF2SdgVIf99dYhvMzDYxb86MjYZpZkwdY+vNN2Ntje75VpmMnFbLMlQUEdSLvNq3zKyePwF/J2krkqGeg4DFwEPAscCC9PdFJbbBzNrUazXkq022fdXlF3aff2nN7bJBu92hlulTx5q298RD9mx60VjPZ/VExDWSLgR+AzwGLAXOBLYBLpD0ZpIvh38uqw1m1p4ia8iX8QXSTvuatSNP2eV62zQyNjrCAXtNa9reZkXgiuSSDWa2SVB86JHHauazt1p2oFbpg7HREU4/4pmTCmj7LVhUMwDXa1+eduQt01C9TS0jEusiNuzXqIhb0b35rHolG1yP32zI1aojX+8iplaHOhotQjIZ9doxvnqC3edfyn4LFrFw6XhL7ciO+wN18+hPP+KZTVM+10VsGJOfN2dGw/etcuxse8vmwG825FqZsGw1q6Td5Qon047Kl1c2mDb6othvwaINXxYAV88/kBlTx+rm0c+bM4OlJx/Mp46evWFyeETa5NjZL5Zm71uROfp5OPCbDbm8QbidrJJ6AW+yaYm10jGr5Qm8go3OdCpfFnm+sObNmcHV8w9k+YJDWV9nyLyyfZ72dnJFLgd+syFXLyjusNXoRumO7YzLN1uusF3V6Zj1NAq82aGcisqXRatfWM3urx5GqrftwqXjG52BlDX84+qcZkOuVhrh2OgIp7xi70lPOJaZqZJNx6w32ZsNvNXtaLQW7iePnl3zPan3hVXvPcxuX2lvvYnmPJk/RXHgNxtyZacR1lqusGitBN6KRl8Wrb4nrWxfb9tGE9BFv39O5zSzgdDq9QJlpZq2a/f5l9Ys+yBg+YJD2zqmV+Ays4HW6plFJy+YyiPPBWRFceA36wOTufq1yCtne72MQy2N2tyJYai88gxXFcWB36zHTaZ8QtGlFxodqxe/FIp8/WXr5BmIA79Zj5vMpF+RE4bNrn7txQDbyQnTInTqDMSB36zHTebq1yKvnG10rHYCbCfOEBqlbObVi2cyk+XAb9bjJjPpN9kJw2zQm5IWHqt1rFa/YGoNwZxw/jKOP39ZYUXLFi4dr3mRVqXNeY/Ri2cyk+Urd8163GSufp3MvtXF22oF/cqx6gXSKVLuomnVBdEme9XqGZfdXDc9Mu+EaVlF5rrNPX6zHpd30q/RkEQ7QxX1ireNSKyP2ORYtcoVV74sqnvKzYZaihiHr/ccQf7eellF5rrNgd+sDzSb9Ks1JHHihddx6sU3smZiLdOnjvHJo2e3FEjrBbf1EZtcUFT9BVNrWCgbzPMsaFJEBc96Nfsne4wycus7yUM9ZgOgVu987bpg9cTammWK82i1IFnR1SrrPU/eQmZFFIgrq8hct7nHbzYA8vSO8wyfZIeLth8bZXRErF33eBDPG/Sa9ZSzZwjjqyc2mYSt9zytTLYWkRffa1f3FqVu4Je0Y47910fE6uKaY1aMbqfgdfr5864F2+gLojqorp5Yy+gUscNWo6x+eG1Lr+OAvaZxzq/+1DCYZ4ev8r5fraaNFpEX30tX9xalUY9/RfrTqNz1CDCz0BaZTVK3U/C68fy1LvevpdHYdM3hovXBqofX5k6xXLh0nFMvvnGTpRsFvPLZ9QNo3uA6qJOtndYo8N8UEXMa7SxpacHtMZu0bl+t2Y3nrxy3VtCtaDZMk2dd2OxzVVR667WGbCoC+Mnv72n4GvIY1MnWTms0ufv8HPvn2caso7rdK+zW88+bM4Ott6jdlxuRmpYbbmdd2GyuP9QO+hVFvP5BnWzttLqBPyL+CiDpbyVtkf69v6R3SZqa3casl7S7zmtRy96Vtc5sHo1SMJudbbSzLmyZC7VXq5xZTKxdt2Fx83aXhBx2edI5vwusk/QU4KvA7sC5pbbKbBLa6RVWX6U6matHu9krncyXTt51YbPKXKg9q/rMYl3EhmM66LcuTzrn+oh4TNI/AZ+KiM94bN96WbMUvFoZJEWOy7eSAlh09k+ebJpmbW+0LuyJh+yZq35P1g5bjU56/d5uz9sMmjyBf62kVwPHAq9I7xstr0lmk1cvS6Rexk294Yp2x6XzZKkUnf2zcOk4310yvlHQb5ZNU0+9Ly/YuDRDraBfmeAtqtgatD5v0u103l6XJ/C/EXg78NGIWC5pd+Bb5TbLrBz1eo4jDSpP5tEs0JR9llHvtQVw3jV3MHe3HXN9EVW38er5B260zX4LFjUc0y8y2Ge1ks3T7XTeftAw8EsaAT4QEcdU7ouI5cCCshtmVoZ6PcTKmHE7y97lWZmqiLOMbNpk5YsqG2gbvbZmgS9vsGx0kdiMqWObfFEUpZVlCT0s1FzDyd2IWAdMk7R5h9pjVqp6PfhKdsiMqWOI1rJFmpXubXSWkbeNtSY3YeNJ6EZnJ81KCecpP9xsorvMdNXsxHOzf59up/P2gzxDPbcBV0u6GHiocmdEfKKsRpmVpVHPsd1L8+sFlPHVE+y3YFHdXnKes4xsL7+eSoBudvVudTuzQzv1pmcr+1S+eBopO10177+PL/JqLk865wrgB+m222Z+zPpO3p5jKzn9jQJK5WrWWpqdZVT38htZsXpiw2vLcyZRnb5aT2WfZvn6rSxuUjZf5NVc0x5/RJzWiYaYdUo7te0bjZE362kH1K0+2Sj76D0XXNc0VbKiuupldXtEkupZkefCq2ywbDRMIuC1fzezZ8bPB7WiZpGaBn5J04CTgL2BLSv3R0Q5szhmXdbK5GD11aT1AnUlvTFPIKp88eQN+rWqXi6+/S8b5fMH8N0l4xuye5oF8uo21hs+GZH476P27bmgOogVNYuUZ4z/HOB84OUkaZ3HApOvtmTWo/JODlafGayLqFukrJWMlzy98VpZPVk/+f09m7QjzwpY9dpZb27k9COeCSRpnu5d9488gf8JEfFVSf8eET8Ffirpp2U3zKxbGk0ONrtqtdGwTl6NeuOVYNsssDb78molPRLyX9DlnPn+kOvK3fT3SkmHkkz2PrG8Jpl1V72geMBe05petQqtDevU0mhYJW+Kab1jbD+WXHTfzjh4reGTWhd0OWe+9+UJ/B+RtD3wHuAzwHbACaW2yqyL6gXFvJUo27mQKXsmMXWrUUaniLXrN17ysJUqlCcesicnfue6jY4B8NCjj7Fw6fiGID7Z4Oyc+f6UJ6vnB+mfa4AD8h5Y0p4kcwMVTwZOBr6R3j+L5BqBoyJiVd7jmnVCraB4/PnLmu7XTtpg9VzBqofXMjoipo6NsmaitSUPs+0/7ZIbWfXwxouyrF0XhfbGnTPfn/Jk9TwV+AKwS0Q8Q9I+wGER8ZFG+0XEzcDs9BgjwDjwfWA+cEVELJA0P739vkm9CrMOaJS1UysTJq+aSx6uC7beYjOWnXJwu81ldVXQryiyN97qXMFkuPBacfIM9XwZOBH4EkBE/FbSuUDDwF/lIOCPEXG7pMOB/dP7zwauxIHf+kCj9MrlCw5t+7hlDZd0ojfeqZx5F14rVp7Av1VEXKuNrwZ8rMXneRVwXvr3LhGxEiAiVkraudYOko4DjgOYOdPruVv3zWiQAjkZZQXoTvXGO5Ez78JrxcpTsuFeSX9LmqEm6UhgZd4nSAu8HQZ8p5WGRcSZETE3IuZOmzat+Q5mJSurFEBZx22lsFmv8yRysfL0+N8BnAnsJWkcWA68toXneBnwm4i4K719l6Rd097+rsDdLbXYrEvKGtYoc7hkUK5g9SRysRRNLguXNBIR6yRtDUyJiAdaegLp28BlEfH19PYZwH2Zyd0dI+KkRseYO3duLF68uJWnNbMBUm8pyH49g+kUSUsiYm71/XmGev6QBuuZbQT9rYCXAN/L3L0AeImkW9LHvKiLmTU0SMNWvSBPj39bksnZN5J8UXwN+HZE3F9+8xLu8ZuZta7tHn9EPBARX46IF5BU6TyFpHzD2ZKeUkJbzcysRE0Dv6QRSYdJ+j7waeC/Sa7CvQT4YcntMzOzguXJ6rkF+AlwRkT8InP/hZL+vpxmmZlZWfIE/n0i4sFaD0TEuwpuj5mZlSxPkbaaQd+sXa65YtZdeXr8ZoVxzRWz7nPgt47q9ZorPhuxYZCnLPMWwCtJ6udv2D4iPlRes2xQ9XLNFZ+N2LDIc+XuRcDhJBU5H8r8mLWsXm2VXqi50uhsxGyQ5BnqeWJEvLT0lthQ6OTCHa3q5bMRsyLl6fH/QtIzS2+JDYVerrnSy2cjZkXK0+N/IfAGScuBR0hWmYuI2KfUltnA6tVSwb18NmJWpDyB/2Wlt8KGSjcyZ/I8Zzt18Z0FZP2obuCXtF1agbOlUsxmjXQjc6aV52zlbMRZQNavGo3xn5v+XgIsTn8vydy2AbFw6Tj7LVjE7vMvZb8Fi1i4dLy05+pG5kxZz+ksIOtXdXv8EfHy9PfunWuOdVqne63dyJwp6zmdBWT9qm6PX9LfNNs5zzbW2zrda+1U5kz2LGaKVMpzOgvI+lWjoZ48tfZdj7/PdbrXeuIhezI2OrLRfUVnzlTOYsZXTxDAuhqrzBXxnJ14LWZlaJTVs6+kRssrCujY8otWjulTxxivEeTL6rU2y5wpIkum1lkMwIjE+ojCsm/ayQIy6wWNxvhH6j1mg6OM3PVmwbte5kxR8w31zlbWR7B8waGtvJSmevWaBLNGXJ1zyDXqtbbT+55M8C6qcmenz2LM+o0Dv9XstbYbwCcTvIuab/AVuGaN5anVY0Oo3WyfyQTvorJkerkekFkvyFOP/+PA1yPixg60x3pEuwG8nWGWypDS+OqJpBBU5rF2e+oeezerL0+P//fAmZKukfR2SduX3SjrvnZ7362mOGZTLyEJ+pWse/fUzcrRNPBHxFciYj/g9SSrcP1W0rmSDii7cdY97eaotzrMUmtIKdL9rp5/YEt1czpVdsKs3+Wa3JU0AuyV/twLXAe8W9LbIuJVJbbPumQyOeqtDLMUMaHrYmlmrckzxv8J4DDgCuA/I+La9KGPSXI1qgHWiXHyIlIve30Bd7Nek2eM/wZgn4h4WyboVzy3hDZZB/TK0EgRZQ9cLM2sNXkC/ypgtHJD0lRJ8wAiYk1J7bISVdeyqQyNdCP4F5F66WJpZq1R1ChgtdEG0rKImF1139KImFNmw7Lmzp0bixd7CYCi7LdgUc3hlcqEar+pHuOH5KzBGUE27CQtiYi51ffnmdytdVbgK3772KANjbhYmllr8gTwxekE7+dIMu3eSbIKl/WpQaxl4wu2zPLLM8b/TuBR4HzgO8BfgXeU2Sgr12QmVHtlUtjM2te0xx8RDwHzO9AW65B2h0acL282GPLk8T8VeC/JVbsbto+I/psFtA3aGRpxvrzZYMgzxv8d4IvAV4BNlzWyoTFok8JmwypP4H8sIr7QzsElTSX5wngGycTwm4CbSeYLZgG3AUdFxKp2jm+d1WhSuIglE82sM/JM7l4i6V8l7Sppx8pPzuN/GvhRROwF7AvcRDJfcEVE7EFSBsLzB32i3qTwAXtN65kLwsysuTwXcC2vcXdExJOb7LcdSTG3J0fmSdL6PvtHxEpJuwJXRkTDdBJfwNU7avXsK7X0q+W9IGzQzxYG/fVZ72r7Aq6I2L3N53wycA/wdUn7kuT+/zuwS0SsTI+9UtLOdRp8HHAcwMyZM9tswnAoMrC0s1D6Cecvq3msPGP/g54pNOivz/pTrqUXJT1D0lGSXl/5ybHbZsCzgC+k5R1aSguNiDMjYm5EzJ02bVre3YZOkXV32j3WZGrltLvEY78Y9Ndn/alp4Jd0CvCZ9OcA4L9IyjQ3cydwZ0Rck96+kOSL4K50iIf0991ttNtSRQaWdo81mQvCBj1TaNBfn/WnPD3+I4GDgD9HxBtJJmm3aLZTRPwZuENS5X//QcDvgIuBY9P7jgUuarXR9rgiA0u7x5pMhc1Br6w56K/P+lOedM6JiFgv6bF0wvZukvH7PN4JnCNpc+BW4I0kXzYXSHoz8Cfgn9tot6WKrLszmWO1WyvnxEP2rFlZs50F1hvp1gRrp16fWSvyFmmbCnyZZIL2QaB6QZaaImIZsMmMMknv3wqQN7DkCXzdCFKdqKzZzQlWVw61XtQ0nXOjjaVZwHYR8dvSWlTDsKZz5u2lNtuulXr1g5h6OGjrD5jl1XY6p6QrIuIggIi4rfo+K0crvdRmwyyt1NgZxPLGnmA121jdyV1JW6ZX6O4kaYfMVbuzgOkda+GQKjJbZ9gDnydYzTbWKKvnbSRj+nulvys/F5EsymIlKjJYD3vgK2JBd7NBUjfwR8Sn06t23xsRT46I3dOffSPisx1s41AqMlgPe+ArYkF3s0GSJ6tnvaSpEbEaQNIOwKsj4vOltmzIFZlh48ySwZy7MGtXniJtyyJidtV9S9MyDB0xbFk9lcya8dUTjEisi2BGHwbrQcwQstb5c9A9bWf1AFMkqVJhU9IIsHnRDbREdTbPuogNPf1++s/i4mQG/hz0qjwlGy4judL2IEkHAucBPyq3WcNrUIp6DcrrsMnx56A35enxv48kw+dfAAGXk6yqZSUYlNTLQXkdNjn+HPSmPPX410s6C1gUEf6aLlmRtXcaKXvctVOvw3qbPwe9KU9Z5sOAZaTDO5JmS7q45HYNrU6kXhZZw7+eYU8htYQ/B70pzxj/KcBzgdWwofDarNJaNOQ6kXPeiXFX584b+HPQq/KM8T8WEWskld4YS5Sdc96pcddBzZ13emJrBvVz0M/y9PhvkPQaYETSHpI+A/yi5HZZiYa9hMNkdGKYzKxseQL/O4G9gUdIUjnvB44vsU1Wsn4fd124dJz9Fixi9/mXst+CRR0Nuk5PtEGQJ6vnYeA/JH0suRkPlN8sK1M/l3Do9gVBTk+0QZCnHv9zgK8B26a31wBvioglJbfNSlRv3LXXx69bWVugDE5PtEGQZ6jnq8C/RsSsiJgFvAP4eqmtsq4oY/y66GGZbve4+32YzAzyBf4HIuKqyo2I+Dng4Z4BVPT4dRlfJN2emHZ6og2CPOmc10r6EsnEbgBHA1dKehZARPymxPZZBxXdmy5jWKYbC8JXc3qi9bs8gX92+vuUqvtfQPJF4NWqB0TR49dlDMv088S0Wa/Ik9VzQCcaYt1XdG+6rIlQ97jNJidPrZ5vSto+c3s3SVeU2yzrhqLHrz0Ratab8gz1/By4RtK7gRnAicB7Sm2V1VV2umWRvWkPy9TX62mzNtiaLr0IIOmFwE+Ae4E5EfHnshuWNWxLL9ZTffESJD1oZ5X0F/87WqfUW3oxz1DP60gu4Ho9cBbwQ0n7Ft5Ca6rT5QK6WRphkLnsg3VbnqGeVwIvjIi7gfMkfR84m8ezfaxDOnnxUqPSCODhm8no9kVoZnmyeuZV3b5W0nNLa5HV1clyAfV6paddciN/Xbvei2dPgss+WLfVHeqRdEHm749VPfyD0lpkdXUyS6Ze73PVw2s9TDFJznaybmvU498j8/dLSBZdr5hWTnOskU5lySxcOs4UiXU5Jv4rPEyR3yBnOzlbqT80CvyN/tfnjwhWqLIvXqqM7dcK+mOjI2yx2RRWT6zd5DEPU7RmEC9C63bJbMuvUeDfStIckuGgsfRvpT/+Xz6gao3tA4xInH7EMwG6XivHelO3S2Zbfo0C/0rgE+nff878XbltA6jekM36iI3+8/p03qo5W6l/1A38rtEznPJknBQ9TOFx4cFQ77MzRWLh0nH/m/aQPPX4bYh0OuOklZr9vqCst9X67ACsi/CC9D3Ggd820umFRvJexVrGoi5WrMpnZ0Ta5DGn/PaWPFfutk3SbSSrda0DHouIuZJ2BM4HZgG3AUdFxKoy22Gt6WTGSd5xYU8c9od5c2ZwwvnLaj7msf7ekadWjyQdI+nk9PbMFq/cPSAiZmcKBc0HroiIPYAr0ts2pPIupeiJw/7R7eUxrbk8Qz2fB54PvDq9/QDwuUk85+EktX5If8+bxLG6zuPOk5N3TsHBpH/4yuTelyfwPy8i3gH8FSAdltk85/EDuFzSEknHpfftEhEr02OtBHautaOk4yQtlrT4nnvuyfl0neVx58nLO6fgYNIZRXRkvCB972taj1/SNSTr6/46Ip4laRpweUTMaXpwaXpErJC0M/Bj4J3AxRExNbPNqojYodFxerUe/34LFtVMX5sxdYyr53sp4qI57bNcXidg8NSrx59ncvd/gO8DO0v6KHAk8ME8TxoRK9Lfd6flnJ8L3CVp14hYKWlX4O68L6LXeNy5swaxzEEv8QT68GhUnXN3gIg4BzgJOJ3kat55EfGdZgeWtLWkbSt/AwcDNwAXA8emmx0LXDSZF9BNHne2QeKOzPBoNMZ/IYCkKyLi9xHxuYj4bETclPPYuwA/l3QdcC1waUT8CFgAvETSLSRVPxdMov1d5XFnGyTuyAyPRkM9UySdAjw1XWh9IxHxiRr7ZB+/FdhkicaIuA84qNWG9qJeKa/bL2Pf/dLOYXXiIXu6AN+QaBT4X0WSarkZsG1HWtOHuj3u3E4p3G4EYJfs7X290pGx8uXJ6nlZRPzfDrWnpl7N6ukFrWYWdStzwxlQZp3XclaPpGMi4lvA0yU9rfrxZkM91hmtTsh1K3PDE4dmvaPR5O7W6e9tSIZ6sj/blNwuy6nVCbluBWBPHJr1jrqBPyK+lP4+rfoHuL9jLbSGWs0s6lYAdgaUWe9otyzzJlk+1h2tXh7frQDsy/jNekfTyd2aO0l3RMSTSmhPTZ7cLVa/plX2a7vNumUyJRtqaf3bwnpGt1NQ2+F0ULPiNMrqeYDaAV5Az8/I9VPvsJ/a2i2uI2NWnEaLrfftRVv91DvsRFsH4YvF6aBmxRnINXfzruPaC8pu66CsGeB0ULPiDGTg70TvsKiVt8puaz99CTbidFCz4gxk4C+7d1hkL7rstg7KEInTQc2K025WT08ru8pgkRONZbd1+tSxmjVy+nGIpB+zkcx60UD2+MvuHRbZiy67rR4iMbNqA9njh3J7h0X3ostsq0vtmlm1gQ38Zer2ghWtpmd6iMTMshz429DNXnQ/XaNgZr3Jgb9N3epF+wpWM5usgZzcHWSDkp5pZt3jHn+fKXpieRDKOZhZa9zjL0FRV/XWUmR65qCUczCz1jjwF6zsYFpk3v+glHMws9Z4qKdgnZh8LWpi2fMFZsPJPf6C9VMwdcVLs+HkHn/B+qk2TjcuRPNkcsLvg3WTA3/Bun1Vby31gkwRF6K1EsB88VnC74N1W1uLrXdavy223ku9ueogA8kXURGF4Fo99n4LFtU8G5oxdYyr5x84qbb0E78P1ilFL7ZuDfRCbZzKl0+tAFPUZHOrE9n9NP9RJr8P1m2e3B1A2ZTSeooIMq0GME8mJ/w+WLc58A+gWj3xakUEmVYDmNcGSPh9sG5z4B9AzXrzRQWZVgOYl09M+H2wbvPk7gCqN3kISZApcrK5lyayzWxjntwdIvVSSsvoVfbCRLaZtcaBfwB5uUUza8SBf0C5J25m9Xhy18xsyJQe+CWNSFoq6Qfp7R0l/VjSLenvHcpug5mZPa4TPf5/B27K3J4PXBERewBXpLfNzKxDSg38kp4IHAp8JXP34cDZ6d9nA/PKbINZLyhzVTazVpU9ufsp4CRg28x9u0TESoCIWClp51o7SjoOOA5g5syZJTfTrDyuxmm9prQev6SXA3dHxJJ29o+IMyNibkTMnTZtWsGtM+scL3FpvabMHv9+wGGS/hHYEthO0reAuyTtmvb2dwXuLrENZl3napzWa0rr8UfE+yPiiRExC3gVsCgijgEuBo5NNzsWuKisNpj1AlfjtF7TjTz+BcBLJN0CvCS9bTawXI3Tek1HrtyNiCuBK9O/7wMO6sTzmvUCl9CwXuOSDWYd4BIa1ktcssHMbMg48JuZDRkHfjOzIePAb2Y2ZBz4zcyGTF+suSvpHuD2Ag+5PbCmC8fIu08R27Xz2E7AvTmet5uK+Lcr+/hlfjbybttsm0H8fPizsem2u0XEpjVvImLofoAzu3GMvPsUsV07jwGLu/1v04l/u37+bOTdttk2g/j58Gcj/7bDOtRzSZeOkXefIrZr97FeV3bbe/2zkXfbZtsM4ufDn42c2/bFUI91hqTFETG32+2w3uTPx+AY1h6/1XZmtxtgPc2fjwHhHr+Z2ZBxj9/MbMg48JuZDRkHfjOzIePAb3VJepqkL0q6UNK/dLs91lskbS1pSbq+tvURB/4hI+lrku6WdEPV/S+VdLOkP0iaDxARN0XE24GjAKfxDbhWPhup9wEXdLaVVgQH/uFzFvDS7B2SRoDPAS8Dng68WtLT08cOA34OXNHZZloXnEXOz4akFwO/A+7qdCNt8rwC15CJiJ9JmlV193OBP0TErQCSvg0cDvwuIi4GLpZ0KXBuRxtrHdXiZ2MbYGuSL4MJST+MiPWdbK+1z4HfAGYAd2Ru3wk8T9L+wBHAFsAPO98s6wE1PxsR8W8Akt4A3Oug318c+A1ANe6LiLgSuLKzTbEeU/OzseGPiLM61xQrisf4DZJe3JMyt58IrOhSW6y3+LMxgBz4DeDXwB6Sdpe0OfAq4OIut8l6gz8bA8iBf8hIOg/4JbCnpDslvTkiHgP+DbgMuAm4ICJu7GY7rfP82RgeLtJmZjZk3OM3MxsyDvxmZkPGgd/MbMg48JuZDRkHfjOzIePAb2Y2ZBz4rXCSdpF0rqRb03rtv5T0T+lj+0taI2lpWur3Z9l67pJOlTQuaZmkG9LqoGW3d1TSAkm3pM95raSXtXmst0t6ffr3GyRNb3H/syQtl/T26uPl3H9/ST+occwj079fnr7310n6naS3pfdn3/dbJH2vUqE1ffwcSX+pHMf6m2v1WKEkCVgInB0Rr0nv2w3IBvCrIuLl6WOzgYWSJiKiUvr5kxHxcUlPA66StHNRRcDS9qnqeB8GdgWeERGPSNoF+Id2jh8RX8zcfANwA62XODgxIi6scbxJkTQKnAk8NyLulLQFMCuzyScj4uPptkcDiyQ9MyLuiYjXSjqrqLZYd7nHb0U7EHg0G7Ai4vaI+EytjSNiGfAhkqtDqx+7CXgM2Cl7f9o7/aakRWnv9K2Zx06U9GtJv5V0WnrfLEk3Sfo88BsytWckbQW8FXhnRDySPu9dEXFB+vgXJC2WdGPleOn9t0n6WHp2cK2kp2Ta9t60ZzwXOCftRY9JOjlt2w2Szky/hBqqHC/9+8rMc/6vpBc127/KtiSdvfvS1/lIRNxca8OIOB+4HHhNi89hfcCB34q2N0lwbcVvgL2q75T0PGA9cE+NffYBDgWeD5wsabqkg4E9SGrIzwaeLenv0+33BL4REXMi4vbMcZ4C/Cki7q/Ttv+IiLnp8/2DpH0yj90fEc8FPgt8KrtT2mNfDLw2ImZHxATw2Yh4TkQ8AxgD2lmycLP0OY8HTmllx4j4C0mdndslnSfptZIaxYCa/y7W/xz4rVSSPpeOJ/+60WZVt0+QtAz4OHB01K4rclFETETEvcBPSIL9wenPUh4PWnuk298eEb9q4yUcJek36TH3Jll4pOK8zO/n5zjWAZKukXQ9yZnR3m2053vp7yVsPExTUa8GSwBExFuAg4BrgfcCX2vwXE3PSKw/eYzfinYj8MrKjYh4h6SdSHq/9cwhKQBWsWGsuYHqABckger0iPhS9gElq0o9VOc4fwBmSto2Ih6o2m93kuD4nIhYlY5xb1mnDQ2LXknaEvg8MDci7pB0atWx8nok/b2O2v9/7wN2qLpvR+DeDQ2NuB64XtI3geUkcxG1zKHxv5v1Kff4rWiLgC0l/Uvmvq3qbZwOnfwfknVdW3G4pC0lPQHYn6R88GXAmyRtkx57hqSdGx0kIh4Gvgr8j5Kyw0jaVdIxwHYkXxhr0gnf6kyfozO/f1nj8A+QjKvD40H+3rR9ZWXH3AJMTyfGKxPr+wLLJG2jZFW1itnA7dUHSPd7JcnZ03m1Hrf+5h6/FSoiQtI84JOSTiIZn38IeF9msxdJWkryhXA38K5MRk9e1wKXAjOBD0fECmBFGvB+mc6bPggcQ9I7buSDwEeA30n6a9rekyPiurSdNwK3AldX7beFpGtIOlCvrnHcs4AvSpogGQr6MnA9cBvJF1Xh0qykY4Cvp2cZa4G3RMQaSdsCJ0n6EjBB8jrfkNn9hHTfrUmykQ6MiFrzK9bnXJbZ+k46TPJgjuGgMttwG8mwzb3Ntm3xuGcBP6ikc/aSXm6btcZDPWa9ZQ3wYaUXcPUKSeeQXNvw1263xSbPPX4zsyHjHr+Z2ZBx4DczGzIO/GZmQ8aB38xsyDjwm5kNGQd+M7Mh8/8Bg9Udv2zVHCwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "life_exp = df.life_exp\n",
    "gdp_cap = df.gdp_cap\n",
    "\n",
    "# Basic scatter plot, log scale\n",
    "plt.scatter(gdp_cap, life_exp)\n",
    "plt.xscale('log') \n",
    "\n",
    "# Strings\n",
    "xlab = 'GDP per Capita [in USD]'\n",
    "ylab = 'Life Expectancy [in years]'\n",
    "title = 'World Development in 2007'\n",
    "\n",
    "# Add axis labels\n",
    "plt.title(title)\n",
    "plt.xlabel(xlab)\n",
    "plt.ylabel(ylab)\n",
    "\n",
    "\n",
    "# Add title\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAvjElEQVR4nO3deZhcZZ328e+dpoFmDWhgSDQEFUFxAW11FJ1hGWUUhIw64oLiio6+OuoMGJcRcBni4LiMO26AIouoAcRX9E1cEBdMDAiRQdSA0kRATFgDZvm9f5xTyUnlVNWp6nNqvT/X1VdXnfWpruT5nWdXRGBmZtbMjF4nwMzM+p+DhZmZteRgYWZmLTlYmJlZSw4WZmbWkoOFmZm15GBhpZJ0iqSvNNl/o6R/6GaaimiV7kElaYWkQ3qdDht8DhYjRtI7JH27btsNDba9qMtpO1PSXyXdnf5cK+k0Sbt2Mx2DokiAi4gDIuIHHVx7D0nnSrpF0p2SrpD0lLpjXiLpJkn3SlokaffMvu0kfVHSXZL+JOltmX3PkHRP3U9Ien676bTucbAYPT8CDpY0BiDpb4Bx4Al12x6RHluYpG1KSN9/RcTOwCzglcDfAldI2rGEa1txOwG/AJ4I7A6cBVwqaScASQcAnwVeBuwJ3Ad8KnP+KcC+wN7AocBJkv4RICIuj4idaj/AUcA9wHe68LmsQw4Wo+cXJMHhwPT93wHfB66v2/a7iLhF0mxJF0v6i6TfSnpt7ULpk+2Fkr4i6S7gFfU3k/Sy9OnzDknvKprIiLg/In4BHA08iCRw1K75KknXSVot6TJJe6fbPyPpQ3X3v6j2VJt+lq9Lul3SSklvbnR/SUenVThrJP1A0qMy+25MS2i/TtPwJUnbp/sOkXSzpJMk3SZplaT5kp4j6Tfp3/GdmWvNkLRA0u/Sv9EFtSd0SfPSJ+7jJf1B0p9rf8M0430ncGz6ZH51g8+xqdov/b4ukHR2WnJbIWmywd//9xHx4YhYFREbIuIMYFtgv/SQlwKXRMSPIuIe4D+A50naOd3/cuB9EbE6Iq4DPkfOv4/U8cCFEXFvo+/Des/BYsRExF+Bn5MEBNLflwM/rttWK1WcC9wMzAZeAPynpMMzlzwGuBCYCZyTvZekRwOfJnn6nE2S6T+kzfTeDXwPeEZ6zfkkmeTzSEofl6dpBPgqSeap9NjdgGcB50maAVwCXA3MAQ4H3iLpiPp7Snpkes23pPf4NnCJpG0zh70UOAJ4OPBI4N2ZfX8DbJ/e5z0kGeVxJE/pzwDeI+lh6bFvBuYDf5/+jVYDn6xL0tNJMunD03MfFRHfAf4TOD99Qn9847/iFo4GziP5vi4GPlHkJEkHkgSL36abDiD5WwIQEb8D/go8Mv27z87uT18fkHPdHUj+XZ1VMP3WIw4Wo+mHbA4MzyDJcC+v2/ZDSQ8lyajenj7pXwV8niTzr/lpRCyKiI0RsbbuPi8AvpU+fT5A8vS5sYP03kJSFQLwOuC0iLguItaTZJgHpqWLy4FI01+7/08j4hbgScCsiHhvRPw1In5PkonntcscC1waEd+LiHXAh4AJ4GmZYz4REX+MiL8AHwBenNm3DvhAeu55wIOBj0XE3RGxAlgBPC7zed4VETenf6NTgBfUVemdGhFrI+Jqkky3aGDI8+OI+HZEbAC+XORaknZJjz01Iu5MN+8E3Fl36J3Azuk+6vbX9tV7PvBnkn+T1sccLEbTj4Cnp0+AsyLiBuAnwNPSbY9Jj5kN/CV9uq+5ieSJueaPTe4zO7s/rWa4o4P0zgH+kr7eG/hYWj20Jt0uYE4ks2Kex+aM+yVsLu3sDcyunZee+06S+va8dN+USffG9HM0+tw3pefU3JFmxgC1AHprZv9aNmeoewPfzKTpOmBDXbr+lHl9X+bcTtRfa/tmbU2SJkhKZD+LiNMyu+4Bdqk7fBfg7nQfdftr++odD5wdntG07zlYjKafArsCJwBXAETEXSRP8CcAt0TEyvT97pl6aIC5wFTmfbP/5KuAh9bepFUOD2onoWmD6j+QlBogyaRfFxEzMz8TEfGTdP+5JE/mewNPAb6eOW9l3Xk7R8Rzcm57C0kmXkuD0s+R/dwPzbyem57TiT8Cz65L1/YRMdXyzOZ/+2mTtB2wiORzv65u9woypZK0Wm074DcRsZrku8+WWh6fnpO9/kOBQ4CzS066VcDBYgSl1UVLgbexOROGpN3ibaTtFRHxR5ISx2mStpf0OODV1LVNNHEhcJSkp6f1/e+l4L85JV0vn0iSWa0GvpTu+gzwjrQ3DpJ2lfTPmc+2HLidpLrssohYk+66ErhL0tslTUgak/QYSU/Kuf0FwJGSDpc0Dvwb8ED6t6h5o6SHpI3R7wTOL/K5cnwG+ECmkX6WpGMKnnsrMC9tjylV+rkvJCkFvTwtXWWdAzxXSTfYHUm+229kSqFnA++WtJuk/YHXAmfWXeNlwE/S9g7rcw4Wo+uHwB4kAaLm8nRbtsvsi4F5JE/O3wROjojvFblBWj//RpKG51Ukmf7NLU47SdLdJNVLZwPLgKfVespExDeBD5I0Wt8FXAs8u+4a55KURr6aScsG4LkkPb5WktSTf56khFWf7utJGqQ/nh73XOC5aeeAmq8C3wV+n/68v8XnauRjJA3N300/989ISkRFfC39fYekX3Z4/0aeRtKl9VnAGm0eD/EM2PTdvp4kaNxG0h7xhsz5JwO/I6mi+yFwetoon/Vy3LA9MOSqQrP2SLoReE1E/L9ep8WsW1yyMDOzlhwszMysJVdDmZlZSy5ZmJlZS2VM/Fa5Bz/4wTFv3rxeJ8PMbKAsW7bszxExq4xrDUSwmDdvHkuXLu11MszMBoqkm1ofVYyroczMrCUHCzMza8nBwszMWnKwMDOzlhwszMyspYHoDWVm1q5Fy6c4/bLruWXNWmbPnODEI/Zj/kFzWp9ouRwszGzoLFo+xTu+cQ1r1yVrUE2tWcs7vnENgANGhxwszGzonH7Z9ZsCRc3adRs4/bLrGwYLl0Sac7Aws6Fzy5r65eCbb3dJpDUHCzMbOrNnTjCVExhmz5wANpciptasZUxiQ86Eqq1KIqPGvaHMbOiceMR+TIyPbbFtYnyME4/Yb1MpohZM8gJFTaOSyChyycLMhk6tNJDXBnHwwiVbtWc0UiuJmIOFmQ2p+QfN2aoKadHyqdzqqTy1koglHCzMbOAV6cn07kXXcM7P/lDoenPcG2orA7FS3uTkZHiKcrPR1igg1PdkAhAQbM70Ad56/lW0yu0mxsc47XmPHZogIWlZREyWcS2XLMys7zXr2po3pqIWFGrHbT8+o2WgEPD8J25ddWUJBwsz63vNBtm1aoNYu25DoQbtAL7/v7cXTtOoDeKrNFhIeivwGpLv4RrglcAOwPnAPOBG4IURsbrKdJjZYGsUEJqNk+hEka6yi5ZPceolK1h937ot0jHsg/gqG2chaQ7wZmAyIh4DjAEvAhYAiyNiX2Bx+t7MrKExqeH2IoFi5sT4VuMu8rTqKlurDssGippaSWdYVT0obxtgQtI2JCWKW4BjgLPS/WcB8ytOg5kNuEYBYUMEc1pk8BPjY5xy9AGc9rzHtjz20P1nNd2fVx2WNcyD+CqrhoqIKUkfAv4ArAW+GxHflbRnRKxKj1klaY+88yWdAJwAMHfu3KqSaWYDYE6D6TvGJKbWrN3U+6mm9n7mxDgSvOX8qwrdp1WbRatgMMyD+KqshtqNpBSxDzAb2FHScUXPj4gzImIyIiZnzWoe7c1suOVN3wGbSxxBEiAgCSwfOfZAPnrsgTywfmNulVEj0wkGwz6Ir8oG7n8AVkbE7QCSvgE8DbhV0l5pqWIv4LYK02BmQ6B++o4ZOW0VtXEVVyw4DKCtaT1qZs+caNrL6cQj9ttqTAckJZhTjj5gaBu3odpg8QfgbyXtQFINdTiwFLgXOB5YmP6+qMI0mI2kfu3WOZ10Zafv2GfBpbnHZEsG7bYfjI+JQ/ef1XSq8mZzTg27Ktssfi7pQuCXwHpgOXAGsBNwgaRXkwSUf64qDWajqKy1GcoOOO2mq9n9W01B3uyYPLvtMM7Jzz2g0KJJeXNOjQJP92E2BLIZa14VDWxZRVPkevXVLdOdCuPghUtyM++8dLW6f9EpPvKqjOrvnQ1C+yy4tOFI70GcL6rM6T68noXZgMuuzxA07mbaTrVMsyfsTjW6/9SatRy8cAmLlk8Vvv/8g+Zs0RU22xsqW2Jp1V22dmzt3s0asOuPHTUOFmYDrlXf/5p2unW2uyxpEe1kxK0Cyz4LLuX0y67nxCP2Y87Mia1KA9mqoysWHMaNC4/kxoVH5gaObBBq1Osq79hR42BhNuCKZODtdutslLFPZxxBOxlxo/sINpWgagGmUbtE3t+lVRCsL7HkyQas+hLRMHOwMBtwjTLWMQmR1LW329bQbFnSThXJiGuZdt796wfeQRJgGk0Fkvd3KRIEa6WRRunMC1ijEDAcLMwGXKOM/b9f+HhWLjySKxYc1najbDZj7zTgNLpus4y4lmnn3b9Rw/OGiMKBrZ0g2E7AGoWqKU9Rbjbgqur7X2UX0bzBbfWZdv39m/WmOvGI/Qp9/nb+VnnHtlPlNWzcddbMeqLdcRxVdOdtVzvdf/uBV8ozs4HXqOTSKIj0w+jpIiWiYeVgYdZFnY6KLms0db9OA1LTapR3r0dP90PA6hVXQ5l1SafVKGVVvzS7DvRHBjho1Tz9ziO4zQZQp6OiyxpN3eg6p16yYosR4L3sDlrFYEArh6uhzLqk04ywrAy00fHNlghtd4K/6dp1Ypw1a7dOT9HBgP1ezTbIHCzMuqTITKllnlefcc7cYXzaCwHltSm89fyreMv5V017or1Fy6e496/rt9o+PkOFGpDLmm3X8rkayqxLOh0V3cl59ZMLTq1Zyz33r2d8bMvRzhPjY8ycGM+9xgxpqykt8qqy6ifw67T66vTLrmfdhq3bUHfafptCmX0Vkx/aZi5ZmHVJkZ40zapR2qleycs4120MZk6Ms+N222xxHcifyrs2e232Cb1V1Vez6qtWGl17TcHSkNs7quVgYdZFzbp+5lWjnHjh1Zxy8QruXLuO2ena0kUy4kYZ5J1r13HVyc/K3ddsPYxaECiyoFCnmXOn1W1lnW/NuRrKrE/klgY2BGvWrivcS2nR8ikOXrik4TxKjTLO2pxNKxceycYm62G0mjm20T1q6Wo2U+t0Jy+sYvJD28zBwqxPFHkib1YHn22nyFM042w2M2veokOt7pHXfpIX9KY7eWFVkx9aomE1lKTdC5y/MSLWlJccs+Z60TWyW/csumZ0o6DSbBGkoj2VFi2f4r6cHknZIJCtSivytymyrnXNdEdo93qE9zBr1mZxS/qTP1l8YgyYW2qKzBroRdfIbt4zb96hPI2e/KfbkPvuRddwzs/+sFUV1syJcU45+oCGM7O2+ju44Xk4NAsW10XEQc1OlrS85PSYNdTOE+og3rN2vVMuXpE7MA2aVyU1K5k0CnK1kkGzEs2O2xXrutqIG56HQ7M2i6cWOL/IMWalaPcJtUijatn3nK75B81hx+3yn+HGpKZ18O2uH92qjaNmup/VDc/DoWGwiIj7ASQ9XNJ26etDJL1Z0szsMWbd0M660EUbVcu8Z1kaZc4bI5o+4bezbCk0b+PIms5nrZVcssufuuF5MBXpDfV1YIOkRwBfAPYBvlppqsxytPOEWtZo3l48FU8nQLVatnTmDuObSltFGtMFHX/W+pJLbflTz9c0mIoMytsYEesl/RPw0Yj4uNsqrBeajWSu75VT1vKXRUdPl9lj6tD9Z23V0NxugMprLB8fE/fcv77w/FACXvq3czv+HO2093gCwP5XJFisk/Ri4Hjguem2/MlkzCqW1/smr8eSIHdgWidVKq16/JTZY2rR8im+vmxqq7Sr4TC7xmmGLYPcvQ+sb9hwvvk+yd9tupMCQvH2Hk8AOBiKBItXAq8HPhARKyXtA3yl2mSZFddocrv6gNHO03mzJ936ffc+sL60HlON2hHuW7exZQaal+bsgkH7LLi06b3LCBBZRXtB9aKXm7WvabCQNAa8MyKOq22LiJXAwqoTZlZUoyfY2hNyJ0uYNnrSBbba1266Fi2f4tRLVmyqDsqOY2hWTdZqjYlWT+etBv2VvRJd0fWqPQ5jMDQNFhGxQdIsSdtGxF+7lSizdjTKBDtdirNV43iRHkS1dNVbtHyKEy+8eoupuNesXceJX7t60zmdBKAiT+eH7j+Lr/zsD7nn13oqlaloe4/HYQyGItVQNwJXSLoYuLe2MSI+XFWizNpR5Am2nQbURhlykd5Dre7f6BrrNganX3Z9y1Hc2Qw0+5katWjUPkutLaSR+llmy1JkhHfREoj1VpFgUZv2Ywawc7XJMWtfqyfYdhtQi87RlLXbDuPssO02he7fyC1r1jYdxZ3NQItesxZcWo2paDY2o2qdrNdh3dcyWETEqd1IiNl0NHuCbbcBtegcTTUT42Oc/Nz8uZMATr1kRVuD32qfZdHyqS2Cxvbjm4dFFRlQlw0uzer/++Ep3hMA9r+WwULSLOAk4ABg+9r2iCi3NcysIu00oNaPOG5WPSNo+RS8aPlUoXENjdaZfmD9xk2vV9+3rtCKdXnpalRaajWFiFlNkWqoc4DzgaNIutAeD9xeZaLMylS0AbW+amdDRMPxGkUbz4uMGG80q2uzElG7jfqN2gWe/8Q5nH7Z9bz1/Ktc/WNNFQkWD4qIL0j614j4IfBDST+sOmFmZWnWgJptJM5bTnS64zWalQA+2mKJ1GYloo8ce2BbjcJ57QKH7j+Lry+b8mA4K6TQCO709ypJR5I0dj+kuiSZlatRAyqwVUkiT6fjNaBxqWbmxHjLa+w6MZ474nrXzLntNArXtwscvHCJB8NZYUWCxfsl7Qr8G/BxYBfgrZWmyqxkeQ2oeZllnnbHa2RLKzN3GGd8hli3cXMgmhgf45SjD2h5nUZDH2rbp9so7MFw1o4ivaG+lb68Ezi06IUl7UfS1lHzMOA9wNnp9nkkYzheGBGri17XrCxFuse221Oovt1j9X3rGB8TMyfGuXPturZKJmsaNIw32t4uD4azdrScolzSIyUtlnRt+v5xkt7d6ryIuD4iDoyIA4EnAvcB3wQWAIsjYl9gcfrerOuajVoWna27kNcovW5DsON227By4ZFcseCwtqqw2tnerm5Mv17GAlTWH4qsZ/E54B2kbRcR8SvgRW3e53DgdxFxE3AMcFa6/SxgfpvXMitFs26x7WbsNWVW7VSdmWcXS+o0ODZT1gJU1h+KtFnsEBFXasunsPVt3udFwLnp6z0jYhVARKyStEfeCZJOAE4AmDt3bpu3M2ttTpPup50qs2qnGyObqxwM59lkh0uRYPFnSQ8n7T0o6QXAqqI3kLQtcDRJ6aSwiDgDOANgcnKymolrbKRVMSdR2dcc5JHNbkAfLkWCxRtJMu39JU0BK4GXtnGPZwO/jIhb0/e3StorLVXsBdzWVorNSlLFk7vnOdrMDejDRdFitklJY+lU5TsCMyLi7rZuIJ0HXBYRX0rfnw7cERELJS0Ado+Ik5pdY3JyMpYuXdrObc2sx/ImO5wYH/P0Il0kaVlETJZxrSIN3L9NM/i5HQSKHYBnAt/IbF4IPFPSDek+L6RkNoSqbkC37ipSstiZpIH6lSTB5YvAeRFxV/XJS7hkYWbWvq6WLCLi7oj4XEQ8jWT22ZNJpv44S9IjykiEmZn1tyKD8sYkHS3pm8DHgP8mGY19CfDtitNnZmZ9oEhvqBuA7wOnR8RPMtsvlPR31STLzMz6SZFg8biIuCdvR0S8ueT0mJlZHyoykWBuoDDLk51xdZTHGJgNmyIlC7NC6vvVezEds+HhYGGl6ce5gFzSMStHy2AhaTvg+STrT2w6PiLeW12ybBD121xALumYlafICO6LSKYVXw/cm/kx20LV6y+0q1lJx8zaU6Qa6iER8Y+Vp8QGXhWzuE5Hv5V0zAZZkZLFTyQ9tvKU2MDrt7mA+q2kYzbIipQsng68QtJK4AGSFScjIh5XacpsIPXT+gv9VtIxG2RFgsWzK0+FDY1u9j5qda9O1pZw7ymzfA2DhaRd0pll25qW3PpTNzLBbvY+Knqvdko67j1l1lizNouvpr+XAUvT38sy721A1DLBqTVrCTZngouWT5V6n272PqriXu49ZdZYw5JFRByV/t6ne8mxKnRrsFw3ex9VcS/3njJrrGHJQtLftDq5yDHWe93KBLvR+2jR8ikOXriERkt2Tede7j1l1lizaqgia1V4PYsB0K1M8MQj9mNifGyLbWX2PspWp+WZ7r2qTr/ZIGvWG+rxkpotnSqga0urWufK7kLaqLG8Ve+j6Tay51Wn1cwpodG+k95TZqOi5Rrc/cBrcE9fWb2h6nsMQRJ4Wg2+6/S8rH0WXJpb/SRg5cIji34Es5FR5hrcnnV2RDTqQtpuEOm0sbyMRvbZMydyq6DcpmBWvSLTfdiQ6qRLbaeN5WU0srtNwax3HCxGWCfjCjptLC+jkb3f5p4yGyVF1rP4EPCliFjRhfRYF3XytN9uY3mtmmtqzdpkUrHMvk5KBf0095TZKCnSZvG/wBmStgG+BJwbEXdWmyzrhk7aANrpMVTfqB2wKWCU0XvJzLqnZbCIiM8Dn5e0H/BK4FeSrgA+FxHfrzqBVp1Ou9QWfbrPq+aqBYorFhxWKI2e2M+sPxRqs5A0Buyf/vwZuBp4m6TzKkybVazqNoDpNmp3a04rM2utSJvFh4GjgcXAf0bElemuD0ryDGsDrso2gOl2de3WnFZm1lqRksW1wOMi4nWZQFHz5ArSZCWqzaW0z4JLOXjhkq4+lU+3q6sn9jPrH0WCxWpgvPZG0kxJ8wHc0N3fel2NM91qLk/sZ9Y/Wk73IemqiDiwbtvyiDioyoRlebqPzhy8cEluNVA7Dcy9VMYUIWajrNvTfeSVPjxNyAAY9GocT+xn1j+KZPpL00buT5L0fHwTyWp51ueGYS4lD8Iz6w9F2izeBPwVOB/4GnA/8MYqE2Xl6LSBuZeN4mbWn4oMyrsXWNCFtFjJOqnGqW8nqDWKZ69nZqOnyDiLRwL/DszLHh8R/d9Cam1X43hsg5nlKdJm8TXgM8DngfxlymxoDHqjuJlVo0iwWB8Rn+7k4pJmkgSZx5A0jr8KuJ6k/WMecCPwwohY3cn1rXyNGsVn7jDOwQuXuFeS2Ygq0sB9iaQ3SNpL0u61n4LX/xjwnYjYH3g8cB1J+8fiiNiXZAoRt4f0kbxG8fExcc/96zsa3OfGcrPhUGRQ3sqczRERD2tx3i4kEw4+LDI3SeeTOiQiVknaC/hBRDTtnuNBed1VP9PrvQ+sZ83adVsd12pw3zAOqvMsuDZIujooLyL26fDaDwNuB74k6fEkYzP+FdgzIlal114laY+8kyWdAJwAMHfu3A6TMFzKyqhaXae+UXyfBZfmXqdVO8awNZa7p5iNsqJTlD9G0gslvbz2U+C0bYAnAJ9OpwZpqwtuRJwREZMRMTlr1qyipw2tsuZ56uQ6nc7RNGyN5Z0sQ2s2LFoGC0knAx9Pfw4F/otkyvJWbgZujoifp+8vJAket6bVT6S/b+sg3SOnrIyqk+t0Orhv2CYCHLbgZ9aOIiWLFwCHA3+KiFeSNFRv1+qkiPgT8Md0hT3Sa/wauBg4Pt12PHBRu4keRWVlVJ1cp9PZY6c7RXm/GbbgZ9aOIl1n10bERknr00br20jaI4p4E3COpG2B35MsyzoDuEDSq4E/AP/cQbpHTtF5nlq1R3Q6X1QnczRVPRFgtxubO12G1mwYFJ1IcCbwOZJG6nuA+kWQckXEVUBeS/zhBdNnqSIZVZEG2G5neFVNBNiLxmbPgmujrGXX2S0OluYBu0TErypLUY5R6Trb6km51f6i61cMQ/fPQV+rw6wbutp1VtLiiDgcICJurN9m5SjypNzqKb1oe8QwTPvtxmaz7mrYwC1p+3Sk9oMl7ZYZvT0PmN21FI6IMno7jVID7Ch9VrN+0Kw31OtI2ij2T3/Xfi4iWQjJSlTGk/Kw9T5qZpQ+q1k/aFgNFREfAz4m6U0R8fEupmkklbGq3Sg1wI7SZzXrB0V6Q22UNDMi1gBI2g14cUR8qtKUjZiyeikNQ3tEUaP0Wc16rUiweG1EbKp2iojVkl4LOFiUpNY7ae26DYxJbIhgzgA8KQ9DryprzN+vZRUJFjMkqTZzrKQxYNtqkzU66ntBbYjYVKLo5/+YnlRvuPn7tXpFpvu4jGTE9eGSDgPOBb5TbbJGx6BOTjeo6bZi/P1avSIli7eT9Iz6F0DAd0lWv7MSDOp4gUFNtxXj79fqFVnPYqOkM4ElEeHHipKV0QuqmarqnatOt/WWv1+rV2SK8qOBq0irniQdKOniitM1MqocL1DWGhh5PM5huPn7tXpF2ixOBp4MrIFNkwPOqyxFI6bT6b+LqLLeucp0W+/5+7V6Rdos1kfEnZIqT8yoqmq8QNX1zsMyzsFdRPMNy/dr5ShSsrhW0kuAMUn7Svo48JOK02Ul8PxJrVVZVWc2TIoEizcBBwAPkHSbvQt4S4VpspIMWr3zouVTHLxwCfssuJSDFy7pSobtLqJmxRTpDXUf8C5JH0zext3VJ8vKMEjzJ/VqEJi7iJoVU2Q9iycBXwR2Tt/fCbwqIpZVnDYrQV69cz/W0Td7wq8ybe4ialZMkWqoLwBviIh5ETEPeCPwpUpTZZUpu46+rKqjXj3hD1pVnVmvFAkWd0fE5bU3EfFjwFVRA6rMOvoyA0+vGuPdRdSsmCJdZ6+U9FmSxu0AjgV+IOkJABHxywrTZyUr8wm+zKqjsqZo74S7iJq1ViRYHJj+Prlu+9NIgsdhZSbIqlVmHX2ZgWeQGuPNRlGR3lCHdiMh1h1lPsGX3TjsJ3yz/lVkbqgvS9o1835vSYurTZZVpcw6ejcOm42OItVQPwZ+LultwBzgRODfKk2VAdV1cS3rCd5VR/3ZDdmsCkoXwGt+kPR04PvAn4GDIuJPVScsa3JyMpYuXdrNW/Zc/SA1SJ7a3VOnf/g7sn4naVlETJZxrSLVUC8jGZT3cuBM4NuSHl/Gza2xbk1D0YspNoaFpwqxUVKkGur5wNMj4jbgXEnfBM5icy8pq0A3Bqk1m2IDRrt6qQhPFWKjpEhvqPl176+U9OTKUmRAd6ahaPRkfOolK7h/3cauz9M0aDxViI2ShtVQki7IvP5g3e5vVZYiA7rT06jRE/Dq+9a5eqUA9wazUdKsZLFv5vUzgbdn3s+qJjlWU3VPo0XLp5ghsaFAB4caV69sadh6g7lnlzXTLFg0y0WK5zDWsaoGqdXaKvICxcT4GNttM4M1a9dttc/VK1sbloGEvZoi3gZHs2Cxg6SDSKqqJtLXSn+cawywvLYKgDGJ0573WICezdNkvdGrKeJtcDQLFquAD6ev/5R5XXtvA6pRddLGiC0yBldJjA737LJWGgYLzwk1vIr04imresX14IOh0b+JGRKLlk/5O7NC61nYkOlWL5521rvw4MDeyvs3AbAhYlqLY9nwcLAYQd1a8KfoCOeyV++z9tX+TYxJW+1zt2mDYiO4OybpRpJV9TYA6yNiUtLuwPnAPOBG4IURsbrKdNjWutGLp2g9uBtX+8P8g+bw1vOvyt3ntgsrMjeUJB0n6T3p+7ltjuA+NCIOzExmtQBYHBH7AovT9zaEii6V6sbV/tGr5W2t/xWphvoU8FTgxen7u4FPTuOex5DMLUX6e/40rtUTrl8vpmjbiDOo/uFR6dZIkWDxlIh4I3A/QFpltG3B6wfwXUnLJJ2QbtszIlal11oF7JF3oqQTJC2VtPT2228veLvquX69uKJtI86gyjPdB5lutWfZ4Gm5noWkn5Ost/2LiHiCpFnAdyPioJYXl2ZHxC2S9gC+B7wJuDgiZmaOWR0RuzW7Tj+tZ3HwwiW5XQznzJzgigVejrxT7mI7fV5fw+qVuZ5FkQbu/wG+Cewh6QPAC4B3F7l4RNyS/r4tndr8ycCtkvaKiFWS9gJu6yzpveH69WoMy7QZveSOAlalZrPO7gMQEecAJwGnkYzqnh8RX2t1YUk7Stq59hp4FnAtcDFwfHrY8cBF0/kA3eb6detXfpCxKjVrs7gQQNLiiPjfiPhkRHwiIq4reO09gR9Luhq4Erg0Ir4DLASeKekGktlsF04j/V3n+nXrV36QsSo1q4aaIelk4JGS3la/MyI+nHNOdv/vga2WX42IO4DD201ov+j1tNT9XLffz2kbBScesZ8ngLTKNAsWLyLp1roNsHNXUjMgelW/3u400t3MvD3Fde/1+kHGhluR3lDPjoj/26X05Oqn3lC91E5PrG73jHEvMbP+05XeUJKOi4ivAI+W9Kj6/a2qoax87TRgdrtnjBtXzYZbswbuHdPfO5FUQ2V/dqo4XZajnQbMbmfeblw1G24Ng0VEfDb9fWr9D3BX11Jom7TTE6vbmbd7iZkNt06nKN+qd5RVr52pGLqdeXuaCLPh1rKBO/ck6Y8R8dAK0pPLDdydGZSurIOSTrNB0+3pPvK0H2G6yJlPYhCm0HCXW7PB0Kw31N3kBwUBfdtqOQiZT1XBbBCDpOczMhsMDYNFRAzkQLx+z3yqCmaDECTzuMut2WAYujW4+z3zKboudb9ct2rucms2GIYuWFSZ+ZSxQl5Vwazfg2Qj7nJrNhiGLlhUlfmUtUJeVcFsUJ/Q3eXWbDB02huqb1U1mVpZbSFVzQw6yDOODkKvLbNRN3TBAqrJfMqq5qkqmHnGUTOr0lAGiyrMnjmRO6tqJ9U87QSzdrrD+gndzKoydG0WVelFQ2xZ7SRmZtPlYFFQLxpiB7U7rJkNH1dDtaHb1TyD2h3WzIaPSxZ9bFC7w5rZ8HGw6GNltZOUMZjQzEabq6FKUsUkfmV0hx3UOaPMrL84WJSgygx5uu0k/T6xopkNBldDlaCfey25kdzMyuBgUYJ+zpDdSG5mZXA1VAnKHN09HXntJt2cM2oQF1+arlH8zDaaXLIoQT9Ms91otDcwrcGERXtSjeJo81H8zDa6FNHXy2kDMDk5GUuXLu11Mprq9RPmwQuX5JZu5syc4IoFh3V0zfqGe0iCYF6wqeL+/W4UP7MNFknLImKyjGu5GqokvZrErxak8jItmF67STs9qfq53aYqo/iZbXS5GmqAZatBGplOu0k7meEoNqSP4me20eVgMcDynvyzpttu0k5m2A/tNt02ip/ZRpeDxQBrVt1Rxqy47WSGo7g86ih+ZhtdbuAeYN1oYO11w72Zdc4N3AZ0Z91tr75nZuBgMdC87raZdYuDxYDzk7+ZdYMbuM3MrKXKg4WkMUnLJX0rfb+7pO9JuiH9vVvVaTAzs+npRsniX4HrMu8XAIsjYl9gcfrezMz6WKXBQtJDgCOBz2c2HwOclb4+C5hfZRrMyuZlam0UVd3A/VHgJGDnzLY9I2IVQESskrRH3omSTgBOAJg7d27FyTQrxsvU2qiqrGQh6SjgtohY1sn5EXFGRExGxOSsWbNKTp1ZZ/p5VUSzKlVZsjgYOFrSc4DtgV0kfQW4VdJeaaliL+C2CtNgVirPNGujqrKSRUS8IyIeEhHzgBcBSyLiOOBi4Pj0sOOBi6pKg1nZPNOsjapejLNYCDxT0g3AM9P3ZgPBM83aqOrKCO6I+AHwg/T1HcDh3bivWdk8xYqNKk/3YdYmT7Fio8jTfZiZWUsOFmZm1pKDhZmZteRgYWZmLTlYmJlZSwOxBrek24GbSrjUrsCdXTy/6PGtjut0f6PtDwb+XCBd3Tbd76eK63ZybpFzpntMu/v8nVd7fr/+X98vInbO2d6+iBiZH+CMbp5f9PhWx3W6v8n2pb3+Lqr4fqq4bifnFjlnuse0u8/febXnj8L/9VGrhrqky+cXPb7VcZ3un+7n7baq0jud63ZybpFzpntMp/v6TT9+552cP/T/1weiGsrKJWlpREz2Oh3WPf7OR1OZ3/uolSwscUavE2Bd5+98NJX2vbtkYWZmLblkYWZmLTlYmJlZSw4WQ07SFyXdJunazLYfSHJj5xBp8D3vLul7km5If++Wbn+FpE/0LrXWqXa+53TfOyT9VtL1ko7IbL+n3Xs7WAy/M4F/7HUirHJnsvX3vABYHBH7AovT9zbYzqTg9yzp0SSrlB6QnvMpSWN0yMFiyEXEj4C/5O2TNEPSWZLe3+VkWckafM/HAGelr88C5tefJ+lIST+V9OBqU2hlaPN7PgY4LyIeiIiVwG+BJ2dPlPTg9Ps/stW9HSxG1zbAOcBvIuLdvU6MVWLPiFgFkP7eI7tT0j+RPIU+JyL6cSoQK6bR9zwH+GPmuJvTbQBI2hO4FHhPRFza6iZeKW90fRa4ICI+0OuEWE8cCkwCz4qIu3qdGKuEcrbVxkqMk1RZvTEifljkYi5ZjK6fAIdK2r7XCbHK3CppL4D0922Zfb8HdgYe2YuEWakafc83Aw/NHPcQ4Jb09XpgGXAEBTlYjK4vAN8GvibJJczhdDFwfPr6eOCizL6bgOcBZ0s6oNsJs1I1+p4vBl4kaTtJ+wD7Alem+wJ4FbC/pEIdHxwshpykc4GfAvtJulnSq2v7IuLDwC+BL0vyv4UB1uB7Xgg8U9INwDPT95tExPXAS0keGB7e7TRb+9r5niNiBXAB8GvgOyRVThtq10pfv4ikhuENLe/t6T7MzKwVP02amVlLDhZmZtaSg4WZmbXkYGFmZi05WJiZWUsOFlY6SXtK+qqk30tals4980/pvkMk3SlpeToT5o8kHZU59xRJU5KuknStpKO7kN5xSQvTWTuvlXSlpGd3eK3XS3p5+voVkma3ef6ZklZKen399Qqef4ikb+Vc8wXp66PSv/3Vkn4t6XXp9uzf/QZJ30gnoqtd4xxJf6ldx0aPB2NZqSQJWAScFREvSbftDWQz/csj4qh034HAIklrI2Jxuv8jEfEhSY8CLpe0R0RsLDF9qrve+4C9gMdExAPpnDl/38n1I+IzmbevAK5l86jZok6MiAtzrjctksZJltl8ckTcLGk7YF7mkI9ExIfSY48Flkh6bETcHhEvlXRmWWmxweOShZXtMOCv2UwuIm6KiI/nHRwRVwHvBf5Pzr7rSKYl2GJG1PQp+MuSlqRPwa/N7DtR0i8k/UrSqem2eZKuk/QpkkGID80cvwPwWuBNEfFAet9bI+KCdP+nJS2VtKJ2vXT7jZI+mJZCrpT0iEza/j19Ap8Ezkmf1ickvSdN27WSzkgDV1O166Wvf5C5528kPaPV+XV2JnlAvCP9nA+kA/O2EhHnA98FXtLmPWxIOVhY2Q4gyZDb8Utg//qNkp4CbARuzznnccCRwFOB90iaLelZJFMaPBk4EHiipL9Lj98PODsiDoqImzLXeQTwhyaT6b0rIibT+/29pMdl9t0VEU8GPgF8NHtSWjJYCrw0Ig6MiLXAJyLiSRHxGGACOIr2bZPe8y3Aye2cGBF/IZkC4iZJ50p6aYuR+7nfi40mBwurlKRPpvXjv2h2WN37t0q6CvgQcGzkTzNwUUSsTafW/j5JgHhW+rOczRndvunxN0XEzzr4CC+U9Mv0mgcAj87sOzfz+6kFrnWopJ9LuoakBNbJnEzfSH8vY8sqpJpGUzIEQES8BjicZI6gfwe+2OReLUs+NjrcZmFlWwE8v/YmIt6oZGGdpU3OOQi4LvN+U915E/WZYpBkbqdFxGezOyTNA+5tcJ3fAnMl7RwRd9edtw9JhvqkiFid1tlnZ+mNBq+3omR2308BkxHxR0mn1F2rqAfS3xvI//97B7Bb3bbdgU3rVUTENcA1kr4MrCRpW8lzEM2/NxshLllY2ZYA20v6l8y2HRodnFbr/AfwyTbvc4yk7SU9CDgE+AVwGfAqSTul154jaY8m1yAi7iOZgfd/JG2bnreXpOOAXUiCzJ1po3d9D6ljM79/mnP5u0naCWBzYPhzmr6qehXdAMxOOwfUOhc8HrhK0k6SDskceyDJ7LNbkfR8klLauXn7bfS4ZGGlioiQNB/4iKSTSNob7gXenjnsGZKWkwSR24A3Z3pCFXUlySpfc4H3RcQtwC1pJvnTtO34HuA4kqfwZt4NvB/4taT70/S+JyKuTtO5gmT9hyvqzttO0s9JHrpenHPdM4HPSFpLUk31OeAa4EaS4Fa6tDfXccCX0tLMOuA1EXGnpJ2BkyR9FlhL8jlfkTn9rem5O5L04josIvLai2wEedZZGzhpFc49BaqqqkzDjSRVSqUuR5pWdX2r1nW2n/Rz2qx6roYy6y93Au9TOiivX0g6h2Tsyf29Tov1hksWZmbWkksWZmbWkoOFmZm15GBhZmYtOViYmVlLDhZmZtbS/weX96iFeNkJygAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Scatter plot\n",
    "plt.scatter(gdp_cap, life_exp)\n",
    "\n",
    "# Previous customizations\n",
    "plt.xscale('log') \n",
    "plt.xlabel('GDP per Capita [in USD]')\n",
    "plt.ylabel('Life Expectancy [in years]')\n",
    "plt.title('World Development in 2007')\n",
    "\n",
    "# Definition of tick_val and tick_lab\n",
    "tick_val = [1000, 10000, 100000]\n",
    "tick_lab = ['1k', '10k', '100k']\n",
    "\n",
    "# Adapt the ticks on the x-axis\n",
    "plt.xticks(tick_val, tick_lab)\n",
    "\n",
    "\n",
    "# After customizing, display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pop = [31.889923, 3.600523, 33.333216, 12.420476, 40.301927, 20.434176, 8.199783, 0.708573, 150.448339, 10.392226, 8.078314, 9.119152, 4.552198, 1.639131, 190.010647, 7.322858, 14.326203, 8.390505, 14.131858, 17.696293, 33.390141, 4.369038, 10.238807, 16.284741, 1318.683096, 44.22755, 0.71096, 64.606759, 3.80061, 4.133884, 18.013409, 4.493312, 11.416987, 10.228744, 5.46812, 0.496374, 9.319622, 13.75568, 80.264543, 6.939688, 0.551201, 4.906585, 76.511887, 5.23846, 61.083916, 1.454867, 1.688359, 82.400996, 22.873338, 10.70629, 12.572928, 9.947814, 1.472041, 8.502814, 7.483763, 6.980412, 9.956108, 0.301931, 1110.396331, 223.547, 69.45357, 27.499638, 4.109086, 6.426679, 58.147733, 2.780132, 127.467972, 6.053193, 35.610177, 23.301725, 49.04479, 2.505559, 3.921278, 2.012649, 3.193942, 6.036914, 19.167654, 13.327079, 24.821286, 12.031795, 3.270065, 1.250882, 108.700891, 2.874127, 0.684736, 33.757175, 19.951656, 47.76198, 2.05508, 28.90179, 16.570613, 4.115771, 5.675356, 12.894865, 135.031164, 4.627926, 3.204897, 169.270617, 3.242173, 6.667147, 28.674757, 91.077287, 38.518241, 10.642836, 3.942491, 0.798094, 22.276056, 8.860588, 0.199579, 27.601038, 12.267493, 10.150265, 6.144562, 4.553009, 5.447502, 2.009245, 9.118773, 43.997828, 40.448191, 20.378239, 42.292929, 1.133066, 9.031088, 7.554661, 19.314747, 23.174294, 38.13964, 65.068149, 5.701579, 1.056608, 10.276158, 71.158647, 29.170398, 60.776238, 301.139947, 3.447496, 26.084662, 85.262356, 4.018332, 22.211743, 11.746035, 12.311143]\n",
    "\n",
    "# Store pop as a numpy array: np_pop\n",
    "np_pop = np.array(pop)\n",
    "\n",
    "# Double np_pop\n",
    "np_pop = np_pop * 2\n",
    "\n",
    "\n",
    "# Update: set s argument to np_pop\n",
    "plt.scatter(gdp_cap, life_exp, s = np_pop) # s --> size = np_pop\n",
    "\n",
    "# Previous customizations\n",
    "plt.xscale('log') \n",
    "plt.xlabel('GDP per Capita [in USD]')\n",
    "plt.ylabel('Life Expectancy [in years]')\n",
    "plt.title('World Development in 2007')\n",
    "plt.xticks([1000, 10000, 100000],['1k', '10k', '100k'])\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Giving color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "col = ['red', 'green', 'blue', 'blue', 'yellow', 'black', 'green', 'red', 'red', 'green', 'blue', 'yellow', 'green', 'blue', 'yellow', 'green', 'blue', 'blue', 'red', 'blue', 'yellow', 'blue', 'blue', 'yellow', 'red', 'yellow', 'blue', 'blue', 'blue', 'yellow', 'blue', 'green', 'yellow', 'green', 'green', 'blue', 'yellow', 'yellow', 'blue', 'yellow', 'blue', 'blue', 'blue', 'green', 'green', 'blue', 'blue', 'green', 'blue', 'green', 'yellow', 'blue', 'blue', 'yellow', 'yellow', 'red', 'green', 'green', 'red', 'red', 'red', 'red', 'green', 'red', 'green', 'yellow', 'red', 'red', 'blue', 'red', 'red', 'red', 'red', 'blue', 'blue', 'blue', 'blue', 'blue', 'red', 'blue', 'blue', 'blue', 'yellow', 'red', 'green', 'blue', 'blue', 'red', 'blue', 'red', 'green', 'black', 'yellow', 'blue', 'blue', 'green', 'red', 'red', 'yellow', 'yellow', 'yellow', 'red', 'green', 'green', 'yellow', 'blue', 'green', 'blue', 'blue', 'red', 'blue', 'green', 'blue', 'red', 'green', 'green', 'blue', 'blue', 'green', 'red', 'blue', 'blue', 'green', 'green', 'red', 'red', 'blue', 'red', 'blue', 'yellow', 'blue', 'green', 'blue', 'green', 'yellow', 'yellow', 'yellow', 'red', 'red', 'red', 'blue', 'blue']\n",
    "\n",
    "np_pop = np.array(pop)\n",
    "\n",
    "# Double np_pop\n",
    "np_pop = np_pop * 2\n",
    "\n",
    "\n",
    "# Update: set s argument to np_pop\n",
    "plt.scatter(gdp_cap, life_exp, s = np_pop, c = col) # s --> size = np_pop\n",
    "\n",
    "# Previous customizations\n",
    "plt.xscale('log') \n",
    "plt.xlabel('GDP per Capita [in USD]')\n",
    "plt.ylabel('Life Expectancy [in years]')\n",
    "plt.title('World Development in 2007')\n",
    "plt.xticks([1000, 10000, 100000],['1k', '10k', '100k'])\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### adding grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABnrUlEQVR4nO2dd3ib1dXAf0eS93b2nkAIK0DYCYT9sffem0KYLXuXUgqlpYy2JBAgUDZlQykQMFB2QhhZQBbZ03tb0vn+OFIsOx6yLXne3/PokfSO+x5J9j3vPVNUFYfD4XA4msLT0QI4HA6Ho/PjlIXD4XA4msUpC4fD4XA0i1MWDofD4WgWpywcDofD0SxOWTgcDoejWZyycMQUEbldRP7VxP6lInJAe8oUDc3J3VURkbkiMqmj5XB0fZyy6GGIyA0i8k69bb80su3kdpbtSRGpFpGS0GOOiNwtIlntKUdXIRoFp6rbqGpeK8buKyLPicgqESkSkc9EZLd6x5wqIr+KSJmIvCYiuRH7kkTkcREpFpE1InJ1xL6JIlJa76EiclxL5XS0H05Z9Dw+AfYSES+AiPQHEoCd6m0bHTo2akTEFwP57lXVDKAPcA6wO/CZiKTFYGxH9KQD3wA7A7nAdOBtEUkHEJFtgCnAGUA/oBz4R8T5twNbAMOAfYFrReT/AFT1U1VNDz+Aw4FS4N12+FyOVuKURc/jG0w5jAu93xv4CPip3rZFqrpKRAaKyBsiki8iC0XkgvBAoTvbl0XkXyJSDJxd/2Iickbo7nOjiNwUrZCqWqmq3wBHAr0wxREe81wRmS8iBSLyXxEZFtr+iIjcV+/6r4fvakOf5d8isl5ElojI5Y1dX0SODJlwCkUkT0S2jti3NLRCmxeS4QkRSQ7tmyQiK0TkWhFZJyKrReRoETlURH4OfY83RozlEZHrRWRR6Dt6MXyHLiLDQ3fcZ4nIMhHZEP4OQxPvjcBJoTvz7xv5HJvMfqHf60UReSq0cpsrIuMb+f4Xq+pfVXW1qgZUdSqQCGwVOuQ04E1V/URVS4FbgGNFJCO0/0zgTlUtUNX5wKM08PcR4izgZVUta+z3cHQ8Tln0MFS1GvgKUwiEnj8F/ldvW3hV8RywAhgIHA/8UUT2jxjyKOBlIBt4JvJaIjIW+Cd29zkQm/QHt1DeEuB9YGJozKOxSfJYbPXxaUhGgGexyVNCx+YABwHPi4gHeBP4HhgE7A9cKSIH17+miGwZGvPK0DXeAd4UkcSIw04DDgZGAVsCN0fs6w8kh65zKzZRno7dpU8EbhWRkaFjLweOBvYJfUcFwN/riTQBm6T3D527taq+C/wReCF0h75D499iHY4Ensd+rzeAh6M5SUTGYcpiYWjTNth3CYCqLgKqgS1D3/vAyP2h19s0MG4q9nc1PUr5HR2EUxY9k4+pVQwTsQn303rbPhaRIdhEdV3oTv874DFs8g/zhaq+pqpBVa2od53jgbdCd59V2N1nsBXyrsJMIQAXAXer6nxV9WMT5rjQ6uJTQEPyh6//haquAnYB+qjq71W1WlUXY5N4Q36Zk4C3VfV9Va0B7gNSgD0jjnlYVZeraj5wF3BKxL4a4K7Quc8DvYEHVLVEVecCc4HtIz7PTaq6IvQd3Q4cX8+kd4eqVqjq99ikG61iaIj/qeo7qhoAno5mLBHJDB17h6oWhTanA0X1Di0CMkL7qLc/vK8+xwEbsL9JRyfGKYueySfAhNAdYB9V/QX4HNgztG3b0DEDgfzQ3X2YX7E75jDLm7jOwMj9ITPDxlbIOwjID70eBjwQMg8VhrYLMEitKubz1E7cp1K72hkGDAyfFzr3Rsze3pDcv0bIHQx9jsY+96+hc8JsDE3GAGEFujZifwW1E+ow4NUImeYDgXpyrYl4XR5xbmuoP1ZyU74mEUnBVmRfqurdEbtKgcx6h2cCJaF91Nsf3lefs4Cn1FU07fQ4ZdEz+QLIAi4EPgNQ1WLsDv5CYJWqLgm9z42wQwMMBVZGvG/qn3w1MCT8JmRy6NUSQUMO1QOwVQPYJH2RqmZHPFJU9fPQ/uewO/NhwG7AvyPOW1LvvAxVPbSBy67CJvGwDBL6HJGfe0jE66Ghc1rDcuCQenIlq+rKZs9s+rtvMyKSBLyGfe6L6u2eS8SqJGRWSwJ+VtUC7LePXLXsEDoncvwhwCTgqRiL7ogDTln0QELmopnA1dROwmB+i6sJ+StUdTm24rhbRJJFZHvgPOr5JprgZeBwEZkQsvf/nij/5sRCL3fGJqsC4InQrkeAG0LROIhIloicEPHZZgPrMXPZf1W1MLTra6BYRK4TkRQR8YrItiKySwOXfxE4TET2F5EE4LdAVei7CHOpiAwOOaNvBF6I5nM1wCPAXRFO+j4iclSU564Fhof8MTEl9LlfxlZBZ4ZWV5E8AxwhFgabhv22r0SsQp8CbhaRHBEZA1wAPFlvjDOAz0P+DkcnxymLnsvHQF9MQYT5NLQtMmT2FGA4duf8KnCbqr4fzQVC9vlLMcfzamzSX9HMadeKSAlmXnoKmAXsGY6UUdVXgXswp3UxMAc4pN4Yz2GrkWcjZAkAR2ARX0swO/lj2Aqrvtw/YQ7ph0LHHQEcEQoOCPMs8B6wOPT4QzOfqzEewBzN74U+95fYiigaXgo9bxSRb1t5/cbYEwtpPQgolNp8iImw6be9GFMa6zB/xCUR598GLMJMdB8Dfw455SM5E+fY7jKIMxU6HC1DRJYC56vqBx0ti8PRXriVhcPhcDiaxSkLh8PhcDSLM0M5HA6Ho1ncysLhcDgczRKLwm9xp3fv3jp8+PCOFqPbUFZWRlqaq8vXk3C/ec9k1qxZG1S1TyzG6hLKYvjw4cycObOjxeg25OXlMWnSpI4Ww9GO9MjffN062LABgkHIyoLBg8HKhvUYROTX5o+Kji6hLBwOhyMqamrgo49g6lT47jtISABVCARgyBC48EI44ghwq6wW43wWDoeje7BwIUyaBJMnww8/2GoiLQ3S0yEzE1avhltugd13h88+62hpuxxOWTgcjq7Pzz/DscfC+vWmGDIz65qcRExxZGXZKuPss2HGjA4TtyvilIXD4ejalJTA6adDVZUpieZITYWkJLj0UljkylJFi1MWDoeja/PGG5CfDxkNtctohORk829MmxY/uboZTlk4HI6uiypMmQKJic0fW5+MDHjlFSgujr1c3RCnLBwOR9flxx9hzRpISWn5uT4f+P3wflRFlHs8Tlk4HI6uy+rV5rxubf6E3w8rIqrmr1oFn39uORqOOrg8C4fD0XWprjZTVGsRgYpQ59tPPrE8DBHweuHpp2HHHWMjZzfArSwcDkfXpX6IbEtRRXNyqAnUwO2314bYVlfDXXfFTMzugFMWDoej67L99jbhB/wUJPgp9PnRJlqTB1Wpqq4mEAiAKt/2C7BL5YNs+dCWnLbljxQnhs71eExhODbhzFAOh6PLEszO4vljtuCfxTNYmR5EgQGlcPJ8Lwf96iMtIY1eKb1ISUghf+NG1qxdSzBo7cQz0xI49cxKgpJCbnIunw8t594N6/jD9wFbYVx1Vcd+uE6GUxYOh6NLEggGOOaFY/g49UP6VlaRXAEKrE6Ce3eu4bteXq78porCykISSaBqXTVe8eD1eiEYpNhTxqpUZXhCEBEhOTOXBQcPhlN/A9tuC1tu2dEfsVPhzFAORzuzZs0aTj75ZEaNGsXYsWM59NBDmTp1KocffniDx59//vnMmzevnaXs3Kgqp75yKv9Z+B8qPUHKEwVvEEQhxQ/pVfD+8ABfD/LgFS+l1WUsGVTD29sE+WLLaob0qmTY3rDdECitWkpFzVyqAoXsu8PRVjbEKYrNcCsLh6MdUVWOOeYYzjrrLJ5//nkAvvvuO958881Gz3nsscfaS7zOjapVlF26lKf7r+XNn97EIx4EYXU6SBByQqsLBDxBeGHLavZclcKcPspt+0NQqknwwH/9cMtpidzlUab/mszKcj+HjK7h4vHjOvhDdl7cysLhaEc++ugjEhISuPjiizdtGzduHBMnTqS0tJTjjz+eMWPGcNpppxFueTxp0qRN/VzS09O56aab2GGHHdh9991Zu3YtAG+++Sa77bYbO+64IwcccMCm7d2Khx6CCy8keOfveejd2/EHavCKF3/QD8DqTGFlllDjAW/QVhcLc5TUygBP7WirjswaSM+Er4YI31VCryTh74cM5r0ztuaqPXLxev4culgZMAt4EXgSeBp4H1gJTTjQuzNOWTgc7cicOXPYeeedG9w3e/Zs/va3vzFv3jwWL17MZw2U0S4rK2P33Xfn+++/Z++99+bRRx8FYMKECXz55ZfMnj2bk08+mXvvvTeun6NDmD4dUlOZOSqFIl8ACdqkHVRzWCNCUYqwsLewJFfIT4EqL3w6oJolObAmDRb0geqsUHpFdYCUlBRSNmV/pwNfA0cD2wOnAzcCdwC3AZOBScAuwN+BnpW4F1czlIhcBZyPqeIfgXOAVOAFYDiwFDhRVQviKYfD0RXYddddGTx4MGCrjaVLlzJhwoQ6xyQmJm7ybey88868HypVsWLFCk466SRWr15NdXU1I0aMaF/h24EvExJ4cdEiRJJQhQxJokRtVSHU5looUJaglCXY+7OPEYIRq4GfiqBXkjJuQBpDhg6lvCZAakIVIiuASuB7IBdoLH+jCvgrQX2A9xdtz6sLsjlzh3PZc8iesf/QnYi4rSxEZBBwOTBeVbcFvMDJwPXADFXdApgReu9w9Ai22WYbZs2a1eC+pKSkTa+9Xi9+v3+zYxISEpBQElrkMZdddhmTJ0/mxx9/ZMqUKVRWVsZB+o5j+fLlnL12La9XVPDsTxsoX5FAn9zBm5REOLdCVTfLswgSrPNegIJqOPmDMradMoc/fvoDq0oWUFlTiU1TTSkKoCIIy8soW7mGMb1e4/ixz/G7/57F8qLlsfvAnZB4m6F8QIqI+LAVxSrgKGB6aP90bM3ncPQI9ttvP6qqqjaZjwC++eYbPv744zaNW1RUxKBBgwCYPn16M0d3PVavXk0wIYHsbbfF12cA1YF0khNS6ZvWF494UJSgBhtMyBNkkyM80eMjOUFQhSWFfk7eJsjF44MUVSoLC/xU+XNoUlH4A7B4CRQWkLyhjJT1yla9/DxwyErWlP4Yvy+gExA3M5SqrhSR+4BlQAXwnqq+JyL9VHV16JjVItK3ofNF5ELgQoB+/fqRl5cXL1F7HKWlpe777ECuueYaHn74YW6//XYSEhLo378/EyZMYOPGjZt+l5UrV5Kenk5eXh6FhYXMmjWL0tJSAoHApmPmzp3LmjVryMvL47jjjuOII46gd+/ejB07lsLCwjq/cVf/zVWV6667joqKCrxeL6l9UynyF+HP9kN/mszaro9gpqrsZBisMPeb0DWA1Z4EEjwJTQkClZXm9FAlKErVMsHnERI8q8j7Ja8Nn7JzI9qWIlxNDSySA/wbOAkoBF4CXgYeVtXsiOMKVDWnqbHGjx+v4WgQR9vJy8tj0qRJHS2Gox3pUr95YSG89ho88wxs3Ai5uXDKKfiPPJKlRUX079+fJWVL2PWxXQkEA/g8PoIapCpQtdlQ9c1UYfqlwYwzIagQUBA8eCSBrORMhmYNbVy2oMLiRVBhZr6aAf2ozEghNSEFr6cYuBa4KDbfQwwQkVmqOj4WY8XTDHUAsERV16tqDfAKsCewVkQGAISee1ZIgcPhaJx582C//eAPf4CVK61f9qpVcPfd+A46iNGVlaSnp1NSXcLgzMGkJ6ab+Sl00xvp6A6/9sjm09xNEyHJB1UB8AfBKwmAkp7YTLc9j8DIkTB8GIweTULvPmQkpeP1eLFoqr8C3TBsmfgqi2XA7iKSKuaR2x+YD7wBnBU65izg9TjK4HD0YGqAjbQ+L6ASeAd4ApjdhnGiJD8fTjsNysogO9t6ZSck2HN2NpSXW6/tjRvpn94fFIZlDWN07mi21Fz2WyocuDGbERlDSfQkkuRLItmXvJmy6J0KB4+G4tBCJOzzSPGlkJ2URZW/itUla8ivyG+4+rnHY132UpLr7UgA/JgRpfsRT5/FVyLyMvAt9g3OBqZi6vdFETkPUygnxEsGh6PnsgI4EbvL3RfLGWjp+SdgyqYGmyoOBe6nbfeY64BLgF+xHIZjanf9+9/W4jSnEat0RgYUFMCLLzLyN7/h0l0v5Z9fPswl7xVw5MwSVBIQLWVVTiWHnKz4EwURwefxUROs2TTM0VuBV0DV1h5pCWn0TutNTlI2CiwqWIQ/GECAQDBIn7TeLfh8qZhyvZQmHeVdkLhGQ6nqbao6RlW3VdUzVLVKVTeq6v6qukXoOT+eMjgcPYMlwNXYYv1x4Fks+DAb+AQob+F4t2ATeybQC8gA3sKymNvC/VhmdAVm3y+t3fX005Bc/269Hikp5ssArtz9SmaUn8D5PybQr+9IcvsMpTTZw4CiIMfOCaKBUA6GCCm+FHweHz6Pj31HePCHVgwJXh+jc0fRKyUXj8eDP+gnEAzi8/gAocLf0u8tCSjGMr27F642lMPRGlRh7VqYPx9+/hmKisxMomoTWnq62ba33hqGDTPTRdxYjkWgl2CmkP8B22J3tiWh55b8qweBjzFFE8YTGudt4OA2yOrFzFlBagJBrvzvZOavX8Z2fbfjtpJ15CY200s7IQE2bLDXNTUMfv5tyOkLiYkkq+IVD+WJykWzPfx3S6UgLYDX40VESPQmAsq2fSuoqGGT6cn8DUaiN5G0xDTKqssQEXJTerXiM3owi/vgVpzbeXHKwuGIljVr4PXX4dNP4ccfzbbu80FVyPgd7timao/ERHvv8cCYMbDHHnDUUfY6prwAFAFhc0kQK5hwHjZpnQkktnDMpNA4kUouiK002sJVwDL8wUVc+34+7/7yKSkJKbz181v8slc+r388kARvEwrD74esLHtdUGBhrJkmk0eEYdnDWVKwhP6lcP3sdG7cuxp/0I9gJqkET5D0RMivAJ/HR6W/En/Aj89rU6EIDM8eTqW/Ap8ngURvE2G0jVIDrG7FeZ0bpywcjqYIBuGrr2DaNMjLMyXg85m5JCtUZCg9vekxAgH46Sf44Qd49FEYOxYuuggOPLBWobSJMupO6hJ6fyEQTmPKa8F4HuAUrIBeduh9FbYqOLFNkppJ6yk+X/4J7yy8gJwU808keZNY1K+EhQnFbE3jymJtsJjbjsqgf97t3LTr70jwek2B+GwqS0tIZWTOCPJXLaYmwUv/tP74g34KKguoDlTj80joeol4xENQFannAPeIkJqQ2obPqJibtnvhlIXD0RCq8MYb8Oc/m7lJ1e5gW2NO8nqtr3Namo3z00/WhS05GS680B5tUhr7Y1VRq7AVRCGwFbUrjWiowpzZfkxBXAtswKKhfJh5626swF7b8YiH+jlewfR0vIleKC63CKj6lJczZWw5byf+SsL3T7HXkL048OSTrcBgTs6mlV1q0EtK7lD2/N2t/FjwPksLljJCRjA6dzRnjzuDvmknsrSmEAUGZw7G25rftLzCrrdZRBSYUm2LsumcOGXhcNRn3Tq47jr45BNISjIlITGKbBGxqB6wHs9/+5sloD34oK04WsUEbCK/HcgHdgL+QXTxK/OAp4DXMDOTYApjF2xlcj2mfEYCzTifW8DOA3ZmaNZQlhQsIcGbQHWgmp0H78zoB34L551vJqa0NPNR1NSYyS85me3P+B1Jvz5KojeRkTkj4doJsHQp/O9/toLzesHnQ/7yV/bc53D2bDAKbGu26bMBSG7dz1pQACtCDuyhQyGrvmnOB4xuxcCdG6csHI4wquaTuPlms4VnZ8dOSTREYqJNhsuWmS/jN7+ByZNbuco4ATgeCBDdv3U1cA22cghi0U7h8xSLeL8Yc9I+RSwVBUBKQgovnvAif/niL/yy8Rd26LcDV+5+JZ7ENHjvPYt4eu45m5izsmz1dfrpHD1oENvmH0d6YrrlWgA8/jjMnQuzZ5tJcL/9av0aDbITIq+3/jOVhQIZUAtqqKMsFPNZbNW6sTsxcSv3EUtcuY/Y0qVKP7QXVVVw5ZU2UaWkNB/CGWv8figttQiqf/0L+jZYMq3V1P3N/VjngE+BLJpegRRhZqnXgYExlanjmIEpwqYUShNUVcGvvwJimdx1lHsxsAOdJTGvq5T7cDi6BuXlcPbZpiiys9tfUYA5aLOyYMkSOOYYW23EjX9iuRfZND8FZAEFwAW0V4e4oAb5csWXvPPLOywrisf3sA8W1dXKMu5JSdaje8stGlgFKqH6p90OZ4Zy9GwqKuDMM82EEW+zU4iaYA2ChBK/IhAxhbFuHRx/PLz6KoTKjseOauAxrJBCtJ81C/gZ+A7YMcby1CWoQSa/M5n3F72Px2NlxaceMZW9h+0dw6v4gCuwDnhJxC7TuhgYhHXT6364lYWj51JTY36CdlQU68s3sGDDTyzYsIDiqpKGD8rKMlv9ySdvSkALBuGpp+Cjj9py9SCWczEfywOIdqUgoXOf3GzPxvKNzFw1kx/W/rCpF3Zb+GjJR7y36D0ykzLJSMzAK16uePeKzSKn2s7pWGRXUYzG82Pf0YNY5Fj3w60sHD2XBx6wiKeIsMt4s75sPR4RgqqsL19PZlIjVU6zsqza6uTJ8OyzzJnj4brrLDDrp59ae/X5wLvUZnaXYo7thvBjqxAP5gjOILLUx/qy9dzx8R38d9F/8YmVCE9PSufyXS/nzB3O3NTNr6WsLVuLopvOT/Yls7FiIzXBmlAGdqzwAA8AR2DfRTPVZpskEBrjKmIVWtwZccrC0TP58UeYMiW2YbFRkJqQSnF1sRWwS0xr+uDsbPjmG3jxRcYcezLnnQej2xSRmU241IblAjT071+FrTpKqW0TlAD0I3z3nF9RyKHPHsra0rX0Sum1qVxGlb+KOz6+g1Ulq7hh4g2tknCbPtsgCDWBGhK8CRRVFbF1761jrCjCDAWewxIQCzFzW0v/FqqwulsXYMUDuy/ODOXoeVRXwxVXmJLwte/90pCsIQzKGMSQzCH0S+vX9MEilpx2xx0krl/JH/5gfviWodidL5g9fR/MXzEYNsuUrgIWYYrCE3p4MSURbnjp4ezXzua7Nd+xrmwdGys2bjo7yZdEVlIW02ZPY0nBkpYKCsAOfbZlWuBwJn29jvLSQoZkDWHKEVNaNVZ0jAXeBLbDFMbmDZQaJhg6PgjcA1xHd6syWx+nLBxdh+JiMxu98w58/LEV72sNDz5ooY+Zba1z1HK84qFXSi7ZydnRTS1JSeZb+e1vzXHRItZjPci2CL0Gy/bOpW6RwDArqV11REoXVhwlBIKrN5mePOJhXVnd3mVej5egBnlpbitDRx98kH0efJ37P0pk5spDmXHmjKY719WnsNB6YkxpiYIZijX1vBXLgC/CIsAqqevXqcHMTQWh5wMx09zxdHdFAc4M5egKLF4MU6dapjNYQlSoBzJHHgkXXwyjRkU31vLlNlZGW2zUcSIxCCesh30LoMoDr/aGD3LMfzFzJrz/Phzckoqv7wALgRysr0UAS957iM2LBFZj5hQvDaNABqXVz+EVLwENgFpNp/r4PD4WFixsgZwRzJ8PHg8eXyKpvyyFBrrcNcmSJVbDa906q78VNR6svPtpWB2tt7HExOXUOvjTgZ2x1dkx1Nbd6hk4ZeHo3Hz+OZx/viVCZWTUNRv5/fDKK/DWW6YAJk5sfrznnrOyEO1sfoqKq5fDHsVQ4YHMAExeCakBgm/0RgU8jzyCtEhZjMD8DQXYHbMHS6ybiOVZRDYZqm5inLBiSSclYSH90vpRXF2MRzwMSB+w2dGBYIDeqS2pSxXB5MmmGKur4frrW37+uHHwwgtWFr5V+LDV2AGh9zXUFlFMpiesIBrDmaEcnZf58+Hcc+11Ts7mE7zPZ9s9HrjgApgzp+nxqqqswU5aM47ljqB3NexWDEVeqPZApQcqPARPXMv89fOZV7mMDV99RPCnBS0YdG+sEdIdWG2n8ER3C5BGncZD4alAgbIglASgJlTSgiCmZJREbzZHjjmS7KRshmUN28zxrKp4PB6O2/q4zaSZu24ub//89mamqzpsvz3MmmUVevfcswWfNYQITJgAQ4a0/NwGScBWFCn0ZEUBTlk4OjP33mv2+oYqkEaSkmKrjHvuafq4994zhdHS2ktVVdYfuqDAViXxICMAAaHOhOQXAmk1BDWA1+OjvLqMjVP+1sKB9wbOpq4RYSTwLywhLR9zYKdYpfMFFbC4Cn6tghUVsKEKavphPg4fcDiX7XoZSb4kSqsjlY0l1BVUFrDboN3YacBOdfa9+dObHPPCMVz136s4+OmDWVG8onGRReLcLMrRGhr9RUQkN4pHdjvK6uhJrFplTYaaLAgXQWYmfPGF+SQa45FHWjYJqcLq1fDLL7BypT0WLDBHe6xZlmzmp+QIJ3ZGgKpvEq2XEkpZkoestz6wGlKN4ue+z+/liv9cQU2gponjtsfapB4DlEDNeijwQ7qa/ztL4CcPXOSBW6qxyJ8tgN0ZnTuaZ459huzkbIqritlQvoGCygJKqko4eNTBTD1i6mZ5FtNmT8MjHjKTMimsKmTG4hmt+pocHUdThttVoUdTay8vFkrgcMSWjz+2yTrayd3jsWihvDw444zN9+fnWzZbtMoHoKTEMqi93tpcjGDQFNKYMbY9VgQE/jQMblmKpgR4c8ZhfPvNzgz+rJS9Ep5EgsX0yR5AYsBnZpp99gmfiPkfHsN6W1fy1PerKKpUdug/kykzC6jwe7l+8A1UB6ojzEblwDTMCe6BykKCyxIIfJuGd2M5npkCqz0QUPghH64ZC72eJHx/ueOAHfn8vM/5bNln/JL/C4neRPYetnejkUvDsobx/drvSfAn4BEP/dKbCRt2dDqaUhbzVbXJQjAiMjvG8jgcRlFRy00+waCZihpi/nzzcbQkAa+gwI6PPMfjMbmKi81fEkvmpsFZW3Nn1VlM/+kYtNqDIuycuh/PjbyJBAnAxo3mm9lnAuaPmIqFeipmW0/jpRPS+HRZMXd9+jUpPsErCeRXrOfez+7h5r1vwXwQFwBfYAX10gisXUdwQICKYcKKG7dj5LCNJCeVgtcHvmRY+Afo1aeOuB7xMHHYRCYOaz6w4LZJt1FYVciCDQs4ffvTOWjUQTH96hzxpyllsUcU50dzjMPRclJSWpdZ3Zjzeu5ci7BpCY0pq3CP7ThQWJbJ9J+OJTO1BG9iEK3y8H3FlnxTtg17pv9g/pavPoNLvwU+wjqy1c0X2ap3Ci/NKySoHpJ9PiCIRwL855d/cPPe12EFAb/GoqHsOy6vSiKxspKkrStJ3qOUtd/2YdiwPvY5AyWQ3atNnys3JZfpR09v0xiOjqXRNb6qVgKIyCgRSQq9niQil4d9FeFjHI6Ys912thKIdlJWtUZC221Xd9vHH8NLL5n/o6XhsllZmyuG8Ot4RFRl11B50QakXxWeARUwsAoZUYEnu5qKhFBxuuQk+OE/oB9ik33D5dSzkrwRxfc8KJCZXARcjuUR+Im0MJcl5dp7j5K+f0ltKlpJCYwYYSW5W8EvG3/hxJdOZM9pe3L1f6+muCoO/h5HuxCNQfjfQEBERmNGzhHAs3GVyuHYcUcLfywvj+74igoYMAB22aV229NPw3nnWbz+G29YNnRLyMmxFU4gUPfRu3fLx2qO7Bq4bxF9D1vI1iN+prAoh5rqBIpKMknpVca4u9+DpCD4NpiDe30GTbkTT90ulwEZiWys8LOh3KrB3rL3EOB9gvrZZjo4e1A6xb5cPARJ8lcyIL3EsqFTUy3jvRWrvPyKfE58+US+Xf0tJVUlvLbgNS59u4H6SaqmzC+6CA4/HK65xlaCjk5FNMoiqKp+LGzib6p6FbB5Jo7DEUtErHNdVVXzvotAAKoq4YrDQWZjNnngww/Nx5CdbT2cWxqO6fFY57qBA23SzMiwZK/+/VvxgZrh7DXQuwZPqZcn77qIfXf7mASfn21GLeCFe8+k146r4Mh1IPmQ4IW1TX8nvVJ9vH3qaO6YNJDrJ/RnVE4SewxO5+5Pyzj6+XdYVrSS/Ir8Tccnp0DONgPQ3v1JTj6YpH32gGuvte9wq9a1CP1uzXdU1FSQnZxNki+JnOQcPlv+GeU1ETcAqnDrrXDOOTBjhmXrv/IKHH00POvuSTsT0azLa0TkFCwX/ojQtu5ZsN3RuTjiCHPmTptmk3VDd/NVVVBeBmf1gmOnAo8CRwL3WV/rzz6z0g8iVgpCxMxVubk2+Td2x1xVZSYYsON6tc1mH0kgaMFZGzdaGklSrwCj9izCU+pFgF7Z+Tz2+8l1Tyr3wJHrbZ2PQFWQnzZUMnd9Bf6g0jctgT2HpJHorVWIuSk+ztzB5M7L8/D+omL+9uUGymoCvLcI9h+5BH+gnD5pgxGpxucrhcy94eqniUUKVrIvmYAGULWS4wEN4BEPCZ6I6eOTTyyrPjOzVpmnptoXc/vtFvUV8wZQjtYQjbI4B2tYe5eqLhGREVhGj8MRX0Tghhtg6FD4y18sAikQsJDV8HNqKtx6CZz5CEgWFhX0OnCt2dlzcy3UVdUmIIDKShsr7OcIT1JJSeaLqK42E0zYVrNmjfXEDvfFrq42BaQKffq0qA1rIGg3z5UVVvbI6wHPkCoTrUJISqpnXPIqJAQtozutBrIT+SwpyD1fLWfe5/5QiSzF6xFSfB7OHteLS3bpU0dphJn+/UbyKwL4vHD5S4M4f3wVF07ciM9bRW7KYOASYDKxytXdddCu7DxgZ75e+TVBDeL1eLlq96tI8EYoi6eeajgJLyHBzG2vvQaXdu/S312FJpWFiHiBG1X19PA2VV0C/CnegjkcgE0kp58OJ51kbeJmzLCQ1uxs2G8/eyQWAlMwp60CHvj2JzjtIlMq/fvbbbyIZXr7Qx3dVO21z2ePsjJTIn6/TV6JifasCmvXmiJJSbHZPqx4SkpMKTXgPC8NpPBW0QTeKNyHokA66Z5yducLDjj03ww5ciX+NT7yH+qPqCmIQNAunRAeyqcwpNLm7gqBEuWlnCA3bF+Dt1zIyvTWSX6rDgR58Kt1fLmijOlHDyfJVzsBBxU+X1GGR0BVqC7J5uEZPv49dyB9+pbwn9P/w8CMwTH96XweH08d8xT/nvdvVpasZKcBO7Hv8H3rHrRyZdMZ9SuayPR2tCtNKgtVDYhIHxFJVNUWxh06ejLp6emUNplpXJe8vDzuu+8+3nrrLd544w3mzZvH9ZGF5BIS4KCD7LEZfYHbsRpIAkW3wLmX265wGXJVMy2FVwvh/AnV2sKC4RVL5PE+n10bbLXh89UqGAj5S6rqKAtVeGzDUfx13en41YuHIF4JEFQPXydvwT++OJVzBj3OVRfdT+oeZSw/cRQaECQhiN/vsXQQsCq0HswFkxbk+9lw41A/qTWQmOjZzISW6PWQkyx8s6qM2/NWc/cBteabSn+QJK8wPCeJ9WV+kvotJzk4hL59kyn3+5i9+vuYKwuTKZFTtjul8QO22soy5FPq99aI2O/oFERjhloKfCYib2DVYwBQ1b/GSyhHz+bII4/kyCOPbOFZp2Edz4DXnjYTRna2vS8vr11N1PdRhBWG3293uOHy55HbNQiJHpAaUxxer20PH1fvzvi+tafzyPrjSfeWkeYx5bP9brM5dfJ0/MnCE4+ew6PPXcD6tX25++YbSN62gsJnc8k9bwP+/Ij6UBViCdqJCn745zegoiQGBXwN+1pEhMxEL/+eX8A1e/UjN8X+xT0CwdIAGRsCZCR6YEiVmbhKS5GSfNIefxpy5sAhh1j4cXt1Dzz7bOtPUlNTq5TBotuSkqwEvaNTEI1xchVWRMaDNaoNPxyOZsnLy2PSpEkcf/zxjBkzhtNOO21T/P+7777LmDFjmDBhAq+88sqmc5588kkmTzYH75tvvsluu+3GjjvuyAEHHMDatWubuJrH7sKnTKl1hvv9sHRp85NfIMC6YG/e0UNYo31ZHBzGRnIJeD0wPAC9a+CWItg9lHeQkWFmqREj6kxyn5duz5T1x5HpLbWMa2DgsBXc8s9bGL3tz4wdO58//vkmRgxbzGsfHsVbHx6G1ggF/+hHxaxUvLmB0IpCYXA1JNh3tbEEPvRBZl+syE5C45/H67Ee368uKNy0LdkjDFgWoFQVSoKwogYWLKVi+WKS84vZ45VvrHbWcceZwpg3r+nvK1bsuCPceKMp9IICW72F/UVTppjPydEpaHZloap3tIcgju7L7NmzmTt3LgMHDmSvvfbis88+Y/z48VxwwQV8+OGHjB49mpNOOqnBcydMmMCXX36JiPDYY49x77338pe//KXxi23YAOvX15qfVqywMiDh1UBDiFAeTObyynv4ke34B79hJIvZqDloJvSq3IgMByYIHLACvh4Lw4c3ONSU9ceCKF6pLQg4YswiPJ4gZSXpqEdJzSxj5JZLWLlmMP+cegkPLroG8XtYfs4IBp2XT9J5G2BEBRQG4RHgP8IyAe94xZNF1IHrc9dVRH5I/v61j1Mn+ilMUChT1FdNIl7+MWc4SZnpdpgqLFoEJ5wAzz9fN8kxXpxzjvmeXnnFfBhjxsAxx8Q0As3RdppVFiLSB7gW2IaIdFFV3S+Ocjm6EbvuuiuDB5s9fNy4cSxdupT09HRGjBjBFltsAcDpp5/O1KlTNzt3xYoVnHTSSaxevZrq6mpGjBjR9MUqKswpLWJ3q6WlzRb886uXNfQjhQpSPFXcondxuL7JfnxISkYlxWdnkLl/CRIMQLKYlaiBxPI1Nb34vGx7Mj1ldbavXDoYQUlMrsQjCn5h+Q9DSCqsZuHSLViUMIoRugSvz0PaR71hQTrsNR8eE7tOAmhvtf5Eq7FVR2IAUltQyNAD2143mLw/r+ZVXyVzhiUzqqYPx63OYUBVhPlHxDLXS0qs6dRnn7VPo6hhw+Cqq+J/HUericYM9QywAMvcvgPzYXwTR5kc3YykiPwIr9eLP3SHX7+MdUNcdtllTJ48mR9//JEpU6ZQWdlMhZn09JCfQW2VEXZoN5GQVxDqRx0QmxTLJY0XPSdzsWcqlyc9yNrj+1E1KBnSg/DvbNCG5V5R3RcfAVMIESz9aRR/u/EaykvSKcrP5p4rbmH190MJFPjwBIOsCvYjMxNGj4LEBKBoPTwatH47mQIpwpAawe+FoAdTIIuroaLxntwKbN27XkjvCbnkXtCH89b5uP+XLZi8tG9dRRFJRoYlg+TlNXoNR88iGmXRS1WnATWq+rGqngvsHme5HN2cMWPGsGTJEhYtWgTAc8891+BxRUVFDAolZU2fHkUhutxc68ddXm5hsOFVRaTTuh4VmkQAD4vYvI/38oXDOOfwJ/ji1glwsQ/+1nhORRBPoxU4PnlnP87d71kuOOhpZn6yO4lJlp6RkAiDh3gYNizkJ6+uhjkFVkA24oa+T7Wwz3ooTqC2TfbKhvtVBFXxinD0mOzNdz69HpLSsDarUfDMM9Ed5+j2RKMswn+Rq0XkMBHZEYh9jJ2jR5GcnMzUqVM57LDDmDBhAsMa6Zl8++23c8IJJzBx4kR6946ir7OI1RiqqKh9H6YRc0oKlbzBkVRJw4pg9bKBrHhpGHzqhbLGa1UNSlhHjfpC+ijKAojiYWhSRJvRggKoFmhA8Vy8CBCoEUxhVAbtEYGqUlQZ4PAts+iTVn/VUALrFBKjzIhOTDQfgsMBiDZwp1XnAJHDgU+BIcBDWD3kO1T1jfiLZ4wfP15nzpzZXpfr9oQjlLot5eWw227W7CgyHFPVsrehVomoUkI6h+pbVHjSNxsqqEIJGcxIOoyhLLPxmqjA+rvkCzj0hhfZapufWLF4CFP+MJkfvmq4LUx5MJm+vgI+2vKiWp3288+hVrLAwCpTGGF94FGeGu7ljjFCYtBPahXIgETobUqwJqCUVAfYoV8Kzxw3ktSE8L2gkpd3DpMmPQrbV4AnNTo/RHm5rdLefLP5Yx2dEhGZparjYzFWsysLVX1LVYtUdY6q7quqO0ejKERkKxH5LuJRLCJXhtqxvi8iv4SeY9xBxtHjSU2Fm24yP0XYfwGmIMJmqXDpcZ+SPLyC5PQqCiSrjpUqqEKhZnO49z8M9USRSZzh5/ZpNzJii8UU5WfRd9BabvnnLfQbvGqzQ1WhMpjIxX1erhvVGwxphkoPLE+C0ggndmkiZ67amik/DGdgZRrFCVDg95NfUU1xVQC/Kufv1JtnNymKINYOtQQzO70Bu+7dTFvWCKqqYGLzjY0cPYNmlYWIbCkiM0RkTuj99iJyc3PnqepPqjpOVccBO2N9HF8FrgdmqOoWwIzQe4cjtowZA4MHm6M2GKqjEQjU9VskAiMgITXAc4NOZXz6TIolk0LNokgzKSaT43yvc0/CLXa8atORVeNLSEspI6FCCaiXirJUEhOr2evgT+scFlShMJDJARlfc0JOvV7UkT08ajywNhGWpMAvCcAgIIkDNmTxwZdb8dInA7mz75Hcus94Hvi/HL65YDA3TkwhJaEYCD/2Bp4EtgSGWcn2Rnw3dYUM2nGnNJF97ehRRBMT9yhwDVZ8B1X9QUSeBf7QguvsDyxS1V9F5ChgUmj7dKwTy3UtGMvhaJ4tt7QJcdgwM+sUFtaaoCoq7K65N5Dsh4DQ25fPC0NPYcHybfm+fBw+/Ozp/YoBsqZ2TNVmmx4JMChhPV6CbPBnE1APNeqlOugjgIfKYBIeUU7I+YDfD3ykTj4GYA76+n6CQMCSDCPauEpQGVeSyrhjp4QKHC4D5mEKAiAL2A4YGHqfZ0+77QY77wxff23jNRSRFgza93XiidZTpM1UAyuB4TTVg8PRuYnGZ/GNqu4iIrPDPblF5LvQiiG6i4g8Dnyrqg+LSKGqZkfsK1DVzUxRInIhcCFAv379dn7++eejvZyjGUpLS0lP39w+32kJBm2ir66215FmJZ/P6golNBAC+ssvdk5DYbOVlSBqpTTCKFDdxGJb1Zy+ja0uvArDKkN+BgEPBNTDsoXDqKpOwkOQLG8Zub5iEqThSKZNsoXLjoSvm5xcd2IPBCzxcOjQxseJoM5vHgxaufaKis0rvoZrY2VmmqKISdmPXzElNhjr7udoL/bdd9+Y+SyiWVlsEJFRhMI7ROR4LDUoKkQkEWswcENLBFPVqVg3esaPH6/d2iHbznR6B3dFBbz/vlWY/fZbWLXKlEEgYBNd2Jzk8ZiyCAZt/zbbwO67Wx+MLbe0SrE33VRbIyqSkhL49VcLUc0OWA2m/ATwNzI5hs0yW2/d9AQ6uhwuWQWjK2BFEjwyEH5ooWIuLbUSJWCKom9f6NevVo6iIjOxvfpq1OUwNvvNq6vhP/+Bf/4TFi607zIQgPHj4YILLKO6pc2iGuVM4GMsTeuYGI3paG+iURaXYpP2GBFZCSzBqrZFyyHYqiJc1GetiAxQ1dUiMgBY18S5jp7E0qXWHe2ZZ2wyC99RZ2c3f4fr98OPP8KsWTYBbrstnHWW+SzKy83pHUlGho1bUAAVzeQcqNok3b9/83IsTIWrR2P3Vq28K09Pt5pTv/5q7z2e2hLrXi8ceCD88Y9tq5uUmGjNoY480r6D8nJbTYTLpMSUR7BpY2wcxna0F9Eoi19V9QARSQM8qlrSwmucAkRmXL2Bdd37U+j59RaO5+hurFgBN98M//ufTczp6Y2XrG4Mn8/OAxtj/ny47jqb5EtKzOZf33w0YIBNktXVTTuuAwFTWtHkeWyijeYbVRg9Gu66y5o3lZXZ6uKgg2Lb1lXElE5cC/alYtWCHF2ZaJTFQhF5GXhcVee3ZHARSQUOBC6K2Pwn4EUROQ/zyp3QkjEd3YhgEF54Ae680ybsyNaabUHEVg5gjuz8fPNfDBtWVwl5vdZje9Eic4I3pDDCHfmGDm2/st1lZXbNZ55pn0J+DkcURKMstgdOBqaJiAd4HHheVYubPg1UtRzoVW/bRiw6ytGTWbECfvtbmDnTIozqm4liRVKSVYj99VdTGH362IoijM9nCiPc/S4yDyPcFGnEiIb7f8eDkhLzvzz1lFMUjk5FNEl5Jar6qKruiVWfvQ0r/TFdREbHXUJH92POHDjsMPMvZGc33VYzFng8NuEPHmzFBRctMidyOAEuIcEylRMTTWH4/bYvO9sc5S3osd1qwuGq6enw8suw007xv6bD0QKiKVHuBQ4DzsECpf+CVaKdCLyDZfs4HNHx7bdwxhl2195QlFI8yc01U9eaNRaeGu7OFjYv9e1rJqDKSivT3SIfRRuoqLBrHnSQ+Shcwx9HJyQaM9QvwEfAn1X184jtL4vI3vERy9FlCTuXi4stizpSIcybZ4oiGKx1Rrc3Ph8MHGjhp0ceaRnN5eVmfho82BTGnDlwxRWh0Nr0hnM4YkEwaN9TWhr8/e9w8MHt5xdxOFpIVD4LVW2wmIyqXh5jeRxdmXnzYPJk80d4PKY4zjrLopLy8+G008zEE3Y+dxQej60cXn/dnN5XXll3/3bbwbvvwkMPwWOPmTJJSDDneCwm86qq2qq4hx4Kt9/uVhOOTk80bVWjrDrm6NHk58Opp9rEmpFhk2ogYJNtaqrlQJSUtL/pqTE8HjNJ/f3vlrewTb3QzsREc8BfeKFVXZ0yxZIDg0H7PImJ0SsOVVOSFRW1JUMuu8zKaQyIskeqw9HBtEO/REeP4NVXzWkcqQy8XlMc999v5p9YKYpw7kRxcW1fba/XTEbZ2dGH3/p8NuFffrllMzfkaM/IMCV4yikWufXMM/Dll9bnOyGhNkfD46m9bjiJr6bGoqgCAVMwe+xhY+27b/yd+g5HjHHKwhEbZs9u+E5bxBzKw4a13YRTU2MrmI0ba2tERdZPKi6G1avNpNOrV3QTckaG+SYefhiuvrrx40Rgl13sAebzWLAA5s61z15UZCuHYNDMVampsP32lkm+9dbmC3H+CEcXJppoqCTgOCwSatPxqvr7+Inl6HIMHVpbhC6SsOmmmWqtzVJRYcXvAgG7g28s4zrcezs/3xRUerqtAoqKTIFEVG4FbAJPT4dHHjGz0OAom0BmZVkF1912a9vncji6CNGs118HjgL8QFnEw+Go5fjjzaxTXV27ze+3ukPZ2U2X02iOigpLmgsG7RpNmZnClWjBak3l59eGyq5cWWu2isTnMyXkKhs7HI0SjRlqsKr+X9wlcXRtRo6Ee+6B66+3XAW/3yboxMTo79Ybwu+3Sb+5xkP18XhMuawKdalTretXqE9ammVNX3ZZ+2VrOxxdiGiUxecisp2q/hh3aRxdm2OOgb32gvfesxXFI4+Y6actq4rCwtr6TC0l3FY1I8MUQFPO78RE83l88IFllzscjjpEY4aaAMwSkZ9E5AcR+VFEfoi3YI4uSt++cPrpsOuu5pBuS82nsP+hLY5hr7e2YmtzlWxFYNq01l/L4ejGRLOyOCTuUji6Bn4/5OXBJ5+YL8Dns3LZhx5qiWyRk/qsWQ37B1pC2JzVlpVJON+jsLD5xLe0NPjhY6jZChISsW7CZ7b+2g5HN6JRZSEimaHKsi3tX+HobhQUWFOiadMsvyHSLOT32/aRI+Gii6yEhs9HzRczSfC1MTK7tLS2hWpbEDG5m1MWngLwFsOiPjBGgN8DI7AyaA5Hz6ap/+ZngcOBWWze9kuBkXGUy9FZWLzYzEpr1tidd1bW5seoWq7CNdfAa6/x5TlTuPzfV/PCsDWMaEsjxLauTFo8VikEgfk1MCYd6xv9LU5ZOBxNKAtVPTz0PKL9xHHEk7fftjl9bLTdLVessJDY0tKm78rDuQqq8NlnjF53AWemjqJ/cmEsxI4NUfk9EiGg8G05HJONufQGxVcuh6OL0KiDW0Sa7d0YzTGOzsN118Ef/mB17JolGIRzzjHzTbR9mUUgO5vec/KYzN9J8VY3f05TtNWM1eKx+lrU1IJSbFUxCTg6djI4HF2Ypv6D3gGa68ASzTGOTsJf/2rtnKNKI/jyS8tviFZRhBGxqKN161of8homI8OioSLLerSWqD6HF2QoVPQFpmCtWmLQ5tXh6AY0pSx2EJGmWqcKdvvl6CIcdJA95+WFNlRXw4cfWue43FzrpxA2Nz3+eOsn6XAuQ1FR20pvp6ZasT6/v/XKIhi0c6NeHXmgOgkY07rrORzdlKZ8Fm24JXR0eubOtV4TxcW1lVNvu80eBx4IH3/c8lVFGBF7rF9fR1msq8nhztXnAXDLgGn0TShofpzeva04YGsJBm2MaCvRqsav2ZHD0YVxVWd7IsGgRTiVl9dVCDU1piyqq5uvwdQUYWVRXddnceuqi3i3eE+7lPp4ZNifmh8rO9uUTk1Ny30YYTNYS9qjqrZPz22Ho4vhDLI9kcJCc1zX71gX7kfd1oJ6kXfmEXkSNeqzoGsFv0Y58Xu9MGKEPbcklDZcAXf48JatFKqr7XoOh6MObmXREylromhwWhosXNi25jxhpRP2F4T4/cApm5TEHQOnRD9eUhKMGmUlymtqbMUTXr3UJxi0h9driqKl5UY8HitV4nA46hBNP4v7gCdUdW47yONoD7xem1AbIhCwxLuSEjumNaYokU0K4/2iXXlw3ckUBDI5MvtjHhl2NymeaGJ3IwgGTXltsYWtitavt1VG/exuEftsffqYr6Q1obdeL4xxzm2Hoz7R/DctAKaKiA94AnhOVYviK5YjroT7SzSkDEpLYfJkmD/fwqZa2wo1MZFPPfvwm2U34BM/Pgnwz/XH82vVAP4+7N7oxigtNed2ZaUpgqws61mdm2uro9JSW2mAKYa0tNr+360h3Ap1yy1bd77D0Y1pVlmo6mPAYyKyFXAO8IOIfAY8qqofxVtARxv45RfzP/z8s5ljDjvMwmNTU+GQQ+Ctt+x1crLdqRcXw6BBloy3YIFFRLUmfNbvh9RUHi04F48ESfdWAJAo1bxXsjsb/Vn08jVzv1FaankeUJurUVhojZBGj7aM8fT0lsnVHOGxnYPb4diMqGwMIuLFAs/HABuA74GrRcS1FuuM1NTA735nCuHJJ+Hrry2f4re/hT33tEnx/vvhxhstga6gwO7eTz4ZXn3V7tx3390cvcUtTKVRNRPWWWdR5s3Ao7WtVgVQhKpgFA7nNWvs2eut9U+EO/G1VKZo8fvh7LPjM7bD0cWJxmfxV+BIYAbwR1X9OrTrHhH5KZ7COVrJbbfBK6803OyntNQcxcuXw/nnw7nnmvJITq6bbe3xwBNPWBXZ4uLoci5U7e5//Hi45RZOXv4+1z3jo0a9+AhQEMhk+5SFDEzc0Pw4FRUNZ3+r2mdorXmsMfx+U0ZHHBHbcR2ObkI0K4s5wPaqelGEogjjwkY6GytWwIsvNt4VLj3dbPNTQtFIHo/Z+huamAcNgpdfNodxfr6tPhoiPIEXFsKECZb9nZjIcXftxGVZT1ETTKAgkMUeaT/yyLC7o/scTZm+YlkzKkxJiRVNjLVpy+HoJkTzX1cAbLIbiEg2MElVX3OO7k7Ia6/V9ptuDI/HzE233958oagRI6xc7bPPmhIoLq5tSKRq0VM+n4W2XnwxHH74psncM2gAVx29lMs+/D+qs/uQGm0UlIiZwjZurDVDQa3/JNarirCj/4wzYjuuw9GNiEZZ3Kaqr4bfqGqhiNwGvBY3qRytZ/Hi5h3S4RyIwkJrN9oc2dlwySVw4YXm9P7sMyvwF+6Ud8ghsO22DV/3xhvxffopPn9Jy3I3+vWzDPPKytoQWRHbHmsHdFERHHeci4JyOJogGmXR0C2qS+brrGRn12YvN0Ug0HxP6vr4fLD//vaIlpEj4dpr4e67a5P1osHrtdVKSYmZuLxe+2xRlcxtAWVltoq5+ebYjutwdDOi8VnMFJG/isgoERkpIvdj3fMcnZFDDrFJval2pIEA7Lxz6wsFtpSzz4ZttrE7+JYQrhY7cKCtKGKtKIJBi666//72+y4cji5KNMriMqAaeAF4CagELo2nUI42MH685Qo0Fl4arq80eXITg8wH7gUeBNa3XSav1ybkhASLcuoMqNaanyZM6GhpHI5OTzRJeWXA9e0giyMWiMC0aXDCCZb9nJpqd+SqtQqkXz/Ye+9GBpgDnACEJ/XnsB5XOW2Ta+RIeOQRC9f1eGK/SmgJqpZbsttucOedHSeHw9GFaHZlISJbishUEXlPRD4MP9pDOEcrGTjQIpiuucb8Evn55syeNAmeecZCYRvlaaAK6B16rAfyYiPXPvvAAw/Y6qKxMNx4E84F2WEHU6odqbQcji5ENI7ql4BHgMeAKDynjk5Bdjb85jf2qN+fYlOrvIbY/E9C1ctHH8H06bB2LeyyC5x3nhV1bTGHHmoT9CWXWKZ5/TLp8SQQMNPTHnvAo4+2vCKtw9GDicZn4VfVf6rq16o6K/yIZnARyRaRl0VkgYjMF5E9RCRXRN4XkV9Cz220bziaJTGxBdVjzwHSsKouG4Gh3HffflxwAXz+uSV+P/uszfnffttKefbfH154Afr2NXNQNNFbbaWkxB7nnmuZ6U5ROBwtIpoZ5E0RuUREBoQm+lwRibax8gPAu6o6BtgB85xeD8xQ1S2wEiLOH9KpGA28DdwK3MXCha8xdWo6mZlW9DUlBXJybH6/9tqmg64A+OknuOkmW4q89FJtldhx4+C99yxSKjyRx4NAwBRS376W2X7zza3v1REIWGHGgw6yvJJDD7UkyMbKvTsc3YhozFBnhZ6vidimwMimThKRTGBv4GwAVa0GqkXkKGBS6LDpmEH8umgFdrSNcBDQscdaW4iJE81SNWRI5FFDgXMBePfd2oTtSNLT4ddfYdkyGDaskYvNnGntW2tqbICPPoIPPjBHt4hpnltusWq4V10Fq1aZgJmZrW/pGqaysra+1DnnWBHFluaVRBIMwuWXw3/+Y2a0pCRLgPztb+Grr+CPf2x9aXSHowsg2uytYSsHFhkHTAXmYauKWcAVwEpVzY44rkBVNzNFiciFwIUA/fr12/n5trb6dADmc/B4Slm3Ln1TIrfHY32FGuo+um6dndNQOaZAwM5r1Ee8eLFlYUdqmkCg8TLgpaWWGV5aau9FWqY0VGvv8sO9t3NyYlNLKlwyvaEaWoGARXt1YtNWaWkp6a7uVY9j3333naWq42MxVlTKQkS2BcYCm/7DVfWpZs4ZD3wJ7KWqX4nIA0AxcFk0yiKS8ePH68yZM5uVsyfw3ntWUPaSS2D77Vt27saN5tu98so8Hn980qbt+flWnfyPf9z8nG+/hZNOspv9yBvn8nLb9vnnTczn229vOyMn6+Ji+Mtfmq7uumqVmXs++MB6cng8pggiW6qqUhxI4+eaEUiCj63kZ9J7JcFOO9mH2Xvv2BYcvPRS+O9/G65LlZ8Pp53WqcNw8/LymDRpUkeL4WhnRCRmyiKaEuW3YWajsVjA/SHA/4AmlQWwAlihql+F3r+M+SfWisgAVV0tIgOAda2Uvceharl0lZVWXPatt1p2/pw5tXNtJGlp8MknDZ+z447mj37vPbPiJCZahQxVuOOOZm78x42zOlI5oXuBYNBO3HrrpgUdOBCuvtoefr+tUObPt4ZMJSUUFwT407cH8cov20GCFzQJSUjk+EN8XHddnArH5uc3rny8XtvvcHRjolnjHw/sD6xR1XMwk1KzwemqugZYHuqwR2iMecAb1PpBzgJeb6nQPRUR613k9TaRU9cEOTkN+2Jrasxi09g1H3rIfNS5uVBVZTfvTz9tTfea5IYbzDRTUGCTaXExnHiimaGixeezAn9HHQXXXUfp9X/gpMV38/zafUke3Jv0QTmk90klKc3HM8/AKafYqifm7LprrXO+PqoWT+xwdGOiWadXqGpQRPwhp/U6mnFuR3AZ8IyIJAKLsbhMD/CiiJwHLMPShR1R8vjjNu/26tXyc7fd1pzRgUBtte9AwObA889v/LyEBAtmOu+8Fl5w663h/ffNbrZ+Pey7b5tLazz+uC0wcnPrrpB8PlOGc+fCv/5lBXJjysknw2OPmSaK9E2UltpS5uijY3xBh6NzEY2ymBnqYfEo5qQuBeo3QWoQVf0OaMhe1oKypY5IPJ7GVwEAK1fCn/5kc9hll9kqIPLcadPM9F5SYu8DAYuGOuywOAncv785WGJAIGApEunpDQceidg8/thjtVVFYsaAAXbxCy+s7enh81k88bRpse+x4XB0MqKpDRX+T39ERN4FMlX1h/iK5WgNquZnXbbMJsqvv7Zo1b59a48ZOtQimF56yaxD227btPLpTBQWmhLMymr8mORkc+SXlcUhOXzXXS1M9uOPrUf44MEWe9xQGJnD0c2IxsE9Q1X3B1DVpfW3OWLHo49aSY0xY+DPf671C0dLebkpipwcu8suK7Noz0hlEWaHHWIicruSkFDrI28spUHVHnGbv5OSLCnP4ehhNLpQF5HkUKZ2bxHJicjeHg4MbDcJewjffgv33mt3zzNmWK+glpKaCtttZ3fWGzfaXXZ3av6WmWmfL5yG0RAlJbYAiHUzPYejp9PUyuIi4EpMMcwCwvdyxcDf4ytWzyMceZmUZBFHq1e3fAwReOopM6GXllpL6e5mSp88GS66qNZlEInfbyuPGLlIHA5HBI0qC1V9AHhARC5T1YfaUaYeyZ57mi9h4UKbBJvsTdQEWVmWntBdOeAAuOIKC+cNBi1HBMzk5vFYVfbWhBU7HI6miSYaKigi2apaCBCqEnuKqv4jrpL1IJYvt9y1iy6yoJsRI5ppOdHDufxy8ys/8YRlkIuYEjn77JZntTscjuiIRllcoKqbzE6qWiAiFwBOWcSA116z6q2BQG05o3//u6Olio7yckuszshof9/Ijjvaw+FwtA/RRKJ7RGpjT0TEC7SyxrMjkvJyy4xOSrIIpsxMi8j82986WrLmWbfOMrhPO81yNP7wh46WyBEPgkErLeOqsDuiURb/xTKu9xeR/bCmzO/GV6yewZIltqKIrNqammqmlc7OAw9YAmB6uq0spk+31hWO7sXVV1vS/e9/39GSODqaaMxQ12GRUb/BIqLew1qsOtrIoEF2xxYZ2VNRAXvtFbtrVFXZpJ6bG9vIqPXra6t1ezz2uqgoduM7Ogfz5tnf0Ny5HS2Jo6OJJoM7KCJPAh+qqrt3jCHZ2Rbm+fDDpjTC5SpiFc20YAGceaZN4qrWJO7MM2Mz9jHHWD5IuPJFv34wdmxsxnZ0Hh55xBpgNVVR3tEziCaD+0jgz5ifYkSoqdHvVfXIOMvWI7jiCksie/ddKw54wglWoTsWXHihJfllZlqxwDvvjF1x1EMOsfDVl16yyK0rr4xTaXBHhzJypMtbcRjRmKFuA3bF2p+iqt+FsrgdMSBcdnzPPWM7blWVheTmhrqlJyTYtRYtit2kfuih9nA4HN2faBzcflV11uguRmKi1YQqK7P3fr+ZooYO7Vi5Oiv5+aZc49Rl2OHo8kSjLOaIyKmAV0S2EJGHgC4Qr9OzETF7c1KSlf4oK7NkNpe0tjmff25BBfvu23BrWYfDEZ2yuAzYBqjCwmaLsZpRjk7OjjvCp59aO+uPPrL+Fo7NefRRW3llZFgvDJdT4HBsTjTRUOXATSJyj73VkviL5YgVmZnWCjsSVZg503p5jx1b69doKX4//O9/lrSVlQWTJsWhh0Q7MG4c5OWZKWrMmBg3TXI4ugnRREPtAjwOZITeFwHnquqsOMvmiAMlJbB4Mdxzj02KSUnWT7ul5qnPPzezVkmJKQ2v1x5XX21d6hrrN9EUlZVw1lkWHfbb37b8/NYyebI19Fu/3rqnOhyOzYkmGmoacImqfgogIhOAJwBn/e6C3HefhbpmZNiEXloKF1wAX34Z/QT/ww9wzjmmHCJXEjU11tI1Kal1+RxVVfDdd5CS0vJz24LXCyed1L7XdDi6GtEsuEvCigJAVf8HOFNUOxAM2p17dXXsxvz2W1MKYcWQng4bNlg+RrTcf7+VKUlNrbs9IcG2/fWvrZM5KwtmzTIfgsPh6FxEoyy+FpEpIjJJRPYRkX8AeSKyk4jsFG8BeyLz5sF115n9fNw42GorOPBAq0ZbXt62sYcMqRseWl1tk3xmZnTnV1TAJ580fnxSkh3z7betky893bW0djg6I9GYocaFnm+rt31PQIH9YilQTyYYNF/CtGk2oWdkWM0oVXMiX3+93bX/61/W86I1XHcdvPOOrSbAxr/33to6T81RWWmrkqacwCJtV2oOh6NzEU001L7tIYgD/vIXM8FkZdWdvEVqO8KtW2f29bfesqS7ljJsmHXku/lmy72YMAF23jn687Oy7FFVVbdabhhVc3iPGtVy2RwOR+elWTOUiDwtIlkR74eJyIz4itXzWL4cpk7dXFHUJyvLonYeakOjW5/PIpauuAJ22gl+/tkc3EuXNn+uxwPnnWeKpqFs58JCqz81bFjr5XM4HJ2PaHwW/wO+EpFDQx3y3gf+FlepeiDPPWdmqGjMQVlZ8PLLFsnUFv73P/OFHHaYRTcdeCAcfbRFOzXFeedZeGtBgZmbgkFbaeTnW6e/++5rm1wOh6Pz0ayyUNUpwPnA68Dvgb1V9c14C9bTeOWVzaOLGsPnswn6iy9af70ZM0xBrFhhzuq0NHueN8/MXN991/i5SUnw1FPWHa9/f4vYSk62fIV33rE+HT2J//4Xzj23azStcjhaSzRJeWcAtwBnYrkV74jIOar6fbyF60kUFzfsA2iMcFhta7n++tpQ1zAipjCKiqy8+bHHmu/hsMM2V2SJiXDqqfboydTUmJIMBCwCrCkl63B0ZaKJhjoOmKCq64DnRORVYDq1UVKOGJCSYhNPtFFJHo/dzbeGsjJTTg2V5lCFjRvNf7FqlV3j73+3lU9ry4J0Z7xe888sWQJbbtnR0jgc8SMaM9TRIUURfv811t/CEUMmTaotJ94cwaA9dmpllkt1tUUslZdbTkSko7q42OTwes00lZ0Ny5bBk0+27lrdHY/HFOnTT7vvyNG9aVRZiMiLEa/vqbf7rbhJ1EM5+2ybeKLpp1BUZOW0+/dv+XUCATNfrVhhNaIWLYKffqrtn11eXitDuC94UpKzxzdFZqY1r4rW5+RwdEWaWllsEfH6wHr7+sRBlh7NttvCPvtYhFFTCqOiwnwNV17Zuuv8/vemGMKJdV6vKZBly2x72G/i89WauaqqnInF4ejpNKUsmrrHdf3EYowIPPgg7L67KYz6eQx+f60iefRRKy3eUlavhmeeMUUwYIApCVVTGh4PrFljjmuPx0xQFRUWDpuWZsUGHd2f8nLL0nc46tOUgztVRHbEFEpK6LWEHu1cF7RnkJoK06dbDahHH7VEvbDDW9VCWs8/H0aObN34n39eW0CwVy97XrPG/B+qtoLweODxx+HXXy00d+xYi4xqbXkRR9ehutrMaX36wPvvd7Q0js5GU8piNfDX0Os1Ea/D7x1xICHBeiqcdBL88outJhITLYQ12mJ/jRFeSYTp1Qtyciy5z++3aKxXXrECho6eh9drRSt79+5oSRydkUaVhasJ1bGIxN5PMH785ts8HlNClZUWvrvFFpsf0xbmzLFEvcREOO44q3rbEKWldmxmJmy9deuaJznahtcLL7zQ0VI4OivR5Fk4ugkjR8IBB9gKIxisrRxbU2P+iRtvjD7PIxq+/NI631VV2YrmiSfg9ddh+PC6xz37LNx5px0TDMLo0dYLe+DA2MniiJ6iIvv+x46FQw7paGkcnQXXbbiHcf/9VluquNhCaMPNla69Fk45JbbX+vOfTQH07m128OJiK78eyezZcNttZn5LT7dEwZ9+gosuii6M2BF7Hn7Y/k4uu8yCIhwOiPPKQkSWYl31AoBfVceLSC7wAjAcWAqcqKoF8ZTDUUtKipmCPv4Yvv/ezEO7724TdawpKanbyMjr3bxEyQsv2GoiMdHei1gi4IIFlhXdWme+o/VsuaWFUPfu3XY/maP7EE2JchGR00Xk1tD7oSLSkgzufVV1nKqGLebXAzNUdQtgRui9o50ZNAgOPdTMUvFQFGAVbCsqzAwVzhQ//PC6xxQUbN5IScQUS1ur6vY0vvvO6lSNGWMBEQcfbJF1LW1xe8IJVmjyvfdq+6g4HNGYof4B7AGEjRQlwN/bcM2jsNpShJ6PbsNYHcKGDVYi/I03XEe4prj4Yrj8clvN5ORYF8ADDqh7zEEHbR6lVVlpd7YuKit6nn7aJvl337VkyqwsS7S85ho444yWm/SGD3erCkddRJv5KxKRb1V1JxGZrao7hrZ9r6o7NDu4yBKgAEvim6KqU0WkUFWzI44pUNWcBs69ELgQoF+/fjs///zzLflccaOmBhYutAkObFIbNarpNqOdjdLSUtLjtZxoIapmbqqvdIcOdZNVtFRUWNkWj6fhKLJAAAYOLCU3t3P85o72Y999950VYdVpE9H4LGpExEsoa1tE+gDBKMffS1VXiUhf4H0RWRCtYKo6FZgKMH78eJ00aVK0p8aVP/0JpkypTWorLLR2qEcd1aFitYi8vDw6y/cJsNdelgT2wQfWKvb442MfwtudueQSMxllZze83++HCy7IY//9J5GV1fAxDkdzRKMsHgReBfqKyF3A8cDN0QyuqqtCz+tCpc13BdaKyABVXS0iA4B1TQ7Syahv/1VtuU3YUZfEROuZcdhhHS1J12TGjIbLzYcJF4ScORP23799ZHJ0P5qqOjsCQFWfAa4F7sayuo9W1ZeaG1hE0kQkI/waOAiYA7wBnBU67CysA1+X4fjjzSa8caM9srOtvLjD0RGommk0GjOou6lxtIWmVhYvAzuLyAxV3R+I2oQUoh/wqpgR1Qc8q6rvisg3wIsich6wDDihFXJ3GGPHWoTJSy+Zv+LMMy2HoD3Jz7e78U7idgAsh+KVV6xb3JZbmrO1X7+Olqr7I2LhxStXNh65pGqPUaPaVzZH96IpZeERkduALUXk6vo7VfWvDZwTuX8xsJkTXFU3Al16MTx2rCWStTerVll00ezZNkkcdRTcdVfTHfNU4186Y80aOOYYWL/ervX22zB1Kjz/fHTVcf1+UzZg5pTI3AxH81x4IdxwgxWibOi3Li62vxFXZt7RFppavJ4MVGIKJaOBh6MdUbWs5tmzzfSVmQmvvmpZ0g1RVGQNlUaNgl13hc8+i59s999vCiM720I2c3IsQueWWxo/JxiEr76yiW7MGNhtN3tstRWce65VyA1GG0bRwzn6aBg3znJWwlF6YH8zRUWmfAcP7ijpHN2FaEJnD1HV/7STPA0yfvx4nTlzZkeK0OEsW2bOyczM2rvHmhqbEH74YfPjf/Mbi7nPybG8BVX48EPrYxHraKgdd7RJKpyFDXa9ggIrDli/g9zPP1sOxooVphAyM2tt7sGg3QmLWCfARx6BbbaJmajdlvJya2z16qu124JBU75/+hNs2NC5IuAc7YOIxD90VkROV9V/AWNFZOv6+5szQzlii8+3eWKVauOF/778snYSTk21bOiffzZlEWvS082PEkkwaDL76v2Fff89nHqqKbqMjM3NJh6PrVBUYd06CyiYPt1WR47GSU01pXDddRb1VFNjvoxwYmNeXoeK5+gGNGWGCrvL0tncBNWJXKs9g4EDYeed7W49GLTJoLTUHOwNMXRobaKb3293/vFQFGAZwhUVtWajsPnjqKPqrjZWrDB5A4G6K6SGEKlVJueea/3CHc2TkwMHHmilXFwGvCOWNNXPYkro+Y76+0TkyjjK1CaWLzfH6qxZNmmNHWvVVLuDc++f/4SbbrIErMREa3U6eXLDx953n93Bl5TY5HzFFfH7Ds45xwr/vfGGrSQCAStOeOutdY/7xz9Mntzc6MdOTbVVywMP2MPhcHQMzfosGjxJZJmqDo2DPA0Sjc+iutr6Mbz+ut3hhiNqamrs7nTiROtx3VTyUlfB76/tm90UZWVWBqJXLyscGCZeGdzLlll3v0GDNr+rLSmBXXaxqJz6pqnmCATss3z5ZcsUjaOWzpa172gfYumzaG1Fo07VxywYtDvsV14xZZCTY3b09HR7nZUFn3wCp59u5pKujs8XXRJWWhpsv31dRRFPhg41J3xD5o+33rJJv6WKAswvEwza7+twODqG1iqLTtWW5oMPrORBTk7Dk2i4R8KPP8Jzz7W7eA7M6dqWZkYeD3zzTezkcTgcLaOpch8lIlLcwKME6FQNL6dMsbvP5hymKSnw6KPdN34/GLTEvfqRSZ2BoqK2Veb1eGoT9xwOR/vT6L+vqmaoamYDjwxV7TS9u0tLrelLNL6IlBSr57RoUdzFapZXX4WHHrIciFhQWgonnQT77GNhpn/6U+dqS5qe3jZ5gkHXiMfh6Ei6UBeGhikvb35VEYnX2/F+i8WL4Xe/g3vvjZ0d/m9/M1NPZqYpzscesyzozsJWW7VNWQQCLhTU4ehIuryyyMiwiSQa05KqRRJ1dE3/3r2tyF5qauwmwAULLJw23JJUFX79NTZjx4JjjzXZWmMCDAbNDHXiibGXy+FwREeXVxYpKbDvvtHZs8vLYcQIi9ppDcuXW6OZG25om/08M9MyamfOhJ12av04key6q4UJB4MWRuzxwNab5d13HP36Rf871aekxD5fa383h8PRdrq8sgA47zx7jiyiVh9VqKqyYnytrcJ69dXwzjvw7LNtTxBLTIxtzsfFF1vl16IiUxp33GE1mzoTl11mSqyqKvpzwj0YrrwyLiI5HI4o6RbKYvfd4ayz7K61oQYvfr+1Pz34YJtQW0sgUKto/P7WjxMPEhOtvesvv8C8eZa93dnYbjurkltREZ1jv6rKkvHuvNMS+hwOR8fRaaKa2oII3Hyz9W9+8EG7uw6vMrxee5x3Hlx7bdvCN//8Z+tjkZlp5TM6I235fO3BUUeZr+aKK0yBJyWZKTGSykp7+HzmuD/iiI6Q1OFwRNItlAWYwrjoIitU9957VrZbFUaPhsMPtwm+rYwaBf/6V9vHaQmrVllkU2qqfb7uUK7kwAMtUuu11yxHJj/flFy4o1tWlimT445z5T0cjs5Ct1EWYVJS7O71qKM6WpK2owqnnQZLl9r7BQtMcXQHsrOtOdOZZ9rnKiys3T5mTOdfITkcPY1upyy6EzU1sGSJ3V3X1FgjoRZTWQkvvABPPGHt7AYOtEJa1dV164d3EB5PdK1XHQ5Hx+Lu3zoxiYmWn1BSYnP+Oee0cIDKSlua3HGHdRJKSTGFsWqVDdZQNIDD4XA0gFtZdHLCfSlSUlrRXnT6dGvanZNTG8aVmmoe/y++sBXHGWfEXGaHw9H9cCuLGFBcDLffDnvtZW1Av/wydmN7PDB+fCv7UD/xhCmHhhJLkpNh2rQ2y+dwOHoGTlm0EVULy50+3ZTGDz+Y0/bHHzuBYGvWWGxqQyQnw8qV7SuTw+Hosjhl0UYWLrSqt7m5Ni9nZlqOx9NPd7BgIlaEqjG/RFWV1eBwOByOKHDKoo1UVpqpKNLSI2KZxx3OmWeaIA2Ve62osLR3R5sIBs398+qrsGJFR0vjcMQP5+BuI2PHQp8+ZvHJyrIQV7CEsg7n3HPhP/+xRIb0dAuvqq62pc9221mklKPVlJdbfMAPP9Ruu/1297U6uiduZdFGvF546imr8FpQYHea119vFVbbi+pqS2qbNs2qsx58MMydiymIF1+0dGifzzo/JSWZ+em558z53QzvvGNRthdcAJ9+2rwsJSVWTbcnROW++KIFm2Vm2o1Cair8/veds1Ohw9FW3MoiBowcCW++aRNlSorNy+1BRQXccw88/7xdOz/f9EBhoVmYvv4aPBkZVrL1yittReH1Wn30KBTFCy/AjTfW9sfIy4N//hMOOKDh44NBK9S4ZAlMnAhPPhmzj9op+fxz+63DJsiEBFOSCxbAnnt2rGwOR6xxK4sYkpHRfooC4KqrbFWTnGyPQMDMYWCKY7PKrl5vi8b/y19M+YXvnL1e29YYNTVWmkQV5s9v0aW6JNtsU7f6cCBg74cP7zCRHI644ZRFF2XpUvjgA8u38/msP7XXaxPWihV2ZxvF4qFJysvrKj+fz7Y1RlKSVf2dNMn6i3d3zjgDBgywldyGDba6O+ssq6jicHQ3nBmqi7JoUV0TSGKiVdjNz7c7/Ecfbfs19t/fzGs5ObZaKCuDU05p+pxDD7VHTyA31+IH3nzTuihOnOjMT47ui1MWXZRBg2wVoVqrMJKSzFzUv//mPSJaw113mYL48EN7f+yxcM01bR+3O5GZ6aKfHD0Dpyy6KFttBePGwbffmoLweGxFUVkJl14am2ukp1tJ9IoKG7+xZHCHw9H9cT6LLoqINQ6aONFs5aWl5ly97jpbAcSSlBSnKByOno5bWXRhcnMtPHXNGvNVDB/edqe2w+FwNIRTFt2A/v3t4XA4HPHCmaEcDofD0SxxVxYi4hWR2SLyVuh9roi8LyK/hJ5z4i2Dw+FwONpGe6wsrgAi83mvB2ao6hbAjNB7h8PhcHRi4qosRGQwcBjwWMTmo4DpodfTgaPjKYPD4XA42k68Hdx/A64FMiK29VPV1QCqulpE+jZ0oohcCFwI0K9fP/Ly8uIraQ+itLTUfZ9tpLLSwpe7Skix+80dbSVuykJEDgfWqeosEZnU0vNVdSowFWD8+PE6aVKLh3A0Ql5eHu77bD2LF8Mhh9jrGTNg8OCOlSca3G/uaCvxXFnsBRwpIocCyUCmiPwLWCsiA0KrigHAujjK4HDEnORkq8Xl8dhrh6MnEDefhareoKqDVXU4cDLwoaqeDrwBhPt5ngW8Hi8ZHI54MHCgNYL69FNrc+5w9AQ6IinvT8CLInIesAw4oQNkcDjaRHZ2R0vgcLQv7aIsVDUPyAu93gjs3x7XdTgcDkdscBncDofD4WgWpywcDofD0SxOWTgcDoejWZyycDgcDkezOGXhcDgcjmZxysLhcDgczSKq2tEyNIuIrAd+jcFQWUBRO54f7fHNHdfa/Y1t7w1siEKu9qatv088xm3NudGc09ZjWrrP/ebxPb+z/q9vpaoZDWxvOaraYx7A1PY8P9rjmzuutfub2D6zo3+LePw+8Ri3NedGc05bj2npPvebx/f8nvC/3tPMUG+28/nRHt/cca3d39bP297ES962jNuac6M5p63HtHZfZ6Mz/uatOb/b/693CTOUI7aIyExVHd/RcjjaD/eb90xi+bv3tJWFw5ja0QI42h33m/dMYva7u5WFw+FwOJrFrSwcDofD0SxOWTgcDoejWZyy6OaIyOMisk5E5kRsyxMR5+zsRjTyO+eKyPsi8kvoOSe0/WwRebjjpHW0lpb8zqF9N4jIQhH5SUQOjthe2tJrO2XR/XkS+L+OFsIRd55k89/5emCGqm4BzAi9d3RtniTK31lExmJdSrcJnfMPEfG29sJOWXRzVPUTIL+hfSLiEZHpIvKHdhbLEWMa+Z2PAqaHXk8Hjq5/nogcJiJfiIhrENsFaOHvfBTwvKpWqeoSYCGwa+SJItI79Psf1ty1nbLoufiAZ4CfVfXmjhbGERf6qepqgNBz38idInIMdhd6qKp2xlIgjuho7HceBCyPOG5FaBsAItIPeBu4VVXfbu4iHdGD29E5mAK8qKp3dbQgjg5hX2A8cJCqFne0MI64IA1sC+dKJGAmq0tV9eNoBnMri57L58C+IpLc0YI44sZaERkAEHpeF7FvMZABbNkRgjliSmO/8wpgSMRxg4FVodd+YBZwMFHilEXPZRrwDvCSiLgVZvfkDeCs0OuzgNcj9v0KHAs8JSLbtLdgjpjS2O/8BnCyiCSJyAhgC+Dr0D4FzgXGiEhUgQ9OWXRzROQ54AtgKxFZISLnhfep6l+Bb4GnRcT9LXRhGvmd/wQcKCK/AAeG3m9CVX8CTsNuGEa1t8yOltOS31lV5wIvAvOAdzGTUyA8Vuj1yZiF4ZJmr+3KfTgcDoejOdzdpMPhcDiaxSkLh8PhcDSLUxYOh8PhaBanLBwOh8PRLE5ZOBwOh6NZnLJwxBwR6Sciz4rIYhGZFao9c0xo3yQRKRKR2aFKmJ+IyOER594uIitF5DsRmSMiR7aDvAki8qdQ1c45IvK1iBzSyrEuFpEzQ6/PFpGBLTz/SRFZIiIX1x8vyvMnichbDYx5fOj14aHv/nsRmSciF4W2R37vv4jIK6FCdOExnhGR/PA4jp6HS8ZyxBQREeA1YLqqnhraNgyInPQ/VdXDQ/vGAa+JSIWqzgjtv19V7xORrYFPRaSvqgZjKJ/UG+9OYACwrapWhWrm7NOa8VX1kYi3ZwNzqM2ajZZrVPXlBsZrEyKSgLXZ3FVVV4hIEjA84pD7VfW+0LEnAR+KyHaqul5VTxORJ2Mli6Pr4VYWjlizH1AdOcmp6q+q+lBDB6vqd8DvgckN7JuPlSWoUxE1dBf8tIh8GLoLviBi3zUi8o2I/CAid4S2DReR+SLyDywJcUjE8anABcBlqloVuu5aVX0xtP+fIjJTROaGxwttXyoi94RWIV+LyOgI2X4XugMfDzwTultPEZFbQ7LNEZGpIcXVJOHxQq/zIq75s4hMbO78emRgN4gbQ5+zKpSYtxmq+gLwHnBqC6/h6KY4ZeGINdtgE3JL+BYYU3+jiOwGBIH1DZyzPXAYsAdwq4gMFJGDsJIGuwLjgJ1FZO/Q8VsBT6nqjqr6a8Q4o4FlTRTTu0lVx4eut4+IbB+xr1hVdwUeBv4WeVJoZTATOE1Vx6lqBfCwqu6iqtsCKcDhtBxf6JpXAre15ERVzcdKQPwqIs+JyGnNZO43+Ls4eiZOWTjiioj8PWQf/6apw+q9v0pEvgPuA07ShssMvK6qFaHS2h9hCuKg0GM2tRPdFqHjf1XVL1vxEU4UkW9DY24DjI3Y91zE8x5RjLWviHwlIj9iK7DW1GR6JfQ8i7ompDCNlWRQAFU9H9gfqxH0O+DxJq7V7MrH0XNwPgtHrJkLHBd+o6qXijXWmdnEOTsC8yPeb7KdN0H9SVGxye1uVZ0SuUNEhgNljYyzEBgqIhmqWlLvvBHYhLqLqhaEbPaRVXq1kdebIVbd9x/AeFVdLiK31xsrWqpCzwEa/v/dCOTU25YLbOpXoao/Aj+KyNPAEsy30hA70vTv5uhBuJWFI9Z8CCSLyG8itqU2dnDIrHML8PcWXucoEUkWkV7AJOAb4L/AuSKSHhp7kIj0bWIMVLUcq8D7oIgkhs4bICKnA5mYkikKOb3rR0idFPH8RQPDl2B+AqhVDBtC8sUrqugXYGAoOCAcXLAD8J2IpIvIpIhjx2HVZzdDRI7DVmnPNbTf0fNwKwtHTFFVFZGjgftF5FrM31AGXBdx2EQRmY0pkXXA5RGRUNHyNdblayhwp6quAlaFJskvQr7jUuB07C68KW4G/gDME5HKkLy3qur3ITnnYv0fPqt3XpKIfIXddJ3SwLhPAo+ISAVmpnoU+BFYiim3mBOK5jodeCK0mqkBzlfVIhHJAK4VkSlABfY5z444/arQuWlYFNd+qtqQv8jRA3FVZx1djpAJpzQKU1U8ZViKmZRi2o40ZOp6Kxw625nozLI54o8zQzkcnYsi4E4JJeV1FkTkGSz3pLKjZXF0DG5l4XA4HI5mcSsLh8PhcDSLUxYOh8PhaBanLBwOh8PRLE5ZOBwOh6NZnLJwOBwOR7P8P/kDUrZz++SXAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Scatter plot\n",
    "plt.scatter(x = gdp_cap, y = life_exp, s = np.array(pop) * 2, c = col, alpha = 0.8)\n",
    "\n",
    "# Previous customizations\n",
    "plt.xscale('log') \n",
    "plt.xlabel('GDP per Capita [in USD]')\n",
    "plt.ylabel('Life Expectancy [in years]')\n",
    "plt.title('World Development in 2007')\n",
    "plt.xticks([1000,10000,100000], ['1k','10k','100k'])\n",
    "\n",
    "# Additional customizations\n",
    "plt.text(1550, 71, 'India')\n",
    "plt.text(5700, 80, 'China')\n",
    "\n",
    "# Add grid() call\n",
    "plt.grid(True)\n",
    "\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interpretation\n",
    "- If you have a look at your colorful plot, it's clear that people **live longer** in countries with a higher GDP per capita.\n",
    "- **No high income** countries have really **short life expectancy**, and **no low income** countries have very **long life expectancy**.\n",
    "- Still, there is a **huge difference** in life expectancy between countries on the same income level. \n",
    "- Most people live in middle income countries where difference in lifespan is huge between countries; depending on how income is distributed and how it is used.\n",
    "- The countries in blue, corresponding to Africa, have both low life expectancy and a low GDP per capita."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recap of lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop = [30.55, 2.77, 39.21]\n",
    "countries = [\"afghanistan\",\"albania\",\"algeria\"]\n",
    "alb = countries.index('albania')\n",
    "alb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.77"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop[alb]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This way of extracting values is not adaptable because:\n",
    "- Not convenient\n",
    "- Not intutive\n",
    "\n",
    "Solution is **Dictionaries**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'afghanistan': 30.55, 'albania': 2.77, 'algeria': 39.21}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "world = {\"afghanistan\":30.55, \"albania\":2.77, \"algeria\":39.21}\n",
    "world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.77"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "world['albania']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'afghanistan': 30.55, 'albania': 4.67, 'algeria': 39.21}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "world = {\"afghanistan\":30.55, \"albania\":2.77, \"algeria\":39.21, \"albania\":4.67}\n",
    "world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'hello', True: 'dear', 'two': 'world'}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{0:\"hello\", True:\"dear\", \"two\":\"world\"} # accept different type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-24-2f5426a4b4fc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;33m{\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"ali\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Qasim'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Hassan'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;34m\"Names\"\u001b[0m\u001b[1;33m}\u001b[0m \u001b[1;31m#Keys have to be \"immutable\" objects ->> Error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "{[\"ali\", 'Qasim', 'Hassan']:\"Names\"} #Keys have to be \"immutable\" objects ->> Error "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Names': ['ali', 'Qasim', 'Hassan']}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\"Names\": [\"ali\", 'Qasim', 'Hassan']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "world['Pakistan'] = 19.60  # adding values in dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'afghanistan': 30.55, 'albania': 4.67, 'algeria': 39.21, 'Pakistan': 19.6}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'afghanistan': 30.55, 'albania': 4.67, 'algeria': 39.21, 'Pakistan': 19.8}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "world['Pakistan'] = 19.80\n",
    "world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Pakistan\" in world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(world['afghanistan']) # will delete afghanistan and slide all prior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'albania': 4.67, 'algeria': 39.21, 'Pakistan': 19.8}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "world"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List vs Dictionary\n",
    "\n",
    "<img src='./media/ListVSdictionary.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src= './media/Pandas_logo.png' width=500px, height=300px>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas part1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- tabluar dataset of temperarue measurement at some company\n",
    "<img src='./media/Tabular_dataset.png' width= 500px height=300px>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- population dataset of BRICS countries\n",
    "<img src = './media/brickscountries.png' width=500px height=300px>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question: How can we store that data in python ? \n",
    "- Numpy Array (absolutely **NO** because in Numpy we save data of same type)\n",
    "<img src ='./media/NumpyQuestion.png' width=400px height=300px>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer:  Pandas\n",
    "- high level  data manipulation\n",
    "- Wes Mckinney\n",
    "- built on Numpy\n",
    "- Data Frame\n",
    "- special concept of Series\n",
    "<img src = './media/bricks_countries.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### lets create this table...!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "bricks = {\"country\": ['Brazil', 'Russia', 'India', 'China', 'South Africa'],\n",
    "         \"capital\": ['Brazilia', 'Moscow', 'New Delhi', 'Beijing', 'Pretoria'],\n",
    "         \"area\": [8.516, 17.100, 3.286, 9.597, 1.221],\n",
    "         \"population\": [200.40, 143.50, 1252.00, 1357.00, 52.98]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTE:\n",
    "   - key (columns, label)\n",
    "   - values(data, column by column)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brazilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        country    capital    area  population\n",
       "0        Brazil   Brazilia   8.516      200.40\n",
       "1        Russia     Moscow  17.100      143.50\n",
       "2         India  New Delhi   3.286     1252.00\n",
       "3         China    Beijing   9.597     1357.00\n",
       "4  South Africa   Pretoria   1.221       52.98"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_df = pd.DataFrame(bricks)\n",
    "bricks_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "bricks_df.index = ['BU', 'RU', 'IN', 'CH', 'SU']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BU</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brazilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SU</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital    area  population\n",
       "BU        Brazil   Brazilia   8.516      200.40\n",
       "RU        Russia     Moscow  17.100      143.50\n",
       "IN         India  New Delhi   3.286     1252.00\n",
       "CH         China    Beijing   9.597     1357.00\n",
       "SU  South Africa   Pretoria   1.221       52.98"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### another way to create DATAFRAME is through csv (comma seperated files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "assume we have **'bricks.csv'** file in our directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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>Unnamed: 0</th>\n",
       "      <th>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>BR</td>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>RU</td>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>IN</td>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>CH</td>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>SA</td>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Unnamed: 0       country    capital    area  population\n",
       "0         BR        Brazil   Brasilia   8.516      200.40\n",
       "1         RU        Russia     Moscow  17.100      143.50\n",
       "2         IN         India  New Delhi   3.286     1252.00\n",
       "3         CH         China    Beijing   9.597     1357.00\n",
       "4         SA  South Africa   Pretoria   1.221       52.98"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv = pd.read_csv('./dataset/bricks.csv')\n",
    "bricks_csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital    area  population\n",
       "BR        Brazil   Brasilia   8.516      200.40\n",
       "RU        Russia     Moscow  17.100      143.50\n",
       "IN         India  New Delhi   3.286     1252.00\n",
       "CH         China    Beijing   9.597     1357.00\n",
       "SA  South Africa   Pretoria   1.221       52.98"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv = pd.read_csv('./dataset/bricks.csv', index_col=0)\n",
    "bricks_csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas part2\n",
    "***index and select data***\n",
    "- square brakets\n",
    "- advance methods\n",
    "    - loc\n",
    "    - iloc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BR          Brazil\n",
       "RU          Russia\n",
       "IN           India\n",
       "CH           China\n",
       "SA    South Africa\n",
       "Name: country, dtype: object"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "country = bricks_csv['country']\n",
    "country"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(country) # here introduce another thing that is series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**: 1D label data is serires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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>country</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country\n",
       "BR        Brazil\n",
       "RU        Russia\n",
       "IN         India\n",
       "CH         China\n",
       "SA  South Africa"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "country = bricks_csv[['country']]\n",
    "country"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.frame.DataFrame"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(country)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital\n",
       "BR        Brazil   Brasilia\n",
       "RU        Russia     Moscow\n",
       "IN         India  New Delhi\n",
       "CH         China    Beijing\n",
       "SA  South Africa   Pretoria"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv[['country', 'capital']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### row accessing through index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country   capital    area  population\n",
       "BR  Brazil  Brasilia   8.516       200.4\n",
       "RU  Russia    Moscow  17.100       143.5"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country    capital    area  population\n",
       "RU  Russia     Moscow  17.100       143.5\n",
       "IN   India  New Delhi   3.286      1252.0\n",
       "CH   China    Beijing   9.597      1357.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country    capital    area  population\n",
       "BR  Brazil   Brasilia   8.516       200.4\n",
       "RU  Russia     Moscow  17.100       143.5\n",
       "IN   India  New Delhi   3.286      1252.0\n",
       "CH   China    Beijing   9.597      1357.0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital   area  population\n",
       "IN         India  New Delhi  3.286     1252.00\n",
       "CH         China    Beijing  9.597     1357.00\n",
       "SA  South Africa   Pretoria  1.221       52.98"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'(slice(2, None, None), slice(None, None, None))' is an invalid key",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-48-d369b992a31f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mbricks_csv\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;31m# test numpy access method for sepcifiec rows and columns ->> Error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mc:\\users\\qasim\\anaconda3\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m   3022\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3023\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3024\u001b[1;33m             \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   3025\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3026\u001b[0m                 \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\users\\qasim\\anaconda3\\lib\\site-packages\\pandas\\core\\indexes\\base.py\u001b[0m in \u001b[0;36mget_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m   3078\u001b[0m             \u001b[0mcasted_key\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_maybe_cast_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3079\u001b[0m             \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3080\u001b[1;33m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   3081\u001b[0m             \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3082\u001b[0m                 \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas\\_libs\\index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: '(slice(2, None, None), slice(None, None, None))' is an invalid key"
     ]
    }
   ],
   "source": [
    "bricks_csv[2:, :] # test numpy access method for sepcifiec rows and columns ->> Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question What if we want specific columns and rows ?\n",
    "###### Key points about [ ] square brakets\n",
    "- square bralets have limited functionality\n",
    "- ideally \n",
    "    - Remember **2D Numpy array** in numpy\n",
    "    - ``my_arr[row, col]``\n",
    "- pandas\n",
    "    - ``loc``(label based)\n",
    "    - ``iloc`` (index based)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital    area  population\n",
       "BR        Brazil   Brasilia   8.516      200.40\n",
       "RU        Russia     Moscow  17.100      143.50\n",
       "IN         India  New Delhi   3.286     1252.00\n",
       "CH         China    Beijing   9.597     1357.00\n",
       "SA  South Africa   Pretoria   1.221       52.98"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "country       Russia\n",
       "capital       Moscow\n",
       "area            17.1\n",
       "population     143.5\n",
       "Name: RU, dtype: object"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.loc['RU'] #rows as pandas series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.series.Series'>\n"
     ]
    }
   ],
   "source": [
    "print(type(bricks_csv.loc['RU'])) # loc also giive us series and DataFrame with same way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "print(type(bricks_csv.loc[['RU']])) # loc also giive us series and DataFrame with same way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.1</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country capital  area  population\n",
       "RU  Russia  Moscow  17.1       143.5"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.loc[['RU']] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country  capital    area  population\n",
       "RU  Russia   Moscow  17.100       143.5\n",
       "CH   China  Beijing   9.597      1357.0"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.loc[['RU','CH']] # specific rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "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>country</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>1357.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country  population\n",
       "RU  Russia       143.5\n",
       "CH   China      1357.0"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.loc[['RU','CH'], ['country', 'population']] # specific rows and columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country    capital    area  population\n",
       "RU  Russia     Moscow  17.100       143.5\n",
       "IN   India  New Delhi   3.286      1252.0\n",
       "CH   China    Beijing   9.597      1357.0"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.loc['RU':'CH']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RU    Russia\n",
       "IN     India\n",
       "CH     China\n",
       "Name: country, dtype: object"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.loc['RU':'CH', 'country']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RU    Russia\n",
       "IN     India\n",
       "CH     China\n",
       "Name: country, dtype: object"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.loc['RU':'CH', 'country']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "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>country</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country\n",
       "RU  Russia\n",
       "IN   India\n",
       "CH   China"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.loc['RU':'CH', ['country']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "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>country</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country  population\n",
       "BR        Brazil      200.40\n",
       "RU        Russia      143.50\n",
       "IN         India     1252.00\n",
       "CH         China     1357.00\n",
       "SA  South Africa       52.98"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.loc[:, ['country', 'population']]  # all rows with specific column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QUICK Recap\n",
    "- Square brakets\n",
    "\n",
    "    - column access --> ``bricks.csv[['country', 'capital']]``\n",
    "    - row access (only through slicing) --> ``bricks_csv[1:4]``\n",
    "    \n",
    "- loc(label-based) remeber ``arr[rows, columns]``\n",
    "\n",
    "    - row access --> ``bricks_csv.loc[['BR', 'IN']]``\n",
    "    - columns access --> ``bricks_csv.loc[:['country', 'capital']]``\n",
    "    - both rows and columns --> <br>\n",
    "    ``bricks_csv.loc[['BR', 'IN'], ['country', 'capital']]``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### row access with iloc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital    area  population\n",
       "BR        Brazil   Brasilia   8.516      200.40\n",
       "RU        Russia     Moscow  17.100      143.50\n",
       "IN         India  New Delhi   3.286     1252.00\n",
       "CH         China    Beijing   9.597     1357.00\n",
       "SA  South Africa   Pretoria   1.221       52.98"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.1</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country capital  area  population\n",
       "RU  Russia  Moscow  17.1       143.5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.iloc[[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country   capital    area  population\n",
       "RU        Russia    Moscow  17.100      143.50\n",
       "CH         China   Beijing   9.597     1357.00\n",
       "SA  South Africa  Pretoria   1.221       52.98"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.iloc[[1,3,4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "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>country</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country  population\n",
       "RU        Russia      143.50\n",
       "CH         China     1357.00\n",
       "SA  South Africa       52.98"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.iloc[[1,3,4],[0,3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "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>country</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country  population\n",
       "BR        Brazil      200.40\n",
       "RU        Russia      143.50\n",
       "IN         India     1252.00\n",
       "CH         China     1357.00\n",
       "SA  South Africa       52.98"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bricks_csv.iloc[:,[0,3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "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>capital</th>\n",
       "      <th>area</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     capital    area\n",
       "RU    Moscow  17.100\n",
       "CH   Beijing   9.597\n",
       "SA  Pretoria   1.221"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#bricks_csv.iloc[[1,3,4]]\n",
    "bricks_csv.iloc[[1,3,4], 1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparsion Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy recap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21.85171573, 20.97505669, 21.75028214, 24.7473475 , 21.44127836])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Code from Intro to Python for Data Science, CLass 01\n",
    "import numpy as np\n",
    "np_height = np.array([1.73, 1.68, 1.71, 1.89, 1.79])\n",
    "np_weight = np.array([65.4, 59.2, 63.6, 88.4, 68.7])\n",
    "bmi = np_weight / np_height ** 2\n",
    "bmi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False,  True, False])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi > 23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([24.7473475])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi[bmi > 23]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Comparison operators means `how Python values relate`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numeric comparsion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2<3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2==3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2<=3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 >= 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x= 4\n",
    "y = 6\n",
    "\n",
    "x > y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " 3 < 4.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String comparsion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"carl\" < \"chris\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Qasim' < 'Hassan'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-78-8405ff8201d1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m3\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;34m\"chris\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: '<' not supported between instances of 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "3 < \"chris\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='./media/comparsion_operators.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean Opearotrs\n",
    "- and \n",
    "- or\n",
    "- not\n",
    "<img src = './media/truth_table.png'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 12\n",
    "x > 5 and x < 15\n",
    "# True     True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 5\n",
    "y < 7 or y > 13\n",
    "# True     False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation in NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21.85171573, 20.97505669, 21.75028214, 24.7473475 , 21.44127836])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True,  True])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi > 21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True, False,  True])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi < 22"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-87-9fa12df1ff18>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mbmi\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m21\u001b[0m  \u001b[1;32mand\u001b[0m \u001b[0mbmi\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m22\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "bmi > 21  and bmi < 22"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy have their own functions for and or not that are:\n",
    "   - `logical_and()`\n",
    "   - `logical_or()`\n",
    "   - `logical_not()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True, False,  True])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logical_and(bmi>21, bmi<22)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21.85171573, 21.75028214, 21.44127836])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmi[np.logical_and(bmi>21, bmi<22)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Statements\n",
    "- if else elif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### if"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if condition:\n",
    "    statemmnet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Even\n"
     ]
    }
   ],
   "source": [
    "num = 4\n",
    "if num % 2 == 0: #True\n",
    "    print('Even')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplt lines can be added\n",
      "Be careful about identation\n",
      "Even\n"
     ]
    }
   ],
   "source": [
    "num = 4\n",
    "if num % 2 == 0: #True\n",
    "    print('Multiplt lines can be added')\n",
    "    print('Be careful about identation')\n",
    "    print('Even')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 5 \n",
    "if num % 2 == 0: #False\n",
    "    print('Multiplt lines can be added')\n",
    "    print('Be careful about identation')\n",
    "    print('Even') # Nothing gona print if statment gonna false then comes else statemnet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### else"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if condition :\n",
    "    expression\n",
    "else :\n",
    "    expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z is odd\n"
     ]
    }
   ],
   "source": [
    "z = 5\n",
    "if z % 2 == 0 : # False\n",
    "    print(\"z is even\")\n",
    "else :\n",
    "    print(\"z is odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### elif"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if condition :\n",
    "    expression\n",
    "elif condition :\n",
    "    expression\n",
    "else :\n",
    "    expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z is divisible by 3\n"
     ]
    }
   ],
   "source": [
    "z = 3\n",
    "if z % 2 == 0 :\n",
    "    print(\"z is divisible by 2\") # False\n",
    "elif z % 3 == 0 :\n",
    "    print(\"z is divisible by 3\") # True\n",
    "else :\n",
    "    print(\"z is neither divisible by 2 nor by 3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z is divisible by 2\n"
     ]
    }
   ],
   "source": [
    "z = 6\n",
    "if z % 2 == 0 :\n",
    "    print(\"z is divisible by 2\") # True\n",
    "elif z % 3 == 0 :\n",
    "    print(\"z is divisible by 3\") # Never reached\n",
    "else :\n",
    "    print(\"z is neither divisible by 2 nor by 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering pandas DataFrames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital    area  population\n",
       "BR        Brazil   Brasilia   8.516      200.40\n",
       "RU        Russia     Moscow  17.100      143.50\n",
       "IN         India  New Delhi   3.286     1252.00\n",
       "CH         China    Beijing   9.597     1357.00\n",
       "SA  South Africa   Pretoria   1.221       52.98"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "brics = pd.read_csv(\"./dataset/bricks.csv\", index_col = 0)\n",
    "brics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task: select countries with area over 8 million km2\n",
    "we'll follow three steps:\n",
    "- Select the area column\n",
    "- Do comparison on area column\n",
    "- Use result to select countries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### step1 : Select the area column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BR     8.516\n",
       "RU    17.100\n",
       "IN     3.286\n",
       "CH     9.597\n",
       "SA     1.221\n",
       "Name: area, dtype: float64"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brics[\"area\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Alternatives:\n",
    "- brics.loc[:,'area']\n",
    "- brics.iloc[:,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BR     8.516\n",
       "RU    17.100\n",
       "IN     3.286\n",
       "CH     9.597\n",
       "SA     1.221\n",
       "Name: area, dtype: float64"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brics.loc[:,'area'] # another way  top get column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BR     8.516\n",
       "RU    17.100\n",
       "IN     3.286\n",
       "CH     9.597\n",
       "SA     1.221\n",
       "Name: area, dtype: float64"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brics.iloc[:,2] # another way to get column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 2: Compare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BR     True\n",
       "RU     True\n",
       "IN    False\n",
       "CH     True\n",
       "SA    False\n",
       "Name: area, dtype: bool"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brics[\"area\"] > 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_huge = brics[\"area\"] > 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 3: Subset DF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BR     True\n",
       "RU     True\n",
       "IN    False\n",
       "CH     True\n",
       "SA    False\n",
       "Name: area, dtype: bool"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_huge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country   capital    area  population\n",
       "BR  Brazil  Brasilia   8.516       200.4\n",
       "RU  Russia    Moscow  17.100       143.5\n",
       "CH   China   Beijing   9.597      1357.0"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brics[is_huge]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Sumamry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country   capital    area  population\n",
       "BR  Brazil  Brasilia   8.516       200.4\n",
       "RU  Russia    Moscow  17.100       143.5\n",
       "CH   China   Beijing   9.597      1357.0"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Method -1\n",
    "is_huge = brics[\"area\"] > 8\n",
    "brics[is_huge]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country   capital    area  population\n",
       "BR  Brazil  Brasilia   8.516       200.4\n",
       "RU  Russia    Moscow  17.100       143.5\n",
       "CH   China   Beijing   9.597      1357.0"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Method -2\n",
    "brics[brics['area']>8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Question: what if we have to check two conditions at a time "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BR     True\n",
       "RU    False\n",
       "IN    False\n",
       "CH     True\n",
       "SA    False\n",
       "Name: area, dtype: bool"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logical_and(brics[\"area\"] > 8, brics[\"area\"] < 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   country   capital   area  population\n",
       "BR  Brazil  Brasilia  8.516       200.4\n",
       "CH   China   Beijing  9.597      1357.0"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brics[np.logical_and(brics[\"area\"] > 8, brics[\"area\"] < 10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LOOPS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recap\n",
    "- remember if else elif which goes through the code once only"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While Loop\n",
    "- ***While loop = repeated if statement***"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "while condition :\n",
    "    expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Numerically calculating model\n",
    "- \"repeating action until condition is met\"\n",
    "- Example\n",
    "    - Error starts at 50\n",
    "    - Divide error by 4 on every run\n",
    "    - Continue until error no longer > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.5\n",
      "3.125\n",
      "0.78125\n"
     ]
    }
   ],
   "source": [
    "error = 50.0\n",
    "# 50.0 ---> True\n",
    "# 12.5 ---> True\n",
    "# 3.125 ---> True\n",
    "# 0.78125 --> False\n",
    "while error > 1:\n",
    "    error = error / 4\n",
    "    print(error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code will follow\n",
    "- Error starts at 50\n",
    "- Divide error by 4 on every run\n",
    "- Continue until error no longer > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-114-bf4627a139f8>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-114-bf4627a139f8>\"\u001b[1;36m, line \u001b[1;32m4\u001b[0m\n\u001b[1;33m    print(error)\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "error = 50.0\n",
    "while error > 1 : # always True to stop restart kernal\n",
    "    # error = error / 4\n",
    "print(error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for loop"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "for var in seq :\n",
    "    expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "spell_above_syntax = \"for each var in seq, execute expression\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember the family list that have heights of family"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.73, 1.68, 1.71, 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.73\n",
      "1.68\n",
      "1.71\n",
      "1.89\n"
     ]
    }
   ],
   "source": [
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "print(fam[0])\n",
    "print(fam[1])\n",
    "print(fam[2])\n",
    "print(fam[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.73\n",
      "1.68\n",
      "1.71\n",
      "1.89\n"
     ]
    }
   ],
   "source": [
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "for height in fam :\n",
    "    # 1 iteration height == 1.73\n",
    "    # 2 iteration height == 1.86\n",
    "    # 3 iteration height == 1.71\n",
    "    # 4 iteration height == 1.89\n",
    "    print(height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### enumerate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In above example we **don't have access** to index lets suppose we want the index number also the code will be "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index 0: 1.73\n",
      "index 1: 1.68\n",
      "index 2: 1.71\n",
      "index 3: 1.89\n"
     ]
    }
   ],
   "source": [
    "fam = [1.73, 1.68, 1.71, 1.89]\n",
    "for index, height in enumerate(fam) :\n",
    "    print(\"index \" + str(index) + \": \" + str(height))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### looping over string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F\n",
      "A\n",
      "M\n",
      "I\n",
      "L\n",
      "Y\n"
     ]
    }
   ],
   "source": [
    "for c in \"family\" :\n",
    "    print(c.capitalize())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index 0 F\n",
      "index 1 A\n",
      "index 2 M\n",
      "index 3 I\n",
      "index 4 L\n",
      "index 5 Y\n"
     ]
    }
   ],
   "source": [
    "for i, c in enumerate(\"family\") :\n",
    "    print(\"index \"+str(i)+\" \"+ c.capitalize())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loop Data Structures Part - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### though Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "too many values to unpack (expected 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-123-2c0ae0235541>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;34m\"albania\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m2.77\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \"algeria\":39.21 }\n\u001b[1;32m----> 4\u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mworld\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m\"--\"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 2)"
     ]
    }
   ],
   "source": [
    "world = { \"afghanistan\":30.55,\n",
    "\"albania\":2.77,\n",
    "\"algeria\":39.21 }\n",
    "for key, value in world :\n",
    "    print(key + \"--\" + str(value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "afghanistan -- 30.55\n",
      "albania -- 2.77\n",
      "algeria -- 39.21\n"
     ]
    }
   ],
   "source": [
    "world = { \"afghanistan\":30.55,\n",
    "\"albania\":2.77,\n",
    "\"algeria\":39.21 }\n",
    "for key, value in world.items() :\n",
    "    print(key + \" -- \" + str(value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "afghanistan -- 30.55\n",
      "albania -- 2.77\n",
      "algeria -- 39.21\n"
     ]
    }
   ],
   "source": [
    "world = { \"afghanistan\":30.55,\n",
    "\"albania\":2.77,\n",
    "\"algeria\":39.21 }\n",
    "for k, v in world.items() : # temperary variable can be anything or name\n",
    "    print(k + \" -- \" + str(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### through Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21.85171572722109\n",
      "20.97505668934241\n",
      "21.750282138093777\n",
      "24.74734749867025\n",
      "21.44127836209856\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "np_height = np.array([1.73, 1.68, 1.71, 1.89, 1.79])\n",
    "np_weight = np.array([65.4, 59.2, 63.6, 88.4, 68.7])\n",
    "bmi = np_weight / np_height ** 2\n",
    "\n",
    "for val in bmi :\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.73 1.68 1.71 1.89 1.79]\n",
      "[65.4 59.2 63.6 88.4 68.7]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "np_height = np.array([1.73, 1.68, 1.71, 1.89, 1.79])\n",
    "np_weight = np.array([65.4, 59.2, 63.6, 88.4, 68.7])\n",
    "\n",
    "meas = np.array([np_height, np_weight])\n",
    "\n",
    "for val in meas :\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.73\n",
      "1.68\n",
      "1.71\n",
      "1.89\n",
      "1.79\n",
      "65.4\n",
      "59.2\n",
      "63.6\n",
      "88.4\n",
      "68.7\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "np_height = np.array([1.73, 1.68, 1.71, 1.89, 1.79])\n",
    "np_weight = np.array([65.4, 59.2, 63.6, 88.4, 68.7])\n",
    "\n",
    "meas = np.array([np_height, np_weight])\n",
    "\n",
    "for val in np.nditer(meas):\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recap:\n",
    "- Dictionaries\n",
    "    - `for key,val in my_dict.items():`\n",
    "- Numpy array\n",
    "    - `for val in np.nditer(my_array) :`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loop Data Structures Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital    area  population\n",
       "BR        Brazil   Brasilia   8.516      200.40\n",
       "RU        Russia     Moscow  17.100      143.50\n",
       "IN         India  New Delhi   3.286     1252.00\n",
       "CH         China    Beijing   9.597     1357.00\n",
       "SA  South Africa   Pretoria   1.221       52.98"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "brics = pd.read_csv(\"./dataset/bricks.csv\", index_col = 0)\n",
    "brics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "country\n",
      "capital\n",
      "area\n",
      "population\n"
     ]
    }
   ],
   "source": [
    "for val in brics :\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### whole table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BR\n",
      "country         Brazil\n",
      "capital       Brasilia\n",
      "area             8.516\n",
      "population       200.4\n",
      "Name: BR, dtype: object\n",
      "\n",
      "RU\n",
      "country       Russia\n",
      "capital       Moscow\n",
      "area            17.1\n",
      "population     143.5\n",
      "Name: RU, dtype: object\n",
      "\n",
      "IN\n",
      "country           India\n",
      "capital       New Delhi\n",
      "area              3.286\n",
      "population       1252.0\n",
      "Name: IN, dtype: object\n",
      "\n",
      "CH\n",
      "country         China\n",
      "capital       Beijing\n",
      "area            9.597\n",
      "population     1357.0\n",
      "Name: CH, dtype: object\n",
      "\n",
      "SA\n",
      "country       South Africa\n",
      "capital           Pretoria\n",
      "area                 1.221\n",
      "population           52.98\n",
      "Name: SA, dtype: object\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for lab, row in brics.iterrows():\n",
    "    print(lab)\n",
    "    print(row)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Selective print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BR: Brasilia\n",
      "RU: Moscow\n",
      "IN: New Delhi\n",
      "CH: Beijing\n",
      "SA: Pretoria\n"
     ]
    }
   ],
   "source": [
    "for lab, row in brics.iterrows():\n",
    "    print(lab + \": \" + row[\"capital\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "for lab, row in brics.iterrows():\n",
    "    brics.loc[lab, 'name_length'] = len(row['country']) # not a adaptive method we use .apply()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "      <th>name_length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital    area  population  name_length\n",
       "BR        Brazil   Brasilia   8.516      200.40          6.0\n",
       "RU        Russia     Moscow  17.100      143.50          6.0\n",
       "IN         India  New Delhi   3.286     1252.00          5.0\n",
       "CH         China    Beijing   9.597     1357.00          5.0\n",
       "SA  South Africa   Pretoria   1.221       52.98         12.0"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### apply()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "brics['apply_name_length'] = brics['country'].apply(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "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>country</th>\n",
       "      <th>capital</th>\n",
       "      <th>area</th>\n",
       "      <th>population</th>\n",
       "      <th>name_length</th>\n",
       "      <th>apply_name_length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BR</th>\n",
       "      <td>Brazil</td>\n",
       "      <td>Brasilia</td>\n",
       "      <td>8.516</td>\n",
       "      <td>200.40</td>\n",
       "      <td>6.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RU</th>\n",
       "      <td>Russia</td>\n",
       "      <td>Moscow</td>\n",
       "      <td>17.100</td>\n",
       "      <td>143.50</td>\n",
       "      <td>6.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IN</th>\n",
       "      <td>India</td>\n",
       "      <td>New Delhi</td>\n",
       "      <td>3.286</td>\n",
       "      <td>1252.00</td>\n",
       "      <td>5.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CH</th>\n",
       "      <td>China</td>\n",
       "      <td>Beijing</td>\n",
       "      <td>9.597</td>\n",
       "      <td>1357.00</td>\n",
       "      <td>5.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SA</th>\n",
       "      <td>South Africa</td>\n",
       "      <td>Pretoria</td>\n",
       "      <td>1.221</td>\n",
       "      <td>52.98</td>\n",
       "      <td>12.0</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         country    capital    area  population  name_length  \\\n",
       "BR        Brazil   Brasilia   8.516      200.40          6.0   \n",
       "RU        Russia     Moscow  17.100      143.50          6.0   \n",
       "IN         India  New Delhi   3.286     1252.00          5.0   \n",
       "CH         China    Beijing   9.597     1357.00          5.0   \n",
       "SA  South Africa   Pretoria   1.221       52.98         12.0   \n",
       "\n",
       "    apply_name_length  \n",
       "BR                  6  \n",
       "RU                  6  \n",
       "IN                  5  \n",
       "CH                  5  \n",
       "SA                 12  "
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Let's Jump to the Hacker stistic case study...!!!***"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}