diff --git a/notebooks/Chronos.ipynb b/notebooks/Chronos.ipynb new file mode 100644 index 0000000..5a50c68 --- /dev/null +++ b/notebooks/Chronos.ipynb @@ -0,0 +1,641 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### fetching data from collab" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UKmLdWL4Sod6", + "outputId": "1758b18e-00ef-4627-9af2-6811c06df515" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mounted at /content/drive\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QadSOSa7jGjv" + }, + "source": [ + "\\" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prerequisite for chronos" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "4MjKEKx7S5-O", + "outputId": "5511fa50-5888-4fd3-875b-1a285592b5bc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/amazon-science/chronos-forecasting.git\n", + " Cloning https://github.com/amazon-science/chronos-forecasting.git to /tmp/pip-req-build-plq3_iz6\n", + " Running command git clone --filter=blob:none --quiet https://github.com/amazon-science/chronos-forecasting.git /tmp/pip-req-build-plq3_iz6\n", + " Resolved https://github.com/amazon-science/chronos-forecasting.git to commit afd9cfd062b60ca1ba8d7c9daef7dc820489db0a\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: torch~=2.0 in /usr/local/lib/python3.10/dist-packages (from chronos==1.2.0) (2.3.0+cu121)\n", + "Requirement already satisfied: transformers~=4.30 in /usr/local/lib/python3.10/dist-packages (from chronos==1.2.0) (4.41.2)\n", + "Collecting accelerate (from chronos==1.2.0)\n", + " Downloading accelerate-0.31.0-py3-none-any.whl (309 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m309.4/309.4 kB\u001b[0m \u001b[31m5.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch~=2.0->chronos==1.2.0) (3.15.3)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch~=2.0->chronos==1.2.0) (4.12.2)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch~=2.0->chronos==1.2.0) (1.12.1)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch~=2.0->chronos==1.2.0) (3.3)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch~=2.0->chronos==1.2.0) (3.1.4)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch~=2.0->chronos==1.2.0) (2023.6.0)\n", + "Collecting nvidia-cuda-nvrtc-cu12==12.1.105 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (23.7 MB)\n", + "Collecting nvidia-cuda-runtime-cu12==12.1.105 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_cuda_runtime_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (823 kB)\n", + "Collecting nvidia-cuda-cupti-cu12==12.1.105 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_cuda_cupti_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (14.1 MB)\n", + "Collecting nvidia-cudnn-cu12==8.9.2.26 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_cudnn_cu12-8.9.2.26-py3-none-manylinux1_x86_64.whl (731.7 MB)\n", + "Collecting nvidia-cublas-cu12==12.1.3.1 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl (410.6 MB)\n", + "Collecting nvidia-cufft-cu12==11.0.2.54 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_cufft_cu12-11.0.2.54-py3-none-manylinux1_x86_64.whl (121.6 MB)\n", + "Collecting nvidia-curand-cu12==10.3.2.106 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_curand_cu12-10.3.2.106-py3-none-manylinux1_x86_64.whl (56.5 MB)\n", + "Collecting nvidia-cusolver-cu12==11.4.5.107 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl (124.2 MB)\n", + "Collecting nvidia-cusparse-cu12==12.1.0.106 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl (196.0 MB)\n", + "Collecting nvidia-nccl-cu12==2.20.5 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_nccl_cu12-2.20.5-py3-none-manylinux2014_x86_64.whl (176.2 MB)\n", + "Collecting nvidia-nvtx-cu12==12.1.105 (from torch~=2.0->chronos==1.2.0)\n", + " Using cached nvidia_nvtx_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (99 kB)\n", + "Requirement already satisfied: triton==2.3.0 in /usr/local/lib/python3.10/dist-packages (from torch~=2.0->chronos==1.2.0) (2.3.0)\n", + "Collecting nvidia-nvjitlink-cu12 (from nvidia-cusolver-cu12==11.4.5.107->torch~=2.0->chronos==1.2.0)\n", + " Downloading nvidia_nvjitlink_cu12-12.5.40-py3-none-manylinux2014_x86_64.whl (21.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.3/21.3 MB\u001b[0m \u001b[31m57.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: huggingface-hub<1.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from transformers~=4.30->chronos==1.2.0) (0.23.4)\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from transformers~=4.30->chronos==1.2.0) (1.25.2)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from transformers~=4.30->chronos==1.2.0) (24.1)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from transformers~=4.30->chronos==1.2.0) (6.0.1)\n", + "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.10/dist-packages (from transformers~=4.30->chronos==1.2.0) (2024.5.15)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from transformers~=4.30->chronos==1.2.0) (2.31.0)\n", + "Requirement already satisfied: tokenizers<0.20,>=0.19 in /usr/local/lib/python3.10/dist-packages (from transformers~=4.30->chronos==1.2.0) (0.19.1)\n", + "Requirement already satisfied: safetensors>=0.4.1 in /usr/local/lib/python3.10/dist-packages (from transformers~=4.30->chronos==1.2.0) (0.4.3)\n", + "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.10/dist-packages (from transformers~=4.30->chronos==1.2.0) (4.66.4)\n", + "Requirement already satisfied: psutil in /usr/local/lib/python3.10/dist-packages (from accelerate->chronos==1.2.0) (5.9.5)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch~=2.0->chronos==1.2.0) (2.1.5)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->transformers~=4.30->chronos==1.2.0) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->transformers~=4.30->chronos==1.2.0) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->transformers~=4.30->chronos==1.2.0) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->transformers~=4.30->chronos==1.2.0) (2024.6.2)\n", + "Requirement already satisfied: mpmath<1.4.0,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->torch~=2.0->chronos==1.2.0) (1.3.0)\n", + "Building wheels for collected packages: chronos\n", + " Building wheel for chronos (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for chronos: filename=chronos-1.2.0-py3-none-any.whl size=13875 sha256=04ec5a3be32763d95d963d5e69d51f30b433b68bab8227602725b0ead4f10692\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-crkdc06c/wheels/bf/c1/65/08857e57345ef1b34ba0edb4791f1b2594943e82f34e93a4ab\n", + "Successfully built chronos\n", + "Installing collected packages: nvidia-nvtx-cu12, nvidia-nvjitlink-cu12, nvidia-nccl-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12, accelerate, chronos\n", + "Successfully installed accelerate-0.31.0 chronos-1.2.0 nvidia-cublas-cu12-12.1.3.1 nvidia-cuda-cupti-cu12-12.1.105 nvidia-cuda-nvrtc-cu12-12.1.105 nvidia-cuda-runtime-cu12-12.1.105 nvidia-cudnn-cu12-8.9.2.26 nvidia-cufft-cu12-11.0.2.54 nvidia-curand-cu12-10.3.2.106 nvidia-cusolver-cu12-11.4.5.107 nvidia-cusparse-cu12-12.1.0.106 nvidia-nccl-cu12-2.20.5 nvidia-nvjitlink-cu12-12.5.40 nvidia-nvtx-cu12-12.1.105\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/amazon-science/chronos-forecasting.git" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## sample script" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "u5VeXz_GS8f_" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import torch\n", + "from chronos import ChronosPipeline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def predict_and_plot_crypto_data(\n", + " coin_name,\n", + " crypto_data_dict,\n", + " model_name=\"amazon/chronos-t5-small\",\n", + " prediction_length=12,\n", + " num_samples=20):\n", + "\n", + " \"\"\"\n", + " Predicts and plots cryptocurrency data for multiple coins.\n", + "\n", + " Args:\n", + " crypto_data_dict: Dictionary containing data for each cryptocurrency.\n", + " Keys should be coin names (e.g., 'BTC', 'ETH'), values should be file paths to CSV data.\n", + " model_name: Name of the pre-trained Chronos model (default: \"amazon/chronos-t5-small\").\n", + " prediction_length: Number of future data points to predict (default: 12).\n", + " num_samples: Number of prediction samples to generate (default: 20).\n", + " \"\"\"\n", + "\n", + " # Check if coin exists in data\n", + " if coin_name not in crypto_data_dict:\n", + " raise ValueError(f\"Coin '{coin_name}' not found in data dictionary.\")\n", + "\n", + "\n", + " # Initialize Chronos pipeline once outside the loop for efficiency\n", + " pipeline = ChronosPipeline.from_pretrained(\n", + " model_name,\n", + " device_map=\"cpu\", # use \"cpu\" for CPU inference and \"mps\" for Apple Silicon\n", + " torch_dtype=torch.bfloat16,\n", + " )\n", + "\n", + " predictions = {} # Create an empty dictionary to store results\n", + "\n", + " for coin_name, csv_file in crypto_data_dict.items():\n", + " # Load data for the specific coin\n", + " csv_file = crypto_data_dict[coin_name]\n", + " df = pd.read_csv(csv_file)\n", + "\n", + "\n", + " # Perform prediction\n", + " forecast = pipeline.predict(\n", + " context=torch.tensor(df[\"Close\"]),\n", + " prediction_length=prediction_length,\n", + " num_samples=num_samples,\n", + " )\n", + "\n", + " # Generate forecast index for plotting\n", + " forecast_index = range(len(df), len(df) + prediction_length)\n", + " low, median, high = np.quantile(forecast[0].numpy(), [0.1, 0.5, 0.9], axis=0)\n", + "\n", + " predictions[coin_name] = { # Add results to the dictionary\n", + " \"median\": median,\n", + " \"low\": low,\n", + " \"high\": high\n", + " }\n", + "\n", + "\n", + " # Plot and visualize predictions (replace with your desired plotting logic)\n", + " plt.plot(df[\"Close\"], label=\"Actual\")\n", + " plt.plot(forecast_index, median, label=\"Median Prediction\")\n", + " plt.fill_between(forecast_index, low, high, alpha=0.2, label=\"Prediction Range\")\n", + " plt.title(f\"Predicted {coin_name} Prices\")\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + " return predictions # Return the dictionary containing predictions\n", + "\n", + "# Example usage\n", + "crypto_data = {\n", + " 'BTC' : \"/content/drive/MyDrive/backtesting/datas/yfinance/BTC-USD.csv\",\n", + " 'BNB' : \"/content/drive/MyDrive/backtesting/datas/yfinance/BNB-USD.csv\",\n", + " 'ETH' : \"/content/drive/MyDrive/backtesting/datas/yfinance/ETH-USD.csv\"\n", + "}\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "5cGwZYzWU7zi", + "outputId": "0e7fe47e-4a41-40f3-e76d-d9f08baa02df" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", + " warnings.warn(\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" + } + ], + "source": [ + "crypto_predictions = predict_and_plot_crypto_data(crypto_data)\n", + "\n", + "# Access predictions for a specific coin (e.g., 'BTC')\n", + "btc_predictions = crypto_predictions['BTC']\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zYabfxk4VySV" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "XYMOyAFYS6Kn", + "outputId": "26331447-1b91-442f-b86d-0b4463664c9c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coin: BTC, Median Prediction: [64722.04095661 64557.35399303 64557.35399303 64227.98006586\n", + " 64722.04095661 65216.10184736 64886.72792019 64227.98006586\n", + " 64886.72792019 64392.66702944 65380.78881095 65545.47577453]\n", + "Coin: BNB, Median Prediction: [594.73070968 593.43215119 593.43215119 594.73070968 594.73070968\n", + " 598.62632181 596.02924706 593.43215119 597.32778443 599.92485919\n", + " 593.43215119 592.1335927 ]\n", + "Coin: ETH, Median Prediction: [3514.24476617 3496.22272314 3460.17922314 3469.19009814 3433.14659814\n", + " 3496.22286966 3487.21184814 3442.15747314 3496.22286966 3424.13572314\n", + " 3487.21184814 3487.21199466]\n" + ] + } + ], + "source": [ + "# Print the median predicted values for all coins\n", + "for coin, prediction in crypto_predictions.items():\n", + " print(f\"Coin: {coin}, Median Prediction: {prediction['median']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "Zb-ikw6lU-Oz" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "8PkVm42VU-kw" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import torch\n", + "from chronos import ChronosPipeline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "# Define the crypto coins data source dictionary\n", + "crypto_data_dict = {\n", + " 'BTC': \"/content/drive/MyDrive/backtesting/datas/yfinance/BTC-USD.csv\",\n", + " 'BNB': \"/content/drive/MyDrive/backtesting/datas/yfinance/BNB-USD.csv\",\n", + " 'ETH': \"/content/drive/MyDrive/backtesting/datas/yfinance/ETH-USD.csv\"\n", + "}\n", + "\n", + "def predict_and_plot_crypto_data(\n", + " coin_name,\n", + " crypto_data_dict,\n", + " model_name=\"amazon/chronos-t5-small\",\n", + " prediction_length=12,\n", + " num_samples=20):\n", + " \"\"\"\n", + " Predicts and plots cryptocurrency data for a single coin.\n", + "\n", + " Args:\n", + " coin_name: Name of the cryptocurrency (e.g., 'BTC', 'ETH').\n", + " crypto_data_dict: Dictionary containing data for each cryptocurrency.\n", + " Keys should be coin names, values should be file paths to CSV data.\n", + " model_name: Name of the pre-trained Chronos model (default: \"amazon/chronos-t5-small\").\n", + " prediction_length: Number of future data points to predict (default: 12).\n", + " num_samples: Number of prediction samples to generate (default: 20).\n", + " \"\"\"\n", + "\n", + "\n", + "\n", + " # Check if coin exists in data\n", + " if coin_name not in crypto_data_dict:\n", + " raise ValueError(f\"Coin '{coin_name}' not found in data dictionary.\")\n", + "\n", + " # Load data for the specified coin\n", + " csv_file = crypto_data_dict[coin_name]\n", + " df = pd.read_csv(csv_file)\n", + "\n", + " # Initialize Chronos pipeline (can be inside or outside depending on preference)\n", + " pipeline = ChronosPipeline.from_pretrained(\n", + " model_name,\n", + " device_map=\"cpu\", # use \"cpu\" for CPU inference and \"mps\" for Apple Silicon\n", + " torch_dtype=torch.bfloat16,\n", + " )\n", + "\n", + " # Perform prediction\n", + " forecast = pipeline.predict(\n", + " context=torch.tensor(df[\"Close\"]),\n", + " prediction_length=prediction_length,\n", + " num_samples=num_samples,\n", + " )\n", + "\n", + " # Generate forecast index for plotting\n", + " forecast_index = range(len(df), len(df) + prediction_length)\n", + " low, median, high = np.quantile(forecast[0].numpy(), [0.1, 0.5, 0.9], axis=0)\n", + "\n", + " # Plot and visualize predictions (replace with your desired plotting logic)\n", + " plt.plot(df[\"Close\"], label=\"Actual\")\n", + " plt.plot(forecast_index, median, label=\"Median Prediction\")\n", + " plt.fill_between(forecast_index, low, high, alpha=0.2, label=\"Prediction Range\")\n", + " plt.title(f\"Predicted {coin_name} Prices\")\n", + " plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 507 + }, + "id": "1e-iWVnPYer1", + "outputId": "7c1a2d96-4749-46d7-87be-662ad63d8f00" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage (assuming crypto_data_dict is defined)\n", + "predict_and_plot_crypto_data('BTC', crypto_data_dict) # Call for Bitcoin" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xnGerO0HjwUY" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Final version" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "id": "E5sffSH1YZgP" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import torch\n", + "from chronos import ChronosPipeline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "# Define the crypto coins data source dictionary\n", + "crypto_data_dict = {\n", + " 'BTC': \"/content/drive/MyDrive/backtesting/datas/yfinance/BTC-USD.csv\",\n", + " 'BNB': \"/content/drive/MyDrive/backtesting/datas/yfinance/BNB-USD.csv\",\n", + " 'ETH': \"/content/drive/MyDrive/backtesting/datas/yfinance/ETH-USD.csv\"\n", + "}\n", + "\n", + "def predict_and_plot_crypto_data(\n", + " coin_name,\n", + " crypto_data_dict,\n", + " model_name=\"amazon/chronos-t5-small\",\n", + " prediction_length=12,\n", + " num_samples=20):\n", + " \"\"\"\n", + " Predicts and plots cryptocurrency data for a single coin.\n", + "\n", + " Args:\n", + " coin_name (str): Name of the cryptocurrency (e.g., 'BTC', 'ETH').\n", + " crypto_data_dict (dict): Dictionary containing data for each cryptocurrency.\n", + " Keys should be coin names, values should be file paths to CSV data.\n", + " model_name (str): Name of the pre-trained Chronos model (default: \"amazon/chronos-t5-small\").\n", + " prediction_length (int): Number of future data points to predict (default: 12).\n", + " num_samples (int): Number of prediction samples to generate (default: 20).\n", + "\n", + " Raises:\n", + " ValueError: If coin_name is not found in crypto_data_dict.\n", + "\n", + " Returns:\n", + " tuple: Tuple containing forecast index and median prediction array.\n", + " \"\"\"\n", + "\n", + " # Check if coin exists in data\n", + " if coin_name not in crypto_data_dict:\n", + " raise ValueError(f\"Coin '{coin_name}' not found in data dictionary.\")\n", + "\n", + " # Load data for the specified coin\n", + " csv_file = crypto_data_dict[coin_name]\n", + " df = pd.read_csv(csv_file)\n", + "\n", + " # Initialize Chronos pipeline\n", + " pipeline = ChronosPipeline.from_pretrained(\n", + " model_name,\n", + " device_map=\"cpu\", # use \"cpu\" for CPU inference and \"mps\" for Apple Silicon\n", + " torch_dtype=torch.bfloat16,\n", + " )\n", + "\n", + " # Perform prediction\n", + " forecast = pipeline.predict(\n", + " context=torch.tensor(df[\"Close\"]),\n", + " prediction_length=prediction_length,\n", + " num_samples=num_samples,\n", + " )\n", + "\n", + " # Generate forecast index for plotting\n", + " forecast_index = range(len(df), len(df) + prediction_length)\n", + " low, median, high = np.quantile(forecast[0].numpy(), [0.1, 0.5, 0.9], axis=0)\n", + "\n", + " # Plot and visualize predictions\n", + " plt.figure(figsize=(10, 6)) # Adjust figure size as needed\n", + " plt.plot(df[\"Close\"], label=\"History\")\n", + " plt.plot(forecast_index, median, label=\"Median Prediction\")\n", + " plt.fill_between(forecast_index, low, high, alpha=0.2, label=\"Prediction Range\")\n", + " plt.title(f\"Predicted {coin_name} Prices\")\n", + " plt.xlabel(\"Time\")\n", + " plt.ylabel(\"Price\")\n", + " plt.legend()\n", + " plt.grid(True) # Add gridlines\n", + " plt.show()\n", + "\n", + " return forecast_index, median # Optionally return forecast data for further use\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 775 + }, + "id": "Et66P-m6jyZG", + "outputId": "38021e65-60e2-474b-df91-bd5654aaccff" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2QAAAIjCAYAAABswtioAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADI7UlEQVR4nOzdd3hUZdoG8PtMn0lm0jshCYTeiwIWRKUooKjYRcBewMbaYFdXsLtiXRRdEaxr+VQWhQUCKyBNkCa99/ReJpNp5/tj5pzMpLeZZJL7d11ckpkz57zzZgznyfO8zyuIoiiCiIiIiIiI/E7R2gMgIiIiIiLqqBiQERERERERtRIGZERERERERK2EARkREREREVErYUBGRERERETUShiQERERERERtRIGZERERERERK2EARkREREREVErYUBGRERERETUShiQERFRm5CcnIzp06fLX69btw6CIGDdunWtNqaqqo6xo+no75+IyBcYkBEREZYsWQJBEOQ/Op0O3bt3x8yZM5GVldXaw2uUFStW4IUXXmjVMXjOpSAICAoKQu/evfHSSy/BbDYDqAw4G/JHcvz4cTzwwAPo0qULdDodTCYTLr74Yrz77rsoLy+vc0zTp0/3OqfJZMKAAQMwf/58VFRU+HQ+iIiodqrWHgAREbUd8+bNQ0pKCiwWCzZu3IgPP/wQK1aswL59+2AwGPw6lpEjR6K8vBwajaZRr1uxYgUWLFjQ6kHZmDFjMHXqVABAaWkpfvvtNzz33HPYs2cPvv/+e/Tq1QtffPGF12tmz56N4OBg/PWvf612vuXLl+Omm26CVqvF1KlT0bdvX1itVmzcuBFPPfUU9u/fj48//rjOMWm1WnzyyScAgMLCQvzwww948sknsX37dnzzzTf1vqfDhw9DoeDvcomIWhIDMiIikl199dUYOnQoAODee+9FREQE3nrrLfznP//BbbfdVuNrysrKEBQU1OJjUSgU0Ol0LX5ef+nevTumTJkif/3ggw/CarXixx9/hMViQUxMjNfzAPDaa68hMjKy2uMnT57ErbfeiqSkJPzvf/9DXFyc/NyMGTNw7NgxLF++vN4xqVQqr3M//PDDGDZsGL799lu89dZbiI+Pr/YaURRhsVig1+uh1Wob/P6JiKhh+GsuIiKq1RVXXAHAFRAArrK34OBgHD9+HOPHj4fRaMQdd9wBAHA6nXjnnXfQp08f6HQ6xMTE4IEHHkBBQYHXOUVRxEsvvYROnTrBYDDg8ssvx/79+6tdu7Y1ZL///jvGjx+PsLAwBAUFoX///nj33Xfl8S1YsAAAaiz5a+kxNlZsbCwEQYBK1bjfh77xxhsoLS3FokWLvIIxSWpqKh577LFGj0ehUGDUqFEAgFOnTgFwrRObOHEiVq1ahaFDh0Kv1+Ojjz6Sn6u6hqywsBBPPPEEkpOTodVq0alTJ0ydOhW5ubnyMRUVFfj73/+O1NRUaLVaJCYm4umnn65WKpmWloZLLrkEoaGhCA4ORo8ePTBnzpxGvy8iokDCDBkREdXq+PHjAICIiAj5MbvdjnHjxuGSSy7Bm2++KZcyPvDAA1iyZAnuuusuPProozh58iT++c9/YteuXdi0aRPUajUA4Pnnn8dLL72E8ePHY/z48di5cyfGjh0Lq9Va73jS0tIwceJExMXF4bHHHkNsbCwOHjyIX375BY899hgeeOABpKenIy0trVo5oL/GKLFYLHJQUlZWhk2bNuGzzz7D7bff3uiA7Oeff0aXLl1w0UUXNep1DVHT9/jw4cO47bbb8MADD+C+++5Djx49anxtaWkpLr30Uhw8eBB33303Bg8ejNzcXCxbtgznzp1DZGQknE4nrr32WmzcuBH3338/evXqhb179+Ltt9/GkSNHsHTpUgDA/v37MXHiRPTv3x/z5s2DVqvFsWPHsGnTphZ/z0REbYpIREQd3uLFi0UA4po1a8ScnBzx7Nmz4jfffCNGRESIer1ePHfunCiKojht2jQRgPjss896vf63334TAYhfffWV1+MrV670ejw7O1vUaDTihAkTRKfTKR83Z84cEYA4bdo0+bFff/1VBCD++uuvoiiKot1uF1NSUsSkpCSxoKDA6zqe55oxY4ZY0z9vvhhjbQDU+Oe6664TLRZLra/r06ePeNlll3k9VlRUJAIQJ02aVO916zJt2jQxKChIzMnJEXNycsRjx46Jr7zyiigIgti/f3/5uKSkJBGAuHLlymrnSEpK8nr/zz//vAhA/PHHH6sdK83dF198ISoUCvG3337zen7hwoUiAHHTpk2iKIri22+/LQIQc3JymvU+iYgCDUsWiYhINnr0aERFRSExMRG33norgoOD8dNPPyEhIcHruIceesjr6++//x4hISEYM2YMcnNz5T9DhgxBcHAwfv31VwDAmjVrYLVa8cgjj3iVEj7++OP1jm3Xrl04efIkHn/8cYSGhno953mu2vhjjJ4mTZqEtLQ0pKWl4T//+Q9mz56NlStX4vbbb4coig0+T3FxMQDAaDQ26vo1KSsrQ1RUFKKiopCamoo5c+ZgxIgR+Omnn7yOS0lJwbhx4+o93w8//IABAwbg+uuvr/acNHdSA5OePXt6zbtUDivNu/Q9/c9//gOn09mct0lEFFBYskhERLIFCxage/fuUKlUiImJQY8ePap11VOpVOjUqZPXY0ePHkVRURGio6NrPG92djYA4PTp0wCAbt26eT0fFRWFsLCwOscmldb17du34W/Iz2P01KlTJ4wePVr++tprr0VERASefPJJ/PLLL7jmmmsadB6TyQQAKCkpafC1a6PT6fDzzz8DcHVcTElJqfa9BFwBWUMcP34ckydPrvOYo0eP4uDBg4iKiqrxeWneb7nlFnzyySe499578eyzz+LKK6/EDTfcgBtvvJGdHYmoXWNARkREsgsvvFDuslgbrVZb7QbZ6XQiOjoaX331VY2vqe1m3J/awhivvPJKAMCGDRsaFZDFx8dj3759zb6+Uqn0ChJro9frm30tidPpRL9+/fDWW2/V+HxiYqJ8zQ0bNuDXX3/F8uXLsXLlSnz77be44oorsHr1aiiVyhYbExFRW8KAjIiImq1r165Ys2YNLr744jpv5pOSkgC4siZdunSRH8/JyanW6bCmawDAvn376gwqaitf9McY62O32wG4mmE0xsSJE/Hxxx9jy5YtGDFiRLPG0JK6du1ab6DYtWtX7NmzB1deeWW9paUKhQJXXnklrrzySrz11lt45ZVX8Ne//hW//vprgwJJIqJAxBoAIiJqtptvvhkOhwMvvvhitefsdjsKCwsBuNaoqdVqvP/++17rqN555516rzF48GCkpKTgnXfekc8n8TyXtCda1WP8Mcb6SOWCAwYMaNTrnn76aQQFBeHee+9FVlZWteePHz8ut/73p8mTJ2PPnj3V1qABld+Tm2++GefPn8e//vWvaseUl5ejrKwMAJCfn1/t+YEDBwJAtfb4RETtCTNkRETUbJdddhkeeOABvPrqq9i9ezfGjh0LtVqNo0eP4vvvv8e7776LG2+8EVFRUXjyySfx6quvYuLEiRg/fjx27dqF//73v4iMjKzzGgqFAh9++CGuueYaDBw4EHfddRfi4uJw6NAh7N+/H6tWrQIADBkyBADw6KOPYty4cVAqlbj11lv9MkZPR44cwZdffgkAMJvN2Lp1Kz777DOkpqbizjvvbNT8du3aFV9//TVuueUW9OrVC1OnTkXfvn1htVqxefNmfP/999X2B/OHp556Cv/3f/+Hm266CXfffTeGDBmC/Px8LFu2DAsXLsSAAQNw55134rvvvsODDz6IX3/9FRdffDEcDgcOHTqE7777Tt7vbN68ediwYQMmTJiApKQkZGdn44MPPkCnTp1wySWX+P29ERH5Tav2eCQiojZBanu/ffv2Oo+TWqfX5uOPPxaHDBki6vV60Wg0iv369ROffvppMT09XT7G4XCIc+fOFePi4kS9Xi+OGjVK3LdvX7WW6lXb3ks2btwojhkzRjQajWJQUJDYv39/8f3335eft9vt4iOPPCJGRUWJgiBUa4HfkmOsDaq0u1cqlWKnTp3E+++/X8zKyqr1dTW1vfd05MgR8b777hOTk5NFjUYjGo1G8eKLLxbff//9Otvpi2L93ztJUlKSOGHChFqfq/r+8/LyxJkzZ4oJCQmiRqMRO3XqJE6bNk3Mzc2Vj7FareLrr78u9unTR9RqtWJYWJg4ZMgQce7cuWJRUZEoiqK4du1acdKkSWJ8fLyo0WjE+Ph48bbbbhOPHDlS75iJiAKZIIqN6L1LRERERERELYZryIiIiIiIiFoJAzIiIiIiIqJWwoCMiIiIiIiolTAgIyIiIiIiaiUMyIiIiIiIiFoJAzIiIiIiIqJWwo2hW4jT6UR6ejqMRiMEQWjt4RARERERUSsRRRElJSWIj4+HQlF3DowBWQtJT09HYmJiaw+DiIiIiIjaiLNnz6JTp051HsOArIUYjUYArkk3mUytOhabzYbVq1dj7NixUKvVrTqW9opz7HucY9/jHPse59j3OMe+xzn2Pc6x7/l7jouLi5GYmCjHCHVhQNZCpDJFk8nUJgIyg8EAk8nE/6l9hHPse5xj3+Mc+x7n2Pc4x77HOfY9zrHvtdYcN2QpE5t6EBERERERtRIGZERERERERK2EARkREREREVEr4RoyPxJFEXa7HQ6Hw6fXsdlsUKlUsFgsPr9WR9Xe51ipVEKlUnELByIiIiIfY0DmJ1arFRkZGTCbzT6/liiKiI2NxdmzZ3lD7SMdYY4NBgPi4uKg0WhaeyhERERE7RYDMj9wOp04efIklEol4uPjodFofHoT73Q6UVpaiuDg4Ho3oqOmac9zLIoirFYrcnJycPLkSXTr1q3dvUciIiKitoIBmR9YrVY4nU4kJibCYDD4/HpOpxNWqxU6nY430j7S3udYr9dDrVbj9OnT8vskIiIiopbX/u4k27D2eONO7Rc/r0RERES+xzsuIiIiIiKiVsKAjIiIiIiIqJUwIKOAJQgCli5d2trDICIiIiJqMgZk1CBbtmyBUqnEhAkTGvW65ORkvPPOO74ZFBERERFRgGNARg2yaNEiPPLII9iwYQPS09NbezhERERERO0CA7JWIooizFa7z/6UWx01Pi6KYqPHWlpaim+//RYPPfQQJkyYgCVLlng9//PPP+OCCy6ATqdDZGQkrr/+egDAqFGjcPr0aTzxxBMQBEHee+2FF17AwIEDvc7xzjvvIDk5Wf56+/btGDNmDCIjIxESEoLLLrsMO3fubPTYiYiIiIjaMu5D1krKbQ70fn6V3697YN44GDSN+7Z/99136NmzJ3r06IEpU6bg8ccfx+zZsyEIApYvX47rr78ef/3rX/H555/DarVixYoVAIAff/wRAwYMwP3334/77ruvUdcsKSnBtGnT8P7770MURcyfPx/jx4/H0aNHYTQaG3UuIiIiIqK2igEZ1WvRokWYMmUKAOCqq65CUVER1q9fj1GjRuHll1/Grbfeirlz58rHDxgwAAAQHh4OpVIJo9GI2NjYRl3ziiuu8Pr6448/RmhoKNavX4+JEyc28x0REREREbUNDMhaiV6txIF543xybqfTiZLiEhhNxmqb++rVykad6/Dhw9i2bRt++uknAIBKpcItt9yCRYsWYdSoUdi9e3ejs18NkZWVhb/97W9Yt24dsrOz4XA4YDabcebMmRa/FhERERFRa2FA1koEQWh06WBDOZ1O2DVKGDSqagFZYy1atAh2ux3x8fHyY6IoQqvV4p///Cf0en2jz6lQKKqtZbPZbF5fT5s2DXl5eXj33XeRlJQErVaLESNGwGq1Nu2NEBERERG1QWzqQbWy2+34/PPPMX/+fOzevVv+s2fPHsTHx+Pf//43+vfvj7Vr19Z6Do1GA4fD4fVYVFQUMjMzvYKy3bt3ex2zadMmPProoxg/fjz69OkDrVaL3NzcFn1/RERERNR+2BzO1h5CkzBDRrX65ZdfUFBQgHvuuQchISFez02ePBmLFi3CP/7xD1x55ZXo2rUrbr31VtjtdqxYsQLPPPMMANc+ZBs2bMCtt94KrVaLyMhIjBo1Cjk5OXjjjTdw4403YuXKlfjvf/8Lk8kkn79bt2744osvMHToUBQXF+Opp55qUjaOiIiIiDoGq90JtTLw8k2BN2Lym0WLFmH06NHVgjHAFZD98ccfCA8Px/fff49ly5Zh4MCBuOKKK7Bt2zb5uHnz5uHUqVPo2rUroqKiAAC9evXCBx98gAULFmDAgAHYtm0bnnzyyWrXLigowODBg3HnnXfi0UcfRXR0tG/fMBERUQP9djQHt3y0BcdzSlt7KETkZrUzQ0btzM8//1zrcxdeeKFccti/f3/ccMMNNR43fPhw7Nmzp9rjDz74IB588EGvx+bMmSP/fdCgQdi+fbvX8zfeeKPX103ZU42IiKglfLX1DH4/mY9lu9PxxJjurT0cIgJgDdCSRWbIiIiIiBrpbIEZAHC+sLyVR0JEkkDNkDEgIyIiImqks/nugKyAARlRW1HBgIyIiIio/Ssqt6HYYgfADBlRWyGKYsB2WWRARkRERNQI59zligCQXlgOh5Nrmolam9XhRKC2F2BARkRERNQIZ/Mrs2J2p4jsEksrjoaIAMDmCNBoDAzIiIiIiBrFM0MGcB0ZUVsQqA09AAZkRERERA2SdiALB9KLca5KAMZ1ZEStL5ADMu5DRkRERFSP03lluO/zPxAZrEWfeBMAQKkQ4HCK1QI0IvK/QA7ImCEjIiIiqoeUBcstrcCmY7kAgL4JIV7PEVHrsTocrT2EJmNARq1u3bp1EAQBhYWFAIAlS5YgNDS0VcfU0qZPn47rrrtO/nrUqFF4/PHHm3XOljgHERE1THG5Tf673d1VcXiXcABcQ0bU2iw2B8qtzJBROzV9+nQIgoAHH3yw2nMzZsyAIAiYPn16i17zlltuwZEjR1r0nDWR3psgCNBoNEhNTcW8efNgt9t9fu0ff/wRL774YoOOrRqwNuUcRETUPEUeARkACAIwLMUdkAVYhuw8W/VTO5NTUtHaQ2gWBmRUr8TERHzzzTcoL6/8B8diseDrr79G586dW/x6er0e0dHRLX7emlx11VXIyMjA0aNH8Ze//AUvvPAC/vGPf9R4rNVqbbHrhoeHw2g0tvo5iIioYaoGZDFGHVIigwG4MmRigGyAtO1kPi5+7X94Ydn+1h4KUYuw2p3V/v8MNAzIWosoAtYy3/2xmWt+vAn/YAwePBiJiYn48ccf5cd+/PFHdO7cGYMGDfI61ul04tVXX0VKSgr0ej0GDBiA//u///M6ZsWKFejevTv0ej0uv/xynDp1yuv5qiWLx48fx6RJkxATE4Pg4GBccMEFWLNmjddrkpOT8corr+Duu++G0WhE586d8fHHH9f73rRaLWJjY5GUlISHHnoIo0ePxrJlywBUlhm+/PLLiI+PR48ePQAAZ8+exS233IKkpCRERkZi0qRJXu/B4XBg1qxZCA0NRUREBJ5++ulq/1BXLTesqKjAM888g8TERGi1WqSmpmLRokU4deoULr/8cgBAWFiYV0ay6jkKCgowdepUhIWFwWAw4Oqrr8bRo0erzeuqVavQq1cvBAcHywEpERHVreoNX6cwPeJCdACAcpsDBebAuCHce74IALA/vaiVR9L2Hcsuwav/PYiiAPnedjQ5JRU4k2dGemF5wG4ILWGXxdZiMwOvxPvk1AoAobU9OScd0AQ1+px33303Fi9ejDvuuAMA8Omnn+Kuu+7CunXrvI579dVX8eWXX2LhwoXo1q0bNmzYgClTpiAqKgqXXXYZzp49ixtuuAEzZszA/fffjz/++AN/+ctf6rx2aWkpxo8fj5dffhlarRaff/45rrnmGhw+fNgrQzd//ny8+OKLmDNnDv7v//4PDz30EC677DI5kGoIvV6PvLw8+eu1a9fCZDIhLS0NAGCz2TBu3DgMHz4cK1asQGhoKF555RVcddVV+PPPP6HRaDB//nwsWbIEn376KXr16oX58+fjp59+whVXXFHrdadOnYotW7bgvffew4ABA3Dy5Enk5uYiMTERP/zwAyZPnozDhw/DZDJBr9fXeI7p06fj6NGjWLZsGUwmE5555hmMHz8eBw4cgFqtBgCYzWa8+eab+OKLL6BQKDBlyhQ8+eST+Oqrrxo8R0REHZEUkF2QHIadZwpxabco6NRKRBm1yCmpwPmCcoQHafw2npO5Zfhm2xnce2kXRBm1DX5dbqmrtCu/rOWqPtqrD9edwA87zyEiSIP7R3Zt7eFQFRabI+AzYxIGZNQgU6ZMwezZs3H69GkAwKZNm/DNN994BWQVFRV45ZVXsGbNGowYMQIA0KVLF2zcuBEfffQRLrvsMnz44Yfo2rUr5s+fDwDo0aMH9u7di9dff73Waw8YMAADBgyQv37xxRfx008/YdmyZZg5c6b8+Pjx4/Hwww8DAJ555hm8/fbb+PXXXxsUkImiiLVr12LVqlV45JFH5MeDgoLwySefQKNx/SP75Zdfwul04l//+hdKSkpgMpmwePFihIaGYt26dRg7dizeeecdzJ49GzfccAMAYOHChVi1alWt1z5y5Ai+++47pKWlYfTo0fK8ScLDXWsUoqOja212IgVimzZtwkUXXQQA+Oqrr5CYmIilS5fipptuAuAKKBcuXIiuXV3/sMycORPz5s2rd36IiDq6onLX+uJxfWLx6fQLEKRx3ULFh+iQU1KBzGIL+iHEb+NZuO44vv3jLIK0Kjx6ZbcGvy7XvdYmjwFZvaSb/aNZpa08EqqJxRa4XRWrYkDWWtQGV7bKB5xOJ4pLSmAyGqFQVKlKVRuadM6oqChMmDABS5YsgSiKmDBhAiIjI72OOXbsGMxmM8aMGeP1uNVqlUsbDx48iGHDhnk9LwVvtSktLcULL7yA5cuXIyMjA3a7HeXl5Thz5ozXcf3795f/LggCYmNjkZ2dXee5f/nlFwQHB8Nms8HpdOL222/HCy+8ID/fr18/ORgDgD179uDYsWMICfH+R9diseD48eMoKipCRkaG13tUqVQYOnRoresLdu/eDaVSicsuu6zOsdbl4MGDUKlUXteNiIhAjx49cPDgQfkxg8EgB2MAEBcXV+8cERFR5c15iF4No04tPx5t0gEoQmaxxa/jOZ1f5vpvnrlRr5MyZCUWO6x2JzQqrl6pjXTDfzzHfwHZhqO5SAgPQs9Yk9+uGYhEUURFAO87VhUDstYiCE0qHWwQpxNQO1znrxqQNcPdd98tZ6QWLFhQ7fnSUtcPrOXLlyMhIcHrOa224eUUVT355JNIS0vDm2++idTUVOj1etx4443VmmxIZXkSQRDgdNb9P+vll1+ODz/8EBqNBvHx8VCpvP+XCAry/h6VlpZiyJAh+OKLL1BaWorg4GA56I2KimrS+6utBNEXapqjQFmITkTUmoo9AjJPsSbXOrJsPwdkUmfHcwWNDcgq/+0sMFsR4x4/VVcuB2RlEEURgiD49HqnSoC3P98Jo1aFNX+5jN+bOlgdzoBfN+aJvxahBrvqqqtgtVrldVRV9e7dG1qtFmfOnEFqaqrXn8TERABAr169sG3bNq/Xbd26tc7rbtq0CdOnT8f111+Pfv36ITY2tlojkKYKCgpCamoqOnfuXC0Yq8ngwYNx9OhRREdHo0uXLl7vMSQkBCEhIYiLi8Pvv/8uv8Zut2PHjh21nrNfv35wOp1Yv359jc9LGTpHHRse9urVC3a73eu6eXl5OHz4MHr37l3v+yIiorpJAZmpSkAWY3L9wjHLjwGZwykio9B1vXON3ANNypABQF4pyxbrUm51/btbVG7zS4nnpizXbXlJhR1zf2YXzKpEUZR/iWyxtZ/sGMCAjBpBqVTi4MGDOHDgAJRKZbXnjUYjnnzySTzxxBP47LPPcPz4cezcuRPvv/8+PvvsMwDAgw8+iKNHj+Kpp57C4cOH8fXXX2PJkiV1Xrdbt2748ccfsXv3buzZswe33357vZkvX7njjjsQGRmJ66+/Hps3b8bJkyexbt06PProozh37hwA4LHHHsNrr72GpUuX4tChQ3j44Yer7SHmKTk5GdOmTcPdd9+NpUuXyuf87rvvAABJSUkQBAG//PILcnJy5Eykp27dumHSpEm47777sHHjRuzZswdTpkxBQkICJk2a5JO5ICLqSIpqyZBFu7MYmcW+2wdp15kCrD2YJX+dXWKRN6fOLLbA7mjYv4miKHoFZGzsUTfPNUrHs31btlhcbsOuvMoM3Iq9mV7f846qtKJyb9jMYov8dYW9/awfAxiQUSOZTCaYTLXXNb/44ot47rnn8Oqrr6JXr1646qqrsHz5cqSkpAAAOnfujB9++AFLly7FgAEDsHDhQrzyyit1XvOtt95CWFgYLrroIlxzzTUYN24cBg8e3KLvq6EMBgM2bNiAxMRETJ06FX369ME999wDi8Uiz8tf/vIX3HnnnZg2bRpGjBgBo9GI66+/vs7zfvjhh7jxxhvx8MMPo2fPnrjvvvtQVuZaH5CQkIC5c+fi2WefRUxMjFcjE0+LFy/GkCFDMHHiRIwYMQKiKGLFihXVyhSJiKhxRFGsNSCL8XHJoiiKuPezP3Dv53/Ia5nOe2TFHE4RGUUNu3ZRuQ02R2WdV15ZBZxOEWarvY5XdVxmq0dAllPm02st+zMDNqeA7tHBuPcS1z3T17+fqedV7V92sQVn880oMtuQW2JFoXsLgop2liETRC4gaRHFxcUICQlBUVFRtYDFYrHg5MmTSElJgU7n+3pgp9OJ4uJimEym6k09qEV0hDn29+e2KpvNhhUrVmD8+PEMKn2Ec+x7nGPf88ccl1XY0efvrm65++eOQ5C2ssT9cGYJxr2zAWEGNXY9P7bFr51RVI4Rr/4PAPDSdX0xZXgS/rP7PB77Zrd8zNf3DcNFXSNrOUOlY9klGP3WBvnrv1/TG3vPF2HVvkz8NONidI8x1vi6jvo5HjB3tRyI33NJCp6b6LslAOPf3YADGSV4bkJP9IoLwe2f/I6UyCD8+uQon10zEBxIL4bDWRmqKBRA7zgTjueUotxaPShTKgT0jq85ceDvz3FdsUFV7fNOkoiIiKiFSDflKoUAg8a7ZF9aQ1ZgtvmkjOqYR6nc9lP5AKqvG2voOrKcEu8SxfwyKzYcyUGZ1YHPt5xq3kDboXLPkkUfdlqssDtwIKMEAHB1nxgkR7oaip3NNze4HLU9sjmcXsEY4OpbV2yxcw1ZS0pOToYgCNX+zJgxA4DrN/QzZsxAREQEgoODMXnyZGRledfTnjlzBhMmTIDBYEB0dDSeeuop2O3eqfd169Zh8ODB0Gq1SE1NrXHN0oIFC5CcnAydTodhw4ZVazxBREREHZNnuWLVTnsherXcOj7bB+vIPAOybSfzIYqi3GFR0tCAzHP9GACcyTfLXRf/szu9Xe3r1FwOpwirR1t1XwZkWUWu74taEBEZrEGsSQetSgG7U2x005b2pLbPY05JRbvqsAi0ckC2fft2ZGRkyH/S0tIAQN7E9oknnsDPP/+M77//HuvXr0d6erq82S7g6jo3YcIEWK1WbN68GZ999hmWLFmC559/Xj7m5MmTmDBhAi6//HLs3r0bjz/+OO69916vjXq//fZbzJo1C3//+9+xc+dODBgwAOPGjeP+TERERFTr+jHAve+lex2ZLzotegYCGUUWnCsol9eQJUW49hZtaOv7qgHZzjMF8t9LLHb8d19Gc4fbblQNBs4VlPssYJUC7DCt6/OkUAhIjnBlyU7m+XbtWltWWxas3Nr+fnHQqgFZVFQUYmNj5T+//PILunbtissuuwxFRUVYtGgR3nrrLVxxxRUYMmQIFi9ejM2bN8tt0levXo0DBw7gyy+/xMCBA3H11VfjxRdfxIIFC+Q9qhYuXIiUlBTMnz8fvXr1wsyZM3HjjTfi7bfflsfx1ltv4b777sNdd92F3r17Y+HChTAYDPj0009bZV6IiIio7SiqpeW9pLL1vW8zZIArSybdwA9LCQfQ+AxZZLBrvGfzvV/3zbazzRpre+JZrhiiV0MUfZclyyhyfR9CtZVpn+RIV7B9Krf9BWQNLe3tSBnbNrMxtNVqxZdffolZs2ZBEATs2LEDNpsNo0ePlo/p2bMnOnfujC1btmD48OHYsmUL+vXrh5iYGPmYcePG4aGHHsL+/fsxaNAgbNmyxesc0jGPP/64fN0dO3Zg9uzZ8vMKhQKjR4/Gli1bah1vRUUFKioqf/AWFxcDcC0YtNlsXsfabDaIogin0+mXdu1SnxbpmtTyOsIcO51OiKIIm81W4zYHvib9f1T1/ydqOZxj3+Mc+54/5rig1JX5MumUNV4nKti1X2R6YVmzxlFhd+KV/x7CnnNFyC+z4fkJPeV268NSwvD7yQJsPZGL8+6M2NDOofjuj3M4l29u0HWlTpDdo4O8smXDU8Kw9WQBfj+Zj4LScgRrvW8PO+LnuMTsmh+dWoEeMcHYdqoAf54tQPcoQ4tf66w7CxamqZzjpHA9AOBEdkm7m/e8kgpEGbX1Hme2VMDZ2DV0olDrfPn7c9yY67SZgGzp0qUoLCzE9OnTAQCZmZnQaDQIDQ31Oi4mJgaZmZnyMZ7BmPS89FxdxxQXF6O8vBwFBQVwOBw1HnPo0KFax/vqq69i7ty51R5fvXo1DAbv/1lVKhViY2NRWloqZ+78oaSkxG/X6qja8xxbrVaUl5djw4YN1dZl+pNUyky+wzn2Pc6x7/lyjremCwCUKM3PwYoVK6o9X5anAKDAlt0HEV3Q9A19DxYK+Ppg5S/AnvtxF3ItrjVrPVS5+B1KrNhzDuV212OlJ3cDUCGjqBw//7ICynrqng6ccI1Tbc6FZ5FUuD0XakEBmyjgp+WrEVFLY92O9DnOMAOACkrRgaCKPAAKrNi8F4bMPS1+rd+Pu74vYdrKOS7Ocn3mth86jRWKky1+zfbsRD3P++tzbDY3rJQYaEMB2aJFi3D11VcjPj6+tYfSILNnz8asWbPkr4uLi5GYmIixY8fW2Pb+7NmzCA4O9kv7cFEUUVJSAqPRWG3xMbWMjjDHFosFer0eI0eObLW292lpaRgzZkyHarPsT5xj3+Mc+54/5vjI2mPA6RPo2bUzxo+v3vo8feMprM84guDIBIwf36/J16nYlQ4c3IeesUYczylFrntJWoxJi1m3XIyV725CdokrcxMVrMGU68fg9b1rUWF3YuDFo5AYVnf25pMzW4GCYowd1hfr/3NAfnz08IHYsfIIskoqMGjYJeib4H0f0xE/x3+eKwL2/I6QID2uuaQbfv1+L4rVYRg/fliLX+uHz3cA2XkI04ryHEeeysc3J/5AmSII48df2uLX9LfichtMejVEUcShzBKkRARBp6m9+qbC5mjS3m8KhYCesbVv3+DPz7FUPdcQbSIgO336NNasWYMff/xRfiw2NhZWqxWFhYVeWbKsrCzExsbKx1Tthih1YfQ8pmpnxqysLJhMJuj1eiiVSiiVyhqPkc5RE61WC622erpVrVZX+yY7HA73Ik2FX/askkropGtSy+sIc6xQKCAIQo2faX9q7et3BJxj3+Mc+54v57i0wrWWJSxIW+M14t2BUE6ptVljKHZfp3uMEanRwfjlT1eTjW7RRoQG6/Hx1KG4+aMtsNqdSAgzQKPRICFUjxO5ZcgqsaNLdN3XznN3VOwZHwJBgNyprmu0CWFBGmSVVKDU5qz1PXSkz7FNdP2yVa9RYlBSBADgYGYJoFBCXV8qspEy3WsPQzWVc9wtJgSAq+GHKCjhFEVMX7wNVrsTL1zbB/07hbboGHzJaneiwFKBCJMa5VYHBIUKToWyzs+S2QYolI0PU5QKod7PqL8+x425Rpu4k1y8eDGio6MxYcIE+bEhQ4ZArVZj7dq18mOHDx/GmTNnMGLECADAiBEjsHfvXq9uiGlpaTCZTOjdu7d8jOc5pGOkc2g0GgwZMsTrGKfTibVr18rHEBERUcdVV5dFAIg2tkyXxQKzK2AKM6hxywWJ8uNdo1wd9wYmhuLNmwZAo1RgZDfXRtBG95hKK+ouLRdFUW5xH2PSIdTjvSRHBMnvrcDcvtYrNZXU1EOvUSIp3ACjTgWr3YmjWS3b2EMURblrZphHU48ooxZBGiWcInC2wIwP1x3H1hP52HmmENd/sBk/7DjXouPwJbPVjnKrA1a7E2ar63Na3/5q5R2ooQfQBjJkTqcTixcvxrRp06BSVQ4nJCQE99xzD2bNmoXw8HCYTCY88sgjGDFiBIYPHw4AGDt2LHr37o0777wTb7zxBjIzM/G3v/0NM2bMkLNXDz74IP75z3/i6aefxt13343//e9/+O6777B8+XL5WrNmzcK0adMwdOhQXHjhhXjnnXdQVlaGu+66y+fvf++5ohY/p1N0oqysDEElIhRCZczdr1NIi1+rJU2fPh2FhYVYunQpAGDUqFEYOHAg3nnnnSafsyXOQUREHVt9AVlll8XmBmSu64QaNLi4ayQSQvU4X1iO1Ohg+ZhrB8RjTK8Y6N3lXsFa13+lG93aFFvssLpvgiODtQgP0qDAbEOoQY0QgxqhBtd7KzL7b617W2Zxt1bXq5VQKAT0jQ/BlhN52Hu+EL3jTTW+xu5wYt4vB9A3PgQ3ewTUdSm22FHmvlaYpvJxQRCQFBGEAxnFWLkvEx+uPw4AGNApBHvOFeGjDccxeUinZrxD33A4RSgV3ks5pPdXWG5FhbuVvc1R90ZiHanDItAGMmRr1qzBmTNncPfdd1d77u2338bEiRMxefJkjBw5ErGxsV5ljUqlEr/88guUSiVGjBiBKVOmYOrUqZg3b558TEpKCpYvX460tDQMGDAA8+fPxyeffIJx48bJx9xyyy1488038fzzz2PgwIHYvXs3Vq5cWa3RR0c0ffp0ecNujUaD1NRUzJs3zy9NHn788Ue8+OKLDTp23bp1EAQBhYWFTT5HU506dcprY/Pw8HBcdtll+O2333x6XSIi8o/6ArJId8e4MqujWTeShe5gKDxIA4VCwCs39MM1A+IxaVCC13F6j7U3Bo3rl9n1ZcgOZbjWs5h0KujUSkQEucYs7XcVqte4x8AMGVCZodGpXXPd3/1L7T+r/CJ955kCvLHyECrsDmw6nofPt5zG3J/3w+ls2M7F6dIeZAY1qi6pSnFnRv+x6jCsdicuTo3AGzcOAODaHLktqrA7YKuS/TK7P5tFZhvM7uDM85iasmXMkPnZ2LFj5RbiVel0OixYsAALFiyo9fVJSUk1djzyNGrUKOzatavOY2bOnImZM2fWP+AO6KqrrsLixYtRUVGBFStWYMaMGVCr1V5bBUisVis0Gk0NZ2m88PDwNnGOhlqzZg369OmD3NxcvPzyy5g4cSKOHDnCwJ6IKMDVtw9ZkKbydqqswi7fxDdWfpkrIJOyVZd1j8Jl3aPqfE2Q+y7eXFH3DexnW04BAK7uGwfAFfQBQLJ7c+nQINc1C8sZkAEeJYvu72XfBFdAtu+8d0A258e9OJRZgoQwPTKLXBnSMqsDZ/LNSI4Mqvc6UkAWF6ID4L0v3D2XpCC9sByHMkqgVgqYe21fRLi/bwVmG6x2JzSqVs+teLE5RDhFp7zOzuEU5Q2ePTd6tnoEYZnFFnTyaEhjczhhryeD1t60re8itUlarRaxsbFISkrCQw89hNGjR2PZsmUAXBm06667Di+//DLi4+PRo0cPAMDZs2dx8803IzQ0FOHh4Zg0aRJOnToln9PhcGDWrFkIDQ1FREQEnn766WqB+ahRo+T94gDX3m/PPPMMEhMTodVqkZqaikWLFuHUqVO4/PLLAQBhYWEQBEHePqHqOQoKCjB16lSEhYXBYDDg6quvxtGjR+XnlyxZgtDQUKxatQq9evVCcHAwrrrqKmRkZNQ7TxEREYiNjUXfvn0xZ84cFBcX4/fff5ef/+KLLzB06FAYjUbExsbi9ttv91r/KGX51q5di6FDh8JgMOCiiy7C4cOHva7z0ksvITo6GkajEffeey+effZZDBw40OuYTz75BL169YJOp0PPnj3xwQcf1Dt+IiKqWVG56zf8tWXIlApBvnEvqycwqouUnQozNPwXm0HuPcPK6ihZPFdgxsp9ru2A7r4kBQAQH+ra56pbjKsjnZQhK2DJIgCg3Fq5hgwA+rkDsoMZJXJ2J7PIgkOZru1vNhzJwfZT+fLrD2Q0rMNeujuIiw+p3s14cOcw/PTwxdg3dxx2PjcGqdHBCNGroVa6SgLzytpelswVgFX+P1BbKa00h3aHEwVlNq/NojtauSLAgIyaQK/Xe+2ntnbtWhw+fBhpaWn45ZdfYLPZMG7cOBiNRvz222/YtGmTHNhIr5s/fz6WLFmCTz/9FBs3bkR+fj5++umnOq87depU/Pvf/8Z7772HgwcP4qOPPkJwcDASExPxww8/AHA1fsnIyMC7775b4zmmT5+OP/74A8uWLcOWLVsgiiLGjx/vtXmf2WzGm2++iS+++AIbNmzAmTNn8OSTTzZ4fsrLy/H5558DgFe20Gaz4cUXX8SePXuwdOlSnDp1Sg4cPf31r3/F/Pnz8ccff0ClUnmV83711Vd4+eWX8frrr2PHjh3o3LkzPvzwQ6/Xf/XVV3j++efx8ssv4+DBg3jllVfw3HPP4bPPPmvweyAiIpdCs1UOUqSsUk0aEhjVp7KpRxMCsjpKFj/bfApOEbgkNRI93C3BHxzVBX+/pjemDE8CAI81ZMyQAR4BmTvQ7hxugEGjhNXhxGn3Rs4bjubIx28+lofdZwvlrw82NCCTMmTuALkmSoUAlTvjpFAIiAx2lZu2xbJFu8OJCntl9ksqUax+nOuX8PL6Mo/PXUcrVwTaQMkiBQ5RFLF27VqsWrUKjzzyiPx4UFAQPvnkEzn4+PLLL+F0OvHJJ5/Ie3QtXrwYoaGhWLduHcaOHYt33nkHs2fPxg033AAAWLhwIVatWlXrtY8cOYLvvvsOaWlpGD16NACgS5cu8vNSaWJ0dHS1zcQlR48exbJly7Bp0yZcdNFFAFzBS2JiIpYuXYqbbroJgCtwWrhwIbp27QrAVc7quS6xNhdddBEUCgXMZjNEUcSQIUNw5ZVXys97BlZdunTBe++9hwsuuAClpaUIDq5csP3yyy/jsssuAwA8++yzmDBhAiwWC3Q6Hd5//33cc889csOZ559/HqtXr0ZpaWXXp7///e+YP3++PLcpKSk4cOAAPvroI0ybNq3e90FERJV+2nUeDqeIXnEmxJpq35MxSKtEbmndgVFdRFGUm3qEBTW8XbbBncEpq+XGVxRF/LDzPADg7kuS5cejjTrcdXGK/HWYgSWLnjy7LAKuQKhbjBF7zhbicGYpUqON+O1ornx8SZXv+4H0RgZkIVqggdtWRRm1yCiytMmAzFYlQ1Ziqfn/B1F0tcOXAt8CsxXRRi0EQZAbf3QkzJBRvX755Rd5U+urr74at9xyC1544QX5+X79+nllgvbs2YNjx47BaDQiODgYwcHBCA8Ph8ViwfHjx1FUVISMjAwMG1a5uaJKpcLQoUNrHcPu3buhVCrlQKUpDh48CJVK5XXdiIgI9OjRAwcPHpQfMxgMcjAGAHFxcV6lhbX59ttvsWvXLvzwww9ITU3FkiVLvPag2LFjB6655hp07twZRqNRfi9nzpzxOk///v29rg1Avv7hw4dx4YUXeh3v+XVZWRmOHz+Oe+65R5774OBgvPTSSzh+/Hi974GIiCqJoohvtp0FANx2YaL8S8aaBDWwuUZtzO624EDjMmTB7gyZuZbrnisoR36ZFWqlgEtSa1+PFiI39WDJIlB9DRkA9Ihx/fL0cFYJHE4RG90ZssTwyuyWlL1qaMniqTwzACAhpPYMWVVRbTxDJgVkdkdlwFXjsU6nnFG22UVkuruUMkNGVIPLL78cH374ITQaDeLj4722JwBcGTJPpaWlGDJkCL766qtq54qKqntxcm30+ob/oGquqhv5CYJQa+MZT4mJiejWrRu6desGu92O66+/Hvv27YNWq0VZWRnGjRuHcePG4auvvkJUVBTOnDmDcePGeZV/Vr2+9I+/tBF1faRM2b/+9S+vwBNwdSUlIqKG23W2EIezSqBVKTBpYEKdxwbLpYNNu5mUyhU1SoWc9WqIyi6L3tcVRRGCIGB/uqsJRfcYY50NIKSSRXZZdLHUEJB1d6+3O5JZgn3ni1BgtsGoVeGBkV3xt6X7AAC3XpCIf/56DBlFFhSUWRFWR5mr3eGUu1/2ijPi4NmGjS3K2HYDMptDhNPpWiNWX7bYM0MGALklVjicIjNkRDUJCgpCamoqOnfuXC0Yq8ngwYNx9OhRREdHIzU11etPSEgIQkJCEBcX59Xwwm63Y8eOHbWes1+/fnA6nVi/fn2Nz0sZOoej9n8Ie/XqBbvd7nXdvLw8HD58WN5IvKXceOONUKlUcjONQ4cOIS8vD6+99houvfRS9OzZs0FZt6p69OiB7du3ez3m+XVMTAzi4+Nx4sSJanOfkpJS9XRERFQLh1PEB78eAwBM6BdXa0MPSZBWaurhugltaNtzSaG8B5m6zkxcbdf1bJ6w+Xguejy3Ej/sOIf97tK5PrXsnSWRsnKF5bYG/RKyvava1AOAvP7uSHYJ1h12ZccuSo3A5T2j5WNG9YhC53BXx8D61pEdzylDhd2JIPfm0w0lB2SlbS8gs7t/gVxhd9ZarigpLrej6ketoKxj/kKAARm1uDvuuAORkZGYNGkSfvvtN5w8eRLr1q3Do48+inPnXDvLP/bYY3jttdewdOlSHDp0CA8//HC1PcQ8JScnY9q0abj77ruxdOlS+ZzfffcdANf2B4Ig4JdffkFOTo7XmipJt27dMGnSJNx3333YuHEj9uzZgylTpiAhIQGTJk1q0TkQBAGPPvooXnvtNZjNZnTu3BkajQbvv/8+Tpw4gWXLljVpf7RHHnkEixYtwmeffYajR4/ipZdewp9//un1j/fcuXPx6quv4r333sORI0ewd+9eLF68GG+99VZLvkUiooCWXliOxZtO1vhbfJvDice/3Y01B7OhVAiYfnFyvefzbOrxv0NZ6PP3Vfhp17kGj6chjUNqvK5Gum7lLyTXH8mB1e7Eoo0n5YBMatteGylD5nCKTS67bE+q7kMGAD3cGbJTuWX4z27Xurwre8UgIVSPKcM7Y1yfGAxIDEXvOFfwK5UtfrH1NB75965q3QOl7GXveBMUioYH4W05QyY167DYHPV+jootHTP4qglLFltZv051/4BsCqfTieJiASaTCQqF/2Nug8GADRs24JlnnsENN9yAkpISJCQk4Morr4TJ5Poh9Ze//AUZGRmYNm0aFAoF7r77blx//fUoKiqq9bwffvgh5syZg4cffhh5eXno3Lkz5syZAwBISEjA3Llz8eyzz+Kuu+7C1KlTsWTJkmrnWLx4MR577DFMnDgRVqsVI0eOxIoVK6qVKbaEadOm4a9//Sv++c9/4umnn8aSJUswZ84cvPfeexg8eDDefPNNXHvttY065x133IETJ07gySefhMViwc0334zp06dj27Zt8jH33nsvDAYD/vGPf+Cpp55CUFAQ+vXr59X+n4ioo3v/f8fw721noFEpcMewJK/nvtp6Gj/vSYdaKeD92wahf6fQes8nB0YVdmw+lodymwM/7jyP6wd1atB4qu5B1lAGKUPmcfObX+o614GMYpzJd61Rqi9DplMroVUpUGF3otBsg1HX8v8uBpJyd9mcZ8lilFGLUIMahWYbTuSWQaNUYFyfWADAS9f1k4/rHW/Cyv2Z2He+CDaHE6+tOIgyqwPj+8bi6n5x8nH7zkvZy8bdC3quIdt8PBc/7TyPF67tI/9SoLXYHU4541VottW7lxgTsZUYkFGdagpqGvJ8bGxsnW3WVSoV3nnnHbzzzju1HrNu3Tqvr3U6Hd56661aMz3PPfccnnvuuTrPERYWJrekr8n06dOrtaK/7rrr6izfSE5OrvF5g8GA/PzKPUluu+023HbbbV7HeL5u1KhR1c4zcODAao9VfZ9jxoxBamqq1zG33347br/99lrHTETU0eW5y73ySqs3sdjlbl/+8KhUXNU3rtrzNZFuhksrHPJG0jtOF8DmqNwkty5N2YMM8A4EJZ57iZVW2CEIQK+4ugMy6dqZxRYUmm1IDG/UMNodSw0li4IgoHuMEdtOuv5tv6xHVI2lrEOTwgAAG4/lYc/ZQjl7uf1UgXdA5s6Q1Ze9rMqzZPGVFQex73wxhiSF4dYLOzfqPC3N7lGmW1czD6qOARlRADGbzVi4cCHGjRsHpVKJf//731izZg3S0tJae2hERAFFKkmraZ+kk7mufaZ615NV8hTssYZMCsjMVgf2pxdjYGJova+XgqjQxgZk2uoli3ll3kFml8gguflHXUINaldAVs5Oi2abK8D1zJABrrJFKSC7ZkB8ja8dmhwOg0aJ3NIK/Ou3E/Ljf5yu/CWt0ynKrfH7JjT8cwZUBmQZRRacK3AFQSfde6O1Jnsj101SJa4hIwoggiBgxYoVGDlyJIYMGYKff/4ZP/zwg7w3GxERNYxFDsi817mIooiTOa6b2y6RQdVeVxvPDZqLPPby+v1EHgBXR7k7PtmKN1YeqvH1UoYsvBF7kLmuW72pR36VgKyhJXFStoedFmtu6gEA3d2NPXRqBa70aObhSaNS4KKukQCAVfuz5Mf3pxfLmcwz+WaUVtihVSmQGhVc43lqI7XWt9qdcLiDoDPu9vmtye7oeN0RWwoDMqIAotfrsWbNGuTl5aGsrAw7d+6UN4AmIqKGqy1DllNagRJ3mV/niIZ3vqssWfQOyKRsytHsEmw6lofPt5yu8fVSENXYkkUp82VziKiwu96LtIZMap9f3/oxidxpkXuRwVLDGjIAuKJnNGJNOtxzSUqda7ZG9fDe5segUcLhFLH7bCEKyqxYticdANAzzgRVA0paPQVpVQiqEiiebuGArKgJG4Tb6lkzRrVjySIRERF1OFIgVjVDJmXHOoXpoVU1fD8weYNmqwPFngHZqXw4nKJ8g19aYYfF5vDq3gc0o2TR48bcXOGAAAEl7izM3Gv7YPneDEwe0rDGItyLrJK8MXSVwCchVI+tc66s9/WeAVmsSYcLU8KxbE86/vm/Y9h5pgAV7k3A+zdy/ZgkyqhFmUcQdjqvTN57riUUl9ugVyvr3LuuKnsD90yl6pgh8yPu60GBhJ9XImrPpKYNVTdyltaPpUQ2roxMykZVzZCVWOw4lFmMCo+W51VLCoGmlyyqlApo3TfNZVa7HNgpFQImD+6EJXddKJe41SdECsiakB1pb+SSRXXDg3JPncIMSI12fYYuSo3ABSmuLilbTuShwu5ESmQQbrswEQ+N6tqk80vryCRlVke1tYPNUd6AtvVV1ddVkWrHgMwPpJbqZnPr1/cSNZT0efXFlgBERK1NyoBU7QYnBWSNWT8GVGbIisttcoONnu71RkezSmGx1x2QNTVDBniuX3PIXSPDDOpG7W0FAKF6qWSxYwdkoijWuA9ZY905PAkqhYCbhiTiguQw+fGr+sQi7YmRePWG/ogP1Tfp3FJAplUpEO3+++kWauzhdIqosDlRWs/GzlXZuIasyViy6AdKpRKhoaHIzs4G4GqH3lIp5Zo4nU5YrVZYLJZW2YesI2jPcyyKIsxmM7KzsxEaGgqlsun/GBERtVXSDXdZlZLFE1JAFtW4gEwKitKLyuXH4kP1OJRZgnKbQ85iAUBuafUNfQuauIYMcGXn8stc78Xszvg1doNp17WlksWOvYZMKicEqpcsNsa0i5Ix7aJkAK5/W28ZmghBAOZO6tPodWNVSXuR9e8UApVCgeySCpzOM2NIUvP3K5B+edDoDBm7LDYZAzI/iY11bRwoBWW+JIoiysvLodfrfRr4dWQdYY5DQ0Plzy0RUXvi9FjTVVuGLKWRGTIpIJPOa9Sq5DLGcqsDOnXlDXjVvc+sdqecVQtr5MbQgMf6tQoH8t3BVFMCslCWLALw/kw0tWSxKkEQ8PqN/VvkXADQx7327IqeMTidV4YtJ/JarLGH9P4dThHlVkeDglKnU4TVzgxZUzEg8xNBEBAXF4fo6GjYbL79QWez2bBhwwaMHDmS5WY+0t7nWK1WMzNGRO2WZwbEM0Nmdzjlsq/GBmTBVTrumfRqudzNYnfAYqv8mVq1ZFHa90sQAJOu8f+meK5fy3dn35oSkIXoO26XxX3ni1BgtuKS1EiY3dlTjUoBZSPLPv3lpiGdcGFyOBLDDfh4g2uvs5YqWbR4/P9RWmFvUEBWZrWDS8+bjgGZnymVSp/f6CqVStjtduh0unYZLLQFnGMiosBV7tFgw+zR1ON8YTlsDhEalQLxIY1b22PQev/bHqJXy9kVi83p1dQjt8y7ZLG43BUUGrWqRq/7Aiqzc2arXQ72mhKQmfSu85Q0cu1QoHM6RUxZ9DsKzTYM6hyKuy9OAdBy2TFfEAQBye5fGiS5t2c4nd+yGTKg4evCqjbHocZpX4tfiIiIiOrhFZDZHHJX2WPZpQCA5AhDowOjII3377hD9Gq5TNFic3hlHaqWLEpdGUOaUK7oeW3PTnvhQQ3rrOhJys4VW5pXyVNWYcfHG44ju9jSrPP4S16ZVW5ksutMIR759y4AbTsg89Q53BWQtdTm0BaP/z/q6pzo8FgzVlrRsctcm4sBGREREXUo5R5lig6nKJcwbj9VAAAY0Cm00edUKgSvG/gQz5JFm8PrJrdqyaIUADWlXBGozM6VVVS2vY9oSobMfX2Lzdms9UDfbj+LV1YcwuPf7m7yOfwpw92IJTxI47WvW3MaeviTlCHLK7M2O5i22BxepYfWWjJkoijiZG4p7A6n1z571DQMyIiIiKhDKbc6q3ztCpa2nsgDAAzvEtGk8wZ5rCOrHpB5Zsiqliza5Nc06boaqamHvbLtfRMCsmBd5fhLmnFjf8q9lmnz8TzsOlPQ5PP4S3qhK5OXGG7AqB7R8uPNaXnvT0adGrEmHQBg77ki+fHtp/Ix9dNtSDuQ1eBzVW1yU9tmz7mlVpRbncgqqUBpBdePNRcDMiIiIupQPEsWAVdDgtIKO/aed93MDuvStNbhwR7ryEIMlQFZuc2JCo99yKpu4CsFZE3NkMn7kFkdcvatKRkypUKo3E+tGevIMosqSxU/WHe8yefxFylDFh+iw5jeMfLjenXg3CZfnBoJANhwNAeAa13csz/8iQ1HcnDf539g3s8H5NLcupir/L9RU8mi3eFEdonre1xQZq1xXz1qnMD5pBERERG1gKoBWbnVgT9O5cPhFJEYrkenMEOTzmvQVM2QeawhszVgDVmTM2SVJYvNaeoBAEad1Nij6RmyTI+1Y2kHsnAkq6TJ5/KHDHcAGReix+UeGbLskur7xbVVI7u7ArLfjuQCAP53KBvHc8qgce939ummk3JJbl3Kq+zLJ4rVG3uUVtghJc5EEY3eQJqqY0BGREREHUrVsqwyqwNbT+QDAIanNK1cEfBufW/Sq6FTVZYsenZZLLc5YPa48ZWyUVKXw8YyuK9b4rGGrKkBmdzYo7z5GbK4EFcZ3cajuU0+l69kFVvw1urDyCq2yAFZfKjOq7HKuYLy2l7e5kgZsgMZxcgpqZBb4d91STJG93IFmYcyi+s8h7OWtWBVs2RmKzsqtjQGZERERNShWKpkyMwV9mavHwOAIK13Uw+pKUSFzem19xngnSUrMjcvQyaVSmYUlkNqfBdmaJ0Mmc3hRI57jdyQpDAAkL9uS77Ychrv/e8YFq4/joxCV+AV6w4gH72yGwDglqGJrTa+xooM1qJvggkA8MqKg9h2Kh9qpYC7L05B16hgAMCJnLr3KSuv0tBDUrWxR9UMMzUfAzIiIiLqUKreUOaVWZu9fgyoqamHQr5e1SDQcx2Z3GWxiQGZVCp51p3RMepU0KiadosnjaGp3fpySiogioBaKaBXnCtAyC5uewGZlEn881yRV8kiADwxuhu+uncY/jqxV6uNryku7RYFAPhp13kAwM1DExFj0smbnJ/IrTsgqy3zZfcIyERRrJZhbg3qknOI3fYKtIXHWnsoLYIBGREREXUoVW88T+SUweEUEaRRNnn9GOBdshhSpWTRYq8SkHlkjZq9hsydIctxr3lqarki4Jkha1rJorR+LNqoQ7TRtRea1ACiLZGCigPpxcgqrixZBFybLl+cGtnkJiut5dJukfLfbxicgL9f0wcA0EXOkJXW+fraAi2bR8lihd3pv46KoghtwVHo8vZDVZYpPxyUvgmpSycg6s+FiP39ZT8NxreaVqxMREREFKCqZqtO57syB5HGxm+m7KlqhszpvnO12B3V1ubUmCFrapfFKptS93Znppqicg2Za0wN6cznSVo/FhuiQ5R7PnPaYHMMKSiXsqVKhYBoo641h9Rsw1MicP/ILog16XDXxckQBNfm5l2iXBmy84XlsNgc1dr5V9gdsFidKLPWHIR7NvXw5/qxmD/+geg9/wQAiIICx65bDqfKgOSVU6Fwuj6fwekbobCVwakO8tu4fIEZMiIiIupQqmYCzuabAbjW4TSH56bCnhmycmtl2/vIYFf2ymsNWXnzShY9A0EAuGlopyadB6jMkBVb7Ph8yykMe2Vto7okegZkUoDTFgOyqsFHtFELpUJopdG0DIVCwJzxvXD3JSlyMAa4tkAw6VQQxco94jxlFVXgTL65xhb3gHdA5q/1Y7q8g4j680MAgENlgCA6EXpsKUJO/AyF04ay6CGoMHaGwlGB4HPr/TImX2JARkRERB1K1ZvKM+6ArCl7d3nyDIxMOpW8hqzCo+19QqhrnVJ+WWWQInU0DGlql0WPQDDGpMVI91qipvBcQ/bLnxnILqnAZncHyoaQShZjTTpEm1wBbr7ZWq11emurGpRLHSHbI0EQkNLAxh41sTsrA7WqbfF9QnQiYdNsCKIDRclX49zINwEAptOrYDq9CgBQ0OMWFCeNcz++Wn5p2P7PgPRdCLSdqhmQERERUYdSNSDLcjedaKmSxWCtCiqlQu6y6CpZdF0z3h2QSRkyp1NsdlMPz0Bw8uBOUCmbfnsnZ8jK7fLaqqr7ptXFs+V9uEEDpUKAKDbuHP5QtfQuzv19aa+6So096llHVhOru0Oo1e6ssS1+Sws58QsM2TvhUAchfcQLKO00Ck6FBtriUzDk7oUIASWJV6I4eSwAwHh2LeC0QVWWibhNfwM+vhwoy/H5OFsSAzIiIiLqUCzum3FtlU6EzS1ZlJp6SM05pJJFm0OUA4BOYa4b/yx3o4tSq13+ZX5T15B5vu6GwU0vV/Q8V7HFJgdXuU0IyGJMOigUglyi2dYae1QNyuPbcYYMqFxHVl+nxZqIIuBwijhfWO6XxFPEgc8AALl974M9KA5OTTDK4i+WnzfHDIHdEAVz9FDYdeFQVRQhKHMbTKfTXAd0ugAIjq7p1G0WAzIiIiLqUKSb8aoBWFRw80oWpY2dQ92bC3s2T5DWiUkd79ILXQGKtAeZVqWo1myhofQaJf55+yC8f9sgpEYHN23wblKG7Fy+Wd47La+s4WvApJJFqQSwrTb2MFcpvZNa3rdXXZpRsgi4vq+lTey82Ri6vIMIytoOUVAhv+ft8uNF7mwYALlUEQolipNcj4cd/k4uZ0TPCT4fZ0tjQEZEREQdihSQVW0PH9HMDNmILpG4flACHrkiFYB3Bs7hXofTJbKy411LlCtKJvaPxzUD4pt1Ds9xpBdVZrQaWm4oiqIckMWYXAGZ1Ngju80FZK7PQIx7nZu0V1d7JWXIjueUVgtGGyLfTyWn4Qe/AAAUJY+DPShWfryk82iIcDUqkYIwAMjveQcAIOTkcgRlbHE9GIABGdveExERUYci3YxHVMmINbdkUa9R4u1bBspfKxQCtCqFnGkCXDf+guBaj5NXZm32HmQtzaSrfmvYkJLFjUdzcTCjWF5vVBmQtc0MmdTU491bB+Fsvhkjuze9EUogSI4IQphBjQKzDbd9vBWLpl/Q7M97SxNsZoQe+xEAkN9rqtdzdkMMzl7+PgRHBawhKfLj5VEDYI4aAEPOHgBARWgqtJHd/DfoFsKAjIiIiDoUSy0ZsshmlizWRKdWegVkwToVYow6ZBZbcL6wXO6wWFMg1BpqWseWV2atc+1QWYUdd3+2XQ7GIoM10Lizg1FtcHNoq90pdw7sFWfC8C4RrTwi39Oplfhk2lDc89kf2HOuCBPf24i3bxmIEbn/h7AzfyLIowtmSeKVKEka4/cxaouOQWk3w66LQFnc8GrPF3W9tsbX5fWaCkPOXwAAJcnj0LbCzIZhySIRERF1KFJ2pGqGoLldFmsitb6XaFVKxIe6skfnC8rlDZjbSobMWENAVmF3oqKO7aeOZJXAanfK+3hdnBopP9cWM2SeJXueWwa0d0OSwvHDQxehS2QQMostuP2TrTixZSmM+79ExKGv5T+df50JwV7u9/FpSs4BAKymJEBo+J5wRV2ugV0bBgAoTr7KJ2Pztbbx6xgiIiIiP5HWkHnuO6ZRKmDUtvxtkd6jUYdaKUCpEJAQZsDOM4VILyyX7zubu4aspejUCqiVAmxVNgkuttX+mkOZro2jL+oagY/vHOoVhFZmyNpSQOb6/quVAtTN2CIgEHWNCsbPj1yCeT8fwLd/nMXeiKsQ3vMSuZ19xMHPoTZnI/j8byjxWKvlD3JAFty4TqGiSoeT4/8Ndel5WKIH+mBkvseAjIiIiDoUqWTRs4lHZLAGQiN+K99Qnp0TpTb40ubQ5wvL5a6GbSVDJggCTDo18sq8142V1hGQHXYHZD1jjfLea5IoqalHcQXsDlcWzRfz3BhSQKZvYlfLQBekVeH1G/vj6n6xuKjr1cgssshrGVWWPETuXwzT6dWND8icDsRufw22oDjk9b27QS8xZO1A2OFvkDH8OahL3QGZsfFbN1giesMS0RuB+h3tWL8WICIiog6vvIamHr4oVwQArcdNv/T3BKlksbCyZLGpe5D5grGG9WwlttqDqIMZxQCAnrGmas9Fe6whu+T1X3HLx1sh+mMzqzpI33+DpmPnJUb1iJbX+kmkDoamM2sAZx11qjUwnl2LqL0fIX7rCwhK39Kg18T+/hLCj3yLsMPfQeMOyGyNzJC1BwzIiIiIqMMQRbHGkkVfdZzTedzwSqV8Ce7Noc8XlLe5LouAd/lkcoQBAFBSS4ZMFEUcznJlyHrEGqs9L5Us2hyulvjbTuY3aXPiliStIetI68caqiz2Qti1IVBZ8mHI/qNRr5U2dAaA+E1zIDjqLlMVbGa5O6Iu/yDUTSxZbA8YkBEREVGHUWF3wt1gz6tkMSKo5TssAvAq4ZP2JYv3KFksdm+2K20q3RZ4Zsj6JIQAqD0gyyquQKHZBqVCqHFTap1aWS3YXH84p+UG2wRmd0Bu0DIgq0ahRkniFQCApLT70O2HMdDl/lnvyzRFJ2A8/xtECLDrwqErOo6oPR/W+RpD9g4Iouvzr88/WJkha0LJYqBjQEZEREQdhrR+DKiSIfNRyaK0bgyoXE8mrSErKrchvdDVza5NZcjc5ZN6tVLeyLq2ksVDma5yxZTIIK/1cp7+MrY7bhicgJmXuzbMXn+keQFZQZkVTmfTyx7lkkV12wmCW1PVJX2FqZMBAKqKQugKDiNy76J6zxFx8EsAQEni5UgfMQ8AELVnATRFJ2t9TXDGVvnvuvyDUNpKATBDRkRERNSuSeWKaqUAnVoJjbvLns9KFtWeJYuugMWoU8v7jh3Ndt2Ehhl8k6FrCilDFhuik+eltqYehzwaetRm6ohkvHXzQFw7MB4AsPVEnldg3FAWmwPzfj6AwS+lYc5Pexv9eonc1IMliwBQLZAu7TQSh2/agLMj5wMATGfXAs7au7oI9nKEHfkOAJDfeyqKulyDkoSRUDgqkLBpjmstmuj0/gMgKKNynZkgur4nNn0URJWuRd9fIGBARkRERB2GlB2RbkKlsjVfbAoN1FyyCFSWLTqcInrGGjGoc5hPrt8UUoYsxqSVA7ISm4CsYguKLd435ocbEJBJukUHIy5Ehwq7E7+fzPd6btOxXKw5kFXra20OJ27+aAs+3XQSogis3J/Z5CwZ15B5q2kerCHJKEy9AXZdBJTWYgRl/F7r60NP/AyltRjW4ESUJFwGCALSL34JTqUWwemb0O/TFPRblOz1J2nVXdC714/Z9FHyuTpiQw+AARkRERF1IFKGTGp5HuTutOerDJm2hpJFAOjkbuyhUyvw/m2DqnW7a02hBldAFh+ilztRZpqBce9uwi0fVZaZFZlt2OAuP+wdX73DYlWCIOCy7q6b73WHsyvPU27DXUu248Evd6DEUnMmZu/5Ivx5rghBGiV0agUKzTY5u9hYzJB506uVNe/DrFCiuPNoAIDp9GqEHP8PjKdXu56ylSHyz4XQFh5D+IHPAQB5vaYACtecWk3JyBz6TK3XNJ1dC4XTBmtQHEoSr5Qfb0rL+/aAxbNERETUYUilclJW4OahiVh/JBuDOof65Hpe+5B5lC+O7B6FdYdz8OKkvugWU392yZ8mDUzA0exS3H1Jijx+s0MAHA4czCiG3eGESqnA66sOIa/MitToYFySGlXPWV2u6BmNb7afxXfbz+KBkV0RG6LD5mO5sNpdZWx5pVYYa9gCYO+5IgDAhSnhsDlEbDyWi20n82rs7Fgfs9X7M9DRKRQCdGoFyq1O6NQKeZNowNUGP/zIt4g4+DkiDywBABy58X+I2L8EEQc/R8yO+VA4KuBUalHQ4xav8+b1uxcFPW6FUKXcUVNyBp3/9zA0JWdRFn8xLOE95edswQm+e6NtGAMyIiIi6jDKra6bTSnQeGx0Nzw2upvPrue1hswjWzZ1RDJuHppYayOM1pQYbsC7tw4C4MqCVVVgtuFsgRlf/34GAPDydX0bnOEb3SsGgzqHYteZQry4/AAW3D7Yq8lH1ZJIyZ5zhQCA/p1CoRAEV0B2qgB3jkhuxDtzKZdLFnkbLNFrVCi3WhEZrMX5wnJIW8WVJlwKp0oPhb1cPjbyz48QcvIXAIDC3dq+KGUCHLrwaud1aqp33izXheHYpF8QcmIZipOvgrbwhPycNTixJd9WwGg7+XEiIiIiH5NLFv2UHdF7bQztfdvVFoOxqkx6FdRK73q2/DIrftzpalF+3cB4DOsS0eDzKRQCXrquLxQCsPzPDKw/kuMdkJXba3ydlCHr3ykEF6a4bvy3ncxr0ibTcsliAMy/vxjUSigUrm6famXl51RU6ZDT/0FYwnoga/ATAIDwI99CaSuDJaQrsgc8jPKIvsge9GijrufQhSG/9zTYDTFeGbKOWrLIgIyIiIg6DKmhg79uxj2DLs/1ZIFCEAQM7hwKg0pEmHttWX6ZFVnFrszIkOTqWZH69IkPwbSLkgEAj32zCxlFFvk5aaNsT2UVdhzLca0X69cpBIM6h0KtFJBVXIEz+eZGX19q7BLEfchkeo0SoQYNFAqhWgCePfgJHJ2chuxBj6HC2Fl+PL/Xnci64Fkcu34FrCFdmnxthy4MlpCuEAUFKsK6N/k8gYwBGREREXUYFpt/syM1tb0PNEumDcHzgxzoGuXakyy/zIrcUldAFtXEZihPju2BxHA9CquURNZUsrjvfBFEEYgL0SHaqINOrcSATqEAUK1bY0NUNvVgyaJEp1bK+/J5Zsi8CArk97oTAOBU6VHQbXKLXf/UVV/g+DU/ddg1ZAzIiIiIqMPIL3Pd8Afr/HMzXltTj0CiUiqgV1XulZZvtiKnxB2QGZu2XUCQVoU3Jg+Qv1YqXFmZ4hoyZHvPu8oV+yWEyI9Vli1WBmSiKOL9tUfr3Xi6TFpDFqABsq9In9VaAzIA+T3vQGHX65A+Yi6c2pBaj2ssm7ETyqMHtdj5Ak1g/mQgIiIiaoIjWa59s7pFV2824AuBXrLoKdydQckv9cyQNX0T3xFdI/Ds1T0xqHMoxveLA1BzyeKfHuvHJFJAtv1UZUC262wh5qcdwfP/2Vfj9Q5nluBMnlkuWWSXxZpVLVn05NQE4+zl76Ggx61+HFH7x1wtERERdRgHM4oBAD1j6983qyW0hwyZJNy9huxMvllujR7ZxAyZ5MHLuuLBy7rirbQjAGopWUx3Z8jcZYoAMCQpDAoBOJ1nRmaRBbEhOpwrcHUCzCiyQBRFCB6baxWV2zBpwUYYdWp5zznuQ1YzdRvaE6+j4IwTERFRh2C1O3Hc3RyiZ5x/9v7SqQJ/DZkkzJ0hk7KMQRpli7WON7lLSGvqspjrLo9MCNXLjxl1ankz6m3uLFlGoSsgs9qdKLZ4n+dYdgksNidySipwKrcMANve10atYHjgb5xxIiIi6hBO5JbC5hBh1Km8bu59yTMLE/AZMndAdjTbFZBFGpvW0KMmIXpX9q1qyaIoiiitcAVXxirr/i5MdrXb33YyDwC8ujVKJZWSU7mV3RjLbSxZrEtdJYvkG4H9k4GIiIioih2n8zHx/d/khg/nC8txPKcUhzJcgUSvWJNXOZsvtas1ZO6SRblcsYkdFmticgdkVUsWy20OON1bjQVrqwRkVRp7ZHoGZCXeAdnpvLJq12TJYs1USgX89L8HuTFXS0RERO3Kf/dmYt/5YvzfjrMYmhSGGz/cjPwyKy7vEQ3Af+WKAKBTtb8MmaSpLe9rYtK5A7IqGbJSd+mhIFTPaF2QHAYAOJJVioIyKzKKPTNkVq9jT+VV36+MGbLaqZUKWO3O1h5GhxHYPxmIiIiIqpBK0o7nlOF8YTkyiiyosDuxcn8mAP819AAAncZjDVmgZ8iqBGTNbejhqbJk0XvtV4m7XDFYq6qW1YwI1iLV3S1zx+kCZBaVy89VLVmsKUPGNWS1a2rZYoxJCw2bgjQaZ4yIiIjaFSkgO5ZdKq938uTXDJlnyWKAZ8jC3CWLkua0vK/KpHc39bDUnCEzamsOnvq79ybbe74I2R5lijlVShaZIWucuvYiq41eo0SUUVstcKf6BfZPBiIiIqIqKtxrnIrKbfj9RH6153vEtE7JYqCvIdOplV5BTEtmyKQ1ZFa7ExZ3QA1AbuhR20bePWJd38vfjuZAFCsf98yQFZqt1ZqFqJVCk4KOjqIpc9MpTA9BEBAepOEatEbiJ5GIiIjalXKPG3qpTPHKntFQKQQM6BSCoFqyLb6gVgpQuG9OA73tPeBdttiSa8iCNSp5njzXkZV6lCzWpGecq/x099lCr8c9AzIpOxZt1Mqlkfp28L3wpcaWLAZplfLnW6kQ5HmmhmFARkRERO1KubUyIDvtvhmfPKQTVj4+EoumX+DXsQiCgM7hBmhUCkS1YJv41uIZkLVk23uFQoBRV73TolSyGKyr+Qa/lztD5hS9H8/xaOohrR9LjgxCSmQQAK4fq09jf2kRaqjS8MWoZZasEfhpJCIionbFYndUe6xbdLDcAMLf/n3/cJRY7O0ia+CrDBngWkdWVG7zauxRmSGrOaMVZdQizKBGgdkVxHUK0+NcQblX23tpD7LkCAPsThG7zxZy/Vg9dGolQvTqaqWeNREEVPts69RKRAZrvdbyKRUCQg1qKBUCsosrqp6mQ2OGjIiIiNoVzwwZAKgUApIiglppNEBciB7d/bhuzZe8ArIWzvhJN/WNKVkUBMGra2Y/d5OPnNIKiO5FZVKGLCkiCF2jXEE59yCrX7SpYVkuk84VZFV7vbGy46JOrUDX6CDEh+pbPJBvDxiQERERUbvi2RQCcJWqsRV3ywh3l6YZtaoWXxNnqqFksUQqWdTWnl307JrZ1x2QWe1OuWX+KalkMSIIveNdwVt0Oygf9TUpS1aVIABGnQrxoTokhusRE1LzXCoUArpFB6NXnBGp0cFyUxuFQoBaxXpGTyxZJCIionbFYvPe0LZ7TOuUKrZH4cGugKwl149JatocurTC9ffauiwCQM/YyoCsS2QQgrUqlFbYkVtSAY1SgUOZrq0PukYHoUeMEe/eOhCDO4e1+Pjbo/hQPUor7LA7KhfphQVpkBCqb9DrFQoBClQPvrQqJWx2ew2v6JgYkBEREVG7Ul4lQ5Ya3T7KBduCCHfJYmRwy+81Vbk5dPWmHrXtQwZ4b/QdG6JDZLDGFZCVWnEytwxmqwNxITr0iDFCEARMGpjQ4mNvr5QKAZ3C9PI6PAAIbYG1kFqVAqXNPkv7wfw9ERERtStSQJYY7votfm8/bgTd3l3eIxoXpoRjyvCkFj935ebQNTT1qCND1j3GCJV7DVNCmB6R7jVKuaUVWL0/CwAwtncMBLb9axKjTo2wIFcQplYJLbJthJYlxF6YISMiIqJ2w+kUYbW7ShbfmDwABzOKMbpXTCuPqv2INunw3QMjfHLumpp6VK4hq/2WVa9R4s2bBqDYYkO0UScHZFnFFqw56A7I+sT6ZMwdRVyIHsXlLdcpVFvP+kOdWlGt9Lg9Y0BGRERE7YZny/sBiSEY0TWiFUdDjWGqqWSxARkyALhuUGUZotT9cdX+TOSVWWHSqXBhSnhLD7dDUSoExIfq5MYczVVfhizEoEZFcQVEsc7D2g3mC4mIiKjd8Gx5r2uhm0fyj5q6LJZV1L+GrCopQ7b1RD4A4MpeMVArecvbXKEGTYttF6BWKqCo41uiUyvrLY1sT50a+ekkIiKidsPiLlfUqhRQ1LA3ErVdNTb1aGCGzNNFqRFyBkajVOCWCxJbcJTUUurKtmlVCgTVE/zFh+obtE9aIGDJIhEREbUbUoaspffIIt+TShYLzdXXkAVpGn7LekFyOPb8fSwqbE5o1Qp+FtoorUpRbRN3wLXPmValhEErAqio8bVKhQCTTo0grUruxBnImCEjIiKidkPaFFrPm/CAI7XUzy+zAnBt7lzhzngaG5EhA9ybGhvUDMbasCCtCnqNAsoqmWyd2hWeGNTKWjNgUkdOKasqCAjozd9bfeTnz5/HlClTEBERAb1ej379+uGPP/6QnxdFEc8//zzi4uKg1+sxevRoHD161Osc+fn5uOOOO2AymRAaGop77rkHpaXeuxv8+eefuPTSS6HT6ZCYmIg33nij2li+//579OzZEzqdDv369cOKFSt886aJiIjIJ+SArIXWupD/RLj3NjNbHTBb7fL6MQAt0mqd2pbwIA1So42IMXlvMi6VMioUQq0BtdG93tCkU0EQgIRQPTqHGwK2hLFVA7KCggJcfPHFUKvV+O9//4sDBw5g/vz5CAur3D39jTfewHvvvYeFCxfi999/R1BQEMaNGweLxSIfc8cdd2D//v1IS0vDL7/8gg0bNuD++++Xny8uLsbYsWORlJSEHTt24B//+AdeeOEFfPzxx/Ixmzdvxm233YZ77rkHu3btwnXXXYfrrrsO+/bt889kEBERUbNJe5Bxn6PAE6xVyVmOvFKrvH5Mp1awKUc7FqJXewVSWnXl9zoqWAuTXgWVsvIAQahs8qJSKpAQqkdYkKvhSLTRO7gLFK3664bXX38diYmJWLx4sfxYSkqK/HdRFPHOO+/gb3/7GyZNmgQA+PzzzxETE4OlS5fi1ltvxcGDB7Fy5Ups374dQ4cOBQC8//77GD9+PN58803Ex8fjq6++gtVqxaeffgqNRoM+ffpg9+7deOutt+TA7d1338VVV12Fp556CgDw4osvIi0tDf/85z+xcOFCf00JERERNYO0JoUZssAjCAIigzRIL7Igr8wKjTsIC9a2zN5X1DaplAqvtWCezT5CDGqEGFzff7PVDptDhE7t3bAnzF3qCgARwQzIGm3ZsmUYN24cbrrpJqxfvx4JCQl4+OGHcd999wEATp48iczMTIwePVp+TUhICIYNG4YtW7bg1ltvxZYtWxAaGioHYwAwevRoKBQK/P7777j++uuxZcsWjBw5EhpN5Tds3LhxeP3111FQUICwsDBs2bIFs2bN8hrfuHHjsHTp0hrHXlFRgYqKyoWGxcXFAACbzQabzVbja/xFun5rj6M94xz7HufY9zjHvsc59r2qc1xmca0/0qkUnPcW4s/Pcbg7IMsqMstZkGCtst1/Lzv6z4pgNVBc5grIlKIDNU2DWgDUKgCiE7YmbBrt7zluzHVaNSA7ceIEPvzwQ8yaNQtz5szB9u3b8eijj0Kj0WDatGnIzMwEAMTExHi9LiYmRn4uMzMT0dHRXs+rVCqEh4d7HeOZefM8Z2ZmJsLCwpCZmVnndap69dVXMXfu3GqPr169GgaDoaFT4FNpaWmtPYR2j3Pse5xj3+Mc+x7n2PekOd6WLQBQoig/l2vBW5g/PscOswKAAuu2/AGjGgCUcFjKOsz3kj8rgFM+Pr+/5thsNjf42FYNyJxOJ4YOHYpXXnkFADBo0CDs27cPCxcuxLRp01pzaPWaPXu2V0atuLgYiYmJGDt2LEwmUyuOzBWRp6WlYcyYMVCrmeb3Bc6x73GOfY9z7HucY9+rOsd5W88Axw8hKSEO48cPaO3htQv+/Byvs+zDwV3pSOjSE/GhOuDQXiREh2P8+At8et3Wxp8VvufvOZaq5xqiVQOyuLg49O7d2+uxXr164YcffgAAxMbGAgCysrIQFxcnH5OVlYWBAwfKx2RnZ3udw263Iz8/X359bGwssrKyvI6Rvq7vGOn5qrRaLbTa6nWqarW6zfyP1JbG0l5xjn2Pc+x7nGPf4xz7njTHUiWTQcs5b2n++BxHG3UAgIJyO8KCRQCAUa/pMN9L/qzwPX/NcWOu0aotay6++GIcPnzY67EjR44gKSkJgKvBR2xsLNauXSs/X1xcjN9//x0jRowAAIwYMQKFhYXYsWOHfMz//vc/OJ1ODBs2TD5mw4YNXrWcaWlp6NGjh9zRccSIEV7XkY6RrkNERERtn9RlUadmV75AJLW+zyutkNveG9nyntq5Vv1p9cQTT2Dr1q145ZVXcOzYMXz99df4+OOPMWPGDACubjuPP/44XnrpJSxbtgx79+7F1KlTER8fj+uuuw6AK6N21VVX4b777sO2bduwadMmzJw5E7feeivi4+MBALfffjs0Gg3uuece7N+/H99++y3effddr5LDxx57DCtXrsT8+fNx6NAhvPDCC/jjjz8wc+ZMv88LERERNU05N4YOaBFBruqjvDKr3HWPe5BRe9eqn/ALLrgAP/30E2bPno158+YhJSUF77zzDu644w75mKeffhplZWW4//77UVhYiEsuuQQrV66ETqeTj/nqq68wc+ZMXHnllVAoFJg8eTLee+89+fmQkBCsXr0aM2bMwJAhQxAZGYnnn3/ea6+yiy66CF9//TX+9re/Yc6cOejWrRuWLl2Kvn37+mcyiIiIqNkq3DWLbHsfmKQMWW6pFSXuDFmwjgEZtW+t/gmfOHEiJk6cWOvzgiBg3rx5mDdvXq3HhIeH4+uvv67zOv3798dvv/1W5zE33XQTbrrpproHTERERG2WtA+ZjhmygBTp3kcqr7RCzpAFM0NG7RwLrImIiKjdqFxDxoAsEEkZsvwyK3JKXfu9mvRsckHtGwMyIiIiajcsXEMW0MKDXAGZ3Sli64k8AEDf+NbdTojI1xiQERERUbvBLouBTatSwuheM2axOaFTK9AnPqSVR0XkW/xpRURERO0GM2SBT1pHBgCDEsOgUfF2ldo3fsKJiIio3bC4uyzq2GUxYEW4yxYB4ILksFYcCZF/MCAjIiKidkMuWVQxIAtUUmMPABiaHN6KIyHyDwZkRERE1G5Ibe+5D1nginCXLCoEYHASM2TU/jEgIyIionajws41ZIEu0l2y2DvexD3IqENgQEZERETtRuXG0LzFCVSDk8IgCMD4fnGtPRQiv+CvHYiIiKhdEEVRXkPGDFngGtUjGntfGMfsGHUY/PURERERtQs2hwin6Po7uywGNgZj1JEwICMiIqJ2QcqOAeyySESBgwEZERERtQvSptBKhQC1Umjl0RARNQwDMiIiImoXLB7rxwSBARkRBQYGZERERNQuyJtCs8MiEQUQ/sQiIiKidqGy5T3XjxFR4GBARkRERO2CxeYEwJb3RBRYGJARERFRu2CxMUNGRIGHARkRERG1C6UVdgCAgXuQEVEAYUBGRERE7UKB2QoAiAjWtPJIiIgajgEZERERtQt5pa6ALMzAgIyIAgcDMiIiImoXpAxZeBADMiIKHAzIiIiIqF3IK2NARkSBhwEZERERtQsFDMiIKAAxICMiIqJ2IZ8BGREFIAZkRERE1C5IARmbehBRIGFARkRERAFPFEU29SCigMSAjIiIiAJeaYUdNocIgAEZEQUWBmREREQU8PLNNgCAQaOETq1s5dEQETUcAzIiIiIKeGzoQUSBigEZERERBbwCd4aMARkRBRoGZERERBTw2GGRiAIVAzIiIiIKeFKHxQhmyIgowDAgIyIiooCXX+YqWQxjQEZEAYYBGREREQU87kFGRIGKARkREREFPHZZJKJAxYCMiIiIAp7UZZFNPYgo0DAgIyIiooBX4F5DFhHMgIyIAgsDMiIiIgp4+Wa2vSeiwMSAjIiIiAKawwmUWOwA2PaeiAIPAzIiIiIKaKWuWAyCAJj06tYdDBFRIzEgIyIiooBW5g7IQvVqKBVC6w6GiKiRGJARERFRQDO7AzKuHyOiQMSAjIiIiAJamc2VFQsxsFyRiAIPAzIiIiIKaMyQEVEgY0BGREREAU1eQ8YMGREFIAZkREREFNDK7K6SRWbIiCgQMSAjIiKigFZZssgMGREFHgZkREREFNDKbK7/hjJDRkQBiAEZERERBTSzu2SRa8iIKBAxICMiIqKAVsYui0QUwBiQERERUUBjl0UiCmQMyIiIiChgiaLIfciIKKAxICMiIqKAVWZ1wCGy7T0RBS4GZERERBSwCs2uFosalQI6NW9riCjw8CcXERERBSwpIAvTqyEIQiuPhoio8RiQERERUcAqLHcFZGzoQUSBigEZERERBaxCsxUAAzIiClwMyIiIiChgyRkyPQMyIgpMDMiIiIioTZr38wH0f2EVDmeW1HpMgZkli0QU2BiQERERUauosDsw46udGPv2ehSUWVFudeDVFQfx+4k85JRU4Iutp1BsseP9/x2t9RxSU49QPVveE1FgUrX2AIiIiKjjcThFzPp2D5bvzQAAfLP9LBxOJz7acALf/nEWtwxNhM0hAgBW7M3AmTwzOkcYqp2niE09iCjAMUNGREREfrU/vQhTP/1dDsYA4KvfT+PzLacBuLJeH204AQAw6VRwisCijSdqPFchSxaJKMAxICMiIiK/2Xg0FxPf34hNx/KgVgqYf9MAmHQqnCsoR3ZJBYzayuIdo06Ft28ZCAD49o+zKHIHX54Kyl1dFsPY1IOIAhQDMiIiIvKbbafyIYrAwMRQrJ01CpOHdMKNQxLl5x+6vCsmDYwHANw8NBFX9IxGjxgjLDYnlu0573WuzcdzcTy7DAAQFsQ1ZEQUmBiQERERkd/klFgAAKN6RMlrwqYM7wylQkCwVoXbL+yM1yf3x4LbB+OpcT0gCAJuvsAVsH33xzn5PCv3ZeDORdtQZnWgc5CI/gkm/78ZIqIWwKYeRERE5DfZxRUAgBiTTn6sS1QwvntgBIK0SoQaXJmuCf3j5OevH5SA1/57EHvPF+FAejF6x5uwaONJOJwiJvSNxSjDOaiU/B0zEQUm/vQiIiIiv8lyZ8iijVqvx4ckhaFnbM1ZrvAgDcb0jgEAfL/jLCw2B/acLQIAPDE6FRqlDwdMRORjDMiIiIjIb6QMWbRRV8+R3m4a6ipbXLrrPLafyofV4USMSYvO4foWHyMRkT8xICMiIiK/cDhF5Ja6AzKTtp6jvV2aGonIYC0KzDa8ufoIAODClAgIgtDi4yQi8icGZEREROQXeWUVcIqAIAARjeyKqFIqcM0A17qyPWcLAQDDUsJbeohERH7HgIyIiIj8QipXjAjSNqkJx/WDEry+ZkBGRO1BswIyq9WKw4cPw263t9R4iIiIqJ3KKZE6LDauXFHSLyEEXSKDALgafaRGB7fY2IiIWkuTAjKz2Yx77rkHBoMBffr0wZkzZwAAjzzyCF577bUWHSARERG1D1nFNXdYbChBEHDDYFeW7KKuXD9GRO1DkwKy2bNnY8+ePVi3bh10usouSaNHj8a3337bYoMjIiKi9iO7pGkdFj3dP7IrXrquL56b2LulhkVE1KqatDH00qVL8e2332L48OFev53q06cPjh8/3mKDIyIiovYjW9qDrIkliwCgUSkwZXhSSw2JiKjVNSlDlpOTg+jo6GqPl5WVNap84IUXXoAgCF5/evbsKT9vsVgwY8YMREREIDg4GJMnT0ZWVpbXOc6cOYMJEybAYDAgOjoaTz31VLU1bevWrcPgwYOh1WqRmpqKJUuWVBvLggULkJycDJ1Oh2HDhmHbtm0Nfh9ERERUv8o9yJoekBERtTdNCsiGDh2K5cuXy19LQdgnn3yCESNGNOpcffr0QUZGhvxn48aN8nNPPPEEfv75Z3z//fdYv3490tPTccMNN8jPOxwOTJgwAVarFZs3b8Znn32GJUuW4Pnnn5ePOXnyJCZMmIDLL78cu3fvxuOPP457770Xq1atko/59ttvMWvWLPz973/Hzp07MWDAAIwbNw7Z2dmNnhsiIiKqmVSyGNWMkkUiovamSSWLr7zyCq6++mocOHAAdrsd7777Lg4cOIDNmzdj/fr1jRuASoXY2NhqjxcVFWHRokX4+uuvccUVVwAAFi9ejF69emHr1q0YPnw4Vq9ejQMHDmDNmjWIiYnBwIED8eKLL+KZZ57BCy+8AI1Gg4ULFyIlJQXz588HAPTq1QsbN27E22+/jXHjxgEA3nrrLdx333246667AAALFy7E8uXL8emnn+LZZ59tyhQRERFRFdnuph5N7bJIRNQeNSkgu+SSS7B792689tpr6NevH1avXo3Bgwdjy5Yt6NevX6POdfToUcTHx0On02HEiBF49dVX0blzZ+zYsQM2mw2jR4+Wj+3Zsyc6d+6MLVu2YPjw4fL1YmJi5GPGjRuHhx56CPv378egQYOwZcsWr3NIxzz++OMAXK37d+zYgdmzZ8vPKxQKjB49Glu2bKl13BUVFaioqJC/Li4uBgDYbDbYbLZGzUFLk67f2uNozzjHvsc59j3Ose9xjl1eW3kYOSVW5JS6/t0M1ytbbE44x77HOfY9zrHv+XuOG3OdJgVkANC1a1f861//aurLAQDDhg3DkiVL0KNHD2RkZGDu3Lm49NJLsW/fPmRmZkKj0SA0NNTrNTExMcjMzAQAZGZmegVj0vPSc3UdU1xcjPLychQUFMDhcNR4zKFDh2od+6uvvoq5c+dWe3z16tUwGAwNmwAfS0tLa+0htHucY9/jHPse59j3OvIcWxzAom3etxt/bPwVqmbthFpdR55jf+Ec+x7n2Pf8Ncdms7nBxzYpIFuxYgWUSqVc8idZtWoVnE4nrr766gadx/O4/v37Y9iwYUhKSsJ3330HvV7flKH5zezZszFr1iz56+LiYiQmJmLs2LEwmUytODJXRJ6WloYxY8ZArVa36ljaK86x73GOfY9z7HucY+BIVgmwrbLiJMygxrUTx7bY+TnHvsc59j3Ose/5e46l6rmGaFJA9uyzz9a4AbQoinj22WcbHJBVFRoaiu7du+PYsWMYM2YMrFYrCgsLvbJkWVlZ8pqz2NjYat0QpS6MnsdU7cyYlZUFk8kEvV4PpVIJpVJZ4zE1rW2TaLVaaLXVa+DVanWb+R+pLY2lveIc+x7n2Pc4x77Xkec4q9RVthMRpIHV7sRFXSN9MhcdeY79hXPse5xj3/PXHDfmGk0qGDh69Ch6966+IWPPnj1x7NixppwSAFBaWorjx48jLi4OQ4YMgVqtxtq1a+XnDx8+jDNnzsidHEeMGIG9e/d6dUNMS0uDyWSSxzdixAivc0jHSOfQaDQYMmSI1zFOpxNr165tdMdIIiIi8nauoBwAMCQpDNv/Nhr/vH1QK4+IiKhtaVJAFhISghMnTlR7/NixYwgKCmrweZ588kmsX78ep06dwubNm3H99ddDqVTitttuQ0hICO655x7MmjULv/76K3bs2IG77roLI0aMwPDhwwEAY8eORe/evXHnnXdiz549WLVqFf72t79hxowZcvbqwQcfxIkTJ/D000/j0KFD+OCDD/Ddd9/hiSeekMcxa9Ys/Otf/8Jnn32GgwcP4qGHHkJZWZncdZGIiIia5rw7IOsUZoBOrWzUfqVERB1Bk0oWJ02ahMcffxw//fQTunbtCsAVjP3lL3/Btdde2+DznDt3Drfddhvy8vIQFRWFSy65BFu3bkVUVBQA4O2334ZCocDkyZNRUVGBcePG4YMPPpBfr1Qq8csvv+Chhx7CiBEjEBQUhGnTpmHevHnyMSkpKVi+fDmeeOIJvPvuu+jUqRM++eQTr/Vvt9xyC3JycvD8888jMzMTAwcOxMqVK6s1+iAiIqLGkTJkCWFte204EVFraVJA9sYbb+Cqq65Cz5490alTJwCu4OrSSy/Fm2++2eDzfPPNN3U+r9PpsGDBAixYsKDWY5KSkrBixYo6zzNq1Cjs2rWrzmNmzpyJmTNn1nkMERERNc65QilDxoCMiKgmTQrIQkJCsHnzZqSlpWHPnj3Q6/Xo378/Ro4c2dLjIyIiogB2vsDV+jkhlAEZEVFNmrwPmSAIGDt2LMaObbnWtURERNR+WGwO5JZaAQCJYW1jj04ioramwQHZe++9h/vvvx86nQ7vvfdencc++uijzR4YERERBTZp/ViwVgWTvsm/AyYiatca/NPx7bffxh133AGdToe333671uMEQWBARkRERDjvsX6M3RWJiGrW4IDs5MmTNf6diIiIqCbnuH6MiKhejd6HzGazoWvXrjh48KAvxkNERETtxLkCdlgkIqpPowMytVoNi8Xii7EQERFRO3Kee5AREdWr0QEZAMyYMQOvv/467HZ7S4+HiIiI2okjWSUAgE7ssEhEVKsmtTzavn071q5di9WrV6Nfv34ICgryev7HH39skcERERFRYNp3vgiHMkugVgoY3iWitYdDRNRmNSkgCw0NxeTJk1t6LERERNROfPfHWQDA2D6xCA/StPJoiIjarkYFZE6nE//4xz9w5MgRWK1WXHHFFXjhhReg17M2nIiIiFzKrQ78tOs8AODWCxJbeTRERG1bo9aQvfzyy5gzZw6Cg4ORkJCA9957DzNmzPDV2IiIiCgA/XdfBkosdnQK0+PirpGtPRwiojatUQHZ559/jg8++ACrVq3C0qVL8fPPP+Orr76C0+n01fiIiIgowPxndzoA4KYhiVAouCE0EVFdGhWQnTlzBuPHj5e/Hj16NARBQHp6eosPjIiIiAJPkdmGTcdyAQATB8S18miIiNq+RgVkdrsdOp3O6zG1Wg2bzdaigyIiIqLAlHYwC3aniB4xRnSNCm7t4RARtXmNauohiiKmT58OrVYrP2axWPDggw96tb5n23siIqKO6b97MwAAV/eLbeWREBEFhkYFZNOmTav22JQpU1psMERERBS4ii02/HbUVa44vh/LFYmIGqJRAdnixYt9NQ4iIiIKcFuO58HqcKJLVBC6RbNckYioIRq1hoyIiIiapthiw60fb8HiTSdbeyg+czbfDADoEx8CQWB3RSKihmBARkRE5AfbT+Zj64l8vP+/YxBFsbWH4xMZRRYAQFyIrp4jiYhIwoCMiIjIDwrNro7E+WVWHM0ubeXR+EamOyCLNTEgIyJqKAZkREREflBUXrlFzO8n8vDd9rOY9M+NOJRZ3IqjalnpReUAgPhQBmRERA3FgIyIiMgPCj0CsvVHcvHqfw9iz7ki3Pf5Hyg0W1txZC1HzpCF6Ft5JEREgYMBGRERkR8UewRkaw5mocBdwng2vxyPf7s74NeV2R1OZJdUAADiuYaMiKjBGJARERH5gWfJouSGQQlQKwWsO5yD03nmVhhVy8kprYDDKUKlEBARrG3t4RARBQwGZERERH5QtSxRo1TgrxN6IdroyiYVBHjZotRhMcakg1LBlvdERA3FgIyIiMgPpAzZwMRQAMCkgfGICNbCqFMBAEos9tYaWovIKGTLeyKiplC19gCIiIg6AikgmzWmO4rKbbiyVzQAtJ+AzN1hMZYBGRFRozAgIyIi8gMpIIsM1mJk9yj5caNODQAosVRfYxZIpA6L8aHssEhE1BgsWSQiIvIxURTlgCzEoPZ6rv1kyLgpNBFRUzAgIyIi8rFymwM2h6utfai+toAssDNkGdwUmoioSRiQERER+VhRuSv7pVIIMGiUXs9JJYvF7SVDxk2hiYgahQEZERGRj8nlino1BMG7JbyUISutCNyAjJtCExE1HQMyIiIiH6tt/RjQPpp6ZBZbuCk0EVETMSAjIiLyMc8MWVWmdtDUY9/5YgBAtxgjN4UmImokBmRERETNcDbfjIMZxXUeI60hqykgaw9dFv88VwgAGNAppHUHQkQUgBiQERERNZHDKeKWj7bg+g82Ia+0otbjii21Z8jaQ8nin+eKAAD9O4W27kCIiAIQAzIiIqImOpBejPQiCyw2J07lmWs9rsjsCraqtrwHAj9D5nSKcoasPzNkRESNxoCMiIioiTYdz5X/nlNiqfW4ogZlyAIzIDuVV4Ziix1alQI9Yo2tPRwiooDDgIyIiKiJNh/Pk/8utX2vibSGzFRHhszqcMJic7TwCH1PKlfsE2+CWsnbCiKixuJPTiIioiaw2p3YfjJf/jqnzoDMXbJo0FR7Lkijkv8eiFmyPXK5YmirjoOIKFAxICMiImqCPecKUe6R0courqOpRx1t75UKAcHawN0ces/ZQgDAgESuHyMiagpV/YcQERH5h9XuxP/tOIcxvWMQZWzbGwxvPuYqV1QrBdgcIrJLLDBb7Xhv7THYHU4khOkxqX8sgLrb3gOussXSCnvAdVp0OkUcyiwBAPRLYEBGRNQUzJAREVGr+PVQNp76fg8KyqzyY//edgZzftqLR/+9y6fXFkWx2efYcaYAADCyWxQA1xqypbvSsXD9cXyy8STm/nwAN3/8O/IsniWLtQdkQOCVLJ4vLIfZ6oBGqUByRFBrD4eIKCAxICMiolbxztqj+H7HOby4/ID82GZ318ItJ/LkUriWVGyx4bml+9DvhdX4fMupZp0rvbAcADCsSzgA1xqyI1mubNGAxFDEmLQ4llOG1/9UorCOkkUgcPciO5rter9dooKgYkMPIqIm4U9PIiJqFVlFrjbxP+48j60n8iCKIv44VSA/v3D9cVhsDljtzha53uHMEox5az2+2HoapRV2vLBsPzYdy63/hbXIdI+/X0IoACC3tEIOUG6/MBH/mXEJ+sQbUeEQAAA6taLOkkUAKA6wDNnRrFIAQGp0cCuPhIgocDEgIyIiv3M4ReSUVjbB+NvSfTiWXYq8MitUClcAs3J/JgbMXY0hL6Uhr7T2hhkNcTK3DHd88juyiiuQHGHAFT2j4RSBmV/vRHZx7fuH1abEYpMbcPRJMEEQAKcI7DpTCADoEhWM2BAd/u/+YXiirx1/G98Dn0y9ADq1ssbzBepeZEezXQFZ9xjuP0ZE1FQMyIiIyO/yy6xwOEUIAhBmUONYdileXH4QADC4cxjG9I6BKAIVdidKLHYczChp8rXsDifuWrwNuaUV6BVnwn9mXIIP7hiMnrFGFJhtWLr7PJxOEe+uOYr/7s1o0Dmz3EGcUaeCSadGRJCrAYnZ6uq62CXStZ5KpVQg2QhMG5GES7pF1nq+yjVkAVay6C7R7MYMGRFRkzEgIyIiv5MCmshgLaaOSAYAbDiSAwAYmhyGN28cgPduG4Q+8SYAQF5Z0zNkJ3PLcCrPDINGic/vvhAhBjV0aiVuHpoIAFh/JAfrjmTj7TVH8PT//QmnU4TDKcpjrEmGu1wxLkQHAIj26AgZalAjPKj6fmN1CcSmHqIoyhmybsyQERE1GQMyIiLyu+wSV0ATbdTizhFJ0Koq/zm6IDkcIQY1rh0Qj6QIAwB4dWJsrBO5ZQCArlHBXq30R/VwdUfcfrIA32w7CwAoqbDjbIEZC9cfx7BX1mLlvswazymtH4sN0bveh6nyvF0igyAIQqPGaHKXLJYGUEAmdVhUKwX5+0RERI3HgIyIiPxO2kQ5xqRDZLAWNwzuBAAQBFfJokTKNOU3IyA76Q7IUiK927KnRAYhMVwPq8OJ1Qey5McPpBfjv/tcpYs//5le4znlgMwdiHlmyLpGNb58T86QVfi/ZPH9tUdx/+d/NHpTaik71iUyGGp2WCQiajL+BCUiIr/LcgdkUiBz/8guMGpVuCQ1EiEee3WFu9dm5TUjIDtVS0AmCAJGdY+udvzOMwXymrXf3d0fq8oorpIhM+rk57o0JyCrJUP2yW8n8NH6440+b30cThHv/3oMqw9k4d01R7ye259ehLsWb8PIN37FH6fyq71WWj+WGsP1Y0REzcGAjIiI/E4uWTS5ApmUyCBsfPYKLJp2gddx4e7grMBcPSDbeiIPH647Xm9bfKlksUtU9Y2LL+seJf89wp2N+3HneTicriAst9SK4zml1V6XJWfIXOP3LIWs6Tr1Cda63mdNbe9P5pbhpeUH8ep/D2HL8bxGn7suZ/PN8vx9uukUDmUWAwD+s/s8Jry3Eb8ezsGZfDPuXLQNvx3N8XrtgXTXsd2juX6MiKg5GJAREZHfVc2QAa5NkzUq73+WwoPdGbLSyoDMYnPgmf/7E7d+vBWvrzyEVftrXuclqa1kEQAuSo2Q16/NvCLVda0q2bgtJ6pnh+pq6tGsksVymxwMSjzf37trvbNYzSWVHQKubNlzS/fB6RTxdprrOmN6x+DSbpEotzlw/+c75EYn2SUWrHCvrxvu3hibiIiahgEZERH5XY47QxZj0tV5XEQNa8g+3XQS3/5xVv563/miWl9fYrEhp8QV/CXXEJAZNCp8PHUo3r5lAG4c0snruUh3MLi1hqxUllyy6A7I3GvJlAoBncMb3+BCCshO5Jahx9/+i083npSf82wssvVEPn4/0XJZMmkj62Ep4dCrldh+qgB/XboPp/LMMGpVeOeWgVg07QIM6hyKcpsDH65zlU1+8ttJWO1ODO4cigtTGJARETUHAzIiIvK7mjJkNQkzuAIyz5JFKQDr6i4NPJBRXONr7Q4nTuWaAbiCK6mTYVWXdY/C9YM6wahTe3ULvPfSFACu0kjPdWQWm0POokkliz1jTUgM1+OqvrHVsnwN0TUqGD3crePtThHf7zgHwNU8ZPfZQggCMLZ3DABgYQuuJTuW5cqQXdotEveN7AIA+Pe2MwCAyUM6IUirgkalwJNjewAAvt52BrvPFuLLracBuLKKje0oSURE3hiQERGRXzmdInJKK7ss1iUiWArIbHC6S/mkIGti/3gArrVMVRtvfL7lFPr8fRX+9dsJAJUbNdend5xr3zO1UsAdwzpDp1Ygr8yKQ5mVG1NLHSK1KgVC3WvcgrQqrH/yciy4fXCDrlOVTq3EyscvxfqnRgFwNcyw2BxYfcCVHRvcOUwuqdxbR0awsaSSxdRoIx4Y2UXOCgLAlOFJ8t8v6hqBC5LDYLU7cd2CTTBbHegdZ8LlPao3RSEiosZhQEZERH6VV2aFwylCEIDI4Lo3UJYyZA6niKJyG0RRxOk815qwsX1ioFQIyCuzIrvEe+PolfsyUWF3YtkeV9v6mtaP1aSXOyDrHR8Co06NS1JdTT+W7jovH5PpUa7omR1SKJqXKRIEV7ljeJAGdqeII1kl8vqxcX1i5PeQW2ptdIv6mjidIo7JGzsHI0irwlPjugNwZQ1ToyvXwgmCgCfGdJe/HtApBPNvHsDsGBFRC1C19gCIiKhjkTosRgRpoapn/yqNSgGjToUSix35ZitsTifKrA4oBCA1Ohhdo4JwJKsUB9KLvbJtns0qACClgZ0PJw/phA1HcnDvpa7yvZuHdsKag1n4Yec5PDmuB9RKBTKKygFUliu2JEEQ0CfehN+O5mLriTxsO+lqKDKmdyyMOjXCgzTIL7PidF4Z+sSHNOta6UXlKLe5N3Z2r3u75YLO6BIVXGPnxIu6RuLnmZfAoFU2qXEJERHVjBkyIiLyq+wGrh+TeG4OfTrPVa4YH6qHVqWUM1o7zxTgb0v34rvtZ1FkrmzkIWlohiwhVI//e+giXNU3FgBwec9oRAZrkVtqxf8OZSO3tALL/3RtGi11WGxpfRNcgdbiTadgc4hIjjDI45fWuEnz0ByeGzt7BsYXJId77QXnqV+nEAZjREQtjBkyIiLyK6lDYYyp4QHZ6Twz8kqtKLHYAFQGWL3jTPjP7nR8tP4ErA4nDJrzctASF6LD4KQwbD+ZjwuSm9YJUK1UYPKQBHy0/gTm/LgXJRV2ed+uoU08Z336ujNfUmv9UR7rtJLCDdh1prBZAdnZfDPeXnNE7lzJjZ2JiFoXAzIiIvIrab1XfQ09JFLr+wKzFecKXIGIFHT1jndlyKwOV5BktjrkdWOp0cH4522DAKBZa51uGZqIj9afkDsrDugUgqfG9cQl3SKbfM669E0weX19WY/Kzas7R7gCUWkdXWPZHU7M/Hon9pyrbAzSLZoBGRFRa2JARkREfiVlyBpasig19sgvs+KUOzOU7A5MpJJFT//Z7QrIukUbW6TpRJeoYCycMgTpheUY2T0SXaOCfdrMonO4QV43p1UpMKJLhPxccjNLFj/acAJ7zhXBqFMh2qjFmXwzRveKaZFxExFR0zAgIyIiv5IyZNENzJCFuzsx5pVacSrXlRmSArLIYC1G94rBuQIzLusehY82nJA7EKa2YOZHWlPmD1Jjj60n8jGiawR0aqX8nJQZPJPf+IDsfGE53llzBAAw99o+uH5QAkSx+d0hiYioeRiQERGRX2U3MkMWITf1qJAzQ8mRlRs4fzJtKERRxPZTBfhowwn58W4BvDZqbO9YbD2Rj5uGJHo9nuQORNOLylFotuLnPen443QBtCoFHhqVWmfzkr3nimBziOgZa8T1gxIgCALYtZ6IqPUxICMiIr9q7BoyqWTxaHYpSivsEAQgMdzgdYwgCOjfKQQapUJeT5YawN0Ap1+UjOsHJSAsyHuftoggDYI0SpRZHbj+g804mVu5luynXefx1LgeuH9k1xrPKZWKpkQGcf8wIqI2hG3viYjIb5xOUW5JH93ALosR7pLFAxnFAID4EFfL+6p0aiX6dXJ1KIwM1lQLZgKJQiHUOH5BEOTGHidzy6BTK/DE6O4Y1SMKNoeIt9OOQhTFGs8pdW2M9VG7fiIiahoGZERE5Df5ZivsThGC4Fr/1RDhQa7jpDhjaHJYrcdKz7Xk+rG2RmrsAQAPjOyKx0Z3w8IpQwAA5TYHii32Gl+X6cMNrYmIqOkYkBERkd9IZXMRQRqolQ37JyjcUJkp6pcQgnnX9q312Fsv6IxecSZMGZ7UvIG2YdI6srgQHR68zFWeqFMrYdK5ViHklFhqfB0zZEREbRPXkBERkd/IHRaNDQ8KEsL0uDA5HCqlgA/uGIwQg7rWY1Mig/Dfxy5t9jjbspuGdsL+9CI8PCoVek1l6WaMSYdiSymyiiuQGm2s9rpMdzAcF6L321iJiKh+DMiIiMhv5A6LDVw/BgBKhYDvHhzhqyEFnK5RwfjinmHVHo8x6XA0u1TOQnoSRVHOkMUxQ0ZE1KawZJGIiPwmu9jdYbERGTJqGGkbgSz3HHsqMNtgtbu6TzYmGCYiIt9jQEZERH6T5V7fFMOgoMVJG21n17CGLLOocu1eTR0qiYio9TAgIyIiv5GyN1Hs9NfipCA3u4YMWWaxu8MiyxWJiNocBmREROQ38qbQRmbIWprUKKWmNWRcP0ZE1HYxICMiIr+pbOrBwKClyRmykhoyZGx5T0TUZrWZgOy1116DIAh4/PHH5ccsFgtmzJiBiIgIBAcHY/LkycjKyvJ63ZkzZzBhwgQYDAZER0fjqaeegt3uvSnmunXrMHjwYGi1WqSmpmLJkiXVrr9gwQIkJydDp9Nh2LBh2LZtmy/eJhFRh+V0isiRMmRcQ9biYkyVGTJR2kXbrTJDxpb3RERtTZsIyLZv346PPvoI/fv393r8iSeewM8//4zvv/8e69evR3p6Om644Qb5eYfDgQkTJsBqtWLz5s347LPPsGTJEjz//PPyMSdPnsSECRNw+eWXY/fu3Xj88cdx7733YtWqVfIx3377LWbNmoW///3v2LlzJwYMGIBx48YhOzvb92+eiKiDyDdbYXeKEAQgMpgBWUuLcpeBVtidKC73/sWklCGLYWaSiKjNafWArLS0FHfccQf+9a9/ISwsTH68qKgIixYtwltvvYUrrrgCQ4YMweLFi7F582Zs3boVALB69WocOHAAX375JQYOHIirr74aL774IhYsWACr1QoAWLhwIVJSUjB//nz06tULM2fOxI033oi3335bvtZbb72F++67D3fddRd69+6NhQsXwmAw4NNPP/XvZBARtWNSs4mIIA3Uylb/56fd0amVCNG7Ns3OKnFlyeb+vB9Xzl+H/elFALiGjIioLWr1jaFnzJiBCRMmYPTo0XjppZfkx3fs2AGbzYbRo0fLj/Xs2ROdO3fGli1bMHz4cGzZsgX9+vVDTEyMfMy4cePw0EMPYf/+/Rg0aBC2bNnidQ7pGKk00mq1YseOHZg9e7b8vEKhwOjRo7Fly5Zax11RUYGKiso6/eLiYgCAzWaDzWZr2mS0EOn6rT2O9oxz7HucY9/z9xyfySsB4MqOdZTvq7/nONqoQVG5DekFZfhxx1ks3nTK6/lIg6rdzT1/Vvge59j3OMe+5+85bsx1WjUg++abb7Bz505s37692nOZmZnQaDQIDQ31ejwmJgaZmZnyMZ7BmPS89FxdxxQXF6O8vBwFBQVwOBw1HnPo0KFax/7qq69i7ty51R5fvXo1DAZDra/zp7S0tNYeQrvHOfY9zrHv+WuOvzyqAKBAqLMIK1as8Ms12wp/zbGiwjXHr/60HYeLXFnIvmFO7C8QoFYAf25dj0PtdBsy/qzwPc6x73GOfc9fc2w2mxt8bKsFZGfPnsVjjz2GtLQ06HSBV0Ixe/ZszJo1S/66uLgYiYmJGDt2LEwmUyuOzBWRp6WlYcyYMVCr/7+9O4+Pqr73P/6amUz2jSRkIxASgkBYAgSBgBuLLFKvVmqVUqRo9UrBK2L1an8WWttevfZWpRW1rthW69a6gQoIAgph38IWIATCkj1k32fO749JBiJbCJlMEt/Px4OHk3O+c853PhwG33y/53usbu1LZ6Uau55q7HptWePTlbU8smUdYOeXP0whKSbIpedrL9r6Ol5TlUb6zmxnGJtzQzzzxiWwP9sxOtkvKsDlfWhr+q5wPdXY9VRj12vrGjfOnmsOtwWybdu2kZeXx9ChQ53bbDYb69at44UXXmD58uXU1tZSXFzcZJQsNzeXyMhIACIjI89ZDbFxFcaz23x3Zcbc3FwCAwPx8fHBYrFgsVjO26bxGOfj5eWFl9e5N6VbrdZ28wepPfWls1KNXU81dr22qPEnu45TW29nQLdAknuGYjKZXHq+9qatruPI4DMzNPpFBfLQjX3wsJgZ1CPE5ed2N31XuJ5q7Hqqseu1VY0v5xxuu6t63LhxpKWlsXPnTuevYcOGMX36dOdrq9XKqlWrnO9JT08nKyuLlJQUAFJSUkhLS2uyGuLKlSsJDAwkMTHR2ebsYzS2aTyGp6cnycnJTdrY7XZWrVrlbCMiIi1ntxu8szkLgOkjYr93Yawtnf3A7d/f2h8PLZ4iItLuuW2ELCAggAEDBjTZ5ufnR2hoqHP7Pffcw/z58wkJCSEwMJAHHniAlJQURo4cCcCECRNITExkxowZPPPMM+Tk5PDEE08wZ84c5+jV/fffzwsvvMCjjz7K3XffzerVq3n//fdZtmyZ87zz589n5syZDBs2jOHDh/P8889TUVHBrFmz2qgaIiKd1/6cUjILKvD1tPAfSdHu7k6nNiohDB+rhRkpsSTHdv5RMRGRzsDtqyxezHPPPYfZbGbq1KnU1NQwceJEXnzxRed+i8XC0qVLmT17NikpKfj5+TFz5kyefPJJZ5u4uDiWLVvGQw89xKJFi4iJieG1115j4sSJzjZ33HEH+fn5LFiwgJycHAYPHsyXX355zkIfIiJy+VIzCgEYGR+Kn1e7/munw7sqIoA9v52IxaxRSBGRjqJd/c24Zs2aJj97e3uzePFiFi9efMH3xMbGXnK1rhtuuIEdO3ZctM3cuXOZO3dus/sqIiLNs/5wAQCjeoW6uSffDwpjIiIdiyaXi4iIy9TZ7GzOLAJgVK8wN/dGRESk/VEgExERl9l9opiKWhshfp70jex8S66LiIhcKQUyERFxmQ2HHfePpcSHYtZUOhERkXMokImIiMusz3DcP5ai+8dERETOS4FMRERcos5mZ+fxYsCxwqKIiIicS4FMRERc4mBuGdV1dgK8PYgP83N3d0RERNolBTIREXGJ3SdKAEiKCdb9YyIiIhegQCYiIi6xq2G64qCYIPd2REREpB1TIBMREZdovH8sqXuwW/shIiLSnimQiYhIq6usredQXjngmLIoIiIi5+fh7g6IiEjbyCurZu47O/jJ8B7cOqRbi49jGAalVfUE+VqbbP9yTw47jp/mdEUt3bv4YrMbRAR6ERnkfaVdFxER6bQUyEREvifWHMhnc2YRNfX2FgUyu91gyYajvL3pGBn5FSy8OZFZo+MA2HK0iPv/se2c92h0TERE5OI0ZVFE5HuioKIGgOziqha9/+3NWTy5dB8Z+RUAPP3FATILHK//vf0EAEN7BDN1aIzzPbp/TERE5OIUyEREvicKymoByCuroabedt42lbX1bDxSSGVtfZPtdTY7L6/JAODea+O4JiGMmno7j/1rN9V1NpbtzgbglxP68KcfJ/HmrKuZPqIHd17d3YWfSEREpOPTlEURke+JwoYRMoCckmqiAz2dPxuGwYtrMnhl3RFKqur4z+vjeXxyPxZ8socNGYVckxDGyeIqwvw9eXhCH/LLapjw3Do2ZRbxszc3U1pdT3iAFyPiQwEY0yecMX3C2/wzioiIdDQaIRMR6QSKKmq5adE3PPLBLqrrzj/6VVhe63x98jvTFjdkFPLH5emUVNUBkHaiBMMw+GDrCQ7nlbNkw1EA7r4mDm+rhe4hvvz2lv4AbDxSBMB/JEVj0QOgRURELosCmYhIJ/DxjpPsyy7lg20nmPbqRo4XVZ7TpqD8zAjZydNNA9k3hwoAiA31BeDE6SqKKmqpOivchfh5MmNkrPPnHw/rzi8nXOX8+UpWbhQREfm+0pRFEZFO4Is92c7XO7KKue6PXzOubwR/+nESQT6O5ekLzhohO1Vc3eT9qUcKAfjR0Bj+tPIg2SVVHGsIdZGB3iy5+2r8PD0I8G661P2cMQkEeFups9npHx3oks8mIiLSmWmETESkg8strWbrsdMAvP3zEVzbOwzDgK/25/LXtY6FOGx2g6Kz7iE7ddaUxbLqOtJOFAOOUS4Ps4k6m8H2hmN2D/Ghb2Qg3UN8zzm3yWRi5qie/PzaeEwmTVcUERG5XApkIiId3PK9ORgGDOkRzOiEMP5+zwieuyMJgI92nMRuNyiurMVunHnP2feQbTlWjN2AnqG+dA/xdT7IeWPDqFlMl3ODmIiIiLQOBTIRkQ6uccn5KQOjnNsmD4gi0NuD7JJqUo8UUlhR2+Q9Z4+QbWpYlCOll2OFxJguPo7tmUVNfhYREZHWp0AmItKBldfUs+WoIzhN7B/p3O5ttfCDpGgA/rXtBAVljumKPlYL4Bgh+2p/Hq+nm/m0IdCNbFiyvluwY0SsrNrxLLLuGiETERFxGQUyEZEObO/JEuwGRAV5n3OP19ShMQB8sSeHrIYFOvpFBWAyQU29nYc/TGN3kZmC8lo8zKZzRsgaaYRMRETEdbTKoohIB7bnVCkAA7oFnbNvaI9gugX7cLK4ihX7cgGICnL8nFtaQ2WtjVAvg3vH9GFAty6EBzjuHet2TiDTCJmIiIirKJCJiHRge06WADDwPIHMZDKRHNuFk8VVrD/seM5YmL8n0cE+5JY6pjCO72bnntE9sVrPLGd/9oiY2QRRwd6u/AgiIiLfa5qyKCLSgTUGsgHdzv8MsMHdgwHHFEWAUH8vugU7AleYvydXdzXOeU9M8JkRsaggH6wW/VUhIiLiKvpbVkSkg6qsrScjvxw4/5RFgKSGQNYozN+L4XEhAPzi+nis5/lbIDLIG3PDI8V0/5iIiIhracqiiEgHtT+7FLsB4QFezvu/vqt/dCAeZhP1DQ8hC/X35MZ+EYzvF0FXPw8+/3zPOe/x9DATEehNdkm17h8TERFxMY2QiYh0UGknLnz/WCNvq4V+UWemM4b5e2I2m4gOvvjIV+PImEbIREREXEuBTESkg0o76Vhhsf9FAhlAUvcz+8P8vZp17Kt7hjT5r4iIiLiGApmISAe0ObOIz9McD3Qe3P3igWxw9y7O16HNDGSPTOzDlv83nmt6h7W8kyIiInJJCmQiIu2A3W7w4prDbDxSeMm2e06WMOvNzVTV2bjuqq5c17vrRdsP7REMQICXB36elmb1x2Qy0TWgeeFNREREWk6LeoiItANf7c/lmS/T6eJrZeOvxuHlcf7gZBgGv/5kDxW1NlLiQ3llRjIel1iWPr6rP0/fNpCuAV6YTCZXdF9ERERaSCNkIiLtwDeHHA9uPl1ZxxdpORdst/ZgPjuyivG2mlk0bTDe1uaNeN05vAfj+kW0Sl9FRESk9WiETESkHVh/uMD5+h8bj3HrkG4AbDhcwLZjp4nr6kdUkA/PrTwIwE9HxF5wqXsRERHpOBTIRETc7GRxFUcKKrCYTZiArcdOcyCnFH8vD2Yt2UJNvb1Je2+rmf+8vpd7OisiIiKtSoFMRMTNGkfHBsUEERXkzedpOSz8ZC8B3lZq6u30DPWli58nBeU1VNXamX1DLy24ISIi0kkokImIuFljILsmIYwpg6JYd7CATZlFAJhN8NJPk5s83FlEREQ6Dy3qISLiRqeKq5wLeoxOCKNvZCBv3T3cuTz9T0fGKoyJiIh0YhohExFxgeNFlaw/XMDU5Bis31mWfuORQp5dcZDIIG82ZBRQVFFLdJA3QxqeF5Yc24V//WIU3xws4KcjY93QexEREWkrCmQiIi7wyIe72HikiOOnK3lkYl/ndsMw+M2nezmQU+bc1i8qkFdmJDd59ljfyED6RmpkTEREpLNTIBMRaWU5JdXOe8BeXZfJ7cnd6RnmB8C6QwUcyCnD19PCnDEJeFrMTB/ZA19PfR2LiIh8H+keMhGRVrYsLRvDcLyutdl5cuk+jIYNr6zLAODOq3swZ0wC914XrzAmIiLyPaZAJiLSypbuPgXAXSmxWC0mVh/I42+px1h7MJ/1hwuxmE3cfU1P93ZSRERE2gX9s6yISCs6XlTJjqxiTCaYOyaBmC4+/M/nB3hy6T7MJkeb24Z0I6aLr3s7KiIiIu2CRshERFrR8r05AIyICyE80Jt7r41n6tAYbHaDOpvBlEFR/O7WAW7upYiIiLQXGiETEWlFjQ95Ht8vAgCTycT/3DaAYF8rEYFe/PyaeMyNQ2UiIiLyvadAJiLSSuptdrYcPQ3AyPhQ53YvDwu//kGiu7olIiIi7ZimLIqItJK9p0opr6kn0NuDflF6hpiIiIhcmgKZiEgrST1SCMCI+FAsmpYoIiIizaBAJiLSSjY2BLKzpyuKiIiIXIwCmYhIK6i32dmSWQTAyPgQN/dGREREOgoFMhGRVrAvu5SKWhtBPlb6Rer+MREREWkeBTIRkVZwqrgagPiuflrWXkRERJpNgUxEpBWUVtUBEORjdXNPREREpCNRIBMRaQUlCmQiIiLSAgpkIiKtQIFMREREWkKBTESkFSiQiYiISEsokImItAIFMhEREWkJBTIRkVbQGMgCFchERETkMiiQiYi0Ao2QiYiISEsokImItAItey8iIiItoUAmItIKNEImIiIiLaFAJiJyhQzDUCATERGRFlEgExG5QpW1NurtBqBAJiIiIpdHgUzcos5mp7iy1t3dEGkVpdWO0TEPswlfT4ubeyMiIiIdiQKZuMXvl+4j+fdfsedkibu7InLFzp6uaDKZ3NwbERER6UgUyMQtVuzLxWY3WHsw391dEbliJZW6f0xERERaRoFMLkt1nY1lu7OprrO1+BhFFbVkl1QDcCCnrLW6JuI2eii0iIiItJQCmVyWP61IZ84723ni4z0tPsb+7FLn6wNnvRbpqBTIREREpKUUyKTZauvtfLjtBAD/2n6CAzktC1N7T525b+xIQcUVjbaJtAda8l5ERERaSoFMmm3V/lxON9wrYxjwzJfpLTrOvlNngpzNbnA4r7xV+ifiLqXOQObh5p6IiIhIR6NA9j1hGAYr9uZw4nTleffvPVVCXmn1RY/x/tbjAEwZGIWH2cTqA3ms2p972X3Z1zBN0dPiuPx0H5l0dBohExERkZZSIPueWLU/j/v+vo2Jz63jg63HMQzDuW/r0SJu/su3TH9tU5PtAPU2Ox/tOMGvPkpzroj4y4l9mDmqJwAPvbeTrMLzh7yz5ZZWM/+9nby7OYuM/AoAxieGA7qPTDo+BTIRERFpKc2v+Z74Oj0PgIpaG498uJvFXx/mlsHdmH1DLxatOoTdgEN55ew+UcKgmCBSjxSSnlPGO5uyOHTWlMKU+FDiwvx4dFIfth07zc7jxcx+exufzBmNh+X8+T6vtJppr2zkSEEF/95xEoBQP0+u692Vz9NySM/VCJl0bApkIiIi0lIKZN8TGzIKAZiQGMG6Q/kcLaxk0apDrEnPY9eJM4tsfLbrFO9uOc4/N2c5twX7Wrnj6u5cFR7A2L6OUS0vDwsvTh/KxOfXsfdUKRuPFDE6IZTUjELCA73o1dUfk8lEcWUt0151hDEvDzM19XYAEqMD6RcVCDhWXaypt+HlYWmrcoi0KgUyERERaSm3Tll86aWXGDRoEIGBgQQGBpKSksIXX3zh3F9dXc2cOXMIDQ3F39+fqVOnkpvb9J6lrKwspkyZgq+vL+Hh4TzyyCPU19c3abNmzRqGDh2Kl5cXCQkJLFmy5Jy+LF68mJ49e+Lt7c2IESPYvHmzSz6zO5wqriKzoAKzCf54exLbnriR/7s9CW+r2RnGYkN9AXhv65kwNr5fBL+ccBVrHxnD45P7MTU5hi5+ns7jRgf78INB0QAs3X2Kv288xk9e28T4Z9dx9R9W8ca3mcz+x3Yy8iuICvJmxUPXMWVgFAAj40O5KiIAkwkKymsZsHA5//HCt/z64z1sO3a6LcsjcsW07L2IiIi0lFsDWUxMDE8//TTbtm1j69atjB07lltuuYW9e/cC8NBDD/HZZ5/xwQcfsHbtWk6dOsVtt93mfL/NZmPKlCnU1tayYcMG3nrrLZYsWcKCBQucbTIzM5kyZQpjxoxh586dzJs3j5///OcsX77c2ea9995j/vz5LFy4kO3bt5OUlMTEiRPJy8tru2K4UOPo2MCYYIJ8rPh5efCj5Bhen3k1Xh5mrBYTr8wYRoCXB2XVjjA7dWgMr80cxtyxvS/6r/43D3IErC/35vDSmgwALGYTBeU1PLl0H6lHCvHztPDmrKuJDfXjz9OG8O9fjOLea+Px8bTwixt6Eexrpc5msPtECX/feIypL23grjc2X3KREXDc42azG5dsJ+JKJVWOPzcaIRMREZHL5dZAdvPNN3PTTTfRu3dvrrrqKv7whz/g7+/Pxo0bKSkp4fXXX+fZZ59l7NixJCcn8+abb7JhwwY2btwIwIoVK9i3bx//+Mc/GDx4MJMnT+Z3v/sdixcvpra2FoCXX36ZuLg4/vSnP9GvXz/mzp3Lj370I5577jlnP5599lnuvfdeZs2aRWJiIi+//DK+vr688cYbbqlLa1l3qIC/rDrE8r05AIzuFdpk/+iEMD5/8Fo+mXMNfSIDuDExAgAfq4VHJ/Vp1jmGx4UQ5u9JcWUd2SXVhAd4sWvhBP7wwwEE+1rxMJv487Qh9I10TE+0mE0M7dEFTw/HpffIxL7s+PWNrHtkDH+ZNoQfJcdgMZtYdzCfB/6546Jhq7rOxtSXU7n2f1dTXlN/wXYirmQYxlnL3iuQiYiIyOVpN/eQ2Ww2PvjgAyoqKkhJSWHbtm3U1dUxfvx4Z5u+ffvSo0cPUlNTGTlyJKmpqQwcOJCIiAhnm4kTJzJ79mz27t3LkCFDSE1NbXKMxjbz5s0DoLa2lm3btvH4448795vNZsaPH09qauoF+1tTU0NNTY3z59JSx0qBdXV11NXVXVEtrlTj+f/fx3vJKT3TxxE9g8/pW49gL+d77hrZnU2Zhcy+Pp4QH0uzP8fExAje3uxYEn/WqFi8zAY/HhrNTf3DKauuJyrI+5LHigq0EpXYlUmJXZmV0p3bX9nMpswinvxsD/5eHoT5e3J7cgzHiypZlpbDTQMj+WxXNruOFwOw8XAe11/VtVn9bQ2Nn8fdv9edWUeo8Yp9uTz31WFqbY57I/2spnbd3+/qCDXu6FRj11ONXU81dj3V2PXausaXcx63B7K0tDRSUlKorq7G39+fjz76iMTERHbu3ImnpyfBwcFN2kdERJCT4xjxycnJaRLGGvc37rtYm9LSUqqqqjh9+jQ2m+28bQ4cOHDBfj/11FP89re/PWf7ihUr8PX1bd6Hd6F6O03CmLfFIG/fJj6/xLOcH+0H5O3m8893N/tcoRUAHvhaDEJO7+Pzz/c12b+j+d12uqW7iX9mWHgr9cziIotW7Ke0FuyYeGltBo4V+k0AvL96GxWH7S040+WxG3CkFGIDwGqGlStXuvyc33fttcb7Tpt49YAZOyasJoPRkQbrVq1wd7dapL3WuDNRjV1PNXY91dj1VGPXa6saV1Ze+rFQjdweyPr06cPOnTspKSnhww8/ZObMmaxdu9bd3bqkxx9/nPnz5zt/Li0tpXv37kyYMIHAwEA39syRyN/51HGxeVvNPH/7IMIDvRjYLchl50zYk0OPEF/6R7fOZ59sGBif7WdNej7JsV3YcvQ0eWWOgNkz1JejDc8+6+Jr5XRlHeVeYdx007DLPs/GI0Xkl9c474W7lDfWH+UvGw8yJCaQO6OKuHnyjVitmqbmCnV1daxcuZIbb2x/NU7PKeNXr27Gjo1bkqJY+IO+BHi3rz42R3uucWehGrueaux6qrHrqcau19Y1bpw91xxuD2Senp4kJCQAkJyczJYtW1i0aBF33HEHtbW1FBcXNxkly83NJTIyEoDIyMhzVkNsXIXx7DbfXZkxNzeXwMBAfHx8sFgsWCyW87ZpPMb5eHl54eXldc52q9XaLv4gFdU6Ro66BfswaVA3l5/vP4Z0b/VjPj01yfm6rLqOD7aeoF9UICPjQ/hk5ym2Z51m8oAopr26kV0nSjCZLRd8Ftr5FJTX8PO/b6em3k5sWADJsV0u+Z5/78gGYMeJUk4XW7h+rJ1IX/f/fndm7eXP1Nle35BFRa2NlPhQ/nj7YOc9kR1Ve6xxZ6Mau55q7Hqqseupxq7XVjW+nHO0u/+LsNvt1NTUkJycjNVqZdWqVc596enpZGVlkZKSAkBKSgppaWlNVkNcuXIlgYGBJCYmOtucfYzGNo3H8PT0JDk5uUkbu93OqlWrnG06otMNsxW7dXH/9MnWEOBt5e5r4kjpFYrJZOLWId148pYBDI8LIcDLg4pa22U/YPpvG446n4v23pasS7SGAzmlpOeWYbWYCPLx4Gi5icl/2cBbG46y63gxe06WkJpR6FxgpKrWRnZJ1eV/WGn3tmc5Hs0w+4ZeHT6MiYiIiHu5dYTs8ccfZ/LkyfTo0YOysjLeeecd1qxZw/LlywkKCuKee+5h/vz5hISEEBgYyAMPPEBKSgojR44EYMKECSQmJjJjxgyeeeYZcnJyeOKJJ5gzZ45z9Or+++/nhRde4NFHH+Xuu+9m9erVvP/++yxbtszZj/nz5zNz5kyGDRvG8OHDef7556moqGDWrFluqUtrKKo5M0LWmVnMJgb3COabQwVszyomMSqQf28/yfK9OcwaHceIuBBWHchjQ0YBh/PKSQj3Z9rwHsR08eFvG485j/PZrmx+/YPEi047+3TnKQBu6BPOg2Piue/NDZyqrGPhp3ubtIsI9OKnI2L528ZjFJbXsOjOIdycFO2aAkibO11Ry7GGKbNJMcHu7YyIiIh0eG4NZHl5edx1111kZ2cTFBTEoEGDWL58OTfeeCMAzz33HGazmalTp1JTU8PEiRN58cUXne+3WCwsXbqU2bNnk5KSgp+fHzNnzuTJJ590tomLi2PZsmU89NBDLFq0iJiYGF577TUmTpzobHPHHXeQn5/PggULyMnJYfDgwXz55ZfnLPTRkTSOkMV06dyBDGBojy58c6iAD7edYOmuU2zKLAJg5f5c4kL9OFJQ4Wz7zaEC3lx/lCAfKyVVdfQI8cXDYuJIfgXvbj7O6IQw4rv64W21NDmHYRh8ussRyG4ZHE2fyAB+OdBGbnAiaw8VkJHvOIfdbpBbWsOfVh50vvfhD3YRHexNcmyIq0shbWDXiWIA4sP8CNJ0VREREblCbg1kr7/++kX3e3t7s3jxYhYvXnzBNrGxsXz++ecXPc4NN9zAjh0XX+tv7ty5zJ0796JtOpLGQBYd7O3ejrSBxnu/GpfA97aaGRkfypr0fI4UVODnaWFqcgy9IwJYf6iAr/bnUtLw3Kj7rounqtbGHz7fzx8+3w84RrhmX9+L0QlhRAf7UFtv55nlBzhxugo/Twvj+kYAdixm+Pk1PZk9prezL9V1Np7/6hCf7TrFHVd3J+1kCSv35fKff9/G2kfG4Ofl9ts25QrtbLjOkroHu7UfIiIi0jno/w47qTNTFjvHPWQXMzI+lIn9IyiurGNEfCi3J8fQPcSXr9Pz2HuyhGnDexDq75jCOmNkLBU19ew6UUxpVT0T+0dwurKOV745QkF5DT5WC7mlNfzms33nPde88Vfh42mhru78S+x7Wy08Nrkvj03uC0BlbT2TF33DscJK/rX9BHel9HRJDaTtNAb/wQpkIiIi0goUyDohu92guNbxutv3YMqip4eZv844d8n7MX3CGdMn/Jztfl4ejOoV5vw5xM+T1MfGYnM82Iz3txznX9tPcjiv3LlAR2yoL0/dNrDJ+5rD19ODu0fHsfDTvby5/ig/HRGL2Wy6rGNI+2EYhkbIREREpFUpkHVCeeU12AwTFrOJiIBzl+aXc3lYzM4/DDNSejIjpSeGYVBVZ8MwwNfTgsnUsiD1o+QY/m9FOpkFFaw9mM+YvueGROkYjhdVcbqyDk+LmX5RAe7ujoiIiHQCWq+5E8ourgYgMtDrsp7LJU2ZTCZ8PT3w8/JocRgDx4jcnVc7ntP2t9SjrdQ7cYcNGQUA9IsOxMvDconWIiIiIpem/1vvhE4WO559Fd3Jl7zvSKYMcix7vz/78p6VJu5zrLCCv6cepajCMf+3tt7Oi2syAJjU/8IPjRcRERG5HJqy2AmdbBghiw7q/CssdhRRDb8X+eU12OwGFt1H1u799rN9rD6Qx9NfHOCuUT3xsVrIKqokzN+LmaNi3d09ERER6SQUyDqhUyWNI2QKZO1FqJ8nZhPY7AaFFTWEB+j3pr1Lz3GMZlbU2nipYWQM4IGxCfh66qtTREREWoemLHZCjSNk3TRlsd3wsJidS+/nlda4uTdyKVW1NufU3/+7PYkRcY6Hesd39ePO4d3d2TURERHpZPTPvJ3Qgil9+cCylut6X94S7eJaEYFe5JfVkFdWDQS5uztyEUcLKwAI8rEydWg3fpQcw/GiSgJ9rFrMQ0RERFqVAlkn1CPEl37BhvO+JWkfIgK82UMpuRoha7Hskip++cEu7h4dx7h+EedtU1xZy5INR8kqrKSy1kZcVz/G9wsnOTak2ec5ku8IZPFd/ZwrbHYP6fwPWRcREZG2p0Am0kbCAx0BObe02s096bje33KC9YcLycir4NreXfH0cMy6LiivwWIy0cXPk2dXHuRvqceavO/ltRl8eH9Ks0PZkfxyAOLC/Fr3A4iIiIh8h+4hE2kj4Q0P6c4ra/0Rsve3HGfF3pxWP257k3ayBICc0mqWpZ0CHAF33J/WMuH5deSVVfPxjpMA/PyaOBbenMiIuBAMA37z6T7sdqNZ58kscIyQ9erq74JPISIiInKGAplIG4loGCHLa+URsuNFlTz6r93Mfns7x4sqW/XY7U3ayWLn61fWZWIYBs+uOEhJVR35ZTXMfGMLpdX1dAv24Vc39WPW6Dhe+MlQArw8SDtZwgfbjjfrPBkNgSxeI2QiIiLiYgpkIm0kItAxQtba95AdK3SEMJvd4JV1R1r12O1JXmk1uaU1mE3gY7WwP7uUJz7ew/tnhaz92aUA/Cg5BnPDs966BnjxX+N6A/DkZ/tIzSi86HkMwyCzccpiVwUyERERcS0FMpE20vjssda+h+z46TOjYu9tPd6wimPn0zhdMSHcn7uv6QnA25uyMAy4aWAkQ3sEA2Aywe3DYpq8d+aonoxOCKWi1sbMNzfz7aGCC56nsKKW0up6TCboGapAJiIiIq6lQCbSRhpHyArKa7A1816m5jhxViCrrbfzxrdHW+3YV8JuN6iqtbXa8XafcASyAd2CePjGPvxl2hD6RgYQHuDFY5P68f+m9MPTYuamAVHEdGm6IqKnh5nXZ17N+H7h1Nbb+d3SfRjG+X8PGu8fiw7ywduqJe5FRETEtRTIRNpIqL8XZhPYDSgsb71piydOOx5gPLCb49lm3xzKb7VjX4lffZRGvwVfMv21jRcdkWquPQ0jZIO6BWE2m7g5KZov513Hpl+No0eoL8mxIWz61Tiev3Pwed/vbbXwpx8PxsvDTHpuGTuOF5+3XeMKi/GarigiIiJtQIFMpI1YzCa6BrT+fWSNC3lMSHQ8l+toQcUFR3/ayrHCCt7b6ri3a/3hQn725maONTxsubmyS6rZkm+irLoegN0NgWxgTHCTdo3PCQPo4ueJ1XLhr7UgHytTBkUB8O7mrHP219ns/H2jY8n8vpEBl9VfERERkZZQIBNpQ664j6xxhGxUQihmE1TU2lyytP7leHP9UQwDRsSFMLh7MPV2g48alqNvroc/TOMfhy2Me+4b7lmyhfwyx4IeiVGBV9S3acN7APDZrmzKqusAx1TPvLJqnlt5kD0nSwn2tXLvtfFXdB4RERGR5tCDoUXaUESgF2knW+9ZZNV1Z8JXXJg/3UN8OVZYyZH8Cucy+22tpLKO9xtGxx4Y25v88mp2vlfMxztO8uC43k1GtC4kv6yGrcdOA3C6so5VB/IAGNs3HB/PK7uva1hsFxLC/TmcV869f9tKSnwYb27IpLiyztnm97cOcD7IW0RERMSVFMhE2lDj/+S31gjZyWLH6Jifp4Uuvlbiw/wcgaygnJReoa1yjsthGAb/tyKdylobfSMDGJ0QSmWtDR/rHo4WVrLjeDFDe3S55HFWH8jFMCDGz2De5EEUVNSREh/KgIb75K6EyWTi0Yl9mPvPHWw8UsTGI0XOfWaTYwTtB4Oir/g8IiIiIs2hQCbShiIapixmtdIDnBunK8Z08cVkMhEX5s/X6flk5l/e/VqXq6bexsc7TrIsLYfs4iquigigb2QAhRW1znuwHp7QB5PJhJ+XB5MGRPLRjpP8fuk++kcHUVtvx9PDzIPjexPm73XO8VfuywVgUIidW5KisFqtrdr/Cf0jWTX/ep5Zns7hvHJ+fk0ctwyOxuMi95+JiIiIuIICmUgbujrOMTr0dXoedTb7RRegKCiv4VhhBcmxIRds07jkfUwXH+DMyoCNS7e7gmEYzH1nhzM0ARzKK2dZWrbz54U3J3JjwyIjALcN7cZHO06yPauY7VnFzu3ZJVW8etewJtMYq2ptfNOwKuOALq5bnKR7iC9/mTbEZccXERERaQ4FMpE2NCIulDB/TwrKa9mQUcj1V3U9bzu73eCu1zezL7uU3986gJ+OjD1vu8YRsu4hjuduxYc5AtkRFwayT3edYuW+XKwWEw+O603/6CAO5ZVxILuMjPxyfjAomlmj45q855qEMH536wBOnq7C08OM2QSLvz7MV/vz+GJPDkndg/H39CDI18ryvTnU1NvpFuxNtG+5yz6HiIiISHugQCbShixmE5MGRPKPjVl8vjvbGchOFldhMZmIDHJMaVyWls2+7FIAnvxsH0kxwQyMOff+qcYl7xtHyOIaRsiyiiovOQLXyDAMXlyTQbCvlekjzh/8GuWX1bDw070A/NfY3swd2xuAMX3DL/o+k8nEjO+ESrvd4M+rD/OLt7cDYLWYGBYbwqbMQgAm9Y/AZFcgExERkc5NgUykjd00MIp/bMxi+b4cbkjryntbj7Mm3fEw50ExQdyeHMOSDUcB6OJr5XRlHfe8tYUFNycyZWAUJpOJ40WVrD9cwO4TjmdzNQayyEBvfKwWqupsHC+qJL6r/yX7syGjkD8uTwegV1d/RsZfeDGQ5786SHFlHf2iArn/hl5XUgZ+MSaBL/bkcCivHIvZRJ3NIPWII4z9cEg35o7pxbpVGVd0DhEREZH2ToFMpI2dPW1xdsPoUOMtVLtPlDhDVrCvlaX/dS0zXt/EkfwK5r6zg98G7CM6yJvdJ0s4+9nPPRumKjoW9vBjX3YpmQUVzkBmGAZbj52mexdf5yhco7+lHnW+/vXHe1j2X9fi6XHuyFpWYSXvbXEsZ/+bmxObNfp2Md5WCx/OHsWJ05X06upPRn45y3Znc3XPEMb0Daeuru7SBxERERHp4BTIRNqYxWxi1ug4nlt5kIRwf0b1CmPmqFh8PT34bNcp3tyQyfGiKh4c15tuwT4sfeAaXl2XyV/XZZBfVkN+w3PHhvcMITbUl0ExQfSNPPOw5PiujkD28c5TJHUPZv3hAl5Zd4S9p0oJ8PLgj7cnMWlAJOCYKtm4OEegtweH8sq57aX1dAv2YWR8KBP7RxId7Bh9e37VQertBtf2DmPERUbRLkeQj5UgH8dUzP7RQfSPvvJl7UVEREQ6EgUyETeYMyaB2df3wmxu+pDku6+JY+aonpwqrnIu1OHr6cGD43tz73Vx7M8u5VhhJcmxXYgN9TvvsSf0j2Tp7mw+23WKz3adcm43maCspp77/7GNuDA/eob6UlFjw27AqF6h3D4shofe28Wek6XsOVnK8r25/GHZfj6eM5ogHysf7zgJOJazFxEREZHWoUAm4ibfDWONLGaTM4ydzdfTg+TYkIsugw/wH0nR+HtZeOKjPZwqqaZHiC+3DunGT0f24JW1R3h9fSaZBRVNlsa/KyWWSQOiiOniy6niKrJLqnl/63GO5Ffw6a5ThAd4YTcgJT6Uwd2Dr+hzi4iIiMgZCmQindDYvhF8/UgYheW1RAV5O5/z9cQPErnv+ngO55aTWVjB0YIKgn09mZDomMJ4dc8zYa97F1/mvLOdr/bl0jXA8fDmif0jzj2ZiIiIiLSYAplIJ+XlYXHe/3W28ABvwgO8GZUQdtH3X3dVGFaLiSMFFc7nmo3rp0AmIiIi0pqubJk0Eem0ArytpPQ6E9r6RgacdyqliIiIiLScApmIXNCN/c488PnGRI2OiYiIiLQ2BTIRuaCzpyiO13RFERERkVane8hE5IKig3341U19KamqY1CMnhEmIiIi0toUyETkou67rpe7uyAiIiLSaWnKooiIiIiIiJsokImIiIiIiLiJApmIiIiIiIibKJCJiIiIiIi4iQKZiIiIiIiImyiQiYiIiIiIuIkCmYiIiIiIiJsokImIiIiIiLiJApmIiIiIiIibKJCJiIiIiIi4iQKZiIiIiIiImyiQiYiIiIiIuIkCmYiIiIiIiJsokImIiIiIiLiJApmIiIiIiIibKJCJiIiIiIi4iQKZiIiIiIiImyiQiYiIiIiIuImHuzvQWRiGAUBpaambewJ1dXVUVlZSWlqK1Wp1d3c6JdXY9VRj11ONXU81dj3V2PVUY9dTjV2vrWvcmAkaM8LFKJC1krKyMgC6d+/u5p6IiIiIiEh7UFZWRlBQ0EXbmIzmxDa5JLvdzqlTpwgICMBkMrm1L6WlpXTv3p3jx48TGBjo1r50Vqqx66nGrqcau55q7Hqqseupxq6nGrteW9fYMAzKysqIjo7GbL74XWIaIWslZrOZmJgYd3ejicDAQP2hdjHV2PVUY9dTjV1PNXY91dj1VGPXU41dry1rfKmRsUZa1ENERERERMRNFMhERERERETcRIGsE/Ly8mLhwoV4eXm5uyudlmrseqqx66nGrqcau55q7Hqqseupxq7XnmusRT1ERERERETcRCNkIiIiIiIibqJAJiIiIiIi4iYKZCIiIiIiIm6iQCYiIiIiIuImCmSd0OLFi+nZsyfe3t6MGDGCzZs3u7tLHdZvfvMbTCZTk199+/Z17q+urmbOnDmEhobi7+/P1KlTyc3NdWOP279169Zx8803Ex0djclk4uOPP26y3zAMFixYQFRUFD4+PowfP55Dhw41aVNUVMT06dMJDAwkODiYe+65h/Ly8jb8FO3bpWr8s5/97JzretKkSU3aqMYX9tRTT3H11VcTEBBAeHg4t956K+np6U3aNOe7ISsriylTpuDr60t4eDiPPPII9fX1bflR2q3m1PiGG2445zq+//77m7RRjS/spZdeYtCgQc6H5KakpPDFF1849+savnKXqrGu4db39NNPYzKZmDdvnnNbR7iWFcg6mffee4/58+ezcOFCtm/fTlJSEhMnTiQvL8/dXeuw+vfvT3Z2tvPXt99+69z30EMP8dlnn/HBBx+wdu1aTp06xW233ebG3rZ/FRUVJCUlsXjx4vPuf+aZZ/jzn//Myy+/zKZNm/Dz82PixIlUV1c720yfPp29e/eycuVKli5dyrp167jvvvva6iO0e5eqMcCkSZOaXNf//Oc/m+xXjS9s7dq1zJkzh40bN7Jy5Urq6uqYMGECFRUVzjaX+m6w2WxMmTKF2tpaNmzYwFtvvcWSJUtYsGCBOz5Su9OcGgPce++9Ta7jZ555xrlPNb64mJgYnn76abZt28bWrVsZO3Yst9xyC3v37gV0DbeGS9UYdA23pi1btvDXv/6VQYMGNdneIa5lQzqV4cOHG3PmzHH+bLPZjOjoaOOpp55yY686roULFxpJSUnn3VdcXGxYrVbjgw8+cG7bv3+/ARipqalt1MOODTA++ugj5892u92IjIw0/vjHPzq3FRcXG15eXsY///lPwzAMY9++fQZgbNmyxdnmiy++MEwmk3Hy5Mk263tH8d0aG4ZhzJw507jlllsu+B7V+PLk5eUZgLF27VrDMJr33fD5558bZrPZyMnJcbZ56aWXjMDAQKOmpqZtP0AH8N0aG4ZhXH/99caDDz54wfeoxpevS5cuxmuvvaZr2IUaa2wYuoZbU1lZmdG7d29j5cqVTeraUa5ljZB1IrW1tWzbto3x48c7t5nNZsaPH09qaqobe9axHTp0iOjoaOLj45k+fTpZWVkAbNu2jbq6uib17tu3Lz169FC9WygzM5OcnJwmNQ0KCmLEiBHOmqamphIcHMywYcOcbcaPH4/ZbGbTpk1t3ueOas2aNYSHh9OnTx9mz55NYWGhc59qfHlKSkoACAkJAZr33ZCamsrAgQOJiIhwtpk4cSKlpaVN/vVcHL5b40Zvv/02YWFhDBgwgMcff5zKykrnPtW4+Ww2G++++y4VFRWkpKToGnaB79a4ka7h1jFnzhymTJnS5JqFjvN97NEmZ5E2UVBQgM1ma3JBAURERHDgwAE39apjGzFiBEuWLKFPnz5kZ2fz29/+lmuvvZY9e/aQk5ODp6cnwcHBTd4TERFBTk6OezrcwTXW7XzXcOO+nJwcwsPDm+z38PAgJCREdW+mSZMmcdtttxEXF0dGRga/+tWvmDx5MqmpqVgsFtX4MtjtdubNm8fo0aMZMGAAQLO+G3Jycs57nTfukzPOV2OAn/zkJ8TGxhIdHc3u3bv57//+b9LT0/n3v/8NqMbNkZaWRkpKCtXV1fj7+/PRRx+RmJjIzp07dQ23kgvVGHQNt5Z3332X7du3s2XLlnP2dZTvYwUykYuYPHmy8/WgQYMYMWIEsbGxvP/++/j4+LixZyItd+eddzpfDxw4kEGDBtGrVy/WrFnDuHHj3NizjmfOnDns2bOnyb2l0rouVOOz72kcOHAgUVFRjBs3joyMDHr16tXW3eyQ+vTpw86dOykpKeHDDz9k5syZrF271t3d6lQuVOPExERdw63g+PHjPPjgg6xcuRJvb293d6fFNGWxEwkLC8NisZyzckxubi6RkZFu6lXnEhwczFVXXcXhw4eJjIyktraW4uLiJm1U75ZrrNvFruHIyMhzFqmpr6+nqKhIdW+h+Ph4wsLCOHz4MKAaN9fcuXNZunQpX3/9NTExMc7tzfluiIyMPO913rhPHC5U4/MZMWIEQJPrWDW+OE9PTxISEkhOTuapp54iKSmJRYsW6RpuRReq8fnoGr5827ZtIy8vj6FDh+Lh4YGHhwdr167lz3/+Mx4eHkRERHSIa1mBrBPx9PQkOTmZVatWObfZ7XZWrVrVZL6ytFx5eTkZGRlERUWRnJyM1WptUu/09HSysrJU7xaKi4sjMjKySU1LS0vZtGmTs6YpKSkUFxezbds2Z5vVq1djt9udf5nJ5Tlx4gSFhYVERUUBqvGlGIbB3Llz+eijj1i9ejVxcXFN9jfnuyElJYW0tLQmwXflypUEBgY6pzN9n12qxuezc+dOgCbXsWp8eex2OzU1NbqGXaixxueja/jyjRs3jrS0NHbu3On8NWzYMKZPn+583SGu5TZZOkTazLvvvmt4eXkZS5YsMfbt22fcd999RnBwcJOVY6T5Hn74YWPNmjVGZmamsX79emP8+PFGWFiYkZeXZxiGYdx///1Gjx49jNWrVxtbt241UlJSjJSUFDf3un0rKyszduzYYezYscMAjGeffdbYsWOHcezYMcMwDOPpp582goODjU8++cTYvXu3ccsttxhxcXFGVVWV8xiTJk0yhgwZYmzatMn49ttvjd69exvTpk1z10dqdy5W47KyMuOXv/ylkZqaamRmZhpfffWVMXToUKN3795GdXW18xiq8YXNnj3bCAoKMtasWWNkZ2c7f1VWVjrbXOq7ob6+3hgwYIAxYcIEY+fOncaXX35pdO3a1Xj88cfd8ZHanUvV+PDhw8aTTz5pbN261cjMzDQ++eQTIz4+3rjuuuucx1CNL+6xxx4z1q5da2RmZhq7d+82HnvsMcNkMhkrVqwwDEPXcGu4WI11DbvOd1ev7AjXsgJZJ/SXv/zF6NGjh+Hp6WkMHz7c2Lhxo7u71GHdcccdRlRUlOHp6Wl069bNuOOOO4zDhw8791dVVRm/+MUvjC5duhi+vr7GD3/4QyM7O9uNPW7/vv76awM459fMmTMNw3Asff/rX//aiIiIMLy8vIxx48YZ6enpTY5RWFhoTJs2zfD39zcCAwONWbNmGWVlZW74NO3TxWpcWVlpTJgwwejatathtVqN2NhY49577z3nH21U4ws7X20B480333S2ac53w9GjR43JkycbPj4+RlhYmPHwww8bdXV1bfxp2qdL1TgrK8u47rrrjJCQEMPLy8tISEgwHnnkEaOkpKTJcVTjC7v77ruN2NhYw9PT0+jatasxbtw4ZxgzDF3DreFiNdY17DrfDWQd4Vo2GYZhtM1YnIiIiIiIiJxN95CJiIiIiIi4iQKZiIiIiIiImyiQiYiIiIiIuIkCmYiIiIiIiJsokImIiIiIiLiJApmIiIiIiIibKJCJiIiIiIi4iQKZiIiIiIiImyiQiYiIXKaf/exn3Hrrre7uhoiIdAIe7u6AiIhIe2IymS66f+HChSxatAjDMNqoRyIi0pkpkImIiJwlOzvb+fq9995jwYIFpKenO7f5+/vj7+/vjq6JiEgnpCmLIiIiZ4mMjHT+CgoKwmQyNdnm7+9/zpTFG264gQceeIB58+bRpUsXIiIiePXVV6moqGDWrFkEBASQkJDAF1980eRce/bsYfLkyfj7+xMREcGMGTMoKCho408sIiLupEAmIiLSCt566y3CwsLYvHkzDzzwALNnz+b2229n1KhRbN++nQkTJjBjxgwqKysBKC4uZuzYsQwZMoStW7fy5Zdfkpuby49//GM3fxIREWlLCmQiIiKtICkpiSeeeILevXvz+OOP4+3tTVhYGPfeey+9e/dmwYIFFBYWsnv3bgBeeOEFhgwZwv/8z//Qt29fhgwZwhtvvMHXX3/NwYMH3fxpRESkregeMhERkVYwaNAg52uLxUJoaCgDBw50bouIiAAgLy8PgF27dvH111+f9360jIwMrrrqKhf3WERE2gMFMhERkVZgtVqb/GwymZpsa1y90W63A1BeXs7NN9/M//7v/55zrKioKBf2VERE2hMFMhERETcYOnQo//rXv+jZsyceHvrrWETk+0r3kImIiLjBnDlzKCoqYtq0aWzZsoWMjAyWL1/OrFmzsNls7u6eiIi0EQUyERERN4iOjmb9+vXYbDYmTJjAwIEDmTdvHsHBwZjN+utZROT7wmQYhuHuToiIiIiIiHwf6Z/gRERERERE3ESBTERERERExE0UyERERERERNxEgUxERERERMRNFMhERERERETcRIFMRERERETETRTIRERERERE3ESBTERERERExE0UyERERERERNxEgUxERERERMRNFMhERERERETc5P8Dt7LZv8xocdgAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(range(367, 397),\n", + " array([64886.72792019, 64886.72792019, 64886.72792019, 64227.98006586,\n", + " 64227.98006586, 63569.22685585, 63733.91381943, 63239.85292868,\n", + " 63733.91381943, 63569.22685585, 64063.29042444, 64557.35399303,\n", + " 64227.98006586, 63898.60078302, 63898.60078302, 63898.60078302,\n", + " 63898.60346085, 63733.91381943, 64557.35131519, 63404.53989226,\n", + " 65051.41488378, 65545.47577453, 65874.8497017 , 65874.8497017 ,\n", + " 65216.10184736, 65874.8497017 , 66039.53666528, 65380.78881095,\n", + " 64886.72792019, 65545.47577453]))" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predict_and_plot_crypto_data('BTC',crypto_data_dict, prediction_length=30)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}