From 6a76e37b347013ed56b62d982a5f4dbf9558ed6d Mon Sep 17 00:00:00 2001 From: siddhapuraanil Date: Tue, 29 Aug 2023 09:04:40 +0530 Subject: [PATCH 1/8] Update chapter4_anil.ipynb --- topics/chapter4_anil.ipynb | 75 ++++++++++++++++++++++---------------- 1 file changed, 43 insertions(+), 32 deletions(-) diff --git a/topics/chapter4_anil.ipynb b/topics/chapter4_anil.ipynb index e45a567..c6c7dac 100644 --- a/topics/chapter4_anil.ipynb +++ b/topics/chapter4_anil.ipynb @@ -2,48 +2,59 @@ "cells": [ { "cell_type": "markdown", - "id": "f170f21f", + "id": "241a54f0", "metadata": {}, "source": [ - "### This is written by Anil" + "# Chapter 4: Read/ Write Data #\n", + "\n", + "## 1.\t Read data using different methods and sources ##\n", + "\n", + "- 1.1.\tRead data from csv\n", + "- 1.2.\tRead data from websites\n", + "- 1.3.\tRead data from database\n", + "- 1.4.\tRead data from github\n", + "\n", + "## 2.\tWrite data to different sources ##\n", + "- 2.1.\tWrite to csv\n", + "- 2.2.\tWrite to websites\n", + "- 2.3.\tWrite to database\n", + "- 2.4.\tWrite to github\n", + "\n", + "## 3.\tRead data from CSV ##\n", + "- 3.1.\tInput: folder path\n", + "\n", + "## 4.\tRead ##\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "### Data related roles ###\n", + "\n", + "- 1)\tData Engineer\n", + "- 2)\tData Analyst\n", + "- 3)\tData Scientist\n", + "- 4)\tData Researcher\n", + "- 5)\tData Expert\n", + "- 6)\tMachine learning Expert\n", + "- 7)\tDeep Learning Expert\n", + "\n", + "Link : https://www.careersinanalytics.com/article/different-roles-in-machine-learning/\n", + "\n" ] }, { "cell_type": "markdown", - "id": "c14e69b4", + "id": "e19ccdd8", "metadata": {}, - "source": [ - "- type1\n", - "-type2" - ] + "source": [] }, { "cell_type": "markdown", - "id": "86cbb372", - "metadata": {}, - "source": [ - "### Chapter 4: Read/ Write Data\n", - "-\t Read data using different methods and sources\n", - "-\tRead data from csv\n", - "1.2.\tRead data from websites\n", - "1.3.\tRead data from database\n", - "1.4.\tRead data from github\n", - "2.\tWrite data to different sources\n", - "2.1.\tWrite to csv\n", - "2.2.\tWrite to websites\n", - "2.3.\tWrite to database\n", - "2.4.\tWrite to github\n", - "3.\tRead data from CSV\n", - "3.1.\tInput: folder path\n", - "4.\tRead \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b4205ceb", + "id": "30cad6a0", "metadata": {}, - "outputs": [], "source": [] } ], @@ -63,7 +74,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.9.13" } }, "nbformat": 4, From f53d2224a01e39f0f01758b256b6cb7c2b464136 Mon Sep 17 00:00:00 2001 From: siddhapuraanil Date: Tue, 29 Aug 2023 14:23:52 +0530 Subject: [PATCH 2/8] Create chapter3_anil.ipynb --- topics/chapter3_anil.ipynb | 140 +++++++++++++++++++++++++++++++++++++ 1 file changed, 140 insertions(+) create mode 100644 topics/chapter3_anil.ipynb diff --git a/topics/chapter3_anil.ipynb b/topics/chapter3_anil.ipynb new file mode 100644 index 0000000..1e11ea8 --- /dev/null +++ b/topics/chapter3_anil.ipynb @@ -0,0 +1,140 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ba83f531", + "metadata": {}, + "source": [ + "# Chapter 3: Git: Version Control System #\n", + "\n", + "## 1.\tCreate Github project ##\n", + " 1.1.\tInstall git\n", + " 1.2.\tInstall github\n", + " 1.3.\tCreate any git project by git init command\n", + " 1.4.\tFrom main branch create another branch, say testing\n", + " 1.5.\tTesting branch make some changes\n", + " 1.6.\tCommit the changes\n", + " 1.7.\tCreate github account, remote\n", + " 1.8.\tPublish this git project to your github account\n", + " \n", + "## 2.\tHomework: ##\n", + " 2.1.\tCheck quick 5 minute video on git desktop from youtube\n", + " 2.2.\tQuick 5 minute video on github\n", + " 2.3.\tExplore https://github.com/secmlops/ML2022\n", + "\n", + "### Book:\n", + "\n", + "https://git-scm.com/book/en/v2\n", + "\n", + "\n", + "## Start with Github ##\n", + " 1)\tCreate Github account\n", + " 2)\tCreate a repository\n", + " 3)\tInstall github desktop\n", + " 4)\tConnect your github desktop to your github account\n", + " 5)\tClone git repository to your local system using github desktop\n", + "\n", + "## Start working with Repository ##\n", + " 1)\tClone few repo to your local\n", + " 2)\tMake some changes in local\n", + " 3)\tPublish change in this local repo to your github account\n", + " 4)\tCommit\n", + " 5)\tPush the change\n", + " 6)\tFrom github desktop, check action on repository\n", + " 7)\tFrom github desktop, check action on branch\n", + "\n", + "\n", + "\n", + "## Using git bash ##\n", + " 1)\tCreate a folder, say testing\n", + " 2)\tOpen git bash\n", + " 3)\tCd to testing from git bash to reach the location of folder\n", + " 4)\tGit init to make this folder as git folder\n", + " 5)\tFrom Github desktop open existing folder\n", + " 6)\tskipping above steps, create new repository from github desktop\n", + "\n", + "\n", + "## Work with github ##\n", + " 1)\tCreate a new repo\n", + " 2)\tLook into code and open with github desktop\n", + " 3)\tClone in a folder\n", + " 4)\tMake some changes in the folder, file, code\n", + " 5)\tCheck from github desktop\n", + " 6)\tCommit\n", + " 7)\tPush to remote, origin and take the change to github \n", + "\n", + "## Fork##\n", + " 1)\tFork a repo to your account\n", + " 2)\tClone the forked repo to you local\n", + " 3)\tMake some change\n", + " 4)\tCommit\n", + " 5)\tpush\n", + "\n", + "## Pull Request ##\n", + " 1)\tMake change in your local\n", + " 2)\tCommit \n", + " 3)\tPush to your github\n", + " 4)\tIf From forked repo create pull request\n", + " 5)\tMake a local branch of main repo, make some change in local and create pull request from local to remote branch, check both the branch and repo before creating pull request\n", + "\n", + "\n", + "### Learning ###\n", + "\n", + "- What is repository?\n", + "- What is fork?\n", + "- What is clone?\n", + "- What is the difference between fork and clone?\n", + "- What is origin?\n", + "- What is hidden file and directory?\n", + "- How to push the code to remote?\n", + "\n", + "## Github ##\n", + "https://www.youtube.com/watch?v=RPagOAUx2SQ\n", + "\n", + "\n", + "### homework: ###\n", + "- What is gitignore, how to create it, explore 5-10 minute video \n", + "- What is wiki in git, what is the use of this, 5-10 minute video\n", + "\n", + "### Wiki ###\n", + "\n", + "- About developer of code\n", + "\n", + "- Homepage with one picture\n", + "\n", + "- What this wiki have\n", + "\n", + "- More picture\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9da1296a", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From da48626638e8f2a9a9c0a7243100ca57e98f4af6 Mon Sep 17 00:00:00 2001 From: siddhapuraanil Date: Tue, 29 Aug 2023 14:31:43 +0530 Subject: [PATCH 3/8] Update chapter3_anil.ipynb --- topics/chapter3_anil.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/topics/chapter3_anil.ipynb b/topics/chapter3_anil.ipynb index 1e11ea8..cfc2a32 100644 --- a/topics/chapter3_anil.ipynb +++ b/topics/chapter3_anil.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "ba83f531", + "id": "d7b21ddd", "metadata": {}, "source": [ "# Chapter 3: Git: Version Control System #\n", @@ -110,7 +110,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9da1296a", + "id": "3ad34d27", "metadata": {}, "outputs": [], "source": [] From 701bbdfa78481b19def0537005002dac631f87c7 Mon Sep 17 00:00:00 2001 From: siddhapuraanil Date: Tue, 29 Aug 2023 14:39:05 +0530 Subject: [PATCH 4/8] Update pandas_readcsv.ipynb --- pandas_readcsv.ipynb | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/pandas_readcsv.ipynb b/pandas_readcsv.ipynb index cdcacec..3f1971e 100644 --- a/pandas_readcsv.ipynb +++ b/pandas_readcsv.ipynb @@ -3,7 +3,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "9f6f0f31", + "id": "2e161235", "metadata": {}, "outputs": [], "source": [ @@ -13,7 +13,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "83a69dc1", + "id": "7c99d18d", "metadata": {}, "outputs": [], "source": [ @@ -23,7 +23,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "34c16513", + "id": "828f7485", "metadata": {}, "outputs": [ { @@ -286,7 +286,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "8a5b8d83", + "id": "0c187775", "metadata": {}, "outputs": [ { @@ -438,7 +438,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "93bdb218", + "id": "e70d89ec", "metadata": {}, "outputs": [ { @@ -680,7 +680,7 @@ { "cell_type": "code", "execution_count": 10, - "id": "9b4cff27", + "id": "a26d79b9", "metadata": {}, "outputs": [ { @@ -832,7 +832,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "47a5d9c8", + "id": "6846fb4f", "metadata": {}, "outputs": [ { @@ -1074,7 +1074,7 @@ { "cell_type": "code", "execution_count": 13, - "id": "3a0e66fd", + "id": "223148b0", "metadata": {}, "outputs": [ { @@ -1095,7 +1095,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "7ba82717", + "id": "4f63e550", "metadata": {}, "outputs": [ { @@ -1302,7 +1302,7 @@ { "cell_type": "code", "execution_count": 15, - "id": "2cea18b2", + "id": "7b14fe77", "metadata": {}, "outputs": [ { @@ -1339,7 +1339,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "93d400d9", + "id": "b57031ef", "metadata": {}, "outputs": [ { @@ -1363,7 +1363,7 @@ { "cell_type": "code", "execution_count": 19, - "id": "d1c35b2b", + "id": "f84a3d6f", "metadata": {}, "outputs": [ { @@ -1481,7 +1481,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "499053a1", + "id": "7536e36a", "metadata": {}, "outputs": [ { @@ -1515,7 +1515,7 @@ { "cell_type": "code", "execution_count": 21, - "id": "2f3cc438", + "id": "305d2349", "metadata": {}, "outputs": [ { @@ -1536,7 +1536,7 @@ { "cell_type": "code", "execution_count": 22, - "id": "dbfc6ca2", + "id": "2ce9ecc2", "metadata": {}, "outputs": [ { @@ -1799,7 +1799,7 @@ { "cell_type": "code", "execution_count": 23, - "id": "d8f76c7c", + "id": "3adea8d9", "metadata": {}, "outputs": [ { @@ -1833,7 +1833,7 @@ { "cell_type": "code", "execution_count": null, - "id": "480070fa", + "id": "ac809bba", "metadata": {}, "outputs": [], "source": [] From 26935371126ea8176c8cb938bb5a3014e90d408a Mon Sep 17 00:00:00 2001 From: siddhapuraanil Date: Tue, 29 Aug 2023 20:23:58 +0530 Subject: [PATCH 5/8] Update 104_pandas_read_csv_data.ipynb --- 104_pandas_read_csv_data.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/104_pandas_read_csv_data.ipynb b/104_pandas_read_csv_data.ipynb index d8b495b..0317964 100644 --- a/104_pandas_read_csv_data.ipynb +++ b/104_pandas_read_csv_data.ipynb @@ -999,7 +999,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.9.13" } }, "nbformat": 4, From 65ca09e67dda92b71f35c597b4b7f616511dd0c0 Mon Sep 17 00:00:00 2001 From: siddhapuraanil Date: Tue, 5 Sep 2023 20:13:49 +0530 Subject: [PATCH 6/8] date as index --- DATE_AS_INDEX.ipynb | 340 ++++++++++++++++++++++++ topics/~$apter1_basic_installation.docx | Bin 0 -> 162 bytes 2 files changed, 340 insertions(+) create mode 100644 DATE_AS_INDEX.ipynb create mode 100644 topics/~$apter1_basic_installation.docx diff --git a/DATE_AS_INDEX.ipynb b/DATE_AS_INDEX.ipynb new file mode 100644 index 0000000..9a353fc --- /dev/null +++ b/DATE_AS_INDEX.ipynb @@ -0,0 +1,340 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "26384b07", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import os\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ab169d43", + "metadata": {}, + "outputs": [], + "source": [ + "data = pd.read_csv(\"data/AAPL.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "bc59ca2e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Date', 'Open', 'High', 'Low', 'Close', 'Volume', 'Ex-Dividend',\n", + " 'Split Ratio', 'Adj. Open', 'Adj. High', 'Adj. Low', 'Adj. Close',\n", + " 'Adj. Volume'],\n", + " dtype='object')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "c2f12969", + "metadata": {}, + "outputs": [], + "source": [ + "data['Date'] = pd.to_datetime(data['Date'])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "a45352ed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 2517 entries, 0 to 2516\n", + "Data columns (total 13 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Date 2517 non-null datetime64[ns]\n", + " 1 Open 2517 non-null float64 \n", + " 2 High 2517 non-null float64 \n", + " 3 Low 2517 non-null float64 \n", + " 4 Close 2517 non-null float64 \n", + " 5 Volume 2517 non-null float64 \n", + " 6 Ex-Dividend 2517 non-null float64 \n", + " 7 Split Ratio 2517 non-null float64 \n", + " 8 Adj. Open 2517 non-null float64 \n", + " 9 Adj. High 2517 non-null float64 \n", + " 10 Adj. Low 2517 non-null float64 \n", + " 11 Adj. Close 2517 non-null float64 \n", + " 12 Adj. Volume 2517 non-null float64 \n", + "dtypes: datetime64[ns](1), float64(12)\n", + "memory usage: 255.8 KB\n" + ] + } + ], + "source": [ + "data.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4796eb15", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAHACAYAAAB9DBhHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACxU0lEQVR4nOydd3wT9f/HX0m66YICXexZyp5aUYaCoOAXlC0IhYKKgiiiCLKHCIryEwQcZcpGQUGUUWjZq1AEWloohQJtKaN0ryT3+yNtepdckrvstO/n45FHk7vPfT7vXC/3ed97fSQMwzAgCIIgCIKwMVJbC0AQBEEQBAGQUkIQBEEQhJ1ASglBEARBEHYBKSUEQRAEQdgFpJQQBEEQBGEXkFJCEARBEIRdQEoJQRAEQRB2ASklBEEQBEHYBaSUEARBEARhF5BSQhAEQRCEXWAzpeT48eN44403EBQUBIlEgr1794ru4+DBg3j++efh5eWFWrVqYdCgQUhJSTG/sARBEARBWBybKSX5+flo27YtVq1aZdTxt2/fxoABA/Dyyy8jLi4OBw8exOPHj/HWW2+ZWVKCIAiCIKyBxB4W5JNIJNizZw8GDhyo3lZSUoJZs2Zhy5YtePbsGVq1aoWlS5eiR48eAIDdu3djxIgRKC4uhlSq0q327duHAQMGoLi4GM7Ozjb4JgRBEARBGIvdxpSMHTsWp06dwvbt2/Hff/9hyJAh6Nu3L27evAkA6NSpE2QyGdavXw+FQoHs7Gxs3rwZr776KikkBEEQBOGA2KWlJDk5GU2bNsX9+/cRFBSkbterVy906dIFX331FQBVXMqQIUPw5MkTKBQKhIWF4cCBA/D19bXBtyAIgiAIwhTs0lJy6dIlMAyDZs2awdPTU/2KiYlBcnIyACAjIwPjx4/HmDFjcOHCBcTExMDFxQWDBw+GHehZBEEQBEGIxMnWAvChVCohk8kQGxsLmUzG2efp6QkA+PHHH+Ht7Y1ly5ap9/3222+oW7cuzp07h+eff96qMhMEQRAEYRp2qZS0b98eCoUCmZmZeOmll3jbFBQUaCks5Z+VSqXFZSQIgiAIwrzYzH2Tl5eHuLg4xMXFAQBSUlIQFxeH1NRUNGvWDCNHjsTo0aPxxx9/ICUlBRcuXMDSpUtx4MABAEC/fv1w4cIFLFiwADdv3sSlS5cwduxY1K9fH+3bt7fV1yIIgiAIwkhsFugaHR2Nnj17am0fM2YMNmzYgNLSUixatAibNm3CgwcP4Ofnh7CwMMyfPx+tW7cGAGzfvh3Lli1DUlISPDw8EBYWhqVLlyIkJMTaX4cgCIIgCBOxi+wbgiAIgiAIu8y+IQiCIAii6kFKCUEQBEEQdoHVs2+USiXS0tLg5eUFiURi7eEJgiAIgjAChmGQm5uLoKAg9fIu5sbqSklaWhrq1q1r7WEJgiAIgjAD9+7dQ506dSzSt9WVEi8vLwCqL+Xt7W3t4QmCIAiCMIKcnBzUrVtXPY9bAqsrJeUuG29vb1JKCIIgCMLBsGToBQW6EgRBEARhF5BSQhAEQRCEXUBKCUEQBEEQdoFdLshHEARBWA+FQoHS0lJbi0HYGGdnZ62Fbq0NKSUEQRBVFIZhkJGRgWfPntlaFMJO8PX1RUBAgM3qiJFSQhAEUUUpV0hq164NDw8PKmhZhWEYBgUFBcjMzAQABAYG2kQOUkoIgiCqIAqFQq2Q+Pn52Vocwg5wd3cHAGRmZqJ27do2ceVQoCtBEEQVpDyGxMPDw8aSEPZE+fVgqxgjUkoIgiCqMOSyIdjY+nogpYQgCIIgCLuAlBKCIAiCIOwCUkoIgiAIh+PevXuIiIhAUFAQXFxcUL9+fUyZMgVPnjyxtWiECVR+pYRhgJICW0tBEARBmInbt2+jU6dOSEpKwrZt23Dr1i2sXbsWUVFRCAsLw9OnT20tImEklV8p2T0W+CoQeHrb1pIQBEEQZuDDDz+Ei4sLDh06hO7du6NevXp47bXXcOTIETx48ABffvklAKBBgwZYuHAh3n77bXh6eiIoKAgrV67k9JWdnY13330XtWvXhre3N15++WVcuXJFvX/evHlo164dNm/ejAYNGsDHxwfDhw9Hbm6uVb9zVaHyKyXX96j+Xoi0rRwEQRB2DsMwKCiRW/3FMIxgGZ8+fYqDBw/igw8+UNfVKCcgIAAjR47Ejh071H1+8803aNOmDS5duoQZM2bgk08+weHDh9Xft1+/fsjIyMCBAwcQGxuLDh064JVXXuFYW5KTk7F3717s378f+/fvR0xMDL7++msznHFCEyqeRhAEQQAACksVCJ1z0Orjxi/oAw8XYdPRzZs3wTAMWrRowbu/RYsWyMrKwqNHjwAAXbt2xRdffAEAaNasGU6dOoXvv/8evXv3xrFjx3D16lVkZmbC1dUVAPDtt99i79692L17N959910AgFKpxIYNG+Dl5QUAeOeddxAVFYXFixeb9L0JbSq/pYQgCIKoMpRbSMrrbYSFhXH2h4WFISEhAQAQGxuLvLw8+Pn5wdPTU/1KSUlBcnKy+pgGDRqoFRJAVYK9vBw7YV7IUkIQBEEAANydZYhf0Mcm4wqlSZMmkEgkiI+Px8CBA7X237hxA9WrV0fNmjV19lGusCiVSgQGBiI6Olqrja+vr/q9s7Oz1vFKpVKwzIRwSCkhCIIgAKgmW6FuFFvh5+eH3r17Y/Xq1fjkk084cSUZGRnYsmULRo8erVY8zp49yzn+7NmzCAkJAQB06NABGRkZcHJyQoMGDaz2HQjdkPuGIAiCcChWrVqF4uJi9OnTB8ePH8e9e/fw77//onfv3ggODubEepw6dQrLli1DUlISfvzxR+zatQtTpkwBAPTq1QthYWEYOHAgDh48iDt37uD06dOYNWsWLl68aKuvV6UhpYQgCIJwKJo2bYqLFy+icePGGDZsGBo3box3330XPXv2xJkzZ1CjRg11208//RSxsbFo3749Fi5ciOXLl6NPH5WLSiKR4MCBA+jWrRvGjRuHZs2aYfjw4bhz5w78/f1t9fWqNBJGTC6WGcjJyYGPjw+ys7Ph7e1t+QHn+aj+hk0C+lCkNEEQBAAUFRUhJSUFDRs2hJubm63FsQgNGjTAxx9/jI8//tjWojgM+q4La8zfVcdSQithEgRBEIRdU3WUEoIgCIIg7Br7DrMmCIIgCCO5c+eOrUUgREKWEoIgCIIg7AJSSgiCIAiCsAtEKSVyuRyzZs1Cw4YN4e7ujkaNGmHBggUOUtmOAl0JgiAIwp4RFVOydOlSrF27Fhs3bkTLli1x8eJFjB07Fj4+PupiNARBEARBEMYgSik5c+YMBgwYgH79+gFQ5YBv27aNKt8RBEEQBGEyotw3L774IqKiopCUlAQAuHLlCk6ePInXX39d5zHFxcXIycnhvGwC1SkhCIIgCLtGlFIyffp0jBgxAiEhIXB2dkb79u3x8ccfY8SIETqPWbJkCXx8fNSvunXrmiw0QRAEQehjw4YNnJV+hRAeHs678jBhPUQpJTt27MBvv/2GrVu34tKlS9i4cSO+/fZbbNy4UecxM2bMQHZ2tvp17949k4UmCIIgqi66lIfo6GhIJBI8e/YMw4YNU1v1CcdBVEzJZ599hi+++ALDhw8HALRu3Rp3797FkiVLMGbMGN5jXF1d4erqarqkBEEQBCEQd3d3uLu721oMQiSiLCUFBQWQSrmHyGQyB0kJJgiCIKoKfO6bRYsWoXbt2vDy8sL48ePxxRdfoF27dlrHfvvttwgMDISfnx8+/PBDlJaWWkdoQpyl5I033sDixYtRr149tGzZEpcvX8Z3332HcePGWUo+giAIwlowDFBaYP1xnT0snoywZcsWLF68GKtXr0bXrl2xfft2LF++HA0bNuS0O3bsGAIDA3Hs2DHcunULw4YNQ7t27TBhwgSLykeoEKWUrFy5ErNnz8YHH3yAzMxMBAUF4b333sOcOXMsJZ8ZoewbgiAIvZQWAF8FWX/cmWmASzVRh+zfvx+enp6cbQqFQmf7lStXIiIiAmPHjgUAzJkzB4cOHUJeXh6nXfXq1bFq1SrIZDKEhISgX79+iIqKIqXESohy33h5eWHFihW4e/cuCgsLkZycjEWLFsHFxcVS8hEEQRCEFj179kRcXBzn9euvv+psn5iYiC5dunC2aX4GgJYtW0Imk6k/BwYGIjMz03yCE3qhVYIJgiAIFc4eKquFLcYVSbVq1dCkSRPOtvv37+s9RqLhImIYRlsUZ2etYyhu0npUHaWEiqcRBEHoRyIR7UZxFJo3b47z58/jnXfeUW+jauT2R9VRSgiCIIgqy+TJkzFhwgR06tQJL7zwAnbs2IH//vsPjRo1srVoBAtSSgiCIIhKz8iRI3H79m1MmzYNRUVFGDp0KMLDw3H+/Hlbi0awkDB8TjULkpOTAx8fH2RnZ8Pb29vyA87zUf198ROg1zzLj0cQBOEAFBUVISUlBQ0bNoSbm5utxbEJvXv3RkBAADZv3mxrUewGfdeFNeZvspQQBEEQlZ6CggKsXbsWffr0gUwmw7Zt23DkyBEcPnzY1qIRLEgpIQiCICo9EokEBw4cwKJFi1BcXIzmzZvj999/R69evWwtGsGiCikllH1DEARRVXF3d8eRI0dsLQZhAFHF0wiCIAiCICwFKSUEQRAEQdgFVUcpoeJpBEEQBGHXVB2lhCAIgiAIu4aUEoIgCIIg7AJSSgiCIAiCsAtIKSEIgiAIwi4gpYQgCIJwKMLDwzFw4EBbi0FYgCqklFD2DUEQBEHYM1VIKSEIgiAqOzExMejSpQtcXV0RGBiIL774AnK5HACwb98++Pr6QqlUAgDi4uIgkUjw2WefqY9/7733MGLECJvITlSpMvMEQRCEPhiGQaG80Orjuju5Q2KGWlIPHjzA66+/jvDwcGzatAk3btzAhAkT4Obmhnnz5qFbt27Izc3F5cuX0bFjR8TExKBmzZqIiYlR9xEdHY1PPvnEZFkI46g6SgkVTyMIgtBLobwQz219zurjnnv7HDycPUzuZ/Xq1ahbty5WrVoFiUSCkJAQpKWlYfr06ZgzZw58fHzQrl07REdHo2PHjmoFZP78+cjNzUV+fj6SkpLQo0cP078UYRTkviEIgiAqBQkJCQgLC+NYXbp27Yq8vDzcv38fANCjRw9ER0eDYRicOHECAwYMQKtWrXDy5EkcO3YM/v7+CAkJsdVXqPJUHUsJQRAEoRd3J3ece/ucTcY1BwzDaLmBGIYBAPX2Hj16IDIyEleuXIFUKkVoaCi6d++OmJgYZGVloXv37maRhTAOUkoIgiAIAKqJ2xxuFFsRGhqK33//naOcnD59Gl5eXggODgYAdVzJihUr0L17d0gkEnTv3h1LlixBVlYWpkyZYsuvUOUh9w1BEAThcGRnZyMuLo7zevfdd3Hv3j1MnjwZN27cwJ9//om5c+di6tSpkEpV0115XMlvv/2mjh3p1q0bLl26RPEkdgBZSgiCIAiHIzo6Gu3bt+dsGzNmDA4cOIDPPvsMbdu2RY0aNRAREYFZs2Zx2vXs2ROXLl1SKyDVq1dHaGgo0tLS0KJFC2t9BYIHCVPucLMSOTk58PHxQXZ2Nry9vS0/4Dwf1d9unwMvf2n58QiCIByAoqIipKSkoGHDhnBzc7O1OISdoO+6sMb8Te4bgiAIgiDsAlJKCIIgCIKwC6qOUkLF0wiCIAjCrqk6SglBEARBEHYNKSUEQRAEQdgFpJQQBEEQBGEXkFJCEARBEIRdQEoJQRAEQRB2QRVSSij7hiAIgiDsmSqklBAEQRBVBYlEgr1799paDEIkpJQQBEEQDkdGRgYmT56MRo0awdXVFXXr1sUbb7yBqKgoW4tGmEDVWZCPiqcRBEFUCu7cuYOuXbvC19cXy5YtQ5s2bVBaWoqDBw/iww8/xI0bN2wtImEkZCkhCIIgHIoPPvgAEokE58+fx+DBg9GsWTO0bNkSU6dOxdmzZ3mPuXr1Kl5++WW4u7vDz88P7777LvLy8tT7o6Oj0aVLF1SrVg2+vr7o2rUr7t69q96/b98+dOzYEW5ubmjUqBHmz58PuVxu8e9a1ag6lhKCIAhCLwzDgCkstPq4End3SARas58+fYp///0XixcvRrVq1bT2+/r6am0rKChA37598fzzz+PChQvIzMzE+PHjMWnSJGzYsAFyuRwDBw7EhAkTsG3bNpSUlOD8+fNqmQ4ePIhRo0bhhx9+wEsvvYTk5GS8++67AIC5c+ca/8UJLUgpIQiCIAAATGEhEjt0tPq4zS/FQuLhIajtrVu3wDAMQkJCBPe/ZcsWFBYWYtOmTWpFZtWqVXjjjTewdOlSODs7Izs7G/3790fjxo0BAC1atFAfv3jxYnzxxRcYM2YMAKBRo0ZYuHAhPv/8c1JKzEwVUkoopoQgCMLRYRgGAARbVgAgISEBbdu25VhWunbtCqVSicTERHTr1g3h4eHo06cPevfujV69emHo0KEIDAwEAMTGxuLChQtYvHix+niFQoGioiIUFBTAQ6BCRRimCiklBEEQhD4k7u5ofinWJuMKpWnTppBIJEhISMDAgQMFHcMwjE4lpnz7+vXr8dFHH+Hff//Fjh07MGvWLBw+fBjPP/88lEol5s+fj7feekvreDc3N8GyE4YhpYQgCIIAoJqghbpRbEWNGjXQp08f/Pjjj/joo4+04kqePXumFVcSGhqKjRs3Ij8/X93+1KlTkEqlaNasmbpd+/bt0b59e8yYMQNhYWHYunUrnn/+eXTo0AGJiYlo0qSJxb9fVYeybwiCIAiHYvXq1VAoFOjSpQt+//133Lx5EwkJCfjhhx8QFham1X7kyJFwc3PDmDFjcO3aNRw7dgyTJ0/GO++8A39/f6SkpGDGjBk4c+YM7t69i0OHDiEpKUkdVzJnzhxs2rQJ8+bNw/Xr15GQkKC2phDmhSwlBEEQhEPRsGFDXLp0CYsXL8ann36K9PR01KpVCx07dsSaNWu02nt4eODgwYOYMmUKOnfuDA8PDwwaNAjfffedev+NGzewceNGPHnyBIGBgZg0aRLee+89AECfPn2wf/9+LFiwAMuWLYOzszNCQkIwfvx4q37vqoCEKY8ashI5OTnw8fFBdnY2vL29LT/gPB/V3x4zgR7TLT8eQRCEA1BUVISUlBQ0bNiQ4iIINfquC2vM3+S+IQiCIAjCLqg6SgmVmScIgiAIu6bqKCW2oCgbSP/P1lIQBEEQhENASokl+aED8NNLQMoJW0tCEARBEHZPFVJKbOC+KXis+pt4wPpjEwRBEISDUYWUEhti3QQngiAIgnBISCkhCIIgCMIuIKXEGlDmD0EQBEEYhJQSa0DuG4IgCLuhQYMGWLFiha3FIHggpYQgCIJwGN544w306tWLd9+ZM2cgkUhw6dIlK0tFmIuqo5SQB4UgCMLhiYiIwNGjR3H37l2tfevWrUO7du3QoUMHG0hGmIOqo5QQBEEQDk///v1Ru3ZtbNiwgbO9oKAAO3bsQEREBH7//Xe0bNkSrq6uaNCgAZYvX66zvzt37kAikSAuLk697dmzZ5BIJIiOjgYAREdHQyKR4ODBg2jfvj3c3d3x8ssvIzMzE//88w9atGgBb29vjBgxAgUFBep+GIbBsmXL0KhRI7i7u6Nt27bYvXu3OU9HpYOUEqtAMSUEQRDmwMnJCaNHj8aGDRvAXk92165dKCkpQVhYGIYOHYrhw4fj6tWrmDdvHmbPnq2lxBjDvHnzsGrVKpw+fRr37t3D0KFDsWLFCmzduhV///03Dh8+jJUrV6rbz5o1C+vXr8eaNWtw/fp1fPLJJxg1ahRiYmJMlqWy4mRrAawH+W8IgiD0wTAM5CVKq4/r5CKFRESW4rhx4/DNN98gOjoaPXv2BKBy3bz11lv47rvv8Morr2D27NkAgGbNmiE+Ph7ffPMNwsPDTZJz0aJF6Nq1KwCVG2nGjBlITk5Go0aNAACDBw/GsWPHMH36dOTn5+O7777D0aNHERYWBgBo1KgRTp48iZ9++gndu3c3SZbKShVSSgiCIAh9yEuU+HmK9Z/i3/2/7nB2lQluHxISghdeeAHr1q1Dz549kZycjBMnTuDQoUP4/PPPMWDAAE77rl27YsWKFVAoFJDJhI+jSZs2bdTv/f394eHhoVZIyredP38eABAfH4+ioiL07t2b00dJSQnat29vtAyVHVJKCIIgCIcjIiICkyZNwo8//oj169ejfv36eOWVV8AwjJbVhdFTlkEqlWq1KS0t5W3r7Oysfi+RSDify7cplSpLU/nfv//+G8HBwZx2rq6uhr5elYWUEoIgCAKAyo3y7v9Z363g5CI+vHHo0KGYMmUKtm7dio0bN2LChAmQSCQIDQ3FyZMnOW1Pnz6NZs2a8VpJatWqBQBIT09XWzDYQa/GEhoaCldXV6SmppKrRgSklBAEQRAAyp7+RbhRbImnpyeGDRuGmTNnIjs7Wx0v8umnn6Jz585YuHAhhg0bhjNnzmDVqlVYvXo1bz/u7u54/vnn8fXXX6NBgwZ4/PgxZs2aZbJ8Xl5emDZtGj755BMolUq8+OKLyMnJwenTp+Hp6YkxY8aYPEZlpHJn39hLJVV7kYMgCKISERERgaysLPTq1Qv16tUDAHTo0AE7d+7E9u3b0apVK8yZMwcLFizQG+S6bt06lJaWolOnTpgyZQoWLVpkFvkWLlyIOXPmYMmSJWjRogX69OmDffv2oWHDhmbpvzIiYfQ52yxATk4OfHx8kJ2dDW9vb8sOplQCC6qr3r8yB3jpU8uOp8k8H9XfLu8Bry+z7tgEQRB6KCoqQkpKCho2bAg3Nzdbi0PYCfquC2vM35XbUkIQBEEQhMMgWil58OABRo0aBT8/P3h4eKBdu3aIjY21hGxmgNwmBEEQBOEoiAp0zcrKQteuXdGzZ0/8888/qF27NpKTk+Hr62sh8cwJFU8jCIIgCHtGlFKydOlS1K1bF+vXr1dva9CggbllMh8UYEoQBEEQDoMo981ff/2FTp06YciQIahduzbat2+PX375xVKyEQRBEARRhRCllNy+fRtr1qxB06ZNcfDgQbz//vv46KOPsGnTJp3HFBcXIycnh/OyHvZiKbEXOQiCIAjCfhHlvlEqlejUqRO++uorAED79u1x/fp1rFmzBqNHj+Y9ZsmSJZg/f77pkhIEQRAEUakRZSkJDAxEaGgoZ1uLFi2Qmpqq85gZM2YgOztb/bp3755xkhoDxZQQBEEQhMMgylLStWtXJCYmcrYlJSWhfv36Oo9xdXW14eJDLKVExLLYBEEQBEFYH1GWkk8++QRnz57FV199hVu3bmHr1q34+eef8eGHH1pKPoIgCIKwG+7cuQOJRCJq0T6JRIK9e/eatU9jMSSLrRGllHTu3Bl79uzBtm3b0KpVKyxcuBArVqzAyJEjLSWfaTxJtrUEBEEQhJkJDw+HRCLRevXt29foPnv06KHux9XVFcHBwXjjjTfwxx9/cNrVrVsX6enpaNWqleC+09PT8dprrxktW1VC9CrB/fv3R//+/S0hi/lZE8b6YEP3DcW2EARBmJW+fftyamYBMDlUYMKECViwYAFKS0vx4MED7NmzB8OHD0d4eDh+/vlnAIBMJkNAQICofsW2r8rQ2jcEQRCEw+Hq6oqAgADOq3r16oiOjoaLiwtOnDihbrt8+XLUrFkT6enpevv08PBAQEAA6tati+effx5Lly7FTz/9hF9++QVHjhwBwHW1KJVK1KlTB2vXruX0c+nSJUgkEty+fRuAtsvk/PnzaN++Pdzc3NCpUydcvnxZS5b4+Hi8/vrr8PT0hL+/P9555x08fvxYvb9Hjx746KOP8Pnnn6NGjRoICAjAvHnzOH3cvHkT3bp1g5ubG0JDQ3H48GFB59aWkFJCEARBAAAYhkFpUZHVX+ZcrL5Hjx74+OOP8c477yA7OxtXrlzBl19+iV9++QWBgYGi+xszZgyqV6+u5cYBAKlUiuHDh2PLli2c7Vu3bkVYWBgaNWqkdUx+fj769++P5s2bIzY2FvPmzcO0adM4bdLT09G9e3e0a9cOFy9exL///ouHDx9i6NChnHYbN25EtWrVcO7cOSxbtgwLFixQKx5KpRJvvfUWZDIZzp49i7Vr12L69Omiv7+1Ee2+IQiCICon8uJi/DBmsNXH/Wjjbji7uYk6Zv/+/fD09ORsmz59OmbPno1FixbhyJEjePfdd3H9+nW88847ePPNN42STSqVolmzZrhz5w7v/pEjR+K7777D3bt3Ub9+fSiVSmzfvh0zZ87kbb9lyxYoFAqsW7cOHh4eaNmyJe7fv4+JEyeq26xZswYdOnRQ1wQDgHXr1qFu3bpISkpCs2bNAABt2rTB3LlzAQBNmzbFqlWrEBUVhd69e+PIkSNISEjAnTt3UKdOHQDAV199ZfexLWQpsQaXdFe8JQiCIMTTs2dPxMXFcV7lmaAuLi747bff8Pvvv6OwsBArVqxQH7dlyxZ4enqqX2w3jy4YhoFER1mJ9u3bIyQkBNu2bQMAxMTEIDMzU8uqUU5CQgLatm0LDw8P9bawsDBOm9jYWBw7dowjZ0hICAAgObkigaNNmzac4wIDA5GZmakep169emqFhG8ce4QsJdZAUawKdqVaKQRB2DFOrq74aONum4wrlmrVqqFJkyY6958+fRoA8PTpUzx9+hTVqlUDAPzvf//Dc889p24XHBysdxyFQoGbN2+ic+fOOtuMHDkSW7duxRdffIGtW7eiT58+qFmzJm9bIa4qpVKJN954A0uXLtXax3ZBOTs7c/ZJJBIolUqd4+hSrOyJqqOU2PqfQUoJQRB2jkQiEe1GsUeSk5PxySef4JdffsHOnTsxevRoREVFQSqVwsvLC15eXoL72rhxI7KysjBo0CCdbd5++23MmjULsbGx2L17N9asWaOzbWhoKDZv3ozCwkK4u7sDAM6ePctp06FDB/z+++9o0KABnJyMm6ZDQ0ORmpqKtLQ0BAUFAQDOnDljVF/WhNw31oJR2loCgiCISkNxcTEyMjI4r8ePH0OhUOCdd97Bq6++irFjx2L9+vW4du0ali9fbrDPgoICZGRk4P79+zh37hymT5+O999/HxMnTkTPnj11HtewYUO88MILiIiIgFwux4ABA3S2ffvttyGVShEREYH4+HgcOHAA3377LafNhx9+iKdPn2LEiBE4f/48bt++jUOHDmHcuHFQKBSCzk+vXr3QvHlzjB49GleuXMGJEyfw5ZdfCjrWlpBSYi0YBVCcZ2spCIIgKgX//vsvAgMDOa8XX3wRixcvxp07d9R1RQICAvDrr79i1qxZBiumlmfoNG7cGG+++Sbi4+OxY8cOrF692qA8I0eOxJUrV/DWW2+pLSB8eHp6Yt++fYiPj0f79u3x5ZdfarlpgoKCcOrUKSgUCvTp0wetWrXClClT4OPjA6lU2LQtlUqxZ88eFBcXo0uXLhg/fjwWL14s6FhbImHMmYslgJycHPj4+CA7Oxve3t6WHWyeT8X73guBrh9Zdjx944cOBOL3Au+fBAJaW1cOgiAIDYqKipCSkoKGDRvCrRK4bAjzoO+6sMb8TZYSaxG/V/X39EqbikEQBEEQ9gopJdbGyVYrJhMEQRCEfUNKibWRkVJCEARBEHxUHaXEXtJxyVJCEARBELxUHaXEXiClhCAIgiB4IaXE2shcbC0BQRAEQdglpJRYGwmdcoIgCILgg2ZIa2PdsjAEQRAE4TBUIaXETgJdCYIgCILgpQopJQRBEAQB3LlzBxKJRF12Pjo6GhKJBM+ePbOpXJo0aNAAK1assLUYVoWUEoIgCMJhyMzMxHvvvYd69erB1dUVAQEB6NOnj0kr4L7wwgtIT0+Hj49qaZANGzbA19fX4HEbNmyARCJRv/z9/fHGG2/g+vXrosbXNd6FCxfw7rvviurL0TFuTWSCIAiCsAGDBg1CaWkpNm7ciEaNGuHhw4eIiorC06dPje7TxcUFAQEBRh3r7e2NxMREMAyDBw8e4PPPP0e/fv2QlJQEFxfTsi1r1apl0vGOSNWxlNhL8TSCIAjCKJ49e4aTJ09i6dKl6NmzJ+rXr48uXbpgxowZ6Nevn7qdRCLBmjVr8Nprr8Hd3R0NGzbErl27dPbLdt9ER0dj7NixyM7OVltA5s2bp/NYiUSCgIAABAYGolOnTvjkk09w9+5dJCYmqtt89913aN26NapVq4a6devigw8+QF5ennpsXeNpum9SU1MxYMAAeHp6wtvbG0OHDsXDhw+NO5l2StVRSgiCIAi9MAwDZYnC6i+hi9V7enrC09MTe/fuRXFxsd62s2fPxqBBg3DlyhWMGjUKI0aMQEJCgsExXnjhBaxYsQLe3t5IT09Heno6pk2bJki+Z8+eYevWrQAAZ2dn9XapVIoffvgB165dw8aNG3H06FF8/vnnosZjGAYDBw7E06dPERMTg8OHDyM5ORnDhg0TJJujQO4bq0MpwQRB2CdMqRJpc05bfdygBS9A4iIz2M7JyQkbNmzAhAkTsHbtWnTo0AHdu3fH8OHD0aZNG07bIUOGYPz48QCAhQsX4vDhw1i5ciVWr16tdwwXFxf4+PioLSCGyM7OhqenJxiGQUFBAQDgf//7H0JCQtRtPv74Y/X7hg0bYuHChZg4cSJWr14teLwjR47gv//+Q0pKCurWrQsA2Lx5M1q2bIkLFy6gc+fOBmV1BKqOpST5KHB0EaBU2FoSgiAIwkgGDRqEtLQ0/PXXX+jTpw+io6PRoUMHbNiwgdMuLCxM67MQS4lYvLy8EBcXh9jYWKxduxaNGzfG2rVrOW2OHTuG3r17Izg4GF5eXhg9ejSePHmC/Px8weMkJCSgbt26aoUEAEJDQ+Hr62uR72UrKq+l5GE89/OtI6pXjUZAu7dtIxMAqpdCEIS9InGWImjBCzYZVwxubm7o3bs3evfujTlz5mD8+PGYO3cuwsPD9Y9jgdhCqVSKJk2aAABCQkKQkZGBYcOG4fjx4wCAu3fv4vXXX8f777+PhQsXokaNGjh58iQiIiJQWloqeByGYXjl17XdUam8lpI1Yfzbn6VaVw6CIAgHQSKRQOois/rL1Ek1NDRUy+pw9uxZrc9sl4o+XFxcoFAYZ1X/5JNPcOXKFezZswcAcPHiRcjlcixfvhzPP/88mjVrhrS0NNHjhYaGIjU1Fffu3VNvi4+PR3Z2Nlq0aGGUrPZI5VVK7BaKKSEIgjCGJ0+e4OWXX8Zvv/2mjq/YtWsXli1bhgEDBnDa7tq1C+vWrUNSUhLmzp2L8+fPY9KkSYLGadCgAfLy8hAVFYXHjx+rY0WE4O3trbbcMAyDxo0bQy6XY+XKlbh9+zY2b96s5d4RMl6vXr3Qpk0bjBw5EpcuXcL58+cxevRodO/eHZ06dRIsn71TBZWSymPmIgiCqEp4enriueeew/fff49u3bqhVatWmD17NiZMmIBVq1Zx2s6fPx/bt29HmzZtsHHjRmzZsgWhoaGCxnnhhRfw/vvvY9iwYahVqxaWLVsmSs4pU6YgISEBu3btQrt27fDdd99h6dKlaNWqFbZs2YIlS5aIHk8ikWDv3r2oXr06unXrhl69eqFRo0bYsWOHKNnsHQkjNBfLTOTk5MDHxwfZ2dnw9va23EDzfPi395gJ9JhuuXENydBjBtDjC+uMTxAEoYOioiKkpKSgYcOGcHNzs7U4ZkUikWDPnj0YOHCgrUVxOPRdF9aYv6uepaQSBQQRBEEQRGWi6iklBEEQBEHYJZU3JZggCIKoklg5KoEwI1XQUkLuG4IgCIKwR6qgUmJjSIMnCIIgCF5IKSEIgiAIwi6oekqJrb03lP1DEARBELxUPaXE1iTss7UEBEEQBGGXkFJibR5eA1KO21oKgiAIgrA7qqBSYgfuk7Q4W0tAEARRpZg3bx7atWun8zNhH1RBpYQgCIJwdE6fPg2ZTIa+ffsadfy0adMQFRUl+rjr169j6NChqFWrFlxdXdG0aVPMnj1b1KJ9hG6qnlJiD4Gm9iADQRCEA7Nu3TpMnjwZJ0+eRGpqqujjPT094efnJ+qYs2fP4rnnnkNJSQn+/vtvJCUl4auvvsLGjRvRu3dvlJSUiJaD4FL1lBJ7gGqVEARBGE1+fj527tyJiRMnon///tiwYYNWm6+//hr+/v7w8vJCREQEioqKOPvFum8YhkFERARatGiBP/74A126dEH9+vUxZMgQ7Nu3D2fOnMH333+vbi+RSLBmzRq89tprcHd3R8OGDbFr1y5Onw8ePMCwYcNQvXp1+Pn5YcCAAbhz5456f3h4OAYOHIhvv/0WgYGB8PPzw4cffojS0lLBcjsapJQIQV4CPLtnaykIgiAsCsMwKCkpsfpLbFn4HTt2oHnz5mjevDlGjRqF9evXc/rYuXMn5s6di8WLF+PixYsIDAzE6tWrTTo3cXFxiI+Px9SpUyGVcqfOtm3bolevXti2bRtn++zZszFo0CBcuXIFo0aNwogRI5CQkAAAKCgoQM+ePeHp6Ynjx4/j5MmT8PT0RN++fTkWl2PHjiE5ORnHjh3Dxo0bsWHDBl4lrLJQBde+McJ1sq4PkHYJGHcQqPe8aptSCaSeBgLbAq5eIjskS4ldkHENeHQDaD3Y1pIQhF1QWlqKr776yurjzpw5Ey4uLoLbR0ZGYtSoUQCAvn37Ii8vD1FRUejVqxcAYMWKFRg3bhzGjx8PAFi0aBGOHDmiZS0RQ1JSEgCgRYsWvPtbtGiBkydPcrYNGTJELcPChQtx+PBhrFy5EqtXr8b27dshlUrx66+/QlLm0l+/fj18fX0RHR2NV199FQBQvXp1rFq1CjKZDCEhIejXrx+ioqIwYcIEo7+LPUOWEiGkXVL9jdtSse38T8CGfsCG/raRyR6RF6uUNUdhbVfg9wgg+aitJSEIQiCJiYk4f/48hg8fDgBwcnLCsGHDsG7dOnWbhIQEhIWFcY7T/GxuGIZRKxe6xgwLC1NbSmJjY3Hr1i14eXnB09MTnp6eqFGjBoqKipCcnKw+pmXLlpDJZOrPgYGByMzMtOA3sS1V0FJiJi6XKSjpcTYVw24oLQS+aQpUbwBMPGmwuV2RcQ1o/LKtpSAIm+Ps7IyZM2faZFyhREZGQi6XIzg4WL2NYRg4OzsjKysL1atXt4SIaNasGQAgPj6eNxblxo0baNq0qcF+yhUXpVKJjh07YsuWLVptatWqpX6veW4kEgmUjvTwJ5KqZymxh8yXcz8Du8cBCrmtJTEfDy4BJbnAw6u2lsQIyJ1GEIBqwnNxcbH6S9PCoAu5XI5NmzZh+fLliIuLU7+uXLmC+vXrqyf4Fi1a4OzZs5xjNT+LpV27dggJCcH333+vpRRcuXIFR44cwYgRI/SOefbsWYSEhAAAOnTogJs3b6J27dpo0qQJ5+Xj42OSrI5M1VNKzIYJE1nOfeDa70DCX+YTx9ZIZYbbEARBmMD+/fuRlZWFiIgItGrVivMaPHgwIiMjAQBTpkzBunXrsG7dOiQlJWHu3Lm4fv263r737NmjVhj4kEgk+PXXXxEfH49Bgwbh/PnzSE1Nxa5du/DGG28gLCwMH3/8MeeYXbt2cWQ4f/48Jk2aBAAYOXIkatasiQEDBuDEiRNISUlBTEwMpkyZgvv375t2ohyYKqiUmGApMXcqb3Gu9rbSQuDk90BmgnnHsjSSKngpEQRhVSIjI9GrVy9eS8KgQYMQFxeHS5cuYdiwYZgzZw6mT5+Ojh074u7du5g4caLevrOzs5GYmKi3TdeuXXH27FnIZDK8/vrraNKkCWbMmIExY8bg8OHDcHV15bSfP38+tm/fjjZt2mDjxo3YsmULQkNDAQAeHh44fvw46tWrh7feegstWrTAuHHjUFhYCG9vb5FnpvJAMSU2hUfJObEcOP4NcGQeMC/b6hIZjYRlKVEqAakDKSlUN4YgHIJ9+3QvaNqhQwdOWvDMmTO14mOWLl2qfl9cXAxPT0/15/DwcISHhxuUoXXr1ti9e7cgeYOCgnDo0CGd+wMCArBx40ad+/lSf1esWCFobEfFgWaOSgjfZPgg1vpymAO2EsIobCeHUZBSQhBVBYZhkJycjKioKLRs2dLW4hAaVD2lxB4CXSsjHEuJoyklBEFUFbKzsxEaGgoXFxebZBoR+iH3jbGYxeRfiZ7QJQ5sKSH3DUFUGXx9fVFcXGzxccRWqSVUVD1LCaAKJF3ZEch7ZFs5KtNFy1ZKyFJCEARBGEHVVEqOzAOe3FIFlBpNJVIozAE7JdjRLCUEQRCEXVA1lZJylLYuXlaJFBuHtpRUov8DQRCEA1O1lRLRQa+sycscrpfK5L5h139xNKWkUv0fCIIgHJcqqJRIdLwnzIbDuW9IKSEIgrAHqqBSQlgG1sTuaJYSgiAIwi6oekoJ22Vj69Lo8iLbjm9O2C4Qh7OUEARR2Zk3bx5ndV/Nz5YcSwg9evTQWjunKlL1lBI2ti6kdmgWUFqJFJNyHM1SQt4bgnA4Tp8+DZlMhr59+xp1/LRp0xAVFSXqGF2Kw4YNG+Dr62tS34SKqq2U8MWUKIRm5JhpJnusfwEox4FmdoIgrMe6deswefJknDx5EqmpqaKP9/T0hJ+fnwUks2zflZ0qqJTosY48SgS+CgSOzLeeOIzSemNZC4fLZnE0eQmiapOfn4+dO3di4sSJ6N+/P+/CdV9//TX8/f3h5eWFiIgIFBVxrdLWdN/I5XJ89NFH8PX1hZ+fH6ZPn44xY8Zg4MCBnOOUSiU+//xz1KhRAwEBAZg3b55F5LNnqqBSwkLTfRO1AFCUACe/M3ysoYlXqMWlsiglnPMhYpIXbJmyIA6nRBGEZWAYBgpFgdVfYkuy79ixA82bN0fz5s0xatQorF+/ntPHzp07MXfuXCxevBgXL15EYGAgVq9ebe7TJZilS5diy5YtWL9+PU6dOoWcnBzs3btXq93GjRtRrVo1nDt3DsuWLcOCBQtw+PBh6wtsQ6r22jeaga6GfhhCfzdKBfB/bYW1rcrz4f1YILI38PKXwEuf2loagqjyKJWFiI5pbfVxe3S/CpnMQ3D7yMhIjBo1CgDQt29f5OXlISoqCr169QIArFixAuPGjcP48eMBAIsWLcKRI0e0rCXGsHr1avz666+cbXK5HG5ubjqPWblyJWbMmIE333wTALBq1SocOHBAq12bNm0wd+5cAEDTpk2xatUqREVFoXfv3ibL7ShUPUuJvuBWc1ktctOBnPvC2lYWS4kxheX2f6zK1IlaYBGJCIKofCQmJuL8+fMYPnw4AMDJyQnDhg3DunXr1G0SEhIQFhbGOU7zs7GMHDkScXFxnNeCBbrvYdnZ2Xj48CG6dOmi3iaTydCxY0ettm3atOF8DgwMRGZmplnkdhSqtqVEE1EKgplMHJVFKTHKfWMvZiJ7kYMgbItU6o4e3a/aZFyhREZGQi6XIzg4WL2NYRg4OzsjKysL1atXt4SIanx8fNCkSRPOttq1axs8TqLxQMznsnJ2dtY6RqmsJHOEQKqepYSNltXETJOTmPonlUUpYeNoMRqOJi9BWAiJRAKZzMPqL80JWxdyuRybNm3C8uXLOZaKK1euoH79+tiyZQsAoEWLFjh79iznWM3P1sLHxwf+/v44f/68eptCocDly5dtIo+9Y5JSsmTJEkgkEgcr+KKnzLwYBUHvRCai/kmlKTRmhKWEdAGCIESwf/9+ZGVlISIiAq1ateK8Bg8ejMjISADAlClTsG7dOqxbtw5JSUmYO3curl+/rrfvPXv2ICQkxCJyT548GUuWLMGff/6JxMRETJkyBVlZWYKVsaqE0UrJhQsX8PPPP2v5wBwKzQvCXFYLMRdalbaU2ItWYi9yEAShj8jISPTq1Qs+Pj5a+wYNGoS4uDhcunQJw4YNw5w5czB9+nR07NgRd+/excSJE/X2nZ2djcREy9SNmj59OkaMGIHRo0cjLCwMnp6e6NOnj97g2KqKUTEleXl5GDlyJH755RcsWrTI3DJZlkR2xLOmUiJmcjKXpaSSKCXGuEDIbUIQhAj27dunc1+HDh04cRozZ87EzJkzOW2WLl2qfl9cXAxPT0/15/DwcISHh+sdPzo6mne75rHz5s3j1BhxcnLCypUrsXLlSgCqeiQtWrTA0KFD9fbNlzZc2THKUvLhhx+iX79+6vQrh+LOiYr3dmEpqSwTsyMHuhIEUVVgGAbJycmIiopCy5YtrTLm3bt38csvvyApKQlXr17FxIkTkZKSgrffftsq4zsSoi0l27dvR2xsLC5evCiofXFxMYqLi9Wfc3JyxA5pQcQqJUIn0SpoKWEjVNGyF4XMXuQgCMLiZGdnIzQ0FJ07d9aypFgKqVSKDRs2YNq0aWAYBq1atcKRI0fQokULq4zvSIhSSu7du4cpU6bg0KFDgn1hS5Yswfz5Vizbbgpmm5xE9FNZJkRjK7raBY4mL0EQxuLr68t5ULYGdevWxalTp6w6pqMiyn0TGxuLzMxMdOzYEU5OTnByckJMTAx++OEHODk5QaHQziSZMWMGsrOz1a979+6ZTXiTsVRKsBhFQyv7phJEYztaoGtlUQwJgiAcHFGWkldeeQVXr3IL64wdOxYhISGYPn06ZDKZ1jGurq5wdXU1TUpLoVVm3lwpwWKUEs0xHXWCNCYl2FG/K0EQBGEJRCklXl5eaNWqFWdbtWrV4Ofnp7XdMbBQoKsoS0kVjilxWAWMIAiCsARVu6KrJmYrM18FlRKHTgm2FzkIgiCqNiavfaMrb9shsFRKsChLSWWZECklmCAIgjCNKm4pMaF4mtiYEr+mOppWEksJG0dTtBxNXoIgiEpK1VZKrGkp6TROR9tKopQYkxJsN8qAvchhBCUFgKLU1lIQhN0zb948tGvXTudnwj6o2kqJpQJdTYopqQwpwWZvSPBRUgB8FQh874hB5gRhGqdPn4ZMJkPfvn2NOn7atGmIiooSdUyPHj0cbAFax6NqKyViLSWmVCrVVXqeUoIJY3l4TfU3L8O2chCEDVi3bh0mT56MkydPIjU1VfTxnp6e8PPzs4BkhClUbaVE0yohN1eVvyqYfWMUdqKUOKxyVAmsagRhBPn5+di5cycmTpyI/v37Y8OGDVptvv76a/j7+8PLywsREREoKiri7LeE++b3339Hy5Yt4erqigYNGmD58uXqfStXrkTr1q3Vn/fu3QuJRIIff/xRva1Pnz6YMWOGWWVyNKq2UpLwF/ezokTEwXomMr5JTtfEV1mUEo6hxNEsJfYiB0HYFoZhkK9QWP3FiLwX7NixA82bN0fz5s0xatQorF+/ntPHzp07MXfuXCxevBgXL15EYGAgVq9ebe7TxSE2NhZDhw7F8OHDcfXqVcybNw+zZ89WK0w9evTA9evX8fjxYwBATEwMatasiZiYGACAXC7H6dOn0b17d4vKae+YnBLs0GT8x/0sSinRB6UEEwSHKzuA4hygywRbS0LooUCpROPjVw03NDPJ3VqjGk9FcF1ERkZi1KhRAIC+ffsiLy8PUVFR6pXrV6xYgXHjxmH8+PEAgEWLFuHIkSNa1hJz8t133+GVV17B7NmzAQDNmjVDfHw8vvnmG4SHh6NVq1bw8/NDTEwMBg0ahOjoaHz66af4/vvvAQAXLlxAUVERXnzxRYvJ6AhUbUuJJmLcN/qUCZMqulYCk7yjVXR1VMVQV5ySPbLnXeDANOCZeN8/QbBJTEzE+fPnMXz4cACAk5MThg0bhnXr1qnbJCQkICwsjHOc5mdzk5CQgK5du3K2de3aFTdv3oRCoYBEIkG3bt0QHR2NZ8+e4fr163j//fehUCiQkJCA6OhodOjQAZ6enhaV096p2pYSTWyRWqm1IJ+DYlRKsEUkIeyZohxbS0DowUMqRXK31oYbWmBcoURGRkIulyM4OFi9jWEYODs7IysrC9WrV7eEiAZhGAYSjQcFTbdUjx498PPPP+PEiRNo27YtfH190a1bN8TExCA6Oho9evSwosT2CVlK2CjNpJSYlH1TCXA0S4nD4iCWEmMUVsImSCQSVJPJrP7SnMx1IZfLsWnTJixfvhxxcXHq15UrV1C/fn1s2bIFANCiRQucPXuWc6zmZ3MTGhqKkydPcradPn0azZo1Uy9WWx5Xsnv3brUC0r17dxw5coTiScogSwkbS659o2uiVmpaShz1pk1r39gUhgFyM4C7p4DQAYDM2dYSVcD+P9vN/5xwRPbv34+srCxERETAx8eHs2/w4MGIjIzEpEmTMGXKFIwZMwadOnXCiy++iC1btuD69eto1KiRzr737NmDGTNm4MaNG3plePToEeLi4jjbAgIC8Omnn6Jz585YuHAhhg0bhjNnzmDVqlWcANvyuJItW7bgzz//BKBSVD799FMAqPLxJABZSkRigawSfW2L84T3Y1c4mKXEUSdK9sMlwwBrwoDfI4Azq2wmEj9kKSHMQ2RkJHr16qWlkADAoEGDEBcXh0uXLmHYsGGYM2cOpk+fjo4dO+Lu3buYOHGi3r6zs7ORmJhoUIatW7eiffv2nNfatWvRoUMH7Ny5E9u3b0erVq0wZ84cLFiwAOHh4epjJRKJ2hry0ksvAQDatGkDHx8ftG/fHt7e3iLORuWELCVsRCkTRu/UaKppKWHNNAdnAv/7QXhftoSehm0MAxRmqd4mHQJe/MS24rCha4MwE/v27dO5r0OHDpwYjpkzZ2LmzJmcNkuXLlW/Ly4u5gSVhoeHcxQIPgwtQDto0CAMGjRIb5vdu3dzPkskEjx58kTvMVUJspRwMNMNU8yNV8t9wyL5qOmyWA2q6Gp9WAqsXcdt2LNsRFWDYRgkJycjKioKLVu2tLU4hAaklBiNyJgSnU31Zd84SCCjJhToah04wYF2bI2wN3mIKk12djZCQ0Ph4uKiZUkhbA+5byyBuSwljqSTOPIqwfYihynYtaWERWU414RD4+vri+Jicy0pQpgbspSwMdsNkywlAhtaVIzKj4NYSuxaNoIg7AlSSsRQIjAbRpSlpDKuEiz0EHv5rvYihwnYzbnkwVGsOARB2BxSSjgYuGEm7ONRIoT2o6PvuN90V7l0pDLijjzx2POErg9dMSV2d/7JUkIQhDBIKWEj5IZZXvXVXGvfPEsF9rLz5yU63jsQDue+sRc5TICTdmtnVYIdWWElCMKqkFIiFkETLl8bPQrGjf3GSmNHOHCgq8PigDElBEEQeiClhIOAm6f6KdQKN1pHct+wcThLiYOi8/qws/NKxdMIghBI5VRKLHnjE2Ia5x3fgEy8xziQUkIpwbbFrr8DuW8I2zNv3jy0a9dO52dzcefOHUgkEq31cQhhkFIium+lgDGMGP/7lsC980ByVMU2R7WUCIYmKNNwEPcNWUoIC3D69GnIZDL07dvXqOOnTZuGqKgoww01uHXrFsaOHYs6derA1dUVDRs2xIgRI3Dx4kWj5CC4VE6lxJIYYykZuNbwMTkPgMjexslkFzC8bwXzcw+g4Km5hBFJJZgo7TqY1J5lIxyVdevWYfLkyTh58iRSU1NFH+/p6Qk/Pz9Rx1y8eBEdO3ZEUlISfvrpJ8THx2PPnj0ICQlRr/RLmEYlVUps7L7RHL/BizDOFeNAlhJT3Tdpl4GYZWYVSTCV4undxtaIpymqTDI+KsX5JeyJ/Px87Ny5ExMnTkT//v2xYcMGrTZff/01/P394eXlhYiICBQVFXH2i3XfMAyD8PBwNG3aFCdOnEC/fv3QuHFjtGvXDnPnzsWff/6p89iYmBh06dIFrq6uCAwMxBdffAG5XK7ev3v3brRu3Rru7u7w8/NDr169kJ+fr96/fv16tGjRAm5ubggJCcHq1asFy+1oVM4y82Jugg9igeCORvStLyVY8Eb9OKr7xthA16Jss4tSZbClpaSkAPihner97MeAzFmjAblvHAWGYVBYqq/KtGVwd5ZBIuJ+t2PHDjRv3hzNmzfHqFGjMHnyZMyePVvdx86dOzF37lz8+OOPeOmll7B582b88MMPaNSokdEyxsXF4fr169i6dSukUu3neV9fX97jHjx4gNdffx3h4eHYtGkTbty4gQkTJsDNzQ3z5s1Deno6RowYgWXLluHNN99Ebm4uTpw4oV7x+JdffsHcuXOxatUqtG/fHpcvX8aECRNQrVo1jBkzxujvY69UTqVEzE35197AXBFuAyGWkmIdxdAqNcZYSjQ+l9eAIYShc0E+K8tR8LjivbxIWymxa9cSwaawVIHQOQetPm78gj7wcBE+HUVGRmLUqFEAgL59+yIvLw9RUVHo1asXAGDFihUYN24cxo8fDwBYtGgRjhw5omUtEcPNmzcBACEhIaKOW716NerWrYtVq1ZBIpEgJCQEaWlpmD59OubMmYP09HTI5XK89dZbqF+/PgCgdevW6uMXLlyI5cuX46233gIANGzYEPHx8fjpp58qpVJSSd03ItC79owR7R9eBzYP5G4z2uLhoJaS0ysFNtSYoBQlZhdFGDacKM1lObCXid/Q9yFLCWEiiYmJOH/+PIYPHw4AcHJywrBhw7Bu3Tp1m4SEBISFhXGO0/wslnLLhRiLDlsW9nFdu3ZFXl4e7t+/j7Zt2+KVV15B69atMWTIEPzyyy/IysoCADx69Aj37t1DREQEPD091a9FixYhOTnZpO9jr1QuSwnDADlpQLVaFhzDgKXk9CrzjeVI7hv2ZHPnhPhjAEBuBqXk70+BrLvA2zsBHhOrIDmsxfU9wIHPgCEbgQZdjehAx/Vh9e8j4jq1t2qzBAd3ZxniF/SxybhCiYyMhFwuR3BwsHobwzBwdnZGVlYWqlevbgkR0axZMwAqJUNsLIqmIsNWcGQyGQ4fPozTp0/j0KFDWLlyJb788kucO3cOHh4eAFQunOeee47Th0wm/Jw5EpXLUrLvI+D7UGCRFZQSq9z4HUgpMQcKMywnfuFX4NZhIO2S6X1Zml3hQP4j4Le3jDuefaOzF0sJ39h2IxthCIlEAg8XJ6u/hFof5HI5Nm3ahOXLlyMuLk79unLlCurXr48tW7YAAFq0aIGzZ89yjtX8LJZ27dohNDQUy5cvh5JnDbRnz57xHhcaGorTp0+rFRFAlc7s5eWlVqwkEgm6du2K+fPn4/Lly3BxccGePXvg7++P4OBg3L59G02aNOG8GjZsaNL3sVcql6Xk0ibjj726W3tbUQ7w+CZ3mzWf9BzJUmLUZKNxjDkVPVF9WXCiVCoApRxwctXfxmTsOZjU3uQhHJX9+/cjKysLERER8PHx4ewbPHgwIiMjMWnSJEyZMgVjxoxBp06d8OKLL2LLli24fv263kDXPXv2YMaMGbhx4wbvfolEgvXr16NXr17o1q0bZs6ciZCQEOTl5WHfvn04dOgQYmJitI774IMPsGLFCkyePBmTJk1CYmIi5s6di6lTp0IqleLcuXOIiorCq6++itq1a+PcuXN49OgRWrRoAUCVJfTRRx/B29sbr732GoqLi3Hx4kVkZWVh6tSpJpxN+6RyKSXGUloE/B6hvf3n7sDT29xtBpUSHZVZazY3QjA7UEoYRphyZMxEqHmMqUoYuz+JnRgBI18FMuOBaTcBV08zd26PlhIe7HmxQMKhiIyMRK9evbQUEgAYNGgQvvrqK1y6dAnDhg1DcnIypk+fjqKiIgwaNAgTJ07EwYO6g3izs7ORmJiod/wuXbrg4sWLWLx4MSZMmIDHjx8jMDAQL7zwAlasWMF7THBwMA4cOIDPPvsMbdu2RY0aNRAREYFZs2YBALy9vXH8+HGsWLECOTk5qF+/PpYvX47XXnsNADB+/Hh4eHjgm2++weeff45q1aqhdevW+Pjjj4WdNAeDlBIAyErh366pkADGr33T5BVx7e2BY0uAi+uACUcB37oWGEDzHGooJUU5qpiLBl2BNsP0WxsA7oRnL1amB2VVHu+eBpq9asGBbKiIcNxIfEqHPVtxCEdi3759Ovd16NCB4yKZOXMmZs6cyWmzdOlS9fvi4mJ4elY8KISHhyM8PNygDM2aNcPGjRt17m/QoAFHDgDo3r07zp8/z9u+RYsW+Pfff/WO+fbbb+Ptt982KFtlwE4eJ23MwS+FtzX2piqRAO1GGXesrYj5GsjPBI5/I6CxBSwl0V8D/20H/poM/NTNcH9sN4gYS4k1JkqLZBbpmOxtOfHnPwFuRQFsn7u9yEYQUAWZJicnIyoqCi1btrS1OIQGpJQA3PVmDGEo0JVvu7FP7fbytC9zsVDHBiwlOfcr3j/i9/NyuzNSKbGGlUGvUmKO8W3pImH939Z2VQXuxv3G2m/HriWiypGdnY3Q0FC4uLhoWVII20NKiS5u6VBUTLrhi70h24lSYshtAnC/WuhAMw0s8vub01KSsA+I7KO7dLpYLGEpsUcLhLysOFXC/opt9ignUWXx9fVFcXExTp48qS5WRtgPpJToQleaprExJYD4G7Kd6CSClBI21RsIa2fIfSPWUmS0pYSHHaOAe2eBfVNM66ccixeGszNrBOf8U6ArQRDCIKVELMZm3xiFnWglTm4CGhkzKRpw34hV4oy1lOij8Jl5+rFmtVprWyP4fhPs82/PmUEEQdgVpJSIpSrWKZEKSNIyxkSvz1KyexwQv1dYP+r+2Nk39hZTYol1fXSdc2tP/IbiqMhSQhCEMEgpEYtVY0ocFTNYSq79Ln5YjqXEThS6cvRZSsxi2bBh3Iah4G6KKSEIQiBUp0Qsp35Q3XB1KSd8N12pTPc+vdjJxCpogjeDpcRUGB1pqNaWgw9D7ht5sfjYHZ2TvT1YSnQ875ClhCAIPZClRCzXdgNXdwEFT4QfI8T9QZihoiu7XLuZysyby+Kib7FBRgEsqg3cPGLCAPZmKdER6FplrIUEQRgDKSXWoNxSIvaGbG8uCH0YZaI3EOgqFrb7xh7cBGwZhAS67p0odgD+sezNUkJl5gk7YN68eZzVfTU/WwuJRIK9e/dafVxHofIrJeOPWnlAPvcNj6UkbJKAvhxIKeFghkBXo4Y11lJiIdgTsJBAV5MyhhjetygpAO7HWlZJE2MpsQdlkagUnD59GjKZDH379jXq+GnTpiEqSnjhzNatW2P8+PG8+7Zt2wZnZ2c8fPjQKFmICiq/UhLYFqjVwrYylCsl7Buyv4DyxvayqJwgzGEpMRFdpc1NEsMERYktg1JuuL3Y/7eQmJLNbwK/vgzEbhDXt7FylFMZLCUMAzxKNNMqzoS5WbduHSZPnoyTJ08iNVV8kUNPT0/4+fkJbh8REYGdO3eioKCAV5b+/fvD399ftBwEF0ea9fTzJFnPThs/naktJWw5BEx2arePA2COJ+DKFlPCmYAFyGPS99ehoNw7q/p7aZMJfRuAdwkAHSnBjsSZVcCPXYC/PrK1JIQG+fn52LlzJyZOnIj+/ftjw4YNWm2+/vpr+Pv7w8vLCxERESgqKuLsF+u+eeedd1BcXIxdu3ZxtqempuLo0aOIiFCtNL9mzRo0btwYLi4uaN68OTZv3qyzz+joaEgkEjx79ky9LS4uDhKJBHfu3AEAbNiwAb6+vti/fz+aN28ODw8PDB48GPn5+di4cSMaNGiA6tWrY/LkyVAoKu6BJSUl+PzzzxEcHIxq1arhueeeQ3R0tODvaysqj1KSepZ/u7XjMvQ9NQa2ZW0TIpe9uG9EZt8YOwk9vG7cceXYW0yJWOuRKZYxvv7j/2L1baFrKTcD2DFSe7tOS4k9/F8EEv216i9nHZ9KDsMAJfnWf4m8Lnbs2IHmzZujefPmGDVqFNavX89ZmXfnzp2YO3cuFi9ejIsXLyIwMBCrV6826dT4+flhwIABWL9+PWf7+vXr4e/vj9deew179uzBlClT8Omnn+LatWt47733MHbsWBw7dsyksQsKCvDDDz9g+/bt+PfffxEdHY233noLBw4cwIEDB7B582b8/PPP2L17t/qYsWPH4tSpU9i+fTv+++8/DBkyBH379sXNmzdNksXSVJ60EJ1mYYntb4TlE0KX91RyNn4ZyEwQcJwD6YzGpuOyeXrbuOOUStXifcZaSix1fYgNPhWtOOjqs2z7zndYfVvoWtJ1Hev6Lo7mvqlqlBYAXwVZf9yZaYBLNcHNIyMjMWqUatX1vn37Ii8vD1FRUejVqxcAYMWKFRg3bpw6BmTRokU4cuSIlrVELOPGjcPrr7+O27dvo1GjRmAYBhs2bEB4eDhkMhm+/fZbhIeH44MPPgAATJ06FWfPnsW3336Lnj17Gj1uaWmp2gIDAIMHD8bmzZvx8OFDeHp6IjQ0FD179sSxY8cwbNgwJCcnY9u2bbh//z6CglT/z2nTpuHff//F+vXr8dVXX5l0HiyJA816htBxA5FIdO+zNk4uQNcpQEBrCLI+2FIpETuhinVVmJO9E4EVrYG4rRbo3EzuG2taSnjHspClRKeLUUfxNHv5LRIOS2JiIs6fP4/hw4cDAJycnDBs2DCsW7dO3SYhIQFhYWGc4zQ/G8Orr76KOnXqqK0lR48exZ07dzB27Fj1uF27duUc07VrVyQkCHgI1YOHh4daIQEAf39/NGjQAJ6enpxtmZmZAIBLly6BYRg0a9YMnp6e6ldMTAySk/WFOtieSmQpsZebnUA5hDwV2zIlWOwTrTksJcby33bV37Ms86xdXA9iLSUmBLoaGqsoW1zfQigpAE6vFNDQQQNdHSkl31w4e6isFrYYVyCRkZGQy+UIDg5Wb2MYBs7OzsjKykL16tUtISEAQCqVIjw8HBs2bMD8+fOxfv16dOvWDU2bNlW3kWhcNwzDaG1j91feppzSUu1MPWdnZ85niUTCu01ZFuyvVCohk8kQGxsLmYz74MBWZOyRymMp0XWzk9iB+4YPQUoJ699Tkg/8NtiyWRRsOOdMgKy2tJTwYqZAV03SrwBZdwR2a0eWEkssCHhsMXDzEP++uN+A/MfCZCPsB4lE5Uax9kugAiiXy7Fp0yYsX74ccXFx6teVK1dQv359bNmyBQDQokULnD3LjTPU/GwsY8eOxf379/HHH3/gjz/+UAe4lo978uRJTvvTp0+jRQv+DNBatWoBANLT09Xb4uLiTJaxffv2UCgUyMzMRJMmTTivgIAAk/u3JJVHKbFGVU6zIlIpObcWuHUY2DfFciJxEDl5mGvi2TIEeJpi/PHGyCC0bfYD4KduwP+1NdxWs18hFgLRSokISwljgbTWe+f071dfqw5qKSHsjv379yMrKwsRERFo1aoV5zV48GBERkYCAKZMmYJ169Zh3bp1SEpKwty5c3H9uv5A+j179iAkJMSgDA0bNsTLL7+Md999F87Ozhg8eLB632effYYNGzZg7dq1uHnzJr777jv88ccfmDZtGm9fTZo0Qd26dTFv3jwkJSXh77//xvLly0WcEX6aNWuGkSNHYvTo0fjjjz+QkpKCCxcuYOnSpThw4IDJ/VuSyqOU6LvZWTM2Q+gEJ0Qmtr/eEuZ3fYhVLMxlKbl5CPhjgvHHGyWDQIX2caIJMgiRx0w1Ufj+d5aotWHoGnl4jaedA1lKyKpjd0RGRqJXr17w8fHR2jdo0CDExcXh0qVLGDZsGObMmYPp06ejY8eOuHv3LiZO1F8xOTs7G4mJwn7jERERyMrKwvDhw+HhUeF6GjhwIP7v//4P33zzDVq2bImffvoJ69evR48ePXj7cXZ2xrZt23Djxg20bdsWS5cuxaJFiwTJYIj169dj9OjR+PTTT9G8eXP873//w7lz51C3bl2z9G8pqkZMCZ8C8N5x1VOvpQnuyL/d3lOCLRlTcitKv8Un+764sXnlsYMJxdLuGzExJUKKt5kbvu9MlhLCBPbt26dzX4cOHTixGTNnzsTMmTM5bZYuXap+X1xczImvCA8PR3h4uCA5RowYgREjRvDumzhxol4FiNH4XXTt2hX//fefzjZ8cs2bNw/z5s3jbNOs1eLs7Iz58+dj/vz5OmWxRyqPpUQffDd7ds0Qyw4ucju7iS3dTha0lPz2FpB9T08Dc3xve1BK9CgK137Xbm/RmBIBZe7NDqPxF8KUs2u/Awe/5FboJQgzwTAMkpOTERUVhZYtBVTWJqxK5VFKDvD77ABY133jLTDH395rkJjivjHVSmEOZUyU90ZfYzMphuwhSgqA3eO020gFXhMPLgGnftBjdeD5PtVqCetbFAZOslonEem+2T1OVU018W9jBSMInWRnZyM0NBQuLi5alhTC9lQe940+rKkACC0NL2TiFTq5P4wH/BoDTq7C2guBPeEJktWRs2/0YIky84piXYMJ6/eXsiJMHcZUbFvDqsHAd900f01Y32IwdH2qv7+IQNdSVnGr8uwdgjAjvr6+KC7W9RskbA0pJeZGqM9ciExC+rr2B7B7LND2beDNNcLGFoQNLSXmQJQMQtsKVBoYBtgVrlFqXcD5EXudCqkKXDGouL7NQtmYYjKzfnnZcuIQBGH32LkPwUzYY/aNmNof+nzrR+aq/l7RqGZ65kdVIG/BU4HyaI4tMg7ArJYSK8eUMAxw9wwQ842BLBWBfWbGA/F7get/sA61REqwLuwkwFR93Yi4ljJZaZv27uIkCMLsVA1LiaZLJai95cbSvPnrMv8LcgswKqVidRiQl8HfRJfCcrDMV3pqBdB7gYCxNIc2IfuGzdk1qoX2/rfSTuvFlLG+r+qvZy2gYzhrhxEy8xUqE6SUmCt+hS/7xhJKiSEljcdSIkZZtOfrpRKhmQ1CVG1sfT1UjUcRzSeu2qGWG8uc7hvPAOBipG6FRAilxi5Axbowxca/sK/pf78ALm8Gbh8zUg4jMfaH9eSWnp0i3DeaCKkTYlFLiQXqlBgUg89SQhk19kJ5mfKCggIbS0LYE+XXg2YZe2tRNSwlmjf78poNAa2BjKvmHUvwTVfABOfqKaydJTBH8TS2QlSca7JI4rBQmXlB3RnpPpEIDJI2BF+hPUsUTzNE+Xc2utqvCdd+boYqg6fTOKBGI+P7qcTIZDL4+vqqF3Hz8PDQuUYLUflhGAYFBQXIzMyEr6+v1po51qJqKCWt3gLunqr4/Nx7qr+j/wKWNTS9/6OLgdQzwKg/eCYfXe4bgX2bfJOwkimOL5Dz3FrrjM2HJcrMC++QZ5MFLCX6CqJl3dUUQFzfZsFES4kp1/7OMcC9s8B/O4FpScb3U8kpXwelXDEhCF9fX5uuj1M1lJKO44DqDStiSTxqcP+ayvFlqr/xe81rKWEYYe3E8PC66ly4GFiV06SYkrJJKDedtUnEpGiW6qMWSAkWOknynTtBFV1F/q/TLunet2sM97PQ839lB1CrORDUznBbgynBZfvvsBcos5ClRKkENg8APPyAIRtUCgkA5D0UMZ4mlT/WQiKRIDAwELVr1+ZdnZaoWjg7O9vMQlJO1VBKpFKgySuWH6ckz7hA1+BOwIOLPI3MMZGx9ifsA3aMAhr1AEb/qf8wU7JveNuLuMGbEkOjVwadjSvenl4JNNCx/IDQPvnaPbwOrHkR6DEdqPcC/3HmzDZ5fFNTKMPH3I4G9ryrej/PHGstMUBhFnBoFmuThSwlT24BKcdV7wetE34cAUDlyrH1ZEQQQFUJdLUWilLjLCXO7vxNLq4zQ4AiazIqL21+O1rccUImNEMpwVaP6DbBfbN1COuDEZYqvmsgKwV4eFWlFOq6Rszpz9dUcIRclw/jzTc+oDqvminploopYZ87WwT1EgRhFkgpMSeKEu2bv5A1dvQ9IR/lWTHS2KBFMeufiC2Gxm7/3w4gJ034WJbApmltAlNlNTGnpUTz+1vkfAit6CriGDZilDT2ubPF4oMEQZgFUkrMSfyf2jf/V+bwt2XfcLNSxI2TfFR4W44bRoTpXGxtCc2+D3ym2UD42GbBwjEl+iZ5Q+fZXBVd9VGime0k5HwIPGcPYlUumeI8w/1pKUcWSgnmKCVkKSEIR0XUXXDJkiXo3LkzvLy8ULt2bQwcOBCJiYmWks3xuH+Be9NtMwxw9dLRmDXBPUsVN86dE6JFA2B8nIXmcdf+ADKuaTTXmGzyMsH5jta2XJhSZl5Iaq5epcQOLCVaQ5rx/P/ysir25mmygTGhfV2IkUPM+WAXSCRLCUE4LKLugjExMfjwww9x9uxZHD58GHK5HK+++iry8/MtJZ9pNO9n3fEadte4CesxP5sSP6Aou+mKrdIpylLCahuzlJtJsXsssLarRnvNid2BjHCassuEFA3SN7kamHhPLOffbmulhK+NwpQJnoHWubBYTAlbKSFLCUE4KqKyb/7991/O5/Xr16N27dqIjY1Ft246MhZsibULAblUs07FSkYJ7PsYuHlIXFEyXbIp5MCWQaoA2OfeB15byp08FCWqsZr1UWWRCOlbs7S/qU/qMrErIJswntQZgLGVcGH4u57/WccOS16vRpyP/Z8AV7YDky4CPsFGDMnjvrFGmXkKdCUIh8WkR7PsbFXaYI0auut9FBcXIycnh/OqtDAMd3LWe1M1YQI6twaIXQ/kPACKDZ1PATElKdEVGTnn1pY9HWtMHuX1HnQ9zWulQpv5qV+Q9YIFwwB5j4CbR8RblMSW1dfaZ6RiamtLieb//OI6oLRAdb0ZNaZSu0+LKe2scch9QxAOi9F3QYZhMHXqVLz44oto1aqVznZLliyBj4+P+lW3bl1jhxRP2mXrjQVAFdjHuuk66Xm6Z098L35iOZHY6LOUaLbTcmm4qP5qWkB09a3VzkRLiWhLCwP82EVlAdJcQZmvreixTHDf6MKiLi8bVXQ1KabESMWdlBKCcFiMvgtOmjQJ//33H7Zt26a33YwZM5Cdna1+3bt3z9ghxZPzwHpjAYC8CLi+p+Jzjxl6GrNuuHU6W0wkDkLrYzAKHiWjzNOnKwhU04+vVSfD1ElRx/FpcTqaM0BhWY2MxH9EDqXrad5M2Te6sKS7UYhM5g5G1rQcCpVDjYjzwZadYkoIwmExqqLr5MmT8ddff+H48eOoU6eO3raurq5wdRUbD+CgsIuSDVgNeAlcP8BcC7EZQshkq25noqVE8zux91erBeQ/0icpT/86JkydCyqasvYN67NORUGfUiJ8aA42d9+YfVAeBcFScuhRShjGOIXPxku4E0RVRNRdkGEYTJo0CX/88QeOHj2Khg3NsJiduRiw2nx9hfQ3vQ9Da8uwb5K6Jnpzo7M+Bo9SoisjRZcCxee+MeuTv8gJQkxzvkmMD6FBxfYYU2IL9w3DaAedipnooxaIG6scTffNxjcsr2DcOABsGaKKYzKSrMtn8GDVJBQ/e2q4MUFUUkTdBT/88EP89ttv2Lp1K7y8vJCRkYGMjAwUFhZaSj7htB5iuI1QzBGM52xAKWFbJ6z1hCzUUqJUaN/EpWVKibGWkvJJkWHEW0n0IcSSYWhC0qoTw2pfvp6KUgHsGCmwT2NjSiSqgmTpVyzjSjHcyMxjKnkUPhG/LVFFBfUoJXdOAPJiEX0ZwfYRqgw19jo/Iqn+Z18EP96Mx+usFGNGEHaIqNlwzZo1yM7ORo8ePRAYGKh+7dixw1LyCcecT+XmUEr0BbkCtrGU6CzapdmMx31T3kZn9o1me03rS9l+rYXiBKJzUtXxfxczqZdoVCblO7bwmeYAuvszVqGQSIFfegI/dQOS/jXcXgzl17RV4y3M4L758Tme6sB8QxlQvq1VHiA/0+Qu3HKpICVRdRHtvuF7hYeHW0g8MZhTKTHDE6NXkIEGbEuJJZUSIQGAAtw36qY6ynmf/ZHbTlf2jdGZEUZk3whuKiBtVa5Rt8QilhIp8DhJ9f7qLuP60AmjsvosqQPEbtTRRKTiZ3BIPveNSIX/0Q09dV04Hesfw6HiQxxJVoIwLw5UdtMAtoxfUMvAOp21mgk/zpKWkovrgL0fln0QE1OicWMvX2CPvahfuYJRyuO+0wp0LRvbWFeV0HgYo/oW8DSvqZTotZQYG1NiwaqkDANsGqiqO7LvI/HH87n0DA9qWkqwqKHYSgnfuXOciV7iQLIShLmpPEqJOSd2vhtnk94Cjiu7Afu3NtxWYi1LCYC438BfXVMtAPejUgGtm/hfk1V///ywYlu5gsI3CUtl/OMZrUSIdd8YWVIf4JdbMybB0inBZi8yxmO14GvDh6IE+KEdsHmgyCF5rrlHiUCBhQM5+f43ZCkhCIeg8iglANDlXfHHvL0TaPmmxkaem0JQe+F9SoWcVivHlCQe0D3RCcm+KUfJspQUZVe01+pTqrHdzJaS1LNA7Abd7TmWBgM3eS35hVhKxPQnEPa5MbdSYkp/9y+qgoHZKe/CBoXWubx5EPimsfGy6BzKUEC3I030jiQrQZgXo+qUVCqa9VG98jKBu6cASPgnZEOBq2yETLwcS4kVdMOMqxBsbWB4LCV8FD5VrYnC52rgc9+UFqoyS4xCQ551fVR/243UbgqIm4SFpARrxcLoOT/Gul4saSkxdkE+wLTrk9dqYeH1ofjOvwNZSiQOJCtBmJvKZSkxhRHbgCEbgS/TdbgjROhvYt0x1rCU6HKnADzVV3liSvjITKhoz9snezwG2Pg/4PcIIdIK5+lt/u1iFmUTYinRCoa1gPuGrRzaU1VSjgVHbL0YKyxQqRpI/5hWk4MgCFOoXJaSarWMP9bNB2g5UPXe1VN7v5hYCEFKhpUtJVIn4e4boUGN5e4bXksJtM39988b7lMXuuTJusu/nSOTgf+dUROWJWJKLOm+0ZBXqeRxM4rMuBI2sMj2RmIJ943ciPpLyUfFH6MFWUqIqkvlspSEfQi4eJneT58lQGBbYAArzVWM4iDIfcN6L8YKYyxalgtdwqDsBi/C3M9nlbj8W0V6K7ut0eg4PjdNR3NWe52l6HnaCh3f4oGu5s6+0QzmFdE/RykRmdK9M1xce6MxkH3jUC4RR5KVIMxL5VJKXKoBg9eZ3o9vXeC940D7UayNIiwlgtw3Fsq+YRggjmeRRIbRo5MIWJCPD0UxkHqOPyVYWwABbQxQnGe4jXo41sSUrVmxVU9bnW1MiFERir5S6SajaSnh6V9I2rVYuUoMlOaXlwCPkvS3EUIlCnR1hJTgnJvXkb50ELKunLO1KEQlo3IpJQDs4uYjNu3VnO6bhL+Ave/z7OCpGVEhgEZTPdk3bA7NAta9CuwXUBbb0Eq93sGG+/hWRO2XPe8Jb6tP4XBy19FG4/wc+wr4uQdQkm+C68WC166W+0aEcsG+Pte/Zj55Ds8BFtUCfuwMxP9puL3+Bqy3eoqnyUuAq7uB3IeixLUudnAPMwCzZRgCC4/A+4/XbS0KUcmofEqJxQLaRNwohMSUcMrMm/HfkHSQf7uzB3THDAioU6KP28cMt7l5SP9+z9rAyN/1tynNFy6TGPRdM+X/S0OBrjFLgbTLqgnPWNcLp09zl0UXopQIuD4y/jOPOCnHgVP/V/H57Fr97Q39rjlWJj1tTyxXBVv/0tOwjLr6J+CDewAAmcTcFj2iqkNKiSk8x2eRgI3dNzq+v1egnhurkZYSc8IwQLWahtv98jLw4JJ5xxbibhF6XekLKDbE5c3GHScERgl4BlR85pu4rfkvz9GIBSot0N/e4P9IYPbNjf1l4z8w0J+O460CKUBE1YWUEsH9MsCLU7nbwibxtxXrjhHi7mnYHagXpr/NPB/gCk88CaA/zVdz/LxM4NYRwzKZGyEWpgexwLq+po8laPVkFqlndR9fyiqs5uplnnRecy8gd+sIIHOu+GzIUsKxPFggPfmJxsKMhpQSQ9YnQ/9PdVC2kRO+FZUSR4gpIQhLQUqJIYI6qP62HAj0msvdx77JsxFbd0SIEtN1imlZOvqUEs0b9ZZBQPQS48cyCka4xUhh5mXohbhbor/SPKjiraKk4r3UyX5N/dn3Kt4r5cIziCzxfU4s534uMcFSwl6PCdDx/yxXSoy8P5ClhCCsAiklhog4DEy/A/jW094nc+E/Rqw7xlD7908BTV4B+mhOjCK4cwK6b3Z2cBN8cap1ishZAk2rgyElp04XAZ2aO6ZEg+glwHctgOz7Fdt0WhuscH0YCrzVdU5jNwILawJJrEBqvasE27+lxBQlkFEokP77WuTcvG5GgQjCelQ+pcTcpmaZE+BenX+fLsuFubNvAlqp/ga2Edcvm4vrgCe3+PfZ+sn+w/MqS5SlFyZkY+p31pe+a3ACs+L57vox//bLm4HcdFXWEB/s35E1JmRlqYH9LHnuXwR2RwDZDypWPD66qGK/vpRgB3DfmEL676sReHU6vLe8YGtRCMIoKldFV8C6E6wl3Te1WwKZ1nrasbFS4lNX9dfccRTmQOf1pEMpYRSGFeP7F0wWSzCuBooJ6lq4kD0JW6PkvcKQpYQl26+vqP7m6Ujr1bf2jT7lIvFfVbB1nU7C+jREZoIqwNzdV9RhJv0K7p425WiCsDmVz1JizScaqQ6lRLT7xgb/Bo6p3sZKSbkyYvaCYRak/JzduwBk3anYfmmT/XyPNsOA6g0MNNJxHTDWtpQY4b55kqyjrb5FAHVc60+SgW3DKhQenccLJC0OWP088H1LcccBAEw533bgiiUIEyClxBR0WUTMkX3TYbTqb4AJLht9cG7cAm5k3sGqwlOWoPx8aQYs2jUM8DAeiOzFLSh285B5lBJzWI3e+tlwP0IUEXtQSsRYKvS6b3R8l2c61lDS26cebh1W/S0RUYW4YjAjjiGIykEldN9YUSnRdcM3h/um83ggoLXqZRFEWkqUCuD7UAvJUnYe3Xws1D8fZrjxP4jl364wh/JmLleWoX7YWUQspdDeYkr0ZdQIaVt+jetaVdrgoo1irxfj/3+mpAQ7ajpxTuI1VKvXGDJ3d1uLQtiYyq2UPDfR8uP1XwHkZgAxX1dsE+2+Yd3AfOoBb/2kCrBt0NUsIvLCKIEnd4Q/1edlWE6WcqXMty7wv1UqH3z9rsCyhpYb01T0LVpoDouPueJrxFhKOLExIuu4mAqjBNb3071fX5wIX1/aG02rvSP2HNhjfJSdknn0T9Q+PhpPJc1QY64V460Iu6RyKyV9LVBrQyJTPYm5+ao+dxqr+stRSsR6xVg3sMY9gfpWiJxXyoGVZTVYRmy3/Hj6YN/AO7xjmTFSTgANXzJjh3qeSM0SU2KmSc1gbZuy71FaxFWm2NYGawS6AsDdk7r3ibKU6EgJvr5Hd/8GlTexipltlBLGAS0ligsbAQA1GDMszEg4PJU7psQSTyvjjwCNegJj9uluI3YtG7ac1nrCYq/sqyuLwVpYI9B3Y3/uZ3OmBGtiSUuJWLkNWe0YBijMApbWB87/VLGdrYjYQ+CuvvVsNDn/M89GPatkAzDsvhGpmJn0OzbBfWProHWCMJHKZymx9JNCcAdg9F79bUyxlFgLdtyDrScdaylij5KAWiJWGtYLo1tBMEdMia5rSOykI8RSknQQkBdpbGZNwmaJkTERfXEimmRc5Wmrp6KxJsnHVBZLzeNFIe6afhp3FjXUR9pvTZSMvzeDKSlCoFl7JUWKqKByW0oAMAyD0hIrmJ9fYZWgNyWmxBAvTRPXty7krFLt1jLP2xrN0uZCyX+ivU2fchC73rhxOOiylIicsAxZ7Rgl/7ozbEU114LxREIx9RplGOHnbutQ1d/AtqzjLRtTItn7gbj+dWK5CV5ZWoKAC5MQeMVM9yCC4KHyKSUaZt7Dkdfx80cxyH5kYG0NU2EXUmO7RszNK7OBkbtN74ejlNiBed4aiDXBA0BpPvBNI10dmiSOXpL+4V8PxtxP7AwD7P9EeztbCZBb8HoWSvn/7uZhUzrh35z/mHttlD9UuLAKz1k8pqRCNmtm0KTv/RVPY/XE8rBg5BZ6eCFDCcGi8iklLQeq/jZQBTXevJgJALgWI3KpcrHkpFe8v7JV5MEib2BNewMjfxc5hgaHZlW8PzjTtL7YBHc0X1/mhuOGMPVOKPB4F0/jh4jbwjOs2MnRgJy6+rM361m5PFELKrblZwo/ntHhbsu8AXzTGNj8ZsW2ctcZJxvJ0tk3ZnJhinDvPT51CIFxn6LGPj1ZTyxK83ONlYogBFP5lBLP2sDMdK1AVIml4xZ0lZwXgjGymZqmefOgacfr4uXZlunXHMT/ab6+SgsNr2xbvyvwwVnjx5DzrIYs9v9urO4Vs9TIAy1EbpnSb3RQtg73zX87tLfxKSWilTRxv2mGE0NkHdNBcSpP7I0O7kfOhtuqphaRQ2wMzYO1n+LBGh7rHlEpqHxKCQC4eGhP9HZdNsAI4byDzC+GObBFyXyx5D0Cdo81rY8fuwAHZ+hv0zlCVXvFWB5e095mdkuJjv3XzOAiNCf7PgYiXzVeKdEVU8K32Gb5Ncx26WgGAusjJ90kS4lp7hvhx4rJ1Klz7wdjhDE7Jc+eIjjjVwQ/XIfCzHTDB+jg4cGdeDL/eeQkClfMNMm/dwdp3wzFk/MxRvdBaFMJs2/4sXiCh9g0UJ0CCRS0fOVgfXgHAzkWdltpInTSrN4AaPs24BVgUXG0+HMSkHoWeHLT8mM5e6j+Sp0NVyzl48o24M213G2iLSUGJp7Ev8X1ZyvyMkwr4Kcr+8bFQ3tb+U+QbSkxZBVjU5IHzu+YYQzegBiYy1Ii/FjGAdOHGVbMoLKYx5IoEP8zEwAAT7ePA4ws2FawIRxBisvAgYNAl2yjZSG4OMBjrbmwsFbScUzFe4NpmOBOFpbQmJ57H/BrbP5+DSF00mQYoMd07nkzFl0LI/JxebN1FBIAcC4rmT32QEWxPWOQF1dcL+a2lFQZdFTg5futSqRA9n1uajFfhpJOJNzftKD/GfseYML/TNShDnhtsLLJGDME6Lsos4w+tprcwHpJhFFUGaXE4paSWs2BN38GPAOAUX+IPNgSwkmA1kMt0K8O3KsDw7dC+I1OQLtRfwDNBQThiV1ryFo4lSkldbsAH54zro+sO8Ci2sDesiUThColr31T1t4BJx5LoMt9w5e+X5gFrH+du02MUiKRgPObFjB5smNKrOZptptrQ4QcLEsJozBdKbHnmjBVlaqjlEit8FNvOwyYlgg06i5AIAvLU5IHtBsJhFvJPD9mHxDST//9xZ+1uGCxgNVTm7wCjNgK9PxSfzs3HwsuXGgCnOBnnv/3+yeBWY+AN34A6j7P30d5VsiVbaq/VwXEesxMA557t+yDvUw8tkZH9o0uhVZz1WAxaf4acVWK4gI8OXcUylJ9Rej4LSW5t+KRc/O68KFFTbKOd20wHKXE9AwxKewsy4yoOkqJXWMJBeXyZpWps8GLpvXTrK+wduVmcH1P8uyvWfhUuAzdPwcav6J7v5uPdRZfFAt7ctLMzuq7VKVIObmoXFg1dCw+yF7VNv8J8M9n2m36LgX6fFXx2Ym10qqfZTImHA5dlpI/Jwk7viRf+FgSrvvm8ZoJ8PvnTaT/+KG+g9Tv3CXZyPiqH57GnoTXb2Hw3vIC5PkClHix2IulRIQcDCsLyjyWElOUEjs5f5UMCnS1FZwfoolr3/jUA7JTTRaJF2eBS4mXm8EttaKsRw3d+9x8gHZvA0HtgTOr+Ot72AJ2vIKm/OxqoYCwG/OqTvzb248EXL1UtXkkUm4V15pNhMla6dFhKRFaUE+MpYRhwP5N++epCr4FP9sJ4Bf+QzSsKwElJ8H81V/dTfHTx3CqZkLNG51yWp+sy2dQcP04gkZMg0QmzvXKsZTIyX1TGakylhKruG80yHlSiJQrjwxHuXOC4kTcKBq/rPo7bDMwfJtGn2b61wrNKlKbwS10o9MXPNwpQnUO/UOBJ8mWGV8sge2A2qG692t9HwHnTZd1SeZSNmYb/qysCFOqoFYSxJSZ56O0zFJSUPY/yEkD7pzib/vsrsGHi5JszQBL7d+rRFJxTTyL2ixQUBG/P0s9QBig+p99EXzrK6TvLV84UUxMSYUSqZSbvvClae4bspRYgiqjlNiCzV+ewYE1V5ES91h7pzlMNyN3A58lA0HtgBCNwDx3PZYFMRQKjE5XZ4fo+aGa8hvWF8zadnjFezcfEwYxI2P+0r/ujOb3MSWTwFD2Ud0uxvetj4mnLdOvJWCUMOkCjFoAnPsJWNYQOLMa+L92wIbXgZQT2m03DdA74d//dRZcvm+A9L/WVWw0cD8IvvOtMDk1fn+5t28gbdcqKEr40mdtO6kyaUbUCFFWyMzIDS8Umbbj//B0fmcU3OfPlDHNfUNYgiqjlFi8oqseHiQZmtiNdN9IZUC1mhWfu07hbzd4Hf92IQS0EdaufFJt1ENVH6VZX6DFGxqNWDfBus+Jk0OfpYR9zl5fVmFBsiXl1gtdaH4fsXVuOH1Z+Wfs4gmETQJ86lh3XFPI+M90y8A/n6v+HpwBKMom+Rs6Asn5qvGWUef+SgCAX2zF8g6Mkbfiwsx0PD59mOXW4CoaHhtfQND1L/F06ava1hkz6ST8Co8YjIwpKTX8mwlKmIMaTBKebZvOu98U9429RQRUFiq1UsJ2m9hdoVFL1Cl5eQ6rf9YTQKtBxvdZT6DyUH6CXTyAj68CI7arUqRf1/GEV11HYKeh/g1RvQHwzh7AuZq4/s2NoVo1mvvtba0ZfXx6A+izGHD1VqVsN+mtiucpZ5SJ6zIB3FW3zcFfk4FcY0vU66GAZwVpALjwq8iOjLsHSH7shJqHBiMzag/vfplEdV3VUsTh2UqN+4CZYkoUBfxBwAXp9w0oLOLHZxh2TIlhS0k5UgV/TFD5+SHsB3ubqs1K7lMRpaEtiMGfnrmUEhlrolPqeQLozv/UwIszT8VLAOi/ouJ9cCegJivLQypTfScXD6DLhIrt7JLeomuLiDxHppzTKf8Bb/5k/PEA/1pIPvUq3tdqzt1nTMVXW1Ee1CyRqFK2R+3m1vto0kv7mHYjxY1RvrCmOXlyy/x96nK7aaYUG0LE9aqUy5G24//wLD4ObhJVVo78+oGyvbrvNrXlsZzPjJmCPJ2+b4yHh7mK6LNrsfD4qSWylwjI/hMTBsNKA2bMEFNC2B+VWin5fWnFj9CW7purx+6DYRiUFrOXR7ewPJpZBf9bBXgFAp8mAs+LSJ/VlX3T7m1gwlHgrV+BCVH6v8+wLUCdzsD/WOtn5Bq/bgUAlQWm8cvAkA2m9cNH9fpAm2Hm7/edParJedJFbaXMFPeNEDzNWM6fzwqkzzI0J0sVjFxOsI4sIg4W+H3IRWTQCEVo9g4vFd9RjPsmY89aBCXMge9O7XpISidv9fuCB8Iz8rKunBfcVhOpRAn/U+M42/JjNgIAajBJuo8reor0fRshZYRbPBhOTInw34yx7jHC+lTqlOCCHNbFbmMH4OqJxyBzlmLojM6oEWQF14Km/7zDO6qXITz9VSXqo+arPutyg0hkQHBH1csQLfqrXmxyRa5joqn0tHyTa4XRam/iTcgSSmPNJsDA1fz7PP3NPx6b0X8CxxarnuwTDxhurw8nnngZfUqJVMo9n/2/B356Sf8Yllba3asDBw0U5dOJBOrH+3K3m5ObuEX7tLoUfr0yDy7zbi/NzYFXXqz6XleS/RQ67JyqIVnum/zze1C9LX9A9MNDuyD66hTgjgzM/xeI/Vdcv2wlUCFcmbHM/Z+ybyxBlVEfJbbWSgAoSpVIPG/ComJiMDZG4Z09QL2wis+6LCWmlnYXUtFVH67eBhqY4f/dqKdxx9UKEX/MqwuNG0sotUPKUse3Ah9dBoI66G7LdjOVE9hWpdhM+Y//GEPBtrVbqCZeT39V6vKI7frPr1KhUjwtRWGWqqaNMTi5Vrwvd98Y8XtjjLSU8JbGB/Bk1Uh4SSriZpQlwpUkXSsGPzr+N/xPjxcuWzmM6TVEeGG5pRVX/+KNpSnNzeE50Pb3f0IYlVYpeZjCvTBvXnyIqA3xUMhtWyxH5mTglOu44YjGGLOy1Anwb8lVOPhWUQWMf5ItLzWvlZljCNZ4QzbyP61zmpvhJvTG/xl3HFupE4pnbaChgOUJTEUiAWo00h/D4uqlvc29hiqzqnp9Hf0auG6d3YEZD4CPr6k+N38NGL1Xd3snN2DAamDEDv392gJ2ZlVS2ZO+qZk9Yi5XHQ8EAcXHOZ+d9+hf7JITNKrjqb846YxgsR5sXIhn8XGqDxYK3GZn3wTlH0DtE+GcYNoHP34E5+V18ejEPxpHWkIpIUuJJai0SsnupRc5nx+l5uLG2QwknEqzkURllD+R+Oq4uetSAoTSvsxF0/0L/e1aDVb9fXlWxbbyOAr2Tc/Zw7yuhdF/qrJyXpkt7ji2khE6QFx7Y9E1ARuippGl3dlP4JbGT0+lV75UX0OWMSGWMxcPbWVy8HodMgSr2jcXuMyBNdFM917RxsTYEkDUrZhXAdS+3r0k+q2y7CPqpK1FSc4zPLvOdQ2JicULTvkWvju7oyTnGSRmWMGXD3ZMSTnsNYWCH6liWWRHNbK37K6kN6AoLMT9NVPx5NxRQe0fnz7Mo2xVPiqtUqKLwjzbRmxf+PsO5CUKwN0XmHIF+FQjEMzFxFLSb/yfqqhVt2n62w2OVAUgdvsMmHAM6PKeKs0TqHA/ePoDbr7A+Cig13zWBGLCD7yan2rhQqHl68vpVBZI1/RVYTcYj5qG2wAQ/F2a9DbcZuw/wItTgc56Yl30oSvTyRK89g13gUQ2vnV5Nho4T8Za+Fq9BUy7qap7UqezcX3oQ5+bylgKNIohis20KYOBBIxCgQf/966WlYN32LLAVZdnwhfo0yT9z8iK8TVcNkXLn4fvrh54fFJknIcGRen3LOi+0Vb++MvNayov9qeUpP+2AHUeRsLvH203Zcb+TXiw8gN1tpGisBA1Dw1GrajhKHkmYt0wB6TKKSXGlJu/+M8dbPryNPKfVZgJcx4X4o9vY3E77pHo/k7svImbFx6qamp4aVgh3HxRmFtiuDS9LqQylQtGyMRdHgcQ3EFVdKw8ZdelGjDtlkq5cXJRTVIvfqzy8Q/fBnzMH1dw4e8UJJw2MatGF7VbANPvCjfnD92kqp3xvL5F0ICDXqz+3GuoLDl81GxmeMz6LwC95hp2LenC1cxrm+jDsxYw8aQOOXjcN4auJ1MKqXnWVinEllg80MnN/H2agLyQW9Pj4b9bEZwl7JoueaaqiVJLfklrn1O+sEybwMtTkRm9DwAg0Zi4vSWq327xRQErUetBUVQAaSlfXIc50L4v8q8WbEQNFKUS6X9GIifxmhFyicf50RWd+wIuTkbwky3I+Ftl+VEUV2SOFWfxVAivRFQ5pUQqleBJWh6uHX8AJY8pkI9zf95G7pMiXPg7Rb3t2G83kH4rG/+sFV8qOf5kGg5FXkf6rWcVG7t9DgR3wgPP/lj32UkcijT+acgseNbiVosFVBNTyOuAr3YgZFZGPs7vS8HRTQnGK1SGcPcVXr3UPxR4Nxpoqt/Ccesmq55Ir7mquAk246NUik0PA+4wcxQM6zETqFYLeOlT0/syBWOsda/MVrnVRmw3YWAd1837J4FRfxjXpZ2Z7Z2WBrE+SaDIyRR+sJ44Df/Sc4K7Kb0bp3qj63fKiTURjyI/B84l/A9ruoq8VQytPzaHbz+fUqIZuMvouQ6Ucjnu/zwdaf83HoGXp8J7W1e9MlSMIaiZTqQKwytPK5/xuOBstGaRtahySgkkwPYF5xGzNRFJ57T/4c8yC3QGwyoVFVdhYa6IdDQdnNvHWpb+5S+BCVGIjVLdpG5dFHGzsgPY56a4wEKmW1Opz1/IqcCjrJBZM574hTqdgL5fAW7eqsyTV+Zot6nZnL9gmFh8glWuDPYYXoGm9ysW3swmA5O7e3WVdar5a8aPq2uSDGgNNHlF5XISi6mxDbpiv8yGcKWJKTX9nsMeU1dwK1sVkRiRWl/z0GC4KPhdDLVPhOs9Nvt6rN79BdditLbJC3IBQMOtwb2H68u+fPhXJOqkrUVwthkeLEQgVQovz89Rxgwobo5OlVNKpCz3zaN7uZx9qdefYMucs9i3UrdZrRx91wXDMNj3Q5zBPh4kPrObqrOmIpVVnNeifGFxO0/T87F51mkknLZS8PFY7jolp3JU2QnxLbcAX6QCXgYKjFWvz6+4iKmXYIjyJ7q3d6oK3g3dZL6+DeEZoCrvzudGsorFwcCjZ7AR8SHs2iGth+peF0nXWky1mgOTYoH3eBbeMxVGIiqQtDT7MR4u7mP6uOWKho44IF3pwWJgB9k+WDEeBRkPBB2n5HXFqHgY9QeCby7W2p6zW1VT6dmqITqPZfQoJYrHt7W2PVz8KtK+GYqiR3qWJjDVVCICTiVbhfbkk77nFzyNO2s1eSxJlVNKHt+vqI8hk3G//pWj9wEADxL5F9DjXIJ6frgFOSVIjRcWjJT7xAJVJm0A21KilAv7sR7dlICcx0U4uumGpcRSxdfo4KlcFdCpVMqEry4s48mQsUSmQbM+qmJ3PnxBpyyMraXCxyfXgZemmh5sbSxd3lX91WV1Yme91Gohvv9Bv6jq8PAtMqkvyLhmE+4SCWbCTZoD10QRKc+nV8K/1AwTT5kipCtDxj3nCjKj90FRWKh3YUGhBD/bhZz17+LBOsPrGUmddWegyf/bx7s9KPcvPI09gdryioxL7YX2xCnV/qXnEJR/ENm/6E+rthZKRcX/itHI9Hp0/G8EXpmGGnvNoLDaAVVOKUk8W6HBS524F2ppsYHJhaWICI1HMURxYeVYEIp9PhQ8mjwfJYVWcPN41gY+ilMF7mpQXrBK1P+Sb00bUyp5GsJbv/smP6cEqfE6FoUTg0fNirWTeANurWApqdNJ9X96eyf/fnba8VgDVWllLqr/+8tlqefsZQOa8dy8X1vG3095LJFvXSCkP38bE/BjEgS3dS41U4BjmVKiObmVUx23UTt6FGRLAxCctsYsQ3oVJSA4dYXBdoX7F+iMK5HoSbuusU/zf6PxmzbS0lerWHisjkXhrPnDvW+W3NVR0NBBqXJKCZtrx7kmxaJ8Q0oJ662eiUxRKtznZ5WJ2Qqwz4dQS4lCYSXzZ42GqsBdAGj8CmtH2c1ZjFLC52MvfGa0aKby5EEe9v2gcjeWliiQeTfHyEBj1jEWWGH52JYb+GftVcOyedbSXfOEfe5lztr1QgBg7L9Ai/+pqtbWaKgKdJ58SeUKK6frx9rH1WoGdGZVLv3sNjAznbuMwls/65fdwlSHtpvBGGT3TiLn5nXUSbfe95FC2MNXYOFRPIreh8KHaSpLDRsTAjwZacXDhObigX4Pthrbq9HyABClKLEVteK/NJZHMLW6tp1RpZWSYg0lJOexfldKIStWQt+9Vckz2XYdzF+sStN9w75Mky85TrAr+zsLtZQobVFdl+UaKPczi4obY1sRPPxUfwNamUEwPWimtQ7QXj+nPI5p15KLSOQJ4DZITdaqxS48SokJKb+MkkH8iTTcjnuEp2mGMw50wo6BkDprT1LNXwfqh6nK6bPl9WvMTdPWlXpdUlDxvpqfdiFDPtedAxJQfALF2/WnypsbiUClBABqHx8N9zUtkP+1xsKNIpQSCZRci4u04v8vOb+W09Zdojt9WSox3z2qJOcZ0navxqOFPZDx9xbOvry7+lewZliuNv+SM3hysaKujTHByPZM5fo2JsKnTLC5e/WJ2tSv11LCM9nqCmg791cKTu66iavR95GfXcyJRTn9hwWWWrcQSo6lRNgPmW0puXfDSgWBWO4XxhhLiXt11crEw7YA44+onq51VSU1F+MOVrwP7gS0H6nVRKlgkH4rGwBwLUZYUCEAVdp0m2GqeIty2AG/I3YArYeossP0IC9V6LQQspXU0hIT3JXlSiCg+j+yV4j2DhZnyei9oOJ9edG2YgO1NWR6Fh3kQeEmtICf9fGQC19BWB8ZLvwZbZq4SXJ17itl+JU9b8l9KAoLoSgpxtO4s3rdN1owDKfSK/t3r5SKVy7Tdv6AB5uXcLZp1nkxRPb/vYmgazNQS3EZARc+4Owr3qD9m2bDKDRcNukV5SmYSqaUVKpVgnMeF+Lkrpuo38rPcOMy4o6kol2vesh9WqQ1OZUUyZHzmBsvUFokh6uHs05LSVF+KfZ+r1mqWb8MV6LuAQCOb+dWd5XKbHuxMQwDhVwJJ2fD5kG2Qpd5Nxd1QmoYPoalvPy1Ig59322Fxh1qc9soGU7GlCESz2UgP7sYHV7VkcrJKuUuZ9zUY4iCvVBcv+V6mxbll6K0WAGvGtpFvLIy8nE1+gE69KkPz+p6bpRB7SreK8oCD/2aAk9u4mZRN9Vm1rkUtb5TUHvtybxaTWDYbyr3SLM+Bku9KxRKbJh+ClKZBGOXvqhVoJDtzhPq2uOlmp9KGXRyU5msW7wBfHFPVexNbMxA2GSVIpN6FnhhsmqbIaVEJA/7HUXQ7zxBtXZANYkZ4pAABMz8G5gnMEich2KmGkreOQLn3/jXiyr4uh28JBkwfDfhIkUpFIUFUN+5WK4+pbM3ICJ+tzQ/F0HxqtikZ9f7wrdl+7Ix+JWkzKN/ovTeVQS9MxOSsrpKJc+eopaCW/SOnRHkq7ypVwbNWiw1L34GvKEKwvVIrLC6MEqlekxHpVIpJbu+voiivFKkXBEeEHZq9y0knE7XMitf+DsFyZce4ckD7mq2xYVlSomOiSz237so0ihl/9bnHZGdKT7Lhp1mawuOb0vCjbPpGPZlF/j66y+BzrCUkjN7ktGhj+H6DpqWqfiTaWqlpKRQjsf3c7FnuUrB69i3Pp4f2Fi/DAyDI+vjAQCN2tbil5mVZVGidNeSvZxHqblIOp+BTq83gKsHT3CrQHZ+dQG5T4owZklXLcVj99JY9fd8a1pHHT2U0fdr4OgioH/ZIoETopB9/QJulBk42IqIIYufIEQsmFiQXaKuTXP9xAMkXXiIAXVehOz+SaDVYOMVJl65NAIa3QytFq0DqRRoPVj1KqdIgFLS/Qsg5mvVcgInv6vY3nqIagmE2zFA3G8AAKWLN5KLnkdjN+ulama4vgSlkxeC8g0EAtsJ2c4hqN0kVOd+Q+v36MIVOZAXFaJcFZFl34SytARSZxcwXnUAEYuUP9w4G+XOwKK7CYBaKeGPB6x9fDQAIPN4W9TuofodPT66G0G8rVHWl4GicRqWEmdJMRTFRchd8jyqo8JqoiwuxtMLR+HdJgyuvmJVOfvAsVUqDTSVAaHw+bnP70vRUkgAIHpLIv74NlbnzbUgW1sF9/R1Q9NOtXla68fWSsm14w8gL1Hi5kU9ufplsK0NNesKSynVjD1hP2H/+ukJtUICqJQ9Q7CLtumc/GpX3ADlZWZjPkvJzq8uIO7IPZzZk2xwXH3kPlFZ2lKuaFe4LA9yTr+VjT9XXMazhwVabdQ8P1FVS6VOmfLi5gN5wPMo/wmzLRBsN0p+djFuxWYKjvMxhtLiiqe4mG1JSL+VjdNOc4G3fgHe+D8oWLLJRQSBW53n3lf9LatFwzAMHt/Pg5J97nrOUAXBahbRG/Qr0GYoJ+iQYRgkFXYTJUI+I9zKy4eienP4vr3UpD6sirlWRdfARVKI7M1T1Z8Dik8ifWXZmlQis+XcH7FWSmaZyNlpx3wZQ/LYiiwyxkAwvERHzZMayarsJ77aJJkHt8KXpZAAwKPjf6HW0bch+745SnMtVerfslQapST7kZ4buhm5F/8U6beydVYt5XPruLjLIJVJ0ap7sKixZE4V/x6GYZBwOp1XUbI0QpQj9sQe3NRwTQdFqVLLlH/32hPcu/EUSoVSVJzH3etPsPf7S8i8w/oR6hKZtYZNgdIXgP6YEnZdGwC4f+MpHt/X7R9nw57MnmXqvz7v38jC0U0G0kM1ouw5adhsa0TZuOf+uo0N00/h4C/XcPXYfUEyi6GkSI5Tu29i23zttMn/zuZBHjIIcPXkyCY3JabE0rQdDnxwFhi6GQBw+VAqdiw6j6ObNeroVPNTuYtmZaqsI+zMns4Rqoq4r8wFlIBCpDGaMfGW7Dfoc3gEay8DoY80L+FWMXOjlPJkUJmJwHzuwoLBOXtVb0QqJX5Mxf+fKa2weLODYNNWfYC0nSuRtqviWgjK/auik2K+AG/D91V3SY5q5Wa+hQhLtL+H4oHKUuwkKUH2VTtJZxZJpVFKfpvNbyIdMfc5q1oc+FIeXdxUN6bO/RqiemA1NOlUG69G6C7qVY6zq2oSynlSiMRzGTi6KQHbF57ntCkuKMXFA9pWnYKcEtzXUQROCOwnayFVJ+Wsp2XNwEbNkvxJFzLw8xTtctGAKrYkrizGRij7V17Bg8Rn2P9jRb6+ztgFmZNqZeZP4qEoM+4qlQyK8kuReVf7yYL93XMeF+LPFXHYseiCQZluxz3CnasVfnt5CfdJJ2pjvNYxBQKXLki+nIkjG+I5FororYnq9+Xf/eKBO+pt/x01v1Jy9s/biDui+3919k9VCitbOTOklDy6l4ufpsTg92UXIS+1sgIjkagWfizL1Ck/f+zaRhycXIGRu1RF7soJbKtaOPKlqWAYBkpGnOsvt+1nAIDHUlVGV6ZzF73t2QrFg3ofw62WaoHPZ4Oi8NBZR5VaDRgX42NCAOB+gJGrYgNgyoJO00LmQ864IN1DwGrcJvD49GFIFMbXFWKK8nB/7TTkz+W6koOfbkNQ/CwEXecGhCuKVWMxIqo+a1pd5DlPwfAoJXxZN0yp6uEnG3VR8wXLnktLUWmUEl3UCKwGv2Btd0Lnfg3MNsaVqHv4Z+1VKBRKvfEHHt4ueHvuc+gzvhWcXA2bLR/fz8P9xCxs/vIMojbwP0Wf2HkT5/5K0QqS3TLnDP78/jLuXquYGEuK5Lh4IAUZKdkGx1aUiDOzlxRVWI6yH6meJoryS/HzRzFY99lJFORU/CgPR8brDS4984dxLhNGaAE3L3/VOjNlKBUMfpt9BruWXMTfq/9DYV6FrOzfffn3MkTu0yL8s/YqZ7HGzLs5iDuSirysIhQXlOLGGe2Jrlx5NcS/P11D4tkM/Lmiwr11j5W1VZBTomWZCWhseOJhGAaXD6XivoBMKEbJ4OFt/dfRrTK3X/zJimUENJUzTXYuvgB5sQIZt3OQfEncCtxxR1IRf0o1VubdHGxfdB73EozP6jI6Mqcs0JBhgBJGfyyWJoFvvYf8cZfhN+sECt67jpqf/410dx2l8QEwLqwVnaUV149v607w//IQij5M4jmKi3e/yaJkLOeJJAQAUOf9b5HReTXSvAcg06mzuE7K3DdBwz+G5Mv7kLYfYZQsQql5aDBgglISdGMu6mT8gmoSYXGLGT9/goL7d3kr4zIarquMA6p6KZlHeNbg0Qh0LWXceIO7JcUqK26Be3OtfY5CpVdKAO0aIT1HhaDLG43Q850Qs/R/ctdN3I57hKMbE7RiSnTFkjg5GT71RXml+FMjkwcADkVex+24Rziz5xbul910024+47QpKVJdxHevVvx4/jt6H+f+SsGBNdorG8f+ewd/fBurnkDYvv8ze5LVT7vyEgX2fn8Zsf/e4Y7Hqkx7L/4p7l57gsuHK9IONeWzNEq5EnlZRbgVm2kwu4ZRMmp33J3/HuPkropIeI6ViPVWXxEwvvWMHt/Lw6ndt/DHN5fwIOkZ73HOAhRVNvoyWbbM4VoOXdwNKzx3rj7B6T9u4c8VcQBUbrGTu25qKXix/97Br5+ewJMH+muOyOVKFOSUcKwpYlKCxRSBy88uxqndt3Bs8w0o5Ers++EKntzPw1//Fye4Dx4BjD8WKvnLg6nZpIUuxMOwX/DQ5QXO9ozOqvoz1eo1gkQqhUdgHUidXVDro9/wuPcu/kHY5cd5Jj6X6hUxKo977UAeo30/8moUgpKpd5Hp1ElrH5tMp87IZQJQ8H48ij5Mgu+MiloZAf1GImjqJshda+ntQ5OA/MPq9zIXV/h27C7qeGMIyj9ouJGZCH6yFR6/toFzlvZSGnIXbsp4wPmJKLh/F/6nx3O2F107gup/cRe6dJYU8RZyDH66DQDAOHBNnSqhlAQ3q46Ib1/CxNU98f6PPRD6oioOOrSrvnho8TxKzdXK/HlxaDPetmyXkquHOL/zzQsP8c/aq7h0MBX52frNgvcTs9RuiQdJKndOYQ73mMy7OTi79zbSb2Xj2G+qm7qmmb28fsqtS5l4kJiFs3u51SWTL3MLvV0+dJfr0jE164LHg8QwjM5YDYWcwZZ553Dwl2ucJ3U+CjTOR3JsxRN6uTLFMAxOsKxReuvU6LEG5D4twqFfr/Puc3GTITX+CY5uTuC4ZsyBokSB4oJSXIm6h7ws/ifFZxncc7l/5RVcibqHhJNpyMsqVi+0eHbvbZQUyg3+TxWlSq1zW5hbKjgFO/X6U5z76zZuXzZsMWFnHBXklHAWhTywxvJluONPpWH7wnPIYRdDZIBsRQBy5LVRxFRYNDxahMG/z1D4z/xHve2B/zgE9OOvVeHkXg01u77KPzBLaZa4aVuEpU5OyB11Bs+GxqDmi33hOf8mCidWWF0f+Kqyj1y8feE5bj1ymGA8krVHZreNUDIV08ODGsNRa+YheM1PhEdAMNxq+UPmoj3xeQ9dqH6f1vIrlH6q3xWrGeDpWsN6tV0y3HpYbSz/klNa2wILo7S2FWdq1xiq80C7WCIAKIv0xLZZMFbH0lQapaTbcP7Jvxw3T2dIpRKtRfjMSRbrph7QyBvvrewOD2/+i0PKspT0GW/eiqCPUisu1qyMAuxachE5jwt1TnSalW2LC+RaWRLRW1QxC6d2VRR0e5qWj0epuSgtUeBhCjce40HSM/zHCq5UyJWI/fcONkw/adyXYrirDx/dnIBNX57GMc0gxDKK8kvVSlHCKf1KSY5GVV0+hSP7USHn/6tZIr+0WIH8MiuZIWuArsnc2c0J+364goRT6bjwdwpvG2ORlypxKPI6Tu66iY0zTvO20WWZeJSai40zTiFy2gmDVY85Y5YocTWaG8sSdzgVf5fF/hTmlaAor1Rn1tHNCw9x8cAd/POTtmVPE3bcimYMU8qVxxwluyi/VJgVRoSh5NjmG3jyIB97vq2oRcEwDJRwxkG39ZB8wop3YgUoPnzhV6R7vAq/oTMNjpFW7XUoGA1rGqvKaa3/vc97nFeTUPiGtlN/dqvpr37v3OZ/6vceQfXgPT8etWZHo/bLAyGdn4XHsjbIZ2qi+tA5gupfeNZvAszLhnx6GoKGfAhnL288aDSd+z1CF+o4umx/s9nIZfSv2J3ZbSPSWi7G04EHkdG5Irg0rdrrBmUshwmxXYCvLjQtIvoITpyvcx/DtwSDg1Bp6pS07lEH929k4XacOD/0a++3RsLpdAQ08sbZvbcR0MgHoS8G4uimG/Cs7oq8LNVEU7+VHyc+wxCDPtdvCmVbSjx8zXMBrZ54FD61PXhv8jFbE3WW+JY5c80Qsf/e0XIx5D9TnQe2YrBtgfDobl3KgxgiPz0Bn9ru8G/gjaTzqniFvKf8VZDY1ojMu/qzZTT74HuSv3uV+78vfzIvn9z2LL+Ex/dy8c7iF4xez+jmhYrUa0Myi+VWLNeSlXk3Bw9TctCyW7C6OJ0uC0ZW+fXEAJtnneFtows+K1Xq9SeIP5XGuSZejWiJpp39tdqWwzCM2pVWWqzAwzs5CGrig8K8Uty88BD+DStiZvgy4xRyJZxcZEi9/gT7Vl5Bu9710HUQ161bUiiHzFmqznpjK+bs8fVRfr8o7w8ApC5ucPH2rehLXvEb8n91CPDqEIP9AkDg1N9Qmp+LJxeOwe94BB62nAdkVFzn7DH0IZHJ8CBoIlD4FEE99E/Mfl/GQFlcDJm7thtKH07uFUsVBI+eCcyrSFN2a9YFKIvzTm+9FJpLTga9PQ3ANKT/tQ6Blz7R6jt39HnUblQRM/GU5cKSNO6BTJ+hqH0iXL0tve23CLwyjdNHmvebCOgfDsR9Kup7OQwO7L6pNEoJAPR9rxWOb08SVWa7UbtaaNRO5Qft0Kc+JBIJGCWDar6uqF3PG/t/vIKHKTl4cUhTOLvJcOtixc099KUgxJ/Qvuk2bGvYBMmuUuomsDiXVw033niFchgGOp862eXrVW0ZJF96BKVCCU+NaqO6MjX2rbwiSE5jaNbFX61o6CM7s9CoQnQZt7MR0Khi4hK7aB07zgRQxayUFMmx8YtT6vgdAPjz+8uiU7/5MHJRU8HsWnJRPU6r7nWQcTubE8jLyXyxwLqJmkrqocjryEzVrYiVlBUtBICDv17D3atP8PzARkg6/xBP0/I5hfL4ApLlpUrIShTqazjucCpHKSkplOOXT1QxEh+s6amlgMhLlKJifvKyinGkLDhdIpFAIpXifvAHkD1NQkAn4+ImJDIZXLx9UfuVN6Hs1g9Bzi54sNK4NWyC3/1a2JhSqWiFxBBSp4r7nc/zui0bgf8bB3nvYXBaqnKzp3u8Cvf+X8K3ETeI06d1Z2BfWd+eNVD7lTeRVSMA+Rf2QlazEQIGRAAaSknQ1A0AgIzOqxBwYRJnX+HEBBQ9uMOxWtyvPRZ1Mi28nIQ5cTbv/8yaVCqlRCKRoGadCr9qa5GTQ/mNSCKVoF6oKkDsjY/aobigFN5+7nh1XEvkPS1Cxu0c1G/thx5vN8fDlBwUZBejMLfi6UfMKsGAdoCjd003dHmjEY6sj8dz/2uEBm38ULOOF5RKBms+OCaqb10c35aktUqyIVKvm6c0tSavjm+JRu1roeeoEPz0EX+qsKn8viwW1QM88PrENnBxd8K1GOEpshtnaPuD40+lIf1WNkchAVQT4qndpq9ZdP9GFrIfFcCnlgfkJQrInKVqhVkMPd8J0WuluvD3HTxKzUX8qXTOdralJj3ZcLaWOYhjBUZrknbzGRhG5TIst1qx45rYyngMKz26HEWpEpdPavdfUiTH7q8vclxz10+koVU37r2jpFAuSilJPMc6n2X6TZ0JS/gbG4HUucy66ogrxLICNGXu+rOTnNyrQclIIZUo4ffez3Dx0a6BJHNxxaOeW1By8wyCeg0CAFRvH4bq7StK12ehCapD9bvMHXUG5RE+/q+NRHpRPiRuXnC9sBwF3q0R7B8Ed/8ggFVmJGDsYmBphVLCzMlC2k+fAkXZ8MiOQ3UIyxh86Pwc/EuFW5gfydqjlqIi2SHD5UUElAhwgZNSYj80al8LJ3bchIu7DC8ObWpyf67uTnAty1yQSCV4/YM2uHUxE007+0MikWDQZx2hkCtxZm+y2mpiqFCWJlKniqeypp1qo+foFnB2kaH5c1y/qlQqwRuT25rFYiFWIRFKyAuBuHE63XBDFk07lZntZUDE8pcgc5JCKpNg7aRos8qWlVGALXPFl/xmm+TL0Qz01UXoi0EGA211wa6949/QG51eb4Dz+4THmny49mXc+U9/6mJBTomWQgKAExthD/BljImhKL+UN1voUOR1jkICqJQaTcXmdtwjhL4UhNTrT1EnpDoKsovx7GEh6rWsoWVVybidzSl8aEkYqQPewlkr3rLdPLqQT70NRVEh3HkUknJqde8PdO+vc7/ru3vwIGoLar7xHrxY5dclUikCB5XF4vQbCV0jaMopkUoRPPF7zrb81Nuotq69+vOzQVHw/f0V7ndp0BuKIfsg+0qVBZXh1gPOL0+F34H/gY+aXx5FxoHfEHBRlbYdMPNvPNiwEMF3vtX5XQEALqSU2A3uni6I+O4lODlJtRYGM1f/rXtULIvu7CqDs6sM3Yc3Uyslfd9rLapP9sJ7Lu5OcHbR/fRTr6UfPlyrqlvw4/tH9fY7fHYXRG1M4AS+WpJ+H7aBu6eLYKWkz4RW8PDhxtO4Vasw7b4xuS2uxjyAX1A1vWXmW3UPxs2LD7UCdm3N8NldUCOoGpo/F4DoLTe0Jr/Axj5gGAYZtw2Xg36YkqMOENXE2VVWEcQsUWWbdXxNtfZQYBPTCmNVFsrdVWziT6VpxQrp4vj2JHUtoDYv18HDFFVMTqfXG6BFV25UxO/LYjmfM+9Y7vfn1XMMsD0Sj6UtYb9rEgPZqAcfpELByOBSvSItWepqOPbBxac6oEchEYJHUD14vDPDpD7KuR/4LurwbK9WrxFyRpxCyY53oXj+E/i37oTHubvhc3AknCWqBxv3kDDIXFxRODEBT4/8hpqvjYNrjZpIOzkAQTl/4kGTmWAKn6H2/fUoGXcSnlIpAvqPxtPARpBV84IPgMCR05H2Q5K6Ymxam29Qs9dQ5N+KV7ucPFrrrm1j70gYsc51AKtXr8Y333yD9PR0tGzZEitWrMBLL70k6NicnBz4+PggOzsb3t5GLqZVCXiWWaCuJfHh2pfVCkbr7sHoNkJY4Zvcp0V4lJqLhm1r4n5iFp5lFKhvnMHNfDFwagcAqkqk5QGKLu5OcHaVqQNXDdFnQisc/OWa1vYX3mqC03+ozKG1G3hj0OcdIZVKwDAMzu9LgVQmgbOrDOm3slGQU4JHqbkY8El7/PGN6oZdN7QG/vdRO0EyAMC5fbdx8e876s/uXs4ozC2Fd003jJz/PKQyKYoL5WCUDC4euKNeedkY6rfyQ2FeKbdsvUiGzerCcSUCQMLpNBzdpHKlTPyxB0cZvXnxoc5UYUN8sLonIFHFTUgAOGkotcUFpTiw5qpZasV4+bmhYZuaqFXPC04uMiRfysSt2Ex4+bmp1/nhu2ZeGNQEp38X7taq26I67iUYX5HYnpA6STBxVU+L9V/4MA2uNWpWuHTskJyb15H/+yy4vfoZqnd4Aen7NkLm4Y3ar7xp+GAbkfZdOIJy9iDDrQcCvvgTRY8eouTZY3g3NVyNmw2jVCLvThKK7t1SWXR4UJaWIOfGFfi07GjSKr95d2+hOCMVfs9ZRimxxvwtWinZsWMH3nnnHaxevRpdu3bFTz/9hF9//RXx8fGoV8/wmguklFRwft9tuHk6o03PujiyIR73Ep5iyBed9S9jb4DH9/Nw5UgqOvdvCO+aFSY8hmGgVDLqlOjysvUdX2uAC/tVLoFO/RqgU98GKCooxYkdSXCt5qyOm4k7cg/tetXF+X23USekhqBVgNko5ErInKR4mp6Pmxceol3vemq3mBDYgYhvftoeQU2rq/vk4+GdHByKvI6Q5wP0ujwatq2pri3j5umMzv0aoE3PugBUbpvyeJKOfevrtdZ41nDFS0Oa4dTvNzHo8046U8GVCiVHGSmHUTK4+M8dnN+XgtY96mil0uqj3HKmD4ZhkPO4CJ41XPEsowAu7k449Ot1ZGhUZXX1cEKLFwK1ysdX83FBv0ltUc3Hlfe7PU3Px64lF9D2lbp4fkBjjhWvXL705Gw4u0pRs44XMu/moDC3FAq5Ev/+fA1u1ZxQmFeqDqr9cO3LKCmS485/jxF/Kh0PjFwyQeYsFR3jxSaoqa/JytyohWHwqeW45vSqirwwH09OHECNsD5w9qrac1U5dqmUPPfcc+jQoQPWrFmj3taiRQsMHDgQS5YYDuQipUQ3SiXDycohzEP8qTR4eLugVl0vHFjznzqIs1y5KS4oRWFeKXxr8wfdlf9flAoligvl+GfNVUikEvg39MbV6PvoPa4lGratKShl1BDlilbOk0KUFilQPbAaIqce5wTU1glRmbLv38hCj5HN0fIl47N9rsXcR8y2JISEBaB97/pwcpHC1cMJW+edQ0FOCVp3D0bC2QwMnt4RfkH6V39WKJRqpXf/qiu4e+0Jmnb2F7TOE6BS2K5E3UedFtVRq64XZx/DMCgpUuDXqcfh7eeGF4c2w+24RxxXYeueddCwdU0c/PUaZM5S9B4bihpBnji/PwU163jCw9sFTi5SVPNx5awh5VbNGSMXPI/IT0+ot3XsWx9FBXK88GZj5GUVQyqT4MbZdMT+Y3i16nKCmvpi4CftLeJGJghbYHdKSUlJCTw8PLBr1y68+WaF2W3KlCmIi4tDTIzhzAlLfamN2zeimJX/TxB8MAyQ+0QGSAGv6gqTU28ZxvLpuwCgYICSfCncqikhkQBKBpAXS+HsqrTId1AwqqQRqcS476hggOIcGdy8FTDnnMyWq/xzud1JtIxKCcAAUimjPqd5WTJ4eCnh5Mx/W1QoJch7IoVndSXkcgmepjrBN0gOqRPg5MxAIZegIEsCV0/ArZrp1xdBGMug1wbCz8+8kUbWUEpEBbo+fvwYCoUC/v7cIkf+/v7IyOBfSbO4uBjFxRXxCzk5xvvp9TE3oRZQbIGCCkTlxbikGIIA2CV17vDsF7ZeG0FYDO9qhzH8TcsucGgJjMq+0TRT66t2uGTJEsyfr7scrrmQSBkoK03RfIIgCIKoeohSSmrWrAmZTKZlFcnMzNSynpQzY8YMTJ06Vf05JycHdevWNUJU/aTM7Wf2PgmCIAiCsB6ibAsuLi7o2LEjDh8+zNl++PBhvPDCC7zHuLq6wtvbm/MiCIIgCILQRLT7ZurUqXjnnXfQqVMnhIWF4eeff0Zqairef59/hUqCIAiCIAghiFZKhg0bhidPnmDBggVIT09Hq1atcODAAdSvL65uBUEQBEEQBBujKrqaAtUpIQiCIAjHwxrzN+WrEARBEARhF5BSQhAEQRCEXUBKCUEQBEEQdgEpJQRBEARB2AWklBAEQRAEYReQUkIQBEEQhF1ASglBEARBEHYBKSUEQRAEQdgFpJQQBEEQBGEXkFJCEARBEIRdIHrtG1Mpr2qfk5Nj7aEJgiAIgjCS8nnbkqvTWF0pyc3NBQDUrVvX2kMTBEEQBGEiubm58PHxsUjfVl+QT6lUIi0tDV5eXpBIJGbrNycnB3Xr1sW9e/dooT8LQufZ8tA5tg50nq0DnWfLY61zzDAMcnNzERQUBKnUMtEfVreUSKVS1KlTx2L9e3t704VvBeg8Wx46x9aBzrN1oPNseaxxji1lISmHAl0JgiAIgrALSCkhCIIgCMIuqDRKiaurK+bOnQtXV1dbi1KpofNseegcWwc6z9aBzrPlqUzn2OqBrgRBEARBEHxUGksJQRAEQRCODSklBEEQBEHYBaSUEARBEARhF4hWSpYsWYLOnTvDy8vr/9u795imr/cP4O/KKJQWUa4FlcsGeANRMSodDiGAqIA6p24YAYNbUHGCtzk0g7mItxUdY05NEDVDQTMUMhWH46LoUIYQ8BJv0zEURFTUolIo5/uHv/Zn5dYCLXV5Xgn/tIfPec47H3qelrYfWFpaYubMmbh+/brSGMYY4uPjYWNjAx6Ph8mTJ+PKlStKY5qamrBs2TKYm5uDz+cjODgY1dXVivsLCgrA4XDa/SkpKemwvlevXiE8PByurq547733MHPmzDZjMjMz4efnBwsLC/Tv3x8eHh44deqUSuvfuXMnHBwcYGhoCHd3d5w9e1bp/vj4eAwbNgx8Ph8DBw6Er68vLly4oNKx5bSVMQBcunQJfn5+GDBgAMzMzPDFF19AIpF0Wp8qGdfU1CAkJARDhw5Fv379EB0d3WtrDw8Pb3NOTJw4UaXjqzuXKjnv2bMHkydPRv/+/cHhcNDQ0NBmro0bN0IkEsHIyAgDBgxQqT5N5nzmzBkEBQXBxsYGHA4Hx44dazNGIpEgKioKgwcPBo/Hw/Dhw/Hzzz+rdPw3aTPn4OBg2NrawtDQENbW1liwYAHu37/faX19nXNvnM/azNje3r5NvWvXru20vr7OODMzE1OmTIG5uTk4HA7Ky8tVOvbbtJWzJve/7uYMdL3/dVTztm3bVJ5D7aaksLAQS5cuRXFxMXJzc9HS0gJ/f380NjYqxmzduhWJiYlITk5GSUkJhEIh/Pz8FF8xDwDR0dE4evQo0tPTUVRUBIlEgsDAQMhkMgCASCRCTU2N0s+iRYtgb2+PcePGdVifTCYDj8fDl19+CV9f33bHnDlzBn5+fjhx4gRKS0vh7e2NoKAglJWVdbr2jIwMREdHY926dSgrK8OkSZMwdepUVFVVKcY4OzsjOTkZlZWVKCoqgr29Pfz9/fHw4UOV8gW0l/H9+/fh6+sLR0dHXLhwATk5Obhy5QrCw8M7rU+VjJuammBhYYF169bBzc2tV9cOAAEBAUrnxokTJ1SeQ525VMn5xYsXCAgIQGxsbIdzSaVSzJkzB4sXL1a5Pk3m3NjYCDc3NyQnJ3c4JiYmBjk5Ofjll19w7do1xMTEYNmyZcjKylJ5HkC7OXt7e+Pw4cO4fv06fv31V9y+fRuffPJJp/X1dc5Az89nbWYMABs2bFCqd/369Z2O7+uMGxsb8eGHH2Lz5s0qH7c92spZk/tfd3NWZf97u+a9e/eCw+Fg9uzZKs8D1kN1dXUMACssLGSMMdba2sqEQiHbvHmzYsyrV6+YiYkJ27VrF2OMsYaGBqavr8/S09MVY+7du8f69evHcnJy2p1HKpUyS0tLtmHDBpVrCwsLYzNmzFBp7IgRI9i3337b6Zjx48ezyMhIpduGDRvG1q5d2+HvPH36lAFgp0+fVqmO9mgq4927dzNLS0smk8kUY8rKyhgAdvPmTZVqUyVjLy8vtnz5cpWO97a3167qnL0xlyo5vyk/P58BYE+ePOlwjtTUVGZiYqJ2bZrMGQA7evRom9tHjhzZ5u9t7NixbP369WrP8SZt5CyXlZXFOBwOk0qlKtXWFzlr4nzWZMZ2dnZs+/bt3a6tLzKWu3PnDgPAysrK1D52e7R1Lmtq/1Mn5+7sfzNmzGA+Pj4qHV+ux+8pefr0KQDA1NQUAHDnzh3U1tbC399fMcbAwABeXl44f/48AKC0tBTNzc1KY2xsbODi4qIY87bs7GzU19d3+Sy+O1pbW/H8+XPFGtojlUpRWlqqVDMA+Pv7d1izVCrFnj17YGJiolZH+jZNZdzU1AQul6t0DQMejwcAKCoq6na9venttcsVFBTA0tISzs7O+Pzzz1FXV9frc6mS83+Zp6cnsrOzce/ePTDGkJ+fjxs3bmDKlCk9Oq62cn78+DHS0tIgEomgr6/fo5o1rbfPZ01nvGXLFpiZmWH06NHYuHEjpFJpj+p9V2nrXNbk/qeK7ux/Dx48wPHjxxEREaHWXD1qShhjWLFiBTw9PeHi4gIAqK2tBQBYWVkpjbWyslLcV1tbCy6Xi4EDB3Y45m0pKSmYMmWKRq4uLBaL0djYiLlz53Y4pr6+HjKZrNN1yf32228QCAQwNDTE9u3bkZubC3Nz827VpsmMfXx8UFtbi23btkEqleLJkyeKlxNramq6VW9vam/tADB16lSkpaUhLy8PYrEYJSUl8PHxQVNTU6/OpUrO/2VJSUkYMWIEBg8eDC6Xi4CAAOzcuROenp7dPqY2cv7qq6/A5/NhZmaGqqoqtf/dpG29fT5rOuPly5cjPT0d+fn5iIqKwo4dO7BkyZJu1fou0+Zjhib3P1Wos//J7d+/H8bGxvj444/VmqtHTUlUVBQqKipw6NChNve9fQVgxliXVwXuaEx1dTVOnTrVpuMaOXIkBAIBBAIBpk6d2o0VAIcOHUJ8fDwyMjJgaWkJADh79qziuAKBAGlpaWqty9vbG+Xl5Th//jwCAgIwd+7cbj/z0WTGI0eOxP79+yEWi2FkZAShUIj3338fVlZW0NPTU4zpacbt6SxjuY7WPm/ePEyfPh0uLi4ICgrCyZMncePGDRw/frzb9fR2zurqy5w7kpSUhOLiYmRnZ6O0tBRisRhLlizB6dOnu12PNnJevXo1ysrK8Pvvv0NPTw+hoaFg//cdkbqYc2+fz5rOOCYmBl5eXhg1ahQWLVqEXbt2ISUlBY8ePQKgmxlrgrYeMzS5/7Wnp/uf3N69ezF//nwYGhqqNX+3rxK8bNkyZGdn48yZM0pX/RUKhQBed4zW1taK2+vq6hRdllAoVDwzf/OZfF1dHUQiUZu5UlNTYWZmhuDgYKXbT5w4gebmZgD//28HdWRkZCAiIgJHjhxRelPQuHHjlN6dbWVlBQMDA+jp6bXpCt9clxyfz4ejoyMcHR0xceJEODk5ISUlBV9//bVa9Wkj45CQEISEhODBgwfg8/ngcDhITEyEg4MDgJ5n3JH2Mn5TR2tvj7W1Nezs7HDz5s1u1dKTnHtLX+XckZcvXyI2NhZHjx7F9OnTAQCjRo1CeXk5vv/++w7fRNcZbeVsbm4Oc3NzODs7Y/jw4RgyZAiKi4vh4eGhczm3pyfnc1+cy/JPCt26dQtmZmbvRMY9pc2cNbX/daSn+x/wurG5fv06MjIy1J5f7VdKGGOIiopCZmYm8vLyFJuXnIODA4RCIXJzcxW3SaVSFBYWKjZDd3d36OvrK42pqanB5cuX2zQljDGkpqYiNDS0zf+F7ezsFJv/oEGD1FrHoUOHEB4ejoMHDyoedOV4PJ7iuI6OjjA2NgaXy4W7u7tSzQCQm5vbbiP19hrUeSlW2xkDr088gUCAjIwMGBoaws/PD0DPMu5Mexmrsvb2PHr0CP/++6/Sg4AqeiPn3qLtnLvS3NyM5uZmpfcbAYCenh5aW1vVqqEvc5a/QiL/+9O1nNvTnfO5LzOWf2pRXu+7kHF3aTtnTe1/nemN/S8lJQXu7u7dei+l2q+ULF26FAcPHkRWVhaMjY0VnZOJiQl4PB44HA6io6ORkJAAJycnODk5ISEhAUZGRggJCVGMjYiIwMqVK2FmZgZTU1OsWrUKrq6ubZ6B5eXl4c6dO2q9Webq1auQSqV4/Pgxnj9/ruj6Ro8eDeB1QxIaGooffvgBEydOVKyBx+PBxMSkw+OuWLECCxYswLhx4+Dh4YE9e/agqqoKkZGRAF5/7Gzjxo0IDg6GtbU1Hj16hJ07d6K6uhpz5sxRuX5tZpycnAyRSASBQIDc3FysXr0amzdv7vK7NLrKGIDiNolEgocPH6K8vBxcLhcjRozo9tolEgni4+Mxe/ZsWFtb4+7du4iNjYW5uTlmzZqlcsa9lTPw+llRbW0tbt26BQCorKyEsbExbG1tFW+Aq6qqwuPHj1FVVQWZTKbIxtHREQKBQOs5SyQSRb3A6zfolZeXw9TUFLa2tujfvz+8vLywevVq8Hg82NnZobCwEAcOHEBiYqLKGQPay/nixYu4ePEiPD09MXDgQPz999/45ptv8MEHH8DDw6PTGvsq5946n7WV8Z9//oni4mJ4e3vDxMQEJSUliImJUXw/jC5mDEDxtyf/zhr5d4sIhULFqxuq0OZjBqCZ/Q/oXs5d7X9yz549w5EjRyAWi1WuWYlan9V5/bSj3Z/U1FTFmNbWVhYXF8eEQiEzMDBgH330EausrFQ6zsuXL1lUVBQzNTVlPB6PBQYGsqqqqjbzffbZZ0wkEqlVo52dXbs1ynl5ebV7f1hYWJfH/umnn5idnR3jcrls7NixSh9VffnyJZs1axazsbFhXC6XWVtbs+DgYHbx4kW16tdmxgsWLGCmpqaMy+WyUaNGsQMHDqhUY1cZd7QOOzu7Hq39xYsXzN/fn1lYWDB9fX1ma2vLwsLC2j13utJbOcfFxXV5nLCwsHbH5Ofnd1qjpnKWfxSxs7+BmpoaFh4ezmxsbJihoSEbOnQoE4vFrLW1tdNjv01bOVdUVDBvb29mamrKDAwMmL29PYuMjGTV1dVd1thXOffW+aytjEtLS9mECROYiYmJ4pyIi4tjjY2NXdbYl+dyampqu2Pi4uK6rLur+jT1mMGYZva/jtbRVc6Mdb7/ye3evZvxeDzW0NCgVt1ydJVgQgghhOgEuvYNIYQQQnQCNSWEEEII0QnUlBBCCCFEJ1BTQgghhBCdQE0JIYQQQnQCNSWEEEII0QnUlBBCCCFEJ1BTQgghhBCdQE0JIYQQQnQCNSWEECXh4eHgcDjgcDjQ19eHlZUV/Pz8sHfvXrUuxrdv374ur6FECCFvoqaEENJGQEAAampqcPfuXZw8eRLe3t5Yvnw5AgMD0dLS0tflEUL+o6gpIYS0YWBgAKFQiEGDBmHs2LGIjY1FVlYWTp48iX379gEAEhMT4erqCj6fjyFDhmDJkiWQSCQAgIKCAixcuBBPnz5VvOoSHx8P4PWl3NesWYNBgwaBz+djwoQJKCgo6JuFEkJ0CjUlhBCV+Pj4wM3NDZmZmQCAfv36ISkpCZcvX8b+/fuRl5eHNWvWAABEIhF27NiB/v37o6amBjU1NVi1ahUAYOHChTh37hzS09NRUVGBOXPmICAgADdv3uyztRFCdANdJZgQoiQ8PBwNDQ04duxYm/s+/fRTVFRU4OrVq23uO3LkCBYvXoz6+noAr99TEh0djYaGBsWY27dvw8nJCdXV1bCxsVHc7uvri/HjxyMhIaHX10MIeXe819cFEELeHYwxcDgcAEB+fj4SEhJw9epVPHv2DC0tLXj16hUaGxvB5/Pb/f1Lly6BMQZnZ2el25uammBmZqbx+gkhuo2aEkKIyq5duwYHBwf8888/mDZtGiIjI/Hdd9/B1NQURUVFiIiIQHNzc4e/39raCj09PZSWlkJPT0/pPoFAoOnyCSE6jpoSQohK8vLyUFlZiZiYGPz1119oaWmBWCxGv36v35p2+PBhpfFcLhcymUzptjFjxkAmk6Gurg6TJk3SWu2EkHcDNSWEkDaamppQW1sLmUyGBw8eICcnB5s2bUJgYCBCQ0NRWVmJlpYW/PjjjwgKCsK5c+ewa9cupWPY29tDIpHgjz/+gJubG4yMjODs7Iz58+cjNDQUYrEYY8aMQX19PfLy8uDq6opp06b10YoJIbqAPn1DCGkjJycH1tbWsLe3R0BAAPLz85GUlISsrCzo6elh9OjRSExMxJYtW+Di4oK0tDRs2rRJ6RgikQiRkZGYN28eLCwssHXrVgBAamoqQkNDsXLlSgwdOhTBwcG4cOEChgwZ0hdLJYToEPr0DSGEEEJ0Ar1SQgghhBCdQE0JIYQQQnQCNSWEEEII0QnUlBBCCCFEJ1BTQgghhBCdQE0JIYQQQnQCNSWEEEII0QnUlBBCCCFEJ1BTQgghhBCdQE0JIYQQQnQCNSWEEEII0QnUlBBCCCFEJ/wP5r9QDJ3b8i4AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data.plot()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "d35535ff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DateOpenHighLowCloseVolumeEx-DividendSplit RatioAdj. OpenAdj. HighAdj. LowAdj. CloseAdj. Volume
02007-12-03181.86184.14177.70178.860034338200.00.01.023.37154523.66455622.83692722.986003240367400.0
12007-12-04177.15180.90176.99179.810027635700.00.01.022.76624423.24817122.74568223.108091193449900.0
22007-12-05182.89186.00182.41185.500031871500.00.01.023.50391423.90359223.44222723.839335223100500.0
32007-12-06186.19190.10186.12189.952832136100.00.01.023.92801024.43050023.91901424.411582224952700.0
42007-12-07190.54194.99188.04194.300038073800.00.01.024.48704625.05893324.16576124.970258266516600.0
\n", + "
" + ], + "text/plain": [ + " Date Open High Low Close Volume Ex-Dividend \\\n", + "0 2007-12-03 181.86 184.14 177.70 178.8600 34338200.0 0.0 \n", + "1 2007-12-04 177.15 180.90 176.99 179.8100 27635700.0 0.0 \n", + "2 2007-12-05 182.89 186.00 182.41 185.5000 31871500.0 0.0 \n", + "3 2007-12-06 186.19 190.10 186.12 189.9528 32136100.0 0.0 \n", + "4 2007-12-07 190.54 194.99 188.04 194.3000 38073800.0 0.0 \n", + "\n", + " Split Ratio Adj. Open Adj. High Adj. Low Adj. Close Adj. Volume \n", + "0 1.0 23.371545 23.664556 22.836927 22.986003 240367400.0 \n", + "1 1.0 22.766244 23.248171 22.745682 23.108091 193449900.0 \n", + "2 1.0 23.503914 23.903592 23.442227 23.839335 223100500.0 \n", + "3 1.0 23.928010 24.430500 23.919014 24.411582 224952700.0 \n", + "4 1.0 24.487046 25.058933 24.165761 24.970258 266516600.0 " + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "a976d8c8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data.plot('Date')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45652b81", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/topics/~$apter1_basic_installation.docx b/topics/~$apter1_basic_installation.docx new file mode 100644 index 0000000000000000000000000000000000000000..1698f019f0ebf9ae63029291babefa8f8302a04f GIT binary patch literal 162 zcmZQC&L~Pv&B|mT39vI1Gh{FnF{A=v76U{xBhUoBNv`z_77Wvv87dfZ8FDbp)R^R6 i&tM6XPi9DBD8Z1|n&er}V8t+ng&~C@AE+i5r~&}za}f>z literal 0 HcmV?d00001 From efc78858d262a4cca7e0b6450dee6fa4d2779594 Mon Sep 17 00:00:00 2001 From: siddhapuraanil Date: Tue, 5 Sep 2023 20:26:35 +0530 Subject: [PATCH 7/8] Update chapter1_anjali.ipynb chap1 --- topics/chapter1_anjali.ipynb | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/topics/chapter1_anjali.ipynb b/topics/chapter1_anjali.ipynb index 533439a..fefaf19 100644 --- a/topics/chapter1_anjali.ipynb +++ b/topics/chapter1_anjali.ipynb @@ -1,9 +1,25 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "3962edb2", + "metadata": {}, + "source": [ + "## Chapter 1: Installation- 18th Aug 2023 ##" + ] + }, + { + "cell_type": "markdown", + "id": "58c96b1c", + "metadata": {}, + "source": [ + "1. Anaconda" + ] + }, { "cell_type": "code", "execution_count": null, - "id": "b8d91c78", + "id": "287c8df0", "metadata": {}, "outputs": [], "source": [] @@ -25,7 +41,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.9.13" } }, "nbformat": 4, From ab87ce3e943cbffa3f43417b4f15efddde25c6d7 Mon Sep 17 00:00:00 2001 From: siddhapuraanil Date: Tue, 5 Sep 2023 20:34:21 +0530 Subject: [PATCH 8/8] Update 106_adjusted_close_price.ipynb --- 106_adjusted_close_price.ipynb | 32 ++++++++++++++------------------ 1 file changed, 14 insertions(+), 18 deletions(-) diff --git a/106_adjusted_close_price.ipynb b/106_adjusted_close_price.ipynb index 9937177..9c46bb4 100644 --- a/106_adjusted_close_price.ipynb +++ b/106_adjusted_close_price.ipynb @@ -54,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "id": "25ede47f", "metadata": {}, "outputs": [ @@ -195,7 +195,7 @@ "4 1.0 24.487046 25.058933 24.165761 24.970258 266516600.0 " ] }, - "execution_count": 2, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -213,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "id": "14b42521", "metadata": {}, "outputs": [ @@ -354,7 +354,7 @@ "2516 1.0 169.95 171.67 168.50 171.05 39590080.0 " ] }, - "execution_count": 3, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -367,7 +367,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "2161a0d2", "metadata": {}, "outputs": [ @@ -377,20 +377,18 @@ "" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -401,20 +399,18 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "7aa74e3a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -459,7 +455,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.9.13" } }, "nbformat": 4,