Writing Functions in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing functions in Python\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crafting a docstring\n",
    "You've decided to write the world's greatest open-source natural language processing Python package. It will revolutionize working with free-form text, the way numpy did for arrays, pandas did for tabular data, and scikit-learn did for machine learning.\n",
    "\n",
    "The first function you write is count_letter(). It takes a string and a single letter and returns the number of times the letter appears in the string. You want the users of your open-source package to be able to understand how this function works easily, so you will need to give it a docstring. Build up a Google Style docstring for this function by following these steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a docstring to count_letter()\n",
    "def count_letter(content, letter):\n",
    "  \"\"\"\n",
    "  Count the number of times `letter` appears in `content`.\n",
    "  \"\"\"\n",
    "\n",
    "  if (not isinstance(letter, str)) or len(letter) != 1:\n",
    "    raise ValueError('`letter` must be a single character string.')\n",
    "  return len([char for char in content if char == letter])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_letter(content, letter):\n",
    "  \"\"\"Count the number of times `letter` appears in `content`.\n",
    "\n",
    "  # Add a Google style arguments section\n",
    "  Args:\n",
    "    content (str): The string to search.\n",
    "    letter (str): The letter to search for.\n",
    "  \"\"\"\n",
    "  if (not isinstance(letter, str)) or len(letter) != 1:\n",
    "    raise ValueError('`letter` must be a single character string.')\n",
    "  return len([char for char in content if char == letter])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_letter(content, letter):\n",
    "  \"\"\"Count the number of times `letter` appears in `content`.\n",
    "\n",
    "  Args:\n",
    "    content (str): The string to search.\n",
    "    letter (str): The letter to search for.\n",
    "\n",
    "  # Add a returns section\n",
    "  Returns:\n",
    "    int\n",
    "  \"\"\"\n",
    "  if (not isinstance(letter, str)) or len(letter) != 1:\n",
    "    raise ValueError('\"letter\" must be a single character string.')\n",
    "  return len([char for char in content if char == letter])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_letter(content, letter):\n",
    "  \"\"\"Count the number of times `letter` appears in `content`.\n",
    "\n",
    "  Args:\n",
    "    content (str): The string to search.\n",
    "    letter (str): The letter to search for.\n",
    "\n",
    "  Returns:\n",
    "    int\n",
    "\n",
    "  # Add a section detailing what errors might be raised\n",
    "  Raises:\n",
    "    ValueError: If `letter` is not a one-character string.\n",
    "  \"\"\"\n",
    "  if (not isinstance(letter, str)) or len(letter) != 1:\n",
    "    raise ValueError('`letter` must be a single character string.')\n",
    "  return len([char for char in content if char == letter])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While it does require a bit more typing, the information presented here will make it very easy for others to use this code in the future. Remember that even though computers execute it, code is actually written for humans to read (otherwise you'd just be writing the 1s and 0s that the computer operates on)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retrieving docstrings\n",
    "You and a group of friends are working on building an amazing new Python IDE (integrated development environment -- like PyCharm, Spyder, Eclipse, Visual Studio, etc.). The team wants to add a feature that displays a tooltip with a function's docstring whenever the user starts typing the function name. That way, the user doesn't have to go elsewhere to look up the documentation for the function they are trying to use. You've been asked to complete the build_tooltip() function that retrieves a docstring from an arbitrary function.\n",
    "\n",
    "Note that in Python, you can pass a function as an argument to another function. I'll talk more about this in chapter 3, but it will be useful to keep in mind for this exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "############################\n",
      "Count the number of times `letter` appears in `content`.\n",
      "\n",
      "  Args:\n",
      "    content (str): The string to search.\n",
      "    letter (str): The letter to search for.\n",
      "\n",
      "  Returns:\n",
      "    int\n",
      "\n",
      "  # Add a section detailing what errors might be raised\n",
      "  Raises:\n",
      "    ValueError: If `letter` is not a one-character string.\n",
      "  \n",
      "############################\n"
     ]
    }
   ],
   "source": [
    "# Get the docstring with an attribute of count_letter()\n",
    "docstring = count_letter.__doc__\n",
    "\n",
    "border = '#' * 28\n",
    "print('{}\\n{}\\n{}'.format(border, docstring, border))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "############################\n",
      "Count the number of times `letter` appears in `content`.\n",
      "\n",
      "Args:\n",
      "  content (str): The string to search.\n",
      "  letter (str): The letter to search for.\n",
      "\n",
      "Returns:\n",
      "  int\n",
      "\n",
      "# Add a section detailing what errors might be raised\n",
      "Raises:\n",
      "  ValueError: If `letter` is not a one-character string.\n",
      "############################\n"
     ]
    }
   ],
   "source": [
    "import inspect\n",
    "\n",
    "# Get the docstring with a function from the inspect module\n",
    "docstring = inspect.getdoc(count_letter)\n",
    "\n",
    "border = '#' * 28\n",
    "print('{}\\n{}\\n{}'.format(border, docstring, border))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "############################\n",
      "Count the number of times `letter` appears in `content`.\n",
      "\n",
      "Args:\n",
      "  content (str): The string to search.\n",
      "  letter (str): The letter to search for.\n",
      "\n",
      "Returns:\n",
      "  int\n",
      "\n",
      "# Add a section detailing what errors might be raised\n",
      "Raises:\n",
      "  ValueError: If `letter` is not a one-character string.\n",
      "############################\n",
      "############################\n",
      "range(stop) -> range object\n",
      "range(start, stop[, step]) -> range object\n",
      "\n",
      "Return an object that produces a sequence of integers from start (inclusive)\n",
      "to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
      "start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
      "These are exactly the valid indices for a list of 4 elements.\n",
      "When step is given, it specifies the increment (or decrement).\n",
      "############################\n",
      "############################\n",
      "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "\n",
      "Prints the values to a stream, or to sys.stdout by default.\n",
      "Optional keyword arguments:\n",
      "file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "sep:   string inserted between values, default a space.\n",
      "end:   string appended after the last value, default a newline.\n",
      "flush: whether to forcibly flush the stream.\n",
      "############################\n"
     ]
    }
   ],
   "source": [
    "def build_tooltip(function):\n",
    "  \"\"\"Create a tooltip for any function that shows the \n",
    "  function's docstring.\n",
    "  \n",
    "  Args:\n",
    "    function (callable): The function we want a tooltip for.\n",
    "    \n",
    "  Returns:\n",
    "    str\n",
    "  \"\"\"\n",
    "  # Use 'inspect' to get the docstring\n",
    "  docstring = inspect.getdoc(function)\n",
    "  border = '#' * 28\n",
    "  return '{}\\n{}\\n{}'.format(border, docstring, border)\n",
    "\n",
    "print(build_tooltip(count_letter))\n",
    "print(build_tooltip(range))\n",
    "print(build_tooltip(print))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the count_letter.__doc__ version of the docstring had strange whitespace at the beginning of all but the first line. That's because the docstring is indented to line up visually when reading the code. But when we want to print the docstring, removing those leading spaces with inspect.getdoc() will look much better."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Docstrings to the rescue!\n",
    "Some maniac has corrupted your installation of numpy! All of the functions still exist, but they've been given random names. You desperately need to call the numpy.histogram() function and you don't have time to reinstall the package. Fortunately for you, the maniac didn't think to alter the docstrings, and you know how to access them. numpy has a lot of functions in it, so we've narrowed it down to four possible functions that could be numpy.histogram() in disguise: numpy.leyud(), numpy.uqka(), numpy.fywdkxa() or numpy.jinzyxq().\n",
    "\n",
    "Examine each of these functions' docstrings in the IPython shell to determine which of them is actually numpy.histogram()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "numpy.fywdkxa() is actually numpy.histogram() in disguise. If you've spent any time browsing numpy's online documentation, you will notice that it is built directly from the docstrings. There are some wonderful tools like sphinx and pydoc that will automatically generate online documentation for you based off of your docstrings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Software Engineering principles : \n",
    "\n",
    "#### DRY (don't repeat yourself)\n",
    "\n",
    "- Principle when writing functions (and coding in general): functions most be concise, clear and non-repetitive.\n",
    "- When we start repeating ourselves in code, it is often the signal that we need to write a function to prevent this.\n",
    "\n",
    "#### DOT (do one thing)\n",
    "\n",
    "- Any function should only have 1 responsability : for instance, load data (this is 1), process data (this is another 1), plot the data (another 1)\n",
    "- Try as much as possible to avoid functions that do everything."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract a function\n",
    "While you were developing a model to predict the likelihood of a student graduating from college, you wrote this bit of code to get the z-scores of students' yearly GPAs. Now you're ready to turn it into a production-quality system, so you need to do something about the repetition. Writing a function to calculate the z-scores would improve this code.\n",
    "\n",
    "````\n",
    "# Standardize the GPAs for each year\n",
    "df['y1_z'] = (df.y1_gpa - df.y1_gpa.mean()) / df.y1_gpa.std()\n",
    "df['y2_z'] = (df.y2_gpa - df.y2_gpa.mean()) / df.y2_gpa.std()\n",
    "df['y3_z'] = (df.y3_gpa - df.y3_gpa.mean()) / df.y3_gpa.std()\n",
    "df['y4_z'] = (df.y4_gpa - df.y4_gpa.mean()) / df.y4_gpa.std()\n",
    "````\n",
    "\n",
    "Note: df is a pandas DataFrame where each row is a student with 4 columns of yearly student GPAs: y1_gpa, y2_gpa, y3_gpa, y4_gpa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    y1_gpa  y2_gpa  y3_gpa  y4_gpa      y1_z      y2_z      y3_z      y4_z\n",
      "0       25      21      29      29  1.422798  0.923734  1.698391  2.083626\n",
      "1        6      10       8       1 -1.115527 -0.338511 -0.703374 -1.378779\n",
      "2       11      15       1      24 -0.447547  0.235237 -1.503963  1.465339\n",
      "3       27      11      22      12  1.689991 -0.223762  0.897803 -0.018549\n",
      "4        5      27       4       4 -1.249124  1.612232 -1.160853 -1.007807\n",
      "5       19       7      28       9  0.621222 -0.682760  1.584021 -0.389521\n",
      "6        9      15      12       6 -0.714739  0.235237 -0.245895 -0.760493\n",
      "7       15       2      23      11  0.086837 -1.256508  1.012172 -0.142206\n",
      "8       21       6       6      10  0.888414 -0.797510 -0.932114 -0.265863\n",
      "9       14       2      24       7 -0.046759 -1.256508  1.126542 -0.636835\n",
      "10       6       5      17      13 -1.115527 -0.912259  0.325954  0.105109\n",
      "11      18      28      11       5  0.487626  1.726981 -0.360265 -0.884150\n",
      "12      19      12       2      24  0.621222 -0.109012 -1.389593  1.465339\n",
      "13       2      20      11      18 -1.649912  0.808985 -0.360265  0.723395\n",
      "14      18       3      25       1  0.487626 -1.141758  1.240912 -1.378779\n",
      "15      10      13       7       2 -0.581143  0.005737 -0.817744 -1.255122\n",
      "16      21      19       7      15  0.888414  0.694235 -0.817744  0.352423\n",
      "17       8      11      12      17 -0.848335 -0.223762 -0.245895  0.599738\n",
      "18      25      29      16      16  1.422798  1.841731  0.211584  0.476081\n",
      "19       8       3      18      19 -0.848335 -1.141758  0.440324  0.847053\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "df = pd.DataFrame({\n",
    "    'y1_gpa' : np.random.randint(1, 30, 20),\n",
    "    'y2_gpa' : np.random.randint(1, 30, 20),\n",
    "    'y3_gpa' : np.random.randint(1, 30, 20),\n",
    "    'y4_gpa' : np.random.randint(1, 30, 20)\n",
    "})\n",
    "\n",
    "def standardize(column):\n",
    "  \"\"\"Standardize the values in a column.\n",
    "\n",
    "  Args:\n",
    "    column (pandas Series): The data to standardize.\n",
    "\n",
    "  Returns:\n",
    "    pandas Series: the values as z-scores\n",
    "  \"\"\"\n",
    "  # Finish the function so that it returns the z-scores\n",
    "  z_score = (column - column.mean()) / column.std()\n",
    "  return z_score\n",
    "\n",
    "# Use the standardize() function to calculate the z-scores\n",
    "df['y1_z'] = standardize(df['y1_gpa'])\n",
    "df['y2_z'] = standardize(df['y2_gpa'])\n",
    "df['y3_z'] = standardize(df['y3_gpa'])\n",
    "df['y4_z'] = standardize(df['y4_gpa'])\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Split up a function\n",
    "Another engineer on your team has written this function to calculate the mean and median of a list. You want to show them how to split it into two simpler functions: mean() and median()\n",
    "\n",
    "```\n",
    "def mean_and_median(values):\n",
    "  \"\"\"Get the mean and median of a list of 'values'\n",
    "\n",
    "  Args:\n",
    "    values (iterable of float): A list of numbers\n",
    "\n",
    "  Returns:\n",
    "    tuple (float, float): The mean and median\n",
    "  \"\"\"\n",
    "  mean = sum(values) / len(values)\n",
    "  midpoint = int(len(values) / 2)\n",
    "  if len(values) % 2 == 0:\n",
    "    median = (values[midpoint - 1] + values[midpoint]) / 2\n",
    "  else:\n",
    "    median = values[midpoint]\n",
    "\n",
    "  return mean, median\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean(values):\n",
    "  \"\"\"Get the mean of a list of values\n",
    "\n",
    "  Args:\n",
    "    values (iterable of float): A list of numbers\n",
    "\n",
    "  Returns:\n",
    "    float\n",
    "  \"\"\"\n",
    "  # Write the mean() function\n",
    "  mean = sum(values) / len(values)\n",
    "  return mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def median(values):\n",
    "  \"\"\"Get the median of a list of values\n",
    "\n",
    "  Args:\n",
    "    values (iterable of float): A list of numbers\n",
    "\n",
    "  Returns:\n",
    "    float\n",
    "  \"\"\"\n",
    "  # Write the median() function\n",
    "  midpoint = int(len(values) / 2)\n",
    "  if len(values) % 2 == 0:\n",
    "    median = (values[midpoint - 1] + values[midpoint]) / 2\n",
    "  else:\n",
    "    median = values[midpoint]\n",
    "  return median"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each function does one thing and does it well. Using, testing, and maintaining these will be a breeze (although you'll probably just use numpy.mean() and numpy.median() for this in real life)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In Python, objects such as lists are mutable but not all\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4gAAAIPCAIAAAC+EGdNAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAEnQAABJ0Ad5mH3gAAGNeSURBVHhe7d3pkxRV3v/9+8n8AzwxJq7wwR2GdwRhED+NCeLSkcGfOLixOQgOMIKAsjgCtoB4yWIjoiyCyCrIIjJscrFLg9issi8iCAz70jRNQ9O27NCr9wdOcibNrKrOoovu093vV5zo6D55KiurKrO+n8rOzPp/fgMAAAAcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpALirsKgov+DXQ0dP7D1wSL/oT28CANREFQqmepds0rbbH/5Yz7aOPftfuXrNm4xqa+hnk/0va90/N/n54BFvWvJSO7faYO6iFf5nzLbHGrU8fOykNyiakpKS9JETAvMx7a8vd87JzfPG1SxHjp/60zOt/A924Cdj9VR4k5OU2rlFdKuw8Lt1m1/u9Hadhx/337Xac63fyMjcqAHeUACoQQimiIFgWrXiBVO1fy1Y7g2KRtFTATQwE9MIphFVfjDVx48W7Xv47zHcnmreYc/P//ZuAAA1BcHUXXomN+/Ys2HLTtsOHT3hTbvPCKZVK0EwbdO1z6XLV71xESxfvT4wB9sqIZhqjfWvwFqfK+f9oVoH02279wbuLl6r8/Djq9ZuKisr824JANUfwdRdVfIPRINgWrUSBNP/90+No+8nu1VY+M7A4YE52FYJwbSqXvrqG0xPn8l5qnkH/30lbvUatmBrAlCTEEzdRTCttRIEU7XPvpjpjStPeBXyN4JpRJW2JRYXlwwaNtZ/R1FasjvRAcBlBFN3EUxrrcTB9PlXuuTlF3hDE5oxd1Hgtv5GMI2o0rbEg4eP12vYwn9Hak+80Hb2/y7PPndeL/raTdtjHnv6w7bd3iwAoJojmLqLYFprJQ6malGCyLXrN15PGxi4ob8RTCOqtC3xy1kL/Pei1rz9W1nZOd7kO27cvJU+Ynxg2AfDx5WWlnojAKA6I5i6i2Baa5UbTKOsCT/uO/jgo40CN/Q3gmlElbMl3rx1q+f7Q/33opdv1dpN3mSfU1lnn2zSzj+SN14ANQbB1F0E01qr3GDasFn7M2fPeaNjKSsrGzP568CtAo1gGlHlbIkFly43b/+W/17+9lrPCxd/8Sb78MYLoAa778E0XGIzN25VvwrnoaMn0keMf/ql1+o8/Ljac63fmDhjbsw3YtXgTyfO0AAzUjf5eMyUBIU5wYJdu37jm6Wr/tH93UcaNFO/fnbrk75l557i4mCZuVVYqEV9PW2gHalbfbduc7zrWidVLeI9LTEnxWvx5m+f2wZN/qFh4edWj9c/H7UvZy0wk4x4eUJzPn0mx/9aJHjVrGTTyY2btzZs2fnOwOFm+dXqN24d72WquHh3p05N8gbFEu9F1EJqUf0zTDYChufcrtu7gZ6lK9d4o2NRymnVOc0//vlXuqj5e8JLlWC1DEiwtocnJWjx5u/f5DVMz6Q2ea175tJI5SbFBAP0mn6/YYt/uy531Uo2mGohs3NyJ8+cr2T5UP1nNf6Bug30nCTeUsLPW+9Bw2O+27DHFEANVjXBNC+/IPBPK9tUh+Ys/NYeL6Uq8vmUWXpbDwwzbcioSTGjQ8wFu3T5akbmRlONwq1lx15ncy94t//tt70HDsW7wLVKwo/7DnrjfKI8G1aCBBCeFK/FnH/uhYtd3vkgMNI0PbfKiIrm9xZM9ar1HzrGBIVAU6dyQ7wYFz2YqgzPX7LysUYt/eP9TS+fXsRUHU6nu5u3OCPeKqGmFW/mvCXxPorEfBGzsnMCiVCt4sFUmSaQRf7Zb0iC3Lx20/bAK6WcF1gx3AymmsmgYWNjrmZqet/QenhvwbSoqHjND9ueeKGtv9+2BNerTyqYKj2/kTYo3vKrmYfgjfbRWq2PE3r2bNNblgnifgrQ2tYC80wfOSFBUAaAaqQKgulnX8ws90J902Yv1DuyIlS8/Gpb197pl68EL5USXrA2XfskqHamNW7V2WTTjVt3mf0c8ZrySrigRnk2rAQJIDwpXgvPXxW03OdWEXzh8tWBznKDqW7yYpty0obmfD4v35uFT8RgqmqtR+QfGa+pDMcLi9HFTJAxm1aMk6ezvZv5hF+pURO/CsRH0yoeTFet3aQw5O9J8PWkyiiBryGt17DF9t37lGX9nQ4GU60/2lQDYwJNz/DSlWuSDab9Phylj7iJ3wE0VR9UwlkwYjDVDZdkZCZ+6zBNc9NHX+9myVAq1UeUwKN48NFG6zbt8EYAQDVXBcE0SlN2UR0d8PHngf6YbcbcRd6d3ZVUafS39z/6TPebYBeabc+/0uXc+d8V9SoPpsdOno6ZiqK0xME0euvUq3/4c0KUYKpEolzrH5a46WNGRf6tHyXB+5uSRHiZo79SFQ+mWj3CO0EDr5ql+9I9+kd27ztYud/xYKoljPhRIdzKDaYRm57h7zds8eZyV5RgqlSqUJs4+PrbPVwY/8bNW0NGTQrMRy3eP44AoDpyNJiq/Ve9pyK+y4dPBLnnYKp71P0GOuO1cVNne/d3R9UGU1Wmt/t/EhgQvaUqmKp9PGZKYJ9TucE0yq7xcDO71b1ZJCPZEGya3aFuRX+lUhJM9UEocJBovCurL8nI9A9Tm7PwWz3JLgdT5bxRE78KTI3eUhVM1XRD3dyb0R1Rgmm5/2YJt/AalYCe27QBwwJzUOvyzgdJrVoA4LiqDKb1G7d+sU03/Qz0h9sDdRvoTdycJhWYZFrgRJAEpdHMSi3ecav+ZpYw3g7UVp3Tfr18xbvL1AVTK0o5tL7fsCXek9OgyT8SPArTkgqmiZ+W8HdmJg6mCpeKTf4Banosb6QN2rBlp0Kkntide/aHj9sLB4goEgSgcteNwJF8CdZtZZS/vdZTD3zkhOmvpw18rcf7gf3ricVcPfREBU60j/n1pLdCX0P6ZJN2p7LO6qNL5QRTv3I/k1jqD19b3rQobxRJBdNy30/eHfxpUVGxN68IW2LuhYuBE+rVHmvUUp+dDh09oecq+9z5GXMXhQ+eDn+Ki+mXXy917zs4cFu1V9/sl52T6w0CgBqhaoLpU807KHOYf8XqfVnFVYUnMMY0VQ6Vdt2RmZuq+3tDRgfGqAWuLx1eMDXNavCnE+1Zsdeu3xg96at4lUnLs3nHHjNPLadiX7jOqY4ePHzczE0ilmojtcFUjyV8KXU9NAUpeyKzHsvuvQfindEVMZj2TR958nS2eVo0W/3eqVeMo0IDdT1xOgnvCFSqU1QNHEWqO1Vn4PX6cNSkKHXdL96X62RkbtTTaMYow337/YbwKx4IgjHXbYWeKV9/Ez6eISnxVg8F9MClSfXcmptY4QeoTUZPpsvBVGt14KBY03r8z0cHDh0rd31TixhM1alX1v9Ca6UKf8QKvNDlbonhb9hSZNSm502+62zuhcCu+gQHClta2pj/TzCHZ3iDAKCmqIJgqrf4XT/t9ybfpbfsxq1+d1ScaROmzwkcSqgS2+/DUYFhgfuNGUzTR4xXHfJG3KFSN232wsAwtadfeu3EqTPeoLuU6sL/qvOX7SoMpir2Kvn+kQpwKpbhozC1PCr2/pGmRQmmMQ9l08sxfNzUwMjAwRWJ00n4/87xzm3Swwl8k3iy/yKXz6fM8s9BrXn7t/595D8fMCytA1oTAoP9QTD8IsZ72pMVb/XQy6eVyt+vTB9IJ4GQpEVavnq9+l0OploMLYx/pFr09U0tSjB9Ms71NJR9NSkw2H+gTuItMXxlLg3+aX/sc5v08AMfG+IdKGwt+25d4POYmqLqL79e8kYAQA1SBcH04zFTYlbu8F4HxYLwXgcJ7xNSqPWfDx5eMJWKQ0dPeJN9wrvr1CbNmBfOf+oJ79TRMnuTqzSYLli2yj9MTXXL7hYKCF8EUa3cYBrvjHsJF2a1tZu2e5MTppPCoqK+6SP9U/XKxswuRvjbjLbs3ONNi+DS5at/79Lbf/N4X65jrNu0I3B3eon1Qpup4Rexw1v/k5K4kGD1CG8m/q8nDSdXxe7cCxc1yeVgun33vkD2SnZ9KzeYav4xz7g3wp+OXk8baLegxFtieJ1McGZeeIXXixLO35aWIfzPEFIpgBqsCoJpvBygihXY7Rfv+tLh6hsoseEFU2KIeZqIqotqjH+klkFl0pv8eyrS/pFq/jxXhcE0UP5Vg8NnFluqzeHrIJYbTBOfaRR+OP4ZJkgnChnhg/OSauXucPI7fjLrv5/7u//mMS8jYIVjgXKzPX4j/KjHTZ0d8wVKVoLVI/ypzH/gRPh//fZzoMvBNHy/ya5v5QZTfXZNcKbRxV8Kmrbr7h/vf3ISb4nhj4VJtfCr4KdJGuAf/4/u7/IffAA1WBUE03ilLnoOK7fEJpURI9ZOSXxd+qoKpuGv2H7yzsku3uRYdF/+8WqJg2mCsG6EP1T4j/pN8AyHk2KyLXB4cWLhPXPlRkk9M/7xanZncPhFTLDzNSkJVg99VAuc22QPnFCSC5wd5X/hXA6mgf/O38P6Vm4wjfcp19BtNQf/eP8nkMRbYsxDC6I3/x2FBe5anzq4ZCmAmo1gWu2DaZTAEXBv3/zkTYsl8aImmFv4hsm2eCtJTOU+8LAEr1T0dTtZiecc/r+zuSpFeLef/9ACl4Npatc3if5mYiW1liZYvZNtiR9s4K6ffum17HPnvWkAUBMRTJMoirV2j+l/1XsqfL6an54xPW/+m/ivrJTgGa74HtNyA4dfeI/pZ1/M9KbFoWfGP143T7DHNN66nazEc87KzmnYrL1/arc+6ddv3Axfgd9/tHQ12mN6D+tbYDUIbzvO7jFN8IYjxcUl/u8p1e8VP7UOAFxGML2PwTRwoVO/QNxRCz8t0Z+QwENQS5CQ7u0Y08CAgPCr7B+f4BkOP2ltuvY5c/ac+iO2q9eum1lFEc7BCVYMCa9piY8xTfC0JyXxnLUOBM7De6xRywOHjgWilVYe/wl/9xZMA1cItnRD3dw/siLBNPH6ExYeH9g0wttO+MH6VeQY0/DCLPr2+8BamqCRNQHAj2CasmCq+ete/FNjXv9cYp5pW5FgGj79Qs+PniVv8u/d21n5Ktsq3t7k3wufJe3frSgJnuHwScpRrux4z8Jn5aslSJM/bNsdOJfob6/1tJfCjb5uJ6vcOYd3jvb5YERgN2r3voP9V2aIEkx1L/4BaoFL0lrhBahIMA3vyU5qfVMrN5iq6Vn1Joek9qz8e7i8bmLaTPSeFm+LBoCahGCasmAa/pe6Wvikb1WsebG+Uzv8tER/QrTAWmz/SDUtW/isID0J93wd05gXwYl5XcnAdb4SP8PhNSTe1+Goc/nq9SMnTLftsy9mBr6Ntlzh65jGvGytZGXnhK8YoAdrX4IqDKbhPXzhFtjZGSWYhgOi/gxf4SHmd7pWJJhqMbQw/pFqWtvD/3yPub6pRQmm9eJciSzmdUz9R0Ek3hLDr4UG6yZmaoAeqdZA/zqslynmRm3oVdN481Vkei3SBgzjQlEAajaCacqCqcQsmcqm9jo1WvI5C7+N+Z3a4aclXK3jnfoQcxesmoKy/SZMhdSKf/NT976D9VhMatTPeN/EY75qyMxKEj/D4T24KsCLV2QGUrXubt2mHYGnzl6kM7rw5ZbUHmnQ7NvvNxQWFZkx+kVp7IkX2gaG6Yb+Yx+rMJjq2QicgB9o4WsARwmmMQ/5VSpakpFpPpOYF/3VN/sFxqjF3MS0XgWGTZ4536w/ftrMY37zU6vOacdOnjbjzV1X8JuftP7os419oc32GP7mp8ALnfitKeZr8Y/u74bXzJgfC7UA4SfE0HMe+EYJtcQXOAOA6o5gmspgqocWGGBb/catE3wJu1r4adECa7EDw5SWFixbtWHLzozMjV98Nd/+tzHBd+Un/mp70yIGU9M0qwQzVFHftnuvN6M7Ej/Dqsrjps72DzBNoWTtpu15+QV6NQ8cOvbR6C/Cz17Mr0JITOPjfVe+nkDluQQvkx6IP3BXYTCV8H+Q/S3w2UCiBNOYq5xpek70zCT4wvqYm1h4i9CTrGXTK6t1WCF15x4v/2mVCH9gMM2sbyn8rnzzQqvF22TeHfypni5vXhHemvQZ4KnmHfwD1BSCP504Q5+7tAKfz8tXIA68KamFPz/46TnRxhK4iZr5Ki8AqJEIpqkMpjG/Rypii/m0hP/v7G/+B6WEGj6QIHpLKpgmboH0JuU+wwWXLrfp2sc/Jkpr3v6te7t0Tsz/RJfbdHdZ2b/LEFUbTBOEyJhXu4wSTCX8zVIRW8xNLHwBgUCzj6u4uGTkhOmBqdFbUsE0cXuySbu9B373haJR3ppifnFo4qbxs75ZFvMtzoh36f6krt0LANULwTSVwbQszpfvR2kxn5aYe2JsCzyoQ0dPqKYGxsRs4T1tiYOpKuh/1XvK3xOvde87OHwMXJRnWK9+gkcabnqkMb/3PKJk706Dw+exVW0wlXghMuYRDhGD6dncC41bBQ/3jNJibmLxdofb5n9c0T8waG0MpMByg2n4JjHbQ/WfXbV2U+B/61HemhSsR038KqlsOmTUJP9+2bDlq9cHbmKa/0BnAKhhCKapDKYSZc+lBoR3hcZ8WlQgY54pZVr4QcU8jSPQXn2zX/hFSRxM9ZwsXL76xTa/e0rDTXPOzsn1ZuET8RnOys4Jn20ds2k9WbtpeyA9JCv63WnYv4/E+G6eKg+m4U3GtJjBJWIwlY1bd8U8DNq2Rxo0+9eC5YF/DsTbxBLHzcDjUiwuN5tqPdRGkfi9IvzM9PtwlDa6xMFRj1pzDp/hF/GtSTec9c2yBIfr+Nt7Q0aXexpTzAtoxNwdDgA1BsE0xcFUVG/iZVMVLVVHhdfoT0tpaemib7+PeUBnzAeVe+Fil3c+CIw0Tfc+auJXenLKfSAxn5O8/IL+Q8fELO12zt7tfy/6M3yrsFDJIN7Rq2q6d1X0ZM/Ej6fcu9OkmfOW2AN5A6o8mGr5A19PqhY4cceKHkyV+L9btzne09KifY89P//74i8F0TexBOtk+HFpJoOGjY25mtlXv9z3ipgDioqK1/ywLXxOm2l6XJt37In5L/Lob01y+kxOvDO0TNMCZGRuDBzuElPMz6Xl7mcFgGqNYJr6YCoqbyreCg0NmvxDwx6q/+zfXus5eeZ8e3p+spnmwsVfJs6Y+1zrN1Sl1J5+6TU9OWs3bY9Z3nTvBw4dSx8x3ty7UqOKru49OyfX7GW8t2Cqft1cdffTiTPMkoTnHFP0Z9jQ67thy0777KnZJ1ArScqPrgvfnX7Rn99v2JL49OcqD6YSvgCn/2tI/aIHU0OPfcbcRXrazd5T85zoiTKrXFKbmBQXl2it69Yn3eRd/fxH93e11gUO2zUCq5maftGfh46eMK/+vQVTM0DPg17Z19MGmiWp37i1eVzqN7cNSyqYipZfW4RWV/vsqUVcqQL0eNdv3vFyp7fNkzB/ycoEywkANUCFgikAAACQKgRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgBMIpgAAAHACwRQAAABOIJgCAADACQRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE6492A6d9GKP/yxntqfnml15Pgpr7d2u3Hz1j/7DTFPi37Rn96EOHgOAaAy2Xdd0xK8UV+7fuP1tIH+wbqtN62KbNm5xy6Mfvd640i2HgGOIJjeVnDpcrc+6S+26aY2Yfocrzd5BFMAcFkgmNZr2OLg4ePetN/7+eCRun9u4h98z8F02XfrTH1p263vydPZXm/yCKaoDQimt+UX/NqkbTfzcIZ+NtnrTR7BFABcFgimal/OWuBN8ykrKxsz+evAyHsOpql6qyeYojYgmN5GMAWA2iAcTFt1Tiu4dNmbfJd61B8YSTAFKgHB9DaCKQDUBuFg+uCjjXbu2e9Nvmvtpu11Hn48MJJgClSCFAdTf+f+fx9dvCLzudZv6M8H6jZ4I23QvoOHy8rKSktL12/e8XKnt7XZq//VN/vt+fnf6jdzkJTMRPnSzESJU7nT6w1t2P5NN9D870EaNuXrb55s0k79D9V/Nm3AsGMnT4efgcAbQVZ2zojx0x5p0Ex/1m/cetzU2deu3zAzNGI+h4aWeeKMuc+07KSpeoxN23XX83CrsNCbDABInn3X9bePx0zxl4+SkpL0kRMCY9RsUdDbtd60A50SzoL+iuNvgcKkSqfqplqmSap3cxZ+m5ObF95d4p/bpu0/Ji6C4YXxJtw5UOHQ0RPvDv7UlCcVta69001t9UYAVed+BVN9BlUUM7/bprV/zQ/bRk38KvBJVBvVwuWrzRwkJTNJYTA9n5ffpmufwFTd3dMvvWZ+jxlM1fl//u9L5nfbXmzTTYnWzFZiPod6a9CC2Xc9f+vYs39efoEZBgBIln3XfaxRy7bd+prfn3+ly7nzed6I337Lys5p2Ky9maTAZ9+NbVFIYTDVG/43S1eZSOpvDZr8Q8XO/B4zmP715c6BIqg/J86YW1xcYgaHF8b03yosnDB9TuC2aoGbA1XlfgXTeO2/6j0V3h7U/O8LKZlJqoKpBrzd/5PApECzz0CCudmmjGuPZ4r5HG7cusu+H4Vbz/eHBna7AgAi8r/rzv7f5Q8+2sj8mblxqzfit9+WZGSaznoNWyxcvjqcQVMYTDUgwRu+aTGDacymyrjsu3VmcHhh1KncOXLCdDs+0HTzeYsz2G+KqnUfg6k+Ao4YP23Dlp36Gfg42KlXf70LfDlrgfk/gmn2fSElM4kYTE2nBmiY6bRvAcYP23bbdy4twEejv1i7afvnU2b579Q+A4FgascHFtK+kYWfQ2VWu3f2ySbttu/eV1paqg+4cxZ+a9+89KZpbg4ASIr/XffHfQftlUrfGTjcHCvlfxvXVI0JZ9DowdT0h9/qjUDJUBla9O33GZkbX32zn+1UixdMzXhVPVVD2/m313peuPhLYOZ2YXbvPWBLSfe+g82unLz8gveGjDadqjunss7evjOgitzHYKosZT546ee02Qttvzahy1eumvHfb9hi930q7ZnOlMwkJcG0pKRk4CdjTb825o1bd3kTfvvt0NET9o3JPgP+N4LAR0+N1wZvJnXs2f/K1WvqDD+HWiTzWPRTj+vOTW/TkgwfN9UM1nslO00B4B4E3nVnzF1k/rSB7ODh4/UatjCdSzIyNca+1eu2ZiYxOyVmFpTwW73hv1Sq/79hxcUlH4+ZYvrVYgbTlh17nc/LN/2B/aBmB014YVSP7Gwbt+p8NveCubkoyyrRmkl6TrxeoCrcr2D6WKOWh4+dNJ2i39VjJv1rwXKv984Htedf6WL67baXkpmkJJheunz17116m37/u4z4t3D7DPjfCJq2637xl/8cD+of/9eXO+fk3v6cGn4Ov5y1wPQkaA2btc/KzrkzVwBAEgLvugqjdpeBCWT2TdhEVY3RSNOj25qZxOyUcBY0/eG3emP56vWmv87Dj9t6ZPjvImYw9d+v+MfrIagnvDBXrl7r2PM/+1bjtb7pIwuLisxsgcp3v4JpYPPzbzP+zSlmIkzJTFISTOP1G+HljPeuZITHh3vsYidogacFABBR4F33VmHhOwOHm57X0waeOXvOXr504CdjS0pKNEYjTY+tOzE7JV4JCL/VG/H6JWb1iVm/jPD48ML4xyRo4eIFVKaaH0yff6WL/0z2H7btNv1q5QbTKtxjWvfPTTR1w5ad4bZ5xx5zJAAAICnhd93MjVtNz4OPNhr75b/MSQV1Hn587abtmhqz7vg7/f++u37jZrc+6abfXzLCd2pU4R7Tlzu9/f2GLYHiYtreA4eUyM1sgcpXY4OpTXj+gzWLi0sGDfOOGVUrN5hW4TGmav6TnLQkerMw7xq7ftpfVFTsTQAARBZ+1z13Ps8eDGab3bMQs+7k5Ob99eXOptN/wsPPB4/Y41OjBNMqPMZU9ch/kpNK0uYde0yJOXriP9c0BCpfjQ2m9kOwmjLl51NmqafH/3xkO9VsMPXvGdXWfubsucKiIvOe4v/+j3s+Kz8w3i58+JH6z8pXpyK13nHUvv1+gz2VMn3kBD7OAsA9CL/r+uOabWMmf212K8SsO4GDNfWmnZG5cea8JXakmj+Y+veM/mvB8qKiYs2htLRUSdReFkBNhewezsoPjI9+Vr5udfJ0th6mgvWHoyaZTi2h2VUMVJUaG0wVLs3XJiVoNphqy9TbUGCquQttzE5dx/TJJu38l+gHAEQX811355799rKAavr9x30HzaR4dWfijLl2fMzmD6b+U6xMU81S5dIklaEEb/imxQum4aZYWZHrmKqp3tnFBqpEjQ2myprzFmfYnZ2m6U/7/xc1G0wlKzvHP0nN3kXlf/PTd+s2+/ew2qZh23bvNcMAAMmK+a7r/6eZmv+SfPHqjupCy4697E1M03u+HewPpnpXV5D11yMbTDWpkr/5Sb98PGZK4LamdeTLBeGAGhtMpbS0dM0P25q2664tUO3lTm+v37xj0/YfzUg1fzCVnNy8gZ+MNe8FelNYvf4/lxHVllzB78rXT/3+y6+XzAyNeI9U9KD0FmN3+uqXz76YyVsGAFREvHdde0FTNf+FPOPVHdEbcvrICf53eL3nx8yCory4au2m51q/oUkqIj3fH2qPTJUKfle+KXAbt+5SzDUjJVCP/AujYf7vytf9tunaZ+nKNeYrBoCqde/BFAAAAEghgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgBMIpgAAAHACwRQAAABOIJgCAADACQRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgBMIpgAAAHCCc8H0bO6FTdt/zC/41fsbAIDq5tr1G1t27jl+MqusrMzrAhCBW8F0994DD9V/9g9/rPdU8w6nz+R4vQAAuCq/4Ncmbbupcs1dtML0FFy63KZrH/XUefjxZd+tM50AonArmC5YtkpbstmYt+/e5/Um49jJ0yMnTB/75b9yL1z0ugAAuG/CwfT4yaz/fu7vppwNHzfVdEZBCQPcCqZ5+QVd3vlAqTR9xPhr1294vcnYsnOP3gj+9EyrI8dPeV0AANw34WBaXFwyeeb8B+o2aNG+h7Km6YyCEgbUtJOf2KoBAJUpHEzvGSUMIJgCAHDvCKZACqUymC7JWPPR6C8mfTUvOyfX60pSzM176GeT1fPPfkN+vXxl8YrMpu2613n48YfqP9s3faT/BCndRMPCTTf3RgAA8Hv3u3LduHnL6/rtN9Wsdwd/+kiDZqpiz7V+Y/LM+fagNUoYYKQmmGafO/+Xpq/6t6Vpsxd605KRYPNWf8uOvez8TXuySbtDR0+YYWzVAIDoKqFy+YPpxq27zGVn/K1N1z7n8/I1lRIGGKkJpmabDLRdP+33JkeWYPNWe6BugxHjp53KOnvg0LH3hozWJ051vp420H+aFP8HAQBEUQmVywbTS5ev/r1Lb/V07zv4bO6FoqJi5VSVKvWMmzrbXuuUEgakIJj+fPCINqRwSxswzBsRWYLNWzF03uIMu/UWF5eMnDBd/XX/3EQLYDqFrRoAUK7KqVw2mKokmRj6w7bdZoDK2eSZ89WjwKrYajopYUAKgumK7zdoQwq3Fh16eCMiS7B5+zdd41TW2SebtNOk5avXe11s1QCACCqnctlgmpOb99eXO6tn+LiptwoLzZgwShhQbfaYBg4hl5iD2aoBAOWq5MpVVlY2bupscxcP1X+289sDZsxdlJ2TG/jCUkoYUG2OMSWYAgBSqJIrV3FxyZKMzKdfes3el1rP94f+8uslM0AoYUBqgmkln9toEEwBAPesSiqXXLp8VaWq96DhD9RtoDGDho1VZjWTKGFAaoKpUZlXgxOCKQCggiqncumnhhVculxaWmoGlJWVzVn4rcY0bNY+K9u7JjclDEhlMK04gikAoHqJUrl+2LY7XJsyN25V538/9/fjJ7NMDyUMqGnBVBuzNml1fjhq0vm8/J8PHvniq/k3b/3uhgAApEqUynXh4i9/e62nel59s9/J09klJSWqVs3bv6Ue/9W4KWFATQum9vqmtoVvCABAqkSsXD9s2/1Ig2a2Npmmni0795gBQgkDalowFQ2b8vU35hKnT7/02rJVa/XZ1JsGAEBKRa9cp8/kpI8YX79xa03Sz4/HTDlz9pw37S5KGGo5t4IpAAAAai2CKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgBMIpgAAAHACwRQAAABOIJgCAADACQRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAKs+twsLdew/8fPBIaWmp1wXgLheDaXFxyTdLVz3ZpN0f/ljvkQbN5iz8Nr/g1yZtu+nPuYtWeIMAAHDe0M8mq3j9s9+QGzdv6U+l0n4fjlKP2rips8vKyswwAIZzwbSkpGTUxK/MRmuatupKDqaFRUXzl6wcOWF6RuZGrwsAgOQFgmnBpcvN279lqlvP94fevHW7MynHTp5WeRr75b9yL1z0uoAaxLlgeirrrNlX+t6Q0VnZOfrz0NETlRxM9fahNxHdnd5QvC4AAJIXCKZlZWVLV655pEGzJ15ou333PjMmKVt27tEM//RMqyPHT3ldQA3iXDA1m9xjjVoePnbS6/rtN4IpAKA6CgTTiiOYomZzNJgGNjmCKQCgOiKYAklJZTBdkrHmo9FfTPpqXnZOrteVDLOxJW7hYHr6TM67gz+t37i1pj7SoFm3Pun7Dh6OeTj5tes3Js+c/0zLThr5UP1nO789YOPWXer0Z1CbgAONtwAAqJEqWLms0tLS9Zt3tOna54G6DdT0y9KVa24VFoaDqQqZelRrVHFMj6HKpfrVtXe6KpQGqKKljxivGudNvnvDcGMfCmqS1ATT7HPn/9L0Vf92Mm32Qm9aZMkG0+Likokz5tZ5+PHAGLUhoyYFPpuezb3QsmOvwDC1Xv0/1tuHfiGYAkCtkpLKZVy7fmPQsLH+WZnWsWf/bn3S9Uu5wVRTVbnsDW1Txp23OMNcWIpgitogNcE0Zpjb9dN+b3IyIv4rX58sta2aVKpJy1evP5+Xv3nHnlff7GfufeSE6UquZrDeMnq+P1SdGv92/0927tmfl1+wdtP2Fu17mMFq/g1bbxD8Kx8AarZUVS7/xWRUVlRcVGJUaDr16m9nmziYqlqpZpmRulWgSKlyfb9hixkp/CsfNVsKgunPB4+YzSnQ0gYM80YkI2IwtSfvK3Eqd5pOsZv3g4820rZtOrV5a8NWm7PwW/8Fja9cvdbjfz7SYDWCKQDUHimsXKpWqlm6bbx6pJY4mKpaqWap079LRc7n5Zv/9bXqnFZw6bLpJJiiZktBMF3x/QZtJOHWokMPb0QyIgbTGXMX6U9lUyVU02Np69U2rKnpIyfog6wM/OT2f1j0MfTylaveoLv03lSvYQtNJZgCQO2Rwsr15awFumHMenTufN7zr3TR1ATBVEVK1Uo9/vRpnTydvWHLzs079ly5es30EExRs1XLPaY2a/ZNH1lYVGTG+H0+ZZamduzZX1vypctX/96lt/5UpzfZx04lmAJA7ZGqyqUapEqkG8asR3ZqgmCqOqVqpZ6YRSqMYIqarVoeY1pucPRv9oHbBsScFcEUAGq8lFSucuuF+jU1QTBNXKTCCKao2VITTFN4biN7TAEAlSAllYs9pkBqpSaYGim5GlyUYCocYwoAqLiKVy6OMQVSKJXBNCUiBlPOygcAuEDVSjUrQT1SSxBMpdyz8l9PG2jnTDBFzVZdg6n/OqYxrxvn37y1PdvrmL43ZPSBQ8cSX8dUM/94zBR1Kvtu3fWT3hpmfbPsp/2HvMkAANxVcn+uY7pq7SZT+B6q/6wqoxkpNgd/OGqSytPPB4988dX8m7e8mQPVXXUNpqItOd43Pw0aNtb/sVUifvOTdejoCbNH1jb/+wIAAJYqTsxvflJ9eT1toH5JHExFU2N+89MjDZp9t26z/3u2/SnWNP/MgequGgdTI9nvyjdxUx9A23bru37zDnXG+6/9/n8ffSNtkPnW496Dhufk5nkTAAD4PfNd+S93etscOda0XffFKzIr8l35qmsjxk87dz5G6dGspnz9jSlnT7/02rJVa0tK/nMAAFCtORdMAQAAUDsRTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgBMIpgAAAHACwRQAAABOIJgCAADACQRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4wa1gml/wa5O23f7wx3pzF63wuqqCI4sBAABQqxBMYyCYAgCqSkbmxpETps9fsrKwqMjrAmoNgmkMBFMAQFUZ+tlkFaB/9hty4+YtrwuoNQimMRBMAQBVhWCK2oxgGgPBFABQVQimqM1SGUyXZKz5aPQXk76al52T63UlyZ8Ir12/MXnm/GdadtKfD9V/tm/6yNNncrxxv2dGPtf6jToPP/5A3QYt2vdYvCLzVmGhN/n3ogwmmAJALVHxyiUqIiolTdt1V2V5pEGzbn3S9x08XFZW5k2+Ky+/4LMvZpq6ppEvd3p76co1tgAphiqMalK4bdm5x4wBarzUBNPsc+f/0vRV/1Y0bfZCb1oybCLsP3TMi21u/+JviqdLMjIDm/q23Xv/9EyrwEi15u3fysoOBtmIgwmmAFDjpapyXbt+o+f7Q/3zUXugboNvlq6yBUu/KFzGLEBtuvY5m3tBYwimgKQmmJoYF2i7ftrvTY7MJkI1bdX6FHv8ZJbeO2b/7/InXmirTmVT//Z56OiJJ5u0U78+oX4+ZdaprLMar1vptups2bHX+bx8b2gygwmmAFDjpapyLV+9XjdUedIvhUVFqiADPv5cPU8172D/0acCZFKpallG5sa8/AKVtgnT56geqVPZtODSZTNS+Fc+arMUBNOfDx7RJhRuaQOGeSMis4mwzsOPz1uc4d85qs3bTLLb6q3CwncGDleP4qa2eTPM2Lh1l94jNGnM5K/NTJIaTDAFgJothZXL5MhufdKv37hpehQ6n37pNXUqqurPa9dvvJ42UH8GdpeILUAz5i7yugimqN1SEExXfL9Bm1C4tejQwxsRmU2E2oa1JXu9dy3JyNSkun9uojcU/Xnw8PF6DVuoR/1mgKV8qZSpSc+/0uXc+Tz1JDWYYAoANVsKK9eXsxbohk82aXfg0DGv6/dUs1S5NCZcgEpKStJHTtCkjj37X7l6zXQSTFGbObrHVNu51+WTlZ3TsFl7TTWfQTM3btXv6gkfSyo/7jv44KONbIpNajDBFABqthRWrtNncp5q3sHc/JmWnT4cNWnDlp3+TGn+11/n4ceffum1F9t0C7T6jVtrqr88EUxRmzl6jGnMRBiYqp/6XT3qNwP8jhw/ZQ7oMcekJjWYYAoANZ55nw+0e6hckp2T23vQcHPGgmmPNGj23brN5vAwU4ASN4IpYKQmmKb8rPzPp8zyunzYYwoASJVUVS6ruLjk9JmcWd8sMweY1mvYwtSUH7bt1p+2xJSLYIraLDXB1EjhdUw5xhQAUAkqWLlKS0sLLl1W1fCHyNwLF5u3f0tFxOxksf+U85/hZJSUlOw9cGjDlp36qd9NJ8EUtVkqg2nF2UQYPiv/xKkz5jOozayclQ8AqFrXb9zs1idd9WL4uKk2WV65eq1jz/6mU3+qAPX7cFTEAiQEU9RmjgZTtQfqNhgxftqprLPZ587rU+ZjjVqqUxtwvOuYaoxGarxuVe51TBMPJpgCACIyh5CqPM1Z+K2i5LXrN6bNXljn4cfV1m7absbYAvTEC22XrlyjcmNKm7mOaaBa2RkuX70+L78gI3PjyjU/eNOAms7RYPrekNH2JEfbtJUuifzNTy+26Xbs5Glv0F0RBxNMAQARKYn2HnT7P3KB1ueDEf5dnvEKkIrdkeOnvEF3KKQqqvrHUIxQezgaTLUR6veJM+byXfkAAMepiCxduaZN1z4qK2r65bt1m8NlyF/X1PSL6pE5OC0gOydXVU+1T6WqU6/+gQMAgBrMrWAKAACAWotgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgBMIpgAAAHACwRQAAABOIJgCAADACQRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcEJtCaZlZWXHT2Zt2bnn2vUbXhcAAABcUluC6bLv1tV5+PE//LFem659Ci5d9noBAKiY/IJfm7Ttpvoyd9EKrwvAvap+wbSwqGj+kpUjJ0zPyNzodUUwfNxUvWuo/fdzfz9+MsvrBQCgYu5rMFWlU71T1VPt87qAGq36BdMbN2/9s98QvQUM/Wyy1xXBsZOnW7Tv8UDdBpNnzi8uLvF6AQComPsaTFXpNGdVPdU+rwuo0WpLMAUA4H4gmAIpRDAFAODeEUyBFEplMF2Sseaj0V9M+mpedk6u15W8W4WFi1dkNm3Xvc7Djz/SoFm3Pun7Dh4uKyvTJLvxB9qfnml15PgpDdCbgv7UmKMnTn8wfNxD9Z/Vn+adQgM0TH9u2bnn9t3cYTf4Xy9fsXeqW/VNH3n6TI43yEeLoYXp2jtdYzRS4+ctzrh2/Ya9Xy2hNxQAUB1UvHL5g6kqwuSZ859p2Ul/xqwmCVKsypP6TUWzu2DCzV/FSktLN27d1fntAabeqWimjxhfbv3SSC3hZ1/MzMsv8N+pGRmlkupOv1m66skm7fS7PzTrrt8d/KkWQ/31G7c2CxOuv/GKJjueIKkJptnnzv+l6atamWybNnuhNy0Z2qR7vj/UPx+1B+o20AagjSpiMNVWZLYB0wKbUziYap4tO/ay403T9nbo6Alv3B3FxSUTZ8w1p/b724ttuvUfOka/hLcxAICzUlW5bG1SLVBF8M9QTSVpSUam2b3iH2xqk1+ywfTK1WsDPv48MFVNRXPe4gxlVjNM9Puchd+G65fu6+MxU8wvpoxKlErasFl7O8kEUz3AdZt2mBTrb+oZ/OnExxq11O8EU0SRmmBqNrNA2/XTfm9yZMtXr9cNtR7rl8KiIq2yZqt7qnkH+xEwwYpr1nU1bX7vDRl94NAxzUHjNSlBMFXTZjxi/LRTWWd1E93QbL2vpw30X/RU4dj0P/FC26Ur15zPy/cPViOYAkA1kqrKZbOmmqrJR6O/OH4yS6l39v8uV71Qp4qaLT12cOJg6nXF/1d+cXGJyZSm3ukeNefNO/a8+mY/07nsu3Xe0N9+27h1l4mMWh4tlZZN9U5VT0urTrVwMDUziVdJ1Vq077F20/a8/IJLl68qlR46euLJOztQH2nQ7PMpszR/3cuMuYvM3lPTCKaIIgXB9OeDR+xq529pA4Z5IyIzW2C3PunXb9w0PVqzn37pNXUqqpqeKMF05ITpgVPvEwRTbXv6cGk/zuqGurn66/65iR6a6bxw8Ze/vdZTnf/o/q62Q9MpupVua7IpwRQAqosUVi6bNQPVRE6fyTGTbLK0gysYTBUKdXfhe7T/eHz+lS7nzueZntfTBqqnZcdeZ3MvmGGiW9l9nDGDaYJKqlmdz8v3en/7raSkJH3kBPUrmyrIer136E8TWNUIpogiBcF0xfcbzDoXaC069PBGRPblrAW6YXjN9is3mAa2aiNBMP17l976wOd13aGPemZDsmk4c+NW/fngo4127gl+mLbbPMEUAKqLFFYumzUD/2czlmRkapLd05GSYKogOPCTsepv1Tkt/JUxBw8fr9ewhaaqculP3a/uXRH2+w1bzABLuXPQsNvzCQfTxJU0sPA5uXl/fbmz+qfNXuhPyaI/1alJagRTROHWHlN9uHyqeQdz82dadvpw1KQNW3YGPiaWG0xjBsQEwTSwwUv4jePzKbP0ZzjCGmZqzPsFADjofuwx/XLWAq/LJys7xxyRafZ0hOuLFT2YqhKpHqn/kQbNXmzTLdAat+ps/kev2qTB5hg5LYOWxNzcz0wNB9PolVR+3HfwwUcbqekXr8vHTPXfimCKBNw6xlSyc3J7DxpuD3xR04b33brN9kNYlQTTeCONBPcLAHBTqipXuGT4BaYmGBw9mNqZJG4mmCauUOE7TTA+XjCNueRW+Fbx7oJgCklNME3VuY1WcXHJ6TM5s75ZZg4wrdewhfkniFRJMGWPKQDUMKmqXLZkmCAYcD/2mF6/cbNbn3T1D/xkbElJOd9lyB5TVC+pCaZGBa8GV1paWnDpslZT/+aXe+Fi8/ZvaTW1G3yVBFOOMQWAGimF1zGNcoypypwpamMmfx04HNOMjBJMdUNzSr49w8nv4i8FG7bsVNMv+vPejjGNXkkl2WNMFyxbpT+fbNLuVNZZ02PoyWnVOU2TCKa1WSqDaQXZj4DDx021HwGvXL3WsWd/02l6qiSY2rPy9b7zy6+XTKdok+OsfACozWzJCJ8jf+LUGfN/P5tZ7XlLimX+q2Wfz8s3V9SOEkxl994D5oT6wLnzuhdzVr6NfXbvSVJn5ScVTJM9K99kZfX4F95fTwmmtZlDwVTM9qDtZM7Cb7URanPSJy2tpmprN203Y7Tumk+KWte37vpJG/Osb5b9tP+Qvfn9CKZir2OqdxmuYwoAMGzJULNXxTZX8TQXlldR85cec6Un9T/xQtuMzI2qJupp0b6HmUMgmNqyuHz1+rz8Ao1fueYH9SvPmSsbalb2aqM79+zv1Ov2rhx1+iOy/zqmpn5pCRNfxzSpYCr+65jqgevhm2cg5nVMbVY2C3/8ZFZgeQimtZlbwVQra+9Bw8166W99Phjhz452A7DNrO73NZjqXYBvfgIABNiSoYxlLyxjmxKh/5ufxGbKwLD0EeP1SyCY2j2pttnCpIpp/hEfaKpToyZ+5d+Neg/f/JRsMPXvf/U39YS/+UnCdVzttR7vt+naR78QTGszt4Kp3Cos1Oc5rZr65KSmX75bt1md3uS79v/76Btpg8wYZdmc3NsH2dzXYCra8PYdPGzuV1Ofadlp8sz5emtIcL8AgJrNXzL0+8QZcxN8V76horZ4ReZzrd/QsEcaNHt38KcapvKkPwPBVLJzcjUfzU3JslOv/v4DAJQ4t+3ea78BXz/1u+qUPwcbgfrVoMk/Royflvi78iNWUj89CrOoGlO/cWvzuOLdyg7W42rarruekF8vX1FF1kiCaW3mXDCtjsxZ+R179r9y9ZrXBQBAMhKfPl8b2Ouzxry+AWoJgmn57EmU6SMnhC/MYc8i/HjMlPCHVAAADFtNwvXCnj9U4/dxmFPywzuGJfCdVaidCKbl09vHmMlfa1N5qP6zG7fu8nrvsIcKxbySFAAAlqqJPabT/x95secnzZi7yOuqoex/9vVU+A+EvRb6ln/UTgTTSHJy815sc/sQogfqNvho9BeB8x/VAhfsAAAg7PTdb96OefZ6y469zufle0NrKKXzcVNnm9KpGqpK6q+ndUKX3EJtQzCN6tjJ0/ZyHoE2aNhYfdTzxgEAEN+en/8dPnlfTZ0HDx/3BtVoN27e+njMlPBVAtTz6cQZ4dOdUasQTJOgbWlJRqa5YoA2IXP+o95iSktLvREAAJTn8pWrM+YuMmflq+kX/VmrdnCobqp6pg0YZg5g0E/9HvN6AqhtCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgBMIpgAAAHACwRQAAABOIJgCAADACQRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAXlZaW/nzwyO69B24VFnpdQE3nVjDNL/i1Sdtuf/hjvbmLVnhdAADUFEeOn/rTM61U5rbs3ON1xVFWVjZu6myNVOv34SiyKWqJWhRMMzI3jpwwff6SlYVFRV4XAACVKHowvXnrVs/3h5pg2rz9WwWXLnsT7g9KJBxRi4Lp0M8ma87/7Dfkxs1bXhcAAJUoejCV7bv3PfFC20caNFu6ck1ZWZnXe39QIuEIgikAAJUkqWBamSiRcATBFACASkIwBRJLZTBdkrHmo9FfTPpqXnZOrteVJH8wvXb9xuSZ859p2Ul/PlT/2b7pI0+fyfHG3aGtWpO0hWs797ru8m9gavpFf4ab/31Bdzdj7qKm7brXefhxTXqu9Rv6U53e5LtuFRYuXpFphj3SoFm3Pun7Dh6+3/9hAQDcJxWvXJaK1LuDP63fuLWKSLwC4Q+mefkFI8ZPs+P1u3q8cXfES7Gap+b8zsDhupWmqkSmDRgWrxj5y5YGB6pblBJJ4UNlSk0wzT53/i9NX/Wv0NNmL/SmJcMG0/5Dx7zY5vYv/qZtb0lGpt0YUhhMDx87Gb47taeadzh4+LgZI9qS7aHotj1Qt8E3S1exiQJA9ZKqyiXFxSUTZ8w1yS/QhoyapDLkjfNlzY/HTDG/+Jt6tu3e6w2NE0wVEydMnxO+L/V8OnFG4OT9rOyc5u3fCoxUs9Wt3BJJ4UMlS00wNWky0Hb9tN+bHJkNpmpa7/Up9vjJLL13zP7f5U+80FadyqZ2+4wYTL2u+P+nyL1w0Wy3+iA4c96S83n5avMWZ5h71NZr99QuX71ePVoG/VJYVKSlHfDx54ExAIBqIVWVS/lMJcMkRc1TBUJFZPOOPa++2c/Mc+SE6UquZrDNmmoqOoqYqnGnss5+PmWW2f35ZJN2x06eDgy2hU/3NWfht+bmnXr1//ngEVUi/Xy7/ydmAcZNnW3zohajZcde6lQ9HTF+mu5F9zVj7iJzR41bdT6be8GMlHglksKHSpaCYKpNQutouKUNGOaNiMwGU21g2s79n8a0AZhJdrNJSTAtKSlJHzlB/XovOHT0hNd7h/5UpyZpgIapx8yhW5/06zdumjHayJ9+6TV1aos1PQAA96WwcinwmWLR8/2h/gPAFEYVSdX/4KONdu7x8q7Nmop6G7fuMp2GMrGZNHzcVFN0wsH04OHj9Rq2UI8/7Iq9L001u0JVQMdM/jrmHelPdWqSBtg6Gy+YUvhQyVIQTFd8v0EraLi16NDDGxGZDaavpw0MH9+5JCNTk+r+uYneUPRnSoJpTm7eX1/urH7/9mnpk6UmaYCG6c8vZy3Qn3oDOnDomBkAAKiOUli5TKVQaVBC9bruKrh0uVXnNE21Ozhs1rQ9lo2StuiEg6ktQ+H7Onc+7/lXumiqxvj/DFc3pdgf9x3csGXn3gOH7DLEC6YUPlQyR/eYmu0qICs7p2Gz9ppqPqWlJJhq49RnWfU3aPKPF9t0CzR1apIGaJgGnz6T81TzDupRe6Zlpw9HTdKGHdiGAQDuS1XlUrAb+MlY3bBv+siYl6b/fMosTe3Ys/+Vq9f0p82amRu3mgF+piTZohMIppq/7kV/PlT/WYXOQMFSj9kPapZED7Dun5vYWZUrXjCl8KGSOXqMaczLRQWmpiSYmpkkbv4NOzsnt/eg4Q/UbWCnPtKg2XfrNof3tgIAXJaSyqWCorKiG6rEeF2/p4KlqbovlTD9Gd4J6heYGvjT3lfiZoJpghIZU7xgKhQ+VKbUBNPsVJ+Vr4+YXpfP/dhjevjYyccatVR/zA+v8RQXl+hD5KxvlpnjbOo1bGGOLgAAVBcpqVz3vMc05gGaifeYKgh+OGqSf24JpGqPqUXhQ+VITTA1Ungd0yjHmG7fva/Ow49rq7MHlRu3CgvfGTg8vIHF3Oou/lLQtF139YcP95FDR09s2LJTd6R5lpaWFly6rCX039ye0R8zSQMAHFfxylWZx5ia/a/2DCc/RdXNO/aoZmVl3z5ZPiXHmFL4UPlSGUwrzgbT8Fn5J06dMZ/SbGa15y0FToS05xtGCaa6i3FTZ6s/fN6iPStfMVfB9PqNm936pOtPe76k6I1An1xNp+kBANQqqTorf9vuveaM+3CKtcHUHvFZ7n3ZmBu+I1slFam9rjglksKHyudoMFULXHfN/MNd25LdPrWRaOs1g83l3MxIc4U2tcAGZj5oag7LV6/Pyy/IyNy4cs0P6rdXetMNdXPNRD1LV64x1zHV2429jJSdw5yF32rOelOYNnuhMrTa2k3bzRgAQK2iCGivY9qifQ+VA5UYpUMVJvWo+S/tZLOmmi06qnSfTpxhwqKKTuLrmNr70vx1L6qbBw4de2/IaNPpv6+Y1zGdMH2OqZKtOqf5v2gqXomk8KGSORpMtY3Z0wBt04bh/+YnsVudv6nn9bSB+iUQTMODtb2ZSXoXeDHWNz9p6/1h224zRrRB9h50+yCBQOvzwQj/HQEAahVlwXjf/DRo2Fj/rk2bNdNHTrC7UWzTpHK/+SnBfalC+e9L4n3zk1Kp+Y+/Fa9EUvhQyRwNptoe9Lu2vQTflW/og50+CJrNW4Mnz5yvrSjeQdzZObmaj+amTVqfNf1X1Net9DHUfptw/catw19bLLcKC5euXNOmax99AFXTL9+t2xz4CjgAQC2kIpXUd+WfOXvu4zFT7u278lW/dF+m9plitH7zjtLSUm+EjyqU/aZ7Nf2ycPnqmJkyXomk8KEyuRVMU8Je6S3eOZIAALgvXjAFarDqGkzNKflq4c018O0XAABURwRT1ELVNZjayzx17zvYf0iNPTMx5tU0AACoLnbu2f+g77KmQG1Qjf+Vv+y7dXXuHA9qz4KMd2YiAADVwvGTWV/OWnAq6+yR46defbOfylnTdt0v/hI84QGoqapxMFXunPXNsgd8X5JmW9qAYeV+KwYAAK6x/743rc7Dj3+zdJU3DagFqvfJT2VlZSdPZ6ePGG/PTOzYs//GrbtinpkIAIDjci9cfPPdD80+l+dav7Hmh21UNNQq1TuYAgAAoMYgmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgBMIpgAAAHACwRQAAABOIJgCAADACQRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAUBudzb2wafuP+QW/en8DDiCY3jb0s8l/+GO9f/YbcuPmLa8LAIDIiotLvlm66skm7VRN6jduPWfht94EV+3ee+Ch+s9qaZ9q3uH0mRyvF6hqzgXT3AsXx375r5ETph87edrruv8IpgCAe1ZSUjJq4leqI7aprHjTqlpG5kaV1PlLVhYWFXlddyxYtsosap2HH9++e5/XC1Q154LpkeOn/vRMK20qW3bu8bruP4IpAOCenco6a/aVvjdkdFZ2jv48dPSEN62qxStwefkFXd75QKk0fcT4a9dveL1AVSOY3kYwBQDcMxUsFZHHGrU8fOyk1+UMChyqF4LpbWy3AIB7ZoKpipdKmNflDAocqpdUBtMlGWs+Gv3FpK/mZefkel3JMBt2uJnNSU2/6E9tY94N7gpnWX9PXn7BiPHT6jdurT8fadAsfcT48FHeMbfbsrKyfQcPvzNwuG6lqQ/VfzZtwDD1qN8bAQCo5u5T5VJZSaps5Rf82qRtN/XMXbTCX7aebNJu8sz5Mf/VbopU197p5hymQIGz9x5u5k7992huYunudKfPtX6jzsOPP1C3QYv2PRavyLxVWOhNviPZBTbzfKZlJ43RyHcHf8oZV4gpNcE0+9z5vzR9VWubbdNmL/SmRRZv865IMP14zBTzi79pG161dpM/X4aDqbbACdPnaJv031BNPZ9OnBHYPgEA1c59rVz3HExfTxsYLls93x8aiHqa+ZBRkwLD1JQj5y3OKC0ttfcebomD6bbde8MLoNa8/VtZ2f+Jkkkt8Pm8/JYdewXGKEn/sG23NwK4KzXB1Kydgbbrp/3e5GSEN1fj3oKpmlZ9RUy9AanpF7v7c/feA2awBIKpMuuchd+am3fq1f/ng0e0Bern2/0/MVF13NTZ7DcFgGothZXLxFPVHVUfryvJsmVzntoTL7RdunJNTm7e2k3bW7TvYTpnzF1kRkpxccnICdNNv4rUzj378/IL7GDVqe83bPGGxv9XfsxgeujoiSfvnMWlWvn5lFmnss4eP5n10egvlHfVqXCpiGlGJrXAmpV6NGel3qKi4jNnz3Xs2V89bbr2Kbh02RsE3JGCYKrEZtbCQEsbMMwbkYzUBlMF0I1bd5lOQ286ZpJ/Kw1stwcPH6/XsIV6tOVr+zdjxL4XaKrGeL0AgOomtZUrhcH0ySbt/Gf0232NSnJXrl4znUqiDz7aSJ2BImUHt+qcZgNf9GB6q7DwnYHD1RNYBlElNQcMjJn8tdkvE32B7fPw4ahJdp/OT/sP1f1zEz2KH/cdND2AkYJguuL7DVrhwq1Fhx7eiGSkNpimj5xQUvKfjVa0VWi70iRtEnpjMp2B7fbLWQv0pzY2fVg0A6xz5/Oef6WLpmqM1wUAqG5SW7lSGEw/nzLL9FhLMjLV37BZe/OfdBU1lTb1+NOndfJ09oYtOzfv2GNTbPRganfK6B5Nj2VLpyqg6qB6klrggZ+MVY8C69ncC2YMEE8N32O6fPV60+Onz2fms6ad6t9uC4uK+qaP1J/6dKgt8MU23fxNPeZTo8YELlYMAKgunN1jGjjiUwIzV+I0/wcPJ8KYogfTzI1b9acNlAGmdNp9OtEXWOy3TNV5+PGm7bp/OnHGrp/2+/f1AlYNP8Y0MBPDTrWbk3+7tXeUuBFMAaBaS2HlCkcxuU/BNMHImKIHU/2iP9WpSabHL7DMSQVT2f/vo5169fefUvxU8w57fv63Nxm4KzXBNCXnNhrhzdW4t2Cqz3+mx8/uMbVT/dttWVnZh3dOdfQf0AMAqGFSWLliRrH7FEyr4x5Tq7Co6NDRE+Omzn6sUUuNadyqM//cR0BqgqlRwavBGeHN1bD/YX9n4PDA1ZrsYeD2JnYmCY4x9Z/AFNhuzafGmGc46R1h8449G7bsjLndAgCql5RUrphRLKmyFT3nuXaMabkLXFxcouXUeP+/GRVPTZmOecQdarNUBtOUiBdMxZyTFDjR/tr1Gz3fH6p+/03sTAKDxZ6V73+nCGy3p8/kPNW8g3oCV2KzZ+XrDUVvK14vAKB2C0QxK3rZSmoHZLln5b+eNtAWr+jB9N7Oyi93gfPyC8xJw/6RObl5f325szoXLFvldQF3OBdML/5S0LRdd62s3fsOzsrOOX4ya9zU2eZDof0w90iDZjPmLso+d14bZ6det/+jYVo4mKo9ULfBqIlfafCprLOfT5llrmOq+dhT8iWw3Wqrm7c4wxwKYy4Rpy3wwKFj7w0ZbToD7wUAgNosXjCNXraSCqZ2L4mavY7pqrWbzByUIO1sRTM0nctXr9ewjMyNK9f8oP6Y96g8qlSqTrvAKp0jxk9LcB3Tche4pKRk+Lippuf7DVvMDlRzyFzM/0yilnMumPpDoWla9bUBxJykpj//56PR5mgVuynaYHrP3/ykLWfijLmB+zKt96Dh/t2oAIBaLpwdjehlK6lgKqpWMb/5SYHyu3Wb/QXO7ka1zdxFvHuM981PL7bpduzkaW9QkgusZWjTtY+dlWl6HsZM/jpwuB3gXDAVhcIlGZnPtX5DK6423S9nLbD/cy8tLV2/ecfLnd7WCq182bV3+r6Dh20MDQdT9fi/w1dbbMzv5435nw5t2PrsqPFmJ6s+L2q70r1rGbwRAADED6YSsWwlG0xFRcr/Xfkqcyp25gDQgOyc3L7pIzVMy9CpV3/zb/oE93gtye/K97ruirnAmueMuYuatutunwclYOopwlwMphUX3uYBAADgOIIpAAAAnEAwBQAAgBMIpgAAAHACwRQAAABOqJnB9OTp7Lbd+r7YptuP+w56XQAAAHBbzQymAAAAqHYIpgAAAHACwRQAAABOIJgCAADACQRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAASJmzuRc2bf8xv+BX728kw8VgWlxc8s3SVU82afeHP9ar37j1nIXfehMAAKjm5i5aoerWpG03gks1MvSzyXrV/tlvyI2bt7yuOHbvPfBQ/Wc1+KnmHU6fyfF6HXa/V8h/LViu+atlbtzqdSXkXDAtKSkZNfEr8xhM09rgTYNPRubGkROmz1+ysrCoyOsCADivWgRTVRbVF1UZ1RqvqxbIvXBx7Jf/0qM+dvK013VX9GC6YNkqk17qPPz49t37vF6H3e8V0sxfbcvOPV5XQs4F01NZZ82+0veGjM7KztGfh46e8KbBJ/pGAgBwR7UIpqosqi9azlq1b+jI8VN/eqZVzAgVvebm5Rd0eecDpdL0EeOvXb/h9TqMYFoOLbeW/rFGLQ8fO+l1IRaCKQBURwRTZ6UkmFY793uFtLuQq3cw1Zqh9cPrQiwEUwCojgimziKYel0plWyuS2UwXZKx5qPRX0z6al52Tq7XlQyz6OFmtgq7TuiBde87+IG6DfSnXXXKysr2HTzcrU/6Iw2aqb9+49bvDv40cNCxnnE972aeMZt/8zMzfGfgcDPDh+o/mzZgmHrU7424wy7Vr5evLF6R2bRd9zoPP67BfdNHhg95vlVYaMdotlra8AwlL7/gsy9mPtOyk+askS93envpyjW6rZlq3yzCLbwhAQASq2Dlsvzv8KpQbbr2MW/d4UATzgG258zZc5NnzjfHs6lMjBg/TRVBA4qLS1at3ZS4xBjqV/lTETRziFdoEtSjeLUySrAot3Tu3LP/wUcbadKSjEzT4xeeWu4MjXgJIUG8DmTQeAnEvnDRy719AvWyel2+l1gv6PrNO7R6aCHV3kgbFH44hnkpzQNXJJg4Y67mbJYzYsiL+OzFDKb23vUwn2v9hlbL8GEJEeef1DJLaoJp9rnzf2n6qu7YtmmzF3rTIou3Wpj1yawT/+f/vlT3z03sJLM+6ckaNGys7bRNz+aMuYu0Pd+ZfRLBVFvshOlzdPPAAPV8OnGGzYhilkqzbdmxl3+kmt5Z/EfHaiF7vj80MEYr5TdLV9mXUL/oEZlNJdC0Ep/NvaAxBFMASImUVC7jytVrPf7nI/+sTOvYs78yn36x+UbiBVPV9fD7/1PNO/y0/1C4xgVKjKjYKbuEK5fakFGT7L1L4noUr1aWGyyilE7d9etpA9WpNOMvpqK7HjP5a016/pUu587nqSfZWhxOCCkPplHKvX0Cw8FU99j57QH2hqbpdd+4dZc37g49FYrm6g+M1M0/HjPF/FJuyIv+7IVXSC1P+N6VQ87n5ZsBEn3+5rmNssxGaoJpzJV410/7vcnJiPcAzDqhpo1HHyJPZZ3VM1hYVKRNceSE6WbSq2/227Blp544fbI0i6QnaN7iDJP8SktLCy5d1q38TR9PX+vxvkbaNUOD5yz81sywU6/+Px88omH6+Xb/T8wLMG7qbDNDCS/VgUPH3hsy2ozU5mc/YSxfvV49uhf9osXWPAd8/Ll6/JeT0JqtB67OJ15om5G5UZ+r9L6pF958FtE6oeU3I8Xctf/NDgAQXaoqV7gM6d175579qiB2tlGCqZpqxyeff2lKSd/0kabz/3v8BfWbeqSiMGriV6o46lfP5StXzRxUlVTsTOnRnFVoVAo379ij5TEz0RLa3TRR6lGCSBdT9NKpyKU/6zVscfDwcXNbQ2FUkVSTFE81MvoMJV5CiB5MjZidRvRyr7s2q1Y4mKppvG6l22oOmo95KW0WN3TvJheq+s+Yu0gvun+wWrkhL6lnL7BCXrp89e9dequne9/BZ3MvKGcpHZmnxd4qqfn/uO/gg482+uvLnXNy//MYE0hBMNWimIULtLQBw7wRyUgcTPWAbdA07J5//1Yn9hOhPsroFfV6f8++m/hnq01FG0x4hnawf3OKuVR2pD666ckxnWakPjpfv3HT9GhVe/ql19Sptwb9aT9H6tOY/0OJ2M8uWkG9rrszJJgCwD1IYeWyVWP4uKn+HUX6XT1mthGDqYq9v5SY3WNqigg292iAyQSqfSr5plNlTsVOnSp8dqTYeqTBKpems9x6JMkG0+ilMxBAzTAxgdU+qIrXYkl5MI1S7hMHU//D0Xw0N81T/fYan3aZ9YqcOHXGdBo2DJQbTJN69gIrpH0Sfti22wzQck6eOV89CqyKrepJav5mhv4VPrEUBNMV32/QQoRbiw49vBHJSBxMm7brfvGX2wfcGCUlJekjJ6i/Vec0/95Ew26o/jxn+VcI/zP75awF6tENw3HWbk4aY3rMUtmXyrJ3bTdyO1t9TjI9AVqnzf8gwkfe2IfZsWf/K1evmU5z1wRTALgHKaxc5u29cavO5oArP/WoX1OjBNPwLiVbFwJXJtcwDVb/gmWrTI/KnP6MWblUHFUiNVV1RNVEPeXWI0k2mEYvnbai+XcT2l0zdtdj9BlKzIQgKQ+m4bARLvcJgmnDZu2zsn93QKp9dT6fMsv0RAkD4YwUkNSzF1gh7doV+KDll9T8qyCYpvBzpyQOpoEcppSmrKZ++4r6FRYVmX+FDPxkrNkaLaVSewCH/+AbexNN0jP7Yptu/qYecxON0UiNj7lUEl4vT5/Jeap5B/WoPdOy04ejJm3YstN/K63TmqSgrA9JgftVM0ey+9fpeHcNAChXqiqXrRq2LvjZqf736kAOiNljxMtJgRKjAqcypz9jLoOoRGqq3bVRbj0S/Rkv0oXZhxmxdIZPcjL/7bU9yc4wXkFM8ChiPrfxnnCJXu7DPRLvJQ4voQkD4QhrmKnhjOSX7LMXWDYFpHFTZ6vHzKHz2wNuH06Qk6v+O7NPev7mWQ0/9niq2TGmgXUi5svvF29NsvvDA//1sKtI4lbuxhBzwfS69h403B4jovZIg2bfrdtsXmyzZiRuBFMASJWUVC5bNWywCAi/V4czSrjHiJeTAiWm3GUIzz9xPZJy5+lnBydutnTa/aPmFCjdaeC0p2RnGK8gJngUMZ/beE+4xLuLcLkP90i8lzi8hPFGGvEykl+yz174HouLS/QJwRzdYZvy0i+/XtLUZOd/+crVyTPnR/+iytQE0+zUnduYVDC9tz2mh46eePLOjvfw0ZzaPPTZUZP8/zRPIPqaaun11qfVWd8sMy95vYYt9MFd/T9s260//cepJBbvrgEAUaSkctlCY8uwn53qf68O54B4WSRiME12j6kVrx6JDR82MCWQbOkU5R5zjwcPH7f//LVHnaaqFid4FM4G04rvMU322Yu3bHLp8lU9FfYzzKBhY7XO3MPLnZTUBFMjJVeDSyqY2uMtoh9jejb3grnWw1PNO8R8Xc0r5D9u19ILsHnHng1bdpa72zKwXtoLAviH5V642Lz9WxpjUrXdHsJHxOph7j1wSPernzZhx7trAEB0Fa9c5ni7ih9jGk4G8XJSoMRI9GNMo9Qj0dRAYEosqdIp/jC6eEWM8/STmmG8gnjz1i1zGnT46lT2cALXgqk+G1T8GNOknr3AsmmR9ItWEq0qZoCSqDnfzsblpOafrFQG05RIKphKUmfln8/LN6lUnYErwFn24Jvo5zaWu6Zev3HTXMpu+LipNlnqxdOnDdOpP7XN9PtwlP4ML5s98MB/DmO8uwYAVCbVZlVo82buTz/6Pamz8sOpJXowtTtiyq1cUeqRaGkDgSmxpEqnqJaZf9/rAZovlAmUs5TUYjEfG1RDVUm9Ll9CUHMtmNoeDdaTYDqN6GflJ/XsBZbN/P82cBeZG7eq87+f+/vxk1n6M6n5a7Zfz1+6cPlq/8gEqn0wtc+CWqde/fVE5OUXrN20vUX7HurxX9nBroj/Ve+ppSvX6JkKNPP5QIPt2fpmhprkv1yZ7k53au49+ppqXnitUvrYocFamGmzF2qGalpaM8YeY/DEC221hIrR2efO63OwuY5p4MADO8Plq9frIWdkbly55gdvGgCgsoTLkEqAfup306nmLxPhjBLuMaIHU3/lUvlTWQlcS9VfuaLUI83QXKxKVWnrrp9UfWZ9s+yn/YfM1LCkSqdhdw2aFthBmJJaLPZjgyrpzHlL9EACL43/ub34S0HTdt3V2b3v4KzsHIWwcVNnKxtoUqUFU9EimQD6WKOWt088uqfrmEZ/9gLLduHiL397rad6Xn2z38nT2fr0ovsyO9TtNROiz18fz94ZOFw9av6dawlU+2AqepriffPTxBlz7VNvt/B4zb4qukm878/oPWi4eVWM6GuqbqXb2vnY1ueDEf7bbtu9N+ZC6qNJ4Amxe39t828DAIBKcyUV3/wUTi22bJUbTCVB5VKJ9FeuiPXI7iuxLbAYAdFLp6EecwqUmj3tya/itVj8Eco2/fk/H41W7NPv/gcVHmxflMoMploMxXSTTf1NK0P0b36K/uyFl+2HbbvNHjF/U4//uYo4f3u5frV4x0AH1IRgKnoV95X3XfnRg6lohtom7dfU6mNKm6591m/eYQ+5MKKvqaLPDUtXrrHfkKtfvlu32f9/H0O31Ytt/rWhpl9ifketZOfk6mXWuqs1Qx9Z4h2cAAC43/RmvnhF5nOt3zAlo0X7HvpTneEyEc4B8VJLUsHUUOGL+F35UerR/n8ffSNtkBmjtFHuN/dELJ2WOQVKLd6+tArWYkODdZOXO72tWqmK2bX37eck3nOrvKWlMq+jkuuXsxaYpyV6uY/56sR7iTU3zVOTNH+v6y69lKbEa6pe0BHjp+XlF8TLSDFFfPZiLpvuPX3EeLMi6acC8Zmz57xpd0Wc//LV6zXgiRfabt+9z+tKyLlgCgAAcF+ZK6eq2W/PqhbMWfnRv96zOiKYAgCAmsaekh9zT6q5joFrCc8usz2a0+/W3eM14+0brhkIpgAAoAYy/6R+8NFG6zbt8LruOHT38FlzCS2v1w3m8IY6oe/91+/2+NfAiWI1DMEUAADUQAWXLrfp2kdJ7oG6DUaMn3Yq6+z5vPylK9c88UJbdSqbKqF6Q51x+crVrr1vnzCnDPp2/0/CJ7wHrtBU8xBMAQBAzZSVnWO+XyDQHmnQbMOWnf5dku7Iyy/o8s4HgQU2rWPP/prqjauhCKYAAKDGunHz1pKMTHNWvrLdk03affbFTMfjXXFxiXJz57cHmLPyzQnvazdtV783ouYimAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgBMIpgAAAHACwRQAAABOIJgCAADACQRTAAAAOIFgCgAAACcQTAEAAOAEgikAAACcQDAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4wa1geuPmrX/2G/KHP9Z7skm7Q0dPeL0hW3bu0Zg/PdPqyPFTXhcAAACqOUeDqVr3voOvXb/hTfg9gikAAEDN424wVRs3dXZZWZk3zYdgCgAAUPM4HUwfqv/sxq27vGk+BFMAAICax9Fg+nrawJYde+kX/Tyfl+9NvotgCgAAUPOkMpguyVjz0egvJn01Lzsn1+tKkg2mQz+bvHHrrofqP6vfPx4zpbi4xBtxR7xgWlZWtu/g4W590h9p0EwD6jdu/e7gT0+fyfEm36WZa6ru6NfLVxavyGzarnudhx/XffVNHxkeLGa27wwcbmarkWkDhqkn5mEGAAAAuDepCabZ587/pemrCm22TZu90JuWDH8wLSkpGTXxK/2u1Ljsu3XeiDtiBtNr128MGjbW3Lu/6eYz5i7yR1sTTJu07WZ2yvpb+GoAtwoLJ0yfo5kERqrn04kzNNUbBwAAgIpJTTBVyAvkNrVdP+33JkfmD6b68/KVq5169defyovHTp42YyQcTJU7R06Ybu731Tf7bdiy83xe/qq1m8yCKUTOW5xhd3CaYKr2QN0GI8ZPO5V19sChY+8NGW3S5+tpA+3VAHSTOQu/NYO1JD8fPJJf8Kt+vt3/EzM43ulZAAAASFYKgqmCmolugZY2YJg3IrJAMJVDR08olaqn5/tDbV4MB9Ode/Y/+GgjdSqe+neO6ia6ofo1EwVQ02mCaSCt2mhb989N9IhM58HDx+s1bBGerR2sqRrj9QIAAKACUhBMV3y/QREt3Fp06OGNiCwcTBUcFR/N7sk5C781OTIQTEtKStJHTlBPq85pBZcu37ndfyiPmmg7Y+4i02OC6d+79L50+arpMezI5avXm54vZy3Qn/5Qa507n/f8K100VWO8LgAAAFSA63tMRZ1v9/9EnQ/Vf3b33gPqCQTTK1evdex5+z/+n0+ZdecWv1NYVNQ3faSmDvxkrCKsekww1R1pzmaMkV/wq/nX/9xFK/SnvaHuVxn0xTbd/E095twsjdFIMwcAAADcM6ePMbXO5l5o3Kqz+lt1TsvLLwgE00CgDAsk0YjB1C5M4kYwBQAASInUBNP7cVa+13WXvXrUyAnT9bt+ud97TMvKyj4cNUl/aua6CzMGAAAA90lqgqmR2uuYel132fONHny0kSKmfqngMablBlPRL/oz5hlOiqqbd+zZsGVnVnaMS58CAAAgWakMphWXIJhKXn6BoqemmmaDqdzDWflRgunpMzlPNe+gHv81AcSfknXXXi8AAAAqoDoFU/n54BFz/SY1fzC1SVGtU6/+CotKsWs3bW/Rvod6Yl7HNEow9V8TwMxWY/wXPQ3kYAAAANyzahZM/UnRH0zlWvxvfpo4Y64/PkYPpqIb6ubmHgOt96Dh/t2oAAAAqIhqFkzF/nc+EExFsTWp78qPEkxFsz109IRmZWb7QN0Gbbr2Wb95R2lpqTcCAAAAFeZWMAUAAECtRTAFAACAEwimAAAAcALBFAAAAE4gmAIAAMAJBFMAAAA4gWAKAAAAJxBMAQAA4ASCKQAAAJxAMAUAAIATCKYAAABwAsEUAAAATiCYAgAAwAkEUwAAADiBYAoAAAAnEEwBAADgBIIpAAAAnEAwBQAAgAN+++3/B3k4hZSys7rxAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"C:/Users/T0230575/Desktop/Datalab LAS/Documentation/Method/mutable_immutable.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bear in mind that mutable objects by default are dangerous !\n",
    "\n",
    "Especially when writing functions, do not hesitate to use decorators and If tests to assess None, Null etc to prevent mutable objects from changing their values.\n",
    "\n",
    "Example : if the values inside the function are supposed to be emptied at start, tell the function to do so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Hello': 'hello'}\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def test(_dict, _string):\n",
    "    _orig_string = _string\n",
    "    _string = _string.lower()\n",
    "    _dict[_orig_string] = _string\n",
    "    \n",
    "d = {}\n",
    "s = 'Hello'\n",
    "\n",
    "test(d, s)\n",
    "print(d)\n",
    "print(s)\n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Dictionaries are mutable objects in Python, so the function can directly change it in the _dict[_orig_string] = _string statement. Strings, on the other hand, are immutable. When the function creates the lowercase version, it has to assign it to the _string variable. This disconnects what happens to _string from the external s variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Best practice for default arguments\n",
    "One of your co-workers (who obviously didn't take this course) has written this function for adding a column to a panda's DataFrame. Unfortunately, they used a mutable variable as a default argument value! Please show them a better way to do this so that they don't get unexpected behavior.\n",
    "\n",
    "```\n",
    "def add_column(values, df=pandas.DataFrame()):\n",
    "  \"\"\"Add a column of `values` to a DataFrame `df`.\n",
    "  The column will be named \"col_<n>\" where \"n\" is\n",
    "  the numerical index of the column.\n",
    "\n",
    "  Args:\n",
    "    values (iterable): The values of the new column\n",
    "    df (DataFrame, optional): The DataFrame to update.\n",
    "      If no DataFrame is passed, one is created by default.\n",
    "\n",
    "  Returns:\n",
    "    DataFrame\n",
    "  \"\"\"\n",
    "  df['col_{}'.format(len(df.columns))] = values\n",
    "  return df\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use an immutable variable for the default argument \n",
    "def better_add_column(values, df=None):\n",
    "  \"\"\"Add a column of `values` to a DataFrame `df`.\n",
    "  The column will be named \"col_<n>\" where \"n\" is\n",
    "  the numerical index of the column.\n",
    "\n",
    "  Args:\n",
    "    values (iterable): The values of the new column\n",
    "    df (DataFrame, optional): The DataFrame to update.\n",
    "      If no DataFrame is passed, one is created by default.\n",
    "\n",
    "  Returns:\n",
    "    DataFrame\n",
    "  \"\"\"\n",
    "  # Update the function to create a default DataFrame\n",
    "  if df is None:\n",
    "    df = pandas.DataFrame()\n",
    "  df['col_{}'.format(len(df.columns))] = values\n",
    "  return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you need to set a mutable variable as a default argument, always use None and then set the value in the body of the function. This prevents unexpected behavior like adding multiple columns if you call the function more than once."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use context managers\n",
    "\n",
    "with `content-manager`(`args`):\n",
    "\n",
    "The function of a context manager is to :\n",
    "- set-up a context,\n",
    "- run the code,\n",
    "- remove the context.\n",
    "\n",
    "open() is an example of a context function. When we use open(), what happens is :\n",
    "- it opens a file at the specified path,\n",
    "- allowing it to read, delete rows... do things with our code\n",
    "- finally it closes the connection with the file properly to make sure we can continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The number of cats\n",
    "You are working on a natural language processing project to determine what makes great writers so great. Your current hypothesis is that great writers talk about cats a lot. To prove it, you want to count the number of times the word \"cat\" appears in \"Alice's Adventures in Wonderland\" by Lewis Carroll. You have already downloaded a text file, alice.txt, with the entire contents of this great book."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lewis Carroll uses the word \"cat(s)\" 24 times\n"
     ]
    }
   ],
   "source": [
    "import os, sys\n",
    "\n",
    "path='C:/Users/T0230575/source/repos/DataCamp__/Python/_data'\n",
    "os.chdir(path)\n",
    "\n",
    "# Open \"alice.txt\" and assign the file to \"file\"\n",
    "with open('alice.txt') as file:\n",
    "  text = file.read()\n",
    "\n",
    "n = 0\n",
    "for word in text.split():\n",
    "  if word.lower() in ['cat', 'cats']:\n",
    "    n += 1\n",
    "\n",
    "print('Lewis Carroll uses the word \"cat(s)\" {} times'.format(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " By opening the file using the with open() statement, you were able to read in the text of the file. More importantly, when you were done reading the text, the context manager closed the file for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# image = get_image_from_instagram()\n",
    "\n",
    "# # Time how long process_with_numpy(image) takes to run\n",
    "# with timer():\n",
    "#   print('Numpy version')\n",
    "#   process_with_numpy(image)\n",
    "\n",
    "# # Time how long process_with_pytorch(image) takes to run\n",
    "# with timer():\n",
    "#   print('Pytorch version')\n",
    "#   process_with_pytorch(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Terrific timing! Now that you know the pytorch version is faster, you can use it in your web service to ensure your users get the rapid response time they expect.\n",
    "\n",
    "You may have noticed there was no as <variable name> at the end of the with statement in timer() context manager. That is because timer() is a context manager that does not return a value, so the as <variable name> at the end of the with statement isn't necessary. In the next lesson, you'll learn how to write your own context managers like timer()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing context managers\n",
    "\n",
    "2 ways to define a CM :\n",
    "- using a class `__xx__`\n",
    "- decoration ``@xx``, then the function \n",
    "\n",
    "Notes :\n",
    "- yield is an intermediary \"return\" statement (it returns a value, but allows us to continue the function).\n",
    "- return returns a value, but also ends the function.\n",
    "\n",
    "yield is what makes content manager so useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"C:/Users/T0230575/Desktop/Datalab LAS/Documentation/Method/func1.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAIHCAIAAABMmf9LAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAEnQAABJ0Ad5mH3gAAJEQSURBVHhe7Z0FYBRHF8eT09xd3N2VEBIieHB3lwKFFi30Q1qgBYq2QHEpxV2KFi3u7lESIiQh7m7n973LLsflEsIlJCHh3q/bMPNmbnX2v+/tzO6qSyQSNQRBEFWFQv6LIAiikqAIIgii0qAIIgii0qAIIgii0qAIIgii0qAIIgii0qAIIgii0qAIIgii0qAIIgii0qAIIgii0qAIIgii0qAIIgii0qAI1pycvPwlq/9ybNGjqX//rXuPlnJ5ZIGamlAoOnn+aru+o02b+P8wd1lSShpZUAfAzOcuXQurAROsD6wVWdCYCQ6LGDVljoFz657DJ915+Fz+NR9V7HYEqQnQvKpFVk5un1FT6GYenz+N/9+CgsIimOej5wEKRbsOnSQW12ApKeXOXLBSfp2XrNkqFAqJ0hPnrug7tZIVwZmckpZBFNUub6Ji2vb5RrYgmLoN/T4pNZ0srj1ge6fNWy6/oK5Dvk9OreFGVT236Nh38hsFe/LWg6dEUdW7XRkaY2NDqku1mit6gjUE1OfM5Ztkpoz/rt2NeZcIifyCojOXbhQWFRN2AM7hu4+ek5naQyQSHT935XlAKJkv4+6jF2f+u0FmGieXbtyX3yjYk/9evE54fFXsdgSpGSiCNSTybVxaeiaZKSMkPDIhORUS6ZlZb2MTCKOM8MgY0CwyU0sUFBUHhr4hM3JALFlcUkpmGhsgdlEx78jMe8CSm1cAiSp2O4LUDBTBGkKjUcnUe7Q0ORSKdH9SKZSKpdQKls+Hok5haTDJjBxMBoNYk8aIuroalaq48jQqFezSxMd3O4LUDGw9NcTB1trUxIjMlGFnbWlpZgIJQwN9W2sLwijDxcGWSq1lHdTW4rTy8SQzcrRt0VyDySAzjQ0NJhP2LZl5j72tla6ONiSq2O0IUjOqLYJw1bU0N+3WoU2lk1dTV7Lee1p6N1OoI5uMDfUb7zXc1NgIdI3MlOHiaGegrwsJTQ7Lyc6GMBI42lnb21iRmdpDXV191OA+Q/p1J/NlTB0/omcXfygi840Qd1dHMvUeVyd7Bp0GiSp2O4LUjGprkJ6O9o51Sy8d21HpNHvqOLLee5bMm65QRzatXvwzh80i6zU2DA10FRS/mbuzrrYWJMDja+HTjDASwDlsZ2NJZmoVEyODPRt/P7J9zfABPb8dMeDcoa2rfvtJX1eHLG6cONvbtPb1IjMgfCZGsKsJP7qK3Y4gNQPD4RrCoNO9mzUhM2V3piArC3jBW2nWxIVIA01dHetOmOBCAgoIOghq2Ltr+8Z7XZFhZGjQ1M2JzMAlxNEWwmEiXfVuR5AagCJYczzdXcHFI9I+nk2auHwI4izMTLw8SIcFTlT/1r4V7+gjH4OlwfT1ciczamqtfDxNDA3ITJW7HUFqQEMXwezcvD1HTg8eP8OxRQ+GebMW3YdPnbP06atgsVhM1vgUBYVFl2/enzh7EfwW5gCTf98x85atC4t4q/xMKsXKwtTHkzxXvZu5G8rdmQJ3rKU3GRF7urs423+4jQVb1PebqcSaENN3MxbKDyqU59iZS/I1Ybp5/wlZVkZUzDvfrsPkKyxataXqsTilXN69xy9+WrQa9gPxE2KvPn4RKBTW2iAeWMqNe49htzf17w+LgL/VWoSvZ1NHO2n3CFxC/LybyV9CqtjttUhEdGy7vqOJ/SObfpi7LDM7l6whR812abWO3YqNO+VrNmnbNzQ8CuzVmgk0HvmaMF28fpcsK49EIlm5aZd8zWYdBhJLVAA28GXQ66VrtnYeNN7AuTXUhGM95od5MGc49chKlVHFiZCRlSN/1sO0+/Ap4lcyPrOBydNwRZDH52/ff9y9bb9p85b/d/1uQpJ0LFjQ64h9/5xp32/s6B/mpWdmEzU/RnFJ6eZdh727DBn47Y+HTpyH3xL2ZwEhm3Yeat55cOdB370KDoPjTdirC5yfbfzIW1etfT2ZjHIdsuC/EKdxcw83UxNDwvhlgV164tyVtn2+6TZ0wta9R2E/EHZir3YcMM6r0yC4YHzmtQH2552Hz7sM/q7PqKmw24lBf/CXWETXId/DPv/kImytLVqWdXy7Odt7uH4IjYGqd3utAE1r4crNCqPQe3VtP3/mJCMDPTJfRv3s0iqwsjBrWf4GNEhSTtmYSgVAGe89ekFm3vP8VUiliplXUKgwBBV8cxsrczJTBmzUrQdP2/cf26b3N6CYD58FEBIGx/rk+atDxs+w8+kG2l2tIatCkejwyQvN2g+QP+sVqJUGJk8DFcGCwuIFf2ycuXDlx56E/ffi9fE/zk8tP25Wnrdx8cMnzJ67dG2l+5EArhvdh02EfVfjNjpu5MDUsPswwRlCmt7j7ur46PI/ULTsl//VxYlaXcCFmTpn2dhpv7x+E02aKgAtCS4Yy9dvh3ObNFUTuA5vP3B86Pcz4VQkTeUh9jl4uFXvc1C6v1YthL138eh2a0sz0vqeKnb75wNn8h8btl+8dofMl9HC22PJnGnWluVUoH52adWwNJjtWnqTmTJAmKJjFUebA+mZORBCkZn3gAXsZEaOuPgkmaATtG3hDQeFzJQ9wT3rt1W9Rkz+2IEGYE8uW/t3h/7fPntVblYfg8vjrdu6b8Ks36p4/r22Gpg8DVQE5/+x4a89R8nMR4CDvf/Y2Ur9OIhlxv9vAXjLZP7jwHGCGOdj8/kkDDrdQE8XJkiQpvdQKBQ9HW0o0uSwSdOXA1wbCBaOnr5I5qtk5cadKzbsqEFYAfvw9MVrEI4RHsHHgFK4zu89+i+Z/wiw32DvwT6sOI6qit3+mYDbsnDlpp0HT5L5MkAB/1z0M3j0ZL6M+tmlyuDj6S7fCweAo0Sm5AiPegsxO5l5D1jATmbkePD0lfyTOa5O9i2ae8jGXcG2T//l9x0HThDZqgkJjxwwdrrCbZxKAc9m7d/7yExl1G4Dk9HQ7wlWzbXbDyu+oKXSWKZq5i1bp8xBaqTAib1i4w4F16Zq/tyy5+CJc9W9MASEhP+2anPVDbQhAyK1bf8xhXMb/NDffvqhbYvm8kMv622XKkPFiBiCcYhnyUwZlcbCBGBXiIjhCMruHRHIx8LEtoNgEVllAM/up0WrK72lWC3qqIE1dBHU19Xp2NZP1smgwJOXQbBfyEwZ0I7hCqDQOmEmc6d//+DikeTQezBdPbl7QK8uZFkZsFu37DqclVPJPe/GDpx156/cUjixIa4ZN2LgjdN7E4PvQFD56NI/kJUPdoDt+49Hx8aTGSWAcwPilEpvPhAHEaI2hUU0KAgv48/Nu8l8GbDCC2dP6dq+tbwC1tsuVRKFznTgyYvAt+UXlJGV87H4sWJE/C4h+Vn5wFk+Fr50497R0/8RaXmgAhziLv6tKt6+ACA427z7MDQSMv8p4JSfOn7EioWz5s+c1Ktrew0ms+4aWMMVQdiVuzYsi3p25fqpvQ/+OxIfeAt2ClkmB4igfPAfFfPu+NnLZKYMiBSO7Fjz+/wZcLU0MtCDqXO7lke2rwYLWaOMa3ceXb31kMx8RaRlZB0+eYHMlAE79q9VC7eu/q1DGz8TIwMIKv2aN925fikY5dsQRDHHz11R3nN5FhBy9lK597sAvl5Nzx3aGhdwEw7i7bMH4l7dgGNa6UnyxYEAsKKXMWvKtyMH9VEY3lRvu1R5Wnp7yoYNASB5T16WU7E30bHPAyuPjSpGxC+DX7+N+/AGEPlYODU9c/8/ZxT2krOD7e4Ny9++uAaH+MqJXRGPL0OiW4c2ZPF7Dp04f/vhMzLzccBBeXXz9L0Lh7asXAi+y7Jf/nf+0Naxw/vXXQNroCIITQeuwGOG9tfW0iQsZiZGq377qaIOJqdllL5/rSY0r+t3H8E1h8gSTJ8wqlPbFgr3lZgMxg/jR44Z1o/Ml3HrwdNa97S/OHBJh+0iM2WMGdZ/SL/uCn01sH+GD+g1/ftRZL6MB09epqZnkZkqgXjq/pOXCnsPLuBHt6/p3bW97C0PcDTHjxy0b/OKhqaD0GYWrNio4GVMGD1k+oRvKr6ion52abWAWLWFtweZKQOcA9nhqPToyCMfEcPZ9DIojEgTyMfCL4PDFLYdlrtj3dJvRwzQK3u4G4BrBjhlB7auGj6gJ2GRcfXWA9nZWinQZtYvm+vRxFnhhK3TBtZARbBv945wQVC4AnPYrKnjRspf8YD8giKBUEikCwqLFfq/wEnu3qldpU8UwP4a1KcbmSkjNDyqiu7mxghfIHj0PJDMlAF7b0ifbpX2VsPeHti7q/zrCcBHeJeYRGaqpOJLvWA+syZ/W+nDgv6tfGZO/pbMNADi4pMq3kQGBYRYrOJzPvW2S6sFnBptWzQnM2WAUkNUS6TBMXxW3jHs1cWfTJUhHxEnJqcqdOb6eXkQjyHBtt+v0LUCO6q1r2fFZ9Uh5AKnRaHHBuYM8yczFQDXZ+KYoQpd8AR12sAaqAiCl6vz3geUR36gLEFefkFJCZdIZ2XnyA48wd1HL+y8uxLjLStOQ8aXi4i/vjfTFZeURpW/NwQuj0/XoQr7QTa16jlS4W19YRGVdB1WJDMrJzklncyU0bV9Kx/PD8+3yQMnTI9ObRVOjy/Ium37FW4iGxvqQ/xVUQGBetul1UUhIoZ4NjgskkgrxMKw56eOHynvOYI0x7wj499XwWFwIhBpAOYJoT3hRlTc9iqcDMDJ3qZvj45kpgyYc1JquXYiT8UxoTLqtIE1UBHUYDIq3bM0Go3N0iAzFcjKyfvMG89VXKYaIzk5eekZnxV8JaWkKTPeKjevIC6hnIPT3KNJFU8xm5kYQchDZhoe4DrtPHgSggwyL0e97dLqUjEifvIyCGLPioEkiBrUbNG8XGfjnUfSD7nw+PwXgeX6T5p7uMke3K647R5uzlU8sQOnsMIYRiA+sZybIo+DrbXeRx6xr9MG1kBFsGaIxKIqbnwoQx2N5PpSiMTiz9wisRhOjU/fyK+45z92GSOo+mLWEDh25tKB45WMHq23XVpdQBEUBlEQsWfFWBiiRXBy27f2IfNlPHkeCD4EaBx4gqSpDHC3ZDFZxW1ns1i0jx9loOJRrmLvUaQohtUEddrAvioRpFKoNesj/1qp9B3XdUHFPV9UXEKmKkMoFJaUkjcxGiybdx1WUASg3nZpDZA9qUkAseebqJiKsbB3syYQMHo1dZP3HG89eApxfXB4FPiPpKl8LAxU3PaS0lLhR55TJqh4lGu29+q0gX1VIqinq21nXe5G6YxJY5JC7hKPWCkzjRnWn/xlPQKHE66xZKY8VR/pT6Krq60QrQzp1z3mxTWFra5i+mXGxCqutzIq7vmQ8KgqvPLU9MzPHzpbu8A51qGNH5kpA+LWZWv/Vhg9Wqe79GOaAiEtV4kvi8oeuJZx99GLG3cfKcTCVhbSnlMTY0NP93JvZoSaCj6jfCwM6Ovrwq/ITBlwlLNzPvqIGzi8Ct1NsJNtrBRfuq4MddrAvioRNDEydLQv92b2sIi3cNEjHrFSZqo4HqIeAHcjLr6SHsPiklKF5zerC7Q5N2cHMlNG5Ns4uEIqbHUVk5LP/BkZ6luYl3vH/dHTFxWeOpAB58a1O4/k7743BGZN+Xbf5j8URtHDem7d+49s+AhQp7v0ZVBYRmWvBaliqLM8sG6yV0sQHDp5XmFII8TCRJwITV3hht2fW/as2bqXzJQhHwsDEHE725d7Zfq9xy8u3aj8PTRAdGy8wocPa/wthDptYF+VCGprcRS6hMDJv/mRJ4h5fP4///639u99smn7/uO5+ZW8fqN2YWloWJqbkpkywOP4a88RhfcOwYG8eO1OxdGh1ULhFaTA6zfR//53o9J7UtIlXr8rv0M27jioZE+RtiZH4dFa4Pf12yr9+YOnrzbvOkRmGgbEkEBwkWZP/VZhiNlfu4/ID/GtxV2qp6uj8E4aCEV3Hz6lcNcMskdOX1QYnfcxFCJi8JVAQMlMWXjr4eYsG85S8aFjeRRiYQC2vX15Zxn4a8/Riu9lAHLy8mFjFZSopU8zwg+tLnXawL4qEYSj261DG/lhWcCqzbsfPQ9UaKNisfjfi9f/N3/FwhWbZBMcsFp/IL8icAU2r3AxPHLq4i/L18tGKZZyeQdPnJu1cFUVDr+StPb1Uug0XL9t/7nLtxQ6KGH/QOg0+7dV8jvk7uMXdOV2CJwq7Vv7gidC5suAGfYaOeXyzfuysxp8W7jwfD9zYRWv9ql/epW9I4sYEAO7S2GIGRyCtVv3JqdlkPna26XgWCm8nAoAd2zl5l2yKyIkVv+1R+FhviqoGBHLo/A6rIoPHcujEAsT+Hq6d/FvRWbKiIiOHTj2xwPHz8LBJSxwuMFv/X7GbwqvMIDm0bOLf82CrTptYF+VCALN3J1HDepNZsqAg9R/zLTJPy15Efg6OzcPJkj8tGg1KKC8xMD+7d2tQxWd7rUFKHXFaxoALcameRf/vmO6D5tg590VVriKFwopDzT6EQPL7RDY6hGTfhox6WdwcDKzc2GHhEW8XbFx56jJPys0nZ6d2im4KlXQ0rvZoD5dycx7iBdJmTRp13nQeJisvTqP/9+CBqWAQN9uHWQDdOHojBnWT+HbVXCy/b3nqOxMq61dCmGpQmRN8Mf67XY+3Yg9Bolla/9W/lpYMSKWR+F1WKBHCg8dy6MQCxOYmRh9981gBTGChgrNVc+xJbTeXiMmu7bp3ab3N5dv3iOL3zNyUG8IxslM9am7Bva1iSCTwZj23ag2fuVGz0MbAseqbZ9vzNzbwwSJbfuPKTSszzxC1aLi5VTGs4AQOOVqRf4IKj2rgfNXbvUcPsnCowPskOadBy9ft01hoeAf9evZSZleEQK4fvwwfmSljyvBrn74LED20s0Gjp6O9oKZk+UHHgPrtu2XvWeoFncpBC4KCyL4nD0GQa5CMEQAC5J/HRaBwhBrGRBTf+zjLX26dRg9tC+ZKQ+0XgjbK9Ug8J0njB7yOZ/EqrsG9rWJIAAX6t/nz3Au/2HGqoHW+cv/JtTbR8tMjQ2H9u9BZuoeOKuXzftR4cJQNdBkl8yZVt172HDa/DF/poKbUClQx9hQn8w0PJq6Oc2cPJbMvOePDdtlzyPV1i6FVjqwV2cyU0s42FpX6gwqxMIEYFEI7QmaezRR6GOUAWK0cPbUiteAKoDNXPTztEoDoGpRRw3sKxRBAHy6w9tWK9lG4Wq8/JcfK31isY6AqzE4npW+FEceqLB26Vwy83lAKzz09yqFrs+P0ayJy/JfZ9SgycJ2De3XA65AVTdTuJivWTKnZ/nHVxsUsCHD+vdQeL/G84DQtX/vkz3/Xyu7lEajTp8wul+PTmS+MmBnLp3345xp35H5T6GjrSn/wVIZCrEwASiawkPHBK18PavwCUyMDP5eveiTDZgATsOd65d179hGwQmtAXXUwL5OEQSgwV06tgNEpNInQAmgaNVvPx3a9qfCgKl6ABrfigWzfp0xsdLDCSfY7g3LYd1q0V0ClT+yffWhv/+EmZOmCsDK/PTD+LMHt3Ru17JmTRbOaohZTu/b7OvVlDSVp3fXDge3/gnXgErfONBw0NbSnPfjBIXO092HT527/KG/vlZ2KSEo40cOIvPlgd0Il/Ofp43nVOf95OAEKETElcbCBLJvWsmALFSu+k4InDub/ph/5cSujx1ogDi//j2wWeGVtJ9DXTSwr1YEARAaCGqinl05d2jrtyMGyD7aDU12+ICe+7eseHnz1E8/jDPQq5PPlX0SOD2W/fK/R5eOLpg1mXjgCa5gECbDSXX77IFxIwfC+hM1awtoFtA4Xtw4deP03h8njJY9ZQXL7du941+rFj65cmzlwlk1G8QgA5p7p3Ytbp3ZDxch2O2EQMDOhyXCco/tWgenhMKLkhomLo520DzIzHvWbzsQIfeutlrZpabGhjvWLbl/8TDMgWilsNOIT+lfPbGrd9f21b1gVIyIwSdQGGcno2KHchWxsDxwELv4t7p/4fDjy/9AG5a90xQ2AVb+3wNbQu6fB/mu9fOr1huYeqXjm5AGwuZdh+cuXUtmyl4fdHT7mnrrwEEaCHyBYOGKTdAYyHxZfP3PzrVVeKCI8qAI1h8CgfDclZvvElPIfBmDendxtCs3Cl9GKZc3Z8ka+S+uQlBzfNf6Ji6VjKtAGhHFJaXHz16W7zsGXw+iE3AJyXx5snJyv/vfgmt3HpF5NTVwwfZtWWFWWS8wUl1QBOuV1X/tWbRqC5kpY/3yX/43cTSZKU94ZMzIyT/LB1/D+vfcsmrBl4rfkdqCy+PNW7ZO4SslED/2617u7Xsybj98Nuz7WfLjP6DNrPxtdnXDZKRSvuZ7gg0QhTfCAifOXVZ4ESwBuIH7j52RV0DA3dVRR6uexvEgdYcGk+nhpvi2u8MnL1T61CY4jLsOnVQYAQcNqR6eblIRUATrFXcXR4Vh0s8DQr+fuVDhXbAQLq39e5/8PSAAYuHuHdvU7E1ESEOjbQtvhVHK5y7f/N+vf6SVf2tpZnbuwhWbFF5D0K6lN/y8tvpbEerSpUvJJFL3aHLYufmF1+Vu7gAJyangBbwIfC0QCLJy8i5eu/vL8vUK38wDxgzrN3xgLzqNRuaRxoy2tmZSStrT8q+uCot8e/D4ubDIGJC3pNT0f/69NHfp2pv3FL+IPfuHcZ3atWwUPeyNArwnWN/AtX3avOXnr9wi88rRwttjz8bfK33CCWmkvI2LH/+/BQpv3Psk/Xp02rZmsYmRAZlHPhu8mNQ3RgZ6v//6v0qfVfoYzmVPHbk42pF55KvA0c5m5cLZ1tX5OGQbv+a//TQVFbB2wXD4C2BooNe+tW9cQooyn4Xy9Wq6btm8Lu1b4T2grw8bK/OW3p6hb6JS5F7V9TF6d+2weslPXk0/9wlcRAEMh78YxSWle46c/mvPkY+9+UdfV2fC6CFTx4/4zEc4kAZOZnbuX7sP7zp06mNvDwJvcfr333w7YgCOjqoLUAS/MKVc3vOAkJv3nrwMeh0dFw+C2NK7mYuTXfeObcFbhMAHHUAVoaCw6OGzgKu3H0REx4aERQmEQk93l6ZuTj07+7f289LT0SbrIbUNiiCCICoNdowgCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSfO5jcxKxSCIRkxkEQZDGRs1FUCQoFfBKQAbJPIIgSCOkhiIo5BULBaVkBkEQpNFSk3uCIgEXFRBBkK+DGoogmUIQBGnkVFsEIXwWi4VkBkEQpJFTA08Qe0IQBPl6qLYIqsN/CIIgXws1uSeIIAjy1YAiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMi2AiIyC49GJIFf8k8giC1Rx2KoFgiuRid638wXHvtS9afL+y3Bq14mFLIF5HFX4IbsQWwJn+/zCDzdQksBZYFSyTz7ykWiAedioIiYrLcHBiSUUKWVUZWiXDMudipl+PgL6RJaxnwQ/j5jGvxZL7xkFEs8NodCvsB9gZpqjPq86AjjZG6EkGBSDL/TtKoszHJhfxRTQx+9DVx0NNY/SSl69GI5AI+WUkloamrd7fXgR0CUxNDFmn9OAYs2sK25lAZ/kKatCIIUkvUlQhejM77+2X6lOZG4VM9d/axW9vV+sZo1/9GuIAC/v0q/fM++N64YdLUf/AxgR0CU1srLdL6cdTV1Qa56kFl+AtpBEFql+p/d1gi4RZnk+mPwBVKxl+IiS/gXRzuYsj+4LzAombfiH+YWHR1FGkHh/FoWPa6JykxuTw6Vb2dldYSf4sW5pryZ7t8HTad4m+ttbaLtZO+BllcFu/0PxkJMqHNpC69l5RaJHDQY67qbNXXkVQNokJZXUV6OugcGejIoZMXg8wS4erHyUdCs/N5IjNN+gQv4xktTLQYVKK0gC/6/kIsrP+FEU6wkoTxQULhwFNRMJ9dfexhPhB2zblZeXw6qbnxlh42ZKYMiGTPRORcHuXSzJhNmuRQmFXFn0M43PtY5GBX/W+aGsCODUorgXX+pY35955GsDPJSsoBh+ZKbN7y+8mvM6V3HpsasRa2M+/jqEuROxKffyAgCu7+T0RkdiVfKwQnV34/KCwLdu/S9payZSlzIJQ56MQOhDU8EZ7zMqVoXVdrGx3m2PMxUGd/P/tOttpEfSA6h7v0ftLVmPwSgbhiw4Cgfsy5t3F5vEP9HaDazXcFdIr6UFf9PzpZGcm1f6Dq+QBw7uwPzvjjYQq0wDaWmpu722x/lXE/oeD6N67GHDpRR/5gUdTVKp41svXZ29d++YPkW+8KmNTK1wcBqEuXLiWTSvPJjw7nlAo3Pk/r6aDb10mXNJUBBykml38jLh+cGiM2XSiW/HYvafHdJC0mbXgTAzcD1oPEwoMhWR4mbFlzh5NhwZ3EJfeSLLQYQ9wMLLUYN+MKjr7O9rfRAgtRJzaXdywsWySWXIvJ726vCydeQFoJiIu7McvFQBpvcoUiBpUCrcSEw4jK4ba10hzgrAdZmHzNOT6mmjRoSmpqaUUCOIuggba31oKVZ1DVD7/Oep1R2tNRl0mVqiT8hRnCnOE07uMkNeZxhf+7Fg8NelsvO1g3qFPMF+lp0GDOIEOJBfx+TnoQ/BLLammh2bS82F2JyX+TVTraw9DkffuWRzYrOz2NmFyupwmnl2O5/ZleLIBdUSQQXXmb52nM8TRhv8nmXojOM2DTfc04cvL1aXYFZky6FMcTSeBU8TPXhLNrf3CWHuvDfGrlQIjKzk9QuqZG7Ng8vrEmfZS7QWsL6c6BhfpbaYF6QjVZwyCW5aSncT2uAObc0UbbVFO6o5Q5EMocdGIHwuKM2bSMEuGdhMKUQr6jvkZEVinsgUEusPulx/1hYmGvY5EwE7gqdLbVLhWKQTTD5BqGQCyBlUnI5z9NKWLSKF1sdQp5ohtxBWGZpcTqQR1l5gPqBifO/NuJsB9GuhtwGNTLb/Ng5hklgrEehpAl5kMcLDqVMsxN38uE8yK1eHdgRrmzRrY+ycWwE3o56IjV1K7G5t+PLxjgogcXFaIaQlAnniBxgZ3f1mK6rzFkHycV/Xj1HZztXqbs/k56ECYT13yiWisLzX397bXLDnB8Pr/3sQg9Fu3iCGdogLJZdbDRIi7vYAF/p+8JqWVfXwcILcFCXPPhenhisKN+2V2z5ylF/U9Et7PSPDTAQf6QEzXXdbUhVkwB8Lx+u5sAPwHlgizsmO0BGdAiDw+w7+8stcgbt/a0GdPUEEL7X28nru9qPcVbcYaEH3dhuEs3+w8OhQJVe4IyZB5fpZ5gEyPWvr72ltrSMz+pgD/wVDQkZL62MoAWwMkJqn1miJNF2XxAU4afkboSV0a5OOpJT63aPRCES2iny5R3w2UQyxrqpg+eJuHSBqeXDDoV1cNe56+etsQVS/kDUcVBJxb0S2vz/7UwuRKTN+587KVRzn5mmn8+TgH/C7a9iSELJHLqlXe34/KhTbobSQ8TLHrt01TwsM4MdYIrHFgIzwtUb39fe1htuGzANWP61bh/wnIuDncmPEpl5pOYz+tzIgpk69wwJ+KAEjsZDqXMEyQOlpU24/BAB+KsSS7gD/43Wl+DdmKII2GRrc+aLtY/eBsT6wPXsK0v0/8Z6AguCNRBZCi2v1onq0T48834tpaa2T/7wJkJgkgWwOEsEmaXCkc3NSSOHGCtzVjQ1rwLXCTfdxoSdYa6GshOFScDDT9zDlxj83nlukpBXokTD2hixIY6b3O5RdXpjI7MLrXSZsI5QGSh6XS00dLVoN6L/9DDC8YxHgbd7LT/fJRyPTZ/y4v03g66YzwMyeIvgasBizhhAEhADJVWxE8pqkbvE5xXoErg+BAKCOhq0Oa0MgMLnDyEpT4PBLGsHg46sqAefBxvU3B5SvK45Hxq8UBQylSVpk4B35/wyLQYNPBnQbakdor6nj52sT96EcoFwKKbm3CgQnQOj7AQ2Osy/a21oBSANR/kqg91wrPI2F+Z+eTyRBBFQbQuO6Buhiy4zBBpAuJgdbXVkZ01cNTaWWqGZ5XCJZCwEMDZ1NdRR7Y+w931Ie5+lVZcVoh8oM5FEM7GRPDvnHTBEdBh0iDMJAvU1CAugL+a748lAAcMYsNlHSzN30dYFet8DKIpE0CqLI6pBnDxTCzgZRQLf3+QPPdmAjH9/SKdJ5QojOKAxvdbO4t8nmjk2WihSLy4vUVFX6ZxQYgOnPlkvgzwTcCPgJOQyNbbgQCIZe0PypIdCAjDwS0VisVicJ/eU28HApYZm8db9zRVtj4QfpJlcsB2y226VFXJ1Hs+OZ/sEmGe9GY02fgBcLENWOVulRAH63x0jmwmMAVnlMhUWwZoOhHOE5hxGOAmNzX69IAEVaOezt6KDaJhAk7NvuBMiBqICdIKbg5BEyMNiHG4Qkl7G20XuZ4BpBa5GJ0rOxAwgadDFshRDwcClAvi7ma7QhfdTZKtDKwbWaw0ysxHKFYDLSMzVfIosUg2E5ggSxZ8HPAuf+9oOdLdgMwj72kc2lRvuBhoxP/Pq/RXP/lJ4U4c8F90/oWovGbGrItRuTfe5ZNWpFa5MNxF4UAETfKQ9ZAS1MOBCM0sWfkwuYutNkSysjWBdSOLlUaZ+eiyKPI9xVWwrquNbCbElDSzedV3lpGPUU8iKJRU8mCAc9mlW/5uEVwtj4ZmQeyTUkje3ahYp46ASMpKmwmX4U9eiePz+YvuJra04Bwd5NjEkLXsfnJjH/5tokkzYNEK+eV83uux+fNuJbx573/V24EAiGVV2mbkqZ8DQYSfg1z1zco6pmuMMvNhUqX3JQPTi2WBLQT7skNAQBwssXIOI6IMdS6CNIo6laJ+OTqvRCCG0PJqTB5Z8P5wHn2dVfD+1Eoo4K98lHLrXQHr/c0dos7piOzi93fmorO5L1KK3Y1YOkxlez9l0ChqsDIfa0AuBqzYPJ581w1EK3rrXq5/mkrmy0aKrHiYlF0q+qOjpaOexrw2ZlHZpZuep8k6EGTQy67oVZ/JTnoaxQJRbmklEbfywArL7ohDArKmmgxzuftKBFdi8kw3Btj+FfQgoZA0vceEQwcP62xkrkxE8rjCdU9TwSLrmqjdA0FRV6dRKBD9VXokiGWdjciR7VXYLt+9Yb2ORcqaivIHouqD/kmInwelwYEi5wAt+WBIJpFWHmXmY6vL9DBmw4afDM+GalBhZ0DGk+RyoS5xsC6+zYVjRFhgnww4GQWBdmJ+uY4aREmq3Xyri72uRntrrT1BmTCx6ZQJXkaB7/un4Oo92sNwy/M0v71hPex1eELxf2/hyIrXdrMmxscAbgasUe4GW1+mR2WH+1trZ5UILr3N02FS57U2J4ZlVAtHPaa9LnP1k5SonFLinrGPGUd2l2SIq96R15njL8YcDtWG8+ptLhfk2M2QNbLJh9soF6Pz/gnL+amlGdGJ3NNed5ib/r7gzE522r3l+nwAX1MOqMPPNxJuxBYQStLbUVd+/C3gZcoGORh3Iba/sx7zvdyM9zR0N2JDy976Ip3Qx8xSIZw6jxIL595MkK9DpEFth5yO8jLhQBp2IPgOa7pYg4gQpTKuvM2HIphOvcnxty7X4Qjn1RRv459vJrTYH9bXUZdJo1yLzU8u5MN8HHTJG221eyB0Nah+ZuzDr7Mn/RdLDOvTY9F+9DMhejxlDSMwrQSWVcwXEQ1jeUdyUAig/IGo+qB/kuam7DaWmtB6QzJKfEw5BTwRXE5gDmSx0igzH9i6X9uYjT4XM+G/OJjA0s9JD5plcPqHp8tlB6vl/nA4a8AiO1iW2kyiDlIt6sQTNOXQDdm01LJRGho09d197I8NcpzZwvTySJexHkbfeRrpl2kcOIl/dLDc3tsO3L7dgRnHwrM9TdhQp5f9h0YMnsjKTlZQp1Qo3v4qHU48OIGvfeMKNcka1cFKh7mrj52VDgPaIpzPMMn7faaa9AvDXSY3N3qSJL3rDH8hfW6Ys2zgCBF/eRizpvlIx14BsHpzWpsbsOkVY7HmppzdfW3hqg+rTSxLNlpCRjsrrQP97TUZFNh8og5MKYVS4eMKxOAOEJYTYdlcoSQ8q1ShDgGo7YpOVo+SCg+FZoGSru9qPcnLiFg9eXo56oBmwSkEYkGa5Jjc3PjkEEcrbcbRsGyQEj0N6rFBDlO9P8yndg8EHPrlHa2+cdeH+RBbBBsLmywrJRoGsayKDaNaB6Lqg/5JdDVoRwc6jnY3ACWC38J+/rOz1VRvE7JYaZScTwcb7YCJTTd1t4Hz5fRQp0MDHCo62sTBgmMER6rSg4VUizoZLM0TSr7/LwZCS4XH5hAEqS4zrsUrPDaH1C514glCfDSumVFUNnfJvaQv++4sBGnUEMNXaRSK/EPcSO1SJ54gQIyKmncrQZNO6eGgY8ym2+sxv/c0rsH9IwRRHSCK2hecEZtLdnFEZHPvxBdM9zVZ0dGSJj8UG6k96koEAZjx85Si9U/Tbr2TvjND9uoOshhBkAoQj/1ejSHHPOowqVO8jX9pYy7/5DVSu9ShCCIIgjR88PKCIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKI1CHFpdx/L925/eglmVdT4/L4B09dDg6LFos/8R0lBKkfUASROkEikdy4/6L9wCnfzf49K/vD17UkErXA0Ej/QVP+t3B9emYOaUWQL0f9vUorPKt02Ono+AL+xm7W33saUav5hsjMEuHBkMwrb/NepJLf6xrqpr+tl62S32n9ihHz+fykRBGXyzAwoBubqNXlK4hFJcW8pEQ1sYRpbk7Vln7lp1KgUZ3+7/asxRv7dm83/8dxNpam6nJrJRSK7j0NWLxml7mp0YYlM6wsTMkCBPkSNA5PMJcr/PlG/KK7SY+Tiip+U1HFEeXmvFs8/3XPjtnnz0iEn/X1zk/CjYqK/HZk+LD+hYEBUqfuIwS9jlq6Yc/Igd02LJ1la2Umr4AAjUbt0s5v97oF2bn5m/acgJCZLECQL0HjEMHoHO79sq/l9nbQ/aOj5cpOlqs6WY1wN5B9phJpOPD4guPnb1iYGM2cOJLDIr/YWRE3J9tvh/U+fu7Gi6Bw0oQgXwLq0qVLyaTSCAXlPolfBRDD3ksouPUuXyBSA7k6E5GbzxP1dNBpbsqRfTgmp1R4813+tZh8iJdZdIo+i6bgOAARWaXHw3JoFPWlHSzGNTNqbanVylLTWV9DqZhaIhFkpHMT4kUF+SVhr4tePqdqaUFIlnfnJi8lmW5oSGEwwYHiJSbwk5OEhflUjpY6jQyxxTw+Nz6Wn5amxudTNDUrrtjHgBlyY9/m371d/DpUwi2lampSmIpyAHVK30ZBnaKQQFF+PlVPj8L88N1YWFtuXJwgK0udQuXGvM27d0eQnkZls6kcDhHwEusmSE3lJcbn3b4lSE9lOTnT9Q2F2dmCzAxRUSGFo6lOfb8hXG5xSGD+/bslb8LVxWJYlqwIanJjYwXp6WI+jwo/oUivi7IdIsjLobBYEh6PqFMaHZl39yZskaaHJ4VKE2Rl8rMyFXZOXELKlr0ne3dp26tz6yr2GBQZ6Go/fhkqEav5t/SklC0XQeqfuronKBJLrsTmz7wWn1JIfgTWmEPP44pEEonsnqBQLDkbkfvzzXjQSqIOMLm58eL2FgYsGsxhX3Dm7BsJkCDLyqPkPUGJQJC+f3f8H0vIvJoa3cSUqqHBjX8HacOhI2wWLqNqa6cfORi/ZD4UOW3bo+XbQio0Eknhy+fR0yYKc7LtVq4zHDJcnabU50NBc5M2rMn45xCZV1PTsLG1mr9Et2t3CoP8hHHFOiwHJ5vlK7Xb+EvlSSLJu3/37Y+TRfl5dCNjEDWiDk1P33rBEoMBQygaTFCo6B8nF716QRQpoNO+k8P6LbA5MKviN+EJSxcUPH1Mlqmp6fXobb1wqYatHaRBNON/X5R15hTL0dlx83a2RzP4SVHQq5gZP8AuMhkz3urX30oi3kRN/U6YlUX8XAGzKdMtf/6VokGq/KMXIb1Gzzq2448+ndsQlo9RyuXPX/l3clrm7nXzdbXLfQ8egJZ55vLdn5Zu9mziuGn5bHsbC7IAQWqVurr8hmWV/nIzgVBAcy2GEZuWUSzgiz6MigDtfZ5SPPdWAiggm05pY6lpryv1g3YFZmx4mlby/jvctQj4WbodO4OOgEslKinRadce5Cb3xrWi0GBQN23fFiAKUFT4/ImYL4D6YoGg6NVzsLDsHDjNvZVUQFFxUcqOvwh1U6fTmZZWkAA1ifttbsGTR9LNLl8H1gpkDhKlMdEJfywpjYqEtDyggKChOv4doaYwNydx3SpQKGI+yiBV2zUrQAFhZWAm2m3aSbf62uXEtSsJUaPp65t+N1HDzgHc0oyT/wgLC8AJzTh6GNaZ7d7UeOx3VXSAVEpyqlSywcsjslWgwaQbG+mLRMJKh8tweYIHz4Jy8wvuPgl4GfyGtCJIbVMnIggu3oOEonf5fAhvt/e2i5jaLOIHz/ltzeW/nVoqFJ8Kz0kvFrgYaNwa7XZztNuT792neEvl4FxkTkwuD1zF/s5698a63fvWbW1Xa5gVg0pZ3sHibpnl/ji3Je0t2LRqrL9O5252q9YbjRwDabNJU+3+3KDduq24qBBkTiIWM+3tQSOgqODxI2GOVB1EuTmE96TVsjXTwhISysCLjc27eR0SppOn+QS+8Xr0qumF66AmoDj5d26IuNI7CbI65v+b7R0U0fxFqOs//zJMzSBWzb93S8wnfWcC0wmT3S/fcj1y0vXoaaaVNawtSDMINMPC0v3s5ZYJmd4vQsHvg5o2vy1rEZMCFpigPriBsF0Fz58WPLpPMzR02nXA5dBx1yOn7DdshbAXQuPCkECpmKqrs5t4mE6aCiqZfeZUwYN7ubdv5ly6AFGw2cQfIMSGOWu1aOUT8AZmC9vCMLeg6ui6HD7ZMj6DWBY4lTI3sFpAREylUNIzc7NzC0iTHCCRHVo1t7Iw6dmxdYvm7qQVQWqbOhFBcPjSivhiicRJj9nBWotOVQdfr7ejrgnngzMFIhiXL+0WbGup5WygAfII9Xo46GjSKeAbZhRLhcCEQ/cx47Qw13Qz0KCpq4PiuRqyIAuTn5mmo55y9wTfQ2Wx4DyHv5BWp1DVKBQ1ClUiEokF0mVRWGyd9h1BHYpCgkoiI0A+SuNii8NegxaAzwilZfP4FBIJLzMdAkwQIP0evala2nCis1zddNp3hkJefLy4qEi+jm7HLlQ2R51C0WzmCT4a1OHGxUnK1ocA5EanY1eappZUqpxdNL19wchPS5OIlOoFlgiF/OREMY/HaeKh2bQZ+IDgz8JMWE4uEGjzU5JhM6Ea7BaDXv0M+g0ENzDut3nxSxeCr2o0ZIRetx5K+r91AUjkoN4dw+4cO7lrha2VGWlFkNqmTkQQQjWQQEiA70Z/r1Oggyw5xw28Ra5QWud8VO6Q09F9T0T1Oxm19F5SkUAskkhKoFjZgK92ACXieHhyvJqDOhQ8eiAuLCgOegVuF9utKcvNnegu+CTSG6w8nlgoALmh0BlwHoMRvCTr+YvAY3LefxQi30rrqNFh70h1VszjqolEUksZ6nSaVLWJOkwmFdSwTNqkWWWQqIm50s94Fwe+ivv15+hpE2GKXzK/JFLaISspKVF7H4fKgmLwWCHoZru6GY8eV91AGEEaI3UigtUiu1R4N77gVlw+TCEZyvY71wU0AyNw+iBR+OIZ+IAghZDWbtVG2r3QyAEXL/fW9Zz/zsOUd/umuLTCflZX13B0JjYf0OnQhWnvQKTrGioNrgZfvh0iKsuXb3yDXfWuf+N671vpnT5igmw7Ky25+4f1BIXJABVgWloVhwalHz1YFPAKolGtVm2oNbrh1aDQatna9Z9/PS7d+jBduWMwYLAs2pXePXz2JPu/80Q269xpab9zHXvjIpGIy+Ub6mnr6miSJgSpd+pEBEG+GGVRsEAskT3fwRWIuXIPe1DV1YlIWZdJI278weRqyGKCV1Dv8icD4kHtNu0kAkHOxXPgPWl5Nee4NSGjUSWQDouDwJZGl4hEEjEZtIq53IRVvz+zNor6brQgM6PSOmoCgbi0BP6VDid8P4KvFlCXBtTwL8yW7eTM9mgGk4aLK4XDkZTfKH5SYtqOrRAIa3r5sN2bCtLT0vZs56emkMXVwdpS6jgnJKUR2Soo4fKS0zM5HDaV+sXuPCJInYgglaJmqgkyqB6dw32aVCgqu/13PS4/rUg69ISATac46kk9rGcpxfH50vtWApHkcEh224PhfY5Hvf5CcTFFU0unQ2dKWecJIHUDdfWJtFKoqzNNzGj60lE4eXduiUqKwZniJrwrfP4EChmWVhQ2W75O/sMHItA+iaQkKrIoQPqqFaa1tTqdHEuoLCCrZaO7+ZmZYuGHPQyAo8e0sqEwmSVvwmARUs9OIikODowYMyysX7e8+3eJjhFYz/QjBwuePtawsbVZ8rv1/MV0I2OImrPOnAIFJ2ZFIu3QpUq4pcKsTBBx0lgeCxPDls3dX4VE8MpGGlVBUkpGYGikh6ujtmYl/U4SieTs5bvunUYNn7zwXWIqaUWQ2qZORJBGUW9twbHWppcIxBMuxXU4/KbdwfBl95PlOztYNEpfJx09DVpYZkmHQ2+6/xPR7mDYnJvxoJh+5hwXgy8TgUq7R5p5cdw9IM0wNdNq2YbCoBNFSsK0t9ft3BUSyZvXv+7ZKfLbEWH9ukNoKe3nbd+R6P2Q1Ulatyqsd9eI0UPfjBjIfRenYWun07YDhV69JVK0tNmu0hEkqTu3vnSxAZcTprj5c0Bepf3O3r6aPn7ggUZ9Pzpy3MjI774BBeQlJbKcXTieXlJFg0D4wb2MY4dhDibffs9u6qnp19Jo5GjIph3cW/jyuVQ638MwNWU5OYt5vJjZ05/bmxHLSj9yQF4QzU2NOrTxPnP13tNXr0lTZQiFolMXb5Zwud38/aTecQW4PMG9p4GJyelX7z55HhhGWhGktqmre4IexuxF/hagcSBqr1KLQek06RT5ES3Q7P2ttVZ1ttJiUAv5ogcJhUSvSDsrrRWdrIzY1ROCWgR8NA0HJ0hwvLxZdg7SFa0OVI6m6aRpBv0HQRp0Le/eHXFpKc3Q0GbRch3/TkQvM1FHv99ASJfGROc/vA8BOGiu1W/L2E09qr1EFstw+Ei9rj3IfHmYFpZWv/7GaeYJypV39zbRK8J2dbNeuIxVtpm8hPjUPTtE+Xmgy/p9+lOYDCqLbTRkhFQ6KwTFNCNj04k/wM/JfGVQqdRvh/a2szRbtmFPeFQcaS0PKOA/567tPHxu4jf9PdwcSWt5NJh0/5ZeejraHVt7+3pWtUQE+Rzq8FVaMOPEAt69hMKcEqG1DrO1pWZGiQBiXktthgnng8alFPJvvyvIKhGC/+hjxvExYzMgnC5PPk8Yk8ODFbXXY4KwklYlKXt2WJCVRdHUZJiZQxwnyMtjGBhQdfR4KYmSUi7d2JhuaCSTnpI34W+nT+LGxdj8/qfxyDGyrgMIDJPWrwZvi8hWxGreQpA2EBFIi/n80vCwksg3EqGAbmqm2aw53ciIqCYD6pSEh5ZEQB0hw9BIy7claCVZBiFqQT4vORkSTCsrcmSMSMRPSZY+ZayjwzC3ACeurCIJrB4vMV5SNiAGtkWhjqi4qPDlC35SAqSZ1jaavi1A6YgiYXY2Lz0N2gHd0PDDm7gkEtA+YW6uGoUC3h9Nr9w9AXLdiJE6FIrCDiQIeh3107LNMe+Sfxg3eNywPmYmBoRdJBI9D3qz++i50//dnjZu8KKfJlbxkgUEqQfq732CjQLpg8ZlDxFr2Dk4bdvDdm9KFlRTBBEgOTVjxeYD56/d37hs1vD+0vAfIJ4XfvAs6Ncfv+3foz2zmncbEKTWQREshyAzI+6Xn3JvXjMaMdpm0TL50cISsVhAOEeV7jEKBeJoCGmrG8x+9WRm5/EFAgtT0hEGTzA2IcXSzISlgVcLpEGAIiiHRJL/6MHbGVMg5LRfs8lg4BCFkBNBkK8PFEEEQVSauuodRhAEaRSgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCNY5EokkMiZ+x+GzeQWFpEmF4fL4B09dDg6LFr//5DGCfFlQBOuW3PyCOcu3+PX67vrdJ3jaAxKJWmBopP+gKf9buD49M4e0IsiXQ+VepZWRlfsi5I2Nuam7i12l3/epRWBZMxdtiIpNmDdtTP8eHfA1ogRCoeje04DFa3aZmxptWDLDyqLRf9seadSolghCLLbwz+27j573aup8YOMiexsLsqCaPA143X3kjD3rFsjeGl8RHl+wfOPec1fv7Vz9a7sWnqS1PCKu4O3is4XhKW6bvuE4GpPWMogibnJek79G0/U5pLWaFL/NeDPrH2E++f1SvdYOjssHUTXKvdFemTrVJe9ZXMSc4yYDmtvN6UmaKhAeFffjwnXNmzovnzcFPzOCfEFUKxzWYDLGDum1bO6k2RNHWtexA/I6IubkxVvTxw9r69eMNNU7dC0N475eZsN8jft5UTUrFxpl6tQFbk623w7rffzcjRdB4aQJQb4EKndPEHzA2ZNGDerdkVb2wfI6AvzrWw9fGuvrdmtf+Ud16weGibb11I42M7pZTWzP+Ig7qUydugB2S5e2Pk2c7e49DhR95DvuCFIPNHQRhMBT27nzifM37j0J7PnNTEj3HzcH0vJRfE5e/uAJ82Yt3hgcFv3N9CVQx6fHuO2HzpRy+WSN9/ORTVBZvpRg9d+H2/afFPQ6atVfB907jbLxGzjjt/XJqRlksdxMIBaG7MQ5Kz82Q0gnJqfZ21oYG5b7WKUCFDqVpsNWp1LUqR8VSkF2UeS8k886rXnebV3MqkuC3BKygEAiyX38NmTCvmcdVkOdN7OOFYUlSXsf6oLyywqbdrgwpPJl0bSYVDZDnfaJ1mVooO/uYv86MqawuPxGIUg9Ql26dCmZVBqhgLx/VA8kpWYcPn1FV1vrxv3n/i29mnu4PH4VevbqPc8mTrZWZkSdUi7vwvUHRSXcO49fOtpZ9ezUurSUt+PQGR6f366FJ63sY0mQNjc17NTWp5WPR2Z2nrWFSVf/FvTyzuCjFyFv3sYlpGRk5eT16tyaw2ZdvP4wLCquQ6vmmhwWVJDNxMXe5lVIxIgB3Yb37wJZmDxcHdycbKjvP8xUWFx89MxVM2PDHh1bKSxFHnWKev7zWEFOsekgHyqrXLeJRCjOuRPBS88vfJ1MYdB0/OxExbz853GlsZm67ZwodPJryGnnAmJXXKLQqAad3TjOJkVvUtPPBbIdTVhW5cRXXCrIvBJK09bQ7+QGlUlreT5RRyJJ+zcgdiW5LJadYWFoUsbFILadEcv2w+eSCQT5pVk3wvTau2g1MSdNlUGjUgLDopJT0/t192dp4G1B5MvQOMJhoVh0cMviX6aP/WPelDN7/oQw88L1+1xeOVcuPDrupymjV/76w5ypo/dvXjRp9IDLNx9FxyYSpQ42lhAFwzR17EArc8XvoMsIi4xr5e2+Z90CqLl3/cIV83+4dvfpoxfBRKlsJkP6doJsN38/IgvT0L6dGfSadCYwjKQfVv8YgpwS0yE+LquH2c7q5rH3O6NeHvkv3hW/SSVLs4vTzwTo+Nl6HJxgN6cnTO5/j9Ww0k87+VxYUvYV9toD1iT9fADbxaTprvGwIIf5fZrt+55lrZ989ImwQPGiSNNkUjlMMvNxICKmUijpmbnZuQWkCUHqncYhgl3a+mprkrerrC3M/LyaxCUkl5SWO/fa+nl6ujsRaQ5Lo0/XtjHxyfEpaYRFSdxd7MB5pFCkuwVO0Ta+HmCJjksiSusCi3FtPY9O/lj/L9NCV9vLmviWsTqNqt/JVSIWl8RlEaX83GJBbrGunx2NTSoOw1hLu5klVOCn17KsEMvSb+tE12MTFoaJtpaHJS8lj5ehOAicaarT/MQPZkN9yTyCNGAahwgqA1uDSaOSQSJgY2m6bO4k8BnJvHJQIECV68eANFjIzJdAujLy60MpF6WCJyjML82+HxW/5YZsKo7OkIjEElEt3xYklkVRwr9DkMbF1yOCChChK/iMZP7rpTAkMfXUS9kEWbKgkUClUSEoJjMIUu9g42v02Mzs1urBfPnJ979ZCkOvGyYikYjL5RvqaevqaJImBKl3UATrBJYGy9rCLDElTeHGZe1CN+DQdFjqovp4JJlYlri4NvtbSri85PRMDodNlbuPgSD1TOMQwftPgwqKiol0QnLqi6BwO2sLNks6bOWLAOGbFoct+rj6sDQYTnZWIRGx7xLJnty6gKHHoetxch5Giwq5hEVYwouYcyLom5289HzCQkBh0ZmmOvycYglXQJoqUHUdclmPomUDFfnpBYWhSUxzXaZxVR3cVZCUkhEYGunh6qitSXa2IEj90zjGCXp7uBw8eTk+Ke3q3afLNuwpKC6Z+8MYR1tLog4xTlBHW6vi0D8CvkBw9sq9a/eePg14/TQg7FlAeFFxSVZO3vOgMLDQqFQLU+mgmUcvQiJj4gf26mCgp0P8MCev4NzVey6ONgoP/4IIBoRG3n0SkJmd9yI4HGaSX1gsWx8CLU32ldtPsnPz27f2Zrwf1qc8xDhBYSHXqHcz2RBCbnJe1vXXuq0ciPF3VDZDTV0t43xQ1s1wbkJ23uO3CVtvl0RnWI5vp+tnK9+jQqFRSt5l59x5UxCUWBqXmf8sFqaiN6lsZxPZkMOq61BZdDWxWtbl0Ozbb2BZOfci4/+6JcgrsZvdneNoQsyhWgiFop2HzwSFR8+dOtrMRHGkIYLUG43DE2zj6zFr0sg7j15u2XPCwdpiz9oF7Vt5kWVKIBJJHj4PXrJ2N0x//nUQlA5k649N+whLXEIKWU9pTI0N/vhlio2V+cotB4iZBIdFk2XvcXW0+W5kvwMnL+049C+P/1H/6zMxHejtvGoIVVsj42IwTJBwWjHIZLC3vAJKUVe3GNfGYmxr0C9ZF0r2jXAJV0hWAKquo65uOuTDsrKuh7FsDNzWj9Rr7VD24+oBCvjPuWs7D5+b+E1/DzdH0oogX4KG/hYZUKtPvq+lwVLK5W/afWzVXwe7+vtOGz+8Y+vmdfrAcqNAJBI9D3qz++i50//dnjZu8KKfJuIrZJAvC3aM1CEsDQaE7fs3LkrNyN524GRBURFZoMLwBaIT52+A47x3/cJlc/ElWsiXBz3B+gCiv9iEZBtLMybjs97T9xUAnmBsQoqlmQm+YhZpIKAnWB9AFOxsb40KCFCpVCc7K1RApOGgcq/XRxAEkQc9QQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVJqv5y0ysB3Rudzb7/I1aNQe9jpmmvjeKgRBPs3XI4JZJcJJl2Kvxki/svajr8nyDpYsurJ+bnhW6bDT0bF5H74nOdRNf1svWy3GJ96GzxeJVz9OXfkoxdeMc2yQo6U2viYPQRoZGA5/eSRCUfyWG8+7rct/9Y40vaf4bUbE3BNQ9NR/VeDwbUkHHoo+/s1MBEFqwNcjggYs2pou1pu62+zobfdzKzPl3UDAmE2f18Z8ZSfLhe3M7XSZpLW+yH0ak34+0HSon463DWkqI/fx27AfDhUEJeq1dTId4ktlMZL2PohZdgF1EEFqkYYbDsN6JRfy04sFFHU1ez2mDpP8PK5ILInL5+VxRWw6xVGPSadQiGqyzQDxs9ZhGrIVP/ULM0wo4D9IKMgpFZppMtpaaZprKUavuVzhxItxl2PyqgiHIQSOyOa+Si1m0SgtLTQPh2at+oxwmJeW/2bmPwxjbZeVQ6haH746JCrkvplzUszlu/w5jGkm/Q5ymcN4C+TSZc0w3Zb2RDUEQT6TBu0JhmSW9DoW2e7gm8Mh2UIxqXLxBfzR52L8D4ZvepbKFUkEYvH+4Mx2B8PBQkydjkTciM0Xlxf3IoF4xaPkZrtCJ12K++V24rcXYjx2hW5/lc4VVu8aAGo741p8y31h0668++5irNfu13uDMsmy6iPmiRJ23BEW82x+7CKvgAA3vYCbnKPb2pFQQECdRtXr4AyJ0sQcwoIgyOfTcEVQXV3Ny5jdzIQFcnYjLh/cNzBCOjit5G0OV4Om3tVOV1O5mBcE9GR49tonaeDEGXPo7ay0IHYuEYgX3k06H5mjIJdVwBNKdrxKPxiSBWkGleJioCGSSDKKax6cZlwOyrkTaTGuHcfZhDS9h+No7PvfLOupHck8giB1Q4P2BI3Y9L6OehR19ZepxZHZXLCUCiV34wtAvxz1NLzN2FAEYrTI36L0Vz+Ybo1x02cpRsEA6NTR0CxQwL6Ous++c78x2vXReHcIh0sF4uPh2TmlIrLep0gtFlyNlfY+d7DRDp3cNHCix8Nvm4AUEqXVpSQqPeXQY91WDkZ9PKSS/0kkkrxnceo0dY6TomIiCFJjGrQI0qnqHWy0LLQZ4AbeSygAFUst4j9NLoSiznY6llrK9mDkcEWpRQIqRb27g45R2b1Cc016d3tdSCTk8wv5yopgAU8IignKC2JqrsUA4QIF7GZHhqvVQljCS9z7ABJWE/xpbOmGpJ5++dR/FchcWXkl5D6JST/7Ss/fWdPVnDQhCPLZNGgRBBz0NTpaa0LiekxBapEwNL30bS5Pi0EFcWRSlfCeyuALxTyRRCSWbHqW1v9kVN8TUQNPRRH38rhCcalQTFT7JEKRBCJr0D4mjfTcqBQ1beYnxhJWgkSSeSk072mM+eg2bCdj0lgl4DbGrb2iYaVvM60LpQZLRBDkIzR0EdSkU8BlY9EpEdmlT5MKb8TlQyzsbsRqZsRWJoJUIDaPd/tdwa24fPibkP9haHQ9I8gtyTgXoNvSzqhvM2UC4eK3GZEL/lWnUh0W9GUYa5FWBEFqg4YughB7tjTnNDVkQ9C6MzDjWtktuc622sacSu79VQ2Ew/Pbmt8Z63bv2w/TscGOtjr1PTCQgJdWkLTrbvyWG8SUcyeCLChPSWzm2yXnIOH851COo1JuI4IgytPQRRAw0aT3dJTed3uSVJRSyDdg0Trb6jAgEFUaGlWdRpE6XGaadD8zTgtzTZhsdCCerp4zScxHIlGT3UWE4LhIoGw0rUBJXGbqqZeyqTAkkSyQAxQwetFZSLisGYYKiCB1QSMQQdC7LrbaJhzyhQjNTTlO+tXz3QxZNEstukgsuRdfmM+TClgBX7TkXlK7g+FTL7/LKvkwxgW8RQ5Duk+SC/kVe421mTR9FrVsyE5eetnImLe53Jtlzmm1oOtzPI9ObvVgvvxkM7MbWfwemQI6/T6IbW9EGBEEqV0axwsU8rjCH6/G/xuRAyL1Z2erqd7GhGcHVHz3gTz2usxTQ52c9DR2BmT8eicRdNBci+FioBGTyyPuCc5pZbawnYUGjZybUCzZH5z5880EgajcbuntoLunnx2TSvnjYfLGZ2lgAVF21GeGpJcSncuf/wKF1NMv4zffcF03UrelHWRFXMHbJedzH0frtXbQsNQj6hAwLfSM+zWnfOrlDgiCKEMj8AQBNp3SzIQNCZCeNhaaMgVUEjpVfYyHwXRfE4q6OgTUd973ikzwMvqfn4lMAQGY81A3/R98TEBtSZMcsBqgv/2cpJIEnuCjxKJigfiTb5qpORJpoJ37JEY+aoYp/1msRFzDGBxBEAUahycIijPuQuy9+ILhTfS39LDVkRsjUiIQQ0zK/cgwFw0axVFPA8QL0hDGvskqfZhYVCIQcRhUfystcAlBFoma8kDNd/n87FIBsW+gig6TBk4lIb6lAvGL1OKQ9BIKRb2dlSYUZZYIWDR1Rz0WU05PEQRpFDQCEYQVvBKbN/58LE8k2drTZnRTg0qVC0EQpAY0gnC4VCi+GVtQyBc56DH9zDmogAiC1CKNQAQTCnh34wsg0cZS01L7y4zpQxDka6Vx3BNEEASpIxpH7zCCIEgdgSKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyKIIIhKgyJY50gkksiY+B2Hz+YVSD8bj9QKCcnpe49dSMvAd3kgnwuKYN2Sm18wZ/kWv17fXb/7RIzvxK89eHz+vmMXW/aZsOvIOR7/w6eyEKS6qNyrtDKycl+EvLExN3V3sVOv4/ezwrJmLtoQFZswb9qY/j06sDRq/hkmpCIFRcUHjv+3+u/DP34/bNakUbh7kZpBXbp0KZlUGqGglEw1Nrg8/vKNexes2v4qNKJja289XW2yoJo8DXjdpMNIBxsLdxd70lQBcE/WbDt872ng3yvn9u7Shk6r5HtMIq4gesG/7zbf0Glhz9DnkNaGQdy6qzEr/5OtWPHbjJBvd/NS8vTaOBIV6oG8Z3FBo3YIcoorXSiTwfDzamJlbrx2+xFrC5MmznV+VUO+SlQrHNZgMsYO6bVs7qTZE0daW5iS1rrhdUTMyYu3po8f1tavGWlCahsKhdKrS5uu7Vsc+fdqemYOaUWQ6qBy9wS9mjrPnjRqUO+OtMpcs9pCIpHcevjSWF+3W3s/dE/qFG1NTv8e7e88fhUeHUeaEKQ6NHQRhMBT27nzifM37j0J7PnNTEj3HzcH0vK3MnPy8gdPmDdr8cbgsOhvpi+BOj49xm0/dKaUyydrvJ+PbILK8qUEq/8+3Lb/pKDXUav+OujeaZSN38AZv61PTs0gi+Vm0n3kDMhOnLPyYzOEdGJymr2thbGhPmmqDAqdStNhq1Mp6tTKhFIiKQxJCp24/6n/qsBh27JuhOU9i4U0BIlkBUAiyX38NmTCvmcdVj/rtCZs2mH4CRjJUgIl6oh5opR/nr7sswnqvJ58sCQ6nSyoQOHrZGKVAgb9lXb2lUQo/fY8AHOI+u3My76bIHAmLAQpR59A5Zy7kWQeVkcoyrgUHDRyB9ifd1sXtfhsaWLlThxNi0llM9Rpn2ilznZWHq4Oga8/LAJBlKeh3xNMSs04fPqKrrbWjfvP/Vt6Nfdwefwq9OzVe55NnGytzIg6pVzehesPikq4dx6/dLSz6tmpdWkpb8ehMzw+v10LTxpV6vFB2tzUsFNbn1Y+HpnZedYWJl39Wyjcp3v0IuTN27iElIysnLxenVtz2KyL1x+GRcV1aNVck8OCCrKZuNjbvAqJGDGg2/D+XSALE5yEbk421LJlAYXFxUfPXDUzNuzRsVWldwMJ1Cnq+c9jBTnFpoN8qCzF+/pFb1Ii5p7iZxYadHTlOJtm34ugMmgFQQmG3ZtqWEo/AA9ClvZvQOzKSxQa1aCzG8vOsDA0KeNiENvOiGVrWDYPZesk7n2QtO8BXY8DdWhaGukXg8QlfEFeiVFPD+KeIKxk1tVQMVeQ9yia7WTCcTIpjcvKvR8NIq7pZqYG7i6Nok6hZF4J1TDT0WpmRcxYWMJLOfxYnUY1H9OKpqkBFolInLDzbuKOuwwjLYPOTTSs9POfxWZff63jbUs30CR+JUOQXwrSr9feRauJOWmqDNDzm/efW5gZw+EmTQiiNI0jHBaKRQe3LP5l+tg/5k05s+dPCDMvXL/P5ZVz5SAa+mnK6JW//jBn6uj9mxdNGj3g8s1H0bGJRKmDjSVEwTBNHTvQytyIMFYkLDKulbf7nnULoObe9QtXzP/h2t2nj14EE6WymQzp2wmy3fz9iCxMQ/t2ZtDpRLVqAVpApsoDYpFxIVjCFzj9PtBp2UDbWd3cNo0CWSSLyxDklKSfD2C7mDTdNd5uTk+H+X2a7fueZa2ffPSJsIC8UClTh5dekH07HKTN/e+x0joL+jrM78tLzSdK5QGldvlzGMyEnI+tQcbFQGE+OR+Om6lU1F7EgfYRFl5KPjiG2s2sGIbkZpbEZYFQguh77P0ONgrm02TjKLCnnXkFm0zUkUHTZFI5n/6+IIWiRqWqp6ZnVfTuEeSTNA4R7NLWV1uT7Dy1tjDz82oSl5BcUlrOIW3r5+np7kSkOSyNPl3bxsQnx6ekERYlcXexA2+CAmcVuGnq6m18PcASHZdElNYFFuPaeh6dTK/QNSwWiAQ5RSwHY1AQwkJjMw26uBFpAn5usSC3WL+tE12PTVgYJtpaHpa8lDxeBjkwW5k6wiKeqJhn0MGFYUxKFdvOULu5NZGWh2VjAD8n0sR8+NlFvKwiwsI01tb1tSuKTOclkOEt+K2iQp5+J1cI+QmLILsYRFOntT24h4SFaa3PcTYDfRcVcgmLDKapTvMTP5gN9SXzCFIHNA4RVAa2BpNGpZEZNTUbS9NlcyeBz0jmlQMiOvl+DEiDhczULxKuABw0hi5bnfFho+j65dxGQlAoVfpKNasDmkVhfliusqir63d0Ae8171ks5ERcQcHzWA3QOEcTohwoTZQOMs28EBy/5QYxJe26y0vNkwjFEnE1h6wiSG3w9YigAkToCj4jmW9sgCKALpCZxgPbxVTTzVwaERfz+OkFxdHpuq0d6fqkEyoj52FU6qmXsqkkLpMs+AyoVLiAkWkEUZ6vVgQbO+pMmiyAbUTQOEzd1g4Q25a8zSh8nSQsKNVrZQ8eIln8Htd1I1s9mC8/VXpPQEl4PCGPLzQ21Ndg4kMjSLVBEawTWBosawuzxJQ0hRuXygMBKZXNKInPFuaVkCY1teKIch0jdAMOTYclLiZ7ISqlZnUkIrGYJyQz1USvnTNNm5V7NwKCYpadEdu+XDcUy8oA/krE5MCaWiE7Nz8lLVOTLe3BR5Dq0jhE8P7ToIKiYiKdkJz6IijcztqCzfpijZ5KoWhx2KIKvZkyWBoMJzurkIjYd4mppKmaUDXoWp5WvJS85EOPRYVciI7zX71LPxdAFpfB0OPQ9Tg5j6IFuaRQQgRaGJrENNdlvu/iUKYO0QmbfS+S/76rpDQmM/9lJWOP4YfwcyJNzIdhoMk0LDe0hWmqq+lukX03Iv9ZrI6vHU23nD9LCG7OnQjZAEOYT8i4PW9m/SPrU64uAa8jMrJyfTxdyTyCVIfGMU7Q28Pl4MnL8UlpV+8+XbZhT0FxydwfxjjaWhJ1iHGCOtpaFYf+EfAFgrNX7l279/RpwOunAWHPAsKLikuycvKeB4WBhUalWphKvZVHL0IiY+IH9upgoKdD/DAnr+Dc1XsujjYKA9BABANCI+8+CcjMznsRHA4zyS8slq0PgZYm+8rtJ+CktG/tzaBXv5NBTU3DUr84Ki3nXmTK0afJBx4WvHxnOsQn/1W8bJwglUVXE6tlXQ7Nvv2Gm5ANNeP/uiXIK7Gb3V3WF6FMHYhhBTklOXcjcu5HSuvcjUi/GMQw0Ko4ThD0K/tGWNGb1NyH0TAfEE2LsW2l/cjyvUllAwYzLgWDzXJie6YpuTMJ6DosYX5J+rnA3AdRpfHZ2XciiPWx+bELx96YrFQdUtKz/tx60N3VfuzQXhrMT4+nQRAFGocITh8/pGv7FodPXz79323vpi5/LpjevpWXrBtXCREU7T9+ceOuY3cfBzx8HgzCBLO9/zQQsjC1b+lFvAdBeRHU5LCbutiHRsbtPXaBmImzvbVCHUN9HaFIvG7HUU2Ohk8zN2LMdrWgshgGnZtoNjFjGGoZdne3ndENPPes668/DJZWV9d0M+O4mBaGJ+c/jS2JzeQ4Gjsu7KfjY/NBlZSro+VhReUwCgLiC0MSIRK3m91DkFVY+i5LQQR1fe1MhvpmnAuEmjQtDaspHUwGeMmGv8igaNBzH0WzbQxNR7SgyPVuA+oUdR1vG6aZTkFAAsTLpXFZWk3MHRf2AeOH9VGa3PyCPzbuC3gdtfSniXAISCuCVIeG/iotcLK6j5yxZ92C4f27kqbGQymXv2n3sVV/Hezq7ztt/PCOrZt/5gPLec/iIuYcd103UrelHWlqkIBERsw9Yfm9v/no1qSptiksLrl889H2w2fj4lM2LJ05uHdH+bFNCKI82DFSh7A0GBC279+4KDUje9uBkwVF5KDiGlOamA2RpjqtYZ/tEknu01h1Bl3Hx5a01AFpGdlb9p401te7cGAtKiDyOaAnWB8IhaLYhGQbSzMmo3qP1uW/epf3KJpIC4t4ufejmJZ6rquHVXzMtuHAS89/M/s401jLaeUQGruubtKBJ5iVnWdjaUo83oMgNQYbUH0AUbCzvXV1FRAoicuSjSjOuhGu2dTCafmghqyAQElkGi85T7edc90pIKDFYdtZm6MCIp9PQ/cEEQRB6hS8kCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotJUWwQl8B+CIMjXQg08QXxdB4IgXw/VFkHpVygpNXlPMoIgSAOkJvcEqXQNMoUgCNLIqaEI0uj4ZS8EQb4Gqv8qrfeIBKUCXom0pwRBEKTRUnMRBOC3YpGg7BuyKIUIgjRKPksEEQRBGjs1uSeIIAjy1YAiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoMiiCCISoOv10cQRKXBDy0hCKLS1FAEhbxioaCUzCAIgjRaanJPUCTgogIiCPJ1UEMRJFMIgiCNnGqLoEQsEouFZAZBEKSRU20RFEv7ghEEQb4ScJwggiAqDYoggiAqDYoggiAqDYoggiAqDYoggiAqDYoggiAqDYoggiAqDYoggiAqDYoggiAqDYoggiAqDYoggiAqDYoggiAqDYog8oUpLuX+e+nO7UcvybyaGpfHP3jqcnBYtFgsJk0IUmd8eRGUSNSicrg7AtIPhGSlFglIK6ICSCSSG/dftB845bvZv2dl55HWsiYRGBrpP2jK/xauT8/MIa0IUjdU+/X6IiFfwC0gM7VBVolw0qXYqzH5kP7R12R5B0sWXVGa04sFSQV8OlXdUU+DXb40lyuceDHuckzeUDf9bb1stRhUsgBp2EDDO/3f7VmLN/bt3m7+j+NsLE3V1dXJMjU1oVB072nA4jW7zE2NNiyZYWVhShYgSG3TCMJhkVhyISq3w+E3o868fZfPI61IdSjl8kFuBk+Yl5MnvdjUKbAIWBAsDhZKmioj6HXU0g17Rg7stmHpLFsrM3kFBGg0apd2frvXLcjOzd+05wSEzGRBwwaU/d6TwJ7fzNR27kxM9bPPkc/hy4ugAYu2pov1pu42O3rb/dzKrKIbiHx98PiC4+dvWJgYzZw4ksPSIK0VcHOy/XZY7+PnbrwICidNDZu375IWrNpGpVIX/zRh2dxJMPXp2o7BYJDFSIOk9hVHLJHE5fFepRbH5/Mhnc8TBqYVB6eXFPDBpZOAkSiCDES4kH6VVpzPE/mYcTyMWDTKB3cAwvSUQmmFl6nFsXk8qF8sEIeml0AWJrBDjExWLQPqpxUJToXn7A7MeJ5SVCLAe+oNl4TktIfPg7u2b2FlbkyaKgPcwy5tfZo42917HCgS1fCV5tBOrsXkb32Zfux1NjS8ird/eEIJtKgdAembn6XtD84MzSgVimv4IVnwW0MjYsYN6z1n6ujZk0bBNGFUf002iyxGGiS1f0+QK5Qsf5C08VnaGA/D9d2sb8UWTLgUy6CoHxno0MJC8+cbCUdCs5Z1sJzmYwx1Vj5KIX+mpsagUnb0sh3hrk8pi4xA9f56kT7/TiJRqgCVor6xm/X3nkagrcQ9QXAhRWI1EFeiQkcb7Q3drN0MlW1/0XGJ42cunz9z/NVbT568Cl3+yxRzI4PZyzZD0drffvTzagKJ+KS072b/3szNcdWC6SwN8vIOkdqcZZsTktP3rFtoZmJAGJUhOTVj64HTF64/SExO9/V0+2ZQ91GDeii4RfJ12rXw/H5kv37d/ZkMOlFKrHP/Hu07t/X5feO+u08CYD7Txw8d0KM9hJNQAQLS+Sv/3nf8IlFfgevHt7TybkqkoRk8ehHy94F/7z8JoNFofbq0+WH8kKYu9rIoFTRryi9/jujXZcGM74iZgze3fOPec1fvHdy0GJYLQd/En1fcfPChk1eGh6vDgc2LneysyLyaGiyr1+hZx3b80adzG9L0EYhNSE7L3L1uvq62FmlVDrgAQxPa8Cyt9P0VEZrNTD/TeW1MdZg0whKTy5t5Pf5WXLmIdaibPkQnZprkfv4kJy/cnDhnJZkpT1d/3z3rF+rr6hDZqg8ogTJ1ANiHM35bz2DQNv/+Uwsvd9KKVB/q0qVLyaRySD+0JKzqxhycNDF53JtxBboatB72Ok+Siq7G5EMbbG2pZa3NOByanV7MH+th5Gao8Tip6EFiIfmzsgba10m3qTGLOPFAnJ+nFN96V7ngglD2dNBpbsrhiSQXovKic7nSq7e6mqcJG4oK+aJ3+TxwHzvZamnQlPJ2c/IK4HymUNT19bTz8gsfvwjJyS9wsLZ8HRETn5zeuZ0vk8HQ4rASktJvPXzRqa2PkYEu8cOYd0mgHeDU9OzYkkJR1rOOiU/6bvYf958E9enSdmCvDny+YM/RC5nZue1aejHo5PkZGRM/4eeVAaGRg3p17NGxVWZW3vqd/8Ai2vh4EAsi1pnLF8DaejV1auvX7E103O6j5x1tLd3L9EsiEZdyed7NXNq18IJFcNisSWMGduvQAtYfJm8PF31dbWJZZy7fnfDTH9pa7JEDu4PiB76OBOn0bOJk/b5HwtzESCgS7j3+X3N3Z1srM7DcexKwZO3uGRNGDOjhD+sDFy2+QNjGz6OVj0dmdh5I3vgRfbv4+8KCmjd1ad7UWZPz4YL09FUonORTxgy0NKvKEwRoVEpgWFRyajoIAUvjo4FzReByuONVxu8PUgQiCTQtCy1GAbQVaFSpxcZsOrQcMMIFe9Pz1H9eZ0N9LQbV14wDAQT4geFZpSyaemsLLfnQpApKSrkOthawpS72Nq9CIkYM6Da8fxdiJ3u4Onq6OzPoUgn75AFVsg7BsXPX4ejDrrYyNwWtJK1I9SHPt1oENMhSm8mkqmeVCHO5oqRCqWJCQ0wu4INSZRYL2HSqpTZDg0Zd5G8BE5SCGg77N7qIXy6AhTY6q6UpTHB27QvOnH0jwUabcWqoU5OPOHf6LNrB/vadbbWhrf96O/FgSBboL4Q/zYyrsY3NXB1HDeoO19gfF6wdM7hXU1d7GyvTAycvZWXnaWtyqFRqhzbNdx05+yI43M3JlvhJ6Ju3KWmZ0AqhlLB8EnC7/r10Nz0r5+jfy4jmC5aDpy7Dhb2zvx/hHIHl/LUHUIfws8AiFIo27Dq2+5/zUMGrqbN0RmUUFBbu+PMXS3MTSE/4ZsDkuStPX7rTo1Mr8Jvg3BvatzPYwZ+ClUxITp06dqDMK5EBQdw/Z68O6dNp1cLphCv63Yi+MxdtOHrmanMPF8IC3t/oQT2fB4TvPX7B092RxxPsOHS2Qxuf0YN7EhsOQR+EfpAAl/BlUJi1hdn/vh8u85drDEg5lUJJz8zNzi2ouOZVAM3v8ts8sUQy0EVvU3cbEw49Lo835XLcg4TC/97mDWuiDxZwFQPSSqDyIBe9v3vZ6mnQ4PK56G7SzoAMuIpP8DKGhkrMrWrgskHECk8DXu88crabv9/w/l2JIhnKHFDlDzrg39LL3cWOyWR2b9+CNCE1QlnPRXnAjTPn0MENzCkVgALG5pJuY0weL7lQkFUqNOXQjTm1L76tzDV9zDggwdpMag97XYiO87nC7JLqfR2USpXuEPjLZmkwmdKrN5zbIqFI9H7ULkR2rXzcn7wMJforQVwevwwFC9iJCsrA5QlAktr6eXq6OxEWONV7dGi1av40Bo2MemR1XBxtCAvIUPtWXukZ2VGxCYSFoI2fp8V7f8rM2ACy8ENwEAiLMoBHmZaR09rHQxaMGxvq+Xq5hkXFweIICwDG6d8NBU8H3MZ/L90Jj46bMWGYoX41hKk+gRa4sbvNg3FN1ne1BtcPLBZa9E42Us8XrsQKt4zhIs0XSe8LgT8Iiln6qx/8UEkFVBJlDqjyBx1o4+vx5OLeu6e3wYWKNCE1ovZFENBj0QxZ1EKeKCaXl1osMGLTdJhU8ATf5vKK+CITTbp2HYzmYzMoRPBSpoMUmro6xMfgCBCltQXEj53a+D599TouXno3Myk1/UVQeEtvD1lcqQyl3FJwytgaTBr1w8XAzMQAJKZbez8iW2mdSgFHSXbnjvCbiLTyELfzbz9+tXH3MdkU8TZBXv0JWnk3HTesz4rN+2GaPHqgX5m30jBh0ymuBhpwIVz9OLX/yai+J6IGnYreE5RJFpehw6R5m7IhAb6h/dbg1gfCpl15dyo8B0IWokItoswBVf6gI7VInYigrgbVUotZKpI8Sy4C7fMz0/QwZicV8ELSi7lCiZ0OU7PRDmkGlenYxgcSz4PC4G9EdFxGTl6Xdr4yGWq8nDh/Y8na3bIJsmSBHOCYQPDFYbPAK+zUxkf5OwCfCZUG3nn12iqEunNuJoL27QqE2Db/Vlz+7XcFKYXlhi5q0NSnehtDLAxpuF4GpZXsD8789kJMm/1h9+ILav0KijRM6kQENagUez2mSCx5nFSUwxU1M2G5GbLSigWQhYYFRXTl7jc3TOxszFv5NL3z+FVGVu7D5yF+nk0cbKV3Nhs7e9YtKIi6LT89urBbvksXKCgq3n74jJG+no6O1sFTl+phDLNIJOJy+YZ62ro6mqRJCaCZ3Y0vPPY6C9IDXfRODnG8963bnbFuk5sr9sNY6zAPD3B4OcH9r542k5obuxhIbwi8y+dveJaWVc17KUgjpU5EkE6VdsZBAi68dIqag56GjQ4DfMDoHC5ce620mWV33horHJZG786tnwaEPX4REhAa2canqY5WNc5PgKXBsrYwK+HyhKIPp1lqevbf+0/fuP+CyFZap44w0NPxcHWA0JfMfwSJRHLm8t3/rj9cMHPcnB9Gn7t67/LNR2Aki6uDtaW00zkhKY3IVgHsgeT0TA6HTa1OhCgUS8IzS4sE4iaGrN87WvZz0mthrgmRr2llo16oFHV3I/ZEL+MtPWwej3f/qaW07xvaakatiqAyB7Q+Dzoio07UCPw8Gx0m8ewHm06FtL2uhixrqc2gVCd4hLrQTGGehXxRTqmwIcQozZo4W5kZ7z/x37vktHYtPKsbC2sw6eamRo9eBAeHRRMWkJJr957OX7WNLyRHgMvqRL6NJyxCoej+0yATYwNne2vCojzSfUiliESSSl/Loq+rbWqsf/dpADh6hAVcvBm/rR8wfm6aXMdIWGQcyPSUsQM7tPKGWLhPl7bbD52peMOeQqGAYIEHV4U+WpgYtmzu/iokgsf/xCszklIyAkMjPVwdtTWlN++URF1NHdoMJHLlOsdSioQ3yo8HfJlabL81SHPNy60v0gVlHSPQMokf0ijqyo2tUhZlDmi1Dvrjl6Gt+03oOHQa7B/ShNSIOhJBdTMtumaZ6hmxacbS7mA6q6xNybqGw7NK3XeEsP58AVOXI29A3fgi8ff/xXJWvwQLFEEF6bzK5uZmwNLToGWWCLsdjWCvlv7EeEOAwgDX+sTSzAiEACLiVt7udjbVjoVBNIf06WhiqD96+pJZizdu3H1sws8rFq7aPmn0gI6tvWV1BvTwhzrjZi3/bc3OdTuOfjNt8R+b9k0bN7hpdXqiCTSYDE93J1jhxWt2Ev0e2w78K3tBC3iC3wzqCS7e8MkLVv99GKYhE37599KdMUN6mhjpE3VAH//af1JPR2v8iH40GhXc4cljBhUWlew6ck4hKNbisGFZ4DMu37CbWNbeYxeKSsijSQCneoc23meu3nv66jVpqgyQgFMXb5Zwud38/ap1pQEJ8zFlQ5tJLRIMPh0N7WrU2bct9r5+klRE1igDLs9eJmyRWDL3VkLrA+F9jke22v967RNpl1dTI5YJpxK3scYoc0CrddAfPAuCy1JASMT1+89JE1Ij6kQEAUM2zahsXIKpJkNXg2qiSQP5g2zNuoahpc5paabw/pgvCJVK9W8lHd8HDpGOFocwVgsHG8vDW5Z8M7j7jQfPl6zd/S4xddncScvnTZENUgFcHGygTv/u/mevgKDsLSop2bfht2njhoIGkTWqw7C+Xf9c+OO9Z4FEv8fRM1dlfh8wuHfHEztX6OnqbNlzAiZIHNv++5A+nQjpkQXCU8YOsraQDkgE3F3svhvZ7/i5GwpBMeyc6eOHgMN47NxNYlmXbj7k88v1SECdb4f2trM0W7ZhT3hUHGktDyjgP+eu7Tx8buI3/T3cHEmrcsBat7bUmtvaVIOmDtfXY6+zz0XmlgjFsgdFCAxZtIXtLEDvIB2WWXL7XUFktlTQITqe29pMt3zlz0eZA6r8QYcQxMnOCo5Cp7bkhROpGXX1Ki2eUPI2txSaHVyN7XSYQrGafBYijhKB+G0ulwsFlaFBoyi8NUsskaQUCtKKBUSfHU1d3UGfCW1aKJbE5vHyeULZnKEUsjE50vGJRB3p72sV2GkQGB48dfnQliWyUdMEL4LCH74IJjPl0dbkjBjQDZ8klRH0OuqnZZtj3iX/MG7wuGF9ZA8dQij9POjN7qPnTv93G5ygRT9NlL82KA80lbg8/v2EgnyuSItJ7WijrUFVTy0WQCtx0tcAfSSqQZt6kFAYlV0KATxV2q402llpQVMiSpGvni//PsHGSF5B4bT563S02OuWzFQ4P5V/jBQBklMzVmw+cP7a/Y3LZsmesiCeF4Zw79cfv+3fo33Fx2YRpBZBEawJd58EjJ62eNXCaRDTkSbkM8jMzuMLBBamRkQWPMHYhBRLM5PPf+oOQT5JQ7nL1oiAU/Th82BbK7PWPh6kCfk8jAx0ZQoIUKlUJzsrVECkfkBPEEEQlQY9QQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUQQRBVBoUwTpHIpFExsTvOHw2r6CQNCHVQSKWFEemJe17kHTgobBE+q5cMV+U9u/LhB13857Fibif+EoJoiQ8vuD2o5eVfmq1HkhITt977IL8N20qokydGoAiWLfk5hfMWb7Fr9d31+8+EVf6lSOkSkD1ohefDZ24P2n/w+wb4ZKyz6JLxOL8Z7EpR59EzDkeNu0wPwOvLp9LcFh0v29/HvjdvHdKfAKwLuDx+fuOXWzZZ8KuI+c+9vktZerUAOrSpUvJpHJIxCKxUHo1bqRkZOXefRrI5wmMDHSr9e2eGgDL+t/C9a9CIlYvnL5gxvfamjX5GklDQyIUFQTEF79JZRhqUph1/s7n/CcxyQcemw72cdvyjdmIFlSW9CWDFBrVsJu7xbdtGMbaWZdC1GkUHd9yHzlAqsXD58Hf/fS7tbnp3vULB/fuWNfnRaUY6OkM69eFrcFcsfmASCz29WxCr/BZFWXq1ADV8gS5PP7qvw+NmvrbtAVr4hKkHxWrGU8DXms7dz554SaZrwy4Um3eeyIk4u3m338aMaBbpa8IhVAuct7Jl303Fb/NIE0VkUhyHkYFDtv21H8VMQWP3iXI+fCNpHqmIDgx4ueT0UvPQ3xKmuoSbkYh+H26rR2pGoqCq06j6rdz0rDUK43Lqjoojlt3FfYbxM5kvkZIJJJ7TwJ7fjMTDj0xDZ4wLyfvi33y8JOUcvmzFm/85EpCjLl8w95mro5bV85p7uFCoVSiCRDQLN+wx8ZvoGzbq278NQO8hB+/H7Zh6cw9/5z/78aDSl91qkyd6qJaIqjBZIwd0mvZ3EmzJ460tpB+/7vueB0Rc/Lirenjh7X1a0aaakRxTGbsn5fVKOqmQ3zNhkkng25N1DVq/+tRSsJxM7Oa3N5sZEvjgV/+I2divlAsFDGMNCtKZK3z9l3SglXbqFTq4p8mQBOCqU/XdgxG4379NYjIhWv3k9Mz500bY2yoR1rLA3V2H72w8/C5UQO7EhsOk521OVlcq4AE9+rSpmv7Fkf+vSr7JKwCytSpFip3T9CrqfPsSaMG9e5Ysw9XKgm0m1sPXxrr63ZrX70P5lZEkF0szC81HeZnO6ubzQzpZDm+HY3NJIvrHVi0+ejWNtM7s20NSVNdomGhC38lYhGRVUBYxBMV19PNmezc/NCImHHDes+ZOhqaEEwTRvVv7N8OzMkruPP4ZTf/Fq5OdqSpAlyeICUts6V3k3nTxxIbDpOfVxOyuLYBX69/j/Z3Hr8Kj/6o565MHeVp6CJIBJ4nzt+QRSL9x82BtLwbDN4++Pzg+QeHRX8zfQnU8ekxbvuhMxAOkDXez0c2QWX5UoLVfx9u239S0OuoVX8ddO80Cpz/Gb+tT079EKjKZtJ95AzITpyz8mMzhHRicpq9rYWxIfnx8kqh0Kk0HbY6laJOVRTK1NMvieA3Ys5xyMZvvkFkYSoXDkskuY/fhkzY96zD6med1oRNO1wYkgRGspRAmTqfgojcZesAU6XRpSC3BFb1Zc8NRJ2gkTsyLgVLhJVLmDKoU6TXKm5yHpGtFKrmJz7IyTDSUqdQ1N9/Y7NaQNz3sYOuEGlCU5m/ahu0HCjqPWb26f9uK9y8J2YFrRdCOahm0bzvtzOXhb55SxaXtUBoSPBDaMA/LliXnJb5x+b9Dq0H/7Fpn/wX7sVi8f2ngaOmLYY5wAQJyMq63YgoGBZk0qznvuMXbz54adtiELHCMEEbJqoRgLKnpGdV+kUX4rT62Hzkw2GhUHTx+n04McEO2zVz0QYIscmy9yhTR4aznZWHq0Pg60gyXxnK1FGSht4xkpSacfj0FV1trRv3n/u39Gru4fL4VejZq/c8mzjZWpkRdUq5vAvXHxSVcOGa5mhn1bNT69JS3o5DZ3h8frsWnjSq9CyCtLmpYae2Pq18PDKz86wtTLr6t1C4q/roRcibt3EJKRlZOXm9OrfmsFkXrz8Mi4rr0Kq5Jkd6wZfNxMXe5lVIxIgB3Yb37wJZmOB4uDnZQKxEzKqwuPjomatmxoY9Oraq4t6tOkU9/3ksKJrpIB/ilr8McSmfrqWh5W7O0NcsTcjWamZl0N4ZsjBxmphreVpR6DQQsrR/A2JXXqLQqAad3Vh2hoWhSRkXg9h2RiyZm6ZMHWUQq4HPxbLShxVQp1H56QWG3ZtqWJYLoEAoYUFZ18O0vaz12jhoupnzUvOzrrym6bMhTVaqJiB/Wddf67Zy0GpSyRxg12VdDdVraa/Z1II0VUbx24yiNykmA70Z+tXumyop5TrYWnzkoDt6ujsz6NJIPDImfsLPKwNCIwf16ggHPTMrb/3OfyBwa+PjIbvLFhYZCw2VpcF8FfKmX3d/N2e7249enr50B+qYmUiPBbTAyJh3ahJ1G0uTExdu5uYXMmh0LS3OyQu3IIJxtLWEOtLg9J/zMxau19ZijxzYvaV30zfRcdsO/GtjadrE2Q7CDolEDGeEdzOXdi28+HwBNONJYwZ269CCWGdvDxd9Xe2y1ZESHZe4YeexUQO7ubvYk6b3iMQSvkDYxs+j0vnACWhR9m0sULe/9p/8328bXB1tvxncA8Lky7cfX7rxsGXzprL4Wpk68sAF+ub95xZmxnD+kqYKKFNHSb7YraVqIRSLDm5ZTPSujh3S8/vZf1y4fr+lt7sG84NwgGO8c/WvxB6By+biNTsv33w0akD3pq7So+tgYwk+PCTg+vYyKEz6g8oIi4ybNHrg+OF9oOFCazt46jI4g49eBA/u3QlKZTOBy+nOI2e7+fvJPpVbY8BJIVPl0fGxhQkS4HDlPIzS7+RqNtSXKJIhyClJPx/AdjFxXT2crscGC2hTxLyTyUefaDe3pmlLhVuZOspAYVBNh5ArAF5qYUgikZaHm5RbEJpoMqC57exuamU3AUSF3Ji1V4pCk0U9PKjsat8+A1XNe/IWHD3tj2gc00hLw1wv73mcYU8Pms5Ht4VpWPlOVgaI+4jQr4qDDk3l/LUH6Vk5Bzct9vV0Awuc9ht2HQO16tO5DegXUY2ASqUc+msZ8bnqnh1bTfnlzwvXHzZr4khcQfl84Y/fD2OzNIpLuPq6Or/NGp+RlTcxZ0VYZAxUhgppGTkXrj34ZlCP5fOmEO7bD+MGz/39r+Pnr3du52ugpwOiPLRvZ7CDSwhhbEJy6tSxA2vwtWuI9CHeh0TV84lLTDl98fb074Yunj2RWB/iDD169uqyOZOIK4QydeSBqwaVqp6angWLrrRHEVCmjpI0jnuCXdr6EgoIWFuYQaOMS0guKS0lLARt/Tw93Z2INLSwPl3bxsQnx6dUb9CTu4sdyChx6YaLahtfD7BExyURpXWBxbi2nkcn06vvoQD83GJBbrF+WydC3QCGibaWhyUvJY/3fuicMnVqF3W5Pgqqlobz8kGOi/tXSwFltwJedFuX+zDa4be+HJfKe7FA+ByXDhAUlr7su4n4Sdy6q2SZHPodXXz/m8VxNCbztQ1x1wxaoIujDWGh0ajtW3mlZ2RHxSYQFhnQMmUf7IcWC796G58IcQxhgRMbWh+0PdBEDQ0G/GUyaUwGTSgko10zE4NLhzesXfw/2ZkPp4a9tQWIY07eF/gMJHGrtFv7FrL1Ic7QyLfviopLCIsydb4gX0/HCFuDSaN+cGwhOlg2d5KxvvS2uvJQIECV68eANFjITMOD6DOhcKrqJFGmTm3BNNcBoUk79SLyl1MZl0JKotKJBzyqC9vOkOgHN+rlISriZl0JFZYq3sAlkIjEWddel8Zk6LV2IH6i1cyKLKtHSrml4CgptMCPAV4emYI9xqB3b9+iY2tvcA9JkxKAmxkQEvH3/tMbdx8jppfB4WRZvZNQNrhafqMqokydL8jXI4IKEKErEcgg9QONzXRcMtB0YPPCkKTYPy+FTNj3qtemN7OOcVOq6taoiI6PLdEP7rCgr/2vfXIfRBe+fEeWlYeXmpdxKdi4j5fL6mHETwy7u5NljQEidK1WL3NxKfeXFVs7Dp02f9W2JWt3E9O1u8/I4q8IuDB8cmCFMnU+yVcrgsgXAYJum5ndfK/+5HvtJ88jk00GNi8ITEjYdlvMq2EHMYXFkIjF3I9E7iKuUMwVSIfRfP6p0Ei4dOPh8XM3tq6ck/n6WkHUbWJaOPM7svirgMcT8vhCY0N9+Zv+CihTR0lQBOsElgbL2sIsMSVN4cZl7UI34NB0WOIqB8opU6cuAK+QZWNgPa2Lnr+T9ImO4g8jPGoAjVNVQy9NrIURs58DcbhLuDyhSPpoc50Sl5jq4mjToZU3hNKk6TMw0NPxcHV4l5QmP+asWlhbSm/XlsiN4KmIMnXkkQ7cScus2jtWpo6SNA4RvP80qKCIHBmXkJz6IijcztqCzaqF7a8ZVApFi8MWiT76QgSWBsPJziokIvZdYippqgMYehy6HifnUbQgl7y7zE8vKAxNYprrMo3J/lBl6tQWOfcig0fvyrrxofNdOsgi/7MuA7zUXPhL16/lVVUAYsxfV2y1aN73j837SysMIP0kGky6uanRoxfBkW/jCYtQKIJGa2Js4GxvTVhqCxqNkpiaId+u4hJS7jx6SWbkAOcYokWRCDxp0lIR8KTsbS2CwqLzC4tIUzUhZPTG/eey/UacoS6Otpocsi9OmTryBLyOyMjK9fF0JfOVoUwdJWkcQ2TgWI6bsbyVT9PC4pKzV+7CmdW/e3vl3WC+QHDh2oPEVOngTDgMiSmZRcXcv/adpNOlgxLa+XlW99ahlbmJr6fb1v2n4pPTmGUvEXBzsiNGMMjo3M73wMlLB09ecnWylfUG1i50fbbJAO/4v26+nnxAt6W9WCDKfRgt5gudlg2UjX1Rpo4ylMRmZv4XRKSLIqV7MuNcQP4z6UBfqjbLdLgfuH5aTS0oLHrMykvZN8I0LPUkYrWCwHj4odnIFlWMX6ka8fte0Uph6HPoOmwxTygRidWr07egAPgUD54FQ+u6cuvxiP5d4QJGFiiHurr6gB7+V+88GTdr+aBeHXW1NZ8HhF+9+2TZ3ElNXR3ISrVEjw6tj5+7OW3BGliQgZ52fGJadFyivp5uYZFiNyucIJ7uTruPnl+8ZqeTg3SLmHTGkD6dTIw+DODX0eJ0a9/ixwXrBnRvN7x/V/leQSWxszIf2q/zkrW7Y+KSW3g3ySsogjPUxFB//PA+srEvytSRkZKedfLCzS7t/Vzfd7VXRJk6ytM4PME2vh6zJo2Ey92WPSccrC32rF3QvpUXWaYEcDF8+DyYuIX8518HI2Pinwa8/mPTPsJSgzcpmBob/PHLFBsr85VbDhAzCQ6LJsveA4fnu5H9QAd3HPq3Fl/7Uw51ddMh3s6rhlC1NTIuBmddD4MI1G39SL3WcieeMnWUgJ9ZlHrqJTERgwRzHkYRWdkbrugGmi5/DjPs7p4fmAD2tH9fikr51j90sprYscYKRaFJfygqqtydFBZyRTXqgFYA/Dj/lp7g3ffq0sbSzIS0VgcXB5vDW5b07+4Pp/fyDXuLSkr2bfht2rihtf50ZlNX+30bFvo0c91/7OKmXSf4fMGWP37ybOJIFpdnWN+ufy788d6zQKKVHj1zVRZRyYB1Htirw/JN+8B1rUFQDBv4v++GH926lMvjwYbD5ndt53dg02LYIWQN5eoQ5OYXwBkKIf/k0QN1tSt3/5WpUy3Uq7vZIiFfwK2/4UigVt1HztizbsHnD0uuf8Dr3LT72Kq/Dnb19502fnjH1s3r9IHlr5LShOyIn04I8kv02jqxbA0Il1PMF2VcDCyNy8p5ECXMK3X+faBeexfyB0j1SUxO+2nZlscvQr4Z1GPy2IHVdYRrBXDDL998tP3w2bj4lA1LZ1b6Ri9l6tSAxuEJNlJYGoy5P4zZv3FRakb2tgMnC4pqeNtFlWFZG7huHKntaZVzL1Lhparg2NINNcHJ1fMv90gGUl2sLEx3rf11ytiBJy/eOnP5LmmtX9IysrfsPWmsr3fhwNqPqZsydWoAeoL1gVAoik1ItrE0q5UePQSpIyBYzszOdbCRPqRcz4CXl5WdZ2NpKnvUuiLK1KkB6AnWBxAFO9tbowIiDRxtTc4XUUBAi8O2szavWt2UqVMDGroniCAIUqegJ4ggiEqDIoggiEqDIoggiEqDIoggiEqDIoggiEqDIoggiEqDIoggiEqDIoggiEqDIoggiEqDIoggiEqDIoggiEpTbRGkUPCNeAiCfD1UWwTVKVQKpXG8lB9BEOST1CQcptIb6EeUEQRBqksNRZBG/2JfekMQBKlFqv0+QRkiQamAV6KmVsOfIwiCNARqLoIA/FYsEsD/KIUIgjRSPksEEQRBGjs4ThBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJXms94sLRAIL924G/H2nUAgIE0IgiCNipqL4OZdh1ds2JFXUEjmEQRBGiE1FMGfFq3euvcomUEQBGm01OSe4MHj51ABEQT5OqiJCG7ceZBMIQiCNHKqLYKFRcXhkTFkBkEQpJFTbREs5fLIFIIgSOMHxwkiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLSoAgiCKLS1JUILpk7vSj+VfDds2S+Ruxcv5SfEiKbKp2bMnUQBEE+RoP2BJNS0kPfRMEU+y5RLBaT1vIoUwdBEORjNGgR/H39dp8uQ2E6dvayUCQireVRpg6CIMjHqHMR3LZmcU70UwhUC+JeXDq2w83ZgSwoA7LnDm0lKpQmBkU/uzp3+vdkWW3zzZC+Abf+LUkIhGUVvnv55Mqx7h3bkGUIgqgqdSuCpiZGQ/v3SE3PjI6Np1Ao3Tq02fTHfC1NDlHqZG9zeNufvbu2F4nEYRFvY+MTzUyNFs35YfmvM4gKtcjkb4dvWjHf3dUxIysbYufCohLvZk12b/x9QK8uZA0EQVSSuhVBBp2+estu93b9YPp1+YbiklKQnj7dOhCl4Jq5OtmHR8a07z+2eefBUGfDdunHPAf36Qr6SNSpLQb37aajpXnl1gOP9gMgdnZp1evuoxdmJkbjRgwgayAIopLUrQgmpaTtOnSKSB88cQ6yLBbTxdGOsJibGoFKvgoOexNFfsPz+p2H2Tl5JkaGPp7uhKW2MDM2LCnlXr/zqLCoGLLw9/GLQL5A4GBrRVRAEEQ1qVsRFIvFhOgAkFDovbWxsoC/ndq1eHXrNDFtXrkAgmUKRZ1KpRJ1agVYhI62Fiw9v7CINCEIgpRR5x0jn8TS3NTDzVk2aWtpkgUIgiB1z5cXwf3HzjDMm8lPBs6tj56+SBYjCILUJV9SBOMTk+EvjUojsnXHnYfP8wsKKRSKDrqZCIKU50uKYEpaJl8gaO3nJRs8OGXc8MyIx4nBd3p2bkdYCOITU/h8AYfNaunTjDRVoOo6qRlZbJZG905tiQE68LeNX3MGnR7zLpGogCCIavIlRfCff/+LiI51tLO+f+Fw4O0zYQ8vrl/+iyaHfePu46u3H5KVyngTHZOVnWtlYXZyz0ZZL8qVE7t8vZqSNT5V58x/N/ILi3p18Q+9fx7skU+vdGzrl5yavuvQSeLnCIKoJl9SBKNj48dO+/XyzftUKsXd1RHUMCc3f+veozMXriRrvOfZq5Cla/9+G5dgbGgg60Jxc7LX0mSTNT5VB8Ru1sJVYRFviVIwBoSET/l5iYLaIgiiaqhLJBIyqRwZWTmWzTqSGQRBkEbOl+8dRhAE+YKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKgCCIIotKonAhO/nb4mQNb1iyZQ3x2DkEQFafORbBDG78nV46VJgbxU0KIKfjuWbKs3mnX0nv+zEl9u3f84buRMyePJa11iZuzw6tbp2Hz/169iDS9Z+m8H+MDbxF7Ji/m+YOLR2BfkWUIgtQXdS6C82dN9vF0z8zOCX0TRUxRMe/Isnrn4bOA81dvwzrce/zy3/9ukNa65NcZE91dHINev/n19w2kqYx9m1f88r+JxoYGCUkpYRFvBQJhS59m+7es6NSuBVkDQZB6oc6/Ngd+n4Od9dqt+5at/Zs0qQw/Thj9+/wZxSWl03/5/fyVW6RVTW1Ary471i2hUWm/r9+2ZfcRsIDDeGznOjdn+4Mnzk3+aQlRDUGQeqBOPEFwZ94F3CSCXzi9GXT6wtlTiCxM8uEwlJ47tDUn+inYITCE8HDu9O/JsvcoU+eT7Fy/VLYCMMHqVepz/bnop4Sg27zkYKgDfyENFrKsmoBnN2PSGDqdtv/YGXkFBLyaumppcmLjEwkFBN5ExTx+EQgJa0tzwoIgSP1QJyJYWFTyJjqWCH4LCovEYnHsu0QiC5MsHAZ1O7J9de+u7UUiMYSEEBhCeLhk3vTVi38mKgDK1FGGpJR0YumRb+Mg9iSt5Vn08w/Tvh9lqK8XU7a28BfSYAE7WaM6LJ4zzcbK/NGzwDV/7SVN7wGnWNPGp2WPEWQeQZAvR52I4Mug171GTPbpMhSm5NR0oUh07OxlIgvTsAmziWrDB/R0cbSLT0wZPnFW886DXVr3XrdtH9gH9+nm69VU+TrK8Pv67cTS/9yyh8vjkdbytG3pzWQwjpy+0KRtX6gJfzfvOlzK5bXy9SRrKM3yX2f4t/JJScvYuONAYVExaf044BjC5kgkksjoONKEIEi9UOcdI1VgbmoEkfLzwJA7D58TltsPnmZl5+rr6YDwERZl6tQiIEN8voDMqKnN/2ODiVu7PqOmknnl6Nm53dhh/SBx+NTFq7cfQuLqyd0QX0NIXlZeCZtXLPBwc05ISv3nzH+kCUGQeuFLiqCNlQX8LSouIbKVokyd2uJVcBgE3eNHDQq+e/bQ33/OnDy2Ws4mAfh0s6eONzc1fvQ8cO1WxUC4UsBtHNq/e2Fx8bpt+5+9CiGtCILUC19SBBsaC1ds+mvPkZzcfFcn+5GDeq9dOvfBxSNPrhyr1vC9/j07+3q5p6ZnrvlrjzKB8NJ5P4LaSiRq2/Yd23XoJGlFEKS+QBEsx6+/b7D26mzv233MD/NAknLzC3w83WdPHUcWK40mh71u2bxXt04TE4S6ZEF5Fv38w/8mjobExh0Hl67ZShgRBKlPvqQIxicmw1/QCyJbKcrUqXWSU9NPnr/6469/bN55iMvj2VlLQ/Jqoa2lCcInm4wM9MgCOUABZ035FhLr/t6HCoggX4ovKYIpaZl8gaBF82ayIXud/VsZGuhBQBr5luwkVaZOrQBSFXj7TMrr+3OmfUea1NQM9HWpFCqZUY6jpy8aOLdmmDeTn24/fEYWv0emgJt2Hvp9/XbCiCBI/fMlnxghxgCC+uQXFCWlpLFZGtaW5gKhYNPOw4v/3KJ8nU/i69X09/kzjA31Ic2g0+1trIQiUVx8kkgsAsuzVyHT5i2HxK4Ny8YOGwDG+MQUcAA1mEwbK3MQwcOnzn/mUxxXT+7u3K7l/mNnpvws7SBu19L78LbVFmYmKWkZ2bl5RB0C2L2LVm15GfSazCMIUsd8SU/wTVTMmB9+uXzzPpVKcXd1BHXLyMr+fd12eXVTps4n0dJkuznZE5Gpi6MdnU5jaTCbuDgQFntbK6Laz4vX7Dh4vKi4xNHOGuzwF9KgXGAnKtQWsALq6uqQMDc1JtZBNsF6wtoS1RAEqQfq3BNEEARpyGDvMIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKg2KIIIgKs3XKYKd2rV4F3AzO+rJ6KH9CEvw3bNF8a+WzJ1OZBEEQQjQE0QQRKVBEUQQRKWpQxFs6dPsyoldEITykoOTQu4umDUZYlL5EBVwc3Y4d2hrTvRTfkpIaWJQfOCtudO/J8veo0ydfj06vbp1GkphWRAIt/RuRhaUR0uT8+TKMaIazGfWlG/JAjW1X/43sSDuBfwWQmnSpKbWs3O7xOA7uW+fTftuFGlSU/tmSN+AW/+WJATC+sBPHlw80r1jG7IMQZDGRl2JIMjN6sU/d/FvJRaLI6JjCwqLJo0dxtLQIIvLAHU7sn11767tRSJxWMTbhKQUY0ODJfOmww/JGsrVAbVdv2yeh5tzUXFJeGQMny+YNXWchgaTLJZj5KDeNlYW4VFvs3PzTY0NF8yeMvnb4UTRmUs3klPTjQz0u3b4oGj+rX31dXXAfuPeY8IyfuSgjX/86u7qmJGVHfomKic3v4W3x871y0AuiQoIgjQu6koERw/t26yJS35B0dylaz07DmrStu+R0xfNzYzJ4jKGD+jp4mgXn5gyfOKs5p0Hu7TuvW7bPrAP7tPN16up8nUgbWluClI1dto8qOPcqtel6/e0NTWJUhk0KjUgJNylVS+fLkPh791HL3S1tQb06kyURsfGvwwKo9GorX29CAvg4+kOlsDQN1BKWEYO7q2jpXn87GVb764wH4/2A24/fGZmYiTv3iII0oioKxE0MTJkMOix8Yk7D54kLOev3E5NyyTSBOamRgw6/XlgyJ2HzwnL7QdPs7Jz9fV0QPgIizJ1dHW0QKoevwi8evshYQG3Licvn0jLEIpEr4LDCouKIQ1/oT5fILA0MyFKAXD3wO5kb0O4dRAXuzragUXmBgJmxoYlpVzZykDpo2cBAqHQ3cWRsCAI0rioOxE0oNNoufkFZF5N7WXQ65LSUjJTBkSm8BdiWCJbKTWrAwsSCoVkRmnOXroZG59koKfbqV1LyLZv7WdooJeUkg52ogLIoo62FpPB+Hna+Fe3ThPTiIG9KOoUKrUO764iCFJ31NWpC6Kgrq5OZhoJ4NbdefgMEq18PeFvcw83iKAfPnsF9rJyEjqdBk6oh5szMUEaLGQZgiCNjboSwbz8QqFQRGYaDyCC2bl5oGsTxwxt6uqYX1j08FkAWfYe0MTvZixkmDeTnzw7DiKLEQRpVNSVCJaUcsUSsY2lmZO9DWHp062Dgb4ekSaIT0yGv5ocNpGtlJrVYbNYNFpNvLOrtx++Cg4r6zDpYmRoEJ+YcunGPbJMKpHP8wsKwcOFSJ80IQjSyKkrEXz2Kjg3r8DWynLVb7PdnB06tPGb++P3RgblRDAlLZMvELRo3kw2NK+zfytDA72c3PzIt3GERZk6hNfZxq+5bJzKkL7dDfR0ibQMBp0OdbQ0OZCGv5AGS1JqOlEq48mLIFhi2xbNmQw6pBVi4dSMLA6bJT8w8ODWVdykoNtnD5B5BEEaFXUlguBSnbt8SyQW9e/ZOfju2Run91pbmL1LkLpsMk6evwpCZmNlfnLPpsDbZyKfXJ4z7XuxWHzs7OWXQa+Vr3Pm0o2klDQLM5PD29ZAnainV3p3a59fWEiUygBpc3d1jHx65dWt0/C3Y1u/vILC81duk8XvIQYMgl8JpfefviSt7zl+5jLYh/Tr/i7gJswH/o4c1LugqPj42ctkDQRBGhXUpUuXkknlKC4p3bBdKa/nyq378Ump4DcVFRffuv9k/h8be3Xx19bSvHLrQWh4FFTIys598PSVjaW5nbWFpbkJFGVkZa/bum/Fxh3EHABl6oBmvUtMaeLiADpobKTP4/N3HTrl4ebEZDBky/ph/Eh9PZ1//r1kYmTg4mjPYWukZWSt3br3733/EDORAT5mGz8vdxfHoNcR85atI63vAWNKWoaTnY2NFSzNiKWh8SYqZsXGnXuPniZrIAjSqFCXSCRkUjkysnIsm3UkM9UEXEJLc9MZC1YePX2RNDU8IFK+dWY/iOCmXYcWrthEWhEE+Uqpq3C4IsQgO7FYIhI16F7jPt06QPSdk5f/4IliLIwgyNdHHYqgr1fTKyd2yQYVH/hrFcSP8UnJr4LDyBoNEhBBXW2t6Nh42fMnCIJ8xdShCGppst2c7GWDio0M9ANCwn9evEb2HG4DxMneprmHm0AovPf4BWlCEOSrpl7vCSIIgjQ06u+eIIIgSAMERRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJUGRRBBEJWm2iLIquyj5giCII2UaouglianiYsDmUEQBGnk1CQcnj1lHJlCEARp5NREBMeNHPjjhNFkBkEQpDFT7Vdpydi86/CKDTvyChS/Z4QgCNKIqLkIAgKB8NKNuxFv3wkEAtKEIAjSqPgsEUQQBGns4DhBBEFUGhRBBEFUGhRBBEFUGDW1/wNfU02AIihKgQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"C:/Users/T0230575/Desktop/Datalab LAS/Documentation/Method/func2.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The timer() context manager\n",
    "A colleague of yours is working on a web service that processes Instagram photos. Customers are complaining that the service takes too long to identify whether or not an image has a cat in it, so your colleague has come to you for help. You decide to write a context manager that they can use to time how long their functions take to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'contextlib' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-43e2b4dd69d6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m# Add a decorator that will make timer() a context manager\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[1;33m@\u001b[0m\u001b[0mcontextlib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcontextmanager\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mtimer\u001b[0m\u001b[1;33m(\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      7\u001b[0m   \"\"\"Time the execution of a context block.\n",
      "\u001b[1;31mNameError\u001b[0m: name 'contextlib' is not defined"
     ]
    }
   ],
   "source": [
    "from contextlib import contextmanager\n",
    "import time\n",
    "\n",
    "# Add a decorator that will make timer() a context manager\n",
    "@contextlib.contextmanager\n",
    "def timer():\n",
    "  \"\"\"Time the execution of a context block.\n",
    "\n",
    "  Yields:\n",
    "    None\n",
    "  \"\"\"\n",
    "  start = time.time()\n",
    "  # Send control back to the context block\n",
    "  yield\n",
    "  end = time.time()\n",
    "  print('Elapsed: {:.2f}s'.format(end - start))\n",
    "\n",
    "with timer():\n",
    "  print('This should take approximately 0.25 seconds')\n",
    "  time.sleep(0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yield is not only about returning a value, it also gives control back to a function calling the context manager.\n",
    "Like when we want to push a value towards another function in the same script, as soon as it gets computes, without having to wait until the end of the function's execution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And your colleague can now use your timer() context manager to figure out which of their functions is running too slow. Notice that the three elements of a context manager are all here: a function definition, a yield statement, and the @contextlib.contextmanager decorator. It's also worth noticing that timer() is a context manager that does not return an explicit value, so yield is written by itself without specifying anything to return."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A read-only open() context manager\n",
    "You have a bunch of data files for your next deep learning project that took you months to collect and clean. It would be terrible if you accidentally overwrote one of those files when trying to read it in for training, so you decide to create a read-only version of the open() context manager to use in your project.\n",
    "\n",
    "The regular open() context manager:\n",
    "\n",
    "- takes a filename and a mode ('r' for read, 'w' for write, or 'a' for append)\n",
    "- opens the file for reading, writing, or appending\n",
    "- yields control back to the context, along with a reference to the file\n",
    "- waits for the context to finish \n",
    "- and then closes the file before exiting\n",
    "\n",
    "Your context manager will do the same thing, except it will only take the filename as an argument and it will only open the file for reading."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@contextlib.contextmanager\n",
    "def open_read_only(filename):\n",
    "  \"\"\"Open a file in read-only mode.\n",
    "\n",
    "  Args:\n",
    "    filename (str): The location of the file to read\n",
    "\n",
    "  Yields:\n",
    "    file object\n",
    "  \"\"\"\n",
    "  read_only_file = open(filename, mode='r')\n",
    "  # Yield read_only_file so it can be assigned to my_file\n",
    "  yield read_only_file\n",
    "  # Close read_only_file\n",
    "  read_only_file.close()\n",
    "\n",
    "with open_read_only('my_file.txt') as my_file:\n",
    "  print(my_file.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is a radical read-only context manager! Now you can relax, knowing that every time you use with open_read_only() your files are safe from being accidentally overwritten. This function is an example of a context manager that does return a value, so we write yield read_only_file instead of just yield. Then the read_only_file object gets assigned to my_file in the with statement so that whoever is using your context can call its .read() method in the context block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple contexts\n",
    "\n",
    "It is possible to chain context's in Python, this allows to do very useful tasks in practice.\n",
    "Imagine the case where we have to open a file, read and store its context, then save it to another file.\n",
    "It it possible to do this in practice with 1 context, although if the file gets too big, we would be stuck with memory problems.\n",
    "So instead, we can open 2 files at a time with 2 contexts (1 for the file to read the data from, 1 for the file that will receive the data), and copy row by row. No more memory issue.\n",
    "\n",
    "### Nested contexts\n",
    "\n",
    "Same goes.\n",
    "\n",
    "### Error handling with contexts\n",
    "Now imagine someone uses the context manager we wrote, with a function, and gets an error for some reason; we need to handle errors in context, that is the role for :\n",
    "- try: allows to write code that might raise an error inside the try block, and catch the error inside the except block; this is the code that might raise the error.\n",
    "\n",
    "- except: do something about the error, can choose to ignore the error, or re-raise it.\n",
    "- finally: runs no matter what, so the function does not crash even if we have an error in the try block, we get a results whatsoever (for instance, DC from the database, eventhough the query inserted in the try block has a syntax error and raises an error).\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### When to use a context manager ?\n",
    "It is good to start considering using context managers when our code involve the following patterns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"C:/Users/T0230575/Desktop/Datalab LAS/Documentation/Method/contextmanagerpattern.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Context manager use cases\n",
    "Which of the following would NOT be a good opportunity to use a context manager?\n",
    "\n",
    "> A function that prints all of the prime numbers between 2 and some value n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scraping the NASDAQ\n",
    "Training deep neural nets is expensive! You might as well invest in NVIDIA stock since you're spending so much on GPUs. To pick the best time to invest, you are going to collect and analyze some data on how their stock is doing. The context manager stock('NVDA') will connect to the NASDAQ and return an object that you can use to get the latest price by calling its .price() method.\n",
    "\n",
    "You want to connect to stock('NVDA') and record 10 timesteps of price data by writing it to the file NVDA.txt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the \"stock('NVDA')\" context manager\n",
    "# and assign the result to the variable \"nvda\"\n",
    "\n",
    "# with stock('NVDA') as nvda:\n",
    "#   # Open 'NVDA.txt' for writing as f_out\n",
    "#   with open('NVDA.txt', 'w') as f_out:\n",
    "#     for _ in range(10):\n",
    "#       value = nvda.price()\n",
    "#       print('Logging ${:.2f} for NVDA'.format(value))\n",
    "#       f_out.write('{:.2f}\\n'.format(value))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can monitor the NVIDIA stock price and decide when is the exact right time to buy. Nesting context managers like this allows you to connect to the stock market (the CONNECT/DISCONNECT pattern) and write to a file (the OPEN/CLOSE pattern) at the same time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing the working directory\n",
    "\n",
    "You are using an open-source library that lets you train deep neural networks on your data. Unfortunately, during training, this library writes out checkpoint models (i.e., models that have been trained on a portion of the data) to the current working directory. You find that behavior frustrating because you don't want to have to launch the script from the directory where the models will be saved.\n",
    "\n",
    "You decide that one way to fix this is to write a context manager that changes the current working directory, lets you build your models, and then resets the working directory to its original location. You'll want to be sure that any errors that occur during model training don't prevent you from resetting the working directory to its original location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, sys\n",
    "\n",
    "def in_dir(directory):\n",
    "  \"\"\"Change current working directory to `directory`,\n",
    "  allow the user to run some code, and change back.\n",
    "\n",
    "  Args:\n",
    "    directory (str): The path to a directory to work in.\n",
    "  \"\"\"\n",
    "  current_dir = os.getcwd()\n",
    "  os.chdir(directory)\n",
    "\n",
    "  # Add code that lets you handle errors\n",
    "  try:\n",
    "    yield \n",
    "    \n",
    "  # Ensure the directory is reset,\n",
    "  # whether there was an error or not\n",
    "  finally:\n",
    "    current_dir(os.getcwd())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, even if someone writes buggy code when using your context manager, you will be sure to change the current working directory back to what it was when they called in_dir(). This is important to do because your users might be relying on their working directory being what it was when they started the script. in_dir() is a great example of the CHANGE/RESET pattern that indicates you should use a context manager."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decorators\n",
    "\n",
    "Decorators are an extremely powerful concept in Python. They allow you to modify the behavior of a function without changing the code of the function itself. This chapter will lay the foundational concepts needed to thoroughly understand decorators (functions as objects, scope, and closures), and give you a good introduction into how decorators are used and defined. This deep dive into Python internals will set you up to be a superstar Pythonista.\n",
    "\n",
    "- Functions are objects. this means they can be manipulated like mutables; they can be renamed, passed into lists, dictionaries etc. Remember we only use () after a function to \"instantiate/execute\" it. But we can also store a function inside a varible.\n",
    "\n",
    "```\n",
    "def my_func():\n",
    "    print('func')\n",
    "    \n",
    "x = my_func\n",
    "```\n",
    "\n",
    "- We can also pass functions as arguments of other functions.\n",
    "\n",
    "- Functions can also be inserted inside other functions (nested/child/inner functions).\n",
    "\n",
    "- Functions can also return function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a command line data app\n",
    "You are building a command line tool that lets a user interactively explore a data set. We've defined four functions: mean(), std(), minimum(), and maximum() that users can call to analyze their data. Help finish this section of the code so that your users can call any of these functions by typing the function name at the input prompt.\n",
    "\n",
    "Note: The function get_user_input() in this exercise is a mock version of asking the user to enter a command. It randomly returns one of the four function names. In real life, you would ask for input and wait until the user entered a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Add the missing function references to the function map\n",
    "# function_map = {\n",
    "#   'mean': mean,\n",
    "#   'std': std,\n",
    "#   'minimum': minimum,\n",
    "#   'maximum': maximum\n",
    "# }\n",
    "\n",
    "# data = load_data()\n",
    "# print(data)\n",
    "\n",
    "# func_name = get_user_input()\n",
    "\n",
    "# # Call the chosen function and pass \"data\" as an argument\n",
    "# function_map[func_name](data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By adding the functions to a dictionary, you can select the function based on the user's input. You could have also used a series of if/else statements, but putting them in a dictionary like this is much easier to read and maintain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reviewing your co-worker's code\n",
    "Your co-worker is asking you to review some code that they've written and give them some tips on how to get it ready for production. You know that having a docstring is considered best practice for maintainable, reusable functions, so as a sanity check you decide to run this has_docstring() function on all of their functions.\n",
    "\n",
    "```\n",
    "def has_docstring(func):\n",
    "  \"\"\"Check to see if the function \n",
    "  `func` has a docstring.\n",
    "\n",
    "  Args:\n",
    "    func (callable): A function.\n",
    "\n",
    "  Returns:\n",
    "    bool\n",
    "  \"\"\"\n",
    "  return func.__doc__ is not None\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Call has_docstring() on the load_and_plot_data() function\n",
    "# ok = has_docstring(load_and_plot_data)\n",
    "\n",
    "# if not ok:\n",
    "#   print(\"load_and_plot_data() doesn't have a docstring!\")\n",
    "# else:\n",
    "#   print(\"load_and_plot_data() looks ok\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Call has_docstring() on the as_2D() function\n",
    "# ok = has_docstring(as_2D)\n",
    "\n",
    "# if not ok:\n",
    "#   print(\"as_2D() doesn't have a docstring!\")\n",
    "# else:\n",
    "#   print(\"as_2D() looks ok\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " You have discovered that your co-worker forgot to write a docstring for log_product(). You have learned enough about best practices to tell them how to fix it.\n",
    "\n",
    "To pass a function as an argument to another function, you had to determine which one you were calling and which one you were referencing. Keeping those straight will be important as we dig deeper into this chapter. From the function names can you think of any other advice you might give your co-worker about their functions?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Returning functions for a math game\n",
    "You are building an educational math game where the player enters a math term, and your program returns a function that matches that term. For instance, if the user types \"add\", your program returns a function that adds two numbers. So far you've only implemented the \"add\" function. Now you want to include a \"subtract\" function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_math_function(func_name):\n",
    "  if func_name == 'add':\n",
    "    def add(a, b):\n",
    "      return a + b\n",
    "    return add\n",
    "  elif func_name == 'subtract':\n",
    "    # Define the subtract() function\n",
    "    def subtract(a, b):\n",
    "      return a - b\n",
    "    return subtract\n",
    "  else:\n",
    "    print(\"I don't know that one\")\n",
    "    \n",
    "add = create_math_function('add')\n",
    "print('5 + 2 = {}'.format(add(5, 2)))\n",
    "\n",
    "subtract = create_math_function('subtract')\n",
    "print('5 - 2 = {}'.format(subtract(5, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you've implemented the subtract() function, you can keep going to include multiply() and divide(). I predict this game is going to be even bigger than Fortnite!\n",
    "\n",
    "Notice how we assign the return value from create_math_function() to the add and subtract variables in the script. Since create_math_function() returns a function, we can then call those variables as functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scope\n",
    "\n",
    "Remember that Python allows the mutation of objects & variables.\n",
    "So when we create/call variables inside functions or even functions inside functions which are already defined, how do Python know which variables/function to consider ?\n",
    "\n",
    "Python will start examining all available variables/functions already existing inside :\n",
    "- the local scope (inside the function itself); if python doesn't find anything it then looks in \n",
    "- the non-local scope (outside the function, but inside another function); if python doesn't find anything it then looks in \n",
    "- the global scope (in the global working environment/session in memory/project folder etc); if python doesn't find anything it then looks in \n",
    "- the built-ins (in the modules, packages and built-ins functions & variables); etc\n",
    "\n",
    "This is called scoping.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"C:/Users/T0230575/Desktop/Datalab LAS/Documentation/Method/scope.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Global keyword \n",
    "\n",
    "Explicitly specify we target the function/variable inside the global scope.\n",
    "Should avoid, because it makes testing & debugging harder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 20\n",
    "\n",
    "def func():\n",
    "    global x\n",
    "    x = 40\n",
    "    print(\"Hello this\", x)\n",
    "    \n",
    "func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Non local keyword\n",
    "\n",
    "Non local variables : variables defined in the parent function that are used by the child function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func():\n",
    "    x = 10\n",
    "    \n",
    "    def func2():\n",
    "        nonlocal x\n",
    "        x = 200\n",
    "        print(\"Hello this\", x)\n",
    "        \n",
    "    func2()\n",
    "    print(x)\n",
    "    \n",
    "func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Below is a good illustration of mutable function as objects in Python and usage of global"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 50\n",
    "\n",
    "def one():\n",
    "  x = 10\n",
    "\n",
    "def two():\n",
    "  global x\n",
    "  x = 30\n",
    "\n",
    "def three():\n",
    "  x = 100\n",
    "  print(x)\n",
    "\n",
    "for func in [one, two, three]:\n",
    "  func()\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "one() doesn't change the global x, so the first print() statement prints 50.\n",
    "\n",
    "two() does change the global x so the second print() statement prints 30.\n",
    "\n",
    "The print() statement inside the function three() is referencing the x value that is local to three(), so it prints 100.\n",
    "\n",
    "But three() does not change the global x value so the last print() statement prints 30 again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "call_count = 0\n",
    "\n",
    "def my_function():\n",
    "  # Use a keyword that lets us update call_count \n",
    "  global call_count\n",
    "  call_count += 1\n",
    "  \n",
    "  print(\"You've called my_function() {} times!\".format(\n",
    "    call_count\n",
    "  ))\n",
    "  \n",
    "for _ in range(10):\n",
    "  my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying variables outside local scope\n",
    "Sometimes your functions will need to modify a variable that is outside of the local scope of that function. While it's generally not best practice to do so, it's still good to know-how in case you need to do it. Update these functions so they can modify variables that would usually be outside of their scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(path)\n",
    "print(os.getcwd())\n",
    "\n",
    "def read_files():\n",
    "  file_contents = None\n",
    "  \n",
    "  def save_contents(filename):\n",
    "    # Add a keyword that lets us modify file_contents\n",
    "    nonlocal file_contents\n",
    "    if file_contents is None:\n",
    "      file_contents = []\n",
    "    with open(filename) as fin:\n",
    "      file_contents.append(fin.read())\n",
    "      \n",
    "  for filename in ['bikes.csv', 'auto.csv']:\n",
    "    save_contents(filename)\n",
    "    \n",
    "  return file_contents\n",
    "\n",
    "print('\\n'.join(read_files()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def wait_until_done():\n",
    "#   def check_is_done():\n",
    "#     # Add a keyword so that wait_until_done() \n",
    "#     # doesn't run forever\n",
    "#     global done\n",
    "#     if random.random() < 0.1:\n",
    "#       done = True\n",
    "      \n",
    "#   while not done:\n",
    "#     check_is_done()\n",
    "\n",
    "# done = False\n",
    "# wait_until_done()\n",
    "\n",
    "# print('Work done? {}'.format(done))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By adding global done in check_is_done(), you ensure that the done being referenced is the one that was set to False before wait_until_done() was called. Without this keyword, wait_until_done() would loop forever because the done = True in check_is_done() would only be changing a variable that is local to check_is_done(). Understanding what scope your variables are in will help you debug tricky situations like this one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Closure\n",
    "\n",
    "A closure is a tuple of variables that are no longer in scope but that a function needs in order to run.\n",
    "Attaching non local variables to nested functions.\n",
    "\n",
    "It is any non local variables attached to a returned function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo():\n",
    "    x = 5\n",
    "    \n",
    "    def bar():\n",
    "        print(x)\n",
    "    return bar\n",
    "\n",
    "func = foo()\n",
    "func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 25\n",
    "\n",
    "def foo(value):\n",
    "    def bar():\n",
    "        print(value)\n",
    "    return bar\n",
    "\n",
    "my_func = foo(x)\n",
    "my_func\n",
    "del(x)\n",
    "my_func\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though we remove x, my_func still returns 25 because its been stored inside a closure. The value persists in the closure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"C:/Users/T0230575/Desktop/Datalab LAS/Documentation/Method/func3.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking for closure\n",
    "You're teaching your niece how to program in Python, and she is working on returning nested functions. She thinks she has written the code correctly, but she is worried that the returned function won't have the necessary information when called. Show her that all of the nonlocal variables she needs are in the new function's closure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_a_func(arg1, arg2):\n",
    "  def new_func():\n",
    "    print('arg1 was {}'.format(arg1))\n",
    "    print('arg2 was {}'.format(arg2))\n",
    "  return new_func\n",
    "    \n",
    "my_func = return_a_func(2, 17)\n",
    "\n",
    "# Show that my_func()'s closure is not None\n",
    "print(my_func.__closure__ is not None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_a_func(arg1, arg2):\n",
    "  def new_func():\n",
    "    print('arg1 was {}'.format(arg1))\n",
    "    print('arg2 was {}'.format(arg2))\n",
    "  return new_func\n",
    "    \n",
    "my_func = return_a_func(2, 17)\n",
    "\n",
    "print(my_func.__closure__ is not None)\n",
    "\n",
    "# Show that there are two variables in the closure\n",
    "print(len(my_func.__closure__) == 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_a_func(arg1, arg2):\n",
    "  def new_func():\n",
    "    print('arg1 was {}'.format(arg1))\n",
    "    print('arg2 was {}'.format(arg2))\n",
    "  return new_func\n",
    "    \n",
    "my_func = return_a_func(2, 17)\n",
    "\n",
    "print(my_func.__closure__ is not None)\n",
    "print(len(my_func.__closure__) == 2)\n",
    "\n",
    "# Get the values of the variables in the closure\n",
    "closure_values = [\n",
    "  my_func.__closure__[i].cell_contents for i in range(2)\n",
    "]\n",
    "print(closure_values == [2, 17])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your niece is relieved to see that the values she passed to return_a_func() are still accessible to the new function she returned, even after the program has left the scope of return_a_func().\n",
    "\n",
    "Values get added to a function's closure in the order they are defined in the enclosing function (in this case, arg1 and then arg2), but only if they are used in the nested function. That is, if return_a_func() took a third argument (e.g., arg3) that wasn't used by new_func(), then it would not be captured in new_func()'s closure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Closures keep your values safe\n",
    "You are still helping your niece understand closures. You have written the function get_new_func() that returns a nested function. The nested function call_func() calls whatever function was passed to get_new_func(). You've also written my_special_function() which simply prints a message that states that you are executing my_special_function().\n",
    "\n",
    "You want to show your niece that no matter what you do to my_special_function() after passing it to get_new_func(), the new function still mimics the behavior of the original my_special_function() because it is in the new function's closure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_special_function():\n",
    "  print('You are running my_special_function()')\n",
    "  \n",
    "def get_new_func(func):\n",
    "  def call_func():\n",
    "    func()\n",
    "  return call_func\n",
    "\n",
    "new_func = get_new_func(my_special_function)\n",
    "\n",
    "# Redefine my_special_function() to just print \"hello\"\n",
    "def my_special_function():\n",
    "  print(\"hello\")\n",
    "\n",
    "new_func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_special_function():\n",
    "  print('You are running my_special_function()')\n",
    "  \n",
    "def get_new_func(func):\n",
    "  def call_func():\n",
    "    func()\n",
    "  return call_func\n",
    "\n",
    "new_func = get_new_func(my_special_function)\n",
    "\n",
    "# Delete my_special_function()\n",
    "del(my_special_function)\n",
    "\n",
    "new_func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_special_function():\n",
    "  print('You are running my_special_function()')\n",
    "  \n",
    "def get_new_func(func):\n",
    "  def call_func():\n",
    "    func()\n",
    "  return call_func\n",
    "\n",
    "# Overwrite `my_special_function` with the new function\n",
    "my_special_function = get_new_func(my_special_function)\n",
    "\n",
    "my_special_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your niece feels like she understands closures now. She has seen that you can modify, delete, or overwrite the values needed by the nested function, but the nested function can still access those values because they are stored safely in the function's closure. She even realized that you could run into memory issues if you wound up adding a very large array or object to the closure, and has resolved to keep her eye out for that sort of problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}