├── .gitignore ├── AA4MTS.ipynb ├── AFA4MTS.ipynb ├── Chap2.ipynb ├── LICENSE ├── README.md ├── TSFS_2.ipynb ├── TSFS_3.ipynb ├── TSFS_4.ipynb ├── TSFS_5.ipynb ├── TSFS_6.ipynb ├── TSFS_7.ipynb └── TSFS_7_Prophet.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | pip-wheel-metadata/ 24 | share/python-wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .nox/ 44 | .coverage 45 | .coverage.* 46 | .cache 47 | nosetests.xml 48 | coverage.xml 49 | *.cover 50 | *.py,cover 51 | .hypothesis/ 52 | .pytest_cache/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | target/ 76 | 77 | # Jupyter Notebook 78 | .ipynb_checkpoints 79 | 80 | # IPython 81 | profile_default/ 82 | ipython_config.py 83 | 84 | # pyenv 85 | .python-version 86 | 87 | # pipenv 88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 91 | # install all needed dependencies. 92 | #Pipfile.lock 93 | 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 95 | __pypackages__/ 96 | 97 | # Celery stuff 98 | celerybeat-schedule 99 | celerybeat.pid 100 | 101 | # SageMath parsed files 102 | *.sage.py 103 | 104 | # Environments 105 | .env 106 | .venv 107 | env/ 108 | venv/ 109 | ENV/ 110 | env.bak/ 111 | venv.bak/ 112 | 113 | # Spyder project settings 114 | .spyderproject 115 | .spyproject 116 | 117 | # Rope project settings 118 | .ropeproject 119 | 120 | # mkdocs documentation 121 | /site 122 | 123 | # mypy 124 | .mypy_cache/ 125 | .dmypy.json 126 | dmypy.json 127 | 128 | # Pyre type checker 129 | .pyre/ 130 | -------------------------------------------------------------------------------- /Chap2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Template \n", 8 | "\n", 9 | "- Author: Israel Oliveira [\\[e-mail\\]](mailto:'Israel%20Oliveira%20')" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": { 16 | "execution": { 17 | "iopub.execute_input": "2021-07-16T22:13:45.938479Z", 18 | "iopub.status.busy": "2021-07-16T22:13:45.935895Z", 19 | "iopub.status.idle": "2021-07-16T22:13:45.979009Z", 20 | "shell.execute_reply": "2021-07-16T22:13:45.978267Z", 21 | "shell.execute_reply.started": "2021-07-16T22:13:45.938351Z" 22 | } 23 | }, 24 | "outputs": [], 25 | "source": [ 26 | "%load_ext watermark" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 2, 32 | "metadata": { 33 | "execution": { 34 | "iopub.execute_input": "2021-07-16T22:13:46.202029Z", 35 | "iopub.status.busy": "2021-07-16T22:13:46.201660Z", 36 | "iopub.status.idle": "2021-07-16T22:13:46.205885Z", 37 | "shell.execute_reply": "2021-07-16T22:13:46.204872Z", 38 | "shell.execute_reply.started": "2021-07-16T22:13:46.202002Z" 39 | } 40 | }, 41 | "outputs": [], 42 | "source": [ 43 | "import pandas as pd" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 3, 49 | "metadata": { 50 | "execution": { 51 | "iopub.execute_input": "2021-07-16T22:13:46.958403Z", 52 | "iopub.status.busy": "2021-07-16T22:13:46.956331Z", 53 | "iopub.status.idle": "2021-07-16T22:13:46.985243Z", 54 | "shell.execute_reply": "2021-07-16T22:13:46.978645Z", 55 | "shell.execute_reply.started": "2021-07-16T22:13:46.958251Z" 56 | } 57 | }, 58 | "outputs": [], 59 | "source": [ 60 | "# from tqdm import tqdm\n", 61 | "\n", 62 | "# from glob import glob\n", 63 | "\n", 64 | "# import matplotlib.pyplot as plt\n", 65 | "# %matplotlib inline\n", 66 | "# from IPython.core.pylabtools import figsize\n", 67 | "# figsize(12, 8)\n", 68 | "\n", 69 | "# import seaborn as sns\n", 70 | "# sns.set_theme()\n", 71 | "\n", 72 | "# pd.set_option(\"max_columns\", None)\n", 73 | "# pd.set_option(\"max_rows\", None)\n", 74 | "# pd.set_option('display.max_colwidth', None)\n", 75 | "\n", 76 | "# from IPython.display import Markdown, display\n", 77 | "# def md(arg):\n", 78 | "# display(Markdown(arg))\n", 79 | "\n", 80 | "# from pandas_profiling import ProfileReport\n", 81 | "# #report = ProfileReport(#DataFrame here#, minimal=True)\n", 82 | "# #report.to\n", 83 | "\n", 84 | "# import pyarrow.parquet as pq\n", 85 | "# #df = pq.ParquetDataset(path_to_folder_with_parquets, filesystem=None).read_pandas().to_pandas()\n", 86 | "\n", 87 | "# import json\n", 88 | "# def open_file_json(path,mode='r',var=None):\n", 89 | "# if mode == 'w':\n", 90 | "# with open(path,'w') as f:\n", 91 | "# json.dump(var, f)\n", 92 | "# if mode == 'r':\n", 93 | "# with open(path,'r') as f:\n", 94 | "# return json.load(f)\n", 95 | "\n", 96 | "# import functools\n", 97 | "# import operator\n", 98 | "# def flat(a):\n", 99 | "# return functools.reduce(operator.iconcat, a, [])" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 4, 105 | "metadata": { 106 | "execution": { 107 | "iopub.execute_input": "2021-07-16T22:13:54.774409Z", 108 | "iopub.status.busy": "2021-07-16T22:13:54.772990Z", 109 | "iopub.status.idle": "2021-07-16T22:13:56.081839Z", 110 | "shell.execute_reply": "2021-07-16T22:13:56.080075Z", 111 | "shell.execute_reply.started": "2021-07-16T22:13:54.774291Z" 112 | } 113 | }, 114 | "outputs": [ 115 | { 116 | "name": "stdout", 117 | "output_type": "stream", 118 | "text": [ 119 | "Python implementation: CPython\n", 120 | "Python version : 3.8.11\n", 121 | "IPython version : 7.25.0\n", 122 | "\n", 123 | "Compiler : GCC 8.3.0\n", 124 | "OS : Linux\n", 125 | "Release : 5.11.0-7620-generic\n", 126 | "Machine : x86_64\n", 127 | "Processor : \n", 128 | "CPU cores : 4\n", 129 | "Architecture: 64bit\n", 130 | "\n", 131 | "Git hash: 3d0b1240da8b6612620dff8921a6898b7024f57f\n", 132 | "\n", 133 | "Git repo: https://github.com/ysraell/forecasting.git\n", 134 | "\n", 135 | "Git branch: main\n", 136 | "\n", 137 | "sys : 3.8.11 (default, Jun 29 2021, 19:54:56) \n", 138 | "[GCC 8.3.0]\n", 139 | "ipywidgets: 7.6.3\n", 140 | "numpy : 1.19.5\n", 141 | "pandas : 1.3.0\n", 142 | "json : 2.0.9\n", 143 | "\n", 144 | "CPU\t: Intel(R) Core(TM) i7-7500U CPU @ 2.70GHz\n", 145 | "Mem: 15G\n", 146 | "Swap: 4.0G\n" 147 | ] 148 | } 149 | ], 150 | "source": [ 151 | "# Run this cell before close.\n", 152 | "%watermark -d --iversion -b -r -g -m -v\n", 153 | "!cat /proc/cpuinfo |grep 'model name'|head -n 1 |sed -e 's/model\\ name/CPU/'\n", 154 | "!free -h |cut -d'i' -f1 |grep -v total" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": null, 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [] 163 | } 164 | ], 165 | "metadata": { 166 | "kernelspec": { 167 | "display_name": "Python 3 (ipykernel)", 168 | "language": "python", 169 | "name": "python3" 170 | }, 171 | "language_info": { 172 | "codemirror_mode": { 173 | "name": "ipython", 174 | "version": 3 175 | }, 176 | "file_extension": ".py", 177 | "mimetype": "text/x-python", 178 | "name": "python", 179 | "nbconvert_exporter": "python", 180 | "pygments_lexer": "ipython3", 181 | "version": "3.8.11" 182 | } 183 | }, 184 | "nbformat": 4, 185 | "nbformat_minor": 4 186 | } 187 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Israel Gonçalves de Oliveira 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # [LAB Python] Forecasting: Principles and Practice 2 | [![Python 3.8](https://img.shields.io/badge/Python-3.8-gree.svg)](https://www.python.org/downloads/release/python-380/) 3 | 4 | `“If we could first know where we are and whither we are tending, we could better judge what to do and how to do it.”` 5 | *Abraham Lincoln* 6 | 7 | Exercises and others experiments in Python using the e-book [*Forecasting: Principles and Practice* (Rob J Hyndman and George Athanasopoulos)](https://otexts.com/fpp3/). 8 | 9 | Author (e-mail): [Israel Oliveira](mailto:prof.israel@gmail.com) 10 | 11 | 12 | # References: 13 | 14 | Hyndman, R.J., & Athanasopoulos, G. (2021) Forecasting: principles and practice, 3rd edition, OTexts: Melbourne, Australia. OTexts.com/fpp3. Accessed on 07/16/2021. 15 | 16 | -------------------------------------------------------------------------------- /TSFS_7.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Time Series From Scratch (part. 7) — Train/Test Splits and Evaluation Metrics (Dario Radečić)\n", 8 | "[Source](https://towardsdatascience.com/time-series-from-scratch-train-test-splits-and-evaluation-metrics-4fd654de1b37). From [Time Series From Scratch](https://towardsdatascience.com/tagged/time-series-from-scratch).\n", 9 | "\n", 10 | "- Author: Israel Oliveira [\\[e-mail\\]](mailto:'Israel%20Oliveira%20')" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 1, 16 | "metadata": { 17 | "execution": { 18 | "iopub.execute_input": "2021-08-01T01:57:12.542843Z", 19 | "iopub.status.busy": "2021-08-01T01:57:12.540126Z", 20 | "iopub.status.idle": "2021-08-01T01:57:12.586573Z", 21 | "shell.execute_reply": "2021-08-01T01:57:12.585750Z", 22 | "shell.execute_reply.started": "2021-08-01T01:57:12.542506Z" 23 | } 24 | }, 25 | "outputs": [], 26 | "source": [ 27 | "%load_ext watermark" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 7, 33 | "metadata": { 34 | "execution": { 35 | "iopub.execute_input": "2021-08-01T02:04:52.029873Z", 36 | "iopub.status.busy": "2021-08-01T02:04:52.029423Z", 37 | "iopub.status.idle": "2021-08-01T02:04:52.604249Z", 38 | "shell.execute_reply": "2021-08-01T02:04:52.603597Z", 39 | "shell.execute_reply.started": "2021-08-01T02:04:52.029835Z" 40 | }, 41 | "tags": [] 42 | }, 43 | "outputs": [], 44 | "source": [ 45 | "\n", 46 | "import numpy as np\n", 47 | "import pandas as pd\n", 48 | "import matplotlib.pyplot as plt\n", 49 | "from matplotlib import rcParams\n", 50 | "from cycler import cycler\n", 51 | "from sklearn.metrics import mean_squared_error, mean_absolute_percentage_error\n", 52 | "\n", 53 | "rcParams['figure.figsize'] = 18, 5\n", 54 | "rcParams['axes.spines.top'] = False\n", 55 | "rcParams['axes.spines.right'] = False\n", 56 | "rcParams['axes.grid'] = True\n", 57 | "rcParams['axes.prop_cycle'] = cycler(color=['#365977'])\n", 58 | "rcParams['lines.linewidth'] = 2.5" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 8, 64 | "metadata": { 65 | "execution": { 66 | "iopub.execute_input": "2021-08-01T02:04:53.537776Z", 67 | "iopub.status.busy": "2021-08-01T02:04:53.535081Z", 68 | "iopub.status.idle": "2021-08-01T02:04:53.561341Z", 69 | "shell.execute_reply": "2021-08-01T02:04:53.557565Z", 70 | "shell.execute_reply.started": "2021-08-01T02:04:53.537600Z" 71 | }, 72 | "tags": [] 73 | }, 74 | "outputs": [], 75 | "source": [ 76 | "# from tqdm import tqdm\n", 77 | "\n", 78 | "# from glob import glob\n", 79 | "\n", 80 | "# import matplotlib.pyplot as plt\n", 81 | "# %matplotlib inline\n", 82 | "# from IPython.core.pylabtools import figsize\n", 83 | "# figsize(12, 8)\n", 84 | "\n", 85 | "# import seaborn as sns\n", 86 | "# sns.set_theme()\n", 87 | "\n", 88 | "# pd.set_option(\"max_columns\", None)\n", 89 | "# pd.set_option(\"max_rows\", None)\n", 90 | "# pd.set_option('display.max_colwidth', None)\n", 91 | "\n", 92 | "# from IPython.display import Markdown, display\n", 93 | "# def md(arg):\n", 94 | "# display(Markdown(arg))\n", 95 | "\n", 96 | "# from pandas_profiling import ProfileReport\n", 97 | "# #report = ProfileReport(#DataFrame here#, minimal=True)\n", 98 | "# #report.to\n", 99 | "\n", 100 | "# import pyarrow.parquet as pq\n", 101 | "# #df = pq.ParquetDataset(path_to_folder_with_parquets, filesystem=None).read_pandas().to_pandas()\n", 102 | "\n", 103 | "# import json\n", 104 | "# def open_file_json(path,mode='r',var=None):\n", 105 | "# if mode == 'w':\n", 106 | "# with open(path,'w') as f:\n", 107 | "# json.dump(var, f)\n", 108 | "# if mode == 'r':\n", 109 | "# with open(path,'r') as f:\n", 110 | "# return json.load(f)\n", 111 | "\n", 112 | "# import functools\n", 113 | "# import operator\n", 114 | "# def flat(a):\n", 115 | "# return functools.reduce(operator.iconcat, a, [])\n", 116 | "\n", 117 | "# import json\n", 118 | "# from glob import glob\n", 119 | "# from typing import NewType\n", 120 | "\n", 121 | "\n", 122 | "# DictsPathType = NewType(\"DictsPath\", str)\n", 123 | "\n", 124 | "\n", 125 | "# def open_file_json(path):\n", 126 | "# with open(path, \"r\") as f:\n", 127 | "# return json.load(f)\n", 128 | "\n", 129 | "# class LoadDicts:\n", 130 | "# def __init__(self, dict_path: DictsPathType = \"./data\"):\n", 131 | "# Dicts_glob = glob(f\"{dict_path}/*.json\")\n", 132 | "# self.List = []\n", 133 | "# self.Dict = {}\n", 134 | "# for path_json in Dicts_glob:\n", 135 | "# name = path_json.split(\"/\")[-1].replace(\".json\", \"\")\n", 136 | "# self.List.append(name)\n", 137 | "# self.Dict[name] = open_file_json(path_json)\n", 138 | "# setattr(self, name, self.Dict[name])\n" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 9, 144 | "metadata": { 145 | "execution": { 146 | "iopub.execute_input": "2021-08-01T02:04:53.686973Z", 147 | "iopub.status.busy": "2021-08-01T02:04:53.686309Z", 148 | "iopub.status.idle": "2021-08-01T02:04:54.996235Z", 149 | "shell.execute_reply": "2021-08-01T02:04:54.991328Z", 150 | "shell.execute_reply.started": "2021-08-01T02:04:53.686942Z" 151 | }, 152 | "tags": [] 153 | }, 154 | "outputs": [ 155 | { 156 | "name": "stdout", 157 | "output_type": "stream", 158 | "text": [ 159 | "Python implementation: CPython\n", 160 | "Python version : 3.9.6\n", 161 | "IPython version : 7.25.0\n", 162 | "\n", 163 | "Compiler : GCC 8.3.0\n", 164 | "OS : Linux\n", 165 | "Release : 5.11.0-7620-generic\n", 166 | "Machine : x86_64\n", 167 | "Processor : \n", 168 | "CPU cores : 4\n", 169 | "Architecture: 64bit\n", 170 | "\n", 171 | "Git hash: 37d3a4de4336d1d67ee2c7ef766fa74155d1cda9\n", 172 | "\n", 173 | "Git repo: https://github.com/ysraell/forecasting.git\n", 174 | "\n", 175 | "Git branch: main\n", 176 | "\n", 177 | "pandas : 1.3.1\n", 178 | "matplotlib: 3.4.2\n", 179 | "numpy : 1.19.5\n", 180 | "\n", 181 | "CPU\t: Intel(R) Core(TM) i7-7500U CPU @ 2.70GHz\n", 182 | "Mem: 15G\n", 183 | "Swap: 4.0G\n" 184 | ] 185 | } 186 | ], 187 | "source": [ 188 | "# Run this cell before close.\n", 189 | "%watermark -d --iversion -b -r -g -m -v\n", 190 | "!cat /proc/cpuinfo |grep 'model name'|head -n 1 |sed -e 's/model\\ name/CPU/'\n", 191 | "!free -h |cut -d'i' -f1 |grep -v total" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 10, 197 | "metadata": { 198 | "execution": { 199 | "iopub.execute_input": "2021-08-01T02:04:55.004203Z", 200 | "iopub.status.busy": "2021-08-01T02:04:55.002090Z", 201 | "iopub.status.idle": "2021-08-01T02:04:55.257432Z", 202 | "shell.execute_reply": "2021-08-01T02:04:55.256600Z", 203 | "shell.execute_reply.started": "2021-08-01T02:04:55.004098Z" 204 | }, 205 | "tags": [] 206 | }, 207 | "outputs": [ 208 | { 209 | "data": { 210 | "image/png": "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\n", 211 | "text/plain": [ 212 | "
" 213 | ] 214 | }, 215 | "metadata": { 216 | "needs_background": "light" 217 | }, 218 | "output_type": "display_data" 219 | } 220 | ], 221 | "source": [ 222 | "# Load\n", 223 | "df = pd.read_csv('/work/tmp/airline-passengers.csv', index_col='Month', parse_dates=True)\n", 224 | "\n", 225 | "# Visualize\n", 226 | "plt.title('Airline Passengers dataset', size=20)\n", 227 | "plt.plot(df);" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": 11, 233 | "metadata": { 234 | "execution": { 235 | "iopub.execute_input": "2021-08-01T02:04:57.200462Z", 236 | "iopub.status.busy": "2021-08-01T02:04:57.198828Z", 237 | "iopub.status.idle": "2021-08-01T02:04:57.502407Z", 238 | "shell.execute_reply": "2021-08-01T02:04:57.501788Z", 239 | "shell.execute_reply.started": "2021-08-01T02:04:57.200305Z" 240 | }, 241 | "tags": [] 242 | }, 243 | "outputs": [ 244 | { 245 | "data": { 246 | "image/png": "iVBORw0KGgoAAAANSUhEUgAABBQAAAFECAYAAACXqW3MAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAACcgklEQVR4nOzdd3hUZdrH8e+TTkgIPfTea+hdQVBBRBR1Vxfb2svay1p33XdXV1fXuurae10rKAqC9N57h1ADhJJGSD/vH+fMZIAkTJLJTDL5fa4rV07OnHLP5AQ993me+zaWZSEiIiIiIiIiUhohgQ5ARERERERERKoeJRREREREREREpNSUUBARERERERGRUlNCQURERERERERKTQkFERERERERESk1JRREREREREREpNSUUBARqQKMMU8aYyxjzPBS7veBs18rj3WtnHUf+DZKkcrFGDPcudafDHQsFaU6vEcREam8lFAQEQkgY8xjzs2AZYzpGOh4RCqSMSbRGJMY6DiqM2PMdc6/N9cF4NyzjDGWv89bksoYk4hIVRIW6ABERKorY4wBbgQswAA3AQ8Us/l/gC+A3T449T6gM5Dqg2OJVGZLsK/1w4EOREREJBhphIKISOCcB7QCPgQOANcaYyKK2tCyrMOWZW2yLCuzvCe1LCvXOVZSeY8lUplZlpXpXOtKKIiIiFQAJRRERALnJuf728CnQH3gkqI2LK6GgrNuljGmkTHmHWPMPmNMfknDmYuroeBZb8EYc4sxZq0xJssYc9AY85YxJq6Y4zUzxvzHGLPDGJNtjDlijJlkjOnn7QfhGZMxppMx5ntjzFFjzHFjzDxjzHlF7BNnjHnQGPObMWavMSbHGJPsnHtQMecZZoyZ7GyfbYw5YIxZZIz56ynbxRtjnjfGbHZiSHGWPzDGtCniuOcbY6YYYw47x91ujHnOGFO7iG0Tna+azja7nX22GWP+7IxcOXUfY4y52xizwfmd7HM+87iSphEYY640xsx04s8yxmw0xjxujIksYtsSr6XSfianHHu4M6y8JdDSFE7zOek69CKGDsaYZ4wxy5zfdbYxZpdzfTYr7rzmlPoCzjksY0yYMeZRY8xW51h7jDHPmmISe8W8tzLHZIxJMMb85HyWmcaY2caYwcWcJ94Y866x/x5PGGNWGWOu9TZO1/sG3nd+fP+U30Mrj+3CjDG3O38baU5sK40xfzLGnPb/jsaYi4wxM4wxSc773++8l9ud11s5v/+znZ89zzvLi7hjjTFPGGPWOfGkG/tv7EtjTJ8ith9gjPna2H/fOc7v9U1jTBOPbbyKyRjTwxjzubH/zrKd3/EKY8xLxphwbz53EZFgpikPIiIBYIyJBy4CtliWtcAYkwbcD9wMfFnKw9UFFgEZwLdAAXCwHOH9CzgfmAxMA0ZgJz/aAed4bmiM6e1sUxeY6py/PnAxMM8Yc4llWVNKce7WwEJgLfAm0Bj4PfCzMeYPlmV5fjadgaeAOcBPwDGgBfbnOsYYM86yrF88Yh3tbJcGTMKe+lHXOc7twN+c7aKB+UBb4FfnczDYN8Pjga+BHR7H/SvwJHAU+BE4BPTAnr5ygTFmkGVZaae8z3Dn82oC/AzkOZ/ZM0CUKxYPrwG3AfuBt4Ac5332d46Ve+oHaYx5D/gjsBf4BkgBBgJ/B0YaY861LCvvlN2KvJZK+5kUIdF5T/c4P7/k8doqb2JwXpsA3ArMBBY4n0NX7KlD44wxfS3L2ldCHKf6DBiG/TtIAy4AHgIaYn923ihrTH2dcy0E3sG+di8FZhhjEizL2uza0BhT3zl2G2Ce89UY+C/235+3PsC+DsYDP3DyZ5/inCsc+/d7PrAZ+zPKwv534FVgAHC1R2w3Y/+tHnD2O4z9+fXA/gxfd479N+A67GvG8/pOLClgY4wBfgEGU/hZ5QHNnJjmAss9tr8e+28kG/vvfA/QnsLfx0DLsnZ7E5MxpgewGHta2iRgJ1AL+9/C24HHKeJvT0SkWrEsS1/60pe+9OXnL+Bh7P9JfcRj3TLsm6d2RWz/pLP98FPWW87XR0BYEft94LzeymNdK2fdB8Vsuxto4bE+DPum3QL6n7J+G/bNxtmnHKsJ9g17EhDpxefhiskCnjvltb7Y/9N+DKjlsT4OqF/EsZph33hvPGX9N87xexaxT32P5XHOdi8WsV0EEOvx8whn2wVA7VO2va6o42DfrFjAFKCGx/qG2Dc5KUC4x/phzvabPc/hxOL6vSQWc+5vPc9xyrV0t7fXUmk+kzP8nhNPjbWU13PToq4n7OlD+cAbp6wf7hzvyVPWz3LWLwfqeqyv6VzT+UAjL99TWWOygOtOee0WZ/3rp6x/q5hryfW3cdp7LCHe64o6dxHXx6tAqMf6UOBd57XxHuuXY9+8Nyzp78rzc/cmTo99ujvn/K6I10KAOh4/d8BO6GwDmp6y7Ujn9/GdtzEB/z71/Xq8VgcIKc170Ze+9KWvYPzSlAcRET9znrjdiJ08+MjjpQ8oLM5YGjnAA9bpT5vL6v8s+wkeAM5xXcOk+3tsNxb7ifWrlmXN9jyAZVn7sUc6NML+H3lvpQL/d8qxlmFPCamNx5QQy7JSrSLmxluWtRf7iXknY0yLIs5xooh9ippjX9R2OZZlpXususv5fpNlWSmnbPsB9hPgiUUcG+Auy7JOeGx/CPupcRzg2fHDNaz9Kc9zWJaVAzxSzLHvxn6Ke73nORx/B44UE9eZriVvPpPyKjYGy7L2WZaVXcT6acB67KfqpfFny7KOehznOPa1FoJ9s35G5YhpvnONeHoP+/fm/jtzRgxMBNKxb/Y9z+H62/AJZzrDndijDe61LCvf41z52KOoLE6/dvIo4kl9MX9XZVXUtVdgWdYxj1W3YY/Yuds6ZVSIZVkzsEcZjDPGxPrg3Mcsyyoo5XFERIKOpjyIiPjfOdg34lNP+Z/ez7CfiF1njHncsixvh9ImOjejvrKsiHV7nO91PNa56hS0PHWOuqO9870z9tN4b6wo5uZ0FvaNdS/sIpYAGGOGYN88D8J+wn/q3PemFHbG+BR7ePpiY8yX2EPU5zsJCE+zsUdXPOxM6ZiCPdx/lecNlmMQ9o3U5caYy4uIOwJoYIypZ1nWEY/1qZZlbSti+6I+517O93lFbL8I+2bOzZme0BN76Pk95vSSDGA/Ue5cxPrirqXSfCblVez17CTjJmI/Ze+J/TmFemySU8pzeXutF6scMZ12bsuyco0xB085dycgGphrWVZRnVlmUZh0Kq8O2FNOtgKPF3PtnODka+dT7H+3NhhjvsC+VuZblpXso5g2YCfmrjTGtMROus0DljlJNU+uf5PONkXXcGmI/bvpgMc0iRJ8if3vy/fGmK+B6djvbXup34WISJBSQkFExP9udr5/4LnSsqyjxpjJ2POoXfPSvXHAd6EBzlzqU7huWj1vlOo534u6kfYUU4pzF1f7wfUe41wrjDGXYH9GWdjz+rcDx7FHfgzHLrbmLj5oWda3xpgLsZ+yXo89vBxjzHLsqSe/OtulGWMGYs+pvojCJ8yHjTGvA//wSPbUw/5v6V/P8L5isEcFuKQUs11Rn7PrPZ/22ViWlW+MOXLK6jrYI10aeBHXqYq8lkr5mZRXSdfzC9h1GJKwa1Dso/Dp8XXYc+G9duqoEkdRv4OSlDWmos7tOr9Xv3+HL//+XX/T7Sn52nH/TVuW9YIx5jB2TYG7sD8LyxgzG3jQGUVRZs41fg7wF+Ay4FnnpXRjzIfYf7sZp8T/4BkO69W/SZZlLTHGDAMec859NYAxZjPwN8uyPvf+nYiIBCclFERE/MgY0wC7+B7A58aY4v6H9Ga8TyhY5Y2rjFxPS8dbljXJR8eML2Z9o1POCfbQ/Rygr2VZGz03Nsa8iVO93ZNlWT8BPxljamIXl7sQe5j0j8aYXpZlbXC22wvc4Dx97oI9quQO7JuaEOAJj3hCLMuqW9o3Wgqugo7xnFL40BgTin0T5TnSxfUZrbQsq3cpz1XstVSKz6S8iozBGNMQ+4Z1HTD41JEsxpgrfXR+r/kpJtfv80x/G77gOtd3lmVN8HYny7I+Aj4ydleTwdhTk64HphpjOpV3tIIzreFe4F5jTDvsv+1bgD9hT4VyFYl0xR9nnV4ItaznXghcaOzOKH2A0djTQj4zxiRbljXdF+cREamqVENBRMS/rsUeBr8cu8BZUV/JwChjTOtABemlRc73YT48Zu9i5jcPd76v9FjXDthQRDIhBBha0kksyzpuWdZvlmXdBzyN/TsZU8R2lmVZ6y3LehU411l9sccmi4A6xpiuJZ2vnFzvuaj3NJBTHg44T2vXA12NMT5PdHjxmZQkH++f/J+qDfb/t0wr4sa9mfO6v/kjpk1AJpBgim7dOryUx3NNUSnq97AJpxtIWVoiWpaVYlnWFMuybsIegVUXOOvUczuJsDKxLGubZVnvYicVMrBHc7mU5d8kr2KyLCvbsqwFlmX9hcLaKeNL2kdEpDpQQkFExL9cBRdvtyzrxqK+sFuwuQo3VmY/YE8zuMMYc0FRGxhjBjlz+r0Vh/3E2/MYfbHnqKcC33m8lAi0P6W3vMEuXNeliFjOMsYUNTLP9eQ309muq9PWs8TtHC8639/2jMPjnDWdqQLl4Src+ZjnDaUxJgI7GVKUF7CTJO85T41PjauOUwvBK6X8TEpyBLumRA1vz+0h0fk+1PPmzxgTA7xNYEZdVnhMzlSST4FYTinK6PG3URquKTKnFSx1CmG+it2S8pWifk/GmMbGmC4eP48wRRdbaOh897w2ij13cYwxrY0xRSVm6mBPafIsmPgf7JomLxpjOhRxrAhnCoOnYmMyxgwu5lot7XUvIhK0NOVBRMRPjDHDsYuBrbUsa0kJm76LPWf3j8aYv5ZQcT+gnAJyE7Dnjf9kjFmAXTwtE2gO9MN+QtsY7//Hew5wozFmAHbRv8bA77ET4LecMoz5ReC/wEpjzDfYNxJDsJMJk7FbHXp6BWhqjJmPfSOYgz2E+RxgF/CFs925wHPGmIXAFuAQdivK8dj1GZ7z+AxmGGMeBv4JbDXGTMHuVR+DPXf+bOwCcqO9fP+nsSxrtjHmLexpMOs93us47CTLficuz33eM8b0wZ7Xvt0YMxW7OGVdoDX2U+P3gVu9DMPrz+QMZmBfF78YY+ZgF4dcbVnW5DPtaFnWAafo3xXAKmPMNOwE1LnYdTRWAQlexuETfozpUexuKfc4SYR5FP5tTMGua+Gthdh/j/cYY+pRWIPhVafo49+xi0veit0R4TfsKTUNsWsrDMH+92mDs993QIYxZhH235XBHiHQD3sklueUgBnYNVe+df5WTgC7LMv6uIR4ezrbLwU2Yl/vDbCvvXAKaypgWdYmY8z12N0y1htjfsG+XsOxEwbDsEeAdfIypoeAc4wxc7H/rjOArtijmY5ht/MUEanWlFAQEfEf1+iEd0rayLKsRGPMdOybknGc/FS+UrEsa40xpidwH3Y9gj9i32AmYQ/V/yt2twFv7cS+kXnG+R4JrMBuZTn1lHO/aYzJxi4Cdy32jcBcJ4ZLOT2h8DT23O6+wCgnzt3O+pc82s9Nxb75OAv7pqWW835+BV6wLGvBKXE86yQp7sKeljAe+0Z/H/YNx2eleP/FuQ17OPot2J/LEezr4lFgL/ZIkZNYlnWHMeZnZ/tR2HPNjzrv+Tngk1Kcv1SfSQn+4cQxDvvGNBS7a8cZEwqOG7DrSPweu35DMnYrwL8A33h5DF+r8Jgsyzps7I4mT2N/dn2BzdjXRSKlSChYlnXMGHMp9t/mdUBN56VPsLuP5BpjLgaucl6/EDtBloz99/kEJ7eqfBi7SGdv4ALsRMou4M/AG6cU63wHO9F2BfbNehh2V4iSEgrLsP89OBs7MVfHiWU58IplWT+f8v4+Mcasxi6+OgI4D7tY637sujRfnnL8kmJ6HTtxMAD7bzsM++/tdeDflmXtKiFuEZFqwVhWoGp5iYiI2IwxrbBvVj60LOu6wEZTdRhj2mM/gf3Csiy/FyUUERGR6k01FERERCo5Y0wjp9ik57po4CXnx0o7ikVERESCl6Y8iIiIVH73AFcaY2ZhTzVohD2nvhnwM/C/gEUmIiIi1ZYSCiIiIpXfr9jF6c7DLqyYhz3V4RXs+g+avygiIiJ+pxoKIiIiIiIiIlJqqqEgIiIiIiIiIqVWKRIKo0ePtgB9BfnXwoULAx6DvoL7S9eYvvzxpetMXxX9pWtMXxX9pWtMX/740nUWVF/FqhQJhcOHS9OiXKqq7OzsQIcgQU7XmPiDrjOpaLrGpKLpGhN/0HVWPVSKhIKIiIiIiIiIVC1KKIiIiIiIiIhIqSmhICIiIiIiIiKlFhboAIqTm5vL3r17ycrKCnQo1UZUVBTNmjUjPDw80KGIiIiIiIhIJVdpEwp79+4lNjaWVq1aYYwJdDhBz7Isjhw5wt69e2ndunWgwxEREREREZFKrtJOecjKyqJevXpKJviJMYZ69eppRIiIiIiIiIh4pdImFAAlE/xMn7eIiIiIiIh4q1InFALpyJEjJCQkkJCQQKNGjWjatKn755ycnBL3XbZsGXfdddcZzzF48GBfhVsqTz/9dEDOKyIiIiIiIsGj0tZQCLR69eqxatUqAJ588kliYmJ44IEH3K/n5eURFlb0x9e3b1/69u17xnMsWLDAJ7GW1tNPP82jjz4akHOLiIiIiIhIcNAIhVK47rrruPXWWxkwYAAPPfQQS5YsYdCgQfTq1YvBgwezefNmAGbNmsWFF14I2MmI66+/nuHDh9OmTRteeeUV9/FiYmLc2w8fPpzLLruMTp06MXHiRCzLAmDKlCl06tSJPn36cNddd7mP62n9+vX079+fhIQEevTowdatWwH45JNP3OtvueUW8vPzefjhhzlx4gQJCQlMnDixQj8vERERERGRSiFtC0wdAKsfB+deS8pPIxRKae/evSxYsIDQ0FDS0tKYO3cuYWFhTJ8+nUcffZRvvvnmtH02bdrEzJkzSU9Pp2PHjtx2222ntWZcuXIl69evp0mTJgwZMoT58+fTt29fbrnlFubMmUPr1q258sori4zpv//9L3fffTcTJ04kJyeH/Px8Nm7cyJdffsn8+fMJDw/n9ttv59NPP+WZZ57hP//5j3v0hYiIiIiISNDb+jocWWJ/hUZBt8cDHVFQqBIJhRc+mszWXft9ftz2LZtw3zXjSrXP5ZdfTmhoKACpqalce+21bN26FWMMubm5Re4zduxYIiMjiYyMpGHDhhw8eJBmzZqdtE3//v3d6xISEkhMTCQmJoY2bdq42zheeeWVvPXWW6cdf9CgQTz11FPs3buXCRMm0L59e2bMmMHy5cvp168fACdOnKBhw4aleq8iIiIiIiJBIXVj4fKaJyCmHbS6InDxBIkqkVDYums/KzbuDHQYANSsWdO9/MQTTzBixAi+++47EhMTGT58eJH7REZGupdDQ0PJy8sr0zbF+cMf/sCAAQP46aefuOCCC3jzzTexLItrr72Wf/7zn14fR0REREREJCilbzn550XXQc0W0CAwhfKDRZVIKLRv2aRSHjc1NZWmTZsC8MEHH/ggopN17NiRHTt2kJiYSKtWrfjyyy+L3G7Hjh20adOGu+66i927d7NmzRrOO+88xo8fz7333kvDhg05evQo6enptGzZkvDwcHJzc0+bdiEiIiIiIhJ08k7A8V32cvw5cGg2FGTDnIvh/EUQ0yag4VVlVSKhUNppCf7y0EMPce211/KPf/yDsWPH+vz4NWrU4PXXX2f06NHUrFnTPX3hVF999RUff/wx4eHhNGrUiEcffZS6devyj3/8g/POO4+CggLCw8N57bXXaNmyJTfffDM9evSgd+/efPrppz6PW0REREREpNLI2AY4hRjb3gAtr4AlN0N2Msy6EM5bABG1AxlhlWWsSlDhsm/fvtayZctOWrdx40Y6d+4coIgqj4yMDGJiYrAsizvuuIP27dtz7733Vtj5KvJzd3WzEKkousbEH3SdSUXTNSYVTdeY+EOlus52fw3zLreXz18K9frCygdh4/P2ukajYPgUCNEI7mKY4l5Q28hK7u233yYhIYGuXbuSmprKLbfcEuiQREREREREqo60zYXLtTrY3xOehWYX28sHpsPSO9ROsgy8SigYY2obY742xmwyxmw0xgwyxtQ1xvxqjNnqfK/jbGuMMa8YY7YZY9YYY3pX7FsIbvfeey+rVq1iw4YNfPrpp0RHRwc6JBERERERkarDlVCo0RjCa9nLJgQGfwJ1+9g/b38b9v4QmPiqMG9HKLwM/GJZViegJ7AReBiYYVlWe2CG8zPAGKC983Uz8IZPIxYRERERERHxlqvDQ2zHk9eH1YSzJkGI03Hv0Bz/xhUEzphQMMbEAWcB7wJYlpVjWVYKMB740NnsQ+BiZ3k88JFlWwTUNsY09nHcIiIiIiIiIiWzrMIRCrU6nv56dBOIbWsvZ2zzX1xBwpsRCq2BZOB9Y8xKY8w7xpiaQLxlWUnONgeAeGe5KbDHY/+9zjoRERERERER/8lOhtwUezm2Q9HbxLSzv2ds90tIwcSbtpFhQG/gTsuyFhtjXqZwegMAlmVZxphSVbAwxtyMPSWC+Ph4Zs2addLrcXFxpKenl+aQ4gNZWVmn/S58JSMjo8KOLQK6xsQ/dJ1JRdM1JhVN15j4Q2W5zuKy19DLWV6zK5ujB2edtk3b1AiaAwWpW5kz8ze7voK4ldStw5uEwl5gr2VZi52fv8ZOKBw0xjS2LCvJmdJwyHl9H9DcY/9mzrqTWJb1FvAW2G0jTw1y48aNxMbGehFexThy5AgjR44E4MCBA4SGhtKgQQMAlixZQkRERIn7z5o1i4iICAYPHlyuOFJSUvjss8+4/fbby3Ucb0VFRdGrV68zb1gGlap1jAQlXWPiD7rOpKLpGpOKpmtM/KHSXGfbtsERe7HHkMshtt3p22zZAMu+JoRchvdvDzWbn76NFOmMqRfLsg4Ae4wxrgknI4ENwCTgWmfdtYCrJOYk4Bqn28NAINVjakSVUa9ePVatWsWqVau49dZb3d0WVq1adcZkAth/QAsWLCh3HCkpKbz++uvlPo6IiIiIiEi1k+7UTwgJh5qtit7GM8mgaQ+l4u1YjjuBT40xa4AE4GngGeBcY8xWYJTzM8AUYAewDXgb8M+jdT9Yvnw5Z599Nn369OH8888nKcnOk7zyyit06dKFHj16cMUVV5CYmMh///tfXnzxRRISEpg7d+5Jx5k9ezYJCQkkJCTQq1cv99SO5557jn79+tGjRw/++te/AvDwww+zfft2EhISePDBB/37hkVERERERKqyNKfDQ0w7CClmgH5M28LldBVmLA1vpjxgWdYqoG8RL40sYlsLuKN8YVU+lmVx55138sMPP9CgQQO+/PJLHnvsMd577z2eeeYZdu7cSWRkJCkpKdSuXZtbb72VmJgYHnjggdOO9fzzz/Paa68xZMgQMjIyiIqKYtq0aWzdupUlS5ZgWRYXXXQRc+bM4ZlnnmHdunWsWrXK/29aRERERESkKnONUKhVTEFGgJotwYSBlacRCqXkVUIh4JbfA8dW+f64dRKgz0tebZqdnc26des499xzAcjPz6dxY7sbZo8ePZg4cSIXX3wxF1988RmPNWTIEO677z4mTpzIhAkTaNasGdOmTWPatGnu+gUZGRls3bqVFi1alOWdiYiIiIiIVG8FuZDuJAhii2gZ6RISZk+HyNimEQqlVDUSCsdWwaHZAQ3Bsiy6du3KwoULT3vtp59+Ys6cOUyePJmnnnqKtWvXlnishx9+mLFjxzJlyhSGDBnC1KlTsSyLRx55hFtuueWkbRMTE335NkRERERERKqHjJ32qAOAWiUkFABi29oJhQwlFEqjaiQU6iQE/LiRkZEkJyezcOFCBg0aRG5uLlu2bKFz587s2bOHESNGMHToUL744gsyMjKIjY0lLS2tyGNt376d7t270717d5YuXcqmTZs4//zzeeKJJ5g4cSIxMTHs27eP8PBwYmNj1T5TRERERESktNI2Fy6fKaEQ0w6Yao9osCwwpkJDCxZVI6Hg5bSEihQSEsLXX3/NXXfdRWpqKnl5edxzzz106NCBq666itTUVCzL4q677qJ27dqMGzeOyy67jB9++IFXX32VYcOGuY/10ksvMXPmTEJCQujatStjxowhMjKSjRs3MmjQIABiYmL45JNPaNu2LUOGDKFbt26MGTOG5557LlAfgYiIiIiISNWR7pFQKGnKA9gjFADy0iE7GaIaVlxcQaRqJBQC7Mknn3Qvz5kz57TX582bd9q6Dh06sGbNmiKP9+qrrxa5/u677+buu+8+bf1nn33mZaQiIiIiIiICFHZ4iKgLUfVL3jbGo3Vk+jYlFLzkbdtIERERERERkarDNUIhtoQODy6xHgkFdXrwmhIKIiIiIiIiEnxcNRTOVD8BIKY14NRNUKcHrymhICIiIiIiIsElJxWyDtrL3iQUQqMgupm9rBEKXqvUCQXLsgIdQrWiz1tERERERIJCaTo8uMQ4hRk1QsFrlTahEBUVxZEjR3ST6yeWZXHkyBGioqICHYqIiIiIiEj5lKbDg3s7p45ChhIK3qq0XR6aNWvG3r17SU5ODnQo1UZUVBTNmjULdBgiIiIiIiLl4+rwgClsCXkmroRC9hHISYGI2hUQWHCptAmF8PBwWrduHegwREREREREpKpxjVCo2cquj+CNGI/EQ8Z2qNvH52EFm0o75UFERERERESkTErT4cHFs3Wk6ih4RQkFERERERGRYGBZsPk/MP1sSJ4f6GgCxyqA9K32cmkSCqeOUJAzUkJBRERERESkqsvLhAVXwfI74dAcWP9MoCMKnMw9kH/CXi5NQiE8FqIa2ssaoeCVSltDQURERERERLxwfDfMuRiOrSxc59nloLrxbBkZ26F0+8a0g6xDGqHgJY1QEBERERERqaoOzYFf+hYmE0Jr2N8zdkJBXuDiCiR3hwdKN0IBCqc9aISCV5RQEBERERERqWosC7a8BjNGQnayva7DndD7387reXB8V+DiCyTX6IywmlCjaen2dRVmPLHfnkYiJVJCQUREREREpCqxLFhyCyz7k504CImAAe9B31egVufC7arrU3bXlIfYDmBM6fb17PSQscN3MQUpJRRERERERESqkgO/wva37eUajWHUbGj7R/vnk26Iq3lCobTTHeDkTg/VNSFTCirKKCIiIiIiUpUcXly4fN4iqNmi8OcaTSA0CvKzClsnVid5mZC5214ubUFGOCUho8KMZ6IRCiIiIiIiIlVJ6jr7e3SLk5MJACbE7lQA1fMJu2cSpSwjFCLqQnicc6xq+PmVkhIKIiIiIiIiVUnKWvt77e5Fv+56yl4dpzykl6PDA9g1F6rz51dKSiiIiIiIiIhUFfnZhTfNtbsVvY37hnhH9Wsd6aqfAGWb8gAeIzw05eFMlFAQERERERGpKtI2gZVvL8cVN0Khvf29IBcy9/gnrsrClVCo0QTCY8t2jFinMGPmLsjP8U1cQUoJBRERERERkaoiZV3hcnEjFGI8CgtWtzoAaZvs72WZ7uDi+vysAjieWO6QgpkSCiIiIiIiIlVFqlM/wYRCrU5Fb+PZqaA6dXrIz4aUNfZycaM3vBHr0TpSnR5KpISCiIiIiIhIVeEaoRDbAUIji94muhmEOK9VpxEKx1ZDgTNFof7Ash+nOo/wKCUlFERERERERKoKV8vI4qY7gN060vWUvTqNUDiyqHC5/oCyH6dGYwitYS9rhEKJlFAQERERERGpCnLT4Pgue/lMQ/pdhRmrU+vDw4vt75ENoGbrsh/HGIhxJWSq0edXBkooiIiIiIiIVAUp6wuXSxqhAIXD9jN2QEF+xcVUmbhGKNQbYCcFysPdelMJhZIooSAiIiIiIlIVuAoyAtQ+0wgF54a4IKd6tI7MSraTJ1C+6Q4u7oTCzuqTkCkDJRRERERERESqAldBxtAaZx7S75ryANXjKfuRxYXL5SnI6OKa8lCQAyf2lv94QUoJBRERERERkaogxRmhENcVQkJL3ja2mnUqcNVPwEDdfuU/3kmfnwozFkcJBRERERERkcrOsgqnPJypfgJAjWYQEmEvV4dOD64RCnGdISKu/MdzjVCA6jHCo4yUUBAREREREanssg5C9hF7Oc6LhEJIaPXpVGAVFCYU6vmgfgJAdHMICbeXg/3zKwclFERERERERCq71HWFy2cqyOhSXToVpG22W2qC7xIKIWGFdSoyNOWhOEooiIiIiIiIVHYpHgkFb0YoQGHryPTt9lP8YHV4UeGyLwoyulSXER7loISCiIiIiIhUWnl5+ViWFegwAs9VkDGiLtRo7N0+tZxODwXZkBnEnQpc0x1Co+2Clb7iGuGRvhUKcn133CDiVULBGJNojFlrjFlljFnmrKtrjPnVGLPV+V7HWW+MMa8YY7YZY9YYY3pX5BsQEREREZHgtGj1Fsbe8TS3/v1NCgqC+Am7N1xTHmp3A2O82yemmnR6cNdP6GdPVfCVev3t7/knTh4FIW6lGaEwwrKsBMuy+jo/PwzMsCyrPTDD+RlgDNDe+boZeMNXwYqIiIiISPWwdN02HnrhI1LSj7NqUyK7kw4HOqTAsQogdb29HOdl/QSA2PaFy8Ha6SHvOKSssZd9VT/BpfF5hctJv/j22EGiPFMexgMfOssfAhd7rP/Isi0CahtjvByTIyIiIiIi1d3KjTt44N8fkp2b516399DRAEYUYMcT7Rtn8K5lpItnp4JgLcx4dHlhfYj6Pk4oRDWEun3s5f1KKBTF24SCBUwzxiw3xtzsrIu3LCvJWT4AxDvLTYE9HvvuddaJiIiIiIiUaO2WXdz33AdkZediPIb27z90JIBRBZirfgJ43+EBnNaRbezlYB2h4DkVoZ4PCzK6NB5tfz+2Ak4c9P3xqzhvJ5gMtSxrnzGmIfCrMWaT54uWZVnGmFJVSnESEzcDxMfHM2vWrNLsLlVQRkaGfs9SoXSNiT/oOpOKpmtMKlplvsb2HErl7Z+Wkp2bhwF+N7w7385ZR25+AYuWr6FhZPUsjNcifTJOWoB5a4+RFzLL6327ZdelPnD8wGqW+vH37q/rrOvRH2kAZIU0YNGSLcAWnx4/LjueXs7yxpkvczD6vBK3D0bDhw8v9jWvEgqWZe1zvh8yxnwH9AcOGmMaW5aV5ExpOORsvg9o7rF7M2fdqcd8C3gLoG/fvlZJQUpwmDVrVokXo0h56RoTf9B1JhVN15hUtMp6jW1O3Mc/PnnbPc3hsZsvY9zwvizd+iI79h4kJCK6UsbtF/P+C+lAdDOGnnNh6fZdPgA2L6SmdYDhZ58Fxj+N/vx2nX23HYCopmczfFgFnK9gKHzzBOSm0rn2bjoProBzVGFnvJqMMTWNMbGuZeA8YB0wCbjW2exa4AdneRJwjdPtYSCQ6jE1QkRERERE5CTbdh/gzqffJT0zC4A/33AJ44bbteCbxtcFYO/BajzlwdXhoTQFGV1crQ/zsyDztOe8VVvmXjix3172df0El5AwaDTKXk6aWlivQQDvaijEA/OMMauBJcBPlmX9AjwDnGuM2QqMcn4GmALsALYBbwO3+zxqEREREREJGn9740tSMzIBuP/acUwYWXhz2LShnVDYf+ho9WwdmZ8DaZvt5dIUZHTx7PQQbIUZDy8uXPZ1hwdPjc+3v2cfhqMrKu48VdAZpzxYlrUD6FnE+iPAyCLWW8AdPolORERERESC2pGUdLbssgc0XzlmKL87f8hJrzdrWA+A7Nw8jqRm0KBOLb/HGFDpm8Fyul2UpiCji2uEAkD6Nogf4Zu4KoMjTkFGE1rYjaEiuBIKYLePrNe34s5VxfhnAo2IiIiIiEgRVm1OdC+f3a/raa83ja/nXq6W0x5S1hUux5VhhEJ0CzDOc+Rg6/TgGqFQuweERVfceWq2gLgu9nKS2kd6UkJBREREREQCZrWTUAgPC6VLm2anve6a8gD2tIdqx9Uy0oRAXOfS7x8S5tE6MoimPBTkwtFl9nL9CmgXeSpX+8jDCyHnWMWfr4pQQkFERERERAJm1aZEADq3aUZkRPhprzduUAdjDFBNRyi4CjLGtofQqLIdwzXtIZhqKKSsg/wT9nJF1k9wcSUUrAI4MKPiz1dFKKEgIiIiIiIBcfxENlt32VX6Ezq2KnKbiPAwGta16yZU6xEKZenw4OIqzJi+LXi6FBzxU0FGl4bDILSGvZw0teLPV0UooSAiIiIiIgGxbttuCiwLgJ7FJBSgsI7C3oPVLKGQmw7HE+3lsnR4cIlxtY48ASeSyh1WpXDYKcgYXhtqdaj484VGFRa0TPoFnOu2ulNCQUREREREAmLVpp3u5e4dWha7nauOwr5D1WzKQ+r6wuWydHhwObXTQzBwjVCo19+uL+EPrmkPmXshdYN/zlnJKaEgIiIiIiIB4SrI2LZ5PHExxVfpd7WOPJZ2nOMnsv0RWuVQ3g4PLq4pDxAcnR5yjkHaJnvZHwUZXVwJBVC3B4cSCiIiIiIi4nd5efms27YHgJ4dWpW4bROPTg/VapRCyhr7e2gUxLQt+3FqtixsHVnVCzMW5MPavxX+7I/6CS6x7aBma3tZCQVACQUREREREQmATYn7yM7JBUqunwDQLL6ato48NNv+XqcXhISW/TghYVCzlb1clUco5KbDnIth88v2zzWaQsOz/Hd+Y6CJM0rh0BzIO+6/c1dSYYEOQEREREQk2OQXFHDwcAq7kw6z58Bhdh9wvicdJiQkhGfvvYq2zRsFOsyAck13gDMnFFxFGaEaFWbMOlQ4QiF+ZPmPF9veHp1QVWsoZCTC7HGFbTTjusDZkyE8xr9xNB4NW9+Aghw4OAuajvXv+SsZJRRERERERHxo08593P3Me6SkF//08qupC3jkxgl+jKrycSUU4uvF0bhBnRK3rVWzBjHRUWRkZlWfEQoHZxYuN/JFQqEdJOG0jrTsp+1VxaF5MHcCZCfbPze5AIZ8DuG1/B9L/AgICYeCXLt9ZDVPKGjKg4iIiIiID301dcFpyYSoyHDatWhEnVr209T12/cEIrRKw7IsVm/eBZx5dAKAMYamDV2tI6tJDYUDM+zvoTWg/qDyH8/V6SE/s2q1jtzxAfx2TmEyodN9cNakwCQTAMJjocFQe1l1FDRCQURERETEV/ILCpi/0q4+36NDS265/DxaNK5Pgzq1MMbw2uc/89Hk2WzffYDMrGyioyIDHHFg7Nqf7E66eJNQALt15ObEfeyrNiMUnIRCg2EQ6oPrpFbnwuVjKyG6SfmPWdF2fASL/mgvh4RDvzeg7Q2BjQnsaQ8HZ9r1KNK3Q2w5CmZWcRqhICIiIiLiI2u37HbfKI8b3pe+XdvSsG4cxhle3rVdcwAKLItNO/cFLM5AW70l0b2c0LG1V/u4CjMmHT5GXn5+RYRVeWTshIwd9rIvpjsA1B8Axrn9S57nm2NWtM0v2d8j6sA50ytHMgGg0ajC5cMLAxdHJaCEgoiIiIiIj8xdsQGwh+gP7dX5tNe7tmvhXl63dbff4qpsXPUTYqKjaNOsoVf7uFpH5ucXcOhIakWFVjm4pjuA7xIK4bWgdk97uSokFDJ22CMpADrc6d9uDmcS180eMQGFMVZTSiiIiIiIiPjInOV2QqF7+xbUjTu9+nyDOrWIrxcHVO86Cqs2JQL2tJCQEO9uSZp5dHoI+mkPrukOEXWgdoLvjuua+39kCeRn+e64FWHPt4XLzS8NXBxFCY2wkwqghEKgAxARERERCQaJ+w6xO+kwAGf16VLsdl3b2qMU1m3djWVZfomtMkk+luZOCCR08m66A9g1FFyCujCjZcHB3+zl+BEQEuq7Y7sSCgU5cGSZ745bEXZ/Y3+PaQe1uwc2lqLU6WV/P7rS/p1VU0ooiIiIiIj4wNwVG93Lw3qfPt3BpVt7u47C4ZR0Dh0N8qH7RVjjTHcA6Nmhldf7NawXR2ioffsS1K0jU9dB1iF7Od5H0x1cXAkFqNzTHjL3wpFF9nKLyypni8u6ve3vuSlwPDGQkQSUEgoiIiIiIj7gmu7QonF9WjUtvi6Aa4QCwLpt1W/awyonoRAeFkrnNk293i8sNJTG9esAsPdgECcUTqqfMKr47coiugnEtLGXk+f69ti+tOe7wuXKNt3BxTVCAar1tAclFEREREREyuloagZrnSKLw3oXP90BoFPrJu4n7eurYULBVZCxc5tmREaEl2pf17SHoK6h4EooRDeD2Pa+P75rlELyfLAKfH98X9jjTHeo2RLq9glsLMWp3QNwRk4cVUJBRERERETKaN7Kje56CCXVTwCIioygXfPGAKzbVr06PWRkZrF1VxJQuvoJLq7CjPsOHQnO+hMFuXBotr0cP7Jihvo3GGZ/z02F1PW+P355nTgIh+bYy80mVM7pDgDhMVCrg72sEQoiIiIiIlJWc5fb9RNqx9ake4cWZ9gaurWz6yhs2rmPvLz8Co2tMlm3dTcFTiKgZ8dWpd7f1ToyIzOLtIxMX4ZWORxZCnnp9rKv2kWeyrOOwqFKOO1h7/eAkyxqUUmnO7i4pj0cWxHYOAJICQURERERkXLIys5h8dqtAAzp1YlQL9oguhIK2Tm5bNtzoELjq0xc9ROMMfRof+bEy6maxRd2egjKaQ+e9RN8XZDRpVZHiHRacFbGwoyu6Q41GkP9QYGN5UxcCYUTSfbIimpICQURERERkXJYsm4b2Tm5AJx9hukOLl3bFd5MV6c6Cqu3JALQtlk8tWKiS71/k5NaRwZhQuGgk1Co1ckuoFgRjPGoo1DJEgrZR+HgTHu52SVgKvntqgozKqEgIiIiIlIec53uDpHhYfTv7l0RveaN6lGrZg0A1m+vHnUUcvPyWO8UrizLdAeApg3ruZeDrnVkXiYcXmgvV9ToBBdXHYXMPXB8V8WeqzT2TQIrz16urN0dPCmhoISCiIiIiEhZ5RcUMHfFJgD6dWtHjagIr/YLCQmhS1t72sO6rdVjhMLWXUlk59o3iz06tCzTMWrWiKROrZoA7D10xGexVQrJ86Agx172dbvIU51UR6ESjVLY7Ux3iKwHDc8KbCzeiKoP0fbf8RkTCrlpsPkVOB5cCUQlFEREREREymjDtj0cS8sAYJiX0x1cXHUUdiUlB2eBwVNsTtzvXu7StlmZj+MapRB0NRRc9RNMCMQPr9hz1ekFofYImUoz7SE3DQ5Ms5ebXQwhYQENx2uuUQpnah25/2dYfjf80LJyFsMsIyUURERERETKaI4z3QFgWO/OpdrXs47Chu17fRZTZbXFSSjUiIxwt38sC1dhxn0Hg2yEgqt+Qp0+EFG7Ys8VGgH1B9rLyZXk5nbfT4UjNKrCdAcXV0IhYxvkpBa/3d7v7e9hsVCvf4WH5S9KKIiIiIiIlJErodC1XXPq1Y4t1b5dPZ7Sr6sGdRS27EoCoH3LxoR40QmjOK7CjIeOppHjTKGo8rKPwlGn9WBFtYs8lWvaQ+p6+/yB5uruEB5X8TUkfKmuRx2FlNVFb5OfbSdMAJqOhdDIio/LT5RQEBEREREpg91JySTuTwbgrFJOdwCIi61J80b1geDv9JBfUMC2PXZCoUPL8nUvcI1usCyLpORj5Y6tUjg4E7DsZX8nFAAOL/DPOYuTl2lPCQBoepE9gqKq8CzMWNy0h4MzIS/dXm52cYWH5E9KKIiIiIiIlMGc5Rvdy2VJKIA9sgHshIJlWT6JqzLak3SYrGy7tWaHVo3LdayTW0cGybQH13SHkEioP8Q/56w/qLAtY6Dn9Cf9AvlOHZEWVWi6A9hFGSOca7K4woyu6Q4hEdBkjF/C8hclFEREREREymDBKru7Q7P4erRu2rBMx+jm1FFIzcgMnpvjIrimO4DvRihAELWOdBVkbDAEwmr455zhsVA7wV4OdGFGV3eHsJrQ6LzAxlJaxkDd3vZyUQkFqwD2/mAvx4+E8Fr+i80PlFAQERERESmlgoICNu6wCyn26dIWY0yZjuPq9ACwLoinPWzZZRdkDA0JoU2z+HIdq15cDJHhdgeAoGgdeXQlpG+xl/013cHFNe3h6FLIO+G74+aVomtJfhbs/9FebjLWfwkVX3JNe0hdb78fT4cXQ9YBe7n5Jf6Nyw+UUBARERERKaXdSYfJzLIr0penBWK7Fo3cN8frtwVvYUZXh4fWTRsSGRFermOFhIS4pz1U+daRlgUrH7SXTRi0+L1/z9/QSSgU5NpJhfIqyIUlt8BXNWmT9pZ3++z82G4ZCdDi8vLHEAiuhIKVDynrTn5t73fOgoGm4/walj8ooSAiIiIiJcrKySX5WFqgw6hUNu7c517u3KZpmY8THhZGx9b2/sFamNGyLPcIhfYty1c/waWpK6FwsIonFJJ+Kayf0P5WiG3r3/N7FmYs77SH3HSYPQ622YmE5hlfQtqWkvexCmDTv+3l6ObQbHz5YggUz8KMntMeLAv2OAmF+oOgRiP/xuUHSiiIiIiISLFy8/K4+pGXufCOp/nbG19xWIkFADZst2/+I8LDyj2E3zXtYcuuJLJzcssdW2VzOCWdY2nHAejYqnz1E1yaOnUU9h06WnWLWRbkw8qH7OXwWtDtL/6PoUZjiHGSGIfKkVDI3A/Tz4Kkqe5VhgJYc4b3tO9HSNtsL3e8B0LKN3olYGLbQ2i0veyZUEjdABnb7OUgnO4ASiiIiIiISAmWrN3G7qTDAEyZu4LL73+ejyfPJjcvL8CRBdYmZ4RC+xaNCQ8LK9exujqFGfPy891TA4LJZo/31L6cBRldmsXbIxSyc3I5kpLuk2P63c4PIdUZHt/lYYhqEJg4XKMUDs+3kxyllbIepg2CY6vsn5uMheZOp4bdXxauL8rG5+zv4XHQ7qbSn7uyCAmFOj3tZc/Wka7uDhB07SJdlFAQERERkWLNWLwGwF10MDMrh/98/jN/+PNLLFy9OZChBUxefr77Jrlzm7LXT3Dp2tajMOP24Jv2sHVXYUKhg4+mPDRpWNjpYW9VnPaQdxzWPGEv12gKHe8OXCwNh9nfc9MKExzeOjgLfh0CmU79j3a3wFnfQ8IzFBBqr1v9WNH7Hl5UOM2i/a1214mqzDXtIWV1YWLGlVCI6wax7QISVkXzOqFgjAk1xqw0xvzo/NzaGLPYGLPNGPOlMSbCWR/p/LzNeb1VBcUuIiIiIhUoJzeP2cs2AHB23y68/PD1tGpiP0XdnXSYe559nwee/5ADh1MCGKX/Je5Ldk9NKE/9BJdG9WtTr7Z9M7Vua/AVZnQlXxrXr02tmGifHLOZU0MBYH9l6/Sw9b8wbUhhq8CibHoRTjiJlp7/gDDffC5l4llH4dBs7/dL/AJmng+5qfbPPZ+Gfm9ASBjEtuNA9AX2+v1Tip5OsfF5+3tIOHS4q2yxVyau1pH5JyB9MxzfA0eX2euCdHQClG6Ewt3ARo+fnwVetCyrHXAMuMFZfwNwzFn/orOdiIiIiFQxi9dsISPTboE2amAPBvbowKfP3MPdE8cSXSMSgLkrNnL/8x9U3XnsZeBqFwm+GaFgjHGPUlgflCMUkgDo4KP6CQCNG9Rxj5rZW5k6PRTk210bDi+AORfDsjtPbyN44iBscG6RaveAVlf7PcyTxHaAGs7vZv8U7/ZJ2woLr4KCHDshMOhj6PoIeLRPTYy9GkKj7B9WP2oXKHRJ3wZ7vrWXW02EaN9dGwHjWZjx6MqTE0rNL/Z7OP7iVULBGNMMGAu84/xsgHOAr51NPgQudpbHOz/jvD7SlLUxr4iIiIgEzPRF9nSHqMhwhvbqDEBYWCh/GDuMr//9AGf37QLAtt0HSNyfHLA4/W3jTjuhEBUZTssmvpn33q29XUchKflYUBW+zMjMYu9BewRBBx/VTwCIjAinUb044OQET8Clb4W8jMKft/wHpg4sLDwIsO7/CrdJ+Jc9/z6QjIGmF9rLB2fa3RrOZM/XdotEgLMmQ+urTtskJ7QBdPiT/UPyXEiaVvjiphcBJ8HQ6YGyx16ZxHW1W3+CXZjR1S4yujnU6R24uCqYtyMUXgIeAgqcn+sBKZZluarx7AVc472aAnsAnNdTne1FREREpIrIysllznJ7usPQXp2pERVx0uv1asdy2+9Hu39evOYM7eGCyKYddkHGDi2bEBbqm5vBHk5CAWD1ll0+OWZlsHV3knvZlyMUAPp2s+ekL9+wg6zK0h3j2IrC5RhnznzKavilD+z40E4sbHvTXt/oXGhyvv9jLErTi+zvBTkn3/gXx/X0vVbnkt9D5z9DmFMbYfWjdpvIrMOw4317XeMxULtr2eOuTEIj7aQC2K1AXdNHml180siNYHPGkrTGmAuBQ5ZlLTfGDPfViY0xNwM3A8THxzNr1ixfHVoqqYyMDP2epULpGhN/0HUmFa2yXGPrdh4kMysHgEYxIUXGZFkWcTWjSD2exc+zFtOoRvB3fsjLL2Bzop1QiI3AZ7+r3Lx8QkMM+QUWU2bMI/RExdUF8Oc1Nn9donv5SNIuZs065LNj1w63n5Bn5+TywRff06lFgLokeGiTOokWQAGhzI95hRZ8QsuMz+wijIuuIyekDhFWPhaGZfm/43gl+FsHCLHCGGIiCbWyObD8bTbtKP55cET+EQYfWQzAroJe7CzmPWRkZDBr0Tpa1riU1ukfwLEVrP/l70TnJdI6/wQAq3LOJaWSfAa+0DG7MY1ZfVJni1VHWlf59zh8+PBiX/Omx80Q4CJjzAVAFFALeBmobYwJc0YhNAP2OdvvA5oDe40xYUAccNq/iJZlvQW8BdC3b1+rpCAlOMyaNavEi1GkvHSNiT/oOpOKVlmusV/XfAZAjcgIbrrqUqIiiu4PP3/rESbPWkbioRQGDxlKRHj5WihWdpsT95GXbz/BPfesgQwf2usMe3jvizmbWbdtN0cz8yv0GvDnNTZ38/8AqBUTzcVjR+PLmdD9BmTz+W9ryMvPJy0vvFL83TDjH3AcQmp3Zdg5Y4AxkHQtLLwasg4RUXAMANP6GvoNujGwsZ5qzmjY+wONCpbT6KxhxU/F2PY2HLQXWw76Ey0bDCpyM/d1ltsbJk2G7CN0zfsMcpyaF3X7kHDePcH19H7zGlj+S+HPEXVJOPdOu1BlkDrjlAfLsh6xLKuZZVmtgCuA3yzLmgjMBC5zNrsWcFWdmOT8jPP6b1Z1qtIjIiIiUsWdyMph3kq7FvewPp2LTSYA9O/WHoCs7FzWbg2eofrF2bDdoyBj6/J3ePDUo2NLADbv2s8JZ3RIVbfF6fDQoWVjnyYTAGrWiKR359YAzF+1KfCFQS3LnjsPhRX/ARqfB2NW21McwJ4C0OPv/o/vTFzTHrIPw5FFxW/nmu4QFQ/1B5z5uOG1oMsj9nL6Fvv4YNdOCKZkApxeK6HpuKBOJkDpujyc6s/AfcaYbdg1Et511r8L1HPW3wc8XL4QRURERMSfFqzaRFa2PSd91MAeJW7bv1s7943i4jVbKzy2QNvo1E+IjoqgReP6Pj12QodWAOTnFwRFt4fcvDx27LWnOPi6foLL4F6dADhwOIUdew9WyDm8lrm78Ol7nVNGrtRoBCN+gZEzYcxKqNnc//GdSZOxgHODv3dS0dvkHYcD0+3lpuPAeHk72f52qOGRgKvZClpcVuzmVVadnrg/QwjqdpEupUooWJY1y7KsC53lHZZl9bcsq51lWZdblpXtrM9yfm7nvL6jIgIXERERkYrxq9PdoWaNSAb26FDitrVr1aSjc7O4eG3wJxQ2OR0eOrVuSkhIeZ7Nna57h5bu5TVbEn167EDYufcQefl2nQNfdnjwNCShk3t5/spNFXIOrx1dWbh8akIB7Jvv+OEQ29ZvIZVKjXio54w42De56G2SpkFBtr3sGtHgjbAa0P0vhT93ujc4n9yHx0KsU4wztIY9OiXI+fZfQRERERGp0jKzslng3Jid1acLkSVMd3AZ0N2e9rA5cT8paccrNL5Ays7JZdueAwB0buP7J8x142Jo3sge9bAmCDo9bNm1373csYJGKLRoXN/9mc1fFeCEwjHPhEJCwMIol2bj7O9pGyF92+mvu6Y7hNaARqNKd+w210PHe6HdrdDulvLFWZk1dT7DVn+AsOjAxuIHSiiIiIiIiNvcFRvJzrW7NYwa1NOrfQb0sBMKlmWxdH0RNyFBYtvuA+Tn213UO7fxbf0Elx7OKIU1W3aRX1Bwhq0rt81O/YTI8DCfTw/xNKRXRwDWbtlNWkZmhZ3njFwJhdj29pPqqshz1MGpoxQK8mH/j/Zy4/PsUQelERIGfV6A/m/YLRaDVcK/7GktfV8PdCR+oYSCiIiIiLhNX2hPd4iNjmJA93Ze7dO9fUuiIu2RDME87WHjTo+CjG2aVcg5Ejq2AuD4iezA1wQop627kgBo27wRYaHFdAzwAde0h/yCAhYFso7H0RX296KmO1QVcV3t+gZweh2Fwwsg22ne13S8X8OqUkJC7REqoRGBjsQvlFAQEREREQAyMrNYuHozAGf360p4mHdznCPCw+jduQ1gF2YMeLX9CrJxh51QiI2OomnDuhVyjh6edRQ2V91pDwUFBe4pD+0rqH6CS6/OrYmOsm/eAjbtISsZTtgFO6t0QsGYwlEKyXMh51jha/tcCQYDTcf6PTSpnJRQEBEREREA5izfQG6eXUTv3IHeTXdwcdVROHQ0lcT9yT6PrTLY5HR46Nymmc9bILq0bNKAuBh73nVVLsyYlHyM4yfs4n0VVT/BJTwsjP7O9bdw1ebATBXxrJ9Qt3fx21UFzZyEgpUP+392lq3C+gkNBkNUw8DEJpWOEgoiIiIiAsAMp7tDXEw0fbuWrhL9AI9uEEuCcNpDVnaOewpCpwqa7gBgjHGPUli9ObHCzlPRNnsUZOzQsnGFn8817SE1I5MN2wLQcvPYGTo8VCUNhkF4LXvZVUchbROkO3/Xmu4gHpRQEBERERHSMjLd88+H9+tGWFjp5ry3atKAhnXjgOCso7BlVxIFzlSOiirI6NLTqaOQdDiFQ0dTK/RcFWVLol0/wRhDuxYVn1AYnNDRvRyQaQ+u+gk1mkJUA/+f35dCI6DxGHt5/89QkOsx3YHCEQwiKKEgIiIiIsCCVZvJy3emOwzqUer9jTH0d4o4Lt+wnRynU0Sw2LC98Kl359YVN0IBTqmjUEXbR251Rii0aFSfGlEVX5yufp1adGptJ3rmrwxAQsE1QqGqT3dwcbU+zE2FQ3MLpzvU6mh/iTiUUBARERERVmzcCUCNyAh6dWpdpmMM6G5Pe8jKzmXt1qp5I1ycjTvt+gm1Y2vSqH7tCj1Xp9ZNCXdGiFTVaQ+uKQ8dKrh+gqchvexpD1t2Jfl3ZEdueuF0gKo+3cGlyRgwziil7W/D4UX2clONTpCTKaEgIiIiIqzaZCcUundoWerpDi79u7VzFytcHMj2fRVgk9PhoSILMrpERoS721KuroKdHo6lZZB8NA3wT/0EF1cdBbBH3PjNsdWFy8GSUIisCw2G2su7vgCczi3NVD9BTqaEgoiIiEg1dyQlnV1JdmeGXp1alfk4tWvVdFf0X7Jumy9CqxQyMrPYlXQYqPj6CS6uOgrbdieRmZXtl3P6ypZdSe5lf45Q6NymKXVqxQB+nvZwbEXhcrBMeYDTRyNENoB6AwMTi1RaSiiIiIhItTJj0RrufPqdKjs3vSK4RicAZZ7u4OJqH7lp5z5S0o6X61iVxZZd+7HcBRkrtn6Ci6uOQn5BAesD0bWgHLYkenZ48F9CISQkhMEJ9rSbpeu2+a+Oh6t+QkRdiG7un3P6g6uOgvvnCyGkbKOXJHgpoSAiIiLVRkFBAc998ANL1m3j/uc+YN/BI4EOqVJY6SQUIsLD6NK2fDdE/Z2EgmVZLF0fHKMUNjrTHcCPCYX2hYUZA1lHYf+ho9z05Bv85/OfyS8oOOP2uXl5zFq6HoAGdWpRNy6mokM8iWvaw4nsHFZs3OGbg+amQ/r24l8/6iQU6vSCCp4O41e12kOtwmkkmu4gRVFCQURERKqNrbuTOOY8NU87foKHXviYE1k5AY4q8FY6BRm7tm1OZER4uY7Vo0NLoiLtYwRL+8iNO+yCjPVrx9KgTi2/nLN2rZq0amK3H1wdwNE0n/w4hzVbdvHx5Nn8851vKSghqWBZFv9482vWbdsNwFl9u/grTLcBPToQGmrf4vhk2sOxNfBLX5g91k4snCo/G1LtBAp1g6R+gqfml9rfw2Kh0ajAxiKVkhIKIiIiUm0sWXvyE/Ntew7wj7e+dg9nr45SMzLZtucAAAnlnO4A9iiH3p3bAHZhxsr42ZY2po0eBRn9yTXtYd223V6NDvA1y7JYuHqL++fJs5bx3Ps/FPv5vfHlVH6ZvwqA7u1bcNfEsf4I8yQx0VHu+hM+SSjsmwzpWyBtMyy5GU5976nrwHKmVtQJovoJLt0eh+7/B2dPhrCagY5GKiElFERERKTaWOI8MW/SoC79u7UDYPqiNXw8eXYgwwooz+H0vTuXP6EAhXUUDh1NZdf+ZJ8c0xcsy+KB5z/kwjue5ouf55GXl3/GfVLTj7PXmRrTyU8FGV16dGgFQOaJbLbvPuDXcwPsOXCE/clHAQgLtefOfztjMS98NPm0pMK30xfx4aRZADRvVJ/n77+WqHKOdimrwT07ArDv0FH2HDhcvoN1fQQanWcv7/oCtr158uuu6Q4QPB0ePIVGQfcnIP7sQEcilZQSCiIiIlItZOXkssq5eR7Qoz3/uPNKmjSoC8DrX05l4Wo/tpmrRFY688xDQ0Po7jFvvzwG9OjgXl60ZksJW/rXjr0HmbtiI4dT0nnx4x+5+tFXWFpMN4q8/Hx+mLmEiY+87F7XqbV/Ryj07BjYOgqL1hT+Tfz7gWtpFl8PgK+mLuDVz352JxXmLt/Ac+//AECdWjV56c9/pHatwD3NHtjT8/or57QbEwKDP4EaTjJp+d1w1KOrg6sgY2g0xLYv37lEqiAlFERERKRaWLM50V31vX/3dsTF1uRf919NVGQ4lmXxxKufl/9pZhW0clMiAJ1aN6VGVIRPjtmqSQMa1LVrDRR3wx4Ia7fuPunnHXsP8qen3+Hhlz5xP4m3LIsZi9dy5UMv8vTb35J8NA2Ajq2a0LdrW7/G27xRfeo4N+aBqKPguhlvUKcWA3q05/XHb3In4T79aQ5v/m8aG7bv4fH/fE6BZREZEc6/H7jOnXgIlHbNG1G/diwAi32R0IpqAEO+ABMKBTkw73LISbFfcyUU6iSoA4JUS0ooiIiISLWwxLmxNcbQp4t9Y9i+RWOeuOVyANIzs3johY/JzMoOWIz+dvxENpt32gUHXXUPfMEYQ/9u9tPaFRt3eDW1wB/WbrVvymOio7j9itHUiLQTKDOXrOOKB17g5U9/4rrH/8OjL3/K7iQ7uRRfL47Hb76M9/5+h9+H8Btj3HUU1mxJ9Ou5c3LzWL7B7mwwoEd7jDHE16vNa4/fSHy9OADe/34mt/79LbKycwkxhqfuvJKu7QLfNtEY4x4ls2z9dnLzfNA+suFQ6PlPezljByy6Hgry4Nhqe10wTncQ8YISCiIiIlItuOondG7dlLiYaPf6UQN7cM04e37wjr0H+ft/q0+RxjVbEilw3qsvCjJ6ctWoyMzKYe223WfY2j/WbrHj6NauBddeNJyv/n0/o4ckAJCdm8dnP81lk5NgqR1bk3uuvpD//fsBxg3v664h4G+uOgoHj6Ry4HCK3867enMiWdm5AAxyahKAXX/ktcducne7yM6xt3nwj+MZ1sf/XR2KM9BJKJzIzmH1Zh+N7uh8PzQdZy/v/Q6W/QnyM+2fg7HDg4gXlFAQERGRoHcsLYPNifsB6N/99HnOt/7+fPcNyG9L1rImgG36/MnVLtIYQ88Ovqmf4NKvezv38pJK0D4yNSOTXUl2gcju7VsA0LBuHH+74wre/MutdGzVBIDoqAhunDCSb158kCvHDC13G83ycnUsAP9OH3F1dwgxhn7d2p30WvNG9XntsZuo50wruG78CCaMGui32LwxoHs7jDGAj6Y9gF1PYeAHUNP5W/Es0KgRClJNKaEgIiIiQW/puu3u5f7d2532emhICH+57XJ3//pJs5b6LbZAWrnJTii0b9GI2Jo1fHrsenGxtGvRCDi9XWcgrPOon9DNSSi4JHRqxfv/+BNv/fVWvn/5z9x02bnEREf5O8QidW7TlNqxdh2FWUvX+e28roKMXdo2P2lEj0vLJg345oUH+ezZe7jt9+f7LS5vxcXWpIvT5tOnhUEj68KQLyHEI9EUEg5xXX13DpEqRAkFERERCXpL1tlPyKMiw4vtZFAvLpaznCHb0xetISMzy2/xBUJWdg4btu8FoJcP6yd4co0G2bB9D+nHT1TIObzlKshojKFbuxanvR4aEkLPjq2Iiw1cd4KihIWGcnZf+7pcvHZrua5Ly7LYujuJjbsOkZdffF2LQ0dT2b7nIACDPDomnKpGVARtmzcqczwVbUAP+/rbsiuJIynpvjtw/QHQ6/nCn+O6Qmik744vUoUooSAiIiJBzbIs95D7Xp3aEBEeVuy2Fw3vB0BWdi6/Llztl/gCZd22Pe6byl4+rp/gMsApzFhgWe4Cf4HiKsjYplnDSjP6wFsj+ncDIDcvn/mrNpVq3xNZOcxdvoFn3v2O8Xc9w1UPv8wHU1fwr/e+L3Yfzyf6A0tIKFR2Az3al55p2kNK2nGSj6V5f/AOd0Kb6+zlVleVITqR4KCEgoiIiAS13UmHOXgkFbDnVZdkQI/2NKxrV7CfNDO4pz2scqY7gD3kvyIkdGpFeJhdzDCQ0x7yCwrYsH0PAN3a+bZWhD/07drWnQSZueTM0x4KCgqYNGsp9zz7Hufd8n888O+P+G7GYvffAcAPM5eycuOOIvdf7LSLrBUTTWdn2kBV1LVdc/fn5mqBWZwPfpjJhHv+xb/e/967riTGwMD34dIjdrFGkWpKCQUREREJap4FAYsqyOgpNCSEccP7ArBhx1627k6q0NgCaYVzM9m6aUPq1IqpkHNERUa4iwouDmBhxu17DpCZlQNAjw6nT3eo7MLDwhjWuzMAC1Zt5oTzXorzy/xVPPXWNyxcvYWc3DznGKEM6N6eO64YTZhTK+SZ974/raViXn6++2+mf7d2hIZU3duFsNBQd0HJxWu3UlBQUOR2R1Mz+HbGYnJy80jcd4iwsFJ09Iis64tQRaqsqvsvhIiIiIgXFjv1E+rXjqVNs/gzbn/h2X3c1eGDdZRCbl6eu0hhRU13cHElcfYePML+5KMVeq7iuNpFAsXW0KjsXNMesnNyWegUTCyKZVl88fN8wO5YMX5EP/5139VMe+svvPLIDVxz0XBG9W4LQOK+Q3z609yT9t+4fS9pTr2LkuonVBWuaQ8p6cfdnV5O9fmUue72l9dfMtJvsYkEAyUUREREJGjl5eWzfIP9JL5ft8I2ciVp0qCu+6nmL/NWum80gsnGHfvIdp5cJ3Su4IRCN8/2kYGZ9uCqn1ArJpoWjesHJIbyGtCjAzUiI4CSpz2s3bqbzYn7AJg49iwevelSzu7bleiowqKBw3q0pnXThgC89+0M9h084n7Ns37CgB7Bk1CAors9pKYf5+tfFwLQo0NL+nSpmAKlIsFKCQUREREJWuu37yHzRDZw5ukOnsaPsIszph0/wexlGyoktkBa6VE/oaJHKHRs1cTddnBJgKY9uDo8dG/fwqukUmUUFRHOkF6dAJi3cpN7KsOpvpq6ALCH+18yckCR24SFhvDnGy4BIDs3j+c++AHLsgBY6Nx0t2vRiAZ1avn0PQRCo/q1adWkAVB0QuGLX+a7p8PccMnIKnt9iASKEgoiIiIStE6qn9Ct5IKMns7q08V9ExyM0x5cxfiaxddzF6GsKCEhIe4RH0vXbye/mHnsFeVoagZ7nSfw3dtXvfoJnlzTHjJPZBeZnEk+lsZvS9YCMHJAd+rVji32WL06tXbXC1m4egu/LV5LavpxdyvRQT07+jr8gHF1qli7dfdJbTfTj59wJ2C6tGnmbjMpIt5TQkFERESC1pJ19hD7ts3jqV+Kp60R4WGMGdYLgKXrt500JLyqy8vPZ/UWewpARXV3OFV/p7tGWkYmW4qZx15R1m3zrJ9QtRMKgxM6Eum0Pf2tiGkP381YTH6+nbC5/PzBZzzenVeOoXZsTQBe+Ggyvy1Z5x6pMDCIbq5d0x7y8wtYvr6wfelXUxe4EwzXX3KORieIlIESCiIiIhKUMjKzWL/NbhXYv1vpb44uGt7PvTx59jKfxRVoW3cluaeBVPR0BxfPz9/f3R5c0x1CjKFL2+Z+PbevRUdFup+2z12+4aT2hrl5eXw3YzEAnds0o1u7M7/XuNia3DXxAgAOp6Tz4keTAagRGUGPDq18HH3g9OrUmggnEeOa0nH8RDZf/GIXr+zQsjFDnS4aIlI6SiiIiIhIUFqxcYd7eH1p6ie4tG3eiG7t7CfaP85ZTl6+F73pq4CVGwvrJ/Tu7J8CdI0b1KF5I7sYor/rKKx1RmO0a9HopMKEVdWI/t0Bu77Hsg2FT9t/W7yOo6kZAPzuvEFeP22/YFhvejuFOV2FOvt0aeO+AQ8GUZERJDjJs0VrtmBZFt/8upC0jEzA7uyg0QkiZaOEgoiIiAQl141reFhomZ/Eu4ozJh9NY9GawBQULEl2Ti6zl65n08597qHqxSkoKGDZ+m38NHc5AA3rxtG4QR1/hAkUTntYs2UXWdk5fjlnXl4+G3bYNQGqarvIUw3t1Ymw0FDg5G4PrloAdWrVZNSgnl4fzxjDn6+/xH1MgIFBVD/BZZAz7SEp+RhbdyXx2RS7XWbb5vGc3bdLIEMTqdKUUBAREZGg5GpR2L1DS2pERZTpGCMH9nC36ps0c4nPYvOV1774hYde/JhrH3uVC+94mqfe+ppZS9dx3JnSALD/0FHe+vpXJtzzL+546h227T4AQN+ubf36VHaAM+0hNy//pC4T5ZGTm8evC1ezfc+BIl/fujvJ3fazWxWvn+ASW7OGu8jl7GUbyC8oYOOOve5aERef07/UowtaNW3I1ePOBuypIYN7Vv12kaca6PGe/vr6lxxLOw7AdePPISREt0QiZRU8Y5lEREREHEnJx9iVlAwU3siWRc0akZw7qAeTZi1j3spNHElJL7Fyvj/l5efzy7yV7p8Pp6QzadYyJs1a5h6VkVdQwIoNO07aLzwslLP7duXW353v13j7dG1LaEgI+QUFLFm3rdxdBDZs38Pf3/yaHXsPEh4WyvP3X3vSTSPA2q273Ms9OgTHCAWAc/p3Y+HqzRxLy2D15kQmz7JrfISGhHDJyIFlOuaNE0ZSq2YNGjeoQ9P4er4Mt1Jo3bQhDerWIvloGjv2HgSgZeMGjBzYPcCRiVRtSseJiIhI0Jm3cpN7+dSbzNK6aER/wK4QP2XuinIdy5dWbUok1ZkDfsGw3id1AMjNy2fJum0nJRM6tW7KA9eN56fXH+Opu/5AfL2KbRd5qpjoKLq0bQaUr45Cdk4ur33+Mzf85XX3jWFuXj4PvfARy9ZvO2lbV0HGOrVq0rRh3TKfs7I5q08XQp2n6t9OX8yvC1cDMLxf1zL/XsPCQvnD2GHu1pTBxhjj7vbgct344e7PUUTKRiMUREREJOjMW7ERgAZ1a9GxVZNyHatbu+a0btqQnfsO8fO8Fe6h4YE2a6k9fz40JIR7rr6QuJhosrJzWLZhBwtWbmLh6i3kF+RzTv/uXHh2X9q1aBTgiO3imGu37mbb7gMcSU2nXlzpRnus3bKLf7z1NYn77dEnYaGhjBnWiylzVpCdm8f9z3/IS3++3l0zw5VQ6Na+RVAV3atdqya9Ordm2frt7mQCeNcqsjob1KODezRH04Z1OW9IQmADEgkCSiiIiIhIUMnIzGKZ02t+WK/O5b6RNMYwekgv3vhqKtv3HGT7ngO0bR7Ym/OCggJmLVsP2J0a4mKiAbua/dBenRjaq1MgwytW/27teffbGQAsXbuN0UN7ebVfVnYOb/5vGp//PN9dfLJzm2Y8fvNltGvRiIE9OvDEq5+TlZ3Lff96n1cevoHGDeqQlHwMgB5BUpDR04j+3dzXOUD7lo1J6NgqcAFVAf26taNWzRqkHT/BjRNGnlSIUkTK5oxjfIwxUcaYJcaY1caY9caYvznrWxtjFhtjthljvjTGRDjrI52ftzmvt6rg9yAiIiLitnjtVneLx2F9fFO9/dxBPdzLnk+EA2Xjjn0kH00D4Ox+XQMcjfe6tWtOdA27deOiNVu82seyLB54/iM+mzIPy7KICA/jjitG887fbnOPuhg1sAd/ue13GGPIzMrh7mffc3c9AOgeJAUZPQ3v2/WkZNnvzhscVKMwKkKtmGje/OutvPrIDVxwVp9AhyMSFLyZNJQNnGNZVk8gARhtjBkIPAu8aFlWO+AYcIOz/Q3AMWf9i852IiIiUkF2Jx1291OXwukONSIj6NOljU+O2TS+Hl3bNgdg2oLVZ2zRWNFcoxOAKtXyLiwslP7uDgXryczKPsMesGnnPpY6tRG6tm3OR0/fxTUXDT/t6fKYob149KYJABw/kc2Hk2YBEBoaQuc2zXz4LiqH+nVquQtN1oqJ1vB9L7VpFk//7mUv1CoiJztjQsGyZTg/hjtfFnAO8LWz/kPgYmd5vPMzzusjjdKlIiIiFWLRmi1cfv/zXHz3s3z/25KA3+gGWn5BAfOdgowDerQnMiLcZ8c+d3BPAPYdOsqG7Xt9dtzSsiyLmUvs+gnd2rWgYV3/Flcsr7HOk+HMrBxmLFp7xu1/nL0csNsZPnPvVbRu2rDYbS8a3o8/X3/xSes6tGxCVGTZ2oZWdg9cexGDenbgr7deTpQPr3UREW95VdbUGBNqjFkFHAJ+BbYDKZZl5Tmb7AWaOstNgT0AzuupQPD1nhEREakEvp2+CLCfyP7znW+565/vsj/5aICjCpy1W3a7Ox8M7dXZp8ceNbCHe0j5tIWrfHrs0ti57xB7DhwG7Kr+Vc3ghI7Ud1pvTpq1tMRts3NymbZgFWAniLxJnkwYNZD7rhnn/rlnx+Crn+DSoVUTXvrz9Qzt7dtrXUTEW14VZbQsKx9IMMbUBr4Dyl3pxxhzM3AzQHx8PLNmzSrvIaWSy8jI0O9ZKpSuMfGHynSdncjOdQ/vd1mybhu/f+DfXNC/IwO6NCekmg0SnLJoMwAGMCeO+Px31aZxHbbvP8pPs5fRs2kMISG+/3zPdI3NWFFYiK9GQeW5HkujW6v6zFqVzpotu/jyux+JrxNT5HartyeRdvwEAK3r1/D6vcZHwRXn9GDb3iO0qxdRJT+jilSZ/h2T4KXrLHgMHz682NdK1eXBsqwUY8xMYBBQ2xgT5oxCaAbsczbbBzQH9hpjwoA44EgRx3oLeAugb9++VklBSnCYNWtWiRejSHnpGhN/qEzX2eRZy8gvsKc4PH33RBat3sykWcvIyc3n+/kb2H0si8duupRm8dVnoOAbP9rD47u1b8GFY873+fFTCqL55zvfkp6ZTa34FvTt2tbn5zjTNfbetDUAtG0ez2Xjx/r8/P7QpmM3Zq16HoADx+H3lwwvcrvvF78PQGx0FLdefVmpprBUkj/TSqky/TsmwUvXWfXgTZeHBs7IBIwxNYBzgY3ATOAyZ7NrgR+c5UnOzziv/2ZV9wmdIiIiFWCa022gTq0Yzu7bhcduvoyXH76eRvVrA7Biww4mPvwSqzYlBi5IP9qdlEzi/mTAd90dTjWifzd3McBpC/zf7WF/8lE2J+4HYHi/bn4/v6+0aFyf3k7BzClzV5Kbl3faNoeOprLY6QRx3uAEn9bDEBER3/CmhkJjYKYxZg2wFPjVsqwfgT8D9xljtmHXSHjX2f5doJ6z/j7gYd+HLSIiUr0dSU1n2Tq78v2ogd3dN7kDe3Tgs2fv5dJRAwHIys7lzf9NDVic/jTXY/rHsAqaUx4XE83AHnaF+JlL1hZ5I1yRZi8t7O5QFesneLpoeD8AUtKPM2f5xtNe/2XeSgqcZ1IXnq0WfyIilZE3XR7WWJbVy7KsHpZldbMs6/+c9Tssy+pvWVY7y7Iutywr21mf5fzcznl9R0W/CRERkermt0Vr3Tdb5w1OOOm1mjUieej6i/nDBUMBWLFxJ4n7Dvk7RL9z1ZNo2rBuiZ0Aysv1eacdP8HiNVsr7DxFcbWLbNKgLu1bNPbruX1tRP9uxERHATBp5snFGS3Lcnd3aN20YVC2fRQRCQZedXkQERGRysU13aFx/dp0b9+iyG0uGTnAvfz9b0v8ElegpGZksnrzLgCG9elMRXasHtans3v4vT+nPRxJTXe/x+H9u1boe/SHqIhwRg/pBcDitVtJSj7mfm3dtj3sSrKnr1x4dt8q/15FRIKVEgoiIiJVTFLyMdZssW8sRw3qWezNVovGDejjzFP/ae4KsnNy/Rajvy1ctZn8ggKg4qY7uERHRbrPMWf5BrKyc3xy3H0Hj/Da5z/z85LNHD6Wdtrrc5ZtwFWWakQVrp/gafwIe9qDZVn8NGe5e/2Ps5cBEBoSwpihvQISm4iInJkSCiIiIlXMrwsLn4qfN6hnidtefI49SiEtI5OZS9ZVaFyB5KqfEBMdRULH1hV+PtfnfiI756TaDaVlWRYrN+7goRc+4tL7nuejybOZtWonE+59jlc/m0JK2nH3trOd6Q71asfSrV3z8r2BSqJDqyZ0bNUUgMmzl5FfUEBWTq77Gh/UswP1ascGMkQRESmBEgoiIiJVjOtmq1WTBrRvWfI8+uH9ulI7tiYA3/22uMJjC4TcvDwWrt4MwKCeHQkLC63wcw5K6Oie/1+WaQ+5eXlMmbuCax97lVv//hazPUYfAGTn5PLJj3O45J5n+e9XU9mffJSl67YDcHafLoSEBM//wrlGKRw4nMLStduYvXQ9x09kAzBWxRhFRCq14PmvkYiISDWQuO8QW3YlAXDu4OKnO7hEhIe5K+Sv2pTIziAszrhy4073DeiwPhU73cElIjzM3WVh4erNpB8/4fW+a7bsYvxdz/K3N75yt4CMCA/jouF9+ezZe7jlwv4kdGoFQGZWDu9/P5PL7nuevPx8AM6u4t0dTnXe4J7umhQ/zFzKj87Uh7iY6AqfviIiIuWjhIKIiEgVMu2k6Q4JXu0zfkR/9/L3QThKwTXlIDQkhEE9OvjtvK5uD7l5+czyaOd4Jk+9/Q1HUtIBqBsXw82XncsPrzzMYzdfRtvmjWjTpC7/feIWXn74erq2tac25Ofb9SFio6PcdTGCRWzNGowc0B2A2cvXs9Rph3r+kATCw8ICGZqIiJyBEgoiIiJVhGVZ7uH1nVo3pUXj+l7t16Jxffp2bQvAlDnBVZzRsix3QiGhUytqxUT77dx9urShTq0Y4ORET0l27jvkbuF5+XmD+OGVh7lhwkjqxsWctJ0xhoE9OvDu/93Ovx+4lg7O1Jbx5/QPypvsi4b3BezEiWvqx4Wa7iAiUukpoSAiIpVeXn4+X/+6kEvvfY4XPpoc6HACZtPOfew5cBiwh4mXhquFZNrxE/wWRMUZt+856G436O/h8WGhoYwaaD9ZX7ZuG8lFdGY41WyPkQy/O38wEeElJweMMQzt3ZmPnr6LH197lD9dOaZ8QVdSCZ1a07xRYYKsfcvG7mKNIiJSeQVfiltERILKio07+PeHk9i2+wAAX/4yn0tGDqB104YBjsz/PJ+CjxrYo1T7nt23C3Vq1eRY2nG+m7G4SrTiKygoIPlYGruTDrM76TAHDh8jJf04qRmZpGZkkpKeyRGPm/hhfbr4PcYxQ3vzv2kLKbAsps5fxVUXnlXi9q5kTptm8bRo3MDr8xhjaFCnVrlircyMMYwf0Y//fP4zAGPP0ugEEZGqQAkFERGplA4eSeGVT6cwfdGa016bNGspd08cG4CoAqegoIDpC+3PIqFTK+Lr1S7V/uFhYVx4dl8+njyb1ZsT2bH3IG2axVdApGWXk5vHZ1PmsnHHXvYeOMKeA4fJzs3zat8OLRvTLL5eBUd4ui5tm9GycQN2JSUzZe5yJo4dVmyhzP3JR9mcuA+AEf27+TPMKuGiEf34deFqjDFcqISCiEiVoISCiIhUKtk5uXw2ZS4f/DCTrGx7rn9kRDjXjR/OwtVbWLNlFz/PXcHtvz8/KOeSF2f15kQOHU0FvC/GeKrxI/rx8eTZAHz/2xLuu2acr8Lzif9NW8AbX04t9vWw0FBqx0YTFxtNXEw0cbE1iYuJpm5cDBcM6+3HSAsZY7jgrN688eVUtu85yJZd+4sdqj9rSeF0h+FB1qnBF+Jiovno6bsCHYaIiJRC9fk/MRERqfRy8/K47e9vsX77Hve6UQN7cNfEC4ivV5vGDeqyZssujqUdZ+6KjZzTv3sAo/WvqU4xxtCQEM4ZULan280b1ad/t3YsWbeNKXOWc/sVo4ly2vUFmmVZ/DjbbhdYs0akM6e+Hi0aNbC/N25Aw7q1CAmpfOWfRg/pxX+/moZlWUyZu6LYhMLMpfZ0h6YN69K+RWN/higiIlIhKt9/lUVEpNr65Mc57mRCu+aNeOOJm3nqrj+4h/eP6N+NmOgoACbNXBqoMP0uNSOTn+etAGBAj/buzgJlcfE5dgvJ9Mwsflu81ifx+cLWXUns2HsQgGvGDeeFB6/j3qvHcem5A+nfvT2N6teulMkEgEb1a7tbOU6dv4q8vPzTtjl8LI21W3cD9nVc3LQIERGRqqRy/pdZRESqnd1Jh3nvu98Au2DdB0/9id6d25y0TVREOKOH2MUEF63ZyoHDKf4OMyC+nb7IPf3jijFDy3Wss/p2cSckvpuxuNyx+YorYQJw/pCEwAVSRmOdKRfH0o6zaM2W016fvWyDux3i8H6qnyAiIsFBCQUREQk4y7J49r3vyHEK8D1y44Ri6yNcNKKve58f5yzzW4yBkp2Ty1dTFwB2K73+3dqV63jhYWGMG25/hmu27GJL4v5yx1he+QUF7ikdvTu3pnGDOgGOqPSG9+9GVKQ9fWTK3BWnvT7Lme7QoG4turZt5tfYREREKooSCiIiEnA/z13BsvXbAZgwcgA9OrQsdtuOrZq656hPnrWM/IICv8QYKFPnr+JoagYAE8ee5ZOh8peM7E+Ic5wvfplX7uOV19J12ziSkg7A6CrQzrIo0VGRjHBGHsxZvoG0jEz3a6kZmSzfsAOA4X27VtqpGyIiIqWl/6KJiEhApaQd56VPfgKgXu1Ybr9i9Bn3GT+iHwAHDqewdN22Co0vkAoKCvh0ylwAGtaN49yBPXxy3CYN6rqH3U9bsNp9Mx8oP89bCUBEeFiVLrQ51ml1mJuXz3SP+hRzl29wJ7403UFERIKJEgoiIhJQr3w2hVTnae7914wjtmaNM+5z3uCeRDrdCSbPCt5pDwtWbSZx3yEArhgzhLCwUJ8d+8oL7FoMuXn5fDN9kc+OW1qZWdnu6QDDenf26vdfWfXu0oaGdeMAe9SNy6yldrvI2rE1SejUKhChiYiIVAglFEREJGCWrd/OT3PsVoGDEzpyzgDvnk7H1qzBOf3tJ72zlq4nJe14hcUYSJ/+NAew2yiOH9Hfp8fu3r4FXdrYc/m/nb6I7Jxcnx7fW7OXbXAXnBxTRac7uISGhLinbKzZsovdSYc5fiKbxWu3AnBWn86EhfouKSQiIhJoSiiIiEhAZOfk8sy73wEQFRnOg38cX6r6AK5pD3n5+Sd1CAgWG7bvYcXGnQBcfM4Ad7tMXzHGcIUzSuFY2nGmLljl0+N7y/UkPy4mmoE9OwQkBl+6wOn2AHbnigWrNrmLjWq6g4iIBBslFEREJCA++GEmew4cBuDmy86lSYO6pdo/oVNrmjeqD8APM5e6W/IFi09/smsnhIaG8PvRQyrkHCP7d6dB3VoAfPnzfL9/hoePpblrYJw7qGexnT2qktZNG7pHfvw8byW/Lbanc9SsEUm/cnboEBERqWyUUBARCQDLspgyZzlv/m8auXl5gQ7H71ZvTuSjSbMB6NiqSZlumI0x7lEKO/cdYt22PT6NMZD2HzrKb05Rv/MG9SS+XlyFnCcsLJTLzxsMwLY9B3xe4HLdtt28/OlPxbamnLZgNQVOEmPMsKo93cGTa5RCUvIxZjr1IYb26kxEeNVPmIiIiHhSQkFExM/y8vP513vf87f//o/3vvuNL36eH+iQ/Grdtt3c86/3ycvPJ8QYHrlxQpnnlV8wrDehTgu+STOX+DLMgPr853nuG+0/jB1Woee6+Jz+7gKXX/ziu2tx7vIN3Pp/b/LZT3O57on/FJk8c01Vad6oPl3bNvfZuQPt3EE93de0a9THiP6a7iAiIsFHCQURET86kZXDwy9+wrczFrvXfTt9sbulXLDbuGMvdz/zHpknsjHG8Pgtl9HZGR5eFvVqxzK0dycAfl24huMnsn0VasCkZmS6O1cM6N6eDi2bVOj54mKiGes8UZ+/chO79ieX+5i/LlzNn1/6hNy8fADy8wt477vfuPaxV9m4Yy8A2/ccYMuuJABGD00oVf2Myq52rZoM6dXR/XNkRDgDe1T9+hAiIiKn0tg7ERE/OZqawf3PfcAG54YqJjqKjMws9icfZdHqLQzp1SnAEZZs1/5kXv1sCnn5BcTF1KBWTDRxsdHExdSkVkwNmsfXo3ObZsXeGG7ZtZ+7nnmPjMwsAB6+4RLGntWn3HFdNKI/s5dt4ER2DlPnr2TCqIHlPqavpKYfJ+lwCh1bNfH6hvm76Ys5kZ0DwMQLz6rI8Nx+P3qIO8n15dT5PPTHi8t8rMmzlvH0299QYFlEhIdx5x/GMGnWMrbuSmL7noNc/8RrXHXhWeR4jFYYMyR4pju4XDCsN7OXbQBgUM8O1IiKCHBEIiIivqeEgoiIH+xOSuaeZ99n36GjgP3k+fFbLuN39/+bE9k5fDN9UaVPKLzx1VTmrthY4jYdWzXlqgvP4pwB3U6axrBj70HufPpd0jIyAXjguvFcfI5v2iAO7NGeRvVrc+BwCh9NmsW44X0rRXG/vPx8rnv8NfYnH6Vv17bcd8042jZvVOI+W3bt58up9rSD9i0b099PRfxaNW3IoJ4dWbh6Mz/NWc4tl59HXEx0qY/zv6kLeP7DSQDUiIzg+QeuoW/XdkwYOZAPJ83ive9+Iy8/n48mz3bv06NDS5rG1/PZe6kshvTqROumDdm1P5lLK1GSS0RExJc05UFEpIKt2bKLG//6hjuZMPasPrzw4HU0rBvHGKdn/YJVm9nvvF4ZZefksmj1FgDq1IqhcYM6RNeIPG27zYn7eOI/n3PZvc/x+c/zOH4im137k7njqbdJST8OwD1XjeXy8wb5LLaw0FCuHT8CgKTDKUyevdxnxy6PjTv2sT/Z/p0uW7+dqx95hX9/OMmdVPG09+AR/vKfL7j6kVc4mpoBwB8uGObXaQBXOi0ks7Jz+eG30tej+HDSLHcyISY6ilceuYG+Xe2ESFhYKDdMGMmHT91Jp9ZNT9pvjEebxWASHhbGO3+7ne9e/jP9u7cPdDgiIiIVIvCPcEREgtjspet54j+fk+30ob9xwkhuvHSU+0ZxwrkD+XbGYizL4rvflnDHFaMDGW6xlq7f7h6G/+AfxzNyQHcA8vLyST2eSUracWYuXcfX0xZyLM0e5v/Sxz/yzjfTCQ8L41iafZN8xxWjufIC3xcZHHd2Hz76YSZJh1N4/7vfuPCsPgGvqL9sfWHHhBBjyC8o4KupC5i2YDW3/f58xg3vy7HUDN777je+n7mE/Hy7jkZoSAi/O38wo4ck+DXe/t3a0aZZPDv2HuR/0xbyhwuGERZ25mKZlmXx5v+m8f73MwG7JsMrj9xwWuIAoF2LRrz7f7fz2U9zefub6cTFRnPuwB4+fy+VRUx0FDHRUYEOQ0REpMJohIKISAX5YeYSHn7pE7Jz8wgNCeGxmy7lpsvOPempc/sWjenRoSUAk2YuJSe3craQnOPMBQ8PCz2puFxYWCj14mJp27wRN04YxfevPMyfb7iE5o3qA5CRmeVOJtx02SiuuWh4hcQXHhbG9ZeMBODQ0VR+mLm0Qs5TGq4WjC0a1+fjf95N7y5tAEhJP84/3/mWiX9+iQn3Psc30xe5kwnnDurJF8/dxz1XX0hIiH//E22M4YoxdvvOQ0dTmbZglVf7zV623p1MqF87lv/+5ZYikwkuYaGhXHPRcH5+43G+eeFBYmvWKHfsIiIiEhhKKIiI+JhlWbz//W88/fa3FFgWUZHhPP/AtVw0ol+R2192rj38PyX9OL8tXuvPUL1SUFDAvJV27YS+XdtRs4ipDi5REeFMGDmAr56/j3/ddzU9OrQkNDSEmy4bxQ3ODX9FuWBYb5o2rAvAhz/MJCsnt0LPV5KsnFzWbt0NQL+u7WjXohGvP3YTT989kUb1awOwc98hsp0YB/XswEdP38k/7rySFo3rBypszh/Si3q1YwF4+5sZp7V5PFVBQQFvff0rALViovnvX26hTbN4r84VEx3lblcpIiIiVZMSCiIiPlRQUMC/P5zEf7+aBtg3Wa89dhODEzoWu8+I/t2oU6smAN9MX+SXOEtjw469HElJB+Csvl282ickJISz+3bl7SdvY+6H/+DGCaMqvB6Aa54+QPKxNL73aM3pb2s2J7pHm/Tt1hawRwCMHNCdL5+7jxsnjKRmjUh6dGjJ64/fxEt/vp6OrYp/qu8vURHhXH/JOQDsTz7KpJnLStz+tyXr2L7nIABXX3iWe2SKiIiIVA9KKIiI+EhObh5P/OcL/jdtIQDx9eJ466+30q1dixL3iwgPY9xwe/TCmi272LJrf4XHWhqu6Q4Aw3p3LvX+oX4cun/+kAT3Te2Hk2aR5dR98Lel67cDdhKhT5e2J70WFRnBTZedy4x3nuTtJ2877fVAGz+iH00a2CM93vtuRrGfYX5BAW9/Mx2AOrVqcpkPC22KiIhI1aCEgoiIDxw/kc39z33A9EVrAGjdtCFvP3k7rZs29Gr/S0b2dz/B/3Z64J6sF2XOcjuh0KVNMxrUqRXgaEoWFhrKjc4ohaOpGQEb8bHMqZ/QsVWTYtsv+rODQ2mEh4Vx02WjADicku5OkJ1q+sI1JO47BMDV484mOqr4qTAiIiISnJRQEBHxgSf+8zlLnJvI7u1b8OZfbyW+XpzX+zdpUJchzrSIX+atJCMzq0LiLK09Bw6z07lp9Ha6Q6CdO7gnrZo0AODjybPJzMr26/nTj59g0859APTr1s6v5/aV84ckuJNhH02addr1mJefzzvf2qMT6sbFcOmogX6PUURERAJPCQURkXJK3HeI+Ss3ATCge3v+8+iNxT6VLsmlTnHGE9k5/Dx3hU9jLCvX6ASAs/pUjYRCaEgIN15qP2E/lnacr4t5wl5RVmzYQYFlAdC3a+WazuCt0JAQbv3deQCkHT/Bpz/NOen1afNXsTvpMADXXDScqMgIv8coIiIigaeEgohIOU2aVVi47oHrLirzzdXAHu3dc9e/mb4Iy7kpDaS5y+3uDk0b1vW6en9lMHJAd3e8n/w4h+Mn/DdKwTVSJTwslISOrfx2Xl87u29XurRpBsDnU+ZxNNVu/5mXl8+73/0G2G0iLxk5IGAxioiISGApoSAiUg65eXlMcUYT9OrUmhaNG5T5WCEhIUwYZd+c7dx3iJWbdvokxrJKSTvO6s2JgD06obLO+S9KSEiIuw5AakYmX02d77dzL1tfOPWlKj+5N8Zw2+/PB+xRMx9OmgnAlHkr2HvwCADXjR9BlFo/ioiIVFtKKIiIlMO8FZs4lmY/ub1oeN9yH2/c2X2JCA8D4KupC8p9vPKYv2qTe+j+sD6l7+4QaMP7dqV9y8YAfPnLfLJzciv8nIeOppK4PxmAvl2rZv0ET/26taNPlzYAfPPrIvYePMJ7zuiEhnXjuGhEv0CGJyIiIgGmhIKISDn8MHMpADVrRHLOgO7lPl7tWjUZ6Rxn5pJ1zFyyrtzHLCtX/YRaMdH0rIJD90NCQrh63NmAXUth6oJVFX7OZU67SKi6BRk9GWO47Xf2KIXcvHz+9NTbJCUfA+CPF48gUqMTREREqrUzJhSMMc2NMTONMRuMMeuNMXc76+saY341xmx1vtdx1htjzCvGmG3GmDXGmN4V/SZERALh4JEUFq3ZAsDoIb18Nrz91t+dT2x0FABPvfW1+wbOn7Jzct3vbUhCR8JCQ/0egy+M7N+dBnXtVpdf/jy/zHUpTmTlsHLjDj7/eR7b9x8pdjvXdIfoqAh3/YGqrnuHlgzrbY9QSTqcAkCj+rUZ54MROSIiIlK1eTNCIQ+437KsLsBA4A5jTBfgYWCGZVntgRnOzwBjgPbO183AGz6PWkSkEvhx9nL3Daovh343ql+bx26+DID0zCz+8toX5OXn++z43li6fjtZ2fYUgarSLrIoYWGhXH7eYAC27TnAUqdg4pnsTjrMlLkr+Nf733PNo68w8sYnufXvb/HSxz/y9k9L3V09PFmWxdJ19giFXp3bEBZWNZMwRbnld+edVEPj+kvOITwsLIARiYiISGVwxoSCZVlJlmWtcJbTgY1AU2A88KGz2YfAxc7yeOAjy7YIqG2MaezrwEUkMDKzsklKPlbkV/rxE4EOz28KCgqYPMue7tChZWM6tW7q0+OP6N+NS0cNBGDNll288810nx7/TOYss6c7RISHMbBHB7+e29cuPqe/e2j+F7+UXJzRsiz+8dbXXH7/8/ztja/45tdFbE7cT35Bgcc28Pirn7F1d9JJ++45cJhDR1MB6FdF20UWp32LxowekgBAs/h6jB3WJ7ABiYiISKVQqscLxphWQC9gMRBvWZbr/6YOAK5+Yk2BPR677XXWnfx/XiJS5azftofbn3rL/eT6VOFhodxy+XnueevBbOn67e7h3xeN6F8h57jrqrGs3pzItj0H+OCHWfTt2tYvhf4KCgqYt9JuF9m3a1uioyIr/JwVKS4mmrHDevPtjMXMX7mJXfuTadmk6G4c0xauZrJHG9DIiHA6t2lKt3Yt6N6+BcdPZPP3//6PzKwc7n/uA977vzuoX8eeUuEanQDQNwjqJ5zqkRsn0LdrW/p1axdUoy9ERESk7Iy380mNMTHAbOApy7K+NcakWJZV2+P1Y5Zl1THG/Ag8Y1nWPGf9DODPlmUtO+V4N2NPiSA+Pr7PF1984ZM3JJVXRkYGMTExgQ5Dyii/oIBXvlnAgWMZZ9z2kqFdGNilhR+iOpk/r7FPp69izY4DhIWG8NhVI4iOrJjidAePZfDqtwvIzS8gtkYk91w2mJgaZbvBz8sv4Gh6JodTMzmcepzDqZmkZ2aftl1ufj5b99p1AgL1u/S15JQMnv9qHgCDurTg4qGnT+PIzMrh3/+bR8aJHGpGRfDH0b1pUr8WoSEnD+b7dekmpq9MBKBZg1rcMm4AEWGhfPzrStbtPEhMjQgeu2oEIVWozaZULvrvpVQ0XWPiD7rOgsfw4cOL/Z8ar0YoGGPCgW+ATy3L+tZZfdAY09iyrCRnSsMhZ/0+oLnH7s2cdSexLOst4C2Avn37WsOHD/cmFKnCZs2ahX7PVdcHP8x0JxPGj+hH9/YtT3o9Lz+fN76cSmpGJj/M38iAvr0Z0b+bX2Ms7TWWmn6c3Lx89xNmb6WkHefx934FYNSgnlxw/rml2r+0atSO56m3vyH9RDbT1+znhQevJSTEuyY9ycfS+PeHk9i6K4n9h46620B664YrL6ZBKT+fymrBlmQWrNrMyu1J/O2e64iLiT7p9aff/oaMEzkAPHT9JYwe2qvI41iWRc3aDflh5hL2JqcxY+1+nrrrDzz16WwABiV05pwRIyr2zUhQ038vpaLpGhN/0HVWPZwxoWDsKkzvAhsty3rB46VJwLXAM873HzzW/8kY8wUwAEj1mBohIlXQ3oNHeO/bGQC0btqQB/84vsiCbO1bNuaOp94mKzuXv7z2BS/HXk/vzm38Ha5Xlm/Yzv3PfUhObh73X3sRl5470Ot9f56/ktw8u0jiRX6odD9ueF8Wr93K9EVrWLh6M1/8PJ8/jB3m1b7Pvvsdc1dsLPK1mOgo4uvFFZmcCDGG0UN6BU0yAeCKMUNZsGozWdm5/PDbEq65aLj7tZWbdrpbgA7o3p7znXoBRTHG8NAfx7P/0FGWrt/GrKXrefjFT0hzaoj06xZc9RNEREREiuPNCIUhwNXAWmPMKmfdo9iJhK+MMTcAu4DfOa9NAS4AtgGZwB99GbCI+JdlWTz77ndk5+YB8PANE4qt7t6tXQueuecq7n/evlF/4PkP+e8Tt9ChVRN/hnxGKzft5L7nPnDXgvjX+99z4EgKt/3uvDM++bcsy12MsVl8Pb8kTIwxPHLjBDZs38v+5KO89sUv9Orcms5naEs4b8VGdzKhS5tm9O/enuaN6tGicQOaN6pH7diaJ1XuD3b9u7WjTbN4duw9yP+mLeQPFwwjLCyUnNw8nnn3OwAiw8N46PqLz/i5hIWF8s97JnLjk2+QuO/QSUmbfn6ocyEiIiJSGXjT5WGeZVnGsqwelmUlOF9TLMs6YlnWSMuy2luWNcqyrKPO9pZlWXdYltXWsqzup9ZOEJGq5Zf5q1jitNq7+Jz+JHRqVeL2g3p25C+3XA7A8RPZ3POv99l38EhFh+m1NVt2ce+z75OVnUuIMdRyhr1/NGkWT77+FTlO4qQ467fvYfueg4DdKtJfN+Qx0VH8484rCQ0NIS8/nyf+8wWZWafXP3DJysnl3x9Odu/77wev47bfn8+FZ/elR4eW1KkVU62SCWAnZq4YMwSAQ0dT+W3JOgA+njybxH32rL0bLh1Fs/h6Xh0vtmYNXnzwOurUqule16RBXZo0rOvjyEVEREQqJ+8m4YpItZSafpyXPv4RgLpxMdxxxWiv9hs9tBf3XDUWgCMp6dz1zHscTT1zMceKtm7bbu5+9j1OZOdgjOEvt/2O9/9+B80b1Qdg6oJV3P3seyW2v5zkDIsPDQlh7LDefonbpWu75txy+XmA3aLwxY8mF7vtJ5Nnsz/5KAC3Xn4edeNUFAng/CG9qB1rJwC++Hkeu5OS+eCHmQC0a96IiRd4N5XEpUnDuvzrvmuICLdH7QzqWbVbbIqIiIiUhhIKIlKsVz6bQkr6cQDuu2ac+2m+N668YBjXOO0j9x48wr3/ep/cvJKf/lekjTv2cvcz75F5IhtjDI/ffCljhvaiWXw93nnyNrq3tzsZrNiwg5v/9l8OOC0hAfLy8tmdlMzc5Rv4deFqAAb36ljqYo6+cNWFZ9Gniz3NYtKsZcxYtOa0bfYfOspHk2YBdl2LS0YN8GeIlVpURDiXjLQ/j/Xb93CfU0fDGMPDN04oUzvEHh1a8p9Hb+Sai4Zz02WjfB2yiIiISKXlVZcHEal+lm/Yzo+zlwP2NIZRA3uU+hi3XzGao2kZ/Dh7OZt27uOLn+dztZNk8KfNifu465/vkpGZBcAjN17ChWcXFlOsXasm/3nsJv762hfMWrqeHXsPcsNfXqNzm2bsSkpm36Gj5OcXnHTM8cP7+fU9uISGhPDX237PVY+8TFpGJv9851u6tmtBo/q13du88PFkd82LB68bT1ho6W+Sg9ll5w7k48mzycvPZ8+BwwBMGDXAnVQqi54dW9GzYysfRSgiIiJSNWiEgkiQsCyL7JxcnxzLs0hdVGQ4D10/vkzz7Y0xPHzDJbRq2hCAd7+dwcEjqT6J0RuWZTF90Rr+9NQ77gr8f77+YsaP6H/atlER4Tx990R+P9qeY384JZ25KzayO+nwacmEPl3aMCihY8W/gWLE14vjsZsmAJCemcVfX/+C/AI7xnkrNzF3uV0gcOxZvXWTW4T6dWpx3uCehT/XjuX233s3nUdERERECmmEgkgQsCyL+577gOXrt/PwDZdwwVl9ynSc/IIC5i3fyCc/zWF3kv3k9qZLz6VJg7IXmQsPC+PB6y7ijqfe4UR2Dq98+hNP3fWHMh/PW0dS0/nXe98za+l697oHrr2ICaOKbw8ZGhLCfdeMo0mDOrz//Uxqx0bTonEDWjZpQIvG9WnZuAEtGzegtkcRvkAZ3q8bF5/Tn+9/W8KqTYl8+MNMJo49ixc+nATYhRjvuHJMgKOsvK68YChTF6wiP7+A+6+7iJjoqECHJCIiIlLlKKEgEgSWb9jBglWbAfjHW98QW7MGw/p08Xr/4yeymTxrKV9NXcC+Q0fd6zu2auquil8efbu2Y9TAHkxftIbpi9Zw8Tn96detYlrrWZbF1Pmr+PdHk0nLyAQgLiaah66/2OtpG1eMGcoVY4ZWSHy+dM9VF7Jq004S9yfzzjcz2Lb7gPv3d8vl51IvLjbAEVZeHVo24c0nbiE7N4++XdsGOhwRERGRKklTHkSCwBc/z3Mv5xcU8Ngrn7F6c+IZ90tKPsZLH//IuD89zYsf/+i+GY2JjuKqC8/i1Ueu99n8+7smjqVGZAQAz3/wQ4UUaEw7nsWD//6Iv77+pTuZMHJAd7547r4y1YCo7GpERfB/f7qC8LBQ8gsKmLF4LWAXYixpJIbYundoqWSCiIiISDlohIJUa2kZmazfvoeCAuu010JCDN3bt6z0Q6F3Jx1m3spNgN1WcNOOfWTn5nH/cx/w1pO30aZZ/Gn7FBQU8OXUBbzxxS/u4n0AzeLrccXoIYw9uw/RUZE+jTO+Xhw3TBjJfz7/mcT9yT4t0Ljv4BF+nr+STybN40SO/X7q1IrhoevHc07/7j45R2XVsVVT7rhiNC998pN7nQoxioiIiIg/KKEg1VZWdg43/PV1d62AotSqWYPn7r+WhE6t/BdYKX01dT6WZSdEHr/5MtZv28M/3vqa9Mws7nrmXd558vaTOgDsP3SUv7/5P1Zs3Ole16dLG64cM5QhvToRElJxA5euGDOEH2cvI3F/Mu9+O4PzBicQXy+uTMfKyMxixuI1TJm7glWbEk96bfSQBO67ZhxxsYGvdeAPvx89hOUbdjB3xUYuGTlAhRhFRERExC+UUJBq691vZ5SYTABIO36CO//5Dk/e/ntGDqh8T7rTj59wt3Yc2KMDbZrF06ZZPEfTMnj9i19IPprGXf98l7f+eitxsdH8MHMpL3/yI5lZOQA0bViXJ269nF6dWvsl3vCwMB64bjx/errsBRpXbtrJ19MWMmf5BnJyT5420aReLPdedwlnlaJ+RDAICQnhmXuvYsfeg7Rr3ijQ4YiIiIhINaGEglRLW3cn8elPcwHo0qYZD1w3/rRtNuzYy4sfTyYnN4/HXvmMQxMv4MoLhvk71BL9MHMpJ7Lt5MCVHkUErxl3NkdT0/ni5/nsSkrmvuc+IC422l24EWDCyAHcOfECn09tOJN+3cpeoHH+yk3c//yH7hEZYLf8Gz20F2OG9mbvjk3VLpngEhYaSoeWTQIdhoiIiIhUI0ooSLWTX1DAP9/5lvyCAkJDQnjkpglF3oh1bdec5o3q8chLn5CZlcNLn/zEgSMp3D1xbIVOC/BWXn4+/5u2AIBWTRsyoEd792vGGO6eOJZjqceZumAV67fvcb/WoG4tHr/pMgb27OD3mF3umjiW+Ss3cSI7h+c/+IFPnrmb8LCS/znKyMzin+9+i2VZRISHcc6A7owZ2ot+3doR6vw+9u7Y5I/wRUREREQEdXmQaujb6YtZv82+wb7ygqElPtUd2KMDb/7lVurXttvvffHzfB595TOycnL9EmtJZi9dz4HDKQBcMXoIxpiTXg8JCeGJWy9jYI/CxMHoob347Jl7AppMgMICjQCJ+5N52aOgYHFe/uRHko+mAfDAdRfxt9t/z8AeHdzJBBERERER8S/9n7hUK4eOpvL6l78A0LhBHW6cMOqM+3Ro1YR3/+8OWjdtCMDMJeu48+l3SD9+okJjPZPPnVaRtWKiGTO0V5HbhIeF8ey9V3H/teN4+eHr+dvtv6dWTLQ/wyzWFWOG0LGVncz537SFfDV1frHbLlqzhUmzlgHQv3t7Lhrezy8xioiIiIhI8ZRQkGrlhY8mk3kiG4A/X38xNaIivNqvUf3avPXXW+nd2S5euGbLLl759MxP1SvKum27Wbt1N2DXQoiKLP59REVG8Lvzh5w0UqEyCA8L47n7r3GP/njxox/d7S89HT+RzT/f+RaA6KgIHr1xwmmjMURERERExP+UUJBqY+7yDcxcsg6Acwf1ZFDPjqXav1ZMNC8/fAP9utoFBH+cvZxd+5N9Hqc3vvjZfpofGhrCZecNCkgMvhBfrzbPP3AtUZHhFFgWT7z6GVt27T9pm9c+/9k9teNPV15A4wZ1AhCpiIiIiIicSgkFqRYys7J57oMfAIiNjuLeay4s03EiwsO495oLMcZQYFm8+b9pvgzTKwePpPDb4rUAnDuwBw3q1PJ7DL7UuU0z/u/2KzDGkJmVw/3PfcjhY3athGXrt/PN9EUA9O7ShktG9g9kqCIiIiIi4kEJBakW3vzfNA4eSQXgT3+4gHpxsWU+VtvmjTh/SAIAMxavZdPOfb4I0St7DhzmpY9/Ir+gAIArPFpFVmVn9+vKn64cA9h1Lu5//kOOpWXw9NvfABAVGc7jN11aKbpriIiIiIiITW0jg8jW3Um8+dU0DqekF/l6fL047rhiNC0aN/BzZIG1JXE/X/1it1fs2bEVFw3vW+5j3nzpKH5duJr8/ALe+HIqLz98fbmPWZy0jEymL17Lz3NXsGbLLvf6nh1b0blNswo7r79NHDuMPQcO8/1vS9i0cx9XPPgiKenHAbj996NpGl8vwBGKiIiIiIgnJRSCxKad+7jz6XdIK6HzwMYde1m5cSfPP3AtPTq09GN0gWNZFi9+8iMFlkVoaAgP33CJT55yN42vx8Xn9OebXxexaM0WVmzcQe/ObXwQsS0vL58Fqzfz89yVzF2xgdy8/JNe79q2OU/ccpnPzlcZGGN48Lrx7D90lCXrtrmTCT07tuLyKlwnQkREREQkWCmhEAQ2bN/DXf98l/TMLAD6d2tHWFjoSdvk5OaxbP12UjMy+dNTb/O3O65gRP9ugQjXr+Ys28CKDTsAuOzcQbRpFu+zY19/8Tn8OHs52Tm5vP7FL7z95G3l6j5gWRabdu5jytwVTFuw2n1D7dKwbhyjh/ZizNBePn0flUlYWChP3z2RG598g8R9h4gMD+Pxmy/TVAcRERERkUpICYUqbu3W3dz9zLscd1ohPnDd+GKf5k6atZRn3vmO7Nw8Hnn5U+65amylnYOfk5vHb4vX0qJxfbq0bV7mY7zy2RQAatWswQ0TRvoyROrXqcXvRw/ho0mzWLt1N/NWbGRYny6lPs7BIyn8Mn8VU+auIHHfoZNeqxEZwfB+XRl7Vh96d2lDaDW4sY6tWYNXHr6BT36czZCETrRoXD/QIYmIiIiISBGUUKjC1mzZxd3Pvkemk0z48w2XMGHkgGK3v2h4PxrUqcWjL39KZlYOL378IwcOp3DXxAsq1RPggoICHn/1M2Yv2wBA9/YtuHLMUM7u15Ww0NAz7F3of9MWsPfgEQBuumwUcTHRPo/16gvP4rvpi0jPzOKNr6YyuFenUt30f/DDTP771TQsy3KvM8bQr1s7xgztxfB+XYmOivR53JVdfL047r/2okCHISIiIiIiJVBCoYpatSmRe//1HplZORhjeOTGSxg/4swt9Qb17Mh//3IL9/7rA46kpPP5z/M4dDSVv972OyIjwv0Q+Zm9/c10dzIB7FEYa7d+RqP6tbn8vMGMH9GP2Jo1SjzGsbQM3vvuNwBaNWnAhJEDKyTWWjHRXH3RcF7/4he27znItAWrGTO0l1f77k5K5k2PZEKbZvFcMKw35w1OIL5eXIXEKyLy/+3deZzNdfvH8dd1ZjBp7CRCU6FuS7LdlVshFZKkEJUYWxE12oxS2jOt9rqVkl+kBRFaJJIkS8oSFUoou8iSZebz++N8O/eUbc7MWeaM9/PxOI/5ns93cX3N9ThzznU+i4iIiEio5J6vpSXLvl65lpS0/xUTHuh2fZaKCX85N+kMRj3Sk6QzTgP8Sx/e/czrHE5PP8GZ4ffJ/KWBQkCFMiXp1LJRoGfBpm2/M3TcdFr0eornXp/CH8eZgPLldz9hjzenRO+bmh8xp0Qo3dCkHiWK+pehHPnODA4dPpyl80ZNnEmGc5gZwx/oyri0FDq0aKBigoiIiIiIxAQVFCLkzwMH2b7r6Ms5BuPb73/mrqdHs//AQXxmPHRbG1pkYxnEMqWK8fKA26h53lkALFyxmhHjP8pxfDmx6qeNPPrSOwAkFkzg2bs70uOGJkwZmkpql1aBAsj+Awd5+6N5dHxgKKt+2njEddas38SkmV8BcGH1SvzngnPDGndCgfx0bnUZAL9u3cHkWQtPeM5PG7fw8bxvAWh8YXXqVK2YowkdRUREREREIk0FhQjYsHk7re9+lqt6PEGLXk/Rb9BYxk37nKU/rOPAwUNZvs7y1b+Q8vRrgWLCgB5tueqSWtmOq3BiQQb1TaZihdMBGDttDrMWLM/29XJi+64/uPe5MRw4eAifGU/0vpEzy5YC/B/YWzW+kPFP92Fw387UquJfnnHjlh10HTCCiZ/MDwwbcM4x+I1pZDiHz4w7b24ekQ/qLRvVpWyp4gC89NZHbN7++3GPz9w7oev1l4c9PhERERERkVBTQSHMft+9l5S019i6YzcAW3bs4tMFyxg8dhrdHn6Ry7o8TOcHhzNp5lekZ2Qc8zor127gzoH+CRjNjP63tqZpFsfqH09Cgfyk9elAYsEEAB797zus+3Vrjq8bjIOHDpP6whts2bELgN43XsVFNSofcZyZcVGNygy/vyu92jcjzufj0OF00l59j4eGj2fv/gPM++Z7vlr2IwCtGl/IOeVPj8g95IuPJ6VDcwD+2PcnA4a/dczf55r1m/hk/lIAmtSrwVlezwsREREREZFYooJCGP158BD3PPc66zdtA/xd2xvWrUpJb7w9wOH0dFasWc/AUZPo+tAIVq7dcMR1flj3K3cMfDUwJ0C/rq1ofmntkMVZrnQJHu7RFoB9+w+QOugN9v95MGTXPx7nHGmvTmLpD+sAaH5pbdpfdfylLH0+Hx1aNGBE/+6UKlYYgI/nfUty/2E8P+Z9wD9kolvryH7z36BOVVp5q2wsWfUTY6bMPupxr0yYifN6UIR6KUsREREREZFIUUEhTNIzMhgwfDzLfvwFgCvr1eDx3u1J69OBqcPvZ8rQVJ6840baN6vP6SWLAvDd2g0kPzicp197j9179gGwdsNmej85KvD83uSWQU3AmFWX1K5Cp5aNAv/mk69M+NtShuFw6PBhBo6axNTPFgP+5SFTu7TK8hCFC85LYsyTd/DvahUBWPfb1sAykcnXXkaxwonhCfw4Um5uTpI3VOPldz8J/P7/8sO6X/l0wTIAml1SkwplSkU8RhERERERkVBQQSFMBr8xjdkLVwBQq8rZPHhrG3w+/3+3mVG6RFEaX3Q+KR2u5q1n7qJTy0bEx8XhnGPCjPm0vec5xk37nNufeJnf/9gLQEqHq2l9xcVhi7l7myuoW9X/4fzjed/y7sdfhu3f2rZzNz0ff5n3Pl0AQOkSRUjr04H8+YJbybR4kUQGpXamW+vLA4WIcqVL0LZJvZDHnBUJBfLzaK925IuPIz0jg4eGjQ/0LAF4ZcInAMT5fHRupd4JIiIiIiISu1RQCIM3p3/OWx9+AcDZ5Urz9Ak+KCcUyE+PG5owduCdgQ/0O3fvZfDYaezYtQeA29s1pX2z4w8FyKk4n4/HerfjtOL+ZQsHvTGNZd5QhFBasXo9nfoPCwxzqHpOeV55pGdg6cVgxfl8dL3uckb070bbJvV44b5OQRcmQuncpDO4vV1TwL/qw7OjJwP+eTA+W/QdAM0vrUW50iWiFqOIiIiIiEhOqaAQQs45pn62iMFjpwNQqlhhXrgvmUKnnpKl85POOI2h93fh8d7t/zbPQvfWV3DLNQ3DEfIRihVO5KmUm4iPi+Nwejr9howNTJZ4IocPpzP1s0V8MHcJ6zdtO+qQiWlzFnPbY/9l607/JJVXN6jNiw92DxQxcqLWv87m7o7X5IphBDc0/Q8XVq8EwAdzl/Dh3CX/650Q5yPZW2ZSREREREQkVkXva9w85M8DB/lg7hLGf/gFP2/cAkDBhPw8f2+nwPwIWWVmXHFxDS6ucS5TZi2kRLFCNKl3QeiDPo5qFSvQ55areea1yWzdsZuUtFd56cFbKZxY8JjnpGdkMGDEW4HVCwCKJBakWqUKVKtYnuqVzmTKvJV8sdzfKyHO56NPh6tpfeXFEVnWMdJ8Ph8DerTlptRB7Ny9l6dGTeTPA/4lQls0qBNYYlJERERERCRWqaCQA1t27GLCjPlMmvkVu7xJEwEKnlKAgSk3UzmpbLavnVgwgRubXxKKMLPl+ssvYu2GzUyYMZ816zdzz3NjGNKvCwn58x1xrHOOtFGT/lZMANi1Zx9fLFnFF0tW/a29aKFTefLOG6ld5Zyw3kO0lShaiP63tuHuZ0YHignxcXEkX6veCSIiIiIiEvtUUMiGlWs3MP6DucyYv5T09IxA++kli9Lmynq0bFQ3y8Mccisz4+6O17Bz114+XbCMb7//mf5DxzEw5Wbi4+ICxznnGDJ2GpNnLQTgnPKluS+5FT/+8hvLV//C8h9/Cay8AHBuUlnS+nSgTKliEb+naKhf8zzaNqnH2x/NA6DlZXWD7rUiIiIiIiKSG6mgkA2jJs7k869XBp5Xr1SBds3q07Bu1b992I51cT4fj9x+A7v37mPRijV8vnglA0dN4oFu1weGKYyaNJNx0+cC/tUVhvbrSomihbjgvCTaXOlfkWLn7j2sWL2e+QsX06tTWxIK5I/aPUVDr/bN2LJjF7v+2EfX6y6PdjgiIiIiIiIhoYJCNrRrVp9533xPo39Xo/1V9alWsUK0Qwqb/PniSevTgZ6Pj+T7n3/l/dmLKF44kZ7tmjL+g7m8/K5/osHTihdh2P1dj7pSQ7HCidSv9S8O79580hUTAArkz0danw7RDkNERERERCSkVFDIhtpVzua9IX1DsjJBLEgsmMALfZPp/vBLbNi8ndenzGb9pu18umAZAMUKn8qw+7ueNMMYREREREREJAvLRprZq2a2xcyWZ2orbmYzzOxH72cxr93MbIiZrTazpWZWK5zBR4uZnTTFhL+UKFKIIamdKV4kESBQTEgsmMCQ1C6cWTb6SzWKiIiIiIhI5JywoACMBpr+oy0VmOmcqwTM9J4DNAMqeY/uwIuhCVNygzNKl2Bw384UPKUAAAkF8vHCfck5Ws1CREREREREYtMJhzw45+aYWdI/mlsCDb3t14HZQF+vfYxzzgHzzayomZVxzv0WsoglqionleXF/t2ZMmshzS+tTdWK5aMdkoiIiIiIiESB+T/7n+Agf0FhqnOumvf8d+dcUW/bgJ3OuaJmNhUY6Jyb6+2bCfR1zi06yjW74+/FQOnSpWuPHz8+NHckudaePXtITEyMdhiShynHJBKUZxJuyjEJN+WYRILyLO9o2LChHWtfjidldM45MztxVeLI80YCIwHq1KnjGjZsmNNQJJebPXs2+j1LOCnHJBKUZxJuyjEJN+WYRILy7OSQlTkUjmazmZUB8H5u8do3Apn7wJfz2kREREREREQkD8luQWEK0NHb7ghMztR+i7faw0XALs2fICIiIiIiIpL3nHDIg5m9iX8CxpJmtgEYAAwE3jazLsA6oK13+HTgKmA1sA9IDkPMIiIiIiIiIhJlWVnlof0xdjU+yrEOuD2nQYmIiIiIiIhI7pbdIQ8iIiIiIiIichJTQUFEREREREREgqaCgoiIiIiIiIgETQUFEREREREREQmaCgoiIiIiIiIiEjTzL8wQ5SDMtuJfflLytpLAtmgHIXmackwiQXkm4aYck3BTjkkkKM/yjm3OuaZH25ErCgpycjCzRc65OtGOQ/Iu5ZhEgvJMwk05JuGmHJNIUJ6dHDTkQURERERERESCpoKCiIiIiIiIiARNBQWJpJHRDkDyPOWYRILyTMJNOSbhphyTSFCenQQ0h4KIiIiIiIiIBE09FEREREREREQkaCooSI6Y2atmtsXMlmdqq2FmX5rZMjN738wKe+1JZrbfzL7xHi9lOqe2d/xqMxtiZhaN+5HcJxQ5ZmYFzWyama0ysxVmNjBa9yO5T6hexzKdOyXztURC+Lcyv5mNNLMfvNez66NxP5I7hTDP2nvHLzWzD82sZDTuR3KfYHLM23e+t2+Ftz/Ba9f7/jxEBQXJqdHAP9ckfQVIdc5VByYB92bat8Y5d4H3uC1T+4tAN6CS9zjqOqdyUhpNaHLsWefceUBN4D9m1iycQUtMGU1ocgwzuw7YE85gJSaNJjQ59gCwxTlXGagCfBbGmCX2jCaHeWZm8cBgoJFz7nxgKdAr7JFLrBhNFnPMy6U3gNucc1WBhsAh7xy9789DVFCQHHHOzQF2/KO5MjDH254BHPcbFDMrAxR2zs13/kk9xgDXhjhUiVGhyDHn3D7n3Cxv+yDwNVAuxKFKjApFjgGYWSJwF/B4SAOUmBeqHAM6A09518xwzm0LWZAS80KUZ+Y9TvW+NS4M/BrKOCV2BZljVwJLnXPfeudud86l631/3qOCgoTDCqClt90GKJ9p31lmtsTMPjOzS7y2M4ANmY7Z4LWJHEuwORZgZkWBFsDMsEcpsSw7OfYY8BywL0IxSmwLKse81y6Ax8zsazN7x8xKRy5ciVFB5Zlz7hDQA1iGv5BQBRgVwXgl9hwrxyoDzsw+8l6z7vPa9b4/j1FBQcKhM9DTzBYDhYCDXvtvQAXnXE383+KNyzzOSiQI2coxr/vdm8AQ59zaCMcssSWoHDOzC4BznHOTohKtxKJgX8fi8fesmuecqwV8CTwb+bAlxgT7WpYPf0GhJlAW/5CHfpEPW2LIsXIsHqgP3OT9bGVmjaMTooRTfLQDkLzHObcKfzcnzKwy0NxrPwAc8LYXm9ka/NXLjfy9+3k5r03kqLKRY4u8U0cCPzrnBkU6Zokt2cixukAdM/sZ/9/W08xstnOuYeSjl1iQjRxbjL/3y0TvEu8AXSIctsSYbOSZeW1rvHPeBlIjH7nEimPlGP6eB3P+GpplZtOBWvjnVdD7/jxEPRQk5MzsNO+nD+gP/DXTfikzi/O2z8Y/Ccta59xvwG4zu8gbr3cLMDkqwUtMCDbHvOePA0WAlCiELDEmG69jLzrnyjrnkvB/E/ODiglyPNnIMQe8j39iM4DGwHcRDltiTDb+Xm4EqphZKe8SVwArIx23xI5j5RjwEVDd/CttxQMNgO/0vj/vUQ8FyREzexP/m5uSZrYBGAAkmtnt3iETgde87UuBR83sEJCBf9bXvyZ26Yl/5thTgA+8h0hIcszMyuGfHX0V8LW3OtEw59wrkbsTya1C+DomclQhzLG+wP+Z2SBgK5AcmTuQWBCqPDOzR4A53r51QKeI3YTkasHkmHNup5k9DywEHDDdOTfNO07v+/MQ8xe8RURERERERESyTkMeRERERERERCRoKiiIiIiIiIiISNBUUBARERERERGRoKmgICIiIiIiIiJBU0FBRERERERERIKmgoKIiIiIiIiIBE0FBREREREREREJmgoKIiIiIiIiIhK0/weLrcGh+AQk4wAAAABJRU5ErkJggg==\n", 247 | "text/plain": [ 248 | "
" 249 | ] 250 | }, 251 | "metadata": { 252 | "needs_background": "light" 253 | }, 254 | "output_type": "display_data" 255 | } 256 | ], 257 | "source": [ 258 | "\n", 259 | "test_size = 24\n", 260 | "\n", 261 | "df_train = df[:-test_size]\n", 262 | "df_test = df[-test_size:]\n", 263 | "\n", 264 | "plt.title('Airline passengers train and test sets', size=20)\n", 265 | "plt.plot(df_train, label='Training set')\n", 266 | "plt.plot(df_test, label='Test set', color='orange')\n", 267 | "plt.legend();" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 12, 273 | "metadata": { 274 | "execution": { 275 | "iopub.execute_input": "2021-08-01T02:05:05.799121Z", 276 | "iopub.status.busy": "2021-08-01T02:05:05.797339Z", 277 | "iopub.status.idle": "2021-08-01T02:05:05.821360Z", 278 | "shell.execute_reply": "2021-08-01T02:05:05.820218Z", 279 | "shell.execute_reply.started": "2021-08-01T02:05:05.798971Z" 280 | } 281 | }, 282 | "outputs": [ 283 | { 284 | "name": "stdout", 285 | "output_type": "stream", 286 | "text": [ 287 | "RMSE: 9.814954576223638\n", 288 | "MAPE: 0.024777401477832514\n" 289 | ] 290 | } 291 | ], 292 | "source": [ 293 | "rmse = lambda act, pred: np.sqrt(mean_squared_error(act, pred))\n", 294 | "\n", 295 | "# Arbitrary data\n", 296 | "actual_passengers = [300, 290, 320, 400, 500, 350]\n", 297 | "predicted_passengers = [291, 288, 333, 412, 488, 344]\n", 298 | "\n", 299 | "# Error metrics\n", 300 | "print(f'RMSE: {rmse(actual_passengers, predicted_passengers)}')\n", 301 | "print(f'MAPE: {mean_absolute_percentage_error(actual_passengers, predicted_passengers)}')" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": null, 307 | "metadata": {}, 308 | "outputs": [], 309 | "source": [] 310 | } 311 | ], 312 | "metadata": { 313 | "kernelspec": { 314 | "display_name": "Python 3 (ipykernel)", 315 | "language": "python", 316 | "name": "python3" 317 | }, 318 | "language_info": { 319 | "codemirror_mode": { 320 | "name": "ipython", 321 | "version": 3 322 | }, 323 | "file_extension": ".py", 324 | "mimetype": "text/x-python", 325 | "name": "python", 326 | "nbconvert_exporter": "python", 327 | "pygments_lexer": "ipython3", 328 | "version": "3.9.6" 329 | } 330 | }, 331 | "nbformat": 4, 332 | "nbformat_minor": 4 333 | } 334 | --------------------------------------------------------------------------------