├── .gitignore ├── .vscode └── settings.json ├── LICENSE ├── README.md ├── data ├── data_clean.ipynb ├── params_test.csv ├── sse50_2023-11-10.pkl ├── sse50_option_data_processed_20231110.pkl └── wing_sim_args.zip ├── data_dev.csv ├── ivs.ipynb ├── ivs_wing.ipynb ├── main.py ├── pdf ├── ORC_wing_model_instruction.pdf └── no_butterfly_arbitrage_wing_model.pdf ├── plot.py ├── plot2.py ├── requirements.txt ├── utils ├── black_scholes.py └── calibrator.py ├── wing_calibrate.ipynb └── wing_simulate.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # For Mac 7 | .DS_Store 8 | 9 | # C extensions 10 | *.so 11 | 12 | # Distribution / packaging 13 | .Python 14 | build/ 15 | develop-eggs/ 16 | dist/ 17 | downloads/ 18 | eggs/ 19 | .eggs/ 20 | lib/ 21 | lib64/ 22 | parts/ 23 | sdist/ 24 | var/ 25 | wheels/ 26 | share/python-wheels/ 27 | *.egg-info/ 28 | .installed.cfg 29 | *.egg 30 | MANIFEST 31 | 32 | # PyInstaller 33 | # Usually these files are written by a python script from a template 34 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 35 | *.manifest 36 | *.spec 37 | 38 | # Installer logs 39 | pip-log.txt 40 | pip-delete-this-directory.txt 41 | 42 | # Unit test / coverage reports 43 | htmlcov/ 44 | .tox/ 45 | .nox/ 46 | .coverage 47 | .coverage.* 48 | .cache 49 | nosetests.xml 50 | coverage.xml 51 | *.cover 52 | *.py,cover 53 | .hypothesis/ 54 | .pytest_cache/ 55 | cover/ 56 | 57 | # Translations 58 | *.mo 59 | *.pot 60 | 61 | # Django stuff: 62 | *.log 63 | local_settings.py 64 | db.sqlite3 65 | db.sqlite3-journal 66 | 67 | # Flask stuff: 68 | instance/ 69 | .webassets-cache 70 | 71 | # Scrapy stuff: 72 | .scrapy 73 | 74 | # Sphinx documentation 75 | docs/_build/ 76 | 77 | # PyBuilder 78 | .pybuilder/ 79 | target/ 80 | 81 | # Jupyter Notebook 82 | .ipynb_checkpoints 83 | 84 | # IPython 85 | profile_default/ 86 | ipython_config.py 87 | 88 | # pyenv 89 | # For a library or package, you might want to ignore these files since the code is 90 | # intended to run in multiple environments; otherwise, check them in: 91 | # .python-version 92 | 93 | # pipenv 94 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 95 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 96 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 97 | # install all needed dependencies. 98 | #Pipfile.lock 99 | 100 | # poetry 101 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 102 | # This is especially recommended for binary packages to ensure reproducibility, and is more 103 | # commonly ignored for libraries. 104 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 105 | #poetry.lock 106 | 107 | # pdm 108 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 109 | #pdm.lock 110 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 111 | # in version control. 112 | # https://pdm.fming.dev/#use-with-ide 113 | .pdm.toml 114 | 115 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 116 | __pypackages__/ 117 | 118 | # Celery stuff 119 | celerybeat-schedule 120 | celerybeat.pid 121 | 122 | # SageMath parsed files 123 | *.sage.py 124 | 125 | # Environments 126 | .env 127 | .venv 128 | env/ 129 | venv/ 130 | ENV/ 131 | env.bak/ 132 | venv.bak/ 133 | 134 | # Spyder project settings 135 | .spyderproject 136 | .spyproject 137 | 138 | # Rope project settings 139 | .ropeproject 140 | 141 | # mkdocs documentation 142 | /site 143 | 144 | # mypy 145 | .mypy_cache/ 146 | .dmypy.json 147 | dmypy.json 148 | 149 | # Pyre type checker 150 | .pyre/ 151 | 152 | # pytype static type analyzer 153 | .pytype/ 154 | 155 | # Cython debug symbols 156 | cython_debug/ 157 | 158 | # PyCharm 159 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 160 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 161 | # and can be added to the global gitignore or merged into this file. For a more nuclear 162 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 163 | #.idea/ 164 | -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "kdb.connectionMap": {} 3 | } -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2024 Jincheng GONG 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 | # wing_model 2 | ORC wing model calibrator and simulator. 3 | -------------------------------------------------------------------------------- /data/sse50_2023-11-10.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Jincheng-Gong/wing_model/d514b012ed5e3903a5edc427753ae0d175edfb65/data/sse50_2023-11-10.pkl -------------------------------------------------------------------------------- /data/sse50_option_data_processed_20231110.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Jincheng-Gong/wing_model/d514b012ed5e3903a5edc427753ae0d175edfb65/data/sse50_option_data_processed_20231110.pkl -------------------------------------------------------------------------------- /data/wing_sim_args.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Jincheng-Gong/wing_model/d514b012ed5e3903a5edc427753ae0d175edfb65/data/wing_sim_args.zip -------------------------------------------------------------------------------- /data_dev.csv: -------------------------------------------------------------------------------- 1 | symx,askp1,bidp1,prc 2 | RM409,2778,2777,2777.5 3 | RM409C2150,634,622.5,628.25 4 | RM409C2175,615,598,606.5 5 | RM409C2200,583,572.5,577.75 6 | RM409C2225,567,547.5,557.25 7 | RM409C2250,560,511.5,535.75 8 | RM409C2275,535.5,487,511.25 9 | RM409C2300,510.5,463,486.75 10 | RM409C2325,486,438.5,462.25 11 | RM409C2350,462,414.5,438.25 12 | RM409C2375,438,390.5,414.25 13 | RM409C2400,414,367.5,390.75 14 | RM409C2425,390,344.5,367.25 15 | RM409C2450,366.5,321.5,344 16 | RM409C2475,324.5,306,315.25 17 | RM409C2500,295.5,287,291.25 18 | RM409C2550,252.5,248.5,250.5 19 | RM409C2600,215,210.5,212.75 20 | RM409C2650,180,176.5,178.25 21 | RM409C2700,150,148.5,149.25 22 | RM409C2750,124.5,122.5,123.5 23 | RM409C2800,103.5,103,103.25 24 | RM409C2850,86.5,84,85.25 25 | RM409C2900,73,72,72.5 26 | RM409C2950,62.5,61.5,62 27 | RM409C3000,54,52.5,53.25 28 | RM409C3050,45.5,45,45.25 29 | RM409C3100,40,39,39.5 30 | RM409C3150,35,34.5,34.75 31 | RM409C3200,31.5,31,31.25 32 | RM409C3250,28,27.5,27.75 33 | RM409C3300,26,25.5,25.75 34 | RM409C3350,25.5,25,25.25 35 | RM409P2150,2,1.5,1.75 36 | RM409P2175,3,1.5,2.25 37 | RM409P2200,3,1.5,2.25 38 | RM409P2225,3,2,2.5 39 | RM409P2250,3.5,2,2.75 40 | RM409P2275,3.5,2,2.75 41 | RM409P2300,4,2.5,3.25 42 | RM409P2325,4.5,3,3.75 43 | RM409P2350,5,4.5,4.75 44 | RM409P2375,6,5.5,5.75 45 | RM409P2400,6.5,6,6.25 46 | RM409P2425,8,7.5,7.75 47 | RM409P2450,11,10.5,10.75 48 | RM409P2475,12.5,12,12.25 49 | RM409P2500,16,15.5,15.75 50 | RM409P2550,24.5,24,24.25 51 | RM409P2600,36,35,35.5 52 | RM409P2650,51.5,50.5,51 53 | RM409P2700,72,71,71.5 54 | RM409P2750,97.5,95,96.25 55 | RM409P2800,126.5,123.5,125 56 | RM409P2850,159.5,157,158.25 57 | RM409P2900,196,192.5,194.25 58 | RM409P2950,234.5,231.5,233 59 | RM409P3000,276,271,273.5 60 | RM409P3050,317.5,315,316.25 61 | RM409P3100,366,357.5,361.75 62 | RM409P3150,413.5,402,407.75 63 | RM409P3200,459.5,447,453.25 64 | RM409P3250,506.5,491,498.75 65 | RM409P3300,553.5,542,547.75 66 | RM409P3350,601.5,584.5,593 67 | -------------------------------------------------------------------------------- /ivs.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 13, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import os\n", 10 | "import time\n", 11 | "import datetime\n", 12 | "import pandas as pd\n", 13 | "import numpy as np\n", 14 | "import matplotlib.pyplot as plt\n", 15 | "from scipy.stats import norm\n", 16 | "from IPython.display import clear_output\n", 17 | "from utils.black_scholes import *\n", 18 | "from utils.calibrator import *\n", 19 | "\n", 20 | "plt.style.use(\"ggplot\")\n", 21 | "\n", 22 | "ivs_log_path = './ivs_log/{}'.format(datetime.date.today())\n", 23 | "if not os.path.isdir(ivs_log_path):\n", 24 | " os.makedirs(ivs_log_path)\n", 25 | "\n", 26 | "def find_strike(x):\n", 27 | " if x['symx'].__len__() > 5:\n", 28 | " return x['symx'][6:]\n", 29 | " else:\n", 30 | " return np.nan\n", 31 | "\n", 32 | "def find_vega(x):\n", 33 | " return bs_vega(x[\"forward\"], x[\"strike\"], x[\"maturity\"], x[\"market_imp_vol_prc\"], x[\"r\"], \"c\")\n", 34 | "\n", 35 | "def Black(CP, F, X, sigma, T, r):\n", 36 | " d1 = (np.log(F/X) + (sigma**2 / 2) * T) / (sigma * np.sqrt(T))\n", 37 | " d2 = d1 - sigma * np.sqrt(T)\n", 38 | " call_price = F * np.exp(-1 * r * T) * norm.cdf(d1) - X * np.exp(-1 * r * T) * norm.cdf(d2)\n", 39 | " put_price = X * np.exp(-1 * r * T) * norm.cdf(-1 * d2) - F * np.exp((-1 * r) * T) * norm.cdf(-1 * d1)\n", 40 | " value = call_price + CP * (put_price - call_price)\n", 41 | " return value\n", 42 | "\n", 43 | "def newton_imp_vol(C0, CP, F, X, T, r, vol_est=0.25, n_iter=1000):\n", 44 | " for i in range(n_iter):\n", 45 | " d1 = (np.log(F/X) + (vol_est**2 / 2) * T) / (vol_est * np.sqrt(T))\n", 46 | " vega = F * np.exp(-1 * r * T) * norm.pdf(d1) * T**0.5\n", 47 | " vol_est = vol_est - (Black(CP, F, X, vol_est, T, r) - C0) / vega\n", 48 | " return vol_est\n" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 15, 54 | "metadata": {}, 55 | "outputs": [ 56 | { 57 | "name": "stdout", 58 | "output_type": "stream", 59 | "text": [ 60 | "{'success': True, 'vr_': 0.24420031904126974, 'sr_': 0.4275141814957703, 'pc_': 2.369873040983272, 'cc_': 1.195117458411083}\n", 61 | "{'success': True, 'vr_': 0.24353441915999893, 'sr_': 0.4483659755127863, 'pc_': 2.5187682767340234, 'cc_': 1.1476973547459999}\n" 62 | ] 63 | }, 64 | { 65 | "data": { 66 | "image/png": "iVBORw0KGgoAAAANSUhEUgAABcUAAAI9CAYAAAD7MRDvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVjU1ffA8fcMMywKKIIIjICAiJpphrjgkrmRiaUGilpppmlZaWaWaZa4ZWVqtrhLmcqWluKapWWimeYvW1xDCRFc2fdh5vcHX6YmUDFlYMbzeh6fr/P53LnnnpmR79OZy7kKvV6vRwghhBBCCCGEEEIIIYS4CyhregFCCCGEEEIIIYQQQgghhKlIUVwIIYQQQgghhBBCCCHEXUOK4kIIIYQQQgghhBBCCCHuGlIUF0IIIYQQQgghhBBCCHHXkKK4EEIIIYQQQgghhBBCiLuGFMWFEEIIIYQQQgghhBBC3DWkKC6EEEIIIYQQQgghhBDiriFFcSGEEEIIIYQQQgghhBB3DSmKCyGEEEIIIYQQQgghhLhrSFFcCCGEEEIIUetFRUWhUCiIiooyut6kSROaNGlSI2sSQgghhBDmSYriQgghhBBCVJFCoTD6Y2VlhbOzMw8++CBr165Fr9dXeM65c+cM4x0dHcnLy6t07sLCQho0aGAYe+bMmRuu5fvvv8fKygqFQsH06dOvO+6PP/5g8ODBuLq6YmtrS0BAAG+++SYFBQWVjr906RITJkzAz88PGxsbXFxc6N+/PwcPHrzhevLy8li0aBE9evTA1dUVa2tr6tevT/v27Zk2bRpJSUk3fL4QQgghhBCmoqrpBQghhBBCCGFu3nzzTQBKSko4c+YMmzZtYu/evRw+fJjFixdX+hyVSkVOTg5xcXGMHDmywv0vvviCjIwMVCoVWq32hvFzcnIYMWIEderUITc397rjfvzxR3r06EFJSQlhYWF4enry7bffEhkZyTfffMM333yDjY2NYXxycjKdO3cmNTWV9u3bM2DAAK5cucLGjRvZvn07cXFxDBw4sEKcgwcPEhYWRmpqKo0bN+bhhx/Gw8OD/Px8/u///o93332Xd999l4MHD3L//fffMDchhBBCCCGqmxTFhRBCCCGEuEVvvfWW0eP9+/fTrVs3lixZwksvvVRpO4/AwEDOnTvHypUrKy2Kr1y5koYNG+Lv709iYuIN40+YMIGsrCymTp3KtGnTKh1TWlrKU089RX5+Pl999RWPPPIIADqdjsGDB/PFF1+wcOFCXnvtNaN5U1NTefHFF1m0aBEKhQKAN954g8DAQEaPHs0DDzxAgwYNDM85fvw4ISEh5Obm8vbbb/Pyyy+jUhn/Z8Zff/3FlClTyM7OvmFeQgghhBBCmIK0TxFCCCGEEOI2de7cmRYtWqDX6zl8+HClY1QqFSNGjGD//v2cOHHC6N6ZM2f47rvvePLJJ1Gr1TeM9dVXX7FmzRo++OADPDw8rjtu7969HD9+nAceeMBQEAdQKpW88847AHzyySeGli+FhYVs27YNpVLJ7NmzDQVxgKZNmzJmzBiuXbvGunXrjOK88MILZGdn8+qrr/Lqq69WKIgDeHl5ER0dTadOnQzXjhw5woQJE2jTpg0NGjTA1tYWf39/Jk2axLVr1274GgghhBBCCHE7pCguhBBCCCHEHaDT6QAqLQqXGz16NACrVq0yur5y5Ur0er3h/vVcunSJMWPGMGDAAB5//PEbjt2zZw8ADz30UIV7vr6+NGvWjL/++svQ6/vatWuUlJTg4uKCg4NDpc8B2L17t+Ha2bNn+eabb7C1tWXKlCk3XA9g1KplxYoVREdHExAQwFNPPcW4ceNo1KgRCxcuJDg4mJycnJvOJ4QQQgghxH8hRXEhhBBCCCFu0w8//MDJkyextramffv21x3n7+9Pt27d+OyzzygpKQFAq9Xy6aef0rlzZ5o3b37DOM888ww6nY6lS5fedE0nT540xLzeWgBOnToFgJOTE1ZWVly5cqXSPuXlxfPyeQH27dsHlLWGqV+//k3X9E9Tp07lwoULxMbGsmDBAhYtWsQPP/zA0qVLOXnyJB999NEtzSeEEEIIIURVSVFcCCGEEEKIW/TWW2/x1ltvMW3aNCIiIujZsyd6vZ533nnnhi1NoGy3+KVLl9iyZQsACQkJpKen33SX+OrVq/nqq6/4+OOPadSo0U3XmJWVBUC9evUqvV9+PTMzEwA7Ozt69OiBTqdjxowZRmOTkpJYuXIlABkZGYbr6enpADRu3Pim6/k3b29vrKysKlx/5plncHR0ZNeuXbc8pxBCCCGEEFUhB20KIYQQQghxi2bOnGn0WKFQsHr16koP0Py3sLAwXnzxRVatWsWgQYNYsWIFjo6ODB48+LrPOXfuHBMnTiQ8PPyG425FeS/xf/YOX7RoEV26dGHhwoUcOHCA4OBgrl69ysaNG/Hx8eHYsWNGhezK5qiqkpISli1bRnR0NH/88QdZWVmGFjQAqamp/zU1IYQQQgghbkiK4kIIIYQQQtyi8mJwXl4eiYmJjBo1inHjxuHj48MDDzxww+fa2dkxbNgwli1bxsGDB9m5cyejR4+mTp06133OqFGjsLOz4+OPP67yGst3gpfvGP+37Oxso3EALVu25MiRI8yaNYtdu3axZMkSXF1dGT16NEOHDqV9+/a4uroaxpfvij9//nyV11VuyJAhbNq0CV9fXx599FHc3NwMPccXLVpEUVHRLc8phBBCCCFEVUhRXAghhBBCiP+obt269O7dm4SEBAIDA3n88cc5efLkDQvcUNZC5eOPPyY8PJzS0lKefvrpG47/+eefycrKomHDhpXenzNnDnPmzOHRRx/lyy+/BCAgIAD4u2f4v50+fRqAZs2aGV338fFh9erVFcavWbMGgKCgIMO1Ll26AHD48GGysrKu26rl3w4fPsymTZvo2bMn27dvR61WG+7pdDreeeedKs0jhBBCCCHEfyE9xYUQQgghhLhNbdq0YcyYMZw/f56FCxfedHzbtm1p27Yt58+fp3Xr1kaF5so8+eSTPP300xX+dOvWDYD77ruPp59+mt69exue06NHDwB27NhRYb6kpCROnTqFt7c3vr6+VcqxvKf48OHDDdd8fHzo1asXhYWFvPvuuzedo3z395kzZwB49NFHjQriAIcOHaKgoKBKaxJCCCGEEOK/kJ3iQgghhBBC3AHTp08nKiqK9957j+eeew4nJ6cbjl+7di2nT5+madOmN537gw8+qPR6VFQU33//Pf369WP27NlG9x544AFatGjB999/z+bNm3nkkUeAsp3Yr776KgDjxo0z6gdeXrQub2MCZa1i3nzzTRITE+nXrx/du3c3irNkyRI6dOjAvHnzcHJyYsKECahUxv+Z8ddffzFlyhTGjRtH9+7dadKkCQB79+7lhRdeMIy7dOkS48ePv+nrIYQQQgghxO2QorgQQgghhBB3gEajYezYsSxevJh33nmHefPm3XD8Pffcwz333FNt67GysmLNmjX06NGDsLAwwsLC8PLy4ptvvuHw4cN07tyZl156yeg5p0+fpmvXrvTp04cmTZpQVFTE119/zR9//EFQUBCfffZZhTjNmzdn586dPPbYY0yePJnFixfTs2dPPDw8yMvL45dffmH//v0oFApDMT4oKIjOnTuzceNGgoOD6dKlCxcvXmT79u0EBAQYepULIYQQQghRHaR9ihBCCCGEEHfI1KlTqVOnDh988AEXL16s6eXQoUMHfvrpJx599FF27drFwoULycrKYsaMGXz99ddGO8IBGjVqxMMPP8yhQ4f44IMPWL16NXXr1mXhwoX88MMPNGjQoNI4HTt25OTJk7z//vv4+fmxdetW3nnnHdasWUN2djYvv/wyJ06coG3btkBZwX7z5s08++yzXLhwgQ8++IAffviB0aNHs3PnzgotVYQQQgghhLiTFHq9Xl/TixBCCCGEEEIIIYQQQgghTEF2igshhBBCCCGEEEIIIYS4a0hRXAghhBBCCCGEEEIIIcRdQ4riQgghhBBCCCGEEEIIIe4aUhQXQgghhBBCCCGEEEIIcdeQorgQQgghhBBCCCGEEEKIu4YUxYUQQgghhBBCCCGEEELcNaQoLoQQQgghhBBCCCGEEOKuIUVxIYQQQgghhBBCCCGEEHcNVU0vwBxkZGSg1Wprehk1omHDhly+fNli4pgyluRU++OYMpbkZB6xLC2OqWOZiqXlZGn5gORkLiQn8yA51X6Wlg9ITuZCcjIPlpaTpeUDkpMlUalUODk5VW1sNa/FImi1WkpKSmp6GSanUCiAsvz1er3ZxzFlLMmp9scxZSzJyTxiWVocU8cyFUvLydLyAcnJXEhO5kFyqv0sLR+QnMyF5GQeLC0nS8sHJKe7mbRPEUIIIYQQQgghhBBCCHHXkKK4EEIIIYQQQgghhBBCiLuGFMWFEEIIIYQQQgghhBBC3DWkKC6EEEIIIYQQQgghhBDiriEHbd4mrVZLfn5+TS+j2hQUFFBcXGwxcUwZ63bi6PV6VCoVdevWvcOrEkIIIYQQQgghhBDi7lariuI7d+5k8+bNZGZm0rhxY0aOHEmLFi1u+rwTJ07w1ltv4enpybvvvmt07+DBg8TExHDx4kUaNWrE0KFDad++/R1Zr1arJS8vDwcHB5RKy9x0r1arKSkpsZg4pox1u3Hy8vIoKirCxsbmDq5KCCGEEEIIIYQQQoi7W62p5CYmJhIVFcWgQYOYP38+LVq0YO7cuVy5cuWGz8vPz+ejjz7i3nvvrXDv1KlTLFq0iG7duvHuu+/SrVs3Fi5cyOnTp+/ImvPz8y26IC5qVp06dSgqKqrpZQghhBBCCCGEEEIIYVFqTTU3ISGBHj160LNnT8MucRcXF3bt2nXD5y1fvpzOnTvj7+9f4d7WrVtp3bo1AwcORKPRMHDgQFq1asXWrVvv2LqlIC6qi0KhqOklCCGEEEIIIYQQQghhcWpF+xStVktSUhIDBgwwut66dWtOnjx53eft2bOHixcv8sILL/DFF19UuH/q1Cn69etndK1NmzZs27at0vlKSkqM2l0oFArs7OwMfxeiJtzss1d+v7o/o5YWx5SxJCfziGVpcUwdy1QsLSdLywckJ3MhOZkHyan2s7R8QHIyF5KTebC0nCwtH5Cc7ma1oiienZ2NTqejXr16Rtfr1atHZmZmpc9JS0tj/fr1zJw5Eysrq0rHZGZmUr9+faNr9evXv+6cmzZtIj4+3vDYx8eH+fPn07Bhw0rHFxQUoFarK0/KgpgqR1O+luaSk7W1Ne7u7lUa6+bmdluxqsrS4pgyluRkHrEsLY6pY5mKpeVkafmA5GQuJCfzIDnVfpaWD0hO5kJyMg+WlpOl5QOS092oVhTFy1X2DUZl13Q6HR988AHh4eF4eHjcUgy9Xn/db0oGDhxIaGhohdiXL19Gq9VWGF9cXGyywyFryo0Oi4yJieGtt97i+PHjACxYsIAdO3bw9ddf/+c4KSkpdOzYkZ07d9KqVavbWvvNYt1p/157VeKEhYXRsmVLIiMjK71fXFxMWlraDedQKBS4ubmRnp6OXq//z+u/GUuLY8pYkpN5xLK0OKaOZSqWlpOl5QOSk7mQnMyD5FT7WVo+IDmZC8nJPFhaTpaWD0hOlkalUl13c3OFsdW8lipxdHREqVRW2MGdlZVVYfc4lO3Q/vPPPzl79iyrV68Gyorder2eiIgIpk+fTqtWrSrdFX69OaGsWHq9nb3V+SEqLYUff7Tm0iUrXF1L6dChmOtsfr+jLl26xAcffMA333xDeno6zs7O3HPPPYwePZquXbve1tx79uzh8ccf5+jRo7i6uhqu33fffahUKg4fPmy4duHCBYKCgli/fj1dunTh6NGjNGjQ4Lbi/9uCBQt4//336d69O7GxsUb3Pv74Y+bMmUOnTp2MflOgtqjqZ6/830B1s7Q4powlOZlHLEuLY+pYpmJpOVlaPiA5mQvJyTxITrWfpeUDkpO5kJzMg6XlZGn5gOR0N6oVRXGVSoWvry/Hjh2jffv2huvHjh0jKCiowng7Ozvee+89o2u7du3it99+Y9KkSYYibLNmzfj111+Ndn8fO3aMZs2aVVMmt27bNltmzKhHWtrfVXB391IiI7N4+OHCaoubkpLCgAEDcHR0ZNq0abRo0QKtVsvevXuZNm0a33///W3N3759e1QqFQcOHODRRx8F4PTp0xQVFVFYWMjZs2fx8fEBIDExEbVaTVBQEFZWVkZF9DupUaNGJCYmcuHCBaNvjWJiYtBoNNUSUwghhBBCCCGEEEIIUbsoa3oB5UJDQ/nmm2/49ttvOX/+PFFRUVy5coXevXsDsH79ej788EMAlEolXl5eRn8cHR1Rq9V4eXlha2sLwMMPP8wvv/zCl19+SWpqKl9++SW//vprhcM3a8q2bbY884wTaWnGb0N6upJnnnFi2zbbaov9+uuvA7B161ZCQ0Px8/MjICCAsWPHsmXLFgCWLVvGAw88QNOmTWnXrh1Tp04lLy+vSvPXrVuXNm3akJiYaLiWmJhIUFAQQUFBHDhwwHD9wIEDtG3bljp16pCSkoJGo+G3334zPEej0bBv3z769u2Ln58fjzzyCGfOnDGKt2jRIlq3bk2zZs2YPHkyc+fONXx2yjk7O9OtWzdiYmIM13766SeuXbtGz549jcbqdDoWLlxIYGAgPj4+9O7dmz179hiNOXr0KH369MHX15e+ffsa1vxPp06d4oknnsDf3582bdrwwgsvcO3atSq9hkIIIYQQQgghhBBC3Ex2cTYXci9Ueu9C7gWyi7NNvKLar9YUxYODgxk5ciRffPEFU6ZM4fjx40ydOtWwozcjI4MrV67c0pwBAQFMnDiRvXv3MnnyZL777jsmTpyIv79/daSAXg/5+Yoq/cnJUfDGG/Uo+y0Gxb/mKXs8Y0Y9cnKqNt+t/DZERkYGe/bsYeTIkdSpU6fC/fL2Mkqlkjlz5vDtt9+yaNEi9u/fz+zZs6scJzg4uEJRPDg4mE6dOlW43qVLlxvONX/+fGbMmMH27dtRqVS8/PLLhnsbN25kyZIlTJs2je3bt6PRaPjss88qnSciIoLo6GjD45iYGAYOHFihbc7KlStZtmwZM2bM4Ouvv6Z79+489dRTJCUlAZCfn8+IESPw8/Nj+/btTJo0iVmzZhnNcfHiRR577DFatmzJ9u3bWbduHVeuXGHs2LE3eeWEEEIIIYQQQgghhLi57OJshm8fTlhCGKm5qUb3UnNTCUsIY/j24VIY/5da0T6lXEhICCEhIZXeGz9+/A2fO3jwYAYPHlzheseOHenYseMdWd/NFBQo8Pd3vyNz6fUK0tKsaN68avOdPp1GnTpVq4yfO3cOvV5P06ZNbzhuzJgxhsMivby8eOWVV5g6dSrz5s2rUpzg4GCWLFnCxYsXadSoEQcPHuTZZ59Fp9OxatUqAFJTU/nrr7/o3LnzDed69dVX6dSpE1D2WXjyyScpLCzE1taW1atXExERwZAhQwB46aWX+O677yrd1d6rVy9ee+01Dh48SOvWrdmyZQubNm0yKpRD2S755557ztD6Zdq0aSQmJrJy5Urmzp3Lxo0bKS0t5f3338fOzo6AgADS0tKYOnWqYY41a9Zw7733Gl1bsGABQUFB/Pnnn/j5+VXpdRRCCCGEEEIIIYQQojK5xblcLbhKck4y4QnhxPePxx13UnNTCU8IJzkn2TDO0dqxhldbe9SqorgwjfIm+wqF4obj9u/fz4cffsipU6fIycmhtLSUwsJC8vPzK91h/m9BQUFYW1tz4MABWrZsSWFhIffeey96vZ6cnBySkpI4cuQINjY2lfaO/6eWLVsa/t6oUSMArl69ikajISkpiREjRhiNv++++9i/f3+FedRqNWFhYcTExJCcnIyvr6/R3AA5OTmkp6dXWFO7du34448/gLL+6C1btsTOzs5wPzAw0Gj8sWPHSExMrPQ3E5KTk6UoLoQQQgghhBBCCCFui4e9B3GhcYYCeNiWMNaHr2fYlmEk5yTj7eBNXGgcHvYeNb3UWkWK4neQnZ2e06fTqjT2xx+tefxx55uO+/zzq3ToUFyl2FXl4+ODQqHg9OnTPPTQQ5WOOX/+PE8++SQjRoxg8uTJ1K9fn59++omXX36ZkpKSKsWxs7PjvvvuIzExkczMTNq3b4+VVdmBou3atSMxMZEjR45w//33Y2tre8N5VaqKH1WdTmf4+78L/Dc6XXfYsGE89NBDnDx50rC7vDKVzVl+rSqn9+p0Onr37m3o3/5P5YV9IYQQQgghhBBCCCFuh8ZeY1QY77y6rCNDeUFcY6+p4RXWPrWmp7glUCigTh19lf5061aEu3spCkXlxVWFQo+Hh5Zu3YqqNN9NNn0bcXJyonv37kRFRZGfn1/hflZWFr/88gtarZaZM2cSGBiIn58f6enpt/yalPcVT0xMNLQ/gbK2NgcOHODAgQM3bZ1yM76+vvzf//2f0bVjx45dd3zz5s0JCAjg5MmTDBw4sMJ9BwcH3NzcOHTokNH1I0eOGHZ9N2vWjD/++IOCggLD/Z9//tlofOvWrTl58iSenp74+PgY/anKTnshhBBCCCGEEEIIIapCY69h8YOLja4tfnCxFMSvQ4riNcTKCiIjswAqFMbLH8+cmc3/NlbfcXPnzkWn09GvXz+2bt1KUlISp0+fZtWqVTzyyCN4e3uj1WpZuXIlycnJxMfHs3bt2luOExwczNmzZ9m7d69Rb/dOnTqxe/duUlJSCA4Ovq1cRo0axYYNG4iNjSUpKYlFixZx/PjxG7aHiY2N5eeffzYcKvpv48aN4+OPP+arr77izJkzzJ07l99//52nn34agIEDB6JUKpk8eTKnTp3im2++YenSpRXWlZmZyXPPPcfRo0dJTk7mu+++Y9KkSZSWlt5WzkIIIYQQQgghhBBClEvNTWXCnglG1ybsmVDh8E1RRoriNejhhwtZvjwDNzed0XV391KWL8/g4YcLqy22l5cXO3bsIDg4mMjISHr27ElERAQ//PAD8+bNo1WrVrz55pssWbKEHj16sGnTJqMDI6sqMDAQGxsboGzndLk2bdpQWlqKra0tbdu2va1cBg0axPPPP8+sWbN46KGHSElJYfDgwYa4lalTp851C+IATz/9NGPHjiUyMpJevXqxZ88e1qxZg6+vLwB169YlKiqKU6dOERISwvz585k2bZrRHG5ubnz55ZfodDqGDx9Ojx49mDFjBg4ODiiV8k9PCCGEEEIIIYQQQty+fx6q6e3gzf5R+/F28DYcvimF8YoU+qo0R77LXb58udJ+19nZ2Tg63v6praWlZT3GL12ywtW1lA4diqtth/itUqvVVe4hXpviRERE0LBhQ5YsWVLtsa7nTsSpymdMoVDg7u5OWlpalXqd/1eWFseUsSQn84hlaXFMHctULC0nS8sHJCdzITmZB8mp9rO0fEByMheSk3mwtJwsLR+wjJwu5F4gLCHMUBCP7x9PO/92HD59mLAt/7geGm/xh22q1WoaNmxYpbFy0GYtYGUFwcE3P0xTVK6goIDPPvuM7t27Y2VlxZdffsm+ffvYsGFDTS9NCCGEEEIIIYQQQohqY29tj7OdM4DRoZr/PHzT2c4Ze2v7mlxmrSNFcWERvv32Wz744AOKiorw8/NjxYoVdOvWraaXJYQQQgghhBBCCCFEtXG0dmRd33XkFudW2AmusdcQHxqPvbU9jta33+3CktSqovjOnTvZvHkzmZmZNG7cmJEjR9KiRYtKx544cYJ169aRmppKUVERDRs2pFevXoSGhhrGaLVavvzyS7777juuXbuGh4cHw4cP57777jNRRsIU7OzsiImJqellCCGEEEIIIYQQQghhco7Wjtctelt6y5T/qtYUxRMTE4mKimL06NEEBASwe/du5s6dy8KFC3Fxcakw3sbGhpCQELy9vbGxseHEiROsWLECW1tbevXqBUB0dDT79u1j7NixaDQafvnlF959911mz56Nj4+PqVMUQgghhBBCCCGEEEIIUcOUNb2AcgkJCfTo0YOePXsadom7uLiwa9euSsf7+PjQpUsXPD09cXV1pVu3brRp04bjx48bxuzbt4+BAwdy//3306hRI/r06UObNm3YsmWLqdISQgghhBBCCCGEEEIIUYvUip3iWq2WpKQkBgwYYHS9devWnDx5skpznD17lpMnTxIREWG4VlJSgrW1tdE4a2vr685ZUlJCSUmJ4bFCocDOzs7wdyFqws0+e+X3q/szamlxTBlLcjKPWJYWx9SxTMXScrK0fEByMheSk3mQnGo/S8sHJCdzITmZB0vLydLyAcnpblYriuLZ2dnodDrq1atndL1evXpkZmbe8Lnjxo0jOzub0tJSwsPD6dmzp+FemzZtSEhIoEWLFjRq1IjffvuNw4cPo9PpKp1r06ZNxMfHGx77+Pgwf/58GjZsWOn4goIC1Gp1FbM0X6bK0ZSvpbnkZG1tjbu7e5XGurm53VasqrK0OKaMJTmZRyxLi2PqWKZiaTlZWj4gOZkLyck8SE61n6XlA5KTuZCczIOl5WRp+YDkdDeqFUXxcpV9g3GzbzUiIyMpLCzk1KlTrF+/Hjc3N7p06QLAU089xdKlS5k4cSIKhYJGjRrRvXt39u7dW+lcAwcONDqoszz25cuX0Wq1FcYXFxcb7Sy3RGq12iQ5miqOKWPdiTjFxcWkpaXdcIxCocDNzY309HT0ev1txbub4pgyluRkHrEsLY6pY5mKpeVkafmA5GQuJCfzIDnVfpaWD0hO5kJyMg+WlpOl5QOSk6VRqVTX3dxcYWw1r6VKHB0dUSqVFXaFZ2VlVdg9/m+urq4AeHl5kZWVRVxcnKEo7ujoyJQpUyguLiY3NxcnJyfWrVtneM6/qdXq6+7svds+RKL2qOpnT6/Xm+RzamlxTBlLcjKPWJYWx9SxTMXScrK0fEByMheSk3mQnGo/S8sHJCdzITmZB0vLydLyAcnpblQrDtpUqVT4+vpy7Ngxo+vHjh0jICCgyvPo9fpKd3RbW1vToEEDSktL+fHHH2nXrt1tr1lATEwMLVq0MDxesGABvXv3vqMxNBoNO3bsuGPzdejQgWXLlt2x+arq36+VEEIIIYQQQgghhBCiZtSKojhAaGgo33zzDd9++y3nz58nKiqKK1euGIqs69ev58MPPzSM37FjB4cPHyYtLY20tDT27NnDli1b6Nq1q2HM6dOn+fHHH7l48SLHjx9n7ty56PV6Hn30UZPnVxtdunSJ6dOn06lTJ3x8fGjXrh0jRoxg3759dzTOhQsXaNKkCd26dbuj8wKEhYWh0WiMPhvlnnjiCTQaDQsWLLil+WbMmGF4fOzYMTQaDYcOHap0/LBhwxg5cuQtr1sIIYQQQgghhBBCCFEzakX7FIDg4GBycnL44osvyMjIwNPTk6lTpxr6wGRkZHDlyhXDeL1ez4YNG7h06RJKpRI3NzeGDx9Or169DGNKSkqIjo7m0qVL2Nra0rZtW55//nnq1q1r8vyqQq/Xm+xk2JSUFAYMGICjoyPTpk2jRYsWaLVa9u7dy7Rp0/j+++/vWKzY2Fj69+/PwYMH+emnnwgKCrpjcwN4eHgQExPD888/b7iWnp7O/v37adSo0W3N3bp1a1q2bElMTAzt27c3upeamsq+fftYuXLlbcUQQgghhBBCCCGEEEKYTq0pigOEhIQQEhJS6b3x48cbPe7bty99+/a94XwtW7Zk4cKFd2x91SG3OJf5h+ezK3kXWp0WlVJFH+8+vNruVeyt7ast7uuvvw7A1q1bqVOnjuF6QEAAERERACxbtoy4uDjOnTtH/fr16d27N9OnT7+lLxX0ej2xsbHMnTsXd3d3NmzYYFQULy4uZubMmWzbto2srCwaNmzI448/zgsvvFDpfAsXLiQqKop169bRqlUrAHr16sWWLVuMCu6xsbF069aN1NTUG64vJiaGN998k+XLl7Nx40YOHDjAgQMHWLVqFQAHDx5k6NChvP3228yaNcvotYqNjcXZ2ZmePXuSmZnJjBkz2L17N0VFRXTq1Il58+bh6elZ5ddKCCGEEEIIIYQQQghR/WpN+5S7UW5xLv039yfq9yjO554nPT+d87nnifo9iv6b+5NbnFstcTMyMtizZw8jR440KvKWKz/cVKlUMmfOHL799lsWLVrE/v37mT179i3F2r9/PwUFBXTt2pXHHnuMLVu2kJv7d16rV69m165drFy5ku+//54lS5ZUWkjW6/XMmDGDDRs2sGnTJkNBHMoOSB00aBAxMTGGa7GxsYbi/vUsXbqUyMhI1q1bR7du3YiMjCQwMJDhw4dz9OhRjh49ioeHBwMHDkSr1bJlyxaj9cTFxREeHo5KpeKll17i2LFjrFmzhs2bN6PX6xk6dCglJSW39HoJIYQQQgghhBBCCCGqlxTFa9D8w/M5k3EGHTqj6zp0nMk4wzuH36mWuOfOnUOv19O0adMbjhszZgxdunTBy8uLLl268MorrxgVhqsiOjqaRx55BCsrKwICAmjSpAmbN2823E9NTcXHx4cOHTrQuHFj2rdvz4ABA4zm0Gq1vPjii3z33Xd8+eWX+Pr6VogTERHBli1byM/P5+DBg+Tk5NCzZ8/rrmvevHksX76c+Ph4AgMDAXB0dMTa2hpbW1tcXV1xdXXFysoKJycnQkJCiI2NNTw/MTGR5ORkhgwZQlJSErt27eLdd9+lQ4cO3HPPPSxZsoT09PQ7ekioEEIIIYQQQgghhBDi9klRvAbtSt5VoSBeToeOXcm7qiWuXq8HuGn/8v379xMWFkZgYCDNmjVj4sSJZGRkkJ+fX6U4WVlZbN++nccee8xw7bHHHiM6OtrwePDgwfz+++906tSJN954g++++67CPG+99RY///wzmzZtwsPDo9JYLVu2xMfHh4SEBKKjo3nsscdQq9WVjv3kk0/4/PPP2bRpEy1atKhSLkOHDuXgwYOcPXsWKCv2BwUF0bRpU86cOYNKpeL+++83jG/QoAF+fn6cOXOmSvMLIYQQQgghhBBCCCFMQ4riNUSv16PVaW84pkRXYihg30k+Pj4oFApOnz593THnz5/nySefpEWLFixfvpzt27czZ86csnVVsSXIpk2bKCwsJDQ0FC8vL7y8vJgzZw5Hjhzh1KlTANx7770cPHiQ1157jcLCQsaNG8eYMWOM5unWrRvp6ens3bv3hvEiIiL49NNP2bp16w1bp3Ts2JHS0tJb2vXetWtXGjduTGxsLDk5OWzfvp2hQ4cCXPc9qo73TgghhBBCCCGEEEIIcXukKF5DFAoFKuWNzzlVKVU33c39Xzg5OdG9e3eioqIq3fWdlZXFL7/8glarZebMmQQGBuLn50d6evotxYmOjmbs2LHs2rXL8Ofrr78mODjYaLe4g4MDAwYM4N133+WTTz5h27ZtZGRkGO736dOHDz/8kFdeeYWvvvrquvEGDBjAiRMnCAgIoFmzZtcd17ZtWz7//HOWLFnCJ598YnRPrVaj01Xcva9QKBgyZAhxcXFs2rQJpVJJ//79AfD390er1fLzzz8bxl+7do2kpCT8/f1v/kIJIYQQQgghhBBCCCFMRoriNaiPdx+U13kLlCgJ8Q6ptthz585Fp9PRr18/tm7dSlJSEqdPn2bVqlU88sgjeHt7o9VqWblyJcnJycTHx7N27doqz//bb7/x66+/MmzYMJo3b270Z8CAAcTHx1NSUsLy5cv56quvOH36NH/++ScJCQm4uroaDvss17dvXxYvXsykSZNISEioNGb9+vX5+eefjXp/X0+7du34/PPPWbhwIcuXLzdc9/T05OjRo6SkpHDt2jWjAvmQIUO4ePEi8+fP59FHHzUcUurr60tISAhTpkzh0KFD/P7777z44ou4ubkRElJ976EQQgghhBBCCCGEEOLWSVG8Br3a7lWaOjWtUBhXosTfyZ8p7aZUW2wvLy927NhBcHAwkZGR9OzZk4iICH744QfmzZtHq1atePPNN1myZAk9evRg06ZNTJ06tcrzR0dH06xZs0oP83zooYfIzMzk66+/pm7dunz00Uf07t2bfv36kZKSwtq1a1EqK340Q0NDWbhwIRMmTGDbtm2Vxq1Xr56hWH0zQUFBfPbZZ7z77rusWrUKgLFjx6JUKunevTv33nsvqamphvEajYauXbuSmZnJkCFDjOZ6//33uffeexkxYgSPPPIIer2eDRs2XLevuRBCCCGEEEIIIYQQomYo9NL4+KYuX75caR/t7OxsHB0db2vu3OJc3jn8DruSd1GiK0GtVNPHuw9T2k3B3tr+tua+E9RqdZV7iJtDHFPGuhNxqvIZUygUuLu7k5aWVq19zC0tjiljSU7mEcvS4pg6lqlYWk6Wlg9ITuZCcjIPklPtZ2n5gORkLiQn82BpOVlKPtnF2eQW5+Jh71Ehpwu5F7C3tsfR+vbqfTXJUt6n/0KtVtOwYcMqjb1xU2sT27lzJ5s3byYzM5PGjRszcuRIWrRoUenYEydOsG7dOlJTUykqKqJhw4b06tWL0NBQo3Fbt25l165dXLlyBUdHRzp06MCwYcOwtrY2RUo3ZW9tT2RwJJHBkej1+mrpIS6EEEIIIYQQQgghxN0uuzib4duHc7XgKnGhcTR2aGy4l5qbSnhCOM52zqzru86sC+Pi5mpNUTwxMZGoqChGjx5NQEAAu3fvZu7cuSxcuBAXF5cK421sbAgJCcHb2xsbGxtOnDjBihUrsLW1pVevXgDs27eP9evX8+yzz9KsWTPS0tL4+OOPARg5cqQp06sSKYgLIYQQQgghhBBCCFE9cotzuVpwleScZMITwonvH4877oaCeHJOsmGcFMUtW63pKZ6QkECPHj3o2bOnYZe4i4sLu3btqnS8j48PXbp0wdPTE1dXV7p160abNm04fvy4YcypU6cICAigS5cuuLq60qZNGzp37kxSUpKp0hJCCCGEEEIIIYQQQtQCHvYexIXG4e3gTXJOMmFbwkhMSSRsSxjJOcl4O3gTFxqHh71HTS9VVLNasVNcq9WSlJTEgAEDjK63bt2akydPVmmOs2fPcvLkSSIiIgzXmjdvzr59+zhz5gxNmzbl4sWLHD16lAceeKDSOUpKSox6QCsUCuzs7Ax/F6Im3OyzV36/uj+jlhbHlLEkJ/OIZWlxTB3LVCwtJ0vLByQncyE5mQfJqfaztHxAcjIXkpN5sLScLCWfxg6Nie8fbyiEd17dGQBvB2/i+8ejsdfU8Apvj6W8T9WtVhy0ee3aNcaNG8esWbMICAgwXN+4cSPfffcdixcvvu5zx40bR3Z2NqWlpYSHhxMWFmZ0f/v27Xz22WcAlJaW0qdPH0aPHl3pXLGxscTHxxse+/j4MH/+/OvGTkpKwsHBoUo5CvFf5OTk4OvrW9PLEEIIIYQQQgghhLAoiSmJhoI4wP5R+wn2DK7BFQlTqhU7xctV9g3Gzb7ViIyMpLCwkFOnTrF+/Xrc3Nzo0qULAL///jsbN25k9OjR+Pv7k56ezpo1a6hfv36F4jnAwIEDjQ7qLI99+fJltFpthfHFxcVGO8stkVqtNkmOpopjylh3Ik5xcTFpaWk3HKNQKHBzcyM9Pb1aTxW2tDimjCU5mUcsS4tj6limYmk5WVo+IDmZC8nJPEhOtZ+l5QOSk7mQnMyDpeVkSfmk5qYybMswo2vD4oZZzE5xS3mfbpVKpaJhw4ZVG1vNa6kSR0dHlEolmZmZRtezsrKoV6/eDZ/r6uoKgJeXF1lZWcTFxRmK4jExMXTr1o2ePXsaxhQWFrJ8+XIGDRqEUmncUl2tVqNWqyuNc7d9iETtUdXPnl6vN8nn1NLimDKW5GQesSwtjqljmYql5WRp+YDkZC4kJ/MgOdV+lpYPSE7mQnIyD5aWk7nn889DNb0dvFkfvp5hccMMPcbjQuPMvjAO5v8+VbdacdCmSqXC19eXY8eOGV0/duyYUTuVm9Hr9UY7uouKiirsNFcqlfKBEEIIIYQQQgghhBDiLnMh94JRQTy+fzzBnsHE9483HL4ZnhDOhdwLNb1UUc1qxU5xgNDQUJYsWYKvry/NmjVj9+7dXLlyhd69ewOwfv16rl27xvPPPw/Ajh07cHFxQaMp++bmxIkTbNmyhb59+xrmDAwMZOvWrfj4+Bjap8TExNCuXbsKu8SFEEIIIYQQQgghhBCWy97aHmc7ZwCjHeEaew1xoXGEJ4TjbOeMvbV9TS5TmECtKYoHBweTk5PDF198QUZGBp6enkydOtXQByYjI4MrV64Yxuv1ejZs2MClS5dQKpW4ubkxfPhwevXqZRjz2GOPoVAoiI6O5tq1azg6OhIYGMjQoUNNnp8liomJ4a233uL48eMALFiwgB07dvD111/f0jwajYaoqCjDFyD/lpKSQseOHdm5cyetWrW65XUmJiYSHh7OH3/8cdN2PHdaWFgYLVu2JDIy0qRxhRBCCCGEEEIIIYQxR2tH1vVdR25xLh72Hkb3NPYa4kPjsbe2x9HasYZWKEyl1hTFAUJCQggJCan03vjx440e9+3b12hXeGWsrKwIDw8nPDz8jq3Rkly6dIkPPviAb775hvT0dJydnbnnnnsYPXo0Xbt2ve35FyxYwPvvv2947ODgQIsWLZgyZQqdOnUyXD969CguLi5Vnre8SG5lZcWPP/6Iu7u74d7FixcJCgqitLSUgwcP4unpWeX5/ll0nz59Onv27GH//v0VxqelpdG+fXuWLVvGww8/XOV1CyGEEEIIIYQQQoia5WjteN2i978L5cJySQ+R2sSEvc5TUlLo27cv+/fvZ9q0aezevZt169YRHBzMtGnT7licgIAAjh49ytGjR9m8eTM+Pj6MGDGC7OxswxhXV1dsbGxuee5GjRoRHx9vdC0uLg43N7fbXndERATnzp3jxx9/rHAvNjYWJyen6+5sF0IIIYQQQgghhBBC1F5SFK9hitxcHN94A9cOHXBt1w7XDh1wfOMNFLm51Rr39ddfB2Dr1q2Ehobi5+dHQEAAY8eOZcuWLQAsW7aMBx54gKZNm9KuXTumTp1KXl7eLcWxsrLC1dUVV1dXmjVrxssvv0xeXh5JSUmGMRqNhm3bthkeHz16lD59+uDr60vfvn357bffKp07PDycmJgYo2uxsbE3/c2AgoICnnjiCUJDQ8nIyKBjx45A2W8qaDQawsLCaNWqFffeey/R0dEVnh8bG0tYWBhqtZoDBw7Qr18/fHx8aNu2LXPnzjU67FUIIYQQQgghhBBCCFG7SFG8Bilyc3Hp35+6UVGozp9HlZ6O6vx56kZF4dK/f7UVxjMyMtizZw8jR46kTp06Fe6X991WKpXMmTOHb7/9lkWLFrF//35mz579n+MWFRURGxtLvXr18PPzq3RMfn4+I0aMwM/Pj+3btzNp0iRmzZpV6dg+ffqQlZXFoUOHADh06BCZmZk33MGdnZ3N4MGDKSkpMez43rp1KwDR0dEcPXqUFStWAGW7xRMSEoy+CDhw4ADnzp0jIiKCtLQ0nnjiCdq0acPXX3/NvHnz2LBhA4sXL/5Pr48QQgghhBBCCCGEEKL6SVG8BjnMn4/qzBkUOp3RdYVOh+rMGRzeeada4p47dw69Xk/Tpk1vOG7MmDF06dIFLy8vunTpwiuvvGLYRV5VJ06cwN/fH39/f/z8/Fi2bBkfffQRDg4OlY7fuHEjpaWlvP/++wQEBNC7d2/GjRtX6ViVSsWgQYMMu7mjo6MZNGgQKlXlrfIvX77MY489houLC5999pnhCwFn57JTh52cnHB1dcXJyQmAgQMHotPpSEhIMMwRHR1NYGAgzZo149NPP8XDw4M5c+bQtGlTHnroIV5++WWWLVuG7l/vqRBCCCGEEEIIIYQQonaQongNst21q0JBvJxCp8N2165qiav/X+9yhUJxw3H79+8nLCzMUASeOHEiGRkZ5OfnVzmWn58fu3btYteuXezYsYMnn3ySsWPH8ssvv1Q6/vTp07Rs2RI7OzvDtcDAwOvOP3ToUBISErh06RIJCQlERERcd2xERATe3t6sXLkSa2vrm669Xr169O3b11B0z83NZdu2bYYYZ86cITAw0Oh1DAoKIi8vj7S0tJvOL4QQQgghhBBCCCGEMD0pitcUvR5u1nu6pKRaDt/08fFBoVBw+vTp6445f/48Tz75JC1atGD58uVs376dOXPm/G9ZJVWOpVar8fHxwcfHh1atWvH666/j5ubGypUrKx2vv8V8mzdvTtOmTXnuuefw9/enefPm1x3bs2dPfvzxR06ePFnl+SMiIjh06BBJSUls3rwZgEceecSw1n9/sXCr6xdCCCGEEEIIIYQQ4k6S+tTNSVG8pigUcJ02HwYqVdm4O8zJyYnu3bsTFRVV6a7vrKwsfvnlF7RaLTNnziQwMBA/Pz/S09PvSHwrKysKCwsrvdesWTP++OMPCgoKDNd+/vnnG843ZMgQDhw4wJAhQ2447vXXXyc8PJywsDBOnTpluK5WqwEqbXnSuXNnvL29iY2NJTo6mv79+2Nvbw+Av78/hw8fNvpBc/jwYezt7XF3d7/hWoQQQgghhBBCCCGEuFNyi3N5I/ENOqzvgOdCTzqs78AbiW+QW1w9ZxaaOymK16DCPn3QKyt/C/RKJYUhIdUWe+7cueh0Ovr168fWrVtJSkri9OnTrFq1ikceeQRvb2+0Wi0rV64kOTmZ+Ph41q5de8txSktLuXTpEpcuXSIpKYlFixZx6tQp+vTpU+n4gQMHolQqmTx5MqdOneKbb75h6dKlN4wxfPhwfv31V4YNG3bT9cyYMYPHHnuMwYMHc+bMGQBcXFywtbVlz549XL58mezsbMN4hULB4MGDWbt2LUeOHGHo0KGGeyNGjODChQtMnz6dM2fOsHPnThYsWMAzzzyD8jrvqxBCCCGEEEIIIYQQd1JucS79N/cn6vcoUnJTSM1JJSU3hajfo+i/ub8UxishlbsalPPqq2ibNq1QGNcrlWj9/cmZMqXaYnt5ebFjxw6Cg4OJjIykZ8+eRERE8MMPPzBv3jxatWrFm2++yZIlS+jRowebNm1i6tSptxzn5MmTtG3blrZt29KnTx8SEhKYN28e4eHhlY6vW7cuUVFRnDp1ipCQEObPn8+0adNuGEOlUtGgQYPrHrD5b7NmzaJ///4MHjyYP//8E5VKxaxZs/j888+5//77GTVqlNH4wYMHk52djZ+fH0FBQYbr7u7urF27lv/7v/+jd+/evPbaawwdOpQJEyZUaR1CCCGEEEIIIYQQQtyu+Yfnk5p9muf8dKxvD7EdYX17eM5PR2r2ad45/E5NL7HWUehrUZOZnTt3snnzZjIzM2ncuDEjR46kRYsWlY49ceIE69atIzU1laKiIho2bEivXr0IDQ01jHnrrbf4448/Kjy3bdu2t1TgvXz5cqV9tLOzs3F0dKzyPJVR5Obi8M47ZYdqlpSAWk1hnz7kTJmC/n9tOmqSWq2+pR7itT2OKWPdiThV+YwpFArc3d1JS0ur1p5RlhbHlLEkJ/OIZWlxTB3LVCwtJ0vLByQncyE5mQfJqfaztHxAcjIXkpN5sLScLC0fsJycHogJ4vVmF/CqA1b/6MRcqoO/CmDeKQ17hxyquQWaiFqtpmHDhlUaW7WttSaQmJhIVFQUo0ePJiAggN27dzN37lwWLlyIi4tLhfE2NjaEhITg7e2NjY0NJ06cYMWKFdja2tKrVy8AJk+ejPYfh1nm5OTwyiuv0KlTJ5PldTN6e3uyIyPJjowsO1SzGnqICyGEEEIIIYQQQgghLI9er2eQewZedsYFcQArJXjZwUD3a+j1ehRSdzSoNe1TEhIS6NGjBz179jTsEndxcWHXrl2Vjvfx8aFLly54enri6upKt27daNOmDcePHzeMsbe3p379+oY/x44dw8bGho4dO5oqrVsjH0whhBBCCCGEEEIIIUQVKRQKguoXY3WdKq+VEoLqF0tB/F9qxU5xrVZLUlISAwYMMLreunVrTp48WaU5zp49y8mTJ4mIiLjumG+//Zbg4GBsbW0rvV9SUmLU7kKhUGBnZ2f4uxA14WafvfL71f0ZtbQ4powlOZlHLEuLY+pYpmJpOVlaPiA5mQvJyTxITrWfpeUDkpO5kJzMgyXklF2cTW5xLh72HhXyuZB7AXtrexytb6+1cE2yhPdIr9fjXKKAysudAGX3Me8877RaURTPzs5Gp9NRr149o+v16tUjMzPzhs8dN24c2dnZlJaWEh4eTs+ePSsdd+bMGVJSUnj22WevO9emTZuIj483PPbx8WH+/PnX7UVTUFCAWq2+4fosgalyNOVraS45WVtb4+7uXqWxbm5utxWrqiwtjiljSU7mEcvS4pg6lqlYWk6Wlg9ITuZCcjIPklPtZ2n5gORkLiQn82CuOWUVZjFo3SAu5V1i74i9eNbzBMrySclKYXDcYFzrurJj+A7q2da7yWy1m7m+R+XemPAGeocSnnxydoV7n302HUWOmlX9PWpgZbVXrSiKl6vs24qbfYMRGRlJYWEhp06dYv369bi5udGlS5cK47799ls8PT1p2rTpdecaOHCg0UGd5bEvX75s1Ju8XHFxsckOh6wp5nQoZW2LdSfiFBcXk5aWdsMxCoUCNzc30tPTq/1wQEuKY8pYkpN5xLK0OKaOZSqWlpOl5QOSk7mQnMyD5FT7WVo+IDmZC8nJPJh7ThdyL5CWlUZyTjJdV3Xli0e+ILBpIEfOHOGxzY+RnJNMqbaUMyln8LA3z4Krub9HAOj12KfDB/GzAIwK4599Np01a2bxYpdI0i5csPjWzSqVyrwO2nR0dESpVFbYFZ6VlVVh9/i/ubq6AuDl5UVWVhZxcXEViuJFRUXs37+fIUOG3HAutVp93Z29ZvsPQ5i9qn729Hq9ST6nlhbHlLEkJ/OIZWlxTB3LVCwtJ0vLByQncyE5mQfJqfaztHxAcjIXkpN5MNec3Ou6ExcaR3hCOMk5yTy2+THWh69n2OZhJOck4+3gTVxoHO513c0yv38y1/eo3Pz0ZRQOKGH5mln8+WdrHB2vUVqqYvv2p3lmwBvM/2011xgNZpzjnVYriuIqlQpfX1+OHTtG+/btDdePHTtGUFBQlefR6/WV7ug+cOAAWq2Wrl273pH1CiGEEEIIIYQQQghh6TT2GqPCeOfVnQEMBXGNvaaGVygAtN0ewndtASpFMd9/H264bq/Oouf2P9A+3rcGV1c71YqiOEBoaChLlizB19eXZs2asXv3bq5cuULv3r0BWL9+PdeuXeP5558HYMeOHbi4uKDRlP3jO3HiBFu2bKFv34pv8rfffktQUBAODg6mS0gIIYQQQgghhBBCCDOnsdew+MHFDNg8wHBt8YOLpSBeC+j1cPCgNW8e+IjfSyqetJlX4kAEcay4Lx0pixurNUXx4OBgcnJy+OKLL8jIyMDT05OpU6ca+sBkZGRw5coVw3i9Xs+GDRu4dOkSSqUSNzc3hg8fTq9evYzmvXDhAidOnGD69OkmzUcIIYQQQgghhBBCCHOXmpvKhD0TjK5N2DNBdorXIJ0Odu+24cMPHThyxPp/V/WAcc9wPUoUCj0z5rnS59FLWFmZfKm1Vq0pigOEhIQQEhJS6b3x48cbPe7bt2+lu8L/zcPDg9jY2DuyPmEsJiaGt956i+PHjwOwYMECduzYwddff13DK/tbYmIi4eHh/PHHHzftT3+nDRgwgBYtWhAZGWnSuEIIIYQQQgghhBB3QmpuqqF1ireDd1lP8biynuLhCeFSGDexkhLYvNmOjz6y5+TJsnMR1Wo9JSUK/l0QL6fXK7hwQcWPP1oTHFxswtXWbsqaXoCoOZcuXWL69Ol06tQJHx8f2rVrx4gRI9i3b98dmX/BggVoNBo0Gg2enp60a9eOyZMnc/Xq1f88Z0pKChqNBi8vL9LS0ozuXbx4ES8vLzQaDSkpKbc032+//Wa4Nn36dDp37lzp+LS0NDw9Pdm2bdt/zkEIIYQQQgghhBCitruQe8GoIB7fP55gz2Di+8fj7eBtKIxfyL1Q00u1eAUFEBVVh65dXXnxRSdOnlRjb69j/Pgcnn46t0pzXLok28T/SYritYgpT7lNSUmhb9++7N+/n2nTprF7927WrVtHcHAw06ZNu2NxAgICOHr0KIcOHWLevHl8/fXXTJgwodKxpaWl6HS6Ks3bqFEj4uPjja7FxcXh5uZ222uOiIjg3Llz/PjjjxXuxcbG4uTkZOh1L4QQQgghhBBCCGGJ7K3tcbZzrnCoZvnhm94O3jjbOWNvbV/DK7VcWVkKPvjAng4dGjFtWn1SUlS4uJTy2mvZvPdeJkeOWLN0adXOUHR1La3m1ZoXKYrXMJ0ul0uX3iApqQNnz7YjKakDly69gU5XtW95/qvXX38dgK1btxIaGoqfnx8BAQGMHTuWLVu2ALBs2TIeeOABmjZtSrt27Zg6dSp5eXm3FMfKygpXV1fc3d3p3bs3o0aN4rvvvqOgoICYmBhatGjB119/TZcuXfDx8eH8+fMUFRUxe/Zs2rVrh4+PD507d2bDhg1G84aHhxMTE2N0LTY2lvDwcG6koKCAYcOGERoaSkZGBh07dgTKWvdoNBrCwsJo1aoV9957L9HR0RWeHxsbS1hYGGq1mgMHDtCvXz98fHxo27Ytc+fORavV3tLrI4QQQgghhBBCCFEbOVo7sq7vOuJD4yu0SNHYa4gPjWdd33U4WjvW0Aot16VLSubOdaBDh0bMn+/I1atWeHpqmTUrk2nTstm82Y5x4xpw8KANKpUeOzsdZT3FK1Io9Hh4aOnQQVqn/JMUxWuQTpfLX3/1JzMzCq32PFptOlrteTIzo/jrr/7VVhjPyMhgz549jBw5kjp16lS4X957W6lUMmfOHL799lsWLVrE/v37mT179m3FtrW1RafTUVpa9u1UQUEBH374Ie+//z7ffvstLi4uTJgwga+++opZs2axd+9e3n777Qrr7NOnD1lZWRw6dAiAQ4cOkZmZecMd3NnZ2QwbNozi4mLDju+tW7cCEB0dzdGjR1mxYgVQtls8ISHB6EuAAwcOcO7cOSIiIkhLS+OJJ56gTZs2fP3118ybN48NGzawePHi23p9hBBCCCGEEEIIIWoLR2tHPOw9Kr3nYe8hBfE7LDnZitdeq0fHjo346CMHcnKUBASUsGBBBmPH5rJypT0vveTEH3+oqVNHxzPP5HLw4EU++CAThaKsAP5P5Y9nzsyWQzb/pVYdtHm3uXJlPsXFZ4B/twzRUVx8hitX3sHV9c4f0nju3Dn0ej1Nmza94bgxY8agVqspKSnBy8uLV155halTpzJv3rz/FPfMmTN89tlntG3bFnv7sl+tKSkpYe7cudx3332UlJTw559/smXLFjZs2EC3bt0A8Pb2rjCXSqVi0KBBREdH0759e6Kjoxk0aBAqVeUf6cuXL/Pss8/SpEkTli9fjkJRdviAs7MzAE5OTri6uhrGDxw4kFmzZpGQkMCQIUOAssJ5YGAgzZo14+2338bDw4M5c+agUCho2rQp6enpzJ07l5deegmlUr5vEkIIIYQQQgghhBA398cfKj7+2J6vvrJDpyurWQUGFvP007n89ZeKt9925PLlsqq2k1MpTz+dx8iReTg5lRW93d0LWb48gxkz6pGW9nf12929lJkzs3n44ULTJ1XLSVG8BuXm7qJiQbycjtzcXdVSFC/vXV5eGL6e/fv38+GHH3Lq1ClycnIoLS2lsLCQ/Pz8SneYV+bEiRP4+/uj0+koKiqiU6dOvPPOO4b71tbWtGzZ0vD4999/x8rKik6dOt107qFDh/LII4/w2muvkZCQwObNm6/bviQiIoL77ruPpUuXYm1tTUlJyQ3nrlevHn379iU6OpohQ4aQm5vLtm3bmDlzJlBW4A8MDDR6DYOCgsjLyyMtLQ2NRk5eFkIIIYQQQgghhBDX99NP1ixZYs8339garj34YCHDhuVx9Kg1r75an5ycso2XGo2WcePyiIjIp04d4x3hpaXZ9O59gZAQDw4dsqG42Blr66u0b1+ETneB0lJ7rKxkV/8/SVG8hpQVpm/Wf7oEvV5/0+L1rfLx8UGhUHD69GkeeuihSsecP3+eJ598khEjRjB58mTq16/PTz/9xMsvv3zTgvI/+fn5sWbNGqysrGjUqBE2NjZG921tbY3ys7W1/fcU19W8eXOaNm3Kc889h7+/P82bN+e3336rdGzPnj3Ztm0bp06donXr1lWaPyIigiFDhpCUlMTBgwcBeOSRRwAqfV9MeVCqEEIIIYQQQgghhDA/ej18+60NH35oz6FDZXUyhUJPaGghgwbl8+23tjz/fAOKisrqTs2alfDcc7kMGFCAWl1xvtLSbFJTh1NaepXGjeMIDm6MuzukpRVTXJzK+fPhWFk5o9Gsk8L4P0iPhxpSVlC92XcSqjteEIeyViHdu3cnKiqK/Pz8CvezsrL45Zdf0Gq1zJw5k8DAQPz8/EhPT7/lWGq1Gh8fH7y8vCoUxCvTokULdDodBw4cqNL8Q4YM4cCBA4YWJ9fz+uuvEx4ezpAhQzh58qTR+gB0uoo79jt37oy3tzexsbFER0fTv39/Q9sXf39/Dh8+bFQIP3z4MPb29ri7u1dp7UIIIYQQQgghhBDi7qDVwpdf2tG7d0OefNKZQ4dssLbWM3x4HqtWXUOp1PP00w1Yu7YuRUUK7r+/mDVrrvLNN5cJD6+8IA5lZxaWll6lpCSZ8+fDKSlJBaCkJPV/j5MpLb1abWcXmqtatVN8586dbN68mczMTBo3bszIkSNp0aJFpWNPnDjBunXrSE1NpaioiIYNG9KrVy9CQ0ONxuXl5bFhwwYOHTpEXl4erq6uPPHEE9x///2mSOmG7O37kJkZReUtVJTY24dUW+y5c+fy6KOP0q9fPyZPnkyLFi0oLS3l+++/57PPPuOjjz5Cq9WycuVKevTowU8//cTatWurbT3lPD09CQ8P5+WXX2bWrFm0bNmS8+fPc+XKFcMu7X8aPnw4/fv3x9Hx5t90zZgxg9LSUgYNGkR8fDxNmzbFxcUFW1tb9uzZg7u7OzY2Noa5FAoFgwcPZsWKFWRmZvLGG28Y5hoxYgQrV65k+vTpPPXUU/z5558sWLCAZ555RvqJCyGEEEIIIYQQQggACgshLq4On3xiT3JyWSm2Th0dTzyRT2BgMdHRdRg1ytkwvkePQsaPz6VDh2KqsldWrfagceM4QwE8JSWMevXWk5IyjJKSZNRqbxo3jkOtrvzA1LtVrSmKJyYmEhUVxejRowkICGD37t3MnTuXhQsX4uLiUmG8jY0NISEheHt7Y2Njw4kTJ1ixYgW2trb06tULAK1Wy+zZs3F0dGTSpEk4Oztz9erVW2rRUZ1cXF4lP/+HSg7bVGJt7Y+Ly5Rqi+3l5cWOHTv44IMPiIyM5NKlSzRo0IDWrVszb948WrVqxZtvvsmSJUuYPXs2HTt2ZOrUqUyYMKHa1lRu3rx5vP3227z++utkZGTg4eHBiy++WOlYlUpFgwYNqjx3eU/wwYMHExcXh5+fH7NmzWLhwoW89957dOjQgfj4eMP4wYMHs2DBAvz8/AgKCjJcd3d3Z+3atcyePZvevXtTv359hg4dapLXRwghhBBCCCGEEEL8N6Wl2eh0uZUWiUtKLqBU3pn+2zk5CtaurcuKFXW5dOnvQzJHjcqjSRMtUVH2LFtW1pFAqdTTv38Bzz2XS6tWN2u3XJFarTEqjB892vl/18sL4nL23b8p9LWkEfLrr7+Oj48PY8aMMVx76aWXCAoKYtiwYVWa47333sPGxoYXXngBgF27drFlyxYWLlyISvXf6/+XL1+utI92dnZ2lXYo34hOl8uVK+/879DNEkCNvX0fXFymoFTa39bcd4Jarb6lHuK1PY4pY92JOFX5jCkUCtzd3UlLS6vWvuaWFseUsSQn84hlaXFMHctULC0nS8sHJCdzITmZB8mp9rO0fEByMheSk3mwtJwsIZ9/99+2tm5syKm4+Pwd6b999aqSlSvr8umndcnKKusm4O5eypgxudStq2PVKntOnSrrhWJjo2fw4HzGjculSZPS286voOAnUlIGGB57en6JnV3Q9Z9gYdRqNQ0bNqzS2FqxU1yr1ZKUlMSAAQOMrrdu3dqo//ONnD17lpMnTxIREWG4duTIEfz9/Vm1ahWHDx/G0dGRzp07M2DAgEpbXJSUlBgVMRUKBXZ2doa/Vwel0h5X10hcXSOr5VBNYf5u9pkov1/dnx1Li2PKWJKTecSytDimjmUqlpaTpeUDkpO5kJzMg+RU+1laPiA5mQvJyTxYWk6WkI9en2fUf9vL6wvAHa32gmGXdfk4haLeLc19/rwVn3xSlw0b6lBYWPYaNW2qZcyYXPLzFaxcWZfU1LJSrIODjhEj8hk9Og9X1/LuEbf3upaUpJKebtzBID19Ap6e8bJTvBK1Yqf4tWvXGDduHLNmzSIgIMBwfePGjXz33XcsXrz4us8dN24c2dnZlJaWEh4eTlhYmOHexIkTuXz5Ml26dCEkJIS0tDRWrVrFww8/bDSuXGxsrFHrDB8fH+bPn3/d2ElJSTg4ONxqukJUWU5ODr6+vjW9DCGEEEIIIYQQQgiLUFiYwv/9X3cKC5OwtfWlRYu1HD/+hOHxffftxdbWs8rz/fEHzJ8P69eXHaYJEBQEzz8PZ8/Chx/ClStl111d4aWX4Nlnod6t1dxNmtPdoFbsFC9X2TdNN/v2KTIyksLCQk6dOsX69etxc3OjS5cuAOj1ehwdHRk7dixKpRJfX18yMjLYvHlzpUXxgQMHGh3UWR778uXLaLUV+/kUFxebrOVHTTGnViO1LdadiFNcXExaWtoNxygUCtzc3EhPT6/2lg+WFMeUsSQn84hlaXFMHctULC0nS8sHJCdzITmZB8mp9rO0fEByMheSk3mwtJwsJx8VHh4xpKSEUViYZNR/28MjhowMFXDjWgzAzz+rWbLEnp07/z67sGvXIoYNy+foUTXPPluH/PyyThXe3lqefTaP8PB87OwgP7/sz51QUnKBlJTHDIdqajSx1KsXiEYTy19/PUZhYRJHjnTF0/MLiz9sU6VSmVf7FEdHR5RKJZmZmUbXs7KyqHeTr01cXV2BsoMjs7KyiIuLMxTF69evj0qlMmqVotFoyMzMRKvVVugzrlarUavVlcYx73/swpxV9bOn1+tN8jm1tDimjCU5mUcsS4tj6limYmk5WVo+IDmZC8nJPEhOtZ+l5QOSk7mQnMyDpeVkCfmoVB64uS026r/t5rYYlcrjhrnp9fD99zZ8+KE9iYk2ACgUevr2LeSRR/L57jtbXnyxPiUlZRttW7Ys4fnnc+jXr5DyMuSdfukUirpYWTkD0LhxHCqVhyHH8sM3raycUSjqmv37difViqK4SqXC19eXY8eO0b59e8P1Y8eOERRU9Wbwer3eaEd3QEAA+/fvR6fTGQrjaWlpODk53dbBm0IIIYQQQgghhBBCCPN0vf7bjRvHVdp/u7QUtm+35aOP7Dl2zBoAlUrPoEEF9OhRyObNdjz7bAP0+rJieMeORYwfn8uDDxZR3S3Yrawc0WjWodPlVtgJrlZraNw4HqXS/j8fHGqpak1lODQ0lCVLluDr60uzZs3YvXs3V65coXfv3gCsX7+ea9eu8fzzzwOwY8cOXFxc0GjKPqgnTpxgy5Yt9O3b1zBnnz592LFjB1FRUTz00EOkp6ezadMmozFCCCGEEEIIIYQQQoi7Q0lJquFQTbXam1at1vPbb8MMh2/+szBeXAxffFGHjz+2JymprIxqZ6dj2LB82rYtJjq6LuPGNTDM3adPAc89l0tQkGnbLVtZOV636G3pLVP+q1pTFA8ODiYnJ4cvvviCjIwMPD09mTp1qqEPTEZGBlfKu9JTtit8w4YNXLp0CaVSiZubG8OHD6dXr16GMS4uLkyfPp1PP/2UV155hQYNGtC3b18GDBhg6vSEEEIIIYQQQgghhBA1qKTkglFB3NMznnr12uHpGU9KSpihMO7ktJGYGD+WL7cnPd0KgPr1dYwYkYeXl5bPPqvLqlX2AFhZ6RkwoIDx43MJCKh4JqGonWpNURwgJCSEkJCQSu+NHz/e6HHfvn2rtOO7WbNmzJkz546sTwghhBBCCCGEEEIIYZ6USnvWrJmKQpHL9OndDDvCy9qMxDF9+iF+/70DZ8+2ITOzrBju5lbKqFG51KmjZ/Xqv3eM29qW7RgfOzaPxo1Laywn8d/UqqK4EEIIIYQQQgghhBDmKrs4m9ziXDzsK7asuJB7AXtrexytpbdzTbGycqR+/UEsWNCQ+vWzmTQpD4ALF5SMHduaI0f+PtuwSRMto0fnkp+vYPXqv3eM16un46mn8hg1Kg9nZ12N5CFunxTFRY0KCwujZcuWzJs3r6aXcsvK1x4ZGVml8TExMbz11lscP368mlcmhBBCCCGEEEIIU8suzmb49uFcLbhKXGgcjR0aG+6l5qYSnhCOs50z6/quk8J4DZo0qQSFIpv33nPkjz/U5OfD99+7otOVnYjZqlUxI0bkk5JixXvvOZKZqQTKdoyPGZPL44/nY2+vr8kUxB2grOkF3M0WLHBg4UL7Su8tXGjPggUO1RJ34sSJaDQaNBoN3t7edOrUicjISPLz86v0/LCwMGbMmGF0rW3btnz00UdG1+bMmYNGo2Hfvn1G1wcPHmxoh7NixQqmTJlyG9lUlJKSgkajwcvLi7S0NKN7Fy9exN3dHY1GQ0pKyh2NK4QQQgghhBBCiLtXbnEuVwuukpyTTHhCOKm5qcDfBfHknGSuFlwltzi3hlcqrKzKeoFv22bH3r2g0ymwstIzalQu7dsX88YbjnzwgQOZmUp8fbW8914miYkXGTcuTwriFkKK4jVIqdTz3nuOFQrjCxfa8957jiiV1feP7MEHH+To0aMkJiYyZcoUPv300yrveK5Mp06dSExMNLp24MABPDw8jK4XFxdz5MgRgoODAXBycsLevvIvBm5Xo0aNiI+PN7oWFxeHu7t7tcQTQgghhBBCCCHE3cvD3oO40Di8HbxJzkkmbEsYiSmJhG0JIzknGW8Hb+JC4yptrSKqn04HO3fa0q1bQ+bPd6S0VGF0v7QUVq+uy+rV9hQWKmndupjly6+xd+8lhg7Nx8amhhYuqoUUxe8gvR7y8xVV/jN2bB4TJuTw3nuOvPOOA/n5Ct55x4H33nNkwoQcxo7Nq/Jc+lusn1tbW+Pq6opGo2HgwIEMGjSInTt3MnHiREaNGmU0dsaMGYSFhQFlu8wPHDjAqlWrDLvNU1JSCA4O5qeffkKrLTtlNzc3l99++43x48dz4MABw1xHjx6lsLDQUBT/967zDh068MEHHzBp0iSaNWtGUFAQn3/+udF6fvrpJ3r37o2vry99+/Zlx44daDQafvvtN6Nx4eHhxMTEGF2LjY1l8ODBFV6PAwcO0K9fP3x8fGjbti1z58415AKQn5/Piy++iL+/P23btmXp0qUV5iguLmb27NkEBgbStGlTHnrooQpfFAghhBBCCCGEEMJyaew1RoXxzqs7GxXENfaaml7iXaewENavr0P37g0ZNaoBf/6pBiorpCkABdbWOtatu8K2bVfo168QKysTL1iYhPQUv4MKChT4+/+3XciLFzuweLHDdR/fzOnTadSp8993ltva2lJSUnLTcZGRkSQlJdG8eXMmT54MgLOzM8HBweTl5fF///d/tGvXjh9//BFfX19CQ0OZOXMmBQUF2NnZkZiYiLu7Oz4+PteNsWzZMl555RVeeOEFtm7dytSpU+nYsSNNmzYlNzeXkSNH0qNHDz766CPOnz/Pm2++Wek8ffr0Ye3atRw6dIj27dtz6NAhMjMzCQkJ4f333zeMS0tL44knnmDw4MEsXryYM2fO8Morr2BjY8PLL78MwKxZs0hMTGTVqlU0bNiQt99+m2PHjtGyZUvDPJMmTSIlJYWPP/6YRo0asWvXLh5//HF2796Nr69vld4HIYQQQgghhBBCmDeNvYbFDy5mwOYBhmuLH1wsBXETy8xUsHZtXVavrsulS2WV7Tp1dOTnKykrgFeuuFiJtTUorj9EWADZKS44evQomzZtokuXLjcd6+joiLW1Nba2tri6uuLq6oqVlRW+vr64ubkZdoUfOHCAjh074uLigpeXFz/99BMAiYmJhl3i19OjRw9GjhyJj48P48ePp0GDBoYd1xs3bkShUPDuu+/SrFkzevTowbPPPlvpPCqVikGDBhEdHQ1AdHQ0gwYNQqUy/i7o008/xcPDgzlz5hh2eL/88sssW7YMnU5HXl4e0dHRvPHGG3Tr1o0WLVqwaNEiSktLDXOcO3eOL7/8kmXLltGhQweaNGnC+PHjCQoKqrBbXQghhBBCCCGEEJYrNTeVCXsmGF2bsGeCoce4qF6pqUpmznSkfftGvP22I5cuWeHuXsrrr2fx8MMFVZqjvIguLJfsFL+D7Oz0nD6ddvOB//Lhh/YsXuyAWq2npETBhAk5PP/8rR26YGd3a7vEd+/ejb+/P6WlpZSUlBASEsLs2bOZPXv2Lc3zT8HBwRw4cIAXXniBAwcOMG7cOAA6duxIYmIiHTp04Oeff2bu3Lk3nOefu68VCgUNGzbk6tWrAPz555+0aNECW1tbw5j77rvvunMNHTqURx55hNdee42EhAQ2b95cYcyZM2cIDAxE8Y+vAIOCgsjLyyMtLY3MzEyKi4tp166d4b6TkxN+fn6Gx7/++it6vZ6uXbsazV1cXIyTk9MN8xVCCCGEEEIIIYRl+Oehmt4O3qwPX8+wuGGGwzelhUr1+eMPFUuX2vPVV3ZotWU1nubNS3jyyTwuX1ayfLk9V65UrdjdsKH25oOEWatVRfGdO3eyefNmMjMzady4MSNHjqRFixaVjj1x4gTr1q0jNTWVoqIiGjZsSK9evQgNDTWM2bt3Lx9//HGF537++edYW1vf8fUrFNxyC5OFC8sK4pMnZ/PSS7mGQzbVaj0vvVR9pxEHBwczb9481Go1jRo1Qq1WA6BUKtH/q0H5P3tr32zOGTNmcO3aNX777Tc6duwIlB3CuXr1ah544AEKCwvp3LnzDef5905uhUKBTqcDQK/XGxWvy69dT/PmzWnatCnPPfcc/v7+NG/enBMnTlR4/o3mvNH85XQ6HVZWVmzfvh2r/zWbUqlUaLVa6tate9PnCyGEEEIIIYQQwrxdyL1gVBCP7x9PO892xPePNxy2GZ4QTnxovBy2eYfo9ZCYaM0nn9izZ8/fGyiDg4sIC8vn2DE1s2Y5UlBQ1izDw0NLZlYu+XmOVN5AQ4dzw/N07FirSqaiGtSadzgxMZGoqChGjx5NQEAAu3fvZu7cuSxcuBAXF5cK421sbAgJCcHb2xsbGxtOnDjBihUrsLW1pVevXoZxdnZ2LF682Oi51VEQ/y/KC+DlBXHA8L/vvedo9PhOq1OnTqV9vZ2dnTl58qTRtd9//91QNAdQq9WGIvU/BQcHk5+fz/Lly/Hx8aFhw4ZA2U7xiRMn8s033+Dl5UXjxo3/87qbNm3Kpk2bKCoqwuZ/x/4eO3bshs8ZMmQIr7/+OvPmzav0vr+/P9u2bTMqjh8+fBh7e3vc3d2pX78+arWaI0eOoNGUfZubmZlJUlKSofDfqlUrSktLuXr1Kh06dADKXqeq9GkXQgghhBBCCCGE+bO3tsfZzhnAaEd4+eGb4QnhONs5Y29tX5PLtAhaLWzbZssnn9hz7FhZnU+p1NOvXyE9exbyzTe2TJ5cH52urM7TqlUxzz6bx8MP5/Ppsom89XYMoMO4MF5W63rh6ZdRKhdxo77jwvzVmqJ4QkICPXr0oGfPngCMHDmSX375hV27djFs2LAK4318fIyKuq6urhw6dIjjx48bFcUVCgX169ev9vX/FzqdwqggXq78cfk/XFPq3Lkzn3zyCXFxcQQGBvLll19y8uRJWrVqZRjj6enJ0aNHSUlJoW7dutSvXx+lUom3tzcajYY1a9YwcOBAw3g3Nzc0Gg1r16412sn/XwwcOJD58+czZcoUnn/+eVJTU1m6dClAhd3e5YYPH07//v1xdHSs9P6IESNYuXIl06dP56mnnuLPP/9kwYIFPPPMMyiVSurWrUtERASzZ8/GycmJhg0bMn/+fJTKv39w+vn5MWjQICZMmMCMGTNo1aoV2dnZfPfddzRv3tzwuRZCCCGEEEIIIYRlcrR2ZF3fdeQW51bYCa6x1xAfGo+9tT2O1pXXJ8TNFRQoiImxY9kye/76q6ysaWurY/DgAlq1KmbTpjpMnPh3G9vu3QsZNy6XLl2K/3dwpoI+929CMTOMDz9czOXLnoaxDRue5/nnJ9K7xWYUisUIy1YriuJarZakpCQGDBhgdL1169YVdi1fz9mzZzl58iQRERFG1wsLC3nuuefQ6XQ0adKEIUOGVLpDGqCkpMRoZ69CocDOzs7w9zvt5ZdzrnuvOlun3Ej37t2ZOHEic+bMoaioiKFDhxIWFmbUcmTs2LFMnDiR7t27U1hYyMGDB/H0LPshEhwcTFxcHJ06dTKat1OnTmzYsOGmh2zejIODA1FRUUydOpU+ffrQvHlzXnrpJcaPH2/YOf5vKpWKBg0aXHdOd3d31q5dy+zZs+nduzf169dn6NChTJjw96EYb7zxBnl5eTz11FPY29szduxYcnKM37/333+fxYsXExkZSXp6Ok5OTgQGBtKjR4/byvlmn73y+9XxGbXkOKaMJTmZRyxLi2PqWKZiaTlZWj4gOZkLyck8SE61n6XlA5KTuZCcaq96NvWoZ1MPqJiTxsG8e4nX5Ht09aqSNWvqsGZNXTIyyjYpOjnpePLJPJyddXz+eR0++6ysfa1KpWfAgALGjcujZcvylsD/W7Nej/Nha7r12UTnzl/x669duXrVHWfnNO69dx9W6HDeZYeiM2Cmn0VL+bdU3RT6qjRMrmbXrl1j3LhxzJo1i4CAAMP1jRs38t1331Vof/JP48aNIzs7m9LSUsLDwwkLCzPcO3XqFOnp6Xh5eVFQUMC2bds4evQo7777Lu7u7hXmio2NJT4+3vDYx8eH+fPnXzd2UlISDg4Ot5quuMPi4+OZMGECZ86cMXyJYSlycnLw9fWt6WUIIYQQQgghhBBCmNyff8L778OaNVBQUHbNxweefRYKC+GTTyAtrey6gwM88wxMmACentefU9vCm5+n/EW+F/DPczdLoc5fcP87XqiOJ1dXSqKWqBU7xctV9g3Gzb7ViIyMpLCwkFOnTrF+/Xrc3Nzo0qULAM2aNaNZs2aGsQEBAbz66qts376dUaNGVZhr4MCBRu09ymNfvny50sMmi4uLLb5ntKn6Yt9KnLi4OLy9vXFzc+OPP/4gMjKS/v37o1KpqjRHbczpeoqLi0kr/+l+HQqFAjc3N9LT06t0KOh/ZWlxTBlLcjKPWJYWx9SxTMXScrK0fEByMheSk3mQnGo/S8sHJCdzITmZB0vLyZT5/PKLmo8/rsvWrbaG9sKtWxczZEg+586pmDmzDnl5ZTvG3dxKGT06j8cfz8fRsWxdNyqlOHbuTdsXVnNupJ6rnUGnAqUWnPdDkygFRRG9uXyTWkxtZmmfu1uhUqkMZxzedGw1r6VKHB0dUSqVZGZmGl3PysqiXr16N3yuq6srAF5eXmRlZREXF2coiv+bUqnEz8+P9PT0Su+r1WqjAyX/6W77ENVmly9f5r333uPy5cu4uroSGhrKa6+9VtPLqjZV/ezp9XqTfE4tLY4pY0lO5hHL0uKYOpapWFpOlpYPSE7mQnIyD5JT7Wdp+YDkZC4kJ/NgaTlVVz56PezZY8Mnn9iTmPh3i9wHHyykb98CDhyw4c0366HVlhXJmzcvYezYXAYMKMDa+u85biZ7yhRc9u2j6Sdn8P9Ih56y5ip6pRKtvz/ZU6ZYxPtlaZ+7O61WFMVVKhW+vr4cO3aM9u3bG64fO3aMoKCgKs+j1+sr3dH9z/vJycmG/tfCPD333HM899xzNb0MIYQQQgghhBBCCHGbiovhq6/KDs88frxss6pKpefRRwsICipm2zZbpkz5+/DMzp2LePbZXLp3L/pPbb/19vZc2bIFh3fewXbXLlQ6HVqlksI+fciZMgW9vf2dSk3UYrWiKA4QGhrKkiVL8PX1pVmzZuzevZsrV67Qu3dvANavX8+1a9d4/vnnAdixYwcuLi5oNGWHFJw4cYItW7bQt29fw5xxcXH4+/vj7u5u6Cl+7tw5nn76adMnKIQQQgghhBBCCCGEACA3V8G6dXVYscKetLSy5t516+oYOjQfLy8t0dF1+eKLOgAolXr69y87PLN169tviau3tyc7MpKcWbNwd3Pj8l3YauRuV2uK4sHBweTk5PDFF1+QkZGBp6cnU6dONfSBycjI4MqVK4bxer2eDRs2cOnSJZRKJW5ubgwfPpxevXoZxuTl5bF8+XIyMzOpU6cOPj4+zJw5k6ZNm5o8PyGEEEIIIYQQQggh7nYXLypZvboun31Wl+zssr7gDRuW8sQTeVhZ6Vm3ri4XLpSVLO3sdAwbls+YMXl4epZWz4L+y3ZzYfZqTVEcICQkhJCQkErvjR8/3uhx3759jXaFV2bkyJGMHDnyTi1PCCGEEEIIIYQQQgjxH5w5o2Lp0rLd38XFZYVoP78Shg7N5/JlJStX2hsVyZ96Ko8nn8zDyUl2cIs7r1YVxYUQQgghhBBCCCGEEJbjp5+s+fjjuuzaZWe4FhRUxCOPFPDrr9bMn+9IScnfRfJx4/IYNCgfW9uaWrG4G0hRXAghhBBCCCGEEEIIccfodLBrly2ffGLP4cPWhushIQV06VLEnj22vPFGfcP19u3LDs/s1asIpbIGFizuOlIUF0IIIYQQQgghhBBC3LbCQvjiizosW1aXP/9UA2BtrWfQoHwCAkr48ss6hmK4QqGnb99Cxo3LJTDw9g/PFOJWSFFc1BoTJ04kOzub1atX35H5FixYwI4dO/j666/vyHy3QqPREBUVRe/evU0eWwghhBBCCCGEEMKUMjMVfPZZXVavrsvly1YAODqWHZJZr14pGzbUJTq6LgC2tnoGD87nmWdy8fGppsMzhbgJ+YWEu9DEiRPRaDRoNBq8vb3p1KkTkZGR5OfnV+n5YWFhzJgx47r3hw4diqenJ0eOHLlTSwYgJiYGjUbDAw88UOHe5s2b0Wg0dOjQ4Zbma9GihdG1nj17Mnny5ErHf/nll3h7e3P58uVbW7gQQgghhBBCCCGEGVqwwIGFC+0rvbdwoT1vvunIW285EhTUiPnzHbl82Qp391ImT85m+PA8oqPrMH9+Pf76S4WTUymTJuVw6NBF5s3LkoK4qFGyU7wGZRdnk1uci4e9R4V7F3IvYG9tj6O1Y7XEfvDBB3n//fcpKSnh0KFDTJ48mfz8fN5+++3bmjc1NZUjR47w1FNPER0dTWBg4B1acZk6depw5coVDh8+TLt27QzXywvmtysiIoL33nuPWbNmYWdnZ3QvOjqaXr160bBhw9uOI4QQQgghhBBCCFHbKZV63nuvrDY1aVKe4frrrzvy6af2KJV6dLqyQzJbtCjhscfy+fNPFUuWOFBUVHa9SRMtY8bkMmRIAXZ2etMnIUQlZKd4Dckuzmb49uGEJYSRmptqdC81N5WwhDCGbx9OdnF2tcS3trbG1dUVjUbDwIEDGTRoEDt37mTixImMGjXKaOyMGTMICwsDynaZHzhwgFWrVhl2m6ekpBjGxsTE0KtXL5588kk2b95cYfd5QkICPXv2xM/Pj3vuuYchQ4Zcd4f6sWPHaN26NYsXLzZcU6lUDBw4kJiYGMO1CxcucODAAQYOHHjDnP/66y86d+7MK6+8wg8//MCkSZPIzs425LFgwQIee+wxiouL2bJli9FzU1NT2b9/PxEREQB8+umnBAcH06RJE7p27Up8fPwNYwshhBBCCCGEEMJYdnE2F3IvVHrvQu6FaquJiKp76aVcJk/O5r33HHnppXpMnw7339+QTz8t2z2u0yno3LmIN9/MxMtLy5w5jmzYUJeiIgVt2xazfPk1vv/+EiNH5ktBXNQqUhSvIbnFuVwtuEpyTjLhCeGGwnhqbirhCeEk5yRzteAqucW5JlmPra0tJSU3P9QgMjKSwMBAhg8fztGjRzl69CgeHmU73fV6PTExMQwaNIimTZvi6+trVFy+ePEi48ePZ8iQIezdu5f4+Hj69u2LXl/xh2JiYiJDhgzh5ZdfZsKECUb3IiIi2Lx5MwUFBQDExsbSvXt3XFxcrrvuEydOMGDAAEJDQ3n33Xdp3749M2fOxMHBwZDHuHHjaNCgAX369CE2Ntbo+TExMTRs2JAePXqwfft23nzzTZ555hm++eYbHn/8cSZNmsT+/ftv+voJIYQQQgghhBCi5jcLiqopLc2mSZNL2NjoiImpw5w5kJ6uAvQEBuYwbdpFCgsVzJxZn5077dDrFfTuXcjGjVfYsuUK/foVYmVV01kIUVGtap+yc+dONm/eTGZmJo0bN2bkyJEVej6XO3HiBOvWrSM1NZWioiIaNmxIr169CA0NrXT8/v37Wbx4Me3atWPKlCnVmUaVeNh7EBcaZyiAhyeEs/jBxUzYM4HknGS8HbyJC42rtLXKnXb06FE2bdpEly5dbjrW0dERa2trbG1tcXV1Nbq3b98+CgoK6N69OwCDBg1iw4YNDBkyBIBLly6h1Wp5+OGHady4MUCl7+/OnTt58cUXmT9/PgMGDKhwv1WrVnh7e5OQkEBYWBhxcXG8+eabJCcnV7rmw4cPM2LECF544QXGjRsHlO2Ud3BwQKFQVMgjIiKCJ554guTkZLy9vdHr9cTGxhIeHo6VlRVLly5l8ODBjBw5EgA/Pz9+/vlnli5dSufOnW/6GgohhBBCCCGEEHe7f28WjO8fjzvuRpsFy8dVV2tZcWNXr+YyZcqf7NjxMKCocP/IEXuOHHEAwNpaz2OP5TN2bB7+/loTr1SIW1drdoonJiYSFRXFoEGDmD9/Pi1atGDu3LlcuXKl0vE2NjaEhIQwc+ZMFi5cyKBBg4iJiWH37t0Vxl6+fJm1a9det8BeUzT2GuJC4/B28CY5J5kBmwcYFcQ19rffI/t6du/ejb+/P76+vjzyyCN07NiR2bNn39acGzZs4JFHHkGlKvuuZcCAARw9epQzZ84A0LJlS7p06ULPnj155plnWLduHZmZmUZzHD16lDFjxrBo0aJKC+LlIiIiiImJ4cCBA+Tl5dGjR49Kx124cIGIiAgmTJhgKIjfzAMPPIC7u7uhRcsPP/xASkqKobh/5swZo37mAEFBQYY8hRBCCCGEEEIIcWPlmwXLayJhW8JITEkkbEuYyTcLCmPnzlnxxhuOdOzox44d/aisIF52TYFCoePZZ9P48ceLvPdelhTEhdmoNUXxhIQEevToQc+ePQ27xF1cXNi1a1el4318fOjSpQuenp64urrSrVs32rRpw/Hjx43G6XQ6PvjgAwYPHlxhR3BtoLHXsPjBxUbXFj+4uFoL4gDBwcHs2rWL77//nqSkJFauXImLiwtKpbJCOxOt9uY/0DIyMti5cyeffvopXl5eeHl5ERgYiFarNRSXraysiI6O5vPPP6dZs2asWbOGbt268ddffxnm8fb2pmnTpkRHR1NcXHzdeAMHDuTo0aO8//77hIWFGQrx/9agQQPuu+8+Nm/eTE5OTlVeGpRKJYMHDyYuLg6dTkdsbCwdO3bE19fXMEahMP4/BL1eX+GaEEIIIYQQQgghru/fmwU7r+5sss2CwpheD4cOWTN6tBNduriyerU9+fk373ui1yvp0UONq6vOBKsU4s6pFe1TtFotSUlJFXYGt27dmpMnT1ZpjrNnz3Ly5EnDQYjl4uPjcXR0pEePHhUK5v9WUlJi1FdboVBgZ2dn+Ht1SM1NZcIe457ZE/ZMqPYf/nXq1MHHx6fCdWdn5wqv+e+//45arTY8VqvV6HTGP+w2bdqEu7s7q1atMrr+ww8/8OGHH/Lqq6+iUqlQKBQEBQURFBTESy+9RPv27dm+fTvPP/88UFbEXrlyJWFhYTz77LMsXbrUKHY5JycnevfuzZYtW3j77bevm6etrS2fffYZTzzxBMOGDWPDhg04OTkBZS1USktLK33ekCFDWLx4Mdu2bWPbtm1GMZo2bcpPP/1EeHi44drhw4dp2rTpdddxO2722Su/X91FeUuLY8pYkpN5xLK0OKaOZSqWlpOl5QOSk7mQnMyD5FT7WVo+IDmZC0vKqbFDYz548AMe3fyo4doHD35AY4fGNbiqO8Mc3ietFrZutWX58rocPWptuN6jRyEODjq++qrOTee4dMmqVud4I+bwHt0qS8ypOtSKonh2djY6nY569eoZXa9Xr16F9hr/Nm7cOLKzsyktLSU8PJyePXsa7p04cYJvv/2Wd955p0rr2LRpE/Hx8YbHPj4+zJ8/n4YNG1Y6vqCgoNKCbVWl5qQSvrWsT5a3ozcf9fyI8d+MJzk7mfCt4Xz56JdoHO58YVypVKJQKCpde7du3fjkk0/YuHEjQUFBxMXFcfLkSe69917DeG9vb/7v//6PtLQ06tati5OTE9HR0fTv3597773XaD4fHx/mzp3L3r17cXV1Zd++fYZDMX/++WeuXbtmaGtTvi53d3c2btzIoEGDeP7551m+fDkqlcqwG7x8HR9++CHvvvsuDRo0AMp2ov8zr/L56tWrx/r16xk6dChPPPEE0dHR2Nvb06RJE/Ly8jhw4AD33HMPdnZ21KlT9sPez8+PLl268Oqrr6JWqxkwYIBh3ueff54xY8bQpk0bunXrxs6dO9m+fTvx8fEVXtPb+XxAWeHe3d29SmPd3NxuK1ZVWVocU8aSnMwjlqXFMXUsU7G0nCwtH5CczIXkZB4kp9rP0vIByclcWEJOKVkpvLTvJaNrL+17ib0j9uJZz7OGVnVn1cb3KSsLVq2CxYuh/Bf4bWxg2DDw9YXYWFu+/bZqc7Vs6UQVSxe1Vm18j26XJeZ0J9WKoni5yr7BuNm3GpGRkRQWFnLq1CnWr1+Pm5sbXbp0oaCggCVLljB27FgcHat2IMPAgQONDuosj3358uVKW4gUFxcb7Sy/FRdyLxCW8I8+Wf3KdobH9fvf4ZvZyQz4cgDxofF3vH+WTqdDr9dXuvauXbsyceJEIiMjKSoqYujQoYSFhXHixAnD+DFjxjBx4kS6dOlCYWEh27dv5/fff+edd96pMKeNjQ3dunXj888/Z9q0aSQmJrJs2TJyc3PRaDTMmDGDbt26VVhXgwYNiImJISwsjLFjx/LRRx8Z3oPyGCqVCgcHB8Pj0tJSo7z+OZ+NjQ1r165l2LBhDBs2jLVr19K2bVueeOIJxowZQ0ZGBpMmTeLll182rD0iIoJ9+/YxfPhw1Gq1Yd7evXszc+ZMPvroI6ZNm4anpyfvv/8+7du3r5D/f/18lCsuLiYtLe2GYxQKBW5ubqSnp1dofXMnWVocU8aSnMwjlqXFMXUsU7G0nCwtH5CczIXkZB4kp9rP0vIByclcWEpOqbmpf/cQd/Rmfdh6hsUPIykjia6ruhLfP96sW6jUxvfp/HkrVq6sw/r1dcjNLeuq7OxcyuDBBQDExdlx5UpZ2xQ7Ox2Fpfnoi+tQeQdmHar6aTRtquQmpYtaqza+R7fLEnOqKpVKdd3Nzf+m0NeCV0er1fL4448zadIk2rdvb7i+Zs0azp07x8yZM6s0zxdffMH333/P4sWLOXfuHFOmTEGp/PsfbXmqCoWCRYsWVfkbk8uXL1da3MzOzq5ywb3Cc4uzGb59OFcLrlZolVJ+0rKznTPr+q6r0VOW/1kMtoQ4pox1J+JU5TNWvrs+LS2t2gt5lhTHlLEkJ/OIZWlxTB3LVCwtJ0vLByQncyE5mQfJqfaztHxAcjIXlpDTvzcLxvePp51/Ow6fPmx02GZ1bBY0ldr0Pv38s5rly+3ZutUWna5sE6i/fwn9+xdw/rwVX31Vh6KisuseHlpGjcpj6NA83lr1EnHvb/jfLP8sjJe11Q2fNJSFk94321Ydtek9ulMsMaeqUqvVVS6K14qd4iqVCl9fX44dO2ZUFD927BhBQUFVnkev1xt2E3t4ePDee+8Z3Y+OjqawsNBwiGdNcrR2ZF3fdeQW51b44a6x1xAfGo+9tX2NFsSFEEIIIYQQQgghqoO9tT3Ods4ARpsFyw/fLN8saG9tX5PLNGulpbBzZ1m/8J9+sjFc79q1iI4di/jxR2vef//vulPbtsWMGZPLww8XolZDSckFxvaLpVW9Ej78cDGXL//dzqZhw/M8//xEOnfZhFb7Cmq1eX5xIe5etaIoDhAaGsqSJUvw9fWlWbNm7N69mytXrtC7d28A1q9fz7Vr1wwHMu7YsQMXFxc0mrIfmidOnGDLli307dsXKOvF7OXlZRSjbt26ABWu1xRHa8frFr3N9VtQIYQQQgghhBBCiJuRzYLVJy9PQUxMHVaurEtycvn5bHr69y/Ay0vL1q12vPtu2euqVOrp27eQMWNyadeuhH9u+FYo6qLUQ7dum+jc+St+/bUrV6+64+ycxr337sPKSoe+tGycEOam1hTFg4ODycnJ4YsvviAjIwNPT0+mTp1q2PKekZHBlStXDOP1ej0bNmzg0qVLKJVK3NzcGD58OL169aqpFIQQQgghhBBCCCFEFclmwTvrwgUla9bUZd26umRllbU6qV9fR1hYPgAbN9px7VodAOztdQwdms+oUXl4eZVWOp9KVQ+bDCXFLjqsrHTcd993FcbYZChRqepVU0bVQ5GdjSI3F51Hxc+Y8sIF9Pb26P9ju2RhPmpNURwgJCSEkJCQSu+NHz/e6HHfvn0Nu8Kr6t9zCCGEEEIIIYQQQghhzn79Vc3y5XXZvNkOrbZsq7ePj5bQ0LJ+4Z9+WpeSkrLrnp7l/cLzcXC4Sb9pvR7nn2xI61MAVpXcLwXnn2ygkx7MpKe4Ijsb5+HDUV69ypW4OPSNGxvuKVNTcQkPR+fszNV166QwbuFqVVFcCCGEEEIIIYQQQghxYzod7N5tw/Ll9hw48He/8I4di+jQoYiffrJhyRIHw/V27cr6hT/0UCGqqlYDFQq8NzqR1byAfC+MC+OlUOcv8N7oxLUJ5lEQB1Dk5qK8ehVVcjIu4eFcjY8Hd3eUqak4h4ejSk5G+79xUhS3bFIUF0IIIYQQQgghhBDCDBQUKIiLs2PFCnuSksrKeipVWV9wLy8t27fbsXhxWTHXykpPv35l/cLvv7/kP8XTdnuIti+s4dxIPVc7g04FSi0474cmUQqKIm6ti0NN03l4cCUuDpf/FcCdw8Jg/Xqchw0rK4h7e3MlLq7S1irCskhRXAghhBBCCCGEEEKIO6C0NBudLhe1umJRtaTkAkqlPVZWt74D+eJFJVFRdfnss7pkZpb1C3d01DFgQD4KBXz1VR0yM+0M14cPz+epp/LQaCrvF15VOa++is0PP9D0kzP4f6RDDygAvVKJ1t+fnClTbmv+mqDTaIwK43TujAr+LohrNDW9RGECUhQXQgghhBBCCCGEEOI2lZZmk5o6nNLSqzRuHIe19d/9qktKUjl/PhwrK2c0mnVVLoz/8YeKFSvs+fJLO4qLy9qUeHlpefjhQi5cULJ+fV1DH/EmTbQ8/XQegwfnY29/k37hVaS3t+fKli04vPMOtrt2odLp0CqVFPbpQ86UKejt7e9IHFPTaTRkLF5MwwEDDNcyFi+WgvhdRFnTCxB3l4kTJzJq1KgbjgkLC2PGjBn/OUaHDh1YsWLFf37+fxUTE0OLFi1MHlcIIYQQQgghhBA1T6fLpbT0KiUlyZw/H05JSSrwd0G8pCSZ0tKr6HS5N5xHr4c9e2yIiHCmd29XYmPrUFysIDCwmOeey8HdvZSlS+3ZvLkOWq2Cjh2LWLXqGt9/f4lRo/LuWEHcsB57e7IjI7n844+QksLlH38kOzLSbAviUHaoptOECUbXnCZMQJmaWkMrEqYmRfG70MSJE9FoNGg0Gry9venUqRORkZHk5+dX6fmVFa1TUlIMc2o0Gpo0aULnzp1ZtGgRev3fP4wjIyNZuHDhLa03LCwMjUbDhx9+WOHeE088gUajYcGCBVWeb8CAAUbrP3bsGBqNhkOHDlU6ftiwYYwcOfKW1iyEEEIIIYQQQoi7i1rtQePGcajV3pSUJJOSEkZWViIpKWGUlCSjVnv/737l/aoLC2HDhjr06NGQxx93Zt8+G5RKPX37FvDMM7lcvark448d+PFHG1QqPYMG5bN9+2W++OIqDz1UiJVVpdPeWQrzOVTzepSpqYbWKVpvb9i/H623t+HwTSmM3x2kfUoNUmRno8jNrbR5v/LCBfT29tV20u2DDz7I+++/T0lJCYcOHWLy5Mnk5+fz9ttv39a80dHRBAQEUFxczKFDh3jllVdo1KgRQ4cOBcDxP+bj4eFBTEwMzz//vOFaeno6+/fvp1GjRre15tatW9OyZUtiYmJo37690b3U1FT27dvHypUrbyuGEEIIIYQQQgghLJ9araFx4zjDzvCjRzv/73p5Qbxie44rV5R89lkdoqLqcvVqWWXb3l5H//4FKBSQkGBHdnbZvtb69XU8/ngeI0fm4e6uM11iFkJ54YJRQfxqfDyN2rXjanw8zmFhhsL4lfh4OWzTwslO8RqiyM7GefhwXMLCKnwDpUxNxSUsDOfhw1FkZ1dLfGtra1xdXdFoNAwcOJBBgwaxc+fOStubzJgxg7CwMKBsl/mBAwdYtWqVYVd4SkqKYayTkxOurq40btyYQYMGERgYyK+//mq4/+/58/PzefHFF2nSpAlt27Zl6dKlla63V69eZGRk8NNPPxmuxcbG0q1bN5ydnW+Ya0xMDM2bN+f7779n4sSJJCYmVlj/0KFD2bJlS4Xd8rGxsTg7O9OzZ08yMzN58cUXadmyJX5+fjz++OMkJSXd5JUWQgghhBBCCCHE3USt1uDmttjompvb4goF8dOnVUyZUo/27RuxYIEjV69a4eGhZdSoXLp2LSI2tg7r19clO1uJj4+WuXMz+emni0ydmiMF8f9Ib2+Pztm5wqGa5Ydvar290Tk7m3VrGFE1tWqn+M6dO9m8eTOZmZk0btyYkSNHXrdH84kTJ1i3bh2pqakUFRXRsGFDevXqRWhoqGHMjz/+yKZNm0hPT6e0tBQ3Nzf69+9Pt27dTJXSdSlyc1Fevfr3N1D/+4do9Csc/xtXXbvF/8nW1paSkpKbjouMjCQpKYnmzZszefJkAJydnblw4UKFsb/88gu//fYb4eHh151v1qxZJCYmEhUVRYMGDXj77bc5duwYLVu2NBqnVqsZNGgQMTExBAUFAWUF6+nTp9+wdcrSpUtZsmQJ69atIzAwkPvuu4+zZ88SEBBgtP6BAwcye/ZstmzZwpAhQwDQ6/XExcURHh6OSqXipZde4uzZs6xZswZ7e3vmzp3LE088wd69e1Gr1Td97YQQQgghhBBCCGH5SkpSSU837lednj6Bxo3jUKk0/PCDNcuX2/Ptt7aG+23aFBMUVMzRo9asXv13QbZz5yLGjMmlZ88ilLK19bbpHR25um6doXPDP5vB6DQarsTHV2vnBlF71JqieHlhdPTo0QQEBLB7927mzp3LwoULcXFxqTDexsaGkJAQvL29sbGx4cSJE6xYsQJbW1t69eoFgL29PYMGDcLDwwOVSsXPP//Mxx9/jKOjI/fdd5+JMzSm8/DgSlycoQDuEh5OxuLFOE2YYPgVjitxcSb5VY2jR4+yadMmunTpctOxjo6OWFtbY2tri6ura4X7jz76KEqlkpKSEkpKShg+fPh1i+J5eXlER0ezaNEiunfvTklJCYsWLaJdu3aVjo+IiGDgwIFERkZy7NgxcnJy6Nmz53WL4vPmzSMuLo74+HjDlyvXW7+TkxMhISHExsYaiuKJiYkkJyczZMgQkpKS2LVrF19++aWhKL9kyRKCgoLYsWMH/fv3v+lrJ4QQQgghhBBCCMv2zjt68vK+Z/jwsh7irVqt57ffhpGff4Enn7zC77/fx9WrZRvrFAo9vXoV0bixll27bFm5sqwYrlbrGTCggNGjc2nVSluT6VgkvaPjdYve0jLl7lFriuIJCQn06NGDnj17AjBy5Eh++eUXdu3axbBhwyqM9/HxwcfHx/DY1dWVQ4cOcfz4cUNR/J577jF6zsMPP8x3333HiRMnarwoDn//akZ5YbzhgAEAFX6Fozrs3r0bf39/SktLKSkpISQkhNmzZzN79uzbmveTTz7B398frVbL8ePHmTFjBvXr1+f111+vMPbcuXMUFxcbFcGdnJzw8/OrdO6WLVvi4+NDQkICiYmJPPbYY9fdob1s2TIKCgrYtm0b3t7eVVr70KFDGTp0KGfPnsXHx4fo6GiCgoJo2rQpu3btQqVScf/99xvGN2jQAD8/P86cOVOl+YUQQgghhBBCCGG5SkoukJf3HStXvoxOp6BPn3789lsz9uz5ic2b7SgoKCt629mV0q9fEUqlnm3b7MjNLdsx7uRUypNP5jNiRB6NGkl7FCGqU60oimu1WpKSkhjwv6JwudatW3Py5MkqzXH27FlOnjxJREREpff1ej2//fYbFy5cYPjw4be75DtGp9GQsXixoSAOkLF4cbUWxAGCg4OZN28earWaRo0aGYrLSqUSvV5vNFarrfq3kh4eHoYvK/z9/fnrr7949913mTRpEra2tkZj/x2nKiIiIvj00085deoUW7duve64Dh068M0337BlyxajwzlvpGvXrjRu3JjY2Fiee+45tm/fzpw5c2641v+SgxBCCCGEEEIIISyPUmnP00+vJ+lsU1avnsTq1eV3GgJgbV1Av34J5OSEsHGjAzpdWfMOf/8SxozJY9CgfOzsambtQtxtakVRPDs7G51OR7169Yyu16tXj8zMzBs+d9y4cWRnZ1NaWkp4eLhhp3m5/Px8xo4di1arRalU8vTTT9O6detK5ypv+VFOoVBg97+fRgqFotLn3C5laipOE4z7TDlNmFDtO8X/n707D2+ySh8+/s3aLU0pLaVtWgsVQVBR2UQKyiYIFtlaC60LOjguOOLu64zboIODG+IyOqMooC2UBEHAhYqCiDgqiuKCKIP21w2he9M1y/P+ERoaWqB0CU24P9flJTnPyTnnTgNN7pzcJzg42GOnfaOIiIhmH0T8+OOPHjuydTodTmfrPrHUaDTY7XZsNluzpHjv3r3R6XR8/fXX9OrVC4Dy8nL279/P8OHDWxxv2rRpPPbYY/Tv35++ffsec94LLriA66+/noyMDDQaDbfccssJ169SqUhLSyMrK4uYmBjUarW7LErj7vdvvvnGXT6ltLSU/fv3c9ZZZ7XqsWirEz33Gq931nPUX+fx5lwSk2/M5W/zeHsub/G3mPwtHpCYfIXE5Bskpq7P3+IBiclXSExdk1odxvK3NvLxR9EtXHXS0BDI2rVHSsxeemk9f/5zNZde2lgvvGvH7g8/o6NJTKevLpEUb9TSD+tEP8AFCxZQV1fHL7/8QlZWFtHR0R61sQMDA3nqqaeoq6vj+++/Z8WKFfTs2bNZaRWAtWvXYrFY3Ld79+7NokWL6NGjR4tz19bWtuuARXVBAd1SU9Hk5uJISKDypZcwzpvnKqWSmkr5unWdkhhXq9WoVKoW137JJZfw8ssv8/bbbzN06FDMZjN79+7lvPPOc/dPSEjg22+/paioiJCQEMLDw9FqXU+lqqoqSktLcTgc7Nmzh6VLlzJy5Ei6d+/ebO5u3bqRnp7OP/7xD3r06EGPHj144oknUKvVaDQa93wqlcp9u0ePHnz//fdotVqP62q1uln/iy++mJUrVzJr1iz0ej0333wzAGeccUaz9asPn1aRkZHB4sWLWbRoEdOnT3d/UNOvXz8uv/xy7r//fp566ikMBgOPP/44MTExJCcno9Pp3I/B0R8gtIderycmJqZVfaOjW/ql2/H8bR5vziUx+cZc/jaPt+fyFn+Lyd/iAYnJV0hMvkFi6vr8LR6QmHyFxNQ1WK2wYgU8/zwcu+BB4ymZCtdfr+Kuu+DccwOAAO8ssgP54s/oRCSm00+XSIobjUbUanWzXeEVFRXNdo8frfGwxDPOOIOKigrMZrNHUlytVrufBL169aKgoIB169a1mBSfPn06ycnJ7tuNCflDhw61WEKkoaHBY2f5yVAXFhKekoKm6aGaJhP1TWqMh02bRrHF0uFF/p1OJ4qitLj2UaNGcccdd7BgwQLq6+uZPXs2KSkp/Pzzz+7+N954I3fccQcjR46krq6O//73v+77p6SkAK4d4lFRUYwdO5b777/ffd+j5/7b3/5GVVUV1157LSEhIdx0001UVFS4a52Dq0RJ09vBwcEAHtedTmeL/QcNGsSKFSu45pprAPjTn/7Erbfeyrx58zzWHx8fD0DPnj0ZNWoUn3zyCampqR6P0TPPPMPDDz/M1VdfTUNDA8OHD2fFihXutTQ+Rxrvo9Pp2vz8aNTQ0EBRUdFx+6hUKqKjozlw4ECnlnPxt3m8OZfE5Btz+ds83p7LW/wtJn+LByQmXyEx+QaJqevzt3hAYvIVElPX8H//p+GNN4JZuTKYykr1ie8AgIorrighIqKBE7zd73J88Wd0IhKTf9Fqtcfc3NysbyevpVW0Wi2JiYns3r2bYcOGudt3797tLlXRGoqinLD+9bGSweBKYh5rZ29HP4kUgwFnRAR28CiV0vTwTWdEBIrB0KHzAjz33HPHvX7PPfdwzz33AC0nds8880w2bNjQ7H4FBQUnPXdISAgvvPCCxzxNS50AHrv3W/Lhhx963P7iiy88bg8fPpxff/31hOtvlJWV1WJ7t27deP755495v7S0NNLS0o671rZo7XNPURSv/GPnb/N4cy6JyTfm8rd5vD2Xt/hbTP4WD0hMvkJi8g0SU9fnb/GAxOQrJCbvUxT4/HM9S5eGkJMT6K4L3quXHZPJzmefBZ5gBDhwQNWlYzyRrv4zaguJ6fTTJZLiAMnJybzwwgskJibSt29fNm/eTHFxMZdddhngSlSWlpa6D0384IMPiIyMxHQ4mfzzzz+zYcMGJk2a5B5z7dq1nHnmmfTs2RO73c6uXbvYtm0bc+fO9X6AR1GMRkoyM1FZrc12gjtNJootFhSDAcVoPEUrFEIIIYQQQgghhBAAdXWwbl0QS5ca+OmnIxsqR4yop1cvO599FtCqhDhAVJSjs5YphGilLpMUHzFiBFVVVaxZs4aysjLi4+N54IEH3Fvey8rKKC4udvdXFIWVK1dy8OBBd4mUjIwMxo8f7+5TX1/Pa6+9RklJCXq9HpPJxF/+8hdGjBjh9fhaohiNx0x6d3TJFCGEEEIIIYQQQghxcoqK1KxYEcJbbwVTWqoBIDDQyWWX1aNWK3z4YSA7drjqghuNTmqqbdgdOo7UEG/KSXBQFcOHt6/UqhCi/bpMUhxg4sSJTJw4scVr8+bN87g9adIkj13hLZk1axazZs3qsPUJIYQQQgghhBBCCP/39dc6li4N4d13g7DbXSVSTCY7SUn15OVp2LAhyN23Xz8b119fzcwZNbx/393cvi4TcOKZGHcC8M+JN6NRPw2ovBaLEKK5LpUUF0IIIYQQQgghhBDiVGhogHffDWLp0hB27dK72wcPricx0c6XXwawenUIACqVwoQJddxwQzVJSQ2oDue4b/xhGzXzUngmewmHiuPdY/Tokc/dV93BjZu+oFQlCXEhTjVJigshhBBCCCGEEEKI01ZxsZq33gpmxYoQ/vjDVSJFr1cYO7YOrRY+/jiAr792lUgJC3Mye3YN111XzRlnNK8Nbr/kcu5a9gZTr32HjyNGcagyhh7GIsaWfMqZyxTqZ93g1diEEC2TpLgQQgghhBBCCCGEOO388IOWpUsNvPNOEPX1rt3bPXo4GDmynqIiNR984Fki5YYbqpkxo5bgYOWYY1bdfz8B27fT79/7ONv5CQquQimKWo39rL5U3XdfJ0clhGgNSYoLIYQQQgghhBBCCK9zOCpxOq3odLHNrtlshajVBjQaY4fOabdDTk4gS5eG8N//BrjbzzuvgT597Hz9tZ61a4MBV4mUiRPruP56zxIpx6MYDBRv2EDok08SmJOD1unErlZTN2ECVffdh2IwdGg8Qoi2kaS4EEIIIYQQQgghhPAqh6OSgoIMHI4S4uLM6PVx7ms2WwH5+aloNBGYTJkdkhgvL1excmUwy5aFkJ/vSodpNAqXXFJPYKDC1q0BfP+9q474iUqknIhiMFC5YAFVjz1GTHQ0hw4cQFGOvbtcCOF9khQXQgghhBBCCCGEEF7ldFpxOEqw2XLJz08lPt4CxLgT4jZbrrtfe5Liv/6qZenSECyWIGpr1QCEhztISqrn0CE1W7YEuvu2tkTKSZFDNYXoktSnegFCdKSLLrqIV1991evzZmdn079/f6/PK4QQQgghhBDi9FDZUEmhtbDFa4XWQiobKr28ovbR6WKJizOj0yVgs+WSl5dCRcUO8vJSsNly0ekSDl9vXlrlRJxO+OijANLTuzN6dBRvvhlCba2avn1tTJlSg8GgsHFjMF98EYharXD55bWsXl3MRx8d4uqrazouIS6E6LIkKX4auuOOOzCZTJhMJhISErj44otZsGABNTU1rbp/SkoKDz/8sEdbXl6ee0yTycSAAQOYMWMGn3/+ebvWmpKSgslk4sUXX2x27ZprrsFkMvHMM8+c1HgPPvig+/bu3bsxmUx8+eWXLfZPT09nzpw5J71uIYQQQgghhBCio1Q2VJLxfgYpG1MosBZ4XCuwFpCyMYWM9zN8MDFu8kiM79qVdFRC3HRS41mtKt54I5hLL43i2msj+OSTQFQqhZEj65kwoZa8PA0bNgSTl6clLMzJLbdY2bHjIEuXlrW6ZrgQwj9IUvwUcjgqsdla/pTXZivE4ei8X2Zjxoxh165d7Nixg/vuu4/ly5ezYMGCdo+7atUqdu3ahcViwWAwcM011/B///d/Lfa12WytGjM2Npbs7GyPtgMHDvDZZ5/Rs2fPdq134MCBDBgwoNn4AAUFBXz66afMnj27XXMIIYQQQgghhBDtYW2wUlJbQm5VLqkbU92J8QJrAakbU8mtyqWktgRrg/UUr/Tk6XQmoqOXeLRFRy85qYR4bq6GRx4xMmRITx58sBv792sxGp1MnFjLkCENbN8eQE6Oq3zK2WfbWLSonJ07/+DBByuJjz/5muFCdDWqykrUhS3nGNWFhagqfesDM2/oUknxTZs2MW/ePDIyMrj//vvZs2fPMfv+/PPPPPTQQ9xwww1kZGRwxx13sHHjRo8+mzdv5uGHH+b666/n+uuv57HHHmPfvn2dHUarNB4okZ+fgs3m+Smvq35WyuEDJzrnSavX64mKisJkMjF9+nRmzJjBpk2buOOOO7jhhhs8+j788MOkpKQArl3mn3/+OUuXLnXvCs/Ly3P3DQ8PJyoqigEDBrBo0SJqa2v55JNPADCZTKxYsYLrr7+ePn36sGSJ65deTk4Ol112GYmJiZx77rnMnTvXY/7x48dTVlbGV1995W5bvXo1l1xyCREREceNMzs7m7PPPptt27a51/6f//zHY+2zZ89mw4YNzXbKr169moiICMaNG0d5eTm33347AwYM4Mwzz+Tqq69m//79J/moCyGEEEIIIYQQJy/WEIs52UxCaAK5VbmkbEhhR94OUjakkFuVS0JoAuZkM7GGky81cqrZbAUcODDfo+3AgfnNciVHUxTYvl3P9deHk5QUxWuvGaiqUtOrl51Jk2oJC3OyaVMQX30V4FEiZfNmKZEi/IuqspKIjAwiU1JQF3j+vVEXFBCZkkJERoYkxo/SZZLiO3bsYNmyZcyYMYNFixbRv39/Fi5cSHFxcYv9AwICmDhxIn//+99ZvHgxM2bMIDs7m82bN7v7/PTTTyQlJfHII4/w+OOPExERweOPP05paam3wjqmow+UaPzHvumBEg5HCU6ndz7lDQwMbNXO7QULFjB48GAyMjLYtWsXu3btIja25V+6QUFBANjtdnfbM888w8SJE/noo4+YNWsWmzdvZu7cuYwfP55NmzaRnZ3NwIEDPcbR6XTun2+j1atXM2vWrOOu9ZVXXmHBggVkZmZyySWXuNd+zTXXeKx9+vTp2O12NmzY4L6voiiYzWZSU1PRarXceeed7N69mzfeeIP169ejKArXXHNNq3e7CyGEEEIIIYQQ7WEymDwS40mvJ3kkxE2Gkys10hU0zYHodAlceOFn7lIqTXMlTdXWQmZmMOPH9yAtLZKcnCAURcXQofWMHVvHgQNq3n8/iLw8Ld26SYkU4f9UVivqkhK0ublEpqa6E+PqggIiU1PR5uaiLilBZfW9b5J0pi6TFN+4cSNjx45l3LhxxMXFMWfOHCIjI8nJyWmxf+/evRk5ciTx8fFERUVxySWXcP7553vsLr/99tuZOHEivXr1wmQycfPNN6MoCt9//723wjqmow+UyM9Ppbb2K49fBm09UOJk7dq1i7Vr1zJy5MgT9jUajej1egIDA4mKiiIqKgqNRtOsX01NDU888QQajYbhw4e726dNm8asWbNISEggLi6O559/nqlTp3L//fdz1llncc4553D77bc3G2/WrFnu3dz//e9/qaqqYty4ccdc5xNPPMF//vMfLBYLgwcP9lh7UFCQx9rDw8OZOHEiq1evdt9/x44d5ObmkpaWxv79+8nJyeGpp57ioosu4pxzzuGFF17gwIEDfPDBByd8zIQQQgghhBBCiI5gMphYMsaz1MiSMUt8NCFe6JEDiY+3EBY2gvh4y1GJcVdJiMJCNU88EcqQIdHcd183fv5ZR3Cwk7Fj6xg8uIGvvgrg448DqatzlUh58kkpkSJOD87YWIrNZuwJCWhzc4lISYEdO4hISUGbm4s9IYFisxnnMTa1nq60p3oB4NpJvH//fqZNm+bRPnDgQPbu3duqMX777Tf27t173N3D9fX12O12DAZDi9dtNpvHzl+VSuXe7azqhI8SGw+UaPwlkJc37XB72w6UOBmbN2/mrLPOwuFwYLPZmDhxIo8//jiPP/54u8adOnUqarWa2tpaevbsyeLFi+nfv7/7+vnnn+/R/8cffyQjI+OE4w4YMIDevXuzceNGduzYwcyZM9HpdC32/fe//01tbS3vvfceCQkJrVr37NmzmT17Nr/99hu9e/dm1apVDB06lD59+pCTk4NWq2XQoEHu/t27d+fMM8/0SjmeEz33Gq93xnPUn+fx5lwSk2/M5W/zeHsub/G3mPwtHpCYfIXE5Bskpq7P3+IBiamrK7AWMH+LZ6mR+VvmY5li8bnEuEYTyhtv/BWVqoqHHroUvT4OAL0+jvh4C4899glOZyhTpvTg9dfDee+9QBwO18/QZLIzYICdPXu0fPxxIABqtcLEifXccEM1I0Y03RF+6n7u/vTcA/+LB/wnJiUujhKLxZ0IJykJLWBPSKDEYkExmU7h34SuqUskxSsrK3E6nYSFhXm0h4WFUV5eftz73nzzzVRWVuJwOEhNTT3u7uHMzEy6d+/Oeeed1+L1tWvXYrFY3Ld79+7NokWL6NGjR4v9a2trj5mYbS2drhdxcS/x22/J7ra4uJcIDu7VrnGPR61Wk5SUxJNPPolOpyM6Otodh1arRaVSecTldDo92lQqFRqNxqOPVut6Kr366qv07duXsLAwunfv3mzu0NBQj/sFBQW5d5q39Fg2nSs9PZ0VK1awd+9eNm3ahE6nQ6VSoVarPdZ28cUX8+GHH/Lee+8123Xe+I/c0XONHTuW+Ph41qxZw2233cYHH3zAE088gU6nQ61Wu+9z9K74xrU1xn/0uO19fuj1emJiYlrVNzo6ul1ztZa/zePNuSQm35jL3+bx9lze4m8x+Vs8IDH5ConJN0hMXZ+/xQMSU1eUV5FHmjmN3KpcEsMTeXP6m1yz9hr2l+0n7f00tl63lfiw+FO9zJMQQ3x8Ao8+GsgZZ8BDD7lao6OjeeSRaF57bQgxMQ5ef/3I+/ChQ6F7d9i2TcuHH7reh4eHw9y5cOutKnr1CgQCT0Esx+frz72j+Vs84CcxxcRAVhYkJbmbtFlZ9Bwy5BQuquvqEknxRi19KnOiT2oWLFhAXV0dv/zyC1lZWURHR7dYBuSdd97hs88+49FHH0Wv17c41vTp00lOPpKcbpz70KFDHnWxGzU0NLS7prSrftY8j7b8/HmdulPc6XQSFBREfPyRX5aNcYSHh7Nnzx73bZ1Ox/fff49Op3O3abXaZrvqGx+fqKgo4uLiPMZsqnFneqOzzz6bTz75hNmzZ7fYX1EU932uvPJK/v73v9O/f38SExOx2WwoioLT6XTfV1EUBg4cyHXXXefegX7LLbe4x9Nqtc3W0Oiqq64iKyuLqKgoVCoVkydPxmazkZiYiN1u54svvmDo0KEAlJaW8r///c+9jsb4m47b9DFrq4aGBoqKio7bR6VSER0dzYEDB1CUzjsoxN/m8eZcEpNvzOVv83h7Lm/xt5j8LR6QmHyFxOQbJKauz9/iAYmpqyq0FjJzw0x3DfHVk1czOH4wqyevZub6mewv28+opaNYM2WNTx22+ec/Q3W1gYcfDuWnn2q45JIg/vUvGz/84MrbFBVpCAhQGDasgaoqFV99dSSfc/bZNv70p2qmT68lOJjD/U9FFMfmD8+9pvwtHvCvmNQFBUSkp3ske+3p6ZRYLDhNvvVNkrbSarXH3NzcrG8nr6VVjEYjarW62a7wioqKZrvHjxYVFQXAGWecQUVFBWazuVlSfP369axdu5aHHnrouOU0dDrdMXf2dsZfjKMPlIiOXnL4hGVX3azOLqHSkqSkJF5++WXMZjODBw9m3bp17N27l3PPPdfdJz4+nl27dpGXl0dISAjdunVr83x33XUXaWlp9O7dmylTpmC329myZQu33nprs77dunXjm2++adXu6yFDhvDWW2+RkZGBRqPhz3/+s3vt33zzjcfaG3eCp6WlsXjxYhYtWsTUqVMJPvxbNTExkYkTJ3LfffexaNEiQkJCeOKJJ4iOjmbixIltjr21WvvcUxTFK/+A+9s83pxLYvKNufxtHm/P5S3+FpO/xQMSk6+QmHyDxNT1+Vs8IDF1NSG6ECKCIgAwJ5uJDXElvmNDYjEnm0ndmEpEUAQhuhCfi/GMxCo0ATpWrQpm1SoAV+LbaHQwaJCNX3/V8umnAUBjiZQ6brihmosvPlIipauH7MvPvZb4Wzzg+zGpCwqIOHyopj0hAW1WFvb0dHeN8WKz+bRJjLdWlzhoU6vVkpiYyO7duz3ad+/eTb9+/Vo9jqIozXZ0r1+/njVr1vDXv/6VM888s0PW2xGOPlAiLs5MUNDQZodvNh4o4S2jR4/mjjvu4B//+AdXXHEFVquVlJQUjz433XQTarWa0aNHc95551FQ0Pw06NYaMWIE//73v9m0aRMTJkzgqquuYteuXcfsHxYW5k5Wn8jQoUNZsWIFTz31FEuXLj3h2k0mE6NGjaK8vJy0tDSPsZ599lnOO+88rrvuOq688koUReHNN99sd3kUIYQQQgghhBDiRIx6I5mTMrEkN68dbjKYsCRbyJyUiVFvPEUrPHl1dXD/A0H85ZYYHPVHlzxRqKxUs3VrIAUFWrp1c3LrrVV8/vlBXnut7Kia4UKc3tSFhUQ2SYiXWCwwYgQlFov78M3I1FTUhd7NMXZ1J7VTfN68ea0uPK9SqXjhhRdaPXZycjIvvPACiYmJ9O3bl82bN1NcXMxll10GQFZWFqWlpdx2220AfPDBB0RGRmI6/CnHzz//zIYNG5g0aZJ7zHfeeYfs7Gxuv/12oqKi3DvRAwMDCQw8tTWm1GoDGo3rU96mO8KbHr6p0USgVrd8KGh7PPfcc8e9fs8993DPPfccXk/zEiBnnnkmGzZsaHa/EyXHj3V98uTJTJ06tcVSI01rvLfkww8/9Lj9xRdfeNwePnw4v/76q/v2mWeeyfvvv3/MsiZZWVkttnfr1o3nn3/+mOtIS0trlkgXQgghhBBCCCE6ilFvPGbS25dKpuTlaXjzzWCysoIpK9Mco9fhww81dp74h5WUlFqCgnx3F68QnUkxGHBGRGAHis1mlMO5UqfJRLHZTGRqKs6ICBRDx+cYfdlJJcUHDBjQaaexjhgxgqqqKtasWUNZWRnx8fE88MAD7jowZWVlFBcXu/srisLKlSs5ePAgarWa6OhoMjIyGD9+vLtPTk4OdrudZ5991mOulJQUrrrqqk6Jo7U0GiMmUyZOpxWdzvOXlysxbjmcOPedT3mFEEIIIYQQQgghjuZ0wrZtASxbFsLmzQEoSutyS4pDy5ln2iUhLsRxKEYjJZmZqKxWnLGxNP3b5TSZKLZYUAwGFKPkGJs66Z3inWnixInHrNF89NyTJk3y2BXekpdeeqnD1tYZNBrjMZPeRyfKhRBCCCGEEEIIIXxJebmK1auDWbEihN9+O5KCGjiwgepqFf/734lLkv7xR5eo/CtEl6YYjcdMejtjJcfYki5x0KYQQgghhBBCCCGE8A8//qhl+fIQ3n47iNpaV1LbYHBy3nk2DhxQs3u3vtVj9ezp7KxlCiFOY+1KilutVjZu3MgPP/xAVVUVRqOR8847j8mTJ2OQOjVCCCGEEEIIIYQQp4WGBnj//UDeeCOEr74KcLf36mWnZ08H33+v4/PPXe2BgU6mTq0l5wMrZRU9gJZ2gzuJishn2DANIKdqCiE6VpuT4qWlpTz00EMUFxdjMpmIjIykrKyMNWvW8Mknn/DYY4/RvXv3jlyrEEIIIYQQQgghhOhCiorUvPVWCJmZwRw65Do4U6tVGDiwgdpaFXv26Pn9d1f66cwzbVx7bQ2pqTWEGZ0sN83nr8+uBpx4JsZdu8PvuO4utJol3g1ICHFaaHNSPCsri4aGBv7xj3/Qp08fd/u+fftYtGgRK1eu7PQa5EIIIYQQQgghhBDCuxQFduzQs2xZCJs2BeJwuHZyR0Y6SEy08+uvWr75xrUrXKNRmDixjuuuqyYpqQGVe9O3ihn6D7A9ksKL/1rCoUPx7vF79MjntlvvYEZ9Dk3uIIQQHabNSfHvvvuOtLQ0j4Q4QJ8+fUhLSyM7O7vdi/MFTqcTtVoOfRAdT1HkdG0hhBBCCCGEEF2H1arCYgli+fIQfvnlyCGZZ59tQ69X+P57HcXFrmR4dLSDjIxqZs+uISam5brg0aUzuHz4myS99Q7f/zSKkpIYIiKKOG/Ap4QWOIn+4hqqvRKZEOJ00+akeE1NDVFRUS1ei4qKoqamps2L8hXBwcFUVVURGhoqiXHR4WpqaggICDhxRyGEEEIIIYQQohP9+quWZctCsFiCsFpd+Y+gICf9+9s4cEDDzz8fSZAnJdVz3XXVTJhQh053rBFdau5+kPNSPifv0n2EjPgEpwnUdui+AeK3nUW5+cHODEsIcRprc1I8KiqKb775hoEDBza7tmvXrmMmzP2JVqslJCQEq9V6qpfSafR6PQ0NDX4zjzfnas88iqKg1WolKS6EEEIIIYQQ4pSw2yEnJ5Bly0L47LMj701NJjs9ejj56Sedu0SK0egkNbWGa6+toU8fe6vnUAwGyi3vEvvkkyTen4PG6cCh1lA3YQLl5vtQDIYOj6uzqSorUVmtOGNjm11TFxaiGAwoRuMpWJkQoqk2J8VHjx5NVlYWTqeT0aNH061bN8rLy9m2bRsffPAB6enpHbnOLkur1WL003/MVCoVMTExFBUVdWopD2/N4825vBmTEEIIIYQQQgjRUQ4dUpOZGcxbb4VQVOQ6OFOtVujf3051Nfz+u46CAlffc89t4Lrrapg2rZbg4La991UMBioXLKDqsceIiY7m0IEDPvs+WlVZSURGBuqSEorNZpS4OPc1dUEBkampOCMiKMnMlMS4EKdYm5PiV155JX/88QebNm1i06ZNHtfGjRvHlVdeedJjbtq0ifXr11NeXk5cXBxz5syhf//+Lfb9+eefyczMpKCggPr6enr06MH48eNJTk5298nLyyM7O5vffvuNQ4cOcd1113HFFVec9LqEEEIIIYQQQggh/JWiwM6dOpYvD2HjxiBsNtfhlmFhTnr1svO//2n58UdXLZSAAIUpU2q57rpqLrzQ1rHnYPr4oZoqqxV1SQna3FwiU1MpsVggJgZ1QQERqaloc3OxH+4nSXEhTq02J8VVKhV//vOfSU5O5ocffsBqtWIwGDj33HOJbeErIieyY8cOli1bxty5c+nXrx+bN29m4cKFLF68mMjIyGb9AwICmDhxIgkJCQQEBPDzzz/z6quvEhgYyPjx4wGor6+nZ8+eXHzxxSxfvrytoQohhBBCCCGEEEL4ndpaFWvXBrFsWYg76Q3Qu7cdnU7hl190fPedHoCEBDvXXFNNWlot3bu3fHDm6c4ZG0ux2Uzk4QR4REoKZGURkZ7uSognJFBsNrdYWqWrknIwwl+1OSnudDpRq9XExsa2KQl+tI0bNzJ27FjGjRsHwJw5c/juu+/IyclpsRRL79696d27t/t2VFQUX375JXv27HEnxfv06UOfPn0AyMrKavcahRBCCCGEEEIIIU4Fh6MSp9OKTtc8B2OzFaJWG9BoWpec/O03DStWhJCdHUxFhevgzIAAhT59XAdn/vabK12kViuMG+c6OPPSS+tRqzsuHn/lNJk8EuMkJaGFIwlxk+lUL7HVpByM8GdtTorffPPNXHLJJYwePZq4Jn8p2sJut7N//36mTZvm0T5w4ED27t3bqjF+++039u7dy6xZs9q8DpvNhs1mc99WqVQEBQW5/3y6aYy5s2P31jzenEti6vrzeHMuick35vK3ebw9l7f4W0z+Fg9ITL5CYvINElPX52/xgMTUVTkclRQUXI3DUUx8vAW93pWHUalU2GwF5OenoNFEEheXeczEuMMBH38cwLJlwWzZEuhuj4py0L27k19+0fLjj65d4ZGRDtLTa7n66hri4hyHe/rP6+TOpsTFUf7880ROnepuK3/+eZS4uE5+FDuWurraoxxM6Zo1EBODprCQ7k3Kwairq3GGhZ3q5baJPz3vGvljTJ1BpbTx9ILFixezc+dO7HY7ffr0YcyYMYwYMYLg4OCTHqu0tJSbb76Zxx57jH79+rnb3377bT755BOWLFlyzPvefPPNVFZW4nA4SE1NJSUlpcV+8+bNY/LkycetKb569WosFov7du/evVm0aNFJxyOEEEIIIYQQQgjRUerq8vn220upq9tPYGAiF1ywlcDAeOrq8vj229FN2j8hMNBz42JJCbz+Orz8Mvz2m6tNpYKzz4aqKsjPP9J31Ci49VaYMQP0ei8G6G/y8mD0aNi//0hbYiJs3Qrx8adqVW3TNJbERHjzTbjmmiO3fTEmIWjHTvE777yTmpoatm/fztatW3n11VdZvnw5w4YNY/To0Zx33nknPWZLn2Cc6FONBQsWUFdXxy+//EJWVhbR0dGMHDnypOcGmD59usdBnY1zHzp0CLvd3qYxfZlKpSI6OpoDnXzys7fm8eZcElPXn8ebc0lMvjGXv83j7bm8xd9i8rd4QGLyFRKTb5CYuj5/iwckpq5LQ2xsNnl5KdTV7efrr0dxzjmZ/PhjBjZbLjpdArGx2ZSVaYAiAL77TscbbwSzfn0QdXWu/IbB4CQuzsFvv2nYs8dVCyUkxElKSi3XXltD//6u3EdJifcj9I+fk6usSERKiruGuDYrC3t6Otr9+7GPGkWJxeJTJVTQalFnZ7ti2r8fkpIAVzmYkuxsnFotFBWd4kW2nb8875ryx5haS6vV0qNHj9b1bc9EwcHBTJgwgQkTJpCfn8+WLVvYvn0727dvJzIykpdeeqlV4xiNRtRqNeXl5R7tFRUVhJ3g6xdRUVEAnHHGGVRUVGA2m9ucFNfpdOh0uhavnW5PoqYURfFK/N6ax5tzSUxdfx5vziUx+cZc/jaPt+fyFn+Lyd/iAYnJV0hMvkFi6vr8LR6QmLoirTaW7j2Xsy93CqHk8u23rtxHlSOUPnHL0Wpjqa1V2LjRdXDmrl1HtnrHxdlRq+H//k/Lzz+7kuFnn23j2murmTmzFoPB9bh0hYfHl39O6sJCj4R4icVCzyFDKLFY3O0RKSkUWyw+ddimIzaWsiVL6NGk7HHZkiU4YmO7xpOmA/jy8+5Y/DGmjtSupHhTcXFxXH311QwYMIDXXnuN4uLi1i9CqyUxMZHdu3czbNgwd/vu3bsZOnRoq8dRFOW03NEthBBCCCGEEEII//bEkwGs/PVbYsZbeeHCI+1/3W0l//H/kWgdxu/79ZSWagDQahV697Zz4ICa/HxX+kenU7jiCteu8GHDGpCSwx1LMRhwRkRgB9fBlId3hDc9fNMZEYFiMJzahZ4kdUEB4fPne7SFz5/vcweHCtFUhyTFi4qK2Lp1K9u2baO0tJTu3bszffr0kxojOTmZF154gcTERPr27cvmzZspLi7msssuAyArK4vS0lJuu+02AD744AMiIyMxHf7L9/PPP7NhwwYmTZrkHtNut5N/uDiW3W6ntLSU33//ncDAQKKjozsidCGEEEIIIYQQQohOt+PANkrem8+l4SV8q9pGcXEsxcWxlLw7l/L8s/nmcL/wcAfh4U7279fy66+ub8ObTHauvrqG2bNr6NHDeeqC8HOK0UhJZiYqqxVnbKzHoZpOk4liiwXFYEAxtnwYalekLiggsvFQzablYA4fvimJceGr2pwUr6urY8eOHWzdupW9e/ei1WoZOnQoo0eP5vzzzz/pE05HjBhBVVUVa9asoaysjPj4eB544AF3HZiysjKP3eeKorBy5UoOHjyIWq0mOjqajIwMxo8f7+5TWlrKfffd5769YcMGNmzYwIABA3j00UfbGroQQgghhBBCCCGEV9lH3MrFRXW8nbmAtzObX9dH/kaocgYlJZrDtcVhzJg6rr22mnHj6tFovLzg05RiNB4z6e1LJVPAVQ6maUK8pXIwkampPlcORghoR1L8xhtvpKGhgd69e3P99dczatQoQkJC2rWYiRMnMnHixBavzZs3z+P2pEmTPHaFtyQqKorVq1e3a01CCCGEEEIIIYQQp1J9fQEDdl3Pqm2zAAU89iC7agY3FPemBOjWzcmsWTVcfXU1vXs7TsFqhb/w13IwQkA7kuLjxo1j7NixnHHGGR25HiGEEEIIIYQQQggBVFaqePvtIFasOI+9e4915porQa7V1vPPf5YwbRoEBXltie2iqqx0lxo5mrqw0OdKjfgbfywHI0SjNifF58yZ0+q+TqeT22+/nfvvv5/4+Pi2TimEEEIIIYQQQgjh9777TsdbbwWzdm0QtbXqVt3Hbg8gIUFPUFBDJ6+uY6gqK4nIyEBdUuLahRwX577WWMfaGRFBSWamJF1PIX8qByNEUx1y0GZrHDp0CJvN5q3phBBCCCGEEEIIIXxGdbWKdeuCePPNYL7/Xu9u79HDQX09VFaeuCj4H3+0LoHeFaisVtQlJe661CUWC8TEoC4oIKKxjvXhfpIUF0J0NK8lxYVoqrKhEmuDlVhD808VC62FGPQGjHr5pSeEEEIIIYQQwr/98IOWt94KYe3aIKxWV1Jbq1WIiXHwxx8aDh1q/QmZPXs6O2uZHc4ZG+uuS63NzSUiJQWysohIT3cf7FhsNstuZCFEp/CdjxCF36hsqCTj/QxSNqZQYC3wuFZgLSBlYwoZ72dQ2VB5ilYohBBCCCGEEEJ0ntpaFdnZQSQnRzJxYhRvvhmC1aqme3cHkZEO7HYVeXlaGhpU9O9vY8GCcoJ1VcCxkt5OQvQVXHSRb5ROadR4YKM9IQFtbi4kJXkmxA8f7CiEEB1NkuLC66wNVkpqS8ityiV1Y6o7MV5gLSB1Yyq5VbmU1JZgbbCe4pUKIYQQQgghhBAdZ+9eLQ89ZGTQoJ7cdVc4u3bp0WgUTCY7Op1CaamG4mINQUFOZs2qZsOGQ3z44SH+dEM1S7vdfniUoxPjrtuvhd2BRq14NZ6O4DSZKFuyxKOtbMkSSYgLITqVJMWF18UaYjEnm0kITSC3KpeUDSnsyNtByoYUcqtySQhNwJxsbrG0ihBCCCGEEEII4Uvq6mDNmiCmT49g7NgoXn/dQGWlmm7dnHTv7sDhUFFQoMVmU3HOOTaeeKKcXbv+4JlnKhg0yIZKBahUpARsZrU+hegQz29cxxjyWa1PISVgM67OvkVdUED4/PkebeHz56MuKDjGPYQQov2kprg4JUwGE+Zks3tneNLrSQDuhLjJIJ8ICyGEEEIIIYTwXfv2acjMDGH16mDKy117EtVqhagoJ4cOqd1tISFOpk2rJSOjhoEDbcfMa9dNmEDKsmXMaHiHTxlFITHEUsQo66eo1VA98XpvhdZh1AUF7pri9oQEtFlZ2A/XFI9MTZUSKkKITtOlkuKbNm1i/fr1lJeXExcXx5w5c+jfv3+LfX/++WcyMzMpKCigvr6eHj16MH78eJKTkz36/fe//yU7O5s//viDnj17Mnv2bIYNG+aNcMQJmAwmloxZwrT109xtS8YskYS4EEIIIYQQQgifVF8PH3wQyJtvhvD55wHudqPRiVqtUF6u4cAB18GZF1zQQHp6DVOn1mIwnLjsSdX99xOwfTvaffsY7fzE3a6o1djPOouq++7r+IA6kbqw0CMhXmKx0HPIEEosFiJSUo4kxi0WOWxTCNHhvJYUHzBgAEFBQce8vmPHDpYtW8bcuXPp168fmzdvZuHChSxevJjIyMhm/QMCApg4cSIJCQkEBATw888/8+qrrxIYGMj48eMB+OWXX3juuedIS0tj2LBhfPnllyxevJgFCxZw1llndVqsonUKrAXM3+L5Fan5W+bLTnEhhBBCCCGEED7l9981ZGYGk50dTEmJK+mtUin06OGkuFhNZaVrV3hoqJMZM2pJT6/m3HPtJzWHYjBQvGEDoU8+SWBODlqnE7taTd2ECVTddx+KwdDhcXUmxWDAGRGBHSg2m1EO7whvPHwzMjUVZ0SEz8UlhPAN7U6Kl5SUsGfPHqqqqggNDaV///5ERER49FGr1TzyyCPHHWfjxo2MHTuWcePGATBnzhy+++47cnJySE9Pb9a/d+/e9O7d2307KiqKL7/8kj179riT4u+++y4DBw5k+vTpAEyfPp2ffvqJd999lzvuuKM9YYt2anqoZkJoAlmpWaSb092Hb0piXAghhBBCCCFEV2azQU5OIG+9Fcy2bYHudoPBiVoNlZVqDh50JcgHD24gI6OaKVPqCA5u+2GYisFA5YIFVD32GDHR0Rw6cABF8b3DNQEUo5GSzExUVivO2FiaVo1xmkwUWywoBgOK0XjK1iiE8F9tToo7nU6WLVvGhx9+iNN55ORjtVrNZZddxpw5c1CrW3eOp91uZ//+/UybNs2jfeDAgezdu7dVY/z222/s3buXWbNmudt++eUXrrjiCo9+559/Pu+9916LY9hsNmw2m/u2SqVy725X+eBhFe3VGHNHx15oLfRIiK+5cg2D4wez5so1zFw/050YXzNlTYcfttlZMZ2qebw5l7/N4825JCbfmMvf5vH2XN7ibzH5WzwgMfkKick3SExdn7/FAxJTa+Tna8jMDGLlymB30lulUoiIcFJaqsZqdeVCwsKcpKS4aoWffXbTXeHtX4dKpQKVyvd/TmFhKGFhuM4S9fw5Ne4c9+UI/e3vk7/FAxLT6azNSXGz2cymTZsYN24cI0eOpFu3bpSXl/Ppp5+yadMmQkJCSEtLa9VYlZWVOJ1OwsLCPNrDwsIoLy8/7n1vvvlmKisrcTgcpKamuneaA5SXl9OtWzeP/o3rbMnatWuxWCzu271792bRokX06NGjVXH4q+jo6A4dL7gumJiwGDRaDVuv20p8WDwAg/sM5tM/fcro5aOJComiT3wfwgLDjj9YG3V0TKd6Hm/O5W/zeHMuick35vK3ebw9l7f4W0z+Fg9ITL5CYvINElPX52/xgMR0NLsd3nsP/v1veP99aNycHRICajVUVakoLnYlyEeNghtvhJQUNUFBIUBIB6y+ZfJz8g3+FpO/xQMS0+mozUnxLVu2MGnSJObMmeNui42NZcCAAQQEBLBly5ZWJ8UbtfQJxok+1ViwYAF1dXX88ssvZGVlER0dzciRI4/ZX1GUY445ffp0j4M6G/sdOnQIu/3kan35A5VKRXR0NAc64etYy8Yvw9pgRVuj5UDtAfc8WkXL6kmrMegN1JTVUENNh87bmTGdinm8OZe/zePNuSQm35jL3+bx9lze4m8x+Vs8IDH5ConJN0hMXZ+/xQP+E1NlQyXWBiuxhthmMRVaCzHoDRj1Jy7LUVioZuXKYLKygikq0rjbu3d3UFamprralTcID3eSmlpDRkYtZ53lyh+Ul7v+6wz+8nNqSmLq+vwtHpCY/I1Wq2315uY2J8WtViuDBg1q8dqgQYPYvHlzq8cyGo2o1epmO7grKiqa7R4/WlRUFABnnHEGFRUVmM1md1K8pV3hxxtTp9Oh0+lavHa6PYmaUhSlw+MP1YUSqgv1GLdxnpiQGPftztIZMZ3Kebw5l7/N4825JCbfmMvf5vH2XN7ibzH5WzwgMfkKick3SExdn7/FA74dU2VDJRnvZ1BSW4I52UxcaBzgiim/Kp/UjalEBEWQOSmzxcS4wwGffBLAm28Gs3lzIE6nK/EdFOSqFV5draa01JUgv/jieq6+uobLL68l8HBZcW8+bL78czoWianr87d4QGI6HbWu6HcLEhISKCoqavFaYWEh8fHxrR5Lq9WSmJjI7t27Pdp3795Nv379Wj2OoigeO7r79u3L999/32zMvn37tnpMIYQQQgghhBBC+A5rg5WS2hL3eVUF1gIACqwF7vOtSmpLsDZYPe73xx9qliwxMGJEFNdcE0FOThBOp4qwMCegUFurprpaTUSEg1tusbJt2x9YLCVMm3YkIS6EEMI3tDkpfs0117Bu3Tq++eYbj/adO3fyzjvvcO21157UeMnJyXz00Ud8/PHH5Ofns2zZMoqLi7nssssAyMrK4sUXX3T3/+CDD9i5cydFRUUUFRWxZcsWNmzYwKhRo9x9Jk+ezHfffce6desoKChg3bp1fP/9980O3xRHVDZUUmgtbPFaobWQyoZKL69ICCGEEEIIIYRovVhDLOZkMwmhCeRW5ZKyIYUdeTtI2ZBCblUuCaEJmJPNxBpicTph27YAbrwxnGHDevLkk0by87UEBCgEBTkBqKhQAypGjarnlVdK2bnzDx58sJIzz3R4NS5VZSXqwpbfr6sLC1FVyvt1IYRorTaXT3n11VdpaGhg0aJFBAUFERYWRkVFBbW1tYSGhrJ06VJ3X5VKxVNPPXXc8UaMGEFVVRVr1qyhrKyM+Ph4HnjgAXcdmLKyMoqLi939FUVh5cqVHDx4ELVaTXR0NBkZGYwfP97dp1+/ftxxxx2sWrWK7OxsoqOjueOOOzjrrLPaGrZfO9ZXzODIJ+rH+4qZEEIIIYQQQgjRFaz699lcbt/OBwkjya3KJen1JAASQhO4PHc7ry/uRkSEk8zMYH7//UhqJDTUSVWVmvp6FaCiRw8HaWk1zJ5dQ69e3k2CN6WqrCQiIwN1SQnFZjNK3JH36+qCAiJTU3FGRFCSmYlilPfrQghxIm1OioeGhmI86h/a7t27t2sxEydOZOLEiS1emzdvnsftSZMmMWnSpBOOOXz4cIYPH96udZ0ujv6KmWWKhRhiPL5i1thPkuJCCCGEEEIIIboqtVrh38/Hcdb0f4DxVbDGQEgRjv1/49/b41CrFXetcL1eQaVSqK9XU1WlRqVSGD26noyMGsaPr+MYR495lcpqRV1SgjY3l8jUVEosFoiJQV1QQERqKtrcXOyH+0lSXAghTqzNSfFHH320A5chuoLGr5g1JsBTNqSQlZpF+ob0Zl8xE0IIIYQQQgghuqob5x3g3x9t4de1GUCGuz3/8P+dThUhIU6qq9U0NLh2hUdHO5g1q4ZZs2qIjz91u8Jb4oyNpdhsJvJwAjwiJQWysohIT3clxBMSKDabccbK+3UhhGiNNifFhX8yGUweifGmXzEzJ5sxGUyneIVCCCGEEEIIIcTx/XnJGqp23Q8ogKrJFeXw/1VUV6tRqxXGjq0nI6OasWPr0XbhLInTZPJIjJOUhBaOJMRN8n5dCCFaq93/3Ofl5XHo0CFsNluzaxdddFF7hxengMlgYsmYJUxbP83dtmTMEkmICyGEEEIIIYTo0goK1PxneS2fvnwvoG6hhytBrlLb+dPNedx0fRCxsU6vrrE9nCYTZUuW0GPaNHdb2ZIlkhAXQoiT1Oak+IEDB3j22WfJzc09Zp/s7Oy2Di9OoQJrAfO3zPdom79lvuwUF0IIIYQQQgjR5TQ0QE5OIKtWBbN1awCKojrhfRSnlhEXlxMbG+CFFXYcdUEB4fM936+Hz58vO8WFEOIktTkp/p///Ify8nKuu+464uLi0Hbl7xiJVmt6qGZCaIKrprg53X34piTGhRBCCCGEEEJ0BXv3alm5Mpg1a4IoLdW423U6JzZbS7vEPdVUJAB1nbjCjqUuKHCXTrEnJKDNysJ+uKZ4ZGqqJMaFEOIktDmTvW/fPm666SaSkpI6cj3iFCq0FnokxC1TLAyJH4JlioWUDSnuxLgl2SKHbQohhBBCCCGE8DqrVcX69UGsXBnMN9/o3e16vUJDA4CqVQlxgJ5RXeswzeNRFxZ6JMRLLBZ6DhlCicVCRErKkcS4xSKHbQohRCu0OSluNBoJDg7uyLWIU8ygNxARFAHgsSO86eGbEUERGPSGU7lMIYQQQgghhBCnEUWBnTt1rFoVzPr1QdTUuJLeKpWCVgs2m4qGBlfJlGHD6klNreGRv2qpsYXQcl1xJyH6Ki4a3vxstK5KMRhwRkRgB4rNZpTDO8KbHr7pjIhAMcj7dSGEaI02J8UnTJjARx99xIUXXtiR6xGnkFFvJHNSJtYGa7Od4CaDCUuyBYPegFFvPEUrbJvKhsoWYwLX7nhfjEkIIYQQQggh/F1xsRqLJYhVq4L59Vedu921K1yFoqiw2SA62kFKSg1XXVXDmWe6dn/3zLFw7Ye3AU48E+OuQzVfvnQ5Gk2K94JpJ8VopCQzE5XVijM2lqZV050mE8UWC4rBgGKU97ZCCNEabU6KX3nllaxYsYL777+fCy+8EEMLn0YmJyef1JibNm1i/fr1lJeXExcXx5w5c+jfv3+Lfb/44gtycnL4/fffsdvtxMXFkZqaygUXXODuY7fbWbduHZ988gmlpaXExsaSkZHh0Ud4CtFA0DHOGekRAOrWfQuty6hsqCTj/QxKakswJ5uJC41zX2usnx4RFEHmpExJjAshhBBCCCHEKeZwwNatAaxaFUxOTiB2uyv9q9EoOJ2gKK5d4Xq9wsSJdaSl1XDJJfVoNJ7jjP7HmSwcmMbiFc9y6FC8u71Hj3zuvPZuRqfN8WJUHUMxGo+Z9JaSKUIIcXLanBT/9ddf+eSTT7Barfz+++8t9jmZpPiOHTtYtmwZc+fOpV+/fmzevJmFCxeyePFiIiMjm/Xfs2cPAwcOZPbs2YSEhLBlyxYWLVrEwoUL6d27NwCrVq3i008/5aabbsJkMvHdd9/x1FNP8fjjj7v7iCMcjkoKCjJwOEqIizOj1x9JINtsBeTnp6LRRGAyZaLR+EYC2dpgpaS25Eg99CkWYojxOFC0sZ8kxYUQQgghhBCno67w7dr/+z8Nq1YFs3p1MEVFRzLcWq2C3a7C4XAlx887r4G0tBqmTaslPFxpcSx72S8U5M7g4uQGRo3YRNV9l1FW2pPw7n8Q+uSH2LtXkZ+7HlPwJrThfTs1LiGEEF1Tm5Pir7/+OqGhodxyyy2YTCa02jYPBcDGjRsZO3Ys48aNA2DOnDl899135OTkkJ6e3qz/nDlzPG6np6ezc+dOvv76a3fC+9NPP2X69OkMGjQIcJV8+fbbb9mwYQO33357u9brj5xOKw5HCTZbLvn5qcTHW4AYd0LcZst192tvUtzhqMTptKLTNX/RZbMVolYbOiTxHmuIdddDz63KJWVDClmpWaRvSHcfKGpONsvBoUIIIYQQQojT0qn8dm1dHbz/vuvQzM8+O/KVZY1GcSfB7XYV4eEOZsyoJS2thnPOsZ9wXE0N6MtBVQ/nPWPEuuoBeg4ezB9ff43hz1/w/d1V6Gpd/Qjv0JCEEEL4iDZnsvPy8rjjjjsYMmRIuxdht9vZv38/06ZN82gfOHAge/fubdUYTqeT2tpajzIuNpsNvV7v0U+v17d6zNONThdLXJzZnQDPy0shLCyLvLx0bLZcdLoE4uLMLSayT4a3d6Q3PSg0tyqXpNeTANwJ8cYDRYUQQgghhBDidNPSt2ujlehO/XbtDz9oWbUqmLVrgykvb6zRqaBWg9Pp2hWuViuMGVPPrFk1jB9fx1Fv7Y9LZepLtPIB3W66hpBvCwhISYGsLCLS09HmFnDe0ybK//0mKpPsEhdCiNNVm5PikZGRKErLX1U6WZWVlTidTsLCwjzaw8LCKC8vb9UYGzdupL6+nosvvtjddv7557Nx40b69+9Pz549+eGHH9i5cydOp7PFMWw2GzbbkdOnVSoVQUFB7j+fDvT6OOLjLeTlpWCz5bJrlyuBrNMlEB9vQadrfwJZUao9dqSfccYaIAa7vdBjR7qiVKNShR1/sFaKC43j+THPM3X9VHfb82Oe99gF0ZEany/eeN54ay5/m8ebc0lMvjGXv83j7bm8xd9i8rd4QGLyFRKTb5CYuj5/iMcUasIyxcKMDTPIrcpl+MrhhAeFU1ZbhkNxEB8aj2WKpd2biSoqVKxbF8TKlUHs3n0kw31kV7gKpxP69LGTllZDSkotPXs2vnc/+cdXFX821lfXEZCSgjY3F5KS0AL2hASsr1pQm3x7c5Q/PPeOJjF1ff4WD0hMpzOV0sbM9tatW/n444958MEHm+3GPlmlpaXcfPPNPP744/Tte+ST2rfffptt27bx3HPPHff+27dv59///jf33nsvAwcOdLdXVlbyyiuv8PXXX6NSqejZsyfnnXceW7du5a233mo2zurVq7FYLO7bvXv3ZtGiRe2KzVdVVOxwJ8QBLrzwM8LCRnTY+HV1eXz77Wjq6vYTGJhI//5vsmfPNe7bF1ywlcDA+BMP1Ep5FXmMXj6a/WX73W2J4YlsvW4r8WEdN48QQgghhBBC+Jqq+iqG/GcIv5T+0uxa3+592fnnnYQGhJ70uIoCn3wCS5eCxeIqlwKgUrmuNQoNhVmz4PrrYfhw1/UOs2MHJB15b8tnn8GIjntvK4QQwje1eaf4/v37KS0t5S9/+QvnnHOOR9kScH0acf3117dqLKPRiFqtbrYrvKKiotnu8aPt2LGDV155hbvuussjId447n333UdDQwNWq5Xw8HAyMzOJiopqcazp06d7HA7a+InKoUOHsNtPXLfMX9hsBeTledZx/+GH9A7bKe6iJTY2m7y8FOrq9nvsSI+NzaasTAsUdchMBdYCUjakuGqIGxPISski3ZLO/rL9jFo6qkN2PRxNpVIRHR3NgQMHOuwbFad6Ln+bx5tzSUy+MZe/zePtubzF32Lyt3hAYvIVEpNvkJi6Pn+J56HPHmJf6b4Wr+0r3cedG+7ksaTHWj3egQNqzOYgVq0K5rffjqQd1GoFp1PlTognJdWTllbL5Mm1BAc33rfNYTSjLihwlUxp0mZPT6fEYsHpBzvF/eG515TE1PX5WzwgMfkbrVZLjx49Wte3rZNs2rTJ/efPPvusxT6tTYprtVoSExPZvXs3w4YNc7fv3r2boUOHHvN+27dv5+WXX2b+/PnuwzRbotfr6d69O3a7nS+++MKjxEpTOp0OnU7X4rXT5UnU9FBNnS6Bc8/N4ocf0t01xl01xTvmxYNWG0t09BLy8qa526Kjl6DVxnbY411oLSRlY4r7UE1LsoUh8UOwJFvcifKUDSlYki2dctimoihee+54ay5/m8ebc0lMvjGXv83j7bm8xd9i8rd4QGLyFRKTb5CYuj5fj2dT7iactFxm1ImTnNwcFoxYcNwxbDb4+ONAVq4M5uOPA9wHZTYmwsFVL9xkspOWVktqag1nnOFw37+jHz51QQERqaloc3OxJySgzcrCnp6ONjeXiJQUis1mn0+Mg+8/91oiMXV9/hYPSEynozYnxbOzsztyHSQnJ/PCCy+QmJhI37592bx5M8XFxVx22WUAZGVlUVpaym233Qa4EuIvvfQSc+bMoW/fvu5d5nq9nuDDHzH/+uuvlJaW0qtXL0pLSzGbzSiKwtSpU1tcw+nOZiv0SIjHx1sICxviUWM8Pz+VuDhLuw/bdM1XwIED8z3aDhyY36GJd4PeQERQBIDHoZpND9+MCIrAoDccbxghhBBCCCGE8EuKolBvr0cFKEBUAPylD7ywDw7Wu6p519nrUBSlxfq0//ufhlWrgjGbgzl0SNN0ZFx1wlUEBipMnlzLVVfVkJTUgFrdbJgOpS4sJLJJQrzEYqHnkCGUWCxEHK4xHpmaSrHFgjO24zdHCSGE6PranBTvaCNGjKCqqoo1a9ZQVlZGfHw8DzzwgHvLe1lZGcXFxe7+mzdvxuFwsHTpUpYuXepuv/TSS5k3bx7gOjhz1apVHDx4kMDAQC688EJuu+02QkJCvBucj1CrDWg0rgRy08S0TmciLs5Mfn4qGk0EanX7E8jH25HuSrx3TGLcqDeSOSkTa4O12U5wk8GEJdmCQW/osFPUhRBCCCGEEMKXFFUXUVZfigLEBMJz50NUIPQ1wB3fQVEdlNWXUlRd5H5PVVOjYuPGQFatCuaLLwLcY6lUCorSmDhXceGFDaSl1XDllbWEhXlvt6JiMOCMiMAOFJvNKId3hDtNJorNZiJTU3FGRKAYZHOUEEKcrrpMUhxg4sSJTJw4scVrjYnuRo8++ugJxxswYACLFy/uiKWdFjQaIyZTJk6ntdlOcFdi3HI4cd6+BLK3d6Qb9cZjJr07o2SKEEIIIYQQQvgKg96AYfvfsVPHc3c9TlSgqz3qcIL8T88+iJZAQq4x8O23OrKygnnnnSCs1sbt3q4d4QCKoqJHDwczZ9aSllZD376n5mwuxWikJDMTldWKMzaWpvvbnSYTxRYLisGAYpTNUUIIcbo6qaT4bbfdxj333EOvXr2YN29ei1+daqRSqXjhhRfavUDhXRqN8ZhJ745IUIN3d6QLIYQQQgghhDg2o95IcpyOt974G++bVJx//jZKSmKIiCjiu+8uwfrhAoYM+4iZV5zJnj1HzuA6sitchVarMH58HWlpNYwZU88xjuryKsVoPGbSW0qmCCGEOKmk+IABA9z1ugcMGHDcpLjwTarKSven6UdTFxZ2yKfp3tqRLoQQQgghhBDi+BRF4aY5z1LwezzLljU/TFOlcrDzy3GNvWm6K7x/fxtXXVXDjBm1REa2fFCnEEII0RWdVFL81ltvdf/56HImwvepKiuJyMhAXVLiqrsWF+e+pi4ocNddK8nM7JDEeGfvSBdCCCGEEEIIcXwqlYptH4xly5Y0wAl4noKpKE0Pz1QRFuZk2jRXeZSBA23IXjkhhBC+qJPPfHZxOp3cdttt5OXleWM60UYqqxV1SYn7JG51QQFwJCGuzc1FXVKCymo9xSsVQgghhBBCCNERSkqsPPH8i7h2gB8rRaAwapSVf/2rlG++OcDChRWcf74kxIUQQvguryTFAQ4dOoTNZvPWdKINnLGxFJvN2BMS0ObmEpGSAjt2EJGSgjY3F3tCAsVms9RfE0IIIYQQQggf5nDA1q0B3HZbN4YM6YO1ujtwvAy3iltvzWfq1DoCA721SiGEEKLznFT5FOH/nCYTxWaze2c4SUlo4UhC3GQ61UsUQgghhBBCCNEGv/yixWwO4u23gzlwQHPiOzRRWtoTqO2chQkhhBBeJklx0YzTZKJsyRJ6TJvmbitbskQS4kIIIYQQQgjhY0pLVbzzThBmczDffadvcuXIoZmtERXl6PC1CSGEEKeKJMVFM+qCAsLnz/doC58/X3aKCyGEEEIIIYQPaGiALVsCMZuD2Lw5EJutMfndNBGu4vzzG5g+vZanngylugZarrDqxBCicNFFDd5YuhBCCOEVkhQXHpoeqmlPSECblYU9Pd19+KYkxoUQQgghhBCi61EU+P57HRZLEGvXBlFa2lJ5FBVxcXZmzKhl5sxa+vSxA2AyOfjzn8NRFCeeiXEnKpWKxc+Vozm5aitCCCFEl9alkuKbNm1i/fr1lJeXExcXx5w5c+jfv3+Lfb/44gtycnL4/fffsdvtxMXFkZqaygUXXODR79133yUnJ4fi4mKMRiMXXXQR6enp6PX6Fsc9nakLCz0S4iUWCz2HDKHEYnEfthmZmkqxxSKHbQohhBBCCCFEF/DHH2refttVHmXvXl2LfYxGJ1Om1DJjRi3DhjWgPmpD+GWX/Y/HH3+N5557kEOH4t3tPXrkc8cd/+Cyy+YCsjlKCCGE/+gySfEdO3awbNky5s6dS79+/di8eTMLFy5k8eLFREZGNuu/Z88eBg4cyOzZswkJCWHLli0sWrSIhQsX0rt3bwA+/fRTsrKyuOWWW+jbty9FRUX861//AmDOnDneDM8nKAYDzogI7ECx2YxyeEd408M3nRERKAbDqV2oEEIIIYQQQpzGamshJycQszmYTz4JwOlsXh5Fq1UYN66OGTNqGT++jsDAlsey2QrJz09lxIhcRo78kKKi93E6+6FW7yUmZhJO52/k528iLs6CTiebo4QQQvgHryXFBwwYQFBQ0DGvb9y4kbFjxzJu3DjAlbT+7rvvyMnJIT09vVn/o5Pa6enp7Ny5k6+//tqdFP/ll1/o168fI0eOBCAqKoqkpCT27dvXQVH5F8VopCQzE5XVijM21uPIFafJRLHFgmIwoBiNp2yNXVllQyXWBiuxhuYvFAuthRj0Box6eeyEEEIIIYQQJ09RYOdOPWZzEBs2BFFZ2VL9bxWDBzcwY0YNV15ZS/fuygnHVasNaDQRAMTFZXPWWUZiYqCoyEhDQzb5+aloNBGo1bI5SgghhP9oc1I8LS2Nf/zjH/Tp06fZtf379/PAAw+QnZ0NgFqt5pFHHjnmWHa7nf379zNt2jSP9oEDB7J3795WrcfpdFJbW4uhyS7ms88+m08//ZR9+/bRp08f/vjjD3bt2sWll17a4hg2mw2bzea+rVKp3Il8lar1p3L7tLAwlLAwVByJufH/jTvHO/qROHqeztRZc1U2VHL1+1dTXFuMZYqFuNA49zwF1gJSNqYQGRRJ5uTMDk+Me+vx87d5vDmXxOQbc/nbPN6ey1v8LSZ/iwckJl8hMfkGialraroZ5uh4OmMzTF6eBoslCIsliN9+a/ktfK9eR+qE9+7taHLlxI+zVhtGXFwWTqcVnc4zJr0+jvj4NYcT5767wccfnndHk5h8g7/F5G/xgMR0OuuUneJOp/OkHvjKykqcTidhYWEe7WFhYZSXl7dqjI0bN1JfX8/FF1/sbktKSqKyspKHHnoIAIfDwYQJE5ol3xutXbsWi8Xivt27d28WLVpEjx49Wh2LP4qOjvbpeez2Cuz2KgID45rNVVeXj1YbilYbdqy7t4qj0kGZrYzcqlzS3k9j63VbAbAF2UhbnUZuVS4arYaQ8BBijDHtmutYfP3ndKrm8eZcEpNvzOVv83h7Lm/xt5j8LR6QmHyFxOQbJKauo6KughmZMzhYfZCt120lPiweRVGIjo4mryKPq8xXERUSxQcZHxAW2Pb3GFVVYLHA8uXwySct9wkPh1mz4JprYPhwLSpVKBDaxhmbv0c58jPqnPcvp4KvPu+OR2LyDf4Wk7/FAxLT6ahTkuL79+8nODj4pO/XUiK9Ncn17du3Yzabuffeez0S6z/++CNvv/02c+fO5ayzzuLAgQO88cYbdOvWjZSUlGbjTJ8+neTk5GZzHzp0CLvdftLx+KKnnzag0cCdd1pRqVRER0dz4MABFEVh8WIDDgfcc4+1Q+c8ep6O5HBUkp+fgcNRTHy8Bb0+zj1XQ0M+eXkpaDSRxMVltmvngwYN2ZOySdmQwv6y/Yx6fRRZKVmkW9LJrcwlITSB7EnZaKo1FFUXdWCEnfv4+fM83pxLYvKNufxtHm/P5S3+FpO/xQMSk6+QmHyDxNT1FFoLKaooIrcql3NeOgeDzoBao8bpcGK1WamyVeGwO9iXt6/FsorH43DAZ5+5yqO8914gtbWN5VGO1AnX6RQmTKhj5sxaxo6tR6939ThwoONi9PWfUUskJt8gMXV9/hYPSEz+RqvVtnpz80klxd977z3ee+899+2nnnoKnc7zdOuGhgYqKioYPnx4q8c1Go2o1epmu8IrKiqa7R4/2o4dO3jllVe46667GDhwoMe17OxsLrnkEned8jPOOIO6ujr+85//MGPGDNRHHbmt0+maxdPodHkSqdUKTz1lRFEU7rqrGnDF/uyzITz9dCj33FPZaY+FoiidkBSvwuEoxmbLJS8vhfh4CxDtTojbbLnufmp1W3dVuMSGxGJONpO6MZXcylySXk8CICE0AXOymdiQ2E59HnXG43c6zOPNuSQm35jL3+bx9lze4m8x+Vs8IDH5ConJN0hMXUdMSAzLJy7nsrcvo8pWRZWtyuO6Tq1j+cTlxITEtDq+ffs0mM3BrFkTTFGRpoUeKi66qJ6ZM2u54opaunU7Mm5HPYSqykr32VJHxnb9jNSFhX5ztpSvPu+OR2LyDf4Wk7/FAxLT6eikkuJGo5G4OFcJikOHDtGzZ89mO8J1Oh1nnHEGkydPbv0itFoSExPZvXs3w4YNc7fv3r2boUOHHvN+27dv5+WXX2b+/PkMGjSo2fX6+vpmO83VarU8IY7jzjtdu8CfftoIqHjqKVi82OBOiDde9xU6XSxxcWby81PdifGwsCzy8tKx2XLR6RKIizN32CnqJoOJJWOWMG39NHfbkjFLMBlMHTK+EEIIIYQQ4tRasWcFdmfL3yS2O+28uedNFoxYcNwxyspUrF8fhNkczK5d+hb7JCbaSEmpZcaMWuLjHS326QiqykoiMjJQl5RQbDajxB0pO6kuKCAyNRVnRAQlmZl+kRgXQggh4CST4iNHjmTkyJEA/P3vf2fu3LmYTB2T7EtOTuaFF14gMTGRvn37snnzZoqLi7nssssAyMrKorS0lNtuuw1wJcRfeukl5syZQ9++fd27zPV6vTtRP3jwYN5991169+7tLp+SnZ3NkCFDmu0SF0fceacVu13F00+H8swzoCihpKVVc/PNvpUQb6TTmTwS47t2JR1ub0yId1zCusBawPwt8z3a5m+ZjznZLIlxIYQQQggh/EBObg6BGoXJ0bCm4Ej7TBO8d0AhJzenxaS4zQZbtgRgNgfz4YeB2GzNS4V27+5g+nTXgZkDB9rwxhlpKqsVdUkJ2txcIlNTKbFYICYGdUEBEampaHNzsR/uJ0lxIYQQ/qLNNcUfeeSRjlwHI0aMoKqqijVr1lBWVkZ8fDwPPPCAuw5MWVkZxcXF7v6bN2/G4XCwdOlSli5d6m6/9NJLmTdvHgAzZ85EpVKxatUqSktLMRqNDB48mNmzZ3fo2v1RUlI9zz0X6v46XnZ2CG+/Hcx559kYNqyBYcMaGDq0ge7dnad2oa2k05mIjl5CXt40d1t09JIOT4inbkwlt8pVQzwrNYt0czq5VbmkbkyVxLgQQgghhBA+TlEUtDTw2DnwzC+e13aUwGPnwIv761EUxf2t5R9+0GI2B7N2bRAlJc3LowQEKFx+uSsRfskl9RyjomenccbGUmw2E3k4AR6RkgJZWUSkp7sS4gkJFJvNHqVVhBBCCF/XroM2Kysr2bhxIz/++CNVVVXce++9xMfH8+GHH9KnTx969+59UuNNnDiRiRMntnitMdHd6NFHHz3heBqNhtTUVFJTU09qHQI+/9z1FT6NxnXgS0iIk+pqNd98o+ebb/S88oqrX58+NneCfNiwBhISHF7ZzXCybLYCDhzw3MF94MD8DtspXmgt9EiIW6ZYGBI/BMsUCykbUtyJcUuy5aQP3BFCCCGEEEJ0DSqViqjP/sKizfUcGraQiKJRJIfGsLGqiKKYT1n0n7/SOyiA4vEa3n47iNWrg/n555ay3ApJSQ3MnFnD5Ml1hIae2hKfTpPJIzFOUhJaOJIQ76BviAshhBBdRZuT4gcPHuTBBx+ktraWhIQE/vjjD2w2GwC5ubn8+uuv3HrrrR22UOE9ixcbePZZI/feW8WTT4Zy331VPPVUKDfeaOWcc2x89ZWer77S88svOvbtc/2XlRUCQFSUg6FDjyTJzznHhraFZ9kzz4SiVist1ihfvNiA06ni7rurmt+xDWy2AnfpFJ0ugXPPzeKHH1w1xfPzUzskMW7QG4gIigDw2BFuMpjch29GBEVg0BvaHY8QQgghhBDi1Cio/IXooHq+XPsY6i33UFIfxvLD11QBFRyqD0MVu5dBg3ridDbfLdSvn6tO+LRpNcTGdq1v3TpNJsqWLKHHtGnutrIlSyQhLoQQwi+1OSn+1ltvERISwj//+U/CwsJIT093Xzv77LMxm80dskDhXa5DNY2HD9WsBkK5804riqK42598sgKA0lIVO3e6EuRffhnAd9/pOHhQw7vvBvHuu0EABAc7GTSocTd5PYMH2wgJUVCrlcOHecJdd1W3OH9HsNkKPRLi8fEWwsKGEB9vIS8vpUli3NKuwzaNeiOZkzKxNlib7QQ3GUxYki0Y9AaM+o6pwVfZUNniXODatd6RcwkhhBBCCCFcgjQKZyX+CDhx1od5XFMO3z5Y2M+jvUcPBzNm1DJjRg3nnGPvkt+sBdehmuHzPb9dGz5/vuwUF0II4ZfanBT//vvvufHGG+nevTtOp+cn3OHh4ZSWlrZ7ccL7nE7V4YS4FTjyaq1xR3fT3Q7duytMmFDPhAn1QBW1tbB7d2OSXM/OnXoqKtRs3x7A9u0BQCgajcI559gYOrSBK6+s4emnjahUKp58sjEhHtpk/vZTqw1oNK4d3E13hDc9fFOjiUCtbv8ObqPeeMxEdEeWTKlsqCTj/QxKakswJ5uJCz1yOnxjXfOIoAgyJ2VKYlwIIYQQQogOFBbYj+X/WnLCfgEBTpKT65g5s5aRI+vRNC8l3qWoCwrcpVPsCQlos7KwH64pHpmaKolxIYQQfqfNSXGbzYbB0HIisb6+HrVa3eZFiVPneCVLTpSoDgqCiy5q4KKLGgBwOuGXX7R8+eWRRHl+vpbdu/Xs3q133++pp0J55hlwOkOZN6+Ku9N+Qak0dMjJ5hqNEZMpE6fT2mwnuCsxbjmcOPed5LG1wUpJbcmROuVTLMQQ43HQZ2M/SYoLIYQQQgjRMYqK1Dz/vIHi0hNvqHnt1VLGjmvwwqraT11Y6JEQL7FY6DlkCCUWCxEpKUcS4xaLHLYphBDCb7Q5cx0bG8vu3btbvPbTTz8RHx/f5kUJ/6BWw9ln27n22hpeeKGcL744yFdfHeDlZwq4pccqztf9iErlOlCm8csGL79sYFqSmlfGbuXb7Q04O6DMnkZjPGZpFJ0u1qcS4uDadW5ONpMQmkBuVS4pG1LYkbfDfaBnQmgC5mSzHOgphBBCCCFEO5WXq1i5MpiZMyMYOrQnK1a07humlVVdfGt4E4rBgDMiotmhmo2Hb9oTEnBGRKAcY1OcEEII4YvavFN83LhxrFixgu7duzNy5EgA7HY7//3vf8nJyeGGG27osEUK/xEb62TaJUXMff7/oT2UywPGF/hn5W1oNOBwuMqzfNEwiC+KBkEadO/uYPToesaMqWf06Hq6d+9ah9GcKk0P8MytyiXp9SQAd0K88aBPIYQQQgghxMmprYWPPgrEYgliy5ZA7PaTLwIeFeXohJV1DsVopCQzE5XVijM2lqbROk0mii0WFEPHfJNXCCGE6CranBSfOHEiv//+O8uXL2fFihUAPPzwwyiKwrhx4xg9enRHrVH4GWdsLMVmM/++bBv/rLiNR8Oe4ZH3Lubvkz/n0Yq7uTJoE46Lh7Ltq26Ulmp4++1g3n47GJVK4YILbIwZU8+YMXWcf76ty9fm60wmg4klY5Ywbf00d9uSMUskIS6ED1AU5VQvQQghhBBN2O2wY0cAFksQ774bSF1d8y9Vm0x2pk+v5fWlQdTUHvuttCHE5i4p6SsUo/GYSW8pmSKEEMIftTkpDnDTTTcxZswYvvnmGyoqKggNDWXw4MH069fvxHcWp7VnVvfj6YqhroR4xT2QBI8AhMGjFXdzz6BKXnr9AF9/rWfLlgA+/jiQn37SsWuXnl279Dz7bCjh4Q4uvfTILvLIyFO7i9zhqGyxdjmAzVbY4bXLC6wFzN/ieTr8/C3zZae4EF2UtcHKop2L+DD3Q5wqJ2pFzWUJl3H/kPsx6OXryEIIIYS3KQp8+62ONWuCePvtYCoqmifCIyMdzJxZy9SptQwcaMNR/gs/fX2Ijz+febhH0/u43o8MG7gOpbIHhPft/CCEEEII0SZtTop/8803DBo0iL59+9K3b/Nf9mazmdTU1JMac9OmTaxfv57y8nLi4uKYM2cO/fv3b7HvF198QU5ODr///jt2u524uDhSU1O54IIL3H0effRRfvrpp2b3vfDCC3nggQdOam2iYzmdKu65p5JbR/aBaUfab13eB+v2SpxOFTodDB/ewPDhDTzwQBUHDqjZutWVIP/00wDKyjSsWxfMunWuXeQDBx7ZRX7hhUd2kT/zTChqtdLiQaGLFxtwOlXHPWC0NRyOSgoKMnA4SoiLM6PXx7mv2WwF5OenotFEYDJldkhivOmhmgmhCWSlZpFuTncfvimJcSG6FmuDlSnrp7CvbB9OjnyAt+zHZWwv3M6GKzdIYlwIIYTwkn37tLz9dhDZ2cEcOND8q6dhYQ6mT69l2rQ6Bg9uQN0k762pgSdvuJoPh63kxX+9SIHtyIaYOF0R8279C5ed+y6amk0Q7o1ohBBCCNEWbU6KL1myhL///e/06tWr2bX169djsVhOKim+Y8cOli1bxty5c+nXrx+bN29m4cKFLF68mMjIyGb99+zZw8CBA5k9ezYhISFs2bKFRYsWsXDhQnr37g3APffcg91ud9+nqqqKe++9l4svvvjkAxYd6u67q1AXFBCe6rnTOXz+fO5ucrhLU9HRTmbNqmXWrFrsdvjmGz0ffxzAli0B/PCDnu++c/333HOhdOvm5JJLXAnyujr4179ciei77qp2j7d4sYGnnzZyzz2V7Y7H6bTicJRgs+WSn59KfLwFiHEnxG22XHe/9ibFC62FHglxyxQLQ+KHYJlicR+2mboxFUuyRQ7bFKKLWLRzUbOEOIATJ/vK9vHkzidZMGLBKVqdEEII4f+KitS8804QK1cGs2+frtn1kBAnV15Zy7RptVx8ccMxyzSqTH2JVj7gLy9dw722eLb2TOXgLQuIevlhRv9hpu6TGMrTP0Blkl3iQgghRFfW5qT40KFDeeKJJ1i4cCERERHu9pycHDIzM7nmmmtOaryNGzcyduxYxo0bB8CcOXP47rvvyMnJIT09vVn/OXPmeNxOT09n586dfP311+6kuOGo07E/++wzAgICGD58+EmtTXQ8dUEBkampaHNzsSckoM3Kwp6ejjY3l8jUVI9Tz1ui1cKwYQ0MG9bA//t/Vfzxh2sX+ZYtgWzbFkB5uZr164NYvz4IgKgoO08/baSgQMObbzYmxEO5557KFneQnyydLpa4OLM7AZ6Xl0JYWBZ5eenYbLnodAnExZlbLK1ysgx6AxFBrr9zTXeENz18MyIoQnadCtGF5OTmNEuIN3LiJCc3R5LiQggh/FZlQyXWBmuLGzYKrYUY9AaM+o4/xLG8XMV77wWRmRnMt9/qAM8DMwMCnFx+eR0zZ9YyalQ9en3rxlXF9aPqP2sJSE1lXG42PJoNgD0hgar/mFEd532MEEIIIbqGNifFb7nlFh5//HGeeOIJFixYQHBwMNu2bWPp0qWkpKSQnJzc6rHsdjv79+9n2rRpHu0DBw5k7969rRrD6XRSW1vbLBHe1Mcff8yIESMIDAxs8brNZsNms7lvq1QqgoKC3H8+3TTG3NGxqwsLiWiSEC9ds4aowYMpXbOG7jNnuhPjJWvWtPpQl+hohVmz6pg1q+7wLnLd4VIrAezerefgQddTfeXKEFauBAglLa2G+fOrOyw+vT6O+HgLeXkp2Gy57NqVBIBOl0B8vAWdrmNeHIcFhJE1Ocv9xqLpzykuNI41U9Z0yhuLzno+nKp5vDmXxOQbc3XWPIqiYHfaj9vH5rR1ytze/Dl5i7/F5G/xgMTkKyQm3+APMVU2VHL1+1dTXFuMZYqFuFBXmUGVSkWBtYCUjSlEBkWSOTmzQ16/1tbC5s2BvPVWMDt26HE4PB87rVZh7Ng6rrqqjjFj6jj8do+jE+YnosTFUf7880ROnepuK3/+eZS4uJMcqevxh+fd0SQm3yAxdX3+Fg9ITKczlaIoSlvvXF1dzUMPPUR4eDhjx47lxRdfZNKkSVx77bUnNU5paSk333wzjz32mMchnW+//TaffPIJS5YsOeEY69evZ926dSxevJiwsLBm1/ft28df//pXFi5cSJ8+fVocY/Xq1VgsFvft3r17s2jRopOKRbRCRQVcfjkcPAhbt0J8/JFreXkwejRERcEHH0ALP8uT9ccfsGkTvP8+rFrleS0qCmbOhNRUuOQSjvk1yZNRUbHDnRAHuPDCzwgLG9H+gYUQPqv3c735veL3Y17vFdaL3+74zXsLEkIIIbwkvzKfS5ddyv6y/SSGJ7L1uq3Eh8WTV5HH6OWj3e2fzPmEOGPcCcdrid0OH38Mr74KGzZAfb3ndY0GxoyBG26AKVPgOPuoWq/xfcv+/UfaEhObv78RQgghRJfU5p3iACEhITzwwAP87W9/4/nnn2f8+PEnnRBvqqVPMFrzqcb27dsxm83ce++9LSbEwbVLPD4+/pgJcYDp06d77HBvnPvQoUMetclPFyqViujoaA4cOEA7Pjtpeexly1BZrTi1WlQHDhyZR6tFvXo1isGAUlMDNTUdMt9ll8EPPxiAUHQ6sNkgMNDJwYNqXn4ZXn4ZevRwMHlyHcnJdQwffuw6gsdjsxWQl+dZ7ueHH9I7dKf40Trz5+TP83hzLonJN+bqzHnGxY3jjYo3WiyhokbNuLhxFBUVdeic4N2fk7f4W0z+Fg9ITL5CYvIN/hCTBg3Zk7JJ2ZDC/rL9jHp9FFkpWaRb0smtdJ2Rkz0pG021hqLq1v8uVBTYtUtHZmYwGzYEYrWqPa6rVAqDBzeQkVHL5ZfXERbmevyqqlz/tYe6oICIlJTmpSD378c+ahQlFstxS0F2df7wvDuaxOQbJKauz9/iAYnJ32i1Wnr06NG6vicz8MaNG1tsP/fcc/n+++/p2bOnR5/WllAxGo2o1WrKy8s92isqKo6Z5G60Y8cOXnnlFe666y4GDhzYYp/6+no+++wz0tLSjjuWTqdDp2t+6Apw2j2JmlIUpcPjV0JDITTU9Wr2qHkcMTGNDR02X2MN8XvvreLJJ0O5774qnnoqlJSUGnQ6hfffD+LQIQ3Ll4ewfHkIPXo4mDSpjilTarnootYlyJseqqnTJXDuuVn88EO6u8a4q6Z457047oyf0+kwjzfnkph8Y67OmOe+IffxaeGnzQ7bVKPmrPCzuG/IfZ0amzd/Tt7ibzH5WzwgMfkKick3+HpMsSGx7rNvcitzSXrd9a3KhNAEzMlmYkNiWx3fvn1asrKCsFiCKSk5+kW6wjnn2EhPr2HKlDoiIo78zu2oh09dWOiREC+xWOg5ZAglFou7PSIlhWKLpdWlILsqX3/etURi8g0SU9fnb/GAxHQ6Oqmk+Jtvvnnc65mZmR63W5sU12q1JCYmsnv3boYNG+Zu3717N0OHDj3m/bZv387LL7/M/PnzGTRo0DH7ff7559jtdkaNGtWq9Qj/4kqIGw8fqlkNhHLnnVYURXG3f/vtAT77LICNGwPdCfIVK0JYsSKkyQ7yYyfIbbZCj4R4fLyFsLAhHjXG8/NTiYuzdMhhm0II32LQG9hw5Qae3Pmk69BNlRO1omZCwgTuG3KfHIwrhBDC74Xpwzg38lxyq3LdbedGnkuY/sTlEouK1KxeHUxWVjD5+c3fwp55po2MjBqmTq0lOrrlg607imIw4IyIwA4Um80oh3eEO00mis1mIlNTcUZEoHRIjRYhhBBCdJaTSoq/+OKLnbUOkpOTeeGFF0hMTKRv375s3ryZ4uJiLrvsMgCysrIoLS3ltttuA1wJ8Zdeeok5c+bQt29f9y5zvV5PcHCwx9gff/wxQ4cOJTQ0tNPWL7oup1N1OCFupekBOq7brus6HYweXc/o0fU88UQFn30WwIYNgXzwQfMd5C0lyNVqAxpNBIDHjnCdzkRcnJn8/FQ0mgjUanlxLMTpyqA3sGDEAh5Leuy0/SqbEEKI05O1wcrl6y7ntwrP8zPe/e1dfir9iQ+mfdDsA+LychXr1gWxfHkIv/yi5eiDMOPi7MyeXcPMmbXExzs6OwQ3xWikJDPTVQoyNtZjVU6TiWKLxVUK0tixh94LIYQQomOdVFK8sSZLQ0MD27Zt4+yzzyYurm2HoRxtxIgRVFVVsWbNGsrKyoiPj+eBBx5wz1lWVkZxcbG7/+bNm3E4HCxdupSlS5e62y+99FLmzZvnvl1YWMjPP//Mgw8+2CHrFL7n7ruPXTSwMTHeVNME+T//WcH27a4d5MdKkE+ZUsuwYUayszehVtdz992qo8Yz8fbbn+F0BnDvvQ0dHp8QwvfIKeBCCCFOJw99/pArIe5UQ+4osMaAoQgSPuW3it94+POHefbSZ6mthQ8+CGTpUgPffafD6fT8fdmjh4PU1BrS0mro08d7ifCjKUbjMZPevl4yRQghhDhdtOmgTb1ezxtvvMHf/va3Dl3MxIkTmThxYovXmia6AR599NFWjRkbG8vq1avbuzRxmtLpYMyYesaMOX6CPCrKgcnkYNcuPSpVJXffXe0eY/FiA88+6yrTApIUF0IIIYQQp49CayHrXh2AvjgLW+5IlMp49zWVMQ/dGZ+xRu3gtxdC+OYrI3a7ZyK8WzcHU6fWcvXVNfTvb0c+VxZCCCFER2hTUhwgKiqq2cGYQvizpgnyIyVWgti0KZCDBzUcPOiqpfLMM0Y+/jiQJUtg/XrXAZ9HyrcIIYQQQghx+gjSODnP3pevv58NeNb7VirjaPhhFgBfNmkPCXEyaVId119fzfnn2yQRLoQQQogO1+ak+OTJk1m3bh0XXHBBsxreQvg7vf5IgryhgcM7yF0J8vJyNbt26bnkEoBQRo6s46qrak71koUQQgghhPC6IJWa3D0jcSXE1UddPZLtDghwMHZsA3PnVjNsWAPqo7sKIYQQQnSgNifF8/LyqKqqYt68eZx77rmEh4d7XFepVFx//fXtXqAQXZ1eD2PH1jN27JEE+XXXdXfXQNy+PZCLLurJpZfWc9VVNUycWEdg4CletBBCCCGEEF6wdu2ZFBeHn7Df8uVljBolpQaFEEII4R1tTopv2rTJ/ecvv/yyxT6SFBenG70e96FAej00NEB8vJ28PC1btwaydWsg3bo5mT69hrS0Ws49t21fB3U4KnE6reh0zQ/ysdkKUasNaDRy4r0QQgghhPC+H3/U8vLLBj7+OJCKitZt+S4ulq3hQgghhPCeNifFs7OzO3IdQviFxYsNPP20kXvvreLJJ0O5774qnnoqlLlzrRgMCqtXB1FYqOWNNwy88YaBAQNspKXVMGNGLd27O088Aa6EeEFBBg5HCXFxZvT6OPc1m62A/PxUNJoITKZMSYwLIYQQQgiv2L3blQjfsiWQqqqTT3D37Nm618JCCCGEEB1BPo4Xfk9VWYm6sLDFa+rCQlSVlR0yT2NCvOmhmnfeaeWeeyp57TUDWq3Cf/97kJUrS5g6tYaAAIWfftLxyCNhDBrUkxtvDOejjwKw248/j9NpxeEowWbLJT8/FZutADiSELfZcnE4SnA623+wZ2VDJYXWlh+7QmshlQ0d89gJIYQQQgjf8+23Ov7852706xfNpElRrF8f7E6I6/UKSUn1/Oc/JfQ05HP0IZtHOIkOzeOiYfVeW7cQQgghRJt3igvhC1SVlURkZKAuKaHYbEaJO7KrWl1QQGRqKs6ICEoyM1GM7dtV7axt4N6bCrjjThVNDw26804rqqoqHLUBaDRwySX1XHJJPeXlFaxbF0R2djC7d+t5770g3nsviOhoBykpNVx1VQ1nnuloNo9OF0tcnNmdAM/LSyEsLIu8vHRstlx0ugTi4swtllY5GZUNlWS8n0FJbQnmZDNxoUceuwJrAakbU4kIiiBzUiZGvexIF0IIIYQ4HezcqeNf/zKwfXsA1dWee6wCA51cdFEDN95YzSWX1KPRuNo/uO9L3mYGzQ/bdN0eofkKjXa4lyIQQgghhGhnUnzbtm289957FBQU0NDQ/FAUKbEiTjWV1Yq6pARtbi6RqamUWCwQE4O6oICI1FS0ubnYD/drT1JcVVnJE58fTr7/qXnyfeEHh5PvlUeS7926KcyZU8OcOTX89JOW7Oxg3n47iAMHNLz4YigvvhjK0KH1zJpVQ3JyHQaD4h5TpzN5JMZ37Uo63N6YEDe1OZZG1gYrJbUl5FblkroxFcsUCzHEuBPiuVW57n6SFBdCCCGE8F9ffOFKhO/YEUBNjWciPDjYyYgR9dx0UzUXX9zQ7Lwce9kvhI/7njGl9fyweySHSuLd16Ii8znnvM8I7/4L9rLuaMP7eiMcIYQQQoi2J8V37tzJyy+/zKWXXspvv/3GmDFjaGho4OuvvyY8PJykpKSTHnPTpk2sX7+e8vJy4uLimDNnDv3792+x7xdffEFOTg6///47druduLg4UlNTueCCCzz6VVdXs3LlSr788kuqq6uJiorimmuuYdCgQW0JW/gYZ2wsxWYzkYcT4BEpKZCVRUR6uishnpBAsdmMM7Z9u6rbm3wfMMDO3/9eyd/+VsnmzYGsWhXMli0BfPWV67+HHnKSnFzHrFk1DBvWwLPPhqJW9+Pmm5eQlzfNPU509BJefLEfTqeKu++ualdMsYZYzMlmdwI8ZUMKWalZpG9IJ7cql4TQBMzJZmIN7XvshBBCCCFE17N9u56XXzbwxRd6ams9E+EGg5ORI+u59VYrgwYd/+B4TQ3ccvlCbEENnHuHmp2MopAYYiliCJ/yw5+c6Gr1aGouhfBODkoIIYQQ4rA2J8XXrVvHFVdcQXp6Olu2bGHChAkkJiZSXl7Oww8/TERExEmNt2PHDpYtW8bcuXPp168fmzdvZuHChSxevJjIyMhm/ffs2cPAgQOZPXs2ISEhbNmyhUWLFrFw4UJ69+4NgN1u5/HHH8doNHLXXXcRERFBSUkJgYGBbQ1b+CCnyeSRGCcpCS0cSYib2r+ruqOS73o9TJ5cx+TJdRw4oGbNmmCys4P43/90rF4dzOrVwfTqZScuzs727YGUl+8jI+PI/f/5z3289tpU7rmnY2p9mwwmj8R40uuuD7saE+ImQ/sfOyGEEEII0TV8/LGe//zHwFdf6amr80yEG41OLr20nltuqeL8809wCE4TKlNfopUP6HZjBiHFRVyq2Y4qPBylrAxVsZPznoyh/NVMVCbZJS6EEEII72nzQZuFhYUMHDjQfdvpdB2c0q1bN2bMmMG77757UuNt3LiRsWPHMm7cOPcu8cjISHJyclrsP2fOHKZOnUqfPn2IiYkhPT2dmJgYvv76a3efjz/+GKvVyr333svZZ59Njx49OPvss+nVq9fJByx8mtNkomzJEo+2siVLOiQh3nSOYrMZe0LCkeR704T4Sc4VHe1k3jwrn3xyiHXrDpGeXk1IiJPff9eyfXsgKpWT1167mwUL1nPOOTvIzHya1167m7lzn+G22/Z2WFwmg4klYzwfuyVjlkhCXAghhBCiE3jzoHNFgU2bAkhNjSAxMYZrronk008DDyfEFbp1czB9eg2bN//Bnj0HeOWVspNKiDdSxfWj6rV3sCckoHI4oLgYlcOBPSGBqtfeQRXXr8NiEkIIIYRojTbvFHc6nWi1WtRqNQEBAZSXl7uvRUZG8scff7R6LLvdzv79+5k2bZpH+8CBA9m7t3XJPafTSW1tLQaDwd329ddfc9ZZZ7F06VJ27tyJ0WgkKSmJadOmoVY3/zzAZrNhs9nct1UqFUFBQe4/n24aY+7s2L0xj7qggPD58z3awufPp8Ri6dDEuBIXR/nzzxM5daq7rfz551Hi4mhrdCoVDBtmZ9iwShYsqOKdd2p5880/+PZb12FEW7ZMISoK4GJmz36FjIx7yM9PID5+TbsP2wTXoZrzt3g+dvO3zMcyxdIpiXFvPe+8OZfE5Btz+ds83p7LW/wtJn+LByQmXyExdU2VDZVc/f7VFNcWY5licR90rlKpKLAWkLIxhcigSDInt/2gc0WBjRsDWbo0mG+/1dPQ0PTxUuje3cn48fX85S/Wow59b9/j2hmvk7sCf3jeHU1i8g0Sk2/wt5j8LR6QmE5nbU6KR0VFUVpaCkBCQgLbt29nyJAhAPz3v/8lPLz1BeEqKytxOp2EhYV5tIeFhXkk249n48aN1NfXc/HFF7vb/vjjDw4dOsTIkSN54IEHKCoqYunSpTidTlJSUpqNsXbtWiwWi/t27969WbRoET169Gh1LP4oOjrat+fJy4O0NMjNhcREePNNuOYatPv30zMtDbZuhfj4Ew7T6rnuvNOjKfLOOzt0jttvr2D06HT27w/k66/X8c9/Hvl7YzbfRHFxLOnpGxg2rA86XdhxRjqxvIo80sxp5FblkhieyJvT3+Satdewv2w/ae+nsfW6rcSHddBjdxRvPe+8OZfE5Btz+ds83p7LW/wtJn+LByQmXyExdS2OSgdltjJyq3Ldr7UAbEE20la7XpNptBpCwkOIMca0flwHrFoFL70EO3dCk31AAERFwZVXwgMPqEhM1ADBh//rQF54nXwq+fLz7lgkJt8gMfkGf4vJ3+IBiel01Oak+Lnnnsv333/PyJEjmTx5Ms899xz/+9//0Gq1FBYWktG00HErtfQJRms+1di+fTtms5l7773XI7GuKApGo5GbbroJtVpNYmIiZWVlrF+/vsWk+PTp00lOTm4296FDh7DbT/5rgr5OpVIRHR3NgQMHUBTFJ+dRFxYSMXOmu4xJ6erVRA0ezMHVq+k+cyba/fuxjxpFyZo17T5sU11QQERKinsubVYW9vT0I3N04K70qKhlREZa+fJL1zcetFqw28FuV/Hhh1fy4YdXsnhxA3/6UzlXXllLQMDJz1FoLWTmhpnuQzVXT17N4PjBrJ68mpnrZ7K/bD+jlo5izZQ1HXrYpreed96cS2Lyjbn8bR5vz+Ut/haTv8UDEpOvkJi6Jg0asidlk7IhxfVa6/VRZKVkkW5JJ7fS9Zose1I2mmoNRdVFxx3LZgOLJZAVK0L44QcdDofnjvCoKCeXX17HX/5ixWRyuq8UHX/YNvHm62Rv84fn3dEkJt8gMfkGf4vJ3+IBicnfaLXaVm9ubnNSfPbs2e5SIxdffDFqtZpPP/0UlUrF1KlTGT16dKvHMhqNqNXqZrvCKyoqmu0eP9qOHTt45ZVXuOuuuzxqnIOrvnljiZdGJpOJ8vJy7HY7Wq1n+DqdDp1O1+I8p9uTqClFUbwSf2fM4wwJwRkRgR0oNptRDie+HU0OxnRGROAMCWnX3OrCQo8X+iUWCz2HDKHEYnG3R6SkUGyxtDv5DqBWh7JkSQxPPx3KvfdW8eSTodx3XxVPPRXKuec28OuvOnbv1jN/vp4FC0LJyKjh2muriYlxnnjww0J0IUQEuQ7MNSebiQ1xrTs2JNZ9+GZEUAQhuvY9dsfireedN+eSmHxjLn+bx9tzeYu/xeRv8YDE5Cskpq6n6Wut3MrmB53HhsQeM77aWjCbg3jrrRD27NHhdHomwqOjnUyaVMttt1URHX1kjM58uLz9OvlU8fXnXUskJt8gMfkGf4vJ3+IBiel01Oak+NEJ5IsuuoiLLrqobYvQaklMTGT37t0MGzbM3b57926GDh16zPtt376dl19+mfnz5zNo0KBm1/v168dnn32G0+l0J8aLiooIDw9vlhAX/kkxGinJzERlteKMjfWoV+g0mSi2WFAMBhRj22oyuucxGDyT74d3ujQevtmYfFea1Lxvj8WLDTz9tJF77qnkzjurgVDuvNOKoig8/bSRefOqMBoVli8PprBQy/PPh/LSSwYmT67jhhuqGTq0gRN9CcOoN5I5KRNrg7XZTnCTwYQl2YJBb2hzPUshhBBCCNGyMH0Y53QfSO7uXmCNAUMR54w2EqZvvmHIalWxcmUQq1aFsHevFkXxTITHxDiYMqWOW2+tokcP778x9vbrZCGEEEKI1mhXZvjLL79k+/btHDp0yOOASnBt1X/qqadaPVZycjIvvPACiYmJ9O3bl82bN1NcXMxll10GQFZWFqWlpdx2222AKyH+0ksvMWfOHPr27eveZa7X6wkOdtW/mzBhAh988AHLli3j8ssv58CBA6xdu5ZJkya1J2zhYxSj8ZhJ747ajeKt5Lt7TKfqcELcStNDj1y3Xddvu83KzTdb2bQpkDfeCOHzzwPYsCGIDRuCOOccGzfcYGXq1FoOnyXbIqPeeMykd0eWTBFCCCGEEC4LF0HmZ3so//UlqDxSa/u9tXnsOOsbMpKGcutNKjIzg1m9Opj//a95ItxkcjB1ai033WQlMvLU7hDz9utkIYQQQojWaHNSfP369WRmZmI0GomOjiYwMLBdCxkxYgRVVVWsWbOGsrIy4uPjeeCBB9x1YMrKyiguLnb337x5Mw6Hg6VLl7J06VJ3+6WXXsq8efMAiIyM5MEHH2T58uXce++9dO/enUmTJjFt2rR2rVWIlngj+d7o7rurjnmtMTEOrlrjV1xRxxVX1PHTT1reeCOEt98O4scfddx9dziPP248XFqlBpPJ0aFrPBmVDZUt7kgHV21z2ZEuhBBCiNOBw1HJN9/9SPnXM4Gjyt5Vmij/Op6lP1bx0vMGwDMRHh/vYPr0Wm680Ur37l3rq9LefJ0shBBCCNEabU6Kb9q0iTFjxvDnP//Zo2Z3e0ycOJGJEye2eK0x0d3o0UcfbdWYffv25R//+Ed7lyaEzxswwM5TT1Xw179WsmpVMMuWhZCfr+XFF0P5178MXH55HddfX83FF5+4tEpHqmyoJOP9DEpqSzAnm4kLjXNfK7AWuGuXZ07KlMS4EEIIIfxafsX/2PvjMFwJ8aPfY7lu19WFHr6tkJDgYObMGubMqSEiovVnxwghhBBCnO7anM22Wq2MHDmywxLiQgjvCA9XuOWWanbsOMjSpaUkJdXjdKp4770gUlMjueyyHmRmBlNbq+KZZ0JZvLjl+o6LFxt45pnQFq+dDGuDlZLaEnKrckndmEqBtQA4khDPrcqlpLYEa4P1BCMJIYQQQvi2n787l9LieE70RuznVAAAkZVJREFUNm1Gahnff/8HO3Yc5O67rZIQF0IIIYQ4SW3OaPfr14/8/PyOXIsQwos0Grj88jpWry7ho48OcvXV1QQFOdmzR8d993VjyJCefPqpnqefNjZLjDce9KlWt/+rubGGWMzJZhJCE8ityiVlQwo78naQsiGF3KpcEkITMCebpYa5EEIIIfxSbS1s2hTAnDnh3HzDGa26z7jR0L27JMKFEEIIIdqqzUnxOXPmsGnTJnbu3Indbu/INQkhvOzss+0sWlTBzp1/8PDDFSQk2CkvV/PVVwGoVApPP23kjjvCUJQjCfEjB322n8lg8kiMJ72e5JEQNxlMHTKPEEIIIURX8McfapYvD+aKKyLp1y+GG26I4MMPg2hoaF0Nu6ioU3cWjBBCCCGEP2hzTfHo6GjOO+88nnrqKVQqFQEBAc36LF++vF2LE0J4V7duCjfdVM3cudV89FEAb7wRwrZtrkN0V68OxmwGRQnl9turOiwh3shkMLFkzBKmrZ/mblsyZokkxIUQQgjh8xQFfvxRy8aNgaxfH0xubvO3YTqdwtALa9izs54yZzda3r/kxKQrZHh/KyBnrQghhBBCtFWbk+JvvfUWmzZtolevXphMJrTaNg8lhOhiNBqYMKGeCRPq2bdPyxtvhLBsWTCK4tq99PrrIVitKq67rpo+fTpmp1KBtYD5W+Z7tM3fMl92igshhBDCJ9XVweefB7BuXRAffhhARYWmWR+DwcmYMXXMnl3LxRfXE1hcyLxx+3i7chbND9t03b4oaDva2j44wyUpLoQQQgjRVm3OZG/dupWpU6eSnp7ekesRQnQxffrYiYx0ACo0GnA4wGpV8/rrBl5/3cAll9Rx/fXVjBtXj6b5e71WaXqoZkJoAlmpWaSb092Hb0piXAghhBC+oLhYzUcfuRLhn3+ux2Zrvts7KspBcnItM2bUcv75NtRNutRFKoRO3cuY/JX8+N1IDpbGH7lf93zOOf8zQuN+oS7yTPTeCEgIIYQQwk+1OSnudDoZOHBgR65FCNHFOByVPPdcKM8+a+Tee6t48slQ7r23iqefDiUxsZbffgtk2zbXf3Fxdq67roZZs6rp3r31B3AWWgs9EuKWKRaGxA/BMsXiPmwzdWMqlmSLHLYphBBCiC5FUWDvXi05OYG8804QP/+sBZrXBT/zTBszZtSSnFx73G/ZaTShzLlhITgaOG++mu9LR1FEDDEUcV7Mp3z/Nydo9Gg0aZ0YlRBCCCGE/2tzUnzgwIH88ssvnHvuuR25HiFEF+FwVPLYY1t49dVbuOuufO68UwOEctddVpzOCp59No5Zs96iW7dJrFoVTn6+ln/8w8gzz4QydWotc+ZUM3Cg7YTzGPQGIoIiADx2hDcevpm6MZWIoAgMekNnhiuEEEII0SoNDfDf/+rZtCmQd98N4tCh5l+VU6sVLrzQRkpKDRMm1BEd7WzV2BqNkbCg6VRYs8m92cnov3zivvbNza7/hwVNR6OR0ilCCCGEEO3R5qR4SkoKixcvJjAwkEGDBmEwNE9YtdR2PJs2bWL9+vWUl5cTFxfHnDlz6N+/f4t9v/jiC3Jycvj999+x2+3ExcWRmprKBRdc4O6zdetW/vWvfzW771tvvYVeL184FOJ4nE4rdns911//EDNmvInNZgFisNkKmDEjhbKya4AI/t//+4177qln/fog3ngjhO+/15OdHUx2djCDBjVw/fXVXHFFLS2cxQuAUW8kc1Im1gZrs53gJoMJS7IFg96AUS9v/oQQQgjhqbKhssXXEOD6NlpHvYYoLVXx8ceBvP9+IFu3BlBX17wsil6vcMkldUyfXseYMXWEhbX+m3NNJb6u57e+0O8Zz/b+C2Hv3dD7Vz3VD7dpaCGEEEIIcVibk+L33nsvAMuXL2f58uUt9snOzm71eDt27GDZsmXMnTuXfv36sXnzZhYuXMjixYuJjIxs1n/Pnj0MHDiQ2bNnExISwpYtW1i0aBELFy6kd+/e7n5BQUEsWbLE476SEBe+TlVZicpqxRnb/A2gurAQxWBAMbbvDaBOF8sjjySRn5+KzZZLXl4KYWFZ5OWlY7Pl8qc/vUlcnBmdLhadDtLSarnqqlq++UbHsmUhbNgQxDff6PnmGz1//7uRjIwarr66mtjY5juljHrjMd+wSskUIYQQQrSksqGSjPczKKktwZxsJi40zn2t8bySiKAIMidlnnRiXFHgf//T8uGHAbz3XiC7dundB443ZTQ6ufzyOpKTa0lKqicwsN1hEbL+Q87/A1QK1EXBr3+Bs16AoCI4/15wRG+WpLgQQgghRDu1OSk+c+ZMVKrmLwzbauPGjYwdO5Zx48YBMGfOHL777jtycnJaPMxzzpw5HrfT09PZuXMnX3/9tUdSXKVS0a1btw5bpxCnmqqykoiMDNQlJRSbzShxR94AqgsKiExNxRkRQUlmZgckxk3ExZndifFdu5IOtyccToh7Hn6pUsHgwTYGDy7n4YcrycwM5s03QzhwQMOSJaG8+KKByy93Hcw5fHgDHfhPiBBCCCFOM9YGKyW1JUfOH5liIVqJ9jjAu7Ffa5LiNht8+aWeDz8M5L33AikoaPmtUnS0gyuvrGXy5DoGDWpo80HjLVEXFKA5dAjV4U3mgQfh3IeOVClXKaA5eBB1QQFOkxxCLoQQQgjRVm1Oil911VUdtgi73c7+/fuZNm2aR/vAgQPZu3dvq8ZwOp3U1tY2K9lSV1fHrbfeitPppFevXqSlpXkkzZuy2WzYbEdqIKtUKoKCgtx/Pt00xtzZsXtrHm/O1ZnzqKurUZeUoM3NJTI1ldI1ayAmBk1hId1TU9Hm5mI/3M8ZFtbu+fT6OGJinuf//m+quy0m5nn0+rjj3AuiohTuvLOa226rJicnkDfeCGbHjgDefTeId98Nol8/G9dfX8PMmbW8/HIIGg3ceae12WO3eLEBhwPuucfa7ljA82vWR8/VkV+zbkqe474xl7/N4+25vMXfYvK3eEBi8hX+EJMp1IRlioUZG2aQW5XL8JXDCQ8Kp6y2DIfiID40HssUi/u8kv/P3p2HN1mlbxz/Jk26kZalLXSlgqwuiIqooIIg4AIqCi6gDo7rKOM2AuM4uIDjDOqIqLijqD9QaXEBB2VRQBFFURBEFhEopaXQfV+yvL8/YkNLy9o2TdL7c129oMnbPO/dk6Ttk5Nz6lNQYGL58hCWLAnliy9CKCmpuywKQI8edkaMqODiiyvo0cNR44X9Rv7+RUZCUBA4D2zGWadCUBBERvrt2AXCfa+mQMsDyuQvlMk/BFqmQMsDytSSmQzDOL7F7hpRXl4ed955J1OnTqV79+6eyz/88ENWrlxZZ/mT+ixYsICPP/6Y6dOn0/qPRuC2bdvIysqiY8eOlJeXs2jRItatW8fTTz9NXFxcnduYN28eqampns87derEtGnTGiGhSCNLT4eBA2HHDujcGd59F2688cDnK1ZAUlKjlKqoSGf9+oFUVOzwXBYa2pnevVcQGnpsNX75BWbOhHfegbIy92WRkXDSSfDddzBlCkyefOD4qVPhkUfqXn68CisKuXjOxewv3c+KP60gqfWB808vTGfg2wNp36o9n4/9nNahDX9BQURERJpWcWUx/d44nbS8nRT/fj6UxIFtLxEnfk1yu06svnUdESERtb5m+3ZYuBA++QS+/hpc9eyBaTbDeefB1VfDFVdAcrKXAgHccQe8/rp7DZeDmUxw++3wyitePCERERGRwONTTfEnnniCbt26eS7/8MMP+eqrr3juuecO+/WrVq3i1VdfZcKECfTq1euQx7lcLiZNmkTPnj3585//XOf6Q80Uz87OxuFwHHswP2cymYiNjSUrK4umvJt4q443a3mjjjkjg6hRo7CkpXkucyQnk5ua2mhvp7XbM0hPH4XdnobVmswpp8zll1/GeD5PSkqts4TK0SgsNJGSEsbs2a3YsaP2G1auuqqcefPCeOihYp5+OoIJE4q5//7GmSWeWZLJ1QuvJq04jeSIZOZfPp8zu5zJj9t/5OoFNS4fMb9R1zLXfdw/agVaHW/X8pZAyxRoeUCZ/EWgZHp89SSsP5bwf6/NoCD3wIvdbaLSueH2e7GfaePhvtP48UcrS5aEsnhxaJ3fPaoFBxtceGEll1xSwUUXVdCuXfN8X0wlJUSNGIHlt98w1ejYG2Yzjq5dyV24EOOgd8f6k0C571ULtDygTP5CmfxDoGUKtDygTIHGYrEQExNzdMc28bkclcjISMxmMwUFBbUuLyws9Mz6PpTVq1fzyiuv8MADDxy2IQ5gNps58cQTycrKqvd6q9WK1Wqt97qWdieqyTAMr+T3Vh1v1mrKOs74ePJnzCCmxrJD+TNm4IyPr39m0TGy2zPZs2dUrQZ469Z9SEpK9TTK09NHkZiYitV6bA3kyEiDW24p5eabS/n66xDeeqsVy5aFYBgmPvwwDIsFIILbby/hvvuKGyMOAHGt4kgZnuJZZ/TqBVczd/RcxiwY42mIpwxPIa5VXJOMm+7j/lEr0Op4u5a3BFqmQMsDyuQv/D3T109fzq9rrqpzeUFuAi/+ez6to3bzvqM9hYX1L/wdEeFi2LAKLrmkggEDKgkLO/C9aK5vi9GqFTkLFhDx1FOELlmCxeXCYTZTMXQoxRMnYrRq1Xwn14j8/b53sEDLA8rkL5TJPwRapkDLA8rUEvlEU9xisdC5c2c2bNhA3759PZdv2LCBs84665Bft2rVKl5++WXuvfdezjjjjCPWMQyDtLQ0khppWQmR5mTOyKDtvffWuqztvfeSk5LSKDPFzWYbQUFRALU21ay5+WZQUBRm8/HPVDKbYcCASgYMqGT37iDeeacVL7/ciurVM197zcYvv1i55poyLr20glatGv5knmBLqNUY7/+me/PQ6ob44dYdFREREd9RWVnIro1DgPrWAXdfVphbd92T2Fgnl15azsUXV3D22VV/vBjvWwybjaIpUyieOpW42FiyW+BMLxEREZGm5DO/Ag4fPpwXXniBzp07061bN5YtW0ZOTg5DhgwBYO7cueTl5TF+/HjA3RCfOXMm48aNo1u3bp5Z5sHBwYSHhwOQkpJC165diYuL86wpvmvXLm655ZZmySjSWMwZGURXb6qZnIxl7lwcY8Z4Nt9sjMZ4UFAkCQlzcLlK6swEdzfGU/9onDd8U0qns4i4uBJateoGmLBYwL1ikcHq1SGsXh3CP/7hYvjwCq65poyzz67CXP8+WEclwZbAjAtncOWCKz2XzbhwhhriIiIifuSjJUWUlfU8qmO7d7dzySXujTJPOcWOX+075VcnKyIiIuIffKYp3q9fP4qLi5k/fz75+fkkJSXx0EMPedaByc/PJycnx3P8smXLcDqdzJo1i1mzZnkuHzBgAHfffTcApaWlvPbaaxQUFBAeHk6nTp14/PHH6dKli3fDiTQic2ZmrYZ4bmoqHfr0ITc11bPGePTo0eSkpuKKb9i62EFBkYdseh/rkimH4nQWkZExllmzxvDGG32YMKGYp56KYOJE95riZ565in37OrJnT0fmzQtn3rxwkpIcjB5dzqhRZSQnO4+5ZkZJBvcurz3L/t7l92qmuIiIiA9zuWDjRisrV4awcmUIa9bEHdXX/f3hLP56Vz27aYqIiIhIi+UzTXGAYcOGMWzYsHqvq250V3vssceOeHvjxo1j3LhxjXBmIr7DsNlwRUXhAHJSUjD+mBHuSkggJyWF6NGjcUVF+c0GTC5XyR8N8b9x663/Zfz4AUAfxo/fSn7+St5442/ccst/ufTSS/nww44sWBBGerqFZ5+N4NlnIzjnnEquuaaMyy6rwGY78tuKM0oyPEunJEcku9cUT3GvKT7609FqjIuIiPiQzEwzX3/tboJ/9VUI+fn1rw1+OGf2tgBVjX9yIiIiIuK3fKopLiJHZkRGkjtnDqaSElzx8dR8Q60rIYGc1FQMmw0jsuHLmniD1RpPq1bXceut/2Xs2AdJT0+mdeu5pKePYezYNABatbqOc84xcc45hTz+eCGLF4cxb14YX30VwnffuT8eftjFpZe6l1fp16/+5VUySzJrNcRTR6TSJ6kPqSNSGbVwlKcxnjo8lXhb48yEFxERkaNXXm7iu++CPU3wrVuthz0+yOTEaZiB+pYYcZHQKp+zz1ZDXERERERqU1NcxA8ZkZGHbHo3dMmU5jBxogm7/QL27EnGbk9j3Tr35pdWazL//OcFWK0H/tANC4MrryznyivLycw08+GH4cybF8bvv1uZPz+c+fPDSUhwMGpUOaNHl9Gp04HlVWzBNqLC3JuH1pwRXnPzzaiwKGzB/jHLXkRExN8ZBmzebPljSZRQvv8+mMrKmg1ug5oNb6vV4JxzqrjwwgoGD65k23fF3DapE/U3xeHxRwsICgpr0gwiIiIi4n/UFBcRn2C1JhAbO4P09Cs9l8XGzsBqPfRSJvHxLsaPL+Huu0tYt87KvHnhfPJJGBkZFmbMiGDGjAjOOquSa64pZ/jwciIjIzl362IcRiUJttp/PCfYErg47RssphAir9CMMhERkaaSne1eEmXFihC+/jqE/fsPtySKifh4B4MGVTJoUCX9+1d6lkszFRWx5JVlwHjCwwspK2vt+arw8ALKytqw8+XPMI24yG/eQSciIiIi3qGmuIj4BLs9g6ys2ptfZmXdS2JiymEb4wAmE5xxhp0zzijksccKWbIklJSUcFasCOGHH9wfkydHcsklFVgskJISTURwEQ88UOq5jenTbbz6fCQPPliE1h0VEZFAVFRVRElVSb1LhGWWZGILthEZ3PjN48pK+OGHYL76KoQVK0LZtOngJVFqzwa3WAzOOquKwYMruPDCSrp3d2CqZyK4o+h3ss7M4+aBk7ll6FNk5q/A0focLIXfEd92ILOWTCSr2Iqj6HeCIk9v9FwiIiIi4r/UFBeRZme3Z7Bnz2js9jSs1mROOWUuv/wyBrs9jT17Rh9VY7xaaChcfnkFl19eQVaWmY8+CmPevHC2bbPy0UfhANhsLp55JpL8fDNvvOFuiD/zTAQPPljE/feXNGVUERGRZlFUVcTYz8aSW55LyvAUEiMSMQz3jOvqTaijwqKYc8mcBjfGDQO2b69eEiWEb78Npry8ns0+PEx06OBk0CB3E/z88yuJjDzy5tnEncitf/07ZG2h93gHZ4dfj2XuXBxjxuAoqyLoxf9AbA+Iu6ZBeUREREQk8KgpLiLNym7PrNUQT0pKpXXrPiQlpZKePqpGYzwVq/XY1kuPjXXxl7+Ucuedpfz8s5WUlHA+/jiMggL3H+azZtl4800wjAhuvbVEDXEREQlYJVUl5JbnklacxuDUwdisNsxBZlxOFyX2EortxZ7jjqcpnp9v4uuv3ZtjrlwZQmZm7T8zTCYDwzgw3dtsNujTp+qPZVEqOOmk+meDH05QUCQJnVIgZDuW8PFY0tKgf3/3HzjJySQkvwjxXQgK0tIpIiIiIlKbmuIi0qzMZhtBQe7NL2vOCLdaE0hMTGHPntEEBUVhNh//5pcmE/Tubad370IeeaSQpUvdy6ssWxbi+QP9jTdsfPttCJddVs5ll5XTpYvzCLd6eM31FnUREZH6xNvieXvY2wz5cAjF9mJPE7ya1Wzl7WFv1/tzqz52O/z0UzArV7ob4evXW2s1vQ9ughuGiehoJxde6G6CX3BBJW3aHMVs8CMICoqEpDPInzGDmCuv9FyeP2MGQUlnNPj2RURERCQwqSkuIs0qKCiShIQ5uFwldWaCuxvjqX80zhungRwSAsOHV/DbbxaWLQvFYgGHw/3H+6ZNVjZtsvLUU5H06GH/o0FeQbduxzZ7rb63qFdr7Leoi4iIHK13Nr+Dw+UAlxnSzoeSOLDtheSvceDg3c3vMqXflEN+/a5dQaxY4W6Cf/NNCCUltZdEMZsNXC73D0zDMGEyGZx+up1BgyoYPLiSU06xYz7cKirHyZyRQdt7a+9L0vbee8lJScGVcHTLr4mIiIhIy6KmuIg0u6CgyEM2vY91yZQjcTqLeO65CJ59NpIJE4p56qkIJk4s5umnIxg6NB+73cqqVa3YssXKli1W/vvfSE480c5ll1Vw2WXlnHzykRvkNd+iPvrT0aSOSCWOOE9DPK04zXOcmuIiIuItX6d/jm3blRR/OgOKkg5cEZmObfi9fB35OXCgKV5UZGL16hBPIzwtrfafDkFBBk7ngR+KLpeJtm2rZ4NXMmBAJe3auZo0kzkjg+jRo7GkpeFITvasKW5JSyN69Gg1xkVERESkXj7VFF+8eDELFiygoKCAxMRExo0bR8+ePes9ds2aNSxZsoRdu3bhcDhITExk9OjR9O7du97jv/nmG2bMmEGfPn2YOHFiE6YQEV/ldBYxdepyXn/9LzzwwB7uvz8IiOD++0twOgt59tlEbrvtZWbMGMyXX8bwv/+FsXJlCL//buX55608/3wEJ5zg8Mwg79XLXm+DPN4WT8rwFE8DfNTCUcwdPZcxC8eQVpxGckQyKcNTjvot6iIiIg3lcBQyKLs/r859v+6VRQkUz03l+qTr+eGHSlatiuKrr0L48cfgWk1vk8nAbMZzWfW/vXtXeZZFOe00O0FBXomEOTOzVkM8NzWVDn36kJuaStSoUQca46mpuOL1M1dEREREDvCZpvjq1auZPXs2t956K927d2fZsmU8+eSTTJ8+nejo6DrHb968mV69enH99dfTqlUrli9fzrRp03jyySfp1KlTrWOzs7N59913D9lgF5GWweUqweGo5OabJ3PVVe9it6cCcdjtGVx11Sjy82/E4YgiMrKI0aNtjB5dTnGxiS++COV//wvlyy9D2bXLwsyZEcycGUFiooNLL3XPID/jjNpvCU+wJdRqjPd/sz+ApyGeYNOsNRER8R6Ho5S3n3v9j88OXsPEDBi8Nu09XjvoupAQg8pKABOGYcLphDZtXFxwgbsJPnBgJTExTTsb/FAMmw1XVBQOICclBeOPGeGuhARyUlKIHj0aV1QUhu349yURERERkcDkM03xTz/9lEGDBjF48GAAxo0bx88//8ySJUsYM2ZMnePHjRtX6/MxY8awdu1afvzxx1pNcZfLxfPPP88111zD5s2bKS0tbdIcIuK7rNZ4Hn20P3v2jMZuTyM9fRStW88lPX0Mdnsat9zy7h+bfR6YTRYRYXDlleVceWU5paUmvvwyhP/9L4wvvghhzx4Lr71m47XXbMTGOj0zyPv0qeLZZ4Mxm+OZccMMrlxwpef2Zlw4g/dfjcflCmbChKpm+C5IS2MYDd/ITkT839JvIqgob32YI0yACXOQC0uQiaoq9yzwykr3v6ec4p4NPnhwJaefXoXFB/6KMCIjyZ0zB1NJCa74eGq+ecuVkEBOaiqGzYYRqaXKRERERKQ2H/h1FhwOBzt27ODKGjvGA/Tq1YutW7ce1W24XC7Ky8uxHTQTJDU1lcjISAYNGsTmzZsPext2ux273e753GQyERYW5vl/S1Oduamze6uON2sFSiZTUdGBPzQPqmPOzGySPzSb+nsXHJxIUlIq6emjsNvTWLfOPYPbak0mKSkVq/XQM7htNrj88kouv7yS8nJYscLdIF+yJISsrCBmzbIxa5aNmBgH0dFb2Lz5FOZufh/OPnAbf/nnNvYuuoLbbnsZl2tQo20gWk33cdUB93r1036YxpK0JbhMLsyGmaHJQ5l01iRswf49Y9Kb9z1vCLQ8oEy+pKICNm60snZtMB990vaovsblNFPlhIgIFwMGVHLhhe6P2Nias8F96PvQujVG69bulv5B41Q9c9yHzvaY+et973ACLVOg5QFl8hfK5B8CLVOg5QFlaslMhg9MIcvLy+POO+9k6tSpdO/e3XP5hx9+yMqVK5kxY8YRb2PBggV8/PHHTJ8+ndat3bNgtmzZwnPPPcdTTz1FZGQkM2fOpLS09JBris+bN4/U1FTP5506dWLatGkNTCfipwoL4eKLYf9+WLECkmpsyJWeDgMHQvv28Pnn0PpwM898U2Hhak9DHOD007+hdet+x3VblZWwdCmkpsInn0BBQe3rwztuYOoTFp55fwl7F93HzTdP5s+3vkOfM74hNDSxASncCisKKa4qJjGy7m3tKdpDRHAErUP9b4zk+BRXFnPurHPZnL0ZFweaWGaTmZ7RPfn2lm+JCIloxjMUkaaSmQmrV8O337r//eknqDrGNyVdd53BnXea6NcPrNamOU8RERERkebmEzPFq9X3CsbRvKqxatUqUlJSmDBhgqchXl5ezgsvvMAdd9xB5FHOZB05ciTDhw+vUzs7OxuHw3FUtxFITCYTsbGxZGVlNenb771Vx5u1AiGTOTOTqL173ZtXnX8+efPn0/7MM9n/44+0u/pq9+VOJ7nbtzfq5lXe+N7Z7Rmkp9delumXX8Yccab44Zx5pvvj8cdhwbISHp/1A5WbhlJSFE3Z7l787SaAk0hM3IozpIA7Pk/inZh9xNsathtZUVURYxeNJac8h9QRqSRGJHq+f3uK9zBq4Siiw6KZc+kcIoMbb1Z6INzHA7XO5G8m12mIA7gMF5uzN3P/wvuZ2n9qo9f1Fm/e97wh0PJA4Gbq0KED+/bt85lMdjv8+quVtWvdM8F//NHKnj11f7UPC3MRFmZQVGTG4Tjc79UuEiwZPDO5DHPbSHJymu7cm0qg3veUybcFWh5QJn+hTP4h0DIFWh5QpkBjsViIiYk5umOb+FyOSmRkJGazmYKDplcWFhZ6mtyHsnr1al555RUeeOABevXq5bl83759ZGdn15rpXX1HuO6663juueeIjY2tdVtWqxXrIabEtLQ7UU2GYXglv7fqeLOWP2dyxsV5NqmypKXR7uqrYe5c2o0Z426IJyeTk5KCKy4OmiBjU33v7PYMz5riVmsyp5wyl19+GeNZY9y9pvjxb4JptcKQwU5mV/0XV+VD3Mg5TPjbXFwud/N7z57uvPPKCwBc9U4Vgy60c+GFFfTrV0V4+LHnLa4sJqc8h7TiNEYtHEXqiFRiY2M9DfG04jTPcRHWxp8d7M/38UCtszhtcZ2GeDUXLpakLWFKvymNXtfbvHnf84ZAywOBkamkqoRpa6exNG2pZymiIclDmNTH+0sR5eWZWbvWyo8/BvPjj8GsW2eloqL2ppgmk0Hbtu7Hf36+GcMwUV5uprzcfb3NXEyJywYY1N5s0/01/4mfSFDZ33C18e93kwTCfe9gyuT7Ai0PKJO/UCb/EGiZAi0PKFNL5BNNcYvFQufOndmwYQN9+/b1XL5hwwbOOuusQ37dqlWrePnll7n33ns544wzal0XHx/PM888U+uy999/n4qKCsaNG0d0dHTjhhAJQK6EhFqNcfr3xwIHGuIJx988bg52e2athnhSUiqtW/eptcb4nj2jSUxMrbXZ5rGKDI7kvf6vUF6wn9kfdcblCsJqrcRuD+G88/ZTWWpm/cZ27E4LZvbsYGbPbkVwsMHZZ1dx4YUVXHhhJV27Ojia5b/ibfGkDE9h9KejPY3xuaPnMmbhGNKK00iOSCZleArxtsabzS++yzAMHK7Dv7PJ7rJjGIbWlxM5gpKqEkYsGMH2/O21XmiavWk2qzJXsfDyhU3WGHc6Yds2yx8zwINZuzaYnTvrnwXeurVBebmJwkJ3Ezwv78A7kDp2dHDWWVWcfXYVZ5yxh5Dic3nk+ddYvvz6g27JzIUXvkfn+xZSGfM3tGqKiIiIiAQ6n2iKAwwfPpwXXniBzp07061bN5YtW0ZOTg5DhgwBYO7cueTl5TF+/HjA3RCfOXMm48aNo1u3bp5Z5sHBwYSHhxMcHEzHjh1r1WjVqhVAnctF5NBcCQnkz5hBTI2NcPNnzGjUhnjNDT0P1pgbeprNNoKCogBqzQi3WhNITExhz57RBAVFYTY3rMlhKirihJvvZOre63hu72XcfPNkbrrpCd5555+89dZU/hn3NJ+dvIAFt73H8jVtWb48hD17LHz9dQhffx3ClCmQkOBg4ED35mbnnVdJRMShX92NDYvgg0te5NrPxpNWnEb/N91rpSdHJPPBJS8SG+bfM/7k6JlMJizmw/9ot5gtaoiLHIWpa6byW/5vGNR+/nXh4rf833hizRP85/z/NEqtwkIT69ZVN8Ct/PRTMCUl5jrHRUc7CQkxyM83U1ZmrjUL3Gw2OOkkO337VnHWWe6PuLgDzXyn08KT4//G8uXX8482jzCk4Cv2Ekcce1na5gKeXD6FdyO38o8X/HszXhERERGRo+EzTfF+/fpRXFzM/Pnzyc/PJykpiYceesizDkx+fj45NRY3XLZsGU6nk1mzZjFr1izP5QMGDODuu+/2+vmLBCpzRgZt77231mVt77230WaKm4qKiBo7FnNuLjkpKRiJBzaLNGdkED16NK6oKHLnzGlwYzwoKJKEhDm4XCV1ZoK7G+OpfzTOG1bHVFLC1L3X8cTeCdx882Ru+dNbnNL7G6ymawB44i33es53n53FsJFmDAN+/93C8uUhrFgRwrffhpCRYWHOHAtz5rTCYjE466yqP5rkFZx00oFZ5E5nEY8/vhKTqYTn7/wnV3x6m+c8nh/wT954diuGkcGjjw5ocC7xD0OThzJ70+x6l1AxY2ZY8rBmOCsR/1JUVcS8bfMAgz8lw7AOYDGDwwWL98E7aQYfbPuAf5z9j2Per8H9nB/kWQblxx+D2brVgmHUfrEqJMRF+/YuXC7Yvz8Iu91ETs6BWeChoQann15F377ujzPOqCIy8tAvoAaZI4j6qhWPhE/m8YInal03sGAllnAD58pIgsx6IVVEREREAp/PNMUBhg0bxrBh9f+xfnCj+7HHHjvm21ezXOTYVDelq9cQt8ydi+OPNcWjR49ulMa4qaQEc26u5zZzU1MhLg5zRgZR1bX/OK4xZosHBUUesjnckCVTaqqMgYyhQdxsnsztg5/g1PsTaPUi9L4fbv+buxGR4WpLZQxYAZMJunRx0KWLg9tuK6W83MS33wazYkUIX34Zys6dFr791t0s//e/I+nQwcnAgZUMHFhBv377MJlKeOONv1FU+SgxJ0F2JcSEwJwZ6cx793FuvfW/uFwlaoq3EJP6TGJV5qo6Sz6YMdO1bVcm9pnYjGcn4h+Kq4pxGQ4MYPFeM8n7z8dVHIc5Yi+LnV9j4MJlOCiuKj5iU7yszMT69e7NMNeuDeann6zk59fdZDkmxklkpIuyMhP79gVRWWkmPf3AbPG2bZ2eBvhZZ1Vx6ql2goOPIZTJxGO257Hs2VPv1Y+XPYGjXSL7TWOP4UZFRERERPyTTzXFRcR3mDMzazXEc1NT6dCnD7mpqUSNGnWgMZ6aWu+yJ0fLFR9fa93yqFGjYO5cog7e0LMBNbzNbLZx+51zcFbuczfE12VA//60Ak79bwK3TH+LoJAOmM2X1vv1YWEGgwZVMmhQJVOmFLFrVxArVoSwfHko33wTzL59QXzwQTgffBCO2dyWk09L5uTTvmTeu48z+gYT9zwSxwtTM5n37uNcc+Oj3PrAWY3W8BffZwu2sfDyhTy19imWpC3xbA44NHkoE/tM9PrmgHJkgbj5jb9nSrAlcNeJwXy07BLSP5zBlKKkA1dGppN01b2MvOgzEmy1Xxg2DNizJ+iPtcDdjfBff7XidNaeBR4cbJCQ4MBqdW+gmZMTRHa2+6NacrJ7PfC+fd1rgp944tHtNXE4lf36ETRvHvXdjAFU9u/fsAIiIiIiIn5CTXERqZdhs+GKisIB7mVN/pgRXnPzTVdUFIat4Q22QNvQs+YyLWWPZtCqxnrsZY/OJPGEhGNapuWEE5yMG1fGuHFlVFbCmjXBrFgRyooVIWzdamXjunbAIABS/u8xUuc4MYwghgx/mS97PMGaz5JIHZ6qzTZbEFuwjSn9pjC1/1RiY2PJysry+yZloCmpKmHa2mksTVvqeeFiSPIQJvWZ5LcvXARSJqeziLbbLyN99ry6VxYlkD47lbYnXENp32J+/bWdZxmUtWuD2b+/7izw6GgHMTEGLhdkZgZRXGxm584D21nWXA+8eiZ4bGzdJZAawpyZSci332LC3QCv2Riv/jxk9WrMmZl+9UK0iIiIiMjxUFNcROplREaSO2eOZwPMmn88uxISyElNbbQNMKtvs6k39PSmoKBIrFnF9a7H7kxJwZVwfN+3kBC44IIqLrigikcegS07y7hzxlxyNpxF5Z7BlJUGYxjuhszST/9C0NIxuDpv4L19Hbmgn5levaoICWlwPPEj2lTT95RUlTBiwYg6S9zM3jSbVZmrWHj5Qr9rIgdapqqqYp5+qnrPmoM3vDQDBlMef58n/2XGbq99vcVikJzsICLCoLTUxO7dFnJyLNTYGofQUBenn27n7LMPrAd+uA2VG4Nhs+GKicGBe8Z4yOrVWFwuHGaz53NXTEyjvNgtIiIiIuLr1BQXkUMyIiMP2fRu7FlkTb2hp7d5Yz12gJ5RDn7e/iFVoS/xwOgJvDn7b5jNDlwuC1ZrJfbK1uRtPp9nN8Oz1N6Y7eyzqzjzzCpsNs0gFvGmaWun1WkeA7hwsT1/O0+tfYop/aY009kdn0DLtHZlB8rKWh/mCBOGYcFud6/13bGjE4sFcnPNpKUF8fvv1lpHt2vn9MwA79u3ilNOOcb1wBtBnRe7TSbiYmPJ/uOdJObMzEZ9sVtERERExJepKS4izc5bDWRv8dZ67ODegNRFDhO63Mabs//GrX9+mmee7c+DD3zDG29OYOSglzlnaxYru93Hmg2R5OYGeTbtBAgKMjjlFLunSd63bxVRUY37ln0RqW1J2pI6zeNqLlwsSVviVw1k8N9MTifs2hXE1q1Wtm61sHWrlW3bLGz/re4SKPVpE+kgP99SZ+PME044sB54376Nsx54Y6jzYneNk9KSKSIiIiLSkqgpLiLNypsNZG/x5nrslTEw+fR7eePNCdx29WSmr3uLVpv689y6GZiuLuL1+VOJ+vPTvPTI71gs8fz+u4U1a4JZsyaY778PJj3dws8/B/Pzz8G8/rr7Nrt2PdAkP+ecKhISnAD8978RmM0G999fUuc8pk+34XKZ+NvfihucqSXQ+t4N48/fP8MwcLgchz3G7rJjGIbfLH3jD5lcLkhPD6rV+N6yxcrvv1uorDz+cyoosmA2G5x8st0zE7wp1gMXEREREZHGpaa4iDQrbzaQAUxFRZ63jh+ssd467s312M1mG4Ypklv//LS7Ib4uA/r3pxUwnbcw/hyJYYrEbLZhMkGXLg66dHEwdmwZABkZZr7/PsTTJN+61cpvv7k/5sxpBUBCgoOzz66iuNjE0qVhADzwQKnnHKZPt/HMM5E8+GBRg/MEMperhJycaZSULGXnThculxmbbQjR0ZMwm7WG75EEyiaOJpMJi/nwv35ZzBa/aYiDb2UyDPdGlu7m94EG+LZtFsrLD14b3C001MWJJzqIjnYREmJQVWUiaz9s+TWYuuuJeyphthbx8muFDOxn1TJUIiIiIiJ+Rk1xEWlW3mwgm4qKiBo7FnNurrsBn5joua56CRdXVBS5c+Y0SmPcG+uxBwVF8uijA3C5Sihb341WNTYqLXt0Jv/snYDZbCMoqP5zSUhwMXJkOSNHlgOQl2fihx8ONMk3bLCSkWHhww8P/Lh45plIPv44jDvugLVrW/PBB+E8+GBRvTPIfV1RVRElVSXE2+qOSWZJJrZgG5HBDb/vuVwl7N49gqqq7VBjiYmCgtmUla2iY8eFaowfRqBt4jg0eSizN82ud7kRM2aGJQ9rhrNqGG9nMgzYt8/Mtm3WOg3wkpL6G9khIQadOjmIi3MQFuZeOiUvz0xamoVNmw61wHd1s7vWTycAZg55leFDb6hxjIiIiIiI+AufaoovXryYBQsWUFBQQGJiIuPGjaNnz571HrtmzRqWLFnCrl27cDgcJCYmMnr0aHr37l3rmI8++oisrCycTiexsbGMGDGCCy64wEuJRORoeKuBbCopwZyb61mSJTc1FeLiMGdkEFW9hMsfx/nTRmNBQZFYs4rr3ajUmZKCK+Hos7RrZzBsWAXDhlUAUFpq4scfrXz/fQjffRfMunXBVFSY2L7dyoQJAOEApKaGs3WrlVNPtXPqqe5N5Nq18+1GUVFVEWM/G0tueS4pw1NIjDjwIklGSQajPx1NVFgUcy6Z0+DGeE7OtDoNcTcXVVXbycl5ivbtfW+9ZV8RaJs4TuoziVWZq+pkMmOma9uuTOwzsRnP7vjc1esulu9Zzq78dIy0/lASB7a9mJK/4YS2HflLr78c923n5prZssU927t67e9t26wUFNTf/LZYDDp3dpCY6CQiwoVhQGGhmfR0i2fZlPp07OigRw87PXo46Np1P21a386sN29jxYrrDjrSzIUXvsepf38Ru30QVqt/LO0lIiIiIiIH+ExTfPXq1cyePZtbb72V7t27s2zZMp588kmmT59OdHR0neM3b95Mr169uP7662nVqhXLly9n2rRpPPnkk3Tq1AkAm83GVVddRXx8PBaLhZ9++omXXnqJyMjIWs1zEWkZXPHxniVZLGlpRI0aBXPnEvXHpp6O5GT3pp5+snZ5tabcqLRVK4MLLqjigguqAKiqgg0brFx1VTROpwn3DEkTu3ZZ2LXLwsKFYZ6vTUpy/NEkd3/06mX3qU08S6pKKKvMprQyndGfjiZ1RCpxxHka4qWVaYSZXZRUlTS4KV5SsoS6DfFqLkpKlqgpfhj+uonjodiCbSy8fCFPrX3Kne2P5WCGJg9lYp+JfjXrHdwvMN3+xe0Urb+I0IX/pjwvynNdaLtcCkc8xO0htx/xBaaCAhPbtlnrNMBzc+vf9NJsNjjhBCedOtlp3drAbDYoLTWTkRHEb7+5G+f1advWSY8eDnr2dDfAe/Sw0727o9YSKE6nnamPjWTFiuv4Z/gjDKr4hqxWJxJb+jtfhvbnieVTeLtTLpMf86+xEhERERERN59pin/66acMGjSIwYMHAzBu3Dh+/vlnlixZwpgxY+ocP27cuFqfjxkzhrVr1/Ljjz96muInn3xyrWMuvfRSVq5cyZYtW9QUF2mhaq5VbklLg/79scCBhvhxNo+bizc3Kq1eauTrr7vhdJoIDoaqKhPjxxfT48xMdm5py7ZfI9i40cquXRbS090fixYdaJTHxTnp1auqVrO8Q4e6zU5vbOrZIczGq2e1JqtkL+PXpTFq4Sjmjp7LmIVjKKtKY+YZFmJtrekQ1rCml3tTyMNvQgj+tbGiN/nDJo7HwxZsY0q/KUztP5XY2FiysrL8dgPRkqoS9v1wJrlvv1LnuvK8tpS//Qqh5jspGex+gam42PTHOt+1G+D79tXf/AZITnZw4okOoqKcWK1QXm5i374gtm2z8MUXYfV+TUiIQbduBxrfPXu6/23f3sWR7irWfSW0/8TOI+GTmRzzLrmpqVx45pns+/FHzh81CnO2gfOTdlj/UoIr3n/eWSQiIiIiIm4+0RR3OBzs2LGDK2ushQvQq1cvtm7delS34XK5KC8vx3aIzfgMw+CXX34hMzOTsWPH1nuM3W7Hbrd7PjeZTISFhXn+39JUZ27q7N6q481ayuTbdYzERAqef57oK67wXFbw/PMYiYk0RdUmzRQRgSs6GgeQm5rqWSfdSEz0NMZd0dEQEdGg+kVVRdzw2Q1sX3A9hZ/3YcKEYp56KoKJE4t5+ukIWl/8KV0uf485f3HPBC0sNLFpk5UNG6xs3Oj+d8eOIPbuDWLv3jAWLz7QxGrf3kmvXnZOOcU9m/zUU+2Yze61y00mk2dTT5PJ9MemnhFMmFDc4O+nYZQSRDHtQxy8eLqF8evS6P9mf2JC4MXTLbQPcRBEMYZRisnU+rjruM+z/hmrB1gxmw+1od/x8+ZzUVMxmUxYzYf//lnNTfP98waTyeT58FcxIRFUfVo9U//gcTADLvI/eJYJO+G330LJyDj0r5/x8U66d7fToYOTsDD3C285OWZ++83C8uUhGEbd75PJZJCc7KzT/O7UyYml3lJH8b2OiOCRE+Zgzsk58NxqMnmeWyf/8dyaF3Gp345dIDw/HEyZ/EOgZQq0PKBM/kKZ/EOgZQq0PKBMLZnJ8IFpSXl5edx5551MnTqV7t27ey7/8MMPWblyJTNmzDjibSxYsICPP/6Y6dOn07r1geZFWVkZd9xxBw6HA7PZzC233MKgQYPqvY158+aRmprq+bxTp05MmzatAclExCelp8PAgbBjx4HLOneGFSsgKam5zur4FRZCcTHU2DjUY88eiIiA1sff1AXYU7SHXtenkL/oftpeOp2f544iqXUS6YXpnDYm1XP5hvdGkxhZz3ngPsX16+Gnn+DHH93/bt4MrnpWxYiJcZ/y9u1w7bXw2GPw/vvw+OMwZQpMntygOB4V2ZtYv/VSKhy7ySiHf2+Bh3pAQhiEWjrSu/siQmNOPvINHcFvv91DRsZM6l9CxUxCwni6dj3yz7qW6p7P7mHmDzNxGfVs4mgyM/6s8cy4RN8/bzIMKChwP8V88kkhkycf23NMXBycdJL7qddmc296mZsLW7bAr79CeXn9XxcTA6eeWvvj5JOhVauGZ6rDC8+tIiIiIiLSPHyqKf7EE0/QrVs3z+UffvghX331Fc8999xhv37VqlW8+uqrTJgwgV69etW6zuVysX//fioqKti4cSPz589nwoQJdZZWgUPPFM/OzsbhONJb3wOPyWTyylu6vVXHm7WUyXfrmDMyPMuKHLz+dvXyI429hEqg3B8efdJg3vb3KDznQZIjk5k7ai5jUseQVpRG6++e4Zou1/P4P47tleiyMhO//mrxzCjfuNG9hrB7vfK62rZ10revnS5dHLU+Wrc+9qymoiLajR1LuWMPy57MISrc6bkutyyIi/4RTZglkbw5cxq88arLVUJa2giqqn6jdmPcTHBwV5KTF2I2N/7axN687zWlkqoSRnwygt/yf6t3Y8qFVyz0q3W4q5ciirfFYzKZ6NChA/v27cMwDDJLMrEF2xq8jn1DuBveJvbuDSIzs/odHmYyMw98nplpprz82GbnDxlSQbdudgoLzezcaWHzZgt5efUvmRIaatC9u/2Ptb8PzACPiWmefQkC5bFUkzL5B2XyfYGWB5TJXyiTfwi0TIGWB5Qp0FgsFmJiYo7u2CY+l6MSGRmJ2WymoKCg1uWFhYW1Zn3XZ/Xq1bzyyis88MADdRriAGazmdjYWABOOOEEMjIy+Pjjj+ttilutVqzW+t+i3dLuRDUZhuGV/N6q481ayuRbdcyZmbUa4vWtvx01alSjrL9dH3+/P0yeWMQtJd259rNk0orcS40AJEck88Gz3Ym3FWEYx9bICwszOPPMKs48s8pzWUUFbN58oEn+3nvhniUT8vODWLw4iMWLa99OTIyTLl3caw537XqgWR4f7+RQq2qYiouZ8tsYQoryuXrqE+z/94Hrek518vzPt1EZ2ZbxxcUYERHHlKtOLVMrOnZcwL59T7N6dSF5eTG0a5dNv36t6dBhAiZTqya9b3jzvtcUWllbseDyBYfcmLKVtWm/f42pqKqIsZ+NJac8m5f69mPHOpfn/tD5dDN3fb+a6LCYI25KebwMA/LzD2541/7/3r1H3/Bu29ZJpM1JWnrwEY9dujSUpUtDa11mMrk3y6y56WWPHnZOOMFJUD398uYeZn9/LNVHmfyDMvm+QMsDyuQvlMk/BFqmQMsDytQS+URT3GKx0LlzZzZs2EDfvn09l2/YsIGzzjrrkF+3atUqXn75Ze69917OOOOMo6plGEat2eAi0nIYNhuuqCgcQE5KCsYfM8Jrbr7piorCOMTeBC2Z01lERsZYnM5cnh/wT6749DbPdc8P+CeOvPFkFEaRkDCHoKCGNfJCQ+HEk3Pp0LWE3NxuGEb1pp4wenQpJ/TIIWNXJLt3hrN9u4WsrCCys90f334bctBtuTjxRCddutg9TfMuXRx07uwgPxLePt3JnpVTSU+AMTzh+brnEv7J60wl8fSnuTISGuMlks8/j+aRR15h794Dnb64OCdTphRy6aUVjVAhcFXPrK5vY8rMkkxcuJp1ZvWxKKkqIac8m91r+nD5lKdxFR5YssncOh3XsHvh7LWUVJUccyZ3w9tMZqb5sA3vioqja3i3a+ckLs5FfLyT2Fgn7do5CQ01MJnA4TBRVmZi//4gMnc62JNuwomFw63XHdPOTo+TXX/M+nY3wbt1cxAWpl/URURERETEu3yiKQ4wfPhwXnjhBTp37ky3bt1YtmwZOTk5DBkyBIC5c+eSl5fH+PHjAXdDfObMmYwbN45u3bp5ZpkHBwcTHh4OwEcffcSJJ55Ihw4dcDgcrFu3jq+++opbb721WTKKSPMyIiPJnTMHU0kJrvj4Wq0bV0ICOampGDZbg5fKCEQuVwlOZy52exoVJX8hJgSyKyEmBCpy/oI9xOE5rqFN8eqZtL8vGHOITT1f4cTL5zJninsmbUmJid9/t7B9+4GP33+3sHOnhYoKM5s2mdm0qfa7gEwmg/iEaMpbV9Ctx7e8Pn8qe7NP4KmsR3j2lFt448MpXHvDo2Rf8CG24BENygOwaFEot9/ets4s16wsM7ff3pbXXstvtMZ4dQO5Q1g8338fTFWV+2dj376V7Ctv/qU5jlVRVRG3LL6OsqocXhv2EYkRiZ4NYzJKMrh98UjCg6OZNex9v8gVb4vnpoq7eWLehDorzLsKE2BeKjed9jTxttovxRgG5OWZ6yxjUrPpnZUVREXF0S1hFBXlJC7OSXy8u/EdHe1ueJvN4HBwoOGdGcSuXUGsXh1MaenxbGbqTnnCZX8h5dnb6uQSERERERFpDj7TFO/Xrx/FxcXMnz+f/Px8kpKSeOihhzzrwOTn55OTk+M5ftmyZTidTmbNmsWsWbM8lw8YMIC7774bgMrKSt544w1yc3MJDg4mISGBv/71r/Tr18+74UTEZxiRkYdsejfFkimBwmqNx9LuRTJ2j6R9iIMXT7cQ3/lFMneMp32Ig/2VFpI7vIjV2vDvYUlVyR8N8b/R+uL/cs1tA4A+XHPbVl7buJLCz//G70DJYPdMWpvN4LTT7Jx2Wu13ATkckJ4e5GmSb99u4bffrGzfbqGgwEzGnmDYcx55fxz/6Ve38Cm3wDaw2QrYvGEQsftP48WfW5OUFEZCgruBmJDgJCLi6Ge2Op1w//1t/miI125YupeFMbj//jYMG5ZV73IRx6L6BYX0NX0wLX6e/VnVM+ejaB9biTHscZLOXttkS3M0heKKLG5O2ExYUBW3f3Y1d0YtJTIojiJnEa/kXs2D3TIod2ZTXJHlF5mqqop49bmxf3x2cJPZDLh47t+3k5PuYv/+sBozvIOorDy6hnd0dO2Gd0yMk/BwA7PZwOk01Wp479lj4fvvgygoOLqGd5s27pnjNT/ati/h/YyHOLMsnLlv/4eysgNL34WHF3HXfX/mp+St2ILvP6oaIiIiIiIiTc1nmuIAw4YNY9iwYfVeV93orvbYY48d8fauu+46rrvuusY4NRGRFi2zJJNbP7wLU6mDfw6w0D7EgSPjTtqHwP5KC0+sdGC0uou3Rn/Y4Jmg8bZ4Rp94FZ9e+jRZfScyamEyc0fPZczCMRSek0as2cXwTqOIt4Uc9nYsFujUyUmnTk6GDKn0XF4943br1kp+/PFddu6IoeDzLiwuGkR107qkpA0bNgxgwwZYsqTubUdGumo1yQ/+6NDBieWPn7Br1gRTUnK4hqOJkhIT553XnoQEJ23auP74MGjd2lXjcxdt2x643GZzL2NRU0lVCft+OJPst1+uU2V/lhXefplg852eFxT8QfswG10joli58hx2vzCDO3OqlxvpTrvob/j9r/cyYMB3tA/z3rJHhuGeSV1a6h479//NlJS4LystNf/x74HPq49LT48kO/tw52qmpKQtr7xS/7UxMTUb3k46dHDRqpWLoCD3C0Hl5Qca3pmZQfz0UzDZ2Uf3akurVgfu1zU/quvFx7sID6/7gpDdnsm56ct5680/UVbWmptCZnFx5TI+D7mId8puIXfvyTx2yVrCTCWAf9zvREREREQksPlUU1xERHxTZIXBnFl5tC6ykDP0SYqZ6LnuxJAnWfjaPyiMzCN0hAEN7E06nUXccsNYbrDv4/71CazLO7Cp5+ntEpj+9xmEWN/H6Ty+9ctNJoiKctGvn5VzO/anzR038mzRzSxmMMFWF1V2M7fyGv2T17N9xANklsaSkRFERoaFjAz3jNqiIvfH5s31b85sNht06OBuMB7tvia7d1vYvfvofyxbLDWb5gZt2riIiGjFvk9fxN3cP3hWsXsWcs7c59hxcTZ7w6xYrRAUZNT7r8XirlHz30NtWtqUgstt7Bl/DY/+8myd6/JyEnj00VT+75QH6JZiw6hnOAwDKiuhrMzsaWIfrnFdWupuXpeUmGv8v/bxZWUmz+avTWVA/xL6D3AREeFueDuddRveGzZY2bcvCKfzyOcSEmLUaG7X/xEZWfeFlqNhNtt49+2/89ZbdzE5fDJTytzr819f+T7J4buY+tZULEFxTH5E+zWIiIiIiIhvUFNcRESOKLLKxAnOdrjM6ezd/w9of+A6+/5/0MHsIM4ZR16Vqc46yceqev1yw5nB06d14PrVB9Yvf/o0B4ZzH06zpcHrl5szM4m+5mb+nXYzjzCViXdkMO2VBCbdmcFTr95Ox7TJPLbwInJSU2strVNaaiIzM+iPRnntj+pmpd1u8ix5cbS6dq+gQ4y7GV3dmHQ63RuMlpebKCszU1jo/qisNOFwmMjNDSI3t2aN0COlprIynGuvTT76b1TNrzbX30A/8C9YrcYx/lu3+V7z36BSFzN+mcahG/0G4355mkG3l1DqCq/T6C4tdX+vmoLJZNCqVc0P9wz+8HD35zabe2a1zeb+PDTUxZ4t5bw6J+6It71lazDf/mClqurI526xGMTG1tfoPrDUSbt2ruNqeB+NoKBI2q1pxyPhk3m87Ila100pewJTOFR+f0qD9xsQERERERFpLGqKi4jIEbni49k37yUy0kZS0d5B6H4LPeNfZHPmeCraO1j/ooWE5JcIaoR12a3WeBITU9i1eyRBzgymnwb/3gIP9YAg1z5MQQkkJqY0eP1yw2bjiapJPM5fmHDHHu571N1cvu9RMwZ7eOTVqTir4rnDVnt2a6tWBl27Ouja1VHv7bpckJ1t9jTON/1eygvPtcWoakXdpu4Bv20N5bethz/n4GCDdu1cf8wKdzdcw8IMT2N5z54gfvjh8MvKgHsJjrAwA7vdhNMJdjs4naZa/9Y3E9rlMlFZyWFzNL4jNVJNOLCy5Ou2R7yl0FDXQU3sA43r6v9XXx4aamC1umdpBwW5Z8kbRvWH6Y8XLA7MHD94JvnevWZKSy2eZVbcl5uBNkeVel9OsDudyaB9e9dBy5gcWLonPt5JTIyrwevRN4Q5M5N//3oDJqez3usfL3sCY1MQ+zK/094NIiIiIiLiE9QUFxGRI7LbM9njGI/9j4Z47/EOQrPvpHcMrH/RQkV7B7sd40m0pzbKZpu5OSU8+ZWDm86AhDB48XT35Rnl8M5PDv59cQmxR55se1hGZCTFV41mgiOD+x6pvS6I+/MMii2jMSKrjul2zWbo0MFFhw4uTj/dznCCiE/Yyd/vPRkwqL25onte/Zhxezi5ayT5+Wby8ur7CKKiwkRVlYmsrCCyshrYATXcs7TDwlxYre6menCwe3Z2cLDhuSwoyH3ZgX+rP9zLbAQFuZu27n/d2U0mA7PZhMl0YCkOk8ndTK7+t8Zp1Gk0u1zVzXmw2038/nsQ3357pBnwcPXVpfTubf/jHA7UcrkO3FZFRd3mdWmpiX37gmo1r0tLzVRUNGHj3+QCz4sONesYgEHMhe/x7J3n0TU5lA4dnAQHN92pNAajVSv34B+iKQ6A2ew+TkRERERExAeoKS4iIkdkNtsICooCoGPoPwnNvg2A0GzoGPoyO61PEBQUhdnc8DWD9+3dBldfzEtFVfzjH9H8pU+O57oFm6J56b/7KHz9YvbNX0yHuG4NqvW3f1RxqFnP9z1iAo6tIV4fp7OIAX3HMWjQZL788sqDrjUzaNDH/PWOqSQkHH6N9PJyU61GeW5uPc3zvXZ++CkMB5ZD5gLIzrGQnXPIq5uVuzlvEBzsXmLF4Ty6BXnmz2/F/PmNfz5BQUaNJVHcM8mrZ5bX/Lx6iZTw8Nqz0Q/+vFUrg3LXFj76YC7/+fczlJW19tQKDy/k7w9N4KrrxtA23AocpsnsQ4zWrXHGxGDJzDzkMc6YGIzWrQ95vYiIiIiIiDepKS4iIkcUFBRJQsIcyNxO+3vG17qu/T1P4PzgRYjv0ihrBkdUQWgpRFvgvqR8Kmtcd19SPgkWCCmFiob3q73C5Sph1hvX8+WXV3LTzU/xiWURhXlxtG63lyscl/LOWxOZ9cZ2/jn58Gukh4UZJCS4l8w4lMySTMY+/Cq/pb6KcYhZ6R0veoIpd4ymtSWGqipwOExUVblnUtvtNf/vXh7k4Muqjztw/YHjal7m/joTDkfdy2r+/2BVVe7Ly8qqLzn6WfHBwbWb1wca2LWb2e4GtqtGc7v+5nV4uIuQEBp1LW67PZPCPTezc8eNlJW15qaQWVxcuYzPQy7inbJb2LkjloJ9N2NLbJx3XXhLxcUX02r2bEyuui9iGGYzFZdc0gxnJSIiIiIiUj81xUVE5KhYs4qJvnY8lrQ0HMnJWObOxTFmDJa0NOKuHU9OSgquhIY3xcOTu1H08Tuk7xlLZQdn7fXLOzhY90IQbRPfITK5YbPEvSW43Eb0F+HcNvpRxtw0haHlB9ZITwhbSUhJKVFfdCD4QRuGtWG1bME2Eod+R8z+eXzz1XUHXWum/wXvE3JNCmf3uYbI4OZ/VcEwwOHgkI33qiqoqCjjk4/e4Y03//nHV9Vt9P994nhuvf0ewsJ8fyNHs9nG228+yFtvjeeR8MlMjnkXy5w5jB47lhOydzHlralYTB2Y/FjD33XhTcWTJhGyahWW7dtrNcYNsxlH164UT5zYjGcnIiIiIiJSm5riIiJyRObMTKJHj/Y0xHNTU+nQpw+5qalEjRqFJS2N6NGjyUlNbfBGenZ7JrlMwv5HQ7zO+uUdHOQyibBGWr+8qZlKSnjU+SSsyOCHqyAh9sAa6UFZ8PyKKRCaQEFJX4zIhjV1w0wldFrzJ2Z9dR033ziV6xZ8QW5hHFGt9/L+5YN5693J3NJ1D2FDSzjyBpZNz2QCq9W9TEp4OLjX1K7NnJnDRd+8RmFwV1Kqrj/4WkYHv8ejnyygYPSfcflBU9y6r4T2n9h5JHwyjwbNwFVlg2uvBZeLR4NmQDg4P2mH9S8luOJ9P081w2YjZ+FCIp56itAlS7C4XDjMZiqGDqV44kQMm381+UVEREREJLD5VFN88eLFLFiwgIKCAhITExk3bhw9e/as99g1a9awZMkSdu3ahcPhIDExkdGjR9O7d2/PMcuWLeOrr74iPT0dgM6dO3P99dfTpUsXb8QREQkYhs2GKyoKB5CTkoKRkACAKyGBnJQUokePxhUV1SiNL2+uX+4NeyJh5J/g/2ZCrydg3YsHruv1BGQ44IY/wQuR0NAWv9lswzBs/Hnco/x37RTaFP5xRSH0XbcS0zgHhhHnN987cN/3/lP0MClV13PX2Hn0ODuVvLwY2rXLZsuaUbw053pOKirgDj9puho2G48kvYN10yYod2ApLgbcv5AZJhOPWaZh73YyuTb/W27EsNkomjKF4qlTiYuNJTsrC8Oo+0KHiIiIiIhIc/OZpvjq1auZPXs2t956K927d2fZsmU8+eSTTJ8+nejo6DrHb968mV69enH99dfTqlUrli9fzrRp03jyySfp1KkTAL/++iv9+/ene/fuWK1WPvnkE5544gmeffZZ2rVr5+2IIiJ+y4iMJHfOHEwlJbji42tt4ehKSCAnNRXDZmvwTGfw7vrl3mALtlEV34G7H3DwaNccam6e+OvkIB7/LZqqqA7Yghve1A0KiuS+0YtJmvAxbX6B8njY/BD0/De0+QX+yxTSnx5JUNDlDa7lLUZkJMVXjWaCI4P7HjkPk+l8YmNjycrKwrjaoJUtg2LLaIzI5l8O5mgYkZFUnXIK1p9/xnRQw9hkGBgOB1Wnntooj6Vm1ZgLsYuIiIiIiDQy85EP8Y5PP/2UQYMGMXjwYM8s8ejoaJYsWVLv8ePGjeOKK66gS5cuxMXFMWbMGOLi4vjxxx89x9xzzz0MGzaME044gYSEBO68804Mw2Djxo3eiiUiEjCMyMhDLo3iio9v1CaeNauYuBrrl/PNN+51zP9Yv9yaVdxotZpaZHAk7wx5hocGWNxrpGfA6eMhNAMqOzh5aICFd4Y8Q2Rww79/5sxMutyy0NMQXz8dik5x/1se726Md7llAebMzEZI5j1/+0cV9z1yoMlqqtFwve8RE3/7h380xKuFrlhRpyFezWQYhK5Y4d0TEhERERERaWF8Yqa4w+Fgx44dXHnllbUu79WrF1u3bj2q23C5XJSXl2M7zNunKysrcTgchzzGbrdjt9s9n5tMJsLCwjz/b2mqMzd1dm/V8WYtZfL9Ot6spUzHxpyZSVSN9cvz5s+n/Zlnkjd/Pu2uvtqzfnnu/PkNXr+8pqbKZLdnUrDvZgxnhnuN9PsdhGZD7/v/WCO9fQYF+24mIml+g9dIN2w27G3NgJP106Gyvfvyyvbuxnjv+8He1oxhs/ntzzVvPp6ahGFgcjgOe4jJbne/G8NPM/r9GNVDmfyDMvmHQMsUaHlAmfyFMvmHQMsUaHlAmVoyn2iKFxUV4XK5aN26da3LW7duTUFBwVHdxqeffkplZSXnnnvuIY+ZM2cO7dq149RTT633+o8++ojU1FTP5506dWLatGnExMQc1TkEqtjY2ICq481ayuT7dbxZS5mOUng4xMVBUBCWFSton5QEQPszz4Svv4aBA7G0b0+HLl3goJ8bjaGxMzkc4eRkRBG0P8O9aWhEZ/j4XUJvvJHe43ew/kULwUlRxMd3wWJpYJ64OL6fHoezYDeVB/3oqmwP65+DoDZx9O3Ro2F1fIA3H0+NLjT0sFcHhYYS14gv+DQXvx6jQ1Am/6BM/iHQMgVaHlAmf6FM/iHQMgVaHlCmlsgnmuLV6nsF42he1Vi1ahUpKSlMmDChTmO92ieffMI333zDY489RnBwcL3HjBw5kuHDh9epnZ2djeMIs7oCkclkOrBuaxNulOWtOt6spUy+X8ebtZTpOG5/9mz3+uUWC6asrAO1LBbM8+a51y8vK4Oyssar2USZzJmZnPTnbMhxYGmVzP5582h/5pnsnzePdldfTe+70yA6m9z/294oM9+DY4ZQYH0LcNW5rjLGTJs2Q9i7d2+D6zQXk8lEbIcOZO3b57ebOEYOHkz4W29hctUdI8NspmzwYIr8fYy89JznLcrkH5TJPwRapkDLA8rkL5TJPwRapkDLA8oUaCwWy1FPbvaJpnhkZCRms7nOrPDCwsJDNrmrrV69mldeeYUHHniAXr161XvMggUL+Oijj5g8eTLJycmHvC2r1YrVaq33upZ2J6rJMAyv5PdWHW/WUibfr+PNWsp0DLcbEQEREVDjtqtrOePiqi9o9Lo16zQWV6tWmMNjMLcyk5OSgvFH49sZH09OSgrRo0fjCo/C1apVo9SNjp5IWdnXVFVtp3Zj3ExwcFeioyf65c80U0kJEdOmEbp0KbhcRJvNVAwZQvGkSRiHWTrNFxVNnEjw119j2b69VmPcMJtxdO1K0UT/HKODefM5z1uUyT8ok38ItEyBlgeUyV8ok38ItEyBlgeUqSXyiaa4xWKhc+fObNiwgb59+3ou37BhA2edddYhv27VqlW8/PLL3HvvvZxxxhn1HrNgwQLmz5/Pww8/zIknntjo5y4iInI4RmQkuXPmuGe+x8dT8/1ProQEclJT3TPfG2mjUrPZRseOC8nJeYqSkiWYzS5cLjM221CioydiNvtXAxncDfHoESNqNZEtQKvZswlZtYqchQv9qjFu2GzkLFxIxFNPEbpkCRaXC4fZTMXQoRRPnOhXWURERERERPyRTzTFAYYPH84LL7xA586d6datG8uWLSMnJ4chQ4YAMHfuXPLy8hg/fjzgbojPnDmTcePG0a1bN88s8+DgYMLDwwH3kikffPAB99xzD+3bt/ccExoaSugR1vMUERFpLEZk5CGb3o25WWg1s9lG+/ZT6NBhakC8bS5i2rQ6s6oBTC4Xlu3biXjqKYqmTGmmszs+hs1G0ZQpFE+dSlxsLNl+PkYiIiIiIiL+xGea4v369aO4uJj58+eTn59PUlISDz30kGcdmPz8fHJycjzHL1u2DKfTyaxZs5g1a5bn8gEDBnD33XcDsGTJEhwOB88++2ytWqNGjeKaa67xQioREZHmFQg7jocuWVLv+tvgboyHLlnid03xWgJgjERERERERPyJzzTFAYYNG8awYcPqva660V3tscceO+LtzZw5szFOS0RERJqLYcCRNru2293HqbksIiIiIiIiR8Hc3CcgIiIickgmE1iO8Bq+xaKGuIiIiIiIiBw1NcVFRETEp1UMHYphrv9XFsNspuIQ7zITERERERERqY+a4iIiIuLTiidNwtGlS53GuGE24+jaleKJE5vpzERERERERMQfqSkuIiIiPs2w2chZuJDSm2/GkZQECQk4kpIovflmchYswLDZmvsURURERERExI/41EabIiIiIvUxbDaKpkyheOpU4mJjyc7KwjCM5j4tERERERER8UOaKS4iIiL+RZtqioiIiIiISAOoKS4iIiIiIiIiIiIiLYaa4iIiIiIiIiIiIiLSYvjUmuKLFy9mwYIFFBQUkJiYyLhx4+jZs2e9x65Zs4YlS5awa9cuHA4HiYmJjB49mt69e3uOSU9P54MPPmDnzp1kZ2fzpz/9icsuu8xLaURERERERERERETE1/jMTPHVq1cze/ZsrrrqKqZNm0bPnj158sknycnJqff4zZs306tXLx566CH+85//cPLJJzNt2jR27tzpOaayspIOHTowZswY2rRp46UkIiIiIiIiIiIiIuKrfGam+KeffsqgQYMYPHgwAOPGjePnn39myZIljBkzps7x48aNq/X5mDFjWLt2LT/++COdOnUCoEuXLnTp0gWAuXPnNm0AEREREREREREREfF5PtEUdzgc7NixgyuvvLLW5b169WLr1q1HdRsul4vy8nJsNttxn4fdbsdut3s+N5lMhIWFef7f0lRnburs3qrjzVrK5Pt1vFlLmfyjVqDV8XYtbwm0TIGWB5TJXyiTf1Am3xdoeUCZ/IUy+YdAyxRoeUCZWjKfaIoXFRXhcrlo3bp1rctbt25NQUHBUd3Gp59+SmVlJeeee+5xn8dHH31Eamqq5/NOnToxbdo0YmJijvs2A0FsbGxA1fFmLWXy/TrerKVM/lEr0Op4u5a3BFqmQMsDyuQvlMk/KJPvC7Q8oEz+Qpn8Q6BlCrQ8oEwtkU80xavV9wrG0byqsWrVKlJSUpgwYUKdxvqxGDlyJMOHD69TOzs7G4fDcdy3669MJhOxsbFkZWVhGIbf1/FmLWXy/TrerKVM/lEr0Op4u5a3BFqmQMsDyuQvlMk/KJPvC7Q8oEz+Qpn8Q6BlCrQ8oEyBxmKxHPXkZp9oikdGRmI2m+vMCi8sLDxik3v16tW88sorPPDAA/Tq1atB52G1WrFarfVe19LuRDUZhuGV/N6q481ayuT7dbxZS5n8o1ag1fF2LW8JtEyBlgeUyV8ok39QJt8XaHlAmfyFMvmHQMsUaHlAmVoic3OfALi7+J07d2bDhg21Lt+wYQPdu3c/5NetWrWKmTNncs8993DGGWc09WmKiIiIiIiIiIiIiJ/ziZniAMOHD+eFF16gc+fOdOvWjWXLlpGTk8OQIUMAmDt3Lnl5eYwfPx440BAfN24c3bp188wyDw4OJjw8HHBv4Llnzx7P//Py8ti1axehoaFaV0dERERERERERESkBfKZpni/fv0oLi5m/vz55Ofnk5SUxEMPPeRZByY/P5+cnBzP8cuWLcPpdDJr1ixmzZrluXzAgAHcfffdAOTl5TFx4kTPdQsXLmThwoWcdNJJPPbYY94JJiIiIiIiIiIiIiI+w2ea4gDDhg1j2LBh9V5X3eiudjRN7fbt2zNv3rzGODURERERERERERERCQA+saa4iIiIiIiIiIiIiIg3qCkuIiIiIiIiIiIiIi2GmuIiIiIiIiIiIiIi0mKoKS4iIiIiIiIiIiIiLYaa4iIiIiIiIiIiIiLSYqgpLiIiIiIiIiIiIiIthpriIiIiIiIiIiIiItJiqCkuIiISyAyjuc9ARERERERExKdYmvsEREREpHGZSkqImDaN0KVLweUixmymYsgQiidNwrDZmvv0RERERERERJqVTzXFFy9ezIIFCygoKCAxMZFx48bRs2fPeo9ds2YNS5YsYdeuXTgcDhITExk9ejS9e/euddx3333HBx98wL59++jQoQPXX389ffv29UIaERER7zOVlBA9YgSW7dsxuVyA+4d9q9mzCVm1ipyFC9UYFxERERERkRbNZ5ZPWb16NbNnz+aqq65i2rRp9OzZkyeffJKcnJx6j9+8eTO9evXioYce4j//+Q8nn3wy06ZNY+fOnZ5jtm3bxnPPPccFF1zA008/zQUXXMD06dP57bffvBVLRETEqyKmTavVEK9mcrmwbN9OxFNPNdOZiYiIiIiIiPgGn2mKf/rppwwaNIjBgwd7ZolHR0ezZMmSeo8fN24cV1xxBV26dCEuLo4xY8YQFxfHjz/+6Dnmf//7H7169WLkyJEkJCQwcuRITjnlFP73v/95K5aIiIhXhS5ZUqchXs3kchF6iJ+rIiIiIiIiIi2FTyyf4nA42LFjB1deeWWty3v16sXWrVuP6jZcLhfl5eXYarwlfNu2bVx22WW1jjvttNNYtGhRvbdht9ux2+2ez00mE2FhYZ7/tzTVmZs6u7fqeLOWMvl+HW/WUib/qBUQdQwDk8Nx+Pp2Oyb3CTR+fS/w5n3PGwItDyiTv1Am/6BMvi/Q8oAy+Qtl8g+BlinQ8oAytWQ+0RQvKirC5XLRunXrWpe3bt2agoKCo7qNTz/9lMrKSs4991zPZQUFBbRp06bWcW3atDnkbX700UekpqZ6Pu/UqRPTpk0jJibmqM4hUMXGxgZUHW/WUibfr+PNWsrkH7X8vk5o6GGvDgoNJS4+vmlqe5E373veEGh5QJn8hTL5B2XyfYGWB5TJXyiTfwi0TIGWB5SpJfKJpni1+l7BOJpXNVatWkVKSgoTJkyo01g/mGEYh7zNkSNHMnz48Dq1s7OzcRxh5l0gMplMxMbGkpWVhWEYfl/Hm7WUyffreLOWMvlHrUCpEzl4MOFvvVXvEiqG2UzZ4MEU7d3b6HW9xZv3PW8ItDygTP5CmfyDMvm+QMsDyuQvlMk/BFqmQMsDyhRoLBbLUU9u9ommeGRkJGazuc4M7sLCwiM2uVevXs0rr7zCAw88QK9evWpdV9+s8MPdptVqxWq11ntdS7sT1WQYhlfye6uON2spk+/X8WYtZfKPWv5ep2jiRIK//rrOZpuG2Yyja1eKJk4MiJ9p3rzveUOg5QFl8hfK5B+UyfcFWh5QJn+hTP4h0DIFWh5QppbIJzbatFgsdO7cmQ0bNtS6fMOGDXTv3v2QX7dq1SpmzpzJPffcwxlnnFHn+m7durFx48Y6t9mtW7fGOXEREREfY9hs5CxcSOnNN+NISoKEBBxJSZTefDM5CxZg1Nh7Q0RERERERKQl8ommOMDw4cP54osv+PLLL9mzZw+zZ88mJyeHIUOGADB37lxefPFFz/HVDfGbbrqJbt26UVBQQEFBAWVlZZ5jLr30Un7++Wc+/vhjMjIy+Pjjj9m4cWOdzTdFREQCiWGzUTRlCtlr1kB6Otlr1lA0ZYoa4iIiIiIiIiL4yPIpAP369aO4uJj58+eTn59PUlISDz30kGcdmPz8fHJycjzHL1u2DKfTyaxZs5g1a5bn8gEDBnD33XcD0L17d+677z7ef/99PvjgA2JjY7nvvvvo2rWrd8OJiIg0F+04LiIiIiIiIlKLzzTFAYYNG8awYcPqva660V3tscceO6rbPOecczjnnHMaemoiIiIiIiIiIiIiEgB8ZvkUEREREREREREREZGmpqa4iIiIiIiIiIiIiLQYaoqLiIiIiIiIiIiISIuhpriIiIiIiIiIiIiItBhqiouIiIiIiIiIiIhIi6GmuIiIiIiIiIiIiIi0GGqKi4iIiIiIiIiIiEiLoaa4iIiIiIiIiIiIiLQYaoqLiIiIiIiIiIiISIuhpriIiIiIiIiIiIiItBhqiouIiIiIiIiIiIhIi6GmuIiIiIiIiIiIiIi0GGqKi4iIiIiIiIiIiEiLoaa4iIiIiIiIiIiIiLQYaoqLiIiIiIiIiIiISIuhpriIiIiIiIiIiIiItBhqiouIiIiIiIiIiIhIi6GmuIiIiIiIiIiIiIi0GGqKi4iIiIiIiIiIiEiLoaa4iIiIiIiIiIiIiLQYaoqLiIiIiIiIiIiISIuhpriIiIiIiIiIiIiItBhqiouIiIiIiIiIiIhIi6GmuIiIiIiIiIiIiIi0GGqKi4iIiIiIiIiIiEiLoaa4iIiIiIiIiIiIiLQYaoqLiIiIiIiIiIiISIuhpriIiIiIiIiIiIiItBhqiouIiIiIiIiIiIhIi6GmuIiIiIiIiIiIiIi0GGqKi4iIiIiIiIiIiEiLoaa4iIiIiIiIiIiIiLQYaoqLiIh4m2E09xmIiIiIiIiItFiW5j4BERGRlsBUUkLEtGmELl0KLhcxZjMVQ4ZQPGkShs3W3KcnIiIiIiIi0mKoKS4iItLETCUlRI8YgWX7dkwuF+D+Adxq9mxCVq0iZ+FCNcZFREREREREvETLp4iIiDSxiGnTajXEq5lcLizbtxPx1FPNdGYiIiIiIiIiLY+a4iIiIk0sdMmSOg3xaiaXi9AlS7x8RiIiIiIiIiItl5riIiIiTckwwOE4/DF2uzbfFBEREREREfESNcVFRESakskEliNs4WGxuI8TERERERERkSanpriIiEgTqxg6FMNc/49cw2ymYtgwL5+RiIiIiIiISMulpriIiEgTK540CUeXLnUa44bZjKNrV4onTmymMxMRERERERFpedQUFxERaWKGzUbOwoWU3nwzjqQkSEjAkZRE6c03k7NgAYbN1tynKCIiIiIiItJiHGGRUxEREWkMhs1G0ZQpFE+dSlxsLNlZWRjaXFNERERERETE6zRTXERExNu0qaaIiIiIiIhIs1FTXERERERERERERERaDDXFRURERERERERERKTFUFNcRERERERERERERFoMNcVFREREREREREREpMVQU1xEREREREREREREWgw1xUVERERERERERESkxVBTXERERERERERERERaDDXFRURERERERERERKTFUFNcRERERERERERERFoMNcVFREREREREREREpMVQU1xEREREREREREREWgw1xUVERERERERERESkxVBTXERERERERERERERaDEtzn4A/sFha9rfJW/m9+X1WJtVpjlrK5B+1Aq2Ot2t5S6BlCrQ8oEz+Qpn8gzL5vkDLA8rkL5TJPwRapkDLA8oUKI4ls8kwDKMJz0VERERERERERERExGdo+RQ5pPLyciZNmkR5eXlA1PFmLWXy/TrerKVM/lEr0Op4u5a3BFqmQMsDyuQvlMk/KJPvC7Q8oEz+Qpn8Q6BlCrQ8oEwtmZrickiGYbBz506a+s0E3qrjzVrK5Pt1vFlLmfyjVqDV8XYtbwm0TIGWB5TJXyiTf1Am3xdoeUCZ/IUy+YdAyxRoeUCZWjI1xUVERERERERERESkxVBTXERERERERERERERaDDXF5ZCsViujRo3CarUGRB1v1lIm36/jzVrK5B+1Aq2Ot2t5S6BlCrQ8oEz+Qpn8gzL5vkDLA8rkL5TJPwRapkDLA8rUkpkMLTAjIiIiIiIiIiIiIi2EZoqLiIiIiIiIiIiISIuhpriIiIiIiIiIiIiItBhqiouIiIiIiIiIiIhIi6GmuIiIiIiIiIiIiIi0GGqKS70qKytVx8drKZPv1/FmLWXyj1qBVseblMk/KJN/CLRMgZYHlMlfKJN/UCbfF2h5QJn8hTK1bGqKSy0Oh4PXXnuNN954g/z8fNXxwVrK5Pt1vFlLmfyjVqDV8SZl8g/K5B8CLVOg5QFl8heBmMkwDH755Rfeffdd8vLymvt0GoUy+b5AywPK5C+USUBNcTmIxWLhrLPOoqqqitdee011fLCWMvl+HW/WUib/qBVodbxJmfyDMvmHQMsUaHlAmfxFIGYymUxER0dTUlKiTD4s0DIFWh5QJn+hTAJqigvuV5NqOv300xk7dizbt29nw4YNquMDtZTJ9+t4s5Yy+UetQKvjTcrkH5TJPwRapkDLA8rkLwIxUzWHwwFAbGwsN9xwA9u3b2fdunXNfFYNo0y+L9DygDL5C2WSamqKt2BVVVWA+9Wkai6XC6fTSfv27enVqxdr165VnWaspUy+X8ebtZTJP2oFWh1vUib/oEz+IdAyBVoeUCZ/EYiZSkpKPP93Op2kpKSwadMmAKKjoznvvPNYvnx5c53ecVEm3xdoeUCZ/IUyyaFYmvsExPtcLhf/+te/yM7O5rTTTqNLly706NGDDh06YDYfeJ0kLS2NCy+8UHWUya8y6XunTIGeyZvfO29RJmVqLsrk+5kCLQ8okzI1H8MwWLRoEbm5uYwZMwaLxUJQUBCVlZW88sorvPDCCwDk5ubSpk0bDMOo9WKAL1Im388UaHlAmQI1k8vlqvX87osCMVNzUlO8BTKbzcTFxfHLL78QEhJCamoqFRUVxMfHEx0dTVxcHD/99BM5OTl07949oOp069btuOt4s1ZLz+QP9ztlUqZAr+NNyqRMzUWZfD9ToOUBZVKm5mMymSgrKyM9PR2LxYJhGBiGwdChQ/niiy945plnyMrKIisrizvuuMPnG17QsjPt27eP22+/3eczBVoeUKZAzeQPzeNAzNScTMbBi6NJi1BVVcXNN9/MpEmT6NWrFzt27GD37t1s3bqV3bt3k5iYyJAhQ+jSpYvqKJPfZdL3TpkCPZM3v3feokz+QZn8Q6BlOtY8/jB7rSVmSkhIYOjQocrUzKqqqrjtttv4y1/+wjnnnAPArl27eOGFF7jpppv48ccfOemkkzzXge/nakmZXnzxRW688UZ++uknunfvTr9+/XC5XJSVlWGz2Zr5rA8t0PLAsWUqKSmhrKyM9u3bN/NZH15Lz+R0OsnOziY2NraZz/rwAjFTc1FTvAX7+OOPWbp0KTNnzjzisfn5+bRq1Yrg4GC/r+NwONixYweJiYmEh4cfcx1v1mrJmQB2795Nu3btjusXIm/V8WYtX83UEN6q481avlhn27ZtdOjQgdatWzfpOTVUS8/kL1p6pmXLltG1a1eSk5O9cGbHL9AytfT7nb9QJv/w+eefs3TpUi677DLatGnDV199RUFBAf/85z+xWCzY7XbWrVtHeXk5SUlJxMfHExoa2tynfVgtJVN+fj7//Oc/sVqtnuO++eYb0tPTGTJkCFFRUc14xocXaHng6DJVVVXx1FNPYTKZuOWWW3y+OdlSMwGsWrWK1atXc+ONNxIXF9eMZ3xkgZipOWgefQt25ZVXUlVVRUpKCoDnbRfgXkOv2p49e/jss89YtGhRQNT56quveP3115k7d+5x1fFmrZacKTMzk2XLlvHuu+/6dB1v1mrOTDVvvyan0+k5F1+u481azVWn5v2h2t69e/nwww959dVXeemll46rjje1lEwH3ye2b9/Ob7/9xu7du5vjFI9ZS8lU3/MrwJYtW5g+fbrXz/FYBVqmw93vqp9Pf/vtN1566SU++OAD1q9f31ynetRaSqaaz+NVVVV88sknTJo0iZdffpk1a9Y016ketUDMdPHFF9O/f38WLlzIyy+/THZ2NpdddhmlpaXMmzePO++8k1dffZV58+Yxffp03njjjeY+5SMK9EyvvPIKubm5XHLJJbUaXgARERGkpaXx1ltvNdOZHp1AywN173cHZzIMg+DgYK677jqioqJ4+eWXm/mMjyzQMx3uvtejRw8iIyN55ZVXmulMj14gZmoOWlO8hfvrX//KmjVrcDgcWCwH7g411x2KjY2lXbt2LFq0iPj4ePr27euzdcaPH3/IOtVvkRswYADx8fHMmDGDk046iX79+h1zHW/WCsRMR3N/iIuLY+DAgUybNo3Vq1f7dJ2Wkslut5Obm4vD4SA8PJzw8HBCQ0PrnIuv1gnETIe6P7hcLn766ScWL15MRUUFXbt2ZcWKFXz99decf/75x13PGwI9k9ls9jxet23bxvz589m+fTvx8fHs3r2bc889l4EDB9KjR49mPuvDC/RMh3p+Bbj11lu5++67/e6+FwiZDnW/CwoKoqKignfeeYfw8HAyMzP57rvvqKqqOq7fJ70p0DPVvN9VVlby9NNPs337di666CJyc3N57733MAyj1rIWvigQM1111VUMHDiQsrIy2rVrR3Z2NlOmTCEvL48rrriC/v37A1BSUsITTzzBd999p0zN4KqrrmLAgAGUlpZiNptJTEz0XFe9gV6vXr1IT0/nnXfeYcOGDfTq1asZz/jwAi0PHMhUXl6OYRgkJSV5rqteoqdLly5ER0fz0EMP8dNPP3HGGWc01+kelUDNdMEFF1BeXo7JZPLc9wzDID8/n3bt2hEdHc3YsWN58MEH+f77733+520gZvI2LZ8iFBQU0KZNm3qvq26EpqWlMWXKFGw2GzNmzPCrOofabffzzz/niy++4Omnnz6uOt6s1RIyVSsqKsLlcnmuW7p0KQsXLuT555/36TrerOXNTIWFhZ7lKfbs2cOLL75Ibm4uXbt2JSMjg/bt22M2mznxxBMxm82MGjXKp+sEYqZD3R9+/vln5syZQ2JiIvfccw9ffvklc+bMYdasWcdVx5sCMVPN+4NhGMyePZvPP/8cgAsvvJC+fftywgkn8PHHH7Nu3TrPzvG+LNAz1VT9e0p1Q2zp0qW8//77fnffq8lfM9XMU1payvz584mIiCAhIYFPP/2UG2+8kRNOOIHly5fz0Ucf+cUMtkDMVN/z+K5du/jPf/7DPffcw0knnQTAF198QWpqqjI1s59//plnnnmG3r17c9tttxEZGVnr+pkzZ2IYBuPHj2+mMzx2gZipWs2/z7Kysnj//ff5/vvvOfPMM7n++uuJj49v5jM8NoGSp7CwELvdTnR0dK3La75L69lnnyUpKYnrrruuOU7xmAVipoqKCnJyckhMTMTlcuFwOHjttdc499xzOfPMMwF47bXXcDgc3HXXXc18tkcnEDN5i5ZPEc8vdw6Ho851FRUVfPDBBzz88MPExcVx0003HXIpAF+qU15ezvr16yksLKzV0K1+KypATEwMZrOZffv2HVcdb9YK1EwAGzdupKCgwHP5jh07+Pe//+35vGfPnlitVn7//XefruPNWt7MVLOREh0djdVq5dRTT2XixIlMmjSJsWPHcuONN/LDDz+QkpLCsmXLfLpOIGaqvj+sX7+e/Px8z+Wnnnoql19+Odu2bcNutzNo0CAiIiJ47733jquONwVipur7g91u54033mD16tVceOGFjBw5ErPZTEpKCpGRkfz5z38mNDSU+fPnN/MZH1kgZzp4eYTqWVHVM0TPP/98wsPDPcsp+LJAy1Sd57fffuO+++7jp59+Ij09ndTUVPbv30/Xrl2xWq1ccMEFhIeHs3bt2mY+4yMLxEzVz+P79u2jrKwMcC/vZhgGJ510Eg6HA5fLRc+ePbHZbKSlpTXj2R6dQMxUbdmyZZx22mncddddREZG4nK5aj1fpKWl0bFjx2Y8w2MXSJlcLhdr165lx44dgPvdPuXl5bz//vs8+OCD7N27lwkTJnD//ff7RQM50PIAlJeX88ADD3Dvvffyr3/9i/fee48NGzZQUlLi+XlbWFjIjh07lKkZORwOZs+ezRdffOF5MSY4OJjo6Ghef/11SkpKAPfzw8EvBPiqQMzkTVo+RQD3L3fff/89Q4YM8Ww48tVXX/Hee+/hcDi44YYbGDhwYIM3I/FWneXLl/P2228TGxtLZGQkPXv2pHfv3pxwwglYLBaCg4M96zI29InBW7UCMdPGjRv5v//7P+666y7PHxo9evQgPz+fOXPmcO2117J161aKi4tp166dV+q0bdv2uOsEaqZqoaGhjB49mn//+9+MGTOG+Ph4tm/fTmpqKg6Hg8GDBzfK7uPequPNWk1dZ/369cyePZv77rvPM95ms5nevXvz+eefs3LlSi666CLuvPNOVq1adch3gPiSQMwEkJ6ezurVq7n22ms5//zzadWqFRUVFTz99NO899573HjjjVx00UXs2LEDp9NJUFBQc5/yEQViJpfLRVBQEPn5+RiGQU5ODrt27aKyspKff/6Z0NBQ9u/fz4oVKxgxYoTPb9YGgZdp69athIeH89hjj9G6dWvy8/OZPHkyqampjBo1ih07dlBYWOjzOWoKtEx79+7ls88+46KLLqJjx4707duXmTNn1nqb/ZYtW7Db7XTo0KGZz/boBGKmnJwc9u3bx4gRIwgLC8MwDM/P0/3795OamkpOTo7PL2FRU6BlMpvNbN++nW+++YannnqKH374odH/fvamY81T/c4mXxYWFsbgwYNZuHAh55xzDqtXr+brr7/GYrEQERFBVFQUmzZt8vxt7Q+ONZM/jJPFYiE6OpqNGzdiNps9EzH79evH559/zvPPP8/WrVsxm83cdNNNzXy2RycQM3mTmuICQIcOHXjvvfcwm8306NGDt99+m+3btzNkyBAuv/zyOrs+H+8T3rHWOV6XXHIJn3zyCaeddhpxcXFs2LCBb775BpfLhc1mw263s2/fPm6//fYG/3F+tLVuu+02goKCjvt7d6yZGtIgOtZax5vp1FNPpby8nJ07d5KcnIzD4SA0NJQ+ffqwbt06vvvuO/bv38/ll1/eoMbu0dYZMWJEgxrVx5PJG9+7hmaq5nK56NWrF+effz4zZsyga9eufPPNN3Ts2JGRI0dy0kknNcqrz96q481aTV2nd+/e2O12du3axQknnOBpPJrNZvLz82u9cOLr6zpXC8RMABkZGSQmJjJo0CCCg4MB94smNXeD79u3L+eee65fNI8hMDP973//49tvv8XhcFBeXk5eXh6xsbGUlZXRrVs3IiIiuOWWW4iJiaGystIvmhFHmyk6Opry8nKfz7R37166dOnieS5o164dw4YNY+HChaxbt46SkhI6d+7MCSec0KzneSwCLVNcXBzr1q0jKSmJjh07YrFYuOmmm/jggw/Yvn07BQUFfPvtt1x22WU+f3+rdqyZ/OEF2+joaEpLSz3vCDWZTJSVlbFu3Tq+//57cnJyuOGGGzz3O3/P9MMPP5Cbm1srkz+49tprWbJkCffeey/l5eUMGjSIESNG1Pn9sXp8fH2cjjWPP7j++uv57LPPaN26NZMnT6agoICsrCy2b9/Onj17uPLKK2tNDvSHJvLhMmVkZDBy5Eguuugiv3kOB7j66qtZtGgRK1euZMCAAYB7GdLo6Gj+9Kc/8euvv9KjRw/POur+cB88UqbNmzfTrVs3v3l3jDepKS4eN998M2+88YZnc4snnniCzp071zqm+gmhIU/eR1OnpuPZiM5kMjFy5EgWLlzICy+8wCWXXILT6WTTpk3k5eVRUFDAwIEDPX90NOQH0pFqFRYWMmDAAE8tb9VpyBP38WQ63g0DR4wYQWpqKieffDIxMTEA7N69myFDhtClSxdCQkI8vxw1ZJwOV6dr164EBwc32uzjo6lVnakhj6VjzdTQTR2r71Nt2rRh5cqVFBUVcc0113DiiSfW+qOiob84HKpOly5dSE5OPu7bbc5ax1LneMfpiiuuIDU1lc6dO3t+4Vm0aBF5eXmedTSrx8ZfZuseLlP1848//KJak9VqJTs7m6qqKk8DecuWLXz99ddcddVVAERGRvrF+FQ7XKarr74a8L9MMTExREVF0bVrV8LCwjj11FNxOp21NgTzN4GWqUePHnzwwQeUlZURHh4OuN8afM4553DaaadRVlZG+/btsdlsfvM8cbhMvXv3prS01JPJX4wYMYKPPvqIjh070r17d4YNG8bevXtZsWIF+fn5DB48mEGDBgH+0SCCY8vkD/c7gJEjRzJ37lx27txJWFgYO3fupLi4mLCwMC677LJam7b7c6aSkhJCQ0MZMmRIrU2FV61aRZcuXYiNjW3GMz48k8nEn//8Z1544QX+/ve/c/rpp9d7XPX4+Po4HSlP9fN2dQ5/GaOxY8fy+uuv07t3b9q0aUObNm0OOXnDH57vjjWTv4zTn/70JxYsWMCePXto3bo1K1asIDExkYSEBBISEmod7+uPJTh0pqSkpHoz+cM4eYs22pRa/vnPfxIcHMzDDz9c64/X6rtJ9RP3pk2b2LJli+eP3caqc7Bt27YxZ84cHn/88eOqc//993P22WcfcdOHmn98HK+jqVVSUsLatWuxWCycd955TVYHGj5Gx1KroeP0n//8B4fDQfv27cnNzWXfvn08+OCDdf5Qb+g4HVxn//79PPjgg7V+SJSWlvLDDz80aIyOthY0fJyOtk5DxwjcTa6XXnoJi8VCq1at2LNnD2+99Vad4xo6TkdTp7HG6WgzNXScjlSnuhHQ0HGaPn06mZmZREZGUlBQgN1u55JLLuGSSy6pdVxjPOd5y8GZHA4Hl1xyCRdffHGt4xrjOc9bJk2aRGJiIsnJydjtdrZs2YLZbOavf/1rrWaXP41TfZmCgoK48847a21M50/jdLRKS0tp1apVc59Ggxz8Qtkvv/zC1q1bfX6cJk2axAknnEC3bt1wOBx8+eWXXHHFFbUaeOBfY3RwpuXLl3P55ZfXyeQvYwTw0ksveZaGqW5KhoaGcu655zJo0CDPDEN/es47OFNYWJjnHXuDBg3yPJf703Pel19+6ZkZ3qVLFzp16sR5553n+b3l+++/Z/PmzSQmJtKzZ0/69u3b3Kd8RNWZsrOzPbMk+/fv75kssGnTJr744gvWr19PXFwc//rXv5r5jI/sr3/9K6eeeiq33357rcsrKirIyspi/fr1bNq0yW/G6VB5qv36668sW7bMr8bojjvu4Pzzz+eGG26o9WJfaWkp2dnZrFu3jl9//dVvxghqZ6qPP47TypUrWbZsGQUFBXTt2pXLL7+cE044gbKyMvbv389PP/3kd8951Zny8/Pp1q0bw4cPrzUB1R/HqalpprjUMmbMGB5//HHS09NrzfysfiLfv38/ixYtYuvWrezYsYOoqCgGDhzYaHUO1qlTJ3bs2MGyZcu46KKLjrnOLbfcwtSpU7n44otr/VFut9vZu3cvv/76KytXrsRisdC1a1f69etHly5djrnOoWpV/xCs/jc8PJxt27bx22+/YTab6/yB05BM1RprjI42EzR8nG6//XbWrl3LZ599RseOHRkxYgSJiYlUVVWxf/9+fvnll0YZp4PrDB8+nLi4uFpZwsLCGjxGh6tVrbHG6WgyQcPHCNzfm44dOzJw4EASExOZP38+JSUlWCwWcnJyGm2c6qtTWFhIRESE55X6xhqnQ9WKjIzEZDI12jgdKVNjPZZuueUWtmzZwtKlSznllFPo2bMnp59+Og6Hg71797Jp06ZGe87zlupMS5Ys4dRTT6VHjx611gBtzOc8b7nvvvtYvnw5ixYtIiEhgbZt23LllVdis9nYs2dPoz2WvKm+TMOHD/f87PDHcaqp5nOqw+EgKyvLL8ep2sGTHaob4v42Tn/961/58MMPmTt3Lu3btychIYHTTjvNs8zbxo0bWblyJVar1W/GqGamDh06EB8fzymnnOK5ft++fSxatIht27b5xRgB/PnPfyYrK4s1a9YQEhJCu3bt6NatG7GxsWRnZ/Pll1961qn1l3GqL1Pnzp09EzqysrL47LPP/GqcBg0axAUXXIDFYqGiooLQ0FByc3NJTU1lxYoVWK1W+vTpw44dO/j+++8pLS3lwgsvbO7TPqyamWq+m6mqqoqVK1eyYMECEhISGD16NO+//z5Lly5lyJAhzXzWh/fXv/6VTz/9lKKiImw2G2azmczMTL788ku+/PJLLBaLX41TdZ6SkpJaEwMcDgcrVqzgk08+8bsxevDBB9myZQtOpxOTyYTJZPLrMQJ3ps2bN9d555U/j9OAAQM4++yzcblcVFVV0aZNG78fp+pM4O55RUREAP49Tk1NM8Wljrlz59K5c2fOOeecWpfv2rWL999/n/T0dEaMGEF+fj6ff/45b7/9dqPWqVb9B+jKlSt58803j7vOkiVL6NWrF+3bt8dsNlNWVsaqVav43//+R35+Pueddx5hYWFkZGSQnp7OzJkzj6sOwOLFi+ndu3e9G+tU/wCpqqpixYoVpKSk8PrrrzdqncYeI3B//0477bRDbhbUWOME7plqVVVVhIWFYbfbWb58eZOMk9PpxG6311n7rDHHqGYtp9Pp+SUcmmac6qtTrTHHqLi42PPDtdqSJUsafZyKioo8s3gO1tjjdKhajT1O9X3vamrMcaqpevZkUzyWmltTPJa8qbKykrKyMs+eCYsXL2bRokV+PU5VVVVUVFTUekzt3LmTDz74wG/HCQ487zTl7xDNzV8fT1VVVRQUFFBWVuaZaNEUP5e8qaqqisLCQioqKjxrmoL/jlF9y6K4XC6WLl3Kp59+SmFhod+N0+GWetmxYwfz5s3zu3E6WEZGBs8++yy5ubmMHj2ayy67zHPdihUr+OCDD3j55Zeb8QyPTvVYVS9PV/35L7/8wvvvv09SUhJ33HEHq1at4vXXX/eLccrLy/PsGZSZmcn06dPJzs7223HKzc0lKiqqzhKC/jxGNbMEwhjBgUyBNE41ZWRkMH36dHJycvx6nKpV/+4aCM95Tcn3F8cRr7v22ms9bw2x2+2ey6Ojo+nTpw8VFRWcc845XH/99cTGxvLGG280uA4cmLVUvVtu9WzkAQMGEBcXx+zZs4+rztChQ4mNjfW8ovnmm2/y1ltvcfLJJ/Paa69x++23c+ONN/L3v/8dm83GRx99dFx1AIYNG1aneexyuXA6nZ76wcHBDB06lA4dOrBs2bIG1XG5XE06RoDnXKs11TiBe6ZaWFgYAC+//DJvvvlmk4xTUFBQrYZ4U4xRzVpBQUE4HA7PZU0xTkFBQZ6GePWmQk0xRgc3dZ9//vkmGaf6mtRNNU7VtRwOR5M+nqq/d9XjUn2faIpxqqkpH0veZrfbm/yx5E0hISGehvjzzz/fZD+bvCk4OBibzVZrnGJiYvx6nACv/A7hbdUvEFfz18dT9f4Z1Q3xpvq55E3BwcHExMSQlJQUEM959TWPZ86cyVtvvcWpp57ql+NUM5Pdbq/1WGrfvr1fjlNNe/bs4V//+hft2rXjpZde8jSHqu+PUVFRhIaGkpmZ2ZyneVRMJhNFRUWsWrWK/Px8z9idcsopXH755axfv57S0lLOO+88OnTowNy5c5v5jI+suiG+Z88ennjiCdq0aePX4xQVFVVrjKr58xhVN40DZYzAnSnQxqla9XNe27Zt/X6cwD3p66uvvgqY57ympKa41BEUFITJZGL16tWsWbPGc7nNZmPgwIF0796d+fPnA+5NM1etWkVBQcFx1an+I7PmbIvqy8rLyzGZTOzbt4/zzjuPzz77jLy8vOPO5XK5ePPNN9mwYQOTJ0/m9ttvJzQ0FLvdjsvlwuVy0aZNm1q/1B6PoqIi5s+fz7x589i+fTsmk6nOuul5eXlUVVU1aHMNl8vFd99916RjdLCmHifDMDzj9Msvv/DII480yTgVFRXx4YcfNvkYgXucvv/+e7799lvPZU05ToZheLI01WMpUMfphx9+8MrjqfoV++pflpv6OW/jxo1NNkbe5HK5WLt2Ld99953nsqZ+zmtq3noseZPL5WLNmjVee87zFm/9DuEt1T+bvPk7RFMK1MfS6tWrA/axFGg/mwLlsVRt586dgHsd4fDwcM/4VP/usn79eiwWyyHfSeprtm3bxkcffURFRUWty7t06UK7du346aefALjnnnto06YN/vJm+kAap61bt2qM/IAeSxqnQKM1xaVeJpOJL774gqSkJM477zxPM9RisdCzZ082bNhAaWkpPXr04LbbbmvQL64VFRWUlZVRVVXFtm3bsNvtbNy4EYfDQVpaGuXl5Z7Zw+vXr/fs5n6sqjf+Gjp0KCeddJLnVT+r1QrA7t272bJlCxdccMFxZwH3rNPPPvuM4uJivv/+eyorK0lOTqZHjx6ceuqplJeXs2vXLvLy8mqtMX2szGaz18YIvDNOJpOJqqqqJh+nyMhIFi1a1ORjBO5xWrZsGUlJSZx//vkB8VgK9HHSc55v8uYYeYu3Hkve5M3nPG/S48m3xylQH0vVv+fpseS7Au2xVG3nzp106dKF6OhoXC6XZ3zy8/P56KOPWL58ObfcckudyQq+qk+fPsyePZuNGzfW2nunqqqKffv2ER0dDUBiYqJnXXh/EEjjdNZZZ/H2229rjHycHksap0Cjprgc0uDBg3n77bcZNWpUrU0v0tLSsFqttGrVCoD+/fs3qM7evXt58sknKSkpITY2lqKiIjp37kxERAQXXHABXbp0ISgoiJNPPpni4uLjrpObm0tFRQV9+vQBDrylqXq93U8++YRTTz21wXkAbrvtNl566SUefvhhdu7cybp161izZg0LFiwgLCyMvLw8Ro4cyUknnVRns4pj4a0xgsAbJ2+NEQTeYwk0Tg0RaI8lb/Lmc563aJz8g8bJ92mM/IPGyT907dqVlStXkpmZSXx8PC6Xi2XLlrFmzRoqKioYO3Ys5513XnOf5jG55ppreP/994mPj6dnz54YhsH7779PUFAQrVu3rnXs4daM9yWBNk4aI/+gcfIPgThOTUEbbcphTZ48mYSEBC644AJOOukkFi1axLvvvsu1117LlVdeWevYhjyQvvzyS5KTkzGZTMTFxREWFtbgBld9Jk2aRJcuXbjiiito3749a9as4euvvyY7O5suXbpw+eWXN9pbYh544AF69erFuHHjPJeVlJSQlZVFQkKCZyZoQ3lrjCDwxslbYwSB91gCjZM/jJM3n/O8xZvPed6icdI4NZdAGyeNke+PEWic/GWc/vOf/7Bv3z7Cw8PZv38/bdq0ISkpif79+3P66adjNptxuVzk5OTQvn375j7dozJr1ix++eUXXC4XeXl5tG3blttvv51TTjkFcC+HYzKZyM7O9ptMgTZOGiP/yKRx8o9MgThOjU1NcTmsvXv38s4777Bt2zYcDgcmk4nLLruM0aNHA1BVVQW4d1SOiIigbdu2jdLUqW4OVW9AV32b27Zt491332XQoEFceOGFx3y7u3fvZsaMGVRVVVFWVkZwcDCdOnXi9NNPp3///p71ozIyMhqcZ8eOHUyePJlnnnmGuLi4Ors0V2topuYaI/D/cfLWGEHgPZZA4+QP4+TN5zxvac7nvKaicfKPTBon38+kMfKPTBon/8hUUlLCzp07+f7770lISCAhIYETTzyR4OBgNmzYwNq1a/nhhx8ICgqie/fuXHjhhfTu3bu5T/uwKioqyMzM5KuvviIxMZGePXuSkJBAYWEhW7ZsYePGjaxZs8avMgXaOGmM/COTxsk/MgXiODU2NcXliCoqKti0aRPFxcV06tSJxMREXC4XmzdvZuPGjXz77bcUFBQQFRVFly5duOuuu45rraXqWRP1zZ4oKipizpw5/Prrr1gsFvLy8pg1a1a9jbEjycvL47fffqO0tJSEhARiYmJo164dv/32m2dzsMLCwgbnAXjiiSew2Wzcd999da5rzEzeGiMIvHHy1hhB4D2WQOPkD+Pkzec8b/Hmc563aJz8I5PGyfczaYz8I5PGyT8yHSwrK4tFixbx888/ExwczJAhQwgLC2Pz5s2sWbOGV1999bh///KG+n7n2rNnD0uXLmXDhg1YLBa/y1Qffx4njZF/ZNI4+UemljJODaGmuByzqqoqli5dyqpVqygrK6N///5ccMEFbNu2jcWLF5OYmMhf/vKXRqtXWVnJRx99xMKFCxk5ciSXXHIJ//nPf4iLi+Ouu+5q8O07HA4WL17MV199RUVFRaPmqaqqoqioyLORgbcyeXuMwH/HqbnGqLp2ID2WQOPUGPz1sdScmuM5r6lpnPyDxsn3aYz8g8bJ9xUUFPDf//6XnJwcRowYwaWXXlrr+ocffpizzjqrznIxvkyZfF+g5QFl8hfK1DK0nPa/NJp58+axePFiBgwYwOjRoz2L9MfGxhIdHc3MmTMpKioiMjLyuG6/qqqK7OxsEhISAAgJCWHo0KHk5eWxY8cOWrVqxW233caECRMYMWIESUlJDcrz/vvvN1me4OBgoqOjqaysJCcnx2uZmnqMIHDGqbnGCALvsQQap+MRKI+l5uSN5zxv0zj5B42T79MY+QeNk2+z2+3MnDmTyspK/vWvf9GuXTvA/TtMcHAwJSUlOBwOQkNDm/lMj54y+b5AywPK5C+UqeXw7YXMxOd8++23LF26lL/+9a/ceuuttG7dGofDgd1uB9xr/0ZGRmKxWDjeNyFs2bKFxYsXk52d7bmsXbt2XHrppaSnp7Nz5046duzIsGHDWLlypc/nAdi6dSuff/55QGUKtHHy5hh5K5M3x8hbmTROvv9Y8jZlUqbmoky+nynQ8oAyKVPzKC0t9cwsbNeuHXa7HYfDQXBwMAAbN25k//79dOzYsZnP9Ogpk+8LtDygTP5CmVoOzRSXY5Kenk7nzp0544wzMAwDu93ueRAVFBSwfPlykpOTCQ8PP+4aVquVb7/9lssuu6zW5WazmeDgYAoKCgC46aab2L9//3HXAe/kAXem7777juHDh9e63N8zBdI4eXOMIPAeS6BxOl6B9ljyNmXyD8rkHwItU6DlAWXyF4GWqaioiPLycrp27Qq4f3cBKC4uJiUlhS+++IIRI0Zw0kknNedpHhNl8n2BlgeUyV8oU8uhprgck4KCAiIiIjwL71f/cvf555/z8ccf06FDB26++eYG1ejZsyeJiYl89NFH3HnnnZ7Ls7OzKSoqokOHDgBYLBbi4+MbVMsbeUCZ/CGTN/OAMh0vZfL9x5K3KZN/UCb/EGiZAi0PKJO/CLRMHTt2JCYmhvfff59BgwZxwgkn8OWXX7Jy5UpCQkIYO3YsF110EVD/xm6+SJl8P1Og5QFlUqbmE4iZGoM22pRjsmfPHv7+979z1VVX0aNHD3Jycvjss88oLy+nV69eDB06lMTExAY/iDIzM3niiSc444wzOOmkk8jLy+O9997jrLPO4q677sJqtTbKg9RbeZTJPzJ5K48yKVNzZfLm84O3KJMyNRdl8v1MgZYHlEmZms/+/ft59dVXyczMpLi4mIiICM455xxOP/10evTo4Wn8+xNl8n2BlgeUyV8oU8ugprgcs8WLF/Pdd9+xZ88e7HY7ffv25fTTT6dnz560adOm0er88MMPrFy5kk2bNmE2m7nkkksYNWpUo91+NW/lAWVqiEC734EyNYQyHT9vPj94izL5B2XyD4GWKdDygDL5i0DMVFlZyd69eykvL6djx44EBQX5/aZsyuT7Ai0PKJO/UKbAp6a4HBfDMNi9ezdxcXGYTCbPekRNYffu3cTHx3veftgUMyq8mQeU6XgF2v2u+naV6fgp0/Hx9vODNyiTf1Am/xBomQItDyiTvwjETCIiIoFCTXE5Zt56m1+g1fFmLWXy/TrerKVM/lEr0Op4kzL5B2XyD4GWKdDygDL5i0DMJCIiEkjUFBcRERERERERERGRFsPc3CcgIiIiIiIiIiIiIuItaoqLiIiIiIiIiIiISIuhpriIiIiIiIiIiIiItBhqiouIiIiIiIiIiIhIi6GmuIiIiIiIiIiIiIi0GGqKi4iIiIiIiIiIiEiLoaa4iIiIiIifW7VqFf/73/+O6Wv279/PNddcw4oVKzyXzZs3j2uuuYaioqJGPkMREREREd+hpriIiIiIiJ9btWoVixYtOqavadu2LU888QRnnHFGE52ViIiIiIhvsjT3CYiIiIiIiPe4XC6cTidWq5Vu3bo19+mIiIiIiHidmuIiIiIiIj6uqKiI9957j/Xr11NYWEhYWBjx8fGMHj2aDz/8kF9//RWAa665xvM18+bNY//+/YwfP56xY8ficDj48ssvyc3N5e9//zvx8fGMHz+eu+66i4EDBx6ydkZGBv/+97+JjIxk0qRJtG7dmoKCAubNm8dPP/1EYWEh7dq1Y+DAgVx11VUEBQU19bdDRERERKRB1BQXEREREfFxL7zwAjt37uS6664jPj6e0tJSdu7cSUlJCbfeeiuvvvoq+/bt48EHH6z36z/77DPi4uK48cYbCQ8PJzY29qjq/vrrrzz99NP07NmTe++9l5CQEAoKCnjooYcwm82MGjWKDh06sG3bNj788EOys7O56667GjO6iIiIiEijU1NcRERERMTHbd26lUGDBnHRRRd5LjvrrLM8/2/VqtVhl0OxWq08/PDDWCwHfv3fv3//YWt+9dVXvPLKKwwZMoQ//elPmM3u7YjmzZtHaWkpzz77LNHR0QCceuqpBAcH8+6773L55ZeTmJh43FlFRERERJqaNtoUEREREfFxXbp0YeXKlcyfP59t27bhcDiO6ev79OlTqyF+JB9++CEvvfQSY8aM4eabb/Y0xAF++uknTj75ZNq2bYvT6fR8nH766QCepVxERERERHyVZoqLiIiIiPi4++67jw8//JAvv/ySDz74gNDQUPr27csNN9xAmzZtjvj1bdu2PaZ6X3/9Ne3ataN///51rissLOTHH3/k+uuvr/dri4qKjqmWiIiIiIi3qSkuIiIiIuLjIiMjGTduHOPGjSMnJ4e1a9cyZ84cCgsLefjhhxu93sMPP8z06dN55JFHeOSRR4iJifFcFxERQXJyMtddd129X3usDXgREREREW/T8ikiIiIiIn4kOjqaiy++mF69erFz504ALBYLVVVVjVpjypQpWK1WHnnkEfbu3eu57owzzmD37t106NCBE088sc5Hu3btGu08RERERESagpriIiIiIiI+rKysjEmTJrFgwQJ+/PFHfv31VxYsWMD69evp1asXAB07dqSwsJAlS5awfft2fv/99wbXbdu2LY899hiRkZE8+v/t3LGJAmEUhdG7oIGYig1oAdZhMqHFyKDZ2IkgmJhpam5kBWIkTGoms9FWIO4u/Oc0cF/8BW+1yu12S5IsFov0er3UdZ3T6ZTr9ZrL5ZLj8ZjNZpO2bd/eBgCAT/I+BQAA/rF+v5/pdJrz+ZzH45HX65XRaJSqqlJVVZJkPp/nfr9nu93m+Xym67rsdru3t3+CeNM0Wa/XWS6XmUwmaZom+/0+h8MhbdtmMBhkPB5nNptlOBy+vQsAAJ/01XVd99dHAAAAAADAb/A+BQAAAACAYojiAAAAAAAUQxQHAAAAAKAYojgAAAAAAMUQxQEAAAAAKIYoDgAAAABAMURxAAAAAACKIYoDAAAAAFAMURwAAAAAgGKI4gAAAAAAFEMUBwAAAACgGKI4AAAAAADF+AbQujDjv3qetQAAAABJRU5ErkJggg==", 67 | "text/plain": [ 68 | "
" 69 | ] 70 | }, 71 | "metadata": {}, 72 | "output_type": "display_data" 73 | }, 74 | { 75 | "ename": "KeyboardInterrupt", 76 | "evalue": "", 77 | "output_type": "error", 78 | "traceback": [ 79 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 80 | "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", 81 | "Cell \u001b[0;32mIn[15], line 64\u001b[0m\n\u001b[1;32m 61\u001b[0m plt\u001b[38;5;241m.\u001b[39msavefig(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m./RM409.png\u001b[39m\u001b[38;5;124m\"\u001b[39m, bbox_inches\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtight\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 63\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n\u001b[0;32m---> 64\u001b[0m \u001b[43mtime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 65\u001b[0m clear_output()\n", 82 | "\u001b[0;31mKeyboardInterrupt\u001b[0m: " 83 | ] 84 | } 85 | ], 86 | "source": [ 87 | "while True:\n", 88 | " data = pd.read_csv(\"data_dev.csv\", header=0)\n", 89 | " data.insert(data.shape[1], 'strike', data.apply(find_strike, axis=1))\n", 90 | " data.strike = data.strike.astype(float)\n", 91 | " data.insert(data.shape[1], 'cp', np.where(data['symx'].str.contains('C'), 0, 1))\n", 92 | " data.insert(data.shape[1], 'forward', data.iloc[0]['prc'])\n", 93 | " data.insert(data.shape[1], 'maturity', 63/365)\n", 94 | " data.insert(data.shape[1], 'r', 0.025)\n", 95 | " data.insert(data.shape[1], 'log_moneyness', value=np.log(data['strike'] / data['forward']))\n", 96 | " data = data.iloc[1:,:]\n", 97 | " data[\"market_imp_vol_prc\"] = newton_imp_vol(data[\"prc\"], data[\"cp\"], data[\"forward\"], data[\"strike\"], data[\"maturity\"], data[\"r\"], 0.25, 500)\n", 98 | " data[\"market_imp_vol_ask\"] = newton_imp_vol(data[\"askp1\"], data[\"cp\"], data[\"forward\"], data[\"strike\"], data[\"maturity\"], data[\"r\"], 0.25, 500)\n", 99 | " data[\"market_imp_vol_bid\"] = newton_imp_vol(data[\"bidp1\"], data[\"cp\"], data[\"forward\"], data[\"strike\"], data[\"maturity\"], data[\"r\"], 0.25, 500)\n", 100 | " data['vega'] = bs_vega(data[\"forward\"], data[\"strike\"], data[\"maturity\"], data[\"market_imp_vol_prc\"], data[\"r\"], \"c\") # type: ignore\n", 101 | " xtk = data.strike.unique()\n", 102 | " data = data.dropna()\n", 103 | " data_c = data[data['cp'] == 0]\n", 104 | " data_p = data[data['cp'] == 1]\n", 105 | " wing_model_params_list_input = [-0.2, 0.2, 0.5, 0.5]\n", 106 | " while True:\n", 107 | " moneyness_inputs_list = list(data_c['log_moneyness'])\n", 108 | " mkt_implied_vol_list = list(data_c['market_imp_vol_prc'])\n", 109 | " mkt_vega_list = list(data_c['vega'])\n", 110 | " final_res_c = wing_model_calibrator(wing_model_params_list_input,\n", 111 | " moneyness_inputs_list,\n", 112 | " mkt_implied_vol_list,\n", 113 | " mkt_vega_list,\n", 114 | " is_bound_limit=True)\n", 115 | " moneyness_inputs_list = list(data_p['log_moneyness'])\n", 116 | " mkt_implied_vol_list = list(data_p['market_imp_vol_prc'])\n", 117 | " mkt_vega_list = list(data_p['vega'])\n", 118 | " final_res_p = wing_model_calibrator(wing_model_params_list_input,\n", 119 | " moneyness_inputs_list,\n", 120 | " mkt_implied_vol_list,\n", 121 | " mkt_vega_list,\n", 122 | " is_bound_limit=True)\n", 123 | " if final_res_c['success'] and final_res_p['success']:\n", 124 | " break\n", 125 | " data_c.insert(data_c.shape[1], 'wing_model_vol', data_c['log_moneyness'].apply(lambda x: wing_model(x, final_res_c['vr_'], final_res_c['sr_'], final_res_c['pc_'], final_res_c['cc_'], -0.2, 0.2, 0.5, 0.5)))\n", 126 | " data_p.insert(data_p.shape[1], 'wing_model_vol', data_p['log_moneyness'].apply(lambda x: wing_model(x, final_res_p['vr_'], final_res_p['sr_'], final_res_p['pc_'], final_res_p['cc_'], -0.2, 0.2, 0.5, 0.5)))\n", 127 | "\n", 128 | " plt.figure(figsize=(18, 6))\n", 129 | " pl1 = data_c.sort_values(by=\"strike\")\n", 130 | " plt.plot(pl1[\"strike\"], pl1[\"wing_model_vol\"], c='b', marker='o')\n", 131 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_ask\"], c='g', marker='o')\n", 132 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_bid\"], c='r', marker='o')\n", 133 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_prc\"], c='y', marker='o')\n", 134 | " pl1 = data_p.sort_values(by=\"strike\")\n", 135 | " plt.plot(pl1[\"strike\"], pl1[\"wing_model_vol\"], c='b', marker='x')\n", 136 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_ask\"], c='g', marker='x')\n", 137 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_bid\"], c='r', marker='x')\n", 138 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_prc\"], c='y', marker='x')\n", 139 | " plt.xlabel(\"strike\")\n", 140 | " plt.ylabel(\"market_imp_vol\")\n", 141 | " plt.yticks(np.arange(0.20, 0.41, 0.01))\n", 142 | " plt.xticks(xtk, rotation=-60)\n", 143 | " plt.title('RM409Call')\n", 144 | " plt.legend(['CallWingModel', 'CallAskMktVol', 'CallBidMktVol', 'CallPrcMktVol', \n", 145 | " 'PutWingModel', 'PutAskMktVol', 'PutBidMktVol', 'PutPrcMktVol'])\n", 146 | " plt.savefig(\"./{}/RM409_{}.png\".format(ivs_log_path, time.strftime(\"%H_%M_%S\")), bbox_inches='tight')\n", 147 | " plt.savefig(\"./RM409.png\", bbox_inches='tight')\n", 148 | "\n", 149 | " plt.show()\n", 150 | " time.sleep(10)\n", 151 | " clear_output()\n" 152 | ] 153 | } 154 | ], 155 | "metadata": { 156 | "kernelspec": { 157 | "display_name": "base", 158 | "language": "python", 159 | "name": "python3" 160 | }, 161 | "language_info": { 162 | "codemirror_mode": { 163 | "name": "ipython", 164 | "version": 3 165 | }, 166 | "file_extension": ".py", 167 | "mimetype": "text/x-python", 168 | "name": "python", 169 | "nbconvert_exporter": "python", 170 | "pygments_lexer": "ipython3", 171 | "version": "3.11.9" 172 | } 173 | }, 174 | "nbformat": 4, 175 | "nbformat_minor": 2 176 | } 177 | -------------------------------------------------------------------------------- /ivs_wing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 23, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import os\n", 10 | "import time\n", 11 | "import datetime\n", 12 | "import pandas as pd\n", 13 | "import numpy as np\n", 14 | "import matplotlib.pyplot as plt\n", 15 | "from scipy.stats import norm\n", 16 | "from IPython.display import clear_output\n", 17 | "from utils.black_scholes import *\n", 18 | "from utils.calibrator import *\n", 19 | "\n", 20 | "plt.style.use(\"ggplot\")\n", 21 | "\n", 22 | "ivs_log_path = './ivs_log/{}'.format(datetime.date.today())\n", 23 | "if not os.path.isdir(ivs_log_path):\n", 24 | " os.makedirs(ivs_log_path)\n", 25 | "\n", 26 | "def find_strike(x):\n", 27 | " if x['symx'].__len__() > 5:\n", 28 | " return x['symx'][6:]\n", 29 | " else:\n", 30 | " return np.nan\n", 31 | "\n", 32 | "def find_vega(x):\n", 33 | " return bs_vega(x[\"forward\"], x[\"strike\"], x[\"maturity\"], x[\"market_imp_vol_prc\"], x[\"r\"], \"c\")\n", 34 | "\n", 35 | "def Black(CP, F, X, sigma, T, r):\n", 36 | " d1 = (np.log(F/X) + (sigma**2 / 2) * T) / (sigma * np.sqrt(T))\n", 37 | " d2 = d1 - sigma * np.sqrt(T)\n", 38 | " call_price = F * np.exp(-1 * r * T) * norm.cdf(d1) - X * np.exp(-1 * r * T) * norm.cdf(d2)\n", 39 | " put_price = X * np.exp(-1 * r * T) * norm.cdf(-1 * d2) - F * np.exp((-1 * r) * T) * norm.cdf(-1 * d1)\n", 40 | " value = call_price + CP * (put_price - call_price)\n", 41 | " return value\n", 42 | "\n", 43 | "def newton_imp_vol(C0, CP, F, X, T, r, vol_est=0.25, n_iter=1000):\n", 44 | " for i in range(n_iter):\n", 45 | " d1 = (np.log(F/X) + (vol_est**2 / 2) * T) / (vol_est * np.sqrt(T))\n", 46 | " vega = F * np.exp(-1 * r * T) * norm.pdf(d1) * T**0.5\n", 47 | " vol_est = vol_est - (Black(CP, F, X, vol_est, T, r) - C0) / vega\n", 48 | " return vol_est\n" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 26, 54 | "metadata": {}, 55 | "outputs": [ 56 | { 57 | "ename": "KeyboardInterrupt", 58 | "evalue": "", 59 | "output_type": "error", 60 | "traceback": [ 61 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 62 | "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", 63 | "Cell \u001b[1;32mIn[26], line 11\u001b[0m\n\u001b[0;32m 9\u001b[0m data\u001b[38;5;241m.\u001b[39minsert(data\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlog_moneyness\u001b[39m\u001b[38;5;124m'\u001b[39m, value\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mlog(data[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mstrike\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m/\u001b[39m data[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mforward\u001b[39m\u001b[38;5;124m'\u001b[39m]))\n\u001b[0;32m 10\u001b[0m data \u001b[38;5;241m=\u001b[39m data\u001b[38;5;241m.\u001b[39miloc[\u001b[38;5;241m1\u001b[39m:,:]\n\u001b[1;32m---> 11\u001b[0m data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmarket_imp_vol_prc\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mnewton_imp_vol\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mprc\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcp\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mforward\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrike\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmaturity\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mr\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.25\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m500\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m 12\u001b[0m data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmarket_imp_vol_ask\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m newton_imp_vol(data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124maskp1\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcp\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mforward\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstrike\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmaturity\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m], \u001b[38;5;241m0.25\u001b[39m, \u001b[38;5;241m500\u001b[39m)\n\u001b[0;32m 13\u001b[0m data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmarket_imp_vol_bid\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m newton_imp_vol(data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbidp1\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcp\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mforward\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstrike\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmaturity\u001b[39m\u001b[38;5;124m\"\u001b[39m], data[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m], \u001b[38;5;241m0.25\u001b[39m, \u001b[38;5;241m500\u001b[39m)\n", 64 | "Cell \u001b[1;32mIn[23], line 39\u001b[0m, in \u001b[0;36mnewton_imp_vol\u001b[1;34m(C0, CP, F, X, T, r, vol_est, n_iter)\u001b[0m\n\u001b[0;32m 37\u001b[0m d1 \u001b[38;5;241m=\u001b[39m (np\u001b[38;5;241m.\u001b[39mlog(F\u001b[38;5;241m/\u001b[39mX) \u001b[38;5;241m+\u001b[39m (vol_est\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m) \u001b[38;5;241m*\u001b[39m T) \u001b[38;5;241m/\u001b[39m (vol_est \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39msqrt(T))\n\u001b[0;32m 38\u001b[0m vega \u001b[38;5;241m=\u001b[39m F \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mexp(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m*\u001b[39m r \u001b[38;5;241m*\u001b[39m T) \u001b[38;5;241m*\u001b[39m norm\u001b[38;5;241m.\u001b[39mpdf(d1) \u001b[38;5;241m*\u001b[39m T\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m0.5\u001b[39m\n\u001b[1;32m---> 39\u001b[0m vol_est \u001b[38;5;241m=\u001b[39m vol_est \u001b[38;5;241m-\u001b[39m (\u001b[43mBlack\u001b[49m\u001b[43m(\u001b[49m\u001b[43mCP\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mF\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvol_est\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mr\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m-\u001b[39m C0) \u001b[38;5;241m/\u001b[39m vega\n\u001b[0;32m 40\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m vol_est\n", 65 | "Cell \u001b[1;32mIn[23], line 30\u001b[0m, in \u001b[0;36mBlack\u001b[1;34m(CP, F, X, sigma, T, r)\u001b[0m\n\u001b[0;32m 28\u001b[0m d1 \u001b[38;5;241m=\u001b[39m (np\u001b[38;5;241m.\u001b[39mlog(F\u001b[38;5;241m/\u001b[39mX) \u001b[38;5;241m+\u001b[39m (sigma\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m) \u001b[38;5;241m*\u001b[39m T) \u001b[38;5;241m/\u001b[39m (sigma \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39msqrt(T))\n\u001b[0;32m 29\u001b[0m d2 \u001b[38;5;241m=\u001b[39m d1 \u001b[38;5;241m-\u001b[39m sigma \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39msqrt(T)\n\u001b[1;32m---> 30\u001b[0m call_price \u001b[38;5;241m=\u001b[39m F \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mexp(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m*\u001b[39m r \u001b[38;5;241m*\u001b[39m T) \u001b[38;5;241m*\u001b[39m \u001b[43mnorm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcdf\u001b[49m\u001b[43m(\u001b[49m\u001b[43md1\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m-\u001b[39m X \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mexp(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m*\u001b[39m r \u001b[38;5;241m*\u001b[39m T) \u001b[38;5;241m*\u001b[39m norm\u001b[38;5;241m.\u001b[39mcdf(d2)\n\u001b[0;32m 31\u001b[0m put_price \u001b[38;5;241m=\u001b[39m X \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mexp(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m*\u001b[39m r \u001b[38;5;241m*\u001b[39m T) \u001b[38;5;241m*\u001b[39m norm\u001b[38;5;241m.\u001b[39mcdf(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m*\u001b[39m d2) \u001b[38;5;241m-\u001b[39m F \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mexp((\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m*\u001b[39m r) \u001b[38;5;241m*\u001b[39m T) \u001b[38;5;241m*\u001b[39m norm\u001b[38;5;241m.\u001b[39mcdf(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m*\u001b[39m d1)\n\u001b[0;32m 32\u001b[0m value \u001b[38;5;241m=\u001b[39m call_price \u001b[38;5;241m+\u001b[39m CP \u001b[38;5;241m*\u001b[39m (put_price \u001b[38;5;241m-\u001b[39m call_price)\n", 66 | "File \u001b[1;32md:\\miniforge3\\lib\\site-packages\\scipy\\stats\\_distn_infrastructure.py:2076\u001b[0m, in \u001b[0;36mrv_continuous.cdf\u001b[1;34m(self, x, *args, **kwds)\u001b[0m\n\u001b[0;32m 2074\u001b[0m output \u001b[38;5;241m=\u001b[39m zeros(shape(cond), dtyp)\n\u001b[0;32m 2075\u001b[0m place(output, (\u001b[38;5;241m1\u001b[39m\u001b[38;5;241m-\u001b[39mcond0)\u001b[38;5;241m+\u001b[39mnp\u001b[38;5;241m.\u001b[39misnan(x), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbadvalue)\n\u001b[1;32m-> 2076\u001b[0m \u001b[43mplace\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcond2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m 2077\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39many(cond): \u001b[38;5;66;03m# call only if at least 1 entry\u001b[39;00m\n\u001b[0;32m 2078\u001b[0m goodargs \u001b[38;5;241m=\u001b[39m argsreduce(cond, \u001b[38;5;241m*\u001b[39m((x,)\u001b[38;5;241m+\u001b[39margs))\n", 67 | "File \u001b[1;32md:\\miniforge3\\lib\\site-packages\\numpy\\lib\\function_base.py:1954\u001b[0m, in \u001b[0;36mplace\u001b[1;34m(arr, mask, vals)\u001b[0m\n\u001b[0;32m 1917\u001b[0m \u001b[38;5;129m@array_function_dispatch\u001b[39m(_place_dispatcher)\n\u001b[0;32m 1918\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mplace\u001b[39m(arr, mask, vals):\n\u001b[0;32m 1919\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 1920\u001b[0m \u001b[38;5;124;03m Change elements of an array based on conditional and input values.\u001b[39;00m\n\u001b[0;32m 1921\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1952\u001b[0m \n\u001b[0;32m 1953\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[1;32m-> 1954\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_place\u001b[49m\u001b[43m(\u001b[49m\u001b[43marr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmask\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvals\u001b[49m\u001b[43m)\u001b[49m\n", 68 | "\u001b[1;31mKeyboardInterrupt\u001b[0m: " 69 | ] 70 | } 71 | ], 72 | "source": [ 73 | "while True:\n", 74 | " data = pd.read_csv(\"data.csv\", header=0)\n", 75 | " data.insert(data.shape[1], 'strike', data.apply(find_strike, axis=1))\n", 76 | " data.strike = data.strike.astype(float)\n", 77 | " data.insert(data.shape[1], 'cp', np.where(data['symx'].str.contains('C'), 0, 1))\n", 78 | " data.insert(data.shape[1], 'forward', data.iloc[0]['prc'])\n", 79 | " data.insert(data.shape[1], 'maturity', 62/365)\n", 80 | " data.insert(data.shape[1], 'r', 0.025)\n", 81 | " data.insert(data.shape[1], 'log_moneyness', value=np.log(data['strike'] / data['forward']))\n", 82 | " data = data.iloc[1:,:]\n", 83 | " data[\"market_imp_vol_prc\"] = newton_imp_vol(data[\"prc\"], data[\"cp\"], data[\"forward\"], data[\"strike\"], data[\"maturity\"], data[\"r\"], 0.25, 500)\n", 84 | " data[\"market_imp_vol_ask\"] = newton_imp_vol(data[\"askp1\"], data[\"cp\"], data[\"forward\"], data[\"strike\"], data[\"maturity\"], data[\"r\"], 0.25, 500)\n", 85 | " data[\"market_imp_vol_bid\"] = newton_imp_vol(data[\"bidp1\"], data[\"cp\"], data[\"forward\"], data[\"strike\"], data[\"maturity\"], data[\"r\"], 0.25, 500)\n", 86 | " data['vega'] = bs_vega(data[\"forward\"], data[\"strike\"], data[\"maturity\"], data[\"market_imp_vol_prc\"], data[\"r\"], \"c\") # type: ignore\n", 87 | " data_c = data[data['cp'] == 0]\n", 88 | " data_p = data[data['cp'] == 1]\n", 89 | " wing_model_params_list_input = [-0.2, 0.2, 0.5, 0.5]\n", 90 | " while True:\n", 91 | " moneyness_inputs_list = list(data_c.drop(data_c[data_c[['market_imp_vol_prc', 'vega']].isnull().any(axis=1)].index)['log_moneyness'])\n", 92 | " mkt_implied_vol_list = list(data_c.drop(data_c[data_c[['market_imp_vol_prc', 'vega']].isnull().any(axis=1)].index)['market_imp_vol_prc'])\n", 93 | " mkt_vega_list = list(data_c.drop(data_c[data_c[['market_imp_vol_prc', 'vega']].isnull().any(axis=1)].index)['vega'])\n", 94 | " final_res_c = wing_model_calibrator(wing_model_params_list_input,\n", 95 | " moneyness_inputs_list,\n", 96 | " mkt_implied_vol_list,\n", 97 | " mkt_vega_list,\n", 98 | " is_bound_limit=True)\n", 99 | " moneyness_inputs_list = list(data_p.drop(data_p[data_p[['market_imp_vol_prc', 'vega']].isnull().any(axis=1)].index)['log_moneyness'])\n", 100 | " mkt_implied_vol_list = list(data_p.drop(data_p[data_p[['market_imp_vol_prc', 'vega']].isnull().any(axis=1)].index)['market_imp_vol_prc'])\n", 101 | " mkt_vega_list = list(data_p.drop(data_p[data_p[['market_imp_vol_prc', 'vega']].isnull().any(axis=1)].index)['vega'])\n", 102 | " final_res_p = wing_model_calibrator(wing_model_params_list_input,\n", 103 | " moneyness_inputs_list,\n", 104 | " mkt_implied_vol_list,\n", 105 | " mkt_vega_list,\n", 106 | " is_bound_limit=True)\n", 107 | " if final_res_c['success'] and final_res_p['success']:\n", 108 | " break\n", 109 | " data_c.insert(data_c.shape[1], 'wing_model_vol', data_c['log_moneyness'].apply(lambda x: wing_model(x, final_res_c['vr_'], final_res_c['sr_'], final_res_c['pc_'], final_res_c['cc_'], -0.2, 0.2, 0.5, 0.5)))\n", 110 | " data_p.insert(data_p.shape[1], 'wing_model_vol', data_p['log_moneyness'].apply(lambda x: wing_model(x, final_res_p['vr_'], final_res_p['sr_'], final_res_p['pc_'], final_res_p['cc_'], -0.2, 0.2, 0.5, 0.5)))\n", 111 | "\n", 112 | " plt.figure(figsize=(18, 10))\n", 113 | " pl1 = data_c.sort_values(by=\"strike\")\n", 114 | " plt.plot(pl1[\"strike\"], pl1[\"wing_model_vol\"], c='b', marker='o')\n", 115 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_ask\"], c='g', marker='o')\n", 116 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_bid\"], c='r', marker='o')\n", 117 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_prc\"], c='y', marker='o')\n", 118 | " pl1 = data_p.sort_values(by=\"strike\")\n", 119 | " plt.plot(pl1[\"strike\"], pl1[\"wing_model_vol\"], c='b', marker='x')\n", 120 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_ask\"], c='g', marker='x')\n", 121 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_bid\"], c='r', marker='x')\n", 122 | " plt.scatter(pl1[\"strike\"], pl1[\"market_imp_vol_prc\"], c='y', marker='x')\n", 123 | " plt.xlabel(\"strike\")\n", 124 | " plt.ylabel(\"imp_vol\")\n", 125 | " plt.yticks(np.arange(0.20, 0.41, 0.01))\n", 126 | " plt.xticks(pl1[\"strike\"], rotation=-60)\n", 127 | " plt.title('RM409')\n", 128 | " plt.legend(['CallWingModel', 'CallAskMktVol', 'CallBidMktVol', 'CallPrcMktVol', 'PutWingModel', 'PutAskMktVol', 'PutBidMktVol', 'PutPrcMktVol'])\n", 129 | " plt.savefig(\"./{}/RM409_{}.png\".format(ivs_log_path, time.strftime(\"%H_%M_%S\")), bbox_inches='tight')\n", 130 | " plt.savefig(\"./RM409.png\", bbox_inches='tight')\n", 131 | "\n", 132 | " plt.show()\n", 133 | " time.sleep(10)\n", 134 | " clear_output()\n" 135 | ] 136 | } 137 | ], 138 | "metadata": { 139 | "kernelspec": { 140 | "display_name": "base", 141 | "language": "python", 142 | "name": "python3" 143 | }, 144 | "language_info": { 145 | "codemirror_mode": { 146 | "name": "ipython", 147 | "version": 3 148 | }, 149 | "file_extension": ".py", 150 | "mimetype": "text/x-python", 151 | "name": "python", 152 | "nbconvert_exporter": "python", 153 | "pygments_lexer": "ipython3", 154 | "version": "3.11.9" 155 | } 156 | }, 157 | "nbformat": 4, 158 | "nbformat_minor": 2 159 | } 160 | -------------------------------------------------------------------------------- /main.py: -------------------------------------------------------------------------------- 1 | ''' 2 | @Time: 2024/4/11 2:03 PM 3 | @Author: Jincheng Gong 4 | @Contact: Jincheng.Gong@hotmail.com 5 | @File: main.py 6 | @Desc: ORC Wing Model Main Program 7 | ''' 8 | 9 | 10 | if __name__ == "__main__": 11 | print("ORC Wing Model powered by Jincheng Gong.") 12 | -------------------------------------------------------------------------------- /pdf/ORC_wing_model_instruction.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Jincheng-Gong/wing_model/d514b012ed5e3903a5edc427753ae0d175edfb65/pdf/ORC_wing_model_instruction.pdf -------------------------------------------------------------------------------- /pdf/no_butterfly_arbitrage_wing_model.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Jincheng-Gong/wing_model/d514b012ed5e3903a5edc427753ae0d175edfb65/pdf/no_butterfly_arbitrage_wing_model.pdf -------------------------------------------------------------------------------- /plot.py: -------------------------------------------------------------------------------- 1 | ''' 2 | @Time: 2024/4/17 11:10 AM 3 | @Author: Jincheng Gong 4 | @Contact: Jincheng.Gong@hotmail.com 5 | @File: plot.py 6 | @Desc: ORC Wing Model Solution Space Plot 7 | ''' 8 | 9 | import warnings 10 | 11 | import matplotlib.pyplot as plt 12 | import pandas as pd 13 | 14 | warnings.filterwarnings("ignore") 15 | 16 | 17 | if __name__ == "__main__": 18 | wing_sim_args = pd.read_csv("./data/wing_sim_args.csv", header=0) 19 | wing_sim_args_true = wing_sim_args[wing_sim_args['wing_model_combined_test']] 20 | 21 | sr_unique = wing_sim_args_true['sr_'].unique() 22 | sol_space = pd.DataFrame(columns=wing_sim_args_true.columns) 23 | for i in sr_unique: 24 | sol_space_i = wing_sim_args_true[wing_sim_args_true['sr_'] == i] 25 | sol_space = pd.concat([sol_space, 26 | sol_space_i[sol_space_i['cc_'] == sol_space_i['cc_'].max()], 27 | sol_space_i[sol_space_i['cc_'] == sol_space_i['cc_'].min()], 28 | sol_space_i[sol_space_i['pc_'] == sol_space_i['pc_'].max()], 29 | sol_space_i[sol_space_i['pc_'] == sol_space_i['pc_'].min()]]) 30 | 31 | ax = plt.subplot(projection='3d') 32 | ax.scatter(sol_space['cc_'], 33 | sol_space['pc_'], 34 | sol_space['sr_'], 35 | c='red', 36 | edgecolors='black', 37 | linewidths=0.5) 38 | plt.show() 39 | -------------------------------------------------------------------------------- /plot2.py: -------------------------------------------------------------------------------- 1 | ''' 2 | @Time: 2024/4/17 14:23 PM 3 | @Author: Jincheng Gong 4 | @Contact: Jincheng.Gong@hotmail.com 5 | @File: plot.py 6 | @Desc: ORC Wing Model Solution Space Plot with 2 Pictures 7 | ''' 8 | 9 | import matplotlib.pyplot as plt 10 | import pandas as pd 11 | 12 | 13 | if __name__ == "__main__": 14 | wing_sim_args = pd.read_csv("./data/wing_sim_args.csv", header=0) 15 | wing_sim_args_true = wing_sim_args[wing_sim_args['wing_model_combined_test']] 16 | 17 | sr_unique = wing_sim_args_true['sr_'].unique() 18 | sol_space = [] 19 | 20 | for i in sr_unique: 21 | sol_space_i = wing_sim_args_true[wing_sim_args_true['sr_'] == i] 22 | sol_space.append(sol_space_i[sol_space_i['cc_'] == sol_space_i['cc_'].max()]) 23 | sol_space.append(sol_space_i[sol_space_i['cc_'] == sol_space_i['cc_'].min()]) 24 | sol_space.append(sol_space_i[sol_space_i['pc_'] == sol_space_i['pc_'].max()]) 25 | sol_space.append(sol_space_i[sol_space_i['pc_'] == sol_space_i['pc_'].min()]) 26 | sol_space = pd.concat(sol_space) 27 | sol_space_positive = sol_space[sol_space['sr_'] >= 0] 28 | sol_space_negative = sol_space[sol_space['sr_'] <= 0] 29 | # * For solution space param test. 30 | # sol_space_negative['cc2_'] = sol_space_negative['pc_'] 31 | # sol_space_negative['pc2_'] = sol_space_negative['cc_'] 32 | # sol_space_negative['sr2_'] = -1 * sol_space_negative['sr_'] 33 | # sol_space_negative.to_csv('negative.csv', index=False) 34 | # sol_space_positive.to_csv('positive.csv', index=False) 35 | 36 | fig = plt.figure(1) 37 | ax1 = plt.subplot(2, 1, 1, projection='3d') 38 | ax1.scatter(sol_space_positive['cc_'], 39 | sol_space_positive['pc_'], 40 | sol_space_positive['sr_'], 41 | c='red', 42 | edgecolors='black', 43 | linewidths=0.5) 44 | ax1.set_xlabel("cc") 45 | ax1.set_ylabel("pc") 46 | ax1.set_zlabel("sc") 47 | ax2 = plt.subplot(2, 1, 2, projection='3d') 48 | ax2.scatter(sol_space_negative['cc_'], 49 | sol_space_negative['pc_'], 50 | sol_space_negative['sr_'], 51 | c='red', 52 | edgecolors='black', 53 | linewidths=0.5) 54 | ax2.set_xlabel("cc") 55 | ax2.set_ylabel("pc") 56 | ax2.set_zlabel("sc") 57 | plt.show() 58 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | numpy 2 | matplotlib 3 | pandas 4 | scipy 5 | -------------------------------------------------------------------------------- /utils/black_scholes.py: -------------------------------------------------------------------------------- 1 | ''' 2 | @Time: 2024/4/12 9:10 AM 3 | @Author: Jincheng Gong 4 | @Contact: Jincheng.Gong@hotmail.com 5 | @File: black_scholes.py 6 | @Desc: Black-Scholes Utilities include Black-Scholes Price, Implied Volatility and Greeks 7 | ''' 8 | 9 | import numpy as np 10 | from scipy.stats import norm 11 | 12 | MAX_ITERS = 1000 13 | MAX_ERROR = 10e-7 14 | 15 | 16 | def bs_d1(f: float, k: float, t: float, v: float) -> float: 17 | """ 18 | :param f: Forward (in %) 19 | :param k: Strike (in %) 20 | :param t: Maturity (in Years) 21 | :param v: Constant Annual Volatility (in %) 22 | :return: d1 23 | """ 24 | return (np.log(f / k) + v * v * t / 2) / v / np.sqrt(t) 25 | 26 | 27 | def bs_d2(f: float, k: float, t: float, v: float) -> float: 28 | """ 29 | :param f: Forward (in %) 30 | :param k: Strike (in %) 31 | :param t: Maturity (in Years) 32 | :param v: Constant Annual Volatility (in %) 33 | :return: d2 34 | """ 35 | return bs_d1(f, k, t, v) - v * np.sqrt(t) 36 | 37 | 38 | def normal_distrib(z: float, mean=0, stdev=1) -> float: 39 | """ 40 | :param z: Datapoint 41 | :param mean: Normal Distribution Expectation 42 | :param stdev: Normal Distribution Standard Deviation 43 | :return: Datapoint Normal Value 44 | """ 45 | return norm.pdf(z, loc=mean, scale=stdev) 46 | 47 | 48 | def snorm(z: float) -> float: 49 | """ 50 | :param z: Datapoint 51 | :return: Datapoint Cumulative Normal Value 52 | """ 53 | return norm.cdf(z) 54 | 55 | 56 | def bs_price(f: float, k: float, t: float, v: float, r: float, opt_type: str) -> float: 57 | """ 58 | :param f: Forward (in %) 59 | :param k: Strike (in %) 60 | :param t: Maturity (in Years) 61 | :param v: Constant Annual Volatility (in %) 62 | :param r: Risk-free Rate (in %) 63 | :param opt_type: Either "c", "p", "c+p" or "c-p" 64 | :return: Black-Scholes Price 65 | """ 66 | d1 = bs_d1(f, k, t, v) 67 | d2 = d1 - v * np.sqrt(t) 68 | switcher = { 69 | "c": np.exp(-r * t) * (f * snorm(d1) - k * snorm(d2)), 70 | "p": np.exp(-r * t) * (-f * snorm(-d1) + k * snorm(-d2)), 71 | "c+p": np.exp(-r * t) * (f * snorm(d1) - snorm(-d1)) - k * (snorm(d2) - snorm(-d2)), 72 | "c-p": np.exp(-r * t) * (f * snorm(d1) + snorm(-d1)) - k * (snorm(d2) + snorm(-d2)), 73 | } 74 | return switcher.get(opt_type.lower(), 0) 75 | 76 | 77 | def bs_delta(f: float, k: float, t: float, v: float, r: float, opt_type: str) -> float: 78 | """ 79 | :param f: Forward (in %) 80 | :param k: Strike (in %) 81 | :param t: Maturity (in Years) 82 | :param v: Constant Annual Volatility (in %) 83 | :param r: Risk-free Rate (in %) 84 | :param opt_type: Either "c", "p", "c+p" or "c-p" 85 | :return: Black-Scholes Delta 86 | """ 87 | d1 = bs_d1(f, k, t, v) 88 | switcher = { 89 | "c": np.exp(-r * t) * snorm(d1), 90 | "p": -np.exp(-r * t) * snorm(-d1), 91 | "c+p": np.exp(-r * t) * (snorm(d1) - snorm(-d1)), 92 | "c-p": np.exp(-r * t) * (snorm(d1) + snorm(-d1)), 93 | } 94 | return switcher.get(opt_type.lower(), 0) 95 | 96 | 97 | def bs_dual_delta(f: float, k: float, t: float, v: float, r: float, opt_type: str) -> float: 98 | """ 99 | :param f: Forward (in %) 100 | :param k: Strike (in %) 101 | :param t: Maturity (in Years) 102 | :param v: Constant Annual Volatility (in %) 103 | :param r: Risk-free Rate (in %) 104 | :param opt_type: Either "c", "p", "c+p" or "c-p" 105 | :return: Black-Scholes Dual Delta 106 | """ 107 | d2 = bs_d2(f, k, t, v) 108 | switcher = { 109 | "c": -np.exp(-r * t) * snorm(d2), 110 | "p": np.exp(-r * t) * snorm(-d2), 111 | "c+p": np.exp(-r * t) * (-snorm(d2) + snorm(-d2)), 112 | "c-p": np.exp(-r * t) * (-snorm(d2) - snorm(-d2)), 113 | } 114 | return switcher.get(opt_type.lower(), 0) 115 | 116 | 117 | def bs_gamma(f: float, k: float, t: float, v: float, r: float, opt_type: str) -> float: 118 | """ 119 | :param f: Forward (in %) 120 | :param k: Strike (in %) 121 | :param t: Maturity (in Years) 122 | :param v: Constant Annual Volatility (in %) 123 | :param r: Risk-free Rate (in %) 124 | :param opt_type: Either "c", "p", "c+p" or "c-p" 125 | :return: Black-Scholes Gamma 126 | """ 127 | d1 = bs_d1(f, k, t, v) 128 | fd1 = normal_distrib(d1) 129 | switcher = { 130 | "c": np.exp(-r * t) * fd1 / (f * v * np.sqrt(t)), 131 | "p": np.exp(-r * t) * fd1 / (f * v * np.sqrt(t)), 132 | "c+p": 2 * np.exp(-r * t) * fd1 / (f * v * np.sqrt(t)), 133 | "c-p": 0, 134 | } 135 | return switcher.get(opt_type.lower(), 0) 136 | 137 | 138 | def bs_theta(f: float, k: float, t: float, v: float, r: float, opt_type: str) -> float: 139 | """ 140 | :param f: Forward (in %) 141 | :param k: Strike (in %) 142 | :param t: Maturity (in Years) 143 | :param v: Constant Annual Volatility (in %) 144 | :param r: Risk-free Rate (in %) 145 | :param opt_type: Either "c", "p", "c+p" or "c-p" 146 | :return: Black-Scholes Theta 147 | """ 148 | d1 = bs_d1(f, k, t, v) 149 | d2 = d1 - v * np.sqrt(t) 150 | switcher = { 151 | "c": -np.exp(-r * t) * ((f * snorm(d1) * v) / 152 | (2 * np.sqrt(t)) - (r * f * snorm(d1)) + (r * k * snorm(d2))), 153 | "p": -np.exp(-r * t) * ((f * snorm(d1) * v) / 154 | (2 * np.sqrt(t)) + (r * f * snorm(-d1)) - (r * k * snorm(-d2))), 155 | "c+p": bs_theta(f, k, t, v, r, "c") + bs_theta(f, k, t, v, r, "p"), 156 | "c-p": bs_theta(f, k, t, v, r, "c") - bs_theta(f, k, t, v, r, "p"), 157 | } 158 | return switcher.get(opt_type.lower(), 0) 159 | 160 | 161 | def bs_vega(f: float, k: float, t: float, v: float, r: float, opt_type: str) -> float: 162 | """ 163 | :param f: Forward (in %) 164 | :param k: Strike (in %) 165 | :param t: Maturity (in Years) 166 | :param v: Constant Annual Volatility (in %) 167 | :param r: Risk-free Rate (in %) 168 | :param opt_type: Either "c", "p", "c+p" or "c-p" 169 | :return: Black-Scholes Vega 170 | """ 171 | d1 = bs_d1(f, k, t, v) 172 | fd1 = normal_distrib(d1) 173 | switcher = { 174 | "c": np.exp(-r * t) * f * fd1 * np.sqrt(t), 175 | "p": np.exp(-r * t) * f * fd1 * np.sqrt(t), 176 | "c+p": 2 * np.exp(-r * t) * f * fd1 * np.sqrt(t), 177 | "c-p": 0, 178 | } 179 | return switcher.get(opt_type.lower(), 0) 180 | 181 | 182 | def bs_vanna(f: float, k: float, t: float, v: float, r: float, opt_type: str) -> float: 183 | """ 184 | :param f: Forward (in %) 185 | :param k: Strike (in %) 186 | :param t: Maturity (in Years) 187 | :param v: Constant Annual Volatility (in %) 188 | :param r: Risk-free Rate (in %) 189 | :param opt_type: Either "c", "p", "c+p" or "c-p" 190 | :return: Black-Scholes Vanna 191 | """ 192 | d1 = bs_d1(f, k, t, v) 193 | d2 = d1 - v * np.sqrt(t) 194 | fd1 = normal_distrib(d1) 195 | switcher = { 196 | "c": -np.exp(-r * t) * fd1 * d2 / v, 197 | "p": -np.exp(-r * t) * fd1 * d2 / v, 198 | "c+p": -2 * np.exp(-r * t) * fd1 * d2 / v, 199 | "c-p": 0, 200 | } 201 | return switcher.get(opt_type.lower(), 0) 202 | 203 | 204 | def bs_volga(f: float, k: float, t: float, v: float, r: float, opt_type: str) -> float: 205 | """ 206 | :param f: Forward (in %) 207 | :param k: Strike (in %) 208 | :param t: Maturity (in Years) 209 | :param v: Constant Annual Volatility (in %) 210 | :param r: Risk-free Rate (in %) 211 | :param opt_type: Either "c", "p", "c+p" or "c-p" 212 | :return: Black-Scholes Volga 213 | """ 214 | d1 = bs_d1(f, k, t, v) 215 | d2 = d1 - v * np.sqrt(t) 216 | fd1 = normal_distrib(d1) 217 | switcher = { 218 | "c": np.exp(-r * t) * f * np.sqrt(t) * fd1 * np.sqrt(t) * d1 * d2, 219 | "p": np.exp(-r * t) * f * np.sqrt(t) * fd1 * np.sqrt(t) * d1 * d2, 220 | "c+p": 2 * np.exp(-r * t) * f * np.sqrt(t) * fd1 * np.sqrt(t) * d1 * d2, 221 | "c-p": 0, 222 | } 223 | return switcher.get(opt_type.lower(), 0) 224 | 225 | 226 | def bs_iv_newton_raphson(f: float, k: float, t: float, mkt_price: float, 227 | r: float, opt_type: str) -> float: 228 | """ 229 | :param f: Forward (in %) 230 | :param k: Strike (in %) 231 | :param t: Maturity (in Years) 232 | :param mkt_price: Option Market Price (in %) 233 | :param r: Risk-free Rate (in %) 234 | :param opt_type: Either "c", "p", "c+p" or "c-p" 235 | :return: Black-Scholes Implied Volatility 236 | """ 237 | iter_numb = 0 238 | v = 0.30 239 | bs_price_error = mkt_price - bs_price(f, k, t, v, r, opt_type) 240 | while ((abs(bs_price_error) > MAX_ERROR) and (iter_numb < MAX_ITERS)): 241 | vega = bs_vega(f, k, t, v, r, opt_type) 242 | if vega == 0: 243 | return -1, iter_numb 244 | if vega != 0: 245 | v += bs_price_error / vega 246 | iter_numb += 1 247 | return v, iter_numb 248 | 249 | 250 | if __name__ == "__main__": 251 | print("Black-Scholes utilities powered by Jincheng Gong.") 252 | -------------------------------------------------------------------------------- /utils/calibrator.py: -------------------------------------------------------------------------------- 1 | ''' 2 | @Time: 2024/4/9 2:32 PM 3 | @Author: Jincheng Gong 4 | @Contact: Jincheng.Gong@hotmail.com 5 | @File: calibrator.py 6 | @Desc: ORC Wing Model Calibrator with Durrleman Condition 7 | ''' 8 | 9 | import random 10 | from typing import List 11 | 12 | import numpy as np 13 | from scipy import optimize 14 | 15 | 16 | def wing_model_durrleman_condition(vr_: float, sr_: float, pc_: float, cc_: float, 17 | dc_: float, uc_: float, dsm_: float, usm_: float, 18 | vcr_: float = 0, scr_: float = 0, ssr_: float = 100, 19 | atm_: float = 1, ref_: float = 1) -> List[List[float]]: 20 | """ 21 | :param vr_: volatility reference 22 | :param sr_: slope reference 23 | :param pc_: put curvature 24 | :param cc_: call curvature 25 | :param dc_: down cutoff 26 | :param uc_: up cutoff 27 | :param dsm_: down smoothing range 28 | :param usm_: up smoothing range 29 | :param atm_: atm forward 30 | :param ref_: reference forward price 31 | :param vcr_: volatility change rate 32 | :param scr_: slope change rate 33 | :param ssr_: skew swimmingness rate 34 | :return: wing model durrleman conditon for each moneyness 35 | """ 36 | moneyness_list = np.linspace(dc_, uc_, 50) 37 | vc_ = vr_ - vcr_ * ssr_ * ((atm_ - ref_) / ref_) 38 | sc_ = sr_ - scr_ * ssr_ * ((atm_ - ref_) / ref_) 39 | g_list = [] 40 | for moneyness in moneyness_list: 41 | if moneyness <= dc_ * (1 + dsm_): 42 | g_list.append(1) 43 | elif dc_ * (1 + dsm_) < moneyness < dc_: # dc_ * (1 + dsm_) < moneyness <= dc_ 44 | a = - pc_ / dsm_ - 0.5 * sc_ / (dc_ * dsm_) 45 | b1 = -0.25 * ((1 + 1 / dsm_) * (2 * dc_ * pc_ + sc_) - 2 * 46 | (pc_ / dsm_ + 0.5 * sc_ / (dc_ * dsm_)) * moneyness) ** 2 47 | b2 = -dc_ ** 2 * (1 + 1 / dsm_) * pc_ - 0.5 * dc_ * sc_ / \ 48 | dsm_ + vc_ + (1 + 1 / dsm_) * (2 * dc_ * pc_ + sc_) * \ 49 | moneyness - (pc_ / dsm_ + 0.5 * sc_ / 50 | (dc_ * dsm_)) * moneyness ** 2 51 | b2 = 0.25 + 1 / b2 52 | b = b1 * b2 53 | c1 = moneyness * ((1 + 1 / dsm_) * (2 * dc_ * pc_ + sc_) - 54 | 2 * (pc_ / dsm_ + 0.5 * sc_ / (dc_ * dsm_)) * moneyness) 55 | c2 = 2 * (-dc_ ** 2 * (1 + 1 / dsm_) * pc_ - 0.5 * dc_ * sc_ / 56 | dsm_ + vc_ + (1 + 1 / dsm_) * (2 * dc_ * pc_ + sc_) * 57 | moneyness - (pc_ / dsm_ + 0.5 * sc_ / (dc_ * dsm_)) * moneyness ** 2) 58 | c = (1 - c1 / c2) ** 2 59 | g_list.append(a + b + c) 60 | elif dc_ <= moneyness <= 0: # dc_ < moneyness <= 0 61 | g_list.append(pc_ - 0.25 * (sc_ + 2 * pc_ * moneyness) ** 2 * 62 | (0.25 + 1 / (vc_ + sc_ * moneyness + 63 | pc_ * moneyness * moneyness)) 64 | + (1 - 0.5 * moneyness * (sc_ + 2 * pc_ * moneyness) / 65 | (vc_ + sc_ * moneyness + pc_ * moneyness * moneyness)) ** 2) 66 | elif 0 < moneyness <= uc_: 67 | g_list.append(cc_ - 0.25 * (sc_ + 2 * cc_ * moneyness) ** 2 * 68 | (0.25 + 1 / (vc_ + sc_ * moneyness + 69 | cc_ * moneyness * moneyness)) 70 | + (1 - 0.5 * moneyness * (sc_ + 2 * cc_ * moneyness) / 71 | (vc_ + sc_ * moneyness + cc_ * moneyness * moneyness)) ** 2) 72 | elif uc_ < moneyness <= uc_ * (1 + usm_): 73 | a = - cc_ / usm_ - 0.5 * sc_ / (uc_ * usm_) 74 | b1 = -0.25 * ((1 + 1 / usm_) * (2 * uc_ * cc_ + sc_) - 2 * 75 | (cc_ / usm_ + 0.5 * sc_ / (uc_ * usm_)) * moneyness) ** 2 76 | b2 = -uc_ ** 2 * (1 + 1 / usm_) * cc_ - 0.5 * uc_ * sc_ / \ 77 | usm_ + vc_ + (1 + 1 / usm_) * (2 * uc_ * cc_ + sc_) * \ 78 | moneyness - (cc_ / usm_ + 0.5 * sc_ / 79 | (uc_ * usm_)) * moneyness ** 2 80 | b2 = 0.25 + 1 / b2 81 | b = b1 * b2 82 | c1 = moneyness * ((1 + 1 / usm_) * (2 * uc_ * cc_ + sc_) - 83 | 2 * (cc_ / usm_ + 0.5 * sc_ / (uc_ * usm_)) * moneyness) 84 | c2 = 2 * (-uc_ ** 2 * (1 + 1 / usm_) * cc_ - 0.5 * uc_ * sc_ / 85 | usm_ + vc_ + (1 + 1 / usm_) * (2 * uc_ * cc_ + sc_) * 86 | moneyness - (cc_ / usm_ + 0.5 * sc_ / (uc_ * usm_)) * moneyness ** 2) 87 | c = (1 - c1 / c2) ** 2 88 | g_list.append(a + b + c) 89 | elif uc_ * (1 + usm_) < moneyness: 90 | g_list.append(1) 91 | return [moneyness_list, g_list] 92 | 93 | 94 | def wing_model(k: float, 95 | vr_: float, sr_: float, pc_: float, cc_: float, 96 | dc_: float, uc_: float, dsm_: float, usm_: float, 97 | vcr_: float = 0, scr_: float = 0, ssr_: float = 100, 98 | atm_: float = 1, ref_: float = 1) -> float: 99 | """ 100 | :param k: log forward moneyness 101 | :param vr_: volatility reference 102 | :param sr_: slope reference 103 | :param pc_: put curvature 104 | :param cc_: call curvature 105 | :param dc_: down cutoff 106 | :param uc_: up cutoff 107 | :param dsm_: down smoothing range 108 | :param usm_: up smoothing range 109 | :param atm_: atm forward 110 | :param ref_: reference forward price 111 | :param vcr_: volatility change rate 112 | :param scr_: slope change rate 113 | :param ssr_: skew swimmingness rate 114 | :return: wing model volatility 115 | """ 116 | vc_ = vr_ - vcr_ * ssr_ * ((atm_ - ref_) / ref_) 117 | sc_ = sr_ - scr_ * ssr_ * ((atm_ - ref_) / ref_) 118 | if k < dc_ * (1 + dsm_): 119 | res = vc_ + dc_ * (2 + dsm_) * (sc_ / 2) + \ 120 | (1 + dsm_) * pc_ * pow(dc_, 2) 121 | elif dc_ * (1 + dsm_) < k <= dc_: 122 | res = vc_ - (1 + 1 / dsm_) * pc_ * pow(dc_, 2) - sc_ * dc_ / (2 * dsm_) + (1 + 1 / dsm_) * \ 123 | (2 * pc_ * dc_ + sc_) * k - \ 124 | (pc_ / dsm_ + sc_ / (2 * dc_ * dsm_)) * pow(k, 2) 125 | elif dc_ < k <= 0: 126 | res = vc_ + sc_ * k + pc_ * pow(k, 2) 127 | elif 0 < k <= uc_: 128 | res = vc_ + sc_ * k + cc_ * pow(k, 2) 129 | elif uc_ < k <= uc_ * (1 + usm_): 130 | res = vc_ - (1 + 1 / usm_) * cc_ * pow(uc_, 2) - sc_ * uc_ / (2 * usm_) + (1 + 1 / usm_) * \ 131 | (2 * cc_ * uc_ + sc_) * k - \ 132 | (cc_ / usm_ + sc_ / (2 * uc_ * usm_)) * pow(k, 2) 133 | elif uc_ * (1 + usm_) < k: 134 | res = vc_ + uc_ * (2 + usm_) * (sc_ / 2) + \ 135 | (1 + usm_) * cc_ * pow(uc_, 2) 136 | else: 137 | raise ValueError("log forward moneyness value input error!") 138 | return res 139 | 140 | 141 | def wing_model_loss_function(wing_model_params_list_solve: List[float], 142 | wing_model_params_list_input: List[float], 143 | moneyness_inputs_list: List[float], 144 | mkt_implied_vol_list: List[float], 145 | mkt_vega_list: List[float], 146 | butterfly_arbitrage_free_cond: 'bool' = True) -> float: 147 | """ 148 | :param wing_model_params_list_solve: [vr_, sc_, cc_, pc_] 149 | :param wing_model_params_list_input: [dc_, uc_, dsm_, usm_] 150 | :param moneyness_inputs_list: [k_1, k_2, k_3, ...] 151 | :param mkt_implied_vol_list: [vol_1, vol_2, vol_3, ...] 152 | :param mkt_vega_list: [vega_1, vega_2, vega_3, ...] 153 | :param butterfly_arbitrage_free_cond: add penality if Durrleman condition is not respected 154 | :return: wing model calibration error 155 | """ 156 | max_mkt_vega = max(mkt_vega_list) 157 | # Mean Squared Error (MSE) 158 | se = 0 159 | for i, moneyness_inputs in enumerate(moneyness_inputs_list): 160 | wing_model_vol = wing_model(k=moneyness_inputs, 161 | vr_=wing_model_params_list_solve[0], 162 | sr_=wing_model_params_list_solve[1], 163 | pc_=wing_model_params_list_solve[2], 164 | cc_=wing_model_params_list_solve[3], 165 | dc_=wing_model_params_list_input[0], 166 | uc_=wing_model_params_list_input[1], 167 | dsm_=wing_model_params_list_input[2], 168 | usm_=wing_model_params_list_input[3]) 169 | se += ((wing_model_vol - mkt_implied_vol_list[i]) * mkt_vega_list[i] / max_mkt_vega) ** 2 170 | mse = ((se) ** 0.5) / len(moneyness_inputs_list) 171 | # Butterfly Arbitrage Penality (Durrleman Condition) 172 | butterfly_arbitrage_penality = 0 173 | if butterfly_arbitrage_free_cond: 174 | _, g_list = wing_model_durrleman_condition(vr_=wing_model_params_list_solve[0], 175 | sr_=wing_model_params_list_solve[1], 176 | pc_=wing_model_params_list_solve[2], 177 | cc_=wing_model_params_list_solve[3], 178 | dc_=wing_model_params_list_input[0], 179 | uc_=wing_model_params_list_input[1], 180 | dsm_=wing_model_params_list_input[2], 181 | usm_=wing_model_params_list_input[3]) 182 | if min(g_list) < 0: 183 | butterfly_arbitrage_penality = 10e5 184 | return mse + butterfly_arbitrage_penality 185 | 186 | 187 | def wing_model_calibrator(wing_model_params_list_input: List[float], 188 | moneyness_inputs_list: List[float], 189 | mkt_implied_vol_list: List[float], 190 | mkt_vega_list: List[float], 191 | is_bound_limit: bool = False, 192 | epsilon: float = 1e-16) -> float: 193 | """ 194 | :param wing_model_params_list_input: [dc_, uc_, dsm_, usm_] 195 | :param moneyness_inputs_list: [k_1, k_2, k_3, ...] 196 | :param mkt_implied_vol_list: [vol_1, vol_2, vol_3, ...] 197 | :param mkt_vega_list: [vega_1, vega_2, vega_3, ...] 198 | :param is_bound_limit: add optimize bound limit if set to True 199 | :param epsilon: optimize accuracy 200 | :return: wing model solved params dict 201 | """ 202 | # Set initial guess for wing_model_params_list_solve 203 | # wing_model_params_list_guess = [0.124577, random.random(), random.random(), random.random()] 204 | wing_model_params_list_guess = [random.random(), random.random(), 205 | random.random(), random.random()] 206 | if is_bound_limit: 207 | bounds = ([-1e3, 1e3], [-1e3, 1e3], [-1e3, 1e3], [-1e3, 1e3]) 208 | # bounds = ([0.114577, 0.134577], [-1e3, 1e3], [0, 1e3], [0, 1e3]) 209 | else: 210 | bounds = ([None, None], [None, None], [None, None], [None, None]) 211 | args = (wing_model_params_list_input, 212 | moneyness_inputs_list, 213 | mkt_implied_vol_list, 214 | mkt_vega_list) 215 | res = optimize.minimize(fun=wing_model_loss_function, 216 | x0=wing_model_params_list_guess, 217 | args=args, 218 | method="SLSQP", 219 | bounds=bounds, 220 | tol=epsilon) 221 | # assert res.success 222 | # print(res.success) 223 | wing_model_solve = list(res.x) 224 | res_dict = {"success": res.success, 225 | "vr_": wing_model_solve[0], 226 | "sr_": wing_model_solve[1], 227 | "pc_": wing_model_solve[2], 228 | "cc_": wing_model_solve[3]} 229 | print(res_dict) 230 | return res_dict 231 | 232 | 233 | if __name__ == "__main__": 234 | print("ORC wing model calibrator powered by Jincheng Gong.") 235 | --------------------------------------------------------------------------------