diff --git a/Basic_Containers.ipynb b/Basic_Containers.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..35eff7b62b1d22f4f3d3423f184042a2164c045f
--- /dev/null
+++ b/Basic_Containers.ipynb
@@ -0,0 +1,188 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3c2a4f39",
+   "metadata": {},
+   "source": [
+    "# Basic Containers\n",
+    "Understanding and Using Basic Containers in Python"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b78245b",
+   "metadata": {},
+   "source": [
+    "\n",
+    "![Google Python Symbol- Image found in the public domain](https://freesvg.org/img/387.png)\n",
+    "\n",
+    "https://freesvg.org/img/387.png\n",
+    "\n",
+    "Python Language Logo from Free SVG\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "Many times, in using python, there will be a need to store values. A common way to do so and store the values under a single variable is to use basic containers. This page will breakdown the common container types in Python. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment\n",
+    "\n",
+    "Click the following link to assess your knowledge on Basic Containers:\n",
+    "https://realpython.com/quizzes/pybasics-tuples-lists-dicts/ "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d237ca9",
+   "metadata": {},
+   "source": [
+    "## Training Materials\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21f9b14e",
+   "metadata": {},
+   "source": [
+    "Video Description (URL Link to video)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "deeec8f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/aBqTgR-gP3g?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x1cd12db60d0>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"aBqTgR-gP3g\",width=\"100%\", height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "08e8ef5c",
+   "metadata": {},
+   "source": [
+    "|Container Type|Mutable or Immutable|Initialization *Without* Values|Initializtion *With* Values|Adding Values to Container|Removing Values from Container|Modifying Values|Access Method|Notable Operations and Additional Information|\n",
+    "|---|---|---|---|---|---|---|---|---|\n",
+    "|**List**| Mutable |<ul><li>`a=list()` </li><li> `a=[]` </li></ul> | `a=['1', '2', '3']`|  <ul><li>` list.append(item) #Adds item to the end of the list` </li><li> ` list.insert(index, item) #Adds item to the specified index in the list`</li></ul>|`list.remove(item) #removes the first instance of 'item' from the list. If there is not such element, this will cause an error`|`>>> a[0] = 'cat'` <br> `>>> a` <br> `['cat', '2', '3']` |Access by index: <br> `>>> a[0]` <br> `1`|See webpage at http://www.linuxtopia.org/online_books/programming_books/python_programming/python_ch14s07.html for some helpful methods when dealing with lists.|\n",
+    "|**Dictionary**|Mutable| `student={}` | `>>> student={'name': 'John Doe', 'age': 22, 'college': 'MSU'}` | `>>> student['major']='Computer Science'` <br> `>>> student` <br> `{'name': 'John Doe', 'age': 22, 'college': 'MSU', 'major': 'Computer Science'}` | `del dictName[keyName] #This method removes all entries associated with the given key` | `>>> student['age'] = 23` <br> `>>> student` <br> `{'name': 'John Doe', 'age': 23, 'college': 'MSU', 'major': 'Computer Science'}`| Access by key word. Note that this key **must** be a string. <br> `>>>student['college']` <br> `MSU`| The 'in' keyword can be very helpful with dictionaries. Ex: <br><ul><li>`'k' in dict #Returns true if key 'k' is in dictionary dict`</li><li>`'k' not in dict #Returns true if key 'k' is not in dicitonary dict`</li><li>`for key in dict #This will iterate over all keys in dictionary dict`</li></ul> <br>See webpage at http://www.python-course.eu/python3_dictionaries.php for additional helpful methods and operations|\n",
+    "|**Set**|Mutable. However the objects contained within a set **must** be immutable. | `s=set()`|`s=set(['a','b','c'])` | `s.add(item)`|<ul><li> `set.discard(item) #If item is in the set, the item is removed, otherwise nothing happens` </li><li> `set.remove(item) #If item is in the set, the item is removed, otherwise raise a KeyError` </li><li> `set.pop() #Remove and return an arbitrary element from the set. If the set is empty, raise a KeyError` </li>| Sets are unordered, therefore indexing does not mean anything. To modify a set, you must directly add or remove elements. |`>>> set.pop() #This will remove and return an arbitrary element from the set`|Some helpful methods include:<ul><li>`difference()`</li><li>`intersection()`</li><li>`isdisjoint()`</li><li>`union()`</li></ul><br> See webpage at http://www.programiz.com/python-programming/set for additional helpful methods and operations|\n",
+    "| **Tuple** |Immutable|<ul><li>`t=()`</li><li> `t=tuple()`</li><ul>|<ul><li>1-tuple:<br>`t=('Hello',)`</li><li> 2-tuple:<br> `t=('Hello', 'Goodbye')`</li><ul>|N/A|N/A|N/A|`t=('Hello','Goodbye','Goodnight')`<ul><li>Access By Index: <br> `>>> t[0]` <br> `'Hello'` </li><br><li> Access By Slice <br> `>>>t[0:1:2]` <br> `('Hello','Goodbye')`</li></ul>|<ul><li>Packing and Unpacking</li><br><li>Tuple to List: `list(tupleName)`</li></ul>|\n",
+    "| **NumPy Array\\***|Mutable|`a=np.array([])`| `a=np.array([1,2,3,4,5])` | <ul><li>`np.insert(arrayName,index,values,axis) #Inserts a value for an array at the given index.` </li><li>`np.append(arrayName,value,axis) #Appends values to the end of an array.`</li></ul>|`np.array(array,index/indices,axis) #Returns a new array with the given index or array of indices deleted on the given axis`|`>>> a[4] = 12` <br> `array([ 1,  2,  3,  4, 12])` <br><br> For additional information on manipulating NumPy Arrays see the webpage at http://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html |<ul><li>Access By Index: <br> `>>> a[0] `<br>` 1 `</li><li>Access By Slice: <br> `>>> a[0:5:2] `<br> `array([1, 3, 5])` </li></ul><br>See webpage at http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html for further information about indexing of NumPy Arrays|See webpages at http://www.scipy-lectures.org/intro/numpy/array_object.html and https://docs.scipy.org/doc/numpy-dev/user/quickstart.html for additional information on NumPy Arrays|\n",
+    "    \n",
+    "\\*Use of the NumPy Array requires the NumPy Python Module. Assuming import statement is \"import numpy as np\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8bdbe577",
+   "metadata": {},
+   "source": [
+    "List â€“ a data structure in Python that is a mutable ordered sequence of elements. \n",
+    "\tmy_list = [1, â€œworldâ€, 5.9]\n",
+    "\n",
+    "Dictionary â€“ a mutable data storage method which is used to store data values in key : value pairs. \n",
+    "\tmy_dict = {â€˜msuâ€™: 1, â€˜spartansâ€™ : â€˜greenâ€™, â€œmcdonelâ€™ : â€˜hallâ€™}\n",
+    " \n",
+    "Tuple â€“ used to store multiple items in a single variable.\n",
+    "\tmy_tuple = (â€œappleâ€. â€œbananasâ€, â€œcherryâ€, â€œstrawberryâ€)\n",
+    "\n",
+    "NumPy Array â€“ a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. \n",
+    "\timport numpy as np\n",
+    "\tarr = np.array(1, 2, 3, 4, 5, 6)\n",
+    "\n",
+    "\tprint(arr)\n",
+    "\n",
+    "\toutput: [1, 2, 3, 4, 5, 6]\n",
+    "\n",
+    "Array â€“ a collection of items stored at contiguous memory locations. Values can be accessed by referring to an index number. \n",
+    "\tcars = [â€œbmwâ€, â€œjeepâ€, â€œtoyotaâ€, â€œkiaâ€]\n",
+    "\n",
+    "\n",
+    "Map â€“ a built-in function that allows the user to process and transform all the items in a container in an iterable(such as a list or dictionary without using a loop.\n",
+    "\t# Return double of n\n",
+    "def addition(n):\n",
+    "   \t\t return n + n\n",
+    "    \n",
+    "    # We double all numbers using map()\n",
+    "    numbers = (1, 2, 3, 4)\n",
+    "    result = map(addition, numbers)\n",
+    "    print(list(result))\n",
+    "\t\n",
+    "\toutput: [2, 4, 6, 8]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by Suliah Apatira, Michigan State University  \n",
+    "As part of the Data Science Bridge Project \n",
+    "    \n",
+    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc/4.0/88x31.png\" /></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/BigO_C++.ipynb b/BigO_C++.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9bdd99dc5cb70891ace2e54a52da16f918fc47b2
--- /dev/null
+++ b/BigO_C++.ipynb
@@ -0,0 +1,422 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc73d74c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "#Install answercheck in current director\n",
+    "from urllib.request import urlretrieve\n",
+    "urlretrieve('https://raw.githubusercontent.com/colbrydi/jupytercheck/master/answercheck.py', filename='answercheck.py')\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c2a4f39",
+   "metadata": {},
+   "source": [
+    "# Big O Notation\n",
+    "Quantifying the efficiency of a program by looking at the amount of time it takes to run and memory space it takes up."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b78245b",
+   "metadata": {},
+   "source": [
+    "**_Optional_** Motivating picture: \n",
+    "\n",
+    "![Hour glass clock](https://pixabay.com/photos/hourglass-time-hours-clock-620397/)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "We write many different algorithms when programming. As we run these programs more often and with larger amounts of data, it is important to be able to compare the efficiency of these programs with one another. Big O allows us to do this. There are two aspects of code Big O considers: Time and Space. \n",
+    "\n",
+    "Big O looks at the amount of time it takes a program to run. It also looks at the amount of memory space a program requires."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6b6725f1",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 1:</span>** Let's say you have a linear algorithm. Type its correct Big O notation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9c50d3cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Put your answer here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7bc902d2",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "O(N)\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0bcbd50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(x,'2cab95d1b144d663bad1ce5c51020ae0')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38dd8bfb",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 2:</span>** What type of algorithm has a higher Big O value? (It requires more time and/or space than the others)\n",
+    "\n",
+    "1. Linear\n",
+    "2. Exponential\n",
+    "3. Quadratic\n",
+    "4. Binary Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a7bd8a8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Put your answer here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62bf095a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "2\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "67a669f6",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 3:</span>** What type of algorithm has to have an ordered container to be used?\n",
+    "\n",
+    "1. Linear\n",
+    "2. Exponential\n",
+    "3. Quadratic\n",
+    "4. Binary Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b5de69d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Put your answer here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5fb293c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "4\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49395163",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 4:</span>** If a program has multiple pieces of code with different run times, what Big O notation is used to represent the entire program run time? \n",
+    "\n",
+    "1. The largest run time from the code\n",
+    "2. The minimum code run time from the code\n",
+    "3. An average of all the code chunk run times\n",
+    "4. The sum of all the code chunk run times"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ccb15b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Put your answer here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd1ea9c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "1\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c12a3b73",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 5:</span>** What type of Big O example is the following code? (Answer in all lowercase text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ac7afad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "valList = [1,2,3,4,5]\n",
+    "listSum = 0;\n",
+    "for x in valList:\n",
+    "    listSum += x\n",
+    "\n",
+    "print(listSum)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac0e0202",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Put your answer here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b5e2b4c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "linear\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "99f869f7",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 7:</span>** What type of Big O example is the following code? (Answer in all lowercase text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4e79ed15",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "valList = [1,2,3,4,5]\n",
+    "listSize = len(valList)\n",
+    "print(listSize)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fbdbbc87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Put your answer here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6628cdd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "constant\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d237ca9",
+   "metadata": {},
+   "source": [
+    "## Training Materials\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b047470",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Read the following website:</span>** <br/> An introduction to what Big O notation is and a few types of notation you should be familiar with: <br/> <br/> https://towardsdatascience.com/introduction-to-big-o-notation-820d2e25d3fd"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72ca96bc",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Watch the following video:</span>** <br/> Reviewing Big O notation, expanding on what you previously read, and going over examples of Big O notation:<br/>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6ff70742",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/__vX2sjlpXU?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7f5f00d7ba00>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"__vX2sjlpXU\",width=\"100%\", height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59d22056",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Click on the link below:</span>** <br/>\n",
+    "You do not need to read the entire article; rather, look at the first couple of Big O notations. These provide good code examples for each notation and an explanation of *why* they fall under a certain Big O notation.<br/><br/>\n",
+    "https://developerinsider.co/big-o-notation-explained-with-examples/"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9812391f",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Click on the link below:</span>** <br/>\n",
+    "**TIP:** In C++, you can see how complex different algorithms are by looking at their documentation. The function you are going to look at is the \"copy\" function. In C++, this function will copy the string (AKA text) from one container to another. <br/> <br/>\n",
+    "https://cplusplus.com/reference/string/string/copy/\n",
+    "<br/><br/>\n",
+    "Scroll down on the page to where it says \"Complexity\". Ask yourself the following questions: <br/>\n",
+    " - *What type of Big O search is this?* <br/>\n",
+    " - *What would be the notation?* <br/> <br/>\n",
+    "Then, click on the following link below and compare the \"at\" functions Complexity to that of the \"copy\" function. <br/><br/>\n",
+    "https://cplusplus.com/reference/string/string/at/"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by Jessica Parks, Michigan State University  \n",
+    "As part of the Data Science Bridge Project \n",
+    "    \n",
+    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc/4.0/88x31.png\" /></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6452d221",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Functions_in_Python.ipynb b/Functions_in_Python.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f87bbdb15e85c3439c9e8ac7f6f52eb372963ad8
--- /dev/null
+++ b/Functions_in_Python.ipynb
@@ -0,0 +1,200 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3c2a4f39",
+   "metadata": {},
+   "source": [
+    "# Functions in Python\n",
+    "An Introduction to Creating and Using Functions in Python "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b78245b",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "![Coding in Python Screen - Image found in the public domain](https://live.staticflickr.com/822/40238552784_c48d2029a2_b.jpg)\n",
+    "\n",
+    "Coding [Day 102] photo found on Flickr by gerlos\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "The fundamental units of any Python program are functions. A function is a named segment of code with a name that carries out a specific action. Usually, this entails receiving some input, processing it, and then producing an output. Functions let you divide your code into distinct, reusable pieces. Functions can even be used outside of the original application in which they were defined. There are two types of functions called built-in functions and user-defined functions. Built-in functions are built into Python. Whereas, user-defined functions are defined by the users themselves. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment\n",
+    "\n",
+    "1. Python Functions Quiz: Python Functions Quiz https://pynative.com/python-functions-quiz/\n",
+    "\n",
+    "\n",
+    "2. Python Functions Exercise: https://pynative.com/python-functions-exercise-with-solutions/\n",
+    "\n",
+    "\n",
+    "3. Python Basics: Chapter 06 â€“ Functions and Loops Quiz: \n",
+    "https://realpython.com/quizzes/pybasics-functions-loops/\n",
+    "It is suggested that you are familiar with loops and functions before completing this quiz. There is a crash course on loops in training material #2. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d237ca9",
+   "metadata": {},
+   "source": [
+    "## Training Materials\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21f9b14e",
+   "metadata": {},
+   "source": [
+    "1. In this article, you'll learn about functions, what a function is, the syntax, components, and types of functions. Also, you'll learn to create a function in Python.\n",
+    "\n",
+    "https://www.programiz.com/python-programming/function#:~:text=In%20Python%2C%20a%20function%20is,and%20makes%20the%20code%20reusable\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ebf1e694",
+   "metadata": {},
+   "source": [
+    "2. In this 12 minute video, you'll get a crash course into statements & functions. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "ee42a54e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAUDBAoICgoKCgoQCgoKCgoKDQoKCgoKCgoKCgoKCgoKCgoJChwNCgoOCgoKDSANDh0dHx8fCg0gICAeIBweHx4BBQUFCAcIDwkJDxkVEhUdGBgYFxYVFhUYGBcWGBgVFRUVFRUVFRUVFRUVFRcVFxUVFRUVFRUWFRUVFRUVFRUVFf/AABEIAWgB4AMBIgACEQEDEQH/xAAdAAABBAMBAQAAAAAAAAAAAAAABQYHCAEDBAIJ/8QAYBAAAgEDAgIEBAwQCwYHAAAHAQIDAAQRBRITIQYHMUEUIlFhCBUjMjM1VHF0gZGTNEJSU2Jyc5KUobGys9LT1BYXGCQ2goS0wcLRRFWDosPiJUNjZHWjxOFFRtXw8Sb/xAAcAQABBQEBAQAAAAAAAAAAAAAAAQIDBAUGBwj/xABIEQABAwEFAgoHBQUHBAMAAAABAAIRAwQFEiExQVEGExRSYXGBkaHBBxUiMkKx0RZTVJLhM2JyovAXIzQ1wuLxQ0SCsiU2c//aAAwDAQACEQMRAD8AplRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRRRQhFFFFCEUUUUIRRUtfxD6h7ot/v5/wB3o/iH1D3Rb/fz/u9W+Q1+YVj/AGgu/wC+b3qJaKlr+IfUPdFv9/P+70fxD6h7ot/v5/3ejkNfmFH2gu/75veoloqWv4h9Q90W/wB/P+70fxD6h7ot/v5/3ejkNfmFH2gu/wC+b3qJaKlr+IfUPdFv9/P+70fxD6h7ot/v5/3ejkNfmFH2gu/75veoloqWv4h9Q90W/wB/P+70fxD6h7ot/nJ/3ejkNfmFH2gu/wC+b3qJaKnDRfQzavdqWjntlQHG6SW4AY94XbaknHlroh9C3rDSSRC6s90SxsSZrrBEm/bj+Z5z4h/FXP2m/LBZ6jqVWs0ObqCdOtbVnYa9MVKYlp0O9QPRU8WXoWtYl34urMcORojma65smMkYs+znWbD0LWsTKWW6swA8ieNNdZzG7ITys+zKmoTwkuwf9dvepuSVeaVA1FTtZ+he1iWLjLdWgXDNgzXW7CFgeyzx9Ka22XoWNZljjkW6swsiI4BmusgOoYA4su3BoPCW7BrXb3o5JV5pUCUVPlz6FXWY0ZzdWeEVmOJrrOFBJx/Mu3ArnuPQwaukInNzabNqNgTXW7D7ccvA8Z8YUDhLdh0rs70ckq80qC6KsB/JP1r3XZ/PXf7lR/JQ1r3XZ/PXf7lTPtRdX4hnel5HW5pVf6KsB/JQ1r3XZ/PXf7lR/JQ1r3XZ/PXf7lR9qLq/EM70cjrc0qv9FWA/koa17rs/nrv9yo/koa17rs/nrv8AcqPtRdX4hnejkdbmlV/oqwH8lDWvddn89d/uVH8lDWvddn89d/uVH2our8QzvRyOtzSq/wBFWA/koa17rs/nrv8AcqP5KGte67P567/cqPtRdX4hnejkdbmlV/oqwH8lDWvddn89d/uVH8lDWvddn89d/uVH2our8QzvRyOtzSq/0VYD+ShrXuuz+eu/3Kj+ShrXuuz+eu/3Kj7UXV+IZ3o5HW5pVf6KsB/JQ1r3XZ/PXf7lR/JQ1r3XZ/PXf7lR9qLq/EM70cjrc0qv9FWA/koa17rs/nrv9yrki9DBq7JLJ4TaYhaZWHGuskwkhtv8z5g7TjNOHCW7DpXZ3pOSVeaVBdYqfLb0KusyIri6s8OqsMzXWcMARn+ZduDWz+ShrXuuz+eu/wBypDwnusZG0M70vJK3NKr/AEVYD+ShrXuuz+eu/wByo/koa17rs/nrv9ypPtRdX4hnejkdbmlV/rNTvB6FvWHkkjF1Z5i2ZJmusHiLuGP5n5B31m/9C1rEKhmurMgvGnKa6zmR1Qdtn2ZanfaW7Jjj2T1pOSVeaVA1FWAHoT9a912fz13+5Vz6b6FvWJ4klW6swsihgGmugwB8uLPGaT7TXXE8ezvS8krc0qCM1irAfyUNa912fz13+5V5l9CnrKqWN1Z4UE+zXWcAZ9xUg4T3Wf8AuGd6OR1uaVANFT3ZehY1mWNJFurMCRFcAzXWQHUMAcWXbg1t/koa17rs/nrv9ypTwnusGDXZ3o5JW5pVf6Kniy9C1rEu/F1ZjhyNEczXXNkxkjFn2c6LL0LWsS78XVoOHI0RzNdc2TGSMWfZzpx4S3YJmu3vSckq80qB6Knm19C1rEjSqLqzzE4Q5musElFfxcWfMYcfjrf/ACUNa912fz13+5U13Ca625GuzvS8krc0qv8ARVgP5KGte67P567/AHKj+ShrXuuz+eu/3Kk+1F1fiGd6OR1uaVX+irAfyUNa912fz13+5UfyUNa912fz13+5Ufai6vxDO9HI63NKr/RVgP5KGte67P567/cqP5KGte67P567/cqPtRdX4hnejkdbmlV/oqwH8lDWvddn89d/uVH8lDWvddn89d/uVH2our8QzvRyOtzSploorZp0CzzxQs5jR28eQIz8OMDLOQo5AAeuPIdp5CvVLZa2Wamaj/8Ak7l893Fcte9rW2zUBmcydgaNSerx0C1Fq1WlwJFDDl2gg8iCORB84rfe6DMvGkt1ee1RnAuUjZVkRSQZAO0oMEFhy5HnXJpWj3FyHMELyKpy2xSRuPPHkLnt2jnXJu4WOxD+7O3KdemYXtDfQkwsJFsbGXtFsFu8FuLXrIK6qK4IJDGdpGMEggjBUg4IIPZz7jXfXRXVelO3U8TciNRuXmHDPgbaeDlrFGqcTHZseNHDyI2hFFFFai45FLXR7QGuQ8jZWFFY573ZQTtXzZ7W+L3tvRPo812298rAp5nsMhHainuHlb/HskK4jCQuqgKqxsAAMAAKcADyV4/6QfSG275sNhdNU5OcPg6B+98l6bwK4EutpFrtYimNG87/AG/Naejoxa23weH8cak/jrTYfRd39ztfyT1v6PfQtt8Hg/RLSZd6ilpLfTyZ2RxWhbaMtgmZeQJ58yK+dzjq1qu0nxJcF7o1rWMaAIAXb0e/2n4XN/lo6MexN8Iuf7xJTN0nrHsYuNuEvqk8kgxGp8VsYz4/I8uyvWjdY1lDGQwk5zTsMRg8nlMg+n7drr+Or1W7LSQ6GHMt8AU1tVu9Ojo/9Aj7nN+dJXd0e+hbb4PB+iWmJpPWFZR2vCYSblSTOI1x47tjnv8AsxW7SusuwihhjYS7o4o0OI1I3IgU4O/mMim1rrtRa8BhzdPZmhtVsjNPnV/YJvuMv5jVwvbi4s0iDhS0MPjHmAVCNzGefZSHL1jWJypjmYHIPqGVIPI/T8wRSd/CvSPcT/gi/rUlC7bS1sFjpBkQAfMJXVGzqnftu/dEPzDfvFG2790Q/MN+8U0P4V6R7if8EX9aj+Feke4n/BF/WqbkFf7s/kb9U3jG7/FO/bd+6IfmG/eKNt37oh+Yb94pofwr0j3E/wCCL+tR/CvSPcT/AIIv61Hq+v8Adn8jfqjjG7/FO/bd+6IfmG/eKNt37oh+Yb94pofwr0j3E/4Iv61H8K9I9xP+CL+tR6vr/dn8jfqjjG7/ABTv23fuiH5hv3ijbd+6IfmG/eKaH8K9I9xP+CL+tR/CvSPcT/gi/rUer6/3Z/I36o4xu/xTv23fuiH5hv3ijbd+6IfmG/eKaH8K9I9xP+CL+tR/CvSPcT/gi/rUer6/3Z/I36o4xu/xTv23fuiH5hv3ijbd+6IfmG/eKaH8K9I9xP8Agi/rUfwr0j3E/wCCL+tR6vr/AHZ/I36o4xu/xTv23fuiH5hv3ijbd+6IfmG/eKZsnTDRl9daMMjPO1QcvLzbs5H5K8/w00X3KfwaP9ej1fX+7P5G/VHGN3+Kem2790Q/MN+8Ubbv3RD8w37xTL/hpovuU/g0f69H8NNF9yn8Gj/Xo9X1/uz+Rv1Rxjd/inptu/dEPzDfvFeEtjBbXCtIHZxcyEqNozIGYgKWOBk0zv4Z6L7lP4NH+vWW6ZaKMHwU8xn6Gj8pH1flBpfV9fTA6JnJjRp1FJxjd6f+kewQ/cYvzFrpFMZOs/TlAAWUAAAARKAABgAeqdwrP8aWn+SX5pf2lZ9S6LW5xPFlSiswDVPitd3OIkeQ8xGjOQO3CKWOPiFMv+NLT/JL80v7SsjrO09sqVlIKtkGJcEBSSD6pz5Cmtue1giaZhBrM3pVtZJ4XW4kCFbt4EZE3boiw2REMTh/XAHl38q6NY4lzIbeIqgi4Mzu4LZbeXiRVUjlmPJPnpm2vTbSo2Q5uGWM5jjcbo4zzAKqZO0AkDOcVuv+n+mSsH3XEcgXZviUIxTOdrePgjPOtQ3fW4wOFMzGsabsp2DJRcY2NU7PTeQxptRRO87W2CSYlkj373yObJtQnHbzArPR8PbkWb4bhwq8ciAjdHuKEOpPJw3eO3NNFunmlGJYdswVSGUqmHVwSeIH4md+STnzmven9YOmQlmBnd3wDJKodyq9ig78KoyeQ8tMfdtbi3NbSOeyO4zOwbEoqidVIU0qoCzEKo7STgD4/frRPMskMjIwZdkgyPKAQR5iDyxTKvOsvT5F25mUhkYMIlJDIwdTgvgjco5GtSdY9gqSLmVnk3sWMSAFmUKMAPhQAFHxVWp3LXDMRYcU6dCcazZ1T26PfQtt8Hg/RLXbUfaT1l2EUMMbCTckUaHEakblRVODv5jIrrj6z7BiABLkkD2Je0nH1yo690Wt1RxFM6lK2qyNU4+j/wDtPwub/LR0f/2n4XN/lrg6BarHeRXEsWdhu5cbhg81jccgfIwrv6P/AO0/C5v8tMtLCw1Wu19lK0zCNG9lvPhC/wB3hpUpL0b2W8+EL/d4aVKpWv3+xvyCkZosV5lkVFLMQqqMlmIAA8pJ7K9E0j2kfhjCaTnApzDGex8cuPIPps/Sg9g59ppaFAOBe8w0a/QdKRzoyC2LqEs30PF4ndNOTGh86RgcRh5zivQt7s8zcRr5ltmI+Vp8mt2r6tBaKHnlESs20M2cFsE45DyAn4q1arrltaBDPMsQkBKbs+OF25IwO7cvyirLXvy4mlkdPZxTHXPhCbA2lYMl3HzZEnH/AKZMMnxJIxVveyK6NPv0nB2khl5NG4KyIfI6HmPf7K8aRq0F2rNBKJVU7SVzgHGccx24INGqWHFw6HhzoPEk/HscfTRN3r8Y500lj3YKrcLt4Ed43dUIzGYzXbRXLpV5xk3EbXUlHTtKSL65c947wfIRXVVKrTNNxa7UKQGQoWpNklIZiCVJyORIOCNpGR3EZ5ec0pVwX0eDnuP5a+0OFdF77MHN0Bk/VeOehS32ahe76VaAajC1pO+QY7R8lIWtdJJdNfTig3wiwiLW+4pG5KBQzYB8ZdiEEjuPlNccOpyWek2UsJ2E3jF1XxVkQSXRaJ+9o2EcalT2hFz2CuqDU9MnW0urmQM9raiBrJ4t/EdVAyMja3MuR3c0yVwa4Ojt9ZXFlDbXUwtzbXPH2FWdZk3SvwwQOQbjMhPMjYMBs8uMxe17wzGWfUvexQApDFRd7LhjyOfv5RtiRn0jcmr0h1Hwu4ln2CPisG2AlsYVV9cRlicbifKTW2A+KPeH5BXnpBLFPcytboI4WfxFVQgCgBdwQckDEFtvduxWxFwAPJXR8EqNTjKlU6adZXlfput9m5LZLI0RUHtRta2Ig9Z+SzS/0T6PNdtvfKwKeZ7DIR9IvkHlb/Hsx0T6PNdtvfKwKeZ7DIR9Knm8rf49kkwxKihVAVVGAoGAAOwAVy3pE9Ijbva6w2F01Tk5w+Dq/e+S4HgTwKdbXC12sRTGg53+35ohjVFCqAqqAAAMAAdgA8leL72OT7R/zTW6tF/7HJ9zf801818Y6pUxOMknMr3drGsbhaIAWjo99C23weH9EtNXp/7Bq3wez/SSU6ej30NbfB4f0S01OmZ4ljqk45JIIok84t5drP7xkZx/UrWsP+Lcf3gP5h9FG/3FEWI4kjLx8Qyqzk7ym1RJJGBHgY35jJ3PkcwMcuajp2gTTyyW8AMjpJMNuyAeLEY1ZyZ5QFJ3KNo8lcli7RImZ+FvJeMGPi7MEoZd2MwZZCN0eW8Ts7K6OjKMt5DG4GY7uA/SkiTwqBGIftOQMduK9Ae4gEjx/oKgAlmPoJqS9kBB7OXgA+LldVwaXo11dO8UBaSSIHiJst04ZDsmN0k4V/W5yufXVI3SrRXk1W0ugYxHEsG4vKiOAks7NhDzIO9ef2NI0l7Fd61DNHllWWKEOVIyUiuxIFz65dyrzHkrGpXjUqMLoafZxZAwCPhOe3sUxpgGEh/wI1T603y2P71SNpFjPdyCKBzLIVL7AkKMFUJuLcWUAHcxGAe7NSgej8p1rw0BDEqjJ3jirm0eIAx4yAWI7fJXjo7qUd5HrM8RJjkJK7gVJAslXmD2cwaY29X4MUA5NOQgAuMQczO/UI4oSmNf9ENRgjeWSNljjRnZv5mcKgLMcLdZOACcCkiytZppFjR97yt6kEWEmRcuNxLOFjGU7GNO3qWjAvGwAD4EeYAGfGs2547Tlicny0raOgtbTVr2LxLoXF6glyWwqSh1Gx8x8mJPZ31ZqW51JzmEAn2YMQJcYEiTpG9NDJEpoan0Vv7WNpp0aOJNu58WjbQzKoO1LksebDsFY0votqF1Ek0SM8cgJVv5muQCVPivcgjmD210dF9TuNOmaaFGYSHMqNFLi4HqpVtws8w7WkBwnbTg6nIM2t+ikHcEAPMKS0DDJLDIGT30trtVahSc/wBkxGcHbkcpyI680NaCYTT1jo7e2acScNGhbYGItXG8qzKCIZyyg7T42K4NOtLieQRK26VmKrGiRnO0uGYu5CKoKEczT8sLQ6RpF4lzgG54scfBPEVmls9iklRyBaNjmhrd9Hso5bYNLdXiqDcYdjChQSqOCFZGVSSOweupBbyQQACSYadAcpJ1MAbczpkjAo8kLqcGQgAPuBiUOjIrttKk7WyE7Qe+u/WNJurMotyTCZASu8W5DBGQSc45jgqGzg9uKdXTS18M059UKm2nK8OWPLsJk4yWybhJgJhcsML9NUh9Irq13JBckeqbpVVtwU+DlXJ3DkCp2kA9tQVr2LMGFk5uDgMyC2JjYde7cnClM5qE10W8McMwVuHcPHHE2228d5TiNQOPlcnvbFaNYsp7N+HcMYXCCTaywElCHAZdkpDHem3H2VS70pvUuYdOmjO5JNSsHViCMgynBIYZHx1365qlnHJi4bD2qC7GQ+UB3xh028nb1w2jPvVC2+asNJpTOLIDMRAHzg5JxojeobvtHurbhGcMizZKZWDDhV3sMxSkr4uOfnrfp/Q6+uEEsKySRlnVX326buG7Rsdsl2GHjIRz8lPTrgcN4Aw7GNwR7xgBH4q5+pdtyXznG51gZiAFBY+FDOFGB2DsqwLxqGxcoAAO6DHvRvTTTGPCmbBoNw0zWqw77iPduRkhLALsYkubraecqnke+udLB2l4IjUyiXgGIRx7xNukUofV9uBw/X5x41ObqaAF2oAA/m0vYAO1bJiTjtOWPM0+7ixtdRuY50fFxY3HDY4O48Atuhwx9ZvkzvA7qda70dZ6pY5uUTIByOevQYSMpYhKiDU9Oe1ZknjWJkCkqYkY4dZGTbw5yCSYyMZ76WB0G1DGfAxjGc4tOz8Np+W9hHNrUzuu54La3eM7mG1iZEJwpw3ikjxs1HJv7l7k3qsxugzgTCEsuFLwcPYlqYyDDy3eXz0+hbqlfJkAhoJkGJcJAEHTec+pI6mAkZIhJtwF2uQquqKGyY2ZgyhyVKtt8mcUq6T0PvbmKOWGEvEwJRitmCRubPKS53eu3dteOkuotcSy3BXhu8zNs8cmMraqozxYwSfFB7O+nj1Qx77a/UYBdYh2BRua2PPkMAZNT2611KFDjABOWRz1y2EaSkY0EwmbrPRe6s0ElxHwkLbA5S0cbyrMoIinLAHaeeKT7DT5JpFiUAyu+xY0iiYsQzIWLvhFXchGSe+pC0mzbS9IvkmAzMJkXgHjjdJZhAXMY8QFkYknkMivMEL6XYR3cAaa7vo41M2HPg6TQCZQIlVkZUkXyDO6om3g4gjImcLToDlM6mANuZ0ySmmo7mtWVtpKgqWVw8KqYyu8nIVSGG2NjlSaWdN6J3kyLNDGdj7trlbOIkKxQnbJcB15gjmKcnSuz9MNOfUXVre4RTHIMuROisIl3K+Ag8Zm5L31v16Qa5FHMgVLu2Zke0m2bSJpF5CS5UAnhxhgyj6aj1g5wBAAzLXE5hpHURIJ2zA2o4uPJM3WNLu7QqsxMbuAUDLCyvlguN8EjBWPP12Oyt+i6BfXicSANIgKqWAtUAcxxylfVbgMcLIvPHfSjq+rTpbRabNAIjZvE5fdI5dYTglFSLaQS4GQe6uvqPbddOxxu8FdMgAeKklsFB2jngd5qSraarLO6qQJGm0EbDkdo6UgaC6E2NasLq0cxykpKArbXEGNjLIwbfFIw7I25Uo6b0Yv7qMTQK0kTFtr4tU3BHZCdklyGXxlPaO6t+lWMdxqTQSruimvJ96gsm/x74gM0ZDYzGh7e6t3Wxfs18Y5WLRwsixAbF4G6K1lkf2MtLkn1reTlTjaHmo2k2JIxEkZRpkJ1npyG9GERKQLi1njlNuzkThthi4cbPuPD24ZHMe0h87i30tK/wDA7U844Zz2Y3WOc+T6Lrp0/pvK9zbXEgEzwQvFIy8RWdZZE3zbFtwBtGPEWuzWdIdrkajZhLuIsuolcxRzKY3EhjAI4xBRQNvlfszTH2msxwa4BsjU5gndqI35+SIGxM+5ikQzJIxzGro6MgRkkBdcZQlXXCHxlJpJtPXp9un5wp19K9Za/d5mj4ZMKxBAZGwY2mBBZ4gA+59u3zU2LW3feh2N69fpT9UPNV+i5xbLhB3Jjhmpe6i/oGX4XJ+gtqdXR/8A2n4XN/lpq9Rf0DL8Lk/QW1Oro/8A7T8Lm/y1wN7ft63Yr1H3Wo0b2W8+EL/d4aVKS9G9lvPhC/3eGlSsi1+/2N+QU7NEmdIyTEIwcGeRIMjtCucyH3+Er0oqoAAAwAAAB2AAYAHmxSdrPsloe7wgj4zbzgfjpTqSscNGmBtk9sx5Jo94qF+tj0yy3hWPBPCZeBjgZx6pw88Px/Yvq/j51JeqdHLbUI4PCYy/Cj8XDumN6pu9jYZzsXt8lNfr4+hIPhH/AEpKcOvdJYdPjtllDbrhCqFFVsMqxjxssMc5F/HW9WqVq1noOojC72vdy6/DVQABrnSmzqzHR72ytbL1KC6liMqH1UuWmWI4abLL4nLxTUk00ui3Rqb2TU9lzcRyK0Mu4sY1XawAO0YIkBanbWXetZji1oMuHvO53bqY6VLSBzKTccK75etuIiT91gK4PvmN8f8ADFKRpN1L6ItPLunP9UQsD/zMtKdVbXm2m46lvyJA8AnM2hQrWHQEYNZor7uc0OEHRfH1Kq+k8PYYIzBGRB3hcbWZzyPL8Y/1rEloe4/L/wDwFdtFYh4OWEg+xr0nwXolP0r8ImFh4/3REFoz6XZZnpWuCEKPP3mnF0T6PNdtvfKwKeZ7DIR9Knm8rf49h0T6PNdtvfKwKeZ7DIR9Knm8rf49kkwxKihVAVVGAoGAAOwAV5pw94e0ropG7ruI4zQkaM/3fJafBrg1ar8tJvO9CXAmfa1cfJo3eSIYlRQqgKqjAUDAAHYAK90UBT5K+b3ufVcXOkk5navamNbTaGtyAWGOOZ5Ac8nkAB2knuFIhzqB7xZqfODdMD8ogBHx1t1aIzzx2zEiIxPM6jIMux0RY2P1GXyQO3FK6x4AAGABgADAAHYAO4Vaax1FocB7R0y0H1+XyTECVz3t0lum9uSrtACjJJJCqiKO0k4AApkdJLjGlXcDq0cqo8mx12lo5LvcGU5wwG8A47DTz1ixaZAFO10dJUJBK70OQGA5lSMjl5aanWHZztZXU0+0FLfhokW9lG+aJndndQcnYBir91sbibi1xA9o0y6ZM/1MdUqIY5BtVZYw5jBC+rLH4pZnKSrnLKHZjy2nxiM9mFPopBLNeQyY4jvcxuwiBcqEuYJJJGEYKpEobtJ5cqS7lm34DFR6qx2k90kpPLPM4FdNjftDtZZ2RiGw4M6SbWIVl3QzDxSYgcV6DUpktICoghPLrot38KWTZhfBo1EjxFoyyNdSPErlColK7Wx5qRurSGR721YKXAcOdkZ2xRhbhMyFE2IC7Gku91d5l2y3LSjxsCRruQKWVk3BZJyA21mGfPWvT9QNvjhXBjONpaM3MTMu5nAbhTDIBY1UZZHts3E9ETHRCcXguxKSUuZE6QOiuQkwjWRBja+yxkdN3LPitz5eWurRIYYH1i1hCo3Ph26kbyps0yUjzuYb27R3mov9NTv4vhDcXIPG3XfG5KU9k4+7GxivvVhNUKyGYXDCZs5mDXYlYEKMNIJ9zDCryPkqo66SRE/C0aalpkHy6k/jQnt1V2UttcSSTxPBGtk26SeKSGNSDa5BeZQuQI2PvCt2g38V3BqOnpIqzXE928TSMqxSrLLtXhuCTJzRj4oPZTJn16aRWR7yRkYFWVpb1lZSMFWU3GGBHLBrlivtrbhOQQ25MCdTEfG5RFJQUHjkY96pql3Go5zzqYjLTDmPEpvGAKVOrO8uxLLFetIpxGkK3A2cRkMvE8H3IDKojVGOOwYpK6o4HWxvWZGVZIwUZlKq4WB1YoxGGAYYyKZEmtyMyO13IzxklGMt6WQsNrFGNxlSV5cqxBrMkaCNLp0jAKiNZLxYwpzlQi3G0A5PLz1FVuovD4yxYdmQw7utKKgEJ6dF18K0W8Wf1UW8cjQh8epFLFHj2Y7NrO2M0o9N9UmtbDT2hlaLdGu4xkAsEtC4GWUgDKio3i1MojRpOUjcbWjQ3aRuNgjO9Fn2tlFAOa8X2qO4EckjyKq4QM00iIHj2gokl1hfEbHZUhuzFVDjpJdEbxHzzRxsBSDrV3JP0eneVzI+/aXbG4hNQVFzgY9aAK9ddQBls8gHxZfXKGHOe0U8mGM7WIz56jqXV2aNoi78FiWMO6cQklt59S8K2ev8bs7edZu9aeYgyyPKVxgytNKV8dHIXi3R25Ma5x5KSjdZp1Q8aBzzEc4AR2QkNUER1KTYPa3RfhmnfpDSB1yAeGHIB/msYyVBI8W9bkSPF5qpyPJTRGsvtROLJsjKsicS42xsnNGjXwvCMp7COyvF3qpmO6V2lbGC0plkYqFkUJukuSQvqjnA8tPs93OpVMc87ZziD5IdUBEKR+tT2PTftZv7ste+pu0eOO7yp2kRosm1xHK0ZuVfhM6jeFY7TjvqObjVZpJFSR2kCOUXiSzyBAfUyUWSYqpK/wCFdFtr86YRJJI1wZNsd1dRRrvBmfaiSchlmPLy1EbrfyXk4PbHTiSiqMUpz9UcLR3wR1KOttKGR1ZHRgtkuGVwCDyz8Yrxp1y0WsNw2KGW/kjkwRiSNrq5JVhtz2xrzzTXj1llcyrIyynOZVubwStuCghpANzDxF5HyCtfpkN/EzhwQ28TXPE37pH4nE2795Mjc8+SrD7EXve4/E2Ijr+qbjEBSrPrUNnrE3GbYstvbxiQ7VjRhxH9Ud2AQEKce9SR0ZW9069SGd3WyVpWaTmLLEySSJ6s8YVW4zouCfXNimFc6rxSxkYyFgAxkmuZC6qrqqsZFJwu9iPPittzrskqmOSZ3Q4yj3V6yHaQy5VuRwQD8Qqu26cLcO9oactwgEbincbmlnrDQtfXKjta428+zJsowM+anJ1UWz+B3p2NtkRBG2xwJdtuyEx7l8cbxjlUfvfmVt5YF95cvJNI7MxiZFLGYbnHiqMg8uVbLXVrmJQkdzw0XkES8ukVRnOAqzYHMns8tTWiwuqWcUQdMOcbo+iaKgDpT26JQm00fUFnQ2xdJ1VZ1MJd2sUXCCTBYs6t2duDXX0m1Oa10nTXhkaImG3DFCAzKti8m3LKQBuQVH1xqs8uBLOJlVtwSa5uZU3AEA7XmxnBPPz1pnvZnRY2mVo0UqiPc3DpGNhjGxHlKqQjEDlTDdpc/E7P2sREZaRHml40BSHcXss+g3byuZHDSpufG4qlwqrnAx2eSkjpd0YW3eF7dpLpZQzcaOKOQo8UkOwq9tAcHAcc/qcU1WvpdjRcZRE5JaIXNwIiWO45jEu3m3PsrZbatcxKEjueGgzhI7u6jRckkhUSbCjJJ5eWloWB9FxLDkXExGwjIdiQ1ARmnr0yAk07T5bjne77cEyYWfaWcvlTzA3Y7q5+pG1dZ3baSng7DiBX4Yd2tpBFvZdvECYJUeWmZe3s0x3STLI4G0PLPLM6DcG8QzudhyO0eetllqVxCu2K4ES+LkRXVzGrFUVN5WOULuKooz5hQbvdyd1GdZ2aTsjcECoMUpciuvANSaeaNwsVzNIyiNg/Ddr3ZIocAMjcQHcD3Gu7rC0WW4uvCYYzdQzsrRtbbpVBjS3hcTlIioUlGxg/StTPvbmWY7nnUvy9UaeWSTADqF3SuTtw7cvPW8azcwJiOYpHuOI4Lm7SNS5ZyFVJgqjJJwPqqmNkfxjajdQMJ6tfmjGIhOWDopDFd21rNcosjRSPKY/BcRzoy8NELQ5XIOcMM+Ss6Pps9jqKJCkoVbwQmVYCqyWrSwFuIyQhCviMdwNM46izlpH5vvU7zxJJS5wVfivNxAV4QHI95rs/hRc+6p/wi7/fKDZqxEOMyIIjbv8AKEYwlzrPjhjvJRCF2uiNII9h3S/zt335BAfcq5zzprQQhlDEIgbO0SNCpfBIOPUMKuQRvfAyDz5GtdxeB8nJyd5Pi83dw+XkkeUuzeqNzNYSWJ1QSbwY1Kjh7SJFLvJglz6m252G/DcivLlzsUaDqdMN1jKU0uBKmDqWBFnMCuwreSqVIAIYQ24IIVBgg8vipydH/wDafhc3+Wmd1S2a3dtcTMXVmvZTtimljUZigbGEbmfGxk8+Qp+6dYLbqVQHBYuSzM5LNjJLMcknArhL4AFeqBMmNmXer1E+yFx6N7LefCF/u8NKdJujD1W85f7Qv93hpU2nyVk2qm7HpsHyCla4Qk/XbdpIjsGZI2WVB5XiYOF/rAFf61dNncLMiSIcq6hh7x7j5CDyx5q3bT5KSJVa0dnRS9u5LOijLwufXSxqObRt2lB2do76kpN42nxRycM2zt3j6JCYMpo9fJxaQfCP+lJSd10ShF0tj9KJW9/aLQ1KEEscyh0IkQ9jDDD/AP3WxkB7QDjygGr1mvTk3Ftew+xinOJxZbsoTHUsUwdUwtM60re4mihWBwZZY4wS0eAZHCAnB7BuzT+ryIl7lHyCky6vmmJitjk9jzjnHCO8KeySb7EdnfVWq2laXDiWYANSTI/r5pwlozMr1aHjXMkg9ZApgU9xkYq8xH2u2NPfDUqVpsrZYUWNBhVGB3nykk97E5OfOa21UtVUPdDdBkOr9dU9ogZqFqKKK+9F8dIpe6J9Hmu23vlYFPM9hkI7VQ+Tyt/j2Y6IaCbx9zHEKMA2D4zHt2L5OXafP8j36IfQdv8Acx/jXkPpD9IAu+k6yWF01dHOHwTOn73yXpnArgUba4Wq1iKYzA536fNKcMSooVQFVRgKBgADsAFeqzRXzI+o6o4ucZJ1JXvLGNY0NaIASXb3khm2ns4kimPhsDHGoYxy8QnDbyE5f+p5jVc+uy5kXWb4B2ADW/IOwA/mdueQB8tWMgWbjc92OJJuJZeCYcPwgig7hIDw8nHdJnliq2ddp/8AGr/7a3/FaW4r1P0f06ZvNwgfs9mfxD+t6xb2JFEdfkmp4VJ28Rs+Xe2cfL2VkXcv1x/v3/1rM4BUMDz8Ve/uUAjyd2a82jEE4zzBHi9o5jn71ez8RT5o7lzuMo8Ml+uP9+3+tL/QvotqOtSNFaK0gXHEkkkZYIgeziOe849aoJ5dnI03NjM21fHYttAHPcxOAB5cn8tXf6v+jMWkWUFpGBmNQZHA5yzsAZZW7yWbOM9gCjsFYV+XhTsFMYGAuOmXipaYLjqoLHod7/Zk38PEx63bOUz5OJjOM9+2o76edBdQ0RkF2gCSEqk0UnEhkYDJVTydTjnhwO+rL9LOtvTdNuGtn4s0iNtkMCRskTYBKs0sq7iAeezOOY7QRUdeiR6S2mqabYzWkwlQXjBhgq8bcCTxZI3AZCfOOfaMism67ztlSu1tZowu2xCkewASmP0Q6otT1W1ivLd4RDNxNolnlWT1OV4m3KsBA8aNuw+Slb+ILWvrlt+Ezfu1P/qT6faZY6PZ29zdCOaPwgsnCnYrvu55F5xxFeaMp+Ope0nUIrqKOeFt8Uqh0fDLuU9hwwBHx1Wt9+WyhVcMIDQSBLUopghVi/iC1r65bfhM37tTE6c9GLnRrnwW5ZTLw0lzC7Om1ywXxmQHPinlirgdJem2n6bKIbu4EMjRiUKY5nzGzOgbMcZHro3GPNVZPRCa3b6hqnHtpOLEbWFN4V18ZWl3DEig8sj5a0LkvO02qtFVowxM4U2owNEhcfQHqz1HW4HuLVo1jSUwkzyyRkuqI52hIjlQJF5+/XV0y6pNU0m1kvLhoWhiMYbgzSu44kixKdrQgY3uvf31YXqE0rwTRbFSPGmjNy3dnwh2lT5ImjHxUv8ATzSPD9PvbUeuntpo178SFCYjjzSBT8VUavCOo21lgAwB0abJhKKeSpZ0Z0mbUbmG0hYCWd9iGRmVMhWbxmUEgYU9gqR/4gta+uW34TN+7UzeqLUYrbVbC4mbZFHKXdyGO1eDIM4UZPMjkKtjofWBpl7Mlvb3Qkmk3bU4U67tiNI3jPEFGERjzPdWnft42iy1AKLAREkxKbTbiGagD+ILWvrlt+Ezfu1cur9SGr2sE1xI8BjgikmYLcTFikSF2Cg24Bbap5EirWzShFZmOFVSxPM4CjJOBz7BUcdMusrSbiwvYYrwNJLZ3MaLwrgbnkgdUXLRYGWIHPy1i2a/7bVeAGgiRMNUnFhQB0A6tdQ1uF57V4gkcphPGmkRt4RH5BIj4uHHM+enH/EFrP1y2/CZv3apB9CT7W3Xw5v0EFSh0m6RWumosl3LwUd+GrFJHy+1m24jQkeKrHn5Knt9+2qlanUabQYOWSa1gIlVd6SdTWq6fbTXUzwGKBDI4jnlZ9oxnarQAE8+80zeiOhT6pdRWduRxpt+0yOyoOHG8rbmVSR4qN2DyVY/rT6xNLu9Kv4ILsPLLbuqJwp13NkHGXiAHZ31FHoYrffrUbfWra5k97KrF/1TWtY7wrusdWtWaA5sxlGxNc2HABdf8QWtfXLf8Jm/dqZHT3old6JOlvdFS7wrMDDI7oUZ3jxuZAdwMbcvOKu9VfPRfWHjabcAcsXMDHz5ikjH6Ws65r9rWm1NpVQIM7Er2QJCjjoD1Z6hrcD3Fq0QjjlMJ40siMXVEkO0JEQRtkXnTjHUDrP1y2/CZv3apa9DNZ8LRIGxznmuZT58TNCD97CKk2q9v4RV6VofTYGwDGm5K2mCM1QS5Ro3ZGOGRmQjPYykqR8oNSD0X6nNU1G2hu4HgEU6l1Ek8qvgMV8ZVgIByp7DTV6w7bg6nqMeMbb67A+1M8hX/lIq1/UX7Sad9wP6SSty+rxfZrMyrTAl0ajolMptkkFQb/EFrP1y2/CZv3am70+6s9Q0SBLi6eIxyTLAODNI7b2SSQZDxABdsTc/eq1PSbplYaa6x3dwIXdN6qY5nyuSucxxkDmCMGoe9Ed0zsNS06GK0uBNIl7FIyiOVCEEFyhbMsYB8Z1HLy1lXbe9sr1mNewYSdcPmnvpgCVH3Qrqp1LV7Zbu2eERMzoBLNKj5RtrZVYSMZ89cHWD1fX+hrC12UZJy6q0EjyKGQKdrl4xtYhsj7VvJVhPQy+0kP3e5/Smlnrq6M+mulXMKrumjHhMIAyeNCCwVfPIhki/4lON/wBSnbjReBgxRps0ScXLZVQ+j2my31xDaxMBLPIsSF2ZUDN2biASB7wqSR1Ba19ctvwmb92pn9TxzrGmHy3cX5auuKt39etWx1mspAQROY6UlNmISVS3oL0AvtZkuYrZow1qVEnGldBl2kUbCkZ3c427cd1Ov+ILWvrlt+Ezfu1Kfof+k9npl1qzXcwhEskYTKSPuKS3RblEhxjcvb5anvox0os9TEhtJuMIiochJE2lgSo9VQZyAezyVTvS+LXZ6pDGjDlnh3jenMpghVx/iC1r65bfhM37tTd6fdWmoaJAk908RjklEIEM0jtvKO4JDxAbdqHn71W26Ra7badFxrqXhRFwm8q7+MwJAxGpPMKefmqDvRI9M7DUtPgjtLjjSR3aSMojmQhODOufVIwD4zKMDy027L6tdorNDmjCTmQ3zQ6mAFEXQvopfaxKYbOIyFcF3ZtkMQOQGlkPJc4OFGScNgHBqTY/Q73+zJvoQ+PWBZ2TPk4hAOPPtqburPotHo9hBaqo3hQ8zgc5LhwDK5PaRnxRnsCKO6kjpj1sadpdwbaTiTSqQHECRssRIDAO0sqgnBBwme3y1Har/tFauWWVogdEz0obSyzVaOnvQHUdE2m7QcJ22JPDJxIXfBbYCQHVtqk4cDsOKam4+U/Kan/0RfSi01XSbWW0mEoW/QMuGSSMm3ucCSNxuXODg9hwcE1X+uquiu+02cPqtAdmNNyhqDCYC3W8smQquy5Pc7KM+Xt81bOPLgnityO32RvP5+zlXMjBSCewEE+8OZp29IerzVtPtpLm6sXhtw0ZMrPAyjiNsTISUtzeRR2d9aJoUzq0dyZLk3N8oJHEbku44kbn4ufLzOKBLL4vqreMSB6o3djt8bl21q4ozn7Db8ezb8ma8hxhB9SxJ+Pb/oaOIp80dyMRSr0YuZPDbQGRj/PLYHx2wfV0B7+yrfmqddGm/ntqf/eW5/8AvQ1c9tPl279h2Y3ZyOztz2+SvIfSXYqlSrR4lhMBxOEaDLMwt+5qgDXYikW40iNmLruhkPa8LbC32642P/WBrx4FcDsuzj7KGIn5VAH4qU8UYrysWysBBz6wD8wVuYWpLOkb/ZppJh9QWWOM++kKjd7zZrrnHCibhIMojFI1GBkAkKFXz9wrpxRikdaajyMeYGzQdwyRhC4NKuGcuC3EVdu2QRmMMSDuXaTz28uY+qx2g13VmjFR1nY3FwEJW5BQrSx0V0fwqZVfKx7GkyARvCMiFVP2zgZ8xrVpWkvKolYYhEsUZJyN5eVUYJ7wJ51ICRKl5GqgKq2cgCgYAAmhwAK+nOH3D1thY6xWJ01CDLh8MDT+L5LwXgXwLdbXC12sRTGg536fNZ6PRLHJdKoCqs6AKBgAC3hwAKz0Q+g7f7mP8a9aJ7NefCF/QQ146IfQdv8Ach/jXzjbHue17nGSSwk/+JXu1JjWANaIAStRRRWUp0VVjrs9ub/7eD+6W9WnqrHXZ7c3/wBvB/dLevS/Rd/mVT+A/wDs1Y19/sh1+SZ1FZ2nGccj345fLQVIxkYz2cu33vLXvC5hd3RuZY7q1dzhEuYHYnsCpKjMT5sA1fGvn5cEqpOOYG7HlwNw+X/GrXdQ/WVDqdvFazyBbyNAilj9Eoi8mUntmVRzXtOCw78cXwtsz3hlRuyZVmgclX7r66N6hp+rXZZPULmaW4gmJwsqSsZGQH65GzlCDjsB7CKZllqLvmKQFWXDYPkHi5B7CPG7RV9+keh22owPb3UKzQv2q2eRHY6Mp3RuM8nXBFVR65OrOTQZVkQmaylYrFMwG+NiN3Am2jG/apIYcm2nkMVLcV6UbQG0n5PHcf1S1ZgqMbi+nViFRioPIjsI83Orv9TDE6LphPabOIn3yOdUuq6fU57Tab8Fi/JUXC2kGUWkbSii6VAPowLqWPVrYRqWB02InHcfCrvz1FWhRTXrxwlSss0yQIG8sjKiH3tz/iqX/RZ+21v/APHQ/wB6vKbnof8ASvC9aswRlYC903m4KExn4pzFWjduGhdwrbQ0pr3S7CrbSbLO3O0YjtoDgdwSGPkPeCrR0evfCba2nBzxoIZs+XiRq+f+am/1y6h4Lo2pS5x/NJYwfPMOCvx5kFcnUNqfheiae57Vh4JHk4LtGo+8VT8deemkTRNb96PNWFVXrW05tO1LUIUXnHcyFFXuimYSxAe9DKvyUrehsvJpOkFgHQquLvmezPgVzjvp2eiu0ng6nDcAYW6tVyfLLbsUc/NPAPipv+h29vrD+1f3K5r0N5baLt4064D4D6qs12F2FW11v6Hn+4y/mNXz3g1K5KrmNhkD8g89fQjWvoef7jL+Y1UIi7B7w/JWNwRote2pPR5qSq/CrPehK9rbr4c36CCuf0Yc7x6ZaFAS3pggwPJ4Nc5ro9CT7W3Xw5v0EFS3qFhDcKFmiSZQdwWWNJFDYIyA4wDgkZ89ZFurihebqjhIBSs90L59QahOzAMhCkgE9wHy1OfoSrbdqV1J9RZMnxyTwkfijanv6JjRbWDSd8NtFE/hcA3xQxxtgiTI3IucHyU3vQgQePqcnkS0TP2xuWP5o+WujtFuZaLrqVWCNniEyDjEqfru5EZiB/8AMk4fx8ORx8pTHx1FvoqbDi6QsvfbXcMhP2MiyQEe9ulT5BTp61NT8ETT5CcA6tYxk/Yuzh/+TdWeunTTd6LqUQG5hbPKAO0tbkTrjz7ohXH3e7iK9Kr0/wDKmcJC3dUVnwNH01MYPgcEhH2UyCVvjy5pf0m7E8SSjscEj3skD8leYlW0twPpbeEDzbYY/wAmFps9SN4bjRdPlJyWgOT5SsjqfxioK/8AeY63T85KUDJVp6+bbha5qK+WSKT522hkJ+VjVlOov2k077gf0klQN6KO24eslvrtpbye+QZYv+kKnnqL9pNO+4H9JJXUX0/HdlA9XyUNMQ4qFPRjXUkd/Y8NS2bN847sTtjv85qErO9mkbDoQuCcnsyOzvq/+oaRbXBDTW8czAYDSwxyEDOcAuuQM91V79FfpsFtJpoggSHcl3u4USR7sG3xu2KM4ye3ympeD95U3Op2fCZ39WaWrMFSL6GX2kh+73P6U1JoqMvQy+0kP3e5/SmnTq+uC21KxtmOEvoLtVz9etTBInmG6OWUe+Erm7yYXWyqG7ye5Pb7oUAXfRr0r6XW0KjEMt7FcwjuEU7MSoHcqSiWMDyRirRimH1ndHRPdaPfqPHstQgRyO0wXMixd3aVn4PvB5KfgqW8rbyptFx1Ag9YKRrcMqgHSa6ljuJuGpbM02cd2JDjv9+rBeg1nkkt9SMilSJ7cAHycJzn5SagbWfZ5/u0v6RqsB6EH2DUfu1v+jkrr7/otFgLtvs+SipvzhLfosJXTRCyAswvLbAHbz4gP4qqroWoy8eEyoRGsiOxPZhXUkdvkzVr/RTe039rt/ySVVKYkKxHaASPfxyqLg1Qa+xk7ZKWo+DC+gQIPMHIPPI7CD3iqZeiH6N39jq9zIV/m13K9xBMWO1+J48kWQPFkjcsu092w99Tj1AdZcOoW8NnPIFuo0VImY8rmNR4oVj2zqowVPMgZGfGxJuv6Nb38L291Es0L9qOOWR2MpHNHB5h1wR3VzFkruu21HjWyND1bwpjmMlQWy1F2zFIpVh42D5ByyCORHPurttgCyg9hIqQuujqwk0ORZoiZrGViqSNgyQOcngzEDByASHHbgg4I5x1XpNhq0qtIPpGQVTqTOa5dWvCoye3ZIezvVTjl2Vf/p90U9O9MaxM3AEot24ojEhUxSRzDxCwByUx8dfPfV4mkOe3znJp+dGenHSe8kWG21C7uJDnbDE5dyqqWYgAdgUfiq04IYQlnrr6BL0cuI4VuDcGW3E24xCLaeI0ZAXeQc7c/HXTrfVylrYtei5LHhwycPggDErRqU38TsHEznH0tOLSJlVGPShlW84jCA6tw0m8G2Jng8Y5MPF4nMd+amjpN6UelPjm24XAts7jDs2FogO3lt7PxVSq13YoblHj1KB5JJjKPFV/6iOq1ekHHnN2bbwK5hGxYeJxB7J67igp63HLy1a7U7FIdPaB29TjtxEWLsniogXJffuHIduc+eqxawl8J7UdFtwtuLi99KtnD374uH4RweW7hcTt7s1NWm3Fy0RjuXZycq6yHdnuKsD21yvCq/qNho4qjHS9rmgjYte7aJrCRlCSPALD64Pwyb9vR4BYfXB+GS/t6VfS6D6ynzafq0el0P1lPm0/Vrwjlg57+9dRgSV4BYfXB+GS/t6PALD64PwyX9vSr6XQ/WU+bT9Wj0uh+sp82n6tJysc9/ejB0JK8AsPrg/DJf29HgFh9cH4ZL+3pV9LofrKfNp+rR6XQ/WU+bT9WjlY57+9GDoXF0giVIEVQFVZ7UBQMAATx4AA7K9yfRyfBJf08NHSb2JfhFr/AHiOsSfRyfBJf08NSU3uezE4yTjz7Am4A32QMsl60X2a8+EL+ghrg0C+aC3ije2m3IgU4hyMjyHdXSLa6ilnaMRMksgccR5VYYjRMELER9Jn4627736iD52b9jTnAEHQg4fijQQlR6cf+3n+Z/7qPTj/ANvP8z/3Ub736iD52b9jRvvfqIPnZv2NR8Szmj86WSj04/8AbT/M/wDdVZ+uKbiavettZMtD4rrtcYtYBzXPLsz8YqzG+9+og+dm/Y1WfriLnV73iBQ+6HIQsyfQsGMFgCfFx+OvQ/RsxrbwfAHuHR07WrIvk/3Q6/JNuQ+KT3FEA98bcjHxGs3B5N9kykecANn3u0VqlQAKR3g598HFa69sXNLbdHLZ7cqny7Rmky2vHsXBBPD3Aqwz4hByBketIOMHzCu6pjTqImvbKzurK5Qm5tYJZILvcoDyRKz7JYkO5CScIy/Gaz7wtNnpNArGJ0UtOdid3oe+tOXUpBYXTcWThs0U59kbhjc0cp+nOwEh+3xDnJ51I/WtpK3ulX8LAH+bSyJn6WWFTNE3mxIi/jqN+ojqTl0O8a+up0ZxG0cVvAXdIzJyeVpZEBJ2ZUIBgbm59gEi9burrZaTfyscFreSFPKZJ1MSYHeQW3e8przq18ULc02Y7RpvVvUZqlIq6nU57Tab8Fi/JVKxV1Opz2m034LF+Sul4X/sGdfkoKGpUF+iz9trf/46H+9XlLPoRNKzLf3ZHrI4rZG88jGWUfEI4PlpG9Fn7bW//wAdD/erypU9DPpPg2jRORhrqaa4Oe3G7gxn3jHCjf1qgtdfi7lYOdA8/JKBNRKXXroN3qelyWlkgklmmg3BpFjAiR+I53OcHmijHnri9D50avtJsJbW+jCMLmSSPbIkg4TqgAyh5YKk4P1VK/TrrGstHlSG4EjSSR8UCJEYBCzIC2+UYyyN8laehXWbY6tceDQLKsnDaT1VI1UhCoIBSUnd42ceY1zQNo5JxeD2JmVNlKaXosNJ42nQXIGWtbkAnyRXCmNse/KsFRF6Hb2+sP7V/crmrN9aekeH6Vf24G5ntpGQeWWIcaH/AO2NKrJ6HU516wPwr+43NdJc9ox3XWZzQ7uI/wCVC8Q8FW11r6Hn+4y/mNVCIuwe8PyVffWvoef7jL+Y1UIi7B7w/JTuBvu1ezzSV9is96En2tuvhzfoIKU/RJdKLjSrG2mtp2gZ7xYmZAhLKYJn2niKRjcgPxUmehJ9rbr4c36CCnP13dAG6RWkNssqw8K5E+6RXYHEUseAEYHPqmfirGthpi9HGr7s5ypGe6FWDpD1i3upxG3uLt54yyvscRAbkzhvEjByAT8tTf6ES3xZ30n1d0ifNwq3/V/HTB6S+h8k0u1uL3wuNxbQvKUWKYMwUc1BaQgEjy1KnoVrbZo7N9dvJ3+9SKL/AKRrZvSvZzdzhQIIxDQR0+SaJx5rk9FtcGPS7YqcEalA2R2gJBcsT8WBUqaNeLeWsM2MpcQRyY7issYYgj3mxioi9F6c6fZp3NeH5BbTj/NTr9Dvqvheh2TE5eJXgbzGN22j5spXPVqH/wAfTq9JCkBzhKXXNqfgmjalNnGLWSMEduZ8QDHnzIKRfQ0v/wCA2S/W2uY+XZyupjj/AJqSvRYajwtISEdtzdwRkeWNd0j/AI0T5a3ehWn36Ntznh3lyny8OT/qUos8XYam93kic4TE9F3a7byxl+uWskefuMu4fpzUvdRftJp33A/pJKjv0X9rmHTZvqJbmL51InH6E/jqROov2k077gf0klXbbUxXTR6CR80xvvlR56JPp1eaTeWsdvdNAklsXKoIyGYSsu474yc4wOXkqEOlHTK51fh+E3DXBh37S4QFRJt3AcNB2lF7fJVjOvDqifpHcW863CRCCBosSJIxJaQuSDG4wOztqGusXqbfo7bLdG4SVZJ0g2RpIpyySuGy7kYHDIx9lWpcNaxgUxIx9WffCSrMKc/Qy+0kP3e5/Smmj6K/VZLK50G5jO1oprxge4MGsWQnyjeAMeend6GX2kh+73P6U0yPRlRh10tT3i/GfIf5lg/EefxVlUKYqXu5p2l3yKfMNU56LqEd/bQzpzjuIklAPaNwDYPkZW5e+tKIqEfQk9KTdWMtjIfVLVy6j/05GIkUeZZsnP8A6wqbhWLbLOaFc0zsKeqE6z7PP92l/SNVgPQg+waj92t/0clV/wBZ9nn+7S/pGqwHoQfYNR+7W/6OSvQb/wD8tPZ5KpS99OD0U3tN/a7f8klVVq1Xopvab+12/wCSSqq0zgp/g+0+SWv7y4Irl7J8j2ItkEf+Wc8lPkGew+9VmPQ9dast9Kmn3T8ZmRuDOxzLmNC5jlb/AMwGNWIc8/F55zya1n1Gy39hZ3llcruuLaOSSC6BVA7Dx+HLEh8U/UMv9anV1G9R02i33h93MhaNHWK2gZ3RXkUo0rySIMYjLqIwD67OeWKo3zaLDWou9oYhOW2VLTJ0KlfrF0hL/Tr23cZElvLtJGdsiKXif30lVG/q1R1TkA+WrvdZmsLYaZezscbbeRVz3yyKY4h9+y/jqkKjHKncDi7iqgOkiPNMr7ENTg6ounS6HqUd40BnEayLw1cRk8SN4wdzKezdn4qb9axAoOcV2SgBhO30RHWEvSS5t50tmthDbmEq8gkLEyO+4FVGBhsYpU1/rPS50w2QtWQmGCLiGVSMwtEc7dnYeH2Z76YaRg5z9S3d9iezyU4ZtHkXTLW6NrGsD3jwLdiSQzyOFdjC8BuOGEAUneEB9TXxufOJ9FryCdiRwxZlO/0OfWwui8a2a0M7XtzAAyyiNYyfUhuBQkjLZ5eSp5vZ7x5HYRwAM7EAyzEgEk8yIOZqoWgRhLuAghcXUJ3N61cTKdzc/Wjt+KrVemT/AO8LX70fvVeW+kgvc6jTEEZnMHXsW9c8Q4ru33v1EHzs37Gjfe/UQfOzfsa4fTJ/94Wv3o/eqPTJ/wDeFr96P3qvLeTO5re5628X9ZLu33v1EHzs37Gjfe/UQfOzfsa4fTJ/94Wv3o/eqPTJ/wDeFr96P3qjkzua3uejF/WS7t979RB87N+xo33v1EHzs37GuH0yf/eFr96P3qj0yf8A3ha/ej96o5M7mt7noxf1ku3pOcQrns49t+njo1C2ildZBcGJ1QpmKSIZVmDEHeh71HyUoXECSAq6h1OMq6hlOOYyGGDXN6TWvuaL5mL9WqlGu1jQHSCJ2A6xvTyJXH4Evu+X563/AGNHgS+75fnrf9jXZ6TWvuaL5mL9Wj0mtfc0XzMX6tScqZvP5GpMB/orj8CX3fL89b/saPAl93y/PW/7Guz0mtfc0XzMX6tHpNa+5ovmYv1aXlTN5/K1GArj8CX3fL89b/sarZ1vpt1a9G8y4aH1RyrM382gPMoADjs5eSrP+k1r7mi+Zi/VqsXXLCsesXyooRQ0GFRQqjNrATgAYHMk/HXofo2rNfeDwD8B2AbW7lkXyCKQ601XztXlyGQD5cnNeK6HYYJz2qi4zzyu3PLtHYe2uevbFzSKsv1YdcGnRWVra3O+3a3gig4nDeeKThoEDDwdTIpO3JDLgZ7TVaKTD4TETt9UXPLBAIGe8MfyVkXvdrbYwNdsU9JwGqunqfXFo0KkrcNM2CRHDbz7mx3B5kWMHzMwqvHXb1nS646QgcK3D4jhDbjz5PLKwHjSbN3ZyAJA7yY0a7un5BCPOzAAfjz8lbrCz2Es7bpDyz3KO3C/i5+as67uD9OhUD471I+oIXZVmOrvrX02y06ytpWk4kNvGjbYty7gOeDu5iqz0mSSXWTheWTjx17M8u/yVo3tdzbYxrTs3KOk6JUr+iB6TW+r38M9qWKLZpCd67DxFnuHIxns2ypz9+ph6MdbGj2NpbWqtKRbwQw54Hbw41Qt67vIJ+OqoWbSlW4gw30vMHu83Zzrk4t39R/zp/rVK03M2rQp0TMNT2uGIlSD1+dKm1bVHmtMmBIYY0L+I2ApZsr3eqNJ+KuHqY6RPperWtzccoVMitsO47XjZW8XvwpJx9jTZsQ+0mQYcnJGQeQAA5jzD8dZvQxXKc3BBAzjzHmfsSavNu2mLNxXRCbxvtK3v8dmkfVS/Mf91QF1bata6ZrqXJJ8DgmvNhVCX4Lw3EUHiZyCRJHy7udRjxbv6j/nT/WuqRpuGCB6ryyNw8vPnnHZiqNiuZtnZUYJhwhOe4EhW61Hrm0qSKVFaXLxugzDyyykDPjdmTVToxgD3hSYZbv6j/nT/WlWrV0XY2xYgNsa9CZVdMKb/Q/dYFlpFlNFdFw8l00qiOPeNnCiTmc8jlDyqR/47NJ+ql+Z/wC+qd3rzhvU1yuB9Mo59/ImtHFu/qP+dP8AWs628H6des6oZzUjHiFazrG62NMvdNvraJpOJNbSxpui2ruZTgE7uVJ3U11l6dpelW1tO0nGUzO+yLcuZJ5HXDbufqZSqzxSXJZdy4XcMncvZnn2HyVmeS5DNtXK5ODuUcu7kTR6gYLPxOcTPgjGJlTt6Ifp5Z6xBZx2pcmKeSRhJHs5GPYuOfPmTXr0OvWLa6TaXVtdlwPCjKnDTf7Ii788+WAsdQXYNMWPFXAxy8YHnkeQ+SsXvGVsxDIIGfGA8Ycu8+THyVaNzMNjFn2TKbj9uVMvojOnVtrDWCWpYpCbiRw67MswjVeWeeB+caV/Q+9YdlpFlPBdM4Z7tpVCR7xtaGBOZz25SoFsOKSTKMYGF5g9vNuw8uxa8XrzhvUxlcA53KOfYRzPmFOfc7DYhZ9kyjH7cqwPX/0+sNYsIorZn4sV2k2JI9oKcKaNsHPbmRD8VODqu61NNsNMs7aZpOLDFtbZFuXJdm5Nu58mFVes5Jyw4i4Xnz3Ke7lyB8teJpLkM21cruODuX1uTjtPkxVZ1xsdZhQMwDKcHjFKuR/HZpP1UvzP/fUe9fvWHY6vp8cFszmRLuKYiSPYNixTocHPbukXlVduLd/Uf86f61vsnnLeqLhcH6ZTz7uQNR2Pg/ToVm1BORQ94gqx/Un1lafpemRW1wziVZJnISLcuHkJXnu7cU2vRF9NLTWfADaljwDdB+Imz2XwbZjnz9if5BUJ3T3G47FyvcdyjuGeRPlzWywaYk8VcDAx4ynn8Rq3QudjLZyjbJPeml4wQnj1PdKPSbVoZ2zwZcrIF5kowCyYHeR4kmO8x1ZIddmkfVS/Mf8AdVQL6NiuV9epDL3cxyIz51JHx1xcW7+o/wCdP9abedx07TV4w+CWnUyS7qjhppmHY0sjD3i7EfiNS36HjpzZ6PDeLdFwZpYmXhpv5IjA558ubCoYgYlV3eu2jIBB8bAz2eeue/eYEcJcjHPxlHPPnPkxWjbrELRZuKPR4KKmYcrDde3WPYarpvg9sXMguIZMPHsG1d4PPPb4wqBa4LN7gsOIuF55O5T3cuQPlrvpLrsLbJR4sb5zS1TJVkeqjre063sba0ut8DW8KRcQRtPG+0YBAgUyK3lBXAz2mnhqPXDo0Ski5aVsEhIrefc2O7dLGI1P2xFUsbwiIkr46kkjBAIBPYQx7vNWGu7p+QjI87MoA/Hn5Kwa/Bqm+qX55qcVBClDrw60ZdaK26Lwbff4kO7cxJBUyysORcIW8Uchlu3tLCrisbMod7tukIxn6VR5Fz+Wu2ujsFjZZqeBoVeo7EUUVgnFAOeyr0qNeJj2UvNb2xsIWFvMl01yyvdsP5m8O18Qx8vZw2w+8rUgT0557n/wu3T0xMm28Z/SrhOBB4kn87ExOxi2du0c/VffoQk7o6v88tR2jwu3HPv9XQc6uCbWP62v3i/6VT3o+N13bcyN11BzBwRumTmD3EZ7atodH/8Acz/Pf9teO+k+ONoS6MneS6C5ZwuXd4LH9bX7xf8ASjwWP62v3i/6Vw+k/wD7mf57/to9J/8A3M/z3/bXlcM+88CtzPcu7wWP62v3i/6UeCx/W1+8X/So9627ySy0y/mtL2ZLqC3eWNjIrgGPDtlHTa2UDDn5arfddYE7yFLrpVdPDJpYukezVrcpqLgbbCYW+TsUbtzDHd2V1Ny8Eq150jVZVhoMaOJ2HIAdO9VK9sbSMEK6Xgcf1tfvF/0o8Fj+tr94v+lVC6ndTjm1bo9Kkt8ZLmK9t7y5u5HaGScwuUSymcnIEqDK/a9p7LX+k/8A7mf57/tqpf1wm66raTqpMifdI2lu87pT7PaONBMKUbjTIZPXRg+fGD8o5029b0MwjenjJ3jvUeXzinhWGXPx17bfXBaxXlSLXMAdscBBB8x0Ln6FrqUjIOW5RtRXbrVpwZWUdnrh7x/0OR8VcdfONtsj7LXfQfq0kHsXUU3h7Q4bUUUUVVUiKqx12e3N/wDbwf3S3q09VY67Pbm/+3g/ulvXpfou/wAxqfwH/wBmrGvv9kOvyTSlUAKR3g5z5QcVrrLNkAeTP4zmsV7wuYRTp6teg1zrtwYYCI0jAaa4cEpCrEhfFBy8jYbCDGdp5gAmmtVqfQs2iJo/EUePNdTs578psjUe8ERTj7I+Wsi/Le6x2Y1Ga6BPpsxFaNO9D7pSJiWWeZ+9zKkYz9ikcXIeZiffpldZnUQ1lC9zp0z3CRKXe2mCmfYuSzRPEoEpA58MgHAOCTgU6+vLrC1DStRsbW0wqzpGypw0fwuV5mi4BZ1JUZ4QxHg+qjnzFTRXEtve32csqufIds/rTsVk02kQvn8KzSl0rijS8vFiAES3VwqAdgjEzhAPMFxSbXpVN+NodvVMoqRvQ7aRb3uqiK5gS4i8GmbhzIsibgUw21hjIyefnqOalP0LntyPgs/5Y6o3u4tslQgwYT6Y9pWE/i60f/ddt+Cw/q0Dq60f/ddt+Cw/qUo9Nr57WwvriM7ZILO6mRsBtrxQO6HawwcMoODVYf499V91r+D237KvOrDStlqBcyocukq5AWer3R7abpQ1rJAklsLzU04DorRbIo7sxrwyNu1Sq4HdtFWD1fq90hYZmXTLYERSEEW0QIIRiCDt5EGq89Q961z0jtp2OWmkvpmIAALSWty7HA5DLMeQq1mtfQ8/3GX8xq07+r1qdpptDiPZboVHTAhUJjPIe8PyVb/oF0D0qbTdPkk023eSSxtHd3tomd3e3jZnZiuWZiScny1T+L1o94fkq8fVv7VaZ/8AH2X92irT4V1qlOlTwOI10KjoCZVY/RF6Tb2WqtFbQpbxeCwPw4UWNNzGTLbVGMnA5+arB9GOgGkPaWrvptuzNbQMzNbRFmZokJZiVySSScmoI9FL7ct8Dt/yy1Zzoj9BWfwW3/QpWde9pqtsNnIcZIzz6k9gGIqtfolOhkWmXcE9rCsNtdR7eHEgSOOeHAcBV8VA8bRtgdpWQ1z+ho0W2vtSniurdLiNbCWQJNGsiBxcWqhwrjAYKzDP2RqeOvHoz6aaVcRqu6aEeFQgDLGWEElF+yeIyR/8QVC3oSz/AOK3H/x0v95s6vWW8XV7pfn7Tcp29BTSyHqU+tPoNpdvpV/LDp9vFLHbSMkkdvErowHJlZVyD5xVTaun1x+02pfBJfyVWDqX6IDWdSigkGbeIG4n7RuijKgRZ8skjInlwXI7KdwbtpbZalWq4kA7c9iKrZIATl6nupyTVkW7vGa3sm5xqmBPcr9UpYYihP1ZBJ54AGGqfdE6utIs1CxafDkDG+WJZ5fPmWcFz8tOcBUXuRFXzKqqo+RVAH4qrv1ldfMoleLTmWGFSVFwyLJNKR9OiygpHGeeFYEnkeXZWHVtttvOqcBhu6YA696kaxrU6eu7opYRnSnjsoY3l1izgkaOCOPiwuJN8cmxRxFO0cm8lPn+LrR/91234LD+pVWdV61b6+EIuLrjeDXMV3GWhtlKSw7gp9RhG4eOeTZ7qe/V31xalfajZW0lyGjnuI42UQW67lJ8YZWPI5A8xVqvYLa2g32/dmcylAEqb/4utH/3XbfgsP6teZurvRwrf+F23rT/ALLD5D9hTrFVP1Drx1RJJU8KGFkkTHg9v2KxXHsWewVl2BtrtTjgqHLpKWAnH6Fvo1ZX9vetd2kVyySwBTPEkpUGNyQpccsnyeSlz0RnRHT7LSuLbWUNvL4VAvEhgjjfawkyu5Vzg4HLzVq9CD9D6jjs40H6N6cHopvab+12/wCSStaraKovcMxGJGU5bEwAYFWLQtKmvp4ra3TiTTOEROzJwSSx+lRVBYt3BSatP1f9TWnadGrXES311gFpZ0DxK3khgfxFUH6ZgW847Ay/Qk9HVxd6i4y24WcRI9aAqSzsPLu3QrkfUOO+pS62+lPpPp8t0uOINscQb1plfO3IzzCqGfHfsNS3/elaraOS0DA0MbT9E2kwRJS1edGbKaMpJZwyR9m17eFl+9KVC3XJ1HRxRy3mlrs4KPLNZ7mdTGil2e2JywcD/wAnsP0uMYLQ6EdeLRN/Obq4uLxrkFo2NsbM2JVA7BBiWO6EnEI4YC4Cg99WaiMhCkEEHBBHYQeYI82KpCraLrqNJJM/vZHflHUpC0OCpnb9Cr2T0uCopOrcTwX1RPH4TBH38/U/GYdtWs0Tq10tbeHi6ZbNIsMSyMbeFiZAihyW2+MS2edVb66+jI0zVLuFECxS4uI1AGBHMCxQDHrUkEiAeRBVs+iol8Ds8dnglv8AoUrW4RWzFRpVGEgOk5GNijpAAkKEOvPqpkjvuJp1ukdu1jNdSRptiji8C2CYqB4oLRyxMEHaVlPlrm9Dt0HW4uIp722juLS9srxrdZgkoMlpe2tvKxjYeIys5UE9zGpU67ei8mqaVPGE3zQfzqEYBbiwhiVUfVPEZY/64qHfQoK3ppcle06dJz8v85tMc++n0Lx467HkEy3LXONmfUkLQHqXOtfoJpltpOozRadbxSQ20jLJHbxK6MOxkZVyDnvFQHoPVhfXWowac22KSa2jvS+4SLHZuR6qQp8Z+YGzlzKjI7asb1xCT0n1LPZ4HLn5KjH0JOnELqM6gb91vCOQGFxJI+PtiU+8FQXXeJo2CpVzJBjMzqle0FwCl7oj1a6ZpkaCG0R37DcTok1w57yZHXxATz2pgeauzpB0C02/VluLGJ8eLvWNY5Vzy8SaLEi9n0p7qafXt0outI0154W2PJNHAJAATEHV2ZxkYBPD2ZPZv8tV76Kdcep2soYXjzLuy0dzI9xG4+p9Vbcg+5kdlZlls9otQNdrjP8AFtjq3/RSwBkujpD1Y3q6p6WwxgyTRy3durTJ41kHn4TO/YJNkLZU+Sk25tbj0mtpjaW62jXrol8kajUJJhHKxt5pd+424XcwUr2onPsy3+kU/hNzczbABPcTT7eTAGWRpMZx4xG7t81c6rjnjn2Z769FozxbcWsBUjrklLowf53afCrb9MlXGMi+UfKKplpEyxzwu4yiTRO4xnKLIrOMHt8UHlU3x9ZejNdJELRRbMuTdvHt4bYclWgEW7GVQblJ9f3YrzL0g3PXt9Sk6ixzg0OnCAd28jPo1K27prNpB2IxMKXeIPKPlFDOuO0fKKaWm6po1ypaERyqDgmO2lcA4BwdsPI4IOD5a6d+mfWV/A5/2NeRvu8sdhc14PSz9VvCpO5NLp7aidLqA4ImhmixntEkbJj/AJqq10X1K6ibRbhbizslaK7tUn2AvGiZVnv43O0s5Hit399Wh6RQWDzhUhXLZIBt3jztGT6+MDkKrxZdXl+8hFto0Uy2upzXXhM88IjuLWCQ4tJYGbc0LFe7t3AY769Z4FuZxTqLjExGIAahwMAnPZv6lj24GcS0dX+tR2x0RH1njGw6RwRppi2xVFsmm33N+l4vJklLhBGxz47kchX0jt9Nij9bGPfxk/GTzNUi6ouqzWek+kXRtptP07TNYu/DSkUFw1zby28+0R26hQsESyQEbQ3vYBq88QIA3HLYGSOQJxzIHkzXohsFAuD3MBOeZAnPM7N6y+MdpK9UUVhjirRIAkpiaXTLHFXy7P8AE4/xpDru1y7E0rMPWjxR7w7/AJcn464a+YeE9qZabyrVaehOXZlPaussbC2k0FZooorBVlFVY67Pbm/+3g/ulvVp6qx12e3N/wDbwf3S3r0v0Xf5lU/gP/s1Y19/sh1+SaToAB5Tg+bByOzy1maIDOO5tpz3kd48g5V5aTIHLmOWc9w7sVmWXd3Yydx78t3nze9XvC5da6nr0JXScbrrTW7ybmPzEKiyg++piP8AUbyioGRCxAUFmJACgZLMTgADvJOBVyuqHoFDoVoECg3cwR7mftZ5AOUat9ZjyVA989pNcxwptFNlm4t2p07NqnoDOU577SLeeWCeWBJJrUu0ErorPAZV2SNExGULKMEimZ119P49GtXVH/nkyMI1B5xKcqbhvIF54z2keQHD7guUkLhHDGNtjhWBMb7VfY4B8Vtjo2D3MKq56K3obPBeJeIS1nenEjFiTDcIoHCyTnbJGuV8myQcgFFcZdNnbaLS2nUPUPGFZJgSolil3gN9UN3y8x+I17rtTSJ/BjdiFvBVlEBmC+piUqWCZ+1Hb2DKjtIrir1emWxDTpkqJRUp+hc9uR8Fn/LHUWVKfoXPbkfBZ/yx1n3z/g6nUnUveCsz0s0w3tleWqsFNza3FuGOSFM0LxBiBzIBbPLyVXFvQuzAE+HR8gT6247h9vVmNWvktYZp5M8OCKSZ8DJ2RIXfA7ztU8qj6Trq0ggjfLzBHsB7xj6qvOrrtVrogigMjrlKtkSoH9DagXXNPA7AtyBzzy8CuO89tW31r6Hn+4y/mNVSvQ5DGu2A8guv7lcVbXWvoef7jL+Y1aXCb/Gs6h8ymUfdVCIvWj3h+Srx9W/tVpn/AMfZf3aKqORetHvD8lXj6t/arTP/AI+y/u0VaXC/9lT7fkmUNqrf6KX25b4Hb/llqznRH6Cs/gtv+hSqx+il9uW+B2/5Zas50R+grP4Lb/oUrLvn/AWbq+iez3iuyzvEkaVVPjQSCJx9S5jjmA+OOWNv61Qr1X9GvSrpVqMCjbC9hLcQjsHAnurVgqj6lHEkX/Cpx6V0lEHSi+sGOFura1lUZ/8APig7h3bolfn/AOmlPq50hTeQ3gHqiQT2rHywzPDMM+XbJAuB/wCq1ZdOq6yhzDo9o+v6KQiUj9cftNqXwSX8lRz6EPTlW2v7nHjSXEdvn7GCIS4Hkybn8QqRuuP2m1L4JL+SmJ6EecHTruP6Zb4uR5BJbwKPxxNVyzOIuurHOCYfeCdXogdaNjot46nDSKsGfsZWAkHxxCRfjqlSWRmPEmJ8bmEBK4B+qI57vMKuL6J3TzPoc+BngzWszDtyizorfFtc/jqptdDwTosNnc7bKZWdGQXEmlxDOFIyCD47nIPvty+KnZ1L6dGmt6Yyg5F3HjLse0MOwnHYTSBTr6n/AG5034XH/jXRW5g5PUy2H5KFrjIV1RXz71rSojcXBIOTPMT47dpkYnvr6CCqEav7PP8Adpf0jVyHA8AuqT0eamrEjRWB9CD9D6j93g/RvTg9FN7Tf2u3/JJSB6EH6H1H7vB+jel/0U3tN/a7f8klVbR/nQ/iHknD3EpehyteHoVme+RrmQ+fdczBf+RVpjejOuj4Hp9uDjj3Mrcu4RRqCff2yt8tSB6H6QNoVgR3LOvxpczqfyVHvoxoCY9Lk7lku0+N1tyPxRtUNkGO9zi5zvNKTDFDVtbXSaDPHDcxR2PpksrWZdfDJLxbeECcK0e8wGNY0LBsZVuVW+6rLw3Gk6bKTkvZW2Se0kRKpJ85xmqbQ3dmLF4zAxvzch1uuKwiS1EagwmHdhnMoZt5HY1XM6urq09LbLwWFre2a1iMMDyNI8UbKGRWkZiXIB7STW5wtog0mHTPyTKLpUIei+tAt1YzY5yW00ZPlEUgZR8XGb5an7oj9BWfwW3/AEKVDXoltTsUvtIN7A1zaxx3rTQRytFJIHVEj2yIwKYlCNyI9aRUwdELpBY2YJ5i1tsnyjgp8lYt4Mm77OCRli+ae0e0UoWd4krSqpy0EgicfUuY45gPjjljb+tUL9V3Rr0q6U6lbqu2F7CW4hHYOBPdWrKqj6lHEkX/AAqdnR/pAidItUs9jss8FhKrqCYoXS3kzxSBhWlRcAnt4OKeFzpKm8hvAPVEgntW88UzxTDPl2yQLgf+q1UA42NrqcyHt/4TyJzSN1ze0up/BJfyVDPoTukCQ3N1ZO2DcrHJHk8jJFxAUH2TIWP/AAqmbrm9pdT+CS/kqlC372k0c6MV2kDcpKsjK26N1K81IbPjDv21s3LZeU3fVp7yo3GHhXu6YdHLbVrSayu04kE6gMAcMpBDJIjfSujqrA+VRVQetbqgn0RtxTfalsR3kK7QCfWpOg5Rye/yPcc5Am7qo664btUg1BhFNyVbrksMh7PVgOUDn6r1vb63kKlzVYIpYpI5kWSKRGR0cBkdGGCrA8iCKz7FbbRddXA8S06jzHSnubiVBoQVVQxywABPlPlrIBzk9mOzvzypc6f6LHY6jdQQtvt0ZWiJO5lWRQ4Rz3sgOM942ntNKel9HLeXbIJi8ZUnYdquOXIkq3LHbjFekU6wqMDm6EKFjIzK4V0PfZpOg8cb2Yc/GQOVB5thdqqTy7aQamrSuilyBFClu4UrhWdSEI2l/GkxtBI8vlrj13qynkYu9u4OAMwtE4OOw7VzTDUZpKsCk/WCo86I9KrrS5FkglbYrb2tzLItvK2MeqRo2G7F59vIVYGx63dIkwDctET3S28w7s82RCo7+091RCegfBYmZZAmCNskbRkHIwd3LuB5Y76bnSWW2wkcCjKY3SAKNwCgYJHNmznOR3Vzd98E7FepD6khw2tIE9eRlWKNrqUch4qyPSHTku7ixdWyrrMysOYZTErKR5iCDWeqfRo+NIj8xxZxjzC4cH/Cop9D1qzPeCB2eQ7HkUvIzRxokZQqisfELF19b9SvkqXOiF0Le4RycK1xdIT5Abh8H4iBXAWOh6lvRlCq6WtLc9MnYs+yVovdx9EuAzXj0GUSwaTe2AGDpWt6npxz2kRSrKD2/wDrEZPkNTjUEdQ9/FadIOmNhuVU9MLPUUO7kzajbGWc9mBhhGc/Z1OyMCMjmPKK9nDgdFhFpGq57i/ij5s4HxjPyd9NrXNcMoKR8kPa3ew8gHcKQ6zXgV9ekC2W6maVMCm06wZJ6J/RdFQu1lM4jmiiiiuAWksVmiuPVdShtU4kzhFzgEgkknuVVGScDPLyVLRovqvDKYJJ0AElNc4ASV11Vnrs9ub/AO3g/ulvVk9G162uyVhl3MoyVKujYyBkB1GRkjs8oqtnXZ7c3/28H90t69O9G9lq2e9KjKzS04DkRB1bvWLfD2uogtM5+SbUZGY+XPb+t+T/ABrxvwijnzDcvpTzPM+cdvxVqZMAHPM4wPMe/P8AhWeFz255gNnl2FQSR5+yvcFzSWOrsL6Z6bu9b4fZls9m0XEZOfNirx18/jOYsSA4KMrZBwRhgSQR2EDnV0uqzptDrVokisPCEVRPEMAq+McRV+tOfGBHlI7Qa4bhfQeXMqDQK3Q0UD9W3T+XSNe1C3vSVSW8mjuN+RtYysY7oZ7V8bduHashPPlVkulOhwanay2lwu6GZcHaRuUghkkjYjAdWCsD5QK49d6E6bfzLcXVjDPOgCiWSJS5QElUZsZdBk+K2RzNLfFjQpHuVWYHZHlQWVAN2xO0hQV7OzIrmrXa2VXNqUgQ4DPrG0KWEjahoFhFp0llJGkWnrAyMhO1EiHjFy5OQ4bx+Iee7nnNUn1aCOKaVIXMsSyOscjLsaSMMdjsn0rFcHb56th6Ibo9c3+lyG0LNLbZn8HQti5RBl49i+vlUDeo581x2nIqBZliil/XHJODntJI5+8RXW8E8Ra95dM6jp39qhrgQFuqU/Que3I+Cz/ljqLKlP0LntyPgs/5Y63r5/wdTqUNL3grF9Z2fSnVMdvpbfY9/wAFlxVDs3Xm+/8A/wCFXy6y/arU/wD46+/ustUfrnOCVJr6T53hTVXkaKQfQ6H/AMesPeuv7lcVbjUYTJFIg7XjdR77KQPxmqPdCNdOmX1pdgZ4MykryBZCGDoCewshZc/ZVdvQ9WhvYUuLeQSRSDKsv41YdquDyKnmMGqfCum5tpbUjKB4FOo+6qFspQEMNpXIYEYKleTAg9hBBGD5KvT0Htmh0+wicYaOytY2B7QyQRqQfOCDXNc9BtLluDdPYQtcF+IZGhUkyA54jDGGfPPcedLeoXkdvG8sriOONSzO5CqqjtJJqnfN8NvBrGMaQR/WSWmzCqreikP/AIy3wO3/ACy1Zzoj9BWfwW3/AEKVTjrV6SDVtSvLpchGcRoD2iKONVjyPpSVAYjysauP0R+grP4Lb/oUq1ftMssVnadY8gkp+8VWPr+1R7DpOt5EcPEtnz7sqium77HcCuPs6tJouox3cENxEcxzxpKvl2uoYA+RhnBHmNVR9E/Fv1q5U8swW3PyHhDB+I4PxVKHoTOlPhenyWch9VtHJA7+HITuUeXbMH+cWi9rFisNGsNgEpzXSSE/euP2m1L4JL+SoG9Cz0lW11KWzkOEvYk2k/X4i5jGfOpkX32Sp564/abUvgkv5KpO9y1u8c6Eq0TA7lJBUEghgRzBVwpz3c6luKy8osFWmdpTXuhwV+tY0+O7gmt5l3RTxvE69mUkUq2D3HB7apb1h9DbnRLloLhTwyx4NxtxFcJ2qyt2CTb2x9oPmwTZHqf61LfV4o4bh1ivQAuCQqXJx6+I9nEPaY+3txy7JHurdJVKSIJEPajqGU++rDBrOu68a101XMe2QdR5hK9geqB5p2dT/tzpvwuP/Gpm9FFpdva6XbiCCOAG/jyIYkiB/m9z2iNRmoZ6n/bnTfhcf+NdrTt4tthqVQIycPBV8OFwCuqKoRq/s8/3aX9I1X3FUI1f2ef7tL+kauf4He9U7PNS19ArBehB+h9R+7wfo3pf9FN7Tf2u3/JJSB6EH6H1H7vB+jel/wBFN7Tf2u3/ACSVUtH+dD+IeSc33Fx+hQ1gTaZLbE+PaXMnLvEU5MiH43EvyClP0S/R1r/SWeNS0lnKt1tUZJjVXjmx5ljkMn/CqvXU102bQ9S4jZaCdQsqDtZDgMUBOOIhVHHvkcs1cnSdRhu4kngkEsUgyrocg+UeVWB5FTzGCDUd60n2G38e0ZTP1CVvtNVEdH0qS8mit4F3zTyLEi8+bOcAnHYgGWJ7gpNXl0nRYraGGBPWQRRxL3eLGgRfxKK1aR0VsLOVp7eyhgmcEGWKCNHIY5YBlXIBPMgduKSus7pzBoluzuwa4dTwYM83bsDuAcrCp5lvNgcyKZe16uvN7GU2kAfMop08Krv6J3UEn1cwoci0tkhOOze5aVvj8cL/AFDVk+jtsosbVgMnwS3/AEKVSK8v3u5bi5kYu80jsWPaxySzHHeZGc1eXo/7X2nPH81t/wBClXL+oGhZKFPdPkkYZcVBPWHqdxYavqV3b6jFZCODSGks5nRJNSMZd4I7dWG5zExkLBMcpxmrC6LqMd3BDcRHMc8aSr5drqGAPkYZwR5jVZevaKB73V1ls5LmU2mn8G7jeZY9PfYxaSZY/EcSeIAJfrRxT99Cd0p8LsHs3Pqlo5ZR/wCnITuXz7Zg+fui0297HisNGsNgEpzXZkJ99c3tLqfwSX8lUxhs3mDhYzIEjZ3CoX2xLgO7hR4qDIyx7M1c7rm9pdT+CS/kqAfQte3P9kn/ADoqtcHbQbPYatWJgzHYo6glwChcCS18aM74hzxnLKP8y1Yq96UXqdGLRUZ47gxI+9SVljtlnMkZz2hfBVQfampqn6FaY0hmOnW5mzu4htYC5cdjk7ObA/THyCor624AVuRJIIlaNg0rjKop5EkZ58uWPPUNS9aNtqswsiCCZUjQRqoO9LIHteMjiMwRMZFIA3GMb3bLSYRQvf5qTerTW9Th1iGK002G7NwrS2r3QmiVkgieSSa2ulcRlSVdN+GGdorjt7aGaW3aYkRJMjOFwQ0ZIWVXQjEimMsNh7asx0l6MoLWzv8ASEFvPYwLJAsduJZZ9PMbzPpkKTNthacsg4hBK119aqGgDf3KzZ6JecQ2JvaV1xXwd47vQmXguUmew1Ky1FbfY+yZrhIGzbpEfXFz4u1s4xUka70usLGzN/PdILMKj+ERkzoySSJEjx+DhmkQySINyA9tVq0PQ08K1jwax1OHU9astQtEh1OyigtRJeNx52W8EgAwkb4LAZB7Tms9Ieg+p6VLDHc6lGqQ6I9tp95eyQafBaXk7wxT2cVwjEtLHaGdxKcZ7OXbVV1npuI2K620VGgmJVh9F6ydGuyBBqts7N2J4VGkh96ORg5PxVBPW/0KGlTrJbjNjcY4TBtwRxu3QBnmaSUqqh+I3L1THdXuz6NWnpN4HqEFtqHSHU11IWUtulrM8kkUKCI+G2oCLsVllDTMO/yYrHQ/osOjVlPpV9G5k1WOyuzd7OBaJMhGdMWcyeq3iMsrbY+1SxwBmn0WBjvZPZv6VHXcXs9odvkur0P15FDqDGRtvqMhBIJG1Ed37B3BRyqT+jmpreSQCI743nnlDAEAxcWSTPMZAK47fqhUJ6/YWdorjm0jRsqoSrKhYErIQQCMEdoJ7eype6jEjHFTiKZbcGDh71Mg8cliY87h4qLz85rlL+uFla2sr5kuiRsAbP1TrDWywLXZsbbppcJ2Jf6DFMeXrpra64K8+wkRK/LzirD9GZ14KguCefLI8UZOB8n5ag7ph0cu5Nf0PULePdBbxajBdvviXZHLCPB/Fdt8mZmY+IDjZzxUgGoOEHCoXO6lhaHFwzExEZKybJxwLZjOUUUUV4KtZJ15rUETlHfBXG4hHZY93ZxHVdqZ89KANN2440DSW6RrILt53R2faF3rmQSrtywXPd2jApcsLfhRxx5zw0RMntOxQufxVetNCmxgLTr0zPT0ZqNpJK1ao7qq7SQC4DsicR0TDc0Tadx3BB2HkxOOVMXrMd2itC+d2657RtYqGQRsyfSsU2kjznsp9apG7Ku0EgOC6I/DZ02sNqvkYO4q3aM7SO+mL1mRssVmHOWBue1t5ClkKKzHmzKhVd3fiuu4EYOX0NJl3X7ru3y06VSt88W5JfVt9HR/aS/ozUZddntzf/bwf3S3qTerf6Oi+1l/Rmoa6/teSDXdRjKElWtuYIx41lbN3+Zq9To//ZHf/j/rWJVE2UfxeSSt4Cgdpznn3e9z555fIK9cUbt3PnuyMDkWBGBz5jJ7abP8KY/rbfKtH8KY/rbfKtdniCy8KXmUEEHmCCCPKDyIrz0f6RXGmSrtlaJ09jmjYoxXzMp8nIr/AIUh/wAKY/rbfKteJukkTja0JYHuO0j8dQWiiyq3C5SMcWqZV69NV4e3w3+twLXfjyZ4Hk7zz89MxusO5a8S6NxI1wucTl2Z1yGAUMT4q4LDaOWCRimF6ZWufYH97iHHyb66PT+Dbs4B2H6XxQCe3Pv576zqd00GzAHcpTVUq/xxal/vCX78f6U07i747vL3yMzkgAZZiSxwBgZbPIU0vTe29zn5V/1rfD0kiQBViYAdgBXvOfL5TVqy2OnZ3EtgTuUb3SE46UNA6RS6XLx4JTDIVMYdDhsNgkZPcdtM/wDhTH9bb5VrXP0ihkGGhLAHPMr2/LVmsxtRhadqa3IqTr3rY1CeN4ZL2R45UeJkZgVdJFKMpGOwqxHx01aaq6xbDn4OeXPtH+tdX8KY/rbfKtQWSzMs4IbGe5OqOxJau4y6kA4bkQfIwOR8WRSp0P6fXWnseDO9vJ2MqPgMR2b4zlJMDsLA00f4Ux/W2+Va03OvwSevgLY78rke8wORTrVZqdcQ5DHFqmtevTVtuPDcnHrzb2e73+UG38VM/ph1j3l/gXFzJcHPioSAm7mAVhiAjDczzUVHfpjbfWX+dP61dFtrsEfrICD2ZyC2PJuJziqNK6aDHSAB1BSGqnBZxkL43rmJZvfbu+IYHxU87frd1CNVRL6RURVVVDjCqoAUDl2AACoz/hTH9bb5Vrk9N7b3Of8Al/1q3arJTrgAxko2OiZT513XpdSlNxNIZZCFQuxyxCDABx5BgVr6NdJJ9IneW3maAyoRvQ4Pau9feJVG+KmjB0jhQYWEqM5wCvb8tE/SGGQYaEsAc8yvb8tPdZqbqXFHRAdDpUl6l1qX91E8Et7JJHKpjZGYFWDcsEY7Ka7KCCCMgjBB7we0U111m2BBFucg57V7R2d9dP8ACmP623yrSWWzU6AIbGaHnEu5JpLM/VQ+Xt2jyOPJ9lT80Hre1G3QLFfyqo7A5ScKPIoukYKvmFRr/CmP623yrXJNq9sxybc5+xIT5djDNQ2iwUquoHaE5tQjVSb0q6wr3V0WG6umuArCQKywxqGAK7tlvEq7trMMkd5pF0zU3s5UuI2KPEwdXHIq3YCPOCaZ1rrVvGcrAwPZktuPys3Kt03SSJwVaJiD2gle458vlFS0bMynSNMRB801zpdKlIdcepf7wl+/H+lNKWXeS/aXJbPlLHJP46afpvbe5z8q/wCtdK9J4wABEwAGO1ewfHSWSyU7OSWxnuQ92JPvo503udJV47e4aDikOwjYDdgFVJyO7nW7XusO81OLwee6eZCyvsdgRuTOD2doBPy1HE+uwSHLQFjjGSV7OZx2+UmsQ65bodywEEd4K9/x1GbDTNXjcp1Sh/swl++gLgFTh1O5T5+9T5iP8KWehvWDd6cx4Fw9s/0yqRtJ5AF4nBjkIHYWBpn/AMKY/rbfKtabnXoJPXwFvPlQR7zA5HxVNarNTriHJGOLVM9315aqybfDivLmUhtVZuX1Qgyvvrio31vXp9Qkb1RpHc5kmkZpG8mXdzlmwMAHyeSmuNStvrLnzGQ4/O511x9JokGFhKgdw2gfiqrZ7so0jIAHUFIahdkE4YogqhR2AYH/APneadi9bmoIiot9IEVVVVDjCqoAVRy7AAPkrm/gVfbVdRE+5FbaJXRwSAdpV4tvLOM57qbeo9E7uEHOluwHfE0UufeETk1BWtVhtZDeMaY2EjzV31XaqWZYezNPPTOkF1qFtqs7amkO6K0Sa3ndBNqSo0ojjhBGXMOSTt7pBTa6NdJZ9Inkkt5mhMqY3ocHtXiJ7xKo1Jmma7a2FvdxXelTceVYhbTNJLbi0dS/GdouS3HEUoMP2bOXbSHP0ihkADQlgOYyV5H5a0DQpVKPF5QqTqb2OlwIUmal1pX93E9vLeySRzKY2RmBVg/LBGKbUGrtZOkqO0b7sK6OyOpwTlXQ7lbl2imoms2ykEW5BBBByvIjmD2+Wt8nSaJgQ0RIPaDtIPvg02jYqdOm5giCmOfJBUxWHXhqqLt8OLDGBxIbZ2H9dodzHzsTUd9Y3Ti61Bg09w07dwO0Lu8qxRKIw3nApqtqVsf/ACXHvSED5N3KsrqkHrUgIZuQOQWOTyG5jntqtRuuix+JoE9ATzVTv6sdRiiuIHvYvCIYnBkj2xsroysFQq42sqtgnd24NXO0+aKSON4WV4WVSjRkGNkxhShHIrjHZXz6kvnjOeA4wc+tyOXPyYNTN1PdcNzp4jtruItZhyzPgy3CKybUWDNyEWNWVMpjkC2BnkbFqsT6mbBortitjaeT1afNJnSDo/Z6igjvLWK6RSWVbiGOYIxGCycRTsbHLK1joxr0GpQRXFu+5JY1kCnAkVWGQJI85RvMaVDWMZaelbohw6EgdEehmn6RxvALRLXwgo0oi37XMQcR+KzELtDvyXHrjUceioMbQafE6hm8JknTIyQYI1XcPeM6/iqWdX1SG0i400gRMhQSR6o5ztjjyfHkYggKO2on1u4u+k8nCWE2unRSDLSxjwiYo0bHAdd8BKMR4uRlO+mVLdSsv99XdAG8/JVrQAWYG6lRF0e0gzsHYhIVZtznBHqSrK6bc55oc589Ny9uTLK83rXeRpcg81ZmLcj2gjPb5qlHrYt4tNgjt7dQqkSRE4ALl40jeSQgeNI0akE1E5NbnBi0m3sdayPZOTeoant8lz9uHFkMGu1Td6G/W9Su7ySKW7kltILdnZJm43qjsqQqJJQZEGBI2FIHiVPtRP6GXRjbWVxJJG0c1xOCQ6FH4EW6KIENz9lF0eePXfGZZrwT0hW1tpvipgAhsNy2wMz3rpLrY5tnGLUoooorh1pJK1L6Ks/7R+jFF1cTSTNDCyx8NEd3dDIWMhbYqqGAC4Q5bzijUvoqz/tH6MVp6TWoLQOCyO00cBeN2jYxPuLISh5jIzzrUoBpLAdxjKdp2KJ21dujXbTRkuAHR5InCklS8bFSUzz2nGeflrR0k0KK/RUkJUoSyuuMqSMEYIwQeXLzCu+ztkhRURdqKMADPlySSeZJJJyfLW6oKdsfZ7Rx1nOEgyI2JSwObhcm70b6JQ2UhlDtI+0qC20BQe3AUdp7MmqmeiQ0+Z+kOpMsMjqWtcMkUjKcWFoDhlXB5gj4qupXH4ezSmNE3CMgSOX27Cyh1wu3x8qw7D311FycLbVZra+11hxji3DmcMCQd3Rp0qlabCx9MMblnK+evpXce55fmJf1KPSu49zy/MS/qV9AE1pt7botsSz+D8XiZJk3BV9T2ZALMOea2XWsbGfxMxRMElk34KOwUqFj25ceOnMH6Y+Suw/tGrzHJv5/016FQ9UDn+C+ffpXce55fmJf1KPSu49zy/MS/qV9CpL9uLwo037dhkYvs4ayesIBU8QkK5wMetHlrTc6xsW4bZnweRI8b8b94iOc7fFxxezn2U1vpIrH/th+fflu6UeqBzvBfPv0ruPc8vzEv6lHpXce55fmJf1K+jGT5aTrHVDIjSlNsGziJJv3M6gEkmPblOQpjPSbUcCRZ9P3/wDalNzgfF4L58eldx7nl+Yl/Uo9K7j3PL8xL+pX0Gs9VLttZNm5DLH4+/iRDb4x8UcM+Ovi+esWmr8TwXxMeExs/rs7NqK+PW+NndjPLsqQ+kisP+2/n6+joKT1QOd4L59eldx7nl+Yl/Uo9K7j3PL8xL+pX0A0/W2k2F4uHHJI8UbiTeWkRnGCgQbQRG5z5hXXbX7SSMqJmNGZGkL4IkXtURlckcx42e+h/pIrNmbOPz/ogXQD8fgvnp6V3HueX5iX9Sj0ruPc8vzEv6lfQbRtSkuMsYtkfjhX4u8sUkMeCmwbfWsc+aujUbzgqDjczsERc43SNnapbHig47aY70l1Q/BycT/H+iPU4icXgvnj6V3HueX5iX9Sj0ruPc8vzEv6lfQi41B0WMGP1eUkLFxPFyoLMDLswMRgtnHditUmuKqRu3ihp/B33PtWJ1WQudxGGVWjIzyzmnj0j1nCRZv5/wBOhHqgc/wXz89K7j3PL8xL+pR6V3HueX5iX9SvoPLq4DzIPG4EPFYhx67L5jIA8VgEB5/VDlXnStUeUoskfCaSPioBJxAyeLkkhRtI3ry89H9o9cCeTfz9u7cj1QOd4L59eldx7nl+Yl/Uo9K7j3PL8xL+pX0DstZ4otTsx4UHPr88PYjP9T42cY7u2vWn6nJJJMjRbBDjLCXfksquo27BjKNnPxUH0j1hM2cZfv8ATG7ej1QOd4L59eldx7nl+Yl/Uo9K7j3PL8xL+pX0Bs9Yke3e4eHYiwmZAJt5kARnwfEGzkBz59tbtN1N5GCSR8J2j4qgScQNHlVzuCjBywGKHekes0EmzDL9/wDRHqgc/wAF8+PSu49zy/MS/qUeldx7nl+Yl/Ur6H6je8FQcbmZhGi5wGkbO1S2PFBx21ouNQdFjBj9XlJCxcTxcqCzAy7MDEYLZx3YpjfSXVcARZ9f3/006UG5xzvBfPf0ruPc8vzEv6lHpXce55fmJf1K+hgvm4sUTLhpInkOHyEKGMFezxub+u81cVjrUslu9w0GxFhaVcTby+1WbafUxs9b2+enj0kViJFnH5xtyGzoR6oHO8FQD0ruPc8vzEv6lHpXce55fmJf1K+hFtqyyOirzV4Gn3q4YDa6oU5DmQSef2JrXHqzmGWfh4iWJpYzxMmVQrPzXZ6kcAdue2j+0ev+G/n35bkeqBz/AAXz79K7j3PL8xL+pR6V3HueX5iX9SvobplzLIu6SPhZwQBJxMqRnJwox71dW4+WoX+k97DBs4/P+icLmn4vBfOj0ruPc8vzEv6lHpXce55fmJf1K+jG4+WjcfLTP7Unfh/5/wDaj1L+94L5z+ldx7nl+Yl/Uo9K7j3PL8xL+pX0Y3Hy0bj5aP7Unfh/5/8Aaj1L+94L5znS7j3PL8xL+pW3QtGee4iikR4980EYDIyFuJIEPrhnlkdnlq/nSDX47PAcMSylhsA5AcuZZh3+SoB6YX66hq+m7Q2I5LqVt+OxIlZexj9Oq/KK6a6+FNrttM1XWfCyHHFinQHoG5MpXextdrQ6TIyhJvXL0vuNL8FFsyq0pmZgyK4KpwwowRkc2PMeSmjp/XRdL7NbRSedDJEfxlh8grl9EHeb7+OPPKK2QY8jO7ufjKlPkrj6qeq286SLdm0kij8E4APhBlRZDNxTtV4omwyiLOCPp1qxY7DYad3tq2prQIkuOXvHLPXaAuitVsqMqkNOSetl1z2jjE1tIme0IY5l/wCYrkfFXX/CXo5e+yrEGPfNamNvjkWPA+Woc6a9G59IvJrG5KGeAoH4TF4/VIklXaxUE+JIvd5aT7WxllDtHE8ixgF2jjd1jDZ2lygwgO1u3yGrQuGxloqUXOaDmC12UHTWVGLxf8QB7FOQ6DaDe+wOoJ9z3YYj+pIzY97FcGodSsR9hvHTzSxLJ+NGXFQmCDzFTD6HMSO12zOxRFijVSzFAXLsSFJwDhB8tV7dZ7XYaLqzLQSBscAejUp1IWa0uwupDsTaueruWOSaMSCTguELK2zcTFHL4qsnYBIF5ntBrzbdG5rbJNu5P1QCyEjlyAhY8sgHsqSbaTeZZPrlxO4+04zrH/8AWqVuqKnwptNB8FrTHRt2q67gtY6rQcx1H6qLpXCevyhP1wGM/I4FbIHXKkjeoYEqG27gCCVDAeKSMjPnqTGGeR5jyVwz6NbOctAhJ+mCKG++UZrZo8OWn9pS7isytwKH/Tqd4Us9Cuoboz0htrfVLEz2cu5HZYpklNvdJskaJ3urYtI0TkDcDg47SKUesPq4u9Lt2nbpQ1tboAp49qwZjIwQBmtpwrZLKvKPllvLyhHQOnF30XupDpriNZYEaWKffPC3jybDteTKMAr81I9dSD036cXXSCfwu7mWUjcI1jJ4EAYIrpApclFYxqSMnnmuhslKnbWtrxkcxIErlrdSdYqrqM5jdotfRrpPcWK7YghUsshjljDrvUDDeKQcjAGQakaHr0mRAq2EQOME8WQc8cyBt+OofrVNPtOMZpLz4OXZayH2mkD3j5KnStlZmTXJf6VdJbjUn3zEAAkqiLhVJ5E5PjEkAdp97FbOrzRvTDUbO1Iysk6lwRkGGLM0wPvxRuPjFOHot0Ut5jbFkd95Vn3YC+OibUCqeaB8nPbzqfOqjo7Bp9s4iiWNmmlVmA8dxHNMIw7nxn2BmA3HkDiuU4R8LLNc1idQs1IgkEN0AEyJ7NelXrLYH2ipieetOu2tkjBCKFycnHaTgAZJ5nAAHxVurFFfN1So57i5xkldaAAICKKzSH6evs4/A/mufZOIOJs3beKItvrM88ZzjnT6VB9T3UhcAt+pfRVn/aP0YrPSD/ZvhcP+asan9FWf9o/RCs9IP9m+Fw/5quUvep9R+ZTDoUqUUUVnFSopLt1aK4lJRmW4eNg6AFYwkSRni7iCCSp9bnupToqSlVwSImck0iU3F0x1MkqoeKb3IyxKmFpE3NwydnrN3jYzWrVdGMnhb7GMjTRGPDuAygQAnYG2tjD82HdTorNXBeLwZ/rZl4eKbxYSXfqzTJw0ZWVlLTEARNESDJGcNlnKjAyOWTgikrVdGMnhb7GMhmiMeHcBlCwAnYG2tjD82HdTorNMp25zIwj+plBZKM86RNKt3FsbUoVZIWj4hxwXZlIyjZ3FRnvApbrFQU65YCI3HtCcWykTTrd2kjJQoILdrcl8DiMeHh49pOY/UzzbB5jlXjSbOQNaqyFfBI2jZm9bKWRUBhIOWXKk+NjtFLxoqwbe4yIH9T9Sm8WE29K014hA4RhI1xKJdxLARF52BCMdqHlF4yAHn5zSjCrG4LIjRoNwkL4CzdvDaIAnmGySTgnI7aU6zSPtrnkkjo8Z8NiMCb/RW14ZYNDIknqxMjMeCwaYsoReKQG2lee0djfGoa3AzrGyjdwpkmKj1zKm7KoOwuc8gce/XfRTH2tzqvGQlwZQkq/3v4POI29SZ2aHC8Yh42iAVd2wkFgxyewH3q5PS5ykO5Mhr57hlIB2RyLOwEgPLcN6qQMjPeacFFPbbS1sAf1n8pKQsSHJpxR5xGh2NZCNTkktJmbkWY5ZsMvM+UV2aDpyW8aYUh9ibtzM5BCjIG9jtGe5eXKlGsU2pbHvbh6u2MkoYAm/pFjIptY2QjwQOGc+sk3xsg4J7WwWHrgK7rKBhLeErgSNGVP1WLdFOPeYEUp0UPtjnEmNRHji+aQMhNbSLIrZzRiCRJTalDxGysj8JwBEDKQvjHuA7RShpFiYJVCqRGbfLFiXIm3RjAaQllG3d4o5cqWaKfUt7nzI1nfujw2IFOFx6uRwyGiaYE42xY3jIPjAlxtx5Qc864ZreZRbSuOK8DSF1jxvcSI8S7AQFJG9Sc45K3bSzWaip2ksaBG/xEJS2UmlGe5gl2ELwJQd2MoztCwVsHk2A3Z5DSLo1gy2c0XAkSY2rod7ZR3KOAIxxSBzI7h207KxUrLc5rcIG7fsJPmkwJEstN4dwrqhUNZlGOTtEm6LkFzhSQpPi+QntrzDFJ4HLbcJt8dq0QbC7JX4TL6kd2SCR9MB2il6sUG3OOomI8P+YRgSX0biVI8CKSI+LkTMWLEKASuZGwvm5UqVmsVVrVOMeXFOAgQs0UUVEnIooooQknpNdwxRnisgJBwH258+AfiqE0MU2oq8e08G2nzsx2zywBM4+xgl+Wpa6wbCKWLc65YAgEMRyPPBwefOoj6OW8cU9668lUwQnJJxw4jcHmfNdCvRuD4oNsTnMc/HEEH3czhy7D3qOytc60iQIHeoE61LvjapesOYWXhfMqsR/GhqzHoLtNMWkTzkYNzfSEHyxwxQxD/7BLVSNRuTNLLKe2SR5D77sWP5anPqc6/YND0+DT5dPdxBxSJ4p0YyPLNLMS0TxrsALheTHktehcJrttFe7G2azNky0ESB7I6+kBVaj5qF3Wov639T8M1nVJs5DX1win/04pDDH/8AXGtWD9BDpuyx1C6xgzXkcGfKttCHGPNuum/HVU3dmJZjuZiWZj2lmOWJ98kmrf8AoXuk2l2eiWtvJf28dyXuZpIHuYUmBaeTaOG7hieAsZwKh4XUqlO6RQotJza3KcgM56hCiZrmq8df2oi61/VZBzC3Rgz57WNLU/8ANCedPvqNXwXS7i5blmWaXP2EES8/vleoU1a/a6mmuH5NPNLOwznDSu0h5++xqeNCt/B+j8EZ7Zo41Pn8NuAD8iTH4hVu+GcVYaNn3ljewf8AC0rrbNQledLhMcMSHtWNFJPaSFAJPnzk100UVx9Rxc4k7V2gECEUUUCmASUqjvpfKrz3PEICDbESW2jbw1z42eXjuwpM0+2jhQJEMJzIwS3rjntJ59tZ1gR3Al4pGyaV25ttzmRnQA57gB97Wy3iEaqi+tVQo95Rgfir3a7aPFWemyNGheLXrW421VHdJWwV1+Crz7602qZPvYP467W7KS3P2KixWi6PNbAaXsKAiABtu0Yc28YTd9kX5DPfTj6M+xN8Iuf7xJTc0PRoVXS8KcSQK7AsxyUt43Xv7N3dTj6M+xN8Iuf7xJXzBwjdZyDxLnnPPH1u0Xa2TFHtR2JUooorj1eRTaOmHi+CcVvBeHxuFhc44uODxMbuFnu7ccqclJn+2/2T/r1dsdQtxRuntGhUb1jUvoqz/tH6MVu1u1eVF4ZHEjkSVA3rWZM4Rj3AgkZ96tOpfRVn/aP0Yr1dak/EaOGDjNGFLkyLEqlhlUBYeM5Xnjs5jnT2h5LC3YJz6zvSHaujS75bhNwBVgSro3ro3HrkYeUeX3q3XVwkSl5GCKO1mIAHk7e/zUh3twNi38PinxVkRhjioH4ZRwOyWNs4bzEcxXX0ijZTDNs4iW7u7xgjO3YRxFDHBZO3B8poNmaag2AzltBGz6FAcYXfZ3ccy7o3DrnGVOefkOOw8xyNb6QbG5CtPeOphikWEKpwZJCN2JCiE+M29VA7eVKNhqSTMUCsjqA3DlQxuVJwGAPaueWRUdeyuaSWjIdsbx2JzXSu2sUUmXhm4vi7sbotm3ZwimRxeKT427G7/lxzzUVCjxpIkDrSudCVKKKxUMZwlWaxSZo/Gz6pu9jG/ibMCbIzwtn0mN3m9Z35rtv5SkUjDtWN2GezKqSPxirFWz4KgYCD1JodIlbjWaRbOG7kRH8KQb0VseCg43KDjPG54zW3wS791r+CD9vTjZ2gwXjx+iMXQlWikrwS791r+CD9vR4Jd+61/BB+3pvEM+8H830RiO5KtFJXgl37rX8EH7ejwS791p+CD9vRxDPvB/N9EYjuSqRRimF0V0e8ivN8gIUFuJIWyJAQcDt8fLYPmxWzpzpN3NcK8Ss6bV2bWxw2Hrs8/FOee7zjyVd9X0+NFPjBETPlqmcYYmE+aKbnS6xuJbRI0O+QcPiBTgyAIQ+PKN+Gx5qOhdjcQ2zpJ4jEtw1Y5KAqACfIN/Pb/rUHJGcVjxiZiPNOxmYhOPFGKYnQvSbyG6LyqyJh+IWbPEJB29/jndht3mNeemGkXkt3vjBZfE4bKwAiwBkZz4h3AnPnqb1fT43i+MERM+WqbxhiYT9optdO7G4ngRYsvhgZFXkXG3Gcd4Dc9vnHkr30YsbmOyaNztlIk4e45MYZcICR2YfLebIqEWRnFB+MTMR5p2POITiIopkdAtJuoJ3aVSkZUhgxB3uSMEYPjEczu/1rR0i0e9kveJGCRuUxyhgFjXA5dvi458u/n25qb1fT40s4wREz5apOMMTCf1FNfrDsJ7iOMQgsoZi6KebZ27DjPjAYbl9kK36TZXK2BiLbZyjhctzQHOxd2eRx392R5KhFkZxTX4xJMRu6UuPOIThIrFM3q+0u5gklMqlIyuNrH10m4EMBnuXd432VOfVN+E27tu/x+HgybNrY2g/Z7M454zSVbIG1uLa4HpQH5Suus1z6dv4a8T1+DnO3djJ27tni79uM7eWc0k29is810XeTxJlVQs0qKF4MTclR8drE/HTG2duJwccm7RntjoS4tyXsUYpL9Iovqpfwm4/aUekUX1Uv4TcftKTBQ5x/L+qJclTFFJTaFHjxZJUbuYXEzEHuO13Kn3jXmHUXhYR3WBk4S4UYhkPcGH/kyfYnkeeKOTtcJpmeiIPZrKMR2pr9bVk0yptlKYBG3BIOT28mGDUY6PZSNp90sZBmna9CsxIBbdJbxOT3DZGjfJUi9a8N47oLcZUA59bnd/X7seTz1BnS671DR/B1jleJX4viPw5l8QxnA4ikqPHPYe+vVuDdnrWmwU6LatOZBa065SSDAnpVana6Vmque8HdKYt/1Z6rDn+bcQDvikjfPvLu3fipvahot1b+zW0kQHfJDIg+VlqTrPrQvk9kjilH2jxt98shX8VOLQes3whxGbNg5BPqUyPyUZJ9VCge9mu2dar0oNxVaTXAbWuj5qakbFaHBtN5k7FAFYIzVk7y/wBNuPomz5nvlshMRn7O3Vgvv5pLm6J9H7okLw43P0sdy0T/ADTvy+SomcI2/wDUpOHUMQ71ZfdLhoe9QEq5IA7SQOXbk8hirLdJ4eDDY2y9iuikfYW9vJj/AOzhUgw9T9oksU0U8mI5I5NsgjkVwjhiuVUYyBjPnpc6WybruJfrVvIxH3eVApP4O4+M1lXtelG2Pp8UcmhxMgjOIHir122R1I+1tK4qKKK51dIiubU7jhQyyfW43f71S3+FdNI/TKXbayDvcxp8TyKG/wCTdVuwUuNtDGbyB4qC01OLpOedgJUU31vLKixy2vERCCDFOAcgbQdrgZ5flrs9OAPXwSp5zFuX5YyaU6K90bSLdCvD31MRkrp0xgyBwchwCMgg459oPMV1NXi3OVHvY+TlXtqzKziSZShWa6PaK6LpuZyeJCjggEFAkMblRl+8HbmnX0Z9ib4Rc/p5KafR4Xu3Tt2PYU4edmNnBj4mdnP2PHbzpzywyWjM8QMsDMzvB2yRsxJZ4CfXAkkmM/FXzpwpfWqvFOtVY85xgjYTkYAzz27iuwsYaGyAR1pZrFabO6SZBJGwZG7CPxg94I8hrfXDOaWmCtCUUl/7b/ZP+vSpSX/tv9k/69WLL8XUU1+xY1L6Ks/7R+jFc+swyRSpJDLwzcypC4KLIuRG5WVQTycKm3HYeXkro1L6Ks/7R+jFGv8ArrT4Wn6GerNBxBYP3T8yfmEx21c2uWiwWLxqSQoXmxyWYzKzMT5SxJ+OlTWPYZ/uUv5jVx9LvoWX+p+kSuzWPYZ/uUv5jVG1xcGE84+SUjVcRs2mtrfYQsiLbypuyULoqkB8c9pGRkeWtehmS6ZLqQKiiN40RWLHxnG93YqO+MAKKUdH9hg+5RfmLXH0R+hYv6/6R6kfWIY/rjsMz8kAZhK1FFFZilXJqd0YlXGBvcJvc4RMqzbm8xKhQOXN1r1ptwZYw5AGSw8U5VtrsodCe1GC7gfIwroIoqwajDSDcOe9NgzKzXLq/sE33GX8xq6q5dX9gm+4y/mNTKH7RvWEO0RpHsEP3GL8xa6a5tI9hg+4xfmLT2sOj0QUcQbmxz5kAeYbe73637p4OWq961RtCPZ1JyGem9Vq1qZQaMSaVJUmpTGWWOK3EgiKAs0/DyXjWT1vCPYGx291OnpBpgt2BU5Rs4z2gjupsaV9EXv3SD+7RVTtN21LBXqUbQ0YmjpjMjPKNhUjKoqtDmnIrHhd37kT8LH7Cjwu79yJ+FD9hWB0itj2Ox7RkQXBHI4OCIsHnWf4Q231Tfg9z+xqHA/7nwd9Usjemv0W1O+kvNkhYrluIjLhYwAcYGMJhsAYrZ051K8iuFWJmRNq7NgyJGPrs8vGOeW0+QcudOT+ENv9W34Pc/sa5bnUo55rURlmKzMxzFMgA4Eq5zJGB2kD46vMquNbjHUoAB2ZZZ7uxNgRErX0vu7mO0V4wUkOzilBkxgoS+PIN+Buo6FXdzLas0mXYFuGzjBcbQRk9438t3v0s6v7BN9xl/MajSPYIfuMX5i1T49vJowjX9f0T49pM7oVqd5LdMspZkw/EDrgRkA7cDHiHdgbR5TXnphqd7HdhIiyr4nCVVyJMqN2RjxzvyMHyCnTo3st58IX+7w1jUvoqz/tH6IVa5SwWjFgHu6dk/om4fZXB08vLiG3RosplhxGTmUG3OAe5d303mHlr10Yu7mSyZ3BaYCThbhgyALmMkd+XyM9+BSn0h+hrn4PN+iauix9jj+0T80VV49os4GEe9+v6J2H2kzugWo3c07rKzPGFO4uPWOCMAcvFJ5+KPP5K09I9Uvo73ZGWA3KI41GUkXA7Rjxs88nu59mKdWgeuu/hb/oYKxf/Rdp9zu/yQVa5SzlBOAe7p2T+iZh9lJnWHe3EEcZhJVSzb3XtXG3YC30oOW5+YVv0m7umsDIwJuAj7Mr4zAZ2MVxzbHd34Hlrr6X/Qdx9yP+FK7dpqpx7RZ2DCPePhn5p+H2kyur3ULqaSUSszxhfXP9LJuGFBI71LeL5hTn1WN2C7QWUPl0R+G7rtYAK+4djlWxkZx8R0dHv9p+Fzf5aU6LXaMNoxtaBH0Q1sthaNORljUOcsAe1txAySqlj64hcDd34Ncejey3nwhf7vDSpSXo3st58IX+7w1Ax+NtRx2jzCdEQi9vJ+PwYUQ4hWUmV3X1zumBsQ/Ud/lo33v1EHzs37GsJ9HP8Ei/TzVs1bUDCcDbyjeQmRygITGVU7eZ59vdy8tWGsxObTYwEkA5zunemTlJK4NS6TLZw3El0nDe2gmuNinInjhRnPg7tgMxC42nB50kDrBtXVlubS4hU8mV7ZbpSPesJJCR8VNbrO1Vp0EGMiWe1XDDmoaeMyEeRhCJK8V0Nmuuzig19RntEnRxBERpqN+oKu2SgKzSSUsydO7C1ZUS6SSF18SK6ZreWI5xsU3KhyuPpGGRy51G/ogtXguFsHKpEv8AOwG4qlZM+DZ2sQAcY7vqqdzcxg8we48wfipIv+i9hPkyWcLE9rcFAx/rqN1dVc1su6w1G1eJOMT7WKSZyzGQ06FBa7kfVaWtqZboUFXMttgkSp84n61KHVy8bXLuHXxYio8ZebO6nlz7QEP31SJqHVVpcucRPDnvimfl7wlLAU29Q6joD7BeOnmkjWT/AJlZcV2VbhNYbXRNIuLJykj6SqNhua0WOu2sAHRsmE468yRhhhgGHkIBHyGmPJ1U6tbfQ16rKOwLLNE33pXb+OuaWy6S2nbC0yj6kQ3GR/wyXrEbdlF+dG0NPWYK6gXuR+0pOHVB+Se6aZEuSicInnmFmgPv5gYHNeZdPYsXFxKHKqhZnWYlULFVJuEYkAu57fpjTLsOlerZYPpckuxtrcK3uQVbAbaxCkK21lOPsh5aW7PpPcN7JpN4h+xtZnH44xTn3fbae0O/8gfAp1O9bE86wekEJZ4VwvZKjjyPEyt9+kmP+WkGPpovEkiaHLROyNwpVfO1iudrhcAkHtpfg1Asu829xGBz9UsrpQPfbhbRTD6KaJdXbtEqBZ8TTusxeLbmUciNhIc8ReRx601oXNYKNbjHW0BrWgZ+78lTva86lIMFjIc5x010CdsPSq2Prt8f20THHvmLIFJnS/VIp0iSKVXPFLsFIJCrG4G5e0eM4PPyVru+iGoRdtqzD6qN4pAfeUSb/wAVI9zbyRECSKSLngcWGSLJ8g4ijJ5d1dBd1yXYK7a1nrSRnGIH9VgW2/Le6g+nWoxIiQDl81roooruFw66Uu4kAVpFU47GdVPPzMc0NqMGPZk+cT9akS46M3967yW1jcXUYITfbWs9wqsFUlWaGMhX552nuIrxJ0C1ggj0oveYP/8ALrz9jXN2m10mvc0uHaVbZScQCArg6BrLumnt4OxEUCLhcsXEkCJkZTAOBn/GnbbauGkSNoJYmk3bTIsYU7F3MMrKT2V66MxslpaqwKsttApVgQyssSAqwPMEEYwfJWvUvoqz/tH6MV803tbLLaq5FKiGRi+ImdTOa7GhTexvtOnTYvOmIFu7sAYBW2YgcgWYTbmx9UcDn5qV6SrD6Lu/udr+SelWsO1n2x1N+QVhmih6fr1SN4Ym0q5WScZjUvb5kHm9U8/fXJb9dKyX0ippVw0sVvseEPb719UV9x9UxjDr8tR30m9stD+0H+WtnRj2/wBS+4/ute1M4JXY0EinqOc7f1rmDbq+KMW2NBulPh+vWGcR3qabcG3tmkWR98GA0qIqj1/b46ffCves9eEZWylOmXCo86SRsXt8S+puoVMP2kyKedQ70Z/o7f8AwmP/APDXf0j+gNA+3g/JFUg4J3aCIp6SPedprv6VH6xtBbOLZOg3wpY1zrnE5axGlXC3DqriMvb52qwctyk7MKa9Tde0VxHdhNMuDwI5FmO+3xD4sgJf1TsGx+z6k0wbj+kifAz+bJSL0a9j6Tfa3H5NQpo4JXYAP7vSD7ztvanG31597eNBsClW16+4YbSKdtNuOBhYhLvg2M6AoQPHz2xt2+SjTeulbRbe1k0u44sgYxqHt/VAXZvF9U8/fUN6p/Ry2+FSfpbunH0p9tdF+0oPBG7DI4vUn4nbO1ILwtETi5uwbVJtv16JJNJAuk3LTRDc8Ye33IPF5n1TH0y/LWiD0QEDwPcrplwYI2CNKHt9qsdmAfHzn1RPvhUd9F/bzVPuQ/8Az02Ojn9HL/4XH+XT6YOBt1fd7vidt7UpvG0c7nbBsU3XHX3FGsDtpdwqXOOExe3xJuwV2+qd+5e3y1uPXkvH8G9Kbnjld/C3227bzO72TGORqGuk/wBB9Hvft/zbel6X+ka/A/8AK9H2Our7rf8AE7Z2pwvC0T727YNqkG36+4pBOy6XclbXPGIe39S279271Tu2P2fUmubUuvuA2hmOm3CwTCSJZS9vsLkOmOT55FH+9NRV0Y9g6Se9P+S9pP1n+jlp8Kl/SXtObwPutrsqe0fE7r3phvK0YZxbCdBvhTdbdecVq1pBPptxE8ghRSzwYYErHu5PnbmrWrXz46zvo/Sfeg/vEdfQgV09wXRZrC15oNjFrmTpO9RVLRUqvLXmY81Fnoiun8PR+3tJpoXmE87RARFAVIjZ8necYwpFQxF14R27mZ9MuAl+0TQePb+PiKJBj1TvJU/1hTl9H37X6Z8Pf+7S1BHSf6F6Of2f8lpVC+ODthtVoNWqyXOyOZGmmh6EMttanLWnIealjReucQFLE6Vcm4VWfhh7fO0sz7ucnZg1ut+vyKRZ3XS7krbZ4pD2+Itu7du9U7tjdn1NR5//AFJ/Y/8ALSJ0Y+hekX9o/Jd1ju4I3Y44jT1g+87b2qfl9cZYt+wbFLc3ogYEgS5bTbgQSMUWUvb7WYFwQPVM5Bjf7010XPXokcscD6VcrLMMohe3y458x6pjuPyVBev/ANHLH4XL+ff06Olft1pX3L9tSfY66/u9/wATtnakF42g/Fzdg2qRpuu5Ljwi2TSrkypG4dd9vmPcpGW9U7OY7K59N6+4RaLMNNuGghCRNKHt9gcBEA5vnmXT74UwejHtvrH3P/BabGjf0bu/hUX6Szp32RuyMPF5ZfE7b2pDeFo1xc7YNimKDrwjt24j6ZcBb+RZIPHt/VAYoUAHj9pyp/rCtt11zh72GIaVc8aFZXMO+33lZEADD1TGByNRR0n9g6N+9B+Sypdj/pG3wP8AypS/ZO7ZxcXnB+J2zLfuSi32iYxbRsG3NPm86847m3vAmmXBWKOWOR99vtiJRgd/qmcDBPLyVkdfsENtFO+mXAgbEay77fa7qGBA8fP/AJb/AHpqKOjX0F0h+2uPzZqTukf9HbD4XJ+XUKPshdkYOLynnO3dab6xtETi2ToN8KaLXroW2neF9KuBNdStPHHvt9xUoqY9kxnMTmsHrpWa7GzS7gvaJMJY99vuXicPBPqmOWw/LTB6T+3ml/cj/wDorx0W9tda+0pPspds4uLzjnO6t+5P5dXmMW2NBulPrV+vSG5sZ5E024EJHCMxeDYrkqADh89rqOX1QpQuOvuJBAW0u5Autphy9v6ru2bdvqnfxE7fqhUJaX/Ru5+FR/pbSlDpJ7H0Y+1t/wAmn0fZC64w8XkCfidu60z1jaInFsB0G0wpW0rroEc81t6VXBneR7jhB7fcEcKRnMmOzHy1ug6+4XSaRdLuSluSJWD2+IyuchvVO7B7PJUd239JJPgg/MipE6OfQGv/AG8/5JaR/BG7HHEae74nbe1P9YWgZYt+wbFLk/ogII4EuW0y4WCRiqSl7fazDfkD1TOfU3+9Na4Oulbe5eF9KuBNdOJY4t9vuKiNU+uY7YnPxVDHSf8Ao7YfCZP/AN1OjpP7f6b9x/eqBwRutoIFPWfids7UnrC0H4ubsG1P6166le7nK6XcM0MCRyRh7fdGVkkcs3qmMeNjl5DWZuvu3e2Nz6V3DQKwXilrYqr5CjtfIOWAz56jvov7Za59of8ANTfsf6Ny/CU/TQU77JXYSDxekD3nfVJ6wrx73O2DYlvpV1lCeS3k8EnhZ5BNCfUHEhZDGAVLeMpE4Pdz21zR9aV2sxhNlxnA3FMeDuFwCD7K6ntHPl21zdKLVcdGuXr1gz5/a/8A1NdsGko3SCaPsHgwP/1wf61rMuqxCmGcXkAd+/fqpqN62mmYa7aNg2hKWl9a8Equ8lpNGsfJ2ThyqhHbkl1JA8wpcs+n2nSKrmfhK/rWmiljQnnyEjJsJ5HlnuNRhoekhrHWWz7HJL+INSb0l0wro1lJ3NKw/Fc/6VBU4O2F5yBb1H6yr9LhJXaJcAcp3bYU+2GrW9x7FPHL5o5Ucg+QhWyD5jXaRUEdKNIb04tInQNuhJ2sAwI/nXaCMH1v4q16C06XV/GkssawZKJFNLGiYLYARHC45DkeVZtTgowiadTvHnPktGnwlYTD2Hdl3qeqKgzTenGpR2BujcmRlk2bJYomQgsq8ysYfPPy05rXrCu0NirwxStelAu0ywBGcwgbiS+RmYcwO7sqjU4L2ph9ktPbHzAV6nf9lcMzHWN6X9A6d2yS3Fp6Xz3Nz4RcSlomhAeMSCON14jA44SxdteP4xbaWOaWPTrgxwEiR99viMgZIb1TPLzU3eiFq0GuNE53PHYRK7DsaQQWm9hkdhfcfjrg6OHGl6390l/MrddcNkc7EWmcvidt7Vx1e3VXVHEHa7YNmiXdS6zFEKmOzmiE4ZYpZDCU3lW2sQGyQCpOPsa9dUe6aa+uXOWcxLn7JjLJJgdw8aPl5qYUz8S0sVP/AJas/wAfjoPiw7fIK3aRrl1ZbhbzGNXbeybInVm2quTxEJHiqo5Edlbo4Mg3dUp2YAOedSToDvz3J9gvJtK0h9Y5AbBtKnqmB103HqdpFn100kuPKIo9hz8c4pFs+sa9X16RSj7WSJvvhIR+Kkfph0jbUnjdohDwo2QASGXJdgWYExjAwqcvNWNcPBS22S8KdSs0YBJkEbsunXoXQXjfdmq2V4puzIiEjRtmslueK8w9lY+mr1eV5+pb6oOslNFsbiM2M1wq3DXMk0TQhEDxRRqCJH3dkPaBTuuev6COKOd9MuFhlOEkL2+HPM4HqmexT8lRLoOPSjVfLtx/yDH5T8tcfS72k0r7p/lmryq+ODF32m2VKtRhJJzOJ27rWtTtlanTAacgJ0G+FNs3XmiTpbNpNyLiRdyxF7bcy4c5HqmMYjf701wN12JPcAppdwTZcbjLvt8puUpz9UxyKN8lMPpB/SOx+DN+Zf1x9EfovpB/xfz7mspvBG7G5ins5ztuW9TcvtExi2kaDYJUiW3XpComvvS24NtKIYxIHgwGjMikHx+8uB8Vdmpdf0FsIzNplxGJl3oWe38dcKcjEnZ4y/LULL/Rv+1f9YV663PYdK+CN+ZbVIeB91vdnT6PedsGW1RuvK0NZIdsB0G0pe6Te2Wh/aD/AC1s6Me3+pfcf3WoYvutO9mntZ2ihD2YxGAku1hy9kBmyezuxXqw61b2G8nvVihMtwuxlKS8MD1P1oE+4H1Ne0ntNdbyGpEZaeahPvT0z4Qn90Z/o7f/AAmP/wDDXf0j+gNA+3g/JFUSWPWDdQ2c1iscRincSMxWTiArwsBSJdoHqK9o7zW296ybuWK0haOILZFDGQkm5tm3HEJmwfWjsxTuRVJnp8lGGnDHRHjKnK4/pInwM/myUi9GfY+k32tx+TUKjJ+te9N6L/hQ8YR8Lbsl4e3DDOOPuz4x765bHrJu4VvlWOIjUA4lykuV38bPCxN4vs7euz2LSchqR3eCdGc9J8QpI1T+jlt8Kk/S3dOPpT7a6L9pUHT9YV09klgY4uDHIZAwWTiFmaRsE8XbjMjd3cK7r/rUvZri1uGihD2gwgVJQjfbgzZPxEUciqfPxSAQI/h8NVMvRf281T7kP/z02Ojn9Hb/AOFx/l0+mDYdat7DdT3ixQmS4XayskuwDxPWgT5B8QdpPfXBZdYF1FZTWKxxGGaRZWYrJxAy8HAUiXaB6gnaO9qUWKp8vBBE/wA3jopc6T/QfR737f8ANt6Xpf6Rr8D/AMr1Bd91kXc0dnE0cQWx2cMhJMtsCAcTMuD6wetx311t1sXpvRf8KHjCPhbdkvD24Izjj7s8/LSchqfPxTtvd4BSZ0Y9g6Se9P8AkvaT9Z/o5afCpf0l7Uc2HWTdwpeoscRF/vEuUlyu/i54WJuXszeuz2CtN11g3UllHYGOLgxSNIGCycQszSsQSZduMyt2DuFLyKpM9PkmYDhjoI8ZUwdZ30fpPvQf3iOvoQK+T2u9Zd3eS280kcQa22bAiShTscON4aYk81HZipi/lq9Ifcen/g99/wD3GrlloupthyXD7bjvhTV6Pv2v0z4e/wDdpagjpP8AQvR3+z/ktKavW96IfVek8MEF7b2sSW8xmU2sVyjFijR4YzXbArhj2YppX/WTdzR2UbRxBbHZwyEly2zhgcTM3P2NfW47TUdos7nuBCbgMu6YU5f/ANSf2P8Ay0idGPoXpF/aPyXdRn/Gve+G+H8KHjcPhbdkvD24xnHH3Z+OuWw6ybuGO9jWOIrfb+ISkuV38QHh4m5eyN67PYKrciqRs2eCkIz7T4hSLr39HLH4XL+ff06Olft1pX3L9tUF3fWBdS2UVgY4hDDI0qsFk4hZjMSGJl2kZmfsHctd+odat7PdW920UIktl2oqpKEI8b14M+SfGPYR3UvIqnz8U1oj+Xw1Uy9GPbfWPuf+C02NG/o3d/Cov0lnTBsetW9huLm5WKEyXS7XBSXYBy9YBNkdneTXDbdYN1HZSWAji4MsiyFisnEDK0TAAiXbjMS9o7zSchqfLwQW/wCrx0UudKPYOjfvQfksqXY/6Rt8D/ypUGX/AFk3cyWSNHEBYBBHhJcts4QHFzNz9hX1uO011L1sXovTf8KHjGPhbdkvD24Azjj7s8vLRyGpEZbfFKBn2jwCkzo19BdIftrj82ak7pH/AEdsPhcn5dQqObHrJu4YryJY4it8XMhKS7l3hgeGRNgevPrs91ab3rAuprKGxaOIQwyNIrBZOIWbjZDEy7SPV37B3LTuR1Jnp8k3CYjojxlTr0n9vNL+5H/9FeOi3trrX2lQ5f8AWrezXcF40UIlt12qoSXhkeP64GbJPjnsI7qxYdal7DcXVwsUJe7GHDJLsUfYATZHxk0zkNSIy081J8U9M+EKQdL/AKN3PwqP9LaUodJPY+jH2tv+TT6iGDrCuksnsBHFwZJBIWKycQMrRsADxduMxr3d5rde9ZV3MLFWjiA08IIsJLltnBxxczeN7AnrcdrU7kVSZ6/ko8BiOgDuMqcLb+kknwQfmRUidHPoDX/t5/yS1Gada96L1r/hQ8Zo+Ft2S8PbhRkDj7s4Ud9ctl1k3cMN5CscRW9LmQlJNy792eGRLgeuPbmk5DU6NngnEZ9/iFI/Sf8Ao7YfCZP/AN1OjpP7f6b9x/eqgu/6wbqazhsWjiEMLmRWCycQluLkMTLtI9WbsHcK7r7rVvZruC9aKES267FUJLwyPVPXAz7ifVG7COwUchqfPxSAf6fDVTD0X9stc+0P+am/Y/0bl+Ep+mgqPbDrTvYZ7q4WKEveDEgZJdq9vrAJsjt7ya44usK6WyawEcXBaQSFisnF3BkbAPF24yg7vLSixVPl4JSMvzeOil3pP2dGPeg/Lp1LFl/SSb4KP0dvUIX3WVdzeABo4h6XhBFhJfG2cHHFzN43sCetx2tXRF1r3q3rX4ih4zx8Mrsl4e3ai5A4+7OEHf5abyGpEdB8UAZz0jwEKSujPtdrv3Sb81q4+lv9H9P+7v8AkvKjex6x7uGG7gWOIpeFmkJSTcpfIPDIlwO3vzWrUesG6ns4bFo4hFA5dWVZBISRIPGJl2keqt2DuFO5FUnt8k0tOGOiPGVOnScf/wDRaf8ABj+S+rm6LxA6hrmR3P8AllqI77rWvZryG+aKETQJw1UJLwyDxebAz7ifVm7D3CvGn9aV5BNdzrFCXvARIGSUqudx9TAmyPXHtzTeQ1Ijo81IPenpnwhPy2tVPRx2xz8JUZ/4sVKWv2qxv0bKjG4wE+/usP8AWomj6wrpbE2Aji4LSCTdtk4u4MrYzxduMqO6t1/1mXcxsS0UQ9L9nCwkvjbDCRxczeN7AnrcdrU/kdSe9MwmI6B4FTbpv9JLn4Kv6K1pt6TLt0vWvPNKP+Wo+g61r1L578RQ8aSMRlSkvCChY1yF4+7OI17/AC0mR9PLlYbiAJHsuXZ3O2TcCwwdh4mAPfzSNsL9vR4J0Z9/inpak8KFT2pEFPkzuZvyMPkoU5NMX+Gdx9RH96/7SsL0yuB9JH96/wC0rqaVopMaGjYqpouKfZPbWD2UxP4ZT/UR/ev+0oPTKfs2R/ev+0p/LKaTiHJ+L2CvOPGpjfwyuPqI+X2L/tKx/DGfOdifev8AtKOV00cQ5TRoCn0q1Y58UxjAwOTBDuOe3mCg/q1y9LvaTSvun+WaoztOsq7itri1EcRjuRhiUl3jljxCJsDl5Qa16j1iXU9rb2jRxCO2bcjKsgcnDDxyZcH157AO6uctVndUrOeNCZ8IVjD7MdEeMqcukH9I7H4M35l/XH0R+i+kH/F/Puaia861r2W9iv2ihE0KGNVCS8MqRMMsDPuJxM3Ye4Vq07rPvIJLyVYoS17u4gZJSF3FyeHibI9kPrs9gqpyGpEZaeafHtT0k+EKRl/o3/av+sKz1uew6V8Eb8y2qL/4w7rwHwDhxcHicTdtk4u7dvxni7cZ81HSLrDur5bdZY4lFtHw02LICVIQZfdKcn1MdmO01I2xvDp6So3MJYR0AdxTOooorUUqKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQiiiihCKKKKEIooooQv//Z\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/l26oaHV7D40?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x1c4b55e6c10>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"l26oaHV7D40\",width=\"100%\", height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd9c7fa5",
+   "metadata": {},
+   "source": [
+    "3. If you need more indepth help, this 30 minute video has a step-by-step breakdown of how to create and use functions in python. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "64684dfd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAUDBAgICAgICAkICAgGBwgICAgICAgICAgICAgICAgICAgIChALCAgOCggIDRUNDhESExMTCAsWGBYSGBASExIBBQUFCAcIDwkJDx4VDxISFxUSEhIeGxISEhIWFRIVFRYSFRUTEhISFRUSFRUSFRISEhcVEhIVEhISFRYSFRISFf/AABEIAWgB4AMBIgACEQEDEQH/xAAdAAEAAgMBAQEBAAAAAAAAAAAABwgEBQYCAwEJ/8QAWxAAAQQAAgQHCggHCwsEAwAAAQACAwQFEQYSIZQHCBMYMVTUFBciNUFRUmF1tDZVcXN0gZHiFSMyNEKSszNicoKhsbLDxNHTFiQlQ1OTlaO1wdJkhaLwRGOE/8QAHAEBAAEFAQEAAAAAAAAAAAAAAAECAwQFBgcI/8QASBEAAgECAwIJCAgCCgEFAAAAAAECAxEEBSESMQYUFkFRUoGS8BMVMlNhcaHRByIzQpGisdJywSM0NTZDVGJzg7LiF4LCw+H/2gAMAwEAAhEDEQA/AKZIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIp95qOkXW8F3i92FOajpF1vBd4vdhWh5UZX6+PjsMjilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UgJFPvNR0i63gu8XuwpzUdIut4LvF7sKcqMr9fHx2DilXqkBIp95qOkXW8F3i92FOajpF1vBd4vdhTlRlfr4+OwcUq9UugiIvns6UIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIi/SWta+SR7IoYGOkmmkOUcUbelzj/IANpOxXqFCpXqRpU1eUnZJb2ymc1FOUnZLez8X5mFHWkPC5HG5zMMqxvaNgtXw55f++ZUY5rYx5RruJ84HQuWt8KOOvJyumJp/Rgr1Ymj1Ati1vtK9RwH0SZjWgpV6kabfNrNr32sr9pzdfhThoO0E5e1aL4k35r8zUC98XHen8JW/wBZuX2auSzKfCvjsZ8O0yw0foWataRp9Rc2Nr/scs2p9D2IS+piYt9Di1/8mWY8LKLetN/Am9FwOi/CxUsubFiUDaL3kAW6xe6prHZ+OgeS+Bn75rnZdJyAJUgzRlhyOR2AgtIc1zXDNr2OGxzSNoIXn2f8FcfksksTH6r9GcdYv2X0s/Y17rm9wWY0MWr0nqt6ejR4REXOGeEREAREQBERAEREBz3CDpKcJp91iEWMpo4uTMvJfumt4WvqO6NXoy8qjvv4P+LW78eyrpOH/wATn6ZX/rFXtewcCODGW5hl3lsTS2p+Ukr3ktEo20jJLn6DSY/F1aVXZg7K3s+RMHfwf8Wt349lTv4P+LW78eyrD0d4BscuwQ2Q/D4IbUMczOWsSmTk5WB7DqQwOGeThsLgugi4teIEeFiNJp8zYZ3j7SR/MuqfAvIF/g/mn+8w+PYnrfBfI1ffwf8AFrd+PZU7+D/i1u/HsqzrvFuxZo/E3cPlPmk7og/lbHIo/wBNeDfGcHaZLtR3c7T+dQOE9cet72eFCM9n4wNzKmPAnIZaKj+af7w8fiF974L5HZd/B/xa3fj2VO/g/wCLW78eyqOdCtGp8XuMo1n147EzHui7pkdEyQxt13RtcxjiZNQOdll0Mdt88hc3nSH0sM3qfsymXAjIo6Oh+af7wsfiOt8F8j6d/B/xa3fj2VO/g/4tbvx7Ko20w0dtYTcmoXGtbPX1CSwl0b2yMa9j4nlo12EO6chtDh0grUKtcBcjevkPzT/eR5wxHW+C+RMHfwf8Wt349lTv4P8Ai1u/HsqjXRDR61ityGhTa109nX1S8lsbGsY6R75Hhp1GANO3I7SB0kKRubzpD6WGb1P2ZUy4EZFHR0PzT/eSsfiOt8F8j6d/B/xa3fj2VO/g/wCLW78eyr583nSH0sM3qfsyc3nSH0sM3qfsyp5FZD6ld6f7xx/E9b4L5H07+D/i1u/Hsqd/B/xa3fj2VfPm86Q+lhm9T9mTm86Q+lhm9T9mTkVkPqV3p/vHH8T1vgvkfTv4P+LW78eyp38H/Frd+PZVptLuBjGcLpT37TqJgqNa6QQ2JXyZPkZENVroGgnWeOkjZmtbwecGWJ47DNPRNQMqzCF/dE0kbtcsbJ4IZE/NuTht2KeRGRWv5DT+Kf7xx/Edb4L5HV9/B/xa3fj2VO/g/wCLW78eyrQ6a8D2L4RSlv23UjBA6JrxDPLJJnNKyFmTXQNBGs8Z7ehR6qo8BsjlqqH5p/vIeYYhfe+C+RMHfwf8Wt349lTv4P8Ai1u/Hsqh9SjgvATjtutXtxOw7krteGxFr2Zmv5OeNsrNdorkB2q4ZgE7fKVEuA+RR30PzT/eFmGIf3vgvkZ/fwf8Wt349lTv4P8Ai1u/Hsq4ThC0Ju4FPFXvGuZLEPLs7nkfI3U13R+EXxtIdm07MvMuaUrgLkbV1Q/NP9484YjrfBfImDv4P+LW78eyp38H/Frd+PZVGui+jl7FJ+58PrS2pQAXBgAZG07A6WV5EcTdh2uIzyyGZUs4PxbsTkaHWr1OsT+hEyW0R6nE8m3W+QketUy4E5FHfQ/NP95Kx+If3vgvkYHfwf8AFrd+PZU7+D/i1u/Hsq3F7i03WtJgxOrK/LY2WtLA0n1vZJIQP4qjDTng/wAWwUg36xbC5way1E4TVXk9A5Vv7m4+Rsga45HIKI8CchloqP5p/vDx+IX3vgvkdv38H/Frd+PZU7+D/i1u/Hsqh9bPRTBZcSu1qELo2S3ZeSjdKXCNrtVzs3ljXOAyaegFXHwFyNf4H5p/vI84YjrfBfIk3v4P+LW78eyp38H/ABa3fj2VeMY4vmOV6807ZKFgwRuk5CvJYdPLqDMsia+u1rpCAchmMzsURAqmPAfIpbqH5p/vJePxC+98F8iYO/g/4tbvx7Knfwf8Wt349lUProeD/Q+5jlp9OkYBNHWfZd3RI6NnJxyQxOycxjjra07NmXRmqnwFyNK7ofmn+8jzhiOt8F8jv+/g/wCLW78eyp38H/Frd+PZVrcf4Dcco1LNyd2HmGjXlsy8nZmc/k4Y3SP1GmuA52q05AkKMVTHgPkUt1D80/3h5hiF974L5E66H8LDsQvVqRothFp7m8qLZk1NWJ8mep3O3W/Iy6R0qUFWXgi8d4d87L7tMrNLyvh7lGEy3G06WFhsxdNSau5a7U1f6zb3JG4y6tOrBubu7/yQREXDGwCIiALkuGiZzMDyaSBYxWtHKB+mxlexM1p9QkY13ytC6zNc7wq4Tau4QyGnBLZlZisMjmQtL3CMVbTS8gdDdZzRn6wu2+juUVntBy/1b/4ZGpzxN4Kol0c3vNRwGYRUfh89sQQ2bndjoZDLE2c14BFG6IMjeCGB5dJm/Lbll+iuO4b8Mq1MUDKrGQctSgnsV4gGxwWZHS6zGsGyLONsT9Tycp61jYbolpJVcX1amK1nuGqX1xNC4t9EuicCR6isafQTHnuc9+HX3ve4uc98T3vc47S5znbXOPnK+haGCdPMamMlibwnFJUm1sxatqtf5c+vMcJUqueGjRVKzTvtW1fwOWJXklbTHtH71Dk+7a09Xl9bk+WYWa+pq6+rn05a7f1gtSSt8pqSundew1zg07NAlWB4Hbz7GBV+UJcaFyxSjJ2nkGsinjYT5mcsWgeQABV7JU9cBPiJ/tix7pUXDfSNCM8krXV7OLXv2kb3g82sZG3Q/wBDs0X7kfMfsX4CvmBq289FCIigBERAEREAREQEfcP/AInP0yv/AFir2VYTh/8AE5+mV/6xV7K9++jb+yf+WX6ROczT7bsRfXg/8UYX7Lo+7RLT6e8JuE4JPHXvSTNmmhE7GRQSS/iy98YcXNGqPCjdszz2LccH/ijC/ZdH3aJVz43/AI5p+yY/e7a6qlBTnZmHJ2RMmj/DTo7dlbC24YJJCGsFqGWuxxJyA5Z7eSBJIABcM81IMrGvaWuAc14LXNcAWuaRkQ4HYQR5F/PEq5PFuxWa3o7TdO5z31nz1mvcc3Oiglc2EEnp1Y9Vmf7xXK9BQV0RGVyE+HfQw6N4pUxLDPxFezNy9Zrc9Wpcgc2R0IH+wdmHNZ5uVb+S0Ky+gekkOL4dVxCHY21EC9meZimaSyaEnzska5uflyB8qj3jaV2vwBjz+VXxKs9h9bmTxH/4yFR5xUNMu5rsuETOyhxMmatmdjLkbPDYPNysTP1oGgbXKWnUpbXOv0G5nW8bTRDl6kOMQtzlw7KC1kNrqkr/AMW85bTyczvqFiQnoVY1/QfFaMVqCatO0SQ2oZIZWHofHI0se0/K0lUms6BWm4//AJPjPlnXRAyUjpruHKi2R0ForfjSB6Lh0hXMLV+rsvm/QiaJq4pGiPI1rGMzN/GXy6tUzG1tWJ/45483KTMA+Ss0+VTFpPpLQwyNkt+zFVZNJycbpXZa79UuLWgDM7Gk/Z5wsvBcOhp1oKtdupDUhjgib5o4mhjQT5TkNp8pzVQuMPpn+F8XkZE7Wp4Vr1a2Rza94cO6px59eRoaCNhbDGfKrMYutNvmJf1UWT77GjnxrU/Wd/4rb6MaZYXib5I6FuG0+BofI2IkljXEhpOYGwkH7FQ1TvxOPz7Ffodf9tIq6uGUYt3IU7ssjiV2KtDLYne2KGtE+aaR35McUbS973fvQ0E/UuS77GjnxrU/Wd/4rO4WvEGN+xcR90mVFlRQoKom2TKVi1HDbwh4JdwDEatXEK09ieOERxMc4ueW2YXkAFvka1x+pYXE58XYl7RZ7tEqyKzfE58XYl7RZ7tEr1WmoUml0kJ3Z1PGe+DN756j79XVO1cTjPfBm989R9+rqnaqwnodvyInvBV7+DLxJg/sfD/dIVRAq9/Bl4kwf2Ph/ukKpxm5EwK/ccLxrQ9mf2mZRToZo9Pit+th9bZJbk1dcglsUbQXyzPy/RYxrnZbM8gBtIUrccLxrQ9mf2mZbbidYG0vxLEnAF0Yiowu9HW/H2ftAq/YVVGexRuQ1eROGhGi1PB6cdKlGGRxjN7zkZZ5SAHzTvA8OR2XyAAAAAADX6b8IuD4M4R3rTWTPaHNrxMfPPqnoc6OIExsORyc/VByORWy05x1uGYbdvuAd3FWklawnISSAZRRk+TWkLG/xlRLE701qeWzYkdNYtSOlmlcc3Pe7pPqHQABsAAAyACx6NHyjbZVKVi5GivDFgGIzsrQ2jFPK4NjZaikriRxOQYyR45MvJyAbrZknYCu4xCnFYikgnjZNDOwskikaHxyMcMnNe12xwIX89iM9h8quNxcdLZMVwVndD3SWsNlNOaR5zfK1jGPglcTtc4xva0uO0ujefKpr4fYV0IyuV54c9APwDiAZDrGhfa6Wm5xLizVIEtZ7jtc6MuZkTtLZGZkkOWDwIfCLB/po/ZSKx/GcwNtvR+xKG5y4XLFcjPlDWu5Kfb6PIyyHLzsb5lXDgQ+EWD/AE0fspFkU6m3Sd99mUtWZd5VY4zfB13BZOL1GZUsQl/zpjRsrW3nPX2fkwzHM+YPzH6bQrR2p2RRvlkcGRwsdI9x6GsYC5zj6gAT9Sx8bwyC7Wmq2WNlr24nRSsPQ5jhlsI2tcNhDhtBAI2hYNKo4SuXGro/n2pi4ofj+x7Ete+4auE4TdDp8DxGWlNm+P8AdKs5GQsVnE6j9mwSDItcPI5p8haT3fFD8f2PYlr33DVsarTptroLS3lhuF34P437GxD3WVUXV6OF34P437GxD3WVUXVnB+i/eTM6vgi8d4d87L7tMrNKsvBF47w752X3aZWaXjP0of2jS/2V/wB5m9yn7J/xfyQREXmhtT9YwuIa0EucQAB0knoC4nTrhHhw+R9SjHDbtQksnszZvqwyDY+KGJpHLvacwXkgAjLI7cuj0wxd2H4ZduMOrM2Ntas4dLZ7TuTEjf30cfKP/iquBXtf0acD8NiaDzDFw2ryapxlrHTfJrnd9FfouchwjzepRkqFJ2drya3+47Z/CvjuZytRtHkaKVHIeoZwE5fKV576+PD/APLZuVDs64gleSV7L5twi/wo91fI5Djlfrv8Wdx32cf64zcqHZ15PC1j/XGblQ7OuHJXlxVLy/C+qj+C+RWsXX67/Fm90s0wxDFRCL04mFUyGICCvDqmXU1/3CNutnybOnPoXPkoSvJKvwhGEdmKsuhaIolKUneTu+lglWL4uUjmaPW3tJa5uKy5EdIzhpAquJKsfxfoizRqZztgs4jNKz1taa0BI/jxPH8UrneFc9nLarvZ7Lt77PcbbJI3xUfHOjsjidj/AGr/ALV+tsNnOpNqh7tjJwA0h3kEobscw+fpCwCV5cV88vGVJaVG5R54ybaf47n0Narenc9KeHg9ys+laH0mjcxzmOGTmEgj1j/svCzL5144Jv0ntMTz53xEAOPrLC37Fhrncdh1QrSgt2ji3v2Wk1f22av7bluDutd/P70ERFiFQREQBERAR9w/+Jz9Mr/1ir2VYTh/8Tn6ZX/rFXsr376Nv7J/5ZfpE5zNPtuxF9eD/wAUYX7Lo+7RKB+NXo7iFvFaktSjetxNwxkbpKtSxYY2QWbLixxhY7Vdquacj5wp44P/ABRhfsuj7tEt3n5PKuphU2J3MRq6KS6N8FGkF6RrGYfYrNcQHTXmOpxxj0nCYCRw9TGuPqVvOD7RmLB8Nq4dE4vFWM68hGqZZpHulml1czqh0j3kDM5DIZnJbm1ZjiaXyvZGwdLpHtY0fK5xyCjPhA4b8Hw6N7asrMTt5EMiqvD4Gu8hmtNzja0HpDNZ3qHSq51J1tEiElE5Xjg4/G2rRwxrhy09ju2Vo6WwQskij1h5A+SUkfR3eZVvp2ZIZI5onGOWvIyWKRv5Ucsbg+N7fW1zQfqWdpTj1rE7c125Jyk9l2biBqsY0DJkUTMzqRNbkANvRmSSSTrFn0qexGxabuy9nBnpVHjOF1b7MmvmZqWIx/qrMfgzx7durrAkZ9LXNPlWNNouDpHFjGqMmYLLSJ2bJe6o5Y3efW5N0zc/MSoC4qelrqmJuwt5Jr4wHOjHSI7kEbnh+XkD4WPaT544vMVapa6rF05NLwi7F3RHPGD0z/A+ESci7Vu4lrVauRyczWb+PsDyjk4ycj6b4vOqagZbPMpA4fdLXYtjVkjMV8Me+jWYdmyGRzZ5cvSklDjn06rYwehR+s7D09iPtZbk7sKd+Jx+fYp9DrftpFBCnficfn2KfQ637aRTiPs2I7ycuFrxBjfsXEfdJlRZXp4WvEGN+xcR90mVFlawfov3kzCs3xOfF2Je0We7RKsis3xOfF2Je0We7RKvFegRDeS5pro1WxelJQt8pyE7onP5J/JvzikZKzJ2Ry8JjVH3N70e/wDXb19xdlwp6VuwTC58RbALJrvrt5F0phDuWnjhJ5QMfllymf5Jzyy2dKhjnNTfE8X/ABJ3Y1h0o1Wvqbi42uc7Xm96Pf8Art6+4pPwXD46lavUi1uSpV4q8WsdZ3JwxtjZrO8rtVozKr3zmpvieL/iTuxqftF8TN2jSuFgjN+nWsmMO1xGZ4WSlgfkNYDXyzyGeXQFFWNRemFbmK3ccLxrQ9mf2mZSHxSq4ZgD3jpnxOy93ytjrwj+SIKPOOF41oezP7TMpA4o9kPwKZnlrYpYYf48NaYH5Pxh+wq9P7BEL0jZcaOYt0atNH+us0mH5Bail/njCp+ricZyqZNGrpaMzXlpy5D0RbhY8/IGvcfkBVO1dwnodvyKZ7wrBcTOweVxmLPwTHQkA8gcHXGuI9ZBb+qFX1WE4mdZ2vjMxHg6lCJp8hdnce8fKBqfrBV4n7N+OciG8mvhMgEuC4vGf9ZhN9vyE1Zcj9RyP1KoXAf8IsH+mj9lIrd8KNnkcDxiT0MJvEfwjWlDR9biB9aqJwH/AAiwf6aP2Uix8P6EvHMVS3ou1ahbJG+N4zbKxzHDzteC0j7Co04uWlhv4UKVh4dewJwpT5nN8kUebK1jpJILGFhcel0Lz5QpPVGtFtK7GC4y+/XzdydqwyeHPJtiu+Y8rC4+TPIEHyOYw7csjao09uLRVJ2LWcNGgUePYc6Fuq27V1paMztmrLl4UL3dIhlADT5iGOyJYAoP4p1eSHSO5DKx0csGEXIpY3jJ8ckd/DmPY4eRwcCD8isxo1jVfEakF2o/lK9uMSRu6DltDmPH6MjXBzXNO0FpHkXFXNHBT0sqYtC3KPHKNrDreQ6LUUbLcMh/hw0nNJ89dvlcpp1GouDDWtzfcLvwfxv2NiHusqour0cLvwfxv2NiHusqour+D9F+8omdXwReO8O+dl92mVmlWXgi8d4d87L7tMrNLxn6UP7Rpf7K/wC8ze5T9k/4v5IIiLzQ2pw/DvMRhVOPyS4o959fI1C0D/nFQmSpo4e2H8GUX+RmJTMPyvrNcP5Iz9ihUlfVnACyyLD26r/HaZ5ln93jZ9n6IEryShKk/gM0DixF0l+4wSVKsnJRQvzEc87WiSR8+W01omOYS0flueGnYCD0uNxlPC0pVam5fi+hL2tmuw+HlWmoR3sjanRsT58hBPOG7CYYZJciPIeTaclkHR/EOo3tzs/4atu3EBE1scADWRgNbs1GADoEcEeTI2+YZFeDjVj0x+o3+5ee1PpIwsZNbDfu1+S/C66GzqIcF5tekVJOj+IdRvbnZ/w15/yexE9FG+fV3FZ/w1bY43Z9MfqN/uXk45Z9MfqN/uVr/wBSsL6uXw+ZcXBWfXK56I8E+LXpGGxC/Dqzj4U1phZMR5WwVDlNLLl0AgN9asEasNKpBh9ZvJxVmMYGZhzmMjzLRI4bHzOc58jj6T16mxWd2fh6ut06jWsJ+VzRmsBxXH8I+GNTMo+TgrQ6N3vvq7u2nMkm9G7NbzK8jjhXtPV+PdYErwShK8ErhzoUjYMP+aj1WnfyxNz/AJgsZZEX5r//AFn9i1Y6wM1+1j/BH9DD+8/eERFrCQiIgCIiAj7h/wDE5+mV/wCsVeyrCcP/AInP0yv/AFir2V799G39k/8ALL9InOZp9t2Ivrwf+KML9l0fdolXHjgNBxqmchmMIj25bfzu2rG8H/inC/ZdH3aJV043/jmn7Jj97trrcP8AafiYUtxChjb05DPz5BekRbItBERAd1wA/CbCPpE3udlXWVKeAH4TYR9Im9zsq6y12M9Ne75l2G4oJpl4yxL2ne96lWqW10y8ZYl7Tve9SrVLYLcWgp34nH59in0Ot+2kUEKd+Jx+fYp9Dr/tpFaxH2bKo7ycuFrxBjfsXEfdJlRZXp4WvEGN+xcR90mVFlawfov3kzCs3xOfF2Je0We7RKsis3xOfF2Je0We7RKvFfZkQ3nU8Z74M3vnqPv1dU7VxOM98Gb3z1H36uqdqnCeh2/Ime8FXv4MvEmD+x8P90hVECr38GXiTB/Y+H+6QqnGbkTAr9xwvGtD2Z/aZll8T/SBsdq/hr3Zd2RR2oAdgMkGbJ2jzuMb43ZeaF3mWJxwvGtD2Z/aZlEGj+Lz0LVe7VdqWKcrZYnHaMxmHNcM/Cjc0ua4eVr3DyquENujYhu0i+OkmExX6dqlNnyV6vLA8jpDZWFms3zOGeYPnAVFNLNH7WF3JqNxhZNXcRnkQyaPMhk8JP5cLwMwflByIIFzuDHT6lj1UTV3BliNo7qpucOWrvOw7P04Sc9WQDIjzEOaNxpHo3QxFjY79Wvbawks5eJrzGT0mNxGtGT52kLFpVXSbTRXJXKDRsLnNa0Oc97g1jGtLnvc45NaxrdrnEkAAbTmrmcX/Q2TBsHZHYbqW70rrdlnSYnPaxkcBI8rI2Mzy2axfln0rf6O6C4Ph8nLUsPqQTAECZsTTK0HpDZX5vaD5gVsdJcdqYbWkt3ZmV4IR4T3npP6LGNHhSSHLIMaCT5Aqq1fyi2UiIxsRzxptIG1MCdVDspsXnjrsaD4XIxObPYfl6GqxsZ+faq88CHwiwf6aP2Ui88LenMuP4g605ro68LTDTgcRnFBnmXPyOXLPPhOI8zW5kMBXrgQ+EeD/TR+ykWTCnsUmnvsylu7LvL+fWM/nNn6VP8AtXr+gq/n1jX5zZ+lT/tXqzg97JqEp8W3hF/Bdv8AB1t+WH4lKAx7j4NS27JrZMz+TDJk1jvIDqO2DXJti5gOWYB1TmMwDkfOPMdp+1fzwIz2edWt4tXCN+Eqv4MuSZ38OiHJvec3W6jcmteSdrpo82sdntILHbSXZTiqP312iEuY7vhd+D+N+xsQ91lVF1ejhd+D+N+xsQ91lVF1OD9F+8iZ1fBF47w752X3aZWaVZeCLx3h3zsvu0ys0vGfpQ/tGl/sr/vM3uU/ZP8Ai/kgiIvNDanOcKuHm1gdwNGb8PlhvtHl1I9aGw75GwzOd/FVeiVayCQNO1oe1zXMkjcM2yRvBbJG4HpBaSFBPCPwe2MOkfPVZJZwx7i6KdgdI6u07eRtgZmN7OjXPguGRzzJaPoD6LeEFKpg3gKkrVINuKf3ot306bPT3WOH4S4CflVXitGrP2NHDEqzvBFG2PRmhq7DOZy4+cvuWXO/kjYPkaFV7lW+cfaFaHgsdnoxhZ9cvvV1dTw4k1lk7eNGYfB1J4rs/mjcOK8EoSvJK+fD0dIErw4r9AJ6ATl5gT/Mvwxv9F36p/uTZk9UitWPBK8Er6GJ/ou/VP8AcvBif6L/ANU/3KPJy6CtNdJ8yV5cV9OReehjyfUxxP8AMsyvh+plJZBY0bWwnZLKfIC3pZH5yVVDDzlq1aK3yekUva/De5XehM6sILV9nO/ce5xqQQR/pODp3jzcpk2P69Ro+0LFX0szOke57ul5zPmHkAHqAAH1L5rSY/EKvWc4+joo/wAMUkr+1pXftbMOKdtd+99uoREWGVBERAEREBH3D/4nP0yv/WKvaszwrYDYxLDjWqhhl7oik/GP1G6rNbW8LI7doUS96LGfRq7x9xe1cAc7wOEyzydetGMvKSdpNJ2tHU0OY0Kk6t4xbVuYxqPCzpHBFHDFiUjIq8bIomCvSIZHG0MY0F1ck5NAGZJOxaDSrSa/iszJ8QsOtTRRCFj3RwxlsYc54ZlCxrT4T3HMjPauo70WM+jV3j7id6LGfRq7x9xdmuEuULVYiH4oweK1uqzgEXf96LGfRq7x9xO9FjPo1d4+4q+VGVf5mHeXzI4pW6rOARd/3osZ9GrvH3E70WM+jV3j7icqMq/zMO8vmOKVuqzjcDxWxRsRW6khhs1nF0UoaxxYXMdGSGyNLT4L3DaD0rr+/HpP8aS7tQ7Mvfeixn0au8fcTvRYz6NXePuKl8Jcoe/EQ7yJ4rW6rOFt2HyySSyO15J5HyyOIALpJHF73ENAAzc4nYMtq+S7/vRYz6NXePuJ3osZ9GrvH3FPKjKf8zDvL5kcUrdVnALd6J6V4jhL5ZMOsuqvsMayVzY4ZNdrSXNBE0bgMiT0ZLpO9FjPo1d4+4neixn0au8fcR8J8pe/Ew7yHFK3VZh4pwqaQ2oJq1jEZJILcMkE0Zr0miSKVhZIwuZAHAFriMwQdq4xd/3osZ9GrvH3E70WM+jV3j7ihcJsoW7EQ7yJ4rW6rOAXR6J6cYthMckWHW31Y55BJI1sVeTWeGhgdnNE4jwQBsy6FvO9FjPo1d4+4neixn0au8fcUvhPlL0eIh3kRxSt1WavSPhHxzEa76l29JYrSljnxOgqMDjG9sjDrRQtcMntadh8i5Rd/wB6LGfRq7x9xO9FjPo1d4+4oXCbKVuxEO8ieKVuqzgF2uHcK+kVeGKvDiUkcNWKOGGMV6RDIomBkbAXVy45NaBmSTs2rK70WM+jV3j7id6LGfRq7x9xHwmyh78RDvIcVrdVnMaV6UYhisrJsRsOtSwx8kx7o4Yy2PWL9XKFjQfCcTmRntWnXf8Aeixn0au8fcTvRYz6NXePuKVwnylaLEw7yI4pW6rOIw69NWlZPXllgmiObJYZHRSMz6dV7CCAfKPKpHwfh40jrtDXT1reXQ61VaXZeYurOiLvlOZ9a1/eixn0au8fcTvRYz6NXePuKmXCXKJb8RDvInitbqs3N7jBaRSNLWmhASMteGo8vHrHdE0jc/lBUd6SaRX8SlE1+1PbkbnqmV+bYwekRRNyjhBy2hjQCur70WM+jV3j7id6LGfRq7x9xI8JMnjuxEO8g8LWf3WcAsvBsSnp2IrVWQw2Kz9eKUNY4sfkRmGyNLTsJ6Qeldp3osZ9GrvH3E70WM+jV3j7iq5T5T/mYd5fMjilbqs8d+PSf40l3ah2ZcNNI57nPcc3SOc5x2bXOJLjs2dJK7zvRYz6NXePuJ3osZ9GrvH3FC4S5Qt2Ih3kTxWt1WcAs3AsVsUbMNupI6GxVfrxSNyJaci0ghwIc0tLmlpBBDiD0rsu9FjPo1d4+4neixn0au8fcU8p8p/zMO8vmRxSt1WecY4YNIbdeerYuMfBcgkgmZ3JUbrRSsLJG6zIg5ubXEZgghcEu/70WM+jV3j7id6LGfRq7x9xRHhNlEd2Ih3kTxWt1Wavgi8d4d87L7tMrNKFtAODbFKWJ1LU7a4hryPc/Un1nZOhkYMm6u3a4KaV5B9ImYYfGY6nPDzU4qkk3F3Se1N209jRusspyhTakra8/uQREXAGyC+led8Z1mOcw+dpyz+XzhfNFXCcoNSi7NbmtGvcQ0nozKN+X0m/7qL/AMFkmw99Ylxz1bDANjWgDk3nIBoA6SftWsWdBtqyfvLEbj6gWPaD9uxb3LcwxVao4VKspLYlpKTktIt7m2iy6UItNJLVbjGJXglHFeSVcZnJGXh+JSQBwYGnXIz1g79HPLLVcPOVknSKfzR/8z/EWoJWXgzA57/BD3she+KNwzD5BlkNX9LIaxy8uS2OEx2KWzSp1GlzLo3vRb2+hc70LFahSs5yjcyjpJY80f8AzP8AEX0sYnNJAyXWLHcu+P8AFue0FoY1wzBcduZWLigLoGySMEcvLajSGCMyR6hLs2ADMA6u3Ly5LxH+Zs+lyfsmK5isfiXRqJ1G06e0r/Va+tG11zPt3ap2ZY8lScVKMbPat09P4g35z/rpf94/+9Y5JJzOZJ6SdpPylfiLjKlepU9OTfvbf6l1RS3IIiKyVBERAEREAREQBEWLi1vkK9ifV1+5q802pnq63JRuk1dbI6uerlnkelVRi5NJb2Q3YykVY2cauUgEYJH4QB8au8u3qK/edTN8SR/8Vd2FdTyJzf1X5ofuMXj1Hp+D+RZtFXfRTjKyXr9GkcHjiGI36tQyjEnSGLumeOHlAzuNuvq6+ermM8ukKxC0+Z5PisulGOJjsuSutVLT/wBrZepVoVNYsIiLWF0IiIAiIgCIiAIiIAiJ/wBkARczwoaXx4FhVnE5InT9z8myOBrgwyzTSNiiYZCDybNZ4JdkcmtdkCcgYe4NOMbLfxOtQv0III8RsR1oZ600rnRTTODIWyxyj8Yxzy1us0ty1gcjtW5wWQ43GYeeJowvCN7u6T0V3ZN3dl0e5alieIhCSjJ6ssOiItMXwiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgC+9KxyZOY1mSN1ZGZ5azenYfI4HaCvgiu0a06U1ODs1u8bmuZp6NaPQiSTVmZr6Bf4Vdwmb6GYbM31OjPT8rc81hTRPb+W1zfU5pb/On/ZZUeITtGQlky8xcSPsdmtxHMcPP04uL/0fWXZGTTXfYjOpH2+/R/z/AENcXhfsbXkjUDi4HZqAkg+rV25rZfhSx/tHfYz/AMV5fiVg7DLJ9Ti3+jkp47hFzz7sV8fKP9Cvy8+qvx/8TwcPneQ+y8xNy/LncTIR5mRk67j6ti/bczSGMjBbFCCGA/lEk5ue/L9Jx+zYvg4knM5knynaftK/Fi4vMvKxcKcbJ+k29qUra6uyVr62S32u3ZFDu7bXNuS0SCIi1ZIREQBERAEREAREQBazSvxff+gW/d5Fs1rNK/F9/wCgW/d5Few/2sf4l+pTLcz+fOhVFlq9hlWXW5K7foVpSwhrxHYsQwyajiCA7VecjkduStmeLXo56eKb3F2dVK0PxBtS5h1t7XPZQu0bT2My13srTxTOazWIGuQwgZkDMhWfPGjwr4txT7aX+OvaOFlPN5VKfm/atZ7Wy0tbq17tGkwjo2flOy50OB8XzAKdqrchfiRmoWoLUQfajczla8rJo9dogBczWYMxmMxmpMxXGqVQsFu1VqmUOMYs2IYC8Ny1iwSuGsBrNzy6NYedRtwacOdDHcRjw2vTvQSzRTSiSc1uTAhZruB5KVzsz8ijrjwj8fgPzGJ/08PXBwy3H5hmVPB5lOSk4tpu0mlaT01tq49JnurTp0nOktLlksLxStba59WxXssY7Uc+vNHOxr8g7Uc6JxAdk5pyO3Jw86YpilWo1r7VivVY92o19iaOBjn5F2o10rgC7JrjkNuQPmUJ8Sgf6FxH22/3Civzjrj/AENhvtpnuN5YXmKHnfzftu21s7VtfRvuLnGH5HylubcTThWNU7ZeKlqraMWqZBWsQzlgdnql4icdUHVdln06p8y+eJaQ4fVfyVm7SrS6odydi3Xhk1Tnk7UkeHapyO31FV14jw/HY98zhf8ATxBcpxwmg6S7QD/oml0/OWlsqXBSnPN55f5R7MYKW1bV6Re6/wDqLTxbVFVLb3u/Et3imL1KsBtWrFevWAae6J5o4ocn7WZSvcGnW8mR2+Rc9hvCdo7ZlbDDi+Gvle4NYzuqNhe47A1heQHuJ2ADPNVU0Z0V0l0zZAWyRmngdavh8E1uWSGpFyELGasTGMe+a25ga+SQNOZc0FzRqNHK8I+gt/AbTaeIsi1pouVilge6WvPHrFjjG97Guza4ZFrmgjMbMnAnaYTgTgZTeHq4n+n1exC2i9qerdtXu/DUtTx1RLaUfq9LP6BrxNK1jXPe5rGMaXOe8hrWtHS5zjsaB5yoo4qOks2I6PtjsPdJLhFuSiJHnWe+BscU9fWJ2nVjnEYJ25QhQlxouEKfEsTsYXFIW4bhExgdExx1LVuIjl5ZwNjxHIHRtacwOSLul2zncDwWrYnMZ4Lasqbe3P8A08zS6ZXVlf8AQyamLjGkqnTuRZOfhY0ZY7UdjWGZ/vLUcjf14yW/yrf4LpJh92F9indp2oIQXSSwWYZY4g0EuMrmOIiyAJOtlkAqeaDcBWPYtTjvRCnVr2WCSv3bPLHJPG4AslbHBBIWxOG0F2RIyIBBBMncCvAzieFux996OuLFvBpcOw+SKcSQym22UzEnVD4wHRVhm9oPhuy2ZraZnweyjD05eTxV6kWk4vZet0mrK26+ursk7lqlia0mrw0fOaXjU8IFoXatbCsVcKUuHh87cNuMDXTmxO08pPVdr56jWeAXZZZbNq7TisaSUK+jsbLd6nDOb9572WbkEcx15sw9zZZA863TmelVr4QNBb+j88NTEBAJZ64nZ3PLyrOT13xbXFjcna0btnyLd6CcDuM43TbfotpGu+WWIGeyYpNeF2o/Ngidsz8ua67F5Nl7yinQdZRpbSfldFtv61r62d7vn5jChXqeWctm76OguXpVRwzFcMniuvgmw21CHyTcu1sIjYRIydllrtVmq5rXB4OQLVGnBrwWaI0MRhs1MRGJXYnl9SGbEqM/JSNa4mSKCoxhlka3WOb9bV1dYAEZraY/gs2HaAWqFnU5eho1PBLybtdmuyBwOq7IZj1quHFnA/yswbYP3S9/0u8uUyjLassBi5UcRJU4Of1Y+jNRje+/TaWjtvRmV6qVSG1HV27Nf5F5FptJNKsMw0NOIXqdLlBmxtmxFE9487GOdrPHyArmuHnTs6P4PJahDTctStqUg8azRPI173TPb+k2OKOR+R2EtY0/lKn2h+i+K6T4lJHATZuTA2Ldy3K4MY3MN5WzNqudtOTWtaCfIG5NOWvyDgvHHUJYvE1PJ0Y8/O7b9Xokt19bvRIuYjF+TkoRV5F08H4StH7kjYa2LYdJLIdVkfdUbHvd6LGyEF7vUM11hVIOFHgWxXAavdk7qtumHsjllrOkzgdI4MZy0U0bSI3PLWhzSdrmggZhSVxR+EexLM7ALsrpmcg+bDZJXF0kfI7Zqeu45vj5P8YwfoiKUdGqG5WZ8E6CwbxmX1vKQj6Se+y32atqt7i0tNblFLGS29ipGzLDYrjVKoWC3aq1TKHGMWbEMBeG5axYJXDWA1m55dGsPOvoMTrGubYsQGqGGQ2hNH3OGA5F/L62pqAgjPPLYq2ceAfj8C+YxP8Ap0FGmhOF6QaTVq2BUnNdQwUSTasj3QVIXWZ5ZxJbe0OMspe6VsbQ0kBrsmjJ7kwHBClicvp42dbYi23Pa3RinJaO+rbSSTtv7GqY1xqOCjfo9+hbZnCto0X8mMawvWzyzNuIM/3pOpl9a7GN7XNDmkOa8BzXNIc1zSMw5rhsII25hUO4UODDFNHeQN4V5IbjnMisVZHyRcowaxifysbHsk1c3AFuRDXZE5HKbuJbpJNNVxHC5XF8eGPr2KmsSeTitGZssLQfyY2yQh4Hnnf0KrOeCeGoYDj2Dq7cFa97O6b2bpq26W9NdPQKGMlKp5Oasye8VxGvUidPamhrQR/lzWJWQxNz6NaSQho+1co3hZ0ZLtUYzhufrssDf1z4P8qrDxptJbF3SG1Uke7uXBTHXrQ5nUD3QRSzzlnQZXPkLdbp1WMC2+iXFyxDEMOq3xiFOA4hWitRQOhmlyinYJIuUnY4APLHNJDWuAJIzOSu0OCmBoYOniMwruDqJOKitFdXS3Sb03vRLd7SJYupKbjTje3j2FssLxGvbibNVngswv8AyZq8sc8TvLskicWn7VlKDeLZwTYho/dxOziPc+tNXgr1nVZ3SxStMj5LD3NcxjgQY4ANdoPhPy6TnOS5DNsLQw2JlTw9TykFa0l7UnbRu9tz9t9DMozlKN5Kz6AiItaXQiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgC1mlfi+/9At+7yLZrWaV+L7/ANAt+7yK9h/tY/xL9SmW5n89tEcPFu3h1Rzixt+5Sque0AuY2zPFC57QdhcA8kZ7NiszzWqHxrf/ANxV/wDFVz4MvG2B+2MJ99rr+h5XrPDnOsZgKtJYaeypKV9E72a6UzUYChContK5EXBhwFVMBxKPEor9qzJDFNEIpooGsImZqE5xgHMdKj/jwfu+BfMYn/Tw9WdVbeO/ReW4HaA/FsfiFZ580kraksQ+tsE/6i5jgzmdfGZ3Rq4me1LZlFN2WmxOy0SW9sysVSjCg1FdH6o3fEp8S4j7bf7hRX5x1vE2G+2me43lwPFh4UsNwOG/SxR8kEVqwy3BOyGaw3lOSbDLFIyBjntOUURDgCD4YOWQzwuMhwqwaQOrUsOZI6hh8jrT7Ekbo32J+TdEHMicNeKvHHJJteAXGQ7GhoLt9HJsW+Ejr+Tfk1La2/u22LaPc3fSy17DH8vDiuzfXdbn3nT8R/8Ad8e+Zwv+niC5TjgfCb/2ml+0trquI+4d0Y63ymDDCB6hJfB/pD7VyvHA+E3/ALTS/aW1m4b+9Nb/AGl/1plEv6pH3/zZPHFYaBonheQA1n4iT6z+FLozPnOQA+oKNePE0cpgB8pZiwJ9QOGEfzn7VJfFZ+CeFfw8R/6reUa8eL8vR/8Ag4v/AD4Wudyj+9M/92t+lQya39UXuj/I3fEi8WYp7XZ7nXVX8feZrdx0jtU2Ltl0jz+iZZ5C9x+TWJ+pWf4kh/0ZivtZnuddV94X9H34djmK05Glre7Z5othAfWtvdYgc0+UakgaSP0mPHkXWZLVis7xsPvPYa9yWv6ow66fkKb95f6KFsbWxsAayJoYxo6GsYA1rR6gAAvSgjg14xGEvoQR4zJNUvVomRSvFaxYhsmNoaJ43Vo3uY54ALmOAycTkSMiu64O+FfCseu2qeHmdxp12TiWaLkWzsMnJyGGN55TVY50QJc1v7qNnlPlmMyDH4ZzdSlLZhvnb6tr2upbnf2fM21PEU5Ws9/NzkE8dPx1h/sdvvlpSrxQ/gxD7Qv/ALdRbx1Y3DF8NeR4L8JLWnyF0duYvHygSM/WC2PFw4XMHwfB5MPxOaSvLBdnmhLa1iw2aKcMfsNeN2pIJOUGTshlqHM7cu6xmErYrg1QhQi5STi7R1drzW5a72a+E4wxUnJ28Im3hw+DWO+yLn7FyqdxaPhZg3zl7/pd5Wf4Rscr4nobil+qXGvewK3LEXt1X6pieCHtBOq4EEEZ7CFWDi0fCzBvnL3/AEu8rfBenKnk2NhJWa8omnvTVPVE4tp1qbXs/Uk/jwzv/wBAxZnk3HFJSPIZGDD2MPyhssg/jlZfEhrs7lxqbIco+5UhcfLyccD5GD1DWmk/+hbvjiaNyW8Gr3oWF7sEtGSbIEubTssEU7wAOhsjKzneZrXE/kqG+LbwlV9H7tpl7lBQxSOISSxsdKa89cyclKYmAudGWyyNdqAu/czkQCrmCozx3Bd0MOrzi3eK3tqpt29+y00ufciKklTxe1Ld/wDlv1LS8M8DZNHMea8AgYJiEgz9OGrLNGflD42n6gqd8AczmaUYGW9Jv6h/gyV543//ABe5TXw78N+EWMItYdhM7rljFIu5pJBBYihr15chOXOsMYXyOj1mBrc8i/M5ZZGN+Kho3Jd0hht6p7nwOKSzM/LweWmikr1Ys/TLpJJB6q7lXwewtXAZLip4qLipKVlLR6w2Vo+s9Fff+BGJmqleChru3e87HjwfnGBfMYn/AE6C6XiUNH4GxI5DM408E5bSBRo5AnzDM/aVzXHg/OMC+YxP+nQXTcSnxLiPtuT3CgsXEf3Tp+//AO2RXH+uPxzIyuObGDo/WJG2PGqxafMTUvNP8jiuF4kfjDGfoFP9vMu945Xweg9s1fdrq4LiR+MMZ+gVP28yYD+6tb3v/vAVP63HxzM+vGg4KLzr82OYdDJbgutjddggYZJ680UbIeVbCwF0sD2RsJ1QS1weT4JzEX6BcK2O4IBDTt69eJxHcNxndFdhB2sa1xEtcZ/oxvYMydmatXpPw04HhmKzYVeknhkrMhL7LYXTV2yTMEghfyGtK14Y6N2eoW+H0jJR3xiNJ9DsTwueWKenbxfVYKMtRrjbEmu3ZPI1o/zbU19Zspy9Ea+qsnJMzxVSjSweOwjnSkoqE9m62XbZcrpx0X3rppa2bKK9KCk5052fOvad/wACHC5W0jZJC+IU8Sqs5SWtr8pHLDrBpsVnkBzmBzmhzSM2F7drgQTJipjxSoJH6TwOjz1YKF2ScjoERjbEA71GaSH7ArnLkeF2V0Mvxzp0PRcVK2/Zu2rdPNfXpM3B1ZVKd5b72CIi5cywiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCx8UqieCeAktFmCWEuAzLRLG5hcAekjWzWQiqjJxd1vRDIG0d4tFKlbp224nckOH261lkboK4a91aZkzWOLdoBLAM/Wp5RFsMxzbFY+SliZ7Tju0Stf3JFunRhT9FWC0Gn+iVPG6EuH3WuMUpa9kkZDZoJmZ8nPC4ghsjcyNoIIc4EEEhb9FhUa06M1Upu0k7premi5KKkrPcViscVixyh5PGIeS1thkw9/KhuewENs6rnZeXMZ+YKStC+A3CcNoXqhMlqxi9KanZvStaJWQzM1SyrEPBrsDtV+WbnEsbrOcGtAlNFvcXwrzPEwUKlXRNPRKN2tVeyV9ebcY8MHSi7pfzIx4HuB+HRuzZsQXrFru2s2CSOaGJjRqSCRkgMe3MeGMv/wBh8yxOFbgQq6QYh+EJb1mq/uaGvycMUL26sLpHB2cm3M8ofsUsosVZ/jliXi1U/pWtlytHdppa1uZcxVxens7FtOg53g20UjwPC62FxSvsMpmciaRrWPfy9may7WazYMnTEbPIAud4ZuCuDSY0TNbnqHDBaDORjik5TurufW1uU6Mu5m5ZekVIiLGpZniaWJeLhO1Vtvast8r30tbW75it0ouOw1p0HD8D3BzDo3Ws1obM1oXLIsOfMxjHNcImRaoEewjJgK/OFfguw3SKNndQkgtV2lsF2vqiZjCdYxSNcC2aHWzOq7oJJaWkknuUVXnXFcZ43tvyt77S0e63MrbtLWs+cjyMNnYtp0FX5OKxa1vBxmuWZ/lOw+UPy/gi0Rn9akzge4FKej1g3e67F266B0GuWtr12xyFpkDK7C5xzLG/lvdlqjIA7VKiLY4zhXmeLpOjVq/Vas0lGN17WkmW4YSlB3S1OF4YuDSppJWiimkfWs03PfVtxsEhjMgAkjkicRysDtRhLdZpzjaQRtzhutxWLGuOVxmER57THh8hkIz25B9kNacvLt+tWeRW8BwmzHA0vI0KlocyaUrX6Lp211tuuTUwtOo9qS1OIwng4r1tHZdHI7Fh1eetbgNiUROmb3Y+SWVzWsa1gAfK8hvr6SuQ4OuACpguKVMUjxG3YfRMxbDLDAxjuWrzVjm5m0ZCYn6gpmRWIZ7joQqwjU0qtupovrOStLmurrosVPD0207bt3sPMsbXtcx7WvY9pa9jgHNc1wIc1zTsc0gkEHzqBNN+LNQsyvmwu4/DRI4uNWWHuuszPpEB5RkkLc/IS8DoGQyAn1Fay7N8Xl8nLDT2b71o0/emmn77aE1aMKitJFaMJ4rLuUBuYuDED4TatItlcPM2WaZzWH1ljvkU9aDaJUMFqNpYfDyMLXF73OcXyzyuADpp5XbZJCAB5gGgAAAAb1FkZlwgx2YRUMRUvFfdSUVf2qKV+3dzFNLDU6bvFEc8MnBRX0lfSfNbnqHDmWGt5GOKTXFgwl2tynRlyDejzlbHgf4PYdG6c9OGxLabauOtOkmYxjg50MMOqBHsyyhB+srtUWPLN8XLCrBuf9Et0bLpvvtfe77yryMNvbtr0nH8LegkWkVBlCaxLVZHbjtcpCxj3l0cc0YZlJsyPLE5/vQtLwOcEVfRqe3PDcsWzehiicJooowwRPc8Fpj6drj0qSkSnm+LhhXhIz/onvjZa6p77X3pc4dGDnt216SE+Eni8UsUtWL9a9ZpWrsrpphK0Xa7pHnNzmse9ksYPQAJC1oAAaAAFxlfis2dYcpjFcMz2lmHyOfl5cg6yAD9as+i2eH4X5rQpqnCrolZXUZNL3uLf4lqWCoyd2jjOCvg3w7R2u+KmJJZrJabNyctM82pnqM8BobHC3Wdkxo8pJLjtXZoi0WJxVXE1HVrS2pPe3v8dC5lojIhBRVluCIixyoIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIqX867SLqmC7ve7cnOu0i6pgu73u3Ls+QeadEe8YPnGiXQRUv512kXVMF3e925OddpF1TBd3vduTkHmnRHvDzjRLoIqX867SLqmC7ve7cnOu0i6pgu73u3JyDzToj3h5xol0EVL+ddpF1TBd3vduTnXaRdUwXd73bk5B5p0R7w840S6CKl/Ou0i6pgu73u3JzrtIuqYLu97tycg806I94ecaJdBFS/nXaRdUwXd73bk512kXVMF3e925OQeadEe8PONEugipfzrtIuqYLu97tyc67SLqmC7ve7cnIPNOiPeHnGiXQRUv512kXVMF3e925OddpF1TBd3vduTkHmnRHvDzjRLoIqX867SLqmC7ve7cnOu0i6pgu73u3JyDzToj3h5xol0EVL+ddpF1TBd3vduTnXaRdUwXd73bk5B5p0R7w840S6CKl/Ou0i6pgu73u3JzrtIuqYLu97tycg806I94ecaJdBFS/nXaRdUwXd73bk512kXVMF3e925OQeadEe8PONEugipfzrtIuqYLu97tyc67SLqmC7ve7cnIPNOiPeHnGiXQRUv512kXVMF3e925OddpF1TBd3vduTkHmnRHvDzjRLoIqX867SLqmC7ve7cnOu0i6pgu73u3JyDzToj3h5xol0EVL+ddpF1TBd3vduTnXaRdUwXd73bk5B5p0R7w840S6CKl/Ou0i6pgu73u3JzrtIuqYLu97tycg806I94ecaJdBFS/nXaRdUwXd73bk512kXVMF3e925OQeadEe8PONEugipfzrtIuqYLu97tyc67SLqmC7ve7cnIPNOiPeHnGiXQRUv512kXVMF3e925OddpF1TBd3vduTkHmnRHvDzjRLoIqX867SLqmC7ve7cnOu0i6pgu73u3JyDzToj3h5xol0EVL+ddpF1TBd3vduTnXaRdUwXd73bk5B5p0R7w840S6CKl/Ou0i6pgu73u3JzrtIuqYLu97tycg806I94ecaJdBFS/nXaRdUwXd73bk512kXVMF3e925OQeadEe8PONEugipfzrtIuqYLu97tyc67SLqmC7ve7cnIPNOiPeHnGiXQRUv512kXVMF3e925OddpF1TBd3vduTkHmnRHvDzjRLoIqX867SLqmC7ve7cnOu0i6pgu73u3JyDzToj3h5xol0EVL+ddpF1TBd3vduTnXaRdUwXd73bk5B5p0R7w840S6CKl/Ou0i6pgu73u3JzrtIuqYLu97tycg806I94ecaJdBFS/nXaRdUwXd73bk512kXVMF3e925OQeadEe8PONEgJERe3mgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiID/9k=\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/u-OmVr_fT4s?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x1c4b55cc040>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"u-OmVr_fT4s\",width=\"100%\", height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by Suliah Apatira, Michigan State University  \n",
+    "As part of the Data Science Bridge Project \n",
+    "    \n",
+    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc/4.0/88x31.png\" /></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "116d24a5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Loops.ipynb b/Loops.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a3d07fdd22ed4cb279e71b6d781f9e0665011e9a
--- /dev/null
+++ b/Loops.ipynb
@@ -0,0 +1,256 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b64fb56b",
+   "metadata": {},
+   "source": [
+    "# Loops"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a4435deb",
+   "metadata": {},
+   "source": [
+    "# Short/Long Title: Loops"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb8f94bb",
+   "metadata": {},
+   "source": [
+    "# Description:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c94faf5",
+   "metadata": {},
+   "source": [
+    "Loops in Python are used to execute a series of code or statements back to back until a specific condition is true or satisfied in a list, tuple, or set. Once the condition is recognized as false, the upcoming line of code is stopped. There are a few different types of loops. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cec184aa",
+   "metadata": {},
+   "source": [
+    "# Types of Loops"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f14394ce",
+   "metadata": {},
+   "source": [
+    "A while loop is used to evaluate a condition before processing a body of code inside of a loop. If a statement is false, the body of the code will not be executed. While, if it is found true only the body of the loop is executed.\n",
+    "A do-while loop or exit-controlled loop allows for a condition to always be executed after the body of a loop.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39abaad6",
+   "metadata": {},
+   "source": [
+    "# Learning Materials"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "9ecc2028",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"640\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/dHANJ4l6fwA?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7fe0b87523d0>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"dHANJ4l6fwA\",width=640,height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "afdfe29c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"640\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/OnDr4J2UXSA?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7fe0b876efa0>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"OnDr4J2UXSA\",width=640,height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d4a0e2e",
+   "metadata": {},
+   "source": [
+    "# Self-Assessment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d56f121b",
+   "metadata": {},
+   "source": [
+    "Create a function to print the first ten even numbers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c55076ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n",
+      "4\n",
+      "6\n",
+      "8\n",
+      "10\n",
+      "12\n",
+      "14\n",
+      "16\n",
+      "18\n",
+      "20\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Put Your Answer Here\n",
+    "for i in range(2,22,2):\n",
+    "     print(i)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6abad683",
+   "metadata": {},
+   "source": [
+    "Define the function prime(num) : return false "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "eb447093",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Enter any number1\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'false' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [5]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m#Put Your Answer Here\u001b[39;00m\n\u001b[1;32m      2\u001b[0m num\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mint\u001b[39m(\u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEnter any number\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[0;32m----> 3\u001b[0m answer\u001b[38;5;241m=\u001b[39m\u001b[43mfalse\u001b[49m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m num\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m num\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m      5\u001b[0m      answer\u001b[38;5;241m=\u001b[39mtrue\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'false' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "#Put Your Answer Here\n",
+    "num=int(input(\"Enter any number\"))\n",
+    "answer=false\n",
+    "if num==1 or num==0:\n",
+    "     answer=true\n",
+    "for i in range(2,num):\n",
+    "     if num%i==0:\n",
+    "         answer=true\n",
+    "if answer==true:\n",
+    "     print(\"Number is not prime\")\n",
+    "else:\n",
+    "     print(\"Number is prime\")\n",
+    "\n",
+    "Assert(prime(11))\n",
+    "Assert(prime(3))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1474fb12",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Numpy_Sympy.ipynb b/Numpy_Sympy.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..2ea1428f857f46e33eb174951edda5b05d3c8bb3
--- /dev/null
+++ b/Numpy_Sympy.ipynb
@@ -0,0 +1,167 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4330cec0",
+   "metadata": {},
+   "source": [
+    "# Numpy & Sympy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac9dca34",
+   "metadata": {},
+   "source": [
+    "Long Title: Numerical Python and Symbolic Mathematics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b70901a3",
+   "metadata": {},
+   "source": [
+    "# Description:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d7d9d98",
+   "metadata": {},
+   "source": [
+    "NumPy, Numerical Python, and SymPy, Symbolic Mathematics, in Python library. They both are used in programming code that pertains to mathematical concepts. Numpy works with arrays by using functions for matrices, linear algebra, and fourier transformations. On the other hand, SymPy uses symbolic expressions to operate. It allows for computer algebra operations to be done either by itself or in a variety of other libraries.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "290ea33a",
+   "metadata": {},
+   "source": [
+    "# Learning Materials"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "8b19d1c3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"640\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/xECXZ3tyONo?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7fc5e0ccedc0>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"xECXZ3tyONo\",width=640,height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f2e77e51",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAUDBAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDhALCAgOCQgIDRUNDhERExMTCAsWGBYSGBASExIBBQUFCAcIDwkJDh4REhUXFxMXFhgTHhgSFRUSGBUWEhUVFRUXFRISFRISEhUVFRISFRUVEhUVFRUVEhIVEhIVFf/AABEIAWgB4AMBIgACEQEDEQH/xAAdAAEAAgIDAQEAAAAAAAAAAAAABwgFBgEDBAkC/8QAVxAAAQMDAQMHCAYECQkFCQAAAQACAwQFERIGITEHExdBVJPTCBQiNVFhcdEjMnSBkcEzQlKhFUNicnN1grG0FiQ0NpKisrPCJVOD0uEJRWNkZYS1xPD/xAAbAQEAAgMBAQAAAAAAAAAAAAAABAYCAwUBB//EADsRAAIBAgIFCAkEAwEAAwAAAAABAgMRBFEFEhUhMRRBUlNhcZGhBhMWMjOSosHRInKB8COx4UI0YrL/2gAMAwEAAhEDEQA/AKZIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiAIpX6Brv2m299VeAnQNd+023vqrwFL5BX6DOPt/R/XIihFK/QNd+023vqrwE6Brv2m299VeAnIK/QY2/o/rkRQilfoGu/abb31V4CdA137Tbe+qvATkFfoMbf0f1yIoRSv0DXftNt76q8BOga79ptvfVXgJyCv0GNv6P65EUIpX6Brv2m299VeAnQNd+023vqrwE5BX6DG39H9ciKEUr9A137Tbe+qvAToGu/abb31V4Ccgr9Bjb+j+uRFCKV+ga79ptvfVXgJ0DXftNt76q8BOQV+gxt/R/XIihFK/QNd+023vqrwE6Brv2m299VeAnIK/QY2/o/rkRQilfoGu/abb31V4CdA137Tbe+qvATkFfoMbf0f1yIoRSv0DXftNt76q8BOga79ptvfVXgJyCv0GNv6P65EUIpX6Brv2m299VeAnQNd+023vqrwE5BX6DG39H9ciKEUr9A137Tbe+qvAToGu/abb31V4Ccgr9Bjb+j+uRFCKV+ga79ptvfVXgJ0DXftNt76q8BOQV+gxt/R/XIihFK/QNd+023vqrwE6Brv2m299VeAnIK/QY2/o/rkRQilfoGu/abb31V4CdA137Tbe+qvATkFfoMbf0f1yIoRSv0DXftNt76q8BOga79ptvfVXgJyCv0GNv6P65EUIpX6Brv2m299VeAnQNd+023vqrwE5BX6DG39H9ciKEUr9A137Tbe+qvAToGu/abb31V4Ccgr9Bjb+j+uRFCKV+ga79ptvfVXgJ0DXftNt76q8BOQV+gxt/R/XIihFK/QNd+023vqrwE6Brv2m299VeAnIK/QY2/o/rkRQilfoGu/abb31V4CdA137Tbe+qvATkFfoMbf0f1yIoRSv0DXftNt76q8BOga79ptvfVXgJyCv0GNv6P65EUIpX6Brv2m299VeAnQNd+023vqrwE5BX6DG39H9ciKEUr9A137Tbe+qvAToGu/abb31V4Ccgr9Bjb+j+uRFCKV+ga79ptvfVXgJ0DXftNt76q8BOQV+gxt/R/XIihFK/QNd+023vqrwE6Brv2m299VeAnIK/QY2/o/rkRQilfoGu/abb31V4CdA137Tbe+qvATkFfoMbf0f1yIoRSv0DXftNt76q8BOga79ptvfVXgJyCv0GNv6P65EUIpX6Brv2m299VeAnQNd+023vqrwE5BX6DG39H9ciKEUr9A137Tbe+qvAToGu/abb31V4Ccgr9Bjb+j+uRZBERXI+MhERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBaVthyh01BI6COM1VQ3c8NeGRRn9l8mCS/3AHHWQdy2LaqudTUNXUM+vFTyPYfY8NOg/AOIP3KtpJJJJJJOSSckk8SSeJJUTE1nCyid/QmjKeJvOpvS3WzfaST0t1HYoe+k/wDKnS3Udih76T5KNkUPlFTMsex8J1fm/wAkk9LdR2KHvpPknS3Udih76T5KNkTlFTMbHwnV+b/JJPS3Udih76T5J0t1HYoe+k+SjZE5RUzGx8J1fm/yST0t1HYoe+k+SdLdR2KHvpPko2ROUVMxsfCdX5v8kk9LdR2KHvpPknS3Udih76T5KNkTlFTMbHwnV+b/ACST0t1HYoe+k+SdLdR2KHvpPko2ROUVMxsfCdX5v8kk9LdR2KHvpPknS3Udih76T5KNkTlFTMbHwnV+b/JJPS3Udih76T5J0t1HYoe+k+SjZE5RUzGx8J1fm/yST0t1HYoe+k+SdLdR2KHvpPko2ROUVMxsfCdX5v8AJJPS3Udih76T5J0t1HYoe+k+SjZE5RUzGx8J1fm/yST0t1HYoe+k+SdLdR2KHvpPko2ROUVMxsfCdX5v8kk9LdR2KHvpPknS3Udih76T5KNkTlFTMbHwnV+b/JJPS3Udih76T5J0t1HYoe+k+SjZE5RUzGx8J1fm/wAkk9LdR2KHvpPknS3Udih76T5KNkTlFTMbHwnV+b/JJPS3Udih76T5J0t1HYoe+k+SjZE5RUzGx8J1fm/yST0t1HYoe+k+SdLdR2KHvpPko2ROUVMxsfCdX5v8kk9LdR2KHvpPknS3Udih76T5KNkTlFTMbHwnV+b/ACST0t1HYoe+k+SdLdR2KHvpPko2ROUVMxsfCdX5v8kk9LdR2KHvpPknS3Udih76T5KNkTlFTMbHwnV+b/JJPS3Udih76T5J0t1HYoe+k+SjZE5RUzGx8J1fm/yST0t1HYoe+k+SdLdR2KHvpPko2ROUVMxsfCdX5v8AJJPS3Udih76T5J0t1HYoe+k+SjZE5RUzGx8J1fm/yST0t1HYoe+k+SdLdR2KHvpPko2ROUVMxsfCdX5v8kk9LdR2KHvpPknS3Udih76T5KNkTlFTMbHwnV+b/JJPS3Udih76T5J0t1HYoe+k+SjZE5RUzGx8J1fm/wAkk9LdR2KHvpPknS3Udih76T/yqNkTlFTMbHwnV+b/ACThsdyhU1fI2CSM0tQ7cxrnh8Urv2WSYBD/AOS4DPUSt1VWgSMEEgjeCDggjgQRwKslsrXOqaGkqH/Xlp43vPteWjWfvdkqZhqznuZXNNaMp4a06e5PdbJ9hk0RFLOAEREBgeUL1VX/AGaT8lXhWH5QvVVf9mk/JV4XOxnvLuLl6N/Al+77IIiKGWIIiIAiIgCIiAIiIAiIgCIiAIhU87DbF26Ghp5ZqaGeaWCOeaWdrZQDIwSFrA/0WMaDjcBnGSubpPSdPAwUppu7skj0gZFPzanZj22bH82k+Shi0xRSXSnYGtdBJcYWBmMsdC+qa3TpP6hYcY9hWvA6V5Spt03DVV9/Px4eAsYhFOPKvYqGG01UsNHTRSMdT6ZI4I43t1VMTDhzQDva4j71juRSzUdRb5ZJ6Wnnf53I3XNDHI4NEUJDQXg4bkk495UWPpBTeFeJ1HZS1bX3/wB3nhD6LO8o1PHDc66OJjYo2S+gxjQ1jQY2OIa0bgMk8Pap2h2VtjomtNBSYdG0EiCIOwWgEh4GoO94OVux2m6eFp06kotqav3bk/uelbEUo7F8njmXWobVx85SUZ+iMjcx1RkGYcgjS9rWElw4BwaN+9ZvlcsdFDappIaSmhkbLT6XxQxxvAdK1rgHMAOCCQsZ6eoLEQoQWtrW3rgtbgCE0W8citBBUXGVlRDFOxtHI8MlY2RocJqdodpeCNWHOGfeVKdzobFSujbU09sgdLnmxLBTs14LQdOW78FzfxC8x+nI4Wv6n1bk7X3AroimnlT2MoW0E1VTU8dNNTBr/oW82yRmtrXsexvo5w4kHGctxwKwHIXbKapfX+cU8M/NtpdHPRMk0azU6tOsHGdDf9kLKGnKU8JLFRi7Rdmue+7+OcEaot15aKGCnuLGQQxwMNJC8siY2NpcZJml2loA1Ya0Z9wUk8oOz1BFbK58dFSxvjgeWPZBE17S0jBa5oyClTTdOEaMtV/5OHZwW/xBAKIu+30rp5ooGaQ+aWOJhcSGh0jwxpcQCQ3JHAFdptJXZ4dCKfdkNhYKWi5mrp6Kpqi6VzpTEJW+kTzbQ+RgfpDQ3q3b8Lp5P9gYqOnkZXw0VXM+XUH83zwbGGMaGB0zAQdQecAfrBVyfpPhkptK9nZf/btXYj0ghFmNtLNJQVk0EnNas860QlxjDJcvY1uprSMA4xjqUz7IUNkqaeBkUFtnmZTQmZrYqeSVrtDQ4yjBcHa851dam47S8MNSjVUXJSy5u8EAIpG5crZTU01F5vBDAHxT6xDGyMOLXx6S4MABI1H8VHKm4LFLFUY1krJ83c7fYBERSjwIiIAiIgCIiAIiIAiIgCIiAKw/J76qoPszPzVeFYfk99VUH2Zn5qZg/efcV30k+BH932ZnkRF0SmhERAYHlC9VV/2aT8lXhWH5QvVVf9mk/JV4XOxnvLuLl6N/Al+77IIiKGWIIiIAiIgCIiAIiIAiIgCIiAKdNiNvrc+jpop6hlPPDDFDI2YFjXGNgj1sk+oWu05xnIzvCgsqcLFVbNCkpRILRzgp4BJzsNMZOcETdfOF7dRfqznO/OVXfSKnTnSipwlLfu1eK79z4npn3WGz18ZkbTUM7H5bz0DY85G4gTQ4c1w+KgnaCl/g25zRwuJ8zqmvhc/efQc2WLVjiR6IPtwVNrNrbHRxEQ1NHHG3LhFSNbvcd50xQD6x9uFBW09z89rKmq0lgnlc9rTjLW7msBxu1aWjPvyoPo5Cv6yopqXq7btbO/4vewJ/slypb3by4tBjnY6Gphz6UUmBrZniCCQ5rvZpK/TRR2O3frNp6ZpO8gyzSOJO8gAPme8+wD4Abop5FbzBSVdT5zUMgikpx+kdpjdIyRunju1hrn4+JXt5br9T1fmMdLVMnYzzh8rYn6mB55lsTnY3atPPAdYy72qBPQ01jeSpv1Tetz24XtfhfmuDQdoLi+rqKiqkAD53ukLRwbn6rAesBoAz7lZS513mtDLU6dfm9K+bTnGrmoi/Tnqzpx96q+/gfgVPW0+1VtktdXEytp3ySUE0bIxIC9z3wOa1gbx1aiBhdT0iwrm6EIRbSbW5cF+nw3AzE+11Fik5meKZ9ZPTwxRska54Ez26nvY06o9LNROoDfgdaxfLT6nn/pab/nMUL7HVEcNxoZZXBkcdVA973cGtbI0uc4+wBSnysbSUFRa5YYKyCaV0sBbHHIHuIbK1zjgcAADvXPnofkeNoKmnJXTbtw39m5WQRq/IL6zm+wy/8+mUmbZbG011fTuqJJ2eb6wGwmMB4kLC4OL2uP6g4Y4lRRyNXOnpbhJJUzRwRupJGB8jg1peZoHBuTuzhrj9yzHLLtLFM6i8wrdWltTz3m07gBqMHN6zGQCfRkxn3+1SdIYTEVdKL1TcP0+9bctzv+AbryvXGOC1VLHuAkqWtiiZn0nuc9pcQOOlrQ4k+4e0KLuSfaZlurHNmwKerDI5Xn+Kcwu5qQ/yAXuB9zs9S1GaV73anvc93DU9xc7HxdvX4XXwehKdHCyw83ra29vhla3da4LMXrZukrJ6WpnYXSUjtcZBGl4+sGyjB1sDwHgbt49hIOpcte07IKY2+Mh09U0GXr5qDVnf/LeWkAezUd27Pp5O9rKGO2UcdTXQMmjjcx7ZpQJGhssgjBDt+BGGY92FDm1FXz9dWTB5lElTM5khJOqPnHCLBP6vNhoHuAVf0RoupLFata+rSb1bp2bvut2X3+HMDHLKbJUVRUVtNFSljajnOchdIcMa+AGYF247vo+GDlYte6w3SaiqI6mAsEserSZG62DWx0btTRvI0vPBXaupOnJQ42dr8L81+w8LGysrvMNLXwm48w0GQjEHnOBrdgN/Rg5x6PUNyW5le2hxO+F9w5qX02jTBzx1mHg0egPowfR6juWr7ecoEFPSh9uqqaoqTKxukESgR4cXuc1pGBuA/tLnaLb6CK287TVdLNXc3T4jBDsyPMfPExA5aA0yHB4YC+Zx0fipxj/jX6p9Heu/duhv/tj0iTbSpq5K6fz5zH1MbhDIYwGx/RDSNAaBu+7rW5eT9/pVb9nj/wCao8u9dJUzTVEuDLM90j9I0jU7f6I6gp+td/sMDQYai2wEsa1xi5mJxAAOl2kAnf1FW3Tc508GqEad3JW/St0dW3NlkDSvKE/TW/8Aoqj/AI4lFysHfL/YqiKTnqi3zubFIGc5zUrhlp3M1AkEkDh1gKvbeA+C2+jtWTw3qpQcdXNWvdt7u4HKIi754EREAREQBERAEREAREQBERAFYfk99VUH2Zn5qvCsPye+qqD7Mz81MwfvPuK76SfAj+77MzyIi6JTQiIgMDyheqq/7NJ+SrwrD8oXqqv+zSfkq8LnYz3l3Fy9G/gS/d9kERFDLEEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAVh+T31VQfZmfmq8Kw/J76qoPszPzUzB+8+4rvpJ8CP7vszPIiLolNCIiAwPKF6qr/s0n5KvCsPyheqq/7NJ+SrwudjPeXcXL0b+BL932QREUMsQREQBERAbVyRUtFPfrTDceaNDJWxNqRO8RwmM5w2V5IAYXaQcnBzjrV4rdySbG1LOcp7RaaiPUW64Q2VmoYy3UxxGoZG73r55q8XkQjGy24f+8qzh8IVCxiaWsn2HS0fJNuDXaah5U2xmytusVQ63UtrpbnHVUkbGwSMbVDVK3nWc0Haj9CXEgjgM9WVoPkbbI2y73K5R3OjhrY4aKKSJk4Lmse6cNc4NBxq0jGfitN8pYD/ACuvpxv87j/wlMpO8gf1rd/6vh/xKNONBu/b42Ckp4lK3Dd/s9vlTcgsVJTSXqwU/NQ08RNwt8Qc5rI2Anz2maSSA0D6Rg3YGsYw/MlbbckezUOzdwqYrPRsqIbJVTxzta7nWTR0L5GSh+c6w9oOTx61JdTtfRR3eKxzP0VlTRGtpg/AZUMZLJHNFGeuZgYH6OJaXEZ0Ox5+Vxgbs7fWtAaBZbkAAMAAUUwAAHAYUT103qpsneoprWaRSfyW7XaKy/czem0klH/B9S9ra2RkcJqGyUwjwXlodJzbpiB7A443brc27kk2NqWc5T2i0zx6i3XCGys1DGW6mOI1DI3e8L55YyFeLyHxjZc43f8AadZ/wwKVi4tfqT7CHgJp/oa7bnfyjcn2xFJbroPMrLTVcNDVuYOeijqIphTPfCWtLw9smosI3ZOR7VW7yT9nKG67RMpbjTR1dP5hVy8zMCWGRhhaxxAIyQHu4+33BeHypGj/ACxvpwM8/Sb8f/TaJbL5E3+tTf6trf8Aip17GLjSbvxVzGU1Ouo2tZ27yyd+5ONhKAwiut9jojUv5qnFXJFTmeT0fo4edeOcf6Tdzcn0gtC8pTkQscFirLnbKNlvq7exs/0DpBDPCJGtmikhcSwO0Oc5rmgHU1oJwSFL3Kdya23aIUYuPnBbQyumhbBLzQc5+gOEnokubiMcCOJXbyx7KVF7stda6aqbSSVUbW866PnGuDHtk5l28FkchYGOcMkNc7AKhwqtNO/edCpSUotaq7D56bAbPuu11t9ta/m/PauGndJuJjje4c9I0Hc57Yg9wB4kAdavPByTbFWSj5yrt1qZTxaRJW3nmJsucQ0OlqK8ljHOcQA0aRkgADcFT3yfoXR7XWSOQaXx3LQ9uQdL2Mla5uRuOHAhWn8tj/VWT+sKL/jepeJbdSMU9zIODSjTlNq7X2MzWckexd8oucpLfazBMHCGuspghw5pLC+Kei+jkLXtIIcHNy0gg7wqJ7Y2V1tuNfb3u1uoayppOcxjnBBM+NsuB9XW1odjq1K7HkXf6pU32y4f4l6qLy6/6z3/APrWs/5pTDNqco3vY8xqi6cZ2s2aWVebk05P9iKu2WnNFZqirnoKN0g56KSokndTMfNqbrL3SatZIxncfYqNKRvJiaP8r7EcDPnM+/G//QatbsRByjdO1t5HwlRRnZq99xce48kmxtMznKiz2qCPIbrmDYmajwbqe4DJwd3uVSPKptlnor6yKyMpGUn8G0z5GUUjJIRUmaq15LHENkMTYSR7C09eTY/y3BnZV39Y0X98iou8Yacbtx/uWnCRb/U32EnHzS/Ql23Ly8jHINs/S2qjqrjRQXGtqKWGpqZa0c9BEZY2ymKGB/0TY2B2NZaXHBJPADY7TsVsFeGzR0FBszWiINExtjaB0kOvUGa5KA64idDsHI+qccFsTP8AVkf1EP8A8eq4f+z+H+e3v7HQf82pUZa0oym3wJf6YOMFHj9iN/KY5PKfZu9ClonPNFVUsdZTskeZJINUksUkBkd6UjWui1Bzt+JACSRkxerEeXn68tv9Uj/GVCruujQk5QTZyMTFRqNIm/ySuS6g2iq6+a5h8tLbW0uKZr3RtqJqo1BHOvjIfzTG059EEajI3fgEGyN05ONg6N4iq6Gx00mkOEdTNDFIWEkB+mV4cWktIz7iq++RpyiWyy1NzprpUNpGXBtG6CplyIGyUpqg+OaThFqbUNIc7Dfo3AkEtBs3cbFsltJIJ5IbLeJuaDGzxupamoELC4taJoSZBGC9xAzgaj7VCxMpKpvbsdHBxg6Sslcqh5Wdp2fpK22tsDbe2N9JM6qbb5o5WaxM0RGQRucGO068cM49yl7yXuTHZ+5bL0FbX2qkqqqaWvEk0zC57hFX1MMYzncBHGwYHs+KjfyteSO2bPtoa+1NfTwVc0lNNSOlkmYyURmZksL5i6RrS1sgLS4gYZpxvW9+RHyi076Q7NT4jqad1RU0JJwKmCaR89REM/x8ckj3462PyPqOK2TbdFOL/JhTSWIamlv8CJuTbZa31HKFJap6WKS3Mu19gbSP1GLmqVlwNPGd+XNYYo8An9QZyt98srYCzWi222e2W6mopZbg6GR8DS0vjNLNJocM4I1Mafu95U9WTkotVJtBV7RxMf55VxaeaJbzEE0gAqamFgGWzyta0OOeuQj9I7NbvLV5RYLjWwWWkLZIrVM+SrnByHVzmGIwRkbiImOeHH9t5bu0HOMKjqVI6vMt4qUVSoy1uLe4zPkbbAWa72y5T3O3U1bLFcRDG+dpeWRClgk0tGcAa5HH359wXi8p/kN82rLbU7PUOmG4TR26Wkga8xQVryfN58DVzNPIzUHu3NaYQeL1ufkD+p7r/Wv/AOlSqabVtrRT113t7pY4ai0TU8c7ZZGM1xVNBTV0dQ3J/RfTvjyeuB3uWFSrKFVtG2nRhOjFM1PZjkF2ZpaOmp57VSVk8MTGTVc8ZdLUSgDnJXb92p+oho3AEAbgqG7e07Ke4XWGFojip6+4RQsGSGRw1MzI2gneQGtaN/sX0m2C2ngvNBFcabPm88tWyBx/jIqarnpWTD2NkEIkA6g8BfN/lO9a3v8ArO6/4yoWzCSk5SuzVjYRUY2RfWfkf2PggdNPZrZFDDEZJZpgGRxxxs1PkllkdhrQ0Elzj1ElY08jWxN2pXOo6GgfE/UxtXa6kgskbx0TUzywvacei7UOogjcpB2wsbbna662ukdC2voaijdK1oe6JtTA+EyNadzi0Pzg+xa7yJ8nEGytumoYaqSqbNWSVsk0rGRYe+GngLWtZuawMpmHeScl3uAiKbtfWdyc6avbVVijbdk20O1kFkqcVEUW0FHQSatwqKWSvhjBeG/VMlO8EgHcXkZ3ZVlfKb5MNn7dsxcKyhtNJS1UL6Lmp4WFsjecrqeJ4BzvBY94wfaq38p21DH7WV93oXMlZDeW1dK8nVFMaKaMxSAt+tC98AcCDva4K79iudq212ec7SX0dxhfBUwOI56lqG41xuI+pPFKGva7rxG8biCZleUo6kvE5+HhCSnBcd9iD/I65PbJd7JW1NyttNWzx3eanZJOwuc2FlDb5WxjfgN1zSO/tqC+Xm0U1BtLeKOjhbBTQVLWwwszoja6nhkLW53hup7jjqzjgrxWC12jYjZ9zTI6OioGPnqamTSZ6qeRwBe4NwH1EkhjjYwf/DYNwCoHygbRvu90r7nIwRural8wjBzzUZwyKMu/Wc2JrGl3WWk4GcLLDyc6kpcxji4Rp0ox5zBoiKac0IiIAiIgCsPye+qqD7Mz81XhWH5PfVVB9mZ+amYP3n3Fd9JPgR/d9mZ5ERdEpoREQGB5QvVVf9mk/JV4Vh+UL1VX/ZpPyVeFzsZ7y7i5ejfwJfu+yCIihliCIiAIiIDaeSSGhkvtpZcuZ8wdWxCq85cGU5j37pnOIaI9WnOTj27sq+ezF/2StkHm1vuNho6fW6TmaevoY4+cfjW/SJPrHSPwXzjXGB7Ao9bD+sfGxLw+K9Uraty23lYRbKTWerrqCSzTXmaro3GekqaaWtl+kYyUu5l5c9vMNIORgBo9gWleRHfaKhud0dW1lLRtkoImxuqqiKna9zagFzWOlIDnAEHAVfsIQiof43C4eKvUVSxYHyzNqYJb5aqu03CGaWkoGvjqaGpjmMFQyrmkjIkhJDZBgHB6sbsFWC5Qtv7NUbNXRovFrknnslY1sbK6kMsk0tDIAxsTX6i9z3ABoGcnGF8/QuMBYvCpqKvwMo41pyduICuT5G+1lqo9nHQVlyoKSYXGqdzVTWU8EmlzINLtErg7Sd+Dw3H2Km64IW2tS9ZG1zTh6zpS1rXJC8pC4QVW1d6qKaaKogknpubmgkbLFJooKSNxZIwlrgHsc3IPFpWweR/d6Wi2mZNWVMFJCbfWRiWpmjgi1uMBaznJSG6iGuwM9RUPIvXTvDU7LHirNVPWW57lpPLd2poKynszbfcaWqeyesdIKKrinLGmOANMnMOOkE8M8cFSlyAbdWiLZmzRVV4t0U8dG2OWOouFMyaNzHvbokZK8PaQABg9WFQgBMLQ8KnBRuSI41qo5249puGy20sdt2lguuOehpru+pcI8OMlOal/OGLeA55he4tycE6epXplvuy21FAYJKy3XGjl5uR1O+obHKxzSHsMkLnNnp5QeohpG9fOdcOaDxAPxGVnVw6nZ3s0YUMW6d1a6Z9GP8o9ltlreIGVlut9JCJHx00U7ZZXl7nSP5qBrnTzyOcSdwcVQLby9i5XW5XANLG1tdVVTGOxqZHNM98THYJGtsZYDjdkFYRrQOAA+AwuUo0FTbd7nmIxLqpK1kgt+8nWvgpdqbLUVM0VPBHUSmSaeRsUUYdR1LGl8jyGtBe5o3ni4LQUW6UdZNGiEtWSlkXL8sTa21VmzZgpLnb6qY3CkcIaasp55C1vOFztETi7SBxPBUzcMgj2oAuVhRperja5sr13VlrWsX75FuVWxXe0UdNJW0kNXHRw0lXQVUrIZC+OFsUvNtmwKmBwGQ5moYdg4IcBmtmrTsls22ononWq1tnDOflNZG0ObHqcxuueQ6WDW7DW4G/gvnSRnjvXAYBwAHwAUd4NX3S3EuOkHZXjdku+VXt5R3++Nlt7+dpKKkZRsqNLmtqJBLNNLJGHYcYQZQwEgZ5txGQWkxIiKXCCjFRRBqTc5OTJ68ke2bM1H8Mf5Qi1FzDQeaC5zQRei7zzn+YE7gHbxFqxn9TPEKxWzlNsDbahtZQS7NUlUxr2MnhrKBkrWyDS8NcH5AI3FfPohNI9gUerhtdt638EmjjPVxS1b9pZDyzOUu13ZtvttsqI60Us8lVU1MDtdO15iMMUMUo9GZ2HyOcWkgYaMkkgV9sNxlpKqmqoJXQTU88U0czDh0bo3h2oH2ccjgRkHIJC8SLdTpqEdVGirWc567PoZym8pNqisd3lob5bPPWWyufR8xX0ck3nQppDT8zGHkvl53RgYOThfPMkneSSSckkkkk7ySTvJz1rjC5WFGgqaZniMS61t1rFsPIi2nttDarnFW3Cho5H3ISMZVVUFO98ZpKdoe1srgXN1McMjraVCnlO11NWbW3moppoKqCSSh5qeGRk0T+btVBE/RIwlrsSRvacHcWEdSjkhcr2NHVm534nssS5U1TtwLzeTDtlZ6bZS009TdbbTzxtqxJDPXU0MrCa+qeA+OR4c3LXNIyN4cCqW8oczJrleJInNkjluFykiewhzZGSVU7o3scNzmuaQQRxyFisLleU6GpJyvxFXEucYxtwPoPyn8otpGz93fRXy3ir/gmtNIaa5U3nPnJpJPN+YEb9fPc4WadO/OMKjN425vdZE6GrvF0qYXgtfDNX1UkT2ni18bn6Xt9xBWu4XKUcOqfaK+KlVtzfyFPvkT7VxW+63CCsr4aOint5l01VRFBBJVw1FOyNzXTEN54QyTDAOS3jnSMQEi2VIa8XE1UqjpyUkWb8uHbGnrWWakt9ypqumzWT1UVHUw1DBMzzZlK+bmScENkqQ0E9bj1bqyLgBcrylT1I6p7WqupNyYREWw0hERAEREAVh+T31VQfZmfmq8Kw/J76qoPszPzUzB+8+4rvpJ8CP7vszPIiLolNCIiAwPKF6qr/ALNJ+SrwrD8oXqqv+zSfkq8LnYz3l3Fy9G/gS/d9kERFDLEEREAREQBERAEREAREQBERAEREAREQBERAEREARF67bbKipeGQQySuJwAxhK8ckt7MlFt2R5EW50ewoY4fwlX0tBwzCXOqKrJ6vNqYPlBPvaPuW+2bY2xiJ0cdq2iucr24FQKaGhgB45Yahxc4buJAXOr6Vw9LjK/98CVDBTfGy72Qeikeq5K7hPK4UdBOxoJ9CWqonvAB6w1wXRV8kF8ibqfSFo4ZM1IN/s3y8VgtN4LrEa3hprt/kj9FusnJbew0PFDM5p4FnNSA/Dm3uysLcNk7jT556kqIwOJfDKxv+05un963U9J4Wfu1E/5MXQmuYwiLsfTvHFp+7ePxC61NjOMleLuammuIREWR4EREAREQBERAEREAREQBERAEREAREQBERAFYfk99VUH2Zn5qvCsPye+qqD7Mz81MwfvPuK76SfAj+77MzyIi6JTQiIgMDyheqq/7NJ+SrwrD8oXqqv8As0n5KvC52M95dxcvRv4Ev3fZBERQyxBERAEREAREQBERAEREAREQBERAEREARFvvIvsnHd6uWB4jLmRmRnO85oJHUTGcj44PwWnEV40abqS4I20aLqzUI85pFJSSzODYo3yOPAMaXH9ykjY3kOvtx0vMHmsLsHnKj0Nx62h2933AqweybYrM1rX7OsYG8au3EVh97ublxM37gAtop9qaKtla6mu7ad0f6SkqI4ow7HFsjZWtlBx+y449i4FbTc5L/Et2fE7dLRMI/Ed/Ihmv5IbFs7TMqrtLNcamR3N0tBTjQ+qnx+jjzk6Bkan4AaCOJIB9Vs2YknYHXCohs1E4eha7c4U+Y9+GVFTnn6rOcHLtORux1ZXZaf8Ahmvqtoq0Zp4i6ntkRzoipYnFmtgcAdcrw55JGfSxwwtO5VdoJGzO0luuYa27/wBBF9UHHDPokD+aVWsVpCviKvqlPvfbksu8j4ivGn+mmrLs5+/nNhvNwtFnYyOgggpzv1vAaamQADSd2ZS3628+5Yp/LJJGzTpe8gnBOiLLereNRJ49S0fZfZasuc0ccYkc6be0DfNIOuR7n7oo8b9Tvkpt2c5I7TQOiZXzB9VI0vbBE4RtcGkBw84lw+Q5PUWe4YC8WjqaV6ru/Myo4OtU/U3Yi23coVayQSRU0xAyG734AcCN79ADtxKy0m3F3q2hv8H1MoByOakyQeH7DlPVJb7TQY/7OFNjhNJSPmAHtdVASaR73OCz2GVEbXRTuETxlr6Z7AHjqLZGgkYI/VI96zeGw7/8+ZLWjIpWcn4lfbXt1c6drInWi6MwSGtNNJIXknJ0amN5zeT9Vei37aSUZkfVW66xB/1jV2uqjZxJyXBp1HfxU2z0da0aY6iOpYTh0dbCz6vX9LThv72O9/tXmu8tPRRPe+sgtz9PoYkIib/9q92iUfBgK0vAUZcIvxMtnRXCbILuG0Wz90qGc62g0EtDtYjilG/0xmQNk1nfjB9i8G1/JPZpojPQVboXEgNikxKw54YeSHtG7jqPwKk667W2yth5p1ubtBIRgzC3xwUrurdPUkhrs53gj7lFG11oltbH3Glght9PzsbX22Oomq4ZBI7BLxPlsbt3FhPuwtsMLVo76NRxeTfH+9xHq4OUYtp63ev6jRLzyRXiAB7IOfhcA5skDmyNIIyMjLXA4I/V+9YqHk8ur9wpZM+zDQT7gHOBJ+CsTY610zY3U8x0SN1MOo6dOM4xvwRjGPcV7zbdLXvedbsOcA3dv3nOeJ3r1elGMgtV28N5yf0y3qPn/wBKjXS2z0z3Rzxvje04c17XMc09WprgC3715FYzbGGG56qCWLMzWF0FW5vpMdpyGF/60R62nPt6gVXy50boJXxPaWuY5zS08QWktc0+8EEfcrbofS3K1qzWrK1+9ZownBJXR5kRF2zSEREAREQBERAEREAREQBERAEREAVh+T31VQfZmfmq8Kw/J76qoPszPzUzB+8+4rvpJ8CP7vszPIiLolNCIiAwPKF6qr/s0n5KvCsPyheqq/7NJ+SrwudjPeXcXL0b+BL932QREUMsQREQBERAEREAREQBERAEREAREQBERAFMfko+tJ/s7/yUOKY/JR9aT/Z3/kuZpn/4dTuJ+jP/AJESzxON53D2laPy4OiZZ6lzoYpKiXmqSmc9jXPZLUyNi1RvIy1wYXuGP2VuFypGzwywP+rLG6M+7UMZHvHH7lXbbOqngloaWeSXm4bnE58Re4xh0D9JIa44G5xwR1L59haetK6fDeWvEy1acn2G+Vr3UdupaOE83E1jN+Bl+kFuST1ej1e9RDtXPJLXuL4zNhzMxtLW64442HA1bsZ3kde9T+2kZV24DS2R8Dy4ZAJ0nf6J94woq5QLQ5skVdCwu5saKiJgy7m8ECVrRvIaCAfc0ewrVo6vFVN6379/ayp091WDlwdv74kh8i9ytdJStfLUVFuraslx85jLI3Qgnmo4zO10fN7tRLS3Jfx3DErmSSaInRR3CEgn6Nwa127cNEnORu+OsfBaFyYVtPXWekAMU7GRmGRh0yAc29zA2SM50ksDThw61geUGx01PPbWUzHUzKyrdDUx08ssMcsQic8N5uNwaz0gN7QCupGvGpUcGrPf2rd4FqtaN1vJBn2is9vjAqH0tJKeNLTSmc6v2RHAAC73FoWJqOUSZ40Wy1S6AMMlrdNHA0DhiD9I5n80LC261U1N+ggiiJ4uawa3fzpD6TvvK76yobFG+R5w1jS4/Ie8nA+9bNeK4K/f/wAMd7Ousq7xV585uXm7D/E22MQ49o84ly9w/sheOk2do43a+ZEsuc87UOdUSZ9odKTpP83C81xZVyQRyRl/PyPYQ1khZHAxwLhkAgSH6oJdnicAbln146smNVBaXyz+qZf6SP8A6lui0zln9Uy/0kf/AFLPDfFj3oxqe6+40DkMvjnOkhLuDBMxud2tjg2THxDm59wClW67TMgLdWloe7SzUCSTu9hHtG7iqoWyvlp3tkhe5j2kEOaS0g8MgjeDjI+9bpTcp1XhonjgqNPAyxAu/GMtH7lu0p6O1JV3Upq8XzXsyqRmnvvbMnI4J1YGT1gdXHcfYot5atlct/hKLGC5sc7esSFp0SfBwbpPva32ldtp5W4XHFTTlgx9aJ44/wAyTAx/bWK2/wBv2XCEUVM3m4nP5xz5CNcj2tcI2HSS1jBqJ4kk44Y38/R+BxuGxMZarVuL5rc57QpSlPVXPu4rf/0jJFy9haSCMEbiPZ+C4X0lO/AjNNOz3BERDwIiIAiIgCIP/T7zwC3bZjk3raoNkqD5nCcEc40uncPdDkaN3W8g+4rKMHJ2SNNfE06EdapKy/viaSv3BE6Q4Y1zz7GNLj+Dd6nizcn9rpgMwCpeOL6kiXP/AIZHNj/ZWzwRMjGmNrWN/ZY0NH4N3KVHBvnZwa3pJTjupwb73b8lbWWKuO8UVYR7RSzn+5q6qi2VMYzJTVEYHEvglYB97grNJlZ8iWZGXpNLq/P/AIVZBXKspdLFRVQ/zilglP7To26x8JB6bfuK0jaDkqgeC6hmdA/iIpsyxH3B/wCkZ8TrWqeEkuG8n4f0hoTdppx815b/ACIiVh+T31VQfZmfmoKv9iqqCTm6qF0ZP1H/AFopP6OQei74cR1gKdeT31VQfZmfmssImptPI0+kM4zw8JRd1rfZmeREXRKeEREBgeUL1VX/AGaT8lXhWH5QvVVf9mk/JV4XOxnvLuLl6N/Al+77IIiKGWIIiIAiIgCIiAIiIAiIgCIiALljSTgcSuF2UzsPafYV4+B6d7bZOd4ie7+aNX7m5K6p6WSP67Hs/ntc3/iW8bN3FzC04DvcQMH3KY9lLjRSNbzsPouA3FocN/uCr2O0vVwr925uhGD4sq+QVMXko+tJ/s7/AMlI962c2ZrXEeaNydzpoWticD7QWFrnALxcnWyNNZ9onQ0sj5Ip7d5wC8g6db3tDWkAEtw0Hfv3lcyt6QRxeHnScHFtX7Nx0MBRSrxkncmRQj5SNkLRFWxjcXtMmOp7BoJ92WmM/wDhuKm5YXbeztrqGopy0OJYXMHte0H0f7QLm/21XMPU9XUTLPUipRcWRjyX7Wl0ALCDLGzTJGf12gYY4Dr37vuXtlooaoGaOTTId7j16veOIOVD8FLU0E7jC52qM64yBvkhO7IH6xB9FzfeMdWd82Y2wp5XNdIxsc+702jLXEdZb1/vPuC3V8L6qTnBayfkVHEUZUZaslePN/w2eTk41BlTGJaWqcwF1RRSyUsxzvy4ReiSeJyOtY672O+h9O43F1V5pKZoI66nY/Dy0sOuenAkcC09a3O1bYFw4tlHWWkE/eDvB+JXmvm1LZpDGSY2MDcgbi5zgDkn2b8Yz1KDQr4hTUU/H/pnCsoq0JtdhrjNrrhB/plpe9o4y2+Zs/xxTyaXj8V03ja+hro46eCbTI+ZolgmY6GZoHBpZIBn0iOGeC2zZ+eCaURPdrY8OxqOSwtaXAguyAN2Me9ezaLYGjrGYfHHKMejrALh/Mfxb9xClPH+rlq1Y+H/AEm0sZWW9pS/2dmMbvYutsrS4sDmlzQC5oIJaDwyOI4LS6m1XaynNM99fRt+tRVL8ysb/wDK1J3jG7DXZG7AyVk9krxTV0089NloMMQljczm5YphJNrZMzqk4b9+faVNp1I1FrQdzoUcRCrw45c5sq0zln9Uy/0kf/Utmqa7S5rQwnXJzTX59HnME7xxLAA7J/kkLUeVeSR1lkMrQx/Oty0DG4PkDTjJwS0A4yeKlYX4se9Gyp7jKyBcrgLlX8pYREQAn+4D8Bj8kREPW7hERDwIiIAvTarfNVTMgp4zJLIcNaPdxc4nc1oHEncF1U0D5XsjjaXySODGMbxc5xw1o9+Sp82A2VjtkGCGvqpQDUSj28REw8eab+8jPsA3UaLqPsOdpLSMcJTvxk+C+77EeXYfYWnt4bLJpnrOuUjLIiRvbA08P559I+7gtvRF1YwUVZFCr4ipXnr1Hd/3hkEXC9Vzon07xHIMOdFBL/ZnhZM0fcH4+4r26vY1KLacuZffh/o8yL1UttqZRmKmqJR7YoJZB+LAV+Kqhni3ywTRD2yxSRj/AHwF5rK9rmXqp21rO2dtx0IuAVysjWee4UUNRG6GeNksT/rMeMg+w+4jqI3hfm00MdLBFTxZ5uFuhgcdRDQTgE9eOH3L1IvLK9zPXlq6t93G3NfMIiL0xCIiAwPKF6qr/s0n5KvCsPyheqq/7NJ+SrwudjPeXcXL0b+BL932QREUMsQREQBERAEREAREQBERAEREAXMZ3hcIjBnLfUYx9Ye8LcrNftAAE0jcDG/LurHvUZBxHAruirJW8HuH3n+5cfG6NlX5zZFrnJdo787c3Ux54AEaSfhjC3jkwrTNe4tWrMdrdGdRzj6aZ+Aesekq8U98lb9YB4+GD+IUweTbXiour3Au9Gke3DjnHpE4Hu3quYzR9WjFymtyTV+Y6GjV/njZljERYzaO7Ckh1BvOTSOEVPCPrSzO3NGP2QSCT8wq6k27IthHt62WZNeHUoZqilzOSwgOp45W+m/P6ha85AO4+gOtaHt7sDUUEhefqOPoVMbTzMh6hKz+Kl+/4F2FPWzFpNMx75nc5V1DucqZeOXdUbfZG0bgPj7gMpPCyRrmSNa9jgWuY8BzXA8Q5p3EKXHFuDtxXDvNVWjGorSRUuO5VVNjnGkgcH73j4iRvpN/tLK021QkIL3uyBjJPODHvP1lLm03JdFITJQSCBxyeYl1OhJ9jJBl8Y9xDvuUS7c7DXCnnoWOpR9PUOiDonxES4jLtOoEOHDO/CmU/U13kzi19ErjFm1bOXimzq1aXndzmrU0e7IwY/v/ABW5QbRTUrC8HnG7sAnIJO4En9Yb/wD1UQO2Hu0Ppx08wx1a4pD8Po3Fx/ArK7IXxz5DbqxropHZDQ4aSHjfgA8Du4e0dWcKDi8BZOcd+ZzKuFq0P1Ilikv75wDKWyRk+mzQ0FoO4lhAzu9/wK1Xb2yTWyq/hOhb9LGP85hG5lbTDe9jh/3rW+k13H0cb8Be7Zej5uoYJH6o9WS0DGrG/B9gOP3BbxtlTh8Gvrac/n/dq/Fc9140qqlS3Ln7TbTqOUfWLijUqGrhqTb5IHa4ZI5qprjxwWhuXjqfqmdkdRBWD5X5NdmkdjAc+Mj4HVg/eMH71j+Tkxx1ldbH6h5vJJLS4cQPNagiZ9OR+yC9rvafS9iyfLN6pl/pI/8AqVlw3xYNZp+J3fWa9LWzRV0LlcBcq/lPCIiAIiIAiIgCIu6gpXzyxQxjL5pGRM/nPcGgn3b/ANyBuyuyTeRPZ0YdcpW5OXRUoI4Yy2aYe/iwfB/tUpLzWuiZTQRU8QxHDGyNvvDABk+1x4k+0leldmlT1I2Pm+PxbxNZ1Hw4LsXN/cwiLvoaOad/NwRSTSHfoiY57se0ho3D3lZtpb2RIxcnZK7MpQWjzi2Vc8bczUU8ckgHE0k0bmud79Eker3DWVuHKlYudoqC6wN1MFJTxVGnfiMsDoZd3UC9zSfezqC6uT+grrPVsmrqZ0NFV4o5XPdEWtfKcwOka1xc0a26cuAH0pypforbDDB5syMCABzREfSYGPJJjAd/F+kQG8AMDgAFwcXjXTqqUd6vdb9zTVpL+GvMvmh9CxxOFnCa1JNJNNWalFtwmk+Zxdnw4Nc7KyWammmqIYYC5ss0jI2Fpc0gvcBqJbvAHE+4FbNQbd19FNJHFUPq6Vkj2NZWEzF8bXFodzn12kgZxkgZ4HC3qh5P/MbxS1dN6dHql1xE/SUznwytaWk/pItTgP2hkcRvEUXqyz00tWx7SBSzCJ7juBMpc6DT+1rjaXjH6oKnQrUcTK25qy48bt28t3icStgsboympK8ZazV03a0Umuxp3k3fLetzJNtTLFtA0tNO2irsEubFpilOOL2OaAypaP5TcjrA3LS9tthKu2Zl/wBIpc/p2NIMe/cJ2b9H84Ej4ZwujZ20NrcGgmNPcYfpG0z36WzaN/OUc/FsgA3xvz/OxnEu7A7RG4wy01ZGGVtN9DWQSMxra4ECTmz+q4Zy3hn3FuYlSpPCu9N3iuMXxXd2ZPgdbDUKOlYKFeKhUfu1Iq0ZtcU0t2suLi7O29WK+kf/AN8d4RSjy7WNkfmdVDG1jSBRuaxoDfRBdTgNbuHoiRv3NCi1dTDV1WpqaKtpPASwWIlRk725801c5REUggBERAYHlC9VV/2aT8lXhWH5QvVVf9mk/JV4XOxnvLuLl6N/Al+77IIiKGWIIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCmPyUfWk/2d/wCShxSFyF7X0lnrpJ6vXofGYxoGcZ6z7lz9K05VMLOMVdtcCbo+ajXi5OyLdVlQyGN8sh0xxtc97uOGtGScDitS2Vr4K2qfWzTRc8NUVJSueA6niyQX6T9aV/WRnAPvwPZYNvLRXgCCthJcN8crhG7f1EP3fvXpuWyVvqRqMDGF28SQHm85/Ww30HfeCvnGo6d4zTT7i4qSlvTuZ5cLTv8AJi4Uu+guLy0cIanLmfAH0m/g0LzV20N5pWnn6GN2P46Nsj4/i7mnED79KxVK/uu/kZGxibVc9AJxDQkuGd2qaduMj26Ys/2lr3Kh/pNj/rB/+HeuvktqZKia4VMrtUj/ADcF3Djz24DqaA1oA9wXZyof6TY/6wk/w71Jw8dWul2P/wDLNdT3T2KMOWaj+lhrIvRqKSJszXAfXEchfh/WQNOR9/tUlOqGB7Yy9okcCWsyNRA4kD2bj+BWjcpTgYblMfqwUPmw989TmNjR7T9N/cpkOJoqJOLvkZNlaGxtqBw0skaOGdWC0fvCz9RtBK6DEoYWPaG+iCHN3EA5J3j2rWYaT/NY4HHBbDGwn2OYxoz+LV6LhE9kbGSaQ1jeceQ4HLR6W4Dhke32lV9RpvW1uPMVKlU1VI062zY2oGN2prGH3kU8kZ+X3LaOWf1TL/SR/wDUo9tVyijvsc88gjY3L3uOTxY95wGgknJxuHWsnypcoVvqqSSkhc9zi5rtbgGj0c7gzJfvz1gK1YKhNunqq9reR3cNUjHD/qdtxBYXK4C5V6K0EREAREQBERAFuHI9Rc9dY3EZFPFLP7tWBEzPwdKD/ZWnqS+QWIGauf1tigZ9z3yOP/LH4LbQV5ogaUqOGFqNZW8d33JaRFwuwfOjbOTvY2S6SOe9xio4nYllGNT3Y1c1FndqwQS48AR1lSnQX200P+ZW6J1TI360FviM7sjdqmn+pqzxc96j/ZKGqvAhtsLn0tspY2GqMe50z3ZL3SEbnySSa8NPotAz6RbvlcRUdopMQwhkbS1kcUTQZaiZ5DI2DO+WZ7iBlx95IA3VzSFRynqz35RXBZXebyXDM+i+juGUKPrKKUV/6qyV281BbrRXDWfF/wDl82H2jqqqqo546q2RwUskZEjqu4wQuYOIeTG2RjHAgEZPEBc8mN1rZYeYq4ZHiEaY68AiGoYNzd8ml73jhra0tdjOfbgL3tXR00nO15Fwr2EmOigcHUVA4cGB7vQdUDgZSHPznAaNyzVhv0t2iJpblT0s2nJp20vOTQn+Vz7/AKZoP67WtCjzpSVLfGyvx32Xdxf88H27jo0cVTli041XKaVtT9OtJZP3Ypp71FNyjv3q7RulTq0nRp149HVnST7HY3gHhnqz1qOuUOlrK6gq2zW8081I6KqZJFMyoiqGxiSN4a4BsmpsUkp0ub7Pasder3d7XM2O4Vk3NyE8zWwwU01OSOqWmMbX5A3lrZAcZxqWVoOUGSmLBdI4jBKxzqa40Wt9NUaQTp5s5cyTcQW5yDxAG9KWHqUmpwtLnVnllwv3cewYrSWGxSlQrOVPc4yTSsrqycuLjxupbovctZ3IWpZ3xPZLE8skjcHse04c1zTkOBU32aZ12pILpSFkN1pmuhf1RTObpMlLOOJp5PRc08WagQdxz1DZSx3QMqaWOPEmHzCGd0D42O1jUacAtZJzjSMFrQdLt+5YbkUkNPcrlQatTG68E9bqSodBrA4AubIPwCn4qvGvTcoq0o8U1zPc13d5wtF4GrgcRGlUkpU6t0nF88VeMlk+a6uSNs5d4q+ESBhZJG8xzwSAGSnqIz6cb/5QO8O6wQetVtusYZUVDAMBk8zAPYGSubj9ynXar/sytjurN1NO6OmujR9UNPo09YR+1G7DCetrgFHHLTzIufNwxxxhlPGZObY1uuaaSWZ73aR6Ti2RhzxOSsNFtRqPVW6Sv3W4rz8LG30qi6mHXrH+unKz3e8p+7JZXUXfKSa5jSURF3yghERAYHlC9VV/2aT8lXhWH5QvVVf9mk/JV4XOxnvLuLl6N/Al+77IIiKGWIIiIAiIgCIiAIiIAiIgCIiAIiIAiIgCIiA/Ub3NOWktI6wSD+5bRsxthdKR5dS3Cop27iWhxkiB6y+F/ouBO/PvPsWqr9wSuY4OacEfgR1gjrChY3CLEQtz8xIw9eVJ3RO1h5b7tCAKyjprhH/3lO/zeYj2kEc2T7gFvtg5b7FUFrKiWa3SndprYixmfdMzUzHvdhVlp388PoH83J+tC52Gu97Cd2Pcfx6l+mSOY7TMwgfrNI4j3tdxCplfARTalGz7N3/PA7NLSFRdpde01VLUNM1JJTzMkwXS07o5GvxnBc+POo7zxWp8qH+k2P8ArB/+HeqtU5hgeJqWaajm6pKSaSnk/wBwgYz7luOz17vt1np6Y3cv81c6pjmqKWCSohAAjc4PAAmOHgDXne5RoYeNKXrHLcr8V2NdpLlpGDi9ZWJtq7bmfzpsgjcI9BLmagwDOXMJIDTg49IEcVpd5q4bjUQUNG7naOkmFXX1AOpk9Qw5igEnCVxedbsbsAY4YX5n2YZL6dxrauuAwSyeYR0+7fnmYg1o/HC9UV4oadojjLI42bmtjZhg+DWDP7lGqYtNNU0287cPuc3FaUUouMF/J33Wse14Yw6fR1F2ASc8AM9Sw93vZdG+Jx9Ib5ZOHoD0gD/K3b/cPevzfLq2bHNAswP0pIBLeO4cAPefb1LQNprwyKNzGHIJy53EyO9mesZ6+vC8wmD9ZqrV/Vc5EIbzVtra4yVD9LiASSQCRkZ9EOxxwB+9YRfqWQucXHiTlflfS8LR9TSjDJCcrsIiKQYBERAEREAREQBSdyBv+kuDesspj/sunH/UoxW9ciNXzdxfETunppGge18bmyj/AHGyfvW6g7VEc/S0HLCVEsr+DT+xNaIi6587Js5DKilFG6CJ+qq1OqKlulw0h7nRRDURg4ZE3cDu1e9fjlDknrLvbrZDI6JpifNM9m5zGSa2yPY79SQQxSsDhw58+1a5yGXCnp56vn5o4nTCkhhD3AGR7pJhpaOs5LPxW5XKLmtpqKV31aq3TQRnq52FxkcM+3Q4fiq3Xj6vFTfHc2r52+x9JwVXlGiqMOC14QlZ/wDnXsr77pysr53I85YbLHRVsLYY2xU76WMRtaMNBiLmPHvONBJ4kvyeK1N7JqV0c3pwnc+GdpLQfY+KUbndfA+0H2KfuUvZj+E6PQzAqYSZKckgAuxh0Tj1NeMfAtaepQfarzX2yV7I5JoHNeRLA4uDdY3HXEfR18N+PZxC6GAxLq0bLfJbmnz5Zle9INGrC41zleMJb4yS4PnVt3B8FdbrcSTNj9p4bzS/wfdY/TlwyOct0RVTwCWmKQejHVjGrDeOCR1gdNw2KmtkUnMSxVtBI4uq6SvdHBC1gG6YTgjm5wcDW0Dq44C1K5bfT1EZjnhbODg4nmk5sOBBa7mqfmskEAjJOCAepa9dL1V1TWsqKmaaNhyyOSRzmtPUcOPpEDdk5PvWungqus7fpi3vjxX8cLeVjfX01hnTSnerNKynbVl3SvdSXfrXV01vbe12b+CJYa1lNPcbfI+meZocwVEc8MX0j2sc4B8ga1pcW6mOLQ7jvCyPINQnz2smBDmQwczrbnS8yyhwLc4OC2AnfvGRnCj210U1RMyCnY6SaQlrWs4kEYcSf1WYJyTuAzlTbBRwWC0c2+VrZZ3tjkn34NRUYjMjRxMcUeXY46YfaUx3+OLpp3c7K3F/ns3nug74irHETgowpJtyW6LfMrX1U7u7skvFG33Whjq6aWCTDop4nMPwe0gOHvGQR8Aq6bVXKeXzelqGgS25klI9/XI9khYXk8T9HFC3f+wT1qwtmvVHVN/zWohmDQN0b2lzRwGpn1m/eFBnK5SCG71WBgSiKYfF8bQ4/e9rj96iaI3VXCS7V2cz8Uzr+mCU8NGtTldN6rtvTXvLwlHd3vM1NERWM+cBERAYHlC9VV/2aT8lXhWS2qoXVNDV07PrywSMYPa8tOgfe4AKtpBG4ggjcQRggjiCDwK52MX6kXH0bkvUzXbfxS/AREUMsYREQBERAEREAREQBERAEREAREQBERAEREAREQAHG8bvhuWUpL1K0BjwJWfsvAcB8A7Iz8MLFotNbD06qtNXMozceBnHVNHLxY6F3tY44+9r8jHwIWW2UfT00zpjOX5YWABgGNTmkk+l/J/etNRcyroaElaMmvM3evdrMlmW+UzmkaicjHAZ/eVi6m9xtGAW49rnAHHwGf71Hes+0/iVwVGp6AUX7/l/0wcom2XTajU3Q12oAYDW7m7vb+195K1mrqXyu1POfYOofBdKLq4XR9LD+6t+Zi53VgiIppgEREAREQBERAEREAWQ2buJo6umqR/Eytc4DiWfVkA95jc4fesei9TtvPJxUouL4PcWjjeHAOaQWuAc0jgWkZBHuIX6Wi8jt/FTR+avP01GA0Z4upzuicPbp+ofgz2rel2ac1OKaPmmKw8qFWVOXN5rmf8AKOWuIIc04c0gtPWHA5BHvBCnqeqgvVLTyUk8QuNK2nr4W6t8MxBzDNjeI3Fr43DqyDjhmBFl9jr4+3VkVU0FzWksmYOMkL8CRo/lbg4e9rVFxuGdVKUfeV7dvY+86ehdJrCTdOorwnZSzVuEl2xvf+osbZ69tREH6XRvHoywv3SQyj68bx7RnIPBwLXDIIKxe1ex9Dct9RGWygYbUREMmAHAF2CHtGTucCBk4wsJTcpdpdUvY4yRjDWtqjGealbgOwdPptAcXD024G/hlbZR3yimGqKrppAf2J43f3HcqxKnVoy1knE+nQxGDxtN05TjU5mt3Nz2+6/hkY1fI7JqPM17C3qEtOQ4D3uY/Dj9wXdbuR0as1NcS3rZBCGHvJHOH+6pJqrzRxDMlVTxgdb542/3lazcuUeiDuZomzXKoP1YqVji34ukIxo97Q5TIYzGVFaL/my/3bccmtobQ2HetNJdmu3fuje77kmZa1We3WeCR8bI6eNrdU08hy9wHXJK7eRng0bsncFiLLSi8zG4VkDXULWmO20tRGHB7HH6Stlifu1P0tDcjc3PtycRYKKpvdVUOu5LIqCaNrbYzAgErmc410zgSZsNc3jxz1AlpxfKTyhuLn0VtfzcbMxy1Me5ziNxjpyPqMHDWN56sAZPkMPUlPVi7zfGV90U+3nbz/hHlfSGHp0FVnHVoptQhb9U5Jtb48IqLXB7773ayRsW1btnKI4lip4alu9ooGc1VsdjcQ+l0uiPvcQFE+2t6FfVCZpkc1sTIWvmbG2Z7WOeQ6URHRrw/GW4zpzgcFhSeJ4knJJ3kk8ST1lF3MNglR3uTk+37FH0npqeMThGChG97Jb3bhd8/ggiIppxQiIgC0rbDk8pq+R08TzS1D973NYHxSu/afHkEP8A5TSM9YJW6osJwUlZm/D4mpQlrU3ZkR9ElR22HuZP/MnRJUdth7mT5qXEWrktPI6O3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpREfRJUdth7mT5p0SVHbYe5k+alxE5LTyG3sX0vpRGmznJ3W0NTFUw10GqM+k0xSBskZ+vG70vqkfgQD1KS0RbIU1DciDisZUxLUqm9rdwsERFsIoBxv8A7xkfgeKyVJcYB+mt9LP79dVC8/HmpAz8GrGosZRUuP8Au3+jOnVlB3Xmk14O6NpodorZEQf4ApXfz6uaQf7MrXBbdZuVWkhAZ/Bhp4/ZSviIH9gtYP3qKEUWrgaVT3k/mf3Z1MNp3F4d3ptLupxX+opkk7T7a04ZcX2+R2u5ClySxzJISyOSGpyDwdzUcIDhkfSkg+iVGoC5RbaGHjRVo/8Ad25eCIuO0hVxk1KpzX3Lhvbbz4t/6yCIi3kIIiIAirf083fs1t7mq8dOnm79mtvc1XjrmbWoZvwLP7IaQyXzFkEVb+nm79mtvc1Xjp083fs1t7mq8dNrUM34D2Q0hkvmLIIq39PN37Nbe5qvHTp5u/Zrb3NV46bWoZvwHshpDJfMWQRVv6ebv2a29zVeOnTzd+zW3uarx02tQzfgPZDSGS+Ysgirf083fs1t7mq8dOnm79mtvc1Xjptahm/AeyGkMl8xZBFW/p5u/Zrb3NV46dPN37Nbe5qvHTa1DN+A9kNIZL5iyCKt/Tzd+zW3uarx06ebv2a29zVeOm1qGb8B7IaQyXzFkEVb+nm79mtvc1Xjp083fs1t7mq8dNrUM34D2Q0hkvmLIIq39PN37Nbe5qvHTp5u/Zrb3NV46bWoZvwHshpDJfMWQRVv6ebv2a29zVeOnTzd+zW3uarx02tQzfgPZDSGS+Ysgirf083fs1t7mq8dOnm79mtvc1Xjptahm/AeyGkMl8xZBFW/p5u/Zrb3NV46dPN37Nbe5qvHTa1DN+A9kNIZL5iyCKt/Tzd+zW3uarx06ebv2a29zVeOm1qGb8B7IaQyXzFkEVb+nm79mtvc1Xjp083fs1t7mq8dNrUM34D2Q0hkvmLIIq39PN37Nbe5qvHTp5u/Zrb3NV46bWoZvwHshpDJfMWQRVv6ebv2a29zVeOnTzd+zW3uarx02tQzfgPZDSGS+Ysgirf083fs1t7mq8dOnm79mtvc1Xjptahm/AeyGkMl8xZBFW/p5u/Zrb3NV46dPN37Nbe5qvHTa1DN+A9kNIZL5iyCKt/Tzd+zW3uarx06ebv2a29zVeOm1qGb8B7IaQyXzFkEVb+nm79mtvc1Xjp083fs1t7mq8dNrUM34D2Q0hkvmLIIq39PN37Nbe5qvHTp5u/Zrb3NV46bWoZvwHshpDJfMWQRVv6ebv2a29zVeOnTzd+zW3uarx02tQzfgPZDSGS+Ysgirf083fs1t7mq8dOnm79mtvc1Xjptahm/AeyGkMl8xZBFW/p5u/Zrb3NV46dPN37Nbe5qvHTa1DN+A9kNIZL5iyCKt/Tzd+zW3uarx06ebv2a29zVeOm1qGb8B7IaQyXzFkEVb+nm79mtvc1Xjp083fs1t7mq8dNrUM34D2Q0hkvmLIIq39PN37Nbe5qvHTp5u/Zrb3NV46bWoZvwHshpDJfMWQRVv6ebv2a29zVeOnTzd+zW3uarx02tQzfgPZDSGS+Ysgirf083fs1t7mq8dOnm79mtvc1Xjptahm/AeyGkMl8xZBFW/p5u/Zrb3NV46dPN37Nbe5qvHTa1DN+A9kNIZL5iKERFVT6uEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQBERAEREAREQH/2Q==\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"640\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/VKOYjemQRqw?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7fc5e0cceb20>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"VKOYjemQRqw\",width=640,height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd551b1b",
+   "metadata": {},
+   "source": [
+    "# Self-Assessment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d6c44a9",
+   "metadata": {},
+   "source": [
+    "How would you convert a variable from SymPy to NumPy?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c38ca7e",
+   "metadata": {},
+   "source": [
+    "If you want to go from SymPy to NumPy, you must convert symbols to numbers beforehand. If the necessary steps are not taken, there will be errors in the programming code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4108a763",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Pointers.ipynb b/Pointers.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b547684acf56e47d76305780aeca48f798441d54
--- /dev/null
+++ b/Pointers.ipynb
@@ -0,0 +1,255 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "fc73d74c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('answercheck.py', <http.client.HTTPMessage at 0x7f646df0f820>)"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "#Install answercheck in current director\n",
+    "from urllib.request import urlretrieve\n",
+    "urlretrieve('https://raw.githubusercontent.com/colbrydi/jupytercheck/master/answercheck.py', filename='answercheck.py')\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c2a4f39",
+   "metadata": {},
+   "source": [
+    "# Pointers\n",
+    "Understanding Pointers and their purpose "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b78245b",
+   "metadata": {},
+   "source": [
+    "Pointer Dog: \n",
+    "![Types of Pointer Dog Breeds - Image found in the Google Images from AZ Animals](https://a-z-animals.com/media/2021/10/Types-of-Pointer-Dogs-header.jpg)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "Pointers are variables whose value is an address, which is in another location in memory. Thus it is possible to refer to another variable in memory by that other variables memory address and also manipulate memory.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ee3c1f1",
+   "metadata": {},
+   "source": [
+    "## Learning Goals\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment\n",
+    "\n",
+    "Questions that test for the learning goals and allows students to evaluate if they truly understand the topics."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "07524fd7",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  What is the correct way to create a pointer so that it points to a string variable named drink in the following code:  \n",
+    "        \n",
+    "        string drink = \"Coke\";\n",
+    "\n",
+    "1. string* ptr = &drink;\n",
+    "2. string ptr = drink;\n",
+    "3. string& ptr = drink*;"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f1da5683",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>** For the code below, which of the following is the best way to read the code:\n",
+    "\n",
+    "    int w = 99;\n",
+    "    int* x = &w;\n",
+    "    int* y = x;\n",
+    "\n",
+    "1. Pointer x and Pointer y point to the same address.\n",
+    "2. Pointer x  points to the value \"99 \"and Pointer y points to the the address of w.\n",
+    "3. Pointer x and Pointer y point to the same value."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e232e3c",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>** For the code below, which of the following is true:\n",
+    "\n",
+    "    int w = 99;\n",
+    "    int* x = &w;\n",
+    "    int* y = x;\n",
+    "\n",
+    "1. x and y have the same name.\n",
+    "2. x and y have the same address.\n",
+    "3. x and y have the same value."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0843ee02",
+   "metadata": {},
+   "source": [
+    "## TODO: DIRK will work on a list of list with pointers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6527d414",
+   "metadata": {},
+   "source": [
+    "## TODO: Reword the second question"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81760d5f",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Optional Question:</span>** Example Question:\n",
+    "\n",
+    "    \n",
+    "\n",
+    "1. AN2 1.\n",
+    "2. ANS 2.\n",
+    "3. ANS 3."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d237ca9",
+   "metadata": {},
+   "source": [
+    "## Training Materials\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21f9b14e",
+   "metadata": {},
+   "source": [
+    "Introduction to Pointers in C++ in 6 minutes (https://youtu.be/fBlM7pR2r_Q)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68f2cbdb",
+   "metadata": {},
+   "source": [
+    "Pointer Material with exercises (https://www.w3schools.com/cpp/cpp_pointers.asp)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd1da075",
+   "metadata": {},
+   "source": [
+    "Pointer Material (https://www.programiz.com/cpp-programming/pointers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "deeec8f7",
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAUDBAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChALCAgOCQgIDRUNDh0dHx8fCAsWGBYeGBAeHx4BBQUFCAcIDwgJDhISERAYExISHhISEhISEhISEhITEhIWFRMSEhUSFRISEhISEhISEhISFRISEhISEhISEhUSEv/AABEIAWgB4AMBIgACEQEDEQH/xAAdAAEAAQQDAQAAAAAAAAAAAAAACAQFBgcBAwkC/8QAWRAAAgIBAwIDBQIHCgkIBwkAAQIAAwQFERIGIQcTMQgUIkFRI2EJFTI2UmKBFiRCcXR1dpG0tRczNFaCobGz0zdTVYOFlJXhGGNykqLB8CY1Q1Rzd7LH0f/EABgBAQADAQAAAAAAAAAAAAAAAAABAgME/8QALhEBAAIBAgQEBAcBAQAAAAAAAAECEQMhEjFBUQRxofATYYGRFCIyUrHB0eFC/9oADAMBAAIRAxEAPwCGUREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEROYHEREBERAREQEROdoHEREBERAREQERORAqjp14UMabApQ2BijAGsbbuCR3X4h3H1nTVjuyuyqStahnP6KllQH/wB5lH7ZmC9RY4a8iy0e8vZaGapWGMzABUVS55/TkNv8XXsPpTtnBq8y0hfdbChqpZqlZ7Bk47P9mh5Vs1aWE7dhue8z4pcVfEamd69vf8/bLE9jPpqmChypCklQ2x4llClgD6EgMvb9YfWZfm69ivbyQ+UfKdK7hjqXpLW1uvwGwg7VrYnw+nmdvSWzK1YWYbUG+zkt1jBfLULclhpK7kN9mVat227/AJQEtFp7NKa17Y/LjvnO3osMbS99MahTR5nmMUZmqYOtSXE1pz8yni5AAfde/wCpsexnbfrSsKKqyKKxuX2qVzU/vVtyMh/KYqhRd/4xGZ7LW1LRbEV948ljycd63at1KuhKsv0IOxHacVVM7BVVmZiAqqCWYk7AADuST8pl+PrWDXdlv+X5zrYpantx+050MocfCeSfcdu/oJ0UdR1I9LDfah8EoFrRWCV4/DMAI23LuF9fXYH5SOKezKuvqT/46Rz2zt5d2KbGdhofgLOJ4Fiob5cgASv8exH9cyjF1rGVMlXY3WOe11lP+OXyQioyizdOLb7fsPqJS9TarRfTXXUW2W13VDWta1VslarUvEnlsVPxfPfeOKc4wtXXvNorwfXft5fzhju0bfdMnxc6mrT0ViGaz3pTUK62LMRWK3ssJ5IEbdh94+8z6bqCt8i8s3l1nzvdbVorZ6A9tbD4e3rWjL/1rH5mOKeyY17znFeWfT6e/nyYtsfpGxmwLs3HOI1tRrrR3Z2r3qBI985cRWnxDINar29OJI9O8tmn9RU+8223fkDktHGlf8WbQ/B1RkJHEbAb7d/oZEXmejKvi72iZinLMc9/4YlsfpO2jGd+ZVSeCl2+5QQCe/3kf1zMv3S4gHEL8IB4jyKzsR7pw/jA4ZHr+kPrOnI1vFta3exq1fHarYUqeTG650YhSNiqsvf9Y/SOOeyI8Vqzz05j7z/TDtjBEzLR9VottqqbiFQ4pr5pUoBpw7Uv+JuxZrvL25evFfoJaOtX5ZW/NXHl1KOLBioVAvGwr8Pm7gk7fNj/ABSYtvhtTXmdT4c1xtn3sscREu6SIiAiIgciXnHwFS2heDPy48iR8DB1BPHbv2B9fullnYtrDbZj2327ntv67TXTvWvOM8mmnaK84XSnSgyWM3JSpfbsdvgAYgjbt2I9dvUT6/FKckG78WVjvxO7MvHtttug3Ydz/XLSbW7/ABHv69z3+X/zMea3rudx2B3Pp9Jr8XT/AGNPi6f7V1bSVFbMWYMGYbActuL8eJ49uXz/AKvrKTV8QUsoXfiRuC3qe5G+2wK+noZSczttudj6icOxPckn7zK6mppzXFa4+qt9SkxiK4fMRE52JERAREQEREBERAREQLv0hYiZlLWMqKOZLNx2X7Ntj8RA3322/ZLrfqOFatt9lC3vWcWoea5osvBF5vtKUN2btWu/fbZCSd++JxLxfEYc9/Dxa3HmeURttynPTuzPTtMwbfIThURYcQK65BOS9lliDJqsp5bVoqm3ZuI/xaHc8p96ri4OOjWHFofaukoFvt8q8m61bWqK5DswVAinv2IJ22mG02sjKyMVZSCrKSCpHcEEdwd52Zubdewa6yy1gOIax2c7Dcgbsd9tye33y3HGOTKfC3m365x5z79z9Ms0vTtOail7DQC9tTEefxsFbZQR6rSb/VaSSSEX0B5du/aMbSvL5+Vj8vL34DJtHx+7ecdgbeW/mnht9wHr64PG8RqRHSC3hLWn9duffH0ZflY1Hk5KIaFpXUEasDMBNlAOQjMamvPLiDUAwG+zE7kSrx9M0+6xzWmOq1HLHE32GopXdj10W2sbgdmFz9wQDxG30OC7zvwsy6hi1NllTbcS1bsjbHbcbqd9uw7fdEXjstfw9pja05/4qeo6Vryr0SryEFh4VEliqeqbsXbcleJ3BPr27TIbMcXPp/vV2PZxxbVt8zJrt3ZLcl0rY15CkHg9W3JgPQb9tpiN9zOxd2ZnYkszElmJ7kknuTPjeV4oy0tpTNYjO8f5hmWdiaajNWq0Nz97Is89t6vLwabqFQLcV2OQ1iDly32K7kiVWpaJh1+XWKah2uR7jeRxt9zsNFd5a/jXYchS3cKPhA+omB7yqzNSyLlVbbrbFT8lXsZwvbb4Qx7dh8pb4kb7MZ8NfNcXnbOd53+bLMLSdP52ix8bitdC9r92Ww4aNa6P7yqsDeWHYN3BGwE7jouCiY/mVIAxxTbaLG5V+ZjGwpkKb9qw9xUA7LsA3xb95ge8qsjUsixFrsutetNuCPY7IvEcRxUnYbDt2kxevZFvDakztqSrOqaaEvAx1CrwXkFdHTn334FLrdl227Fj85aYMTKd3ZSvDERnLiIiQsTnecRAREQEREBERAREQEREDnecREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQOYlfotCOz8lDcULAM3BdwRtu242HeVWUmIuwCghnYF1ck1gFdiAPyh3b19dpvXQma8WYhvXQma8WYjzWWJktWBjsx+GscVYlRbyr25oqMzh/wAohn7b/IdpS5VWOrLX5YRnYhmZ2+xIvdeLgE9uA7/xg7/W9vCzEZmYWnwsxGZmPf0WSJkvumGD3FZ3CnbzAADvbv6WN8lT5/wvvnycXD+EfCO67sLNyRtTv232G5scf6H3GW/BzjPFX7r/AIOcZ4q/djk5l7yq8WvmeAfvUAvmDtyFnMpwdv0U9SfWWSc+pp8G2Yc99Pg6w4iImbNn+p9ZYvD97e9LYtOXVVZYCbK/ObDNC+bZk2N8HkXHknEAuCqAky1P1Y7VUVuz/Hde+eErpRb1ttrsHDYbCwcWIbYbFtx6mYrE548LpxEbcu/1/wBTlsluo8LJsLsC2NVjfb+8MFuuspyWysRK0uybrrySooJ3Owuc9hNd5V7W2PY55PY7O7dhyZyWY7Dt3JM6oltLQrp5x19+/oZIiJsgiIgIiICJdNF0n3lLSHVGQ1KvMhVJsLDux9DuB/X9BOxencggbBOZK7181Fiqz8Fdgeypy2G/3gnsZnOtSJxM8mU69ImazPJZ5zL3Vomwt5vuRQb6Xr2euxVYq25OxX4gR/omfK9N5PGpyABaUA7klfMUvXuAO/JQT23+W/cyPjU6yj8RpxzlZZzL1b01kKbA3AFN/hL7M21Qv+FSN/8AFnfv/Ee8splq6lbcpXpqVv8ApnLiIiXXIiIHMyK7ozPRKLHqKrkNWi7paCpsXmOe6dtlHoP2THZkerdUDLTHqvx0FVLBn8hceiyzbFx8cBbFxz5Y5UM+2xHxqu21a7Y6vxMxwYxvnPp2SorOncvlkCqi25Ma22qyxKrAoNJPLcMoZDxHLiw37Ht2M6U0m1VqtvV6Ma5gq5D1uU77nkoA3cfC3p+ifpL7Z1ivnNbXjMofOtzmR7w/2l1TI6BhUuy7sSP6vvlrztVx7/Ia3Gs82uuim16sgIttWPSKK+CPS3lWcEr3bcj4D8I3lK21ZnExt9M9fn77DqzdDvTIux0U3NTljD5Vg7Pcz2JUqg9938p9h+qZ94vTuTZjPlCtxWGqWoFG3va2zygKe3x/FuP2EDuJd8fq+lMu7J9zdhbm0ah5bZQ+HJobIYfGtA3p/fL/AA+vwr8R7g/GF1l5S1FcVTfWMEGxrSa2XT7A1IFPH4OSgBjv6gEbStr6+MVr+3t9evvobLI+h5a3pjNj2rfYOSVsvEsvcl9z24AK27eg4NuexnLaPaMVMr+DZcaUUI5LEAnkHC8D8SleO+/b02l1yurGa3cVMcZqPdrca16zzqNjWsqWUU1eV8ZDAgeq99wSJ0aX1BXj41dVdDm+rLqzEta9TV5tLHgrUCkMa+BII5evffbtL8WriMxHTOPX+u/+NlIenc4WLScS8WshsCGtgeCnZmO47AN2O/oex7z7u6czExhltSRTztRiezIajWGLqfQcrOP8at9JcaeqakZBXjW10IMg+UMlLGd8lqjb5rX47120bU1gVsp/J3JLd5QZmsVW02VNjBP3zkZOP5NnCug5IqV6jWyMbKwtNfEAjbbuTIi2tONoj3Pz8u/U2fFnTeeti1Nh5C2PzKq1bAkVnaw9x2C7gnf9JT6EToGi5fC6z3e7hQzJcSjDymTbmrgjdSu43+m43l2xOrXTLzMhqy1WY2SzUeYPs/eLq7y1TWVsgs5U0gsVO4QdpUL1kBXlKcblbkjJU3s9fmFMioVKLWWgGxqwDtxKj4m+Hc7yJtrx/wCYnl/3r29fRssWq6Jl4oDZONdSrNxDWVsoLAbkAkbb7f7D9J2Y2g5FuJ73UjWVrZclgRGY1imuq1rHIGwXjYT/ANW59BLpq/Vi5RUW4oasZYyLK/OYeYhyMu96eaqGXkMtl5D9Hf5ym03qIUKiJQONd2baq+YdtsvGXGCbkEngF33PrvJi2tw7xGfSfXqbLPl4dtXlmxCotRbK2PdXRvRlYdmG+4P0KkHuJTy5Z2qNZRViogroqJsKglmsvZFWy5mb03CgBV2ACjsTuTbZ0VzjdBERJCIiAiIgIiICIiAiIgIiIH3XYy78SRuNjsdtx9D90+d4nEZMu7HybKySjshI2JUkHb6dvlOt2JJJJJPck+pP3ziBJzPJOZ5G8bziJCHO84iICIiAiIgIiICIiAiIgIiIFdpmqW43Py+Px8SQ6I43Q7owDg7EEzvTX8pQoDjdSvx8ELkK3NVdyN3QN32P3b+glqiUnTrO8xDOdGkzmYj7LwnUFwLHjSQU8sL5ScUTdmKooGygs5J/jnCdQZAFfdCaxxBNaElPLNXBjt8S+WxX+r6CWiJHwqdoR8DT7Qu1uv5DHkSu/wB1aKB9iKOwA2A8sAbS1EziJatIryhetK15RgiIlliIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAmT6R4edQZlS34mhaxlUOAyXY2mZt9TqRuGWyqoqwI+YkxPY49nzCxsHF6g1rGrys/LRMnAxchFspwcdtnx72qbdXy3XjYC35IKbAMDJKdTdU6Zpio2pajg6etpK1NnZdGKLGHcis3uvMgfSB5Ha3o+Xg2+Rm4uTh3gBjTlUW49vEkgN5dqhttwe/3GUM9F/bG630YdHX2A6fqp1Jhh6Y6tTl1LfYpazMotrLBHppDsHX+Eagfyp50QESa3sx+zz0xrvS2mapqOLkWZmSc0XOmZfUh8jPysevatG4rtXUg7fQmRI8SNMpwtZ1fCx1K0Ymp5+LQrMXZacfKtqrBY92IRF7mBYIibb9k3ofTuoeo69N1Ot7cVsTKuKV2vS3OpFKHnWQdgSe0DUkST3tpeDuhdL4mk26RRdS+Xk5NdxtybbwyVVVsgAsJ492PpIwwEuukdOahmIbMTAzcqtW4NZjYt96K4AYoWqQgNxZTt+sJapP78HJ+auf8A0gyv7u0qBCFuiNaAJOkaoAO5J0/LA/3csVtbIzIylWUlWVgQysp2KsD3DAjbaevutdT6bg249GbqODh35bccWnKy6Me3Jfkqcceu5w1zc3Rdl37sB85i/jN4TaR1Th2Y+dj1rleWwxNRStRl4lm3wMtg2aynfblUx2O3yIBAeXmkdOahmIbMTAzcqtW4NZjYt96K4AYoWqQgNxZTt+sJWfuG1v8A6H1X/wAPy/8AhydnsC6VdgaDrWDkADIwuqdRxLwp3Aux8PTKbADt3AdDN5a91TpmBZRTn6jgYVuSSMarLzMfGsyCGVSKEudWtPJ0Hw/pL9YHkNmYtlNjVXV2VWodnrsRq3Q7b7MjAFTsR6zpnrP4q+HGk9S4NmFqeMlm6MKMpVUZeHYfybsa4jlWwbY8fQ7bMCCRIKeAXgDZrHVGpaVqJYYHT+TZXqdlW9ZyXS+ynHx6ifiRb/JtfmP4Nb7EEgwNM9OdN6jqTtXp2Bm59iAF0wsW/KdA2+xZaEYqDsfX6GX7VfCjqfFTzMjp/WK6wpZrDp2UURR6l3Wsqn+lPU7QtHwNJxFxsOjGwMLHQkV1IlFNaj4ndtthue7M7dzuSTvOvp3qrS9RNi6dqWBntV2tGFmY+Uaj6faCh2KHf6wPIGJ6J+1h4A4WvYOVqmm41dGvY9bX8qUCfjNa15PRkKo2sySoIS099wik8fSK/sk+Da9WapY2ZzXSNNFdubwJR8l7C3kYSOO6B/LsZmXuFrIBDMCA1X050xqWpM6adp2dqDpsXXCxL8pkB32LChGKg7H1+hl51vwu6kwka3K0HV6KkXm9z6dleSi9+72ivgnYH1M9VdG0vC0zEXHxKMfBwsZDxrqRKKKkXuzHbZR8yWP3kmUeg9aaPn2NTg6tpmbau4arEz8XJsUj1DJTYWB7QPIrGpe10rrRrLLGVERFLO7uQqoiqN2YkgAD6y+/uG1v/ofVf/D8v/hTeninq+Hl+LWmjCox6asTqHQsK1setK/eMqjUMf3y64IAGvGQ9tRY/Khd56AWOFBZiFVQSSSAAoG5JJ9AADA8gNV6Z1LETzcrT87Gr3A8zIxL6U3J2A52IBuSZaZ6/wDTvUmmarXY2n5+DqVSHy7mwsrHzK0Zl34WGh2Ckr8jIa+3l4OYGlpjdQ6VQmJXk5Iw9QxKE444ueuy2nLqrUccfkKXRwNgSaiByYkhEqZAvRGtEAjSNUIIBBGn5ZBB9CCK+4mU+zL0b+PeqdJwnTnjpkDMzAV5J7rhj3ixLB+hYUSn/rhPU7eB45anp2Ri2mnJoux7lALVX1PTYAw3UmuwBgCCCP4596TpWVmOasTGyMqwKXNePTZe4QEAuUrUkKCyjf8AWH1kvfwkXR3fSNfrUd+ek5bbnfceZl4Oy+np78C33Vj+LDvwcf506h/R/K/vHSoGh/3Da3/0Pqv/AIfl/wDClgdSpIIIIOxBGxBHqCD6Geys8y/bJ6S/FPWGphV40aiU1WjuTuM3kcg9/T9+JlgAfICBrPSumNSy6/NxdPzsmrcr5uPiX3V8l23XnWhXkNx2++fWpdK6pi1Ndk6bn49Kbcrb8PIqqUswVeVliBRuxAG/1E9S/A7pT8R9O6PpZUJbjYVXvKqSR73dvkZmxIBI95tt9Zhnts/mJrv/AGZ/fGnwPOvF6O1e1Etq0rUrK7FV67K8HKdLEYbq6OtezKQQQRKTWNAzsIIczCy8QWEhDk411AcrtyCG1RyI3Hp9Z6peBX5rdNf0f0b+7saYT7anSX416P1AqvK/TDXqtPcjiMXkuUTt67YduUdvqFgea+Fi232JTTXZdbYwWuqpGssdj6KiICzH7hL3+4bW/wDofVf/AA/L/wCFN7/g8elPfOosrVHUGrSMJuDbndMvP5Y9Ow22IOMmd/qk/wCB4+0dN6jZfZipgZr5VKh7cZMW9r6lPHZrKQnNF+NO5H8NfrOdW6Z1LEr83L0/NxaiwQWZGJfTXzIJC87EA5EA9vuMn54af8qnW3816R/YtKn37fv5nWfzjg/7bIECauitZZVZdI1NlZQysuBlFWVhurKRXsVIIO/3yyZND1O9diNXZWzJZW6lHR0JVkdWG6sGBBB+k9gelv8AIcL+SY3+5SQw/CC+Fvu2VV1Ph1nyc1kxtTCgkV5aJxx8kgdlW2pOBPYcqlP5VsCNFXRWssqsukamysAysuBlFWVhurKRXsQRsdx9ZZMmh6neuxGrsrZksrdSjo6Eq6OjDdWDAgg/Qz2B6W/yHC/kmN/uUnn3oXhVZ1b4idRYJd6cHH1zWcrUchBu6Yyapcvk1MRwGRa7BF5enxvsRWQQ0h0/oGfqNhp0/Cy860Dc1YeNdk2Aem5SlWYDeZFqPhP1Rj1+bd09rSV8eRc6bllUUepsK1ny/wDS2nqT0f0vp2jYdeFpuLThYlK9q6htvsADZbYxL3WkDvY5JPqTOnS+uNFyrzi4usaXk5Kni2PRqGJdeG32Kmmu0uDv22+6B5ERJD+37rGJf1UcXFox67MHDoTOuqpVLsjLvHvH21qj7cJjvjAE+hNg3+QjxAREQEREBM36V07TeGHlW5FK2orNZQ9qrvYmTbWtjhm3UjzcJgnzFVxPYGYREy1tOb14YmY8hn+PXhtli2n3WsW42pJbyzVrFblsmmmxGsuUebYprBX02sZgoHpS6XjV2YWLTl30LSmpjmFycVra8Zj5drKi2F+BsLHfb0PL8mYVEz/D9Mz/AH1/0XvrHHxq70XGAVTUpsC2VWVizm4PlmrKv4rwCdmYnfl8iJl/S2mUZ7dN4uffQarM23GsWvLxjetWQMf3OqxKXNtNbOjISwHHkdyCRNbTsxb3qdLK2KWVuro6nYq6EMrA/IggH9k6KxiMD2QrRVAVQFVQAoA2AUDYAAdgAJ5aePmuX6rqupahnXcsptRtpx6fODtRgVm0V0GlSfd1q+yUA7ElrGIJ3M9HfBzrvG6j0XC1bGZN76lXJqU7nGzEAGTjNuAQVs32J9VZGHZhNAeO/sjnV9UydV0bUKMM51hvysPMrt8pchyTfdRfSGZVsY8jUy9iX2bYgLIgvJs+yt4CdLa70tg6lqenvkZl9uatlozc2kMKcy6qsCum5UGyIo7D5TVPjr7MeX0todernPXUGTJSnOrpxzVVjU3gJRctj2FrF8/jWSQO+RXsOxM07o3XGtYVK4+Hq+qYmOhYpRjahl0UqXYs5WqqwKpLEk7fUwPVroTpPB0PAo0zTaTRhYxtNNRstuK+ddZfZ9pczO29ljnufntNda17M/RuZlZGZkaXZZkZd92Te/4w1BA919jW2twTICqC7Mdh9Z2ex1qeTmdGaRk5mRflZFjajzvybbL7n4apmIvO21izbIqqN/koHykGfFrxE6gp6g12qnXdZqqq1jU66q69TzUrrrTNvVERFtARFUAAD6CBfPBDoDStT69v0PNxmt01MrWqlxxffWwTEGT7uPOrcWHj5ad9++3eTc8PfArpjQM1dR0rAfHy1rsqWw5mbcOFo4uvC+5kO4HrtPMTTtdzsbJObj5mXRmE2McunIuqyS1u/msb0YWEvybkd+/I7yRvsQdaazndW00ZuranmUe45rmnKz8rIqLKi8WNdthUsN+xgTH8UPDLRupa8arWcVsqvEeyyhVyMjH4taqq5Jx7FLbhV9ZDL24PCnQumV0I6NhtinNOpDJLZOVkc/dxgeUP3xa3Dbz7Pyf0u/pNtfhCuotQ07B0N9Pz83BazKzFsbDyr8U2KKaSquaXXmASdt/qZCTqHqfUtR8sahqOdninn5PvmXkZXleZx8zy/PduHLgm+3rwXf0gWiT+/Byfmrn/ANIMr+7tKkAZP78HJ+auf/SDK/u7SoGc+0D4E4vWOTpl2VqF+HVp63o1ePTW73re9LNtbY21TAVbA8T+V6dptjOy6cam2++xKcfHqe2661wqVU1IXssssc7KiopJY/QmaK9rHxyz+jrNLTCw8PK/GFeYznKNw8tsdscLxFTruD5x3B+gkO/F32gOpOpqji5uTVjYLFS+Dp9bY+PayHkpuLu916g7Hg7Fd0U8dxvAmR7F2s16jgdT6hSCKc/rTWsyoMNmFeVTp96Bh8m4uJkfjt4G6b1hdgW6hl52MMBLkRcNqF8xb2qZ+TXVPsR5Q22+pmvPwcn5q5/9IMr+7tKmw/EfxHfR+rOmdNusC6frdGoYtisE2TOFmJ7hcH489y7NRxB2/fW5BKiBsXVNQxNMw7MjJuTGwsOjlZda54VU1KBuzN3J2AH1PYepmnvY91ivVsLqLW0Xj+NuqNRyFUgC2vGWjEXFpt4kgutZ3O3zsMyz2jPDpeqOn8vTV+HLXbK09y3FVzaFbylc+nl2Kz1En0FpbbdRI9/g7us68Z9V6Yy/3vlNkNn4tVoNdj3V1Lj5+OUfYi5Ex6G4euy3Hb4DAqfwkXU2XVTo2lVWPXh5fvWVlKpKrkPjNjrjo+35SIbHfie25rO26iRA6N6jy9Iz8TUsG005WHcl9TgsASp+KuwKQXpdeSOnoQ7Kexnpl7Q/g7h9Y4FONfc2Jl4lj24WalYt8o2KFuqsqYjzKLAlZIBB3prO/Yg6V8LfY1rwdRozdY1SrOx8W1bkwsfGatch62DVjIttc7U8gOVYHf05CBLaptwp2I5AHY+o3G+x++aa9lDQsfBxOpEoChT1hryAKAAleLemLTWuw7IEqBA/XM2V191TiaJpubqua4THwqWtfuA1jDtVTXy7G2ywpWo+rrIwewF4nLl3a3pObYi5ubnX67j9yBfZkhV1CusN6FDXTYE3JIe07bITA6/wkPUuXVToulV2PXh5ZysrLRDxGS+M2OuOjkflIhsd+J7bms7bqJsbF9k/owcLa8fPUjjZW66jkKwPZlZWB3BHY7iZZ7Q/g7hdY4FWNfc2Jl4lj24OalYtNLWKq3VWVMR5lFgWslQQd6qzv22NH4J9CdU6VlWWa51N+OMMYhxsbCXGFYSzzKSmS1p2bktdTpx77+cTv27hpzxd8GNE6b1norN0xMpcjL6w0qnIfIyrMnzFOVVaWPmbnnzXfl+sd5LfMpFldlRJAsR0JHqA6lSR9/eaO9q7/L+gf6a6T/vkm7dWsZMe90OzLTayn6MqMQe/b1ga08BvA3TOj2zrMHJzcq3OWhLWy3p4olBsZBUlNSdybTuW3/JXbbvvqH8In13ippuJ09VYtmbkZVedkopDe7YtFdgqFo33Sy221GUfSl9/Ub7m9mTxDPU3TeFn3OHzquWFqJARd8zHChrStahENtbVXcVAA8/YDYSIHt2eGTaPrn43x0b3DXGsvY/Ewo1FdmyqmY78RZyFyg/pXADauBsn8G90dxp1bXrE+K100vEYjYhKwmTmEb/lIztiDcfOlxN+eJ3iRXpGt9K6UzKo1zOyqbmOxIrTFarHQEn4Wsz8nDAP6jiV3gJ0f+Iem9J0wrwuoxEsyh6/vzJJyMsb+rAX2uoJ+SKPlHVNfSmTm1X6m2h25+CyrTZl3YRysR6rPNUIbX50utnxdtu8Cn9ovo78e9Mavp6KWvbGORiAbcjl4hGTQik+nN6hWT9LWkQvwcf506h/R/K/vHSpPnEya7q0tqsS2qxQ9dlbK9diMN1dHUkMpGx3Eif7P3Rv4i8U+psJE4Y76Pl5mGAvFPds3UdKyK0rH6FbO9X/AFJgS0mj/aH8LBrmvdG5wrLV4upvTnkVlw2JXU+p1i5gPgp8zBtp3PzzVG+5Ey72i+qH0Xp3K1WvlvgZmi3uqbcrKV1vThkUjl2+0oNlf+mZn2JkV3V121MHqtRbK3U7q6OoZGB+hUg/tgds0z7bP5ia7/2Z/fGny9nrDzuuq9DrbdMLpjNzsoA/CcjL1LSq6EceosroqZh92XLJ7bP5ia7/ANmf3xp8DM/Ar81umv6P6N/d2NMr1DEryKbaLVFlV1b02ofR67FKOpH0KkiYp4Ffmt01/R/Rv7uxpavD7rDz+pur9EsYl9PydKzMcMR/kubo2ALK6x67JkUu53+eWIGO+yB4bv05o2bTeG95yNY1Hm7oa3ajCyH0/GIB7mp1xnvU/MZQIOxm6ZYfETqWrRtJ1HVbtimBh35PAnbzHrQmqkH9J7OCD/2xKLway7Mjpvp++52suv0TSbbbG/KeyzAx3d2+8sSf2wNTeGn/ACq9bfzXpH9i0qfft/fmdZ/OOB/tsnx4af8AKr1t/Nekf2LSp9+39+Z1n844H+2yBvDpb/IcL+SY3+5SUXXXTWHrul52l5YFmLm02Y9hXgxrdW2W2vcFRfTeiuu/o1Q+krelv8hwv5Jjf7lJHz2a/FIHqfqvpXMsG69Qa9maQWIG6nUsq3Nwk3Pcgl8hQP0sknsogSK0fFNGNj0sQzU0VVFh2BNdaoSAfQEiaI9k3Tql1fxCywPtrertQx3O5P2WPk5dlYA9B8WVb/q+kkFIi+zJ13Th9eda6Jk2BBquu6pdhFjspy8TUM3nSP8A1ltNm43/APyoA7nuGQfhDepszD0DCw8ax6atSzWqzHrPE2Y9NLP7szevlu7oxA9fJ29CQezw/wDZf6N1DSNLz2xs1mzdOwcst79cu5ycaq4niNgu5f0E2544+GWF1XpL6ZmO9LCxcjEyqwGfFykVlS0ISBbWVd1as7bhzsQwBGG+CHhf1RoeVjpqHVA1HR8LFOLjacuL5e6LWKsfk5O9a1qBsN2/JAgaX9sHwL0HQtBbVsBc3346hjVPbkZtuT5iWrcHD+duWPwqd/X4R32kPJ6JfhAvzPP86YP/APG+edsBERAREQEREBERAREQNgeC3i5rHSeU1+m2q1FxHveDeC+LlBdwC6ghq7V37WIQfkd1JBlRovtt6Q1IOboupU37fEmLbi5VO+/ba216W2P8X9cgvECUnjf7XFmtafmaTp2kV42Lm1Pj35GdYMm9qbFIbyaK1FePcDts5LbbbgA7ERbiIF503qvVMapaMbUs/HpTlwqozMiqpOTFm411uFXdiSdvqZasi57Heyx2sssZnd3Ys7uxLM7s3dmJJJJ+s64gJV6VqWRiWedi5F2NaAVFuPbZTZxb8oc6yG2P0lJEC56xr+fmBFzM3Ly1rJKLk5N14QkbEqLWIUkAen0lsiICSL9mT2jMbpDScnTb9LvzWv1G3OFtWRXUqi3GxMfyyj1k7g4xO/6/3SOkQN1e1L410dZW6Y9GBbgjT68pW829LjaclqCNuCDiF8j/AOL7ppWIgSL9mT2jMXpDScnTb9LvzWv1G3OFtWRXUqrbjYmP5ZV6ydwcYnf9f7pYPad8b6+rsnSsjEwr9ObTEyNmbIWyxrLrKXV62rRTWUNIIP633TScQJp6L7btC41C5eh5FmUtNa5FlOXUlVl6oBbZWjVbojMCwU+m+2523kcfGDxAxtT6ifX9FxsjRrrWqyXC3qbF1BCfMyqXpVfLL7Vsf1jY2/xTXUQJd+GvtqZVFNdGv6Z766KAc/BsTHus4gDlbiOvlNYx3JZCo+iTL9X9tvRlqY4mjanddt8KZNmLi1k/fbU9zAfskFYgbN8c/GzWerrU9+evHwaLGfG07G5Lj1ud1F1pZi2RkitivmN6cn4qocg6+0XVMjCyKcvEusx8nHsW2m+pilldincMrD0P/nKOIEvvDj21ciqqunXtL97dFAbOwLEpssI2AazDsXyjYe5LIyj6IJles+25o61E4ei6lfd/BTJtxcWvf77KmuYD9kgtEDc3WntC6trWu6NqmopWMLRtTxdQxtLxCaqv3vk1XNzss5NbktXUE8xuw3biqhiDvLUfbZwLKbqxoGWDZVYgJzadgWQqN9qfTcyE8QN0ey945v0bdnLbi2Z2Dn11FqEuFT1ZNBPl3Vl1ZdjW9isNu+1Z3+Daba639rPQdZx6sbP6ay7qqMzDzqh75j7rfh3pfWQTSdgwVq229VtsXccpD2IE3j7cGB8tAzN/lvm0gf1+T2kM+qNXs1DOzc+7bzs7LyMy3b08zJue59vu5OZbYgSp8Dvaxq0HQsLSMzSsjNswRbVXk15daB6Gte2pWR6iVKLZ5YA+Va/WVt/tYaWeocfX10HKW1NGy9IvX3ynlbXbm4WbjMCKtgK2pygQfX3gfo94kxAlP47+1RidSdP5+i1aPk4r5vuu19mVVYlfu+bj5Z3RawW3FHH/AEt/lKzwh9ryrR9E07S83ScjLu0+gYoyKsqutbKKSVxh5b1kqyUCuv1P+L3+ewiZEDfXhz7Qf4v6w1nqrNwbMn8a42RjLi13qr49T5GE+MnmvXtYK6MKurfYb+vb0mW+PHtUYnUnT+fotWkZOK+b7rtfZlVWJX7tm4+Wd0WsFtxRx/0t/lIsRAmH4fe2JhaZpGl6a+iZVr6fp2FgtauZUq2NiY1eObFU1bqG8vfY/Wa30/2hfd+u8vq6rAsGLnUJiZGnm9fNbHTBxcYAX8OIb3jDpu22/g8fvmhIgSW9oz2n16n0Y6Ph6bdgpdk025VtuSlvmU0E2pQqJWPW8UvyJ/8AwQNu/bLfD72xMLTNI0rTX0TKtfT9OwsFrVzKVW04mNXjmxVNW6hvL5bH67SHkQJK9K+0vjYfV+u9StpN706xiYmMmKuVWLKDi0YdPJrDXxcN7sx7enIDvPr2jPaZxeqtEOk06TkYjtlY95utya7FC08yVCJWCSSwH9cjRECamj+2tg0Y+PS2g5ZaqiqpiM2nYmutUJG9PpuDItar1zkfukyuo8Dli5FmsZOrYyluZqa/LsyVqsK7C1Nn4MPQgsCNjMQiBNyj24MLinPp/KD8V5hM6koH2HIKTSCV332J/qkROtepGzta1HV6BZivmapl6lSFsPm4zZGXZlVhbU2PmIXHxLt3XcTHogSx8KPbJ1HGrqxNc08apwHH37FsXGyyiqTyupZDVkWdvygU7dzufXYOpe2jpC1O2Nomq3XKDslz4mPUWA32N1dlrBfTchT677SCuDk+U/LYMCrKynfYqwKkdu49ZUpqYClRUo25hDuxKCxeLj12Pb6/UzSsVxvLalaTH5p39+/eW2vHvxs13q5a8e6qrB01LTbVp+OS29la7C3LyLNjc6i1gOyjuPh37zT7adcFZzWQq7ht/lxOzdvXtuN5X/j5t9xWoBLlwC3xGw1ljvy+HvWvpKLOz2tAB7bM7bgk78yCQST39Je0aURtMtb10IicTM+4+XmooiJg5CIiAiIgIl36T0tMvJFdrOlFdORk5DVhTZ5GJRZk2LWG7eYy1lQT6FwSNhLlo+gDV8tKtNxMuirYC92Zs5KSQxR3eqivy1bhts3z32O3YBi0TJ9I6F1PI96HuWbW2LUzFWw8jk9wFLrjAcN1uau9LAvrsQdtjMcvpet2rsVkdGKOjgq6Op2ZWU91YEEEH6QOuIiAiIgIiICIiAiIgIiICJsb2adHxdQ6s0TDzaK8nFvymW6i0cq7FWi5wrr/AAhyVTt909DP8BvR/wDm7pX/AHZYHlbE9OeqPZs6Mz6mrOjVYjlSEvwLLcW2skflqqN5TsPkLFI+6QY9o/weyekNTTGaw5WDmK9unZfHi9iIyrZRcg7DIqLoDx7EWVsNuWwDVsScns9eyVgU41GodUVvlZlqraul83rxsQHi6LlGsh8jIGw5JvxHJlKt6yQmP4X9NV1mpOntEWtvyk/FWCQ3YD496fjOwHcwPJeJ6N+L/ssdOaxRY+nY9eiaiFJpuw14YbsAeNeRhL9mKiSfiqCt6HcgbGJ/s++H/l+IGD0/r2DXb5N2o1ZeJevOmw1aXmX0v9LKiVqtVvmCh9DA0pE9G/Hvwf6Xw+mNdysXQtOoyMfTcm2i6rHVLKrETkrow7ggiUPs0eEfTOd0nouXmaJp+Tk34zvdfdQLLLG94uG7Oe57AD9gEDzyiSs9ubwUxNIXE1zRcNMXAcrh5+NjqRVRf3ONkhRuK0sAatj2HJKv4Vk3D7NHhH0zndJ6Ll5miafk5N+M73X3UB7LH94uG7Mx3PYAfsAgeeUT0c6R8HOlrOoOpKH0LT3px00XyKmp3rpNuLe1vlITxr5MATt67DeZt/gN6P8A83dK/wC7LA8rYnql/gN6P/zd0r/uyzXfg94WdLZ2b1WLND062vD6jtwcZWoDLRVRp+nh6qwT8C+e17bD5uYHnjE9Uv8AAb0f/m7pX/dlmJeM/g30ti9Oa/k4+g6bTkY+jalfRdXjhbKrqcO6yuxGHcMrqp/ZA82onob7NHhH0zndJ6Ll5miafk5N+M73X3UB7LH94uG7Mx3PYAfsAmxH8C+jyNv3O6X3+mOoP7CDuIHldEm57R/spaamn5WqdNV24uTiVPkW6b5luRRlVVBrLvdvNLXV5PHchASDwChQTvNZ+x34BY/U3n6rq/mHScW73avGrdqmzskIllge1CHrx0SxN+GxJfYMOB3CN8T1dxPB3pOqsVL03ohUDYGzTMS2zb073W1tYx+8mR39sTwO6T0rRr9bxFfSMxbaqaMbGbzMXPyLnG1Pu1z/AGLLUlr70kACuwlGPaBCqIiAiIgIiICIiAiIgIiICIiAiIgIiICIiBXaHqduHkV5FPHnXyHGxQ9bpYjV21WIezVvW7oR9GMrU6gNeTRlY2LiYjUb8a6VvatmPLdn94usdm+Lb127DYSyRArdM1GzHF4r4/vjHfGs5Df7N2Rm49+zbovf+OUURAREQEREBERAREQEREBERA2p7JH569P/AMrs/st89KOvsTKv0nVKMFnTNu07Nqw3rtNFi5VmNamOyXhgaXFpQhwRt2O/aea/skfnr0//ACuz+y3z021zUq8PFycy7l5WLj3ZNvABn8uitrX4jccm4qdhA1b7LXTfVWmablVdU5tmXkPlc8Vb8ts/Ipp8sBxZlMzFlZxuE3O2x/S2nHjhpOHqPUPQ2FkIHsXVc/UlX5inTNPfJ3b/ANWcsYIK/P6EAzAepfbS6dprf3DA1TNv471i1MfExyx3+F7ja9ifLuEPrNF+GPjXmap4h6PresWpXU9z6dXTXuuNh4+ZTfi01ryJIQX5C2M7feT2GwCeviD1GmkaVqOqWIbFwMPIyvLB4m1qa2dag23w8mAXf9aeauveP/WGZmnOOu52O/MumPiXNj4Va7krWMRD5VqKNh9qGJ2+Ik956W9ddO1avpmoaXczJXn4eRiNYoBavz62rFqg9iyEhgD+iJ5ya37M3WeNltippD5YDla8rFvx2xbl32FgttsXylPrtaFP1ECbHsmeJmT1T08mZnBff8TJtwMyxEWtMiyqum6vJWtDsham+vkBsOS2FVCkCY54laBVT4ndE6kg4252HruNdsAORwNLymRz9X45oXf6VoPlMs9lzwxs6U0CvAyXSzNyMizOzTWeVaX2pVUtNbEAsqU0VAn68yOxmG+IvUtOR4pdG6XWwZ9Nw9avv4kEV2ajpWWVqbvuLBViVPsfleh+cDYntJ/mh1H/ADTmf7oy3eyZ+ZfT/wDI2/tN8uPtJ/mh1H/NOZ/ujLd7Jn5l9P8A8jb+03wM7616cxdX07M0zNTzMXNoei0dt1Dd1srJB42o4V1b5FFPylg8Cumb9G6f07SsnY3YC5GOzr+TaqZeR5dyDfsllfBwD8nG/eWHR/ExU621LpbKfbzsPEz9LZiBvYMZffMMd9ySiC9QB/AyST6TasCAHto9X6tpfWWaum6pqOnLdhacbhg5uTiC0pSwQ2DHsUOVDNtv+kfrJM+xhrOZn9IYWTnZeTm5L5GcGyMu+3JvYJlWKga25mcgKAAPukS/b3/PPJ/kOB/uZKX2EvzJwP5VqP8AbLYGlvb4631rTepMGjTtX1TT6H0PGtanC1DLxamtbP1NGtauixVawrWi8j32RR8psX8Hfl25GgaxffbZffdr+Rddda7WW222YWC9lttjktZYzEkse5JJM01+Ec/OnT/6P4v946rNvfg4Pzb1P+e7f7BgQNoePHhzrHUH4v8AxV1LndO+6e9+8e5nKHvnn+7eV5nu2VT/AIvybNuW/wDj222+cdvHvwj6n0Lp7UdSyuvdY1LHrWmm3Att1Fa8qvMyKsR6rDZqFiFOF7EqwIIUj5yQftAdZ9T6QdO/c5oY1r3j3z3zeu+z3byfdfd+9Nihefm3+v8AzXb0kcfHfrPxB13Q8rB1DpJsHBXhl5WTVj5XJKcPe9iTZcVVBwDE7eiGBJH2TPzL6f8A5G39pvlg646E6xyessHVdO1psTQKWwTk4TZ+Warq6v8ALE/FoQ47tYhKgnbuQ24IBl/9kz8y+n/5G39pvmS6R11j36/qPT7KK8rBw8PPrPmA+842TyS1lr2BTyrfLU+v+UVwMh1zUaMPFyMvJda8bGotyL7G24pTSjWWMd/kFUyP34PnqDGyelmwa2UZOnZ2QMirdefDKbz6L+IO4rbeysE/PHf6Tp/CCYOsP07VfgZNi6ZTkBdZw61QedXYye6ZFln5ZoqvUKax2JyKmI+z3ES/Zw0bqnJ1S+/pOx6tQwcOy+x/MSuq2kvWvulnng0XNY5UrVb2PlFv4G4CeXj54TZPUnut2Fr+o6Ll4auKjjWW+62cyG5WU1W1utu4AFin0+R2kMvai0PrjATT8bqjLfUcDGayvTs+tltx7LLFUut1/lpc+Vwr7e8fFstnEkAyUPgT409Q6hqdehdR9M5uBmMt22oU4uTVhjyK3s3yK7wRVWwr4i5GYFrKwFAbtn/tJ6TRmdI9RV5CB0q0nNy032+HIwqHysd1PyYXUp/rHzgeVcREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQNh+zfruJpnVWjZ2dcuPiY+SzXXuGZa1ai1AzBFLbcnUftk5PETx86PyNH1ainXcWy67Tc6qqtUyCz2WYtqIijyu5LMB+2ebEQERECZvs8+1xj1YtOm9U+cr0ItVWsVo+R5taDZRn01g2m5QAPNrDct/iUEEmRGN429I2Vixeo9ICkb7PmVVWftqsIcH7iJ5VRA9A/F/2udC06i2rQydY1Aq61uK7a9OosGwD322cHyAN+QWnseJHNd95F72d+vVr66wNe1/P2D26jbm514JHmZGm5tKErUvwJ5llaBVGwHEABRNOxA9D/Hfxy6Tzumtcw8TW8W/JydOyaKKUTI5WW2JxRF3q23JPqZRezd429K6d0ro2Fm6zjY2VjYz130WJkc6394uPE8aiPQg7j6zz9iBvP2n/ETHyOtV1zQM5bvda9Osx8qpXCC/GQMV2sUc132Uj0O7A/OS96R9pfpLLwMTJytVx8HJuorfJw7VyC+NfxHnU8hVs6rZyAYeo2PznmfEDcftidVafrPVORm6ZlJl4pxMOoXVq4QvXT8ajzFBOxO2/wDH9JIT2QfGHprSOlcPB1LV8fEy6sjNayi1L+SrZkvYh3WsqQUYHt/8pBiIG+vbh6z0vXOocPL0nMrzcerRsfGe2oWBVvTN1G1q/tFBJCXVHt+lNl+w14p9P6HoeoYuranRg5FmqvkV12rcS9LYmJWHUpWVI51WDb9X75DqIHqJ/wCkN0X/AJwYf/u5P/BmOeKPjz0hk6FrWNRrmLbfkaTqNFFSpkcrLrsO6utF3q23Z2A7/Web0QPQL2bvGzpXTuldGws3WcbGysbGeu+ixMjnW/vFx2O1RHoQdx9RNOeJvjNgY3iTh9Q6XljL06qnDxcyykXBLMaytqsxArKptKV2cwPTlUnzWRgiB6c6z46dCZuNfiZOt4N2NlU2UX1OmTxspuQpYjfZbgFWIkefZm8W+l+jcvWtIvse/GyNRNmN1Fjo99eRhVpxxKsrHWpbq/LBsbesN8WTaNtlBMTIgeqlPjf0g9QtHUek8Nt9my60t2//AEXItB+7aRp9rL2mcHU9Pu0Lp5rLqcrZc/UmSyhGoVgxxsWuwLY3NgA9jADYFQDz3EQYgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgcxL5puAXwMmwVWErZV9oEVk4DlyAPllkK+pIPzXcdpd00bDryK14WuvvNuMVe1PidFQoe1f1Yjj/F3mFvERXMds+kRP8Abnv4mtcxjln0iJ/thcSq1Krhc6eXZTsR9nad3XcA/EeK+vr6fMS+ZGhUhaCWsq80qLC5qb3Y+TzCWAlQWsPxLuR27dzvte2pFcZ6tLata4z1YzEzjQNGxRzBK5CiytLWKglKXTcvvW7JSoPImwnt5Y29TMIb1MjT1ovMxHRXS141JmIztj1cRETVsREQEREBERAufTGPVbl49d3Lg9takKvLlu6jifiXip323H9UvlGlU5ZNm9jB7TSHqopx68YJWH82+qssvl/ER6jtU5J3ExJWIO4OxHcEeoP3TlXI3AJAI7gE9++/f69wD+yXraI5ww1NK1pzFsLrrmJjUqqIbfP8vFsblx8thfji5woA3XiWQDf15H049+7p3Gr911LJZFsfHoqrqRxyVDlWil8gr6EohZRv6NajeqiWNmJ7kk+g7/QDYD+qd+BnW0eZ5bcfNqemwEKyvVYNmVlYEHuFYH5FFYd1ErM5a1rMRid1/wATSFuq08GuytLLra7H4qSw40Mrq3AdjybZTv8AknvOzF0vFKWMtF9xfEW+qtbVFikZS0OAVqIc7Kzb7enIbfOYz7zZsF5tsNthyOw29Nu/afK2sNiGII7AgnsO/YfT1P8AXMeCe7n+Df8Ad/PeZfVSb2KvB23cL5anaxt2A4KeJ+M+np+yZjrPTlT5zrZz0+psTBvqV1wau9uHjtYn77yMSt2V2YMU77qxKiYUrEEEEgg7gjsQR3BB+Rlfp+PfnXLUbt24WubL3cpXVTW99zsdmbitdbtsoJ7dhvNXUzbN6dwq9KscIH44j315qpYWOVXqJxuFl6XNjBWr2rWmvnvs9nIAKWtnSmi1tquPQcTLZLMaqzhfXWSrXY6Mch6zU62YvJyV32/Kr+IETELHIBrD8kDEjYtwY+nMKwHqPmRvKrN1jJutN72sLCiV71BaVWutVRKkrpCpXWqqoCqAOw7QK1dGVcG/IbzHyKrhS9CbIcIBlBuzFdeZV2JqUKNgT8Tg7K2Q9UaVRZk6ea8O6jHy8m6lMSrDONqRRbKdgEtusS8lbQqWDYEpaCBtMEdySWJJLEliSSWJO5JJ9Tv3lXg6nfTemUj731nkllipcVYLxVtrgw5L2Kn5FVI2IEC+6NpXmaZqtgxrjZQ1JFzVqwRFuUWV/wCK5VWKjFnIb023XYbzs/cti89LX8Y45GagZ9kzdzvmZWPvTvh9lIpVPj78uR247GYwuZcAyi2wK5YuA7bOWGzFhv8AESPXedEDLcbSaEv1TC5V5FdeNk3V5CK4ei3C52IC1tSN8WxpZQNibVI3KgzEpU4+bZXXdUhAS8ItvwryZa38xU5kchXzCMVHYmtCfyRKaAlTplSvait3BPf5f6xKecqxB3HYj6SJjML6doraJmM49V2/F9Vh3RiASF+EFlD7EnctsQm23/xfSdfuauKBx4Fw4JHI8mH5G/I9tzt6fWW9LGAOxI39dj6j6GdtWZYpXuW4/khtyoO2wIB7dpnw27uyNfRnnTGeePOJ+m0Y27q8aSnE7u3IbjbiNuQVSQTv22Ztv9GcPpKLvu7bLy5HgO5VeW6d+6//AOg/OW03v+ke5J9T6n1M4Nzn1Y9ht6nsPp/FHBfumdfw+NtP1lcF06soWV2I+Mr8HbZNj8R37E77f1fWVFmn1C7Zdypa5QpBIUpt9G3I2Yd/ulqOSxQV77KCTsPmTt6/X0nCZDjuHYHv33Pz23/2D+qOC3c/EaET+jt6c1diaarqDyIJYBhxHwgsE37ndu5+U6NTxFq48WLBhv3AB/1H6EToOQ/pybbfl6n1+v8AHPh3J23JO31kxW2czLK+rozThim+2+ffN8RETRyEREBLloNfJrBxU/ZWgMWVeJNbhduR2O52H7ZbZzL0tw2yreMxhkGBjY4NBIHMNQ7kuCDvcUdSp7ABQD/5RhYWJYvM/DyRT5fmLug52qzAsRudkQ9/0/TYzH4m8eIrtmsMZ0Z3/NK6vXSDUiV87CtTk+ZspJXd0Ppx77f6/rKvJqr3zFNdbv5vNGNigmsmz4lIIHb4TsPqO3aY/G8iNeI6fx28lp0p7/z382QnAxlRGPFmCEsFsADnyuY/hFh8QI9B8xKfKxKVWw1qrnkfW5R5ScEZSBuDZuzMP9D6mWbeJNtesxjhhFdG0TmbSuuv4tFYTyTvuWG/JWDKOPF+xJDHc/8A0JaZzOJjqWi1sxGGlKzWMTOSIiZrkREBERA53jecRATnecRA53M4iICIiAiIgIiICIiAiIgIiICIiAl86MzEqyLEseuqvIxczGNtlYYVvfiX1UtzVGspXznrDMnyLA7qSJY5f+gq0szq6LK0sqyEtptDoj8Eapj5ylvirasqH5V/F8BA332IWKxeJI3DbEjde4Ox9R9QZ8z7uQKzKGVwGIDryCuAdgyh1DBT69wD37ifEBERAREQEREBERAREQEREBERAREQEREBERAREQEREBETMPBvTNFzNZw8bqDMtwNMtcrbkVBfyyv2KW2sCMalrOIa3Y7fPYbsoYfElJi+zFg4OsW4OuapbVpupU+V03q2PUnu1+oWnlTRnXEmujJFa/DS2wt5ny7Ay8ZS9KeyjlY2ZnX9VZtGm9P6Zu1mfTfWHzk2BQ43mA+71/EAzWjffZFVidwEZYkjNN9nXDwdL1LW+ptXs0rTwuRVoYbH8vOzbDz9xycjBsJsr8xFD+5j49ixZkFZJj/o+l5OZatGJj35V7b8acamy+1gO5411KWOw+kCjiXn9yuqe8vh/i3P97rTzLMX3PI95SvdV8x6OHNU5Mo3I/hD6z5v6X1NKWyX07OTHUEte2JkLSoDcCWtKcQOXbvAtES64fTmoXUHKpwM23GUOzZFeLfZQFr3NhNqoUAXY7nftsd523dKaolJyH03UEoCeab2w8haRWRy8w2FOITj35QLLEuC6JmHGOaMTKOGp2bLGPacYHmK9jfx8sHmQvr6kCVOm9K6pk1Ldjabn5FL7hbaMPItqbiSrcbK0KnZgQdvoYFmiVubpWVRcMa7GyKcklAMe2myu4mzbywKnUOS242+u4lZqnSuqYllFWVpufjW5LBMau/DyKbMhmKqq0JYgNrEso2X9IfWBZol3/czqXvHun4vzvevL833b3S/3jy/+c8nhz4frbTn9y2p8ef4uz+Hne78/c8jj7x53u/kcuG3nef9nw9d/h23gWeJddW6c1HDQWZeBm4tZPEPkYt9CFiN+Ia1AC2wPb7p2fuU1TyRk/i3P93NYuGR7nkeSaWUOLRbw4+WVIbl6d94FmiXfSumNSy6/NxdOzsmrkV83HxL7q+S7cl51oV3G47ffKleidZJIGkamSu3IDAytxv3G48vtuIGPxLzl9K6pU9Ndum59T5D+XQlmHkI91n6FSsm9j9/RZ0a7oWdgOtedh5eFYw5LXl492M7L+kqXKpI+8QLbERAREQESo9zt8zyvKs807bV8G5ncch8G2/cbGdLKQSCCCCQQexBHqCPkYyPmInZRS9jBEVndvRVUsx+fYDuYHXE+nQqSrAgg7EEbEEdiCPkZ8wErdJ1K3FdrKeIsap6g7IrsgsHF2r5A8LOO68h3HI7SiiAidzY1gQWFHFbEqthU8GI9QG9Cex7TpgInYaXCB+LcCxUPseJZQCyhvQsAynb9YfWc3UOnHmjJzUOvJSvJD6Mu/qp+o+kZHVERAREQOdp2NQ4JBVgVG7Ag7qO3cj5DuP65U6HmjHyKrmXmK232BAP/tKSDxceoP1Al/wupaqi/fKs+0S1WZ1DX8auHk5PrvTvvt69mcbfF2tWInnLDV1L1n8tc/VYMXS77FR1T4HsFSszKo5kE99z2UAHdvTse8p7Md1LfDvxJBK/EvYgH4h2I3K9/wBYfWZW/VFLGj/KUFdtdp4spFYro8ryqF3HFNwP2Ntt279DdSVpzSvzvKsszndSQof3vFWmvmqnY8LOR/iI+ctNa92VNbVmd6sasodQGZWCt6EggH+I/OdUzLxEzqrhUKshbFFlzCtSzbBwgFhZnPDcKAKwBtxPwjeYbK3jhnDXw+rOrSLzGMkREq3IiIF103QMu80cabETIfy6brEsWh3+L4Vs4kMfgbsP0T9J9U9O5hNwfHvq93qe202Y+QBWFqa1Q/CsmsuqnYtsO+5IHeXbTusvJ8phjb2qMRLm89gllWEvCkV18PsbCoTdtz+SSAORnXj6tQzG4sKEx8HJwsfGJtuvsF+PkVqzXCsVna3JdmJ49gAqzl49XinMbdOvv3PyTssZ0nKAqY41/HIIWhvKs2uY7bCo8ftCdx2X6yrPTWeKrrjiZCpjsqW8qbAycq3tLMCvZFRN2J9Oab/lS7HrRtqPsADWKkuCmmtbkqxLMIENVQtyWeTbZszM2xY8QB2lpTU8dasqgY9vk3NTbUDkKbKraKr60Z38kC1Cch2KgL6L37S8W1esdvn136x0NlDmaffStbXU21LaOVTWVui2LsDyrLABxsy9x+kPrKWXnqHWUykoUUlXqBD32Oll1o4VoqM9dSFkUV9ufI/ERy2lmmtJmY/NGJQRESwREzDwdo0GzWcRepLcinSeRN744Ykso5V13GtTauO7DixqHLZuxHqAlV7Bl2o6npGqafq9b5vT1a1V4lWfi13YfPkzX0VX3Pu9a8UY08SqnYhlPZpK1YPvl+XXqWJTdj4uoYt2mDJw8fij04tFi5GO/vFptsTIe7jaVrIPJQpC8jE2r2g+mdTy7cLUsfJ0/pTScZbdK0bEoUVaxkYz/Z0alVQQDV+Q1eIxFRKsbmOwn1ontN6V1Hk5GmdVYC4GmW5KZGk6hiWXe9aNk0D97XtkVjzEyVbcrk0gbFyrIa2O05Q097W2u6zl9TZ9OrtkhMS62vT8e+kY1dWGz/Zvj0pbYhSwKp84MS3FST22Gx/YK660TSm1nH1HIq03MzVxvd9SyNhQtVYuU1PfYPKxtrbEf7QgNuoJ3UCfes+L/S/Vml5+ndVe8LmaYuXZoeu041a52bXUW8hLaaz5VWZci186WIrYkkMjKpmpPAbxhyuk7M004GDqFGopTXl05iPyKUeaUWm1W2rBa0lgwIPFe3YSEpx9LaZr9PW2NZq+dh6hht0tqdWn34mKcMs6arotmU2VSbbAL2W3GHJG4kVjZQQd8k6b0mjUemTpmSwFepUangnc/EfPszQ3D9dUDuNv0N/lIan2tNbOtrrDYOAa6NOyNNxNP+2FFFeVkYeTfebQ3mW3scHHX5DZBsoO+9P/AOlTrAxtNx68DBqOmagufXYrZBa3vki2hwX2FdlWXbWSO+zQJd6V0uuh9BX6MfLXIwumcw5aVtzUZORh5VuS6ttuyNlHJ2P3S/6LqFmLp3T+RZqGBg6dVplbaiM3ij2oMCnyDRkPciY/l2fE5YHcdu3rIUZ3tW6xcuupZgYLDW6fII5ZG2HV7j7lwo+PuO72/F/Ctf5TDPGLxpzOptP0nT8nDxcevSU4VWUG0vb9hVR8fmMQO1QPb6wJReM2dpuT4adTX6OEGm26tyxvLXjU3/2iwRfZUvoKnyBc6gfJ12EvHsy6l7p4a6bf+NMLRuFuYPxhqFS34lPLWsleNlb5FIJffgPiHdwe/pI2+DvtNaj01pFOj4+mYGVTTZfYLchrxYxvta4hgj8ezN2/iEyDQfbE1fEqsq/FGmWrZlZmV8TZI2OXlW5Xl7B9uKG3iD+qPnAr9C8R9Nx/E+3U9Y1DD1XFrxhiUaxg4vDErt9xqK5a0V3XlUQG+lnVjtuWOwB23X4uDWc6zp7UcLWNN1Xpp+r9AyW92oVcims6rj41FS5lN7U5uMuU/E/CrAhAd+JkStQ8e9Qs6qp6sTA05MyihcdMZktsxggpehnH2gdbSljgMD23mTdc+1Vq2o/i6qjTsDT8PB1HC1OzFo8xvfL8HLTNrrts7BKDfWrlUG+4BLQJy5fTOFka9jazW6jUNOxMjTckKBysxczysqlLTty+zsTkny/fF/z9Ndv/APcK/wD7j/8A9ktIuYXtV61Tr2XriYWEPfcDGwcjB5X+7P7pZZZj5PLnzF6edco+W1z9t+86T7T+pe5DC/FuDwGvfj/nzyOfn/j89QeR+Xt5Xnnyt/Xj98CbniPr2BgU6q/UOdpn4kswkRcC5F96c8LfeUIaz99G0eWErRd91PeW/wAMM2zH6Z6PvOdhYWFXoeltn++AA20jR6eC0XNai0OtvFizb9lI2nnf43eJGR1Vqn41ysejFt92pxvKxzYU40lyG3sJPI8z/UJdvErxkzNc0LRdCuw8aijRKsaqm+prTdcMbDXDU2B24jdRyO3zgTu6J1/TG0jqDUNH1DA0zTjrOU1GpXUq+n1WeXg15WQajbUtlNmZ7wQQwB84MD3mtug/GbUruvcXp5NV0nW9NzK7Huz8DD8hWenSsrLWulkzLk+GyusMdz/CGw2kf/Bb2lNR6X0oaTj6bg5VIvuvFmQ14cm7iSpCPxIBWUmr+0Ln5HVWndVnTsGvJ03Dswq8VDcMexLK8+svYeXPntn2en/NrAkp/hvx8bxB1DTdebHowtMpvx9KzPJfbHsy69PvyDluCwRWSoqLtgFHME7OTMD9u3F1yzStLzbNVwNV6ffOd8W7Ex1pu83KossxDbbVbZTl0Lj13hLquO/mHkp3UjTeh+POoYnVOf1TXgYD5Go1mjIxLltsoWlxjLYKG8wPXaVxlHM7/luNiDtOfHnx51HqujEwXxMTTtNw7PPqw8UFuV4rapLLLGA7JXZaqqgA+1bfftsGoYiICduKfjT4lX4l+J15Ivcd3XieSj5jY/xTqiBmn44xKcvJuDY9/m4SqjqmXUFvFK12VKqCooHYMdwNtiuxHcTEWtDWF3UlWfk6qxBILbsFd+RB2+Z3+/edMTLT0opy+UfZWK4d2W1ZcmpHSvtxWyxbXHYb7uqID33Pp8wJlWXl6ea8NaGqpdGoL2nzhZVxpPvAsFWIC/O3vvyf5bAKSBh8Sb6cWxnOxNcsxy8vBY6lvbjsbrrraLRVa1rh1Z0rVbsbZF5sFLBkIPI/EAJSdX5WBZXSuGlYKk915i1a+CgJcpxkVm5Anlyc9277bTGYlK6ERMTmdvmiKdVTW9PlMGrsNxI4WC1RWq7ruGqNRZzty7hh6jt273LpC7FrtsbK47eSRSbByRbedfdh5FoI8vzQN1Pcj09RZJzNbU4owtMZZTm5OK2NeiXUqGz1vqxf32yrSpuQqH8hRw2sVvkdge3LtLnVqGkjIexvd25VV8V8pkx69rbPNqBXALOxr8r4ym/dhz3G5wKczGfDVmMZn7+X+K8DI8rJxfdKAGxrHqyb7BilMgMabfLCpZclSeaQVY8i2+3EA/IUvWWpplZl1tYHl+ZYK2BuPNDa7LYVuYlCVI+EbD9USyxL10orOfP1TFcERE1WIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiIH//2Q==\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/fBlM7pR2r_Q?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7f646ce74370>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"fBlM7pR2r_Q\",width=\"100%\", height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by <<YOUR NAME HERE>>, Michigan State University  \n",
+    "As part of the Data Science Bridge Project \n",
+    "    \n",
+    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc/4.0/88x31.png\" /></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/References.ipynb b/References.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..5bb8e7ef7bbd4be05039cbc2e75d0a167239c8de
--- /dev/null
+++ b/References.ipynb
@@ -0,0 +1,202 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "fc73d74c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('answercheck.py', <http.client.HTTPMessage at 0x7fc9a8612220>)"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "#Install answercheck in current director\n",
+    "from urllib.request import urlretrieve\n",
+    "urlretrieve('https://raw.githubusercontent.com/colbrydi/jupytercheck/master/answercheck.py', filename='answercheck.py')\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c2a4f39",
+   "metadata": {},
+   "source": [
+    "# References\n",
+    "Understanding References and their purpose "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b78245b",
+   "metadata": {},
+   "source": [
+    "Understanding the Reference: \n",
+    "![Captain America Meme - Image found in Google Images from Know Your Meme](https://i.kym-cdn.com/entries/icons/mobile/000/017/204/CaptainAmerica1_zps8c295f96.jpg)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "A reference variable is an alias, that is, another name for an already existing variable. Think of a variable name as a label attached to the variable's location in memory. You can then think of a reference as a second label attached to that memory location. Therefore, you can access the contents of the variable through either the original variable name or the reference.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89c2fa92",
+   "metadata": {},
+   "source": [
+    "## Learning Goals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment\n",
+    "\n",
+    "Questions that test for the learning goals and allows students to evaluate if they truly understand the topics."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0234bfdc",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  Based on the code below what will be the output of the variable meal:\n",
+    "\n",
+    "    string food = \"Pizza\";\n",
+    "    string &meal = food; \n",
+    "\n",
+    "    cout << meal;\n",
+    "\n",
+    "1. \"Pizza\"\n",
+    "2. \"food\"\n",
+    "3. nothing\n",
+    "4. error"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d030f312",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  Based on the code below, what should be done to change the value of the variable GPA without changing the variable directly:\n",
+    "\n",
+    "    #include <iostream>\n",
+    "    int main(){\n",
+    "        double GPA = 3.14;\n",
+    "        std::cout << \"My GPA is: \" << GPA;\n",
+    "        }\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "daaf2d04",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Put your answer here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d237ca9",
+   "metadata": {},
+   "source": [
+    "## Training Materials\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21f9b14e",
+   "metadata": {},
+   "source": [
+    "Reference Variable In C++ in 6 minutes (https://youtu.be/NGKt3Xwlobg)\n",
+    "\n",
+    "References Materials (https://www.w3schools.com/cpp/cpp_references.asp)\n",
+    "\n",
+    "References Material (https://www.tutorialspoint.com/cplusplus/cpp_references.htm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "9cc2b34a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed variable is <class 'int'> and not a numpy.matrix.\n",
+      "    Trying to convert to a array matrix using ```A = np.matrix(A)```.\n",
+      "\n",
+      "\n",
+      "CheckWarning: passed matrix is int64 and not <class 'numpy.float64'>...\n",
+      "    Trying to convert to float using ```A = A.astype(float)```.\n",
+      "\n",
+      "Testing [[4.]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(x,'2cab95d1b144d663bad1ce5c51020ae0')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by <<YOUR NAME HERE>>, Michigan State University  \n",
+    "As part of the Data Science Bridge Project \n",
+    "    \n",
+    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc/4.0/88x31.png\" /></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Scope_C++.ipynb b/Scope_C++.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..bd97ce4354a8dd400cebdabbaf4e99f11876c45c
--- /dev/null
+++ b/Scope_C++.ipynb
@@ -0,0 +1,548 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "fc73d74c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('answercheck.py', <http.client.HTTPMessage at 0x7fd334327910>)"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "#Install answercheck in current director\n",
+    "from urllib.request import urlretrieve\n",
+    "urlretrieve('https://raw.githubusercontent.com/colbrydi/jupytercheck/master/answercheck.py', filename='answercheck.py')\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c2a4f39",
+   "metadata": {},
+   "source": [
+    "# Scope\n",
+    "Recognizing where variables can be used in a program and where they cannot be used."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b78245b",
+   "metadata": {},
+   "source": [
+    "**_Optional_** Motivating picture: \n",
+    "\n",
+    "![title](scopePicture.jpg)(https://blogs.lse.ac.uk/impactofsocialsciences/files/2015/03/bridge-construction.jpg)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "Scope is defined as when and where a variable is accessible in a program. There are different types of scope - different ways a variable can be accessed in a program. This document will only focus on two types of scope, Global scope and Local scope."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment\n",
+    "\n",
+    "Questions that test for the learning goals and allows students to evaluate if they truly understand the topics."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4af35ce7",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 1:</span>**  Which of the scope types is accessible to all of the program?\n",
+    "\n",
+    "1. Local Scope\n",
+    "2. Global Scope"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "15f43828",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "2\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3921c156",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 2:</span>**  Where would you not see a local scope defined in a program?\n",
+    "\n",
+    "1. In a function\n",
+    "2. In a class\n",
+    "3. In a loop\n",
+    "4. Beginning of a program"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c3dfd97d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "4\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77bd1740",
+   "metadata": {},
+   "source": [
+    "**Use the code below to answer questions 3-5.** <br/>\n",
+    "**Hint:** The print statement is written as the following:\n",
+    "``` bash \n",
+    "std::cout<< YourTextHere <<std::endl; \n",
+    "```\n",
+    "![title](GlobalScope.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12d2601a",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 3:</span>**  What is printed at line 8?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "65583bcc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "10\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93d6fe2f",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 4:</span>**  What is printed at line 15?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e5e975d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "4\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "87a7ef55",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 5:</span>**  If we were to print out **c** after the last yellow curly bracket, what would be its value?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "53254c28",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "10\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5024c8b7",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 6:</span>**  What will be printed below?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1d37b9f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = 300\n",
+    "def func():\n",
+    "    x = 200\n",
+    "    print(x)\n",
+    "\n",
+    "\n",
+    "# print(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "6c5c196b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "300"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "300\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0456a3c4",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 7:</span>**  What will be printed below?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f0e44800",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = 300\n",
+    "def func():\n",
+    "    x = 200\n",
+    "    print(x)\n",
+    "\n",
+    "# func()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "51029b03",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "200"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "200\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6b48b0d0",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question 8:</span>**  How do you identify the scope of a variable in Python (As opposed to C++ syntax)?\n",
+    "\n",
+    "1. Using curly brackets {}\n",
+    "2. Using parantheses ()\n",
+    "3. Using indentation\n",
+    "4. Using the variable name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "4f70eba5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "3\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "9cc2b34a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# from answercheck import checkanswer\n",
+    "# checkanswer.vector(x,'2cab95d1b144d663bad1ce5c51020ae0')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a3fad10",
+   "metadata": {},
+   "source": [
+    "## Training Materials"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ea15c34b",
+   "metadata": {},
+   "source": [
+    "#### What is Scope?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "343e3b11",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Read the following website:</span>** https://www.educative.io/answers/what-is-scope  <br>\n",
+    "**Note:** The website talks about where the scope is but not how to necessarily identify it in the code. When there are \"curly brackets\" or { }, the variables defined within this are considered **local** - in the case seen on the website, the following variable is local:\n",
+    "``` bash \n",
+    "    string name = Bob\n",
+    "```\n",
+    "<br> \n",
+    "The video below will go more in depth about this, but this link will help first introduce you to Global and Local Scope."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b44650dd",
+   "metadata": {},
+   "source": [
+    "#### Introduction to Global and Local Scope in C++"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b64de2b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/RTWHa8WEtYk?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7fd334290520>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"RTWHa8WEtYk\",width=\"100%\", height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "560d9310",
+   "metadata": {},
+   "source": [
+    "#### Code Walkthrough of Scope in C++"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "3690ed8b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/tXo7QyOGMBk?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7fd334290d60>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"tXo7QyOGMBk\",width=\"100%\", height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e8ae5f06",
+   "metadata": {},
+   "source": [
+    "#### Scope in Python"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e9a0e12",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Read the following website:</span>** https://www.w3schools.com/python/python_scope.asp  <br>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by Jessica Parks, Michigan State University  \n",
+    "As part of the Data Science Bridge Project \n",
+    "    \n",
+    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc/4.0/88x31.png\" /></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Whitespace_Indentation.ipynb b/Whitespace_Indentation.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..0e477d82ed267697c2ef4ab2d162b4a35cf0f2a1
--- /dev/null
+++ b/Whitespace_Indentation.ipynb
@@ -0,0 +1,188 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "950c4fef",
+   "metadata": {},
+   "source": [
+    "# Whitespace Sensitivity"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "019e60ef",
+   "metadata": {},
+   "source": [
+    "Short Title: Indentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c61cba51",
+   "metadata": {},
+   "source": [
+    "# Description"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55abe61f",
+   "metadata": {},
+   "source": [
+    "Whitespaces or indedentation act as the spaces at the very start or inside of a code for enhanced readibility in Python. It is used to designate a block of code inside of a program. Any code without indentation or white space is attached to a specific source file. Whitespaces tend to be sensitive due to their ability to completely effect the possibilities of an output of a code or interpretation of a statement ultimately causing an error to pop up.\n",
+    "\n",
+    "It is important to understand, whitespace must always be consistant throughout code. So if a programmer starts with 5 spaces, 5 space must be used throughout the remainder of the block of code or else a syntax error will not allow the code to be ran."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f8796bb7",
+   "metadata": {},
+   "source": [
+    "# Examples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "410f3f67",
+   "metadata": {},
+   "source": [
+    "'' - space\n",
+    "\n",
+    "/t - tab"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "880c1d84",
+   "metadata": {},
+   "source": [
+    "# Learning Materials"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "dfad44a7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"640\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/vgefSv5k-o4?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7ff3796ec7c0>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"vgefSv5k-o4\",width=640,height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50fdb729",
+   "metadata": {},
+   "source": [
+    "10 minutes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ae1c549",
+   "metadata": {},
+   "source": [
+    "# Self-Assessment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2e5459e",
+   "metadata": {},
+   "source": [
+    "Create a code that tests whitespace values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "80ee2cd9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "printable Value is:  \n",
+      "printable Value is:  \n",
+      "printable Value is:  \n",
+      "printable Value is:  \n",
+      "printable Value is:  \n",
+      "printable Value is:  \n"
+     ]
+    }
+   ],
+   "source": [
+    "#Put your answer here\n",
+    "# import string \n",
+    "import string \n",
+    "    \n",
+    "# An input string.\n",
+    "Sentence = \"What time does lunch begin at Shaw?\"\n",
+    "  \n",
+    "for i in Sentence:\n",
+    "      \n",
+    "    # determines if whitespace is found in code\n",
+    "    if i in string.whitespace:\n",
+    "          \n",
+    "        # Prints the number of whitespace values and its characters\n",
+    "        print(\"printable Value is: \" + i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "351205d1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}