{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a795ba59-d48d-4f8d-934e-2cbc558071e4",
   "metadata": {},
   "source": [
    "# News: \n",
    "\n",
    "I enabled a `.ipynb` viewer at https://strawlab-rp2.zoologie.uni-freiburg.de/straw/pm21-dragon.\n",
    "\n",
    "# `exercise-04` review\n",
    "\n",
    "## Flow control Q3\n",
    "\n",
    "Now create a function called `simulate_generation` which takes two arguments, `a` and `Rt`. This function should return `None`. The first argument `a` will be a list with the number of infected individuals and `Rt` is the effective reproduction number, as before. The function should compute the number of newly infected individuals after one generation and append this to the list passed as the first argument.\n",
    "\n",
    "Your function signature should look like this:\n",
    "\n",
    "```python\n",
    "    def simulate_generation(a,Rt):\n",
    "```\n",
    "\n",
    "Here is an example that works:\n",
    "\n",
    "```python\n",
    "b = [1]\n",
    "simulate_generation(b,3)\n",
    "simulate_generation(b,3)\n",
    "simulate_generation(b,3)\n",
    "b\n",
    "```\n",
    "\n",
    "In this above example, `b` would be equal to `[1, 3, 9, 27]` at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5dbf80df-9df2-479b-bc33-fa5ee7465faa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_generation(a,Rt):\n",
    "    previous = a[-1]\n",
    "    new_infected = previous*Rt\n",
    "    a.append(new_infected)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "13f871cc-57bd-466b-ab2c-335097d45871",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 9, 27]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = [1]\n",
    "simulate_generation(b,3)\n",
    "simulate_generation(b,3)\n",
    "simulate_generation(b,3)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d4cbed4-d429-423c-9730-8eec2e7be271",
   "metadata": {},
   "source": [
    "## Flow control Q4\n",
    "\n",
    "Now create a function called `calculate_timeseries_to_1000` which takes one argument, `Rt`. This function should return a list containing the number of infected individuals after each cycle up to and including the first value over 1000 individuals.\n",
    "\n",
    "Your function signature should look like this:\n",
    "\n",
    "```python\n",
    "    def calculate_timeseries_to_1000(Rt):\n",
    "```\n",
    "\n",
    "Your code should work so that `calculate_timeseries_to_1000(2)` would return `[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]` and that `calculate_timeseries_to_1000(3)` would return `[1, 3, 9, 27, 81, 243, 729, 2187]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73d2d5a4-7697-4e91-9e0f-95f6ba36511b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here is an incorrect answer from someone:\n",
    "\n",
    "def calculate_timeseries_to_1000(Rt):\n",
    "    infected_series = [1]\n",
    "    while infected_series[-1] <1000:\n",
    "        # Again, this is not correct:\n",
    "        print(infected_series)\n",
    "        infected_series = infected_series * Rt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eba13625-66b6-4910-8cdc-67b8cba4e6e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's try to run it:\n",
    "\n",
    "calculate_timeseries_to_1000(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fa76fadc-1ab5-42b3-9884-7542d5df0cac",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_timeseries_to_1000(Rt):\n",
    "    a = [1]\n",
    "    while a[-1] < 1000:\n",
    "        simulate_generation(a,Rt)\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "56ea8eec-1128-4415-94ae-a1060cc2443c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculate_timeseries_to_1000(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2b32e617-dc56-4f32-8953-ce4c4a12dce8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 9, 27, 81, 243, 729, 2187]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculate_timeseries_to_1000(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ef5d53f-d007-4727-8852-5d430eb7fef7",
   "metadata": {},
   "source": [
    "* I check your answers based on file name. Please keep the files names exactly as specified, i.e. `my_name.py`.\n",
    "\n",
    "* Example answers:\n",
    "\n",
    "```python\n",
    "print(\"Paolo\")\n",
    "\n",
    "\n",
    "a = 1001\n",
    "b = 22\n",
    "def onethousandandone_times_twentytwo(a,b):\n",
    "    print(a*b)\n",
    "```\n",
    "\n",
    "vs\n",
    "\n",
    "```python\n",
    "# Create a Python script called `my_name.py` which does two things:\n",
    "\n",
    "# 1) prints your name\n",
    "\n",
    "print(\"Paolo\")\n",
    "\n",
    "# 2) computes the value of 1001 * 22 and then prints this\n",
    "\n",
    "result = 1001*22\n",
    "print(result)\n",
    "```\n",
    "\n",
    "vs\n",
    "\n",
    "```python\n",
    "print (\"Paolo\")\n",
    "value1 = 1001*22\n",
    "print (value1)\n",
    "```\n",
    "\n",
    "Correct answer should look like this:\n",
    "\n",
    "```\n",
    "astraw@computer$ python my_name.py\n",
    "Paolo\n",
    "22022\n",
    "astraw@computer$\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ba980f4b-8e46-41d7-940c-90910d939b81",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Andrew' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# What is wrong with this code?\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mAndrew\u001b[49m)\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;241m1001\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m22\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'Andrew' is not defined"
     ]
    }
   ],
   "source": [
    "# What is wrong with this code?\n",
    "print(Andrew)\n",
    "print(1001 * 22)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4df1eac5-e457-4d81-a1bf-fd151265ea9c",
   "metadata": {
    "tags": []
   },
   "source": [
    "# For loops, iterators, Dictionaries, more operators, files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e19d742e-a9b2-4583-baf7-f3277157beb6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# We run this for use below\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a1b23a3-eca2-475c-928d-74a9340c8948",
   "metadata": {},
   "source": [
    "## Control flow with `for` using `range` to produce an iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b083f041-81b4-4036-a074-777cca57b714",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5d9b3d49-bfb1-4710-ad2d-2017c8f53f57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for x in range(0, 10):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ecaeef4-1e00-4ca7-9577-c17c5ea99da9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1a9fa26d-b496-4027-8284-296eeb03c458",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "100\n",
      "200\n",
      "300\n",
      "400\n",
      "500\n",
      "600\n",
      "700\n",
      "800\n",
      "900\n"
     ]
    }
   ],
   "source": [
    "for y in range(0, 1000, 100):\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f255422b-b9f2-4cac-8416-e6e2873c0efd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myiter: range(0, 1000, 100)\n",
      "<class 'range'>\n",
      "0\n",
      "100\n",
      "200\n",
      "300\n",
      "400\n",
      "500\n",
      "600\n",
      "700\n",
      "800\n",
      "900\n"
     ]
    }
   ],
   "source": [
    "myiter = range(0, 1000, 100)\n",
    "print('myiter:', myiter)\n",
    "print(type(myiter))\n",
    "for y in myiter:\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d8cde809-3a7c-4d47-95e0-ae92f4fbc32f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for y in range(10):\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "618eae3e-271e-4aa9-b960-2406e66f5dff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for y in range(4,10):\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b1d9ce42-4b17-464b-890b-58fc3074451c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for y in range(4, 10, 2):\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce930921-7f89-40c3-8ae1-86fa4bf76950",
   "metadata": {},
   "source": [
    "Note the symmetry between `range()` and slices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "21919ffa-13fa-44bb-b1d9-263e176c497c",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7418236e-f87c-4caf-9ae8-6e4f50fcda59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "72a30f71-a29c-4b5e-b18d-828c85598502",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[4:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "84bcbdbf-4bc2-4099-ba18-3d1f88df47f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 6, 8]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[4:10:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f170ad1-3f66-4dce-b838-08e9e6962fe4",
   "metadata": {},
   "source": [
    "## Control flow with `for` using a list as an iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5e8ad5d5-8310-44f7-b3a3-03efedd846c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "end\n"
     ]
    }
   ],
   "source": [
    "my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "for y in my_list:\n",
    "    print(y)\n",
    "print(\"end\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "9d72823c-57da-443c-85b7-8beef3d785d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y: [5, 5, 6]\n",
      "5\n",
      "5\n",
      "6\n",
      "y: [6, 6, 7]\n",
      "6\n",
      "6\n",
      "7\n",
      "end\n"
     ]
    }
   ],
   "source": [
    "my_list = [[5,5,6], [6,6,7]]\n",
    "\n",
    "for y in my_list:\n",
    "    print('y:',y)\n",
    "    for z in y:\n",
    "        print(z)\n",
    "print(\"end\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8063e2bc-23a3-4364-bfa2-21d6da515555",
   "metadata": {},
   "source": [
    "# iterators\n",
    "\n",
    "We have seen now a couple examples of *iterators*.\n",
    "\n",
    "An iterator is not a type in Python but rather a behavior that some types have. Namely, you can iterate over them. This means you can use them as the source of data in a `for` loop. All items in the iterators do not need to be stored in memory at once, but rather they can be constructed one at a time.\n",
    "\n",
    "Iterators could run infinitely or they can end at a certain point.\n",
    "\n",
    "We can create a list from all values in an iterator in a couple different ways.\n",
    "\n",
    "The first you should be able to do by yourself already:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "04ae4602-76fe-4382-a9bc-946999dc9f49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = []\n",
    "for x in range(10):\n",
    "    my_list.append(x)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7784431a-461e-4d0c-b3eb-21ab73d8da44",
   "metadata": {},
   "source": [
    "The second approach of creating a list from all values in an iterator relies on the `list()` function, which is the *constructor* of a list. This constructor function will iterate over the iterator and create a list with its contents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "67b35f94-b268-488b-a8ee-c0cb12bc708c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = list(range(10))\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "fb690611-4886-47fd-810a-048487ffa4bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = []\n",
    "x = \"my super important data\"\n",
    "# Note that we overwrite x here!\n",
    "for x in range(2):\n",
    "    my_list.append(x)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0a7785b5-9a4d-438e-9cd6-b5fe38afa003",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c93a418-83fd-459f-a277-d28384d7a0cf",
   "metadata": {},
   "source": [
    "`continue` and `break` work in for loops, too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "13d2a909-7a05-43f6-92b9-f9c09e51563f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = []\n",
    "for x in range(100):\n",
    "    if x > 5:\n",
    "        if x < 10:\n",
    "            continue\n",
    "    if x >= 20:\n",
    "        break\n",
    "    my_list.append(x)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6545f21f-1f66-41ec-9573-eabd95b0f0e8",
   "metadata": {},
   "source": [
    "# Methods\n",
    "\n",
    "Methods are a way of giving a type specific additional functions. You already know a few of them, which so far we have just used without discussing much. This includes `list.append` and `str.format`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "09c591ee-a2a6-475c-bfbd-b2fa52a3accc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "my_list.append(10)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "82a767b3-d398-4f7e-b389-0b143511737c",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_str = \"Hello, my name is {}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "8c459558-d7ce-4459-9195-1d197a1a23b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, my name is {}'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "d987a1f3-4d33-405d-ac3e-2eb5b44f95c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, my name is Andrew'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_str.format(\"Andrew\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3dcd5aba-8877-4ca5-9725-445870073529",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, my name is {}'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_str"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d866caa5-8d01-4c36-9a0c-817cf5bb637f",
   "metadata": {},
   "source": [
    "Later, we will learn how to define our own methods. For now, it's just important that you know a method is like a function. Both can be *called* with input arguments, they return an output value, and they can have \"side effects\" -- changes to their inputs or something else."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e24fa7e-e8a7-42d9-9b74-7b82f18067b0",
   "metadata": {},
   "source": [
    "# Modules\n",
    "\n",
    "We have also used a number of modules without discussing this aspect much. There are built-in modules -- they come with Python as part of \"the standard library\" -- and there are modules which have to be installed separately. Matplotlib, for example, is a set of modules, (a \"library\") which we use a lot and which is not part of the Python language itself.\n",
    "\n",
    "Modules are a data type in Python like any other. They can have functions which have names like `module_name.function_name`. This is a very minor point, but the `.` makes a function in a module \"look like\" a method, but actually it is a normal function.\n",
    "\n",
    "Here we *import* the `random` module from the standard library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "cc64c0d3-8bee-4d5f-ace8-1fcd05b2ca85",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "39943249-daa9-49c3-bc95-d537ca76e025",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1,2,3,4,5,'asdf','dalkfj']\n",
    "random.choice(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "885b9d19-4d21-400a-81f4-669460baa6f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.choice(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f424016-3f5a-4d51-ac50-bfbc1971f42d",
   "metadata": {},
   "source": [
    "As mentioned, there are modules which are not part of the Python language itself. In fact there are approximately zillions of libraries for doing many, many different things, and this is one of the reasons Python is so useful and so popular. There can be a positive feedback loop between language popularity and the availability of libraries, and Python has benefitted a lot from this - especially in the data science area.\n",
    "\n",
    "One place that distributes many Python modules: [PyPI, the python package index](https://pypi.org/) another is [Anaconda](https://www.anaconda.com).\n",
    "\n",
    "As an example, let's return to our previous use of matplotlib. Check, for example the [matplotlib gallery](https://matplotlib.org/stable/gallery/index.html) for example plots. Here is a simple usage of matplotlib to draw a simple plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "09231cae-e75e-463d-8b9b-b2c873d482d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x117d65210>]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Below, we will use matplotlib, so we need to import it here.\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x=[1,2,3,4,5,6,7,8,9,10]\n",
    "y=[0,4,0,3,3,0,3,4,5,2]\n",
    "\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a417b0c-a52b-4a87-888e-322150bade72",
   "metadata": {},
   "source": [
    "To start with, there are a few simple things you can do to improve your plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "822633f1-a12b-4d5e-a577-937111d10914",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'y (unit 2)')"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGwCAYAAABcnuQpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACKCElEQVR4nO3dd3hTZfvA8W+S7k1LB4UCZe9RluyyQWQo4ABeXKAMBeT9qThxgrhFBBVfcW+QKXsjyCp7b0oHbSndOzm/Pw6tFFroSHqS5v5cVy89pycnd0ia3LnP89yPTlEUBSGEEEIIG6XXOgAhhBBCiPKQZEYIIYQQNk2SGSGEEELYNElmhBBCCGHTJJkRQgghhE2TZEYIIYQQNk2SGSGEEELYNAetA7A0k8lEdHQ0np6e6HQ6rcMRQgghRAkoikJqairBwcHo9bevvVT6ZCY6OpqQkBCtwxBCCCFEGURGRlKjRo3bHlPpkxlPT09A/cfw8vLSOBohhBBClERKSgohISEFn+O3U+mTmfxLS15eXpLMCCGEEDamJENEZACwEEIIIWyaJDNCCCGEsGmSzAghhBDCplX6MTMlZTQayc3N1ToMTTg6OmIwGLQOQwghhCgTu09mFEUhNjaWpKQkrUPRlI+PD0FBQdKLRwghhM2x+2QmP5EJCAjAzc3N7j7MFUUhIyODuLg4AKpVq6ZxREIIIUTp2HUyYzQaCxIZPz8/rcPRjKurKwBxcXEEBATIJSchhBA2xa4HAOePkXFzc9M4Eu3l/xvY67ghIYQQtsuuk5l89nZpqSjybyCEEMJWSTIjhBBCCJumaTKzdetWBg0aRHBwMDqdjiVLlhT6vaIovPbaawQHB+Pq6kp4eDhHjx7VJlghhBBCWCVNk5n09HRatmzJ3Llzi/z9u+++y4cffsjcuXPZs2cPQUFB9OnTh9TU1AqO9PaMJoWdZ6+y9EAUO89exWhStA5JCCGEsBuazmYaMGAAAwYMKPJ3iqLw8ccf89JLL3HfffcB8O233xIYGMhPP/3Ek08+WZGhFmv1kRheX36MmOSsgn3VvF2YMagJ/ZtpM805JiaG//73v+zbt4/Tp08zefJkPv74Y01iEUIIUYkpCpxeB/V6gV67mbBWO2bm/PnzxMbG0rdv34J9zs7OdO/enR07dhR7u+zsbFJSUgr9WMrqIzFM+CGiUCIDEJucxYQfIlh9JMZi93072dnZ+Pv789JLL9GyZUtNYhBCCFHJpcXBr6PhpxHwzzxNQ7HaZCY2NhaAwMDAQvsDAwMLfleUWbNm4e3tXfATEhJSqvtVFIWMnLw7/qRm5TJj2VGKuqCUv++1ZcdIzcot0fkUpeSXpr777jv8/PzIzs4utH/YsGGMGTOG2rVr88knnzBmzBi8vb1L9fiFEEKIOzqyGD7rACdWgN4BTHmahmP1TfNunjKsKMptpxG/8MILTJs2rWA7JSWlVAlNZq6RJq+uKX2gN1GA2JQsmr+2tkTHH3ujH25OJXs6RowYweTJk1m2bBkjRowAICEhgRUrVrB69eqyhiyEEELcXnoCrPwvHFuibgc2h6HzoFoLTcOy2spMUFAQwC1VmLi4uFuqNTdydnbGy8ur0E9l4+rqysiRI1m4cGHBvh9//JEaNWoQHh6uXWBCCCEqr2NL1WrMsSVqNab7dBi3UfNEBqy4MhMaGkpQUBDr1q2jdevWAOTk5LBlyxZmz55tsft1dTRw7I1+dzxu9/lEHlm4547HffNoO9qH+pbofktj3LhxtGvXjqioKKpXr87ChQt55JFHpPmdEEII80q/Cn/9HxxdrG4HNFWrMcGtNA3rRpomM2lpaZw5c6Zg+/z58xw4cABfX19q1qzJ1KlTmTlzJvXr16d+/frMnDkTNzc3Ro4cabGYdDpdiS73dK3vTzVvF2KTs4ocN6MDgrxd6FrfH4Pe/AlG69atadmyJd999x39+vXj8OHDLF++3Oz3I4QQwo4dXw4rnoH0eNAZoMsz0P05cHDWOrJCNE1m9u7dS48ePQq288e6PPzww3zzzTc899xzZGZmMnHiRK5du0aHDh1Yu3Ytnp6eWoVcwKDXMWNQEyb8EIEOCiU0+anLjEFNLJLI5Bs7diwfffQRUVFR9O7du9SDnYUQQogiZSTCqufh8G/qtn8jGDofqodpG1cxdEppptHYoJSUFLy9vUlOTr5l/ExWVhbnz58nNDQUFxeXMp1fyz4zKSkpVKtWjby8PL777jseeOCBgt8dOHAAUBOehg0b8uyzz+Lk5ESTJk2KPJc5/i2EEEJUAif+ghVTIe0K6PTQeQqEv1Dh1ZjbfX7fTJIZM3yAG00Ku88nEpeaRYCnC+1DfS1akbnRmDFjWLlyJdHR0Tg7//tCK2rsTK1atbhw4UKR55FkRggh7FzmNVg1HQ79om5XbaBWY2q01SSc0iQzVjsA2JYY9Do61vXT5L5jYmIYNWpUoUQGKFXfGiGEEHbu1BpYPgVSY9RqTMenoMdL4GgbX24lmbFRiYmJrF27lo0bNxa7tpUQQghxW5lJsOYlOPCDuu1XT63GhLTXNKzSkmTGRoWFhXHt2jVmz55Nw4YNtQ5HCCGErTm9HpY9DanRgA46ToKeL4Ojq9aRlZokMzaquLEvQgghxG1lJavVmP3fq9u+dWDIPKjVUdu4ykGSGSGEEMJenN0IS5+GlMuADjqMh16vgpOb1pGViyQzQgghRGWXnQprX4F915fBqVJbrcbU7qxpWOYiyYwQQghRmZ3brFZjki+p2+2fgN6vgZO7llGZlSQzQgghRGWUnQbrZ8Cer9Rtn5ow5DMI7aZtXBYgyYwQQghR2VzYDksmQtJFdbvt49DnDXD20DYuC5FkRgghhKgsctJh/euw+wt12zsEBn8KdXvc/nY2TpIZIYQQojK4uEOtxlw7r263eQT6vAkut18KoDKQZEYIIYSwZTkZsPFN+Gc+oIBXdbUaU6+X1pFVGL3WAYjSi4+PJygoiJkzZxbs27VrF05OTqxdu1bDyIQQQlSoS7vg8y7wzzxAgdajYeJOu0pkQCozt1IUyM2o+Pt1dIMiVrouir+/P19//TVDhw6lb9++NGrUiNGjRzNx4kT69u1r4UCFEEJoLjcTNr4FOz8DFPCsplZj6vfROjJNSDJzs9wMmBlc8ff7YnSp5vzffffdjBs3jlGjRtGuXTtcXFx45513LBigEEIIqxC5B5ZMgKun1e1Wo6DfTHD10TQsLUkyY8Pef/99mjVrxm+//cbevXtxcbGNpdqFEEKUQW4WbJ4JOz4FxQQeQTDoE2jYX+vINCfJzM0c3dQqiRb3W0rnzp0jOjoak8nExYsXadGihQUCE0IIobmoffDnBEg4qW63eAD6vwNuvtrGZSUkmbmZTmcTLZ5zcnIYNWoUDzzwAI0aNeLxxx/n8OHDBAYGah2aEEIIc8nLhs3vwN8fq9UY9wAY9DE0Gqh1ZFZFkhkb9dJLL5GcnMycOXPw8PBg1apVPP7446xYsULr0IQQQphD9H61GhN/XN1uPgIGvCvVmCLI1GwbtHnzZj7++GO+//57vLy80Ov1fP/992zfvp358+drHZ4QQojyyMtRZyot6KUmMm5V4f7vYdhXksgUQyozNig8PJzc3NxC+2rWrElSUpI2AQkhhDCPmINqF98rR9TtpvfC3e+De1Vt47JykswIIYQQWjPmwrYPYOt7YMoDNz8Y+IGazIg7kmRGCCGE0FLsYbVvTOxhdbvxYBj4IXj4axuXDZFkRgghhNCCMRe2fwxbZoMpF1yrqJeUmg0rcUd4oZJkRgghhKhoV47BkvHqGBmAhgPhno/AU9prlIUkM0IIIURFMebBjk9g0yy1GuPiA3e/p067lmpMmUkyI4QQQlSEuBPq2JjoCHW7wQC1AZ5nkKZhVQaSzAghhBCWZMyDnZ/CpplgzAEXb+g/G1o+KNUYM5FkRgghhLCU+FNqNSZqr7pdv6+6OKRXsLZxVTKSzAghhBDmZjLCP/Ngw5tgzAZnL+g/C1qNkmqMBUgyI4QQQphTwhlYOhEid6nbdXvB4DngXUPbuCoxWZvJDIwmI3ti9/DXub/YE7sHo8moaTyLFy+mT58++Pv74+XlRceOHVmzZo2mMQkhRKVnMsHOefB5ZzWRcfKEQXNg9CJJZCxMKjPltP7iet7Z/Q5XMq4U7At0C2R6++n0rtVbk5i2bt1Knz59mDlzJj4+PixcuJBBgwaxa9cuWrdurUlMQghRqV09C0ufgks71O064TB4LviEaBqWvZBkphzWX1zPtM3TUFAK7Y/LiGPa5ml8GP6hRRKa7777jmeeeYbo6GicnZ0L9g8bNgx3d3e+++67QsfPnDmTpUuXsnz5cklmhBDCnEwm2LMA1s2AvExw8oC+b0KbR2VsTAWSy0zFyMjNICM3A0X5N1HJNeaSkZtBjjEHo8nIO7vfuSWRAQr2vbP7HTJyM4o8r0kxlTm2ESNGYDQaWbZsWcG+hIQEVqxYwaOPPnrL8SaTidTUVHx9Zel4IYQwm8Tz8O0gWPWcmsiEdoMJO6DtY5LIVDBJZorR4acOdPipA9eyrxXsW3h0IR1+6sDMXTOJiIsodGnpZgoKVzKuMHnj5EL7+y/qT4efOnAu6VyZY3N1dWXkyJEsXLiwYN+PP/5IjRo1CA8Pv+X4Dz74gPT0dO6///4y36cQQojrTCbYvQDmd4aL28HRTV1T6T9LoUotraOzS3KZqYziM+JLdFy2Mdsi9z9u3DjatWtHVFQU1atXZ+HChTzyyCPobvo28PPPP/Paa6+xdOlSAgICLBKLEELYjWsXYdlTcH6rul2rCwyZC76h2sZl5ySZKcaukeqUOlcH14J9jzZ9lNGNR+Ogd+Bg/MESnWd8y/GFtlcPWw2Ai4NLueJr3bo1LVu25LvvvqNfv34cPnyY5cuXFzrm119/5fHHH+f333+nd29tBiMLIUSloCiwbyGsfQVy0sDBFfq8Du3GgV4ucmhNkpliuDm63bLP0eCIo8ERgLCAMALdAonLiCty3IwOHYFugdxV7a47nresxo4dy0cffURUVBS9e/cmJOTfUfM///wzjz32GD///DMDBw40230KIYTdSYpUqzHnNqvbNTvCkM/Ar66mYYl/STpZRga9gentpwNq4nKj/O3n2z+PQW+wWAyjRo0iKiqKBQsW8NhjjxXs//nnnxkzZgwffPABd911F7GxscTGxpKcnGyxWIQQotJRFNj3LczrqCYyDi7QbxY88pckMlZGkply6F2rNx+Gf0iAW+GxKIFugRabln0jLy8vhg0bhoeHB0OHDi3Y/8UXX5CXl8ekSZOoVq1awc+UKVMsGo8QQlQayVHwwzBYPhlyUiGkA4z/GzpOlMtKVkguM5VT71q96RHSg4i4COIz4vF38ycsIMyiFZkbxcTEMGrUqEL9ZjZv3lwh9y2EEJWOosCBH2H1C5CdAgZn6PUK3DURKuh9XZSeJDNmYNAbaBfUrkLvMzExkbVr17Jx40bmzp1bofcthBCVUko0LJ8Cp9eq29XbwtD54N9A27jEHUkyY6PCwsK4du0as2fPpmHDhlqHI4QQtktR4OAvsPp5yEoGgxP0eAk6PS3VGBshyYyNunDhgtYhCCGE7UuNheVT4dQqdTs4TK3GBDTSNCxROpLMCCGEsD+KAod/h7+ehawk0DtCjxeg0xQwyEejrZFnDAqtv2Sv5N9ACGE30uJgxTNwYoW6Xa2VWo0JbKJpWKLs7DqZcXRUG+BlZGTg6up6h6Mrt4wMdUHM/H8TIYSodBQFjixSqzGZiWo1pvvz0GUqGOS9z5bZdTJjMBjw8fEhLi4OADc3t1vWNqrsFEUhIyODuLg4fHx8MBhksJsQohJKi4eV0+D4MnU7qDkM/RyCmmkblzALu05mAIKCggAKEhp75ePjU/BvIYQQlcrRP2HlfyHjKugdoNuz0PW/Uo2pROw+mdHpdFSrVo2AgAByc3O1DkcTjo6OUpERQlQ+6Vfhr/+qyQxAQFO4dz5Ua6ltXMLs7D6ZyWcwGOQDXQghKovjy9VBvunxoDOolZhuz4KDk9aRCQuQZEYIIUTlkZGoDvA98oe67d9YrcYEt9Y2LmFRkswIIYSoHE6sVBvgpceBTg9dnlFnKzk43/GmwrZJMiOEEMK2ZV6DVdPh0C/qdtWGajWmehtt4xIVRpIZIYQQtuvkanVxyLRYtRrTaTKEvwCOLlpHJiqQXusAbicvL4+XX36Z0NBQXF1dqVOnDm+88QYmk0nr0IQQQmgpMwmWTISfH1ATGb/68Nha6PO6JDJ2yKorM7Nnz+bzzz/n22+/pWnTpuzdu5dHH30Ub29vpkyZonV4QgghtHB6HSybDKnRgA46PaWucu1o353c7ZlVJzM7d+5kyJAhDBw4EIDatWvz888/s3fv3mJvk52dTXZ2dsF2SkqKxeMUQghRAbKSYc1LsP97ddu3rrqmUs0O2sYlNGfVl5m6dOnChg0bOHXqFAAHDx5k+/bt3H333cXeZtasWXh7exf8hISEVFS4QgghLOXMBpjX8Xoio4O7JsH47ZLICAB0ihUvl6woCi+++CKzZ8/GYDBgNBp5++23eeGFF4q9TVGVmZCQEJKTk/Hy8qqIsIUQQphLVgqsfRkivlW3q4TC0HlQq5O2cQmLS0lJwdvbu0Sf31Z9menXX3/lhx9+4KeffqJp06YcOHCAqVOnEhwczMMPP1zkbZydnXF2lp4CQghh885thqVPQXKkut1hPPR6FZzcNQ1LWB+rTmaeffZZpk+fzoMPPghA8+bNuXjxIrNmzSo2mRFCCGHjstNg3auw93/qtk8tGPIZhHbVNi5htaw6mcnIyECvLzysx2AwyNRsIYSorM5vhaWTIOmSut1uHPR+DZw9NA1LWDerTmYGDRrE22+/Tc2aNWnatCn79+/nww8/5LHHHtM6NCGEEOaUkw7rX4PdX6rb3jVhyFyo013TsIRtsOoBwKmpqbzyyiv8+eefxMXFERwczEMPPcSrr76Kk1PJVj4tzQAiIYQQGrjwNyydCNcuqNttH4M+b4Czp6ZhCW2V5vPbqpMZc5BkRgghrFROBmx4A3Z9DijgVQOGfAp1e2odmbAClWY2kxBCiErq4k61GpN4Tt0OGwN93wYX+dIpSk+SGSGEEBUnNxM2vgU7P0OtxlSHwXOgXm+tIxM2TJIZIYQQFSNyNyyZAFfPqNutR0O/meDirW1cwuZJMiOEEMKycrNg09uwcy4oJvCsBoPmQIO+WkcmKglJZoQQQljO5b1qNSZBXWOPlg9B/1ngWkXbuESlIsmMEEII88vLhs2z4O9P1GqMRyAM+gQaDtA6MlEJSTIjhBDCvKIiYMlEiD+ubje/HwbMBjdfbeMSlZYkM0IIIcwjLxu2vAvbPwLFCO7+cM/H0PgerSMTlZwkM0IIIcov+oBajYk7qm43GwYD3gN3P03DEvZBkhkhhBBll5cD296HbR+AKQ/cqsI9H0KTIVpHJuyIJDNCCCHKJvYw/DkBrhxWt5sMhYEfgHtVTcMS9keSGSGEEKVjzIVtH8LWd9VqjKuvmsQ0u0/ryISdkmRGCCFEyV05Cn+Oh9hD6nbjQTDwQ/AI0DYuYdckmRFCCHFnxjz4+yPYPBtMuWrTu7vfVwf66nRaRyfsnCQzQgghbi/uuNrFN3q/ut1wINzzEXgGahuXENdJMiOEEKJoxjzY+SlsmgnGHHDxgQHvQov7pRojrIokM0IIIW4Vf1KtxkTtU7cb9Fcb4HlV0zQsIYoiyYwQQoh/mYzq6tYb3wZjNjh7w4B31AUipRojrJQkM0IIIVQJp9Uuvpd3q9v1+sDgOeAVrG1cQtyBJDNCCGHvTEbY9TlseAPyssDZC/rNhNajpRojbIIkM0IIYc+unlWrMZH/qNt1e8LgT8G7hrZxCVEKkswIIYQ9Mplg9xew/nXIywQnT+j3FoQ9LNUYYXMkmRFCCHuTeA6WPgUX/1a3Q7vDkLngU1PbuIQoI0lmhBDCXphMsPd/sO5VyM0AR3fo+ya0fUyqMcKmSTIjhBD24NoFtRpzYZu6XburWo2pUlvLqIQwC0lmhBCiMjOZYN/XsPZVyE0HRzfo8wa0fRz0eq2jE8IsJJkRQojKKumSWo05v0XdrtVZrcb41tE2LiHMTJIZIYSobBQFIr6FNS9DTio4uELv16D9E1KNEZWSJDNCCFGZJF+GZU/D2Y3qdshdMHQe+NXVNi4hLEiSGSGEqAwUBfZ/D2teguwUcHCBXq9Ch/GgN2gdnRAWJcmMEELYuuQoWD4ZzqxXt2u0V6sxVetrG5cQFUSSGSGEsFWKAgd/hlXTITsZDM7Q82XoOEmqMcKuSDIjhBC2KCUGlk+B02vU7eptYOh88G+obVxCaECSGSGEsCWKAod+hVXPQVYyGJygx4vQ8WkwyFu6sE/yyhdCCFuRegVWTIWTf6nbwa3VakxAY03DEkJrkswIIYS1UxQ4sgj++j/IvAZ6RwifDp2nSjVGCCSZEUII65YWByuegRMr1O1qLdVqTGBTbeMSwopIMiOEENbqyGJY+V/ITAS9A3R/Hro8AwZHrSMTwqpIMiOEENYmPUFNYo4tUbcDm6t9Y6q10DQsIayVJDNCCGFNji2FFdMgI0GtxnT9P+j6X3Bw0joyIayWJDNCCGEN0q+qA3yPLla3A5qq1ZjgVpqGJYQtkGRGCCG0dnyFOuU6PR50Bug6Dbo9J9UYIUpIkhkhhNBKRiKseh4O/6Zu+zdSZypVD9M2LiFsjCQzQgihhRN/qdWYtCug06s9Y8Kng4Oz1pEJYXMkmRFCiIqUeU1dGPLQL+p21QYw9HOo0UbbuISwYZLMCCFERTm1Rl0cMjVGrcZ0fAp6vASOLlpHJoRNk2RGCCEsLTMJ1rwEB35Qt/3qqWNjQtprGpYQlYUkM0IIYUmn18OypyE1GtBBx0nQ82VwdNU6MiEqDUlmhBDCErKS1WrM/u/Vbd86MGQe1OqobVxCVEKSzAghhLmd3QhLn4aUy4AOOoyHXq+Ck5vWkQlRKUkyI4QQ5pKdCmtfgX0L1e0qtdVqTO3OmoYlRGUnyYwQQpjDuc1qNSb5krrd/gno/Ro4uWsZlRB2QZIZIYQoj+w0WD8D9nylbvvUhCGfQWg3beMSwo5IMiOEEGV1fhssnQRJF9Xtto9DnzfA2UPbuISwM5LMCCFEaeWkw/rXYfcX6rZ3CAyZC3XCNQ1LCHslyYwQQpTGxR2wZCJcO69ut3kE+rwJLl6ahiWEPdNrHcCdREVFMXr0aPz8/HBzc6NVq1bs27dP67CEEPYmJwNWvwAL71YTGa8aMHoxDPpEEhkhNGbVlZlr167RuXNnevTowapVqwgICODs2bP4+PhoHZoQwp5c2gVLJkDiWXW79X+g39vg4q1tXEIIwMqTmdmzZxMSEsLChQsL9tWuXfu2t8nOziY7O7tgOyUlxVLhCSEqu9xM2PgW7PwMUMCzGgz+FOr30ToyIcQNrPoy07Jly2jbti0jRowgICCA1q1bs2DBgtveZtasWXh7exf8hISEVFC0QohKJXIPfN4Vds4FFGg1Cib+I4mMEFZIpyiKonUQxXFxcQFg2rRpjBgxgt27dzN16lS++OILxowZU+RtiqrMhISEkJycjJeXXNcWQtxBbhZsngk7PgXFBB5BMHgONOindWRC2JWUlBS8vb1L9Plt1cmMk5MTbdu2ZceOHQX7Jk+ezJ49e9i5c2eJzlGafwwhhJ2L2gd/ToCEk+p2iwdhwDvgWkXbuISwQ6X5/Lbqy0zVqlWjSZMmhfY1btyYS5cuaRSREKJSystW+8Z81VtNZNwD4MGf4b4vJJERwgZY9QDgzp07c/LkyUL7Tp06Ra1atTSKSAhR6URFqH1j4o+r281HwIB3wc1X27iEECVW6mQmOzub3bt3c+HCBTIyMvD396d169aEhoaaPbhnnnmGTp06MXPmTO6//352797Nl19+yZdffmn2+xJC2Jm8HNj6Lmz7EBQjuPvDPR9B40FaRyaEKKUSj5nZsWMHn376KUuWLCEnJwcfHx9cXV1JTEwkOzubOnXq8MQTTzB+/Hg8PT3NFuCKFSt44YUXOH36NKGhoUybNo1x48aV+PYyZkYIcYuYg2o15soRdbvpfXD3++Dup21cQogCZh8APGTIEPbs2cPIkSMZPHgwbdu2xc3NreD3586dY9u2bfz8888cPHiQ7777jj59rGP6oiQzQogCeTmw7QPY9j6Y8sDNDwZ+AE3v1ToyIcRNSvP5XaLLTH379uX333/HycmpyN/XqVOHOnXq8PDDD3P06FGio6NLH7UQQlhS7GG1i2/sYXW78WAY+CF4+GsblxCi3Kx6arY5SGVGCDtnzIXtH8GW2Wo1xtUXBr6vXlrS6bSOTghRDLNXZoQQwiZdOQZLxqtjZAAa3aMO8vUI0DYuIYRZlarPzMqVKxk7dizPPfccJ06cKPS7a9eu0bNnT7MGJ4QQZWLMg63vwxfd1ETGxQfu+woe+EESGSEqoRInMz/99BNDhgwhNjaWnTt30rp1a3788ceC3+fk5LBlyxaLBCmEECUWdwL+1xs2vgmmXGgwACbtghYj5LKSEJVUiS8zvf/++3z00Uc8/fTTAPzxxx88+uijZGVl8fjjj1ssQCGEKBFjHuz8FDbNBGMOuHirze9aPCBJjBCVXImTmVOnTnHPPfcUbA8fPpyqVasyePBgcnNzufdemdoohNBI/Cl1plLUXnW7fl8YNAe8qmkblxCiQpQ4mfHy8uLKlSuFOv2Gh4ezfPly7rnnHi5fvmyRAIUQolgmI+z8DDa+BcZscPaC/u9Aq5FSjRHCjpQ4mWnfvj2rVq3irrvuKrS/e/fuBQmNEEJUmIQzajXm8m51u15vtRrjXV3buIQQFa7EA4CfeeYZXFxcivxdeHg4K1asYMyYMWYLTAghipRfjfm8s5rIOHnC4E9h1B+SyAhhp6RpnhDCdlw9C0snwaWd6nadHmoi4xOibVxCCLOTpnlCiMrFZILdX8L61yAvE5w8oO9b0OYRGRsjhJBkRghh5RLPq9WYi3+r26HdYPBcqFJL27iEEFZDkhkhhHUymWDv/2Ddq5CbAY7u0PcNaPMY6EvVvFwIUclJMiOEsD7XLqrVmAvb1O3aXWHIXKhSW9OwhBDWqdRfbx577DFSU1Nv2Z+ens5jjz1mlqCEEHZKUWDP/2B+JzWRcXSDAe/BmGWSyAghilXq2UwGg4GYmBgCAgov1paQkEBQUBB5eXlmDbC8ZDaTEDYi6RIsexrObVa3a3aCoZ+Bbx1NwxJCaMMis5lSUlJQFAVFUUhNTS3Uc8ZoNPLXX3/dkuAIIcQdKQpEfAtrXoacVHBwhd4zoP2TMjZGCFEiJU5mfHx80Ol06HQ6GjRocMvvdTodr7/+ulmDE0JUcsmXYdlkOLtB3Q7pAEPng19dbeMSQtiUEiczmzZtQlEUevbsyaJFi/D19S34nZOTE7Vq1SI4ONgiQQohKhlFgf0/wJoXITsFHFyg5ytw1wTQG7SOTghhY0qczHTv3h2A8+fPU7NmTXTSqEoIURYp0Wo15sw6dbtGO7UaU7W+tnEJIWxWiZKZQ4cO0axZM/R6PcnJyRw+fLjYY1u0aGG24IQQlYiiwMGfYdV0yE4GgzP0fAk6PiXVGGFXjCaF3ecTiUvNIsDThfahvhj0UiAojxIlM61atSI2NpaAgABatWqFTqejqElQOp0Oo9Fo9iCFEDYuJQZWTIVTq9Xt4DC493Pwb6hpWEJUtNVHYnh9+TFikrMK9lXzdmHGoCb0b1ZNw8hsW4mSmfPnz+Pv71/w/0IIUSKKAod+g1XPQVYSGJwg/AXoNBkM0rNT2JfVR2KY8EMEN5cCYpOzmPBDBPNHh0lCU0YlejepVatWkf8vhBDFSr0CK56BkyvV7Wqt1LExgU00DUsILRhNCq8vP3ZLIgOgADrg9eXH6NMkSC45lUGZvhqdOnWKzZs3ExcXh8lkKvS7V1991SyBCSFslKLAkUXw1/9B5jXQO0L356HLVDA4ah2dEJrYfT6x0KWlmylATHIWu88n0rGuX8UFVkmUOplZsGABEyZMoGrVqgQFBRWa1aTT6SSZEcKepcXDymfg+HJ1O6iFWo0JaqZtXEJoLC61+ESmLMeJwkqdzLz11lu8/fbbPP/885aIRwhhq44sVqsxGVdB7wDdnoOu06QaIwSgL2E7kwBPlzsfJG5R6mTm2rVrjBgxwhKxCCFsUXoCrPwvHFuibgc2U6sx1aRNgxCKovDrnkjeXHHstsfpgCBvdZq2KL1SL3wyYsQI1q5da4lYhBC25thS+KyDmsjoDOrYmHGbJJERAohJzuThhXuYvvgw6TlG6vi7A2ricjMFmDGoiQz+LaNSV2bq1avHK6+8wj///EPz5s1xdCxcQp48ebLZghNCWKmMRPWS0pFF6nZAExg6D4JbaxuXEFZAURR+33eZN5cfIzU7DycHPc/2bchjXUJZdyz2lj4zANV9XOjbJEijiG2fTimq+91thIaGFn8ynY5z586VOyhzKs0S4kKIEjixEpZPhfQ4tRrT5Rno/hw4OGsdmRCai03O4oXFh9h0Mh6AViE+vD+iJfUCPAqOubEDsJuTgam/HCA9x8jno9vQv5kkNPlK8/ld6sqMNM0Twk5lJMKq5+Hwb+q2fyO1GlO9jbZxCWEFFEVhcUQUry8/SkpWHk4GPdP6NmBc1zq3XDoy6HWFpl8/2jmUuZvOMGfDafo1DZS1D8tAWnAKIe7s5CpYPgXSroBOr3bwDX8BHGXmhRBxKVm8+Odh1h+PA6BlDW/eH9GS+oGeJbr9411CWfj3eY7FpLDu2BX6NpXqTGmVOpl57LHHbvv7r7/+uszBCCGsTGYSrH4BDv6kbldtoM5UqtFW07CEsAaKorD0QDQzlh0lOTMXR4OOqb0b8GS3OjgYSj6/poq7Ew93qs28zWf5ZMNp+jSR6kxplWlq9o1yc3M5cuQISUlJ9OzZ02yBCSE0dmotLJ8MqTGADjo9BT1eAkdXrSMTQnPxqdm89Odh1h67AkDz6mo1pmFQyaoxNxvbtQ7f7rjA0egU1h+Po0+TQHOGW+mVOpn5888/b9lnMpmYOHEiderUMUtQQggNZSXD6hfhwA/qtm9dtRpTs4O2cQlhBRRFYfmhGGYsPcK1DLUaM7lnfcaH18WxFNWYm/m6OzGmU23mbz7LJxtO0btxgFRnSqHUs5mKc/LkScLDw4mJiTHH6cxGZjMJUQpn1sOyyZASBejgronQ82VwctM6MiE0l5CWzStLjrDqSCwATap58cH9LWlczTyfLYnpOXSZvZGMHCP/e7gtvRrbd3XGorOZinP27Fny8vLMdTohREXKSoG1L0PEt+q2bx0YMg9qddQ2LiGsxMpDMbyy9AiJ6Tk46HU81bMek3rUK1c15ma+7k78p2Mtvthyjo/Xn6ZnI6nOlFSpk5lp06YV2lYUhZiYGFauXMnDDz9stsCEEBXk7CZY9jQkR6rbHcZDr1fByV3buISwAonpObyy9AgrD6lXHRoFefLB/S1pGuxtkft7omsdvttxkcNRyWw6GUfPRvZdnSmpUicz+/fvL7St1+vx9/fngw8+uONMJyGEFclOhXWvwt7rMxCr1IYhn0HtLpqGJYS1WH0khpeXHCEhLQeDXsek8Lo81bM+Tg7mq8bczM/DmTEda/HF1nN8sv40PRpKdaYkSp3MbNq0yRJxCCEq0vmtsHQSJF1St9uNg96vgbPHbW8mhD24lp7DjGVHWXYwGoAGgR58MKIVzWtYphpzs3Hd6vDdzoscvJzM5lPx9GgYUCH3a8ukaZ4Q9iQ7Dda/BnsWqNs+NdVqTGg3TcMSwlqsPRrLi38eISEtG70OJoTXZXKv+jg7GCoshqoezoy+qyYLtp3nk/WnCW/gL9WZOyhRrax///7s2LHjjselpqYye/ZsPvvss3IHJoQwswvbYX6nfxOZto/BhB2SyAgBJGXk8MyvB3ji+30kpGVTP8CDPyd25tl+jSo0kcn3RLe6uDjqORCZxJZT8RV+/7amRJWZESNGcP/99+Pp6cngwYNp27YtwcHBuLi4cO3aNY4dO8b27dv566+/uOeee3jvvfcsHbcQoqRy0mHDG7Drc3XbOwQGfwp1e2gblxBWYsPxK7yw+DBxqWo15oludZnauz4ujhWfxOTz93RmdIdafLX9PJ9sOE13qc7cVon7zOTk5PDHH3/w66+/sm3bNpKSktQT6HQ0adKEfv36MW7cOBo2bGjJeEtN+swIu3ZxJyydCInXV7MPexj6vgUu8rcgRHJmLm8sP8aiiMsA1PF35/0RLQmrWUXjyFRxqVl0nb2J7DwT3z3Wnm4N/LUOqUKV5vO7zE3zkpOTyczMxM/PD0dHxzIFWhEkmRF2KScDNr4F/8wDFPCqDoPnQL3eWkcmhFXYdDKOFxYdJjYlC50OxnWtw7Q+DTStxhTljeXH+Prv87SpVYU/xne0q+pMhTTN8/b2xtu7YkZ2CyFKIXI3LJkAV8+o261HQ7+Z4CJ/r0KkZOXy1opj/LZXrcaEVnXn/REtaFPLV+PIija+ex1+3HWRfRevsf1MAl3r21d1pqRkNpMQlUVuJmx6G3Z+BooJPKvBoDnQoK/WkQlhFbaeiuf5RYeISVarMY91DuX/+jbE1cm6qjE3CvByYWSHmiz8+wKfrD9Nl3pV7ao6U1KSzAhRGVzeq1ZjEk6p2y0fgv6zwNU6rv0LoaXUrFxm/nWcn3erXa5r+bnx3vCWtA+1zmrMzcZ3r8uPuy6x9+I1dpy9Sud6VbUOyepIMiOELcvNgs2zYMcctRrjEQiDPoGGA7SOTAirsP10As8vOkRUUiYAj3SqzXP9G+LmZDsff4FeLoxsX5NvdqjVmU51/aQ6cxPbeTaFEIVF7YMlEyH+hLrd/H4YMBvcbOPbphCWlJadx6y/jvPjLrXLdU1fN94d3oK76vhpHFnZjO9el592XWL3hUR2nr1KJ6nOFFLqBSYeeeQRtm7daolYhBAlkZet9o35qo+ayLj7wwM/wrAFksgIAew4m0D/j7cWJDJjOtZi1ZSuNpvIAAR5u/BQ+xAAPt5wWuNorE+pk5nU1FT69u1L/fr1mTlzJlFRUZaISwhRlOgD8GU4bPsAFCM0GwYTd0Hje7SOTAjNZeTkMWPpEUYu2MXla5lU93Hlp7EdeGNIM9ydbf9CxPjwujgZ9Ow+r1ZnxL9KncwsWrSIqKgonnrqKX7//Xdq167NgAED+OOPP8jNzbVEjEKIvBzYNBMW9IS4Y+BWFe7/DoZ/De62+21TCHPZde4q/T/exrc7LwIwqkNN1jzTrVJdjqnm7coD7dTqzCcbTmkcjXUpc9O8fPv37+frr7/mq6++wsPDg9GjRzNx4kTq169vrhjLRZrm3Z7RpLD7fCJxqVkEeLrQPtQXg972BpYZTUYi4iKIz4jH382fsIAwDHrrnW5ZnCIfx5Wj6tiYK4fVg5oMhYEfgHvleZO2VpX6dWWTj+PW96vsPCPvrj7JNzsuABDs7cLs4S2suh9LeZ6P6KRMur+3iVyjwi9P3GXTl87upEKa5gHExMSwdu1a1q5di8Fg4O677+bo0aM0adKEd999l2eeeaY8p7/FrFmzePHFF5kyZQoff/yxWc9tj1YfieH15ceISc4q2FfN24UZg5rQv1k1DSMrnfUX1/PO7ne4knGlYF+gWyDT20+ndy3b6Xhb5OMwuDE95jK909PA1VdNYprdp2GU9qNSv65s8HEU9X7l5+6EXgfxaTkAPNguhJcGNsbTxXq70pf3+Qj2UaszP/xziU/Wn+auJypvMlMapa7M5ObmsmzZMhYuXMjatWtp0aIFY8eOZdSoUXh6egLwyy+/MGHCBK5du2a2QPfs2cP999+Pl5cXPXr0KHEyI5WZoq0+EsOEHyK4+cnPr8nMHx1mEwnN+ovrmbZ5GspNj0R3/ZF8GP6hTbxhF/s4rv95fuhUm96DvwaPAC3CszuV/nVlY4+juPerfD5ujnzyYGu6W/naReZ6PqKSMgm/Xp357cmONtMvp7RK8/ld6jEz1apVY9y4cdSqVYvdu3ezd+9exo8fX5DIAPTr1w8fH59SB16ctLQ0Ro0axYIFC6hSRZqAlZfRpPD68mNFvjHk73t9+TGMpnJdgbQ4o8nIO7vfueWNASjY9/aut/l438f8dvK3Qr//9cSvzImYw7nkcwX7LqVcYk7EHH48/mOhYxedWsSciDmcTDxZsC8mLYY5EXP49ui3hY5ddnYZcyLmcPTq0YJ98RnxzImYw1eHvyp07Krzq5gTMYeIKxHFPw6dDnQ6ZjtmY3STb2AV4U6vKwWF13e+jtFkLNi/4NAC5kTMISEzoWDfkYQjzImYw/Kzywud45sj3zAnYg6x6bEF+04mnmROxBz+PP1noWN/OPYDcyLmEJkaWbDvbNJZ5kTMKfY1fT75fMHjePuft2/79zF79+xCj8Ma3e79Kp+Lg54uVj42piTvVyV9Pqr7uDKirYyduVGpk5mPPvqI6OhoPvvsM1q1alXkMVWqVOH8+fPlja3ApEmTGDhwIL173zljzc7OJiUlpdCPKGz3+cRCpdqbKUBMcha7zydWXFBlEBEXUahUezMFhYTMBP535H8sPbu00O+Wnl3KgsMLiEz590MiKi2KBYcXsPj04kLHrjy/kgWHFxR8SABcybjCgsML+PXkr4WOXXNhDQsOL+BU4r9vMIlZiSw4vOCWJGnDpQ0sOLyANRfW3OFxQGxGLBFxEcUeI8znTq8rgKTspELPxw/Hf2DB4QUkZSUV7DuReIIFhxew9uLaQrf95eQvLDi8gPiM+IJ9Z5LOsODwAv46/1ehY/849QcLDi8gJi2mYN/FlIssOLyAZWeXFTp2yZkl6mv6euITERdBQlYCxVFQbOJ1daf3K4DYlOxK8X5VmudjYnhdHA06/j5zlT0XrPuxV4RSj5n5z3/+Y4k4ivXLL78QERHBnj17SnT8rFmzeP311y0clW2LS739G0Npj9PKjR8Gt9M5uDOdq3cutK9f7X609G9JdY/qBfuC3IMY3Xg0/m6FS9W9a/amYZWG1PKqVbCvqmtVRjcejY+zT6Fjw0PCqelZk7o+dQv2+Tj7MLrxaNwd3Qsd26V6F/xd/fFwcCvR4yjp4xXlU9J/5xuPG1Z/GJl5mXg7/7uYZz2feoxuPJp6PvUK3W5IvSGkZKfg5/pvpa22d21GNx5d6DUGcE/de7iaeZVA98CCfTU8azC68WiCPYILHds/tD+tAloR7B5c5sdhjezt/aqkx9Wo4sbwNiH8vFsdO/PD2A7lCc/mWfXE+8jISKZMmcLatWtxcXEp0W1eeOEFpk2bVrCdkpJCSEiIpUK0SQGeJfu3LOlxWrk56SjO480fp11Qu0L7Hm768C3HhXqH8nz752/ZP7LxyFv21fCsUeSxIxqMuGVfoHtgkccOrTcU4k+yZ+njfF6C8YolfbyifEr673zjcZPDJt/y+1YBrWgV0OqW/RNaTrhlX1O/pjT1a3rL/rHNx96yr0GVBkW+nm5+TZflcVib7DwjG47HlejYyvJ+VZrnY2J4XX7fG8n2Mwnsu5hotSt/V4RSX2aqSPv27SMuLo42bdrg4OCAg4MDW7ZsYc6cOTg4OGA03npt0dnZGS8vr0I/orD2ob5U8y7+D1+HOqvJ2geVtazaElcH12J/r0NHkFsQYQFhFRhVCZmM8Pcn8HlXwi4fJtBo4nYT4q32cVRCYQFhBLoFFgzKvJlVv65ucKfHAdb9ujoYmcQ9c7az7GD0bY+zlfersIAw/FyKH/dWltdViK8bw9vUAODj9fbdFdiqk5levXpx+PBhDhw4UPDTtm1bRo0axYEDBzAYbK9PgjUw6HW8PLDxbY+ZMaiJ1feb+fHEj2TmZRb5u/w38OfbP299/TQSTsPX/WDdq2DMxlCvD9M7zkCNuuh/89FNRlvf46ikDHoD09tPB7jl+bDq19VNbvc48vdZ4+PIzjPy/pqT3Dd/B6fj0qjq4cST3eugg1seRf62LbxfGfQG+tXuV+TvdOhQUAgPCUevK93H8qQe9XDQ69h2OoF9F803g9jWWHUy4+npSbNmzQr9uLu74+fnR7NmzbQOz6a5OqlvYDf//bs6GmxmWvaQekPoXL0zIxuNJNAtsNDvAt0CrW/aqckIO+bC513g8h5w9oLBc2HU7/RufD8fhn9IgFvhqddOBifcHNxo6NtQo6DtS3J2MtM2T6NhlYZFPh9W+bq6jd61ehf5OILcggoeRzn7pprVkahkBn/6N3M3ncFoUhjUMpi1z3TnhQGNmT86jKCbKspB3i42834F8EKHF5gaNhV/18KXkgLcAqjuUZ1fTv7CotOLSnXOEF837gtTx/59YsdrNpW7A3BFCw8Pp1WrVtJnppwm/riPvw7H8kin2vRrGsSeC4l8uO4Uzg469r7cx6qbTt1IURR0Op31dzi9elbt4hv5j7pdtycM/hS8axQ67ObHEeoVSp6SR5B7kAZB25+Xt7/M0rNLaezbmF/v+RWTYrLu11UJFff3sTd2L3P2z+HTnp8WGrxc0XLyTMzddIbPricxfu5OvDW0GQOaF05SKnPH8m+OfsN3x77jna7v0DG4Y6nOd+lqBj0+2IzRpPDnxE60rlk5WpiU5vPb5pKZ0pJk5lZJGTm0f3sDOUYTf03uSpNgLxRFoc9HWzkTl8a7w1pwfzvrHDRtUkycTDxJY7/bXyazGiYT7P4C1r8OeZng5An93oawMaAr/ZuwSTGVugwtSi42PZaXt7/MM22eoWnVWwfkViZ5pjyGLh3KxZSLjG48ushBxRXhaHQy//f7IY7HqG00BraoxhuDm+Ln4axJPOZ25toZPtj3Aa93ev2WCtmNTIqJpOwkfF3KNvbn2d8P8vu+y4Q39OebR9uXNVyrYtGmecL2LT8YTY7RRONqXjQJVl8gOp2OYWFqleCPfZe1DO+2/nf4fzy48kEWHlmodSh3lngOvhkIq6eriUxod5i4A9o8XKZE5ujVo4xYPoIz185YIFgB6vT8BX0XVPpEBsBB78DsbrO5r/59PN366Qq//1yjiU/Wn2bI3L85HpNCFTdH5o5szWcjwypNIqMoCjN2zmB71Hbe3/v+bY/V6/SFEpmM3IxS3ddTPeth0OvYfDKeA5FJZQnXpkkyY4f+iIgCYFhY9UL7721dHb0Odl9I5OLVdC1Cuy1FUYhKi8KkmG7p72JVTCbY9SXM7wyXdoCjOwz8EMYsBZ+aZT7t/APzOXXtFB/s+8CMwYrUnFSOXz1esK0rQ6Jpq5r6NeX1Tq/j5liyXkfmciI2haGf/c1H60+RZ1Lo3zSItc90554WwXe+sQ3R6XS83fltOlfvzPPtSl75Ohh/kKFLh7L0zNI7H3xdLT93hra6PnZmvf11BZZkxs6ciUvlYGQSDnodQ1sXTmaCvF3ocn2l2UXXEx5rotPpeK3Tayzst1Dt0WKNrl2A7wbDqmchNwNqd1WrMe0eL1M15kavdXqNYfWH8U7Xd8wTq0BRFF7b8Rqj/hp1S0dde7Tp0iZSc1Itdv48o4m5G08z6NPtHI1OwcfNkTkPtWb+6DD8PStHNeZmtb1r83nvzws1SbyTXTG7iEmP4ftj35dquYmnr1dnNp2M56CdVWckmbEzf+xTk5Twhv5ULaKUm1+tWRxxGZOVrM1087CutkFtre/bs8kEe76CeZ3gwjZwdIO734cxy6BKbbPcRVXXqrzW6TVNB2pWNjmmHPJMeSiKQm2v2lqHo6nPD37O5E2TeW3HaxaZ4XQyNpV75+3g/bWnyDUq9GkSyNpnujG4ZbD1/T2X04XkC4XWfSutsc3HMiVsCt/0/6ZUA85rV3VnSCu1ujXHzmY2STJjR4wmhT/3q+Nh8hst3axf0yA8nR24fC2T3Vay3sc3R7/hrX/eItuYrXUoRUu6BN8PhZX/hdx0qNUZJvwN7ceB3nJ/YjuidpTrDVOAs8GZj3t8zE8Df6KFfwutw9FUp+BOOOodCfEMwaSYzHbePKOJeZvPMOjT7RyOSsbb1ZGPH2jFl/9pY/Vde8siKy+LaVum8eCKB/k76u8ynUOv0zO2+Vg8nDxKfdune9ZHr4MNJ+I4dDmpTPdviySZsSPbzyRwJSUbHzdHejQqelS9i6OBe1qq0yGtYSBwbHosc/bP4deTv7Lp0iatwylMUWDvQpjXEc5vAQdX6D8bHl4BvnUsetdLzizhyfVP8n9b/o+sPOtek8Ya3Vh50Ol0tjM7zoJa+Lfgr/v+YmqbqWabfn4mLpVhn+/k3dUnyTGa6NUogLXPdGNo6+qVrhqTLysvC19nX1wdXGlQpYFZzrk5cjNrLqwp0bGhVd0Zcn3sjD1VZ6x6bSZhXouuJydDWgbj7FD8m9XwNjX4eXckfx2O4fXBTXF31u5lEuQexKc9P2VL5JZiu2dqIikSlj0N564nWDU7wpDPwK/u7W9nJl2qd8HPxY/W/q0r7YeCpSiKwgvbXyDYPZiJrSbioJe3wXw39jNSFIVcUy5OBqdSn8doUvhq2zk+WHeKnDwTni4OvDaoKfeFVd4kJp+Piw9f9PmCqLQos6x7tSNqB09vfBpXB1ca+zamptedJxE81bMeSw9Esf54HEeikmlWvfJfmpa/YjuRkpXLmqOxAAwr5hJTvrCaVQit6s75hHRWH4m94/GW1qV6F7pU76JpDAUUBfZ/D6tfhJxUcHCBXjOgw5NQgc3UqrpWZfGQxWXuSWHPDsQfYOW5lRh0BnrX6k0TvyZah2R1UnJSmPH3DJwMTrzT9Z1SJSBn49P4v98Psv9SEgA9Gvoz674Wt3TvrWzyTHkFibFBbyhR0lESHap1oH1QexpUaUA195J1Oq7r78HglsEsORDNJxtOs2BMW7PEYs3kMpOdWHkohuw8Ew0CPWh+hyxdp9Nx3/WZTositLnUtCVyCyk5KZrcd7GSo+DH4WpFJicVarSH8duh48QKTWTy3ZzIlLYvhb1qHdCa97q/x7PtnpVEphjnk8+zKXITay+u5WzS2RLdJr8ac/cn29h/KQlPZwfeHd6Crx9pV+kTmWxjNmNWjeHrI1+bdbwRqInR570/5/n2z+NoKHln9qd61keng3XHrnAkKtmsMVkjSWbsRP74l2FhNUr0Leu+NjXQ6WDH2atcvlaxH5KH4w8zdfNU7l9+PwmZCRV630VSFNj/ozo25sx6MDhDnzfhsdVQtb7W0ZGZl8krf7/CI6sfsd5B0lamf+3+jGo8SuswrFZL/5a8ctcr/DDgB+pVqXfH488npPPAFzt5a+VxsvNMdK1flTXPdOP+tiGV/rISwF/n/uJwwmG+OfINiVnmnzhxYxKjKAqRqZF3vE29AA8GtbCfmU1ymckOnE9IZ9/Fa+h1amO8kqju40rHOn7sOHuVPyOieLpXxX1o6/V6At0CaeLXBD+XkvdmsIiUGFg+BU5fH3xXvS0MnQ/+5hnYZw4p2SlsidxCck4yu2N207VGV61Dskp/nv6T/qH9cXVw1ToUmzCswbA7HmMyKXyz4wLvrjlBVq4JD2cHXh7YmAfa2UcSk29ovaEYFSNB7kFUda1qsfvJzMtkxo4ZbL28ld/u+e2Ol7Im96rH8kPRrD12hWPRKQUd3ysjqczYgcXXLxV1a+BPgFfJy73507cXRVyu0JV1m/o15fdBv/N6p9e1e0NUFDj4C8zroCYyBifo/To8tsaqEhmAQPdAZnebzVd9v5JEphhLzizh1R2vMvqv0eQac7UOx+bEpsfy9ZGvC+27eDWdB7/8hzdWHCMr10SXemo15sH2Ne0qkQH10vzwBsMtPrbPUe/IlfQrZOVlcTD+4B2PrxfgWdBVubJXZ6QyU8mZTAqLC5YvKN1A3v7NgnhlyREuXM1g38VrtK1t2cGmOcacgpkTnk6eFr2v20qNheVT4dQqdTu4tVqNCbDe6bulXWXX3lT3qE5V16r0q92vVOMOBKTnpvPgige5mnUVPxc/BtUZzPf/XOSdVSfIzDXi5mTgpYGNGWlnSUyOMYefT/zMyEYjK+w1lb+eVmx6LK0CWpXoNpN71mPFoWhWH43leEwKjatVzuqMVGYquX/OXSUqKRNPFwf6NAks1W3dnBy4u7k6et7SA4GPXT3GgMUD2Hp5q0Xv57YUBQ79Dp91UBMZvSP0fAUeX2/ViczNrmVd4/0975NjzNE6FKvRLqgdiwcvZmzzsVqHYnPcHd15qNFDNPZtTJBzI0Z+9Q8zlh0lM9dIxzp+rJnajVEdatlVIgPw0b6PeH/v+zy9qWIX6QxyDypxIgNQP9Cz4H28MldnJJmp5PIH/g5qGYyLY+ln3ORPy15xMIas3JKvEVJaXx3+iriMOBafXmyx+7ittDj4dTQsHgtZSVCtJTy5Bbr9Hxhsp4BpUkyMXTuWb499y5yIOVqHo7kbZ3hVcamCXidveWXxeLOxDPCbyaMLzvPPuURcHQ28OaQpP47tQIhvxS5SaS06VOuAt7M3DzV8SLMYEjITeGbTM3ccEDz5+symVUdiORFrZbNEzUT+siuxtOw8Vh1Re8sUt3zBnbSv7UuNKq6kZucV9KmxhHe6vsOTLZ7k9U6vW+w+iqQocGSRWo05sQL0DtDjJRi7AQKbVmwsZqDX6Xm69dOEeocyqO4grcPR1IpzKxi0ZBARVyK0DsWmXb6WwcML9/D6spNk5BhpH+rLT+Mb85+OtdHr7asac6PwkHBW3beK7iHdNYvhzZ1vsv7SembsmHHb4xoGeXJ3M7U68+mGMxURWoWTZKYS++twDJm5RupUdad1iE+ZzqHX6wrG2lhyeQMngxNPtX6qYhdRTIuH38bAH49BZiIENYcnNkP358CGx1WEh4SzaPAiGvo21DoUzZgUEz8c+4G4jDj+iflH63BskqIo/LTrEv0+2srfZ67i4qhnxqAmPNTzCk9sGs6Kcyu0DrHC5ZpySctJK9jWdGwfML39dNoEtuHlDi/f8dine6lT7P86EsPJWMutjK4VSWYqsfzlC4a1KVlvmeLkJzN/n0kgNtl86wCdTDzJkjNLzHa+Ujm6RJ2pdHyZWo3pPh3GblQTmkrAUf9vMhaTFkOuyb5m8Oh1er7u9zVTw6byZIsntQ7H5kQlZTLm6928+Odh0nOMtKtdhdVTuvFo51Ci06PIMmax/uJ6rcOscHMi5vDAigc4fvW41qEAUM2jGt/0/4Y6PndeC65RkBcDmgWhKDBnY+UbO2M7gwFEqUQmZrDrfCK6UvSWKU5NPzfah/qy+3wif+6PYkJ4+dcfysjN4P+2/B8XUi6QnptecQ3M0q/CX/8HR6+PzQloCvfOV8fIVEIbL23k5e0vM6zBMP7b9r9ah1Oh3BzdeLz541qHYVMUReG3vZG8ueI4adl5ODvoea5/Ix7pVBvD9UtK41uMp4ZHDbu7jJmem87aC2uJTo8mOj3aKhcnvZhyEUe9I8EewUX+fnKv+qw6Estfh2M4fSWV+oHaVpbMSSozlVT+7KPOdasS7FP+JmHDCy41RZql54yLgwuD6w6mukd1BoYOLPf5SuT4crUac3Qx6AzQ7Vn1slIlTWRA/XBKzU1lf9x+u+ivsu7iOrusGJhDTHImjyzcw/OLDpOWnUdYTR9WTenK411CCxIZUNvrD6k3xO4GU7s7uvPboN94o9Mb9KrZS+twbrE9ajv3L7+fZ7c+W2wltnE1L/o3za/OVK6xM/b1arQTJpNSkMyUdeDvze5uUQ1XRwNn49M5eLn863zodXrGtRjHn0P+xMfFp/wB3k5GIvzxuDpbKT0e/BvD2PXQ82VwKP2KwLakV61ezOkxh4X9F1b6/iqXUy/zyt+v8MzmZ9gcuVnrcGyGoij8vjeSvh9tZcupeJwc9Lx4dyN+H9+JOv4et72tSTGx4NACVl9YXUHRasvb2Zt769+rdRhFqu1VG4POgJPeifSc9GKPm3y9m/uKQ9Gcias8Y2fkMlMZGU1GIuIiiM+Ix9/Nn7CAMAwaLDZYlD0XEolMzMTD2YF+TYPMck4PZwf6Nwviz/1R/LEvklZlHFCckJmAr4tvwbc6i7eWP/GXuhxBehzo9NB5KoRPBwdny95vGRlNCrvPJxKXmkWApwvtQ30LfSsuix41e5gpupKzxOO4k0D3QO5vcD+HEg5ZzyrrVqK45+NKShYvLD7MxhNxALQK8eH9ES2pF3D7JCbf0jNLmbN/Du6O7rQNbGvRVv5a+frI1zT2bWz1jSlreNbg2wHfEuodWrB6d1GaBHvRt0kga49dYc6GM8x5qHUFRmk5ksyUwfqL63ln9ztcybhSsC/QLZDp7afTu1ZvDSNT5VdlBjavhquT+RKsYWE1+HN/FMsPxvDywCal7luTkZvB42seJ8g9iFldZ92y6rNZZV6DVdPh0C/qdtWGahffGm0sd5/ltPpIDK8vP0bMDYOsq3m7MGNQE/pfn1ZZHoqi8OvJX0nMSmRiq4nlPl9xLP04iuOod2Ra22nkmnJv+2Zub4p6PoK8XejfNJDFEVGkZOXhZNAzrW8DxnYJxcFQ8oL9oLqDWHNhDf1q99N+HTUL2BO7h4/2fYQOHX8O+ZO6PuUfL2hJ9asUXkPPpJiKvBw4uVd91h67wvJD0UzuVb/Eyas1k8tMpbT+4nqmbZ5WKJEBiMuIY9rmaZpfr8/IyWPloRjg34Z35tKxrh/B3i4kZ+ay4XhcqW9/7OoxotOiOXPNwtdqT66Gz+5SExmdHjpPgSe3Wn0iM+GHiEIfOACxyVlM+CGC1Udiyn0fB+IP8Paut5l/cD6H4w+X+3xFqYjHcbPI1MLjuG6cyWXvbvd8fLPjIilZebSo4c3KyV0Y371uqRIZUNvrz+89n3vr31spOwA3r9qc4Q2Gc3/D+60+kbmRoih8e/Rbnlj7BHmmvFt+36y6N32aBKIoMLeSzGySZKYUjCYj7+x+B4VbB8Dm75u9ezZGk+U65d7JmqOxpOcYqenrRrvaVcx6boNex71h6syosixv0DaoLT8N/IkPwj+wTFUmMwn+nAA/PwBpseBXHx5bC33eAMeSL7BZ0YwmhdeXHyviVUXBvteXH8NoKt/A69YBrRndeDTPtn2WZlWbletcRamox3Gjy6mXeWD5A/x3y38LdfsVt38+8nm6OPD7kx3LNavlxiQmx5jDsavHynwua+Pi4MKMjjN4scOLWodSKnEZcXx+8HN2xe5izYU1RR4z5frYmWUHozkbn1bkMbZEarGlEBEXcUtF5kYKCrEZsUTERdAuqF0FRvavRfv+XVTSEt+UhoXV4LNNZ9lyKr7g+ntp3FwGNZvT62DZZEiNBnTQcZI6wNfRwmNyzGD3+cRbvjnfSAFikrNo9cZaHEv5zflWYQB8vNj8FcRco4nUrFu/BebLfxy7zyfSsa55LkkcTjhMZl4mcRlxlX6Ac2nd6XUFkJqVR8SlJLM8HwmZCUzaMInIlEh+HfQrIZ4h5T6nVk5dO0WDKg0Ktm1t5lageyCvd3qdxKxE7g69u8hjmlX3pnfjANYfj2PuxjN89ECrig3SzCSZKYX4jHizHmdu0UmZ/H02AYD7wsrXW6Y4dfw9CKvpQ8SlJJbuj2Zct9s3a8rMy+SNnW8wseVEQrws8OaWlQxrXoL936vbvnXUsTE17zL/fVlIXGrJGhHeLlEoGyMGt/MYM+qZ+by3V9LHWxIDQgdQw6MGVV2ryuWlm5T039lcz4e3szeOekcMegOx6bE2m8zsjN7Jk+ue5N769/LqXa9azcSO0upbu+8dj5nSqwHrj8ex9EAUT/esd8fZa9ZMkplS8HfzN+tx5vbn/igUBe6q42vRxd+Gtwkh4lISf+y7zNiuobetAM2JmMOKcys4knCEJUOWmPeN4cwGWPY0pEQBOrhrgrrKtZNtLXxX0urW+8Nb0LKMs8hulmPM5s290zh27QAz2n1CC7+25T7nwcgk/u+PQ3c8rrTVvDtp7l85ujabW0n/nc31fDjqHXm/+/uAurKzrTp9TR1DokNns4nMzXJNuSw+tZjhDYYXekzNa3jTq1EAG07EMXfTGT68v5V2QZaTJDOlEBYQRqBbIHEZcUWOm9Ghw9vZG3dH9wqPTVGUgrWT8pcfsJSBLarx2vKjnLySytHoFJpVL349pYebPszxxOOMbznefG8MWSmw9mWI+FbdrlIbhsyD2p3Nc/4K1j7Ul2reLsVeEtChzj65N6yGGac3e9Koah3Op57E291olk6gdfw9+GDdKWKTs4ocp5H/ONqHlm+8VHRaNO/sfoeX73qZALeAcp2rMivp66q8z8eNbk5iFEWxuYHBY5qOoVnVZlbZ4bcsFEXhqQ1PsSN6BwlZCUxqNanQ76f0rs+GE3EsPRDN5J71qV214j+/zMG2LgRqzKA3ML39dEBNXG6kQ4eCQlZeFqNWjuJA3IEKjS3iUhLnE9JxczJwd3PLTX8F8HZ1pG+TQODOi08GuQexsN9C7qpmpss+5zbD/E7/JjLtn4QJO2w2kQF1YPXz/RsV+bv8V9mMQU3M3qdlevvp/D7od7O1EzDodcwY1ASA4iI1x+N4fefrbIrcxOs7K3iFdRtz4/NxM0u+rvIdTTjKQysfIjot2iLnt6SwwDDL98CqIDqdjsF1B+Pp6EnDKrcuPtuihg89GvpjNCl8asNdgSWZKaXetXrzYfiHt3wjDHQL5I1Ob9ApuBNN/JrQvGrFlr7zk4r+zYJwd7Z8wS2/s/DSA1Hk5JkK/S7bmM3JxJMF22b5ZpadBiumwXdDIDkSfGrCwyvg7nfByTa/Sdwo/9vzzR8sQd4uzB8dZpH+LC4OLtT0qlmwbVJMtzm6ZPo3q8b80WEEed966eKJbnXM8jheaP8C7YLa8UL7F8p9rsoutGrRYyAs+boCtRrw7p53OXr1KB/u+9Ai92FOe2L3MHnjZJKykrQOxSIG1hnIyvtWFvvFZUpvdbDzkgNRXLxafPdga6ZTzLHQjhVLSUnB29ub5ORkvLy8zHbe4joAK4pCem46Hk7qm4hJMbHy3EoGhA6wWCOvrFwj7d5eT2pWHj+N60Cnupbvwmk0KXSctYG41Gy++E+bQp2G39z5JovPLOaVu17hvvr3lf/Ozm+FpZMg6ZK63W4s9H4dnG13sNqN0rPz6PruJhLTc3hveAtqVHGr0M65AOeSzvHc1ud4vv3zZpmJd2PH2U0n4lhyIJom1bxYObmLzV12sGWTfopg5aEYBjQLZEzH0Ap9XV1Ovcz8g/N5rt1zeDsXfylaa3mmPO758x6i0qIY02QMz7Z7VuuQLC4jNwNng3OhS/+PLNzN5pPxjGhTg/dGWMd6daX5/JbKTBkZ9AbaBbXj7jp30y6oXcGLQqfTFSQyAL+f/J0Xt7/IuLXjzLJAY1HWHbtCalYe1X1cuSu0YrpwFuo5c8OlpjxTHlezrpJnyiPQLbB8d5KTDn89C98OUhMZ7xAYsxQGflBpEhmAH/65SGJ6DrX93Li3dXU61vVjSCv1vxWRyAD8ePxHTl47yXt73jPL69Sg1xU8jhmDmuLuZOBYTArrjhXf2uB2YtNjOZd0rtxx2ZPTV1L567DapHBK7wYV/rqq4VmDt7u8bdWJDKiN/z7u8TE9QnrcMp6kMjqZeJIHVjzAV4e/KrQ/v+/M4v1RXLpqez2bJJmxMC9nLzydPOldq7fFvpHmX2K6L6w6+gr68IN/V9LeeCKOq2nZgPrG8FH4R3w/4Hs6Vy/HOJYLf6tjY3Z/qW63eUQdG1MnvHxBW5mMnDy+3Kp+SE/qUa/UHVjN5b9t/8vwBsOZ13ue2V+nVdydeLhTbQA+2XC61MlSnimP57c+z4MrH2RL5BazxlaZzdl4BkWBAc2CaBRkvqp0We2I2kFseqzWYRSpkW8j5vScg5ujbc2ELIuT105yIeUCi04vKtRosnXNKnRroI6dmbvJ9roCSzJjYQNCB7Bs6DIeavRQwb7IlEizfcu8kpLFttNqXxtLz2K6Wf1AT1rW8CbPpLD0QFTBfp1OR6uAVmU7aU6GuqbSNwPh2gXwqgGjF8OgT8BF+zdkc/vhn4tcTc+h1vWqjFbcHN2Y0XGGxRYKHNu1Du5OBo5Gp7C+lEthZORl4GhwRK/TU8f79n2NhOr0lVRWHFIH3uavkqyl307+xpPrn+T5rc8X2V5fC0cTjtrk4OTyGlx3MNPbT+fXe369JXkrqM5ERBGZaFvVGUlmKkBV16oFHSSNJiMvbn+REctHsPbC2nKf+8/9UZgUaFuriiZT6vLXf/rq2Md8EvFJ+d6oLu6EzzvDrvmAAmFjYOIOqNfLPMFamcwco1VUZYpyIO6AWWfk+bo7MaagOnOqVNUZLycvvuj9Bd8P+N4yjRcroU+vV2X6NQ2kcTXtvwTcVe0uPBw9qF+lvlkGmpfXtaxrTN40meHLh1tsnTJrNqrxKKq43LrcTZtaVehavyp5JoXPNtnWzCbrefe0Exl5GXg4eeBocCz3+jiKohSMVxlu5kUlS2pQi2Cc3WJJdd7EV4e/KtsHYG6m2sV34QBIPAeewTBqEQz+FFys+3p7efy46yIJaTmE+LpqWpW52dbLW3lk9SP8d8t/uZZ1zWznHde1Dm5OBo5EpbDxxJ2rMzd+6Bn0BssthVHJnIlLY7kVVWUAanrVZMmQJbx818s4GZy0DodsYzZBbkH4ufjZ1AKSlrAndg+/nvi1YHtqb/U188e+yzZVnZFkpoJ5Onkyr9c8fhn4C8EewQX7jyQcKfU3lkOXkzkdl4azg567W1i2t0xxqrg70bNOKzIvj6Sp63DaBpWyk2zkbvi8C+ycCyjQahRM3An1zdP7xFpl5hj5fItalXmqRz0zrLlkPm0D2xLiGUKbwDZm/eDxdXfiPx1rAXceO2M0GXly3ZP87/D/rOKbvC2Zu/E0igJ9mgTSNNh6vgwEuheeEJCVZ75lLUoryD2Ib/p/w5d9vrSLcTLFOZF4grFrxzJr9ywOxavdu9vU8qVLPbU6M2+z7VRnrOcd1I7odDpqe9cu2D597TRjVo3h0dWPkpZT8tVL81eu7t8sCC8X7dalGRZWg7zUFpw51Zk8Ywk/eHKzYO0r8HU/uHoGPIJg5G8wdB64+lg0XmugVmWyqVHFlfsqeKzTnbg5uvH9gO+Z3XW22btZP9G1Dq6OBg5dTmbTyeKrM+svreefmH/44tAXVjto1BqdjU9j2UG1KjPFSqoyN8vIzeDl7S8zccNEjCZjhd53rim34P8dDY5U89DmS6C1aFilIQNCBzC47uBClc8p16szv++9zOVrtlGdkWTGClxKuYSj3hFPJ88Sf3hk5xkL3rQqeuBvvtUXVpORm0H3hv5U9XAiIS2bradLsMjm5X3wRVfYMQcUE7R8CCb9Aw36WT5oK5CVa+SLrdZZlcnn4+JTaFZTak6qWc7r5+HMmPzqzPriqzN9a/XltY6v8VrH1wpVMMXtzd14BpMCvRsH3naZES3FZ8az7uI69l3ZR0RcRIXdb3J2MvctvY/fTv5msTYZtkan0/FW57d4o/MbhToet6vtS+d6fterM2c1jLDkrO9d1A71qtWLxUMWM6PjjIIPkFxjLlFpUcXeZuPxOJIycgnycqFzPcs3ybvZ5sjNPLvlWUauHEmuKYshrdQxH7dd3iAvG9a/Bv/rDQmnwCMQHvwZ7v0cXG8djFZZ/bTrEvGp2VT3sb6qzM1yjbnM3j2b4cuGk5ydbJZzjuumVmcOXk5m86mik1+dTsewBsO4u87dZrlPe3AuPq1gVqG1VmUAannV4u0ub/NV36/M0qCxpH4/9TsXUi7w7dFvyTJqd4nL2tzczPViykVAXVEb4Pe9kUQlZVZ4XKUlyYyVqO5RvdBq218c+oJ7l97LkjNLijw+/xLTvWHVK6yx2o08HD3wd/WnY3BH3BzdCgYgrz8WR1JGzq03iIqAL7rD9o/UakzzETDxH2hkXx9WWblGPt+iftOZ1KMeTg7W/SeYbcxmy+UtRKdHszlys1nOWdXDmdF3qcso3FidMZqM/HLiF3KNube7uSjG3E1qVaZXowCa17DOqky+3rV6V2giA/BYs8f4v7b/x3vd36s06y6ZU54pjzd2vsHQJUM5GH+Q9qG+dKzjR65RYZ4NzGyy7ndSO2VSTByMP0hmXmaRf3TxqdlsOqlNb5l8bYPa8sfgP5jWZhoAjat50aSaFzlGE8sP3tC7IS8bNrwJX/WG+OPg7g8P/ADDvgI3863Wayt+3n2JuOtVGa1moJWGh5MH73d/n097fsqQekPMdt4nutXFxVHPgcgktlyvziw4vIC3d73NE+uekMsApXQ+IZ0l+69XZXpbb1WmKIlZiXx24DOLj5/R6/Q83PRhmvgVvfimvTPoDKTkpGBUjByMOwj8+1r6bW8k0VZenZFkxgrpdXq+6PMFn/X6jH61/x1HkpCZgKKoDeqMJoVWIT7UC6jYtv7ZxuyC//d18cXR8O/A4/wP5z8irl8eiz4AX/aAbe+DYoRmw2DiLmg8qCJDtho3VmUm9qhr9VWZfE38mhAeEm7Wc/p7OjO6Q+GZTY18G+Hl5MXQekNl/aZSyh8r07NRAC1q+GgdTonlmfJ4eNXDfH7wc/535H9mP39KTgrfHv22wgca2yKdTsdrHV9jQd8FjGk6BoC76vhxVx1fco0K86187IxtvJvaIb1OT7ca3Qq2s43ZPLbmMZ5Y9wS/RhwB/m1YV1G2Xd7GwMUD2XdlX5G/H9IqGAe9jmORCSSumAFf9YK4o+DmByO+heFfg3vFrB1ljX7dE8mVlGyCvV0Y0cY2m7+l5aTxzu53SMlJKfe5nuheB2cHPfsvJbHtdALhIeGsvHelWStA9uDi1XSW2MBYmaI46B0Y23wsod6hZk+YFUXhtR2v8f7e93l1x6tmPXdl5eHkQYdqHQrtyx878+ueSGKSrbc6I8mMjTiScISYtBhOXD3N6SvZOBn0DG5RcbM8FEXhq8NfcSXjSrGdi/08nBldO5WlTq/gu/djMOVBkyFqNabp0AqL1Rpl5RoLvtlMsIGxMsWZtnkaPx7/kTd3vlnucwV4ujCyfQjoswuqMz4uPuUP0s7M3XgGo0khvKE/LUN8tA6n1IbUG8Lvg36nQZUGZj2vTqejR0gPvJ29Cy0nI0omOTuZ/9vyf3h6x9A+1Jcco4nPrbg6Y5vvqHaoTWAb/hj8By2dnwKTG32aBOLt5liqvjTlodPpmN97PuNbjmda22m3HmDMhS3v8mrMRJroL5KEJ6ZhC+H+78DD/9bj7cxveyOJTcmimrcL97e1/rEyxZkcNpmanjUZ3WS0Wc7nU207HqFz2H/lCNvPJJjlnPbk4tV0Fu+3zarMjZwNzgX/fyX9itkaJQ6qO4g1w9aUu9u6Pfp0/6esubCGF7e/yOSe6ppoP++OJDbZOmeCSTJjQ4LdQ9h5VJ2lMLxNDfbE7qHvor78efrPCrl/N0c3JrWaVOiNB4ArR9VLSpveRq/ksYH29M56l23OXSskLmuXnfdvVWZieF2cHQwaR1R2zao2Y+nQpbT0b1nuc2Ubs1l9aSk6p6sYnKNv23dGFO2zTWpVpnsDf1rXtP32BhsubeDepffy9ZGvy3yO9Nz0Qt2Fzd340V5MDpvMXdXuYlbXWXSuF0C72lXU6swW66zOSDJjQzafjOdqeg7+ns50rV+V30/9TmpOKgfjD1rsPndG72T9xfVF/9KYB1vfU6dcxxwEFx+47yu2tf6IBLwL1o2yd7/tvUxMchZBXi7c3842x8rc6Ma+FPEZ8WWuDjobnPnlnl+Y1OK/6NLbs/fiNXacvWquMCu9yMQMFkfY5gym4iRlJZGam8r2qO1lGrSbP05m1F+jOJ983gIR2g8vJy8W9F1AU7+m6HQ6pvZWLwP+tPsSV1KsrzojyYwN+WNfJABDWwXjYNAzq8ssXmj/Av/X9v8Kjsk15prt221CZgLTt03nmc3PsPr86sK/jDuuNr/b+BaYcqHh3TBpF7QYwbDrg1vXHI0lJcu+e4Zk5xmZf71HwwQbr8rcbE/sHoYvH84bO98o82vO29mb8a0fYWT7O3cFFoV9tukMeSaFrvWrElYJqjIA99W/j9ldZ7Og7wIM+tL/rVzJuMLu2N2cSzpntiaPQlUnKJfmtTPJybPO6owkMzYiMT2nYKXh/FlMBr2BkY1H4uH07/Tsmbtn8vTGp4nPKMGyAnfg7ezNkHpDaFil4b8zDYx5auO7L7pB9H51Vet7v4QHfwLPIACaVfeiYaAn2XkmVh6KKXcctuz3vZeJTs4i0MuZBypBVeZGTgYnUrJTOJt8ltTcki938Pup39kRvaPQvvHd6+Jk0LP7QiI7pTpzR5GJGQXdtqdWkqoMqGPz7q5zN476sq01F+QexB+D/uCdbu/QKqCVeYOzYwfjDzJixQjSq3wF+ix+2nWJOCurzkgyYyOWHYgi16jQrLoXjYK8ijwmJi2GZWeWseXyFi6kXCj3fTrqHZnWZho/DvwRFwcXiD8JX/dVlyQw5kD9fupMpZYPwA19QXQ6HcPalGB5g0ouJ8/07wym7nVxcaw8VRmAlv4t+az3Z/x49494ORX9mrzZ0atHmfnPTMavG8+RhCMF+4O8XXiovZrsfbzhtEXirUzmbf63KtOmVuVsPqkoCr+c+IUfj/9Yqtv5u/kX6s8lyq+2V21cHVzxd/emeYgz2XkmPt9yTuuwCpFkxkYsun5tfPhtOv5W86jGr/f8ynPtnivUKry0MwNi02MLlfqddQ7w9yfweVeI2gfO3jBkHoz8FbyKXnV2aKvq6HWw7+I1ziekl+r+K4s/9l0mKimTAE9nHmxfU+twLKJTcCc10S2hut51ubf+vfSt3Zemfk0L/W58+PXqzHmpztzO5WsZ/L5X/ZJgyzOY7uTv6L95e9fbvL/nfc4mFX9ZQ1EUPtz7IQfiDlRccHbG29mbr/p+xfcDvufZXmofmh93XSQu1XqqM5LM2ICTsakcjkrG0aBj8PUFHYtTr0o9/tPkPwXbydnJDF8+nFXnV5VoLEJCZgIPrXyI/275rzqwM+E0fN0f1r0Kxmyo1xsm7oTWowpVY24W4OVC9wbqlOzFEfZXncnJM/HZ9bEy4ythVaYoK86t4M2db972debi4MKrHV/lna7v3NLlt5q3a8GluE82nLJorLZs3uaz5JkUOtfzo23tylmVAegc3Jl76tzDtLbTqONdp9jjVp1fxcKjCxm7diwJmTK931JqedXCyeBE1/pVaV3Th+y8PL60ouqMJDM2IH9RyZ6NAvB1dyrVbb879h2nr51m3oF55JruPBj3YNxBkrKTOJ90DsOer+DzLnB5Nzh5wuBPYdQf4H37hCpf/tiexRFRmEz2NahzUYRalfH3dGZkh8pZlbnRxZSLvLz9ZX479RtbLm8p8vc3unml3nwTwuviaNDxz7lE/jkn1ZmbRSVl8vtedSJAfmfWykqn0zGzy0z+0+Q/t13eoluNbvSv3Z/xLcdT1bVqBUZov9o3P41b6Fx+2H2K+NTsO9+gAhT9jiKsRp7RxJ/Xm2KVZVHJ8S3H46BzoFP1TjgZbk2EjCYjEXERxGfE4+/mT3hION93moXr5ndxPTBDPahODzWR8SndANbejQPxcnEgKimTf85dpVM9+3ijyTXaX1Wmllctnm79NNnGbLpW71rodZWWm8bMXTMZXHcwr9z1SqH1vG4W7OPK/W1D+HHXJT5Zf5q7nrDf5S+KMm/TGXKNCp3q+tE+tPJWZfLdmMTkmfI4FH8Io2IseL8KCwjDw8mDd7u9i4J9fWHSSnpuOutjv8fgEkeuxw6mLkmjYQ2o6RXEyJbhODlok1ZYdTIza9YsFi9ezIkTJ3B1daVTp07Mnj2bhg0bah1ahdl2OoH41Gx83Z0IbxhQ6ts76h2Z0GpCoX1rLqxh3cV1dKnehbn753Il40rB7wId3JkeG03v1GRw8oC+b0GbR257Sak4Lo4GBrUM5sddl/hj32W7SWYWR1zm8rVMqno4M8oOqjL5Hm/+OADrL67nnd3vFHpdAZxNOltsReZGE3vU47e9kew8d5Xd5xPt4kO7JKKTMvmtoCpTecfKFCU9N52RK0dyLrnwZY1At0Cmt59O71q90SGLk1YEDycP3uv2Hq9t/oqzvn9zyLSKQ5fU33140If/1J/Ms11HVHhcVn2ZacuWLUyaNIl//vmHdevWkZeXR9++fUlPt58BpX9cv8Q0pFWwWdbzyTHmMHv3bNZcWMMrf79yywdOXG4a0/y8WB/aRh0b0/bRMiUy+fJX0l51JJa07LxyxW4Lco0m5hZUZerYRVXmRusvrmfa5mm3vK4ADiUcYsOlDXc8R3UfV0a0lbEzN5u/+Sy5RoW76vjSoY59Vax2RO24JZEBta/MtM3Tim/sKSxiw6mznMvchs6h8IKzJn0S3559g/e2/V7hMVl1MrN69WoeeeQRmjZtSsuWLVm4cCGXLl1i376iV22ubJIzcll3VP1QKMslpqI4GZz4pOcnuBiKnoGi6HSg0zHbTY/Rq2RjY26nVYgPdfzdycw18tfhyt9z5s+IKCITM6nq4cSoDrW0DqdCGU1G3tn9TrHlfh06Zu+eXaLOrhOvj535+8xV9lxINHeoNicmOZNf99jHWJmbGU1GZu+ZfdtjSvq6EuWXk5fH96fnALd+z83f/v7UHHLyKvbLq1UnMzdLTlY7Ovr6Fl92zs7OJiUlpdCPrVp+KJoco4lGQZ40DS5ZH4+SyMrLIstY/JQ6BYjNuEJEXES570un0xUkYpV9eYMbqzJPdquLq5N9VWUi4iKKrMjkU1CIzYgt0euqRhW3gqreJ+ul78z8zWfJMZroEOpLx7r2VZUx5+tKlN9PBzejGJKKLdjrdKA4JPHTwc0VGpfNJDOKojBt2jS6dOlCs2bFr4A6a9YsvL29C35CQmy362p+w7nhbWrcdjR/acVnxJXwuPJ3EQa4L6w6Oh3sOp9IZGKGWc5pjZbsj+JSYgZ+7k6Must+xsrkK+nrpaTHTQyvh4Nex/YzCey7aL/VmdjkLH7Zfb0qU4m6/ZaUuV9XonwupcSa9ThzsZlk5qmnnuLQoUP8/PPPtz3uhRdeIDk5ueAnMjKygiI0r7PxaRyITMKg1zHkDr1lSiXpEv7bPinRof5u/ma5y2rernS5Pvh3USXtOZN3Q1XmiW51cHOy6rH1FlHS10tJjwvx/bc687EdV2c+36JWZdrX9qWjnY2VAfO/rkT51PQKMutx5mITyczTTz/NsmXL2LRpEzVq3H7siLOzM15eXoV+bFH+JZnwBv74ezqX/4SKAvu+gXmdCDu/i8A8Y7Fj/3XoCHILIiwgrPz3e13+h9KiiMuVsufMkgPRXLyaga+7E//paF9jZfKFBYQR6BZY7KySsryuJvVQqzPbTiew7+I1c4VqM66kZPHTbnWqyJTe9c1aobUVlnhdibIb2TIcndGH4npjKgro8nwY2TK8QuOy6mRGURSeeuopFi9ezMaNGwkNDdU6pAphNCkszl++oI0ZBv4mX4Yf7oPlUyAnFUPIXUzv8CLq20DhN4j87efbP1+mVWuL07dJEB7ODkQmZla6AZ15RhNzN6qVA3utyoC68On09tMBzPa6CvF1474wtTL5iR2u2TR/81ly8ky0q12FTnY2ViafJV5XouycHBz4T/3JALckNPnb/2kwucL7zVh1MjNp0iR++OEHfvrpJzw9PYmNjSU2NpbMzEytQ7OoHWcTiE3JwtvVkZ6NS99bpoCiQMT3MK8jnN0IDi7Q92149C96NxvNh+EfEuBW+PyBboF8GP4hvWv1LuejKMzVycA9LdR1nCrbpaZlB6O5kF+Vucs+qzL5etfqbfbX1VM96mPQ69h6Kp79l+ynOhOXksXP+VWZXg3ssiqTzxKvK1F2z3YdwcN1X0Vv8im0X2/04eG6r2rSZ0anlGTBHo0U98e7cOFCHnnkkRKdIyUlBW9vb5KTk23mktOUX/az9EA0/7mrFm8OLX6w822lRMOyyXBmnbpdox0MnQ9VCw8gvLkDcFhAmMW+4ey5kMiIz3fi7mRgz8u9K0UFI89oou9HWzmXkM5z/RsyMbye1iFZBXO/rp79/SC/77tMeEN/vnm0vRkjtV5vLD/G13+fp02tKvwxvqNdJzP5KvL9StxZTl4ePx3czKWUWIt0AC7N57dVf5pYcZ5lMSlZuaw5qo4CL9MlJkWBgz/DqumQnQwGZ+j5EnR8Cor4ozfoDYVW2LaktrWqUMvPjYtXM1hzNJZ7W5und46Wlh+K5lxCOj5ujozpWFvrcKyGuV9XT/Wsx+L9UWw+Gc+ByCRahfiY7dzWKC41ix93qetZTelln2NlilKR71fizpwcHHikjXVUxaz6MpM9+utQDFm5JuoFeNCihnfpbpwSAz8/CEsmqIlMcBiM3wadpxSZyFS0G3vO/FEJes4YTQqfblRnMI3rWgcPZ6v+bmDTavm5M/T6rL5P1lf+rsBfbDlHdp6J1jV96FrfPpYBEaI8JJmxMvnjSUrVW0ZR4OCvMO8uOLUaDE7QawY8vg78rWsdq3tbqx9IO85eJTrJtsc+rTgUzbl4tSrzcKfaWodT6T3dsx4GvY5NJ+M5GJmkdTgWE5+aXVCVmdrbvsfKCFFSksxYkQsJ6ey5cA297t8P/TtKvQK/jII/n4CsJKjWCp7YAl2ngcH6KgUhvm50rOOHolCwGrgtMpoU5lyfXTO2S6hUZSpA7aruDGkVDFDwb18Zfbn1LFm5JlqF+NBNqjJClIgkM1Zk8fWqTNf6/gR6Fb12UgFFgcN/wLwOcHIl6B2h58swdj0ENqmAaMtuWJt/LzXZ6rioFYeiORufjrerVGUq0tM966PXwYYTcRy+nKx1OGaXkJbN9/9cHytjp31lhCgLSWashMmksOh6b5lhdxr4mxYPv/0HFj0OmdcgqAU8sRm6PQsGR8sHW04DmgXh5mTgfEI6EZeStA6n1G4cKzO2SyieLtb/b15ZhFZ1L+iIXRlX1P5y6zmyck20rOFNeAPpaCtESUkyYyX+OX+VqKRMPF0c6NsksPgDjyxWqzHHl4PeAcJfhHEbIaiMU7g14O7swIBmas8ZWxwI/NfhGM7EpeHl4sDDnWtrHY7deapnPfQ6WH88jiNRlac6k5CWzfc7ZayMEGUhyYyVWLRPrcrc0yIYF8ciZh6lJ8BvD8Mfj0LGVQhsBuM2QfjzNlGNudmwNuq36xWHosnKNWocTcmZbhgr83iXOnhJVabC1fX3YHBLdexMZeoKvGDbOTJzjbSo4U14Q6nKCFEaksxYgfTsPFYdiQFgeJsiBv4eWwqfdYBjS0BngO7Pq4lMtRYVG6gZ3RXqR3UfV1Kz8lh77IrW4ZTYX0diOB2XhqeLA49IVUYzT/Wsj04H645dqRTVmas3VGWkr4wQpSfJjBVYdSSWjBwjoVXdCatZ5d9fZCTCH4/Bb2MgIwECmsC4DdDjRXBw0i5gM9DrdQy7vubOIhu51FS4KhOKt6tUZbRSL8CDQS0qz8ymBdvOk5FjpHl1b3o2KscSJkLYKUlmrED+h/mwsOr/fiM7sVKtxhxZpFZjuv6fOsg3uLV2gZpZ/kDnbafjuZKSpXE0d7b6aCynrqhVmUc728eip9Zscq966HSw9tgVjkWnaB1OmSWm5/DdzguAVGWEKCtJZjQWmZjBznNX0eng3rAaajVm0Tj4ZSSkx4F/Ixi7Dnq9Ag7OWodrVrX83GlXuwomG+g5c2NV5tHOUpWxBvUCPLmnElRnvtp2jowcI82qe9GrPAvLCmHHJJnRWP6HeKe6flS/slnt4nv4N9DpocszagO86m20DdKC8tefWmTlPWfWHI3lRGwqns4OPC5VGasxuadanVl9NJbjMbZXnbmWnsO3Oy4AMLmnVGWEKCtJZjSkKAqLIi7jRRqzdJ+p6yqlXYGqDdSlCHq/Bo53aJ5n4+5uXg0XRz2n49I4ZKVN0EwmpWDWzKOda+PtJlUZa1E/0JO7m6vT/G2xOvPV9nOk5xhpUs2LPrdrySCEuC1JZjS09+I1Qq/9zTrn56kZuQzQQafJ8ORWqNFW6/AqhKeLI/2aBgH/rktlbdYeu8KJ2FQ8nB14rItUZazN5J71AXUg/YlY26nOJGXk8O0O6fYrhDlIMqOVrGRYMolvnN4jUHcN/OrBY2ug75vg6Kp1dBUq/1LT0gPRZOdZV88ZRfl3rMwjnWrj42bbs8gqo4ZBngy8Xp35dMMZjaMpuf9tP09adh6Nq3ndvlGmEOKOJJnRwpn1mD67i3ZJf2FSdMQ0eRzGb4eaHbSOTBOd6lYlyMuF5MxcNh6P0zqcQtYeu8KxmBTcnQw8LlUZq/V0r3qA2gfoZGyqxtHcWVJGDt/8fQGAKb3qSVVGiHKSZKYiZaXAssnwwzD0qdGcNwXylMtbBA7/wO6qMTcy6HXcl99zxoouNRWqynSuTRV3qcpYq0ZBXgxoFoSiwJyN1j925uvt50nNzqNRkCd9mwRpHY4QNk+SmYpydhPM7wQR3wKw2uNeBuS8Q4N2fdHr5VtZfs+ZTSfjiU/N1jga1frjcRyNVqsyY7vU0ToccQeTe6ljZ/46HMPpK9ZbnUnOyGXh9arM5F715e9fCDOQZMbSslNh+VT4figkR0KV2lwdsZgJV0eQhTPDwu6wQradqOvvQeuaPhhNCksPaN9zRlGUglWZx3SSqowtaFzNi/5N86sz1jt25uu/1apMw0BP+jeVqowQ5iDJjCWd2wLzOsG+hep2+ydgwg5+iauFokCHUF9CfN20jdGK5Cd21rCS9objcRyJSsHNycC4rlKVsRX51ZkVh6I5E2d91ZnkzFy+/vs8IFUZIcxJkhlLyE6Dlf8H3w2G5EvgUxMeXg53v4fi6FYwLiT/0opQDWoRjJODnhOxqRyN1q7njFqVUcddjOlYG1+pytiMJsHqzCBFgU+tsDrzzd8XSM3Ko0GgBwOaSVVGCHORZMbcLmxXx8bsWaBut30cJuyE0G4A7I9M4lx8Oq6OhoJmX0Ll7eZY0DhMy+rMppNxHI5KxtXRwLiuMoPJ1uRXZ5YdjOZMXJrG0fwrJSuX/20/B8DTPaUqI4Q5STJjLjnpsOp5+GYgJF0E7xD4zxK450Nw9ig4LH9RyQHNgvBwdtAoWOs1/PqlpmUHosk1mir8/hVF4ZP1+VWZWvh5VK71sOxBs+re9LlenZlrRTObvvn7AilZedQP8JAvMkKYmSQz5nBxJ3zeBXZ9rm63eQQm7IC6PQodlpVrZPnBaEAuMRWna/2q+Hs6czU9h80n4yv8/jefjOfg5etVmW4yVsZWTbmhOnMuXvvqTGpWLv/bro6VebpXfQxSlRHCrCSZKY+cDFj9IiwcAInnwKsGjF4Mgz4BF69bDl9//AopWXkEe7vQsY6fBgFbPweDnntbqz1n/tgXWaH3rSgKH18fK/OfjrWoKlUZm9Wsuje9GwdgUmCuFYyd+XbHBZIzc6nr717QrVgIYT6SzJTVpV1qNeafzwAFWv8HJu6Aer2KvUn+Jab7wmrI9fLbyJ/VtPFEHInpORV2v1tOxXMwMgkXR73MYKoEpvRqAMCSA1GaVmdSs3JZsO3fGUxSlRHC/CSZKaujf0LiWfCsBqP+gCFzwcW72MPjUrLYckq9bCKXmG6vYZAnzat7k2tUWFZBPWdunME0ukMt/D2lKmPrmtfwpmej69WZTdpVZ77beZHkzFzq+LtzT4tgzeIQojKTZKaser0KnafAxH+gfp87Hr7kQBQmBdrUqkJoVfcKCNC2DStY3qBikpmtpxPYfykJZwc9T3SXqkxlkT92ZumBaC4kpFf4/adl57FgmzqDaXJPqcoIYSmSzJSVkxv0eQNcfe54qKIoBVONh0tVpkQGt6qOo0HH4ahkiy8cqM5gUrv9jr6rFgGeLha9P1FxWob40KOhP0aTokl15rudF0jKyKVOVXcGtZSqjBCWIslMBTgSlcKpK2k4O+gZ2EIG/5WEr7sTPRsFAJZffHL7mQQirldlnpSqTKUzpbc6dubP/VFcvFpx1Zn07DwWbFWrMk/1rCdVGSEsSJKZCpD/Ydy3aRBeLo4aR2M7hrcJAdQPoTwL9Zy5sa/MyA41pSpTCbUK8aF7g+vVmQqc2fTdzotcy8gltKo7g6UqI4RFSTJjYTl5poKFE+USU+mEN/THz92J+NRstp1OsMh9/H3mKnsvXsPJQc/47nUtch9Ce1N6q2NnFu+P4tLVDIvfX/oNY2We6lEPB4O81QphSfIXZmEbT8RxLSOXQC9nutSrqnU4NsXRoGdIq+s9ZyxwqenGlbFHtq9JoJdUZSqrsJpV6Ha9OvNZBYyd+eGfiySm51Dbz40hraQqI4SlSTJjYfkDf+9tXUOumZfBsDZqMrPu6BWSM3LNeu6dZ6+y54JalZkQLlWZyi5/ZtOiiMtEJlquOpORk8eX18fKTJKqjBAVQv7KLCghLZvNJ+MAGH79Q1mUTtNgbxpX8yLHaGL5oWiznffGbr8PtQuRqowdaFOrCl3rVyXPwtWZH/65yNX0HGr6uhV0sxZCWJYkMxa09EA0eSaFliE+1Avw1Docm5Xfc8acK2nvPHeV3ecTcTLoGS9VGbuRX535Y59lqjOZOcaCqsxTPaUqI0RFkb80C8pfvmB4mHw7K48hrapj0Os4EJnEWTO1pc+fwfRg+xCqebua5ZzC+rWt7UuXemp1Zt7ms2Y//4+7LpKQlkOIr6tUZYSoQJLMWMix6BSOxaTgZNBLs6xy8vd0pkdDf+DfBLE8/jl3lV3XqzIyVsb+5M9s+n1vJJevma86k5lj5PMtaoL0VI96OEpVRogKI39tFpLfW6Z3kwB83Jw0jsb25S8+uTgiCqNJKde58qsy97erIVUZO9Suti+d6vqZvTqTX5WpUcWV+8KkDYMQFUmSGQvINf7bW2aYvKmZRc/GAfi4ORKbksWOs2XvObPr3FV2nruKo0HHhPB6ZoxQ2JL8sTO/740kKimz3OfLyjXyxdZ/+8pIVUaIiiV/cRaw5WQ8CWk5VPVwplsDf63DqRScHQwFXVTLMxA4f2Xs+9uGUN1HqjL2qkMdPzrW8SPXqDB/c/lnNv206xLxqdlU95GqjBBakGTGAvIvMQ1tFSzf0Mwov4PymqOxpGSVvufMnguJ7DirVmUm9pCqjL3LHzvz655IostRncnKNTL/+liZST3q4eQgf/NCVDT5qzOza+k5rD9+BYBhsnyBWTWv7k39AA+yck38dSim1LfPHyszvI1UZQTcVcePDqG+16szZR878/Puf6sysmSJENqQZMbMlh+KJteo0DTYi8bVvLQOp1LR6XQFCWJpV9LeeyGR7WcScNDrmCgzmMR1U6+vqP3rnkhikktfncnK/XcG08QedaUqI4RG5C/PzPLHc8g3NMu4t3V19DrYc+EaFxLSS3y7/LEyI9rWIMTXzVLhCRvTsa4f7UN9yTGa+LwM1Zlf90RyJSWbYG8XRlxf5V0IUfEkmTGj01dSOXQ5GQe9rmCwqjCvQC8XutZXB1UvLmF1Zt/Fa2w7nV+VkbEyorCp12c2/bw7ktjkrBLfLivXyLzrg4cnyFgZITQlf31mlL+yc49GAfh5OGscTeU1vOBSUxSmEvScya/KDAuTqoy4Vce6frSrXUWtzmwpeXXmt71qVaaatwv3t5VKrBBakmTGTPKMJv6MUHvLyCUmy+rTJBBPFweikjL55/zV2x4bcekaW0/FY9DrmCQzmEQRdDodU3qpY2d+2n2JKyl3rs5k5xkLBg1PCK+Ls4PBojEKIW5Pkhkz2X4mgbjUbKq4OdKjYYDW4VRqLo6GgiUiFu2Luu2x+TOYhoVVp6afVGVE0TrX86NtrSrk5JWsOvPb3svEJGcR5OXC/W1lrIwQWpNkxkzyB/4OaVVdrp1XgPzOyquOxJCenVfkMQcik9hyvSrzVI/6FRmesDE6na6g78xPuy4Rd5vqTHaekXmbro+VCa+Li6NUZYTQmnzqmkFyZi5rj6m9ZeQSU8UIq+lDaFV3MnKMrDoSW+Qxn6w/BagzoKQqI+6kS72qhNX0ITvPxOdbzhV73O/XqzKBXs480E6qMkJYA0lmzGDFoWhy8kw0CvKkabD0lqkIOp3u34HARSxvcCAyiU0n86syMlZG3JlanVHHzvy46yJxqbdWZ3LyTAVjZcZ3l6qMENZCkhkzyP8wHRZWA51Op3E09uPe1tXR6WDnuatEJmYU+t2c6zOYhraqTu2q7lqEJ2xQt/pVaX29OvNlEdWZP/ZdJiopkwBPZx5qX1ODCIUQRZFkppzOxacRcSkJg17HkNbSW6YiBfu40rluVQD+3P/vQOBDl5PYeCIOvQ6e6ilVGVFy6swmdezMD7suEp+aXfC7nDwTn10fKyNVGSGsiyQz5ZTfVr97A38CPF00jsb+DGtTHVCfB0VRe87cWJUJlaqMKKXuDfxpGeJDVq6JL7f+O7NpUYRalfH3dGZkB6nKCGFNHLQOwFYZTQr/nLvKj/9cAuDeVtU1jsg+9WsahIfzUS5ezeDbHRdIyzay/ngcOqQqI8pGp9MxtVd9Hv1mD9/tvECbWlXIyDHywdqTADzZrY5UZYSwMjZRmZk3bx6hoaG4uLjQpk0btm3bpmk8q4/E0GX2RkZ9tYukzFwA3v7rGKuPlH4lZ1E+bk4OtKjhDcBry4/x/vUPHGdHPaeupGoZmrBh4Q39qeXnRnaewvgfIpj220ES0nLQ68DfU7p7C2FtrD6Z+fXXX5k6dSovvfQS+/fvp2vXrgwYMIBLly5pEs/qIzFM+CGCmJvWcLmSks2EHyIkoalgq4/EsOPsrV2As3JN8nyIMltzNJaLVzNu2W9SYOovB+R1JYSVsfpk5sMPP+Txxx9n7NixNG7cmI8//piQkBDmz59f4bEYTQqvLz9GUasB5e97ffkxjCVYL0iUX/7zcTvyfIjSkteVELbHqpOZnJwc9u3bR9++fQvt79u3Lzt27CjyNtnZ2aSkpBT6MZfd5xNvqcjcSAFikrPYfT7RbPcpiifPh7AEeV0JYXusOplJSEjAaDQSGBhYaH9gYCCxsUV3fZ01axbe3t4FPyEh5uvQWVQTrfIcJ8pHng9hCfK6EsL2WHUyk+/mRnSKohTbnO6FF14gOTm54CcyMtJscZR06rVM0a4Y8nwIS5DXlRC2x6qnZletWhWDwXBLFSYuLu6Wak0+Z2dnnJ0tM9ugfagv1bxdiE3OKnLcjA4I8nahfaivRe5fFCbPh7AEeV0JYXusujLj5OREmzZtWLduXaH969ato1OnThUej0GvY8agJoD6hnaj/O0Zg5pg0MuSBhVBng9hCfK6EsL2WHUyAzBt2jS++uorvv76a44fP84zzzzDpUuXGD9+vCbx9G9WjfmjwwjyLlxiDvJ2Yf7oMPo3q6ZJXPZKng9hCfK6EsK26JT8HvBWbN68ebz77rvExMTQrFkzPvroI7p161ai26akpODt7U1ycjJeXuZb0dpoUth9PpG41CwCPNWSs3xT0448H8IS5HUlhHZK8/ltE8lMeVgqmRFCCCGE5ZTm89vqLzMJIYQQQtyOJDNCCCGEsGmSzAghhBDCpkkyI4QQQgibJsmMEEIIIWyaJDNCCCGEsGmSzAghhBDCpkkyI4QQQgibJsmMEEIIIWyaVa+abQ75DY5TUlI0jkQIIYQQJZX/uV2ShQoqfTKTmpoKQEhIiMaRCCGEEKK0UlNT8fb2vu0xlX5tJpPJRHR0NJ6enuh0skBcUVJSUggJCSEyMlLWr7IC8nxYF3k+rIs8H9bFks+HoiikpqYSHByMXn/7UTGVvjKj1+upUaOG1mHYBC8vL3lzsCLyfFgXeT6sizwf1sVSz8edKjL5ZACwEEIIIWyaJDNCCCGEsGmSzAicnZ2ZMWMGzs7OWocikOfD2sjzYV3k+bAu1vJ8VPoBwEIIIYSo3KQyI4QQQgibJsmMEEIIIWyaJDNCCCGEsGmSzAghhBDCpkkyY6dmzZpFu3bt8PT0JCAggKFDh3Ly5EmtwxLXzZo1C51Ox9SpU7UOxa5FRUUxevRo/Pz8cHNzo1WrVuzbt0/rsOxSXl4eL7/8MqGhobi6ulKnTh3eeOMNTCaT1qHZha1btzJo0CCCg4PR6XQsWbKk0O8VReG1114jODgYV1dXwsPDOXr0aIXFJ8mMndqyZQuTJk3in3/+Yd26deTl5dG3b1/S09O1Ds3u7dmzhy+//JIWLVpoHYpdu3btGp07d8bR0ZFVq1Zx7NgxPvjgA3x8fLQOzS7Nnj2bzz//nLlz53L8+HHeffdd3nvvPT799FOtQ7ML6enptGzZkrlz5xb5+3fffZcPP/yQuXPnsmfPHoKCgujTp0/B+oiWJlOzBQDx8fEEBASwZcsWunXrpnU4distLY2wsDDmzZvHW2+9RatWrfj444+1DssuTZ8+nb///ptt27ZpHYoA7rnnHgIDA/nf//5XsG/YsGG4ubnx/fffaxiZ/dHpdPz5558MHToUUKsywcHBTJ06leeffx6A7OxsAgMDmT17Nk8++aTFY5LKjAAgOTkZAF9fX40jsW+TJk1i4MCB9O7dW+tQ7N6yZcto27YtI0aMICAggNatW7NgwQKtw7JbXbp0YcOGDZw6dQqAgwcPsn37du6++26NIxPnz58nNjaWvn37Fuxzdname/fu7Nixo0JiqPQLTYo7UxSFadOm0aVLF5o1a6Z1OHbrl19+ISIigj179mgdigDOnTvH/PnzmTZtGi+++CK7d+9m8uTJODs7M2bMGK3DszvPP/88ycnJNGrUCIPBgNFo5O233+ahhx7SOjS7FxsbC0BgYGCh/YGBgVy8eLFCYpBkRvDUU09x6NAhtm/frnUodisyMpIpU6awdu1aXFxctA5HACaTibZt2zJz5kwAWrduzdGjR5k/f74kMxr49ddf+eGHH/jpp59o2rQpBw4cYOrUqQQHB/Pwww9rHZ5Avfx0I0VRbtlnKZLM2Lmnn36aZcuWsXXrVmrUqKF1OHZr3759xMXF0aZNm4J9RqORrVu3MnfuXLKzszEYDBpGaH+qVatGkyZNCu1r3LgxixYt0igi+/bss88yffp0HnzwQQCaN2/OxYsXmTVrliQzGgsKCgLUCk21atUK9sfFxd1SrbEUGTNjpxRF4amnnmLx4sVs3LiR0NBQrUOya7169eLw4cMcOHCg4Kdt27aMGjWKAwcOSCKjgc6dO9/SruDUqVPUqlVLo4jsW0ZGBnp94Y8sg8EgU7OtQGhoKEFBQaxbt65gX05ODlu2bKFTp04VEoNUZuzUpEmT+Omnn1i6dCmenp4F1zy9vb1xdXXVODr74+npect4JXd3d/z8/GQck0aeeeYZOnXqxMyZM7n//vvZvXs3X375JV9++aXWodmlQYMG8fbbb1OzZk2aNm3K/v37+fDDD3nssce0Ds0upKWlcebMmYLt8+fPc+DAAXx9falZsyZTp05l5syZ1K9fn/r16zNz5kzc3NwYOXJkxQSoCLsEFPmzcOFCrUMT13Xv3l2ZMmWK1mHYteXLlyvNmjVTnJ2dlUaNGilffvml1iHZrZSUFGXKlClKzZo1FRcXF6VOnTrKSy+9pGRnZ2sdml3YtGlTkZ8ZDz/8sKIoimIymZQZM2YoQUFBirOzs9KtWzfl8OHDFRaf9JkRQgghhE2TMTNCCCGEsGmSzAghhBDCpkkyI4QQQgibJsmMEEIIIWyaJDNCCCGEsGmSzAghhBDCpkkyI4QQQgibJsmMEEIIIWyaJDNCCM3873//o2/fvmY954ULF9DpdBw4cMCs5wWYO3cugwcPNvt5hRDlI8mMEEIT2dnZvPrqq7zyyitmPW9ISAgxMTEFa1pt3rwZnU5HUlLSbW+XlZXFI488QvPmzXFwcGDo0KG3HDNu3Dj27NnD9u3bzRqzEKJ8JJkRQmhi0aJFeHh40LVrV7Oe12AwEBQUhIND6dbRNRqNuLq6MnnyZHr37l3kMc7OzowcOZJPP/3UHKEKIcxEkhkhRLnEx8cTFBTEzJkzC/bt2rULJycn1q5dW+ztfvnll1su2YSHhzN16tRC+4YOHcojjzxSsF27dm1mzpzJY489hqenJzVr1iy0kvWNl5kuXLhAjx49AKhSpQo6na7QuW7k7u7O/PnzGTduHEFBQcXGPXjwYJYsWUJmZmaxxwghKpYkM0KIcvH39+frr7/mtddeY+/evaSlpTF69GgmTpx42/Ew27Zto23btmW6zw8++IC2bduyf/9+Jk6cyIQJEzhx4sQtx4WEhLBo0SIATp48SUxMDJ988kmZ7jNf27Ztyc3NZffu3eU6jxDCfCSZEUKU29133824ceMYNWoU48ePx8XFhXfeeafY45OSkkhKSiI4OLjM9zdx4kTq1avH888/T9WqVdm8efMtxxkMBnx9fQEICAggKCgIb2/vMt1nPnd3d3x8fLhw4UK5ziOEMB9JZoQQZvH++++Tl5fHb7/9xo8//oiLi0uxx+ZforndMbfTokWLgv/X6XQEBQURFxdXpnOVhaurKxkZGRV2f0KI25NkRghhFufOnSM6OhqTycTFixdve6yfnx86nY5r164V2q/X61EUpdC+3NzcW27v6OhYaFun02EymcoYeeklJibi7+9fYfcnhLg9SWaEEOWWk5PDqFGjeOCBB3jrrbd4/PHHuXLlSrHHOzk50aRJE44dO1Zov7+/PzExMQXbRqORI0eOlCs2JyengnOZw9mzZ8nKyqJ169ZmOZ8QovwkmRFClNtLL71EcnIyc+bM4bnnnqNx48Y8/vjjt71Nv379bunX0rNnT1auXMnKlSs5ceIEEydOvGN/mDupVasWOp2OFStWEB8fT1paWrHHHjt2jAMHDpCYmEhycjIHDhy4pfnetm3bqFOnDnXr1i1XXEII8yldIwYhhLjJ5s2b+fjjj9m0aRNeXl4AfP/997Ro0YL58+czYcKEIm83btw4wsLCSE5OLhiU+9hjj3Hw4EHGjBmDg4MDzzzzTMHU6rKqXr06r7/+OtOnT+fRRx9lzJgxfPPNN0Uee/fddxe6RJZffbnx0tfPP//MuHHjyhWTEMK8dMrNF6iFEKKC3H///bRu3ZoXXnhB61BK5MiRI/Tq1YtTp06Ve1aUEMJ85DKTEEIz7733Hh4eHlqHUWLR0dF89913ksgIYWWkMiOEEEIImyaVGSGEEELYNElmhBBCCGHTJJkRQgghhE2TZEYIIYQQNk2SGSGEEELYNElmhBBCCGHTJJkRQgghhE2TZEYIIYQQNk2SGSGEEELYtP8HVsyfQvgXsmgAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Below, we will use matplotlib, so we need to import it here.\n",
    "\n",
    "x=[1,2,3,4,5,6,7,8,9,10]\n",
    "y1=[0,4,0,3,3,0,3,4,5,2]\n",
    "plt.plot(x, y1, \"o-\", label=\"y1\")\n",
    "plt.plot(x, x, label=\"x\")\n",
    "y2=[3,2,4,4,2,4,4,2,4,2]\n",
    "plt.plot(x, y2, \"o:\", label=\"y2\")\n",
    "plt.legend()\n",
    "plt.xlabel('x (unit 1)')\n",
    "plt.ylabel('y (unit 2)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bb1996b-1984-4b72-80a4-5d51f2c53dae",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Example: compute the Fibonacci sequence using *recursion*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cf12416-91df-412f-948c-b65fc37dc0c1",
   "metadata": {
    "tags": []
   },
   "source": [
    "1, 1, 2, 3, 5, 8, 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "2ea9d4a7-57e1-4a48-8314-8271e04baa35",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fib(n):\n",
    "    \"\"\"Return the Fibonacci sequence up to position n.\n",
    "    \n",
    "    n is an integer\"\"\"\n",
    "    # Check that our assumptions are true\n",
    "    assert type(n)==int\n",
    "    assert n>0\n",
    "    \n",
    "    # special cases for short lists\n",
    "    if n == 1:\n",
    "        return [1]\n",
    "    if n == 2:\n",
    "        return [1,1]\n",
    "    \n",
    "    seq = fib(n-1)\n",
    "    a = seq[-2]\n",
    "    b = seq[-1]\n",
    "    seq.append( a+b )\n",
    "    return seq\n",
    "\n",
    "fib(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "884683c3-fc5b-4a7e-b9ea-3c5cf44d7e0d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "5c028087-c2d7-4db5-883d-28f8a7bedee7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "073bfda5-113a-4d20-9862-97c81f8b0854",
   "metadata": {},
   "source": [
    "## More strings\n",
    "\n",
    "[`str`](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)\n",
    "\n",
    "Useful function for strings:\n",
    "\n",
    "- `len`\n",
    "\n",
    "Useful methods:\n",
    "\n",
    "- `strip`\n",
    "- `split`\n",
    "- `startswith`\n",
    "- `endswith`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "2e2a51f4-ba55-4da6-8c95-11d5d3b1c4ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(\"my string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "51b609ce-a438-41dc-a708-3c29e616bd37",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'my string'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"   my string    \".strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "006f32e1-db2a-4358-a7e4-f78d23f1a382",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(\"   my string    \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "4c8ae22e-f44b-4465-a908-d116347a8343",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(\"   my string    \".strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "014ef6e5-1a9c-42fc-a143-840fe2a0a992",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'my string'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=\"   my string    \"\n",
    "a.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "967cb647-c24a-462c-88b9-a7b018ec448e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   my string    '"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "6993859c-1479-4fe8-8402-20b1281e077c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'def']"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"a,b,c,def\".split(\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "71684557-3b94-46e1-a0da-edbaf5752204",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello world\".startswith(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "323f78f6-cad4-4522-a291-c3faa0d92edd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello world\".endswith(\"world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a9120ae-28a2-4d0b-8f90-7238f8dea8a2",
   "metadata": {},
   "source": [
    "## Dictionaries - Python's `dict` type\n",
    "\n",
    "`dict` construction is with either `{}` or `dict()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "13a7d7fc-704e-4ea6-b17e-353ac1b8ed5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {'key1': 'value1',\n",
    "     'key2': 'value2',\n",
    "    'key3': 'value3',\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "a5aa8b60-b195-400c-9cdd-99608c9b5b38",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "6ee1492a-acc6-41a1-9751-66319d1585f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value1'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x['key1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "5abd5123-ff6c-468b-87c2-5d1a88749b8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "key = \"key3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "f48ab396-0797-484e-b812-f8ea25ec411a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value3'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[key]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "9d620659-6db4-4c50-b573-a6c0d9f4c94d",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'key1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[68], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m x[\u001b[43mkey1\u001b[49m]\n",
      "\u001b[0;31mNameError\u001b[0m: name 'key1' is not defined"
     ]
    }
   ],
   "source": [
    "x[key1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "3025c22b-fb7c-4964-a0a0-f1d2a68ac910",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = dict(   (('key1', 'value1'), ['key2', 'value2'], ('key3', 'value3'))    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "3aee4625-a694-48ec-9627-89de9ad343df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "b95d11fc-96c9-42fb-9ae5-79470f1d5a78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bff2b811-cfab-484c-9d12-35ae7308c42a",
   "metadata": {},
   "source": [
    "Keys in a `dict` can be any value that is *hashable*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "98c0c33d-c4cf-4912-87f7-37ff05f90217",
   "metadata": {},
   "outputs": [],
   "source": [
    "x={1:'value1', 2:'value2'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "f2b9029e-1ba7-43fe-8447-39082e0972dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value1'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "34fc4694-1e93-4bb7-bc45-a9bfeb58cb9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(1, 2, 3): '456'}"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x={(1,2,3): \"456\"}\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "7130ab9e-83d7-4c88-a29b-d51db4090fc5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'456'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[(1,2,3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "83a55976-33e5-4496-a069-d50d9b9079e3",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[76], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m x\u001b[38;5;241m=\u001b[39m{[\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m3\u001b[39m]: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m456\u001b[39m\u001b[38;5;124m\"\u001b[39m}\n\u001b[1;32m      2\u001b[0m x\n",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "x={[1,2,3]: \"456\"}\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "e6081d5f-f775-4cb1-a126-c1517a712f0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {'key1':1, 'key2':2, 'key3':123456, 'key4': [1,2,3], 'key5': {}, 1234: 4321, (1,2,3): '9845712345'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "d453c135-5195-4fe3-8366-4799c0ea35e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 1,\n",
       " 'key2': 2,\n",
       " 'key3': 123456,\n",
       " 'key4': [1, 2, 3],\n",
       " 'key5': {},\n",
       " 1234: 4321,\n",
       " (1, 2, 3): '9845712345'}"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "378490b3-1a1c-40eb-9fdd-49f373cfd311",
   "metadata": {},
   "source": [
    "Just like we can iterate over items in a list, we can iterate over the keys in a dict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "4dc3830e-d4ca-41e8-8e7d-98cb583e1f61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key1\n",
      "key2\n",
      "key3\n",
      "key4\n",
      "key5\n",
      "1234\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "for key in x:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "19560e57-1815-48a8-95e8-f640d151e12b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key: key1, value: 1\n",
      "key: key2, value: 2\n",
      "key: key3, value: 123456\n",
      "key: key4, value: [1, 2, 3]\n",
      "key: key5, value: {}\n",
      "key: 1234, value: 4321\n",
      "key: (1, 2, 3), value: 9845712345\n"
     ]
    }
   ],
   "source": [
    "for key in x:\n",
    "    value = x[key]\n",
    "    print(f\"key: {key}, value: {value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "83e6c07c-dec3-4c86-9c0e-11954dce7b32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x['key5']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "84b5bc6d-4a1f-4f64-a1f6-09ef906f838a",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'key does not exist'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[82], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mkey does not exist\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[0;31mKeyError\u001b[0m: 'key does not exist'"
     ]
    }
   ],
   "source": [
    "x['key does not exist']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "937a9759-bccb-4edc-85d1-4007a2e6bf07",
   "metadata": {},
   "outputs": [],
   "source": [
    "x['my new key'] = 9843059"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "71d14521-f025-440d-80e4-e2ac8f4f30d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 1,\n",
       " 'key2': 2,\n",
       " 'key3': 123456,\n",
       " 'key4': [1, 2, 3],\n",
       " 'key5': {},\n",
       " 1234: 4321,\n",
       " (1, 2, 3): '9845712345',\n",
       " 'my new key': 9843059}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "27f83073-2f88-4d7b-8ba8-5fc124cc78e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "x['key5']['hello'] = 'world'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "9305e9cf-b800-436f-8261-d0264c965e91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 1,\n",
       " 'key2': 2,\n",
       " 'key3': 123456,\n",
       " 'key4': [1, 2, 3],\n",
       " 'key5': {'hello': 'world'},\n",
       " 1234: 4321,\n",
       " (1, 2, 3): '9845712345',\n",
       " 'my new key': 9843059}"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "f9b2afb6-9aba-41ed-8894-737eca4da4fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "tmp = x['key5']\n",
    "tmp['hello'] = 'world 2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "3933cbbd-fa69-4729-8a18-0a62d40a2d45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 1,\n",
       " 'key2': 2,\n",
       " 'key3': 123456,\n",
       " 'key4': [1, 2, 3],\n",
       " 'key5': {'hello': 'world 2'},\n",
       " 1234: 4321,\n",
       " (1, 2, 3): '9845712345',\n",
       " 'my new key': 9843059}"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "7216abd8-d3af-4b2e-bac4-712c34cce195",
   "metadata": {},
   "outputs": [],
   "source": [
    "x['key4'].append( 4 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "746ed972-e427-4fa1-9fcf-99def813343c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 1,\n",
       " 'key2': 2,\n",
       " 'key3': 123456,\n",
       " 'key4': [1, 2, 3, 4],\n",
       " 'key5': {'hello': 'world 2'},\n",
       " 1234: 4321,\n",
       " (1, 2, 3): '9845712345',\n",
       " 'my new key': 9843059}"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "de23284e-f7ce-442d-8e17-e9b2346256b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'key1' in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "3f86ace1-eb0c-4e9d-83d3-03e7b0610479",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "f1cc91eb-e228-48de-b797-ed1efa675d51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1234 in x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a2d6058-e5db-478c-9b18-ed4380a0d943",
   "metadata": {},
   "source": [
    "## More about functions: keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "01cd5398-943c-49ee-a0bb-95f48dd52bff",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(x, z=1):\n",
    "    return x+z*z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "b3419f92-8017-4656-b4cc-c9b29102e46b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_function(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "3a7c0dc4-5af9-493f-a7d1-b0f97d0e72fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "130"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_function(9,11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "c76e2e4c-9005-4cee-a27b-2e9decf954c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "130"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_function(9,z=11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "debac7a1-0865-4c35-878a-e40626e7f485",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "130"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_function(x=9,z=11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "f952135a-9211-484d-8159-0e8971cf3b23",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "my_function() missing 1 required positional argument: 'x'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[100], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmy_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m11\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: my_function() missing 1 required positional argument: 'x'"
     ]
    }
   ],
   "source": [
    "my_function(z=11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "4d5d297c-711b-4d54-bae4-923d95aa18f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "130"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_function(z=11,x=9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "cf7db77e-fd81-4035-8bd8-66219ed478d9",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (690924689.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[102], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    my_function(z=11,9)\u001b[0m\n\u001b[0m                      ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "my_function(z=11,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "21f8f437-b093-47f0-a00a-e80fda8ade30",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function2(x, y, z=1, qq=0):\n",
    "    return x+z+qq+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "fa8fe1f7-22aa-46f7-8f6a-4de9b354f7c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_function2(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "d019400e-2aa2-4b42-85c6-27dea98ae5b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-30"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_function2(0,1,qq=-32)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6593546-0c45-4708-918a-6c215a1fb3a2",
   "metadata": {},
   "source": [
    "## The `+` operator on various data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "3d6f8126-f40b-4733-9fe1-fd86af8a0d1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "7ea7cec7-9343-4f9a-b615-2755747ed983",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.3"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "24a67ab4-d73f-48d0-be71-2eff2964ac48",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[108], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m1\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "\"1\"+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "f2ac0055-6908-43f4-b8c4-e749191641af",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[109], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;241;43m1\u001b[39;49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m1\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "1+\"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "f37d2ace-962a-4c02-90f2-52bffd60592d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'11'"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"1\"+\"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "81dc1b8a-0b49-47af-afb0-b5681dd9c045",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1   x1   y'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"1   x\" + \"1   y\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "bab16714-5a6b-4e4f-8ed4-8a16498923a6",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate list (not \"int\") to list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[112], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list"
     ]
    }
   ],
   "source": [
    "[1]+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "00d9ea96-be24-43a0-b2bd-6bcedf2c05ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1] + [1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "3bc11485-00de-40c3-8af6-3e063d2de489",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[1]\n",
    "y=[1]\n",
    "z=x+y\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "5a100456-56a3-4134-ab9f-6017ec27f7b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list.__add__([1], [1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "9533ce06-1ee9-4c98-9d7b-188774fb2c26",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=[1]\n",
    "x.append(1)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "d524a21a-7538-45be-8f92-7b7299bfd2cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int.__add__(1, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "3f8b6fbe-f757-490d-8689-93adf78ee211",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e52366a-b96e-4602-8f50-0e2b1932adc2",
   "metadata": {},
   "source": [
    "Note: \"joining\" or \"combining\" one sequence to another is called *concatenating* the sequences. It works with lists of any length:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "568bdadd-2505-4972-9955-968fd8b959dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] + [4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "5863946d-499d-406c-ac15-6e9d627d5d32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3] + []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "91fcf9e5-a3a6-413f-a5aa-990ab97fd9b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[] + [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "b6fdaf75-7185-4b9f-9c5d-178242b662e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1)"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1,) + (1,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "cc30aba1-031e-4bec-9af0-910df0e8c74d",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate tuple (not \"int\") to tuple",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[123], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate tuple (not \"int\") to tuple"
     ]
    }
   ],
   "source": [
    "(1,) + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bac25ee-d7ee-4501-bc94-9a372f889a19",
   "metadata": {},
   "source": [
    "## The `*` operator on various data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "c99b7fb4-8d1a-464a-b2b6-b71c78053a6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "14bc9a15-79c8-4840-a623-ff4267b874bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1xz1xz1xz1xz1xz'"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"1xz\"*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "b1ff7075-8a59-490a-9047-c2283a6f648e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[126], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m1xz\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mblah\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n",
      "\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'"
     ]
    }
   ],
   "source": [
    "\"1xz\"*\"blah\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "342b200b-8dae-4793-9140-597b88f142f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3]*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "6a5d7d47-2c74-4c88-87e0-cb9d18f70ea4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 * [1,2,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16e4e558-5d84-44df-94d7-02d638a88ed5",
   "metadata": {},
   "source": [
    "## Special method: `object.__add__(other)`\n",
    "\n",
    "Many of the bits of Python we have already been using are defined as \"special methods\". The names of these methods start and end with a double underscore `__`. They are not usually called directly, but rather Python calls these methods \"secretly\" to acheive some task. As we saw above, the \"add\" special method is implemended with `__add__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "d201089e-a0bc-44ae-b786-ca6c5b372c4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "six = 6\n",
    "six.__add__(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "bd47841c-f7ea-4d41-bf8d-702c81677ad1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int.__add__(6,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "f658de87-ace5-4863-b401-8c77e953af67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "six+4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de7adb09-9380-47f3-8640-a839355322d0",
   "metadata": {},
   "source": [
    "## Special method: `object.__getitem__(index)`\n",
    "\n",
    "The special method `object.__getitem__(index)` is how python implements `object[index]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "1ba584d9-4454-4f92-8161-91db385765e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "x={0:1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "48747698-be87-43c4-9b62-c4f2c01d3358",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 1}"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "8b329eca-9cc2-49b5-9f38-984e2a5d6082",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "7d8c44c3-83a8-44fb-a2aa-662cec019329",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.__getitem__(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "843c9276-15fa-4c37-8957-e65095bfd1ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "x={1:\"value1\",2:43}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "ad181878-37d7-453b-9d82-0e0e87fa262e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value1'"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "078a64da-72e6-482a-bd10-6214b13b0259",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value1'"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.__getitem__(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7700f265-438e-47f0-8374-bfaa04c37839",
   "metadata": {},
   "source": [
    "## Special method: `sequence.__len__()`\n",
    "\n",
    "Another special method is `__len__`, which returns the length of a sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "3f43db53-58aa-4fb7-844a-2a887f573a5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'value1', 2: 43}"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "cbc1f087-1bd2-45c8-9769-b634ed0bf454",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "340077e2-4976-4c35-ae40-875fc852bd7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.__len__()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10e6adc3-9886-46b5-9648-7ce6cc848e5c",
   "metadata": {},
   "source": [
    "## Special methods: `object.__str__()` (and `object.__repr__()`)\n",
    "\n",
    "Another special method is `__str__`, which returns a string representation of the object. (`__repr__` does something very similar but can often be used to \"reproduce\" the original thing and is hence a little more exact if less \"nice\" or \"pretty\".)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "9af0f5db-21ac-4034-95ce-0f87d4f707fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.4'"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(0.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "2a1fc7fb-d30b-4777-868f-6048d35a481c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.4'"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 0.4\n",
    "x.__str__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "39c639fd-ef4f-4dee-9d0f-e7c1afa2e561",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"{1: 'value1', 2: 43}\""
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x={1:\"value1\",2:43}\n",
    "x.__str__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "9378b32d-b53d-400a-b961-e71e856a190d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'value1', 2: 43}\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "059a009a-b3f0-420e-b5f4-b8c38f0f1baa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "15846c60-857d-4d5c-a8af-359165665d99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "80199a3b-8e26-4ca2-b172-6acfb4c2cd58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"my value is: {1: 'value1', 2: 43}\""
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"my value is: {x}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "3d68b71b-21dd-4190-ba3e-266003959887",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one = 1\n",
    "one.__str__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "e7a3c69e-437f-47dd-ac3c-e831af5a9efd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'my value is: 1'"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"my value is: {1}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "742638d8-641e-4d44-9633-9984bb4032bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.30000000000000004'"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(0.1 + 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "bc52ee21-d3f2-44e7-a526-f8be942d2749",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1 + 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b701ab6-6fbb-4d03-b598-92010251ca94",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "49372fac-b68d-4937-8836-e143fbf35cc8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"{1: 'value1', 2: 43}\""
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.__repr__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "dc6ed135-8ee7-4aad-8e4b-331c042e16a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"'hello'\""
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\".__repr__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "49c71868-c7b0-4ad3-bc95-0956dcce9883",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\".__str__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "8879819f-72ac-4c78-af40-a11c1e0466c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\".__str__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "ef18f2c3-690e-4633-a3ae-198800f37408",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'hello'\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\".__repr__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "9f22f4d4-8ef1-4edb-9a78-0adff34c77d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<built-in function print>'"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print.__str__()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "981f1a73-7c79-4a0e-b91e-63a3d348a503",
   "metadata": {},
   "source": [
    "# Abstract *interfaces* in python\n",
    "\n",
    "`for` loops iterate over \"iterables\". You can construct a `list` (or a `dict`) from iterables.\n",
    "\n",
    "Functions and methods are \"callable\".\n",
    "\n",
    "Getting items with square brackets (e.g. `x[0]`) works by calling the `__getitem__` method (so, `x.__getitem__(0)`). Any type can define how this works for that type."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aa6d28b-16cb-4d24-8a94-ec39f011d192",
   "metadata": {},
   "source": [
    "## More on iterators\n",
    "\n",
    "There are a couple of very handy functions which take an iterable and return a new iterator:\n",
    "\n",
    "- `enumerate(items)` - returns iterator with index of items. Each iteration produces a tuple with `(index, item)`.\n",
    "- `zip(a_items, b_items)` - returns iterator combining two other iterators. Each iteration produces a tuple with `(a_item, b_item)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "6efaf701-1c93-4029-9c66-26f4154a42ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: abc\n",
      "1: def\n",
      "2: ghi\n"
     ]
    }
   ],
   "source": [
    "my_list = ['abc', 'def', 'ghi']\n",
    "my_iterator = enumerate(my_list)\n",
    "for x in my_iterator:\n",
    "    idx, item = x\n",
    "    print(f\"{idx}: {item}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b727d87-2494-4834-8031-ef4c8cb936c4",
   "metadata": {},
   "source": [
    "Usually, the temporary iterator would be implicit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "d85af85e-6cd1-4004-9b25-e45e66e16e74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: abc\n",
      "1: def\n",
      "2: ghi\n"
     ]
    }
   ],
   "source": [
    "my_list = ['abc', 'def', 'ghi']\n",
    "for x in enumerate(my_list):\n",
    "    idx, item = x\n",
    "    print(f\"{idx}: {item}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ba404f2-d30f-44ed-b6ce-e174153e1340",
   "metadata": {},
   "source": [
    "We can directly assign the tuple to two variables for further elimination of temporary variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "d0bf3490-b600-4d44-b6c3-ff298237c3a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: abc\n",
      "1: def\n",
      "2: ghi\n"
     ]
    }
   ],
   "source": [
    "my_list = ['abc', 'def', 'ghi']\n",
    "for idx, item in enumerate(my_list):\n",
    "    print(f\"{idx}: {item}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01eaf24f-4556-4c2d-a980-9523557cec4a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "61709401-22b2-4419-b36f-e9b79e5909f4",
   "metadata": {},
   "source": [
    "Now, for `zip`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "3506da24-eb14-4e94-951e-70b599388fb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc red\n",
      "def green\n",
      "ghi blue\n"
     ]
    }
   ],
   "source": [
    "my_list = ['abc', 'def', 'ghi']\n",
    "list2 = ['red', 'green', 'blue']\n",
    "my_iterator = zip(my_list, list2)\n",
    "for x in my_iterator:\n",
    "    (item, color) = x\n",
    "    print(f\"{item} {color}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "fce72964-cc76-44b6-95f3-732c07f032c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc red\n",
      "def green\n",
      "ghi blue\n"
     ]
    }
   ],
   "source": [
    "my_list = ['abc', 'def', 'ghi']\n",
    "for (item, color) in zip(my_list, ['red', 'green', 'blue']):\n",
    "    print(f\"{item} {color}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "48c0294b-0d17-464f-bd2c-c4c8000f277f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc 3\n",
      "def 4\n",
      "ghi 5\n"
     ]
    }
   ],
   "source": [
    "my_list = ['abc', 'def', 'ghi']\n",
    "for item, number in zip(my_list, range(3,6)):\n",
    "    print(f\"{item} {number}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3610ab7-a3fb-49b9-b147-4ae6570f2ed9",
   "metadata": {},
   "source": [
    "# Data Frames\n",
    "\n",
    "We are going to look at data in *tables* where each *row* of the table contains measurements or values about a single thing and each *column* is the measurement type. Such tables are very common in data science."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7f6488f-694b-4ee6-8f28-f0f7b1ec691a",
   "metadata": {},
   "source": [
    "(Loading the iris data is hidden in this cell. You can ignore this.)\n",
    "<!--\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.datasets import load_iris\n",
    "iris = load_iris()\n",
    "df= pd.DataFrame(data= np.c_[iris['data'], iris['target']],\n",
    "                 columns= iris['feature_names'] + ['target'])\n",
    "df['species'] = pd.Categorical.from_codes(iris.target, iris.target_names)\n",
    "df = df.drop('target',axis=1)\n",
    "def to_dict(df):\n",
    "    result = {}\n",
    "    for column_name in df.columns:\n",
    "        result[column_name] = []\n",
    "    for i,row in df.iterrows():\n",
    "        for column_name in df.columns:\n",
    "            result[column_name].append( row[column_name] )\n",
    "    return result\n",
    "iris_dict = to_dict(df)\n",
    "print(iris_dict)\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b60c8c3-2b6f-4ca4-b4b7-ec085fb1609b",
   "metadata": {},
   "source": [
    "Here is an example of the data we will be looking at. It is a subsampling of the very famous [Iris data set](https://en.wikipedia.org/wiki/Iris_flower_data_set).\n",
    "\n",
    "<table class=\"dataframe\" border=\"1\">\n",
    "  <thead>\n",
    "    <tr style=\"text-align: right;\">\n",
    "      <th></th>\n",
    "      <th>sepal length (cm)</th>\n",
    "      <th>sepal width (cm)</th>\n",
    "      <th>petal length (cm)</th>\n",
    "      <th>petal width (cm)</th>\n",
    "      <th>species</th>\n",
    "    </tr>\n",
    "  </thead>\n",
    "  <tbody>\n",
    "    <tr>\n",
    "      <th>11</th>\n",
    "      <td>4.8</td>\n",
    "      <td>3.4</td>\n",
    "      <td>1.6</td>\n",
    "      <td>0.2</td>\n",
    "      <td>setosa</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>81</th>\n",
    "      <td>5.5</td>\n",
    "      <td>2.4</td>\n",
    "      <td>3.7</td>\n",
    "      <td>1.0</td>\n",
    "      <td>versicolor</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>97</th>\n",
    "      <td>6.2</td>\n",
    "      <td>2.9</td>\n",
    "      <td>4.3</td>\n",
    "      <td>1.3</td>\n",
    "      <td>versicolor</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>37</th>\n",
    "      <td>4.9</td>\n",
    "      <td>3.6</td>\n",
    "      <td>1.4</td>\n",
    "      <td>0.1</td>\n",
    "      <td>setosa</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>31</th>\n",
    "      <td>5.4</td>\n",
    "      <td>3.4</td>\n",
    "      <td>1.5</td>\n",
    "      <td>0.4</td>\n",
    "      <td>setosa</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>28</th>\n",
    "      <td>5.2</td>\n",
    "      <td>3.4</td>\n",
    "      <td>1.4</td>\n",
    "      <td>0.2</td>\n",
    "      <td>setosa</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>141</th>\n",
    "      <td>6.9</td>\n",
    "      <td>3.1</td>\n",
    "      <td>5.1</td>\n",
    "      <td>2.3</td>\n",
    "      <td>virginica</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th>149</th>\n",
    "      <td>5.9</td>\n",
    "      <td>3.0</td>\n",
    "      <td>5.1</td>\n",
    "      <td>1.8</td>\n",
    "      <td>virginica</td>\n",
    "    </tr>\n",
    "  </tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbf97605-aa5d-4f7a-8015-fd9e543c80c0",
   "metadata": {},
   "source": [
    "For now, the data are given as a `dict`. This `dict` is created in a special way, where each key is the column name and each value is a list of the entry for each row for that column. Later we will read this from a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "e212cde2-364f-4055-b5f3-9e58db575544",
   "metadata": {},
   "outputs": [],
   "source": [
    "iris_dataset = {'sepal length (cm)': [5.1, 4.9, 4.7, 4.6, 5.0, 5.4, 4.6, 5.0, 4.4, 4.9, 5.4, 4.8, \n",
    "                                      4.8, 4.3, 5.8, 5.7, 5.4, 5.1, 5.7, 5.1, 5.4, 5.1, 4.6, 5.1, \n",
    "                                      4.8, 5.0, 5.0, 5.2, 5.2, 4.7, 4.8, 5.4, 5.2, 5.5, 4.9, 5.0,\n",
    "                                      5.5, 4.9, 4.4, 5.1, 5.0, 4.5, 4.4, 5.0, 5.1, 4.8, 5.1, 4.6,\n",
    "                                      5.3, 5.0, 7.0, 6.4, 6.9, 5.5, 6.5, 5.7, 6.3, 4.9, 6.6, 5.2,\n",
    "                                      5.0, 5.9, 6.0, 6.1, 5.6, 6.7, 5.6, 5.8, 6.2, 5.6, 5.9, 6.1,\n",
    "                                      6.3, 6.1, 6.4, 6.6, 6.8, 6.7, 6.0, 5.7, 5.5, 5.5, 5.8, 6.0,\n",
    "                                      5.4, 6.0, 6.7, 6.3, 5.6, 5.5, 5.5, 6.1, 5.8, 5.0, 5.6, 5.7, \n",
    "                                      5.7, 6.2, 5.1, 5.7, 6.3, 5.8, 7.1, 6.3, 6.5, 7.6, 4.9, 7.3, 6.7, \n",
    "                                      7.2, 6.5, 6.4, 6.8, 5.7, 5.8, 6.4, 6.5, 7.7, 7.7, 6.0, 6.9, 5.6, 7.7, 6.3, 6.7, \n",
    "                                      7.2, 6.2, 6.1, 6.4, 7.2, 7.4, 7.9, 6.4, 6.3, 6.1, 7.7, 6.3, 6.4, 6.0, 6.9, 6.7, \n",
    "                                      6.9, 5.8, 6.8, 6.7, 6.7, 6.3, 6.5, 6.2, 5.9], \n",
    "                'sepal width (cm)': [3.5, 3.0, 3.2, 3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.4, 3.0, 3.0, 4.0, 4.4, 3.9, 3.5, 3.8, 3.8, 3.4, 3.7, 3.6, 3.3, 3.4, 3.0, 3.4, 3.5, 3.4, 3.2, 3.1, 3.4, 4.1, 4.2, 3.1, 3.2, 3.5, 3.6, 3.0, 3.4, 3.5, 2.3, 3.2, 3.5, 3.8, 3.0, 3.8, 3.2, 3.7, 3.3, 3.2, 3.2, 3.1, 2.3, 2.8, 2.8, 3.3, 2.4, 2.9, 2.7, 2.0, 3.0, 2.2, 2.9, 2.9, 3.1, 3.0, 2.7, 2.2, 2.5, 3.2, 2.8, 2.5, 2.8, 2.9, 3.0, 2.8, 3.0, 2.9, 2.6, 2.4, 2.4, 2.7, 2.7, 3.0, 3.4, 3.1, 2.3, 3.0, 2.5, 2.6, 3.0, 2.6, 2.3, 2.7, 3.0, 2.9, 2.9, 2.5, 2.8, 3.3, 2.7, 3.0, 2.9, 3.0, 3.0, 2.5, 2.9, 2.5, 3.6, 3.2, 2.7, 3.0, 2.5, 2.8, 3.2, 3.0, 3.8, 2.6, 2.2, 3.2, 2.8, 2.8, 2.7, 3.3, 3.2, 2.8, 3.0, 2.8, 3.0, 2.8, 3.8, 2.8, 2.8, 2.6, 3.0, 3.4, 3.1, 3.0, 3.1, 3.1, 3.1, 2.7, 3.2, 3.3, 3.0, 2.5, 3.0, 3.4, 3.0], 'petal length (cm)': [1.4, 1.4, 1.3, 1.5, 1.4, 1.7, 1.4, 1.5, 1.4, 1.5, 1.5, 1.6, 1.4, 1.1, 1.2, 1.5, 1.3, 1.4, 1.7, 1.5, 1.7, 1.5, 1.0, 1.7, 1.9, 1.6, 1.6, 1.5, 1.4, 1.6, 1.6, 1.5, 1.5, 1.4, 1.5, 1.2, 1.3, 1.4, 1.3, 1.5, 1.3, 1.3, 1.3, 1.6, 1.9, 1.4, 1.6, 1.4, 1.5, 1.4, 4.7, 4.5, 4.9, 4.0, 4.6, 4.5, 4.7, 3.3, 4.6, 3.9, 3.5, 4.2, 4.0, 4.7, 3.6, 4.4, 4.5, 4.1, 4.5, 3.9, 4.8, 4.0, 4.9, 4.7, 4.3, 4.4, 4.8, 5.0, 4.5, 3.5, 3.8, 3.7, 3.9, 5.1, 4.5, 4.5, 4.7, 4.4, 4.1, 4.0, 4.4, 4.6, 4.0, 3.3, 4.2, 4.2, 4.2, 4.3, 3.0, 4.1, 6.0, 5.1, 5.9, 5.6, 5.8, 6.6, 4.5, 6.3, 5.8, 6.1, 5.1, 5.3, 5.5, 5.0, 5.1, 5.3, 5.5, 6.7, 6.9, 5.0, 5.7, 4.9, 6.7, 4.9, 5.7, 6.0, 4.8, 4.9, 5.6, 5.8, 6.1, 6.4, 5.6, 5.1, 5.6, 6.1, 5.6, 5.5, 4.8, 5.4, 5.6, 5.1, 5.1, 5.9, 5.7, 5.2, 5.0, 5.2, 5.4, 5.1], 'petal width (cm)': [0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.3, 0.2, 0.2, 0.1, 0.2, 0.2, 0.1, 0.1, 0.2, 0.4, 0.4, 0.3, 0.3, 0.3, 0.2, 0.4, 0.2, 0.5, 0.2, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.4, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 0.2, 0.2, 0.3, 0.3, 0.2, 0.6, 0.4, 0.3, 0.2, 0.2, 0.2, 0.2, 1.4, 1.5, 1.5, 1.3, 1.5, 1.3, 1.6, 1.0, 1.3, 1.4, 1.0, 1.5, 1.0, 1.4, 1.3, 1.4, 1.5, 1.0, 1.5, 1.1, 1.8, 1.3, 1.5, 1.2, 1.3, 1.4, 1.4, 1.7, 1.5, 1.0, 1.1, 1.0, 1.2, 1.6, 1.5, 1.6, 1.5, 1.3, 1.3, 1.3, 1.2, 1.4, 1.2, 1.0, 1.3, 1.2, 1.3, 1.3, 1.1, 1.3, 2.5, 1.9, 2.1, 1.8, 2.2, 2.1, 1.7, 1.8, 1.8, 2.5, 2.0, 1.9, 2.1, 2.0, 2.4, 2.3, 1.8, 2.2, 2.3, 1.5, 2.3, 2.0, 2.0, 1.8, 2.1, 1.8, 1.8, 1.8, 2.1, 1.6, 1.9, 2.0, 2.2, 1.5, 1.4, 2.3, 2.4, 1.8, 1.8, 2.1, 2.4, 2.3, 1.9, 2.3, 2.5, 2.3, 1.9, 2.0, 2.3, 1.8], 'species': ['setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'setosa', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica', 'virginica']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7ca47cc-1af9-485b-96f2-cd6bb54aad8b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "378a0233-8278-41a7-b889-336a897cd7ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'petal width (cm)')"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(iris_dataset['sepal width (cm)'], iris_dataset['petal width (cm)'], 'o');\n",
    "plt.xlabel('sepal width (cm)')\n",
    "plt.ylabel('petal width (cm)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "bc40c86c-9fb8-45f2-8159-bd3f3580d902",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sepal length (cm)\n",
      "sepal width (cm)\n",
      "petal length (cm)\n",
      "petal width (cm)\n",
      "species\n"
     ]
    }
   ],
   "source": [
    "for column_name in iris_dataset:\n",
    "    print(column_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4bc81fb-b355-441a-a95e-32c31ac4a08d",
   "metadata": {},
   "source": [
    "Let's double check that every column (the value of each key) has the same number of rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "8eecef02-329d-42c8-a357-fc5735cd787e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'sepal length (cm)': 150 rows\n",
      "'sepal width (cm)': 150 rows\n",
      "'petal length (cm)': 150 rows\n",
      "'petal width (cm)': 150 rows\n",
      "'species': 150 rows\n"
     ]
    }
   ],
   "source": [
    "for column_name in iris_dataset:\n",
    "    column = iris_dataset[column_name]\n",
    "    print(\"'{}': {} rows\".format(column_name, len(column)))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}