diff --git a/Central_Limit_Theorem.ipynb b/Central_Limit_Theorem.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..590d918df2553495ed97403602e5692ba7f708ba
--- /dev/null
+++ b/Central_Limit_Theorem.ipynb
@@ -0,0 +1,175 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6f3d3c8e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Volume in drive C is Windows\n",
+      " Volume Serial Number is 9804-D0F8\n",
+      "\n",
+      " Directory of C:\\Users\\12058\n",
+      "\n",
+      "06/28/2022  09:42 AM    <DIR>          .\n",
+      "06/28/2022  09:42 AM    <DIR>          ..\n",
+      "06/28/2022  07:50 AM    <DIR>          .ipynb_checkpoints\n",
+      "06/01/2022  09:53 AM    <DIR>          .ipython\n",
+      "06/02/2022  07:27 PM    <DIR>          .jupyter\n",
+      "06/02/2022  08:03 PM    <DIR>          .matplotlib\n",
+      "06/28/2022  09:43 AM    <DIR>          .ssh\n",
+      "06/08/2022  10:09 AM           248,337 01-Python_Packages.ipynb\n",
+      "06/08/2022  09:17 AM            98,945 04--Gauss_Jordan_pre-class-assignment.ipynb\n",
+      "06/08/2022  10:53 AM            39,849 04-Gauss_Jordan_in-class-assignment.ipynb\n",
+      "06/10/2022  09:59 AM            32,829 05--Gauss_Jordan2_pre-class-assignment.ipynb\n",
+      "06/12/2022  07:06 PM             9,262 05-Gauss_Jordan2_in-class-assignment.ipynb\n",
+      "06/13/2022  09:29 AM            27,253 06--Mechanics_pre-class-assignment.ipynb\n",
+      "06/13/2022  09:22 PM            19,582 06-Mechanics_in-class-assignment.ipynb\n",
+      "06/15/2022  09:34 AM            64,736 07--Transformations_pre-class-assignment.ipynb\n",
+      "06/15/2022  10:51 AM            82,657 07-Transformations_in-class-assignment.ipynb\n",
+      "06/20/2022  09:23 AM            15,503 11--Vector_Spaces_pre-class-assignment.ipynb\n",
+      "06/20/2022  10:39 AM            17,851 11-Vector_Spaces_in-class-assignment.ipynb\n",
+      "06/22/2022  10:56 AM            13,714 14-Fundamental_Spaces_in-class-assignment(1).ipynb\n",
+      "04/29/2021  12:44 AM    <DIR>          3D Objects\n",
+      "06/01/2022  10:34 AM             2,675 6-1 LA Practice .ipynb\n",
+      "06/01/2022  09:50 AM    <DIR>          anaconda3\n",
+      "06/28/2022  07:51 AM             6,858 answercheck.py\n",
+      "10/06/2020  08:59 PM    <DIR>          Apple\n",
+      "06/27/2022  10:33 AM            33,584 banner.png\n",
+      "06/27/2022  10:33 AM            53,166 beaumont.png\n",
+      "06/27/2022  10:33 AM            31,359 billboard.png\n",
+      "08/22/2021  02:05 PM               151 BullseyeCoverageError.txt\n",
+      "06/28/2022  07:57 AM             2,174 Central Limit Theorem .ipynb\n",
+      "04/29/2021  12:44 AM    <DIR>          Contacts\n",
+      "06/28/2022  09:43 AM    <DIR>          data_science_bridge_curriculum\n",
+      "01/04/2021  01:01 PM    <DIR>          Documents\n",
+      "06/28/2022  09:13 AM    <DIR>          Downloads\n",
+      "06/10/2022  10:50 AM             2,193 Example 6.10 OneNote .ipynb\n",
+      "04/29/2021  12:44 AM    <DIR>          Favorites\n",
+      "06/17/2022  11:00 PM            69,632 HW1-Systems_of_linear_equations-STUDENT(1).ipynb\n",
+      "06/27/2022  10:38 AM           335,400 HW2-Affine_transform-STUDENT(1).ipynb\n",
+      "06/24/2022  10:36 AM            22,996 Intro_to_Statistics.ipynb\n",
+      "04/29/2021  12:44 AM    <DIR>          Links\n",
+      "04/29/2021  12:44 AM    <DIR>          Music\n",
+      "08/01/2021  10:31 AM    <DIR>          OneDrive\n",
+      "06/02/2022  08:50 PM            76,621 PRACTICE Chapter 2 Vectors-Copy1.ipynb\n",
+      "06/02/2022  08:51 PM            76,621 PRACTICE Chapter 2 Vectors.ipynb\n",
+      "06/13/2022  09:11 AM             9,464 Practice_6_10.ipynb\n",
+      "06/28/2022  07:56 AM             2,103 PTest.ipynb\n",
+      "12/21/2021  06:50 PM    <DIR>          PycharmProjects\n",
+      "06/03/2022  09:21 AM            25,465 Python_practice_6_1 (1).ipynb\n",
+      "06/07/2022  09:34 PM             4,627 Python_practice_6_6.ipynb\n",
+      "04/29/2021  12:44 AM    <DIR>          Saved Games\n",
+      "04/29/2021  12:44 AM    <DIR>          Searches\n",
+      "06/27/2022  10:33 AM            46,172 sparty.png\n",
+      "06/02/2022  10:58 PM             2,752 Untitled.ipynb\n",
+      "04/29/2021  12:44 AM    <DIR>          Videos\n",
+      "06/28/2022  07:48 AM            42,345 _Template.ipynb\n",
+      "06/08/2022  10:08 AM    <DIR>          __pycache__\n",
+      "              32 File(s)      1,516,876 bytes\n",
+      "              23 Dir(s)  401,290,428,416 bytes free\n"
+     ]
+    }
+   ],
+   "source": [
+    "!dir\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "8e746444",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('answercheck.py', <http.client.HTTPMessage at 0x20990c87880>)"
+      ]
+     },
+     "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": "b7598d9e",
+   "metadata": {},
+   "source": [
+    "# Central Limit Theroem \n",
+    "Understanding and computing using the Central Limit Theorem (CLT)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74fcd9bf",
+   "metadata": {},
+   "source": [
+    "# Description \n",
+    "The Central Limit Theorem states that the distribution of sample means approximates a normal distribution as the sample size gets larger, regardless of the population's distribution. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2238469c",
+   "metadata": {},
+   "source": [
+    "# Training Materials \n",
+    "https://www.khanacademy.org/math/ap-statistics/sampling-distribution-ap/what-is-sampling-distribution/v/central-limit-theorem\n",
+    "\n",
+    "https://www.youtube.com/watch?v=4YLtvNeRIrg"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bcc501fa",
+   "metadata": {},
+   "source": [
+    "# Self Assessment "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aff596ae",
+   "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/Eigenvalues.ipynb b/Eigenvalues.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9457caba9774e4c4702a21088d91b04dc7e6620f
--- /dev/null
+++ b/Eigenvalues.ipynb
@@ -0,0 +1,558 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "bf3966f2",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (4091352979.py, line 3)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  Input \u001b[0;32mIn [4]\u001b[0;36m\u001b[0m\n\u001b[0;31m    [Beezer Chapter E pg 367-369](http://linear.ups.edu/download/fcla-3.50-tablet.pdf)\u001b[0m\n\u001b[0m            ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "Sources\n",
+    "\n",
+    "[Beezer Chapter E pg 367-369](http://linear.ups.edu/download/fcla-3.50-tablet.pdf)\n",
+    "\"10--Eigenproblems_pre-class-assignment\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "fc73d74c",
+   "metadata": {
+    "scrolled": true
+   },
+   "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": [
+    "# Eigenvalues and Eigenvectors\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "Suppose $A$ is an $nxn$ matrix, and $x$ is a non-zero vector of length $n$. We call $x$ an eigenvector of $A$, (and $\\lambda$ an eigenvalue of $A$ if the following holds true:\n",
+    "$$Ax=\\lambda x$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9e7b32e4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import sympy as sym\n",
+    "sym.init_printing(use_unicode=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43219d26",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  Find the eigenvectors and corresponding eigenvalues to the following matrix:\n",
+    "\n",
+    "$$A =\n",
+    "\\left[\n",
+    "\\begin{matrix}\n",
+    "    -5 & 3  \\\\\n",
+    "    2 & 5\n",
+    " \\end{matrix}\n",
+    "\\right] \n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "64684dfd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([-5.56776436,  5.56776436]),\n",
+       " matrix([[-0.98255847, -0.27309129],\n",
+       "         [ 0.18595389, -0.96198812]]))"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Put your answer here\n",
+    "Eigenvector_1 = \n",
+    "Eigenvector_2 = \n",
+    "Eigenvalue_1 = \n",
+    "Eigenvalue_2 = "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "619a2259",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "Eigenvector_1 = np.matrix([[-0.98255847],[0.18595389]])\n",
+    "Eigenvector_2 = np.matrix([[ -0.27309129],[-0.96198812]])\n",
+    "Eigenvalue_1 = -5.56776436\n",
+    "Eigenvalue_2 = 5.56776436\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "9cc2b34a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed matrix is int64 and not <class 'numpy.float64'>...\n",
+      "    Trying to convert to float using ```A = A.astype(float)```.\n",
+      "\n",
+      "\n",
+      "CheckWarning: numpy.matrix is row vector...\n",
+      "    Trying to convert to a column vector using ```A = A.T```.\n",
+      "\n",
+      "Testing [[-6.  2.]\n",
+      " [ 3.  5.]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(Eigenvector_1,'b10e973911c0f1aaa0935b4a5d28d45e')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "e68fb05c",
+   "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 [[3.]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(Eigenvector_2,'1a8eec37d810b762b4d59f473a71d4ef')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "c174a35a",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed variable is <class 'float'> and not a numpy.matrix.\n",
+      "    Trying to convert to a array matrix using ```A = np.matrix(A)```.\n",
+      "\n",
+      "Testing [[-5.56776]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(Eigenvalue_1,'e068443cfbf0eda723d5db1cc537d83e')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "398e9ba7",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed variable is <class 'float'> and not a numpy.matrix.\n",
+      "    Trying to convert to a array matrix using ```A = np.matrix(A)```.\n",
+      "\n",
+      "Testing [[5.56776]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(Eigenvalue_2,'d184fa6826328eed38a2d3d2ef46ca27')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc8a72ca",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  Find the eigenvectors and corresponding eigenvalues to the following matrix:\n",
+    "\n",
+    "$$A =\n",
+    "\\left[\n",
+    "\\begin{matrix}\n",
+    "    4 & 9  \\\\\n",
+    "    2 & 6\n",
+    " \\end{matrix}\n",
+    "\\right] \n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "ebf94d59",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([0.64110106, 9.35889894]),\n",
+       " matrix([[-0.93687907, -0.85921919],\n",
+       "         [ 0.34965357, -0.51160765]]))"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Put your answer here\n",
+    "Eigenvector_1 =\n",
+    "Eigenvector_2 =\n",
+    "Eigenvalue_1 = \n",
+    "Eigenvalue_2 = "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "ee9b8f48",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "Eigenvector_1 = np.matrix([[-0.93687907],[0.34965357]])\n",
+    "Eigenvector_2 = np.matrix([[-0.85921919],[-0.51160765]])\n",
+    "Eigenvalue_1 = 0.64110106\n",
+    "Eigenvalue_2 = 9.35889894\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "ac03c94b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: numpy.matrix is row vector...\n",
+      "    Trying to convert to a column vector using ```A = A.T```.\n",
+      "\n",
+      "Testing [[-0.93688  0.34965]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(Eigenvector_1,'b891f1e405f7bf6b5c3e231c913df9bf')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "b0665a78",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: numpy.matrix is row vector...\n",
+      "    Trying to convert to a column vector using ```A = A.T```.\n",
+      "\n",
+      "Testing [[-0.85922 -0.51161]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(Eigenvector_2,'ae93047ed19ef8a751245ce81fd5f331')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "5d1675a7",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed variable is <class 'float'> and not a numpy.matrix.\n",
+      "    Trying to convert to a array matrix using ```A = np.matrix(A)```.\n",
+      "\n",
+      "Testing [[0.6411]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(Eigenvalue_1,'832b904a70eb6542300aea5f522a5011')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "15ed65e4",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed variable is <class 'float'> and not a numpy.matrix.\n",
+      "    Trying to convert to a array matrix using ```A = np.matrix(A)```.\n",
+      "\n",
+      "Testing [[9.3589]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(Eigenvalue_2,'13907c0ecf18105ff35d136662c2a8a0')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d237ca9",
+   "metadata": {},
+   "source": [
+    "## Training Materials\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62a1dda0",
+   "metadata": {},
+   "source": [
+    "Reviewing the following text might be helpful: [Beezer Chapter E pg 367-369](http://linear.ups.edu/download/fcla-3.50-tablet.pdf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "cb7c7b43",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAUDBAgICAgICAoICAgICAgICAgICAgICAgICAgICAgICAgIChALCAgOCQgIDhUNDhERExMTCAsWGBYSGBASExIBBQUFBwYHDwkJDxgVEBIXFRUVExUXGBYYGBIZFxUVGBseGBgVFxYYGhoYEhUVGRgSHhcVFRUVGBUYGBcTFxUVEv/AABEIAWgB4AMBIgACEQEDEQH/xAAdAAEAAwEAAwEBAAAAAAAAAAAABgcIBQEDBAIJ/8QASxAAAQQBAwIBBwsCAwYFAQkAAgABAwQFBhESBxMhCBQYIjFRlBUXMkFUVWGV09TVI0IzUnEWJGKBk9IJJkN1kbMlNkVjZHKSobT/xAAbAQEAAwADAQAAAAAAAAAAAAAAAwQFAQIGB//EADQRAQACAQMDAgQFAwIHAAAAAAABAhEDBCEFEjFBUQYTYXEiMoGRoRRC8NHhFSNicpOxwf/aAAwDAQACEQMRAD8AxkiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAi0T6HOr/fifjZP26ehzq/34n42T9ugzsi0T6HOr/fifjZP26ehzq/34n42T9ugzsi0T6HOr/fifjZP26ehzq/34n42T9ugzsi0T6HOr/fifjZP26ehzq/34n42T9ugzsi0T6HWr/8ANifjZP26eh1q/wDzYn42T9ugzsi0T6HOr/fifjZP26eh1q//ADYn42T9ugzsi0T6HOr/AH4n42T9unoc6v8AfifjZP26DOyLRPoc6v8AfifjZP26ehzq/wB+J+Nk/boM7ItE+hzq/wB+J+Nk/bp6HOr/AH4n42T9ugzsi0T6HWr/AH4n42T9unoc6v8AfifjZP26DOyLRPoc6v8AfifjZP26ehzq/wB+J+Nk/boM7ItE+hzq/wB+J+Nk/bp6HOr/AH4n42T9ugzsi0T6HOr/AH4n42T9unoc6v8AfifjZP26DOyLRPoc6v8AfifjZP26ehzq/wB+J+Nk/boM7ItE+hzq/wB+J+Nk/bp6HOr/AH4n42T9ugzsi0T6HOr/AH4n42T9unoc6v8AfifjZP26DOyLRPoc6v8AfifjZP26ehzq/wB+J+Nk/boM7ItE+hzq/wB+J+Nk/bp6HOr/AH4n42T9ugzsi0T6HWr/AH4n42T9unoc6v8A82J+Nk/boM7ItE+h1q/34n42T9unodav9+J+Nk/boM7ItE+h1q//ADYn42T9unoc6v8AfifjZP26DOyLRPoc6v8AfifjZP26ehzq/wB+J+Nk/boM7ItE+hzq/wB+J+Nk/bp6HOr/AH4n42T9ugzsi0T6HOr/AH4n42T9unoc6v8AfifjZP26DOyLRPoc6v8AfifjZP26ehzq/wB+J+Nk/boM7ItE+hzq/wB+J+Nk/bp6HOr/AH4n42T9ugzsi0T6HOr/AH4n42T9unoc6v8AfifjZP26DOyLRPoc6v8AfifjZP26ehzq/wB+J+Nk/boM7ItE+hzq/wB+J+Nk/bp6HOr/AH4n42T9ugzsi0T6HOr/AH4n42T9unoc6v8AfifjZP26D+h6IiAiIgpbyyNcZTT+nQv4ifzS0+SrQPL2K9jeGSKwRhwsxmHi8YeO2/h7VX+ezHVTTlJ83dtYbP46COOe3VjrhFNFWfYpJW7FSAmYQfxJnPj9Jxdmdd3/AMQx/wDyjH/7xT/+jbUf6meUrhshgp8NgY72Vy2SoljYYIqU4sD2IOzLI7GPOVxAjdgAS3dm32bd2C7MN1bw02m4NUTzjTxssLGbzetJFMxlFJVYY2cppxmAwYQZ3LjuzbLl9NevunM/cHH0554bsoFLXgu1jqlajFuTlWItwkfgzkw78nESdmdhd2zx1i6Y5XD9OtNwSgchYvJFkcxDHHHaaq1t7EjFJE59ucIO60Retwd5Cfdhd3b6tPT1NT6m00T6vLL3sdYa5Vjr6Plx/CKCSGxNVs2Y5QaIDCJx3JjAdy9nJmIPz1C64W72tp8dBnbOCw1GWOpC9fHFaK3ehkhjswTxNxkbnYKwHccnBhgF2Z+W73VoDUxPqvVFeTMWr0VCApXxB0Hhhxo8oj5Q2u4/nL8d224t9P8ABQfQsY/PLqdnZtvkOu+zs22/menn329/tXo6ZP8A+feo/wD7e/8A9OJBMp/Kw0aEUMvnVo+8Zh2wpyvLCIcWeSYN/UB3Lw23J+L7Mvb5QGso2o6eu0c5Pia2RuRdixTpFdbIxzxgcUBNzB4Bdn35P4t4tsypno7iqp9IdRGcMJGR5GUjKMHN5a41igNydt+QOIuL/Vt4Ln9QS30J018f/wAUh+v3SzN//SDTnUDrjp7A5A8ZlLElayFVrn+BIcZREx8BAwZ+cxODswM27v8Ah4r7OknV/Caoisy4uY3enx85hsxvXmiA+ThKTE7i8T8D9Znfbi++yqHP1opesmP7gBJwwLyAxixMMgw3eJiz+wmZ32f6lwNE6de3rHqfiqXbqnexFivC4N24wnuRxj3HYPZvLM5O7ePrE6C0fSi0e9qas1yZxhc2K41SZ6RGDF6gT7eLk4Owk7MJO7bFs+6sbprrajqHHx5PGlIdSU5YwKWJ4jcoTeM9wLxZuTOsmdONWWsPpLIaQuaYyxZMK+WGaU6kYY2QZu/K929clcWCOKN9mkHmJDXj4n4ttcXkIt/5JofjayG34/75KyDneVfrfUWOy2lsZp+9FjpM1NZrSHPWqzxPJ3qMUByFYryFGA989+DfX4s+zL7tBaf6jx5OnJldQYa9jgm5XKtatWCeaHiW4xkGOAhLlxfwMfZ7VXnl9jQLMaMHKFIGNeW8184uXdGo8+N75RsAuXNg5bbM7p0Ht9MKGepHgbeUPKWCKnWCxHbeIytD23Eu5XER8H9ru2yC1+kuoTn1PqqtJmbGQClI/wD9mzUnrQYkXnk2GK08jtZHi3Hls3gO/wBa9D+VHo/zqas1ycgh5sVwakz0iMGL1An28XJxdhJ2YSd22Lx3Vb9NcRLkNUdVqEB9qe7WmqQy7u3CWw1qECd28WZiNvFRvprq21h9J5HSFzS+WPJhBlhlkKpEGOmGVp5Hu3bcziIhEHgxtzEhrxcT8WZg05hOreDtYKTUjWXgxETysdizEcRMUUnacWh2czMpNhERZyJ3ZmZ3dlw+nnlB6azl4MdUnsQ252cqoXaslYbYszvvWMtxN3Zndhd2d9n2Z9llm7gL9zpBjjphLLHTztm5cjiYiJ6gndgeZxHxOOOWWN3+pm3J9mB3aQ0bdLVOX0zCWrvlG5TuRWMfXr6LOkdQoXineGaeGUWiid64DuzmAuLE+zNyQaE1v5QmmcLfv43IWJobeOjjkmjatIbSPMFeSOOuQ+EsrhZjfbwZmE3d2YXX14Lrpp+7hLmfrS2ZaWOMAvANWR7dZzeNmKSu3iUe0glzFyHYTff1C2qvQNaKTrHql5AA3jw0Bx8xYuBPVwMZEO/sLiZDv7jdvrXP8kfCVbGW6n46SMPM58kNM4BFhjatJa1BC8Yi3gItG+zM3s2ZBe+d6s4Wnga+pJ5jbF2RrlCYxEcxvZfYI2hbx7jOxch+rtn7lz+ofW/BYGHHy5MrkJZOu1qpANGc5yi4gRNIzNwikHuAxARcm39iyboHC5DJZbFdObwOdHTufyeQumTepPj4OEkDEBP/AIchyWGZ/rbJxezi7q4uu3Ua/W1hUwkuVi0riWxvnIZQsfXtyWpT5coRmtRkEEW8bD4bNvC+7k5AzBZ+E6r4rUGDy97BWnkOlTtPIxRnBZqzNVllhIopRZ9ncdxNtxdwJmfcXZoF0Q6xjS0NTz+pbVmw8l6zVOy0XelcnsTDCLhGzeqwxu2/+irXycrASX+pRx2vP45MYcjXfMgx3ne8V1/OHpgIjDy5OXgLb8uWzctlH7FGWfoxXeICkavmJJ5uLO/bia7YjKQtvYLFKG7/AFboNfa36nYvDPiWvFML5qYK9HtwFJykPssLSbP/AE/8ePxf8fcuf1U6z4HTc0NXITSndnDuR0qcB2rLxbu3cMA8Iwd2Lbk7OXAtt+L7Zh6x9VcXqSfQAYzzk/M8rTa4cteWGOCcpMcPmvdNuEszcSd+DuzNxffxX3dVrNzA9RcnkbeVfTsGTow/J+Ylwvy3CcQQVIpKgRu+9c2OE2cgZ3bYd2ZpGdBqDRfVPB5fFT5mncjehVGQrckrFCdTsh3JGsRm3KN2Dxbwdib2bqOaF8oPTeZyEGNpy3Gs23k8z7+PtRR22iA5TKGTg7MDBGb7nx+iqa6TYXBvhtdZmfLW81jMpGUOUOngJcSbzB3ZHs0YnkKOU3K277cQYH3c2YXXE6I68sY7O6eweFzQasw1qSSFq1jGWKt3C12HxMZpw5gwRkfgJkHGE24AxA6Da0p8Rcn32Znd9mcn2Zt/AR8Sf8GVIUvKq0ZLYCBrk8YyG0YWpqNmKru7sLOUhDyjDd23IhZm9r7MrP6l5izjsNk71KLzm3ToWrFeDiRNJLFCRgzgHrGO7buI+Lszs3i6wj1K1qeX0cM1zUkd+9NNFKenYsJThCjwssG7WYYRkqiAE20u+x9xg8eW6DaPUXq/gtP2qdTK2CrHehknhl7RSQNFHvyI5A34+zwZmd33Zm3d18fSbrhp/U9ieri55XswA8rwWICgOSFiEHmi33YwYiDdt+Tcm3Zt1SPUGCOzqvpYM4hMJ4ytIQyixiRDFHIBExeDu0giTfizLtQVAj6wWmgYISm08RkQCw7zFBEPdJm+kWwB4/8ACyCfah8pLSdHJni5rkhTQy9mzPDWklp1pGJgIZrA+Gwm7CRAxML7s7ts643kX6yyOax+ZnyFuS88Gamr1pJHB+NZoIDjEHBmZw9d33/FU/5NOv8AB6Up53A6krzRZoshME8D0p7kuWE4QiiqC4xlvufc4tJxAmtCTO/MlPP/AA7NvkXNbA8LfLkm0Lu7vE3mlXaJ3Jt3cfZ4+PgglHlja5zWDpYcsJaGlZvZUKUkhwVpwcJIZOLE1mGRhFj4u7i2/h/yXMwum+qI2qz2NS4KauNiErEMdWqMksAyi80YO2LZ2Mo2Jm2dvb7W9q5H/iHNC+LwDWHdq75se+478mh82l7rjszvy4clCum1npLj8vj7mNuZd78VqNqjSxXSjKaXeEBNirM3F3k28Xb2oLwxOdlfqBex75mzJGGOCcdPvQca1cfNqbecDf7m0huZEfHi3jM7f27v7M55Sek6eSkxkluU5IJHhs2Yass1KtIxMBNLYBvoiT7OQsQs7Pu/g6guIHl1hy4sTi76cEeTe0XeDHeLfi2+6h3QPM3tFx5XTWS03lsjftXpSr2KVMZquTjkijgjCezM7A1TduXcZyEWnk5CLiW4aQ0H1awmaoXsnTsONHGySRW7NkPN4o3iiGYz5G+zxsBM/JveovpfyltJ5G9DRhs2IitSdmpYtU5q9S1JvxYI5pG9V3LZv6jD4kze12ZZs6W4C/kOm2sq1CJ3sNnAlKrWdz5w1mozWIIeDv3WGMHdhF35MDM2+7b/AChkaGosTgsHZ1Z486MVTE19Fl5xjbIx9kRG1WlHmIOTs8gE7mz8nZ/HYNcdQOt2nsDkHxuUsHWsNT8+3eAyieF+5xETHdzmIoiFgZnd32Xp0D10wGcpZG7j5LMrYqArNys9YxuDAImfcigZ377O0Z7MDu+7M2zO7M9V6gx8Z9XsHHYYbBQae5sUgs7FPHBkmaXg7u3Ld3Jt99n2dvFmdfR0WqRR9T9bxRhGEb0oCeMRFgd5fMDldwZtn5GZu/vc396C38b1awljT8mpo5z+SoRlKSQoiGYXhm7BA8L+t3Hk4sw/XzH3r0ZvrJgqOEq5+5PJWo3hYqQywm1uyxbuHaqjuZbizFv7GEhd3bdZC1Bgb9XKXemFdpAo5XU1TI15m9gYo4SnkEWLfk0ccdc3dv7qJ+92Vl+WXh5sfkdHZKEipYfFO9TzwaAZOHEyMcHm08lGQmGVmCMHFn+ut4bkws4Xj0q6zYLUks9bHTSjcrg0s1K3AdW0MTuw90QPwkBnIWdwd+PMN9uQ78TX3lH6Vw16TH2bM09mAnG0NKsdkKpM7MQzSjsPMX8CEXJxfwdmfwVUdFYaub1rDmYdUFnb+Px0g2OzpeXFV56skc8ARS2WlYGlCScD3ON3JgEWd+Pq8Lyedd4XRf8AtJiNXDJXy8mSlllnloTWXydYomAAE44yc4ykaeRu5sBNb3Z/EtgsTyiPKNjxNHB2sFLBY+Viay0lirOcRYwXOOUxFyjOOwMzC3Am3+l4Kz8V1hwM+CLUb2nr4kTkjeezEcRlJGfbcI4GZ5JJHJnZhFnd9vYqJ8sLNU8hpDS2Wx8MsWNfK0poweq9cq1ZqtkAjeHZmjBuHEePqFsPFyZxd/f5VGarag0/gdQ4qOXKYDHZrzjJQhBJF3a8TtHKZwzCJNEzjNE5O2zd/f2bugtDQPlHaWzV2PH1rM0FqcuNUbtc6wWifwEYZS3DkT+AiTi5P4Mzv4Lpa565aewl+xjclYkr2a1RrkjPAZAUZsLgERt/iTE5MzAzb77/AFM7rPPlFa5w2t209idJDJazI5COWOeOlNVLG1RiIZAOWSMXCMZHgkd43cB81338B3kue05SyfWAYb8MVuKDDRWWhmAZITmircYykiLcTYXk5MzttuIv9SC29W9e9PYuHGyWZbJS5WlDkatSvVOxbanODGE80cTuMQ7bt4l4uB7b8XdTLp5rLH5+hFksZIU1SYpACQ4ZoC5xE4SDwmES8DZ23bdvB9ndZx8po8LU1JUtQZ2zpTP0sXFHDP8AJtizjLNTlY7dX+gDsBDu/LcTj2cG4uTeFo+SRrXIZ7TgXcjFCEo3LVcJ68Pm8N6OMhIrYxMLCJFMcwlxZmcozfZn3Zgt5ERAREQVt8/OjvvvG/8AWf8A7U+fnR333jf+s/8A2qR/N7gPujD/AJZS/ST5vMB90Yf8spfpII58/OjvvvG/9Z/+1Pn50d9943/rP/2qR/N5gPujD/llL9JPm8wH3Rh/yyl+kgi1vrdomYWGXL4mUWdiYZDYx5NuzPsQO2/i/j+K9VTrPoaF3eHK4eJ3bZ3jcAd29zuINuyl3zeYD7ow/wCWUv0k+b3AfdOH/LKX6SCNv130a7bPmsZs/g7d72t7vor4cZ1e0FVcyq5LCVikfeR4GjheR/bubxxs5P8A6qZfN5gPujD/AJZS/SXj5vNP/dGH/LKX6SCLB1s0Q0hTNl8S0xNsUrELSE2wtsR8OTtsI/X/AGt7l+Q61aHEjNstiGORnaQ2IWORn9rGTBubf6qV/N5p/wC6MP8AllL9JPm80/8AdGH/ACyl+kgicfWjQwxvCOWw4xFvyiFxaMt9t9wYOL+xvq+pl4PrNoUgCN8rhnCN94wdwcI3fx3AXDYX/wBFLvm8wH3Rh/yyl+knze4D7ow/5ZS/SQRV+tmie40z5fEvMzcWl5j3GbZ22aThy22d/Df61+Pnp0QxSGGYxUUsrOxzRmAyvv8AW59v1nZ2Z/Hf2Mpb83uA+6MP+WUv0k+bzAfdGH/LKX6SDK9/C6ZmiOifUfKyYqV+MlGa88xHE7bFCUxPxeN239Xt8f8AhV06D6n6BwmOq4vH5jHRVKkfbiF53IyciI5JJC4tylOQzMn2bdzf2exT75vNP/dGH/LKX6SfN5p/7ow/5ZS/SQRS71p0PO7PNlsPM47sLyuMnFn2325g+2+zf/C9MXWDQQExhk8IBC7OJC0YkLt7HYmj3Z1Mfm80/wDdGH/LKX6S8/N5p/7ow/5ZS/SQRJutWiReQo8xiopJWfnLGYDITvv6zlw9Ymd9/HfxVCX8LpmaI6J9R8rJipdxkozXnmI4nbYoSmJ2F43b2j2+P/CtUfN7gPunD/llL9JPm8wH3Rh/yyl+kgr/AEH1N0DhMdVxVDL42OpUjeOMSncjJyIjkkkLj68hyGZE+zbuT+Dexfbjur2gaxnJXyWDgkl/xJIRiiOTx39co42c/H3qZfN5p/7ow/5ZS/ST5vNP/dGH/LKX6SCKh1s0QMhTDl8S0ptsUrELSE3qtsRsHJ29Ufa/9re5ea3WzRERGUeXxMZSPvIQGIFI+5PubiG5PuRe3/M/vUq+b3AfdGH/ACyl+knze4D7ow/5ZS/SQROPrTocZSnHLYcZzbiczOLSmPq+qUjByJvVHwd/7W9y/GT6yaEtcGs5TC2GjLkDT8JuBf5g7gPxL8WUu+bzT/3Rh/yyl+knzeaf+6MP+WUv0kEUDrVodnkJstiGKVtpSYhZ5G90jsG5t+DrzF1r0QEbxBl8QMTsTPGJCMbsX0mcGDi7Pu+/h4qV/N7gPunD/llL9JPm8wH3Rh/yyl+kghlfq7oGMAjjyWDjjjJzjABiEIzJ2ciARj2EncWfdvcy9uT6zaFtR9qzlcPZid2d453CaPdvY/CQHbdS75vMB90Yf8spfpLx83mn/ujD/llL9JBF6nW/RMMYxRZjExRA3EI4zYIxH3CAizC34MvnodYNB1zOSDJ4SCSX/EkhaOI5Pr9cwjZz8feph83mn/ujD/llL9Jefm8wH3Rh/wAspfpII58/OjvvvG/9Z/8AtXNi6t6ADu8cjgh7xMU3EYm7pM+7FLtH/ULfx3fdTX5vcB904f8ALKX6SfN5gPujD/llL9JBEy606HcoyfLYhyiZmiJyFyjZvY0b8NwZvcy/Xz2aI7ne+V8T3tuPd5j3OO223Phy22+rdSr5vcB904f8spfpJ83uA+6cP+WUv0kEQn6yaEkmCweUwp2IvCOc+BTRt/wSkHIP+Tr20+tuiIWJosviYmJ+RNGQgxF7NyYQbd9vrUq+b3AfdOH/ACyl+knze4D7ow/5ZS/SQRS71s0RMzNNl8RKwvuLSkMjM/s3ZjB9n2Xzt1c0Czs7ZHBs7PuzsMW7O3sdv6ftUz+bzAfdGH/LKX6SfN5gPujD/llL9JBFG62aIaR5my+I7ztxeXkPccfBtnPhydtmbw3+plSWo49PWJ7hV+o+Tq1L00s09Pz4pAbvyFJLHAQFGMMTuZNxENttmfdaX+bzT/3Rh/yyl+knzeaf+6MP+WUv0kFYdJtb9PtM4yLF43M0OyBnLJLNYYp7E8m3OaYhBhc3YRbZmZmYBZm8F3YOr2gY5ysx5LBhZPfnYAYhnPf28pRj5l/zdTL5vNP/AHRh/wAspfpLz83mA+6MP+WUv0kEUfrZoh5GmfL4h5Wbi0vMe4w7O3Fj4cmbZ38N/rdeY+tmiBkKUcviRlNtjkExaQ28PAjYNybwb2+5lKvm9wH3Th/yyl+knze4D7pw/wCWUv0kETLrTod5msPlsO84jwGdyF5hDx9UZOHJh9YvDf8Auf3r22Ouei5BIJMzizAmcSA5OQkz+1iEh2dlJ/m9wH3Th/yyl+knzeYD7ow/5ZS/SQRDFdY9CVAeOrlMLWjd+ThX4Qg5e9xjBmd/xX4yfV7QVogOzksJYOLxjKdo5ijfffcHkjdwff3KZfN5gPujD/llL9JPm8wH3Rh/yyl+kgitvrbomaMopcviZYibYopDY4yZvYxAQOLt+GyVOtuiYYxiiy+JiiFuIxRmwRiP+VgEGFm/DZSr5vcB904f8spfpJ83uA+6cP8AllL9JBDcZ1f0FVcyrZLCVykfeQoGjheR999zeONnJ9/evo+ezRHc73yvie9tt3eQ9zbbbbnw5bbfVupV83uA+6cP+WUv0k+bzAfdGH/LKX6SCIZTrJoS0LBaymGsgz7sFjhMLP72GQHZnX0w9dNGALCGaxYiLMwiMvERZvBmFmHZm/BSb5vNP/dGH/LKX6S8fN5p/wC6MP8AllL9JBHfn50d9943/rP/ANqfPzo777xv/Wf/ALVIvm80/wDdGH/LKX6SfN5p/wC6MP8AllL9JBHfn50d9943/rP/ANqfPzo777xv/Wf/ALVIvm80/wDdGH/LKX6SfN5p/wC6MP8AllL9JBJ0REBERAREQEREBERAREQEREBERARcPX+ogxGLyGUOMpgx9OxbKIH2KRoIik4MWz8d3Hbl9W+/1KmuhvVfVWfnpWDpYCfD3Ck78mPyfK7hxYDMBvwGZEUz8QZgYG3eQd3Bn8A0CiztmetOpMnn8lh9H4yjehwknZyVvITFEJzCZxnFE7SxtF/VimAXfny7RFszMvz0w69ZbKx6yK3QrUJtNU5Z4qjlNJINiIb3cr3JObNIwyVWF3Bg38X8PqDRaKg6vW3In08PWD16fnwuW1babzTYcv8AJ7f+p3N+1630vpfh4LvZrXuopNNYPL4ejjbNzJ1ali41y41OnSazUax3G70ovJHz3Dbny9YfB/F2C3kVFdD+suVyWau6cz9CtSydan5/DPQnaelYr7w/RLuGz7jPGTEBkz7SM/Bx2eKdF/KB1JqTIQ0q+IrlFBkuGWvwtK1anjX4hHx7s/jcIxsP7X9UG2AvWcQ1AizZc636ny1rLFpTGY2xi8JPLWls5GyQT5GWHd5BpRhKDBuwu4s/LcSjd3Fy4NbXQzqNX1Tha+WgjeAjKSGzWc2kevahdmkj5szcxdiAxd2Z3GQHdmfdkE5RUf176wZXAZzB4nG0IMm+Wjk2gIzisHO0nbijimc2iiByceRmLsLMTr4ui/WLPXNS3dL6lx1TH3oapXIDpmZBwbskIFykkCYSim5NIBNs8ZC4778Qv1FBOoPVHHYC7TrZUZ6la7DYkiyhjH8njNWjKU6csnPuRWSjHcBcdj3Zhd33Zvls9Rzm0nc1NVqT1u3i7mRp1skICcgQQSSwSShXlLjDIwMTMxs7iTP4boLFRZEt+UhrEMJS1K2Dx7YV5Xht2Cnk5Tn5xJCxVo2neSrDyFo2Mwk3Nnf2OzLVmm8pHep1LsTO0VytBajYvpNHYiCUGL8eJsg+9FnLUfWnU56ozmmcHiaWRnoQRy1ZJJigaMShqSyTXDkmEDHexwEA4O7mHjsL7xbTvlEa0yuPvljcBTO7hHlfMTyTG1YAjYnaKCocwSla/pWOQNIezRN/nZkGtkVO6H6q5POaOHP4vH1pco5FC+PmtNBVeWK00E0jWZeLDG0T93iTt7HHk7tu8W0T1vz8WexuF1Nj8ZCGZ5hQu4m4NiJpgb/Dk2mlEvW4A7bi7PIL7OzoNFosW4HUesG6nZyOrWrT22hEJ6E1smpQYxmxYx3IRewwedPW82NxZ/pWJW2+ppz1F8oDPU9VZXTGKxUGTsQxVxxog03dKxPUp2zluP3WBqscc1jfbh7I9yFt3QaFl1HjwuR447dMchKPOKgVqAbkgcZD5x1XPumHCKUt2HbaI3/tddRZrt5SIup2n4LeNqNlJMC055Bp77WK0j4/J96vHAFp6hR7tIO5Rk+0hes7sLt51l5RV7Tt3OYrPUoHyEEUc+nXpBZ7OYjsSlDB3BMjeJ2fYi2L/wBGwDbkI8g0mvBFso905tZSfGVZ81HXrZGaNpbFaqJtHWc/WGB3kkNzlEXZidn25cmbwbd491+1Z8k4O1IBcbNlvM6uztyaWcXYpB97hG0hf6iyj1dSNOk2nxHK1stpqb3cU0NP815isfr/AJlPa9kJN3AgNmfZ3AhJmf3Pxfwde5lmToD5zpzODh7ji0eYo17MXHfgFloykGP3MbM08ZP9bxx+9mWmhdR7bX+dTMxiY4mPaV7rnSo6Xufl1v30tEWpeIxFqz9PvEx+jyiIrDHEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQcTXY3Xxt0cdFVs3irSjWguu7VJZTFxYbGzPyi2d9x8GL2O4s/JsqaI6VZ6TU+FyVXToaNGlZ72Ys1sxHaqXod4iOtXpRmXYExCQOEbkG03rbcW32MiDLtXSmsNIakz1zA4yHUGL1FYe44FcgqS1bJSzzCMhTGPAQOzO3sISHtvyEmdlH/JtwuQv5Tqbj8jJXbJ3ovNbcsDG9WO1afJxn2mL1ngA5Nm38eIMthLi4TSmOpWbdypVr17V82kuzxRsEto2IzY5ibxMuUhvu/8AmdBjuroTqK2kLejWw1RqsM3cG292q09mIr8dt69Zns9si7xFJ3D4t2wIdufHeV9SOluoDp6EkfFtnKmCxdatldOlegrs9sK0cZSObm8UzMTMO48/8Jm2cTJazRBl/oh01zFLWtjNS4Krp/FT4eSCKrTuVbMcE5PV/pydomd5yeKQicI2BvBt3fd3lfka6FymBxeUgy9V6c9rMTWogeatM51yr1gAnKtKYt64SNs77+33q9UQYqudDcjhMllI20tU1hQuWTsY24WT8wnpjKRv5vZB5Gc2HcN/VZndndj9ZxHS/QPSfyPhYIJMfSxFucntX6ePnmsVRtmEcRGBzmTiTxQw7gxEIuLsxH9J58iCjOsOhsrf1rpHLVKzzY/F93z6w01cGg5mTt/TklaSTw8fUEl5i0NlW6lnn/NnbEPhWqNc71fbzjtg3Dsd3ve1nbfht4e1XkiCo+vvTS/qw6mMknhp4GMZrVuSN3PIWMg0UkVEI4yi7cdWIj7hPzdz8R2HZiX05LAZ6xonIYrIDWtZs8Lex4lTlZobsr1pIa0nKcIhhlkZw5M7MLFy2dm9lpogzDkumOdk6Vw6cGkXy0BBypPYps7MGaK079/v9h27Gx/T+vb2+Cv7prQmq4XEVbAPFYrYvH154nICeOaGpFHLG5Rk4E4mJNuLuz7eDupBsiCjOnWhsrU6hanzdis8eLyFGGKnb71YmlkjHHMQ9kJXmB94ZfEgZvU/Ft+b0D6fZnGQ63G9VKAsveuT45u/Vk85jlC40bt2pSaJ3eSPwk4/S/120LsiDGtnoxql+nlDDDVdr1XOSXruJe7XB71JykcQaxDM8RbEQHwc2+ju3rADP9VHphmLGpNK5arpOppqhj7YldCtkqNidwE4n84siLx8hFuTCwicj7SOXtFlsBEGZdQ6S1Ti+ol7UeKxkeUo5enVplKVuvAFQO1j4ZzkGSUZHMHoc2bbYhlZmfdn27+kNAZaDqbndQTVeOIuYuOvVuPNWLuTjXw8ZC0IyvMD71rDbkDN6j+9t77RBQ2odB5aTqbitQR1XLEV8VJVmuNNWZo5irZIGF4ClacvXnhbcQdv6jfUzu0J6m9J9VasyGUzVlpMNPiBiHSFHzipIcsledrD2LJwyHHDLK8bbO5M4nJHvuMXr6vRBGemmQydnFVZczUfH5TtsF2u0kEsbzB6pTQnXlkDtSfSYeW48nZ/Zu9b9W9EZHUWepVpYpoMHThMpLYSwf1JpB5m0cbk5c92iBnIPDaT3tvdybKHW0a61e23j/20OmdS1um63z9HHfiYiZ/tmYxmPrjxlnHXnQg6EMF3T53LWQrWoJQhnlr+IgXJijImjZiGRgLZy8WYmWgcFYllrQSTxFXmkijOWAiAihkIGc4iKMiAnEndtxd28PB3X27IuujtqaNpmnGfT0T9R63u+paVKbme6aZxefzYnHGfaMZj7yIiKwyBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERARE3QEXwZrM1aUYy25oa0ZyxQCcxjGJTTEwRRsRPs5kTszMvuYlzicZMPKIi4BERARHdes5Wb2uzf6uzIPYi8MS87oCL8SyCAuROwiLORE77MzM27u7v7GZl8uFy1a7BFaqSxWa8w84poTGSOQd3bcSF9n8WdvwdnXOJxn0MPtREXAIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIg+TM5GGpXntWDGKvWhlsTyE+wxwwgUkpk/1MwCT/wDJfzJzvXXUc+bmzEN/JxV/lEbcOPa9ZGkEITdyCnJXCTtPG8UbAQ7etsbvvu61f5fuv/k3AR4mEuNrNyFGezuzhQrOB2X3ZvDmZQR7P7ROX3OqqwHTPGSdMJxKzj2zVg/9oYwK1WedvNwJq9TbmxcioPLsD+ySy/uQbQ0Zn6+Vx9LJVX3r3q0NmLf2sMwMfAvcYu7i7fU4uyifVnVtjHSVI62Q09jylGUpBzkkwFKIvGwFW7RjuLO5sW+/tBUn/wCHfr5rOOuafmL+rjje5SZ3bcqVk/6wC3tdo7L8nf8A/Vj7leHXHp7HqLGHX9ULkDvPQmLw4TsOzxm7ePZkH1Sb6txLbcWVzp/yP6mnz5xTOJnGcR74n28pNHt747vCN5arqbK46Rp5dHXcZbgcjPhkjry13bl3BlaTiwszcmNn8HZnZ2dl9Hk95vjW+S7GZxGZsQM51GoWXsWApBwF2nI35ygBmAsbt4MQs7u7ssuwa8y9HD3NLuJgElsozB2LzmAXImt4+MB9oyz7O7N/mlbZ+56uqPJw6aNgcb3LAt8p3mCW2/qu8AM28VMCb+0N3cvbuZG/sYdvWdb6R/wzZWjWvX8V/wDlRSI/FWP7pn04nHHn7YXtzo/K057pjzxiP5Wqyi2vuomFwHm/yxdho+dd3zfutK/d7Hb7vHtgW3HvR+3/ADspSqk8ofpXg9TtjmzV6fHtSe29bs2adbvPYat3eXncR8+PYj247bdx999228OzX0ekRov75p//AMLP6KkehOp+Bzs0sGIvwXpYI2llCIZmcI3JgYneQGbbk7N7Vnn0UtDffl78zw/7VWb5PnR3T2mrluxhsjYvzWawwzRzW6NhgjGUTYxGrCBC/Jmbd928UF0uyqfrh06PJRz347Fl569dihpcmes7w8jNwD2jMYu/rM/tEVbC52or8dWrYszPtFBDJLI//CAu7t/z9n/NWtnuNTb61b6fnP7/AE/Vf6ZvdfZbqurofmzEYxnPPj9Vf+TpqmTIYx4ZzKSxRkaF5DLkckJCxQGRP4k+3IN38X7e77u6mHUHLnRx89iOxQpyB22jsZQjCiBnKAM05A7E27O7Ns/0nFUB5N+c7GaOEmGMMjCYsH1NLG7zwiLv/a0bzM3+rLSOcxcF2tPUtAM1exEcU0ZewgNtib3s/j4O3izszrR6ztqbXqE5j8M4tiPafP092z8W9PrsOq3iIxW2LxH38/tOYVdp3UGp8kMhY+/oy8MRMMj1nyEzRkTbsx8JX4u7eLbqP9P5ZMHnbUV3MaYqwXJWe3haliUCjyEwj2pKtewW9aaUjj5Az7Fyb1d9naoZpsp0+z1uOD+tDNAYQlN4Q3axsT1Zz4eHfhmfZ22bxGVm2aRiU48lPp5LetHqfKcpf60p0e79KzaMi84vm3sdhIiEN/7nItm4A69LvOj6W02mpuJ1K/IvWvy5isd17TzjHpjHM+Y/dmamjFKTbMdsxxxHMtSivK8CvK+fwyhERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEReuzCMgHGe7gYkBMzuLuJM4kzELs4vs7+LOzoP55dUDsdROoBY+nLwqjKWPq2HB5Y69Gi0h2rnAXZpGOVpzHxHl3Yh3b2qwW8ho/v8Pyd/3607ojpXp7CWCt4rHVqVk4igKaJjc3iIgMg3Mn2ZyjB/D/Kpmg/m9SpWemeuqg2JnsVoCh71gYyhG5i7wdueTsCRv/TfuOwbl/UqN+C3F1o6iQYDFFcFwls2G7ePi33aaYx3GR9n8YAH1yf3Mzb7ky6OuemeBzksU+WoVr00MbxRSTMfII3Jz4M4E248nd/H3v716c70uwV4KkdukEwUaw1KgnNZ4wVwZmGMGaVvqEW3fxfiO7vs21nZW29NxW24iZpE5mI8zHtyk0prFom3hjVtDZi5h7WqTKSQGtkZyO7+cyjzLzjIAQv6scc+zeDNtsZNsweOqfJv6lNn8b27BN8p0WCK23gzzg7bQ3BZv7ZGZ2L2bGJ/U472LTw9aGqFKKGMKgQtXCuwt2mhYOHa4v4OHHw2dR7SXTHB4mx53j6UdWw0Zxd2OWd3eI3FyjcTkcSF3EX2dvaIv9TL0nVviTS6ttraetp4tW2dKa4/DTx2z9OPT1+i1r7uuvTFo59PsmKpXyn+h8ms2xbBeDH/ACa913c6j2nl87802Ztpg4MPmz7+3fk3s28bqZF5JRYq9Byf79h/Kj/eK2vJl8nyTR127bPIR5BrdUazANMqzxuMoy8+Tznyb1dttmV9ogO6pzyj83IcdTCVX3sZKaLmzbu7RNIwxi+3sYpuO7/5YzVxG26jEmhseeT+V5IzkuiwtGRyyPHFwB42eOLfgz8Xfx29ru/tdXdhr6e31o1LxntzMR/1en88tTo270Nnuo19WJnsiZrEet/7c/SJ5/RSfWfB/IN7C36YuwQQwReGzcpaDi+xP75Ii4v+AOr0h1djyoy5BrML1YYO/PKxsTQhw7n9Rh8RLj/b7V+9YaWqZas9W6Hcj5jILiThJHIP0TjNvEX2d2/Fndn3Z1xafS3Cx0Zcc9bu1bEkctgJJpnKaSF+UTyGBM5CL+LD7Gdt9t1c197obrb6ca3d30nEzERzTOffzHOF/fdV2+/2GlXW7vnaea5xGLUmc8znOY8Rwy3ciyvUHOXJa20UNavIUAzO/aq1xY/NYT4+DWLEzes/jt67+LRsymnkn9RJKVk9M5Jyj3mlGj3fpV7UZH5xj5H/ALeRCbjv7DYx3fkLLRGjtHY3DxyQ42tHUjlk7sjRuROZ8WFnIzdyfYWZmbfZv+a5Oa6V4C5cK/YoQncOQJSnGSeI3lj49uT+lILNI3AfWZt/VZbe6+J9rutvfZ20pjQisRpYx3UtHrPvnPP+SzL7yl6zSY/D6e8SmgryvAsvK8XDPEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERARF4Z0HlERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQRHX+pRoHTie9j8eduQoovlCvPOM57xiIRPFYiGMmc235O+/JvZs65GjshJDnLtGxl6VyeWEbJ4mCvZGapKLRcpwkmtzdiuURxbwuzDyMCHjzJj4vlYWcaOnpobwPNYsSBHi4Y25TvkNn7ZxNs7sIi58tvaJEHi5szxnyTDhr2MzRyAyx6lGYZbvncjS2JqvCPtvGfi7xiZs5eJb96Mt9iFh3tDp1LdLtuszmMx24jnmv4onz2xnEzHriM4mVuulHyJuuvWuqqGFpS5HJzNVpwvGMs7xyyMDyyDFGzhCBG+5mLeDfWoPhPKF0dds16dXKxy2bc8VavE1TIC8k88gxRRsR1mEXIyFt3dm8fau/1prX5cNZDGY7H5q451nix2UCE6UzNYieQpRnkAOQAxGO5N6wDtv7FSWi8LrEMljytaL0ZSrDeqlYuVYMc1qpA04PLZrOF0iaeMORjxF35C3g6wVRqDdQq31Y01Ff+TJMtjQvdzsvXKyDOM3Lj2TPfgE3J9uDuxb+GykGro7JY+8NJ3a4VO0NV2dmdrLwSNA7O/gz9xx8V/PbScdObSlnHZC7pHGGFqZrnyljcmWqILQWd2kGSDeSQmbYP6cZMwOYG2/NBtbX+q8jU1BgaFaxhoad8ja1BeOUclY4GzO2NEH4E7D7eXvXZ1X1O0/ibIU8lk6FO0bC7QTziBiJ/RKVv/RB28WI+LOqD1xRsVdVdK61qcbdiCpLDNaBycbJxwQg8zEbMRc9uW7+L7qN4u7idPav1UGssVNkJsvdKbDW5Ma2Tjs1ZJJXCnViMXbuFFLAHqb/4JATjxZnDWWnNYYvI+d+Y261rzGV4bbwyMY15B5bjIXsZ24H9f9rrkad6r6byNzzCjlcdauO7sEEVkCKVxZyJoH+jYdhEn/puXgLv9SyF07o3JNH9S4MVWnqSNkgFqPi9ivSjsG9uk+27kcdMZQJm33YSbx3XxYinVytHStetldE4y3FaoPjvM6GRhzcd4WZ2gyEoEfrlOzcpJGYDkEHEvWbcNoag6mYDHz2Kt7JUatipCM9iGecY5Ioj7TAbi/i/J5otmbd35tsy8h1KwJY35YHI03xbSNCV1pWeAJXdmaKQmbeKTdxbiTM/rD723oWPTePynVzLwZKrVvwxafgnGC3DHYhaZo8ZExvFKziTsEsjNuz7ct18Hk4aJrZPE9Q9PcWjqS5u5Urh9IK5R9xqkgs+/jHJDXJn/wDyhQaX1DrPFY+Ctau3K1evcOOOrLJIzBYOUHkiGHbfuOQM7tt7V8mtuo2DwhRBlchToyTNyiinlZpTHfjzaIdzaPdnbk7beD+KyX0Inu6ozGlcLfiMIdB1rZ5ETb1Du1rT1qEWzE7OcYw028fb2rGzbLzqqaWtr7VDZOXTNeSzHCVKTV1OxaqSY54+IhQMTGKN+DCBM77k4GLeLGyDZlPO0pqg34rFaSiUTzjcCaMqzwizuUvfZ+DRszPuW+zbPv7FHNMdV9N5Oy9OhlcfassxO0Mc48zYGcieJi27zMLO/qb+DO6yZl9N3K3TDK/Jl+HLY6XOtbN8cF2OKvQAmjuVxiuA0wVwtRwyexx48jd3Z3J7o6Zag6aS3cHFh48S2UkryR4/s0XG3F/Q5TBalaJuFlwaRuUz8nd5eL+s+4dXpN5QuLzuZymJd6tbza0FfEzNceZ80BFa5SwRvCPbYQgjJ25F/jN4+HjOdW9UtPYmwNTJZOhTskwv2JZxaUGNtxKUB3eEXbxZz2ZZy8nKPT9DXWr6VqDHV7nyxFHp+E6cXchYJMk8w47jG/mo9koN+Dizjx+plxujeR0lRm1bDrqOm+c+VrklgsrUKzLNTdmIGokUZExvJ3DbtbETHCQu7MOwa4zOtMTTox5SzdqRY6XtPFdeYCrSNM28TxzA7iYk3sdn2de/T2qMfkZLMVGzBaOmYRWmgPuNBIYuQxmTeDSbM+477tt47LC9mraj6UZApAnioTalCbDR2PpjjzOPYh8X2jeZpv8AUmkJt2JnfZPRfQeMwGLrwY6EYnmgry2pndymtz9pnKecyfcjdyLw8GbfZmZvBBN0REBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERBzshhKdiWGaxXrTzVi5V5ZoY5ZIC3EnKEzFyifkIvuLt4i3uR8HTey1169d7jB22t9mPzlg2duDT8ebDs7ttv8AWugb7Mo5jtaY+fIS4sJCa7CJEUZxSxsTC7MXakMWGXbf+139j+59pKV1LRPbnERzj0j/AES6enq6kT2RM9sZnHpH+iSMi8M68qNELg3NF4ea2N+bHY6W8Ds43JKVY7QuP0Saco3NibZtn38Nl3kQfBcwtOaaGzNXrTWa2/m9iWCKSevy+l2ZTFzi3/4XZVprXpdnLd+3cx2qcti4brg8lJq8FqCDhEEO1PkQeas4xs/q+Lk5E7u7u6tndRbpx1BxWoYbE+KmKxFVsFVnIoJoHCcREyDjOAuXqmPi27eKDndFemNLS1A6VSSezJYsHbuXLRMU9qzIwiUhbeACwizMLfi7u7u7v3cdovD1rRXq+Ox0F0+TnbhpVorJOW/J3nCNjd33fd9/Hdd7dEHwR4WmNk7o16w3JAaKS2METWjjbjtGc7D3CD1A9V329QfcyYrC06jzPVr1qz2JHlnevBFC88ru7vLM8Yt3JHd39Yt38XX3og5+OwdKtNYsV61WvPbJjtTQwRRS2TZyJinkAWKYtzN9yd/pP718+pNLYzJiA5GlSvjG+8Y3KsFlo3fbdwaYC4v4N7Pcy7G6boPnqUoYYgghjjihAWAIYwEIgBm2YBjFmEQ2+pm2XKwWjcRQmksUcfj6c8rO0s1WlWryyM77uxyRAxEzv73Xd3UWxvUDF2M3c09FMRZWhXC1arvBOIxwGNUxJpyDtG7jcr+qJO/rP7n2DpFpfGvcbIvSpPkGbZrz1YHuMzDwZmsuHcb1fD2+zwXq1Bo7E5CSOa/j8fdmh/wpbdOvYkjZn32A5gchbf6mXc3TdB8GVwtO3C1a1WrWa7cXavYgimgbg2wbRSC4er9Xh4L7YwYWYRZhEWZhFm2ZmbwZmZvYzMv0iAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiICIiAiIgIiIPD+xUr1xzcVLNYOyDP3qRFPaMfZHRnlirv3Nvfyk23+vf3q6j9iru/0786bOFcnaWbL8I4pGidhpV6+71IxEjfuOJvzJ248n+pvar/TtXS0tbu1PGMY988T+0TMtnoe42+23PzNefw4muPeLfhn9q2mfrMRCwoDYmZ28Wdmdnb2Oz+LOs1eUNkKsWckGbXF7TJ+bVn+S69W5LGLbFtOxwysDvJ7dmbf1fFX1oTGW6dKGtdsBbmiFgaYIniZ4xZhjEmInczZm8Tfbd39jJmtFYa9M9i7jcZcncRB57VCrYmcA34i8ksbk4tu+zb+G6pXiK2mInMe7K1a1pea1nMRM4mPWPfnE/urryXrcEtbIvBqSzq1msQs9izBYgem/afaEWsGXJi+luO3s8VxvK96m3sIOFxuPsfJ0+atyBNk2qncOlTrlXac4KwATyzP5wHgwu+wEzbOTEN0af07j8cJjj6dOiMpMUg06sFYZCFthI2hAWMmbw3dRXrR0wq6mrVgknsUL1Cw1vG5Ko+1ilYbj6wtu3MHcQdx3F94wdnZ2XVGpjoR1JyI6pjwhZO/qPDX6ckkF+9ibOPsUr0ISzFCZzRC5xlFCXi+47yRceLsTFwdHdX8xR0VqzLvL5zeqZ88dRlkhh4Vgl80iCQgAGE2j7pk3NnZy4M+7eCvrpb0/zONtz3cvqG/npJIGrhXOvDRoRAJsbS+aRmbFaZ2Ju6LjuxuxMWzO0XxPR+LAaa1Hj3hPU45SxZv/ACdxCgc0koQiNcJnlLtkJRCbSs7EzjuLOTMzhVHVibWundLVs5/tSV075UnnhetXFoitRvMD4214vII/RceIiQu5Mw8WZSHrr1WvhmcTp+LJz4Ko+KgyOTylWhNkb0xygXCvBDBERRj6gu8jbNvKW7+qwlVeY6VWspBXxGI09qqrKdiISuakt74/D1ubPO1CNhCI2LwcjdnPjG4iLua1J1L6Ntk7GOyeNyNnB5vGVhpwZKtEE4y1WZ/6NqqZC0wM5SbNyZv6hbsXhsFUdOOqmZkxGtqc12zkHw+IuX8JnpaEuPsTRjVmdu5DNEL92OVonZyZ33c/Em4qGZrVmuaeksPrN8/3AKcIXxj042CSIrNkGltTb/7zIRRMLjwHiJNxJnHx0jhul94cJm8Xks5fy1nOV7MEt21DGMNR7FY629OiB7QxsJM7xtJxdwbbju+/Hz/QYLejaekfPzjCnIBtf80Eik4TzTsz1u+zD/jbb83+j+KDl601nk8PrTTsli0bad1HTKqVeUgavTybRi4EBuO48yKqzMRePdm9y5fSXXeQyWM1hqe/lZMbiDsXK2BlmijOHHQQ8giuhCQP5ybySVhaN2LkcUgszuWysfrj0mg1RhIsRLP5rJXlrTVrrQNOUUkDds37PdDkxwlIO3NtnIX8eOz/AIs9G8fJpAdIEcg1BqQwPZiEY5SsxTBbe5293HkdsXkcHd9+RNv9aDOmL6o5vGZXT08Wocln6GWyVepZgyOnZ8TXlr2TAGnpWJgcJB2k5D2zF2cB3Yhd2U30tIQdV9bmDuJBpuEhJvaxDSwDs7fizsu9L5PWTtDhRympreQHBXatmlD8l1a9ZoarxcIiCKbuST7RMPeOQ3ZnduPi7vN8L0njr6szGqCtFL8r4+PHyUHgYQiAIsfE5tYaR3k3aj7ODf4r+Ph4hUGjuomam6WZLNy3pzy0Mlhorr9vugwXq8QszMHHbgRN7P7nXydRusOUhxuh8cGQlxsucw9XIZfNhSK/bCN60bk1etCBEUpyNK7uI7tuHiLcnXZDyTONXIYyPUOUDDWpO/WxbRf0IJ2MCGS03nHG7xYG8GGLcgjJ93BlONU9CIbmM0/XgyFnH5bTVWCtjc1VjYZP6UMUJ96q8m0kJ9oS7fNnbcm5OxGxBD/Jp6jZKfP3sFYvW89jPNHuY7L3MbPjrIHGUQy05wniB5H2ld+T7+MW7bMXEdKKAdKNDZTFSW7GVzt/P2bbRBtNFHUpVwh58XrUoyMYZX5vyISZi2bdt23U/QEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEXrtWI4gKSUgjjAXM5DJgABFtyIyJ9hFm+t1xtMayxGUeQcbkMfkChZnlGldr2ijZ3dhIxhMnEXdn2d/B9kHdRR7UWucLjZBiyOTxlCUm3GK5fq1pHbw9ZgmkEuPi3jt9a7lW1HLGEsRhJFILGEkZicZg7bsQGLuxC7fWyD2oo3jNe4O1aejWymLsXWIxepBfqy2OUe7SD2Qkc+Quz7ttu2z7quMJ1jm/wBstRYLIljqeIw1GK2F6UiryM8gY19rM803Z48rcu2wj7Ab6n3C60XP0/m6WQgG1Qs1rtY3JhsVJ4rEJED7GLSRE4uTP4O2/g6+q5ZCICkkIY4wZyMzJhARbxciIvBm/FPJEZ4h7k3XFwuqcdeIgp26tkxbcggnjkJh325OIvvx/H2KM4PVGQm1Ddxsj4/zOCIzjaKeIrrOzVuLyxNM5iP9U994x9oe9t567bUnuzGO2Mznjhc09hrX74mMTSvdMW4nHHiJ+6wEXCsavxkU/msl2mFjdm7JWYmkYn9guLluxfg/ivqw2fp3QOSnYr2o4y4HJXmjlAC4sXEiB3Zn4uz+PvXSdLUiMzWcfZDbb61K91qzEe8xOOfDpouFjtX4uxP5tBdpzT+LdqKxEZ7j9JmES3J2+vb2L2ZDU+Przebz26kM/B5ezLYijk7bCROfAiZ+PEDff3CXuSdHUicds58+J8OZ2utFu2aTnGcYnOPf7Oyi4lHVWOnhmsQ3KksFdnKeYJ4yjhFm5O8pM+0bcWd9328F762fpy1iuR2a51BYyK0E0ZVxGPfuOUrPxFh2ffd/DZ1xOlePMT7ePVxbb6tZxNZjE48T59vu6iLiPqvGtWG49ym1UicBsvYiaEjF3EhGTlxcmJnbbffwde7DagpXmJ6dmtaYH2PzeaOXg7+xjYHfj/zSdK8RmYnHvgnb61azaaziJxM4nES6u6Kr+mHUGe9LmvlAqsFfGyswyszwiEXdsA5THIbj4DEPj4e11OC1Nj2qtee3Uak78Wt9+Lzd35vHs02/B35s4+32tsptfaauhfstHPHjnzGVjd9N3O01p0r15jHjmMzEWiPvifDsJuubYztSOuNuSxAFUhExslKDQEBszgYyO/EhdnbZ29u6/OC1BSvMRU7Ne0IPsb15gl4O7bsxcH9V/wDVQ/LvjOJxHrhW+Tqds37ZxHEzicZ+7qIuJr3JT08XkbdXzbzmtStT1/PJBhqd6KEzje1McgDFX5M3InMWZt33b2qO9KdZT2tPw5bOTYiue9orNihdry4qOKG1NFGY3RsSROzRgPJ+54FyZ+O2zdESeouPpnVOMyYFJjbtLIAD8TOlagtCBe3ibwmXAtnbwfb2rpXLUUMZSzGEUQNyOSQxCMBb2kZk7MLfi6D3Io/pzXGFyUhQ47JYy/KA8iipX6tqQR/zOEEhEw/j7F+9S6zxGMKMMlkMdjzmZ3iC7drVSkZnZnIBnMXIWd2Z3bw8WQd1FzsnnaNWs92zaq16bCJPbnsRRVmE9mAnnMmDZ3dtvHx3X407qLH5GLv4+3UvQs7i8tOzDZjYm9oucJOLF+CDqIo5c15g4bfyfNk8XFecmDzOS/VCzzLbiHYKTmxvu2w7bvuu/YnCMCkkIQABcjMyYQARbciIn8BFm8d3QexFH9Na3w2TkOLG5LG35Y25HHSvVrRgO+3IghkJ2Hf6/Yof0d1rlclf1DBknwjQYy1HFT+S71e1YGN574H8phFblerNwrweqYx+LTeD8XYQtBFGsdr/AAVmy1KvlcTPcciBqsORpy2HMd+QNCErm5Ns+7bbtsoV1b640NPZnDYica8nynJxt2DyENZsVE8kIBYtxmD7REMkhM5EDO0JeL+LsFtIuW+ose1P5Re3TbH9vvNeezD5m8Xs7vnXLtdv/i5bL8aY1RjcpGcuNu0shHGXCQ6VqG0MZ7b8DeEn4Fs7Ps/1OyDrouDmdaYelZip3Mhjqlufj2a1m7WgsS9x+IcIZDYy5F4Ns3i/gyr7ye+qF/UN3U9a5FViDC5PzKs9YJRKSPvXI+U3ckJiPauH0eLeJeHs2C30REBERAREQEREBERAREQEREBERAREQEREGZv/ABBL9iPEYes27ULmYjjvt3vNwlGMHlhglm2do43cZD5Oz8XgEtn4qJYvQWUi1Npm/iMPhtOFDIzWIaWoqtsspi+cTWTGs7AUzhXOXcxYnLuA7+Ii61hq7TdHLVJaGRgit1J2ZpIJR3F9n3EhdtijkF2Z2MXZ2dmdnZQTp90B0rgrg5DH0eNuPl2Zp7Fiy8HJnF3hGcyED2d257ctnfx8XQUrqWGhq7UmpQo6axN48UY08nk8pmLePlnKu0lXlBFXB2rkL1pRaV2f1YQcnbwFq+0FqHJQdJc8NWSVhhzvmXIDdyrULIY87ARkPsjOWY2fbw/3mR/rWrdS9A9K5HJSZW1QYrcxMdjhYswwWjZ2J3sV4pGjl5OLcmdtj29Zn3dd3RHS/B4bH2sVQqAGPuySS2qs5y24pymijglY2tEe4FHEA8PZ4exBU3TPpV0+Cjpm7H5kdlzqTUrUl5wnv5Fou48csTy7SytMzl2GH1SiYdmZnF4XQ0LjM/1W1VVy0PndWHH17A13llijKVquIiEpOyYkbCMp7M77buz/AFMrj0/5N2jqN6PIV8a3fik70ITWbU9eKRn5CQwTSED8X8WYmdmdm29jKZYnp9iquZu5+CAgyuQhGvasPPOQyRC0DCLQEbxB4VofERZ/V/F0FBeQtWallNeYyEj8yoZeGKrERufbYbGWruW7+0yirQM5e1+23uU+8q2zMNGjEzk1eW0Xe2fZiII3OIC/DfkXj9cbP9Sn2iOneJwtrJ3MdAUFjMTtZyBvPPK08zSWJWNgmMhi9e1M+wMzev8Ag23X1Jg62QgOtbiGaA9twLdtnbxEhJvEDZ/Y7eLK50/c12u5pq2jMVnw0+jb6mw32nuL17orOZj+P3jzH1ZzxuCufKeHno1KeOkE4nFoMpBOVqESApjYTl5F/ReTlxZ3Ji/BlJMB3P8AbPPPDv3fMLfa2237nao8Gbf6+XFT7TfSbC4+yFuCA3mjflE800koxl/mESfbm2/gT7uy7NHRtGDJT5aOM2u2AeOQ3mkeNxftb7ROXAXfsx+LN9T+91sa/WNK82iMzmk1icevdE85tPD0+7+JttqTqRGZidKdOszXE903i3Ob2mYjHmZ/TDOnTsdOPj8h8tlI1/uSce53+9x4Ds8TD4FP3u5y5etv7fBeNM2ZotJZjtO4tJkasUxD4P2TjiY23/yk7iL/AIE6mWb0RqWSxNJ5jgZpZZJCG80MTTAxE7gbOe39QW47EQETcfa/tU+6XdPQxmKkoW2jslbIpLg7c4X5gMbRDybcgEAbxdm3d3fZvq0t11PQ09Pv7u6ZtS3Z3d0REecccR923v8Ar200tGdab9821NK/y++LxEV5mIjH4Y/7uc444UN8g2JqWNkp1KdSZjjeC82Ugaa1O7/02eGWRmjm7rM7M3iLjs23sUt1viAyGscfTvDuE9Ws1kBJx3IKtmUhYwfdm7kbeLP7FY9HozgYZxsDXMnA2MY5J5ZImJn3bcCf1xZ9vAt28FILWiqEmSiy5xm96AWCORpZGBmaOSNt4mLg78JTbxb629yp6vXdL5k2rM/lvETjExa3jnunx/kMzcfFuhOtN9Obfk1YrOMWi18Y5nUtOIx6Yx6QqDpvg4a2q8xiomfzIqVmJ4TJzYoyeqTCTl4nx7xszvu+zv71DbeStYypldMMMkks2ShCF+XiQk4s4tv4N3Wjq+Hs/rGtJ4/RtCDJT5aMDa7YB45TeWRwcS7bFtE78Bd+zH7G+r8XXz5LQWNsZKLKyxOVuLg4k0hNG5Rs7RmcTPxIx38Hf/KPuZdKdb0fm92pEzHbT/yV8T9kWl8Vbb+om+tW1onT0vPn5+nHE+fEzmJnzMKy6lwVMdTwWAenHkJ/VKJ5ZzqwtM79qSQiicXPnJKbuzuzeG7+LMo/04pS0NX16zxQ1COOUJYK1g7MPAqskvHuG7l4nGBcX9m3uV4a30Pj8wMTXoiMoXLtSAZRyAx/SHkPtB9m8H8PBlz9N9LcPj7MNyrDIE8DGwG9iY2dzEwIiEi2I3GQm3f8Pcyj0eraNdrbTt3d1otE+sTaZzE/mx/CLbfEe0p0++jfvm966kWjmYm9pmYt+fEfbtznnKndIN/9n63/AP2v/wDDT3HXrsZer/sNDTaaJ7XnpM9fmPdb/fpZ93j+kzdt2ff3Or1wWhMbS8+aGF3HJcvOwlkOYJWJ5HIOMjuzA/dPwb/Mo+PRTAM0jdiZ+5ts72p942YuTNG/L1fq9u/gp69Y2trzN+7i9LxiI/tr248rdPifp19abasXiI1NLVriI5mlIpMTzxzGeFP6+nlKDSVcxaSq2KpSBDJN2IZ5iYQlGSTdmB2Htjy/taUtnbkpF04wt6HUkM0Farj4nidrtSvkYLLNXKORhl7bSOfB5hi28H2dvxdW7l9B421Rr46eHnWqRxx1/XNpYhjBgFxmZ+e/FmZ/Hx+vdejRXTbE4iYp6cJNOQuHdlkKUxAtuQg5PsDPs2+zbvs26jv1rSttZ04jE4tGMcTmc5/NjP6Tyg1fijbW2FtGtZi0xqVxjNZi1pnP54iJ59azOY4l6Ovn/wB1NS/+xZX/APwzrMuA0hNm+lem6de3RqWGy9qaCvkbDV62Tkjv5Z2oc3duUrtykEfHfsv7PpDsPUOHr5Cnao2heStcrzVbEbEQOcE8ZRSgxg7EG4E7bi7O2/goXa6Kaalw9fAy0AkxlQ5ZKsRzWCmryTyHNKcVrud8XI5Dd/X2dnZvYzMvMvBqp8l3K06+ocliLmnamndRtjYprJ4+ZpaNirHJE7tFEEskdRyKxEX9MzY+Dcn3BmexfKq1Zj8Rpm5Lk6b5OtbKKj5i0p1xnkm5GLHYjZzgEWhIuQ+tuA7bO+7djpd0g0/poppMRUaCawLBLYklmsTlGzsXaGScieOLkIu4jszuIu++zbSHXOksfm6UuOycAWqk2znETkLsQvuEkcgOxxSC/sIXZ/b73QYl13pifBZrRV4MVi9PWLOVrPH8k5exbOeAp6bHHZgnHwZhmIHOMiE2nIS3bipp100Vdj1Rm87DTwmrqPm1cMjibdwByGHiipxG/bB5hKs5ADSiYMRO0xbBv6z3Ni/Jw0hWKqcdA3lp2I7Nec7t05gkhcShHuPNu8IuDO0X0N9328V9WvPJ+0pm7h37+PZ7cr8ppa9izVecvD1phgkETN9vEtuT+9BTGt8LW1Vo/SEmnRoY+OrbM6Wn8taYYb8tPuR2KYyyGPnsglDM7k/FzCaV3cHd2X46e6oGni9dVcfgo9NapoY3v3AoTecwHwgNgmq7EQ1ijGUjaIHIX5MTO78lfep+i+mclj6eLtY6B6ePAgohEUsElUTdnkaKeI2k9chYi3J+btuW7+K+zph0rwemo548RVav504vZkOSWxNNwZ2ATlnIiaNuRbA2w7kT7bu7oMu6B6e6Ht9PZ8rcOAsl5pcmuZGS1J57XygvK8UDROf0ubRMMXF+6xs/rc2dcTWWospZ6daOiyk9mLH3sydTIW3cmlkx1eeVqjSk7bmDRBKQ778vNI38dt1pC75Muipbb3CxYCTm0jwRWbUNRyZ2fZqscrRhHu30BZh+rZWNntI4y/jyxVupXmxxRhC1N4xGEI42ZomiENuy4cW4uGzjxbbbZBXWiumOhcdlcZaxcdCLJDVmLHjFeKY7EDgAyWxiOYvODGM3butv4TF7fB2pnoBqKviLPVrI24ysV6t9jlgHbecSu56Nod38BYyNhd39jE7/AFK9+n3QLS2CuNkMdR42w5NDNPYsWng5M7O8IzmQxnxd25bctndt/F12cD0owNJ812KjO2oCc8uE0088dt3Kyb7xzGQxNytzvsDD9Nvc2wYm6paZANKUdQVcDisDDNPVkx1ypnLk+TYSIuDSxTDxnImBi5MTGDhy2b1mVkeU1g8da1J0+s34oi+WPN4srJLIYBZhE8cIhI/NmjFmsStuPH6bq44fJh0WMUkL445IzdnbuXr5lCzFzdq5vPyhZ323cdnJm2d3ZSvqJ0kwOoKtOplKvfix7caZDNNDNAPAIyAZojYyAhjj3EndneMX9rM6DO3lZVoa93RGEpwQT6e5zPDjyyD1KFueKaOMIJr5OXbEWkYeTu+3fNvDfdup0q0TlqWuKt6pjMXp+mdE48viqOcrXe5XIJhhuNUBgOMPOGrN6ouPKJ38HIt75zHSnAXMPXwNmlHNjKgAFWEzleSv2xcROGzz7wSbETcmLd2J2fdn2Xw9Meium9NzSWcVTaKzIDxvYmmmszDG/iQRlOZdoX2bfjs77Nvugzh5Oek9Pahu6ut6raG1lgyVgZor1o4Xq1Gc2kmj/qC4MJsUfPf+m0EbNx38ZL/4fUcAS6wCrIU9UMlVGtMb7lNXEsg0MpPt4kUbC7v+Kt/WXQLSmXyD5S9jwkuEQnMUc1iCOwQPuxWIYZBjlJ/rJ23L+7dSHp102w2niuliKzU/lCUJrIDLMcZGDyODRxyG4wAPdNmCNhFm2bbwZBLkREBERAREQEREBERAREQEREBERAREQEREBERARUXrvXuVw+vsLQsWW/2czVGYRhOGsIwXoAm5kNhomnf1hq+BG7f70/h4NtWXR/ykslYt6mmypkVFsVkc3p+GWCvX4wUbFiIKwSRAJWCPwByNz9apJ4+3cNN9Rte4rTtULuYsNUrSTjWCTszz8pyjllGNgrxme7hDI++23q/6Lp2NQUYirBNZrQyXOPmkc08cMtly4MwwRyExSlvIDbCzvuYt9ayN1G1vqEemmJzWSngt5LIZgDErmKxNiOOlJDfCuIVpKjwM5BCMjScOe07tvs+y/Hlb4/NSaq0U9a3WhazLWDCMUEbtj7wz49pbE49h2kieY6xML82ZoXZhbfZw1Pq/qBicRbxtLIWWr2cvM9fHxvDYk84maSCHhzhjIIn7lmFvXcfp+5n2lCxz5VEGZr3+mcdmWrfzsVyVnmduzTs5BruH7JGMUYduB5e3vxEfDfZlJ9Aa71hitdVdMaluU8pFlqktqA6sEUIVWGG3MDxEEEcjtypyxuEnLw4Ez777hp9F6MhJwikLmEXGMy7sm3bj4i79yTd2bgO277u3gzrE+putGqsOzZL/AGq0vnWinBrOEpRwOJRyFx415WqRyzRC+3rhJybwd+TboNvovjwt4bVWvaBnYLMEU4M/tYZoxkFn2+vYllLqZ1cz5aqy+HjzuP0lFjuyONiyVAJK+UcoxN5LV+aGRq0ZbsTE2zcJBZmchd3DXKLNPlG9R9UYUNFR46zUkv5WV4rwV4IDo5GdnxrBFDJYEzhrGdiQWMCEuMm+7eG3L1LrbXej8piLGoruPy+Hy9sKlmKrXCBsdLIQuQwG0ASkwAZEDm59wYDYmB3YkGqkWXusPWHJz6nsabxmXxelquMhGS9l8k1YzsWDjjkGtVjtM4Ezd6NtmZn/AKcpOWzCJfV0a6/WSxmp/luSpkrWlweZr+NeNq+Wrl3I4SjeP+mxnNGzcxER4zh6rOJbhpdRXI9QsRXzNbATWeGWuQ9+tU7Fh+5FtOXJphjeEfCtP4OTP6n4tvQeiLPVPOVKuoauRw1SvdlCavhZ6sfZ8xKTgxyStXKbi7bnt3ebj4sTO7Au3rXUduLqlpzGf7m9exh3mmJ8fSOy8ow5p94b0sJW4I94Q9QZWbZyb+4tws3U3WPTeNysOFt3wjyc8leEKoQ2ZyGW04NXCY4IiCAj7kbsxu3gYu+zPuutpTqBicpeyONo2e/cxMjw5CHs2I/N5Gllhce5LGISP3IZG9Ry+j+LLIXTbSuo7fUXOC9zGSXaVirYyk9mjXmGzSGzTJ4abSVCavP2WjHmIg+4b8m9qsrpBr+SvnepVi6Nd6mDlsTg1ahRrWCir2MkZDJYrwBLbkJomblMRvu7vvu7u4abRZU0Tlup2paQ6jxuQxOPqWJjejhpq0ZRy14ZyhPu2DrHKzO4G2/NnLi7tw3ZakotK0UbTOBTcA7xRCQxPLxbuPGJu5DHy32Z3d9tvF0Hu3XL1VqCrjKk167J2atdhKWRgkkcWIxAfUiFzL1iFvBn9qzvq/qrlMhmslRo5jHacpYySWuEt0YXkvWYZChNt54z2BpYz+jtxHi78nLZvfU6pXMvovPSWfNSyOMOGCSUYIJ69iOSeLtWHrTgULk/GVtuLi7xsTM2+w+hj4b3Va0vfGLTSJrEzExF/wAvMxjn6Zx6wuRs78TPrj+WhNNZytkakF2mfdrWQ7kMnA4+YO7tvwkFjHxZ/B2Z10d1mzOdSslQ01pSpjWgDKZyEIo5mr14oof6kUTPFXCNq8ZlLYiZvU4szG/H2L4+oWf1xp0sVFdylWzFdtgL2IKtbus7FE0tSRpa7C8PEnIZBFif1t3b1WSnw7r6toiLVr3TeKVtM5mKZzPFcemPTM+IcRtJmfMR5xE/Rp/dN1nrrD1Rv/Lz4DH5ClgoqsYHdyd0Y33kkhCcYIu8JB/hzReDMzu7l4swvv56UdVsjbg1Dj7lqrdu4qhZt0srTaN47UccZtzcBBoicZHhdnYW3Y3Ym3F3KCegbuNtGvxiYrbHOYracRPjHrHETM4nOHX+lvFO7/MNCbpusjVdba7n09/tAGQrNTpzFHJtXqNbs/1wjKSSPzXs9oCMQ2Fwd2E3fd9neZdQOpeaq47Suo4pe1j7bV2zNOOCGWMiPjIZRmcZTRsUYWWbY22cY/a7vvPq/DW509SKd9JmbWpxM8XrGe2ePM+npnjh2ts7ROMx6x+rQ+6bqlpta5LIa3ixGNs9vFY+mNnJsEMEgzkQNIw984yIWfzioLMBC/8Aiv8AV4V1keruYy1nIz081i9P1KZmFCpa82ebIcN+JEU8Zv6zCz7t6rObDsWzkotDoG61vWIjtreZnPEWnFYnETOZ88Z45mYcV2l7ftn92rmdN1ngOvkzaQ+V3iifK+ePiuGxeb+dNF5x5w4M/Jo/N9j4b/S9XfZ9129DYrX8dyhYyGQx9ilO/K/UOKJjrREPNhj7NeNyn29RnE3Fifx5s26j1Oia+hS1ta1ads2rEWmc2tXzjET7xzOInOHWdtasTNpiPTn1W7XzlOSxJTjsVjtwjylqhPGViIfVflJCxcwbYw8Xb+8fevv3WQtK4nUR66y0VW9WhyUe8l20cUbxzUe5QLsAL1iYT7J1h3YRfeMvW8d3sLVustRZnUFzA6cmgxsOMDlcvTRhIZm3FiAWkjkYR5yMLCws7vGb8mbZntbj4fnT1a1pq1mPl11LWnMRWJx549ZmIjGZn2hJfaYtiJjxmZ9l97puqL6XdQM3Hk8lpvPlFNkKdOW1WvQAIjMIRhJsYiAgW4SgQlwH6BsTb+2MeT5rHWWfmqySWI5MbSuO+SsyRVYZLISQA404xhrt4hux7iwv/WbcvBmUF+g7ilNS9rV7aRWe7PFotEzXHHOcY98/rjpO1tETOY4/+tOMi8CvKxFYREQEREBERAREQEREBERAREQEREBERAREQEREFL+Vp0muarxlKLGnXhyNG734pLByRA9eWI47EbSRgRATl2C9n/pbfWq96x+TJcyGH0xSxMlSG1h6RUb0kpyRR2I5+E08gvHGTm/nXnB8X2Z/OCWqkQUn5SXSG1nNMY/A4V6sPmFqkUfnckkUQ1adOxWEWKKIyc/6kfht9T+K+PyjulGazM+mclhJqMd/T07zDHdeRoZD5U5YzEgAuTDJUZnB2bdpPazts98IgoHqb0q1DnLmhshYlxj2sBbG3mXGSaOOQ3t46wbUAaB+bMNSRmY+H9vj4u662rOl2Rt9QMLqmM6jY7HY46k8ZyytbKQosqDPHE0TgQb3YvFzb2F4eDb3QiCNdUtMlmcLk8UEr1yv05qwzbOTRlILsLkLOzlHvsxM3tZ3ZZqyPQvWlvTEemTHSdWCoUTx2IBtPaukE/PlLYeDaB9nIiNgcjdmZ9mcnWukQczStE6tClWk4vJXp1oJHB3cXOGEIz4u7M7jyF9ndmVBdaumetMzLka22kspjrbytj5slTmhyOGikDgI1ZYgJxkBvW7jkbkTk/EWdgbSCIMU+UloifFVumWAjuF53BcsVI8hxcnisS2sXtPFGRbvHFLK3EXdvVjBvBT/ACXSHWWostij1ZdxL4jDWGshDixmGS/KBA7HLEcbCJSNGzETkzAJGwC3J3WjrdCCYgKaKKUon5RlJGBvGW7PyjcmdwfcRfdv8re5fSgzv1V6K5f/AGim1Np35FszXoAhyGMz1Z56pmABG1iEmEnEnGKHwbtuzgT8iY3FpNoHphemw2XoalHCjLlxlhcMFj4qY06phsELWBjArDhJtIPMXcS33M2duNxIgzJpPp31Mw9WHBY/KYL5KrTh5vkZoZTvQ1GlaQoWgOIgdtuTdt3LZi4tILbOMx1N0tylnX2D1QMlN6GOxj07Iucsdk5niyYOcMDRkHb5XYn2eTdmYvbs291Igp3px0yyOO1nqTUE51So5eGOOqEckhWRIHr796MomAW/pF9Ei+pcvpz0XtVsrrmbKvWlxuq5JwijrTSvYGtYlvPI03KIWil7VodnAi2dn8fDdXsiDL+lumXUjA1SwWFyeFfEjOZU79qKR79OCSTuSCMJQnGzuRG/F+425vsQ7ttpjHhKMMQzmEs4xg00scbxRySsLNJIETmTxAR7uwuRbM7Nu+26+hEGetU9IMvTzF7JYOPC3YMkZzT08xA0rQTyG8hnE7g+7PIUhbsQ/wCI7OxbM7d1+m2Wk0tkcZYfE/Kt8mLnTqhRrCAzxyxwynBE3ecBaRmPtt4ELOzuzmV0bJsta/W91eKd3bmk1mLY5nt/LmfX0++OVmd1ecfTH8M4dWNJY+hpXAVc5Zko3aBBVrX6MUlwYbBRnJJyBuBnW2hF9x4kxBHt7nq3KHJmsnhalfL3dTXGtxbyFTlqVqVVpIHMmil3Mz9UjkmfZuMYs+7rbs8ASC4mImL+0TFiF/8AVn8HXoo4ytBv2IYId/b2oo49/wDXgzbrR2PxJbbac91ZtfN5jmvbE2zn+ybR5zMRaIlJp7zsjxzz/Kl+q/SbITZr5fwrY2aeWIYrtHKwtLWmcIxhGUdwJuXbjibb1HbtM7F4uL9XQmhcvFQzQ5IMJHbyFaevTixtKOsFUJa5RvFJajjY5ISk7ZcXY3FxJ+RbsI27svOyy79X3GpoV0rYntxETjnticxGfb+cceEM7i81ivspDB9LcnBom1p4yqfKExzEBDNI9ZmO3HOPKV4mJvUF/wCz2/8Ayu9L04lsaNj09ZeHzuOgEQmBEcIXIH7kEgm4sTxtII7vsz7O/grR2TZNTrG6vabTPPzPm8R/f7/7OJ17zOfrn9VReTj00t4CvdlyRQyZC7LGxHFIczDVgjZoQeSQRdy5lK7+Hs4N9Shdno3nMVdvFhI8DfoXZHljjzFYZZqRE5Pxjd439UeWzPydnYW3Hdnd9I7JspY67u/n6mtbEzqY7omPw8eOPTHph2/qtTum3v5U7mekMuR0vHiL0lGPJhI1vzujTjq1nuCxgLyQwiDSbwF2iNhDfwJhHZhXzaKwuvxtY+PIXcWFCkQtYKMO/PfhEeHbk3jB+bj7DZ49n2J2Pbi917Jsoo6tr/Ktp2isxM2mM1ie2bee32/293Hz7YxOFD5rpxqStqy1ncNNj2gyDQx2POnPnDDxqjYBo+2TGT+aiQkz/wB2zs227+/WnTTO1M7NqDTFiqEt0ON6ld5NEZbCxELsLsQu8YHtuBCTFsTsbirx2TZSR1vdRaszFZxT5cxNYxakYxE++MRifMYc/wBTf6eMePRTHS/pdkoLuSzudsQWcxfryVowr7+b1ojAB+lxHcuMUQMzD6ogXibk7rr+TZoO7p7EzUr71ynkvSWWetIcsfbKvWiHcjjB+W8JeG3s28VaGyKHc9V3O5pal5jtt28RGIiKRMViPaIiZ4db697xMT64/gZERZyEREQEREBERAREQEREBFgD01dU/Y9P/C5H+RT01dU/Y9P/AAuR/kUG/wBFgD01dU/Y9P8AwuR/kU9NXVP2PT/wuR/kUG/0WAPTV1T9j0/8Lkf5FPTV1T9j0/8AC5H+RQb/AEWAPTV1T9j0/wDC5H+RT01dU/Y9P/C5H+RQb/RYA9NXVP2PT/wuR/kU9NXVP2PT/wALkf5FBv8ARYA9NXVP2PT/AMLkf5FPTV1T9j0/8Lkf5FBv9FgD01dU/Y9P/C5H+RT01dU/Y9P/AAuR/kUG/wBFgD01dU/Y9P8AwuR/kU9NXVP2PT/wuR/kUG/0WAPTV1T9j0/8Lkf5FPTV1T9j0/8AC5H+RQb/AEWAPTV1T9j0/wDC5H+RT01dU/Y9P/C5H+RQb/RYA9NXVP2PT/wuR/kU9NXVP2PT/wALkf5FBv8ARYA9NXVP2PT/AMLkf5FPTV1T9j0/8Lkf5FBv9FgD01dU/Y9P/C5H+RT01dU/Y9P/AAuR/kUG/wBFgD01dU/Y9P8AwuR/kU9NXVP2PT/wuR/kUG/0WAPTV1T9j0/8Lkf5FPTV1T9j0/8AC5H+RQb/AEWAPTV1T9j0/wDC5H+RT01dU/Y9P/C5H+RQb/RYA9NXVP2PT/wuR/kU9NXVP2PT/wALkf5FBv8ARYA9NXVP2PT/AMLkf5FPTV1T9j0/8Lkf5FBv9FgD01dU/Y9P/C5H+RT01dU/Y9P/AAuR/kUG/wBFgD01dU/Y9P8AwuR/kU9NXVP2PT/wuR/kUG/0WAPTV1T9j0/8Lkf5FPTV1T9j0/8AC5H+RQb/AEWAPTV1T9j0/wDC5H+RT01dU/Y9P/C5H+RQb/RYA9NXVP2PT/wuR/kU9NXVP2PT/wALkf5FBv8ARYA9NXVP2PT/AMLkf5FPTV1T9j0/8Lkf5FBv9FgD01dU/Y9P/C5H+RT01dU/Y9P/AAuR/kUG/wBFgD01dU/Y9P8AwuR/kU9NXVP2PT/wuR/kUG/0WAPTV1T9j0/8Lkf5FPTV1T9j0/8AC5H+RQb/AEWAPTV1T9j0/wDC5H+RT01dU/Y9P/C5H+RQb/RYA9NXVP2PT/wuR/kU9NXVX2PT/wALkf5FBv8ARYA9NXVX2PT/AMLkf5FPTV1V9j0/8Lkf5FBmZERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREBERAREQEREH//Z\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"640\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/TQvxWaQnrqI?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7fea02c4b040>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"TQvxWaQnrqI\",width=640,height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "03d3acf7",
+   "metadata": {
+    "scrolled": true
+   },
+   "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/PFDu9oVAE-g?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7fea02c40460>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"PFDu9oVAE-g\",width=640,height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by Edmond Anderson, 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": "2efe914d",
+   "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/PTest.ipynb b/PTest.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..cc6c5b797b51bb70fd201078150dcbcd4b7f0b44
--- /dev/null
+++ b/PTest.ipynb
@@ -0,0 +1,95 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "15c5a985",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('answercheck.py', <http.client.HTTPMessage at 0x22adaab7c40>)"
+      ]
+     },
+     "execution_count": 3,
+     "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": "031076bc",
+   "metadata": {},
+   "source": [
+    "# PTest \n",
+    "Understanding and computing using the Ptest "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "87deb2e1",
+   "metadata": {},
+   "source": [
+    "# Description \n",
+    "A p-test is a statistical method to test the validity of a commonly accepted claim about a population. That commonly accepted claim is called a null hypothesis. Based on the p-value, we reject or fail to reject a null hypothesis.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a182669f",
+   "metadata": {},
+   "source": [
+    "# Training Materials \n",
+    "https://www.youtube.com/watch?v=KS6KEWaoOOE\n",
+    "\n",
+    "https://www.youtube.com/watch?v=8Aw45HN5lnA"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c7fd81c",
+   "metadata": {},
+   "source": [
+    "# Self Assessment "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b14d8f0",
+   "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/RREF.ipynb b/RREF.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a7a96d3750b9199089f37611ebb7861c28a21b7b
--- /dev/null
+++ b/RREF.ipynb
@@ -0,0 +1,371 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf3966f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Sources\n",
+    "\n",
+    "https://textbooks.math.gatech.edu/ila/row-reduction.html"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "fc73d74c",
+   "metadata": {
+    "scrolled": true
+   },
+   "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": [
+    "# Reduced Row Echelon Form\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "We say a matrix is in reduced row echelon form if it is in row echelon form, each pivot is equal to 1, and each pivot is the only nonzero entry in its column."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9e7b32e4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import sympy as sym\n",
+    "sym.init_printing(use_unicode=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43219d26",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  Use an augmented matrix to solve the following system of equations:\n",
+    "\n",
+    "\n",
+    "$$x+5y+10z = 300$$ $$6x+2y+6z=3$$ $$x+z=6$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "64684dfd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Put your answer here\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "619a2259",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "x = -85/3\n",
+    "y = -3\n",
+    "z = 103/3\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "9cc2b34a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed variable is <class 'float'> and not a numpy.matrix.\n",
+      "    Trying to convert to a array matrix using ```A = np.matrix(A)```.\n",
+      "\n",
+      "Testing [[-28.33333]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(x,'412995a755fefadf29c7c0474a1f229d')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "e68fb05c",
+   "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 [[-3.]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(y,'cc2be23a521defd3ec6e6400899c16b2')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "c174a35a",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed variable is <class 'float'> and not a numpy.matrix.\n",
+      "    Trying to convert to a array matrix using ```A = np.matrix(A)```.\n",
+      "\n",
+      "Testing [[34.33333]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(z,'6c0c78b64a1a6ae19769d37986ae0148')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bfd97a19",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  Put the following system of equations in reduced row echelon form.\n",
+    "\n",
+    "\n",
+    "$$3x+.5y+3z = 5$$ $$5x+2y+2z=3$$ $$x+y+z=7$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "9855f5ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed variable is <class 'tuple'> and not a numpy.matrix.\n",
+      "    Trying to convert to a array matrix using ```A = np.matrix(A)```.\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/edmond/opt/anaconda3/lib/python3.9/site-packages/numpy/matrixlib/defmatrix.py:145: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
+      "  arr = N.array(data, dtype=dtype, copy=copy)\n"
+     ]
+    },
+    {
+     "ename": "ValueError",
+     "evalue": "could not broadcast input array from shape (3,4) into shape (3,)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [30]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01manswercheck\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m checkanswer\n\u001b[0;32m----> 2\u001b[0m \u001b[43mcheckanswer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvector\u001b[49m\u001b[43m(\u001b[49m\u001b[43mM\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m412995a755fefadf29c7c0474a1f229d\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/data_science_bridge_curriculum/answercheck.py:105\u001b[0m, in \u001b[0;36mcheckanswer.vector\u001b[0;34m(A, hashtag, decimal_accuracy)\u001b[0m\n\u001b[1;32m    104\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mvector\u001b[39m(A, hashtag\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, decimal_accuracy \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m):\n\u001b[0;32m--> 105\u001b[0m     A \u001b[38;5;241m=\u001b[39m \u001b[43mcheckanswer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmake_vector\u001b[49m\u001b[43m(\u001b[49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdecimal_accuracy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    106\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m checkanswer\u001b[38;5;241m.\u001b[39mbasic(A, hashtag)\n",
+      "File \u001b[0;32m~/data_science_bridge_curriculum/answercheck.py:82\u001b[0m, in \u001b[0;36mcheckanswer.make_vector\u001b[0;34m(A, decimal_accuracy)\u001b[0m\n\u001b[1;32m     78\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m(\u001b[38;5;28mtype\u001b[39m(A) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np\u001b[38;5;241m.\u001b[39mmatrix):\n\u001b[1;32m     79\u001b[0m     printwarning(textwrap\u001b[38;5;241m.\u001b[39mdedent(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\"\"\u001b[39m\n\u001b[1;32m     80\u001b[0m \u001b[38;5;124m    CheckWarning: passed variable is \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(A)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m and not a numpy.matrix.\u001b[39m\n\u001b[1;32m     81\u001b[0m \u001b[38;5;124m        Trying to convert to a array matrix using ```A = np.matrix(A)```.\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\"\"\u001b[39m))\n\u001b[0;32m---> 82\u001b[0m     A \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmatrix\u001b[49m\u001b[43m(\u001b[49m\u001b[43mA\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     83\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np\u001b[38;5;241m.\u001b[39missubdtype(A\u001b[38;5;241m.\u001b[39mdtype, np\u001b[38;5;241m.\u001b[39mdtype(\u001b[38;5;28mfloat\u001b[39m)\u001b[38;5;241m.\u001b[39mtype):\n\u001b[1;32m     84\u001b[0m     printwarning(textwrap\u001b[38;5;241m.\u001b[39mdedent(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\"\"\u001b[39m\n\u001b[1;32m     85\u001b[0m \u001b[38;5;124m    CheckWarning: passed matrix is \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mA\u001b[38;5;241m.\u001b[39mdtype\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m and not \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnp\u001b[38;5;241m.\u001b[39mdtype(\u001b[38;5;28mfloat\u001b[39m)\u001b[38;5;241m.\u001b[39mtype\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m...\u001b[39m\n\u001b[1;32m     86\u001b[0m \u001b[38;5;124m        Trying to convert to float using ```A = A.astype(float)```.\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\"\"\u001b[39m))\n",
+      "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/numpy/matrixlib/defmatrix.py:145\u001b[0m, in \u001b[0;36mmatrix.__new__\u001b[0;34m(subtype, data, dtype, copy)\u001b[0m\n\u001b[1;32m    142\u001b[0m     data \u001b[38;5;241m=\u001b[39m _convert_from_string(data)\n\u001b[1;32m    144\u001b[0m \u001b[38;5;66;03m# now convert data to an array\u001b[39;00m\n\u001b[0;32m--> 145\u001b[0m arr \u001b[38;5;241m=\u001b[39m \u001b[43mN\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    146\u001b[0m ndim \u001b[38;5;241m=\u001b[39m arr\u001b[38;5;241m.\u001b[39mndim\n\u001b[1;32m    147\u001b[0m shape \u001b[38;5;241m=\u001b[39m arr\u001b[38;5;241m.\u001b[39mshape\n",
+      "\u001b[0;31mValueError\u001b[0m: could not broadcast input array from shape (3,4) into shape (3,)"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(M,'412995a755fefadf29c7c0474a1f229d')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5704e5ea",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  Is the following matrix in reduced row echelon form? Why or why not?\n",
+    "\n",
+    "\n",
+    "$\\left[ \\begin{matrix} 1&0&0&0&5\\\\ 0&1&0&0&3\\\\0&0&0&1&2\\end{matrix} \\right]$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2515c443",
+   "metadata": {},
+   "source": [
+    "A - Yes, this matrix is in reduced row echelon form\n",
+    "B - No, this matrix is not in reduced row echelon form because there are non-zero entries in the last column\n",
+    "C - No, this matrix is not in reduced row echelon form because the third column has no leading coefficient"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "ce853368",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "##ANSWER##\n",
+    "A\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d237ca9",
+   "metadata": {},
+   "source": [
+    "## Training Materials\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "03d3acf7",
+   "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/eYSASx8_nyg?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7fb019c41bb0>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"eYSASx8_nyg\",width=640,height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by Edmond Anderson, 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": "2efe914d",
+   "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
+}