diff --git a/extra/Getting_Started/ElasticsearchConnection.ipynb b/extra/Getting_Started/ElasticsearchConnection.ipynb
new file mode 100755
index 0000000..c860001
--- /dev/null
+++ b/extra/Getting_Started/ElasticsearchConnection.ipynb
@@ -0,0 +1,1243 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Elasticsearch Data Analytics\n",
+ "\n",
+ "This notebook provides sample code to fetch Elasticsearch Data into and analyze it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import Image\n",
+ "from IPython.core.display import HTML \n",
+ "Image(url= \"https://www.antaresnet.com/wp-content/uploads/2018/07/Elasticsearch-Logo-Color-V.png\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Loading modules and connect to the Elastic Stack"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "pycharm": {
+ "is_executing": false
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import sys\n",
+ "import json\n",
+ "import requests\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import seaborn as sns\n",
+ "import pytz\n",
+ "from datetime import datetime, timedelta\n",
+ "from dateutil import tz\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "sns.set(style=\"darkgrid\")\n",
+ "plt.rcParams[\"figure.figsize\"] = (18,10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "pycharm": {
+ "is_executing": false
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Last run: 2019-12-20 08:12:58.766840 UTC, status: 7.0604683677036 %\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{'name': 'c185f3ed577c',\n",
+ " 'cluster_name': 'il.es.cluster',\n",
+ " 'cluster_uuid': 'sBgbgyRXTvKta2cEJCczKQ',\n",
+ " 'version': {'number': '6.2.2',\n",
+ " 'build_hash': '10b1edd',\n",
+ " 'build_date': '2018-02-16T19:01:30.685723Z',\n",
+ " 'build_snapshot': False,\n",
+ " 'lucene_version': '7.2.1',\n",
+ " 'minimum_wire_compatibility_version': '5.6.0',\n",
+ " 'minimum_index_compatibility_version': '5.0.0'},\n",
+ " 'tagline': 'You Know, for Search'}"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# connect to our cluster\n",
+ "from elasticsearch import Elasticsearch\n",
+ "es = Elasticsearch([{'host': 'elasticsearch', 'port': 9200}])\n",
+ "print('Last run: {} UTC, status: {} %'.format(\n",
+ " datetime.utcnow(),\n",
+ " es.cluster.health()['active_shards_percent_as_number']))\n",
+ "es.info()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Display our indices and document types saved in elasticsearch.\n",
+ "\n",
+ "Update the elasticsearch package."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: elasticsearch<8.0.0,>=7.0.0 in /opt/conda/lib/python3.7/site-packages (7.1.0)\n",
+ "Requirement already satisfied: urllib3>=1.21.1 in /opt/conda/lib/python3.7/site-packages (from elasticsearch<8.0.0,>=7.0.0) (1.25.7)\n"
+ ]
+ }
+ ],
+ "source": [
+ "!sudo pip install \"elasticsearch>=7.0.0,<8.0.0\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Defining useful functions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# %load scroller.py\n",
+ "def scroller(index, quantity, timerange=timedelta(days=0), startdt=\"\", enddt=\"\"):\n",
+ " print(\"Starting to scroll\", end='')\n",
+ " # Retrieve the datetimes, note that timerange has a higher priority\n",
+ " if timerange.total_seconds() > 0:\n",
+ " now = datetime.utcnow().replace(tzinfo=pytz.UTC)\n",
+ " startdt = (now - timerange).isoformat()\n",
+ " enddt = now.isoformat()\n",
+ " \n",
+ " # search the first page and write the result to data\n",
+ " response = es.search(\n",
+ " index=index,\n",
+ " body={\n",
+ " \"query\": {\n",
+ " \"bool\": {\n",
+ " \"must\": [\n",
+ " {\"range\" : {\n",
+ " \"phenomenonTime\" : {\n",
+ " #\"gte\": \"2018-02-20T09:08:34.230693+00:00\", \n",
+ " \"gte\": startdt,\n",
+ " \"lte\": enddt, \n",
+ " \"time_zone\": \"+01:00\"\n",
+ " }\n",
+ " }},\n",
+ " {\n",
+ " \"match_phrase\": {\n",
+ " \"Datastream.name.keyword\": quantity\n",
+ " }\n",
+ " }\n",
+ " ]\n",
+ " }\n",
+ " }\n",
+ " },\n",
+ " scroll='10m'\n",
+ " )\n",
+ " data = [[row[\"_source\"][\"phenomenonTime\"], row[\"_source\"][\"result\"]] for row in response['hits']['hits']]\n",
+ "\n",
+ " # Append new pages until there aren't any left\n",
+ " while len(response['hits']['hits']):\n",
+ " print(\".\", end='')\n",
+ " # process results\n",
+ " # print([item[\"_id\"] for item in response[\"hits\"][\"hits\"]])\n",
+ " response = es.scroll(scroll_id=response['_scroll_id'], scroll='10m')\n",
+ " data += [[row[\"_source\"][\"phenomenonTime\"], row[\"_source\"][\"result\"]] for row in response['hits']['hits']]\n",
+ " \n",
+ " # Convert data to a DataFrame and return it\n",
+ " df = pd.DataFrame(data, columns=[\"phenomenonTime\", quantity])\n",
+ " # df.index = pd.to_datetime(df[\"phenomenonTime\"].map(lambda t: t.split(\".\")[0]), utc=True)\n",
+ " df.index = pd.to_datetime(df[\"phenomenonTime\"].map(lambda t: roundto(t, 1)), utc=True)\n",
+ " df = df.drop([\"phenomenonTime\"], axis=1)\n",
+ " print(\"\\nFetched {} tuples.\".format(df.shape[0]))\n",
+ " return df\n",
+ "\n",
+ "def roundto(string, n):\n",
+ " base = string.split(\".\")[0]\n",
+ " if n > 0:\n",
+ " base += \".\" + string.split(\".\")[1][:n]\n",
+ " return base\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Gather data from Elasticsearch\n",
+ "\n",
+ "It is supposed that in the Elasticsearch instance, there is data with the Datastream.name \"at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature\" within the index name \"at.srfg.iot-iot4cps-wp5.infraprov.internal-*\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Starting to scroll\n",
+ "Fetched 0 tuples.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature | \n",
+ "
\n",
+ " \n",
+ " phenomenonTime | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ "Empty DataFrame\n",
+ "Columns: [at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature]\n",
+ "Index: []"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Get data for an index and a quantity between two static timestamps\n",
+ "startdt=\"2019-08-07T08:58:34+00:00\"\n",
+ "enddt=\"2019-08-07T11:58:34+00:00\"\n",
+ "df = scroller(\"at.srfg.iot-iot4cps-wp5.infraprov.internal-*\",\n",
+ " \"at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature\",\n",
+ " startdt=startdt, enddt=enddt)\n",
+ "df.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Starting to scroll\n",
+ "Fetched 0 tuples.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature | \n",
+ "
\n",
+ " \n",
+ " phenomenonTime | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ "Empty DataFrame\n",
+ "Columns: [at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature]\n",
+ "Index: []"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Get data for an index and a quantity of the latest timerange\n",
+ "df = scroller(\"at.srfg.iot-iot4cps-wp5.infraprov.internal-*\",\n",
+ " \"at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature\",\n",
+ " timerange=timedelta(days=10))\n",
+ "df.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Plot the extracted data using pandas and seaborn\n",
+ "df.plot()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Get multiple quantities and (outer) join them to a single DataFrame.\n",
+ "# There can be a lot of missing values\n",
+ "used_quantities = [\"at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature\", \n",
+ " \"at.srfg.iot-iot4cps-wp5.CarFleet2.car_2.Air Temperature\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Starting to scroll.....\n",
+ "Fetched 48 tuples.\n",
+ "at.srfg.iot-iot4cps-wp5.CarFleet2.car_2.Air Temperature\n",
+ "Starting to scroll\n",
+ "Fetched 0 tuples.\n"
+ ]
+ }
+ ],
+ "source": [
+ "df = scroller(\"at.srfg.iot-iot4cps-wp5.infraprov.internal-*\",\n",
+ " used_quantities[0],\n",
+ " timerange=timedelta(days=10))\n",
+ "for q in used_quantities[1:]:\n",
+ " print(q)\n",
+ " df = df.join(scroller(\"at.srfg.iot-iot4cps-wp5.infraprov.internal-*\", q,\n",
+ " timerange=timedelta(days=10)),\n",
+ " how=\"outer\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature | \n",
+ " at.srfg.iot-iot4cps-wp5.CarFleet2.car_2.Air Temperature | \n",
+ "
\n",
+ " \n",
+ " phenomenonTime | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 2019-08-07 09:32:50.600000+00:00 | \n",
+ " -1.396915 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:33:40.700000+00:00 | \n",
+ " -2.559881 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:34:10.700000+00:00 | \n",
+ " -3.360251 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:32:10.600000+00:00 | \n",
+ " -0.112741 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:32:40.600000+00:00 | \n",
+ " -0.956904 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature \\\n",
+ "phenomenonTime \n",
+ "2019-08-07 09:32:50.600000+00:00 -1.396915 \n",
+ "2019-08-07 09:33:40.700000+00:00 -2.559881 \n",
+ "2019-08-07 09:34:10.700000+00:00 -3.360251 \n",
+ "2019-08-07 09:32:10.600000+00:00 -0.112741 \n",
+ "2019-08-07 09:32:40.600000+00:00 -0.956904 \n",
+ "\n",
+ " at.srfg.iot-iot4cps-wp5.CarFleet2.car_2.Air Temperature \n",
+ "phenomenonTime \n",
+ "2019-08-07 09:32:50.600000+00:00 NaN \n",
+ "2019-08-07 09:33:40.700000+00:00 NaN \n",
+ "2019-08-07 09:34:10.700000+00:00 NaN \n",
+ "2019-08-07 09:32:10.600000+00:00 NaN \n",
+ "2019-08-07 09:32:40.600000+00:00 NaN "
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Store and retrieve the DataFrame in a csv"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "df.to_csv(\"elasticsearchdata.csv\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature | \n",
+ " at.srfg.iot-iot4cps-wp5.CarFleet2.car_2.Air Temperature | \n",
+ "
\n",
+ " \n",
+ " phenomenonTime | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 2019-08-07 09:39:01.100000+00:00 | \n",
+ " -3.039692 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:39:51.100000+00:00 | \n",
+ " -1.599475 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:39:21.100000+00:00 | \n",
+ " -2.488179 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:39:31.100000+00:00 | \n",
+ " -2.259640 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:40:01.200000+00:00 | \n",
+ " -1.246612 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature \\\n",
+ "phenomenonTime \n",
+ "2019-08-07 09:39:01.100000+00:00 -3.039692 \n",
+ "2019-08-07 09:39:51.100000+00:00 -1.599475 \n",
+ "2019-08-07 09:39:21.100000+00:00 -2.488179 \n",
+ "2019-08-07 09:39:31.100000+00:00 -2.259640 \n",
+ "2019-08-07 09:40:01.200000+00:00 -1.246612 \n",
+ "\n",
+ " at.srfg.iot-iot4cps-wp5.CarFleet2.car_2.Air Temperature \n",
+ "phenomenonTime \n",
+ "2019-08-07 09:39:01.100000+00:00 NaN \n",
+ "2019-08-07 09:39:51.100000+00:00 NaN \n",
+ "2019-08-07 09:39:21.100000+00:00 NaN \n",
+ "2019-08-07 09:39:31.100000+00:00 NaN \n",
+ "2019-08-07 09:40:01.200000+00:00 NaN "
+ ]
+ },
+ "execution_count": 56,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df = pd.read_csv(\"elasticsearchdata.csv\", parse_dates=True, index_col='phenomenonTime')\n",
+ "df.tail()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Pre-processing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Reduce size and interpolate"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "df = pd.read_csv(\"elasticsearchdata.csv\", parse_dates=True, index_col='phenomenonTime')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "df.index.names = [\"time\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "col_mapping = {\"at.srfg.iot-iot4cps-wp5.CarFleet1.car_1.Air Temperature\": \"car1_temp\", \n",
+ " \"at.srfg.iot-iot4cps-wp5.CarFleet2.car_2.Air Temperature\": \"car2_temp\"}\n",
+ "df = df.rename(index=str, \n",
+ " columns=col_mapping)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " car1_temp | \n",
+ " car2_temp | \n",
+ "
\n",
+ " \n",
+ " time | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 2019-08-07 09:32:50.600000+00:00 | \n",
+ " -1.396915 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:33:40.700000+00:00 | \n",
+ " -2.559881 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:34:10.700000+00:00 | \n",
+ " -3.360251 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:32:10.600000+00:00 | \n",
+ " -0.112741 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 2019-08-07 09:32:40.600000+00:00 | \n",
+ " -0.956904 | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " car1_temp car2_temp\n",
+ "time \n",
+ "2019-08-07 09:32:50.600000+00:00 -1.396915 NaN\n",
+ "2019-08-07 09:33:40.700000+00:00 -2.559881 NaN\n",
+ "2019-08-07 09:34:10.700000+00:00 -3.360251 NaN\n",
+ "2019-08-07 09:32:10.600000+00:00 -0.112741 NaN\n",
+ "2019-08-07 09:32:40.600000+00:00 -0.956904 NaN"
+ ]
+ },
+ "execution_count": 60,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Interpolate forwards and backwaonly up to \n",
+ "df = df.interpolate(method ='linear', limit_direction ='both', limit=10)\n",
+ "df = df.interpolate(method ='linear', limit_direction ='both', limit=10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Keep only the rows with at least 2 non-NA values.\n",
+ "df = df.dropna(thresh=2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# make Timestamp unique\n",
+ "df = df.reset_index()\n",
+ "df = df.groupby(\"time\").agg({q: \"mean\" for q in col_mapping.values()})"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Interpolate again to close gaps, use the smalles value \n",
+ "df = df.interpolate(method ='zero', limit_direction ='forward')\n",
+ "df = df.interpolate(method ='zero', limit_direction ='forward')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "nan"
+ ]
+ },
+ "execution_count": 65,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df.index.min()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(0, 2)"
+ ]
+ },
+ "execution_count": 66,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df.shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "car1_temp 0\n",
+ "car2_temp 0\n",
+ "dtype: int64"
+ ]
+ },
+ "execution_count": 67,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df.isna().sum()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " car1_temp | \n",
+ " car2_temp | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " count | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ "
\n",
+ " \n",
+ " mean | \n",
+ " NaN | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " std | \n",
+ " NaN | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " min | \n",
+ " NaN | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 25% | \n",
+ " NaN | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 50% | \n",
+ " NaN | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " 75% | \n",
+ " NaN | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ " max | \n",
+ " NaN | \n",
+ " NaN | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " car1_temp car2_temp\n",
+ "count 0.0 0.0\n",
+ "mean NaN NaN\n",
+ "std NaN NaN\n",
+ "min NaN NaN\n",
+ "25% NaN NaN\n",
+ "50% NaN NaN\n",
+ "75% NaN NaN\n",
+ "max NaN NaN"
+ ]
+ },
+ "execution_count": 68,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df.describe()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Keep only rows with all filled rows\n",
+ "df = df.dropna()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "df.to_csv(\"elasticsearchdata.csv\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Basic Data Analysis"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " car1_temp | \n",
+ " car2_temp | \n",
+ "
\n",
+ " \n",
+ " time | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ "Empty DataFrame\n",
+ "Columns: [car1_temp, car2_temp]\n",
+ "Index: []"
+ ]
+ },
+ "execution_count": 71,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df = pd.read_csv(\"elasticsearchdata.csv\", parse_dates=True, index_col='time')\n",
+ "df.tail()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# df.hist()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# pd.plotting.scatter_matrix(df, alpha=0.2)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# corr = df.corr() \n",
+ "cm = sns.light_palette(\"orange\", as_cmap=True) \n",
+ "cm = sns.diverging_palette(220, 20, sep=20, as_cmap=True) \n",
+ "# corr.style.background_gradient(cmap=cm).set_precision(2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Feature Engineering\n",
+ "\n",
+ "This task is very domain-specific and must be done by an expert."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Data Analytics"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "75cfeeea6204489e945d894895b2bc30",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "interactive(children=(IntSlider(value=45, description='pitch', max=90), IntSlider(value=45, description='yaw',…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from IPython.html.widgets import *\n",
+ "from mpl_toolkits.mplot3d import Axes3D\n",
+ "\n",
+ "plt.rcParams[\"figure.figsize\"] = (18,10)\n",
+ "sns.set(style=\"darkgrid\")\n",
+ "\n",
+ "def plot3D(pitch, yaw):\n",
+ " fig = plt.figure()\n",
+ " ax = fig.add_subplot(111, projection='3d')\n",
+ " plot = ax.scatter(df['car1_temp'], df['car1_temp'], df['car2_temp'], c=df[\"car1_temp\"], s=60)\n",
+ " fig.colorbar(plot)\n",
+ " ax.view_init(pitch, yaw)\n",
+ " ax.legend(['Vibration for each 3D position'])\n",
+ " ax.set_xlabel(\"x-Position\")\n",
+ " ax.set_ylabel(\"y-Position\")\n",
+ " ax.set_zlabel(\"z-Position\")\n",
+ "interact(plot3D, pitch=(0,90,1), yaw=(0,90,1))\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# df[col_mapping.values()].hist()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# pd.plotting.scatter_matrix(df[[\"vib\", \"distance\", \"projection\", \"v-radial\", \"v-tang\"]], alpha=0.5)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 80,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# bins = np.linspace(0, df['v-radial'].max(), 10)\n",
+ "# df[\"binned-v-radial\"] = pd.cut(df['v-radial'], bins)\n",
+ "# df.groupby(\"binned-v-radial\").agg({\"vib\": {\"min\", \"median\", \"mean\", \"max\", \"count\"}})"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# corr = df[df.columns.sort_values()].corr()[[\"vib\", \"vib-x\", \"vib-y\"]]\n",
+ "# cm = sns.light_palette(\"orange\", as_cmap=True) \n",
+ "# cm = sns.diverging_palette(220, 20, sep=20, as_cmap=True) \n",
+ "# corr.style.background_gradient(cmap=cm).set_precision(2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/markdown": [
+ "\n",
+ "## Inline Description:\n",
+ "\n",
+ "It is very nice to describe results using Markdown with dynamic values like: **3.141592653589793**.\n",
+ "\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 82,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import Markdown \n",
+ "Markdown(\"\"\"\n",
+ "## Inline Description:\n",
+ "\n",
+ "It is very nice to describe results using Markdown with dynamic values like: **{pi}**.\n",
+ "\n",
+ "\"\"\".format(pi=np.pi))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Machine Learning\n",
+ "\n",
+ "**Be careful when handling with Artificial Intelligence:**\n",
+ "\n",
+ "![Be careful when handling with Artificial Intelligence](https://imgs.xkcd.com/comics/twitter_bot.png)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/extra/Getting_Started/GPU-processing.ipynb b/extra/Getting_Started/GPU-processing.ipynb
new file mode 100644
index 0000000..fae5cde
--- /dev/null
+++ b/extra/Getting_Started/GPU-processing.ipynb
@@ -0,0 +1,417 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# GPU-Jupyter\n",
+ "\n",
+ "This Jupyterlab Instance is connected to the GPU via CUDA drivers. In this notebook, we test the installation and perform some basic operations on the GPU."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Test GPU connection\n",
+ "\n",
+ "#### Using the following command, your GPU type and its NVIDIA-SMI driver version should be listed:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Fri Dec 20 09:42:29 2019 \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 440.26 Driver Version: 440.26 CUDA Version: 10.2 |\n",
+ "|-------------------------------+----------------------+----------------------+\n",
+ "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n",
+ "|===============================+======================+======================|\n",
+ "| 0 GeForce RTX 207... Off | 00000000:01:00.0 Off | N/A |\n",
+ "| 0% 54C P0 38W / 215W | 204MiB / 7974MiB | 0% Default |\n",
+ "+-------------------------------+----------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| Processes: GPU Memory |\n",
+ "| GPU PID Type Process name Usage |\n",
+ "|=============================================================================|\n",
+ "+-----------------------------------------------------------------------------+\n"
+ ]
+ }
+ ],
+ "source": [
+ "!nvidia-smi"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Now, test if PyTorch can access the GPU via CUDA:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "torch.cuda.is_available()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[name: \"/device:CPU:0\"\n",
+ " device_type: \"CPU\"\n",
+ " memory_limit: 268435456\n",
+ " locality {\n",
+ " }\n",
+ " incarnation: 891330946073693377, name: \"/device:XLA_CPU:0\"\n",
+ " device_type: \"XLA_CPU\"\n",
+ " memory_limit: 17179869184\n",
+ " locality {\n",
+ " }\n",
+ " incarnation: 9415777875944419380\n",
+ " physical_device_desc: \"device: XLA_CPU device\"]"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from tensorflow.python.client import device_lib\n",
+ "device_lib.list_local_devices()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[0.8722, 0.5115, 0.9504],\n",
+ " [0.7723, 0.2860, 0.5793],\n",
+ " [0.5388, 0.5681, 0.4295],\n",
+ " [0.5269, 0.5165, 0.7475],\n",
+ " [0.4882, 0.8255, 0.6498]])"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from __future__ import print_function\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "a = torch.rand(5, 3)\n",
+ "a"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Performance test\n",
+ "\n",
+ "#### Now we want to know how much faster a typical operation is using GPU. Therefore we do the same operation in numpy, PyTorch and PyTorch with CUDA. The test operation is the calculation of the prediction matrix that is done in a linear regression."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 1) Numpy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = np.random.rand(10000, 256)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "590 ms ± 41.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%timeit\n",
+ "H = x.dot(np.linalg.inv(x.transpose().dot(x))).dot(x.transpose())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 2) PyTorch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = torch.rand(10000, 256)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "853 ms ± 16.6 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%timeit\n",
+ "# Calculate the projection matrix of x\n",
+ "H = x.mm( (x.t().mm(x)).inverse() ).mm(x.t())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 3) PyTorch on GPU via CUDA"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[0.1054, 0.3291, 0.7729, 0.6005, 0.2372],\n",
+ " [0.1022, 0.4534, 0.3964, 0.9174, 0.2610],\n",
+ " [0.3969, 0.5472, 0.3876, 0.1979, 0.4063],\n",
+ " [0.3630, 0.6374, 0.4176, 0.4804, 0.0396],\n",
+ " [0.8256, 0.2289, 0.2265, 0.4388, 0.6070]], device='cuda:0')\n",
+ "tensor([[0.1054, 0.3291, 0.7729, 0.6005, 0.2372],\n",
+ " [0.1022, 0.4534, 0.3964, 0.9174, 0.2610],\n",
+ " [0.3969, 0.5472, 0.3876, 0.1979, 0.4063],\n",
+ " [0.3630, 0.6374, 0.4176, 0.4804, 0.0396],\n",
+ " [0.8256, 0.2289, 0.2265, 0.4388, 0.6070]], dtype=torch.float64)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# let us run this cell only if CUDA is available\n",
+ "# We will use ``torch.device`` objects to move tensors in and out of GPU\n",
+ "if torch.cuda.is_available():\n",
+ " device = torch.device(\"cuda\") # a CUDA device object\n",
+ " x = torch.rand(10000, 256, device=device) # directly create a tensor on GPU\n",
+ " y = x.to(device) # or just use strings ``.to(\"cuda\")``\n",
+ " print(x[0:5, 0:5])\n",
+ " print(y.to(\"cpu\", torch.double)[0:5, 0:5])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "11.3 ms ± 60.3 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%timeit\n",
+ "H = x.mm( (x.t().mm(x)).inverse() ).mm(x.t())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Exhaustive Testing on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# let us run this cell only if CUDA is available\n",
+ "# We will use ``torch.device`` objects to move tensors in and out of GPU\n",
+ "import torch\n",
+ "if torch.cuda.is_available():\n",
+ " device = torch.device(\"cuda\") # a CUDA device object\n",
+ " x = torch.rand(10000, 10, device=device) # directly create a tensor on GPU"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[0.3112, 0.7480, 0.1882, 0.8453, 0.8198],\n",
+ " [0.5953, 0.8401, 0.3126, 0.6025, 0.5252],\n",
+ " [0.1902, 0.5610, 0.7968, 0.1463, 0.7154],\n",
+ " [0.7979, 0.2161, 0.6176, 0.2951, 0.1980],\n",
+ " [0.6451, 0.3837, 0.5305, 0.2740, 0.3330]], device='cuda:0')\n"
+ ]
+ }
+ ],
+ "source": [
+ "if torch.cuda.is_available():\n",
+ " y = x.to(device) # or just use strings ``.to(\"cuda\")``\n",
+ " print(x[0:5, 0:5])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if torch.cuda.is_available():\n",
+ " # Here is the memory of the GPU a border. \n",
+ " # A matrix with 100000 lines requires 37 GB, but only 8 GB are available.\n",
+ " H = x.mm( (x.t().mm(x)).inverse() ).mm(x.t())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 1.2748e-03, 5.3656e-04, 1.7376e-04, 3.3888e-06, -1.7049e-04],\n",
+ " [ 5.3656e-04, 6.3624e-04, 2.5957e-05, 3.3281e-04, -1.6239e-05],\n",
+ " [ 1.7376e-04, 2.5957e-05, 7.6328e-04, 7.7603e-05, 1.8272e-04],\n",
+ " [ 3.3888e-06, 3.3281e-04, 7.7603e-05, 9.6281e-04, 1.2375e-04],\n",
+ " [-1.7049e-04, -1.6239e-05, 1.8272e-04, 1.2375e-04, 6.9231e-04]],\n",
+ " device='cuda:0')\n"
+ ]
+ }
+ ],
+ "source": [
+ "if torch.cuda.is_available():\n",
+ " print(H[0:5, 0:5])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 1.2748e-03, 5.3656e-04, 1.7376e-04, 3.3888e-06, -1.7049e-04],\n",
+ " [ 5.3656e-04, 6.3624e-04, 2.5957e-05, 3.3281e-04, -1.6239e-05],\n",
+ " [ 1.7376e-04, 2.5957e-05, 7.6328e-04, 7.7603e-05, 1.8272e-04],\n",
+ " [ 3.3888e-06, 3.3281e-04, 7.7603e-05, 9.6281e-04, 1.2375e-04],\n",
+ " [-1.7049e-04, -1.6239e-05, 1.8272e-04, 1.2375e-04, 6.9231e-04]],\n",
+ " dtype=torch.float64)\n"
+ ]
+ }
+ ],
+ "source": [
+ "if torch.cuda.is_available():\n",
+ " # This operation is difficult, as an symmetric matrix is transferred \n",
+ " # back to the CPU. Is possible up to 30000 rows.\n",
+ " print(H.to(\"cpu\", torch.double)[0:5, 0:5])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/extra/Getting_Started/JuliaQuickstart.ipynb b/extra/Getting_Started/JuliaQuickstart.ipynb
new file mode 100755
index 0000000..6f9e005
--- /dev/null
+++ b/extra/Getting_Started/JuliaQuickstart.ipynb
@@ -0,0 +1,5742 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Demo script for Julia language\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Basic Interaction & Plotting"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.024"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# In Julia, calculations can be written very comfortable\n",
+ "n = 10\n",
+ "(2^n - 10^(0.3*n)) / 10^(0.3*n)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "using IJulia\n",
+ "using Gadfly\n",
+ "using RDatasets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# This is how additional packages can be imported\n",
+ "# import Pkg\n",
+ "# Pkg.add(\"RDatasets\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "iris = dataset(\"datasets\", \"iris\");"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "┌ Warning: `getindex(df::DataFrame, col_ind::ColumnIndex)` is deprecated, use `df[!, col_ind]` instead.\n",
+ "│ caller = evalmapping(::DataFrame, ::Symbol) at dataframes.jl:96\n",
+ "â”” @ Gadfly /opt/julia/packages/Gadfly/1wgcD/src/dataframes.jl:96\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ "\n",
+ "\n"
+ ],
+ "text/html": [
+ "\n",
+ "\n"
+ ],
+ "text/plain": [
+ "Plot(...)"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "plot(iris, x=:SepalLength, y=:PetalWidth, color=:Species, Geom.point)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Python $\\leftrightarrow$ Julia interoperability\n",
+ "\n",
+ "## Julia Kernel in Python notebook\n",
+ "\n",
+ "To use the `%%julia` magic in a notebook with another kernel, add `julia` in the defaults in the file `/opt/conda/lib/python3.7/site-packages/IPython/core/magics/script.py` (using nano in a terminal).\n",
+ "\n",
+ "Like here:\n",
+ "```python\n",
+ "defaults = [\n",
+ " 'sh',\n",
+ " 'bash',\n",
+ " 'perl',\n",
+ " 'ruby',\n",
+ " 'python',\n",
+ " 'python2',\n",
+ " 'python3',\n",
+ " 'pypy',\n",
+ " 'julia', # add the julia interpreter\n",
+ "]\n",
+ "```\n",
+ "\n",
+ "Then restart the kernal and use the julia kernel in a non-julia notebook with:\n",
+ "\n",
+ "```python\n",
+ "%%julia\n",
+ "rfib(n) = n < 2 ? n : rfib(n-1) + rfib(n-2)\n",
+ "rfib(12)\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Python Modules in Julia\n",
+ "\n",
+ "**Important: This funcionality is still in progress, see https://github.com/JuliaPy**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m registry at `/opt/julia/registries/General`\n",
+ "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n",
+ "\u001b[?25l\u001b[2K\u001b[?25h\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n",
+ "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `/opt/julia/environments/v1.1/Project.toml`\n",
+ "\u001b[90m [no changes]\u001b[39m\n",
+ "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `/opt/julia/environments/v1.1/Manifest.toml`\n",
+ "\u001b[90m [no changes]\u001b[39m\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Install if not already done\n",
+ "import Pkg; Pkg.add(\"PyCall\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "using PyCall"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "PyObject "
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np = pyimport(\"numpy\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Did it work?\n",
+ " -> true\n"
+ ]
+ }
+ ],
+ "source": [
+ "println(\"Did it work?\\n -> \", np.sin(np.pi/2) == 1.0)"
+ ]
+ },
+ {
+ "cell_type": "raw",
+ "metadata": {},
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Julia 1.1.0",
+ "language": "julia",
+ "name": "julia-1.1"
+ },
+ "language_info": {
+ "file_extension": ".jl",
+ "mimetype": "application/julia",
+ "name": "julia",
+ "version": "1.1.0"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/extra/Getting_Started/JupyterBasics.ipynb b/extra/Getting_Started/JupyterBasics.ipynb
new file mode 100755
index 0000000..52b7f35
--- /dev/null
+++ b/extra/Getting_Started/JupyterBasics.ipynb
@@ -0,0 +1,337 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Getting Started\n",
+ "\n",
+ "**Markdown** is a method to write documentations and even embed `HTML` and `Latex` formulas.\n",
+ "\n",
+ "### Jupyter tutorial\n",
+ "\n",
+ "[![Jupyter Youtube Tutorial](https://img.youtube.com/vi/CwFq3YDU6_Y/0.jpg)](https://www.youtube.com/watch?v=CwFq3YDU6_Y?rel=0&showinfo=0)\n",
+ "\n",
+ "\n",
+ "### Bayesian Rule\n",
+ "$$P(A \\mid B) = \\frac{P(B \\mid A)P(A)}{P(B)}$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Coding and magic commands"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[1, 8, 27, 64, 125, 216, 343]"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "[x**3 for x in range(1,8)]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/json": {
+ "cell": {
+ "!": "OSMagics",
+ "HTML": "Other",
+ "SVG": "Other",
+ "bash": "Other",
+ "capture": "ExecutionMagics",
+ "debug": "ExecutionMagics",
+ "file": "Other",
+ "html": "DisplayMagics",
+ "javascript": "DisplayMagics",
+ "js": "DisplayMagics",
+ "latex": "DisplayMagics",
+ "markdown": "DisplayMagics",
+ "perl": "Other",
+ "prun": "ExecutionMagics",
+ "pypy": "Other",
+ "python": "Other",
+ "python2": "Other",
+ "python3": "Other",
+ "ruby": "Other",
+ "script": "ScriptMagics",
+ "sh": "Other",
+ "svg": "DisplayMagics",
+ "sx": "OSMagics",
+ "system": "OSMagics",
+ "time": "ExecutionMagics",
+ "timeit": "ExecutionMagics",
+ "writefile": "OSMagics"
+ },
+ "line": {
+ "alias": "OSMagics",
+ "alias_magic": "BasicMagics",
+ "autoawait": "AsyncMagics",
+ "autocall": "AutoMagics",
+ "automagic": "AutoMagics",
+ "autosave": "KernelMagics",
+ "bookmark": "OSMagics",
+ "cat": "Other",
+ "cd": "OSMagics",
+ "clear": "KernelMagics",
+ "colors": "BasicMagics",
+ "conda": "PackagingMagics",
+ "config": "ConfigMagics",
+ "connect_info": "KernelMagics",
+ "cp": "Other",
+ "debug": "ExecutionMagics",
+ "dhist": "OSMagics",
+ "dirs": "OSMagics",
+ "doctest_mode": "BasicMagics",
+ "ed": "Other",
+ "edit": "KernelMagics",
+ "env": "OSMagics",
+ "gui": "BasicMagics",
+ "hist": "Other",
+ "history": "HistoryMagics",
+ "killbgscripts": "ScriptMagics",
+ "ldir": "Other",
+ "less": "KernelMagics",
+ "lf": "Other",
+ "lk": "Other",
+ "ll": "Other",
+ "load": "CodeMagics",
+ "load_ext": "ExtensionMagics",
+ "loadpy": "CodeMagics",
+ "logoff": "LoggingMagics",
+ "logon": "LoggingMagics",
+ "logstart": "LoggingMagics",
+ "logstate": "LoggingMagics",
+ "logstop": "LoggingMagics",
+ "ls": "Other",
+ "lsmagic": "BasicMagics",
+ "lx": "Other",
+ "macro": "ExecutionMagics",
+ "magic": "BasicMagics",
+ "man": "KernelMagics",
+ "matplotlib": "PylabMagics",
+ "mkdir": "Other",
+ "more": "KernelMagics",
+ "mv": "Other",
+ "notebook": "BasicMagics",
+ "page": "BasicMagics",
+ "pastebin": "CodeMagics",
+ "pdb": "ExecutionMagics",
+ "pdef": "NamespaceMagics",
+ "pdoc": "NamespaceMagics",
+ "pfile": "NamespaceMagics",
+ "pinfo": "NamespaceMagics",
+ "pinfo2": "NamespaceMagics",
+ "pip": "PackagingMagics",
+ "popd": "OSMagics",
+ "pprint": "BasicMagics",
+ "precision": "BasicMagics",
+ "prun": "ExecutionMagics",
+ "psearch": "NamespaceMagics",
+ "psource": "NamespaceMagics",
+ "pushd": "OSMagics",
+ "pwd": "OSMagics",
+ "pycat": "OSMagics",
+ "pylab": "PylabMagics",
+ "qtconsole": "KernelMagics",
+ "quickref": "BasicMagics",
+ "recall": "HistoryMagics",
+ "rehashx": "OSMagics",
+ "reload_ext": "ExtensionMagics",
+ "rep": "Other",
+ "rerun": "HistoryMagics",
+ "reset": "NamespaceMagics",
+ "reset_selective": "NamespaceMagics",
+ "rm": "Other",
+ "rmdir": "Other",
+ "run": "ExecutionMagics",
+ "save": "CodeMagics",
+ "sc": "OSMagics",
+ "set_env": "OSMagics",
+ "store": "StoreMagics",
+ "sx": "OSMagics",
+ "system": "OSMagics",
+ "tb": "ExecutionMagics",
+ "time": "ExecutionMagics",
+ "timeit": "ExecutionMagics",
+ "unalias": "OSMagics",
+ "unload_ext": "ExtensionMagics",
+ "who": "NamespaceMagics",
+ "who_ls": "NamespaceMagics",
+ "whos": "NamespaceMagics",
+ "xdel": "NamespaceMagics",
+ "xmode": "BasicMagics"
+ }
+ },
+ "text/plain": [
+ "Available line magics:\n",
+ "%alias %alias_magic %autoawait %autocall %automagic %autosave %bookmark %cat %cd %clear %colors %conda %config %connect_info %cp %debug %dhist %dirs %doctest_mode %ed %edit %env %gui %hist %history %killbgscripts %ldir %less %lf %lk %ll %load %load_ext %loadpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %lx %macro %magic %man %matplotlib %mkdir %more %mv %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %pip %popd %pprint %precision %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx %reload_ext %rep %rerun %reset %reset_selective %rm %rmdir %run %save %sc %set_env %store %sx %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmode\n",
+ "\n",
+ "Available cell magics:\n",
+ "%%! %%HTML %%SVG %%bash %%capture %%debug %%file %%html %%javascript %%js %%latex %%markdown %%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%time %%timeit %%writefile\n",
+ "\n",
+ "Automagic is ON, % prefix IS NOT needed for line magics."
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# List all magic commands\n",
+ "%lsmagic"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np \n",
+ "x = np.random.normal(0, 1, 1_000_000)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1.03 ms ± 4.93 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%timeit \n",
+ "x.mean()**2 - (x**2).mean()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Send variables back and fourth in bash\n",
+ "\n",
+ "The strings will be saved as files in the working directory"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "string_0\n",
+ "string_1\n",
+ "string_2\n",
+ "string_3\n",
+ "string_4\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i in range(5):\n",
+ " string = \"string_{}\".format(i)\n",
+ " print(string)\n",
+ " !touch $string"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "-rw-r--r-- 1 jovyan users 0 Dec 19 08:44 string_0\n",
+ "-rw-r--r-- 1 jovyan users 0 Dec 19 08:44 string_1\n",
+ "-rw-r--r-- 1 jovyan users 0 Dec 19 08:44 string_2\n",
+ "-rw-r--r-- 1 jovyan users 0 Dec 19 08:44 string_3\n",
+ "-rw-r--r-- 1 jovyan users 0 Dec 19 08:44 string_4\n"
+ ]
+ }
+ ],
+ "source": [
+ "!ls -l | grep string_"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['string_0', 'string_1', 'string_2', 'string_3', 'string_4']"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "files = !ls -1 string_*\n",
+ "!rm string_*\n",
+ "files"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/extra/Getting_Started/MultiInterpreterNotebook.ipynb b/extra/Getting_Started/MultiInterpreterNotebook.ipynb
new file mode 100755
index 0000000..ed97de3
--- /dev/null
+++ b/extra/Getting_Started/MultiInterpreterNotebook.ipynb
@@ -0,0 +1,142 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Python and R in a single Notebook \n",
+ "\n",
+ "From the instructions of [all-spark-notebook](https://github.com/jupyter/docker-stacks/tree/master/all-spark-notebook) and [Stackoverflow](https://stackoverflow.com/questions/39008069/r-and-python-in-one-jupyter-notebook).\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Last run: 2019-12-19 09:09:24.610738 UTC\n"
+ ]
+ }
+ ],
+ "source": [
+ "import datetime\n",
+ "print('Last run:', datetime.datetime.utcnow(), 'UTC') # timezone can't be detected from browser"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Processing in Python\n",
+ "* Create a dataframe\n",
+ "* load the rpy2 module"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "n = 100\n",
+ "df = pd.DataFrame({\n",
+ " 'cups_of_coffee': np.random.exponential(3, size=n),\n",
+ " 'productivity': np.random.normal(100, 15, n),\n",
+ " 'gender': np.random.choice([\"f\", \"m\"], n)\n",
+ "})"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%load_ext rpy2.ipython"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Processing in R\n",
+ "\n",
+ "* Install and load ggplot2\n",
+ "* Receive the dataframe and set the figure size including resolution\n",
+ "* Plot the dataframe"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%%R\n",
+ "#install.packages(\"ggplot2\", repos='http://cran.us.r-project.org', quiet=TRUE)\n",
+ "library(ggplot2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/conda/lib/python3.7/site-packages/rpy2/robjects/pandas2ri.py:191: FutureWarning: from_items is deprecated. Please use DataFrame.from_dict(dict(items), ...) instead. DataFrame.from_dict(OrderedDict(items)) may be used to preserve the key order.\n",
+ " res = PandasDataFrame.from_items(items)\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxMAAAMTCAIAAABVON0HAAAACXBIWXMAAB7CAAAewgFu0HU+AAAgAElEQVR4nOzdeXxU1d0/8O+5984+WcmeQBICCMgmIirggoCKirJYC4pSH+2u1v6qtVVrFa219nGptk/bp621LvRRBNe64YKgLCKbAmEPIWTfk9nn3nt+fwwZQjKZmWT2mc/71dereOfM3G9yk8xnzjn3HMY5JwAAAAAIghDrAgAAAAASBpITAAAAQLCQnAAAAACCheQEAAAAECwkJwAAAIBgITkBAAAABAvJCQAAACBYSE4AAAAAwUJyAgAAAAgWkhMAAABAsJCcAAAAAIKF5AQAAAAQLCQnAAAAgGAhOQEAAAAES4p1Acmgo6NjyM/V6XRarZaIHA6H2+0OX1HxS5Ikg8FgtVpVVY11LdGQspfYZrMpihLrWqLBe4mdTqfL5Yp1OdEgiqLRaEydS6zVanU6HfVc4szMzFhXBLGE5BQGsiwP+bk6nU4URSLinIfyOglEEARRFFVVTZGv13uJKbQflQTiucSKoqTI16vValPtt5gxhksMKQujdQAAAADBQnICAAAACBaSEwAAAECwkJwAAAAAgoXkBAAAABAsJCcAAACAYCE5AQAAAAQLyQkAAAAgWEhOAAAAAMFCcgIAAAAIFpITAAAAQLCQnAAAAACCheQEAAAAECwkJwAAAIBgITkBAAAABAvJCQAAACBYSE4AAAAAwUJyAgAAAAgWkhMAAABAsJCcAAAAAIKF5AQAAAAQLCQnAAAAgGAhOQEAxJhNVR2cx7oKAAiKFOsCAABSVK3b/UxL+9udXc2yQkTDtZpFGek/HpaVLYmxLg0ABoQ+JwCAGFjXbZ116Nhzre2e2ERENS73M82tFxw+tsPmiG1tAOAHkhMAQLTttDtuPl5rUdX+DzXJ8rLjJ2rccvSrAoBgIDkBAETbPXWNTp8TmzgRUZus/Lq+McolAUCQkJwAAKJqr8O50z7AeBw7+f/vdVvbekbxACCuIDkBAETVgLGpF5nzrx2Y7QQQj5CcAACiqlvxMb2pP4uKdQoA4hGSEwBAVBVqgloOpgBrEwDEJSQnAICousBslBjz3yZbEqcY9NGpBwAGBckJACCqhoni9VkZ/tv8cFhWwHQFADGB5AQAEG0P5ueO1esGevQCs/HHOdnRrAcAgofkBAAQbWmi8GbZ8EvTzH2OM6JlmemrSks06HACiFfYtw4AIAayJfHl0uJtNsd/urqPuFwCsbE67cLM9HE6baxLAwB/kJxSncL5AaerWZbTRfFMvU6bep90m2Xlna7u/U6XTVHKddpL08wTBh5GAQivc4z6c4yYCQ6QSJCcUpeL8/9paf9ra1tLz1LFZkFYlpX+87ycTDElbofmRH9obnuyucXea+Gc3za2XJme9mRRPvarBwCA/pCcwoCF0E/jfS5jLJTXGaxuRV1afWKr1db7oEVV/9basa7buqZ8eKk2UkMGvb/kCJ0iSD+rbXihraP/8f90dR90Ot+rKA17goz5lxwdni8zyj/SMdT7y0ypLzl1LrFXCn7J0B/jPnedhGS3ZO/+tc2tAz06wWTcfvYUrZDMfyBebWr59r4Dfhosy8tdNX5M1OoBgISgqqog4OaqlIbkFAZWq3XIz9VqtRqNhoicTqcsy+Eryp8vuq2X7T/kv81TpSXfzcuJxNlFUdTr9Xa7XVWD2oMiQs7be2CPze6nASP6etL48pCn63ovscvlcrvdIb5aQoiTSxw1uMRJT6PRaLVaInK5XC6Xy2zue1MkpBSM1oWB3e7vDdg/QRA8f3PdbrcjWht8rmpqDtjm382ty9NMkTi7VqvV6/XRTIr91bnlk7GJn9qdvg9O9E5zy63DskI8V+9LHMqPSgKJh0scTYyxVLvEGo0m1S6xJzl5/lAjOaU4dDmmov0OZ+A2zsBtElett2PA74BkrTsl3hUAACB4SE6pKHAc4ORK6n3aTcFNUzBiNgMAAJwObwypqFSjCdCCUbk2UJtEVqHTBhOeJhmwsBMAAJwG85zigMOh7PpKPFBptFpUnV4tGeEeP4kbDJE74fx089rOrkBt0iJXQMzpGFuYkfZyeyfRgFOdCjXSxeaIzPQCAIDEheQUY+zAPtdba7jV4ukAEYnoYKX2i88cl1wmT5gcoZMuSDeP1+v2DTzbKVsSvx/yzOg494u8nA+6LS2y4jM2MaJHCvN0WLgFAABOh9G6WNIcrGT/9wK3WvocZ06H4b03Nbu3R+i8ImPPjyjOk3znZoPA/l5SlPQraBdopFWlJT6/CSJjjxTmXZ3UvW4AADA0SE4xw+x23ftv08Draek+fl/o9LHCdViUazUfVoyY12/dgbMM+nfKR1xgNkbovHHlLIP+s1Fl3x2WOaxnrXAtY5emmd8tH/G9ZO9yAwCAocFoXcxodm9nTn8LODFF0Wzf6rzksggVUKzRrCotOeJ0bbDammQ5SxSnGw2TDfqUGqDKkcRHC/MfLshrkhUn54UaCSN0AADgB5JTzEjVR4NoUxXpVZUqdNqKkJfJTnQiY4Ua/C4AAEBgGK2LGdZvepOPNpbuKFQCAAAAQUJyih1d4LWCeBBtAAAAIGqQnGJGLiwJ2EYpCtwGAAAAogbJKWbkSWdRoMnI7slTo1MMAAAABAPJKWaUnDzXOef7aSBPmKwML4tWOQAAABAYklMsOS+4hA8QntzjJjguvSrK9QAAAIB/uBM7pgSBX7lQe9Y05fP1ypGDzOnkGo1SPMI99Ry5YkysiwMAAIC+kJxiT6gYLVSMdlosTquFi5G9IkyWWUcbU1U1LSOimwoDAAAkJSSnOBLR2MQ6O/RffCYe3MfcbiIixpSiEueMC5WyisidFAAAIMlgnlNKEE9Um174m7R398nYRESci7U1xtdWab9YH8vKAAAAEgqSU/ITujoNr7/KHHYfj3Gu27RB882uqBcFAACQkJCckp/u8099xyZvg8/WneqLAgAAgIEhOSU5JrvFA5UB2tjtUtXh6NQDAACQ0JCckpzQ3s7kwP1JrKkhCsUAAAAkOiSnZHcyNnH/rZgsR6EWAACARIfklOTUjExijKjXBnm+QpSakRm1kgAAABIXklOS40aTUlB02qH+uwwLgoIlywEAAIKA5JT8XDMu8t9AzchS0zOiUwwAAEBCQ3JKfnJ5hWoyEw042Ulob5UO7o9mSQAAAAkKySn5idVVgtVC5Gucrofuq81RqwcAACBxITklP+l4VcA2Qt0J5nJFoRgAAICEhuSU/ASLJXAjzpk1iGYAAACpDckp+ak6bTDNuF4f6UoAAAASHZJT8lOLSgK3yczmBmMUigEAAEhoSE7JTx51Bjea/LdxTz4rOsUAAAAkNCSn5Mc1Wue8K4gNeGedkl/oPvvcaJYEAACQoJCcUoJ7zDjHpVeSKPZ/SC0qti9ZxkUp+lUBAAAkHLxfpgr3pKnK8FLt1k1S1WFm6eaiyAuKXBMmuydMIQEBGgAAIChITilEzRrmuHwBEZGi+Ox/AgAAAP+QnFJS6sUml8pXdXS+1dV9yOninMq1mqsz0m/MztAPPP0LAACgPyQnSH5HXa4bq2sPOk8tkt4oy1ts9r+2tr1YWjIuuPWuAAAACDPEIek1yfLiqhO9Y5NXtcu9uOp4jcsd/aoAACBBITlBklvZ2FLrHjAbtcjK/Q3N0awHAAASGpITJLMORVnb0eW/zXtd3XVuOTr1AABAokNygmS23e5wc+6/DSfaarNHpx4AAEh0SE6QzNplJZhmbTL6nAAAIChITpDMhgW3/kKuBjeZAgBAUJCcIJmdYzJoA63YJBCdbzRGpx4AAEh0SE6QzMyCcENWhv82izPTc6WUWxoUAACGBskJkty9+TkVA691WaLVrCzIi2Y9AACQ0JCcIMlliuLrZcOnGQ39H5qo171ZPhwdTgAAEDxMjIXkV6iR/lM+4j/dljc7uw46XZxolE57VZp5YUaaiH3rAABgMJCcICUIjBakmxekm2NdCAAAJDaM1gEAAAAEC31OKUE8dlQ6ekjoaOcaDc/Nd4+boGZkxrooAACAxIPklORYV6fhnbVibc2pQ/v3ajd95pp2nnPWbBLQ6QgAADAISE7JjFm6Tav+ybr7bXmrKNqtXwjd3fYrriFMkQYAAAgauhySmf6Dt33Eph7Svq+lym+iWQ8AAECiQ3JKWmJLk3T0sP82ui83RacYAACA5IDklLTEqiMB2wjNTay7OwrFAAAAJAckp6TFLAEjESciwTLgcB4AAAD0gRniSYtrB9ysrQcjIq7TRaGYSGA2q1RTTXYb6Q1y8XCelh7rigAAIPkhOSUttaAoYBtuMKiZ2VEoJryYzar75EPN/j3Eec8hJleMcVxyGcc6VQAAEEkYrUtaSlkFT8/w38Z95uSEW9JJ6Owwvfh3TeU3p2ITEXEuHT5gevHvYnNT7EoDAIDkl2DvmhA8LoqOufP9LNekpme4zrsgmiWFgarq33iVdXX6fJDZbfrX/4/JcpSLAgCA1IHklMzkijGOy64iUez/kJqZbf/Wcm4wRL+qUGgO7BObGvw0EDo7NLu3R60eAEgUVVVVVVVVsa4CkgHmOSU598SzlKLhui2fi0cOMqeDiNSsbPnMya5p53JNzxRyRRFrjoltraSqamaWUjqSazSxLHpg4sHKgG2kg5Wus8+NQjEAkBAQmCC8kJySnzosx37lQiJiDjtJGi6ddtGlPbv1Gz5mVov3CNfpXOfOck2fEYcbswhtrWFpAwCpAJkJIgHJKYVwfd+xOd3GT7RbPu9zkDmdug0fC431jgVL4i48BVNPvNUMALGA2AQRgnlOqUs6uL9/bPLSHNinjb+9WdRhOWFpAwBJDFOaIKLQ55TMVE7VbneXouRIYnG/qUu6zz/x/3Tt1s/dU6eHcc5Tl6J+7XBYrPYKYqM4H0LXkHzGeM3+vf7buM8YP7TyACDRITBBFCA5JSerqv6xpe2Fts6mnlv0R2q1P8zJujErQ2SMiIS2FqG1xf+LMKdTrD4qjzoj9Hrq3fLDjc1vdnW7VE5EVHU8QxS/Nyzzztxh2sEMrsmjxypFJWLdiYEaqMNy3BPP6nOQuV3Svm/EY0cFq4Xr9GpRievMSQEXuwKABILMBFGD5JSE6t3yt4/VVDpdvQ8edbnurmv8oNvyzxHFesaEjvZgXirIZv7tczi/dexE0+nLLHXKyu+bWtdbrK+WDTcHvxonY/ZrvmV85QWf08B5eoZ90dI+qzCIx44Y3n2z9xR4OnpIs3mja9bFrukzBvu1AEC8QWaCKENySjYy5zcdr+0Tm7w+6rbeXdvwbElhsEuHh7zCuFVVlx+vbeq/OiUjItpmc9xxov65EcXBvyA3p9luuEX3+afS1zuZ0vOyoiiPm+C4aC43mno3Fo8dMa75N6lq35Mrsu6zj8jtcs28eFBfTioTG+s1u3cIdTXM5SKT2V1a7p4yjZvTYl0XpC5kJogJJKdk838dXbvsDj8NXuno+q9hWVOzc4ix0zYw8UXJDnW29d9aO2pcbj8N3u6ybLPZzzEOYk1Ortc75s5nF80RTtQwu5UMRqWwuP+dg8ztNrz7Zv/Y5KXbvFGpGKMEscFfqlNV3acfanduO/UD09mhqzuh3bbFcemV8pmTYlocpCjEJogV3FuXbF7t8L0ziRcnWt3RydMzlKKSAC3Nacrw0hDrWRuoHiJ6o7N7CK/MNVqlvEIeP0kuH9U/NhGRtO+b0wbpfLwE13y1ZQinTjX6j97T7viyb87mxGS34b03NZV7YlQXpCjcOgexheSUbPY5fI/T9bbX4SIi50Vz/Q/GOS6c43PnluBxosOeDie/fVsHBxhbDJFYfTRgG+lY4DYpTjxe5XtDG8/Mfs51H73L7PboFgUpCpkJ4gGSU7JxeAan/CYVB1eJSCke7rj0qoHCk/O8WaGPwqicnxwq83v/nBxo0HBoBP8dTkTkWVddUSJx9qSh3bHNfwPmcGj2fR2dYiBlITNB/MA8p2QzQqs55HT5TyojepZock+comYP0332kVhb431UzclzXjA7LIsRiIyVajRHXQG6lEbqtP4bDA3X6QO3kTQh9qslPbGmOqg22CsQIgOBCeINklOyuTTNfMjZFrCN999K8XDb9Tezrk6xtZlUVc0epmYNC2M9V2aYn20OUM9V6RG5P0spKpGOHPTfRi0ZHolTJw9VZY7AI3HMZo1CLZBqkJkgPmG0Ltn8MCfr1PJIvgbBRum0CzP6JhWeniGXj5IrxoQ3NhHRj4ZlZ0n+OnXONxlmm43hPamH+8xJfbY39tFm0tRInDp5CILP2fd99FkMAiB0iE0Qt5Cckk2+JP1PSaHGszB3vzG7TFF8bniRJop74uZI4j9KiowDzKYq02r+NjxSiwLwtHTXBZf4aSCPOsM9emyEzp40lJIRgduEfA8mgBemNEGcQ3JKQvPTzavLSkZq+04emm40vD9yxDi9Lsr1XGA2vjtyxDnG02YdCUTfzsr4YGRpfqBuoWC4VL7T7vi027rb7ug939w17TzXzIvJV1KUR53huGqRz4egN9fU6f4bcJ3eNX5idIqB5IbMBAkB85yS00yT8fPRZZ9bbF/a7e2Kmi9JF5gM0waz2mR4nanXvTuytNLh3G53dBONTE+fJrKwjAt2K+oTza0vtnd0KSdv48sUxZuzM36am2MQGBE5Z1woV4zWfLVFOnaU2axco1VLhrsmTZVHj0VsCoZSWu6edJbm650DNXDMnU+GiIy3QupAYIIEguSUtDSMzU4zzU6Lowko4/S6cXqdVqtNT0/v6OiQ+2/JMkj1bvnaYzUHnS7ip4YmOxTlqea2j7qtr5UPzxZFIlLyC5UrFxERcY60NASOuVeQKGl2fdVnMUwuSc55V8jocIIQIDNBwkFygkSlcP6dmtqTq2j2i0PfOJy31tStKRt+2iOITUMjio65813jJ2m/3iHWn2B2u2pOU8oqXGdN42npsS4OEhUyEyQoJCdIVGs7u3fY/O3Qt9Fi+6DLcnm62U8bCJ5aVOwoGsTezAB+IDZB4kqY5MQ5f/fdd//5z3+6XK577733vPPO89msrq7u9ddf37VrV2trqyiKhYWF06dPX7RokcnUd9CqtbX1tdde27FjR0tLi0ajKS0tnTdv3pw5cxi6JRLE2s6uYNogOQHEFWQmSHSJkZxaW1ufeeaZnTsHnKPq8eWXXz7++OMul0uv15eWltrt9urq6mPHjq1fv/53v/vdsGGnZiRXV1fff//9nZ2dJpNpzJgxDodj//79lZWVu3bt+tnPfobwlBAOBLHb3f7I7IgHAEOAzATJIQGS05dffvn0009brdZFixZ98cUXTU1NPpu1t7c/8cQTLpfr4osv/sEPfmA0GomoqqrqkUceaWpqev7553/2s595Wqqq+tRTT3V2dl588cW33XabVqslourq6gceeGDDhg0TJ0687LLLovbVwZC5g9jtLpg2ABBpyEyQTBJgPafPPvtMo9E89NBDN998szDAgopE9Mknn9jt9oKCgp/85Cee2ERE5eXlN910ExFt2bKF97yJ7tix4+jRo9nZ2bfffru2Z9Gj0tLSW265hYjWrFkT2a8HwqSsZ/e93tJkeWZb85VNdVO72kXOy7Q+2gBA1GCJJkg+CdDnNGXKlO9973sZGRn+m40aNWrZsmUlJSXi6Ru4jho1ioicTqfFYklLSyOiTZs2EdGFF16oOf2td+bMmc8++2xDQ8ORI0cqKirC/GVAuM1PN2+x2YnIsyRBodP+yP6vr204rlNPLuzUotUdnnw2lRRiT1+A6ENggmSVAMlp3rx5wTSbPHny5MmT+x/v6uoiIp1O550kfuTIESI644wz+rQURXHkyJGVlZVITglhRXbmX1rb690yMZrY3fn2tvUFztNutctxOXO2bVIa6uxLlnFfHVQAEAnITJDcEmC0LkTr1q0jogsvvNA70tfQ0EBEubm5/Rvn5+cTUV1dXRQLhCEyCcLzw4vTRCFNltd+taFPbPISa47pP/xPlGsDSFmITZD0EqDPKRRffPHFxx9/bDQar7/+es8RzrnD4SAi71yo3jwH7XZ7/4ccDscrr7zS//jEiRP7d18FT+rZtU2j0aTIPX2eL1mn02lC7geaaTCsNxm3vfvWcIfN3xkrvzHOvJAXxmYtot6XOCYFRF8YL3FC8H6ZKfL1EpFnUkSfS3zo0CGK+2+CwTCUTah6/xZz3HeS8pI5OX366afPPvusIAi//OUvvUsSuN1uz8+95GujWc/vvNPp7P+Q3W5/9tln+x//zne+M3Xq1NCr1el0Ol209+KNoaH9/epvqsk0oak2wF8yzrUH9kmjxoTljEOm1Wq1/bZhTmLhusQJJGUvcWVlJRElxF+w/mv7DYpWq/X53gEpJTl/Ajjnq1ateuWVV/R6/S9+8Yve8588XTucc5+bprlcLkqQ3384SVV5S3PAVryxIQq1AKQaT2YCSClJmJxcLtfTTz/9+eef5+Tk3H///SNHjuz9KGPMYDDYbDabzcf4jtVqpQE+lBgMhttvv73/8YkTJ3qeNTRardbb0RX6DrgJQZIknU5nt9vVnpvgQqIoUhCd54rb7QrhMoXCe4ldLpfb7Y5JDVEW5ksc91LwEouiWFVV5Xa7E+4SD+3PtUaj8fQmulwul8tlNmNngpSWbMnJ5XI9+OCDe/bsGT169P3335+VldW/TVFR0eHDhxsbG8eM6Tt8U19fT0TDhw/v/yy9Xr9ixQqfJ21paRlywYIgeP7mut1uzwSspKfVanU6XRiTojk9g3V2+G8jp2c4fE1fi4Lel9jnFLrkE/ZLHOcYYyl1iauqqkRRNBgMiZichnaBGGOe5OT5Q43klOKS6t46WZYfffTRPXv2nHPOOY8++qjP2EREo0ePJqL9+/f3Oe5wOI4ePUpE/RMVxDP3qMAz9N2jhz6LHwA8sKwlACVZcvrb3/62Y8eOSZMm/eIXv/AzV2nWrFlEtGHDBs+sJq/169crijJy5MjiYmwIn0hc02dwv1PTlOGlShkW6AIICTITgEfyJKe9e/e+9957JpPprrvu8n9b7MSJE88888zOzs4nn3zSO0BWWVn5/PPPE5F3/QJIFNyc5liwhIunDT17pz6pmVn2BUuiXxVA0kBXE0Bv8T7PqaWl5dFHH/X+Z2trKxE999xzr776qufIt7/97XPPPZeIXn/9dSJijK1cudLnS91www1nn32259933nnnvffeu2nTpp07d5aVlVmt1uPHjxPR4sWLp0+fHskvCCJCLh9lX7ZCt+5dsbHec4QREWPucRMcl1xGBh9rdwFAQAhMAP3Fe3Jyu92HDx/uc9CzCLhHZ2en5x/d3d1EZLFY+rfv3cAjPz//6aefXrNmzdatWw8fPqzT6aZMmXLVVVchNiUupbDYdtN3xcZ6oe4EczlVU5pSWs7T0mNdF0BCQmYCGAjDcqihC+XeOpPJ5FlNzmKxpM69denp6R0dHSly45X3Elut1lS48YpS7xIbjUbP9gPJcYmDyUyee+tsNlvC3VtXXl4+hGf1ucQ5OTnhrgsSSbz3OQEAQHSgnwkgGEhOAACpDpkJIHjJc28dAAAMAWITwKCgzwkAIEUhMwEMAZITAEDKQWYCGDIkp5RQ6XD+rbX9C6u9TVHSBeE8k/E72RnnGA2xrgsAog2ZCSBESE5JjhM92dz6eGOL99bhDkU53tG5uqPzluzMhwvzJMZiWR8ARAsyE0BYIDkluWeaWx9r9LHcFCf6e1sHEf22KD/qRQFAVCEzAYQR7q1LZsdc7sebW/00+Edbx1e2hF+4DwAGgi3nAMIOySmZvdTe6VL9rRHPiZ5v74xaPQAQTchMAJGA0bpktsVqC9hmsyVwGwBILMhMAJGD5JTMOoLYUqpDVaJQCQBEBzITQKQhOSWzHFE8ELgNfgYAkgEyE0B04F0zmc0yGb8INGA3y2yMTjEAECHITADRhBniyezG7Ayj4O8Si4x9NzszavUAQHjh1jmA6ENySmb5kvTYacs19b3P7p68nLF6XTRLAoCwQGYCiBWM1iW5ZZnpRPSLukabqhKdWi5cK7Bf5Obcnpsdu9IAYCgQmABiC8kp+S3LTL/EbHyxrfNzq61ZlrNE8TyT8casjFKtJtalAcAgIDMBxAMkp5SQL0l35Q27i4ad/G9F0ezdLR2oFNpbiUjNzpHHnukeP5H8TooCgBhCbAKIE0hOKUdoazW8/orQdmozO6GzQ6o6rPlqs2PRUjUDE8YB4gsyE0BcQR9DamGWbuMrL/SOTV5ic5PxlReYzRr9qgDAJ0wDB4hDSE6pRffJB8zSPdCjrLND99lH0awHAHxCZgKIW0hOKYRZLZqDlf7baCr3MIc9OvUAQH/ITABxDvOcUohUW0O875JOfSmKWHdCHjk6KhUBwCkITAAJAckpldgD7MRyki24ZgAQJshMAAkEySmVGILbos5o6nOAOZ1ch6XGAcIPmQkg4SA5pRC5ZAQxFmDAThSVohLPP6WD+7W7tgknjjNF4aKkDC91TztXLh8VjVoBkh0yE0CCQnJKIdxoco89U1O5x08b9/iJXK9niqJ79w3N/r3e40yRpWNHpGNH3BOnOC69CmtmAoQCsQkgcSE5pRbn7EulE9Ws+7SFCXjPhnZqRqbzonlEpP/wHalXbOpN880urtE458yPeK0AyQiZCSDRoecgtXCT2bZ0hZqT1/ugJzYpeQX2pSu4wSDWVEt7dvt5Ee3Or8TG+kiWCZCEsNwAQHJAn1PKUTOzrTd9V1P5jXRgn9DWRozU7Bz32PHy2AmeMTjN1zsCvATnmq93KvMKo1EuQOJDYAJIJkhOKUkU3ROmuCdM8f1gfW3AFxCCaAPBaJGVLTZ7myxnSuK5RkO+hF/JpILMBJB88Gca+mJOZxBtHFGoJLk1yfIDDc2vd3SpPUcEoqvS0x4uzCvS4Bcz4SEzASQr/IGGvlRzmhho319uTotOMcnqmMu9sKqm1u3uffSfeFsAACAASURBVFAlequre6vNvrZ8+BidNla1QYiQmQCSW0gzxDs6OsJVB8QPpawicBus6hQCmfMVx2v7xCavRlm+6XitK+A+ORB/Dh06hNgEkPRCSk4FBQVLlix5/fXXXS5XuAqCmHNNPYf7nW3DdXrX5LOjVk/yWdPRtc/hb0j0iNO1qr0zavVA6CorKysrA2ynDQDJIaTk5HQ6165du3jx4oKCgu9///sbN27k+KCc+HhaumPelcTYaQe9/2LMcfkCbjBEva7k8XaXJYg23QHbQDyoqqo6dOhQrKsAgOgJKTmdd955jDEiam9v/9///d8LL7xw5MiR999///79+8NUHsSGPGGy46rFveORJ0Zxo8m+6NvymHGxKiw5HA2ij/awE/248Q7rMwGkppBmiG/evLmmpua1115bvXr1li1bOOfHjh37zW9+85vf/Obss89evnz5smXL8vPzw1UrRJN77JlyWYW0f49YUy047KrBpIwolcdN4BrMXA4VC9yEWFCtIGaQmQBSFgvX+NqJEyc8EWrz5s3e1xRFce7cucuXL1+0aJHJZArLieJQS0vLkJ9rMpkMBgMRWSwWhyMlbvXXarXp6ekdHR2yLMe6lmjwXmKr1Wq324loxfG6dwMNxs1OM71aWhKN+iIguS9x/8yk1Wq1Wi0ROZ1O9wAT/5OMKIoGg8Fms6mqGrh1PCkvLx/Cs4xGo9FopJ7f4pycnHDXBYkkbLuvlJSU3HnnnV988UVNTc3TTz89c+ZMxpiiKB988MGNN96Yn59/4403fvDBB4qihOuMAAnq6nRzEG2w7kPcwfAcAFAk9q0rLi7+yU9+8vnnnx87dux3v/vd5MmTichqtb700kuXX375iBEj7r333pqamrCfFyBRLMxIm2zQ+2kwTq/7dmZ61OqBgJCZAMArgjv+jhgxYtmyZd/5zndGjhzpPVhXV/fb3/525MiRt956a0NDQ+TODhC3RMaeH15UqtX4fLREq3lhRLGGYZ5TXEBmAoA+IpKcmpqannnmmZkzZ5aWlv70pz89evSo5/g555yzfPlyo9Eoy/I//vGPSZMmbdiwIRIFAMS5Eq3mw5Gly7MyeickibGlWRkfjiwtGyBUQTQhMwGAT+HcfcXpdL711lv/+te/Pvjgg94zQ4uLi5cvX75ixYpx48YR0bPPPvvUU0899thjzc3N8+fP/+qrrzzHAVJKtiQ+VVzwYEHuV3ZHs1seJknTDPosSYx1XYD75gDAn/Akp02bNr3wwguvvPJK7/1YDAbDwoULV6xYMW/ePEE41bmVmZn50EMPXX755ZdcconNZrv//vvXrFkTljIAEk6GKM4xJ+1tpwkHmQkAAgopOR07duzFF1984YUXDh8+3Pv4rFmzVqxYcd1116WnDzjL9fzzz7/vvvt+9atfrV+/PpQakhsn+truOOh0ceIjtdqpBoOA2S8AEYDMBABBCik5jRw5svdyUGVlZTfeeOOKFSsqKgJvGUtE8+fP/9WvftXW1hZKDUnsnc7ulY3NVa5Ty8MUazT35g+7LjMjhlUBJBlkJgAYlJCSkyc2mc3ma6+9dsWKFRdddBEbzA1BnuUBMzMzQ6khWT3R3PpYY98FNmvd7h+faPjG7ny4MC8mVQEkE2QmABiCkJLTnDlzVqxYsWTJEs/iqn7U1dXt27evoKBgwoQJ3oPjx4/HDsE+vddl+V2/2OT1l9b2Mw36pVjvB2CokJkAYMhCWpXg448/vummm3rP/h7I7t27582bd8stt4RyutTxcGOz/0T5m8ZmGaETYPCw1gAAhCicqxL44emU6jORHHyqdLoOOV1ERHzAvWEb3PKXNvsMU4CuPgDwQmACgLAYdHJSVbXPFo+KovjZ15NzXl9f/8c//pGIbDbbEEpMNUc8sYkGjE0eh50uJCeAYCAzAUAYDTo5rVy58qGHHup9xGwOvH2px5gxYwZ7OgCAIUNmAoCwG3Ryys3N1Wq1LpcrcNPTCYKwcuXKwT4rBVV4d94YeLSOiEbptNGpByARITMBQIQMOjn9+Mc/vvXWW7dv375p06a7776biBYtWuR/krjRaCwtLb3++uuxy0owxul1o3XaQ06Xn9hUoJGmGw1RLAogYSAzAUBEDWWGuE6nmzFjxowZMzzJadWqVXq9PtyFpbQH8nNvOl7r5965+/JzpcEsnZWIhLYWoauTa7TqsByuR0yEwJCZACAKQrq37p577iEiSYrSDXqp4/J08z35Of1XwvT4wbCsZF7MiXPN3t3aTRuEzp49EAXBPeoM14Vz1KzsmFYG8QuZCQCiJqTQ89hjj4WrDujjZ7nDztBqU273Fc4N770p7f36tIOqqjlYKVVX2Rdep4woi01hEMcQmwAgmtBdFL+uyki7MiPta7vjgNPJOVXokn/HX93mDX1jUw/mdBjeXG1d8T2enrzBEQYJmQkAom8QyWnu3LlENHv27Pvuu6/3kUH56KOPBvuUVMaIJhv0kw0pMY2MWS2arV/4a+Cw6zZtcFy+IGolQdxCZgKAWBlEcvr444+JKCcnp88RgLCQDu1nAy+perLNwUqadwWJYnRKgjiEzAQAsTWI5GQymYio9210niMAYSG0Ngdsw5wOwdKtZmRGoR6IN8hMABAPBpGcLBZLwCMAQ8bU4PYwVpQIFwLxJYECU1NTk6IovTvmASD5hDRD3GazebbyBQidmpkVsA0XRZ4egxUZxJYmofYEc9pVo1kZUYZZ6tGRQJmpvr4+1iUAQJSElJzy8/MXLlx4ww03zJ07F6s6QYjkUWN0n31E3F/Pk1JWwSWNnwZhJzY36T58R6w7ceoQY+4zxjvnXM6NGK2OlATKTC0tLZIkiZh7B5Ay/O2aEpDFYnnppZfmz59fXFx8xx13bNmyJVxlQQpSs4bJ4yf5ayEIrpkXRascIiKx5pjh5X+cFpuIiHPN/r2ml/7BujqjWUyKqKqqSpTY1NLS0tLie7laAEhiISUn7z50TU1Nzz777Pnnnz9q1KgHHnjgwIED4agNEpKD83Xd1j+3tP+ppe0/Xd1WVR3Ec+fNVwqKfD/GmGPO5Up+YXiqDIbdZnhzNXO7fT7IOjuMb6/x30MGg5IomamlR6wLAYDYCCk57du3b8+ePb/+9a/Hjx/vOXLkyJGHH3547Nix06ZNe+qppzD2n2qeb+uYvP/I9dUnHmhoerCh+TvH6yYeOPJsc1uQk7+5RmtfusJ91jl91h1QM7Psi5e6p0yLSNED0H61hdntfhoIdSekIwejVk8SS6zMFOsqACDGGA/Th+bKysrVq1evXr16z5493oOCIMyePfuGG25YsmRJeiwm9kZHKH9MTSaTwWAgIovF4nA4wldUDPyyrvHvbR0+H1qckf6X4YWe9c+1Wm16enpHR4c88OpNzGYVjx0ROzq4Tqfk5islI0gIKeUPgemffxZaAiyU4J4w2TH/mgCv03OJrVar3W8USxrBXGKPhAhMFOh33DvPSZblFLm3ThRFg8Fgs9nUwXQqx4Py8vIhPMtoNHpuh/L8FqfCJQY/wpacvA4cOOCJUF9/fWobDb1ef9VVV91www0LFy4M7+niQVImJ060y+7YarO3ynK+RjPTZByn0/ppv7qj60cn/HUxrizI+2FOFg3mbTWWODc/9SgLtAKCUjzcdv3N/tsgOfmUHJnJA8kpgSA5QejCn5y8Dh48uHr16rVr1+7YscN7MHKni6HkS057HM6f1TXssJ1Wz4Vm4xNFBWVaH7e2caJpB44eH2BKkEemKO4ZW6FjLDGSE5H5qd8y2d9XRETK8FLb0hX+2yA59ZEQmWlQv9RITgkEyQlCF8ERkDFjxtx3333btm176623vBOhIP5tttqvPHq8T2wiog0W22VHqysdzv5P2eNw+o9NRNShKJusiZQb1JzcINrkRaGSpJEQ85kwmQkA/IvUIkwWi+W999574403Pvjgg9bW1gidBcKuU1H+q6bWNsDnyDZZubmmbkNFmVZgvY9XuwLEJo+jTudsc8IsnSqPPVNsqPPfxj32zOgUk+jiPzBRaJ3HAJA6wpyc2tra3n777bVr13744Ye9x55KSkquu+66pUuXhvd0EHbPtXW2yP4m9xxxul7r7Lo+67RFtINcBFDDWOBGccN91jmaXduFjraBGsijxyolI6JZUiJCZgKAJBOe5FRfX//GG2+sXbt2/fr1vWc25OXlXXvttUuXLp01axZLqHfNlPVeV3fANu93W/okp7F6XTAvPq7XdtHxj0uSfclS46svse6u/o+qRSUB76pLcUeOHInzSTAITAAwBCElp6qqqrVr165du3bz5s29p35nZmYuWrRo6dKlc+bMwaYEiSWYcbdj/dqUazVnGfQ77f5muI/QaM42JFJyIiI1O8d603d1Gz6W9u1hysmPBFxvcE2d7j5vJhex45BvR44c0cd3SkZmAoAhC+lP/8iRI3v/p8lkWrBgwdKlS+fPn6/V+ruDHeKWVmAU4E5834NuDxbkLj52Qhng3klG9FBBrpCA3Y7caHJcfjWbc7nQWM9sdtWcpuYXED4PDMAzNhfPu1giMwFAiMLwB06n011++eXLli1bsGCB575NSFzj9LoGd4DFAjJE4bHGli5VKZCk2WnmiXodEc0wGX9flP/zuka5X3hiRPfm51yVkRapoiOPa7RKSWmsq4hr8T+fCZkJAMIipOR02WWXLV26dNGiRRkZGYFbQyJYnJ72abfVf5uNFttGi83z74cbWy42m54uzi/WaG7Myhij065saP7Sdmr1gUkG/f35uQl0Sx0MCgITAKSakJLT+++/H646IEjrLdb/dFkOOl1ENEanXZBuvtBsCuPrfysz/bm2jgFnLHGifiNu6y3Wy44cf6+idLhGOtdo+M/IEXVu+aDTqRKN1umGa+J34AZCgcwEAKkJ72oJo1VRvl9T/5nlVIfQJqvt+baO2Wmmv5QUZvuceaMo0oF9UtVhobOD63RKXoF85iQ129/qtyJj/xpR/K3qEwd8rXjZPzZ5NMryd2vq3hs5wvN4kUYqQmBKXshMAJDKBvH2NnfuXCKaPXv2fffd1/vIoHz00UeDfQoQUbeiXlNV4zPNfNptXXj0+LsVpebT98QVmxr0b70mtJ9ajkg6elj35SbX2ec6L5zjZwPdQo30XvmIp1paX2zr7OjZuE0vMIfqb+ec7Tb7pxbrJWHtAIM4ccjpeq+r+7DTVdzclC9Jkwz6LDHaGzAHCZkJACJtEMnp448/JqLe+/V4jkAUPNLU4rsTiIiIKp2uRxubHy3M9x4RW5oM/36euVx9m6qqdttmZrf5X4soTRQeyM+9Ny9nv9PVKst5knRNVY0j0E13H3YjOSUbm6reU9f4akfXzM52IjpBRETvdHXPMhmvTDdLcbNIGwITAETNIJKTyWQiot7LtHiOQKR1KepL7R3+27zQ1nlvfu7JbifOde+87iM29dDs2S1XjJHHjPP/mhJjE/Q6Ip1VVduVQGsVEFUPfEZIRE7Orz12Ql9fN/P04yrRBqutWZb/KztTiHV4QmYCgCgbRHKyWCwBj0AkbLHZXH5HyojIyflWm32O2URE4rGjYnPjgE05ESPdV1sCJicvLWOMKEAFRPpYv4lCGFVVVb3d1a3vuYmyv0qna4PVdnHsehmRmQAgJqI0jbeurm7fvn0FBQUTJkyIzhmTSZPfjeS8GnvWYZKO+53Ay4iIhLoTzO3imqAWLNUwdoZet3/g4UKPCYm2RDj45JkA7lD55wPHJo9Puq0XmoxR7nZCYAKA2AopOXm2orPb7QF3Wti9e/cVV1wxffr0rVu3hnLG+GQwGIb8XO9qyxqNZqCt/XIdQY2C5Rr0nkpEhz1gY+LcoMg8PdiFuJblZP/6RL2fBhJj1+fnGXSBo5hnQx6dTqfRaII8e0LrfYljW0lAhw4dop46K232ACuiElk5r+dUpu37dQmC4Hmd8O5b19TURD0/P3FF6LnfwvuFx7ScaIjQJY6Cof257v1bzAfYKQFSR5T6nDxrix8+fDg6p4uysMz30ul0Op3vfXMvkjTscJX/X1aB6OK8XJNWS0RyWlownVSGrGEs6MrvKi9b1dZxwHZ6Juu1vNOdJUUTs7OCfDUKLW7ytlbe3cX0epab7+cmwXij1WrjdleiyspKIur9E2jxuwuhVzdjA/3chjFA1NfXU3xv6uIhCIIgCAN9Q5JPImbEEP9ca7Xa+P85hEgb9E+Aqqp9PmQoiiLLA3465ZzX19f/8Y9/JCKbLUDnf4IKZfjAZDJ5MoTFYnE4fL9X6YnmppnWeZb29rUWJRFdlm7WdHV56tBkDQs4bKZmDWu128keRO9UjxdLCq87VnPadr89lSzJTP9ZuinI74NWq01PT+/o6PDzY+Obqmp2b9du2yx09syXNxhdE6e4zpvFdfE7UOi9xFar1T6Yb3gU+FmZiQc33587nZZ+P5CSJOn1epvNFmKHRKIMzEmS5OkJk2VZUZRUmAAqiqLBYAj9Ekff0H6ojEaj5/O/57e49z3mkIIGnZxWrlz50EMP9T5iNpuDfO6YMWMGezrw+E1h/jZbdYeinAwrng6onnesbEl8uCDP21geNZabzMzq78+3e/LUwdZQrtV8VFH6VHPbv9s723putRun096eO+zazHQ/U13ExnrNN7uEhjrmdHBzOh81mi68ZLBnZ7Ksf+NVqer0bku7TfvlJunQAft1y9WgRx6BgljNsiSI7gRGVByZXodEyUwAkIIGnZxyc3O1Wq1r8PefC4KwcuXKwT4LPMq1mldKS246Xtvo6afplVMKNdILI4pLe8014RqNc+58/Vuv0QDj8UpBkXvq9CGUkSGKDxbk/io/p8rltqpqgUbK999xrSj69es0O7edqqStlY5XOTd/Ll61SC6rCP7UunX/6Rubegjtrfo1/7bd9F2KvxkwcSjIFcCLNFKRJNX57Rc8Q6dND/eSmMhMABDn2BAmuzmdzu3bt2/atOnuu+8mokWLFgl+55oYjcbS0tLrr79+3Lhgb4NPLJEerfPqUtS/tra/1dV91OUiogqt9pqMtO9lZ6X5evfSfLNTv+5d6rcOk1o83LbwOm6Mxs3k+vfe1OzZ7fsxQbAvWRZkeBIb6owv/WOgIOjhmHP50OJgpMXPaN1gd02pcrn/3NI20Jw5HWN35GQX+NpmZ2ijdYmbmfqM1qXCUE7ijtaVl5cP4VkYrYPehpKcTj056HvrklvUktNgCe1t2m2bpKOHmaWbi6KaX+ieOMV95uTozKqWjh4yrPm3nwbcnGb97m1cCjzco/vkA+32AHdlqkXF1htuGVyJURHz5BTKNnO77Y5V7Z39+530jK3IzhgzwFToQSWnxA1MXkhOCQTJCUIX0j0C99xzDyXCDS8pS83Kdlx6FRER5xT1ZSoDZh1m6Rb375MnTA74UmJLU8A2rClwm1QT+ta8kw36Qo20rtu61+F0ck5EBsYmGfTzzKYsKdSx0STITACQgkIKPY899pjnHy6Xa/PmzRdddFGfBlVVVXv37p03b17q3KYbp6K/ujfnYk11wFZSzbFgkhMFcRceU5WYBMQ4FHpg6i1Pkm7IypA5t6gqI5YmsNCXvkRmAoDEFYZRm+eee660tHTOnDn9B/727t27YMGCoqKiv/71r6GfCBIIczr6T7Hy0cxqDebVeGbglaLU9AzEpqqqqvDGJi+JsUxRzBCFUGJTS48wFgYAEGWhJqcHHnjglltuaWhoUBSlvb3dZ5u2trYf/OAHDz74YIjnggTCtbqgZlMZjcG8mlwReD0LedQZwbxUsopcZgoLBCYASBohJaetW7c+8sgjRJSZmXnHHXf0Xx/53HPPfeSRRwoLC4lo5cqV27dvD+V04IOqiseOaDd+ov/wHd2GT6SqwxQnEzYFQSkqoUD7BMslI4J5MffosUpunp8GXKN1TTt/EOUli6oesS7EN3QyAUDyCWme0zPPPMM5Lyws3Lx5c2lpaf8Gubm5991338033zxt2rT6+vpnn332+eefD+WM0JvYUKd//y2hudfM6K2kZg1zzL9aKR4eu7pOck+dLp447mdohxsM8hnjg3otQXBc8y3jy/9kdl/L0Iui46pFPC1taHUmqLhNSx719fVDWPUNACD+hdTntHHjRiL65S9/6TM2eRUVFd11111E9Omnn4ZyOuhNPHHc8O/nT8Wmnr4dob3V+MoLUtWRWBXm5R4zTh4zdsCHGXPOuzL4XVPUrGG2m76rlPa9o1jNzrFdtzx1hurivJOJiFpaWpqbm2NdBQBApITU59TY2EhEU6ZMCdjyrLPOIqKGhoZQTgdezO0yvPUa633HWe++HUXRv7PWcuuPyRDULKJIYcxx5WKd8KZm/96+D2k0rssWuIPscOqhpmfYrrtRbGoUq48yq4V0erm4RCkpTaBNf0MRz2mJcLscAKSMkJKTyWRyuVzBrKXp6bcPfoc78E/z9U7/29Ixh1238yvnjAujVpJPXJIcC5a4J07RfL1TrK8V3G7FbKZRZxhmz7PzoNYa6E/Jy1fy8sNeatyK88BEyEwAkGJCSk4jR47cvn37xo0bL7wwwDv0W2+9RUT+B/UgeNLRQwHbiEcPUayTk4dSVqH02mVFq9Wy9HTq6IhhSfEPgQkAID6FNMyxZMkSInr88cf93zT38ssv/+UvfyGiq6++OpTTgRfr7AzYRuhENElIcT6NibDEAACktpD6nL7//e//6U9/qq2tPf/885cuXXrFFVeMGjUqKytLkqSOjo7W1tZ9+/atXr16w4YNRDRs2LDbbrstTGWnOu5rm9V+bQLvBwfxI87TkgcCEwBASMkpOzv73//+9/z5861W64svvvjiiy8O1NJsNr/yyivYJTFc1LwCsakxQJv8wugUA6FAYAKIjm5VbZMVh8NZrtPqU36/AQhFqJv1XnDBBV9++eVPfvKTjz76yGcDxthll1325JNPjhs3LsRzgZf7zMmaPbsDtZkUnWJgCBIiMBEyEySFPQ7Hum7rCbdMRBvd3CgICzPS7snLKQqi8x6gvzD83IwfP37dunVHjhxZt27dvn37GhsbHQ6H0WgsKCiYMGHCpZdeOnx47FdljH+HDx8uKSkJsrEyosx9xnjNgX0DNZDLK4LZsQSiDIEJIJo40Zud3Rutp62ga1PVVe2d73dZXi4tnmY0xKo2SFxhS9wVFRUVFRWB28HAPG+r5eV9F3v0yTn/GsHlFH2teKmUjHBctSSht7/lRLvsju02u13lBRrpIrMxT0rgT4eVlZVE5HQ6Y11IYMhMkEw2WGx9YpNXm6Isr679bHRZfiL/bYGYwE9M3KmqqgomPHGNxrZ4mebrHdrtXwptJ9/t1Mxs99RzXFOmkShGuMwI2mqz/7yucZ/jVM4QGft2ZvrDBXnpYiIteumJwjqdThP3s/URmCD5WFX1g25/6961Ksp/N7X+viiF1oeDsEByikfBdj4JgnvKNPeUacxmFaxW1WjkpoRfa/SdLsv3aurcpy+vqnC+qr3zK5v97fIR2VK8h8JEGZLzQGaCZLXP4XIGWqj5jc7uRwvzNIncQw/RF1JyKisrC76xy+Wy2+3t7e2hnDGlBD94x40mxWiKfEURV+1y/+hE39jkddDpur224eXS4ihXFYzESkuEwAQpoM7tDtimQ1Hq3HKpNt57hSGuhJScqqurw1UHDGRQk58S3ZPNrXbV32fED7stX9ns8TOpM+ECEyEzQcqQe30GczPmEEQNV/s3c6g+DgL4EVJymjx5sp9Hu7q6jh8/riiKJElXXHGF2WxOS0sL5XQpos8bm2cRrFTIT5zoPb+TEjze7bYMLTm1KopFUXMl0RjaDsGJmJYIgQlSg4vzZk61nNeqfKukrTSKDkFwCILMGBGNcDr6tJcYK0aHEwxSSMlp165d/htYrdY1a9bce++9NTU1q1evxs13Q9D7Da+lpSUnJydZ81OnorTLSsBmVa7APfC9OTj/35a2F9s7j7ncRCQQTTMabsvJnp8+iDlhCZqWPJCZIPm4OTVwXsd5Pac6lddxXsepVlXbe/dZM4E0p31McvT71DTTZDSH9lEKUlBkZ4ibTKabbrppzpw506ZNmzNnzrZt23JzcyN6xqTn3TLMuyB70gQpKbhJmoOaH97glpdVn9jT6zY9lehLm/2m47U3ZmX8d1GBMPA5EzotEQITJAVO1MypjvM6lXt6kuo5r1OpmfsaeAukT3ISiO7KGxauUiF1ROPeuuLi4l/84hd33nnnM8888/DDD0fhjKnAm5/6v8EnaJYyC0KxRlMbaFLnWJ0uyBd0c778eG3v2NTbi+2dwyTxvvxTUT7Ro5IHAhMkqG6iWpU3c96i8lpOtSqv5byakz3Q/XHBc7DTPnndl59zXtxMmoQEEqVVCWbNmkVEb731FpJTePXpf/LwmQASIk4tykj7Y0sbEREn8tUbJDJ2TUaws+VebOvYbe87raG3XYePfNXVOSzulzkIEjITJAQ75/WcajmvU6mO87qeniRr2ALSgFw9ncy5kvhQQd63MtMjfkpIRlFKTqIoUrJ8po9DPvNTHwkRp27PzX61o6tJln3GJiK6KStjtE4b5Kv9X0dXnyMXdJ62KIZCtN3uuDQtsRd0QGCC+OSdilSr8jpO9ZzXcV6nUnv4+pCCxIiyGaVzbub8wtycaQb93HQzNv2FIYtSctq9ezcRKUrg+b8wZMHkpz4GyrKxSlTZovhSafHSYyfaTv6onNb1NMdseqQwL8iXOnq0KqOh8YJAzU4EseJLfEJggjjBiVo41apq3aluJKrjvEkdylSkEKUzKmKsWGBFjBUJrIhREWOFjLQ9Oam8AHNtIVTRSE67du369a9/TUS4ty4KvG+og4pQfQTsHYxctDrLoP+oovThxuZ3uizuno+meZJ0e272d7MzxdM/JvqpUyEeTE53Rf3jb+iQmSBWOvnJ8bV6z+JlhQAAIABJREFUmTe5rcfdcq2q1vMY/B7piIoEVsxYEaMiQSgSqIixIsbM6EiCyAspOS1cuNB/A5vNduzYsUOHDnn+c/HixaGcDgZlCF1QwQtl4FWSJL1eb7PZ1IEXoPsl0Z16sd6t2LiaJYpFksC6Oo53dQziLIyZBWbxu64mEWUmzg3JCEwQNfaefiPPQJvn1rY6lfveOzeSJKICTwcSo0JBKGLk6UkahrE2iJ2QktObb74ZfOOpU6feddddoZwOhiCi+SmiDIIwUhdSrBmn023zO0OciMYb9KGcIgoQmCByZKJ6NdCqSFHBiHJ6ElLvgbZ8gSXMhxtIGZEdrWOMZWRkjB07dvHixbfffrteH+/vUskqcfNTKGanmXbYHcoAt+kRUYEkTQh6vnmUITBBGKmcWilepiKlERWLwsmEdLIPiRUJLE5/FQH6CSk5uQPNrhVFkaFPNQgK51stts3d3TVud5nNamBCgUY6Q6cN7+K2qZaf8iVpYUba2s5uTtR/nQMDY8uzMoQ4+/lEYIIQdZ4aZeN1nOpUtY5TQyymIulPZqNTU5EKGStilBZnv3QAgxVScpKkKN2al9ya3e7Fe/az1jbvETtXq1yuYy7XVIO+XBvmT2JhmUKeKGaYjEZBeL2zy3L6J+vhGmlZVkZ+3PwAIzDBYDk8CSkWqyL1IRHl9wyuFTFWJFCxIBQxlo2ABEkqXt45UpZL5Vd/U7mlq7v//fOc03a7Q2JsuCYiG1KmSBfUFIN+nF631+6sdrnsnGeI4hiddpROGw9/1RGYICA3p0bu7UCK5VQkIsrxBCPGigWh3KAf5nYVEuUzwlQkGIKLL774s88+y8jI6OgYxN0/8QDJKcb+1tS8pavb92OMiGinzVGYoYncdUqFLigdY1ON+qnGGE+zs6m80u7oUlVDZ+cwScQ+o9Bbr1WRqGesbegbtIXIuyqSZ3ytkDHPzCRvB7goiga91qbKfu6QBUhWg3hHzszMDOVMbrfb4XBgMcw+nmtuJSKiAT8/uojXutyl2oh0O/U2UBcUk2XxRLXQ2MDsdhKYak5XC4uUgiIKcrIC56yzk9ksxIhMZjUtI+yVxz+Hqq5pbm1oqO99mXNFaYpRn4H8lHq8qyLVqeRZD8lzdxtWRQJICINITp2dnZGrIzV1KWqlzU5EA979RURErYpSShFPTh59uqCEjnbNru3MdereftFhF1sapZpq1+SzeaDNd4X6Ws2h/cxh9x7hBqM6bgKVjYxA7XHqeEPDJ53dnYrc53izIn/abZ1pMuYmy8Z50IfDm5A41aneWdsxmIokEuUzVix4pyIxrIoEMGSDSE4XXXRR/4OMsY6Ojl27dhGRKIrl5eXZ2dlardZms9XV1TU0NHiazZ07Nzc3NyMjFfsb/OgKrgfOHYt1rltaWpjTIVYdKXCdtiSS5xY11tGm2b7Vfe4MLg74IyQdrJSOHelzkNlt4o4vVbuNShM1PFlV9Wu7o84tuzhlisI4va6sX49g7wlMm232/rHJQya+2Wa7LM2swxtYIpOJGog1MnZCkOoFTbtTro+PVZEKGRWLQiGjfMYQzwHCZRDJaf369f0Prlu3bvny5WeeeeaDDz545ZVXGgyG3o82NTWtWbPm4Ycf3r9///333+8ze6WyHI0kMqYECkax2plSrKtlqtqoP7khbr7DSr06xwRLl3j0sDx6rM/nCvUn+scmL7Vyj6AzqHn54S04CjZYbe93WZy9LtlHFutonXZZZkaGKPSf8d0sKw1+F+9wcX7A6ZyEpc4SASdqY0IDY42C0EBCoyA0MKGBsVYmnJzs4/mDKkdj6k+6Z3wNqyIBRF1IcywqKysXLVpUUlKydevWa6+9tk9sIqK8vLwf/vCHX331Fef86quv9m7DAh56xs5PMwVsFpOb55nDzuyn7bXQqDd5/uc9Ip44Tj5jH+eaQwf8v754sNL3c+PY213db3Z2O0/f0WW03Uod7W9UHz/R1Nz/KbVB7Ch8wuW7RwpiqJvYYUH8XNS8Jmn/pNH/Smv8nt680JB+o958t8703xrDSxrdOlHzjSA2e2NTZGiJyhjNFNl1GvFOrfS4XnrJoPnEqP3IqH1BLz2mk+7QitdqxBmiUIbYlNpee+21Sy+9NC8vz2AwnHHGGXfddVd9fT0R/ehHP2KMCYLA+/3JtdlszzzzzCWXXJKbm6vVagsKCmbMmPH73/++q6ur/+tnZWUxxn74wx8SUXNz8/333z9p0qS0tDSTyTRp0qQHH3zQYrH4LOzll1+++OKLhw0bZjAYKioqfvCDHxw8eND/1zKowtLS0hhjt912GxGtWrVq0qRJRqPx1ltvDeJ7NkQhvSU/8cQTVqv117/+tcnk7+2/qKjonnvuueOOO5588sk///nPoZwx+fykIP/zLt8/bR4ZgpgfwVvrBiTYrAM91LsXSrB0q2npfZ/b2dF7bpNPzGbRfrVVzS9Qikp43Kyr5McBp2u9xUZExGi0ve83x87VbXb7BSZjn+OWIO48snFVDfFDDAyVg6iRCQ2C0MiERiY0MKGRsUZBsPqdehgJp62KJAieO9qKBMrBSC4Ewjm/+eab//Wvf3mPHDx48Iknnli1atX777/f1tZGRHq9vs/C1Dt37ly4cOHx48e9RxobGxsbGzdv3vyHP/zhtddeO++883q39+wCYrVaDx06NHfu3N5P/Oabb7755pt3331348aNul7zXznnN91000svveQ9cvTo0b/+9a8vv/zy66+/PtBC2YMtzGAwWCwWq9X67rvv3nDDDZ6DEV3pIKR3rE8++YSIzj777IAtPV/nhx9+GMrpktKVWRm3Fub/vb7R56MSselGQ2z+cAYxB6tRb5Lb2rjT1eeOPGbzlwW9hPYWob1FPHLQPXGKmpM3xDqj5Zv6+tF+vyeNstyuKFki5pPEI5mo+eRAm9hA7GRUEoSOqCckIsrFBm0QVs8884wnNhUXF//2t7+dNWuWoihvvPHGww8/fN1115WVlRGR9vRFlWtqai699NKWlhZJkv7f//t/S5YsKS0tbW5ufuONNx599NHa2torrrhi+/bt5eXl3qd41r7u7Oz81re+JcvyH/7wh5kzZ4qiuGvXrgceeKCmpmbbtm3/8z//89Of/tT7lD/96U+e2FReXv7444/PmDFDVdVt27atXLly+fLlRUVF/b+WIRSm0WiIyG63//znP9fr9QsWLCgsLKyoqAjr9/g0rH/3XfAMBoPD4aitrfX59fe2Y8eOs88+W6/X2+0BuiISUSjrGZpMJq1ef29V9dZv9nh6J7z9GSYmnGcyxOqdWGxrFRrqAjaTK0Zz3WlzdHJycsS6Gs2e3YM4GRNcZ52j5uQOtshI815ZN6e3uroC/qqM1+nH60/78/S1w3HQ6fL/rDRBuCzNPPQq448oipIkuVyuUP68DA0naiPWKAgNnqlInqjEWEuEx9R8SmOsiFGxNycJJzuTkmBMTRRFg8Fgs9kSbj2n3u+4wTMajUajkYisVqvdbo+r1e/cbndxcXFzc7PBYNi9e/fo0aO9D23btm3WrFmyLKuq2mfByWuvvXbNmjVE9MYbb1xzzTW9X/DTTz+dO3euqqrXXXfdK6+84j1eVlZWXV0tSVJhYeHWrVsLCwu9D+3cuXPq1KlEdMEFF2zYsMFzUFGUkpKShoYGo9G4d+9eT4DzsFgs06dPr6ysJKLQCystLT1+/PjIkSNbWlo2btw4adKkoXwfByOkPie9Xu9wODZv3rxkyRL/Lbdt20ZE/SdCARGJjP1uZNmHrS1burpOuOVMl8MoCAWSNFyrieFnUNVoCnh2Lkl9YhN5bspTuKQ3Uc+k8sC4qtmzy3XBbD936kXHQCHYwdVgIoC935qFJRrNgMmpZye9ksisEZ/0uog1Cp4hNuYZa/P8Z4CgGgE6ogLihZznq0quqow2mz23/adFvRJIQRs3bmxubiai5cuX945NRHTOOefcdtttTz75ZJ+nVFdXv/7660S0ePHiPumEiGbPnr1w4cK1a9euXbu2vb09Kyur96OyLP/mN7/pHZuI6Kyzzho1atThw4f37t3rPfjFF1947q9ftmxZ79hERGaz+aGHHrruuuvCUphn1O/o0aOPPfZYFGIThZicJk2atGHDhrvvvvvss8/u833pbf/+/Q8++CARjR8/PpTTJbc8jTQ/PY2IWv4/e28eH1V59v9f99lmzb4nYBJCkB0VAUFBBASqFRXUqpWW1uWnVm0flz7W9rHa8rNPW7e2+uKn9WmrdSnPT9Tq16UiOy6IQioICGEN2TPZZzvLfX//OMkwmcyWnMlsud6vvuzknHvOfYfJzPnMdV3352JJYRbKzGZmtYfPu7HcvODHLVYmikRR/MvJIayQIrKXa6jXxpYPb7XDJsp4YZTvk8HhwVyeHytJdXKwuzkBADATboIpDWIQI4gXSN92NsI1E66xP+PmjnsBkACQz2gxo0WUFjNWxGgRo8WMFvA8z/MAoGqqpmn5AqbdkPixa9cu/cHy5csHn7355psHK6fNmzfrwcLB2kVHFyiqqm7ZsmXlypX+p3ieDziiU1lZWVtb29nZyRjTpYxvYUuWLBk8/vLLL+d5PsAc28jCAOD6668P+qyYY0g53XLLLdu3bz9+/PiUKVNuvPHGxYsXV1VV5eTkSJIky3JHR0dtbe3GjRtfe+01j8cDAKtXr47RspF4oJWW8cdrSYjiHmax0ryQ+TWtsEioPx1wMEBIwUAtxbW3jahyMpJUtXCciRBvpNxT0NTqHLvN3c3aVMUXZPIhEXKhzSJiCTAA9Jci+fJrzYRvIqSJkM5E1P/kMlbEtGLGiigtZrQYWBGl+YxiFRuSbBw7dkx/MGHChMFnJ0+enJeX53A4/A/u3btXf2C1Wk+cODH4Wb6WIQcOHAgQKOXl5UH3hOk5JUqppml6RZRvA13QkiOr1VpRUXH06ADzGiMLs1qt5eVx+u5tSDmtXr36gw8+ePXVV10u1wsvvPDCCy+EGbx8+fJbb73VyHRInGGSpJWP40+fJINCJtRup2VnsdC3fJaVQz1ezhFko74//lqKKao6SNxEX08w0t1zKyTxm7AVSxKQ0mB5N4GQJbnZ+3udh1xutb/NDgEoFcTpFpNt9HVf8XdFaiZcEySyFMnGWDGjRYwV+4JJwIqohmFAJFXQt84BQF5e8CRARUVFgHLy/bhixYrwF/fZWfvIyAiehR68Ua6jo0N/EJDv85GXlxegnIwsrKAgfpWyRstKXn755blz565du7a5OfjuMADIzMy89957H3roIW703SRSHWY2a1UTSGcH6ekmigxAmNlMs7KZPXIJh1ZUTM1mvqWJROFpBAAsWMBmpPVQ9JxtMtXJqit099VpFrMYQknyADPstklmU4tX9jAqAskVeGkUhJp6gPjsIptIn3VkC+Gi+oOIKRJjxcD8Em1aEWNFjNpTzVQMQQLQUzoAYArRDstuD9yA4nRGV4EK0NMToiF9FPg2hAVs6/Mx+LiRhRlsrTskjCon3X7qjjvu+Pjjj3ft2nX48OGOjg63220ymbKysqqqqmbOnLlo0aJQryiS/DBCWE4u5OQO57lZ2WpWNnG7+YbTxOuJMNoS2RQ0gUiEXGSz7nS6goqnKSZzZaSuzBxAgcAHq4ZKeQJKkZo5vpnjmsxS/F2ReICCgYk2vRQpBxUSkqb49IcS4juqy+UKOOLTUvv27Zs6deoILcx335eDFnombmHGic1WJp7nFyxYsGDBgphcDUkzmMWiFRYJdSfDjSGExvEbw/DI5LlLM2zfeOUTsuJhFAAIQJEgTDSb8keHjZPPFaklWUqR+oRRMaXFwAqpVsDYqHglEKQfX/qss7OzqChIS6vTpwNLTgsL+/zz6uvrR06g+DrV+tJ2ATQ0BBrfxGdhxkkB72YkDWAZmTQzi+vuCjmgqIQJKbA5XyRkqtk01WzyMEYZmLj0bKTq74qkO2sHNmiLI3bG9NqjYsaKaF+WrRiYhGEkBAHwlUUfP3787LPPDjh77NgxvQeLP+eee67+4PDhw8uWLRuhhfkKw2tra2fNmhVwtqWlZXCtUnwWZpyYKae9e/fu3Lnz66+/bm9vd7lcdrs9Ly9vxowZixYtGj9+fKxmQVIXWjYGAIKKJ1pYrIUwOEhazIQkwn069viXIiXWFUkC0Mu0C+mZYu1iRm2okBAkNDNmzNAfbN68ebAxQdCdW4sXL9YdAV555ZW777578IA9e/bs3LnzsssuM3L79vUX+eijj2644YaAs7rdZUIWZhxDHuI627dvv+eee/797+Ce0YSQJUuWPPPMM0E3TKYHBj3E9c2cNTU1epY6eWqiRwLS2813dBC3C1SViSKz2Wle/mA7zXRCEIQ+sx9V1aLoaTNC+EqR+q0j+aYENWjjAfL9drEVM6aXbOemrEIKeImTymB6hEAP8Viva/h0dXUVFRV5vd68vLyDBw/6bzHbu3fvvHnzNE1TFCWUVfe6detuv/32gAsuWrRoz549ubm5p06d8nkQ6B7iM2bMqKmpGbyMq6666p///CcAKIqiuxJ4vd7CwsLu7m6LxVJTU+OvAZqams4///z6+noI7SEeq4WNBEZjTv/4xz+++93vhnnzMMY2btx47rnnbty4cd68eQanQ1IdZs9kWTl8glpzjAYCSpH0RFuiGrQNdkXCUiQEiS1ZWVm33nrrM88843A4Fi1a9Nvf/vb888/3er1vvfXWww8/PHXq1IyMjC1btgQ86+mnn968eXNHR8edd965d+/e733ve2PHjm1vb9+1a9cTTzxx5MgRAHjkkUeCWjdFiclkuvfeex955BG3233xxRc/8sgjs2fPVlV1165dv/3tb/WoykcffRT/hRnHUMypvr6+urra7XZzHLdixYrLLrtsypQpeXl5en+61tbWffv2vfXWWxs3bgSAgoKCo0ePhrKCSGkw5jQkEtjULCGMXMzJ0Z9oa+YS7IrUV4rUt+eflgCMEfhcr0cclS9xUgUkRgiMOcV6XYbo7e295JJLvvjii4Dj1dXVH3300Q9/+MNNmzYFhHYAoKam5oorrhhcPw4APM///Oc/f/TRR/0PDjXmpD++4oor/vWvfwUMzsjIePvtt59//vnXXnvNarUGmBHEdmEjgaGY05/+9Ce3252dnf3+++9fcMEFAWcnTpw4f/78O++884MPPli1alVra+u6det++tOfGpkRQUYh3UBa+jb89zUeSWApkl6jXQysmGqhSpF4nhcYkQFGhW5CkERjt9t37tz55JNPrl+//ujRo4qiVFVVrV69+q677vLt8x/sVHnOOeccPnz4+eef/+c//7l///6Ojg6z2VxRUbFw4cLbb799ypQpxhcmiuJ77733/PPPv/TSSwcPHvR4PCUlJUuWLLnvvvvOPvtsvWuvz48qngsziKGY08yZM/fs2fOHP/zhnnvuCT/y17/+9cMPP7xgwYJt27YNe7qkBWNOQwJjTqGQCWmEAQ3a9IybKylckYZQijTKX+JkC0iMBBhzivW6RpC5c+d+9tlnY8aMqaurS/Ra0gRDMSe9rUzQLoMBXHXVVQ8//PDBgweNTIcg6YEK0NbXfiRJXJGwFAlB0hb9Tu2zSkKMY0g5dXd3A0BubmR36eLiYgAISLIiSHqjN2hrJVwL4ZqANAp8Iw/NHNdGuPhvsbPpNkiMFTGtRNdJ2KANQVIfxth///d/79+/HwBeeeWVgLP79+/XbZN8HgGIcQwpp6ysLIfD0dzcHDF0qWegMjMzjUyHIElLgCtSU78r0oBuCHHJuflckfQGbYVU030jsUEbgqQlhJB33333448/BoDvf//7S5cu9Z2ilP7sZz/TH1977bWJWV86Ykg5VVdXOxyOt956K2LF1ptvvgkAaWzphIwSZEKawNe8NsGuSEZKkRAESRsefvjh5cuXM8ZWrlx5//33L1++PDc3t7a29umnn9b3ti9cuHDJkiWJXmb6YEg5fetb3/rss88ee+yx884771vf+laoYW+//fbatWsB4PLLLzcyHYLEDX9XpGZC9JLtJsJ1DNqfEgdyGNOFUTHT9EhSEcNSJARB+li6dOmTTz55//33O53ORx99NGDT/vnnn/+Pf/xj8N46ZNgY2lvncDiqqqq6uroAYOnSpStXrpw6dWpBQYHZbHa5XC0tLTU1NW+88Ya+ny4vL6+2tjY76bu6DoM021tHKCW9PcTrAcaYKDF7BhNj2VEuqTZenWnQ1u+K1MTxCW7Q1u+KVERpijZoS6qXOA7g3roUIo331n311VfPPvvstm3bTp06papqXl7eueeee+211950001iTD/DEUMxp7y8vPXr169YsUKW5Q8//PDDDz8MNdJqtb711ltpKZvSDK7DwbU0E//N84TQnFxaVMJS/CtLLyE+u8hkcEUqBlaEDdoQBIkR06dPf+655xK9ilGB0e4ry5Yt271791133bVjx46gAwghy5Yt++Mf/1hdXW1wLmSk4ZubOEdr4FHGuHYH8bi18nFnxBNjRFUBgAkCJJmiCt6gjXDOuK9Tb9BWzFgJgRJghZpWqGnxLkXSNL6zHZy9RNOA8MxqoTm5TMQddQiCIMPEqHICgOnTp2/fvv3QoUObN2/et2+fw+FwuVw2my0/P/+cc85ZsmTJ8KKjSDyRGevp6aG9vXZBzFSVwQOIy8U1N2rFpUSWudZm0tNNKAUAxvMsI5MWFMb/ZpzMrkhFjBUxms+o4J/KoapG42pHwHV3cY31/hFE4urlHG20oEjLLwjzRARBECQUMVBOOhMnTpw4cWKsrobEjR5Kv3J7m1SFAUB+IQDYVXVKT9c4V2/ASK6jnVksXEM98QuZEE0jnR2ku0sbcxazj1RTQv8Gbc1E79GWMFck3S7SP9GWnK5IXHcXf/pUkBOMcS1NwKhWUBT3RSEIgqQ8hpTTzTff3NXVdfHFF999992xWhAST5oV9VOXWx3YXqxXEHbl5LVIpjmdjgH5Lcb4hnoIlmkilPJ1J7XK8cxsNrKenjO9R0izvqkNSDPHJ6YUyU8YFTOmVyaliisS0TSusT7MAK61hWZkMrMlbktCEARJDwwpp1dffdXj8YwdOzZWq0HiiZPSwbLJx3GbPUNTp/R0DTgaWjcQxvimRrUiqsysF6COcI1E10mkifD6g2Ro0FbIaBGleSnerJbr7CBhe+QBANfeppXimxdBEGRoGFJO48aNO3DgQENDQ6xWg8STrz3eULIJAIDBAXvWeGePKepdx8TVSxTF38JAA2gl/ZXa/Y1s+1yRTCaD6x8q/a5IZ/y109kVyRmYbB0MiWIMgiAIEoAh5fSzn/1s9erVb7/99ldffTV9+vRYrQmJAxSgXlHDjSCgEnLabK1y9QIAC9s7hAG0i1KTyVTPSJMg+fb8J6YUqa8IifmJpJR0RTIC0cK+uPoYNf4vDoIgSMpjSDnddNNN2dnZ//mf/zl//vyHHnro+uuvLy8vj9XKkBHFSakWRUKqqz+A5JNNvYLQKJmaJHOTydxkMjeazE2SqclkVuK+53+wK1IRo0WMZaR4oi028JFDaSyKMQiCIEgAhpTTXXfd5XQ6p02b5na7H3zwwQcffNBqtRYUFIRxvKypqTEyIxIraCR1oRHSw/EHrBl1JnOTydQoWppMpmaTuTfut1vdFcm/WLsYG7RFglmspDdCMo5ZrfFZDIIgSDphSDk9++yzAUdcLtfJkydPnjxp5LJIHLDxHAFgABTAyfO9vNjD8z0C38sLPZzQIwhuLgGuSDl9KTZWxLTitC9FGklodi5payVhxSXNyYvbehAEQdIGQ8rJbrdbLBZRFAVBwG6CCYAxoirAAEQxYmuUgAZtzYQ7nGd2cLyT5+Pfd0qiLENTMqhmV7UMTbVr2kJJmMJzo6oUaURhosiKiklTY6gBNDuH2ezxXBKCIDHn4MGDiV7CACZNmpToJcQDQ8qpp6cnVusY7Shy5olar2hSzWZOUykf4XUhisy1tpDurj4jb0L6jLxNZhjUoK2ZEH1TW6Ar0shHcvRSpEyqUVm2a1qGpmaoqp1qg/frdam8ZLeN+IJGE1puPlDGtTQNPkWzc2hJWfyXhCBIzEmSvtqjKnoSMw9xxAis3VH26fa+HzJzGOGoIGiSpAkiFSVNFKkg6j9qogheD6k/TSiVOa7JbNULtBtN5ibgGwVzkyDGv0Eb19+gzb9ku5jRXMYOeeT9Xk+Q5wzcrefQNIUxMbnfe4RSkGVgFCRT9OXVDMBFqcZY/H3GtfwCmpHBORzE2QOqCjzPrDaak4vRJgRJG2RZTgbxZDKZRo94QuWUFLCB0TvCKK/IvNIXJFIJ1ySZ6s2WerO13myuN1vqx0+qN1nbpAT0/MhlrJiqRbK32OMuVpRiQgrN5jwheJSsXlGCyyYAIAPEEwNwMZaVrG88IstcSxPp6fZVDjGrVSsoCi9BPIwd8nhPKarMKAAQgCJBmGQ25cWxyp6ZzFophpcQBEFixjCV04kTJ9avX7979+729vasrKwZM2Zcc801U6dOje3iRg+s36pbI6QmI7vebOn7n8ly2mxpMplp3M21bf7F2v3+2gNckcwmMEdws/zK7Q13euDvlLQqnvT28qdPkoEZRuJyCSeP08IiLb8w6LM6NG2n0+1lZ57FAJpUtalXnWY2n21Kwk53CIIgSGSGfLdijD366KOPPfaYoii+g2+99davfvWrNWvWPPvssxYLdsIaOv0xJ4Vw358+i8VRJ0mMlahysaYVU1oErAigkCNFsWjQ1q5pThZt9bkExJqI3XwRIbJ3sGzywbU0U1FiWYE2HB7Kdjpd3hD/hvs8HgshZ0li0LMIgiBIMjNk5fTwww+vXbt28HHG2F//+tfGxsZ3332XS8pbYDLDerr1B2aq5ctyqxT7ziQcsGKvp8zjKfO4Sr2eMq9rjNs9xusukAeHhYgmipogUNFRZ5W0AAAgAElEQVTkV24laqKoCSKVTDS617dbG8KmvbGSmJyJOq6lKZRs0uGbG7XMrIC9jV97vX2yKYT5+r89njJJRLcFBEGQlGNoyqm2tvaxxx4DAEEQ7rnnnmuvvbasrKyzs3Pbtm2//e1vT58+/cEHH7zwwgu33XbbyKw2beHKK9vGT+RdTsHrKZO9BpVTviyXeV1lXneZx13mcY/xuMu87mKvh482jMT6qqzcruCnOV4TRCpJmiBookRFURMlKgiaKOkPdBkRfczKRLhJkRJ/CYFoGhdpAylRVXD2gj3Dd4QC1Mn9EdkQetDLWJOilIkYdkIQBEkxhqacnn/+eUopALz88svf+c539INjx46dNm3addddN2vWrFOnTj311FOonIYKN3VGk8r0BGhutzPKZ9k1ZYzHU+Zxl3ldZfoDj2uM12OiI9uPjFBNkDWQQ5R+A+gxqixezAdwCqJTEFw87+RFFy84ed47sD5aAu4im8WcnLXhsheikJucx6P5KadejYZrpdxPh0bLUDghCIKkGkNTTlu3bgWAefPm+WSTj8LCwl/84he33XbboUOH6urqxo4dG6sl6jDG3nvvvb/+9a+yLD/00EMXXHBB0GEOh+P111/fs2dPW1ubKIrl5eWXXnrp4sWLB++WjH5knCmiNMBpSQIoYrSQ0mJGS1ubit2uEq+31OPOVmUOGMeAY5RjwAPlGHCMMY4Ln2AaaXhV4VVFBAjqiaYRzsXzvYLo4nkXL5ZZLURxUlH3XJCoILDkyfZGGaUbWM4VTUNAANCSYCMxgiAIMlSGppyOHTsGAEuXLg169tJLL9UfHD16NLbKyeFw/PGPf9y7d2/4YSdPnvzFL37R1dVls9kmTJjg8XgOHTp08ODBmpqa++67z18SRT8y/kxm2lJNKaJaEWM+VyTfWZ6qXIdDf6xwQepkaF6BVlTMUXqkt6fF5bZrqkVVrVS1q6pFVe2aatM0i6Yk8DfkGc1QaYban8/qDhxAeVETBSpImiT2KyqxPz8oUiGOm/Ciy6bRgfYQluiUn41PGoGIIAiCRM3QbkKdnZ0AEEoVlZaW6g86OjoMLsufzz///Omnn3Y6nVdfffXHH3/c0tISdBil9Kmnnurq6lq4cOFdd90lSRIAnDx58uGHH96+ffu0adOWLVs21JEJYaamztRU349EVbnODuLs7XcytFK7nQvRzJVZrbSwCAAox30DvMsSvKUrYWChqk3VxhOo5oBXZF5ROFXhFYVXFV6WyQjn+8LDaQqnKQDuoGf7bEJ1g9C+EivxTBm7IMYwZMVEiZnMJJQllQ4h/kVOAGAmJJvnO7UI/4bF8ZSACIIgSIwY2me3pmkAIIUwYPQd1yLdM4bEtm3bRFF89NFHzznnnE8//TTUsD179hw7diw3N/fuu+8W+0MF5eXlN9988+OPP75hwwafHop+ZMIhXR18Y4N/6o24nEAIs9mJyzkgl0QIzcqhJaV6dTYFcIV2BGAEXLzg4gUiCGW2IOqKUMorMqfoWkrmFFVQZSIrvKrox8kQ6r9jTIBN6GAoz5/J/elbAkWJ6m7sgqANsShbKygSTofrYE1zctkgH9DJJukTV3DlpzNGFO3Jk5REEARBoiYFvvWec845t912W1ZWVvhhn3zyCQAsWLBAHHhrvPDCC//0pz81NTUdPXq0qqpqSCMTC+nqEOpPBznBGHH20rwCEMW+EmbJRDMymZ+iJf0e3eEJdetmHKeazGAyh3oiryq6ruJUpS9kpSi8IuuBK84vZhZ/OE3jNLcQKmQFRI9UaYLIRFEVzyQE9eMBISuWmUnz8jlHW/CrWa20qGTw8VJRHC9ptbIc1JUgg+POs4T8t0UQBEGSmRRQTr7yqfAcPXoUAM4+++yA4zzPjxs37uDBgz49FP3IBEJUlW9sCDOAa29Tx41nuXnBnw5g5/ieSEm3zOGW2miCqAmiEsL0lDDKKyqnyHrur09OnflRJVE7ZMYc4vNcCAHjeD1YpYqiHqlSRRGysll3F2WUAenTo4TQnFxaVMJCVMWdYzFbOe6Axxuwz65MFGdazFKiNyIgSBgYwGlFqVdUmbFsjptgMpk5/ItFkD5SQDlFSVNTEwAUFBQMPlVUVHTw4MGGhoahjkwgXGc7oTSEjSIAADDGtTu00B3vx4riAW8E5TR2ZPyEGOFUSYIQWV2e5yUAzeUksswrMq+qnOzlVdWXH+Q0JegT4wOhmuB1g9cdqj2KxvFUEDSTmXrcWkNdn5dVf3tm6ue5MMEkVUhiI6XdGlUYsxFSzPNZWBiOJDdHvPJbXT1N6pnIsQAw325dnmEXUPEjSNooJ8aYx+MBAKs1SNWOftDtdg9pZACdnZ0rV64cfPyGG2645ZZbhr1y3z4+SZL0QrGenh4AYG5XONkEAACcyymYQhpITpWkEw7FFTrsVG4yFwf7R4gDFIBkZgGABhBkfZRyisLJMqfKnCy7PO6mXqddU6yaZlNVq6YKiQtZAQBPNV7WxCDe6wAAjOOpJFFBpJJERYlJUoFkoqLIJJMmilSUYNTce0IVRAIAeDzM4wLKwGQiVlva/JsIgiAIgs1mS/RChs9n3T0vOToC3mAqwJZe1ymN/risxD9cmoq9tvLygsfpo8RqtZrNmGqPJQ6H47777nv77be7u7vnzp27Y8eORK8oMsNRTnqdUBh27Nihq5PB3HTTTcOYMSKKojDGAEAItl9Jr2fyer1DGhkAY6y7e9AGegCv1xsTF4OAizA1ilKhsGNEQi7JztzU0eUJpjMKRfGCTPsQ1xgvOI6aTLRfFO7vde2zDHAHNWnUpqkWTT0jp1S1kieionCKzCnKUAzMYwyhGu9x8yGqrACAiZLusMAkSRMlKklMlDRRYpJERSmungsJobeHnq7zt6dnokiKS0l+kBhwipJwT7hhU++VX25pDfW95Kjb87+tbauLzrS4TsXf1OCaCSGp+FsnMz//+c9ffPFFk8m0dOnShNfJRMlwPqbXrVu3bt26MAP++Mc/hjo1QspJFEVCCGNMDSYmZFkGAJPJNKSRiYXwfOSbPx+h71m2IHwrL6emx3nC6/FdTSLcJKtlss2aKkkjeZDy8/Kcl5cABoQ0vpWbkysIoFfHyzKvyET2corCy16iV1kpMpFlLtGeC0SRBUUGd3CneMZxVPATVbqc0oNYJhMVRUZS5XULAnO0srpTgf6iisLqToKzl5RXJmhdSB/vONrVsJ87n3T1LMvNKcSuQWkB6e3hThwDRyvIMggi5ObR8kqWnRPnZezatQsAfv/73999991xnnrYpMkXXEKIxWJxuVwuV5BWa06nEwD0EHr0IwPIzs7evHnz4OMmk8nhcAx75TabTY/9er1eXczp6o0zW0KZNvmgFqsqh6x01hEAzreYppulTlWTGbNwJIfnOUIiPnHk4DhOEARf8C8iAo1qGKeqsr9zuiiBGDxbRDStr6ZK1RWVvitQ5WSZVxU+wSEryssekD2h3plBbUJp3w5BgYb4leNM8JfY5RQGy6Z+WLtDE0WaXxj0bJLD8zzP8wCgqiqlVP8YSTkUxvb1Rlg5Bdjd3rHQbuN53mw2u91umtB2BcNgeB/XFotFr+VwuVxut9tgyi8Z4GoPc0cOnel/oMhQ7+Tr62jFODppajwT6Hp5TMz7jowoQ1NOv/zlL0doHcYpLS2tra1tbm6eMGFCwKnGxkbwe2GiH+kPISQzMzPo1D2RmsKGwf/Woj/W/0uzczlHW/juHzQ3L0rxIQIUCGcCVFE+a0RhjEW5jEKR/zp4TdEZ7BxnISTKCzKOo6E9FwiAT1T1OVr1uy2kmE1on6OVoIkmTRB0B/Z4drYJeImF5ubwf8+krRVy8pKo986wiP4PO9noVKNyE2lRVN/vmIq/rMEFp+KvPBjuWC13+ECwM4w7cRQA6ORpcVjG9ddfv379ev3x1VdfDQBTpkzZv39/HKY2yNCU0yOPPDIyy4gB1dXVtbW1hw4dmj9/vv9xj8ejN43x6aToRyYQJkm0oIhraQo1gObmsRAW4WlGHs9HtOSuNsUs1sIANFHURBFCObD7bEJVlVe8nKKekVZKoj0XItqEcrwuoQbahApUNA3DJnQIC9NU4ooQQyWaRnp7WGYE5zZkhIjSdiC1hW1ak3XquKkjckSNqAqpOxnua8w3+1lvFwvt5+dDsWd0VAX6+0TPlVdeWVFR8ec//7m9vX3lypXV1dXFxcXDvlo8SZNsHQBcdNFF77///vbt27///e/7b+rZunWrpmnjxo0rKysb6sjEouUXAGNca/PgUzQ3Tysujf+SEoUUdpehAKQijlmq6GxC++2sFFnUNF5VOVkmsocoCp9Ym1CqcZ5INqH6xkBBUEWJiiIVJK1fYw0/IBRddpgE25yBxIcsjjMR4o0UUCkS0+eukWbY6+uyTh6NzbWOHYlmlKugyIhyuuGGG2644Ya33nqrvb199erVV1111bAvFWfS5z0wbdq0KVOmfP31108++eRPfvITvXjo4MGDf/vb3wDgxhtvHMbIhKMVFNKMTK7dQVy+vnW20RNt0mnTtJawakMFdkKRq8LsgY8vuk0o9G/YFgTBVwSjaRphVA9T9bey6TeyUvu6B5LEFY6csQkNWcDOnwlWCSIVRVWUmCj2l1tJIe+60SY4Uj4PkrrwhEy3mHeH7RokAEzDPfnIqCfZlVNbW9tjjz3m+1Ev7vvLX/7yv//7v/qR73znO3PmzNEf/+QnP3nooYc++eSTvXv3VlRUOJ3OU6dOAcDKlStnz57tf9noRyYcZjZrpTGIgRFKSU8P8biBURBEas9gI/MJSCjlOhykpxtkGQhhZjPLyqEGUjCn5MjGmKdkJXmUU3gY4TRJ0kKvltPUvrY2cl8Ze1/3QFnhVYVTk8ImNNR5vUqdihKYTDLPa4Ko24RSwnEAESVhNAkCZORYmmHb5/Z4Qsvci+02tHJFkGRXToqi1NbWBhzUTcB1urq6fI+LioqefvrpDRs27Nq1q7a21mQynXPOOd/+9rcHi6HoR6YHXFcH19RI/EqFuJYmmpFBS8cM7lZrBOJ28XUniZ/jA1EU6OnhrFZtTDkblllRdxQNpLu0FNvgEwYXx9dxtJ0DxSRYLFyRwJeKou9mRRjTRdWA1oF9P8p8QkNWAIxXFV5V9JDVYG8PBkAJRwmhQDRCKCGUACUcBdA4QjmB2ZLVY2x0kMvzq3OzXmzvkoOJp+lm0/KMFDb5RJBYkezKqaSk5O23345+fEZGxpo1a9asWRPDkakO39YatNKc6+khx2q1yvHDEzSDIV4Pf/J40Ds3cbn4k8e1yqphFMpEIwRoumR5amV5n9ur+f06x2WwE+8cmyWH5wGAEaKJkha6rovTNP8WgX39mM+0DlQT6bkAwDMaxqmM7q/xtV7WBIFKet261Fd9lfY2oUnARJPpx/m573T3fOOVfS9UJsctzrBdaLWiBySCQPIrJ8QgxO0Ks0GPKArXUKedFRsHQr6hPkzAg3g9XFuLVjjkrRN2jmuPFHbK4CKYgqYEBzzyAa8HBrXd6WV0a6/zYrst1+d9yhhRFWAAohjQcpjyPOUtKgRvi0EA+iysVIUoiqCcSQhyisIryeG5ELwBQb/ngiRpgl5rdaZjoK63UtomNHkoFoVb83J6KD0tKwpjOQI/RhBRMyU/HeOqXdF8wCoKOXyAhPHJI4SOnwDmyK111BRsvxMTUDmlOUG35g0Y0NtLPW4WxZskPMTjJu4g5qID5upoH4ZyKhWFU0qE4p4SMeWVU4emHfB6AIJ3K9QAdjndyzLtvKJwrc2kp1vPvTJCmN1OC4qifAUZQPiQlc9zQVAUTlU4RRb8bEI5RSEJDFlF9FzgBT8jK5/nQr+vlYDO10Mgg+MmmRPfTQGJHldRiauoJJqRxJbB79sDAIO/pwEArZ5Eq4e/Y240gMopnSGMcVHYGXM93Zph5cS5ovBN1jTi8cAQ+6GWiWIWJ3eFjoVIhExIgoY5BvnGE3rfPgMg4GS0vre3sv6Uf70aYYz09HC9vVpxKc3JNb4Mn+dCqNXwisKrKqd4z6QCFUXfKsgpMhdFUdrIwWkqp6khbUL7PRc0UWKSqAq6TaikbxI05LmAICkFG3uWBsB9/e/AGDPH0eqJtCrxjoZJDiqntEZVotoNHimiE91c0dkUDd3NiADMtVm29Lq8wRwmeYALrBYp9XMJTaoa9PsfwJmDLb2944JKE8b4xnomisyeEX4WIns5Rxtx6iYXHLPYaE7ukOqy+21CQ2QDKeVVRVBViTHmdhJZ4VV/K/aE2oRG47ngswkVBF/ISvcOpaKYJsV0CKKLp4JCru4kcbSC1wOSieXmsbHlzIqbACKDyimtibLsI/RXbcIYi1KURFm9O6ytfHaOW2K3fun2NA3UZ9k8P9NizonU+Tj50QBUYGH9PgEA3GFfC76pQR0fLsbOO9q4lqYzYppSonRx3V00O5uWjIn2hQ4L4zhVMjGLlQmCLGcM7lMx0Ca0v3WgLHP6VsGE2oQSqglR24T6t7gBk5mzWmhaFNshowizmVafDZiYGzqonNIZJghMEEikaFCAiQ6hlHO0ke5O3dCZiSLLyKR5BSxsaw5qtUeUaYznh20iZeG4i2zWHkpbVNVNmYkj+TyfBppJhwcgUex5E8P3fZNl4nKG+srIdTi45sbgpzo7gYFWFo+OmwE2oQEQSvuSgH02oX3OC30/poBNqEhFieVehIk/BEljhqCcsrOzjcykKIrH49ESWgYxCmFZOcTRGm4Ax/l3CiMeD193gvjl74iikHYH6ezQxpwVJhnEzGZmtRJXuCJxlps/lLUHIYPjMkbS8TI/3+gK29rahvfEXJ53RHp35MkRmpNwHrcWTDkRVeGagsumvid2ddKs7IjJvpGGcRFsQnlN4/QugQNsQvvbMyfeJlRjsuxF2YQgUXPo0KFEL2HIDEE5+XtOIqkCzS8g3Z0kdCUTKyxi/ZEboir8qeNBY1SEUr7upFYxLkzjF610LH+8loS4/TOLheYXDHH5McO4JBr2RCaTSRRFAPB6vcrAF8JfZlVIksMdrvEFT1lFiGjHGULsNOY6O0mkijeuw6FFUk4uSk/ISpumyYyZCCnkhUqTGM8iM43nNd4CoTwXGOuvW5c5Re0vseovY1flOISsRq5rMoIgScIQlNPFF188+CAhpLOzs6amBgB4nq+srMzNzZUkyeVyNTQ0+My+lyxZUlBQkJWFXdDjDeN5bWxFQBjJB83L1/ziQFxLc5jUHmGMb2xQx40POZckaeXjgs7F7Ha17CwY4Vts3ORRrPBfcC5jnzs6jvm1mqkeqJOm93RaIgWlaKhurFHsfAwfLwSAw155v8fjLz2aVfWg1zvTah6bHHKBEdJXwA4hUpaUcrLXz7+qr26dU7y8qvKKYtwmlCbHPwWCICPHEJTT1q1bBx/cuHHjTTfdNGXKlEceeeTyyy+3DCxfaGlp2bBhw69//etDhw794he/CKq9kJGGmc3auGqutZnr6oT+Wy+zWLWCQv/sDKGUdHWGvxTxuElY8ydmNmvjzyadHaSniygKAGFmE83KZvbMmPwu/qScTgoPR8ia3Oy/tXf6xNMRS9/tnwAsttsWNJwgHhcANJtDbH4hBEIEjUIFAqMfc8gj7/cGcahUge1yucEKSSKewkM5jprD24T2tQjkVEVQFD0zKAzFJlQTpJTf54kgSFgMVYgfPHjw6quvPvvss7dv324LZtJTWFh4xx13XHnllbNnz16xYsUXX3xRXV1tZEZkeDCe14pLteJSosigURBFNri22uOOmNABAOJyhTddZISwnFyIhbdQAGkmlQZj47g78nJ2uz2fuVx1ssoAJELONkkL7bYKSVTHVYtf/xsAijxBAkjNZhvNyQ3VhZCJAgmXCQQACNOEp0ujXweTTT6+dHmKMoVU94ZgZzwXgg/w2YT6iqsERSGKIqgKrypElgkwTQwV90MQJE0w9B5/4oknnE7nL3/5y6CyyUdpael//ud/3nPPPU8++eS6deuMzIgYhIkShAoNRFcCEs/NTWkvlQbDETLHapljtVDGZAZm7owW0UrHcO0OvvF00CcWSKIyaYq/IB5Qq261Q3d3+KlZ6HdxrSyH19QqsGNeZaJ5BIv3kwGfTWjAcUEQeJ4HAOp2a1SL/ZcGBEGSCUPKafPmzQAwc+bMiCMvuOACAPjwww+NTIeMLNH1pmAj+Y16FEqlUHCEmAMiOIQoU2cwq5U/fnRg2ohopWPUgbIJBv5jkqwsU/3JZj6sr0RuyPr9FiWyzVKLpk6ENFdOEaGiSDXcWIcgaY6hu2BjYyMAkChC9PoXsoaGBiPTISMKM5ujMn+yDsFvOhpQLQ0BQtSqCdqYcq6lkXM6QdOYzaYVFIcJF+kwUZSnTC+q+TKgAtpXMkXzC1jo5p3eKNK43jANRBEEQdIIQ8rJbDZ7PJ5PP/101apV4Ufu3r0bACyjta9yqsDy8klzU5gBNCs7vB9mlJSUlLhcLpo4V8OUhplM2tiKoRqj0cJiecZ54oGv/Hc+FnmcwHFqZbU6bjwQEsqMSiREjSSexNSucUIQBIkWQ8pp+vTp27dvf+CBB2bOnFlRURFq2KFDhx555BEAmDx5spHpkJFGy80nvb3E2Rv0LJMkWlxq5Pp6eEmIsk8LEmtoUYmcm8/XnyKONuL1gijQ7FytbKzPdjwg/ucTUvkCX6dEkLn5Qpr4uSMIgoTH0D3slltu2b59+/Hjx6dMmXLjjTcuXry4qqoqJydHkiRZljs6Omprazdu3Pjaa695PB4AWL16dYyWjYwMhGhnlXONDVxnR8AZZrVrY8YG2ZEXCUzGJRVMFNWKKqioimaw77Wb6JU3OzqqQ/twcgCVI+ntjiAIkjwYUk6rV6/+4IMPXn31VZfL9cILL7zwwgthBi9fvvzWW281Mh0SBxjhtNIxNDef6+oE2QMMQJJoRiazDa28KYaCqU3Veim1EFIg8FyK73tPUapM0hyrZdfAg/5CarLJbMOWIwiCjA6M5k1efvnluXPnrl27trm5OdSYzMzMe++996GHHuLwszVFYGazZi4e6rNiG16ijO10ubf3ujr6HRpthFxgsyzOsJtQP8WdlVkZALDLdcYVSjfqJACXZtguzLA7htuwD0EQJLUwqpwIIXfdddcdd9zx8ccf79q16/Dhwx0dHW6322QyZWVlVVVVzZw5c9GiRSaTKSbLRZKQkcjHyYz9pb3ziFfuP8AAiJOxTb2urz3ybXk5WfwAFU4Z+7fHu9/j6dAoAVYkiOdZzONNmD+KGQIh12Vnnmcxf+J0HZcVF6MZHD/eJM23WctEAQb+GQiC0NERmPBFEARJD2JTq8vz/IIFCxYsWBCTq41aiMfNtbXyPT3AcdRsGWqCLM6MaAHT+s4uP9kEAGeCTE2q+pf2jh/n5/oyd22q+rf2zkb1zG6zE7K6y+WeajbdkJ3lbyaJGGS8SYpSj/pvnwy1ZQ9BEINMmjQp0UsYjeAup+TA7eJqvjDVnwZgnNkGAJzeQLe4lEVqXx9n4lDxfUJWatzeMANOK+put2eO1QIAnZr2TFtHTzCDg/0e75/bO+7IyxEwu5dQQm3ZQxDEIAcPHkz0EgYwSpRczJRTR0fHli1bDhw40NTU1NPT8+KLL/pOOZ3O8O1ZRjnM6VTWPUW8SsBxIsvCqRNa2RialZOQhfkTzy1yX7oitVgD+NLVp5xe7+wOKpt0TsjK1l7Xkgz880si/P+WUEUhiEFYFEa1cSAaT+y0IQbK6dixYw8++OCbb76p+tlP+5RTbW3tBRdc8Mgjj9x1113G50pL1P//FdbaApnB5RHfUM/MFjaoVVbciL+tQEMkH3MAaFQVAGhV1YMDknpB2N7rXGS34qa85ARVFIIYRJblZBBPJpNp9Igno8rpk08+ueyyy7q6ukINePfddx0Ox913393W1qb7YSL+kPo6enB/uBGMcW0tWtlZ8VpRHwn0YdIifgowUBkAwJFIsgkAnIw1qVopNrBPejCphyBISmDIJqCzs/Oaa67p6urieX7VqlUvvfTS22+/HTDmoosuOvfccwFg7dq1yZaRTQq+ORBxCOnpicNCdPL7iduMg8mN6LdJII/nAaA3ul5p3XSorUqQxJPvR6LXgiAIcgZDX8TXrVvX2NhotVrff/99fWPdiRMnAsbMnDlz8+bN559//tGjR5977rmnn37ayIxpSEd7xCGEUqIqTIhBw7gwGL8/VVZWRjNMkqTMzMzOzk51YFbu+PHj+oPJZtO/PeEqxAHgbLMEANbo9s1ZCRqJpTaY1EMQJHkwpJz0CNPPf/7z8H4E2dnZ991335133rllyxYj06UlJLp+JoxwACAz5mZMALByMdtqP1TBFKU8Gga+K49h7KnaE/6ZuPldgeZAX7o9083mCimymjQRgqm6dAJVFIIgicXQHeXo0aMAcOWVV0YcOWfOHAgWkUJYYXFEDcQEoZHSQ26Po99NWwJSbhInmUzScCvyohFMIyeSwiMS8pexpStO1HX0WzTtGLi7cH5Xe49Gn3d03FOQWy6JJ+XAbYn+zLaa0ZUgXUEVhSBI/DGknHSb4IKCgogj8/LyAMDtjrzbfLTBJk8jmz4ALWQhDgP4Mq/oyMCN+jKwI165XlYvslkz+aGlosJopkRJpcFMNJv+Na78iuOnmpUg++x2ZObq1phuwfzraWet3VMjhygqz+f5pRlJbSiKxApUUQiCxAdDyik7O7utre3EiROFhYXhR546dQoAcnNzjUyXnmTn8PMXaVs3hjp/KCvniBD8ZXIxutPpujTDJkYRUwkqmJJHKg2mSOC71EGCkgGQM47iO50uEyF3z5j2w1MN7ZoGA/N6JQL/w7wcK3ZLHH2gikIQZOQwpJymTp26devWN954Y/bs2eFH/u1vfwOAKVOmGJkuXRGWXc46HNBfH+2PR5L22afcPK4AACAASURBVDPDPNfF6Ddeeao5XFvAAM2UzGrJn3+7vZ7BkaRBEnGXy31TTtZn1ZV/bu94v7v3Cy7XRLiJJmllduZFne2Yp0NQRSEIElsMKaerrrpq69atTz755IUXXnjFFVeEGvbss8/+9a9/BYAVK1YYmS5t4Tjxhu/T//M2OfINcTv1Y4wQlpV9IidfkyNYFp2UlaDKyf+GkSpqyZ8OLbIfJgC0qyoA5Aj8Twvzf1o4MK6Wm63///FgqhQZhaCKQhDEOIaU0y233PLEE0/U1dVdeeWVK1euvPbaa61Wq35q3759DQ0N33zzzSuvvPL5558DwNixY2+77bYYLDktIYSNLZeLS4nLqba2AceB2cQI1+n2RHyqm1GZMf9Scf32kIpqyZ+CEDnKAArFyNvr/P8pRq2KIl4P6e4CVQWzmWXlsFGfxEQVhSDI8DCknGw225tvvrl06dL29vYNGzZs2LDBd2r69On+I3Nyct555x2LxWJkutEAs9qY7UwxeGQ3bQAAUPuVU35+fqoLJh8zzOYMnutR6eAMnQ8CcKF1aH9Uvn+f0SOhiNMpfPM139YK0PfnxARRK6/UKsejftJBFYUgSPQY/dycOXPmnj17Vq5cyYX4CNbtxb/66qsZM2YYnGsUEo3TIwcwd/bsWbNmzZo1K21kEwBIHPlhbk4Y2QQAl2dljI3C0ikolZWV6fTPFQquwyHt2sm3tfhkEwAQVRGOHha//IyE3tQ5akHvcgRBwhMDh8Dy8vINGzacOHFi8+bNNTU1DofD6XTa7fbCwsJzzz138eLFpaWlxmcZnZSI4qHQrdmOWGw7snKWZtiH7eqU5NxbkLvF4fiKBj9bwrTfFEfY1BmR9A5BEdkr1XwJanC/K66jXTi4X5mKX2lCgrEoBEEGEzNv5YqKih/+8Iexuhqik8fzhYLQMrBLyRGLDfrNITmA/yhIW68He1fn+9ve+96k8zblFwecmt7T+Y89H5eCV5l2bkzmSksJxR+rBSXcDgO+4bRWPo5mZMRtSakLqigEQXTi1JVCluXDhw8DwNSpU+MzY9ow22LZ1Ov8ytxXzdPvpt2XeflFUcH5Qyz0SSGkHZttvT3v7t72r4KS/y0565A9U+G46t6eFS2nr2ms4xlj2zapE6eyKIrEo0eXUOmhn/iWxkhDGNfcQDPOjsdq0gifikIJhSCjEEPKac2aNQDw7W9/+5prrgk/8tSpU9OmTQMAFl3JM6Kjf0BfnZ8nd3T92WzzO0Nyef5XxQXfyclK1NpGGiLLQu03+uNlrY3LWoOIAOJ28cePqhMmxnz2NAhBEVUlnsh7M4mzNw6LSVf0d6gkSZIkNTZG1KkIkkQ0Kcr2HucRj7dX0yw8V2UyXZRhK5ekRK8rBTCknF588UX9v//xH//xu9/9TohuGzkSkYDS1BlVVTMArnd7NvW6GhTFTMi5VvPSDLs9rTdGcR2OaOqX+bbmkVBOPtIpBIWMKCUlJV6vV1GUyspK/INBkpyNXT3vdXX7ikhdquZQXbudrvkZtqtzstP51hILYvPv89RTT11yySX4lcsg+m6vAAdLX/BjusX8HwW5vy8t+nVJ4cqszPSWTQAQppffAAZ3aBkBUnEjHhMEJpkjD7PaIo5BhkqlH4leC4IEsrm79//4ySYfDGB7j/PNjs64reS1114jhKxatUrTtF//+tfV1dVms3nMmDF33323y+UCgC1btixatCgnJ8dqtV500UVbt26N29rCEIMo0bx58z755JOdO3eed95569evX7BggfFrjkLGjx/v6c+tpMSnLXG7xf01/OlTxO1iFqs2tlyeMh0s1lhdn2ZlAyEQKb1Ls7NjNWNEUi6FR4uK+boTkcaUxGUtoxc0YkXiw4eKdkgLsRXZDzdln3oVag75WX1CYQecniyej3ipMo6skgypCLPZDABOp/OWW2555513FixYUFZWtmPHjmeeeaajo+OGG264+uqr58yZs3Dhws8///zjjz9evnz5vn37qqurjUxqnBgop//5n/959913H3zwwaampsWLF//mN7+5//77jV921JISskn4+ivzpveJ13vmSO030ifbPUu+pU6eFpMpmM2uFZXwTQ3hBnGcWpmAt1CqpPDUyvFcYz0J4UoAAFpRKc1M21K5JCTlxDeSQmxX1PeU6GLwUrhWpwBQp1JQI4uw8wTOoHIihADA559/XllZeeDAgcLCQgD4+9///r3vfW/9+vVbtmx5+eWXr7vuOgDo6emZNWvWN9988+KLL65du9bIpMaJTcbnvvvu27x5c0lJiaqqDzzwwKpVq7q7u2NyZSQJEffVWN57y1826RCvx/LeW8L+f8dqIvnCheEHKDNmssTtqE/+XAwzm5UZ5zEu+HdHmpmlTomNzEWGCqbzEMRHR0fHH/7wB102AcCNN96YlZWlquqiRYt02QQAGRkZN9xwAwDs378/YQvtJ2a1MvPnz9+zZ4+eqnvjjTdmzZqVDL8eEnNId5fpo/dCnmbMvPE90tMTk7nUceO9F1wU6iwtHeNduCQmExkhyW9+NK9AmXMhzR5g+sU4Ti0fp8yex4RYGjogwwNVFDLK0WuYfD/yPF9SUgIA8+bN8x82ZswYAEiGuEwsq4yLi4s3bdp03333AcDhw4fnzJnz6quvxvD6SDIg1XxBBjpzBkBURazZHavp5PmLPMuuYAEdDzlOOed813dWJ8+NP5lvezQjU549z3vRJfLUc5RJU+VzZskLL1XPnhwqFoUkEJRQyChEl0T+8Dw/+Lh+kNLIacSRJsY+AoIgPP744/PmzfvBD37Q3d393e9+95NPPnnyySdjOwuSQPiTkeszhJPH5fkxm1GZfq46aapwvJa0thCq0cxsddx4lpEZswliRzJXsTCrDbfRpRBYV46MHsQQbsahjiecEXFgWrly5dSpU1etWrV///5nn332yy+//M1vfjMSEyHxh3NGzsRxXTHe1MpEUZkwCSZMiu1lR45UKSFHUgJUUUg0XCkJ5wmRA8luSt/t7NYg5LZlArA0KzM7ir11+VH0pE9LRsq7csKECbt27brtttteeeWVzz777PLLLx+hiZCY06Co+zweF2VjRPFci0kY2E6YmSwRy5iIy2n9x4vub69k9lHdEE2/4TU0hN0eiCBDIZnjmkhimSXws6IbWWW3vNYe8vvtt7IyllsibL4b5Yyg67fVan355Zfnzp1777336pZWSJJz0Cv/V2PL9l6n78tIrsDfnZ97R14O36+ftNIyrq0l4qX4upPWV//qWn1rYInS6KO6utpisRw8eDDRC0HSCgxEIcPmArsNAF7v6FQGBp54gG9lZ16aOaq/8UaDIeW0atUqAMjMDFdx8qMf/ej888+/9tpr6+rqjMyFjDSbe51rTtW76YB3UruqPdrU+rHT9eLYMokjAKBMP0/cVxPRoBKAcV2dpk0feL599YgtOZWYNGmS0+k8cOBAoheCpCGoopChcoHdNsli/rTXecQjd2uanefGmUxz7bb8KPJ9iCHl9Prrr0czbM6cOXv37t27d6+RuZARpU5Rb6lrCJBNPj7qcT7a3Pr/lhQCgFZSppw7S9zzeaRLEgAQD+33LljE0GuxH6x/QkYaTOchUZLF88uzMpfjx/PQiVOP3ry8vCVLEm+9g4Ti982tPWFt+//S3vn/5OecJYoA4Fl4Kaiq+NWeyNdlTDh1Qpk6I1brTA9QPyFxAANRCDJCxEk5IcmMyti7Pb3A9DhR6DFdvXfk5wAA8Lxn2bdpVrZpx+aIF+d6Y+OKmX6gfkLiBqooJDm56qqrWLDaj6BO2mvWrFmzZs2IrykKhqCc9KDRJZdc8vOf/9z/yJD46KOPhvoUZKRpVtVujYaRTTqHB7Zb0caWR3NxasI9GuGorKzEOxkSTzCdhyAGGYJy2rRpEwDk5+cHHEFSncjV3gAAEJDMo4VFjBeIFs5PHABoaaA5LBIABp+QhICBKAQZHkNQTjabDQDMZnPAESTVKRIFG8c5I1naV0kD7FyZKKmTpohh+/tqRSVaYXEMljgKQP2EJBAMRCFI9AxBOfX29kY8gqQiIiHLM+0bOsO1UeQALh9k8uFdsFg4fpQ4g/8ZMF7wXnoZkFFqMjs8UD8hiQUDUQgSkVh2/EVSl/sL8sxhJc4NOVlVJingILPZ3dfdxLKyB49nJpPn6uu0krJYrnLUgD1fkWQA2w8jSFBwbx0CADDeJD07tuSO041yMEunOVbLb0qKgj5Ryy90rrld+nKXcOhrrr0NKKWZWWr1RHn2vFHeesU4GH9CkgQMRCGIP6ickD5WZGaUVIgPNjZ/5fb4Dlo4clte7k8L86TQESkmSd65871z5wOlwBhE0ScSiR7UT0hSof9BiqKYlZX15ZdfJno5CJIAhqCcFi5caHy+rVu3Gr8IMkLMspo3VZUf8Hi/cnt6GRsrChfZrDYu6pRu9CORIYL6CUlCqqqqVFUF/MtERhlDUE7btm0buXUgycNks2myGU2YkhE0f0KSE0znIaOKISinrCxsb4MgCQaDT0iSgwYHSNozBOXU2dk5cutAECR6UD8hyQ8GopB0BSvEESRVQf2EpAoYiELSiTiV9La3txNChtHnDkGQ8KDjDpJCVPqR6LUgyDCJU8yptrYWAL744ov4TIfEFg9jx7xyD6VjRKFMFCM/AYk7WDyOpBwYiIoJJuyqHndioJwURXn33Xc///xzh8OhaVrAWcZYa2urbkbAo9NPqtGoqP/d0vZWV4+rv6vdJJN0b2H+VVnocpl0YPIOSVGwImrYTJo0KdFLGI0YVU41NTWrVq06duxYNIOXLl1qcDoknux1e248ebpNHaCGD3rlW+sadjizHy8two50SQjqJySlwUAUkvwYUk5tbW3Lly9vbm4OP4wQMmbMmBUrVqxdu9bIdEg8aVO1m07WB8gmYAAEAOCl9s6xoviTgtyErA2JCOonJNXBQBSStBiqEH/mmWd02XTddde9//77R44cqaurA4DMzMy6urojR46sX79+7ty5xcXFzz333DPPPJOdHaQ1LJKcPNna1qKqAAD+jezIgAGtamByFkkqsAgXSQ+wqBxJKgzFnN577z0AWLVq1fr16/2P60EmABg/fvw111xz7733XnbZZc8999xtt91mZDokbmiMvdHZ0/dDiJycm7L/093zg1xUw0kNBp+QdAIDUUgyYEg5HT58GABuv/32MGM4jnv66af37Nlz5513zps3b+rUqUZmROJDi6o5BhX7D+aAxxuHxSDRQGSZa24kbhe12WlxaUDfZdRPSPqBFVFIojCknHp7ewFg7NixAce93sAb6r333rtjx44//OEPf/7zn43MiMQHmbHIgwA8/RvukARCXE7T9k3CgX2kX+wyk1k+93xl7gImDHiDo35C0hIMRCFxxlCdk9VqBQCn0+l/MCsry+PxeDwe/4Nz5swBgA8//NDIdEjcKBYFiUTeOVdhkuKwGCQMXLvD9vcXxH01xC9GSLwe02c7La/9jXjcg5+CxSJIGoMVUUgcMKScKioqAGD79u3+BwsLCwFg9+7d/gdFUQSAxsZGI9MhccNEyCV2W8RhyzPs/j/u83jvqm+a8c3R4q8PTzpU+71T9Zt6naGeixiHaKrljX+Q7q6gZ/mmBvO7bwU9hbcWJO1Bs3Jk5DCknC6++GIAWLt27bZt23wHq6qqAOCll17yH7ljxw5Aq9OU4r7CPD5s2OnyzIwp5jMv6O9bHEtqT6zv6GpQVI2yNlV7v7v3+hOnbz/d6I0u94cMFbHmS67DEWaAcOwIfypk8gJvKsgoASUUElsMKac77rhDEASHw7Fw4cLly5frBy+//HIAeOGFF+6///5Dhw41NDRs2LDhRz/6EQBMnjzZ+IqR+HCuxfyr4oJQ0qnaJD1ZWuT78Zm29t+1tJ0pevJ72obO7h/XN43QIkc54qH9kccc/Dr8ALydIKMH/GtHYoIh5TR58uTHH39cf0z64xNr1qwpKysDgCeeeGLSpEllZWXXXHONnqdbs2aNocUi8eW2vJwXziotEQdUGROAlVmZ7407K1fo271VJyu/aW4Lc50Nnd2bMW03AhBHuH92Hc7RGnEMfh1HEASJHqPdV3784x9PnTr18ccfHz9+vH7Ebre/+eabV1xxRYC3+OrVq8P7FyBJyIrMjGUZ9q29zq/cXhelZaKwJMNeIQ1o+vtaZ1fEvXh/a+9cFEXhFDI0otjbSFi0+x9x5x2CIEg0xKDj7+LFixcvXux/ZNasWV9//fXf//73vXv39vb2jhkz5sorr1y0aJHxuZD4YyJkWYZ92cBicH92uzyhTvn43BlkkxdiEJqdy7dG6H1Es/OGdM3KykoUTwiCIGGIgXIKSl5e3k9+8pMRujiSVHRF4ZnZhc5PI4A2YWJE5aRUnz3Uy2LwCUEQJAyG6pwQBAAKhcj6u1DgI45Bhop83mxmDZcD1YpL1eqJw7s4Fj8hCIIEJQYxJ03Tvvzyy8OHD3d1dSmKEn4wBqLSj/l26796esOPWYBFTiMAM1vcV11nef0VIstnDvZvbWSZWe4V10AUjqZhwOQdgiBIAEaV09///vcHHnggoBg8DKic0o/rszOfaHV0qCFzdhzA7Xk58VzS6EErG+v67g/NG9/jT5/SjxAAIEQ5e7J38fLwEakoweRdNDCvlx09wjWcNrld9n+5tIIideo5yoRJBpUrgiBJCGEGXArfeeedFStWDOkpRqZLWrQoCn1CwXGcbuhAKU3df5y3HR3XHPgmVCnTI+VjfnHWGN+PhBCO41L69x0S8XmJWXMTO3UC3E7IyCLjxpOs7JGY5dChQ9EMI4QQQhhjo+QlhuYm+sVnoPRF/iZ0d+gPSOV47sY1xJaGAdfR9i7Wf18AoJRSSoUoShSQNMaQcrr44ov11ivXXnvt5ZdfftZZZ1kslvBPueCCC4Y9XdIS0KRvSAiCoL8JFUUxosASzjttjtuPHGsnAyrnzJT+UmA/mT3b/yDHcZIkeb3eUfKZmzYvsc7hw4cjjiGECIKgquqoeInb28inO/wdIiZ0d/iSpqxsLPzwdhDEkE9PTfR3sSzLdHRs/vC9i1VVVRQl4p0OSW8MCeeamhoAeOCBB373u9/FaD0pSW9vhCqfMNhsNv0N6fV6jSiwxEI09fI3XzvQ3PhyWeWWvKImkzlHkS/ocHyv/vhZbqfc2uC9eIlvsCRJkiS53W5VVRO45rjhe4llWXa7U96dobS0FCIl7/TbzKi4rTJmqvkyiLFWf46O1Nd5t22W51wY53WNNKIoSpLkcrlGybvYarX6Pqjdbjcqp1GOIeWkv2euueaaGC0GSVWkbZv406eyAe46cfiuE4ExCenzT7Syser4IW+PR5IWLH7S4RxtxBnhi5P07y/l2fOw4AlB0gZDrgTl5eUAIIrpFohGhgRxOaWaL8KPkXZujctakLiCtgXhOy7rkK5O0tMdh8UgCBIfDCmnlStXAsDOnTtjtBgk8ZCeHtMn26zr/27923PW9S+ZPtlGenrCP4U/VguRynf41mbS1Rm7ZSLJwii3fSLR5ao4T8pnaREE8WEoW3ffffe9/vrrv/rVrxYvXjx58uRYrQlJFGLNF6YtH/rfDPhTJ8RdH3svWaqcc36oZ3HRSSKuq1MbmQ1fSMIZtck7JknRDKOxsIdAECRJMKSccnJyNm/efPPNN8+cOfMHP/jBZZddVllZaQu7BbeiosLIjMjIIe753Lzpg8HHiaqaN74HlCrnzR58FgAIH50/OO7jTXdGoW0mzc2Do5HHMHtGXJaDIEg8MHoz0zRt0qRJmzZtWrdu3bp16yKOHxW7lFMQrqvTtHVjmAGmrRu1qgk0WNBIKyiMPAHP09yhtZ5FUhE9+FRXV5fohcQJmp1LM7O47q4wY+SZc+K2HgRB4oChOqfa2to5c+Y89dRTEZuuIEmOuHc3CVurRDRN3Ls76CmtfFxEr2q1cjwz4z7e0UJVVdWkSZMSvYq4QIg65RzgQ+6SUSuqlOnnxXNFCIKMNIZiTmvXrm1sbASA7OzshQsXRuOEiSQn/KkTwx7DBMFz8RLL+/8M9UQmit4Fi4e7NCRVqaqqOnLkSKJXMeLQjAw29yLy5efgdgacUiZN9S67AjhsrI4gaYUh5bRlyxYAuOSSS95++2273R6jJSEJgHO7Io9xBd4YfKhTZ3i7Ok2fbodB2Vgmip4V19C8fKNLRFKQUVI5zrJzxKWX0ZPHtYbT4HJqVgstLFKmzNDGnJXopSEIEnsMKSe90e/PfvYzlE2pDjWZeQhXqwEA1GwOc1a+8GJaNkbauZVvrO87xPNq1QTv/EtoLsqmUc2o0E88z40br5SNVRTFNYptGhBkNGBIORUXF588ebK4uDhWq0ESBR1zFt/aHGlMefgBakWVWlFFnL1cZwdwHM3NZyZT7NaIpDajcOcdgiBpiaEE/Pz58wFgNJQypD3KjJkRukMQosyYGc2lmM2ulY3VSspQNiEBjHLbTARB0gNDyum//uu/srKyHnvssTToYzrK0QoK5dnhmpLKsy+Myn0ASTLaVO2ZtvabTtZfduzU907V/3+OjnY1guH7SIPiCUGQlMaQcpowYcJHH33U3d190UUXffjhh1qkFhxIMuOdf4k8a26QyBMh8qy53vmXJGJRiCFe6+yedfjYo02t/+rp3e1yv9/d+1+NLbOPHH+jK8Ft1DD4hCBI6mKozumOO+5wOp0TJ058//33ly1bZjabKyoqwnuIf/FFhNawSMIgxLvwUnXiFGnPbv70SXA5wWrTxpTL583SiksTvThkyLzY3nl/Q5DatS5Nu73u/7Z354FR1Pf/+F+z95Vkc58QkhAOIRAQMEgg3KAoIIhYVED9VFoI1m/51Qq11oMPLbaiKFZbv/2qeKKCCKKIyhEuASVAgIQbEkLuY5Psfczvj7Hrkmx2J3sn+3z8tcy+Z+aVHSb7zMx73u8qC8vep44KfFWOwqLnOAD0OF4lpzfffNPxnwaDoayszLt6IMisSSn6O2cFuwrwVoXZsqqqllgiZ73XWKI/3KgtUCkTQ2BKHPQcB4Duxavfm2q1WiaTiUQiIc+ZywAgIP5vQ5OJZZ3GJo7OZnu7ofmpxJAYMAIXnwCgG/EqOTU1NfmqDgDwoaK2Toct/aWNVvsUhURy4iA/AUC3gGkBwhdjtQrqaoU3rjMu5yuF7qiWxwN0NeZQfKQDPccBIMR5dc3p0Ucf1Wg0BQUFy5cv91VBEACMTis9uE909hRjMnFLbHHxxtvGWG4ZEtzCwFeihIJai/s2Aamly3DxCQBCmVfJ6cMPPzQYDL169fJVNRAAwrpa+WcfMG2tjgsF9XXyHVstVy/rp8/EBKU9wEiF/ILR5LrNKKUiMMV4Bj3HASA0efUdmZmZSUQ3btzwUTHgd4xBL9/yUbvYZCc6c0pycG9gKwK/WBgd5XJIeBIQPRQd5FEJ3MKwTwAQgrxKTitXriSibdu2nTp1ykf1gH9Jjh123atJ6q4BdAu3KuQPx0a7aPDbuJhBsu4xPQ7yEwCEFK+S04MPPrh9+/bMzMyxY8euXbv22rVrvioL/ER8tsRNC6tVfO5sQGoB/1qdFN/ZVaX/iVH/OTTGI+AP4QkAQoRX/ZwKCwu1Wm1OTo5er3/qqaeeeuophUIRHx+vVqs7W+XEiRPe7BG8wRgMfK4nCeucDDwN3Y6YYdalJs2Oivh/jZpDOl2TxRojFI5Ryh+Li8lTyINdnSfQcxwAQoFXyen1119vt0Sn0127dg0Xn0KUjddT6KzF3UNZEECM2SRobCCLxRapZiMiurr6OJVynMrVhEjdDnqOA0BweZWcVCqVXC4Xi8UikYjpOFMshBhWrmDFEsbs5pErVu2qfwwEjKC5UVK0W3TxHPPfubSticmmMQWWrH7BLSzocPEJAILIq+TU2ur8ES0IUQxjycoWl51x3crSt39gygk1jKZZdOm8oLmJBAJbXII5K5vkQXtuX3jtivyLTxij8aaFNVXyLR+bRo0xFkwKVmGhA/kJAIIi+PN9QiCZR48VXygjq9PbdiwRY83IsqakebDlSrP5y5a2swajhaV0ieiOyIicbvLoFhExFot0zy7xqeNks9kXSsVi0+ixplFjKODXUwXNTR1jk53k6EFbVJQ5d0SAqwpNuHkHAAGG5BRerHEJhsl3yHbtIJbt8CZji1Lr75jV5W2y7N9qG/7Z0Giy/bLNv9c23BUV8XJKojrkZ4NmrBb5J+8JKyvaLzebpUW7BU2NhukzA1yS5MCezmITR3pgj+WWIaxEErCSQhkuPgFAIPksORUXFx84cODMmTONjY06nU6lUsXGxg4dOnTixIl9+/b11V7Ae+Yhw1mFUvb9zpues2MYc/YA49QZbBfvT7FES69Xb9G0dHzrS03rRaNpR0bvyFCd5YMj2b+nY2yyE5ecsKSlWwYPDVg9jNksOl/mpo1eL7py0dz/lsCU1C3g4hMABIYPklNRUdHjjz9+8uRJp+8yDDN58uQNGzb06xfu3VpDh6Vv/7aMvqLyK8KqG2QyspFRlowsW3SsB5v6sEnjNDZxygzGP1XVvJaW7EWxfqbXiY8fdd1EergokMlJ0NzIWN0/3sjU1RCS081w8QkAAsDbiwEff/zxhAkTOotNRMSy7Lfffjts2LBDhw55uS/wJaHQktHXePs44/gppuGjPItNRPRyXYPrBp9qWm+YQ3eYA/G1K4zzXl+/EDQ3CerrAlMPEdHPo0J0vJ16EwaDR3QCY44DgF95dc2psrLykUcesdlsAoFg5syZd95556BBg2JjY2UymV6vr6urKykp2bp167fffqvT6WbPnn3p0qWIrg9IAyHrotF0zWR23cbKsnvatA+E6hRpjKaZTzNBS7MtLt7fxXBs6mhiGHfBiWwYPMIl3LwDAD/xKjm99tprer1erVZ//fXXeXl57d4dsfvsfgAAIABJREFUMGDA2LFjly5dunPnzrlz59bV1b3xxhtPPvmkN3uEkHLD7CY2cSr5NWuHJTqpN/yo02tttkSxeKxSnioWe7AdN0S8TgGWXzOfYOUKa3Kq8MZ1V40EAktmdqAq6q5w8w4A/MGru3XffvstET333HMdY5Oj6dOnP/XUU0S0Y8cOb3YHoUYh4PX/h2czRz/q9JMuXp1y6drKqtrVNfXLr1cNO3f5N9erGt3dWesqa0KS+0YCgS0+0bf7dc04psD1UAjmnGFsZIhexgs1uHMHAL7lVXK6evUqEU2fPt1ty9mzZxNRaWmpN7uDUDNAJpXwGOsoVy7r0mZ3tbbNulJRYrjpsXyWaHNzy9RL12p82r/HmtrLFtXpNIscS5+srj5y6CVrnyzT7eM6fTc51ThxaiDr6e7Q8wkAfMir5NTS0kJEMTExblsmJSURUXMzrz4l4CVBc6Ow4qqwpsrfnYhVAsHMKDcd1/pIxF2aX7bKbFlSUWVyMtwUEdE1k3lJRVUXSnRLIDBOnObiAg8rFhsLJvtyj/wYby/Q3zGLVdw85ZxAYM4dob9/ISvyw43Lng75CQB8wqveG1FRUQ0NDTU1NXFxca5b1tfXE1FkZKQ3uwM3WFZcckJy5ICguennBSKxZeBg49gJrFLlp33+KSFud5u20eL8JpqA6G8piaKujMH9al1Dm8NA3h0d1Or2tWkLfDeLraVvf+PE6dI931CH/bJiiWHWvQHrG96+sMFDtQMGCa9cFNbVsFYrG6W2ZGR7MOkvOELPcQDwklfJKTs7u6GhYevWrYMGDXLd8vPPPyciDOnkRzab7Mst4nNnHZcxFrO4pFh0+YL+3gesCX7pqZMmEX/YO/XB8sr6DuFJzDD/SEmc1MWI83Wrlk8bHyYnIjINH2lJTJIdKhKWX+HyEysSWbIHmPLH29TuL6n6D1eGJXtAEGvoedBzHAC84VVyuuOOO3744Yc1a9YMHz78jjvu6KzZtm3bVq9eTUQzZszwZnfggrTo+3axyY7Rtsm3fKRdvISVdeGuGX+3KuRFfTNeqWvYomnh8pNcwExRqf6/xLiB0q5ND2JiWT7P6112OTOJZ2ypvXTzHmAMBkFrC8sQq47GHbGeDRefAMAzXiWnZcuWrVu3TqPR3HnnnVOnTp0zZ87gwYPj4+NlMplOp6utrT1x4sSWLVv27dtHRLGxscuWLfNR2XATgaZZ4nIgbKa1RXL0sHHcRD8VEC8S/m9ywurkhDqLxcJSvEgo9miWXAER43YISKIu3f7rElYms8q61p8dui9cfAIAD3iVnGJjYzdt2jRz5kyTybRr165du3Z11lKhUGzdulWtdvMQE3hGVHaa3D2uLy4t8V9y4jBECZ2Me7SnVft+k+a4waC12ZLE4mmxMQ9HqlIE7QOQiGH6SiXnjSbXOxqIcAO+g4tPANAl3s6+Mm3atGPHjo0dO7azBgzDTJ8+/cSJE/n5+V7uCzrDZ24QpkXDGA0BKKYdA8s+VnHjvmvXt7W0XjeZmyzWUr3hles3RpVdfL9J07H9HLWbxwgYonvcPdAH0CV47A4A+PPByMhDhgwpKioqKyvbvXt3SUlJQ0ODTqdTKpVxcXG5ubmTJ0/GryS/4zk+pK+HkXSLJfrt9aovNa0d3zLabL+vrJYxzL03R6UlsdEfNGkqOp/UZX501GCZ1Pe1QtjDzTsA4MNnc0oMGDBgwAA8ARQcLI8pzFipNMDDORLRly1tTmMThyVaWVU7OUKpFgrtC1UCwQfpafOuVDgd8XKcSvH3lIAO5w3hBjfvAMA1b+/WQSiw9O3vvk1WP9cTevjD/2toct2g2Wrd0tzSbuFAqeS7rPT71ZFSh4LjRcJnEuM3pafJAv5TQLjBzTsAcCFw85iC/1hT0ix9skRXL3XaQig05XXaF81PWKKjer3bZj/o9I/Etr9mliQWvZaW/LeUxNMGo8ZqTRaLb5FKhMhMEEC4+AQATnUtORUWFnq5vw0bNni5BXDKMGO24oO3Bc2NTt4TCPRT77LFuhnn3a0bZkuZ0Whh2QyJJJvHQE1am81kczvCADVZOx0xXCkQ3NaVmVsAfAs9nwCgo64lp9dff93L/SE5+QmrUGoffET23dfic2fJYdI3mzraOOVOS58sbzZ+TGd4trr2qO6XC0j9pJKVCXF3uXzGTSkQyAWM3l14ihcJXTcACC5cfAIAR11LTkIh3y85hmHEYrFcLlcqlSzLXr9+veu1QRfJFYa755rGTRJeuci0tpBEYk1KtfZKJ4FXvdk+bm75P5XVlpun4D1vND1cceNxQ+yfEzu9lMUQjVEqvnM3m0q+MtD91gG6ChefAMCua8nJ4uxxJ9fee++9P/zhDz/vrJNhEsGHbFFqW+4IX23tmE7/fyqrLTaWnHUxerWuoa9U8qvOR2BaEhvtOjklikSzMTgTdBPITwBAfn22rqSkZNy4cQsXLqypqSGicePGHT9+3H+7A394vrrOwjqPTZzV1XUmttP7ceNVyoUxnQ4cL2SYV9OSFN5dEgMIMDx2BxDm/PKl1dra+vvf/3748OH79+8noqSkpI0bN+7bty8nJ8cfuwM/uWG2HNG5eTiu1mI5qHXV5sXkhN/GRXf8fxYtEr7bO2WiSuldjQBBgGELAMKZ72+fffTRRytWrKiqqiIikUi0bNmy559/PjLSzZQaEIIuGI3uH40jOmc0TlB12ldJyDDPJyXcr476oElTrDc0W62pEsmdCXHzFDJV5xerAEIfeo4DhCdfJqezZ88uW7Zs79693D/Hjh37+uuv4zpT98VzrhYLjwB0i0z6v8kJ3GuJRBIZGdnc3OxBtzmAkMJdeaqsrAx2IQAQOL65W9fW1vbkk0/m5uZysYm7PVdUVITY1K1lSP47aJPLaJQpEQegGICQlZ2dHewSACBwfJCcPv300wEDBvz97383m81CofDxxx8/d+7cQw895P2WIbgyJOKB3IiXnfcQVwkEBeirBGFv4MCBAwcODHYVABAIXt2tO3fuXGFh4Xfffcf9Mz8///XXXx8yZIgvCgt3tRbLvjZdjcUiZ5hbFfKhcllQZh5ZlRj/ULmrOxG/i49R4uE4ACIiys7O1vOYcQgAujUPk5NOp1u9evVLL71kMpmIKDEx8cUXX1y4cKFPawtTLVbbn6trNzW3WB36Dw2SSV9MSRwV8KlIpkeqVsTHvlTXcPNilrsMdVek6vG42ACXBAAAEESeXC34/PPPBw4c+Ne//tVkMtlvzyE2+USjxXrnlfIPmzTWm7tdnzEY77lasaOlNfAlPZUY98+05CSxY8hmIoSCpxPj/tMrVYBJeAEAIJx07ZrTxYsXly9fvnPnTu6fuD3nc4WVVecMRqdvmWzs0uvV+7NlvcU39chmzCayWFi5H+cwmaeOnB0VcUirO280W4lNF4sLVAqMYAkAAGGoa8lp8ODBRqORiBITE9euXbtw4UKz2azValneA/OoVKou1xg2jun037qcq0Rns71S27AuNYmIGL1ecuywuLSEadEQESuVWfv2M+aNtcX45faZmGEKVMoCHD0AAAhvXUtOXGwiIr1ev2zZskceecRms3VpC/wzVhj6qqXNbZsdLW3rUklYWy3f8hHT+svNO8ZoEJ05JSw7Y5h+t+UWXAUEAADwCw9vuLS0tGi12q7GJnDtqtnstk2j1app0cg/+9AxNtkxVqv8623Cq5f8UB0AAAB08ZrTX/7yFz/VAUQk5NdMeXg/o+386pTNJvvua+0jSwn9kAAAAHyta8np2Wef9U8ZQETUXyolcvP0XJpYpD57ynUbQVOj8Hq5tXcfn1UGAAAAROSr2VfAJ2ZFRXR6PP7bPWyuSMjwmO5NWI2JtAAAAHwPySmE9JNKFsaonb/HEBElikTLeV4lNJl8VRUAAADYITmFlv9NTpjYyTRwMULhe+mp0ZERfLbDRkT6tC4AAAAgQnIKNRKG+TA99bmk+HjRL/3FxQxzT1TEd1npw+QyW3SsLaqT61J2DGPN6OvfQgEAAMKSVzP+gj8IGWZpXMxvYmNOGwyVZkukUDBYJo0S/hKkTLfly3Z96WIL5gGDbJFR/q8UAAAg7CA5hSgBQ0PksiHOZvg1DxkmvHpJfL7U6Yq26BjDpOn+LQ4AACBc4W5dN8QwhrvnmkbkdRyxydInS7fgYfLnHHYAAADhDNecuieBwDhhqnnYSHHZGaa+jrFabOoYS3Z/a0qai5UYnVbQ1Egsa1NHsypePc0BAADAEZJTN2ZTRxvz8vm0FFZVSot2CyuuEjdvIMNYU9KMYydae6X7t0QAAICeBXfrej7x6ZOKj94Rll8h+3TLLCusrFBs2ij56UhQSwMAAOhmkJx6OGFlheyb7WS1OnmPZaV7dokunQ94UQAAAN0VklPwsTotW11FLZpfrgn5jnTPLrLZOt83K92zyx/7BQAA6JHQzyl4WFZcdob56YipqpKIxESiyChzzjDTyNGsWOyTPQiaG4VVbiawEzQ1Cqpu2FJSfbJHAACAng3JKUhsNtlXX4hLSxyXMS0aycG9wnNn9fcu8Mn0KYK6Wj7NhPW1SE4AAAB84G5dcEj3ftsuNtkJ62vln29y3jOpixjuPp3be3FWi/f7AgAACAdITkEgaKiXFB9z0UBYUyU+ddz7Hf08wx3joglLRGx0jPf7AgAACAdITkEgOnvKVa9tIiKSnD3l/Y6sicnu7voxrEyGUZ0AAAB4Qj+nIBDWVrttw9RUE8sS4+p6kXsMYxxTINu53UUT021jWOF//xuwrLD8qujyBaZFw4jF1vhE84DBbARGGwcAAPgZklMQMBb3/YoYm41sNhIKvdyXOWeYsPK6uKTY6buWfgNNI2/nXgtaNLLtm4U3rtvfFRFJ9u8xj8435o31NsMBAAD0CEhOQcBGRrlvo1J5H5s4hml32eLiJYeKGKPhl+2LxeZRY4x5+VwkYlo0ivf/w2jbbi6CGKtFcmAv09ZmmHKnT4oBAADo1npacjp//vz27dvPnDnT1NQkkUjS0tJGjx49Y8YMuVzermVDQ8Nnn312/Pjx+vp6sVicnp4+ZcqUSZMmMf6/uGLJzBadPum2jc/2xzCmEXnmIcNFVy8J6uuIWFt0rCUji5X98pnIv/6ifWyiX7qWi0/8aIuJMQ8exkqlPqsKAACgG+pRyWnnzp1vvPEGy7L9+/cfOnSo1Wo9ceLExo0bd+3atWbNmri4OHvLa9euPf300xqNRqlU9uvXz2AwlJWVlZaWnjhxYsWKFf4OT+bsAZK4BEF9p4MtsUKhadQY3+6UlUjM/QZSv4Ed3xLcqBSWX3W9unT3Lum+7y19skxjJ1rjE3xbGwAAQHfRc5JTTU3Nv//9b5ZlV6xYUVBQwC3U6XQvvPDCmTNn3nrrrZUrV3ILbTbbyy+/rNFoxo8fX1hYKJFIiOjatWvPPPNMUVFRTk7OtGnT/FurQKC/e67io3cYg97JuwxjmHqXTR3t3xociK9e4tXOahVdOi+8esl452zzgEF+LgoAACAU9ZxRCQ4fPmyxWLKysuyxiYgUCsX8+fOJ6OjRo2azmVt4/Pjxy5cvx8TELF++nItNRJSenv7oo48S0ebNmwNQrS0uXvfgI7bUXu2WsxGR+nvmWwYPDUANdkxbCxGPATO5xlar7KutghtuJnUBAADokXrONSetVktEjrfkONwSq9VqNBrFYjERHTp0iIjGjRsnvnl6uDFjxrz22mvV1dWXLl3Kysryd8G26FjtrxYrG+vF5VepVWMWCI0JSdas7F/GCAgUViwhcj1g5s2sVtneXboFD/utIgAAgBDVc5JTamoqEd24caPd8pqaGiKKiopSqVTckkuXLhFR//7927UUCoWZmZmlpaWBSU5ERAxDvfuI+g8kIkNbm8VgcLuGP9iSuzxpnbCyQqBp/nmMcgAAgLDRc5LT7bffvnHjxoqKih07dsyYMYNbaDKZuLtvd911l71ldXU1EcXHx3fcSGJiYmlpacf4xW2qqKio4/I+ffokJiZ6XLbwv0MPiEQiaZCeXGNuGUy7v6GOz9a5JG1utCV48oOLRCIiEovFQh8NuxDiQuEQB1i4HWLu56VwOsTckQ2fQ+x4Ftv7eEDY6jnJSSKRvPDCCy+++OK//vWvPXv2ZGRkGI3GkydPtrW1zZo167777uOasSxrMBiISKFQdNwIt1Cvd9JxW6vVPvXUUx2XL168uLCw0Pv6ZTKZTCbzfjuesc2cY/5oY5dWkYtEAi+GF1cqlR6v201JpdIw+Vrl4BD3eOF5iNt184Aw1HOSExElJiZOnTr1448/Pn/+/Pnz57mFw4cPHzlypH2gAbPZzLIsOfyZ6Ig7JYxGY6BKDhWC3BGitjbLjq1uJ9SzY2Ji/VoSAABACOo5ycloNK5aterChQtjxoy5//77U1NTjUbjmTNn3n333aeffnrhwoX33nsvEYnFYoZhWJa1OJsCxWQyEZHTvxqlUumcOXM6Lh80aJDBi/5JIpGIy3Bms9lqtXq8HR8Ykcek9mKLdjMXy8hkdtM4ItIYl0Ae/eACgUAikZhMJhvvlNathdAhDpSwPcQWi8XpL5aeJ5wPsdls7ji0MoSVnpOcNm3adOHChWHDhv3xj3/klohEolGjRvXu3XvZsmUffPBBXl5eWloawzByuVyn0+l0uo4b4R7Qc3oJWqFQrFq1yumu6+vrPS5bqVRyJ6TRaPQmgflGRBTNuIdYVlq0W3L0oIuGhrx8s1br2U4kEolEItHpdGHyHWM/xCaTyemN4J4n3A6xQqGwn8VhcojFYnE4H2IkpzDXc8ZzOnjwIBE5DubESUpKysjIsFqtx44d45akpKTQf5+5a6eqqoqIevVqP8xSeGEY49gJLqZ/sdwyxDz01kBWBAAAECJ6TnLiriE5feqB+1vBfkUnOzubiMrKyto1MxgMly9fJqJ+/fr5tdRuQCDQz77PdNsY9uYHZ1ix2DR2ov7OWeT/2f0AAABCUM+5W5eYmKjRaC5cuJCfn++43GQyVVRUEFFycjK3JD8//+uvvy4qKlq0aJFj0tq7d6/Vas3MzOSGhgp3QqFx3CTTiDzRpQuCpgZiGGt0rDWrH4vL1AAAEMZ6zjWnCRMmENGOHTtOnz5tX8iy7Icfftja2qpSqUaNGsUtzMnJGTRokEajWbdunf1CVGlp6TvvvENECxYsCHTpIYxVKM05ucZxk4xjJ1oGD0VsAgCAMNdzrjndcccdZ8+e3b9//6pVqwYNGpScnGyxWMrKyqqrq6VS6YoVKxwHcHriiSdWrVp16NCh4uLiPn36aLXa8vJyIpozZ449YAEAAAC0w3CDG/UYhw8f/v777y9cuNDS0iIWi+Pj43Nzc+++++6kpKR2LVtbWzdv3nzkyJHa2lqpVNq3b9+77rrLs9jk5bN13GMabW1twX+2LiAkEklkZGRzc3OYPJVjP8RarTZMHrwKt0OsUCi4P8zC5xCLxeKoqKiwPcQdJ0iFsNJzrjlxRo8ePXr0aD4tIyIiFi9evHjxYj9XBAAAAD1HT0tOAEHBaJpFl84LmpuIYWxxCZa+/Vi5k+l9AACgu0NyAvAKY7VId+8SnzruOHENKxKb88YY88Zi+AYAgB4GyQnAc4zVKv/kfeH18vbLLWbJgb2Cxkb9nbOCUhgAAPhJzxmVACDwJAf2dIxNdqKzp8QlxYGsBwAA/A3JCcBDjMEg/umo6zbSw/upZz2+CgAQ5pCcADwkKr/CWN08ks20aJja6sDUAwAAAYB+TqGOJfqmpe2LltZzBqOFZftKJTMiI2ZHRQjR9TjYGE0zr3ZNjdQn08+1AABAgCA5hbR6i/XRihuHtDr7klKjaXtL24b6xnd6p6ZLxEGsDVgRr9OHFeEwAQD0HLhbF7rabLY5VyscY5PdaYNx5pXymvAYvTdk2RLaD0zvBMNQUrL/awEAgABBcgpdL9bWlxqMnb17w2z5U1VtIOuBdqwpabboGNdtLOmZpIoITD0AABAASE4hysCy7zZqXLfZpmmtMuOyU/AwjHHidBdjXbIisWnClEBWBAAA/obkFKKO6/Q6hzGpnWKJDjq7lwcBY8nsa5h8BwmcnEesWGKYda81LiHwVQEAgP+gh3iIarC6iU2cOovV35WAa+bcEbakFMmBvaJrl7kJWFiRyJI9wDRmvNt7eQAA0O0gOYUo9c+XMVgiV6MPRAtx1TD4rEkp+nsXMEYj06IhhmHV0TwfuwMAgG4Hv99D1DCFTMIwJnejT+cpFQEpB9xjpVI2HvfmAAB6OFyxCFEqgWCeOtJ1mwkqRR8M6QQAABBASE6h6+nE+F6dB6NokXBtCo/xhAAAAMB3kJxCV5xIuLlPr/4yace3UsXiT9PTMnDBCQAAILDQzymkZUjEuzPTP2jWbNW0XjAarUQZEsndkaqHY9QKZ0/CAwAAgF8hOYU6iYB5OEb9cIw62IUAAAAA7tYBAAAA8IbkBAAAAMAXkhMAAAAAX0hOAAAAAHwhOQEAAADwhWfrALoBluii0VRrscSIRNkSsYhxNZshAAD4D5ITQEgz2dg3GxrfamyuNlu4JTEi4UPR6ifiY1QY0wsAIOCQnABCV6vV9qtr14/o9I4LGy3W9XUN37S2fZKelizGKQwAEFD4mxUgdC2rrGoXm+zKDMaF5ZUWlg1wSQAAYQ7JCSBE7W/Tfd3S5qLBCb3hU01rwOoBAABCcgIIWZ9pWty3adYEoBIAALBDcgIIUWVGo9s2Zw3u2wAAgA8hOQGEKKPNfR8mE/o5AQAEFpITQIjqI5G4bZMuFgegEgAAsENyAghR0yJVbttM59EGAAB8CMkJIETNjYzIkrq67BQjEv46Jjpg9QAAACE5AYQsiYB5u1dKtEjo9F0Zw/zftE7fBQAAP0FyAghdA2XSbzLT85WKdsuHyGVfZvYeq2q/HAAA/A1TNwCEtAyJ+POMXqcNxoNaXa3FqhYI8pTyEQo5pvwFAAgKJCfwAUFTg+jCOUGLhmXIFhtvyR7AKtFz2ZcGy6SDZdJgVwEAAEhO4B3GbJJ+97X4zClyGFiI3b3LdNsY0+3jiMGVEQAA6FGQnMBzjMUs/3ijsPpG++VWi/TQPmFzk/7OWQhPAADQk6CHOHhOuu/7jrHJTnT2lPj0iUDWAwAA4G9ITuAhRq8Tn/zJdRvJoSLC9CAAANCDIDmBh4RXLpHV6rqNoEUjaKgLTD0AAAABgOQEHhK0ang1a2nxdyUAAAABg+QEnhLxmmuWFeMpBAAA6DmQnMBD1sQk940EAltcov9rAQAACBAkJ/CQNaWXTR3juo0lqx8rlwemHgAAgABAcgJPCQTGSdNdDNfESqXGgkmBrAgAAMDfkJzAc5bMvoYpM0jg5H8RK5PpZ99ni44NfFUAAAD+g9674BXz0OG2pGTJwX3Cq5cYq5WIWKnU0m+g8fYCNjIq2NUBAAD4GJITeMuamKyfcz9jsTAtzSQU2VQRJBQGuygAAAC/QHIC32BFIjYmLthVAAAA+Bf6OQEAAADwheQE4BcmG1tnsZpsmLYPAKBHwd06AF+ysfS5puU/jc0/6fQ2IgHRbRGqJ3qlzkvArUwAgJ4AyQnAZ/Q2dsn1G1+3tNmX2IgOt7YdPnvus7qGN3unBLE2AADwCSQnAJ95orLaMTY5+rSuXsba1iXFB7gkAADwLfRzAvCN/W26LZoWFw3eq288qtMHrB4AAPAHJCcA3/iwWeO+TZP7NgAAEMqQnAB844Te4LZNMY82AAAQypCcAHyjzWZz38bqvg0AAIQyJCcA30gRu37eguXRBgAAQh2SE4BvTFAqXb7PENGkCFVgigEAAD9BcgLwjUdjo1UCVyeUWihcFB0VsHoAAMAfkJwAfCNeJHwtLVnIME7fFTHMW5m9o0XCAFcFAAC+heQE4DN3Rare652a1KEzUy+p9Ksht9yhxgUnAIBuD/1VAXxpSoTyaHbmly2th7S6JqstRiiYGBM9PzVZLhBotdpgVwcAAN5CcgLwMbmAmaeOnKeO5P6pVCrlLvs/AQBAN4Jf6AAAAAB8ITkBAAAA8IXkBAAAAMAXkhMAAAAAX0hOAAAAAHwhOQEAAADwheQEAAAAwBeSEwAAAABfSE4AAAAAfCE5AQAAAPCF5AQAAADAF5ITAAAAAF9ITgAAAAB8ITkBAAAA8IXkBAAAAMAXkhMAAAAAX6JgF9ATSKVSj9cVCoXcC5FI5M12uhGRSEREYrHY/rP3bGF7iCUSSZgcYu7nJRzinsvxLJZIJMEtBoKOYVk22DUAAAB0DzabTSDA7ZqwhmtOPtDc3OzxunK5nPsjVa/XG41G3xUVusRisVKpbG1ttVqtwa4lEHCIezyZTCaTySicDrFIJFKpVGF7iNVqdbArgmBCcvIBi8Xi8bo2m417YbVavdlON8L9uRY+P6/9ENtstjD5kXGIezyGYQiHGMIVLjkCAAAA8IXkBAAAAMAXkhMAAAAAX0hOAAAAAHwhOQEAAADwheQEAAAAwBeSEwAAAABfSE4AAAAAfCE5AQAAAPCF5AQAAADAF5ITAAAAAF9ITgAAAAB8ITkBAAAA8IXkBAAAAMAXkhMAAAAAX0hOAAAAAHwhOQEAAADwheQEAAAAwBeSE3TCag12BQAAACFHFOwCIJSwrOhsiaSkWFBVyVgsrFxh6ZNlHnW7NSEx2JUBAACEBCQn+BljMMi3fSq8duWXJXqduLREXHbaOHaC6bb8INYGAAAQInC3DoiIyGaTf3FTbPoFy0qLdouLjwW8JgAAgJCD5AREROKzJcJyZ7Hpv6T7vmd02oDVAwAAEJqQnICISHLquOsGjNkkLj0dmGIAAABCFpITELGsoKrSbStBZUUAagEAAAhlSE5AjNlMNpv7ZkZjAIoBAAAIZUhOQKxEwool7pupIgJQDAAAQChDcgIiImufTB5tMgJQCQAAQChDcgIiItPI0a6vflvEAAAY0klEQVQb2KLU5n63BKYYAACAkIXkBERE1tReLsa6ZIUi/Yx7SCgMZEkAAAAhCGOIw8+MYyewUonk4D7m5hnr2Ci1/q45tpS0YBUGAAAQOpCc4L8YxnRbvnlgjuRsieDGdcZktKkiLX0yrQMHsUL8PwEAACBCcoJ22MgoYx6mqAMAAHAO/ZwAAAAA+EJyAgAAAOALyQkAAACALyQnAAAAAL6QnAAAAAD4QnICAAAA4AvJCQAAAIAvJCcAAAAAvpCcAAAAAPhCcgIAAADgC8kJAAAAgC8kJwAAAAC+kJwAAAAA+EJyAgAAAOALyQkAAACALyQnAAAAAL6QnAAAAAD4QnICAAAA4AvJCQAAAIAvJCcAAAAAvpCcAAAAAPhCcgIAAADgC8kJAAAAgC+GZdlg1xDWDhw4UFxcTEQTJkwYPHhwsMsB3zt06NBPP/1ERAUFBUOGDAl2OeB7P/zww7Fjx4goPz9/2LBhwS4HfO/o0aNHjhwhojFjxgwfPjzY5UCQiYJdQLg7duzYBx98QEQpKSlITj3STz/99O677xJRQkICklOPVFxczB3imJgYJKce6cSJE9whjoyMRHIC3K0DAAAA4AvJCQAAAIAvJCcAAAAAvpCcAAAAAPhCcgIAAADgC8kJAAAAgC+M5xRkRqPRaDQSkUwmk0gkwS4HfA+HuMfDIe7xTCaTwWAgHGIgIiQnAAAAAP5wtw4AAACALyQnAAAAAL6QnAAAAAD4QnICAAAA4Asz/gZNQ0PDZ599dvz48fr6erFYnJ6ePmXKlEmTJjEME+zSwFssy86ePbuzxy+mT5++dOnSAJcE3mNZ9quvvnr77bdNJtOqVavy8vKcNsOp3X25PcQ4tYGQnILl2rVrTz/9tEajUSqV/fr1MxgMZWVlpaWlJ06cWLFiBX7Ddnc6nY5lWYZhsrKyOr6bkJAQ+JLASw0NDa+++mpxcbHrZji1uy8+hxinNhCSU1DYbLaXX35Zo9GMHz++sLCQGx3k2rVrzzzzTFFRUU5OzrRp04JdI3hFq9USkVwuX7duXbBrAR84evToK6+8otVq77nnnoMHD9bW1jpthlO7++J5iHFqA6GfU1AcP3788uXLMTExy5cvtw+qlp6e/uijjxLR5s2bg1od+AD361WpVAa7EPCNffv2icXi55577uGHHxYIOv21iVO7++J5iHFqAyE5BcWhQ4eIaNy4cWKx2HH5mDFjpFJpdXX1pUuXglQa+Ab361WhUAS7EPCN3NzcV199NTc313UznNrdF89DjFMbCMkpKLjfnv3792+3XCgUZmZm2htA94U/THuYKVOmREVFuW2GU7v74nmIcWoDoZ9TUFRXVxNRfHx8x7cSExNLS0tv3LgR8KLAl+x/mFZUVOzdu7e8vNxqtSYkJIwcOfLWW28NdnXgLzi1ezyc2kBIToHHsiw3c6TT673cQr1eH+iywKe4X6/nzp0rLCx0fID5q6++ysnJWblypUqlCl514Bc4tcMBTm0gJKfAM5vN3PkmEjn58LnuEdy869B9cb9etVrtzJkzp0yZkpKS0tbWtnfv3o8++qikpGTdunXPPPNMsGsEH8OpHQ5wagMhOQWeWCxmGIZlWYvF0vFdk8lERFKpNOB1gS9Nnz599OjRSqUyLi6OW6JWq2fPnp2Wlvb888//+OOPFy5cyM7ODm6R4Fs4tcMBTm0g9BAPPIZh5HI5Eel0uo7vovthz6BWq9PT0+2/W+1GjBiRmppKRCdPngxGXeBHOLXDAU5tICSnoEhJSSGimpqajm9VVVURUa9evQJdEwQKd/Tb2tqCXQj4Hk7tcIZTO3wgOQUBdy23rKys3XKDwXD58mUi6tevXxDKAt9hWbapqclsNnd8q6mpiYj4PP8M3Q5O7R4PpzYQklNQ5OfnE1FRURHX9cFu7969Vqs1MzOTu+oL3VdhYeGiRYt27tzZbvnFixe5EX1ycnKCURf4F07tHg+nNhCSU1Dk5OQMGjRIo9GsW7eOe4yZiEpLS9955x0iWrBgQTCLA18YN24cEb333ns//PCDfeGFCxdeeukllmWHDBnSt2/f4FUH/oJTu8fDqQ1ExDiOSAEBU1NTs2rVqrq6Orlc3qdPH61WW15eTkRz5sxZvHhxsKsDb5nN5jVr1vz0009EFBMTk5CQ0NjYWFdXx7Jsenr6888/Hx0dHewaga/6+vo1a9bY/3nt2jWz2ZyUlGQfuWf+/Pm33XYb9xqndnfE/xDj1AZCcgqi1tbWzZs3HzlypLa2ViqV9u3b96677ho1alSw6wLfYFl27969u3fvvnz5sk6nk8lkvXv3zs/PnzZtmn0uWOgWqqqqlixZ4qJBYWHh1KlT7f/Eqd3tdOkQ49QGJCcAAAAAvtDPCQAAAIAvJCcAAAAAvpCcAAAAAPhCcgIAAADgC8kJAAAAgC8kJwAAAAC+kJwAAAAA+EJyAgAAAOALyQkAAACALyQnAAAAAL6QnAAAAAD4QnICCDlarfb3v/99enq6RCKJiIj4xz/+EeyKnHBaZLeovLsYP348wzBqtTrYhQDATUTBLgDC3cGDB7dv375nz57Kysr6+nqBQBAXFzdw4MBJkyYtWLAgLS0t2AUGwQMPPPDFF19wr81mc319Pf91A/Z5Oi3Sm8oBALoFhmXZYNcAYerkyZNPPPHE3r17O2sgkUiWLl3617/+VSaTBbCuIKusrOTyTUxMzPr16wcOHKhWq7OystyuGMjP02mRMpnMs8rBqfHjx+/bty8qKqq5uTnYtQDAL3DNCYLjiy++WLBggU6nIyKBQJCXlzdmzJiEhASLxXLlypVvv/32ypUrJpPplVdeOXz48DfffBMVFRXskgPkypUr3Ivf/OY3Dz74IM+1Avx5Oi3ywIEDHlQOANC9IDlBEBw5cmTevHlms5mIZsyYsX79+nZXJliW3bx589KlS+vq6o4cObJw4UL7PaAeT6PRcC969+7Nc5XAf55Oi/SgcgCAbgc9xCHQTCbTggULuK/5JUuWbN++veMNHYZh7r333kOHDsXGxhLRtm3bwic52W+gC4VCPu2D8nk6LbKrlQMAdEssQGD95z//4f7v5ebmmkwm143/9a9/CYXCiRMnfvnll9wSLiIQ0axZs5yuMnToUCJKT0+3L7HZbAzDENFjjz3Gsuy5c+d+/etfZ2RkyGSymJiYMWPGvPXWWzabreOmysvLV65cOWLECLVaLRQKlUpl//79H3744UOHDnXpR66vr3/uuefy8vLi4uLEYnFsbOzIkSP/9Kc/3bhxw7HZ7373O6cn6R//+EcXG/fy8/RVkW4r12q169evnzBhArf9xMTE0aNHv/jiixqNprNqPVilHY8PfVf3rlKpiGjZsmUsy37wwQc5OTlyufzRRx/lU+T7779fUFAQExMjk8kyMzOXLFly7tw5lmULCgqIKCoqquMqZ86cWb58+ZAhQyIjI0UikVqtvu2225577rn6+nrHZhMnTiQihmGuXLnS2d7z8vKISCqVNjU18akWAJCcINBGjhzJfa1u377dbWOLxVJbW+u4xIPkxLKsXC4novnz5+/bty8yMrLjd/zdd99tsVgcV9mxY4dSqewsE6xatYrnz+uiU5FCodi0aZO9pWfJycvP01dFuq78+PHjnd3CS01NPXz4cMeSPFjFKQ8OvQd7j4+PJ6LFixfv2LHD3nLu3Lmua7PZbE47hKlUqm+//Xb8+PHkLDmtX79eJHLe0SI5OfnkyZP2lhs3buSWP//8804LKC8v55LlnDlzeH2aAIDkBAHW0tLC3cpJSEiwWq0ebMGz5MRdEhg/fnzv3r0zMjI2bNiwd+/eH3/8ccOGDdx3HhG98MIL9vYNDQ1ckoiKivrrX/965MiRS5cuFRcX//Of/+zbty/X/osvvnBb7cmTJyUSCRHJ5fJnn3321KlTtbW1paWlL730EjdOj0Ag2L9/v/1H0+v1W7Zs4bb/xhtv6PV6vV5vNps72773n6dPimxtbW1tbe2s8vLy8ri4OCISiURPPvnkkSNHqqurS0pKXnjhBS7WREdHX7582bEkD1bpTFcPvWd7T0lJIaL58+cPGjRIJpPNmzfv8ccfX79+vevaXnvtNa6AjIyMTz/9tLKysqKiYsuWLbm5uYmJicOGDeuYnHbv3s2tEhMT8+KLLx49erS0tHTnzp0LFy7klmdlZdkvPba1tXE/fnZ2ttMC1q1bx621ZcsWPh8mALBIThBg33//PfebeubMmZ5twbPkZL+gkpKS0u6iy+nTp6VSKRGp1Wq9Xs8ttP+x/tFHH7XbfnNzc3JyMhFNmTLFbbVjx47ltrNjx452bx08eFAgEBBRbm6u4/Lt27dzq7z11ltut+/95+nDIjurfO7cudzyrVu3ttv+7t27ue3fd999Xq7Sma4ees/2zl2gyszMjIyMdLzq44LFYklKSiIihULR7m5aa2vrwIEDuRraJac77riDW75nz552G7zvvvs6lr148WJu4cGDBzvWMHr0aC4IGo1GPjUDAIvkBAH2/vvvc7/H//CHP3i2BS+T0+uvv95xFfvf69988w23ZM2aNdwSrsdJO0eOHNm3b9/169ddl1paWsptZOrUqU4bzJo1i2tQXFxsX9il5OT95+nDIp0uvHr1Khc1OrsfNGfOHCISiUSNjY0er+JCVw+9Z3tPT0/ntvO3v/3NbUmcffv2cas47Q71ySefOE1Oy5YtmzZtmtOD9fXXX3OrrFy50r5wz5493MIlS5a0a19RUeHYCQwAeMKzdRBQTU1N3ItgzSlx7733dlw4efJk7sWxY8e4F4mJidyLf//73x3bjxo1aty4campqa73Zb+xwn3XdjRjxgzuxf79+93U3QnvP09/F7l7926bzUZE9isi7cyePZuILBaL/Tveg1X44Hnovdz7/fffz7OeI0eOtKvB0YwZM5w+orhhw4adO3d+8803Hd+y30duaGiwLywoKOjTpw8Rbdq0yWg0Orb/7LPPWJYlIgy+BdAlSE4QUNxf80RksVgCv/eUlJSEhISOy7Ozs7kXly9f5l7MnDkzOjqaiF566aVx48Zt3Lixrq6uq7srKSnhXgwePNhpg0GDBnEvzpw509WNc7z/PP1dZHFxMfdCoVBcdcae+c6ePevxKm7xP/Te7F2hUNgvPrl1/vx57oXTYdYVCgWXePizDw1vtVrtCxmGeeihh4ioubl527Ztju0//fRTIurTp09+fn6XdgQQ5jASJgRUTEwM98Lxz+KAsV9JaofrDkxE9mku4uLitm7dOnfu3Pr6+v379+/fv59hmJycnKlTp86dO5d7kNst+89o74ncDje6EhE1Njby/ykcef95+rtI+/ZnzpzpumV1dbXHq7jF/9B7s/fOPkOn7NcLuYzeUWxs7KVLlzou12q177zzzs6dOy9dulRTU+P2uCxatOiFF14gonfffXfevHncwsrKysOHDxPRAw88wN2zAwCecM0JAsr+pPeJEycCv/fORhngniwjIsfbGePGjbt8+fLatWsHDBhARCzLnjp16h//+Mfo0aNHjhxpv9XiAjcXCjlcDGjHvtzesqu8/zz9XaRWq+XZsrW11eNV3OJ/6L3Ze5fumer1+nY1dFabo2PHjvXv37+wsPDLL78sLS1tbGyUyWRRUVFRUVFOx1wgoqysLO6q0jfffFNbW8stxK06AI8hOUFADR8+nPs+OHr0KP+vPV+x9y5vx2QycS+4Z87tIiIinnzyydLS0gsXLrz22mszZ85UKBRE9OOPPxYUFNh7CHXG/m3dWeawf3dyj457wPvP099F2tcqKSlx3eny3Xff9XgVt/gfen/s3SnusT7HGtrpeEQaGhruvvvuyspKIlq8ePGePXt0Op1er29ubm5ubnZxO3XRokVEZLFYPv74Y24Jd6vu1ltv5f4wAAD+kJwgoGQyGffnr8Fg4PnF8+STT77zzjv8+/G0tLR09lZnt7Tq6+u5F/Y7U+307du3sLDwiy++qKmpefbZZxmGMRqNTzzxhOtK7HeCOusjZV/e2X7d8v7z9HeR9t5F3Pe9n1Zxi/+h98fenbI/9Ge/bdfOjRs32i157733ampqiGjFihVvv/32+PHjHbO+wWDobF/33Xcf13LTpk1EVFFRcejQIcIFJwCPIDlBoC1dupR7sXr1are9c3bu3Pn3v//94Ycfnj9/PrdEKBRy3TKcXiPR6XTl5eWdbe3KlSv2KyiOLl68yL2wP53UGZVK9Ze//IX7C76kpMTeOcap3Nxc7kVnt9LsvbO5kRQ84+Xn6e8iueEcyaFDtD9WcYv/offH3p2ydwy31+Cotra2Yz8qe+/1//mf/+m4yvHjxzvbV2RkJPdI4OHDh69fv/7xxx+zLCsUCn/1q195VjxAOENygkCbPXs29+VUU1Mzb948F91Kjh49umDBAiJiGGb58uXcQoZhuD/Wr1692nGVzZs3Oz5Y1I7VarWPeePIft+NGxjQZDJt3br1z3/+84EDB5xup3///twL151zJ02axIU8++Da7din3eXmF/OMl5+nv4ucNGkS93T9Bx984LTB8ePHX331Vcf04MEqbvE89H7au1O33nor9+K7777r+O7mzZs7Lmxra+NedOzSxLLs+vXr7a87rsvFfZZlN2/e/NFHHxHR5MmTO+s4DwCu8Bz3CcCHzpw5w3UYIqIhQ4Z0HN3YYDC8/vrr9q+HdhO32R9tO3HihOPy69evp6amclN6dTYSZk5OjlardXzrwoULXDHJycncbCEWi4V7SGrEiBGtra3tajObzdxUrBEREW5HXp4+fTq3346TytmH5Jk8ebLj8i6NhMnx8vP0VZFuxxB/44032m2/ubl5+PDhRBQTE9PW1ubNKp3p0qH3eO/cYARDhw51W4+dwWDgjohcLm834GpVVZV9tDDHkTAff/xxbuHmzZvbbW3FihXJyclcCL777rs77s5qtXLbtF/reu+99/hXCwB2SE4QHEVFRY4PIuXk5Pzud79bu3bt2rVrlyxZws0CxlmyZEm72exffPFF7q309PR33nmnuLj4xx9/fOWVV5KSknJzc7mHyZ0mp7y8vISEhBEjRmzbtu369evcbYu0tDRua6+++mrHXQwYMODVV189dOjQ+fPnT5w4sWnTJm4eVuI3bPf58+e572a5XL5mzZqzZ8/W1dWdPn16zZo1XNdshUJRVlbmuIoHycnLz9NXRXZWeUVFBffgPcMwjz322IEDB65du1ZcXPzmm2/ah1Ny/PA9W6UzXT30nu3dg+TEsuyzzz7LbS0pKenNN988fvz40aNHX3vttbS0tLS0NG6ETMfkZL86lZqaunXr1rq6uqqqqq1bt44bN46Ivvrqq169ehFRRETEkSNHOg6w/sc//tH+30CpVPLJnQDQEZITBM358+ft41M7lZiY+Pbbb3dcUafT2XvnOOrdu/f58+e5G1LJycmOq3Bfn1OnTt2xY4f98oyjBx54wDFP2Gy2xx57zEVt999/P8+pvoqKijrrWx0fH3/gwIF27T1LTt58nr4q0kXlxcXF9pjSjlAofOaZZzqW5MEqTnX10Hu2d8+Sk8lkmjZtWsddRERE7Nmzh+uEpFAoHFfh/nt3LOnNN99kWfa3v/2t4/J2u3McuvPBBx/sUqkAYIfkBEF29OjRlStX3nbbbampqVKpVKlUZmRk3Hvvve+++267eyuOWlpannnmmcGDB8vlcpVKdcsttzz11FM1NTUsyy5ZsoSI1Gq1Y3vu63PChAksy549e/axxx7LzMyUyWQxMTFjx47duHGj070UFRU98sgjAwcOVKlUAoFAqVQOGDBg0aJFu3fv7tLP2NTUtHr16tGjR8fExIjF4ri4uPz8/L/97W8ajaZjY4+TE8ezz9MnRbquXKfTvfLKKxMmTIiPjxeJRCqVavDgwYWFhadPn+6sJA9W6cizQ9/VvXuWnFiWtVqtb7zxxujRo9VqtUwmy8jI+PWvf81d4fvNb35DRAKBoF37DRs2jBgxQqlUikSitLS0xYsX229bNzY2zp8/PyYmRqVSFRQUdNzdyJEjuWO0c+fOrpYKAByGddaXEKCHUavVGo2moKBg7969wa4FAgqH3tFDDz30/vvvp6SklJeXO50XDwDcwrN1AABhobm5mXuCctGiRYhNAB5DcgIACAsvv/yyTqcTiUTtukMBQJcgOQEA9HxHjx5du3YtES1atIh7BA8APCMKdgEAAOAvZ8+eNRgMO3fuXL16tdFojIuLW716dbCLAujekJwAAHqsQYMG2V/L5fJPPvkkKSkpiPUA9AC4WwcA0GNx46NGR0fPmTPnxx9/nDBhQrArAuj2MCoBAAAAAF+45gQAAADAF5ITAAAAAF9ITgAAAAB8ITkBAAAA8IXkBAAAAMAXkhMAAAAAX0hOAAAAAHwhOQEAAADwheQEAAAAwBeSEwAAAABfSE4AAAAAfCE5AQAAAPCF5AQAAADAF5ITAAAAAF//PwXdx+gzg/LsAAAAAElFTkSuQmCC\n"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%%R -i df -w 10 -h 10 --units cm -r 200\n",
+ "ggplot(df, aes(x=cups_of_coffee, y=productivity, color=gender)) + geom_point() + \n",
+ "geom_smooth(method=\"lm\", se=TRUE) + ylab(\"Normalized Productivity\") + xlab(\"Cups of Coffee per day\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/extra/Getting_Started/jupyterlab-overview.png b/extra/Getting_Started/jupyterlab-overview.png
new file mode 100755
index 0000000..6618e53
Binary files /dev/null and b/extra/Getting_Started/jupyterlab-overview.png differ
diff --git a/extra/Getting_Started/scroller.py b/extra/Getting_Started/scroller.py
new file mode 100755
index 0000000..82de8e8
--- /dev/null
+++ b/extra/Getting_Started/scroller.py
@@ -0,0 +1,57 @@
+def scroller(index, quantity, timerange=timedelta(days=0), startdt="", enddt=""):
+ print("Starting to scroll", end='')
+ # Retrieve the datetimes, note that timerange has a higher priority
+ if timerange.total_seconds() > 0:
+ now = datetime.utcnow().replace(tzinfo=pytz.UTC)
+ startdt = (now - timerange).isoformat()
+ enddt = now.isoformat()
+
+ # search the first page and write the result to data
+ response = es.search(
+ index=index,
+ body={
+ "query": {
+ "bool": {
+ "must": [
+ {"range" : {
+ "phenomenonTime" : {
+ #"gte": "2018-02-20T09:08:34.230693+00:00",
+ "gte": startdt,
+ "lte": enddt,
+ "time_zone": "+01:00"
+ }
+ }},
+ {
+ "match_phrase": {
+ "Datastream.name.keyword": quantity
+ }
+ }
+ ]
+ }
+ }
+ },
+ scroll='10m'
+ )
+ data = [[row["_source"]["phenomenonTime"], row["_source"]["result"]] for row in response['hits']['hits']]
+
+ # Append new pages until there aren't any left
+ while len(response['hits']['hits']):
+ print(".", end='')
+ # process results
+ # print([item["_id"] for item in response["hits"]["hits"]])
+ response = es.scroll(scroll_id=response['_scroll_id'], scroll='10m')
+ data += [[row["_source"]["phenomenonTime"], row["_source"]["result"]] for row in response['hits']['hits']]
+
+ # Convert data to a DataFrame and return it
+ df = pd.DataFrame(data, columns=["phenomenonTime", quantity])
+ # df.index = pd.to_datetime(df["phenomenonTime"].map(lambda t: t.split(".")[0]), utc=True)
+ df.index = pd.to_datetime(df["phenomenonTime"].map(lambda t: roundto(t, 1)), utc=True)
+ df = df.drop(["phenomenonTime"], axis=1)
+ print("\nFetched {} tuples.".format(df.shape[0]))
+ return df
+
+def roundto(string, n):
+ base = string.split(".")[0]
+ if n > 0:
+ base += "." + string.split(".")[1][:n]
+ return base
diff --git a/extra/performance-test.png b/extra/performance-test.png
new file mode 100644
index 0000000..050731f
Binary files /dev/null and b/extra/performance-test.png differ
diff --git a/src/Dockerfile b/src/Dockerfile
index b0acda4..2dd636c 100644
--- a/src/Dockerfile
+++ b/src/Dockerfile
@@ -417,6 +417,44 @@ RUN conda install -y -c pytorch \
############################ Useful packages ###############################
############################################################################
+# Update conda
+RUN conda update -n base conda -y
+
+# Install elasticsearch libs
+USER root
+RUN apt-get update \
+ && curl -sL http://central.maven.org/maven2/org/elasticsearch/elasticsearch-hadoop/6.8.1/elasticsearch-hadoop-6.8.1.jar
+RUN pip install --no-cache-dir elasticsearch==7.1.0
+
+# Install rpy2 to share data between Python and R
+RUN conda install rpy2=2.9.4 plotly=4.4.1
+RUN conda install -c conda-forge ipyleaflet
+
+# Install important packages and Graphviz
+RUN set -ex \
+ && buildDeps=' \
+ graphviz==0.11 \
+' \
+ && apt-get update \
+ && apt-get -y install htop apt-utils graphviz libgraphviz-dev \
+ && pip install --no-cache-dir $buildDeps
+
+# Install various extensions
+RUN jupyter labextension install @jupyterlab/github
+RUN jupyter labextension install jupyterlab-drawio
+RUN jupyter labextension install jupyter-leaflet
+RUN jupyter labextension install @jupyterlab/plotly-extension
+RUN jupyter labextension install @jupyter-widgets/jupyterlab-manager
+RUN pip install --no-cache-dir jupyter-tabnine==1.0.2 && \
+ jupyter nbextension install --py jupyter_tabnine && \
+ jupyter nbextension enable --py jupyter_tabnine && \
+ jupyter serverextension enable --py jupyter_tabnine
+RUN conda install -c conda-forge jupyter_contrib_nbextensions && \
+ conda install -c conda-forge jupyter_nbextensions_configurator && \
+ jupyter nbextension enable codefolding/main
+RUN jupyter labextension install @ijmbarr/jupyterlab_spellchecker
+
+# Copying config and fix permissions
COPY jupyter_notebook_config.json /etc/jupyter/
RUN fix-permissions /home/$NB_USER