diff --git a/UG_Minor_2023_Basics_of_Python.ipynb b/UG_Minor_2023_Basics_of_Python.ipynb new file mode 100644 index 0000000..7dcf37d --- /dev/null +++ b/UG_Minor_2023_Basics_of_Python.ipynb @@ -0,0 +1,2092 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Getting Started\n", + "\n", + "FMML Module 1, Lab 1
\n", + " Module Coordinator: Amit Pandey ( amit.pandey@research.iiit.ac.in )
\n", + " Release date: Aug 2022
\n", + "\n" + ], + "metadata": { + "id": "TMVRKfbpTAeR" + } + }, + { + "cell_type": "markdown", + "source": [ + "### In this notebook we will be covering the very basics of Python and some basic libraries such as Numpy, Matplotlib and Nltk.\n", + "#### It is suggested that you go through each line and try some examples." + ], + "metadata": { + "id": "F-XjWYLBTI0f" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Section 1 - Python : Basic data types and indexing." + ], + "metadata": { + "id": "wEyEnIhnTdhB" + } + }, + { + "cell_type": "code", + "source": [ + "## Strings\n", + "'''\n", + "A string is a collection of one or more characters put in a single quote,\n", + " double-quote or triple quote. In python there is no character data type,\n", + " a character is a string of length one. It is represented by str class.\n", + "\n", + "String can have special characters. String can be indexed\n", + "\n", + "'''\n", + "\n", + "\n", + "name = 'First Lab'\n", + "name_extended = name + 'Module 1'\n", + "last_element_string = name[-1] # -1 in python is index of the last element.\n", + "## indexing is important for preprocessing of the raw data." + ], + "metadata": { + "id": "AzguFJmTQIqt" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(name ,\"\\n\", name_extended, \"\\n\", last_element_string)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DPokcpuLQO6s", + "outputId": "5241dfe9-ad74-44f8-86bd-414aef1e1b13" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "First Lab \n", + " First LabModule 1 \n", + " b\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "## List\n", + "\n", + "'''\n", + "Lists are ordered collection of data, and are very similar to arrays,\n", + "It is very flexible as the items in a list do not need to be of the same type.\n", + "'''\n", + "\n", + "name_list = ['First Lab', 3 , '1.1' , 'Lab 1'] ## notice elements are of different data type.\n", + "name_list.extend(['Module 1']) ## adding elements to list (Read about append method as well).\n", + "element_2 = name_list[1] ## Just like other languages, the index starts from 0.\n", + "two_dimesional_list = [[1,2],[3,4]] ## practice with multi-dimensional lists and arrays\n", + "## you would soon be required to handle 4 dimensional data :p :)\n", + "name_list[2] = '1.111' ##list elements can be changed" + ], + "metadata": { + "id": "g7WZtwkpE2tO" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(name_list)\n", + "print(element_2)\n", + "print(two_dimesional_list)\n", + "## list can have list, dictionary, string etc." + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vblBrQflE9Cs", + "outputId": "19b44b31-914f-4599-f40c-e0f320f437fc" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['First Lab', 3, '1.111', 'Lab 1', 'Module 1']\n", + "3\n", + "[[1, 2], [3, 4]]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "## Tuples\n", + "\n", + "name_tuple = ('First Lab', 1, (2,3),[1,1,'list having string']) ## A tuple can have a tuple.\n", + "\n", + "print(name_tuple[2])\n", + "print(\"first indexing the last element of the tuple, which is a list and \\n then last element of the list (a string) and then second last element of the string:\")\n", + "print(name_tuple[-1][-1][-2])\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "x5eOXNK5FtlF", + "outputId": "285bbce1-d201-426f-ea69-a4c2bfeba7c1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2, 3)\n", + "first indexing the last element of the tuple, which is a list and \n", + " then last element of the list (a string) and then second last element of the string:\n", + "n\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "## tuples are immutable, read the error !\n", + " #usued when passing parameters etc. and dont want them to be changed\n", + "\n", + "name_tuple[1] = 2" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 202 + }, + "id": "m92Oab8YRha1", + "outputId": "37950885-a207-4bcf-a915-26ff813f69e1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m## tuples are immutable, read the error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mname_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "## Sets\n", + "'''a Set is an unordered collection of data types that is iterable, mutable and has no duplicate elements.\n", + "The order of elements in a set is undefined though it may consist of various elements.\n", + "The major advantage of using a set, as opposed to a list,\n", + " is that it has a highly optimized method for checking whether a specific element is contained in the set.\n", + "'''\n", + "set_unique = set([1,1,2,3,5,6,'Lab1'])\n", + "print(set_unique) ##notice it is unordered\n", + "last_el = set_unique.pop()\n", + "set_unique.add((1,2))\n", + "\n", + "\n", + "print(last_el)\n", + "print(set_unique)\n", + "\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "MfkMO0mlTcep", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a3fc45c0-fec6-487c-b8fa-40c2ca4013d9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'Lab1', 1, 2, 3, 5, 6}\n", + "Lab1\n", + "{(1, 2), 1, 2, 3, 5, 6}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "set_unique[1] ##it is not indexable" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 166 + }, + "id": "QgHlNSRPampd", + "outputId": "eaf861ab-4341-4109-b56f-ed45b8dc7522" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mset_unique\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'set' object is not subscriptable" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "## Dictionary\n", + "'''\n", + "Dictionary in Python is an unordered collection of data values, used to store data values like a map,\n", + " which, unlike other data types which hold only a single value as an element.\n", + "'''\n", + "\n", + "dic = {'1': 'A','2':'B', 'C':3 } ##Observe how key and values can be anything\n", + "dic['4'] ='New'\n", + "print(dic)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rxhE3hYtZxVb", + "outputId": "3f21c392-6b7d-4d14-dd9d-9a614eed40be" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'1': 'A', '2': 'B', 'C': 3, '4': 'New'}\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Question 0:\n", + "###### write down 3-5 methods applicable to each data type. (Hint: extend, reverse, etc." + ], + "metadata": { + "id": "hizs_paeceA5" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Section 2 - Functions\n", + "### a group of related statements that performs a specific task." + ], + "metadata": { + "id": "tub_Skp3X1cN" + } + }, + { + "cell_type": "code", + "source": [ + "def add_new(a:str, b): ## a and b are the arguments that are passed. to provide data type hint\n", + " # def add_new(x: float, y: float) -> float:\n", + " sum = a + b\n", + " return sum\n", + "\n", + "ans = add_new(1,2) ## intentionally written str, and passed int, to show it doesn't matter. It is just hint\n", + "print(ans)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "K-6Q5T8nX_YF", + "outputId": "06cbd1d2-4766-4b81-95a3-9e41556d7be0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "3\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "asn = add_new()" + ], + "metadata": { + "id": "aVLU3Bpu0YJV" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def check_even_list(num_list):\n", + "\n", + " even_numbers = []\n", + "\n", + " # Go through each number\n", + " for number in num_list:\n", + " # Once we get a \"hit\" on an even number, we append the even number\n", + " if number % 2 == 0:\n", + " even_numbers.append(number)\n", + " # Don't do anything if its not even\n", + " else:\n", + " pass\n", + " # Notice the indentation! This ensures we run through the entire for loop\n", + " return even_numbers" + ], + "metadata": { + "id": "aRa47XCsZLsh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Question 1 :\n", + "\n", + "##### Define a function, which takes in two strings A and B. Reverses the first string A, adds it to B, and returns the final string.\n", + "\n", + "\n", + "#### Question 2 :\n", + "##### Given a list having Names, work_hours, and gender, Write a function to print name of the female worker that worked the most hours. Also how much do should she be paid if the pay is $ 20 per hour.\n", + "\n", + "##### work_hours = [('Abby',100 , 'F'),('Billy',400, 'M'),('Cassie',800,'F'), ('Maggi',600,'F'),('Alex',500,'M'),('Raj',225,'M'),('Penny',920,'F'),('Ben',300,'M')]\n", + "\n", + "##### Answer : the female worker that worked the most hours is Penny and she should be paid 18400" + ], + "metadata": { + "id": "heD0_u4D01jp" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Section 3 - Libraries and Reading data." + ], + "metadata": { + "id": "T9fGzOAKXhtt" + } + }, + { + "cell_type": "markdown", + "source": [ + "##### Numpy - One of the most used libraries - supports for large, multi-dimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays." + ], + "metadata": { + "id": "TKVyOsBKYZXa" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np" + ], + "metadata": { + "id": "_ODaZ44RXkyg" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + "a = np.array([1,1,2,3,4,5,5,6,1]) ## np.array converts given list to array\n", + "\n", + "b = a>1 ## important comparison operation, where frequently used in manipulation and image processing.\n", + "\n", + "print(b)\n", + "print(a[b]) ## [printing only those values in a which are greater than 1]\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "29vs7Iicavlg", + "outputId": "33aa6551-b6c4-4806-f1e7-604383c7a30d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[False False True True True True True True False]\n", + "[2 3 4 5 5 6]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "a_range = np.arange(10,19).reshape(3,3) ## create a 3x3 array with values in range 10-19\n", + "a_range\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MAGJJ1K_jCHN", + "outputId": "4561eb1d-5401-48d1-9e19-d5b5490ea5e9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[10, 11, 12],\n", + " [13, 14, 15],\n", + " [16, 17, 18]])" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## Indexing in arrays works same as that of list\n", + "\n", + "a_range[0] # printing all the columns of first row" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BpNpo-eDt9Fr", + "outputId": "69574bc2-5229-4cf8-eafa-5ac70642f838" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([10, 11, 12])" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "source": [ + "a_range[:,2] #printing all the rows of second column" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HbDG7M3QuCDQ", + "outputId": "09459c12-a940-4908-eceb-cb5499d71bfa" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([12, 15, 18])" + ] + }, + "metadata": {}, + "execution_count": 58 + } + ] + }, + { + "cell_type": "code", + "source": [ + "iden = np.eye(3) #idnetity matrix of given size\n", + "iden" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RQ7UV_-fjJw3", + "outputId": "784d4b89-bdf1-4bbd-8584-ddef9c6ead92" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[1., 0., 0.],\n", + " [0., 1., 0.],\n", + " [0., 0., 1.]])" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## adding two matrices\n", + "summed = a_range + iden\n", + "summed\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hYJXXvnwjPfE", + "outputId": "7e7d6bcc-8ecc-4a74-ec1f-87de5c43fbda" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[11., 11., 12.],\n", + " [13., 15., 15.],\n", + " [16., 17., 19.]])" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "source": [ + "### arrays support normal matrix multiplication that you are used to, point-wise multiplication\n", + "### and dot product as well.\n", + "\n", + "mul = a_range@iden ## normal multiplication\n", + "mul\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VoyeEptRjYRu", + "outputId": "ba301768-c6e5-49ed-c61f-f39a10df2a97" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[10., 11., 12.],\n", + " [13., 14., 15.],\n", + " [16., 17., 18.]])" + ] + }, + "metadata": {}, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## point wise multiplication\n", + "p_mul = a_range * iden\n", + "p_mul" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "58S3a_YmtAe8", + "outputId": "14ebfbe9-f186-4379-caa7-65e3f89c5977" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[10., 0., 0.],\n", + " [ 0., 14., 0.],\n", + " [ 0., 0., 18.]])" + ] + }, + "metadata": {}, + "execution_count": 18 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## Transpose of a matrix.\n", + "\n", + "mtx_t = mul.T\n", + "mtx_t\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HC5uJ03ftJHA", + "outputId": "fb6a9ba4-cd8b-496c-8459-6fd4897f0c87" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[10., 13., 16.],\n", + " [11., 14., 17.],\n", + " [12., 15., 18.]])" + ] + }, + "metadata": {}, + "execution_count": 19 + } + ] + }, + { + "cell_type": "code", + "source": [ + "### Here we are changing the values of last row of the transposed matrix.\n", + "### basically point wise multiplying the values of last row with 1,2 and 3\n", + "\n", + "mtx_t[2] = mtx_t[2]*[1,2,3] ## indexing, point wise multiplication and mutation of values\n", + "mtx_t" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ROFhfs2lutat", + "outputId": "5f0d0e66-2679-4250-c5ca-0c5fdcad7f31" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[10., 13., 16.],\n", + " [11., 14., 17.],\n", + " [12., 30., 54.]])" + ] + }, + "metadata": {}, + "execution_count": 20 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## Just like the greater than 1 (a>1) example we saw earlier.\n", + "## here we are checking if the elements are divisible by 2 (%), and if they are, then replace by 0.\n", + "\n", + "mtx_t[(mtx_t % 2 == 0)] = 0 ## convert even elements of the matrix to zero.\n", + "mtx_t" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Mh80ju2xvAqL", + "outputId": "0f134f2e-3ec8-4ca5-dc70-a3f992e4ce15" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 0., 13., 0.],\n", + " [11., 0., 17.],\n", + " [ 0., 0., 0.]])" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Question 3 :\n", + "\n", + "##### a)Create a 5x5 matrix of the following form,\n", + "\n", + "##### [[1,1]\n", + "##### [2,2]]\n", + "\n", + "##### i.e. each row is increasing and has repetive elements.\n", + "\n", + "###### Hint : you can use hstack, vstack etc.\n", + "\n", + "##### b) find dot product of the matrix with any matrix. (Figure out the size/ shape of the matrix)" + ], + "metadata": { + "id": "uqWUH6Rv4OhT" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Reading Files" + ], + "metadata": { + "id": "GzNoCosKdVa2" + } + }, + { + "cell_type": "code", + "source": [ + "## loading from the google drive\n", + "from google.colab import drive\n", + "drive.mount('/content/gdrive')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_wCHdrtQwDJe", + "outputId": "b3fbb284-b8ff-43b7-ca34-49d9c4890f29" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/gdrive\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "with open ('/content/sample_data/README.md', 'r') as f:\n", + " a = f.readlines()\n", + "\n", + "a ## here a is list of elements/strings each splitted at \\n, \\n is also part of the list element.\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c1rzXSJobLku", + "outputId": "7a2e058e-01bb-482f-f014-153aaa581b7c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['This directory includes a few sample datasets to get you started.\\n',\n", + " '\\n',\n", + " '* `california_housing_data*.csv` is California housing data from the 1990 US\\n',\n", + " ' Census; more information is available at:\\n',\n", + " ' https://developers.google.com/machine-learning/crash-course/california-housing-data-description\\n',\n", + " '\\n',\n", + " '* `mnist_*.csv` is a small sample of the\\n',\n", + " ' [MNIST database](https://en.wikipedia.org/wiki/MNIST_database), which is\\n',\n", + " ' described at: http://yann.lecun.com/exdb/mnist/\\n',\n", + " '\\n',\n", + " '* `anscombe.json` contains a copy of\\n',\n", + " \" [Anscombe's quartet](https://en.wikipedia.org/wiki/Anscombe%27s_quartet); it\\n\",\n", + " ' was originally described in\\n',\n", + " '\\n',\n", + " \" Anscombe, F. J. (1973). 'Graphs in Statistical Analysis'. American\\n\",\n", + " ' Statistician. 27 (1): 17-21. JSTOR 2682899.\\n',\n", + " '\\n',\n", + " ' and our copy was prepared by the\\n',\n", + " ' [vega_datasets library](https://github.com/altair-viz/vega_datasets/blob/4f67bdaad10f45e3549984e17e1b3088c731503d/vega_datasets/_data/anscombe.json).\\n']" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "\n", + "df = pd.read_csv('/content/sample_data/california_housing_test.csv','r')\n", + "df.head(10) ## pass as argument number of top elements you wish to print. Head is used to have a quick glance and understand the data." + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 363 + }, + "id": "CgXsQFpobVGk", + "outputId": "f8026768-aada-4e5d-c660-e1cca88875c5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
longitude,\"latitude\",\"housing_median_age\",\"total_ooms\",\"total_bedooms\",\"population\",\"households\",\"median_income\",\"median_house_value\"
0-122.050000,37.370000,27.000000,3885.000000,66...NaNNaN
1-118.300000,34.260000,43.000000,1510.000000,31...NaNNaN
2-117.810000,33.780000,27.000000,3589.000000,50...NaNNaN
3-118.360000,33.820000,28.000000,67.000000,15.0...NaNNaN
4-119.670000,36.330000,19.000000,1241.000000,24...NaNNaN
5-119.560000,36.510000,37.000000,1018.000000,21...NaNNaN
6-121.430000,38.630000,43.000000,1009.000000,22...NaNNaN
7-120.650000,35.480000,19.000000,2310.000000,47...NaNNaN
8-122.840000,38.400000,15.000000,3080.000000,61...NaNNaN
9-118.020000,34.080000,31.000000,2402.000000,63...NaNNaN
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " longitude,\"latitude\",\"housing_median_age\",\"total_ ... ooms\",\"population\",\"households\",\"median_income\",\"median_house_value\"\n", + "0 -122.050000,37.370000,27.000000,3885.000000,66... ... NaN \n", + "1 -118.300000,34.260000,43.000000,1510.000000,31... ... NaN \n", + "2 -117.810000,33.780000,27.000000,3589.000000,50... ... NaN \n", + "3 -118.360000,33.820000,28.000000,67.000000,15.0... ... NaN \n", + "4 -119.670000,36.330000,19.000000,1241.000000,24... ... NaN \n", + "5 -119.560000,36.510000,37.000000,1018.000000,21... ... NaN \n", + "6 -121.430000,38.630000,43.000000,1009.000000,22... ... NaN \n", + "7 -120.650000,35.480000,19.000000,2310.000000,47... ... NaN \n", + "8 -122.840000,38.400000,15.000000,3080.000000,61... ... NaN \n", + "9 -118.020000,34.080000,31.000000,2402.000000,63... ... NaN \n", + "\n", + "[10 rows x 3 columns]" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "source": [ + "len(df.columns), df.columns" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iMMaPe3gduKb", + "outputId": "f6dc3cb8-6c33-48f7-f15c-bb691b593821" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(3,\n", + " Index(['longitude,\"latitude\",\"housing_median_age\",\"total_', 'ooms\",\"total_bed',\n", + " 'ooms\",\"population\",\"households\",\"median_income\",\"median_house_value\"'],\n", + " dtype='object'))" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "code", + "source": [ + "df.columns[0]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "GT1dA9Q3eRQU", + "outputId": "5514ad00-df53-44e0-beb5-99775e8174de" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'longitude,\"latitude\",\"housing_median_age\",\"total_'" + ] + }, + "metadata": {}, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "source": [ + "df['longitude,\"latitude\",\"housing_median_age\",\"total_'][:5]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oEZhq9rBe-Hb", + "outputId": "ddfb73be-f5c4-44ca-8e34-117a4b47562c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 -122.050000,37.370000,27.000000,3885.000000,66...\n", + "1 -118.300000,34.260000,43.000000,1510.000000,31...\n", + "2 -117.810000,33.780000,27.000000,3589.000000,50...\n", + "3 -118.360000,33.820000,28.000000,67.000000,15.0...\n", + "4 -119.670000,36.330000,19.000000,1241.000000,24...\n", + "Name: longitude,\"latitude\",\"housing_median_age\",\"total_, dtype: object" + ] + }, + "metadata": {}, + "execution_count": 38 + } + ] + }, + { + "cell_type": "code", + "source": [ + "df = df.rename(columns = {'longitude,\"latitude\",\"housing_median_age\",\"total_':'Detail1'}) ##rename column names as at times it makes it easier for us" + ], + "metadata": { + "id": "-hpbslfWfwy3" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df.head(3)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 143 + }, + "id": "C0gpXPf1hN5Q", + "outputId": "47fbd865-7d9c-4d54-c9b1-6e3e9db64eb3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Detail1ooms\",\"total_bedooms\",\"population\",\"households\",\"median_income\",\"median_house_value\"
0-122.050000,37.370000,27.000000,3885.000000,66...NaNNaN
1-118.300000,34.260000,43.000000,1510.000000,31...NaNNaN
2-117.810000,33.780000,27.000000,3589.000000,50...NaNNaN
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Detail1 ... ooms\",\"population\",\"households\",\"median_income\",\"median_house_value\"\n", + "0 -122.050000,37.370000,27.000000,3885.000000,66... ... NaN \n", + "1 -118.300000,34.260000,43.000000,1510.000000,31... ... NaN \n", + "2 -117.810000,33.780000,27.000000,3589.000000,50... ... NaN \n", + "\n", + "[3 rows x 3 columns]" + ] + }, + "metadata": {}, + "execution_count": 40 + } + ] + }, + { + "cell_type": "code", + "source": [ + "df.iloc[:5, 0] ##iloc - index - 0 to 4 rows and first column only." + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A0FFUn-ghP1n", + "outputId": "161adc0a-69ae-4a53-e7b7-edf91a8c4f4e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 -122.050000,37.370000,27.000000,3885.000000,66...\n", + "1 -118.300000,34.260000,43.000000,1510.000000,31...\n", + "2 -117.810000,33.780000,27.000000,3589.000000,50...\n", + "3 -118.360000,33.820000,28.000000,67.000000,15.0...\n", + "4 -119.670000,36.330000,19.000000,1241.000000,24...\n", + "Name: Detail1, dtype: object" + ] + }, + "metadata": {}, + "execution_count": 41 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import matplotlib\n", + "from matplotlib import pyplot as plt" + ], + "metadata": { + "id": "oJ7JrZqWioIO" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "xpoints = np.array([1, 8])\n", + "ypoints = np.array([3, 10])\n", + "\n", + "plt.plot(xpoints, ypoints)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "tzunFbpUxKAP", + "outputId": "8c0572dc-8832-4eda-ee70-e438d30b1d0b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "xpoints = np.array([1, 2, 6, 8])\n", + "ypoints = np.array([3, 8, 1, 10])\n", + "\n", + "plt.plot(xpoints, ypoints)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "p7l83i5SxW4k", + "outputId": "db30f2a7-289c-4fbf-bd92-43e4c874ae73" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Creating a dataframe.\n", + "#### Task: Study about other methods of creating dataframe (for example: using Pandas Series, Lists etc.)" + ], + "metadata": { + "id": "GT6yXu7l1gtL" + } + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np" + ], + "metadata": { + "id": "1vR1hTJ51ckl" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "values = np.arange(16).reshape(4,4)\n", + "values" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o0W0z3Fr1gOb", + "outputId": "9242f716-42cb-4f5d-a30b-54e263054122" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7],\n", + " [ 8, 9, 10, 11],\n", + " [12, 13, 14, 15]])" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "dataframe_from_array = pd.DataFrame(values, index = ['a','b','c','d'], columns=['w','x','y','z'] )\n", + "dataframe_from_array" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 175 + }, + "id": "_p5vKhPN2Bey", + "outputId": "d10b4d3c-56d8-47b0-de70-c2b6fa98ccde" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " w x y z\n", + "a 0 1 2 3\n", + "b 4 5 6 7\n", + "c 8 9 10 11\n", + "d 12 13 14 15" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
wxyz
a0123
b4567
c891011
d12131415
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ] + }, + "metadata": {}, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "source": [ + "dataframe_from_array.loc[['a','b'],['w','x']]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 112 + }, + "id": "jdIORDyX2h-Z", + "outputId": "0e33c053-b6f5-43c3-d917-b35217f81665" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " w x\n", + "a 0 1\n", + "b 4 5" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
wx
a01
b45
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ] + }, + "metadata": {}, + "execution_count": 6 + } + ] + }, + { + "cell_type": "code", + "source": [ + "dataframe_from_array.iloc['a'] ## it needs position as integer" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 311 + }, + "id": "iPTlROGv2r7M", + "outputId": "32f6cfa4-ea28-41de-ecd7-9e2a2af7c564" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdataframe_from_array\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 929\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 930\u001b[0m \u001b[0mmaybe_callable\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_if_callable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 931\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_axis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmaybe_callable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 932\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 933\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_is_scalar_access\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m_getitem_axis\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m 1561\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mitem_from_zerodim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1562\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1563\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Cannot index by location index with a non-integer key\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1564\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1565\u001b[0m \u001b[0;31m# validate the location\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: Cannot index by location index with a non-integer key" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "dataframe_from_array.iloc[1,3] #second row and last column" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PI4cRSO526jo", + "outputId": "2ba8878e-166b-44c1-8e62-94789e0d6f51" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "7" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "source": [ + "dataframe_from_array.iloc[::2,::2]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 112 + }, + "id": "-BpY8Prl3GQX", + "outputId": "173191ad-f956-4477-a440-8eba89bb75f3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " w y\n", + "a 0 2\n", + "c 8 10" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
wy
a02
c810
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "ys = 200 + np.random.randn(100)\n", + "x = [x for x in range(len(ys))]\n", + "\n", + "plt.plot(x, ys, '-')\n", + "plt.fill_between(x, ys, 195, where=(ys > 200), facecolor='g', alpha=0.6)\n", + "\n", + "plt.title(\"Sample Visualization\")\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + }, + "id": "fqzrScL-GrZU", + "outputId": "b2e971b2-4fca-477b-e121-6a116815f38c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "## Question 3 : Upload an image to your google drive, Use plt.imread to read image from the google drive and then print that image using plt.imshow\n", + "\n", + "\n", + "## Answer 3 :\n", + "\n", + "## 1) make sure drive is loaded and then upload a test image onto your drive\n" + ], + "metadata": { + "id": "mC8rNbeKxiaF" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/sakshi kadu.ipynb b/sakshi kadu.ipynb new file mode 100644 index 0000000..08f58e3 --- /dev/null +++ b/sakshi kadu.ipynb @@ -0,0 +1,1172 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_fJLfdEpHP9d", + "outputId": "ff96b290-9ab5-4952-ea33-38e4135f12a2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cloning into 'Machine-Learning-Simplified'...\n", + "remote: Enumerating objects: 23, done.\u001b[K\n", + "remote: Counting objects: 100% (19/19), done.\u001b[K\n", + "remote: Compressing objects: 100% (13/13), done.\u001b[K\n", + "remote: Total 23 (delta 5), reused 19 (delta 5), pack-reused 4\u001b[K\n", + "Receiving objects: 100% (23/23), 27.32 KiB | 3.90 MiB/s, done.\n", + "Resolving deltas: 100% (5/5), done.\n" + ] + } + ], + "source": [ + "!git clone https://github.com/IEEE-CISCodeCraft/Machine-Learning-Simplified.git" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "91bMnvq8oqbp" + }, + "source": [ + "#Replace the None instances pesent in the code." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "6DNQ2HHJHjYZ" + }, + "outputs": [], + "source": [ + "!cp \"/content/Machine-Learning-Simplified/Day-1/LRTestCases.py\" \"/content/\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dG5rIH8KHUOT" + }, + "outputs": [], + "source": [ + "from LRTestCases import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1tOdDoSwZeIE" + }, + "outputs": [], + "source": [ + "def error(yhat, y):\n", + " error = yhat-y #Subtract y from yhat\n", + " return error" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "D7yM32C_Xz-g", + "outputId": "619b2be0-4236-40cc-a2fa-fb05008b54dc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_error_function(error)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Nnoygph2er5y" + }, + "outputs": [], + "source": [ + "def error_square(error):\n", + " square = error_calculated ** 2 #Square the error claculated above\n", + " return square" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MHGCiEXJX_AR", + "outputId": "dedd1d03-d4c8-46a1-e145-cbf40b0d2d6b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_error_function(error)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wgwOEQK9fMqA" + }, + "outputs": [], + "source": [ + "def total_squared_error(error, num):\n", + " total_squared_error = 0\n", + " for i in range(num):\n", + " total_squared_error = error + total_squared_error #Add the \"error\" to the \"total_sqared_error\"\n", + " return total_squared_error" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ilzjasT4YJAh", + "outputId": "874c4c1b-32b5-4e6e-f258-92eb1163d2b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_total_squared_error_function(total_squared_error)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oS7bM8mBjJ-u" + }, + "source": [ + "$\\text{Mean Squared Error}=\\frac{1}{2*m}\\sum\\limits_{i = 0}^{m-1}(y-ŷ)^2$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Q6sFN7i2piR8" + }, + "outputs": [], + "source": [ + "def mse(total_squared_error, num):\n", + " denominator = num*2 #Multipy num with 2\n", + " mse = total_squared_error/denominator #Divide \"total_sqaured_error\" by \"denominator\"\n", + " return num" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fZ816KtRYsoj", + "outputId": "93bc6f50-36e4-44ce-d8b1-be1dd8bf0e4a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_mse_function(mse)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3Uqj2E0BlU_U" + }, + "source": [ + "**Finding the predicted value**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oiwBU-fSjp5C" + }, + "outputs": [], + "source": [ + "def predicted_value(w, x, b):\n", + " yhat = w*x+b #Multiply 'w' with 'x' and add 'b'\n", + " return yhat" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MXs2kadnreTF", + "outputId": "3857049c-da81-4ba8-9d3b-18c3edcd5441" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_predicted_value(predicted_value)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qW9qAdiUwOrk" + }, + "source": [ + "## Cost Function\n", + "The equation for cost with one variable is:\n", + "$$J(w,b) = \\frac{1}{2m} \\sum\\limits_{i = 0}^{m-1} (ŷ - y^{(i)})^2$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RCCqRXf-wNoI" + }, + "outputs": [], + "source": [ + "def compute_cost(x, y, w, b):\n", + " # number of training examples\n", + " m = x.shape[0]\n", + " total_squared_error = 0\n", + " for i in range(m):\n", + " yhat = w * x[i] + b\n", + " error = yhat-y[i] #Subtract \"y[i]\" from \"yhat\"\n", + " squared_error = error ** 2 #Square the error\n", + " total_squared_error = error + total_squared_error #Add the \"error\" to the \"total_sqared_error\"\n", + " denominator = m*2 #Multiply m by 2\n", + " total_cost = total_squared_error / denominator #Divide total_cost by denominator\n", + " return total_cost" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OGswOCVFzR7W" + }, + "source": [ + "# Gradient Descent\n", + "## 1. Compute Gradient\n", + "The gradient is defined as:\n", + "$$\n", + "\\begin{align}\n", + "\\frac{\\partial J(w,b)}{\\partial w} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (ŷ - y^{(i)})x^{(i)} \\\\\n", + " \\frac{\\partial J(w,b)}{\\partial b} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (ŷ - y^{(i)}) \\\\\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VMBk0PnA0wK3" + }, + "outputs": [], + "source": [ + "def compute_gradient(x, y, w, b):\n", + " # Number of training examples\n", + " m = x.shape[0]\n", + " dj_dw = 0\n", + " dj_db = 0\n", + "\n", + " for i in range(m):\n", + " yhat = w * x[i] + b\n", + " dj_dw_i = (yhat - y[i]) * x[i]\n", + " dj_db_i = yhat - y[i]\n", + " dj_db += dj_db_i\n", + " dj_dw += dj_dw_i\n", + " dj_dw = dj_dw / m\n", + " dj_db = dj_db / m\n", + "\n", + " return dj_dw, dj_db" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3U-qZNSFE1QK", + "outputId": "deb5e7b2-ee3d-4249-9f2e-3ee3470d8a4d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "test_compute_gradient(compute_gradient)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AhWGXBq82p6P" + }, + "source": [ + "## 2. Update the parameters num_iterations times\n", + "$$\\begin{align*} \\text{repeat}&\\text{ until convergence:} \\; \\lbrace \\newline\n", + "\\; w &= w - \\alpha \\frac{\\partial J(w,b)}{\\partial w} \\; \\newline\n", + " b &= b - \\alpha \\frac{\\partial J(w,b)}{\\partial b} \\newline \\rbrace\n", + "\\end{align*}$$\n", + "where, parameters $w$, $b$ are updated simultaneously." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OlNwBvu52cUv" + }, + "outputs": [], + "source": [ + "def gradient_descent(x, y, learning_rate, num_iterations):\n", + " # Initialize weights and bias\n", + " w = 0\n", + " b = 0\n", + " # Number of training examples\n", + " m = x.shape[0]\n", + " for _ in range(num_iterations):\n", + " # Compute gradients using the compute_gradient function\n", + " dj_dw, dj_db = compute_gradient(x, y, w, b)\n", + "\n", + " # Update weights and bias\n", + " w = w - learning_rate * dj_dw\n", + " b = b - learning_rate * dj_db\n", + " # Compute the cost for monitoring\n", + " cost = compute_cost(x, y, w, b)\n", + " print(f'Iteration {_+1}/{num_iterations}, Cost: {cost:.6f}')\n", + " return w, b" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dpmvXbs4lmHO", + "outputId": "59c057d6-d2fa-4301-da22-928ac1a0ec8e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 1/10, Cost: -1.782000\n", + "Iteration 2/10, Cost: -1.589760\n", + "Iteration 3/10, Cost: -1.420232\n", + "Iteration 4/10, Cost: -1.270730\n", + "Iteration 5/10, Cost: -1.138884\n", + "Iteration 6/10, Cost: -1.022606\n", + "Iteration 7/10, Cost: -0.920053\n", + "Iteration 8/10, Cost: -0.829601\n", + "Iteration 9/10, Cost: -0.749820\n", + "Iteration 10/10, Cost: -0.679447\n", + "Final parameters: w = 0.7955, b = 0.2545\n", + "Final cost: -0.679447\n", + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "test_gradient_descent(gradient_descent, compute_cost, compute_gradient)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NknHm9DGGonf" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_Vb4kNxkG_Ml" + }, + "source": [ + "# **Project:** Melanoma Tumor Size Prediction" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ibTpczTtGokE" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.metrics import mean_squared_error, mean_absolute_error\n", + "from sklearn.model_selection import train_test_split\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "eqAMMJ9lGohp" + }, + "outputs": [], + "source": [ + "#Read the dataset\n", + "data = pd.read_csv('/content/Machine-Learning-Simplified/Day-1/melanoma_dataset.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 423 + }, + "id": "Q14KncK6GofO", + "outputId": "b3fda9fb-80c5-478b-d8df-e4eb26f048e2" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mass_npeatumor_size
018.1593067.490802
139.69322819.014286
232.65995614.639879
327.55692511.973170
49.8005363.120373
.........
9955.3432601.831641
99639.08077418.346272
9978.4357082.736373
99840.58019219.004747
99920.1478108.920115
\n", + "

1000 rows × 2 columns

\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n" + ], + "text/plain": [ + " mass_npea tumor_size\n", + "0 18.159306 7.490802\n", + "1 39.693228 19.014286\n", + "2 32.659956 14.639879\n", + "3 27.556925 11.973170\n", + "4 9.800536 3.120373\n", + ".. ... ...\n", + "995 5.343260 1.831641\n", + "996 39.080774 18.346272\n", + "997 8.435708 2.736373\n", + "998 40.580192 19.004747\n", + "999 20.147810 8.920115\n", + "\n", + "[1000 rows x 2 columns]" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Display the dataset\n", + "data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 466 + }, + "id": "P9ipnJ_iKF42", + "outputId": "5a6dc77f-ef9f-4099-f755-2907e0c1571f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACkWElEQVR4nOzde3zT9b0/8FfuaXpJ2oTSFtoSSKW03IKFgklRwAkIKMg8s3KOhaLuJxbcOE5AQblN0Dl1gOg2KbBN0LOhIKBsAgptQa5R7tiUSosFSkOTXtLc8/sjfL/k21xaaoEW3s/Hg8dZvrd8y9ns28/nfeF5vV4vCCGEEELuIvzb/QKEEEIIIbcaBUCEEEIIuetQAEQIIYSQuw4FQIQQQgi561AARAghhJC7DgVAhBBCCLnrUABECCGEkLuO8Ha/QEfk8XhQVVWF6Oho8Hi82/06hBBCCGkFr9eL+vp6JCUlgc8Pv8ZDAVAQVVVVSE5Ovt2vQQghhJA2qKysRPfu3cNeQwFQENHR0QB8f4ExMTG3+W0IIYQQ0hp1dXVITk5mf4+HQwFQEMy2V0xMDAVAhBBCSCfTmvQVSoImhBBCyF2HAiBCCCGE3HUoACKEEELIXYcCIEIIIYTcdSgAIoQQQshdhwIgQgghhNx1KAAihBBCyF2HAiBCCCGE3HUoACKEEELIXYcCIEIIIYTcdW5rALRs2TIMHjwY0dHRiI+Px8SJE3H27FnONTabDc8//zyUSiWioqIwefJkXL58OexzvV4vXn31VSQmJiIiIgIPPvggSktLb+aPQgghhJBmLFYHyqobYKioRdmVBlisjtv9SqzbGgDt2bMHzz//PL799lt89dVXcDqdeOihh9DY2Mhe89vf/hZbt27FP//5T+zZswdVVVV47LHHwj73zTffxIoVK/DBBx/gwIEDiIyMxOjRo2Gz2W72j0QIIYQQAFXmJhRsNGDU23swafU+TFhZjP+cuoyzl+pw6MerOFVlwXlT420Linher9d7W745iCtXriA+Ph579uzB8OHDYbFY0KVLF2zYsAG//OUvAQBnzpxBnz59sH//fgwdOjTgGV6vF0lJSfjf//1fvPjiiwAAi8WCrl27Yt26dXjiiSdafI+6ujrI5XJYLBYahkoIIeSOZbE6UNPgQJ3NiZgIEVSRYshl4nZ5bsFGA4pKawAAMrEAq57UYm1xOYqMJvY6nUaJmSPTkBonQ6Ii4md/7438/u5Q0+AtFgsAIC4uDgBw5MgROJ1OPPjgg+w16enpSElJCRkAlZeX49KlS5x75HI5srOzsX///qABkN1uh91uZz/X1dW1289ECCGEdERV5ibM2XSMDVIAYHiaCssn90ekWHDDgZHF6oCp0QGXxwu3x4vcISmYplPjaEUthHweCovLUewX/ABAybXP4/sn4eG+Ce0SfLVWhwmAPB4PfvOb30Cn06Fv374AgEuXLkEsFkOhUHCu7dq1Ky5duhT0Oczxrl27tvqeZcuWYdGiRT/zJyCEEEI6B4vVERD8AMDe0hq8uuUEns5Ro9Huht3lQa3ViYPlV/HAPV2QqIjA5TobahsdqLO5EBMhRKxMDK/Hi/lbTuCJISlYW1LOBjYAkKNRYd7DffDuzuC5uCVGE/J1atQ0OO7OAOj555/HiRMnUFxcfMu/e968eZg9ezb7ua6uDsnJybf8PQghhJC2uNGtLLPVian39UDukBRIRQIcrahFYXE5AOCJISl4b7eRs1WVo1FiiDoWZdUNWPj5Cc45vUaJhY/0hTZFERD8AECRsQZTLU1h39/u8qDe5mzLj95mHSIAKigowLZt27B37150796dPZ6QkACHwwGz2cxZBbp8+TISEhKCPos5fvnyZSQmJnLuGThwYNB7JBIJJBLJz/9BCCGEkFss2FZWTpoKCx/JBA+AslkwVGVuwvzNxwNycVbkanGyyhIiiDHhwLmr+OL4xYBtrGKjCQs/P4E5Y9Pxh3//0KafQSLkI1oqatO9bXVbq8C8Xi8KCgrw2WefYffu3VCr1Zzz9957L0QiEXbt2sUeO3v2LCoqKjBs2LCgz1Sr1UhISODcU1dXhwMHDoS8hxBCCOmMQm1lFV3byvrU8BNmbjSgytzEvT5ILs7aknKM6B0fEPwwusZIcbTCjIKRGqzJy8LqKYNQOHUwCkZqcLTCjCaHJ+R7GirNyNEog57TaZSorrdDFXXrtr+A2xwAPf/88/jHP/6BDRs2IDo6GpcuXcKlS5fQ1OT7f5RcLsf06dMxe/ZsfP311zhy5AimTZuGYcOGcRKg09PT8dlnnwEAeDwefvOb32Dp0qX4/PPPcfz4cTz11FNISkrCxIkTb8ePSQghhNwUNQ2OgOCHUWI0QZuswN7SGszddIzdJgt3fTgujxcrcrUwVNRi+vrDmPHRUeSvOwRDRS1W5GoRKRaEvLewuBwLxmciJ03FOc5UgY24p8stzf8BbvMW2Pvvvw8AeOCBBzjH165di6lTpwIA3nnnHfD5fEyePBl2ux2jR4/G6tWrOdefPXuWrSADgJdeegmNjY149tlnYTabodfrsWPHDkil0pv68xBCCCG3Ul0LeTN2l29VZm9pDZsjFE6Twx3yXKJcijd2nAkIlJjPv5/YFzkaFYqMgQGWNkWBL09exNJH+8Lh9sDS5IRMLECkWAiFTHTLgx/gNgdArWlBJJVK8d577+G9995r9XN4PB4WL16MxYsX/+x3JIQQQjqqmBbyZiTC6xs9TNAR9nkRIix7rB+WbDsFa7NgyOPhrhLJxALk69XQJitgd3lgc3mwYHwGFm87yckT0mmUmKZT45ODFZg6rMdtCXaC6RBJ0IQQQgi5caooMYanqbA3yLaWTqOEodLMfrY53dh9tho6jTLodpdOo8T24xfxfaUZa/KyMH39YTYI0mmUsLmuB0QysQArcrVYW1KOVbuN7PEH+8Tj9Un98JO5CbVWJyRCPgyVZnxysAKLH+3bYYIfgAIgQgghpFNiGg++9kgmFn5+kpPbw6y6zNpoAOArVd93zoTC4nKsyNUC4K7m+F9vdbgBrxcfPzsUF2qb2CDG6nCzqz4P3NMFliYnput7QpsSi8Liclgdbuw8XQ2Hy4M/PD4ADTYX6m1OTBrYDSq9ukMFP0AHG4XRUdAoDEIIIR2Zf+k7E5ToeikhEvDhcHmw75wJHx+swBNDUnBfTyX4PB6anG4cqahlj4/O7IrKq9cDHCaIYTCrQIzf/iINQ3rEYdXXxvDBE4Bds+9Hr/ioW/cXck2nHYVBCCGEkPCal75bHW6s2m3Eqt1GjEzvginZqchKicUjA5KwZOtJzhaVTqPE8sn9MWujARmJMZjx0dGQ38MkUDO8XmB1s+AHuL6SlK9Xs991q5satsVtLYMnhBBCyI0JV8q++8wVAMDhilos3noyaL+f9SXl+PjZoYiTidk+PsGSo+UR3ATrwT3iAp7n/1xtsoL9fKubGrYFrQARQgghnYTF6sBVqyPsNXaXB9pkBWflx1+R0YSp9XZ2e4vpAu2/hZWjUSE+RoKPns6G2+uFgMeD2xM+Y4ZZMRqeprrlTQ3bggIgQggh5Da40fldF81N+OaHK+jfPQYFIzVs+XmkWAi31wN5hAhOlxdymRBSoQCFUwfD5nRzZn0xAY7/9lbzLSydRolFj2Zi6fZT2H3mClvxFSEKX0IvEfIxPE2FNyb373AJz8FQAEQIIYTcYsHmdw1PU2H55P5IUkQEXH+5zoarjQ7ER0vA5/GRJJdi5rUKrxW5WqwrKUex0cQpT2+eqOy/yuPfHwjwBUFzxqRDm6xAdZ0NZquD3U6zOtyYtdGAlbnakI0Oc9JUSOsSxVZ/GSpqWxXU3U4UABFCCCG3UKj5XczIipW52oDhpXP+9X3Q4aUnfuIOL83Xq4MOM/U/b6io5fQHYlyobcLGgxVY8mhfnKtp4JyzOtyYudGAFblaeODlPH94mgpvTu4PD4AX//l9q4O6240CIEIIIeQWCpbE7N9V+YfqBsRFiqGK9AVBoYaXAsBvH7wH7+4sZY+Hy/0pMZow4wENBiYr2P5A/nqqIrHqWvDldAcONmVWgvL1aswdm47qOju6x0YgIcY3Zqpgo6HVQV1HQAEQIYQQcgs1n8cVqqvy8DQVFj2SiSPna4M+p8RowswR3MTk5qXrzQn5PAj5PHzw3/ciLtIX6NQ1uVBlaUKiXMoGKfHRkqAdpq0ON76vNOPxQd2Rkipjry+rbghZmcbMIetoARCVwRNCCCG3UPP5XaG2rfaW1uDVLSeQr1eHfJZMwk1Mbp7b05zb48XUtYfwVOFBjF9ZjLf+cxZOjwe7Tl9Go18TRLlMjOWT+2N4s+ntzHZXqiqSE9C0NGS1I/YFohUgQggh5BZqPr8rKyUWAJCvU8Pu8nCqtoqMJkzVhQ6AAHASkw2V5pCzvphxGP6Y67QpsQFbVUmKCKzM1aKmwYF6mxPRUhFUUcGTmlsaytoR+wJRAEQIIYTcQszqytxNx3D4fC0SFVIYimsDOjYzVVtA4OR1qUiAS5YmFBuv4MXRveGFF8XG67O+eABnInuORoU8XY+guT8lRhPydb4SeP+tqhsp0w83lLWj9gWiWWBB0CwwQgghN5vF6oDZ6sT8zceDdljWaZTQpsRiTGYC6m1O/LXoHDKS5GwQFCsTIVEuhd3lhscDeLzA+atWyEQCuL1e8Hg82Jy+kve4SDGmfHiAM+vL3+opgzDjo6PYPOM+DEyJveEyfcBXrTZ30zFOEMT0BUq8RVVgNAuMEEII6eDkMrGvIqxZ8OO/2hMl8f2avnDViv8emoo1xdxEab1GicWP9kXe+oP4438NDDnba01eVsjgB7ieOxQtFd1wmT7jRrbMOgIKgAghhJDbhEkeZoKeQSmxkIkE8MCLfWUmtnvz65P6Ym1xYKJ0sdGE1z4/iQ/++17O8eZbZvHRUuSkqYJWauk0Shgqzci5tlUVbtZYSxVdclnHDXiaowCIEEIIuU1ipKKAMngmeBnWUwl9LxWanG4oo8RYuv100GcUldZg6n02GCrN0GuUOFphDiirl4kFKMzLYq9n6DRKTNOpseHAeSx6JBNymRjnahrDvnNHrOhqCwqACCGEkNtEFSXGgvEZbBl8qJ5AORoVNj+vw1enLsHl8aJfNwWEfB7by0cs8PX3ma7viXGWpoCyeqvDjfz1h7FgfAbmje2DBrsLkRIBnG4PzI1OZCTJ2Ws7Y0VXW1AARAghhLSz1lZQyWViDEpRYN6nxwGE7glUZKzBoq0nMb5fEnqoZJi+/jCb08Os4hy7YEb/7nL0TojGvM9OBHyX1eHGvE+PY01eFjsJnjE8TYVnrvUb6owVXW1BjRAJIYSQdlRlbkLBRgNGvb0Hk1bvw6g/7sHMjQZUmZuCXu+fnKxNVgTt4QP4ytXjYyRY9bWR0xyxxGjC2pJyZCTJsaa4HDwe74bel2luCPg6Ov9oasTiR/sGbYLYWSa9twatABFCCCHtxL+Cqnki8nmTL7emeRm5/5ZTS6Ms7C4P27fHn38vn7ljwwdAKXEy7Jp9P6dSq9Hh5szykokFWDA+A6+M64Mmh7vDV3S1BQVAhBBCSDthKqjC5fL8flJfpCgj2WMRYgH0GiWKjaYWR1kw54MFSsyx+iZXyIqv4WkqxEdLOIFMsLJ3ZrtseJqqQw4ybQ8UABFCCCHthClrD5fL8/Jnx/HH/xqIrtemqNfbnJiqU8OL8KMsmHJ1wDesdE1eFmd0RkKMBDKxAHKZCNN0PeDxejnPCbWF9XPK3jszCoAIIYSQFrQ2qZnZztImKzgrP/6KjSZcbXTgQq0VkRIh6ptcmLXRgHy9GmMyu2JC/0Qs3X46aLn6rI0G5GhU+OFyPV72S3TWa5R4uG8CPn1uGMDjIVoiwoJxGRAIeKhtdEAsFCBRLmWDLn+dcZBpe6AAiBBCCAnjRsZCqKLEeLBPPOIixQErNExTQwAwW53I/eu3AIANT2fD6nBj1W4jtMkKzNxowLPDe+KlMb1RXWcH4FsZmrXRgHtTYzHjAQ2mrz/E+d5iownLvjyDCf0T8dKm4+zx631+yvDq+MygP9/dUvbeHAVAhBBCSAgtJTUL+DzOqopcJsb8cRlY0Gy+l/9wU6vDjSipgD2375yJnehuqDRDm6LAuztL8Ze957AyVwupSICMxBiszNUiPlqKX/1lf9CxFkWlNXhpTG/IxAL2vP+09wVbTmBVkHyeu6XsvTkKgAghhJAQWkxqTlNh4SOZ4AFQRvoChebBD3A9EMnXq/F9pRk19Xb2XGFxOT6bcR8WbzvFTnP3v2fKhwfYa1dPGRR2pld1nR35ejXnHUNNe2f4T6cPNsj0Tsz/ASgAIoQQQkJqMam5tAavbjkBbUosjlWa8cq4PkEnuwO+QGTGAxo83DcBV+rt7EqN1eHGRbMN+To1pA8I0GB3Yc6YdAj5PFiaXJxntFQlBvjyj5pjK8RC5PN0tkGm7YEaIRJCCCEh+Cc1h2tQqE1WYG9pDS7UBm92yBAJ+Hiq8CD+UnSO08zwcEUtIkQCTPnwAH799yN4ZFUJLlpssDq4ARBTJRYMUyUWrETef9p7KHKZGL3iozAwJRa94qPu6OAHoBUgQgghJCRVlBi/6BMPkSD8ekFLDQwZUhEff30qC1FSIRwuD/QaFUQCPn6saQhY3TFUmpEkl3LK4oNtkQHcKrGV1877nzNUmu/ofJ62uK0rQHv37sWECROQlJQEHo+HzZs3c87zeLygf/7whz+EfObChQsDrk9PT7/JPwkhhJA7kVzmG1Yq4IfvrswEL4ZKM3KajZBg6DRKfH22GmarE4fKr+KSxYarjQ5YmpxwuL1QRIohE19Pji4sLkeiPAIFIzTsqo/V4casjQaM75eIrTN1eP+/B2FNXha0KbGYtdGAQSkKtlcQ853TdGqcvVh3R+fztMVtXQFqbGzEgAEDkJ+fj8ceeyzg/MWLFzmfv/zyS0yfPh2TJ08O+9zMzEzs3LmT/SwU0kIXIYSQG2exOvDK5hMYkKxoVYPCwuJyfDErB69uOYG9fpVjw3oqIeDxIBXxIRby8WHxuYAVHLUyEgsnZLBl7FaHG89vOIpf398TrzzcBx4vYHW4IBEKwOcB73z1A3afucI+I0ejxJKJ/dDkdOGBe7ogSiKEgM+DgM/DW48PoOCnmdsaGYwdOxZjx44NeT4hIYHzecuWLRgxYgR69uwZ9rlCoTDgXkIIIcRfa5obMlVgR87XBt16yklTYcH4DJTXNKJw6mCYGuwQ8XkY2y8R+To1usfJsOjzEygsLke+Xo2HMrpi2RenAwIp5vOiRzI5gZbV4cah8qvITJJj1kYDAKBw6mB8WHQOGUlyTMlOhd3lgSJChJQ4GbrHyW7a39edptMsjVy+fBnbt2/H+vXrW7y2tLQUSUlJkEqlGDZsGJYtW4aUlJSQ19vtdtjt10sS6+rq2uWdCSGEdEytbW7IVIExW0/5ejXydWo43B50j43AiQsWTHyvhC1NX/ZYP8z99DiKjDUoGKnBmuJzOFJhZkvotcmKsFViNqcHQ9RxyNep2SaK3WMjUFXbhJW5WnSPjUBCjBR/fHzAXVWxdTN0mgBo/fr1iI6ODrpV5i87Oxvr1q1D7969cfHiRSxatAg5OTk4ceIEoqOjg96zbNkyLFq06Ga8NiGEkA4m2PBPwDf3au6mY5zhn/5dkpluzQDw21+kobbRga4xUrz1+AC223PXGCmKjL7nMuMwCkZq2BL6KdmpYd+tyeHGiN7xyF93CDUNDgDAF7P0SI6TBQQ5FPD8PJ2mDL6wsBBTpkyBVBo4x8Tf2LFj8fjjj6N///4YPXo0vvjiC5jNZvzf//1fyHvmzZsHi8XC/qmsrGzv1yeEENJBtGb4J4PpkuxPJhZgbGYith+/iOnrD2PGR0eRv+4QDBW1kImuJzEzlWH+JfQt9fGpsznx5o4z+DBvMGRiAYanqdBNEXFXlKXfap0iACoqKsLZs2fx9NNP3/C9CoUC99xzD4zG4EPpAEAikSAmJobzhxBCyJ2ppeGftVYHLFZfEMR0SfYPgvL1aizZdjJoHo/b62U/M8GOf4l8a/r4FBtN+OO/z2LB+Ayq3LqJOsUW2Jo1a3DvvfdiwIABN3xvQ0MDysrK8D//8z834c0IIYR0Ni0N/7Q0OTFzowGLH+0LS5MD0VIR/vD4ADTYXKi3ORFxrVR9ql+eDjPsdH+zuV46jZKz6tOaPj4AUGSswasTMpDYbNhqa6fSk5bd1gCooaGBszJTXl6O7777DnFxcWzScl1dHf75z3/ij3/8Y9BnjBo1CpMmTUJBQQEA4MUXX8SECROQmpqKqqoqvPbaaxAIBMjNzb35PxAhhJAOL9zwT2YVZm9pDV7ZfBzalFis2m1kE6R7xUeh7EoDDBW1nHlbzLDTuZuOYcPTQ7Fk20k22LlcZ2Mru5onUwOAPEKEb364wg5KZTTauV2gb2QqPWnZbQ2ADh8+jBEjRrCfZ8+eDQDIy8vDunXrAAAff/wxvF5vyACmrKwMNTXX/8tw4cIF5ObmwmQyoUuXLtDr9fj222/RpUuXm/eDEEII6TRCDf/UaZSYrlfj+E8WrMnLgt3lQcq1svLC4nLM3XQMf3h8ABZuORGyjP2JISnwwot7e8Rhqk4Nl8eL7J5xyFYrsfDzEyi6FgSt2m1EjkaFPF0PPFV4MOiAU/+xFTeSuE1ah+f1+m1YEgC+VSe5XA6LxUL5QIQQcoeyWB34ydyEH01WSIR8HP/JggHdFQFNCnM0SiyYkImdpy9hZHpXjHm3KOQzNzydjUiJEI++V8IeKxipwakqCzKS5BjRuwtcbi9cHi9sTjc+OnCe08yQMTxNxQlqyqobMOrtPSG/d9fs+9ErPqotfw13lBv5/d0pkqAJIYSQ9iaXiSERCjDjo6OYvv4wXB4vJ/iRiQUoGKnBVJ0aVbVNGJOZiJ9aGHbK5/NQ2+jgHCssLseT2akwVNTCbHVi2rpD2H/OBAGPhzlj0pGj4VaZDU9TBSQ/t5S4HWrKOwmtUyRBE0IIIUD7JwH75wMNupbvA/iCH6Z5IdPL56/F59i8nVCiJEI02l0Ymd6FXdnxz/uJkgg5/YSYURlTdT1gd3nQQylDN0VEwM/UUuJ2uCnvJDgKgAghhHQK7ZkEzARSDXYnFj/aF69uOQGh38DTfL2abV4IXG9qqE2JDTsTbMfJS/i+woyFj2YCOMUJgr6vMGN8/0TOPf7BEODbygoW0IVL3KYp721DARAhhJAOrz2TgJsHUjKxAAvGZ6BLtIS9RpusQGFxOQpGaqBNVkAmFqJw6mAcu2DG03rfPMrmeUJ518rYrQ43XttyAq89kon/HtoDNqcb8ggRbE43IkSCNgUyoRK3g22XkdahJOggKAmaEEI6lvZKArZYHSjYaAgIpGRiAbYU6FBdZ4elyYnUuAg4PcAf/n0moF/Pszk94fF6oYqWoMHmRrRUCImIj9y/fMvpIv3R09nYf84EQ0UtpunU+ORgBd56fACsDje++eEK4qMlbB+hy3U2jLinCxJaWMliVq5oBlhwN/L7m1aACCGEdHg3kgQcKk/IYnXgosUWNPhZkavF4s9PsoNKC0ZqYKioDdjqMlSYIRby8d7XRhQ3WwFaPrk/p5ePpcmJ0ZldAQCfHKzA4kf7Qi4To9HRhC+OXWRnhgG+lZz772m5XYtcRgFPe6EAiBBCSIfX2iTgUHlCSyf2xeJtp/DYoO4B9zbP9wGu5/wEu3bV18aAwKjIaIKHOX/tPomQjyaHB5MGdoNKr2aDsDmbjnGCH4D6+dwOVAZPCCGkwws2lJTB5M6EyxN6+bPjSE+MCTqM1H9YKcN/fldL1zJKjCaMzkxAwUgNRqZ3gaHSDGWkmDPI9EYGsZKbi1aACCGEdHitSQIuq24IGVwUG02YplPjRJUFr0/qi64xUjb/JlYmgkws4HRjZgIlpkxdm6yA3eVBfLQEBSM1KCwuD9q9ufKqFd9V1GLB+Eys3PVDQFIz9fPpOCgAIoQQ0ikkKSKwMlcbMgm41hp+9UQi4mNs30Qs2Xo91wcActJUWJGr5eTvGCrNGJneBU9mp7K9gBjM3K/ms7sAX+BUbDRhybaTQauzqJ9Px0FbYIQQQjoNucy3pTQwJZaztWSxOuAIsW3FiJOJsahZ8AMARaU1WFdSjnz99SaHhcXl+M2D9wTkBgG+ra61za4Hrg9SBXwrTjZn4Pu0ZiuP3BoUABFCCOk0LFYHyqp909jLrjTAcm3Vp6bBgX3nTNBplEHvy9GowOPxQubvFBtNGNbz+r1WhxuNdlfYfB9tsoL9rNMoMU2nRmFxOXss2HYWs5XXPAiifj63Hm2BEUII6RSCVXjlpKmw8JFMmJscKCwux4pcLQAE9O7J16thaQqfX+P2erEmLwuR18ZZCAXh1whipCKsnjIIEiEfhkpzwJZYqO2slrbyyK1BARAhhJAOL1SFV1FpDV7dcgJzxqRzZm799sF72IDnRJUFXngRLQn/K8/p8mD6+sNYPWUQZnx0FNtn6sNeHyUVYsWuHwK21ADfio6Qz4OhojbozDLq53P7UQBECCGkwwtXPl5iNMHh8rAzulbtNkKbrMD09YevDzUtLseAFuZ4Mfk7EiEfMrEAURIhcjSqgJ49zPXwevHi6HSAdzZgVWrGAxqMXVHErgi1dWYZuXkoACKEENLhtVQ+XtPgwJwx6ai3uWBpciIhRoI1eVmIj5bizR2ncaTCjHt7xGHu2HRU19nB4/FwtKIWhcXl0KYoMO3aHC+dRokTVRYU5g3Gkm0nkafrAQ+8nKBJr1Fi4SOZ+M+pS8hIkGPRhEyUmxoBAMmxMhw5X4v89Yc422F7S2swZ9MxrKJGhx0GBUCEEEI6JP+RFhFiQdj+O91ipVj+pW9uF7vqU1KOfJ0aRyrM7Od3d5ay9+RolNg2U4+tx6owa6MB96YosGBCJhxOD97YcRpFRhP2nbuKfL0a+To17C4PO9R0+Rdn0Le7HG6vF/V2F9bv+xFvTO6PBrsL8z47HvTnKSqtQXW9nQKgDoICIEIIIR1OsIRnfYj+OzkaJY5fsLCrNP6jLaZkpwYddQH4xle8tuUk5j6cjtEZCTBU1GLieyVYmatl83qsDnfASIw1eVnYeaYaudkpiI+RQCzgsyMsDv14NezP1VIiNrl1qAyeEELITROqbL2le4IlPBcbTQH9enQaJRZMyMTS7achu7ZKNDqzKxvsSIT8sOMriow1EPB5+P32U5j32QlYHe6QYzAY/ufPXKxHQoyUXdWJFAvC3itr4Ty5dWgFiBBCyE0RajBpS8nA4RKei40mzB+XgRG9u8Du9ODgj1dhbvQFVcw2V0ZiDHu9odLM6dcTTL3NxankCjYvzB9zPiFGiszEGM6WVqRYGDbROlJMv3Y7CloBIoQQ0u7CDSadu+kYZyUoYJWoKfwqkc3pxr2pcchMisGjA5Lg8ng521z+AUxhcTniYyRhn9d81cZQaQ7ZUJGpFstJU0EVLUFCs0BOIRNh5si0gPt1GiVmjkyDQkajLjoKCkUJIYS0u9ZMPZfLxEFXiTY8nR322f4NBi9abNh3ztfFmcnVYQKYEqMJVocbu05XI0ejDNmvp/mqTLiGitN0anx8sAJvTu6PrjHSgOfJZWKkxskwvn8SmzgtEfJRXW9HjzgZJUB3IBQAEUIIaXetmXoeapVo3zkT9BolioMELDlpKri9XpRdaYCQz4PH60VhcTn0va6PlmgewPxl7zmsyNXCC3CemXNt/IRMLMDwNBU7Zd6/oeLzIzTg83iIlAjgcnthd7rx+0n9ggY/jERFBB7um8Dp9JyVGkvBTwdDARAhhJB215qp56FWiZgAhsfjBVSB5d3XAxPfK4HV4UZOmgqvTcjAs8N7IlIqxOopgyAVCXC0ohZzNx3DE0NS2FWYRLkE03Rq5Ot7wuZ0QxEhglDAg0wsYOdzzd10jBMEfVdRi4HJCrbqjJnXFS74YVCn546PAiBCCCHtjpl6vjdIgDM8TYUoqRAVV61B72VWYD597j443B7YXR44XR7sO2filMAfOV+Lmno7jvx4ldPfZ2R6FxROHYyaBgdsTjdiZSJcrrNj5rV7ma2sWX8zYGuBHnKZOOh8riipbybYhqezaV7XHYgCIEIIIe0u2KoK4At+lk7si1c+O47cISmQiQXI16uhTVbA7vKwKziFxeX4ydyE6esPY01eFqavP8w+g7nnoYyu+MOOM5zcHplYgCezU/HGjjOc/J2cNBU+m6HDRXMTDlfUsoGU/8R2WrW5u1AARAgh5KYItaryymfHsfN0Nfp1l2NNXhZWfW3kNBvUaZRYk5eFg9eaCvr33fHv8qxNVgQkNodselhag6XbTmJASiznu0JNbCd3PgqACCGE3DTNV1XKqhuw83Q1AEDI5+HHmkbk69SYkp3KWf1Z/U0Z8nU9IBMLOGXtzbs8N19BSo6TBXRuZhQZTZiqu95EcXiaCqooWvG5W1EARAgh5JZhevzIxAL8ok8CFm07yd2q0iixeYYO5aZGxEdL8fGzQ1FUeoUta9cmK9gARya6vhrEHFs9ZVDY72dWk5iEZtryuntRAEQIIeSWqDI3web0BSD5ejWWNAt+AN8qzaJtJ6FNicWv/34Eeo0SL41JR98kOfjgboe5vd6A7a6Wujj3UMqwa/b9lNBMqBM0IYSQm89ideDVLSfQ5HTjo6ez8VBG16CNCQGwKz2Ar2/PH/59Ft1jIzBhQBKS4653XubxeAEBVLguzsPTVOimiECv+CgKfggFQIQQQm4+U6MDT2anYMOB89h/zhe0rJ4yCIVTB6NgpCZgSKj/Sk9RaQ2q6+1QRUtQU29HjsbX9NDmdKO5wuJyTNOpA4KgHNryIs3c1gBo7969mDBhApKSksDj8bB582bO+alTp4LH43H+jBkzpsXnvvfee+jRowekUimys7Nx8ODBm/QTEEIIaQ23x4sN355HbnYqDBW1eGRVCWZ8dBT56w7BUFGLFblaThAUHy3hfHZ6vFhb/COu1NuRp+sBnUYZdLuL6SGkTYnFly/k4J+/HoatM3WYpE2iSeyE47YGQI2NjRgwYADee++9kNeMGTMGFy9eZP9s3Lgx7DM/+eQTzJ49G6+99hqOHj2KAQMGYPTo0aiurm7v1yeEENJKbq8X6UnyoCXqJUYT1paUI1/vq9DSaZT44XI9JyiKlYlQZKyBMkrCBjhdoiXICbLdZXW4YaioxfbjF/H4n/dj+ZdnEBMhhqkx/JBVcne5rUnQY8eOxdixY8NeI5FIkJCQ0Opnvv3223jmmWcwbdo0AMAHH3yA7du3o7CwEHPnzg16j91uh91uZz/X1dW1+vsIIYS0rN7m4lRwNVdiNCH/2tbVNJ36WpCjQL5eDUNFLVxuLwDf1pjV4caq3UZ2ZIYHwYeWztpoYJ8NAAsnZN7cH5J0Kh2+Cuybb75BfHw8YmNjMXLkSCxduhRKZfAEN4fDgSNHjmDevHnsMT6fjwcffBD79+8P+R3Lli3DokWL2v3dCSHkbmWxOlDT4ECdzYmYCBEixQJcqbeHvSdKIsScMemoaXDgrccHQCoSICFGgntTYmGx+jo2+297+Q8tnT+uD3jgwenxoLbRCbfHi3y9GoXF5bA63CgxmuD2eG/qz0w6lw4dAI0ZMwaPPfYY1Go1ysrK8PLLL2Ps2LHYv38/BILAvdyamhq43W507dqVc7xr1644c+ZMyO+ZN28eZs+ezX6uq6tDcnJy+/0ghBByF6kyNwVMef9ilh7yiPBdl2USAd78kjvaIidNhQXjMtDocOH1SX1xosrCucfqcKOwuBy/HNQdCzYf59yr0yixIlfLjr1gZogRAnTwAOiJJ55g/3O/fv3Qv39/9OrVC9988w1GjRrVbt8jkUggkUja7XmEEHK3slgdmLPpGI6cr0XBSA3bodnm9CAxRooH0+Ox80xgTmaORonjFywBpfFFpTVsX6DvK8yYpvd1h/YPZhaMz8CCzScC7mW2vvL1aqzabWwxACN3l05VBt+zZ0+oVCoYjcH3kFUqFQQCAS5fvsw5fvny5RvKIyKEENI2NQ0OHDnvq+oyVNRi+vrDmPHRUTz2/j689vlJzB+fgZHpXTj36DRKLJiQiaXbTwd9JtMXqMhYg8Li68nSgC9w0qb4zoW7l8ZekOY69ApQcxcuXIDJZEJiYmLQ82KxGPfeey927dqFiRMnAgA8Hg927dqFgoKCW/imhBDSeTXP31FFtr5rcp3NGTCQ1H9eV9mVBvzvQ73xmwfvwUWLDUI+D4ZKM8prGsNuUTF9gYqNJswZm46MxBhIhHx0iZag3uZq8b2oBxBp7rYGQA0NDZzVnPLycnz33XeIi4tDXFwcFi1ahMmTJyMhIQFlZWV46aWXoNFoMHr0aPaeUaNGYdKkSWyAM3v2bOTl5SErKwtDhgzBu+++i8bGRrYqjBBCSGjB8neGp6mwfHJ/JCkiwtzpEyMVced1iQPndQGAXqPEVJ0aM6/l52x4Ojvsc/2TnyuvNmHGR0cBAGvyspASJwt7b0qcDImteHdyd7mtAdDhw4cxYsQI9jOTiJyXl4f3338fx44dw/r162E2m5GUlISHHnoIS5Ys4eTrlJWVoabm+v9Qf/WrX+HKlSt49dVXcenSJQwcOBA7duwISIwmhBDCxeTv+Ac/ALC3tAZzNx3Dylxt0FUU/xWjKIkQUtH1IpXmq0GMYqMJPB4Pnz53H8ADzFYnO/C0OZ1GCUOlmf3MNEm0OtzoHhuB+GgJhqepsLc0cBtseJoK8dGU40kC8bxeL9UFNlNXVwe5XA6LxYKYmJjb/TqEEHJLlFU3YNTbe0Ke3zX7fvSKj+IcC7ZitPGZbOT+9QAA3wrN9PWHQz5zTV4WZm404JNnsxElEeGixQZzkxNSkQBHK2pxqsqCJ7NT2UounUaJcf0SER8jxScHK/DW4wMgl4lRZW7C3E3HOEEQM/GdVn/uHjfy+7tT5QARQgi5MTeSz1Nnc4Z9Vn2z86FWjKwON/QaJYqNJs5Mr2CY8xKhEPO3nOCsAOVoVPjf0b3x9PpDbPDDNDgclKLg5PUkKSKwMleLmgYH6m1OREtFNPGdhEUBECGE3KFuNJ8nRhq+TDxSIkRZdQO71eX2egOCHwAQ8HiYqlPDCwSd1+VPIuQjX6/G4m0nA7a/mMquvz6VhauNDhgqzexKULHRBJuTG1zJZRTwkNbrVGXwhBBCWqelfB6L1RFwvZDPQ06aKujzctJUOHy+FqPe3oNJq/fhF+/sxU+1TUGvtTrdLc7rAnwl7IZKM7TJChQHyf0BfEHQ1UYHpq8/jFW7jZxKseYrUoTcCFoBIoSQO1BNgyPo6gzgC4JqGhzsagmzUsT07/F4vZzVmOFpKswdm47qOjtWTxnE5ufweLygz5eKBK2a17Xo0b5Yuv0UMhLD52qE2kaLbmHFipBwKAAihJA7UGvzeSxWB/b8cAVT7+uB3CEpEPH5yNepMV3fE16vFylxMkiEfCzcehK7z1xh79dplHgoo2tA5ZZMLIAqSszmAPnP68rX+RoYyiNE+OaHKzBeaUBGkhypLZSxB9tGo8aG5OeiLTBCCLkDtZTPw6ye1Fqd2Hasiu3YnLf2IApLyuHxejFzowFiAR+vfHacE/wAvtWcd3f+gJdGp3O2zfL1ary78wdM1amRo/EdZ1eDSsrhBfBU4UGs2m1EolwKbbICUpGAvba5HI0Kl+tsnGNMdRfl+5Cfg8rgg6AyeEJIZ2exOjBzoyFkb5yVuVrYXB68+H/fBczQAoCR6V0wJTsVSYoIlNc0sttezHR1xo7f6GG2OhEjFeOipQnxMRJMWFkCmViAlblaSEUCWJqckAj5MFSa2fv1GiUGpsRi1W4jZGIBtjyvw8KtJwO2yabr1Tj+kwUPZSSgyeGGPIKqu0hoN/L7mwKgICgAIoTcCcL1xgGA8ppGPPnhgYD7mO7N60vKA6arT9OpMXfTMTwxJAVZqbGIkgjhdHsQKRHiib98i7ceH8B2afbvAu0f2DBdoJnnaJMVEAv5iJGKwOOBMyKjsLgc2hQFtCmxOFZpbnVHanJ3ogDoZ6IAiBByp7hcZ0NtowN1NhdiIoSIlYkhFfJRsNGA3CEpbLDCYFZu1jULfhg6jRJzxqTjjR1nmvXsUSJPpwafx0P+ukOc5zFzwOwuD3qoIvHF8Yv4+GAFlk/uHzI48m98OM3vM7N6RStAJBhqhEgIISRkH6BXxvVBUWkNpt7Xg3M9s2IjFQmCBj+AL/en3uYK0rPHBA+AfJ2akxjN5P8AvuDpxYd6Y9VuIwpGasKOyPi8QAerw42vz1azwQ8QWMFGSFtREjQhhNyBwvUBunCtf4+h0gydRgmZWICCkRp8/OxQrC8ph6UpfAVZqPMlRhMEPB6mXQuC/OVcW8mxO32BjDZZEXTuFwAUldbgvMmKN3acQWaSPOA89f8h7YFWgAgh5A7UvA+Q/1ZUpFiIwqmDceyCGb/O6QWRkIdVXxuhTVagyGjC1Gvl6qGE6+7s9noxd9MxvDG5P+aOTUej3Ze4fNHShH8ersS8sX0wPE3VqhEZTICUr1dzJslT/x/SHigAIoSQO5B/HyBma2vDgfMAwObjDFHHIT5agmVfnEaJ0YQp2akArq8MBVuhyUlTcSazN6eQibDh6aFYsu0kZxstR6PCvIfTIY8QYfnk/vixpjHs+zNBVonRxPYPAqj/D2k/FAARQsgdyL8PUL5ejQ0HzuPJ7FSsLSnnrKbkaFTI0/XA/nNX2aCD6d4MIGA46YsP9cbKXaVBv1OnUcJsdeLtr34IPtfryzNYlatFkiICgmtjN4J1q9ZdG5HBYFaLqP8PaU8UABFCyB1IFSXG8DQV9pbWQJusAICgScdFxhp44EW+Xs1Z+fHv3mx3eaCIECFaKsSMj45i0aOZsLs87LBSwBcczR/fBx6PN2xuD5PA3DVG6tsma1am71/1xeihlGHX7Pup/w9pV1QGHwSVwRNC7gRMH6AnhqRAIuRj+vrDIa9dP20IPF4PEuUR+MncBB6PxzY+1KYo8NLodDQ5XAB4cLg8cHk9iI+WwtLkREyEEC63FxarEyIhH1OC9BZibJ5xHwamxLKfLVYHquvtqLhqBQBOs0QAVPZObgiVwRNCCEGSIgIrc7W4WGdDk8ONNXlZsLs8AV2dZWIBusVG4LXPTwRseW2fqYfV4cYfvzobMAtsul4NU4MD8dEKNLpdSFHKwOch5PcAgQnMcplvVSdSIgzZtJGCH3IzUABECCEdjMXqQE2DA3U2J2IiRFBFtrz1E+4er9eLMxfrEB8jBQAIeDzoNUqMyUxAZa0V8dFSHCo3wVBh5jyzyFiDBVtOoGCkJugsMB6ANyb3R7dY3zDTKnMT5vzrGGdrTKdRYkWuFrM2GpCVGhsygZkJ1moaHKi3OREtpZEX5OaiAIgQQjqQUM0Lw42ACHeP2+WB2erEtuMXUWI0sRVhf9ldHjB3iwlU/Gd9FRtNmDM2Pej3MtPey6ob4PZ6sWTryYAGisx3LBifgQfu6RI2oGFWgwi5FagRIiGEdBDhmhfO3XQMFqvjhu/xAFj1tZHTUydYMnSJ0YS1JeXI1wf2AGqwXQ+ImKaJa/KysHrKIDjdHvAAON2esN2j702JRSLN8CIdCK0AEUJIB9G8eaG/UCMgWrrH6nRzgh1tsoJTBu+vec8dRpRUAIA73NT/GTqNEjNHpIX92SprrYiSCmmQKekwKAAihJAOoq6FEQ/BRkDU2ZwBA0f9k4+b39OaDsz+9BolGu0uAOFXj2Y8oAn7XACYu+kYVXSRDoMCIEII6SBiWhjxEGwEhDxCFHJVZkWuFjER3HvCjbEAgPhoCVvFpZCJ0F0RAbfHi5w0VdjVo/3nTMjRqDgJ0P7vYqg00yBT0qFQDhAhhHQQTPPCYEKNgIiUCEOuyqwrKYdUKECO5vozmWaHweSkqVB6uR7T1x/GjI+O4sm/HsDLnx1HuakRWT1iESkO/e/MhcXlmD++T8CzmcaGhcXlAGiQKek4aAWIEEI6CLlMjOVBuiOH64fTYHOF7LxcbDThksWGafoekAh5SE+SIyslFhP6J2LpttPNOjkrMeMBDaavPxTwDB6Al8b0gd3lRihWhxsXzTZoU2KRr1MjUiJEo90FQ6WZU1lGg0xJR0EBECGEdCA32g+npbwh8IDTF+sw88F78NaOM1i128jmDP2/B3pBwOfB6nBDFSXGE3/5llMCzygymvCCy9cwMdw21+GKWqzabYReo8TAlNiA7TIaZEo6EgqACCGkg7mRfjgt5Q012l2IlYnx1o4zbJm61eHGqt1GrNpthE6jhDYlFhmJMUGDH4alyYmnCg9iRa4WHngDeggx87ty0lT4/cS+WLLtFOd+6upMOhoKgAghpBOLkgpbnKquTVaE7dETrPQ9GKvDzRmSCgAJMVLIxALUWh3Y8rwO8dESyGVivPX4AOrqTDo0CoAIIaSDaO0IDIvVAbPViQaHC1a7CwsnZGLZF6eQniRnS+EVMhGiJELkrzuEjMTwQyEjJUJIhPwWq7iA66tHjDV5WVi/78eA8nbq6kw6OgqACCGkAwg2ziInTYVlk/qhe5yMPXbR3ITzV61YubuU3YZSRYnxt/whWPbF6YBS+OWT+0PI44X97ka7C/nrDFiRq4UXXhT7D0RNU2H+uD64ZLGjYKSGM9gU8PUNovJ20hlRAEQIIbdZqHEWR87Xoqj0CgalxsLqcCNKIoSp0YG/7C3j5OA8MSQFv//idNBSeADI16mh0yiDVosxqzv+21vPPaCBWMCHw+3B/nMmTFq9D1aHO+i8MKavEJW3k87mtvYB2rt3LyZMmICkpCTweDxs3ryZPed0OjFnzhz069cPkZGRSEpKwlNPPYWqqqqwz1y4cCF4PB7nT3p68EF+hBByu1msDly02Njgh5m1VTh1MArzBiNVFYmtxy5iyocH8It39uK93UY8mZ0KmVjAPkObrAhZCl9iNEHA52H+uAxseDobq6cMQuHUwSgYqcHI9C6cHj3M9taUDw/A4fZgyocHsGq3kQ12ms8L898ao/J20tnc1hWgxsZGDBgwAPn5+Xjsscc456xWK44ePYoFCxZgwIABqK2txQsvvIBHHnkEhw8fDvvczMxM7Ny5k/0sFNJCFyGk42G2vXKHpAAIP2uLWXkpMtbAAy/y9Wq2pF0kCP/vshEiAV7ffoqTCJ2TpsL/PtQbT68/FLT6y9IUfEWHSZr2r/yi8nbSGd3WyGDs2LEYO3Zs0HNyuRxfffUV59iqVaswZMgQVFRUICUlJeRzhUIhEhISWv0edrsddrud/VxXV9fqewkhpC38t72m3tcDQPhZW8z5Vbt9k92f0ffEb3+RhrGZiahpsDd/PIfb4w2oAisqrYHH68UTQ1KCjrcINzIjUiKENiUWszYakJUaS+XtpFPqVKMwLBYLeDweFApF2OtKS0uRlJSEnj17YsqUKaioqAh7/bJlyyCXy9k/ycnJ7fjWhBASiJnizmxlMbO2wm1laZMVAHwrRYkKKbpESbBo20nsO2dCTqjxFhoV9p1r+ZnN72G2toJRRIjwYHo8thbosTJXi0Sa8E46oU4TANlsNsyZMwe5ubmIiQld0pmdnY1169Zhx44deP/991FeXo6cnBzU19eHvGfevHmwWCzsn8rKypvxIxBCCADf6o/d5cYH/30vNj13H6422PG70b1bvI+Z1J6vV2PptlPoGiNFidGEjw9WYOEjfYPO4Zo/vg+b49MaOo0S8x5Ox5mLwVfCh6epkCiXYmBKLHrFR9HKD+m0OkVyjNPpxH/913/B6/Xi/fffD3ut/5Za//79kZ2djdTUVPzf//0fpk+fHvQeiUQCiUTSru9MCCHBBCt312mUeCZGiqQWVlKYban7eiqxarcRudeSoZdP7o/Kq1Z2Dpfd5YFEyIeh0oyLZlvYDs8KmQj/+n/D4PJ42dWob36oxivj+sBxrcSdQd2cyZ2kwwdATPBz/vx57N69O+zqTzAKhQL33HMPjMbAPW5CCLmVQpW7M9te0/XqoM0IZWIB5o/rg/gYCT55diiipUJsLdCDx/Pi2eE9fZVZOnXQXJ6CkZqQJfA5GhW+Pnsl6MyuKUNSb2gmGSGdTYcOgJjgp7S0FF9//TWUyuB73OE0NDSgrKwM//M//3MT3pAQQlqPyfsJpsRownR9TywYn4HlO04j41pXZ4fbg5Q4GY5VmvGrP18fVqrTKDFzhAajM7ri3Z2l0KbEBg10CovLUZiXBT7ASYTWaZRY9Ggmlm7nzuzKabbKQwEPuVPd1gCooaGBszJTXl6O7777DnFxcUhMTMQvf/lLHD16FNu2bYPb7calS5cAAHFxcRCLff+jHDVqFCZNmoSCggIAwIsvvogJEyYgNTUVVVVVeO211yAQCJCbm3vrf0BCCPHT0uR2p9uDS5YmvDIuAwu3nAhZCm91uNlAZ84YX5+zwuJyrMjVAgAnCLo3JRZNTg/u7RGHqX7bY5frbPjyxEVkJMkxJTuVPa7pEkVJzeSucFsDoMOHD2PEiBHs59mzZwMA8vLysHDhQnz++ecAgIEDB3Lu+/rrr/HAAw8AAMrKylBTc/3fqC5cuIDc3FyYTCZ06dIFer0e3377Lbp06XJzfxhCCGlBuMntMrEAamUkDp+/ij8XnQtZCv/s8J5webzszC+RgI+CkRp8fLACJ36y4LcP3oOZI7yIlAjgBSCXCHHwx6vo100Ou8sDqUiAy5YmJMoj8PZXP+CJISmcd5D6NVgk5E7G83q93rbe7HA4UF5ejl69et1RzQbr6uogl8thsVhuOOeIEEJCsVgdmLnRwEksZrw5uR/cHi/6dpej8moTpCIBjlbUBsze2jpTh+VfnuEESKPSu+ClMX2weNtJznG9RonFj/bF69tPYeeZK+zxnDQVXhiVhnqbCx8Wc4Ot4WkqLJ/cv8WEbEI6ohv5/d2mMnir1Yrp06dDJpMhMzOT7bMzc+ZMLF++vC2PJISQTs1idaCsugGGilqUXWmAxeoIuEYuE2PpxL7QNytXH5XeBYPVcfjq9GX8++RlSIR82Jxu3NdLiY+fHcrpslzf5IKhwsy5v0+SPCD4AYBiowmvbjmB9CQ553hRaQ3+tKsUlyxNAffsLa3B3E3Hgr4/IXeSNi3bzJs3D99//z2++eYbjBkzhj3+4IMPYuHChZg7d267vSAhhHR0wUrbg62kWKwOLN52CgNTYjHNLx8HAH6/7RSezE4NGIOh1yjxYd5gPPlXXwK0FwgYSKpNVgStAAN8QdA0nTrguH8H6uZouju5G7QpANq8eTM++eQTDB06FDwejz2emZmJsrKydns5Qgjp6JjS9iPna1EwUsPm5khFAuz54Qoe7pvABhI1DQ7sPF2NnaerAfhybvL1aozO7Ir0JHnQMRjFRhN4OIt8vRqGilrsP2eCoaKWHYsBXG+QGEqo8+Huo+nu5E7XpgDoypUriI+PDzje2NjICYgIIeROV9PgwJHztSGHmA5Vx7Gf7S43Vk8ZBKlIgGMXzBjQXYEPi88hIzEm7CpOkbEGzz3QCwOTFezKT77fqk64uV3hzoe7j6a7kztdm3KAsrKysH37dvYzE/R8+OGHGDZsWPu8GSGEdAJ1NmfYIaa/334KP5mbULDhKB5eUYwZHx1F/rpDOPLjVUhFfBgqzJCKBC2u4ri9Xs62l//1hkpzQF4RQ69RBp3rlaNRoro++BBVmu5O7gZtWgF6/fXXMXbsWJw6dQoulwt/+tOfcOrUKezbtw979uxp73ckhJAOK0YqQlZKLACwYyiYCq6PD1YgNzsVZqsTudmpmKbvyVZ2FRlN8MA318vr9UIeEX7FxeHycKrB/FdvTlVZsPjRvnhty0lOF+kcjRKvPZKJ1784zXmWTqNEwcg0dFdEYHiaisZdkLtSm8vgy8rKsHz5cnz//fdoaGjAoEGDMGfOHPTr16+93/GWozJ4QkhrWawOXK6zY1GzKqyR6V0wZ0wfLN12MqAD8zSdml3NWZOXBQGPh7goMd7ccQbFQUZW6DRKaFNi2S2yHI0S8x7ugwa7G9FSIVxuL1Z/U4pe8dFsDlJyXAR2na7GoORYXDBb0TVGymmCOKynEuouUbBYHTTugtwxbuT3d5ub9/Tq1Qt//etf23o7IYTcMZYEKUHPCFGaznxmkpiZrawX1x3Ch3mDwcNZziqOXqPE1GsBE+ALhmaMSMPlOjue33AU96bG4vkHemHPDzX48sRl9r41eVl4d2cpm2jdNUbKnquy2MD8m69cRgEPuTu1KQAaOXIk7r//frz22muc47W1tZg8eTJ2797dLi9HCCEdXU2Dg7PCw/BPamaCEP8KMVWUGIXF5exWVk2DA0/+9Vvk69WYquvBXuf1etEtNgLrpg1BhJgPrxf4+mw1/rznHKwON4pKa+DxejlVYYAvL4iZDRZs2Okz+sDSeELuJm0KgL755hscP34cBoMBH330ESIjIwH4OkNTDhAh5G4Sar4Xs7IjEwuCVojlaJQozBuMiquNqKhtChms5GiUWDKxLwQyEX7xzl42mFqZq+XkGzF5SAxmNhifxwvoT0Q5PoT8jC2wnTt34te//jWGDh2KrVu3okePHu34WoQQ0rExuTMtlZiHqhDzrRrxkK/vgfhoKSb0T8LS7ac4wYpOo8TzI9MAAI12Z8hgSqdRYkL/RMjEAjZR2upwY9ZGA76clQOXx0s5PoQ006YyeABITEzEnj170K9fPwwePBjffPNNO74WIYTcXuFGW1SZm1Cw0YBRb+/BFycuQRekBJ0pTdcmKwKCH0aRsQYeLzB13SHsOHkRY/smYE1eFlZPGYQ1eVnQpsQif90hvLL5BMRCQdhy+6XbTiO/2bZWVmosFDIResVHYWBKLHrFR1HwQ8g1bVoBYvr+SCQSbNiwAUuXLsWYMWMwZ86cdn05Qgi5HcKNtogUC9hzMrEAQj4Pc8emo7rODh6Px5a5n71Yh99P6gdjdUPY73K4fVtlfZPkmL7+cNBrSowmWB1uDOupDNsscaquB+d9aauLkNDaFAA1r5yfP38++vTpg7y8vHZ5KUIIuV2Y0RZFzSa2M0NClzzalw1+Vj2pRWFxOd7dWcpel5OmwucFeni9XnxXWYveCeFLcbtESQC0PM7iSoMdsRHhgxl5hAibZ9xHW12EtEKbAqDy8nKoVCrOscmTJ6N37944cuRIu7wYIYTcDjUNjoDgh7G3tAaNDhcA4NnhPbG2uDygb09RaQ1e+/wEtCmx+L6iFksn9WMTnJvTaZQQX8sVammchVjAh9XpDntNrEyMXvFRYa8hhPi0KQcoNTUVfH7grX379qVVIEJIpxaqqovRaPcFIXqNKmj5O+DbstImK1BkNGHJ1lP43ej0gDwhpiGi0+XB5hn3oacqEjlpqqDP010bZ3G0ojbkNTS+gpAb0+oVoMceewzr1q1DTEwMHnvssbDXfvrppz/7xQgh5HaIkYqC9u1hcnt4PF9A4nKHb6LPbGntPFON/x6a6ktovjYqQyLkw1BpxqyNBmx67j40OVzwAljyaF8s2Hw8ZOfo+3oqsfjRTLy25SSNryDkZ2p1ACSXy9nkZ7lcftNeiBBCbqdoqRCFUwdj5e7SgFLzwrzBEAt5mDe2D3gtPMd/S8vt9QZNXtZrlNh+/CIKi8uRr1dD10uJWaPuwcvjhHC6Pbja4MDhilrM2mjAoBQFZo5KA7zAylwtja8g5GdqdQC0du3aoP+ZEELuFFXmJpQYa/D5dz/BUGFGwUgNZxWo3NSIzKRoVNfbkRwbETa3x38CezdFBPQaJSdfiBlxMXfTsZCNEheMz0Q/twd/fSoL0VIh/rKnDL+f1I/GVxDSDtqUBN3U1ASv1wuZTAYAOH/+PD777DNkZGTgoYceatcXJISQW4Gp/pqmU+NIhTlkw8F7UzJRsOEAFk7IwMxrTQpLQmxZAb5AB/CNqpgzNh0NNjcUMhG2H7+IWRsNYRslLtl2Er8bk47/nLqMsxfrsPjRvhT4ENJO2jQN/qGHHsJjjz2G//f//h/MZjN69+4NsViMmpoavP3223juueduxrveMjQNnpC7T1l1AyasKkZh3mAUl9XAUFEbdHUnR6PCS2PSsevMZeg1SpRfaUTP+Ch4vYDD5cG+cyYUFpfD6nCzwdDHByvw8tg+qGl0IELER5PTg//6834AvqGlofr/AMAXs/SQCAW0zUVIK9zI7+82VYEdPXoUOTk5AIB//etfSEhIwPnz5/G3v/0NK1asaMsjCSHktqqzOZGvV8Pt9bbYvbm63oZDP15Fo92NwWol3v3qBzxVeBD7zvmqv1bmarF1pg6De8Rh1kYDdp6uhtXpxp92/YAJq0pQ71dp1lL/H4fLQx2cCbkJ2rQFZrVaER0dDQD4z3/+g8ceewx8Ph9Dhw7F+fPn2/UFCSHkVoiRiqBNVmD/OROyUmID8n+YKjCrww27y4MSowmPDkhClbkJU3Vq5GZzr9OmKKBNiWVnczXYXRiijkO+To24SDFyNCoUGWta7P8TLRXdih+fkLtOmwIgjUaDzZs3Y9KkSfj3v/+N3/72twCA6upq2jIihNwWzHDSOpsTMREiqCJbt2V0uc6G2kYH6u0uREmE+PhgBR7TdsNfi88F5P+syNVi1kYDJEI+ZGIBBibHYtG2kwE5QMx1+brrs7ncHi+cbi+mrz8MmViAwqmDAZ5vZlioZOoc6u1DyE3Tphygf/3rX3jyySfhdrsxatQo/Oc//wEALFu2DHv37sWXX37Z7i96K1EOECGdS0uzu+qanGhwuFF/LTiKlYnRNUaK86ZGvPzZcTb4KJw6GEcravFdRW1Ah2fAF9yM65eIKosNAPB9RW3QZog6jRLalFhkJMZgxkdHkaNR4t4ecRiTmQCb082Wrl+ut6PB5kSURIQl206hyMidBD9zZBr6JETT9hchrXQjv7/bFAABwKVLl3Dx4kUMGDCA7Qp98OBBxMTEID09HQBw4cIFJCUlBe0a3ZFRAERI52GxOlCw0RB0fMW4fgl48aHemL/lBGeFRa9R4veT+mH5l6fx5YnL7PE1eVmQigSY8uGBkN+3daYOv/rzt1iZqw2bvLwmLwsAUFhSjoIRabA53VBGitA/OZa9pqy6AT+aGjHzWjUYs+XGNEosLC7H1gI9jbcgpJVu5Pd3m7bAACAhIQEJCQmcY0OGDOF8zsjIwHfffYeePXu29WsIISSscLO7HhvUPSD4AYBiowmvfHYc03RqTgAk4PEg4IVvcXihtonNA2pJl2gJtCmxmL7+ELQpCrw+sR/nvCpKjB9NjbA63CGnvNe3MJqDENI2bQ6AWqONi0uEENJq4WZ3xcdIQlZzFRtNmDM2nXPM6nSjpbBGLPCtaMsjwicnx8dI8Ks/f8smQZcYTQFBk1wmRvfYiLDPoSRoQm6OzrU3RQghzcSECRAabOGnp1vtbqyeMgiFUwejYKQGMpEAxy6YkaMJPnA0J02FbooIrMnLgs3pDhhwyl6nUWLX6Wo2+GFcMFtRZW7iHEuIkWI4DTgl5JajAIgQ0qmposQhA4gYafhFbplEgBkfHUXBhqNIkksRHyPFUHUcXnskAzlBprc/P0IDsZCPmRsNmLnRgGk6ddAp73k6Nf6y91zA93m9wNxNx2CxOthjcpkYyyf3D/gZaMApITdXm5OgWyM6Ohrff/99p8sBoiRoQjqXKnMTXt1yAumJMWwisUImQpJcivmbTwSt6MrRKDF/fAbO1TQiOVaGYxfMWLr9NKwON2RiAeaP64N+3eW4UNsEseB6UvKHT2XB6nSzoy78k5fjoyUorW7Akm2nAlZ/mMqwVbuN2DX7/oDEZqaMnwacEtJ2N70TdGvxWkgm3Lt3LyZMmICkpCTweDxs3ryZc97r9eLVV19FYmIiIiIi8OCDD6K0tLTF733vvffQo0cPSKVSZGdn4+DBgz/nxyCEdHBJigi8Mq4Pvq+oxfT1hzHjo6N48q8H8MaOM1g6sV/Aak5OmgrPj0jDpNX78Nw/jmL8ymJsP34RK3K1kIkFsDrcePmzE1j+5RmcrKrD9PWHsWq3EVaHG+YmJ9aV+Ka3M8nLzHf+eU8ZcjQq3Jsay/k+ZiRGYXE5gOCJzXKZGL3iozAwJZY6PxNyC9zWJOjGxkYMGDAA+fn5eOyxxwLOv/nmm1ixYgXWr18PtVqNBQsWYPTo0Th16hSkUmnQZ37yySeYPXs2PvjgA2RnZ+Pdd9/F6NGjcfbsWcTHx7fLz0UI6Vgu19lw0WxDbnYqpul7st2Y9/xQg3ydDQ/3S8RUnZpdpfnhcj3y1x/irNIwydL5ejVbkVViNHGaGcrEAnSPjcA0nRpREiEGpcSy35WVGovFj/ZFoiICSx/tC+OVBk5J+6yNBvb7KLGZkNvvhgMgp9OJiIgIfPfdd+jbt2/Ya0+dOoWkpKSQ58eOHYuxY8cGPef1evHuu+9i/vz5ePTRRwEAf/vb39C1a1ds3rwZTzzxRND73n77bTzzzDOYNm0aAOCDDz7A9u3bUVhYiLlz57bmRySEdDDhujxXmZsw51/fcxoSMt2YT1ZZ8O6uUk4l2Jq8LLz82Ymg39M84AGuz+qSiQUozBuMP+w4w/muHI0S22fqEef3TgqZCOv3/Yi9QcrzKbGZkI7hhrfARCIRUlJS4HaHr64AgOTkZAgEgja9WHl5OS5duoQHH3yQPSaXy5GdnY39+/cHvcfhcODIkSOce/h8Ph588MGQ9wCA3W5HXV0d5w8h5NawWB0oq26AoaIWZVcaOAnCgC/AKdhowKi392DS6n0Y9cc9mLnRgCpzEyxWh68DdLMcnxKjCWtLyjGid3xAGXxL/Xuan2dmdS0Y1wfvfV0a8F1FRhNe/fwk5xglNhPS8bVpC+yVV17Byy+/jL///e+Ii4tr73cC4Os0DQBdu3blHO/atSt7rrmamhq43e6g95w5cybkdy1btgyLFi36mW9MCLlR4UZYJCkirgc4zVZS9pbWYO6mY1gwPiNkE8Rg/X+YLaw1eVlBh5wC4AwnzdGokCCX4qOnsyER8lEUYuWoqLQG1fV2TmCTpIjAylwtJTYT0kG1KQBatWoVjEYjkpKSkJqaisjISM75o0ePtsvL3Srz5s3D7Nmz2c91dXVITk6+jW9EyJ2vpeCGCR5CBTh7S2tgbgrfJdk/x0cmFmBFrhZv7jjDqQrzH16qTVHAUGkG4BuXsejRTFyus2HKhwewesqg8D9PkHeRyyjgIaSjalMANHHixHZ+jUDMmI3Lly8jMTGRPX758mUMHDgw6D0qlQoCgQCXL1/mHL98+XLA2A5/EokEEonk5780IaTVWgpumJyfUGRiAaIl4f8RJhUKkKNRochYg3y9GmtLygNWhpjPC8ZnIFsdB+OVBmydqYPXC+QVHsTvJ/nGV/ivDIV6H0JI59GmAOi1115r7/cIoFarkZCQgF27drEBT11dHQ4cOIDnnnsu6D1isRj33nsvdu3axQZpHo8Hu3btQkFBwU1/Z0JI64ULbgBfqXioLs/Mao6hohY6jTLodldOmgpxkSIUjNTAAy+0yYqQ87ZKjCb87qF0fHniIv7w7x/wr/83DE8VHoTV4YbT7csJMlSaQ36XTqNEpPimFtUSQtrZz/pf7JEjR3D69GkAQGZmJrRa7Q3d39DQAKPx+j+QysvL8d133yEuLg4pKSn4zW9+g6VLlyItLY0tg09KSuKsQI0aNQqTJk1iA5zZs2cjLy8PWVlZGDJkCN599100NjayVWGEkI4h3AgLAGzOzPA0VUA1Vb5ejXUl5ThaYcaKXN8/d/wDk5w0FRaMz8Dh87UY1lOJVx7ugwa7bztMJhZwmhcyeUCX621IT4iBTqPENz9cYbfPDJVm6DVKFBaXB/8ujRLPj0yDQkal7YR0Jm0KgKqrq/HEE0/gm2++gUKhAACYzWaMGDECH3/8Mbp06dKq5xw+fBgjRoxgPzN5OHl5eVi3bh1eeuklNDY24tlnn4XZbIZer8eOHTs4PYDKyspQU3P9H46/+tWvcOXKFbz66qu4dOkSBg4ciB07dgQkRhNCbq9QwQ1wvVScqaZ6bcsJ9Pbr8pyqlAEAjlb4+uvk69XIv9bnRyoSICVOhgtXrZBHiFBvc0EeIYKlycmuHK0tKeesBuk0SjzSPwlV5ibMHJmG/HWH2HNnLtZh6cR+WLDlBOe7AN/A0zMX69EjTka5PoR0Mm0ahfGrX/0K586dw9/+9jf06dMHgK/nT15eHjQaDTZu3NjuL3or0SgMQm6NKnMT5m46xgmCftEnHgsfyYTN6UGdzQlFhAgCPg+vfHY8oNfPNJ2a02CQCXDWl5Rzrh2epsLrk/qhyFiDbceqgm+ZaZRYMrEvYmViXKqz4UKtb2ipodKMjw9W4H8f6o1BKQo02n2jMgR8HgR8HpSRlOhMSEdxI7+/2xQAyeVy7Ny5E4MHD+YcP3jwIB566CGYzeYbfWSHQgEQIbfO5TobahsdqLO5IJcJESES+oKda0FRwUgNDBW1IXNvmPlaLV37iz7xeHF0b4x+tyjku/znN8PRNUaCgo2GoAnaw9NUWJmrpYCHkA7qRn5/t2kLzOPxQCQK3O8WiUTweMI3GSOE3L2Yjs6WJgdkEiF4AMxWB4qMJhQW++ZrNQ9gWkpe9u/cHO7ar05X49nhvcK+X53NCQGf12J1GgVAhHR+bQqARo4ciRdeeAEbN25kR1389NNP+O1vf4tRo0a16wsSQu4MwZoeMttYp6osWJGrhZDHCwhgbrRzczgSUcul7K2pTiOEdH5tboT4yCOPoEePHmzDwMrKSvTt2xf/+Mc/2vUFCSGdX6imh8xKjzYlFmtLyvHiQ70D7m2p/05yXARWTxkEiZAPZWTL/bxaKmWXCMNnBdAgU0LuDG0KgJKTk3H06FHs3LmTHTHRp08fzgwuQghhhGt6yGxjrdptxNyxvIDzhkozcjTKgBlcgC9o+ffJy5wcIL1GiWKjKaDcXSET4WqDA9P1avZ7/Z8z06+UvaXqNEJI59emJOg7HSVBE9I+mJwfU6MDDXYXZ+6Wf4AiEwvR5HQjSS5Fnc2BepsbPB4PNqcbESIBeihlWLL9FHafucI+O1wV2McHKvBEdkpA52edRomn9T3x/QUz+nWTQyYWIlIiwMmqOoy4pwsSFBEAglenMYNME69dQwjpeG56FRgAHDp0CF9//TWqq6sDEp/ffvvttjyyw6AAiJCfL1zOz9xNx7B8cv+AAOXB9Hj8bkw6lmw7yZnXlaNR4X9H94a50QGr043usRH4z6nL+PhgBZ4YksJpanj8JzMe7puIxVtPhlw1YirH1uRloZsiAolyaUBiMxO80SBTQjqPm14F9vrrr2P+/Pno3bs3unbtCh7v+rK1/38mhNydWsr5eeuXA1BlaUK+To0p2alsN2aRgIfF204G5OgUGWt84yz8AhemM3OwpoajMxKCBj/MO+Tr1NBplKiutyMrNTZoYEODTAm5s7UpAPrTn/6EwsJCTJ06tZ1fhxByJwiX82OoMCNFKcNfi88FbE+9Nj4Tf95zLuh9/iXvhkoz5o/rE3K46U/mphbfcebINOrgTMhdLHx5Raib+HzodLr2fhdCyB0iXCl5vl6N17acCBq4LNl2Evn66319ZGIBCkZqsCYvC6unDELXGCkKRmrw8cEK9OsuD1rN1RrdYiPQJyGazfkhhNx92rQC9Nvf/hbvvfce3n333XZ+HULInSDcoNNwzQqLjCZMvbbKE2puV06aCh8/OwxmqyPkd5yosmDZpL6Ij5FyBp4WFpcjKzUWiTGBOT+EkLtLmwKgF198EePGjUOvXr2QkZER0BX6008/bZeXI4R0PharA0I+DzlpqpDbYOEwaYT5enXQLa6i0hq89vkJzBmTHvR+mViAft3kWFtcHjA7rHDqYNr2IoQAaOMW2KxZs/D111/jnnvugVKphFwu5/whhNydqsxNKNhowNgVRVgwLgM6jZJzXqdRIj4mfLPCJEUERqV3gTZZEXKLq8RogsPlCXg+4Auc1jQLfph7Vn9tRIRYcIM/FSHkTtSmFaD169dj06ZNGDduXHu/DyGkk2pe+VVuaoQ2JRb5OjXsLg8kQj4MlWbsOl0dtrGh4bwZLzx4D9vbJ5QrDXZM0wU2NbyvpzLkFhvN8iKEMNoUAMXFxaFXr/BDBQkhdxf/yi+ZWABlpDhoICITC7B5hg6LmpW7+zc2/OTXQ2F3hp/xJRbwMXOjAfl6NfJ1asjEQlgdLohbGJ1Bs7wIIUAbt8AWLlyI1157DVartb3fhxDSSVisDpRVN8BQUYuyKw1we72QiQVs8vIPl+uDblFZHW5UmZugTYllq7vW5GVBmxLLdnWurrMjOc63FRaMTqOEodIMq8ONVbuNmL7+MKwOF9bv+xHyiPCzumiWFyEEaOMK0IoVK1BWVoauXbuiR48eAUnQR48ebZeXI4R0TMG6POekqbAiV4uTVRasLSmHocKMFblaANwtqhyNEsro4KtDjPgYKQ6cM2HRhEw43Sc4Iyn8V4r8j1XX2/Hm5P7ghUnAHp6mQpRUiLLqBtTZnIiJEEEVSQ0PCbkbtSkAmjhxYju/BiGkswjV5bmotAZerxcvjUnHO1+VAgBm+W1RMXlAXaIl2HW6OuxU9n+fvARDRS2G9lJiZa6WHUkRIRbgaIWZM/8rJ02FJY/2RaxMhEaHG69+dhx59/WAx+vlPH94mgpLJ/bFK58dx87T1Zzjyyf3RxL1BCLkrkLDUIOgWWCEhFZW3YBRb+8JeX7rTB0mrCxhPzefyp4SJ8OuM5evlar/iCJj8NUdq8ONHI0Kyyf3Q7dYGXtNqBldFqsDBRsNKCqtCZwEHyFCD1UkXt1yghP8MIanqbAyV0srQYR0cjd9Fhgh5O7BBBzMlhGT6xOqSqvJ4Ubh1ME4WlGLjw9WsENPOc0MNSqM7ZuARY9motHhQuXVJrZKzH91p8hYg/MmK6IkQjY4CTWjyz8Jm8kN8rfjhZygwQ9A1WGE3I3aFADx+fywQ0/d7vDlq4SQziFcro9/oOKv3ubC9PWHodMo8WHeYKzY9UPQ4aaLtp7CnDHpuFJvx4yPQucNmpucrQpOwo3f8J13hT1P1WGE3F3aFAB99tlnnM9OpxMGgwHr16/HokWL2uXFCCG3V0u5Pvl6dcAqC1OdBfgSn/k4iwEpCuw+cyXg+SVGEyyNzhZzbyRCfquCk3DjN3znw//jjqrDCLm7tCkAevTRRwOO/fKXv0RmZiY++eQTTJ8+/We/GCHk9go30b3YaMKMBzScAChYdVaRsQYvPJjG5uL4z+SyOtyod7hw7Iw5ZNUWE1BNGtitxfdVRYkxPE3FqRhjDE9TITYy/HlVFG1/EXI3aVMfoFCGDh2KXbt2tecjCSG3SbhhowAgEfGx4elsbHxmaEAfH3+WJiemrz+MGR8dRf66QzBU1GJFrhYysQASIR/vfV2G/32oN/RBxmZM06lx5mId3F4vyq40wBLmneQyMZZP7o/haSrO8eFpKrwxuT+6xkjDnqf8H0LuLu2WBN3U1IQVK1agW7eW/02NENKxWawOSEXhZ2ZFSoT4nzX7sDJXi+nrD7f62Uw+0Pxxfdhmhk+vP4R//b9h+Mlsg6XJySZEbzxwHrnZqZj4XgmsDneLJetJighO2bx/lVhrzhNC7h5tCoBiY2M5SdBerxf19fWQyWT4xz/+0W4vRwi5cc2rttrS6M9sdeL7C+aQvXpy0lQwVJiRr1fDUBn6Ov+cIH8lRhPmje2D6vrLWJOXBQCotTphc7ohFQkgFPAwrKdvRch/VWlvaQ3mbjoWtmQ9VJVYa88TQu4ObQqA3n33XbjdbggEvn9D5PP56NKlC7Kzs1FfX9+uL0gIab1gVVs30uiPCZ5sLjeWbj8dtJOzTqPEokcyMX5lMVbmajFzoyFkx+e8azlBzfvySEUCCPg8HLtgxrs7SznPnqZTw+UGnlp3MOg7Usk6IaQ9tCkAys/Px8WLFxEfH885bjKZoFarqQyekNsgVNUWs2ryh8cHoMHmCrky5B88ffzMUFgd7qCdnA2VZtQ02NlVGf/r5oxJx4XaJrbj8xN/+RYAsCJXG7QXUJ6uB749d5V9FhNA/Xp4+GHLVLJOCPm52hQAeb3eoH2AGhoaIJVKf/ZLEUJuXLiqrcPna2FqsOOixQa7y4NaqxMHy6/igXu6IFERERA8CQW+/30HaygIAA/c4xtSGh8jgV6jRLHRhFW7jdAmK9iePgUjNdCmKKBNicXakvKgvYAALz5+digu1DZxKsRiI2mgKSHk5rqhAGj27NkAAB6PhwULFkAmu96e3u1248CBAxg4cGC7viAhpHVCNQJkprMv++I0ipptZalVkZCJBQHB04FyE5Y91g/x0ZKA8vV7U2JRbKxBjkaJXaerMTAlFs89oIHb60VshJgtaS8sLseKXC0iRIKQg0+LjCZM9WuEqNMosSJXC48HIfOKqGSdENIebigAMhh8/T28Xi+OHz8Osfj6P4TEYjEGDBiAF198sX3fkBDSKqEaAebr1UFXYJjPr0/sxwmeZGIB+iTGYG1xeUDAVJiXBbvLg7/vP4/fjUnH1QYHrE43XG4PUlUywAPMG5sOr/c0io0mzNpowAf/fW/Y97a7PAHvNG9sOmaOTAOfxwvIZ6KSdUJIe7ihAOjrr78GAEybNg1/+tOfbsmg0B49euD8+fMBx2fMmIH33nsv4Pi6deswbdo0zjGJRAKbzXbT3pGQjiBUI0BtsiLkCkyJ0YRGh4sTPOXr1VhTHDxg4vN4eHV8H8x7uA+q622wXqvaOnS+Fn/f/yOm5/TES/86hvemDMJzNhcsTc4Wt7MkQm47shKjCUIBH30SZFhFJeuEkJukTTlAa9eube/3COnQoUOcpOoTJ07gF7/4BR5//PGQ98TExODs2bPs53Bzywi5UzCNAOduOha023EoVocb3RQRbPAULmAqKq2B2wss3HoioDJsmk6NNUW+bS9TgwMerxcykQAutxc5GhVn6rv/fcHK5G0ON2f4KSGEtLcOPw2+S5cunM/Lly9Hr169cP/994e8h8fjISEh4Wa/GiEdTvNGf5ESITxeb9h7IiVC2FwevDG5P+ZsOsbZkgrmp9qmkNtp2pRYXG10sMNQp+nUeOZvh7F8cn+AB852VrDRGQxKciaE3GwdPgDy53A48I9//AOzZ88Ou6rT0NCA1NRUeDweDBo0CK+//joyMzNDXm+322G329nPdXV17frehNxKTKM/pqz9pdHpYRsVbj9+Ed9V1OL3E/vhrccHwNQYfgRGKCVGE1suz3zmA/jvoamYtdGAT5+7Dz+Zm2B3eRAfLcEPl+uDjs6gJGdCyK3QrrPAbrbNmzfDbDZj6tSpIa/p3bs3CgsLsWXLFvzjH/+Ax+PBfffdhwsXLoS8Z9myZZDL5eyf5OTkm/D2hNw6/mXtVZYmTNerkdNs1laORonpejUKi8tRbDThlc3H8aOpEXyer0dPMDkhtqwYIiEfyXERWD1lEAqnDsaAlFj8IiMeQ3vGwQuwM8GeKjyI+BgptCkKzv2U5EwIuVV4Xm8L6+MdyOjRoyEWi7F169ZW3+N0OtGnTx/k5uZiyZIlQa8JtgKUnJwMi8VySxK9CWkvTCfnq1YH6m0uHK2oRXaPOChkYrg9XticbkRKBPACOHOxDl1jpPjughl9k+SwuzxQqyLBgxc8Hh+Lt50MyPN5bUImO5crmI+ezsaUDw9w7xmfCYfbDZlYiAVbrucO+XeHBoBuiggkyqUU/BBC2qyurg5yubxVv787zRbY+fPnsXPnTnz66ac3dJ9IJIJWq4XRGDypE/BViUkkkp/7ioTcdOHmfAUbgzEyvQsmD+qG+ZuDJy3/ff95jOwTj5nXOjkzFVndYiMwd0w6+HygweaGTCJEdZ0NX526BG2KIuh2ml6jxP5zgblBS7adwssPp0PI42GaTs0eZ5osMu8iFvIp+CGE3DKdJgBau3Yt4uPjMW7cuBu6z+124/jx43j44Ydv0psRcmuEm/MVKRYEHYORkSTHq82CH4CbtJwkjwgxquL6LC+rww2dRomn9T3RJzGG8wzANxw1774eQROai4w18ACQy0T45GAFtCmxAaM1PjlYgbceH/Cz/44IIaS1OkUA5PF4sHbtWuTl5UEo5L7yU089hW7dumHZsmUAgMWLF2Po0KHQaDQwm834wx/+gPPnz+Ppp5++Ha9OSLsIN+drzqZjWPxIJgYkK3DkfC1ne6qlHkD5OjXkMhHe+s/ZIKMqTPDA1xdo1W4jm9Q8tJcS2pRYPP+ABiIhH1IRHyIBH4+t3hdya6zpWln7okf7Yu6mY5x3orwfQsjt0CkCoJ07d6KiogL5+fkB5yoqKsDnX8/lrq2txTPPPINLly4hNjYW9957L/bt24eMjIxb+cqEtBuL1YGLFlvIOV9FpTU4V9MIQ0UtVuRqOZVVLZW0210eCAW8oFtawPUgiXGkwowlj/aFF4DV6Ua9zQWHywtJC/8kkUf4ytqbl+lTc0NCyO3SKQKghx56CKFytb/55hvO53feeQfvvPPOLXgrQm4+Ztvrv4em+oaLJisCZnNZHW7YXR42iGFWbIDALsvNKSJEaLQFX7VhiIR8yMQCAMB7Tw7CpTobVn5tDNgCWzt1MKatOxSwCpSTpkJ89PUcO6ZMnxBCbqdOVQZPyN2E2fY6cr4WamUkDBW1bBl5/rpD7IqPTCxgA50SowmjMxNQMFIDmVgAQ6U5oPydkaNRoUtMy8n/Ah4PK3K1+PX9PXHR0hQQ/AC+VahVXxuxYFwfzvHhaSq8SdtbhJAOqFOsABFyJwhXwRUMM6G9YKQmoCQduJ6EPH9cH05vnsqrVjY42nz0AhZP7Bu0CixP1wPLvjiN3zx4D/QaJYpDNErcf84EQ0Ut5oxJx5V6e8jtsqLSGrwwKg0bns6GRMSHIkJM21uEkA6LAiBCboFwFVxJioig9zAT2kMlMsvEAmhTYjEwJRaxpkYUTh2MoxW1iBYLoU2JhUwkwP8M6wGb0405Y9LRYHPB3ORkK6/8c4VeHJ0OHu9syFEVVocbAh6vxZwiAMhMiqGghxDS4VEARMhNFq6Ca+6mY1iZqw0aMDAT2oMFHTKxAO89OQgXLU24aG4CkyLXTS5Ft7gInNpv4QRNzRsU+tt95gqeGtoDL4/tg6r7mtjy9BNVFpz4yYKVuVrfO/CA7rERkIkFIau9Yim/hxDSSVAARMhNxmxlBbO3tAY1DY6gQYMqSozhaSpIRYKAc7++vyekIj62H78YsLXVQxWJAckK7D5zhT1uaXKGfUer0w2X14Pp6w8D8AVYTG+gd3eWstflaJRYk5eF6esP0wwvQkinRgEQITcZs5UVSn2I83KZGG9M7g9zkxOj0rugT5KcrQK7p2s0Xvs8dIPDOWPS8c5X1wOXlqrB5BEiVNfZ2aGp+Xo11paUB+0NBPAwf1wfvPzZCfZ4DvXyIYR0MhQAEXKTMVtZoUSHOS8TC7B02ym8NKYPFm87yW5rfV6gC9u7pzlDpTnkRHi9RoloqRAvfGzA8sn9AYRvoFhkrMG8h/vg8wId7E4PFDIR4qMlFPwQQjoVKoMn5CZjtrKCGZ6mQpRUiHNXGvDD5XqcuVSHo+evouxKAy7X2XCpzgZ1fFRAFZjVHr53T/PtqcLickzTqQOmvOdoVFj8aF+8/40RNQ0OzNpogDYlFlEtdDb80dSIR1aVIC5SjLSu0RT8EEI6HVoBIuQmk8vEWD65P+ZuOoa9zarAlk7si8VbT2LSoO4BW056jRILxmcgKyU2YDVGKOCF/U4hn3ve6nBjw4HzePWRDDTa3DA12gH4Vob+68/78cSQFKzJSwYAKCMlcHnCV3tJhHzK+SGEdGoUABFyCwQbARElFeKVz44jPTEmaL5NsdGEpdtOY/ZD9wQ8r9hYgxyNCkXGwOTqnDQVzl1p4BzTaZR4YdQ9WPbFaUzJTmWTnRn+AdaavKywW2Y6jRLV9XbK+SGEdGoUABFyizQfAVFW3YCdp6uROyQlbL7N3LHpAcf/svccVj2pBeC9lpjsk6NRYrpeje8vmPHR09kQCXiot7lgqDSjttGB3Weu4Jf3+lZ6ZGIB8vXqgPEaLo8XhcXlWJGrBRA49X3Jo30RKxNR8EMI6dQoACLkNmGqw1pqLtjocAd0arY63CjYYMCCcRl44cF7UF1vh1Qk8M3M8wJp8dGwuzyIj4nAX/acw84z1Vg9ZRAA3/aVf5m7f/Cl0yjxSP8kAMCsjQbk69XI16nZ3kCaLlFIVUW2918FIYTcchQAEXKbMNVhLZWoWx0uX6dmnOVseWlTFBiUqsCk1fsAgA1oSpqtCC2e2BceeNnvMVSaMX9cn6DbbiVGE5ZsO8kOVPUPjoanqbDy2qoQIYR0dlQFRshtwlSHMfk2weg0Shw+X4sn//otBqQo8NHT2fjb9CHYOlMHbUosLpptsDrcYfv2vLr5JKZkp6JLtAQ5GiUKi8vRr7s89Ewvown39eS+z3Dq80MIucPQChAhtwlTHfbalhOYplMDQEAV2FS/WVyGiloMTFZg1kYDfn1/T3RTRCBKKsSavCx0jZECAAwV5oAS+CJjDf7fA73wxF++xYpcLTwox4XaprDvJhUJsGv2/WzCNg01JYTcaSgAIuQ2SlJEYOEjmai8asWLD/XG3LE81FqdEPP5SJBLcKnOhrceH8AOMJ276RieHd4TD6Z3xaU6G+quJTgXFpdDm6LAilwtZ8gpQ8DnYVCKgs3r6R4bfAArQx4hQq/4qJv5oxNCyG1FARAht5DF6kBNgwN1NidiIkSIkgjx2ucnsa/MN34iKyUWcpkIQgEfP5ltiIsU49yVRizdfhqAL89nfbP5XDqNkg18gHI2f8efQibCH/9rIOqanKi4aoXX68sPKgqyDUb9fQghdwMKgAi5RarMTQFT4XPSVJim64Ep2an4+7c/YmCyAm/952xAIvPmGTo4XB68seN0QNDCXMskKEeKhRiUEoujFbUoLC7HvamxSIyRQi4To2uMFJESIV7bcgJ5OjU84G67Ua4PIeRuwfN6vd7b/RIdTV1dHeRyOSwWC2JiYm7365A7wOU6G8qqG2BucrL9dgqLy2F1uJGjUeL5kRoI+XxYmpzg8Xic84BvZMUr4/tgzLtFIb/jo6ezMeXDA+xnnUaJghEaCPg89G42rsJidcDU6IDb44Xb44XV4YY8gnJ9CCGd2438/qYVIEJusipzE+b863vOyo3/tlWR0YTnHtDgl3/Zz57PSVNh47NDMX3dIdQ0OFBkrEFdkyvs91iauFPlS4wm8AHc2yMOykjusNLmTRkJIeRuQ2XwhNxEFqvDt+0VZNtqbYkvXwcAzM2Cl6LSGry14yzWTh0CmVgAAOz/DSVYP6Eiown9uslRb3MGuYMQQu5eFAARcpNYrA5ctNg4OT/+SowmaJMVAEIFLzXg84Bf398TACAV8cP2CzJUmoOes7s8iL7WdJEQQogPbYER0k6YvBqXxwuPxwtTowMCfvip7XaXJ2zwcqnOhrGZifi+0oxGuwvTdGrwweN0hM5JUyHvvh7XqsACKa7l9hBCCLmOAiBC2kGVuQmvbjmBJ4akcDoyr8nLCnufIkKEaTo15m46hoKRmoDBpAIeD0u2ncLvxvSG1e7CrI0GfPR0Nl4a2xuVV5vYlaOPDpwP6P0D+JoppipllO9DCCHNUABEyM/E5PkMSFZgbUk5DBVmNpgRCfjY8Ew29pWZOFVdgG/lJjk2ApfqmvDR09lYuu0Up3+PXqPEg3264khFLRrtLqTEyZCVGourjQ7YXR7M+OgoALCDTe0uT8Dk9mWT+qFbrOzW/WUQQkgnQWXwQVAZPLkRZdUNGPX2HqzJy8LMjQaselKLwuJyzvT25mMtdBolpunU2HjgPH7z4D14Y8cZzvUMnUYJbUosRvaOx6DUWPxUa8WVBgfsTjcaHW62XB4A8vVqdgWppyoSiXIprfwQQu4qVAZPyC1Ud63Cyu7y4NnhPbG2WfADAMVGE3jg4aOns3G10QFDpZkNhqbrewYNfgBfonS+To1oqRBV5ibM/fQ4J6nav5yeWT1iprZT8EMIIaFRAETIzxRzrcJKIuRDr1FxxlT4KzLWYKquB6avP8w53rwEHvBtazErOpFiITxeL/b8cAVHztdyrmO2vJjxF9TJmRBCWocCIEJagVPh5fXCandBLhNDFSmGKkqM4WkqGCrNyNGowj7H7vIEHGteAs/k9KwtKefkBPmv9vjnEpUYTXjl4T6YNLAbdXImhJBWogCIkBaEqvACfNtNSyf2RcFIDT7YU4axmQlhnxWs3w8TODGl7fl6dcD3AIGrPf4cLg8ykuRt+vkIIeRuRI0QyV3DYnWgrLoBhopalF1pgMXqaPG60sv12HP2Cvp2kwcNSvaW1uDlz46jwe7CjAc0kIoEIZsV6kP0+zlVZcH/ju7N3qdNVgR8D8O/eaI/anRICCE3psMHQAsXLgSPx+P8SU9PD3vPP//5T6Snp0MqlaJfv3744osvbtHbko6qytyEgo0GjHp7Dyat3odRf9yDmRsNqDI3hb3uF+/sxbbjVRjVJz5kUFJsNEEiFOCXH+zHtuNVKBihCQiCdBolFj6SiTNVFs7xnDQVnsnphafXH4I2JRZr8rIgE4dfmG2+jTY8TUWNDgkh5AZ1ii2wzMxM7Ny5k/0sFIZ+7X379iE3NxfLli3D+PHjsWHDBkycOBFHjx5F3759b8Xrkg6GncfVbCTF3tIazN10jK2YCnVdidGE6jp72O9osLtQMFKDft0UEPB4eOXhPrA63LjSYIdYwMflOhuqam3o212B3OxU2F0eSIR8JMmlEAr46JMQzW5rtdQ80X8bjZKeCSGkbTpFACQUCpGQED63gvGnP/0JY8aMwe9+9zsAwJIlS/DVV19h1apV+OCDD27ma5IOqqbBEXIe197SGtQ0OCCXicNeF44qSoy0+Cj8Y/+PnNycnDQVXpuQiQtXraiy2LB0++mAbs3//k0O3txxBvf2iMNLY9NRXWdHl2gJcjTKgAGqzDN7dYnE5hn3IVoqoqRnQghpo04RAJWWliIpKQlSqRTDhg3DsmXLkJKSEvTa/fv3Y/bs2Zxjo0ePxubNm0M+3263w26//m/4dXV17fLepGOoa2ESuqXJibLqBpgag+cEAUyicmBQIhML8Pf8bCzYciJgi6yotAaLPj+Bsf0SA5KWAd/qTUKMFG89PgBmqxPzNx9HkdHEVoF5AM4zdRolZjygAR88DEyJbcVPTgghJJQOnwOUnZ2NdevWYceOHXj//fdRXl6OnJwc1NfXB73+0qVL6Nq1K+dY165dcenSpZDfsWzZMsjlcvZPcnJyu/4M5PaKaSFBWCLk4+zlekSIBQHnZGIBCkZqkJUSi9ce6RtQ5r5gXB/UWh0h84OKjCb06y4PyAnK8du6ksvEcHm8bHBldbgxa6OBzQlaPWUQts7UQZsSi+nrD6HB4bqRH58QQkgQHX4FaOzYsex/7t+/P7Kzs5Gamor/+7//w/Tp09vlO+bNm8dZNaqrq6Mg6A7C9OnZG2R7S69R4suTl7BqtxEFIzXQa5RsV+bm/XiY5oTPPdALIiEfTrcHYgEf1fXh84Mu1DZBmxJ7raOzCDERQiTGcMdU1DarSLM63JxVo9VTBrGfgw09JYQQcmM6/ApQcwqFAvfccw+MxsAtBQBISEjA5cuXOccuX74cNodIIpEgJiaG84fcOeQyMZZP7o/hadzVG2Y+FzNLq7C4HFN1auivrdY8O7wn1vmVvjNByZMfHsCKnaXYV2ZCdb09aG8ff2IBH6t2GzF9/WF4vV7Eyrh5OxarA44gDRL9+X+HPIJK3gkh5OfqdAFQQ0MDysrKkJiYGPT8sGHDsGvXLs6xr776CsOGDbsVr0c6qCRFBFbmarFr9v3YPOM+7HghBwNTYjldlZmtp4Epsdg+S4cxmQkhZ3QVGWugTVZAIuTDUGkO2fsnR6Pi9P5psLvwu39+zym/r2lwYN85U8hn6Pz6B+WkqRAfLWnD3wAhhBB/HT4AevHFF7Fnzx78+OOP2LdvHyZNmgSBQIDc3FwAwFNPPYV58+ax17/wwgvYsWMH/vjHP+LMmTNYuHAhDh8+jIKCgtv1I5AOQi4To1d8FAamxKLJ6VvNab6dxKzyOFxe/NSsR1BzdpcHhkozTlVZME2nDghg9BolXhzdm11hYgIZpvyeacRYZ3OisLg86DOYqfGFxeUYnqbCm1TyTggh7aLD5wBduHABubm5MJlM6NKlC/R6Pb799lt06dIFAFBRUQE+/3ocd99992HDhg2YP38+Xn75ZaSlpWHz5s3UA4hwhEuMlokFiJGKIBTwwj5DESFCYXE5VuRq8fGB82yej93lgTxChGipEPnrDsHqcLOBzKyNBgDc8vsYqYhdfcrXq5GvU8Ph9qBLlARiIR8utwdbC/RU8k4IIe2I5/V6vbf7JTqauro6yOVyWCwWyge6Q1msDszcaAhIjJaJBb7Kq6+NGJASC0NFbdAKrxyNCr8b0xtv7DgDQ4UZHz87FDUNDggFPMTJxBAL+XC7PSg3WdltssLics6K06fP3YdBqbEh3wXwlcozjRoJIYSEdyO/vzv8ChAhN4NcJsbrk/ph7qfHOHk+88f1weqvjSgymnCkwowVuVoAgf14Fj6SiaraJswflwGvF2i0O+HxevHnPefYa9fkZWHGR0dDvoPsWtk9k6Q9d9MxThBEXZ4JIeTmoRWgIGgFqHOxWB2oaXCgzuZETIQIqsjWbRWVX2nAuZpGxMdI0GBzI0oqBODFhJUl7DVM6bs2WQG7y4PkuAgcv2DBlQY73vmqFGvysiCPECFOJsaCz7nNEAtGakKuIOk0SiyckIm0rtEBP0e9zUldngkhpA1oBYjcNarMTQHzu4anqfD6pH5wuD2wNIUOivh8HqQiASqvNkEqEuBAuQlDesRxrmnej2dNXhbiY6RYuv00m9SckRgDmVgYEOgw+UFA4ArSNJ0aAj43x0guo4CHEEJuFQqASKcVdsjpp8cwMCWWDV6Y7SSZWICaBgdqrQ443B7sP2dic3NyNCr8ok/XgFUfqUiAoxW1KCwuR3yMBNPWHoI2RcEmNf/1qSyYGgObIfonNs8Zk44LtU1sPtAnByvw1uMDbsnfEyGEkEC0BRYEbYF1DmXVDRj19p6Q5//1/4bB0uSE3eVBhEiABLkUf91ThnEDkthtr5gIIcRCPvLXHkJlbRPenNwPKXEyrPzaGLBqUzBCgwtXrRiQHIudZy7B4fJiSI84iIV8REqEGPunopDvsiYvC9PXHwZwPRhLVES0318GIYQQ2gIjd4fWDDllgg7A15dnycS+WLLtFHafucI5/vfp2ai8aoXL48F7zYIfwLeFxQcP9/aIxebvT2LOmHS8seMM3t1ZCgABYzT8DU9TQdMliia4E0JIB9LhGyESEkpLQ06bKzaasGDzCWQkyQOOz998HA63B2KhIGDiO6PIWIN+3eQoMZrQYHNxgqTmYzQYzGpPqioSA1Ni0Ss+ioIfQgjpAGgFiHRa4Yac+o+P8FdsNGGaTh30+Jyx6ai82nL3ZwAwN3FXn/zzfeaPy4DN6abVHkII6cBoBYh0Wkz/nJxmQ05z/MZHBGMPMXi0weZucbApcz7YdUzFmM3pptUeQgjp4GgFiHRqkWIBHu6XiKn39WArtroppJi0el/AnC9GqCAnSipASVkNdBplyN49hkpzwIDT5qJvcGuOEELIrUcrQKRTq2lwYN6nxzF9/WG8+M/vwQPg8XgxKEUR9Hp9iK0xvUaJ6jo7O5Q02KrSdL0ap6oseHF0b5yqsoR8vq+hIiGEkI6M/klNOh3/zs9SER9r8rIg4PEgl4lw5mId/v7tj5iqU8MLbgNCvUaJpZP6YcnWk5zn6TVKvDohE0/+9VtYHW58fKACz4/oxa4qSYR8VNfb0VMZiQHJCkxffwjLJ/eH3eXhPD9Ho0SeTo1Gu+tW/VUQQghpI+oDFAT1Aeo4/IOdaKkQYj4fJWU1iI+Rsv19IsR8REuFqLe5ESkRYsLK4oBmhkwDwnH9ElBvcyFSIkSj3YVoqQgRIgFqrXZcqrNDESGCIkKM/yk8gJoGB+ddctJUGJCswKrdxqDP7xItwRN/+RYbns7GwJTY2/Q3Rgghdy/qA0TuCM3HXPz2F2kY0iMO245fDFjZmXqtK/M7vxqIgpEaNjDh8Xg4dbGO7fZ8f1oX1Nlc+GBPGQYkKzA2MxELNh/nlL7rNEosn9wfszYaOHlERaU1eO7+Xli12xgwIkOnUUKbEgurw005QIQQ0glQAEQ6pGBjLkb0jscbO84EJCgXG03wAvhgyiCkqiIRJRHC0uRkR1icqrJgRa4WszYaECUV4v09RjyZnYrqOhsWbTsZtOkhAOTr1ZwgBwBEQt+WG4/HY8dj+I/FGJ6mgiqKKr8IIaSjowCI3BYtTXCvaXAEzPgCELQ6CwAMFWZ0i5Ph5c+OBx08uuHAeSwY1wcSIR8ZSXKsLSlHvk4d8nklRhPyg/QLqvPrLp2jUWHzDB2+PHkRszYakJUaizcm96fSd0II6QQoACK3XKgJ7ssn90fStflYwcZcWO3ukINKhXweFm45EXI1R5sSC21qLK42OqC9lsczJTs17Hs27xfUvLlikbEGS7afwqvjMzC+XxI1PSSEkE6EyuDJLRV2gvumY7BYfYnHwcZciIU8rMjVwlBRi+nrD2PGR0eRv+4QDBW1GNUnPuQIC0OFGQ9ldIXT7YHHC8RHS1AwUgOZSBD2Xf37BelCNFcsKq0Bn8ejpoeEENLJ0AoQuaVCbW3JxAL0T1bgosWGczWNiJIIseyxfliy7RSbiGxucmJtSXnQVZ7qOnvQ75OJBViRq8UfdpwJSHR+sE9XjEzvwhmMysjRKJEol+LT5+6DVMTHFycuBSRFM+pbGMpKCCGk46EAiNxS/ltbzHZWVkosEhVSLN12ipN0nJOmQuHUwchfd+ha4MELmbMTSr5eHTJoAs5gzpj0wH4+aSo8P0KDOJkYCYoIlFU3BCRD+6OqL0II6XwoACK3FLO1xazMrC3xbSkZimsDgpSi0hrA68X2mXpcaXDA4wndsso3okIZsA3G5PsEU2I0oabBAW1KLJvwnBAjRbRUCHmEiN3SCjd0laq+CCGkc6IcIHJLMcGE/8rMoJTYkCs7py/Vw+sFoqVCRIcZMVFYXI5XJ2RCp1He0PvIxAJkJPqaZRkqzXj8z/thd3k4+TzM0NXhzcZjDE9TUdUXIYR0UrQCRG4pJpj4saYRq3YboYoSI0oS/L+GqigxPnp6KBZ87qvuKhipCTmoVJuigN3lxqJHMmF3emB1uBElFaKlPueNdhdmfHQ04FhzSYoIrMzVoqbBgXqbE9FSEVV9EUJIJ0YBELnlkhQRuGRpgkwsQOHUwai3BZ+d9cbk/ljs16iwsLgcK3K1ABAwg2vBhEws//I0vj13ld1aayloytH4VnRkYgEnuTlUTo9cRgEPIYTcKSgAIreFPEKMfL0a9TYX9p8zBQ1S4mMknGNWhxuzNhqQr1cjX6dGtFSEepsTkRIh3vzyNHafuYKCkRpO0nOooEmnUSJP1wMfHTjPdom2OtyU00MIIXcJCoDITWWxOmC2OtHocKHR4YYiQoT4aAlUUWLc11MJc5MzZJDSaAssOfefwbXxmaGYvv4w1uRlYee1UvbmSc9M0LQyV4sZD2hgaXKyg1GZoMfu8iBfr8axSjPl9BBCyF2CpsEHQdPg28dFcxPOX7Vi5e7SgDLzNyf3x0VLE4QCPq7U2+FwexAfLYVIwMNFiw0SAR/JcTL8aGrkdHxmhpoCwJcv6OF0eyHg8VBvd0Ek4EPI5yH3r98G9OtZk5fFjrAIZscLOUiUSyn4IYSQToymwZPbzmJ14JsfrmDbsaqAra0j52tRbKxBv+5y/FTbBB6Phx8u1+PspXoM7hEHeYQIURIhDpabsGT7aTaY0WmU7HbVsJ5xEAn4WLr9ZEBwtepJLQo2cJsWNh9r0ZzN6abghxBC7iIUAJGboqbBgfhobg6PTCzAr+/vibF9E7Fk60n87l/H2ONr8rKw+msj3t1Zyl7vH/BYHW72WQvG9cGwXiq8svl4yN5BzSe5+4+1CIaaGRJCyN2F+gCRm6LO5uSsujCNDxNjpFiy9SSnYWG+Xo1VXxsDmhiWGE2+qe16NeeYNiUWP5oaQ/YOKjKaMKwntx9Qdb0dOc36+DAo8ZkQQu4+tAJEbgpVpBgSkQAbnxnqa2DoBX64XIe+3RR4adNxzrUtdWtmujQzzE3OoDO5/EmEfHz12+FotLvYnj3339MFczcd43R0pmaGhBByd6IAiLS7ClMj5n12vFmvHhWeH9GLMwuM0VJ+TvPz0VJh0GaF/qIkQqR1jeYck8tAzQwJIYQA6ARbYMuWLcPgwYMRHR2N+Ph4TJw4EWfPng17z7p168Dj8Th/pFLpLXrju9vlOltA8AMARcYarPzaiJgg4yxays/xP6/TKHHJYsPlOlvIsRc5GiViI4MHNXKZGL3iozAwJRa94qMo+CGEkLtUhw+A9uzZg+effx7ffvstvvrqKzidTjz00ENobGwMe19MTAwuXrzI/jl//vwteuO7j8XqQFl1AwwVtbja6AiZm1NiNEEs5AcELoZKc8hgRqdRwlBpBuBbRSoYkYY5m44hUR6BghGagPtyNCr8flI/dI2hgJcQQkhoHX4LbMeOHZzP69atQ3x8PI4cOYLhw4eHvI/H4yEhIaFV32G322G329nPdXV1bXvZTspidaCmwYE6mxMxESKoIlu/LVRlbsKcTcd81VcAVk8ZFPb6y3U2vPJwHyz74gyKjL57CovLsSYvC3wej30O4AtmXp2QgVqrA9pkBY7/ZMHBH014Y3J/8AAoo8R4dXwGHG4PbE4PYqRCKGRiCn4IIYS0qMMHQM1ZLBYAQFxcXNjrGhoakJqaCo/Hg0GDBuH1119HZmZm0GuXLVuGRYsWtfu7dgbNAxjAlxi8fHJ/JCkiwt5rsTow51/HcKSiFgUjNdAmK9AlWhL0WplYgHy9GrGRElRbbHhpTDpecLlxpcGO5FgZAC8m9E/E1Pt6wO7yQCLk43KdDRdqm+Bwe/Drvx8JeKZ/c0O9Rok3Jven4IcQQkirdKpO0B6PB4888gjMZjOKi4tDXrd//36Ulpaif//+sFgseOutt7B3716cPHkS3bt3D7g+2ApQcnLyHd8J2mJ1oGCjgRP8MIanqbAyVxt2JejspTpMWr0vYPiooaI2oP+P/zUMnUaJaTo1ukZLsXzH6aBbZzqNEnPGpOORVSUB51ZPGcSZ5L7h6WxkJsVQXg8hhNyl7thO0M8//zxOnDgRNvgBgGHDhmHYsGHs5/vuuw99+vTBn//8ZyxZsiTgeolEAokk+MrFnaymwRE0+AGAvaU1qGlwhAwmLFYHfqptQr5eHTB8dNWTWvDBw5GKWuTr1Xjgni6wNDkxXd8T2pRYdpwFc8/cselh84YcIarEmidPm5ucYd+ZEEIIYXSaAKigoADbtm3D3r17g67ihCMSiaDVamE0Bu81c7cKVpLurz7M+ZpGO1KUMnSJkSAjMQbT9T3ZWV3Hf7JgwoBELBifgSXbTnJ6/ATr7txoD9/T50qDPeCYf3I0QyLkh31nQgghhNHhAyCv14uZM2fis88+wzfffAO1Wt3yTc243W4cP34cDz/88E14w84rpoXxD/7jIfwTpeURIvB5PLy65QSnezMT3Ah5PByuqMWW7wPngDGf/UdVyMSCG3pPZuts1kYD55ih0oxJA7uFfRYhhBACdIIA6Pnnn8eGDRuwZcsWREdH49KlSwAAuVyOiAhfku5TTz2Fbt26YdmyZQCAxYsXY+jQodBoNDCbzfjDH/6A8+fP4+mnn75tP0dHpIoSY3iaitMZmeE/HqJ5onTBSA2+r6gNOroCAF58qHeL3Z3njk1HRmIMpCIBIsQC6DVKFIfIARLwfdPaz1+1IjlWhu8ra9kVJOaaaTo1PjlYAZX+xgNkQgghd58OHwC9//77AIAHHniAc3zt2rWYOnUqAKCiogJ8/vV8kNraWjzzzDO4dOkSYmNjce+992Lfvn3IyMi4Va/dKchlYiyf3D/seAiL1RFQJdZycMNrsbtz5dUmNoH5wfQuWDKxL+ZvPhEw2X3B+Ax8eeIivq80IyNJjlc+O46/T8/Gh09lwdzkhETIh6HSjE8OVmDxo30p/4cQQkirdPgAqDVFat988w3n8zvvvIN33nnnJr3RncNidcDmdGP++Ax4vF5Y7W7II7jjIZhEaaaMXZusgEwc/r82tVbfNlk4/gnMO89cgQenkK9TI1+nht3lgTxCBJvTjYnvlbArPVOyU3Gs0ozYCBGS5FJ2pMWkgd2g0qsp+CGEENJqHT4AIjdH820tmViABeMzMChFgXM1jYiS2CEW8FFrdWDt1MFQRonx7s4fsGq3EWvyssI+WykTI0oqDLut1TyBefeZK5iSnYrp6w9zcnz8h57GRIg4pfkU8BBCCGmrDj8Kg7S/5ttaTJ+ebceqMPrdIkxavQ+/eGcvXt58HHU2J479ZEa9zYVnc3ph7dTBABBmDpcKUpEA31XUYunEfsjRqDjnmeCmsLg84F6ZWIgvX8iBNiU2IPgBgDgZDS4lhBDSPmgF6C7k3/9HJhZgZa4W65o1KQR8+Tx88PDyuHS4PF402NzoEi2B1eHC0kf7Yv6WEwGNDfN0PTBhVTG0KQr0TojGw/0SMFXn6+6cHBeBf5+8HDS4AQAvvIgQ8aFNVuCtxwdAKhKwpfVZqbFsUjYhhBDyc1EAdBdi+v8wKz9SkSCgootRZKzB1UYnpnx4gM0DGtZTCVOjA6+Oz4CQz8fVRjt4PB6KjTWc/j5v/vss5o/LwIJrgRLTJTpY8KPXKNFdEYFXPjseUFpfOHUwesTJaPWHEEJIu6EtsLsQ01eH6eJsaQrfPNDS5GSDJUNFLaZ8eAC//GA/Rr9bhFc/PwGLzYXV3xjRt5ucc9/uM1dgd7rx4kO9sXWmDkN7xmHRI32Rk8bdFsvRqLB0Yj8s3HoyaGn9e18bEdFCryBCCCHkRtAK0F2g+bT3KKkQv+gTz5az5+vC986RCPkBIy8YzGdtSizWlpRzGhwCgMXmwhN/+Zb9LBMLsLVAh3qbGzaXGzKxrw/QJUsTdp+5EvT7i1oYy0EIIYTcKAqA7nChpr0vndgX5640AgAMlWboNMqQw0gNleYWe//k69RBgymRgIeCkRpkpcRCLhNBKODjaqMTMRFC8PnARYsN3WMjcNXa9rEchBBCyI2iLbA7WLAmhoBv0On8zSeQqpQB8A0wnaZTB1R25aSp2IqtlhobMuf9r8vRqCAWCHCqygKX14u3/nMWE1YW4/E/+7bP3txxBgI+Dz+ZmwIGmzYX3cLYDkIIIeRG0ArQHaylae9WhxsbnsnGvjIT5m46hieGpHAaEabERmDh1pOwOtwtBijMeeb/5miU+N2Y3nhn51lkJMmDbp8xPYJeGpOO/5y6HHIVKsdvLAchhBDSHmgF6A7W4rR3uwtPrz+M7ypqsXxyfxQWl2P6+sP46MB5OFweNNhdWDA+E/pr22Chev8w22Q5GhUS5FJsnanHyw/3gdXuwu4zV6BNVgQNbABfECQW8nHmYl3QVSi9Rollk/pR/g8hhJB2RStAdyAm6bmlVRu3x8smLfPAw0dPZ+NqowMnqizwwovXvziN05fqUTh1MKx2Fyb0T8TSbadRZLy+qqTXKPG70elYsesHLJiQgT/t/AHPj9DgP6cvY1BKLAC0uH1mc7ix+NG+eG3LCWhTYtlVKEWECKlKGbrFyn7+XwohhBDihwKgO4x/0nPBSA1yNCpOwMLQaZTYf84EbbICgK/fz1RdD0xffxgFIzVYU3x9y+pKvR3T1x9m+wAxjQ2ZQaQSER9Thqbi3a/OomDUPbhsseFw+VX0TfKVxbcmvydJEYG3Hh/AzveKlnJnkhFCCCHtiQKgO0jzpOfC4nJ8NuM+LN52KqBjMzNr64//NQAFIzXskNPCqYOhihJzRlUwKzhWhztoJZg2WYHUOBnmje2DSe/vg9XhxsfPDgXgywUKV2U23C+/R06jLgghhNwiFADdQZonPVsdblw02zjbSsyqDdOxuXtsBP7x7XlOYJOjUWFFrpa9RiYSsEGS3eXhjKhgujov2nYKix7JxBNDUlBYXI4LtU148Z/fY0WuFhsOnMe0a+Xx/kHQ8DQV3pjcn4IeQgghtxwFQHeQYEnPhytqYaioDbpyk6NR4vgFS8DKTJGxBh748oMK/397dx8VdZ3vAfw9A8zAwDAwPAyQoBSoWIKIoaMolRS62oZ6tg7XCpDaSjCR4+6GN7OubXir3fWJ1XY3idOGeq2De3tUDwquiCkgZeYTygo3BYTiaXgYmPndP2h+MTAgtMWMzvt1Duc4v993fnx+56PHz/k+HquGh6ts0DPmhHiJxc3p2mb881Ijqht1OF3zHbYmRsJRIkGH3oDnd5/GiphgOEokWPvQJLywUILvOnrgq5TD392ZxQ8REVkFC6DbREuHHi5ODvjz8ulmPTS7jlVja2IkpMCgM7bWP3w3EnJKLD7PtLnhiphgvHHgvMUdoCXoW8Ju2um5u9cotlvx/YqukqqmQcXXvFBvbEuMZPFDRERWwwLIhg08wsLb1fIcGUu7PZt6aJ7ffRrP7z6N95/VIrmlC3qDET5ucsgcpfhOp7d4MGl/w+0AfayqCSvaf3iGabJzSVUTUmPu5LAXERHZLBZANmqoIyw2LQtHgIeLeG2o3Z7FnpiYYJyu+Q66bgNS88rM2rydNGPYGLxc5ejqGb5AcnFywK7ke1HX0omvrrWI192dHSFzkOC1hKnQG4zQdfdyZRcREdkMFkA2aLgjLH73wZf472Xh6OoxoNcowGAUhtztuaSqCesWhuH+Sb5QOA0+Tf1mZ4DJHSXo0AvDxtqh70VqXhnmhngjJWYCFDIHdOgN8FTIcJev2yjemoiIaOxwJ2gbNNwRFv+81IirTTpcadThlQ/PorpRN+yzrn7bgWU7jqOy9jvMDfE2u2c6AyzGwhlgGx6+G0cuNqCr1zDoeyamHaCBvonTbx/rOw1+Ho+uICIiG8ceIBt0syMsnJ0csP1IlThR+WZtAWDjx+eQmzwDvwj3h69SLi5nb2zrwgsLJ6OhTY+unr4zv4K9XbF427G+JfAyB2xNjIQRwpB7CZmUVDUh7b4QJEwLgK67l0NdRERks1gA2SB3Cyefm3Zhjgz0QI9BQGrMnYgM8sSZb1qGHMaKCfGCIPwwhKXTG/DJl9fMVoPNDfGCt1KO9PzT4mTm/3lmFmaM9xQPTDUtZV8xJxiuckfounvN9hLqr1cQ8MvtJZge5IFNS8MxTs1jLIiIyPawALJB3m4yzAv1xtHvh8FMvTC5JdWD9uJ5KuZOhI/rO3KixKyw8caLi8MgAPjf9DkQBODNA+fNih+gb2m8ERDPBAP6jqbIXjoVL//vWRw61yDuAD0v1Bv/uShMXPZuSU+vER16A45VNSGr4Ay2c7k7ERHZIBZANkilkGHTsnBxIvSKmGDkllRb3ItH7ijFk7Mm4HcLJgMAunuMcHKQouhiA5b8ue9YijkhXnhh4eRBxU//55iG0uaEeOHjM9fxZW0zXlsyFVm/CENrZ98yfFe5I7r0BswN9bY4R6n/nCCgb75SY7ueBRAREdkcFkBjqKVDj+aOHuj0vdDpDfBwcYKvUm6xQDAdDnq5oR1uzo4W9+JRyBzwHzPH4+1jV8TiRiFzwIuLwjA/zBeT/JSQO/ZtitjQ2j1sbN29RrN5PR16A9YVnMG2xEjc6eOGa819R1uUX+3b6dko3HxOEAC03WQ+ExERkTWwABoj15s7cfXbDmw7fMl8qOr7jQH77+1jonF3hsEo4Nz1VovPHNgz1H+obF3BV2K7OSFeiL9bM2x8gWoXRAZ5ms3rOfp9Dw4As2X5/ecEAYDKxQlFF29YnBOktDCfiYiIyNq4DH4MtHToUXTxxqDiB+gbJnrhgy/R0qG3+N0ADxcEDTGRODLQw+x5ww2Vnfm/FswNHXo5+4Gz9dh+uGpQAdPcqbd4yOr2w1VIzStDal4ZunuNFr/L5fBERGSrWACNgcZ2PXyVcosrtYC+npbrLV04XfMdLt9oH1QM+SrlmGeheOnuNZp9HlgQmShkDrjR3o3/+uXdmDtgz5+YEC+8mjAV0wI9sCv5XqQ/EAKF7IdNE7t7jGjptFycmcgdpYOKKx55QUREtoxDYGOgtatnULEy0JVGHVa+VwFg8JEXAydFm6hczIeXLP2O/sNibxVfwYqYYCR/P3Tl5+6MhrYubPzoLKYEqLD9cJXZGWKRQR44fqUJi6f6Dxu7p0KG7YmRaGzXo62rh0deEBGRzWMBNAbcnZ3wre7mvSgmpiMv1i+eAgepBN6uMjhKJfjFPX5Inj0B3b1GBKpd0NDabbYHUP9nmAwcFhu4jP53Cybj8PkbWD5zPIAfltK/uCgMvu7OeH73aTwSEWC2LL8/0zCXSsGCh4iIbh0cAhsD3m4yNLT1FSuWzB2wfBzomxtU+20HHt52DOfq2lDV0I6sgq+QmleGle9VoPbbTqzafRopc4LF55rO9upvqGExwHzfoP69RyVVTZioUYqTmh2kEmxaFj5oGI7DXEREdKu6JQqgnJwcTJgwAc7Ozpg5cyZOnjw5bPt9+/Zh8uTJcHZ2xtSpU/HJJ5+MUaSWqRQy3DfRB6seCB1UoPQdIhqMXceqB32vu9eIFTHB2Hb4Epo7zZeTyx2l4i7NkUGeeDtpBqbeocKGxebzfG429GY67X1g71FDWzc69AbMC/WGl6sMAR4u2JYYicLMWOxfORuFmbHYlhgJfwur14iIiGydzQ+B7d27F5mZmdi5cydmzpyJzZs3Iz4+HhcuXICvr++g9sePH0diYiKys7OxePFi5OfnIyEhARUVFbjnnnus8AZ9/D1coJA54LWEqdDpe9GhN8DN2RGffVVndgxFf3JHKSIDPbD9cNWgM7/6n+Tef1jLtA/QbxdORke3Ae4uwy9Dd5M7DdrA0PS7B/bwcJiLiIhuFzbfA/THP/4RTz/9NFJSUjBlyhTs3LkTCoUCu3btsth+y5YtWLBgAX7zm98gLCwMGzduxPTp07F9+/Yhf0d3dzdaW1vNfn4OKoUM471dMSVAhRkT1PB3d0bF1e8sFj+mosTUgzNweMt0kvugIa8gD/i6O2PLoYtQu8oglWDI09znhnjDaBSQMse8B2puqDdCfNzYw0NERLctmy6A9Ho9ysvLERcXJ16TSqWIi4tDaWmpxe+UlpaatQeA+Pj4IdsDQHZ2NlQqlfgTGBj407zATZhWdw2cW2PaVXnXsWpxaGpgwWMa/locHoADGXPxwXNafLwqBmsfmgRHiQSTA1R4JKcEdS3dSImZMGj5+9wQL6TETIARgtkGhvNCvfH6snCM93Zlbw8REd22bHoIrLGxEQaDARqN+S7GGo0G58+ft/iduro6i+3r6uqG/D1ZWVnIzMwUP7e2to5ZEWSaW9PYrkdLZw+6egw4fqVJLEr6D3X134G5u9cIDxcn3OXrBo27MwDgWnMnXvjgS7PVWtdaOlF4rh4RQZ5I/v57ckcpTtc2Y/fnNXh1yVR8mB7D5etERGRXbLoAGityuRxyudxqv7//3JprzZ3YWXxZ7JHZdawau5LvhVQiwT8vNYrzfUzzc0zFD2BeTPUvaGIn+uCFD740myvU//sa9zF8WSIiIhtg0wWQt7c3HBwcUF9fb3a9vr4efn5+Fr/j5+c3qva2ZqgiZqQbDVqaqKxSwOIz2dNDRET2yqYLIJlMhqioKBQWFiIhIQEAYDQaUVhYiPT0dIvf0Wq1KCwsREZGhnjt0KFD0Gq1YxDxT2Oo1Vb/TsHCFVxEREQ/sOkCCAAyMzORlJSEGTNmIDo6Gps3b4ZOp0NKSgoA4Mknn8Qdd9yB7OxsAMDq1asRGxuLP/zhD1i0aBH27NmDsrIy/OUvf7HmaxAREZENsfkC6LHHHsONGzfw0ksvoa6uDtOmTcNnn30mTnSuqamBVPrDYrbZs2cjPz8fL774ItatW4fQ0FDs37/fqnsAERERkW2RCIIgWDsIW9Pa2gqVSoWWlha4u3OGMBER0a1gNP9/2/Q+QEREREQ/BxZAREREZHdYABEREZHdYQFEREREdocFEBEREdkdFkBERERkd1gAERERkd2x+Y0QrcG0NVJra6uVIyEiIqKRMv2/PZItDlkAWdDW1gYACAwMtHIkRERENFptbW1QqVTDtuFO0BYYjUZcu3YNSqUSEolEvN7a2orAwEDU1tZyh2gbxjzZPubo1sA83RqYpx8IgoC2tjYEBASYHZNlCXuALJBKpRg3btyQ993d3e3+L9mtgHmyfczRrYF5ujUwT31u1vNjwknQREREZHdYABEREZHdYQE0CnK5HBs2bIBcLrd2KDQM5sn2MUe3Bubp1sA8/TicBE1ERER2hz1AREREZHdYABEREZHdYQFEREREdocFEBEREdkdFkCjkJOTgwkTJsDZ2RkzZ87EyZMnrR2S3Tp69CgefvhhBAQEQCKRYP/+/Wb3BUHASy+9BH9/f7i4uCAuLg6XLl2yTrB2LDs7G/feey+USiV8fX2RkJCACxcumLXp6upCWloavLy84ObmhmXLlqG+vt5KEdufHTt2IDw8XNxET6vV4tNPPxXvMz+2adOmTZBIJMjIyBCvMVejwwJohPbu3YvMzExs2LABFRUViIiIQHx8PBoaGqwdml3S6XSIiIhATk6Oxfuvv/46tm7dip07d+Lzzz+Hq6sr4uPj0dXVNcaR2rfi4mKkpaXhxIkTOHToEHp6evDQQw9Bp9OJbdasWYMPP/wQ+/btQ3FxMa5du4alS5daMWr7Mm7cOGzatAnl5eUoKyvDAw88gEceeQRnz54FwPzYolOnTuGtt95CeHi42XXmapQEGpHo6GghLS1N/GwwGISAgAAhOzvbilGRIAgCAKGgoED8bDQaBT8/P+GNN94QrzU3NwtyuVzYvXu3FSIkk4aGBgGAUFxcLAhCX16cnJyEffv2iW3OnTsnABBKS0utFabd8/T0FP72t78xPzaora1NCA0NFQ4dOiTExsYKq1evFgSB/5Z+DPYAjYBer0d5eTni4uLEa1KpFHFxcSgtLbViZGRJdXU16urqzPKlUqkwc+ZM5svKWlpaAABqtRoAUF5ejp6eHrNcTZ48GUFBQcyVFRgMBuzZswc6nQ5arZb5sUFpaWlYtGiRWU4A/lv6MXgY6gg0NjbCYDBAo9GYXddoNDh//ryVoqKh1NXVAYDFfJnu0dgzGo3IyMjAnDlzcM899wDoy5VMJoOHh4dZW+ZqbJ05cwZarRZdXV1wc3NDQUEBpkyZgsrKSubHhuzZswcVFRU4derUoHv8tzR6LICIaEykpaXhq6++wrFjx6wdCg0wadIkVFZWoqWlBe+//z6SkpJQXFxs7bCon9raWqxevRqHDh2Cs7OztcO5LXAIbAS8vb3h4OAwaDZ9fX09/Pz8rBQVDcWUE+bLdqSnp+Ojjz7CkSNHMG7cOPG6n58f9Ho9mpubzdozV2NLJpMhJCQEUVFRyM7ORkREBLZs2cL82JDy8nI0NDRg+vTpcHR0hKOjI4qLi7F161Y4OjpCo9EwV6PEAmgEZDIZoqKiUFhYKF4zGo0oLCyEVqu1YmRkSXBwMPz8/Mzy1drais8//5z5GmOCICA9PR0FBQU4fPgwgoODze5HRUXBycnJLFcXLlxATU0Nc2VFRqMR3d3dzI8NmT9/Ps6cOYPKykrxZ8aMGVi+fLn4Z+ZqdDgENkKZmZlISkrCjBkzEB0djc2bN0On0yElJcXaodml9vZ2VFVViZ+rq6tRWVkJtVqNoKAgZGRk4NVXX0VoaCiCg4Oxfv16BAQEICEhwXpB26G0tDTk5+fjH//4B5RKpTgXQaVSwcXFBSqVCqmpqcjMzIRarYa7uztWrVoFrVaLWbNmWTl6+5CVlYWFCxciKCgIbW1tyM/PR1FREQ4cOMD82BClUinOnTNxdXWFl5eXeJ25GiVrL0O7lWzbtk0ICgoSZDKZEB0dLZw4ccLaIdmtI0eOCAAG/SQlJQmC0LcUfv369YJGoxHkcrkwf/584cKFC9YN2g5ZyhEAITc3V2zT2dkprFy5UvD09BQUCoWwZMkS4fr169YL2s6sWLFCGD9+vCCTyQQfHx9h/vz5wsGDB8X7zI/t6r8MXhCYq9GSCIIgWKn2IiIiIrIKzgEiIiIiu8MCiIiIiOwOCyAiIiKyOyyAiIiIyO6wACIiIiK7wwKIiIiI7A4LICIiIrI7LICIiIjI7rAAIiIiIrvDAoiIiIjsDgsgIiIisjssgIjoZ3Pfffdh1apVyMjIgKenJzQaDf76179Cp9MhJSUFSqUSISEh+PTTTwEABoMBqampCA4OhouLCyZNmoQtW7aYPbOoqAjR0dFwdXWFh4cH5syZg6tXrwIAvvjiC9x///1QKpVwd3dHVFQUysrKbhrnO++8Aw8PDxw4cABhYWFwc3PDggULcP36dbFNcnIyEhIS8Morr8DHxwfu7u549tlnodfrxTZGoxHZ2dli/BEREXj//ffF+yN5PyIaG47WDoCIbm95eXn47W9/i5MnT2Lv3r147rnnUFBQgCVLlmDdunX405/+hCeeeAI1NTVwcnLCuHHjsG/fPnh5eeH48eP49a9/DX9/fzz66KPo7e1FQkICnn76aezevRt6vR4nT56ERCIBACxfvhyRkZHYsWMHHBwcUFlZCScnpxHF2dHRgTfffBPvvvsupFIpHn/8caxduxbvvfee2KawsBDOzs4oKirCv/71L6SkpMDLywu///3vAQDZ2dn4+9//jp07dyI0NBRHjx7F448/Dh8fH8TGxsJoNA77fkQ0hqx9HD0R3b5iY2OFmJgY8XNvb6/g6uoqPPHEE+K169evCwCE0tJSi89IS0sTli1bJgiCIDQ1NQkAhKKiIottlUql8M4774w6ztzcXAGAUFVVJV7LyckRNBqN+DkpKUlQq9WCTqcTr+3YsUNwc3MTDAaD0NXVJSgUCuH48eNmz05NTRUSExOH/N3934+Ixg57gIjoZxUeHi7+2cHBAV5eXpg6dap4TaPRAAAaGhoAADk5Odi1axdqamrQ2dkJvV6PadOmAQDUajWSk5MRHx+PBx98EHFxcXj00Ufh7+8PAMjMzMRTTz2Fd999F3FxcfjVr36Fu+66a0RxKhQKs7b+/v5iTCYRERFQKBTiZ61Wi/b2dtTW1qK9vR0dHR148MEHzb6j1+sRGRkpfh7u/Yho7HAOEBH9rAYOQUkkErNrpuEro9GIPXv2YO3atUhNTcXBgwdRWVmJlJQUs3k2ubm5KC0txezZs7F3715MnDgRJ06cAAC8/PLLOHv2LBYtWoTDhw9jypQpKCgo+NFxCoIw4vdsb28HAHz88ceorKwUf77++mtxHtBI3o+IxgZ7gIjIZpSUlGD27NlYuXKleO3y5cuD2kVGRiIyMhJZWVnQarXIz8/HrFmzAAATJ07ExIkTsWbNGiQmJiI3NxdLliz5SeL74osv0NnZCRcXFwDAiRMn4ObmhsDAQKjVasjlctTU1CA2Nvbfej8i+vmxB4iIbEZoaCjKyspw4MABXLx4EevXr8epU6fE+9XV1cjKykJpaSmuXr2KgwcP4tKlSwgLC0NnZyfS09NRVFSEq1evoqSkBKdOnUJYWNhPFp9er0dqaiq+/vprfPLJJ9iwYQPS09MhlUqhVCqxdu1arFmzBnl5ebh8+TIqKiqwbds25OXljej9iGjssAeIiGzGM888g9OnT+Oxxx6DRCJBYmIiVq5cKS6TVygUOH/+PPLy8tDU1AR/f3+kpaXhmWeeQW9vL5qamvDkk0+ivr4e3t7eWLp0KV555ZWfLL758+cjNDQU8+bNQ3d3NxITE/Hyyy+L9zdu3AgfHx9kZ2fjypUr8PDwwPTp07Fu3boRvR8RjR2JMJpBbiIiO5WcnIzm5mbs37/f2qEQ0U+AQ2BERERkd1gAEdFtb+HChXBzc7P489prr1k7PCKyAg6BEdFt75tvvkFnZ6fFe2q1Gmq1eowjIiJrYwFEREREdodDYERERGR3WAARERGR3WEBRERERHaHBRARERHZHRZAREREZHdYABEREZHdYQFEREREduf/Ad0da9NqimMzAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Gain insights of dataset\n", + "sns.scatterplot(x='mass_npea', y='tumor_size', data=data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 300 + }, + "id": "ItVOltUuLE-T", + "outputId": "0b86549c-3a7f-417b-c950-ce2d4b925871" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mass_npeatumor_size
count1000.0000001000.000000
mean22.7091589.805131
std11.6821225.842747
min1.5754830.092640
25%12.2908114.719465
50%22.9682809.936148
75%32.66443914.886392
max44.25568119.994353
\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n" + ], + "text/plain": [ + " mass_npea tumor_size\n", + "count 1000.000000 1000.000000\n", + "mean 22.709158 9.805131\n", + "std 11.682122 5.842747\n", + "min 1.575483 0.092640\n", + "25% 12.290811 4.719465\n", + "50% 22.968280 9.936148\n", + "75% 32.664439 14.886392\n", + "max 44.255681 19.994353" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Plot a graph to check linearity\n", + "data.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "mQ5YOGJFLE63" + }, + "outputs": [], + "source": [ + "#Extract X and Y from data\n", + "X = data[['mass_npea']]\n", + "Y = data['tumor_size']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 74 + }, + "id": "M1Jpn6TCLE4s", + "outputId": "2becbffd-e4a5-43c9-975b-445a9c9bcea8" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LinearRegression()" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Train a Linear Regression Model\n", + "model = LinearRegression()\n", + "model.fit(X,Y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "E4sxQ9G4LE2v", + "outputId": "644b0b49-8a24-4fbe-b754-a614c6d75603" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.24388273258319765" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Evaluate the Model\n", + "y_pred = model.predict(X)\n", + "mse = mean_squared_error(Y,y_pred)\n", + "mse" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "F5p0Zr1_LSIP", + "outputId": "4c7d448e-0f25-415e-82a5-67b622d8ff9a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the data and regression line\n", + "plt.scatter(X,Y, label='Data')\n", + "plt.plot(X, y_pred,color='red')\n", + "plt.ylabel('Tumor Size')\n", + "plt.xlabel('Mass Npea')\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}