diff --git a/Crypto_Bot b/Crypto_Bot
new file mode 160000
index 0000000..faee72f
--- /dev/null
+++ b/Crypto_Bot
@@ -0,0 +1 @@
+Subproject commit faee72f2a2ae57a0fdbace78bc3e3c92fcf0280d
diff --git a/Notebook/Bot Functions.ipynb b/Notebook/Bot Functions.ipynb
new file mode 100644
index 0000000..f063aee
--- /dev/null
+++ b/Notebook/Bot Functions.ipynb	
@@ -0,0 +1,439 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "688dd5a4",
+   "metadata": {},
+   "source": [
+    "# CRYPTO BOT\n",
+    "\n",
+    "Disclaimer: This program is not intended as serious financial advice. If the program makes a suggestion, you should ALWAYS do your research and make your own informed decisions. Beware, sometimes the best predictions are Elon Musk's tweets :P\n",
+    "\n",
+    "This program allows users to select one of their favorite cryptocurrencies and obtain the most up-to-date value in the market. Furthermore, the program contains a trading bot that suggests what to do with that crypto at this moment. Should you buy? Is it a good time to sell? The Crypto bot uses the Relative Strength Index (RSI) to run this calculation, so that you could sit back and relax, while the bot does all the work for you.\n",
+    "\n",
+    "Furthermore, if you can't to explore the behavior of a cryptocurrency from the past, you can do that by just specifying some parameters. It is super easy. \n",
+    "\n",
+    "Don't miss out on the next bull market. Keep calm, grab your favorite drink and watch how Elon Musk destroys everything."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e26cd94",
+   "metadata": {},
+   "source": [
+    "### Functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "90978cfa",
+   "metadata": {},
+   "source": [
+    "### Retrieve current price"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5bdf0cc7",
+   "metadata": {},
+   "source": [
+    "This function retrieves the current price of the crypto from the CoinMarketCap.com API (in USD).\n",
+    "The user must input the symbol of their desired coin."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ce6e1981",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import requests\n",
+    "from requests import Session\n",
+    "\n",
+    "\n",
+    "url = 'https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest'\n",
+    "\n",
+    "coin = 'litecoin'\n",
+    "def bot_api(coin):\n",
+    "    global data\n",
+    "\n",
+    "    parameters = {\n",
+    "        'symbol': coin,\n",
+    "        'convert': \"usd\"\n",
+    "    }\n",
+    "\n",
+    "    headers = {\n",
+    "        'Accepts': 'application/json',\n",
+    "        'X-CMC_PRO_API_KEY': '31233140-af13-4dd0-ad7e-1bdb98b80470'\n",
+    "    }\n",
+    "\n",
+    "    session = Session()\n",
+    "    session.headers.update(headers)\n",
+    "\n",
+    "    response = session.get(url, params = parameters)\n",
+    "\n",
+    "    result = json.loads(response.text)['data']\n",
+    "    result = list(result)\n",
+    "    number = result[0]\n",
+    "\n",
+    "    result = json.loads(response.text)['data'][str(number)]['quote']['USD']['price']\n",
+    "\n",
+    "    return(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b412b0d",
+   "metadata": {},
+   "source": [
+    "#### Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "a20460f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2369.3446384777594"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Current price of Ethereum (30/May 15:33)\n",
+    "bot_api('eth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "a6f16105",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "36278.33979143302"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Current price of Bitcoin (30/May 15:33)\n",
+    "bot_api('btc')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "76c38016",
+   "metadata": {},
+   "source": [
+    "### Obtain on-going crypto prices"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "311285ce",
+   "metadata": {},
+   "source": [
+    "This function retrieves data from the binance websocket. Every second, it receives the current price of the selected crypto in USD."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "8ecec57f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import asyncio\n",
+    "import websocket\n",
+    "import websockets\n",
+    "import time\n",
+    "import datetime as dt\n",
+    "\n",
+    "async def main(symbol, prices):\n",
+    "    global xdata\n",
+    "    global results\n",
+    "\n",
+    "    url = \"wss://stream.binance.com:9443/stream?streams=\" + symbol + \"usdt@miniTicker\"\n",
+    "    async with websockets.connect(url) as client:\n",
+    "        global xdata\n",
+    "        for x in range(prices):\n",
+    "        # while len(xdata) < prices:\n",
+    "            data = json.loads(await client.recv())['data']\n",
+    "\n",
+    "            event_time = time.localtime(data['E'] // 1000)\n",
+    "            event_time = f\"{event_time.tm_hour}:{event_time.tm_min}:{event_time.tm_sec}\"\n",
+    "\n",
+    "            print(event_time, data['c'])\n",
+    "            a = data['c']\n",
+    "            results.append(a)\n",
+    "\n",
+    "            print(x)\n",
+    "        return(results)\n",
+    "\n",
+    "def run_bot2(symbol, prices):\n",
+    "    if __name__ == '__main__':\n",
+    "        loop = asyncio.get_event_loop()\n",
+    "        loop.run_until_complete(main(symbol, prices))\n",
+    "        return(results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9b9011d",
+   "metadata": {},
+   "source": [
+    "#### Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "5359a953",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<video src=\"run_bot2_demo.mov\" controls  >\n",
+       "      Your browser does not support the <code>video</code> element.\n",
+       "    </video>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Video object>"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#run_bot2('btc', 15)\n",
+    "\n",
+    "from IPython.display import Video\n",
+    "Video('run_bot2_demo.mov')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9db82bd",
+   "metadata": {},
+   "source": [
+    "### Technical Analysis - RSI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "812bb1f8",
+   "metadata": {},
+   "source": [
+    "This function suggest the user if it's a good time to sell/buy or retain their crypto, based on the Relative Strength Index (RSI). For more info on the RSI, visit: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/RSI\n",
+    "\n",
+    "It runs the run_bot2 function and, after 15 seconds elapse (also, 15 crypto values), it gives a suggestion."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "407558e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import talib\n",
+    "import numpy as npy\n",
+    "def rsi(symbol, prices):\n",
+    "    df = run_bot2(symbol, prices)\n",
+    "    print(df)\n",
+    "    df = np.array(df, dtype='f8')\n",
+    "\n",
+    "    #Buy or sell, depending on the RSI value\n",
+    "    rsi = talib.RSI(df, RSI_PERIOD)\n",
+    "    # print(rsi)\n",
+    "    last_rsi = rsi[-1]\n",
+    "    print(last_rsi)\n",
+    "    if last_rsi > RSI_OVERBOUGHT:\n",
+    "        decision = \"BEARISH: SELL YOUR CRYPTO NOW\"\n",
+    "        # if in_position:\n",
+    "        #     print(\"Bearish: But, you can't sell what you don't have\")\n",
+    "        #     # Binance selling order\n",
+    "\n",
+    "    if last_rsi < RSI_OVERSOLD:\n",
+    "        decision = \"BULLISH: BUUUUY, TO THE MOON\"\n",
+    "        # if in_position:\n",
+    "        #     print(\"Bullish: You have some already, move on\")\n",
+    "        #     # Binance buying order\n",
+    "\n",
+    "    if last_rsi > RSI_OVERSOLD and last_rsi < RSI_OVERBOUGHT:\n",
+    "        decision = \"RELAX AND DO NOTHING\"\n",
+    "    print(decision)\n",
+    "\n",
+    "    last_rsi = round(last_rsi, 2)\n",
+    "    return(last_rsi, decision)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "34c863ad",
+   "metadata": {},
+   "source": [
+    "#### Example\n",
+    "\n",
+    "It saves the last 15 values in an array and it calculates the RSI\n",
+    "- If RSI > 70 = Market is bearish/overbought, you should sell now\n",
+    "- If 30 < RSI > 70 = Market is stable, you should not do anything\n",
+    "- If RSI < 30 = Market is bullish/oversold, you should buy now"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "9ad7099f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# rsi('btc', 15)\n",
+    "\n",
+    "from IPython.display import Image\n",
+    "Image('RSI_demo.png')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e0b463e",
+   "metadata": {},
+   "source": [
+    "### Historical Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "63cdf8c2",
+   "metadata": {},
+   "source": [
+    "This function allows the user to observe the graphical behavior of a selected crypto in any historical timeframe. For example, the bitcoin 1h interval price from 2020/04/01 until 2020/05/01.\n",
+    "\n",
+    "Note: The limit for possible values is 1000. For example:\n",
+    "1) if I want to get an hourly graph of bitcoin from 2020/01/01 to 2021/01/01 it won't be possible because (1h * 24h/day * 30days * 12 months) > 1000.   \n",
+    "\n",
+    "2) If you want an hourly graph of bitcoin from 2020/April/01 to 2020/May/01, it is possible because (1h * 24h/day * 30days * 1month) < 1000."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "d5240d01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import datetime as dt\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "def historical(symbol, interval, startYear, startMonth, startDay, endYear, endMonth, endDay):\n",
+    "    global df\n",
+    "\n",
+    "    url = 'https://api.binance.com/api/v3/klines'\n",
+    "\n",
+    "    symbol = symbol.upper()\n",
+    "    startTime = str(int(dt.datetime(startYear,startMonth,startDay).timestamp() * 1000))\n",
+    "    endTime = str(int(dt.datetime(endYear,endMonth,endDay).timestamp() * 1000))\n",
+    "    limit = '1000'\n",
+    "\n",
+    "    req_params = {'symbol': symbol + 'USDT', 'interval': interval, 'startTime': startTime, \n",
+    "    'endTime': endTime, 'limit': limit}\n",
+    "\n",
+    "    df = pd.DataFrame(json.loads(requests.get(url, params = req_params).text))\n",
+    "\n",
+    "    df = df.iloc[:, 0:6]\n",
+    "\n",
+    "    df.columns =  ['datetime', 'open', 'high', 'low', 'close', 'volume']\n",
+    "\n",
+    "    df.index = [dt.datetime.fromtimestamp(x / 1000.0) for x in df.datetime]\n",
+    "    df['close'] = df['close'].astype(float)\n",
+    "    df['close'].plot()\n",
+    "    plt.show()\n",
+    "    #return df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "d1555299",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "historical('btc', '1h', 2020,4,1,2020,5,1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e326a84e",
+   "metadata": {},
+   "source": [
+    "For more information on how to use the GUI, please visit the Crypto GUI vignette."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Notebook/Crypto GUI.ipynb b/Notebook/Crypto GUI.ipynb
new file mode 100644
index 0000000..9635168
--- /dev/null
+++ b/Notebook/Crypto GUI.ipynb	
@@ -0,0 +1,229 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "85ee8f6b",
+   "metadata": {},
+   "source": [
+    "# Crypto GUI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "557adfdb",
+   "metadata": {},
+   "source": [
+    "Disclaimer: This program is not intended as serious financial advice. If the program makes a suggestion, you should ALWAYS do your research and make your own informed decisions. Beware, sometimes the best predictions are Elon Musk's tweets :P\n",
+    "    \n",
+    "\n",
+    "This vignette is intended to guide you through the GUI, so that you could make use of it without any hassle."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4a95cefc",
+   "metadata": {},
+   "source": [
+    "### Pre-requisites\n",
+    "\n",
+    "- Sign in to this website: https://coinmarketcap.com/api/\n",
+    "- Install homebrew from this website: https://brew.sh/index_es\n",
+    "- Python3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "071b2977",
+   "metadata": {},
+   "source": [
+    "# Run the GUI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a5bbd52d",
+   "metadata": {},
+   "source": [
+    "Initialize git in your terminal\n",
+    "$ git init\n",
+    "\n",
+    "Clone the Crypto_bot repo in your local desktop\n",
+    "$ git clone https://github.com/Programming-The-Next-Step-2021/Crypto_Bot.git\n",
+    "\n",
+    "Install the package and its dependencies\n",
+    "$ sudo python3 setup.py install\n",
+    "\n",
+    "Go to the directory where the bot_API.py file is located\n",
+    "\n",
+    "Run the script on your terminal\n",
+    "$ {path-to-file}/bot_API.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9e92de1e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5AAAALgCAYAAADiGZhRAAAYgGlDQ1BJQ0MgUHJvZmlsZQAAWIWVeQdUFE2zds9GdlmWnHNOknPOOecosOScMypRJKgEAUVABRUEFUwEERURRBQRVMCASBAlqaCCICB3CPq+n99//ntun9PTz1ZXV3VXdU917QDAOkIKDw9GUAEQEhodaW2gzeXo5MyFnQJIgAAUgAHQkLyiwrUsLU0BXH63/1mWhwC01T4X25L13/3/30Lj7RPlBQDkCmNP7yivEBi3A4Aq9wqPjAYAs0XnjYsO38IpMKaLhCcI46It7LeDL2xhzx3cts1ja60D434AyAgkUqQfAMQRmM4V6+UHyyGuw300od4BoQDQwyvHqHv5k7wBYLWEefaEhIRt4X0wFoL5w2F8DsaKnv+S6fcf8j3/yCeR/P7gnXVtFzLdgKjwYFLC/9E0/3sJCY75rUMArgT/SEPrrfXDNnwZFGayhQkwng/1NLfYsjWMVwK8d+wOAALvH2Not8OPYPOK0oHtB3scICS9SbomMGaDsX5osLnpLt3TN0DfCMawzRDxAdFGtjBmgnGWT5SezS7Pmcgw611diCbfSB2tXfpDUuS23i1dozFBdlq78r/6+xjtykcSE/1tHWCMhzFfbIC9OYyJMBaPCrIx2eVRTfTXMf/NExljvTV/Phhb+4QaaO/IR8b6Rupb7/LnhET9Xi/yjH+Akfkuvhbtb2u4Yx9kpxdpe/7wWpD9PqFadr/l+EQ5mv5ei7ePrt7O2pHTPqF2NrtyVsKjta13xqLw4cGWu/woHp9ggy06D4xlo2Jtdsei7KPhzbkjH+UbHm1puzNPVGIgydhyZz6ofGAKdIAu4AIxcPUEYSAQBPTNN8/Dv3Z69AEJRAI/4APEdim/Rzhs94TCTxuQCD7ByAdE/Rmnvd3rA2Jh+sYf6s5TDPhu98ZujwgCH2AcAkxAMPw7ZntU6B9t9uA9TAn4L+0kuHrB8w2G61b//5v+m/oPRQummO5SYn5r5KL8zYnRw+hiDDH6GGEUC0odpYIyhZ+acJVGKaKUfq/jH370B/QAegI9iB5Dv3IPSIv8a5ZmYAyWr79rC89/2wIlAMuUQ2mj1GDpsGQUA4oFiKFkYT1aKA1YsxxM1dmd95ZVuP6S/R8r+Jc3dvlwkjgEjhGniRP6eyRRhCj3R8qWrf9tn525ev6xt86fnr/16/zL+t5wa/I3JzILeR3ZjbyH7EG2IZsBF/IusgXZi7y9hf/srvfbu+u3Nuvt+QTBcgL+Sx9pV+eWJaMkL0rOSK7v9EX7xEdvHTydsPCEyAA//2guLTg6+HAZhXqJ7+GSlpSWAmAr1uy8vr5Zb8cQiOHpPzSfaQBU4TOD6/+HFngMgLouABhz/qEJuADAvAeAq8+8YiJjd2iorQcafktQwieNGXAAXiAEr0cayAMVoAn0gDGwALbACbjBVvaH93kkiAP7QCrIBLkgHxSDk+A0OAsugMvgGmgGbeAeeAAeg34wCN7Au2cKzIEFsAzWIAjCQhQQLcQMcUL8kCgkDSlC6pAeZApZQ06QB+QHhUIx0D4oHcqFCqGTUCVUC12FbkL3oB5oAHoFjUMz0FfoJwKJICDoEOwIAYQEQhGhhTBB2CL2IvwQEYhERAbiKOIEogpxCdGEuId4jBhEjCHmEEtIgCRHMiC5kWJIRaQO0gLpjPRFRiIPIHOQJcgqZD2yFfbzc+QYch65isKgaFFcKDF4Bxui7FBeqAjUAdRh1EnUBVQTqhP1HDWOWkD9QlOg2dCiaGW0EdoR7YeOQ2eiS9DV6EZ0F3yWptDLGAyGASOIUYDPohMmEJOEOYypwDRg2jEDmEnMEhaLZcaKYtWwFlgSNhqbiS3FXsLexT7DTmFXyMjJOMmkyfTJnMlCydLISsjqyO6QPSP7SLaGo8Lx45RxFjhvXAIuD3cO14p7ipvCreGp8YJ4NbwtPhCfij+Br8d34Ufw38jJyXnIlcityAPIU8hPkF8hf0g+Tr5KoCGIEHQIroQYwlFCDaGd8IrwjYKCQoBCk8KZIpriKEUtxX2KUYoVIi1RnGhE9CYmE8uITcRnxM+UOEp+Si1KN8pEyhLK65RPKeepcFQCVDpUJKoDVGVUN6mGqZaoaamlqC2oQ6gPU9dR91BP02BpBGj0aLxpMmjO0tynmaRF0vLS6tB60abTnqPtop2iw9AJ0hnRBdLl0l2m66NboKehl6W3p4+nL6O/TT/GgGQQYDBiCGbIY7jGMMTwk5GdUYvRhzGbsZ7xGeMPJlYmTSYfphymBqZBpp/MXMx6zEHMBczNzG9ZUCwiLFYscSynWLpY5lnpWFVYvVhzWK+xvmZDsImwWbMlsZ1l62VbYudgN2APZy9lv88+z8HAockRyFHEcYdjhpOWU50zgLOI8y7nLBc9lxZXMNcJrk6uBW42bkPuGO5K7j7uNR5BHjueNJ4Gnre8eF5FXl/eIt4O3gU+Tj4zvn18F/le8+P4Ffn9+Y/zd/P/EBAUcBA4JNAsMC3IJGgkmCh4UXBEiEJIQyhCqErohTBGWFE4SLhCuF8EISIn4i9SJvJUFCEqLxogWiE6sAe9R2lP6J6qPcNiBDEtsVixi2Lj4gzipuJp4s3inyX4JJwlCiS6JX5JykkGS56TfCNFI2UslSbVKvVVWkTaS7pM+oUMhYy+TLJMi8yirKisj+wp2ZdytHJmcofkOuQ25BXkI+Xr5WcU+BQ8FMoVhhXpFC0VDys+VEIraSslK7UprSrLK0crX1P+oiKmEqRSpzKtKqjqo3pOdVKNR42kVqk2ps6l7qF+Rn1Mg1uDpFGlMaHJq+mtWa35UUtYK1DrktZnbUntSO1G7R86yjr7ddp1kboGujm6fXo0enZ6J/VG9Xn0/fQv6i8YyBkkGbQbog1NDAsMh43YjbyMao0WjBWM9xt3mhBMbExOmkyYiphGmraaIcyMzY6ZjZjzm4eaN1sACyOLYxZvLQUtIyxvWWGsLK3KrD5YS1nvs+62obVxt6mzWbbVts2zfWMnZBdj12FPae9qX2v/w0HXodBhzFHCcb/jYycWpwCnFmess71ztfOSi55LscuUq5xrpuvQXsG98Xt73Fjcgt1uu1O6k9yve6A9HDzqPNZJFqQq0pKnkWe554KXjtdxrzlvTe8i7xkfNZ9Cn4++ar6FvtN+an7H/Gb8NfxL/OcDdAJOBiwGGgaeDvwRZBFUE7QZ7BDcEEIW4hFyM5QmNCi0M4wjLD5sIFw0PDN8LEI5ojhiIdIksjoKitob1RJNB1/qe2OEYg7GjMeqx5bFrsTZx12Pp44Pje9NEEnITviYqJ94PgmV5JXUsY97X+q+8f1a+ysPQAc8D3Qk8yZnJE+lGKRcSMWnBqU+SZNMK0z7nu6Q3prBnpGSMXnQ4ODFTGJmZObwIZVDp7NQWQFZfdky2aXZv3K8cx7lSuaW5K4f9jr86IjUkRNHNo/6Hu3Lk887lY/JD80fKtAouFBIXZhYOHnM7FhTEVdRTtH3YvfinhLZktPH8cdjjo+dMD3RUspXml+6ftL/5GCZdllDOVt5dvmPCu+KZ6c0T9WfZj+de/rnmYAzLysNKpuqBKpKzmLOxp79cM7+XPd5xfO11SzVudUbNaE1YxesL3TWKtTW1rHV5V1EXIy5OHPJ9VL/Zd3LLfVi9ZUNDA25V8CVmCuzVz2uDl0zudZxXfF6/Q3+G+WNtI05TVBTQtNCs3/zWItTy8BN45sdrSqtjbfEb9W0cbeV3aa/nXcHfyfjzubdxLtL7eHt8/f87k12uHe8ue94/0WnVWdfl0nXwwf6D+53a3Xffaj2sK1HuefmI8VHzY/lHzf1yvU2PpF70tgn39f0VOFpS79Sf+uA6sCdZxrP7j3Xff7ghdGLx4PmgwNDdkMvh12Hx156v5x+Ffxq8XXs67U3KSPokZy3VG9LRtlGq94Jv2sYkx+7Pa473jthM/Fm0mty7n3U+/WpjA8UH0o+cn6snZaebpvRn+mfdZmdmgufW5vP/ET9qfyz0OcbXzS/9C44LkwtRi5ufj38jflbzXfZ7x1LlkujyyHLaz9yVphXLqwqrnb/dPj5cS1uHbt+YkN4o/WXya+RzZDNzXBSJGn7KoCEK8LXF4CvNQBQOAFAC+dteJedXHC3IOHLBwJu7SE9hBZSEcWExmPIsJJkTrh0/F0ChoJEbKbCUwfTPKKToy9nBExBzH2s8mz57HOcmlx53AO8eD4lfieBIMEQIVdhbRF2kUXRB3tKxYLE1SQoJN5JNkilSFvJcMt8kr0pd1DeSoFNYUqxXileWUsFr/JctVzNW32P+leNZs19WtraBO13Ond06/Qq9AsMDhiSjDSMmYwXTXpN680qzCst2iwnrdE2zLYsdlT2SPt1hzUn4IxzIbpS7EXtXXKbcO/3aCdd96z2KvXO8Unw9fOz9dcOkA0UCeIOZg6hDEWGfg+bCO+PuBV5LupodHJMZmxjPCrBJ7F9H9gvcEA52SjFJTUm7Wh6cUbSQdmDk5l5hyyz+LPJc0Au4jD1EaGj6nnm+Q4FzoXOxxyL7IttS6yOm58wKTU4qV2mXq5UIXNK7LTIGclKk6r0s2Pnjaov1czVUtfxX5S6pHJZt96sweGK+1X/a+HX424caExrOtic1ZJ7M6+1+FZ5W/XtG3e67g63j90b6mi479vJ1Pmwq+RBXLfvw709Do+sHpv0Gjwx7LN9GtF/ZuDVc/IXEoM6Q0bDei8VX/G/Jr5efTM98vLtvdGz79LH/MbtJswnzd5bTFl8MP6oNM04PTaTMys7OzZ3YT7xk+Fnss+1Xwy+TC6cXYz/6vbN4rvZUuByx8qhn80bupubu/6XQqKQM6gx9CRmgQyJk8f7k5cTxogilHFUD2iYaRPoXjBIM6YxvWWRY81k6+dg4XTkKuBu4xnhXeJb5p8VeCJ4VihSWF2ETOSF6Ok9gWJyYr/EH0gclXSQ4pT6KF0vEyurJgfJdcnnKFgo0ioOKZUqu6iwq4zAu8BVnVl9WOO4pouWgNaa9qDOVd3Dej76qgbUBh8M24yKjWNNfEw9zfzNwyxCLD2tLKxVbERsWe2I9gj7ZYePjkNO953rXcpcc/YmugW4O3rokiQ8mbwgr1nvQZ9O30a/av+SgIzAsCCnYM0QwVAKeCeMh49GfI/ijnaPKY29F/cyfjJhPnF1H/l+jgNCyVwpmJR3qY1peemRGW4H7TIdDwVkpWdX5FzObTzcdOTG0at5l/NrC84XnjlWVlRcnFeSfTztREJp2Em/soDylIq7p4XPXKgSPFt47vn51RriBZZa3joReB8oXFav120wu+J0Nfha5vWzN+40DjSNNk+3fGtF3mJsE72tckfzrkI79z3EvYmO7vuNnTVdZQ/yuw8+TOyJfBT9OLu3rY/h6f7+t89Ynmu8sB30HUoZPv/y6avvb2hGxN6ajoa/Oz52a/zZxOjkxPu5D2jY+6kzA3PU85Kf5D4LfKH8srLwYXH466NvN79XLiUv2/8Q/LG80raa+FNljbCuuzGz639xaA5RgXRDCaOx6EXMDHaWbAK3SI4n8FNoEZ0pU6kuUQ/QbNLx0+sxBDIeZDrNfIOli/Uh2wP2WxyVnPFc2lw/uc/xmPDM8WbxCfJ18LvxrwoUCUoKPhLyE8YK14gYinwUzdwjtKdLzEsciFdIqEq8lIyBbzcN0qbS0zLpshyyLXLWcvPyBxU4FZrhW8u0UrIyg/JFFS2VZ6peqp/VktSx6mUashpDmolaHFot2hbar3T8dTZ1q/Qs9XH69w32GcoazhpVGbuaMJkMmRab2ZhTmvdYpFuqWH63arAOshG0eW9babfXntn+hUOeo6HjplOjc7ALn8tb15K95nuX3Yrc+d1veGh5vCbFe/J4voTfI/4+Br4Kfkr+RgGkwJAgUrBGCFXISOj5sJBwufD1iPuROVGW0fTRb2JOx3rHCcR9iD+VoJcwkhicRJf0fN+t/XcOdCbfT7mZWptWkp6eEXbQJVPvkEgWOutFdmmOcy5f7trhsSNPjt7MO5N/oMClUPkYy7HVoqHiayXHjx85UVhaefJ62YPylxWzp9bOUFRyVcmcNTznej6s+kBN9oXDtSl1pIsKl4iXvl7+VL96hXCV45r0dcsbSY03mlZalG6Gt5beutLWcvvWnZ67S/cMOm522nQtdZf0yDx60Xukz6Pf6JnWC+2h4FfEkbmJvtml76tb/t/5T3CrYOQBOJYKZ6iZANhpAFDQCeeZg3DeiQfAkgIAWyWAEPAFCEIvgJTH/8QPCI42GEAOqAET4ASCQBIow1myBXAGviAKzi7zwClQD+6Ap2AcfIczRzZICjKA3KE4qAC6BD2EPiAwCCGEKSIKUQHneZtwXheLvIn8hTJAHUNNoGXQWeh3GGVMKWYNzrAekSmQ1eBYcQV4cnw2OZ48n8BCqKGQpWgjqhFbKRUpb1EZUr2hjqahorlMq0s7QGdLN0BvQf+MwZ1hhbGUSY1plHk/CytLK6sbG46tjT2WQ5bjG+c1rkhuOe51nm7eEj5/flUBosCY4HWhLGFPES1RgT3EPWtin8XfSwxKNkolSUtJj8pkycrJfpFrkS9USFD0VjJVllRhVCWqiauXaYpqHdHu0fmiR6ZPb8BsyGbEZyxrYm4aYXbCvNPiqxWvtYPNUdtue5SDrmOmU68Lg6vn3jq39x4YErUnxnPJa8p7xGfWj9LfJKA48GOwakhR6Odw44i6KEJ0RMzrOP34lkSxpOr9XAfKUhhSC9LxGakHlw4FZs3l5B4OOdpYQH2MpehTSe0J95MMZf0VR04bnFmqyjtHdz6revlCUO3Xi/mX9Rqoryxe+3Bjummu5WPrZNviXcZ7Ovfdujy6bXo0Hks8EX4qPxD6fGUY9Ro3cvod7fidKeL0vjmtTw1f1r7Kf9dfxv84svJodfrn1Nqr9Rsb+b88NyW33x9b/scCAqABzIAbiAAZoAYMgS3wACEgCWSDUlALboLH4C1YgNAQCyS57f0EqAi6AvVBnxCUCBmEMyIdcQ0xheREuiPPIedR8qgM1CBaGJ2KHoF9X4YFWH/sIJkeWQtOAleHF8ZfIpclv0uwJExSxBNxxGJKbsorcP76hjqOhoGmmdae9hPdfno8/QkGMYZHjGFMjEztzAEsdCztrGFsfGwj7KUcjpxMnK+4Kri9eSR5Ae8Lvov8GQKugrJwLjcr3CtyHY5ieWLp4vskoiW9pDSlCdJ9MjmyJnKMcovyrxS6FZuUqpQPqySqxqplq7do/NCS0fbWydWt1mvSv2Vwy/C2UY/xuCnCTMTc3uKgZbPVvA2frbtdhf2oI49ToHOTK3avg9tJ9y6PAVKHZ61XlneAj7WvoZ+Tf1pAexBFsGdIWxhLeGLE2yjt6NpYyrjw+MeJ3Emx+/oPyCWfS2VNK8rAH0zKnM8iZU/kJh6RzEPkvy28WhRbInv8a+nVspgK5VM/z1RXSZ+tOPexWrDG/8KVOsaL5ZfV6j9dKb2mdL2vkdS01lLVatUGbtfeNW1f7Djd6flA+SH3I9TjJ09in2L6c54RnlcNug+bvQp+U/P24xjnhOX71A93Zhjn8j8LLDz5VrR8eNVoTXr91Mb7X4u7/kcBHKCCTz83EAXyQAdYAjfY9/vhk18JboCHYBQ+9wRIANKE9kJJUBl0GxpH4GCvkxDFiH4kPdIHeRvFhkpBzaKd0E8wOpjbWDXsPTJTsre4KDwl/gq5PQFJaKaIIEoRVyi7qEqpY2icaI3ojOmtGIwZFZiEmeVY3FkT2KLZPTlsOc25zLjNeEx5zfis+d0FogSPCNUJPxSZ2UMhpiDuK3FSckiaRcZbtkFuTcFS8YlytqqTOlojX3Nd20QnHfZgs36bwR3DPqM1ExPTJnNxi0tW4tZNtjp2Qw4hTnjnS672btQe5J7u3i4+7/1U/HMDPgRZB/eGmoU9i3CJnI5OiuWIG014kNS+vyLZLuVnWmWGfSbnoYXs27mHj/jmGRQwFz4u8i1ePp5eSn2yqly+4slp30qoqvyc4vnBmpha1rqHl5LrDa5IXNO/kdxU1ZLX6tTGeHv4btk9p/vYzvMPZLtv9eg9Gu6N75PoRw4sPJ8eHBgueCX4uuLNr7d6oznvHo9TTthNnnk/80HqY9D0mZmHs7Pz6E9snyW/6C44LJK+en+z/M7zfWnpyDLbct0PpR8nf6yuOKw0rTKsRq42ra791PyZ8bNnjbhms3Z8rX+dbF1zPX796vrMBveG00bhxqONjV9Sv7x/Hf/1+NevTalNn80Tm71b/o/ylZHeDh8QQRsA9Ojm5jcBALCFAGwUbG6uVW1ubpyFk40RANqDd74zbccaKgDKF7bQ45bF+b+/8ex8g/pXHvN3C7Yj0bZWOBJtla2oBP4HZmHpu8xMX7oAAABWZVhJZk1NACoAAAAIAAGHaQAEAAAAAQAAABoAAAAAAAOShgAHAAAAEgAAAESgAgAEAAAAAQAAA5CgAwAEAAAAAQAAAuAAAAAAQVNDSUkAAABTY3JlZW5zaG90lVpuDwAAAdZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iPgogICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+NzM2PC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxYRGltZW5zaW9uPjkxMjwvZXhpZjpQaXhlbFhEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlVzZXJDb21tZW50PlNjcmVlbnNob3Q8L2V4aWY6VXNlckNvbW1lbnQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgqhod68AABAAElEQVR4AezdB4BcVfXH8bOzsyGBTa+EAKGGTiIgvUqTGjpSBESkqCD+QRSkCQICgqCgogIiRToElIBSA0hVWuiEFlJI78m297+/s7mP2cnM7G7qbuZ7YfJmXr3v82Z358y5976KTz8fk9Q3NFhFRYU1hGllZaU11NdbYmb19XU2b16NTZk82WrmzbMVq1e0bl26WLduXa1L586+fpJoTfPt/Un4R/MymYxP4zxNtX8VHSt3uebrdXr8+evl7kfPtV3uQ+tzfPzje8rfXOGf3PdNnKcp7z9+/vQ+4PcPv3/5+/PV32f+/vL5g89ffP7k8/f8+KeM44/Zs2fblKlTbdr0mabnK6zQ0bqGeK9jx06WzWYXiL8qPh09NkkUiIX/Ghq+CkYUME6fPj3saKqtOXCg9ezR3Wpra/X5y3fiT/gHAQQQQAABBBBAAAEEEECgXQrEJF3ul0nTpk23D0aNsq5du1vnztUhiKzyZJ++hJ8aAs2Kjz8bHaLGmH3MWF1dfXjU2YQJX1omMKy7zloeMOrbCW1EQQABBBBAAAEEEEAAAQQQWP4EYutOtUp97/0PQ4qxwnr36WOVobVoCAbt+eefs8z48V+GM1fzULNx48bZ62++aa+8/LLNCNnH9Qat4yoxMl3+iDgjBBBAAAEEEEAAAQQQQAABCcTugor/Bq27duga1mCTJk60hjCdNi1kH8O0crMtt7pg5X4re+bx3ffft759+4QUZYVtucVmrhijUEgRQAABBBBAAAEEEEAAAQSWfwHFgGrW2qN7N/t89GjLVlVZbU2tzZk9U8+zNmXKFKsOg+Mowpw+ZWpotrqmDzhC8Lj8vzk4QwQQQAABBBBAAAEEEEAgX0DdGtWUdY2Bq9uYseO9KWvNx4lla+fOs1kzZ9oqq/S3Ht262yeffmrbbLWF94PM3wmvEUAAAQQQQAABBBBAAAEEykOgpqbGOlevFAZTrQkZyPC8cxfL7rrbbpYJHSBrQkqye/fu4fYcK3nwGG95UB40nCUCCCCAAAIIIIAAAggggEC+gOLCTuGWHnPmzglD6phln3vuORs0aN3QxrXS3h450gZvunG4/2N9/nYLvg4pzYbH/mnJiKes4bPPfHlmtdWsYvudLLP7XmHP2QW3KTUnqbWGT2+1hi+GWcOM9xv31znUa5X9LLP6UaFHZ1WprRdYVpvU2S1j7rYHvnzU3pv5kS8fVL2WDe2zh327/yFWVdHK+i1wBGYggAACCCyvAvPCrawefvjhcC+sFWyfffZZXk+T80IAAQQQQKBZAXVr7Nixg82aM8/qG+osW925c7jHY0+rVUAY+kBqAB2Vkv0fJ0+yhksvtOqpU6xz166WXW1V36auZp7NuO8um/nEvyzzs/PNwn5bVOaNt/qXv2PVFeOsc5euVtWzcX+1NVNtxujf2szP77bKLW40W6Fvi3Y3rmaCHTPyNBtTOSHcv6SrDejduL/JNTPs6ol/sTvHD7O/bniN9evQu0X7YyUEEEAAgeVb4PXXX7cvvvjCNtlkExswYEBolVNjjz/+eGiq09n23nvv5fvkOTsEEEAAAQRKCGgwnZVWWsmmzZjpa2U32XjjMGBOfUgYZm311Va3Pr17l85AhkAzCcFj15kzrEvfENCFiDSWbPimtnuYVzlpkk275AKruPTXIRPZTOZQmccQPHbNTrSuPfo12V9Vh47Wo3cnq5w80aa9fJxltr7fLNMhHq7gVJlHBY/jq6ZY37z9dQz769irk40P+/v2W6fZQ4Nvtg6tzGwWPCgzEUAAAQTatcBrr71mL730knXr1i2MCbBK+iWqvkwt+YVquz5rKo8AAggggEDzAmqdqn6QasraUN9g2foQEGbC6Do+I2Qgde+Pkn8sH3vEM4/5wWN66PDHtkvPnlY/frzNfGy42TdLN/1JPrvNM48xeMyJR32XoTYhsOxl9RPGhUzk7Vax2jHpoQo9+dvYezzzmAaPX8W381dPrFfY39iJ4+zWsffacSsfVmg3zEMAAQQQKBOBO+64w5SB1N++YcOGmYLJo446Kv1bqPm6T/KNN97o84477jjr379/mehwmggggAACCDS2TtXfQ4VW2YqQkgyzPAupORqutWQA+exT3mw1rFTcMixT09YZYV3bs3TTnyT0eVSzVe2v0C41T0Gk1pkR1rVVv138uGGJ+jx27da4Pz/D/LW92iEo7dzV1z2236H5a/AaAQQQQKCMBPqGljPV1dU2d+5c69WrlzdhjX8HNZ06dapdf/31Pj322GNt5ZVXLv13sozsOFUEEEAAgfIQaMw+1nvMlvVIsiEEkCEdqUDSXxeK5ObbJB+PsuxaazUrpeasDR+NsooS+9JOGqaNtKrea1tIfhYt2kXVCh2tYfrblmlmf2/NeNfW6rt22HHR3ek0rWPY38gZ7/EhoAQTixBAAIFyENhpp53s888/t4kTJ9qWW25pW2+9tc0Mt7dS0fT3v/+9TZ482Y488kgbPHgwfzfK4U3BOSKAAAIINBFQK9WGEId16Rpu46EXdaFda2W2MqT6KppvwtpkVyVeKNALTWPjt7gl1mzZIu0vjJy6uPan/WQX4/5adhKshQACCCDQVgXi3xdN40N1HT16tFeZzGNbvXLUCwEEEEBgSQvEv4v9+vWzxgxk+GNZHzKQDSGQVHoy/hEtVJHKNda0ujC8uTKMpUpdGMFOt/WoV+BXomS6bmi186aZBswptmqIa8ONK+dZJtzWQ5FvqbJR5/VsyryZpgFzCjZh1cZhf/PC/nRbj1LnWuo4LEMAAQQQWH4E4t8Cjb4a/0jGs9twww1tZLjN1U033WRnnnlmGMo8/H2hIIAAAgggUG4CHodVWOVJJ3//gkrvB2k2bdo0692zhweRRT3CH9eKN16zTqG/SNESIr5pYSTWubvuacla6xRdTQsqGsINKSc9a51W6uw3psxfWcGjMqPTpkyyef2OsKTLJvmrNHk9p2GuPTP9RasO+ytY5u9v0tRJdnSPA23TlTYouBozEUAAAQTKR2DMmDH24Ycf2pdffuljAWgk1ieeeML7Rp5xxhn2/vvvm9aZFP62bbrppuUDw5kigAACCCAwX+DLCZPCuDTehDUMnFPfdOCc+E1sIa36nXe1GU897rfq0GirC6QNQ7A3PfyBnR52rnUXWJ630/qVD7UZY+71W3VotFUNmBOTjGnwGG67MaM+3F4krJsuzNtPfHl47/3t7gn/sAlhG4226mnImLScHzxODMv61vY0rVvqXOM+mSKAAAIILN8C6vv41ltv+b0gX375Zdtiiy3870P8G3H00UfblVdeaf/9739t0KBB3ldy+Rbh7BBAAAEEEPhKQN0eKzKNd+uoGPnu+0lDGESntrbGxo8bb4PWWbP0fSDDfiqmTLbsry+1LtOn+Wir2Q6N92ZUs9UZIYs5vXMXqzvjbEu69/jqqCWeVdR8aZWvn2RdKr/00VarOjQ2j1Wz1enhGB48bvpHSzr0KbGXrxaNr51oJ3xwpo2rmuSjra4wf39qtjo17K9fCB7/vO4V1rdKASYFAQQQQACBRgEFjPojSUEAAQQQQACBrwQyocXqex+M8nslV7z59nshgAz9HxvqvXnOBoPWCcFk7VdrF3sWbvdR+cRjlnnuGUvGfOFrVfRfxRq23cHqd9k93CAkW2zLwvOTWqsc83erGPeQJTNHNe6vek1L+u1r9f0PD1FrVeHtisytTers9gn324OTHrOPZn/qa6214uq2f8/d7YjeB1hVGECHggACCCCAAAIIIIAAAgggUFqgqqrK3nrnPVt1wKqhO+PId7yFThLuo/HZZ5/Z+uuuXboPZOl9sxQBBBBAAAEEEEAAAQQQQGA5EugQWpy+OfJdv1dyGIU13DIxZB91H8hMRcab7igjSUEAAQQQQAABBBBAAAEEEEAgbaEaunlkFSxmMpXe77EhZCGbu40HfAgggAACCCCAAAIIIIAAAuUj4IPohOBRt33M9unZzbOOuvfVvNkzab5aPu8DzhQBBBBAAAEEEEAAAQQQaFZAScZuXVayPr26W2jCqhFYa9PhyjXCTn2ILCkIIIAAAggggAACCCCAAAIIxNtaaeoBZDaMmKoMZGy+GleACgEEEEAAAQQQQAABBBBAoLwF1IRVMWJj98eQcawLt+RQ0QwKAggggAACCCCAAAIIIIAAAlEgN07MTps+wwPIMBirzZo9xz788EObO3duXJcpAggggAACCCCAAAIIIIBAGQt06tTJGkLAOGPmrDAKa0hFZiorQ/ax3iqzlbb7rnv4oDpl7MOpI4AAAggggAACCCCAAAIIzBdQ89Xhjz4WgsgQO+pFRVhQV1fvg+mofSsFAQQQQAABBBBAAAEEEEAAAQl4jBjCREWKGc2oC6OuNoaNBI/yoCCAAAIIIIAAAggggAACCDQK+AA69Q2NGcgwnI6PqKOoMpMJN4dkIB3eJwgggAACCCCAAAIIIIAAAjkCutWjHlnNU9CoqFKjseo+kBQEEEAAAQQQQAABBBBAAAEEJKBko2796ElHjb5a6UFjeKb/QyBJQQABBBBAAAEEEEAAAQQQQEACnmyc3+0xk4Tso0bTaQjjspJ95A2CAAIIIIAAAggggAACCCCQK6DMo+LG+vCY3141jMQ6f/wcLaQggAACCCCAAAIIIIAAAgggEAUqwng5ykRm9c+LL7xoHVboaD26d/OZBJGRiSkCCCCAAAIIIIAAAgggUN4Cihk9eKysDPeBDB0fH374YRvxzNON9/cobxvOHgEEEEAAAQQQQAABBBBAIEegsQlr46CrFbvtsWfy9sh3wuLEunfrbm+88T8CyRwsniKAAAIIIIAAAggggAAC5S5w/4MP2iqrDLDMoYceYquutqpttNHGduDBBxI8lvs7g/NHAAEEEEAAAQQQQAABBPIFws06NOhqZvDgIdazR3fr37+fDR68af5qvEYAAQQQQAABBBBAAAEEEChjgYYw+qpKfX2dZSorNRCrRtQxa6hvXOBL+QcBBBBAAAEEEEAAAQQQQKDsBfx2j+FmHeoLmVHgqBF1vGNk6AdJQQABBBBAAAEEEEAAAQQQQKCJQAgV60PCMVNfXx+CR7O62tqQh+QekE2QeIEAAggggAACCCCAAAIIIJCOlZNR8KjRdF57/Q37aNQoz0bigwACCCCAAAIIIIAAAggggIAE1GK1MfE4vwnrzrvsZNlspV3166sQQgABBBBAAAEEEEAAAQQQQCAViN0dkzCYTlaD6KwxcA27/vfX26effpqmJtO1eYIAAggggAACCCCAAAIIIFD2AhW6jUfS0DhwjoZm9fasZc8CAAIIIIAAAggggAACCCCAQK6A4kZ1f8zUhUF0MiELGYdmzV2J5wggsOQEbrrpJvvtb39rDz74oD300EP29ttvW7zHjo76wx/+0C6++OLFXoGJEyfajjvuaM8///xi33fuDl944QU79NBDc2ct0eePPvqoW8ozPoYPH170mFdccYX97ne/K7qcBWaLw2jcuHF266232q9+9St74oknrK6ubrHSXnPNNXbVVctP94tXX33VDjjggEU2euutt9KfA/1++eSTTxZ5n0trB0vqd19L6n/QQQfZiy++2JJVl9g6unbF6jBs2DDbbbfdrKamZokdv9COl9Zx//Of/yzVvxuFzpV5CCBQXCAJd+zQZ9WsAkd1iNQLtW2lIIDA0hH4zne+4wdad911bdq0aTZ+/HgP7P7xj3/YSiut1OTnUR8mzjzzTHv66aebzF+YmurnPD4WZvuWbjN27Fh77LHHSq6+xx572E9+8hP7xje+UXK9liw85phjPDjp0qVLunrPnj1tzz339Nf5x/rf//5n1dXV6bo8MVvcRn/605/sxBNPtL59+9qaa65pF1xwgW299dZ29913m67N4iivv/76Yg9KF0e9FnYfX375pT3yyCMLu3m63R//+Ef7y1/+Yv369bM5c+aYAvn+/fub5u+zzz7pem3xybL8LKIvoo499thlyqJr9MEHH1ihL8Dyf3fn/8wuqYrnH3dJHUfv09y/G0vr/JbU+bBfBJY3AcWNugVkaLVaYZUeRNZxG4/l7SpzPm1aQB+q9QHvvffeMwVb999/vweI//rXv7ze1157rf385z/351OmTLERI0YsllGS9cH9qaee8g/yyxpI3zZPmDBhsVXj8ssvt1FhNOn4ePnll9N9L+5jpTtejp4sTqOXXnrJfvCDH/h7eMyYMfbcc8/ZK6+8YiNHjrRLLrlkOVJru6eyww47+M+Cfr989NFHtssuu9hhhx1mujZtueT+7mvL9VwWddt33309wOrQoYMffnH+zJY6n/zjllp3cS5bWue3OOvMvhBYXgW8lZz3fEzUB7LBM5AeUYa0JAUBBJa+gL7I2X333W2FFVawSZMmeQW+973v2S9+8Qt74IEH7Nvf/rbPGzhwYNpc74svvjA1t+rRo4etttpqnqGsDfdzVdFQyz/72c9snXXWse7du9vQoUPt888/92VqQrj66qv7h/nZs2f788suu8wGDRpkffr0sdNOO81mzpzp6y6Of9S8UMGyMiEKKNTiQfXUueg4aq626667+qFU73POOcfr3bVrV9trr718cC8tVF3VDHL06NGtqlaxY2knU6dO9WMo47vxxhvbM888k+774Ycftm222cazlKqfmhaqRLPzzjvP7WJzw3g9unXr5vu6/vrr031pndzXTz75pHvn7k/NlddYYw3T9gqE//rXv9qAAQNMDsriyW1RS/Rda621/Jocd9xxfj4La/T3v//d4hce+XVTs9X11lvPs456f6tsuOGGduWVV6bvcb0X9T5dddVVPeuuptXKvKgoSyn/k08+2Tp37mx33HGHz//b3/5mm2yyia9/yCGH2IwZM3y+/tFAcPqgKzO930466aS0qZ/2t+2223rGu1evXjZ48GD/AidurOun66Sfp7XXXtvOOuusJk3K43oLM9V7SXXWz7dMZBOLvkBSlmXFFVe0IUOGLBDcldq2lH/cf5wqA3zjjTfaRhttZFdffXWcbWqaKBcdX976IisWNZOUoSz1u0GB3QYbbGD//ve/fZVi76e4vequfXfq1Mm9c/dd6rjxd5/209x1i8damKnef6eccor/LOh31G9+85smuyn1e1QrqhuCrqvs9F7Uvv7v//4v3Uex3yFaoTXXLt1heKLm+V//+teb/R2a/zMe91HqmpT6GYjH1X6W5DWJ9Sz2Oym+5/S3Lf9vRNyWKQIILBkBxYppEPniy68kL7z4UvL8Cy8md959dxI+pISfTwoCCCxpgfDjnYQPHUloppSED3ZJ+OCbhA+XyeTJk/3Q+++/f3LqqacmIchJ/vCHP+jbneTNN99MQsYuCX9ck/BBMAkZhuTZZ59N7rrrriQEislFF13k24YgzF/fe++9SejrmIQmor7v8IEw0UP70nbhw7c/1770OnxIT8KH9eSWW25Z4PRD1jIJH4ALPkI/tAXWv++++3zf4QNkErKnyT333JOEP/jJT3/60/C9VUMS+nwm4YNlEoKl5MMPP/Ttzz33XF8nfEBJQjCX7Lzzzkn4gObLQp9K39/vf//7BY6lGeEDYBI+vCXhw236eOONN4oe61vf+lZSWVnptjr3ECQmIRD3ff/3v/9NOnbs6J4ha5Ycf/zxvv/QfzQ107UKfcuS999/36/HpptumoQvARLVM2SWk5AhSGSgstVWWyW//OUv/bn+Cc2Uff96Hq/BFltskYTMUPLrX//azzMEE76v2267LQm/tJPQtE6rNykh+C54PXSdQqDdZF29uPDCC5PevXsn4cN7EppDJ+uvv34ih2LXo5SR9hcCP79Gep5fdN1Vv1LlzjvvdNfwJYm/T7fbbrskZMl8E/1M6H0avjzx90Jo2pmELGaSzWYTvb91XX784x/7OkcffbRvo/pqezlqn+GDvV9fLYz7CwFREjLTvq2c9POln6cQ3Pq56Bgh0ElCIOnvVd9x3j+hKWhBd/085hftX+9N1Tk0m05CYJqEgNp/jufNm5eED8LJTjvt5Oemn7/QrNr3rf2U2lbLS/mHL2uSEJhqtSZF78MQTPo8Oel9Glo6JOELkuT8889PqqqqkpD18eXf//73/f0Sggf//aDz0zXR+0el2PtJy2QsX/286/nZZ5/t5/3OO+/49Sl13Pi7T/spdd20PLe09ufhjDPOSMIXNol+T+r3TWhe3eT8Sv0eDf15/ecyfMnndjpP2cT3YqnfIarzwlw7baffByuvvHLRn9mFvSbN/QzE46oOS/Ka6Hem/k4U+51U6m+E6kZBAIElK3DnXXcnzz73fGIKIJ8PH3hGPPtccs+9jR92luyh2TsCCEhAHzb00AfXkPHwD24hA5KEb4EdKPdDVOgT5evGL3j0QVTbhoxLiql5CtRUtL+QZUiXhSZsvr4+yBUKIGOgow1CVjMJzdzSbeOTkC1MXnvttYIPBbX5JQaQMTjUcgWL+sAci4JVfWiORfUOGar40j9k68Od6qyifUWDdKX5T/QhXUG0gsD4CJmMdLX8YynY+OY3v5kuVyAvUwXwISvm10XnpUfol+PL9EE6BnwKHmORi7YNzTN9fW0T+pmlji0JIP/5z3/67vTBSYF1bhCvD/xhwJ94uHSqILHYNQnZlXS9+CRkNJPQDzGtY8hyer3juq0x0j5Dv10PcuL+c6errLJKEgbhyZ1V9LmurwJEBTAKLFT0IVX10QfbWEJ/WQ/G42tN9QVD/NAe58+aNct/jvR+UsCoov3JNe5P6+hLAr2/4s9TbtAdsm1JyAjHXTaZ6joXcs99rzfZILzQdQ1N0ZOQcXTzkIX2IFjvm9A6IF1dXwIp8MothbbV8lL+xQJI/bzpixNdcwV1Cppyy/bbb5/IWUWBSsicp4s/++wzr3sMIEu9n/QztOWWW6bb6knIfiWheXmzx8393VfqujXZeXjR2p8HXd/QQiLdzbvvvtvk/Er9HtWXewr8c4t+zuN7sdTvEG2zMNdO2+UGcnqd/zO7sNekuZ+B3OMuyWsSA0idm0r++TX3N6JxK/5FAIElIaC/RXfdfU/y7PP/SbLhAOFmkNl0IJ3wx4yCAAJLQUBNptQXLA6mM336dB/c4oQTTjANpFOqaMRWDQCjpquxqEmeSvgw7v2d1FQuFjVBU9NIbRcyZXF2OlVTyVjUnFD9pfKLmnkW2jZ/vdzX4YOwqSlVLCHj5ftW07GQSYqzfRrrrWaOsaip4YEHHhhfNtlXOjPniZpHRs+c2UWf5p53tFQ9NGql+uqpmVRuUd9K9SNT0fWLReuqhAxanGXqtxqvSTqzxBOdq4qae8omdzCgEOgU7P8agjTToyVF5xU+YNsFF1xgGrlURXVUUdO1eP4+I+efYkZaRc0aixVd65CdLbbY56u5qt7v6h+pZo65zVG1gpqT5r5P1NxTTShzS+7rEBx5E+gQ6Pj7Xc3Bc6+J6hv3p2aH6g+sJsn6uQgfVJtYqv4ff/yxD0CjuuWW3GPmzi/0PGQZLWRKLXwAt7lz53qTcq0X/hBbCFj85zjXOHffpbbVPkr5a3mhonPVuYUg0s9bz3OLXmsdvV80sFfu+0KD8IQMpa/e3PspZBoXuFZ77723bxvrUOi4ufPi82LXLS6P09b+POj65p6/BjSL7w+dn34PFvs9qi4B6gqQW9QsP5ZSv0O0zsJcu7jvYtNFuSa33357yZ+B/GMuiWuSf4z81/GalPobkb8NrxFAYPEJ6POJHuEbUctWr9j4hzEbbuWxYqeO/kdNbVwpCCCwdAUUMIRmjBa+gS16YH3o1M+n+iuq/6BGrFNwqKIgQB9QFbDpQ58+HMWiQCE0h1sgIIrLWzLVh3f1zStUDj/8cB9aPn+ZPgCrXjHIUZ1Ut/ghTevrSyyVkHkyfQBTUBFHTtWHe33IViC2OH4vxWP5AUv8oz5pqnOhURAL9Q8N34r7L1XdKiE38IuH0PlqdM1YdC0WR1FfOvWnLFQUTKv/ayzylX3I8pUMsltqFPdbbLrZZpt5Py99MZJroj6MGhhDfUI1SJTeIwrM9cWFRm1Vn8hiRe/t0DSwyeL4IV/v/dDU2PugheaE3kdS/YoVfDdX9EWBglfd4iYG8qqTArv84FH7KtZPWPULWb0mh1OfM53X448/7v0B5RGvi9bX+ylkrC00LfbtdNxYSm0b12nNVOenIFt9TVV03qFVQpNd6PjqD6z3i4JZjUoaAz/1fQwZXF+/ufeTgrH8WwXpi5aQ1Sx53CaVaeWL1v486PrmeuuLB325pRLPr9jvUf1OUj9l/Y7SlxEaSTs0hbfQ7N63L/U7xFdYjP/En9lY52I/481dk9b8DLS0+q25JsX2mXt+S/pvRLE6MB8BBBo/r63Qoco6V69kHinGPwjCWRwf0kBGAIHmBfTHWt/S6xGaD9l1111nN998s4VmUQtsrG/+VRRc6gOnBm7QgCvf/e53/QOQRlXUwAoa1VVlv/32s9AUzj+o6wOQBqXQhyUN0rGwRZkHZWwKPQp9yI7H0QAw+pCvD5Oh/5WFZqNxkX+Y1AdUfYBW0WA/qrdGnFUwdky4NUdoaurL9AFN982MgwH5zLx/tCz0E00fso1FH1xzjxXnF5rqA7M+8N9www1eNw0gIb/8D8RxW2VmtVznqnorw6IRMBXIqCjLoYyERiENzRwt9HOMmy7SVFnoQtdD85Rhyi8aYCb0kTLdo1MBrQb80HtJX0yotMZI62sgkGIBrAZH0t8W3QtUt6HRlxj6MKmBlHQcFQ0MFL8U0e04mrufo75Y0K1s9LOikV11n8oYAOlDZnwoKFVGpVjd/OA5/+j6KbjW9dPPi3w0gJW8CpVi5sry5xcFJKqXvrXV+zz0u0tX0XH1sx2Pq3O79NJL0+WlttVKpfy1XMGqfh5kpIBdt8tRXfQzpqL3uX7W5KmRWkNfa79XZwwYFeDrXqkHH3ywZ4o1oE7ulz+l3k9api8KdE3jvjWAjwY6au64XrmF+Ke1Pw8apEuDV6me+rnU+eWWUr9H9WWF3mcaeCg0Z/Vp7mep5n6HtPTa5f4+UwYuv+T/zC7sNWntz0B+PYq9bu01yd9P/vmV+huRvy2vEUBg8Qvob5mXcMPaRA91+M7t0xP+yFAQQGAJCoQfQKXe0kf4ZjUJAWESAkQ/avhD6YPoxCqoT134wU00iICK+lKFoNEHctDAFxqQJ3xg9GXhg0Zy1FFH+YAc2iZkg/znXAu1TMfVwDE6lp6rb2Qsp59+ehI+OMWXCz1VXxYNUKGBbVSH8O14or5N4Rv7dJ8aECc0jfUBfjQzfABLQtDo/V5UrxB4+e8mLdMgPpqn/pyFSsjEppZaTw8NGBNL/rGOOOKIJDSfjIuTEGz6NuqbpKKBizTQhfajOobmxj6/kJkWqF+cnMOXcH6+ul5xQKQQlPg5xn3pHDXAi0qh/YWMXaL+lrGon2yhPpBxeUun4QNvovMOH+r8vNSfSIOHxNJaI/mGoD5uvsBUf1fUL0x97nTu4YsGH7AlBEa+rvoR6n2vZRq0JjQ/TkJw5svCCJcF+yCqH63W0Tbad/jAnPY702BOOoaWbb755j6gThgZs+j+QpY5CRlRXx6Cft9G71X5yElei1rU11I/T9qvHhr4R1MNwqISgmt/n6vO8tTPn/pmqjS3bSl/DSijfeqh96T6isoifMHh+47/hC9JvM+w1gtfgiT5g1Spr6bqrHrJSD8LsQ9kc+8n9ZULzTy9DvpdoH6lsZQ6bu7vvkLvg9zrFve3MFP56v2j35+6Jur7qT536qupUur3qJbr5zqMYO2/R/T7Tj/XsQ+klhf7HaJlLb128RpqGrKl3gdSgzjFkv8zuyjXpNTPgPpAxuMuyWuiAazUlz2W/PMr9TcibsMUAQSWnIBiRfWZrtAvDH1rpm+B9e29vr2iIIBA2xQIHw68D1JuSwFlMtXXUM2X8osyGGrap2+Bl2VRM6/w68ybFebXQ3XU75/c+muetslt+qiba4cPExaCjvxdtPh1oWM1t7GyRuqLVyijV2hbXQ+tq2Zt+UV98nROsR9Z/vKl9Vq/80PgmjalzD1uS42UUZSLmjaraVypoia76k+npr6FHOWi7F2hZYX2q/eL9qnj5xfVX8tiU9T85c291vVTRj0309bcNi1ZLu8QpBT8GdD24csGN8j92Y77LbRta/zjfkpNdfx8T2UflfkPo5H6pmoBoVsHqUWBbgsSS6n3k9bR9VXWtlApdNxC6y3JeSGQ9GtT6GdWx9V7Kv/3qLLUIUD2DKb6A+o9p/e3Msyx5UGsc/7vkMV97Qr9zC7KNVlSPwPRo7XTQuenefl/I1q7X9ZHAIHWCehzXBjwz1tcZfWHWDMoCCDQ9gUUKOYXDf5RrOhD8LIOHlW3Yh/MtKzQB3XNyw0etZ4CFfVpW5RS6FjN7S9kCppbpcnyUtej2IfoJjtYCi8UwMZ+ePmHa6mR+qaG7GGzwaP2r+BQj2KltS4KsvKDnbhv1X9hg0fto9T1i8dYmGlzP4fFzkfHKrRta/xbUt9Cx1fTa90bU025NYiWmoTrvpy5waP2Xer9pOWlrm+h42qbpVl0bqWK3lP510D9QxVEqh+pHmpqqgF3QhZygV3l/w5Z3Neu0M/solyTJfUzsABMC2cUOj/Ny/8b0cLdsRoCCCykgL4EVdcTxY0+DKL+GGuGfiA1UytQEEAAgbYkoL6QuSOftqW6lWNdFDxqZFHKshFYGv7qM6mRdBUoKdujfnK5I2AumzNvG0dV8KI+zRo4R623FFRrELSWDNq0NK5d21CiFgggsDwJKEZUSyElHyvU/1Enp+YZGpSAJqzL06XmXBBAAAEEEEAAAQQQQACBRRdQE1YN/pZRttEjyTAl87josOwBAQQQQAABBBBAAAEEEFieBJSBjF0fM/GJUpJqyqrXFAQQQAABBBBAAAEEEEAAAQSiQLz9VjZmIBVVatSuQiPAxY2YIoAAAggggAACCCCAAAIIlJeAYkYN0KVYMaNTj0Ona4ECSQoCCCCAAAIIIIAAAggggAACElCMqAyk4sWMXsRHDCRhQgABBBBAAAEEEEAAAQQQQEACMdGo7o4+iI5HkiEdqUBSzykIIIAAAggggAACCCCAAAIIRIEYJ3oTVqUj9YiZyLgSUwQQQAABBBBAAAEEEEAAgfIWUJyoks1mG5uwqjNkBdnH8n5XcPYIIIAAAggggAACCCCAQAGB2IS1rq6usQmr1slmKz0DWWB9ZiGAAAIIIIAAAggggAACCJS5gHd9VEdIPamrrfN7QMa2rWVuw+kjgAACCCCAAAIIIIAAAgjkCKjlajb2e8yoPWuYQUEAAQQQQAABBBBAAAEEEEAgCsSko8bNyejWHQocG0IfyIaG+rgOUwQQQAABBBBAAAEEEEAAAQTSRKPixnQUVo2oE+7wAQ8CCCCAAAIIIIAAAggggAACTQTU1dHvA6k0pLKQ3AOyiQ8vEEAAAQQQQAABBBBAAAEE5gvEsXJCFrKx36OiSZV4j4/56zFBAAEEEEAAAQQQQAABBBAoYwHFiJ59VBPWOIhO7BhZxi6cOgIIIIAAAggggAACCCCAQJ6Aso9pEKnmqwoe1QdS2ciYmszbhpcIIIAAAggggAACCCCAAAJlLJAOoiMDBZHqD0lBAAEEEEAAAQQQQAABBBBAIF/AA8i6uro0+5i/Aq8RQAABBBBAAAEEEEAAAQQQUBNWJRyziiL1JPaBvOoFsxk1ACGAAAIIIIAAAggggAACCCBg1qWj2drzB18N8WMYSWd+EKlpghACCCCAAAIIIIAAAggggAAC8wUa6hvSsXIyyjzq4cFjSEuGAXYoCCCAAAIIIIAAAggggAACCLhARUg0KmZU8ZtAauTVOBprMn+BL+UfBBBAAAEEEEAAAQQQQACBshaISUb1g8xKImYhFUQquqQggAACCCCAAAIIIIAAAgggIIGGerVUrfBWq1mPIsM9IGtqajyQDEHlAmX9cXctMI8ZCCCwdAQOPfTQpXMgjoIAAggggAACCCCAQBC48JmmDBWZCg8gveujIslY9JwmrFGDKQIIIIAAAggggAACCCCAQNKQpOPmeBPW2traVEWD6VAQQKDtCcycOdPmzp3b9ipGjRBAAAEEEEAAAQTavUDHjh2turq66HnExKMHkFVVVd6EVc1ZKQgg0DYFFDz26tWrbVaOWiGAAAIIIIAAAgi0a4GJEycWDSDVhFXFuz8q46gMpDdfVQD5VYvWdg1A5RFYXgUqLuSHdHm9tpwXAggggAACCCCwLASS80snEtWEVfGiHtmPPx1t9fX1Cidt7LgJlvRZFlXmmAgggAACCCCAAAIIIIAAAm1RQBnI0V+Ms4ak0rKrr9o/vY1HttLsHW/GSoajLV446oQAAggggAACCCCAAAIILG0BNV0dsEo/69+/r/mIOWrGqixkXV1daMJK8Li0LwjHQwABBBBAAAEEEEAAAQTaqkBovOrNVxU3ZtSOVffziG1aCR/b6mWjXggggAACCCCAAAIIIIDA0hdIrPE2HspEZvSPHpWVlf5IkoalXyOOiAACCCCAAAIIIIAAAggg0DYFwhg7SjrqkVXmMQaRPhor94FsmxeNWiGAAAIIIIAAAggggAACy0BAg+jo1o/ehFXHV/ZRxYPJMEQrBQEEEEAAAQQQQAABBBBAAAEJ6DYeGjNH8WLahDU2Y+U+kLxJEEAAAQQQQAABBBBAAAEEUoH5rVbVhNUH0fFIMm26yjA6KRRPEEAAAQQQQAABBBBAAIEyFwjxo2cfxeC38VA6Ug9FlKFDZJnzcPoIIIAAAggggAACCCCAAAJRQE1YVbLZbGMTVnWGVBZSDwoCCCCAAAIIIIAAAggggAACUUCD6KjLY11dXWMTVi1QNKmZFAQQQAABBBBAAAEEEEAAAQTyBbzro5qt6omiSX9eSRYyH4rXCCCAAAIIIIAAAggggEC5CsSGqmq5mo33gPR7eoQZSegGSUEAAQQQQAABBBBAAAEEEEBAAvV1jUlHjZuT0T0gFTwq+1hbWxuykSAhgAACCCCAAAIIIIAAAggg0ChQEeJFFU866kkchfX222/XSwoCCCCAAAIIIIAAAggggAACqYC6PSrpmFHwqCzksGHD7PPPPycDmRLxBAEEEEAAAQQQQAABBBBAQALxjh0hC5mxGTNm2PPPP289evQIUSUjsfIWQQABBBBAAAEEEEAAAQQQmC8Q7tbh2ccQO2Y0iM4777zjzVjXXXddM+JH3icIIIAAAggggAACCCCAAALzBeJ9IBVEZtV8ddy4cZ6SfPHFF231I9reKDpjx4610aNHF7yAXbt2NQ98Cy5lZlsXuPHGG03X8KCDDmpVVd9//337xz/+YaeffnqrtmNlBBBAAAEEEEAAAQQQWDgBtV7NatOamhpTJnKNNdYI04Xb2ZLc6s033/Q+mjrGzJkzfbTY7t27+yE32GADAsjFjP/BBx/YrbfeahdccEHa1nkxHyLdXWxLnc5o4ZOpU6fa66+/3sK1WQ0BBBBAAAEEEEAAAQQWVcADyLq6OuvSpYsHCiuvvPKi7nOJbL/77rubHip33HGHN7n9xS9+sUSOxU7NZs2aZe+++65/qbCwAV5LHY877riWrsp6CCCAAAIIIIAAAgggsAwElGRUwlEDsGYVRa6++uo+48MPP7QBy6BCi3pIjSCrbNS5556b7uqqq66yVVZZxYYOHerNHPfdd1/717/+ZRMnTrSNNtrIvvvd7/qgQdpg8uTJdtNNN5kynb169bLddtvN9thjj3Rf8YkycltssYXtvffePmvatGl29tln22mnneZZ0FdeecUefPBB+/jjj23gwIG233772de//nVf98orr7SNN9443e9bb71lf/7zn+03v/mNzZs3z+u444472tNPP21rrrmmnXHGGfGwPtUF+/vf/27/+c9/bPr06TZo0CA/h969e/s8NefUdRwxYoQdfPDBNnz4cPv5z39u/fv39+2feuopn3fZZZfZdddd518afPHFF6Z6DBgwwJuQ6txeeuklu+GGG3ybH/zgB7bXXnvZPvvs40Zqbvr2229bdXW1bbnllvatb33L7wVTqm7aUSmXP/7xj9azZ0+vs+qlfX/66aem96K81LRVHsXKPffcY48++qjXQ9dN565S6prqOJ06dbKPPvrIRo0aZX/72998JGL5ajCpuXPn2pAhQ+z444+3FVZYodihmY8AAggggAACCCCAQFkIhJDRP2/rZEP8mPHgp0+fPvbll1+2yzF0Nt10Uw+EFBCpqHmjAqFNNtnEA+NJkybZvffe6wHPT3/6U5syZYpdccUVvq6iaAVVChrOOeccDw7/+te/+va+Qs4/66+/vj355JPpHPUZ1fZrr722BzwKWhWcKjuqOik4VF89FdVp9uzZ6bZqNqxgVkUBmOr4wgsveNBy5JFHpuvFJ3fddZcHSkcccYSdddZZ3oz38ssv98Wqu5qdap8/+9nPbKeddrIOHTp4YBm3f+aZZ9KmvgpAH374Ya+36qpg9JprrvF+pqr/YYcd5pvJaocddvBz/OUvf+n117GPOuooe/zxxz2g1Yql6qZAsJSL6qJRgFX0XMGgAmkdW68VIBYrc+bMMfWP1brf+MY37O6773aH5q6p9vvvf//btt9+e7vooossm836+0PndMwxx3gwr3r/4Q9/KHZo5iOAAAIIIIAAAgggUDYCDfUNade2jEbSUQCjoEDZlnB/yHZXlHlTxk/ZORUFdsrMrbfeeum5KChShk19Jk888UTPPE2YMMHvfamMlwKHvn372mabbebBnzJR+UWBje6VGQf00fEUhCgIf/nllz1TpuMoY3bIIYfYOuus4/Pz91Psta6Bjl+oKfFzzz3n2bitttrKFMj+6Ec/8mybmiCrdOzY0U466SRfpibJCiLjOSh4VeZQ82LZcMMNfXvV9dhjj/XM6//+9z9bccUV3U7rKTOpfcVzVkZSwaayqjq/uP9SdWutizKbctZ1+uY3v2mvvfaaB7Cx3rlTNa9VlnCttdbyc1lppZU8e6n6NndNt912W9tzzz09iNY+FTwq66wBmXTe+++/v5+ffj4oCCCAAAIIIIAAAgiUs0BFJuO38ZCBD6KjD+IKwhRETfEPzCFH2c6KgiM1UVUTRgV2CkJy++8pKIhFTVtVlLHUoDwq5513nk/1j/oAyiO/9OvXzwMo7V/NJXX7EwUwKtpX3G/cTq9jsBnnlZpqNNJCRUHi+PHjbdVVV00XK7BTsBWLmn5qRN1YlDlUk0wFUwoedf65TUFzPeSkpq4xgxv3Eac6BwWouk9oLDo3BeDKqpaqW2td1Jw1FjUnVjZRQVzuucXlqpMCXhUF8RpYqba2NjUvdU1zreWrJq/Kdj7yyCO+P70HVDRf9aAggAACCCCAAAIIIFCuAiFc8KLEoweQ+oCuhzJwU8MH8fZYtttuO+/Lpr6QGgDmlFNOaXIaCnKUuVNRU10VBYQxgPzd736XBiO+sMg/O++8s48Iq4BNAVkMxLQv9anLLTpODPoU4KjPZCy5zVnjvGJTNbFURlXNNQcPHuyrqd+kgrOBIfNaqCjYUxNeBbsjR470gDp3vWgQ5+m1Mqa5RW8QFZ2bmsmq6acCVxWtr2PEjGWxujXn4jtbzP/omCotvabyVeCqrKquLwUBBBBAAAEEEEAAAQS+EmioTzw5p5gm41Fk+ACtoiByfszw1drt5Fnnzp29+ecll1zigaL6dOaWO++80/spKtDRYDAKMhQwK9Oo4OFPf/qTB0XKtp1//vl222235W6ePlcTUu3j5ptvbhKUfe1rX/OMpPrwqY+lsqEaoEbzVZSxe/XVVz3I1H031QexNUXNb9WPU1lPBW8aCObaa68tuQtlYbWNAmo1tc0taq6qfoDKsN13332etVPAqRJvkaJ+pAocFaTmGqlfp7J1am6rUqpuzbn4DhbzP629pjq8zkV9KHVuCvRvueUWH8hIPxMUBBBAAAEEEEAAAQTKWaAiU+EBpD4bZ3Obeep54h+Y22cWUgGTgp6dQnPW/LLNNtvYxRdfbBp4RQHGmWee6QhVVVU+kqqyVaeeeqr3B1XQoz5whYpG71T/uWeffdancR312TvhhBM8YFOAquycmrdqJFGVAw44wAM5jdqqvqZqfprfZDT3WsT9xqn6RypbGgf8UUCq0V/1LYC2K7StAjsV9Xfs1q1b3JVPFQhrpFYFzmrOqVFp1ZdQRT4y0CBABx54oA+qo3oraP3hD3/o9d98882976TWL1W35lwK1Vv7zC3F1tG5Fyqtvabah5pvq9mq3iPK7urLhZNPPtl9Cx2DeQgggAACCCCAAAIIlItA0pB4stFjj3DrikT9xpSJHDNmjL3fax+bUdOUYv1xdzWd0UZfPfHEE3brrbfa9ddf7332VE1l0BQcaBRRNTlVAKnBVgoVLRNKc7duUJZTTVgVcBYqCvS0vFDRiKMKQtVscmGK+gQqwIl9/0rtQ4PnKODTI95OROtfeuml3rQ2Bn7yKBSk6X2hvoe5gZqMNMJroT6JzdWtlEup81iUZS29pvEY6g+p90yx6xfXW5rTQw891A+nUXvVH7PiwvmN0JdmJTgWAggggAACCCCAwHIrkJyf+B0i4tgfFz7T9FSrqxJbd+LDHkN4FKOMjW4BEfu8NV29fbz69a9/7SN2Hn744WnwmF9zBULFgketq8CuVPnkk0/83o0amEYBabFSKvhQU9tFKQrcWhI8ajCYhx56yAaG5qcxE1nouKXqqvdFfill1FzdSh0r/ziL63Wp+hY6hgL7ZVHPQnVhHgIIIIAAAggggAACbUFATVhVvPujgiplmpSB8gCynSY3lGHbe++9m9y6QyepbJnujahRRhe1aAAZ3epBt7LI72O5qPte3NuvscYa3sRU96PMzy7qViMawZSCAAIIIIAAAggggAACCDQnoCasiin0yDYOnNM4Qxu210F08geJiQgKkOPIpXHewk7Vr7HYcRZ2n0tqu9x7YOYfI/d2HvnLeI0AAggggAACCCCAAAII5AooA6nuaio+Ckns4+b98tprBJl7hjxHAAEEEEAAAQQQQAABBBBYLAJqqaruako+pgGkIkoNIBLykovlIOwEAQQQQAABBBBAAAEEEECg/QuExqvefFWJx4zasSqSjG1aCR/b/wXmDBBAAAEEEEAAAQQQQACBxSWQWONtPJSJzOifmJJUWjJJuHH64oJmPwgggAACCCCAAAIIIIBAuxdIzJOOSjxmlXmMQaSPxhrSkhQEEEAAAQQQQAABBBBAAAEEJKBBdHSLP2/CqhnKPKp4MBmGaKUggAACCCCAAAIIIIAAAgggIAHdxkNj5iheTJuwxmasoX8kBQEEEEAAAQQQQAABBBBAAIFGgfmtVn0U1jh4TryVR8hDwoQAAggggAACCCCAAAIIIICAC4T40bOPeuEdHpWO1EMRZegQCRMCCCCAAAIIIIAAAggggAACLqAmrCrZbLaxCauyjzET6Uv4BwEEEEAAAQQQQAABBBBAAIEgoEF01OWxrq6u8T6QUlE0qZkUBBBAAAEEEEAAAQQQQAABBPIFfBAdNVvVE0WT/rySPpD5ULxGAAEEEEAAAQQQQAABBMpVQH0gVdRyNTtx4sT0PpDTp0+3pG/jQv5FAAEEEEAAAQQQQAABBBBAoL6uwaZOnWqdOnWybLdu3TzzqAykZsToEiYEEEAAAQQQQAABBBBAAAEEKkLmsbq62rp27do4CquarlZWViKDAAIIIIAAAggggAACCCCAwAIC6vaouDGj23eoLasG0GkciXWBdZmBAAIIIIAAAggggAACCCBQxgKKFVWyCh5VFE02TjUSKwPpOAb/IIAAAggggAACCCCAAALlLhCSjZ591CA6yjzGh0eV3Mmj3N8enD8CCCCAAAIIIIAAAgggkAroPpAafFW3fsyo76MCSE2VjdRCCgIIIIAAAggggAACCCCAAAJRoG/fvjZgwADLakbMQKo/ZIglKQgg0IYFkvP5IW3Dl4eqIYAAAggggAACy6WAYka/D6Ru36FUpIJHCgIItF2Bjh072ogRI9puBakZAggggAACCCCAQLsVGDJkSNG6xySj+kH6IDoKHvXCR2EtuhkLEEBgWQro3jvbb7/9sqwCx0YAAQQQQAABBBAoQwGNuxrv3JGOwqpMpM8sQxBOGQEEEEAAAQQQQAABBBBAoLBAQ/38ZGO4lYePwtr0XpALbvROv0MXnMkcBBBYKgIXPrNUDsNBEEAAAQQQQAABBBAoKFARUpCTJk2yWbNmNQaQarqq7KOasSZ+P8jGe0MW3JqZCCCAAAIIIIAAAggggAACZSMQwkWbPHmyTZs2zTJPPfWUj8KqLKRu5aHokoIAAggggAACCCCAAAIIIICABBrqE/vf//5no0ePtuyGG27ogaOyj56B5A4BvEsQQAABBBBAAAEEEEAAAQTmC1RkKmzNNde0OXPmWLZPnz7pfSDVlJUmrLxPEEAAAQQQQAABBBBAAAEEokDSkFi3bt0a7wOpG0JqBFYFjypnbEMT1gjFFAEEEEAAAQQQQAABBBAodwHdB/KaF0OyMTzxaDGbzbqJZlAQQAABBBBAAAEEEEAAAQQQiALeUnV+rJipra31vo9aSAAZiZgigAACCCCAAAIIIIAAAghIwDOPYbDVefPmWWb48OEeQCqqjM1YYUIAAQQQQAABBBBAAAEEEEBAAooTu3TpYlOmTLHMvvvu66OwaoFu40EWUhIUBBBAAAEEEEAAAQQQQAABCShG7Nmzp51wwgmNfSAVUeoWHrmD6UCFAAIIIIAAAggggAACCCCAQGytqmkmBo9xJjwIIIAAAggggAACCCCAAAIIRAFlIGNL1Ux8kQmdItWEVZlICgIIIIAAAggggAACCCCAAAJRQHGiHlllHmMQqSasCiQpCCCAAAIIIIAAAggggAACCEhAMaNu/ahY0ZuwKvMYS0xNxtdMEUAAAQQQQAABBBBAAAEEyldAMWJ9fb0DZJWGjBnI3ECyfHk4cwQQQAABBBBAAAEEEEAAgSigDOT48eM9E+kZSM2ITVf1nIIAAggggAACCCCAAAIIIIBAFOjdu7f16dOn8TYesUNkzEbGlZgigAACCCCAAAIIIIAAAgiUt0Ds5uj9IPUiZh3jtLx5OHsEEEAAAQQQQAABBBBAAIEooDhRyUb1gwwtVxtHXVU0GSPLuCJTBBBAAAEEEEAAAQQQQAABBKJAdsqUKZ6BrKmpsRkzZqTZyLgCUwQQQAABBBBAAAEEEEAAgfIWmDlzps2aNcuyPXv2TEdhnTdvXnmrcPYIIIAAAggggAACCCCAAAJNBNR8tUePHtatWzfL6NYdasYaB9JpsiYvEEAAAQQQQAABBBBAAAEEylogdnvUNCsJdYZUH8hYHnjggfiUKQLtWmDo0KHtuv5UHgEEEEAAAQQQQACBtiAQB9LJKnhUFlIZyNxRWDfffPO2UE/qgMBCC7zyyisLvW1b2lDtzefOnduWqkRdEEAAgbIV6Nixo1VXV5ft+XPiCCBQvgIxVswqDanRVxVAqsSRWGOasnyJOHME2oaAgsdevXq1jcpQCwQQQKDMBSZOnEgAWebvAU4fgXIUiPGiN2EdOXKkB43KRH755ZepR4ww0xk8QQABBBBAAAEEEEAAAQQQKDsBxYYxiMxuvPHGplt4aObo0aPTZqxkIMvufcEJI4AAAggggAACCCCAAAJFBRQjZuJSNWFVFpKCAAIIIIAAAggggAACCCCAQL6AB5B1dXU+AisZx3weXiOAAAIIIIAAAggggAACCEhATViVcAxxY8af5I/CChMCCCCAAAIIIIAAAggggAACEogJRw8gYxAZZ0KELq/tegAAQABJREFUAAIIIIAAAggggAACCCCAgARyk41ZvdBDwWO8hYdWYhRWKVAQQAABBBBAAAEEEEAAgfIWUKyomFElM2rUKA8WKysrfWZcUN5EnD0CCCCAAAIIIIAAAggggECugBKOmQ8//NCef/557wepIJJmrLlEPEcAAQQQQAABBBBAAAEEyltAgaNaqCpWzMycOdO23nprFyH7WN5vDM4eAQQQQAABBBBAAAEEEMgXUPCoh3d9PPDAA02ZR5U4M38DXiOAAAIIIIAAAggggAACCJSngDKQHjyGDGRWBLW1talEbMIap+kCniCAAAIIIIAAAggggAACCJSlgJKNKhn9U1VVpUmTUVh9Bv8ggAACCCCAAAIIIIAAAgiUtUAMHn0QndmzZ/sAOpqpGRQEEEAAAQQQQAABBBBAAAEEokAcREcxY2bYsGE2duxY7/8YV2CKAAIIIIAAAggggAACCCCAgAQUONbX1ztGVn0d586d2/gim02zkDFN6Qv4BwEEEEAAAQQQQAABBBBAoCwFlIHUwKsaSCd76KGHOsK8efOsrq4uzUTSnLUs3xucNAIIIIAAAggggAACCCDQREDJRW++qlFYYzoyzoxr6jUFAQQQQAABBBBAAAEEEECgvAWUXFT2UdOM/tFDKcmYlixvHs4eAQQQQAABBBBAAAEEEEAgV0ABpDdhVaYxBpG6HyT3f8xl4jkCCCCAAAIIIIAAAgggUN4Cihl160fFin4fSGUeVWIwWd48nD0CCCCAAAIIIIAAAggggEAUUMJRo7AqXszG7GNsxhpX0kIKAggggAACCCCAAAIIIIBAeQvERGPahFUzYtPVGDjGaXlTcfYIIIAAAggggAACCCCAAAIxPsyOHDnS05GKJr/88kvba6+90EEAAQQQQAABBBBAAAEEEEDABdRaVSWbzVp2gw028NF0dA/Irl27+gL+QQABBBBAAAEEEEAAAQQQQEACyj4qiFTMmElTkSGajJHlojB9+OGH9uc//9n+8Ic/2AsvvLAou2oz27700kt23HHHeX0eeeQRO+CAA6ympqbN1K+tV+QnP/mJXXnllW29mtQPAQQQQAABBBBAAAEESggodsyq6aqe6BYe8bm2iYFlie0XWHTCCSfYPffcY+uss443ix01apTtt99+dv3119tKK620wPr5Mw488EA77bTTbMcdd8xftExfT5gwwZ588kk3kUvuY5lWbCEPvrSd8/vXLmS12QwBBBBAAAEEEEAAAQSWoYA+16ejsPo9PcKMhS1XX3213X///fbQQw/Zdttt57t5/vnnbd9997Wvf/3r9v3vf7/ZXb/88ss2ceLEZtdblit885vfND3ac1nazr/61a/aMxd1RwABBBBAAAEEEECgrAViolG38sjoHpAKHjVTj4UtarZ6+umnp8Gj9rPNNtvYJZdckgaFaiJ70UUX2eDBgz1Lecopp9js2bM9+7nJJpvYzJkzTc0d999//wWqce211y4w/5hjjrFf/vKXvu6YMWPsyCOPtIEDB9qQIUPs/PPPT8/n1ltvtUMOOaTJPrfcckt75pln/Pgbb7yx11NT7aNU+cc//mG77LKLr6I6KZuXW7T9ZZdd5rNUp6OPPtpWX311t5BRsRLXVf032mgjO/fcc91FPvn1K2UR11cTYp3jKqusYt/61rdM+1eWuZCzrsuFF15oX/va17yuOofRo0cXrOoDDzxge+yxh11++eW2xhprmPrQyjo2f9Y11TXcddddrVevXn5MZZVjEBnfAzrWaqut5tfls88+S481fPhw23333b3eeh+89tpr6TKeIIAAAggggAACCCCAwNIXiC0KPek4bdo0mzJlis2aNcsDuFid3GaazT1XE08FKAqs8tc96aST7IILLvD5V1xxhf31r3/1AEvTV1991U499VSrqqrypq8dO3b0JqzXXHPNAvv5xje+4QHfBx984Mt0zIcfftiPqUj4oIMOshkzZthdd91lF198sd1yyy0erKo+06dPt/HjxzfZpwKkOXPmeOCj5wqM1E9PAW7+OeSaaBudq9ZRndS09eOPP/bX48aNs3/+858+X3U67LDD3PW+++4zBVZnn3221zl//1r34IMPtsmTJ9udd97pQbGCXjko4MqvXymLuL6sFdjdfffdpnopKCzmrCD85ptv9iBSTZD1XlBgrE6y+XXVMvUJ/c9//uPWCjxvuOEGU1CrdXVdtC+d+2OPPWYdOnTwLxD0HtPySy+91PvIqm4613nz5tkRRxzhy9544w079thjPYCUowLvQw891N+f+fVoyet43ZgigAACCCCAAAIIIIDAogko2afP9N6EVcOxKvsYI8vW7lp9HVUGhuxZLAoKdBCVzp0722233ebBo/pJqkmrijKWJ598sgcggwYN8mFhBwwY4JktXyHnH2XllD1TM9mzzjrLhg0b5hmsrbfe2t5880179913TYFa//79fasvvvjC+14qeG1JUeC45557tmTVdB3VadNNN/XjnnHGGR6Err322n5+qtNbb73lAwn17t3bz0kBr+qoZr255e2337Z33nnHz2PVVVf1RWuuuaYHcnG9/PoVs1CAp/Lzn//c9t57b3+u4G6HHXawzz//3Ao5q07KGqq/qooCQq2n+iubW6j85S9/sZ49e/q5yv7BBx+0H/3oR76qgvnvfe97hTbzLwrOPPNMGzp0qC9XsPncc895plJBvLKa3/nOd3yZsrB/+9vf3JDbyxTkZCYCCCCAAAIIIIAAAktFILZcTZuw6qgKIGNTxNbUIgY9yszFomBEgYSaMSpjpVFLtVzNOzfbbDN/KHhUyd0ubl9oqiyagh0VTdU0U5mo9957z6qrq9PgUcsVAH366aeeZdTr5kqfPn2aW6XgcgXKCmpVVCe9VlFQpaKgNJ7vo48+ahqlNr+o/hpkKDpquQJEBcex5NevmEVcf7311otP3UIvlL3NL7ouyqCuu+666aK+ffv6LV3iOaQL5j9RQKzgMRZZ555Xfl3jevFY66+/fpzl+9F7RdlRNV/VMdW8VY8tttjC1/vkk0/S9XmCAAIIIIAAAggggAACS1dAMaIe84PIjAdhCsRyM5BxpZZMV155ZQ/ebr/9dt+xtlETxm9/+9u+TwUnChCUXfztb3/rAYuCFqVA9dB8baOiTGixY6qZp7Kdjz/+uGelDj/8cF9X2TplOzUAT9xW+1c2Us1idaJqWhmXzZ07N22+Go8blxWaxssTl+l1fK46vf/++16n//73v37eWqZMmsrrr7/e5HzV7zJuG6fKWipzqKamcZ4yqDpXvVaJ8+O0mEVcX+cf140BmDLEcXl01nVR4Kp14vq6JmraLNc4L05VFzmrWXCcp2Opualeq8T5ceozwz86lvo9KtiMy3Te6ueoZrxqAq2H6hIfqou+aIjrt2Yaj8sUAQQQQAABBBBAAAEEFl4gxoo+VfNVFX24V6Clma0t2kbNDW+66SYfLGXs2LGmgVHU30196mJzRmXjNJiKRgFVQHfOOefYtttumw52o8zXE088kQ66k1+PHj16+AAuymwqO6dgREVNSRWEqgmlso7avwZ5iU1SFcAqOFOAq+BHzUEViCyOEuv0wx/+0G8/EpvQqk4awEbNdGWhzJqaYRZqUrvhhhv6uag/qAIn9Q1VP0c13yxW4nHzLeL66teo/Xz00UemJqMKBmNQm++sUWXVZ1KZYvlp0Budh7KghYrstI7OSwGxbtOy2267FVp1gXlqVqtjaYReba/g8Pjjj/f1NDjP008/bTeHZq26ThqwSIP0vPjiiwvshxkIIIAAAggggAACCCCw9AQU8yl2zOqJHspI6RGL5rWmqDmpBl1RIBlHIe3WrZvp9h5xVFWNyDp16lQ74IADPOOmgOa6667zwFXH0q0+1HfvlVde8SCw0PHVRFR9CdWEM9ZxhRVWsHvvvddOPPFEH+FVzUEVFKkeWkf3ldRgLArQlOlSXTt16uTLYtZV07i//ONqflyu5/ER1zvqqKO8TnEAHs1X5lN10iBCGnVWQZcCJAWU+cfRQDNq/qpAW003Fcjvs88+9uMf/zjNCsfjx2NqWsgi7luD4OihTKGC2TvuuCPdV76zgk1dF62vjKDqq7rLqFBRYKwmw+r/KXvVVQMExWPn++TOl5GOpQy1ssYK7m+88UY/Z/XT1EBGeshpxRVXNPUt3WqrrQpVg3kIIIAAAggggAACCCCwFAU8JgnBWqInCqyUEVIQocFMdt5554WqigIlZbE0VbNG7Tu/6HYSClQUYOYXBaEKZBVUFSoaXfW8886zkSNHer/B/HU0EqsCn5hZzV2uEVS1fw3qszSL6qSgUAFRc0XrKigrdv652xeyUFCmbKwyuQrwtL+WOstGzXsVHBYrGh1WWWQNEqRj6byKBZrF9qH5OpZuOdKlS5eCqykD2b17d99/wRVaMFMj5MbBelqweptdRRbqS0xBAAEEEFj2AvxOXvbXgBoggMCyEVCCSS1AswoAFDwq4CsU7LW2eso2DQx97UoVNZctFNRom0KBX9yX7qn473//27OUyjIWKqWCw4UJdAodo7XzStUpf18tXbclFrq2rXGWfangMb+urVk3f1sdq1jwqHUJmPLFeI0AAggggAACCCCAwLITUGyhEj7HZ73poe7HF2dqQWx2qOdtpej2Fz/4wQ9o0hguSDELBdbqd7rOOusskWuovpnqT9kW3x9t5X1KPRBAAAEEEEAAAQQQWJ4E1EJUyUY9srHvo14oC9mWi/rNURoFilnoOrZ0QJuFsdTgOnGgoIXZnm0QQAABBBBAAAEEEECgfQkoxojj5fgQrJqhogAyLmhfp0RtEUAAAQQQQAABBBBAAAEElqSAd3tUU8QYOKoJawwml+SB2TcCCCCAAAIIIIAAAggggED7EPDAMSQdFS9m9UJPNJBObvaRPm7t42JSSwQQQAABBBBAAAEEEEBgSQooNtRD8WJIOH51m404c0kenH0jgAACCCCAAAIIIIAAAgi0HwElHWMWMqMnuidfzDjmBpTt55SoKQIIIIAAAggggAACCCCAwJISSONFPdF9GSkIIIAAAggggAACCCCAAAII5AvE4FHzvQmr+j9qprKRFAQQQAABBBBAAAEEEEAAAQSigOJExYt6ZNQRMs6IKzBFAAEEEEAAAQQQQAABBBBAQAIKHJV0VEnvA6lAMpvNpllIrURBAAEEEEAAAQQQQAABBBAobwElHHXnDh+FVRQaOEcRZe5gOuVNxNkjgAACCCCAAAIIIIAAAghIIG2+GuLGjF4okowzIUIAAQQQQAABBBBAAAEEEEAgCigDGbs++m08YkoypiXjikwRQAABBBBAAAEEEEAAAQQQUACpR1aZRwWQetTW1npzVvFoPgUBBBBAAAEEEEAAAQQQQKC8BRQb6taP6vrog+go8xj7PyqQVInT8qbi7BFAAAEEEEAAAQQQQACB8hZQbBhv/ZjVi/hQIBkLGcgowRQBBBBAAAEEEEAAAQQQKF+B2GpVTVh9EB3NUDpShcCxfN8YnDkCCCCAAAIIIIAAAgggUEggxokeNSodqUccWafQBsxDAAEEEEAAAQQQQAABBBAoP4HYvTGbzZqPwqrsoyLKGFWWHwlnjAACCCCAAAIIIIAAAgggUEhAcaKCSI2b46OwaiVFkzGy1GuCSSlQEEAAAQQQQAABBBBAAAEEJKAYMaNmq3qiaDI+hwcBBBBAAAEEEEAAAQQQQACBXAG/jUccgVUv4kA6uSvxHAEEEEAAAQQQQAABBBBAoHwFYqJR4+ZkdOsOBY6aqQcFAQQQQAABBBBAAAEEEEAAgSgQE42edNRMRZLqA0lBAAEEEEAAAQQQQAABBBBAIF9A3R6VcMwoeFQWUk1ZGTgnn4nXCCCAAAIIIIAAAggggAACMVbMKg2p4DE2X40jscYVoEIAAQQQQAABBBBAAAEEEChfgRgvKnbM6kWckRs05j4vXyrOHIFlL9CxY0cbMWLEsq8INUAAAQQQsCFDhqCAAAIIlJ2AYsMYM2bVfLWmpsb7QCqijIHj8OHDyw6GE0agLQpUV1fb9ttv3xarRp0QQAABBBBAAAEEykjAM5DxfNWEVf0hVYYOHRpnM0UAAQQQQAABBBBAAAEEEEDA796RqaurS7OPmCCAAAIIIIAAAggggAACCCCQL6AmrH73DqUh9UQZyNh89YEHHshfn9cItEsBsunt8rJRaQQQQAABBBBAAIE2JqC4USUdhbW2ttZTkrGem2++eXzKFIF2KfDKK6+0y3rnV3rmzJk2d+7c/Nm8RgABBBBYBgIa2Ex90ykIIIBAOQnkJhuzeqGHIkqlJWOJEWZ8zRQBBJaNgILHXr16LZuDc1QEEEAAgSYCEydOJIBsIsILBBAoBwHFhooZVbL6R01XNRprDCbjPE0pCCCAAAIIIIAAAggggAACCCjh6AFkDBwVRMbMY5zChAACCCCAAAIIIIAAAgggUL4CChz/PrLCuk7IWMajyKzHkWlasnxpOHMEEEAAAQQQQAABBBBAAIFcAbVY1SNJQtfHOPKqVtDz2LY1dwOeI4AAAggggAACCCCAAAIIlKeAko4KHitCX0gfi1UjsMZC09UowRQBBBBAAAEEEEAAAQQQQEACnngMY656AFlVVeUqiiwpCCCAAAIIIIAAAggggAACCEQBb74aXoQ8ZON9IJWB9Jk5AaRHmHELpggggAACCCCAAAIIIIAAAmUpoETjERtV2IABFZZRn0fNIGAsy/cCJ40AAggggAACCCCAAAIIlBRQrFhfX+/reBPW2O8xG0ZjpRlrSTsWIoAAAggggAACCCCAAAJlJaAYcdasWTZ58uTGPpAKIBVR1tXVkYksq7cCJ4sAAggggAACCCCAAAIIlBZQBrJr167Wo0cPy8Z0pKZ6UBBAAAEEEEAAAQQQQAABBBCIAspA7nf7PmZdzLJ6oUdlZaU/4n0gY7PWuBFTBBBAAAEEEEAAAQQQQACBMhVoCOcdHp6BjEGkRmMlcCzTNwSnjQACCCCAAAIIIIAAAggUEPCWqpVhQRhBxwfRUfZRRQsUTFIQQAABBBBAAAEEEEAAAQQQkIDHiMpAhpKJ2UdNYyDZuIh/EUAAAQQQQAABBBBAAAEEyl0gHSsn5Bq9CatmxKarcWGcljsW548AAggggAACCCCAAAIIlL3A/PFWs4LQLTz00AA6sQlrnJY9FAAIIIAAAggggAACCCCAQBkLpLFh6ADpo7Aq+6jgMTfrmPu8jK04dQQQQAABBBBAAAEEEECgrAU8NtRQOaEfZCYGitlsNs0+lrUOJ48AAggggAACCCCAAAIIIFBQIBMzj3V1dQtkIQtuwUwEEEAAAQQQQAABBBBAAIHyE4hNWNWmVc1Y40A65SfBGSOAAAIIIIAAAggggAACCBQSUNLRS5hkdesOzaitrfVp3IBgMkowRQABBBBAAAEEEEAAAQTKV8BjQ43CGh4hCdk4Cqv6QFIQQAABBBBAAAEEEEAAAQQQKCgQBtLJ6PYdykKqGWscUKfgysxEAAEEEEAAAQQQQAABBBAoa4GQjfQkZNp8Nb3HR1mzcPIIIIAAAggggAACCCCAAAIS8BhRt/FQE1a90COOxtpeiN5991278cYb7Te/+Y09+eSTLb4FybXXXmt/+tOf/DRfeuklO+6441p0ytdcc026XYs2aCcr5Xq0kypTTQQQQAABBBBAAAEEEFiKAmlL1RBE+iA6NTU1pj6QykbGhXG6FOvV4kMpcDzzzDNtgw02sK5du9qvfvUr23HHHe22227z8yi1ozfffNNWWmklP88JEyZ48NmSc33rrbfS7Urtv70ty/Vob3WnvggggAACCCCAAAIIILAUBeIgOjqkMpDqD9nWi+p5ySWX2KmnnmojRoywhx9+2B555BF77LHH7Omnn27r1ad+CCCAAAIIIIAAAggggED7FFAAWVdXl2Yf28NZzJgxwyZNmmSbbrppWt0hQ4Z4ELnuuuv6vDFjxtjRRx9tq6++um2zzTb25z//OV13UZ7o2NrvyiuvbNttt53dfffdvrvx48fbxhtvbJ999lm6+3PPPdfOOeccf7333nvb9ddfny5T5nOTTTaxl19+OZ0Xn6juRx55pA0cONB0Xueff37aP/WBBx6w3Xff3X784x/bgAED7J577ombpdNTTjnFfvKTn9iuu+5qvXr18tuztNRD74ULL7zQNtxwQ+vfv7+p3h999JHv+3vf+57XK/aR1Xr77bdfWre0AjxBAAEEEEAAAQQQQACB5U9AfSA1CquarSrzmN8HUs062+KjW7dutvPOO9tpp53mwc4zzzxjc+fOta233tpWW201P5fDDjvMZs2aZffdd58poDr77LM9Uxmbqsbzilc1vi411br333+/rbnmmjZ8+HAP5E4++WR79dVX/ZijR482BWBxH5MnTzY99FpBrJrXxmUPPfSQB3abbbZZOk/LdB0OOuggU6B611132cUXX2y33HKLXXTRRb6ezklB55w5czx4lUPcZ5wqOL355ptNBsrK6vq21EPZXNXziiuusAcffNDfEwpWtW8Fw7JWfXTO1113nZ133nk+gm88dlubxuvLFAEEEEAAAQQQQAABBBZRIGQfFUBmFWAoq1RbW+vBxiLudqlsfuutt3oAc++99/ogOtXV1XbMMcfYL37xC3vnnXdM/RVfeOEF6927t62xxhoePCqY3HfffRepfsp66hgqgwcPtqeeesr++c9/2vHHH19yv0cccYRdeeWV9t5779mgQYM8ED388MM9+Mrd8O233zYNDqS6KgOo8sUXX3j28oILLvDXOtff/e53Jft6KghVxlBFfRxb6nHAAQeYHnovTJs2zfuVXnXVVb6fgSEjqr6mP/3pT61fv352+umn2xZbbOHL+AcBBBBAAAEEEEAAAQSWXwElGzUCqx5ZvdAjBpLxtGNTxfi6LU1XXHFFH0RHA+mo+agG1bn88su9yaoylCp77LFHWmUFQxtttFE6UqvOLff8cp+nGxV4ouAvd129/uCDD9J5ufuN62mqIHarrbbywFCjvj733HMeUMZ14qEUPCpAVBPZuEzNcj/99FObPXu2r9a9e/f0vp1xu/ypAue4vQJqlZZ4qLmqMrsKvjt16mQzZ870beO+FAirKa7qo8xknO8r8Q8CCCCAAAIIIIAAAggslwKKFZV9VPGbQKrpYWVlpQeSHl02LmuT/ypgU9POefPmef369u1rP/vZz3xEVi1TE1OVN954wz755BN/TJkyxQfc8QWL8M/HH3/cZGvtX8GhRrBVmThxYrpcQWtuUb9GZRbVj1F9GxV85pe11lrLgzb18YxFx1A2UgHdwpTWeETX1157zT7//HPP7ipgjUVNd9XPs0uXLvbb3/42zmaKAAIIIIAAAggggAAC5SCgPpA6TwWN6n+nINKjyzCvrfVni/VRwKj+dxooRv0Op0+fbnfccYe9//77PrCNBrNZZZVVvImlgh01G91rr728v6T2oRL35S/mv9Z+brjhBm8yGpfnTrWu+h/q2OPGjbM//vGPnqnTYDVq0qnbifzlL3/x7R9//HH717/+5Rm6uI+hQ4f6gDRqAqpMXpyfO1XdNTiOmocqy/fKK694ZnXPPff09XPrm7td7nOtk/u6NR4xG633gZq96lzj/hTUauRbDepz9dVXe3NWBem5x2prz73y/IMAAggggAACCCCAAAKLJJC2PAzhVEYvYgatrWcfddYK1DTAjII0BUcaaVXNKdWcVaOCrrDCCqa+kaNGjfJ+imo6qozZj370I0dTkBOLnseAWX0FzzrrLKuqqoqLm0y1rgJRZRHXX399D+yUsdthhx18PTWhVYZOTWW1Hw2ck3uszp07+wA5Wvnggw9usu/4okOHDl53Zf/Ux1JB57bbbmuXXXaZr5Jb37hNc9PWeMhQWVTdX1P9Rbfccst09//3f//n2Vb191Rz2H322cdOPPFEHzgoXYknCCCAAAIIIIAAAgggsNwJeFyjMCpkICtC4OStWWtqaky3e1CQNGzYMB/ptK2f+dixY73Jp5ppKmuWXzSaqearz2Rz5aabbvIM4rPPPtvcqjZ16lQPSmPwGTdQAK7msj179oyzmkwPPPBA69GjR4tuK6K6q9lqDO6b7GghX7TUQ6PHKlAvZLqQh14mmz355JMehC+Tgy/Ggyqo1y1ZKAgggAACy16A38nL/hpQAwQQWPoCnnQ8MjRe7RoG0dHhNepmLDEoys2exWVtbRpHKi1WL2UeW1rUf3KXXXZpkjUstm1uv8DcdRRwFfqgr+ymMqAaJOeJJ55o0TFaU/fcOpR63tJ9FguAS+2bZQgggAACCCCAAAIIILAcC8xvyOkBpJptKgOZtm1djs+72KmpWWmfPn2KLV6k+QrIdFsNNadVk1sKAggggAACCCCAAAIIINBeBDy5qHar4eH3gVQGUjPLOYDcbLPNltj1U6b0sMMOW2L7Z8cIIIAAAggggAACCCCAwJIS8DhRGcjwyKjfnma0hyarSwqE/SKAAAIIIIAAAggggAACCBQW8FixoXGZ38Yj9nvUgC3lnIUszMVcBBBAAAEEEEAAAQQQQKB8BTxGVOSoJqxiUACpZqx1dXVpJpKMZPm+QThzBBBAAAEEEEAAAQQQQCAKpLGhmrDqhZqxapouiGsyRQABBBBAAAEEEEAAAQQQKGuB3FaqGb3QQ7eg0EPBJAUBBBBAAAEEEEAAAQQQQACBVEBhYnhklXWMQaSascb+kOmKPEEAAQQQQAABBBBAAAEEEChbAW+pWhlOP/SD9EF0lHlUicGkv+AfBBBAAAEEEEAAAQQQQACBshfwJqzzG6pmY/YxNmONOvSHjBJMEUAAAQQQQAABBBBAAIHyFUhjwzAKqw+ioxmx6Wq6sHx9OHMEEEAAAQQQQAABBBBAAIFcgTACq4o3Ya2vrzc9NICOpycbl/EvAggggAACCCCAAAIIIIBAmQukMaL6QOqFso/KPJJ9LPN3BqePAAIIIIAAAggggAACCOQJeJwYmq+mo7BqeTabbZJ9JJjMU+MlAggggAACCCCAAAIIIFDmAlk1W1WwqFt4xOcySdOUZQ7E6SOAAAIIIIAAAggggAACCASB0IQ1HYVVzVjjQDrCIQPJWwQBBBBAAAEEEEAAAQQQQECJRi9hktE9IBU4ama6ACMEEEAAAQQQQAABBBBAAAEEgoAnGjUKa3iko7CqDyQFAQQQQAABBBBAAAEEEEAAgYICug+kbt+hLKT6PNJstSATMxFAAAEEEEAAAQQQQAABBIJAVulIBY+x+WocPIdgkvcHAggggAACCCCAAAIIIICAx4i6jYeasOpFDCAJGnlzIIAAAggggAACCCCAAAII5AqkcaKasKr5qrKP6gOpbGS6MHcLniOAAAIIIIAAAggggAACCJS3QBxERwoKItUfkoIAAggggAACCCCAAAIIIIDAAgIKIOvq6tLs4wIrMAMBBBBAAAEEEEAAAQQQQAAB9YFUE1Y1W1XmURlImq/yvkAAAQQQQAABBBBAAAEEEFhAIGQfFUCmo7DW1tY23iBy/poEkwuQMQMBBBBAAAEEEEAAAQQQKDsBv2OHAsjwyOqFHvF2HlGDADJKMEVg2Qp07NjRRowYsWwrwdERQAABBFxgyJAhSCCAAAJlJ6BYUdlHlaz+UbAYR2P16DLMGz58uBZREEBgGQtUV1fb9ttvv4xrweERQAABBBBAAAEEyl5ATViFELOQCiIVXQ4dOrTsbQBAAAEEEEAAAQQQQAABBBAIycdkfvpRo7Dqhe4BqRKzjyAhgAACCCCAAAIIIIAAAgggIAHv3jh/EJ1Mbl9HPSeI5E2CAAIIIIAAAggggAACCCAQBTwDqSSkBtHRTI3AGot3kIwvmCKAAAIIIIAAAggggAACCJS9wAPfGmarrrpqYwBZVVVlNTU1X7VtLXseABBAAAEEEEAAAQQQQAABBCSglqojR460CRMmNN4HUhlIzUw7R+KEAAIIIIAAAggggAACCCCAQBBQnLjRRhvZgAEDLKM+j5qR2xcSJQQQQAABBBBAAAEEEEAAAQQkoFixvr7eMcIdIcNQrLoxZCgajZUspFPwDwIIIIAAAggggAACCCCAQBBQjKhbPir5mAaQiijr6urIRPIWQQABBBBAAAEEEEAAAQQQSAWUgdRDicdsTEfGmelaPEEAAQQQQAABBBBAAAEEECh7AWUgp06daiuuuKJl9CKmJGNasuyFAEAAAQQQQAABBBBAAAEEEEgFqqurrUuXLo0ZyBhEajTW2B8yXZMnCCCAAAIIIIAAAggggAACZSug1qoH3j3UrHMYP0cKyjyqaIGCSQoCCCCAAAIIIIAAAggggAACEvAYsaHRIm3CGpuxQoQAAggggAACCCCAAAIIIIBAFFCi0UvINWbi4Dmx6Wq6MK7NFAEEEEAAAQQQQAABBBBAoLwF5seQ3oRVt/DQQ/f1oAlreb8vOHsEEEAAAQQQQAABBBBAIFcgjRFD9OhNWJV9jJnI3BV5jgACCCCAAAIIIIAAAgggUN4C3kpVQ+WEfpDehFUc2WyW7GN5vy84ewQQQAABBBBAAAEEEECgpEBGzVYVUdbV1XkTVvpAlvRiIQIIIIAAAggggAACCCBQngKhCWtW7Vn1UDPWOJBOeWpw1ggggAACCCCAAAIIIIAAAvkCSjp6URNW3QNSgaNmpgvyt+A1AggggAACCCCAAAIIIIBAWQp4olGjsIZHOgqr+kBSEEAAAQQQQAABBBBAAAEEECgooPtA6vYdykKqGSv9HwsyMRMBBBBAAAEEEEAAAQQQQCAIhGykJyHT5qvpPT7gQQABBBBAAAEEEEAAAQQQKHsBjxF1Gw81YdULPeJorGWvAwACCCCAAAIIIIAAAggggEAqkLZUVRNWNV9V8Kg+kMpGpgvT1XmCAAIIIIAAAggggAACCCBQ9gJxEB1BKIhUf0gKAggggAACCCCAAAIIIIAAAgsIKICsq6tLs48LrMAMBBBAAAEEEEAAAQQQQAABBNQHUk1Y1WxVmUf6QPKeQAABBBBAAAEEEEAAAQQQKCgQso9pABmDSE0pCCCAAAIIIIAAAggggAACCEQBJRs1AquPwqoXeih45BYekYgpAggggAACCCCAAAIIIICABDzRqCaseq5/NPJqHI3Vo0vNpPw/e+cBIElRNeC6ZY+cczjgyDlnAUmSJAkioIAIiAKKCIICgoCCosRfoiBRguQsKhIkgyA55xwlx7u967++2quhd252d3Z3bm/35nt3s91d3V1d/XV1d716r15LQAISkIAEJCABCUhAAhKQgAQygahEtjKfrZAokbqxZjpOJSABCUhAAhKQgAQkIAEJSKDiqUoUVhb4BiSi9dHKIQEJSEACEpCABCQgAQlIQAJlAnispjGQRGFNC2PWMq8SWUblvAQkIAEJSEACEpCABCQggeYmkCyQjIHEAgmKkSNHVojowlpB4YwEJCABCUhAAhKQgAQkIAEJQIAorFGSAjl06NC0UPFtTUv+kYAEJCABCUhAAhKQgAQkIIFmJ5C8VrFA4sKKxXHUqFEpEqsKZLNXDc9fAhKQgAQkIAEJSEACEpBARwJJT8QCiQsrYx5JKI+F7Li5SxKQgAQkIAEJSEACEpCABCTQrASSrji6/eyTC2se90g0Vq2QzVotPG8JSEACEpCABCQgAQlIQAJjE0g6IpojLqyszm6sbW1tWiLH5mWKBCQgAQlIQAISkIAEJCCBpiVQ8VbFhZUF3FiZVlY0LRpPXAISkIAEJCABCUhAAhKQgATKBMpeqi0s8JtooonSz+9AllE5LwEJSEACEpCABCQgAQlIQAKBMZDx14rVMSuRfA8yj4cUkQQkIAEJSEACEpCABCQgAQlIIHmqThQ5xAGQaQwk1kckK5NpwT8SkIAEJCABCUhAAhKQgAQk0PQEkgtrjsKarY/ZjbXp6QhAAhKQgAQkIAEJSEACEpCABCoEKrFyiMLKAr/sulpZWdncGQlIQAISkIAEJCABCUhAAhJoagIxAiuSXFhHjRoV+BFAJ5kn29f5VwISkIAEJCABCUhAAhKQgASanEBFR2QMJAtYH7MlssnZePoSkIAEJCABCUhAAhKQgAQkUCKQvFSj+ypRWJMLK+taW1u1PpYgOSsBCUhAAhKQgAQkIAEJSEACHQm04LaKRtnW1pZcWB0D2RGQSxKQgAQkIAEJSEACEpCABCQQCUQX1lZcWLMbaw6kIxwJSEACEpCABCQgAQlIQAISkAAEMDomwYWVb0CiOJJYWdG+2r8SkIAEJCABCUhAAhKQgAQk0OQEkqGRKKzxV4nCyhhIRQISkIAEJCABCUhAAhKQgAQkUJMA34Hk8x1YIXFjdfxjTUwmSkACEpCABCQgAQlIQAISkEAkEK2RyQhZcV9FkVQkIAEJSEACEpCABCQgAQlIQAIQSDoiaiIurCzwy9FYRSQBCUhAAhKQgAQkIAEJSEACEsgEKp6quLDivoryyBhIrJGVlXlrpxKQgAQkIAEJSEACEpCABCQggRxEBxIokYyHVCQgAQlIQAISkIAEJCABCUhAAmMRQIFsa2urWB/H2sAECUhAAhKQgAQkIAEJSEACEpAAYyBxYcVtFcujYyCtExKQgAQkIAEJSEACEpCABCRQk0C0PlYUyKxEMlUkIAEJSEACEpCABCQgAQlIQAKZAMZGIrCmKKws8EN59BMeGZFTCUhAAhKQgAQkIAEJSEACEoBAMjTiwso8f4i8mqOxJu2SREUCEpCABCQgAQlIQAISkIAEJJAJRCWylflshUSJ1I0103EqAQlIQAISkIAEJCABCUhAAhVPVaKwssA3IBGtj1YOCUhAAhKQgAQkIAEJSEACEigTwGM1jYEkCmtaGLOWeZXIMirnJSABCUhAAhKQgAQkIAEJNDeBZIFkDCQWSFCMHDmyQkQX1goKZyQgAQlIQAISkIAEJCABCUgAAkRhjZJ8V4cOHRpGjBhhFNZ2Jv6VgAQkIAEJSEACEpCABCQggTEE8FS9YpurwrBhw0IrFkcskCRWBkeKSgISkIAEJCABCUhAAhKQgAQkEAmgJz722GPh7bffDq2MeSShPBZSShKQgAQkIAEJSEACEpCABCQgAQigKy688MJh7rnnbh8Dmcc9Eo1VK6SVRAISkIAEJCABCUhAAhKQgAQyAXREPvmI8TGNgcxurG1tbeGYu4eEj0fkTZ1KQAISkIAEJCABCUhAAhKQQDMTmGriIeG+R4eEqd9saf+MB5okZsn0a2YynrsEJCABCUhAAhKQgAQkIAEJdCBQhPgNj2J0TCtCC+bIbJLELFmkFR22d0ECEpCABCQgAQlIQAISkIAEmpVA1B8xOo6OumIrVsesRKZorDEqqyIBCUhAAhKQgAQkIAEJSEACEoDAkJYhYaLWodF9NbqwkoDlEUnK5OioXioSkIAEJCABCUhAAhKQgAQkIIFIoIg64ujRo+LckNCarY/ZjTWmjSWLvHHRWGkmSGCrrbYSggRqErjoIp8ZNcE0eaLPjCavAF2cvs+MLuA0aJX3X4NAdpONdbkbQA1YbV1uAMQ6sjj0lqqNotfqNosWYdiw0e1BdLA85k95oFUqEpCABCQgAQlIQAISkIAEJCABCER1MXmrMp8+4zFq1KjAj4GRcUAkm7BOkUBdBD7++OPw+eef17WtG024BCaddNIw5ZRTTrgn6Jk1jIDPjIahHNQZ+cwYP5fP+6/x3K3LjWdaT47W5Xoo9WybruoyLqxIa2truwsr1sf8KY+eHcatJRCS8jjjjDOKoskJvPPOOyqQTV4H6j19Opx8ZtRLa8LdzmfG+Lm23n+N525dbjzTenK0LtdDqWfbdFWXCaLDkMe2trb2KKxkjTZJoiKB3hIYcqiW696yG+z7FQf77Bjs13B8lN9nxvigPjCO6TNj/F8H77/GXAPrcmM49iUX63Jf6H25b711OQ19zJZHtMk0P5FKwJconZOABCQgAQlIQAISkIAEJNDcBBgDieC5WonCygK/+G1IRQISkIAEJCABCUhAAhKQgAQkkAiMahudgugQN6eFb0DmMZDt1kgpSUACEpCABCQgAQlIQAISkIAE2gkMiYZGJBkdmUGTZAykIgEJSEACEpCABCQgAQlIQAISqCbA+EcMji0oj1ghCaBDYvZvrd7BZQlIQAISkIAEJCABCUhAAhJoTgLoiki0QrabI9EmkdFjvvGRFvwjAQlIQAISkIAEJCABCUhAAs1NIBobk/WRuDlYHvm1j3+MWqXR+Ju7cnj2EpCABCQgAQlIQAISkIAESgTydyCTEon7KjOMgcQayUpFAhKQgAQkIAEJSEACEpCABCRQJlAJokMiSiTjIaMxUpGABCQgAQlIQAISkIAEJCABCXQgkBTItra2ivWxw1oXJCABCUhAAhKQgAQkIAEJSKDpCWBkZNhj+g4kWiQzeQykDqxNXz8EIAEJSEACEpCABCQgAQlIoEKAuKvojUicxkg6Y5RIpnqwVjg5IwEJSEACEpCABCQgAQlIoOkJjB41On3yERAtWB75JeUxmiX9DmTT1w8BSEACEpCABCQgAQlIQAISqBAYEg2N6IxIskPyUcgcjbUYs6KytTMSkIAEJCABCUhAAhKQgAQk0LQEspGRcZCtUMhWSJRItEtFAhKQgAQkIAEJSEACEpCABCQAgdGj8FQdkrxWW5IWGb8BmVZE6yMRdhQJSEACEpCABCQgAQlIQAISkAAEhrQMSQpkGvqIJpmFeV1YMw2nEpCABCQgAQlIQAISkIAEJFCMLipxc5K/6siRIytUCKajSEACEpCABCQgAQlIQAISkIAEMoFseEza4tChQ1M67qyKBCQgAQlIQAISkIAEJCABCUggE8CFFUFfjAbHljBq1Kjk05oUyC89WvP2TiUgAQlIQAISkIAEJCABCUigSQngwooFkl/6DiSKYzZJaoRs0lrhaUtAAhKQgAQkIAEJSEACEqhBAAskRkckubDmcY+tRGNVg6yBzCQJSEACEpCABCQgAQlIQALNSQCDI598JApr+n4HCiSBdNra2mKMVn1Ym7NaeNYSmPAJvPLKK+Hxxx8Pn3zySZh33nnDEkssUfG+GNdn/8ILL4T3338/LL300h0O9c4774Tnn38+LLXUUmHiiSfusM4FCUigI4HxeQ9TkgceeCBMPfXU6fnRsWQhfPjhh+GJJ54ICy+8cNqmen1fl//whz+ErbbaKgwfPryvWbn/ICAwEOp6DrI5ySSThPnnnz9MPvnkg4CcRRxXBKLzarv7atQbW3FdzWMgk1/ruDqq+UpAAhIYjwSuv/76cPrpp4e55porvQQvueSSsPjii4d999039ahdeeWV4bPPPgvbbLNNr0t5+OGHh0033TQpptWZfP755+F3v/td+PnPfx6WW265tJrevOOOOy4QyGyFFVao3sVlCUigRGB838MUhXt4sskmC2eccUb6mHapeOGqq64KV199dfjlL38ZllxyyfKqHs8//fTT4dxzzw2HHHJIpZPr/vvvDxtssEGP83KHwUdgINT1k046KekH1PePPvoofPHFF0mJ5J05zTTTDD6olrjPBIrQ/hkP2i6t/MkmScySRTE6HsBPefSZshlIQAIDhgDuFhdeeGFS7r7zne+kcj377LPhgAMOCA8//HCyCr722mvh008/7VOZn3rqqWSFqJUJVok111wznH322alxidJ4yy23hOeeey4ceeSRtXYxTQISGENgINzDFGXSSSdNHU333Xdfh04fLDUoj40SvCSwZtI+yzEqGpW3+QxsAgOlrkNpu+22C2uttVZyWXzmmWfC8ccfnzpR6NjgXlCajED8WAf1k1+yQGYlkgfgkGiWVCQgAQlMSASwLNKDOs8881ROa7755guHHnpomHHGGcOf/vSncOedd6aH4u677x4OPPDAMMsssySl89Zbbw0ff/xxYPsf/vCHYbbZZkvbXnvttWHuuecOrP/+97+ftsXKeOaZZ4Ybb7wxHHTQQZVj5RlexnvttVeyVGy44YbhvPPOS0rtHHPMkTbhWfzXv/413HHHHYG8lllmmbDzzjsH3IfwFEEJrqc8lHPVVVfNh3UqgUFPYKDcw9yLDPvBQlT2GrjrrruSJwENqyzczxdccEFgHc+fRRddNOy4447pmcPz5m9/+1tYaKGFwk033RRmmGGGZF1ce+21wz333BNOPfXUlM2Pf/zj8PWvfz1svPHGaRkX/LPOOivg+k5+e+yxR5hiiinyIZ1OAAQGSl0vo6TOL7jggmG//fYL++yzT3jwwQfDSiutFN5+++1kjadeMgSDe4I6/sYbb4Tf/va36V06++yzp6xuvvnm8Pe//z0cccQR5aydH0QECKJD5zf1IWmLWB4RerkI0apIQAISmJAI0MDCpQxFEaXtkUceCSNGjEhjlVAgt9xyy7QeKyFWyZlnnjk14njh7bTTTkkZpGF42mmnJSwod7iYkcf++++fxi8y5cGKC+suu+xSE99UU00Vtt1223D55ZenstAY3WKLLSrbXnrppeGGG24IO+ywQ1I06fE95ZRT0noalfWWh7GdigQmJAID5R6G6Te+8Y3w0EMPpUZyZvzPf/4zKXk8A7LQ4fOvf/0r3fM8H3hu4OZOvAnm8VhAWeCZgzs9LvZ4QTC/9dZbp2xosH/1q1/NWYbbb789dSrR0cXz4bLLLqusc2bCIDCQ6no1UTo755xzzlT3WHf++ecn11Y6XXnv4VVDh8iwYcOSQklHSRbWoYQqg5cAOmIe9lhxYaWnLCmSxtAZvFfWkktAAp0S+NnPfhawGtIAY6wS7jfrrLNOctGh95+XNp1ovPiQVVZZJf1o7NGoQylD8cvC/rvuumv7czMmMiaEZyh5zTrrrHmzsaZrRjdWFEGsEjQqy4FzUB7XX3/9ykt2s802C4xDwcrQ0/KMdWATJDDICQyUexiLymKLLZaUQ7wKXnzxxdShtOeee4brrruuQhlPgm9+85vJUkMi9zHeAWyPoGzSQcVzg+cOSigu9Vh2ZpppprQN6fT2Z9l8883TsVkmoM8LMTiXMuERGCh1vRZZvHPefPPNtIo6jzA+cvrppw/TTTddpU7yrsNjhnuAAHKPPfZYet+mHfwzOAlgaIz6YsWFlUbTlw8oNcjBeVUttQQk0BUBFD5eZPllRmMNix8vQ5S2ann99deTlfDJJ59MSh4Wg7JMOeWUFeWxnN7dPM9bLAqMuSxHZEVRfffddwPBfXIjlHFQCOkMMcCC2ujydFde10tgoBAYKPcwPNZbb73kkYClEHdWAmPhzZCF+5lGdnZPJ33aaadNAbyIronkTifm8UbgmYJXQ1dCB1UWjsdzSpnwCAykul5N9+WXXw6rrbZaSqZDFjdtXKrphGW4B548CO85hmSwPcojnSFEP1cGL4HYfKmMyU6f8cAcyS/57kfNMq4evGdnySUgAQlUEUBZw30G5ZFefxpyhMPHLfTVV1+tbE3PWhZefDQCCRpAQw3rIO46jRCUSH5l4Tu8NA6/9a1vpaAF5XXMH3vsseOsPNXHclkCA43AQLuHl19++TTeGXc9rCx77713B2Tczzw33nrrrUo6jWu8GRhHXX7uVDaoMVN+JtVYbdIESGCg1fUyYsY+0mnBJz3o7Dj55JPDJptsEvCWQek97LDD0juWfbBIMnQEN9ZHH300rLHGGuWsnB+EBPIwR55vLTycsD7WatAMwnOzyBKQgATGIoDCeM0116TB/vSU0oj797//nayABKJAcL3he4w07OhMy24aPB9xE2P/7oQ8cCvje3C9EawYF198cRob9cEHH4RzzjknBSzobXl6Uwb3kcBAJDDQ7mHcTnGBJ6oyZav12Q6UTLwcGOuIIklgHBrVw4cP7xYxzxKETq5q74dud3aDQU1gINV13pcvvfRScq3m3XT00UcnRZDvFmfhXUln62233ZYUxZzOFKWRe4CIwquvvnp5lfODkABBdPL1TlFYOQe0SRIVCUhAAhMaAT5+TDAKxhMSIRXBEkkAG8YbIbzceAFiSeCzGqw76qijwm677ZZcc4gud++996ZtO+tw22ijjcJf/vKXFGAAi2FnUm19zNsRPAe3VXpxGVOCey3HR4ntTXlyvk4lMNgJDKR7ON+/KJAEsVl33XUrHgV5Hby333775NKX72eiQBMwh3HPnT1D8nUiwvOyyy6bvhPLvZ+D6uT1eVo+Xk5zOrgJDKS6zpAKfrhYY3VkDC7WRuod9ZigcASmIz4A7qmLLLJIaUhcqEQqZswwirEyYRBIz68YSSxpjYyvwU/52dk2Cx91HOoTFnnjognjjD2LhhLABRChhwpXnSGHdnTJa+jBzGxAEygOLir1gIJedNHAfWYwnpAefQLdfDn2ux0vnWg8C8uBbQi/z9iO6m07uyAMByAfOuV6K/TmUkbGRFVLT8tTvf/4XPaZMT7pD6xj9+WZMRju4TJtngk8V3Dx66mwH9bOep8/XeXv/dcVnd6v60td7u6og6GuU7/p+Jx66qnHOh2C5xA8it+KK6441vreJliXe0uu6/2q6/Kht3Tcfur4CJvvjavSJ8wqUVh5OPErvvyEUce9XJKABCQwARDAhawzyb2q5fV8eqMnQmOvr4LyWUt5JN+elqevZXF/CQw0AoPhHi4z45nQ2+dC+bMg5Tydbw4Cg6GuU7drKY8Eg7v66quTy3b5m6nNceUmzLMc1TY6WZ/pNGjlwjO+hl4uptEqrUhAAhKQgAQkIAEJSEACEugVAVy2v/e976XvJOtq3SuEA26nIdHQiGBwrERh7Yu71YA7QwskAQlIQAISkIAEJCABCYwXAvlzHuPl4B50nBGgMwCDYwtmSKyQjNlJgyK1QI4z6GYsAQlIQAISkIAEJCABCUhgMBLI1uRohWw3R6JNIqNHG4l1MF5QyywBCUhAAhKQgAQkIAEJSGCcEIjGxmR9jLpj+g4k1sf28Y/R/Kj+OE6Ym6kEJCABCUhAAhKQgAQkIIHBSCB/BzIpkTmIDmMgsUayUpGABCQgAQlIQAISkIAEJCABCZQJoC+2+6/GVLRJxkNGY6QiAQlIQAISkIAEJCABCUhAAhLoQCApkHywOlsfO6x1QQISkIAEJCABCUhAAhKQgASangBGRoY9YnCMSmRLmsljIHVgbfr6IQAJSEACEpCABCQgAQlIQAIVAlFlTMMdSUgKZFYimerBWuHkjAQkIAEJSEACEpCABCQggaYnMHrU6PTJR0C0YHlM0XRQHqNZMn4fUpGABCQgAQlIQAISkIAEJCABCSQCQ6KuiM6IpCA6fBQyR2MtxqxIa/0jAQlIQAISkIAEJCABCUhAAk1NIBsZMTi2QiJbIVEi0S4VCUhAAhKQgAQkIAEJSEACEpAABEaPwlN1SBoH2ZK0yPgNyLQiWh+JsKNIQAISkIAEJCABCUhAAhKQgAQgMKRlSFIg09BHNMkszOvCmmk4lYAEJCABCUhAAhKQgAQkIIFidFGJm5P8VUeOHFmhQiRWRQISkIAEJCABCUhAAhKQgAQkkAlkw2PSFocOHZrScWdVJCABCUhAAhKQgAQkIAEJSEACmQAurAj6YvoO5KhRo5JPa1Igv/Rozds7lYAEJCABCUhAAhKQgAQkIIEmJYALKxZIfuk7kCiO2SSpEbJJa4WnLQEJSEACEpCABCQgAQlIoAYBLJAYHZHkwprHPbYSjVUNsgYykyQgAQlIQAISkIAEJCABCTQnAQyOfPIxRWEFAQokGmVbW1uM0Tph+LA+8MAD4Z133hnQV/ipp54Kxx577IAuo4WTgAQkIAEJSEACEpCABJqbQHRebXdfjXpjC66raJLZp3XCUB9DOOmkk8LDDz9c1/Dtj3YAAEAASURBVJU+/PDD6962rgzr3Oj9998PDz74YJ1bu5kEJCABCUhAAhKQgAQkIIH+J1CE9s94pCA6/MkmScySRTG6/0s0no+IJfDDDz8cz6Xw8BKQgAQkIAEJSEACEpCABAYggfixDoyO/FqxPGYlku9BDpkAvwN54oknhimnnDK8+OKL4ZlnnglLLLFE+OY3vxnmmmuusOeee4bPP/88nHnmmeHGG28MBx10UOLx17/+Ndxxxx1p3TLLLBN23nnnMMkkk4Q777wzXHvttWHuuecOt956a/jhD38Yrr/++rDSSiuFDTfcMF3t9957Lxx44IFhr732CvPMM0+48MIL07Yff/xxmG+++dI+s8022wCsGRZJAhKQQP8RKA7201H9R9sjSaAjAe+/jjxcGrwErMv9c+0IosOnHxn6GKPmhDQgkvGPSZmMIVrjQMj+KUk/HQXr4u23354Uty233DJccMEF4ZJLLgn77rtv2H///cN+++0XNt1007DiiiumEl166aXhhhtuCLvuumuYfPLJw5///OdwyimnVJTNp59+OqAAsu8cc8wRXnnllXDTTTdVFMi77rorKaHzzjtvuPvuu8PNN98cdtlllzDNNNOEc889N5x22mnhV7/6VT+dvYeRgAQkMLAITDrppKlTbWCVytL0NwE6Z5X+J+D913jm1uXGM60nR+tyPZR6tk1XdZnPeORPP7Zm62N2Y53AdMcKNSyEa6yxRlrGUnjCCSckE+ywYcOSAj3DDDOEWWedNa1HeVx//fXDggsumJY322yzNKZyjz32SMtUWJRLXH4R8r3sssvCa6+9FmafffZkpfzqV7+aNPRVVlkl8ENB//TTT5P18/LLL0/7+UcCEpBAMxLAI2T11VdvxlP3nCUw3gl4/433S2ABGkTAutwgkPVmM8ZrteLCiuUxf8pjQrM+ZiYoiFlmnHHGpEEDICuBeR2K3rvvvpsslNddd11K/uSTT9KUdIQKW94PxXPhhRdOiiPKJGMqd99997Tt66+/Hv70pz+FJ598Mkw88cTJJTat8I8EJCABCUhAAhKQgAQkIIFBQCCqi8lblaImF1bMkfxQqKLvZUyesFxYe3JN+BYmyua3vvWtsNZaa9W965prrpnGRjJOEstltmYylhKl9Pjjjw8orlg3zz///LrzdUMJSEACEpCABCQgAQlIQALjkwAurAi6Uguuq1gf82c8xmfBxtexp5tuusB3I3Mk1uWWWy5cfPHFyZL4wQcfhHPOOSfss88+7Qp2J4VceeWVw5tvvpmUSJTJLPBFMYfxCy+8EK655pq8yqkEJCABCUhAAhKQgAQkIIEBT4AgOug1GMZSFFZKjDZJYjMJSjOy0UYbhb/85S8pQuuxxx4bdthhh4Db6mGHHRa++OKLMMsss4TddtutS0V7sskmS5FYCZrDmMcsW2yxRTjqqKPS/lNMMUVYYYUVwr333ptXl1yHK0nOSEACEpigCRCRmujXSnMTIJ4AQ0KU/iXg/dd43tblxjOtJ0frcj2UerZNPXU5GR0feuihpDXyCY+XX345PDvbZuGjqvf6Im9c1LOjD8KtceFFgUaRzoKGTSOnES+4jz76KKBAfjnWNB9l8E632mqrVPh33nknuecOObR5XZ8H71VsTMkJoZ3rATledNGE/8xoDLnmyqX6mdFcZ+/ZVhPwmVFNZNwue/+NO77W5XHHtlbO1uVaVBqTVq7Lh97SMc+pJw1hvjeuSp8yrERhRbHhV8RhkM0o5aA4+fxRJhuhPJLfVFNNlbN1KgEJSEACkYCdTs1bDfxu2/i/9t5/jbkG1uXGcOxLLtblvtD7ct/u6vKottFpyCNGtxYUJxRHxunxG+PV+WVuzklAAhKQgAQkIAEJSEACEpBA0xIYEvVFBL2xEoW17LrZtGQ8cQlIQAISkIAEJCABCUhAAhIYiwCxXvhcYStmSKyQ7dbHIVogx0JlggQkIAEJSEACEpCABCQggeYmsMACC4SZZ54ZK2S7ORIFEhk95hsfzY3Hs5eABCQgAQlIQAISkIAEJCCBRGDM1zrwWk3fgczfKkyftWiuL3lYIyQgAQlIQAISkIAEJCABCUigCwJ8BxJBb0xBdLA+Jm0yWiPzyi72d5UEJCABCUhAAhKQgAQkIAEJNBEBjI0pAGs+Z5TI9m8h5hSnEpCABCQgAQlIQAISkIAEJCCBdgIMf2xpa2urWB8FIwEJSEACEpCABCQgAQlIQAISKBNgCGQe9piC6GB5rERhLW/pvAQkIAEJSEACEpCABCQgAQk0NQHirmJ9TGMgkxkyLqBEpsSmRuPJS0ACEpCABCQgAQlIQAISkECZwOhRo+PnHvnk45DQguWRX9YoY5oiAQlIQAISkIAEJCABCUhAAhJIBIaMsT6ykD4CmSPqoEgW8adIQAISkIAEJCABCUhAAhKQgAQggJER91V+rSRkKyRhWdEuFQlIQAISkIAEJCABCUhAAhKQAARGjyra3VejrtiStMjWpEcmRZIIO4oEJCABCUhAAhKQgAQkIAEJSAACQ1raxz+moY+4r2ZhXhfWTMOpBCQgAQlIQAISkIAEJCABCRSj291XUwBWcIwcObJChURFAhKQgAQkIAEJSEACEpCABCSQCSTlERdWEoYOHZrScWdVJCABCUhAAhKQgAQkIAEJSEACmQAurAj6YlQk278BmdxXUSC/9GjN2zuVgAQkIAEJSEACEpCABCQggSYlgAtrHvqYvgOJJpkTNEI2aa3wtCUgAQlIQAISkIAEJCABCdQggAVy1KhR7ZFYWZ/HPbYSjVUNsgYykyQgAQlIQAISkIAEJCABCTQnAQyOfPIxubCCILuxtrW1tX8lsjm5eNYSkIAEJCABCUhAAhKQgAQkUEUgfsSjktKK62o2RzL/5arKNs5IQAISmKAIPPDAAx2iT3NyBBNbeumle3yezz33XLjsssvCPvvsM9a+999/f5hhhhnCXHPN1WHdU089FeiwW3TRRTukuyABCdRHoL/u4Y8//jg89thjYcEFFwzTTjvtWIV74YUXwrvvvhuWXXbZsdb1NYHnxLXXXhv22muvvmbl/oOYQH/W9ccff7xCavrppw/Dhw9PFqdKojNNTSB+xCOdP/piK2bIbJJsN0uOjiv9lEdT1xBPXgITOIGTTjopdZxNNtlklTOdaqqpeqVAfvDBBwFFsZY8+OCD4Y477gjHHXdcmHzyydMmb7zxRjj00EPDd7/7XRXIWtBMk0AdBPrrHn755ZfD0UcfHTbYYIOw4447digZbaff/va3gWfAhRde2GFdbxauvPLK8Nlnn4Vtttkm7f7+++8HniFKcxPoz7p+1FFHpU5PPBPfeeedMPHEE4e11lprrLrf3Fekic8+6o+jR49Ov2SBzEok34Mc4ncgm7hmeOoSaB4C2223XXoxjssz3nrrrcNdd90VLr744rDDDjukQ5111llh7rnnDuuuu+64PLR5S2CCJ9Af93CG+Pe//z185zvfCZNMMklOSsodymOj5LXXXguffvppo7IznwmIQH/WdTpM6FylLt55553htNNOC1NMMUXYaqutJiCinkpvCBBEh3g5dDDEqDkhmadxp8IkSYhWv+XRG6zuIwEJTAgEeGH+7W9/CwsttFC46aabUm8s1oe11147nR6NvDPPPDPg6jP77LOHFVZYodPT5iX8ve99L/zf//1f2v/NN98MuCNhtcjBy3B/I7+HH344zDjjjEmxXH/99VOeb7/9djjjjDPSsegJ5lhYQXiAn3jiiekl/+yzzwbcaP/yl7+k9E4L4woJNAmBRt7DGRn38u233155DpD+z3/+M92DtJ2y3HvvvQFL4vPPPx+GR/e/TTfdNKy44oppNffslFNOGV588cXwzDPPhCWWWCJ885vfDPPOO2/405/+lBrr9O7vvvvu4cADD8xZhksuuST84x//SM8MOp623HLLyjpnmpvAuKjrmSheM+uss0748MMPw6WXXhq22GKL9I657777wgUXXBB4F84888ypDq+++urhqquuSp0qBx10UM4iHHPMMWGOOeYIdKYqg58AOiLPKKQlWx+zG6uDIAf/BfYMJCCB7gm88sorSWlDceP30ksvpZ0+//zzwNgjXMkOOOCAsPjii4fTTz899cbS0fb73/8+jV/kJbnZZpuFq6++usuDrbzyymHJJZcMf/7zn8PZZ58dUA5pMCKMPz/iiCMCx/zlL38ZNtpoo7TNPffck9aff/754YsvvkiNyV122SXccsstSallJS/1f/3rX4EX929+8xuVx0TMP81EoL/uYYb3oAiiMGbBve+///1v2HzzzXNSUgppMPPM+PWvfx2WWmqp5L7O8wThnkURXGONNcJ+++2XllEOEZRCnhMLL7xweu7QMEd4Dr3++utpexrzeDM8/fTTaZ1/modAf9X1WkR5h+GhyDsSqySdHcsvv3zqCKVT84QTTkh1mfr+yCOPhFdffTVlgws27zLqtTKBECh1liUXVnrPcm+41scJ5CJ7GhKQQJcEsC7Se5uFADo/+MEP0iIBdXbaaafknTFs2LDUcETJnGmmmQJjGH/1q18lyyRWSpYJotOVkNfPfvazZH3I45vYnvFVWCNwGZp66qnDLLPMkl64jJvEarHnnnumbFEiCWgw3XTTBYJ2ZFl11VXT2Ky87FQCzUSgP+9hPBBQ9rAczj///OGGG25IgXVwR8/yn//8J3UOZWsLHUU0qEknCA+y0korJQWS+Q033DA1vulIItgWboK0x3jmZGF55513TmOo55lnnoArLc+MBRZYIG/itAkI9Gddr8aZOzPwoKFOn3rqqSl2Csok4yOxPPIuW2yxxcLwaHXnvUqHyN13353emXSKKBMGgfg4quiLyYWVhxe/ZJZM34H80h1jwjhlz0ICEpBARwLbb799p2Mgp5lmmkrkOcY84XY2YsSI1LPKMo29LOXGXk6rnqIYLrLIImG22WZLLm95Pb3KCApplk8++SSNkWQZlzlchbB20LgkImT5ZUw5FQk0K4H+vIeJwEqnzvXXX58aySiQBMIqC5YX3PXKwnK+z0kvPztwWc9tL6yctWTSSSetBOCio59OJKxBSnMR6M+6Xk02WxSJJk7dO+ecc8Ktt96a5nkvIXgxImuuuWa6R1AgUSSxtpddvNNG/hm0BNqHOYbk8ZSisPJQQnn0Ig/aa2rBJSCBfiCAIog1EFc0LIbIW2+9VdeReb5WP2NnnXXWtC8uQDlKa84MhfXkk08Om2yySXKVpSF52GGHpc+N5G2cSkACPSPQl3t4vfXWS257WBNpM+Hah4UxC/czY5LLwvNhzjnnLCd1OZ8b4l1u5EoJ1EGgL3W9nD1Wb8YAM+YfqyKdJwzhwAMHF2s8bLKsttpqaTw+0YOfeOKJNJ43r3M6+AkQRIdnHx1fLblBQ1AGH1yD/+J6BhKQQH0EsOoxpiP/ylaCznLAPQcLAC48NAz5Ptzll1/e2ebdpuP+hkWCKHfkRxkOPvjgcN5551X25bnM2MvbbrstPProo5V0ZyTQ7AT6+x7mu600yglsxXhE2k1l4VuQBNdinON7772XLDEomPV+I5JnC8F3sPgkj7By5s43NYH+rOt5aAUWRALA4T5LYCf0Beol7yTm6UgleFtZ+BzWcsstlzpa8LrJ7q/lbZyfMAi0UhmoCJil0/xE0X1V74gJ4+p6FhKQQKcEGM+UA1iwES8+At3wPORXS4iEus8++wS+y7XHHnukfXDRwa2tN8JYSwL1YIH8yU9+kl7MNDYJzsOxtt1226RMoqQy9oQX8pfj1XtzRPeRwIRDoD/u4ernAVZIoiZ/7WtfSyDL61EwCXZFxEqUTMYtM36RaKtdSX7eEBCLjqK99947HHnkkWkX7/euyDXPuv6q6xDNUVTp0MDKuO+++1Y6QVAOl1lmmdTRybYEfqsW3okEz8GdVZmwCNA04nmFy/2QaGaOnQlFarjQ6/DUTJuEj0d0POFF3rioY4JLEogE8jeB6BljLMeQQ2s3uoU14RMoDi7SOD3qAXLRRRP+M4PxiLidNqqBhysQeZW/MwdLXEUYF5ldZkkbrOIzY7BeucaXeyA8Mxp9D5cpkTdjp3sqtMfo0KcDqdHi/ddoou35DYS63N2ZNbquEzkcYWhFtdx4443h3HPPTR2ttdZXb9+bZetyb6h1v091XT70lo77TNE6Ogx76aLkztyKFonlsWKBVAfoSMslCUhAAjUI9KZxWCObShJjTGoJz+gJQXmsdW6mSWB8Emj0PVw+l97mTe/+uFAey2VzvvkI9LY+dkaqM8WQiOJ865ho451t01mepg98AkNiJzfCc6oShbXal3/gn4YllIAEJCABCUhAAhKQgAQGAgEiFePWWo4WPhDKZRkaRwDlEU+JVtyjshWSxPhfkYAEJCABCUhAAhKQgAQkUDcBxvEqEzYBdEUkDrlpN0fixoqMHt3+LZe04B8JSEACEpCABCQgAQlIQAISaG4C0fKYg6+25AA6OSGoPzZ35fDsJSABCUhAAhKQgAQkIAEJlAjwHUj0RnTGluy+yhhIrJGsVCQgAQlIQAISkIAEJCABCUhAApkALqzoju3+qzEVbZLxkFGxVCQgAQlIQAISkIAEJCABCUhAAhUCWCBRIlva2tpCtj5W1jojAQlIQAISkIAEJCABCUhAAhKIBLKRMbmw4raK5TGPgdSB1ToiAQlIQAISkIAEJCABCUhAApkAcVfTcEcskMxkJZKpHqwZk1MJSEACEpCABCQgAQlIQAISGD1qdHJfhUQLlscxpsgUWWfM5z2kJAEJSEACEpCABCQgAQlIQAISiIFWW5LOCIoURCdH1EGRLOJPkYAEJCABCUhAAhKQgAQkIAEJQCAbGQmk00pCtkISlhXtUpGABCQgAQlIQAISkIAEJCABCUBg9Kj2CKwpCmvSIuM3INMKLJAOgkws/CMBCUhAAhKQgAQkIAEJSEAC0QLZkoLnJBQtaJFZmNeFNdNwKgEJSEACEpCABCQgAQlIQALF6KISNyf5q44cObJChUisigQkIAEJSEACEpCABCQgAQlIIBNIxsborpq0xaFDh6Z03FkVCUhAAhKQgAQkIAEJSEACEpBAJoALa5ZocGwJo0aNSt/1SArkl+vyNk4lIAEJSEACEpCABCQgAQlIoEkJ4MKahz6m70CiOOYEjZBNWis8bQlIQAISkIAEJCABCUhAAjUIYIHkyx3ojMmFNY97bCUaqxpkDWQmSUACEpCABCQgAQlIQAISaE4CGBzRGVEiKwokbqxtbW1ffiWyOdl41hKQgAQkIAEJSEACEpCABCRQIjAkxH9YH6MSmT7jkc2RJDoEskTKWQlIQAISkIAEJCABCUhAAk1OoAjx3xhP1RZm+E000UTpVxSjmxyPpy8BCUhAAhKQgAQkIAEJSEACFQLxYx0YHfm1YnXMSiTfgxzidyArnJyRgAQkIAEJSEACEpCABCTQ7AQIokO8HFxYY9SckCyPjH9MymQM0RoHQjY7I8+/FwSKg/2OaC+wuYsEmpaAz4ymvfSe+AAg4P03AC6CRWgIAetyQzB2mwmf8cjDHluz9TG7sao7dsvPDaoITDrppOHWW2+tSnWx2Qgss8wyzXbKnm8vCfjM6CW4CWw3nxnj54J6/zWeu3W58UzrydG6XA+lnm3TZV2OXqtIxYU1R9RpP4TWx3YO/q2XwJRTThlWX331ejd3OwlIoMkJ+Mxo8grg6Y9XAt5/4xW/B28gAetyA2HWkRX6Izojkj7jwSc8+KFR+h3IOgi6iQQkIAEJSEACEpCABCQggSYhgAsrwjjIIQ8//HCB4sgYyNdeey08OcNG4eORWiGbpC54mhKQgAQkIAEJSEACEpCABLokMNUkIcz50sVhjjnmaP8OJFujTTIOUpGABCQgAQlIQAISkIAEJCABCVQTSEMfczQdLJBpfiKtj9WgXJaABCQgAQlIQAISkIAEJNCsBMYMf2z/jEeOwso3PfgVcRikIgEJSEACEpCABCQgAQlIQAISgMCottEpiA5xc1ommmiipDhifWy3RgpJAhKQgAQkIAEJSEACEpCABCTQTmBINDQiGBxbmUGTZAwksvdKaeIfCUhAAhKQgAQkIAEJSEACEpBAInDppUOSwbEF5RErJK6s+dseMpKABCQgAQlIQAISkIAEJCABCWQCWVeMVsh2cyTuq4iRWDMipxKQgAQkIAEJSEACEpCABCSQ4+ZgeGzNC+3jH43AavWQgAQkIAEJSEACEpCABCQggS8JYH3873//G1588cXQihY5YsSINAYSa2Q2TX65uXMSkIAEJCABCUhAAhKQgAQk0MwEVlpppTDXXHOFdv/VSAILJOMhFQlIQAISkIAEJCABCUhAAhKQQDUBDI4tbW1tFetj9QYuS0ACEpCABCQgAQlIQAISkIAEGPqYvgOJFsmMYyCtFBKQgAQkIAEJSEACEpCABCRQi0AOvhqn0Qw5RonMibV2ME0CEpCABCQgAQlIQAISkIAEmo9A2djYwgI/lEc/4dF8lcEzloAEJCABCUhAAhKQgAQk0BUBdEV0RiQF0SHyKtFYszLZ1c6uk4AEJCABCUhAAhKQgAQkIIHmI4DBsZXTzoojSqRurM1XETxjCUhAAhKQgAQkIAEJSEACnRFAccToiK440W677XYIiiOBdD788MOw0EILdbaf6RKQQIMJvP766+HMM88MyyyzTPIC6Gv2V111Vfjxj38cttlmm3DPPfeEn/3sZ+Fb3/pWt9luuummYZFFFgmzzjprzW27W19rp3feeSdsuOGG6Zky55xz1tpkQKTdeeeddXOqp8A8YP/5z3+Gzz77LMwyyyz17NKrbR588MFw5ZVXhueeey7MOOOMYcopp+xVPl3txHvh6quvDk8++WSH32yzzRYmnXTSrnbt9brO+A2ksvTmfigDeeWVV8LFF18cbrzxxjD55JN3uO/6mvcbb7wRrr322nDHHXeEoUOHdqiDfc07nwMfkub5MsMMM4QpppgiJR955JHh/vvvDyuuuGLerEfTl19+OVxzzTUpX+rWTDPNVNm/r3mTUWf1inWff/55YnbppZeGDz74IMw///yVzvRGHJtjPPTQQ+kD3AsssACLnco3v/nNMHz48DBs2LBOtymv6Mlz4P/+7/9SvVhllVXKWXQ53xW3Lnfs4cr//e9/4frrrw8zzzxzmGyyydLe7777bvjHP/4RpptuuprPtwceeCDcd999YcEFF+zh0dxcAhLoDQGUx6effrr9fnz44YcLfvEmLGJDoYgv6fi8UCQggf4g8NOf/rSIN3Fx2WWXNeRwUYEs1l133eKLL75IeU4zzTR15dva2lpEpafTbbtbX2vHqEAWa6yxRhEbsrVWj5W23nrrFf/617/GSh/XCbCvl1N3ZXnrrbeKqDSna7r77rt3t3mv1x922GFFVA6K1VZbrYgN0iI25IvYqO91fp3tGBWddC7zzjtvMd9881V+jz/+eGe79Cm9K34DqSy9uR8yGN61008/fbHccsul+yP25BbnnHNOXl30Je+77ror5b3wwgsXq666ahE7h4ujjjqqIXnnTKKiV0w99dSpXvz973/PycW3v/3tYpdddqks92SG51ZUGoolllii+MpXvpLK/Yc//KGSRV/yJpOu6tUnn3xSfPWrXy1ip0ix0UYbFVNNNVXxjW98o2HHjh5exW9/+9t0XWNHTyXfzmaiQl7Aox7p6XNgxx13LLbffvt6sk7bdMWt7kzq2PCWW24posKc6tRNN91U2YN03o8/+clPKml5Bq6xgy6tz2lOJSCBcUuA+y52XBexs7BIYyBHjhxZUUR1Ya2gcEYC45QA32A9//zz0zHOPvvshhxrk002SdaviSeeuCH59SUTrBM333xzqLe3G0vg22+/3ZdDjtd9sbguvfTSyfK4wgorjLOy4Cnym9/8Jpx11lnh1ltvDY899liYe+65w5///OeGH/PNN99MFqZnn302PPPMM5VfVFAafqzu+A2ksvTl5I8++uiw8sorh//85z/p/oiN+oCVqxESFZWw5pprpjpx2223hYMPPjhERayhAfL23XffEJXf5DFBb3QjJCpCYYsttkhWuttvvz0cccQR4de//nUYMWJEn7Pvrl7hLYDlFEsWFlAsw1dccUWyuPf54DGDqLCF4447Lmy77baNyK6Sx7h+DnTHrVKQPs7EDrywzjrrhK233rrTnP74xz+GTz/9tMN6LJM8ExpVBztk7oIEJNApgXzPJQUSNxck6q2d7uAKCUigsQRi732Ivd/hb3/7W/rxws5CI5CXZhZcXXFrotH54osvBhTFaDVLrm+77rprpaGFS2NnLmQ0jpZccskwySSTBBSAc889N2efptF6kRQgXNI22GCD5KbQYYMxC6+++mrAzWraaacN0WIQTjrppFqbBRRkFJt77703rf/e974X9t5779RYwN0y9vInly46sDi3jz/+OOyxxx7ha1/7Wtqe59Evf/nLEC1fyQ2PhnZuRNDIi5aKEF3wQ7QYhAsuuCA1nDtjRln233//gCst5xcto52eH25siy22WHLRRCHEzRDh2L///e8D7oe1hPU77LBDiFbUDu53eV9Y0FCeZ555Ejsa9nQc4KrGtfzhD3+YhhLUyrucBi/cnrfaaquUHC1WYa655gofffRRWoZNtD6FaN1O+eLeFXvyA/zgDuu//vWv5Sw7naeBlt2aYVgtjTxWV/w4bndloX5xzquvvnpygYvWpHS/oKzhEklHxgsvvFB9CjWXuysLO8GUegLTjTfeOLz//vs186pOXH755cN+++1XafiutNJK6Z4ub9fbvHfeeeekjOYXPPcOzxjiHGTpbd7sT4fQ5ZdfHk488cScXYcpDL7+9a+ne4xnA8eqR6i7PJuyLLXUUoF6Hj0pclLi25u8u7uWPD9QWHHLRrgeCM/ZLL09L/bHFRcFda211srZVabcU9FTIT3fcHdH0axXunsOkM9f/vKXxJVnHkMZ8jOinmN0xY3z4TmGEougcPN8yx2AKHfcG/W0KSkTbvJ0GHQm0eKdnvHl9SeffHIgnWenIgEJ9A+B/G5J9/ajjz5aRD/y5P6EWVKRgAT6h0B8oSe3L1wComJTHH/88ZUDH3jggUVUXirLcexK2gYXc9y51l577SKOQSrii7uIY6iKU045JW173nnnJVcsFsqumbEBlNx9okKWXA9+8YtfFPFBUMQXftoPtzlcty688MIiWi6SS1ccD11EC0BlPS6usdFSxMZdgbsp7nKnn356Ea2dNV1w2Tc+0lJ+ZIJrJ9tGpan497//nVzVoiJccP7RipZc2HBbi5audMxDDz20iI2v5M7F9nGMZjp3Vp5xxhkp7+9+97tFbKQmF7WumHFeuDvBC5daXD9hiJQ5xTE3yTX0mGOOKZ5//vlin332KXDfhDvny/nEhkvar6s/saFblF1YYyMp7Rstk+m6RStUWo5jX1O+XDdcGWPDq6tsO6yLylAROwUKrmUcI1RERT2tz2zi+Nd0rXHLw5XxRz/6UXrW77TTTkVU/hP3DhnWWIiKanJbxa2Q+hLHhlXqGps38ljlw1fzY113ZaF+cS9ccsklBW5wcSxVEZW7Ilr5E3Ncfb///e+XD1PXfK2ycL/g0stxOB71FN49FepVVHiLLbfcsrJrX/PGfR3X0j/96U/FHHPMURx++OENyZt8eSb86le/SvlRp8r1lecSaTyLeIbEjqAidmxUjt3VDPUfhoccckhyuWW/2NlU2aUveVcyiTO1rmV5PfPHHntsuj94FiCNOjb1t9qFlecL92LstErPsdjJkZ4L9bqwUr7OngPRkpvcZnnm82yAJ8+vnriwkj9SzY33AG7/caxtWh87b1LeUWFNyxwrjrdN8/X+wZWY8nFPZeHZjqs+rrq4fGd56aWXUl2LHXqJX053KgEJjFsCtNcY7ogLa2D8IzP8VCDHLXhzl0Am8N577xXREphuRNJ+/vOfF9EykVcXcZByarDH4CUpjfFMNATKwgs3WgNToz5aIdOqzhTIvB83P8cm3/LLmkbr7373u7xZUp5YT+cSwnoUSJZJp+MJ5ZNftL4U0f2osm+eqaVA0hjLEq1gSaGkMYKgwEZLYl6dxsTQoMzHQfHk2LHXPikubJ/3Zad6mFEmxvUcfPDB6djsV1Yg8zg7lNFo8WJ1B0G5rWeceHWDKyuQ0dqc8uM6MOarPPYNRfWEE07ocLyuFmAVe/kTE8Y20ahCUOoYo5bLSWMU5ZT6gtCYhCMcupNomSkYk0XDEL4o+OR13XXXpV0beaxyWar5sa67sqBA0pDNQkOZDoosKNrR8pwX657WKgv3A+eeJVr+iuiGlxfrnjK2C0U3Wrsq+/Q17+jJkDp5aOAzpjBa0BuSd7QQpfG2MeBMyq+WAsk1yIISSz3LilhOrzWNwVOKaBlPSiTKI/WXzqksPDd6m3fOg2mta1lef8MNN1Q6uXJ6o45dS4GMVryCzqosTzzxRGLWEwWys+cA75Rofc9Zp2m08jZEgSSz6IVSRHfm1BEVvRQKOvO+853vpOMsu+yydXW0pY3H/OlKgYyBoZIiSacpwvOZdyJ1DAVckYAE+o8AHfHojMmFNY97jC+uulwO4ktBkYAE+kAgWsSSexbun5tttllyKcTVMwYnSbkSBTBaycJFF10UiE7I+EBc9BDcNaOykdx3cPtibBpRBLsSXMGiBSpFs8MlMTak0+ZRkanstuiii1bmcXMkEl5s0FTSmImKY1qmbLhG8sM1liid9Ug5siBul1Ghq+m2STquolGBrBwH91AEF1okBiIJPLOydMWMqGG4BRPxEre+aN2suP3m/ZlGi02IDdfA9cGlDBdWrkEW9s3Py5zWkynRUhHcQCg7LlhZcLOMr4C82O2USLuPPPJIwPX5qaeeCnvttVdlH6IW5nIyHpZjce5IjnBYz7GixS5d2+222y5FpmT8Gy7GuJxladSxcn6dTespC+6CWRia0Re+OZ/OprXqcmfb1krHHZq6xv3DvVCWvuTN2GOiU8aOl+TmjLt72XWxN3nj+sv4yhiQJxUzu5YyLbs2V+fNxtzLXQnuoZtvvnkaKxg7NZLraFS2AtebSK9ZepN33reeKcwoxwEHHBCiMtRhl3FxbLg8//zzKfp1PhjP0/IzLad3Ne3sOcAzufxMJ4/q5a7y7W5dVOiTSzPceMbglo3rKpFTSWN9o4RnMWNkcVuNnYZpvDeuv4oEJNC/BGg3xM7DNCyiokDG3ur0Isj+rf1bJI8mgeYicNppp6UTJqw+L1rG5yHRIpWm/EFhRJHJ4/1QkFAUGedEQAbCzaM8xKir3X5SgUYqx6Thz9iWrKhWDhZn+BxEFj4FwGcoUJjKQhl4RtCgpKHAjwdK7I0qb9br+azU0CChUU0Du3wc1lc3tssHq8WM9bHHOinsnCPjdk499dT0CYLyvnk+ungmhYzGHeMsaaAx/m6gCME+ogW1UhwUhtjzn4InVRIbNBMtMpUxoDlLxtDyvuhvGUhl6eu5oyAdEjtHGLPcqIBLNKxR8OlQQlCgGR8dLTuBwDR9Efbn2UNnFx0d/KgDPL/ys6u3+dNJxfhngs1kQZFj3B6fC+kPIUgU474ZJ1y+t8blsXnGoZiWn7vRi6CDQt7V8bt7DvDsLudNXpxnowRePPd5R0XLblKE6bAhSBSfg2NMZCMFhZGx22fF4GHUvej23cjszUsCEqiDAO0/fnRQtzCDFSIn1rG/m0hAAn0gQAOPlz8BJmjg5R8BVghsk62CBD2gARDH5CRlkkOiQOUfvf9EcY1jRrotDVYC9uM+xzIRx96MtU8cK5WienJMykTjhkAYZSG4BekEfEGJJAJoDIGfep/L2/VmniAW9GBTPgTLCZZCgvtgmeCbllhcM59ax6jFjO1ocLAfDz2+mxbdxmrtniy9BIcgwBHWSCyQWARo7KGso6jRuz6uhfqBkltLsLIRhTW6HIfojpysxCjaXIfeCI2yzuoQSgMNNyJVUt+wxnKNemNdoMMjjvNNFvXelHMglaWr8nd3nnTi0Elx0EEHpW/exWEkDCVJlpWu8mVdV3mjMBJ5lcBSKArUV+oIdZdAQt1JV3mj0KHclH88S+jwonOmO+kq7+jumAKhYMGi04bOGqyAKL54DXQnXeXd3b6s53h0FNGrznXJ1yM/h7rLo6v7p7t9Ubx47uNhwnuB525Z+vIcQMGLY8dTwKPXXnstBVciCFuWvnLj+ci3g7mnCViFMCUQEMfO0tU55G3qmfJ8w/OGQGtYp6nXigQk0L8EaEfSlmLakhujPDyzWbJ/i+PRJNBcBOI4xRQNFDfQssSxNslt8+YY6RAhOiDRTrHA5YibuB/i+oYChOUJ5ZIXa3ZXZD8adnma01HGaKywLYoakeuqO41w28JNiJ5rXD6Jtoi1KQvbs4xyxXq2W3zxxVNecXxZ3qzuabmc7IQLZgxIUlGEOEcYYWHFhSmOC0qNIc6JffO5lQ9YixnraayjhKL8xuA5qcGY9yvnRQRGWBEhlnMlCiyWW9w0iYRLtMFa1tucV57mc6teLqcz39lyHF8XqCe1BAssoe/jeMnkxouST13AqoWQZy02Oa98zDyN4/Aqrsl5mzzFdZXGGg1D6l620GCJQnpyLBRvjoWi053kspW3664s5W2Zh0FnHPpaFvKvLmNe7i7vHG2SukWHSP6Vo/vmvDgOkpe7yxtlBs8BXCHpaOAe5n4lYnKWnFf1cld54/5MBOPyD7bclzkKZmf5kt5V3igCRDrOzxRc7Kn7REPOn4vpbd75HPO0Oh/SiYTMswEliw6yfD3K91Pen2nOI0+7un+q96uujzy/icrLkAKuGcfmGZa368tzgOcm7wosqih7PDN4tmXp6prkbfI0n2tezlM6kmhM8kxFeE7g4VLuYOrqHHI+nU05bmbBNnRmYWmnAxNhfWdlSxv4RwISaDgB7nl+jKFJgyH5CDUDIxUJSGDgEyB4TOwh73FBCeYS3cU63Y8ANf/73/86XV9eEV1BK4FZyul9mee8oqWrQxZxrFBdgTg67NTJQrTKpCA8nayuJMOhFl/S+0MIyELkwe6EQD85OE5329ZaHzsnivh2SUGVaq3PaRyDwElci94K0TmJ4NtXGUhlqXUujTrPvuTNPR6VolpZdJo2EModrWI177tOCx1XjMtyd3Vc1tV7/3SXD9er1n3ciOdA9L6o+UzvL271nkN3jFwvAQkMDAJEX0ZnTGMgsTwi9OTE4qV5/0hAAgOXAG6VOSBLT0rJN+sYW9SZ8CwgOE09Qk95DsxSz/b1bJPdRcvbYrHCAtgIwVKXn3dd5cc2tfjWs29X+da7jgAY66+/frebxwiefboGjD8bHgMmYf3oSrjOBOCox3rYWT6cU/z8S2er604fSGWpVehGnWdf8uYeLwcUqpVXddpAKDdj6Grdd9VlLS+Py3KXj1Nrvt77p9a+5TSuV61nKefW1+cAFrxaz/T+4lbvOZR5OC8BCQxMAuiIDAlCX5wojpc4hATMkbEHLMRvZekSMDCvm6WSgASahMA8cRwmHx4f1+5ZKOy4n+GaOK6FRizHyi6P4/p4XeU/Lsti3mOTH6xMxj6Tjinj+v4Zl8+BcXlNypTG5TmUj+O8BCQw7gnQJqFTCAPCEFxYUR7RKAmPnwdDj/tieAQJSEACEpCABCQgAQlIQAISGAwECATHuOrkworyyA9FUhfWwXD5LKMEJCABCUhAAhKQgAQkIIH+IZB1RLwvUhRWfOQxS45rd6n+OT2PIgEJSEACEpCABCQgAQlIQAKNIoCeiBLJp+HSdyDJGG0ya5aNOpD5SEACEpCABCQgAQlIQAISkMCEQQBFsgW3VWbQJvP8hHF6noUEJCABCUhAAhKQgAQkIAEJNIoAnqutWB35scBPkYAEJCABCUhAAhKQgAQkIAEJZALZ0EjcnBa+a4biSCI/RQISkIAEJCABCUhAAhKQgAQkkAlkQ2MyOpKIJskYSEUCEpCABCQgAQlIQAISkIAEJFBNgGGPGBxbUB6xQuLGSqIiAQlIQAISkIAEJCABCUhAAhIoE8i6YrRCto97zO6rRmItY3JeAhKQgAQkIAEJSEACEpBAcxNAR0zWR+LmsJATslbZ3Hg8ewlIQAISkIAEJCABCUhAAhLIBNATs86YguigTTIGEmukSmTG5FQCEpCABCQgAQlIQAISkIAEMoFKEB0SUCIZD6lIQAISkIAEJCABCUhAAhKQgASqCSQFsq2trWJ9rN7AZQlIQAISkIAEJCABCUhAAhKQAC6s6TuQaJHMYIHUfdWKIQEJSEACEpCABCQgAQlIQALVBNAbkTiNkXTGKJE5sXpjlyUgAQlIQAISkIAEJCABCUigOQmUjY0tLPBDecQsqUhAAhKQgAQkIAEJSEACEpCABDIBdEV0RiTZIXFdnWiiiVJiXpE3dioBCUhAAhKQgAQkIAEJSEACEsDg2AqGbIVEidSN1YohAQlIQAISkIAEJCABCUhAApkAiiNGR3TFlqRFxm9AIlofMyKnEpCABCQgAQlIQAISkIAEJAABlEd+6IstzGTJiXnZqQQkIAEJSEACEpCABCQgAQk0NwGMjkl5xAIJipEjR1aI6MJaQeGMBCQgAQlIQAISkIAEJCABCUQC2fCYFMihQ4cmKGiWigQkIIGBTuDvf/97+O9//1uzmG+//Xa44oorwjvvvFNzfT2J7LvGGmuEO+64o57N3WY8EXj00UfD1ltvHTbYYIOaJdh0003DAw88UHPdHnvsEQ477LCa6xqd2KhjdXU+1WVu1DGr8+3Lcn+UqRH37v/+979w5ZVXhnfffXes033++efDscceG66++uowYsSIHq//6KOPwvnnnx9OOeWU8NZbb421vwkSkIAEBiqBrDyiL0aDY0sYNWpU0ihVIAfqJbNcEpBAmcCGG24Y1lprrfTsKqczf+SRR4bNN9883H///dWr6l7mIZl/de/khj0m8Pvf/z4ceOCBPd4v7/DDH/4wvPLKK4FpLbnuuusCHQq1JL8Ia60rp919993hq1/9ap8+c1XvscrHrTXf1fmsv/764YYbbqjs1qhjVjJswExPytTbusEx8q83Rb711lvD0ksvHb7xjW+Ehx56qEMWF110UZh33nmTArjDDjuE5ZZbroMHV3frqYvs/4tf/CIcf/zxYY455gj33Xdfh2O4IAEJSGCgEkBPzM/XVnxZc8JALbDlkoAEJFAmMNVUU4UPP/wwXHPNNWGzzTarrPriiy+SAllJ6OXMDDPMEG6++eZe7u1u9RJ46qmnwvvvv1/v5mNtx/5HH3106jAYa2U3CX/84x+72aJ99XvvvRdQKvrynqz3WHUVqJON7rzzzg7Kcn8cs5OidJrckzL1tm705d697LLLwjbbbBN+8pOfpHpVPhGeN6TT4fGb3/wmUC/mm2++8Ic//CH88pe/TM+jrtaT1z777BNmmWWWZBVvjcELsZ5///vfT94UPVGuy+VyXgISkEB/EeA5hdERSS6sedwjDzStkP11GTyOBCTQWwKTTz55mHbaacPJJ5/cIYuLL744TDbZZCG75bMSJXPJJZcMk0wySVh44YXDueeem/Z54403wiKLLBJOPfXUtPzZZ5+FlVZaKRx11FGhra0tzD333OHee+8Nn376aZrH3XGeeeZJx6XRePbZZ4dhw4aFaaaZJlnA8kMV6+dJJ52U8uTPTTfdFBZaaKG03NO8KpnEGcq0//77hznnnDNMMcUUycX26aefTptw3quuumr46U9/msqz4IILhltuuSXsuOOOYcoppwzDhw8Pf/3rX3tVBt4JHHeBBRYI0003XbLMvPzyyymvM844I3z9619P8/nPoosuGm688ca0+L3vfS/svffeYZ111knlwKqTXY932WWXcOGFFwasarB+8skncxaV6auvvpqUw+mnnz7MP//8yXJDp+fHH3+c9sHVkPy/8pWvVPapnoHDYostlo6/8cYbVxTWH/zgB+HXv/512hxXRPKZbbbZEj+uIfUDV+jvfve7aRsYHnPMMWm+s3KxkmtBeXbbbbdAR8cFF1wQysdiG+ok14u6irXr8ssvJ7nLa5w2qPGHGAaUDSa4iH7ta19LW5WPyXWgbqy++urpmBtttFH4z3/+E1ZeeeUw6aSThlVWWSW88MILldwpH+dA3SG/bCXL9RdFkOvMetxq4ZGlKzblMuU6+/Of/zzMOOOMicPpp5+esqlVNzq7Rvm4eVq+d0l77rnnwnrrrZfuGe6dQw89tNN2Du6luKbmepHzZIolmvqGEohwL+y6667J1ZXl7tazDW6x7E9bC9lvv/2SMvnSSy+lZf9IQAISGMgEaA/wyUfew+Hhhx8u+MWGUhEfbnGdIgEJSGBgE4i9+EV0cSti51fxzDPPVAobG71FtAYUseFe/POf/yyidatgW9KiS2sRXceK2INWRFeytM+JJ56Ytn3xxReLfffdt4gKZREbyUVsrDIgvLjtttuK2KhM8yussEJxzz33FNHilZaXWWaZ4q677irOO++8VI5//OMfKc/YKC8OP/zwSpmuvfbaIjbS03JP86pkEmeispXOJSo1RRybWay22mrF2muvnTaJilwq089+9rN0nlFBKOJDvvjRj35UxDGAxU477VREhbuID/0enw/sYmO5uPTSS9NxozJYREU8MYoKVREVoHIxi6jcFrERntKiq3Ex8cQTF1HZLv79738XXJ9NNtkkrYtKaBEVtSIqKMVjjz1WROtxh3yiYlRExa+IrsrF7bffXkQlq4iKZBEb3UVU1tM+UXlP1yNaqzrsmxdiQ72IVqIiKvHFJZdcUsw000wFjJBouS6ixSjNw4+8uZ7RbbHgGu65556p/sSxaokt70nqTVflIrN8LaLiWUTltYjj3DocKypuRezMSOfB/AEHHJDq5OOPP97lNSZvzod6XRauKfyiMlrEjo3K/VA+P65D7HRJDGAx88wzF1H5K+JYvFSnY+dAES1hKduo4Kf6Gq1sqV2w8847p3oXxxZW6k5U+ArqIdd0+eWXTz927o5NuUyZU1TCCjhEBT5x4Z6tVTc6u0ZlFsyX712WOfc4RraIYxdTmaOFMl0X1nUmn3zySbrmsMoSXU6L2IGUF9MUflNPPXWa72597JBIeXKuWajzPMPimO6c5FQCEpDAgCYQOxhTOyM88sgjxYMPPljEHsbiqquuGtCFtnASkIAEIIBSSAMWZQbFD+E5htIUe/MrCmRaEf/QyI4uZ0W0co3VMIwWtCKOZUoNcBrPSLkRmpW+v/3tb2kdedFYP+ecc9Iyf+K4puKEE05Iy/UokPXmVTlAaYayoZQcfPDBSTljFY1rGrIoVgjPchqmNIQROghRiNmvp+cTLX9FDBqS8uHP66+/XmkI16NAfvvb367sG62gqcwoGgiK7RZbbFFZX55B4afMcYxjJTlavjo04lEG4rizyvrqGRQu2GRBGaLOIGVlhvNDwYZbtETnzdM0WkhTOTLb7srF8ejAyOdYfaxozS2ipbvDMXghR0tZJa3WNWZlLQUy78Qxo7UzL3Y4P5SoaIWsrNt+++0rijyJdKzEoFFpPeVDcUdZ5pcVHzqYc92Jlv+0LX8yj2jBrMx3ds3KzOHEfZQ5UVfpaKGjAqmuG11do7TDmD/le5ckOi04N54P9UotBRIudCKV5frrr091I1p/i+7WlzmV86DenXnmmeUk5yUgAQkMSAK0f3hP0lZqiSVM7hyYJCtmyYFsP7VsEpCABMYQ2H333UNsfAXGPhLVEBdF3NSykB6tcMndbNZZZ01un6yLD8G8STjuuOOSi15UZEK0KlbSq2dws0MYAxAb8iEqbJVNcAPkWVqv9CYv3FXXXHPNgPsuY69wxYuN5cohcanLwxGi1S+VkW0RXCWRchnrKQP5P/vss8n1N2UQ/8AR9+Fo9cpJXU5x880y11xzpTJnd9+cXmtK/riAEmgkCy7H0ZIUcDeuV2odv3pfgvAw9m277bZLLqy4ZWb34Opt6ykXLrfUkVoSLY3J/bO8DpdS3KO7u8blfXo6H62vlV1w8e6s/uLCSXRbXJb54faN4AqaBZfgLFwT5Iknnkh1oifXLFpCK5yoq4xfxE22lvTkGpX357lA22bZZZdN4w9xIS3fN+Vtu5rn+rz22msdNsFdF664lHe3HjdjpJwH58oYYPZVJCABCQwGArSf+LXQGKJRwULsCaw0QAbDSVhGCUiguQnQ0GdsY7RmpLGNKJRlYSzXaaedlsY10Vij8V4tjG1kPFd0ccSlv3p1j5dRHMrh+fsSJKZ8cIJ3oBDTkCegB2M3aXCPS0ERRelDactC8BDOCeWi+lwpX0+UO/IsK7X5GEzJP1q8OnyOhXNHIcwKcXn7vsyTH+Np+WwD4zdRDBiHV5bc6dDXcjE+tVo5RWHj2H29xp2xLJ9Hd/NEc+XHdc4/8mUMZRY6FbLkukGnRl/Z5DzztHw+9VyjvF95usQSS6TotJwLAZei23p6JpS3qWceRRrlL7q7VzbnMz9Zwe5uPZ0uBNApfxooz+c8Khk7IwEJSGAAEkBnpAOSzuoURIfeOSQrkwOwzBZJAhKQwFgEUGBo6O+1117JMrbuuut22IaAGjRCebZFd7xKAIy8EVEXo8tciOMUkwUquvb1yjqR82OKRQYrDgF44vjMsaI5lrftyTxWu9TrFx/c0R2vEtClJ3n0ZluUdKJOEuUTZYFAKChxWGtzo/mss85KfON4yQ7W3e6OR9Aagupgvaq2Si611FJJecXyxHHj+MQU3CSOoewu2x6vR3HjUx0oCBwXq2dWUmefffaUH3WFQDV9LRflhyUBeaI7cLKcL7744kkx6cs1hmUch9shEmuPQcQdsIbyORA6KLhnCPzC9c7KDnkedNBBIY4HTorwj3/846Q4okD2lU25vNV1o6trVN6vPM/9guUxupemZ0B0QU3WwmyZL2/b3TyBhqjzeDQQYCm6oaeOK84f6W4927DtEUcckZ4NKOEEENpyyy2TYsl6RQISkMBAJkB7ivcUbaqKCyuJWZEcyIW3bBKQgAR4ePFDUCB5oBERMafl9TTWiRKKcpAjbOZ1NI5RToi4ODy6l2GdQIFAWSpLOc+cnvOotRyDogQsdzRWibCJBSS7lvY0r5w/UxrtWDZpzMfgOR0ij5JvPkZ5nzxfPm55vrw+p5PGfF6GC1FUiWSJkoAyF4N+pOidlAO3T64B7oh8xL2rxnnOM0/Zl3KjdFe7xMKQ4xChkuPSORDHsiWX43K5uzrvfC55+/JyLgNplB9lg2iwRNWlHuSIq0TwxTUaF1ei73ZXLvKtLlP5WDH4UbKAEckU5RTlhnmUk66ucT6Hcl45jSmdKFjRqetIZ9uxjvJVl5F0hO+rxvG8Acs813TbbbdNShNRWbPw+QnqA9ZUrjlKJserh03Og+07KwPbVNeNrq5RzrN6Sv5xrHCggwOXXRRcOkS4lj0VOqviuOdABGKeJVtttVWIgZbSlLy6W882RF3N9y5RhXF9rY4kzXaKBCQggYFIgOc2+iLvyyEE0WGGBhhuO/Q+KhKQgAQmJAJYjnjw0WDrLyHkP43W8idFGnFs8sUdrr87/LDmfv755+nTDdXngdsq6xn/1lPhZYTrK+NIOxNcWbEI0kgflxKDp6QXY63zoIzZdSeXoa/l4lrWckPu7TXmGvA+R5FrhNDJwnjOXNe4j2CD9RHLHudPXawlfWVDnrXqRlfXqFY5chqKLmVtRB3ikye4o2YrdT5Gnna3Hnda7iUUUUUCEpDAYCKAhxVeOultjPLIjxcPD2waWooEJCCBCYUA36vrb6mlGDSiDOMq3+7KRsO7M46dNaS7y5PbnswUAAAk00lEQVT1vG+6Uh7ZppZCR3qjpasOBsbaVktfy9XZtewsvfr41cuNUI7KeZYD75TTmUep7Ex5ZH1f2ZBHrbrR1TVin84kB43qbH1P0odHj4WupLv1BLxSJCABCQw2AuiICO+a5MKKmwcPahXHwXYpLa8EJCABCUigfwjgnhw/axIWWmih/jmgR5GABCQggQFDAD0RJRJvl9asNKJNZs1ywJTUgkhAAhKQgAQkMCAI0Nm8wQYbDIiyWAgJSEACEhg/BNAdW9JAyDiTx05khXL8FMmjSkACEpCABCQgAQlIQAISkMBAJEBnYitWR34s8FMkIAEJSEACEpCABCQgAQlIQAKZQDY6EjenhYHwKI4k8lMkIAEJSEACEpCABCQgAQlIQAKZQDY0JqMjiWiSjY7elg/mVAISkIAEJCABCUhAAhKQgAQGNwGGOmJwbEF5xAqJG6vjHwf3RbX0EpCABCQgAQlIQAISkIAExgWBrCtGK2T7uMfsvmok1nGB2zwlIAEJSEACEpCABCQgAQkMTgLoiMn6SNwcFnJC1ioH52lZaglIQAISkIAEJCABCUhAAhJoNAH0xKwzpiA6aJOMgcQaqRLZaNzmJwEJSEACEpCABCQgAQlIYPATqATR4VRQIhkPqUhAAhKQgAQkIAEJSEACEpCABKoJJAWyra2tYn2s3sBlCUhAAhKQgAQkIAEJSEACEpAALqzpO5BokcxggdR91YohAQlIQAISkIAEJCABCUhAAtUE0BuRVmbQJkeOHJnGQJJ4xRVXMFEkIAEJSEACEpCABCQgAQlIoMkJbLrpphVjYyuWR35Zkcxsll9++TzrVAISkIAEJCABCUhAAhKQgASakMC9996bdEV0RqSVP7iuTjTRREmRzCuyiZL1igQkIAEJSEACEpCABCQgAQk0NwE8V5MCma2QKJFZcXQ8ZHNXDs9eAhKQgAQkIAEJSEACEpAABFAc0Q/RFVuTFhm/ATlixIhkgcyIsiKZl51KQAISkIAEJCABCUhAAhKQQPMRQHnkl4Y+li2NObH5kHjGEpCABCQgAQlIQAISkIAEJFCLAEbHpDxigbz++usD34JE3n333bDxxhvX2sc0CUhAAhKQgAQkIAEJSEACEmhSAnfeeWd46qmnQuu6666bEODC+uqrrzYpDk9bAhKQgAQkIAEJSEACEpCABGoRwFP1K1/5Shg2bBjjIFvCqFGjkk8rpklFAhKQgAQkIAEJSEACEpCABCSQCeQgOiiS6TuQOSFvwLQ8NrKc7rwEJCABCUhAAhKQgAQkIAEJNA8BdEOMjkhL+hOtkEhrjMaqFTKh8I8EJCABCUhAAhKQgAQkIAEJRALoiHzyMQXSgUh2YyWYjpZH64gEJCABCUhAAhKQgAQkIAEJZALoiPzQG1uYQZPMiXkjpxKQgAQkIAEJSEACEpCABCQgASyQ6IxMW/iTTZLZLCkiCUhAAhKQgAQkIAEJSEACEpBAJoACya8Vy2NWIkeOHJnMkmyEeVKRgAQkIAEJSEACEpCABCQggeYmgM44dOjQdhdWUGB5RLIymRb8IwEJSEACEpCABCQgAQlIQAJNTwCDY/70Y8WFNbuxNj0dAUhAAhKQgAQkIAEJSEACEpBAhUA2NOLCmoLokJBdVplXJCABCUhAAhKQgAQkIAEJSEACmUDWE1tJwBzJL0fWIS1vwLwiAQlIQAISkIAEJCABCUhAAs1JAG9VpLW1NbSygPUR5bGsNOaNmhORZy0BCUhAAhKQgAQkIAEJSEACEEBPRD9sa2trj8JKItpkWWksK5OsVyQgAQlIQAISkIAEJCABCUigeQmgI7ZkyyPaZJ5vXiSeuQQkIAEJSEACEpCABCQgAQnUIoDnausrr7xS+Q7k22+/XWs70yQgAQlIQAISkIAEJCABCUigSQlgaHzrrbfavwOZBkJG91Wk7MLapGw8bQlIQAISkIAEJCABCUhAAhIoEcDyyG+iiSZqHwNJBFYUSRKzlOdzmlMJSEACEpCABCQgAQlIQAISaD4COZBOMj3mADoqjc1XETxjCUhAAhKQgAQkIAEJSEAC3RHA+oi+2MIMP4QE3Vi7Q+d6CUhAAhKQgAQkIAEJSEACzUMAHZFfUiI57ZzgpzuapxJ4phKQgAQkIAEJSEACEpCABOohgJ6YdcUW3FdZGDp0aNIo84p6MnIbCUhAAhJoHgJPPPFEOOOMM8Jxxx0XbrrppnHisfLYY4+Fe++9dyyoL730UjomK/73v/+FjTbaKNx9991jbdfohEYd649//GM47bTTuizeM888E/785z+HU045Jdx1111dbtvXlffcc0/Ycccd+5qN+0tAAhKQQBMRQE/EApnGQGYLJMF0sqhIZhJOJSABCUgAxXHfffcNiy66aJhmmmnC73//+7DGGmuE8847LwVhaxShs88+Ozz77LPh0ksv7ZDljTfeGI466qjw6KOPto+/YAxG/HX3rtpiiy3CnnvumcraIcM6F9JYjzqP1VWWDz/8cJhiiik6Le8uu+wSLrnkkrDAAgsE3sXPPfdc2HTTTcNJJ52U9usq796s47NddAJ0x683ebuPBCQgAQlMmATQGXkvtjKD9ZFve5CgSEACEpCABMoEeD/89re/DT/5yU/CwQcfnFbdf//9Ye211w7//ve/wzrrrFPefJzPTz/99OGaa66p6zj/+c9/wjvvvFPXtrU26smxau1fT9qxxx4bLr/88nD11VeH1VZbLe1yxx13hE022SSsuOKK4Uc/+lE92biNBCQgAQlIYJwSoNMxKZHM0NtJA8GeyHHK3MwlIAEJDEoCH330UXIbXWqppSrlX2aZZcJ1110XFlxwwZT22muvhe233z7MPffc4Stf+Upyxcwb87L5zW9+E5ZeeulkYdt9993Dp59+mlf3eNrW1haWWGKJgBKLXHXVVWHllVcOs8wyS1h99dXDLbfcEkaOHBmWXHLJ8PHHH4ef//znYbPNNkvbUpZDDz00LLvssqms2267bXjllVfSOspEvijLTFlXfax8nsOHDw+LL754OOigg9KxyAA322222SbMNddcictee+0VRowYkfLu6g9uq2yblUe2hSHlyMrvFVdcEdZbb72w9957h2HDhiVrJWXjXBZbbLEw++yzJ7derLcI26+//vrhD3/4Q5hnnnmS5Rjln/MvC5ZkrJ4LL7xwsiqX1zkvAQlIQAISKBPIxsZW/FhRHL/44osOFkiVyTIu5yUgAQk0L4Fpp502rLXWWskV9MEHH0zzWMZWWWWVBAVFZuuttw4zzTRTuOyyy8Ljjz+eFJ1ZZ501WdFQYnBNPeGEE8LUU0+dlCWsmaeffnpNqO+++26ybJZXPvXUU2kxv5tQ+lDOPvjgg7DzzjsnRWrjjTdOiisuq/fdd19SsnCzZRl3UPY97LDDwllnnRUYk0j5Dj/88ICbKxY/lCvyRfnCXRbFCsnHorN1yy23DNNNN1248MILwxtvvBF++tOfJpde3Ht//etfh88++yxceeWV4fXXXw/f//73A0p3HmvI8XP5U8bxz1tvvRVQSrHmVq/bdddd82bhk08+CVhT55tvvnDxxRcnBRUrLC7EjEmF/a9+9avEHYWa7RnnOPnkk4eLLroovPDCC8mCjEWVMiMffvhhcpUlPzoDjjjiiPC1r30tLL/88pXjOiMBCUhAAhKAQPZW5V2VXFhJyIqkiCQgAQlIQALVBM4999xw4oknprGJKCxTTjll2GGHHZLShML4yCOPpMAvKDJYvFBuUCZxw0R5ZIwfSieCtW233XYLp556anr3VB+L/LBSlgVLIsesFqyGKLDvvfdeUpawdPJDFlpooTQ+E4sdZUIoExZJFEqEMrAd5c8KI/tvsMEGaT2WzCwE+KFsjGecc845U/K8886blDUWskJMmWabbbakoD700EN595pTxjoiw6NFM8t3vvOdZDlleaqppkpKIvOcP0o4we+QzTffPP0oI4o0yvIxxxyT1uU/lGmGGWZI7AmChHKbFUgaASjKKPVYa2EBBxXITM+pBCQgAQlkAlgfs8dqegvxEiExu7KyYbWbS97ZqQQkIAEJNB8BLFlY2fi9+eabKRorlkVcVrFQIrhMZkGhwcUT7xYsbFi3Tj755LSadcirr75aUcRSwpg/q6666lhBdM4888yk7PBuyu8npihqxx9/fGAcIcoQx8TNE+UqS94Hi+Xzzz+fFMWcx8wzz5wUKBTD+eefP+2CEpzXl6coYATCQSHN6bi6IiwTBAflE4slgYZQanGtzdsyzfNpp/iHvBBYcC4ISjdlZXzprbfeWtkHyyedvTkP3FWxrhKxdbLJJqsonXk954HFMS/jbkwk2LyMcsqPZdoAWGQ///zzyvpUGP9IQAISkIAESgTSO4NlZrIVMvu2lrZzVgISkIAEmpjA008/nVw/UQYRxhruv//+aVwd67DCIVjbcJXkh/KE8jPxxBMnJQklr7yO9dmKl3buw5/tttsuuaziXouVc6eddkquoTnLrDBRFo754osv5lXh/fffT66cuIZ2J1gocQ1Fgc6CcoxSiuK1xx57hK222iqNhcSyuOaaa4ZJJ500b1pzythFfhdccEFlPeMov/vd7yalLo8xrawszeCOyzV54IEHwssvv5xcWVEyszB+kvGrWeCPwq9IQAISkIAEekqAdylGx4oLKz2aKJD8srBSkYAEJCABCaAw4r7Kpx+wQOLyeO211wbGJf7iF79IAWfmmGOO5JpKoBbGAeKmutJKK4VDDjkkuYMSrIVALcOjq2b+juRtt93WYex9mXT1OygvMy3PMy6QsYa4buLCiSsmLp6TTDJJ2o6y8wkQxnDOOOOMYcMNNwxHHnlk2g7rI+VFgWOsIq6wSPUxchrWTRQwxm9ifeUbkQTa+fa3v53cYnm58sOlFGskCjSus+Xy5vl0oDHHYuwiLr2UFcUR6yNjG8kD99/yPuX5/N7mHY7rKdcol5UpZcFCyTVAecQCjHJdzqM8n/etTiNdkYAEJCCB5ibAu4Ef75bWssWR+bIS2dyYPHsJSEACEoAA7pgEYkHJOeeccxIULGsokzk4Dd9tJOgLkVZ5ueDOmsfaEU0US983vvGNZMFDqULZKb9/MunOlJfO0hmvx3hFxg2ieOGySYCc7FbLJzAOPPDAcO+996YgNATNoSy4uGJNpLyUnfNhGensWHzyim1/8IMfBKLQorgRuAeXWVxIiYiKsnb00UenfHHFzefYWZ4cD4sjSicRXX/3u9+RlMqPW26OHsv+Oa+0QfwDfxRYvs3J+VIWFPssKPWMm0Q5RqFm/QEHHJBW18ov7+dUAhKQgAQkUE2AdzvCu2jI7bffXtDrSiJR43iREYGO3lpFAhKQgAQkUCbAe4KANritokBVCy6TpDNmslpQklDSsnJXvb4vy4zhRzEkYEy18I6jcxQX1iyk4XZaKzBP3qarKeeJUlbOk+3JlzGetcrRVX6s4z2Mey1TLJ3VCmNn+xO1FiW/fD0IeoTVl4A/XC/WoeQqEpCABCQggZ4SuOmmm1KHJhHI8dppJQPcfXixZ82StK56S1mvSEACEpBA8xHgxdGV4N7amaBsVStcnW3b03TeY7io1hIsh9VCWq306u06W+7sPMmzs3J0lldO572LdbanUktZze9wpgTKUSQgAQlIQAJ9IcD7BF2RX3JhRXlEygpkXw7gvhKQgAQkIAEJjD8CfFeyN8ro+CuxR5aABCQggYFMAD0RJZJfK2495YSBXHDLJgEJSEACEpBA9wSwFHdnLe4+F7eQgAQkIAEJtBNAcWS4CNKS/sTBkAhjJLRCJhT+kYAEJCABCUhAAhKQgAQkIIFIAB0RXRHjYwsLDNRngcH/aJeKBCQgAQlIQAISkIAEJCABCUgAAtl9Fb2xlQWUx5yYEalIZhJOJSABCUhAAhKQgAQkIAEJNC8BjI7ojEjyXc1WyGyWbF40nrkEJCABCUhAAhKQgAQkIAEJVBNAgeSXLJAokPxwYa33u1PVGbosAQlIQAISkIAEJCABCUhAAhMeAbxT+WQW02SBxPKYBUVSkYAEJCABCUhAAhKQgAQkIAEJQAAdMQ97TEF0sgWyrEiKSgISkIAEJCABCUhAAhKQgAQkgOUxK5HJhTWZIsd8yoN5JE/FJQEJSEACEpCABCQgAQlIQALNTSAPdUwWSD4KmQdF6sLa3BXDs5eABCQgAQlIQAISkIAEJFAmkHVExkGmMZBZm9TqWMbkvAQkIAEJSEACEpCABCQgAQmgJ2JwxPDYkpVGtMmsWYpIAhKQgAQkIAEJSEACEpCABP6/vTsJtata8wC+6nLUiNEkFgbbPJFng5RNRA2C7URnao2cKjhRRHFgH6eCouLEkSCCHYqgA5vYVJUNdii2CDEK+rAKQ2wSNea9JFde3f/S73K8Jj7b3JNzfgtOdnv23ut3zrl7f/nWXpvAXIFB9aazdevW2Z51slIFlnPfYJoAAQIECBAgQIAAAQIEJk8gLVcHyTrmlYlqyhoK2cjJ+0KoMQECBAgQIECAAAECBOYKVNIxw0Ee3ZGR6enpPqyVZSBLwpAAAQIECBAgQIAAAQKTK1CJxsSIvROd3AyZQFLQOLlfCjUnQIAAAQIECBAgQIDA9gQSKybxOFXBoyar26MynwABAgQIECBAgAABApMtUMnGmWxkT0LONl8VSE72F0PtCRAgQIAAAQIECBAgMCyQGLFnH4c70cnMiiqz8vD48JuNEyBAgAABAgQIECBAgMDkCCQ2TLyY11TufcxIhslGChwn54ugpgQIECBAgAABAgQIEPilAokVZx/jkSAy90MqBAgQIECAAAECBAgQIEBgrkASjr0TncFg8KNnQM5d0TQBAgQIECBAgAABAgQITK5AEo4/3Ac51TOPmdB8dXK/EGpOgAABAgQIECBAgACB7Qkk+9jvgexpyJmJ6lVne28wnwABAgQIECBAgAABAgQmT6CSjf0eyExU8JiIsopsZEkYEiBAgAABAgQIECBAYHIFknRMzJh4cRCGBIs1MwtqXh/xDwECBAgQIECAAAECBAhMvMBsAJmR9MBaj/KIzKpVqyYeCAABAgQIECBAgAABAgQmXSDxYiUd+2M8EjhWU9bgnHvuuZNupP4ECBAgQIAAAQIECBAg8INAAsh+62Pd61hRZTVhJUWAAAECBAgQIECAAAECBBIr5pXbHvs9kNPT07OP8MhMhQCB0RB45JFHRuNAHAUBAgQIEJgnAS3j5gnebgnMEajEYw8gB4NB27p1a48q56xnkgCBeRY4/vjj5/kI7J4AAQIECMyPwOuvvz4/O7ZXAgR+JJDgsbKQg2QcEzymZKZCgMBoCWgVMFqfh6MhQIAAAQIECEyaQOLEBJF5DXLP4/CMScNQXwKjLlDNBUb9OB0fAQIECBAgQIDAeArkejRP7UjpTViT4Uggmd5YK5gcz6qrFYGdT0AGcuf7zBwxAQIECBAgQGCcBBIj1pM7pjJRAeRwZzrjVGF1IUCAAAECBAgQIECAAIHfJlDNVxM3TmUi2cea+ds26V0ECBAgQIAAAQIECBAgMI4CSTrW4x77MzsqC1lpyXGstDoRIECAAAECBAgQIECAwG8TSACZ1yCZxwSQeaUJq/utfhuodxEgQIAAAQIECBAgQGAcBRIz5tGPfZgKJvOY4DElgWQWKAQIjIaA3+NofA6OggABAgQIECAwqQKJEeu2x96JTmUgE0gqBAgQIECAAAECBAgQIECgBJLQqCCyd6KTGdV0VbajmAwJECBAgAABAgQIECBAIAIVL/YMZB4KWTdFJrJUCBAgQIAAAQIECBAgQIBABCpGzH2QvRfWiiZlH31BCBAgQIAAAQIECBAgQGBYIHFiEo5JPPZeWLMw0WRFlsMrGydAYH4F6j945vco7J0AAQIECBAgQIDATFPW6k0nvbDWOBgCBAgQIECAAAECBAgQIDAskMTGIFnHvDIh0zHMY5wAAQIECBAgQIAAAQIEKtGY4VQe3ZHAMUFkZigECBAgQIAAAQIECBAgQKAEKtGYeyEHmZmbIRNI6kSniAwJjI6A3+XofBaOhAABAgQIECAwqQLVkc6ggkfZx0n9Kqj3qAvo3GrUPyHHR4AAAQIECBAYf4FKagzmNl/NxWotHH8GNSQw+gJ+j6P/GTlCAgQIECBAgMA4C9TtjokdpzJRLxeq4/yxqxsBAgQIECBAgAABAgR+vUDixIoZeyc6majOdASRvx7UOwgQIECAAAECBAgQIDDuAokVZx/jkSAy90MqBAgQIECAAAECBAgQIEBgrkCasPZOdAaDgeBxro5pAiMioFXAiHwQDoMAAQIECBAgMMECSTim49XeiU4yj5lwoTrB3whVH1kBv8uR/WgcGAECBAgQIEBgYgSq89WZ4UxPOjOvBJAZKgQIECBAgAABAgQIECBAoAQq2ZjExlQmKnhMWlIhQIAAAQIECBAgQIAAAQIlUAnHxIuDzOyR5A9ZyAoma2VDAgQIECAwLgKrV69uL730Uvv666/bMccc004//XS3b4zLh6seBAgQIPCnC8wGkBnJfZD1KI8/fc92QIDALxZwD+QvprIigZ8VuPPOO9sVV1zRjjzyyLZo0aJ24403ttNOO63de++9LZ3J3XbbbW3jxo1t5cqVP7sdCwkQIECAwKQJJF6spONUJhI4ZkayjwoBAgQIEBg3gZzfbrjhhnbppZe2F154oT366KPtiSeeaE899VR77rnnenU//PDD9v77749b1dWHAAECBAj8boHEihUvTmUkpaJKQeTv9rUBAgQIEBgxgW+++aZ98cUXvdlqHdry5ct7EHnYYYf1wPLhhx9uzzzzTDvqqKPaBx980Fd7/PHH21lnndX222+/duaZZ/bAs95/8cUXt+uvv76dd955bd999+3NYR977LFabEiAAAECBMZGILFiXrkXst8DOT09PXsPiJ5Yx+ZzVpExEaj/5BmT6qgGgXkRWLx4cTvjjDPaZZdd1t5+++0+fuKJJ7aTTjqpH8/VV1/d1q9f35uwpmnrwQcf3N588812/vnn9/fcdNNNPdi84IIL+vCEE05on332Wbv//vvbNddc06699tp23333tQsvvLA9++yz7YgjjpiXetopAQIECBD4swTqmrQ/tyP3fqQkqlQIECBAgMA4Ctxzzz3tkksu6QHgOeec0w499NB23XXX9T4ADjjggJYgc88992yHH35423XXXXu28dhjj+33RGaYQDGBY5q/Vjn11FPbVVdd1bI8gWe2k2axCgECBAgQGCeBBI9DWcipfvJMBQWQ4/QxqwsBAgQIDAvsscce7corr2yvvvpqv9cxTVBvv/32ls51tlVyP2SCyeGS6fTkWmV4eU6uaQ5bzV9rHUMCBAgQILCzCyROzHkur0HueRyesbNXzvETGDcB/7Ezbp+o+syHQIK6Bx54oPfCuttuu7WlS5f2jGKyiWvWrJn9X9U6J+YYDznkkPbGG2/86D9XP/roo96La/0uP/744x8tz/Txxx//o3nzUV/7JECAAAECf6RAAsc8tSOlN2Gt+x7TG2udFP/IHdoWAQIECBCYT4EEjMk25jEen3zySfvqq6/6PYsJHk8++eR+aOkI55133ukBZU6S6TTn5ZdfbnfccUdbu3Ztz1Q+//zzvVOdqsvTTz/d7rrrrvbpp5+2m2++uWc2c6+lQoAAAQIExkkgMWJixfxH6yATCSDTkc5wZzrjVGF1IbAzC+R/fBQCBH6fQO5vfPDBB9tFF13U7r777r6xBQsW9IDy7LPP7k1y0pvqQw891FasWNFefPHFdsopp7Rbb721B4Zp+rr//vu3W265pfe2Wkdz7rnn9gDz8ssv71nNrH/cccfVYkMCBAgQIDAWAtV8tffCmolEkjVzLGqoEgQIECBAYI5AOrx57733erZw48aNvYlq/je1Su5ffOutt9rmzZtbgsuU82d6Yc0rPbQuWbKkVp0dLlu2rGcgN2zY0BYtWtTPpbMLjRAgQIAAgTERSNIxMWNK7361spCVlqwmrWNSX9UgQIAAAQKzAnmm4/ZK/jO1gsfhdbYVPA4vT4ZTIUCAAAEC4yyQALI3Yd3w9be96WqCyC/Xf92bs45zxdWNwM4mkAtahQCB0RNYuXJlW7hwoazj6H00jogAAQIE/mCBXI9u+sfW9tU3m9rgLwft3yPJfv/jP6d7JzouWP9gcZsjQIAAgbETWL58+djVSYUIECBAgMC2BJJs3Hfpv7eDZmLHqUykZDh8L8i23mgeAQIECBAgQIAAAQIECEyWQBKMiRfThHXmdsep3vymhrKPk/VlUFsCBAgQIECAAAECBAj8K4HqJ6d3opPnXeWViDKRpSDyX/FZTmDHCfg97jhreyJAgAABAgQIEPipQLVaHQwG3zdhlX38KZI5BAgQIECAAAECBAgQINB6gjFBZPrNmarsRqLJiiwhESBAgAABAgQIECBAgACBYYHEjlNptpqRasJaAeXwisYJECBAgAABAgQIECBAYLIF0unqIFnHvNKMtW6MnGwWtSdAgAABAgQIECBAgACBEhhOOk4likzgmJl5KQQIECBAgAABAgQIECBAoAQq0ZjhbC+suQdSIUBg9AQ0Kx+9z8QRESBAgAABAgQmTSDXpEk49nsgqwOdiiwnDUN9CRAgQIAAAQIECBAgQGD7AhUrzgyn+lrVfFVPrNtHs4QAAQIECBAgQIAAAQKTJpAYsWcf029OdaKToaZyk/ZVUF8CBAgQIECAAAECBAj8vEDixIobB+lEZ8uWLS3NWJONFET+PJ6lBHa0gN/kjha3PwIECBAgQIAAgW0JJF7sPefkAjUpyTwLUiFAYLQE8r89CgECBAgQIECAAIH5FugBZILGZB8zlOmY74/E/gn8VMDv8qcm5hAgQIAAAQIECOx4gR/ug5zqwWMmXKju+A/BHgkQIECAAAECBAgQIDDqAtX56qBGtm7d2u+BHPUDd3wECBAgQIAAAQIECBAgsOMEhpONvRfWzEhnOlXcc1UShgQIECBAgAABAgQIEJhsgSQd66kds53oJIBME9Z169a1ffbZZ7KF1J7ACAloWj5CH4ZDIUCAAAECBAhMmEACx/Xr1/eEY8anUv+MJAu52267tU2bNrkXcsK+FKpLgAABAgQIECBAgACBbQkkmZEAcpdddulBZA8g0wtrSoafffbZtt5nHgECBAgQIECAAAECBAhMoEACyCQbk3ScquZxGS5YsKB9+eWXE0iiygQIECBAgAABAgQIECAwLJCWqimJEWczkAkcp6ene7PVRJWZXrt27fD7jBMgQIAAAQIECBAgQIDAhAkkNkwL1WQek2zMdG/CmmgyE3ktWrSovfvuuxNGo7oECBAgQIAAAQIECBAgMCyQDOQbb7zR9t5779lHPg7S+2qeAZngMWX33XfvHem8/PLLbcWKFbOB5fCGjBMgsOME6re54/ZoTwQIECBAgAABApMs0O91nHl0xyuvvNJ23XXX/sqjPHJdOsjClMyoFZOF/Pzzz9trr73Wg8hEni5iJ/krpO7zKeC3N5/69k2AAAECBAgQmDyBXH8mePz222979jFBZGLFJB8HWVgPhkxT1i1btvQbJJcuXdq++OKL9uSTT7ajjz667bfffv1xHxVMuqidvC+SGs+PwKpVq+Znx/ZKgAABAgQIECAw9gIV31VF161b115//fXeMnXJkiU9aEzwmCd2ZPhva9as+WeCwQSOeXNKhmnW+t1337XNmze3DRs29CCzt32diTqX7rNPW7Zs2ey69b4KRDOd8eGSeXPnV8Yz6/WDmTmOCkwznTJ3O33m0D+13Vq3pue+b1vz7X+mG94fPif+Mz8G3z+/v5nvQIq/P/7+1jmlfyG280+dV2rdmq6/q/W2bc13/nH+qe+J86/zr+sP1//zHf/kER15JXDMMGXx4sU9gEzQmOPL36xkHzM+yEQCxQxzkktJr6xZuVZMynLTpk3t0cefaKtXr24HH/yXtuKEE2YvsvKeF2fumfz447+1w/7613bUUf/RN169u2ZH9Qcy+6pS+85+a3mW1fgn//t/7aADD+jHVcdUJ+JsM+MZ5pXtplLD26p6Vd0yHD6mTGdfw9usY6331H6yrZgMr5tj/bX7z3bqPfbP3/fP72/4b4q/P9+fK/z9/f587Pzz/Xne+df1h+sv15/D58pRvv7O+Wtb8cfPXf/nPXPP/3UerL9/qXMMMj9l+D2Jf1KyvLaTeTU/w2wnw7wvw6xbJdP1eI70srrXXnv1wLH2lW3mlVL7GAy/OePJOOaHOhxoZcMLFy5si2fujVx+7LHt9NNO7QcyvPP/POec9l///T9twcyjQA488MDZ92ebyWZm3eHt1vazPBfR2UdK1s145v397/9oaUqbkgOv/dVFd82vZZmfyuZVH16WZV8pwcl4Lc+yem/2mfHsP8eZbdWy2k+hzd1/tpdl9s/f98/vr/6+ZJi/If7++Pvr/OP86/rD9ZfrT9ffdX2Qa4O8UubGHxVrVMyT9wzPq/G8v2KnxB8Zz2s4UMx41ksiMOMV32SbdY2SeXVcWS/br2Oq9XKcGc+yvLK//wcCwT6ACxDahgAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image\n",
+    "Image('GUI_demo.png')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9638f07",
+   "metadata": {},
+   "source": [
+    "To obtain the current price + logo from your favorite cryptocurrency:\n",
+    "\n",
+    "Write your favorite crypto symbol in the line that says \"Type your cryptocoin here\"\n",
+    "Click the button \"Get your live crypto price\"\n",
+    "\n",
+    "The result will be shown on the right of the button"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9c917fcf",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<video src=\"Crypto_Price_demo.mov\" controls  >\n",
+       "      Your browser does not support the <code>video</code> element.\n",
+       "    </video>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Video object>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Video\n",
+    "Video('Crypto_Price_demo.mov')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f25b087",
+   "metadata": {},
+   "source": [
+    "If you want to retrieve values in a continuous fashion and get the RSI from the last 14 prices, click the button \"Sell, buy or relax\" and, after 20 seconds have elapsed, the current RSI value will be displayed, alongisde a recommendation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "37155258",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<video src=\"Crypto_RSI_demo.mov\" controls  >\n",
+       "      Your browser does not support the <code>video</code> element.\n",
+       "    </video>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Video object>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Video\n",
+    "Video('Crypto_RSI_demo.mov')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "965ccdfb",
+   "metadata": {},
+   "source": [
+    "Finally, to obtain historical data from any of the available crypto coins, you just have to specify the start/end date (year/month/day) and the desired interval.\n",
+    "\n",
+    "After, just exit the window and press the Stop Button to exit the program."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "ef9b8831",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<video src=\"Historical_demo.mov\" controls  >\n",
+       "      Your browser does not support the <code>video</code> element.\n",
+       "    </video>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Video object>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Video\n",
+    "Video('Historical_demo.mov')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cd1e36f8",
+   "metadata": {},
+   "source": [
+    "**That's all bugs, see you next time**"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/__pycache__/__init__.cpython-39.pyc b/__pycache__/__init__.cpython-39.pyc
deleted file mode 100644
index e015ba7..0000000
Binary files a/__pycache__/__init__.cpython-39.pyc and /dev/null differ
diff --git a/__pycache__/bot.cpython-39.pyc b/__pycache__/bot.cpython-39.pyc
deleted file mode 100644
index 541dbe1..0000000
Binary files a/__pycache__/bot.cpython-39.pyc and /dev/null differ
diff --git a/__pycache__/config.cpython-39.pyc b/__pycache__/config.cpython-39.pyc
deleted file mode 100644
index 59d27d6..0000000
Binary files a/__pycache__/config.cpython-39.pyc and /dev/null differ
diff --git a/__pycache__/crypto_selection.cpython-39.pyc b/__pycache__/crypto_selection.cpython-39.pyc
deleted file mode 100644
index 221f155..0000000
Binary files a/__pycache__/crypto_selection.cpython-39.pyc and /dev/null differ
diff --git a/background_image.png b/background_image.png
deleted file mode 100644
index a3b6620..0000000
Binary files a/background_image.png and /dev/null differ
diff --git a/bot.py b/bot.py
deleted file mode 100644
index 6955bad..0000000
--- a/bot.py
+++ /dev/null
@@ -1,95 +0,0 @@
-from tkinter import Label
-import websocket
-import json
-import pprint
-import talib
-import numpy as np
-from binance.client import Client
-from binance.enums import *
-
-#Select your favorite coin
-cc = 'btcusd'
-
-#Select how often do you want to get updates
-interval = '1m'
-
-#Specify the websocket to stream data
-SOCKET = f"wss://stream.binance.com:9443/ws/{cc}t@kline_{interval}"
-
-#Bot values (adjust as preferred)
-RSI_PERIOD = 2
-RSI_OVERBOUGHT = 10
-RSI_OVERSOLD = 90
-TRADE_SYMBOL = 'BTCUSD'
-TRADE_QUANTITY = 0.05
-
-def run():
-    #empty list of closing values
-    closes = []
-
-    #In the beginning, God didn't give you any cryptos --> you have none
-    in_position = False
-    def format_reponse(json_message):
-        candle = json_message['k']
-
-        is_candle_closed = candle['x']
-        close = candle['c']
-        
-        final_str = str(close)
-
-    #Function
-    def on_open(ws):
-        print('opened connection')
-
-    def on_close(ws):
-        print('closed connection')
-
-    def on_message(ws, message): 
-        global closes
-
-        print("received message")   
-        json_message = json.loads(message)
-        # pprint.pprint(json_message)
-
-        candle = json_message['k']
-
-        is_candle_closed = candle['x']
-        close = candle['c']
-
-        #Get the crypto value when the candle closes
-        if is_candle_closed:
-            print('candle( closed at {}'.format(close))
-            closes.append(float(close))
-            print("closes")
-
-        #     print(closes)
-
-        #     #Buy or sell, depending on the RSI value
-        #     if len(closes) > RSI_PERIOD:
-        #         np_closes = np.array(closes)
-        #         rsi = talib.RSI(np_closes, RSI_PERIOD)
-        #         print("calculated rsis")
-        #         print(rsi)
-        #         last_rsi = rsi[-1]
-        #         print("the current RSI is {}".format(last_rsi))
-
-        #         if last_rsi > RSI_OVERBOUGHT:
-        #             print("BEARISH: SELL YOUR CRYPTOS NOW")
-        #             # if in_position:
-        #             #     print("Bearish: But, you can't sell what you don't have")
-        #             #     # Binance selling order
-
-        #         if last_rsi < RSI_OVERSOLD:
-        #             print("BULLISH: BUUUUY, TO THE MOON")
-        #             # if in_position:
-        #             #     print("Bullish: You have some already, move on")
-        #             #     # Binance buying order
-
-
-
-    
-    #Assing functions to the websocket 
-    ws = websocket.WebSocketApp(SOCKET, on_open=on_open, on_message = on_message, on_close = on_close)
-
-    #Get information for my coin
-    ws.run_forever()
diff --git a/bot_API.py b/bot_API.py
index 467cc6a..b8e4060 100644
--- a/bot_API.py
+++ b/bot_API.py
@@ -1,4 +1,3 @@
-#### This script runs perfectly - for updates, see Final_GUI.py
 #LAST
 
 from tkinter.constants import END
@@ -33,6 +32,24 @@
 
 coin = 'litecoin'
 def bot_api(coin):
+    """
+    A function that retrieves the latest price of the selected cryptocurrency from the API 
+    of coinmarketcap.
+
+    If an unexistent symbol is computed, no value is retrieved
+
+    Properties
+    -----------
+    coin : str
+        the symbol of a cryptocurrency
+
+    Returns
+    --------
+    str
+        A string with the latest value of the specified cryptocurrency
+
+    """
+
     global data
 
     parameters = {
@@ -84,6 +101,7 @@ def add_image(coin):
         coin_image.image_create(END, image = my_image)
 
 async def main(symbol, prices):
+
     global xdata
     global results
 
@@ -105,6 +123,32 @@ async def main(symbol, prices):
         return(results)
 
 def run_bot2(symbol, prices):
+    """
+    This function can obtain real-live prices of cryptos every second.
+
+    This function contains the asynchronous function main(), which uses the
+    Binance websocket in order to retrieve the latest cryptocurrency from
+    its platform each second. With this, a loop is set to run 15 times (enough 
+    values to calculate the RSI of 14 timepoints). The results from the 15 
+    values are stored within the 'results' object.
+    It is important to note that, while the values are being calculated, it 
+    is not possible to use anything else from the GUI.
+
+    If an unexistent symbol is specified, no value is retrieved.
+
+    Properties
+    -----------
+    symbol : str
+        the symbol of a cryptocurrency
+    prices : int 
+        The ammount of prices you want to retrieve
+
+    Returns
+    -------
+    list
+        A list with the ammount of cryptocurrency values specified
+    """
+
     if __name__ == '__main__':
         loop = asyncio.get_event_loop()
         loop.run_until_complete(main(symbol, prices))
@@ -112,6 +156,39 @@ def run_bot2(symbol, prices):
 
 
 def historical(symbol, interval, startYear, startMonth, startDay, endYear, endMonth, endDay):
+    """
+    This function can retrieve historical data of any crypto in a graph
+
+    It connect with the API from Binance and it appends the closing candlestick
+    values of the crypto, with a specified interval.
+
+    Properties
+    ----------
+    symbol : str
+        A cryptocurrency symbol
+    interval : str
+        Interval of closing candlesticks
+    startYear : str
+        The year of the starting date
+    startMonth : str
+        The month of the starting date
+    startDay : str
+        The day of the starting date
+    endYear : str
+        The year for the ending date
+    endMonth : str
+        The month for the ending date
+    endDay : str
+        The day for the ending date
+
+    Returns
+    --------
+    dataframe
+        A dataframe with all the values that appear in the graph
+    plot
+        A graph with the crpto values (x_axis = date, y_axis = price)
+    """
+
     global df
 
     url = 'https://api.binance.com/api/v3/klines'
@@ -137,6 +214,32 @@ def historical(symbol, interval, startYear, startMonth, startDay, endYear, endMo
     return df
 
 def rsi(symbol, prices):
+    """
+    This function calculate the Relative Strength Index (RSI) from live crypto
+    prices
+
+    It uses the run_bot2 function to communicate with the websocket from 
+    Binance, and after 15 values have been obtained, it calculates the RSI,
+    and it displays a message with a suggestion to buy/sell/retain:
+    - If RSI > 70 = Market is bearish/overbought, you should sell now
+    - If 30 < RSI > 70 = Market is stable, you should not do anything
+    - If RSI < 30 = Market is bullish/oversold, you should buy now  
+
+    Properties
+    ----------
+    symbol : str
+        a crypto symbol
+    prices : int
+        (optional) it is set to 15 as default
+
+    Returns
+    -------
+    float
+        The RSI value
+    str
+        The buying/selling/retaining decision
+    """
+
     df = run_bot2(symbol, prices)
     print(df)
     df = np.array(df, dtype='f8')
@@ -160,6 +263,7 @@ def rsi(symbol, prices):
 
     if last_rsi > RSI_OVERSOLD and last_rsi < RSI_OVERBOUGHT:
         decision = "RELAX AND DO NOTHING"
+    
     print(decision)
 
     last_rsi = round(last_rsi, 2)
@@ -173,10 +277,6 @@ def do_rsi(symbol, prices):
     entry_rsi.insert(0, ('RSI value: {}, {}').format(rsi_value, decision))
 
 
-# rsi('btc', 25) #'1d', 2020,4,1,2020,5,1)
-
-
-
 # ------------------ GUI ---------------------- #
 
 root = tk.Tk()
diff --git a/crypto_selection.py b/crypto_selection.py
deleted file mode 100644
index 8eb3716..0000000
--- a/crypto_selection.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-
-#This is where I'll code the functions
-
-class Crypto_bot:
-    """
-    Documentation: A class where you can select your favorite cryptos, track them and use a trading bot    
-    """
-
-    def which_crypto():
-        """
-        This is function 1
-        """
-        print("This function will allow you to choose between BTC, ETH, ADA or DOGE coins")
-        
-    def trade_bot():
-        """
-        This is function 2
-        """    
-        print("This function will suggest you to sell or buy")    
-    
diff --git a/demos/Crypto_Price_Demo.mov b/demos/Crypto_Price_Demo.mov
new file mode 100644
index 0000000..b884442
Binary files /dev/null and b/demos/Crypto_Price_Demo.mov differ
diff --git a/demos/Crypto_RSI_demo.mov b/demos/Crypto_RSI_demo.mov
new file mode 100644
index 0000000..7488d76
Binary files /dev/null and b/demos/Crypto_RSI_demo.mov differ
diff --git a/demos/GUI_demo.png b/demos/GUI_demo.png
new file mode 100644
index 0000000..5baf706
Binary files /dev/null and b/demos/GUI_demo.png differ
diff --git a/demos/Historical_demo.mov b/demos/Historical_demo.mov
new file mode 100644
index 0000000..1e35cc2
Binary files /dev/null and b/demos/Historical_demo.mov differ
diff --git a/demos/RSI_demo.png b/demos/RSI_demo.png
new file mode 100644
index 0000000..7219274
Binary files /dev/null and b/demos/RSI_demo.png differ
diff --git a/demos/run_bot2_demo.mov b/demos/run_bot2_demo.mov
new file mode 100644
index 0000000..4604d33
Binary files /dev/null and b/demos/run_bot2_demo.mov differ
diff --git a/gui.py b/gui.py
deleted file mode 100644
index 0d4af1a..0000000
--- a/gui.py
+++ /dev/null
@@ -1,132 +0,0 @@
-import tkinter as tk
-import requests
-from PIL import Image
-from PIL import ImageTk
-# import bot
-from tkinter import Label
-import websocket
-import json
-import pprint
-import talib
-import numpy as np
-from binance.client import Client
-from binance.enums import *
-
-#Select your favorite coin
-cc = 'btcusd'
-
-#Select how often do you want to get updates
-interval = '1m'
-
-#Specify the websocket to stream data
-SOCKET = f"wss://stream.binance.com:9443/ws/{cc}t@kline_{interval}"
-
-#Bot values (adjust as preferred)
-RSI_PERIOD = 2
-RSI_OVERBOUGHT = 10
-RSI_OVERSOLD = 90
-TRADE_SYMBOL = 'BTCUSD'
-TRADE_QUANTITY = 0.05
-
-def run():
-    #empty list of closing values
-    closes = []
-
-    #In the beginning, God didn't give you any cryptos --> you have none
-    in_position = False
-
-    #Function
-    def on_open(ws):
-        print('opened connection')
-
-    def on_close(ws):
-        print('closed connection')
-
-    def on_message(ws, message): 
-        global closes
-
-        print("received message")   
-        json_message = json.loads(message)
-        # pprint.pprint(json_message)
-
-        candle = json_message['k']
-
-        is_candle_closed = candle['x']
-        close = candle['c']
-
-        #Get the crypto value when the candle closes
-        if is_candle_closed:
-            print('candle( closed at {}'.format(close))
-            closes.append(float(close))
-            print("closes")
-
-        #     print(closes)
-
-        #     #Buy or sell, depending on the RSI value
-        #     if len(closes) > RSI_PERIOD:
-        #         np_closes = np.array(closes)
-        #         rsi = talib.RSI(np_closes, RSI_PERIOD)
-        #         print("calculated rsis")
-        #         print(rsi)
-        #         last_rsi = rsi[-1]
-        #         print("the current RSI is {}".format(last_rsi))
-
-        #         if last_rsi > RSI_OVERBOUGHT:
-        #             print("BEARISH: SELL YOUR CRYPTOS NOW")
-        #             # if in_position:
-        #             #     print("Bearish: But, you can't sell what you don't have")
-        #             #     # Binance selling order
-
-        #         if last_rsi < RSI_OVERSOLD:
-        #             print("BULLISH: BUUUUY, TO THE MOON")
-        #             # if in_position:
-        #             #     print("Bullish: You have some already, move on")
-        #             #     # Binance buying order
-
-
-
-    
-    #Assing functions to the websocket 
-    ws = websocket.WebSocketApp(SOCKET, on_open=on_open, on_message = on_message, on_close = on_close)
-
-    #Get information for my coin
-    ws.run_forever()
-
-
-
-
-
-
-
-
-
-
-
-root = tk.Tk()
-
-canvas = tk.Canvas(root, height = 500, width = 700)
-canvas.pack()
-
-background_image = Image.open('background_image.png')
-background_image = ImageTk.PhotoImage(background_image)
-background_label = tk.Label(root, image=background_image)
-background_label.place(relwidth = 1, relheight = 1)
-
-frame = tk.Frame(root, bg='#80c1ff', bd = 5)
-frame.place(relx = 0.5, rely = 0.1, relwidth=0.75, relheight=0.1, anchor = 'n')
-
-entry = tk.Entry(frame, bg='green', font = 20)
-entry.place(relwidth=0.85, relheight=1)
-
-button = tk.Button(frame, text = "Crypto History", background = '#3968b3', font = 30, 
-command = lambda:run())
-
-button.place(relx = 0.7, relwidth=0.3, relheight=1)
-
-frame2 = tk.Frame(root, bg='#80c1ff', bd = 5)
-frame2.place(relx = 0.5, rely = 0.25, relwidth = 0.75, relheight=0.6, anchor = 'n')
-
-label = tk.Label(frame2, bg= "darkgray", font = 50)
-label.place(relx = 0.5, relwidth=1, relheight=1, anchor = 'n')
-
-root.mainloop() 
diff --git a/logos/.DS_Store b/logos/.DS_Store
new file mode 100644
index 0000000..5008ddf
Binary files /dev/null and b/logos/.DS_Store differ
diff --git a/logos/ada.png b/logos/ada.png
new file mode 100644
index 0000000..917b1a2
Binary files /dev/null and b/logos/ada.png differ
diff --git a/logos/bnb.png b/logos/bnb.png
new file mode 100644
index 0000000..ad578f5
Binary files /dev/null and b/logos/bnb.png differ
diff --git a/logos/btc.png b/logos/btc.png
new file mode 100644
index 0000000..62f8fce
Binary files /dev/null and b/logos/btc.png differ
diff --git a/logos/doge.png b/logos/doge.png
new file mode 100644
index 0000000..5add5ac
Binary files /dev/null and b/logos/doge.png differ
diff --git a/logos/eth.png b/logos/eth.png
new file mode 100644
index 0000000..fc04613
Binary files /dev/null and b/logos/eth.png differ
diff --git a/logos/ltc.png b/logos/ltc.png
new file mode 100644
index 0000000..ee22932
Binary files /dev/null and b/logos/ltc.png differ
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 40fd168..0000000
--- a/requirements.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-python-binance
-TA-Lib
-numpy
-websocket
diff --git a/setup.py b/setup.py
index a7d3e84..aac7685 100644
--- a/setup.py
+++ b/setup.py
@@ -6,14 +6,19 @@
     version = 0.1, 
     author = "Alexis",
     author_email = "alexis_daniels@hotmail.com",
-    description = "A package where you can keep track of your favorite cryptocurrencies and obtain buy/sell suggestion based on RSI",
+    description = "A package where you can keep track of your favorite cryptocurrencies and obtain buy/sell suggestion based on the RSI",
     license = 'MIT',
-    packages = [
-        'setuptools.find_packages()'
-    ]
-    install_requires=[
+    packages = setuptools.find_packages(),
+    install_requires = [
         'numpy',
         'pandas',
-        'talib'
+        'matplotlib',
+        'asyncio',
+        'websocket',
+        'websockets',
+        'asyncio',
+        'TA-Lib',
+        'tkinter'
     ],
-    )
+)
+
diff --git a/RSI_OVERBOUGHT: b/test/__init__.py
similarity index 100%
rename from RSI_OVERBOUGHT:
rename to test/__init__.py
diff --git a/test/__pycache__/__init__.cpython-39.pyc b/test/__pycache__/__init__.cpython-39.pyc
new file mode 100644
index 0000000..4d2b481
Binary files /dev/null and b/test/__pycache__/__init__.cpython-39.pyc differ
diff --git a/test/__pycache__/functions.cpython-39.pyc b/test/__pycache__/functions.cpython-39.pyc
new file mode 100644
index 0000000..f4d8b62
Binary files /dev/null and b/test/__pycache__/functions.cpython-39.pyc differ
diff --git a/test/__pycache__/unittest.cpython-39.pyc b/test/__pycache__/unittest.cpython-39.pyc
new file mode 100644
index 0000000..f97bb14
Binary files /dev/null and b/test/__pycache__/unittest.cpython-39.pyc differ
diff --git a/test/functions.py b/test/functions.py
new file mode 100644
index 0000000..b697cc0
--- /dev/null
+++ b/test/functions.py
@@ -0,0 +1,242 @@
+from tkinter.constants import END
+from requests import Session
+import json
+import time
+import tkinter as tk
+import talib
+import numpy as np
+from numpy import DataSource
+import pandas as pd
+import datetime as dt
+import matplotlib.pyplot as plt
+import requests
+import websockets
+import asyncio
+
+RSI_PERIOD = 14
+RSI_OVERBOUGHT = 70
+RSI_OVERSOLD = 30
+# TRADE_SYMBOL = 'BTCUSD'
+# TRADE_QUANTITY = 0.05
+
+results = []
+xdata = []
+ydata = []
+
+url = 'https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest'
+
+coin = 'litecoin'
+def bot_api(coin):
+    """
+    A function that retrieves the latest price of the selected cryptocurrency from the API 
+    of coinmarketcap.
+
+    If an unexistent symbol is computed, no value is retrieved
+
+    Properties
+    -----------
+    coin : str
+        the symbol of a cryptocurrency
+
+    Returns
+    --------
+    str
+        A string with the latest value of the specified cryptocurrency
+
+    """
+
+    global data
+
+    parameters = {
+        'symbol': coin,
+        'convert': "usd"
+    }
+
+    headers = {
+        'Accepts': 'application/json',
+        'X-CMC_PRO_API_KEY': '31233140-af13-4dd0-ad7e-1bdb98b80470'
+    }
+
+    session = Session()
+    session.headers.update(headers)
+
+    response = session.get(url, params = parameters)
+
+    result = json.loads(response.text)['data']
+    result = list(result)
+    number = result[0]
+
+    result = json.loads(response.text)['data'][str(number)]['quote']['USD']['price']
+
+    return(result)
+
+
+async def main(symbol, prices):
+
+    global xdata
+    global results
+
+    url = "wss://stream.binance.com:9443/stream?streams=" + symbol + "usdt@miniTicker"
+    async with websockets.connect(url) as client:
+        global xdata
+        for x in range(prices):
+        # while len(xdata) < prices:
+            data = json.loads(await client.recv())['data']
+
+            event_time = time.localtime(data['E'] // 1000)
+            event_time = f"{event_time.tm_hour}:{event_time.tm_min}:{event_time.tm_sec}"
+
+            print(event_time, data['c'])
+            a = data['c']
+            results.append(a)
+
+            print(x)
+        return(results)
+
+def run_bot2(symbol, prices):
+    """
+    This function can obtain real-live prices of cryptos every second.
+
+    This function contains the asynchronous function main(), which uses the
+    Binance websocket in order to retrieve the latest cryptocurrency from
+    its platform each second. With this, a loop is set to run 15 times (enough 
+    values to calculate the RSI of 14 timepoints). The results from the 15 
+    values are stored within the 'results' object.
+    It is important to note that, while the values are being calculated, it 
+    is not possible to use anything else from the GUI.
+
+    If an unexistent symbol is specified, no value is retrieved.
+
+    Properties
+    -----------
+    symbol : str
+        the symbol of a cryptocurrency
+    prices : int 
+        The ammount of prices you want to retrieve
+
+    Returns
+    -------
+    list
+        A list with the ammount of cryptocurrency values specified
+    """
+
+    if __name__ == '__main__':
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(main(symbol, prices))
+        return(results)
+
+
+def historical(symbol, interval, startYear, startMonth, startDay, endYear, endMonth, endDay):
+    """
+    This function can retrieve historical data of any crypto in a graph
+
+    It connect with the API from Binance and it appends the closing candlestick
+    values of the crypto, with a specified interval.
+
+    Properties
+    ----------
+    symbol : str
+        A cryptocurrency symbol
+    interval : str
+        Interval of closing candlesticks
+    startYear : str
+        The year of the starting date
+    startMonth : str
+        The month of the starting date
+    startDay : str
+        The day of the starting date
+    endYear : str
+        The year for the ending date
+    endMonth : str
+        The month for the ending date
+    endDay : str
+        The day for the ending date
+
+    Returns
+    --------
+    dataframe
+        A dataframe with all the values that appear in the graph
+    plot
+        A graph with the crpto values (x_axis = date, y_axis = price)
+    """
+
+    global df
+
+    url = 'https://api.binance.com/api/v3/klines'
+
+    symbol = symbol.upper()
+    startTime = str(int(dt.datetime(startYear,startMonth,startDay).timestamp() * 1000))
+    endTime = str(int(dt.datetime(endYear,endMonth,endDay).timestamp() * 1000))
+    limit = '1000'
+
+    req_params = {'symbol': symbol + 'USDT', 'interval': interval, 'startTime': startTime, 
+    'endTime': endTime, 'limit': limit}
+
+    df = pd.DataFrame(json.loads(requests.get(url, params = req_params).text))
+
+    df = df.iloc[:, 0:6]
+
+    df.columns =  ['datetime', 'open', 'high', 'low', 'close', 'volume']
+
+    df.index = [dt.datetime.fromtimestamp(x / 1000.0) for x in df.datetime]
+    df['close'] = df['close'].astype(float)
+    df['close'].plot()
+    # plt.show()
+    return df
+
+def rsi(symbol, prices):
+    """
+    This function calculate the Relative Strength Index (RSI) from live crypto
+    prices
+
+    It uses the run_bot2 function to communicate with the websocket from 
+    Binance, and after 15 values have been obtained, it calculates the RSI,
+    and it displays a message with a suggestion to buy/sell/retain:
+    - If RSI > 70 = Market is bearish/overbought, you should sell now
+    - If 30 < RSI > 70 = Market is stable, you should not do anything
+    - If RSI < 30 = Market is bullish/oversold, you should buy now  
+
+    Properties
+    ----------
+    symbol : str
+        a crypto symbol
+    prices : int
+        (optional) it is set to 15 as default
+
+    Returns
+    -------
+    float
+        The RSI value
+    str
+        The buying/selling/retaining decision
+    """
+
+    df = run_bot2(symbol, prices)
+    print(df)
+    df = np.array(df, dtype='f8')
+
+    #Buy or sell, depending on the RSI value
+    rsi = talib.RSI(df, RSI_PERIOD)
+    # print(rsi)
+    last_rsi = rsi[-1]
+    print(last_rsi)
+    if last_rsi > RSI_OVERBOUGHT:
+        decision = "BEARISH: SELL YOUR CRYPTO NOW"
+        # if in_position:
+        #     print("Bearish: But, you can't sell what you don't have")
+        #     # Binance selling order
+
+    if last_rsi < RSI_OVERSOLD:
+        decision = "BULLISH: BUUUUY, TO THE MOON"
+        # if in_position:
+        #     print("Bullish: You have some already, move on")
+        #     # Binance buying order
+
+    if last_rsi > RSI_OVERSOLD and last_rsi < RSI_OVERBOUGHT:
+        decision = "RELAX AND DO NOTHING"
+    
+    print(decision)
+
+    last_rsi = round(last_rsi, 2)
+    return(last_rsi, decision)
+
diff --git a/test/unittest.py b/test/unittest.py
new file mode 100644
index 0000000..a684a3a
--- /dev/null
+++ b/test/unittest.py
@@ -0,0 +1,27 @@
+from functions import historical
+import unittest
+
+class TestStringMethods(unittest.TestCase):
+
+    def test_upper(self):
+        self.assertEqual('foo'.upper(), 'FOO')
+
+    def test_isupper(self):
+        self.assertTrue('FOO'.isupper())
+        self.assertFalse('Foo'.isupper())
+
+    def test_split(self):
+        s = 'hello world'
+        self.assertEqual(s.split(), ['hello', 'world'])
+        # check that s.split fails when the separator is not a string
+        with self.assertRaises(TypeError):
+            s.split(2)
+
+if __name__ == '__main__':
+    unittest.main()
+
+
+
+
+
+#I didn't understand unit testing - this code is a copy from https://docs.python.org/3/library/unittest.html
\ No newline at end of file