Spaces:

MaryamKarimi080
/

SCR_Course_ChatBot

Running

File size: 51,428 Bytes

d48d4f3

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7a095b1d",
   "metadata": {},
   "source": [
    "# Python Tutorial (Beginners)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "929f009f",
   "metadata": {},
   "source": [
    "In this tutorial some basic concepts like variables, loops, conditional statements, and functions will be discussed. we will start with variables:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2da4d02a",
   "metadata": {},
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fd5c8a3",
   "metadata": {},
   "source": [
    "In python, we have 4 kinds of variables: numerical variables, strings, boolean, and complex numbers variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a122a867",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24 <class 'int'>\n",
      "Ali <class 'str'>\n",
      "True <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "age = 24\n",
    "name = \"Ali\"\n",
    "is_student = True\n",
    "\n",
    "print(age,type(age))\n",
    "print(name,type(name))\n",
    "print(is_student,type(is_student))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a958bac",
   "metadata": {},
   "source": [
    "We can cast the variable types to each others, meaning that converting the type of the variables using functions below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3dc9be28",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Casting\n",
    "x = str(3)    # x will be '3'\n",
    "y = int(3)    # y will be 3\n",
    "z = float(3)  # z will be 3.0\n",
    "n = bool(3)   # n will be True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6acf69aa",
   "metadata": {},
   "source": [
    "## Input data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc2f5cc3",
   "metadata": {},
   "source": [
    "by just one line of code, you can get the input data from the keyboard. Just remember that the type of this data will be string..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "f4f0441e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what's your name? Ali\n",
      "Your name is Ali\n"
     ]
    }
   ],
   "source": [
    "name=input(\"what's your name? \")\n",
    "print(\"Your name is \"+name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf245272",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7caee28a",
   "metadata": {},
   "source": [
    "Strings in python are surrounded by either single quotation marks, or double quotation marks.\n",
    "\n",
    "'hello' is the same as \"hello\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "157b0f7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "TODAY IS A GREAT DAY!\n",
      "3\n",
      "Today is a greaaaaaaaaat day!\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "context='Today is a great day!'\n",
    "print(context.count('d'))\n",
    "print(context.upper())\n",
    "print(context.find('a'))\n",
    "print(context.replace('great','greaaaaaaaaat'))\n",
    "print('great' in context)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9773b46f",
   "metadata": {},
   "source": [
    "## Math operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "952d3451",
   "metadata": {},
   "source": [
    "Arithmetic or math operators are used with numeric values to perform common mathematical operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "40b2ddef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6666666666666667\n",
      "1\n",
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "#we have +, -, /, *, //, %, **\n",
    "\n",
    "print(10/6) # Division\n",
    "print(10//6) # Floor division\n",
    "print(10%6) # Modulus\n",
    "print(2**3) # Exponentiation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fceb3dc6",
   "metadata": {},
   "source": [
    "## Comparison operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1df26526",
   "metadata": {},
   "source": [
    "Comparison operators are used to compare two values. The output is a boolean variable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "48551023",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# <, >, ==, !=, >=, <=\n",
    "\n",
    "print(1>100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee87b217",
   "metadata": {},
   "source": [
    "## Logical operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a82c266",
   "metadata": {},
   "source": [
    "Logical operators are used to combine conditional statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c34d2249",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# and: Returns True if both statements are true\n",
    "# or: Returns True if one of the statements is true\n",
    "# not: Reverse the result, returns False if the result is true\n",
    "\n",
    "print(1>0 and 1>2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21ba4836",
   "metadata": {},
   "source": [
    "## Conditional statement"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "362ae8c6",
   "metadata": {},
   "source": [
    "Python relies on indentation (whitespace at the beginning of a line) to define scope in the code. Other programming languages often use curly-brackets for this purpose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "651af70e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter your score: 20\n",
      "Your scaled score is: 4\n"
     ]
    }
   ],
   "source": [
    "# Writing lines of code that convert your score to american scale\n",
    "score=input('enter your score: ')\n",
    "score=float(score)\n",
    "\n",
    "if score >= 16:\n",
    "    scaled=4\n",
    "elif score <= 15 and score >= 14:\n",
    "    scaled=3\n",
    "elif score <= 13 and score >= 12:\n",
    "    scaled=2\n",
    "elif score <= 11 and score >= 10:\n",
    "    scaled=1\n",
    "else:\n",
    "    scaled=0\n",
    "\n",
    "# Using format string to include variables in the string.  \n",
    "print(\"Your scaled score is: {}\".format(scaled))\n",
    "#print(f\"Your scaled score is: {scaled}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ace97b5a",
   "metadata": {},
   "source": [
    "The format() method formats the specified value(s) and insert them inside the string's placeholder.\n",
    "The placeholder is defined using curly brackets: {}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d92becba",
   "metadata": {},
   "source": [
    "## while loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbd37206",
   "metadata": {},
   "source": [
    "Python has two primitive loop commands:\n",
    "\n",
    "--> while loops\n",
    "\n",
    "--> for loops\n",
    "\n",
    "With the while loop we can execute a set of statements as long as a condition is true. The while loop requires relevant variables to be ready, in this example we need to define an indexing variable, i, which we set to 1.\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "eb99d022",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "i is no longer less than 6\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"i is no longer less than 6\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d47e1d64",
   "metadata": {},
   "source": [
    "Note: With the \"break\" statement we can stop the loop even if the while condition is true.\n",
    "\n",
    "Note: With the \"continue\" statement we can stop the current iteration, and continue with the next.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e9e87ff6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Can I stop now??!no\n",
      "2\n",
      "Can I stop now??!yeS\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 100:\n",
    "    print(i)\n",
    "    i += 1\n",
    "    input_=input('Can I stop now??!')\n",
    "    input_=input_.lower()\n",
    "    if input_=='yes':\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "960ea4eb",
   "metadata": {},
   "source": [
    "## for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d90ddfa2",
   "metadata": {},
   "source": [
    "A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).\n",
    "\n",
    "This is less like the for keyword in other programming languages, and works more like an iterator method as found in other object-orientated programming languages.\n",
    "\n",
    "With the for loop we can execute a set of statements, once for each item in a list, tuple, set etc.\n",
    "\n",
    "Note: \"break\" and \"continue\" works here as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "cc042b24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "0\n",
      "banana\n",
      "1\n",
      "cherry\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for i, x in enumerate(fruits):\n",
    "    print(x)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38d6ca50",
   "metadata": {},
   "source": [
    "To loop through a set of code a specified number of times, we can use the range() function,\n",
    "The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "3cc097ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Finally finished!\n"
     ]
    }
   ],
   "source": [
    "for x in range(100):\n",
    "    print(x)\n",
    "else:\n",
    "    print(\"Finally finished!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6144cba",
   "metadata": {},
   "source": [
    "The range() function defaults to increment the sequence by 1, however it is possible to specify the increment value by adding a third parameter: range(2, 30, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b4b5e70",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f0dff88",
   "metadata": {},
   "source": [
    "Lists are used to store multiple items in a single variable. Lists are one of 4 built-in data types in Python used to store collections of data, the other 3 are Tuple, Set, and Dictionary, all with different qualities and usage. We can shortly summerize their properties below:\n",
    "\n",
    "List is a collection which is ordered and changeable. Allows duplicate members.\n",
    "\n",
    "Tuple is a collection which is ordered and unchangeable. Allows duplicate members.\n",
    "\n",
    "Set is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.\n",
    "\n",
    "Dictionary is a collection which is ordered** and changeable. No duplicate members."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "9428f711",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "['apple', 'banana', 'cherry', 5, True]\n",
      "['apple', 'banana']\n",
      "['apple', 'Ali', 'banana', 'cherry', 5, True, 6]\n",
      "['Ali', 'banana', 'cherry', 5, True, 6]\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\", 5 , True]\n",
    "print(len(thislist)) # returns the length of the list\n",
    "print(thislist)\n",
    "print(thislist[0:2]) # returns the defined elements of the list\n",
    "\n",
    "# Methods\n",
    "thislist.append('6') # insert the new element at the end of the list\n",
    "thislist.insert(1,'Ali') # insert the element at the desired index (here 1)\n",
    "print(thislist)\n",
    "thislist.pop(0) # deletes the defined element of the list\n",
    "print(thislist)\n",
    "\n",
    "print(5 in thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37bdbece",
   "metadata": {},
   "source": [
    "#### IMPORTANT Note: keep in mind that in python, the indices start from 0 (unlike MATLAB that start from 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8772402b",
   "metadata": {},
   "source": [
    "## tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c65ebc4",
   "metadata": {},
   "source": [
    "Tuples are used to store multiple items in a single variable.\n",
    "\n",
    "A tuple is a collection which is ordered and unchangeable.\n",
    "\n",
    "Tuples are written with round brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8e9f366b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "('abc', 34, True, 40, 'NOT')\n"
     ]
    }
   ],
   "source": [
    "thistuple = (\"apple\", \"banana\", \"cherry\")\n",
    "print(len(thistuple))\n",
    "tuple1 = (\"abc\", 34, True, 40, \"NOT\")\n",
    "print(tuple1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6a41e81",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dbbba2b",
   "metadata": {},
   "source": [
    "A set is a collection which is unordered, unchangeable*, and unindexed.\n",
    "\n",
    "* Note: Set items are unchangeable, but you can remove items and add new items.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "269d7988",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{True, 2, 'cherry', 'apple', 'banana'}\n"
     ]
    }
   ],
   "source": [
    "new_set = {\"apple\", \"banana\", \"cherry\", True, 1, 2, 2}\n",
    "print(new_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e90b39d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{True, 2, 'cherry', 'banana'}\n"
     ]
    }
   ],
   "source": [
    "new_set.remove('apple') # we cannot remove by index, because index has no meaning in sets!!\n",
    "print(new_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f939ce8c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{True, 2, 'cherry', 'Hi', 'banana'}\n"
     ]
    }
   ],
   "source": [
    "new_set.add('Hi') # we cannot remove by index, because index has no meaning in sets!!\n",
    "print(new_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "049b3aa4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hi', 'cherry']\n",
      "*******\n",
      "True\n",
      "*******\n",
      "True\n",
      "2\n",
      "cherry\n",
      "Hi\n",
      "banana\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\aligh\\AppData\\Local\\Temp/ipykernel_11788/3704487697.py:3: DeprecationWarning: Sampling from a set deprecated\n",
      "since Python 3.9 and will be removed in a subsequent version.\n",
      "  print(random.sample(new_set, 2))\n"
     ]
    }
   ],
   "source": [
    "# sample from the set:\n",
    "import random\n",
    "print(random.sample(new_set, 2))\n",
    "\n",
    "print('*******')\n",
    "# another way: by converting set to list\n",
    "print(list(new_set)[0])\n",
    "\n",
    "print('*******')\n",
    "# another way: by iterating over a loop\n",
    "for i in new_set:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "286a5c81",
   "metadata": {},
   "source": [
    "## Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c51ed29b",
   "metadata": {},
   "source": [
    "Dictionaries are written with curly brackets, and have keys and values. Dictionary items are presented in key:value pairs, and can be referred to by using the key name. in this example, the keys are 'brand', 'model', and 'year. we cannot have several same keys (like year here), and the dictionary will only keep one of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "364bc79f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'brand': [], 'model': 'Mustang', 'year': 2020}\n"
     ]
    }
   ],
   "source": [
    "thisdict = {\n",
    "  \"brand\": [],\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964,\n",
    "  \"year\": 2020\n",
    "}\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "72014022",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'brand': ['Ford'], 'model': 'Mustang', 'year': 2020}\n"
     ]
    }
   ],
   "source": [
    "# adding an element to the 'brand' key\n",
    "thisdict['brand'].append('Ford')\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "bf091f0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['brand', 'model', 'year'])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# keys of the dictionary\n",
    "thisdict.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7786ced7",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a9e1e91",
   "metadata": {},
   "source": [
    "A function is a block of code which only runs when it is called.\n",
    "You can pass data, known as parameters, into a function.\n",
    "A function can return data as a result.\n",
    "\n",
    "In Python a function is defined using the def keyword:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "52c2e95f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "25\n",
      "45\n"
     ]
    }
   ],
   "source": [
    "def my_function(x):\n",
    "    result= 5 * x\n",
    "    return result\n",
    "\n",
    "print(my_function(3))\n",
    "print(my_function(5))\n",
    "print(my_function(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93a11d54",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "307d4912",
   "metadata": {},
   "source": [
    "matplotlib is a strong library for plotting in python. Below is a brief representation of this library, but you can learn more about this on https://matplotlib.org/3.5.3/api/_as_gen/matplotlib.pyplot.html and search for your intended plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "49b5121d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "xpoints = [1, 8]\n",
    "ypoints = [3, 10]\n",
    "\n",
    "plt.plot(xpoints, ypoints)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "659c3924",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAoI0lEQVR4nO3da3iU9bku8PvJERIICZCEQ0iiCCaAEiAiag+W4Kq1tdW2HtoK7L27L7vWanfVZa+17NH2y1r2YLWfurenVUBbtfWAtVVrUaxowEwwQZCTwgwhCSFhJifIcebZH2YGIiaTOb+n+3dduTIzmcw8JG8e3nnmvd+/qCqIiMh6MowugIiI4sMGTkRkUWzgREQWxQZORGRRbOBERBaVlc4nmz17tlZWVqbzKclBGhsbu1S12Ijn5rZNqTTRtp3WBl5ZWQmXy5XOpyQHERGPUc/NbZtSaaJtmyMUIiKLYgMnIrIoNnAiIotiAycisig2cCIii5q0gYvIYyJyUkT2jrltpoi8KiKHQ5+LUlsmUWqISKaIvCsiL4auc9smy4hmD/x3AK4977Z7AGxT1UUAtoWuE1nRHQD2j7nObZssY9IGrqr/AOA97+YvAdgUurwJwA3JLYvo43Yc7sL/feNDDI36k/J4IlIG4PMAHhlzM7dtSrvfbv8QjR5fzN8X7wy8VFXbASD0uWSiO4rI7SLiEhFXZ2dnnE9HBGxtasX/e+ND5GQm7a2bBwH8O4DAmNu4bVNavXm4Ez9/+QD+3NwW8/em/E1MVX1IVWtVtba42JCUM9lEo8eHVRUzISIJP5aIfAHASVVtjPcxuG1TorrPDON7f2zGRSXTcM/nqmL+/ngbeIeIzAWA0OeTcT4OUVS6+odwpOs0LqtM2nuKVwH4ooi4ATwJYK2IPA5u25QmqoofPPcevKeH8eAtNZiSnRnzY8TbwF8AsDF0eSOArXE+DlFUXO7gfLA2SQ1cVb+vqmWqWgngVgCvqept4LZNafLs7lb89b0TuOuaxVg2f0ZcjxHNYYR/AFAP4GIROS4i3wRwH4BrROQwgGtC14lSxuX2IicrI+4NPQbctinlWrxncO8L+7C6cia+9amFcT/OpGcjVNWvTfCluriflShGLo8PNWWFyM2K/WXmZFR1O4DtocunwG2bUsgfUNz9dDMA4P6blyMzI/73dJjEJNMbGPZjb2sPViVv/k1kmIf+cQTvuL346ReXYsHMvIQeiw2cTK+ppRujAU3mG5hEhtjb2oNfv3oQn1s2B19ZOT/hx2MDJ9NzuYM5slXlMw2uhCh+gyN+3PVUE4rycvCfN16SlMNh07oiD1E8XB4fLi6djhl52UaXQhS3+146gMMn+7H5f61GUX5OUh6Te+Bkav6AYrfHx/k3Wdqbhzvxu7fd+B9XVuJTi5MX+mIDJ1M7eKIPfUOjnH+TZSWatoyEDZxMrdETnH/XVnD+Tdajqvjhc3txqj/+tGUkbOBkag1uH+YUTEFZ0VSjSyGK2XPvtuIv77UnlLaMhA2cTM3l9mJVZVFS3rEnSqcW7xncu3UfLqsswj9/Ov60ZSRs4GRard0DaOsZxGUVnH+TtYTTlgrg1zfXJJS2jISHEZJphY//rq3k/JusJZy2/NVNyxNOW0bCPXAyLZfbh/ycTFTNmW50KURRS3baMhI2cDKtBrcXKyuKkJW8FXiIUioVactI+JdBptQ7OIKDHX08fJAs5ecvB9OWv7xpedLSlpGwgZMp7fb4oAoGeMgy3jzcif9+K5i2/HQS05aRsIGTKbncPmRmCGrKC40uhWhSqUxbRsIGTqbU4PZi6bwC5OXwQCkyt1SnLSNhAyfTGR4NoPl4N+ffZAmpTltGwgZOprOvrQeDIwHOv8n0jvtSn7aMhA2cTCe8Aj1PIUtm5g8o/i0NactIOGAk02lwe1ExKw8l06cYXQrRhB76xxG8czT1actIuAdOpqKqaPT4OP8mU0tn2jISNnAylaNdp3Hq9DBqOT4hk0p32jISjlDIVMLzb76BSWYVTltuSuLalvHiHjiZisvjRVFeNhYWT0v5c4nIFBF5R0SaRWSfiPwsdPtPRaRVRJpCH9elvBiyhHDacuMVFWlLW0bCPXAyFZfbh1UVM9P1snQIwFpV7ReRbAA7ROSl0NceUNVfpaMIsoZw2nJhcT7u+Vy10eUA4B44mUhX/xCOdJ1O2/xbg/pDV7NDH5qWJydLGZu2/M2tKzA1J31py0jYwMk0jJh/i0imiDQBOAngVVXdFfrSd0Rkj4g8JiLjFiQit4uIS0RcnZ2d6SqZDGBk2jISNnAyjUaPFzlZGWn9A1FVv6rWACgDsFpElgH4LYCFAGoAtAO4f4LvfUhVa1W1trjY+HkopYbRactI2MDJNBrcPtSUFSI3K/0vT1W1G8B2ANeqakeosQcAPAxgddoLIlMwQ9oyEjZwMoWBYT/2tvakNT4vIsUiUhi6PBXAOgAHRGTumLvdCGBv2ooiU3n4zWDa8t7rlxiWtoyER6GQKTS1dGM0oOk+/nsugE0ikongzszTqvqiiGwRkRoE39B0A/hWOosic9jb2oP7/3YQ1y6dg6+uKjO6nHGxgZMpNHqCK9CvKk9fhF5V9wBYMc7t69NWBJnSR9KWXzY2bRkJGziZQoPbh8Wl0zAjL9voUog+kracaXDaMhLOwMlw/oBit8eH2kqewIqMZ7a0ZSQJNXARuSsUQd4rIn8QEZ7/k2J2qKMPfUOjPP8JGc6MactI4m7gIjIfwHcB1KrqMgCZAG5NVmHkHC53cP7NU8iSkcyatowk0RFKFoCpIpIFIA9AW+IlWcdrBzrw5mEm8BLV4PahtCAXZUVTjS6FHMysactI4m7gqtoK4FcAjiGYVutR1b+dfz+7xo0Hhv2488km/OC596DK02ckwuX2orYybSewIvqYcNqytsJ8actIEhmhFAH4EoALAMwDkC8it51/P7vGjbc2taJ3cBQt3gF8cLJ/8m+gcbV2D6CtZxCXVXD+TcYYm7Z84BbzpS0jSWSEsg7AUVXtVNURAM8CuDI5ZZmbqmJTvefsS/6/7z9pcEXWdXb+zSNQyCBmT1tGkkgDPwZgjYjkSfC1bx2A/ckpy9waPT7sb+/Fv159EZbNL8C2/R1Gl2RZLrcP+TmZqJoz3ehSyIH2tZk/bRlJIjPwXQD+BGA3gPdCj/VQkuoytU31HkyfkoUbVszD2qpS7D7mg/f0sNFlWVKD24uVFUXIymQkgdIrnLYsNHnaMpKE/mpU9V5VrVLVZaq6XlWHklWYWZ3sHcRL77XjplULkJeThXXVJQgo8PoBjlFi1Ts4goMdfTx8kAzx85cP4FBHP3751UtNnbaMhLs9MfrDOy0YDSjWX1EBAFg2bwZKpufiNTbwmO32+KAKrkBPaTc2bXn1xSVGlxM3NvAYjPgD+P07HnxqcTEumJ0PAMjIENRVl+CNQ50YHg0YXKG1uNw+ZGYIahYUGl0KOYjV0paRsIHH4G/7OtDRO4QNayo+cvvaqlL0D43inaNegyqzJpfHi6XzCpCfy3OqUXqoKn74vLXSlpGwgcdgc70bZUVT8Zmqj77k+sRFs5GblYG/82iUqA2PBtDU0s35N6XV802t+Msea6UtI2EDj9KBE73YddSL29ZUfOxA/6k5mbjqotnYdqCDqcwo7WvrweBIgPNvSpvjvjP4yfPWS1tGwgYepS31HuRmZeCW2gXjfr2uuoSpzBiEV6CvZQKT0iCctgyoWi5tGQkbeBR6B0fw3LutuH75PBRNcLhRXVUpAKYyo+XyeFExKw8lBTwDMaVeOG350y8utVzaMhI28Cg803gcZ4b92HhF5YT3mTNjCpbOYyozGqoKl9vH+TelhdXTlpGwgU8iEFBsqfegZkEhLimL/KZHXTVTmdE42nUap04Pc/5NKWeHtGUkbOCTeOvDLhzpOo2NV1ZMet9wKnP7QY5RIgnPv7kCD6XaL14+aPm0ZSRs4JPY9LYHs/JzcN0lcye9bziVuY1z8IhcHi+K8rKxsHia0aWQjb15uBOPvXUUGyyetoyEDTyCFu8ZvHagA7euXoDcrMkP+GcqMzoutw+rKops93KWzGNs2vL7Fk9bRsIGHsETu44BAL5++eTjkzCmMiPr6h/Cka7TPP83pczYtOWDt1g/bRkJG/gEBkf8eKrhGK5ZUor5hdGv1RhOZW47wKNRxtPoMc/8W0SmiMg7ItIsIvtE5Geh22eKyKsicjj02fhiKWpj05aTHXhgdWzgE3hxTzt8Z0awIcKhg+M5m8rcf5KpzHG43F7kZGWYJcY8BGCtqi4HUAPgWhFZA+AeANtUdRGAbaHrZAF2TFtGwgY+gS31biwszseVC2fF/L111SU45j3DVOY4Gtw+LC+bEdV7CqmmQeFfUnboQxFc63VT6PZNAG5If3UUK39AcbcN05aRsIGPo6mlG83He7Dhisq43mhbGzrZFVOZHzUw7Mfe1h5Tzb9FJFNEmgCcBPBqaKWpUlVtB4DQ53EPYRCR20XEJSKuzs7OtNVM43v4zSPYddSLe22WtoyEDXwcm+vdyM/JxJdXzo/r++fOmMpU5jiaj3djNKCmmH+HqapfVWsAlAFYLSLLYvjeh1S1VlVri4uLU1YjTS6ctvzs0lLcZLO0ZSRs4Oc51T+EF5vb8eWVZZg+JTvux2Eq8+PCK9CvKjfPHniYqnYD2A7gWgAdIjIXAEKf+VLKxMamLf/ry5c66vBUNvDzPOVqwbA/gA1XRH/o4HiYyvy4BrcPi0unYUZe/P8xJpOIFItIYejyVADrABwA8AKAjaG7bQSw1ZACKSp2T1tGwgY+hj+geGLnMVxx4SwsKp2e0GMxlflR/oBit8dnqvk3gLkAXheRPQAaEJyBvwjgPgDXiMhhANeErpMJ7TjcZfu0ZSRcy2qMbfs70No9gB9/IfHkVkaGYG1VCV7c047h0QByspz9f+Whjj70DY2abf69B8CKcW4/BaAu/RVRLJyStozE2V3lPJvrPZg7YwrWVZcm5fHqqpnKDAvPv3kKWUqGcNqyq3/I9mnLSNjAQz442Y8dH3ThG5eXIyszOT8WpjLPaXD7UFqQi7Ki6FOtRBMJpy3vXLfI9mnLSNjAQx7f6UF2puCWy8qT9phMZZ7TGJp/O+kIAUqNsWnLf7n6IqPLMRQbOID+oVE803gcn79kLoqn5yb1sddWMZXZ2j2A1u4BXMb1LylBTkxbRsIGDuC5d1vRNzSK9TGe9yQaddVMZZ6df5vrCBSyoEccmLaMxPENXFWxpd6NZfMLsLK8MOmPH05lvubgObjL7UN+Tiaq5iR2aCY52/ttvfiVA9OWkTi+ge884sWhjn5sWBPfeU+iUVddikaPDz6HpjJdHh9WVhQl7c1hcp7BET/ufOpdR6YtI3H8X9SWnW4U5mXjizXzUvYc4VTm6w5MZfYOjuDAiV4ePkgJCactf+HAtGUkjm7g7T0DeGVfB26uXYAp2ak7jnTZvBkodmgqc7fHB1VwBXqK29i05WccmLaMxNEN/A+7jiGgittiWDItHhkZgroqZ66V6XL7kJkhqFlQaHQpZEFMW0bm2AY+PBrA799pwWcuLkH5rNS/mx1OZTa4nZXKdHm8WDqvAPm5PGsDxUZV8SOmLSNybAN/aW87uvqHEj7rYLTCqcy/O+gc4cOjATS1dGMVj/+mOGxtasOLTFtG5NgGvrneg8pZefjUovSciH9qTiauXDjLUanMfW09GBwJ4DIe/00xOu47gx8/vxerHLK2ZbwSauAiUigifxKRAyKyX0SuSFZhqbS3tQeNHh9uW1OBjDQmueqqSx2VygyvQF/LPXCKwUfSljfX8PDTCBL9yfwGwMuqWgVgOYD9iZeUelvqPZiSnYGbVi1I6/M6LZXZ4PaiYlYeSgqmGF0KWcjYtGU63p+ysrgbuIgUAPgUgEcBQFWHQ8tSmVr3mWFsbW7FjSvmp31lGCelMlUVLreP82+KCdOWsUlkD/xCAJ0A/ltE3hWRR0Qk//w7mW3l7j+6jmNwJID1ayoNeX6npDKPdp3GqdPDnH9T1Ji2jF0iDTwLwEoAv1XVFQBOA7jn/DuZaeXuQECxZacHl1UWYcm8AkNqqKtyRirTFZp/m2kFHjK3X77CtGWsEmngxwEcV9Vdoet/QrChm9YbhzpxzHsmJWcdjNYl852RynS5vSjKy8bC4mlGl0IWsONwFx7dcRTr1zBtGYu4G7iqngDQIiIXh26qA/B+UqpKkc31bhRPz8W1S+cYVkM4lfkPm6cyw/NvvgymyYTTlhcW5+MH1zFtGYtEj0L5PwCeCK3qXQPgPxOuKEU8p05j+6FOfG11ueELDNdVl6LPxqnMU/1DONJ1muf/pkmNTVv+hmnLmCWUb1bVJgC1ySkltR7f6UGmCL5xefKWTIvXVRfNQk4olXnVRbONLifpOP+maIXTlt/7p8VMW8bBEUfIDwz78VRDCz67dA5KTXBMcl5OFq6ycSrT5fYiJysDy+bzD5Im1to9gB9vZdoyEY5o4C80t6J3cDRt5z2Jhp1TmQ1uH5aXzUBuFl8O0/j8AcW/PdWEQIBpy0TY/qemqtj0tgcXl07H6gvMM5MNpzK3HbDX0SgDw37sa+uxxPxbRBaIyOuh00DsE5E7Qrf/VERaRaQp9HGd0bXazdm05fVMWybC9g189zEf3m/vxYYrK0x1REQ4lbnNZmcnbD7ejRG/WmX+PQrgblWtBrAGwLdFZEnoaw+oak3o46/GlWg/H0lb1jJtmQjbN/BNb3swPTcLN9TMN7qUj6mrKrFdKjO8Av3KcvM3cFVtV9Xdoct9CJ7Lx3wbio0wbZlctm7gJ/sG8dLedny1tsyUCwrUVZfaLpXZ4PZhcek0FOZZK0knIpUAVgAIB9O+IyJ7ROQxERn3fyOznSbCCpi2TC5bN/An32nBiF+xfo153rwc62wq0yZzcH9AsfuYzxLz77FEZBqAZwDcqaq9AH4LYCGC2YZ2APeP931mOk2EFbz1AdOWyWbbBj7iD+D3u47hk4tm40KTxrnPpjIP2iOVeaijD32Do1aZfwMARCQbweb9hKo+CwCq2qGqflUNAHgYwGoja7SDnjMjuPtppi2TzbYN/NX3O3CidxAbDDzvSTTWVpXYJpUZnn/XVlhjD1yCA9hHAexX1V+PuX3umLvdCGBvumuzE1XFD59/L7S2ZQ3TlklkvsFwkmyud2N+4VSsrTL3S7VPLJptm1Smy+NDaUEuyoqmGl1KtK4CsB7AeyLSFLrtBwC+JiI1ABSAG8C3jCjOLsamLS8tKzS6HFuxZQM/eKIPO4948R/XViEzjUumxWNsKvMnX1hi6XflXe7g/Nsq/wZV3QFgvGJ52GCSMG2ZWrYcoWzZ6UZOVgZuuSy9S6bFK5zK/LDTuqnM1u4BtHYPcP1LOisQUNz9NNOWqWS7n2jv4Aie3d2K6y+dZ5nDlOywVmZ4/s0VeCjskR1HsPMI05apZLsG/mzjcZwZ9mPjleY8dHA8c2dMxZK51k5lNnp8yM/JRNWc6UaXQiawv70Xv3rlEP5pCdOWqWSrBq6q2LzTg+ULCi33Zsm6amunMhvcPqysKOLLZAqmLZ9swoy8bNz3FaYtU8lWf21vfXAKRzpPY6OJzjoYLSunMnsHR3DgRC9XoCcAwbTlwY4+pi3TwFYNfFO9GzPzc3DdJXMnv7PJWDmVudvjgyrn38S0ZbrZpoEf953Btv0duPWyBZiSbb2gQEaGYO3F1kxlNnp8yMwQ1CwoNLoUMhDTlulnmwb+xK5jAIBvmPS8J9Goq7ZmKrPB7cXSeQWmPGEYpc+Ptu5l2jLNbNHAB0eCS6atqy7F/ELLpAA/Zmwq0ypG/AE0tXRz/u1wW5ta8efmNtxRt8hyBxBYmS0a+F/2tMN7etj05z2ZjBXXytzX1ovBkQDn3w7W2j2AHz0fTFv+y9VMW6aTLRr45p0eXFicj6summV0KQmzWirz3AmsuAfuRExbGsvyP+3mlm40t3RjwxpzLZkWr/DJt6ySymxwe1E+Mw8lBVOMLoUMwLSlsSzfwDfXe5Cfk4mvrLJH2mteoXVSmaoaOoEV976diGlL41m6gXtPD+PPe9pw48r5mD4l2+hyksYqqUz3qTM4dXqY828HCqctC6Zm47++fIktXv1akaUb+FMNLRgeDVj+zcvzhVOZ2w+Ze4zScPYEVtwDd5pfhdKWv7zpUsyalmt0OY5l2QbuDyge3+nBmgtnYnGpvU6gFE5lmn0O7nJ7UZiXjQtnm3PJOkqNtz7owiNMW5qCZRv4awdOorV7ABtttvcNWCeV6XL7UFtRhAyTL5pBycO0pblYtoFvrndjTsEUXLOk1OhSUsLsqcxT/UM40nXacivQU2KYtjQXSzbwDzv78ebhLnzj8nLbHndq9lSmy+MDwPm3kzBtaT6W7H5b6j3IzhTcurrc6FJSxuypTJfbi5ysDCybP8PoUigNwmnLleWFTFuaiOUa+OmhUTzTeBzXXTIXxdPt/e73WhOnMl0eH5aXzUBuFl9G210goPje083BtOUtTFuaieV+E8+924q+oVFssOCiDbGqM2kqc2DYj72tPZx/O8SjO46i/sgp3Hv9UlTMyje6HBrDUg1cVbGl3oOl8wqwstz+s1ezpjKbj3djxK88/4kD7G/vxS9fOci0pUlZqoHvOurFwY4+bLjCHuc9iYYZU5nhE1jxFLL2xrSl+SXcwEUkU0TeFZEXk1FQJFvqPZgxNRtfXD4/1U9lGmZMZbo8PiwunYbCPGuvdygiC0TkdRHZLyL7ROSO0O0zReRVETkc+uzI/6nOpi2/yrSlWSVjD/wOAPuT8DgRnegZxMv7TuDm2jJHHX9qtlSmP6Bo9PjsMv8eBXC3qlYDWAPg2yKyBMA9ALap6iIA20LXHeXtUNrytjXl+EwV05ZmlVADF5EyAJ8H8EhyypnY7985hoAqbrPwkmnxMFsq81BHH/oGR20x/1bVdlXdHbrch+COyHwAXwKwKXS3TQBuMKRAg/ScGcHdfwymLX943RKjy6EIEt0DfxDAvwOYsLOIyO0i4hIRV2dnZ1xPMjwawO93HcPVi4sd+S64mVKZrrMnsLLFHvhZIlIJYAWAXQBKVbUdCDZ5AOPugiZj2zajH2/di86+ITxwM9OWZhd3AxeRLwA4qaqNke6nqg+paq2q1hYXF8f1XC/vO4Gu/iFsuLIyru+3unAqc5sJxigujw+lBbkoK7Lu2qPnE5FpAJ4BcKeq9kb7fcnYts1ma1MrXgilLZcvKDS6HJpEInvgVwH4ooi4ATwJYK2IPJ6Uqs6z+W03Kmbl4dOL7PFHEqu8nCxcuXAWth3oMDyVGVzAYaZtjkgQkWwEm/cTqvps6OYOEZkb+vpcAMb/z5kGTFtaT9wNXFW/r6plqloJ4FYAr6nqbUmrLGRfWw9cHh/Wr6lw9Fnv6qpL4TllbCqzrXsArd0Dtph/A4AE/xd6FMB+Vf31mC+9AGBj6PJGAFvTXVu6MW1pTab/LW2p92BKdgZuWrXA6FIMZYZU5rkTWNlm/n0VgPUIvnpsCn1cB+A+ANeIyGEA14Su21o4bfmT65c48n0mq8pKxoOo6nYA25PxWGP1nBnB802tuKFmPmbk2WfJtHiMTWX+86eNeXnrcnuRn5OJqjn2WEBDVXcAmOhlXV06azHS2LTlzbXO3lGyGlPvgf+xsQWDIwGsd8B5T6JhdCqzwe3DivIivry2kcERP+56imlLqzLtX2IgoNiy04PaiiIsncdTlgLBsxMalcrsHRzBgRO9XIHeZu7/20EcOMG0pVWZtoG/cbgTnlNnuPc9xqUGpjLfPdYNVVvNvx3v7Q+68PCbTFtamWkb+JZ6D2ZPy8Xnls01uhTTMDKV6XJ7kZkhqOGxwbZwNm05m2lLKzNlAz926gxeP3gSX1+9ADlZpizRMOFUpivNqcwGtxdL5hYgPzcp73uTwc6mLbm2paWZsjs+vsuDDBF8/XKOT853bq3M9I1RRvwBNLV0c/5tE0xb2ofpGvjAsB9PNbTgs0tLMWfGFKPLMR0jUpn72noxOBLg/NsG2pi2tBXTNfA/N7ehZ2AEG66oNLoU00p3KjM8rrFLAtOpAgHF3Uxb2oqpfoOqik31biwunYbLL+De3kTSncpscHtRPjMPJQV8RWRlTFvaj6ka+O5j3djX1osNV1QyUBBBOJX5WhoauGp4AQfufVsZ05b2ZKoGvrnejem5WbhxhXOWTItXXXUJXB5vylOZ7lNn0NU/zPm3hTFtaV+maeCdfUP463vt+MqqMh6qFoV0rZXZwPm35TFtaV+maeBPvnMMI35l8jJK6UplutxeFOZlY2HxtJQ+D6XG2x9ybUs7M0UDH/UH8MSuY/jkotlsFFEam8oc8aculeny+FBbUeToc7FbVc+ZEdz9dDMumMW0pV2ZooG/+n4HTvQOYr3DFixO1NrwWplHU5PKPNU/hCOdp+2yAr3jMG1pf6Zo4JvrPZhfOBV11aVGl2Ipn0xxKjO8gAPn39YTTlt+l2lLWzO8gY/4AygpyMX/vKoSmXyZHpNUpzJdbi9ysjJwSRlP52sl4bTlivJC/CvTlrZmeAPPzszAb25dgf/9yQuNLsWSUpnKdHl8WF42A7lZfPltFeG0pT+geJBpS9vjb9fiwqnMbUkeowwM+7G3tYfzb4t57K1g2vJepi0dgQ3c4uYVTkX13IKkN/Dm490Y8Svn3xZy4EQvfvEy05ZOwgZuA+tSkMpsDL2BuYoN3BIGR/y480mmLZ2GDdwGUpHKbHB7sbh0GgrzcpL2mJQ64bTlL756CdOWDsIGbgOXzp+B2dOSl8r0B4InsFpVwfm3FYTTlt+4vBxrq3gorpOwgdtARoZgbVVx0lKZhzr60Dc4ist4BkLT6xkYwfeebkblrHz88PPVRpdDacYGbhN11aVJS2WGAzx2PwOhiDwmIidFZO+Y234qIq0i0hT6uM7IGifzk6170dE3hAdvqUFeDk8C5zRs4DaRzFSmy+1FaUEuyoqmJqEyU/sdgGvHuf0BVa0Jffw1zTVFbWtTK7Y2cW1LJ2MDt4lkpjJdbh9qK2ba/kgGVf0HgNScSCbFmLYkgA3cVs6lMk/H/Rht3QNo7R5w+go83xGRPaERy4Q/CBG5XURcIuLq7OxMW3FMW1IYf/M2svZsKrMj7sdwyvw7gt8CWAigBkA7gPsnuqOqPqSqtapaW1xcnKbyzqUtf/IFpi2djg3cRuYnIZXpcnuRn5OJqjnTk1iZdahqh6r6VTUA4GEAq42uaaxw2nJddSluuYxpS6djA7eZRFOZDW4fVpQXOfZluYjMHXP1RgB7J7pvug2Nnktb/vwrTFsSG7jtJJLK7B0cwcETvY6Zf4vIHwDUA7hYRI6LyDcB/EJE3hORPQA+A+AuQ4sc4/6/HWLakj6CB47aTDiVuW3/Sdy4oiym7333WDcC6pz5t6p+bZybH017IVF4+8MuPPzmEaYt6SO4B24z4VTmG4diT2W63F5kZghqeEyxqTBtSRNhA7ehuupS9A3GnspscHuxZG4B8nP5wsxMwmnLB5i2pPPE3cBFZIGIvC4i+0Vkn4jckczCKH7xpDJH/AE0tXQ7Zv5tFS80t2FrUxu+u3YRXxnRxySyBz4K4G5VrQawBsC3RWRJcsqiRMSTytzX1ovBkYBj5t9W0NY9gB899x5WlBfi259h2pI+Lu4Grqrtqro7dLkPwH4A85NVGCWmrqokplSmyx0ct3AFHnMIBBTf+2MzRpm2pAiSslWISCWAFQB2jfM1Q+LGTre2OnikQrSpTJfbh/KZeSgpmJLKsihKj711FG9/yLQlRZZwAxeRaQCeAXCnqvae/3Wj4sZOF0sqU1Xh8ng5/zYJpi0pWgk1cBHJRrB5P6GqzyanJEqWaFOZ7lNn0NU/zPm3CZxLW2bhPqYtaRKJHIUiCIYe9qvqr5NXEiXL2qoSBBR441Dk0VUD59+mcS5teSlmM21Jk0hkD/wqAOsBrLXK6iVOs7ysMLRWZuQ5eKPbh8K8bCwsnpamymg89R+eYtqSYhJ3KkBVdwDg6zsTC6cyX9p7AiP+ALInOJKhweNFbUURMjL46zRKz8AI7n66iWlLigmPTbK5yVKZp/qHcKTzNFegNxjTlhQPNnCb+8RFkVOZ5xZw4PzbKExbUrzYwG0uPzcLV1w4cSqz0eNDTlYGLimbYUB1xLQlJYIN3AHWVU+cymxwe7G8bAZyszINqMzZxqYtH7iZaUuKHbcYB5golTk44sfe1h7Ovw0yNm1ZOZtpS4odG7gDTJTKbG7pxohfOf82wIETvfjFK0xbUmLYwB0inMrsPnMulRl+A3MVAzxpdTZtOYVpS0oMG7hDhFOZ2w+eS2U2uL1YXDoNhXk5BlbmPExbUrKwgTvE+anMQEDR6PFx/p1m4bTl15m2pCRgA3eI89fKPHSyD32Do5x/p9HYtOWPmLakJGADd5CxqcwGdzjAwz3wdLmXaUtKMm5FDvKJi2YjJzMD2w6cRFf/EEqm56KsaKrRZTnCC81teL6pDXetW8y0JSUNG7iD5Odm4YqFs7Btf0fo8MGZPAIiDZi2pFThCMVh1lWXwH3qDFq7Bxy/Ao+IPCYiJ0Vk75jbZorIqyJyOPQ5oR8S05aUStyaHCacygQ4/wbwOwDXnnfbPQC2qeoiANtC1+MWTlv+mGlLSgE2cIcJpzLzcjJRNWe60eUYSlX/AeD88+x+CcCm0OVNAG6I9/EPnug7m7a8lWlLSgHOwB3oP669GO09g3w5P75SVW0HAFVtF5GSie4oIrcDuB0AysvLP/b1DAEuv2Am05aUMmzgDnT1xRP2JIqBqj4E4CEAqK2t/di5eheVTseWb16e9rrIObgLRvRRHSIyFwBCn8dfCYPIBNjAiT7qBQAbQ5c3AthqYC1EEbGBk2OJyB8A1AO4WESOi8g3AdwH4BoROQzgmtB1IlPiDJwcS1W/NsGX6tJaCFGcuAdORGRRbOBERBbFBk5EZFFs4EREFiWqH8sfpO7JRDoBeCb48mwAXWkrJnlYd3pFqrtCVYvTWUxYhG3bqj9nwLq127HucbfttDbwSETEpaq1RtcRK9adXlar22r1jmXV2p1UN0coREQWxQZORGRRZmrgDxldQJxYd3pZrW6r1TuWVWt3TN2mmYETEVFszLQHTkREMWADJyKyKMMbuIhcKyIHReQDEUlo/cF0Gm9BXCsQkQUi8rqI7BeRfSJyh9E1RUNEpojIOyLSHKr7Z0bXNBlu2+nj1O3a0Bm4iGQCOITgaTuPA2gA8DVVfd+woqIkIp8C0A9gs6ouM7qeaIUWKZirqrtFZDqARgA3mP1nLsE1yfJVtV9EsgHsAHCHqu40uLRxcdtOL6du10bvga8G8IGqHlHVYQBPIriorOlNsCCu6alqu6ruDl3uA7AfwHxjq5qcBvWHrmaHPsz8Djy37TRy6nZtdAOfD6BlzPXjsMAP3S5EpBLACgC7DC4lKiKSKSJNCC5z9qqqmrlubtsGcdJ2bXQDH2+pbjPvVdmGiEwD8AyAO1W11+h6oqGqflWtAVAGYLWImPnlPbdtAzhtuza6gR8HsGDM9TIAbQbV4hihWdszAJ5Q1WeNridWqtoNYDuAa42tJCJu22nmxO3a6AbeAGCRiFwgIjkAbkVwUVlKkdCbJo8C2K+qvza6nmiJSLGIFIYuTwWwDsABQ4uKjNt2Gjl1uza0gavqKIDvAHgFwTcdnlbVfUbWFK0JFsS1gqsArAewVkSaQh/XGV1UFOYCeF1E9iDYHF9V1RcNrmlC3LbTzpHbNaP0REQWZfQIhYiI4sQGTkRkUWzgREQWxQZORGRRbOBERBbFBk5EZFFs4EREFvX/AQakEqag8CvOAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#plot 1:\n",
    "x = [0, 1, 2, 3]\n",
    "y = [3, 8, 1, 10]\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(x,y)\n",
    "\n",
    "#plot 2:\n",
    "x = [0, 1, 2, 3]\n",
    "y = [10, 20, 30, 40]\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(x,y)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "840fadd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = [\"A\", \"B\", \"C\", \"D\"]\n",
    "y = [3, 8, 1, 10]\n",
    "\n",
    "plt.bar(x,y)\n",
    "plt.show()"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}