From 6b84da949fa7cea9a45f0a6065fc104c72a4b2b3 Mon Sep 17 00:00:00 2001 From: Oleg Sheynin Date: Tue, 2 Jul 2024 15:34:18 +0000 Subject: [PATCH] progress --- fastai/docker-compose.yml | 1 + pytorch/.docker-compose.yml.swp | Bin 0 -> 12288 bytes pytorch/notebooks/Testing GPU.ipynb | 6 +- tensorflow/docker-compose.yml | 2 + .../notebooks/leo/LSTM_All_Crypto_01.ipynb | 158 +- .../notebooks/leo/LSTM_All_Crypto_02.ipynb | 4918 +++++++++++++++++ .../leo/LSTM_All_Crypto_Simple.ipynb | 3368 +++++++++++ 7 files changed, 8404 insertions(+), 49 deletions(-) create mode 100644 pytorch/.docker-compose.yml.swp create mode 100644 tensorflow/notebooks/leo/LSTM_All_Crypto_02.ipynb create mode 100644 tensorflow/notebooks/leo/LSTM_All_Crypto_Simple.ipynb diff --git a/fastai/docker-compose.yml b/fastai/docker-compose.yml index f6d3684..0af1e62 100644 --- a/fastai/docker-compose.yml +++ b/fastai/docker-compose.yml @@ -11,6 +11,7 @@ services: image: cvtt/fastai:v0.0.1 container_name: fastai_jupyter runtime: nvidia + restart: unless-stopped environment: - JUPYTER_ENABLE_LAB=yes volumes: diff --git a/pytorch/.docker-compose.yml.swp b/pytorch/.docker-compose.yml.swp new file mode 100644 index 0000000000000000000000000000000000000000..d691b9e1bedf43f5775feb84e10ae047cc65e8cf GIT binary patch literal 12288 zcmeI2&ubGw6vwCD#9Bqc^OzQTO13``%3=;Ft+u5$HKvLnq?^q&S(EH6GqYP_EZ!9S z54;K9>c8MWP){Djf53xR1@S0;cQ@O{5~#UZcmv(_S1jzAlT01+SpM1Tko0U|&IhyW2d zzXVJ$!CoN!3xlta8}t*W`oWYsB0vO)01+SpM1Tko0U|&IhyW2F0z}{(5^x%fy}86# zaT3Yn{eSlV{|Daxe}_Imuc7CV4?Te%KpW5vXcC%$zD+Uq2|9#cK^l4l-GOGIi_ovj zjD3NQptsN_^c&Cp2)&06p_fn}x(~%U-G-p%b(4BTq@cEBrw;CA4vrv3clsgw}a&WDtlnmI{62b#ZC1so^v$Jkd 5\u001b[0m sample_size \u001b[38;5;241m=\u001b[39m \u001b[43msample_test\u001b[49m\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m (\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msample_size: \u001b[39m\u001b[38;5;124m'\u001b[39m, sample_size)\n\u001b[1;32m 8\u001b[0m sl \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m16\u001b[39m \u001b[38;5;66;03m# <--- sequence length\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'sample_test' is not defined" + ] + } + ], "source": [ - "# variables are close and volume\n", + "# variables are volume and volume\n", "# ==============================\n", "# Test Sample --- 06.14.2024\n", "# ==============================\n", @@ -1556,16 +1586,28 @@ "\n", "print (selected_indices)\n", "\n", - "all_ts_xrp = np.empty((1, )) # final input/output\n", - "all_ts_eth = np.empty((1, )) # final input/output\n", - "all_ts_ltc = np.empty((1, )) # final input/output\n", - "all_ts_btc = np.empty((1, )) # final input/output\n", + "# all_ts_xrp = np.empty((1, )) # final input/output\n", + "# all_ts_eth = np.empty((1, )) # final input/output\n", + "# all_ts_ltc = np.empty((1, )) # final input/output\n", + "# all_ts_btc = np.empty((1, )) # final input/output\n", + "\n", + "\n", + "all_ts_close_xrp = np.empty((1, )) # final input/output\n", + "all_ts_close_eth = np.empty((1, )) # final input/output\n", + "all_ts_close_ltc = np.empty((1, )) # final input/output\n", + "all_ts_close_btc = np.empty((1, )) # final input/output\n", + "\n", + "all_ts_volume_xrp = np.empty((1, )) # final input/output\n", + "all_ts_volume_eth = np.empty((1, )) # final input/output\n", + "all_ts_volume_ltc = np.empty((1, )) # final input/output\n", + "all_ts_volume_btc = np.empty((1, )) # final input/output\n", "\n", "stdev_xrp = np.empty((1, )) # final input/output\n", "stdev_eth = np.empty((1, )) # final input/output\n", "stdev_ltc = np.empty((1, )) # final input/output\n", "stdev_btc = np.empty((1, )) # final input/output\n", "\n", + "\n", "aft_ts_xrp = np.empty((1))\n", "aft_ts_eth = np.empty((1))\n", "aft_ts_ltc = np.empty((1))\n", @@ -1575,71 +1617,93 @@ " selected_rows_before = sample_test.iloc[max(0, idx-sl): idx]\n", " selected_rows_after = sample_test.iloc[max(0, idx): idx+frwd]\n", "\n", - " # print ('====================')\n", - " sr_before_vwap_xrp = np.array(selected_rows_before['vwap_xrp'])\n", - " sr_after_vwap_xrp = np.array(selected_rows_after['vwap_xrp']) \n", - " # print (sr_before_vwap_xrp)\n", - "\n", - "# Compute standard deviation\n", - " std_dev_xrp = np.std(sr_before_vwap_xrp)\n", + " # xrp\n", + " sr_before_close_xrp = np.array(selected_rows_before['close_xrp'])\n", + " sr_after_close_xrp = np.array(selected_rows_after['close_xrp']) \n", + " # print (sr_before_close_xrp)\n", + " sr_before_volume_xrp = np.array(selected_rows_before['volume_xrp'])\n", + " sr_after_volume_xrp = np.array(selected_rows_after['volume_xrp']) \n", + " # print (sr_before_volume_xrp) \n", + " # Compute standard deviation\n", + " std_dev_xrp = np.std(sr_before_close_xrp)\n", " std_dev_xrp_arr = np.repeat(std_dev_xrp, sl)\n", " # print(std_dev_xrp_arr)\n", - "\n", - " sr_before_vwap_eth = np.array(selected_rows_before['vwap_eth'])\n", - " sr_after_vwap_eth = np.array(selected_rows_after['vwap_eth'])\n", - "\n", - "# Compute standard deviation\n", - " std_dev_eth = np.std(sr_before_vwap_eth)\n", + " \n", + "# eth\n", + " sr_before_close_eth = np.array(selected_rows_before['close_eth'])\n", + " sr_after_close_eth = np.array(selected_rows_after['close_eth'])\n", + " sr_before_volume_eth = np.array(selected_rows_before['volume_eth'])\n", + " sr_after_volume_eth = np.array(selected_rows_after['volume_eth'])\n", + " # Compute standard deviation\n", + " std_dev_eth = np.std(sr_before_close_eth)\n", " std_dev_eth_arr = np.repeat(std_dev_eth, sl)\n", " # print(std_dev_eth_arr)\n", " \n", - "\n", - " sr_before_vwap_ltc = np.array(selected_rows_before['vwap_ltc'])\n", - " sr_after_vwap_ltc = np.array(selected_rows_after['vwap_ltc'])\n", - "\n", + "# ltc\n", + " sr_before_close_ltc = np.array(selected_rows_before['close_ltc'])\n", + " sr_after_close_ltc = np.array(selected_rows_after['close_ltc'])\n", + " sr_before_volume_ltc = np.array(selected_rows_before['volume_ltc'])\n", + " sr_after_volume_ltc = np.array(selected_rows_after['volume_ltc'])\n", "# Compute standard deviation\n", - " std_dev_ltc = np.std(sr_before_vwap_ltc)\n", + " std_dev_ltc = np.std(sr_before_close_ltc)\n", " std_dev_ltc_arr = np.repeat(std_dev_ltc, sl)\n", " # print(std_dev_ltc_arr)\n", - " \n", - " sr_before_vwap_btc = np.array(selected_rows_before['vwap_btc'])\n", - " sr_after_vwap_btc = np.array(selected_rows_after['vwap_btc'])\n", "\n", - "# Compute standard deviation\n", - " std_dev_btc = np.std(sr_before_vwap_btc)\n", + "# btc\n", + " sr_before_close_btc = np.array(selected_rows_before['close_btc'])\n", + " sr_after_close_btc = np.array(selected_rows_after['close_btc'])\n", + " sr_before_volume_btc = np.array(selected_rows_before['volume_btc'])\n", + " sr_after_volume_btc = np.array(selected_rows_after['volume_btc'])\n", + " # Compute standard deviation\n", + " std_dev_btc = np.std(sr_before_close_btc)\n", " std_dev_btc_arr = np.repeat(std_dev_btc, sl)\n", " # print(std_dev_btc_arr)\n", - " \n", - " all_ts_xrp = np.concatenate((all_ts_xrp, sr_before_vwap_xrp))\n", + "\n", + "# xrp\n", + " all_ts_close_xrp = np.concatenate((all_ts_close_xrp, sr_before_close_xrp))\n", + " all_ts_volume_xrp = np.concatenate((all_ts_volume_xrp, sr_before_volume_xrp))\n", " stdev_xrp = np.concatenate((stdev_xrp, std_dev_xrp_arr))\n", - " \n", - " all_ts_eth = np.concatenate((all_ts_eth, sr_before_vwap_eth))\n", + "# eth\n", + " all_ts_close_eth = np.concatenate((all_ts_close_eth, sr_before_close_eth))\n", + " all_ts_volume_eth = np.concatenate((all_ts_volume_eth, sr_before_volume_eth))\n", " stdev_eth = np.concatenate((stdev_eth, std_dev_eth_arr))\n", - "\n", - " all_ts_ltc = np.concatenate((all_ts_ltc, sr_before_vwap_ltc))\n", + "# ltc\n", + " all_ts_close_ltc = np.concatenate((all_ts_close_ltc, sr_before_close_ltc))\n", + " all_ts_volume_ltc = np.concatenate((all_ts_volume_ltc, sr_before_volume_tc))\n", " stdev_ltc = np.concatenate((stdev_ltc, std_dev_ltc_arr))\n", - "\n", - " all_ts_btc = np.concatenate((all_ts_btc, sr_before_vwap_btc))\n", + "# btc\n", + " all_ts_close_btc = np.concatenate((all_ts_close_btc, sr_before_close_btc))\n", + " all_ts_volume_btc = np.concatenate((all_ts_volume_btc, sr_before_volume_btc))\n", " stdev_btc = np.concatenate((stdev_btc, std_dev_btc_arr))\n", "\n", - " aft_ts_xrp = np.concatenate((aft_ts_xrp, sr_after_vwap_xrp))\n", - " aft_ts_eth = np.concatenate((aft_ts_eth, sr_after_vwap_eth))\n", - " aft_ts_ltc = np.concatenate((aft_ts_ltc, sr_after_vwap_ltc))\n", - " aft_ts_btc = np.concatenate((aft_ts_btc, sr_after_vwap_btc))\n", "\n", - "X_XRP = all_ts_xrp[1:]\n", + " aft_ts_close_xrp = np.concatenate((aft_ts_close_xrp, sr_after_close_xrp))\n", + " aft_ts_close_eth = np.concatenate((aft_ts_close_eth, sr_after_close_eth))\n", + " aft_ts_close_ltc = np.concatenate((aft_ts_close_ltc, sr_after_close_ltc))\n", + " aft_ts_close_btc = np.concatenate((aft_ts_close_btc, sr_after_close_btc))\n", + "\n", + "\n", + "X_XRP_close = all_ts_close_xrp[1:]\n", + "X_XRP_volume = all_ts_volume_xrp[1:]\n", "X_XRP_stdev = stdev_xrp[1:]\n", "\n", - "X_ETH = all_ts_eth[1:]\n", + "\n", + "X_ETH_close = all_ts_close_eth[1:]\n", + "X_ETH_volume = all_ts_volume_eth[1:]\n", "X_ETH_stdev = stdev_eth[1:]\n", "\n", - "X_LTC = all_ts_ltc[1:]\n", + "X_LTC_close = all_ts_close_ltc[1:]\n", + "X_LTC_volume = all_ts_volume_ltc[1:]\n", "X_LTC_stdev = stdev_ltc[1:]\n", "\n", - "X_BTC = all_ts_btc[1:]\n", + "X_BTC_close = all_ts_close_btc[1:]\n", + "X_BTC_volume = all_ts_volume_btc[1:]\n", "X_BTC_stdev = stdev_btc[1:]\n", "\n", - "X0 = np.column_stack((X_XRP, X_XRP_stdev, X_ETH, X_ETH_stdev, X_LTC, X_LTC_stdev, X_BTC, X_BTC_stdev))\n", + "X0 = np.column_stack((X_XRP_close, X_XRP_volume, \n", + " X_ETH_close, X_ETH_volume, \n", + " X_LTC_close, X_LTC_volume, \n", + " X_BTC_close, X_BTC_volume))\n", "print (X0)\n", "\n", "# ======== Model Input =========\n", diff --git a/tensorflow/notebooks/leo/LSTM_All_Crypto_02.ipynb b/tensorflow/notebooks/leo/LSTM_All_Crypto_02.ipynb new file mode 100644 index 0000000..7fe9348 --- /dev/null +++ b/tensorflow/notebooks/leo/LSTM_All_Crypto_02.ipynb @@ -0,0 +1,4918 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1023f2c1-e45f-4e1c-9a1b-66f59f128196", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Panda Version: 2.2.2\n", + "Today date is: 2024-06-17\n" + ] + } + ], + "source": [ + "import sqlite3\n", + "\n", + "import os\n", + "import re\n", + "\n", + "import numpy as np\n", + "# It is apparently officially accepted to explicitly\n", + "# list all the functions you need from numpy:\n", + "from numpy import array, zeros, exp, random, dot\n", + "from numpy import shape, reshape, meshgrid, linspace\n", + "from numpy import hstack, vstack\n", + "\n", + "import pandas as pd\n", + "print('Panda Version:', pd.__version__)\n", + "\n", + "# Set ipython's max row display\n", + "pd.set_option('display.max_row', 100, 'display.max_columns', 25)\n", + "\n", + "import matplotlib.pyplot as plt # for plotting\n", + "import matplotlib\n", + "matplotlib.rcParams['figure.dpi'] = 100 # highres display\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow import Variable\n", + "\n", + "from tensorflow.keras import Sequential\n", + "from tensorflow.keras import Model\n", + "from tensorflow.keras.layers import Dense\n", + "from tensorflow.keras.layers import Dropout\n", + "from tensorflow.keras.layers import TimeDistributed, RepeatVector\n", + "\n", + "from keras.optimizers import SGD\n", + "\n", + "from keras.models import load_model\n", + "from keras.callbacks import EarlyStopping\n", + "from keras.callbacks import ModelCheckpoint\n", + "\n", + "from keras.layers import LSTM, Dense, Concatenate\n", + "\n", + "from keras.optimizers import SGD\n", + "\n", + "import collections\n", + "from collections import Counter\n", + "\n", + "import seaborn as sns\n", + "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n", + "\n", + "# Import date class from datetime module\n", + "import time\n", + "import datetime\n", + "# import datetime as dt\n", + "from datetime import date\n", + "print(\"Today date is: \", date.today())" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c09a37a6-f0d9-48e3-a1d1-65ddaf2c489c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/workspace/leo\n", + "total 22016\n", + "drwxrwxr-x 1 1000 1000 848 Jun 17 10:00 .\n", + "drwxrwxr-x 1 1000 1000 18 Jun 3 23:40 ..\n", + "-rw------- 1 1000 1000 1449984 Jun 4 00:49 20240601.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 3 23:44 20240602.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1437696 Jun 4 16:45 20240603.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1269760 Jun 5 10:00 20240604.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1081344 Jun 6 10:00 20240605.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1441792 Jun 7 10:00 20240606.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 8 10:00 20240607.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 9 10:00 20240608.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1437696 Jun 10 10:00 20240609.mktdata.ohlcv.db\n", + "-rw-r--r-- 1 1000 1000 0 Jun 12 15:29 20240609.mktdata.ohlcvdb\n", + "-rw------- 1 1000 1000 1437696 Jun 11 10:00 20240610.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 12 10:01 20240611.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 13 10:01 20240612.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 14 10:01 20240613.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1404928 Jun 15 10:01 20240614.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 16 10:00 20240615.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 17 10:00 20240616.mktdata.ohlcv.db\n" + ] + } + ], + "source": [ + "!pwd\n", + "\n", + "!ls -la /workspace/data/crypto_md/" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "8d72d849-e8df-4564-a006-03ab646b9330", + "metadata": {}, + "outputs": [], + "source": [ + "# db_conn = sqlite3.connect(mktdata_db_file)\n", + "# tables_df = pd.read_sql_query(\"select * from sqlite_master where type = 'table'\", db_conn)\n", + "# print (tables_df_20240601.head())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4df4b0d4-e92e-42a9-8747-ff60669a4e10", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5d2aed0b-8c9d-4f5a-9166-785da4811390", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "89716\n" + ] + } + ], + "source": [ + "directory = \"/workspace/data/crypto_md\"\n", + "\n", + "# List of dates\n", + "dates = ['20240601', \n", + " '20240602', \n", + " '20240603', \n", + " '20240604', \n", + " '20240605', \n", + " '20240606', \n", + " '20240607', \n", + " '20240608', \n", + " '20240609',\n", + " '20240610',\n", + " '20240611',\n", + " '20240612',\n", + " '20240613', \n", + " '20240614', \n", + " '20240615', \n", + " '20240616'] \n", + "\n", + "# Create an entirely empty DataFrame\n", + "df_concat = pd.DataFrame()\n", + "\n", + "for date in dates:\n", + " # Construct the filename\n", + " filename = f\"{directory}/{date}.mktdata.ohlcv.db\"\n", + " \n", + " # Create the SQLite connection\n", + " conn = sqlite3.connect(filename)\n", + " \n", + " # Read the data into a DataFrame\n", + " df = pd.read_sql_query(\"select * from coinbase_ohlcv_1min\", conn)\n", + "\n", + " df_concat = pd.concat([df_concat, df], axis = 0,ignore_index = True)\n", + " # Print the combined DataFrame\n", + " # print(df_concat.shape[0])\n", + " # print(df_concat.shape[1])\n", + " conn.close()\n", + "print(df_concat.shape[0])\n", + "# print(df_concat.head(2))\n", + "# print(df_concat.tail(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cd83027c-eaa1-44d9-98ad-8506099c323d", + "metadata": {}, + "outputs": [], + "source": [ + "df_concat['tstamp'] = pd.to_datetime(df_concat['tstamp'])\n", + "# Extract individual components\n", + "df_concat['year'] = df_concat['tstamp'].dt.year\n", + "df_concat['month'] = df_concat['tstamp'].dt.month\n", + "df_concat['day'] = df_concat['tstamp'].dt.day\n", + "df_concat['hour'] = df_concat['tstamp'].dt.hour\n", + "df_concat['minute'] = df_concat['tstamp'].dt.minute\n", + "df_concat['second'] = df_concat['tstamp'].dt.second\n", + "\n", + "df_concat['date'] = df_concat['day'].astype(str) + '-' + df_concat['hour'].astype(str) + '-' + df_concat['minute'].astype(str)\n", + "df_concat = df_concat.sort_values(by = ['day', 'hour', 'minute'])\n", + "\n", + "selected_columns = ['date', 'instrument_id', 'close', 'volume', 'vwap']\n", + "df_concat = df_concat[selected_columns]\n", + "\n", + "# instrument_list = df_concat['instrument_id'].unique().tolist()\n", + "# print(\"Distinct values in column 'instrument_id':\", instrument_list)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "316c0cfb-c73d-4dad-9d49-eb80daa229ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "========================================\n", + " date close_xrp volume_xrp vwap_xrp close_eth volume_eth vwap_eth \\\n", + "0 1-0-0 0.5173 28809.165339 0.517217 0.376204 37.497964 0.376108 \n", + "1 1-0-1 0.5170 10184.511212 0.517060 0.375942 11.703305 0.376013 \n", + "2 1-0-10 0.5176 15515.348778 0.517601 0.375938 11.922897 0.375935 \n", + "\n", + " close_ltc volume_ltc vwap_ltc close_btc volume_btc vwap_btc \n", + "0 0.8317 110.056253 0.831662 0.675060 2.045049 0.674969 \n", + "1 0.8312 176.868598 0.831441 0.674947 0.646759 0.675009 \n", + "2 0.8311 58.951033 0.831037 0.675507 1.201335 0.675478 \n", + "test sample size: 22424\n" + ] + } + ], + "source": [ + "# BTC\n", + "df_concat_btc = df_concat[df_concat['instrument_id'] == 'PAIR-BTC-USD']\n", + "\n", + "# Reset Index\n", + "df_concat_btc = df_concat_btc.reset_index(drop = True)\n", + "\n", + "# Rename Vars\n", + "df_concat_btc['close_btc'] = df_concat_btc['close']/100000.00\n", + "df_concat_btc['volume_btc'] = df_concat_btc['volume']\n", + "df_concat_btc['vwap_btc'] = df_concat_btc['vwap']/100000.00\n", + "\n", + "df_concat_btc = df_concat_btc.drop('close', axis = 1)\n", + "df_concat_btc = df_concat_btc.drop('volume', axis = 1)\n", + "df_concat_btc = df_concat_btc.drop('vwap', axis = 1)\n", + "df_concat_btc = df_concat_btc.drop('instrument_id', axis = 1)\n", + "\n", + "# print (df_concat_btc.head(3))\n", + "\n", + "# LTC\n", + "df_concat_ltc = df_concat[df_concat['instrument_id'] == 'PAIR-LTC-USD']\n", + "\n", + "# Reset Index\n", + "df_concat_ltc = df_concat_ltc.reset_index(drop = True)\n", + "\n", + "# Rename Vars\n", + "df_concat_ltc['close_ltc'] = df_concat_ltc['close']/100.00\n", + "df_concat_ltc['volume_ltc'] = df_concat_ltc['volume']\n", + "df_concat_ltc['vwap_ltc'] = df_concat_ltc['vwap']/100.00\n", + "\n", + "df_concat_ltc = df_concat_ltc.drop('close', axis = 1)\n", + "df_concat_ltc = df_concat_ltc.drop('volume', axis = 1)\n", + "df_concat_ltc = df_concat_ltc.drop('vwap', axis = 1)\n", + "df_concat_ltc = df_concat_ltc.drop('instrument_id', axis = 1)\n", + "\n", + "# print (df_concat_ltc.head(3))\n", + "\n", + "# ETH\n", + "df_concat_eth = df_concat[df_concat['instrument_id'] == 'PAIR-ETH-USD']\n", + "\n", + "# Reset Index\n", + "df_concat_eth = df_concat_eth.reset_index(drop = True)\n", + "\n", + "# Rename Vars\n", + "df_concat_eth['close_eth'] = df_concat_eth['close']/10000.00\n", + "df_concat_eth['volume_eth'] = df_concat_eth['volume']\n", + "df_concat_eth['vwap_eth'] = df_concat_eth['vwap']/10000.00\n", + "\n", + "df_concat_eth = df_concat_eth.drop('close', axis = 1)\n", + "df_concat_eth = df_concat_eth.drop('volume', axis = 1)\n", + "df_concat_eth = df_concat_eth.drop('vwap', axis = 1)\n", + "df_concat_eth = df_concat_eth.drop('instrument_id', axis = 1)\n", + "\n", + "# print (df_concat_eth.head(3))\n", + "\n", + "# XRP\n", + "df_concat_xrp = df_concat[df_concat['instrument_id'] == 'PAIR-XRP-USD']\n", + "\n", + "# Reset Index\n", + "df_concat_xrp = df_concat_xrp.reset_index(drop = True)\n", + "\n", + "# Rename Vars\n", + "df_concat_xrp['close_xrp'] = df_concat_xrp['close']\n", + "df_concat_xrp['volume_xrp'] = df_concat_xrp['volume']\n", + "df_concat_xrp['vwap_xrp'] = df_concat_xrp['vwap']\n", + "\n", + "df_concat_xrp = df_concat_xrp.drop('close', axis = 1)\n", + "df_concat_xrp = df_concat_xrp.drop('volume', axis = 1)\n", + "df_concat_xrp = df_concat_xrp.drop('vwap', axis = 1)\n", + "df_concat_xrp = df_concat_xrp.drop('instrument_id', axis = 1)\n", + "\n", + "# print (df_concat_xrp.head(3))\n", + "\n", + "df_M1 = pd.merge(df_concat_xrp, df_concat_eth, on = 'date', how = 'outer')\n", + "# print (df_M1.head(3))\n", + "# print (\"M1: \", df_M1.shape[0])\n", + "df_M2 = pd.merge(df_M1, df_concat_ltc, on = 'date', how = 'outer')\n", + "# print (df_M2.head(3))\n", + "# print (\"M2: \", df_M2.shape[0])\n", + "df_M3 = pd.merge(df_M2, df_concat_btc, on = 'date', how = 'outer')\n", + "# print (df_M3.head(3))\n", + "# print (\"M3: \", df_M3.shape[0])\n", + "\n", + "# Drop rows with any NaN value and assign it to a new DataFrame\n", + "sample = df_M3.dropna(axis = 0).reset_index(drop = True)\n", + "print (\"========================================\")\n", + "print (sample.head(3))\n", + "sample_size = sample.shape[0]\n", + "print (\"test sample size: \", sample_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 177, + "id": "92700c76-8eac-4ebb-86d3-27066486c437", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAGzCAYAAADUo+joAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACDEklEQVR4nO3dd3hTVR8H8G9aOoGW2QEUyt4ULFDZoEVERECZiiAOEBCRqkAFisiSKTKkgmzZyF4CZchSNoLsXUYLZbRQoPO+f9w34yY3aZKmuUn7/TxPnt6ce+65J9Amv5ypEgRBABERERFpuChdASIiIiJHwwCJiIiISA8DJCIiIiI9DJCIiIiI9DBAIiIiItLDAImIiIhIDwMkIiIiIj0MkIiIiIj0MEAiIiIi0sMAiYiIiEgPAySiPG7hwoVQqVSah6enJypVqoQvvvgC8fHxkrxbt26FSqVCiRIlkJmZKVtecHAw3n77bUmabvkqlQo+Pj5o1qwZtmzZYlYdmzdvLrne3d0dZcuWRe/evREbG2v0PsYee/fuBQAkJSVh1KhRCAkJQYECBeDl5YUaNWpgyJAhuHv3bpb1knutaseOHYNKpcLChQsl6QcOHEDr1q1RsmRJeHp6onTp0mjbti2WLVtm9N8sX758KFKkCEJDQzFw4ECcO3fO5L+Pscf333+f9T82EQEA8ildASJyDD/88APKli2Lly9f4sCBA5g9eza2bt2Ks2fPwtvbGwCwdOlSBAcH48aNG9i9ezfCw8PNLr9ly5bo0aMHBEHAzZs3MXv2bLRt2xbbtm1Dq1atsry+VKlSGD9+PAAgNTUV586dQ3R0NP7880+cP38e3t7eWLJkieSaxYsXY+fOnQbpVatWxbVr1xAeHo5bt26hU6dO6N27N9zd3fHvv/9i3rx5WLduHS5dumT26zPH6tWr0aVLF9SuXRsDBw5E4cKFcf36dfz111+YO3cu3n//fUl+3X+zxMREnD59GosWLcIvv/yCCRMmICIiAgAwbNgwfPrpp5rrjh49iunTp+O7775D1apVNem1atWy6eshytUEIsrTFixYIAAQjh49KkmPiIgQAAjLli0TBEEQnj17JuTPn1+YPn26UKdOHeGjjz6SLa9MmTJCmzZtJGkAhP79+0vSzp07JwAQWrdunWUdmzVrJlSvXt0gfebMmQIAYceOHbLX9e/fX5B7m0tLSxNCQkIEb29vYf/+/QbnExMThe+++y7Lesm9VrWjR48KAIQFCxZo0qpVqyZUr15dSElJMcgfHx8veS73byYIgpCQkCA0aNBAACBs2bJF9t6rV68WAAh79uzJ8jUQkTx2sRGRrNdeew0AcP36dQDAunXr8OLFC3Tq1Aldu3bF2rVr8fLlS6vLr1q1KooVK4arV69aXUZAQAAAIF8+yxrD//jjD5w+fRrDhg1D48aNDc77+Phg7NixVtfLmKtXr6JevXpwd3c3OOfn52dWGUWLFsWKFSuQL1++HKkjEYkYIBGRLHXgUrRoUQBi91qLFi0QEBCArl274unTp9i0aZPV5ScmJuLx48coXLiwWfkzMjKQkJCAhIQE3Lt3D7t378bIkSNRoUIFNGrUyKJ7b9y4EQDw4YcfWlzv7ChTpgxiYmJw+/btbJVTunRpNGvWDH///TeSkpJsVDsi0sUAiYgAiAFLQkICbt++jZUrV+KHH36Al5cX3n77bdy/fx+7du1C165dAYgf0A0aNMDSpUvNLv/ly5dISEjAgwcPcPz4cXTt2hUZGRno2LGjWddfuHABxYsXR/HixVGiRAm8/vrryMzMxI4dO2RbZEw5f/48fH19ERQUZNF12TVkyBDExsaifPnyeO211xAVFYUDBw4YHfBuSo0aNZCZmYkbN27YvqJExACJiETh4eEoXrw4goKC0LVrVxQoUADr1q1DyZIlsWLFCri4uOC9997T5O/WrRu2bduGx48fm1X+vHnzULx4cfj5+aFu3bqIiYnB4MGDNQONsxIcHIydO3di586d2LZtG6ZNm4bExES0bt0aDx48sOi1JiUloWDBghZdYwsff/wxtm/fjubNm+PAgQMYPXo0mjRpgooVK+LQoUMWlVWgQAEAwNOnT3OiqkR5HmexEREAYNasWahUqRLy5csHf39/VK5cGS4u4neo33//HfXr18fDhw/x8OFDAECdOnWQmpqK1atXo3fv3lmW365dO3zxxRdITU3F0aNHMW7cODx//lxzDwB48OABMjIyNM8LFCigCQTy588vmTX35ptvonHjxqhbty5+/PFHTJkyxezX6uPjg2vXrpmV99mzZ3j27JnmuaurK4oXL272vVQqleR5q1at0KpVKzx//hzHjx/HypUrER0djbfffhsXLlwweyySuk5KBHpEeQEDJCICANSvXx9169Y1SL98+TKOHj0KAKhYsaLB+aVLl5oVIJUqVUoT4Lz11lsoVqwYvvjiC7Ro0QLvvvsuAKBevXq4efOm5pqRI0eaXLsnNDQUvr6++Ouvv7K8v64qVarg5MmTiI2NzbKbbfLkyRg1apTmeZkyZTTdWp6ennjx4oXsdc+fP9fkkePt7Y0mTZqgSZMmKFasGEaNGoVt27ahZ8+eZr2Gs2fPwtXVFWXLljUrPxFZhgESEZm0dOlSuLm5YcmSJXB1dZWcO3DgAKZPn45bt26hdOnSFpXbp08f/PTTTxg+fDg6dOgAlUqFpUuXSgKOcuXKZVlORkaGpIXHHG3btsXy5cvx+++/IzIy0mTeHj16SGa6eXl5aY7LlCljsGij2sWLFzV5sqIOTO/du5dlXgC4desW9u3bhwYNGrAFiSiHMEAiIpOWLl2KJk2aoEuXLgbnGjRogOnTp2P58uUYMmSIReXmy5cPX3/9Nfr164cNGzagffv2Fs9G27NnD549e4aQkBCLruvYsSPGjx+PsWPHonnz5mjQoIHk/NOnT/Hjjz9i7NixKFeunNFA7a233sKOHTuwfv16tG/fXpOekpKC3377DX5+fnjllVc06TExMXj99dcNytm6dSsAoHLlylnW/dGjR+jWrRsyMjIwbNgwc14uEVmBARIRGfXPP//gypUr+OKLL2TPlyxZEq+88gqWLl1qcYAEAB999BGioqIwYcIESYAhJzExEb///jsAID09HRcvXsTs2bPh5eWFoUOHWnRfNzc3rF27FuHh4WjatCk6d+6MRo0awc3NDf/99x+WLVuGwoULZ7nOUO/evTF//nx06tQJH3/8MerUqYOHDx9i5cqVOHv2LBYvXiyZYdeuXTuULVsWbdu2Rfny5ZGcnIxdu3Zh06ZNqFevHtq2bSsp/9KlS/j9998hCAKSkpJw+vRprF69Gs+ePcPUqVPx5ptvWvS6ich8DJCIyCj1NH79D25dbdu2xffff49///3X4q0svLy88MUXX+D777/H3r170bx5c6N5b9++rVm3SKVSoXDhwmjWrBlGjhyJ2rVrW3RfAKhQoQJOnTqFn376CevWrcP69euRmZmJChUq4NNPP8WXX35pVv337duHH374AevXr8eCBQvg5eWF0NBQbN261SCA+e2337BhwwasWrUKd+/ehSAIKFeuHIYNG4YhQ4YYLHipnrXn4uICHx8flC1bFj179kTv3r1RrVo1i18zEZlPJQiCoHQliIiIiBwJ10EiIiIi0sMAiYiIiEgPAyQiIiIiPQyQiIiIiPQwQCIiIiLSwwCJiIiISA/XQZKRmZmJu3fvomDBggYbTRIREZFjEgQBT58+RYkSJSQbYVuDAZKMu3fvZrmBJRERETmm2NhYlCpVKltlOESANGvWLEyaNAlxcXEICQnBjBkzUL9+fdm8zZs3x759+wzS33rrLWzZsgVpaWkYPnw4tm7dimvXrsHX1xfh4eH48ccfUaJECbPqo978MTY2Fj4+Pta/MCIiIrKbpKQkBAUF2WQTZ8UDpJUrVyIiIgLR0dEICwvDtGnT0KpVK1y8eBF+fn4G+deuXYvU1FTN84cPHyIkJASdOnUCADx//hwnTpzAiBEjEBISgsePH2PgwIF45513cOzYMbPqpO5W8/HxYYBERETkZGwxPEbxrUbCwsJQr149zJw5E4A4/icoKAgDBgwwawPKadOmISoqCvfu3UP+/Pll8xw9ehT169fHzZs3Ubp06SzLTEpKgq+vLxITExkgEREROQlbfn4rOostNTUVx48fR3h4uCbNxcUF4eHhOHz4sFllzJs3D127djUaHAHiLuAqlQqFChWSPZ+SkoKkpCTJg4iIiPIuRQOkhIQEZGRkwN/fX5Lu7++PuLi4LK8/cuQIzp49i08//dRonpcvX2LIkCHo1q2b0Why/Pjx8PX11Tw4QJuIiChvc+p1kObNm4eaNWsaHdCdlpaGzp07QxAEzJ4922g5kZGRSExM1DxiY2NzqspE5GRSUoCqVYFff1W6JkRkT4oGSMWKFYOrqyvi4+Ml6fHx8QgICDB5bXJyMlasWIFPPvlE9rw6OLp58yZ27txpsi/Sw8NDMyCbA7OJSJenJ3DhAvD558DLl0rXhojsRdEAyd3dHaGhoYiJidGkZWZmIiYmBg0aNDB57erVq5GSkoLu3bsbnFMHR5cvX8auXbtQtGhRm9ediPKeU6eUrgER2Yvi0/wjIiLQs2dP1K1bF/Xr18e0adOQnJyMXr16AQB69OiBkiVLYvz48ZLr5s2bh/bt2xsEP2lpaejYsSNOnDiBzZs3IyMjQzOeqUiRInB3d7fPCyOiXCebC/MSkRNRPEDq0qULHjx4gKioKMTFxaF27drYvn27ZuD2rVu3DJYLv3jxIg4cOIAdO3YYlHfnzh1s3LgRAFC7dm3JuT179qB58+Y58jqInNmSJcCYMcCGDUDlysCLF4C3t9K1cjzceYgo71B8HSRHxHWQKK9Rf/CXLw9cvSoe79kD8PuENCg6dgwIDVWuLkRkWq5ZB4mIlLd0qfZYHRwBQIsW9q+Lo2MXG1HewT93ojxu4ECla+A8vLyUrgER2QsDJKI87uFD+fTChe1bDzlbtgCTJwOOMhBg+3age3eAi+0T5X6KD9ImIsfkCC1Lb78t/gwLA5o0sf/99dc9GjRI/FmyJDBhgv3rQ0T2wxYkIpKVmal0DbTu3VPmviNHyqffumXfehCR/TFAIiJZP/ygzH2HDgWqVQP279emHTumTF0mTpRP//tvx+n2I6KcwWn+MjjNn/ISY2v7VK4MHD8OHD0KNG4M5LNTh7yx+uTEO1V6uunXZWrdo3btgPXrbV4lIsoGTvMnohzXqBHw3nvidP8ff1S6NrYXGQkUKwZcu2Y8T/v2xs9t2MBWJKLcjAESEclKSwP+/FM8njYt5+93+DCwd6/8uXLlbH+/H38EEhOBb7+VP//vv1m3ED1/bvNqEZGDYIBElIukpYktG48emZff1EDstDTt8cOHwJMn2aqaSenpQMOGxhenvH/ftvfTbfn5+2/D848eASEhWZfz/12NiCgXYoBElIuMHCl2C+nt4WzUtm3Gz61YIX2u24r06JFtZ7ll1RLz7Jlt1x5avlx7fPcucO6c9Ly5/35BQbarExE5FgZIRLnI+PGW5dedPl+kiOm8o0YBs2YBhQqJAUT37hZXz6jk5KzzvHhhu/t98IH0efXqwHffWV6Ose45InJ+DJCI8jDdbrR//gE2bzY9q+uLL8RxO4C0Feb8eXHGl7W73T99mnWelBTrytan31qkNn682CpmyX3kuueIKHdggESUS1y/Ln2ekZH1NbpdSRUqAG3aWDZ1XaUC5s4V1y3STTtwwPwyAGD+fPn0QoW0x2+9JZZ95YplZeu6d09sLTLm5Utg3z5p2qefmi6TM9mIcicGSES5hP5Mr5s35fOlpgLvvgvMnAmULm14/tkzy+7bu7dhWlbbgvz9NxAbq31ubNuOJ08AT0/x+L//xJ8VK1oflMjVVdcbbwCtWknThg0zfY2LC/D559bVh4gcFwMkolyqfHn59GXLgHXrgAEDxNljgBh0qFnbTabvnXeApUsN08+eBRo0kA/O5OjvhwYAXl7i4GpLbd4sfb5kifT5wYPS556eQIkSWZf766+W14WIHBsDJCInk5oqruFz6pQ2zZwxPDduiNPSe/XSpqm74VxdtWnBwdLrdM9ZYtMmcSC3/mw33YHkgmB6oHPfvvLpKSnihrGWKlVKe+zqKtZPtyVLX0IC4O5u+X2IyPkxQCJyEidPiospTp4srgJdp472nLHVoMeO1XZHlS0rbo+hq3lz8afuDLH69aV5XF2B2bPNq+P27YZpixcDFy6I9Vi8WNoitHu3+HqMqVDBvPuaq1kz7bF6Bp9u0KTrzz+B/PkN080JRonI+dlpdyUiyo6tW8UB1EDW43t0DR8OVKkibhliirHxSoDYYqW7aKKx/ct69QJatpRPB8TB3z17Ss+Fh5uul24QmF0vX2q7/H77DSheXHtOpTIc12Rs0coCBWxXJyJyXGxBInIC6uAIAA4d0h6npoo/a9fWpk2dKr22Y0cgLs6y+xUsKH3eoAHw++/A/v3Gu9wmTBAHLBtjal8zY7LaB86SKfkdOmiPfX2l53SXO1BzczNe1tdfm39fInJODJCInIzu9P3duw3PDxpkmBYaatk95IKgDz4AGjc2fo06qOrWzbJ76d8DEAOj+HjxuFIl4/n1Z6Xt3i0GQg8fGubV7f5Tz4xTc3UFjh4FVq4Efvop661N5Lr+zFlWgYich0oQuIqHvqSkJPj6+iIxMRE+Pj5KV4fI5MwyQZCe139uLt13gnr1gGPH5M/p1sfTUzumSJ3nxQvA29vy+3/5JfDzz4bpP/0ERESYV291verUAU6cEM9t2yaOv9Jdqyk93bLB5/r/vmlphoO3X7wwDLyIyL5s+fnNFiQiJ/Pmm8bPvfGGbe6huw+bl5fxfGPGAJ06SQdae3lZvk5RwYLieCk5prq61NRdjWonT4pBjYuL2D2pGxwB1s/MM1WnlSuzVyYRORYGSERORm6mmNqCBeLPCxeyd4/y5YGoKHFsk7qry1i+Vavkx+RMmSJ/zfr1wOrVYjfY+vXA7dviRrS6g6Z16a6mDRiOZVq1CvDwML/VbNcu8/JZauHCnCmXiJTBLjYZ7GIjR2NuF1tcHODvr003NWharhxzrVsndsGNGWO8bqmpYuCiKyFBur2JOVJSpF1XgiC2No0da1k5aidPSge1m0O/iw0Qyzh9WpqP76ZEymIXG1Ee8+qr8un60+B1P8hVKnGrDnNY2vrRoYMYoJgK3NzdxYBo9Wrgjz/EulgaHAFikLVnj3j88cfiz0aNxJ/WLAOg3yJlCd2uur17TbfmEZFz4zpIRE5AvSWIvqwWUvT1FQMCU4FSr16G6xPZStGi4jID2dW8ubR1Rt0ydvKk5WUZ68qzVKFChvu2EVHuwQCJyAnoD0JWW70aSE7WPpdr0XnwQFzc0NiaQWXKZL9+9mZqjNVHH4ljmkqUEDfk1RUUJL86trn8/Ky/loicC7vYiBxcSgrw77/Gz3/3nenr8+UTp+IbGx+TnYBBKaaWEQgNFbv0ZswAypWTntPfrNZc69eL3Xrz5xueK1zYujKJyLExQCJycEePmj4/fbr2OKuZXJs2iUHDu+9q05wxQGra1DBt1ixxLaU+fbRply6JweX9++JxrVrW3a9dO+DAAXE9JX3R0eJPU4toEpHzYRcbkYO7dct2Zb39tviIjwfWrhXTrFnUUWmVKxum9etnmObqCtSsKR7bauyRPvU6UZZse0JEjo8tSEQObvBg0+d1d6M3dy0g3cUfzVmI0dHl1NpG5nj8WPyZVUsfETkXBkhEDu7OHdPnb9+2vEzdbTLy5YJ25NdeU+7e6sU5iSh3YYBE5OAs2VfN3Ly6AZKpAeDOwpq952xFdwxYZqZy9SAi22KAROTgIiPl01u3tr5M3RW2nz2zvhySTv3/4w/l6kFEtsUAicjBqaeR6y9KWKyYYV5rVtYPC7P8GtLSbY376y/l6kFEtsUAicjBqWdHlSoFXL0KvPcekJgov8+aJeOJli4FPv8c6NzZNvXMq3QDJCLKPRggUZ6VmSkGHI5OHSB5eIhrGK1ZI7YUZXf22fvvA7Nni1PhyXq6G/Jys1qi3IMBEuVZH38s7mU2Z47SNTFNN0DSlZYmfd69u33qQ1K6rXazZilXDyKyLQZIlGctWiT+1F152RE9eCD+1O9S0w+QJkywT30cTUCA0jUgotyIARKRA0tN1a6zM2WK9Jz+lPLAQPvUydGwi5Bs5cEDdpOSFgMkIge2eLHxc7oBUpcuyq4FpKSQEKVrQLnB/Pnikg3qltrkZGDdOi6DkZc5RIA0a9YsBAcHw9PTE2FhYThy5IjRvM2bN4dKpTJ4tGnTRpNHEARERUUhMDAQXl5eCA8Px+XLl+3xUohsytQq2RkZ2uMVK3K+Lo7m+HGgd2/xg01pvr5K14Cy65NPpM9ff13c1Ll8eWXqQ8pTPEBauXIlIiIiMHLkSJw4cQIhISFo1aoV7t+/L5t/7dq1uHfvnuZx9uxZuLq6olOnTpo8EydOxPTp0xEdHY1//vkH+fPnR6tWrfDy5Ut7vSxyMg8fKl0DQ+PHA6NGGT//+efiT7md7fOCV14Bfv0V8PdXuibA7t3izwIFlK0HWS9/funzf/4Rfxr5KKI8QPEAaerUqfjss8/Qq1cvVKtWDdHR0fD29sZ8I18LixQpgoCAAM1j586d8Pb21gRIgiBg2rRpGD58ONq1a4datWph8eLFuHv3LtavX2/HV0bO5Nw5pWsglZkJfPedNO3LL6XPw8OBa9eU3aiVROq1kHQ3ASbnUrOm9pgLfprnxQula5CzFA2QUlNTcfz4cYSHh2vSXFxcEB4ejsOHD5tVxrx589C1a1fk/3/4f/36dcTFxUnK9PX1RVhYmNEyU1JSkJSUJHkQKUm3+0ytVi3DtLJls78eEmWfetwK92JzXn//rT1u1ky5ejiLMWMAb+/cPfZR0QApISEBGRkZ8NdrI/f390dcXFyW1x85cgRnz57Fp59+qklTX2dJmePHj4evr6/mERQUZOlLISfnaH/kiYmGaVznyHGpZ9LJBbbk+NgKa7kRI7THZrZnOB3Fu9iyY968eahZsybq16+frXIiIyORmJioecTGxtqohuSoHP2b/vLlhmn6C0WS42CA5Nz27zd9ftIk+9TDWY0bp3QNcoaiAVKxYsXg6uqK+Ph4SXp8fDwCslj9LTk5GStWrMAnelMP1NdZUqaHhwd8fHwkD8rdnjyRPne0tU8cfXVvkmIXW/Zdvw4cOKDMvbP6+x882D71cFabN4s/MzOBIUOAP/5Qtj62omiA5O7ujtDQUMTExGjSMjMzERMTgwYNGpi8dvXq1UhJSUF3vX6HsmXLIiAgQFJmUlIS/vnnnyzLpLxD/5v+wYPK1MOYs2eVrgFZgi1I1ktPB44cEfcZbNIE+O8/Mf3qVeDKFfvU4elT+9wntzD2RWD9emDiRKBjR7tWJ8co3sUWERGBuXPnYtGiRTh//jz69u2L5ORk9OrVCwDQo0cPREZGGlw3b948tG/fHkWLFpWkq1QqfPXVVxgzZgw2btyIM2fOoEePHihRogTat29vj5dETiA1Vfpc5leMyGwMkKz30UdAWJj2eY8ewMuX4j6JFSuKx/oePAAKFwYWLrRNHV591Tbl5BVyv+fffWd63TZnpHiA1KVLF0yePBlRUVGoXbs2Tp06he3bt2sGWd+6dQv37t2TXHPx4kUcOHDAoHtNbfDgwRgwYAB69+6NevXq4dmzZ9i+fTs8PT1z/PWQ47t4EShVSulaUG6i7mJjgCR18qQ4AWLmTON5li6VPj9xQmyFUHvrLcNr/PzEbvJevYCuXbNfT3O62G/cyP59cgu9j2QA4rpt+vtDOjuVIDja6AvlJSUlwdfXF4mJiRyPlAtVqSIGSfq2bwd8fABH6InVn1XXrRuwbJkydaGsxcdrN83lO6qW7u+x3L9LWpp2DSlTnj2TTinX//s4fVp+GQxzlS4N6M/NiY83XISU/7eif//Neosfpf6tbPn5rXgLEpG9yQVHAPDmm0DDhvati7nkZrWR49DdMJcDtc2zdq15wREgrlDu4iL+206bZng+JASIijLsOjeXbnDUqxewcaPYSqVeIV1txgygRQtxn7a8Kj3d/P83Z8cWJBlsQcrd5NY8ql9fHCgKiG/CSq+LJHd//qU6rkePAPVwyNRULt6ppvt7nJ6uDSS3bwdat7a8vEKFDGeg6urSxfJ9Ce/eBUqWFI99fKRrkOme0xUSApw6Zdl9coPUVKB6dXFrpsePxX+bO3fk87IFiSiX0P1jdsQWgHz5lK4BmcIWJHmVK2uPY2PFqfyRkfLBkd7KLLJMBUcAsHIl0KEDcOuW+XX85hvtsYveJ6KxlpLTp80vPzc5dUqcWfj4sfjc21vR6uQ4BkhEkA4uTE9Xrh7GVKumdA3IFN0AydYDtVNTgfnzLfvQdxSFC2uPN2wQp/L/+KNhvnz5xC4tS6bbBwfLBzDr10uDnqxcvqw91l9/TD9g0qUePL5/v9gllxfoB0QMkIxYsmQJGjVqhBIlSuDmzZsAgGnTpmHDhg02qxyRvegGSI44EyO3vxE5O90PUlsHSB4ewCefAGXKSNOt6cLIzLRv14duwPPVV8bzqafyFygAHD0qjk9KTxfr+uab8tccPWp84sLq1cbv9c03QO/e2pa+58+156pUkebVDfD0bdsGVK0KNG0KtGsHDBpkPG9uoftFAADy55fvgswtrAqQZs+ejYiICLz11lt48uQJMv7/jlCoUCFMkxtBR+RAdKcNR0SIP3W7ReTWXRk9WpzGag9yeyWPGmWfe5N1zGlBmjJFDBLkApRly8TxOn36SNPl8r58KU40cHERrzl/Xnq+Th0xXaUSu7Tu3NE+d3XVXnfsmEUv0SrqRR+NOXFCfI26/35164rdZOq0bdsMW2jefx8oVgx4911xULWc/v21r1v97/jypfj/MHeuWL67O3DunPaa6tWlZahUpnesv3BBezxtGpCQYPLlOr3Zs6XP8+UznP2nlivGTApWqFq1qrBu3TpBEAShQIECwtWrVwVBEIQzZ84IRYsWtaZIh5KYmCgAEBITE5WuCuUA8U9XEDp0EISffhKPy5XTpm/ZIuY7cEAQKlUShKNHteeePs35+o0bp72f+kGOLS1N+391547h+efPtefnzRN/BgeLPxcvNv5/vX274e+C3EPuPuZel5Fh3WveulUQpk83fj493fS9u3c3/176ZcnVOSbG9P08PATh8mXj55s2NX5/S/5Nb940/3U5G/3XWrCgmO7hYXhu0yZl6mjLz2+rWpCuX7+OOnXqGKR7eHggOS/PfySnsm6d9luqbjN7mzbiN8HGjYFLl4B69bTn7PENkduMOB/dFpAXL8Sdzrdu1abpLqynXt9WvfBgjx7Ssho31h4b617Sd+WKuB+WpV2x6lalGTMsuy4jQ2yJ/fJL4JdfxLTHj4HoaHFGX3o6sGaN8etffx1YssT8+7m6SpfgkBsb9NprQOfOxstISRFX5jbG3IkQZ86YPq/fFZqbqbtQU1IMz+WGjSusCpDKli2LUzJzHLdv346qVatmt05EdqN+U9QNkACgeHH5/OasphsfD1y7Zn2duCCk89Gdzr58OTBmjBhoA+KHx59/ml+Wel9AS5aaqFYNaNvWvLx6uzMBEAMdQch6/FRmJvDee9Jgon9/cXPSIkWAvn3F8t3cTK9wvXateXXVtX07EBQkTuU3Zt48y8tVM3fafo0a4r8BmZYbVpW3KkCKiIhA//79sXLlSgiCgCNHjmDs2LGIjIzEYG57TA5iwwbDN2L9P1r1N3+5cT9yBg7MOk9AAFC+vG1amz79NG+ut+LMRozQHnfsCHh6Av36WVaGqUHGcsyZWLBhgxgEGQvyXVzEwMfHRxzI/Oqr2hYCQQD27RODPrngxpLNSevWFe9hqYIFxTFVphZNNTXrLCuWBG3ZCcTIiVjbN/f7778LFSpUEFQqlaBSqYSSJUsKv/32W7b7/BwBxyA5v7t3tX3h/x8iJwiCICQmatOLFhWE336zbHxBVn8xy5dr861YYV3dAwI49sgZWfp7pH74+QnCX38JwsqVxvO8/774uzVnjnlltmsnfb5ypSBkZlpX19RU61+b3OPAgZz7P0hJsb5ef/5pvNxLl8Q8HTtK09PSxJ/37pn/HuHMjL0fGvs3ff7c/nW05ed3tv8rk5OThfj4+GxXxJEwQHJ+f/yh/SNdtUpMe/ZMEBYt0qZPny4ICxda9iZqaiBn796GH1KhoYKQlGRZ3YsXz/1vtLmRtR/MahkZxvO8eKHNl5YmCKNHC0J8vPH8t24Jwrffisf//WdY1+PHBcHbWxD697dd4BMeLgYShQoJQpEi4pcPQRCEXr20eYYNkwZqOeHQIUF47TX5Op4/LwjvvSc/ESKrj7GUFNPnL1wQyylc2HavxdHo/5up/4+XLxcEd3fpF0RAfsJCTlM8QHr+/LmQnJyseX7jxg3hp59+Ev40FYI7EQZIzu/QIcNvhmXLSv94MzMFYdky6z/Q9BnL/957ltU9L3wTzY3M+d1JShIEHx8xMHntNUH47jtpGeHhhtesX2/8nuoZcbqPzZstq/e2bYIwdqwgLFhg/t/A4MHitRcvigHBX38ZLz85WfySYs+304wMQejRQxCWLtXWWT3jSk339TRrlv17qluZfH2zX5aj0v890A1209IMWxtDQsQZiPakeIDUsmVLYfbs2YIgCMLjx48FPz8/oVSpUoKnp6fwyy+/ZLtSSmOA5Lx+/VV8s965U/tH+u67hlOpS5US848ebXmA9N13gvDkieG9rQmq5DBAck7ZCa7V7t+X5j91KutrMjNt9ztz9678lG31o1w5QahfP+dbgWzp2DExWEpNlaYfOWLbv7MrV+QDsdwkq99nuVbQ3bvtW0fFp/mfOHECTZo0AQCsWbMGAQEBuHnzJhYvXozp06fbZGwUkaX++ktcaK9pU+DZM2362rWGU6lv3xZ/ZrWQnZxx44BataSLS+pO45YTF6c93rgR+PBDaR3VdGe/ffut5XUj51a8uDiL7aOPgF27xE1Rs6JSiYspAtnfIywwUFxMURCAAwek55YsAa5eBf75R/nNnC0RGgosWmS4gXC9euLsQltNglAPEM8Ns7esJfd74cx7E1q1Bebz589RsGBBAMCOHTvw7rvvwsXFBa+++qpm2xEie9Ndn6RDB/OusXYLj1u3xBlwgiA+L1HCdP7AQG3edu3En7//rk1TK19ee8wVM3KP4GDzZz41bChd88ccb75p+LuUXQ0bAg0aAIcPA5MmAR98YNvyHcEbb9iuLHWA5MwBQXbJBUjOvNG2VS1IFSpUwPr16xEbG4s///wTb/z/t+z+/fvwsWb+JpENDBhg+TXqrUbkHD2a9fWpqYbbE5iiv2N5aqrxvM78xkJakZHi9PTXXlO6JpZRqYBDh8TA65tvnKvVSAnqJUPySoDUsqV5+Zz5fcyqACkqKgrffPMNgoODUb9+fTRo0ACA2Jokt8I2kT1Y8g1avXGmn5/xPDVqZF3O8OHSvZzUunY1LHvaNHGNJF3qrj4AGDZMes6a7j9yPOqVsyl3ywstSOoW99mzzV83ypkDJKuq3rFjRzRu3Bj37t1DiE4n+euvv44O5vZtEClI/e3H1JuZm5sYtIwdazzPpEmGaepA7dkzcXE7Nbndvh89AsqVAxYuFMc26XryxPh9yXkUKKB0Dcge8kKApH5ve/NN83+v9cd+OROr1x0NCAhAnTp1cPfuXdz+/9fg+vXro0qVKjarHFFOqVxZ/Cm37YKaqyswerR4/Prr5pWr3pcKAPLnzzr/48fAw4fyO5JnNa6JnINukEy5V14KkCzpbs3O6uZKs6rqmZmZ+OGHH+Dr64syZcqgTJkyKFSoEEaPHo3M3PzbQQ6tVSvz8sXEaAdDZ9X8q1KJbwq7dpnX5/7559Jr5883nf/FC6BYMflz6m5Acl5Nm1o/EYCci24gYOsB847CmgDJmUMCqwKkYcOGYebMmfjxxx9x8uRJnDx5EuPGjcOMGTMwQncjIiI7MhZo6GvRQj69VStgyhTj18l1p+kqW9bwjaNXL9P7VP3zj/FznO/g3EaNAvbuVboWZC+6AZIzBwWmmBMg6X8pdOZ/C6sCpEWLFuG3335D3759UatWLdSqVQv9+vXD3LlzsXDhQhtXkcg8S5capi1YALRuLR1HZOyPu1IlcWNRY0JCpF1o+vbvl0///5JhsvTHHVHu4eXFmV95iW6AdOuWcvXISeYESPrDBfJcgPTo0SPZsUZVqlTBo0ePsl0pIlv56CNg61ZxqnVEBBAdbTyvqyvg7m66vM6djZ8rWVI+XXen9UOHst6pvW5dYPt203nI8Tnz7B2ynG6AZO4ML2djTRebMy+caVWAFBISgpkzZxqkz5w5UzKrjSgnHD4MfPll1t9MxozRHqtUYvdZnz7G87u4AG+/LR4bm+JfpIg4YNtUq5A+Dw/tcd26xrvcNm8WV0I+etT88VTkuNTr4lDeoBsgOXNQYEpeC5Cs+o4zceJEtGnTBrt27dKsgXT48GHExsZi69atNq0gkT71KsO3bgHr14vHUVHa86+/Dnz3neUL87m6iusUPX5sfAaaSgXs3Ckemzs7o00bccB13bqmp7y2aWNRdcnB1aypdA3InnTfD3RbjXMTawKk9PScqYs9WNWC1KxZM1y6dAkdOnTAkydP8OTJE7z77ru4ePGiZo82opygOztkwwbtsXo6PiAOErRm1WL1G1yhQqYDGZVKfPz7r3nlli0rBnO7d2vTihSxvH7kPJYsMT4ZgHIn3QApJUW5euSkvBYgWd1LXqJECYw1tYIeUQ5YvjzrPIUKWVe2bleYOWrWFMc1TZ0KzJplOq/+mkZ//SXtxpNbjZucU+XKQPfuSteC7E03QDp2TLl65CRrAiRnbk0zO0D619yvywBq1aplVWWIsjJ8uPZYPVtCv4/b2unx1qxXM2kS0LevdJNZc+i3UAUFWX5vcky5dQ0cMk13zNm2bcrVwx6yCpB8fYHERPFY3YI0Y4b4JbR375ytmy2ZHSDVrl0bKpUKQhZ//SqVChnOPCqLHJqXl/bY11f8+ddf2Stz4EBg40bTA7iNcXEBKlSw/Dr9AeaWtl6R42KAlDfptiC1bq1cPXKK7u91VgHSqVPi0AJAbEG6fVucWAOIM4GtbeW3N7MDpOvXr+dkPYjM8t132u4LddOt7ngjCxo6NaZNA376yb5r1lSuLD4uXhSfO/N+RSTF/8u8Sff9Izf+DlgSIAUHA82aAfv2iS1IcXHac1evAqGhOVJFmzN7kLZ6S5EyZcpg2bJliImJkaSVKVMGMTExWLFiRU7Wl/I43TeeWbOAhATpeWtnDtl7QT+VCrhwQVwocs0a+96bcsaiRWJXqdyCpZS3pKYqXQPbsyRAAsTZwABw7Zp04+26dW1arRxl1Sy2X3/9VXahyOrVqyPa1Ep8RNm0b5/0efHiytTDViIjgffeU7oWZAs9eoizFWvXVrompLTt28WZjA8eKF0T27E0QFK35kdGalvKnY1VAVJcXBwCAwMN0osXL4579+5lu1KU++zYIXZjZXd8hqmtPoiIHEWPHoCfH3D8uNI1sQ1LAyRdd+/ati72YlWAFBQUhIMHDxqkHzx4ECX05zMTQVwZOiIC2LNH6ZoQEeWMtm0N0777zv71yAnZCZB27bJtXezFqgDps88+w1dffYUFCxbg5s2buHnzJubPn49Bgwbhs88+s3UdKRe5di3nyp40KefKJiLKSqNGhmmmNsB2JtkJkN54Q/r89dezXx97sGqhyG+//RYPHz5Ev379kPr/0Wienp4YMmQIIiMjbVpByl2ys6pqVt1zERHWl01ElF1ygYMz72avy9IA6Y03xKEVNWuK+0vq2r0bePFCumyLI7KqBUmlUmHChAl48OAB/v77b5w+fRqPHj1ClO6GWJSnCYL2D0p3WazsLJE1Y4bp8+bujUZEZC+bNytdA9uwNEBStxKdOQP8+afheW9vYMsW29Qtp2TrI6VAgQKoV68eatSoAQ+udEf/JwjidPzixcVvTy9fas8dOWJ9uQMHGj9Xp4715RIR2YL+LNvcxNIAyZy1oN5+2/r62AO/c5PNnTghthQ9fAjcuQMkJWnPLV5s+5WGo6KAv/+2bZlERJbautUwzd3d/vXICZYGSPms3unVcTBAIpv77z/tsYuLuFK1LldXYOHC7N1D/e1k40Zg1Kjc8yZERLmL7kr/zswWLUjt2kmfP3yYvTrlNMUDpFmzZiE4OBienp4ICwvDkSz6YJ48eYL+/fsjMDAQHh4eqFSpErbqhO0ZGRkYMWIEypYtCy8vL5QvXx6jR4/Ocg85sh3dvcnu3QMmTpSeFwTtRrPW+vprsZVKblotEZGj2L5d6RrYhi0CpMWLpc+LFMlenXKaogHSypUrERERgZEjR+LEiRMICQlBq1atcP/+fdn8qampaNmyJW7cuIE1a9bg4sWLmDt3LkqWLKnJM2HCBMyePRszZ87E+fPnMWHCBEycOBEzshrhSzajOxC7Xj3j+bKzvceQIRyUTUTOITd8kbNFF5uPj3ZgtjPsSqZoL+HUqVPx2Wefodf/mxOio6OxZcsWzJ8/H0OHDjXIP3/+fDx69AiHDh2C2//D0+DgYEmeQ4cOoV27dmjTpo3m/PLly7NsmSLbUW8ia47Ro4Hhw837g3vzTfHb2PffO89u0EREmzeLAYa993y0BUEQx5IWLKhNy84g7bfesv041Jyi2Hfw1NRUHD9+HOHh4drKuLggPDwchw8flr1m48aNaNCgAfr37w9/f3/UqFED48aNQ4ZOk0XDhg0RExODS5cuAQBOnz6NAwcOoHXr1kbrkpKSgqSkJMmDrGdJgBQVBfz4o3l5vb3Fn35+lteJiEhJzrjlyNKlYkt9UBDw7bfadGtakP74w7Z1swfFAqSEhARkZGTA399fku7v74+4uDjZa65du4Y1a9YgIyMDW7duxYgRIzBlyhSMGTNGk2fo0KHo2rUrqlSpAjc3N9SpUwdfffUVPvjgA6N1GT9+PHx9fTWPoKAg27zIPMqSAAkwvhT/e++Jf4jVq4vP1QuusWuNiJzN6tXA/9dVdgqCAHTvrn0+d6722JwASXd5F0DcbsrZONVHTWZmJvz8/DBnzhyEhoaiS5cuGDZsGKKjozV5Vq1ahaVLl2LZsmU4ceIEFi1ahMmTJ2PRokVGy42MjERiYqLmERsba4+Xk2sZWy37yBFxbSR9YWGGaQ8eAGvXisfnzolBl7pZlgESETm63bulzydOBJxpuUBTX3TNeQ/Wff0qleOvmi1HsY+aYsWKwdXVFfHx8ZL0+Ph4BAQEyF4TGBiISpUqwdXVVZNWtWpVxMXFabY8+fbbbzWtSDVr1sSHH36IQYMGYfz48Ubr4uHhAR8fH8kjrzp+PPtNwXJ/WIULiwO279833DPtn3+0xxkZ4pYhDRtK8zx4AGzYIB7fu5e9+hER5QT1itGdOgHNmilbl+zKboDUtav2WBCc84utYlV2d3dHaGgoYmJiNGmZmZmIiYlBgwYNZK9p1KgRrly5gkydzW0uXbqEwMBAuP9/IZznz5/DRe9/wtXVVXINyUtNBerWFR9yY9ozMswbXCf3h3Xhgvb4m2/EgEnOokXATz8BV65I03UmKuLXX7OuAxGRvb3xhrjH2KpVxruhUlLsWydrmaqnOV1sztRaZoyiMV1ERATmzp2LRYsW4fz58+jbty+Sk5M1s9p69Ogh2fy2b9++ePToEQYOHIhLly5hy5YtGDduHPr376/J07ZtW4wdOxZbtmzBjRs3sG7dOkydOhUdOnSw++uzB0EALl4Ezp4Vl7mvV0+6cnVWVCrxkZkp7R8PCwMSErTPe/cWB92pY8/168UVs+XIBUj6A6tHj5a/9pdfsq7zzz9nnYeISAmenuJPY0GEpydQtqz96mOt58+zd70zztgzIChsxowZQunSpQV3d3ehfv36wt9//60516xZM6Fnz56S/IcOHRLCwsIEDw8PoVy5csLYsWOF9PR0zfmkpCRh4MCBQunSpQVPT0+hXLlywrBhw4SUlBSz65SYmCgAEBITE7P9+nLasGHqbWGlj99+E89nZAhCjRqC8NVX2msyMwVh1SrDa+rXN0z79lv58tWPu3cFoVo1QfjzT235c+ca5tOXmak9V7q0IKSnC8Inn5i+l/px9WrO/psSEdmCqfexY8eUrp1ply4Zr7s59u2z/BpbsOXnt0oQnGVFAvtJSkqCr68vEhMT7TYeaft2YN06YMoUcQxOWhowf37WUbip86NHA7VqGS7vnlMePRK7zmbPBvr1E9e7SE0FWrYEBg82zD9sGDBunOkyN20yXGRNfR8iIkdm6v153TqgfXu7VcVip08DtWvLnzMnati/H2ja1LJrbMGWn99OOGwqd0lMFP+IWrcG5swRF+OaO1fcq+zaNbH7bOpUIDBQ2x2mUondacnJpsseMcK+Gwa+8Yb4U93FVqAAsHOnfHAEACEhWZf5//U+JXx9rasfEZGjePpU6RqYpu5iK1dOul2U7npIpjjjoGx9ueAlOK8XL0yvCF2hAlClirjvmP7SUM2biwFIVuQCjJxy7Jj4U/3HtGqV6fzGlgMAxMBRvfLsyJHSc7nhD4+I8rYePZSugWnqAMnbGxg4UJs+YYJ51+u2njnruFF+1NhZQoK2Fejdd5Wujejff4GNG4H+/cUuscuXpeebNBHPJSWJK6u+9RZw8qTx8u7cMe++piYW6raMDh9uXnlERI5EEMT3uVdflT+/cKG49Ikj0g2Q3N21o4nMHXyt+0VWvQuCs2GAZEcPHkgXSsyJXZ6DgoC//5Y/N2QI0KiRuEngs2fiNE5BAGrWFMf5zJwp7p9ToYK0v7hTJ/FcwYLA+++Lmw3Wrg0cPQpUq2a8LrqrsMoxd8Vte3YTEhHZkkoFGNk9C716Aa+9lr3yu3cHAgK0K1d//73Yw1CrlvSLrCAAp05pu/a6dRPrpm7516cbIFlDN5D6/yo8TocBkh3t22f6vO7CWpZ49AiIjRUHPJ84AdSvL5/vxx+BAweALl2A/Pmz/qVdskTM+9ln8ufr1gX++w+YNUub9umn2mNj35rUTHWx6Vu8WPxGsnq1+dcQETm6//7L3vVLlwLx8WIvQGwsMGqU+Flz5oz45VZt3jygTh2gSBHxc2DFCjG9Xj1peWfOAHv2iMMcAEBnXWaL6LYg5URjgD1wFpuMnJrF1qGDuH6QvvbtxVaSlSuBYsWAx4/F4EK/Jej8efGXu3hx4MYNIDjYeHPnvn3A1avAJ59o03Lqf/q//4AaNQzT//1XbJ0y5tIloHJlaVqhQuIfepMmhvlfvtSuMUJE5ExMdU1Z+96ckaFtYd+0SVxfSfe9uFgxsefCkvvL5bOmfps3a2cgt2plvyCJs9iclG40r2vdOrFlxMVFbA168UJskk1NFTdqDQkR+7GrVBEXXFSpxD8EU7/wzZoBH38M7NolBlI7duTISwKg3UxWn1zQpKtSJcO0Y8fkgyOAwREROS9ji+Nmx4sX2uNDhwCddZUBSBf7NWXJEvHnqVM2qRYA6YLFzrp7F1uQZORUC5Kx/Whyw/+Atd86PDykK3gnJjrvHxMRkSnGvtRa+xlw/z7g76997uFhuEXIypVA585ZD65++lQcZ6ovIkJcn89Sy5YBH3wgHv/0E/DVV5aXYQ22IDkplUr8FlGlijbNVBeUM1u3zrx8J09KAyIGR0SUW02aBHz0kWG6tQGSbgsSIL9GUZcuwN69WZdlbAysqYk4pjx6pD3+8EPrylAaAyQ7Gz5cHEu0fj3QoIH5gYSzMXf17mrVgOvXxUHj9lyziYjI3r75BliwwDB940brytPfL81Yl9o//2Rd1pYt8unvv29ZndR0NxgvWtS6MpTGCdQKadfOfluA2MPVq0B4OPDkiTi43JKNCosUAR4+dN6poERE2dG+vXWtSPotSNHR8vliYy0vGwBmzAC8vKy7NjdggEQ2Ua6cuDWKJQuJ6fLwsH2diIichTXvnerB1VmZNUvcrurePcNr5bq/Xr4Up/u/8opl9clt2MVGNmVNcERElJe8fGk4Lkh3Y9fffhPfS421CAHAwYPAtGny5y5flk5+AbTB0YkTYjDWvbu4WKS+YsXEL6x162ZvW6fAQOuvdRScxSYjp2axERERqel/oUxPFxdm1E039gltzrpGcnn++0868Fo/T3Q00KeP8bItMWWKuDODPYeTcBYbERFRLhMTk/0yFi7UHsu1QLm5SZ/Xri3+/O8/cfKQrYIjQNxo3ZnH2jJAIiIicgB9+4orUFtj6VIgLg7o2VObprv1k5r+OknHj4stV9WqOXcwkxMYIBERESlg7lzp82vXtNtzqD14YDhbTb0xrdrQoeJ0fN1FIwGxu27OHGlaxYrS5y4u1u+3lttxFhsREZEC9Lu75Pj5iT8zMrSDpnUXYQRML+aoP0OYM4bNxxYkIiIiB1emjPb411+1x598YnoxR7k9L8k8bEEiIiJSQEaG+Xlv39Ye79ypPf7tN9PXqQdhk+XYgkRERKSA9HTrrrNk6w5PT+vuQQyQiIiIFGFJC5KusDDxZ1CQ7epChhggERERKaB4ceuuS04Wf773nnn5X39d/Llvn3X3y6s4BomIiEgB775r3XU//ij+NHcj2V27rLtPXscWJCIiIgVYuteZfpfcyZO2qwsZYgsSERGRE0hKki7qePeucnXJC9iCREREpJBx44D27c3b5qN2bWD3bu3zmjVzqlYEsAWJiIhIMZGR0ue3bgFPngAhIYZ5b90COnTQPs/HT/AcxX9eIiIiB1G6tPgwR/nyOVuXvI5dbERERA7mq6/En926Gc/z9dd2qUqexQCJiIjIwUydCly5AixdCpQsKZ/H29u+dcpr2MVGRETkYFQqdqEpjS1IREREDiwzU+ka5E0MkIiIiByYtXu2UfYwQCIiInJg9+8rXYO8iQESERERkR4GSERERE6mcGGla5D7MUAiIiJyMuPHK12D3I8BEhERkZPx8lK6BrkfAyQiIiIno1IpXYPcjwESERGRk6lRQ+ka5H5cSZuIiMhJHDsG3LkD1KmjdE1yP8VbkGbNmoXg4GB4enoiLCwMR44cMZn/yZMn6N+/PwIDA+Hh4YFKlSph69atkjx37txB9+7dUbRoUXh5eaFmzZo4duxYTr4MIiKiHFWnDhAaCrzzjtI1yRsUDZBWrlyJiIgIjBw5EidOnEBISAhatWqF+0ZWxUpNTUXLli1x48YNrFmzBhcvXsTcuXNRUmcnv8ePH6NRo0Zwc3PDtm3bcO7cOUyZMgWFOSeSiIic0LhxgIsL8MsvStckb1EJgiAodfOwsDDUq1cPM2fOBABkZmYiKCgIAwYMwNChQw3yR0dHY9KkSbhw4QLc3Nxkyxw6dCgOHjyI/fv3W12vpKQk+Pr6IjExET4+PlaXQ0REZAtpaYCRjz3SYcvPb8VakFJTU3H8+HGEh4drK+PigvDwcBw+fFj2mo0bN6JBgwbo378//P39UaNGDYwbNw4ZOhvVbNy4EXXr1kWnTp3g5+eHOnXqYO7cuSbrkpKSgqSkJMmDiIjIUTA4sj/FAqSEhARkZGTA399fku7v74+4uDjZa65du4Y1a9YgIyMDW7duxYgRIzBlyhSMGTNGkmf27NmoWLEi/vzzT/Tt2xdffvklFi1aZLQu48ePh6+vr+YRFBRkmxdJRERETsmpZrFlZmbCz88Pc+bMgaurK0JDQ3Hnzh1MmjQJI0eO1OSpW7cuxo0bBwCoU6cOzp49i+joaPTs2VO23MjISERERGieJyUlMUgiIiLKwxQLkIoVKwZXV1fEx8dL0uPj4xEQECB7TWBgINzc3ODq6qpJq1q1KuLi4pCamgp3d3cEBgaiWrVqkuuqVq2KP/74w2hdPDw84OHhkY1XQ0RERLmJYl1s7u7uCA0NRUxMjCYtMzMTMTExaNCggew1jRo1wpUrV5CZmalJu3TpEgIDA+Hu7q7Jc/HiRcl1ly5dQpkyZXLgVRAREVFupGgXW0REBHr27Im6deuifv36mDZtGpKTk9GrVy8AQI8ePVCyZEmM//+ufH379sXMmTMxcOBADBgwAJcvX8a4cePw5ZdfasocNGgQGjZsiHHjxqFz5844cuQI5syZgzlz5phdL/XEPg7WJiIich7qz22bTNAXFDZjxgyhdOnSgru7u1C/fn3h77//1pxr1qyZ0LNnT0n+Q4cOCWFhYYKHh4dQrlw5YezYsUJ6erokz6ZNm4QaNWoIHh4eQpUqVYQ5c+ZYVKfY2FgBAB988MEHH3zw4YSP2NhYq+MSNUXXQXJUmZmZuHv3LgoWLAiVjXcEDA0NxZUrV2xaJhERkTPavXs3QkNDbVaeIAh4+vQpSpQoAReX7I0icqpZbPbi4uKCUqVK5UjZugPMiYiI8rICBQrYfEFmX19fm5Sj+F5sRERERI6GARIRERGRHgZIdtakSROlq0BERKQ4V1dXBAYGKl0NozhIm4iIiEgPW5CIiIiI9DBAIiIiItLDAImIiIhIDwMkIiIiIj1cKDILtl5Jm4iIiJSxcOFC9OzZ06y8bEEiIiKiPCEkJMTsvAyQsiAIguZBREREzmvcuHFm52WARERERHnCnTt3zM7LAImIiIjyhPj4eLPzciVtC3DANhERkfPy9vZGcnKyWXkZIFmAARIREZFzMzfsYRcbERER5Qlubm5m52WAlIUvvvgCKpWKrUdERERObuTIkWbnZRdbFhgYERER5Q579uxB8+bNzcrLlbSzwPiRiIgo72EXGxEREZEeBkhEREREehggEREREelhgERERESkhwESERERkR4GSERERER6GCARERER6WGARERERKSHARIR5SrNmzfHV199pXQ1iMjJMUAiojxr7969UKlUePLkidJVISIHw61GZGRmZuLu3bsoWLAg92IjcjLp6elISUlBUlJSlnmTk5MBAElJSXBx4fdFImcnCAKePn2KEiVKZPtvmpvVyrh9+zaCgoKUrgYRERFZITY2FqVKlcpWGWxBklGwYEEA4j+wj4+PwrUhIiIicyQlJSEoKEjzOZ4dDhEgzZo1C5MmTUJcXBxCQkIwY8YM1K9fXzZv8+bNsW/fPoP0t956C1u2bEFaWhqGDx+OrVu34tq1a/D19UV4eDh+/PFHlChRwqz6qLvVfHx8GCARERE5GVsMj1G8033lypWIiIjAyJEjceLECYSEhKBVq1a4f/++bP61a9fi3r17msfZs2fh6uqKTp06AQCeP3+OEydOYMSIEThx4gTWrl2Lixcv4p133rHnyyIiIiInpvgYpLCwMNSrVw8zZ84EIA6QDgoKwoABAzB06NAsr582bRqioqJw79495M+fXzbP0aNHUb9+fdy8eROlS5fOssykpCT4+voiMTGRLUhEREROwpaf34q2IKWmpuL48eMIDw/XpLm4uCA8PByHDx82q4x58+aha9euRoMjAEhMTIRKpUKhQoVkz6tnvOg+iIiIKO9SNEBKSEhARkYG/P39Jen+/v6Ii4vL8vojR47g7Nmz+PTTT43mefnyJYYMGYJu3boZjSbHjx8PX19fzYMz2IhI1/O05+CEX6K8RfExSNkxb9481KxZ0+iA7rS0NHTu3BmCIGD27NlGy4mMjERiYqLmERsbm1NVJiInc+PJDeQflx8VZ1RUuipEZEeKzmIrVqwYXF1dER8fL0mPj49HQECAyWuTk5OxYsUK/PDDD7Ln1cHRzZs3sXv3bpN9kR4eHvDw8LD8BRBRrlf257IAgKuPrypcEyKyJ0VbkNzd3REaGoqYmBhNWmZmJmJiYtCgQQOT165evRopKSno3r27wTl1cHT58mXs2rULRYsWtXndiSjveZn+UukqEJGdKN7FFhERgblz52LRokU4f/48+vbti+TkZPTq1QsA0KNHD0RGRhpcN2/ePLRv394g+ElLS0PHjh1x7NgxLF26FBkZGYiLi0NcXBxSU1Pt8pqIKHc6FXdK6SoQkZ0ovlBkly5d8ODBA0RFRSEuLg61a9fG9u3bNQO3b926ZbCfysWLF3HgwAHs2LHDoLw7d+5g48aNAIDatWtLzu3ZswfNmzfPkddB5MwuPbyEdefX4Yv6X8DbzRtPXj5BYa/CSlfL4bioFP9OSUR2ovg6SI6I6yBRXnLuwTlU/6U6AOCDmh/gRfoLrD2/Fvs+2oemZZoqXDvlqUZpV+Q9+tlR1C1RV8HaEJEptvz8VrwFiYiU1er3VprjpWeWao57beiFq19yYLIuFbK/fQEROQe2FxPlcbeTbsumX3t8zc41cXye+TyVrgIR2QkDJCKSVcOvhtJVQHJqMuKeZb1orL2su7AObZa1waMXj5SuChHlMAZIRCSrW41uSlcBLZe0ROCUQNxKvKXI/fWHaI7YMwJbL2/FqL2jFKkPEdkPAyQikpUpZCpdBRy+Le7JuOf6HkXuf/fpXdn0+8/v27kmRGRvDJCISFZKeooi9z0Vdwpzjs+RdGOpAyV7qzyzsmz6k5dPuGgkUS7HAImIZKVkKBMg1fm1Dvps7oOiE7WLwP56/FdF6pKcliybvv3KdqPBExHlDgyQiEjWy/SX2HVtF1osaoFLDy8pXR2b+/v234jaE4XUDOMr7Leu0NrouVuJtwzGKBFR7sF1kIhIVkp6ClouaQkA6L62O458diRH7zfx4ET8cf4P2XMF3AvY/H4N5on7Pfp6+OLrhl8bnE/PTMe9Z/dMlpGclpwjdSMi5bEFiYhkPU9/rjk+evconrx8kqP3G7JrCI7ckQ/CnqU+y7H7rvhvhUFaakYqQqJDstx77eCtgzlUKyJSGgMkolzk5pObaL6wOdadX2dWflMDjX//93fJ8yWnl2iObzy5YbJrKicYm1FmjQO3DmiOj909hoTnCZLzHmM8cO7BuSzLYesRUe7FAIkoFxm5dyT23dyHd1e9a1b+bZe3mV32l9u/xMaLG6EapULZn8ui9VLj43MslZGZkWWeF2kvbHa/JguaSJ4Xn1Qcmy5usricHVcNN8wmotyBARJRLvLwxUOL8pctXFZzfOjjQyjlU8pk/nYr2mmOd1/frTlOTk1Gqaml0HN9T4vur2ZO951KZZt90IxtrfLOincAiGOPzPXDXz/YpE5E5HgYIBHlEplCJjZf2qx5npaRZtH1DYIaIHZQLE71OWX2NZsvbYYgCKgVXQt3nt7B4tOLoRqlwsPnlgVqR+8ezTLPtsvb0Gl1J4sCGH1PU54i6Kcgo+dfpL3AodhDkrS/PvrL6vsRkfNigESUS8w7MU/y/GnqU9l8aRlpeP+P9zHn+BxN15Zuy1GQr/EAQl/b5W3h8oOLwca2poIQOca66zxcPTR1+2LbF1hzbg3cRrtZVLausfvHmjw/88hMNFvYTJLml9/P5DWqUSqM3jfa6joRkWNigESUS/Te3FvyvM/mPrL5Vv23CsvPLkefzX0024m4qLRvBQXdC2a7Li/SX+DKoyuyg8DTM9PRcVVHjNs/LstyUjJSZLvEKs2oZNWg7QkHJ0iev1nhTcnzwbsGS57X9KuJ8kXKZ1lu1N4oi+tCRI6NARJRLiDXnbbm3BqDtNSMVAzcPlDzXC5AcnO1voVGV8UZFeE11stgMcXNlzbjj/N/YNjuYQCA72K+M1qGh6uHbPrlR5dRcmrJbNdxY9eN+LDWh0bPn/r8FPK5cLk4oryIARKRk7mddBvVZlXDzCMzNWn/xv8rm/f64+ua4483fAyPMR6SgdzLziyTvc7NRRok/db2N7Pq9mf3Pw3Srj6+CkAcyP3uynfx2wltWYdjD2P8gfFGyxvedLhZ9zXXu1W1s/v++ugvuLm6YXGHxbJ5D/Q6IAkc1Ur7lkbEqxGSNLl8ROTc+FdN5AQyMjPQfW13TDk0BVF7onA+4TwGbBugOe/t5i17Xbnp5XDzyU0AwIJTCwzOTz8yHYC4rpEud1d3yXPdbqZ7X8uvLr2x60a0CG5hkF5xRkWoRqkw+dBkrLuwDlsub9Gce3/t+7JlqWU1q85S8c/iAQBda3RFkzLaqf5Vi1U1yFuvZD3ZMrZ/sB1lCpWRpKlb4ogo92CAROQEXpnzCpaeWYpvdn6DM/fPaNJT0sUNZSNjIjVpRb2KSq4N/jkYFxIuWHQ/AdJusebBzfFe1ffwfbPvEVAgQPaaGn414ObqhjYV28ie/37f9wZp+oGZvg9qfoBZb80yXk8L9kL7/d/fcTBWXPm6c7XOknP/9fvPIL9+kKhWtXhVgxY2Isp9GCAROQHdLrSklCTNsXp6/IaLGzRp97+9b3B90wVNLbqfXIvIms5rMLL5SKPXBBcKBiAObLbWyo4rAQATwicgcWgi3FzdUNy7uNH8c47PkTy/n3wfK86ukB2T9eE67Vgj/QBQpVIhuk00eoT0wGtlX5MNmHTprh+lZs5il0TkPBggETkZ3UHDw3cbjtGRGw/z4PkDi+5hzZga9UKOH9T6wOJrAaBluZboXL0zhJECBjcaDB8PHwDGW3IA4PMtn0uev7X0LXT7o5tkBl9GZoZBS1PLci0NyupTtw8WtV+EmB4xqFa8msm6tirfyiAtO+szEZHjYYBE5GQqFqmoOd53c1+O3GPFe4YbuMoZ//p41A6ojf71+mvSavjVwMauGy2+55Q3psim/3PnH7PLOH7vOABxvJVqlAqqUSrkG50PLj9I3+oKemRvKQO5Vb2fpz2XyUlEzooBEpGT0e1O03f4k8MAYNFq2HLaVm6Lp5FPcbLPSWRGGR+A7J/fHyf7nMTMt2ZK0ttWbovJLSfLXtO4dGNULloZOz/cCReVC76o9wVeDnuJmv7yXXP6A6jbVmoreX7jyQ00nNcQP+wzb9uP2W1mm5XPUotOL8qRcolIGVzggygXKVtIHBsTEhCC1OGpcB9jvHsqKwXcC6B2QG3Zc6Oaj8KeG3vQrWY3o9d/FvoZvtn5jSTt0heXULGotgUsIyrrcTuvlnpV8nxjt41ouqAp9t/aDwCoO6cuHr54iMO3D2dZFgDU8q9lVj45ugPUY3rEYNbRWVh7fi0A42s2EZFzYgsSkRN7r+p7kue6XT9urm54POSxWeXUL1nfovtGNYvCnp574JnP02geHw8fPI18im0fbMMvb/2CGwNvSIIjc1UsWhGrOq5CYIFALOmwBAAwpNEQAOKAcEs36C3mXcziOqgV9iysOX6t7Gv4o/Mfmuff7Ta+4CUROR+2IBE5sQzBdAuMr4evWeXs7rHbFtUxUMC9gMF2HtboVL0TOlXvpHmuDsx0lzwwV3YCJFP/3k9ePrG6XCJyPGxBInJiiS8TJTO0VJAOHlapVGYNuM7vnt/mdctJuksd6GtbqS288nnJnivgXgBFvIpYfV8uCEmUdzBAInJwpqaP77mxB4kpiSav71KjC071OYVz/c7Jnv+i3hfZqp8SUjJSjJ4L8Q/B82HPIYw0XERy+pvTs3VfrnVElHewi43Iwe2/ud/k+ag92p3k5aafA+KgbUCc5bbvxj4MjRmqOVe1uOE2G45OdyyQWtMyTZGRmYFBDQZp0uK+jkP0sWiUL1Ielx9exochxjemNaVX7V5YcGoBRjYzXCjz9w6/o/u67mhcurFVZRORY2KAROTgXqS/MHl+xpEZZpf1aqlX8WqpV9G4dGM0XiB+oJsaaO2oWpY3XOhxb8+9BgGifwF/k6t/m+u3d37DyGYjDfZgA4BCnoUAAC/TX2b7PkTkONjFRuTgZh8zvW6Pf35/zbH+GCRj1C1Kzkp/pe/VnVYbbT2z1f3kgiMA8HITxzu9SDMdyBKRc2GAROTgtl3eZvJ8fHK8xWV6u3lrji3Z8NVRdajSQbF7q/8tuZI2Ue7CAInIwam7cMxhbiuKbguM/satzsjVxVWxe6tnzF1/cl2xOhCR7TFAInJwvWr3ytHyuclq9ui2xh2ONW81byJyfAyQiBxcKZ9SAIAu1bvAVSW2lOR3y4+Pan9kkNea7S6MrRlE5lGPQQKAJf8uUbAmRGRLDJCIHFxaZhoAwN3VHft77cerpV5FTI8YuLm4GeTVbc3Iys9v/ox3Kr9jcj81yppugJmakapgTYjIlhggETm4lHRxUUR3V3c0CGqAw58cRlipME1rki5LZnJ9GfYlNnTdAHdX6ze0JWlQmtWinUTkPBggETm4Z6nPAIjbZOjSH1wd5BNktzo5EnP3m8spuutI6f8fEZHzYoBEedalh5cwfPdwPH5h3o73SlEHSAXdC0rS9btzRrcYbbc6ORIlZ7AB0la7hacWKlcRIrIprqRNeVbj+Y3x4PkDXHx4Eas7rVa6OrIyMjMw8+hMAFm3TnSv1d0eVSIiyhPYgkR51oPnDwAAf938S+GaGDfr6CzNsakAqVFQI8VbUpSidBcb5Q7JqcnovLozVpxdoXRVyEE4RIA0a9YsBAcHw9PTE2FhYThy5IjRvM2bN4dKpTJ4tGnTRpNHEARERUUhMDAQXl5eCA8Px+XLl+3xUohs6vpj7eKDT14+kZzTHYO076N99qqSw9jYdSNq+NXA2i5rla4K5QJTD0/F6nOr0e0PcVZn/LN4hC8Ox8WEiwrXjJSieIC0cuVKREREYOTIkThx4gRCQkLQqlUr3L9/Xzb/2rVrce/ePc3j7NmzcHV1RadOnTR5Jk6ciOnTpyM6Ohr//PMP8ufPj1atWuHlS24mSYbuJ8v/rjkCN1ftVP5HLx5Jzg2oPwAA8Halt/Nk61Hbym1xpu8Z1A6orXRVMKbFGKWrQNl06PYhyfOAKQGIuR6DKrOqKFQjUpriAdLUqVPx2WefoVevXqhWrRqio6Ph7e2N+fPny+YvUqQIAgICNI+dO3fC29tbEyAJgoBp06Zh+PDhaNeuHWrVqoXFixfj7t27WL9+vR1fGTmTB8kPlK6Cgehj0Zh0aJLmuUc+6SKQrwS+goeDH2JD1w32rhrpebvS2wCAgAIBCteErLX9ynbNcaaQqWBNyFEoGiClpqbi+PHjCA8P16S5uLggPDwchw+bt2T/vHnz0LVrV+TPnx8AcP36dcTFxUnK9PX1RVhYmNEyU1JSkJSUJHlQ3vJv/L9KV8FA3y19Jc/lVrwu4lXEYGd7sj91Cx4/WHMH1x/yXouspZ6mPMXmS5tx88lNpauSYxR9Z01ISEBGRgb8/f0l6f7+/oiLi8vy+iNHjuDs2bP49NNPNWnq6ywpc/z48fD19dU8goLy5noyeVlKRorSVZB4mvLUIG1A2AAFakLmUAepGZkZCteEyD7eXv422i5vi+Cfg3H10VWlq5MjnPqr57x581CzZk3Ur18/W+VERkYiMTFR84iNjbVRDclZONqGrYtOL5I8D/IJQiHPQspUhrKkXtU8Q2CA5Ix0J0PISXzJFdL16c7+/XzL5wrWJOcoGiAVK1YMrq6uiI+Pl6THx8cjIMB0X35ycjJWrFiBTz75RJKuvs6SMj08PODj4yN5UO6mv8iiowVI957ekzxvXLqxQjUhc7CLzbnturbL5PlCEwrZpyJOSvff73na81zzd6BogOTu7o7Q0FDExMRo0jIzMxETE4MGDRqYvHb16tVISUlB9+7SxfHKli2LgIAASZlJSUn4559/siyT8g79ACkpxbHGna2/uF7yXHc2GzkedrFl35zjc/Dhug8V+bLi5WY4vo8sF/8sHvnH5Ufrpa2VropNKN7FFhERgblz52LRokU4f/48+vbti+TkZPTq1QsA0KNHD0RGRhpcN2/ePLRv3x5FixaVpKtUKnz11VcYM2YMNm7ciDNnzqBHjx4oUaIE2rdvb4+XRE5AP0Dqvam3QjWRd+7BOclzNxcGSI6MXWzW+/v23ygyoQj6bO6D3//9HYtOid3L3+74Fn039zV63bXH1/Ay3TZLt3i4emSdiTQEQZBNX3pmKQBgx9Ud9qxOjlF8q5EuXbrgwYMHiIqKQlxcHGrXro3t27drBlnfunULLi7SOO7ixYs4cOAAduyQ/08YPHgwkpOT0bt3bzx58gSNGzfG9u3b4enpKZuf8p7k1GTJ87TMNIVqYh4GSI5N3cXGFiRDSSlJKOheULJnna4G86Qt+9/s/Abv13wfkw9PBgBENolEad/Skjzv//E+lp9dDgA41ecUQgJCslVHbzfvbF2f18h9EWi7vC1q+dVSoDY5RyUYCwXzsKSkJPj6+iIxMZHjkXKhf27/g1fnvWqQLox0nD8F1Sjph8mA+gMwvfV0hWpDWbn79C5KTi0JV5Ur0qMcazybkqKPRaPvlr6oXrw6zvY7K5tH/3ddXxnfMrjx1Q2T17wY9gKe+az/Atx2eVtsvrRZkjay2UiM2jdK8/y3tr/hk1c+0b80T3r84jGKTCxikF7Is5BmxX+l3k9t+fmteBcbkb11XtPZIO31sq8rUBPz6XcJkmNhF5s89Vpe/z34z+Bc/LN4TDgwIcsybibexKJTi3Ah4YLRPBsvbrS+koBBcAQA3zf/HtWKV9M8/3TTpwZ58qrnac9l0/W3Q3J2DJAoz7mVeMsgrWqxqvjr5l84ee+kAjXK2q/Hf1W6CmSC7lYvuWUGj63pd1Z0XtMZQ2OGmnXtRxs+QtVZVbH18lYETDacjdxlTReoRqlwKPaQzNWW+eujv/Bi2AsAwPou66X1WP8RKs2ohNtJt7N9H2emHvtlagPt3IABEhGAe8/uodnCZnhlzitKV4WckO5q5gyQ5D1LfaY5nnlkpmQdHQD4KuyrLMtos6wN4pPjjZ5vNL8RUtItW/T1wK0DkudNyjTRdNfld88vObfo9CJcfnQZ/bf2t+geuUm3P7rhnRXvAMj9Y7cYIBEBkm+EjrYmEgBUKlpJ6SqQCeouNoADtXXVL6ldxPdF+gvEXItBm2VtMGCb4arwP735E+a/I78HpzHtKrczSPMc64n5J80v57uY7zTHrwRKvyAZ28Zn48WNuPb4mtn3yC0SnidgxdkVmlm2DJCI8gDdLhJLv4HaA2exOTbd3x9bj0OKfxaPjqs6Giz94Ax0B05XmF4B4UvCsfXyVoN86g2Xe9XppZmxNrjhYPz10V8GedVGNR9ldHPgTzYaH0ydkZkh+RvXbZH69W1pV7apL0vlp5cHANSfWx+qUao80XKoPxbS280bs9vMVqg2OY8BEuVpRbzEmRgqaGfF2GptFVvS/QAmx5PdLrb0zHQM3TUUN57cMDgXMCUAf5z/A9V/qa5Jy8jMwPDdw7Hvxj7Z8uRWij8TfwbzT87H1stb7fY7rtuN9jTVcH9BAFj+3nK8U/kdzfObX92EMFLAhJYT0KRMEzwe8hgjmo4wuC6qWRQmvzHZ5P1T0lMk/x/pmemo/kt11P61NtIyxKU9ggsFa86r3w/U5DaI1qUapcLRu0cBAFVnVTWZNzfQH0fmlc8Ln9c13GbExyN3zP5mgER5TmCBQM1xZGNxEVLdb/1yHx7vLH8HzRY2M7pAmq3pL1z3Zvk37XJfso45XWyj941G5C7DRW8BwG20GyYcnICyP5eVpOv/vj1IfoBx+8ehVnQtjN0/Fs0XNcfa82sleVSjVPAY4wHVKBW2Xt6KenPrwW20G2pF18InGz9Bm2Vt4DXWC9/u+NaKV2pbwkgBXWt0NZmnkGchdKvRTZKmbnEq4F4AKzuuRJViVQyuU41SwXOsJ1x/cNUEngnPE3Dx4UVcSLgA9zHuiNoTJVnUsFzhcpIyinoX1dwrK5ceXkLUniiz8jor/cD74YuHAJCtJRYcmeILRRLZ271n4j5npXxKaT7YdP/wz9w/g5I+JfHf/f8w6dAkjH99PDZd2gQAuPLoCioWrZij9buddBspGdJuvu+bf5+j96TsyaqL7X7yfUTtFT88KxerjF4bemnO6W9CnPgyEb6evgCAflv6Sc75TfYzKPu9Ve9p1py5mHBRcq7NsjZG6zz58GS0qtAKmy5uwoSWEyz+kJtzfA5O3juJmW/NlG3hzOrLxI2BN8y+V9Xi0taZtyu9rTnuXL0zOlfvjJfpL+E1Vr7FRz/wVBv912jN8TcNvpHNo9u6BQDz35mPjzd+bLS8/vX6w7+Av+x5Z6cenK2mDjzltm66n3wffvkNf1+dCVuQKM+6nXRb88auOyZBvY9Qjdk1sOj0IpSYWkJzzh57tlWcYRiAca8ox6bfxbb8zHKciT+jSbv88LLmWDc4AgzXjlFvjJqSnoLo49Fm3X/+yfmYcmgKqswybEkxpeWSlph+ZLrRwELO87TnuJV4C30290H08WgUm1QMAHD0zlFUmlEJ+2/uR/yzeLj8YPzjpWmZpihTqIxFdd3RXWzp8fHwkR087ZnP02BaviX+vPqnWfm61exm8nzAFNMbrTuzs/flF/uU61busa5HTlcnx7EFifI0uRYkAPAeKz87w9g4Cl3qb87GtlbIiiOOgSLTdD+wt1/Zjg/XfQgAyIzKxKWHl7Do9CKLyssUMuE51vwWHVODknXt77Uf269sx9j9Yw3OTft7Gmr41UB4uXDEP4vHrcRbqFeyniTPy/SXyD9OOvX9ycsnkpWtmy5sarIODUo1wKZum8yqr67wcuFY3H6xwbYjulqUbWFxuWq6i0Ka4pnPEwc/PohG8xtZfa/cIsTf+BYv5gacjowtSJRrTft7Gr7f+73JPOoWpMuPLkvSX6S/kM0/+1jWMzbarWiHar9Us1mgY6zpnxzTrKOzNMcuP7igyqwqmHtibpbXfVpHu1Kz/iatr5Yy3BrHUuu6rEPj0o0xpNEQ2fOD/hyElktaQjVKhYApAaj/W33MPDITgPgFovH8xha1NBkzuNFgqwbxqlQqfBjyIZoFNzOaJ79bfqPnstK/nvG1jXTHmAFAw6CGONlHXFR2TIsxVt/T2Z2OP23yvCPOCLYEAyTKleKfxWPQn4Mwat8oSfeGeuYKAHxQ8wOLZxyt+m+V0XMv01+iwbwG2HRpEy4kXMCe63ssrzik32QfDn6IiS0nWlUOKePqo6sW5Z/ZeibuRtzFqBbafb/mnJgjyfN9s+/x/LvnSBuRhtEtRusXYWDeO/Mkzxe2W6hZM6igR0Gz6zZg2wDcfXoXHmM8cDD2oNnXqfWr288gaNGfgGBLri6uePDtA6uu1V8UUlfC4AQUcC+Asa9pW95qB9SGMFLAsKbDkPxdMioUqQAg968uLadx6cay6XHP4uxcE9tiFxvlSuqdvgHg0YtHAMRuixVnV2jSZ7SeYXEzefPg5kbP1filBq4+1n44vrXsLQDiYFRLxluElw3XrHmjP+2YHN+D55Z9QPevn/WqzC3Lt9R04w1vOhzDmw4HYHyj1+61uqNeiXpYeGohJracaDCIWhgpIFPIhIvKBQXHF5Sscq2v5NSSsunHex9H6JxQzfNz/c6havGqSE5Nhmc+T809v274Ncb8NQYLTi0AILa+5KRi3sVw9LOjqDe3nsE5YaSA1IxUuLu6G/zb1Q6obbTMQp6F8DTSePe6t5s3try/BZVnVkY+l7zzsaoORtd0WoN5J+ehctHK6Li6o+a8s+8hyRYkypXKFy6vOVZ3l7n+4Ioe67UDBwt5FpKsgWKOvTf2Gj2nGxzp+nanZdOp1YvTya39Qs5NGClgR/cdONP3DKa1moY/u0vHaUS3MRyUHTso1uiKzjE9YhDkE2RwD3dXd9T0r4kpraYYXUNLXebTyKcQRgpIGpqEn9/82azXcbbvWbwS+AoyozKxqdsmPB7yWDPTLL97fsk9yxUuh/nt5iNleAqShiZpZujlpNDAUHzX+DvMaD3D4Jy7qzsAcRarWmZUptF/Y3Opr88LC0aqFfMWB+j7F/DHd02+M1i4c88N61rRHUXeCXUp1xMEAcN3DzfYLuCTjZ9g0KuDDPKrVCoMenUQtl3ZZtF9+m3ph9EtRqOod1FN2uMXj43mt3QDTfUU/6wWqSPn1LJ8SwBADb8aBuf61O2Dz7doF957/t1zkzMYXyv7Gm4NumW0JckSBT0KYkD9AWhWphn+uvkXXqS/wJBd2vFK3m7eOPTxIaRlpqG6n7hopUqlkky5N8Xd1V0TnOQ0lUqFsa+L3WGr/luF/bf2G4y9ih0Ui9jEWBTxKmL1hApdeTFA0qe/xEWfzX3wWtnXNN2PzoYBEuUaO67uwLgD4wCIM2XUrj2+Jrv3E2DdeIHZx2Zj9rHZiB0Uq/kWGvZbmNH8d57ewcl7J1EnsA4AYOLBifj9399x8OODBuNBUjNScenhJQCAR76cG6tB9jez9Uyz8gkjBQiCYNGH9tm+Z1Fjdg2s6mh8jJw5VCoVQgJCEBIQghtPbkgCpBXvrUBIgPFZS45q8/ubse/GPrSq0MrgXJBvkMwV1mGABNl1j648usIAiUhpGy5qV7w9fPuwWdeY+nbeMKihydafoJ+CNGMa9GfB6XtlziuaxfzUHzo+P/po0tSaL2yuqXtuXZ02r2lfpT2WvbvMorWsLG3RqO5X3eB3KbuCCwVjXZd1+O3EbwguFIw2lYwvOunIfDx80LZy2xy/jzpAyiubFcst1SC7ojmy3zqnFAZIlGuYMwVfn6lurIXtFqLSzEomr3/84jGKTDR/ILX+YNhHLx5JBmLrBnY5OduH7GdYk2FOu9Bn+yrt0b5Ke6Wr4RTUSwHkhRakOW/PMbtrNbtju5TkvDUnyobvGn8HwHQLkjnToTus7CCb/uvbv6JjtY6StALjCqDgeGmZCc8TAIjjp/SXEDh291iW9yfH5+uR84OSSXl5oYtNvWTD6+VeN/saW4zvUgoDJMqTXiv7GgBpK41+P7lnPk/s77XfZDn7bkp3U6/pVxPCSAG9Q3tj2bvLJOeS05INrn+e9hwAMPnQZHRZ00Vy7mUGV9TODXLLzuZkWl4IkAT8f5cAC7rNnLmLjQES5TlvV3pbsyWB7iBt3Wm/gBg8NS7dGEc/O4qEbxPMKnvam9M0x26ubllu1vg05SninsVh8K7BBueqFqsqcwU5G0sWZiTnpQ6QBAhZbtTrrMzZRunH13+UPGcLEpED6Fqjq1n5VndarXkz0109V39RRvUssrol6qKod1Hc/+Z+lmWrW6bUbgy8gaZljO9N9TT1KQKnBMqeGxg2MMv7kWP7ofkP8HaT39ePchfdsTbqlpbcxpwWpCGN5beycUYMkCjXMHcFW2ODnz1cPfBJHe2mn/qDC4vnL46NXTcaLVd/zBEgjnEqWVB+JWIAuJ1023g9Oc3fqQ1vMhwjmnGxz7xC9/0it85ks2YjbvXCt86IARLlGhcTLhqkxX8Tj7099yKmR4wmzdgft0c+D4SXCzd5j7TMNKPnlr67VDZdvdWJWotg7Y7jfTb3MXk/cl72WhSRHIMkQBJyaYBkxRgkZw4WGSBRrnH07lGDNL/8fmgW3AyvlX0N0W2isfX9rUavd3dxl2wUK+fNCm8av97IB2K3Gt00x0c+PYLdPXebvMevb/+KzKjcO9Azr3Dm6c1kOd3tVdZfWK9cRXKQNS1Izhwsch0kcjrXH1/H3ht78VHtjzR/qHeS7hjku9D/guR5n7qmW2vcXd1Ry78W/uj8h8GAbTVvN28sar8IaRlp+HTTp2bVV/eDsl5Jww001V4Oe4l8LvmM7p1FzsWZB6eS5XT/zi8kXDCR03nltRYkBkjkdMpNLwdA7Lr6uuHXAIBa0bU052e9NQv96vWzuFz1GKZ3q75rMl+PEHHDW3MDpFr+tbLOBI45ym3aVsr51ZvJcegGSMmphkt65AYcg0TkJL7Z+Y3mWHecT1YBjjGWttzojmsytdZNSEAItr6/FWf6ntGkbf9guyRPucLlLLo3OS5fD19cGXAFNf1rKl0VsiNJgCSz5lluYFULkhN3sTFAIqdy/sH5LPNYuzCfubPg1F4r+xou9L+AztU740CvAybztq7YWrJ7u/5Yp50f7rTo3uS4fD19Ub5IeaWrQXaWJwIka8YgsYuNyD6G7xmuOf489HMAQEp6iiSPqf3VTLE0QAKAysUqY2XHlRZfV8izkOS5qaUAyLlwcHbepPv//jTlqYI1yTnWtCCpu9hW/bcKaRlp+KDWBzlSt5zAv2RyKm0qancUVy/AN//kfEkeSwfHFvMuBgB4p/I72ayd+Qp6FJQsIMnxR7kHu0vzJt2gQb2FUG6V1Xvs2b5nNccZQgaSU5PRZU0XdF/XHfeTs15w11EwQCKnorvatXpNon5btQOy7319z+Iyr355FWf7nkX9kvWzX0ELLG6/2K73o5y1t+dedKjSAYvaL1K6KqQA3aAhN85g1N0+JasWpOp+1dGgVAMA4gzjm4k3NefuPbX8PVop7GIjp5KWoV2occaRGQbdaQEFAiwu08fDB9X9qme7bpYqU6gMDn580GCLE3JOzYKboVlwM6WrQZQjdLdPMScAPHz7MABxWESTMk006ZExkdj6gfH16BwJAyRyKluvSP+wJh6aqFBNbKNhUEOlq0BENrb9ynYcvHUQhb0KZ7n4rLOwpAVJn26XY1JKks3qlNPYxUZ2kZKeYpO+54WnFma/MkREOUC3Rbvxgsao/kv1XLOqdnY24H2R9kJzfDD2oC2qYxcMkMguQqJD4D/ZHzee3FC6KkREOWJEU8PNiXus66FATWxP0oJk4Rgr3TFIzoQBEtnFxYfiRrJbLm3JVjn1ShjfquPql1ezVTYRUXbILRXyNDV3TPmXjEEyo4tNvSl3Lf9aGL57uOTce6ves23lcggDJLKr7DTTAjC5AB+nVxORknLj7DU55rzOVuVbAQBCA0PRPLi55Nza82vxMv1lTlTNphggUY7IFDI1TbK6K6neSrxldZnnHpzDirMrsl03IqKcINey0q5yOwVqYnuWDtJWb910Mu4ktlw27DmoN7ce9t7Ya7P65QQGSGRzgiCgyYImqDe3HtIz0yXL7k86NMnqct9Y8obRc/3qWr45LRGRLcntO1ahSAUFamJ7lk7zd1WJAdKpuFOy58/eP4sWi1rYpG45hdP8yeaSUpJwKPYQAODu07uStYuy487TO7Lpqzqususq2EREcn45+otBmjN0JZnD2hYkUyoVrZStOuU0tiCRzSWmJGqOXVWuqP1rbcn5YhOL2Wy6/rou69Cpeidu1UFEipObrXX07lEFamJ71rYg6Vr+3nLJ838//zf7FctBigdIs2bNQnBwMDw9PREWFoYjR46YzP/kyRP0798fgYGB8PDwQKVKlbB1q3bxwIyMDIwYMQJly5aFl5cXypcvj9GjR0uiX8pZuguBpWem41nqM8n5hy8eoteGXtm6x6L2i/A08inaV2mfrXKIiHLSkTumP9OchS1akLpU7yJ57uhfbBUNkFauXImIiAiMHDkSJ06cQEhICFq1aoX79+UXFExNTUXLli1x48YNrFmzBhcvXsTcuXNRsqR2J/QJEyZg9uzZmDlzJs6fP48JEyZg4sSJmDFjhr1eVp6nGxAF/xxsNJ//ZH+LyvXx8NEcf1jrQxRwL2Bx3YiI7C3uWZzSVcg2S1uQ5JY8UKlU2NB1AwBgYrjj74Kg6BikqVOn4rPPPkOvXmJrQnR0NLZs2YL58+dj6NChBvnnz5+PR48e4dChQ3BzcwMABAcHS/IcOnQI7dq1Q5s2bTTnly9fnmXLFNmOuWOO7iffx8FbB9GodCOz8nep3gVzT8zF6Baj88x0WiJyfoFTAiGMdM5eDEEQcDvpNgp5FtKkmdWCJNPFBgDvVH4HjwY/kpTnqBRrQUpNTcXx48cRHh6urYyLC8LDw3H48GHZazZu3IgGDRqgf//+8Pf3R40aNTBu3DhkZGhnDjRs2BAxMTG4dOkSAOD06dM4cOAAWrdubbQuKSkpSEpKkjzIemmZ5g/KbrygsdmLR6ZmpAIA3F3draoXEZFSbDVZxZ7239wP/8n+KD2tNEbs0a4SbtYYJL0uth3dd2iOC3sVdoovuYoFSAkJCcjIyIC/v7Sbxd/fH3Fx8s2R165dw5o1a5CRkYGtW7dixIgRmDJlCsaMGaPJM3ToUHTt2hVVqlSBm5sb6tSpg6+++goffPCB0bqMHz8evr6+mkdQUJBtXmQelZ6ZblH+t5e/LZu+8+pOlPu5nGbtI3Xg5ebilr0KEhHlMM98npLnWy87xw72upoubIoHzx8AAH7+52dNujUtSHVL1LVt5exA8UHalsjMzISfnx/mzJmD0NBQdOnSBcOGDUN0dLQmz6pVq7B06VIsW7YMJ06cwKJFizB58mQsWrTIaLmRkZFITEzUPGJjY+3xcnItY9+U/v7kb7PLeJH2Am/8/gauP7mObn90Q3pmuqZcN1cGSETk2Fa8J13Utv3K9jgcK9874mysaUFyxjGjigVIxYoVg6urK+Lj4yXp8fHxCAgIkL0mMDAQlSpVgqur9h++atWqiIuLQ2qq2P3y7bffalqRatasiQ8//BCDBg3C+PHjjdbFw8MDPj4+kgdZz1gLUlipMAgjBUS3iZY9r3bp4SXN3m1qiS8TsfrcagDSWXJERI7iRO8TmuPGpRsbnG84v6E9q5NjjI0v0qU/SNsZv9gqFiC5u7sjNDQUMTExmrTMzEzExMSgQYMGstc0atQIV65cQWZmpibt0qVLCAwMhLu7OC7l+fPncHGRvixXV1fJNaSVnJosCTh6rOsBjzEeku1BLCU3BulUn1Oa4z51+6CIVxHZa889OIfKMyujzq91JOnFJhXTHHO7ESJyRHUC6yD+m3ikDE9xyoBAl6mlccxZBNKcIMrRKdrFFhERgblz52LRokU4f/48+vbti+TkZM2sth49eiAyMlKTv2/fvnj06BEGDhyIS5cuYcuWLRg3bhz69++vydO2bVuMHTsWW7ZswY0bN7Bu3TpMnToVHTp0sPvrs4f4Z/FYcHIBHiQ/wLG7x9B9bXfNYOasCIKAmrNrotjEYkhOTYYgCFjy7xKkZqQi3+h8khVgd1zdAdUoFQZtHwQAOP/gPB4kP5AtV64FqZZ/LcnzMS3GGOQBgOhjpluXAOCHFj9kmYeISAl++f3g7upudDJJvy39MOXQFDvXynLmfo4YY04Q5egUnebfpUsXPHjwAFFRUYiLi0Pt2rWxfft2zcDtW7duSVqDgoKC8Oeff2LQoEGoVasWSpYsiYEDB2LIkCGaPDNmzMCIESPQr18/3L9/HyVKlECfPn0QFRVl99dnD2/8/gb+jZeuRrr0zFLc/OomSvuWhiAImHxoMl4JfAWvl3tdk+dO0h2U+qmU5nnRiUUxt+1cSTld13TFiKYjUHeudnDdtH+moah3Uc2MhtThqVh8ejHCy4WjTKEyAOTHIOn3WX9e93P02yrun1a5aGUAwLrz6zDjSNbrVanzExE5KmOTSWYfmw0AeLfquyhbuKw9q2QR3T00rZEbWpBUApeYNpCUlARfX18kJibabTzSg+QH8PX0hburOzqu6ohHLx5hV49dcFGZbuRTjTI+WG5j140o6FFQsyHg+NfHY/ax2biVeMumdVd7MewFPPN5Yv7J+fhk4ycIKxmGk3En0aR0E+zqscsg/4YLG9B+ZXsAQNlCZXH9yXWDPAvaLTBYdfvWV7cQ5MuZhkTk2Ey9Py9otwAf1f7IfpWx0K3EWygzrYzsOXPWdNp+ZTtaL9Uur2OvdaBs+fntVLPYcqt5J+bBb7IfPMZ44N2V7+KP839gz409uJggDlTOyMzAgVsHMHTXUHy0/iOoRqk050x5Z8U7SHyp3RctMiYyx4IjAPhw3YcAxHFNAFCmUBk8HPwQf3b/Uza/t5u35lguOAKAniE9DdICCwZmt6pERIoq6F5Q6SqYpH4fL+xZGEvfXapJH9rIcBFnObqDtM29xtEo2sWWl6kb7lx+kMao6y6s0xxX+6UaXFQuyBQMB5hXmVXFrPuoW2jsYc25NQC0W40UcCtgcmrn87TnxsvqtAYtyraASqWCX34/3E/Wbj8jt4Q9EZGj2fbBNqw7vw5zTswxONd/a3+8V+09BWplHnUXWwH3AuhaoysWn16MqsWqYny48RnhunS72Jxxij/AFiS7u/LoCvps6gOXH1xQcmrJLPPLBUe29nDwQzQr0wxe+bzwcPBDnO17VnK+U7VOWN1pNTKiMhDZOBINSjUw2ioEAI9fPgYg3TtNjqlBgO9Ve08z021NpzXmvhQiIofxZoU38WvbX1HDr4bBufjkeMw/OR/xz+JlrlSe+otufvf8cFG5YHv37fjpzZ/Mvl53kDYDJMrSnaQ7qDijoubbxL1n92xWtnrgcqOgRpjdZrbJvBu7bsSDbx8g7us4CCMFFPEqgr0f7cXzYc9RxKsIqvtVR+pwbfBSJ6AOOlbrCBeVC8a9Pg6HPjmEN8q/gTN9z6BOQB2D8qcengoAmkHbxqRkpJj12pqUaWJWPiIiR3T689Oy6Z9s/ARNFmT//U13KPHmS5ux5dIWHLt7TPIFO/FlIlouaYl5J+YBAA7HHsY7y9+RzFbWpe5iy++W36o66bYg5Xe3rgylMUCyo2N3j5k8X8y7mMnzxtwedBvbPtiGQa8OwvL3luPzup/L5hNGChBGCmhbuS2KeReDfwF/2XyAuKjXuNfG4ZXAV9C3Xl/ZPDX8auBEnxMY3HCwJm3r5a3IEMQ1lLLaM82c5erVZr01CwDw69u/mn0NEZEjMDXZ5vKjy9kqu8SUEnD5wQXJqclIeJ6Atsvb4u3lb6Pe3HqYeHCiJt/EgxOx69oufLrpU2RkZqDh/IbYdGkTqv9SXVLe87TnePTikaSLzRq6LUjZWVdPSQyQ7EiA/Cj+uiXqokKRCoj7WrsHXYvgFgb59vTcg7N9z+Jp5FMsar8ITyOf4uHghyjpUxJlC5fF1FZTNbO7rg+8jrWd12qurVS0ksX1jWwSieO9j2e563LP2tqB1G2WtdEcd6hieu2pVhVayaav7rTaIK1fvX54OPgheof2NlkmEZEjeruS/J6T2aXuiVj530okPE+QnPthn3bNuHEHxmmOS0wtoTm+9via5Jra0bURMDkAC08tBADsu7nPqnrptiDtuLbDRE7HxdGudjT6r9Gy6Uc+PaJZJ0gYKeBW4i0EFghEWmYaqs2qhiDfIOztuVcSkfcI6WHyXsGFghFcKBiXB1zGz3//jG8bfWu7F6LH2KrYfvn9TF4n12J2vv95VCkmPwDd2H2IiBzdpm6bTE77t4Zu19rFhIsGay8Z+1KuO+kFEFuNvN288fD5Q02L1rYr27JVN93JNB6uHtkqSylsQbKjqKbyi1XqL6JY2rc03Fzd4O3mjcsDLhsER5aoUKQCZrw1A6V9S1t1vTkCCsjvnWdOnYt6FZU8Dy4UbIsqERHlerrjhyYemqhZhFL3/Ml7J7MsZ/KhyQCAzzZ9ZnCuV+1eBmnm0J2Ew0HalKV2VdpZfI2bq5tTLtk+9rWxZuU7/MlhSfDmmc8zp6pEROSQrB2jo79USqvyhsMWXpnzCv67/5/JckbuHYn9N/dLlplRa12htcwVWdPdk/PH8B+tKkNpDJDsLG1EGq4MuILer4hjaQbUH6BwjXLGtw3N69KrWLSi0ZY1IqLcZHab2fiy/pcG6YdvH7aqPP0A6dGLR7L59t7Ym2VZTRc2lU1vU6mNbHpWdLv/shrH6qgYINlZPpd8KF+kPGa/PRtXBlzBz2/+rHSVbOLKgCua4ylvTLFoJ2v9jWyJiHKjz+t+jp9bG77nWzvV/0X6C8nz6Uemy+Z79OKRRbOG1T4P/Vyy44G1stoyy1FxkLZCXFQuKF+kvNLVsJnyRcrjTsQdHLx1EB2qmp69pq9eyXrY3G0zyhUul0O1IyLKfczdOipqbxRKFCyBu0/vatI+qv0Rzt4/K7v8zINvH2Dt+bXoUr2L1XWzZua0o+FmtTKU2KyWiIjyhqX/LsXXO75GfLJ2Fe3jvY/jlcBXNM8fJD9AMe9iBpN4dBmbFTe37Vy0CG6BCjMqGJw70/cM/PL7wS+/n+yGtN5u3kj+LtnSlyTryJ0jKOxZGBWLVrRJeebgZrVERERO6oNaHyDumzhJWuicUM1xyyUt4TfZD5VmGm+FeWPJG0bPffrKp0Z7KAq4F9AswSI3u3lIoyEm626J+iXr2zU4sjUGSERERArQ321APW1/17VdAMS9O43ZeW2nbLruTOARTUcYnDe2dcji9osxpsUYsyfY5AUcg0RERKSARkGNsOfGHs3z3078hi/qf2FVWbPemgUVVGhbua0mbWSzkQYLFOvvi5Y6PBUChCy3hsqLGCAREREp4MuwLyUB0oBtA7LcsxOQTqEHgI9rf4x+9foZ5HN1ccX0N6fjy+3apQW88nlJ8lgy4zivYRcbERGRAuTmSC06vUjyfPo/07HjqnQvs6uPr0qeD2owyOg9mgc3lzw3NeibpBggERERKUB3tWljBm4fiFa/t8LmS5s1abpbjMx7Zx5q+NUwer1HPufcB80RMEAiIiJSQHpmutl52y7Xji369divmuOP63xs8jr9/S7JfAyQiIiIFGDtHmzLzy43O29RbwZI1mKARERE5EQev3ysdBXyBAZIRERECmhXpZ1V1w1tNBQA8FrZ1yy6btCrxgdzkyFO8yciIlKAj4d1W2FkCpkAgFp+5m30nRmVifMJ51GlWBWr7pdXsQWJiIjICagHdf948EcA4jpH5lCpVKhWvBpcVPzItwT/tYiIiJzAs9RnkueHbx9WqCZ5AwMkIiIiJxD3LE4y800FLvqYkxggERERKeR8//NY12Udfn7zZ03alDemyOatOqsq6s2tp3le0KNgjtcvL+MgbSIiIoVUKVZFM3j6yzDtnmlf7/haNv/JuJOaY24wm7PYgkREROSEPgr5SOkq5GoMkIiIiBxMcKFgAEDrCq1RoUgF2Tztq7S3X4XyIAZIREREDmZvz70Y1XwUFndYLLtn2yuBr0Cl4iDtnMQxSERERA6mTKEyiGoWBUB+z7YT907Yu0p5DluQiIiIHFhsUqzSVciTGCARERE5mQalGihdhVyPARIREZGT4SraOY8BEhEREZEeBkhEREROZmDYQKWrkOsxQCIiInIy5QuXV7oKuR4DJCIiIiI9DJCIiIicjABB6SrkegyQiIiInETTMk0BAB2rdVS4Jrmf4gHSrFmzEBwcDE9PT4SFheHIkSMm8z958gT9+/dHYGAgPDw8UKlSJWzdulWS586dO+jevTuKFi0KLy8v1KxZE8eOHcvJl0FERJQjjn52FEE+QTj22THs7rEbSUOTUKJgCaWrlesputXIypUrERERgejoaISFhWHatGlo1aoVLl68CD8/P4P8qampaNmyJfz8/LBmzRqULFkSN2/eRKFChTR5Hj9+jEaNGqFFixbYtm0bihcvjsuXL6Nw4cJ2fGVERES2UbdEXdwadEvzvKBHQQVrk3eoBEFQrCMzLCwM9erVw8yZMwEAmZmZCAoKwoABAzB06FCD/NHR0Zg0aRIuXLgANzc32TKHDh2KgwcPYv/+/VbXKykpCb6+vkhMTISPj4/V5RAREZH92PLzW7EuttTUVBw/fhzh4eHayri4IDw8HIcPy68QunHjRjRo0AD9+/eHv78/atSogXHjxiEjI0OSp27duujUqRP8/PxQp04dzJ0712RdUlJSkJSUJHkQERFR3qVYgJSQkICMjAz4+/tL0v39/REXFyd7zbVr17BmzRpkZGRg69atGDFiBKZMmYIxY8ZI8syePRsVK1bEn3/+ib59++LLL7/EokWLjNZl/Pjx8PX11TyCgoJs8yKJiIjIKSk6BslSmZmZ8PPzw5w5c+Dq6orQ0FDcuXMHkyZNwsiRIzV56tati3HjxgEA6tSpg7NnzyI6Oho9e/aULTcyMhIRERGa50lJSQySiIiI8jDFAqRixYrB1dUV8fHxkvT4+HgEBATIXhMYGAg3Nze4urpq0qpWrYq4uDikpqbC3d0dgYGBqFatmuS6qlWr4o8//jBaFw8PD3h4eGieq4dlsauNiIjIeag/t20xvFqxAMnd3R2hoaGIiYlB+/btAYitPzExMfjiiy9kr2nUqBGWLVuGzMxMuLiIvYOXLl1CYGAg3N3dNXkuXrwoue7SpUsoU6aM2XV7+vQpALAViYiIyAk9ffoUvr6+2SpD0S62iIgI9OzZE3Xr1kX9+vUxbdo0JCcno1evXgCAHj16oGTJkhg/fjwAoG/fvpg5cyYGDhyIAQMG4PLlyxg3bhy+/PJLTZmDBg1Cw4YNMW7cOHTu3BlHjhzBnDlzMGfOHLPrVaJECcTGxqJgwYJQqVQ2fc2hoaG4cuWKTcskIiJyRrt370ZoaKjNyhMEAU+fPkWJEjZYJ0pQ2IwZM4TSpUsL7u7uQv369YW///5bc65Zs2ZCz549JfkPHTokhIWFCR4eHkK5cuWEsWPHCunp6ZI8mzZtEmrUqCF4eHgIVapUEebMmWOPl2KWypUrCwD44IMPPvjgI88/jhw5ovTHslGKroOUF1WpUsWgC5CIiCgvOnLkCOrVq6d0NWQpvtUIERERkaNhgGRnTZo0UboKREREinN1dUVgYKDS1TCKXWxEREREetiCRERERKSHARIRERGRHgZIRERERHoYIBERERHpYYBEREREpEfRrUacga23GiEiIiJlLFy4ED179jQrL1uQiIiIKE8ICQkxOy8DpCwIgqB5EBERkfMaN26c2XkZIBEREVGecOfOHbPzMkAiIiKiPCE+Pt7svNxqxAIcsE1EROS8vL29kZycbFZeBkgWYIBERETk3MwNe9jFRkRERHmCm5ub2XkZIGXhiy++gEqlYusRERGRkxs5cqTZednFlgUGRkRERLnDnj170Lx5c7PyciXtLDB+JCIiynvYxUZERESkhwESERERkR4GSERERER6GCARERER6WGARERERKSHARIRERGRHgZIRERERHoYIBERERHpYYBEREREpIcBEhEREZEeBkhEREREev4Hy73hByHbkmMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a figure and axis object\n", + "fig, ax = plt.subplots(2 , 1)\n", + "\n", + "# Plot the data\n", + "ax[0].plot(df_concat_btc['date'], df_concat_btc['close_btc'], 'blue')\n", + "# ax[0].plot(df_concat_btc['date'], df_concat_btc['vwap_btc'], 'green')\n", + "\n", + "# Customize the plot\n", + "ax[0].set_title('PAIR-BTC-USDT')\n", + "ax[0].set_xlabel('date')\n", + "ax[0].set_ylabel('close')\n", + "\n", + "ax[1].plot(df_concat_btc['date'], df_concat_btc['vwap_btc'], 'green')\n", + "# ax[1].plot(df_concat_btc['date'], df_concat_btc['volume_BTC'], 'red')\n", + "\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3c6d80b3-4a46-432b-9b88-6a264f9b7a7e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "First part of the DataFrame:\n", + " date close_xrp volume_xrp vwap_xrp close_eth volume_eth \\\n", + "17937 6-7-20 0.5232 49433.678414 0.523313 0.384779 27.276124 \n", + "17938 6-7-21 0.5233 801.681295 0.523286 0.384825 9.953973 \n", + "\n", + " vwap_eth close_ltc volume_ltc vwap_ltc close_btc volume_btc \\\n", + "17937 0.384768 0.8462 170.281602 0.846104 0.709604 0.941874 \n", + "17938 0.384780 0.8475 338.862661 0.846593 0.709634 0.190872 \n", + "\n", + " vwap_btc \n", + "17937 0.709530 \n", + "17938 0.709608 \n", + "\n", + "Second part of the DataFrame:\n", + " date close_xrp volume_xrp vwap_xrp close_eth volume_eth \\\n", + "17939 6-7-22 0.5229 8344.906144 0.523054 0.384777 5.698963 \n", + "17940 6-7-23 0.5229 4108.984575 0.522904 0.384792 31.878562 \n", + "\n", + " vwap_eth close_ltc volume_ltc vwap_ltc close_btc volume_btc \\\n", + "17939 0.384822 0.8473 67.170996 0.847403 0.709429 0.818917 \n", + "17940 0.384741 0.8474 32.162817 0.847309 0.709656 1.442286 \n", + "\n", + " vwap_btc \n", + "17939 0.709495 \n", + "17940 0.709480 \n" + ] + } + ], + "source": [ + "split_index = round(sample.shape[0] * 0.8)\n", + "\n", + "# First part of the DataFrame\n", + "sample_test = sample.iloc[:split_index]\n", + "\n", + "# Second part of the DataFrame\n", + "sample_valid = sample.iloc[split_index:]\n", + "\n", + "print(\"\\nFirst part of the DataFrame:\")\n", + "print (sample_test.tail(2))\n", + "\n", + "print(\"\\nSecond part of the DataFrame:\")\n", + "print (sample_valid.head(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "id": "4edcdbdb-85fb-415e-a6c4-71cc383c4410", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sample_size: 17939\n", + "[ 1384 5757 16213 13069 13373 6000 13791 4981 10888 8316 2533 5742\n", + " 9334 10830 17542 9836 11376 1664 16224 3630 10028 12874 11194 1160\n", + " 14281 5410 10529 11583 14703 6138 9215 11697 13449 7512 2548 3457\n", + " 15383 8654 12674 2381 295 15015 4884 11299 16782 4391 10095 6513\n", + " 3652 6528 14073 17098 9411 4580 7166 9903 9486 11610 12676 13070\n", + " 6903 16818 11461 1043 11513 11574 13418 4472 7134 6228 15303 5823\n", + " 14108 1230 1677 15232 4179 3161 16294 8711 5301 9021 2673 9559\n", + " 10899 11601 7617 796 2841 263 12059 2439 8251 5510 7132 4027\n", + " 1886 15771 354 3241]\n", + "XXXX ====== Actual Input ====== XXXX\n", + "[[[5.20000000e-01 8.56084855e+03 3.79046000e-01 ... 2.03619299e+01\n", + " 6.76403300e-01 1.93662680e-01]\n", + " [5.20000000e-01 2.72118622e+02 3.79189000e-01 ... 8.46549397e+00\n", + " 6.76504300e-01 4.19622650e-01]\n", + " [5.20000000e-01 2.79186141e+03 3.79209000e-01 ... 9.51299285e+00\n", + " 6.76559900e-01 3.23554580e-01]\n", + " ...\n", + " [5.20000000e-01 2.34551037e+03 3.79253000e-01 ... 9.23012016e+00\n", + " 6.76558500e-01 2.55822060e-01]\n", + " [5.20000000e-01 3.50569145e+03 3.79316000e-01 ... 5.44805370e+00\n", + " 6.76642900e-01 1.19834213e+00]\n", + " [5.20100000e-01 7.10046519e+03 3.78628000e-01 ... 2.05868650e+01\n", + " 6.76144800e-01 2.24357180e-01]]\n", + "\n", + " [[5.20300000e-01 2.93545880e+03 3.79701000e-01 ... 2.53874822e+01\n", + " 6.77093000e-01 2.22327350e+00]\n", + " [5.20200000e-01 3.12651115e+03 3.79640000e-01 ... 1.83111202e+01\n", + " 6.77082400e-01 1.31045968e+00]\n", + " [5.20500000e-01 1.75052628e+02 3.79667000e-01 ... 5.35875780e+01\n", + " 6.77240000e-01 4.97309079e+00]\n", + " ...\n", + " [5.20000000e-01 3.98791700e+03 3.79276000e-01 ... 1.91059710e+01\n", + " 6.76848200e-01 1.05492698e+00]\n", + " [5.20000000e-01 5.69737121e+02 3.79358000e-01 ... 3.18347024e+01\n", + " 6.76996900e-01 2.57768765e+00]\n", + " [5.20000000e-01 1.12777242e+03 3.79209000e-01 ... 5.55224208e+01\n", + " 6.76583600e-01 1.40268434e+00]]\n", + "\n", + " [[5.20400000e-01 8.67225652e+03 3.80053000e-01 ... 4.50314861e+01\n", + " 6.77052500e-01 2.27481940e-01]\n", + " [5.20500000e-01 3.46548103e+04 3.80022000e-01 ... 3.13637753e+01\n", + " 6.76988800e-01 8.76670170e-01]\n", + " [5.20800000e-01 4.68701195e+03 3.80407000e-01 ... 8.55327881e+00\n", + " 6.77175400e-01 1.22887788e+00]\n", + " ...\n", + " [5.20400000e-01 1.64008808e+04 3.80139000e-01 ... 9.18567195e+00\n", + " 6.76818400e-01 5.53732460e-01]\n", + " [5.20400000e-01 3.08324726e+03 3.80059000e-01 ... 2.94599945e+01\n", + " 6.76661200e-01 1.83913002e+00]\n", + " [5.20300000e-01 5.95064867e+03 3.79930000e-01 ... 9.88781977e+00\n", + " 6.76423300e-01 5.63015055e+00]]\n", + "\n", + " ...\n", + "\n", + " [[5.23900000e-01 2.45069102e+04 3.85197000e-01 ... 1.02574301e+01\n", + " 7.10021100e-01 6.22385750e+00]\n", + " [5.23800000e-01 6.93309624e+03 3.84956000e-01 ... 8.44888757e+00\n", + " 7.09474700e-01 1.82884794e+00]\n", + " [5.23700000e-01 4.12015524e+03 3.84846000e-01 ... 1.06924232e+02\n", + " 7.09350200e-01 1.86376625e+00]\n", + " ...\n", + " [5.23800000e-01 5.77692784e+04 3.84756000e-01 ... 1.66761842e+01\n", + " 7.09051100e-01 5.99728850e-01]\n", + " [5.23900000e-01 1.89309224e+04 3.84884000e-01 ... 5.71141576e+01\n", + " 7.09201100e-01 3.29582923e+00]\n", + " [5.23900000e-01 5.61077570e+04 3.84962000e-01 ... 2.61822582e+01\n", + " 7.09247000e-01 4.49988880e-01]]\n", + "\n", + " [[5.27500000e-01 1.06101033e+05 3.83875000e-01 ... 6.35624910e+01\n", + " 7.14000700e-01 2.14567180e+00]\n", + " [5.27400000e-01 3.05276624e+04 3.83896000e-01 ... 3.02172816e+01\n", + " 7.14079700e-01 3.02984498e+00]\n", + " [5.27500000e-01 1.08386986e+04 3.83909000e-01 ... 1.87709165e+02\n", + " 7.14251300e-01 5.73878876e+00]\n", + " ...\n", + " [5.27300000e-01 2.18365663e+04 3.83990000e-01 ... 2.19385179e+01\n", + " 7.14393600e-01 5.18800769e+00]\n", + " [5.27300000e-01 6.10690967e+03 3.84390000e-01 ... 1.01786571e+01\n", + " 7.14956400e-01 8.79365379e+00]\n", + " [5.27300000e-01 2.35593068e+04 3.83868000e-01 ... 4.16372778e+01\n", + " 7.14482400e-01 6.17570624e+00]]\n", + "\n", + " [[5.20200000e-01 1.41947088e+04 3.79926000e-01 ... 2.63679389e+01\n", + " 7.07415700e-01 4.74391646e+00]\n", + " [5.20300000e-01 8.84749542e+03 3.79982000e-01 ... 2.20708443e+01\n", + " 7.07351900e-01 1.27134142e+00]\n", + " [5.20300000e-01 2.49273746e+04 3.79820000e-01 ... 8.40738079e+00\n", + " 7.07351900e-01 6.11735120e-01]\n", + " ...\n", + " [5.20300000e-01 1.18607002e+04 3.79680000e-01 ... 5.61017141e+01\n", + " 7.07200000e-01 2.00946575e+00]\n", + " [5.20300000e-01 1.76526070e+03 3.79823000e-01 ... 3.28731657e+01\n", + " 7.07333700e-01 1.22403338e+00]\n", + " [5.20300000e-01 6.97804121e+03 3.79770000e-01 ... 5.04943137e+01\n", + " 7.07341800e-01 8.95961780e-01]]]\n", + "(100, 8, 8)\n", + "[[0.5199 0.379288 0.8324 0.6765375]\n", + " [0.5202 0.379148 0.8334 0.6767105]\n", + " [0.5202 0.379767 0.8348 0.6763607]\n", + " [0.5192 0.37977 0.8332 0.6767982]\n", + " [0.5188 0.377201 0.8307 0.6760006]\n", + " [0.5182 0.377899 0.8321 0.6756274]\n", + " [0.5186 0.378081 0.8328 0.6757138]\n", + " [0.5191 0.38014 0.8329 0.6765158]\n", + " [0.4977 0.367354 0.793 0.6938254]\n", + " [0.4977 0.367329 0.7924 0.6936574]\n", + " [0.5034 0.369327 0.8 0.6995121]\n", + " [0.4966 0.366876 0.7941 0.6941364]\n", + " [0.4964 0.366675 0.7964 0.6949151]\n", + " [0.4993 0.368361 0.7967 0.6957514]\n", + " [0.4992 0.36881 0.7984 0.6965808]\n", + " [0.4969 0.367134 0.7941 0.6941668]\n", + " [0.4962 0.36718 0.7952 0.6938654]\n", + " [0.4816 0.352869 0.779 0.6690186]\n", + " [0.4827 0.352455 0.7776 0.6689029]\n", + " [0.4743 0.344845 0.7654 0.6646754]\n", + " [0.4888 0.359898 0.7801 0.68196 ]\n", + " [0.4791 0.349045 0.7724 0.6734318]\n", + " [0.4876 0.355972 0.7761 0.6777174]\n", + " [0.4856 0.354109 0.7818 0.6774215]\n", + " [0.4771 0.347886 0.7692 0.670822 ]\n", + " [0.4845 0.354287 0.7761 0.6795899]\n", + " [0.492 0.363658 0.7855 0.6939979]\n", + " [0.4949 0.360833 0.7903 0.6965295]\n", + " [0.49 0.355639 0.7845 0.6854835]\n", + " [0.4914 0.356044 0.7842 0.6822952]\n", + " [0.4828 0.352291 0.7738 0.6754 ]\n", + " [0.4814 0.351729 0.7733 0.6736573]\n", + " [0.4907 0.35516 0.7837 0.6808988]\n", + " [0.4904 0.355253 0.7836 0.6815314]\n", + " [0.4901 0.355711 0.7845 0.6830635]\n", + " [0.4853 0.350243 0.7904 0.6786821]\n", + " [0.4864 0.35163 0.7903 0.6753284]\n", + " [0.4814 0.345716 0.7808 0.6667358]\n", + " [0.4862 0.350504 0.7781 0.6768845]\n", + " [0.4822 0.3483 0.7938 0.6668867]\n", + " [0.4879 0.350302 0.782 0.6738774]\n", + " [0.4875 0.34998 0.7838 0.675553 ]\n", + " [0.4865 0.348801 0.7816 0.6745817]\n", + " [0.4853 0.348273 0.7819 0.673084 ]\n", + " [0.4786 0.349576 0.7984 0.669583 ]\n", + " [0.4736 0.346438 0.7859 0.6640479]\n", + " [0.4793 0.349726 0.7972 0.6679527]\n", + " [0.4802 0.350856 0.7983 0.6685 ]\n", + " [0.4753 0.349081 0.7779 0.6614854]\n", + " [0.4793 0.352875 0.7868 0.6616846]\n", + " [0.4846 0.358939 0.7871 0.6639155]\n", + " [0.4868 0.356201 0.7889 0.6612099]\n", + " [0.4748 0.348094 0.7782 0.6615113]\n", + " [0.4925 0.355075 0.7913 0.6601025]\n", + " [0.4917 0.356035 0.7911 0.6608456]\n", + " [0.4924 0.356746 0.7913 0.6619063]\n", + " [0.479 0.355212 0.7877 0.6617 ]\n", + " [0.4781 0.352716 0.7892 0.6602838]\n", + " [0.489 0.356266 0.7914 0.6616443]\n", + " [0.4894 0.355895 0.7914 0.6616007]\n", + " [0.4895 0.359965 0.7919 0.6658917]\n", + " [0.4894 0.35978 0.7887 0.6650277]\n", + " [0.4896 0.359747 0.787 0.6646644]\n", + " [0.4896 0.359573 0.787 0.6647763]\n", + " [0.4897 0.35659 0.7945 0.6619875]\n", + " [0.489 0.356601 0.7975 0.6626441]\n", + " [0.4894 0.355284 0.7952 0.662544 ]\n", + " [0.4948 0.355105 0.796 0.6635939]\n", + " [0.5187 0.382243 0.8326 0.6777381]\n", + " [0.5185 0.382145 0.8325 0.6769427]\n", + " [0.5187 0.382936 0.8321 0.6777502]\n", + " [0.5148 0.377079 0.8221 0.6737738]\n", + " [0.5149 0.377167 0.8227 0.6744739]\n", + " [0.5171 0.380651 0.8293 0.6820897]\n", + " [0.5123 0.377114 0.8262 0.6784567]\n", + " [0.5183 0.380546 0.8317 0.6772093]\n", + " [0.5181 0.380675 0.8314 0.6772635]\n", + " [0.5141 0.378251 0.824 0.6756163]\n", + " [0.5198 0.380792 0.8352 0.6899958]\n", + " [0.5197 0.380895 0.8354 0.6899816]\n", + " [0.5209 0.37879 0.8325 0.6928397]\n", + " [0.5196 0.377257 0.8298 0.6916359]\n", + " [0.5197 0.375896 0.8299 0.688 ]\n", + " [0.5223 0.377703 0.832 0.6917992]\n", + " [0.5176 0.381546 0.8379 0.6863937]\n", + " [0.5174 0.38252 0.8386 0.6895754]\n", + " [0.5203 0.381832 0.8382 0.6907739]\n", + " [0.5281 0.378782 0.8241 0.6982118]\n", + " [0.5276 0.379652 0.8283 0.7045105]\n", + " [0.5211 0.377761 0.8292 0.6925909]\n", + " [0.5202 0.376687 0.8205 0.6905941]\n", + " [0.5195 0.376172 0.8203 0.6895395]\n", + " [0.5286 0.380636 0.8392 0.708304 ]\n", + " [0.5272 0.386513 0.8498 0.7133316]\n", + " [0.5272 0.386866 0.8499 0.7127191]\n", + " [0.5271 0.385475 0.8492 0.7113771]\n", + " [0.5245 0.385799 0.8483 0.7097274]\n", + " [0.5233 0.384712 0.8503 0.7090648]\n", + " [0.5272 0.383846 0.8554 0.714612 ]\n", + " [0.5203 0.379769 0.8454 0.7071974]]\n", + "YYYY ====== Actual Input ====== YYYY\n", + "[[[0.6765375]]\n", + "\n", + " [[0.6767105]]\n", + "\n", + " [[0.6763607]]\n", + "\n", + " [[0.6767982]]\n", + "\n", + " [[0.6760006]]\n", + "\n", + " [[0.6756274]]\n", + "\n", + " [[0.6757138]]\n", + "\n", + " [[0.6765158]]\n", + "\n", + " [[0.6938254]]\n", + "\n", + " [[0.6936574]]\n", + "\n", + " [[0.6995121]]\n", + "\n", + " [[0.6941364]]\n", + "\n", + " [[0.6949151]]\n", + "\n", + " [[0.6957514]]\n", + "\n", + " [[0.6965808]]\n", + "\n", + " [[0.6941668]]\n", + "\n", + " [[0.6938654]]\n", + "\n", + " [[0.6690186]]\n", + "\n", + " [[0.6689029]]\n", + "\n", + " [[0.6646754]]\n", + "\n", + " [[0.68196 ]]\n", + "\n", + " [[0.6734318]]\n", + "\n", + " [[0.6777174]]\n", + "\n", + " [[0.6774215]]\n", + "\n", + " [[0.670822 ]]\n", + "\n", + " [[0.6795899]]\n", + "\n", + " [[0.6939979]]\n", + "\n", + " [[0.6965295]]\n", + "\n", + " [[0.6854835]]\n", + "\n", + " [[0.6822952]]\n", + "\n", + " [[0.6754 ]]\n", + "\n", + " [[0.6736573]]\n", + "\n", + " [[0.6808988]]\n", + "\n", + " [[0.6815314]]\n", + "\n", + " [[0.6830635]]\n", + "\n", + " [[0.6786821]]\n", + "\n", + " [[0.6753284]]\n", + "\n", + " [[0.6667358]]\n", + "\n", + " [[0.6768845]]\n", + "\n", + " [[0.6668867]]\n", + "\n", + " [[0.6738774]]\n", + "\n", + " [[0.675553 ]]\n", + "\n", + " [[0.6745817]]\n", + "\n", + " [[0.673084 ]]\n", + "\n", + " [[0.669583 ]]\n", + "\n", + " [[0.6640479]]\n", + "\n", + " [[0.6679527]]\n", + "\n", + " [[0.6685 ]]\n", + "\n", + " [[0.6614854]]\n", + "\n", + " [[0.6616846]]\n", + "\n", + " [[0.6639155]]\n", + "\n", + " [[0.6612099]]\n", + "\n", + " [[0.6615113]]\n", + "\n", + " [[0.6601025]]\n", + "\n", + " [[0.6608456]]\n", + "\n", + " [[0.6619063]]\n", + "\n", + " [[0.6617 ]]\n", + "\n", + " [[0.6602838]]\n", + "\n", + " [[0.6616443]]\n", + "\n", + " [[0.6616007]]\n", + "\n", + " [[0.6658917]]\n", + "\n", + " [[0.6650277]]\n", + "\n", + " [[0.6646644]]\n", + "\n", + " [[0.6647763]]\n", + "\n", + " [[0.6619875]]\n", + "\n", + " [[0.6626441]]\n", + "\n", + " [[0.662544 ]]\n", + "\n", + " [[0.6635939]]\n", + "\n", + " [[0.6777381]]\n", + "\n", + " [[0.6769427]]\n", + "\n", + " [[0.6777502]]\n", + "\n", + " [[0.6737738]]\n", + "\n", + " [[0.6744739]]\n", + "\n", + " [[0.6820897]]\n", + "\n", + " [[0.6784567]]\n", + "\n", + " [[0.6772093]]\n", + "\n", + " [[0.6772635]]\n", + "\n", + " [[0.6756163]]\n", + "\n", + " [[0.6899958]]\n", + "\n", + " [[0.6899816]]\n", + "\n", + " [[0.6928397]]\n", + "\n", + " [[0.6916359]]\n", + "\n", + " [[0.688 ]]\n", + "\n", + " [[0.6917992]]\n", + "\n", + " [[0.6863937]]\n", + "\n", + " [[0.6895754]]\n", + "\n", + " [[0.6907739]]\n", + "\n", + " [[0.6982118]]\n", + "\n", + " [[0.7045105]]\n", + "\n", + " [[0.6925909]]\n", + "\n", + " [[0.6905941]]\n", + "\n", + " [[0.6895395]]\n", + "\n", + " [[0.708304 ]]\n", + "\n", + " [[0.7133316]]\n", + "\n", + " [[0.7127191]]\n", + "\n", + " [[0.7113771]]\n", + "\n", + " [[0.7097274]]\n", + "\n", + " [[0.7090648]]\n", + "\n", + " [[0.714612 ]]\n", + "\n", + " [[0.7071974]]]\n", + "(100, 1, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_936/4176381576.py:16: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " sample_test['Selected'] = 0\n" + ] + } + ], + "source": [ + "# variables are close and volume\n", + "# ==============================\n", + "# Test Sample --- 06.17.2024\n", + "# ==============================\n", + "sample_size = sample_test.shape[0]\n", + "print ('sample_size: ', sample_size)\n", + "\n", + "sl = 8 # <--- sequence length\n", + "batch = 100 # <--- batch size\n", + "n_features = 8 # <---- no. of variables\n", + "n_out = 1 # <----- no. of predicted variables\n", + "frwd = 1 # <--- how many to predict\n", + "\n", + "# Trimming Indices !!!\n", + "# Marking selected rows\n", + "sample_test['Selected'] = 0\n", + "\n", + "# Selecting m random rows without replacement\n", + "np.random.seed(125)\n", + "selected_indices = np.random.choice(sample_test.index, size = batch, replace = False)\n", + "\n", + "sample_test.loc[selected_indices, 'Selected'] = 1 # print (sample_test[sample_test['Selected'] == 1])\n", + "chosen_idx1 = sample_test[sample_test['Selected'] == 1].index\n", + "chosen_idx2 = chosen_idx1[chosen_idx1 > sl]\n", + "\n", + "thrown_idx1 = chosen_idx1[chosen_idx1 <= sl]\n", + "cnt_thrown_idx1 = len(thrown_idx1)\n", + "\n", + "chosen_idx3 = chosen_idx2[chosen_idx2 < (sample_size - frwd)]\n", + "\n", + "thrown_idx2 = chosen_idx2[chosen_idx2 >= (sample_size - frwd)]\n", + "cnt_thrown_idx2 = len(thrown_idx2)\n", + "\n", + "cnt_thrown_idx = cnt_thrown_idx1 + cnt_thrown_idx2\n", + "\n", + "print (selected_indices)\n", + "\n", + "all_ts_close_xrp = np.empty((1, )) # final input/output\n", + "all_ts_close_eth = np.empty((1, )) # final input/output\n", + "all_ts_close_ltc = np.empty((1, )) # final input/output\n", + "all_ts_close_btc = np.empty((1, )) # final input/output\n", + "\n", + "all_ts_volume_xrp = np.empty((1, )) # final input/output\n", + "all_ts_volume_eth = np.empty((1, )) # final input/output\n", + "all_ts_volume_ltc = np.empty((1, )) # final input/output\n", + "all_ts_volume_btc = np.empty((1, )) # final input/output\n", + "\n", + "stdev_xrp = np.empty((1, )) # final input/output\n", + "stdev_eth = np.empty((1, )) # final input/output\n", + "stdev_ltc = np.empty((1, )) # final input/output\n", + "stdev_btc = np.empty((1, )) # final input/output\n", + "\n", + "\n", + "aft_ts_close_xrp = np.empty((1))\n", + "aft_ts_close_eth = np.empty((1))\n", + "aft_ts_close_ltc = np.empty((1))\n", + "aft_ts_close_btc = np.empty((1))\n", + "\n", + "for idx in chosen_idx3:\n", + " selected_rows_before = sample_test.iloc[max(0, idx-sl): idx]\n", + " selected_rows_after = sample_test.iloc[max(0, idx): idx+frwd]\n", + "\n", + " # xrp\n", + " sr_before_close_xrp = np.array(selected_rows_before['close_xrp'])\n", + " sr_after_close_xrp = np.array(selected_rows_after['close_xrp']) \n", + " # print (sr_before_close_xrp)\n", + " sr_before_volume_xrp = np.array(selected_rows_before['volume_xrp'])\n", + " sr_after_volume_xrp = np.array(selected_rows_after['volume_xrp']) \n", + " # print (sr_before_volume_xrp) \n", + " # Compute standard deviation\n", + " std_dev_xrp = np.std(sr_before_close_xrp)\n", + " std_dev_xrp_arr = np.repeat(std_dev_xrp, sl)\n", + " # print(std_dev_xrp_arr)\n", + " \n", + "# eth\n", + " sr_before_close_eth = np.array(selected_rows_before['close_eth'])\n", + " sr_after_close_eth = np.array(selected_rows_after['close_eth'])\n", + " sr_before_volume_eth = np.array(selected_rows_before['volume_eth'])\n", + " sr_after_volume_eth = np.array(selected_rows_after['volume_eth'])\n", + " # Compute standard deviation\n", + " std_dev_eth = np.std(sr_before_close_eth)\n", + " std_dev_eth_arr = np.repeat(std_dev_eth, sl)\n", + " # print(std_dev_eth_arr)\n", + " \n", + "# ltc\n", + " sr_before_close_ltc = np.array(selected_rows_before['close_ltc'])\n", + " sr_after_close_ltc = np.array(selected_rows_after['close_ltc'])\n", + " sr_before_volume_ltc = np.array(selected_rows_before['volume_ltc'])\n", + " sr_after_volume_ltc = np.array(selected_rows_after['volume_ltc'])\n", + "# Compute standard deviation\n", + " std_dev_ltc = np.std(sr_before_close_ltc)\n", + " std_dev_ltc_arr = np.repeat(std_dev_ltc, sl)\n", + " # print(std_dev_ltc_arr)\n", + "\n", + "# btc\n", + " sr_before_close_btc = np.array(selected_rows_before['close_btc'])\n", + " sr_after_close_btc = np.array(selected_rows_after['close_btc'])\n", + " sr_before_volume_btc = np.array(selected_rows_before['volume_btc'])\n", + " sr_after_volume_btc = np.array(selected_rows_after['volume_btc'])\n", + " # Compute standard deviation\n", + " std_dev_btc = np.std(sr_before_close_btc)\n", + " std_dev_btc_arr = np.repeat(std_dev_btc, sl)\n", + " # print(std_dev_btc_arr)\n", + "\n", + "# xrp\n", + " all_ts_close_xrp = np.concatenate((all_ts_close_xrp, sr_before_close_xrp))\n", + " all_ts_volume_xrp = np.concatenate((all_ts_volume_xrp, sr_before_volume_xrp))\n", + " stdev_xrp = np.concatenate((stdev_xrp, std_dev_xrp_arr))\n", + "# eth\n", + " all_ts_close_eth = np.concatenate((all_ts_close_eth, sr_before_close_eth))\n", + " all_ts_volume_eth = np.concatenate((all_ts_volume_eth, sr_before_volume_eth))\n", + " stdev_eth = np.concatenate((stdev_eth, std_dev_eth_arr))\n", + "# ltc\n", + " all_ts_close_ltc = np.concatenate((all_ts_close_ltc, sr_before_close_ltc))\n", + " all_ts_volume_ltc = np.concatenate((all_ts_volume_ltc, sr_before_volume_ltc))\n", + " stdev_ltc = np.concatenate((stdev_ltc, std_dev_ltc_arr))\n", + "# btc\n", + " all_ts_close_btc = np.concatenate((all_ts_close_btc, sr_before_close_btc))\n", + " all_ts_volume_btc = np.concatenate((all_ts_volume_btc, sr_before_volume_btc))\n", + " stdev_btc = np.concatenate((stdev_btc, std_dev_btc_arr))\n", + "\n", + "\n", + " aft_ts_close_xrp = np.concatenate((aft_ts_close_xrp, sr_after_close_xrp))\n", + " aft_ts_close_eth = np.concatenate((aft_ts_close_eth, sr_after_close_eth))\n", + " aft_ts_close_ltc = np.concatenate((aft_ts_close_ltc, sr_after_close_ltc))\n", + " aft_ts_close_btc = np.concatenate((aft_ts_close_btc, sr_after_close_btc))\n", + "\n", + "\n", + "X_XRP_close = all_ts_close_xrp[1:]\n", + "X_XRP_volume = all_ts_volume_xrp[1:]\n", + "X_XRP_stdev = stdev_xrp[1:]\n", + "\n", + "\n", + "X_ETH_close = all_ts_close_eth[1:]\n", + "X_ETH_volume = all_ts_volume_eth[1:]\n", + "X_ETH_stdev = stdev_eth[1:]\n", + "\n", + "X_LTC_close = all_ts_close_ltc[1:]\n", + "X_LTC_volume = all_ts_volume_ltc[1:]\n", + "X_LTC_stdev = stdev_ltc[1:]\n", + "\n", + "X_BTC_close = all_ts_close_btc[1:]\n", + "X_BTC_volume = all_ts_volume_btc[1:]\n", + "X_BTC_stdev = stdev_btc[1:]\n", + "\n", + "X0 = np.column_stack((X_XRP_close, X_XRP_volume, \n", + " X_ETH_close, X_ETH_volume, \n", + " X_LTC_close, X_LTC_volume, \n", + " X_BTC_close, X_BTC_volume))\n", + "# print (X0)\n", + "\n", + "# ======== Model Input =========\n", + "X = X0.reshape(batch-cnt_thrown_idx, sl, n_features)\n", + "print ('XXXX ====== Actual Input ====== XXXX')\n", + "print (X)\n", + "print (X.shape)\n", + "\n", + "y_XRP = aft_ts_close_xrp[1:]\n", + "y_ETH = aft_ts_close_eth[1:]\n", + "y_LTC = aft_ts_close_ltc[1:]\n", + "y_BTC = aft_ts_close_btc[1:]\n", + "\n", + "y = np.column_stack((y_XRP, y_ETH, y_LTC, y_BTC))\n", + "print (y)\n", + "\n", + "y = y_BTC.reshape(batch-cnt_thrown_idx, frwd, n_out)\n", + "print ('YYYY ====== Actual Input ====== YYYY')\n", + "print (y)\n", + "print (y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c40d6239-1f0e-43c9-a378-c71b31be86c4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 147, + "id": "cf50668b-5970-4caa-bed5-72cc62e4ea8e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.677093 0.6770824 0.67724 0.6770763 0.6770743 0.6768482 0.6769969\n", + " 0.6765836]\n", + "0.6769993375000001\n", + "0.00018735635789518952\n" + ] + } + ], + "source": [ + "# 06.05.2024 just helper\n", + "values = X_BTC_close.reshape(batch-cnt_thrown_idx, sl)\n", + "\n", + "print (values[0])\n", + "print (np.mean(values[0]))\n", + "print (np.std(values[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "id": "88e292cc-1244-462a-b311-3e964773c742", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "13\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "16\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "17\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGzCAYAAAAi6m1wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGZUlEQVR4nO3deXxU1f3/8fdkmyRAFiArhl0JyGaDpKCySEpAasUigl/8sajgAioEqtBWkEXjXlwQpLLYFoqlirvRCASqImAQFcUoCoLIJCCSIQEmycz9/QEZGLKQQCaT3Lyej8c8knvvuWc+d5Iwb869547FMAxDAAAAJuLn6wIAAABqGgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHQKWysrJksViUlZVVo/1aLBY9+OCDNdqnWXnrZ1BVLpdLnTt31kMPPeST5y9PRkaGGjdurIMHD/q6FNRRBBw0GM8//7wsFouSk5MvuK933nmHN+cqqIuv04MPPiiLxVLuY9GiRT6t7fnnn9fy5ct9WkN5/v3vf2vfvn2aNGlSudur+reVm5uradOmKTExUaGhoWrUqJGSkpI0b948HTlyxN2uX79+Ff6MvvnmG0nSoEGD1L59e6Wnp9fYccJcAnxdAFBbVqxYodatW2vLli3atWuX2rdvf959vfPOO1qwYEGde/Ouayp7nY4fP66AAN/9E7Rw4UI1btzYY11NhN8L8fzzz6t58+YaO3asx/o+ffro+PHjCgoK8kldjz/+uEaOHKnw8PByt1flb2vr1q265pprVFBQoJtvvllJSUmSpE8//VSPPPKINm7cqPfff9/d/qKLLio3vMTHx7u/v/322zVt2jTNnj1bTZo0udDDhMkQcNAg7N69Wx9//LFeffVV3X777VqxYoVmzZrl67K86tixYwoNDS2zvqSkRC6Xy2dvlqWCg4N9+vw33HCDmjdv7tMaqsrPz89nr9dnn32mzz//XE8++WS526vyt3XkyBFdf/318vf312effabExESP7Q899JD+/ve/e6wLDw/XzTffXGltw4YN0913363Vq1frlltuOY+jg5lxigoNwooVKxQZGakhQ4bohhtu0IoVK8q0qeg6hz179shisbhPHYwdO1YLFiyQJI+h81KFhYWaOnWqEhISZLVa1aFDBz3xxBMyDKPMc/7rX/9Sz549FRoaqsjISPXp08fjf7HSyf/VX3rppbJarYqPj9fEiRM9hvOlk0P6nTt3VnZ2tvr06aPQ0FD9+c9/dtf+xBNPaP78+WrXrp2sVqu+/vprSdI333yjG264QU2bNlVwcLB69OihN95445yv5//+9z8NHz5cLVu2lNVqVUJCgqZMmaLjx4+725zrdSrvGpzPPvtMgwcPVlhYmBo3bqwBAwbok08+8WizfPlyWSwWffTRR0pLS1NUVJQaNWqk66+/vkauxzj7532ms2suPd21a9cujR07VhEREQoPD9e4ceN07NixMvtX9vNu3bq1vvrqK23YsMH9WvXr109Sxb+bq1evVlJSkkJCQtS8eXPdfPPN2r9/v0ebsWPHqnHjxtq/f7+GDh2qxo0bKyoqStOmTZPT6Tzn6/Haa68pKChIffr0KXd7Vf62XnjhBe3fv19PPfVUmXAjSTExMfrrX/96zlrOFh0dra5du+r111+v9r4wP0Zw0CCsWLFCf/zjHxUUFKSbbrpJCxcu1NatW3X55ZdXu6/bb79dP//8szIzM/XPf/7TY5thGPrDH/6g9evX69Zbb1X37t313nvv6U9/+pP279+vv/3tb+62s2fP1oMPPqjevXtrzpw5CgoK0ubNm7Vu3ToNHDhQ0sk30NmzZyslJUV33nmncnJy3LV/9NFHCgwMdPf3yy+/aPDgwRo5cqRuvvlmxcTEuLctW7ZMJ06c0IQJE2S1WtW0aVN99dVXuuKKK9SiRQtNnz5djRo10n/+8x8NHTpUr7zyiq6//voKX4PVq1fr2LFjuvPOO9WsWTNt2bJFzz77rH766SetXr36nK9Teb766itdddVVCgsL03333afAwEC98MIL6tevnzZs2FDm9NHdd9+tyMhIzZo1S3v27NH8+fM1adIkvfzyy+d8Lkk6fPiwx7K/v78iIyOrtO/ZbrzxRrVp00bp6enatm2bXnzxRUVHR+vRRx91tznXz3v+/Pm6++671bhxY/3lL3+RJI+f4dmWL1+ucePG6fLLL1d6erpyc3P19NNP66OPPtJnn32miIgId1un06nU1FQlJyfriSee0AcffKAnn3xS7dq105133lnpsX388cfq3Lmzx+/amaryt/XGG28oJCREN9xwQ1VeTnfNhw4d8lgXHBxc5rRiUlKSXnvttSr3iwbEAEzu008/NSQZmZmZhmEYhsvlMi666CLj3nvv9Wi3fv16Q5Kxfv16j/W7d+82JBnLli1zr5s4caJR3p/Pa6+9Zkgy5s2b57H+hhtuMCwWi7Fr1y7DMAzju+++M/z8/Izrr7/ecDqdHm1dLpdhGIaRl5dnBAUFGQMHDvRo89xzzxmSjKVLl7rX9e3b15BkLFq0qNzaw8LCjLy8PI9tAwYMMLp06WKcOHHC47l79+5tXHzxxZW+LseOHStz7Onp6YbFYjF+/PHHc75OhmEYkoxZs2a5l4cOHWoEBQUZ33//vXvdzz//bDRp0sTo06ePe92yZcsMSUZKSor7tTIMw5gyZYrh7+9vHDlypNznKzVr1ixDUplHq1atDMMo/+ddUc2lfd1yyy0e7a6//nqjWbNm7uWq/LwNwzAuvfRSo2/fvmWe9+yfQVFRkREdHW107tzZOH78uLvdW2+9ZUgyZs6c6V43ZswYQ5IxZ84cjz4vu+wyIykpqdzX6EwXXXSRMWzYsHK3VfVvKzIy0ujWrds5n6tU6e/z2Y8xY8aUafvwww8bkozc3Nwq94+GgVNUML0VK1YoJiZG/fv3l3TyNMOIESO0atWqKg3RV8c777wjf39/3XPPPR7rp06dKsMw9O6770o6Oezvcrk0c+ZM+fl5/hmWnsb54IMPVFRUpMmTJ3u0GT9+vMLCwvT222977Ge1WjVu3Lhy6xo2bJiioqLcy4cPH9a6det044036ujRozp06JAOHTqkX375Rampqfruu+/KnOo4U0hIiPv7wsJCHTp0SL1795ZhGPrss88qe4nK5XQ69f7772vo0KFq27ate31cXJz+7//+Tx9++KHsdrvHPhMmTPA45XXVVVfJ6XTqxx9/rNJzvvLKK8rMzHQ/yju1UlV33HGHx/JVV12lX375xV1zVX7e1fHpp58qLy9Pd911l8e1OUOGDFFiYmKZ342Kavzhhx/O+Vy//PJLhSNbVf3bstvt1b4IuHXr1h4/n8zMTN13331l2pXWdvZoD8ApKpia0+nUqlWr1L9/f+3evdu9Pjk5WU8++aTWrl3rPh1UE3788UfFx8eX+ce8Y8eO7u2S9P3338vPz0+dOnWqtC9J6tChg8f6oKAgtW3btswbeYsWLSq8cLhNmzYey7t27ZJhGHrggQf0wAMPlLtPXl6eWrRoUe62vXv3aubMmXrjjTf066+/emzLz8+v8JgqcvDgQR07dqzMsUonXzuXy6V9+/bp0ksvda9v2bKlR7vSN7qz66lInz59auwi48pqCQsLq9LPuzoq+t2QpMTERH344Yce64KDgz0CbmmNVX2tjHKuH6vO31ZYWJiOHj1apecq1ahRI6WkpFS5tvMJijA3Ag5Mbd26dTpw4IBWrVqlVatWldm+YsUK9z/CFf0DWdOjPN5y5qjKuba5XC5J0rRp05SamlruPhVNo3c6nfrd736nw4cP6/7771diYqIaNWqk/fv3a+zYse6+vc3f37/c9eW9GVfH+fweeKuWmlJRfVXRrFmzcoNQdf62EhMTtX37dhUVFdX47L3S2urLjDjUHgIOTG3FihWKjo52z+Y506uvvqo1a9Zo0aJFCgkJcf+v++wZSuWd8qjoTbBVq1b64IMPdPToUY9RnNKbk7Vq1UqS1K5dO7lcLn399dfq3r17hX1JUk5Ojsdpm6KiIu3evbtK/7utSGl/gYGB1e7nyy+/1LfffquXXnpJo0ePdq/PzMws07aq/6uOiopSaGiocnJyymz75ptv5Ofnp4SEhGrVeb6q83tQVVX5eUtVf73O/N24+uqrPbbl5OS4t9eExMREjxGaUtX527r22mu1adMmvfLKK7rppptqrDbp5DT15s2blxmhArgGB6Z1/Phxvfrqq/r973+vG264ocxj0qRJOnr0qHtadKtWreTv76+NGzd69PP888+X6btRo0aSyr4JXnPNNXI6nXruuec81v/tb3+TxWLR4MGDJUlDhw6Vn5+f5syZU2bEo/R//SkpKQoKCtIzzzzjMRKwZMkS5efna8iQIefxqpwUHR2tfv366YUXXtCBAwfKbK9sunXpaMCZNRmGoaeffrpM24pep/L6HDhwoF5//XXt2bPHvT43N1crV67UlVdeqbCwsEr7qClhYWFq3rx5lX4PqqoqP2/p5Ot1rtdKknr06KHo6GgtWrRIDofDvf7dd9/Vzp07L+h342y9evXSjh07PJ6nun9bd9xxh+Li4jR16lR9++23ZZ4jLy9P8+bNO6/6srOz1atXr/M7OJgaIzgwrTfeeENHjx7VH/7wh3K3//a3v1VUVJRWrFihESNGKDw8XMOHD9ezzz4ri8Widu3a6a233lJeXl6ZfUvvwnrPPfcoNTVV/v7+GjlypK699lr1799ff/nLX7Rnzx5169ZN77//vl5//XVNnjxZ7dq1k3Ty9M9f/vIXzZ07V1dddZX++Mc/ymq1auvWrYqPj1d6erqioqI0Y8YMzZ49W4MGDdIf/vAH5eTk6Pnnn9fll19+zpugncuCBQt05ZVXqkuXLho/frzatm2r3Nxcbdq0ST/99JM+//zzcvdLTExUu3btNG3aNO3fv19hYWF65ZVXyj2NUdHrVJ558+YpMzNTV155pe666y4FBATohRdekMPh0GOPPXZBx1pdt912mx555BHddttt6tGjhzZu3FjuG3NVVeXnLZ18vRYuXKh58+apffv2io6OLjNCI50ceXv00Uc1btw49e3bVzfddJN7mnjr1q01ZcqU8671bNddd53mzp2rDRs2uE85VfdvKzIyUmvWrNE111yj7t27e9zJeNu2bfr3v/99XiElLy9PX3zxhSZOnHj+Bwjz8s3kLcD7rr32WiM4ONgoLCyssM3YsWONwMBA49ChQ4ZhGMbBgweNYcOGGaGhoUZkZKRx++23Gzt27CgzbbikpMS4++67jaioKMNisXhMhT569KgxZcoUIz4+3ggMDDQuvvhi4/HHH/eYDlxq6dKlxmWXXWZYrVYjMjLS6Nu3r3vKbannnnvOSExMNAIDA42YmBjjzjvvNH799VePNn379jUuvfTSMv2XTnl+/PHHyz3+77//3hg9erQRGxtrBAYGGi1atDB+//vfG//973/dbcqbJv71118bKSkpRuPGjY3mzZsb48ePNz7//PNqvU46a8q1YRjGtm3bjNTUVKNx48ZGaGio0b9/f+Pjjz/2aFM6TXzr1q0e6yua5n+20qndBw8erLDNsWPHjFtvvdUIDw83mjRpYtx4441GXl5ehdPEz+6rtMbdu3d7rD/Xz9tmsxlDhgwxmjRpYkhyTxmv6Nhefvlld39NmzY1Ro0aZfz0008ebcaMGWM0atSowtehKrp27Wrceuut7uXz+dsyjJPT/qdMmWJccsklRnBwsBEaGmokJSUZDz30kJGfn+9uV9Hv89kWLlxohIaGGna7vUrHgYbFYhh15Co4AECd9M9//lMTJ07U3r17PW4g6GuXXXaZ+vXr53EDTaAU1+AAACo1atQotWzZstwLin0lIyND3333nWbMmOHrUlBHMYIDAABMhxEcAABgOl4NOBs3btS1116r+Ph4WSyWKn0gWlZWln7zm9/IarWqffv25X6i74IFC9S6dWsFBwcrOTlZW7ZsqfniAQBAveXVgFNYWKhu3bpV+bzt7t27NWTIEPXv31/bt2/X5MmTddttt+m9995zt3n55ZeVlpamWbNmadu2berWrZtSU1PLncoLAAAaplq7BsdisWjNmjUaOnRohW3uv/9+vf3229qxY4d73ciRI3XkyBFlZGRIOvk5J5dffrn7Rmoul0sJCQm6++67NX36dK8eAwAAqB/q1I3+Nm3aVOa28ampqZo8ebKkk7eoz87O9rhq3s/PTykpKdq0aVOF/TocDo+7cLpcLh0+fFjNmjXjA9oAAKgnDMPQ0aNHFR8fLz+/yk9C1amAY7PZFBMT47EuJiZGdrtdx48f16+//iqn01lum9LP+ilPenq6Zs+e7ZWaAQBA7dq3b58uuuiiStvUqYDjLTNmzFBaWpp7OT8/Xy1bttS+fftq5PNt/pb5rZZ/vEdOV9mzff5+Fo3t3VpTfnfJBT8PAAANmd1uV0JCgseHGVekTgWc2NhY5ebmeqzLzc1VWFiYQkJC5O/vL39//3LbxMbGVtiv1WqV1Wotsz4sLKxGAs7ovh310qe58ivnaiaLRRrTt6PCwhpd8PMAAABV6fKSOnUfnF69emnt2rUe6zIzM90fwhYUFKSkpCSPNi6XS2vXrvXpp8m2ad5Ijw7rKr8zXm9/i0V+FunRYV3VujnhBgCA2uTVEZyCggLt2rXLvbx7925t375dTZs2VcuWLTVjxgzt379f//jHPyRJd9xxh5577jndd999uuWWW7Ru3Tr95z//0dtvv+3uIy0tTWPGjFGPHj3Us2dPzZ8/X4WFhRo3bpw3D+WchvdIUOcWYRr89IeSpHFXttbNya0INwAA+IBXA86nn36q/v37u5dLr4MZM2aMli9frgMHDmjv3r3u7W3atNHbb7+tKVOm6Omnn9ZFF12kF198Uampqe42I0aM0MGDBzVz5kzZbDZ1795dGRkZZS489oVWzU6HmbTfXaLQoDp1BhAAgAajQX4Wld1uV3h4uPLz82vkGpxSx4pK1GnmyZsSfj0nlYADAEANqs77d526BgcAAKAmEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpBPi6AAAAUP+dKHaq0FGiQodTwUF+im4S7NN6CDgAAKBaikpcKnSUqMBRosKiEhU6SlRUYri3x0f4NtxIBBwAAFCJEqdLhQ6nCopKVHDiZKgpKnH5uqxzIuAAAABJktNluEdkSsPMieK6H2bKQ8ABAKABcrkMHSt2uoNMoaNEx4udMoxz71sfEHAAADA5wzB03CPMOHWsqEQuk4SZ8hBwAAAwmeNFTveoTIGjRMeKnHKaOc2Ug4ADAEA9dub07NJZTSXOhhVmykPAAQCgnjjX9GycRsABAKAOqq/Ts+sKAg4AAD5mpunZdQUBBwCAWmT26dl1BQEHAAAvaYjTs+sKAg4AADWE6dl1BwEHAIDzwPTsuo2AAwDAOTA9u/4h4AAAcAamZ5sDAQcA0GAxPdu8CDgAgHrFMAz3lGqjdNm9TSpdcrdxtzVOBhqHk+nZDQABBwAaEJfLkKPEJUeJU44Sl4pKXB4BoLLgoDOCgyGVv5/huaxy2p3us2z/ns/v2Y4gguog4ACAyRSdCjAnist+LXa6CApoEPxq40kWLFig1q1bKzg4WMnJydqyZUuFbfv16yeLxVLmMWTIEHebsWPHltk+aNCg2jgUAPA5l8vQsaIS/VpYpAP5x7XnUKG+sdn1+b4j2rL7sLJ//FU79tu1K69A+w4f18GjDtmPl3iM1gBm5/URnJdffllpaWlatGiRkpOTNX/+fKWmpionJ0fR0dFl2r/66qsqKipyL//yyy/q1q2bhg8f7tFu0KBBWrZsmXvZarV67yAAoBYZhqEip8s98uI4aySG6cnAuXk94Dz11FMaP368xo0bJ0latGiR3n77bS1dulTTp08v075p06Yey6tWrVJoaGiZgGO1WhUbG+u9wgHAi0qcLjlKXDpR7PT46ihxyVHs5Fb+wAXyasApKipSdna2ZsyY4V7n5+enlJQUbdq0qUp9LFmyRCNHjlSjRo081mdlZSk6OlqRkZG6+uqrNW/ePDVr1qzcPhwOhxwOh3vZbrefx9EAQNUZxqmLeYtdOnFqFObEGaMxxdzxFvAqrwacQ4cOyel0KiYmxmN9TEyMvvnmm3Puv2XLFu3YsUNLlizxWD9o0CD98Y9/VJs2bfT999/rz3/+swYPHqxNmzbJ39+/TD/p6emaPXv2hR0MAJyl2FnOCMypIMP1LoBv1elZVEuWLFGXLl3Us2dPj/UjR450f9+lSxd17dpV7dq1U1ZWlgYMGFCmnxkzZigtLc29bLfblZCQ4L3CAZhC6ZTq06ePPGck8SGKQN3l1YDTvHlz+fv7Kzc312N9bm7uOa+fKSws1KpVqzRnzpxzPk/btm3VvHlz7dq1q9yAY7VauQgZqAKny1Cx06Uip0vFJS4VOw2VuCq+q2tNjlBUpa/Td025sH5O9lU+p8twBxpuzw/UX14NOEFBQUpKStLatWs1dOhQSZLL5dLatWs1adKkSvddvXq1HA6Hbr755nM+z08//aRffvlFcXFxNVE2YDrFzpP3PykuOTk7p9h58s3bHWacJ4MNn4QMwCy8fooqLS1NY8aMUY8ePdSzZ0/Nnz9fhYWF7llVo0ePVosWLZSenu6x35IlSzR06NAyFw4XFBRo9uzZGjZsmGJjY/X999/rvvvuU/v27ZWamurtwwHqDMMwVOw0zhhtOR1WPMJLiYsZOQAaHK8HnBEjRujgwYOaOXOmbDabunfvroyMDPeFx3v37pWfn+f9BnNycvThhx/q/fffL9Ofv7+/vvjiC7300ks6cuSI4uPjNXDgQM2dO5fTUDAFl+vsUZbTp41Kg0vxqSDDRawAUD6LYTS8fyLtdrvCw8OVn5+vsLCwGuv3WFGJOs18T5L09ZxUhQbV6Wu4UctKSkdXygQVl4rOOHXEaSIA9V18RLBaNWt07obVVJ33b96BgQtQeprIHVTOHnUp4TQRAPgCAQf1nmEYchlnfC39xOJT35+5TYbkOvXJxC6jtN3pTyp2bzuVRkrbuM5oU+LyvFi34Y2BAkDdR8BBGcZZb+qng8Dp8OB+w3eVDRFnBozTwaDsurMDhkeYqOj53G08gwkAAGci4JjEsaIS2fJPnDoNUho4PEODdEZ4UDkBw0VgAACYAwHHJBzFLuXaHeduCABAA+B37iYAAAD1CwEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYTq0EnAULFqh169YKDg5WcnKytmzZUmHb5cuXy2KxeDyCg4M92hiGoZkzZyouLk4hISFKSUnRd9995+3DAAAA9YTXA87LL7+stLQ0zZo1S9u2bVO3bt2UmpqqvLy8CvcJCwvTgQMH3I8ff/zRY/tjjz2mZ555RosWLdLmzZvVqFEjpaam6sSJE94+HAAAUA94PeA89dRTGj9+vMaNG6dOnTpp0aJFCg0N1dKlSyvcx2KxKDY21v2IiYlxbzMMQ/Pnz9df//pXXXfdderatav+8Y9/6Oeff9Zrr73m7cMBAAD1gFcDTlFRkbKzs5WSknL6Cf38lJKSok2bNlW4X0FBgVq1aqWEhARdd911+uqrr9zbdu/eLZvN5tFneHi4kpOTK+zT4XDIbrd7PAAAgHl5NeAcOnRITqfTYwRGkmJiYmSz2crdp0OHDlq6dKlef/11/etf/5LL5VLv3r31008/SZJ7v+r0mZ6ervDwcPcjISHhQg8NAADUYXVuFlWvXr00evRode/eXX379tWrr76qqKgovfDCC+fd54wZM5Sfn+9+7Nu3rwYrBgAAdY1XA07z5s3l7++v3Nxcj/W5ubmKjY2tUh+BgYG67LLLtGvXLkly71edPq1Wq8LCwjweAADAvLwacIKCgpSUlKS1a9e617lcLq1du1a9evWqUh9Op1Nffvml4uLiJElt2rRRbGysR592u12bN2+ucp8AAMDcArz9BGlpaRozZox69Oihnj17av78+SosLNS4ceMkSaNHj1aLFi2Unp4uSZozZ45++9vfqn379jpy5Igef/xx/fjjj7rtttsknZxhNXnyZM2bN08XX3yx2rRpowceeEDx8fEaOnSotw8HAADUA14POCNGjNDBgwc1c+ZM2Ww2de/eXRkZGe6LhPfu3Ss/v9MDSb/++qvGjx8vm82myMhIJSUl6eOPP1anTp3cbe677z4VFhZqwoQJOnLkiK688kplZGSUuSEgAABomCyGYRi+LqK22e12hYeHKz8/v0avxzlWVKJOM9+TJH09J1WhQV7Pj26/FhbpG9vRWns+AAAqEh8RrFbNGtV4v9V5/65zs6gAAAAuFAEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYTq0EnAULFqh169YKDg5WcnKytmzZUmHbv//977rqqqsUGRmpyMhIpaSklGk/duxYWSwWj8egQYO8fRgAAKCe8HrAefnll5WWlqZZs2Zp27Zt6tatm1JTU5WXl1du+6ysLN10001av369Nm3apISEBA0cOFD79+/3aDdo0CAdOHDA/fj3v//t7UMBAAD1hNcDzlNPPaXx48dr3Lhx6tSpkxYtWqTQ0FAtXbq03PYrVqzQXXfdpe7duysxMVEvvviiXC6X1q5d69HOarUqNjbW/YiMjPT2oQAAgHrCqwGnqKhI2dnZSklJOf2Efn5KSUnRpk2bqtTHsWPHVFxcrKZNm3qsz8rKUnR0tDp06KA777xTv/zyS4V9OBwO2e12jwcAADAvrwacQ4cOyel0KiYmxmN9TEyMbDZblfq4//77FR8f7xGSBg0apH/84x9au3atHn30UW3YsEGDBw+W0+kst4/09HSFh4e7HwkJCed/UAAAoM4L8HUBlXnkkUe0atUqZWVlKTg42L1+5MiR7u+7dOmirl27ql27dsrKytKAAQPK9DNjxgylpaW5l+12OyEHAAAT82rAad68ufz9/ZWbm+uxPjc3V7GxsZXu+8QTT+iRRx7RBx98oK5du1batm3btmrevLl27dpVbsCxWq2yWq3VPwDgDAfyjysr56AOFjgU1diqfh2iFBce4uuyAADl8OopqqCgICUlJXlcIFx6wXCvXr0q3O+xxx7T3LlzlZGRoR49epzzeX766Sf98ssviouLq5G6gbNl5eRp6urP9dYXP+uTH37RW1/8rKmrP9eGb8ufDQgA8C2vz6JKS0vT3//+d7300kvauXOn7rzzThUWFmrcuHGSpNGjR2vGjBnu9o8++qgeeOABLV26VK1bt5bNZpPNZlNBQYEkqaCgQH/605/0ySefaM+ePVq7dq2uu+46tW/fXqmpqd4+HDRAB/KPa/H/fpBhSC5DHl9f2PiDbPknfF0iAOAsXr8GZ8SIETp48KBmzpwpm82m7t27KyMjw33h8d69e+XndzpnLVy4UEVFRbrhhhs8+pk1a5YefPBB+fv764svvtBLL72kI0eOKD4+XgMHDtTcuXM5DQWvyMo5KIsko5xtFknrc/J0U8+WtVwVAKAytXKR8aRJkzRp0qRyt2VlZXks79mzp9K+QkJC9N5779VQZcC5HSxwlBtupJOh52CBozbLAQBUAZ9FBZxDVGOrLBVss5zaDgCoWwg4wDn06xBV6QhO/w7RtVkOAKAKCDjAOcSFh+j2Pm1lOWMYx88iWSzS7X3aKjY8uOKdAQA+Uadv9AfUFX0viVbrZo00/dUvJUmDOsfqdx1jCTcAUEcRcIAqigk7HWaGJyUoONDfh9UAACrDKSoAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA63AcH5+1A/nFl5RzUwQKHohpb1a9DlOLCQ3xdFgAABBycn6ycPC3+3w+y6OTnMVkkvfnFz7q9T1v1vYTPZgIA+BanqFBtB/KPa/H/fpBhSC5DHl9f2PiDbPknfF0iAKCBI+Cg2rJyDspSwTaLpPU5ebVZDgAAZRBwUG0HCxwyKthmnNoOAIAvEXBQbVGNrZWO4EQ1ttZmOQAAlEHAQbX16xBV6QhO/w5cZAwA8C0CDqotLjxEt/dpK8sZwzh+FslikW7v01ax4cG+Kw4AADFNHOep7yXRat2skaa/+qUkaVDnWP2uYyzhBgBQJxBwcN5iwk6HmeFJCQoO9PdhNQAAnMYpKgAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDrc6A9AuQ7kH1dWzkEdLHAoqrFV/TpEKS48xNdlAUCVEHAAlJGVk6fF//tBFp38AFWLpDe/+Fm392mrvpfwYaoA6j5OUQHwcCD/uBb/7wcZhuQy5PH1hY0/yJZ/wtclAsA5EXAAeMjKOShLBdssktbn5NVmOQBwXgg4ADwcLHDIqGCbcWo7ANR1BBwAHqIaWysdwYlqbK3NcgDgvNRKwFmwYIFat26t4OBgJScna8uWLZW2X716tRITExUcHKwuXbronXfe8dhuGIZmzpypuLg4hYSEKCUlRd999503DwFoMPp1iKp0BKd/By4yBlD3eX0W1csvv6y0tDQtWrRIycnJmj9/vlJTU5WTk6Po6LL/UH788ce66aablJ6ert///vdauXKlhg4dqm3btqlz586SpMcee0zPPPOMXnrpJbVp00YPPPCAUlNT9fXXXys4OLjKtR0rKlFAUUmNHeuxM/o6VoP9VsXxIqdOFDtr9TkdZzyfo5af2xcayvFGhgbplt5ttPSj3e6g42c5GW5u6d1GEaGBtf67BqB+OV7k9Mr7YHX6tBiGUdF/1mpEcnKyLr/8cj333HOSJJfLpYSEBN19992aPn16mfYjRoxQYWGh3nrrLfe63/72t+revbsWLVokwzAUHx+vqVOnatq0aZKk/Px8xcTEaPny5Ro5cmSZPh0OhxyO09cN2O12JSQkKGHyf+RnDa3pQwYAAF7gchzTvvk3Kj8/X2FhYZW29eopqqKiImVnZyslJeX0E/r5KSUlRZs2bSp3n02bNnm0l6TU1FR3+927d8tms3m0CQ8PV3JycoV9pqenKzw83P1ISEi40EMDAAB1mFdPUR06dEhOp1MxMTEe62NiYvTNN9+Uu4/NZiu3vc1mc28vXVdRm7PNmDFDaWlp7uXSEZwtfxlwzgRYXxwpLFZO7lFflwHUW45ip+5YsU2StGjUb2QN9PdxRd7F8XK83hQXHqyWzWr+DIndblfc/Kq1bRB3MrZarbJay878CA0KUGiQOV4CR7FLwSb/gwVqizXQv0H9PXG85uaL4w0J8vfK+2tJNfr06imq5s2by9/fX7m5uR7rc3NzFRsbW+4+sbGxlbYv/VqdPgEAQMPi1YATFBSkpKQkrV271r3O5XJp7dq16tWrV7n79OrVy6O9JGVmZrrbt2nTRrGxsR5t7Ha7Nm/eXGGfAACgYfH6+Zm0tDSNGTNGPXr0UM+ePTV//nwVFhZq3LhxkqTRo0erRYsWSk9PlyTde++96tu3r5588kkNGTJEq1at0qeffqrFixdLkiwWiyZPnqx58+bp4osvdk8Tj4+P19ChQ719OAAAoB7wesAZMWKEDh48qJkzZ8pms6l79+7KyMhwXyS8d+9e+fmdHkjq3bu3Vq5cqb/+9a/685//rIsvvlivvfaa+x44knTfffepsLBQEyZM0JEjR3TllVcqIyOjWvfAAQAA5lUrV9hOmjRJkyZNKndbVlZWmXXDhw/X8OHDK+zPYrFozpw5mjNnTk2VCAAATITPogIAAKZDwAEAAKZDwAEAAKZDwAGABshmP+H+fnX2Ph3IP+7DaoCaR8ABgAYmKydPf17zpXs5Y4dNU1d/rg3f5vmwKqBmEXAAoAE5kH9ci//3gwzj9DqXIRmG9MLGH2TLP1HxzkA9QsABgAYkK+egLBVss0han8MoDsyBgAMADcjBAoeMCrYZp7YDZkDAAYAGJKqxtdIRnKjG1tosB/AaAg4ANCD9OkRVOoLTv0N0bZYDeA0BBwAakLjwEN3ep60sFsnPIo+vt/dpq9hwPtPPDLgNQC19FhUAoO7oe0m0OsSEaX1Ong4WOBTV2Kr+HaIJNyaRlZOnxf/7wb2cscOmd3fYdHuftup7ScMZoSPgAEADFBserJt6tvR1GahhFd0GQDp5G4AOMWENJshyigoAAJPgNgCnEXAAADAJbgNwGgEHAACT4DYApxFwAAAwCW4DcBoBBwAAk+A2AKcxiwoAABPhNgAnEXAAADAZbgPAKSoAAGBCBBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6BBwAAGA6Xg04hw8f1qhRoxQWFqaIiAjdeuutKigoqLT93XffrQ4dOigkJEQtW7bUPffco/z8fI92FoulzGPVqlXePBQAAFCPBHiz81GjRunAgQPKzMxUcXGxxo0bpwkTJmjlypXltv/555/1888/64knnlCnTp30448/6o477tDPP/+s//73vx5tly1bpkGDBrmXIyIivHkoAACgHvFawNm5c6cyMjK0detW9ejRQ5L07LPP6pprrtETTzyh+Pj4Mvt07txZr7zyinu5Xbt2euihh3TzzTerpKREAQGny42IiFBsbKy3ygfQwNjsJ9zfr87ep5SOMYoLD/FhRQAuhNdOUW3atEkRERHucCNJKSkp8vPz0+bNm6vcT35+vsLCwjzCjSRNnDhRzZs3V8+ePbV06VIZhlFhHw6HQ3a73eMBAKWycvL05zVfupczdtg0dfXn2vBtng+rAnAhvDaCY7PZFB0d7flkAQFq2rSpbDZblfo4dOiQ5s6dqwkTJnisnzNnjq6++mqFhobq/fff11133aWCggLdc8895faTnp6u2bNnn9+BADC1A/nHtfh/P+jM/yO5Tn3/wsYf1CEmTLHhwb4pDsB5q/YIzvTp08u9yPfMxzfffHPBhdntdg0ZMkSdOnXSgw8+6LHtgQce0BVXXKHLLrtM999/v+677z49/vjjFfY1Y8YM5efnux/79u274PoAmENWzkFZKthmkbQ+h1EcoD6q9gjO1KlTNXbs2ErbtG3bVrGxscrL8/yHoaSkRIcPHz7ntTNHjx7VoEGD1KRJE61Zs0aBgYGVtk9OTtbcuXPlcDhktVrLbLdareWuB4CDBQ5VdILbOLUdQP1T7YATFRWlqKioc7br1auXjhw5ouzsbCUlJUmS1q1bJ5fLpeTk5Ar3s9vtSk1NldVq1RtvvKHg4HMPDW/fvl2RkZGEGADVFtXYKotUbsixnNoOoP7x2kXGHTt21KBBgzR+/Hht2bJFH330kSZNmqSRI0e6Z1Dt379fiYmJ2rJli6ST4WbgwIEqLCzUkiVLZLfbZbPZZLPZ5HQ6JUlvvvmmXnzxRe3YsUO7du3SwoUL9fDDD+vuu+/21qEAMLF+HaIqHcHp3yG6gq0A6jKv3gdnxYoVmjRpkgYMGCA/Pz8NGzZMzzzzjHt7cXGxcnJydOzYMUnStm3b3DOs2rdv79HX7t271bp1awUGBmrBggWaMmWKDMNQ+/bt9dRTT2n8+PHePBQAJhUXHqLb+7TVCxt/cI/klH69vU9bLjAG6imLUdn8apOy2+0KDw93T0E3g18Li/SN7aivywDqLVv+Ca3PydPBAoeiGlvVv0M04cZEThQ7NW75VknSsrGXKzjQ38cVmVt8RLBaNWtU4/1W5/3bqyM4AFBfxIYH66aeLX1dBoAawodtAgAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAABMz2Y/4f5+dfY+Hcg/7sNqUBsIOAAAU8vKydOf13zpXs7YYdPU1Z9rw7d5PqwK3kbAAQCY1oH841r8vx9kGKfXuQzJMKQXNv4gW/6JindGvUbAAQCYVlbOQVkq2GaRtD6HURyzIuAAAEzrYIFDRgXbjFPbYU4EHACAaUU1tlY6ghPV2Fqb5aAWEXAAAKbVr0NUpSM4/TtE12Y5qEUEHACAacWFh+j2Pm1lsUh+Fnl8vb1PW8WGB/u6RHhJgK8LAADAm/peEq0OMWFan5OngwUORTW2qn+HaMKNyRFwAACmFxserJt6tvR1GahFnKICAACmQ8ABAACmQ8ABAACmQ8ABAACmQ8ABAACm49WAc/jwYY0aNUphYWGKiIjQrbfeqoKCgkr36devnywWi8fjjjvu8Gizd+9eDRkyRKGhoYqOjtaf/vQnlZSUePNQAABAPeLVaeKjRo3SgQMHlJmZqeLiYo0bN04TJkzQypUrK91v/PjxmjNnjns5NDTU/b3T6dSQIUMUGxurjz/+WAcOHNDo0aMVGBiohx9+2GvHAgAA6g+vBZydO3cqIyNDW7duVY8ePSRJzz77rK655ho98cQTio+Pr3Df0NBQxcbGlrvt/fff19dff60PPvhAMTEx6t69u+bOnav7779fDz74oIKCgrxyPAAAoP7w2imqTZs2KSIiwh1uJCklJUV+fn7avHlzpfuuWLFCzZs3V+fOnTVjxgwdO3bMo98uXbooJibGvS41NVV2u11fffVVuf05HA7Z7XaPBwAAMC+vjeDYbDZFR3t+iFlAQICaNm0qm81W4X7/93//p1atWik+Pl5ffPGF7r//fuXk5OjVV19193tmuJHkXq6o3/T0dM2ePftCDgcAANQj1Q4406dP16OPPlppm507d553QRMmTHB/36VLF8XFxWnAgAH6/vvv1a5du/Pqc8aMGUpLS3Mv2+12JSQknHeNAACgbqt2wJk6darGjh1baZu2bdsqNjZWeXl5HutLSkp0+PDhCq+vKU9ycrIkadeuXWrXrp1iY2O1ZcsWjza5ubmSVGG/VqtVVqu1ys8JAADqt2oHnKioKEVFRZ2zXa9evXTkyBFlZ2crKSlJkrRu3Tq5XC53aKmK7du3S5Li4uLc/T700EPKy8tznwLLzMxUWFiYOnXqVM2jAQAAZuS1i4w7duyoQYMGafz48dqyZYs++ugjTZo0SSNHjnTPoNq/f78SExPdIzLff/+95s6dq+zsbO3Zs0dvvPGGRo8erT59+qhr166SpIEDB6pTp076f//v/+nzzz/Xe++9p7/+9a+aOHEiozQAAECSl2/0t2LFCiUmJmrAgAG65pprdOWVV2rx4sXu7cXFxcrJyXHPkgoKCtIHH3yggQMHKjExUVOnTtWwYcP05ptvuvfx9/fXW2+9JX9/f/Xq1Us333yzRo8e7XHfHAAA0LBZDMMwfF1EbbPb7QoPD1d+fr7CwsJ8XU6N+LWwSN/Yjvq6DAAAFB8RrFbNGtV4v9V5/+azqAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkE+LoA1IzgQH/FRwTLZUiGYchlSJJxallyGYb7q3TGOp3eZpQuu05+PdUUAIB6h4BjEiFB/mrVrFGN9mmcEYrODEKSZ2AyJBkuyXAHqlNfVRqcPLcZxjkC1pl9V/R87uUzAx0AACcRcFAhi8Uii0Xyk8XXpVSJO1iVCU5lw5fKC1gqJ3ydSk5nBiyny1CR06Vip6GiEpecpCsAqHMIODANi8Uif4ukWg5kTpehYqfrZOgpKf1aGoJcKio5+bXYSRACgNpCwAEukL+fRf5+/goO9K+0nWF4jvycHX6KSsOR08X1TwBwgQg4QC2xWCyyBvjLGiDJWnnb4jNGf0pDUeno0JmhiNNjAFA+Ag5QBwX6+ynQ30+hQZW3c7o8R36K3afHnCoqMU6v4/QYgAbGq/fBOXz4sEaNGqWwsDBFRETo1ltvVUFBQYXt9+zZc+rC1rKP1atXu9uVt33VqlXePBSgTvL3sygkyF/hIYFq3tiquPAQtWwWqvbRTdQpPkzdEiLUo3VTJbdpqstaRqhzizB1iG2itlGNdFFkiKLDrIpsFKjG1gAFBfjJUj+uJweAc/LqCM6oUaN04MABZWZmqri4WOPGjdOECRO0cuXKctsnJCTowIEDHusWL16sxx9/XIMHD/ZYv2zZMg0aNMi9HBERUeP1A2bh52dRcBWvEyp2nh75KXKee5ZYVa4Xqur4kVHFi49q8hqls/tyGoZOFDvlKHHJUezkFgRAPeW1gLNz505lZGRo69at6tGjhyTp2Wef1TXXXKMnnnhC8fHxZfbx9/dXbGysx7o1a9boxhtvVOPGjT3WR0RElGkL4MJYLBYFBVgUFMBNzks5Sk6GnRPFTjmKXXKUOHXi1NeiEtIPUFd5LeBs2rRJERER7nAjSSkpKfLz89PmzZt1/fXXn7OP7Oxsbd++XQsWLCizbeLEibrtttvUtm1b3XHHHRo3bpwsFYyvOxwOORwO97Ldbj+PIwLQEJ28MNxfYcGBZba5XMbp8FPOVy4CB3zHawHHZrMpOjra88kCAtS0aVPZbLYq9bFkyRJ17NhRvXv39lg/Z84cXX311QoNDdX777+vu+66SwUFBbrnnnvK7Sc9PV2zZ88+vwMBgAr4nboGKiSo/FN/RSUuzxGgM74WlXA7AMCbqh1wpk+frkcffbTSNjt37jzvgkodP35cK1eu1AMPPFBm25nrLrvsMhUWFurxxx+vMODMmDFDaWlp7mW73a6EhIQLrhEAKhMU4KegAD81KWebYXiO/jiKXTpR4nR/LWHmG3BBqh1wpk6dqrFjx1bapm3btoqNjVVeXp7H+pKSEh0+fLhK187897//1bFjxzR69Ohztk1OTtbcuXPlcDhktZa9wYjVai13PQD4isViUXBgxRd+lzhdOnHqQufSr2cGIkZ/gMpVO+BERUUpKirqnO169eqlI0eOKDs7W0lJSZKkdevWyeVyKTk5+Zz7L1myRH/4wx+q9Fzbt29XZGQkIQaAaQT4+6mxv58aW8v+M106+uMoJ/hw8TNwkteuwenYsaMGDRqk8ePHa9GiRSouLtakSZM0cuRI9wyq/fv3a8CAAfrHP/6hnj17uvfdtWuXNm7cqHfeeadMv2+++aZyc3P129/+VsHBwcrMzNTDDz+sadOmeetQAKBO8Rj9CSl78bPTZXjM9vL4ytR3NBBevQ/OihUrNGnSJA0YMEB+fn4aNmyYnnnmGff24uJi5eTk6NixYx77LV26VBdddJEGDhxYps/AwEAtWLBAU6ZMkWEYat++vZ566imNHz/em4cCAPWGv59FoUEBFd4Ju/TCZ0fxyXsdld5/6MzTXoYhGTLc6wydvk+R4W5rnNG2gv1OLZ/Z/+k+y/Z/Zj9n9396/7PbAWVZjKreWctE7Ha7wsPDlZ+fr7CwMF+XAwC4AIZReRA7M2C5DEMFjhIVOpwqdJSo0FHCiJYXxEcEq1WzRjXeb3Xev/ksKgBAvXbyI3s81lTaPjQoQKVT2wzD0LGik2Hn6KnAc6zIyciQCRBwAAANlsViUSNrgBpZA1R65zaXy1Bh0clRngJHsQocTp0oJvTUNwQcAADO4OdnUZPgQDUJDpQULOnkhdsFp0Z4Skd7HMUu3xaKShFwAAA4B38/i8JDAhV+xqy1YqdLhY4S9zU9BY4SFZUQeuoKAg4AAOch0N9PEaFBijhjupqjxOm+gLl0xKeYu1L7BAEHAIAaUvrhrE0bnQ49J4qd7rBTOtrDB7F6HwEHAAAvKr0pY/PGJ++2bxiGThS7dNRRzHR1LyLgAABQiyyWMz6FnunqXkPAAQDAx5iuXvMIOAAA1EFMV78wBBwAAOoJpqtXHQEHAIB6jOnq5SPgAABgMkxXJ+AAANAgNLTp6gQcAAAaILNPVyfgAAAASeaark7AAQAAFaqv09UJOAAAoFrONV3dGuDvw+pOIuAAAIALVt50dV/y83UBAAAANY2AAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATMdrAeehhx5S7969FRoaqoiIiCrtYxiGZs6cqbi4OIWEhCglJUXfffedR5vDhw9r1KhRCgsLU0REhG699VYVFBR44QgAAEB95bWAU1RUpOHDh+vOO++s8j6PPfaYnnnmGS1atEibN29Wo0aNlJqaqhMnTrjbjBo1Sl999ZUyMzP11ltvaePGjZowYYI3DgEAANRTFsMwDG8+wfLlyzV58mQdOXKk0naGYSg+Pl5Tp07VtGnTJEn5+fmKiYnR8uXLNXLkSO3cuVOdOnXS1q1b1aNHD0lSRkaGrrnmGv3000+Kj4+vUk12u13h4eHKz89XWFjYBR0fAACoHdV5/w6opZrOaffu3bLZbEpJSXGvCw8PV3JysjZt2qSRI0dq06ZNioiIcIcbSUpJSZGfn582b96s66+/vty+HQ6HHA6Hezk/P1/SyRcKAADUD6Xv21UZm6kzAcdms0mSYmJiPNbHxMS4t9lsNkVHR3tsDwgIUNOmTd1typOenq7Zs2eXWZ+QkHChZQMAgFp29OhRhYeHV9qmWgFn+vTpevTRRytts3PnTiUmJlanW6+bMWOG0tLS3Msul0uHDx9Ws2bNZLFYavS57Ha7EhIStG/fvgZx+ovjNTeO19w4XnMz4/EahqGjR49W6ZKUagWcqVOnauzYsZW2adu2bXW6dIuNjZUk5ebmKi4uzr0+NzdX3bt3d7fJy8vz2K+kpESHDx92718eq9Uqq9Xqsa6qM7vOV1hYmGl+oaqC4zU3jtfcOF5zM9vxnmvkplS1Ak5UVJSioqLOq6BzadOmjWJjY7V27Vp3oLHb7dq8ebN7JlavXr105MgRZWdnKykpSZK0bt06uVwuJScne6UuAABQ/3htmvjevXu1fft27d27V06nU9u3b9f27ds97lmTmJioNWvWSJIsFosmT56sefPm6Y033tCXX36p0aNHKz4+XkOHDpUkdezYUYMGDdL48eO1ZcsWffTRR5o0aZJGjhxZ5RlUAADA/Lx2kfHMmTP10ksvuZcvu+wySdL69evVr18/SVJOTo57RpMk3XfffSosLNSECRN05MgRXXnllcrIyFBwcLC7zYoVKzRp0iQNGDBAfn5+GjZsmJ555hlvHUa1Wa1WzZo1q8wpMbPieM2N4zU3jtfcGtrxns3r98EBAACobXwWFQAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CTg1asGCBWrdureDgYCUnJ2vLli2+LslrNm7cqGuvvVbx8fGyWCx67bXXfF2SV6Wnp+vyyy9XkyZNFB0draFDhyonJ8fXZXnNwoUL1bVrV/cdUHv16qV3333X12XVikceecR9Xy6zevDBB2WxWDwede0jdmra/v37dfPNN6tZs2YKCQlRly5d9Omnn/q6LK9o3bp1mZ+vxWLRxIkTfV1arSLg1JCXX35ZaWlpmjVrlrZt26Zu3bopNTW1zEdLmEVhYaG6deumBQsW+LqUWrFhwwZNnDhRn3zyiTIzM1VcXKyBAweqsLDQ16V5xUUXXaRHHnlE2dnZ+vTTT3X11Vfruuuu01dffeXr0rxq69ateuGFF9S1a1dfl+J1l156qQ4cOOB+fPjhh74uyWt+/fVXXXHFFQoMDNS7776rr7/+Wk8++aQiIyN9XZpXbN261eNnm5mZKUkaPny4jyurZQZqRM+ePY2JEye6l51OpxEfH2+kp6f7sKraIclYs2aNr8uoVXl5eYYkY8OGDb4updZERkYaL774oq/L8JqjR48aF198sZGZmWn07dvXuPfee31dktfMmjXL6Natm6/LqDX333+/ceWVV/q6DJ+59957jXbt2hkul8vXpdQqRnBqQFFRkbKzs5WSkuJe5+fnp5SUFG3atMmHlcFbSu/A3bRpUx9X4n1Op1OrVq1SYWGhevXq5etyvGbixIkaMmSIx9+xmX333XeKj49X27ZtNWrUKO3du9fXJXnNG2+8oR49emj48OGKjo7WZZddpr///e++LqtWFBUV6V//+pduueUWWSwWX5dTqwg4NeDQoUNyOp2KiYnxWB8TEyObzeajquAtLpdLkydP1hVXXKHOnTv7uhyv+fLLL9W4cWNZrVbdcccdWrNmjTp16uTrsrxi1apV2rZtm9LT031dSq1ITk7W8uXLlZGRoYULF2r37t266qqrdPToUV+X5hU//PCDFi5cqIsvvljvvfee7rzzTt1zzz0eHydkVq+99pqOHDmisWPH+rqUWue1z6ICzGrixInasWOHqa9ZkKQOHTpo+/btys/P13//+1+NGTNGGzZsMF3I2bdvn+69915lZmZ6fO6dmQ0ePNj9fdeuXZWcnKxWrVrpP//5j2699VYfVuYdLpdLPXr00MMPPyzp5Gcj7tixQ4sWLdKYMWN8XJ13LVmyRIMHD26QH0jNCE4NaN68ufz9/ZWbm+uxPjc3V7GxsT6qCt4wadIkvfXWW1q/fr0uuugiX5fjVUFBQWrfvr2SkpKUnp6ubt266emnn/Z1WTUuOztbeXl5+s1vfqOAgAAFBARow4YNeuaZZxQQECCn0+nrEr0uIiJCl1xyiXbt2uXrUrwiLi6uTDDv2LGjqU/LSdKPP/6oDz74QLfddpuvS/EJAk4NCAoKUlJSktauXete53K5tHbtWlNfs9CQGIahSZMmac2aNVq3bp3atGnj65JqncvlksPh8HUZNW7AgAH68ssvtX37dvejR48eGjVqlLZv3y5/f39fl+h1BQUF+v777xUXF+frUrziiiuuKHNbh2+//VatWrXyUUW1Y9myZYqOjtaQIUN8XYpPcIqqhqSlpWnMmDHq0aOHevbsqfnz56uwsFDjxo3zdWleUVBQ4PG/vd27d2v79u1q2rSpWrZs6cPKvGPixIlauXKlXn/9dTVp0sR9bVV4eLhCQkJ8XF3NmzFjhgYPHqyWLVvq6NGjWrlypbKysvTee+/5urQa16RJkzLXUjVq1EjNmjUz7TVW06ZN07XXXqtWrVrp559/1qxZs+Tv76+bbrrJ16V5xZQpU9S7d289/PDDuvHGG7VlyxYtXrxYixcv9nVpXuNyubRs2TKNGTNGAQEN9K3e19O4zOTZZ581WrZsaQQFBRk9e/Y0PvnkE1+X5DXr1683JJV5jBkzxteleUV5xyrJWLZsma9L84pbbrnFaNWqlREUFGRERUUZAwYMMN5//31fl1VrzD5NfMSIEUZcXJwRFBRktGjRwhgxYoSxa9cuX5flVW+++abRuXNnw2q1GomJicbixYt9XZJXvffee4YkIycnx9el+IzFMAzDN9EKAADAO7gGBwAAmA4BBwAAmA4BBwAAmA4BBwAAmA4BBwAAmA4BBwAAmA4BBwAAmA4BBwAAmA4BBwAAmA4BBwAAmA4BBwAAmM7/B6YHtKNVup1vAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "18\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "19\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "25\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "26\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "28\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "29\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "30\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "31\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "32\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "33\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "34\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "35\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "36\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "37\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "38\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "39\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "40\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "41\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "42\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "43\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGzCAYAAAAi6m1wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFH0lEQVR4nO3deXxU1f3/8fckJBMCZIHsGHYlIJtNJEKRRVICUhWLCH7hx6KCC6gQqEJbQRaNuBVRFGkFtIKoVRSXRiNr1RQwiCtGURREkrAlk40sM/f3B2ZgyEICmQy5eT0fj3kkc++5537uTJJ5595z77UYhmEIAADARLw8XQAAAEBdI+AAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAqNaWLVtksVi0ZcuWOu3XYrHogQceqNM+zcpd70FNORwOdevWTQ8++KBH1l+ZlJQUNW/eXIcPH/Z0KbhAEXDQaDzzzDOyWCyKj48/777ee+89Ppxr4EJ8nR544AFZLJZKH8uXL/dobc8884xWr17t0Roq8/LLL+vAgQOaNm1apfNr+ruVlZWlWbNmKSYmRv7+/mrWrJliY2O1aNEi5eTkONsNHDiwyvfo22+/lSQNHTpUnTp1UnJycp1tJ8yliacLAOrLmjVr1K5dO+3YsUN79+5Vp06dzrmv9957T8uWLbvgPrwvNNW9TkVFRWrSxHN/gp599lk1b97cZVpdhN/z8cwzzygkJEQTJ050md6/f38VFRXJ19fXI3U9+uijGjNmjAIDAyudX5PfrZ07d+rqq69Wfn6+xo0bp9jYWEnSp59+qocffljbtm3TBx984Gx/0UUXVRpeoqKinN/fdtttmjVrlubPn68WLVqc72bCZAg4aBT27dunTz75RG+88YZuu+02rVmzRvPmzfN0WW5VWFgof3//CtPLysrkcDg89mFZzs/Pz6Prv+GGGxQSEuLRGmrKy8vLY6/XZ599ps8//1yPP/54pfNr8ruVk5Oj66+/Xt7e3vrss88UExPjMv/BBx/UP/7xD5dpgYGBGjduXLW1jRw5UnfddZdee+013XzzzeewdTAzDlGhUVizZo2Cg4M1fPhw3XDDDVqzZk2FNlWNc/jpp59ksVichw4mTpyoZcuWSZLLrvNyBQUFmjlzpqKjo2W1WtW5c2c99thjMgyjwjpfeukl9e7dW/7+/goODlb//v1d/ouVTv5Xf+mll8pqtSoqKkpTp0512Z0vndyl361bN6Wnp6t///7y9/fXX/7yF2ftjz32mJYsWaKOHTvKarXqm2++kSR9++23uuGGG9SyZUv5+fkpLi5OGzZsOOvr+d///lejRo1SmzZtZLVaFR0drRkzZqioqMjZ5myvU2VjcD777DMNGzZMAQEBat68uQYPHqz//e9/Lm1Wr14ti8Wijz/+WElJSQoNDVWzZs10/fXX18l4jDPf79OdWXP54a69e/dq4sSJCgoKUmBgoCZNmqTCwsIKy1f3frdr105ff/21tm7d6nytBg4cKKnqn83XXntNsbGxatq0qUJCQjRu3DgdPHjQpc3EiRPVvHlzHTx4UCNGjFDz5s0VGhqqWbNmyW63n/X1ePPNN+Xr66v+/ftXOr8mv1vPPfecDh48qCeeeKJCuJGk8PBw/e1vfztrLWcKCwtTjx499NZbb9V6WZgfe3DQKKxZs0Z/+tOf5Ovrq5tuuknPPvusdu7cqcsvv7zWfd1222369ddflZqaqn/9618u8wzD0LXXXqvNmzfrlltuUa9evfT+++/rz3/+sw4ePKi///3vzrbz58/XAw88oL59+2rBggXy9fXV9u3btWnTJg0ZMkTSyQ/Q+fPnKyEhQXfccYcyMjKctX/88cfy8fFx9nf06FENGzZMY8aM0bhx4xQeHu6ct2rVKp04cUJTpkyR1WpVy5Yt9fXXX+v3v/+9WrdurdmzZ6tZs2Z69dVXNWLECL3++uu6/vrrq3wNXnvtNRUWFuqOO+5Qq1attGPHDj311FP65Zdf9Nprr531darM119/rSuvvFIBAQG699575ePjo+eee04DBw7U1q1bKxw+uuuuuxQcHKx58+bpp59+0pIlSzRt2jS98sorZ12XJB07dszlube3t4KDg2u07JluvPFGtW/fXsnJydq1a5f++c9/KiwsTIsXL3a2Odv7vWTJEt11111q3ry5/vrXv0qSy3t4ptWrV2vSpEm6/PLLlZycrKysLD355JP6+OOP9dlnnykoKMjZ1m63KzExUfHx8Xrsscf04Ycf6vHHH1fHjh11xx13VLttn3zyibp16+bys3a6mvxubdiwQU2bNtUNN9xQk5fTWfORI0dcpvn5+VU4rBgbG6s333yzxv2iETEAk/v0008NSUZqaqphGIbhcDiMiy66yLjnnntc2m3evNmQZGzevNll+r59+wxJxqpVq5zTpk6dalT26/Pmm28akoxFixa5TL/hhhsMi8Vi7N271zAMw/j+++8NLy8v4/rrrzfsdrtLW4fDYRiGYWRnZxu+vr7GkCFDXNo8/fTThiRj5cqVzmkDBgwwJBnLly+vtPaAgAAjOzvbZd7gwYON7t27GydOnHBZd9++fY2LL7642telsLCwwrYnJycbFovF+Pnnn8/6OhmGYUgy5s2b53w+YsQIw9fX1/jhhx+c03799VejRYsWRv/+/Z3TVq1aZUgyEhISnK+VYRjGjBkzDG9vbyMnJ6fS9ZWbN2+eIanCo23btoZhVP5+V1VzeV8333yzS7vrr7/eaNWqlfN5Td5vwzCMSy+91BgwYECF9Z75HpSUlBhhYWFGt27djKKiIme7d955x5BkzJ071zltwoQJhiRjwYIFLn1edtllRmxsbKWv0ekuuugiY+TIkZXOq+nvVnBwsNGzZ8+zrqtc+c/zmY8JEyZUaPvQQw8ZkoysrKwa94/GgUNUML01a9YoPDxcgwYNknTyMMPo0aO1bt26Gu2ir4333ntP3t7euvvuu12mz5w5U4Zh6D//+Y+kk7v9HQ6H5s6dKy8v11/D8sM4H374oUpKSjR9+nSXNpMnT1ZAQIDeffddl+WsVqsmTZpUaV0jR45UaGio8/mxY8e0adMm3XjjjcrLy9ORI0d05MgRHT16VImJifr+++8rHOo4XdOmTZ3fFxQU6MiRI+rbt68Mw9Bnn31W3UtUKbvdrg8++EAjRoxQhw4dnNMjIyP1f//3f/roo49ks9lclpkyZYrLIa8rr7xSdrtdP//8c43W+frrrys1NdX5qOzQSk3dfvvtLs+vvPJKHT161FlzTd7v2vj000+VnZ2tO++802VszvDhwxUTE1PhZ6OqGn/88cezruvo0aNV7tmq6e+WzWar9SDgdu3aubw/qampuvfeeyu0K6/tzL09AIeoYGp2u13r1q3ToEGDtG/fPuf0+Ph4Pf7449q4caPzcFBd+PnnnxUVFVXhj3mXLl2c8yXphx9+kJeXl7p27VptX5LUuXNnl+m+vr7q0KFDhQ/y1q1bVzlwuH379i7P9+7dK8MwdP/99+v++++vdJns7Gy1bt260nn79+/X3LlztWHDBh0/ftxlXm5ubpXbVJXDhw+rsLCwwrZKJ187h8OhAwcO6NJLL3VOb9OmjUu78g+6M+upSv/+/etskHF1tQQEBNTo/a6Nqn42JCkmJkYfffSRyzQ/Pz+XgFteY01fK6OS8WO1+d0KCAhQXl5ejdZVrlmzZkpISKhxbecSFGFuBByY2qZNm3To0CGtW7dO69atqzB/zZo1zj/CVf2BrOu9PO5y+l6Vs81zOBySpFmzZikxMbHSZao6jd5ut+sPf/iDjh07pvvuu08xMTFq1qyZDh48qIkTJzr7djdvb+9Kp1f2YVwb5/Jz4K5a6kpV9dVEq1atKg1CtfndiomJ0e7du1VSUlLnZ++V19ZQzohD/SHgwNTWrFmjsLAw59k8p3vjjTe0fv16LV++XE2bNnX+133mGUqVHfKo6kOwbdu2+vDDD5WXl+eyF6f84mRt27aVJHXs2FEOh0PffPONevXqVWVfkpSRkeFy2KakpET79u2r0X+3VSnvz8fHp9b9fPnll/ruu+/0wgsvaPz48c7pqampFdrW9L/q0NBQ+fv7KyMjo8K8b7/9Vl5eXoqOjq5VneeqNj8HNVWT91uq+et1+s/GVVdd5TIvIyPDOb8uxMTEuOyhKVeb361rrrlGaWlpev3113XTTTfVWW3SydPUQ0JCKuyhAhiDA9MqKirSG2+8oT/+8Y+64YYbKjymTZumvLw852nRbdu2lbe3t7Zt2+bSzzPPPFOh72bNmkmq+CF49dVXy2636+mnn3aZ/ve//10Wi0XDhg2TJI0YMUJeXl5asGBBhT0e5f/1JyQkyNfXV0uXLnXZE/D8888rNzdXw4cPP4dX5aSwsDANHDhQzz33nA4dOlRhfnWnW5fvDTi9JsMw9OSTT1ZoW9XrVFmfQ4YM0VtvvaWffvrJOT0rK0tr165Vv379FBAQUG0fdSUgIEAhISE1+jmoqZq839LJ1+tsr5UkxcXFKSwsTMuXL1dxcbFz+n/+8x/t2bPnvH42ztSnTx999dVXLuup7e/W7bffrsjISM2cOVPfffddhXVkZ2dr0aJF51Rfenq6+vTpc24bB1NjDw5Ma8OGDcrLy9O1115b6fwrrrhCoaGhWrNmjUaPHq3AwECNGjVKTz31lCwWizp27Kh33nlH2dnZFZYtvwrr3XffrcTERHl7e2vMmDG65pprNGjQIP31r3/VTz/9pJ49e+qDDz7QW2+9penTp6tjx46STh7++etf/6qFCxfqyiuv1J/+9CdZrVbt3LlTUVFRSk5OVmhoqObMmaP58+dr6NChuvbaa5WRkaFnnnlGl19++VkvgnY2y5YtU79+/dS9e3dNnjxZHTp0UFZWltLS0vTLL7/o888/r3S5mJgYdezYUbNmzdLBgwcVEBCg119/vdLDGFW9TpVZtGiRUlNT1a9fP915551q0qSJnnvuORUXF+uRRx45r22trVtvvVUPP/ywbr31VsXFxWnbtm2VfjDXVE3eb+nk6/Xss89q0aJF6tSpk8LCwirsoZFO7nlbvHixJk2apAEDBuimm25yniberl07zZgx45xrPdN1112nhQsXauvWrc5DTrX93QoODtb69et19dVXq1evXi5XMt61a5defvnlcwop2dnZ+uKLLzR16tRz30CYl2dO3gLc75prrjH8/PyMgoKCKttMnDjR8PHxMY4cOWIYhmEcPnzYGDlypOHv728EBwcbt912m/HVV19VOG24rKzMuOuuu4zQ0FDDYrG4nAqdl5dnzJgxw4iKijJ8fHyMiy++2Hj00UddTgcut3LlSuOyyy4zrFarERwcbAwYMMB5ym25p59+2oiJiTF8fHyM8PBw44477jCOHz/u0mbAgAHGpZdeWqH/8lOeH3300Uq3/4cffjDGjx9vREREGD4+Pkbr1q2NP/7xj8a///1vZ5vKThP/5ptvjISEBKN58+ZGSEiIMXnyZOPzzz+v1eukM065NgzD2LVrl5GYmGg0b97c8Pf3NwYNGmR88sknLm3KTxPfuXOny/SqTvM/U/mp3YcPH66yTWFhoXHLLbcYgYGBRosWLYwbb7zRyM7OrvI08TP7Kq9x3759LtPP9n5nZmYaw4cPN1q0aGFIcp4yXtW2vfLKK87+WrZsaYwdO9b45ZdfXNpMmDDBaNasWZWvQ0306NHDuOWWW5zPz+V3yzBOnvY/Y8YM45JLLjH8/PwMf39/IzY21njwwQeN3NxcZ7uqfp7P9Oyzzxr+/v6GzWar0XagcbEYxgUyCg4AcEH617/+palTp2r//v0uFxD0tMsuu0wDBw50uYAmUI4xOACAao0dO1Zt2rSpdECxp6SkpOj777/XnDlzPF0KLlDswQEAAKbDHhwAAGA6bg0427Zt0zXXXKOoqChZLJYa3RBty5Yt+t3vfier1apOnTpVekffZcuWqV27dvLz81N8fLx27NhR98UDAIAGy60Bp6CgQD179qzxcdt9+/Zp+PDhGjRokHbv3q3p06fr1ltv1fvvv+9s88orrygpKUnz5s3Trl271LNnTyUmJlZ6Ki8AAGic6m0MjsVi0fr16zVixIgq29x3331699139dVXXzmnjRkzRjk5OUpJSZF08j4nl19+ufNCag6HQ9HR0brrrrs0e/Zst24DAABoGC6oC/2lpaVVuGx8YmKipk+fLunkJerT09NdRs17eXkpISFBaWlpVfZbXFzschVOh8OhY8eOqVWrVtygDQCABsIwDOXl5SkqKkpeXtUfhLqgAk5mZqbCw8NdpoWHh8tms6moqEjHjx+X3W6vtE35vX4qk5ycrPnz57ulZgAAUL8OHDigiy66qNo2F1TAcZc5c+YoKSnJ+Tw3N1dt2rTRgQMH6uT+Nn9P/U6rP/lJdkfFo33eXhZN7NtOM/5wyXmvBwCAxsxmsyk6OtrlZsZVuaACTkREhLKyslymZWVlKSAgQE2bNpW3t7e8vb0rbRMREVFlv1arVVartcL0gICAOgk44wd00QufZsmrktFMFos0YUAXBQQ0O+/1AAAA1Wh4yQV1HZw+ffpo48aNLtNSU1OdN2Hz9fVVbGysSxuHw6GNGzd69G6y7UOaafHIHvI67fX2tljkZZEWj+yhdiGEGwAA6pNb9+Dk5+dr7969zuf79u3T7t271bJlS7Vp00Zz5szRwYMH9eKLL0qSbr/9dj399NO69957dfPNN2vTpk169dVX9e677zr7SEpK0oQJExQXF6fevXtryZIlKigo0KRJk9y5KWc1Ki5a3VoHaNiTH0mSJvVrp3HxbQk3AAB4gFsDzqeffqpBgwY5n5ePg5kwYYJWr16tQ4cOaf/+/c757du317vvvqsZM2boySef1EUXXaR//vOfSkxMdLYZPXq0Dh8+rLlz5yozM1O9evVSSkpKhYHHntC21akwk/SHS+Tve0EdAQQAoNFolPeistlsCgwMVG5ubp2MwSlXWFKmrnNPXpTwmwWJBBwAAOpQbT6/L6gxOAAAAHWBgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyniacLAACgtgzDkGFIDsOQod++Gjr5kCGHcbKNw5B0Wjvjt681X8951FirNVVY2BOL1tn2NrM2UYCfz3lUcv4IOAAAp/JQ4PyqU8GhYpioGDJOhgnXkHH68i5B4/S2jhqsS5LDUb68J18lnE1UkB8BBwBQv4rL7MopLNXxwhIVFJfJ7jgVIAgOMAsCDgCYnGEYyi8uOy3U2D1dEuB2BBwAMKEyu0O5RaU6Xliq3KISlZSxawaNCwEHAEyiqMSu44UlOl5YorwTZRxuQqNGwAGABsowDNmKypyh5kSpw9MlARcMAg4ANCAlZQ7lFJUop7BUuUWlKrOzmwaoDAEHAC5w+cVlOl5QotyiUuWdKPN0OUCDQMABgAuM3WH8NkD45J6akjIOPQG1RcABgAvAidJT16axFZWevAIvgHNGwAEADzAMQ7YTZcr5bS9NYQnXpgHqEgEHAOpJqd2hnMLSk6GGAcKAW9XL3cSXLVumdu3ayc/PT/Hx8dqxY0eVbQcOHCiLxVLhMXz4cGebiRMnVpg/dOjQ+tgUAKiVwpIyHcwp0lcHc5X+83Htzc7XkfwSwg3gZm7fg/PKK68oKSlJy5cvV3x8vJYsWaLExERlZGQoLCysQvs33nhDJSUlzudHjx5Vz549NWrUKJd2Q4cO1apVq5zPrVar+zYCAGrIcfoA4aJSFXNtGsAj3B5wnnjiCU2ePFmTJk2SJC1fvlzvvvuuVq5cqdmzZ1do37JlS5fn69atk7+/f4WAY7VaFRER4b7CAaCGTr95pa2oTHZGCAMe59aAU1JSovT0dM2ZM8c5zcvLSwkJCUpLS6tRH88//7zGjBmjZs2auUzfsmWLwsLCFBwcrKuuukqLFi1Sq1atKu2juLhYxcXFzuc2m+0ctgYATuLmlcCFz60B58iRI7Lb7QoPD3eZHh4erm+//fasy+/YsUNfffWVnn/+eZfpQ4cO1Z/+9Ce1b99eP/zwg/7yl79o2LBhSktLk7e3d4V+kpOTNX/+/PPbGACNWpndoZyiUucg4VLG0AAXtAv6LKrnn39e3bt3V+/evV2mjxkzxvl99+7d1aNHD3Xs2FFbtmzR4MGDK/QzZ84cJSUlOZ/bbDZFR0e7r3AApsDNK4GGy60BJyQkRN7e3srKynKZnpWVddbxMwUFBVq3bp0WLFhw1vV06NBBISEh2rt3b6UBx2q1MggZ0MlDK+Uf0sZp08qfn5r327QL+APdXbWVlDm4eSVgAm4NOL6+voqNjdXGjRs1YsQISZLD4dDGjRs1bdq0apd97bXXVFxcrHHjxp11Pb/88ouOHj2qyMjIuigbjZxhGCq1G7I7DJU6HCqzGyqzO1TqOPm1fADpqYDgXLKS8FAxLJweIs78kK60/Wl11XSdVbcHgMbB7YeokpKSNGHCBMXFxal3795asmSJCgoKnGdVjR8/Xq1bt1ZycrLLcs8//7xGjBhRYeBwfn6+5s+fr5EjRyoiIkI//PCD7r33XnXq1EmJiYnu3hw0MIZhqMxhqMxeeVgptRsq+216qd3hbAsAaNjcHnBGjx6tw4cPa+7cucrMzFSvXr2UkpLiHHi8f/9+eXm5Xm8wIyNDH330kT744IMK/Xl7e+uLL77QCy+8oJycHEVFRWnIkCFauHAhh6EagbLfQkip3XFGaDn1/amgcvIrey8AoPGxGEbj+/Nvs9kUGBio3NxcBQQE1Fm/hSVl6jr3fUnSNwsS5e97QY/h9riahJWy076W2gkrANAQRAX5qW2rZmdvWEu1+fzmExh1wu5w3XNS2aGf8iBDWAEAuBsBBxU4HIZKzjjMc+ahn9LTgkqZ3SEu3AoAuJAQcEzO4Tj7OBXCCgDAbAg4JlFYUqZfc4p+Cymnggz3xAEANEYEHJMoLnXocF7J2RsCANAIeJ29CQAAQMNCwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZTLwFn2bJlateunfz8/BQfH68dO3ZU2Xb16tWyWCwuDz8/P5c2hmFo7ty5ioyMVNOmTZWQkKDvv//e3ZsBAAAaCLcHnFdeeUVJSUmaN2+edu3apZ49eyoxMVHZ2dlVLhMQEKBDhw45Hz///LPL/EceeURLly7V8uXLtX37djVr1kyJiYk6ceKEuzcHAAA0AG4POE888YQmT56sSZMmqWvXrlq+fLn8/f21cuXKKpexWCyKiIhwPsLDw53zDMPQkiVL9Le//U3XXXedevTooRdffFG//vqr3nzzTXdvDgAAaADcGnBKSkqUnp6uhISEUyv08lJCQoLS0tKqXC4/P19t27ZVdHS0rrvuOn399dfOefv27VNmZqZLn4GBgYqPj6+yz+LiYtlsNpcHAAAwL7cGnCNHjshut7vsgZGk8PBwZWZmVrpM586dtXLlSr311lt66aWX5HA41LdvX/3yyy+S5FyuNn0mJycrMDDQ+YiOjj7fTQMAABewC+4sqj59+mj8+PHq1auXBgwYoDfeeEOhoaF67rnnzrnPOXPmKDc31/k4cOBAHVYMAAAuNG4NOCEhIfL29lZWVpbL9KysLEVERNSoDx8fH1122WXau3evJDmXq02fVqtVAQEBLg8AAGBebg04vr6+io2N1caNG53THA6HNm7cqD59+tSoD7vdri+//FKRkZGSpPbt2ysiIsKlT5vNpu3bt9e4TwAAYG5N3L2CpKQkTZgwQXFxcerdu7eWLFmigoICTZo0SZI0fvx4tW7dWsnJyZKkBQsW6IorrlCnTp2Uk5OjRx99VD///LNuvfVWSSfPsJo+fboWLVqkiy++WO3bt9f999+vqKgojRgxwt2bAwAAGgC3B5zRo0fr8OHDmjt3rjIzM9WrVy+lpKQ4Bwnv379fXl6ndiQdP35ckydPVmZmpoKDgxUbG6tPPvlEXbt2dba59957VVBQoClTpignJ0f9+vVTSkpKhQsCAgCAxsliGIbh6SLqm81mU2BgoHJzc+t0PE5hSZm6zn1fkvTNgkT5+7o9PzodLyjRt5l59bY+AACqEhXkp7atmtV5v7X5/L7gzqICAAA4XwQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOvUScJYtW6Z27drJz89P8fHx2rFjR5Vt//GPf+jKK69UcHCwgoODlZCQUKH9xIkTZbFYXB5Dhw5192YAAIAGwu0B55VXXlFSUpLmzZunXbt2qWfPnkpMTFR2dnal7bds2aKbbrpJmzdvVlpamqKjozVkyBAdPHjQpd3QoUN16NAh5+Pll19296YAAIAGwu0B54knntDkyZM1adIkde3aVcuXL5e/v79WrlxZafs1a9bozjvvVK9evRQTE6N//vOfcjgc2rhxo0s7q9WqiIgI5yM4ONjdmwIAABoItwackpISpaenKyEh4dQKvbyUkJCgtLS0GvVRWFio0tJStWzZ0mX6li1bFBYWps6dO+uOO+7Q0aNHq+yjuLhYNpvN5QEAAMzLrQHnyJEjstvtCg8Pd5keHh6uzMzMGvVx3333KSoqyiUkDR06VC+++KI2btyoxYsXa+vWrRo2bJjsdnulfSQnJyswMND5iI6OPveNAgAAF7wmni6gOg8//LDWrVunLVu2yM/Pzzl9zJgxzu+7d++uHj16qGPHjtqyZYsGDx5coZ85c+YoKSnJ+dxmsxFyAAAwMbfuwQkJCZG3t7eysrJcpmdlZSkiIqLaZR977DE9/PDD+uCDD9SjR49q23bo0EEhISHau3dvpfOtVqsCAgJcHgAAwLzcGnB8fX0VGxvrMkC4fMBwnz59qlzukUce0cKFC5WSkqK4uLizrueXX37R0aNHFRkZWSd1AwCAhs3tZ1ElJSXpH//4h1544QXt2bNHd9xxhwoKCjRp0iRJ0vjx4zVnzhxn+8WLF+v+++/XypUr1a5dO2VmZiozM1P5+fmSpPz8fP35z3/W//73P/3000/auHGjrrvuOnXq1EmJiYnu3hwAANAAuH0MzujRo3X48GHNnTtXmZmZ6tWrl1JSUpwDj/fv3y8vr1M569lnn1VJSYluuOEGl37mzZunBx54QN7e3vriiy/0wgsvKCcnR1FRURoyZIgWLlwoq9Xq7s0BAAANgMUwDMPTRdQ3m82mwMBA5ebm1ul4nMKSMnWd+74k6ZsFifL3rb8x3McLSvRtZl69rQ8AgKpEBfmpbatmdd5vbT6/uRcVAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwnSaeLgAAUP8O5RZpS8ZhHc4vVmhzqwZ2DlVkYFNPlwXUGQIOADQyWzKyteK/P8oiyZBkkfT2F7/qtv4dNOCSMA9XB9QNDlEBQCNyKLdIK/77owxDchhy+frcth+VmXvC0yUCdYKAAwCNyJaMw7JUMc8iaXNGdn2WA7gNAQcAGpHD+cUyqphn/DYfMAMCDgA0IqHNrdXuwQltbq3PcgC3IeAAQCMysHNotXtwBnVmkDHMgYADAI1IZGBT3da/gyyn7cbxskgWi3Rb/w6KCPTzXHFAHeI0cQBoZAZcEqZ2rZpp9htfSpKGdovQH7pEEG5gKgQcAGiEwgNOhZlRsdHy8/H2YDVA3eMQFQAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB3OogIAwGQO5RZpS8ZhHc4vVmhzqwZ2DlVkYFNPl1WvCDgAANNrTB/4WzKyteK/P8qik1entkh6+4tfdVv/DhpwSeO5UjUBBwBgao3pA/9QbpFW/PdHGYact+Qo//rcth/VOTyg0VzQkTE4ACp1KLdIL+/Yr6WbvtfLO/brUG6Rp0sCau30D3yHIZevz237UZm5JzxdYp3aknG42pupbs7Irs9yPIo9OAAqaEz/8cLcyj/wK7vBaPkH/k2929RzVe5zOL+42pupHs4vrs9yPIo9OABcNLb/eGFuje0DP7S5tdo9OKHNrfVZjkcRcAC4YBc3zKSxfeAP7BxabaAb1Lnx7IGtl4CzbNkytWvXTn5+foqPj9eOHTuqbf/aa68pJiZGfn5+6t69u9577z2X+YZhaO7cuYqMjFTTpk2VkJCg77//3p2bADQaje0/XphbY/vAjwxsqtv6d5DltFTnZZEsFum2/h0azQBjqR7G4LzyyitKSkrS8uXLFR8fryVLligxMVEZGRkKC6v4g/XJJ5/opptuUnJysv74xz9q7dq1GjFihHbt2qVu3bpJkh555BEtXbpUL7zwgtq3b6/7779fiYmJ+uabb+TnV/M3r7CkTE1KyupsWwtP66uwDvutiaISu06U2ut1nTCnYH+fascsBPv78LNmAsWnvYfFJn4/g/19dXPf9lr58T7nz7SX5eTP98192yvIhD/P8e1bKSrQT3M3fCNJ+kOXcA2KCVN4gF+9bWtRid0tn4O16dNiGEZV4bZOxMfH6/LLL9fTTz8tSXI4HIqOjtZdd92l2bNnV2g/evRoFRQU6J133nFOu+KKK9SrVy8tX75chmEoKipKM2fO1KxZsyRJubm5Cg8P1+rVqzVmzJgKfRYXF6u4+NR/nTabTdHR0Yqe/qq8rP51vckAAMANHMWFOrDkRuXm5iogIKDatm49RFVSUqL09HQlJCScWqGXlxISEpSWllbpMmlpaS7tJSkxMdHZft++fcrMzHRpExgYqPj4+Cr7TE5OVmBgoPMRHR19vpsGAAAuYG49RHXkyBHZ7XaFh4e7TA8PD9e3335b6TKZmZmVts/MzHTOL59WVZszzZkzR0lJSc7n5Xtwdvx18FkTYEORU1CqjKy8el1ncaldt6/ZJUlaPvZ3svp41+v661tj294s2wlt+/6wjuaXqFVzX/W/OFThAeY9ft/Y3l/AnSID/dSmVd0fIbHZbIpcUrO2jeI6OFarVVZrxZHy/r5N5O9rjpeguNQhPw/+Qbb6eHt0/fWtMWxv21bN9P9aNfN0GR7RGN5fwJ2a+nq75fO1rBZ9uvUQVUhIiLy9vZWVleUyPSsrSxEREZUuExERUW378q+16RMAADQubg04vr6+io2N1caNG53THA6HNm7cqD59+lS6TJ8+fVzaS1Jqaqqzffv27RUREeHSxmazafv27VX2CQAAGhe3H59JSkrShAkTFBcXp969e2vJkiUqKCjQpEmTJEnjx49X69atlZycLEm65557NGDAAD3++OMaPny41q1bp08//VQrVqyQJFksFk2fPl2LFi3SxRdf7DxNPCoqSiNGjHD35gAAgAbA7QFn9OjROnz4sObOnavMzEz16tVLKSkpzkHC+/fvl5fXqR1Jffv21dq1a/W3v/1Nf/nLX3TxxRfrzTffdF4DR5LuvfdeFRQUaMqUKcrJyVG/fv2UkpJSq2vgAAAA86qXEbbTpk3TtGnTKp23ZcuWCtNGjRqlUaNGVdmfxWLRggULtGDBgroqEQAAmAj3ogIAAKZDwAFqKNN26i7ar6Uf0KHcIg9WAwCoDgEHqIEtGdn6y/ovnc9TvsrUzNc+19bvuLM2AFyICDjAWRzKLdKK//6o0+/a5jAkw5Ce2/ajMnNPVL0wAMAjCDjAWWzJOCxLFfMskjZnsBcHAC40BBzgLA7nF8uoYp7x23wAwIWFgAOcRWhza7V7cEKbV7zPGQDAswg4wFkM7Bxa7R6cQZ3D6rMcAEANEHCAs4gMbKrb+neQxSJ5WeTy9bb+HRQRyBW0AeBCUy9XMgYaugGXhKlzeIA2Z2TrcH6xQptbNahzGOEGAC5QBByghiIC/XRT7zaeLgMAUAMcogIAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwME5y7SdcH7/WvoBHcot8mA1AACcQsDBOdmSka2/rP/S+Tzlq0zNfO1zbf0u24NVAQBwEgEHtXYot0gr/vujDOPUNIchGYb03LYflZl7ouqFAQCoB24NOMeOHdPYsWMVEBCgoKAg3XLLLcrPz6+2/V133aXOnTuradOmatOmje6++27l5ua6tLNYLBUe69atc+em4DRbMg7LUsU8i6TNGezFAQB4VhN3dj527FgdOnRIqampKi0t1aRJkzRlyhStXbu20va//vqrfv31Vz322GPq2rWrfv75Z91+++369ddf9e9//9ul7apVqzR06FDn86CgIHduCk5zOL9YRhXzjN/mAwDgSW4LOHv27FFKSop27typuLg4SdJTTz2lq6++Wo899piioqIqLNOtWze9/vrrzucdO3bUgw8+qHHjxqmsrExNmpwqNygoSBEREe4qH9UIbW6VRao05Fh+mw8AgCe57RBVWlqagoKCnOFGkhISEuTl5aXt27fXuJ/c3FwFBAS4hBtJmjp1qkJCQtS7d2+tXLlShlHVPgWpuLhYNpvN5YFzN7BzaLV7cAZ1DqvPcgAAqMBtASczM1NhYa4fdE2aNFHLli2VmZlZoz6OHDmihQsXasqUKS7TFyxYoFdffVWpqakaOXKk7rzzTj311FNV9pOcnKzAwEDnIzo6uvYbBKfIwKa6rX8HWSySl0UuX2/r30ERgX6eLhEA0MjV+hDV7NmztXjx4mrb7Nmz55wLKmez2TR8+HB17dpVDzzwgMu8+++/3/n9ZZddpoKCAj366KO6++67K+1rzpw5SkpKcumbkHN+BlwSps7hAdqcka3D+cUKbW7VoM5hhBsAwAWh1gFn5syZmjhxYrVtOnTooIiICGVnu55NU1ZWpmPHjp117ExeXp6GDh2qFi1aaP369fLx8am2fXx8vBYuXKji4mJZrRXHf1it1kqn4/xEBPrppt5tPF0GAAAV1DrghIaGKjQ09Kzt+vTpo5ycHKWnpys2NlaStGnTJjkcDsXHx1e5nM1mU2JioqxWqzZs2CA/v7PvEdi9e7eCg4MJMQAAQJIbz6Lq0qWLhg4dqsmTJ2v58uUqLS3VtGnTNGbMGOcZVAcPHtTgwYP14osvqnfv3rLZbBoyZIgKCwv10ksvuQwIDg0Nlbe3t95++21lZWXpiiuukJ+fn1JTU/XQQw9p1qxZ7toUAADQwLj1Ojhr1qzRtGnTNHjwYHl5eWnkyJFaunSpc35paakyMjJUWFgoSdq1a5fzDKtOnTq59LVv3z61a9dOPj4+WrZsmWbMmCHDMNSpUyc98cQTmjx5sjs3BQAANCBuDTgtW7as8qJ+ktSuXTuX07sHDhxY7enekjR06FCXC/wBAACciXtRAQAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAAAA0yHgAICkTNsJ5/evpR/QodwiD1YD4HwRcAA0elsysvWX9V86n6d8lamZr32urd9le7AqAOeDgAOgUTuUW6QV//1RhnFqmsOQDEN6btuPysw9UfXCAC5YBBwAjdqWjMOyVDHPImlzBntxgIaIgAOgUTucXyyjinnGb/MBNDwEHACNWmhza7V7cEKbW+uzHAB1hIADoFEb2Dm02j04gzqH1Wc5AOoIAQdAoxYZ2FS39e8gi0Xyssjl6239Oygi0M/TJQI4B008XQAAeNqAS8LUOTxAmzOydTi/WKHNrRrUOYxwAzRgBBwAkBQR6KeberfxdBkA6giHqAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOm4NeAcO3ZMY8eOVUBAgIKCgnTLLbcoPz+/2mUGDhwoi8Xi8rj99ttd2uzfv1/Dhw+Xv7+/wsLC9Oc//1llZWXu3BQAANCAuPVWDWPHjtWhQ4eUmpqq0tJSTZo0SVOmTNHatWurXW7y5MlasGCB87m/v7/ze7vdruHDhysiIkKffPKJDh06pPHjx8vHx0cPPfSQ27YFAAA0HG4LOHv27FFKSop27typuLg4SdJTTz2lq6++Wo899piioqKqXNbf318RERGVzvvggw/0zTff6MMPP1R4eLh69eqlhQsX6r777tMDDzwgX19ft2wPAABoONx2iCotLU1BQUHOcCNJCQkJ8vLy0vbt26tdds2aNQoJCVG3bt00Z84cFRYWuvTbvXt3hYeHO6clJibKZrPp66+/rrS/4uJi2Ww2lwcAADAvt+3ByczMVFhYmOvKmjRRy5YtlZmZWeVy//d//6e2bdsqKipKX3zxhe677z5lZGTojTfecPZ7eriR5HxeVb/JycmaP3/++WwOAABoQGodcGbPnq3FixdX22bPnj3nXNCUKVOc33fv3l2RkZEaPHiwfvjhB3Xs2PGc+pwzZ46SkpKcz202m6Kjo8+5RgAAcGGrdcCZOXOmJk6cWG2bDh06KCIiQtnZ2S7Ty8rKdOzYsSrH11QmPj5ekrR371517NhRERER2rFjh0ubrKwsSaqyX6vVKqvVWuN1AgCAhq3WASc0NFShoaFnbdenTx/l5OQoPT1dsbGxkqRNmzbJ4XA4Q0tN7N69W5IUGRnp7PfBBx9Udna28xBYamqqAgIC1LVr11puDQAAMCO3DTLu0qWLhg4dqsmTJ2vHjh36+OOPNW3aNI0ZM8Z5BtXBgwcVExPj3CPzww8/aOHChUpPT9dPP/2kDRs2aPz48erfv7969OghSRoyZIi6du2q//f//p8+//xzvf/++/rb3/6mqVOnspcGAABIcvOF/tasWaOYmBgNHjxYV199tfr166cVK1Y455eWliojI8N5lpSvr68+/PBDDRkyRDExMZo5c6ZGjhypt99+27mMt7e33nnnHXl7e6tPnz4aN26cxo8f73LdHAAA0LhZDMMwPF1EfbPZbAoMDFRubq4CAgI8XU6dOF5Qom8z8zxdBgAAigryU9tWzeq839p8fnMvKgAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDpNPF0A6oafj7fCA6wqcxgqtTtUZjdU5nCo1G7IMDxdHQAA9YuAYxJNfb3VIbR5pfPK7A6X4FPq+C0AnfZ96W9tytsSigAADRkBpxFo4u2lJt4n9/LU1OlhyE4oAgA0MAQcVMrH20s+3lJT1SwUGYbxW9g5PQw5VPpbACr97ZCZazAiEQEA3IOAgzphsVjk422pdSgqPW2s0JmH0socp4IQoQgAUBsEHHiMxWKRbxOLfGtxMl9NQlHpGYfS7A5CEQA0NgQcNCjnEoocjrOPITozNJGJAKBhc2vAOXbsmO666y69/fbb8vLy0siRI/Xkk0+qefPKz/b56aef1L59+0rnvfrqqxo1apSkkx9yZ3r55Zc1ZsyYuisepuHlZZHVy1vWWvy02x2nxgydGYocv42mLh9UXZ6FDMM47fvynoxK2jnnnPr+tGmuy1c+7/R1lvd9+jrPrO/UeozTWoiB4QBMy60BZ+zYsTp06JBSU1NVWlqqSZMmacqUKVq7dm2l7aOjo3Xo0CGXaStWrNCjjz6qYcOGuUxftWqVhg4d6nweFBRU5/Wj8fL2ssi7lqGooTIqCWxnBqHz678OOjmX9Z5j9SVlDuUUlup4YYkKiu11XBWA+uK2P9979uxRSkqKdu7cqbi4OEnSU089pauvvlqPPfaYoqKiKizj7e2tiIgIl2nr16/XjTfeWGGvT1BQUIW2AGqvfI+o647RintJGwtrE2+18PNRdEt/FZfZnWHHVlTGeC6gAXHbrRrS0tIUFBTkDDeSlJCQIC8vL23fvr1GfaSnp2v37t265ZZbKsybOnWqQkJC1Lt3b61cudL5H2dliouLZbPZXB4AcDbWJt4KD/BTTESA4toGq0tkC0UE+snqw11ugAud2/bgZGZmKiwszHVlTZqoZcuWyszMrFEfzz//vLp06aK+ffu6TF+wYIGuuuoq+fv764MPPtCdd96p/Px83X333ZX2k5ycrPnz55/bhgCATo7lCvL3VZC/r9qrmQpLynS8sFTHC0qUX1zGeCbgAlPrgDN79mwtXry42jZ79uw554LKFRUVae3atbr//vsrzDt92mWXXaaCggI9+uijVQacOXPmKCkpyfncZrMpOjr6vGsE0Hj5+zaRv28TtQ5qqlL7yXE7OYUlyikq5XpNwAWg1gFn5syZmjhxYrVtOnTooIiICGVnZ7tMLysr07Fjx2o0dubf//63CgsLNX78+LO2jY+P18KFC1VcXCyr1VphvtVqrXQ6ANQFH28vhbawKrSFVYZhKK+4TDkFJ8fuFJYwUBnwhFoHnNDQUIWGhp61XZ8+fZSTk6P09HTFxsZKkjZt2iSHw6H4+PizLv/888/r2muvrdG6du/ereDgYEIMAI+zWCwK8PNRgJ+P2rTy14nS0wcql3KNJaCeuG0MTpcuXTR06FBNnjxZy5cvV2lpqaZNm6YxY8Y4z6A6ePCgBg8erBdffFG9e/d2Lrt3715t27ZN7733XoV+3377bWVlZemKK66Qn5+fUlNT9dBDD2nWrFnu2hQAOGd+Pt6KCPRWRKCf7A5DuUUnw05OYalKyhyeLg8wLbde5WPNmjWaNm2aBg8e7LzQ39KlS53zS0tLlZGRocLCQpflVq5cqYsuukhDhgyp0KePj4+WLVumGTNmyDAMderUSU888YQmT57szk0BgPPm7WVRy2a+atnMV5KUX1x2ctxOYanyTpR5uDrAXCxGdedXm5TNZlNgYKByc3MVEBDg6XIA4OQFBotKfhusXMo1d9CgRQX5qW2rZnXeb20+vxvBdVoB4MLn28RLYS38FNbCT4ZhyFZUpuOFJTpeWKITpRzKAmqLgAMAFxiLxaJAfx8F+vuonZqpqMSunKISHS8ole1EKdfcAWqAgAMAF7imvt5q6ttUkYFNVWZ3/DZQuVS5RSUqKSPtAJUh4ABAA9LE20utmlvVqvnJa+6cHKjMzUGBMxFwAKCBslgsauHnU+HmoDmFpcotYqAyGjcCDgCYxMmbg568QajDYch24uShrOOFJSpmoDIaGQIOAJgQNwdFY0fAAYBGoKqbg+YVl8kwDBmG5DAkwzC4nQRMgYADAI3M6TcHrUp50HF+1ckQdDIIGTL029ff2pw5XeWBSaf6qXb50547atLWcfIre6JQFQIOAKACi8Uib4skWTxdSrUqC1fl4ej0cOUwJJ0W1M5pXedZZ/2v8xyXO9e1nrZYU1/vc+ujDhFwAAANlsVikcUieV3gQQz1z8vTBQAAANQ1Ag4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdtwWcBx98UH379pW/v7+CgoJqtIxhGJo7d64iIyPVtGlTJSQk6Pvvv3dpc+zYMY0dO1YBAQEKCgrSLbfcovz8fDdsAQAAaKjcFnBKSko0atQo3XHHHTVe5pFHHtHSpUu1fPlybd++Xc2aNVNiYqJOnDjhbDN27Fh9/fXXSk1N1TvvvKNt27ZpypQp7tgEAADQQFkMwzDcuYLVq1dr+vTpysnJqbadYRiKiorSzJkzNWvWLElSbm6uwsPDtXr1ao0ZM0Z79uxR165dtXPnTsXFxUmSUlJSdPXVV+uXX35RVFRUjWqy2WwKDAxUbm6uAgICzmv7AABA/ajN53eTeqrprPbt26fMzEwlJCQ4pwUGBio+Pl5paWkaM2aM0tLSFBQU5Aw3kpSQkCAvLy9t375d119/faV9FxcXq7i42Pk8NzdX0skXCgAANAzln9s12TdzwQSczMxMSVJ4eLjL9PDwcOe8zMxMhYWFucxv0qSJWrZs6WxTmeTkZM2fP7/C9Ojo6PMtGwAA1LO8vDwFBgZW26ZWAWf27NlavHhxtW327NmjmJiY2nTrdnPmzFFSUpLzucPh0LFjx9SqVStZLJY6XZfNZlN0dLQOHDjQKA5/sb3mxvaaG9trbmbcXsMwlJeXV6MhKbUKODNnztTEiROrbdOhQ4fadOkUEREhScrKylJkZKRzelZWlnr16uVsk52d7bJcWVmZjh075ly+MlarVVar1WVaTc/sOlcBAQGm+YGqCbbX3Nhec2N7zc1s23u2PTflahVwQkNDFRoaek4FnU379u0VERGhjRs3OgONzWbT9u3bnWdi9enTRzk5OUpPT1dsbKwkadOmTXI4HIqPj3dLXQAAoOFx22ni+/fv1+7du7V//37Z7Xbt3r1bu3fvdrlmTUxMjNavXy9Jslgsmj59uhYtWqQNGzboyy+/1Pjx4xUVFaURI0ZIkrp06aKhQ4dq8uTJ2rFjhz7++GNNmzZNY8aMqfEZVAAAwPzcNsh47ty5euGFF5zPL7vsMknS5s2bNXDgQElSRkaG84wmSbr33ntVUFCgKVOmKCcnR/369VNKSor8/PycbdasWaNp06Zp8ODB8vLy0siRI7V06VJ3bUatWa1WzZs3r8IhMbNie82N7TU3ttfcGtv2nsnt18EBAACob9yLCgAAmA4BBwAAmA4BBwAAmA4BBwAAmA4BBwAAmA4Bpw4tW7ZM7dq1k5+fn+Lj47Vjxw5Pl+Q227Zt0zXXXKOoqChZLBa9+eabni7JrZKTk3X55ZerRYsWCgsL04gRI5SRkeHpstzm2WefVY8ePZxXQO3Tp4/+85//eLqsevHwww87r8tlVg888IAsFovL40K7xU5dO3jwoMaNG6dWrVqpadOm6t69uz799FNPl+UW7dq1q/D+WiwWTZ061dOl1SsCTh155ZVXlJSUpHnz5mnXrl3q2bOnEhMTK9xawiwKCgrUs2dPLVu2zNOl1IutW7dq6tSp+t///qfU1FSVlpZqyJAhKigo8HRpbnHRRRfp4YcfVnp6uj799FNdddVVuu666/T11197ujS32rlzp5577jn16NHD06W43aWXXqpDhw45Hx999JGnS3Kb48eP6/e//718fHz0n//8R998840ef/xxBQcHe7o0t9i5c6fLe5uamipJGjVqlIcrq2cG6kTv3r2NqVOnOp/b7XYjKirKSE5O9mBV9UOSsX79ek+XUa+ys7MNScbWrVs9XUq9CQ4ONv75z396ugy3ycvLMy6++GIjNTXVGDBggHHPPfd4uiS3mTdvntGzZ09Pl1Fv7rvvPqNfv36eLsNj7rnnHqNjx46Gw+HwdCn1ij04daCkpETp6elKSEhwTvPy8lJCQoLS0tI8WBncpfwK3C1btvRwJe5nt9u1bt06FRQUqE+fPp4ux22mTp2q4cOHu/wem9n333+vqKgodejQQWPHjtX+/fs9XZLbbNiwQXFxcRo1apTCwsJ02WWX6R//+Ieny6oXJSUleumll3TzzTfLYrF4upx6RcCpA0eOHJHdbld4eLjL9PDwcGVmZnqoKriLw+HQ9OnT9fvf/17dunXzdDlu8+WXX6p58+ayWq26/fbbtX79enXt2tXTZbnFunXrtGvXLiUnJ3u6lHoRHx+v1atXKyUlRc8++6z27dunK6+8Unl5eZ4uzS1+/PFHPfvss7r44ov1/vvv64477tDdd9/tcjshs3rzzTeVk5OjiRMnerqUeue2e1EBZjV16lR99dVXph6zIEmdO3fW7t27lZubq3//+9+aMGGCtm7darqQc+DAAd1zzz1KTU11ue+dmQ0bNsz5fY8ePRQfH6+2bdvq1Vdf1S233OLBytzD4XAoLi5ODz30kKST90b86quvtHz5ck2YMMHD1bnX888/r2HDhjXKG1KzB6cOhISEyNvbW1lZWS7Ts7KyFBER4aGq4A7Tpk3TO++8o82bN+uiiy7ydDlu5evrq06dOik2NlbJycnq2bOnnnzySU+XVefS09OVnZ2t3/3ud2rSpImaNGmirVu3aunSpWrSpInsdrunS3S7oKAgXXLJJdq7d6+nS3GLyMjICsG8S5cupj4sJ0k///yzPvzwQ916662eLsUjCDh1wNfXV7Gxsdq4caNzmsPh0MaNG009ZqExMQxD06ZN0/r167Vp0ya1b9/e0yXVO4fDoeLiYk+XUecGDx6sL7/8Urt373Y+4uLiNHbsWO3evVve3t6eLtHt8vPz9cMPPygyMtLTpbjF73//+wqXdfjuu+/Utm1bD1VUP1atWqWwsDANHz7c06V4BIeo6khSUpImTJiguLg49e7dW0uWLFFBQYEmTZrk6dLcIj8/3+W/vX379mn37t1q2bKl2rRp48HK3GPq1Klau3at3nrrLbVo0cI5tiowMFBNmzb1cHV1b86cORo2bJjatGmjvLw8rV27Vlu2bNH777/v6dLqXIsWLSqMpWrWrJlatWpl2jFWs2bN0jXXXKO2bdvq119/1bx58+Tt7a2bbrrJ06W5xYwZM9S3b1899NBDuvHGG7Vjxw6tWLFCK1as8HRpbuNwOLRq1SpNmDBBTZo00o96T5/GZSZPPfWU0aZNG8PX19fo3bu38b///c/TJbnN5s2bDUkVHhMmTPB0aW5R2bZKMlatWuXp0tzi5ptvNtq2bWv4+voaoaGhxuDBg40PPvjA02XVG7OfJj569GgjMjLS8PX1NVq3bm2MHj3a2Lt3r6fLcqu3337b6Natm2G1Wo2YmBhjxYoVni7Jrd5//31DkpGRkeHpUjzGYhiG4ZloBQAA4B6MwQEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKZDwAEAAKbz/wFBi4Wdu/c8IAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "44\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "45\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "46\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "47\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "48\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "49\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "51\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "52\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "53\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "54\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGzCAYAAAAi6m1wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABHGklEQVR4nO3deXxU1f3/8fdkmyRAFiAL0bAriGw2SMQFUFICUisWEfzij0UEF1AhUJW2giwa9y9VUbQV0G+hWKq4NxJZW6WAIK4YRVEQSQIiGbIwSWbO74+QgSELCWQyyc3r+XjMI5l7zz3zuZOEeXPuuffajDFGAAAAFhLg7wIAAADqGgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHQLU2bNggm82mDRs21Gm/NptNDzzwQJ32aVW++hnUlNvtVvfu3fXggw/65fUrk5GRoebNm+vgwYP+LgUNFAEHTcazzz4rm82m5OTks+7r3Xff5cO5Bhri+/TAAw/IZrNV+li8eLFfa3v22We1bNkyv9ZQmb///e/at2+fpk6dWun6mv5t5eTkaObMmeratavCw8PVrFkzJSUlacGCBTpy5Iin3cCBA6v8GX311VeSpCFDhqhz585KT0+vs/2EtQT5uwCgvixfvlzt27fX1q1btXv3bnXu3PmM+3r33Xe1aNGiBvfh3dBU9z4VFRUpKMh//wQ999xzat68udeyugi/Z+PZZ59V69atNX78eK/l/fv3V1FRkUJCQvxS12OPPabRo0crMjKy0vU1+dvatm2brr76auXn5+umm25SUlKSJOmjjz7Sww8/rE2bNmnNmjWe9ueee26l4SUhIcHz/a233qqZM2dq7ty5atGixdnuJiyGgIMmYc+ePfrwww/12muv6dZbb9Xy5cs1Z84cf5flU4WFhQoPD6+wvLS0VG63228fluVCQ0P9+vrXX3+9Wrdu7dcaaiogIMBv79fHH3+sTz75RE888USl62vyt3XkyBFdd911CgwM1Mcff6yuXbt6rX/wwQf1l7/8xWtZZGSkbrrppmprGzFihO68806tWrVKN9988xnsHayMQ1RoEpYvX67o6GgNGzZM119/vZYvX16hTVXzHL7//nvZbDbPoYPx48dr0aJFkuQ1dF6uoKBAM2bMUGJioux2u7p06aLHH39cxpgKr/m3v/1Nffv2VXh4uKKjo9W/f3+v/8VKZf+rv/DCC2W325WQkKApU6Z4DedLZUP63bt31/bt29W/f3+Fh4frD3/4g6f2xx9/XAsXLlSnTp1kt9v15ZdfSpK++uorXX/99WrZsqVCQ0PVp08fvfnmm6d9P//9739r5MiRatu2rex2uxITEzV9+nQVFRV52pzufapsDs7HH3+soUOHKiIiQs2bN9egQYP03//+16vNsmXLZLPZ9MEHHygtLU0xMTFq1qyZrrvuujqZj3Hqz/tkp9Zcfrhr9+7dGj9+vKKiohQZGakJEyaosLCwwvbV/bzbt2+vL774Qhs3bvS8VwMHDpRU9e/mqlWrlJSUpLCwMLVu3Vo33XST9u/f79Vm/Pjxat68ufbv36/hw4erefPmiomJ0cyZM+VyuU77frz++usKCQlR//79K11fk7+t559/Xvv379eTTz5ZIdxIUlxcnP70pz+dtpZTxcbGqmfPnnrjjTdqvS2sjxEcNAnLly/X7373O4WEhOjGG2/Uc889p23btuniiy+udV+33nqrfvrpJ2VmZur//u//vNYZY/Tb3/5W69ev18SJE9W7d2+99957+v3vf6/9+/frf//3fz1t586dqwceeECXXnqp5s2bp5CQEG3ZskXr1q3T4MGDJZV9gM6dO1cpKSm6/fbblZWV5an9gw8+UHBwsKe/n3/+WUOHDtXo0aN10003KS4uzrNu6dKlOnbsmCZPniy73a6WLVvqiy++0GWXXaZzzjlH9913n5o1a6Z//OMfGj58uF599VVdd911Vb4Hq1atUmFhoW6//Xa1atVKW7du1dNPP60ff/xRq1atOu37VJkvvvhCV1xxhSIiInTPPfcoODhYzz//vAYOHKiNGzdWOHx05513Kjo6WnPmzNH333+vhQsXaurUqXrllVdO+1qSdPjwYa/ngYGBio6OrtG2p7rhhhvUoUMHpaena8eOHfrrX/+q2NhYPfLII542p/t5L1y4UHfeeaeaN2+uP/7xj5Lk9TM81bJlyzRhwgRdfPHFSk9PV05Ojv785z/rgw8+0Mcff6yoqChPW5fLpdTUVCUnJ+vxxx/X+++/ryeeeEKdOnXS7bffXu2+ffjhh+revbvX79rJavK39eabbyosLEzXX399Td5OT82HDh3yWhYaGlrhsGJSUpJef/31GveLJsQAFvfRRx8ZSSYzM9MYY4zb7Tbnnnuuufvuu73arV+/3kgy69ev91q+Z88eI8ksXbrUs2zKlCmmsj+f119/3UgyCxYs8Fp+/fXXG5vNZnbv3m2MMeabb74xAQEB5rrrrjMul8urrdvtNsYYk5uba0JCQszgwYO92jzzzDNGklmyZIln2YABA4wks3jx4kprj4iIMLm5uV7rBg0aZHr06GGOHTvm9dqXXnqpOe+886p9XwoLCyvse3p6urHZbOaHH3447ftkjDGSzJw5czzPhw8fbkJCQsy3337rWfbTTz+ZFi1amP79+3uWLV261EgyKSkpnvfKGGOmT59uAgMDzZEjRyp9vXJz5swxkio82rVrZ4yp/OddVc3lfd18881e7a677jrTqlUrz/Oa/LyNMebCCy80AwYMqPC6p/4MiouLTWxsrOnevbspKirytHv77beNJDN79mzPsnHjxhlJZt68eV59XnTRRSYpKanS9+hk5557rhkxYkSl62r6txUdHW169ep12tcqV/77fOpj3LhxFdo+9NBDRpLJycmpcf9oGjhEBctbvny54uLidOWVV0oqO8wwatQorVy5skZD9LXx7rvvKjAwUHfddZfX8hkzZsgYo3/961+Syob93W63Zs+erYAA7z/D8sM477//voqLizVt2jSvNpMmTVJERITeeecdr+3sdrsmTJhQaV0jRoxQTEyM5/nhw4e1bt063XDDDTp69KgOHTqkQ4cO6eeff1Zqaqq++eabCoc6ThYWFub5vqCgQIcOHdKll14qY4w+/vjj6t6iSrlcLq1Zs0bDhw9Xx44dPcvbtGmj//mf/9F//vMfORwOr20mT57sdcjriiuukMvl0g8//FCj13z11VeVmZnpeVR2aKWmbrvtNq/nV1xxhX7++WdPzTX5edfGRx99pNzcXN1xxx1ec3OGDRumrl27VvjdqKrG77777rSv9fPPP1c5slXTvy2Hw1HrScDt27f3+vlkZmbqnnvuqdCuvLZTR3sADlHB0lwul1auXKkrr7xSe/bs8SxPTk7WE088obVr13oOB9WFH374QQkJCRX+Mb/gggs86yXp22+/VUBAgLp161ZtX5LUpUsXr+UhISHq2LFjhQ/yc845p8qJwx06dPB6vnv3bhljdP/99+v++++vdJvc3Fydc845la7bu3evZs+erTfffFO//PKL17q8vLwq96kqBw8eVGFhYYV9lcreO7fbrX379unCCy/0LG/btq1Xu/IPulPrqUr//v3rbJJxdbVERETU6OddG1X9bkhS165d9Z///MdrWWhoqFfALa+xpu+VqWT+WG3+tiIiInT06NEavVa5Zs2aKSUlpca1nUlQhLURcGBp69at04EDB7Ry5UqtXLmywvrly5d7/hGu6h/Iuh7l8ZWTR1VOt87tdkuSZs6cqdTU1Eq3qeo0epfLpV//+tc6fPiw7r33XnXt2lXNmjXT/v37NX78eE/fvhYYGFjp8so+jGvjTH4PfFVLXamqvppo1apVpUGoNn9bXbt21c6dO1VcXFznZ++V19ZYzohD/SHgwNKWL1+u2NhYz9k8J3vttde0evVqLV68WGFhYZ7/dZ96hlJlhzyq+hBs166d3n//fR09etRrFKf84mTt2rWTJHXq1Elut1tffvmlevfuXWVfkpSVleV12Ka4uFh79uyp0f9uq1LeX3BwcK37+eyzz/T111/rpZde0tixYz3LMzMzK7St6f+qY2JiFB4erqysrArrvvrqKwUEBCgxMbFWdZ6p2vwe1FRNft5Szd+vk383rrrqKq91WVlZnvV1oWvXrl4jNOVq87d1zTXXaPPmzXr11Vd144031lltUtlp6q1bt64wQgUwBweWVVRUpNdee02/+c1vdP3111d4TJ06VUePHvWcFt2uXTsFBgZq06ZNXv08++yzFfpu1qyZpIofgldffbVcLpeeeeYZr+X/+7//K5vNpqFDh0qShg8froCAAM2bN6/CiEf5//pTUlIUEhKip556ymsk4MUXX1ReXp6GDRt2Bu9KmdjYWA0cOFDPP/+8Dhw4UGF9dadbl48GnFyTMUZ//vOfK7St6n2qrM/BgwfrjTfe0Pfff+9ZnpOToxUrVujyyy9XREREtX3UlYiICLVu3bpGvwc1VZOft1T2fp3uvZKkPn36KDY2VosXL5bT6fQs/9e//qVdu3ad1e/Gqfr166fPP//c63Vq+7d12223qU2bNpoxY4a+/vrrCq+Rm5urBQsWnFF927dvV79+/c5s52BpjODAst58800dPXpUv/3tbytdf8kllygmJkbLly/XqFGjFBkZqZEjR+rpp5+WzWZTp06d9Pbbbys3N7fCtuVXYb3rrruUmpqqwMBAjR49Wtdcc42uvPJK/fGPf9T333+vXr16ac2aNXrjjTc0bdo0derUSVLZ4Z8//vGPmj9/vq644gr97ne/k91u17Zt25SQkKD09HTFxMRo1qxZmjt3roYMGaLf/va3ysrK0rPPPquLL774tBdBO51Fixbp8ssvV48ePTRp0iR17NhROTk52rx5s3788Ud98sknlW7XtWtXderUSTNnztT+/fsVERGhV199tdLDGFW9T5VZsGCBMjMzdfnll+uOO+5QUFCQnn/+eTmdTj366KNnta+1dcstt+jhhx/WLbfcoj59+mjTpk2VfjDXVE1+3lLZ+/Xcc89pwYIF6ty5s2JjYyuM0EhlI2+PPPKIJkyYoAEDBujGG2/0nCbevn17TZ8+/YxrPdW1116r+fPna+PGjZ5DTrX924qOjtbq1at19dVXq3fv3l5XMt6xY4f+/ve/n1FIyc3N1aeffqopU6ac+Q7Cuvxz8hbge9dcc40JDQ01BQUFVbYZP368CQ4ONocOHTLGGHPw4EEzYsQIEx4ebqKjo82tt95qPv/88wqnDZeWlpo777zTxMTEGJvN5nUq9NGjR8306dNNQkKCCQ4ONuedd5557LHHvE4HLrdkyRJz0UUXGbvdbqKjo82AAQM8p9yWe+aZZ0zXrl1NcHCwiYuLM7fffrv55ZdfvNoMGDDAXHjhhRX6Lz/l+bHHHqt0/7/99lszduxYEx8fb4KDg80555xjfvOb35h//vOfnjaVnSb+5ZdfmpSUFNO8eXPTunVrM2nSJPPJJ5/U6n3SKadcG2PMjh07TGpqqmnevLkJDw83V155pfnwww+92pSfJr5t2zav5VWd5n+q8lO7Dx48WGWbwsJCM3HiRBMZGWlatGhhbrjhBpObm1vlaeKn9lVe4549e7yWn+7nnZ2dbYYNG2ZatGhhJHlOGa9q31555RVPfy1btjRjxowxP/74o1ebcePGmWbNmlX5PtREz549zcSJEz3Pz+Rvy5iy0/6nT59uzj//fBMaGmrCw8NNUlKSefDBB01eXp6nXVW/z6d67rnnTHh4uHE4HDXaDzQtNmMayCw4AECD9H//93+aMmWK9u7d63UBQX+76KKLNHDgQK8LaALlmIMDAKjWmDFj1LZt20onFPtLRkaGvvnmG82aNcvfpaCBYgQHAABYDiM4AADAcnwacDZt2qRrrrlGCQkJstlsNboh2oYNG/SrX/1KdrtdnTt3rvSOvosWLVL79u0VGhqq5ORkbd26te6LBwAAjZZPA05BQYF69epV4+O2e/bs0bBhw3TllVdq586dmjZtmm655Ra99957njavvPKK0tLSNGfOHO3YsUO9evVSampqpafyAgCApqne5uDYbDatXr1aw4cPr7LNvffeq3feeUeff/65Z9no0aN15MgRZWRkSCq7z8nFF1/suZCa2+1WYmKi7rzzTt13330+3QcAANA4NKgL/W3evLnCZeNTU1M1bdo0SWWXqN++fbvXrPmAgAClpKRo8+bNVfbrdDq9rsLpdrt1+PBhtWrVihu0AQDQSBhjdPToUSUkJCggoPqDUA0q4GRnZysuLs5rWVxcnBwOh4qKivTLL7/I5XJV2qb8Xj+VSU9P19y5c31SMwAAqF/79u3TueeeW22bBhVwfGXWrFlKS0vzPM/Ly1Pbtm21b9++Orm/zf9mfq1lH34vl7vi0b7AAJvGX9pe0399/lm/DgAATZnD4VBiYqLXzYyr0qACTnx8vHJycryW5eTkKCIiQmFhYQoMDFRgYGClbeLj46vs1263y263V1geERFRJwFn7IAL9NJHOQqoZDaTzSaNG3CBIiKanfXrAAAA1Wh6SYO6Dk6/fv20du1ar2WZmZmem7CFhIQoKSnJq43b7dbatWv9ejfZDq2b6ZERPRVw0vsdaLMpwCY9MqKn2rcm3AAAUJ98OoKTn5+v3bt3e57v2bNHO3fuVMuWLdW2bVvNmjVL+/fv18svvyxJuu222/TMM8/onnvu0c0336x169bpH//4h9555x1PH2lpaRo3bpz69Omjvn37auHChSooKNCECRN8uSunNbJPorqfE6Ghf/6PJGnC5e11U3I7wg0AAH7g04Dz0Ucf6corr/Q8L58HM27cOC1btkwHDhzQ3r17Pes7dOigd955R9OnT9ef//xnnXvuufrrX/+q1NRUT5tRo0bp4MGDmj17trKzs9W7d29lZGRUmHjsD+1anQgzab8+X+EhDeoIIAAATUaTvBeVw+FQZGSk8vLy6mQOTrnC4lJ1m112UcIv56UScAAAqEO1+fxuUHNwAAAA6gIBBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA6X2gUAoIlyu42MJLcxchsjY+T11W0kU8lzt5GMyr663WXrPc+NUWRYsFo3t/t13wg4AADUk8oCxYnwUHWgOLFN5YHCEzpMDfo+XofbhzdqCgqwEXAAAKgPxhg5S911FijKtqk+UOikUQ5fBgpURMABAFhOicutwmKXCotLy746y74nZDQdBBwAQKNljFFRiUsFTpeKil0qOB5oikvd/i4NfkbAAQA0CiUutwqdJ0JMYXGpiopdjMqgUgQcAECD4naXjcqUh5gCp0tFJaUqLiXJoOYIOAAAv3GWlh9acqnIE2ZcMmQZnCUCDgDA59xuo8KS45N+jx9mKip2qcRFkoFvEHAAAHXqWMmJCb/lozPHGJVBPSPgAADOiMttPBN9C4pdKnCWqqjEpVJGZdAAEHAAAKd17Pik3/IQU+As9Vw0D2iICDgAAA+X25w4tOQsPx3bJRfnYqORIeAAQBNUXOpWscstp+d07LI5M84SLpAHayDgAIDFlIeX4tKTHi6XjpWULS8pdXNxPFgeAQcAGpFTw4uz1HX8K+EFOBkBBwAaAGOMSlzGc9jIO8ScCDVM6gVqhoADAD5mjPE+ZER4AXyOgAMAZ4HwAjRMBBwAqMLpwouz1K0SF+EFaIgIOAAsxe02chsjlzEypuy6Lm5j5DbVrHPreBsjl9sQXgALIOAAqBdud1mwODlQuIyROel7r3Xu4yHk+HJjjFxVrCsLLjrezt97CqAhIOAAqJQxxnOTxPIA4fKEiePP3WXBw+01UlL5OgCoTwQcAB6FxaXKKyqRo6hUjmMl3DQRQKNFwAGasGMlruOBpkSOYyUqLiXQALAGAg7QhBwrcclxrCzQ5BWVqriU+w4BsKaA+niRRYsWqX379goNDVVycrK2bt1aZduBAwfKZrNVeAwbNszTZvz48RXWDxkypD52BWhUikvdOpTv1LcH8/Xx3l/08d4j+ja3QAePFhNuAFiaz0dwXnnlFaWlpWnx4sVKTk7WwoULlZqaqqysLMXGxlZo/9prr6m4uNjz/Oeff1avXr00cuRIr3ZDhgzR0qVLPc/tdrvvdgJoJEpc7uOHm8rm0hQVu/xdEgD4hc8DzpNPPqlJkyZpwoQJkqTFixfrnXfe0ZIlS3TfffdVaN+yZUuv5ytXrlR4eHiFgGO32xUfH++7woFGwOU2nvkzeUUlKnASaABA8nHAKS4u1vbt2zVr1izPsoCAAKWkpGjz5s016uPFF1/U6NGj1axZM6/lGzZsUGxsrKKjo3XVVVdpwYIFatWqVaV9OJ1OOZ1Oz3OHw3EGewP4n9ttdPT46IzjWInynaVc9wUAKuHTgHPo0CG5XC7FxcV5LY+Li9NXX3112u23bt2qzz//XC+++KLX8iFDhuh3v/udOnTooG+//VZ/+MMfNHToUG3evFmBgYEV+klPT9fcuXPPbmcAP3C7jY46Sz2jNPnHSsUlZQDg9Br0WVQvvviievToob59+3otHz16tOf7Hj16qGfPnurUqZM2bNigQYMGVehn1qxZSktL8zx3OBxKTEz0XeHAGTLGKN9ZWjaHprBshIaL5AFA7fk04LRu3VqBgYHKycnxWp6Tk3Pa+TMFBQVauXKl5s2bd9rX6dixo1q3bq3du3dXGnDsdjuTkNFgFThPHHI6eqyUi+sBQB3w6WniISEhSkpK0tq1az3L3G631q5dq379+lW77apVq+R0OnXTTTed9nV+/PFH/fzzz2rTps1Z1wz4WlGxS9l5x/R1zlF99P1hffpjnn74uVC/FHDlYACoKz4/RJWWlqZx48apT58+6tu3rxYuXKiCggLPWVVjx47VOeeco/T0dK/tXnzxRQ0fPrzCxOH8/HzNnTtXI0aMUHx8vL799lvdc8896ty5s1JTU329O0CtHStxHb+wHlcLBoD64vOAM2rUKB08eFCzZ89Wdna2evfurYyMDM/E47179yogwHsgKSsrS//5z3+0Zs2aCv0FBgbq008/1UsvvaQjR44oISFBgwcP1vz58zkMhQbBWeqSo+jEYSdnCRfUA4D6ZjOm6Z1k6nA4FBkZqby8PEVERNRZv4XFpeo2+z1J0pfzUhUe0qDncKOOlLjcnvs55RWV6BiBBkATlxAVqnatmp2+YS3V5vObT2CglkpdbjmOlXoCTSFXCwaABoeAg0bBGCO3OemrjIyR3ObEV7eR5PneyOjEek9blV1bxhzvw21ObnOib7e7bLl0ou/y9SUuNxfXA4AGjoADD3NKWKhNiChbVvsQUeVrlG/nLuuPQAEAqA0CjkUUFpcqO++YZ6ShPHgQIgAATREBxyKcJW7lOJynbwgAQBPg0wv9AQAA+AMBBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWA4BBwAAWE69BJxFixapffv2Cg0NVXJysrZu3Vpl22XLlslms3k9QkNDvdoYYzR79my1adNGYWFhSklJ0TfffOPr3QAAAI2EzwPOK6+8orS0NM2ZM0c7duxQr169lJqaqtzc3Cq3iYiI0IEDBzyPH374wWv9o48+qqeeekqLFy/Wli1b1KxZM6WmpurYsWO+3h0AANAI+DzgPPnkk5o0aZImTJigbt26afHixQoPD9eSJUuq3MZmsyk+Pt7ziIuL86wzxmjhwoX605/+pGuvvVY9e/bUyy+/rJ9++kmvv/66r3cHAAA0Aj4NOMXFxdq+fbtSUlJOvGBAgFJSUrR58+Yqt8vPz1e7du2UmJioa6+9Vl988YVn3Z49e5Sdne3VZ2RkpJKTk6vs0+l0yuFweD0AAIB1+TTgHDp0SC6Xy2sERpLi4uKUnZ1d6TZdunTRkiVL9MYbb+hvf/ub3G63Lr30Uv3444+S5NmuNn2mp6crMjLS80hMTDzbXQMAAA1YgzuLql+/fho7dqx69+6tAQMG6LXXXlNMTIyef/75M+5z1qxZysvL8zz27dtXhxUDAICGxqcBp3Xr1goMDFROTo7X8pycHMXHx9eoj+DgYF100UXavXu3JHm2q02fdrtdERERXg8AAGBdPg04ISEhSkpK0tq1az3L3G631q5dq379+tWoD5fLpc8++0xt2rSRJHXo0EHx8fFefTocDm3ZsqXGfQIAAGsL8vULpKWlady4cerTp4/69u2rhQsXqqCgQBMmTJAkjR07Vuecc47S09MlSfPmzdMll1yizp0768iRI3rsscf0ww8/6JZbbpFUdobVtGnTtGDBAp133nnq0KGD7r//fiUkJGj48OG+3h0AANAI+DzgjBo1SgcPHtTs2bOVnZ2t3r17KyMjwzNJeO/evQoIODGQ9Msvv2jSpEnKzs5WdHS0kpKS9OGHH6pbt26eNvfcc48KCgo0efJkHTlyRJdffrkyMjIqXBAQAAA0TTZjjPF3EfXN4XAoMjJSeXl5dTofp7C4VN1mvydJ+nJeqsJDfJ4fPX4pKNZX2Ufr7fUAAKhKQlSo2rVqVuf91ubzu8GdRQUAAHC2CDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMBygvxdANBYHMgr0oasgzqY71RMc7sGdolRm8gwf5cFAKgEAQeogQ1ZuXrh39/JJslIskl669OfdGv/jhpwfqyfqwMAnIpDVMBpHMgr0gv//k7GSG4jr6/Pb/pO2XnH/F0iAOAUBBzgNDZkHZStinU2SeuzcuuzHABADRBwgNM4mO+UqWKdOb4eANCwEHCA04hpbq92BCemub0+ywEA1AABBziNgV1iqh3BubILk4wBoKEh4ACn0SYyTLf27yjbScM4ATbJZpNu7d9R8ZGh/isOAFApThMHamDA+bFq36qZ7nvtM0nSkO7x+vUF8YQbAGigCDhADcVFnAgzI5MSFRoc6MdqAADV4RAVAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwnHoJOIsWLVL79u0VGhqq5ORkbd26tcq2f/nLX3TFFVcoOjpa0dHRSklJqdB+/PjxstlsXo8hQ4b4ejcAAEAj4fOA88orrygtLU1z5szRjh071KtXL6Wmpio3N7fS9hs2bNCNN96o9evXa/PmzUpMTNTgwYO1f/9+r3ZDhgzRgQMHPI+///3vvt4VAADQSPg84Dz55JOaNGmSJkyYoG7dumnx4sUKDw/XkiVLKm2/fPly3XHHHerdu7e6du2qv/71r3K73Vq7dq1XO7vdrvj4eM8jOjra17sCAAAaCZ8GnOLiYm3fvl0pKSknXjAgQCkpKdq8eXON+igsLFRJSYlatmzptXzDhg2KjY1Vly5ddPvtt+vnn3+usg+n0ymHw+H1AAAA1uXTgHPo0CG5XC7FxcV5LY+Li1N2dnaN+rj33nuVkJDgFZKGDBmil19+WWvXrtUjjzyijRs3aujQoXK5XJX2kZ6ersjISM8jMTHxzHcKAAA0eEH+LqA6Dz/8sFauXKkNGzYoNDTUs3z06NGe73v06KGePXuqU6dO2rBhgwYNGlShn1mzZiktLc3z3OFwEHIAALAwn47gtG7dWoGBgcrJyfFanpOTo/j4+Gq3ffzxx/Xwww9rzZo16tmzZ7VtO3bsqNatW2v37t2Vrrfb7YqIiPB6AAAA6/JpwAkJCVFSUpLXBOHyCcP9+vWrcrtHH31U8+fPV0ZGhvr06XPa1/nxxx/1888/q02bNnVSNwAAaNx8fhZVWlqa/vKXv+ill17Srl27dPvtt6ugoEATJkyQJI0dO1azZs3ytH/kkUd0//33a8mSJWrfvr2ys7OVnZ2t/Px8SVJ+fr5+//vf67///a++//57rV27Vtdee606d+6s1NRUX+8OAABoBHw+B2fUqFE6ePCgZs+erezsbPXu3VsZGRmeicd79+5VQMCJnPXcc8+puLhY119/vVc/c+bM0QMPPKDAwEB9+umneumll3TkyBElJCRo8ODBmj9/vux2u693BwAANAL1Msl46tSpmjp1aqXrNmzY4PX8+++/r7avsLAwvffee3VUGQAAsCLuRQUAACyHgAMAACyHgAMAACyHgAMAACyHgAMAACyHgAMAACyHgAMAACyHgAMAACyHgAMAACyHgAMAACyHgAMAACynXu5FBWs6kFekDVkHdTDfqZjmdg3sEqM2kWH+LgsAAAIOzsyGrFy98O/vZJNkJNkkvfXpT7q1f0cNOD/Wz9UBAJo6DlGh1g7kFemFf38nYyS3kdfX5zd9p+y8Y/4uEQDQxBFwUGsbsg7KVsU6m6T1Wbn1WQ4AABUQcFBrB/OdMlWsM8fXAwDgTwQc1FpMc3u1Izgxze31WQ4AABUQcFBrA7vEVDuCc2UXJhkDAPyLgINaaxMZplv7d5TtpGGcAJtks0m39u+o+MhQ/xUHAIA4TRxnaMD5sWrfqpnue+0zSdKQ7vH69QXxhBsAQINAwMEZi4s4EWZGJiUqNDjQj9UAAHACh6gAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDlEHAAAIDl1EvAWbRokdq3b6/Q0FAlJydr69at1bZftWqVunbtqtDQUPXo0UPvvvuu13pjjGbPnq02bdooLCxMKSkp+uabb3y5CwAAoBEJ8vULvPLKK0pLS9PixYuVnJyshQsXKjU1VVlZWYqNja3Q/sMPP9SNN96o9PR0/eY3v9GKFSs0fPhw7dixQ927d5ckPfroo3rqqaf00ksvqUOHDrr//vuVmpqqL7/8UqGhoTWurbC4VEHFpXW2r4Un9VVYh/3WRFGxS8dKXPX6ms6TXs9Zz6/tD01tfwHgTBUVu3zyOVibPm3GGFPnFZwkOTlZF198sZ555hlJktvtVmJiou68807dd999FdqPGjVKBQUFevvttz3LLrnkEvXu3VuLFy+WMUYJCQmaMWOGZs6cKUnKy8tTXFycli1bptGjR1fo0+l0yul0ep47HA4lJiYqcdo/FGAPr+tdBgAAPuB2FmrfwhuUl5eniIiIatv69BBVcXGxtm/frpSUlBMvGBCglJQUbd68udJtNm/e7NVeklJTUz3t9+zZo+zsbK82kZGRSk5OrrLP9PR0RUZGeh6JiYlnu2sAAKAB8+khqkOHDsnlcikuLs5reVxcnL766qtKt8nOzq60fXZ2tmd9+bKq2pxq1qxZSktL8zwvH8HZ+sdBp02AjcWRghJl5Rz1dxmwEGeJS7ct3yFJWjzmV7IHB/q5It9if9lfK/H3/raJDFXbVnV/hMThcKjNwpq19fkcnIbAbrfLbrdXWB4eEqTwEGu8Bc4St0It/gcL/7EHBzap3y/219rYX98LCwn0yedraS369OkhqtatWyswMFA5OTley3NychQfH1/pNvHx8dW2L/9amz4BAEDT4tOAExISoqSkJK1du9azzO12a+3aterXr1+l2/Tr18+rvSRlZmZ62nfo0EHx8fFebRwOh7Zs2VJlnwAAoGnx+fGZtLQ0jRs3Tn369FHfvn21cOFCFRQUaMKECZKksWPH6pxzzlF6erok6e6779aAAQP0xBNPaNiwYVq5cqU++ugjvfDCC5Ikm82madOmacGCBTrvvPM8p4knJCRo+PDhvt4dAADQCPg84IwaNUoHDx7U7NmzlZ2drd69eysjI8MzSXjv3r0KCDgxkHTppZdqxYoV+tOf/qQ//OEPOu+88/T66697roEjSffcc48KCgo0efJkHTlyRJdffrkyMjJqdQ0cAABgXfUyw3bq1KmaOnVqpes2bNhQYdnIkSM1cuTIKvuz2WyaN2+e5s2bV1clAgAAC+FeVAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAWEy245jn+1Xb9+lAXpEfq/EPAg4AABayIStXf1j9med5xufZmrHqE238OtePVdU/Ag4AABZxIK9IL/z7OxlzYpnbSMZIz2/6Ttl5x6re2GIIOAAAWMSGrIOyVbHOJml9VtMZxSHgAABgEQfznTJVrDPH1zcVBBwAlWKSItD4xDS3VzuCE9PcXp/l+BUBB0AFTFIEGqeBXWKqHcG5sktsfZbjVwQcAF6YpAg0Xm0iw3Rr/46y2aQAm7y+3tq/o+IjQ/1dYr0J8ncBABqW8kmKlf0vsHyS4o1929ZzVcDZOfWQa8oFcWoTGebHinxnwPmx6hIXofVZuTqY71RMc7uu7BLbpMKNRMABcAomKcJqNmTl6oV/f+d5nvF5tv71ebZu7d9RA8635iGb+MjQJv8fEQ5RAfDCJEVYCYdcmy4CDgAvTFKElXBdmKaLgAPAC5MUYSUccm26mIMDoAImKcIqyg+5VjVpnkOu1kXAAVApJinCCgZ2idFbn/5U6ToOuVobh6gAAJbFIdemixEcAIClcci1aSLgAAAsj0OuTQ+HqAAAgOUQcAAAgOUQcAAAgOUQcAAAgOUQcAAAgOUQcAAAgOUQcABAUrbjxF2lV23fpwN5RX6sBsDZ8mnAOXz4sMaMGaOIiAhFRUVp4sSJys/Pr7b9nXfeqS5duigsLExt27bVXXfdpby8PK92NputwmPlypW+3BUAFrYhK1d/WP2Z53nG59maseoTbfyaO00DjZVPL/Q3ZswYHThwQJmZmSopKdGECRM0efJkrVixotL2P/30k3766Sc9/vjj6tatm3744Qfddttt+umnn/TPf/7Tq+3SpUs1ZMgQz/OoqChf7goAizqQV6QX/v2dzEl3Y3Qf//75Td+pS1wEV7wFGiGfBZxdu3YpIyND27ZtU58+fSRJTz/9tK6++mo9/vjjSkhIqLBN9+7d9eqrr3qed+rUSQ8++KBuuukmlZaWKijoRLlRUVGKj4/3VfkAmogNWQervdv0+qxcroALNEI+O0S1efNmRUVFecKNJKWkpCggIEBbtmypcT95eXmKiIjwCjeSNGXKFLVu3Vp9+/bVkiVLZExl/zyVcTqdcjgcXg8AkKSD+c5Kw41UFnoO5jvrsxwAdcRnIzjZ2dmKjfW+DX1QUJBatmyp7OzsGvVx6NAhzZ8/X5MnT/ZaPm/ePF111VUKDw/XmjVrdMcddyg/P1933XVXpf2kp6dr7ty5Z7YjACwtprm92hGcmOb2eq4IQF2o9QjOfffdV+kk35MfX3311VkX5nA4NGzYMHXr1k0PPPCA17r7779fl112mS666CLde++9uueee/TYY49V2desWbOUl5fneezbt++s6wNgDQO7xFQ7gnNll9gq1gJoyGo9gjNjxgyNHz++2jYdO3ZUfHy8cnO9z0AoLS3V4cOHTzt35ujRoxoyZIhatGih1atXKzg4uNr2ycnJmj9/vpxOp+z2iv/bstvtlS4HgDaRYbq1f0c9v+k7z0hO+ddb+3dkgjHQSNU64MTExCgmJua07fr166cjR45o+/btSkpKkiStW7dObrdbycnJVW7ncDiUmpoqu92uN998U6Ghp//HZefOnYqOjibEADgjA86PVZe4CK3PytXBfKdimtt1ZZdYwg3QiPlsDs4FF1ygIUOGaNKkSVq8eLFKSko0depUjR492nMG1f79+zVo0CC9/PLL6tu3rxwOhwYPHqzCwkL97W9/85oQHBMTo8DAQL311lvKycnRJZdcotDQUGVmZuqhhx7SzJkzfbUrAJqA+MhQzpYCLMSn18FZvny5pk6dqkGDBikgIEAjRozQU0895VlfUlKirKwsFRYWSpJ27NjhOcOqc+fOXn3t2bNH7du3V3BwsBYtWqTp06fLGKPOnTvrySef1KRJk3y5KwAAoBHxacBp2bJllRf1k6T27dt7nd49cODAak/3lqQhQ4Z4XeAPAADgVNyLCgAAWA4BBwAAWA4BBwAAWA4BBwCaoGzHMc/3q7bv04G8Ij9WA9Q9Ag4ANDEbsnL1h9WfeZ5nfJ6tGas+0cavc6vZCmhcCDgA0IQcyCvSC//+TiefsOo2kjHS85u+U3besao3BhoRAg4ANCEbsg7KVsU6m6T1WYziwBoIOADQhBzMd1Z7c9GD+c76LAfwGQIOADQhMc3t1Y7gxDTnnn6wBgIOADQhA7vEVDuCc2WX2PosB/AZAg4ANCFtIsN0a/+OstmkAJu8vt7avyN3UIdl+PReVACAhmfA+bHqEheh9Vm5OpjvVExzu67sEku4gaUQcACgCYqPDNWNfdv6uwzAZzhEBQAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALMenAefw4cMaM2aMIiIiFBUVpYkTJyo/P7/abQYOHCibzeb1uO2227za7N27V8OGDVN4eLhiY2P1+9//XqWlpb7cFQAA0IgE+bLzMWPG6MCBA8rMzFRJSYkmTJigyZMna8WKFdVuN2nSJM2bN8/zPDw83PO9y+XSsGHDFB8frw8//FAHDhzQ2LFjFRwcrIceeshn+wIAABoPnwWcXbt2KSMjQ9u2bVOfPn0kSU8//bSuvvpqPf7440pISKhy2/DwcMXHx1e6bs2aNfryyy/1/vvvKy4uTr1799b8+fN177336oEHHlBISIhP9gcAADQePjtEtXnzZkVFRXnCjSSlpKQoICBAW7ZsqXbb5cuXq3Xr1urevbtmzZqlwsJCr3579OihuLg4z7LU1FQ5HA598cUXlfbndDrlcDi8HgAAwLp8NoKTnZ2t2NhY7xcLClLLli2VnZ1d5Xb/8z//o3bt2ikhIUGffvqp7r33XmVlZem1117z9HtyuJHkeV5Vv+np6Zo7d+7Z7A4AAGhEah1w7rvvPj3yyCPVttm1a9cZFzR58mTP9z169FCbNm00aNAgffvtt+rUqdMZ9Tlr1iylpaV5njscDiUmJp5xjQAAoGGrdcCZMWOGxo8fX22bjh07Kj4+Xrm5uV7LS0tLdfjw4Srn11QmOTlZkrR792516tRJ8fHx2rp1q1ebnJwcSaqyX7vdLrvdXuPXBAAAjVutA05MTIxiYmJO265fv346cuSItm/frqSkJEnSunXr5Ha7PaGlJnbu3ClJatOmjaffBx98ULm5uZ5DYJmZmYqIiFC3bt1quTcAAMCKfDbJ+IILLtCQIUM0adIkbd26VR988IGmTp2q0aNHe86g2r9/v7p27eoZkfn22281f/58bd++Xd9//73efPNNjR07Vv3791fPnj0lSYMHD1a3bt30//7f/9Mnn3yi9957T3/60580ZcoURmkAAIAkH1/ob/ny5eratasGDRqkq6++WpdffrleeOEFz/qSkhJlZWV5zpIKCQnR+++/r8GDB6tr166aMWOGRowYobfeesuzTWBgoN5++20FBgaqX79+uummmzR27Fiv6+YAAICmzWaMMf4uor45HA5FRkYqLy9PERER/i6nTvxSUKyvso/6uwwAAJQQFap2rZrVeb+1+fzmXlQAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMByCDgAAMBygvxdAOpGaHCgEqJC5TaS2xgZIxlj5DaSkZHbXbZcKvvqPmm9VPbV7TYyko43AwCg0SLgWERYSKDatWpWJ32ZUwJQlcHIlC8rC0YngtVJy48/NzKELwBAvSHgoAKbzaZAmyTZ/F1KBQ0hfDlLXMfDFwCgoSLgoFFpCOHL7TY6eqxUjmMlyisqUb6zlJElAGhgCDhALQUE2BQZHqzI8GAlSnK5jRxFJXIcK5GjqFQFxQQeAPA3Ag5wlgIDbIpuFqLoZiGSpFKXW45jpcorKpGjqESFxS4/VwgATQ8BB6hjQYEBatksRC2PB57iUvfx0Z2yQ1rHStx+rhAArM+n18E5fPiwxowZo4iICEVFRWnixInKz8+vsv33338vm81W6WPVqlWedpWtX7lypS93BThjIUEBat3cro4xzXVR22j9ql2UOsU2U0wLu0KCuBQVAPiCT0dwxowZowMHDigzM1MlJSWaMGGCJk+erBUrVlTaPjExUQcOHPBa9sILL+ixxx7T0KFDvZYvXbpUQ4YM8TyPioqq8/oBX7AHBSq2RaBiW5Q9P1bi8ozuOI6VqLiUCTwAcLZ8FnB27dqljIwMbdu2TX369JEkPf3007r66qv1+OOPKyEhocI2gYGBio+P91q2evVq3XDDDWrevLnX8qioqAptgcYoNDhQocGBio0IlSQVFpfKUVQ2h+fosRKVuAg8AFBbPhsf37x5s6KiojzhRpJSUlIUEBCgLVu21KiP7du3a+fOnZo4cWKFdVOmTFHr1q3Vt29fLVmyRKaa01acTqccDofXA2iowkOCFB8Zqi7xLZTULlo9z41Uu1bhim4WrMCAhndtIgBoiHw2gpOdna3Y2FjvFwsKUsuWLZWdnV2jPl588UVdcMEFuvTSS72Wz5s3T1dddZXCw8O1Zs0a3XHHHcrPz9ddd91VaT/p6emaO3fume0I4Ec2m03N7EFqZg9SgsJkjFG+s/wMrVIdPVbCRQcBoBK1Djj33XefHnnkkWrb7Nq164wLKldUVKQVK1bo/vvvr7Du5GUXXXSRCgoK9Nhjj1UZcGbNmqW0tDTPc4fDocTExLOuEahvNptNLUKD1SI0WIo+ftFBZ6lnDg8XHQSAMrUOODNmzND48eOrbdOxY0fFx8crNzfXa3lpaakOHz5co7kz//znP1VYWKixY8eetm1ycrLmz58vp9Mpu91eYb3dbq90OdDYBQTYFBkWrMiwExcdPHr8goN5RSVcdBBAk1XrgBMTE6OYmJjTtuvXr5+OHDmi7du3KykpSZK0bt06ud1uJScnn3b7F198Ub/97W9r9Fo7d+5UdHQ0IQZNXmCATVHhIYoKP3HRwaPlFx08VqICJxcdBNA0+GwOzgUXXKAhQ4Zo0qRJWrx4sUpKSjR16lSNHj3acwbV/v37NWjQIL388svq27evZ9vdu3dr06ZNevfddyv0+9ZbbyknJ0eXXHKJQkNDlZmZqYceekgzZ8701a4AjVZQYIDXVZZLXO6TTkkvVRFXWQZgUT69Ds7y5cs1depUDRo0SAEBARoxYoSeeuopz/qSkhJlZWWpsLDQa7slS5bo3HPP1eDBgyv0GRwcrEWLFmn69Okyxqhz58568sknNWnSJF/uCmAJwYEBatXcrlbNy0Y7i0vdntGdvKISObnKMgCLsJnqzq+2KIfDocjISOXl5SkiIsLf5QANRvlFB8sCT6mKSwk8AGovISpU7Vo1q/N+a/P5zb2oAHicetHBomKXjpW45DJGbmPkdktuY+RyGxlz/HtjZIyR65R15ducvK7p/XcKgL8QcABUKSwkUGEhgXXWn9ttTgpFJwKR21Rc53IbTygq/77scfp1BCkABBwA9SYgwKYA2Xz+D485OThVCD8n1pnjgerkgFXqNioudctZ6lZxqVsurqQINEoEHACWY7PZFBRYN7e1KHW5VewqCzue4HPS82KXW6XcLwxocAg4AFCNoMAABQUG6PilhSpFCAIaHgIOAJylmoQgl+fQl4sQBNQDAg4A1IPAANtpJ22Xh6DiUrecLpfXXCBCEFA7BBwAaCC8Q1BwpW0qC0Hl4cdZQggCyhFwAKAROdsQVP59CSEIFkfAAQCLqU0Icpa6VFjsUmFxqQqcLhWVuLiOECyBgAMATdDJISgq/MRyY8zxwFMWesq/FpeSetC4EHAAAB42m03N7EFqZg+SZPcsL3G5Veh0qbCkbKSnsLjsbvRcBxENFQEHAHBawYEBigwPUORJh7yMMSoqOT7ac1L44SataAgIOACAM2Kz2RQeEqTwkCCp+YnlpS63CopdKip2qaC4VIXH5/Zw2wvUJwIOAKBOBQUGKDIsQJFh3qM9x0rcJ83rKQs/zhJGe+AbBBwAgM/ZbCcmNbc6aXmpy63CkuOjPc4T4YfRHpwtAg4AwG+CAgMUERigiFDv09mPHZ/bU+AsVVFJ2VdnqZtT2FFjBBwAQIMTGhyo0OBAtWx24gZfLrfxPsR1PPxw5WZUhoADAGgUAgNsahEarBaVjPaUT2gu++rSMS5Y2OQRcAAAjVr5aE/0SaM9brdRYYlLhcfn9ZSHH25R0XQQcAAAlhMQYFNze5Ca270/5kpcbrmNkTHy+uo2ZWd6VfbVbYyMykKTOfm5Md5tqvhaWZ/wPQIOAKDJCA4M8HcJksrCkndQOn3QInDVDgEHAIB6FhBgU4Bs/i7DozxwuY1kVH0YKg9L1QWuU0fO/MH/FQAAAL9qaIGrLjSMsToAAIA6RMABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACW47OA8+CDD+rSSy9VeHi4oqKiarSNMUazZ89WmzZtFBYWppSUFH3zzTdebQ4fPqwxY8YoIiJCUVFRmjhxovLz832wBwAAoLHyWcApLi7WyJEjdfvtt9d4m0cffVRPPfWUFi9erC1btqhZs2ZKTU3VsWPHPG3GjBmjL774QpmZmXr77be1adMmTZ482Re7AAAAGimbMcb48gWWLVumadOm6ciRI9W2M8YoISFBM2bM0MyZMyVJeXl5iouL07JlyzR69Gjt2rVL3bp107Zt29SnTx9JUkZGhq6++mr9+OOPSkhIqFFNDodDkZGRysvLU0RExFntHwAAqB+1+fwOqqeaTmvPnj3Kzs5WSkqKZ1lkZKSSk5O1efNmjR49Wps3b1ZUVJQn3EhSSkqKAgICtGXLFl133XWV9u10OuV0Oj3P8/LyJJW9UQAAoHEo/9yuydhMgwk42dnZkqS4uDiv5XFxcZ512dnZio2N9VofFBSkli1betpUJj09XXPnzq2wPDEx8WzLBgAA9ezo0aOKjIystk2tAs59992nRx55pNo2u3btUteuXWvTrc/NmjVLaWlpnudut1uHDx9Wq1atZLPZ6vS1HA6HEhMTtW/fviZx+Iv9tTb219rYX2uz4v4aY3T06NEaTUmpVcCZMWOGxo8fX22bjh071qZLj/j4eElSTk6O2rRp41mek5Oj3r17e9rk5uZ6bVdaWqrDhw97tq+M3W6X3W73WlbTM7vOVEREhGV+oWqC/bU29tfa2F9rs9r+nm7kplytAk5MTIxiYmLOqKDT6dChg+Lj47V27VpPoHE4HNqyZYvnTKx+/frpyJEj2r59u5KSkiRJ69atk9vtVnJysk/qAgAAjY/PThPfu3evdu7cqb1798rlcmnnzp3auXOn1zVrunbtqtWrV0uSbDabpk2bpgULFujNN9/UZ599prFjxyohIUHDhw+XJF1wwQUaMmSIJk2apK1bt+qDDz7Q1KlTNXr06BqfQQUAAKzPZ5OMZ8+erZdeesnz/KKLLpIkrV+/XgMHDpQkZWVlec5okqR77rlHBQUFmjx5so4cOaLLL79cGRkZCg0N9bRZvny5pk6dqkGDBikgIEAjRozQU0895avdqDW73a45c+ZUOCRmVeyvtbG/1sb+WltT299T+fw6OAAAAPWNe1EBAADLIeAAAADLIeAAAADLIeAAAADLIeAAAADLIeDUoUWLFql9+/YKDQ1VcnKytm7d6u+SfGbTpk265pprlJCQIJvNptdff93fJflUenq6Lr74YrVo0UKxsbEaPny4srKy/F2Wzzz33HPq2bOn5wqo/fr107/+9S9/l1UvHn74Yc91uazqgQcekM1m83o0tFvs1LX9+/frpptuUqtWrRQWFqYePXroo48+8ndZPtG+ffsKP1+bzaYpU6b4u7R6RcCpI6+88orS0tI0Z84c7dixQ7169VJqamqFW0tYRUFBgXr16qVFixb5u5R6sXHjRk2ZMkX//e9/lZmZqZKSEg0ePFgFBQX+Ls0nzj33XD388MPavn27PvroI1111VW69tpr9cUXX/i7NJ/atm2bnn/+efXs2dPfpfjchRdeqAMHDnge//nPf/xdks/88ssvuuyyyxQcHKx//etf+vLLL/XEE08oOjra36X5xLZt27x+tpmZmZKkkSNH+rmyemZQJ/r27WumTJniee5yuUxCQoJJT0/3Y1X1Q5JZvXq1v8uoV7m5uUaS2bhxo79LqTfR0dHmr3/9q7/L8JmjR4+a8847z2RmZpoBAwaYu+++298l+cycOXNMr169/F1Gvbn33nvN5Zdf7u8y/Obuu+82nTp1Mm6329+l1CtGcOpAcXGxtm/frpSUFM+ygIAApaSkaPPmzX6sDL5SfgXuli1b+rkS33O5XFq5cqUKCgrUr18/f5fjM1OmTNGwYcO8/o6t7JtvvlFCQoI6duyoMWPGaO/evf4uyWfefPNN9enTRyNHjlRsbKwuuugi/eUvf/F3WfWiuLhYf/vb33TzzTfLZrP5u5x6RcCpA4cOHZLL5VJcXJzX8ri4OGVnZ/upKviK2+3WtGnTdNlll6l79+7+LsdnPvvsMzVv3lx2u1233XabVq9erW7duvm7LJ9YuXKlduzYofT0dH+XUi+Sk5O1bNkyZWRk6LnnntOePXt0xRVX6OjRo/4uzSe+++47PffcczrvvPP03nvv6fbbb9ddd93ldTshq3r99dd15MgRjR8/3t+l1Duf3YsKsKopU6bo888/t/ScBUnq0qWLdu7cqby8PP3zn//UuHHjtHHjRsuFnH379unuu+9WZmam133vrGzo0KGe73v27Knk5GS1a9dO//jHPzRx4kQ/VuYbbrdbffr00UMPPSSp7N6In3/+uRYvXqxx48b5uTrfevHFFzV06NAmeUNqRnDqQOvWrRUYGKicnByv5Tk5OYqPj/dTVfCFqVOn6u2339b69et17rnn+rscnwoJCVHnzp2VlJSk9PR09erVS3/+85/9XVad2759u3Jzc/WrX/1KQUFBCgoK0saNG/XUU08pKChILpfL3yX6XFRUlM4//3zt3r3b36X4RJs2bSoE8wsuuMDSh+Uk6YcfftD777+vW265xd+l+AUBpw6EhIQoKSlJa9eu9Sxzu91au3atpecsNCXGGE2dOlWrV6/WunXr1KFDB3+XVO/cbrecTqe/y6hzgwYN0meffaadO3d6Hn369NGYMWO0c+dOBQYG+rtEn8vPz9e3336rNm3a+LsUn7jssssqXNbh66+/Vrt27fxUUf1YunSpYmNjNWzYMH+X4hccoqojaWlpGjdunPr06aO+fftq4cKFKigo0IQJE/xdmk/k5+d7/W9vz5492rlzp1q2bKm2bdv6sTLfmDJlilasWKE33nhDLVq08MytioyMVFhYmJ+rq3uzZs3S0KFD1bZtWx09elQrVqzQhg0b9N577/m7tDrXokWLCnOpmjVrplatWll2jtXMmTN1zTXXqF27dvrpp580Z84cBQYG6sYbb/R3aT4xffp0XXrppXrooYd0ww03aOvWrXrhhRf0wgsv+Ls0n3G73Vq6dKnGjRunoKAm+lHv79O4rOTpp582bdu2NSEhIaZv377mv//9r79L8pn169cbSRUe48aN83dpPlHZvkoyS5cu9XdpPnHzzTebdu3amZCQEBMTE2MGDRpk1qxZ4++y6o3VTxMfNWqUadOmjQkJCTHnnHOOGTVqlNm9e7e/y/Kpt956y3Tv3t3Y7XbTtWtX88ILL/i7JJ967733jCSTlZXl71L8xmaMMf6JVgAAAL7BHBwAAGA5BBwAAGA5BBwAAGA5BBwAAGA5BBwAAGA5BBwAAGA5BBwAAGA5BBwAAGA5BBwAAGA5BBwAAGA5BBwAAGA5/x9LLmAWeFpEtAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "55\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGzCAYAAAAi6m1wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFU0lEQVR4nO3deVyVZf7/8ffhCAdRQVRWw71Ec2swSTO1ZARzmmzMtK/+XCptkUrRKW0mzaVoH1sss0ltZnSspmwfklxyKkYNs9WYNE1TAc0ABWU59/37Azl6ZBGMw4Gb1/PxOA+47/u6r/O5D+B5e93XfW6baZqmAAAALMTH2wUAAADUNgIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOAACwHAIOgCpt2rRJNptNmzZtqtV+bTabHnjggVrt06o89TOoLsMw1KNHDz344INeef6KpKSkqHnz5jp8+LC3S0E9RcBBo/Hcc8/JZrMpNjb2V/f1/vvv8+ZcDfXxdXrggQdks9kqfCxdutSrtT333HNauXKlV2uoyD//+U/t379fiYmJFW6v7t9WVlaWZs2apejoaAUEBKhZs2aKiYnRokWLlJOT42o3ZMiQSn9G3333nSQpISFBXbp0UXJycq0dJ6ylibcLAOrKqlWr1KFDB23dulW7du1Sly5dzruv999/X0uWLKl3b971TVWv04kTJ9Skiff+CXr++efVvHlzt3W1EX5/jeeee05t2rTRpEmT3NYPGjRIJ06ckJ+fn1fqeuyxxzR27FgFBQVVuL06f1vbtm3T1VdfrePHj2v8+PGKiYmRJH322Wd6+OGHtXnzZq1bt87V/oILLqgwvERGRrq+v/XWWzVr1izNnz9fLVq0+LWHCYsh4KBR2LNnjz799FO98cYbuvXWW7Vq1SrNmzfP22V5VEFBgQICAsqtLykpkWEYXnuzLOPv7+/V57/++uvVpk0br9ZQXT4+Pl57vT7//HN98cUXeuKJJyrcXp2/rZycHF133XWy2+36/PPPFR0d7bb9wQcf1Isvvui2LigoSOPHj6+ytlGjRunOO+/Ua6+9pptuuuk8jg5WxikqNAqrVq1ScHCwRowYoeuvv16rVq0q16ayeQ579+6VzWZznTqYNGmSlixZIkluQ+dl8vPzNXPmTEVFRcnhcKhr1656/PHHZZpmuef8xz/+oX79+ikgIEDBwcEaNGiQ2/9ipdL/1V988cVyOByKjIzUtGnT3IbzpdIh/R49eig9PV2DBg1SQECA7rvvPlftjz/+uBYvXqzOnTvL4XDo22+/lSR99913uv7669WqVSv5+/urb9++evvtt8/5ev7nP//R6NGj1a5dOzkcDkVFRWnGjBk6ceKEq825XqeK5uB8/vnnGj58uAIDA9W8eXMNHTpU//3vf93arFy5UjabTZ988omSkpIUEhKiZs2a6brrrquV+Rhn/7zPdHbNZae7du3apUmTJqlly5YKCgrS5MmTVVBQUG7/qn7eHTp00DfffKOPPvrI9VoNGTJEUuW/m6+99ppiYmLUtGlTtWnTRuPHj9eBAwfc2kyaNEnNmzfXgQMHNHLkSDVv3lwhISGaNWuWnE7nOV+PN998U35+fho0aFCF26vzt/XCCy/owIEDevLJJ8uFG0kKCwvTn//853PWcrbQ0FD16tVLb731Vo33hfUxgoNGYdWqVfrDH/4gPz8/3XjjjXr++ee1bds2XXrppTXu69Zbb9XBgweVmpqqv//9727bTNPU73//e23cuFE333yz+vTpow8++EB//OMfdeDAAf3lL39xtZ0/f74eeOABDRgwQAsWLJCfn5+2bNmiDRs2aNiwYZJK30Dnz5+vuLg43X777crIyHDV/sknn8jX19fV388//6zhw4dr7NixGj9+vMLCwlzbVqxYoZMnT2rq1KlyOBxq1aqVvvnmG11++eVq27atZs+erWbNmunVV1/VyJEj9frrr+u6666r9DV47bXXVFBQoNtvv12tW7fW1q1b9cwzz+inn37Sa6+9ds7XqSLffPONrrjiCgUGBuqee+6Rr6+vXnjhBQ0ZMkQfffRRudNHd955p4KDgzVv3jzt3btXixcvVmJiol555ZVzPpckHT161G3ZbrcrODi4Wvue7YYbblDHjh2VnJys7du3669//atCQ0P1yCOPuNqc6+e9ePFi3XnnnWrevLn+9Kc/SZLbz/BsK1eu1OTJk3XppZcqOTlZWVlZeuqpp/TJJ5/o888/V8uWLV1tnU6n4uPjFRsbq8cff1wffvihnnjiCXXu3Fm33357lcf26aefqkePHm6/a2eqzt/W22+/raZNm+r666+vzsvpqvnIkSNu6/z9/cudVoyJidGbb75Z7X7RiJiAxX322WemJDM1NdU0TdM0DMO84IILzLvvvtut3caNG01J5saNG93W79mzx5RkrlixwrVu2rRpZkV/Pm+++aYpyVy0aJHb+uuvv9602Wzmrl27TNM0ze+//9708fExr7vuOtPpdLq1NQzDNE3TzM7ONv38/Mxhw4a5tXn22WdNSeby5ctd6wYPHmxKMpcuXVph7YGBgWZ2drbbtqFDh5o9e/Y0T5486fbcAwYMMC+88MIqX5eCgoJyx56cnGzabDbzxx9/POfrZJqmKcmcN2+ea3nkyJGmn5+fuXv3bte6gwcPmi1atDAHDRrkWrdixQpTkhkXF+d6rUzTNGfMmGHa7XYzJyenwucrM2/ePFNSuUf79u1N06z4511ZzWV93XTTTW7trrvuOrN169au5er8vE3TNC+++GJz8ODB5Z737J9BUVGRGRoaavbo0cM8ceKEq927775rSjLnzp3rWjdx4kRTkrlgwQK3Pi+55BIzJiamwtfoTBdccIE5atSoCrdV928rODjY7N279zmfq0zZ7/PZj4kTJ5Zr+9BDD5mSzKysrGr3j8aBU1SwvFWrViksLExXXnmlpNLTDGPGjNGaNWuqNURfE++//77sdrvuuusut/UzZ86UaZr697//Lal02N8wDM2dO1c+Pu5/hmWncT788EMVFRVp+vTpbm2mTJmiwMBAvffee277ORwOTZ48ucK6Ro0apZCQENfy0aNHtWHDBt1www06duyYjhw5oiNHjujnn39WfHy8vv/++3KnOs7UtGlT1/f5+fk6cuSIBgwYINM09fnnn1f1ElXI6XRq3bp1GjlypDp16uRaHxERof/7v//Txx9/rLy8PLd9pk6d6nbK64orrpDT6dSPP/5Yred8/fXXlZqa6npUdGqlum677Ta35SuuuEI///yzq+bq/Lxr4rPPPlN2drbuuOMOt7k5I0aMUHR0dLnfjcpq/OGHH875XD///HOlI1vV/dvKy8ur8STgDh06uP18UlNTdc8995RrV1bb2aM9AKeoYGlOp1Nr1qzRlVdeqT179rjWx8bG6oknntD69etdp4Nqw48//qjIyMhy/5h369bNtV2Sdu/eLR8fH3Xv3r3KviSpa9eubuv9/PzUqVOncm/kbdu2rXTicMeOHd2Wd+3aJdM0df/99+v++++vcJ/s7Gy1bdu2wm379u3T3Llz9fbbb+uXX35x25abm1vpMVXm8OHDKigoKHesUulrZxiG9u/fr4svvti1vl27dm7tyt7ozq6nMoMGDaq1ScZV1RIYGFitn3dNVPa7IUnR0dH6+OOP3db5+/u7BdyyGqv7WpkVzB+ryd9WYGCgjh07Vq3nKtOsWTPFxcVVu7bzCYqwNgIOLG3Dhg06dOiQ1qxZozVr1pTbvmrVKtc/wpX9A1nbozyecuaoyrm2GYYhSZo1a5bi4+Mr3Keyy+idTqd++9vf6ujRo7r33nsVHR2tZs2a6cCBA5o0aZKrb0+z2+0Vrq/ozbgmzuf3wFO11JbK6quO1q1bVxiEavK3FR0drR07dqioqKjWr94rq62hXBGHukPAgaWtWrVKoaGhrqt5zvTGG29o7dq1Wrp0qZo2ber6X/fZVyhVdMqjsjfB9u3b68MPP9SxY8fcRnHKPpysffv2kqTOnTvLMAx9++236tOnT6V9SVJGRobbaZuioiLt2bOnWv+7rUxZf76+vjXu56uvvtL//vc/vfzyy5owYYJrfWpqarm21f1fdUhIiAICApSRkVFu23fffScfHx9FRUXVqM7zVZPfg+qqzs9bqv7rdebvxlVXXeW2LSMjw7W9NkRHR7uN0JSpyd/WNddco7S0NL3++uu68cYba602qfQy9TZt2pQboQKYgwPLOnHihN544w397ne/0/XXX1/ukZiYqGPHjrkui27fvr3sdrs2b97s1s9zzz1Xru9mzZpJKv8mePXVV8vpdOrZZ591W/+Xv/xFNptNw4cPlySNHDlSPj4+WrBgQbkRj7L/9cfFxcnPz09PP/2020jASy+9pNzcXI0YMeI8XpVSoaGhGjJkiF544QUdOnSo3PaqLrcuGw04sybTNPXUU0+Va1vZ61RRn8OGDdNbb72lvXv3utZnZWVp9erVGjhwoAIDA6vso7YEBgaqTZs21fo9qK7q/Lyl0tfrXK+VJPXt21ehoaFaunSpCgsLXev//e9/a+fOnb/qd+Ns/fv319dff+32PDX927rtttsUERGhmTNn6n//+1+558jOztaiRYvOq7709HT179///A4OlsYIDizr7bff1rFjx/T73/++wu2XXXaZQkJCtGrVKo0ZM0ZBQUEaPXq0nnnmGdlsNnXu3FnvvvuusrOzy+1b9imsd911l+Lj42W32zV27Fhdc801uvLKK/WnP/1Je/fuVe/evbVu3Tq99dZbmj59ujp37iyp9PTPn/70Jy1cuFBXXHGF/vCHP8jhcGjbtm2KjIxUcnKyQkJCNGfOHM2fP18JCQn6/e9/r4yMDD333HO69NJLz/khaOeyZMkSDRw4UD179tSUKVPUqVMnZWVlKS0tTT/99JO++OKLCveLjo5W586dNWvWLB04cECBgYF6/fXXKzyNUdnrVJFFixYpNTVVAwcO1B133KEmTZrohRdeUGFhoR599NFfdaw1dcstt+jhhx/WLbfcor59+2rz5s0VvjFXV3V+3lLp6/X8889r0aJF6tKli0JDQ8uN0EilI2+PPPKIJk+erMGDB+vGG290XSbeoUMHzZgx47xrPdu1116rhQsX6qOPPnKdcqrp31ZwcLDWrl2rq6++Wn369HH7JOPt27frn//853mFlOzsbH355ZeaNm3a+R8grMs7F28BnnfNNdeY/v7+Zn5+fqVtJk2aZPr6+ppHjhwxTdM0Dx8+bI4aNcoMCAgwg4ODzVtvvdX8+uuvy102XFJSYt55551mSEiIabPZ3C6FPnbsmDljxgwzMjLS9PX1NS+88ELzsccec7scuMzy5cvNSy65xHQ4HGZwcLA5ePBg1yW3ZZ599lkzOjra9PX1NcPCwszbb7/d/OWXX9zaDB482Lz44ovL9V92yfNjjz1W4fHv3r3bnDBhghkeHm76+vqabdu2NX/3u9+Z//rXv1xtKrpM/NtvvzXj4uLM5s2bm23atDGnTJlifvHFFzV6nXTWJdemaZrbt2834+PjzebNm5sBAQHmlVdeaX766adubcouE9+2bZvb+sou8z9b2aXdhw8frrRNQUGBefPNN5tBQUFmixYtzBtuuMHMzs6u9DLxs/sqq3HPnj1u68/1887MzDRHjBhhtmjRwpTkumS8smN75ZVXXP21atXKHDdunPnTTz+5tZk4caLZrFmzSl+H6ujVq5d58803u5bP52/LNEsv+58xY4Z50UUXmf7+/mZAQIAZExNjPvjgg2Zubq6rXWW/z2d7/vnnzYCAADMvL69ax4HGxWaa9WQWHACgXvr73/+uadOmad++fW4fIOhtl1xyiYYMGeL2AZpAGebgAACqNG7cOLVr167CCcXekpKSou+//15z5szxdimopxjBAQAAlsMIDgAAsByPBpzNmzfrmmuuUWRkpGw2W7VuiLZp0yb95je/kcPhUJcuXSq8o++SJUvUoUMH+fv7KzY2Vlu3bq394gEAQIPl0YCTn5+v3r17V/u87Z49ezRixAhdeeWV2rFjh6ZPn65bbrlFH3zwgavNK6+8oqSkJM2bN0/bt29X7969FR8fX+GlvAAAoHGqszk4NptNa9eu1ciRIyttc++99+q9997T119/7Vo3duxY5eTkKCUlRVLpfU4uvfRS1wepGYahqKgo3XnnnZo9e7ZHjwEAADQM9eqD/tLS0sp9bHx8fLymT58uqfQj6tPT091mzfv4+CguLk5paWmV9ltYWOj2KZyGYejo0aNq3bo1N2gDAKCBME1Tx44dU2RkpHx8qj4JVa8CTmZmpsLCwtzWhYWFKS8vTydOnNAvv/wip9NZYZuye/1UJDk5WfPnz/dIzQAAoG7t379fF1xwQZVt6lXA8ZQ5c+YoKSnJtZybm6t27dpp//79tXJ/m7+k/k8rP90rp1H+bJ/dx6ZJAzpoxm8v+tXPAwBAY5aXl6eoqCi3mxlXpl4FnPDwcGVlZbmty8rKUmBgoJo2bSq73S673V5hm/Dw8Er7dTgccjgc5dYHBgbWSsCZMLibXv4sSz4VzGay2aSJg7spMLDZr34eAACgak0vqVefg9O/f3+tX7/ebV1qaqrrJmx+fn6KiYlxa2MYhtavX+/Vu8l2bNNMj4zqJZ8zXm+7zSYfm/TIqF7q0IZwAwBAXfLoCM7x48e1a9cu1/KePXu0Y8cOtWrVSu3atdOcOXN04MAB/e1vf5Mk3XbbbXr22Wd1zz336KabbtKGDRv06quv6r333nP1kZSUpIkTJ6pv377q16+fFi9erPz8fE2ePNmTh3JOo/tGqUfbQA1/6mNJ0uSBHTQ+tj3hBgAAL/BowPnss8905ZVXupbL5sFMnDhRK1eu1KFDh7Rv3z7X9o4dO+q9997TjBkz9NRTT+mCCy7QX//6V8XHx7vajBkzRocPH9bcuXOVmZmpPn36KCUlpdzEY29o3/p0mEn67UUK8KtXZwABAGg0GuW9qPLy8hQUFKTc3NxamYNTpqCoRN3nln4o4bcL4gk4AADUopq8f9erOTgAAAC1gYADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsh4ADAAAsp4m3CwAAAPWb0zBVYhhyGqbrUXLGV8O1bKjEMBUc4KewQH+v1kzAAQDAwtxDiVFBKDn9tbI2plmz52zqa/fMwdQAAQcAgHrqzBDiNE05ne4BpPxoiiHDkFubmoYTqyDgAADgAWXhxDBPBZCycGKeCiPOM07xmGcunz4VZDTScFIbCDgAAJzFNM9x+sZ5RnA5I6yUhhfj1HZvH0XjRsABAFhesdNQQaFTJ4qdFZ7iOb1syGmUzltBw0bAAQBYyslip/ILS1RQ5FR+UYnyC50qKjG8XRbqGAEHANAgGYap/KJTQeZUoCkocjL6AkkEHABAA1BUYqigqET5RU4VFJZ+PVnsbLRXCOHcCDgAgHrDNE2dKHYqv9CpgqKyUZkSFZWQZFAzBBwAgFeUOA0VFDtVUFg6V6bgVKjhDBNqAwEHAOBxJ4udZ82VKdHJYib+wnMIOACAWmMYp04xnRqRKZsEXOJkWAZ1q07uJr5kyRJ16NBB/v7+io2N1datWyttO2TIENlstnKPESNGuNpMmjSp3PaEhIS6OBQAwCnFTkO5BcU6mHNCu7KP6Yv9Odq696i+/ClXu7PzdSj3pPJOlBBu4BUeH8F55ZVXlJSUpKVLlyo2NlaLFy9WfHy8MjIyFBoaWq79G2+8oaKiItfyzz//rN69e2v06NFu7RISErRixQrXssPh8NxBAEAjx2fLoKHxeMB58sknNWXKFE2ePFmStHTpUr333ntavny5Zs+eXa59q1at3JbXrFmjgICAcgHH4XAoPDzcc4UDQCPkNEzX1Ut8tgwaMo8GnKKiIqWnp2vOnDmudT4+PoqLi1NaWlq1+njppZc0duxYNWvWzG39pk2bFBoaquDgYF111VVatGiRWrduXWEfhYWFKiwsdC3n5eWdx9EAQMNiGKZMSYZZekfpsq+mSu+TZJ66wWPplUx8tgysxaMB58iRI3I6nQoLC3NbHxYWpu++++6c+2/dulVff/21XnrpJbf1CQkJ+sMf/qCOHTtq9+7duu+++zR8+HClpaXJbreX6yc5OVnz58//dQcDAGcwzdMhwTgVGs4MEYZZGi5M43SgcAUMs5LgccZ+Z7Yt698wTj9PWVvX87j6Or0v0JjV66uoXnrpJfXs2VP9+vVzWz927FjX9z179lSvXr3UuXNnbdq0SUOHDi3Xz5w5c5SUlORazsvLU1RUlOcKB+oJwyh9A3SapW+OZd+bhkrXmaaMU3dANswz2p/6apx6Iy19C625832TPe/9aqnOM0c5yoUSoyxQnF+NAOqGRwNOmzZtZLfblZWV5bY+KyvrnPNn8vPztWbNGi1YsOCcz9OpUye1adNGu3btqjDgOBwOJiGj3jFdQeL0/8SdhnsQMU4FE+epIFIWOpyGWbr/qX3MU+tO98P/4gE0bh4NOH5+foqJidH69es1cuRISZJhGFq/fr0SExOr3Pe1115TYWGhxo8ff87n+emnn/Tzzz8rIiKiNsoG3JimqWJnaZAoNgw5nadHRdyCxVmjIka50HE6zJSFEgCAZ3j8FFVSUpImTpyovn37ql+/flq8eLHy8/NdV1VNmDBBbdu2VXJystt+L730kkaOHFlu4vDx48c1f/58jRo1SuHh4dq9e7fuuecedenSRfHx8Z4+HDRwTsNUsdNQiWHK6SwNLCXO0nVOw1SJYajYWTrxssQobcdneABAw+PxgDNmzBgdPnxYc+fOVWZmpvr06aOUlBTXxON9+/bJx8f98wYzMjL08ccfa926deX6s9vt+vLLL/Xyyy8rJydHkZGRGjZsmBYuXMhpqEbk7FEVVyA5FU6KDeN0mDljG1e6AkDjYDPNxjdQnpeXp6CgIOXm5iowMLDW+i0oKlH3uR9Ikr5dEK8Av3o9h7veYFQFAKwlsqW/2rdudu6GNVST92/egVFrTNN0hQ9GVQAA3kTAQYUqG1UpOeOr6xSRk1EVAED9QsCxOEZVAACNEQHHIgqKSnQw5wSjKgAAiIBjGYXFhg4fKzp3QwAAGgGfczcBAABoWAg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcgg4AADAcuok4CxZskQdOnSQv7+/YmNjtXXr1krbrly5Ujabze3h7+/v1sY0Tc2dO1cRERFq2rSp4uLi9P3333v6MAAAQAPh8YDzyiuvKCkpSfPmzdP27dvVu3dvxcfHKzs7u9J9AgMDdejQIdfjxx9/dNv+6KOP6umnn9bSpUu1ZcsWNWvWTPHx8Tp58qSnDwcAADQAHg84Tz75pKZMmaLJkyere/fuWrp0qQICArR8+fJK97HZbAoPD3c9wsLCXNtM09TixYv15z//Wddee6169eqlv/3tbzp48KDefPNNTx8OAABoADwacIqKipSenq64uLjTT+jjo7i4OKWlpVW63/Hjx9W+fXtFRUXp2muv1TfffOPatmfPHmVmZrr1GRQUpNjY2Er7LCwsVF5entsDAABYl0cDzpEjR+R0Ot1GYCQpLCxMmZmZFe7TtWtXLV++XG+99Zb+8Y9/yDAMDRgwQD/99JMkufarSZ/JyckKCgpyPaKion7toQEAgHqs3l1F1b9/f02YMEF9+vTR4MGD9cYbbygkJEQvvPDCefc5Z84c5ebmuh779++vxYoBAEB949GA06ZNG9ntdmVlZbmtz8rKUnh4eLX68PX11SWXXKJdu3ZJkmu/mvTpcDgUGBjo9gAAANbl0YDj5+enmJgYrV+/3rXOMAytX79e/fv3r1YfTqdTX331lSIiIiRJHTt2VHh4uFufeXl52rJlS7X7BAAA1tbE00+QlJSkiRMnqm/fvurXr58WL16s/Px8TZ48WZI0YcIEtW3bVsnJyZKkBQsW6LLLLlOXLl2Uk5Ojxx57TD/++KNuueUWSaVXWE2fPl2LFi3ShRdeqI4dO+r+++9XZGSkRo4c6enDAQAADYDHA86YMWN0+PBhzZ07V5mZmerTp49SUlJck4T37dsnH5/TA0m//PKLpkyZoszMTAUHBysmJkaffvqpunfv7mpzzz33KD8/X1OnTlVOTo4GDhyolJSUch8ICAAAGiebaZqmt4uoa3l5eQoKClJubm6tzscpKCpR97kfSJK+XRCvAD+P50eXX/KL9F3msTp7PgAAKhPZ0l/tWzer9X5r8v5d766iAgAA+LUIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHIIOAAAwHLqJOAsWbJEHTp0kL+/v2JjY7V169ZK27744ou64oorFBwcrODgYMXFxZVrP2nSJNlsNrdHQkKCpw8DAAA0EB4POK+88oqSkpI0b948bd++Xb1791Z8fLyys7MrbL9p0ybdeOON2rhxo9LS0hQVFaVhw4bpwIEDbu0SEhJ06NAh1+Of//ynpw8FAAA0EB4POE8++aSmTJmiyZMnq3v37lq6dKkCAgK0fPnyCtuvWrVKd9xxh/r06aPo6Gj99a9/lWEYWr9+vVs7h8Oh8PBw1yM4ONjThwIAABoIjwacoqIipaenKy4u7vQT+vgoLi5OaWlp1eqjoKBAxcXFatWqldv6TZs2KTQ0VF27dtXtt9+un3/+udI+CgsLlZeX5/YAAADW1cSTnR85ckROp1NhYWFu68PCwvTdd99Vq497771XkZGRbiEpISFBf/jDH9SxY0ft3r1b9913n4YPH660tDTZ7fZyfSQnJ2v+/Pm/7mBQzqHcE9qUcViHjxcqpLlDQ7qGKCKoqbfLAgDAswHn13r44Ye1Zs0abdq0Sf7+/q71Y8eOdX3fs2dP9erVS507d9amTZs0dOjQcv3MmTNHSUlJruW8vDxFRUV5tniL25SRrWX/+UE2SaYkm6R3vjyoWwd10uCLQr1cHQCgsfPoKao2bdrIbrcrKyvLbX1WVpbCw8Or3Pfxxx/Xww8/rHXr1qlXr15Vtu3UqZPatGmjXbt2Vbjd4XAoMDDQ7YHzdyj3hJb95weZpmSYcvv6wuYflJl70tslAgAaOY8GHD8/P8XExLhNEC6bMNy/f/9K93v00Ue1cOFCpaSkqG/fvud8np9++kk///yzIiIiaqVuVG1TxmHZKtlmk7Qxo+Ir5AAAqCsev4oqKSlJL774ol5++WXt3LlTt99+u/Lz8zV58mRJ0oQJEzRnzhxX+0ceeUT333+/li9frg4dOigzM1OZmZk6fvy4JOn48eP64x//qP/+97/au3ev1q9fr2uvvVZdunRRfHy8pw8Hkg4fL5RZyTbz1HYAALzJ43NwxowZo8OHD2vu3LnKzMxUnz59lJKS4pp4vG/fPvn4nM5Zzz//vIqKinT99de79TNv3jw98MADstvt+vLLL/Xyyy8rJydHkZGRGjZsmBYuXCiHw+Hpw4GkkOYO19ybs9lObQcAwJvqZJJxYmKiEhMTK9y2adMmt+W9e/dW2VfTpk31wQcf1FJlOB9DuobonS8PVrjNlHRlVyYZAwC8i3tRocYigprq1kGdZDtjIo6PTbLZpFsHdVJ4kH/lOwMAUAfq9WXiqL8GXxSqDq2bafYbX0mSEnqE67fdwgk3AIB6gYCD8xYWeDrMjI6Jkr9v+Q9ZBADAGzhFBQAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIeAAwAALIfLxIFqOpR7QpsyDuvw8UKFNHdoSNcQRQQ19XZZAIAKEHCAatiUka1l//nBdQ8um6R3vjyoWwd10uCLuDUFANQ3nKICzuFQ7gkt+88PMk3JMOX29YXNPygz96S3SwQAnIWAA5zDpozDslWyzSZpY0Z2XZYDAKgGAg5wDoePF8qsZJt5ajsAoH4h4ADnENLcUeUITkhzR12WAwCoBgIOcA5DuoZUOYJzZVcmGQNAfUPAAc4hIqipbh3USbYzhnF8bJLNJt06qJPCg/wr3xkA4BVcJg5Uw+CLQtWhdTPNfuMrSVJCj3D9tls44QYA6ikCDlBNYYGnw8zomCj5+9q9WA0AoCqcogIAAJZDwAEAAJZDwAEAAJZDwAEAAJZDwAEAAJZDwAEAAJZDwAEAAJZDwAEAAJZDwAEAAJZDwAEAAJZDwAEAAJZDwAEAAJbDzTYBVOhQ7gltyjisw8cLFdLcoSFdQxQR1NTbZQFAtRBwAJSzKSNby/7zg2ySTEk2Se98eVC3DuqkwReFerk6ADg3TlEBcHMo94SW/ecHmaZkmHL7+sLmH5SZe9LbJQLAORFwALjZlHFYtkq22SRtzMiuy3IA4LwQcAC4OXy8UGYl28xT2wGgvquTgLNkyRJ16NBB/v7+io2N1datW6ts/9prryk6Olr+/v7q2bOn3n//fbftpmlq7ty5ioiIUNOmTRUXF6fvv//ek4cANBohzR1VjuCENHfUZTkAcF48Psn4lVdeUVJSkpYuXarY2FgtXrxY8fHxysjIUGho+cmKn376qW688UYlJyfrd7/7nVavXq2RI0dq+/bt6tGjhyTp0Ucf1dNPP62XX35ZHTt21P3336/4+Hh9++238vf3r3ZtBUUlalJUUmvHWnBGXwW12G91nChy6mSxs06fs/CM5yus4+f2hsZyvP07t9Y7Xx6scJspaUDn1nX+uwagYTlR5PTI+2BN+rSZplnZaHStiI2N1aWXXqpnn31WkmQYhqKionTnnXdq9uzZ5dqPGTNG+fn5evfdd13rLrvsMvXp00dLly6VaZqKjIzUzJkzNWvWLElSbm6uwsLCtHLlSo0dO7Zcn4WFhSosPD2snpeXp6ioKEVNf1U+joDaPmQAAOABRmGB9i++Qbm5uQoMDKyyrUdPURUVFSk9PV1xcXGnn9DHR3FxcUpLS6twn7S0NLf2khQfH+9qv2fPHmVmZrq1CQoKUmxsbKV9JicnKygoyPWIior6tYcGAADqMY+eojpy5IicTqfCwsLc1oeFhem7776rcJ/MzMwK22dmZrq2l62rrM3Z5syZo6SkJNdy2QjO1j8NPWcCbChy8ouVkXXM22UADVZhsVO3rdouSVo67jdy+Nq9XJFncbwcrydFBPmrXevaP0OSl5eniMXVa9soPujP4XDI4Sg/MTLAr4kC/KzxEhQWG/K3+B8sUFccvvZG9ffE8VqbN463qZ/dI++vJTXo06OnqNq0aSO73a6srCy39VlZWQoPD69wn/Dw8Crbl32tSZ8AAKBx8WjA8fPzU0xMjNavX+9aZxiG1q9fr/79+1e4T//+/d3aS1JqaqqrfceOHRUeHu7WJi8vT1u2bKm0TwAA0Lh4/PxMUlKSJk6cqL59+6pfv35avHix8vPzNXnyZEnShAkT1LZtWyUnJ0uS7r77bg0ePFhPPPGERowYoTVr1uizzz7TsmXLJEk2m03Tp0/XokWLdOGFF7ouE4+MjNTIkSM9fTgAAKAB8HjAGTNmjA4fPqy5c+cqMzNTffr0UUpKimuS8L59++Tjc3ogacCAAVq9erX+/Oc/67777tOFF16oN9980/UZOJJ0zz33KD8/X1OnTlVOTo4GDhyolJSUGn0GDgAAsK46mWGbmJioxMTECrdt2rSp3LrRo0dr9OjRlfZns9m0YMECLViwoLZKBAAAFsK9qAAAgOUQcAAAgOUQcAAAgOUQcAAAgOUQcAAAgOUQcAAAgOUQcAAAgOUQcAAAgOUQcAAAgOUQcABAUmbeSdf3r6Xv16HcE16sBsCvRcAB0OhtysjWfWu/ci2nfJ2pma99oY/+l+3FqgD8GgQcAI3aodwTWvafH2Sap9cZpmSa0gubf1Bm7snKdwZQbxFwADRqmzIOy1bJNpukjRmM4gANEQEHQKN2+HihzEq2mae2A2h4CDgAGrWQ5o4qR3BCmjvqshwAtYSAA6BRG9I1pMoRnCu7htZlOQBqCQEHQKMWEdRUtw7qJJtN8rHJ7eutgzopPMjf2yUCOA9NvF0AAHjb4ItC1TUsUBszsnX4eKFCmjt0ZddQwg3QgBFwAEBSeJC/buzXzttlAKglnKICAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAACWQ8ABAFheZt5J1/evpe/XodwTXqwGdYGAAwCwtE0Z2bpv7Veu5ZSvMzXztS/00f+yvVgVPI2AAwCwrEO5J7TsPz/INE+vM0zJNKUXNv+gzNyTle+MBo2AAwCwrE0Zh2WrZJtN0sYMRnGsioADALCsw8cLZVayzTy13YqYc+ThgHP06FGNGzdOgYGBatmypW6++WYdP368yvZ33nmnunbtqqZNm6pdu3a66667lJub69bOZrOVe6xZs8aThwIAaIBCmjuqHMEJae6oy3LqBHOOSnk04IwbN07ffPONUlNT9e6772rz5s2aOnVqpe0PHjyogwcP6vHHH9fXX3+tlStXKiUlRTfffHO5titWrNChQ4dcj5EjR3rwSAAADdGQriFVjuBc2TW0LsvxOOYcndbEUx3v3LlTKSkp2rZtm/r27StJeuaZZ3T11Vfr8ccfV2RkZLl9evTooddff9213LlzZz344IMaP368SkpK1KTJ6XJbtmyp8PBwT5UPALCAiKCmunVQJ72w+QfZVBpqyr7eOqiTwoP8vVtgLSubc1RRqCubc3Rjv3Z1XJV3eGwEJy0tTS1btnSFG0mKi4uTj4+PtmzZUu1+cnNzFRgY6BZuJGnatGlq06aN+vXrp+XLl8s0K8voUmFhofLy8tweAIDGYfBFoXpydB/9rlekLuvUWr/rFaknR/fR4IusNXojNd45RxXx2AhOZmamQkPdf3maNGmiVq1aKTMzs1p9HDlyRAsXLix3WmvBggW66qqrFBAQoHXr1umOO+7Q8ePHddddd1XYT3JysubPn39+BwIAaPDCg/wbxchF2ZyjykZwrDjnqDI1HsGZPXt2hZN8z3x89913v7qwvLw8jRgxQt27d9cDDzzgtu3+++/X5ZdfrksuuUT33nuv7rnnHj322GOV9jVnzhzl5ua6Hvv37//V9QEAUN80tjlHVanxCM7MmTM1adKkKtt06tRJ4eHhys52n7FdUlKio0ePnnPuzLFjx5SQkKAWLVpo7dq18vX1rbJ9bGysFi5cqMLCQjkc5dOpw+GocD0AAFbS2OYcVaXGASckJEQhISHnbNe/f3/l5OQoPT1dMTExkqQNGzbIMAzFxsZWul9eXp7i4+PlcDj09ttvy9//3D+MHTt2KDg4mBADAGj0Bl8Uqq5hgdqYka3DxwsV0tyhK7uGNqpwI3lwDk63bt2UkJCgKVOmaOnSpSouLlZiYqLGjh3ruoLqwIEDGjp0qP72t7+pX79+ysvL07Bhw1RQUKB//OMfbhOCQ0JCZLfb9c477ygrK0uXXXaZ/P39lZqaqoceekizZs3y1KEAANCgNJY5R1XxWMCRpFWrVikxMVFDhw6Vj4+PRo0apaefftq1vbi4WBkZGSooKJAkbd++3XWFVZcuXdz62rNnjzp06CBfX18tWbJEM2bMkGma6tKli5588klNmTLFk4cCAAAaEI8GnFatWmn16tWVbu/QoYPb5d1Dhgyp8nJvSUpISFBCQkKt1QgAAKyHe1EBQCPEvYpgdQQcAGhkuFcRGgMCDgA0ItyrCI0FAQcAGpGyexVVpOxeRYAVEHAAoBHhXkVoLAg4ANCIlN2rqCKN7V5FsDYCDgA0ItyrCI0FAQcAGpGyexXZbJKPTW5fG9u9imBtHv2gPwBA/cO9itAYEHAAoBHiXkWwOk5RAQAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAyyHgAAAAy/FowDl69KjGjRunwMBAtWzZUjfffLOOHz9e5T5DhgyRzWZze9x2221ubfbt26cRI0YoICBAoaGh+uMf/6iSkhJPHgoAAGhAmniy83HjxunQoUNKTU1VcXGxJk+erKlTp2r16tVV7jdlyhQtWLDAtRwQEOD63ul0asSIEQoPD9enn36qQ4cOacKECfL19dVDDz3ksWMBAAANh8cCzs6dO5WSkqJt27apb9++kqRnnnlGV199tR5//HFFRkZWum9AQIDCw8Mr3LZu3Tp9++23+vDDDxUWFqY+ffpo4cKFuvfee/XAAw/Iz8/PI8cDAAAaDo+dokpLS1PLli1d4UaS4uLi5OPjoy1btlS576pVq9SmTRv16NFDc+bMUUFBgVu/PXv2VFhYmGtdfHy88vLy9M0331TYX2FhofLy8tweAADAujw2gpOZmanQ0FD3J2vSRK1atVJmZmal+/3f//2f2rdvr8jISH355Ze69957lZGRoTfeeMPV75nhRpJrubJ+k5OTNX/+/F9zOAAAoAGpccCZPXu2HnnkkSrb7Ny587wLmjp1quv7nj17KiIiQkOHDtXu3bvVuXPn8+pzzpw5SkpKci3n5eUpKirqvGsEAAD1W40DzsyZMzVp0qQq23Tq1Enh4eHKzs52W19SUqKjR49WOr+mIrGxsZKkXbt2qXPnzgoPD9fWrVvd2mRlZUlSpf06HA45HI5qPycAAGjYahxwQkJCFBIScs52/fv3V05OjtLT0xUTEyNJ2rBhgwzDcIWW6tixY4ckKSIiwtXvgw8+qOzsbNcpsNTUVAUGBqp79+41PBoAAGBFHptk3K1bNyUkJGjKlCnaunWrPvnkEyUmJmrs2LGuK6gOHDig6Oho14jM7t27tXDhQqWnp2vv3r16++23NWHCBA0aNEi9evWSJA0bNkzdu3fX//t//09ffPGFPvjgA/35z3/WtGnTGKUBAACSPPxBf6tWrVJ0dLSGDh2qq6++WgMHDtSyZctc24uLi5WRkeG6SsrPz08ffvihhg0bpujoaM2cOVOjRo3SO++849rHbrfr3Xffld1uV//+/TV+/HhNmDDB7XNzAABA42YzTdP0dhF1LS8vT0FBQcrNzVVgYKC3y6kVv+QX6bvMY94uAwAARbb0V/vWzWq935q8f3MvKgAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDlNvF0Aaoe/r11hgQ6VGKZKnKZKDEPFTlMlTkOG6e3qAACoWwQci2jqZ1enkOYVbjMMU8WGURp8ToWfEsNUsfPUOuPUOmfpOqdRus4kGAEAGigCTiPg42OTw8cuRw1+2qZpuo0GlThLQ5Lz1Lpip8FoEQCg3iLgoEI2m02+dpt87ZJkr/Z+jBYBAOoDAg5qVW2OFpU4TTmN06NFZYGI0SIAwLkQcOB15zta5DxjNKi6o0XFTlIRADQGBBw0WHYfm+yMFgEAKuDRgHP06FHdeeedeuedd+Tj46NRo0bpqaeeUvPmFV/ts3fvXnXs2LHCba+++qpGjx4tqfR//Gf75z//qbFjx9Ze8bCkWhktMkyZZmkgMkzJME0ZZctG6bLTLGujU+3KHqXLZ+4PAKh9Hg0448aN06FDh5Samqri4mJNnjxZU6dO1erVqytsHxUVpUOHDrmtW7ZsmR577DENHz7cbf2KFSuUkJDgWm7ZsmWt1w+UOZ/Rouowzwg9bkHJLJ2wfToslbZxnpqQ7SwLTEbp9rJgZZwVvMraA0Bj47GAs3PnTqWkpGjbtm3q27evJOmZZ57R1Vdfrccff1yRkZHl9rHb7QoPD3dbt3btWt1www3lRn1atmxZri3Q0NhsNtltpQHKU6oz2mScCknOU6HpzNEmyTyrv/Os47zrP9/nO78dzVOvk2mWfm/q9GtXuq60Z8Mo/UqABOonjwWctLQ0tWzZ0hVuJCkuLk4+Pj7asmWLrrvuunP2kZ6erh07dmjJkiXltk2bNk233HKLOnXqpNtuu02TJ0+u8NSVJBUWFqqwsNC1nJeXdx5HBDRMNptNTeyeC1CNXdkonOurToejskBpSjKNKsLSqeUzg5Xhtq1s+6k+jNPP47bvqXrK2pZtAxojjwWczMxMhYaGuj9ZkyZq1aqVMjMzq9XHSy+9pG7dumnAgAFu6xcsWKCrrrpKAQEBWrdune644w4dP35cd911V4X9JCcna/78+ed3IABQhbJROKn+hsiy0SZX4DpjdKrYaepEkVP5RSUqKHSqoKiEuWGwhBoHnNmzZ+uRRx6pss3OnTvPu6AyJ06c0OrVq3X//feX23bmuksuuUT5+fl67LHHKg04c+bMUVJSkms5Ly9PUVFRv7pGAGgIfE6dArVXEsKCmvq6vjdNUyeKnco/FXbKvvIRC2hoahxwZs6cqUmTJlXZplOnTgoPD1d2drbb+pKSEh09erRac2f+9a9/qaCgQBMmTDhn29jYWC1cuFCFhYVyOBzltjscjgrXAwDc2Ww2Bfg1UYBfE0mn/90sKjFKA0+RUwWFpV9PFjs5BYZ6q8YBJyQkRCEhIeds179/f+Xk5Cg9PV0xMTGSpA0bNsgwDMXGxp5z/5deekm///3vq/VcO3bsUHBwMCEGADzEr4mP/Jr4qWXA6XVOw1RBUYkKipzKLyz9WlDkPDU5HfAuj83B6datmxISEjRlyhQtXbpUxcXFSkxM1NixY11XUB04cEBDhw7V3/72N/Xr18+1765du7R582a9//775fp95513lJWVpcsuu0z+/v5KTU3VQw89pFmzZnnqUAAAFbD72NTC31ct/H3d1p8sPh148k+d5ioqMbxUJRorj34OzqpVq5SYmKihQ4e6Pujv6aefdm0vLi5WRkaGCgoK3PZbvny5LrjgAg0bNqxcn76+vlqyZIlmzJgh0zTVpUsXPfnkk5oyZYonDwUAUE3+vnb5+9rV+ox1xU5DBYWnJjMXnR7t4RQXPMVmmo3v1ysvL09BQUHKzc1VYGCgt8sBgEbJME5NaD51BVf+qeBTwoTmBi+ypb/at25W6/3W5P2be1EBALzCx8emZo4mauZoIrU4vf5ksdM1r+fEqdNdJ4s5xYWaIeAAAOqVslNcrZr5udaVOA0VFDtPj/TwmT04BwIOAKDea2L3UaDdR4H+FX9mj+vDCotKVFRC6gEBBwDQQLl/Zs9pfGYPJAIOAMBiKvrMHsMwlV9UOqfHaZgqcZbedLbk1M1lTy8brmVOfzVsBBwAgOX5VPKZPVUxTgUgp2HKaZpyOksDkPPM9Wd8X2IYMgy5tWHUyHsIOAAAVMDHxyY/n193E1WnWxAyzlo2KwhLp8ORQUj6VQg4AAB4iN3HJrsrJNnPq4+qwpH7slHhyJKzkYYkAg4AAPVYaUg6v3BU5uzRIafz1Gm3csulIalsTpKrTQP88EUCDgAAFlcbIanEaZyelG2UzUmqeI5SU99f91y1gYADAADOqYndR028n1uqzcfbBQAAANQ2Ag4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcAg4AALAcjwWcBx98UAMGDFBAQIBatmxZrX1M09TcuXMVERGhpk2bKi4uTt9//71bm6NHj2rcuHEKDAxUy5YtdfPNN+v48eMeOAIAANBQeSzgFBUVafTo0br99turvc+jjz6qp59+WkuXLtWWLVvUrFkzxcfH6+TJk64248aN0zfffKPU1FS9++672rx5s6ZOneqJQwAAAA2UzTRN05NPsHLlSk2fPl05OTlVtjNNU5GRkZo5c6ZmzZolScrNzVVYWJhWrlypsWPHaufOnerevbu2bdumvn37SpJSUlJ09dVX66efflJkZGS1asrLy1NQUJByc3MVGBj4q44PAADUjZq8fzepo5rOac+ePcrMzFRcXJxrXVBQkGJjY5WWlqaxY8cqLS1NLVu2dIUbSYqLi5OPj4+2bNmi6667rsK+CwsLVVhY6FrOzc2VVPpCAQCAhqHsfbs6YzP1JuBkZmZKksLCwtzWh4WFubZlZmYqNDTUbXuTJk3UqlUrV5uKJCcna/78+eXWR0VF/dqyAQBAHTt27JiCgoKqbFOjgDN79mw98sgjVbbZuXOnoqOja9Ktx82ZM0dJSUmuZcMwdPToUbVu3Vo2m61WnysvL09RUVHav39/ozj9xfFaG8drbRyvtVnxeE3T1LFjx6o1JaVGAWfmzJmaNGlSlW06depUky5dwsPDJUlZWVmKiIhwrc/KylKfPn1cbbKzs932Kykp0dGjR137V8ThcMjhcLitq+6VXecrMDDQMr9Q1cHxWhvHa20cr7VZ7XjPNXJTpkYBJyQkRCEhIedV0Ll07NhR4eHhWr9+vSvQ5OXlacuWLa4rsfr376+cnBylp6crJiZGkrRhwwYZhqHY2FiP1AUAABoej10mvm/fPu3YsUP79u2T0+nUjh07tGPHDrfPrImOjtbatWslSTabTdOnT9eiRYv09ttv66uvvtKECRMUGRmpkSNHSpK6deumhIQETZkyRVu3btUnn3yixMREjR07ttpXUAEAAOvz2CTjuXPn6uWXX3YtX3LJJZKkjRs3asiQIZKkjIwM1xVNknTPPfcoPz9fU6dOVU5OjgYOHKiUlBT5+/u72qxatUqJiYkaOnSofHx8NGrUKD399NOeOowaczgcmjdvXrlTYlbF8Vobx2ttHK+1NbbjPZvHPwcHAACgrnEvKgAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEHAAAYDkEnFq0ZMkSdejQQf7+/oqNjdXWrVu9XZLHbN68Wddcc40iIyNls9n05ptverskj0pOTtall16qFi1aKDQ0VCNHjlRGRoa3y/KY559/Xr169XJ9Amr//v3173//29tl1YmHH37Y9blcVvXAAw/IZrO5PerbLXZq24EDBzR+/Hi1bt1aTZs2Vc+ePfXZZ595uyyP6NChQ7mfr81m07Rp07xdWp0i4NSSV155RUlJSZo3b562b9+u3r17Kz4+vtytJawiPz9fvXv31pIlS7xdSp346KOPNG3aNP33v/9VamqqiouLNWzYMOXn53u7NI+44IIL9PDDDys9PV2fffaZrrrqKl177bX65ptvvF2aR23btk0vvPCCevXq5e1SPO7iiy/WoUOHXI+PP/7Y2yV5zC+//KLLL79cvr6++ve//61vv/1WTzzxhIKDg71dmkds27bN7WebmpoqSRo9erSXK6tjJmpFv379zGnTprmWnU6nGRkZaSYnJ3uxqrohyVy7dq23y6hT2dnZpiTzo48+8nYpdSY4ONj861//6u0yPObYsWPmhRdeaKamppqDBw827777bm+X5DHz5s0ze/fu7e0y6sy9995rDhw40NtleM3dd99tdu7c2TQMw9ul1ClGcGpBUVGR0tPTFRcX51rn4+OjuLg4paWlebEyeErZJ3C3atXKy5V4ntPp1Jo1a5Sfn6/+/ft7uxyPmTZtmkaMGOH2d2xl33//vSIjI9WpUyeNGzdO+/bt83ZJHvP222+rb9++Gj16tEJDQ3XJJZfoxRdf9HZZdaKoqEj/+Mc/dNNNN8lms3m7nDpFwKkFR44ckdPpVFhYmNv6sLAwZWZmeqkqeIphGJo+fbouv/xy9ejRw9vleMxXX32l5s2by+Fw6LbbbtPatWvVvXt3b5flEWvWrNH27duVnJzs7VLqRGxsrFauXKmUlBQ9//zz2rNnj6644godO3bM26V5xA8//KDnn39eF154oT744APdfvvtuuuuu9xuJ2RVb775pnJycjRp0iRvl1LnPHYvKsCqpk2bpq+//trScxYkqWvXrtqxY4dyc3P1r3/9SxMnTtRHH31kuZCzf/9+3X333UpNTXW7752VDR8+3PV9r169FBsbq/bt2+vVV1/VzTff7MXKPMMwDPXt21cPPfSQpNJ7I3799ddaunSpJk6c6OXqPOull17S8OHDG+UNqRnBqQVt2rSR3W5XVlaW2/qsrCyFh4d7qSp4QmJiot59911t3LhRF1xwgbfL8Sg/Pz916dJFMTExSk5OVu/evfXUU095u6xal56eruzsbP3mN79RkyZN1KRJE3300Ud6+umn1aRJEzmdTm+X6HEtW7bURRddpF27dnm7FI+IiIgoF8y7detm6dNykvTjjz/qww8/1C233OLtUryCgFML/Pz8FBMTo/Xr17vWGYah9evXW3rOQmNimqYSExO1du1abdiwQR07dvR2SXXOMAwVFhZ6u4xaN3ToUH311VfasWOH69G3b1+NGzdOO3bskN1u93aJHnf8+HHt3r1bERER3i7FIy6//PJyH+vwv//9T+3bt/dSRXVjxYoVCg0N1YgRI7xdildwiqqWJCUlaeLEierbt6/69eunxYsXKz8/X5MnT/Z2aR5x/Phxt//t7dmzRzt27FCrVq3Url07L1bmGdOmTdPq1av11ltvqUWLFq65VUFBQWratKmXq6t9c+bM0fDhw9WuXTsdO3ZMq1ev1qZNm/TBBx94u7Ra16JFi3JzqZo1a6bWrVtbdo7VrFmzdM0116h9+/Y6ePCg5s2bJ7vdrhtvvNHbpXnEjBkzNGDAAD300EO64YYbtHXrVi1btkzLli3zdmkeYxiGVqxYoYkTJ6pJk0b6Vu/ty7is5JlnnjHbtWtn+vn5mf369TP/+9//erskj9m4caMpqdxj4sSJ3i7NIyo6VknmihUrvF2aR9x0001m+/btTT8/PzMkJMQcOnSouW7dOm+XVWesfpn4mDFjzIiICNPPz89s27atOWbMGHPXrl3eLsuj3nnnHbNHjx6mw+Ewo6OjzWXLlnm7JI/64IMPTElmRkaGt0vxGptpmqZ3ohUAAIBnMAcHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYDgEHAABYzv8HCBBHUz77KVAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "56\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "57\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "58\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGzCAYAAAAi6m1wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFX0lEQVR4nO3dd3xUVf7/8fekTQghBdKIhq5EpLlBIqgUyRKQdcVFBL/4o4igSFQIrJrdFaRo7IsFRV0B3YXFZRXFFolUSxYwiBWjKAgiKYBkSAIpM/f3B2ZgSIdMJrl5PR+PeSRz7rlnPneSMG/uPfdei2EYhgAAAEzEy9MFAAAA1DcCDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDoBqbdq0SRaLRZs2barXcS0Wi+6///56HdOs3PUzqC2Hw6Hu3bvrgQce8MjrVyYtLU2BgYHKy8vzdClopAg4aDaeffZZWSwWxcfHn/NY7777Lh/OtdAY36f7779fFoul0seSJUs8Wtuzzz6r5cuXe7SGyvz73//W/v37lZSUVOny2v5t5eTkaPbs2YqNjVVAQIBatmypuLg4LVy4UEePHnX2GzRoUJU/o2+//VaSNGzYMHXp0kWpqan1tp0wFx9PFwA0lBUrVqhDhw7atm2bdu/erS5dupz1WO+++64WL17c6D68G5vq3qfjx4/Lx8dz/wQ999xzCgwMdGmrj/B7Lp599lmFhYVp4sSJLu0DBgzQ8ePH5efn55G6Hn30UY0dO1bBwcGVLq/N39b27dt19dVXq6CgQDfddJPi4uIkSZ9++qkeeughbdmyRevWrXP2P//88ysNL9HR0c7vb731Vs2ePVvz5s1Tq1atznUzYTIEHDQLe/bs0SeffKLXX39dt956q1asWKG5c+d6uiy3KioqUkBAQIX2srIyORwOj31YlvP39/fo619//fUKCwvzaA215eXl5bH367PPPtPnn3+uxx9/vNLltfnbOnr0qK677jp5e3vrs88+U2xsrMvyBx54QC+++KJLW3BwsG666aZqaxs1apTuuOMOrV69WjfffPNZbB3MjENUaBZWrFih0NBQjRgxQtdff71WrFhRoU9V8xz27t0ri8XiPHQwceJELV68WJJcdp2XKyws1KxZsxQTEyOr1aquXbvqsccek2EYFV7zX//6l/r27auAgACFhoZqwIABLv+LlU7+r/7iiy+W1WpVdHS0pk+f7rI7Xzq5S7979+7KzMzUgAEDFBAQoL/85S/O2h977DEtWrRInTt3ltVq1TfffCNJ+vbbb3X99derdevW8vf3V58+fbR27doa388PP/xQo0ePVrt27WS1WhUTE6OZM2fq+PHjzj41vU+VzcH57LPPNHz4cAUFBSkwMFBDhgzR//73P5c+y5cvl8Vi0ccff6zk5GSFh4erZcuWuu666+plPsaZP+/TnVlz+eGu3bt3a+LEiQoJCVFwcLAmTZqkoqKiCutX9/Pu0KGDvv76a23evNn5Xg0aNEhS1b+bq1evVlxcnFq0aKGwsDDddNNNOnDggEufiRMnKjAwUAcOHNDIkSMVGBio8PBwzZ49W3a7vcb344033pCfn58GDBhQ6fLa/G09//zzOnDggJ544okK4UaSIiMj9be//a3GWs4UERGhnj176s0336zzujA/9uCgWVixYoX+9Kc/yc/PTzfeeKOee+45bd++XZdeemmdx7r11lv1yy+/KD09Xf/85z9dlhmGoT/+8Y/auHGjJk+erN69e+v999/Xn//8Zx04cEB///vfnX3nzZun+++/X/3799f8+fPl5+enrVu3asOGDRo6dKikkx+g8+bNU0JCgqZNm6asrCxn7R9//LF8fX2d4x0+fFjDhw/X2LFjddNNNykyMtK5bNmyZTpx4oSmTp0qq9Wq1q1b6+uvv9bll1+u8847T/fee69atmyp//znPxo5cqRee+01XXfddVW+B6tXr1ZRUZGmTZumNm3aaNu2bXr66af1888/a/Xq1TW+T5X5+uuvdeWVVyooKEh33323fH199fzzz2vQoEHavHlzhcNHd9xxh0JDQzV37lzt3btXixYtUlJSkl599dUaX0uSjhw54vLc29tboaGhtVr3TDfccIM6duyo1NRU7dixQ//4xz8UERGhhx9+2Nmnpp/3okWLdMcddygwMFB//etfJcnlZ3im5cuXa9KkSbr00kuVmpqqnJwcPfnkk/r444/12WefKSQkxNnXbrcrMTFR8fHxeuyxx/TBBx/o8ccfV+fOnTVt2rRqt+2TTz5R9+7dXX7XTlebv621a9eqRYsWuv7662vzdjprPnTokEubv79/hcOKcXFxeuONN2o9LpoRAzC5Tz/91JBkpKenG4ZhGA6Hwzj//PONu+66y6Xfxo0bDUnGxo0bXdr37NljSDKWLVvmbJs+fbpR2Z/PG2+8YUgyFi5c6NJ+/fXXGxaLxdi9e7dhGIbx/fffG15eXsZ1111n2O12l74Oh8MwDMPIzc01/Pz8jKFDh7r0eeaZZwxJxtKlS51tAwcONCQZS5YsqbT2oKAgIzc312XZkCFDjB49ehgnTpxwee3+/fsbF1xwQbXvS1FRUYVtT01NNSwWi/HTTz/V+D4ZhmFIMubOnet8PnLkSMPPz8/44YcfnG2//PKL0apVK2PAgAHOtmXLlhmSjISEBOd7ZRiGMXPmTMPb29s4evRopa9Xbu7cuYakCo/27dsbhlH5z7uqmsvHuvnmm136XXfddUabNm2cz2vz8zYMw7j44ouNgQMHVnjdM38GJSUlRkREhNG9e3fj+PHjzn5vv/22IcmYM2eOs23ChAmGJGP+/PkuY15yySVGXFxcpe/R6c4//3xj1KhRlS6r7d9WaGio0atXrxpfq1z57/OZjwkTJlTo++CDDxqSjJycnFqPj+aBQ1QwvRUrVigyMlKDBw+WdPIww5gxY7Rq1apa7aKvi3fffVfe3t668847XdpnzZolwzD03nvvSTq529/hcGjOnDny8nL9Myw/jPPBBx+opKREM2bMcOkzZcoUBQUF6Z133nFZz2q1atKkSZXWNWrUKIWHhzufHzlyRBs2bNANN9ygY8eO6dChQzp06JAOHz6sxMREff/99xUOdZyuRYsWzu8LCwt16NAh9e/fX4Zh6LPPPqvuLaqU3W7XunXrNHLkSHXq1MnZ3rZtW/3f//2fPvroI9lsNpd1pk6d6nLI68orr5TdbtdPP/1Uq9d87bXXlJ6e7nxUdmiltm677TaX51deeaUOHz7srLk2P++6+PTTT5Wbm6vbb7/dZW7OiBEjFBsbW+F3o6oaf/zxxxpf6/Dhw1Xu2art35bNZqvzJOAOHTq4/HzS09N19913V+hXXtuZe3sADlHB1Ox2u1atWqXBgwdrz549zvb4+Hg9/vjjWr9+vfNwUH346aefFB0dXeEf84suusi5XJJ++OEHeXl5qVu3btWOJUldu3Z1affz81OnTp0qfJCfd955VU4c7tixo8vz3bt3yzAM3XfffbrvvvsqXSc3N1fnnXdepcv27dunOXPmaO3atfr1119dluXn51e5TVXJy8tTUVFRhW2VTr53DodD+/fv18UXX+xsb9eunUu/8g+6M+upyoABA+ptknF1tQQFBdXq510XVf1uSFJsbKw++ugjlzZ/f3+XgFteY23fK6OS+WN1+dsKCgrSsWPHavVa5Vq2bKmEhIRa13Y2QRHmRsCBqW3YsEEHDx7UqlWrtGrVqgrLV6xY4fxHuKp/IOt7L4+7nL5XpaZlDodDkjR79mwlJiZWuk5Vp9Hb7Xb9/ve/15EjR3TPPfcoNjZWLVu21IEDBzRx4kTn2O7m7e1daXtlH8Z1cTa/B+6qpb5UVV9ttGnTptIgVJe/rdjYWO3cuVMlJSX1fvZeeW1N5Yw4NBwCDkxtxYoVioiIcJ7Nc7rXX39da9as0ZIlS9SiRQvn/7rPPEOpskMeVX0Itm/fXh988IGOHTvmshen/OJk7du3lyR17txZDodD33zzjXr37l3lWJKUlZXlctimpKREe/bsqdX/bqtSPp6vr2+dx/nyyy/13Xff6eWXX9b48eOd7enp6RX61vZ/1eHh4QoICFBWVlaFZd9++628vLwUExNTpzrPVl1+D2qrNj9vqfbv1+m/G1dddZXLsqysLOfy+hAbG+uyh6ZcXf62rrnmGmVkZOi1117TjTfeWG+1SSdPUw8LC6uwhwpgDg5M6/jx43r99df1hz/8Qddff32FR1JSko4dO+Y8Lbp9+/by9vbWli1bXMZ59tlnK4zdsmVLSRU/BK+++mrZ7XY988wzLu1///vfZbFYNHz4cEnSyJEj5eXlpfnz51fY41H+v/6EhAT5+fnpqaeectkT8NJLLyk/P18jRow4i3flpIiICA0aNEjPP/+8Dh48WGF5dadbl+8NOL0mwzD05JNPVuhb1ftU2ZhDhw7Vm2++qb179zrbc3JytHLlSl1xxRUKCgqqdoz6EhQUpLCwsFr9HtRWbX7e0sn3q6b3SpL69OmjiIgILVmyRMXFxc729957T7t27Tqn340z9evXT1999ZXL69T1b+u2225T27ZtNWvWLH333XcVXiM3N1cLFy48q/oyMzPVr1+/s9s4mBp7cGBaa9eu1bFjx/THP/6x0uWXXXaZwsPDtWLFCo0ZM0bBwcEaPXq0nn76aVksFnXu3Flvv/22cnNzK6xbfhXWO++8U4mJifL29tbYsWN1zTXXaPDgwfrrX/+qvXv3qlevXlq3bp3efPNNzZgxQ507d5Z08vDPX//6Vy1YsEBXXnml/vSnP8lqtWr79u2Kjo5WamqqwsPDlZKSonnz5mnYsGH64x//qKysLD377LO69NJLa7wIWk0WL16sK664Qj169NCUKVPUqVMn5eTkKCMjQz///LM+//zzSteLjY1V586dNXv2bB04cEBBQUF67bXXKj2MUdX7VJmFCxcqPT1dV1xxhW6//Xb5+Pjo+eefV3FxsR555JFz2ta6uuWWW/TQQw/plltuUZ8+fbRly5ZKP5hrqzY/b+nk+/Xcc89p4cKF6tKliyIiIirsoZFO7nl7+OGHNWnSJA0cOFA33nij8zTxDh06aObMmWdd65muvfZaLViwQJs3b3Yecqrr31ZoaKjWrFmjq6++Wr1793a5kvGOHTv073//+6xCSm5urr744gtNnz797DcQ5uWZk7cA97vmmmsMf39/o7CwsMo+EydONHx9fY1Dhw4ZhmEYeXl5xqhRo4yAgAAjNDTUuPXWW42vvvqqwmnDZWVlxh133GGEh4cbFovF5VToY8eOGTNnzjSio6MNX19f44ILLjAeffRRl9OByy1dutS45JJLDKvVaoSGhhoDBw50nnJb7plnnjFiY2MNX19fIzIy0pg2bZrx66+/uvQZOHCgcfHFF1cYv/yU50cffbTS7f/hhx+M8ePHG1FRUYavr69x3nnnGX/4wx+M//73v84+lZ0m/s033xgJCQlGYGCgERYWZkyZMsX4/PPP6/Q+6YxTrg3DMHbs2GEkJiYagYGBRkBAgDF48GDjk08+celTfpr49u3bXdqrOs3/TOWndufl5VXZp6ioyJg8ebIRHBxstGrVyrjhhhuM3NzcKk8TP3Os8hr37Nnj0l7Tzzs7O9sYMWKE0apVK0OS85Txqrbt1VdfdY7XunVrY9y4ccbPP//s0mfChAlGy5Ytq3wfaqNnz57G5MmTnc/P5m/LME6e9j9z5kzjwgsvNPz9/Y2AgAAjLi7OeOCBB4z8/Hxnv6p+n8/03HPPGQEBAYbNZqvVdqB5sRhGI5kFBwBolP75z39q+vTp2rdvn8sFBD3tkksu0aBBg1wuoAmUYw4OAKBa48aNU7t27SqdUOwpaWlp+v7775WSkuLpUtBIsQcHAACYDntwAACA6bg14GzZskXXXHONoqOjZbFYanVDtE2bNul3v/udrFarunTpUukdfRcvXqwOHTrI399f8fHx2rZtW/0XDwAAmiy3BpzCwkL16tWr1sdt9+zZoxEjRmjw4MHauXOnZsyYoVtuuUXvv/++s8+rr76q5ORkzZ07Vzt27FCvXr2UmJhY6am8AACgeWqwOTgWi0Vr1qzRyJEjq+xzzz336J133tFXX33lbBs7dqyOHj2qtLQ0SSfvc3LppZc6L6TmcDgUExOjO+64Q/fee69btwEAADQNjepCfxkZGRUuG5+YmKgZM2ZIOnmJ+szMTJdZ815eXkpISFBGRkaV4xYXF7tchdPhcOjIkSNq06YNN2gDAKCJMAxDx44dU3R0tLy8qj8I1agCTnZ2tiIjI13aIiMjZbPZdPz4cf3666+y2+2V9im/109lUlNTNW/ePLfUDAAAGtb+/ft1/vnnV9unUQUcd0lJSVFycrLzeX5+vtq1a6f9+/fXy/1t/p7+nZZ/sld2R8Wjfd5eFk3s30Ezf3/hOb8OAADNmc1mU0xMjMvNjKvSqAJOVFSUcnJyXNpycnIUFBSkFi1ayNvbW97e3pX2iYqKqnJcq9Uqq9VaoT0oKKheAs74gRfp5U9z5FXJbCaLRZow8CIFBbU859cBAACq1fSSRnUdnH79+mn9+vUubenp6c6bsPn5+SkuLs6lj8Ph0Pr16z16N9mOYS318Kie8jrt/fa2WORlkR4e1VMdwgg3AAA0JLfuwSkoKNDu3budz/fs2aOdO3eqdevWateunVJSUnTgwAG98sorkqTbbrtNzzzzjO6++27dfPPN2rBhg/7zn//onXfecY6RnJysCRMmqE+fPurbt68WLVqkwsJCTZo0yZ2bUqPRfWLU/bwgDX/yI0nSpCs66Kb49oQbAAA8wK0B59NPP9XgwYOdz8vnwUyYMEHLly/XwYMHtW/fPufyjh076p133tHMmTP15JNP6vzzz9c//vEPJSYmOvuMGTNGeXl5mjNnjrKzs9W7d2+lpaVVmHjsCe3bnAozyb+/UAF+jeoIIAAAzUazvBeVzWZTcHCw8vPz62UOTrmikjJ1m3PyooTfzE8k4AAAUI/q8vndqObgAAAA1AcCDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB3uJQAAAM6aYRgqLnPoRKnd+TXAz0fhrawerYuAAwAAqmV3GC4B5uTDoeKyk21n3tUyOsRfEgEHAAB4WKnd4Qwup4eZ4jK7Ssqa3n25CTgAADQD5YeSiksdOlFmd34tDzV2R9MLMdUh4AAAYBIOh3FGeDl1SKmyQ0lmRsABAKAJKbU7Kp0Lc6LUoZIyh6fLazQIOAAANDLlgaXYZWLvyb0yZfZmtBvmHBBwAABoYA5HxVOrT5wWakw2HcYjCDgAALhB2emHkspc58KUNLP5MJ5AwAEA4CyVlJ06E6n4tLkwJ0rtKuVQkkcRcAAAqMLpV+k9cUaAKS4z36nVZkLAAQA0a3W9Si+aBgIOAMD0yg8lFZeeujpveYhpilfpRc0IOACAJq98Qu/pZyYVc1ZSs0bAAQA0eg6HoRL7aeHltNsNFJcxoRcVEXAAAI1C+ZyXU2ckndoLU2pnLgzqhoADAGgQZXaHTpS5Xp23/LASh5FQ3wg4AIB6UX513tMn8J4eZLjFABoSAQcAUCuGUT4P5rfwUnp6mOFGj2hcCDgAAKfyO1UX/3Z7gdMPJ5WUOTiMhCaDgANA0sn5EWUOQ3aHcdrX5jmxs6ZtNlTzm1LzGLWp49xfpyb20w4rcRgJZkLAAUyiqoBidxgqs1fR/ttzu8NolkEGgHkRcIBGokLwsFceSMrsBBQAqAkBB6gntQ0orntUTrUTUACg/hBwgBqU2R0qKrXrRIldRSV2ldgdBBQAaOS8GuJFFi9erA4dOsjf31/x8fHatm1blX0HDRoki8VS4TFixAhnn4kTJ1ZYPmzYsIbYFJhYmd0h24lS5dpOaO+hQn3zi02ZP/2q7Xt/1dcHbPohr1AH80/ocEGJ8o+XqqC47LcrrBJuAKCxcfsenFdffVXJyclasmSJ4uPjtWjRIiUmJiorK0sREREV+r/++usqKSlxPj98+LB69eql0aNHu/QbNmyYli1b5nxutVrdtxEwlTP3yBSV2HX8t1NgAQDm4PaA88QTT2jKlCmaNGmSJGnJkiV65513tHTpUt17770V+rdu3drl+apVqxQQEFAh4FitVkVFRbmvcDR5ZXaHjpfadZwgAwDNjlsDTklJiTIzM5WSkuJs8/LyUkJCgjIyMmo1xksvvaSxY8eqZcuWLu2bNm1SRESEQkNDddVVV2nhwoVq06ZNpWMUFxeruLjY+dxms53F1qCxOjPIHC/9ba4MQQYAmi23BpxDhw7JbrcrMjLSpT0yMlLffvttjetv27ZNX331lV566SWX9mHDhulPf/qTOnbsqB9++EF/+ctfNHz4cGVkZMjb27vCOKmpqZo3b965bQw8jiADAKitRn0W1UsvvaQePXqob9++Lu1jx451ft+jRw/17NlTnTt31qZNmzRkyJAK46SkpCg5Odn53GazKSYmxn2F45wQZAAA58qtAScsLEze3t7Kyclxac/Jyalx/kxhYaFWrVql+fPn1/g6nTp1UlhYmHbv3l1pwLFarUxCboQIMgAAd3FrwPHz81NcXJzWr1+vkSNHSpIcDofWr1+vpKSkatddvXq1iouLddNNN9X4Oj///LMOHz6stm3b1kfZqGenB5nyEEOQAQC4k9sPUSUnJ2vChAnq06eP+vbtq0WLFqmwsNB5VtX48eN13nnnKTU11WW9l156SSNHjqwwcbigoEDz5s3TqFGjFBUVpR9++EF33323unTposTERHdvDqpBkAEANBZuDzhjxoxRXl6e5syZo+zsbPXu3VtpaWnOicf79u2Tl5fr9QazsrL00Ucfad26dRXG8/b21hdffKGXX35ZR48eVXR0tIYOHaoFCxZwGKqB2B2GikrKCDIAgEbLYhjN7xqsNptNwcHBys/PV1BQUL2NW1RSpm5z3pckfTM/UQF+jXoOd40IMgCAsxEd4q/2bVrW3LGO6vL53bQ/gVEvCDIAALMh4DQjziBzxtV9CTIAALMh4JhQZUHmeKldxaUEGQBA80DAMYmikjL9dLiIIAMAgAg4plFc6tDRolJPlwEAQKPgVXMXAACApoWAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATKdBAs7ixYvVoUMH+fv7Kz4+Xtu2bauy7/Lly2WxWFwe/v7+Ln0Mw9CcOXPUtm1btWjRQgkJCfr+++/dvRkAAKCJcHvAefXVV5WcnKy5c+dqx44d6tWrlxITE5Wbm1vlOkFBQTp48KDz8dNPP7ksf+SRR/TUU09pyZIl2rp1q1q2bKnExESdOHHC3ZsDAACaALcHnCeeeEJTpkzRpEmT1K1bNy1ZskQBAQFaunRpletYLBZFRUU5H5GRkc5lhmFo0aJF+tvf/qZrr71WPXv21CuvvKJffvlFb7zxhrs3BwAANAFuDTglJSXKzMxUQkLCqRf08lJCQoIyMjKqXK+goEDt27dXTEyMrr32Wn399dfOZXv27FF2drbLmMHBwYqPj69yzOLiYtlsNpcHAAAwL7cGnEOHDslut7vsgZGkyMhIZWdnV7pO165dtXTpUr355pv617/+JYfDof79++vnn3+WJOd6dRkzNTVVwcHBzkdMTMy5bhoAAGjEGt1ZVP369dP48ePVu3dvDRw4UK+//rrCw8P1/PPPn/WYKSkpys/Pdz72799fjxUDAIDGxq0BJywsTN7e3srJyXFpz8nJUVRUVK3G8PX11SWXXKLdu3dLknO9uoxptVoVFBTk8gAAAObl1oDj5+enuLg4rV+/3tnmcDi0fv169evXr1Zj2O12ffnll2rbtq0kqWPHjoqKinIZ02azaevWrbUeEwAAmJuPu18gOTlZEyZMUJ8+fdS3b18tWrRIhYWFmjRpkiRp/PjxOu+885SamipJmj9/vi677DJ16dJFR48e1aOPPqqffvpJt9xyi6STZ1jNmDFDCxcu1AUXXKCOHTvqvvvuU3R0tEaOHOnuzQEAAE2A2wPOmDFjlJeXpzlz5ig7O1u9e/dWWlqac5Lwvn375OV1akfSr7/+qilTpig7O1uhoaGKi4vTJ598om7dujn73H333SosLNTUqVN19OhRXXHFFUpLS6twQUAAANA8WQzDMDxdREOz2WwKDg5Wfn5+vc7HKSopU7c570uSvpmfqAA/t+dHp18LS/Rt9rEGez0AAKoSHeKv9m1a1vu4dfn8bnRnUQEAAJwrAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdH08XgKbrYP5xbcrKU15BscIDrRrUNVxtg1t4uiwAAAg4ODubsnL1woc/yiLJkGSR9NYXv+jWAZ008MIID1cHAGjuOESFOjuYf1wvfPijDENyGHL5+vyWH5Wdf8LTJQIAmjkCDupsU1aeLFUss0jamJXbkOUAAFABAQd1lldQLKOKZcZvywEA8CQCDuosPNBa7R6c8EBrQ5YDAEAFBBzU2aCu4dXuwRnclUnGAADPIuCgztoGt9CtAzrJctpuHC+LZLFItw7opKhgf88VBwCAOE0cZ2nghRHq0Kal7n39S0nSsO5R+v1FUYQbAECjQMDBWYsMOhVmRsfFyN/X24PVAABwCoeoAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6TRIwFm8eLE6dOggf39/xcfHa9u2bVX2ffHFF3XllVcqNDRUoaGhSkhIqNB/4sSJslgsLo9hw4a5ezMAAEAT4faA8+qrryo5OVlz587Vjh071KtXLyUmJio3N7fS/ps2bdKNN96ojRs3KiMjQzExMRo6dKgOHDjg0m/YsGE6ePCg8/Hvf//b3ZsCAACaCLcHnCeeeEJTpkzRpEmT1K1bNy1ZskQBAQFaunRppf1XrFih22+/Xb1791ZsbKz+8Y9/yOFwaP369S79rFaroqKinI/Q0FB3bwoAAGgi3BpwSkpKlJmZqYSEhFMv6OWlhIQEZWRk1GqMoqIilZaWqnXr1i7tmzZtUkREhLp27app06bp8OHDVY5RXFwsm83m8gAAAObl1oBz6NAh2e12RUZGurRHRkYqOzu7VmPcc889io6OdglJw4YN0yuvvKL169fr4Ycf1ubNmzV8+HDZ7fZKx0hNTVVwcLDzERMTc/YbBQAAGj0fTxdQnYceekirVq3Spk2b5O/v72wfO3as8/sePXqoZ8+e6ty5szZt2qQhQ4ZUGCclJUXJycnO5zabjZADAICJuXUPTlhYmLy9vZWTk+PSnpOTo6ioqGrXfeyxx/TQQw9p3bp16tmzZ7V9O3XqpLCwMO3evbvS5VarVUFBQS4PAABgXm4NOH5+foqLi3OZIFw+Ybhfv35VrvfII49owYIFSktLU58+fWp8nZ9//lmHDx9W27Zt66VuAADQtLn9LKrk5GS9+OKLevnll7Vr1y5NmzZNhYWFmjRpkiRp/PjxSklJcfZ/+OGHdd9992np0qXq0KGDsrOzlZ2drYKCAklSQUGB/vznP+t///uf9u7dq/Xr1+vaa69Vly5dlJiY6O7NAQAATYDb5+CMGTNGeXl5mjNnjrKzs9W7d2+lpaU5Jx7v27dPXl6nctZzzz2nkpISXX/99S7jzJ07V/fff7+8vb31xRdf6OWXX9bRo0cVHR2toUOHasGCBbJare7eHAAA0AQ0yCTjpKQkJSUlVbps06ZNLs/37t1b7VgtWrTQ+++/X0+VAQAAM+JeVAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHR8PF0AADQGB/OPa1NWnvIKihUeaNWgruFqG9zC02UBOEsEHADN3qasXL3w4Y+ySDIkWSS99cUvunVAJw28MMLD1QE4GxyiAtCsHcw/rhc+/FGGITkMuXx9fsuPys4/4ekSAZwFAg6AZm1TVp4sVSyzSNqYlduQ5QCoJwQcAM1aXkGxjCqWGb8tB9D0EHAANGvhgdZq9+CEB1obshwA9aRBAs7ixYvVoUMH+fv7Kz4+Xtu2bau2/+rVqxUbGyt/f3/16NFD7777rstywzA0Z84ctW3bVi1atFBCQoK+//57d24CAJMa1DW82j04g7syyRhoitx+FtWrr76q5ORkLVmyRPHx8Vq0aJESExOVlZWliIiK/3B88sknuvHGG5Wamqo//OEPWrlypUaOHKkdO3aoe/fukqRHHnlETz31lF5++WV17NhR9913nxITE/XNN9/I39+/1rUVlZTJp6Ss3ra16LSxiupx3No4XmLXiVJ7g75m8WmvV9zArw33y7ad0Iff5+lwQYnaBPrpygvCFRVU+7+vpiI0wE839++opR/vcQYdL8vJcHNz/44KCfBt8L8toKk7XmJ3y+dgXca0GIZR1X9e6kV8fLwuvfRSPfPMM5Ikh8OhmJgY3XHHHbr33nsr9B8zZowKCwv19ttvO9suu+wy9e7dW0uWLJFhGIqOjtasWbM0e/ZsSVJ+fr4iIyO1fPlyjR07tsKYxcXFKi4+dRzdZrMpJiZGMTP+Iy9rQH1vMgAAcANHcZH2L7pB+fn5CgoKqravWw9RlZSUKDMzUwkJCade0MtLCQkJysjIqHSdjIwMl/6SlJiY6Oy/Z88eZWdnu/QJDg5WfHx8lWOmpqYqODjY+YiJiTnXTQMAAI2YWw9RHTp0SHa7XZGRkS7tkZGR+vbbbytdJzs7u9L+2dnZzuXlbVX1OVNKSoqSk5Odz8v34Gz765AaE2BTcbSwVFk5xzxdhqkVl9p124odkqQl434nq6+3hytyj9WZ+5X2VbYclezb9bJIw7pHaXQc/0lo6prL73M5trdht7dtsL/atan/IyQ2m01tF9Wub7O4krHVapXVWvFMiAA/HwX4meMtKC51yN/kf7CNidXX27Tv969FpdVOuv21qNS0295cmfn3uTJsr/u18PN2y+drWR3GdOshqrCwMHl7eysnJ8elPScnR1FRUZWuExUVVW3/8q91GRNA7XHaNAAzcGvA8fPzU1xcnNavX+9sczgcWr9+vfr161fpOv369XPpL0np6enO/h07dlRUVJRLH5vNpq1bt1Y5JoDa47RpAGbg9uvgJCcn68UXX9TLL7+sXbt2adq0aSosLNSkSZMkSePHj1dKSoqz/1133aW0tDQ9/vjj+vbbb3X//ffr008/VVJSkiTJYrFoxowZWrhwodauXasvv/xS48ePV3R0tEaOHOnuzQFMr21wC906oJMslpNzbk7/euuATooKNt+p4gDMx+0TUMaMGaO8vDzNmTNH2dnZ6t27t9LS0pyThPft2ycvr1M5q3///lq5cqX+9re/6S9/+YsuuOACvfHGG85r4EjS3XffrcLCQk2dOlVHjx7VFVdcobS0tDpdAwdA1QZeGKGukUHamJWrvIJihQdaNbhrBOEGQJPRIDNsk5KSnHtgzrRp06YKbaNHj9bo0aOrHM9isWj+/PmaP39+fZUI4AxRwf66sW87T5cBAGeFe1EBAADTIeAAAADTIeAAAADTIeAAAGAy2bYTzu9XZ+7XwfzjHqzGMwg4AACYyKasXP1lzZfO52lfZWvW6s+1+btcD1bV8Ag4AACYxMH843rhwx9lnHa1TochGYb0/JYflZ1/ouqVTYaAAwCASWzKyqv2Visbs5rPXhwCDgAAJpFXUFztrVbyCoobshyPIuAAAGAS3Cz3FAIOAAAmwc1yTyHgAABgEtws95QGuRcVAABoGNws9yQCDgAAJsPNcjlEBQAATIiAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAAwAATIeAA9RStu2E8/vVmft1MP+4B6sBAFSHgAPUwqasXP1lzZfO52lfZWvW6s+1+btcD1YFAKgKAQeowcH843rhwx9lGKfaHIZkGNLzW35Udv6JqlcGAHgEAQeowaasPFmqWGaRtDGLvTgA0NgQcIAa5BUUy6himfHbcgBA40LAAWoQHmitdg9OeKC1IcsBANQCAQeowaCu4dXuwRncNaIhywEA1AIBB6hB2+AWunVAJ1kskpdFLl9vHdBJUcH+ni4RAHAGH08XADQFAy+MUNfIIG3MylVeQbHCA60a3DWCcAMAjRQBB6ilqGB/3di3nafLAADUAoeoAACA6RBwAACA6RBwAACA6bg14Bw5ckTjxo1TUFCQQkJCNHnyZBUUFFTb/4477lDXrl3VokULtWvXTnfeeafy8/Nd+lkslgqPVatWuXNTAABAE+LWScbjxo3TwYMHlZ6ertLSUk2aNElTp07VypUrK+3/yy+/6JdfftFjjz2mbt266aefftJtt92mX375Rf/9739d+i5btkzDhg1zPg8JCXHnpgAAgCbEbQFn165dSktL0/bt29WnTx9J0tNPP62rr75ajz32mKKjoyus0717d7322mvO5507d9YDDzygm266SWVlZfLxOVVuSEiIoqKi3FU+AABowtx2iCojI0MhISHOcCNJCQkJ8vLy0tatW2s9Tn5+voKCglzCjSRNnz5dYWFh6tu3r5YuXSrDqOpas1JxcbFsNpvLAwCas2zbCef3qzP362D+cQ9WA9Q/t+3Byc7OVkSE6yXsfXx81Lp1a2VnZ9dqjEOHDmnBggWaOnWqS/v8+fN11VVXKSAgQOvWrdPtt9+ugoIC3XnnnZWOk5qaqnnz5p3dhgCAyWzKytULH/7ofJ72Vbbe+ypbtw7opIEXcusRmEOd9+Dce++9lU7yPf3x7bffnnNhNptNI0aMULdu3XT//fe7LLvvvvt0+eWX65JLLtE999yju+++W48++miVY6WkpCg/P9/52L9//znXBwBN0cH843rhwx91+k5vhyEZhvT8lh+VnX+i6pWBJqTOe3BmzZqliRMnVtunU6dOioqKUm5urkt7WVmZjhw5UuPcmWPHjmnYsGFq1aqV1qxZI19f32r7x8fHa8GCBSouLpbVWvHOzlartdJ2AGhuNmXlySJVegNZi6SNWblcsRumUOeAEx4ervDw8Br79evXT0ePHlVmZqbi4uIkSRs2bJDD4VB8fHyV69lsNiUmJspqtWrt2rXy96/5Xj87d+5UaGgoIQYAapBXUFxpuJFOhp68guKGLAdwG7fNwbnooos0bNgwTZkyRUuWLFFpaamSkpI0duxY5xlUBw4c0JAhQ/TKK6+ob9++stlsGjp0qIqKivSvf/3LZUJweHi4vL299dZbbyknJ0eXXXaZ/P39lZ6ergcffFCzZ89216YAgGmEB1qr3YMTHsh/FGEObr0OzooVK5SUlKQhQ4bIy8tLo0aN0lNPPeVcXlpaqqysLBUVFUmSduzY4TzDqkuXLi5j7dmzRx06dJCvr68WL16smTNnyjAMdenSRU888YSmTJnizk0BAFMY1DVcb33xS6XLDEmDuzLJGOZgMao7v9qkbDabgoODnaegm8GvhSX6NvuYp8sA0ARs/i5Xz2/50bknp/yrmc+iOlFq16Tl2yVJyyZeKn9fbw9XZG7RIf5q36ZlvY9bl89vt+7BAQA0PgMvjFDXyCBtzMpVXkGxwgOtGtw1QlHBNc95BJoKAg4ANENRwf6cLQVT427iAADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADTy7aduono6sz9Oph/3IPVoCEQcAAAprYpK1d/WfOl83naV9matfpzbf4ut5q10NQRcAAApnUw/7he+PBHnX7NfochGYb0/JYflZ1/ouqV0aQRcAAAprUpK0+WKpZZJG3MYi+OWRFwAACmlVdQXOmd06WT99/KKyhuyHLQgAg4AADTCg+0VrsHJzzQ2pDloAERcAAApjWoa3i1e3AGdzXn3dNBwAEAmFjb4Ba6dUAnWSySl0UuX28d0Ik7qJsYdxMHAJjawAsj1DUySBuzcpVXUKzwQKsGd40g3JgcAQcAYHpRwf66sW87T5eBBsQhKgAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDpuDThHjhzRuHHjFBQUpJCQEE2ePFkFBQXVrjNo0CBZLBaXx2233ebSZ9++fRoxYoQCAgIUERGhP//5zyorK3PnpgAAgCbEx52Djxs3TgcPHlR6erpKS0s1adIkTZ06VStXrqx2vSlTpmj+/PnO5wEBAc7v7Xa7RowYoaioKH3yySc6ePCgxo8fL19fXz344INu2xYAANB0uC3g7Nq1S2lpadq+fbv69OkjSXr66ad19dVX67HHHlN0dHSV6wYEBCgqKqrSZevWrdM333yjDz74QJGRkerdu7cWLFige+65R/fff7/8/Pzcsj0AAKDpcNshqoyMDIWEhDjDjSQlJCTIy8tLW7durXbdFStWKCwsTN27d1dKSoqKiopcxu3Ro4ciIyOdbYmJibLZbPr6668rHa+4uFg2m83lAQAAzMtte3Cys7MVERHh+mI+PmrdurWys7OrXO///u//1L59e0VHR+uLL77QPffco6ysLL3++uvOcU8PN5Kcz6saNzU1VfPmzTuXzQEAAE1InQPOvffeq4cffrjaPrt27TrrgqZOner8vkePHmrbtq2GDBmiH374QZ07dz6rMVNSUpScnOx8brPZFBMTc9Y1AgCAxq3OAWfWrFmaOHFitX06deqkqKgo5ebmurSXlZXpyJEjVc6vqUx8fLwkaffu3ercubOioqK0bds2lz45OTmSVOW4VqtVVqu11q8JAACatjoHnPDwcIWHh9fYr1+/fjp69KgyMzMVFxcnSdqwYYMcDocztNTGzp07JUlt27Z1jvvAAw8oNzfXeQgsPT1dQUFB6tatWx23BgAAmJHbJhlfdNFFGjZsmKZMmaJt27bp448/VlJSksaOHes8g+rAgQOKjY117pH54YcftGDBAmVmZmrv3r1au3atxo8frwEDBqhnz56SpKFDh6pbt276f//v/+nzzz/X+++/r7/97W+aPn06e2kAAIAkN1/ob8WKFYqNjdWQIUN09dVX64orrtALL7zgXF5aWqqsrCznWVJ+fn764IMPNHToUMXGxmrWrFkaNWqU3nrrLec63t7eevvtt+Xt7a1+/frppptu0vjx412umwMAAJo3i2EYhqeLaGg2m03BwcHKz89XUFCQp8upF78Wlujb7GOeLgMAAEWH+Kt9m5b1Pm5dPr+5FxUAADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAo5JWH291CbQTwF+3rJYPF0NAACe5ePpAlA/Avx8dGFkK0mSYRg6XmrX8RK7ikrszu+Pl9plGB4uFACABkDAMSGLxaIAPx8F+PmozWntlQWfohK7ThB8AAAmQ8BpRmoKPkUlp/b0EHwAAE0ZAQcuwed0BB8AQFNFwEGVqgo+DoehE2UEHwBA40XAQZ15eRF8AACNm1tPEz9y5IjGjRunoKAghYSEaPLkySooKKiy/969e2WxWCp9rF692tmvsuWrVq1y56agFsqDT1igVTGtA3RhZCv1jglR3w6t1SsmWBdEBur80BZqE+inFpzODgBwI7fuwRk3bpwOHjyo9PR0lZaWatKkSZo6dapWrlxZaf+YmBgdPHjQpe2FF17Qo48+quHDh7u0L1u2TMOGDXM+DwkJqff6UT/Y4wMAaGhuCzi7du1SWlqatm/frj59+kiSnn76aV199dV67LHHFB0dXWEdb29vRUVFubStWbNGN9xwgwIDA13aQ0JCKvRF00LwAQC4i9sOUWVkZCgkJMQZbiQpISFBXl5e2rp1a63GyMzM1M6dOzV58uQKy6ZPn66wsDD17dtXS5culVHNJ19xcbFsNpvLA40Xh7oAAOfKbXtwsrOzFRER4fpiPj5q3bq1srOzazXGSy+9pIsuukj9+/d3aZ8/f76uuuoqBQQEaN26dbr99ttVUFCgO++8s9JxUlNTNW/evLPbEDQa7PEBANRWnQPOvffeq4cffrjaPrt27TrrgsodP35cK1eu1H333Vdh2eltl1xyiQoLC/Xoo49WGXBSUlKUnJzsfG6z2RQTE3PONaJxqC74HC+1V7h6M8EHAMyvzgFn1qxZmjhxYrV9OnXqpKioKOXm5rq0l5WV6ciRI7WaO/Pf//5XRUVFGj9+fI194+PjtWDBAhUXF8tqtVZYbrVaK22HuXl5WdTS6qOWVoIPADQ3dQ444eHhCg8Pr7Ffv379dPToUWVmZiouLk6StGHDBjkcDsXHx9e4/ksvvaQ//vGPtXqtnTt3KjQ0lBCDWiH4AID5uW0OzkUXXaRhw4ZpypQpWrJkiUpLS5WUlKSxY8c6z6A6cOCAhgwZoldeeUV9+/Z1rrt7925t2bJF7777boVx33rrLeXk5Oiyyy6Tv7+/0tPT9eCDD2r27Nnu2hQ0E7UNPsVlDtkdhsoc5V8N2X97EIQAoHFw63VwVqxYoaSkJA0ZMkReXl4aNWqUnnrqKefy0tJSZWVlqaioyGW9pUuX6vzzz9fQoUMrjOnr66vFixdr5syZMgxDXbp00RNPPKEpU6a4c1PQjFUVfCpTZnc4A8+pr78FIXsV7eXP7aQjAKgvFqO686tNymazKTg4WPn5+QoKCvJ0OYCkkzc3dQ1AFQPSybaTIerMwGR3NLs/ZQCNVHSIv9q3aVnv49bl85t7UQGNhMVikY+3RT7eZ7e+YZwRjuyV7CUiIAFoJgg4gElYLBb5elvkW88BqTnmHkM1bHQt3pOautRm33mNddRinJpGcDgMFZfZdaLUoeIyh0rKHDUXBjQBBBwAks49IMEcTgYex2mh5+TE+hOlJ78yVwxNBQEHAODk5WVRCz9vtfCrPOmW2R06UeZQcalr8Cn+ra057vFD40TAAQDUmo+3lwK9vRRYxVmFLnt8fjvsVR6CSu0OLqWABkPAAQDUG6uPt6w+3gry962w7PTDXy57f0odOlFm5/AX6hUBBwDQIGpz+OvMw16nQhCHv1A3BBwAQKPg4+0lH2+vKi+qWVJ2ck9PcWnFSdAlZRz+gisCDgCgSfDz8ZKfj5fkX3GZw2GoxH7qcNeZIaiUw1/NDgEHANDkeXlZ5O/lLX9fbwWr4vwfu8NwHu468dtNdE8/BMbeH/Mh4AAATM/beU+5issMw3CZ7HwyAJ3aA8RVvpsmAg4AoFmzWCzy961670/53J9Tp76fDD4nSjn01ZgRcAAAqEb53J/KTn0vP/R1otTuvADiid/2BDHx2bMIOAAAnKVTh74qfpyWH/oqP+R1MgSd3At0gtPe3Y6AAwCAG5x+6KsyLqe6lzpc5v5w6OvcEXAAAPCA8qs+q5J5P+X3/DrzzK8TpdzxvbYIOAAANDLV3fOr/JYX5Ye8Tj/jiys+n0LAAQCgCanulhfOU97PmPBcvieoOd3vi4ADAIBJuMz7aVHx0Fep3VHhOj8nw49dJWXmCj8EHAAAmglfby/5enupVSW3u7A7jDNCj+tVn5vaKe8EHAAAIG8viwL8fBTgV3FZU7zaMwEHAABUq7ZXey4/3T2gkvlBDY2AAwAAzkl1d3r3FC9PFwAAAFDfCDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB0CDgAAMB03BZwHnjgAfXv318BAQEKCQmp1TqGYWjOnDlq27atWrRooYSEBH3//fcufY4cOaJx48YpKChIISEhmjx5sgoKCtywBQAAoKlyW8ApKSnR6NGjNW3atFqv88gjj+ipp57SkiVLtHXrVrVs2VKJiYk6ceKEs8+4ceP09ddfKz09XW+//ba2bNmiqVOnumMTAABAE2UxDMNw5wssX75cM2bM0NGjR6vtZxiGoqOjNWvWLM2ePVuSlJ+fr8jISC1fvlxjx47Vrl271K1bN23fvl19+vSRJKWlpenqq6/Wzz//rOjo6FrVZLPZFBwcrPz8fAUFBZ3T9gEAgIZRl89vnwaqqUZ79uxRdna2EhISnG3BwcGKj49XRkaGxo4dq4yMDIWEhDjDjSQlJCTIy8tLW7du1XXXXVfp2MXFxSouLnY+z8/Pl3TyjQIAAE1D+ed2bfbNNJqAk52dLUmKjIx0aY+MjHQuy87OVkREhMtyHx8ftW7d2tmnMqmpqZo3b16F9piYmHMtGwAANLBjx44pODi42j51Cjj33nuvHn744Wr77Nq1S7GxsXUZ1u1SUlKUnJzsfO5wOHTkyBG1adNGFoulXl/LZrMpJiZG+/fvbxaHv9hec2N7zY3tNTczbq9hGDp27FitpqTUKeDMmjVLEydOrLZPp06d6jKkU1RUlCQpJydHbdu2dbbn5OSod+/ezj65ubku65WVlenIkSPO9StjtVpltVpd2mp7ZtfZCgoKMs0vVG2wvebG9pob22tuZtvemvbclKtTwAkPD1d4ePhZFVSTjh07KioqSuvXr3cGGpvNpq1btzrPxOrXr5+OHj2qzMxMxcXFSZI2bNggh8Oh+Ph4t9QFAACaHredJr5v3z7t3LlT+/btk91u186dO7Vz506Xa9bExsZqzZo1kiSLxaIZM2Zo4cKFWrt2rb788kuNHz9e0dHRGjlypCTpoosu0rBhwzRlyhRt27ZNH3/8sZKSkjR27Nhan0EFAADMz22TjOfMmaOXX37Z+fySSy6RJG3cuFGDBg2SJGVlZTnPaJKku+++W4WFhZo6daqOHj2qK664QmlpafL393f2WbFihZKSkjRkyBB5eXlp1KhReuqpp9y1GXVmtVo1d+7cCofEzIrtNTe219zYXnNrbtt7JrdfBwcAAKChcS8qAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgScerR48WJ16NBB/v7+io+P17Zt2zxdktts2bJF11xzjaKjo2WxWPTGG294uiS3Sk1N1aWXXqpWrVopIiJCI0eOVFZWlqfLcpvnnntOPXv2dF4BtV+/fnrvvfc8XVaDeOihh5zX5TKr+++/XxaLxeXR2G6xU98OHDigm266SW3atFGLFi3Uo0cPffrpp54uyy06dOhQ4edrsVg0ffp0T5fWoAg49eTVV19VcnKy5s6dqx07dqhXr15KTEyscGsJsygsLFSvXr20ePFiT5fSIDZv3qzp06frf//7n9LT01VaWqqhQ4eqsLDQ06W5xfnnn6+HHnpImZmZ+vTTT3XVVVfp2muv1ddff+3p0txq+/btev7559WzZ09Pl+J2F198sQ4ePOh8fPTRR54uyW1+/fVXXX755fL19dV7772nb775Ro8//rhCQ0M9XZpbbN++3eVnm56eLkkaPXq0hytrYAbqRd++fY3p06c7n9vtdiM6OtpITU31YFUNQ5KxZs0aT5fRoHJzcw1JxubNmz1dSoMJDQ01/vGPf3i6DLc5duyYccEFFxjp6enGwIEDjbvuusvTJbnN3LlzjV69enm6jAZzzz33GFdccYWny/CYu+66y+jcubPhcDg8XUqDYg9OPSgpKVFmZqYSEhKcbV5eXkpISFBGRoYHK4O7lF+Bu3Xr1h6uxP3sdrtWrVqlwsJC9evXz9PluM306dM1YsQIl79jM/v+++8VHR2tTp06ady4cdq3b5+nS3KbtWvXqk+fPho9erQiIiJ0ySWX6MUXX/R0WQ2ipKRE//rXv3TzzTfLYrF4upwGRcCpB4cOHZLdbldkZKRLe2RkpLKzsz1UFdzF4XBoxowZuvzyy9W9e3dPl+M2X375pQIDA2W1WnXbbbdpzZo16tatm6fLcotVq1Zpx44dSk1N9XQpDSI+Pl7Lly9XWlqannvuOe3Zs0dXXnmljh075unS3OLHH3/Uc889pwsuuEDvv/++pk2bpjvvvNPldkJm9cYbb+jo0aOaOHGip0tpcG67FxVgVtOnT9dXX31l6jkLktS1a1ft3LlT+fn5+u9//6sJEyZo8+bNpgs5+/fv11133aX09HSX+96Z2fDhw53f9+zZU/Hx8Wrfvr3+85//aPLkyR6szD0cDof69OmjBx98UNLJeyN+9dVXWrJkiSZMmODh6tzrpZde0vDhw5vlDanZg1MPwsLC5O3trZycHJf2nJwcRUVFeagquENSUpLefvttbdy4Ueeff76ny3ErPz8/denSRXFxcUpNTVWvXr305JNPerqsepeZmanc3Fz97ne/k4+Pj3x8fLR582Y99dRT8vHxkd1u93SJbhcSEqILL7xQu3fv9nQpbtG2bdsKwfyiiy4y9WE5Sfrpp5/0wQcf6JZbbvF0KR5BwKkHfn5+iouL0/r1651tDodD69evN/WchebEMAwlJSVpzZo12rBhgzp27Ojpkhqcw+FQcXGxp8uod0OGDNGXX36pnTt3Oh99+vTRuHHjtHPnTnl7e3u6RLcrKCjQDz/8oLZt23q6FLe4/PLLK1zW4bvvvlP79u09VFHDWLZsmSIiIjRixAhPl+IRHKKqJ8nJyZowYYL69Omjvn37atGiRSosLNSkSZM8XZpbFBQUuPxvb8+ePdq5c6dat26tdu3aebAy95g+fbpWrlypN998U61atXLOrQoODlaLFi08XF39S0lJ0fDhw9WuXTsdO3ZMK1eu1KZNm/T+++97urR616pVqwpzqVq2bKk2bdqYdo7V7Nmzdc0116h9+/b65ZdfNHfuXHl7e+vGG2/0dGluMXPmTPXv318PPvigbrjhBm3btk0vvPCCXnjhBU+X5jYOh0PLli3ThAkT5OPTTD/qPX0al5k8/fTTRrt27Qw/Pz+jb9++xv/+9z9Pl+Q2GzduNCRVeEyYMMHTpblFZdsqyVi2bJmnS3OLm2++2Wjfvr3h5+dnhIeHG0OGDDHWrVvn6bIajNlPEx8zZozRtm1bw8/PzzjvvPOMMWPGGLt37/Z0WW711ltvGd27dzesVqsRGxtrvPDCC54uya3ef/99Q5KRlZXl6VI8xmIYhuGZaAUAAOAezMEBAACmQ8ABAACmQ8ABAACmQ8ABAACmQ8ABAACmQ8ABAACmQ8ABAACmQ8ABAACmQ8ABAACmQ8ABAACmQ8ABAACm8/8B3Fix24Zjs3UAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "59\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Figure AutoCorrelations and Partial AutoCorrelations\n", + "import seaborn as sns\n", + "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n", + "\n", + "for i in range(batch-cnt_thrown_idx):\n", + " print (i)\n", + "# Plot the autocorrelation function (ACF) \n", + " plt.figure(figsize = (12, 6))\n", + " plot_acf(values[i], lags = sl - 1)\n", + " plt.title('Autocorrelation Function (ACF)')\n", + " plt.show()\n", + " \n", + "# Plot the partial autocorrelation function (PACF)\n", + " # plt.figure(figsize = (12, 6))\n", + " # plot_pacf(values[round(i/2)], lags = 60)\n", + " # plt.title('Partial Autocorrelation Function (PACF)')\n", + " # plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "4c6cf92b-58fd-4642-81ee-d7af73c3e75f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===================================================\n", + "sequence length: 8\n", + "batch size: 60\n", + "no. of variables: 8\n", + "no. of predicted variables: 1\n", + "how many steps forward to predict: 1\n", + "===================================================\n" + ] + } + ], + "source": [ + "print (\"===================================================\")\n", + "print (\"sequence length: \", sl)\n", + "print (\"batch size: \", batch-cnt_thrown_idx)\n", + "print (\"no. of variables: \", n_features)\n", + "print (\"no. of predicted variables: \", n_out)\n", + "print (\"how many steps forward to predict: \", frwd)\n", + "print (\"===================================================\")" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "id": "4021e394-635b-4493-8a89-a658e1229325", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"sequential_46\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential_46\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ lstm_88 (LSTM)                  │ (None, 32)             │         5,248 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ repeat_vector_43 (RepeatVector) │ (None, 1, 32)          │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ lstm_89 (LSTM)                  │ (None, 1, 32)          │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ time_distributed_43             │ (None, 1, 1)           │            33 │\n",
+       "│ (TimeDistributed)               │                        │               │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ lstm_88 (\u001b[38;5;33mLSTM\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m5,248\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ repeat_vector_43 (\u001b[38;5;33mRepeatVector\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ lstm_89 (\u001b[38;5;33mLSTM\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ time_distributed_43 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m33\u001b[0m │\n", + "│ (\u001b[38;5;33mTimeDistributed\u001b[0m) │ │ │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 13,601 (53.13 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m13,601\u001b[0m (53.13 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 13,601 (53.13 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m13,601\u001b[0m (53.13 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/500\n", + "3/3 - 6s - 2s/step - loss: 1577620.1250 - val_loss: 1035992.6875\n", + "Epoch 2/500\n", + "3/3 - 0s - 18ms/step - loss: 1006795.6875 - val_loss: 712147.4375\n", + "Epoch 3/500\n", + "3/3 - 0s - 17ms/step - loss: 922834.5000 - val_loss: 511394.2500\n", + "Epoch 4/500\n", + "3/3 - 0s - 17ms/step - loss: 428416.4062 - val_loss: 420227.0625\n", + "Epoch 5/500\n", + "3/3 - 0s - 18ms/step - loss: 406738.7812 - val_loss: 336247.9062\n", + "Epoch 6/500\n", + "3/3 - 0s - 17ms/step - loss: 214966.7500 - val_loss: 284008.7188\n", + "Epoch 7/500\n", + "3/3 - 0s - 17ms/step - loss: 272694.0312 - val_loss: 105427.6406\n", + "Epoch 8/500\n", + "3/3 - 0s - 17ms/step - loss: 241169.9531 - val_loss: 109991.3984\n", + "Epoch 9/500\n", + "3/3 - 0s - 17ms/step - loss: 176282.8281 - val_loss: 115337.9297\n", + "Epoch 10/500\n", + "3/3 - 0s - 17ms/step - loss: 321056.3750 - val_loss: 78467.2422\n", + "Epoch 11/500\n", + "3/3 - 0s - 17ms/step - loss: 200496.0000 - val_loss: 78079.6953\n", + "Epoch 12/500\n", + "3/3 - 0s - 17ms/step - loss: 215983.7031 - val_loss: 47101.2930\n", + "Epoch 13/500\n", + "3/3 - 0s - 17ms/step - loss: 96757.1328 - val_loss: 39729.7539\n", + "Epoch 14/500\n", + "3/3 - 0s - 17ms/step - loss: 79489.1172 - val_loss: 34956.5977\n", + "Epoch 15/500\n", + "3/3 - 0s - 17ms/step - loss: 148872.8281 - val_loss: 47535.5898\n", + "Epoch 16/500\n", + "3/3 - 0s - 17ms/step - loss: 144388.3125 - val_loss: 49040.0977\n", + "Epoch 17/500\n", + "3/3 - 0s - 17ms/step - loss: 197894.4531 - val_loss: 47830.2188\n", + "Epoch 18/500\n", + "3/3 - 0s - 17ms/step - loss: 243352.5000 - val_loss: 49264.0234\n", + "Epoch 19/500\n", + "3/3 - 0s - 17ms/step - loss: 221788.1094 - val_loss: 51334.2344\n", + "Epoch 20/500\n", + "3/3 - 0s - 17ms/step - loss: 267164.3438 - val_loss: 46634.6328\n", + "Epoch 21/500\n", + "3/3 - 0s - 17ms/step - loss: 158554.4688 - val_loss: 38950.9688\n", + "Epoch 22/500\n", + "3/3 - 0s - 17ms/step - loss: 184688.6094 - val_loss: 35354.6328\n", + "Epoch 23/500\n", + "3/3 - 0s - 17ms/step - loss: 360960.1562 - val_loss: 31703.1777\n", + "Epoch 24/500\n", + "3/3 - 0s - 17ms/step - loss: 363645.5938 - val_loss: 37171.2617\n", + "Epoch 25/500\n", + "3/3 - 0s - 17ms/step - loss: 343539.7812 - val_loss: 45172.4453\n", + "Epoch 26/500\n", + "3/3 - 0s - 17ms/step - loss: 215831.2969 - val_loss: 47661.1719\n", + "Epoch 27/500\n", + "3/3 - 0s - 17ms/step - loss: 139321.3438 - val_loss: 42291.2461\n", + "Epoch 28/500\n", + "3/3 - 0s - 17ms/step - loss: 113726.1641 - val_loss: 45771.2227\n", + "Epoch 29/500\n", + "3/3 - 0s - 17ms/step - loss: 120703.1250 - val_loss: 59627.6445\n", + "Epoch 30/500\n", + "3/3 - 0s - 17ms/step - loss: 90586.1250 - val_loss: 57300.3008\n", + "Epoch 31/500\n", + "3/3 - 0s - 17ms/step - loss: 113709.4141 - val_loss: 49259.7852\n", + "Epoch 32/500\n", + "3/3 - 0s - 17ms/step - loss: 87760.8359 - val_loss: 71564.4375\n", + "Epoch 33/500\n", + "3/3 - 0s - 17ms/step - loss: 102664.3516 - val_loss: 73859.9297\n", + "Epoch 34/500\n", + "3/3 - 0s - 17ms/step - loss: 90722.9609 - val_loss: 73659.6172\n", + "Epoch 35/500\n", + "3/3 - 0s - 17ms/step - loss: 79201.2266 - val_loss: 73161.0859\n", + "Epoch 36/500\n", + "3/3 - 0s - 17ms/step - loss: 67643.6562 - val_loss: 62967.1055\n", + "Epoch 37/500\n", + "3/3 - 0s - 17ms/step - loss: 63248.0117 - val_loss: 60570.9492\n", + "Epoch 38/500\n", + "3/3 - 0s - 17ms/step - loss: 70526.8828 - val_loss: 58385.6758\n", + "Epoch 39/500\n", + "3/3 - 0s - 17ms/step - loss: 63774.8242 - val_loss: 56600.7695\n", + "Epoch 40/500\n", + "3/3 - 0s - 17ms/step - loss: 70474.1641 - val_loss: 55161.8555\n", + "Epoch 41/500\n", + "3/3 - 0s - 17ms/step - loss: 92072.3516 - val_loss: 71176.0859\n", + "Epoch 42/500\n", + "3/3 - 0s - 17ms/step - loss: 82258.6172 - val_loss: 73632.4453\n", + "Epoch 43/500\n", + "3/3 - 0s - 17ms/step - loss: 84066.4062 - val_loss: 56627.8086\n", + "Epoch 44/500\n", + "3/3 - 0s - 17ms/step - loss: 61725.2617 - val_loss: 56477.7148\n", + "Epoch 45/500\n", + "3/3 - 0s - 17ms/step - loss: 66950.0547 - val_loss: 51456.1953\n", + "Epoch 46/500\n", + "3/3 - 0s - 17ms/step - loss: 64535.0430 - val_loss: 53841.9258\n", + "Epoch 47/500\n", + "3/3 - 0s - 17ms/step - loss: 51982.5352 - val_loss: 52132.7031\n", + "Epoch 48/500\n", + "3/3 - 0s - 17ms/step - loss: 72170.8516 - val_loss: 128972.2031\n", + "Epoch 49/500\n", + "3/3 - 0s - 17ms/step - loss: 76506.0547 - val_loss: 124632.0781\n", + "Epoch 50/500\n", + "3/3 - 0s - 17ms/step - loss: 69145.2188 - val_loss: 115954.6484\n", + "Epoch 51/500\n", + "3/3 - 0s - 17ms/step - loss: 74869.0078 - val_loss: 113876.5391\n", + "Epoch 52/500\n", + "3/3 - 0s - 17ms/step - loss: 57064.9062 - val_loss: 65494.2266\n", + "Epoch 53/500\n", + "3/3 - 0s - 17ms/step - loss: 46040.5977 - val_loss: 59621.1836\n", + "Epoch 54/500\n", + "3/3 - 0s - 17ms/step - loss: 38510.9258 - val_loss: 37471.7539\n", + "Epoch 55/500\n", + "3/3 - 0s - 17ms/step - loss: 34913.2969 - val_loss: 34535.2891\n", + "Epoch 56/500\n", + "3/3 - 0s - 17ms/step - loss: 35200.2070 - val_loss: 35531.7891\n", + "Epoch 57/500\n", + "3/3 - 0s - 17ms/step - loss: 28312.3066 - val_loss: 31874.5664\n", + "Epoch 58/500\n", + "3/3 - 0s - 17ms/step - loss: 31373.1641 - val_loss: 29488.3574\n", + "Epoch 59/500\n", + "3/3 - 0s - 17ms/step - loss: 23213.3887 - val_loss: 27704.2812\n", + "Epoch 60/500\n", + "3/3 - 0s - 17ms/step - loss: 21196.7129 - val_loss: 25269.4609\n", + "Epoch 61/500\n", + "3/3 - 0s - 17ms/step - loss: 22167.6895 - val_loss: 22155.5547\n", + "Epoch 62/500\n", + "3/3 - 0s - 17ms/step - loss: 21443.4980 - val_loss: 23349.7520\n", + "Epoch 63/500\n", + "3/3 - 0s - 17ms/step - loss: 17979.2812 - val_loss: 22404.6660\n", + "Epoch 64/500\n", + "3/3 - 0s - 17ms/step - loss: 17518.4883 - val_loss: 21413.2598\n", + "Epoch 65/500\n", + "3/3 - 0s - 17ms/step - loss: 17048.6211 - val_loss: 20634.8203\n", + "Epoch 66/500\n", + "3/3 - 0s - 17ms/step - loss: 16080.3643 - val_loss: 19911.9844\n", + "Epoch 67/500\n", + "3/3 - 0s - 17ms/step - loss: 15101.1992 - val_loss: 19594.3887\n", + "Epoch 68/500\n", + "3/3 - 0s - 17ms/step - loss: 15706.7334 - val_loss: 19700.5840\n", + "Epoch 69/500\n", + "3/3 - 0s - 17ms/step - loss: 14665.1514 - val_loss: 18448.5039\n", + "Epoch 70/500\n", + "3/3 - 0s - 17ms/step - loss: 14265.4922 - val_loss: 17777.3262\n", + "Epoch 71/500\n", + "3/3 - 0s - 17ms/step - loss: 12902.4658 - val_loss: 17351.3340\n", + "Epoch 72/500\n", + "3/3 - 0s - 17ms/step - loss: 11572.8047 - val_loss: 16956.3965\n", + "Epoch 73/500\n", + "3/3 - 0s - 17ms/step - loss: 12027.3916 - val_loss: 16569.5879\n", + "Epoch 74/500\n", + "3/3 - 0s - 17ms/step - loss: 10551.6729 - val_loss: 16271.1582\n", + "Epoch 75/500\n", + "3/3 - 0s - 17ms/step - loss: 10439.2451 - val_loss: 16044.6436\n", + "Epoch 76/500\n", + "3/3 - 0s - 17ms/step - loss: 11071.5596 - val_loss: 15823.5957\n", + "Epoch 77/500\n", + "3/3 - 0s - 17ms/step - loss: 10418.6670 - val_loss: 15599.3906\n", + "Epoch 78/500\n", + "3/3 - 0s - 17ms/step - loss: 10553.6680 - val_loss: 15402.1904\n", + "Epoch 79/500\n", + "3/3 - 0s - 17ms/step - loss: 9883.8818 - val_loss: 15189.1172\n", + "Epoch 80/500\n", + "3/3 - 0s - 17ms/step - loss: 9617.8359 - val_loss: 15025.6895\n", + "Epoch 81/500\n", + "3/3 - 0s - 17ms/step - loss: 9512.1338 - val_loss: 14899.7578\n", + "Epoch 82/500\n", + "3/3 - 0s - 17ms/step - loss: 9044.3662 - val_loss: 14730.1592\n", + "Epoch 83/500\n", + "3/3 - 0s - 17ms/step - loss: 9315.6680 - val_loss: 14579.1660\n", + "Epoch 84/500\n", + "3/3 - 0s - 17ms/step - loss: 8551.9814 - val_loss: 14447.9062\n", + "Epoch 85/500\n", + "3/3 - 0s - 17ms/step - loss: 9113.3145 - val_loss: 14297.2646\n", + "Epoch 86/500\n", + "3/3 - 0s - 17ms/step - loss: 8694.2236 - val_loss: 14157.2393\n", + "Epoch 87/500\n", + "3/3 - 0s - 17ms/step - loss: 8342.2139 - val_loss: 14043.7100\n", + "Epoch 88/500\n", + "3/3 - 0s - 17ms/step - loss: 8992.1514 - val_loss: 13919.0566\n", + "Epoch 89/500\n", + "3/3 - 0s - 17ms/step - loss: 7541.2388 - val_loss: 13865.8203\n", + "Epoch 90/500\n", + "3/3 - 0s - 17ms/step - loss: 7780.2798 - val_loss: 13785.7188\n", + "Epoch 91/500\n", + "3/3 - 0s - 17ms/step - loss: 8247.5918 - val_loss: 13762.8584\n", + "Epoch 92/500\n", + "3/3 - 0s - 17ms/step - loss: 7518.6812 - val_loss: 13678.4062\n", + "Epoch 93/500\n", + "3/3 - 0s - 17ms/step - loss: 8522.7119 - val_loss: 13593.0723\n", + "Epoch 94/500\n", + "3/3 - 0s - 17ms/step - loss: 6849.8789 - val_loss: 13488.4033\n", + "Epoch 95/500\n", + "3/3 - 0s - 17ms/step - loss: 7273.5195 - val_loss: 13380.3350\n", + "Epoch 96/500\n", + "3/3 - 0s - 17ms/step - loss: 7337.6196 - val_loss: 13316.9297\n", + "Epoch 97/500\n", + "3/3 - 0s - 17ms/step - loss: 7175.2280 - val_loss: 13242.3535\n", + "Epoch 98/500\n", + "3/3 - 0s - 19ms/step - loss: 7500.2827 - val_loss: 13176.6484\n", + "Epoch 99/500\n", + "3/3 - 0s - 17ms/step - loss: 6619.0620 - val_loss: 13090.2676\n", + "Epoch 100/500\n", + "3/3 - 0s - 17ms/step - loss: 6902.8594 - val_loss: 12976.0146\n", + "Epoch 101/500\n", + "3/3 - 0s - 17ms/step - loss: 7102.5073 - val_loss: 12917.9521\n", + "Epoch 102/500\n", + "3/3 - 0s - 17ms/step - loss: 7205.6382 - val_loss: 12824.3486\n", + "Epoch 103/500\n", + "3/3 - 0s - 17ms/step - loss: 6483.1211 - val_loss: 12659.1982\n", + "Epoch 104/500\n", + "3/3 - 0s - 17ms/step - loss: 7135.5410 - val_loss: 12507.6357\n", + "Epoch 105/500\n", + "3/3 - 0s - 17ms/step - loss: 6698.7788 - val_loss: 12316.6436\n", + "Epoch 106/500\n", + "3/3 - 0s - 17ms/step - loss: 6532.5171 - val_loss: 12149.9092\n", + "Epoch 107/500\n", + "3/3 - 0s - 17ms/step - loss: 6785.1406 - val_loss: 11996.8418\n", + "Epoch 108/500\n", + "3/3 - 0s - 17ms/step - loss: 7204.9927 - val_loss: 11829.5898\n", + "Epoch 109/500\n", + "3/3 - 0s - 17ms/step - loss: 5881.8110 - val_loss: 11715.4062\n", + "Epoch 110/500\n", + "3/3 - 0s - 17ms/step - loss: 6347.8042 - val_loss: 11649.9619\n", + "Epoch 111/500\n", + "3/3 - 0s - 17ms/step - loss: 5860.5815 - val_loss: 11653.6641\n", + "Epoch 112/500\n", + "3/3 - 0s - 17ms/step - loss: 6514.9790 - val_loss: 11706.1748\n", + "Epoch 113/500\n", + "3/3 - 0s - 17ms/step - loss: 5974.7368 - val_loss: 11781.4209\n", + "Epoch 114/500\n", + "3/3 - 0s - 17ms/step - loss: 6258.1758 - val_loss: 11847.5732\n", + "Epoch 115/500\n", + "3/3 - 0s - 17ms/step - loss: 5973.9233 - val_loss: 11875.2539\n", + "Epoch 116/500\n", + "3/3 - 0s - 17ms/step - loss: 6185.3374 - val_loss: 11884.4131\n", + "Epoch 117/500\n", + "3/3 - 0s - 17ms/step - loss: 5806.7749 - val_loss: 11862.1357\n", + "Epoch 118/500\n", + "3/3 - 0s - 17ms/step - loss: 6040.7817 - val_loss: 11792.9082\n", + "Epoch 119/500\n", + "3/3 - 0s - 17ms/step - loss: 5374.0913 - val_loss: 11854.8457\n", + "Epoch 120/500\n", + "3/3 - 0s - 17ms/step - loss: 6490.8823 - val_loss: 11988.4209\n", + "Epoch 121/500\n", + "3/3 - 0s - 17ms/step - loss: 6152.3477 - val_loss: 11620.7148\n", + "Epoch 122/500\n", + "3/3 - 0s - 17ms/step - loss: 5583.0962 - val_loss: 11533.5322\n", + "Epoch 123/500\n", + "3/3 - 0s - 17ms/step - loss: 5360.0103 - val_loss: 11507.3887\n", + "Epoch 124/500\n", + "3/3 - 0s - 17ms/step - loss: 5370.2061 - val_loss: 11479.8779\n", + "Epoch 125/500\n", + "3/3 - 0s - 17ms/step - loss: 5244.2739 - val_loss: 11459.6963\n", + "Epoch 126/500\n", + "3/3 - 0s - 17ms/step - loss: 4844.1953 - val_loss: 11477.1514\n", + "Epoch 127/500\n", + "3/3 - 0s - 17ms/step - loss: 6969.0991 - val_loss: 12250.8584\n", + "Epoch 128/500\n", + "3/3 - 0s - 17ms/step - loss: 5982.0835 - val_loss: 13208.2266\n", + "Epoch 129/500\n", + "3/3 - 0s - 17ms/step - loss: 6461.0430 - val_loss: 13315.3311\n", + "Epoch 130/500\n", + "3/3 - 0s - 17ms/step - loss: 6904.3735 - val_loss: 13618.5332\n", + "Epoch 131/500\n", + "3/3 - 0s - 17ms/step - loss: 6700.4160 - val_loss: 11804.9521\n", + "Epoch 132/500\n", + "3/3 - 0s - 17ms/step - loss: 6360.9819 - val_loss: 12533.9229\n", + "Epoch 133/500\n", + "3/3 - 0s - 17ms/step - loss: 6388.5142 - val_loss: 13853.2061\n", + "Epoch 134/500\n", + "3/3 - 0s - 17ms/step - loss: 6412.3931 - val_loss: 18993.2441\n", + "Epoch 135/500\n", + "3/3 - 0s - 17ms/step - loss: 7065.1460 - val_loss: 22720.4355\n", + "Epoch 136/500\n", + "3/3 - 0s - 17ms/step - loss: 7311.1699 - val_loss: 24538.2773\n", + "Epoch 137/500\n", + "3/3 - 0s - 18ms/step - loss: 11358.3643 - val_loss: 24147.8789\n", + "Epoch 138/500\n", + "3/3 - 0s - 17ms/step - loss: 8021.5093 - val_loss: 23935.0098\n", + "Epoch 139/500\n", + "3/3 - 0s - 17ms/step - loss: 6730.9028 - val_loss: 23719.8789\n", + "Epoch 140/500\n", + "3/3 - 0s - 17ms/step - loss: 5881.1714 - val_loss: 24308.2715\n", + "Epoch 141/500\n", + "3/3 - 0s - 17ms/step - loss: 5595.9634 - val_loss: 24558.7480\n", + "Epoch 142/500\n", + "3/3 - 0s - 17ms/step - loss: 6338.6743 - val_loss: 19675.8457\n", + "Epoch 143/500\n", + "3/3 - 0s - 17ms/step - loss: 4687.2954 - val_loss: 19081.9531\n", + "Epoch 144/500\n", + "3/3 - 0s - 17ms/step - loss: 4734.3750 - val_loss: 18653.2539\n", + "Epoch 145/500\n", + "3/3 - 0s - 17ms/step - loss: 4775.7676 - val_loss: 18508.7520\n", + "Epoch 146/500\n", + "3/3 - 0s - 17ms/step - loss: 4857.1978 - val_loss: 18702.7852\n", + "Epoch 147/500\n", + "3/3 - 0s - 17ms/step - loss: 4870.7104 - val_loss: 18674.9375\n", + "Epoch 148/500\n", + "3/3 - 0s - 17ms/step - loss: 4665.5122 - val_loss: 18363.3828\n", + "Epoch 149/500\n", + "3/3 - 0s - 17ms/step - loss: 4326.8413 - val_loss: 17993.0020\n", + "Epoch 150/500\n", + "3/3 - 0s - 17ms/step - loss: 4707.4146 - val_loss: 17808.5625\n", + "Epoch 151/500\n", + "3/3 - 0s - 17ms/step - loss: 3925.4746 - val_loss: 18038.3770\n", + "Epoch 152/500\n", + "3/3 - 0s - 17ms/step - loss: 3836.0369 - val_loss: 18333.1738\n", + "Epoch 153/500\n", + "3/3 - 0s - 17ms/step - loss: 4060.7488 - val_loss: 18415.2793\n", + "Epoch 154/500\n", + "3/3 - 0s - 17ms/step - loss: 4384.4146 - val_loss: 18396.7266\n", + "Epoch 155/500\n", + "3/3 - 0s - 17ms/step - loss: 3997.3323 - val_loss: 18208.0781\n", + "Epoch 156/500\n", + "3/3 - 0s - 17ms/step - loss: 5244.0190 - val_loss: 18128.0781\n", + "Epoch 157/500\n", + "3/3 - 0s - 17ms/step - loss: 4037.8164 - val_loss: 18231.4590\n", + "Epoch 158/500\n", + "3/3 - 0s - 17ms/step - loss: 4113.8140 - val_loss: 18416.0742\n", + "Epoch 159/500\n", + "3/3 - 0s - 17ms/step - loss: 4483.6909 - val_loss: 18744.3535\n", + "Epoch 160/500\n", + "3/3 - 0s - 17ms/step - loss: 3630.3333 - val_loss: 18858.3965\n", + "Epoch 161/500\n", + "3/3 - 0s - 17ms/step - loss: 3940.3350 - val_loss: 18779.4551\n", + "Epoch 162/500\n", + "3/3 - 0s - 17ms/step - loss: 3652.9739 - val_loss: 18591.2617\n", + "Epoch 163/500\n", + "3/3 - 0s - 17ms/step - loss: 3639.7590 - val_loss: 18515.0625\n", + "Epoch 164/500\n", + "3/3 - 0s - 17ms/step - loss: 3647.7791 - val_loss: 18622.2402\n", + "Epoch 165/500\n", + "3/3 - 0s - 17ms/step - loss: 4415.7188 - val_loss: 18714.8145\n", + "Epoch 166/500\n", + "3/3 - 0s - 17ms/step - loss: 3732.8684 - val_loss: 18670.3262\n", + "Epoch 167/500\n", + "3/3 - 0s - 17ms/step - loss: 3902.9172 - val_loss: 18641.7500\n", + "Epoch 168/500\n", + "3/3 - 0s - 17ms/step - loss: 3753.1931 - val_loss: 18661.0352\n", + "Epoch 169/500\n", + "3/3 - 0s - 17ms/step - loss: 3725.9143 - val_loss: 18745.0332\n", + "Epoch 170/500\n", + "3/3 - 0s - 17ms/step - loss: 3680.4209 - val_loss: 18856.6309\n", + "Epoch 171/500\n", + "3/3 - 0s - 17ms/step - loss: 3987.4885 - val_loss: 18896.3535\n", + "Epoch 172/500\n", + "3/3 - 0s - 17ms/step - loss: 3280.0046 - val_loss: 18927.8770\n", + "Epoch 173/500\n", + "3/3 - 0s - 17ms/step - loss: 3115.8259 - val_loss: 18905.5234\n", + "Epoch 174/500\n", + "3/3 - 0s - 17ms/step - loss: 3158.8679 - val_loss: 18803.5977\n", + "Epoch 175/500\n", + "3/3 - 0s - 17ms/step - loss: 3392.3606 - val_loss: 18725.3457\n", + "Epoch 176/500\n", + "3/3 - 0s - 17ms/step - loss: 3746.1562 - val_loss: 18716.7871\n", + "Epoch 177/500\n", + "3/3 - 0s - 17ms/step - loss: 3653.2764 - val_loss: 18670.1934\n", + "Epoch 178/500\n", + "3/3 - 0s - 17ms/step - loss: 3654.4133 - val_loss: 18534.9805\n", + "Epoch 179/500\n", + "3/3 - 0s - 17ms/step - loss: 2962.4319 - val_loss: 18382.9395\n", + "Epoch 180/500\n", + "3/3 - 0s - 17ms/step - loss: 3404.0977 - val_loss: 18203.9863\n", + "Epoch 181/500\n", + "3/3 - 0s - 17ms/step - loss: 3160.8613 - val_loss: 18052.0371\n", + "Epoch 182/500\n", + "3/3 - 0s - 17ms/step - loss: 3418.8357 - val_loss: 17976.0039\n", + "Epoch 183/500\n", + "3/3 - 0s - 17ms/step - loss: 2980.8420 - val_loss: 17900.7656\n", + "Epoch 184/500\n", + "3/3 - 0s - 17ms/step - loss: 3644.5862 - val_loss: 17809.3691\n", + "Epoch 185/500\n", + "3/3 - 0s - 17ms/step - loss: 3902.3477 - val_loss: 17688.0137\n", + "Epoch 186/500\n", + "3/3 - 0s - 17ms/step - loss: 3514.9778 - val_loss: 17584.5645\n", + "Epoch 187/500\n", + "3/3 - 0s - 17ms/step - loss: 2951.1553 - val_loss: 17470.7480\n", + "Epoch 188/500\n", + "3/3 - 0s - 17ms/step - loss: 3228.0754 - val_loss: 17402.5840\n", + "Epoch 189/500\n", + "3/3 - 0s - 17ms/step - loss: 3113.6101 - val_loss: 17273.6836\n", + "Epoch 190/500\n", + "3/3 - 0s - 17ms/step - loss: 3045.7063 - val_loss: 17098.5801\n", + "Epoch 191/500\n", + "3/3 - 0s - 17ms/step - loss: 3489.2734 - val_loss: 16920.6914\n", + "Epoch 192/500\n", + "3/3 - 0s - 17ms/step - loss: 2931.6960 - val_loss: 16793.7871\n", + "Epoch 193/500\n", + "3/3 - 0s - 17ms/step - loss: 3032.7559 - val_loss: 16751.4395\n", + "Epoch 194/500\n", + "3/3 - 0s - 17ms/step - loss: 2942.9387 - val_loss: 16780.5605\n", + "Epoch 195/500\n", + "3/3 - 0s - 17ms/step - loss: 3007.7012 - val_loss: 16719.8750\n", + "Epoch 196/500\n", + "3/3 - 0s - 17ms/step - loss: 3133.3801 - val_loss: 16616.3945\n", + "Epoch 197/500\n", + "3/3 - 0s - 17ms/step - loss: 3034.3074 - val_loss: 16528.7656\n", + "Epoch 198/500\n", + "3/3 - 0s - 17ms/step - loss: 3449.7559 - val_loss: 16426.1074\n", + "Epoch 199/500\n", + "3/3 - 0s - 17ms/step - loss: 3364.4834 - val_loss: 16450.8848\n", + "Epoch 200/500\n", + "3/3 - 0s - 17ms/step - loss: 2866.5554 - val_loss: 16415.9355\n", + "Epoch 201/500\n", + "3/3 - 0s - 17ms/step - loss: 3216.8184 - val_loss: 16339.2529\n", + "Epoch 202/500\n", + "3/3 - 0s - 17ms/step - loss: 2678.1689 - val_loss: 16167.3613\n", + "Epoch 203/500\n", + "3/3 - 0s - 17ms/step - loss: 2782.3298 - val_loss: 16056.4521\n", + "Epoch 204/500\n", + "3/3 - 0s - 17ms/step - loss: 3129.0564 - val_loss: 15949.4482\n", + "Epoch 205/500\n", + "3/3 - 0s - 17ms/step - loss: 3238.1853 - val_loss: 15941.4688\n", + "Epoch 206/500\n", + "3/3 - 0s - 17ms/step - loss: 2498.1443 - val_loss: 15878.9922\n", + "Epoch 207/500\n", + "3/3 - 0s - 17ms/step - loss: 2999.0684 - val_loss: 15802.9834\n", + "Epoch 208/500\n", + "3/3 - 0s - 17ms/step - loss: 2993.4895 - val_loss: 15638.4014\n", + "Epoch 209/500\n", + "3/3 - 0s - 17ms/step - loss: 3250.6543 - val_loss: 15470.9688\n", + "Epoch 210/500\n", + "3/3 - 0s - 17ms/step - loss: 2669.8547 - val_loss: 15291.3330\n", + "Epoch 211/500\n", + "3/3 - 0s - 17ms/step - loss: 2485.7488 - val_loss: 15224.9395\n", + "Epoch 212/500\n", + "3/3 - 0s - 17ms/step - loss: 2677.9358 - val_loss: 15242.0908\n", + "Epoch 213/500\n", + "3/3 - 0s - 17ms/step - loss: 2717.8411 - val_loss: 15234.4395\n", + "Epoch 214/500\n", + "3/3 - 0s - 17ms/step - loss: 2734.1433 - val_loss: 15191.9736\n", + "Epoch 215/500\n", + "3/3 - 0s - 17ms/step - loss: 2879.7581 - val_loss: 15115.6084\n", + "Epoch 216/500\n", + "3/3 - 0s - 17ms/step - loss: 2481.2527 - val_loss: 14973.1016\n", + "Epoch 217/500\n", + "3/3 - 0s - 17ms/step - loss: 2668.2205 - val_loss: 14828.6475\n", + "Epoch 218/500\n", + "3/3 - 0s - 17ms/step - loss: 2718.4495 - val_loss: 14689.3613\n", + "Epoch 219/500\n", + "3/3 - 0s - 17ms/step - loss: 2672.1052 - val_loss: 14581.8818\n", + "Epoch 220/500\n", + "3/3 - 0s - 17ms/step - loss: 3036.5305 - val_loss: 14525.4629\n", + "Epoch 221/500\n", + "3/3 - 0s - 17ms/step - loss: 2575.9553 - val_loss: 14540.5615\n", + "Epoch 222/500\n", + "3/3 - 0s - 17ms/step - loss: 2505.0505 - val_loss: 14586.3125\n", + "Epoch 223/500\n", + "3/3 - 0s - 17ms/step - loss: 2976.8020 - val_loss: 14570.0566\n", + "Epoch 224/500\n", + "3/3 - 0s - 17ms/step - loss: 2871.0500 - val_loss: 14476.0391\n", + "Epoch 225/500\n", + "3/3 - 0s - 17ms/step - loss: 2807.6414 - val_loss: 14350.0264\n", + "Epoch 226/500\n", + "3/3 - 0s - 17ms/step - loss: 2389.1531 - val_loss: 14253.9219\n", + "Epoch 227/500\n", + "3/3 - 0s - 17ms/step - loss: 2288.1179 - val_loss: 14208.1689\n", + "Epoch 228/500\n", + "3/3 - 0s - 17ms/step - loss: 2468.2761 - val_loss: 14220.1895\n", + "Epoch 229/500\n", + "3/3 - 0s - 17ms/step - loss: 2558.4497 - val_loss: 14204.7021\n", + "Epoch 230/500\n", + "3/3 - 0s - 17ms/step - loss: 2684.0771 - val_loss: 14111.4404\n", + "Epoch 231/500\n", + "3/3 - 0s - 17ms/step - loss: 2576.6367 - val_loss: 14078.6592\n", + "Epoch 232/500\n", + "3/3 - 0s - 17ms/step - loss: 2449.9182 - val_loss: 14025.8066\n", + "Epoch 233/500\n", + "3/3 - 0s - 17ms/step - loss: 2442.3611 - val_loss: 13931.4873\n", + "Epoch 234/500\n", + "3/3 - 0s - 17ms/step - loss: 2328.9626 - val_loss: 13862.4062\n", + "Epoch 235/500\n", + "3/3 - 0s - 17ms/step - loss: 2957.0996 - val_loss: 13858.1191\n", + "Epoch 236/500\n", + "3/3 - 0s - 17ms/step - loss: 2726.1152 - val_loss: 13932.9551\n", + "Epoch 237/500\n", + "3/3 - 0s - 17ms/step - loss: 2640.7307 - val_loss: 13955.4404\n", + "Epoch 238/500\n", + "3/3 - 0s - 17ms/step - loss: 2980.5842 - val_loss: 14038.5361\n", + "Epoch 239/500\n", + "3/3 - 0s - 17ms/step - loss: 2714.3347 - val_loss: 14000.5420\n", + "Epoch 240/500\n", + "3/3 - 0s - 17ms/step - loss: 2426.4412 - val_loss: 13916.3281\n", + "Epoch 241/500\n", + "3/3 - 0s - 17ms/step - loss: 3226.7058 - val_loss: 13886.5801\n", + "Epoch 242/500\n", + "3/3 - 0s - 17ms/step - loss: 2136.6353 - val_loss: 13842.0000\n", + "Epoch 243/500\n", + "3/3 - 0s - 17ms/step - loss: 2098.1785 - val_loss: 13857.7881\n", + "Epoch 244/500\n", + "3/3 - 0s - 17ms/step - loss: 2487.5461 - val_loss: 13896.6816\n", + "Epoch 245/500\n", + "3/3 - 0s - 17ms/step - loss: 2260.4631 - val_loss: 13908.2988\n", + "Epoch 246/500\n", + "3/3 - 0s - 17ms/step - loss: 2372.3616 - val_loss: 13854.9834\n", + "Epoch 247/500\n", + "3/3 - 0s - 17ms/step - loss: 2755.5605 - val_loss: 13870.9707\n", + "Epoch 248/500\n", + "3/3 - 0s - 17ms/step - loss: 2246.5942 - val_loss: 13867.9160\n", + "Epoch 249/500\n", + "3/3 - 0s - 17ms/step - loss: 1986.6266 - val_loss: 13939.2373\n", + "Epoch 250/500\n", + "3/3 - 0s - 17ms/step - loss: 2359.3875 - val_loss: 13932.6562\n", + "Epoch 251/500\n", + "3/3 - 0s - 17ms/step - loss: 2008.7090 - val_loss: 13847.3223\n", + "Epoch 252/500\n", + "3/3 - 0s - 17ms/step - loss: 2185.2908 - val_loss: 13776.6953\n", + "Epoch 253/500\n", + "3/3 - 0s - 17ms/step - loss: 2430.3616 - val_loss: 13720.9629\n", + "Epoch 254/500\n", + "3/3 - 0s - 17ms/step - loss: 2290.3757 - val_loss: 13525.9971\n", + "Epoch 255/500\n", + "3/3 - 0s - 17ms/step - loss: 2270.8977 - val_loss: 13316.2910\n", + "Epoch 256/500\n", + "3/3 - 0s - 17ms/step - loss: 2199.4377 - val_loss: 13145.4785\n", + "Epoch 257/500\n", + "3/3 - 0s - 17ms/step - loss: 2469.5984 - val_loss: 13049.3428\n", + "Epoch 258/500\n", + "3/3 - 0s - 17ms/step - loss: 2035.0575 - val_loss: 13010.0146\n", + "Epoch 259/500\n", + "3/3 - 0s - 17ms/step - loss: 2001.6678 - val_loss: 13008.3037\n", + "Epoch 260/500\n", + "3/3 - 0s - 17ms/step - loss: 2304.7673 - val_loss: 12992.6240\n", + "Epoch 261/500\n", + "3/3 - 0s - 17ms/step - loss: 2021.9121 - val_loss: 13041.0381\n", + "Epoch 262/500\n", + "3/3 - 0s - 17ms/step - loss: 2470.8645 - val_loss: 13104.7842\n", + "Epoch 263/500\n", + "3/3 - 0s - 17ms/step - loss: 2118.3308 - val_loss: 13150.8311\n", + "Epoch 264/500\n", + "3/3 - 0s - 17ms/step - loss: 1991.0944 - val_loss: 13234.5234\n", + "Epoch 265/500\n", + "3/3 - 0s - 17ms/step - loss: 2219.9153 - val_loss: 13292.2314\n", + "Epoch 266/500\n", + "3/3 - 0s - 17ms/step - loss: 2427.2390 - val_loss: 13293.6221\n", + "Epoch 267/500\n", + "3/3 - 0s - 17ms/step - loss: 2458.7197 - val_loss: 13294.8271\n", + "Epoch 268/500\n", + "3/3 - 0s - 17ms/step - loss: 2269.1716 - val_loss: 13252.9736\n", + "Epoch 269/500\n", + "3/3 - 0s - 17ms/step - loss: 2110.8438 - val_loss: 13196.6436\n", + "Epoch 270/500\n", + "3/3 - 0s - 17ms/step - loss: 2175.5251 - val_loss: 13144.8506\n", + "Epoch 271/500\n", + "3/3 - 0s - 17ms/step - loss: 2637.5645 - val_loss: 13147.6143\n", + "Epoch 272/500\n", + "3/3 - 0s - 17ms/step - loss: 1959.9712 - val_loss: 13075.0127\n", + "Epoch 273/500\n", + "3/3 - 0s - 17ms/step - loss: 1895.2294 - val_loss: 12988.1904\n", + "Epoch 274/500\n", + "3/3 - 0s - 17ms/step - loss: 1895.2510 - val_loss: 12908.2646\n", + "Epoch 275/500\n", + "3/3 - 0s - 17ms/step - loss: 1830.8086 - val_loss: 12812.6592\n", + "Epoch 276/500\n", + "3/3 - 0s - 17ms/step - loss: 2185.9648 - val_loss: 12658.1611\n", + "Epoch 277/500\n", + "3/3 - 0s - 17ms/step - loss: 1929.5404 - val_loss: 12560.1406\n", + "Epoch 278/500\n", + "3/3 - 0s - 17ms/step - loss: 2054.0000 - val_loss: 12498.7988\n", + "Epoch 279/500\n", + "3/3 - 0s - 17ms/step - loss: 1816.7731 - val_loss: 12392.9961\n", + "Epoch 280/500\n", + "3/3 - 0s - 17ms/step - loss: 1784.1198 - val_loss: 12292.5303\n", + "Epoch 281/500\n", + "3/3 - 0s - 17ms/step - loss: 1827.3315 - val_loss: 12253.4111\n", + "Epoch 282/500\n", + "3/3 - 0s - 17ms/step - loss: 1884.4404 - val_loss: 12237.7959\n", + "Epoch 283/500\n", + "3/3 - 0s - 17ms/step - loss: 1995.6757 - val_loss: 12262.1328\n", + "Epoch 284/500\n", + "3/3 - 0s - 17ms/step - loss: 2085.4297 - val_loss: 12239.9580\n", + "Epoch 285/500\n", + "3/3 - 0s - 17ms/step - loss: 1884.5956 - val_loss: 12309.9014\n", + "Epoch 286/500\n", + "3/3 - 0s - 17ms/step - loss: 2060.9026 - val_loss: 12349.3447\n", + "Epoch 287/500\n", + "3/3 - 0s - 17ms/step - loss: 2061.5439 - val_loss: 12426.7607\n", + "Epoch 288/500\n", + "3/3 - 0s - 17ms/step - loss: 1784.0231 - val_loss: 12459.5068\n", + "Epoch 289/500\n", + "3/3 - 0s - 17ms/step - loss: 1999.7129 - val_loss: 12454.4766\n", + "Epoch 290/500\n", + "3/3 - 0s - 17ms/step - loss: 1745.6362 - val_loss: 12419.9033\n", + "Epoch 291/500\n", + "3/3 - 0s - 17ms/step - loss: 2300.4675 - val_loss: 12363.6182\n", + "Epoch 292/500\n", + "3/3 - 0s - 17ms/step - loss: 2077.6472 - val_loss: 12220.9658\n", + "Epoch 293/500\n", + "3/3 - 0s - 17ms/step - loss: 1793.9449 - val_loss: 12169.4375\n", + "Epoch 294/500\n", + "3/3 - 0s - 17ms/step - loss: 1776.3177 - val_loss: 12188.7188\n", + "Epoch 295/500\n", + "3/3 - 0s - 17ms/step - loss: 2684.6150 - val_loss: 13584.7412\n", + "Epoch 296/500\n", + "3/3 - 0s - 17ms/step - loss: 1659.9438 - val_loss: 13687.3848\n", + "Epoch 297/500\n", + "3/3 - 0s - 17ms/step - loss: 1924.0333 - val_loss: 13685.2207\n", + "Epoch 298/500\n", + "3/3 - 0s - 17ms/step - loss: 1590.8243 - val_loss: 13697.4248\n", + "Epoch 299/500\n", + "3/3 - 0s - 17ms/step - loss: 2014.3086 - val_loss: 13722.4873\n", + "Epoch 300/500\n", + "3/3 - 0s - 17ms/step - loss: 2031.5521 - val_loss: 13786.9688\n", + "Epoch 301/500\n", + "3/3 - 0s - 17ms/step - loss: 2013.7220 - val_loss: 13823.4766\n", + "Epoch 302/500\n", + "3/3 - 0s - 17ms/step - loss: 1806.6090 - val_loss: 13903.6660\n", + "Epoch 303/500\n", + "3/3 - 0s - 17ms/step - loss: 1665.8705 - val_loss: 13831.3223\n", + "Epoch 304/500\n", + "3/3 - 0s - 17ms/step - loss: 1950.0693 - val_loss: 13729.0957\n", + "Epoch 305/500\n", + "3/3 - 0s - 17ms/step - loss: 1877.4735 - val_loss: 13637.7725\n", + "Epoch 306/500\n", + "3/3 - 0s - 17ms/step - loss: 1579.6666 - val_loss: 13532.7568\n", + "Epoch 307/500\n", + "3/3 - 0s - 17ms/step - loss: 2407.2993 - val_loss: 13426.3828\n", + "Epoch 308/500\n", + "3/3 - 0s - 17ms/step - loss: 1828.1490 - val_loss: 13285.3564\n", + "Epoch 309/500\n", + "3/3 - 0s - 17ms/step - loss: 2054.0947 - val_loss: 13189.5537\n", + "Epoch 310/500\n", + "3/3 - 0s - 17ms/step - loss: 2350.3054 - val_loss: 13055.4346\n", + "Epoch 311/500\n", + "3/3 - 0s - 17ms/step - loss: 1792.4049 - val_loss: 12924.3389\n", + "Epoch 312/500\n", + "3/3 - 0s - 17ms/step - loss: 1813.4556 - val_loss: 12863.7109\n", + "Epoch 313/500\n", + "3/3 - 0s - 17ms/step - loss: 2235.1895 - val_loss: 12929.0537\n", + "Epoch 314/500\n", + "3/3 - 0s - 17ms/step - loss: 1987.4508 - val_loss: 13050.5010\n", + "Epoch 315/500\n", + "3/3 - 0s - 17ms/step - loss: 1829.1294 - val_loss: 13248.6982\n", + "Epoch 316/500\n", + "3/3 - 0s - 17ms/step - loss: 1801.2770 - val_loss: 13404.8281\n", + "Epoch 317/500\n", + "3/3 - 0s - 17ms/step - loss: 1666.7926 - val_loss: 13476.9912\n", + "Epoch 318/500\n", + "3/3 - 0s - 17ms/step - loss: 1860.7777 - val_loss: 13528.9287\n", + "Epoch 319/500\n", + "3/3 - 0s - 17ms/step - loss: 1810.8472 - val_loss: 13568.8193\n", + "Epoch 320/500\n", + "3/3 - 0s - 17ms/step - loss: 1942.2100 - val_loss: 13550.3193\n", + "Epoch 321/500\n", + "3/3 - 0s - 17ms/step - loss: 1964.9346 - val_loss: 13573.9092\n", + "Epoch 322/500\n", + "3/3 - 0s - 17ms/step - loss: 1729.3109 - val_loss: 13582.2295\n", + "Epoch 323/500\n", + "3/3 - 0s - 17ms/step - loss: 1716.8322 - val_loss: 13621.8877\n", + "Epoch 324/500\n", + "3/3 - 0s - 17ms/step - loss: 1853.9681 - val_loss: 13620.2295\n", + "Epoch 325/500\n", + "3/3 - 0s - 17ms/step - loss: 1597.7877 - val_loss: 13600.8330\n", + "Epoch 326/500\n", + "3/3 - 0s - 17ms/step - loss: 1813.2780 - val_loss: 13631.6123\n", + "Epoch 327/500\n", + "3/3 - 0s - 17ms/step - loss: 1608.7754 - val_loss: 13665.4395\n", + "Epoch 328/500\n", + "3/3 - 0s - 17ms/step - loss: 1543.5660 - val_loss: 13708.9912\n", + "Epoch 329/500\n", + "3/3 - 0s - 17ms/step - loss: 1538.7759 - val_loss: 13734.4707\n", + "Epoch 330/500\n", + "3/3 - 0s - 17ms/step - loss: 1629.5703 - val_loss: 13693.1816\n", + "Epoch 331/500\n", + "3/3 - 0s - 17ms/step - loss: 1962.2760 - val_loss: 13592.3750\n", + "Epoch 332/500\n", + "3/3 - 0s - 17ms/step - loss: 1554.6298 - val_loss: 13549.6826\n", + "Epoch 333/500\n", + "3/3 - 0s - 17ms/step - loss: 1610.6703 - val_loss: 13530.4375\n", + "Epoch 334/500\n", + "3/3 - 0s - 17ms/step - loss: 1503.0254 - val_loss: 13506.1357\n", + "Epoch 335/500\n", + "3/3 - 0s - 17ms/step - loss: 1649.6929 - val_loss: 13453.0283\n", + "Epoch 336/500\n", + "3/3 - 0s - 17ms/step - loss: 1707.4263 - val_loss: 13408.0049\n", + "Epoch 337/500\n", + "3/3 - 0s - 17ms/step - loss: 1768.1312 - val_loss: 13372.1045\n", + "Epoch 338/500\n", + "3/3 - 0s - 17ms/step - loss: 1567.9438 - val_loss: 13315.0967\n", + "Epoch 339/500\n", + "3/3 - 0s - 17ms/step - loss: 1518.4185 - val_loss: 13265.5938\n", + "Epoch 340/500\n", + "3/3 - 0s - 17ms/step - loss: 2023.1421 - val_loss: 13278.0566\n", + "Epoch 341/500\n", + "3/3 - 0s - 17ms/step - loss: 1563.7338 - val_loss: 13407.3047\n", + "Epoch 342/500\n", + "3/3 - 0s - 17ms/step - loss: 1697.8990 - val_loss: 13494.3691\n", + "Epoch 343/500\n", + "3/3 - 0s - 17ms/step - loss: 1646.9691 - val_loss: 13516.5830\n", + "Epoch 344/500\n", + "3/3 - 0s - 17ms/step - loss: 1573.9227 - val_loss: 13488.8457\n", + "Epoch 345/500\n", + "3/3 - 0s - 17ms/step - loss: 1479.3379 - val_loss: 13481.7207\n", + "Epoch 346/500\n", + "3/3 - 0s - 17ms/step - loss: 1458.4619 - val_loss: 13491.8750\n", + "Epoch 347/500\n", + "3/3 - 0s - 17ms/step - loss: 1841.0597 - val_loss: 13479.2998\n", + "Epoch 348/500\n", + "3/3 - 0s - 17ms/step - loss: 1568.7733 - val_loss: 13458.4785\n", + "Epoch 349/500\n", + "3/3 - 0s - 17ms/step - loss: 1395.7603 - val_loss: 13380.1162\n", + "Epoch 350/500\n", + "3/3 - 0s - 17ms/step - loss: 1479.0137 - val_loss: 13317.0078\n", + "Epoch 351/500\n", + "3/3 - 0s - 17ms/step - loss: 1698.2603 - val_loss: 13245.8564\n", + "Epoch 352/500\n", + "3/3 - 0s - 17ms/step - loss: 1451.6334 - val_loss: 13172.2490\n", + "Epoch 353/500\n", + "3/3 - 0s - 17ms/step - loss: 1416.2529 - val_loss: 13085.0176\n", + "Epoch 354/500\n", + "3/3 - 0s - 17ms/step - loss: 1534.3610 - val_loss: 13026.6357\n", + "Epoch 355/500\n", + "3/3 - 0s - 17ms/step - loss: 1419.8143 - val_loss: 12978.6855\n", + "Epoch 356/500\n", + "3/3 - 0s - 17ms/step - loss: 1444.2311 - val_loss: 12979.1084\n", + "Epoch 357/500\n", + "3/3 - 0s - 17ms/step - loss: 1479.5620 - val_loss: 12937.1719\n", + "Epoch 358/500\n", + "3/3 - 0s - 17ms/step - loss: 1446.3419 - val_loss: 12900.1152\n", + "Epoch 359/500\n", + "3/3 - 0s - 17ms/step - loss: 1391.5829 - val_loss: 12873.0811\n", + "Epoch 360/500\n", + "3/3 - 0s - 17ms/step - loss: 1396.7211 - val_loss: 12829.1660\n", + "Epoch 361/500\n", + "3/3 - 0s - 17ms/step - loss: 1435.2969 - val_loss: 12800.2109\n", + "Epoch 362/500\n", + "3/3 - 0s - 17ms/step - loss: 1338.8273 - val_loss: 12755.6436\n", + "Epoch 363/500\n", + "3/3 - 0s - 17ms/step - loss: 1375.0375 - val_loss: 12723.7412\n", + "Epoch 364/500\n", + "3/3 - 0s - 17ms/step - loss: 1621.9196 - val_loss: 12739.0234\n", + "Epoch 365/500\n", + "3/3 - 0s - 17ms/step - loss: 1791.9625 - val_loss: 12722.8066\n", + "Epoch 366/500\n", + "3/3 - 0s - 17ms/step - loss: 1442.6084 - val_loss: 12752.6279\n", + "Epoch 367/500\n", + "3/3 - 0s - 17ms/step - loss: 1455.9635 - val_loss: 12734.0811\n", + "Epoch 368/500\n", + "3/3 - 0s - 17ms/step - loss: 1294.8817 - val_loss: 12645.9307\n", + "Epoch 369/500\n", + "3/3 - 0s - 17ms/step - loss: 1284.7350 - val_loss: 12630.0850\n", + "Epoch 370/500\n", + "3/3 - 0s - 17ms/step - loss: 1380.2316 - val_loss: 12618.9902\n", + "Epoch 371/500\n", + "3/3 - 0s - 17ms/step - loss: 1417.1742 - val_loss: 12601.0039\n", + "Epoch 372/500\n", + "3/3 - 0s - 17ms/step - loss: 1583.6881 - val_loss: 12542.2998\n", + "Epoch 373/500\n", + "3/3 - 0s - 17ms/step - loss: 1665.1879 - val_loss: 12538.6748\n", + "Epoch 374/500\n", + "3/3 - 0s - 17ms/step - loss: 1502.0543 - val_loss: 12537.4854\n", + "Epoch 375/500\n", + "3/3 - 0s - 17ms/step - loss: 1363.8408 - val_loss: 12615.8311\n", + "Epoch 376/500\n", + "3/3 - 0s - 17ms/step - loss: 1376.9369 - val_loss: 12656.5859\n", + "Epoch 377/500\n", + "3/3 - 0s - 17ms/step - loss: 1273.7534 - val_loss: 12583.3984\n", + "Epoch 378/500\n", + "3/3 - 0s - 17ms/step - loss: 1488.0697 - val_loss: 12531.9219\n", + "Epoch 379/500\n", + "3/3 - 0s - 17ms/step - loss: 1286.6088 - val_loss: 12505.0068\n", + "Epoch 380/500\n", + "3/3 - 0s - 17ms/step - loss: 1399.4713 - val_loss: 12485.4355\n", + "Epoch 381/500\n", + "3/3 - 0s - 17ms/step - loss: 1307.6622 - val_loss: 12485.5195\n", + "Epoch 382/500\n", + "3/3 - 0s - 17ms/step - loss: 1401.3275 - val_loss: 12469.3584\n", + "Epoch 383/500\n", + "3/3 - 0s - 17ms/step - loss: 1466.6924 - val_loss: 12395.5732\n", + "Epoch 384/500\n", + "3/3 - 0s - 17ms/step - loss: 1283.4943 - val_loss: 12323.6455\n", + "Epoch 385/500\n", + "3/3 - 0s - 17ms/step - loss: 1247.2410 - val_loss: 12300.4014\n", + "Epoch 386/500\n", + "3/3 - 0s - 17ms/step - loss: 1433.7179 - val_loss: 12343.1201\n", + "Epoch 387/500\n", + "3/3 - 0s - 17ms/step - loss: 1242.2963 - val_loss: 12443.2217\n", + "Epoch 388/500\n", + "3/3 - 0s - 17ms/step - loss: 1213.0107 - val_loss: 12494.0088\n", + "Epoch 389/500\n", + "3/3 - 0s - 17ms/step - loss: 1283.5161 - val_loss: 12479.6016\n", + "Epoch 390/500\n", + "3/3 - 0s - 17ms/step - loss: 1389.0199 - val_loss: 12383.9912\n", + "Epoch 391/500\n", + "3/3 - 0s - 17ms/step - loss: 1158.7157 - val_loss: 12292.5557\n", + "Epoch 392/500\n", + "3/3 - 0s - 17ms/step - loss: 1174.8827 - val_loss: 12207.8447\n", + "Epoch 393/500\n", + "3/3 - 0s - 17ms/step - loss: 1211.8270 - val_loss: 12190.5986\n", + "Epoch 394/500\n", + "3/3 - 0s - 17ms/step - loss: 1236.8213 - val_loss: 12176.5840\n", + "Epoch 395/500\n", + "3/3 - 0s - 17ms/step - loss: 1343.8510 - val_loss: 12197.2256\n", + "Epoch 396/500\n", + "3/3 - 0s - 17ms/step - loss: 1193.8666 - val_loss: 12210.9326\n", + "Epoch 397/500\n", + "3/3 - 0s - 17ms/step - loss: 1227.3073 - val_loss: 12194.8799\n", + "Epoch 398/500\n", + "3/3 - 0s - 17ms/step - loss: 1438.6051 - val_loss: 12117.0215\n", + "Epoch 399/500\n", + "3/3 - 0s - 17ms/step - loss: 1143.3475 - val_loss: 12034.7480\n", + "Epoch 400/500\n", + "3/3 - 0s - 17ms/step - loss: 1410.8807 - val_loss: 11978.9248\n", + "Epoch 401/500\n", + "3/3 - 0s - 17ms/step - loss: 1201.5463 - val_loss: 11939.1055\n", + "Epoch 402/500\n", + "3/3 - 0s - 17ms/step - loss: 1519.7070 - val_loss: 11877.4912\n", + "Epoch 403/500\n", + "3/3 - 0s - 17ms/step - loss: 1163.8295 - val_loss: 11874.0195\n", + "Epoch 404/500\n", + "3/3 - 0s - 17ms/step - loss: 1618.0254 - val_loss: 11860.0586\n", + "Epoch 405/500\n", + "3/3 - 0s - 17ms/step - loss: 1169.9755 - val_loss: 11875.3779\n", + "Epoch 406/500\n", + "3/3 - 0s - 17ms/step - loss: 1203.3438 - val_loss: 11905.3701\n", + "Epoch 407/500\n", + "3/3 - 0s - 17ms/step - loss: 1216.2635 - val_loss: 11935.9619\n", + "Epoch 408/500\n", + "3/3 - 0s - 17ms/step - loss: 1542.9293 - val_loss: 11876.6016\n", + "Epoch 409/500\n", + "3/3 - 0s - 17ms/step - loss: 1200.5552 - val_loss: 11866.6982\n", + "Epoch 410/500\n", + "3/3 - 0s - 17ms/step - loss: 1119.0197 - val_loss: 11769.4502\n", + "Epoch 411/500\n", + "3/3 - 0s - 17ms/step - loss: 1367.1244 - val_loss: 11674.1240\n", + "Epoch 412/500\n", + "3/3 - 0s - 17ms/step - loss: 1378.3365 - val_loss: 11673.0674\n", + "Epoch 413/500\n", + "3/3 - 0s - 17ms/step - loss: 1109.5961 - val_loss: 11756.2256\n", + "Epoch 414/500\n", + "3/3 - 0s - 17ms/step - loss: 1149.8401 - val_loss: 11792.6953\n", + "Epoch 415/500\n", + "3/3 - 0s - 17ms/step - loss: 1561.5957 - val_loss: 11826.3037\n", + "Epoch 416/500\n", + "3/3 - 0s - 17ms/step - loss: 1329.2100 - val_loss: 11884.2412\n", + "Epoch 417/500\n", + "3/3 - 0s - 17ms/step - loss: 1098.0538 - val_loss: 11918.5576\n", + "Epoch 418/500\n", + "3/3 - 0s - 17ms/step - loss: 1083.4044 - val_loss: 11893.9326\n", + "Epoch 419/500\n", + "3/3 - 0s - 17ms/step - loss: 1366.9742 - val_loss: 11903.0342\n", + "Epoch 420/500\n", + "3/3 - 0s - 17ms/step - loss: 1135.4385 - val_loss: 11940.2383\n", + "Epoch 421/500\n", + "3/3 - 0s - 17ms/step - loss: 1219.8468 - val_loss: 11945.9521\n", + "Epoch 422/500\n", + "3/3 - 0s - 17ms/step - loss: 1192.0673 - val_loss: 11806.8135\n", + "Epoch 423/500\n", + "3/3 - 0s - 17ms/step - loss: 1263.4198 - val_loss: 11639.0420\n", + "Epoch 424/500\n", + "3/3 - 0s - 17ms/step - loss: 1263.3772 - val_loss: 11530.3486\n", + "Epoch 425/500\n", + "3/3 - 0s - 17ms/step - loss: 1248.3644 - val_loss: 11538.7588\n", + "Epoch 426/500\n", + "3/3 - 0s - 17ms/step - loss: 1081.1595 - val_loss: 11663.2607\n", + "Epoch 427/500\n", + "3/3 - 0s - 17ms/step - loss: 1285.9462 - val_loss: 11853.4385\n", + "Epoch 428/500\n", + "3/3 - 0s - 17ms/step - loss: 1162.6328 - val_loss: 11965.1104\n", + "Epoch 429/500\n", + "3/3 - 0s - 17ms/step - loss: 1159.7513 - val_loss: 11908.4639\n", + "Epoch 430/500\n", + "3/3 - 0s - 17ms/step - loss: 1044.7308 - val_loss: 11743.1602\n", + "Epoch 431/500\n", + "3/3 - 0s - 17ms/step - loss: 1042.9562 - val_loss: 11633.8027\n", + "Epoch 432/500\n", + "3/3 - 0s - 17ms/step - loss: 1272.7484 - val_loss: 11611.1973\n", + "Epoch 433/500\n", + "3/3 - 0s - 17ms/step - loss: 1108.2052 - val_loss: 11584.9092\n", + "Epoch 434/500\n", + "3/3 - 0s - 17ms/step - loss: 1210.9020 - val_loss: 11574.4648\n", + "Epoch 435/500\n", + "3/3 - 0s - 17ms/step - loss: 1090.7620 - val_loss: 11537.9082\n", + "Epoch 436/500\n", + "3/3 - 0s - 17ms/step - loss: 1065.0841 - val_loss: 11375.5342\n", + "Epoch 437/500\n", + "3/3 - 0s - 17ms/step - loss: 1198.2792 - val_loss: 11215.7734\n", + "Epoch 438/500\n", + "3/3 - 0s - 17ms/step - loss: 1281.9584 - val_loss: 11074.5303\n", + "Epoch 439/500\n", + "3/3 - 0s - 17ms/step - loss: 1005.8123 - val_loss: 11021.5156\n", + "Epoch 440/500\n", + "3/3 - 0s - 17ms/step - loss: 1120.0093 - val_loss: 10988.1074\n", + "Epoch 441/500\n", + "3/3 - 0s - 17ms/step - loss: 1077.2847 - val_loss: 10935.0840\n", + "Epoch 442/500\n", + "3/3 - 0s - 17ms/step - loss: 1174.5868 - val_loss: 10802.0693\n", + "Epoch 443/500\n", + "3/3 - 0s - 17ms/step - loss: 932.2080 - val_loss: 10693.5713\n", + "Epoch 444/500\n", + "3/3 - 0s - 17ms/step - loss: 778.5749 - val_loss: 10640.6455\n", + "Epoch 445/500\n", + "3/3 - 0s - 17ms/step - loss: 850.2438 - val_loss: 10127.6709\n", + "Epoch 446/500\n", + "3/3 - 0s - 17ms/step - loss: 1342.6503 - val_loss: 9836.2764\n", + "Epoch 447/500\n", + "3/3 - 0s - 17ms/step - loss: 1026.7169 - val_loss: 14556.1426\n", + "Epoch 448/500\n", + "3/3 - 0s - 17ms/step - loss: 5180.3804 - val_loss: 14474.1504\n", + "Epoch 449/500\n", + "3/3 - 0s - 17ms/step - loss: 3231.8652 - val_loss: 15235.2393\n", + "Epoch 450/500\n", + "3/3 - 0s - 17ms/step - loss: 3603.4180 - val_loss: 12494.5469\n", + "Epoch 451/500\n", + "3/3 - 0s - 17ms/step - loss: 2771.7141 - val_loss: 12596.5791\n", + "Epoch 452/500\n", + "3/3 - 0s - 17ms/step - loss: 2492.6287 - val_loss: 12458.5967\n", + "Epoch 453/500\n", + "3/3 - 0s - 17ms/step - loss: 130566.2422 - val_loss: 14305.2217\n", + "Epoch 454/500\n", + "3/3 - 0s - 17ms/step - loss: 59600.2695 - val_loss: 19778.2305\n", + "Epoch 455/500\n", + "3/3 - 0s - 20ms/step - loss: 21048.7246 - val_loss: 24050.7891\n", + "Epoch 456/500\n", + "3/3 - 0s - 17ms/step - loss: 10682.6162 - val_loss: 19382.1562\n", + "Epoch 457/500\n", + "3/3 - 0s - 17ms/step - loss: 11721.0078 - val_loss: 12668.3018\n", + "Epoch 458/500\n", + "3/3 - 0s - 17ms/step - loss: 30869.4824 - val_loss: 9933.6396\n", + "Epoch 459/500\n", + "3/3 - 0s - 17ms/step - loss: 11409.1807 - val_loss: 13904.3174\n", + "Epoch 460/500\n", + "3/3 - 0s - 17ms/step - loss: 68008.8828 - val_loss: 15173.6787\n", + "Epoch 461/500\n", + "3/3 - 0s - 17ms/step - loss: 34727.7773 - val_loss: 10858.1074\n", + "Epoch 462/500\n", + "3/3 - 0s - 16ms/step - loss: 17068.3496 - val_loss: 11095.0381\n", + "Epoch 463/500\n", + "3/3 - 0s - 17ms/step - loss: 13025.5830 - val_loss: 14808.9287\n", + "Epoch 464/500\n", + "3/3 - 0s - 17ms/step - loss: 14887.2920 - val_loss: 23951.9512\n", + "Epoch 465/500\n", + "3/3 - 0s - 17ms/step - loss: 12912.5537 - val_loss: 23915.0215\n", + "Epoch 466/500\n", + "3/3 - 0s - 17ms/step - loss: 14608.3086 - val_loss: 21541.1621\n", + "Epoch 467/500\n", + "3/3 - 0s - 17ms/step - loss: 10615.5127 - val_loss: 29248.0449\n", + "Epoch 468/500\n", + "3/3 - 0s - 17ms/step - loss: 15356.8174 - val_loss: 25405.4102\n", + "Epoch 469/500\n", + "3/3 - 0s - 16ms/step - loss: 27714.8652 - val_loss: 25208.1387\n", + "Epoch 470/500\n", + "3/3 - 0s - 17ms/step - loss: 17119.8184 - val_loss: 26038.4824\n", + "Epoch 471/500\n", + "3/3 - 0s - 17ms/step - loss: 32523.9238 - val_loss: 24291.9277\n", + "Epoch 472/500\n", + "3/3 - 0s - 17ms/step - loss: 18067.1816 - val_loss: 38093.5234\n", + "Epoch 473/500\n", + "3/3 - 0s - 17ms/step - loss: 13829.0586 - val_loss: 37849.4180\n", + "Epoch 474/500\n", + "3/3 - 0s - 17ms/step - loss: 12389.2812 - val_loss: 29200.4258\n", + "Epoch 475/500\n", + "3/3 - 0s - 17ms/step - loss: 12729.7666 - val_loss: 27840.2324\n", + "Epoch 476/500\n", + "3/3 - 0s - 17ms/step - loss: 29856.1738 - val_loss: 29042.3027\n", + "Epoch 477/500\n", + "3/3 - 0s - 17ms/step - loss: 8976.9941 - val_loss: 27598.9043\n", + "Epoch 478/500\n", + "3/3 - 0s - 17ms/step - loss: 46873.7148 - val_loss: 28163.9512\n", + "Epoch 479/500\n", + "3/3 - 0s - 17ms/step - loss: 257083.5781 - val_loss: 34960.1250\n", + "Epoch 480/500\n", + "3/3 - 0s - 17ms/step - loss: 196442.7656 - val_loss: 49547.0469\n", + "Epoch 481/500\n", + "3/3 - 0s - 17ms/step - loss: 51236.3867 - val_loss: 58072.3867\n", + "Epoch 482/500\n", + "3/3 - 0s - 17ms/step - loss: 29239.3223 - val_loss: 40773.7148\n", + "Epoch 483/500\n", + "3/3 - 0s - 17ms/step - loss: 43134.9727 - val_loss: 23137.1465\n", + "Epoch 484/500\n", + "3/3 - 0s - 17ms/step - loss: 29392.6641 - val_loss: 18808.0078\n", + "Epoch 485/500\n", + "3/3 - 0s - 17ms/step - loss: 31492.0723 - val_loss: 15686.3145\n", + "Epoch 486/500\n", + "3/3 - 0s - 17ms/step - loss: 19207.5312 - val_loss: 14302.8828\n", + "Epoch 487/500\n", + "3/3 - 0s - 17ms/step - loss: 17661.4570 - val_loss: 14177.6357\n", + "Epoch 488/500\n", + "3/3 - 0s - 17ms/step - loss: 15505.5361 - val_loss: 15030.9736\n", + "Epoch 489/500\n", + "3/3 - 0s - 17ms/step - loss: 16390.7949 - val_loss: 15634.1953\n", + "Epoch 490/500\n", + "3/3 - 0s - 17ms/step - loss: 12059.5088 - val_loss: 12010.7764\n", + "Epoch 491/500\n", + "3/3 - 0s - 17ms/step - loss: 13109.5967 - val_loss: 12178.0254\n", + "Epoch 492/500\n", + "3/3 - 0s - 17ms/step - loss: 13104.2812 - val_loss: 11961.1035\n", + "Epoch 493/500\n", + "3/3 - 0s - 17ms/step - loss: 9449.1895 - val_loss: 11808.8223\n", + "Epoch 494/500\n", + "3/3 - 0s - 17ms/step - loss: 12841.9756 - val_loss: 12565.6006\n", + "Epoch 495/500\n", + "3/3 - 0s - 17ms/step - loss: 10409.1924 - val_loss: 12375.4824\n", + "Epoch 496/500\n", + "3/3 - 0s - 17ms/step - loss: 8109.4546 - val_loss: 12493.7500\n", + "Epoch 497/500\n", + "3/3 - 0s - 17ms/step - loss: 8853.0518 - val_loss: 12203.5312\n", + "Epoch 498/500\n", + "3/3 - 0s - 17ms/step - loss: 11350.3633 - val_loss: 13461.4443\n", + "Epoch 499/500\n", + "3/3 - 0s - 17ms/step - loss: 12640.6377 - val_loss: 17364.1230\n", + "Epoch 500/500\n", + "3/3 - 0s - 17ms/step - loss: 42449.3906 - val_loss: 34727.5820\n" + ] + } + ], + "source": [ + "from keras.initializers import glorot_uniform, he_uniform, orthogonal, zeros\n", + "\n", + "n_steps = sl\n", + "\n", + "model_8f = Sequential()\n", + "model_8f.add(tf.keras.layers.Input(shape = (n_steps, n_features)))\n", + "# model_8f.add(tf.keras.layers.LSTM(units = 64, activation = 'relu', return_sequences = False)) \n", + "\n", + "model_8f.add(tf.keras.layers.LSTM(\n", + " units = 32,\n", + " kernel_initializer = glorot_uniform(), # Initialize the input weights\n", + " recurrent_initializer = orthogonal(), # Initialize the recurrent weights\n", + " bias_initializer = zeros(), # Initialize the biases\n", + " activation = 'relu', \n", + " return_sequences = False\n", + "))\n", + "\n", + "# model_8f.add(tf.keras.layers.Dropout(0.2)) \n", + "model_8f.add(tf.keras.layers.RepeatVector(frwd))\n", + "model_8f.add(tf.keras.layers.LSTM(units = 32, activation = 'relu', return_sequences = True))\n", + "# model_8f.add(tf.keras.layers.Dropout(0.2)) \n", + "model_8f.add(tf.keras.layers.TimeDistributed(Dense(units = n_out)))\n", + "\n", + "# Compile the model with MSE loss computed for each time step\n", + "\n", + "# sgd = SGD(learning_rate = 0.1)\n", + "# model_8f.compile(optimizer = sgd, loss = 'mse')\n", + "model_8f.compile(optimizer = 'adam', loss = 'mean_squared_error')\n", + "model_8f.summary()\n", + "\n", + "# es = EarlyStopping(monitor = 'val_loss', mode = 'min', verbose = 1, patience = 5)\n", + "\n", + "# fit model\n", + "# The number of epochs is the number of complete passes through the training dataset\n", + "history = model_8f.fit(X, y, epochs = 500, \n", + " validation_split = 0.2,\n", + " verbose = 2)\n", + " # , callbacks=[es])\n", + " # , callbacks = [TimeStepErrorLogger()])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e40d38e-3eb1-4b9d-8d2a-8ec6a6a56f38", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 175, + "id": "badacf02-562c-495a-8d62-374545da5804", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a figure and axis object\n", + "fig, ax = plt.subplots(1, 1)\n", + "\n", + "# Plot the data\n", + "ax.plot(history.history['loss'], 'blue')\n", + "ax.plot(history.history['val_loss'], 'red')\n", + "\n", + "# Customize the plot\n", + "ax.set_title('Model Loss (blue) vs Val. Loss (red)')\n", + "ax.set_xlabel('Epoch')\n", + "ax.set_ylabel('Loss')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "d08d10b3-a984-4dec-b1af-e29a9e937626", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract weights from the LSTM layer\n", + "lstm_layer = model_8f.layers[0]\n", + "lstm_weights = lstm_layer.get_weights()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "1f7cdb81-3ea1-467d-8492-fbdc469a4039", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kernel shape: (8, 8)\n", + "Recurrent Kernel shape: (2, 8)\n", + "Bias shape: (8,)\n" + ] + } + ], + "source": [ + "kernel, recurrent_kernel, bias = lstm_weights\n", + "\n", + "# Print the shapes\n", + "print(f\"Kernel shape: {kernel.shape}\")\n", + "print(f\"Recurrent Kernel shape: {recurrent_kernel.shape}\")\n", + "print(f\"Bias shape: {bias.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 223, + "id": "5be4cb34-6a95-426f-b08f-1c26fcfdaa90", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kernel weights: [[ 0.05232579 0.01374082 0.01113737 ... -0.03336089 0.03715584\n", + " -0.03538815]\n", + " [ 0.03264289 0.02306121 0.02604442 ... 0.03129478 -0.05207984\n", + " 0.04096095]\n", + " [-0.02632057 -0.02589257 -0.02369264 ... -0.03858705 -0.01252202\n", + " 0.00666459]\n", + " ...\n", + " [-0.01920575 -0.00956063 0.02410255 ... 0.01255936 0.04612235\n", + " 0.05381919]\n", + " [ 0.04781022 0.01975601 -0.0432153 ... 0.05187599 -0.01336266\n", + " 0.03635232]\n", + " [-0.03965205 -0.00055679 -0.03181865 ... 0.0390408 -0.0238521\n", + " 0.00138673]]\n", + "Recurrent kernel weights: [[-0.01153879 -0.00017272 0.0282393 ... 0.00996209 0.01181875\n", + " -0.01943585]\n", + " [ 0.01909763 0.00872338 0.02296009 ... 0.01635076 0.01008803\n", + " -0.01466706]\n", + " [ 0.02507331 0.0413265 -0.00896156 ... 0.01102871 0.00432566\n", + " 0.01624689]\n", + " ...\n", + " [-0.00220611 -0.00429316 0.03294532 ... -0.02962208 0.02178407\n", + " -0.00670702]\n", + " [ 0.00095747 0.00812461 0.00659628 ... 0.03368684 -0.05981153\n", + " 0.00807448]\n", + " [ 0.00640679 0.01504548 0.01278104 ... -0.00735644 -0.00102678\n", + " -0.02216036]]\n", + "Bias weights: [ 8.6383414e-05 0.0000000e+00 0.0000000e+00 ... -6.8583427e-07\n", + " 1.6081285e-05 1.9838195e-04]\n" + ] + } + ], + "source": [ + "# Print the weights\n", + "print(\"Kernel weights:\", kernel)\n", + "print(\"Recurrent kernel weights:\", recurrent_kernel)\n", + "print(\"Bias weights:\", bias)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb2a2814-070a-40e4-b909-a18698b0b848", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "7ab3f50a-cf41-4307-b34b-17b0614504e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sample_size: 4485\n", + "[3444 2461 3517 2548 1172 3424 976 2268 1445 3323]\n", + "XXXX ====== Actual Input ====== XXXX\n", + "[[[4.91900000e-01 2.85165527e+04 3.67903000e-01 8.77595847e+01\n", + " 7.93500000e-01 4.74830980e+02 6.91327800e-01 1.06080062e+01]\n", + " [4.95300000e-01 1.84248992e+04 3.67317000e-01 4.51914654e+01\n", + " 7.96300000e-01 7.50671488e+01 6.90076200e-01 7.32009821e+00]\n", + " [4.95400000e-01 3.43324861e+04 3.67229000e-01 8.47281527e+01\n", + " 7.96100000e-01 1.14132468e+02 6.89944300e-01 5.18948335e+00]\n", + " [4.95700000e-01 2.15298357e+05 3.67687000e-01 5.10162893e+01\n", + " 7.96800000e-01 6.55170188e+01 6.90316800e-01 4.38908488e+00]\n", + " [4.96900000e-01 2.29025823e+05 3.67847000e-01 6.77505122e+01\n", + " 7.97500000e-01 2.27206460e+02 6.90792100e-01 5.71190279e+00]\n", + " [4.97200000e-01 1.35593174e+05 3.68042000e-01 3.77163439e+01\n", + " 7.98400000e-01 5.48284123e+02 6.91105400e-01 4.84039589e+00]\n", + " [4.97800000e-01 2.99639502e+05 3.67965000e-01 6.48344487e+01\n", + " 7.98100000e-01 1.76385979e+02 6.91101700e-01 8.32839892e+00]\n", + " [4.96500000e-01 1.21164386e+05 3.67995000e-01 1.69759580e+01\n", + " 7.98100000e-01 5.57862063e+01 6.91194900e-01 4.48928283e+00]]\n", + "\n", + " [[4.98800000e-01 1.07007705e+04 3.67842000e-01 2.05497321e+01\n", + " 8.01000000e-01 9.76422592e+01 6.93305200e-01 2.08234279e+00]\n", + " [4.98800000e-01 8.76357682e+03 3.67842000e-01 2.45268451e+01\n", + " 8.01300000e-01 8.10546620e+01 6.92960100e-01 2.66734846e+00]\n", + " [4.98700000e-01 2.74902948e+04 3.67820000e-01 6.49791656e+01\n", + " 8.01400000e-01 3.53138231e+01 6.93127700e-01 1.50345221e+00]\n", + " [4.98900000e-01 1.14209532e+05 3.67874000e-01 4.48622068e+01\n", + " 8.01400000e-01 7.06801422e+01 6.93293600e-01 1.57980874e+00]\n", + " [4.98700000e-01 5.17001836e+04 3.67886000e-01 4.22026498e+01\n", + " 8.01400000e-01 9.10803486e+01 6.93385000e-01 3.53739017e+00]\n", + " [4.98800000e-01 4.82191403e+04 3.67886000e-01 2.41292728e+01\n", + " 8.01600000e-01 1.47099118e+02 6.93372200e-01 1.82757717e+00]\n", + " [4.99900000e-01 2.05310429e+04 3.69059000e-01 8.26260728e+01\n", + " 8.02500000e-01 3.93397045e+02 6.94147100e-01 2.40852567e+00]\n", + " [4.98600000e-01 2.17133399e+04 3.67669000e-01 4.67225044e+01\n", + " 8.01000000e-01 1.05135855e+02 6.93240500e-01 1.95429090e+00]]\n", + "\n", + " [[5.22600000e-01 1.39840038e+05 3.81523000e-01 5.00122750e+00\n", + " 8.41700000e-01 1.24987592e+01 7.12149300e-01 2.61801778e+00]\n", + " [5.22800000e-01 2.68969941e+03 3.82313000e-01 1.30827581e+01\n", + " 8.42600000e-01 1.00775557e+01 7.12684400e-01 5.05627330e-01]\n", + " [5.22700000e-01 3.13847271e+03 3.82009000e-01 1.85996850e+01\n", + " 8.42400000e-01 1.77229845e+01 7.12188800e-01 1.10268813e+01]\n", + " [5.22500000e-01 6.75279776e+03 3.81963000e-01 4.37579874e+00\n", + " 8.42000000e-01 5.03515385e+01 7.12230300e-01 9.60494540e-01]\n", + " [5.22600000e-01 9.09866130e+03 3.81978000e-01 4.94506097e+00\n", + " 8.42200000e-01 1.22180569e+00 7.12479900e-01 1.34226875e+00]\n", + " [5.22400000e-01 5.00439858e+04 3.81945000e-01 1.05686095e+01\n", + " 8.41900000e-01 6.57209801e+01 7.12418400e-01 1.49653793e+00]\n", + " [5.22500000e-01 1.45437914e+04 3.81966000e-01 9.57898972e+00\n", + " 8.41900000e-01 2.11501791e+01 7.12387200e-01 2.38567678e+00]\n", + " [5.22300000e-01 1.24534018e+04 3.81907000e-01 1.03477777e+01\n", + " 8.41500000e-01 2.06003030e+01 7.12213700e-01 2.11093786e+00]]\n", + "\n", + " [[4.93100000e-01 3.02525760e+03 3.68837000e-01 4.82890495e+00\n", + " 7.97300000e-01 2.07119275e+01 6.94511000e-01 8.35140770e-01]\n", + " [4.94500000e-01 3.68138291e+04 3.68980000e-01 4.07393591e+00\n", + " 7.97300000e-01 2.37462099e+02 6.94680600e-01 1.72490654e+00]\n", + " [4.95000000e-01 3.33194366e+04 3.69189000e-01 2.55834653e+01\n", + " 7.97900000e-01 1.72838645e+02 6.94811200e-01 2.41188116e+00]\n", + " [4.95100000e-01 1.38397717e+04 3.69200000e-01 9.43631585e+00\n", + " 7.98200000e-01 1.29042737e+02 6.94749100e-01 1.70376158e+00]\n", + " [4.95200000e-01 1.74001280e+03 3.69270000e-01 5.39680801e+00\n", + " 7.98800000e-01 2.62608799e+01 6.94724500e-01 1.09210278e+00]\n", + " [4.93600000e-01 2.19330316e+04 3.69004000e-01 2.41624631e+01\n", + " 7.97400000e-01 1.65891306e+02 6.94715800e-01 8.26815640e-01]\n", + " [4.93900000e-01 2.54213464e+04 3.69107000e-01 1.81314972e+01\n", + " 7.98000000e-01 3.85160347e+01 6.94802500e-01 1.34991770e+00]\n", + " [4.94000000e-01 3.04526279e+04 3.69145000e-01 1.73231419e+01\n", + " 7.97000000e-01 7.92920897e+01 6.94704400e-01 6.44866270e-01]]\n", + "\n", + " [[4.93000000e-01 3.42625103e+04 3.67229000e-01 1.22028997e+01\n", + " 7.97400000e-01 5.08485769e+01 6.93555000e-01 5.61673890e-01]\n", + " [4.93100000e-01 7.52126882e+03 3.67279000e-01 7.99187705e+00\n", + " 7.97800000e-01 5.45016114e+01 6.93571900e-01 3.13484520e-01]\n", + " [4.93300000e-01 1.15386530e+04 3.67385000e-01 5.83091656e+00\n", + " 7.98000000e-01 1.07818908e+01 6.93614000e-01 3.13496670e-01]\n", + " [4.93400000e-01 2.12272369e+04 3.67452000e-01 9.52407854e+00\n", + " 7.98500000e-01 8.88557497e+01 6.93640000e-01 6.34791400e-01]\n", + " [4.93100000e-01 1.52929433e+04 3.67239000e-01 1.31101354e+01\n", + " 7.97100000e-01 2.13197511e+01 6.93573400e-01 1.54853732e+00]\n", + " [4.93700000e-01 1.25103187e+04 3.67473000e-01 5.42380775e+00\n", + " 7.98500000e-01 2.86239360e+01 6.93716800e-01 4.41324740e-01]\n", + " [4.93900000e-01 5.13969992e+03 3.67613000e-01 4.19277070e+00\n", + " 7.98800000e-01 2.38044139e+01 6.93795800e-01 2.78444380e-01]\n", + " [4.94000000e-01 6.82302725e+03 3.67841000e-01 6.58054527e+00\n", + " 7.99000000e-01 3.21805152e+01 6.94015000e-01 5.76701460e-01]]\n", + "\n", + " [[4.92600000e-01 5.75509792e+03 3.67608000e-01 4.81205131e+01\n", + " 8.00200000e-01 4.16793362e+01 6.93165600e-01 3.10123823e+00]\n", + " [4.92400000e-01 9.84990223e+03 3.67526000e-01 2.10671157e+01\n", + " 8.00300000e-01 8.04173570e+00 6.93038500e-01 1.14990365e+00]\n", + " [4.92500000e-01 8.54802390e+03 3.67587000e-01 1.16503534e+01\n", + " 8.00000000e-01 1.52858409e+02 6.93089600e-01 2.26364970e-01]\n", + " [4.92500000e-01 5.32515363e+03 3.67621000e-01 4.27023701e+00\n", + " 7.99900000e-01 2.02544244e+01 6.93207600e-01 6.67096820e-01]\n", + " [4.92500000e-01 2.83275925e+03 3.67625000e-01 1.87265988e+01\n", + " 7.99900000e-01 1.38751458e+01 6.93434400e-01 1.92171998e+00]\n", + " [4.92600000e-01 2.25925246e+04 3.67413000e-01 1.23766830e+02\n", + " 7.99800000e-01 2.29777418e+01 6.93089000e-01 5.42066520e-01]\n", + " [4.92600000e-01 1.16192775e+04 3.67479000e-01 1.42837791e+01\n", + " 7.99600000e-01 8.51286872e+00 6.93085100e-01 1.34806064e+00]\n", + " [4.92700000e-01 6.46768239e+03 3.67621000e-01 1.25676508e+01\n", + " 7.99900000e-01 1.49247738e+01 6.93126200e-01 8.99892260e-01]]\n", + "\n", + " [[4.95000000e-01 1.07008358e+04 3.69573000e-01 7.55537839e+00\n", + " 8.01800000e-01 7.29007627e+00 6.94660800e-01 1.72226637e+00]\n", + " [4.94900000e-01 2.75450860e+03 3.69619000e-01 7.32033056e+00\n", + " 8.02100000e-01 1.18809504e+01 6.94710300e-01 1.14962087e+00]\n", + " [4.95100000e-01 1.08410117e+04 3.69572000e-01 2.83773641e+00\n", + " 8.02000000e-01 7.58737369e+00 6.94613000e-01 1.24252866e+00]\n", + " [4.95100000e-01 1.72537831e+04 3.69656000e-01 1.45647462e+01\n", + " 8.02400000e-01 2.87925742e+01 6.94639700e-01 4.04561400e-01]\n", + " [4.94200000e-01 9.86041426e+02 3.69328000e-01 1.05481884e+00\n", + " 8.00900000e-01 8.18180430e+00 6.93793200e-01 1.52223720e-01]\n", + " [4.95600000e-01 1.43303516e+04 3.69860000e-01 1.33860206e+01\n", + " 8.02600000e-01 1.72982420e+01 6.94891100e-01 2.21427138e+00]\n", + " [4.95500000e-01 4.17154371e+03 3.69876000e-01 1.09511989e+01\n", + " 8.02300000e-01 5.71997851e+01 6.94977300e-01 3.97323409e+00]\n", + " [4.95800000e-01 2.65183452e+03 3.69938000e-01 1.68684779e+01\n", + " 8.02700000e-01 4.31418043e+00 6.95157800e-01 7.03872760e-01]]\n", + "\n", + " [[4.94800000e-01 1.89431957e+04 3.69246000e-01 1.00902993e+01\n", + " 8.04000000e-01 2.80570594e+01 6.95087900e-01 1.09283300e+00]\n", + " [4.95200000e-01 1.77274711e+04 3.69024000e-01 1.17578106e+01\n", + " 8.02000000e-01 1.36036515e+01 6.94672800e-01 1.73535308e+00]\n", + " [4.94700000e-01 5.93736492e+03 3.69205000e-01 4.00430064e+00\n", + " 8.03700000e-01 5.58754980e+01 6.95094700e-01 6.11436430e-01]\n", + " [4.94900000e-01 2.72499517e+04 3.69222000e-01 4.86308799e+00\n", + " 8.03400000e-01 6.79371760e+01 6.95006000e-01 1.45114199e+00]\n", + " [4.94500000e-01 9.56207886e+03 3.69142000e-01 1.21657638e+01\n", + " 8.03100000e-01 1.39407786e+01 6.94748700e-01 7.89065330e-01]\n", + " [4.94400000e-01 7.02915593e+03 3.69160000e-01 2.72298672e+00\n", + " 8.03100000e-01 1.97028165e+01 6.94839900e-01 4.33714160e-01]\n", + " [4.94600000e-01 8.80194057e+03 3.69213000e-01 1.10343026e+01\n", + " 8.03100000e-01 1.88170126e+01 6.94946500e-01 5.43629640e-01]\n", + " [4.94700000e-01 1.69578167e+04 3.69128000e-01 8.51258343e+00\n", + " 8.03800000e-01 2.15048197e+01 6.94797300e-01 5.96437430e-01]]\n", + "\n", + " [[4.94600000e-01 4.86422894e+03 3.68779000e-01 9.91169723e+00\n", + " 8.03400000e-01 1.42868230e+01 6.93821300e-01 3.88555360e-01]\n", + " [4.94700000e-01 4.91384285e+04 3.68987000e-01 1.00831321e+01\n", + " 8.03800000e-01 4.69497219e+01 6.94268400e-01 1.66799815e+00]\n", + " [4.94500000e-01 4.50217889e+03 3.68984000e-01 4.69434928e+00\n", + " 8.03900000e-01 1.21029552e+01 6.94185900e-01 8.78172000e-01]\n", + " [4.95300000e-01 2.60004030e+03 3.69160000e-01 1.81409645e+01\n", + " 8.01800000e-01 2.88165015e+01 6.94710300e-01 2.52977208e+00]\n", + " [4.94600000e-01 3.02959510e+04 3.68948000e-01 6.84444565e+00\n", + " 8.04200000e-01 1.12168509e+01 6.94186300e-01 7.30781200e-01]\n", + " [4.94500000e-01 8.75105937e+03 3.68947000e-01 3.93544853e+00\n", + " 8.04100000e-01 8.43232789e+00 6.94143000e-01 2.73413870e-01]\n", + " [4.94700000e-01 8.08725128e+03 3.68987000e-01 1.26816155e+01\n", + " 8.04200000e-01 2.14423490e+01 6.94200000e-01 8.23884290e-01]\n", + " [4.94700000e-01 1.58749120e+04 3.68941000e-01 7.55447244e+00\n", + " 8.03900000e-01 2.91841612e+01 6.94123900e-01 7.04898490e-01]]\n", + "\n", + " [[4.95100000e-01 8.29167555e+03 3.69282000e-01 1.82985366e+01\n", + " 8.05900000e-01 3.00306365e+01 6.95408300e-01 8.19471870e-01]\n", + " [4.95000000e-01 1.86604344e+03 3.69240000e-01 7.55855134e+00\n", + " 8.05200000e-01 3.26059709e+01 6.94863500e-01 5.20499770e-01]\n", + " [4.95200000e-01 1.42637913e+04 3.69329000e-01 9.66275562e+00\n", + " 8.05700000e-01 9.87090237e+00 6.95620300e-01 2.11625586e+00]\n", + " [4.95300000e-01 8.31469725e+03 3.69252000e-01 1.51421228e+01\n", + " 8.05300000e-01 7.73527880e+01 6.95537800e-01 2.98841999e+00]\n", + " [4.95200000e-01 4.12276630e+03 3.69268000e-01 1.61726013e+01\n", + " 8.05000000e-01 7.01341249e+01 6.95345800e-01 8.20871120e-01]\n", + " [4.95200000e-01 3.54415629e+03 3.69194000e-01 9.52500491e+00\n", + " 8.05000000e-01 7.20951413e+01 6.95208600e-01 4.15137160e+00]\n", + " [4.95200000e-01 1.68910388e+03 3.69162000e-01 1.19417970e+01\n", + " 8.05400000e-01 5.31725332e+01 6.95205000e-01 5.07932280e-01]\n", + " [4.95300000e-01 5.97806601e+03 3.69180000e-01 2.43125279e+01\n", + " 8.05800000e-01 1.82218695e+01 6.95247500e-01 8.31382440e-01]]]\n", + "(10, 8, 8)\n", + "YYYY ====== Actual Input ====== YYYY\n", + "[[[0.6915686]]\n", + "\n", + " [[0.6933044]]\n", + "\n", + " [[0.7122553]]\n", + "\n", + " [[0.6946416]]\n", + "\n", + " [[0.6940752]]\n", + "\n", + " [[0.6931973]]\n", + "\n", + " [[0.6952175]]\n", + "\n", + " [[0.6941199]]\n", + "\n", + " [[0.6946209]]\n", + "\n", + " [[0.6952265]]]\n", + "(10, 1, 1)\n" + ] + } + ], + "source": [ + "# Validation Set - 06.18.2024\n", + "# ============================\n", + "# Reset Index\n", + "sample_valid = sample_valid.reset_index(drop = True)\n", + "sample_size = sample_valid.shape[0]\n", + "print ('sample_size: ', sample_size)\n", + "# sample_valid.head()\n", + "# sl = 8 # <--- sequence length\n", + "batch_valid = 10 # <--- batch size\n", + "# n_features = 8 # <---- no. of variables\n", + "# n_out = 1 # <----- no. of predicted variables\n", + "# frwd = 1 # <--- how many to predict\n", + "\n", + "# Trimming Indices !!!\n", + "# Marking selected rows\n", + "sample_valid['Selected'] = 0\n", + "\n", + "# Selecting m random rows without replacement\n", + "np.random.seed(374)\n", + "selected_indices = np.random.choice(sample_valid.index, size = batch_valid, replace = False)\n", + "\n", + "sample_valid.loc[selected_indices, 'Selected'] = 1 # print (sample_valid[sample_valid['Selected'] == 1])\n", + "chosen_idx1 = sample_valid[sample_valid['Selected'] == 1].index\n", + "chosen_idx2 = chosen_idx1[chosen_idx1 > sl]\n", + "\n", + "thrown_idx1 = chosen_idx1[chosen_idx1 <= sl]\n", + "cnt_thrown_idx1 = len(thrown_idx1)\n", + "\n", + "chosen_idx3 = chosen_idx2[chosen_idx2 < (sample_size - frwd)]\n", + "\n", + "thrown_idx2 = chosen_idx2[chosen_idx2 >= (sample_size - frwd)]\n", + "cnt_thrown_idx2 = len(thrown_idx2)\n", + "\n", + "cnt_thrown_idx = cnt_thrown_idx1 + cnt_thrown_idx2\n", + "\n", + "print (selected_indices)\n", + "\n", + "all_ts_close_xrp = np.empty((1, )) # final input/output\n", + "all_ts_close_eth = np.empty((1, )) # final input/output\n", + "all_ts_close_ltc = np.empty((1, )) # final input/output\n", + "all_ts_close_btc = np.empty((1, )) # final input/output\n", + "\n", + "all_ts_volume_xrp = np.empty((1, )) # final input/output\n", + "all_ts_volume_eth = np.empty((1, )) # final input/output\n", + "all_ts_volume_ltc = np.empty((1, )) # final input/output\n", + "all_ts_volume_btc = np.empty((1, )) # final input/output\n", + "\n", + "stdev_xrp = np.empty((1, )) # final input/output\n", + "stdev_eth = np.empty((1, )) # final input/output\n", + "stdev_ltc = np.empty((1, )) # final input/output\n", + "stdev_btc = np.empty((1, )) # final input/output\n", + "\n", + "\n", + "aft_ts_close_xrp = np.empty((1))\n", + "aft_ts_close_eth = np.empty((1))\n", + "aft_ts_close_ltc = np.empty((1))\n", + "aft_ts_close_btc = np.empty((1))\n", + "\n", + "for idx in chosen_idx3:\n", + " selected_rows_before = sample_valid.iloc[max(0, idx-sl): idx]\n", + " selected_rows_after = sample_valid.iloc[max(0, idx): idx+frwd]\n", + "\n", + " # xrp\n", + " sr_before_close_xrp = np.array(selected_rows_before['close_xrp'])\n", + " sr_after_close_xrp = np.array(selected_rows_after['close_xrp']) \n", + " # print (sr_before_close_xrp)\n", + " sr_before_volume_xrp = np.array(selected_rows_before['volume_xrp'])\n", + " sr_after_volume_xrp = np.array(selected_rows_after['volume_xrp']) \n", + " # print (sr_before_volume_xrp) \n", + " # Compute standard deviation\n", + " std_dev_xrp = np.std(sr_before_close_xrp)\n", + " std_dev_xrp_arr = np.repeat(std_dev_xrp, sl)\n", + " # print(std_dev_xrp_arr)\n", + " \n", + "# eth\n", + " sr_before_close_eth = np.array(selected_rows_before['close_eth'])\n", + " sr_after_close_eth = np.array(selected_rows_after['close_eth'])\n", + " sr_before_volume_eth = np.array(selected_rows_before['volume_eth'])\n", + " sr_after_volume_eth = np.array(selected_rows_after['volume_eth'])\n", + " # Compute standard deviation\n", + " std_dev_eth = np.std(sr_before_close_eth)\n", + " std_dev_eth_arr = np.repeat(std_dev_eth, sl)\n", + " # print(std_dev_eth_arr)\n", + " \n", + "# ltc\n", + " sr_before_close_ltc = np.array(selected_rows_before['close_ltc'])\n", + " sr_after_close_ltc = np.array(selected_rows_after['close_ltc'])\n", + " sr_before_volume_ltc = np.array(selected_rows_before['volume_ltc'])\n", + " sr_after_volume_ltc = np.array(selected_rows_after['volume_ltc'])\n", + "# Compute standard deviation\n", + " std_dev_ltc = np.std(sr_before_close_ltc)\n", + " std_dev_ltc_arr = np.repeat(std_dev_ltc, sl)\n", + " # print(std_dev_ltc_arr)\n", + "\n", + "# btc\n", + " sr_before_close_btc = np.array(selected_rows_before['close_btc'])\n", + " sr_after_close_btc = np.array(selected_rows_after['close_btc'])\n", + " sr_before_volume_btc = np.array(selected_rows_before['volume_btc'])\n", + " sr_after_volume_btc = np.array(selected_rows_after['volume_btc'])\n", + " # Compute standard deviation\n", + " std_dev_btc = np.std(sr_before_close_btc)\n", + " std_dev_btc_arr = np.repeat(std_dev_btc, sl)\n", + " # print(std_dev_btc_arr)\n", + "\n", + "# xrp\n", + " all_ts_close_xrp = np.concatenate((all_ts_close_xrp, sr_before_close_xrp))\n", + " all_ts_volume_xrp = np.concatenate((all_ts_volume_xrp, sr_before_volume_xrp))\n", + " stdev_xrp = np.concatenate((stdev_xrp, std_dev_xrp_arr))\n", + "# eth\n", + " all_ts_close_eth = np.concatenate((all_ts_close_eth, sr_before_close_eth))\n", + " all_ts_volume_eth = np.concatenate((all_ts_volume_eth, sr_before_volume_eth))\n", + " stdev_eth = np.concatenate((stdev_eth, std_dev_eth_arr))\n", + "# ltc\n", + " all_ts_close_ltc = np.concatenate((all_ts_close_ltc, sr_before_close_ltc))\n", + " all_ts_volume_ltc = np.concatenate((all_ts_volume_ltc, sr_before_volume_ltc))\n", + " stdev_ltc = np.concatenate((stdev_ltc, std_dev_ltc_arr))\n", + "# btc\n", + " all_ts_close_btc = np.concatenate((all_ts_close_btc, sr_before_close_btc))\n", + " all_ts_volume_btc = np.concatenate((all_ts_volume_btc, sr_before_volume_btc))\n", + " stdev_btc = np.concatenate((stdev_btc, std_dev_btc_arr))\n", + "\n", + "\n", + " aft_ts_close_xrp = np.concatenate((aft_ts_close_xrp, sr_after_close_xrp))\n", + " aft_ts_close_eth = np.concatenate((aft_ts_close_eth, sr_after_close_eth))\n", + " aft_ts_close_ltc = np.concatenate((aft_ts_close_ltc, sr_after_close_ltc))\n", + " aft_ts_close_btc = np.concatenate((aft_ts_close_btc, sr_after_close_btc))\n", + "\n", + "\n", + "X_XRP_close = all_ts_close_xrp[1:]\n", + "X_XRP_volume = all_ts_volume_xrp[1:]\n", + "X_XRP_stdev = stdev_xrp[1:]\n", + "\n", + "\n", + "X_ETH_close = all_ts_close_eth[1:]\n", + "X_ETH_volume = all_ts_volume_eth[1:]\n", + "X_ETH_stdev = stdev_eth[1:]\n", + "\n", + "X_LTC_close = all_ts_close_ltc[1:]\n", + "X_LTC_volume = all_ts_volume_ltc[1:]\n", + "X_LTC_stdev = stdev_ltc[1:]\n", + "\n", + "X_BTC_close = all_ts_close_btc[1:]\n", + "X_BTC_volume = all_ts_volume_btc[1:]\n", + "X_BTC_stdev = stdev_btc[1:]\n", + "\n", + "X0_valid = np.column_stack((X_XRP_close, X_XRP_volume, \n", + " X_ETH_close, X_ETH_volume, \n", + " X_LTC_close, X_LTC_volume, \n", + " X_BTC_close, X_BTC_volume))\n", + "# print (X0)\n", + "\n", + "# ======== Model Input =========\n", + "X_valid = X0_valid.reshape(batch_valid-cnt_thrown_idx, sl, n_features)\n", + "print ('XXXX ====== Actual Input ====== XXXX')\n", + "print (X_valid)\n", + "print (X_valid.shape)\n", + "\n", + "y_XRP = aft_ts_close_xrp[1:]\n", + "y_ETH = aft_ts_close_eth[1:]\n", + "y_LTC = aft_ts_close_ltc[1:]\n", + "y_BTC = aft_ts_close_btc[1:]\n", + "\n", + "# y_valid = np.column_stack((y_XRP, y_ETH, y_LTC, y_BTC))\n", + "# print (y_valid)\n", + "\n", + "y_valid = y_BTC.reshape(batch_valid-cnt_thrown_idx, frwd, n_out)\n", + "print ('YYYY ====== Actual Input ====== YYYY')\n", + "print (y_valid)\n", + "print (y_valid.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "id": "263e1cab-3b94-49e2-a278-fa0336867310", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 554ms/step\n", + "y_valid\n", + "\n", + "(10, 1, 1)\n", + "[[[0.6915686]]\n", + "\n", + " [[0.6933044]]\n", + "\n", + " [[0.7122553]]\n", + "\n", + " [[0.6946416]]\n", + "\n", + " [[0.6940752]]\n", + "\n", + " [[0.6931973]]\n", + "\n", + " [[0.6952175]]\n", + "\n", + " [[0.6941199]]\n", + "\n", + " [[0.6946209]]\n", + "\n", + " [[0.6952265]]]\n", + "y_hat\n", + "\n", + "(10, 1)\n", + "[[ 8.0367511e+02]\n", + " [ 1.3962366e+02]\n", + " [ 5.3128414e+01]\n", + " [-5.9378960e+01]\n", + " [-6.6341087e+01]\n", + " [-6.4128904e+00]\n", + " [ 2.1907943e-03]\n", + " [-1.9205887e+01]\n", + " [-1.2864524e+01]\n", + " [-9.5366278e+00]]\n" + ] + } + ], + "source": [ + "y_hat = model_8f.predict(X_valid, verbose = 1).reshape(batch_valid-cnt_thrown_idx, frwd)\n", + "# print (sl)\n", + "\n", + "print ('y_valid')\n", + "print (type(y_valid))\n", + "print (y_valid.shape)\n", + "print (y_valid)\n", + "# print (y_valid[0:10])\n", + "\n", + "print ('y_hat')\n", + "print (type(y_hat))\n", + "print (y_hat.shape)\n", + "print (y_hat)\n", + "# y_ht1 = y_hat.reshape(batch-cnt_thrown_idx, frwd)\n", + "# # print (y_hat[0:10])\n", + "# print (y_ht1)" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "id": "e1969a05-91ff-40df-a466-01edd42f1b40", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "2\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "3\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "6\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "7\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2IAAAIjCAYAAABh3KjvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB0dElEQVR4nO3deVxVdf7H8fdlF2QJBRHBfUFTcStHszJXzJqy0iz7uVQ6LVZq06RTmVpqWjqlNS2TaTU6tkyWWTmSS82Y5VJomnsqKuCSAgIKF+75/YHcIlBBOffce3k9H4/7GO+555z7OR+YHr493+/32AzDMAQAAAAAcBkfqwsAAAAAgOqGIAYAAAAALkYQAwAAAAAXI4gBAAAAgIsRxAAAAADAxQhiAAAAAOBiBDEAAAAAcDGCGAAAAAC4GEEMAAAAAFyMIAYA8Dg2m02TJk2yugwAAC4aQQwAqrm///3vstls6ty580WfIy0tTZMmTVJKSkrVFeal1qxZI5vNVu5r8ODBVpdnus8//5wQDQCS/KwuAABgrYULF6phw4Zav3699uzZo6ZNm1b6HGlpaZo8ebIaNmyodu3aVX2RXujhhx/WFVdcUWpbw4YNrSnGhT7//HO98sorhDEA1R5BDACqsX379umbb77RRx99pD/96U9auHChnn76aavLqhauvvpq3XbbbVV+3tzcXIWEhFT5eQEAVYuhiQBQjS1cuFCXXXaZ+vfvr9tuu00LFy4sd7/MzEyNHTtWDRs2VGBgoOLi4jR06FAdP35ca9ascd7ZGTFihHOY3YIFCyQV3+UZPnx4mXN2795d3bt3d74vKCjQxIkT1bFjR4WHhyskJERXX321Vq9efcHrOHXqlMaMGeOsLzo6Wr1799b3339/zmM+/PBD2Ww2ffXVV2U+e/3112Wz2bR161ZJUkZGhkaMGKG4uDgFBgaqbt26uummm7R///4L1naxfvjhB/Xr109hYWGqWbOmevbsqW+//bbUPgsWLHBewwMPPKDo6GjFxcU5P//iiy909dVXKyQkRKGhoerfv7+2bdtW5rt27NihQYMGKSoqSjVq1FCLFi30xBNPOD8/cOCAHnjgAbVo0UI1atRQrVq1NHDgwDLXb7fbNXnyZDVr1kxBQUGqVauWunXrpuTkZEnS8OHD9corr0hSqSGZJRYvXqyOHTsqNDRUYWFhatOmjV566aVL7iUAuCPuiAFANbZw4ULdcsstCggI0B133KFXX31VGzZsKDVkLicnR1dffbW2b9+uu+++Wx06dNDx48e1dOlSHTp0SC1bttSUKVM0ceJEjRo1SldffbUkqWvXrpWqJTs7W2+++abuuOMOjRw5UqdOndK8efPUt29frV+//rxDHu+77z59+OGHGj16tFq1aqVffvlF//vf/7R9+3Z16NCh3GP69++vmjVr6v3339e1115b6rP33ntPl19+uVq3bi1JuvXWW7Vt2zY99NBDatiwoY4ePark5GSlpqZe9HDCU6dO6fjx46W2RUZGysfHR9u2bdPVV1+tsLAw/eUvf5G/v79ef/11de/eXV999VWZ+XwPPPCAoqKiNHHiROXm5kqS3n33XQ0bNkx9+/bVjBkzlJeXp1dffVXdunXTDz/84Kx7y5Ytuvrqq+Xv769Ro0apYcOG2rt3rz799FNNnTpVkrRhwwZ98803Gjx4sOLi4rR//369+uqr6t69u3766ScFBwdLkiZNmqTp06fr3nvv1ZVXXqns7Gxt3LhR33//vXr37q0//elPSktLU3Jyst59991S15CcnKw77rhDPXv21IwZMyRJ27dv19q1a/XII49cVI8BwK0ZAIBqaePGjYYkIzk52TAMw3A4HEZcXJzxyCOPlNpv4sSJhiTjo48+KnMOh8NhGIZhbNiwwZBkzJ8/v8w+DRo0MIYNG1Zm+7XXXmtce+21zveFhYVGfn5+qX1Onjxp1KlTx7j77rtLbZdkPP3008734eHhxoMPPnieqy3fHXfcYURHRxuFhYXObenp6YaPj48xZcoUZw2SjOeff77S5y/P6tWrDUnlvvbt22cYhmHcfPPNRkBAgLF3717ncWlpaUZoaKhxzTXXOLfNnz/fkGR069at1DWcOnXKiIiIMEaOHFnquzMyMozw8PBS26+55hojNDTUOHDgQKl9S362hmEYeXl5Za5j3bp1hiTjnXfecW5LTEw0+vfvf97rf/DBB43y/vrxyCOPGGFhYaWuAwC8GUMTAaCaWrhwoerUqaPrrrtOUvFQsdtvv12LFy9WUVGRc79///vfSkxM1IABA8qc47fDyi6Vr6+vAgICJEkOh0MnTpxQYWGhOnXqdN4hhpIUERGh7777TmlpaZX6zttvv11Hjx7VmjVrnNs+/PBDORwO3X777ZKkGjVqKCAgQGvWrNHJkycrd1HnMXHiRCUnJ5d6xcTEqKioSCtWrNDNN9+sxo0bO/evW7eu7rzzTv3vf/9TdnZ2qXONHDlSvr6+zvfJycnKzMzUHXfcoePHjztfvr6+6ty5s3O457Fjx/T111/r7rvvVv369Uud87c/2xo1ajj/bLfb9csvv6hp06aKiIgo9bOJiIjQtm3btHv37kr3IyIiQrm5uc5hjADg7QhiVejrr7/WjTfeqNjYWNlsNn388ceVPodhGHrhhRfUvHlzBQYGql69es6hIQBQVYqKirR48WJdd9112rdvn/bs2aM9e/aoc+fOOnLkiFauXOncd+/evc4hemZ7++231bZtW+f8oqioKH322WfKyso673EzZ87U1q1bFR8fryuvvFKTJk3Szz//fMHvS0pKUnh4uN577z3ntvfee0/t2rVT8+bNJUmBgYGaMWOGvvjiC9WpU0fXXHONZs6cqYyMjEu61jZt2qhXr16lXkFBQTp27Jjy8vLUokWLMse0bNlSDodDBw8eLLW9UaNGpd6XBKEePXooKiqq1GvFihU6evSoJDl7dKGf7+nTpzVx4kTFx8crMDBQtWvXVlRUlDIzM0v9bKZMmaLMzEw1b95cbdq00WOPPaYtW7ZUqB8PPPCAmjdvrn79+ikuLk533323li9fXqFjAcATEcSqUG5urhITE50TkS/GI488ojfffFMvvPCCduzYoaVLl+rKK6+swioBQFq1apXS09O1ePFiNWvWzPkaNGiQJJ1z0Y6Lca67Zr+96yZJ//znPzV8+HA1adJE8+bN0/Lly5WcnKwePXrI4XCc9zsGDRqkn3/+WXPnzlVsbKyef/55XX755friiy/Oe1xgYKBuvvlmLVmyRIWFhTp8+LDWrl3rvBtWYsyYMdq1a5emT5+uoKAgPfXUU2rZsqV++OGHCnTAfL+9YyXJ2a933323zF235ORkffLJJ5U6/0MPPaSpU6dq0KBBev/997VixQolJyerVq1apX4211xzjfbu3au33npLrVu31ptvvqkOHTrozTffvOB3REdHKyUlRUuXLtUf//hHrV69Wv369dOwYcMqVSsAeAyrx0Z6K0nGkiVLSm07c+aM8eijjxqxsbFGcHCwceWVVxqrV692fv7TTz8Zfn5+xo4dO1xbLIBqZ9iwYUZ0dLTxwQcflHndcccdRmhoqHNe0OWXX24kJiae93wl883KmyPWvn1746abbiqzPT4+vtQcsZtuuslo3LhxqblJhmEYXbt2NRo0aFBqm343R+z3jhw5YtSrV8+46qqrzlu3YRjG559/bkgyli9fbvztb38zJBk///zzeY/ZtWuXERwcbAwZMuSC5/+9kjliH3zwQbmfFxYWGsHBwcagQYPKfHbfffcZPj4+RlZWlmEYv84R27BhQ6n93n//fUOS8Z///Oe8tRw9etSQVGZe4O+Fh4cbI0aMKLXt9OnThq+vb7nz/0qcOnXKaN++vVGvXj3nttGjR5c7R+z3ioqKjD/96U+GJGP37t0X3B8APA13xFxo9OjRWrdunRYvXqwtW7Zo4MCBSkpKcg4h+fTTT9W4cWMtW7ZMjRo1UsOGDXXvvffqxIkTFlcOwJucPn1aH330kW644QbddtttZV6jR4/WqVOntHTpUknFKwZu3rxZS5YsKXMuwzAkyfncqszMzDL7NGnSRN9++60KCgqc25YtW1ZmeF3JHKeSc0rSd999p3Xr1p33eoqKisoMXYyOjlZsbKzy8/PPe6wk9erVS5GRkXrvvff03nvv6corryw11C8vL09nzpwpc02hoaGlzp+enq4dO3bIbrdf8DvPx9fXV3369NEnn3xSann4I0eOaNGiRerWrZvCwsLOe46+ffsqLCxM06ZNK7eeY8eOSZKioqJ0zTXX6K233lJqamqpfX77c/D19S31XpLmzp1b5q7mL7/8Uup9zZo11bRp01J9Otfvyu+P9fHxUdu2bSWpQj9HAPA0LF/vIqmpqZo/f75SU1MVGxsrSfrzn/+s5cuXa/78+Zo2bZp+/vlnHThwQB988IHeeecdFRUVaezYsbrtttu0atUqi68AgLdYunSpTp06pT/+8Y/lfv6HP/xBUVFRWrhwoW6//XY99thj+vDDDzVw4EDdfffd6tixo06cOKGlS5fqtddeU2Jiopo0aaKIiAi99tprCg0NVUhIiDp37qxGjRrp3nvv1YcffqikpCQNGjRIe/fu1T//+U81adKk1PfecMMN+uijjzRgwAD1799f+/bt02uvvaZWrVopJyfnnNdz6tQpxcXF6bbbblNiYqJq1qypL7/8Uhs2bNCsWbMu2A9/f3/dcsstWrx4sXJzc/XCCy+U+nzXrl3q2bOnBg0apFatWsnPz09LlizRkSNHNHjwYOd+EyZM0Ntvv619+/Zd9JL2JZ599lklJyerW7dueuCBB+Tn56fXX39d+fn5mjlz5gWPDwsL06uvvqr/+7//U4cOHTR48GBFRUUpNTVVn332ma666iq9/PLLkqQ5c+aoW7du6tChg0aNGqVGjRpp//79+uyzz5SSkiKp+Gfz7rvvKjw8XK1atdK6dev05ZdfqlatWqW+t1WrVurevbs6duyoyMhIbdy40flYgRIdO3aUJD388MPq27evfH19NXjwYOc/PPbo0UNxcXE6cOCA5s6dq3bt2qlly5aX1E8AcEvW3pDzXvrd0MRly5YZkoyQkJBSLz8/P+fwk5EjRxqSjJ07dzqP27RpkyGJ4YoAqsyNN95oBAUFGbm5uefcZ/jw4Ya/v79x/PhxwzAM45dffjFGjx5t1KtXzwgICDDi4uKMYcOGOT83DMP45JNPjFatWhl+fn5lhinOmjXLqFevnhEYGGhcddVVxsaNG8ssX+9wOIxp06YZDRo0MAIDA4327dsby5YtM4YNG3beoYn5+fnGY489ZiQmJhqhoaFGSEiIkZiYaPz973+vcE+Sk5MNSYbNZjMOHjxY6rPjx48bDz74oJGQkGCEhIQY4eHhRufOnY3333+/1H7Dhg0rtQT9uVxoaGKJ77//3ujbt69Rs2ZNIzg42LjuuuuMb775ptQ+5xqa+Nvv6tu3rxEeHm4EBQUZTZo0MYYPH25s3Lix1H5bt241BgwYYERERBhBQUFGixYtjKeeesr5+cmTJ40RI0YYtWvXNmrWrGn07dvX2LFjR5lHEzz77LPGlVdeaURERBg1atQwEhISjKlTpxoFBQXOfQoLC42HHnrIiIqKMmw2m3OY4ocffmj06dPHiI6ONgICAoz69esbf/rTn4z09PTz9gkAPJXNMH431gBVwmazacmSJbr55pslFa/CNWTIEG3btq3UEsNS8dCNmJgYPf3002WGkZw+fVrBwcFasWKFevfu7cpLAAAAAGAShia6SPv27VVUVKSjR4/q6quvLnefq666SoWFhdq7d69zyM6uXbskSQ0aNHBZrQAAAADMxR2xKpSTk6M9e/ZIKg5es2fP1nXXXafIyEjVr19fd911l9auXatZs2apffv2OnbsmFauXKm2bduqf//+cjgcuuKKK1SzZk29+OKLcjgcevDBBxUWFqYVK1ZYfHUAAAAAqgpBrAqtWbNG1113XZntw4YN04IFC2S32/Xss8/qnXfe0eHDh1W7dm394Q9/0OTJk9WmTRtJUlpamh566CGtWLFCISEh6tevn2bNmqXIyEhXXw4AAAAAkxDEAAAAAMDFeI4YAAAAALgYQQwAAAAAXIxVE6uAw+FQWlqaQkNDZbPZrC4HAAAAgEUMw9CpU6cUGxsrH59z3/ciiFWBtLQ0xcfHW10GAAAAADdx8OBBxcXFnfNzglgVCA0NlVTc7LCwMEtrsdvtWrFihfr06SN/f39La/FG9Ndc9Ndc9Ndc9Ndc9Ndc9Ndc9Ndc7tbf7OxsxcfHOzPCuRDEqkDJcMSwsDC3CGLBwcEKCwtzi19Eb0N/zUV/zUV/zUV/zUV/zUV/zUV/zeWu/b3QlCUW6wAAAAAAFyOIAQAAAICLEcQAAAAAwMUIYgAAAADgYgQxAAAAAHAxghgAAAAAuBhBDAAAAABcjCAGAAAAAC5GEAMAAAAAFyOIAQAAAICLEcQAAAAAwMUIYgAAAADgYgQxAAAAAHAxgpg3cRTJduB/qndinWwH/ic5iqyuyLvQX3PRX3PRX3PRX3PRX3PRX3PRX3N5cH9thmEYVhfh6bKzsxUeHq6srCyFhYW5/Pv/lrxLzU+sVv/DL0rZab9+EBarz+qN0a7I6zS2d3OX1+Ut6K+56K+56K+56K+56K+56K+56K8L/LRUWv54mf4qaYbU6o+WlVXRbMAdMS/Q/MRq9fvpLzJ++0soychOU7+f/qLmJ1ZbVJl3oL/mor/mor/mor/mor/mor/mor8m+2mp9P7Q0iFMkrLTi7f/tNSauiqBO2JVwNI7Yo4i6cXWMrLTZCvnY0OSPSBC2zpMkmzm5W7Dokxvs5V31VXIcOjyTU/JvyDzPP29TNs6TjG3vxb839Qmh/lfYjh0+feTLtBf839/vVYF+7u1g7m/v17LcKj19xMt/++D16rQf3/5/b1oFfr9pb8XrQL9tdWIlG54SfKpgv6a9vchE/+edSk1OxzS0tHS6RPnOnnxnbExP0o+vhf/PRepotmAIFYFLA1i+/4rvX2Da78TAAAAcHfDlkmNrnb511Y0G/i5sCaYIedIhXY77FtP2T7hJhdTeSbfz7pkoY4s1Ss6fMH9DvvW0yk37K9U/K9u7iqsEv11x99fd0d/zVWZ/rrrfx/cWWX++8vvb+Xx3wdzVbS/imwihdS+tC8z7Z6KiX+DuNSa836RTu678H4V/HuyVQhinq5mnQrtVu+u11XPgn8R8HgVvONY767XLfkXF49Xif7y+3sR6K+5+O+Dufj9NRf9NVdFRyzd+BL/fbgYFe1vBf+ebBUG/Xq6Bl2lsNhz/puFIUlh9Yr3Q+XRX3PRX3PRX3PRX3PRX3PRX3PRX3Od7e+5x1bZPKK/BDFP5+Orz+qNkWGUvYFsqPjO72f1HrFkoqJXoL/mor/mor/mor/mor/mor/mor/m8vEtXqJeUtkwdvZ90nNu31+CmBfYFXmdvmg1U7aw2FLbbWH19EWrmdoVeZ1FlXkH+msu+msu+msu+msu+msu+muuc/U3L6gO/a0Krf4oDXpHCqtbentYbPF2C58jVlGsmlgFrH6gs5OjSIU/f62U//5H7a7uK7/G17j9vwR4FPprLvprLvprLvprLvprLvprrrP9XfDJCn35S6TqJfbQrNs7Wl2V93DD318e6Fwd+fjKaNBNhyO7yGjQzfJfQq9Df81Ff81Ff81Ff81Ff81Ff811tr9Ha3XRt45WSjl0yuqKvIsH//4SxAAAAACTNahZPAjt5+O5yj5jt7gauAOCGAAAAGCymv5SXESQDEPaeijL6nLgBghiAAAAgAu0jSt+OHbKoUxrC4FbIIgBAAAALlASxLYc5I4YPDCIvfLKK2rYsKGCgoLUuXNnrV+//rz7f/DBB0pISFBQUJDatGmjzz//vNTnhmFo4sSJqlu3rmrUqKFevXpp9+7dZl4CAAAAqqE29YpX0NvMHTHIw4LYe++9p3Hjxunpp5/W999/r8TERPXt21dHjx4td/9vvvlGd9xxh+655x798MMPuvnmm3XzzTdr69atzn1mzpypOXPm6LXXXtN3332nkJAQ9e3bV2fOnHHVZQEAAKAauLxumHxsUnrWGR3N5u+a1Z2f1QVUxuzZszVy5EiNGDFCkvTaa6/ps88+01tvvaXx48eX2f+ll15SUlKSHnvsMUnSM888o+TkZL388st67bXXZBiGXnzxRT355JO66aabJEnvvPOO6tSpo48//liDBw8ut478/Hzl5+c732dnZ0uS7Ha77HZrV8Ep+X6r6/BW9Ndc9Ndc9Ndc9Ndc9Ndc9NdcJX0N8DHULLqmdh7J0ff7f1HPltEWV+Yd3O33t6J1eMwDnQsKChQcHKwPP/xQN998s3P7sGHDlJmZqU8++aTMMfXr19e4ceM0ZswY57ann35aH3/8sTZv3qyff/5ZTZo00Q8//KB27do597n22mvVrl07vfTSS+XWMmnSJE2ePLnM9kWLFik4OPiirxEAAADebdEeH313zEd96jnUv77D6nJggry8PN15550XfKCzx9wRO378uIqKilSnTp1S2+vUqaMdO3aUe0xGRka5+2dkZDg/L9l2rn3KM2HCBI0bN875Pjs7W/Hx8erTp895m+0KdrtdycnJ6t27t/z9/S2txRvRX3PRX3PRX3PRX3PRX3PRX3P9tr9ZURn6bul25QZF6frrO1pdmldwt9/fktFyF+IxQcydBAYGKjAwsMx2f39/t/jhS+5Vizeiv+aiv+aiv+aiv+aiv+aiv+by9/dXhwa1JEk/Hs6Sn5+fbDabxVV5D3f5/a1oDR6zWEft2rXl6+urI0eOlNp+5MgRxcTElHtMTEzMefcv+d/KnBMAAAC4WC1iQhXo56PsM4Xa/0ue1eXAQh4TxAICAtSxY0etXLnSuc3hcGjlypXq0qVLucd06dKl1P6SlJyc7Ny/UaNGiomJKbVPdna2vvvuu3OeEwAAALhY/r4+ujz27DL2BzOtLQaW8pggJknjxo3TP/7xD7399tvavn277r//fuXm5jpXURw6dKgmTJjg3P+RRx7R8uXLNWvWLO3YsUOTJk3Sxo0bNXr0aEmSzWbTmDFj9Oyzz2rp0qX68ccfNXToUMXGxpZaEAQAAACoKonxEZJ4nlh151FzxG6//XYdO3ZMEydOVEZGhtq1a6fly5c7F9tITU2Vj8+v2bJr165atGiRnnzySf31r39Vs2bN9PHHH6t169bOff7yl78oNzdXo0aNUmZmprp166bly5crKCjI5dcHAAAA75cYFyGJO2LVnUcFMUkaPXq0847W761Zs6bMtoEDB2rgwIHnPJ/NZtOUKVM0ZcqUqioRAAAAOKeSO2Jb07JlL3LI39ejBqmhivBTBwAAAFyoYa1ghQX5qaDQoZ0Zp6wuBxYhiAEAAAAuZLPZmCcGghgAAADgaswTA0EMAAAAcDHnHbGDWdYWAssQxAAAAAAXS4wLlyTtPnpKufmFFlcDKxDEAAAAABeLDgtS3fAgOQxp62HuilVHBDEAAADAAs55YizYUS0RxAAAAAAL/LpyInfEqiOCGAAAAGCBknlirJxYPRHEAAAAAAu0jguXzSYdOnlav+TkW10OXIwgBgAAAFggLMhfTaJqSpK2MDyx2iGIAQAAABZpe3Z4YgrDE6sdghgAAABgkXbOBTsyLa0DrkcQAwAAACxSsoT9lkNZMgzD2mLgUgQxAAAAwCIJdUPl72vTidwCHTp52upy4EIEMQAAAMAigX6+alU3TBLzxKobghgAAABgoZIHO29hnli1QhADAAAALNT27DyxzQdZwr46IYgBAAAAFmoXX7yE/Y+Hs1RY5LC4GrgKQQwAAACwUOPaNVUz0E+n7UXacyzH6nLgIgQxAAAAwEI+Pja1qVd8V2wzC3ZUGwQxAAAAwGIlC3akME+s2iCIAQAAABYrmSfGHbHqgyAGAAAAWKzkjtjOI6d0xl5kbTFwCYIYAAAAYLGYsCBFhQaqyGFoWxrDE6sDghgAAABgMZvNpsSzzxNjnlj1QBADAAAA3EDJPLEthzKtLQQuQRADAAAA3EDbs3fEWLCjeiCIAQAAAG6gbVzxHbH9v+QpM6/A4mpgNoIYAAAA4AYiggPUqHaIJGnLIeaJeTuCGAAAAOAmSu6KMTzR+xHEAAAAADdRsnLiZhbs8HoEMQAAAMBNlDzYOeVglgzDsLYYmIogBgAAALiJy2PD5Odj0/GcfKVnnbG6HJiIIAYAAAC4iSB/X7WICZXEPDFvRxADAAAA3EjJ8MTNrJzo1QhiAAAAgBtJZOXEaoEgBgAAALiRkjtiPx7OksPBgh3eiiAGAAAAuJFm0aEKDvBVTn6hfj6eY3U5MAlBDAAAAHAjvj42tY4tHp6YcpB5Yt6KIAYAAAC4mcR45ol5O48JYidOnNCQIUMUFhamiIgI3XPPPcrJOfet2hMnTuihhx5SixYtVKNGDdWvX18PP/ywsrJK/6uCzWYr81q8eLHZlwMAAACc068rJ2ZaWgfM42d1ARU1ZMgQpaenKzk5WXa7XSNGjNCoUaO0aNGicvdPS0tTWlqaXnjhBbVq1UoHDhzQfffdp7S0NH344Yel9p0/f76SkpKc7yMiIsy8FAAAAOC8EuMiJEnb07OVX1ikQD9fawtClfOIILZ9+3YtX75cGzZsUKdOnSRJc+fO1fXXX68XXnhBsbGxZY5p3bq1/v3vfzvfN2nSRFOnTtVdd92lwsJC+fn9eukRERGKiYkx/0IAAACACoi7rIYiQwJ0IrdA29NPqd3ZO2TwHh4RxNatW6eIiAhnCJOkXr16ycfHR999950GDBhQofNkZWUpLCysVAiTpAcffFD33nuvGjdurPvuu08jRoyQzWY753ny8/OVn5/vfJ+dnS1Jstvtstvtlbm0Klfy/VbX4a3or7nor7nor7nor7nor7nor7kutr9t6oXpq13H9f3+X3R5TIgZpXkFd/v9rWgdHhHEMjIyFB0dXWqbn5+fIiMjlZGRUaFzHD9+XM8884xGjRpVavuUKVPUo0cPBQcHa8WKFXrggQeUk5Ojhx9++Jznmj59uiZPnlxm+4oVKxQcHFyhesyWnJxsdQlejf6ai/6ai/6ai/6ai/6ai/6aq7L9rZHnI8lHX6z/SbVObDWnKC/iLr+/eXl5FdrP0iA2fvx4zZgx47z7bN++/ZK/Jzs7W/3791erVq00adKkUp899dRTzj+3b99eubm5ev75588bxCZMmKBx48aVOn98fLz69OmjsLCwS673UtjtdiUnJ6t3797y9/e3tBZvRH/NRX/NRX/NRX/NRX/NRX/NdbH9Dd51TMvf/UG/GKG6/vqrTKzQs7nb72/JaLkLsTSIPfrooxo+fPh592ncuLFiYmJ09OjRUtsLCwt14sSJC87tOnXqlJKSkhQaGqolS5Zc8IfTuXNnPfPMM8rPz1dgYGC5+wQGBpb7mb+/v1v88CX3qsUb0V9z0V9z0V9z0V9z0V9z0V9zVba/HRrUkiT9fDxXp4uksCB+NufjLr+/Fa3B0iAWFRWlqKioC+7XpUsXZWZmatOmTerYsaMkadWqVXI4HOrcufM5j8vOzlbfvn0VGBiopUuXKigo6ILflZKSossuu+ycIQwAAABwhVo1AxUfWUMHT5zW1kNZ6tq0ttUloQp5xHPEWrZsqaSkJI0cOVLr16/X2rVrNXr0aA0ePNi5YuLhw4eVkJCg9evXSyoOYX369FFubq7mzZun7OxsZWRkKCMjQ0VFRZKkTz/9VG+++aa2bt2qPXv26NVXX9W0adP00EMPWXatAAAAQIm2Z5exT+F5Yl7HIxbrkKSFCxdq9OjR6tmzp3x8fHTrrbdqzpw5zs/tdrt27tzpnBz3/fff67vvvpMkNW3atNS59u3bp4YNG8rf31+vvPKKxo4dK8Mw1LRpU82ePVsjR4503YUBAAAA59AuLkKfbUnX5oOZVpeCKuYxQSwyMvKcD2+WpIYNG8owDOf77t27l3pfnqSkpFIPcgYAAADcSeLZ54dtOZRlbSGoch4xNBEAAACojlrXC5OPTUrPOqMj2WesLgdViCAGAAAAuKngAD81rxMqSQxP9DIEMQAAAMCNJZ5dsIPhid6FIAYAAAC4sbbx4ZKkzayc6FUIYgAAAIAbK7kjtvlg5gUXo4PnIIgBAAAAbqxFTKgC/XyUfaZQ+3/Js7ocVBGCGAAAAODG/H19dHlsmCQW7PAmBDEAAADAzZU8TyyFIOY1CGIAAACAm2vnfLBzpqV1oOoQxAAAAAA31/bsgh1b07JlL3JYWwyqBEEMAAAAcHMNawUrLMhPBYUO7cw4ZXU5qAIEMQAAAMDN2Ww25ol5GYIYAAAA4AFKnifGPDHvQBADAAAAPEDJHbHNB7OsLQRVgiAGAAAAeIDEuHBJ0u6jp5SbX2hxNbhUBDEAAADAA0SHBalueJAchrT1MHfFPB1BDAAAAPAQJfPENjNPzOMRxAAAAAAPwTwx70EQAwAAADxEYnzxPDHuiHk+ghgAAADgIdrUC5fNJh06eVrHc/KtLgeXgCAGAAAAeIjQIH81iaopieeJeTqCGAAAAOBBnAt2ME/MoxHEAAAAAA/CPDHvQBADAAAAPMivd8QyZRiGtcXgohHEAAAAAA+SUDdUAb4+Opln16GTp60uBxeJIAYAAAB4kEA/X7WsGypJSjmYaW0xuGgEMQAAAMDD/Ppg50xL68DFI4gBAAAAHqZkntiWQ6yc6KkIYgAAAICHKVk58cfDWSosclhcDS4GQQwAAADwMI1r11TNQD+dthdp99Ecq8vBRSCIAQAAAB7Gx8emtnHFd8W28Dwxj0QQAwAAADxQ27PzxFIOMk/MExHEAAAAAA/U7uw8MVZO9EwEMQAAAMADlSxhv/PIKZ0uKLK2GFQaQQwAAADwQDFhQYoKDVSRw9BP6QxP9DQEMQAAAMAD2Ww25/PEmCfmeQhiAAAAgIdinpjnIogBAAAAHqpk5USWsPc8BDEAAADAQ5U8S2z/L3nKzCuwuBpUBkEMAAAA8FARwQFqVDtEkrT5EPPEPAlBDAAAAPBgJXfFtjBPzKMQxAAAAAAPVrJy4mbmiXkUjwliJ06c0JAhQxQWFqaIiAjdc889ysnJOe8x3bt3l81mK/W67777Su2Tmpqq/v37Kzg4WNHR0XrsscdUWFho5qUAAAAAVabkwc4pB7NkGIa1xaDC/KwuoKKGDBmi9PR0JScny263a8SIERo1apQWLVp03uNGjhypKVOmON8HBwc7/1xUVKT+/fsrJiZG33zzjdLT0zV06FD5+/tr2rRppl0LAAAAUFUujw2Tn49Nx3PylZ51RrERNawuCRXgEXfEtm/fruXLl+vNN99U586d1a1bN82dO1eLFy9WWlraeY8NDg5WTEyM8xUWFub8bMWKFfrpp5/0z3/+U+3atVO/fv30zDPP6JVXXlFBAavOAAAAwP0F+fuqRUyoJJ4n5kk84o7YunXrFBERoU6dOjm39erVSz4+Pvruu+80YMCAcx67cOFC/fOf/1RMTIxuvPFGPfXUU867YuvWrVObNm1Up04d5/59+/bV/fffr23btql9+/blnjM/P1/5+fnO99nZ2ZIku90uu91+Sdd6qUq+3+o6vBX9NRf9NRf9NRf9NRf9NRf9NZcr+tumXpi2pWXr+wMn1Cuhtmnf447c7fe3onV4RBDLyMhQdHR0qW1+fn6KjIxURkbGOY+788471aBBA8XGxmrLli16/PHHtXPnTn300UfO8/42hElyvj/feadPn67JkyeX2b5ixYpSQx+tlJycbHUJXo3+mov+mov+mov+mov+mov+msvM/tpO2CT5as2Wn9W6aI9p3+PO3OX3Ny8vr0L7WRrExo8frxkzZpx3n+3bt1/0+UeNGuX8c5s2bVS3bl317NlTe/fuVZMmTS76vBMmTNC4ceOc77OzsxUfH68+ffqUGvpoBbvdruTkZPXu3Vv+/v6W1uKN6K+56K+56K+56K+56K+56K+5XNHfJhmn9K9X1ikt3199k3rI18dmyve4I3f7/S0ZLXchlgaxRx99VMOHDz/vPo0bN1ZMTIyOHj1aanthYaFOnDihmJiYCn9f586dJUl79uxRkyZNFBMTo/Xr15fa58iRI5J03vMGBgYqMDCwzHZ/f3+3+OFL7lWLN6K/5qK/5qK/5qK/5qK/5qK/5jKzvy3rXabgAF/l5hfpYGa+mtUJNeV73Jm7/P5WtAZLg1hUVJSioqIuuF+XLl2UmZmpTZs2qWPHjpKkVatWyeFwOMNVRaSkpEiS6tat6zzv1KlTdfToUefQx+TkZIWFhalVq1aVvBoAAADAGr4+NrWuF671+05o86GsahnEPI1HrJrYsmVLJSUlaeTIkVq/fr3Wrl2r0aNHa/DgwYqNjZUkHT58WAkJCc47XHv37tUzzzyjTZs2af/+/Vq6dKmGDh2qa665Rm3btpUk9enTR61atdL//d//afPmzfrPf/6jJ598Ug8++GC5d7wAAAAAd5UYFy6JlRM9hUcEMal49cOEhAT17NlT119/vbp166Y33njD+bndbtfOnTudk+MCAgL05Zdfqk+fPkpISNCjjz6qW2+9VZ9++qnzGF9fXy1btky+vr7q0qWL7rrrLg0dOrTUc8cAAAAAT1DyYOfNhzItrQMV4xGrJkpSZGTkeR/e3LBhw1JPEo+Pj9dXX311wfM2aNBAn3/+eZXUCAAAAFglMS5CkrQ9PVv5hUUK9PO1tiCcl8fcEQMAAABwbnGX1VBkSIDsRYa2p5+yuhxcAEEMAAAA8AI2m415Yh6EIAYAAAB4Cec8MYKY2yOIAQAAAF6iZJ4YC3a4P4IYAAAA4CXanh2auPdYrrLP2C2uBudDEAMAAAC8RK2agYqPrCFJ+vFQlsXV4HwIYgAAAIAXacvwRI9AEAMAAAC8SLuSIMaCHW6NIAYAAAB4kV9XTmRoojsjiAEAAABepHW9MPnYpIzsMzqSfcbqcnAOBDEAAADAiwQH+Kl5nVBJDE90ZwQxAAAAwMvwPDH3RxADAAAAvEzJPLEtLGHvtghiAAAAgJcpebDz5oOZcjgMi6tBeQhiAAAAgJdpEROqQD8fZZ8p1P5fcq0uB+UgiAEAAABext/XR63rFd8VY3iieyKIAQAAAF6oZHhiCisnuiWCGAAAAOCF2pU82JmVE90SQQwAAADwQiVL2G9Ly5a9yGFtMSiDIAYAAAB4oQa1ghVew18FhQ7tzDhldTn4HYIYAAAA4IVsNhvzxNwYQQwAAADwUs55YgQxt0MQAwAAALxU27PzxFjC3v0QxAAAAAAvlXh2aOKuo6eUk19ocTX4LYIYAAAA4KWiw4IUGx4kw5C2HuaumDshiAEAAABe7NfhiZmW1oHSCGIAAACAF0t0LtjBHTF3QhADAAAAvFhiPEvYuyOCGAAAAODF2tQLl80mHc48reM5+VaXg7MIYgAAAIAXCw3yV5OompKYJ+ZOCGIAAACAl0s8u2BHCvPE3AZBDAAAAPByJfPEuCPmPghiAAAAgJcruSO2+WCmDMOwthhIIogBAAAAXi+hbqgCfH10Ms+ugydOW10ORBADAAAAvF6gn69a1g2VJG1meKJbIIgBAAAA1cCvD3bOtLQOFCOIAQAAANWAc54Yd8TcAkEMAAAAqAZK7ohtPZytwiKHtcWAIAYAAABUB41rhyg00E+n7UXafTTH6nKqPYIYAAAAUA34+NjUJq74eWLME7MeQQwAAACoJpwLdhzKsrYQEMQAAACA6iKRO2Juw2OC2IkTJzRkyBCFhYUpIiJC99xzj3Jyzj22df/+/bLZbOW+PvjgA+d+5X2+ePFiV1wSAAAA4FIld8R2Hjml0wVF1hZTzXlMEBsyZIi2bdum5ORkLVu2TF9//bVGjRp1zv3j4+OVnp5e6jV58mTVrFlT/fr1K7Xv/PnzS+138803m3w1AAAAgOvFhAUpOjRQRQ5D29IYnmglP6sLqIjt27dr+fLl2rBhgzp16iRJmjt3rq6//nq98MILio2NLXOMr6+vYmJiSm1bsmSJBg0apJo1a5baHhERUWZfAAAAwNvYbDa1jYvQl9uPaPOhLHVqGGl1SdWWRwSxdevWKSIiwhnCJKlXr17y8fHRd999pwEDBlzwHJs2bVJKSopeeeWVMp89+OCDuvfee9W4cWPdd999GjFihGw22znPlZ+fr/z8fOf77OxsSZLdbpfdbq/MpVW5ku+3ug5vRX/NRX/NRX/NRX/NRX/NRX/N5W79bRMbqi+3H9EPB07I3jnO6nIumbv1t6J1eEQQy8jIUHR0dKltfn5+ioyMVEZGRoXOMW/ePLVs2VJdu3YttX3KlCnq0aOHgoODtWLFCj3wwAPKycnRww8/fM5zTZ8+XZMnTy6zfcWKFQoODq5QPWZLTk62ugSvRn/NRX/NRX/NRX/NRX/NRX/N5S79PZNpk+Srb3el6/PPD1ldTpVxl/7m5eVVaD9Lg9j48eM1Y8aM8+6zffv2S/6e06dPa9GiRXrqqafKfPbbbe3bt1dubq6ef/758waxCRMmaNy4cc732dnZio+PV58+fRQWFnbJ9V4Ku92u5ORk9e7dW/7+/pbW4o3or7nor7nor7nor7nor7nor7ncrb9Xnbbr1e2rdTzfpq7deysi2PqaLoW79bdktNyFWBrEHn30UQ0fPvy8+zRu3FgxMTE6evRoqe2FhYU6ceJEheZ2ffjhh8rLy9PQoUMvuG/nzp31zDPPKD8/X4GBgeXuExgYWO5n/v7+bvHDl9yrFm9Ef81Ff81Ff81Ff81Ff81Ff83lLv2t7e+vRrVDtO94rn46kqtrm0dZXVKVcJf+VrQGS4NYVFSUoqIu/IPv0qWLMjMztWnTJnXs2FGStGrVKjkcDnXu3PmCx8+bN09//OMfK/RdKSkpuuyyy84ZwgAAAABPlxgXrn3Hc7X5YKbXBDFP4xHL17ds2VJJSUkaOXKk1q9fr7Vr12r06NEaPHiwc8XEw4cPKyEhQevXry917J49e/T111/r3nvvLXPeTz/9VG+++aa2bt2qPXv26NVXX9W0adP00EMPueS6AAAAACu0jYuQJG05lGlpHdWZRyzWIUkLFy7U6NGj1bNnT/n4+OjWW2/VnDlznJ/b7Xbt3LmzzOS4t956S3FxcerTp0+Zc/r7++uVV17R2LFjZRiGmjZtqtmzZ2vkyJGmXw8AAABglZIHO6cczJJhGOddMRzm8JggFhkZqUWLFp3z84YNG8owjDLbp02bpmnTppV7TFJSkpKSkqqsRgAAAMATXB4bJj8fm47n5Cst64zqRdSwuqRqxyOGJgIAAACoOkH+vmoREypJ2nIw09piqimCGAAAAFANOYcnMk/MEgQxAAAAoBpqd3bBjs3cEbMEQQwAAACohtrGh0uSth7OVpGj7FoLMBdBDAAAAKiGmkWHKjjAVzn5hfr5WI7V5VQ7BDEAAACgGvL1sal1veK7YikMT3Q5ghgAAABQTbU7u2DHlkNZ1hZSDRHEAAAAgGqqbVzxHbHNrJzocgQxAAAAoJpKPLty4vb0bJ2xF1lbTDVDEAMAAACqqbjLaqhWSIDsRYa2p2dbXU61QhADAAAAqimbzeYcnsg8MdciiAEAAADVWOLZBTt4sLNrEcQAAACAaqwkiKWwYIdLXVQQKyws1JdffqnXX39dp06dkiSlpaUpJ4cHwQEAAACepGTBjp+P5Sr7jN3aYqoRv8oecODAASUlJSk1NVX5+fnq3bu3QkNDNWPGDOXn5+u1114zo04AAAAAJogMCVB8ZA0dPHFaPx7K0lVNa1tdUrVQ6TtijzzyiDp16qSTJ0+qRo0azu0DBgzQypUrq7Q4AAAAAOYruSuWwjwxl6n0HbH//ve/+uabbxQQEFBqe8OGDXX48OEqKwwAAACAayTGRWjZlnRtYZ6Yy1T6jpjD4VBRUdmHvR06dEihoaFVUhQAAAAA1/l15USWsHeVSgexPn366MUXX3S+t9lsysnJ0dNPP63rr7++KmsDAAAA4AKt64XJxyZlZJ/RkewzVpdTLVQ6iM2aNUtr165Vq1atdObMGd15553OYYkzZswwo0YAAAAAJgoO8FPzOsWj23iemGtUeo5YXFycNm/erMWLF2vLli3KycnRPffcoyFDhpRavAMAAACA50iMi9COjFPafChTfS6Psbocr1fpICZJfn5+uuuuu6q6FgAAAAAWSYyP0HsbDzJPzEUqHcTeeeed834+dOjQiy4GAAAAgDXaxoVLkrYcypTDYcjHx2ZxRd6t0kHskUceKfXebrcrLy9PAQEBCg4OJogBAAAAHqhFTKgC/XyUfaZQ+3/JVeOomlaX5NUqvVjHyZMnS71ycnK0c+dOdevWTf/617/MqBEAAACAyfx9fdS6XvFdsc08T8x0lQ5i5WnWrJmee+65MnfLAAAAAHiOkuGJzBMzX5UEMal4AY+0tLSqOh0AAAAAF2tX8mBn7oiZrtJzxJYuXVrqvWEYSk9P18svv6yrrrqqygoDAAAA4FqJcRGSpG1p2SoodCjAr8ru2+B3Kh3Ebr755lLvbTaboqKi1KNHD82aNauq6gIAAADgYg1qBSu8hr+yTtu168gp55wxVL1KBzGHw2FGHQAAAAAsZrPZ1DYuXP/dfVwpBzMJYibiXiMAAAAAJ+c8sYOZltbh7Sp0R2zcuHEVPuHs2bMvuhgAAAAA1iqZJ8aCHeaqUBD74YcfKnQym42nbwMAAACerG188XDE3UdzlJNfqJqBlZ7NhAqoUFdXr15tdh0AAAAA3EB0aJBiw4OUlnVGWw9n6Q+Na1ldkldijhgAAACAUhKZJ2a6i7rPuHHjRr3//vtKTU1VQUFBqc8++uijKikMAAAAgDXaxkXoi60Z2nIoy+pSvFal74gtXrxYXbt21fbt27VkyRLZ7XZt27ZNq1atUng4y1sCAAAAni7x7DyxFO6ImabSQWzatGn629/+pk8//VQBAQF66aWXtGPHDg0aNEj169c3o0YAAAAALtSmXrhsNulw5mkdz8m3uhyvVOkgtnfvXvXv31+SFBAQoNzcXNlsNo0dO1ZvvPFGlRcIAAAAwLVCg/zVJKqmJGkLy9ibotJB7LLLLtOpU6ckSfXq1dPWrVslSZmZmcrLy6va6gAAAABYouR5YikHmSdmhgoHsZLAdc011yg5OVmSNHDgQD3yyCMaOXKk7rjjDvXs2dOcKgEAAAC4VLuz88RYOdEcFV41sW3btrriiit08803a+DAgZKkJ554Qv7+/vrmm29066236sknnzStUAAAAACu0/bsHbEthzJlGIZsNpu1BXmZCt8R++qrr3T55Zdr+vTpatmypYYNG6a1a9dq/PjxWrp0qWbNmqXLLrvMtEKnTp2qrl27Kjg4WBERERU6xjAMTZw4UXXr1lWNGjXUq1cv7d69u9Q+J06c0JAhQxQWFqaIiAjdc889ysnJMeEKAAAAAM+RUDdUAb4+Opln18ETp60ux+tUOIhdffXVeuutt5Senq65c+dq//79uvbaa9W8eXPNmDFDGRkZZtapgoICDRw4UPfff3+Fj5k5c6bmzJmj1157Td99951CQkLUt29fnTlzxrnPkCFDtG3bNiUnJ2vZsmX6+uuvNWrUKDMuAQAAAPAYgX6+ahkbJklKYcGOKlfpBzqHhIRoxIgRGjFihPbs2aP58+frlVde0VNPPaWkpCQtXbrUjDo1efJkSdKCBQsqtL9hGHrxxRf15JNP6qabbpIkvfPOO6pTp44+/vhjDR48WNu3b9fy5cu1YcMGderUSZI0d+5cXX/99XrhhRcUGxtb7rnz8/OVn//rMp7Z2dmSJLvdLrvdfrGXWCVKvt/qOrwV/TUX/TUX/TUX/TUX/TUX/TWXJ/e3TWyoNh/MVMqBE+rXKsrqcsrlbv2taB02wzCMS/mi3NxcLVy4UBMmTFBmZqaKioou5XQXtGDBAo0ZM0aZmZnn3e/nn39WkyZN9MMPP6hdu3bO7ddee63atWunl156SW+99ZYeffRRnTx50vl5YWGhgoKC9MEHH2jAgAHlnnvSpEnOYPhbixYtUnBw8EVdFwAAAOBu1h+zaeEeXzUONfRIa3P/nu8t8vLydOeddyorK0thYWHn3K/Sd8RKfP3113rrrbf073//Wz4+Pho0aJDuueeeiz1dlSsZKlmnTp1S2+vUqeP8LCMjQ9HR0aU+9/PzU2Rk5HmHWk6YMEHjxo1zvs/OzlZ8fLz69Olz3ma7gt1uV3Jysnr37i1/f39La/FG9Ndc9Ndc9Ndc9Ndc9Ndc9NdcntzfFsdytXDOWqWd8VWfvr3l51vpp1+Zzt36WzJa7kIqFcTS0tK0YMECLViwQHv27FHXrl01Z84cDRo0SCEhIZUucvz48ZoxY8Z599m+fbsSEhIqfW4zBQYGKjAwsMx2f39/t/jhS+5Vizeiv+aiv+aiv+aiv+aiv+aiv+byxP42jwlXaKCfTuUXav/JfLWsa+1Nh/Nxl/5WtIYKB7F+/frpyy+/VO3atTV06FDdfffdatGixUUXKEmPPvqohg8fft59GjdufFHnjomJkSQdOXJEdevWdW4/cuSIc6hiTEyMjh49Wuq4wsJCnThxwnk8AAAAUF35+NjUJi5c3+z9RZsPZrp1EPM0FQ5i/v7++vDDD3XDDTfI19e3Sr48KipKUVHmTPpr1KiRYmJitHLlSmfwys7O1nfffedcebFLly7KzMzUpk2b1LFjR0nSqlWr5HA41LlzZ1PqAgAAADxJYnxEcRA7lKnBV9a3uhyvUeEgZtZqiBWVmpqqEydOKDU1VUVFRUpJSZEkNW3aVDVr1pQkJSQkaPr06RowYIBsNpvGjBmjZ599Vs2aNVOjRo301FNPKTY2VjfffLMkqWXLlkpKStLIkSP12muvyW63a/To0Ro8ePA5V0wEAAAAqpPEuHBJ0uaDWRZX4l0uerEOV5s4caLefvtt5/v27dtLklavXq3u3btLknbu3KmsrF9/Qf7yl78oNzdXo0aNUmZmprp166bly5crKCjIuc/ChQs1evRo9ezZUz4+Prr11ls1Z84c11wUAAAA4OYS4yMkSTuPnNLpgiLVCKia0XHVnccEsZJFQs7n9yvx22w2TZkyRVOmTDnnMZGRkVq0aFFVlAgAAAB4nZiwIEWHBuroqXxtS8tSp4aRVpfkFdxv/UkAAAAAbsNms6ltXIQkKeVgpqW1eBOCGAAAAIDzahdfPE9syyHmiVUVghgAAACA8yqZJ7b5UKaldXgTghgAAACA82pbL0KSdOCXPJ3MLbC2GC9BEAMAAABwXuHB/mpUO0SStOUwwxOrAkEMAAAAwAX9+jyxTGsL8RIEMQAAAAAX5JwnRhCrEgQxAAAAABdUsoT95kNZZZ7fi8ojiAEAAAC4oMtjw+TnY9PxnHylZZ2xuhyPRxADAAAAcEFB/r5KqBsqieGJVYEgBgAAAKBCfh2emGlpHd6AIAYAAACgQtqVBDHuiF0yghgAAACACilZOfHHQ1kqcrBgx6UgiAEAAACokKbRNRUc4KvcgiL9fCzH6nI8GkEMAAAAQIX4+tjUul7xg51TGJ54SQhiAAAAACqsXcmDnVmw45IQxAAAAABUWNu44jtiWw5lWVyJZyOIAQAAAKiwxLMrJ25Pz9YZe5G1xXgwghgAAACACou7rIZqhQTIXmRoe3q21eV4LIIYAAAAgAqz2WzO4Yk8T+ziEcQAAAAAVErJ88SYJ3bxCGIAAAAAKqUkiKWwcuJFI4gBAAAAqJSSBTt+PparrNN2a4vxUAQxAAAAAJUSGRKg+MgakqSthxmeeDEIYgAAAAAqreSuWAoLdlwUghgAAACASmt3dp4YKydeHIIYAAAAgEpre/aOGCsnXhyCGAAAAIBKa10vTD42KSP7jDKyzlhdjschiAEAAACotOAAPzWvEypJ2swy9pVGEAMAAABwURKdwxMzLa3DExHEAAAAAFyUROeCHcwTqyyCGAAAAICLkhgfLql4aKLDYVhcjWchiAEAAAC4KM3rhCrQz0enzhRq/y+5VpfjUQhiAAAAAC6Kv6+PWtf79a4YKo4gBgAAAOCilSzYwTyxyiGIAQAAALhov50nhoojiAEAAAC4aCV3xLalZaug0GFtMR6EIAYAAADgojWoFazwGv4qKHRoZ8Ypq8vxGAQxAAAAABfNZrOpbRzDEyuLIAYAAADgkrRzPtg509I6PAlBDAAAAMAlca6cyB2xCvOYIDZ16lR17dpVwcHBioiIuOD+drtdjz/+uNq0aaOQkBDFxsZq6NChSktLK7Vfw4YNZbPZSr2ee+45k64CAAAA8D5tz66cuPtojnLyCy2uxjN4TBArKCjQwIEDdf/991do/7y8PH3//fd66qmn9P333+ujjz7Szp079cc//rHMvlOmTFF6errz9dBDD1V1+QAAAIDXig4NUmx4kAxD2nqY54lVhJ/VBVTU5MmTJUkLFiyo0P7h4eFKTk4ute3ll1/WlVdeqdTUVNWvX9+5PTQ0VDExMVVWKwAAAFDdJMZHKC0rQ5sPZuoPjWtZXY7b85ggVhWysrJks9nKDG187rnn9Mwzz6h+/fq68847NXbsWPn5nbs1+fn5ys/Pd77Pzs6WVDwc0m63m1J7RZV8v9V1eCv6ay76ay76ay76ay76ay76a67q0t/L64bqi60Z+iH1pEuv1d36W9E6bIZhGCbXUqUWLFigMWPGKDMzs1LHnTlzRldddZUSEhK0cOFC5/bZs2erQ4cOioyM1DfffKMJEyZoxIgRmj179jnPNWnSJOcdut9atGiRgoODK1UXAAAA4A12Z9n08k++igw09HSHIqvLsUxeXp7uvPNOZWVlKSws7Jz7WRrExo8frxkzZpx3n+3btyshIcH5/mKCmN1u16233qpDhw5pzZo1523IW2+9pT/96U/KyclRYGBgufuUd0csPj5ex48fP++5XcFutys5OVm9e/eWv7+/pbV4I/prLvprLvprLvprLvprLvprrurS31NnCtVx2ioZhrTu8WtVu2b5f5euau7W3+zsbNWuXfuCQczSoYmPPvqohg8fft59GjdufEnfYbfbNWjQIB04cECrVq26YFDq3LmzCgsLtX//frVo0aLcfQIDA8sNaf7+/m7xw5fcqxZvRH/NRX/NRX/NRX/NRX/NRX/N5e39jfT3V5OomtpzNEc/ZeSqZ8uaLv1+d+lvRWuwNIhFRUUpKirKtPOXhLDdu3dr9erVqlXrwpMGU1JS5OPjo+joaNPqAgAAALxRYlyE9hzN0eZDWerZso7V5bg1j1m+PjU1VSkpKUpNTVVRUZFSUlKUkpKinJwc5z4JCQlasmSJpOIQdtttt2njxo1auHChioqKlJGRoYyMDBUUFEiS1q1bpxdffFGbN2/Wzz//rIULF2rs2LG66667dNlll1lynQAAAICnanf2eWKbD2ZaW4gH8JhVEydOnKi3337b+b59+/aSpNWrV6t79+6SpJ07dyorq/i5BYcPH9bSpUslSe3atSt1rpJjAgMDtXjxYk2aNEn5+flq1KiRxo4dq3Hjxpl/QQAAAICXSYyPkCRtPpQpwzBks9msLciNeUwQW7BgwQWfIfbbdUcaNmyoC61D0qFDB3377bdVUR4AAABQ7SXEhCnA10eZeXYdPHFa9Wuxovi5eMzQRAAAAADuLcDPRy1jixfHSzmUaW0xbo4gBgAAAKDKtItjnlhFEMQAAAAAVJm2cRGSpC3cETsvghgAAACAKlOyYMePh7NUWOSwthg3RhADAAAAUGUa1w5RaKCfztgd2nUk58IHVFMEMQAAAABVxsfHpjZn54kxPPHcCGIAAAAAqtRvnyeG8hHEAAAAAFSpxLMLdqQczLK2EDdGEAMAAABQpRLji4cm7jpySqcLiiyuxj0RxAAAAABUqZiwIEWHBqrIYWhbGnfFykMQAwAAAFClbDabc55YCg92LhdBDAAAAECVSzy7cuLmQ9wRKw9BDAAAAECVK7kjxhL25SOIAQAAAKhybetFSJIO/JKnk7kF1hbjhghiAAAAAKpceLC/GtUOkcTzxMpDEAMAAABgipJ5YluYJ1YGQQwAAACAKUrmiW1m5cQyCGIAAAAATNE2LkJS8dBEwzCsLcbNEMQAAAAAmOLy2DD5+dh0PKdAaVlnrC7HrRDEAAAAAJgiyN9XCXVDJTE88fcIYgAAAABMk1gyPJEgVgpBDAAAAIBpEn8zTwy/IogBAAAAME3Jyok/HspSkYMFO0oQxAAAAACYpml0TQUH+Cq3oEh7j+VYXY7bIIgBAAAAMI2vj02t6xU/2Jl5Yr8iiAEAAAAwVbuSBzszT8yJIAYAAADAVL+unJhlbSFuhCAGAAAAwFRt44qHJu7IyNYZe5HF1bgHghgAAAAAU8VdVkO1QgJkLzK0PT3b6nLcAkEMAAAAgKlsNptzGXsW7ChGEAMAAABgupLhiZsPMU9MIogBAAAAcIFEVk4shSAGAAAAwHQlKyf+fCxXWaft1hbjBghiAAAAAEwXGRKg+MgakqQfGZ5IEAMAAADgGs7niTE8kSAGAAAAwDXasXKiE0EMAAAAgEu05Y6YE0EMAAAAgEu0rhcmH5t0JDtfGVlnrC7HUgQxAAAAAC4RHOCn5nVCJXFXjCAGAAAAwGWcC3ZU83liBDEAAAAALlPyYOct1XwJe4IYAAAAAJdJjA+XVDw00eEwLK7GOh4TxKZOnaquXbsqODhYERERFTpm+PDhstlspV5JSUml9jlx4oSGDBmisLAwRURE6J577lFOTo4JVwAAAACgeZ1QBfr56NSZQu37JdfqcizjMUGsoKBAAwcO1P3331+p45KSkpSenu58/etf/yr1+ZAhQ7Rt2zYlJydr2bJl+vrrrzVq1KiqLB0AAADAWf6+Pmpdr/iu2JZqvGCHn9UFVNTkyZMlSQsWLKjUcYGBgYqJiSn3s+3bt2v58uXasGGDOnXqJEmaO3eurr/+er3wwguKjY29pJoBAAAAlJUYF6FNB05q88EsDWgfZ3U5lvCYIHax1qxZo+joaF122WXq0aOHnn32WdWqVUuStG7dOkVERDhDmCT16tVLPj4++u677zRgwIByz5mfn6/8/Hzn++zsbEmS3W6X3W438WourOT7ra7DW9Ffc9Ffc9Ffc9Ffc9Ffc9Ffc9HfslrH1pQk/ZB68pL74m79rWgdXh3EkpKSdMstt6hRo0bau3ev/vrXv6pfv35at26dfH19lZGRoejo6FLH+Pn5KTIyUhkZGec87/Tp05136H5rxYoVCg4OrvLruBjJyclWl+DV6K+56K+56K+56K+56K+56K+56O+vTpyWJD9tO5yppcs+l18VTJhyl/7m5eVVaD9Lg9j48eM1Y8aM8+6zfft2JSQkXNT5Bw8e7PxzmzZt1LZtWzVp0kRr1qxRz549L+qckjRhwgSNGzfO+T47O1vx8fHq06ePwsLCLvq8VcFutys5OVm9e/eWv7+/pbV4I/prLvprLvprLvprLvprLvprLvpblmEYmrtztbJOF6px+25qXe/i/w7tbv0tGS13IZYGsUcffVTDhw8/7z6NGzeusu9r3LixateurT179qhnz56KiYnR0aNHS+1TWFioEydOnHNemVQ87ywwMLDMdn9/f7f44UvuVYs3or/mor/mor/mor/mor/mor/mor+lJcZfpq93HdPWjBy1b1jrks/nLv2taA2WBrGoqChFRUW57PsOHTqkX375RXXr1pUkdenSRZmZmdq0aZM6duwoSVq1apUcDoc6d+7ssroAAACA6iYxLlxf7zqmLQczpT80sLocl/OY5etTU1OVkpKi1NRUFRUVKSUlRSkpKaWe+ZWQkKAlS5ZIknJycvTYY4/p22+/1f79+7Vy5UrddNNNatq0qfr27StJatmypZKSkjRy5EitX79ea9eu1ejRozV48GBWTAQAAABMlBgXIan4wc7Vkccs1jFx4kS9/fbbzvft27eXJK1evVrdu3eXJO3cuVNZWVmSJF9fX23ZskVvv/22MjMzFRsbqz59+uiZZ54pNaxw4cKFGj16tHr27CkfHx/deuutmjNnjusuDAAAAKiG2sYXP0ts99Ec5eQXqmagx0STKuExV7tgwYILPkPMMAznn2vUqKH//Oc/FzxvZGSkFi1adKnlAQAAAKiE6NAgxYYHKS3rjH48lKUuTS59npgn8ZihiQAAAAC8S2J8hCRpSzUcnkgQAwAAAGCJkiBWHeeJEcQAAAAAWKJtXPE8sc0HsyyuxPUIYgAAAAAs0aZeuGw26XDmaR07lW91OS5FEAMAAABgidAgfzWNqimp+s0TI4gBAAAAsEzbkueJHcy0tA5XI4gBAAAAsEy7s88T23yoes0TI4gBAAAAsMxvV0787XOBvR1BDAAAAIBlEmLCFODro8w8u1JP5FldjssQxAAAAABYJsDPRy1jwyRVr+GJBDEAAAAAlmrnfJ5YprWFuBBBDAAAAIClquPKiQQxAAAAAJYqWbBja1qWCosc1hbjIgQxAAAAAJZqXDtEoYF+OmN3aNeRHKvLcQmCGAAAAABL+fjY1Nb5PLFMa4txEYIYAAAAAMuVzBPbQhADAAAAANdIPBvEUg5WjyXsCWIAAAAALNfu7IIdu46cUl5BobXFuABBDAAAAIDlYsKDFB0aqCKHoW1p2VaXYzqCGAAAAAC3ULKMfXV4nhhBDAAAAIBbKBmeuPmQ988TI4gBAAAAcAtt484uYc8dMQAAAABwjbb1IiRJqSfydDK3wNpiTEYQAwAAAOAWwoP91bh2iCTvf7AzQQwAAACA2/h1eKJ3zxMjiAEAAABwGyUrJ27hjhgAAAAAuIZzCftDmTIMw9piTEQQAwAAAOA2WtUNk5+PTcdzCnQ487TV5ZiGIAYAAADAbQT5+yqhbqgkaYsXP0+MIAYAAADArSTGRUjy7ueJEcQAAAAAuJWSIJZCEAMAAAAA1yhZsGPr4SwVObxzwQ6CGAAAAAC30jS6poIDfJVbUKS9x3KsLscUBDEAAAAAbsXXx6bW9Yof7OytwxMJYgAAAADcTjsvf7AzQQwAAACA2/l15UTvXMKeIAYAAADA7bSNKx6auD09W2fsRRZXU/UIYgAAAADcTtxlNVQrJECFDkPb07OtLqfKEcQAAAAAuB2bzeZcxt4bH+xMEAMAAADglpzzxA553zwxghgAAAAAt9Q2vnieGHfEAAAAAMBFSu6I/Xw8V1mn7dYWU8U8JohNnTpVXbt2VXBwsCIiIip0jM1mK/f1/PPPO/dp2LBhmc+fe+45k64CAAAAQEVFhgSofmSwJOlHLxue6DFBrKCgQAMHDtT9999f4WPS09NLvd566y3ZbDbdeuutpfabMmVKqf0eeuihqi4fAAAAwEUoWcZ+s5c92NnP6gIqavLkyZKkBQsWVPiYmJiYUu8/+eQTXXfddWrcuHGp7aGhoWX2BQAAAGC9dvERWrYl3evmiXlMELtUR44c0Weffaa33367zGfPPfecnnnmGdWvX1933nmnxo4dKz+/c7cmPz9f+fn5zvfZ2cXPNbDb7bLbrR27WvL9Vtfhreivueivueivueivueivueivuejvpbm8bk1JxQt2lNdDd+tvReuwGYZhmFxLlVqwYIHGjBmjzMzMSh03c+ZMPffcc0pLS1NQUJBz++zZs9WhQwdFRkbqm2++0YQJEzRixAjNnj37nOeaNGmS8w7dby1atEjBwcGVqgsAAADAueUXSY+v95UhmyZ3KFREoNUVnV9eXp7uvPNOZWVlKSws7Jz7WRrExo8frxkzZpx3n+3btyshIcH5/mKDWEJCgnr37q25c+eed7+33npLf/rTn5STk6PAwPJ/yuXdEYuPj9fx48fP22xXsNvtSk5OVu/eveXv729pLd6I/pqL/pqL/pqL/pqL/pqL/pqL/l66G1/+RjuO5Ojvd7RT71bRpT5zt/5mZ2erdu3aFwxilg5NfPTRRzV8+PDz7vP7+VwX47///a927typ995774L7du7cWYWFhdq/f79atGhR7j6BgYHlhjR/f3+3+OFL7lWLN6K/5qK/5qK/5qK/5qK/5qK/5qK/F69d/cu040iOtqaf0vWJ9crdx136W9EaLA1iUVFRioqKMv175s2bp44dOyoxMfGC+6akpMjHx0fR0dEX3LcyHA6HCgoKqvSc5bHb7fLz89OZM2dUVFRk+vdVJ+7wf2wAAIDqqG1chBZvOOhVKyd6zGIdqampOnHihFJTU1VUVKSUlBRJUtOmTVWzZvEEvoSEBE2fPl0DBgxwHpedna0PPvhAs2bNKnPOdevW6bvvvtN1112n0NBQrVu3TmPHjtVdd92lyy67rMpqLygo0L59++RwOKrsnOdiGIZiYmJ08OBB2Ww207+vugkNDbW6BAAAgGonMb54Cfsth7LkcBjy8fH8v+d6TBCbOHFiqRUP27dvL0lavXq1unfvLknauXOnsrJKP+ht8eLFMgxDd9xxR5lzBgYGavHixZo0aZLy8/PVqFEjjR07VuPGjauyug3DUHp6unx9fRUfHy8fH3Mf3eZwOJSTk6OaNWua/l3ViWEYysvL05EjRwhjAAAALta8TqiC/H106kyh9v2SqyZRNa0u6ZJ5TBBbsGDBBZ8hVt66I6NGjdKoUaPK3b9Dhw769ttvq6K8cyosLFReXp5iY2NdsqJiyRDIoKAgglgVq1GjhhwOh3Jzc1VUVMRQRQAAABfx9/XR5bHh2nTgpDYfzPSKIMbf1E1WMk8rICDA4kpQFYKDg+Xj46PCwkKrSwEAAKhWEuMiJBUPT/QGBDEXYb6Wdyj5OXrY4/cAAAA8Xsk8sZSDmdYWUkUIYgAAAADcXskdsZ/SslVQaP4ieGYjiAEAAABwew1qBSu8hr8KihzamXHK6nIuGUHMzf0teZfmrNxd7mdzVu7W35J3mfK9w4cPl81mK/Pas2ePKd9ntgULFigiIsLqMgAAAHCRbDabEuMjJEkpXvA8MYKYm/P1sWl2OWFszsrdmp28S74mPkMhKSlJ6enppV6NGjWq9Hlc8SBrAAAAeL/EuOJ5Ypu9YJ4YQczFDMNQXkFhhV/3Xt1ID/VoqtnJuzRrxU7lFRRq1oqdmp28Sw/1aKp7r25U5pjTBUXlnquyC0wEBgYqJiam1MvX11dfffWVrrzySgUGBqpu3boaP358qVUEu3fvrtGjR2vMmDGqXbu2+vbtK0naunWr+vXrp5o1a6pOnTr6v//7Px0/ftx5nMPh0MyZM9W0aVMFBgaqfv36mjp1qvPzxx9/XM2bN1dwcLAaN26sp556Sna73fn55s2bnQ/nDgsLU8eOHbVx40atWbNGI0aMUFZWlvPO3qRJkyRJf//739WsWTMFBQWpTp06uu222y7mxwoAAAAX+HXlxExL66gKHvMcMW9x2l6kVhP/c1HHzl21R3NX7Tnn+wv5aUpfBQdc2o/88OHDuv766zV8+HC988472rFjh0aOHKmgoCBnuJGkt99+W/fff7/Wrl0rScrMzFSPHj1077336m9/+5tOnz6txx9/XIMGDdKqVaskSRMmTNA//vEP/e1vf1O3bt2Unp6uHTt2OM8ZGhqqBQsWKDY2Vj/++KNGjhyp0NBQ/eUvf5EkDRkyRO3bt9err74qX19fpaSkyN/fX127dtWLL76oiRMnaufOnZKkmjVrauPGjXr44Yf17rvvqmvXrjpx4oT++9//XlJ/AAAAYJ62Z1dO3H00Rzn5haoZ6LlxxnMrh+mWLVummjV/fVhev3791Lx5c8XHx+vll1+WzWZTQkKC0tLS9Pjjj2vixInOh0g3a9ZMM2fOdB777LPPqn379po2bZpz21tvvaX4+Hjt2rVLdevW1UsvvaSXX35Zw4YNkyQ1adJE3bp1c+7/5JNPOv/csGFD/fnPf9bixYudQSw1NVWPPfaYEhISnDWUCA8Pl81mU0xMjHNbamqqQkJCdMMNNyg0NFQNGjRQ+/btq6R3AAAAqHrRoUGqF1FDhzNP68dDWerSpJbVJV00gpiL1fD31U9T+lb6uFfX7NXcVXvk72uTvcjQQz2a6v7uTcrs53A4dCr7lELDQp2h6LffXRnXXXedXn31Vef7kJAQPfjgg+rSpUup56JdddVVysnJ0aFDh1S/fn1JUseOHUuda/PmzVq9enWpYFdi7969yszMVH5+vnr27HnOet577z3NmTNHe/fuVU5OjgoLCxUWFub8fNy4cbr33nv17rvvqlevXho4cKCaNCnboxK9e/dWgwYN1LhxYyUlJSkpKUkDBgxQcHDwhZsDAAAAS7SNC9fhzNPafCjTo4MYc8RczGazKTjAr1KvN/+7T3NX7dG43s21e+r1Gte7ueau2qM3/7uv3P1rBPiWu72yD5UOCQlR06ZNna+6detW6tjfysnJ0Y033qiUlJRSr927d+uaa65RjRo1znu+devWaciQIbr++uu1bNky/fDDD3riiSdKLQQyadIkbdu2Tf3799eqVavUqlUrLVmy5JznDA0N1ffff69//etfqlu3riZOnKjExERlZmZW+DoBAADgWiUrJ3r6PDGCmJsrWR1xXO/merhn8VC7h3s207jezctdTdFsLVu21Lp160ot/LF27VqFhoYqLi7unMd16NBB27ZtU8OGDUuFu6ZNmyokJETNmjVTjRo1tHLlynKP/+abb9SgQQM98cQT6tSpk5o1a6YDBw6U2a958+YaO3asVqxYoVtuuUXz58+XJAUEBKioqKjM/n5+furVq5dmzpypLVu2aP/+/c45awAAAHA/JQt2bD6YZW0hl4gg5uaKHEapEFaiJIwVOSq3EuKleuCBB3Tw4EE99NBD2rFjhz755BM9/fTTGjduXJmhkL/14IMP6sSJE7rjjju0YcMG7d27V//5z380YsQIFRUVKSgoSI8//rj+8pe/6J133tHevXv17bffat68eZKK53ulpqZq8eLF2rt3r+bMmVPqbtfp06c1evRorVmzRgcOHNDatWu1YcMGtWzZUlLxnLKcnBytXLlSx48fV15enpYtW6Y5c+YoJSVFBw4c0DvvvCOHw6EWLVqY20QAAABctDZx4bLZpMOZp3XsVL7V5Vw05oi5ubG9m5/zs9+HM1eoV6+ePv/8cz322GNKTExUZGSk7rnnnlILaZQnNjZWa9eu1eOPP64+ffooPz9fDRo0UFJSkjPAPfXUU/Lz89PEiROVlpamunXr6r777pMk/fGPf9TYsWM1evRo5efnq3///nrqqaecKzX6+vrql19+0dChQ3XkyBHVrl1bt9xyiyZPnixJ6tq1q+677z7dfvvt+uWXX/T000+rV69e+uijjzRp0iSdOXNGzZo107/+9S9dfvnl5jUQAAAAl6RmoJ+aRtXU7qM52nIoU9c0jbS6pItCEEO5FixYcM7Prr32Wq1fv/6cn69Zs6bc7c2aNdNHH310zuN8fHz0xBNP6Iknnij385kzZ5ZaiVGSxowZI6l46OG//vWvc55bkl599dVSi4+cr1YAAAC4r8T4CO0+mqPNBz03iDE0EQAAAIBHSYwrfp5YyiHPnSdGEAMAAADgUX67cuJvF5HzJAQxAAAAAB4lISZMAb4+ysyzK/XkaavLuSgEMQAAAAAeJcDPRy1jwyRJWzx0eCJBDAAAAIDHaXd2ntiPh7MtruTiEMQAAAAAeJxf54lxRwwAAAAAXKJtXIQkaVt6too8cL0OghgAAAAAj9O4dohCA/10xu5QRp7V1VQeQQwAAACAx/HxsaltfPE8sQM5NourqTyCmKdwFEn7/iv9+GHx/zqKrK7IMjabTR9//LHVZQAAAMBiJcMTUwliMMVPS6UXW0tv3yD9+57i/32xdfF2k61bt06+vr7q379/pY5r2LChXnzxRXOKAgAAQLX2t+RdmrNytxLLCWJzVu7W35J3WVRZxRHE3N1PS6X3h0rZaaW3Z6cXbzc5jM2bN08PPfSQvv76a6WlpV34AAAAAMBkvj42zU7epe8PnJQkpedJeQWFmrNyt2Yn75Kvj/vfISOIuZphSAW5FXudyZa++Iuk8paBObtt+ePF+/32OHte+eczKrecTE5Ojt577z3df//96t+/vxYsWFDq808//VRXXHGFgoKCVLt2bQ0YMECS1L17dx04cEBjx46VzWaTzVb8f4RJkyapXbt2pc7x4osvqmHDhs73GzZsUO/evVW7dm2Fh4fr2muv1ffff3/OGgsKCjR69GjVrVtXQUFBatCggaZPn16p6wQAAIBnebhnM43r3Vxv/PdnhQT4yiGbnv18p2Yn79K43s31cM9mVpd4QX5WF1Dt2POkabFVdDKj+E7Zc/HOLT6SIs61+1/TpICQCp/9/fffV0JCglq0aKG77rpLY8aM0YQJE2Sz2fTZZ59pwIABeuKJJ/TOO++ooKBAn3/+uSTpo48+UmJiokaNGqWRI0dW6opOnTqlYcOGae7cuTIMQ7NmzdL111+v3bt3KzQ0tMz+c+bM0dKlS/X++++rfv36OnjwoA4ePFip7wQAAIDnKQlbs88OQ/xg02GPCWESQQznMW/ePN11112SpKSkJGVlZemrr75S9+7dNXXqVA0ePFiTJ0927p+YmChJioyMlK+vr0JDQxUTE1Op7+zRo0ep92+88YYiIiL01Vdf6YYbbiizf2pqqpo1a6Zu3brJZrOpQYMGlb1MAAAAeKiHezbTS1/uVpFhyNfH5jEhTCKIuZ5/cPGdqYo48I208LYL7zfkQ6lBV0mSw+FQ9qlTCgsNlY/P70ae+gdXuMydO3dq/fr1WrJkiSTJz89Pt99+u+bNm6fu3bsrJSWl0ne7KuLIkSN68skntWbNGh09elRFRUXKy8tTampqufsPHz5cvXv3VosWLZSUlKQbbrhBffr0qfK6AAAA4H7mrDwbwmyGihzF7z0ljBHEXM1mq/jwwCY9pLDY4oU5yp0nZiv+vEkPyce3eJPDIfkXFX/H74NYJcybN0+FhYWKjf11GKVhGAoMDNTLL7+sGjVqVPqcPj4+Mn43T81ut5d6P2zYMP3yyy966aWX1KBBAwUGBqpLly4qKCgo95wdOnTQvn379MUXX+jLL7/UoEGD1KtXL3344YeVrg8AAACeo2Rhjkd6NFHj0zv1c40WzmGKnhDGWKzDnfn4Skkzzr75/covZ98nPfdrCKsihYWFeueddzRr1iylpKQ4X5s3b1ZsbKz+9a9/qW3btlq5cuU5zxEQEKCiotLPOouKilJGRkapMJaSklJqn7Vr1+rhhx/W9ddfr8svv1yBgYE6fvz4eesNCwvT7bffrn/84x9677339O9//1snTpyo/IUDAADAI5SEsHG9m2v0dU0kSaOva6JxvZtr9tml7d0dd8TcXas/SoPeKV4d8bdL2IfFFoewVn+s8q9ctmyZTp48qXvuuUfh4eGlPrv11ls1b948Pf/88+rZs6eaNGmiwYMHq7CwUJ9//rkef/xxScXPEfv66681ePBgBQYGqnbt2urevbuOHTummTNn6rbbbtPy5cv1xRdfKCwszHn+Zs2a6d1331WnTp2UnZ2txx577Lx332bPnq26deuqffv28vHx0QcffKCYmBhFRERUeV8AAADgHoochnNhjt+OsCq5E1bkqNxq4VbgjpgnaPVHacxWadgy6dZ5xf875kdTQphUPCyxV69eZUKYVBzENm7cqMjISH3wwQdaunSp2rVrpx49emj9+vXO/aZMmaL9+/erSZMmioqKkiS1bNlSf//73/XKK68oMTFR69ev15///Ocy333y5El16NBB//d//6eHH35Y0dHR56w1NDRUM2fOVKdOnXTFFVdo//79+vzzz8vOjwMAAIDXGHue1REf7tlMY3s3d3FFlccdMU/h4ys1utolX/Xpp5+e87Mrr7zSObSwbdu2uuWWW8rd7w9/+IM2b95cZvt9992n++67r9S2v/71r84/t2/fXhs2bCj1+W23lV6w5LdDG0eOHGnKoiEAAACAmbhtAAAAAAAuRhADAAAAABcjiAEAAACAixHEAAAAAMDFCGIu8vsHGcMzlfwcbbbfP9cNAAAAqDiCmMl8fYsftlxQUGBxJagKeXl5cjgc8vNjwVEAAABcPI/42+T+/fv1zDPPaNWqVcrIyFBsbKzuuusuPfHEEwoICDjncWfOnNGjjz6qxYsXKz8/X3379tXf//531alTx7lPamqq7r//fq1evVo1a9bUsGHDNH369Cr7i7afn5+Cg4N17Ngx+fv7m/58K4fDoYKCAp05c4ZnaVUhwzCUl5enY8eO6dSpU86ADQAAAFwMjwhiO3bskMPh0Ouvv66mTZtq69atGjlypHJzc/XCCy+c87ixY8fqs88+0wcffKDw8HCNHj1at9xyi9auXStJKioqUv/+/RUTE6NvvvlG6enpGjp0qPz9/TVt2rQqqd1ms6lu3brat2+fDhw4UCXnPB/DMHT69GnVqFGD4XMmCAsL0+7du60uAwAAAB7OI4JYUlKSkpKSnO8bN26snTt36tVXXz1nEMvKytK8efO0aNEi9ejRQ5I0f/58tWzZUt9++63+8Ic/aMWKFfrpp5/05Zdfqk6dOmrXrp2eeeYZPf7445o0adI577bl5+crPz/f+T47O1uSZLfbZbfby+xvs9nUsGFD2e120+eKFRYW6ptvvlHXrl0ZPleFbDab/Pz85HA4JKncnzMuXUlf6a856K+56K+56K+56K+56K+53K2/Fa3DZnjoKhJPPvmkli9fro0bN5b7+apVq9SzZ0+dPHlSERERzu0NGjTQmDFjNHbsWE2cOFFLly5VSkqK8/N9+/apcePG+v7779W+fftyzz1p0iRNnjy5zPZFixYpODj4kq4LAAAAgOfKy8vTnXfeqaysLIWFhZ1zP4+8ZbJnzx7NnTv3vMMSMzIyFBAQUCqESVKdOnWUkZHh3Oe388VKPi/57FwmTJigcePGOd9nZ2crPj5effr0OW+zXcFutys5OVm9e/eWv7+/pbV4I/prLvprLvprLvprLvprLvprLvprLnfrb8louQuxNIiNHz9eM2bMOO8+27dvV0JCgvP94cOHlZSUpIEDB2rkyJFml1iuwMBABQYGltnu7+/vFj98yb1q8Ub011z011z011z011z011z011z011zu0t+K1mBpEHv00Uc1fPjw8+7TuHFj55/T0tJ03XXXqWvXrnrjjTfOe1xMTIwKCgqUmZlZ6q7YkSNHFBMT49xn/fr1pY47cuSI8zMAAAAAMIOlQSwqKkpRUVEV2vfw4cO67rrr1LFjR82fP/+CS7N37NhR/v7+WrlypW699VZJ0s6dO5WamqouXbpIkrp06aKpU6fq6NGjio6OliQlJycrLCxMrVq1qvB1lEyzq+htSDPZ7Xbl5eUpOzvbLf5FwNvQX3PRX3PRX3PRX3PRX3PRX3PRX3O5W39LMsEFl+IwPMChQ4eMpk2bGj179jQOHTpkpKenO1+/3adFixbGd99959x23333GfXr1zdWrVplbNy40ejSpYvRpUsX5+eFhYVG69atjT59+hgpKSnG8uXLjaioKGPChAmVqu/gwYOGJF68ePHixYsXL168ePEyJBkHDx48b4bwiMU6kpOTtWfPHu3Zs0dxcXGlPjPOJk273a6dO3cqLy/P+dnf/vY3+fj46NZbby31QOcSvr6+WrZsme6//3516dJFISEhGjZsmKZMmVKp+mJjY3Xw4EGFhoZa/uyukoVDDh48aPnCId6I/pqL/pqL/pqL/pqL/pqL/pqL/prL3fprGIZOnTql2NjY8+7nscvXo3zZ2dkKDw+/4HKZuDj011z011z011z011z011z011z011ye2t/zT7QCAAAAAFQ5ghgAAAAAuBhBzMsEBgbq6aefLvc5Z7h09Ndc9Ndc9Ndc9Ndc9Ndc9Ndc9Ndcntpf5ogBAAAAgItxRwwAAAAAXIwgBgAAAAAuRhADAAAAABcjiAEAAACAixHEvMgrr7yihg0bKigoSJ07d9b69eutLslrfP3117rxxhsVGxsrm82mjz/+2OqSvMr06dN1xRVXKDQ0VNHR0br55pu1c+dOq8vyGq+++qratm2rsLAwhYWFqUuXLvriiy+sLssrPffcc7LZbBozZozVpXiNSZMmyWazlXolJCRYXZZXOXz4sO666y7VqlVLNWrUUJs2bbRx40ary/IKDRs2LPP7a7PZ9OCDD1pdmlcoKirSU089pUaNGqlGjRpq0qSJnnnmGXnKWoQEMS/x3nvvady4cXr66af1/fffKzExUX379tXRo0etLs0r5ObmKjExUa+88orVpXilr776Sg8++KC+/fZbJScny263q0+fPsrNzbW6NK8QFxen5557Tps2bdLGjRvVo0cP3XTTTdq2bZvVpXmVDRs26PXXX1fbtm2tLsXrXH755UpPT3e+/ve//1ldktc4efKkrrrqKvn7++uLL77QTz/9pFmzZumyyy6zujSvsGHDhlK/u8nJyZKkgQMHWlyZd5gxY4ZeffVVvfzyy9q+fbtmzJihmTNnau7cuVaXViEsX+8lOnfurCuuuEIvv/yyJMnhcCg+Pl4PPfSQxo8fb3F13sVms2nJkiW6+eabrS7Fax07dkzR0dH66quvdM0111hdjleKjIzU888/r3vuucfqUrxCTk6OOnTooL///e969tln1a5dO7344otWl+UVJk2apI8//lgpKSlWl+KVxo8fr7Vr1+q///2v1aVUC2PGjNGyZcu0e/du2Ww2q8vxeDfccIPq1KmjefPmObfdeuutqlGjhv75z39aWFnFcEfMCxQUFGjTpk3q1auXc5uPj4969eqldevWWVgZcHGysrIkFYcFVK2ioiItXrxYubm56tKli9XleI0HH3xQ/fv3L/XfYVSd3bt3KzY2Vo0bN9aQIUOUmppqdUleY+nSperUqZMGDhyo6OhotW/fXv/4xz+sLssrFRQU6J///KfuvvtuQlgV6dq1q1auXKldu3ZJkjZv3qz//e9/6tevn8WVVYyf1QXg0h0/flxFRUWqU6dOqe116tTRjh07LKoKuDgOh0NjxozRVVddpdatW1tdjtf48ccf1aVLF505c0Y1a9bUkiVL1KpVK6vL8gqLFy/W999/rw0bNlhdilfq3LmzFixYoBYtWig9PV2TJ0/W1Vdfra1btyo0NNTq8jzezz//rFdffVXjxo3TX//6V23YsEEPP/ywAgICNGzYMKvL8yoff/yxMjMzNXz4cKtL8Rrjx49Xdna2EhIS5Ovrq6KiIk2dOlVDhgyxurQKIYgBcCsPPvigtm7dyhyQKtaiRQulpKQoKytLH374oYYNG6avvvqKMHaJDh48qEceeUTJyckKCgqyuhyv9Nt/2W7btq06d+6sBg0a6P3332dobRVwOBzq1KmTpk2bJklq3769tm7dqtdee40gVsXmzZunfv36KTY21upSvMb777+vhQsXatGiRbr88suVkpKiMWPGKDY21iN+fwliXqB27dry9fXVkSNHSm0/cuSIYmJiLKoKqLzRo0dr2bJl+vrrrxUXF2d1OV4lICBATZs2lSR17NhRGzZs0EsvvaTXX3/d4so826ZNm3T06FF16NDBua2oqEhff/21Xn75ZeXn58vX19fCCr1PRESEmjdvrj179lhdileoW7dumX+Qadmypf79739bVJF3OnDggL788kt99NFHVpfiVR577DGNHz9egwcPliS1adNGBw4c0PTp0z0iiDFHzAsEBASoY8eOWrlypXObw+HQypUrmQMCj2AYhkaPHq0lS5Zo1apVatSokdUleT2Hw6H8/Hyry/B4PXv21I8//qiUlBTnq1OnThoyZIhSUlIIYSbIycnR3r17VbduXatL8QpXXXVVmceF7Nq1Sw0aNLCoIu80f/58RUdHq3///laX4lXy8vLk41M6zvj6+srhcFhUUeVwR8xLjBs3TsOGDVOnTp105ZVX6sUXX1Rubq5GjBhhdWleIScnp9S/vu7bt08pKSmKjIxU/fr1LazMOzz44INatGiRPvnkE4WGhiojI0OSFB4erho1alhcneebMGGC+vXrp/r16+vUqVNatGiR1qxZo//85z9Wl+bxQkNDy8xlDAkJUa1atZjjWEX+/Oc/68Ybb1SDBg2Ulpamp59+Wr6+vrrjjjusLs0rjB07Vl27dtW0adM0aNAgrV+/Xm+88YbeeOMNq0vzGg6HQ/Pnz9ewYcPk58dfvavSjTfeqKlTp6p+/fq6/PLL9cMPP2j27Nm6++67rS6tYgx4jblz5xr169c3AgICjCuvvNL49ttvrS7Ja6xevdqQVOY1bNgwq0vzCuX1VpIxf/58q0vzCnfffbfRoEEDIyAgwIiKijJ69uxprFixwuqyvNa1115rPPLII1aX4TVuv/12o27dukZAQIBRr1494/bbbzf27NljdVle5dNPPzVat25tBAYGGgkJCcYbb7xhdUle5T//+Y8hydi5c6fVpXid7Oxs45FHHjHq169vBAUFGY0bNzaeeOIJIz8/3+rSKoTniAEAAACAizFHDAAAAABcjCAGAAAAAC5GEAMAAAAAFyOIAQAAAICLEcQAAAAAwMUIYgAAAADgYgQxAAAAAHAxghgAAAAAuBhBDAAAAABcjCAGAMBvDB8+XDabTTabTf7+/qpTp4569+6tt956Sw6Ho8LnWbBggSIiIswrFADg0QhiAAD8TlJSktLT07V//3598cUXuu666/TII4/ohhtuUGFhodXlAQC8AEEMAIDfCQwMVExMjOrVq6cOHTror3/9qz755BN98cUXWrBggSRp9uzZatOmjUJCQhQfH68HHnhAOTk5kqQ1a9ZoxIgRysrKct5dmzRpkiQpPz9ff/7zn1WvXj2FhISoc+fOWrNmjTUXCgCwDEEMAIAK6NGjhxITE/XRRx9Jknx8fDRnzhxt27ZNb7/9tlatWqW//OUvkqSuXbvqxRdfVFhYmNLT05Wenq4///nPkqTRo0dr3bp1Wrx4sbZs2aKBAwcqKSlJu3fvtuzaAACuZzMMw7C6CAAA3MXw4cOVmZmpjz/+uMxngwcP1pYtW/TTTz+V+ezDDz/Ufffdp+PHj0sqniM2ZswYZWZmOvdJTU1V48aNlZqaqtjYWOf2Xr166corr9S0adOq/HoAAO7Jz+oCAADwFIZhyGazSZK+/PJLTZ8+XTt27FB2drYKCwt15swZ5eXlKTg4uNzjf/zxRxUVFal58+altufn56tWrVqm1w8AcB8EMQAAKmj79u1q1KiR9u/frxtuuEH333+/pk6dqsjISP3vf//TPffco4KCgnMGsZycHPn6+mrTpk3y9fUt9VnNmjVdcQkAADdBEAMAoAJWrVqlH3/8UWPHjtWmTZvkcDg0a9Ys+fgUT7d+//33S+0fEBCgoqKiUtvat2+voqIiHT16VFdffbXLagcAuB+CGAAAv5Ofn6+MjAwVFRXpyJEjWr58uaZPn64bbrhBQ4cO1datW2W32zV37lzdeOONWrt2rV577bVS52jYsKFycnK0cuVKJSYmKjg4WM2bN9eQIUM0dOhQzZo1S+3bt9exY8e0cuVKtW3bVv3797foigEArsaqiQAA/M7y5ctVt25dNWzYUElJSVq9erXmzJmjTz75RL6+vkpMTNTs2bM1Y8YMtW7dWgsXLtT06dNLnaNr16667777dPvttysqKkozZ86UJM2fP19Dhw7Vo48+qhYtWujmm2/Whg0bVL9+fSsuFQBgEVZNBAAAAAAX444YAAAAALgYQQwAAAAAXIwgBgAAAAAuRhADAAAAABcjiAEAAACAixHEAAAAAMDFCGIAAAAA4GIEMQAAAABwMYIYAAAAALgYQQwAAAAAXIwgBgAAAAAu9v9dbsfvbH9LoQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "8\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "9\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAIjCAYAAADxz9EgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABmZElEQVR4nO3dd3hUZfrG8Xtm0rtAIIQEQm+S0IQFQZGO6IoFRHEFRVwLKuC64roi+BNZWLGAbVUUcWERC4qorBFEXEQpGhCkqxAIPaZD2pzfHyGjMQGSMCdnZvL9XFcunTOnPPNk5PLmvO97bIZhGAIAAAAAuIXd6gIAAAAAwJcQsgAAAADAjQhZAAAAAOBGhCwAAAAAcCNCFgAAAAC4ESELAAAAANyIkAUAAAAAbkTIAgAAAAA3ImQBAAAAgBsRsgAAHsVms2nq1KlWlwEAQLURsgDAh73wwguy2Wzq3r17tc+RlpamqVOnKiUlxX2F+ajVq1fLZrNV+DNy5EiryzPdxx9/TEAGAEl+VhcAADDPwoULlZCQoPXr12vPnj1q0aJFlc+RlpamadOmKSEhQR07dnR/kT7o3nvv1UUXXVRmW0JCgjXF1KCPP/5Yzz//PEELQK1HyAIAH/XTTz/pq6++0nvvvac///nPWrhwoR599FGry6oVevfureuuu87t583NzVVoaKjbzwsAcC+GCwKAj1q4cKEuuOACDR06VNddd50WLlxY4X4ZGRmaOHGiEhISFBgYqLi4ON188806fvy4Vq9e7bojc8stt7iGvs2fP19Syd2ZMWPGlDtnnz591KdPH9frgoICTZkyRV26dFFkZKRCQ0PVu3dvff755+f8HNnZ2ZowYYKrvvr162vAgAH69ttvz3jMO++8I5vNpi+++KLce//6179ks9m0detWSdLhw4d1yy23KC4uToGBgWrYsKGuuuoq/fzzz+esrbq+++47DRkyRBEREQoLC1O/fv309ddfl9ln/vz5rs9w1113qX79+oqLi3O9/8knn6h3794KDQ1VeHi4hg4dqm3btpW71o4dOzRixAhFR0crODhYrVu31sMPP+x6f9++fbrrrrvUunVrBQcHq27duho+fHi5z19YWKhp06apZcuWCgoKUt26ddWrVy8lJydLksaMGaPnn39eksoMkyy1ePFidenSReHh4YqIiFCHDh307LPPnncvAcATcScLAHzUwoULdc011yggIEA33HCDXnzxRW3YsKHMMLacnBz17t1b27dv16233qrOnTvr+PHjWrZsmQ4cOKC2bdvqscce05QpU3T77berd+/ekqSePXtWqZasrCy9+uqruuGGGzRu3DhlZ2dr3rx5GjRokNavX3/WYYh33HGH3nnnHY0fP17t2rXTiRMn9L///U/bt29X586dKzxm6NChCgsL05IlS3TppZeWee+tt95S+/btdeGFF0qSrr32Wm3btk333HOPEhISdPToUSUnJ2v//v3VHuKXnZ2t48ePl9lWp04d2e12bdu2Tb1791ZERIT++te/yt/fX//617/Up08fffHFF+Xmz911112Kjo7WlClTlJubK0l68803NXr0aA0aNEgzZ85UXl6eXnzxRfXq1Uvfffedq+4tW7aod+/e8vf31+23366EhATt3btXH374oaZPny5J2rBhg7766iuNHDlScXFx+vnnn/Xiiy+qT58++uGHHxQSEiJJmjp1qmbMmKHbbrtN3bp1U1ZWljZu3Khvv/1WAwYM0J///GelpaUpOTlZb775ZpnPkJycrBtuuEH9+vXTzJkzJUnbt2/X2rVrdd9991WrxwDg0QwAgM/ZuHGjIclITk42DMMwnE6nERcXZ9x3331l9psyZYohyXjvvffKncPpdBqGYRgbNmwwJBmvv/56uX2aNGlijB49utz2Sy+91Lj00ktdr4uKioz8/Pwy+/zyyy9GgwYNjFtvvbXMdknGo48+6nodGRlp3H333Wf5tBW74YYbjPr16xtFRUWubYcOHTLsdrvx2GOPuWqQZPzzn/+s8vkr8vnnnxuSKvz56aefDMMwjGHDhhkBAQHG3r17XcelpaUZ4eHhxiWXXOLa9vrrrxuSjF69epX5DNnZ2UZUVJQxbty4Mtc+fPiwERkZWWb7JZdcYoSHhxv79u0rs2/p79YwDCMvL6/c51i3bp0hyViwYIFrW1JSkjF06NCzfv67777bqOh/Le677z4jIiKizOcAAF/GcEEA8EELFy5UgwYNdNlll0kqGb51/fXXa/HixSouLnbt9+677yopKUlXX311uXP8dqjX+XI4HAoICJAkOZ1Opaenq6ioSF27dj3rsD9JioqK0jfffKO0tLQqXfP666/X0aNHtXr1ate2d955R06nU9dff70kKTg4WAEBAVq9erV++eWXqn2os5gyZYqSk5PL/MTExKi4uFiffvqphg0bpmbNmrn2b9iwoW688Ub973//U1ZWVplzjRs3Tg6Hw/U6OTlZGRkZuuGGG3T8+HHXj8PhUPfu3V1DMI8dO6Y1a9bo1ltvVePGjcuc87e/2+DgYNe/FxYW6sSJE2rRooWioqLK/G6ioqK0bds27d69u8r9iIqKUm5urmtoIQD4OkJWJa1Zs0ZXXnmlYmNjZbPZ9P7771f5HIZh6Mknn1SrVq0UGBioRo0auYZrAIC7FBcXa/Hixbrsssv0008/ac+ePdqzZ4+6d++uI0eOaOXKla599+7d6xo2Z7Y33nhDiYmJrvk80dHR+uijj5SZmXnW42bNmqWtW7cqPj5e3bp109SpU/Xjjz+e83qDBw9WZGSk3nrrLde2t956Sx07dlSrVq0kSYGBgZo5c6Y++eQTNWjQQJdccolmzZqlw4cPn9dn7dChg/r371/mJygoSMeOHVNeXp5at25d7pi2bdvK6XQqNTW1zPamTZuWeV0acvr27avo6OgyP59++qmOHj0qSa4enev3e/LkSU2ZMkXx8fEKDAxUvXr1FB0drYyMjDK/m8cee0wZGRlq1aqVOnTooAceeEBbtmypVD/uuusutWrVSkOGDFFcXJxuvfVWrVixolLHAoA3ImRVUm5urpKSklyTeqvjvvvu06uvvqonn3xSO3bs0LJly9StWzc3VgkA0qpVq3To0CEtXrxYLVu2dP2MGDFCks64AEZ1nOlu12/vlknSv//9b40ZM0bNmzfXvHnztGLFCiUnJ6tv375yOp1nvcaIESP0448/au7cuYqNjdU///lPtW/fXp988slZjwsMDNSwYcO0dOlSFRUV6eDBg1q7dq3rLlapCRMmaNeuXZoxY4aCgoL0yCOPqG3btvruu+8q0QHz/fZOkyRXv958881yd8uSk5P1wQcfVOn899xzj6ZPn64RI0ZoyZIl+vTTT5WcnKy6deuW+d1ccskl2rt3r1577TVdeOGFevXVV9W5c2e9+uqr57xG/fr1lZKSomXLlumPf/yjPv/8cw0ZMkSjR4+uUq0A4DWsHq/ojSQZS5cuLbPt1KlTxv3332/ExsYaISEhRrdu3YzPP//c9f4PP/xg+Pn5GTt27KjZYgHUOqNHjzbq169vvP322+V+brjhBiM8PNw1D6d9+/ZGUlLSWc9XOr+rojlZnTp1Mq666qpy2+Pj48vMybrqqquMZs2alZkLZBiG0bNnT6NJkyZltul3c7J+78iRI0ajRo2Miy+++Kx1G4ZhfPzxx4YkY8WKFcbTTz9tSDJ+/PHHsx6za9cuIyQkxBg1atQ5z/97pXOy3n777QrfLyoqMkJCQowRI0aUe++OO+4w7Ha7kZmZaRjGr3OyNmzYUGa/JUuWGJKM//73v2et5ejRo4akcvPwfi8yMtK45ZZbymw7efKk4XA4KpxvVyo7O9vo1KmT0ahRI9e28ePHVzgn6/eKi4uNP//5z4YkY/fu3efcHwC8DXey3GT8+PFat26dFi9erC1btmj48OEaPHiwa1jHhx9+qGbNmmn58uVq2rSpEhISdNtttyk9Pd3iygH4kpMnT+q9997TFVdcoeuuu67cz/jx45Wdna1ly5ZJKllZb/PmzVq6dGm5cxmGIUmu5zJlZGSU26d58+b6+uuvVVBQ4Nq2fPnyckPeSucUlZ5Tkr755hutW7furJ+nuLi43HDC+vXrKzY2Vvn5+Wc9VpL69++vOnXq6K233tJbb72lbt26lRl+l5eXp1OnTpX7TOHh4WXOf+jQIe3YsUOFhYXnvObZOBwODRw4UB988EGZJdKPHDmiRYsWqVevXoqIiDjrOQYNGqSIiAg98cQTFdZz7NgxSVJ0dLQuueQSvfbaa9q/f3+ZfX77e3A4HGVeS9LcuXPL3Y08ceJEmddhYWFq0aJFmT6d6bvy+2PtdrsSExMlqVK/RwDwNizh7gb79+/X66+/rv379ys2NlaS9Je//EUrVqzQ66+/rieeeEI//vij9u3bp7ffflsLFixQcXGxJk6cqOuuu06rVq2y+BMA8BXLli1Tdna2/vjHP1b4/h/+8AdFR0dr4cKFuv766/XAAw/onXfe0fDhw3XrrbeqS5cuSk9P17Jly/TSSy8pKSlJzZs3V1RUlF566SWFh4crNDRU3bt3V9OmTXXbbbfpnXfe0eDBgzVixAjt3btX//73v9W8efMy173iiiv03nvv6eqrr9bQoUP1008/6aWXXlK7du2Uk5Nzxs+TnZ2tuLg4XXfddUpKSlJYWJg+++wzbdiwQbNnzz5nP/z9/XXNNddo8eLFys3N1ZNPPlnm/V27dqlfv34aMWKE2rVrJz8/Py1dulRHjhzRyJEjXfs99NBDeuONN/TTTz9Ve1n3Uo8//riSk5PVq1cv3XXXXfLz89O//vUv5efna9asWec8PiIiQi+++KL+9Kc/qXPnzho5cqSio6O1f/9+ffTRR7r44ov13HPPSZLmzJmjXr16qXPnzrr99tvVtGlT/fzzz/roo4+UkpIiqeR38+abbyoyMlLt2rXTunXr9Nlnn6lu3bplrtuuXTv16dNHXbp0UZ06dbRx40bX0vqlunTpIkm69957NWjQIDkcDo0cOdL1l4p9+/ZVXFyc9u3bp7lz56pjx45q27btefUTADyStTfSvJN+N1xw+fLlhiQjNDS0zI+fn59rSMi4ceMMScbOnTtdx23atMmQxBBCAG5z5ZVXGkFBQUZubu4Z9xkzZozh7+9vHD9+3DAMwzhx4oQxfvx4o1GjRkZAQIARFxdnjB492vW+YRjGBx98YLRr187w8/MrN3Rw9uzZRqNGjYzAwEDj4osvNjZu3FhuCXen02k88cQTRpMmTYzAwECjU6dOxvLly43Ro0efdbhgfn6+8cADDxhJSUlGeHi4ERoaaiQlJRkvvPBCpXuSnJxsSDJsNpuRmppa5r3jx48bd999t9GmTRsjNDTUiIyMNLp3724sWbKkzH6jR48uswz7mZxruGCpb7/91hg0aJARFhZmhISEGJdddpnx1VdfldnnTMMFf3utQYMGGZGRkUZQUJDRvHlzY8yYMcbGjRvL7Ld161bj6quvNqKiooygoCCjdevWxiOPPOJ6/5dffjFuueUWo169ekZYWJgxaNAgY8eOHeWW53/88ceNbt26GVFRUUZwcLDRpk0bY/r06UZBQYFrn6KiIuOee+4xoqOjDZvN5ho6+M477xgDBw406tevbwQEBBiNGzc2/vznPxuHDh06a58AwFvZDON3YwRwTjabTUuXLtWwYcMklaxWNWrUKG3btq3MMrtSyXCKmJgYPfroo+WGdpw8eVIhISH69NNPNWDAgJr8CAAAAABMwnBBN+jUqZOKi4t19OhR9e7du8J9Lr74YhUVFWnv3r2uYTS7du2SJDVp0qTGagUAAABgLu5kVVJOTo727NkjqSRUPfXUU7rssstUp04dNW7cWDfddJPWrl2r2bNnq1OnTjp27JhWrlypxMREDR06VE6nUxdddJHCwsL0zDPPyOl06u6771ZERIQ+/fRTiz8dAAAAAHchZFXS6tWrddlll5XbPnr0aM2fP1+FhYV6/PHHtWDBAh08eFD16tXTH/7wB02bNk0dOnSQJKWlpemee+7Rp59+qtDQUA0ZMkSzZ89WnTp1avrjAAAAADAJIQsAAAAA3IjnZAEAAACAGxGyAAAAAMCNWF3wHJxOp9LS0hQeHi6bzWZ1OQAAAAAsYhiGsrOzFRsbK7v9zPerCFnnkJaWpvj4eKvLAAAAAOAhUlNTFRcXd8b3CVnnEB4eLqmkkREREZbWUlhYqE8//VQDBw6Uv7+/pbX4IvprLvprLvprLvprLvprPnpsLvprLk/qb1ZWluLj410Z4UwIWedQOkQwIiLCI0JWSEiIIiIiLP+C+SL6ay76ay76ay76ay76az56bC76ay5P7O+5phGx8AUAAAAAuBEhCwAAAADciJAFAAAAAG5EyAIAAAAANyJkAQAAAIAbEbIAAAAAwI0IWQAAAADgRoQsAAAAAHAjQhYAAAAAuBEhCwAAAADciJAFAAAAAG5EyAIAAAAANyJkAQAAAIAbEbK8hbNYtn3/U6P0dbLt+5/kLLa6It9Cf81Ff81Ff81Ff81Ff81Hj81Ff83lpf21GYZhWF2EJ8vKylJkZKQyMzMVERFR49d/OnmXWqV/rqEHn5Gy0n59IyJWHzWaoF11LtPEAa1qvC5fQX/NRX/NRX/NRX/NRX/NR4/NRX9rwA/LpBUPluuvBs+U2v3RkpIqmw24k+XhWqV/riE//FXGb79ckoysNA354a9qlf65RZX5BvprLvprLvprLvprLvprPnpsLvprsh+WSUtuLhuwJCnrUMn2H5ZZU1clcSfrHCy9k+Uslp65UEZWmmwVvG1IKgy4QNu6PCbZzMvLtvM5t62iys0/tlKHGk61/eZv8i/45cz9DbxA27s9UWF/q/RfTlV2rsK+huGsQhFVKaHyNdh0hhoMp9p/O1X+BRln+f5GaVvnqaZ+f31WJfu7tbO5fz6cL9v5/BlhJsOp9pseOUd/zf/z93yd15/fZjKcarfx4XP294eLpnt0fz2a4VS7DX87d4+7Pk6Pq6MS32FbSF3pijmSnf5WmdMpfXiPdDL9DDvYSu5oTfhesjtqtLTKZgNC1jlYGrJ++lJ644qavSYAAADgDUYvl5r2rtFLVjYb+NVgTaiqnCOV2u2gPVbZ9sgzvm/T+eTo6h97ftetvspeN8yZrYbOw+fc75A9Rjn28ArfMyr8+6vzV7XzVn7fKp23CncYKup4hDNTjYoPnvPYg45GyjrL9xcV84X+eug9LElSeGX7e44/f61k1Z/BlRHuzFKsM+2c+6XZGyrbXvPzoX1BSY8PnXO/NHssPa6Gyn6HVaeZFFLX/IJ8Td4JKf3Hc+9Xyf9XtgIhy5OFNajUbo3+9HKNp3ifUMk7hQ3/9Cr9rY5K9rfRTf9SI/pbdfTXXJXtL3/+Vk8l+xv7p1fob3VVusd8h6ulsqONrpxDf6ujsv2t5P8rW4FBop6sSU8pIvaMfxdpSFJEo5L9UHX011z011z011z011z013z02Fz011yn+3vmMQ82j+8vIcuT2R36qNEEGUb54ViGStZH+KjRfTU+4c9n0F9z0V9z0V9z0V9z0V/z0WNz0V9z2R0ly7RLKh+0Tr8e/A+P7i8hy8PtqnOZPmk3S7aI2DLbbRGN9Em7WdpV5zKLKvMN9Ndc9Ndc9Ndc9Ndc9Nd89Nhc9Ndk7f4ojVggRTQsuz0itmS7Rc/JqixWFzwHqx9G7OIsVtGPa5Ty5X/Vsfcg+TW7xKPTu9ehv+aiv+aiv+aiv+aiv+ajx+ZyFuv7tR/plU++UXFofT3/0Hj6604e9v3lYcS+xu6Q0aSXDtbpIaNJL/7jdTf6ay76ay76ay76ay76az56bC67Q3GdBuhDZw99lN1Cx3KLrK7It3jp95eQBQAAAJyHsEA/NQgu+fctBzIsrQWegZAFAAAAnKfGYSUzcDanZlhbCDwCIQsAAAA4T01KQ9aBTIsrgScgZAEAAADnyXUn60CGWFcOhCwAAADgPMWGSP4OmzLyCrU/Pc/qcmAxQhYAAABwnvzsUruGJUt6M2QQhCwAAADADRIbnQ5ZLH5R6xGyAAAAADdIjIuURMgCIQsAAABwi8RGJSFra1qmioqdFlcDKxGyAAAAADdIqBui8EA/nSp0ateRHKvLgYUIWQAAAIAb2O02JcafHjJ4IMPaYmApQhYAAADgJklxUZKkLYSsWo2QBQAAALhJ4umQlZLKMu61GSELAAAAcJOO8VGSpF1HsnWyoNjaYmAZQhYAAADgJjGRQWoQEahip6FtadzNqq0IWQAAAIAb/TpkMMPSOmAdQhYAAADgRqVDBjcf4E5WbeV1Iev5559XQkKCgoKC1L17d61fv/6s+7/99ttq06aNgoKC1KFDB3388cc1VCkAAABqI1YYhFeFrLfeekuTJk3So48+qm+//VZJSUkaNGiQjh49WuH+X331lW644QaNHTtW3333nYYNG6Zhw4Zp69atNVw5AAAAaosOcSXPytp3Ik+/5BZYXA2s4FUh66mnntK4ceN0yy23qF27dnrppZcUEhKi1157rcL9n332WQ0ePFgPPPCA2rZtq//7v/9T586d9dxzz9Vw5QAAAKgtIoP91axeqCQeSlxb+VldQGUVFBRo06ZNeuihh1zb7Ha7+vfvr3Xr1lV4zLp16zRp0qQy2wYNGqT333//jNfJz89Xfn6+63VWVpYkqbCwUIWFhefxCc5f6fWtrsNX0V9z0V9z0V9z0V9z0V/z0WNzVdTfDo0i9OPxXH27L10XN7vAqtJ8gid9fytbg9eErOPHj6u4uFgNGjQos71BgwbasWNHhcccPny4wv0PHz58xuvMmDFD06ZNK7f9008/VUhISDUqd7/k5GSrS/Bp9Ndc9Ndc9Ndc9Ndc9Nd89Nhcv+2vX6ZNkkMrv9ut5id3WleUD/GE729eXl6l9vOakFVTHnrooTJ3v7KyshQfH6+BAwcqIiLCwspKknNycrIGDBggf39/S2vxRfTXXPTXXPTXXPTXXPTXfPTYXBX1t2Fqht59eb0OFwRpyJBLZbPZLK7Se3nS97d0lNu5eE3IqlevnhwOh44cOVJm+5EjRxQTE1PhMTExMVXaX5ICAwMVGBhYbru/v7/lv9RSnlSLL6K/5qK/5qK/5qK/5qK/5qPH5vptfxPj68jPbtOJ3AIdzS1S3AWeMSLKm3nC97ey1/eahS8CAgLUpUsXrVy50rXN6XRq5cqV6tGjR4XH9OjRo8z+UsltxjPtDwAAALhDkL9DbRuWjILawvOyah2vCVmSNGnSJL3yyit64403tH37dt15553Kzc3VLbfcIkm6+eabyyyMcd9992nFihWaPXu2duzYoalTp2rjxo0aP368VR8BAAAAtUTi6aXcN6dmWFsIapzXDBeUpOuvv17Hjh3TlClTdPjwYXXs2FErVqxwLW6xf/9+2e2/5saePXtq0aJF+vvf/66//e1vatmypd5//31deOGFVn0EAAAA1BJJ8VFa+M1+pRCyah2vClmSNH78+DPeiVq9enW5bcOHD9fw4cNNrgoAAAAoq2N8lCRp68FMFTsNOewsflFbeNVwQQAAAMBbNI8OU0iAQ7kFxdp7LMfqclCDCFkAAACACRx2mzo0KpmXxZDB2oWQBQAAAJikdMjglgMZltaBmkXIAgAAAEySGBclSdqcyjLutQkhCwAAADBJUnzJcMHth7J0qrDY4mpQUwhZAAAAgEkaRQWrXliAipyGth/Ksroc1BBCFgAAAGASm832myGDGZbWgppDyAIAAABMlFQasg4wL6u2IGQBAAAAJiqdl7WZFQZrDUIWAAAAYKLS4YI/HstV5slCa4tBjSBkAQAAACaqExqgxnVCJEnfM2SwViBkAQAAACZLOv1QYoYM1g6ELAAAAMBkSXGn52WxwmCtQMgCAAAATMadrNqFkAUAAACYrH1shBx2m45k5etw5imry4HJCFkAAACAyUIC/NSqQbgk7mbVBoQsAAAAoAYwL6v2IGQBAAAANYB5WbUHIQsAAACoAUmnH0q85UCmnE7D2mJgKkIWAAAAUANaNQhTkL9d2aeK9NOJXKvLgYkIWQAAAEAN8HPYdWEs87JqA0IWAAAAUENK52VtOZBpbSEwFSELAAAAqCGJp1cYTOFOlk8jZAEAAAA1pOPpO1k/pGWpoMhpbTEwDSELAAAAqCGN64QoKsRfBcVO7TycbXU5MAkhCwAAAKghNptNiaeXck/heVk+i5AFAAAA1KCOcaww6OsIWQAAAEAN+nWFwQxL64B5CFkAAABADSodLrj7aI5y8ousLQamIGQBAAAANSg6PFCNooJlGNL3PC/LJxGyAAAAgBqWFH96XhZDBn0SIQsAAACoYaVDBpmX5ZsIWQAAAEANSzodsjanMlzQFxGyAAAAgBrWIS5SNpt0MOOkjmXnW10O3IyQBQAAANSwsEA/tYgOk8SQQV9EyAIAAAAsUPq8LB5K7HsIWQAAAIAFSkNWCsu4+xxCFgAAAGCBjr9ZYdAwDGuLgVsRsgAAAAALtI4JV4DDroy8Qu1Pz7O6HLgRIQsAAACwQICfXe1iIyRJKczL8imELAAAAMAiHU/Py9rCvCyfQsgCAAAALJIYFymJFQZ9DSELAAAAsEjpCoNb0zJVVOy0thi4DSELAAAAsEjTuqEKD/LTqUKndh3JsbocuAkhCwAAALCI3W77dcjggQxri4HbELIAAAAACyWdfl4W87J8ByELAAAAsFDpvKzNrDDoMwhZAAAAgIVK72TtOpKtvIIia4uBWxCyAAAAAAvFRAapQUSgip2GtqVlWV0O3ICQBQAAAFiMeVm+hZAFAAAAWIx5Wb6FkAUAAABYjDtZvoWQBQAAAFisw+lnZe1Pz1N6boHF1eB8EbIAAAAAi0UG+6tZvVBJ0hYeSuz1CFkAAACAB3DNy0plXpa3I2QBAAAAHiDp9JDBzdzJ8nqELAAAAMADJJ6+k7XlQIYMw7C2GJwXQhYAAADgAdo1jJCf3abjOQU6mHHS6nJwHghZAAAAgAcI8neobcMISczL8naELAAAAMBDJMWXzMtihUHvRsgCAAAAPETi6YcSp/BQYq9GyAIAAAA8RMfTi198fzBTxU4Wv/BWhCwAAADAQzSPDlNogEN5BcXaeyzH6nJQTYQsAAAAwEM47DZd2KhkXhZDBr0XIQsAAADwIKVDBjcTsrwWIQsAAADwIEmuhxKzjLu3ImQBAAAAHiQxrmS44PZDWTpVWGxxNagOQhYAAADgQRpFBateWICKnIZ+OJRldTmoBkIWAAAA4EFsNpuSTj8vawvzsrwSIQsAAADwMKUPJd7MvCyvRMgCAAAAPExSfMm8LFYY9E5eE7LS09M1atQoRUREKCoqSmPHjlVOzpkf0Jaenq577rlHrVu3VnBwsBo3bqx7771XmZn8bQAAAAA8W+lwwR+P5yrzZKG1xaDKvCZkjRo1Stu2bVNycrKWL1+uNWvW6Pbbbz/j/mlpaUpLS9OTTz6prVu3av78+VqxYoXGjh1bg1UDAAAAVXdBaIAa1wmRJH3PkEGv42d1AZWxfft2rVixQhs2bFDXrl0lSXPnztXll1+uJ598UrGxseWOufDCC/Xuu++6Xjdv3lzTp0/XTTfdpKKiIvn5ecVHBwAAQC2VFB+l/el52nwgQ71a1rO6HFSBVySNdevWKSoqyhWwJKl///6y2+365ptvdPXVV1fqPJmZmYqIiDhrwMrPz1d+fr7rdVZWybKZhYWFKiy09lZt6fWtrsNX0V9z0V9z0V9z0V9z0V/z0WNzmdXfDrHh+nCz9N2+9Fr9u/Ok729la7AZhmGYXMt5e+KJJ/TGG29o586dZbbXr19f06ZN05133nnOcxw/flxdunTRTTfdpOnTp59xv6lTp2ratGnlti9atEghISFVLx4AAACohr1Z0pxtfor0N/RYVx5K7Any8vJ04403um7enImld7ImT56smTNnnnWf7du3n/d1srKyNHToULVr105Tp049674PPfSQJk2aVObY+Ph4DRw48KyNrAmFhYVKTk7WgAED5O/vb2ktvoj+mov+mov+mov+mov+mo8em8us/uYVFOn57Z8rs1Dq3KuvYiKC3HZub+JJ39/SUW7nYmnIuv/++zVmzJiz7tOsWTPFxMTo6NGjZbYXFRUpPT1dMTExZz0+OztbgwcPVnh4uJYuXXrOX0xgYKACAwPLbff397f8l1rKk2rxRfTXXPTXXPTXXPTXXPTXfPTYXO7ub6S/v1o1CNf2Q1nadihX8XXD3XZub+QJ39/KXt/SkBUdHa3o6Ohz7tejRw9lZGRo06ZN6tKliyRp1apVcjqd6t69+xmPy8rK0qBBgxQYGKhly5YpKKh2pn8AAAB4p6S4SG0/lKUtBzI0+MKz31yA5/CKJdzbtm2rwYMHa9y4cVq/fr3Wrl2r8ePHa+TIka6VBQ8ePKg2bdpo/fr1kkoC1sCBA5Wbm6t58+YpKytLhw8f1uHDh1VczJhWAAAAeL6k+ChJ0uYDGZbWgarxitUFJWnhwoUaP368+vXrJ7vdrmuvvVZz5sxxvV9YWKidO3cqLy9PkvTtt9/qm2++kSS1aNGizLl++uknJSQk1FjtAAAAQHWUPpR4S2qmnE5DdrvN2oJQKV4TsurUqaNFixad8f2EhAT9dqHEPn36yAsWTgQAAADOqFWDMAX525WdX6SfTuSqeXSY1SWhErxiuCAAAABQG/k57LowNlKStDk1w9piUGmELAAAAMCDueZlEbK8BiELAAAA8GC/Ln6RaW0hqDRCFgAAAODBkuJKhgv+kJalgiKnxdWgMghZAAAAgAdrXCdEUSH+Kih2asfhLKvLQSUQsgAAAAAPZrPZXEu5M2TQOxCyAAAAAA9XOmSQxS+8AyELAAAA8HCsMOhdCFkAAACAh0s8PVxwz7Ec5eQXWVsMzomQBQAAAHi46PBANYoKlmFI3zMvy+MRsgAAAAAvkBR/el7WgQxrC8E5EbIAAAAAL+BaYZB5WR6PkAUAAAB4gdJ5WVsYLujxCFkAAACAF+gQFymbTTqYcVJHs09ZXQ7OgpAFAAAAeIGwQD+1rB8mSdqSyt0sT0bIAgAAALzEr0MGMyytA2dHyAIAAAC8ROlDiVOYl+XRCFkAAACAl+j4mztZhmFYWwzOiJAFAAAAeInWMeEKcNiVkVeo/el5VpeDMyBkAQAAAF4iwM+udrERkqQUnpflsQhZAAAAgBfpeHpe1mZWGPRYhCwAAADAiyTFR0pihUFPRsgCAAAAvEjpMu5b0zJVWOy0thhUiJAFAAAAeJGmdUMVHuSnU4VO7TqSbXU5qAAhCwAAAPAidrtNSa6l3JmX5YkIWQAAAICXSYwrmZe1mRUGPRIhCwAAAPAySadXGGQZd89EyAIAAAC8TOky7ruOZCuvoMjaYlAOIQsAAADwMg0igtQgIlBOQ9qWlmV1OfgdQhYAAADghUoXv2BeluchZAEAAABeiHlZnouQBQAAAHghlnH3XIQsAAAAwAt1OL2M+/70PKXnFlhcDX6LkAUAAAB4ochgfzWLDpUkbT6QYW0xKIOQBQAAAHgp15DBVIYMehJCFgAAAOClkk4PGeROlmchZAEAAABeqnSFwc2pGTIMw9pi4ELIAgAAALxU24YR8rPbdCK3QAczTlpdDk4jZAEAAABeKsjfobYNIyRJm5mX5TEIWQAAAIAXS4pnXpanIWQBAAAAXizx9AqDm1MzLK0DvyJkAQAAAF6s4+nFL74/mKliJ4tfeAJCFgAAAODFmkeHKTTAobyCYu05mmN1ORAhCwAAAPBqDrtNHXhelkchZAEAAABeLol5WR6FkAUAAAB4OddDibmT5REIWQAAAICXKw1ZOw5l61RhsbXFgJAFAAAAeLvYyCDVCwtQkdPQD4eyrC6n1iNkAQAAAF7OZrMxL8uDELIAAAAAH+Cal0XIshwhCwAAAPABiaeXcd9yINPiSkDIAgAAAHxA6XDBH4/nKjOv0NpiajlCFgAAAOADLggNUJO6IZKkLQczrC2mliNkAQAAAD4i8fTdLIYMWouQBQAAAPiIpNPzslJY/MJShCwAAADAR3RkhUGPQMgCAAAAfET72Eg57DYdzc7X4cxTVpdTaxGyAAAAAB8RHOBQqwbhkhgyaCVCFgAAAOBDOsaXzMvafCDD2kJqMUIWAAAA4EN+XWEww9I6ajNCFgAAAOBDSh9KvCU1U06nYW0xtRQhCwAAAPAhrRqEKcjfruz8Iv14PNfqcmolQhYAAADgQ/wcdl0YWzIviyGD1iBkAQAAAD4miedlWYqQBQAAAPiY0pCVciDT2kJqKUIWAAAA4GM6nl78YntalgqKnNYWUwsRsgAAAAAfE18nWBeE+Kug2Kkdh7OsLqfWIWQBAAAAPsZms7mel8W8rJpHyAIAAAB8kGteVirzsmoaIQsAAADwQUlxLONuFUIWAAAA4INKhwvuOZaj7FOF1hZTyxCyAAAAAB8UHR6oRlHBMgzp+4MMGaxJXhOy0tPTNWrUKEVERCgqKkpjx45VTk5OpY41DENDhgyRzWbT+++/b26hAAAAgIdIii8dMkjIqkleE7JGjRqlbdu2KTk5WcuXL9eaNWt0++23V+rYZ555RjabzeQKAQAAAM+SxAqDlvCzuoDK2L59u1asWKENGzaoa9eukqS5c+fq8ssv15NPPqnY2NgzHpuSkqLZs2dr48aNatiw4TmvlZ+fr/z8fNfrrKyS5woUFhaqsNDasayl17e6Dl9Ff81Ff81Ff81Ff81Ff81Hj83lyf1t3zBMkpSSmuGR9VWGJ/W3sjXYDMMwTK7lvL322mu6//779csvv7i2FRUVKSgoSG+//bauvvrqCo/Ly8tT165dNWPGDF111VWy2WxaunSphg0bdsZrTZ06VdOmTSu3fdGiRQoJCTnvzwIAAADUlFPF0uT1Dhmy6f+6FCkiwOqKvFteXp5uvPFGZWZmKiIi4oz7VetOVlFRkVavXq29e/fqxhtvVHh4uNLS0hQREaGwsLBqF30mhw8fVv369cts8/PzU506dXT48OEzHjdx4kT17NlTV111VaWv9dBDD2nSpEmu11lZWYqPj9fAgQPP2siaUFhYqOTkZA0YMED+/v6W1uKL6K+56K+56K+56K+56K/56LG5PL2/r/68VruP5iq6TVf1a1P/3Ad4GE/qb+kot3Opcsjat2+fBg8erP379ys/P18DBgxQeHi4Zs6cqfz8fL300kuVPtfkyZM1c+bMs+6zffv2qpYoSVq2bJlWrVql7777rkrHBQYGKjAwsNx2f39/y3+ppTypFl9Ef81Ff81Ff81Ff81Ff81Hj83lqf3tGH+Bdh/N1bZDORrcoZHV5VSbJ/S3stevcsi677771LVrV23evFl169Z1bb/66qs1bty4Kp3r/vvv15gxY866T7NmzRQTE6OjR4+W2V5UVKT09HTFxMRUeNyqVau0d+9eRUVFldl+7bXXqnfv3lq9enWVagUAAAC8UWJ8lN7edECbWWGwxlQ5ZH355Zf66quvFBBQdkBnQkKCDh48WKVzRUdHKzo6+pz79ejRQxkZGdq0aZO6dOkiqSREOZ1Ode/evcJjJk+erNtuu63Mtg4dOujpp5/WlVdeWaU6AQAAAG/V8TcrDBqGwarbNaDKIcvpdKq4uLjc9gMHDig8PNwtRf1e27ZtNXjwYI0bN04vvfSSCgsLNX78eI0cOdK1suDBgwfVr18/LViwQN26dVNMTEyFd7kaN26spk2bmlInAAAA4Glax4QrwM+uzJOF2nciTwn1Qq0uyedV+TlZAwcO1DPPPON6bbPZlJOTo0cffVSXX365O2srY+HChWrTpo369eunyy+/XL169dLLL7/ser+wsFA7d+5UXl6eaTUAAAAA3ibAz652DUsWcNt8IMPaYmqJKt/Jmj17tgYNGqR27drp1KlTuvHGG7V7927Vq1dP//nPf8yoUZJUp04dLVq06IzvJyQk6Fyr0XvBavUAAACA23WMj1JKaoY2p2bqqo7eu/iFt6hyyIqLi9PmzZu1ePFibdmyRTk5ORo7dqxGjRql4OBgM2oEAAAAcB6S4iMlcSerplTrOVl+fn666aab3F0LAAAAABMknl78YltapgqLnfJ3VHnWEKqgyiFrwYIFZ33/5ptvrnYxAAAAANyvad1QhQf5KftUkXYdyVb72EirS/Jp1XpO1m8VFhYqLy9PAQEBCgkJIWQBAAAAHsZutykpLkr/23Ncm1MzCVkmq/J9wl9++aXMT05Ojnbu3KlevXqZuvAFAAAAgOpzzctKzbC2kFrALYMxW7ZsqX/84x/l7nIBAAAA8Ayl87JY/MJ8bpvx5ufnp7S0NHedDgAAAIAbdYyPkiTtOpKtvIIia4vxcVWek7Vs2bIyrw3D0KFDh/Tcc8/p4osvdlthAAAAANynQUSQYiKCdDjrlLYezFK3pnWsLslnVTlkDRs2rMxrm82m6Oho9e3bV7Nnz3ZXXQAAAADcLDEuUod/OKUtBzIIWSaqcshyOp1m1AEAAADAZEnxUfr0hyNKYfELU/EUMgAAAKCWKJ2XxeIX5qrUnaxJkyZV+oRPPfVUtYsBAAAAYJ4LG5Us456aflLpuQWqExpgcUW+qVIh67vvvqvUyWw223kVAwAAAMA8kcH+ahYdqh+P5WrzgQxd1rq+1SX5pEqFrM8//9zsOgAAAADUgI5xUSUhK5WQZRbmZAEAAAC1SGJcyZDBLQcyLa7Ed1V5dUFJ2rhxo5YsWaL9+/eroKCgzHvvvfeeWwoDAAAA4H5JpYtfpGbIMAym/JigyneyFi9erJ49e2r79u1aunSpCgsLtW3bNq1atUqRkZFm1AgAAADATdo2jJC/w6YTuQU68MtJq8vxSVUOWU888YSefvppffjhhwoICNCzzz6rHTt2aMSIEWrcuLEZNQIAAABwkyB/h9rEREhiyKBZqhyy9u7dq6FDh0qSAgIClJubK5vNpokTJ+rll192e4EAAAAA3CspvmQEGs/LMkeVQ9YFF1yg7OxsSVKjRo20detWSVJGRoby8vLcWx0AAAAAt0uKi5IkpaRmWFqHr6p0yCoNU5dccomSk5MlScOHD9d9992ncePG6YYbblC/fv3MqRIAAACA25QufrH1YKaKnYa1xfigSoesxMREde/eXR06dNDw4cMlSQ8//LAmTZqkI0eO6Nprr9W8efNMKxQAAACAezSPDlNogEN5BcXaczTH6nJ8TqVD1hdffKH27dtrxowZatu2rUaPHq21a9dq8uTJWrZsmWbPnq0LLrjAzFoBAAAAuIHDblOH08/L2syQQberdMjq3bu3XnvtNR06dEhz587Vzz//rEsvvVStWrXSzJkzdfjwYTPrBAAAAOBGrnlZLH7hdlVe+CI0NFS33HKLvvjiC+3atUvDhw/X888/r8aNG+uPf/yjGTUCAAAAcLPSeVlbCFluV+WQ9VstWrTQ3/72N/39739XeHi4PvroI3fVBQAAAMBEpSFrx6FsnSostrYYH1PtkLVmzRqNGTNGMTExeuCBB3TNNddo7dq17qwNAAAAgEliI4NULyxQRU5D29KyrC7Hp1QpZKWlpemJJ55Qq1at1KdPH+3Zs0dz5sxRWlqaXnnlFf3hD38wq04AAAAAbmSz2ZR0evELhgy6l19ldxwyZIg+++wz1atXTzfffLNuvfVWtW7d2szaAAAAAJgoKT5KK3ccZYVBN6t0yPL399c777yjK664Qg6Hw8yaAAAAANSA0nlZmw9kWluIj6l0yFq2bJmZdQAAAACoYYmNSoYL/nQ8V5l5hYoM8be4It9wXqsLAgAAAPBeF4QGqEndEEnSloMZ1hbjQwhZAAAAQC1W+lBi5mW5DyELAAAAqMUST68wyLws9yFkAQAAALVYx9OLX6SkZsgwDGuL8RGELAAAAKAWax8bKYfdpmPZ+TqcdcrqcnwCIQsAAACoxYIDHGrVIFyStDmVIYPuQMgCAAAAarmO8aXzsjKsLcRHELIAAACAWo4VBt2LkAUAAADUcomnQ9b3BzLldLL4xfkiZAEAAAC1XKsGYQrytys7v0g/Hs+1uhyvR8gCAAAAajk/h10dGp2el8WQwfNGyAIAAADgGjLI4hfnj5AFAAAAQEmnH0q8+QDLuJ8vQhYAAAAAdTx9J2t7Wpbyi4qtLcbLEbIAAAAAKL5OsC4I8VdBsVM7DmVbXY5XI2QBAAAAkM1mc83L2sK8rPNCyAIAAAAg6dd5WSmpzMs6H4QsAAAAAJKkjvGnl3HnTtZ5IWQBAAAAkPTrMu57j+Uo+1ShtcV4MUIWAAAAAElSvbBANYoKlmFI3x9kyGB1EbIAAAAAuHQsfV4W87KqjZAFAAAAwCUxrmReFisMVh8hCwAAAIBLkutOVoaldXgzQhYAAAAAlw6NImW3SWmZp3Q0+5TV5XglQhYAAAAAl9BAP7WoHyZJ2sK8rGohZAEAAAAoI+n0Uu48L6t6CFkAAAAAyiidl5XCvKxqIWQBAAAAKKP0TtaWA5kyDMPaYrwQIQsAAABAGa1jwhXgZ1fmyULtO5FndTleh5AFAAAAoIwAP7vax0ZIYl5WdRCyAAAAAJTjWvyCFQarjJAFAAAAoJyk+EhJ3MmqDkIWAAAAgHJK72RtPZipwmKntcV4GUIWAAAAgHIS6oYqPMhP+UVO7TycbXU5XoWQBQAAAKAcu91WZil3VB4hCwAAAECFXPOyeChxlRCyAAAAAFQosXSFQRa/qBJCFgAAAIAKdYyPkiTtOpKtvIIia4vxIoQsAAAAABVqEBGkmIggOQ1p68Esq8vxGoQsAAAAAGfEvKyq85qQlZ6erlGjRikiIkJRUVEaO3ascnJyznncunXr1LdvX4WGhioiIkKXXHKJTp48WQMVAwAAAN6PeVlV5zUha9SoUdq2bZuSk5O1fPlyrVmzRrfffvtZj1m3bp0GDx6sgQMHav369dqwYYPGjx8vu91rPjYAAABgqdJ5WYSsyvOzuoDK2L59u1asWKENGzaoa9eukqS5c+fq8ssv15NPPqnY2NgKj5s4caLuvfdeTZ482bWtdevWNVIzAAAA4As6xJUMF0xNP6kTOfmqGxZocUWezytC1rp16xQVFeUKWJLUv39/2e12ffPNN7r66qvLHXP06FF98803GjVqlHr27Km9e/eqTZs2mj59unr16nXGa+Xn5ys/P9/1OiurZIJfYWGhCgsL3fipqq70+lbX4avor7nor7nor7nor7nor/nosbl8vb/BDqlZvRD9eDxP3+07oUtbRdfo9T2pv5WtwWYYhmFyLeftiSee0BtvvKGdO3eW2V6/fn1NmzZNd955Z7ljvv76a/Xo0UN16tTRk08+qY4dO2rBggV64YUXtHXrVrVs2bLCa02dOlXTpk0rt33RokUKCQlxzwcCAAAAvMi/d9u14bhdg+OKNSTe4+ODafLy8nTjjTcqMzNTERERZ9zP0jtZkydP1syZM8+6z/bt26t1bqfTKUn685//rFtuuUWS1KlTJ61cuVKvvfaaZsyYUeFxDz30kCZNmuR6nZWVpfj4eA0cOPCsjawJhYWFSk5O1oABA+Tv729pLb6I/pqL/pqL/pqL/pqL/pqPHpurNvT3xNf7teGjHToZ0kCXX965Rq/tSf0tHeV2LpaGrPvvv19jxow56z7NmjVTTEyMjh49WmZ7UVGR0tPTFRMTU+FxDRs2lCS1a9euzPa2bdtq//79Z7xeYGCgAgPLjzP19/e3/JdaypNq8UX011z011z011z011z013z02Fy+3N9OTepIKnlWlp+fn2w2W43X4An9rez1LQ1Z0dHRio4+95jOHj16KCMjQ5s2bVKXLl0kSatWrZLT6VT37t0rPCYhIUGxsbHlhhju2rVLQ4YMOf/iAQAAgFqibcMI+TtsOpFboAO/nFR8HabRnI1XrGXetm1bDR48WOPGjdP69eu1du1ajR8/XiNHjnStLHjw4EG1adNG69evlyTZbDY98MADmjNnjt555x3t2bNHjzzyiHbs2KGxY8da+XEAAAAArxLk71DbhiVTZ1jK/dy8YnVBSVq4cKHGjx+vfv36yW6369prr9WcOXNc7xcWFmrnzp3Ky8tzbZswYYJOnTqliRMnKj09XUlJSUpOTlbz5s2t+AgAAACA10qMi9SWA5naciBTVyRW/AgllPCakFWnTh0tWrTojO8nJCSoooUSJ0+eXOY5WQAAAACqLikuSv/WfqWkZlhdisfziuGCAAAAAKzVMT5KkvT9gUwVFTutLcbDEbIAAAAAnFOz6DCFBjh0srBYe47lWF2ORyNkAQAAADgnh92mDnGRkqQtqZkWV+PZCFkAAAAAKiXp9JDBFFYYPCtCFgAAAIBKSYqLkiRtZvGLsyJkAQAAAKiU0jtZOw9n61RhsbXFeDBCFgAAAIBKiY0MUr2wQBU5DW1Ly7K6HI9FyAIAAABQKTabTUmnF79gyOCZEbIAAAAAVFrpkMEtLH5xRoQsAAAAAJVWGrI2H2AZ9zMhZAEAAACotNLhgj8dz1VmXqHF1XgmQhYAAACASosKCVCTuiGSpC0HM6wtxkMRsgAAAABUCc/LOjtCFgAAAIAqKZ2XlZLKvKyKELIAAAAAVIlrGfcDGTIMw+JqPA8hCwAAAECVtI+NlMNu07HsfB3OOmV1OR6HkAUAAACgSoIDHGrdIFwS87IqQsgCAAAAUGVJ8aVDBpmX9XuELAAAAABVxgqDZ0bIAgAAAFBlpSsMbjmQKaeTxS9+i5AFAAAAoMpa1g9TkL9dOflF+vF4jtXleBRCFgAAAIAq83PY1aHR6XlZPC+rDEIWAAAAgGpxzcs6kGFpHZ6GkAUAAACgWhJPz8ti8YuyCFkAAAAAqqXj6TtZ2w9lK7+o2NpiPAghCwAAAEC1xNcJ1gUh/ioodmrHoWyry/EYhCwAAAAA1WKz2ZTIvKxyCFkAAAAAqi3JNS+LFQZLEbIAAAAAVFvH+NPLuHMny4WQBQAAAKDaSocL7j2Wo+xThdYW4yEIWQAAAACqrV5YoBpFBcswpO8PMmRQImQBAAAAOE8dmZdVBiELAAAAwHlJKp2XxUOJJRGyAAAAAJyn0nlZW1j8QhIhCwAAAMB56tAoUnablJZ5SkezTlldjuUIWQAAAADOS2ign1rWD5ckbT7AvCxCFgAAAIDzlhhXMi+LIYOELAAAAABukHR6hcEUFr8gZAEAAAA4f78u454hwzCsLcZihCwAAAAA5611TLgC/OzKOlWkn0/kWV2OpQhZAAAAAM6bv8Ou9rERkpiXRcgCAAAA4BZJp5+XVdvnZRGyAAAAALhFUnzJCoObCVkAAAAAcP5K72RtS8tSYbHT2mIsRMgCAAAA4BYJdUMVEeSn/CKndh7OtrocyxCyAAAAALiF3W5T4um7WZtr8eIXhCwAAAAAblM6L2tLaqbFlViHkAUAAADAbZK4k0XIAgAAAOA+SfFRkqRdR7KVV1BkbTEWIWQBAAAAcJsGEUGKiQiS05C2HsyyuhxLELIAAAAAuFVtf14WIQsAAACAW5WuMJhSS+dlEbIAAAAAuFXH0/OythCyAAAAAOD8dYgrGS6Ymn5SJ3LyLa6m5hGyAAAAALhVRJC/mkeHSpK2HKh9z8siZAEAAABwu9r8vCxCFgAAAAC3K31eVm1cYZCQBQAAAMDtXCHrQKYMw7C2mBpGyAIAAADgdm0bhsvfYVN6boEO/HLS6nJqFCELAAAAgNsF+jnUtmGEpNo3L4uQBQAAAMAUrsUvatm8LEIWAAAAAFMknn5e1ubU2rWMOyELAAAAgCk6nl784vuDmSoqdlpbTA0iZAEAAAAwRbPoMIUF+ulkYbH2HMuxupwaQ8gCAAAAYAqH3aYLG51e/KIWzcsiZAEAAAAwzW+fl1VbELIAAAAAmKZjLVxhkJAFAAAAwDSJp+9k7TicrVOFxdYWU0MIWQAAAABMExsZpHphgSp2GtqWlmV1OTWCkAUAAADANDabTR3jS5+XlWFtMTWEkAUAAADAVIml87IOZFhaR03xmpCVnp6uUaNGKSIiQlFRURo7dqxycs6+1v7hw4f1pz/9STExMQoNDVXnzp317rvv1lDFAAAAAKRfVxjcUktWGPSakDVq1Cht27ZNycnJWr58udasWaPbb7/9rMfcfPPN2rlzp5YtW6bvv/9e11xzjUaMGKHvvvuuhqoGAAAAkBRXMlzwp+O5ysgrsLga83lFyNq+fbtWrFihV199Vd27d1evXr00d+5cLV68WGlpaWc87quvvtI999yjbt26qVmzZvr73/+uqKgobdq0qQarBwAAAGq3qJAANakbIql23M3ys7qAyli3bp2ioqLUtWtX17b+/fvLbrfrm2++0dVXX13hcT179tRbb72loUOHKioqSkuWLNGpU6fUp0+fM14rPz9f+fn5rtdZWSUroBQWFqqwsNA9H6iaSq9vdR2+iv6ai/6ai/6ai/6ai/6ajx6bi/5WTofYCO07kafv9qWrR9OoSh/nSf2tbA1eEbIOHz6s+vXrl9nm5+enOnXq6PDhw2c8bsmSJbr++utVt25d+fn5KSQkREuXLlWLFi3OeMyMGTM0bdq0cts//fRThYSEVP9DuFFycrLVJfg0+msu+msu+msu+msu+ms+emwu+nt2/tk2SQ4lf7tLCXk7qny8J/Q3Ly+vUvtZGrImT56smTNnnnWf7du3V/v8jzzyiDIyMvTZZ5+pXr16ev/99zVixAh9+eWX6tChQ4XHPPTQQ5o0aZLrdVZWluLj4zVw4EBFRERUuxZ3KCwsVHJysgYMGCB/f39La/FF9Ndc9Ndc9Ndc9Ndc9Nd89Nhc9LdyYvZnaOkr63WkMEhDhlwqm81WqeM8qb+lo9zOxdKQdf/992vMmDFn3adZs2aKiYnR0aNHy2wvKipSenq6YmJiKjxu7969eu6557R161a1b99ekpSUlKQvv/xSzz//vF566aUKjwsMDFRgYGC57f7+/pb/Ukt5Ui2+iP6ai/6ai/6ai/6ai/6ajx6bi/6eXWJ8HTnsNh3LKdCJk8VqGBlcpeM9ob+Vvb6lISs6OlrR0dHn3K9Hjx7KyMjQpk2b1KVLF0nSqlWr5HQ61b179wqPKb2VZ7eXXdvD4XDI6XSeZ+UAAAAAqiI4wKHWDcL1w6EsbU7NqHLI8iZesbpg27ZtNXjwYI0bN07r16/X2rVrNX78eI0cOVKxsbGSpIMHD6pNmzZav369JKlNmzZq0aKF/vznP2v9+vXau3evZs+ereTkZA0bNszCTwMAAADUTqXPy0pJ9e0VBr0iZEnSwoUL1aZNG/Xr10+XX365evXqpZdfftn1fmFhoXbu3Om6g+Xv76+PP/5Y0dHRuvLKK5WYmKgFCxbojTfe0OWXX27VxwAAAABqrdLnZW1OzbC2EJN5xeqCklSnTh0tWrTojO8nJCTIMIwy21q2bKl3333X7NIAAAAAVELpnazvD2bK6TRkt1du8Qtv4zV3sgAAAAB4t5b1wxTs71BOfpF+PJ5jdTmmIWQBAAAAqBF+DrsubFTyWCRfnpdFyAIAAABQY5LioiRJWw5kWFqHmQhZAAAAAGpM6bwsX178gpAFAAAAoMaU3sn64VCW8ouKrS3GJIQsAAAAADUmvk6wLgjxV2GxoR2Hsq0uxxSELAAAAAA1xmaz/Tpk0EfnZRGyAAAAANSoxNNDBlN8dF4WIQsAAABAjeoYHylJ2nLAN5dxJ2QBAAAAqFGld7L2HstR1qlCa4sxASELAAAAQI2qFxaoRlHBMgxpqw/ezSJkAQAAAKhxHV2LXxCyAAAAAOC8JZ2el+WLDyUmZAEAAACocaXzsnxxGXdCFgAAAIAa16FRpOw26VDmKR3NOmV1OW5FyAIAAABQ40ID/dSyfrgk35uXRcgCAAAAYAlfnZdFyAIAAABgCV+dl0XIAgAAAGAJ1zLuqRkyDMPaYtyIkAUAAADAEq1jwhXgZ1fWqSL9fCLP6nLchpAFAAAAwBL+Drvax0ZI8q15WYQsAAAAAJZJ8sF5WYQsAAAAAJb57bwsX+FndQG+ori4WIWFhaZeo7CwUH5+fjp16pSKi4tNvVZt4+/vb3UJAAAAtVJiXMky7tvSslRY7JS/w/vvAxGyzpNhGDp8+LAyMjJq5FoxMTFKTU2VzWYz/Xq1TXh4uNUlAAAA1DoJdUMVEeSnrFNF2nk4Wxc2irS6pPNGyDpPpQGrfv36CgkJMTX8OJ1O5eTkKCwsTHa79yd8T2EYhvLy8nTkyBGCFgAAQA2z221Kio/Sl7uPa/OBDEJWbVdcXOwKWHXr1jX9ek6nUwUFBQoKCiJkuVlwcLCcTqdyc3NVXFzM8EEAAIAalBgXWRKyUjM0qnsTq8s5b/yf+nkonYMVEhJicSVwh5CQENntdhUVFVldCgAAQK1SusLglgOZ1hbiJoQsN2B+lG8o/T360tPGAQAAvEHpCoO7jmQrN9/7/8KbkAUAAADAUvUjghQTESSnIW096P13swhZAAAAACyXFF+y4IUvDBkkZFno6eRdmrNyd4XvzVm5W08n7zLt2mPGjJHNZiv3s2fPHtOuaab58+crKirK6jIAAABQTUmnhwymHMiwtA53IGRZyGG36akKgtaclbv1VPIuOezmzvUaPHiwDh06VOanadOmVT5PQUGBCdUBAACgNild/GJzaoaldbgDIcuNDMNQXkFRpX9u691U9/RtoaeSd2n2pzuVV1Ck2Z/u1FPJu3RP3xa6rXfTcsecLCiu8FzVWawhMDBQMTExZX4cDoe++OILdevWTYGBgWrYsKEmT55cZsW9Pn36aPz48ZowYYLq1aunQYMGSZK2bt2qIUOGKCwsTA0aNNCf/vQnHT9+3HWc0+nUrFmz1KJFCwUGBqpx48aaPn266/0HH3xQrVq1UkhIiJo1a6ZHHnnEtYKjJG3evFmXXXaZwsPDFRERoS5dumjjxo1avXq1brnlFmVmZrruyE2dOlWS9MILL6hly5YKCgpSgwYNdN1111W5TwAAADBfh7iS4YIHfjmpEzn5FldzfnhOlhudLCxWuyn/rdaxc1ft0dxVe874+lx+eGyQQgLO/9d58OBBXX755RozZowWLFigHTt2aNy4cQoKCnIFF0l64403dOedd2rt2rWSpIyMDPXt21e33Xabnn76aZ08eVIPPvigRowYoVWrVkmSHnroIb3yyit6+umn1atXLx06dEg7duxwnTM8PFzz589XbGysvv/+e40bN07h4eH661//KkkaNWqUOnXqpBdffFEOh0MpKSny9/dXz5499cwzz2jKlCnauXOnJCksLEwbN27UvffeqzfffFM9e/ZUenq6vvzyy/PuEQAAANwvIshfzaNDtfdYrrYcyNRlbepbXVK1EbJqseXLlyssLMz1esiQIWrVqpXi4+P13HPPyWazqU2bNkpLS9ODDz6oKVOmuB6C3LJlS82aNct17OOPP65OnTrpiSeecG177bXXFB8fr127dqlhw4Z69tln9dxzz2n06NGSpObNm6tXr16u/f/+97+7/j0hIUF/+ctftHjxYlfI2r9/vx544AG1adPGVUOpyMhI2Ww2xcTEuLbt379foaGhuuKKKxQeHq4mTZqoU6dObukdAAAA3C8pLkp7j+UqJTWDkIUSwf4O/fDYoCof9+LqvZq7ao/8HTYVFhu6p28L3dmnebn9nE6nsrOyFR4R7go7v712VV122WV68cUXXa9DQ0N19913q0ePHmWe/XXxxRcrJydHBw4cUOPGjSVJXbp0KXOuzZs36/PPPy8T2krt3btXGRkZys/PV79+/c5Yz1tvvaU5c+Zo7969ysnJUVFRkSIiIlzvT5o0SbfddpvefPNN9e/fX8OHD1fz5uX7VGrAgAFq0qSJmjVrpsGDB2vw4MG6+uqreXg0AACAh0qKj9J73x3UZi9f/II5WW5ks9kUEuBXpZ9Xv/xJc1ft0aQBrbR7+uWaNKCV5q7ao1e//KnC/YMDHBVur84DkUNDQ9WiRQvXT8OGDat07G/l5OToyiuvVEpKSpmf3bt365JLLlFwcPBZz7du3TqNGjVKl19+uZYvX67vvvtODz/8cJlFNaZOnapt27Zp6NChWrVqldq1a6elS5ee8Zzh4eH69ttv9Z///EcNGzbUlClTlJSUpIyMjEp/TgAAANSc0hUGtxzIrNaaA56CkGWh0lUEJw1opXv7lQx9u7dfS00a0KrCVQdrQtu2bbVu3boyX+q1a9cqPDxccXFxZzyuc+fO2rZtmxISEsoEtxYtWig0NFQtW7ZUcHCwVq5cWeHxX331lZo0aaKHH35YXbt2VcuWLbVv375y+7Vq1UoTJ07Up59+qmuuuUavv/66JCkgIEDFxcXl9vfz81P//v01a9YsbdmyRT///LNrjhgAAAA8S9uG4fJ32JSeW6ADv5y0upxqI2RZqNhplAlYpUqDVrGz5tP7XXfdpdTUVN1zzz3asWOHPvjgAz366KOaNGlSuSGKv3X33XcrPT1dN9xwgzZs2KC9e/fqv//9r2655RYVFxcrKChIDz74oP76179qwYIF2rt3r77++mvNmzdPUsn8qv3792vx4sXau3ev5syZU+Yu1cmTJzV+/HitXr1a+/bt09q1a7Vhwwa1bdtWUskcrpycHK1cuVLHjx9XXl6eli9frjlz5iglJUX79u3TggUL5HQ61bp1a3ObCAAAgGoJ9HOobcOS6SIpXryUO3OyLDRxQKszvvf74FVTGjVqpI8//lgPPPCAkpKSVKdOHY0dO7bMohQViY2N1dq1a/Xggw9q4MCBys/PV5MmTTR48GBXOHvkkUfk5+enKVOmKC0tTQ0bNtQdd9whSfrjH/+oiRMnavz48crPz9fQoUP1yCOPuFY0dDgcOnHihG6++WYdOXJE9erV0zXXXKNp06ZJknr27Kk77rhD119/vU6cOKFHH31U/fv313vvvaepU6fq1KlTatmypf7zn/+offv25jUQAAAA5yUpLkpbDmRqy4EMXZkUa3U51ULIqqXmz59/xvcuvfRSrV+//ozvr169usLtLVu21HvvvXfG4+x2ux5++GE9/PDDFb4/a9asMisWStKECRMklQwH/M9//nPGc0vSiy++WGYhj7PVCgAAAM+UFB+lN7/ep82pmVaXUm0MFwQAAADgMZJOP5T4+4OZKip2WlxN9RCyAAAAAHiMZtFhCgv008nCYu05lmN1OdVCyAIAAADgMRx2mzo0KrmbtdlLF78gZAEAAADwKInxJSErxUvnZRGyAAAAAHiUjnFRkqQtBzIsraO6CFkAAAAAPEpSfJQkacfhbJ0qLLa2mGogZAEAAADwKA0jg1QvLFDFTkM/HMq2upwqI2QBAAAA8Cg2m00dT8/L2nLQ++ZlEbIAAAAAeJwk17wsQhaqw1ks/fSl9P07Jf90et+4U3ex2Wx6//33rS4DAAAAFks8PS9ry4EsawupBkKW1X5YJj1zofTGFdK7Y0v++cyFJdtNtm7dOjkcDg0dOrRKxyUkJOiZZ54xpygAAADUek8n79I3P56QJO1Lz1Nu4a/vzVm5W08n77KossohZFnph2XSkpulrLSy27MOlWw3OWjNmzdP99xzj9asWaO0tLRzHwAAAADUAIfdphdW71VUsL8kKTXXJqkkYD2VvEsOu83K8s6JkOVOhiEV5Fbu51SW9MlfJRkVnajkHyseLNnvt8cV5lV8PqOi85xZTk6O3nrrLd15550aOnSo5s+fX+b9Dz/8UBdddJGCgoJUr149XX311ZKkPn36aN++fZo4caJsNptstpIv+NSpU9WxY8cy53jmmWeUkJDger1hwwYNGDBA9erVU2RkpC699FJ9++23Z6yxoKBA48ePV8OGDRUUFKQmTZpoxowZVfqcAAAA8D739mupSQNaKeNkyS2sfTnSc5/v1VPJuzRpQCvd26+lxRWenZ/VBfiUwjzpiVg3ncwoucP1j3jXFrukqDPt/rc0KSC00mdfsmSJ2rRpo9atW+umm27ShAkT9NBDD8lms+mjjz7S1VdfrYcfflgLFixQQUGBPv74Y0nSe++9p6SkJN1+++0aN25clT5Rdna2Ro8erblz58owDM2ePVuXX365du/erfDw8HL7z5kzR8uWLdOSJUvUuHFjpaamKjU1tUrXBAAAgHe6t19Lbdr3i77YdUyfpNr1ceperwhYEiGr1po3b55uuukmSdLgwYOVmZmpL774Qn369NH06dM1cuRITZs2zbV/UlKSJKlOnTpyOBwKDw9XTExMla7Zt2/fMq9ffvllRUVF6YsvvtAVV1xRbv/9+/erZcuW6tWrl2w2m5o0aVLVjwkAAAAvdm+/llqz65gM2eTvsHlFwJIIWe7lH1JyR6ky9n0lLbzu3PuNekdq0lOS5HQ6lZWdrYjwcNntvxvp6R9S6TJ37typ9evXa+nSpZIkPz8/XX/99Zo3b5769OmjlJSUKt+lqowjR47o73//u1avXq2jR4+quLhYeXl52r9/f4X7jxkzRgMGDFDr1q01ePBgXXHFFRo4cKDb6wIAAIBnWrvnuAxJDpuhwuKSOVneELQIWe5ks1V+yF7zvlJEbMkiFxXOy7KVvN+8r2R3lGxyOiX/4pJr/D5kVcG8efNUVFSk2NhfhzYahqHAwEA999xzCg4OrvI57Xa7jN/NCyssLCzzevTo0Tpx4oSeffZZNWnSRIGBgerRo4cKCgoqPGfnzp31008/6ZNPPtFnn32mESNGqH///nrnnXeqXB8AAAC8S+kiF/f1ba5mJ3fqx+DWeur0qoKeHrRY+MIqdoc0eObpF79fHeX068H/+DVguUlRUZEWLFig2bNnKyUlxfWzefNmxcbG6j//+Y8SExO1cuXKM54jICBAxcVln+UVHR2tw4cPlwlaKSkpZfZZu3at7r33Xl1++eVq3769AgMDdfz48bPWGxERoeuvv16vvPKK3nrrLb377rtKT0+v+gcHAACA1ygNWJMGtNL4y5pLksZf1lyTBrTSU8m7NGflbosrPDvuZFmp3R+lEQtKVhH87TLuEbElAavdH91+yeXLl+uXX37R2LFjFRkZWea9a6+9VvPmzdM///lP9evXT82bN9fIkSNVVFSkjz/+WA8++KCkkudkrVmzRiNHjlRgYKDq1aunPn366NixY5o1a5auu+46rVixQp988okiIiJc52/ZsqXefPNNde3aVVlZWXrggQfOetfsqaeeUsOGDdWpUyfZ7Xa9/fbbiomJUVRUlNv7AgAAAM9R7DRci1z8dnRU6R2sYmfVVtauadzJslq7P0oTtkqjl0vXziv554TvTQlYUslQwf79+5cLWFJJyNq4caPq1Kmjt99+W8uWLVPHjh3Vt29frV+/3rXfY489pp9//lnNmzdXdHS0JKlt27Z64YUX9PzzzyspKUnr16/XX/7yl3LX/uWXX9S5c2f96U9/0r333qv69eufsdbw8HDNmjVLXbt21UUXXaSff/5ZH3/8cfn5aAAAAPApE8+yiuC9/Vpq4oBWNVxR1XAnyxPYHVLT3jVyqQ8//PCM73Xr1s013C8xMVHXXHNNhfv94Q9/0ObNm8ttv+OOO3THHXeU2fa3v/3N9e+dOnXShg0byrx/3XVlF//47XDDcePGmbIABwAAAGAmbgkAAAAAgBsRsgAAAADAjQhZAAAAAOBGhCwAAAAAcCNClhv8/iG88E6lv0eb7ffPLQMAAAAqj5B1Hvz9/SVJeXl5FlcCd8jLy5PT6ZSfH4tuAgAAoPr4v8nz4HA4FBUVpaNHj0qSQkJCTL0L4nQ6VVBQoFOnTvGsKDcyDEN5eXk6duyYsrOz5XA4rC4JAAAAXoyQdZ5iYmIkyRW0zGQYhk6ePKng4GCGtJkgIiJCu3fvtroMAAAAeDmvCVnTp0/XRx99pJSUFAUEBCgjI+OcxxiGoUcffVSvvPKKMjIydPHFF+vFF19Uy5YVPz26Omw2mxo2bKj69eursLDQbeetSGFhodasWaNLLrnENVQR7uHv7y+n02l1GQAAAPABXhOyCgoKNHz4cPXo0UPz5s2r1DGzZs3SnDlz9MYbb6hp06Z65JFHNGjQIP3www8KCgpya30Oh8P0YWYOh0NFRUUKCgoiZJmAkAUAAAB38JqQNW3aNEnS/PnzK7W/YRh65pln9Pe//11XXXWVJGnBggVq0KCB3n//fY0cOdKsUgEAAADUYl4Tsqrqp59+0uHDh9W/f3/XtsjISHXv3l3r1q07Y8jKz89Xfn6+63VWVpakkqF6Zg8HPJfS61tdh6+iv+aiv+aiv+aiv+aiv+ajx+aiv+bypP5Wtgab4WUPeZo/f74mTJhwzjlZX331lS6++GKlpaWpYcOGru0jRoyQzWbTW2+9VeFxU6dOdd01+61FixYpJCTkvGoHAAAA4L3y8vJ04403KjMzUxEREWfcz9I7WZMnT9bMmTPPus/27dvVpk2bGqpIeuihhzRp0iTX68zMTDVu3Fg9evRQeHh4jdVRkcLCQn3++ee67LLLmJNlAvprLvprLvprLvprLvprPnpsLvprLk/qb3Z2tqSSqUlnY2nIuv/++zVmzJiz7tOsWbNqnbt0afUjR46UuZN15MgRdezY8YzHBQYGKjAw0PW6dLhg06ZNq1UHAAAAAN+SnZ2tyMjIM75vaciKjo5WdHS0Kedu2rSpYmJitHLlSleoysrK0jfffKM777yz0ueJjY1VamqqwsPDLX82VVZWluLj45WamnrW25OoHvprLvprLvprLvprLvprPnpsLvprLk/qr2EYys7OVmxs7Fn385qFL/bv36/09HTt379fxcXFSklJkSS1aNFCYWFhkqQ2bdpoxowZuvrqq2Wz2TRhwgQ9/vjjatmypWsJ99jYWA0bNqzS17Xb7YqLizPhE1VfRESE5V8wX0Z/zUV/zUV/zUV/zUV/zUePzUV/zeUp/T3bHaxSXhOypkyZojfeeMP1ulOnTpKkzz//XH369JEk7dy5U5mZma59/vrXvyo3N1e33367MjIy1KtXL61YscLtz8gCAAAAgFJeE7Lmz59/zmdk/X4Cms1m02OPPabHHnvMxMoAAAAA4Fd2qwtA5QUGBurRRx8tszAH3If+mov+mov+mov+mov+mo8em4v+mssb++t1z8kCAAAAAE/GnSwAAAAAcCNCFgAAAAC4ESELAAAAANyIkAUAAAAAbkTI8iLPP/+8EhISFBQUpO7du2v9+vVWl+QT1qxZoyuvvFKxsbGy2Wx6//33rS7Jp8yYMUMXXXSRwsPDVb9+fQ0bNkw7d+60uiyf8eKLLyoxMdH1gMYePXrok08+sbosn/WPf/zD9bB7nL+pU6fKZrOV+WnTpo3VZfmUgwcP6qabblLdunUVHBysDh06aOPGjVaX5RMSEhLKfX9tNpvuvvtuq0vzCcXFxXrkkUfUtGlTBQcHq3nz5vq///u/co9s8lSELC/x1ltvadKkSXr00Uf17bffKikpSYMGDdLRo0etLs3r5ebmKikpSc8//7zVpfikL774Qnfffbe+/vprJScnq7CwUAMHDlRubq7VpfmEuLg4/eMf/9CmTZu0ceNG9e3bV1dddZW2bdtmdWk+Z8OGDfrXv/6lxMREq0vxKe3bt9ehQ4dcP//73/+sLsln/PLLL7r44ovl7++vTz75RD/88INmz56tCy64wOrSfMKGDRvKfHeTk5MlScOHD7e4Mt8wc+ZMvfjii3ruuee0fft2zZw5U7NmzdLcuXOtLq1SWMLdS3Tv3l0XXXSRnnvuOUmS0+lUfHy87rnnHk2ePNni6nyHzWbT0qVLNWzYMKtL8VnHjh1T/fr19cUXX+iSSy6xuhyfVKdOHf3zn//U2LFjrS7FZ+Tk5Khz58564YUX9Pjjj6tjx4565plnrC7L602dOlXvv/++UlJSrC7FJ02ePFlr167Vl19+aXUptcKECRO0fPly7d69WzabzepyvN4VV1yhBg0aaN68ea5t1157rYKDg/Xvf//bwsoqhztZXqCgoECbNm1S//79Xdvsdrv69++vdevWWVgZUHWZmZmSSoIA3Ku4uFiLFy9Wbm6uevToYXU5PuXuu+/W0KFDy/w5DPfYvXu3YmNj1axZM40aNUr79++3uiSfsWzZMnXt2lXDhw9X/fr11alTJ73yyitWl+WTCgoK9O9//1u33norActNevbsqZUrV2rXrl2SpM2bN+t///ufhgwZYnFlleNndQE4t+PHj6u4uFgNGjQos71BgwbasWOHRVUBVed0OjVhwgRdfPHFuvDCC60ux2d8//336tGjh06dOqWwsDAtXbpU7dq1s7osn7F48WJ9++232rBhg9Wl+Jzu3btr/vz5at26tQ4dOqRp06apd+/e2rp1q8LDw60uz+v9+OOPevHFFzVp0iT97W9/04YNG3TvvfcqICBAo0ePtro8n/L+++8rIyNDY8aMsboUnzF58mRlZWWpTZs2cjgcKi4u1vTp0zVq1CirS6sUQhaAGnP33Xdr69atzLlws9atWyslJUWZmZl65513NHr0aH3xxRcELTdITU3Vfffdp+TkZAUFBVldjs/57d9IJyYmqnv37mrSpImWLFnCcFc3cDqd6tq1q5544glJUqdOnbR161a99NJLhCw3mzdvnoYMGaLY2FirS/EZS5Ys0cKFC7Vo0SK1b99eKSkpmjBhgmJjY73i+0vI8gL16tWTw+HQkSNHymw/cuSIYmJiLKoKqJrx48dr+fLlWrNmjeLi4qwux6cEBASoRYsWkqQuXbpow4YNevbZZ/Wvf/3L4sq836ZNm3T06FF17tzZta24uFhr1qzRc889p/z8fDkcDgsr9C1RUVFq1aqV9uzZY3UpPqFhw4bl/rKlbdu2evfddy2qyDft27dPn332md577z2rS/EpDzzwgCZPnqyRI0dKkjp06KB9+/ZpxowZXhGymJPlBQICAtSlSxetXLnStc3pdGrlypXMu4DHMwxD48eP19KlS7Vq1So1bdrU6pJ8ntPpVH5+vtVl+IR+/frp+++/V0pKiuuna9euGjVqlFJSUghYbpaTk6O9e/eqYcOGVpfiEy6++OJyj8zYtWuXmjRpYlFFvun1119X/fr1NXToUKtL8Sl5eXmy28tGFYfDIafTaVFFVcOdLC8xadIkjR49Wl27dlW3bt30zDPPKDc3V7fccovVpXm9nJycMn9r+tNPPyklJUV16tRR48aNLazMN9x9991atGiRPvjgA4WHh+vw4cOSpMjISAUHB1tcnfd76KGHNGTIEDVu3FjZ2dlatGiRVq9erf/+979Wl+YTwsPDy80fDA0NVd26dZlX6AZ/+ctfdOWVV6pJkyZKS0vTo48+KofDoRtuuMHq0nzCxIkT1bNnTz3xxBMaMWKE1q9fr5dfflkvv/yy1aX5DKfTqddff12jR4+Wnx//W+1OV155paZPn67GjRurffv2+u677/TUU0/p1ltvtbq0yjHgNebOnWs0btzYCAgIMLp162Z8/fXXVpfkEz7//HNDUrmf0aNHW12aT6iot5KM119/3erSfMKtt95qNGnSxAgICDCio6ONfv36GZ9++qnVZfm0Sy+91LjvvvusLsMnXH/99UbDhg2NgIAAo1GjRsb1119v7Nmzx+qyfMqHH35oXHjhhUZgYKDRpk0b4+WXX7a6JJ/y3//+15Bk7Ny50+pSfE5WVpZx3333GY0bNzaCgoKMZs2aGQ8//LCRn59vdWmVwnOyAAAAAMCNmJMFAAAAAG5EyAIAAAAANyJkAQAAAIAbEbIAAAAAwI0IWQAAAADgRoQsAAAAAHAjQhYAAAAAuBEhCwAAAADciJAFAAAAAG5EyAIA1BpjxoyRzWaTzWaTv7+/GjRooAEDBui1116T0+ms9Hnmz5+vqKgo8woFAHg1QhYAoFYZPHiwDh06pJ9//lmffPKJLrvsMt1333264oorVFRUZHV5AAAfQMgCANQqgYGBiomJUaNGjdS5c2f97W9/0wcffKBPPvlE8+fPlyQ99dRT6tChg0JDQxUfH6+77rpLOTk5kqTVq1frlltuUWZmpuuu2NSpUyVJ+fn5+stf/qJGjRopNDRU3bt31+rVq635oAAAyxCyAAC1Xt++fZWUlKT33ntPkmS32zVnzhxt27ZNb7zxhlatWqW//vWvkqSePXvqmWeeUUREhA4dOqRDhw7pL3/5iyRp/PjxWrdunRYvXqwtW7Zo+PDhGjx4sHbv3m3ZZwMA1DybYRiG1UUAAFATxowZo4yMDL3//vvl3hs5cqS2bNmiH374odx777zzju644w4dP35cUsmcrAkTJigjI8O1z/79+9WsWTPt379fsbGxru39+/dXt27d9MQTT7j98wAAPJOf1QUAAOAJDMOQzWaTJH322WeaMWOGduzYoaysLBUVFenUqVPKy8tTSEhIhcd///33Ki4uVqtWrcpsz8/PV926dU2vHwDgOQhZAABI2r59u5o2baqff/5ZV1xxhe68805Nnz5dderU0f/+9z+NHTtWBQUFZwxZOTk5cjgc2rRpkxwOR5n3wsLCauIjAAA8BCELAFDrrVq1St9//70mTpyoTZs2yel0avbs2bLbS6YuL1mypMz+AQEBKi4uLrOtU6dOKi4u1tGjR9W7d+8aqx0A4HkIWQCAWiU/P1+HDx9WcXGxjhw5ohUrVmjGjBm64oordPPNN2vr1q0qLCzU3LlzdeWVV2rt2rV66aWXypwjISFBOTk5WrlypZKSkhQSEqJWrVpp1KhRuvnmmzV79mx16tRJx44d08qVK5WYmKihQ4da9IkBADWN1QUBALXKihUr1LBhQyUkJGjw4MH6/PPPNWfOHH3wwQdyOBxKSkrSU089pZkzZ+rCCy/UwoULNWPGjDLn6Nmzp+644w5df/31io6O1qxZsyRJr7/+um6++Wbdf//9at26tYYNG6YNGzaocePGVnxUAIBFWF0QAAAAANyIO1kAAAAA4EaELAAAAABwI0IWAAAAALgRIQsAAAAA3IiQBQAAAABuRMgCAAAAADciZAEAAACAGxGyAAAAAMCNCFkAAAAA4EaELAAAAABwI0IWAAAAALjR/wN8105nM3bqEQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(batch_valid-cnt_thrown_idx):\n", + " print ('\\n') \n", + " print (i)\n", + " X_resh = X_valid[i:i+1, :, 6].flatten()\n", + " # print (X_resh)\n", + " # print ('\\n')\n", + " y_resh = y_valid[i:i+1].flatten()\n", + " # print (y_resh)\n", + " y_est_resh = y_hat[i:i+1].flatten()\n", + " # print (y_est_resh)\n", + " # print ('\\n')\n", + " actual = np.concatenate((X_resh, y_resh)) * 100000.00\n", + " # print (actual)\n", + " # print ('\\n')\n", + " estimate = np.concatenate((X_resh, y_est_resh)) * 100000.00\n", + " # print (estimate)\n", + "\n", + " dates = list(range(sl+frwd))\n", + " \n", + " # Create a pandas DataFrame\n", + " data = pd.DataFrame({'Date': dates, 'Actuals': actual, 'Forecasts': estimate})\n", + " \n", + " # Set the 'Date' column as the index\n", + " data.set_index('Date', inplace=True)\n", + " \n", + " # Create a figure and axis object using object-oriented style\n", + " fig, ax = plt.subplots(figsize = (10, 6))\n", + " \n", + " # Plot actuals vs. forecasts\n", + " ax.plot(data.index, data['Forecasts'], label = 'Forecasts', marker = 'x')\n", + " ax.plot(data.index, data['Actuals'], label = 'Actuals', marker = 'o')\n", + " \n", + " # Set labels and title\n", + " ax.set_xlabel('Date')\n", + " ax.set_ylabel('Value')\n", + " ax.set_title('Actuals vs. Forecasts')\n", + "\n", + " ax.legend() # Add legend\n", + "\n", + " ax.grid(True) # Add grid\n", + " \n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4acc8461-7c33-4b38-91c7-422f89d7d5b0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "75c0ee52-c740-434a-92bd-4f46f9ce290a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 255, + "id": "7a9e8c46-d24e-4ce9-b20a-232b4a86dab6", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " date close_xrp volume_xrp vwap_xrp close_eth volume_eth vwap_eth \\\n", + "0 1-0-0 0.5173 28809.165339 0.517217 0.376204 37.497964 0.376108 \n", + "\n", + " close_ltc volume_ltc vwap_ltc close_btc volume_btc vwap_btc Selected \n", + "0 0.8317 110.056253 0.831662 0.67506 2.045049 0.674969 0 \n" + ] + } + ], + "source": [ + "print (sample_test.head(1))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14eb03d2-1dbe-4834-908f-5a520a4a28c5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "598f83ca-cbb1-44f8-a1c6-7ce84f2243d7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "39259ac7-422b-48dc-aecd-2c9799ae3066", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'sample_test' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 5\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# variables are close and volume\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# ==============================\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# Test Sample --- 06.14.2024\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# ==============================\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m sample_size \u001b[38;5;241m=\u001b[39m \u001b[43msample_test\u001b[49m\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m (\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msample_size: \u001b[39m\u001b[38;5;124m'\u001b[39m, sample_size)\n\u001b[1;32m 8\u001b[0m sl \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m16\u001b[39m \u001b[38;5;66;03m# <--- sequence length\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'sample_test' is not defined" + ] + } + ], + "source": [ + "# variables are volume and volume\n", + "# ==============================\n", + "# Test Sample --- 06.14.2024\n", + "# ==============================\n", + "sample_size = sample_test.shape[0]\n", + "print ('sample_size: ', sample_size)\n", + "\n", + "sl = 16 # <--- sequence length\n", + "batch = 10 # <--- batch size\n", + "n_features = 8 # <---- no. of variables\n", + "n_out = 1 # <----- no. of predicted variables\n", + "frwd = 1 # <--- how many to predict\n", + "\n", + "\n", + "# Trimming Indices !!!\n", + "# Marking selected rows\n", + "sample_test['Selected'] = 0\n", + "\n", + "# Selecting m random rows without replacement\n", + "np.random.seed(125)\n", + "selected_indices = np.random.choice(sample_test.index, size = batch, replace = False)\n", + "\n", + "sample_test.loc[selected_indices, 'Selected'] = 1 # print (sample_test[sample_test['Selected'] == 1])\n", + "chosen_idx1 = sample_test[sample_test['Selected'] == 1].index\n", + "chosen_idx2 = chosen_idx1[chosen_idx1 > sl]\n", + "\n", + "thrown_idx1 = chosen_idx1[chosen_idx1 <= sl]\n", + "cnt_thrown_idx1 = len(thrown_idx1)\n", + "\n", + "chosen_idx3 = chosen_idx2[chosen_idx2 < (sample_size - frwd)]\n", + "\n", + "thrown_idx2 = chosen_idx2[chosen_idx2 >= (sample_size - frwd)]\n", + "cnt_thrown_idx2 = len(thrown_idx2)\n", + "\n", + "cnt_thrown_idx = cnt_thrown_idx1 + cnt_thrown_idx2\n", + "\n", + "print (selected_indices)\n", + "\n", + "# all_ts_xrp = np.empty((1, )) # final input/output\n", + "# all_ts_eth = np.empty((1, )) # final input/output\n", + "# all_ts_ltc = np.empty((1, )) # final input/output\n", + "# all_ts_btc = np.empty((1, )) # final input/output\n", + "\n", + "\n", + "all_ts_close_xrp = np.empty((1, )) # final input/output\n", + "all_ts_close_eth = np.empty((1, )) # final input/output\n", + "all_ts_close_ltc = np.empty((1, )) # final input/output\n", + "all_ts_close_btc = np.empty((1, )) # final input/output\n", + "\n", + "all_ts_volume_xrp = np.empty((1, )) # final input/output\n", + "all_ts_volume_eth = np.empty((1, )) # final input/output\n", + "all_ts_volume_ltc = np.empty((1, )) # final input/output\n", + "all_ts_volume_btc = np.empty((1, )) # final input/output\n", + "\n", + "stdev_xrp = np.empty((1, )) # final input/output\n", + "stdev_eth = np.empty((1, )) # final input/output\n", + "stdev_ltc = np.empty((1, )) # final input/output\n", + "stdev_btc = np.empty((1, )) # final input/output\n", + "\n", + "\n", + "aft_ts_xrp = np.empty((1))\n", + "aft_ts_eth = np.empty((1))\n", + "aft_ts_ltc = np.empty((1))\n", + "aft_ts_btc = np.empty((1))\n", + "\n", + "for idx in chosen_idx3:\n", + " selected_rows_before = sample_test.iloc[max(0, idx-sl): idx]\n", + " selected_rows_after = sample_test.iloc[max(0, idx): idx+frwd]\n", + "\n", + " # xrp\n", + " sr_before_close_xrp = np.array(selected_rows_before['close_xrp'])\n", + " sr_after_close_xrp = np.array(selected_rows_after['close_xrp']) \n", + " # print (sr_before_close_xrp)\n", + " sr_before_volume_xrp = np.array(selected_rows_before['volume_xrp'])\n", + " sr_after_volume_xrp = np.array(selected_rows_after['volume_xrp']) \n", + " # print (sr_before_volume_xrp) \n", + " # Compute standard deviation\n", + " std_dev_xrp = np.std(sr_before_close_xrp)\n", + " std_dev_xrp_arr = np.repeat(std_dev_xrp, sl)\n", + " # print(std_dev_xrp_arr)\n", + " \n", + "# eth\n", + " sr_before_close_eth = np.array(selected_rows_before['close_eth'])\n", + " sr_after_close_eth = np.array(selected_rows_after['close_eth'])\n", + " sr_before_volume_eth = np.array(selected_rows_before['volume_eth'])\n", + " sr_after_volume_eth = np.array(selected_rows_after['volume_eth'])\n", + " # Compute standard deviation\n", + " std_dev_eth = np.std(sr_before_close_eth)\n", + " std_dev_eth_arr = np.repeat(std_dev_eth, sl)\n", + " # print(std_dev_eth_arr)\n", + " \n", + "# ltc\n", + " sr_before_close_ltc = np.array(selected_rows_before['close_ltc'])\n", + " sr_after_close_ltc = np.array(selected_rows_after['close_ltc'])\n", + " sr_before_volume_ltc = np.array(selected_rows_before['volume_ltc'])\n", + " sr_after_volume_ltc = np.array(selected_rows_after['volume_ltc'])\n", + "# Compute standard deviation\n", + " std_dev_ltc = np.std(sr_before_close_ltc)\n", + " std_dev_ltc_arr = np.repeat(std_dev_ltc, sl)\n", + " # print(std_dev_ltc_arr)\n", + "\n", + "# btc\n", + " sr_before_close_btc = np.array(selected_rows_before['close_btc'])\n", + " sr_after_close_btc = np.array(selected_rows_after['close_btc'])\n", + " sr_before_volume_btc = np.array(selected_rows_before['volume_btc'])\n", + " sr_after_volume_btc = np.array(selected_rows_after['volume_btc'])\n", + " # Compute standard deviation\n", + " std_dev_btc = np.std(sr_before_close_btc)\n", + " std_dev_btc_arr = np.repeat(std_dev_btc, sl)\n", + " # print(std_dev_btc_arr)\n", + "\n", + "# xrp\n", + " all_ts_close_xrp = np.concatenate((all_ts_close_xrp, sr_before_close_xrp))\n", + " all_ts_volume_xrp = np.concatenate((all_ts_volume_xrp, sr_before_volume_xrp))\n", + " stdev_xrp = np.concatenate((stdev_xrp, std_dev_xrp_arr))\n", + "# eth\n", + " all_ts_close_eth = np.concatenate((all_ts_close_eth, sr_before_close_eth))\n", + " all_ts_volume_eth = np.concatenate((all_ts_volume_eth, sr_before_volume_eth))\n", + " stdev_eth = np.concatenate((stdev_eth, std_dev_eth_arr))\n", + "# ltc\n", + " all_ts_close_ltc = np.concatenate((all_ts_close_ltc, sr_before_close_ltc))\n", + " all_ts_volume_ltc = np.concatenate((all_ts_volume_ltc, sr_before_volume_tc))\n", + " stdev_ltc = np.concatenate((stdev_ltc, std_dev_ltc_arr))\n", + "# btc\n", + " all_ts_close_btc = np.concatenate((all_ts_close_btc, sr_before_close_btc))\n", + " all_ts_volume_btc = np.concatenate((all_ts_volume_btc, sr_before_volume_btc))\n", + " stdev_btc = np.concatenate((stdev_btc, std_dev_btc_arr))\n", + "\n", + "\n", + " aft_ts_close_xrp = np.concatenate((aft_ts_close_xrp, sr_after_close_xrp))\n", + " aft_ts_close_eth = np.concatenate((aft_ts_close_eth, sr_after_close_eth))\n", + " aft_ts_close_ltc = np.concatenate((aft_ts_close_ltc, sr_after_close_ltc))\n", + " aft_ts_close_btc = np.concatenate((aft_ts_close_btc, sr_after_close_btc))\n", + "\n", + "\n", + "X_XRP_close = all_ts_close_xrp[1:]\n", + "X_XRP_volume = all_ts_volume_xrp[1:]\n", + "X_XRP_stdev = stdev_xrp[1:]\n", + "\n", + "\n", + "X_ETH_close = all_ts_close_eth[1:]\n", + "X_ETH_volume = all_ts_volume_eth[1:]\n", + "X_ETH_stdev = stdev_eth[1:]\n", + "\n", + "X_LTC_close = all_ts_close_ltc[1:]\n", + "X_LTC_volume = all_ts_volume_ltc[1:]\n", + "X_LTC_stdev = stdev_ltc[1:]\n", + "\n", + "X_BTC_close = all_ts_close_btc[1:]\n", + "X_BTC_volume = all_ts_volume_btc[1:]\n", + "X_BTC_stdev = stdev_btc[1:]\n", + "\n", + "X0 = np.column_stack((X_XRP_close, X_XRP_volume, \n", + " X_ETH_close, X_ETH_volume, \n", + " X_LTC_close, X_LTC_volume, \n", + " X_BTC_close, X_BTC_volume))\n", + "print (X0)\n", + "\n", + "# ======== Model Input =========\n", + "X = X0.reshape(batch-cnt_thrown_idx, sl, n_features)\n", + "print ('XXXX ====== Actual Input ====== XXXX')\n", + "print (X.shape)\n", + "\n", + "y_XRP = aft_ts_xrp[1:]\n", + "y_ETH = aft_ts_eth[1:]\n", + "y_LTC = aft_ts_ltc[1:]\n", + "y_BTC = aft_ts_btc[1:]\n", + "\n", + "y = np.column_stack((y_XRP, y_ETH, y_LTC, y_BTC))\n", + "print (y)\n", + "\n", + "y = y_BTC.reshape(batch-cnt_thrown_idx, frwd, n_out)\n", + "# print ('YYYY ====== Actual Input ====== YYYY')\n", + "print (y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47d6927d-9021-4a56-9e52-ee2061bd5979", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0rc1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tensorflow/notebooks/leo/LSTM_All_Crypto_Simple.ipynb b/tensorflow/notebooks/leo/LSTM_All_Crypto_Simple.ipynb new file mode 100644 index 0000000..4443223 --- /dev/null +++ b/tensorflow/notebooks/leo/LSTM_All_Crypto_Simple.ipynb @@ -0,0 +1,3368 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 28, + "id": "1023f2c1-e45f-4e1c-9a1b-66f59f128196", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Panda Version: 2.2.2\n", + "Today date is: 2024-07-01\n" + ] + } + ], + "source": [ + "import sqlite3\n", + "\n", + "import os\n", + "import re\n", + "\n", + "import numpy as np\n", + "# It is apparently officially accepted to explicitly\n", + "# list all the functions you need from numpy:\n", + "from numpy import array, zeros, exp, random, dot\n", + "from numpy import shape, reshape, meshgrid, linspace\n", + "from numpy import hstack, vstack\n", + "\n", + "import pandas as pd\n", + "print('Panda Version:', pd.__version__)\n", + "\n", + "# Set ipython's max row display\n", + "pd.set_option('display.max_row', 100, 'display.max_columns', 25)\n", + "\n", + "import matplotlib.pyplot as plt # for plotting\n", + "import matplotlib\n", + "matplotlib.rcParams['figure.dpi'] = 100 # highres display\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow import Variable\n", + "\n", + "from tensorflow.keras import Sequential\n", + "from tensorflow.keras import Model\n", + "from tensorflow.keras.layers import Dense\n", + "from tensorflow.keras.layers import Dropout\n", + "from tensorflow.keras.layers import TimeDistributed, RepeatVector\n", + "\n", + "from keras.optimizers import SGD\n", + "\n", + "from keras.models import load_model\n", + "from keras.callbacks import EarlyStopping\n", + "from keras.callbacks import ModelCheckpoint\n", + "\n", + "from keras.layers import LSTM, Dense, Concatenate\n", + "\n", + "from keras.optimizers import SGD\n", + "\n", + "import collections\n", + "from collections import Counter\n", + "\n", + "import seaborn as sns\n", + "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n", + "from statsmodels.tsa.seasonal import seasonal_decompose\n", + "\n", + "from scipy import signal\n", + "\n", + "# Import date class from datetime module\n", + "import time\n", + "import datetime\n", + "# import datetime as dt\n", + "from datetime import date\n", + "print(\"Today date is: \", date.today())" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c09a37a6-f0d9-48e3-a1d1-65ddaf2c489c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/workspace/leo\n", + "total 39536\n", + "drwxrwxr-x 1 1000 1000 1598 Jul 1 20:50 .\n", + "drwxrwxr-x 1 1000 1000 18 Jun 3 23:40 ..\n", + "-rw------- 1 1000 1000 1449984 Jun 4 00:49 20240601.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 3 23:44 20240602.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1437696 Jun 4 16:45 20240603.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1269760 Jun 5 10:00 20240604.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1081344 Jun 6 10:00 20240605.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1441792 Jun 7 10:00 20240606.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 8 10:00 20240607.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 9 10:00 20240608.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1437696 Jun 10 10:00 20240609.mktdata.ohlcv.db\n", + "-rw-r--r-- 1 1000 1000 0 Jun 12 15:29 20240609.mktdata.ohlcvdb\n", + "-rw------- 1 1000 1000 1437696 Jun 11 10:00 20240610.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 12 10:01 20240611.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 13 10:01 20240612.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 14 10:01 20240613.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1404928 Jun 15 10:01 20240614.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 16 10:00 20240615.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 17 10:00 20240616.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1437696 Jun 18 10:01 20240617.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 970752 Jun 19 10:00 20240618.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 802816 Jun 20 10:00 20240619.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 806912 Jun 21 10:00 20240620.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 888832 Jun 22 10:00 20240621.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 23 10:00 20240622.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 24 10:00 20240623.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1437696 Jun 25 10:00 20240624.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 26 10:00 20240625.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 27 10:00 20240626.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 28 10:00 20240627.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 29 10:00 20240628.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 30 10:00 20240629.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jul 1 10:00 20240630.mktdata.ohlcv.db\n", + "-rw-r--r-- 1 root root 0 Jul 1 20:50 20240701.mktdata.ohlcv.db\n" + ] + } + ], + "source": [ + "!pwd\n", + "\n", + "!ls -la /workspace/data/crypto_md/" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "8d72d849-e8df-4564-a006-03ab646b9330", + "metadata": {}, + "outputs": [], + "source": [ + "# db_conn = sqlite3.connect(mktdata_db_file)\n", + "# tables_df = pd.read_sql_query(\"select * from sqlite_master where type = 'table'\", db_conn)\n", + "# print (tables_df_20240601.head())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4df4b0d4-e92e-42a9-8747-ff60669a4e10", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "5d2aed0b-8c9d-4f5a-9166-785da4811390", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "170211\n", + " tstamp exchange_id instrument_id open high \\\n", + "0 1717200000000000000 COINBASE PAIR-BTC-USD 67473.07 67514.99 \n", + "1 1717200060000000000 COINBASE PAIR-BTC-USD 67506.57 67515.00 \n", + "\n", + " low close volume vwap \n", + "0 67468.13 67506.03 2.045049 67496.869352 \n", + "1 67480.66 67494.74 0.646759 67500.893305 \n", + " tstamp exchange_id instrument_id open high low \\\n", + "170209 1719791880000000000 COINBASE PAIR-XRP-USD 0.4754 0.4755 0.4752 \n", + "170210 1719791940000000000 COINBASE PAIR-XRP-USD 0.4754 0.4754 0.4753 \n", + "\n", + " close volume vwap \n", + "170209 0.4752 1673.163942 0.475444 \n", + "170210 0.4753 4375.796190 0.475368 \n" + ] + } + ], + "source": [ + "directory = \"/workspace/data/crypto_md\"\n", + "\n", + "# List of dates\n", + "dates = ['20240601', \n", + " '20240602', \n", + " '20240603',\n", + " '20240604', \n", + " '20240605', \n", + " '20240606', \n", + " '20240607', \n", + " '20240608',\n", + " '20240609',\n", + " '20240610',\n", + " '20240611',\n", + " '20240612',\n", + " '20240613', \n", + " '20240614', \n", + " '20240615', \n", + " '20240616', \n", + " '20240617',\n", + " '20240618',\n", + " '20240619',\n", + " '20240620',\n", + " '20240621', \n", + " '20240622', \n", + " '20240623',\n", + " '20240624',\n", + " '20240625', \n", + " '20240626',\n", + " '20240627',\n", + " '20240628',\n", + " '20240629',\n", + " '20240630']\n", + " # '20240701']\n", + " \n", + "# Create an entirely empty DataFrame\n", + "df_concat = pd.DataFrame()\n", + "\n", + "for date in dates:\n", + " # Construct the filename\n", + " filename = f\"{directory}/{date}.mktdata.ohlcv.db\"\n", + " \n", + " # Create the SQLite connection\n", + " conn = sqlite3.connect(filename)\n", + " \n", + " # Read the data into a DataFrame\n", + " df = pd.read_sql_query(\"select * from coinbase_ohlcv_1min\", conn)\n", + "\n", + " df_concat = pd.concat([df_concat, df], axis = 0,ignore_index = True)\n", + " # Print the combined DataFrame\n", + " # print(df_concat.shape[0])\n", + " # print(df_concat.shape[1])\n", + " conn.close()\n", + "print(df_concat.shape[0])\n", + "print(df_concat.head(2))\n", + "print(df_concat.tail(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "cd83027c-eaa1-44d9-98ad-8506099c323d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distinct values in column 'instrument_id': ['PAIR-BTC-USD', 'PAIR-ETH-USD', 'PAIR-LTC-USD', 'PAIR-XRP-USD']\n" + ] + } + ], + "source": [ + "df_concat['tstamp'] = pd.to_datetime(df_concat['tstamp'])\n", + "\n", + "# Extract individual components\n", + "\n", + "df_concat['year'] = df_concat['tstamp'].dt.year\n", + "df_concat['month'] = df_concat['tstamp'].dt.month\n", + "df_concat['day'] = df_concat['tstamp'].dt.day\n", + "df_concat['hour'] = df_concat['tstamp'].dt.hour\n", + "df_concat['minute'] = df_concat['tstamp'].dt.minute\n", + "df_concat['second'] = df_concat['tstamp'].dt.second\n", + "\n", + "df_concat['date'] = df_concat['day'].astype(str) + '-' + df_concat['hour'].astype(str) + '-' + df_concat['minute'].astype(str)\n", + "df_concat = df_concat.sort_values(by = ['day', 'hour', 'minute'])\n", + "\n", + "selected_columns = ['date', 'instrument_id', 'close', 'volume', 'vwap']\n", + "df_concat = df_concat[selected_columns]\n", + "\n", + "instrument_list = df_concat['instrument_id'].unique().tolist()\n", + "print(\"Distinct values in column 'instrument_id':\", instrument_list)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "316c0cfb-c73d-4dad-9d49-eb80daa229ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "========================================\n", + " date close_xrp volume_xrp vwap_xrp close_eth volume_eth vwap_eth \\\n", + "0 1-0-0 0.5173 28809.165339 0.517217 0.376204 37.497964 0.376108 \n", + "1 1-0-1 0.5170 10184.511212 0.517060 0.375942 11.703305 0.376013 \n", + "2 1-0-10 0.5176 15515.348778 0.517601 0.375938 11.922897 0.375935 \n", + "\n", + " close_ltc volume_ltc vwap_ltc close_btc volume_btc vwap_btc \n", + "0 0.8317 110.056253 0.831662 0.675060 2.045049 0.674969 \n", + "1 0.8312 176.868598 0.831441 0.674947 0.646759 0.675009 \n", + "2 0.8311 58.951033 0.831037 0.675507 1.201335 0.675478 \n", + "test sample size: 42544\n" + ] + } + ], + "source": [ + "# BTC\n", + "df_concat_btc = df_concat[df_concat['instrument_id'] == 'PAIR-BTC-USD']\n", + "\n", + "# Reset Index\n", + "df_concat_btc = df_concat_btc.reset_index(drop = True)\n", + "\n", + "# Rename Vars\n", + "df_concat_btc['close_btc'] = df_concat_btc['close']/100000.00\n", + "df_concat_btc['volume_btc'] = df_concat_btc['volume']\n", + "df_concat_btc['vwap_btc'] = df_concat_btc['vwap']/100000.00\n", + "\n", + "df_concat_btc = df_concat_btc.drop('close', axis = 1)\n", + "df_concat_btc = df_concat_btc.drop('volume', axis = 1)\n", + "df_concat_btc = df_concat_btc.drop('vwap', axis = 1)\n", + "df_concat_btc = df_concat_btc.drop('instrument_id', axis = 1)\n", + "\n", + "# print (df_concat_btc.head(3))\n", + "\n", + "# LTC\n", + "df_concat_ltc = df_concat[df_concat['instrument_id'] == 'PAIR-LTC-USD']\n", + "\n", + "# Reset Index\n", + "df_concat_ltc = df_concat_ltc.reset_index(drop = True)\n", + "\n", + "# Rename Vars\n", + "df_concat_ltc['close_ltc'] = df_concat_ltc['close']/100.00\n", + "df_concat_ltc['volume_ltc'] = df_concat_ltc['volume']\n", + "df_concat_ltc['vwap_ltc'] = df_concat_ltc['vwap']/100.00\n", + "\n", + "df_concat_ltc = df_concat_ltc.drop('close', axis = 1)\n", + "df_concat_ltc = df_concat_ltc.drop('volume', axis = 1)\n", + "df_concat_ltc = df_concat_ltc.drop('vwap', axis = 1)\n", + "df_concat_ltc = df_concat_ltc.drop('instrument_id', axis = 1)\n", + "\n", + "# print (df_concat_ltc.head(3))\n", + "\n", + "# ETH\n", + "df_concat_eth = df_concat[df_concat['instrument_id'] == 'PAIR-ETH-USD']\n", + "\n", + "# Reset Index\n", + "df_concat_eth = df_concat_eth.reset_index(drop = True)\n", + "\n", + "# Rename Vars\n", + "df_concat_eth['close_eth'] = df_concat_eth['close']/10000.00\n", + "df_concat_eth['volume_eth'] = df_concat_eth['volume']\n", + "df_concat_eth['vwap_eth'] = df_concat_eth['vwap']/10000.00\n", + "\n", + "df_concat_eth = df_concat_eth.drop('close', axis = 1)\n", + "df_concat_eth = df_concat_eth.drop('volume', axis = 1)\n", + "df_concat_eth = df_concat_eth.drop('vwap', axis = 1)\n", + "df_concat_eth = df_concat_eth.drop('instrument_id', axis = 1)\n", + "\n", + "# print (df_concat_eth.head(3))\n", + "\n", + "# XRP\n", + "df_concat_xrp = df_concat[df_concat['instrument_id'] == 'PAIR-XRP-USD']\n", + "\n", + "# Reset Index\n", + "df_concat_xrp = df_concat_xrp.reset_index(drop = True)\n", + "\n", + "# Rename Vars\n", + "df_concat_xrp['close_xrp'] = df_concat_xrp['close']\n", + "df_concat_xrp['volume_xrp'] = df_concat_xrp['volume']\n", + "df_concat_xrp['vwap_xrp'] = df_concat_xrp['vwap']\n", + "\n", + "df_concat_xrp = df_concat_xrp.drop('close', axis = 1)\n", + "df_concat_xrp = df_concat_xrp.drop('volume', axis = 1)\n", + "df_concat_xrp = df_concat_xrp.drop('vwap', axis = 1)\n", + "df_concat_xrp = df_concat_xrp.drop('instrument_id', axis = 1)\n", + "\n", + "# print (df_concat_xrp.head(3))\n", + "\n", + "df_M1 = pd.merge(df_concat_xrp, df_concat_eth, on = 'date', how = 'outer')\n", + "# print (df_M1.head(3))\n", + "# print (\"M1: \", df_M1.shape[0])\n", + "df_M2 = pd.merge(df_M1, df_concat_ltc, on = 'date', how = 'outer')\n", + "# print (df_M2.head(3))\n", + "# print (\"M2: \", df_M2.shape[0])\n", + "df_M3 = pd.merge(df_M2, df_concat_btc, on = 'date', how = 'outer')\n", + "# print (df_M3.head(3))\n", + "# print (\"M3: \", df_M3.shape[0])\n", + "\n", + "# Drop rows with any NaN value and assign it to a new DataFrame\n", + "sample = df_M3.dropna(axis = 0).reset_index(drop = True)\n", + "print (\"========================================\")\n", + "print (sample.head(3))\n", + "sample_size = sample.shape[0]\n", + "print (\"test sample size: \", sample_size)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e0111b3-ec60-4a3f-8c05-b915be03c7da", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92700c76-8eac-4ebb-86d3-27066486c437", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a figure and axis object\n", + "fig, ax = plt.subplots(2 , 1)\n", + "\n", + "# Plot the data\n", + "ax[0].plot(df_concat_btc['date'], df_concat_btc['close_btc'], 'blue')\n", + "# ax[0].plot(df_concat_btc['date'], df_concat_btc['vwap_btc'], 'green')\n", + "\n", + "# Customize the plot\n", + "ax[0].set_title('PAIR-BTC-USDT')\n", + "ax[0].set_xlabel('date')\n", + "ax[0].set_ylabel('close')\n", + "\n", + "ax[1].plot(df_concat_btc['date'], df_concat_btc['vwap_btc'], 'green')\n", + "# ax[1].plot(df_concat_btc['date'], df_concat_btc['volume_BTC'], 'red')\n", + "\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "3c6d80b3-4a46-432b-9b88-6a264f9b7a7e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "First part of the DataFrame:\n", + " date close_xrp volume_xrp vwap_xrp close_eth volume_eth \\\n", + "34033 30-3-12 0.4705 23903.550015 0.470389 0.336016 26.085988 \n", + "34034 30-3-13 0.4704 2874.524770 0.470399 0.335908 5.563220 \n", + "\n", + " vwap_eth close_ltc volume_ltc vwap_ltc close_btc volume_btc \\\n", + "34033 0.336069 0.7532 77.639105 0.752861 0.607710 0.166529 \n", + "34034 0.335966 0.7531 37.653148 0.752865 0.607414 0.811043 \n", + "\n", + " vwap_btc \n", + "34033 0.607675 \n", + "34034 0.607543 \n", + "\n", + "Second part of the DataFrame:\n", + " date close_xrp volume_xrp vwap_xrp close_eth volume_eth \\\n", + "34035 30-3-14 0.4703 433.136168 0.470274 0.335963 13.152171 \n", + "34036 30-3-15 0.4704 10739.731198 0.470326 0.336184 12.567832 \n", + "\n", + " vwap_eth close_ltc volume_ltc vwap_ltc close_btc volume_btc \\\n", + "34035 0.335893 0.7531 18.631439 0.753011 0.607389 1.337421 \n", + "34036 0.336058 0.7528 42.495271 0.752919 0.607574 1.000359 \n", + "\n", + " vwap_btc \n", + "34035 0.607315 \n", + "34036 0.607486 \n" + ] + } + ], + "source": [ + "split_index = round(sample.shape[0] * 0.8)\n", + "\n", + "# First part of the DataFrame\n", + "sample_test = sample.iloc[:split_index]\n", + "\n", + "# Second part of the DataFrame\n", + "sample_valid = sample.iloc[split_index:]\n", + "\n", + "print(\"\\nFirst part of the DataFrame:\")\n", + "print (sample_test.tail(2))\n", + "\n", + "print(\"\\nSecond part of the DataFrame:\")\n", + "print (sample_valid.head(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "4edcdbdb-85fb-415e-a6c4-71cc383c4410", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sample_size: 34035\n", + "[19934]\n", + "XXXX ====== Actual Input ====== XXXX\n", + "[[[0.4903 0.350729 0.7377 0.6455032]\n", + " [0.4903 0.350877 0.7377 0.6457926]\n", + " [0.4905 0.350933 0.7378 0.6459017]\n", + " [0.4905 0.351024 0.7377 0.6459088]\n", + " [0.4887 0.35135 0.7407 0.6460095]\n", + " [0.4889 0.351423 0.7406 0.6462003]\n", + " [0.4888 0.351417 0.7406 0.6461287]\n", + " [0.4891 0.35157 0.7409 0.6463387]\n", + " [0.4911 0.3515 0.738 0.6463418]\n", + " [0.4913 0.351714 0.7376 0.6466298]\n", + " [0.4902 0.351286 0.7368 0.6462171]\n", + " [0.4901 0.351246 0.7368 0.6460858]\n", + " [0.4908 0.351296 0.7372 0.6462293]\n", + " [0.4909 0.351368 0.7368 0.6463424]\n", + " [0.491 0.351486 0.7371 0.6465279]\n", + " [0.4909 0.351606 0.7372 0.6469269]\n", + " [0.4908 0.351709 0.7362 0.6467869]\n", + " [0.491 0.351545 0.7362 0.6466154]\n", + " [0.4916 0.351287 0.736 0.6465932]\n", + " [0.4914 0.35129 0.7362 0.6466617]\n", + " [0.4908 0.351293 0.7374 0.6459877]\n", + " [0.4923 0.351355 0.7362 0.6468191]\n", + " [0.4924 0.351374 0.7364 0.6467814]\n", + " [0.4924 0.351467 0.7364 0.6469565]\n", + " [0.4923 0.351074 0.7355 0.6464956]\n", + " [0.492 0.351047 0.7343 0.6463371]\n", + " [0.4922 0.351055 0.7344 0.6464964]\n", + " [0.4919 0.351305 0.7346 0.6468045]\n", + " [0.4915 0.351157 0.7349 0.6466907]\n", + " [0.4915 0.351322 0.7339 0.6469997]\n", + " [0.4915 0.351399 0.7341 0.6470494]\n", + " [0.4906 0.351147 0.737 0.6459061]\n", + " [0.492 0.350953 0.7333 0.6465835]\n", + " [0.4922 0.350958 0.7335 0.6464431]\n", + " [0.4921 0.350888 0.7328 0.6464784]\n", + " [0.4923 0.35085 0.7334 0.6464815]]]\n", + "(1, 36, 4)\n", + "YYYY ====== Actual Input ====== YYYY\n", + "[[[0.4917 0.350808 0.7332 0.6462491]]]\n", + "(1, 1, 4)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_29/4116522689.py:20: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " sample_test['Selected'] = 0\n" + ] + } + ], + "source": [ + "# Original Model, to repeat\n", + "# ==============================\n", + "# variables are close and volume\n", + "# ==============================\n", + "# Test Sample --- 06.20.2024\n", + "# ==============================\n", + "sample_size = sample_test.shape[0]\n", + "print ('sample_size: ', sample_size)\n", + "\n", + "# Model Input\n", + "# ========================================\n", + "sl = 36 # <--- sequence length\n", + "batch = 1 # <--- batch size\n", + "n_features = 4 # <---- no. of variables\n", + "n_out = 4 # <----- no. of predicted variables\n", + "frwd = 1 # <--- how many to predict\n", + "\n", + "# Trimming Indices !!!\n", + "# Marking selected rows\n", + "sample_test['Selected'] = 0\n", + "\n", + "# Selecting m random rows without replacement\n", + "np.random.seed(125)\n", + "selected_indices = np.random.choice(sample_test.index, size = batch, replace = False)\n", + "\n", + "sample_test.loc[selected_indices, 'Selected'] = 1 # print (sample_test[sample_test['Selected'] == 1])\n", + "chosen_idx1 = sample_test[sample_test['Selected'] == 1].index\n", + "chosen_idx2 = chosen_idx1[chosen_idx1 > sl]\n", + "\n", + "thrown_idx1 = chosen_idx1[chosen_idx1 <= sl]\n", + "cnt_thrown_idx1 = len(thrown_idx1)\n", + "\n", + "chosen_idx3 = chosen_idx2[chosen_idx2 < (sample_size - frwd)]\n", + "\n", + "thrown_idx2 = chosen_idx2[chosen_idx2 >= (sample_size - frwd)]\n", + "cnt_thrown_idx2 = len(thrown_idx2)\n", + "\n", + "cnt_thrown_idx = cnt_thrown_idx1 + cnt_thrown_idx2\n", + "\n", + "print (selected_indices)\n", + "\n", + "all_ts_close_xrp = np.empty((1, )) # final input/output\n", + "all_ts_close_eth = np.empty((1, )) # final input/output\n", + "all_ts_close_ltc = np.empty((1, )) # final input/output\n", + "all_ts_close_btc = np.empty((1, )) # final input/output\n", + "\n", + "all_ts_volume_xrp = np.empty((1, )) # final input/output\n", + "all_ts_volume_eth = np.empty((1, )) # final input/output\n", + "all_ts_volume_ltc = np.empty((1, )) # final input/output\n", + "all_ts_volume_btc = np.empty((1, )) # final input/output\n", + "\n", + "stdev_xrp = np.empty((1, )) # final input/output\n", + "stdev_eth = np.empty((1, )) # final input/output\n", + "stdev_ltc = np.empty((1, )) # final input/output\n", + "stdev_btc = np.empty((1, )) # final input/output\n", + "\n", + "\n", + "aft_ts_close_xrp = np.empty((1))\n", + "aft_ts_close_eth = np.empty((1))\n", + "aft_ts_close_ltc = np.empty((1))\n", + "aft_ts_close_btc = np.empty((1))\n", + "\n", + "\n", + "for idx in chosen_idx3:\n", + " selected_rows_before = sample_test.iloc[max(0, idx-sl): idx]\n", + " selected_rows_after = sample_test.iloc[max(0, idx): idx+frwd]\n", + "\n", + " # xrp\n", + " sr_before_close_xrp = np.array(selected_rows_before['close_xrp'])\n", + " sr_after_close_xrp = np.array(selected_rows_after['close_xrp']) \n", + " # print (sr_before_close_xrp)\n", + " sr_before_volume_xrp = np.array(selected_rows_before['volume_xrp'])\n", + " sr_after_volume_xrp = np.array(selected_rows_after['volume_xrp']) \n", + " # print (sr_before_volume_xrp) \n", + "# Compute standard deviation\n", + " std_dev_xrp = np.std(sr_before_close_xrp)\n", + " std_dev_xrp_arr = np.repeat(std_dev_xrp, sl)\n", + "# Compute the weighted average\n", + " weighted_avg_xrp = np.average(sr_after_close_xrp, weights = sr_after_volume_xrp)\n", + " # print ('XRP w.average: ', weighted_avg_xrp)\n", + "\n", + "# eth\n", + " sr_before_close_eth = np.array(selected_rows_before['close_eth'])\n", + " sr_after_close_eth = np.array(selected_rows_after['close_eth'])\n", + " sr_before_volume_eth = np.array(selected_rows_before['volume_eth'])\n", + " sr_after_volume_eth = np.array(selected_rows_after['volume_eth'])\n", + "# Compute standard deviation\n", + " std_dev_eth = np.std(sr_before_close_eth)\n", + " std_dev_eth_arr = np.repeat(std_dev_eth, sl)\n", + "# Compute the weighted average\n", + " weighted_avg_eth = np.average(sr_after_close_eth, weights = sr_after_volume_eth)\n", + " # print ('ETH w.average: ', weighted_avg_eth)\n", + " \n", + "# ltc\n", + " sr_before_close_ltc = np.array(selected_rows_before['close_ltc'])\n", + " sr_after_close_ltc = np.array(selected_rows_after['close_ltc'])\n", + " sr_before_volume_ltc = np.array(selected_rows_before['volume_ltc'])\n", + " sr_after_volume_ltc = np.array(selected_rows_after['volume_ltc'])\n", + "# Compute standard deviation\n", + " std_dev_ltc = np.std(sr_before_close_ltc)\n", + " std_dev_ltc_arr = np.repeat(std_dev_ltc, sl)\n", + "# Compute the weighted average\n", + " weighted_avg_ltc = np.average(sr_after_close_ltc, weights = sr_after_volume_ltc)\n", + " # print ('LTC w.average: ', weighted_avg_ltc)\n", + "\n", + "# btc\n", + " sr_before_close_btc = np.array(selected_rows_before['close_btc'])\n", + " sr_after_close_btc = np.array(selected_rows_after['close_btc'])\n", + " sr_before_volume_btc = np.array(selected_rows_before['volume_btc'])\n", + " sr_after_volume_btc = np.array(selected_rows_after['volume_btc'])\n", + "# Compute standard deviation\n", + " std_dev_btc = np.std(sr_before_close_btc)\n", + " std_dev_btc_arr = np.repeat(std_dev_btc, sl)\n", + "# Compute the weighted average\n", + " weighted_avg_btc = np.average(sr_after_close_btc, weights = sr_after_volume_btc)\n", + " # print ('BTC w.average: ', weighted_avg_btc)\n", + "\n", + "\n", + "# xrp\n", + " all_ts_close_xrp = np.concatenate((all_ts_close_xrp, sr_before_close_xrp))\n", + " all_ts_volume_xrp = np.concatenate((all_ts_volume_xrp, sr_before_volume_xrp))\n", + " stdev_xrp = np.concatenate((stdev_xrp, std_dev_xrp_arr))\n", + "# eth\n", + " all_ts_close_eth = np.concatenate((all_ts_close_eth, sr_before_close_eth))\n", + " all_ts_volume_eth = np.concatenate((all_ts_volume_eth, sr_before_volume_eth))\n", + " stdev_eth = np.concatenate((stdev_eth, std_dev_eth_arr))\n", + "# ltc\n", + " stdev_ltc = np.concatenate((stdev_ltc, std_dev_ltc_arr))\n", + " all_ts_close_ltc = np.concatenate((all_ts_close_ltc, sr_before_close_ltc))\n", + " all_ts_volume_ltc = np.concatenate((all_ts_volume_ltc, sr_before_volume_ltc))\n", + "# btc\n", + " all_ts_close_btc = np.concatenate((all_ts_close_btc, sr_before_close_btc))\n", + " all_ts_volume_btc = np.concatenate((all_ts_volume_btc, sr_before_volume_btc))\n", + " stdev_btc = np.concatenate((stdev_btc, std_dev_btc_arr))\n", + "\n", + "\n", + " aft_ts_close_xrp = np.concatenate((aft_ts_close_xrp, sr_after_close_xrp))\n", + " aft_ts_close_eth = np.concatenate((aft_ts_close_eth, sr_after_close_eth))\n", + " aft_ts_close_ltc = np.concatenate((aft_ts_close_ltc, sr_after_close_ltc))\n", + " aft_ts_close_btc = np.concatenate((aft_ts_close_btc, sr_after_close_btc))\n", + "\n", + "\n", + "X_XRP_close = all_ts_close_xrp[1:]\n", + "X_XRP_volume = all_ts_volume_xrp[1:]\n", + "X_XRP_stdev = stdev_xrp[1:]\n", + "\n", + "X_ETH_close = all_ts_close_eth[1:]\n", + "X_ETH_volume = all_ts_volume_eth[1:]\n", + "X_ETH_stdev = stdev_eth[1:]\n", + "\n", + "X_LTC_close = all_ts_close_ltc[1:]\n", + "X_LTC_volume = all_ts_volume_ltc[1:]\n", + "X_LTC_stdev = stdev_ltc[1:]\n", + "\n", + "X_BTC_close = all_ts_close_btc[1:]\n", + "X_BTC_volume = all_ts_volume_btc[1:]\n", + "X_BTC_stdev = stdev_btc[1:]\n", + "\n", + "# X0 = np.column_stack((X_XRP_close, X_XRP_volume, \n", + "# X_ETH_close, X_ETH_volume, \n", + "# X_LTC_close, X_LTC_volume, \n", + "# X_BTC_close, X_BTC_volume))\n", + "\n", + "X0 = np.column_stack((X_XRP_close,\n", + " X_ETH_close,\n", + " X_LTC_close,\n", + " X_BTC_close))\n", + "# print (X0)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# ======== Model Input =========\n", + "X = X0.reshape(batch-cnt_thrown_idx, sl, n_features)\n", + "print ('XXXX ====== Actual Input ====== XXXX')\n", + "print (X)\n", + "print (X.shape)\n", + "\n", + "y_XRP = aft_ts_close_xrp[1:]\n", + "y_ETH = aft_ts_close_eth[1:]\n", + "y_LTC = aft_ts_close_ltc[1:]\n", + "y_BTC = aft_ts_close_btc[1:]\n", + "\n", + "y0 = np.column_stack((y_XRP, y_ETH, y_LTC, y_BTC))\n", + "# print (y0)\n", + "\n", + "y = y0.reshape(batch-cnt_thrown_idx, frwd, n_out)\n", + "print ('YYYY ====== Actual Input ====== YYYY')\n", + "print (y)\n", + "print (y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c40d6239-1f0e-43c9-a378-c71b31be86c4", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + " 06.26.2014 Trends and Seasonalities\n", + "========================================================\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "fef5aa61-5189-4775-beed-02405bbbe946", + "metadata": {}, + "outputs": [], + "source": [ + "X0 = np.column_stack((X_XRP_close,\n", + " X_ETH_close,\n", + " X_LTC_close,\n", + " X_BTC_close))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "bf9b898e-49d2-4ae4-af2f-5d30f9fd16ed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(36, 4)\n" + ] + } + ], + "source": [ + "print (type(X0))\n", + "print (X0.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "449fca01-0060-4b0f-887b-6cf6c1d630c1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "crypto_list = ['XRP', 'ETH', 'LTC', 'BTC']\n", + "df_trend = pd.DataFrame(X0, columns = crypto_list)\n", + "\n", + "# print (crypto_list)\n", + "for crypto in crypto_list:\n", + " fig, ax = plt.subplots()\n", + " ax.plot(df_trend.index, df_trend[crypto], label = crypto)\n", + " # ax.plot(df.index, df['B'], label='B')\n", + " # ax.plot(df.index, df['C'], label='C')\n", + " # ax.plot(df.index, df['D'], label='D')\n", + " \n", + " ax.set_xlabel('Date')\n", + " ax.set_ylabel('Values')\n", + " ax.set_title('Time Series Plot')\n", + " ax.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "d35b8d31-9080-4220-b0d4-c7af987ccc45", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = np.array([\n", + " [0.5233, 0.383067, 0.8573, 0.7105592],\n", + " [0.5235, 0.383102, 0.8574, 0.7105005],\n", + " [0.5243, 0.383687, 0.8538, 0.710517],\n", + " [0.5239, 0.383284, 0.8528, 0.7100418],\n", + " [0.5238, 0.382979, 0.8526, 0.7097535],\n", + " [0.5229, 0.3827, 0.8522, 0.7088585]\n", + "])\n", + "\n", + "df = pd.DataFrame(data, columns=['A', 'B', 'C', 'D'])\n", + "df.index = pd.date_range(start='2023-01-01', periods=len(df), freq='D')\n", + "\n", + "# Function to de-trend a series\n", + "def detrend_series(series):\n", + " x = np.arange(len(series))\n", + " y = series.values # Ensure we are using the values of the series\n", + " trend = np.polyfit(x, y, 1)\n", + " trend_line = np.polyval(trend, x)\n", + " detrended_series = series - trend_line\n", + " return detrended_series\n", + "\n", + "# Apply de-trending to each column in the DataFrame\n", + "df_detrended = df.apply(detrend_series)\n", + "\n", + "# Plot the original and de-trended time series\n", + "fig, axes = plt.subplots(nrows=2, ncols=1, figsize=(10, 8))\n", + "\n", + "df.plot(ax=axes[0], title='Original Time Series')\n", + "df_detrended.plot(ax=axes[1], title='De-trended Time Series')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "96360fe8-062c-46fc-87f2-06dd49ce6fcc", + "metadata": {}, + "outputs": [], + "source": [ + "def detrend_series(series):\n", + " trend = np.polyfit(np.arange(len(series)), series.values, 1)\n", + " trend_line = np.polyval(trend, np.arange(len(series)))\n", + " detrended_series = series - trend_line\n", + " return detrended_series\n", + "\n", + "df_detrended = df.apply(detrend_series)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "9187fc21-3596-4c31-975b-a0fbc461c2c6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "36\n", + "[7.49806950e-05 4.89748949e-01]\n", + "[0.48974895 0.48982393 0.48989891 0.48997389 0.49004887 0.49012385\n", + " 0.49019883 0.49027381 0.49034879 0.49042378 0.49049876 0.49057374\n", + " 0.49064872 0.4907237 0.49079868 0.49087366 0.49094864 0.49102362\n", + " 0.4910986 0.49117358 0.49124856 0.49132354 0.49139852 0.4914735\n", + " 0.49154849 0.49162347 0.49169845 0.49177343 0.49184841 0.49192339\n", + " 0.49199837 0.49207335 0.49214833 0.49222331 0.49229829 0.49237327]\n", + "0 0.000551\n", + "1 0.000476\n", + "2 0.000601\n", + "3 0.000526\n", + "4 -0.001349\n", + "5 -0.001224\n", + "6 -0.001399\n", + "7 -0.001174\n", + "8 0.000751\n", + "9 0.000876\n", + "10 -0.000299\n", + "11 -0.000474\n", + "12 0.000151\n", + "13 0.000176\n", + "14 0.000201\n", + "15 0.000026\n", + "16 -0.000149\n", + "17 -0.000024\n", + "18 0.000501\n", + "19 0.000226\n", + "20 -0.000449\n", + "21 0.000976\n", + "22 0.001001\n", + "23 0.000926\n", + "24 0.000752\n", + "25 0.000377\n", + "26 0.000502\n", + "27 0.000127\n", + "28 -0.000348\n", + "29 -0.000423\n", + "30 -0.000498\n", + "31 -0.001473\n", + "32 -0.000148\n", + "33 -0.000023\n", + "34 -0.000198\n", + "35 -0.000073\n", + "Name: XRP, dtype: float64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_trend = pd.DataFrame(X0, columns = crypto_list)\n", + "\n", + "# print (df_trend)\n", + "\n", + "# for crypto in crypto_list:\n", + "\n", + "print (len(df_trend))\n", + "\n", + "trend = np.polyfit(np.arange(len(df_trend)), df_trend[crypto_list[0]], 1)\n", + "print (trend)\n", + "\n", + "trend_line = np.polyval(trend, np.arange(len(df_trend)))\n", + "print (trend_line)\n", + "\n", + "detrended_series = df_trend[crypto_list[0]] - trend_line\n", + "print (detrended_series)\n", + "\n", + "fig, ax = plt.subplots()\n", + "# ax.plot(df_trend.index, df_trend[crypto_list[0]], label = crypto_list[0], color = 'blue')\n", + "ax.plot(df_trend.index, detrended_series, label = crypto_list[0], color = 'red')\n", + "# ax.plot(df_trend.index, trend_line, label = crypto_list[0], color = 'red')\n", + "# # ax.plot(df.index, df['C'], label='C')\n", + "# # ax.plot(df.index, df['D'], label='D')\n", + "\n", + "ax.set_xlabel('Date')\n", + "ax.set_ylabel('Values')\n", + "ax.set_title('Time Series Plot')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "e3c4d287-9610-4b98-9f84-a4f1e914e37c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[7.49806950e-05 4.89748949e-01]\n", + "7.498069498070488e-05\n", + "0.489748948948949\n" + ] + } + ], + "source": [ + "print (trend)\n", + "print (trend[0])\n", + "print (trend[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 290, + "id": "8a9f9cd9-bd71-4ca9-b79f-20d076f9cf2b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4946327327327326\n", + "0.49703948948948984\n" + ] + } + ], + "source": [ + "print (trend[0]*0 + trend[1])\n", + "print (trend[0]*(len(df_trend)-1) + trend[1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed74c932-19b7-4a4a-9334-29623fba4d21", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d20af57c-121c-49c8-84d3-15393f36c45d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "898e6822-8444-4835-acef-9feb8f8e6190", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5bb2fcd8-18ab-4c9b-b66e-4a415cea12fd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "48adf790-d801-404b-aaeb-a97297f4ef14", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ec5f297d-be92-421a-b25e-d61043ed9faf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cf50668b-5970-4caa-bed5-72cc62e4ea8e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.4961 0.4961 0.4966 0.4956 0.4956 0.4958 0.4959 0.4961]\n", + "0.495975\n", + "0.00030720514318610995\n" + ] + } + ], + "source": [ + "# 06.05.2024 just helper\n", + "values = X_XRP_close.reshape(batch-cnt_thrown_idx, sl)\n", + "\n", + "print (values[0])\n", + "print (np.mean(values[0]))\n", + "print (np.std(values[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "88e292cc-1244-462a-b311-3e964773c742", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Figure AutoCorrelations and Partial AutoCorrelations\n", + "import seaborn as sns\n", + "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n", + "\n", + "for i in range(batch-cnt_thrown_idx):\n", + " print (i)\n", + "# Plot the autocorrelation function (ACF) \n", + " plt.figure(figsize = (12, 6))\n", + " plot_acf(values[i], lags = sl - 1)\n", + " plt.title('Autocorrelation Function (ACF)')\n", + " plt.show()\n", + " \n", + "# Plot the partial autocorrelation function (PACF)\n", + " # plt.figure(figsize = (12, 6))\n", + " # plot_pacf(values[round(i/2)], lags = 60)\n", + " # plt.title('Partial Autocorrelation Function (PACF)')\n", + " # plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "4c6cf92b-58fd-4642-81ee-d7af73c3e75f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===================================================\n", + "sequence length: 6\n", + "batch size: 10\n", + "no. of variables: 4\n", + "no. of predicted variables: 4\n", + "how many steps forward to predict: 1\n", + "===================================================\n", + "input shape (10, 6, 4)\n", + "output shape (10, 1, 4)\n" + ] + } + ], + "source": [ + "print (\"===================================================\")\n", + "print (\"sequence length: \", sl)\n", + "print (\"batch size: \", batch-cnt_thrown_idx)\n", + "print (\"no. of variables: \", n_features)\n", + "print (\"no. of predicted variables: \", n_out)\n", + "print (\"how many steps forward to predict: \", frwd)\n", + "print (\"===================================================\")\n", + "print (\"input shape\", X.shape)\n", + "print (\"output shape\", y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "4021e394-635b-4493-8a89-a658e1229325", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"sequential_26\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential_26\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ lstm_49 (LSTM)                  │ (None, 6, 64)          │        17,664 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ lstm_50 (LSTM)                  │ (None, 64)             │        33,024 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_17 (Dense)                │ (None, 4)              │           260 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ lstm_49 (\u001b[38;5;33mLSTM\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m17,664\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ lstm_50 (\u001b[38;5;33mLSTM\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m33,024\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_17 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m260\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 50,948 (199.02 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m50,948\u001b[0m (199.02 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 50,948 (199.02 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m50,948\u001b[0m (199.02 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n", + "1/1 - 4s - 4s/step - loss: 0.3775 - val_loss: 0.3479\n", + "Epoch 2/100\n", + "1/1 - 0s - 49ms/step - loss: 0.3665 - val_loss: 0.3377\n", + "Epoch 3/100\n", + "1/1 - 0s - 47ms/step - loss: 0.3560 - val_loss: 0.3281\n", + "Epoch 4/100\n", + "1/1 - 0s - 47ms/step - loss: 0.3460 - val_loss: 0.3187\n", + "Epoch 5/100\n", + "1/1 - 0s - 47ms/step - loss: 0.3363 - val_loss: 0.3096\n", + "Epoch 6/100\n", + "1/1 - 0s - 47ms/step - loss: 0.3269 - val_loss: 0.3005\n", + "Epoch 7/100\n", + "1/1 - 0s - 47ms/step - loss: 0.3174 - val_loss: 0.2917\n", + "Epoch 8/100\n", + "1/1 - 0s - 47ms/step - loss: 0.3080 - val_loss: 0.2827\n", + "Epoch 9/100\n", + "1/1 - 0s - 47ms/step - loss: 0.2985 - val_loss: 0.2733\n", + "Epoch 10/100\n", + "1/1 - 0s - 47ms/step - loss: 0.2887 - val_loss: 0.2634\n", + "Epoch 11/100\n", + "1/1 - 0s - 47ms/step - loss: 0.2784 - val_loss: 0.2530\n", + "Epoch 12/100\n", + "1/1 - 0s - 47ms/step - loss: 0.2675 - val_loss: 0.2420\n", + "Epoch 13/100\n", + "1/1 - 0s - 47ms/step - loss: 0.2559 - val_loss: 0.2305\n", + "Epoch 14/100\n", + "1/1 - 0s - 48ms/step - loss: 0.2439 - val_loss: 0.2182\n", + "Epoch 15/100\n", + "1/1 - 0s - 47ms/step - loss: 0.2310 - val_loss: 0.2050\n", + "Epoch 16/100\n", + "1/1 - 0s - 47ms/step - loss: 0.2172 - val_loss: 0.1910\n", + "Epoch 17/100\n", + "1/1 - 0s - 47ms/step - loss: 0.2025 - val_loss: 0.1760\n", + "Epoch 18/100\n", + "1/1 - 0s - 47ms/step - loss: 0.1868 - val_loss: 0.1600\n", + "Epoch 19/100\n", + "1/1 - 0s - 46ms/step - loss: 0.1700 - val_loss: 0.1432\n", + "Epoch 20/100\n", + "1/1 - 0s - 47ms/step - loss: 0.1523 - val_loss: 0.1255\n", + "Epoch 21/100\n", + "1/1 - 0s - 47ms/step - loss: 0.1336 - val_loss: 0.1071\n", + "Epoch 22/100\n", + "1/1 - 0s - 47ms/step - loss: 0.1141 - val_loss: 0.0882\n", + "Epoch 23/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0940 - val_loss: 0.0694\n", + "Epoch 24/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0740 - val_loss: 0.0514\n", + "Epoch 25/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0548 - val_loss: 0.0353\n", + "Epoch 26/100\n", + "1/1 - 0s - 46ms/step - loss: 0.0375 - val_loss: 0.0229\n", + "Epoch 27/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0240 - val_loss: 0.0165\n", + "Epoch 28/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0167 - val_loss: 0.0176\n", + "Epoch 29/100\n", + "1/1 - 0s - 46ms/step - loss: 0.0173 - val_loss: 0.0252\n", + "Epoch 30/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0249 - val_loss: 0.0333\n", + "Epoch 31/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0331 - val_loss: 0.0357\n", + "Epoch 32/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0356 - val_loss: 0.0314\n", + "Epoch 33/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0312 - val_loss: 0.0234\n", + "Epoch 34/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0229 - val_loss: 0.0147\n", + "Epoch 35/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0140 - val_loss: 0.0077\n", + "Epoch 36/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0070 - val_loss: 0.0033\n", + "Epoch 37/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0027 - val_loss: 0.0014\n", + "Epoch 38/100\n", + "1/1 - 0s - 47ms/step - loss: 9.7462e-04 - val_loss: 0.0014\n", + "Epoch 39/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0012 - val_loss: 0.0023\n", + "Epoch 40/100\n", + "1/1 - 0s - 46ms/step - loss: 0.0024 - val_loss: 0.0036\n", + "Epoch 41/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0040 - val_loss: 0.0048\n", + "Epoch 42/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0054 - val_loss: 0.0056\n", + "Epoch 43/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0063 - val_loss: 0.0060\n", + "Epoch 44/100\n", + "1/1 - 0s - 46ms/step - loss: 0.0068 - val_loss: 0.0058\n", + "Epoch 45/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0066 - val_loss: 0.0053\n", + "Epoch 46/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0061 - val_loss: 0.0045\n", + "Epoch 47/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0052 - val_loss: 0.0036\n", + "Epoch 48/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0042 - val_loss: 0.0027\n", + "Epoch 49/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0033 - val_loss: 0.0020\n", + "Epoch 50/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0025 - val_loss: 0.0016\n", + "Epoch 51/100\n", + "1/1 - 0s - 46ms/step - loss: 0.0020 - val_loss: 0.0015\n", + "Epoch 52/100\n", + "1/1 - 0s - 46ms/step - loss: 0.0018 - val_loss: 0.0016\n", + "Epoch 53/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0019 - val_loss: 0.0019\n", + "Epoch 54/100\n", + "1/1 - 0s - 46ms/step - loss: 0.0021 - val_loss: 0.0021\n", + "Epoch 55/100\n", + "1/1 - 0s - 46ms/step - loss: 0.0023 - val_loss: 0.0022\n", + "Epoch 56/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0024 - val_loss: 0.0022\n", + "Epoch 57/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0023 - val_loss: 0.0019\n", + "Epoch 58/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0020 - val_loss: 0.0015\n", + "Epoch 59/100\n", + "1/1 - 0s - 47ms/step - loss: 0.0015 - val_loss: 0.0011\n", + "Epoch 60/100\n", + "1/1 - 0s - 46ms/step - loss: 0.0011 - val_loss: 6.7669e-04\n", + "Epoch 61/100\n", + "1/1 - 0s - 46ms/step - loss: 6.8051e-04 - val_loss: 3.8524e-04\n", + "Epoch 62/100\n", + "1/1 - 0s - 47ms/step - loss: 3.9242e-04 - val_loss: 2.2256e-04\n", + "Epoch 63/100\n", + "1/1 - 0s - 47ms/step - loss: 2.4080e-04 - val_loss: 1.7843e-04\n", + "Epoch 64/100\n", + "1/1 - 0s - 47ms/step - loss: 2.1108e-04 - val_loss: 2.2081e-04\n", + "Epoch 65/100\n", + "1/1 - 0s - 47ms/step - loss: 2.6670e-04 - val_loss: 3.0922e-04\n", + "Epoch 66/100\n", + "1/1 - 0s - 47ms/step - loss: 3.6316e-04 - val_loss: 4.0596e-04\n", + "Epoch 67/100\n", + "1/1 - 0s - 47ms/step - loss: 4.5969e-04 - val_loss: 4.8350e-04\n", + "Epoch 68/100\n", + "1/1 - 0s - 47ms/step - loss: 5.2697e-04 - val_loss: 5.2768e-04\n", + "Epoch 69/100\n", + "1/1 - 0s - 47ms/step - loss: 5.5038e-04 - val_loss: 5.3742e-04\n", + "Epoch 70/100\n", + "1/1 - 0s - 47ms/step - loss: 5.2964e-04 - val_loss: 5.2177e-04\n", + "Epoch 71/100\n", + "1/1 - 0s - 47ms/step - loss: 4.7567e-04 - val_loss: 4.9559e-04\n", + "Epoch 72/100\n", + "1/1 - 0s - 47ms/step - loss: 4.0594e-04 - val_loss: 4.7460e-04\n", + "Epoch 73/100\n", + "1/1 - 0s - 46ms/step - loss: 3.3913e-04 - val_loss: 4.7086e-04\n", + "Epoch 74/100\n", + "1/1 - 0s - 47ms/step - loss: 2.9032e-04 - val_loss: 4.8965e-04\n", + "Epoch 75/100\n", + "1/1 - 0s - 47ms/step - loss: 2.6752e-04 - val_loss: 5.2833e-04\n", + "Epoch 76/100\n", + "1/1 - 0s - 47ms/step - loss: 2.7031e-04 - val_loss: 5.7745e-04\n", + "Epoch 77/100\n", + "1/1 - 0s - 46ms/step - loss: 2.9083e-04 - val_loss: 6.2387e-04\n", + "Epoch 78/100\n", + "1/1 - 0s - 47ms/step - loss: 3.1684e-04 - val_loss: 6.5473e-04\n", + "Epoch 79/100\n", + "1/1 - 0s - 47ms/step - loss: 3.3584e-04 - val_loss: 6.6121e-04\n", + "Epoch 80/100\n", + "1/1 - 0s - 47ms/step - loss: 3.3892e-04 - val_loss: 6.4073e-04\n", + "Epoch 81/100\n", + "1/1 - 0s - 47ms/step - loss: 3.2300e-04 - val_loss: 5.9708e-04\n", + "Epoch 82/100\n", + "1/1 - 0s - 49ms/step - loss: 2.9110e-04 - val_loss: 5.3859e-04\n", + "Epoch 83/100\n", + "1/1 - 0s - 47ms/step - loss: 2.5049e-04 - val_loss: 4.7530e-04\n", + "Epoch 84/100\n", + "1/1 - 0s - 47ms/step - loss: 2.0993e-04 - val_loss: 4.1616e-04\n", + "Epoch 85/100\n", + "1/1 - 0s - 46ms/step - loss: 1.7687e-04 - val_loss: 3.6708e-04\n", + "Epoch 86/100\n", + "1/1 - 0s - 47ms/step - loss: 1.5554e-04 - val_loss: 3.3027e-04\n", + "Epoch 87/100\n", + "1/1 - 0s - 47ms/step - loss: 1.4645e-04 - val_loss: 3.0470e-04\n", + "Epoch 88/100\n", + "1/1 - 0s - 47ms/step - loss: 1.4697e-04 - val_loss: 2.8734e-04\n", + "Epoch 89/100\n", + "1/1 - 0s - 47ms/step - loss: 1.5275e-04 - val_loss: 2.7467e-04\n", + "Epoch 90/100\n", + "1/1 - 0s - 47ms/step - loss: 1.5925e-04 - val_loss: 2.6381e-04\n", + "Epoch 91/100\n", + "1/1 - 0s - 46ms/step - loss: 1.6302e-04 - val_loss: 2.5326e-04\n", + "Epoch 92/100\n", + "1/1 - 0s - 47ms/step - loss: 1.6244e-04 - val_loss: 2.4302e-04\n", + "Epoch 93/100\n", + "1/1 - 0s - 47ms/step - loss: 1.5774e-04 - val_loss: 2.3417e-04\n", + "Epoch 94/100\n", + "1/1 - 0s - 47ms/step - loss: 1.5060e-04 - val_loss: 2.2821e-04\n", + "Epoch 95/100\n", + "1/1 - 0s - 47ms/step - loss: 1.4331e-04 - val_loss: 2.2631e-04\n", + "Epoch 96/100\n", + "1/1 - 0s - 47ms/step - loss: 1.3798e-04 - val_loss: 2.2878e-04\n", + "Epoch 97/100\n", + "1/1 - 0s - 47ms/step - loss: 1.3583e-04 - val_loss: 2.3486e-04\n", + "Epoch 98/100\n", + "1/1 - 0s - 47ms/step - loss: 1.3695e-04 - val_loss: 2.4290e-04\n", + "Epoch 99/100\n", + "1/1 - 0s - 47ms/step - loss: 1.4039e-04 - val_loss: 2.5078e-04\n", + "Epoch 100/100\n", + "1/1 - 0s - 47ms/step - loss: 1.4456e-04 - val_loss: 2.5656e-04\n" + ] + } + ], + "source": [ + "n_steps = sl\n", + "\n", + "model_2f = Sequential()\n", + "model_2f.add(tf.keras.layers.Input(shape = (n_steps, n_features)))\n", + "model_2f.add(tf.keras.layers.LSTM(units = 64, activation = 'relu', return_sequences = True)) \n", + "model_2f.add(tf.keras.layers.LSTM(units = 64, activation = 'relu', return_sequences = False)) \n", + "\n", + "model_2f.add(tf.keras.layers.Dense(units = n_out))\n", + "\n", + "\n", + "model_2f.compile(optimizer = 'adam', loss = 'mean_squared_error')\n", + "model_2f.summary()\n", + "\n", + "\n", + "# fit model\n", + "# The number of epochs is the number of complete passes through the training dataset\n", + "history = model_2f.fit(X, y, epochs = 100, \n", + " validation_split = 0.2,\n", + " verbose = 2)\n", + " # , callbacks=[es])\n", + " # , callbacks = [TimeStepErrorLogger()])" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "1e40d38e-3eb1-4b9d-8d2a-8ec6a6a56f38", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input shape (10, 16, 2)\n", + "output shape (10, 1, 2)\n" + ] + } + ], + "source": [ + "print (\"input shape\", X.shape)\n", + "print (\"output shape\", y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "badacf02-562c-495a-8d62-374545da5804", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a figure and axis object\n", + "fig, ax = plt.subplots(1, 1)\n", + "\n", + "# Plot the data\n", + "ax.plot(history.history['loss'], 'blue')\n", + "ax.plot(history.history['val_loss'], 'red')\n", + "\n", + "# Customize the plot\n", + "ax.set_title('Model Loss (blue) vs Val. Loss (red)')\n", + "ax.set_xlabel('Epoch')\n", + "ax.set_ylabel('Loss')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "d08d10b3-a984-4dec-b1af-e29a9e937626", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract weights from the LSTM layer\n", + "lstm_layer = model_2f.layers[0]\n", + "lstm_weights = lstm_layer.get_weights()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "1f7cdb81-3ea1-467d-8492-fbdc469a4039", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kernel shape: (2, 96)\n", + "Recurrent Kernel shape: (24, 96)\n", + "Bias shape: (96,)\n" + ] + } + ], + "source": [ + "kernel, recurrent_kernel, bias = lstm_weights\n", + "\n", + "# Print the shapes\n", + "print(f\"Kernel shape: {kernel.shape}\")\n", + "print(f\"Recurrent Kernel shape: {recurrent_kernel.shape}\")\n", + "print(f\"Bias shape: {bias.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5be4cb34-6a95-426f-b08f-1c26fcfdaa90", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kernel weights: [[-0.14694473 -0.2149557 0.21574722 -0.03168026 -0.2404067 0.00060298\n", + " 0.17182997 0.00421425 -0.06863409 0.22241846 0.0680408 0.2418472\n", + " -0.12803034 -0.15664381 0.15597875 -0.06085367 0.31251866 -0.02795665\n", + " -0.03430395 0.17601249 -0.14519325 -0.2162165 0.1255817 -0.08926678\n", + " -0.12125828 0.01932479 -0.12725121 0.2553787 -0.20190533 -0.19571888\n", + " 0.19269451 -0.15448165 0.00514798 0.05390324 -0.06658281 -0.23524462\n", + " 0.03737664 0.20991202 -0.0054796 0.13213603 0.16205935 -0.01213002\n", + " 0.1249122 0.08729742 0.23968889 0.22381271 0.22225435 0.14512493\n", + " 0.28880545 -0.1228936 -0.15207523 0.08161885 -0.1339008 -0.13070342\n", + " 0.24040265 0.17981866 -0.20574768 0.20776649 0.02432974 -0.14321205\n", + " 0.13607569 -0.19716436 -0.16750313 0.23942116 0.18560551 0.1364063\n", + " 0.12954217 0.06407089 -0.19326611 -0.05672123 -0.03679872 -0.06065868\n", + " 0.2761794 -0.1028993 0.10128753 -0.03650422 0.19155361 0.1891764\n", + " 0.21571362 -0.10350706 0.1532831 -0.1285459 -0.05763114 -0.00507711\n", + " -0.08422921 0.1560979 -0.11944492 0.23335452 0.23056944 0.21127014\n", + " 0.07350815 -0.01996051 0.08705227 0.21876277 -0.18549427 0.197928 ]\n", + " [ 0.26203096 0.12240998 0.24058907 -0.09778985 0.19834791 0.10873221\n", + " 0.16476503 0.16783768 0.036851 0.10429716 0.04640302 0.2418495\n", + " -0.10726697 -0.19560209 -0.20697165 0.00630637 0.01057402 -0.08481433\n", + " -0.05003158 0.1952445 0.08110683 0.20927776 0.08692156 0.24042912\n", + " 0.25072643 0.1847647 0.1954032 0.12657973 -0.11109175 0.17831136\n", + " -0.11111107 -0.19023757 0.17980568 -0.16693711 0.16857032 -0.15084457\n", + " -0.15376592 0.20926367 0.04831796 0.20594598 0.0991715 0.28390962\n", + " -0.11456122 0.16153586 0.01970394 0.18575267 0.06581433 -0.22094718\n", + " -0.1586191 -0.11394337 0.00179346 -0.11634386 0.04116417 0.15990387\n", + " -0.03459395 -0.24665378 0.05317496 -0.0924813 0.18609585 -0.10262136\n", + " 0.01094547 -0.10844027 0.10128119 0.09482033 0.01047933 -0.01082687\n", + " 0.11301377 0.2715998 -0.05260633 -0.20140713 -0.09439795 -0.0901483\n", + " 0.00599721 0.18204151 0.2442772 0.20379005 -0.14100784 0.07093702\n", + " 0.21719107 0.00733359 0.01349489 0.18499427 0.27750826 0.24083222\n", + " -0.21442056 0.23683076 0.07468879 0.30029342 0.02205097 0.14139593\n", + " 0.04972949 -0.1360935 -0.18753073 -0.09531116 -0.01884812 -0.1299744 ]]\n", + "Recurrent kernel weights: [[-0.01517656 0.1375877 -0.06416896 ... 0.00074398 0.17237714\n", + " -0.15113147]\n", + " [ 0.25785878 -0.04419266 0.00638575 ... 0.00293989 0.10673533\n", + " -0.0980736 ]\n", + " [ 0.22084515 -0.03020044 -0.17384924 ... 0.05369796 0.02574822\n", + " -0.10007842]\n", + " ...\n", + " [-0.05204705 -0.04770876 -0.07243105 ... -0.08166026 -0.03370833\n", + " -0.20000169]\n", + " [ 0.0614294 0.15823954 0.04897207 ... -0.17869669 0.00265792\n", + " -0.04954483]\n", + " [ 0.09174671 0.00046977 0.2106277 ... 0.00700023 -0.15859836\n", + " 0.05801002]]\n", + "Bias weights: [ 7.4678138e-02 0.0000000e+00 0.0000000e+00 2.6737887e-02\n", + " 0.0000000e+00 0.0000000e+00 7.7817202e-02 -1.3005517e-02\n", + " 0.0000000e+00 -6.2749349e-04 7.8569911e-02 -2.2737358e-03\n", + " -3.8393803e-02 -2.2382624e-03 2.3661956e-02 7.6413356e-02\n", + " 7.3369220e-02 9.0766929e-02 -3.4188893e-02 8.0341838e-02\n", + " 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n", + " 1.0681593e+00 1.0000000e+00 1.0000000e+00 1.0165220e+00\n", + " 1.0000000e+00 1.0000000e+00 1.0604813e+00 9.8689413e-01\n", + " 1.0000000e+00 9.8318946e-01 1.0598619e+00 1.0000000e+00\n", + " 9.6168667e-01 1.0000000e+00 1.0188148e+00 1.0588562e+00\n", + " 1.0536528e+00 1.0676780e+00 9.6711385e-01 1.0490637e+00\n", + " 1.0000000e+00 1.0000000e+00 1.0000000e+00 1.0000000e+00\n", + " 8.3460465e-02 0.0000000e+00 0.0000000e+00 4.3994829e-02\n", + " 0.0000000e+00 0.0000000e+00 6.6631623e-02 -1.5223692e-02\n", + " 0.0000000e+00 1.1426008e-02 6.5101713e-02 -1.6715661e-02\n", + " -5.3329937e-02 -1.1888843e-02 2.0905571e-02 6.6886052e-02\n", + " 6.5841772e-02 7.0495069e-02 -3.9093327e-02 7.4364722e-02\n", + " 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n", + " 7.5314201e-02 0.0000000e+00 0.0000000e+00 2.6895128e-02\n", + " 0.0000000e+00 0.0000000e+00 7.8255147e-02 -1.3008333e-02\n", + " 0.0000000e+00 -6.8368547e-04 7.7843674e-02 -2.3535045e-03\n", + " -3.8584907e-02 -1.8483091e-03 2.3716228e-02 7.6190464e-02\n", + " 7.3574908e-02 9.0011276e-02 -3.4145214e-02 8.0686800e-02\n", + " 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00]\n" + ] + } + ], + "source": [ + "# Print the weights\n", + "print(\"Kernel weights:\", kernel)\n", + "print(\"Recurrent kernel weights:\", recurrent_kernel)\n", + "print(\"Bias weights:\", bias)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb2a2814-070a-40e4-b909-a18698b0b848", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "7ab3f50a-cf41-4307-b34b-17b0614504e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sample_size: 5345\n", + "[2705 2304 2028 3132 245 3235]\n", + "XXXX ====== Actual Input ====== XXXX\n", + "[[[0.5233 0.383067 0.8573 0.7105592]\n", + " [0.5235 0.383102 0.8574 0.7105005]\n", + " [0.5243 0.383687 0.8538 0.710517 ]\n", + " [0.5239 0.383284 0.8528 0.7100418]\n", + " [0.5238 0.382979 0.8526 0.7097535]\n", + " [0.5229 0.3827 0.8522 0.7088585]]\n", + "\n", + " [[0.4988 0.367839 0.8013 0.693467 ]\n", + " [0.4988 0.367874 0.801 0.6934189]\n", + " [0.4988 0.367842 0.801 0.6933052]\n", + " [0.4988 0.367842 0.8013 0.6929601]\n", + " [0.4987 0.36782 0.8014 0.6931277]\n", + " [0.4989 0.367874 0.8014 0.6932936]]\n", + "\n", + " [[0.5228 0.382313 0.8426 0.7126844]\n", + " [0.5227 0.382009 0.8424 0.7121888]\n", + " [0.5225 0.381963 0.842 0.7122303]\n", + " [0.5226 0.381978 0.8422 0.7124799]\n", + " [0.5224 0.381945 0.8419 0.7124184]\n", + " [0.5225 0.381966 0.8419 0.7123872]]\n", + "\n", + " [[0.4931 0.368402 0.7943 0.6936869]\n", + " [0.4932 0.368171 0.7941 0.6934014]\n", + " [0.4973 0.369449 0.8 0.694914 ]\n", + " [0.4972 0.369305 0.7997 0.6946885]\n", + " [0.497 0.369176 0.7992 0.6945709]\n", + " [0.4965 0.368981 0.7983 0.6943933]]\n", + "\n", + " [[0.4939 0.369107 0.798 0.6948025]\n", + " [0.494 0.369145 0.797 0.6947044]\n", + " [0.4938 0.368975 0.7969 0.6946416]\n", + " [0.4936 0.368882 0.7966 0.6946453]\n", + " [0.4937 0.368987 0.797 0.6948034]\n", + " [0.4937 0.36885 0.7966 0.6946897]]\n", + "\n", + " [[0.4998 0.368504 0.8036 0.6940102]\n", + " [0.4987 0.368769 0.8021 0.6940389]\n", + " [0.5 0.368602 0.8042 0.6940193]\n", + " [0.4998 0.368501 0.8039 0.6938383]\n", + " [0.5 0.368537 0.804 0.6940189]\n", + " [0.5002 0.368528 0.8039 0.6939844]]]\n", + "(6, 6, 4)\n", + "YYYY ====== Actual Input ====== YYYY\n", + "[[[0.5233 0.382751 0.8576 0.7103601]]\n", + "\n", + " [[0.4987 0.367886 0.8014 0.693385 ]]\n", + "\n", + " [[0.5223 0.381907 0.8415 0.7122137]]\n", + "\n", + " [[0.4925 0.368111 0.794 0.6931971]]\n", + "\n", + " [[0.4937 0.368967 0.7971 0.6947576]]\n", + "\n", + " [[0.5 0.368552 0.8041 0.6938843]]]\n", + "(6, 1, 4)\n" + ] + } + ], + "source": [ + "# Validation Set - 06.20.2024\n", + "# ============================\n", + "# Reset Index\n", + "sample_valid = sample_valid.reset_index(drop = True)\n", + "sample_size = sample_valid.shape[0]\n", + "print ('sample_size: ', sample_size)\n", + "# sample_valid.head()\n", + "# sl = 8 # <--- sequence length\n", + "batch_valid = 6 # <--- batch size\n", + "# n_features = 8 # <---- no. of variables\n", + "# n_out = 1 # <----- no. of predicted variables\n", + "# frwd = 1 # <--- how many to predict\n", + "\n", + "# Trimming Indices !!!\n", + "# Marking selected rows\n", + "sample_valid['Selected'] = 0\n", + "\n", + "# Selecting m random rows without replacement\n", + "np.random.seed(374)\n", + "selected_indices = np.random.choice(sample_valid.index, size = batch_valid, replace = False)\n", + "\n", + "sample_valid.loc[selected_indices, 'Selected'] = 1 # print (sample_valid[sample_valid['Selected'] == 1])\n", + "chosen_idx1 = sample_valid[sample_valid['Selected'] == 1].index\n", + "chosen_idx2 = chosen_idx1[chosen_idx1 > sl]\n", + "\n", + "thrown_idx1 = chosen_idx1[chosen_idx1 <= sl]\n", + "cnt_thrown_idx1 = len(thrown_idx1)\n", + "\n", + "chosen_idx3 = chosen_idx2[chosen_idx2 < (sample_size - frwd)]\n", + "\n", + "thrown_idx2 = chosen_idx2[chosen_idx2 >= (sample_size - frwd)]\n", + "cnt_thrown_idx2 = len(thrown_idx2)\n", + "\n", + "cnt_thrown_idx = cnt_thrown_idx1 + cnt_thrown_idx2\n", + "\n", + "print (selected_indices)\n", + "\n", + "all_ts_close_xrp = np.empty((1, )) # final input/output\n", + "all_ts_close_eth = np.empty((1, )) # final input/output\n", + "all_ts_close_ltc = np.empty((1, )) # final input/output\n", + "all_ts_close_btc = np.empty((1, )) # final input/output\n", + "\n", + "all_ts_volume_xrp = np.empty((1, )) # final input/output\n", + "all_ts_volume_eth = np.empty((1, )) # final input/output\n", + "all_ts_volume_ltc = np.empty((1, )) # final input/output\n", + "all_ts_volume_btc = np.empty((1, )) # final input/output\n", + "\n", + "stdev_xrp = np.empty((1, )) # final input/output\n", + "stdev_eth = np.empty((1, )) # final input/output\n", + "stdev_ltc = np.empty((1, )) # final input/output\n", + "stdev_btc = np.empty((1, )) # final input/output\n", + "\n", + "\n", + "aft_ts_close_xrp = np.empty((1))\n", + "aft_ts_close_eth = np.empty((1))\n", + "aft_ts_close_ltc = np.empty((1))\n", + "aft_ts_close_btc = np.empty((1))\n", + "\n", + "for idx in chosen_idx3:\n", + " selected_rows_before = sample_valid.iloc[max(0, idx-sl): idx]\n", + " selected_rows_after = sample_valid.iloc[max(0, idx): idx+frwd]\n", + "\n", + " # xrp\n", + " sr_before_close_xrp = np.array(selected_rows_before['close_xrp'])\n", + " sr_after_close_xrp = np.array(selected_rows_after['close_xrp']) \n", + " # print (sr_before_close_xrp)\n", + " sr_before_volume_xrp = np.array(selected_rows_before['volume_xrp'])\n", + " sr_after_volume_xrp = np.array(selected_rows_after['volume_xrp']) \n", + " # print (sr_before_volume_xrp) \n", + " # Compute standard deviation\n", + " std_dev_xrp = np.std(sr_before_close_xrp)\n", + " std_dev_xrp_arr = np.repeat(std_dev_xrp, sl)\n", + " # print(std_dev_xrp_arr)\n", + " \n", + "# eth\n", + " sr_before_close_eth = np.array(selected_rows_before['close_eth'])\n", + " sr_after_close_eth = np.array(selected_rows_after['close_eth'])\n", + " sr_before_volume_eth = np.array(selected_rows_before['volume_eth'])\n", + " sr_after_volume_eth = np.array(selected_rows_after['volume_eth'])\n", + " # Compute standard deviation\n", + " std_dev_eth = np.std(sr_before_close_eth)\n", + " std_dev_eth_arr = np.repeat(std_dev_eth, sl)\n", + " # print(std_dev_eth_arr)\n", + " \n", + "# ltc\n", + " sr_before_close_ltc = np.array(selected_rows_before['close_ltc'])\n", + " sr_after_close_ltc = np.array(selected_rows_after['close_ltc'])\n", + " sr_before_volume_ltc = np.array(selected_rows_before['volume_ltc'])\n", + " sr_after_volume_ltc = np.array(selected_rows_after['volume_ltc'])\n", + "# Compute standard deviation\n", + " std_dev_ltc = np.std(sr_before_close_ltc)\n", + " std_dev_ltc_arr = np.repeat(std_dev_ltc, sl)\n", + " # print(std_dev_ltc_arr)\n", + "\n", + "# btc\n", + " sr_before_close_btc = np.array(selected_rows_before['close_btc'])\n", + " sr_after_close_btc = np.array(selected_rows_after['close_btc'])\n", + " sr_before_volume_btc = np.array(selected_rows_before['volume_btc'])\n", + " sr_after_volume_btc = np.array(selected_rows_after['volume_btc'])\n", + " # Compute standard deviation\n", + " std_dev_btc = np.std(sr_before_close_btc)\n", + " std_dev_btc_arr = np.repeat(std_dev_btc, sl)\n", + " # print(std_dev_btc_arr)\n", + "\n", + "# xrp\n", + " all_ts_close_xrp = np.concatenate((all_ts_close_xrp, sr_before_close_xrp))\n", + " all_ts_volume_xrp = np.concatenate((all_ts_volume_xrp, sr_before_volume_xrp))\n", + " stdev_xrp = np.concatenate((stdev_xrp, std_dev_xrp_arr))\n", + "# eth\n", + " all_ts_close_eth = np.concatenate((all_ts_close_eth, sr_before_close_eth))\n", + " all_ts_volume_eth = np.concatenate((all_ts_volume_eth, sr_before_volume_eth))\n", + " stdev_eth = np.concatenate((stdev_eth, std_dev_eth_arr))\n", + "# ltc\n", + " all_ts_close_ltc = np.concatenate((all_ts_close_ltc, sr_before_close_ltc))\n", + " all_ts_volume_ltc = np.concatenate((all_ts_volume_ltc, sr_before_volume_ltc))\n", + " stdev_ltc = np.concatenate((stdev_ltc, std_dev_ltc_arr))\n", + "# btc\n", + " all_ts_close_btc = np.concatenate((all_ts_close_btc, sr_before_close_btc))\n", + " all_ts_volume_btc = np.concatenate((all_ts_volume_btc, sr_before_volume_btc))\n", + " stdev_btc = np.concatenate((stdev_btc, std_dev_btc_arr))\n", + "\n", + "\n", + " aft_ts_close_xrp = np.concatenate((aft_ts_close_xrp, sr_after_close_xrp))\n", + " aft_ts_close_eth = np.concatenate((aft_ts_close_eth, sr_after_close_eth))\n", + " aft_ts_close_ltc = np.concatenate((aft_ts_close_ltc, sr_after_close_ltc))\n", + " aft_ts_close_btc = np.concatenate((aft_ts_close_btc, sr_after_close_btc))\n", + "\n", + "\n", + "X_XRP_close = all_ts_close_xrp[1:]\n", + "X_XRP_volume = all_ts_volume_xrp[1:]\n", + "X_XRP_stdev = stdev_xrp[1:]\n", + "\n", + "\n", + "X_ETH_close = all_ts_close_eth[1:]\n", + "X_ETH_volume = all_ts_volume_eth[1:]\n", + "X_ETH_stdev = stdev_eth[1:]\n", + "\n", + "X_LTC_close = all_ts_close_ltc[1:]\n", + "X_LTC_volume = all_ts_volume_ltc[1:]\n", + "X_LTC_stdev = stdev_ltc[1:]\n", + "\n", + "X_BTC_close = all_ts_close_btc[1:]\n", + "X_BTC_volume = all_ts_volume_btc[1:]\n", + "X_BTC_stdev = stdev_btc[1:]\n", + "\n", + "# print (X0)\n", + "\n", + "X0_valid = np.column_stack((X_XRP_close,\n", + " X_ETH_close,\n", + " X_LTC_close,\n", + " X_BTC_close\n", + " ))\n", + "\n", + "# ======== Model Input =========\n", + "X_valid = X0_valid.reshape(batch_valid-cnt_thrown_idx, sl, n_features)\n", + "print ('XXXX ====== Actual Input ====== XXXX')\n", + "print (X_valid)\n", + "print (X_valid.shape)\n", + "\n", + "\n", + "y_XRP = aft_ts_close_xrp[1:]\n", + "y_ETH = aft_ts_close_eth[1:]\n", + "y_LTC = aft_ts_close_ltc[1:]\n", + "y_BTC = aft_ts_close_btc[1:]\n", + "\n", + "y0_valid = np.column_stack((y_XRP, y_ETH, y_LTC, y_BTC))\n", + "# print (y0)\n", + "\n", + "y_valid = y0_valid.reshape(batch_valid-cnt_thrown_idx, frwd, n_out)\n", + "print ('YYYY ====== Actual Input ====== YYYY')\n", + "print (y_valid)\n", + "print (y_valid.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "id": "263e1cab-3b94-49e2-a278-fa0336867310", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y_valid\n", + "\n", + "(6, 4)\n", + "[[0.5233 0.382751 0.8576 0.7103601]\n", + " [0.4987 0.367886 0.8014 0.693385 ]\n", + " [0.5223 0.381907 0.8415 0.7122137]\n", + " [0.4925 0.368111 0.794 0.6931971]\n", + " [0.4937 0.368967 0.7971 0.6947576]\n", + " [0.5 0.368552 0.8041 0.6938843]]\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n", + "y_hat\n", + "\n", + "(6, 4)\n", + "[[0.52473974 0.38107908 0.8461987 0.7331535 ]\n", + " [0.5036733 0.36514583 0.80844265 0.70000196]\n", + " [0.523268 0.37977216 0.8430245 0.7305254 ]\n", + " [0.5026271 0.36427632 0.80654866 0.6983792 ]\n", + " [0.50249064 0.36416662 0.80624986 0.6981052 ]\n", + " [0.50450474 0.36577496 0.80995065 0.7013234 ]]\n" + ] + } + ], + "source": [ + "y_valid = y_valid.reshape(batch_valid-cnt_thrown_idx, n_out)\n", + "print ('y_valid')\n", + "print (type(y_valid))\n", + "print (y_valid.shape)\n", + "print (y_valid)\n", + "# print (y_valid[0:10])\n", + "\n", + "y_hat = model_2f.predict(X_valid, verbose = 1)\n", + "# .reshape(batch_valid-cnt_thrown_idx, frwd)\n", + "# print (sl)\n", + "\n", + "\n", + "print ('y_hat')\n", + "print (type(y_hat))\n", + "print (y_hat.shape)\n", + "print (y_hat)\n", + "# y_ht1 = y_hat.reshape(batch-cnt_thrown_idx, frwd)\n", + "# # print (y_hat[0:10])\n", + "# print (y_ht1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93784fe7-754c-42f7-b03f-2b1ed5f22e32", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 170, + "id": "a0002571-14aa-4f19-8fe3-70b384921398", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.5233 0.382751 0.8576 0.7103601]\n", + "[0.52473974 0.38107908 0.8461987 0.7331535 ]\n" + ] + } + ], + "source": [ + "print (y_valid[0])\n", + "print (y_hat[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "520c5fbf-3f16-46d1-b265-b7ce7bf30fbb", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 189, + "id": "7ece23e6-d5dc-4795-9bed-c579d560efa2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " XRP ETH LTC BTC\n", + "0 0.5233 0.383067 0.8573 0.710559\n", + "1 0.5235 0.383102 0.8574 0.710500\n", + "2 0.5243 0.383687 0.8538 0.710517\n", + "3 0.5239 0.383284 0.8528 0.710042\n", + "4 0.5238 0.382979 0.8526 0.709754\n", + "5 0.5229 0.382700 0.8522 0.708859\n", + "6 0.5233 0.382751 0.8576 0.710360\n", + " XRP ETH LTC BTC\n", + "0 0.52330 0.383067 0.857300 0.710559\n", + "1 0.52350 0.383102 0.857400 0.710500\n", + "2 0.52430 0.383687 0.853800 0.710517\n", + "3 0.52390 0.383284 0.852800 0.710042\n", + "4 0.52380 0.382979 0.852600 0.709754\n", + "5 0.52290 0.382700 0.852200 0.708859\n", + "6 0.52474 0.381079 0.846199 0.733154\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " XRP ETH LTC BTC\n", + "0 0.4988 0.367839 0.8013 0.693467\n", + "1 0.4988 0.367874 0.8010 0.693419\n", + "2 0.4988 0.367842 0.8010 0.693305\n", + "3 0.4988 0.367842 0.8013 0.692960\n", + "4 0.4987 0.367820 0.8014 0.693128\n", + "5 0.4989 0.367874 0.8014 0.693294\n", + "6 0.4987 0.367886 0.8014 0.693385\n", + " XRP ETH LTC BTC\n", + "0 0.498800 0.367839 0.801300 0.693467\n", + "1 0.498800 0.367874 0.801000 0.693419\n", + "2 0.498800 0.367842 0.801000 0.693305\n", + "3 0.498800 0.367842 0.801300 0.692960\n", + "4 0.498700 0.367820 0.801400 0.693128\n", + "5 0.498900 0.367874 0.801400 0.693294\n", + "6 0.503673 0.365146 0.808443 0.700002\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " XRP ETH LTC BTC\n", + "0 0.5228 0.382313 0.8426 0.712684\n", + "1 0.5227 0.382009 0.8424 0.712189\n", + "2 0.5225 0.381963 0.8420 0.712230\n", + "3 0.5226 0.381978 0.8422 0.712480\n", + "4 0.5224 0.381945 0.8419 0.712418\n", + "5 0.5225 0.381966 0.8419 0.712387\n", + "6 0.5223 0.381907 0.8415 0.712214\n", + " XRP ETH LTC BTC\n", + "0 0.522800 0.382313 0.842600 0.712684\n", + "1 0.522700 0.382009 0.842400 0.712189\n", + "2 0.522500 0.381963 0.842000 0.712230\n", + "3 0.522600 0.381978 0.842200 0.712480\n", + "4 0.522400 0.381945 0.841900 0.712418\n", + "5 0.522500 0.381966 0.841900 0.712387\n", + "6 0.523268 0.379772 0.843024 0.730525\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " XRP ETH LTC BTC\n", + "0 0.4931 0.368402 0.7943 0.693687\n", + "1 0.4932 0.368171 0.7941 0.693401\n", + "2 0.4973 0.369449 0.8000 0.694914\n", + "3 0.4972 0.369305 0.7997 0.694689\n", + "4 0.4970 0.369176 0.7992 0.694571\n", + "5 0.4965 0.368981 0.7983 0.694393\n", + "6 0.4925 0.368111 0.7940 0.693197\n", + " XRP ETH LTC BTC\n", + "0 0.493100 0.368402 0.794300 0.693687\n", + "1 0.493200 0.368171 0.794100 0.693401\n", + "2 0.497300 0.369449 0.800000 0.694914\n", + "3 0.497200 0.369305 0.799700 0.694689\n", + "4 0.497000 0.369176 0.799200 0.694571\n", + "5 0.496500 0.368981 0.798300 0.694393\n", + "6 0.502627 0.364276 0.806549 0.698379\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " XRP ETH LTC BTC\n", + "0 0.4939 0.369107 0.7980 0.694802\n", + "1 0.4940 0.369145 0.7970 0.694704\n", + "2 0.4938 0.368975 0.7969 0.694642\n", + "3 0.4936 0.368882 0.7966 0.694645\n", + "4 0.4937 0.368987 0.7970 0.694803\n", + "5 0.4937 0.368850 0.7966 0.694690\n", + "6 0.4937 0.368967 0.7971 0.694758\n", + " XRP ETH LTC BTC\n", + "0 0.493900 0.369107 0.79800 0.694802\n", + "1 0.494000 0.369145 0.79700 0.694704\n", + "2 0.493800 0.368975 0.79690 0.694642\n", + "3 0.493600 0.368882 0.79660 0.694645\n", + "4 0.493700 0.368987 0.79700 0.694803\n", + "5 0.493700 0.368850 0.79660 0.694690\n", + "6 0.502491 0.364167 0.80625 0.698105\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAHHCAYAAACfqw0dAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5DUlEQVR4nO3deXxU1f3/8dedSSYbCSFAFiImLLIXkAAxoODComirlRYErAgKiiDbr4hUC6hsiiLWUih+i1gVsUpVKEhEEBAIiyCu7FvYEkAgIQvJZOb+/kgyGpPAJCSZLO/n4zGPzNx77rmf+RCST+4594xhmqaJiIiIiJSIxdMBiIiIiFRFKqJERERESkFFlIiIiEgpqIgSERERKQUVUSIiIiKloCJKREREpBRURImIiIiUgoooERERkVJQESUiIiJSCiqiRKTSW79+PYZhsH79ek+H4hGV+f1X5thEypuKKJEaYvHixRiGUeARGhrKbbfdxqeffupq9/DDDxdqV9Tj4Ycfdh3z0Ucfcdddd1GvXj1sNhsNGjSgX79+rFu3rth4SnOeyiQ7O5vXXnuNG2+8kaCgIIKDg2ndujXDhw9n7969ng7vmv36+8XX15dmzZoxatQokpOTy+Qcq1atYurUqWXSl4gneHk6ABGpWM8//zyNGjXCNE2Sk5NZvHgxffr0YcWKFdxzzz089thj9OjRw9X+yJEjTJ48meHDh3PLLbe4tjdp0gTTNBk6dCiLFy/mxhtvZPz48YSHh3P69Gk++ugj7rjjDjZv3kyXLl0KxVGS88TGxpKZmYnNZiunrJRc3759+fTTTxkwYADDhg3Dbrezd+9e/ve//9GlSxdatGhRZufq1q2bx95//vfL5cuX2bRpE/Pnz2fVqlV8//33+Pv7X1Pfq1atYt68eSqkpOoyRaRGePPNN03A3LFjR4Ht58+fN729vc2BAwcWedyOHTtMwHzzzTcL7Zs9e7YJmGPHjjWdTmeh/f/+97/Nbdu2uRXflc5T2Wzfvt0EzOnTpxfal5OTY547d65MzpOZmWk6HI4y6aukivt+GT9+vAmYS5YsMU3TNL/44gsTML/44osSn2PkyJGmfg1JVabhPJEaLjg4GD8/P7y8SnZhOjMzk5kzZ9KiRQtefvllDMMo1OZPf/oTnTt3vuYYi5p3c+utt9KmTRu+/fZbunfvjr+/P02bNuXDDz8EYMOGDcTGxuLn50fz5s35/PPPC/V78uRJhg4dSlhYGD4+PrRu3ZpFixZdNZ5Dhw4B0LVr10L7rFYrdevWLfF58t/j0qVLefbZZ4mMjMTf35/U1NRi5x1t27aNO++8k9q1a+Pv70/37t3ZvHlzgTaXLl1i7NixREdH4+PjQ2hoKD179mTXrl1XfZ9Fuf3224HcK4dX8sEHHxATE4Ofnx/16tXjwQcf5OTJk679Dz/8MPPmzQMoMGwoUpVoOE+khklJSeHcuXOYpsmZM2d4/fXXSUtL48EHHyxRP5s2beL8+fOMHTsWq9VaTtFe2YULF7jnnnt44IEH+OMf/8j8+fN54IEHePfddxk7diyPP/44AwcOZPbs2fzhD3/g+PHjBAYGApCcnMxNN92EYRiMGjWK+vXr8+mnn/LII4+QmprK2LFjiz1vVFQUAO+++y5du3a9YgFa0vO88MIL2Gw2/vznP5OVlVXsEN66deu46667iImJYcqUKVgsFt58801uv/12vvzyS1fx+vjjj/Phhx8yatQoWrVqxU8//cSmTZvYs2cPHTp0KEG2c+UXkL8uFH9p8eLFDBkyhE6dOjFz5kySk5N57bXX2Lx5M19//TXBwcE89thjnDp1ijVr1vD222+XOA6RSsHTl8JEpGLkD8/8+uHj42MuXry42OOKG2Z77bXXTMD86KOPyiS+Kw3nFTVk1L179wLDSqZpmnv37jUB02KxmFu3bnVtj4+PL9T3I488YkZERBQaenvggQfM2rVrmxkZGcXG6nQ6XecPCwszBwwYYM6bN888duxYobbunif/PTZu3LjQuX/9/p1Op3nDDTeYvXv3LjCMmpGRYTZq1Mjs2bOna1vt2rXNkSNHFvteipP//fL555+bZ8+eNY8fP24uXbrUrFu3runn52eeOHGiyNiys7PN0NBQs02bNmZmZqarv//9738mYE6ePNm1TcN5UtVpOE+khpk3bx5r1qxhzZo1vPPOO9x22208+uij/Pe//y1RP6mpqQCuKzueUKtWLR544AHX6+bNmxMcHEzLli2JjY11bc9/fvjwYQBM02TZsmX89re/xTRNzp0753r07t2blJSUKw53GYZBfHw806ZNo06dOrz33nuMHDmSqKgo+vfvz8WLF0t9nsGDB+Pn53fF9717924OHDjAwIED+emnn1x9pqenc8cdd7Bx40acTieQO1y7bds2Tp065X5if6FHjx7Ur1+fhg0b8sADD1CrVi0++ugjIiMji2z/1VdfcebMGZ544gl8fX1d2++++25atGjBypUrSxWHSGWk4TyRGqZz58507NjR9XrAgAHceOONjBo1invuucftO8CCgoKA3Dk3nnLdddcVmkdTu3ZtGjZsWGgb5A7/AZw9e5aLFy+ycOFCFi5cWGTfZ86cueK5fXx8eOaZZ3jmmWc4ffo0GzZs4LXXXuM///kP3t7evPPOO6U6T6NGja54XoADBw4AuQVXcVJSUqhTpw4vvfQSgwcPpmHDhsTExNCnTx8eeughGjdufNXzQG7R3axZM7y8vAgLC6N58+ZYLMX//X3s2DEgt6D9tRYtWrBp0ya3zitSFaiIEqnhLBYLt912G6+99hoHDhygdevWbh2Xfwv/d999x3333VeOERavuLlYxW03TRPAdZXmwQcfLLYQadu2rdtxRERE8MADD9C3b19at27Nf/7zHxYvXlyq81ztKtQv4589ezbt27cvsk2tWrUA6NevH7fccgsfffQRn332GbNnz+bFF1/kv//9L3fddddVz/XroltEfqYiSkTIyckBIC0tze1jbr75ZtdQ1l/+8hePTS4vjfr16xMYGIjD4SiwVtW18vb2pm3bthw4cIBz586V23maNGkC5F4NdKffiIgInnjiCZ544gnOnDlDhw4dmD59ultFVEnlT7rft2+f606+fPv27XPtB3Q3nlR5mhMlUsPZ7XY+++wzbDYbLVu2dPs4f39/Jk6cyJ49e5g4caLrKs8vvfPOO2zfvr0swy0TVquVvn37smzZMr7//vtC+8+ePXvF4w8cOEBiYmKh7RcvXiQhIYE6depQv379az5PcWJiYmjSpAkvv/xykYVvfr8Oh4OUlJQC+0JDQ2nQoAFZWVmlOvfVdOzYkdDQUBYsWFDgHJ9++il79uzh7rvvdm0LCAgAcM0hE6lqdCVKpIb59NNPXR9LcubMGZYsWcKBAwd4+umnXfOc3DVhwgR++OEHXnnlFb744gv+8Ic/EB4eTlJSEh9//DHbt29ny5Yt5fE2rtmsWbP44osviI2NZdiwYbRq1Yrz58+za9cuPv/8c86fP1/ssd988w0DBw7krrvu4pZbbiEkJISTJ0/y1ltvcerUKebOneu6Mnct5ymOxWLh//7v/7jrrrto3bo1Q4YMITIykpMnT/LFF18QFBTEihUruHTpEtdddx1/+MMfaNeuHbVq1eLzzz9nx44dvPLKK6XO3ZV4e3vz4osvMmTIELp3786AAQNcSxxER0czbtw4V9uYmBgARo8eTe/evbFarQVuFBCp9Dx5a6CIVJyiljjw9fU127dvb86fP7/IFcdN072VxD/88EOzV69eZkhIiOnl5WVGRESY/fv3N9evX+92fKVZ4qB169aF2kZFRZl33313oe1AoVv9k5OTzZEjR5oNGzY0vb29zfDwcPOOO+4wFy5ceMVYk5OTzVmzZpndu3c3IyIiTC8vL7NOnTrm7bffbn744YdFtr/aefLf4wcffODW+zdN0/z666/N+++/36xbt67p4+NjRkVFmf369TPXrl1rmqZpZmVlmRMmTDDbtWtnBgYGmgEBAWa7du3Mf/zjH1d8f6ZZ/Irl7sb2/vvvmzfeeKPp4+NjhoSEmIMGDXIti5AvJyfHfPLJJ8369eubhmFouQOpcgzTLOIavIiIiIhckeZEiYiIiJSCiigRERGRUlARJSIiIlIKKqJERERESkFFlIiIiEgpqIgSERERKQUttlmOnE4np06dIjAwUB9vICIiUkWYpsmlS5do0KDBFT9wW0VUOTp16lShT5MXERGRquH48eNcd911xe5XEVWOAgMDgdx/hJJ+nMaV5H/WWa9evfD29i6zfqsj5apklC/3KVfuU67cp1y5rzxzlZqaSsOGDV2/x4ujIqoc5Q/hBQUFlXkR5e/vT1BQkP6TXYVyVTLKl/uUK/cpV+5TrtxXEbm62lQcTSwXERERKQUVUSIiIiKloCJKREREpBQ0J6oScDgc2O12t9vb7Xa8vLy4fPkyDoejHCOr+qpyrry9vbFarZ4OQ0REiqEiyoNM0yQpKYmLFy+W+Ljw8HCOHz+u9aeuoqrnKjg4mPDw8CoZu4hIdaciyoPyC6jQ0FD8/f3d/kXpdDpJS0ujVq1aV1wETKpurkzTJCMjgzNnzgAQERHh4YhEROTXVER5iMPhcBVQdevWLdGxTqeT7OxsfH19q1Rh4AlVOVd+fn4AnDlzhtDQUA3tiYhUMlXrt0o1kj8Hyt/f38ORSGWW//1RkjlzIiJSMVREeZjmusiV6PtDRKTyUhElIiIiUgoqoqTaePjhh7nvvvs8HYaIiJSbqcALxex7IW9/xVERVcWZThP7UTvZ32djP2rHdJqeDumKpk6dSvv27T1y7vXr12MYhuvh5+dH69atWbhwoavNL/cX9Zg6dSoAX3/9NX/84x8JCwvD19eXG264gWHDhrF//36PvDcRkZrBCkymcCH1Qt72ir0BR3fnVWH2vXYyP8vEvPRz4WQEGvj39sfW0ubByCq3ffv2ERQURGZmJitWrGDEiBE0adKEO+64g9OnT7vavf/++0yePJl9+/a5ttWqVYv//e9/9O3bl969e/Puu+/SpEkTzpw5wwcffMBf//pX3n//fU+8LRGRGuCveV8nY7Ek4ePTGYtlOvAc8Pwv9lcMXYmqosyDJhnLMgoUUADmJZP0D9PJ3pNdLuddvXo1N998M8HBwdStW5d77rmHQ4cOFWhz4sQJBgwYQEhICAEBAXTs2JFt27axePFinnvuOb755hvXlZ3Fixdz9OhRDMNg9+7drj4uXryIYRisX78eyF0S4pFHHqFRo0b4+fnRvHlzXnvttVK9h9DQUMLDw2nUqBGjR4+mUaNG7Nq1C4Dw8HDXo3bt2hiGUWCbxWJhyJAh9OnTh+XLl9OjRw8aNWpEbGwsL7/8Mv/85z9LFZOIiLjrr8DzWK3/4M47H8Zq9UwBBboSVWmYpglu3sXuzHHCxiu3yYjPwKuRF4bFjbu7vN2/Cyw9PZ3x48fTtm1b0tLSmDx5Mr///e/ZvXs3FouFtLQ0unfvTmRkJMuXLyc8PJxdu3bhdDrp378/33//PatXr+bzzz8HoHbt2iQnJ1/1vE6nk+uuu44PPviAunXrsmXLFoYPH05ERAT9+vVzK/ZfM02T+Ph4EhMTiY2NdeuY+Ph4zp07x1NPPVXk/uDg4FLFIiIiJTEJ05yMYYBpemMYFV9AgYqoysMOF1+8WGbdmZdMUmanuNU2eGIwuDn617dv3wKvFy1aRP369fnxxx9p06YNS5Ys4ezZs+zYsYOQkBAAmjZt6mpfq1YtvLy8CA8Pd++Eeby9vXnuuedcrxs1akRCQgL/+c9/SlxEXXfddQBkZWXhdDp5/vnn6datm1vHHjhwAIAWLVqU6JwiIlKWnswroMAw7OTOidKVKKnkDhw4wOTJk9m2bRvnzp3D6XQCkJiYSJs2bdi9ezc33nijq4AqS/PmzWPRokUkJiaSmZlJdnZ2qSapf/nllwQGBpKVlcX27dsZNWoUISEhjBgx4qrHmmblnrgvIlL9vQAsAODMmQ7Uq/dbrNbJefsqtpBSEVVZeOddEXJD9tFsMt7PuGq7gAEBeF/v7da53fXb3/6WqKgo3njjDRo0aIDT6aRNmzZkZ+fOwcr/qJKSyP84ll8WKL9eoXvp0qX8+c9/5pVXXiEuLo7AwEBmz57Ntm3bSny+Ro0auYbdWrduzbZt25g+fbpbRVSzZs0A2Lt3L3FxcSU+t4iIXIv8u/DaAN9z/nxzQkKeyftYrIovpDSxvJIwDAPD5t7Dq7EX1LpKf0EG3o293evTzflQP/30E/v27ePZZ5/ljjvuoGXLlly4cKFAm7Zt27J7927Onz9fZB82mw2Hw1FgW/369QEK3Bn3y0nmAJs3b6ZLly488cQT3HjjjTRt2rTQhPbSslqtZGZmutW2V69e1KtXj5deeqnI/RcvXiyTmEREpCgOcieRpwJw/nz+1Iq/5m13FH1YOVERVQUZFgNuuXIb/17+7k0qL4E6depQt25dFi5cyMGDB1m3bh3jx48v0GbAgAGEh4dz3333sXnzZg4fPsyyZctISEgAIDo6miNHjrB7927OnTtHVlYWfn5+3HTTTcyaNYs9e/awYcMGnn322QL93nDDDXz11VfEx8ezf/9+/vrXv7Jjx45SvY8zZ86QlJTEsWPH+OCDD3j77be599573To2ICCA//u//2PlypX87ne/4/PPP+fo0aN89dVXPPXUUzz++OOliklERNwxFRgCJGKaFi5ebPaLfX+lxi22OW/ePKKjo/H19SU2Npbt27dfsf3FixcZOXIkERER+Pj40KxZM1atWuXaf+nSJcaOHUtUVBR+fn506dKl0C/btLQ0Ro0axXXXXYefnx+tWrViwYIFBdpcvnyZkSNHUrduXWrVqkXfvn3duousohhNDfz7+mMEFiyUjCCDgD8ElMs6URaLhaVLl7Jz507atGnDuHHjmD17doE2NpuNzz77jNDQUPr06cNvfvMbZs2alXepNXdi+p133sltt91G/fr1ee+994DcCeo5OTnExMQwduxYpk2bVqDfxx57jPvvv5/+/fsTGxvLTz/9xBNPPFGq99G8eXMiIiJo2rQpEydO5LHHHuP11193+/h7772XLVu24O3tzcCBA2nRogUDBgwgJSWlUNwiIlLWEvK+/oacnJJPISlTpgctXbrUtNls5qJFi8wffvjBHDZsmBkcHGwmJycX2T4rK8vs2LGj2adPH3PTpk3mkSNHzPXr15u7d+92tenXr5/ZqlUrc8OGDeaBAwfMKVOmmEFBQeaJEydcbYYNG2Y2adLE/OKLL8wjR46Y//znP02r1Wp+8sknrjaPP/642bBhQ3Pt2rXmV199Zd50001mly5dSvT+UlJSTMBMSUkptC8zM9P88ccfzczMzBL1aZqm6XA4zAsXLpgOh8N0Opxm9pFsM+u7LDP7SLbpdDhL3F919stcVUXX8n1SGtnZ2ebHH39sZmdnV8j5qjLlyn3KlfuUK3eMNU0TMyfn8XLL1ZV+f/+SR69EzZkzh2HDhjFkyBDX1SB/f38WLVpUZPtFixZx/vx5Pv74Y7p27Up0dDTdu3enXbt2AGRmZrJs2TJeeuklunXrRtOmTZk6dSpNmzZl/vz5rn62bNnC4MGDufXWW4mOjmb48OG0a9fOdRUsJSWFf/3rX8yZM4fbb7+dmJgY3nzzTbZs2cLWrVvLPzElYFgMvKO9sbWx4R3tXeZDeCIiIpXLFgBM8yYPx+HBu/Oys7PZuXMnkyZNcm2zWCz06NHDNX/m15YvX05cXBwjR47kk08+oX79+gwcOJCJEyditVrJycnB4XDg6+tb4Dg/Pz82bdrket2lSxeWL1/O0KFDadCgAevXr2f//v28+uqrAOzcuRO73U6PHj1cx7Ro0YLrr7+ehIQEbrqp6H+4rKwssrKyXK9TU3Mnvtnt9kJ3m9ntdkzTxOl0upYJcJeZdxdb/vFSvKqeK6fTiWma2O1215Boecr/Pv3196sUply5T7lyn3J1NZl4ee3CMMBu7wQcKJdcudunx4qoc+fO4XA4CAsLK7A9LCyMvXv3FnnM4cOHWbduHYMGDWLVqlUcPHiQJ554ArvdzpQpUwgMDCQuLo4XXniBli1bEhYWxnvvvUdCQkKBBR9ff/11hg8fznXXXYeXlxcWi4U33njDteBiUlISNput0OrTYWFhJCUlFfueZs6cWWBByHyfffYZ/v7+BbblLziZlpbmWh6gpC5dulSq42qiqpqr7OxsMjMz2bhxIzk5ORV23jVr1lTYuao65cp9ypX7lKuihYT8wC235HD5ch0++2w/YJRLrjIyrr6MEFSxdaKcTiehoaEsXLgQq9VKTEwMJ0+eZPbs2UyZMgWAt99+m6FDhxIZGYnVaqVDhw4MGDCAnTt3uvp5/fXX2bp1K8uXLycqKoqNGzcycuRIGjRoUODqU0lNmjSpwN1qqampNGzYkF69ehEUFFSg7eXLlzl+/Di1atUqdOXsakzT5NKlSwQGBrq9PEFNVdVzdfnyZfz8/OjWrVuJv09Kw263s2bNGnr27Im3dwkWEKuBlCv3KVfuU66uzGL5AQCbrTs9e/Yqt1zljyRdjceKqHr16mG1Wgvd8ZacnFzsR4JERETg7e1dYFijZcuWJCUlkZ2djc1mo0mTJmzYsIH09HRSU1OJiIigf//+NG7cGMidN/WXv/yFjz76iLvvvhv4eW2jl19+mR49ehAeHk52djYXL14scDXqSrEB+Pj44OPjU2i7t7d3oX9gh8OBYRhYLBbXYpPuyh+Wyj9eilfVc2WxWDAMo8jvofJU0eerypQr9ylX7lOuipO7wLLFcrMrP+WRK3f789hvFZvNRkxMDGvXrnVtczqdrF27ttiVoLt27crBgwcLzG3Zv38/ERER2GwFb+kPCAggIiKCCxcuEB8f71oHKH9+0q9/oVqtVle/MTExeHt7F4ht3759JCYmapVqERERjzDJn1QOXTwZiItHh/PGjx/P4MGD6dixI507d2bu3Lmkp6czZMgQAB566CEiIyOZOXMmACNGjODvf/87Y8aM4cknn+TAgQPMmDGD0aNHu/qMj4/HNE2aN2/OwYMHmTBhAi1atHD1GRQURPfu3ZkwYQJ+fn5ERUWxYcMG/v3vfzNnzhwAateuzSOPPML48eMJCQkhKCiIJ598kri4uGInlYuIiEh5OgicA3yADh6OJZdHi6j+/ftz9uxZJk+eTFJSEu3bt2f16tWuyeaJiYkFrhg1bNiQ+Ph4xo0bR9u2bYmMjGTMmDFMnDjR1SYlJYVJkyZx4sQJQkJC6Nu3L9OnTy9waW7p0qVMmjSJQYMGcf78eaKiopg+fXqB1aZfffVVLBYLffv2JSsri969e/OPf/yjArIiIiIiheVfhepIbiHl+TsYPT6xfNSoUYwaNarIfevXry+0LS4u7oprNfXr149+/fpd8Zzh4eG8+eabV2zj6+vLvHnzmDdv3hXbiYiISEWoXEN5UAk+9kWqFtM0GT58OCEhIRiGUeiDgkVERMrH5ryvKqKkilq9ejWLFy/mf//7H6dPn6ZNmzaeDqnUoqOjmTt3rlvtDMPAMAysVisNGjTgkUce4cKFCwA8/PDDrv1FPaKjo4HcW2afeeYZWrRoga+vL+Hh4fTo0YP//ve/rkVBRUSkKBeBH/KeV54bvFREVVG+vrOA4j7s9gXK65OsDx06REREBF26dCE8PBwvr5KPCJumWaELR5aF559/ntOnT5OYmMi7777Lxo0bXTc0vPbaa5w+fdr1AHjzzTddr3fs2MHFixfp0qUL//73v5k0aRK7du1i48aN9O/fn6eeeoqUlBRPvj0RkUoufxpPEyDsSg0rlIqoKso0rVgsU8gtmH7pBWAyUPYfEfLwww/z5JNPkpiYWOAKS1ZWFqNHjyY0NBRfX19uvvlmduzY4Tpu/fr1GIbBp59+SkxMDD4+PmzatAmn08nMmTNp1KgRfn5+tGvXjg8//LDAOX/44QfuuecegoKCCAwM5JZbbuHQoUMA7Nixg549e1KvXj1q165N9+7d2bVr1y9yZPLcc8/Rpk0b/Pz8aNCggavwufXWWzl27Bjjxo1zXTG6ksDAQMLDw4mMjOS2225j8ODBrnPVrl2b8PBw1wMgODjY9bp+/fr85S9/4ejRo2zbto3BgwfTqlUrmjVrxrBhw9i9eze1atW6tn8cEZFqrfLNh4JKMLFc8pmAe8vMg5OsrCfw8TGwWCYD2cDTQP7VqWeB8UC6m/35A1dfzfu1116jSZMmLFy4kB07drgWPX3qqadYtmwZb731FlFRUbz00kv07t2bgwcPEhIS4jr+6aef5uWXX6Zx48bUqVOHmTNn8s4777BgwQJuuOEGNm7cyIMPPkj9+vXp3r07J0+epFu3btx6662sW7eOoKAgNm/e7LqKdenSJQYPHszrr7+OaZq88sor9OnThwMHDhAYGMiyZcuYO3cu//d//0enTp04c+YM33zzDQD//e9/adeuHcOHD2fYsGFu5inXyZMnWbFiBbGxsW61dzqdLF26lEGDBtGgQYNC+1VAiYhcjYoouaIMwL1fphYLFPxYv2kUHNr79eurSQMCrtqqdu3aBAYGYrVaXVdc0tPTmT9/PosXL+auu+4C4I033mDNmjX861//YsKECa7jn3/+eXr27AnkXr2aMWMGn3/+uWsB08aNG7Np0yb++c9/0r17d+bNm0ft2rVZunSpa4mKZs2aufq7/fbbC8S3cOFCgoOD2bBhA/fccw+JiYmEh4dz6623UrduXaKjo+ncuTMAISEhWK1W1xWmq5k4cSLPPvssDoeDy5cvExsb61pX7GrOnTvHhQsXaNGihVvtRUTkl3LIX6m8shVRGs6Ta3Lo0CHsdjtdu3Z1bfP29qZz587s2bOnQNuOHTu6nh88eJCMjAx69uxJrVq1XI9///vfruG63bt3c8sttxS7/H5ycjLDhg3jhhtuoHbt2gQFBZGWlkZiYiIAf/zjH8nMzKR9+/YMHz6cjz76qNRzsSZMmMDu3bv59ttvXSvZ33333Tgcjqseq0njIiLX4nty/9gPBFp7OJaCdCWq0vAn95vk6pxOJ6mpqQQFBWGxvETuVScbucN6z5I7tFfSc5e/gICfr3alpeW+15UrVxIZGVmgXf7nD/r5+V2xv8GDB/PTTz/x2muvERUVhY+PD3FxcWRnZwO5i7Pu2bOH5cuXs2XLFp544glmz57Nhg0bSvw5S/Xq1aNp06YA3HDDDcydO5e4uDi++OKLq35odf369QkODmbv3r0lOqeIiMDPQ3k3UR7zfa+FrkRVGga5Q2olebxKbgH1PJCV93UaMKeE/Vx9PlRxmjRpgs1mY/Pmza5tdrudHTt20KpVq2KPa9WqFT4+PiQmJtK0adMCj4YNGwK5Hwz95ZdfYrcXvSrt5s2bGT16NH369KF169b4+Phw7ty5Am38/Py46667eO2111i/fj0JCQl89913QO7nN7pzJako+fPBMjMzr9rWYrHwwAMP8O6773Lq1KlC+9PS0qrc3YoiIhWncs6HAl2JqrJ8fGZjscwgt3D6a97W/K+Tf/W6/AQEBDBixAgmTJhASEgI119/PS+99BIZGRk88sgjxR4XGBjIn//8Z8aNG4fT6eTmm28mJSWFzZs3ExQUxODBgxk1ahSvv/46DzzwAJMmTaJ27dps3bqVzp0707x5c2644QbefvttOnbsSGpqquvzEPMtXrwYu91O69atCQ0N5Z133nF9XiLkrv+0ceNGHnjgAXx8fKhXr16x8V66dImkpCRM0+T48eM89dRT1K9fny5d3PtPPX36dNavX09sbCzTp0+nY8eOeHt78+WXXzJz5kx27NhBcMGJbiIiAqiIkjJnGA6czuewWH5dKOW/Lt0VltKYNWsWTqeTP/3pT1y6dImOHTsSHx9PnTp1rnjcCy+8QP369Zk5cyaHDx8mODiYDh068Je//AWAunXrsm7dOiZMmED37t2xWq20b9/eNf/qX//6F8OHD6dDhw40bNiQGTNm8Oc//9nVf3BwMLNmzeLHH3/E6XTym9/8hhUrVlC3bl0gd6L7Y489RpMmTcjKyrri3KXJkyczeXJucVq/fn06derEZ5995urrakJCQti6dSuzZs1i2rRpHDt2jDp16vCb3/yG2bNnU7t2bbf6ERGpWU4DR8gdMXHvjuiKZJia9VpuUlNTqV27NikpKQQFBRXYd/nyZY4cOUKjRo3w9fUtUb8F50RpRPZKqnquruX7pDTsdjurVq2iT58+JZ43VtMoV+5TrtynXP3af4G+wG+AbwvsKc9cXen39y9Vvd8qIiIiUkPkD+V1vWIrT1ERJSIiIpVU5Z0PBSqiREREpFK6DOzMe64iSkRERMRNO8ld/zAUaOzhWIqmIsrDNK9frkTfHyJSc/1yKK/06xmWJxVRHpJ/J0FGhrsfOiw1Uf73h+7SEZGap3LPhwKtE+UxVquV4OBgzpw5A4C/vz+G4V6l7XQ6yc7O5vLly1Xytv2KVFVzZZomGRkZnDlzhuDgYNcK6SIiNYOJiii5ovDwcABXIeUu0zTJzMzEz8/P7cKrpqrquQoODnZ9n4iI1ByHgTOANxDj4ViKpyLKgwzDICIigtDQ0GI/H64odrudjRs30q1bNw3zXEVVzpW3t7euQIlIDZV/FSoGKP+FhktLRVQlYLVaS/TL0mq1kpOTg6+vb5UrDCqaciUiUhVV/qE80MRyERERqXRURImIiIiUUCrwXd7zOE8GclUqokRERKQS2Ubu3XnRQAPPhnIVKqJERESkEqkaQ3mgIkpEREQqFRVRIiIiIiXkALbmPVcRJSIiIuKmH8mdWF4L+I2HY7k6FVEiIiJSSeQP5cVSFZayVBElIiIilUTVmQ8FKqJERESk0tic91VFlIiIiIibkoFDec9v8mQgblMRJSIiIpVAQt7X1kCwB+Nwn4ooERERqQSq1nwoUBElIiIilYKKKBEREZESygK+ynuuIqpE5s2bR3R0NL6+vsTGxrJ9+/Yrtr948SIjR44kIiICHx8fmjVrxqpVq1z7L126xNixY4mKisLPz48uXbqwY8eOAn0YhlHkY/bs2a420dHRhfbPmjWrbN+8iIhIjfc1uYVUXeAGD8fiPo+vZPX+++8zfvx4FixYQGxsLHPnzqV3797s27eP0NDQQu2zs7Pp2bMnoaGhfPjhh0RGRnLs2DGCg4NdbR599FG+//573n77bRo0aMA777xDjx49+PHHH4mMjATg9OnTBfr99NNPeeSRR+jbt2+B7c8//zzDhg1zvQ4MDCzDdy8iIiIFh/IMTwZSIh4voubMmcOwYcMYMmQIAAsWLGDlypUsWrSIp59+ulD7RYsWcf78ebZs2YK3tzeQe8UoX2ZmJsuWLeOTTz6hW7duAEydOpUVK1Ywf/58pk2bBkB4eHiBfj/55BNuu+02GjduXGB7YGBgobYiIiJSlqrefCjw8HBednY2O3fupEePHq5tFouFHj16kJCQUOQxy5cvJy4ujpEjRxIWFkabNm2YMWMGDocDgJycHBwOB76+vgWO8/PzY9OmTUX2mZyczMqVK3nkkUcK7Zs1axZ169blxhtvZPbs2eTk5JT27YqIiEghJlVtkc18Hr0Sde7cORwOB2FhYQW2h4WFsXfv3iKPOXz4MOvWrWPQoEGsWrWKgwcP8sQTT2C325kyZQqBgYHExcXxwgsv0LJlS8LCwnjvvfdISEigadOmRfb51ltvERgYyP33319g++jRo+nQoQMhISFs2bKFSZMmcfr0aebMmVNkP1lZWWRlZblep6amAmC327Hb7W7n5Wry+yrLPqsr5apklC/3KVfuU67cVzNzdRRv7yRM04ucnHaAe++9PHPlbp+GaZpmmZ/dTadOnSIyMpItW7YQFxfn2v7UU0+xYcMGtm3bVuiYZs2acfnyZY4cOYLVagVyhwRnz57tmud06NAhhg4dysaNG7FarXTo0IFmzZqxc+dO9uzZU6jPFi1a0LNnT15//fUrxrto0SIee+wx0tLS8PHxKbR/6tSpPPfcc4W2L1myBH9//ysnQ0REpAaKjNxAx46vcuHCDWzcOPvqB1SAjIwMBg4cSEpKCkFBQcW28+iVqHr16mG1WklOTi6wPTk5udh5SBEREXh7e7sKKICWLVuSlJREdnY2NpuNJk2asGHDBtLT00lNTSUiIoL+/fsXmu8E8OWXX7Jv3z7ef//9q8YbGxtLTk4OR48epXnz5oX2T5o0ifHjx7tep6am0rBhQ3r16nXFf4SSstvtrFmzhp49e7rmhUnRlKuSUb7cp1y5T7lyX03MlcUSD0BQ0F306dPH7ePKM1f5I0lX49EiymazERMTw9q1a7nvvvsAcDqdrF27llGjRhV5TNeuXVmyZAlOpxOLJXdK1/79+4mIiMBmsxVoGxAQQEBAABcuXCA+Pp6XXnqpUH//+te/iImJoV27dleNd/fu3VgsliLvGgTw8fEp8gqVt7d3ufxnKK9+qyPlqmSUL/cpV+5TrtxXs3K1FQCr9Was1pK/5/LIlbv9efzuvPHjxzN48GA6duxI586dmTt3Lunp6a679R566CEiIyOZOXMmACNGjODvf/87Y8aM4cknn+TAgQPMmDGD0aNHu/qMj4/HNE2aN2/OwYMHmTBhAi1atHD1mS81NZUPPviAV155pVBcCQkJbNu2jdtuu43AwEASEhIYN24cDz74IHXq1CnHjIiIiNQUacA3ec/jrtSwUvJ4EdW/f3/Onj3L5MmTSUpKon379qxevdo12TwxMdF1xQmgYcOGxMfHM27cONq2bUtkZCRjxoxh4sSJrjYpKSlMmjSJEydOEBISQt++fZk+fXqhynLp0qWYpsmAAQMKxeXj48PSpUuZOnUqWVlZNGrUiHHjxhUYrhMREZFrsR1wAtcD13k4lpLzeBEFMGrUqGKH79avX19oW1xcHFu3bi22v379+tGvX7+rnnf48OEMHz68yH0dOnS44jlERETkWlXNpQ3yVYqPfREREZGaqGousplPRZSIiIh4gBPIX1hbRZSIiIiIm/YAKYA/0NbDsZSOiigRERHxgPyhvM5A1VzOQUWUiIiIeEDVng8FKqJERETEI1REiYiIiJTQOWB/3vObPBnINVERJSIiIhUs/668FkBdTwZyTVREiYiISAWr+kN5oCJKREREKpyKKBEREZESspP7mXkAXT0ZyDVTESUiIiIVaDdwGQgBmnk2lGukIkpEREQqUP5QXhxVvQyp2tGLiIhIFVM95kOBiigRERGpMCawOe+5iigRERERNx0HTgJWoJOHY7l2KqJERESkguQP5bUHAjwYR9lQESUiIiIVpPrMhwIVUSIiIlJhVESJiIiIlFA6uWtEgYooEREREbftABxAJNDQw7GUDRVRIiIiUgF+OZRneDKQMqMiSkRERCpA9ZoPBSqiREREpNw5gYS85yqiRERERNy0HzgP+JK7RlT1oCJKREREyln+UF4nwObJQMqUiigREREpZ/lFVFePRlHWVESJiIhIOat+k8pBRZSIiIiUq/PAnrzncZ4MpMypiBIREZFytDXvazOgnicDKXMqokRERKQcbc77Wr2G8kBFlIiIiJSr6jkfClREiYiISLmxA9vznquIEhEREXHTt0AGUBto6eFYyp6KKBERESkn+UN5cVTHkqP6vSMRERGpJKrvfChQESUiIiLlRkWUiIiISAmdABLJLTU6eziW8lEpiqh58+YRHR2Nr68vsbGxbN++/YrtL168yMiRI4mIiMDHx4dmzZqxatUq1/5Lly4xduxYoqKi8PPzo0uXLuzYsaNAH4ZhFPmYPXu2q8358+cZNGgQQUFBBAcH88gjj5CWlla2b15ERKRaSsj72hYI9GQg5cbjRdT777/P+PHjmTJlCrt27aJdu3b07t2bM2fOFNk+Ozubnj17cvToUT788EP27dvHG2+8QWRkpKvNo48+ypo1a3j77bf57rvv6NWrFz169ODkyZOuNqdPny7wWLRoEYZh0LdvX1ebQYMG8cMPP7BmzRr+97//sXHjRoYPH15+yRAREak2qvdQHoCXpwOYM2cOw4YNY8iQIQAsWLCAlStXsmjRIp5++ulC7RctWsT58+fZsmUL3t7eAERHR7v2Z2ZmsmzZMj755BO6desGwNSpU1mxYgXz589n2rRpAISHhxfo95NPPuG2226jcePGAOzZs4fVq1ezY8cOOnbsCMDrr79Onz59ePnll2nQoEHZJkJERKRaURFVrrKzs9m5cyeTJk1ybbNYLPTo0YOEhIQij1m+fDlxcXGMHDmSTz75hPr16zNw4EAmTpyI1WolJycHh8OBr69vgeP8/PzYtGlTkX0mJyezcuVK3nrrLde2hIQEgoODXQUUQI8ePbBYLGzbto3f//73hfrJysoiKyvL9To1NRUAu92O3W53IyPuye+rLPusrpSrklG+3KdcuU+5cl/1yVUmXl67MAyw2zuTu+hm2SrPXLnbp0eLqHPnzuFwOAgLCyuwPSwsjL179xZ5zOHDh1m3bh2DBg1i1apVHDx4kCeeeAK73c6UKVMIDAwkLi6OF154gZYtWxIWFsZ7771HQkICTZs2LbLPt956i8DAQO6//37XtqSkJEJDQwu08/LyIiQkhKSkpCL7mTlzJs8991yh7Z999hn+/v5XzEVprFmzpsz7rK6Uq5JRvtynXLlPuXJfVc9VSMgP3HJLDpcv1yE+/gfgx3I7V3nkKiMjw612Hh/OKymn00loaCgLFy7EarUSExPDyZMnmT17NlOmTAHg7bffZujQoURGRmK1WunQoQMDBgxg586dRfa5aNEiBg0aVOjqVUlNmjSJ8ePHu16npqbSsGFDevXqRVBQ0DX1/Ut2u501a9bQs2dP15CmFE25Khnly33KlfuUK/dVl1xZLD8AYLPdSp8+d5fLOcozV/kjSVfj0SKqXr16WK1WkpOTC2xPTk4uNGcpX0REBN7e3litVte2li1bkpSURHZ2NjabjSZNmrBhwwbS09NJTU0lIiKC/v37u+Y7/dKXX37Jvn37eP/99wtsDw8PLzS5PScnh/Pnzxcbm4+PDz4+PoW2e3t7l8t/hvLqtzpSrkpG+XKfcuU+5cp9VT9X2wCwWG7GYinf91EeuXK3P4/enWez2YiJiWHt2rWubU6nk7Vr1xIXF1fkMV27duXgwYM4nU7Xtv379xMREYHNZivQNiAggIiICC5cuEB8fDz33ntvof7+9a9/ERMTQ7t27Qpsj4uL4+LFiwWuXq1btw6n00lsbGyp3q+IiEj1Z1ITJpVDJVjiYPz48bzxxhu89dZb7NmzhxEjRpCenu66W++hhx4qMPF8xIgRnD9/njFjxrB//35WrlzJjBkzGDlypKtNfHw8q1ev5siRI6xZs4bbbruNFi1auPrMl5qaygcffMCjjz5aKK6WLVty5513MmzYMLZv387mzZsZNWoUDzzwgO7MExERKdYB4BzgA9zo4VjKl8fnRPXv35+zZ88yefJkkpKSaN++PatXr3ZNNk9MTMRi+bnWa9iwIfHx8YwbN462bdsSGRnJmDFjmDhxoqtNSkoKkyZN4sSJE4SEhNC3b1+mT59e6PLc0qVLMU2TAQMGFBnbu+++y6hRo7jjjjuwWCz07duXv/3tb+WQBRERkeoi/ypUR3ILqerL40UUwKhRoxg1alSR+9avX19oW1xcHFu3bi22v379+tGvX7+rnnf48OFXXDwzJCSEJUuWXLUfERERyVczhvKgEgzniYiISHWiIkpERESkhC4CP+Q9L/oGsepERZSIiIiUkfypNk2AsCs1rBZURImIiEgZqTlDeaAiSkRERMqMiigRERGREsohf6VyFVEiIiIibvseSAMCgdYejqViqIgSERGRMpA/lHcTYL1Sw2pDRZSIiIiUgfwiqqtHo6hIKqJERESkDNSsSeWgIkpERESu2WngCGAAsR6OpeKoiBIREZFrlJD39TdAkCcDqVAqokREROQabc77WnOG8kBFlIiIiFyzmjcfClREiYiIyDW5DOzMe64iSkRERMRNOwE7EAo09nAsFUtFlIiIiFyDXw7lGZ4MpMKpiBIREZFrUDPnQ4GKKBERESk1ExVRIiIiIiV2GDgDeAMxHo6l4qmIEhERkVLKvwoVA/h6MhCPUBElIiIipVRzh/JARZSIiIiUmoooERERkRJKBb7Le64iSkRERMRN28i9O68REOHhWDxDRZSIiIiUQs0eygMVUSIiIlIqKqJURImIiEgJOYCtec9VRImIiIi46QdyJ5bXAtp4OBbPURElIiIiJZQ/lBcLeHkyEI9SESUiIiIlpPlQoCJKRERESkxFFKiIEhERkRJJBg7lPb/Jk4F4nIooERERKYGEvK+tgWAPxuF5JS6ijh8/zokTJ1yvt2/fztixY1m4cGGZBiYiIiKVkYby8pW4iBo4cCBffPEFAElJSfTs2ZPt27fzzDPP8Pzzz5d5gCIiIlKZqIjKV+Ii6vvvv6dz584A/Oc//6FNmzZs2bKFd999l8WLF5d1fCIiIlJpZAFf5T1XEVXiIsput+Pj4wPA559/zu9+9zsAWrRowenTp0scwLx584iOjsbX15fY2Fi2b99+xfYXL15k5MiRRERE4OPjQ7NmzVi1apVr/6VLlxg7dixRUVH4+fnRpUsXduzYUaifPXv28Lvf/Y7atWsTEBBAp06dSExMdO2/9dZbMQyjwOPxxx8v8fsTERGpPr4mt5CqB9zg4Vg8r8RFVOvWrVmwYAFffvkla9as4c477wTg1KlT1K1bt0R9vf/++4wfP54pU6awa9cu2rVrR+/evTlz5kyR7bOzs+nZsydHjx7lww8/ZN++fbzxxhtERka62jz66KOsWbOGt99+m++++45evXrRo0cPTp486Wpz6NAhbr75Zlq0aMH69ev59ttv+etf/4qvr2+B8w0bNozTp0+7Hi+99FKJ3p+IiEj18suhPMOTgVQKJV5m9MUXX+T3v/89s2fPZvDgwbRr1w6A5cuXu4b53DVnzhyGDRvGkCFDAFiwYAErV65k0aJFPP3004XaL1q0iPPnz7Nlyxa8vb0BiI6Odu3PzMxk2bJlfPLJJ3Tr1g2AqVOnsmLFCubPn8+0adMAeOaZZ+jTp0+BoqhJkyaFzufv7094eHiJ3pOIiEj1pflQv1TiK1G33nor586d49y5cyxatMi1ffjw4SxYsMDtfrKzs9m5cyc9evT4ORiLhR49epCQkFDkMcuXLycuLo6RI0cSFhZGmzZtmDFjBg6HA4CcnBwcDkehK0p+fn5s2rQJAKfTycqVK2nWrBm9e/cmNDSU2NhYPv7440Lne/fdd6lXrx5t2rRh0qRJZGRkuP3+REREqhcT2Jz3XEUUlPIDb0zTZOfOnRw6dIiBAwcSGBiIzWbD39/f7T7OnTuHw+EgLCyswPawsDD27t1b5DGHDx9m3bp1DBo0iFWrVnHw4EGeeOIJ7HY7U6ZMITAwkLi4OF544QVatmxJWFgY7733HgkJCTRt2hSAM2fOkJaWxqxZs5g2bRovvvgiq1ev5v777+eLL76ge/fuQO5diFFRUTRo0IBvv/2WiRMnsm/fPv773/8W+56ysrLIyspyvU5NTQVy55HZ7Xa3c3M1+X2VZZ/VlXJVMsqX+5Qr9ylX7qvcuTqKt3cSpulFTk47wLMxlmeu3O3TME3TLEnHx44d48477yQxMZGsrCz2799P48aNGTNmDFlZWW5fjTp16hSRkZFs2bKFuLg41/annnqKDRs2sG3btkLHNGvWjMuXL3PkyBGsViuQOyQ4e/Zs16T2Q4cOMXToUDZu3IjVaqVDhw40a9aMnTt3smfPHtd5BwwYwJIlS1x9/+53vyMgIID33nuvyHjXrVvHHXfcwcGDB4sc+oPcocPnnnuu0PYlS5aUqMAUERGpbCIjN9Cx46tcuHADGzfO9nQ45SojI4OBAweSkpJCUFBQse1KfCVqzJgxdOzYkW+++abARPLf//73DBs2zO1+6tWrh9VqJTk5ucD25OTkYuchRURE4O3t7SqgAFq2bElSUhLZ2dnYbDaaNGnChg0bSE9PJzU1lYiICPr370/jxo1d5/Xy8qJVq1YF+m7ZsqVryK8osbGxAFcsoiZNmsT48eNdr1NTU2nYsCG9evW64j9CSdntdtasWUPPnj1dc8OkaMpVyShf7lOu3Kdcua8y58piWQ1AUNBd9OnTx8PRlG+u8keSrqbERdSXX37Jli1bsNlsBbZHR0cXuAPuamw2GzExMaxdu5b77rsPyJ2vtHbtWkaNGlXkMV27dmXJkiU4nU4sltzpXPv37yciIqJQPAEBAQQEBHDhwgXi4+Ndk8htNhudOnVi3759Bdrv37+fqKioYuPdvXs3kFvIFcfHx8e1/MMveXt7l8t/hvLqtzpSrkpG+XKfcuU+5cp9lTNXWwGwWm/Gaq08sZVHrtztr8RFlNPpdE3k/qUTJ04QGBhYor7Gjx/P4MGD6dixI507d2bu3Lmkp6e77tZ76KGHiIyMZObMmQCMGDGCv//974wZM4Ynn3ySAwcOMGPGDEaPHu3qMz4+HtM0ad68OQcPHmTChAm0aNHC1SfAhAkT6N+/P926deO2225j9erVrFixgvXr1wO5Q4JLliyhT58+1K1bl2+//ZZx48bRrVs32rZtW9KUiYiIVHGXgG/znsddqWGNUuIiqlevXsydO9f1WXmGYZCWlsaUKVNKfHmvf//+nD17lsmTJ5OUlET79u1ZvXq1a7J5YmKi64oTQMOGDYmPj2fcuHG0bduWyMhIxowZw8SJE11tUlJSmDRpEidOnCAkJIS+ffsyffr0AlXl73//exYsWMDMmTMZPXo0zZs3Z9myZdx8881A7tWqzz//3FXUNWzYkL59+/Lss8+WNF0iIiLVwHbACVwPXOfhWCqPEhdRr7zyCr1796ZVq1ZcvnyZgQMHcuDAAerVq1fspOwrGTVqVLHDd/lXhn4pLi6OrVu3Fttfv3796Nev31XPO3ToUIYOHVrkvoYNG7Jhw4ar9iEiIlIzaH2oopS4iLruuuv45ptvWLp0Kd9++y1paWk88sgjDBo0CD8/v/KIUURERDxKRVRRSrVOlJeXFw8++GBZxyIiIiKVjhPIXwRbRdQvlbiI+ve//33F/Q899FCpgxEREZHKZg+QAvgDurnql0q1TtQv2e12MjIyXCuWq4gSERGpTvKH8joDlWdpg8qgxJ+dd+HChQKPtLQ09u3bx80331yqieUiIiJSmWk+VHFKXEQV5YYbbmDWrFmFrlKJiIhIVaciqjhlUkRB7mTzU6dOlVV3IiIi4nHngP15z7XI5q+VeE7U8uXLC7w2TZPTp0/z97//na5du5ZZYCIiIuJp+XfltQRCPBlIpVTiIir/c+7yGYZB/fr1uf3223nllVfKKi4RERHxOA3lXUmpPjtPREREagIVUVdSZnOiREREpDqxk/uZeaAiqmhuXYkaP3682x3OmTOn1MGIiIhIZfE1cJncuVDNPBxL5eRWEfX111+71ZlhGNcUjIiIiFQW+UN5cWjgqmhuFVFffPFFecchIiIilYrmQ12NSksRERH5FRPYnPdcRVRxSnx3HsBXX33Ff/7zHxITE8nOzi6w77///W+ZBCYiIiKechw4BViBTh6OpfIq8ZWopUuX0qVLF/bs2cNHH32E3W7nhx9+YN26ddSuXbs8YhQREZEKlT+U1x4I8GAclVuJi6gZM2bw6quvsmLFCmw2G6+99hp79+6lX79+XH/99eURo4iIiFQozYdyR4mLqEOHDnH33XcDYLPZSE9PxzAMxo0bx8KFC8s8QBEREaloKqLcUeIiqk6dOly6dAmAyMhIvv/+ewAuXrxIRkZG2UYnIiIiFSwd2J33XEXUlbhdROUXS926dWPNmjUA/PGPf2TMmDEMGzaMAQMGcMcdd5RPlCIiIlJBdgAOIBJo6OFYKje3785r27YtnTp14r777uOPf/wjAM888wze3t5s2bKFvn378uyzz5ZboCIiIlIR8ofyugJaRPtK3C6iNmzYwJtvvsnMmTOZPn06ffv25dFHH+Xpp58uz/hERESkQmk+lLvcHs675ZZbWLRoEadPn+b111/n6NGjdO/enWbNmvHiiy+SlJRUnnGKiIhIuXMCCXnPVURdTYknlgcEBDBkyBA2bNjA/v37+eMf/8i8efO4/vrr+d3vflceMYqIiEiF2A+cB/zIXSNKruSaPvaladOm/OUvf+HZZ58lMDCQlStXllVcIiIiUuHyh/I6Ad6eDKRKKNXHvgBs3LiRRYsWsWzZMiwWC/369eORRx4py9hERESkQmk+VEmUqIg6deoUixcvZvHixRw8eJAuXbrwt7/9jX79+hEQoGXhRUREqjZ96HBJuF1E3XXXXXz++efUq1ePhx56iKFDh9K8efPyjE1EREQqzE/A3rzncZ4MpMpwu4jy9vbmww8/5J577sFqtZZnTCIiIlLhtuZ9bQbU82QgVYbbRdTy5cvLMw4RERHxKM2HKqlrujtPREREqgsVUSWlIkpERKTGswPb856riHKXiigREZEa71sgA6gNtPRwLFWHiigREZEaL38oLw6VBu5TpkRERGo8zYcqDRVRIiIiNV5+EdXVo1FUNSqiREREarQTQCK5JUFnD8dStXi8iJo3bx7R0dH4+voSGxvL9u3br9j+4sWLjBw5koiICHx8fGjWrBmrVq1y7b906RJjx44lKioKPz8/unTpwo4dOwr1s2fPHn73u99Ru3ZtAgIC6NSpE4mJia79ly9fZuTIkdStW5datWrRt29fkpOTy+6Ni4iIVAoJeV/bAbU8GUiV49Ei6v3332f8+PFMmTKFXbt20a5dO3r37s2ZM2eKbJ+dnU3Pnj05evQoH374Ifv27eONN94gMjLS1ebRRx9lzZo1vP3223z33Xf06tWLHj16cPLkSVebQ4cOcfPNN9OiRQvWr1/Pt99+y1//+ld8fX1dbcaNG8eKFSv44IMP2LBhA6dOneL+++8vv2SIiIh4hOZDlVaJPoC4rM2ZM4dhw4YxZMgQABYsWMDKlStZtGgRTz/9dKH2ixYt4vz582zZsgVvb28AoqOjXfszMzNZtmwZn3zyCd26dQNg6tSprFixgvnz5zNt2jQAnnnmGfr06cNLL73kOrZJkyau5ykpKfzrX/9iyZIl3H777QC8+eabtGzZkq1bt3LTTTeVbSJEREQ8RkVUaXmsiMrOzmbnzp1MmjTJtc1isdCjRw8SEhKKPGb58uXExcUxcuRIPvnkE+rXr8/AgQOZOHEiVquVnJwcHA5HgStKAH5+fmzatAkAp9PJypUreeqpp+jduzdff/01jRo1YtKkSdx3330A7Ny5E7vdTo8ePVx9tGjRguuvv56EhIRii6isrCyysrJcr1NTUwGw2+3Y7faSJ6kY+X2VZZ/VlXJVMsqX+5Qr9ylX7qv4XGXi5bULwwC7vRO5i25WDeWZK3f79FgRde7cORwOB2FhYQW2h4WFsXfv3iKPOXz4MOvWrWPQoEGsWrWKgwcP8sQTT2C325kyZQqBgYHExcXxwgsv0LJlS8LCwnjvvfdISEigadOmAJw5c4a0tDRmzZrFtGnTePHFF1m9ejX3338/X3zxBd27dycpKQmbzUZwcHCh2JKSkop9TzNnzuS5554rtP2zzz7D39+/hBm6ujVr1pR5n9WVclUyypf7lCv3KVfuq6hc1a37AzffnMPly3WIj/8B+LFCzluWyiNXGRkZbrXz6HBeSTmdTkJDQ1m4cCFWq5WYmBhOnjzJ7NmzmTJlCgBvv/02Q4cOJTIyEqvVSocOHRgwYAA7d+509QFw7733Mm7cOADat2/Pli1bWLBgAd27dy91fJMmTWL8+PGu16mpqTRs2JBevXoRFBRU6n5/zW63s2bNGnr27Oka1pSiKVclo3y5T7lyn3LlvorOlcXyPQA226306XN3uZ+vLJVnrvJHkq7GY0VUvXr1sFqthe54S05OJjw8vMhjIiIi8Pb2xmq1ura1bNmSpKQksrOzsdlsNGnShA0bNpCenk5qaioRERH079+fxo0bu87r5eVFq1atCvTdsmVL15BfeHg42dnZXLx4scDVqCvFBuDj44OPj0+h7d7e3uXyn6G8+q2OlKuSUb7cp1y5T7lyX8XlahsAFsvNWCxV89+mPHLlbn8euzvPZrMRExPD2rVrXducTidr164lLi6uyGO6du3KwYMHXVeTAPbv309ERAQ2m61A24CAACIiIrhw4QLx8fHce++9rvN26tSJffv2FWi/f/9+oqKiAIiJicHb27tAbPv27SMxMbHY2ERERKoWE00qvzYeHc4bP348gwcPpmPHjnTu3Jm5c+eSnp7uulvvoYceIjIykpkzZwIwYsQI/v73vzNmzBiefPJJDhw4wIwZMxg9erSrz/j4eEzTpHnz5hw8eJAJEybQokULV58AEyZMoH///nTr1o3bbruN1atXs2LFCtavXw9A7dq1eeSRRxg/fjwhISEEBQXx5JNPEhcXpzvzRESkmjgA/AT4ADd6OJaqyaNFVP/+/Tl79iyTJ08mKSmJ9u3bs3r1atdk88TERCyWny+WNWzYkPj4eMaNG0fbtm2JjIxkzJgxTJw40dUmJSWFSZMmceLECUJCQujbty/Tp08vcGnu97//PQsWLGDmzJmMHj2a5s2bs2zZMm6++WZXm1dffRWLxULfvn3Jysqid+/e/OMf/6iArIiIiFSE/KtQHcktpKSkPD6xfNSoUYwaNarIfflXhn4pLi6OrVu3Fttfv3796Nev31XPO3ToUIYOHVrsfl9fX+bNm8e8efOu2peIiEjVo6G8a+Xxj30RERERT1ARda1URImIiNQ4F4Ef8p7rhqnSUhElIiJS4+RPi2kChF2poVyBiigREZEaJ38or6tHo6jqVESJiIjUOJoPVRZURImIiNQoOeSvVK4i6tqoiBIREalRvgfSgCCg1VXaypWoiBIREalR8ofybgKsV2ooV6EiSkREpEbRfKiyoiJKRESkRtmc91VF1LVSESUiIlJjnAKOAgYQ69lQqgEVUSIiIjVGQt7X35A7sVyuhYooERGRGkPzocqSiigREZEaQ0VUWVIRJSIiUiNcBnbmPVcRVRZURImIiNQIOwE7EAo09nAs1YOKKBERkRrhl0N5hicDqTZURImIiNQImg9V1lREiYiIVHsmPxdRXT0ZSLWiIkpERKTaOwycAWxABw/HUn2oiBIREan28q9CxQC+ngykWlERJSIiUu1pPlR5UBElIiJS7amIKg8qokRERKq1VOC7vOdxngyk2lERJSIiUq1tI/fuvEZAhIdjqV5URImIiFRrm/O+aiivrKmIEhERqdY0H6q8qIgSERGpthzA1rznKqLKmoooERGRausH4BJQC2jj4ViqHxVRIiIi1Vb+UF4s4OXJQKolFVEiIiLVluZDlScVUSIiItWWiqjypCJKRESkWkoGDuU9v8mTgVRbKqJERESqpYS8r62BYA/GUX2piBIREamW8ofyuno0iupMRZSIiEi1pPlQ5U1FlIiISLWTBXyV91xFVHmpFEXUvHnziI6OxtfXl9jYWLZv337F9hcvXmTkyJFERETg4+NDs2bNWLVqlWv/pUuXGDt2LFFRUfj5+dGlSxd27NhRoI+HH34YwzAKPO68884CbaKjowu1mTVrVtm9cRERkXLxNbmFVD2gqYdjqb48vvLW+++/z/jx41mwYAGxsbHMnTuX3r17s2/fPkJDQwu1z87OpmfPnoSGhvLhhx8SGRnJsWPHCA4OdrV59NFH+f7773n77bdp0KAB77zzDj169ODHH38kMjLS1e7OO+/kzTffdL328fEpdL7nn3+eYcOGuV4HBgaW0TsXEREpL78cyjM8GUi15vEias6cOQwbNowhQ4YAsGDBAlauXMmiRYt4+umnC7VftGgR58+fZ8uWLXh7ewO5V4zyZWZmsmzZMj755BO6desGwNSpU1mxYgXz589n2rRprrY+Pj6Eh4dfMb7AwMCrthEREalcNB+qInh0OC87O5udO3fSo0cP1zaLxUKPHj1ISEgo8pjly5cTFxfHyJEjCQsLo02bNsyYMQOHwwFATk4ODocDX1/fAsf5+fmxadOmAtvWr19PaGgozZs3Z8SIEfz000+Fzjdr1izq1q3LjTfeyOzZs8nJybnWty0iIlKOTGBz3nMVUeXJo1eizp07h8PhICwsrMD2sLAw9u7dW+Qxhw8fZt26dQwaNIhVq1Zx8OBBnnjiCex2O1OmTCEwMJC4uDheeOEFWrZsSVhYGO+99x4JCQk0bfrzuPCdd97J/fffT6NGjTh06BB/+ctfuOuuu0hISMBqtQIwevRoOnToQEhICFu2bGHSpEmcPn2aOXPmFBlbVlYWWVlZrtepqakA2O127Hb7NeXql/L7Kss+qyvlqmSUL/cpV+5TrtxXNrk6grd3EqbpRU5OO6B65r08v6/c7dMwTdMs87O76dSpU0RGRrJlyxbi4uJc25966ik2bNjAtm3bCh3TrFkzLl++zJEjR1zFzpw5c5g9ezanT58G4NChQwwdOpSNGzditVrp0KEDzZo1Y+fOnezZs6fIWA4fPkyTJk34/PPPueOOO4pss2jRIh577DHS0tKKnD81depUnnvuuULblyxZgr+//9UTIiIico2uu24DMTGvcuHCDWzcONvT4VRJGRkZDBw4kJSUFIKCgopt59ErUfXq1cNqtZKcnFxge3JycrHzkCIiIvD29nYVUAAtW7YkKSmJ7OxsbDYbTZo0YcOGDaSnp5OamkpERAT9+/encePGxcbSuHFj6tWrx8GDB4stomJjY8nJyeHo0aM0b9680P5JkyYxfvx41+vU1FQaNmxIr169rviPUFJ2u501a9bQs2dP17wwKZpyVTLKl/uUK/cpV+4ri1xZLKsBCAq6iz59+pRleJVKeX5f5Y8kXY1HiyibzUZMTAxr167lvvvuA8DpdLJ27VpGjRpV5DFdu3ZlyZIlOJ1OLJbcKV379+8nIiICm81WoG1AQAABAQFcuHCB+Ph4XnrppWJjOXHiBD/99BMRERHFttm9ezcWi6XIuwYhd6J6UVeovL29y+UHR3n1Wx0pVyWjfLlPuXKfcuW+a8vVVgCs1puxWqt/vsvj+8rd/jy+TtT48eN54403eOutt9izZw8jRowgPT3ddbfeQw89xKRJk1ztR4wYwfnz5xkzZgz79+9n5cqVzJgxg5EjR7raxMfHs3r1ao4cOcKaNWu47bbbaNGihavPtLQ0JkyYwNatWzl69Chr167l3nvvpWnTpvTu3RuAhIQE5s6dyzfffMPhw4d59913GTduHA8++CB16tSpwAyJiIi46xLwbd7zuCs1lDLg8SUO+vfvz9mzZ5k8eTJJSUm0b9+e1atXuyabJyYmuq44ATRs2JD4+HjGjRtH27ZtiYyMZMyYMUycONHVJiUlhUmTJnHixAlCQkLo27cv06dPd1WWVquVb7/9lrfeeouLFy/SoEEDevXqxQsvvOC6kuTj48PSpUuZOnUqWVlZNGrUiHHjxhUYrhMREalctgNO4HrgOg/HUv15vIgCGDVqVLHDd+vXry+0LS4ujq1btxbbX79+/ejXr1+x+/38/IiPj79iTB06dLjiOURERCofrQ9VkTw+nCciIiJlRUVURVIRJSIiUi04gfyFqrt6MpAaQ0WUiIhItbAHSAH8gbYejqVmUBElIiJSLeQP5cVSSaY8V3sqokRERKoFzYeqaCqiREREqgUVURVNRZSIiEiVdw7Yn/f8Jk8GUqOoiBIREany8u/KawmEeDKQGkVFlIiISJW3Oe+rhvIqkoooERGRKk/zoTxBRZSIiEiVlg3syHuuIqoiqYgSERGp0nYDl8mdC9XMs6HUMCqiREREqrT8obw49Gu9YinbIiIiVZrmQ3mKiigREZEqy0R35nmOiigREZEq6zhwCrACnTwcS82jIkpERKTKyh/KuxEI8GQgNZKKKBERkSpL86E8SUWUiIhIlaUiypNURImIiFRJ6eSuEQUqojxDRZSIiEiVtANwANcBDT0cS82kIkpERKRK0lCep6mIEhERqZJURHmaiigREZEqx4mKKM9TESUiIlLl7AMuAH5Ae8+GUoOpiBIREaly8q9CdQK8PRlIjaYiSkREpMrRUF5loCJKRESkylERVRmoiBIREalSfgL25j2P82QgNZ6KKBERkSpla97XZkA9TwZS46mIEhERqVI0lFdZqIgSERGpUlREVRYqokRERKoMO7A973lXTwYiqIgSERGpQr4FMoBgoIVnQxEVUSIiIlVH/lBeHPoV7nn6FxAREakyNB+qMlERJSIiUmWoiKpMVESJiIhUCSeARHJ/dXf2cCwClaSImjdvHtHR0fj6+hIbG8v27duv2P7ixYuMHDmSiIgIfHx8aNasGatWrXLtv3TpEmPHjiUqKgo/Pz+6dOnCjh07CvTx8MMPYxhGgcedd95ZoM358+cZNGgQQUFBBAcH88gjj5CWllZ2b1xERMRtCXlf2wG1PBmI5PHydADvv/8+48ePZ8GCBcTGxjJ37lx69+7Nvn37CA0NLdQ+Ozubnj17EhoayocffkhkZCTHjh0jODjY1ebRRx/l+++/5+2336ZBgwa888479OjRgx9//JHIyEhXuzvvvJM333zT9drHx6fAuQYNGsTp06dZs2YNdrudIUOGMHz4cJYsWVL2iRAREbmizXlfNZRXWXi8iJozZw7Dhg1jyJAhACxYsICVK1eyaNEinn766ULtFy1axPnz59myZQve3t4AREdHu/ZnZmaybNkyPvnkE7p16wbA1KlTWbFiBfPnz2fatGmutj4+PoSHhxcZ1549e1i9ejU7duygY8eOALz++uv06dOHl19+mQYNGpTJ+xcREXGP5kNVNh4torKzs9m5cyeTJk1ybbNYLPTo0YOEhIQij1m+fDlxcXGMHDmSTz75hPr16zNw4EAmTpyI1WolJycHh8OBr69vgeP8/PzYtGlTgW3r168nNDSUOnXqcPvttzNt2jTq1q0LQEJCAsHBwa4CCqBHjx5YLBa2bdvG73//+0KxZWVlkZWV5XqdmpoKgN1ux263lzA7xcvvqyz7rK6Uq5JRvtynXLlPuXJf8bnKwMvrawwD7PZO5C66WbOV5/eVu316tIg6d+4cDoeDsLCwAtvDwsLYu3dvkcccPnyYdevWMWjQIFatWsXBgwd54oknsNvtTJkyhcDAQOLi4njhhRdo2bIlYWFhvPfeeyQkJNC0aVNXP3feeSf3338/jRo14tChQ/zlL3/hrrvuIiEhAavVSlJSUqHhRC8vL0JCQkhKSioytpkzZ/Lcc88V2v7ZZ5/h7+9f0vRc1Zo1a8q8z+pKuSoZ5ct9ypX7lCv3/TpXdev+wM0353D5ch3i438AfvRMYJVQeXxfZWRkuNXO48N5JeV0OgkNDWXhwoVYrVZiYmI4efIks2fPZsqUKQC8/fbbDB06lMjISKxWKx06dGDAgAHs3LnT1c8DDzzgev6b3/yGtm3b0qRJE9avX88dd9xRqtgmTZrE+PHjXa9TU1Np2LAhvXr1IigoqJTvuDC73c6aNWvo2bOna0hTiqZclYzy5T7lyn3KlfuKy5XF8j0ANtut9Olzt6fCq1TK8/sqfyTpajxaRNWrVw+r1UpycnKB7cnJycXOVYqIiMDb2xur1era1rJlS5KSksjOzsZms9GkSRM2bNhAeno6qampRERE0L9/fxo3blxsLI0bN6ZevXocPHiQO+64g/DwcM6cOVOgTU5ODufPny82Nh8fn0KT0wG8vb3L5QdHefVbHSlXJaN8uU+5cp9y5b7CudoGgMVyMxaLcvhL5fF95W5/Hl3iwGazERMTw9q1a13bnE4na9euJS4urshjunbtysGDB3E6na5t+/fvJyIiApvNVqBtQEAAERERXLhwgfj4eO69995iYzlx4gQ//fQTERERAMTFxXHx4sUCV6/WrVuH0+kkNja2VO9XRESk5Ew0qbxy8vg6UePHj+eNN97grbfeYs+ePYwYMYL09HTX3XoPPfRQgYnnI0aM4Pz584wZM4b9+/ezcuVKZsyYwciRI11t4uPjWb16NUeOHGHNmjXcdttttGjRwtVnWloaEyZMYOvWrRw9epS1a9dy77330rRpU3r37g3kXt268847GTZsGNu3b2fz5s2MGjWKBx54QHfmiYhIBToA/AT4ADd6OBb5JY/Pierfvz9nz55l8uTJJCUl0b59e1avXu2abJ6YmIjF8nOt17BhQ+Lj4xk3bhxt27YlMjKSMWPGMHHiRFeblJQUJk2axIkTJwgJCaFv375Mnz7ddXnOarXy7bff8tZbb3Hx4kUaNGhAr169eOGFFwoMx7377ruMGjWKO+64A4vFQt++ffnb3/5WQZkRERGBn69CdSK3kJLKwuNFFMCoUaMYNWpUkfvWr19faFtcXBxbt24ttr9+/frRr1+/Yvf7+fkRHx9/1bhCQkK0sKaIiHiYhvIqK48P54mIiMiVqIiqrFREiYiIVFoXgR/ynhd9w5V4joooERGRSit/6kpToPDnyYpnqYgSERGptDSUV5mpiBIREam0VERVZiqiREREKqUc8lcqVxFVOamIEhERqZS+A9KAIKCVh2ORoqiIqmJMp0nOsRzqX6hPzrEcTKfp6ZBERIqln1nXIn8o7ybAeqWG4iGVYrFNccdUcs5C2rtjMS+ZtKQll9+7TFZgFrUGzcWrfm4bEZHKQT+zrp3mQ1V2uhJVReScBa/6z+HT/qUC233av4RX/efIOeuhwEREiqCfWWVBRVRlpytRVYDpNEl7dyw+7bPxu3UmAJe/nIDvLbPxu3UmmesnkfXNWGo/aWJYDA9HKyI1nX5mlYVTwFHAAGI9G4oUS0VUFZCTmIN5yeTylxMA8Lt1Jr7dZ2EYJtmHbsXxU1Mstb7CfqgF3k0bYBi6wCginmM/lo3hdRjH+cbYEzsX/Jl18DYcyW0wbHuxH2mNrUmgp8OtlAwjf5HN35A7sVwqIxVRVYCZ9vNEzMtfTnD9MAKwNVmPrcn6n9tm++NIux4zMwozJxrMKPBqjOETjaVWEwzfEBVZIlJmTNOJeSkRR+p2yNmB4bMTr4hd1B6VUqCd62dW0y+wNf0i91inBUfK9ZjpTTDtzYCmGN7NMQKaYQlshGGpub+ifi6iNJRXlF/fsODV2MsjVzVr7ndoFWLU+vkbw/eW2RiGiemwYlgd5CS1huxaWIITMQKTMGwZWEP2AnuL7MvMqoUjLRrz8vWYOVFAI7BGY/g2xlqrCYZvcIW8JxGpmpxpJ3GkbAP7Vxi2r7AEf40l6ByWX10sMXNsOJLbYJrgfd0uTIcXhjWHnDMtweGNNeQwhk8a1tpHofZRYG3h4y82wsxsgmm/AYwbMHyaYwlojlErstr/MWgYCXnPVET9WvaebDLiMwrdsODf2x9bS1uFxqIiqgrwut4LI9DAp/1LrvkEhecXPEXQCB+c6ccwLx/BzD4M5lGwHsPwOYolIBFLQHLuDy2f74HvizyXMzMYM/16zMtRmI5oIBq8GmHxbYwlsDGGTZfeRWoKZ8YZnBe3Y2bvwPDaiSV4F5Zap7HUKtjOdHjhvNAKZ3oHoCP4dSJ9aTQ+becW+zMr7ZsJBA5Jx8zYh5m9H5z7MbwOYvgfxBJ0BMMrC2vIPmBfobjM7AAcqY1xZjYFxw1guQHDtzmWWi0w/OphGFV7npXFko1h7Mp71dWjsVQ22XuySf8wvdB285KZu/0PVGghpSKqCjAsRt4twT//MAIKzJHybm3DYpsKthZAiyL7Me0ZONOOYGYexrQfBfMIWI9i8T2GEXAMi/9PWPwugt9F4Nsi+3Bm1MVMvx7n5WhwRIHRGMM7GsO3UW6R5e1fxu9eRCqC8/J5nBd2YGblFUyBu7DUTsTyq//SptOC80KL3ILJjMHw64w15Eas9fyw1vu5Xa0BU6/6M8saNBWCrgPu+NU5cnCkHsNM34+ZvQ/Yj+GdX2AlYtjSsdb7DivfFX4fmcE4LjWFrKaYjhswrM3AtxnWoBYYPlVjblFw8CEMww6EAY08HU6l4XQ4yYjPuGKbjM8y8G7uXWFDeyqiqgiv+pBzdgpZu8cCP8+RyvrmKbxb2/LWXLkyw9sfa53WUKd1kfvN7Es4Lx3Gefkw5BwFjmBYj2H4HsUISMTidxGL/0/g/xNWvi6yD2d6KM70KMysKHBEgxGN4d0Iw68xlsBoDC/fkr51ESljZvYlHBe+wszcDtbcgskafAhLROG2jgs3YF7qgGnGYPh2wlqnI9a6tbDWvfI5ruVnlmHxwhrUBIKaAHcVjN2RhePCIZwZ+8C+H4z9GLZDWGodwBJ4KvfnlN9XwFeF+nWmh+G81BQzqymYN4BXMyx+zbHUvgHDy+/Kb6gChYTkT8foQu7dedWX6TQxM0zMdBNnurPw14xfvL7kBOdV+ks1yUnMwTvau0LiVxFVZUzFqz7UHm1y+fBlvt70NTfefCO+jX0xLFPL5AyGLRBr3XZYaVfkfvPyRRxphzCzjkDOEeAohtdRDN9ELLWOYvikYQk4gyXgDLCj8PGmgfNSBM6M6yErCtMZnVtk2Rpj+DfCUisKw1p2l2Ery8RDEU8y7Rk4LuzKLZiMnVhq7cJSZx9eYYVXDnemROFIjQFHXsEU3AlrnWCoU5ozl8/PLMPqg7VOK6x1Cn8MimlPx5G6DzPzAOTsA8tBDJ8DWAIPYvE/hyUgGUtAMrC54HGmgTP1OpxpTXPnX5k3YHg3wwhojiWoMYalYn4h5ytYRFU9pr2YgqiIr2ZG2a9g/8ubscqbiqgqxrAYeEV5cfaHs3hFVWxRYPgG4+UbA8QU2meaTpyZ53GmHf65yDLyiiy/Y1hqJWLYMjACT2EJPAVsLdyH04IztQHOjCjM7GhwRoGlEYatEYZfIyyB17t5t45WSpaayXRk4Ti/GzNjB/AVloBdWEJ+xCvUUait81IDnCkxmDkxGLZOWII7YaldH0vtso2pIn9mGd4BeNXtAHQotM95+TzOS/sg8wCmcx+G9SCG7wEsQQcxfC5hBB3HEnQc+KLAcabDC8eFaMyMppj2pmA0x7A1y53gHngdhlF2H8eS+4efnbqR+/Nex1EZ5s+bpomZWczVogwnZlre17ztZJf8HIa/geFvYKllKfprgAXHBQcZH195OA8K3oxV3lRESZkwDAuGXz0sfvWAzoX2m6YTZ/pZnOmHIOsopuNwbpHlfRTDLxFLYCKGVxZG0AksQSf49V+KkDd5NSUSZ0Y0pj0KnNFgicbwaYTFvwlGrQYYhvUXKyVnu+ZgQP5KyTPJOTvFreFPkcrMdNpxXPgOM30HmDux+H+Fpc4PeNUv/BvMmV4f58UOmPaOGN55BVNgAyw16D4Ri28IFt84IK7A9tyfTWdwpu3FzNoPzgMYXgcw/A5iCTqM4Z2Jtc5BqHOwUJ+m3Q9HamPMzKaYOXkT3G3NsQQ2x/APLcEdhD//4Wd4Hab2qAuYOTZS5jeh1gNTy+UPP9NxhSG0IobUrjaMVogVjIDc4ueqX/0Nt4prawMrmWszMS8Vf6XJCDLwur7iShsVUVIhDMOCERCGJSCMoi5Rm6YDZ1oSzozDcPkIpjPvSpbtWO6VrMDjGFY7Ru1jWGofK/IcZo4NR1pDzEsNybG3x+/WmVhCfyRr6whsrT7G96YFWilZqiTTdOC8sAdn2nYwv8Lw3YU15Fu86mbCr+YmOTPr4LxwI2Z2DHh1wlo7FqPWdXgFVIJLGpVQ7s+mcCwB4cCtBfaZpgNn6gmc6Xsxsw+Aue8XE9yP5hZYdX8AfijUr/NyEM5LTXBm3gDOphiW5uB3A5bAFlh8C46P/vIPP+fF6wFwnG6Hz2/+5vYffqZpQhaF5xOlFf3VvFzyIS/D1yhQ+FzpqhE+lPldkobFwL+3f5F35+Xz7+VfoT/bVURJpWAYVoxakVhqRQK3FNpvOnNwXjqFMyNvTpbzKFhyiyyL31GMwJMYXtlYgw9hDT7kOs6n1Sf4tPrE9dr35lfw6bAY5091MXPqY+bUA2c9MOuBEQrW+hhe9TBsoRg+oRh+dWv0gn9S8UzTiTPlIOal7ZiOHbkFU53dWEPSsIb8qm1WII4LN2Je7gDWzliCOmEJaoxXAxVMZcEwrBhBUViCooDeBfaZTjuOi4cx0/dh2veDcQDDdgBLwEGMwBNYfFPB9+sib8JxptfHmdYEM+sGTEcT7N82JqfBo/jdOpOckzfm9m8aPy9hs2ss/r/LLn5ILe8rhUdtr/IGS3C1KMDAsHr+D09bSxv8Adc6UfmMIAP/XlonSqRIhsULI/B6LIHXA7cV2m867ThSjmM/vB9H4iEsdY5hqX0cW9v3cxcnNcEwwPDKxgg6DZx267ymaeDMqIOZVQ8zux7Y62E66oJZH6iPYQkFr3rgXR+LbxiGX6juQBS3FbXat6XOLqzBKRD8q7bZ/jgutMstmCwdsdSKxRLcDK/wspuTI+4zLN5Yg5tDcPNC+8ycTBwpB3Bm7oOcvALL52DuBPeAZCwBZ7EEnCV/bqjtF6sYeEXmFl3e12//xfIQJunvFX/1pQAbPxc//haMWsV8DTAw/IwquaaWraUN7+beRdywoBXLRUrFsHhjrd0YZ52GZP4v98M6Xau759gwvLLJ3Phnsnf/CcP/HD5xl7AE/gTOs8A5sJzDsJwF73MYPucwfHLXzDIME8P/PPifB/a7FYuZVQvzct3cwsteD9ORd7WL+mCpD9Z6GN6hGLZQLH5hYAusFKsv625G95U2V+6v9u2D4/xvMDNjwIjBEtAZS53WeIXpR3ZVYHj5Ya3bFittC+0zs1JxpO6FywcwHfswcw5g8T2Ape6h3HX68tvleBeY02kEGljrWq9+xci7Zvyf9eRNVr+k/5FSrVxtdXec3mR98xS2lrWv+p/OdGRjXj6HefkMpv0s2M9iOs+AeRaMn8ByFsP7XO7D96fchzUHwycNwycNKHruVqHz5NhwXq6LeTmv6KrwIUbdzeg+93NVotW+z7fGmZG72rfh3wlrSFu8Qn0q+L1JRTB8gvCq35n8G3DsR+1cejMNAN/bnsfv5rmYDm8MLzu+t8x2FVIB9wVU2NpH4j4VUVKtuLu6uzvr1BhWG0ZAAwho4Na5c5d5uJBbdGWfxcw5A46zuVe7jHNgnMPwyiu8fM5h+J7PXfbBKxuj1mmoVTZDjFjrYVhDfzHEWP+KCwnqbkb3FZurmOfxqv8qOcm3g/33bqz2HZO32nen3NW+6/uhQbmaqcAffjfPLfyHH7kLlFbkHWfiPv2rSLVTFqu7l0buMg91wa8u0NKtY0x7Os6MZMzsM2A/l1t4lfsQY11MR33XEKN9Tz0c1/0Bv1tnYvheIGvHY/h0WojvTfO5vO0xsn+8B//f/ZC7Xo1pgukkN68mJs5C26Co1ya590jnPy+unfNXx5iYOHKfG/nbyO0rb79Bwb5Nw1nwfAUezoLnB3Jn4/4qBuNXceb1ZT8Kzoa34nfrTLyiNmGmh+LVeB0W/wsAeIWtK5B3x4UbMNNiMB15BVOdGLdW+5aaoyz/8JOKpyJKqqHyX929rBjeAVhrNwYau9W+PIYYvaN/fu570wJ8b1rw8+vYf+Ib+89re5PVyC9z5d3oywL7HOejcZxuj2nphLVOZ6x1OmGtU7uUq31LTeKpP/zk2qmIkmqrskw8LEtlPcRo2s9icBbD/ycM/5+w1D6OYeRdhMnOm7xjGpgYYFoAA0wj92tR24r4amK58jGFtvHza37VT4Hjiuk3/7PGzLw2vz7m1+fO22b+qo2R384wME0LZjZ5HyeRey5buyUYFiemw4uUOfswL+dWSwG/D8ArvGJvs5aqrur84ScFqYgSqcauNsRoP2on7e28Sa15czBcdzMmPOkaUqj1p1o1flKr/aid9BU/58qwOF258un0f65cVeRHTkj1Uh3/8KvuVESJ1GBXvZsRTWrNp1yJyK/pf7tIDaZJre5TrkTk11REidRwmtTqPuVKRH5JRZRIjadJre5TrkTkZ57/rAkRqRRck1rraFLr1ShXIgIqokRERERKRUWUiIiISClUiiJq3rx5REdH4+vrS2xsLNu3b79i+4sXLzJy5EgiIiLw8fGhWbNmrFq1yrX/0qVLjB07lqioKPz8/OjSpQs7duwotr/HH38cwzCYO3duge3R0dEYhlHgMWvWrGt6ryIiIlI9eHxi+fvvv8/48eNZsGABsbGxzJ07l969e7Nv3z5CQ0MLtc/OzqZnz56Ehoby4YcfEhkZybFjxwgODna1efTRR/n+++95++23adCgAe+88w49evTgxx9/JDIyskB/H330EVu3bqVBg6JXgH7++ecZNmyY63VgYGDZvHERERGp0jx+JWrOnDkMGzaMIUOG0KpVKxYsWIC/vz+LFi0qsv2iRYs4f/48H3/8MV27diU6Opru3bvTrl07ADIzM1m2bBkvvfQS3bp1o2nTpkydOpWmTZsyf/78An2dPHmSJ598knfffRdv76JXYw4MDCQ8PNz1CAgIKNsEiIiISJXk0SIqOzubnTt30qNHD9c2i8VCjx49SEhIKPKY5cuXExcXx8iRIwkLC6NNmzbMmDEDh8MBQE5ODg6HA19f3wLH+fn5sWnTJtdrp9PJn/70JyZMmEDr1q2LjXHWrFnUrVuXG2+8kdmzZ5OTk3Mtb1lERESqCY8O5507dw6Hw0FYWFiB7WFhYezdu7fIYw4fPsy6desYNGgQq1at4uDBgzzxxBPY7XamTJlCYGAgcXFxvPDCC7Rs2ZKwsDDee+89EhISaNq0qaufF198ES8vL0aPHl1sfKNHj6ZDhw6EhISwZcsWJk2axOnTp5kzZ06R7bOyssjKynK9Tk1NBcBut2O3293Oy9Xk91WWfVZXylXJKF/uU67cp1y5T7lyX3nmyt0+DdM0zas3Kx+nTp0iMjKSLVu2EBcX59r+1FNPsWHDBrZt21bomGbNmnH58mWOHDmC1WoFcocEZ8+ezenTpwE4dOgQQ4cOZePGjVitVjp06ECzZs3YuXMne/bsYefOndx9993s2rXLNRcqOjqasWPHMnbs2GLjXbRoEY899hhpaWn4+PgU2j916lSee+65QtuXLFmCv79/iXIjIiIinpGRkcHAgQNJSUkhKCio2HYevRJVr149rFYrycnJBbYnJycTHh5e5DERERF4e3u7CiiAli1bkpSURHZ2NjabjSZNmrBhwwbS09NJTU0lIiKC/v3707hxYwC+/PJLzpw5w/XXX+/qw+Fw8P/+3/9j7ty5HD16tMhzx8bGkpOTw9GjR2nevHmh/ZMmTWL8+PGu16mpqTRs2JBevXpd8R+hpOx2O2vWrKFnz57FzuWSXMpVyShf7lOu3KdcuU+5cl955ip/JOlqPFpE2Ww2YmJiWLt2Lffddx+QO1dp7dq1jBo1qshjunbtypIlS3A6nVgsuVO69u/fT0REBDabrUDbgIAAAgICuHDhAvHx8bz00ksA/OlPfyowDwugd+/e/OlPf2LIkCHFxrt7924sFkuRdw0C+Pj4FLhClX+RLzMzs0z/ge12OxkZGWRmZmqO1lUoVyWjfLlPuXKfcuU+5cp95ZmrzMxM4Off48UyPWzp0qWmj4+PuXjxYvPHH380hw8fbgYHB5tJSUmmaZrmn/70J/Ppp592tU9MTDQDAwPNUaNGmfv27TP/97//maGhoea0adNcbVavXm1++umn5uHDh83PPvvMbNeunRkbG2tmZ2cXG0dUVJT56quvul5v2bLFfPXVV83du3ebhw4dMt955x2zfv365kMPPeT2ezt+/LhJ7qeU6qGHHnrooYceVexx/PjxK/6e9/g6Uf379+fs2bNMnjyZpKQk2rdvz+rVq12TzRMTE11XnAAaNmxIfHw848aNo23btkRGRjJmzBgmTpzoapOSksKkSZM4ceIEISEh9O3bl+nTp5foapCPjw9Lly5l6tSpZGVl0ahRI8aNG1dguO5qGjRowPHjxwkMDMQwyu6ztfKHCY8fP16mw4TVkXJVMsqX+5Qr9ylX7lOu3FeeuTJNk0uXLhW7hmQ+j04sl9JJTU2ldu3aV53wJspVSSlf7lOu3KdcuU+5cl9lyJXHF9sUERERqYpURImIiIiUgoqoKsjHx4cpU6YUuVaVFKRclYzy5T7lyn3KlfuUK/dVhlxpTpSIiIhIKehKlIiIiEgpqIgSERERKQUVUSIiIiKloCJKREREpBRURFVB8+bNIzo6Gl9fX2JjY9m+fbunQ6qUNm7cyG9/+1saNGiAYRh8/PHHng6pUpo5cyadOnUiMDCQ0NBQ7rvvPvbt2+fpsCql+fPn07ZtW4KCgggKCiIuLo5PP/3U02FVCbNmzcIwDMaOHevpUCqlqVOnYhhGgUeLFi08HValdfLkSR588EHq1q2Ln58fv/nNb/jqq68qPA4VUVXM+++/z/jx45kyZQq7du2iXbt29O7dmzNnzng6tEonPT2ddu3aMW/ePE+HUqlt2LCBkSNHsnXrVtasWYPdbqdXr16kp6d7OrRK57rrrmPWrFns3LmTr776ittvv517772XH374wdOhVWo7duzgn//8J23btvV0KJVa69atOX36tOuxadMmT4dUKV24cIGuXbvi7e3Np59+yo8//sgrr7xCnTp1KjwWLXFQxcTGxtKpUyf+/ve/A+B0OmnYsCFPPvkkTz/9tIejq7wMw+Cjjz7ivvvu83Qold7Zs2cJDQ1lw4YNdOvWzdPhVHohISHMnj2bRx55xNOhVEppaWl06NCBf/zjH0ybNo327dszd+5cT4dV6UydOpWPP/6Y3bt3ezqUSu/pp59m8+bNfPnll54ORVeiqpLs7Gx27txJjx49XNssFgs9evQgISHBg5FJdZKSkgLkFgdSPIfDwdKlS0lPTycuLs7T4VRaI0eO5O677y7wc0uKduDAARo0aEDjxo0ZNGgQiYmJng6pUlq+fDkdO3bkj3/8I6Ghodx444288cYbHolFRVQVcu7cORwOB2FhYQW2h4WFkZSU5KGopDpxOp2MHTuWrl270qZNG0+HUyl999131KpVCx8fHx5//HE++ugjWrVq5emwKqWlS5eya9cuZs6c6elQKr3Y2FgWL17M6tWrmT9/PkeOHOGWW27h0qVLng6t0jl8+DDz58/nhhtuID4+nhEjRjB69GjeeuutCo/Fq8LPKCKV1siRI/n+++81F+MKmjdvzu7du0lJSeHDDz9k8ODBbNiwQYXUrxw/fpwxY8awZs0afH19PR1OpXfXXXe5nrdt25bY2FiioqL4z3/+o6HiX3E6nXTs2JEZM2YAcOONN/L999+zYMECBg8eXKGx6EpUFVKvXj2sVivJyckFticnJxMeHu6hqKS6GDVqFP/73//44osvuO666zwdTqVls9lo2rQpMTExzJw5k3bt2vHaa695OqxKZ+fOnZw5c4YOHTrg5eWFl5cXGzZs4G9/+xteXl44HA5Ph1ipBQcH06xZMw4ePOjpUCqdiIiIQn+0tGzZ0iPDnyqiqhCbzUZMTAxr1651bXM6naxdu1ZzMqTUTNNk1KhRfPTRR6xbt45GjRp5OqQqxel0kpWV5ekwKp077riD7777jt27d7seHTt2ZNCgQezevRur1erpECu1tLQ0Dh06REREhKdDqXS6du1aaBmW/fv3ExUVVeGxaDivihk/fjyDBw+mY8eOdO7cmblz55Kens6QIUM8HVqlk5aWVuCvuCNHjrB7925CQkK4/vrrPRhZ5TJy5EiWLFnCJ598QmBgoGt+Xe3atfHz8/NwdJXLpEmTuOuuu7j++uu5dOkSS5YsYf369cTHx3s6tEonMDCw0Ly6gIAA6tatq/l2Rfjzn//Mb3/7W6Kiojh16hRTpkzBarUyYMAAT4dW6YwbN44uXbowY8YM+vXrx/bt21m4cCELFy6s+GBMqXJef/118/rrrzdtNpvZuXNnc+vWrZ4OqVL64osvTKDQY/DgwZ4OrVIpKkeA+eabb3o6tEpn6NChZlRUlGmz2cz69eubd9xxh/nZZ595Oqwqo3v37uaYMWM8HUal1L9/fzMiIsK02WxmZGSk2b9/f/PgwYOeDqvSWrFihdmmTRvTx8fHbNGihblw4UKPxKF1okRERERKQXOiREREREpBRZSIiIhIKaiIEhERESkFFVEiIiIipaAiSkRERKQUVESJiIiIlIKKKBEREZFSUBElIlIKhmHw8ccfezoMEfEgFVEiUuM8/PDD3HfffZ4OQ0SqOBVRIiIiIqWgIkpEarRbb72V0aNH89RTTxESEkJ4eDhTp04t0ObAgQN069YNX19fWrVqxZo1awr1c/z4cfr160dwcDAhISHce++9HD16FIC9e/fi7+/PkiVLXO3/85//4Ofnx48//lieb09EypGKKBGp8d566y0CAgLYtm0bL730Es8//7yrUHI6ndx///3YbDa2bdvGggULmDhxYoHj7XY7vXv3JjAwkC+//JLNmzdTq1Yt7rzzTrKzs2nRogUvv/wyTzzxBImJiZw4cYLHH3+cF198kVatWnniLYtIGdAHEItIjfPwww9z8eJFPv74Y2699VYcDgdffvmla3/nzp25/fbbmTVrFp999hl33303x44do0GDBgCsXr2au+66i48++oj77ruPd955h2nTprFnzx4MwwAgOzub4OBgPv74Y3r16gXAPffcQ2pqKjabDavVyurVq13tRaTq8fJ0ACIinta2bdsCryMiIjhz5gwAe/bsoWHDhq4CCiAuLq5A+2+++YaDBw8SGBhYYPvly5c5dOiQ6/WiRYto1qwZFouFH374QQWUSBWnIkpEajxvb+8Crw3DwOl0un18WloaMTExvPvuu4X21a9f3/X8m2++IT09HYvFwunTp4mIiCh90CLicSqiRESuoGXLlhw/frxA0bN169YCbTp06MD7779PaGgoQUFBRfZz/vx5Hn74YZ555hlOnz7NoEGD2LVrF35+fuX+HkSkfGhiuYjIFfTo0YNmzZoxePBgvvnmG7788kueeeaZAm0GDRpEvXr1uPfee/nyyy85cuQI69evZ/To0Zw4cQKAxx9/nIYNG/Lss88yZ84cHA4Hf/7znz3xlkSkjKiIEhG5AovFwkcffURmZiadO3fm0UcfZfr06QXa+Pv7s3HjRq6//nruv/9+WrZsySOPPMLly5cJCgri3//+N6tWreLtt9/Gy8uLgIAA3nnnHd544w0+/fRTD70zEblWujtPREREpBR0JUpERESkFFREiYiIiJSCiigRERGRUlARJSIiIlIKKqJERERESkFFlIiIiEgpqIgSERERKQUVUSIiIiKloCJKREREpBRURImIiIiUgoooERERkVJQESUiIiJSCv8fx4KaA5tjFYgAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " XRP ETH LTC BTC\n", + "0 0.4998 0.368504 0.8036 0.694010\n", + "1 0.4987 0.368769 0.8021 0.694039\n", + "2 0.5000 0.368602 0.8042 0.694019\n", + "3 0.4998 0.368501 0.8039 0.693838\n", + "4 0.5000 0.368537 0.8040 0.694019\n", + "5 0.5002 0.368528 0.8039 0.693984\n", + "6 0.5000 0.368552 0.8041 0.693884\n", + " XRP ETH LTC BTC\n", + "0 0.499800 0.368504 0.803600 0.694010\n", + "1 0.498700 0.368769 0.802100 0.694039\n", + "2 0.500000 0.368602 0.804200 0.694019\n", + "3 0.499800 0.368501 0.803900 0.693838\n", + "4 0.500000 0.368537 0.804000 0.694019\n", + "5 0.500200 0.368528 0.803900 0.693984\n", + "6 0.504505 0.365775 0.809951 0.701323\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHHCAYAAABEEKc/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB9F0lEQVR4nO3deVxU9f7H8dfMsO8uKC4obpmmuQa55JZi2eXWbdGrZeZNrW6WyW1xQzRTbDO6ZXnrl+3e7FZ6W8wkFbXUNM3KckM0XFFUZBMYZub3BzE3FHVA4Az4fvrgIXPme77ncz6O8vF8v99zTA6Hw4GIiIiIOJmNDkBERETE3ahAEhERETmLCiQRERGRs6hAEhERETmLCiQRERGRs6hAEhERETmLCiQRERGRs6hAEhERETmLCiQRERGRs6hAEhFD3HPPPURERBgdhmHc+fzdOTaR6qICSaQWeeuttzCZTHz//feltptMJpe+kpOTAcjKymLmzJl06tSJgIAAfH196dChA0888QSHDx8+7/HLexx3s3//fkaPHk2rVq3w8fEhLCyMPn36EB8fb3RolaJfv36l/hzq1q3LNddcw8KFC7Hb7ZVyjDlz5rB06dJK6UvESB5GByAiVe/dd98t9fqdd94hKSnpnO3t2rUjNTWVgQMHkpaWxh133MG4cePw8vLip59+4o033mDJkiXs3r37ko/z+uuvV9oP5cqQkpLCNddcg6+vL3/729+IiIjgyJEjbN26laeffpqZM2dW6vGMOv+mTZuSkJAAwPHjx3nnnXe499572b17N3Pnzr3k/ufMmcPtt9/OLbfccsl9iRhJBZLIZeCuu+4q9Xrjxo0kJSWds72oqIjBgweTnp5OcnIyvXv3LvX+7Nmzefrppy/5OO7ohRdeICcnh23bttG8efNS7x07dqzSjpObm4u/vz+enp6V1md5BAcHl/rzuO+++2jbti0vv/wys2bNMiwuEXejITYRcfr444/58ccfmTp16jnFEUBQUBCzZ8+ulGOdPc9l//79mEwmnnvuOebPn0/Lli3x8/MjOjqaAwcO4HA4mDVrFk2bNsXX15ebb76ZkydPntPvl19+yXXXXYe/vz+BgYHcdNNN/PLLLxeNZ+/evTRt2vSc4gigQYMGFTrOPffcQ0BAAHv37mXIkCEEBgZy5513lnn+AHa7ncTERK666ip8fHxo2LAh9913H6dOnSrV7vvvv2fw4MHUr18fX19fWrRowd/+9reLnmNZ/Pz8uPbaa8nNzeX48ePnbZebm8s//vEPwsPD8fb2pm3btjz33HM4HA5nG5PJRG5uLm+//bZzGO+ee+6pUFwiRtMVJBFx+vTTTwEYOXKkYTG8//77FBYW8tBDD3Hy5EmeeeYZhg4dyoABA0hOTuaJJ54gJSWFl156iUcffZSFCxc693333XcZNWoUgwcP5umnnyYvL49XX32V3r1788MPP1xw4nHz5s35+uuvWbVqFQMGDLhgjOU5TslVud69e/Pcc8/h5+d33n7vu+8+3nrrLUaPHs3DDz/Mvn37ePnll/nhhx/49ttv8fT05NixY0RHRxMaGsqkSZMICQlh//79fPLJJy7n+GypqalYLBZCQkLKfN/hcPDnP/+Z1atXc++999K5c2e++uorHnvsMQ4dOsQLL7zgzMuYMWOIjIxk3LhxALRq1arCcYkYyiEitcabb77pABybN2++YLsHH3zQUdZf/y5dujiCg4MrLZ7zHcfhcDhGjRrlaN68ufP1vn37HIAjNDTUkZmZ6dw+efJkB+Do1KmTw2q1OrcPHz7c4eXl5cjPz3c4HA5Hdna2IyQkxDF27NhSxzl69KgjODj4nO1n2759u8PX19cBODp37uyYMGGCY+nSpY7c3NxS7cpznFGjRjkAx6RJky56/uvWrXMAjvfff79Uu+XLl5favmTJEpf+jMvSt29fx5VXXuk4fvy44/jx444dO3Y4Hn74YQfgiImJOW9sS5cudQCOp556qlR/t99+u8NkMjlSUlKc2/z9/R2jRo0qd2wi7kZDbCLilJWVRWBgoKEx3HHHHQQHBztfR0VFAcXzmzw8PEptLyws5NChQwAkJSWRmZnJ8OHDycjIcH5ZLBaioqJYvXr1BY971VVXsW3bNu666y7279/Piy++yC233ELDhg15/fXXne0qcpwHHnjgouf9n//8h+DgYAYNGlSq327duhEQEODst+Qqz+eff47Var1ov2fbuXMnoaGhhIaG0q5dO1566SVuuummUlfizrZs2TIsFgsPP/xwqe3/+Mc/cDgcfPnll+WOQ8TdaYhNRJyCgoJITU01NIZmzZqVel1SLIWHh5e5vWR+zp49ewDOOzwWFBR00WNfccUVvPvuu9hsNn799Vc+//xznnnmGcaNG0eLFi0YOHBguY/j4eFB06ZNL3rsPXv2cPr06TLnO8H/Jor37duX2267jZkzZ/LCCy/Qr18/brnlFkaMGIG3t/dFjxMREcHrr7+OyWTCx8eHNm3anPeYJX777TcaN258TvHcrl075/sitY0KJBFxuvLKK/nhhx84cODAOQVJdbFYLOXa7vh9knDJkvl3332XsLCwc9r98eqTKzF07NiRjh070qNHD/r378/777/PwIEDy30cb29vzOaLX6y32+00aNCA999/v8z3Q0NDgeKJ0B999BEbN27ks88+46uvvuJvf/sbzz//PBs3biQgIOCCx/H392fgwIEXjUfkcqcCSUScYmJi+Pe//817773H5MmTjQ6nXEomAzdo0KBSC4Du3bsDcOTIkSo9TqtWrfj666/p1asXvr6+F21/7bXXcu211zJ79mwWLVrEnXfeyQcffMCYMWMqLaYSJRPYs7OzS11F2rlzp/P9EiaTqdKPL2IEzUESEafbb7+djh07Mnv2bDZs2HDO+9nZ2UydOtWAyC5u8ODBBAUFMWfOnDLn5lxoCTvAunXrytxv2bJlALRt27ZSjnM+Q4cOxWazMWvWrHPeKyoqIjMzEygeUnT8YWk9QOfOnQEoKCio0LEvZsiQIdhsNl5++eVS21944QVMJhM33nijc5u/v78zVpGaTFeQRGqhhQsXsnz58nO2T5gw4YKTsD09Pfnkk08YOHAgffr0YejQofTq1QtPT09++eUXFi1aRJ06dSrtXkiVKSgoiFdffZWRI0fStWtX/vrXvxIaGkpaWhpffPEFvXr1OucH/B89/fTTbNmyhVtvvZWrr74agK1bt/LOO+9Qt25dHnnkkUo5zvn07duX++67j4SEBLZt20Z0dDSenp7s2bOH//znP7z44ovcfvvtvP3227zyyiv85S9/oVWrVmRnZ/P6668TFBTEkCFDKpS7i4mJiaF///5MnTqV/fv306lTJ1asWMF///tfHnnkkVJL+bt168bXX3/NvHnzaNy4MS1atHBOtBepSVQgidRCr776apnb77nnnouuUmvdujXbtm3jhRdeYMmSJSxduhS73U7r1q0ZM2bMOSuZ3MmIESNo3Lgxc+fO5dlnn6WgoIAmTZpw3XXXMXr06AvuO2XKFBYtWsSaNWt4//33ycvLo1GjRvz1r38lLi6OFi1aVMpxLmTBggV069aNf/3rX0yZMgUPDw8iIiK466676NWrF1BcSG3atIkPPviA9PR0goODiYyM5P333y8VY2Uym818+umnTJ8+ncWLF/Pmm28SERHBs88+yz/+8Y9SbefNm8e4ceOYNm0aZ86cYdSoUSqQpEYyOc6+VisiIiJymdMcJBEREZGzqEASEREROYsKJBEREZGzqEASEREROYsKJBEREZGzqEASEREROYvug1RBdrudw4cPExgYqFvri4iI1BAOh4Ps7GwaN258weckqkCqoMOHDxv2ME8RERG5NAcOHKBp06bnfV8FUgWV3I34wIEDBAUFVVq/VquVFStWOB8zIBemfLlOuXKdcuU65cp1ypXrqjJXWVlZhIeHX/SpAiqQKqhkWC0oKKjSCyQ/Pz+CgoL0F8gFypfrlCvXKVeuU65cp1y5rjpydbHpMZqkLSIiInIWFUgiIiIiZ1GBJCIiInIWzUGqYjabDavV6nJ7q9WKh4cH+fn52Gy2Koysdqgp+fL09MRisRgdhoiIuEgFUhVxOBwcPXqUzMzMcu8XFhbGgQMHdH8lF9SkfIWEhBAWFub2cYqIiAqkKlNSHDVo0AA/Pz+Xfyja7XZycnIICAi44A2spFhNyJfD4SAvL49jx44B0KhRI4MjEhGRi1GBVAVsNpuzOKpXr1659rXb7RQWFuLj4+O2P/DdSU3Jl6+vLwDHjh2jQYMGGm4TEXFz7vsTpQYrmXPk5+dncCTiTko+D+WZkyYiIsYwvECaP38+ERER+Pj4EBUVxaZNmy7YPjExkbZt2+Lr60t4eDgTJ04kPz/f+f7atWuJiYmhcePGmEwmli5dek4fDoeD6dOn06hRI3x9fRk4cCB79uyp7FPTXBMpRZ8HEZGaw9ACafHixcTGxhIfH8/WrVvp1KkTgwcPds7VONuiRYuYNGkS8fHx7NixgzfeeIPFixczZcoUZ5vc3Fw6derE/Pnzz3vcZ555hn/+858sWLCA7777Dn9/fwYPHlyq0BIREZHLl6EF0rx58xg7diyjR4+mffv2LFiwAD8/PxYuXFhm+/Xr19OrVy9GjBhBREQE0dHRDB8+vNRVpxtvvJGnnnqKv/zlL2X24XA4SExMZNq0adx8881cffXVvPPOOxw+fLjMq03iHu655x5uueUWo8MQEZEqkjwjmTWz1pT53ppZa0iekVyt8Rg2SbuwsJAtW7YwefJk5zaz2czAgQPZsGFDmfv07NmT9957j02bNhEZGUlqairLli1j5MiRLh933759HD16lIEDBzq3BQcHExUVxYYNG/jrX/9a5n4FBQUUFBQ4X2dlZQHF80nOnlNitVpxOBzY7XbsdrvLsUFxAVfyu7XIyrq0dRzJOUKjgEZc1+w6LGb3ndw7c+ZM/vvf/7J169ZK79vhcDhzevZ2gNWrVzNw4EBOnDhBSEgIAAMGDGDNmrL/sgH07duXVatWcfToUebMmcOyZcs4dOgQDRo0oFOnTkyYMIHrr7++0s7BbrcX/7larYZM0i75nGoO1MUpV65TrlynXF2YAwdrpq/BbrMT9XgUUJyrb2Z/w9qZa+kT36dScudqH4YVSBkZGdhsNho2bFhqe8OGDdm5c2eZ+4wYMYKMjAx69+6Nw+GgqKiI+++/v9QQ28UcPXrUeZyzj1vyXlkSEhKYOXPmOdtXrFhxzmRsDw8PwsLCyMnJobCw0OXY/mjRD4uYtGYSh3MOO7c1DmjM3L5ziWkdU6E+q1pBQQE2m81ZPFYmq9VKUVHRefs+c+YMANnZ2c7VbG+++aYz/4cOHeL6669n6dKlXHnllQB4eXmxfft2brjhBoKDg5kxYwbt27fHarWyatUqHnzwwYvOiSuPwsJCzpw5w9q1aykqKqq0fssrKSnJsGPXNMqV65Qr1ylX59EFwoaHsXbmWn7d+iuhfwrl3THvcvTfRwkbHkZWlyyWLVt2yYfJy8tzqV2NWuafnJzMnDlzeOWVV4iKiiIlJYUJEyYwa9Ys4uLiqvTYkydPJjY21vk6KyuL8PBwoqOjCQoKKtU2Pz+fAwcOEBAQgI+PT7mO43A4WPTDIkZ9MQoHjlLvHck5wqgvRvHh7R9ya7tbK34y57F8+XLmzJnD9u3bsVgsXHvttSQmJtKqVStnm4MHD/L444+zYsUKCgoKaNeuHS+99BI7duzg6aefBqBOnToAvPHGG/Tr149WrVqxZcsWOnfuDEBmZib16tVj5cqV9OvXD5vNxn333cfq1as5evQozZo144EHHuDhhx92HtfT0xMPD49zcu1wOMjOznYuow8MDHS2+WPbkqdBh4eH06ZNG+f2m266CbPZzKZNm/D393duj4qK4oEHHjjneJciPz8fX19f+vTpU+7PRWWwWq0kJSUxaNAgPUn8IpQr1ylXrlOuXDAEvrmi+IpRxmcZAPSJ70Pvqb0r7RCu/ifesAKpfv36WCwW0tPTS21PT08nLCyszH3i4uIYOXIkY8aMAaBjx47k5uYybtw4pk6d6tJ9cEr6Tk9PL3XDvvT0dOcP8LJ4e3vj7e19znZPT89zPug2mw2TyYTZbMZsNhffKNDqWsVqLbLyRPIT5xRHUHz50YSJiV9NJLpVtEvDbX6ert+k8syZM8TGxnL11VeTk5PD9OnTue2229i2bRtms5mcnBz69+9PkyZN+PTTTwkLC3MOpw0fPpxff/2V5cuX8/XXXwPFQ5clf74luSj5/o/bbDYb4eHh/Oc//6FevXqsX7+ecePG0bhxY4YOHQoUrwAryekflQy5lZzjH4/zR2cfE+DkyZN89dVXzJ49m8DAwHP2qVu3rkt5c5XZbMZkMpX5malORh+/JlGuXKdcuU65urB+8f1YO3MtAGYPM/1n9K/U/l3NvWEFkpeXF926dWPlypXOybd2u52VK1cyfvz4MvfJy8s754dfyVyOkrkoF9OiRQvCwsJYuXKlsyDKysriu+++44EHHqjYyVxEnjWPgISASunLgYOD2QcJfjrYpfY5k3Pw9/K/eEPgtttuK/V64cKFhIaG8uuvv9KhQwcWLVrE8ePH2bx5s7N4aN26tbN9QECAc3ixPDw9PUsNX7Zo0YINGzbw4YcfOgukqpCSkoLD4XAOuYmIiPGWPfi/YTR7kZ01s9bQN65vtcdh6BBbbGwso0aNonv37kRGRpKYmEhubi6jR48G4O6776ZJkyYkJCQAEBMTw7x58+jSpYtziC0uLo6YmBhnoZSTk0NKSorzGPv27WPbtm3UrVuXZs2aYTKZeOSRR3jqqado06YNLVq0IC4ujsaNG1/2q6T27NnD9OnT+e6778jIyHBenUlLS6NDhw5s27aNLl26VPqVFSi+H9bChQtJS0vjzJkzFBYWXvCKXmVwtagWEZHqsWbWGr5/9XsAgiKD6HxjZ5KnJwNUe5FkaIE0bNgwjh8/zvTp0zl69CidO3dm+fLlzgnUaWlppa4YTZs2DZPJxLRp0zh06BChoaHExMQwe/ZsZ5vvv/+e/v3/dzmuZN7QqFGjeOuttwB4/PHHnUNzmZmZ9O7dm+XLl1fZvBA/Tz9yJue41HbN/jXc9O+bLtpu2Yhl9Gnex6VjuyomJobmzZvz+uuv07hxY+x2Ox06dHBOdC6Z51MeJX9+fyxGzl5B8MEHH/Doo4/y/PPP06NHDwIDA3n22Wf57rvvyn288mjTpg0mk+m8iwJERKT6rJm1huTpyQQ1CyIrLYugbkH0ntobs8VsSJFk+CTt8ePHn3dILTk5udRrDw8P4uPjiY+PP29//fr1u+iVAZPJxJNPPsmTTz5Z7ngrwmQyuTzMNajlIBoHNOZIzpEy5yGZMNE0qKnLc5BcdeLECXbt2sXrr7/OddddB8A333xTqs3VV1/N//3f/3Hy5MkyryJ5eXlhs9lKbQsNDQXgyJEjdOnSBYBt27aVavPtt9/Ss2dP/v73vzu37d2795LP6WLq1q3L4MGDmT9/Pg8//HCpSdpQPJm85JYBIiJStRw2B70m9WL9M+sBCOpavEimpChy2Kr3qr/hjxqR0ixmC3P7zgWKi6E/KnmdeENipd8PqU6dOtSrV4/XXnuNlJQUVq1aVWrVHhRPxA4LC+OWW27h22+/JTU1lY8//th536qIiAjnkGZGRgYFBQX4+vpy7bXXMnfuXHbs2MGaNWuYNm1aqX7btGnD999/z1dffcXu3buJi4tj8+bNFTqPn3/+mW3btjm/fvzxxwu2nz9/PjabjcjISD7++GP27NnDjh07+Oc//0mPHj0qFIOIiJRfvxn9aHh1Qxx2B6EdQvEK9XK+1zeuL/1m9KvWeFQguaGY1jF8ePuHNAlqUmp706CmfDT0oypZ4m82m/nggw/YsmULHTp0YOLEiTz77LOl2nh5ebFixQoaNGjAkCFD6NixI3PnznXO/7rtttu44YYb6N+/P6Ghofz73/8Giid7FxUV0a1bN+f8rz+67777uPXWWxk2bBhRUVGcOHGi1NWk8ujTpw9dunRxfnXr1u2C7Vu2bMnWrVvp378///jHP+jQoQODBg1i5cqVvPrqqxWKQUREKiZlWfEc4tY3tL5Iy6pncmimaoVkZWURHBzM6dOny7wP0r59+2jRokW55zXZ7XaysrIICgrCgaP4TtrZR2gU6P530jbCH/Plym0ejHQpn4vKYLVaWbZsGUOGDNES44tQrlynXLlOubowu83O82HPk5eRx10r72J79vYqydWFfn7/keFzkOT8LGYL/SL6GR2GiIhIlTu8+TB5GXl4B3vT5NombE/abmg87v1fbhEREbks7Fm2B4DWg1tj8TR+tEQFkoiIiBjOWSANMX7+EahAEhEREYNlH8nmyJYjgHtM0AYVSCIiImKwlOXFq9caX9OYgIaV82iuS6UCSURERAxVsry/zZA2BkfyPyqQRERExDA2q429K4qfnqACSURERAQ48O0BCrIK8Av1o3H3xkaH46QCSURERAxTsnqtzY1tMJlNF2ldfVQgiZPD4WDcuHHUrVsXk8l0zkNlRUREKpu7Le8voQJJnJYvX85bb73F559/zpEjR+jQoYPRIVVYREQEiYmJ5W731ltvYTKZLvi1f/9+HA4Hr732GlFRUQQEBBASEkL37t1JTEwkLy+v6k5MRKQWyfwtk+O/HMdkMdEqupXR4ZSiAskNbZy7kbVPrS3zvTWz1pA8I7lKjrt3714aNWpEz549CQsLw8Oj/E+icTgcFBUVVUF01WPYsGEcOXLE+dWjRw/Gjh1balt4eDgjR47kkUce4eabb2b16tVs27aNuLg4/vvf/7JixQqjT0NEpEYouXoU3jMc3zq+BkdTmgokN2SymFgTv4Y1s9aU2r5m1hqSpydjslT+GO0999zDQw89RFpaGiaTiYiICAAKCgp4+OGHadCgAT4+PvTu3ZvNmzc790tOTsZkMvHll1/SrVs3vL29+eabb7Db7SQkJNCiRQt8fX3p1KkTH330Ualj/vLLL/zpT38iKCiIwMBArrvuOvbuLV7JsHnzZgYNGkT9+vUJDg6mb9++bN261bmvw+FgxowZRERE0LBhQ5o2bcrDDz8MQL9+/fjtt9+YOHGi86qPq3x9fQkLC3N+eXl54efnV2rbxx9/zPvvv8+///1vpkyZwjXXXENERAQ333wzq1aton///hX9YxARuay44/L+EnpYbTVwOBxY86wutbXb7XT9e1c8TB4kT0/GVmij96TefDP3G9Y9tY7rpl1Hj9geFOYWutSfp5+nSwXCiy++SKtWrXjttdfYvHkzFkvxc3Aef/xxPv74Y95++22aN2/OM888w+DBg0lJSaFu3brO/SdNmsRzzz1Hy5YtqVOnDgkJCbz33nssWLCANm3asHbtWu666y5CQ0Pp27cvhw4dok+fPvTr149Vq1YRFBTEt99+67z6lJ2dzahRo3jppZdwOBw8//zzDBkyhD179hAYGMjHH3/MCy+8wKJFi2jWrBm5ubn8/PPPAHzyySd06tSJcePGMXbsWJfyVB7vv/8+bdu25eabbz7nPZPJRHBwcKUfU0SktrGesZK6MhVQgXTZsuZZSQhIqNC+655ax7qn1p339cVMzpmMl7/XRdsFBwcTGBiIxWIhLCwMgNzcXF599VXeeustbrzxRgBef/11kpKSeOONN3jsscec+z/55JMMGjQIKL7qNGfOHL7++mt69OgBQMuWLfnmm2/417/+Rd++fZk/fz7BwcF88MEHeHp6AnDFFVc4+xswYECp+F577TVCQkJYs2YNf/rTn0hLSyMsLIyBAwdy5swZgoKCuPbaawGoW7cuFouFwMBA57lUpj179tC2bdtK71dE5HLy25rfKDpTRFDTIBp0bGB0OOfQEJuc1969e7FarfTq1cu5zdPTk8jISHbs2FGqbffu3Z3fp6SkkJeXx6BBgwgICHB+vfPOO84htG3btnHdddc5i6OzpaenM3bsWNq0aUNwcDBBQUHk5OSQlpYGwB133MGZM2do3bo1EyZMYMmSJdU298nhcFTLcUREarM/rl4rz1SI6qIrSNXA08+TyTmTXWprt9vJzsomMCiQ9c+sZ91T67B4WbAV2rhu2nX0ntS73MeuDv7+/s7vc3JyAPjiiy9o0qRJqXbe3t5A8VyfCxk1ahQnTpzgxRdfpHnz5nh7e9OjRw8KC4uHFsPDw9m1axcrVqxg2bJljB8/nueff541a9act+iqLFdccQU7d+6s0mOIiNRmDoeDPV/8fv8jNxxeA11BqhYmkwkvfy+Xvzz9Pdn4wkbWPbWOfk/2Y1rBNPo92Y91T61jw7wN5errUqryVq1a4eXlxbfffuvcZrVa2bx5M+3btz/vfu3bt8fb25u0tDRat25d6is8PByAq6++mnXr1mG1lj0369tvv+Xhhx9myJAhXHXVVXh7e5ORkVGqja+vLzExMTz99NOsWrWKDRs2OOcheXl5YbPZKnzuFzJixAh2797Nf//733PeczgcnD59ukqOKyJSW5zYfYJTqaeweFloeX1Lo8Mpk64guaHvnv2OjXM20u/JfvSN6wvg/D15enKp11XJ39+fBx54gMcee4y6devSrFkznnnmGfLy8rj33nvPu19gYCCPPvooEydOxG6307t3b06fPs23335LUFAQo0aNYvz48bz00kv89a9/ZfLkyQQHB7Nx40YiIyNp27Ytbdq04d1336V79+5kZWXx2GOPlbrq9NZbb2Gz2bjmmmuw2+189NFH+Pr60rx5c6D4/kZr167lr3/9K97e3tSvX/+88R46dOicm2I2b96cOnXqlNl+6NChLFmyhOHDhzNt2jSio6MJDQ3l559/5oUXXuChhx7illtucT3RIiKXmZLhteZ9m+MVcPF5skZQgeSGHDYHfWf2PacIKnntsFXfHJi5c+dit9sZOXIk2dnZdO/ena+++uq8xUOJWbNmERoaSkJCAqmpqYSEhNC1a1emTJkCQL169Vi1ahWPPfYYffv2xWKx0LlzZ+d8pzfeeINx48bRtWtXwsPDmTNnDo8++qiz/5CQEObOnUtsbCw2m42OHTvy2WefUa9ePaB40vh9991Hq1atKCgouOC8oeeee47nnnuu1LZ3332Xu+66q8z2JpOJRYsW8dprr7Fw4UJmz56Nh4cHbdq04e6772bw4MEXT6yIyGXMnZf3lzA5NOO0QrKysggODub06dMEBQWVei8/P599+/bRokULfHx8ytWv3W4nKyuLoKAgzGaNgF5MTcrXpXwuKoPVamXZsmUMGTKkyudp1XTKleuUK9cpV8UKsgt4pt4z2K12xu8aT70r6p3TpipzdaGf33/k3j9RREREpFbZt3Ifdquduq3rllkcuQsVSCIiIlJt3PXhtGdTgSQiIiLVwuFwOAskd55/BCqQREREpJqk/5RO9qFsPP08iegbYXQ4F6QCqQpp/rv8kT4PInK5K7l61OL6Fnj4uPdCehVIVaBkxn1eXp7BkYg7Kfk8XM6rV0Tk8lYTlveXcO/yrYayWCyEhIRw7NgxAPz8/Fy+o7XdbqewsJD8/Hy3X7buDmpCvhwOB3l5eRw7doyQkBAsFovRIYmIVLszJ89wYP0BQAWSS+bPn8+zzz7L0aNH6dSpEy+99BKRkZHnbZ+YmMirr75KWloa9evX5/bbbychIaHUfWUu1ufevXt59NFH+eabbygoKOCGG27gpZdeomHDhpV2XiVPkS8pklzlcDg4c+YMvr6+bvnwPndTk/IVEhLi/FyIiFxu9q7Yi8PuoEGHBgQ3CzY6nIsytEBavHgxsbGxLFiwgKioKBITExk8eDC7du2iQYMG57RftGgRkyZNYuHChfTs2ZPdu3dzzz33YDKZmDdvnkt95ubmEh0dTadOnVi1ahUAcXFxxMTEsHHjxkq7CmEymWjUqBENGjQ47/PGymK1Wlm7di19+vTRUIwLakq+PD09deVIRC5rNWV5fwlDC6R58+YxduxYRo8eDcCCBQv44osvWLhwIZMmTTqn/fr16+nVqxcjRowAip+3NXz4cL777juX+/z222/Zv38/P/zwg/MOmm+//TZ16tRh1apVDBw4sFLP0WKxlOsHo8VioaioCB8fH7f+ge8ulC8REffnsDtI+bLmzD8CAydpFxYWsmXLllIFidlsZuDAgWzYsKHMfXr27MmWLVvYtGkTAKmpqc5bkbvaZ0FBASaTCW9vb2cbHx8fzGYz33zzTaWfp4iIyOXu0OZD5GXk4R3sTXjPcKPDcYlhV5AyMjKw2WznzPtp2LAhO3fuLHOfESNGkJGRQe/evXE4HBQVFXH//fc7H4DqSp/XXnst/v7+PPHEE8yZMweHw8GkSZOw2WwcOXLkvPEWFBRQUFDgfJ2VlQUUD/GUZwjtYkr6qsw+azPly3XKleuUK9cpV667nHO167NdALQY2AI7duxW+wXbV2WuXO3T8Ena5ZGcnMycOXN45ZVXiIqKIiUlhQkTJjBr1izi4uJc6iM0NJT//Oc/PPDAA/zzn//EbDYzfPhwunbtesH5RwkJCcycOfOc7StWrMDPz6/C53Q+SUlJld5nbaZ8uU65cp1y5TrlynWXY652LS4ukHIb57Js2TKX96uKXLl6Cx7DCqT69etjsVhIT08vtT09Pf28K33i4uIYOXIkY8aMAaBjx47k5uYybtw4pk6d6nKf0dHR7N27l4yMDDw8PJyri1q2bHneeCdPnkxsbKzzdVZWFuHh4URHR1/wacDlZbVaSUpKYtCgQZpT4wLly3XKleuUK9cpV667XHOVczSHbSnbAPjLY38hICzgovtUZa5KRoAuxrACycvLi27durFy5UpuueUWoPieNitXrmT8+PFl7pOXl3fOVZ6SCdAOh6PcfdavXx+AVatWcezYMf785z+fN15vb+9S85ZKeHp6VskHvar6ra2UL9cpV65TrlynXLnucsvVbyt/A6Bx98bUCa9Trn2rIleu9mfoEFtsbCyjRo2ie/fuREZGkpiYSG5urnMF2t13302TJk1ISEgAICYmhnnz5tGlSxfnEFvJEv2SQulifQK8+eabtGvXjtDQUDZs2MCECROYOHEibdu2rf4kiIiI1GI1bXl/CUMLpGHDhnH8+HGmT5/O0aNH6dy5M8uXL3dOsk5LSyt1xWjatGmYTCamTZvGoUOHCA0NJSYmhtmzZ7vcJ8CuXbuYPHkyJ0+eJCIigqlTpzJx4sTqO3EREZHLgM1qY+9Xe4Gas7y/hOGTtMePH3/eIbXk5ORSrz08PIiPjyc+Pr7CfQLMnTuXuXPnljtWERERcd2B9QcoyCrAr74fjbs3NjqccnHPh1eJiIhIjeccXruxNWZLzSo5ala0IiIiUmOkLKtZd8/+IxVIIiIiUulOp53m2PZjmMwmWkW3MjqcclOBJCIiIpWuZHgtvGc4vnV9DY6m/FQgiYiISKWrqcv7S6hAEhERkUpVlF/EvpX7gJo5/whUIImIiEgl279mP9Y8K4FNAml4dcOL7+CGVCCJiIhIpSoZXmszpA0mk8ngaCpGBZKIiIhUqpq8vL+ECiQRERGpNCd2n+BkyknMnmZaXN/C6HAqTAWSiIiIVJqS4bWIvhF4B3obHE3FqUASERGRSlPTl/eXUIEkIiIilaIwp5Df1vwG1Oz5R6ACSURERCpJ6spUbIU26rSqQ70r6hkdziVRgSQiIiKVojYs7y+hAklEREQumcPhqBXL+0uoQBIREZFLduznY2QdzMLD14PmfZsbHc4lU4EkIiIil6xkeK3l9S3x9PU0OJpLpwJJRERELlltWd5fQgWSiIiIXJIzp85wYP0BoHbMPwIVSCIiInKJ9q7Yi8PmIPSqUEKahxgdTqVQgSQiIiKXpDatXiuhAklEREQqzGF3sOfL/93/qLZQgSQiIiIVdvj7w+Qdz8M7yJvwXuFGh1NpVCCJiIhIhZWsXmsV3QqLp8XgaCqPCiQRERGpsNq2vL+ECiQRERGpkJz0HA5vPgxAmxtrz/wjUIEkIiIiFZSyvHj1WqNujQgICzA4msqlAklEREQqpDYu7y+hAklERETKzWa1kfKVCiQRERERp4MbDlJwugC/+n40vqax0eFUOhVIIiIiUm7O1Ws3tMZsqX3lhOFnNH/+fCIiIvDx8SEqKopNmzZdsH1iYiJt27bF19eX8PBwJk6cSH5+frn6PHr0KCNHjiQsLAx/f3+6du3Kxx9/XOnnJiIiUlvV1uX9JQwtkBYvXkxsbCzx8fFs3bqVTp06MXjwYI4dO1Zm+0WLFjFp0iTi4+PZsWMHb7zxBosXL2bKlCnl6vPuu+9m165dfPrpp/z888/ceuutDB06lB9++KHKz1lERKSmO512mmM/H8NkNtF6sAqkSjdv3jzGjh3L6NGjad++PQsWLMDPz4+FCxeW2X79+vX06tWLESNGEBERQXR0NMOHDy91hciVPtevX89DDz1EZGQkLVu2ZNq0aYSEhLBly5YqP2cREZGaruTZa017NMW3rq/B0VQND6MOXFhYyJYtW5g8ebJzm9lsZuDAgWzYsKHMfXr27Ml7773Hpk2biIyMJDU1lWXLljFy5Mhy9dmzZ08WL17MTTfdREhICB9++CH5+fn069fvvPEWFBRQUFDgfJ2VlQWA1WrFarVWKAdlKemrMvuszZQv1ylXrlOuXKdcua425Wr357sBaDm4ZZWcT1XmytU+DSuQMjIysNlsNGzYsNT2hg0bsnPnzjL3GTFiBBkZGfTu3RuHw0FRURH333+/c4jN1T4//PBDhg0bRr169fDw8MDPz48lS5bQuvX5LxMmJCQwc+bMc7avWLECPz8/l8/bVUlJSZXeZ22mfLlOuXKdcuU65cp1NT1X9kI7e5P2AnAk4AjLli2rsmNVRa7y8vJcamdYgVQRycnJzJkzh1deeYWoqChSUlKYMGECs2bNIi4uzuV+4uLiyMzM5Ouvv6Z+/fosXbqUoUOHsm7dOjp27FjmPpMnTyY2Ntb5Oisri/DwcKKjowkKCrrkcythtVpJSkpi0KBBeHp6Vlq/tZXy5TrlynXKleuUK9fVllylJqXyU8FPBDQO4LYHb8NkMlX6MaoyVyUjQBdjWIFUv359LBYL6enppbanp6cTFhZW5j5xcXGMHDmSMWPGANCxY0dyc3MZN24cU6dOdanPvXv38vLLL7N9+3auuuoqADp16sS6deuYP38+CxYsKPPY3t7eeHt7n7Pd09OzSj7oVdVvbaV8uU65cp1y5TrlynU1PVf7VuwDim8O6eXlVaXHqopcudqfYZO0vby86NatGytXrnRus9vtrFy5kh49epS5T15eHmZz6ZAtFgsADofDpT5LLq2V1Y/dbr/0ExMREanF9nxRPEG7Nt49+48MHWKLjY1l1KhRdO/encjISBITE8nNzWX06NFA8XL8Jk2akJCQAEBMTAzz5s2jS5cuziG2uLg4YmJinIXSxfq88sorad26Nffddx/PPfcc9erVY+nSpSQlJfH5558bkwgREZEa4MSeE5xMOYnZ00zLgS2NDqdKGVogDRs2jOPHjzN9+nSOHj1K586dWb58uXOSdVpaWqkrPdOmTcNkMjFt2jQOHTpEaGgoMTExzJ492+U+PT09WbZsGZMmTSImJoacnBxat27N22+/zZAhQ6o3ASIiIjVIyc0hm/dpjnfgudNOahPDJ2mPHz+e8ePHl/lecnJyqdceHh7Ex8cTHx9f4T4B2rRpoztni4iIlFPKstr7cNqzGf6oEREREXF/hTmF7E/eD6hAEhEREQFg36p92Apt1GlZh3pt6xkdTpVTgSQiIiIX9ceH01bFvY/cjQokERERuSCHw3HZLO8voQJJRERELujY9mNkHczCw9eDiH4RRodTLVQgiYiIyAWVDK+1GNACT9+aexfw8lCBJCIiIhd0OS3vL6ECSURERM7rzKkzpH2bBqhAEhEREQEgNSkVh81BaPtQQiJCjA6n2qhAEhERkfP64/L+y4kKJBERESmTw+4g5cvLb/4RqEASERGR8zi85TC5x3LxCvSiWa9mRodTrVQgiYiISJlKhtdaRbfC4mUxOJrqpQJJREREynS53T37j1QgiYiIyDly0nM4vPkwAK1vvLwmaIMKJBERESnD3q/2AtCoayMCGwUaHE31U4EkIiIi57hcl/eXUIEkIiIipdiL7M4rSJfj/CNQgSQiIiJnObDhAPmZ+fjW86VJZBOjwzGECiQREREpxTm8dkNrzJbLs1S4PM9aREREzutyXt5fQgWSiIiIOJ0+cJpjPx/DZDbRanAro8MxjAokERERcSp59lrTa5viV8/P4GiMowJJREREnC735f0lVCCJiIgIAEUFRaR+nQpc3vOPQAWSiIiI/O63tb9hzbUS0CiAsM5hRodjKBVIIiIiAvxveK3NkDaYTCaDozGWCiQREREBtLz/j1QgiYiICCf2nODknpOYPc20HNjS6HAMpwJJREREnMv7m1/XHO8gb4OjMZ4KJBEREdHy/rOoQBIREbnMFeYWsj95P6D5RyXcokCaP38+ERER+Pj4EBUVxaZNmy7YPjExkbZt2+Lr60t4eDgTJ04kPz/f5T7379+PyWQq8+s///lPlZyjiIiIu9q3ah+2AhshLUKof2V9o8NxC4YXSIsXLyY2Npb4+Hi2bt1Kp06dGDx4MMeOHSuz/aJFi5g0aRLx8fHs2LGDN954g8WLFzNlyhSX+wwPD+fIkSOlvmbOnElAQAA33nhjtZy3iIiIu9Dy/nMZXiDNmzePsWPHMnr0aNq3b8+CBQvw8/Nj4cKFZbZfv349vXr1YsSIEURERBAdHc3w4cNLXSG6WJ8Wi4WwsLBSX0uWLGHo0KEEBARUy3mLiIi4A4fDoeX9ZfAw8uCFhYVs2bKFyZMnO7eZzWYGDhzIhg0bytynZ8+evPfee2zatInIyEhSU1NZtmwZI0eOrHCfW7ZsYdu2bcyfP/+8sRYUFFBQUOB8nZWVBYDVasVqtbp+0hdR0ldl9lmbKV+uU65cp1y5Trlynbvm6tj2Y2QdyMLDx4MmvZq4RXxVmStX+zS0QMrIyMBms9GwYcNS2xs2bMjOnTvL3GfEiBFkZGTQu3dvHA4HRUVF3H///c4htor0+cYbb9CuXTt69ux53lgTEhKYOXPmOdtXrFiBn1/lP+04KSmp0vuszZQv1ylXrlOuXKdcuc7dcpX+SToAflf5kZTsXrFVRa7y8vJcamdogVQRycnJzJkzh1deeYWoqChSUlKYMGECs2bNIi4urtz9nTlzhkWLFl1038mTJxMbG+t8nZWVRXh4ONHR0QQFBZX7uOdjtVpJSkpi0KBBeHp6Vlq/tZXy5TrlynXKleuUK9e5a67eff5dAK69+1q6D+lucDTFqjJXJSNAF2NogVS/fn0sFgvp6emltqenpxMWVvZD8uLi4hg5ciRjxowBoGPHjuTm5jJu3DimTp1a7j4/+ugj8vLyuPvuuy8Yq7e3N97e5944y9PTs0o+6FXVb22lfLlOuXKdcuU65cp17pSr/Mx8Dq4/CMCVMVe6TVwlqiJXrvZn6CRtLy8vunXrxsqVK53b7HY7K1eupEePHmXuk5eXh9lcOmyLxQIUTzQrb59vvPEGf/7znwkNDa2MUxIREakx9ibtxWFzUL9dfeq0qGN0OG7F8CG22NhYRo0aRffu3YmMjCQxMZHc3FxGjx4NwN13302TJk1ISEgAICYmhnnz5tGlSxfnEFtcXBwxMTHOQulifZZISUlh7dq1LFu2rHpPWkRExA2kLCt+vIhWr53L8AJp2LBhHD9+nOnTp3P06FE6d+7M8uXLnZOs09LSSl0xmjZtGiaTiWnTpnHo0CFCQ0OJiYlh9uzZLvdZYuHChTRt2pTo6OjqOVkRERE34bA7St3/SEozvEACGD9+POPHjy/zveTk5FKvPTw8iI+PJz4+vsJ9lpgzZw5z5swpV6wiIiK1wZGtR8g9lotXoBfNejczOhy3Y/iNIkVERKT6lVw9ajWoFRYvi8HRuB8VSCIiIpehkrtntx7S2uBI3JMKJBERkctM7rFcDm0+BECbGzX/qCwqkERERC4zKV+lgAPCuoQR2DjQ6HDckgokERGRy4yW91+cCiQREZHLiL3ITspyFUgXowJJRETkMnJw40HyM/PxretLk6gmRofjtlQgiYiIXEZKlve3vqE1ZovKgPNRZkRERC4jWt7vGhVIIiIil4msg1mk/5QOJmg9WAXShahAEhERuUzs+bL46lHTa5viV9/P4GjcmwokERGRy0TJ8JpWr12cCiQREZHLQFFBEalfpwIqkFyhAklEROQykLYuDWuulYBGAYR1CTM6HLenAklEROQy4Fzef2NrTCaTwdG4v3IXSAcOHODgwYPO15s2beKRRx7htddeq9TAREREpPJo/lH5lLtAGjFiBKtXrwbg6NGjDBo0iE2bNjF16lSefPLJSg9QRERELs3JlJOc2H0Cs4eZlgNbGh1OjVDuAmn79u1ERkYC8OGHH9KhQwfWr1/P+++/z1tvvVXZ8YmIiMglKlne3+y6ZvgE+xgcTc1Q7gLJarXi7e0NwNdff82f//xnAK688kqOHDlSudGJiIjIJdPwWvmVu0C66qqrWLBgAevWrSMpKYkbbrgBgMOHD1OvXr1KD1BEREQqrjC3kP3J+wEVSOVR7gLp6aef5l//+hf9+vVj+PDhdOrUCYBPP/3UOfQmIiIi7mH/6v3YCmyERIRQv119o8OpMTzKu0O/fv3IyMggKyuLOnXqOLePGzcOPz/dtlxERMSdOJf3D9Hy/vKo0H2QHA4HW7Zs4V//+hfZ2dkAeHl5qUASERFxIw6HQ/OPKqjcV5B+++03brjhBtLS0igoKGDQoEEEBgby9NNPU1BQwIIFC6oiThERESmn478e53TaaTx8PGjRv4XR4dQo5b6CNGHCBLp3786pU6fw9fV1bv/LX/7CypUrKzU4ERERqbiS4bWI/hF4+nkaHE3NUu4rSOvWrWP9+vV4eXmV2h4REcGhQ4cqLTARERG5NBpeq7hyX0Gy2+3YbLZzth88eJDAwMBKCUpEREQuTf7pfNK+SQNUIFVEuQuk6OhoEhMTna9NJhM5OTnEx8czZMiQyoxNREREKig1KRWHzUH9K+tTp2Wdi+8gpZR7iO35559n8ODBtG/fnvz8fEaMGMGePXuoX78+//73v6siRhERESmnPy7vl/Ird4HUtGlTfvzxRz744AN++ukncnJyuPfee7nzzjtLTdoWERERYzjsDmeBpOG1iil3gQTg4eHBXXfdVdmxiIiISCU48sMRctNz8Qrwovl1zY0Op0Yqd4H0zjvvXPD9u+++u8LBiIiIyKUruXrUclBLLF4Wg6OpmSp0H6Q/fv3973/nnnvuYdy4cTzyyCPlDmD+/PlERETg4+NDVFQUmzZtumD7xMRE2rZti6+vL+Hh4UycOJH8/Pxy97lhwwYGDBiAv78/QUFB9OnThzNnzpQ7fhEREXej5f2XrtwF0qlTp0p95eTksGvXLnr37l3uSdqLFy8mNjaW+Ph4tm7dSqdOnRg8eDDHjh0rs/2iRYuYNGkS8fHx7NixgzfeeIPFixczZcqUcvW5YcMGbrjhBqKjo9m0aRObN29m/PjxmM0VevKKiIiI28g9nsuhTcX3JWx9oyZoV1SlVARt2rRh7ty5TJgwoVz7zZs3j7FjxzJ69Gjat2/PggUL8PPzY+HChWW2X79+Pb169WLEiBFEREQQHR3N8OHDS10hcqXPiRMn8vDDDzNp0iSuuuoq2rZty9ChQ/H29q5YAkRERNzE3q/2ggPCOocR1CTI6HBqrApN0i6zIw8PDh8+7HL7wsJCtmzZwuTJk53bzGYzAwcOZMOGDWXu07NnT9577z02bdpEZGQkqampLFu2jJEjR7rc57Fjx/juu++488476dmzJ3v37uXKK69k9uzZ9O7d+7zxFhQUUFBQ4HydlZUFgNVqxWq1unzeF1PSV2X2WZspX65TrlynXLlOuXJddeVq12e7AGg5uGWN/XOpyly52me5C6RPP/201GuHw8GRI0d4+eWX6dWrl8v9ZGRkYLPZaNiwYantDRs2ZOfOnWXuM2LECDIyMujduzcOh4OioiLuv/9+5xCbK32mpqYCMGPGDJ577jk6d+7MO++8w/XXX8/27dtp06bs8dqEhARmzpx5zvYVK1bg5+fn8nm7KikpqdL7rM2UL9cpV65TrlynXLmuKnPlsDnYtay4QDoWcoxly5ZV2bGqQ1XkKi8vz6V25S6QbrnlllKvTSYToaGhDBgwgOeff7683ZVLcnIyc+bM4ZVXXiEqKoqUlBQmTJjArFmziIuLc6kPu90OwH333cfo0aMB6NKlCytXrmThwoUkJCSUud/kyZOJjY11vs7KyiI8PJzo6GiCgirvEqbVaiUpKYlBgwbh6akHC16M8uU65cp1ypXrlCvXVUeuDqw/wI85P+Jb15fbH7kds6Vmzq2tylyVjABdTLkLpJIC41LVr18fi8VCenp6qe3p6emEhYWVuU9cXBwjR45kzJgxAHTs2JHc3FzGjRvH1KlTXeqzUaNGALRv375Um3bt2pGWlnbeeL29vcuco+Tp6VklH/Sq6re2Ur5cp1y5TrlynXLluqrM1b4V+wBoNbgV3j41f15tVeTK1f4MKy29vLzo1q0bK1eudG6z2+2sXLmSHj16lLlPXl7eOSvNLJbi+zs4HA6X+oyIiKBx48bs2rWrVD+7d++meXPdTEtERGouLe+vPC5dQfrj0NLFzJs3z+W2sbGxjBo1iu7duxMZGUliYiK5ubnOoa+7776bJk2aOIe9YmJimDdvHl26dHEOscXFxRETE+MslC7Wp8lk4rHHHiM+Pp5OnTrRuXNn3n77bXbu3MlHH33kcuwiIiLuJOtQFuk/poOp+AqSXBqXCqQffvjBpc5MJlO5Dj5s2DCOHz/O9OnTOXr0KJ07d2b58uXOSdZpaWmlrhhNmzYNk8nEtGnTOHToEKGhocTExDB79myX+wR45JFHyM/PZ+LEiZw8eZJOnTqRlJREq1b6QImISM2U8mUKAE2jmuIf6m9wNDWfSwXS6tWrqyyA8ePHM378+DLfS05OLvXaw8OD+Ph44uPjK9xniUmTJjFp0qRyxSoiIuKuSobXWg/RzSErQ82c3i4iIiJORQVFpH5dfBsbzT+qHBW6UeT333/Phx9+SFpaGoWFhaXe++STTyolMBEREXFN2jdpFOYUEhAWQKMujYwOp1Yo9xWkDz74gJ49e7Jjxw6WLFmC1Wrll19+YdWqVQQHB1dFjCIiInIBe5b9Prx2Y2tM5vLNB5aylbtAmjNnDi+88AKfffYZXl5evPjii+zcuZOhQ4fSrFmzqohRRERELkDL+ytfuQukvXv3ctNNNwHF9zLKzc3FZDIxceJEXnvttUoPUERERM7v5N6TnNh1ArOHmZaDWhodTq1R7gKpTp06ZGdnA9CkSRO2b98OQGZmpsvPNxEREZHKUbK8v1nvZvgE+xgcTe3hcoFUUgj16dPH+fC4O+64gwkTJjB27FiGDx/O9ddfXzVRioiISJm0vL9quLyK7eqrr+aaa67hlltu4Y477gBg6tSpeHp6sn79em677TamTZtWZYGKiIhIadY8K/tWFz9/TfOPKpfLBdKaNWt48803SUhIYPbs2dx2222MGTNGN1sUERExyL7V+7AV2AhuHkxo+1Cjw6lVXB5iu+6661i4cCFHjhzhpZdeYv/+/fTt25crrriCp59+mqNHj1ZlnCIiInKWP65eK+/jvuTCyj1J29/fn9GjR7NmzRp2797NHXfcwfz582nWrBl//vOfqyJGEREROYvD4XDe/0jDa5Xvkh410rp1a6ZMmcK0adMIDAzkiy++qKy4RERE5AIydmRw+rfTWLwttBjQwuhwap0KPWoEYO3atSxcuJCPP/4Ys9nM0KFDuffeeyszNhERETmPkqtHLfq3wNPP0+Boap9yFUiHDx/mrbfe4q233iIlJYWePXvyz3/+k6FDh+Lv719VMYqIiMhZtLy/arlcIN144418/fXX1K9fn7vvvpu//e1vtG3btipjExERkTLkn84n7Zs0QPOPqorLBZKnpycfffQRf/rTn7BYLFUZk4iIiFxA6tep2Ivs1Gtbj7qt6hodTq3kcoH06aefVmUcIiIi4iI9nLbqXdIqNhEREaleDrvD+fw1FUhVRwWSiIhIDXJ021FyjubgFeBFs+uaGR1OraUCSUREpAYpWd7fcmBLPLwrfLceuQgVSCIiIjWIlvdXDxVIIiIiNUReRh4HvzsIQJsbNf+oKqlAEhERqSFSvkoBBzTs1JCgpkFGh1OrqUASERGpIbS8v/qoQBIREakB7DY7Kcu1vL+6qEASERGpAQ59d4j8U/n41PGh6bVNjQ6n1lOBJCIiUgOULO9vPbg1Zg/9+K5qyrCIiEgNoOX91UsFkoiIiJvLOpTF0W1HwQStb1CBVB1UIImIiLi5ksnZTSKb4B/qb3A0lwcVSCIiIm5Oy/urnwokERERN2YrtJGalAqoQKpOblEgzZ8/n4iICHx8fIiKimLTpk0XbJ+YmEjbtm3x9fUlPDyciRMnkp+fX64++/Xrh8lkKvV1//33V/q5iYiIXIq0b9IozCnEv6E/jbo2Mjqcy4bhBdLixYuJjY0lPj6erVu30qlTJwYPHsyxY8fKbL9o0SImTZpEfHw8O3bs4I033mDx4sVMmTKl3H2OHTuWI0eOOL+eeeaZKj1XERGR8tr9xW6g+NlrJrPJ4GguH4YXSPPmzWPs2LGMHj2a9u3bs2DBAvz8/Fi4cGGZ7devX0+vXr0YMWIEERERREdHM3z48FJXiFzt08/Pj7CwMOdXUJCeayMiIu4lZVnxBG0t769eHkYevLCwkC1btjB58mTnNrPZzMCBA9mwYUOZ+/Ts2ZP33nuPTZs2ERkZSWpqKsuWLWPkyJHl7vP999/nvffeIywsjJiYGOLi4vDz8yvzuAUFBRQUFDhfZ2VlAWC1WrFarRVLQBlK+qrMPmsz5ct1ypXrlCvXKVeuq0iuTqWeImNnBiaLiWb9ml02ea7Kz5WrfRpaIGVkZGCz2WjYsGGp7Q0bNmTnzp1l7jNixAgyMjLo3bs3DoeDoqIi7r//fucQm6t9jhgxgubNm9O4cWN++uknnnjiCXbt2sUnn3xS5nETEhKYOXPmOdtXrFhx3qLqUiQlJVV6n7WZ8uU65cp1ypXrlCvXlSdXx5cdB8DvSj9WrV9VVSG5rar4XOXl5bnUztACqSKSk5OZM2cOr7zyClFRUaSkpDBhwgRmzZpFXFycy/2MGzfO+X3Hjh1p1KgR119/PXv37qVVq1bntJ88eTKxsbHO11lZWYSHhxMdHV2pQ3NWq5WkpCQGDRqEp6dnpfVbWylfrlOuXKdcuU65cl1FcrV4wWIAIu+MpMeQHlUZnlupys9VyQjQxRhaINWvXx+LxUJ6enqp7enp6YSFhZW5T1xcHCNHjmTMmDFAcXGTm5vLuHHjmDp1aoX6BIiKigIgJSWlzALJ29sbb2/vc7Z7enpWyT8KVdVvbaV8uU65cp1y5TrlynWu5sqaZ+W35N8AuDLmyssyv1XxuXK1P0MnaXt5edGtWzdWrlzp3Ga321m5ciU9epRdKefl5WE2lw7bYrEA4HA4KtQnwLZt2wBo1EhLKEVExHj7k/dTlF9EcLNgQq8KNTqcy47hQ2yxsbGMGjWK7t27ExkZSWJiIrm5uYwePRqAu+++myZNmpCQkABATEwM8+bNo0uXLs4htri4OGJiYpyF0sX63Lt3L4sWLWLIkCHUq1ePn376iYkTJ9KnTx+uvvpqYxIhIiLyByXL+1sPaY3JpOX91c3wAmnYsGEcP36c6dOnc/ToUTp37szy5cudk6zT0tJKXTGaNm0aJpOJadOmcejQIUJDQ4mJiWH27Nku9+nl5cXXX3/tLJzCw8O57bbbmDZtWvWevIiISBkcDodzeb/unm0MwwskgPHjxzN+/Pgy30tOTi712sPDg/j4eOLj4yvcZ3h4OGvWrKlQrCIiIlUtY2cGmfszsXhbaDGghdHhXJYMv1GkiIiIlLZnWfHDaSP6ReDl72VwNJcnFUgiIiJuZs8XxQWShteMowJJRETEjRRkFZC2Lg1QgWQkFUgiIiJuJPXrVOxFdupdUY+6resaHc5lSwWSiIiIG/nj8n4xjgokERERN6Hl/e5DBZKIiIibOLrtKDlHc/D096R5n+ZGh3NZU4EkIiLiJkpWr7Uc2BIPb7e4VeFlSwWSiIiImyi5/5GG14ynAklERMQN5GXkcXDjQQBa36gJ2kZTgSQiIuIG9q7YCw5oeHVDgsODjQ7nsqcCSURExA2UzD/S8n73oAJJRETEYHabnZTlWt7vTlQgiYiIGOzQpkOcOXkGnxAfwnuEGx2OoAJJRETEcCXDa60Gt8LsoR/N7kB/CiIiIgbT8n73owJJRETEQNmHszn6w1EwQesbNEHbXahAEhERMVDJ5Owm1zTBv4G/wdFICRVIIiIiBtLyfvekAklERMQgtkIbe5P2App/5G5UIImIiBgk7ds0CrML8W/gT+NujY0OR/5ABZKIiIhBnMNrN7bGZDYZHI38kQokkcuAzW5jzW9rWHtqLWt+W4PNbjM6JBFBy/vdmYfRAYhI1UmekcyOkzuY02IOB7OKnxI+77d5NA1qypR9U2hXtx39ZvQzNkiRy9SpfafI2JGByWKiVXQro8ORs+gKkkgttuPkDo69dIyWn7Ustb3VZ6049tIxdpzcYVBkIpLyZfHy/ma9muET4mNwNHI2XUESqaVsdhtzWsyhZf+WDFg9AIC1fdfSZ00f+q/uz+r+q0ltkco4+zgsZovB0YpcfrS8372pQBKppdalreNg1kEO9j1IYHYgA1YPoP/q/pgwkRaexumg09h22Pjy5y/5U6c/GR2uyGXFesbKvlX7AM0/Otsf50z6/+ZP/5b9DflPnAokkVrqSPYRAAKzAmm7qy0AJopXyTQ70IxmB5oB8P3r35NcLxlbhI2AKwJocnUTroq6iq6RXfH31119RarC/uT9FOUXERQeRIMODYwOx218suMTJiyfcM6cyRdveJFb291arbGoQBKppRoFNsKz0JO/fvBXgrKDALCZbVjsFg40OYDVy0qDYw0IyA0g8EQgnAC2QPq/00knna/NX5Mdmg0tIPjKYMI7hdMhqgOdu3XGy8vL2JMTqeFKhtfaDGmDyaTl/VBcHN3+4e04cJTafijrELd/eDsfDf2oWoskFUgitVSvpr249dNbaXK4CQAbrt3AVzd8RZ81fRiwegCr+69m9UOrSb45mR83/kjKDykc336cwpRCfA/64pPvQ3B6MKQDG+HA778+s3xGTqMczC3N1LmyDs07N6dTj05c1fEqLBbNZRK5GIfDUapAkuJhtQnLJ5xTHAE4cGDCxCPLH+HmtjdX23CbCiSRWmr2mNm0294OgK1dtvLVDV8BxRO1TZjov7o/wzoMo2XLlrRs2RJG/G9fu91Oyu4UftjwA6lbUznx6wlsqTb8DvnhZfUi5GAIHATbWhupv/9a7LWYvMZ5eLTyoF77erTs2pLO13am9RWtMZu1YFakxIldJ8jcn4nFy0KL61sYHY7hTuef5uNfP3YOq5XFgYMDWQdYl7aOfhH9qiUutyiQ5s+fz7PPPsvRo0fp1KkTL730EpGRkedtn5iYyKuvvkpaWhr169fn9ttvJyEhAR8fn3L36XA4GDJkCMuXL2fJkiXccsstVXGKItXqtWdfw/R28WX7/Gvz2Tp0K2T97/3UmFSGdRhGu7rtytzfbDZzxZVXcMWVV8Do/2232Wxs/2k7P238id+2/capHaewp9oJOBqAV6EXXvu9YD8UrCxgx++/8n3yORN+Bq9WXoR2CKVNtzZ069mN8GbhVZgBqQ7uMpm2ptn7ZfGz1yL6ReDlX7uHq89Yz3Ag6wAHTh8g7XSa8/sDWQec32cXZrvcX8ncyupgeIG0ePFiYmNjWbBgAVFRUSQmJjJ48GB27dpFgwbnTlxbtGgRkyZNYuHChfTs2ZPdu3dzzz33YDKZmDdvXrn7TExM1Piv1CorPl9B2pQ0PPGk8LZCEj5K4Cn7U6xOXc2X33zJjb1vrPAPMovFQqcunejUpVOp7YWFhWzbso2fN/7MgR8PkLUrC/ZB4PFAfPJ98NnjA3sgb3keP/7+Ky8gj4JmBfi29qVhx4Zc0e0KuvfsToOGmrDq7nQD0kuTsrz4/kc1fXm/1WblUPah/xU8v//+x0LoxJkTLvUV6BXoUqHUKLDRpYbtMsMLpHnz5jF27FhGjy7+b+qCBQv44osvWLhwIZMmTTqn/fr16+nVqxcjRhSPB0RERDB8+HC+++67cve5bds2nn/+eb7//nsaNaq+pItUlV07dvH1iK/xL/Ins3Mmz/z7GQAsZgt9m/cl95dc+jbvW+n/y/fy8iKyRySRPUpfpc3JyWHrd1v5dfOvHPrpEDm7crD8ZiHwRCB+OX74/eoHv8LpT0+z+fdfOSE5FDUvwq+NH407NubKyCvp3qM7wcHBlRqzVJzzBqT9W3Kw7/+GRVp91opjq4/BQ9CPfsYF6MZseTYOfHMAcO/5R3aHnfSc9P8VPGdd9TmQdYAj2UfKnDN0Nn9Pf5oFNyM8OJzwoN+/fv++WXAzmgY1xcfDh4gXIziUdajMPk2YaBrUlOuaXVcVp1smQwukwsJCtmzZwuTJk53bzGYzAwcOZMOGDWXu07NnT9577z02bdpEZGQkqampLFu2jJEjR5arz7y8PEaMGMH8+fMJCwurojMUqT6nTp1iweAFhGSHcLrxaaasmIKnp6ehMQUEBNDn+j70ub5Pqe0nT55ky4Yt7Ny8kyM/H+HMnjN4pHkQcDqAgMwAyAR+hIyPMviGb1jHOrLrZ2OPsBPYNpCmnZrS/pr2dIvqhq+vryHndjkpLCwk43gGGcczOHH8BAusC2jdsTUDVg+gycEmpLRJocW+FrTf0Z6tXbay17KXa7dcS/3Q+oQ2CC01/eFyl/1TNnarnbpt6lKvTT1DYnA4HJw8c/K8V30OZB3gUNYhrHbrRfvysnjRNKips9j5Y/FT8nuIT4hLIzUv3vAit394OyZMpYqkktuTJN6QWK1DuIYWSBkZGdhsNho2bFhqe8OGDdm5c2eZ+4wYMYKMjAx69+6Nw+GgqKiI+++/nylTppSrz4kTJ9KzZ09uvvlml2ItKCigoKDA+Torq3hCh9VqxWq9+IfIVSV9VWaftZnyVcxms/HkDU8SciCEPP88Rn46kpCQkFJ5cadcBQYG0i+6H/2i+5XafvTwUX747gf2bN3DsV+OUZBSgM8BH3xzfQnKCIIM4Hs48v4RjnCEFeYV5DTIgRYQeEVg8a0IIjtwdZerK1wc2uw2kvcls/bUWrz3etOvRb8aO6/GbreTmZnJyYyTnDhxgqwTWZw+eZrsU9nkZeaRl5lHQVYBhVmFWHOs2LJtOHIdkAvmPDMe+R54nvHEy1p6nsyt/G+pdds9bWm7p63zddcfutL1h658mvipc5vV04rV20qRXxF2XzsOfwcmfxOWAAseQR54BXjhHeKNb5Av/iH+BNYNJKhOEMH1gqlTrw7169enTp06mC01d7J/yedq97e78cKLFoNbVNnfxeyCbA5kHeBg9kEOZh0s/j6r+Pu0rDQOZR8iz5p30X7MJjONAxrTNKipswhqGtjUWfg0DWxKqH8oZtOF/1yKiopcijumdQwf3PoBsUmxHMo+5NzeJKgJzw98npjWMZWSM1f7MHyIrbySk5OZM2cOr7zyClFRUaSkpDBhwgRmzZpFXFycS318+umnrFq1ih9++MHl4yYkJDBz5sxztq9YsQI/Pz+X+3FVUlJSpfdZm13u+UpakEToplCKLEUExQaRdjCNtINpZbd191x5Q+serWnd43/zM05knOBgykFO7T9F/oF8LActBB0NwrvAm+CjwXAU2ACHfv/1hccXnG5wGmtjK57hngRHBNOoZSPCGoed91YER/59hIOFB1nQfQEnrMXzJub9No96nvW4//v7aerVlEbDq28o3mq1kpOdQ25OLmdyznAm5wwFuQUU5hZizbNSlFuE/YwdR54DR54DU74J8xkzljMWPPI98Mr3wqvAC7Pjwj+8zJjx+f3XRWPysFLgU0CBVwH5PvkUeBcQsT8Cs8OMAweHmhzCJ98H7wJvvAu8nYWVp9UTT6sn5Jy/7yKKyP7911GOnvO+AwcFPgVYfYqLLZuvDbuPHYevA/zA5GvC4mfB4mfBy9+ruOjy88YnwAffAF/8A/zxD/DH29v7oudZmUp9rgpP8I8f/oEXXsTlxLFx2MZyf66sdisZ1gwyCjNK//6H73NtuS71FewRTH3P+tT3ql/699+/r+tZF4vpD39fCn7/yoD0339VNm+8+WfLf/Jrzq+cKjpFHY86tA9ojyXVwrLUZZVyjLy8ixeHYHCBVL9+fSwWC+nppZOcnp5+3mGvuLg4Ro4cyZgxYwDo2LEjubm5jBs3jqlTp7rU56pVq9i7dy8hISGl2tx2221cd911JCcnn3PcyZMnExsb63ydlZVFeHg40dHRBAUFlffUz8tqtZKUlMSgQYMMHx6pCZQveO2Z1whdHgpAaFwoD0x5oMx2tS1Xdrud3bt289N3P7H/h/2c3HESe6od/yP+eFo9qXe4HhwGvi9uf5zjHPI6RG6TXDxaFt+KoEWXFnS+tjMtWrbg/5L+D8/5nlyVeRVr+651HqfD1x3wXO2J7UEbQ4YMuWhcNpuNzFOZZGRkcDLjJFkni6/a5JzKITczlzNZZyjILL5qU5RThC2n+KqNKbe4wPHI88Az3xPPonP/jDx//1XuXJnsFHoXYvW1YvOz4fArvoJj8jfhEeiBR6AHPkE++IT44BfsR0CdAALrBBJUN4i69epSt35d6tWvh6+vL2t+W8Og9wcB0GdNH1rua0mRpQgPmwe7r9jtzF3SnUlENYzi5ImTnMg4wakTp8g6mUXWySxyMnPIy8wj/3Q++Vn5WLOs2HJs2HJskAumPBOWvOJCzzvfG7PdjAlT8YT/fNeH6+zYyfv91wmKi94ijyIKfQop8inC7mcvzkWACXOAGY9AD7yCvPAO8sYv2A+/kOJcBNcNJqhOEHVD61KvXj3q1qvr8j2/Xkt6zfm52n3FbgJzAin0LCRkXwiea0p/rorsRRzJOVLmVZ+S74/lHXPpuMHewTQNakqzoGbOK0BNg5oSHhju/N7Hw32HPm+w3lBl/16VjABdjKEFkpeXF926dWPlypXO5fV2u52VK1cyfvz4MvfJy8s7554qJR9Uh8PhUp+TJk1yFlglOnbsyAsvvEBMTEyZx/X29i7zfx6enp5V8sOmqvqtrS7XfH259EuOzjiKBx5Yh1l5OP7hi+5Tm3LV8eqOdLy6Y6ltVquVX376pfhWBD/+RuaOTBypDgLSf78VwT4v2AeFKwvZ9fuvfN98jjU4hrmxmQGrBxCSGcLmazZzzaZr6LqtK79e+Svpaelk3J9BYXah8we6PceOI9eBOc9c6gd6yZyJ87FgwRfX5k4VehZi9fn9iol/8Q90c4C5eHgq0APvYG98gnzwC/H73/BU3SDq1KtT/AO9fj1CQkIq7V5U/Vv2p2lQU1p91or+q/uzqv8q50OQB6wegAkTqTGpzpWSgYGBNI9oXuHj2e12srOzyTiWwckTJzmVcYrTJ4qHCXNO5XDm9BnyT+dTcLoAa/bvfy65dkw5JkxnTM6C06uw+GqWR5EHHjkeF7yaZcPmvJpV1lUSB47/FZy+xQUn/mD2N2MJtOAZ5Il3kDfewd58mv4pjTo0YsDqAbTZUzwp+3TQafqt6ceq/qvY3Ggz77/zPgezDnI4+zA2h+2iOfH18D1nns/Z838CvQMrlG93UxX/Xrnan+FDbLGxsYwaNYru3bsTGRlJYmIiubm5zhVod999N02aNCEhIQGAmJgY5s2bR5cuXZxDbHFxccTExDgLpYv1GRYWVuYVqmbNmtGihW7aJTXDLz/9QvLIZPyK/Mjsnslz7z9ndEhuwdPTk87dOtO5W+dS2/Pz8/lxy49s/2578a0IdmZh2m8i4HgAPmd8aPZbM2fbknk0JdrvbE/7ne0B8Pr918XYzXYKfAoo8i0q/iHq78DkZ8IcaMYj4PcrFcHe+AYXz7vxD/EnuF4wIfVCCKkXQv3Q+tStV9ftJjhbzBam7JvCsdXHWN1/tfOK0dk3IK2seVtms5ng4GCCg4Np1aZVhfuxWq1kHC++qnfyxEkyMzLJOpVF9sls8k7ncSbzzP/mY2Vbi4vfHEepq1le+V5YbBZMmJzDiGSWfTwHDvLJJ5po57bwg8X3/go9EeosLCmCDQf/t4DIw+zhnO9z9qqvkiKorm9d3Z6mGhheIA0bNozjx48zffp0jh49SufOnVm+fLlzknVaWlqp//lMmzYNk8nEtGnTOHToEKGhocTExDB79myX+xSp6U6ePMn/Dfk/QnJCyGyaSdxXcXrMx0X4+PgQ1SuKqF5Rpbbn5OTw4n9e5MPPPiT0eCgNjjXgit1XOFfSHGpyyDnfpm69utQNrYt3kDc+wT74BvsSUCeAoHpBBNUJok79OtStV5f6DeoTGBhYa+8g3q5uO3gI9rbYW64bkBrJ09OTRo0b0ahxxeeR2e12cnJyOJFxghPHT5B5MpPTGafJOpVFbmYueafyyM/639WsrJNZ5J7KdRZTocdDMWGiyFJUahh3QtQEhncYTnhwOA39G9bYRQG1jcnhcFz8JgZyjqysLIKDgzl9+nSlz0FatmwZQ4YMqTXDIFXpcsyXzWbj0ahHCdkSQl5AHqM2jKJ9h/YX3e9yzJWrkvcn0//t/gDOoaKSeTXO/+kDq0etrrbHHNQENrutUm5AWlvpc1VxVfnvlas/vw2/giQi5RN/ZzwhW0Io8iii//v9XSqO5MKua3adS/NqqvMmdTVBVd+AtKbT56pmU4EkUoPMf3I+nouL/zfVZFYTbvjzDQZHVDtU97wauTzoc1WzqUASqSE+//hz0p9Mx4IF+1127p90v9Eh1So1cV6NuD99rmouFUgiNcD2n7bzzahv8LX5cjrqNM++9azRIdU6/Wb0ox/9GGcfp3k1Umn0uaq5VCCJuLnjx4+z8MaFBOcGk9ksk+lfTteKtSqkeTVSFfS5qnlq5xpUkVrCarUyJ3oOwYeDyQ3K5f7l91OnTh2jwxIRqfVUILkRm93Gmt/WsPbUWtb8tgab/eJ3VJXaLf6v8YRsC8HqYWXQokG0bdf24juJiMgl0xCbG0iekcyOkzuY02IOB7MOAsUPyWwa1JQp+6bQrm47+s3oZ2yQUu1ejHsR70+KH28TMTeCQTcNMjgiEZHLh64guYEdJ3dw7KVjtPysZantrT5rxbGXjrHj5A6DIhOjLP1gKSfmFD9ck3tgzD/GXLC9iIhULl1BMpjNbmNOizm07N+SAasH4FHkgc1iAwf0X9Of1f1Xk9oilXH2cZrUd5nYtmUbG+/diK/dl9M9T/PcG3rGmohIdVOBZLB1aes4mHWQg30PggMGJA9wvre291rW9F0DWcXtdCv62u9Y+jHeuekdgvOCyYzIZOaXM2vt87xERNyZ/uU12JHsI87v1/Zbi838v4nZ7Xa2I+RUyDntpHYqLCwkYVACwenB5ATn8Pev/l6pz/kTERHXqUAyWKPA/z1Zus+aPljsFmeRFJoRytjXx9L0QNNS7aR2ir8jnpCfQ7B6Wrlx8Y20uaKN0SGJiFy2VCAZrORhhn3X9GXA6gGs6r+KWdNn8W3PbwHwz/PnnrfuYfd/dhscqVSleZPn4fOpDwAtn2nJgMEDLrKHiIhUJRVIBit5mGH/1f1LPcwwKTqJNdetAcDD5sGRx48wa+ws7Ha7keFKFfjk/U84/cxpAMxjzPztkb8ZHJGIiKhAcgPt6rajwUMN2Buzt9T2lL+kEPr3UIquLALA/n92Hh/4OGfOnDEiTKkC33/3PZvHbsZsN5PVJ4up/5pqdEgiIoJWsbkFVx5m+PwTz5P1XBaBqwOZ3GUyj698nMZNGhscuVyKI4eP8O8//5ugM0Fktsxk1heztGJNRMRN6F9jN1LyMMM+dfqc8zDDfzz9D9q93o4C7wLq7KrD812f54fvfzAwWrkU+fn5PD3oaYKOBZETksPDSQ8TEBBgdFgiIvI7FUg1yF//9leGLB9CTp0cgo4FsbjvYj7/+HOjw5IKiL89njq/1qHQq5CYj2Jo0bKF0SGJiMgfqECqYXr3680Dmx8gMyIT3zxfvhv2HQsSFhgdlpTDc489h98XfjhwcGXilfS5vo/RIYmIyFlUINVALVu1ZMa2GZyOPI2HzYP0KenMuGeGVrjVAB++9SHZ87IB8HzAk5EPjDQ4IhERKYsKpBoqODiYZ9c/i3WoFQDT2yYe6/8Yubm5Bkcm57NpwyZ+eOAHzHYz2f2zmfzyZKNDEhGR81CBVINZLBaeWvwUwVODsZltBK0NYmqXqRxIO2B0aHKWgwcOsvjPi/HJ9+FU61PM/EzPWBMRcWf6F7oWeOSpR7j6ravJ98mnzp46JHZLZPPGzUaHJb87c+YMz0U/R1BGENl1s4lNisXf39/osERE5AJUINUSt4+8nZuTbia7bjZBGUF8MuATln6w1OiwLnt2u534W+Kps7N4xdpfPvkLzSKaGR2WiIhchAqkWuTa3tcy/vvxZLbMxOeMD1vv2srLT75sdFiXtWdjn8V/hT8OHLR/qT29+vYyOiQREXGBCqRaJqJFBDN/mMnpnqex2CyciD/B9DunY7PZjA7tsrPo9UXk/TMPAJ+HfLhz3J0GRyQiIq5SgVQLBQUF8ezaZ7HdWVwUWRZZeOy6x8jKyjI4ssvH+rXr2f7QdswOMzkDc3g88XGjQxIRkXJQgVRLWSwWnnzvSerPrI/NYiN4QzDxXeLZv2+/0aHVemn70/jk1k/wLvDmVNtTPPnpk1qxJiJSw+hf7VruwekP0vW9ruT75hOSGsLL3V9m4zcbjQ6r1srNzWVe9DwCTwSSXS+bf6z4B76+vkaHJSIi5aQC6TJwy19v4dZVt5JVP4vAk4F8OvBTPnr3I6PDqnXsdjszbp5BnT11KPAu4PaltxPeLNzosEREpAJUIF0mrrn2Gh7Z8gin2pzCu8Cbn+/5mcRpiUaHVas8/fDTBKwMwG6y0+nVTlzb+1qjQxIRkQpyiwJp/vz5RERE4OPjQ1RUFJs2bbpg+8TERNq2bYuvry/h4eFMnDiR/Pz8cvV533330apVK3x9fQkNDeXmm29m586dlX5u7iS8WTizf5hNVp8szHYzp2efZurQqVrhVgneffVdCuYXABAwMYBho4cZHJGIiFwKwwukxYsXExsbS3x8PFu3bqVTp04MHjyYY8eOldl+0aJFTJo0ifj4eHbs2MEbb7zB4sWLmTJlSrn67NatG2+++SY7duzgq6++wuFwEB0dXeuLBX9/f55d/SzcU/za6z9ePNrjUU6fPm1oXDXZutXr2PnITkyYyLsxj388+w+jQxIRkUtkeIE0b948xo4dy+jRo2nfvj0LFizAz8+PhQsXltl+/fr19OrVixEjRhAREUF0dDTDhw8vdYXIlT7HjRtHnz59iIiIoGvXrjz11FMcOHCA/fv3V/UpG85sNhP/ZjwN5zSkyFJEyOYQZnSawd49e40OrcbZl7qPT2/7FK9CL061P8XMT/SMNRGR2sDDyIMXFhayZcsWJk/+31PNzWYzAwcOZMOGDWXu07NnT9577z02bdpEZGQkqampLFu2jJEjR1a4z9zcXN58801atGhBeHjZk2oLCgooKChwvi65p5DVasVqtZbvxC+gpK/K7PN87n30Xpa1WsaG0RsI+S2EBZELuOk/N9Wouz1XZ77OlpOTw4vRL1LnVB2yQrOY+MVELBaLIbG4wshc1TTKleuUK9cpV66ryly52qehBVJGRgY2m42GDRuW2t6wYcPzzgcaMWIEGRkZ9O7dG4fDQVFREffff79ziK08fb7yyis8/vjj5Obm0rZtW5KSkvDy8irzuAkJCcycOfOc7StWrMDPz8/lc3ZVUlJSpfdZJm9omtCUvbP2EpIRwoo/rWDV+FV0u65b9Ry/klRbvn5nt9tZkbCCsL1h5Pvk03xyc7b9uI1tP26r1jgqorpzVZMpV65TrlynXLmuKnKVl5fnUjtDC6SKSE5OZs6cObzyyitERUWRkpLChAkTmDVrFnFxceXq684772TQoEEcOXKE5557jqFDh/Ltt9/i4+NzTtvJkycTGxvrfJ2VlUV4eDjR0dEEBQVd8nmVsFqtJCUlMWjQIDw9PSut34s5/OfDvHDjC9TZWQf7PDu7Tbt5ZM4j1Xb8ijIqX3MfnEvY5jDsZjudX+3MrXfeWm3HriijclUTKVeuU65cp1y5ripz5epTJQwtkOrXr4/FYiE9Pb3U9vT0dMLCwsrcJy4ujpEjRzJmzBgAOnbsSG5uLuPGjWPq1Knl6jM4OJjg4GDatGnDtddeS506dViyZAnDhw8/57je3t54e3ufs93T07NKPuhV1e/5NI9oTsLWBOL+FEfgqkDynstjesp0nvzwyRrxF7k68/XWS29hf90OQNCjQQy7p2atWKvuz1ZNply5TrlynXLluqrIlav9GTqb1MvLi27durFy5UrnNrvdzsqVK+nRo0eZ++Tl5Z0zCdZisQDgcDgq1GfJvg6Ho9Q8o8uNr68vzyQ9g3lscX59lvrw+LWPc/LkSYMjcx/JK5LZ8489AJz50xn+8bRWrImI1EaGL7eJjY3l9ddf5+2332bHjh088MAD5ObmMnr0aADuvvvuUhOuY2JiePXVV/nggw/Yt28fSUlJxMXFERMT4yyULtZnamoqCQkJbNmyhbS0NNavX88dd9yBr68vQ4YMqf4kuBGz2Uzca3E0ea4JRR5FhGwNYVbnWezeudvo0AyXujeVL4Z9gZfVi1MdT/Hkx08aHZKIiFQRw+cgDRs2jOPHjzN9+nSOHj1K586dWb58uXOSdVpaWqkrRtOmTcNkMjFt2jQOHTpEaGgoMTExzJ492+U+fXx8WLduHYmJiZw6dYqGDRvSp08f1q9fT4MGDao3AW5qzD/GsLzNclaPWE3IgRD+L+r/GPKfIfSL7md0aIbIysripUEvEZIZQlaDLCavmHzeCf0iIlLzGV4gAYwfP57x48eX+V5ycnKp1x4eHsTHxxMfH1/hPhs3bsyyZcsqFOvl5IY/30Djbxrz1o1vEXw0mKSYJA4kHmDkAyONDq1a2e12Zt40k5B9IeT75nPXF3fRMKzhxXcUEZEay/AhNnFvV3e+mid+eIJTV53Cq9CLvX/fyzMTn8FutxsdWrV5auxTBH0ThM1sI/L/IunSvYvRIYmISBVTgSQX1TCsIXO/n0tudC4mTJxJPMOUm6dQWFhodGhV7o15b+BY6ACg7uS6/GXEXwyOSEREqoMKJHGJj48Pc7+ci+ffPXHgwPdzX56IfILjx48bHVqV+frLr9k3aR8A+bfk88hTjxgbkIiIVBsVSOIys9nMlPlTaP5ic6yeVkJ+DCGhcwK/bv/V6NAq3e6du1nx1xV4Wj3J7JTJzMXn3kVdRERqLxVIUm6jHx5N3yV9yQ3MJfhwMG/1fIuvv/za6LAqzenTp3l18Kv4Z/lzOuw0k7/SijURkcuNCiSpkEE3DeKe9fdwuvFp/LP9Sb45mbdeesvosC6ZzWZj5g0zCUkL4Yz/GUYtG0WDhrr1g4jI5UYFklRY+w7tmbxtMplXZ+Jp9WT/w/tJGJ9Qo1e4zfrbLII3BmOz2Oj1Zi86delkdEgiImIAFUhySUJDQ3l689Pk3ZSHCROF8wuZNGQS+fn5RodWbv96+l+Y3jEB0GB6A2LuiDE4IhERMYoKJLlkXl5eJHyagM8EHxw48P/Kn0ndJ5F+NP3iO7uJrz77ioPTDgJQeEch46eXfZNRERG5PKhAkkphNpt5IvEJWr3SikKvQur8UoenuzzNT9t+Mjq0i9rxyw5W3rkSjyIPMrtmMuP9GUaHJCIiBlOBJJVq5AMjGfTZIHKDcgk+Gsz7173P8k+XGx3WeZ06dYrXbnwN/2x/Tjc+zbSvpuHp6Wl0WCIiYjAVSFLp+kX3496N95IZnolfjh/f3PYN//f8/xkd1jlsNhtPDn6SkAMh5AXkce+X91Kvfj2jwxIRETegAkmqRNt2bYnbFkdm10w8izw59OghZo2b5VYr3GbePZOQzSEUWYro+05frrr6KqNDEhERN6ECSapM3bp1eWbjM+TfXLyizf66nSein+DMmTMGRwavznkVyyILAI1mNmLIX4YYHJGIiLgTFUhSpTw9PUlYmoD/o/7YTXYCVgYwuetkDh86bFhMXy79ksPTi49fNLyIv0/9u2GxiIiIe1KBJNXi0Wcf5crXrixe4bazDs93fZ4fvv+h2uP45adfSB6ZjIfNg8xrMpnx7oxqj0FERNyfCiSpNsPHDOeG5TeQE5JD0LEgFvddzOcff15txz+RcYI3bnwDvxw/MsMziVseh8Viqbbji4hIzaECSarVdf2v4/5N95PZLBPfPF++G/YdC+YuqPLjWq1Wnhr8FMGHg8kLyGPcl+OoW7dulR9XRERqJhVIUu1atWnF9G3TybwmEw+bB+mT05k5emaVrnCbcecMQraGUORRxIBFA2h3VbsqO5aIiNR8KpDEEHXq1OG5Dc9ReHth8Ya34LEBj5Gbm1vpx3ppxkt4/ccLgKZPNWVwzOBKP4aIiNQuKpDEMBaLhdn/mU3wlGDsZjtBa4KY2mUqB9IOVNoxPvvPZxx/6jgA9pF27nvivkrrW0REai8VSGK4R2Y/QoeFHSjwLqDOnjokdktk88bNl9zvjz/8yLf3fIvFZuH0taeZ/ub0SohWREQuByqQxC3cMeoO/rTiT2TXySYoI4hPBnzC0g+WVri/48eP8/aQt/HN8yWzWSbxy+O1Yk1ERFymAkncRs8+PXnw+wfJbJGJzxkftt61lflPzi93P1arlTmD5hB8NJjcoFwe+OoBgoODqyBiERGprVQgiVtp0bIFM7fN5PS1p7HYLGTEZzD9runYbDaX+4gfFk/IjyFYPa1EfxDNFVdeUYURi4hIbaQCSdxOUFAQz37zLLYRxUWR5X0Lj/V5jKysrIvumzgtEe8l3gC0mNuCgTcOrNJYRUSkdlKBJG7JYrHw5PtPUje+LjazjeD1wUzvOp39+/afd5+lHyzlZMJJAEx/M3Fv7L3VFK2IiNQ2KpDErT004yG6vNuFfJ986uytw8vXvMzGbzYCYLPbWPPbGtaeWsvby95m470bsdgtZPXKYtrr0wyOXEREajIPowMQuZi/jPgLTVs2ZfGfFhN4IpAv+n3BlwO/ZOHghRzMOojPGR/ufeNeQvNCyQ3OJfq6aMxm1f4iIlJx+ikiNcI1117DhK0TONX6FB42D8xfmen9r96YbWZu/+h2QjNCyffOx/+0P6m5qUaHKyIiNZwKJKkxwpuFM3PLTH7t9CsAV+66kokvTKT13tYUmYvwKfBhdf/VJLRIwGZ3fdWbiIjI2VQgSY3yw8kf+PCWD0numwxAYE4gAB52D1b1X8Wavms4kHWAdWnrDIxSRERqOrcokObPn09ERAQ+Pj5ERUWxadOmC7ZPTEykbdu2+Pr6Eh4ezsSJE8nPz3e5z5MnT/LQQw85+2jWrBkPP/wwp0+frpLzk8pzJPsImCC5fzKf/OUTHDgAKLIUsbbv2tLtREREKsjwAmnx4sXExsYSHx/P1q1b6dSpE4MHD+bYsWNltl+0aBGTJk0iPj6eHTt28MYbb7B48WKmTJnicp+HDx/m8OHDPPfcc2zfvp233nqL5cuXc++9Whbu7hoFNnJ+H5IZggkTRZYiPGwe9FnTp8x2IiIi5WX4KrZ58+YxduxYRo8eDcCCBQv44osvWLhwIZMmTTqn/fr16+nVqxcjRowAICIiguHDh/Pdd9+53GeHDh34+OOPne1btWrF7NmzueuuuygqKsLDw/C0yHlc1+w6mgY1pdVnrei/uj+r+q9ibd+19FnThwGrB2DCRGpMKtc1u87oUEVEpAYztBIoLCxky5YtTJ482bnNbDYzcOBANmzYUOY+PXv25L333mPTpk1ERkaSmprKsmXLGDlyZIX7BDh9+jRBQUHnLY4KCgooKChwvi65q7PVasVqtbp+0hdR0ldl9lnbTNo7iYzVGazuv9o5rLa271pMmOi/uj93tL8Du82O3WY3OFL3os+W65Qr1ylXrlOuXFeVuXK1T0MLpIyMDGw2Gw0bNiy1vWHDhuzcubPMfUaMGEFGRga9e/fG4XBQVFTE/fff7xxiq0ifGRkZzJo1i3Hjxp031oSEBGbOnHnO9hUrVuDn53fB86yIpKSkSu+ztrBkWLD+xcr27tvhD5/zXwb+Qu+Q3lgyLCxbtsy4AN2cPluuU65cp1y5TrlyXVXkKi8vz6V2NW4sKTk5mTlz5vDKK68QFRVFSkoKEyZMYNasWcTFxZW7v6ysLG666Sbat2/PjBkzzttu8uTJxMbGltovPDyc6OhogoKCKnIqZbJarSQlJTFo0CA8PT0rrd9aZUjxb9Ps00jel0zSxiQGXTuIfi36YTFbDA3Nnemz5TrlynXKleuUK9dVZa5cea4nGFwg1a9fH4vFQnp6eqnt6enphIWFlblPXFwcI0eOZMyYMQB07NiR3Nxcxo0bx9SpU8vVZ3Z2NjfccAOBgYEsWbLkgn8I3t7eeHt7n7Pd09OzSj7oVdVvbeKJJ9e3up6CXQVc3+p65ctF+my5TrlynXLlOuXKdVWRK1f7M3QVm5eXF926dWPlypXObXa7nZUrV9KjR48y98nLyzvnMRIWS/FVA4fD4XKfWVlZREdH4+XlxaeffoqPj09lnpqIiIjUYIYPscXGxjJq1Ci6d+9OZGQkiYmJ5ObmOleg3X333TRp0oSEhAQAYmJimDdvHl26dHEOscXFxRETE+MslC7WZ0lxlJeXx3vvvUdWVpbzkltoaKizHxEREbk8GV4gDRs2jOPHjzN9+nSOHj1K586dWb58uXOSdVpaWqkrRtOmTcNkMjFt2jQOHTpEaGgoMTExzJ492+U+t27d6rwtQOvWrUvFs2/fPiIiIqr4rEVERMSdGV4gAYwfP57x48eX+V5ycnKp1x4eHsTHxxMfH1/hPvv164fD4ahQrCIiIlL7GX4nbRERERF3owJJRERE5CwqkERERETOogJJRERE5CwqkERERETO4har2GqiklVwrt6y3FVWq5W8vDyysrJ0p1UXKF+uU65cp1y5TrlynXLluqrMVcnP7YutZleBVEHZ2dkAhIeHGxyJiIiIlFd2djbBwcHnfd/k0A2BKsRut3P48GECAwMxmUyV1m/JQ3APHDhQqQ/Bra2UL9cpV65TrlynXLlOuXJdVebK4XCQnZ1N48aNz3l02R/pClIFmc1mmjZtWmX9BwUF6S9QOShfrlOuXKdcuU65cp1y5bqqytWFrhyV0CRtERERkbOoQBIRERE5iwokN+Pt7U18fDze3t5Gh1IjKF+uU65cp1y5TrlynXLlOnfIlSZpi4iIiJxFV5BEREREzqICSUREROQsKpBEREREzqICSUREROQsKpDczPz584mIiMDHx4eoqCg2bdpkdEhuae3atcTExNC4cWNMJhNLly41OiS3lJCQwDXXXENgYCANGjTglltuYdeuXUaH5bZeffVVrr76aufN6Xr06MGXX35pdFhub+7cuZhMJh555BGjQ3FLM2bMwGQylfq68sorjQ7LbR06dIi77rqLevXq4evrS8eOHfn++++rPQ4VSG5k8eLFxMbGEh8fz9atW+nUqRODBw/m2LFjRofmdnJzc+nUqRPz5883OhS3tmbNGh588EE2btxIUlISVquV6OhocnNzjQ7NLTVt2pS5c+eyZcsWvv/+ewYMGMDNN9/ML7/8YnRobmvz5s3861//4uqrrzY6FLd21VVXceTIEefXN998Y3RIbunUqVP06tULT09PvvzyS3799Veef/556tSpU+2xaJm/G4mKiuKaa67h5ZdfBoqf9xYeHs5DDz3EpEmTDI7OfZlMJpYsWcItt9xidChu7/jx4zRo0IA1a9bQp08fo8OpEerWrcuzzz7Lvffea3QobicnJ4euXbvyyiuv8NRTT9G5c2cSExONDsvtzJgxg6VLl7Jt2zajQ3F7kyZN4ttvv2XdunVGh6IrSO6isLCQLVu2MHDgQOc2s9nMwIED2bBhg4GRSW1y+vRpoPiHvlyYzWbjgw8+IDc3lx49ehgdjlt68MEHuemmm0r9uyVl27NnD40bN6Zly5bceeedpKWlGR2SW/r000/p3r07d9xxBw0aNKBLly68/vrrhsSiAslNZGRkYLPZaNiwYantDRs25OjRowZFJbWJ3W7nkUceoVevXnTo0MHocNzWzz//TEBAAN7e3tx///0sWbKE9u3bGx2W2/nggw/YunUrCQkJRofi9qKionjrrbdYvnw5r776Kvv27eO6664jOzvb6NDcTmpqKq+++ipt2rThq6++4oEHHuDhhx/m7bffrvZYPKr9iCJiiAcffJDt27dr7sNFtG3blm3btnH69Gk++ugjRo0axZo1a1Qk/cGBAweYMGECSUlJ+Pj4GB2O27vxxhud31999dVERUXRvHlzPvzwQw3dnsVut9O9e3fmzJkDQJcuXdi+fTsLFixg1KhR1RqLriC5ifr162OxWEhPTy+1PT09nbCwMIOiktpi/PjxfP7556xevZqmTZsaHY5b8/LyonXr1nTr1o2EhAQ6derEiy++aHRYbmXLli0cO3aMrl274uHhgYeHB2vWrOGf//wnHh4e2Gw2o0N0ayEhIVxxxRWkpKQYHYrbadSo0Tn/GWnXrp0hQ5IqkNyEl5cX3bp1Y+XKlc5tdrudlStXav6DVJjD4WD8+PEsWbKEVatW0aJFC6NDqnHsdjsFBQVGh+FWrr/+en7++We2bdvm/OrevTt33nkn27Ztw2KxGB2iW8vJyWHv3r00atTI6FDcTq9evc65Fcnu3btp3rx5tceiITY3Ehsby6hRo+jevTuRkZEkJiaSm5vL6NGjjQ7N7eTk5JT639e+ffvYtm0bdevWpVmzZgZG5l4efPBBFi1axH//+18CAwOd89mCg4Px9fU1ODr3M3nyZG688UaaNWtGdnY2ixYtIjk5ma+++sro0NxKYGDgOfPY/P39qVevnua3leHRRx8lJiaG5s2bc/jwYeLj47FYLAwfPtzo0NzOxIkT6dmzJ3PmzGHo0KFs2rSJ1157jddee636g3GIW3nppZcczZo1c3h5eTkiIyMdGzduNDokt7R69WoHcM7XqFGjjA7NrZSVI8Dx5ptvGh2aW/rb3/7maN68ucPLy8sRGhrquP766x0rVqwwOqwaoW/fvo4JEyYYHYZbGjZsmKNRo0YOLy8vR5MmTRzDhg1zpKSkGB2W2/rss88cHTp0cHh7ezuuvPJKx2uvvWZIHLoPkoiIiMhZNAdJRERE5CwqkERERETOogJJRERE5CwqkERERETOogJJRERE5CwqkERERETOogJJRERE5CwqkEREzmIymVi6dKnRYYiIgVQgiUitcs8993DLLbcYHYaI1HAqkERERETOogJJRGqtfv368fDDD/P4449Tt25dwsLCmDFjRqk2e/bsoU+fPvj4+NC+fXuSkpLO6efAgQMMHTqUkJAQ6taty80338z+/fsB2LlzJ35+fixatMjZ/sMPP8TX15dff/21Kk9PRKqQCiQRqdXefvtt/P39+e6773jmmWd48sknnUWQ3W7n1ltvxcvLi++++44FCxbwxBNPlNrfarUyePBgAgMDWbduHd9++y0BAQHccMMNFBYWcuWVV/Lcc8/x97//nbS0NA4ePMj999/P008/Tfv27Y04ZRGpBHpYrYjUKvfccw+ZmZksXbqUfv36YbPZWLdunfP9yMhIBgwYwNy5c1mxYgU33XQTv/32G40bNwZg+fLl3HjjjSxZsoRbbrmF9957j6eeeoodO3ZgMpkAKCwsJCQkhKVLlxIdHQ3An/70J7KysvDy8sJisbB8+XJnexGpeTyMDkBEpCpdffXVpV43atSIY8eOAbBjxw7Cw8OdxRFAjx49SrX/8ccfSUlJITAwsNT2/Px89u7d63y9cOFCrrjiCsxmM7/88ouKI5EaTgWSiNRqnp6epV6bTCbsdrvL++fk5NCtWzfef//9c94LDQ11fv/jjz+Sm5uL2WzmyJEjNGrUqOJBi4jhVCCJyGWrXbt2HDhwoFRBs3HjxlJtunbtyuLFi2nQoAFBQUFl9nPy5Enuuecepk6dypEjR7jzzjvZunUrvr6+VX4OIlI1NElbRC5bAwcO5IorrmDUqFH8+OOPrFu3jqlTp5Zqc+edd1K/fn1uvvlm1q1bx759+0hOTubhhx/m4MGDANx///2Eh4czbdo05s2bh81m49FHHzXilESkkqhAEpHLltlsZsmSJZw5c4bIyEjGjBnD7NmzS7Xx8/Nj7dq1NGvWjFtvvZV27dpx7733kp+fT1BQEO+88w7Lli3j3XffxcPDA39/f9577z1ef/11vvzyS4POTEQulVaxiYiIiJxFV5BEREREzqICSUREROQsKpBEREREzqICSUREROQsKpBEREREzqICSUREROQsKpBEREREzqICSUREROQsKpBEREREzqICSUREROQsKpBEREREzqICSUREROQs/w/q49L8SdQAoAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(batch_valid):\n", + " actual = pd.concat([pd.DataFrame(X_valid[i], columns = ['XRP', 'ETH', 'LTC', 'BTC']), \n", + " pd.DataFrame(y_valid[i].reshape(1, 4), columns = ['XRP', 'ETH', 'LTC', 'BTC'])], \n", + " ignore_index = True)\n", + " print(actual)\n", + " \n", + " forecast = pd.concat([pd.DataFrame(X_valid[i], columns = ['XRP', 'ETH', 'LTC', 'BTC']), \n", + " pd.DataFrame(y_hat[i].reshape(1, 4), columns = ['XRP', 'ETH', 'LTC', 'BTC'])], \n", + " ignore_index = True)\n", + " print(forecast)\n", + "\n", + "# =================== XPR ======================== \n", + " fig, ax = plt.subplots()\n", + " \n", + " ax.plot(actual.index, actual['XRP'], label = 'actual XRP', marker = 'o', color = 'black')\n", + " ax.plot(forecast.index, forecast['XRP'], label = 'forecast XRP', marker = 'x', color = 'orange')\n", + " \n", + " # Add labels and a title\n", + " ax.set_xlabel('Index')\n", + " ax.set_ylabel('Values')\n", + " ax.set_title('XRP Time Series Plot')\n", + " \n", + " ax.legend() # Add legend\n", + "\n", + " ax.grid(True) # Add grid\n", + " \n", + " plt.show()\n", + "# =================== ETH ========================\n", + " fig, ax = plt.subplots()\n", + " ax.plot(actual.index, actual['ETH'], label = 'actual ETH', marker = 'o', color = 'blue')\n", + " ax.plot(forecast.index, forecast['ETH'], label = 'forecast ETH', marker = 'x', color = 'red')\n", + " \n", + " # Add labels and a title\n", + " ax.set_xlabel('Index')\n", + " ax.set_ylabel('Values')\n", + " ax.set_title('ETH Time Series Plot')\n", + "\n", + " ax.legend() # Add legend\n", + "\n", + " ax.grid(True) # Add grid\n", + " \n", + " plt.show()\n", + "\n", + "# =================== LTC ========================\n", + " fig, ax = plt.subplots()\n", + " \n", + " ax.plot(actual.index, actual['LTC'], label = 'actual LTC', marker = 'o', color = 'green')\n", + " ax.plot(forecast.index, forecast['LTC'], label = 'forecast LTC', marker = 'x', color = 'purple')\n", + "\n", + " # Add labels and a title\n", + " ax.set_xlabel('Index')\n", + " ax.set_ylabel('Values')\n", + " ax.set_title('LTC Time Series Plot')\n", + " \n", + " ax.legend() # Add legend\n", + "\n", + " ax.grid(True) # Add grid\n", + " \n", + " plt.show()\n", + " \n", + "# =================== BTC ========================\n", + " fig, ax = plt.subplots()\n", + " \n", + " ax.plot(actual.index, actual['BTC'], label = 'actual BTC', marker = 'o', color = 'violet')\n", + " ax.plot(forecast.index, forecast['BTC'], label = 'forecast BTC', marker = 'x', color = 'yellow')\n", + " \n", + " # Add labels and a title\n", + " ax.set_xlabel('Index')\n", + " ax.set_ylabel('Values')\n", + " ax.set_title('BTC Time Series Plot')\n", + "\n", + " ax.legend() # Add legend\n", + "\n", + " ax.grid(True) # Add grid\n", + " \n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "070a40ef-19e3-4fd2-96d2-02b2f539dd6d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 156, + "id": "c2cde064-bdf9-464f-b277-a56fdbc46056", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6]\n", + "range(0, 4)\n" + ] + } + ], + "source": [ + "time_index = list(range(sl+frwd))\n", + "print (time_index)\n", + "\n", + "print (range(actual.shape[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "117c9058-fad0-4ebc-87f7-c343fca58341", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35b7c9dd-de36-4d6b-886d-eeeb55d46dde", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "753f259f-5e73-4c67-ac07-3c3851b4b3ff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(6, 4)\n", + "[[0.5233 0.383067 0.8573 0.7105592]\n", + " [0.5235 0.383102 0.8574 0.7105005]\n", + " [0.5243 0.383687 0.8538 0.710517 ]\n", + " [0.5239 0.383284 0.8528 0.7100418]\n", + " [0.5238 0.382979 0.8526 0.7097535]\n", + " [0.5229 0.3827 0.8522 0.7088585]]\n" + ] + } + ], + "source": [ + "print (type(X_valid[0]))\n", + "print (shape(X_valid[0]))\n", + "print (X_valid[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "132549eb-5c83-4243-8747-680f57b4fd20", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 136, + "id": "b57187f1-a74f-466d-9128-b0cb963cb9fc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a time index (assuming each row is a time point)\n", + "# time_index = np.arange(len(X_valid[0])) # This will create [0, 1, 2, 3, 4, 5] as the index\n", + "\n", + "time_index = list(range(sl))\n", + "\n", + "column_names = ['XRP', 'ETH', 'LTC', 'BTC)']\n", + "\n", + "# Create figure and axes objects using object-oriented approach\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "\n", + "# Plot each column as a separate line\n", + "for i in range(X_valid[0].shape[1]):\n", + " ax.plot(time_index, data[:, i], label = f'Column {column_names[i]}')\n", + "\n", + "# Customize plot elements\n", + "ax.set_xlabel('Time Index')\n", + "ax.set_ylabel('Close (Price)')\n", + "ax.set_title('Time Series')\n", + "ax.legend()\n", + "\n", + "ax.grid(True)\n", + "fig.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ad93eb0-3c7e-4c05-9dbc-a469d025b355", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 123, + "id": "02ce660f-f77d-43a1-b7b9-c5f8257b723a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "0\n", + "[[0.5233 0.383067 0.8573 0.7105592]\n", + " [0.5235 0.383102 0.8574 0.7105005]\n", + " [0.5243 0.383687 0.8538 0.710517 ]\n", + " [0.5239 0.383284 0.8528 0.7100418]\n", + " [0.5238 0.382979 0.8526 0.7097535]\n", + " [0.5229 0.3827 0.8522 0.7088585]]\n", + "\n", + "\n", + "1\n", + "[[0.4988 0.367839 0.8013 0.693467 ]\n", + " [0.4988 0.367874 0.801 0.6934189]\n", + " [0.4988 0.367842 0.801 0.6933052]\n", + " [0.4988 0.367842 0.8013 0.6929601]\n", + " [0.4987 0.36782 0.8014 0.6931277]\n", + " [0.4989 0.367874 0.8014 0.6932936]]\n", + "\n", + "\n", + "2\n", + "[[0.5228 0.382313 0.8426 0.7126844]\n", + " [0.5227 0.382009 0.8424 0.7121888]\n", + " [0.5225 0.381963 0.842 0.7122303]\n", + " [0.5226 0.381978 0.8422 0.7124799]\n", + " [0.5224 0.381945 0.8419 0.7124184]\n", + " [0.5225 0.381966 0.8419 0.7123872]]\n", + "\n", + "\n", + "3\n", + "[[0.4931 0.368402 0.7943 0.6936869]\n", + " [0.4932 0.368171 0.7941 0.6934014]\n", + " [0.4973 0.369449 0.8 0.694914 ]\n", + " [0.4972 0.369305 0.7997 0.6946885]\n", + " [0.497 0.369176 0.7992 0.6945709]\n", + " [0.4965 0.368981 0.7983 0.6943933]]\n", + "\n", + "\n", + "4\n", + "[[0.4939 0.369107 0.798 0.6948025]\n", + " [0.494 0.369145 0.797 0.6947044]\n", + " [0.4938 0.368975 0.7969 0.6946416]\n", + " [0.4936 0.368882 0.7966 0.6946453]\n", + " [0.4937 0.368987 0.797 0.6948034]\n", + " [0.4937 0.36885 0.7966 0.6946897]]\n", + "\n", + "\n", + "5\n", + "[[0.4998 0.368504 0.8036 0.6940102]\n", + " [0.4987 0.368769 0.8021 0.6940389]\n", + " [0.5 0.368602 0.8042 0.6940193]\n", + " [0.4998 0.368501 0.8039 0.6938383]\n", + " [0.5 0.368537 0.804 0.6940189]\n", + " [0.5002 0.368528 0.8039 0.6939844]]\n" + ] + } + ], + "source": [ + "\n", + "for i in range(batch_valid-cnt_thrown_idx):\n", + " print ('\\n') \n", + " print (i)\n", + " print (X_valid[i])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44a7484f-0b64-4f51-9a19-4e48c0a0fcc9", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9615359e-a814-4b4f-a30f-b609d1e88988", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26ca9040-f391-4b54-bf6d-68e1f9f4334b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6dd4db36-823e-45a4-b831-65fe4b8b6798", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a68242e4-f581-4908-a65f-73fa72f84ce7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 109, + "id": "e1969a05-91ff-40df-a466-01edd42f1b40", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "0\n" + ] + }, + { + "ename": "ValueError", + "evalue": "All arrays must be of the same length", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[109], line 21\u001b[0m\n\u001b[1;32m 18\u001b[0m dates \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mrange\u001b[39m(sl\u001b[38;5;241m+\u001b[39mfrwd))\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# Create a pandas DataFrame\u001b[39;00m\n\u001b[0;32m---> 21\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mDataFrame\u001b[49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mDate\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdates\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mActuals\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mactual\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mForecasts\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mestimate\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 23\u001b[0m \u001b[38;5;66;03m# Set the 'Date' column as the index\u001b[39;00m\n\u001b[1;32m 24\u001b[0m data\u001b[38;5;241m.\u001b[39mset_index(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDate\u001b[39m\u001b[38;5;124m'\u001b[39m, inplace\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n", + "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/pandas/core/frame.py:778\u001b[0m, in \u001b[0;36mDataFrame.__init__\u001b[0;34m(self, data, index, columns, dtype, copy)\u001b[0m\n\u001b[1;32m 772\u001b[0m mgr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_init_mgr(\n\u001b[1;32m 773\u001b[0m data, axes\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mindex\u001b[39m\u001b[38;5;124m\"\u001b[39m: index, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcolumns\u001b[39m\u001b[38;5;124m\"\u001b[39m: columns}, dtype\u001b[38;5;241m=\u001b[39mdtype, copy\u001b[38;5;241m=\u001b[39mcopy\n\u001b[1;32m 774\u001b[0m )\n\u001b[1;32m 776\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(data, \u001b[38;5;28mdict\u001b[39m):\n\u001b[1;32m 777\u001b[0m \u001b[38;5;66;03m# GH#38939 de facto copy defaults to False only in non-dict cases\u001b[39;00m\n\u001b[0;32m--> 778\u001b[0m mgr \u001b[38;5;241m=\u001b[39m \u001b[43mdict_to_mgr\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtyp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmanager\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 779\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(data, ma\u001b[38;5;241m.\u001b[39mMaskedArray):\n\u001b[1;32m 780\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mma\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m mrecords\n", + "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/pandas/core/internals/construction.py:503\u001b[0m, in \u001b[0;36mdict_to_mgr\u001b[0;34m(data, index, columns, dtype, typ, copy)\u001b[0m\n\u001b[1;32m 499\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 500\u001b[0m \u001b[38;5;66;03m# dtype check to exclude e.g. range objects, scalars\u001b[39;00m\n\u001b[1;32m 501\u001b[0m arrays \u001b[38;5;241m=\u001b[39m [x\u001b[38;5;241m.\u001b[39mcopy() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(x, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdtype\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01melse\u001b[39;00m x \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m arrays]\n\u001b[0;32m--> 503\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43marrays_to_mgr\u001b[49m\u001b[43m(\u001b[49m\u001b[43marrays\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtyp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtyp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconsolidate\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/pandas/core/internals/construction.py:114\u001b[0m, in \u001b[0;36marrays_to_mgr\u001b[0;34m(arrays, columns, index, dtype, verify_integrity, typ, consolidate)\u001b[0m\n\u001b[1;32m 111\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m verify_integrity:\n\u001b[1;32m 112\u001b[0m \u001b[38;5;66;03m# figure out the index, if necessary\u001b[39;00m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m index \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 114\u001b[0m index \u001b[38;5;241m=\u001b[39m \u001b[43m_extract_index\u001b[49m\u001b[43m(\u001b[49m\u001b[43marrays\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 115\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 116\u001b[0m index \u001b[38;5;241m=\u001b[39m ensure_index(index)\n", + "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/pandas/core/internals/construction.py:677\u001b[0m, in \u001b[0;36m_extract_index\u001b[0;34m(data)\u001b[0m\n\u001b[1;32m 675\u001b[0m lengths \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mset\u001b[39m(raw_lengths))\n\u001b[1;32m 676\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(lengths) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 677\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAll arrays must be of the same length\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 679\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m have_dicts:\n\u001b[1;32m 680\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 681\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMixing dicts with non-Series may lead to ambiguous ordering.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 682\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: All arrays must be of the same length" + ] + } + ], + "source": [ + "for i in range(batch_valid-cnt_thrown_idx):\n", + " print ('\\n') \n", + " print (i)\n", + " X_resh = X_valid[i:i+1, :, 6].flatten()\n", + " # print (X_resh)\n", + " # print ('\\n')\n", + " y_resh = y_valid[i:i+1].flatten()\n", + " # print (y_resh)\n", + " y_est_resh = y_hat[i:i+1].flatten()\n", + " # print (y_est_resh)\n", + " # print ('\\n')\n", + " actual = np.concatenate((X_resh, y_resh)) \n", + " # print (actual)\n", + " # print ('\\n')\n", + " estimate = np.concatenate((X_resh, y_est_resh))\n", + " # print (estimate)\n", + "\n", + " dates = list(range(sl+frwd))\n", + " \n", + " # Create a pandas DataFrame\n", + " data = pd.DataFrame({'Date': dates, 'Actuals': actual, 'Forecasts': estimate})\n", + " \n", + " # Set the 'Date' column as the index\n", + " data.set_index('Date', inplace=True)\n", + " \n", + " # Create a figure and axis object using object-oriented style\n", + " fig, ax = plt.subplots(figsize = (10, 6))\n", + " \n", + " # Plot actuals vs. forecasts\n", + " ax.plot(data.index, data['Forecasts'], label = 'Forecasts', marker = 'x')\n", + " ax.plot(data.index, data['Actuals'], label = 'Actuals', marker = 'o')\n", + " \n", + " # Set labels and title\n", + " ax.set_xlabel('Date')\n", + " ax.set_ylabel('Value')\n", + " ax.set_title('Actuals vs. Forecasts')\n", + "\n", + " ax.legend() # Add legend\n", + "\n", + " ax.grid(True) # Add grid\n", + " \n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4acc8461-7c33-4b38-91c7-422f89d7d5b0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "75c0ee52-c740-434a-92bd-4f46f9ce290a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 255, + "id": "7a9e8c46-d24e-4ce9-b20a-232b4a86dab6", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " date close_xrp volume_xrp vwap_xrp close_eth volume_eth vwap_eth \\\n", + "0 1-0-0 0.5173 28809.165339 0.517217 0.376204 37.497964 0.376108 \n", + "\n", + " close_ltc volume_ltc vwap_ltc close_btc volume_btc vwap_btc Selected \n", + "0 0.8317 110.056253 0.831662 0.67506 2.045049 0.674969 0 \n" + ] + } + ], + "source": [ + "print (sample_test.head(1))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14eb03d2-1dbe-4834-908f-5a520a4a28c5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "598f83ca-cbb1-44f8-a1c6-7ce84f2243d7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "39259ac7-422b-48dc-aecd-2c9799ae3066", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'sample_test' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 5\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# variables are close and volume\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# ==============================\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# Test Sample --- 06.14.2024\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# ==============================\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m sample_size \u001b[38;5;241m=\u001b[39m \u001b[43msample_test\u001b[49m\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m (\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msample_size: \u001b[39m\u001b[38;5;124m'\u001b[39m, sample_size)\n\u001b[1;32m 8\u001b[0m sl \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m16\u001b[39m \u001b[38;5;66;03m# <--- sequence length\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'sample_test' is not defined" + ] + } + ], + "source": [ + "# variables are volume and volume\n", + "# ==============================\n", + "# Test Sample --- 06.14.2024\n", + "# ==============================\n", + "sample_size = sample_test.shape[0]\n", + "print ('sample_size: ', sample_size)\n", + "\n", + "sl = 16 # <--- sequence length\n", + "batch = 10 # <--- batch size\n", + "n_features = 8 # <---- no. of variables\n", + "n_out = 1 # <----- no. of predicted variables\n", + "frwd = 1 # <--- how many to predict\n", + "\n", + "\n", + "# Trimming Indices !!!\n", + "# Marking selected rows\n", + "sample_test['Selected'] = 0\n", + "\n", + "# Selecting m random rows without replacement\n", + "np.random.seed(125)\n", + "selected_indices = np.random.choice(sample_test.index, size = batch, replace = False)\n", + "\n", + "sample_test.loc[selected_indices, 'Selected'] = 1 # print (sample_test[sample_test['Selected'] == 1])\n", + "chosen_idx1 = sample_test[sample_test['Selected'] == 1].index\n", + "chosen_idx2 = chosen_idx1[chosen_idx1 > sl]\n", + "\n", + "thrown_idx1 = chosen_idx1[chosen_idx1 <= sl]\n", + "cnt_thrown_idx1 = len(thrown_idx1)\n", + "\n", + "chosen_idx3 = chosen_idx2[chosen_idx2 < (sample_size - frwd)]\n", + "\n", + "thrown_idx2 = chosen_idx2[chosen_idx2 >= (sample_size - frwd)]\n", + "cnt_thrown_idx2 = len(thrown_idx2)\n", + "\n", + "cnt_thrown_idx = cnt_thrown_idx1 + cnt_thrown_idx2\n", + "\n", + "print (selected_indices)\n", + "\n", + "# all_ts_xrp = np.empty((1, )) # final input/output\n", + "# all_ts_eth = np.empty((1, )) # final input/output\n", + "# all_ts_ltc = np.empty((1, )) # final input/output\n", + "# all_ts_btc = np.empty((1, )) # final input/output\n", + "\n", + "\n", + "all_ts_close_xrp = np.empty((1, )) # final input/output\n", + "all_ts_close_eth = np.empty((1, )) # final input/output\n", + "all_ts_close_ltc = np.empty((1, )) # final input/output\n", + "all_ts_close_btc = np.empty((1, )) # final input/output\n", + "\n", + "all_ts_volume_xrp = np.empty((1, )) # final input/output\n", + "all_ts_volume_eth = np.empty((1, )) # final input/output\n", + "all_ts_volume_ltc = np.empty((1, )) # final input/output\n", + "all_ts_volume_btc = np.empty((1, )) # final input/output\n", + "\n", + "stdev_xrp = np.empty((1, )) # final input/output\n", + "stdev_eth = np.empty((1, )) # final input/output\n", + "stdev_ltc = np.empty((1, )) # final input/output\n", + "stdev_btc = np.empty((1, )) # final input/output\n", + "\n", + "\n", + "aft_ts_xrp = np.empty((1))\n", + "aft_ts_eth = np.empty((1))\n", + "aft_ts_ltc = np.empty((1))\n", + "aft_ts_btc = np.empty((1))\n", + "\n", + "for idx in chosen_idx3:\n", + " selected_rows_before = sample_test.iloc[max(0, idx-sl): idx]\n", + " selected_rows_after = sample_test.iloc[max(0, idx): idx+frwd]\n", + "\n", + " # xrp\n", + " sr_before_close_xrp = np.array(selected_rows_before['close_xrp'])\n", + " sr_after_close_xrp = np.array(selected_rows_after['close_xrp']) \n", + " # print (sr_before_close_xrp)\n", + " sr_before_volume_xrp = np.array(selected_rows_before['volume_xrp'])\n", + " sr_after_volume_xrp = np.array(selected_rows_after['volume_xrp']) \n", + " # print (sr_before_volume_xrp) \n", + " # Compute standard deviation\n", + " std_dev_xrp = np.std(sr_before_close_xrp)\n", + " std_dev_xrp_arr = np.repeat(std_dev_xrp, sl)\n", + " # print(std_dev_xrp_arr)\n", + " \n", + "# eth\n", + " sr_before_close_eth = np.array(selected_rows_before['close_eth'])\n", + " sr_after_close_eth = np.array(selected_rows_after['close_eth'])\n", + " sr_before_volume_eth = np.array(selected_rows_before['volume_eth'])\n", + " sr_after_volume_eth = np.array(selected_rows_after['volume_eth'])\n", + " # Compute standard deviation\n", + " std_dev_eth = np.std(sr_before_close_eth)\n", + " std_dev_eth_arr = np.repeat(std_dev_eth, sl)\n", + " # print(std_dev_eth_arr)\n", + " \n", + "# ltc\n", + " sr_before_close_ltc = np.array(selected_rows_before['close_ltc'])\n", + " sr_after_close_ltc = np.array(selected_rows_after['close_ltc'])\n", + " sr_before_volume_ltc = np.array(selected_rows_before['volume_ltc'])\n", + " sr_after_volume_ltc = np.array(selected_rows_after['volume_ltc'])\n", + "# Compute standard deviation\n", + " std_dev_ltc = np.std(sr_before_close_ltc)\n", + " std_dev_ltc_arr = np.repeat(std_dev_ltc, sl)\n", + " # print(std_dev_ltc_arr)\n", + "\n", + "# btc\n", + " sr_before_close_btc = np.array(selected_rows_before['close_btc'])\n", + " sr_after_close_btc = np.array(selected_rows_after['close_btc'])\n", + " sr_before_volume_btc = np.array(selected_rows_before['volume_btc'])\n", + " sr_after_volume_btc = np.array(selected_rows_after['volume_btc'])\n", + " # Compute standard deviation\n", + " std_dev_btc = np.std(sr_before_close_btc)\n", + " std_dev_btc_arr = np.repeat(std_dev_btc, sl)\n", + " # print(std_dev_btc_arr)\n", + "\n", + "# xrp\n", + " all_ts_close_xrp = np.concatenate((all_ts_close_xrp, sr_before_close_xrp))\n", + " all_ts_volume_xrp = np.concatenate((all_ts_volume_xrp, sr_before_volume_xrp))\n", + " stdev_xrp = np.concatenate((stdev_xrp, std_dev_xrp_arr))\n", + "# eth\n", + " all_ts_close_eth = np.concatenate((all_ts_close_eth, sr_before_close_eth))\n", + " all_ts_volume_eth = np.concatenate((all_ts_volume_eth, sr_before_volume_eth))\n", + " stdev_eth = np.concatenate((stdev_eth, std_dev_eth_arr))\n", + "# ltc\n", + " all_ts_close_ltc = np.concatenate((all_ts_close_ltc, sr_before_close_ltc))\n", + " all_ts_volume_ltc = np.concatenate((all_ts_volume_ltc, sr_before_volume_tc))\n", + " stdev_ltc = np.concatenate((stdev_ltc, std_dev_ltc_arr))\n", + "# btc\n", + " all_ts_close_btc = np.concatenate((all_ts_close_btc, sr_before_close_btc))\n", + " all_ts_volume_btc = np.concatenate((all_ts_volume_btc, sr_before_volume_btc))\n", + " stdev_btc = np.concatenate((stdev_btc, std_dev_btc_arr))\n", + "\n", + "\n", + " aft_ts_close_xrp = np.concatenate((aft_ts_close_xrp, sr_after_close_xrp))\n", + " aft_ts_close_eth = np.concatenate((aft_ts_close_eth, sr_after_close_eth))\n", + " aft_ts_close_ltc = np.concatenate((aft_ts_close_ltc, sr_after_close_ltc))\n", + " aft_ts_close_btc = np.concatenate((aft_ts_close_btc, sr_after_close_btc))\n", + "\n", + "\n", + "X_XRP_close = all_ts_close_xrp[1:]\n", + "X_XRP_volume = all_ts_volume_xrp[1:]\n", + "X_XRP_stdev = stdev_xrp[1:]\n", + "\n", + "\n", + "X_ETH_close = all_ts_close_eth[1:]\n", + "X_ETH_volume = all_ts_volume_eth[1:]\n", + "X_ETH_stdev = stdev_eth[1:]\n", + "\n", + "X_LTC_close = all_ts_close_ltc[1:]\n", + "X_LTC_volume = all_ts_volume_ltc[1:]\n", + "X_LTC_stdev = stdev_ltc[1:]\n", + "\n", + "X_BTC_close = all_ts_close_btc[1:]\n", + "X_BTC_volume = all_ts_volume_btc[1:]\n", + "X_BTC_stdev = stdev_btc[1:]\n", + "\n", + "X0 = np.column_stack((X_XRP_close, X_XRP_volume, \n", + " X_ETH_close, X_ETH_volume, \n", + " X_LTC_close, X_LTC_volume, \n", + " X_BTC_close, X_BTC_volume))\n", + "print (X0)\n", + "\n", + "# ======== Model Input =========\n", + "X = X0.reshape(batch-cnt_thrown_idx, sl, n_features)\n", + "print ('XXXX ====== Actual Input ====== XXXX')\n", + "print (X.shape)\n", + "\n", + "y_XRP = aft_ts_xrp[1:]\n", + "y_ETH = aft_ts_eth[1:]\n", + "y_LTC = aft_ts_ltc[1:]\n", + "y_BTC = aft_ts_btc[1:]\n", + "\n", + "y = np.column_stack((y_XRP, y_ETH, y_LTC, y_BTC))\n", + "print (y)\n", + "\n", + "y = y_BTC.reshape(batch-cnt_thrown_idx, frwd, n_out)\n", + "# print ('YYYY ====== Actual Input ====== YYYY')\n", + "print (y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47d6927d-9021-4a56-9e52-ee2061bd5979", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0rc1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}