NewQuant/futures_trading_strategies/FG/FisherTrendStrategy/search_Strategy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "id": "522f09ca7b3fe929",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-02-21T18:33:30.135169Z",
     "start_time": "2026-02-21T18:33:30.100924Z"
    }
   },
   "source": [
    "import sys\n",
    "\n",
    "if '/mnt/d/PyProject/NewQuant/' not in sys.path:\n",
    "    sys.path.append('/mnt/d/PyProject/NewQuant/')\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "code",
   "id": "4f7e4b438cea750e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-02-21T18:33:31.099905Z",
     "start_time": "2026-02-21T18:33:30.138432Z"
    }
   },
   "source": [
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "import itertools\n",
    "from typing import Dict, Any, List, Tuple, Optional\n",
    "import multiprocessing  # 导入 multiprocessing 模块\n",
    "import math  # 保留 math 导入，因为您的策略内部可能需要用到数学函数\n",
    "\n",
    "# 导入所有必要的模块\n",
    "# 请确保这些导入路径与您的项目结构相符\n",
    "from src.analysis.grid_search_analyzer import GridSearchAnalyzer\n",
    "from src.analysis.result_analyzer import ResultAnalyzer\n",
    "from src.common_utils import generate_parameter_range\n",
    "from src.data_manager import DataManager\n",
    "from src.backtest_engine import BacktestEngine\n",
    "# 导入策略类\n",
    "\n",
    "import builtins\n",
    "\n",
    "origin_print = print\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-02-21T18:33:31.123206Z",
     "start_time": "2026-02-21T18:33:31.104195Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "def slient_print(*args):\n",
    "    pass\n"
   ],
   "id": "f903fd2761d446cd",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-02-21T18:36:12.827204Z",
     "start_time": "2026-02-21T18:33:31.124458Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "# --- 主执行块 ---\n",
    "# 这是多进程代码的入口点，必须在 'if __name__ == \"__main__\":' 保护块中\n",
    "# 确保 autoreload 启用 (在Jupyter Notebook中使用，纯Python脚本运行时可移除)\n",
    "# %load_ext autoreload\n",
    "# %autoreload 2\n",
    "\n",
    "from src.strategies.FisherTrendStrategy.FisherTrendStrategy2 import PragmaticCyberneticStrategy\n",
    "from src.strategies.TestStrategy.utils import run_single_backtest\n",
    "\n",
    "# --- 全局配置 ---\n",
    "data_file_path = \"D:/PyProject/NewQuant/data/data/KQ_m@CZCE_FG/KQ_m@CZCE_FG_min15.csv\"\n",
    "\n",
    "initial_capital = 100000.0\n",
    "slippage_rate = 0.0000\n",
    "commission_rate = 0.0000\n",
    "global_config = {\n",
    "    'symbol': 'FG',\n",
    "}\n",
    "# 确保每个合约的tick_size在这里定义或获取\n",
    "RB_TICK_SIZE = 1.0  # 螺纹钢的最小变动单位\n",
    "\n",
    "# --- 定义参数网格 ---\n",
    "param1_name = \"fb_entry_threshold\"\n",
    "param1_values = generate_parameter_range(start=0.1, end=2.1, step=0.2)\n",
    "param2_name = \"fisher_exit_level\"\n",
    "param2_values = generate_parameter_range(start=0.1, end=2.1, step=0.2)\n",
    "# param2_name = \"fisher_exit_level\"\n",
    "# param2_values = generate_parameter_range(start=0.1, end=0.5, step=0.05)\n",
    "optimization_metric = 'total_return'\n",
    "\n",
    "strategy_params = {\n",
    "    'trend_period': 6\n",
    "}\n",
    "\n",
    "# 生成所有参数组合\n",
    "param_combinations = list(itertools.product(param1_values, param2_values))\n",
    "total_combinations = len(param_combinations)\n",
    "print(f\"总计 {total_combinations} 种参数组合需要回测。\")\n",
    "\n",
    "all_results: List[Dict[str, Any]] = []\n",
    "grid_results: List[Dict[str, Any]] = []\n",
    "\n",
    "# 准备传递给每个子进程的公共配置字典\n",
    "common_config_for_processes = {\n",
    "    'main_symbol': global_config['symbol'],\n",
    "    'symbol': global_config['symbol'],\n",
    "    'data_path': data_file_path,\n",
    "    'initial_capital': initial_capital,\n",
    "    'slippage_rate': slippage_rate,\n",
    "    'commission_rate': commission_rate,\n",
    "    'start_time': datetime(2022, 1, 1),  # 回测起始时间\n",
    "    'end_time': datetime(2024, 6, 1),  # 回测结束时间\n",
    "    'roll_over_mode': True,  # 保持换月模式\n",
    "    'param1_name': param1_name,\n",
    "    'param2_name': param2_name,\n",
    "    'optimization_metric': optimization_metric,\n",
    "    'strategy': PragmaticCyberneticStrategy,\n",
    "    # 'hawkes_entry_percent': 0.9,\n",
    "    'strategy_params': strategy_params\n",
    "}\n",
    "\n",
    "# 确定要使用的进程数量 (通常是CPU核心数)\n",
    "num_processes = int(multiprocessing.cpu_count() * 0.6)\n",
    "if num_processes < 1:\n",
    "    num_processes = 1\n",
    "\n",
    "print(f\"--- 启动多进程网格搜索，使用 {num_processes} 个进程 ---\")\n",
    "\n",
    "builtins.print = slient_print\n",
    "\n",
    "# 创建一个进程池\n",
    "with multiprocessing.Pool(processes=num_processes) as pool:\n",
    "    # 准备 run_single_backtest 函数的参数列表\n",
    "    # starmap 需要一个可迭代对象，其中每个元素是传递给目标函数的参数元组\n",
    "    args_for_starmap = [\n",
    "        (combo, common_config_for_processes) for combo in param_combinations\n",
    "    ]\n",
    "\n",
    "    run_single_backtest(*args_for_starmap[0])\n",
    "\n",
    "    # 使用 starmap() 来并行执行 run_single_backtest 函数\n",
    "    # starmap 是阻塞的，会等待所有任务完成并返回结果列表\n",
    "    for i, result_entry in enumerate(pool.starmap(run_single_backtest, args_for_starmap)):\n",
    "        if result_entry:  # 确保结果不为空\n",
    "            all_results.append(result_entry)\n",
    "            # 仅将成功的（无错误的）结果添加到用于网格分析的列表中\n",
    "            if 'error' not in result_entry:\n",
    "                grid_results.append(\n",
    "                    {\n",
    "                        param1_name: result_entry.get(param1_name),\n",
    "                        param2_name: result_entry.get(param2_name),\n",
    "                        **result_entry,\n",
    "                    }\n",
    "                )\n",
    "            else:\n",
    "                # 对于失败的组合，将其优化指标设置为一个特殊值，便于识别\n",
    "                grid_results.append(\n",
    "                    {\n",
    "                        param1_name: result_entry.get(param1_name),\n",
    "                        param2_name: result_entry.get(param2_name),\n",
    "                        **result_entry,\n",
    "                        'error_message': result_entry['error']\n",
    "                    }\n",
    "                )\n",
    "\n",
    "builtins.print = origin_print\n",
    "print(\"\\n--- 网格搜索回测完毕 ---\")"
   ],
   "id": "aed5938660e42b20",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "总计 121 种参数组合需要回测。\n",
      "--- 启动多进程网格搜索，使用 12 个进程 ---\n",
      "\n",
      "--- 网格搜索回测完毕 ---\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-02-21T18:36:13.053778Z",
     "start_time": "2026-02-21T18:36:12.837824Z"
    }
   },
   "cell_type": "code",
   "source": [
    "optimization_metric = 'total_return'\n",
    "# --- 5. 后处理和最佳结果选择 ---\n",
    "if all_results:\n",
    "    results_df = pd.DataFrame(all_results)\n",
    "    # print(\"\\n--- 所有回测结果汇总 ---\")\n",
    "    # # 确保打印时浮点数格式化\n",
    "    # pd.set_option('display.float_format', lambda x: '%.4f' % x)\n",
    "    # print(results_df.to_string())\n",
    "\n",
    "    # 找到最佳组合 (排除有错误的)\n",
    "    # 过滤掉包含 'error' 键的行，或者 'error' 键的值不为空的行\n",
    "    # 同时确保优化指标是数值，并且不为无穷大\n",
    "    print(results_df.info())\n",
    "    successful_results_df = results_df[(pd.to_numeric(results_df[optimization_metric], errors='coerce').notna()) &\n",
    "                                       (pd.to_numeric(results_df[optimization_metric], errors='coerce') != float(\n",
    "                                           '-inf'))\n",
    "                                       ].copy()  # 使用 .copy() 避免 SettingWithCopyWarning\n",
    "\n",
    "    if not successful_results_df.empty and optimization_metric in successful_results_df.columns:\n",
    "        # 确保优化指标列是数值类型\n",
    "        successful_results_df[optimization_metric] = pd.to_numeric(successful_results_df[optimization_metric],\n",
    "                                                                   errors='coerce')\n",
    "\n",
    "        if not successful_results_df.empty and optimization_metric in successful_results_df.columns:\n",
    "            # 过滤掉NaN值，如果所有夏普比率都是NaN，则可能没有有效结果\n",
    "            normal_results = successful_results_df[\n",
    "                (results_df['total_trades'] > 300)\n",
    "                # &\n",
    "                # (results_df['profit_factor'] < 3.)\n",
    "            ]\n",
    "            if len(normal_results) > 0:\n",
    "                best_result = normal_results.loc[(normal_results[optimization_metric].idxmax())]\n",
    "                print(f\"\\n--- 最优参数组合 (按{optimization_metric}) ---\")\n",
    "                print(best_result)\n",
    "            else:\n",
    "                print('ERROR!!!!!!!!!!!!!!!!!!!!')\n",
    "\n",
    "        # 找到最大值的索引\n",
    "        # best_result = successful_results_df.loc[successful_results_df[optimization_metric].idxmax()]\n",
    "        # print(f\"\\n--- 最优参数组合 (按 {optimization_metric}) ---\")\n",
    "        # print(best_result)\n",
    "\n",
    "        # 导出到CSV\n",
    "        output_filename = f\"grid_search_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv\"\n",
    "        # results_df.to_csv(output_filename, index=False, encoding='utf-8')\n",
    "        # print(f\"\\n所有结果已导出到: {output_filename}\")\n",
    "\n",
    "        # 打印枢轴表\n",
    "        grid_df = pd.DataFrame(grid_results)\n",
    "        # 确保优化指标列是数值类型，非数值的（如 -inf）在pandas中可能被正确处理\n",
    "        grid_df[optimization_metric] = pd.to_numeric(grid_df[optimization_metric], errors='coerce')\n",
    "\n",
    "        pivot_table = grid_df.pivot_table(\n",
    "            index=param1_name, columns=param2_name, values=optimization_metric\n",
    "        )\n",
    "        # print(f\"\\n{optimization_metric} 网格结果 (Pivoted):\")\n",
    "        # print(pivot_table.to_string())\n",
    "    else:\n",
    "        print(f\"\\n没有成功的组合结果可供分析，或优化指标 '{optimization_metric}' 不在结果中，或所有组合均失败。\")\n",
    "else:\n",
    "    print(\"没有可用的回测结果。\")\n",
    "print(\"\\n--- 动态网格搜索完成 ---\")\n",
    "\n",
    "# --- 6. 可视化 (依赖 GridSearchAnalyzer) ---\n",
    "if grid_results:\n",
    "    grid_analyzer = GridSearchAnalyzer(grid_results, optimization_metric)\n",
    "    grid_analyzer.find_best_parameters()  # 这会找到并打印最佳参数\n",
    "    grid_analyzer.plot_heatmap()  # 这会绘制热力图\n",
    "else:\n",
    "    print(\"\\n没有生成任何网格搜索结果，无法进行分析。\")"
   ],
   "id": "a1c18a2776fcaba2",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 121 entries, 0 to 120\n",
      "Data columns (total 39 columns):\n",
      " #   Column                Non-Null Count  Dtype  \n",
      "---  ------                --------------  -----  \n",
      " 0   main_symbol           121 non-null    object \n",
      " 1   trade_volume          121 non-null    int64  \n",
      " 2   fb_entry_threshold    121 non-null    float64\n",
      " 3   fisher_exit_level     121 non-null    float64\n",
      " 4   enable_log            121 non-null    bool   \n",
      " 5   trend_period          121 non-null    int64  \n",
      " 6   初始资金                  121 non-null    float64\n",
      " 7   最终资金                  121 non-null    float64\n",
      " 8   总收益率                  121 non-null    float64\n",
      " 9   年化收益率                 121 non-null    float64\n",
      " 10  最大回撤                  121 non-null    float64\n",
      " 11  夏普比率                  121 non-null    float64\n",
      " 12  卡玛比率                  121 non-null    float64\n",
      " 13  总交易次数                 121 non-null    int64  \n",
      " 14  交易成本                  121 non-null    float64\n",
      " 15  总实现盈亏                 121 non-null    float64\n",
      " 16  胜率                    121 non-null    float64\n",
      " 17  盈亏比                   121 non-null    float64\n",
      " 18  盈利交易次数                121 non-null    int64  \n",
      " 19  亏损交易次数                121 non-null    int64  \n",
      " 20  平均每次盈利                121 non-null    float64\n",
      " 21  平均每次亏损                121 non-null    float64\n",
      " 22  initial_capital       121 non-null    float64\n",
      " 23  final_capital         121 non-null    float64\n",
      " 24  total_return          121 non-null    float64\n",
      " 25  annualized_return     121 non-null    float64\n",
      " 26  max_drawdown          121 non-null    float64\n",
      " 27  sharpe_ratio          121 non-null    float64\n",
      " 28  calmar_ratio          121 non-null    float64\n",
      " 29  sortino_ratio         121 non-null    float64\n",
      " 30  total_trades          121 non-null    int64  \n",
      " 31  transaction_costs     121 non-null    float64\n",
      " 32  total_realized_pnl    121 non-null    float64\n",
      " 33  win_rate              121 non-null    float64\n",
      " 34  profit_loss_ratio     121 non-null    float64\n",
      " 35  winning_trades_count  121 non-null    int64  \n",
      " 36  losing_trades_count   121 non-null    int64  \n",
      " 37  avg_profit_per_trade  121 non-null    float64\n",
      " 38  avg_loss_per_trade    121 non-null    float64\n",
      "dtypes: bool(1), float64(29), int64(8), object(1)\n",
      "memory usage: 36.2+ KB\n",
      "None\n",
      "\n",
      "--- 最优参数组合 (按total_return) ---\n",
      "main_symbol                    FG\n",
      "trade_volume                    1\n",
      "fb_entry_threshold            0.3\n",
      "fisher_exit_level             1.3\n",
      "enable_log                  False\n",
      "trend_period                    6\n",
      "初始资金                     100000.0\n",
      "最终资金                     100590.0\n",
      "总收益率                       0.0059\n",
      "年化收益率                     0.00169\n",
      "最大回撤                     0.006922\n",
      "夏普比率                     0.113557\n",
      "卡玛比率                     0.244134\n",
      "总交易次数                         308\n",
      "交易成本                          0.0\n",
      "总实现盈亏                       589.0\n",
      "胜率                       0.300654\n",
      "盈亏比                      2.731912\n",
      "盈利交易次数                         46\n",
      "亏损交易次数                        107\n",
      "平均每次盈利                  86.195652\n",
      "平均每次亏损                 -31.551402\n",
      "initial_capital          100000.0\n",
      "final_capital            100590.0\n",
      "total_return               0.0059\n",
      "annualized_return         0.00169\n",
      "max_drawdown             0.006922\n",
      "sharpe_ratio             0.113557\n",
      "calmar_ratio             0.244134\n",
      "sortino_ratio            0.142519\n",
      "total_trades                  308\n",
      "transaction_costs             0.0\n",
      "total_realized_pnl          589.0\n",
      "win_rate                 0.300654\n",
      "profit_loss_ratio        2.731912\n",
      "winning_trades_count           46\n",
      "losing_trades_count           107\n",
      "avg_profit_per_trade    86.195652\n",
      "avg_loss_per_trade     -31.551402\n",
      "Name: 17, dtype: object\n",
      "\n",
      "--- 动态网格搜索完成 ---\n",
      "\n",
      "--- 最佳参数组合 ---\n",
      "  fb_entry_threshold: 0.1\n",
      "  fisher_exit_level: 1.7\n",
      "  total_return: 0.0175\n",
      "[0.1, 2.1, 0.1, 2.1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x800 with 2 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7YAAAMWCAYAAADF5hp2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAA6ZVJREFUeJzs3Qd8FNXax/F/EloCqfQuKFKVIkWwgSAICiKK2Bv46rWLvSGK5aoXO9arYL12VCxUQUQEAUFAkBZ67ylAAsm+n+fEhJQlBQOb2fy+fIbszszuzJ49MzvPnBbi8/l8AgAAAADAo0IDvQMAAAAAAPwTBLYAAAAAAE8jsAUAAAAAeBqBLQAAAADA0whsAQAAAACeRmALAAAAAPA0AlsAAAAAgKcR2AIAAAAAPI3AFgAAAADgaQS2HjR06FCFhIRo27Ztgd4VFLNjjjlGV199NelaArz//vtq0qSJypYtq5iYmKzv59xzzw30rnnKqlWr3PnqP//5j4J1f0aNGuXe0967pB3jBw4c0D333KO6desqNDRUffv2dfNtf+23pCg6d+6sFi1aKFjZ57OpOEyZMsWlsf0NtJK0L4d73ABAYRDYoki+//77Il8MecGGDRvc55o3b16pS5vi+OzB5q+//nLBx7HHHqu33npLb775pkq6QH+PXs3/Jdm6det08cUXq1q1aoqKilKHDh1cMFAU77zzjp599lldeOGFevfdd3XHHXccsf0NNoE+pnB02U0NC7R79+5d4m/QAfCvzCHmA4e8eB0xYkTQXcDaBcyjjz7qSlNatWpVqtKmOD57sLGSjfT0dL344os67rjj5AWB/h69mv9LKst/ffr00dKlS3X77berVq1a+u233/TJJ58UqcT3xx9/VO3atfX888/nmL93716VKcMlQHbjx48vUccUAuPbb7/VnDlzdNJJJ/EVAB7DrxoQhBfEqampqlChQkD3Y9++fSpXrpyr/ug1W7ZscX8zqyAHoz179igiIkIlXXJysipWrKjSZsmSJZo7d66eeeYZ3X333W7ejTfeqJSUlCLnZX/5ONDnh5J4/rLzFbz7XRbHuaJevXpKTEx0NzS++eabYts3AEeH9644kWXXrl3uzr1dtERHR+uaa65xF6u5ffDBB+7OY3h4uOLi4lzVtrVr1+ZY5+eff1b//v3dSb18+fKuPZZVWbO7+plsW1YiY6xKTuaUu5qOrdOwYUN30dy9e3e3LZ/Pp2HDhqlOnTpuP8477zzt2LEjxz58/fXXOuecc1zJhO2DVQO116Slpflt52V3VDt16uTer0GDBnr99dfzfPY1a9a4aqUFlc61a9fOPbY0zPxc2av8ffbZZ1lpWKVKFV1++eVav359odLGWLrYvlauXNm9h73X559/Xiy52bZz880368MPP1Tz5s1d2o0dO9Yts3289tprVb16dTffllvVxMJ+9kO1B8zdFi2zDdfHH3+shx56yJUQ2fefkJDgXl+pUiW3L9a+zx5XrVpVd911V57vNjdrz2p5yZ+OHTuqbdu2Wc8nTJigU0891R0Pto3GjRvrgQceKHJ62md+5JFH3GPbT39tEa1kx0pw7IKtWbNm+vLLL3U4CnNsZub3RYsWqUuXLi5dLX0t4Cns95j9mDn99NPde1jaXHXVVS4/79+/P8++2bFraVgYBeX/TFal245ry4u2v7NmzcrzPvbdrVixQr169VJkZKQuu+yyrIvkF154weVhS3fL09dff7127tyZ4z1mz56tHj16uM+VeW6wY8CfgvYns8TztNNOcxfMlrfs3LV48eIC08TOeY8//rg751l623f3559/qrAybwjZ+2Rn+1oYmefkyZMnu+1mfieZ7Sxz52u7mLeSYcv/tg2r/nzWWWfp999/z/Pe+eXFTBaA23FkNR4yf1OsrW/uwDy/81dhzJw5U2effbb7DbT9OeOMM/TLL79kLbfvyvLBlVdemeN106ZNU1hYmO69916/57XC/C4cjoL2134XbDs//fRTnte+8cYbbtnChQuz5tnvm1Uzt/OHHRd2TizugMwCxjvvvNN9h/b92HnBftNy5838vkvLg2eeeab7LuyYsGPDjml/fvjhh6xjzs4Bdl2Q+9jJ71zxT9j72LXPmDFj/Ob93OLj4921k6W/fZ8nn3yyvvvuuxzrZP4+fvrpp3riiSfc57fvqmvXrlq+fHmR8wiAfPjgOY888oj9mvhat27t69evn+/VV1/1DRo0yM275557cqz7+OOP+0JCQnwDBgxw6z366KO+KlWq+I455hjfzp07s9a75ZZbfL169fI9+eSTvjfeeMM3cOBAX1hYmO/CCy/MWmf69Om+s846y23n/fffz5rMypUr3fxWrVr5mjVr5nvuued8Dz30kK9cuXK+k08+2ffAAw/4OnXq5HvppZd8t956q9una665Jse+9u3b13fRRRf5nn32Wd9rr73m69+/v3vPu+66K8d6Z5xxhq9WrVq+atWq+W6++Wb3nqeeeqpb9+23386zbkHZfNOmTb7HHnvMrfd///d/WZ9rxYoVbvnIkSPdsnbt2vmef/5533333ecLDw/PkYb5pY2pU6eO78Ybb/S98sorLm3at2/v1v32229z7Ev9+vV9V111la8o7H2aNm3qq1q1qvt+R4wY4Zs7d677XLbdunXrus9nadqnTx+3vn2Ownz2Q+2PpatNmSZPnuzew757ywP2GZ966ilfcnKye32FChV8zZs391177bVuPy644AK3vuXJ/Lz33ntuvd9++y3H/FWrVrn5llfMwoULXV5r27at78UXX/S9/vrrLt+cfvrpvqIaPXq07/zzz3fvb/tq6fHHH39kpcfxxx/vi4mJcfnAPucJJ5zgCw0N9Y0fP75I2ynssZmZ3+17vO2229y6Z555ptu/77//vlDfo71HjRo1XB6xY92O8a+++so3YcIE95oxY8bk2LeNGze649/eszAKc26w89Vxxx3ne/rpp33PPPOM+6yWP1NTU7Pex/JK+fLlfccee6x7bN+j5QFj57gyZcr4rrvuOjf/3nvv9VWsWNEdl5nvsXnzZl9sbKz7jixvvPXWW74HH3zQHR+ZirI/lj62TXs/WyfzO7Jt2PtkyjxHZJ9n5z+bZ+dVO+4t79v3aK8v7DFu50w7z61evdpXVElJSe47aNKkiftcmd+J5RVj+2a/JZkuvfRSdwwNHjzY99///telS+/evX0ffPBBkfKiSUtL83Xv3t0XERHhu/32211+s3O1peV5551XqPNXYUyaNMntc8eOHX3Dhw9357UTTzzRzZs5c2bWepYXbDtff/11VtpYHrPz1b59+/ye1wo6pgqSeU60v0XZ3z179vgqVarkfi9y69KlizuPZrLzXnR0tPsc9n1ZPrNznp1Xvvzyy3z3pbDS09Pdd2zvacegbcPyhb2ffbeF+S7tfGLz7LgZOnSo+z4aNWrkPnvu48aOd9vW2Wef7Xv55Zfd57Jzop1zs6+X37nCfne2bt1a4LRjx44c+2/fvaXv7t273b7a58x93sj8zcnMI9WrV/dFRka684z9HrRs2dL9HvhLfzvnnHTSSe57t3Sw48OuBQ4nTwPwj8DWw4GtXShlZxfjlStXznHxbxenTzzxRI71FixY4C4wss+3H9PcLDCxH5jsF1U33XST30Ax86RvP167du3Kmn///fe7+Xay379/f9b8Sy65xJ2os19U+NuH66+/3p38c1982HvaST9TSkqKC6jsIjD7hWlhAlsza9Yst55doGZn72Xv2aJFC9/evXuz5ltAausPGTKkwLTx99nsfe097YKhOAJb+yH9888/c8y3mxM1a9b0bdu2Lcf8iy++2F0MZe7ToT774QS2DRs2zPNZ7fW2LHeQlPkjnx+7wLCLlzvvvDPHfAsysudN+/G3bdjFSnEeY7nfz9LD5n/xxRc59tHS2T5PYRXl2MzMw5kXbZn53QJVu0GQKb/vMfM97OIvOwtALOix4Do7u0Cz9I2Pjy/0Zyro3GDnpuwXkhZk5A6qM/OK3TTI7ueff3bzP/zwwxzzx44dm2O+3ZSw55YWh1KU/ck8p2zfvj1rnt3ksOPtyiuvPGRgu2XLFnd+O+ecc1xgkMlu8Nl6hTnG7aLZzpv2Po0bN3bveTgyL9Zzyx3Y2jnBvsOC3qswedECQEsj+96ys/xnr//ll18KPH8VxNLVgqMePXrkSGM7/zRo0MDdaMmez+3mpwUhdj60z2nHWe58kvu8lt8xVZDcwWRR9td+Hy3fHThwIGueBYeWTtnPo127dnU31rL/Ptp72w0R29ah9qUo7AaYvdZuxGVnN73tHLF8+fICv0sLgG1Z9sDM8rPluezHTWJiogtg7eZV7mPB1s0+/1Dniuzn74ImO58f6lixwNzWmTNnziED28zPlT2f22ew79OCcct32dPfgn47XjLZTVibb+f9ouYRAP5RFdnDbrjhhhzPrerO9u3bXfVPY9UjrarPRRdd5IYGypxq1KihRo0auSpqmax6UPZqR7aeVZ213ypr51VYViXHqs9ksl48jVXdzd5Ric23tjfZq/Nm3werFmf7YJ/Jqlfnrk5s72XVELO3jbLn1p7MqltmrwKUu7pUUVi1RntPa9uWvZ2QVY2yoWByVzk6lOyfzapO7t692322wlR1KgyrqmRVYjPZZ/7iiy9c7472OPv3b9U0bfvFte3srGpr9s9aUH61alz5sZ5ge/bs6apwZf8erQMdq/JlVedNZhtCq85+qOptxcWqyp9//vk59tGqOdpxsmnTpkK9R1GOTWNV7uwYyp7f27dvX2D6ZWfVAq1KZe7qrlZ9z6ou2jGXyaoS2vFv1XiLy4ABAxQbG5vj+zf+PsO//vWvHM+tKYCdV6xqbPb0smrcljaZ6ZWZD6zzF3/Vq4uyPxs3bnS94VqVR6tmmOnEE090+2GdZR3KxIkT3fntlltuyVEl26r6FnaIHus4yqpiLliwwH03VjXcmp9k+t///ufe26piFgdLO6sCaR0m5acwedG+r6ZNm7pzZPbvy6qimtz5O/f5qzDsu1m2bJkuvfRS97uXuQ37/bIqnlOnTs06F1g+tyrESUlJ7nzy6quv6v7778/RlOFIK8r+Wt60353sw/NYFWVbbsuMNeWxavJ2Dsn8vbTJ3tvO8bat7L+vh8vyuVXZvvXWW3PMt6rJdk62asMFfZf2Hna+tnySyZp55K46bM1JLI9fcsklOfKNbd+uGXLnG3/nCmPnY3uvgiY7zx3Kbbfd5s4P1tY2v7Sxz2RNYLIfH//3f//nmgJYlf3s7PybvR137nNOUfIIAP/oPMrDMi/qM2VepFngZBfbdoK0Hx67UPbHxufM3hZ1yJAh7gI3d5s1C4IOd58yg1xrm+NvfvZtWRsaa59pP9aZwfmh9sGCi9ydRBx//PHur/2g2I9ocVi9erX766+toV20WTutwrALbWtTZD9c2duY+WuHeDhyByBbt251FwjWhvBQQ9VkdpBUnA4VCNlNAbuQyZ1fc+c1f+xC7quvvtKvv/7qgi27kLebF9beMvs6//3vfzVo0CDdd9997iKgX79+ru1ZcXdeZW0Gc39v2fOeBacFKcqxaaxNVu5tWvrNnz+/0PttbSH9dY5jF4FPP/20Ro8e7R5bp0WWvv7arB+p81Xum1b2eXOnl50DrN1nfnnZLqovuOACdzFqvQBbe0lr120Xirnbpha0P/kd+xa0jRs37pCd1WS+Nvf3a8dA9mD6UCyIsR6QbbK8Zduyi2BrS2gX5LZNa2dp71dcNx+snazdmLJztd0wsG1Zfsjdxr0wedG+L2vbmvuYP9S553A+g23D2D4fiuWZzPS2ttTWptg64rL25g8//LCOpqLsb2b7SruBZ+cyY4+tXX/mucbaZto5xD7HoT6LpbMd9/+E5WX7vbW2p7mPgczlBX2Xtk7mTe7sch9bmWmUeQMkN7uuKehcYSzPHqpvhsKy9LcbUdZO3G5a+jtuD/W5sqdN9nGfCzrnFDVPA8iLwNbD7C6mP5klW3Znzy5A7I6qv3XtzqKxDnysBMLuAFtHGhaw2YWT3e210oqi3CE81D4VtK8WhNlFqf1wPfbYY+4ixIIhK1W0ffLyXUrrmMtKX6zTHispqFmzpgtcRo4cqY8++qhYtpG7lDQzvaxk5VA/klbyVJBDBd6WZ/x9p4cqrT3U918YVupsHWhYqa0FtvbXglWrHZB9u3Y32+7oWym6dVhiF4J2gWQdPf2T7R8JhT02C3v8FMahvhsrXbFAxjqyskDG/loAbCVBxamwn8EC0Nw3Iyy9LKg9VAlLZgBlaWpB4YwZM1znLxYQWsdRw4cPd/Oyp2txpOmRMn36dHfRnlmiaBfHdtPRSm2t8yor8bcxaa1kq7hu3Nj3bcGz3eCwY8bGvrUbHrYtK+UsSrrZ93XCCSfoueee87tu7hudh8qb+ck8x9l+HmoontzHUeZwPlYqbSVihbkJVVyKsr92DNgNGfsu7Ddj8+bNrvOgJ598Ms/7WSd8VkLrTyCGKjuc7zL3Z3r//ff9fje5h6fyd64wVjJvU0EsLx/q5ktmqa3dILMbZdlvpB7Ja7ai5mkAORHYBjELDu2EaXdQM+/y+mNV3WysRLtQyt5zpJUM5FZcJYy5WZUru9CwiygLADOtXLnS7/p2YZK7tMQ+g7FePYvqUJ+rfv367q+VYuW+i2zzMpfn9x5WJdiCdLvIzl5qZIHtkWI/1naH3QLQbt265btuft+p3RnOXv0xk92J/qd3xAvLvmPrHdmqN9qFsgWsdgFupQjZ2QWOlW7YZOvZReCDDz7ogt2C0qAoMktKsqdbUfNeYY/Novgnx6Yd94MHD3bVb+1mi1W1L2qpwJE6N2Sml1XvPeWUUwp14Ww1NmyyHkjt81iVR+ux20r0Cyv7sZ+bNY2wXpcPNbRI5mutBCb7cWI1KQpTS8HS0qoj2/eRmc8tz9tnsBLpli1bupKbzGGAiovddLNmFzZZaV+bNm1cGmYPbAv7ff3xxx/uWDxS+cK2YexmaGGOb6uBYL9p9nmeeuop13TFmi7kpzj3vaj7a7VQ7Dd50qRJrvTbzheZ1ZBNZr6ym6TFeX7zl5ft2LPqztlLbTObB2X/DczvPTJLI7PLfWxlppHdxPonn8l6bM6vCnH2/bJaNgWV2lpJv78bxPb6Q50fMpcfyTwCIC/a2AYxq4ppdwjtBJ+7FMKeWyCZ/S5i9nXs8YsvvpjnPTMv5PwFO/+Ev32wNmp2t9ofu+izoQ+yr2vPLaDLPqh6YYb7ye9zWYmJ/cjaRVH2KsRW0mYXGxYAFPQe9tnsAin70Db2Y2rVa48U26ZdAFtQnX1oiOwX2AXtd+YPrZV0Wfpmr1ade0iaI80u6OxmhlU3tgvm7Bd4JvfQUSbzjnf2783yguWJf8L2w0pSMlm1+ffee89tr7AlQIU9NovinxybVvJnedRKKKy9V/Y2lEdj+4UpTbTjx4b/8ncuyNymBY2509NfPihskGevteAi+2ey48lK/qyq7qHYRakFHC+//HKO/SlsqU/mRa01D8nOSmstOLfzhw1F468a5uGwtM3d3MPOexZUFzXdMr8vq/Hz1ltv5VlmQ8jZTcl/ys7zdn6yIMZf6Vz2c5zdILWbAHZOtGGu7DVWAm7H7dHK00XZ38w8YG277UaeTdaWM3s1X/t+rKq9/e7ZDZCC3u9wWT63/PHKK6/kmG8lmXbOKMxND3sP+x2xqvXZ9y93DQwrebagzm5K+msjX9jPVBxtbDNZYGvtz60mmb/PZZ/JmslksrxtzX/sJmdR240XNY8AyIsS2yBmJ0hr12mdZNiFkFVtsjuu9iNvF+bWwYFVY7Kqx7auPbaLEfthsYDIX8lCZtBoHUnYj5BdnNvYm/+UVTG1EiK7K2rvbT+YVh3pUNUC7YLLqsnZ57ISL/vht/ar9oOSvX2i/cDZeIAFVS+0z28/XhbAWhrZBY21nbELCduOdfpgVaUtALBqYRb02w+XjXdXUNpY8GsliNZuytr6WUmIjflp1cSK0kayqP7973+70kr7HNddd537kbUA0Kp32x34zGAwv89uF9FWtdP23S5WrX2rVVXNvLN8tGSOU2h5NDNoz84uOqwqsqW13SW3NLabInbhn71jD2v7ZN9j9k5Zisry28CBA92YpzaWqo0LbHmiKCXwhT02iyK/77EgdkPIvmMrFbf3yH7DprCO1LnB2HdmJWxW0mbHuVXJtePcSoFsn+14tPbUFoTa926de1l6WCmTBVd2TssvED0UqxJoF+42ZrJ95xaUWbBqJTm5xzbOLnOcZttfq21g27Z2enZDzEp6C2KvsSD27bffdjUELH9kjglqVaytVosd2xb4+rvgLipLJztWLA2tNNiqO9o5wvK4VeMuqiuuuMI1GbAO42w/raTdgiO7sWTzrfbKP+24yWpo2I0u+35szFQ7R1t7UvsNs23ad25pZed+q45uJf2vvfaae63lJfuNsxs5FkDmrv1RHMfU4e5vJsvfdgPMSuktWLJgJzf7HbHzm1X7tnO8leLaucgCrXXr1rmbgIdi50Abi9jakOaXl60piK1ntV/sXGX5w27sWGm3BX2F+S2w8Yvt99zOMZbmlo72W23n6uy/gZYG9h1Z/rHaAnb+sGPJbkZaExPLR7kDbH+Ko41tJjvWbZ/9lQBbfw7WiZt9p3besxsRdg6y87jlr6I2EyhqHgHgxyF6S0YJdqihSPyNpWhsaBIb6sDGfLTJxjW04Q6WLFmStc6iRYt83bp1c+Pn2TiL1q2+DWuRe6gDG37AxsG0YX2sq//MLOSvK/zs3dx/9tlnfvc1+3ALNgSEjXlrY8TaWIk2Ju+4cePyDFOQ2SX/7Nmz3VhvNkaqddtv4+vlVtjhfjKH+7DxAG0YiNyf+5NPPnHDudjQM3Fxcb7LLrvMt27duhyvP1TaGBtf17rxt9db+tt7Z36PxTHcz6GG6bBxPW2ZjTtZtmxZNyyHDRHx5ptvFvqz27BKtWvXdvt+yimnuHQ/1HA/ub9nY5/H8l1u/j5/fizNbX3Lp7nZ2H82PqblGxsexf7akBlLly7NsZ69Pvt+H85wPzaEi+VLG1sw8/v097kLozDH5qGGa7F0zT1cxaG+x0O9R3affvpp1pidh6Oo5wZ/Q84cKq9ksnxrQ0TZOcLGjrShTuw8sWHDBrf8999/d997vXr13HdjQ6ace+65Ls9mKsr+mIkTJ7p8b9uMiopyY1va+bKgc68N9WFDhthQUPbazp07u3FHC3uMW3raPtr3ZnnahjuxYUAyx0u2cWdtm+++++4/Hu7HhiC5++673fBClq72Hdjj3ONMFyUv2pBmNgaprW/fhY0Lat+dpYkNkZV9PwoaZig/Nk6qjeduwzfZdmw/bDx0OydkH1Il+xBdZs2aNe77tHGGs3++3OeH/M6N+TnUEDsF7W92meNM2/G0du1av9uxcXVt6Ck7t9s53s7Vluc///zzfPfFhrXyNwSYPzaEzR133OHOq7YN+y2zvJl9SJqCvsv58+e7tLXfa9vHYcOGud9Ff9cstp+W1y3P2/o2Vu3VV1+d4zgu6FxxOA6Vv21c8cyhiXKfNyz9begjG6bI9tXGpc09Pv2hfh8zz0W581RR8giAnELsP38BL1BSWfUr6wLfXxVbAIfHSmCsZNBKvjOHoQAQnKwU1UobrUZA7h7DAcCraGMLAHBVdq36Xvaq2wCCk1VttWGCCGoBBBPa2AIl1KZNm/Jdbm3GMscDRsnhte/N2vBZOzdrw2ZtVXP3BGudClnb0vwczWFTEPys/X/2DuuKOkzLkWTHQkFju1tbS39jRpck1n4aAIINVZHhOaWlKnJBQ01YR1ujRo06avuD4PzebH+tsyDrado6yck9VqSNZW0douSHFi0o7nO8dfp3uMO0HEl27FqnPgWVhtpnAACUosDWeoy0cUutp0QrxbCeca0H2saNGx/yNX/++afrCXLOnDluLE3rct565gOCjfVKmh/rybOowwngyAu2723RokVuiKP8MOYiipP9vuc33q9dL1gPuYFgQ+vYdUhBPYQXdRxoAIDHA1vr+t26c7fx+GwsQhtfzkrh7ELqUAPfW/UZGy7AfjhsqJV7772XwBYAAAAASrESVRXZBp+2QcetCpKN01cQG0fUSmspsQUAAACA0qtEdR6V2SGDdbxQnFJSUtyUKT093Q10bYOeZ4/rra1Z5vOIiAhXipxfBxZeZm3q9uzZ49Iivw46KlSo4NIpO+tF0drhWVqlpaW5TjISExMVTGygdKvulv2zWy2Cffv2uc98KLbO/v37/eYbS3N7veWr0pxGdpzZ8WXHZO60yG9ZaUsnY6+z/JSZFsF67B1OGh3q/FTQsmBPI/vcdl7PPAfZ6+yYSkpKyndZMCCNSCfyUsk85uy3y+ZFRka613iJ7XdJiQXsN9/O48iHr4SwwezPOecc3ymnnFLo19ig1c8//3yB69kg9PZRMycb2Hv69Ok55uWeLr74Yt8333yT7zpenmxg8JYtW+a7jg1WbgOF57fOgAEDfFOnTg345ymO6YorrnCf16Z77rnHt3v3bl9YWFjW8o0bN7qB4v29tlKlSr5ffvnF9+CDDx4yLdeuXesLDQ0ttWmUfbrvvvt8L730UpGXlbZ0suPrUOchrx97/zSN8js/Febc5bWpatWqhUqju+66y/faa69lPe/Zs6fv559/LnBZMEykEelEXirZx5xdB3nJ3r17fTWqHfxsgZ5q1Kjh9gmHVmJKbG+66SbXvnbatGnF/t7333+/Bg8enOPOkW1v9e/HKKpSxp2jkLDK8qVZifEBKaScIqpfofTUFdq5tKGCUVTtMvr56zpKS03Uv7f576yrYdQJqnZMpO6d3jNrXpmQsiobWl5705IUUSZKg5o9oQlr38+xjleNf7mJrn3m+7+fRav/up168JXRGjN1gbq2b6Ide3yKan+tWrfP+brw8mU14r6L9ev8lfo+PkKtL3kiz3vf/a/eGjtrtVoOGCYvqLjR/93JlWulW+746u9n4VoRv0OPPf65fhg3T51Pb6Zdu9NVs+7lqlk35+sqx1XSjp0ZNSTCw8vp0ssu17ffz9WpnR/Jd1lJkBJd9NPkXwnS/w399u9nkbpozU49/NyX+u7H+TqzYxPtTEpXXIurFdci5+vq1IjVxq27lZaWrjJlQjXw5vO0buNOtTtvmMqVDVP5cmWVmLxP0ZHheuyxy/T6Rz+5ZUfLnhphxfZev0u6/PUf/n4Wows37dS9b3+lr39doLPaNNb2FJ8qdBuo5t38v77B8fVUoXJNNb/+ySItKy4HwnXU/bVlp+5+7yuNnrVAPVo21rb9PpXpPVDZz+Bzo2N09yWX6YMNqdqWmKy7Bl6oyUtWqvHtT+a7LFiQRqQTeankHXNzKoTrjj59XM01L7GS2k1b0rR6zjGKigxsSXNCYrrqn7TK7ROltiW8je3NN9+sr7/+WlOnTlWDBg0K/brDbWNrH9mqIq/9vdrBjFq+u0Iq3SbJqk6UkVJ/lS/xacvWCiYhUcOk8p2l0CpS+i7Jl6yhi29Vn9o3a0nCb1qS+JvKhpTTLY1fc0Fs+dAIJaft1vydUzRx8/uqWCZa1zR4Qj75FKIQzdj+rWbvGKtg8P3wM3I8r18jVkMG9VB0pXAl703RY2+P14p129yyB685Sz/PXaGp8+J1Te/2+r/zOip+w/as106ctVQjx/zmHlcML6cfXrhelzz0ntZvzX/8w5Ki0vrC5fu6deJ0793nKCoqXHv2pOjpZ7/XylVb3bK7BvfU9F+Xafqvy9X3vDY679zWSkvzKSwsRFOmLtG772fcxMpvWUmQEvPP7//VqxWrh27qqahKFZS8N1VPvDpW8Wsy8tJ9N3TXtNkr3HRetxPVv2cbpaWnKywsVHMWrNGID35S6v40xUZHaMTQAUr3+RQaEqJPv/9dX034Q0dTcs3iC2xzq18tVsMu666YiuFK2peqIR+O0/KNGcfUI5d005QF8fppYbwqlC2jbx6+WmXLhCmyQnntSNqjb2ct1ktjfsl3WXE7EKGj7pgqsXqif3fFRIQrKSVVD302Tss2b9ejF3TTlEXxmrw43q13YbsWGti5nXs8K36dHhs9SQf+bnaS37JgQBqRTuSlknfMpaXs02lJ8XrjjTc8VRU5ISHBjTtvhVxRkWGB3ZfENMUeH++abVoMgxIY2Nqmb7nlFo0ePVpTpkxRo0aNivT6ww1sc2ZU7xxgR8qjW70z9MjRDGxLs8IGtqVBcQS2weJIBrZeE4jAFgC8yALbJS884LmgLDNe2L60QYkosa18/ErPpeHRFtArNqsO/NFHH7nSWmtQvmnTJjffMpE1RjdXXnmlateu7ca8NVYEb8MBZT5ev3695s2b56o3HHfccQH8NAAAAACAQAjo7YfXXnvN3Xno3LmzatasmTV98sknWeusWbPGDYieacOGDWrdurWbbP5//vMf93jQoEEB+hQAAAAAgFJbYluYWtBWRTl39eMS0CwYAAAAQJBL86UrzRf4fUDBaGAKAAAAAPA0AlsAAAAAgKfR3ScAAAAA+JEun5sCKdDb9wpKbAEAAAAAnkaJLQAAAAD4ke7+BVbg98AbKLEFAAAAAHgagS0AAAAAwNOoigwAAAAAfqT5fG4KpEBv3ysosQUAAAAAeBqBLQAAAADA06iKDAAAAAB+MI6td1BiCwAAAADwNAJbAAAAAICnURUZAAAAAA5RFTlNvoDvAwpGiS0AAAAAwNMosQUAAAAAP+g8yjsosQUAAAAAeBqBLQAAAADA06iKDAAAAAB+pPl8bgqkQG/fKyixBQAAAAB4GoEtAAAAAMDTqIoMAAAAAH6k/z0FUqC37xWU2AIAAAAAPI3AFgAAAADgaVRFBgAAAAA/0uRzUyAFevteQYktAAAAAMDTKLEFAAAAAD/SfBlTIAV6+15BiS0AAAAAwNMIbAEAAAAAnkZVZAAAAADwg3FsvYMSWwAAAACApxHYAgAAAAA8jarIAAAAAOBHukKUppCA7wMKRoktAAAAAMDTCGwBAAAAAJ5GVWQAAAAA8CPdlzEFUqC37xWU2AIAAAAAPI0SWwAAAADwI60EdB4V6O17BSW2AAAAAABPI7AFAAAAAHgaVZEBAAAAwA+qInsHJbYAAAAAAE8jsAUAAAAAeBpVkQEAAADAj3RfiJsCKdDb9wpKbAEAAAAAnkZgCwAAAADwNKoiAwAAAIAf9IrsHZTYAgAAAAA8jRJbAAAAAPAjTaFuCqS0gG7dOyixBQAAAIAgMnXqVPXu3Vu1atVSSEiIvvrqq3zXnzJlilsv97Rp0yZ5BYEtAAAAAASR5ORktWzZUiNGjCjS65YsWaKNGzdmTdWqVZNXUBUZAAAAAPzwlYBxbG0fiqpnz55uKioLZGNiYuRFlNgCAAAAANSqVSvVrFlTZ511ln755RdPpQgltgAAAABQwiUkJOR4Xr58eTcVh5o1a+r1119X27ZtlZKSov/+97/q3LmzZs6cqTZt2sgLCGwBAAAAoISPY1u3bt0c8x955BENHTq0WLbRuHFjN2Xq1KmTVqxYoeeff17vv/++vIDAFgAAAABKuLVr1yoqKirreXGV1h5K+/btNW3aNHkFgS0AAAAAlHAW1GYPbI+0efPmuSrKXkFgCyCP0NR0UgUAAJR6ab5QNwVSmq/or0lKStLy5cuznq9cudIFqnFxcapXr57uv/9+rV+/Xu+9955b/sILL6hBgwZq3ry59u3b59rY/vjjjxo/fry8gsAWAAAAAILI7Nmz1aVLl6zngwcPdn+vuuoqjRo1yo1Ru2bNmqzlqampuvPOO12wGxERoRNPPFETJ07M8R4lXUAD26lTp+rZZ5/VnDlzXOKOHj1affv2zfc1NsjwK6+8olWrVrm7DQ8++KCuvPLKIm23YsWKmjt3rqIa1lPI/tny7bpJCqutkCqTpANLs9bz7bpZSjv4hQeDkMiHpQpnKiSsjtK39ZEOLM6zTkzZaupb51bVDG+onamb9fryOw6+XiE6q8ZVOi6yjUIVprV7FuvbDa8rzXdAwaZu9RgNHXS2oiPDlbwnRY/+d5ziN2zPs17bpnV1c//TFF6+rOUaTftjpV757Gf5fNLJLerrlotOy1o3NjJC23cn64qhHyoY1K4dq3sf6K3o6HAlJafomae+1epV2/yu26BhVd18a3fFxlV0z9956ydN+3mJe9yzV0tdfFlHhYaEaO7cVXrxuXFKSwueUuM6NWL08M09/85LqXp8xA9auS5vXmpxfE3ddd1Z7nGZsFDN/2u9nn/nR+0/kKaQEOmmy8/Qya0aKCwsRPOXbNCzb03QgQPBkU71qsZo2OU9FFsxXIl7UzTkw/FasSlvGtWKi9Jjl3VXkzrVtH77bg145sNCLQsG9SrH6MmLeig2IlxJ+1L0wGfjtWJL3jTq17a5BnVup5CQEP22Yq2GffWjDqSnF7gsGJBGpBN5qWQec9dee627/vaidIUoPcAjpKar6EW2nTt3ls8uRg/Bgtvs7rnnHjd5WUC/peTkZLVs2dIFq4Xx2muvuWJz6/3rzz//1KOPPqqbbrpJY8aMKfJ2W7duLd+BbfLt/ebgAl+yfNv7ZE3BFtQa376x8m2/RL60dYdcJyV9j37c/KE+Xzs8z7I2sd1UM/xYvbF8sF5ZdpN88unkyr0VjO6/qptG/zRfF943Uu9+P0uPDOrhd72E5H168LXvNODBd13AeuJxtXTOKc3cshkLV+uyIR9kTX+t3qKxM/5SsLjjrp76bsxcXXX5G/rkoxm65/5z/a5XvnwZPfbEhRr59k+69so3Nejqt7Rg/lq3rEaNaF098HTdfsv7uuLS1xQbW1Hn9m6tYHLv9d319cT5uvi2d/TB17/poZv8D5i+bNVWDbzvA11993u64s5Rio2OUL8erdyy3meeoMYNq+vqe9/TJbePlC/dp4t6naRg8fCArvrilwXq8/gojZw02wWo/tiF04jvpuv+d38o0rJgMLRfV33+2wKdM3yU3v5ptp7snzeNasdG6ZbunXTl65+q57MjVblShPq3P6HAZcGCNCKdyEsl8JiLi9awYcO0Z8+eo7x3KG0CGtj27NlTjz/+uM4///xCrW9dTV9//fUaMGCAGjZsqIsvvlj/93//p6effvqwevkKCasspUxSqbJ/lpS+Kd9V9qYlac2exdqfnpJnWfXwBopP+iOrhHZZ4hydGNNZwSY2MlxNG1TXD9MzSrR/nL1M1StHqk61mDzrLl2zVeu37naPU/enuec1q0TnWa9KTEW1a1ZP3/+ySMEgJiZCxzeuqQkTFrrnU3/6S9WqRqlW7dg863bt1lyLF23QwgUZN1TS033avTvjB+70zk306y/LtHNHsns+5uu56tI148ZAMIiNilCThtU1bmrG9z55xlJVqxKp2jXy5qWU1ANZJdVly4SpfLkyWXdbjzummmbNX51VQvvr3JU6+/TgSKe4SuFqVq+6vpudcbxNnLdMNWIjVdfPcZSwJ0Vz4zdob+r+Ii3zuriK4Wpeu7rGzM1Io/ELl6lGTKTqVc6ZRt1PaKTJi+K1LSnj+Ppk5nz1atW4wGXBgDQinchLJfOY69Gyib755pt8Sw+B4hDYcvUissGCK1SokGNeeHi4fvvtN+3fX7QLmYEDByo1cbSkbFVoQ8IVUvkLhVT+Sqp4s9eS56jYsHeFGke1V/nQcFcVuXn0qYopV03BpnpcpLbvSlZa+sGT8KbtiapROTLf11WOjlDXdo00bV58nmXnntpc0+ev1M7EvQoGVatFacf2JKVn69Fgy5YEVauWt7e++sdU0f79B/TEU/31xn8H/l19OcItq1Y9Wps3Z9wYMJs37Va16kevx78jzYLYbbny0uZtCapRxX9eqlE1Su8+e6W+f+cmJe1J0Zfj57n5S1Zs1qltj1VEeDmFhYWqa6fGqlk1ONKpemyktu3OdbztTFTN2OD4fMXBLha3JuZMo427ElUzJmca1YyJ1IZdCVnPN+xMcPMKWhYMSCPSibxUMo+5WrFRWr16tbw+jm2gJxTMU5Fbjx49XA9d1ibX7vpYo2h7bkHttm3+2/VlBsQJCQlZU2JioivtTU347OBKaVvl23qqfNsvkG/HVQop11aqOPDofDAPmbdzkpYn/q5rGj7ppu0pG5TuSwv0bpUIFSuU03O39dV738/S4lWb8yzvc1oLfT01o3SztAkNC1Wbkxro+eE/6PpBb2vb1kTdPvjsQO9WibRpa4Kuuvs99b7uNZUrE6bO7Ru5+d9NWaiZ81bp1UcHuGnNxp1KC6K2kQAAAKWmV+SHH35YmzZt0sknn+wC2+rVq7uevZ555hmFhh46Rn/qqadce9xM9hqr0ty0ynKpfObrUqX0HRkPfbvl2/u5Qir0lk9vHemP5TlTtnzsJtMi+jRtTQmOtsi9OjXVZWdntFkcN2OJKsdUVFhoSNadSCuttVJbfyIqlNVLd/bTT3NX6KNxv+dZ3qZJHZUrG6YZC1bJy87q0UIX9u/gHk+e9KfiKldSaFhIVqmtldZaqW1uWzYnaN7c1dq2Lck9nzhhoZ5+9uK/l+1WrVoHqy9XrxHt1vcyqyJ8ce+27vHEaX+5aujZ81L1KlHatM1/Xsq0d99+TfzlL3U/rZkmTs/oZOvtz6a7yXTr1Fjxa/N20OEV57Zrqiu6tHGPx/6+RFWicx1vsZHauNPb+aA4bdqVqKqROdPISls3ZiuBzSwtqRsXk6OkxOYVtCwYkEakE3mpZB5zVjukfv36R3nvUBp5qsTWqh2/8847rvG59YpsXVQfc8wxioyMVNWqVQ/5Outwavfu3VnTG2+8obfffjvnSqFx2eL8cgqp0F06EBxtIYtTmZCyqhCa0atdRFikTq3aT9O2WpVu7/t++uKsTp6s1HXJ6i3q2ampW3Zm20bavCNR67bsyvM66w3ZgtpfF6zSO2Nm+n3v805voW+n/al0j7cvmTBuoStxtenj/83QsqWbdNZZLdyy089ooq1bE7Vh/c48r/tp8mI1blJTERHl3PMOJx+rFSu2uMc//7REHU9plNVbcu/zWmvyj94+9sZOXeQ6gLLJOotasnKLevzdHrbLycdry/ZErd+UNy9Zu1urZmzKlAnV6R0aacWare653RiJrFjePbbelS8/v4M+/Po3edW3sxa7XottGjlxthav3aJz2mYcb91aNdLmXUlau+1gFfXSbkfyXi3asEW9W2ekUfcWjbRpd5LWbM+ZRhMWLleXZg1VpVJGVf8BHU7UD38sKXBZMCCNSCfyUsk85sbPX6I+ffq43ti9PI5toCcULMRXQlpyW2YvzHA/uZ1xxhmqXbu2Pvroo0K/xj5yVFSU1v5eTVGRf2eU8t0VUuk2V5PeBbipv8qXaJ1SpSqYhEQNk8p3lkKrSOm7XE/QQxffqj61b9aShN+0JPE3lQ0pp1sav+aC2PKhEUpO2635O6do4ub3VbFMtK5p8ITrDdmG/pmx/VvN3jFWweD74WfkeF6/RqyGDOqh6ErhSt6bosfeHq8V6zKqvD94zVn6ee4KTZ0Xr2t6t9f/ndcxx1BAE2ct1cgxGUFHxfBy+uGF63XJQ+9ldTJV0kWt3Feo9erUjdO995+rqKhwJSen6tmnv9XK+IxA7M67e2n6L8v06/Rl7nm37i108SUd3fG3bVuinnv2excIm17nttIll3Z0j/+Yt1rPDx9bYob72VstIxj/J+rVinU9IUdVqqDkval64tWxil+TkZfuu6G7ps1e4abzup2o/j3buCrGFuDOWbBGIz74yXVKZj0kjxg6wN0csWGRPv3+d3014Q8dTck1w47Ye9evFqthl3VXTEUbMiJVQz4cp+UbM46pRy7ppikL4vXTwnhVKFtG3zx8tetcK7JCee1I2uOC5JfG/JLvsuJ2ICM2PKqOqRKrJ/p3V4wNq5GSqoc+G6dlm7fr0Qu6acqieE1enNG2/8J2LTSwczv3eFb8Oj02elLWkD75LQsGpBHpRF4qecdcWso+nZYU7wqW8qthWdJY88Xo6GiN/qORKkYeud+/wkhOTNP5LZe5AjqLYVACA9ukpCQtX77cPbbhd5577jk3CHBcXJwbo9ZKWm2Q4Pfee8+ts3TpUtdRVIcOHbRz5063/oQJE1ybWyu5LWpG3bm04cHAthR7dGtw9Kxa3IFtaVbYwLY0KI7ANlgcycDWawIR2AKAF1lgu+SFBzwXlBHYek9A29ha508WyGYaPHhwVhtYGzR448aNrrpxprS0NA0fPlxLlixR2bJl3WunT59epKAWAAAAAAojXSFuCqRAb98rAhrYdu7cOd8xrSy4za5p06aaO3fuUdgzAAAAAIBXeKpXZAAAAAA4WtIVqrQA97ebrhLRJVKJRwNTAAAAAICnEdgCAAAAADyNqsgAAAAA4EdJGEc2rWSMzlriUWILAAAAAPA0AlsAAAAAgKdRFRkAAAAADtErsk2BRK/IhUOJLQAAAADA0whsAQAAAACeRlVkAAAAAPAjzRfipkAK9Pa9ghJbAAAAAICnUWILAAAAAH6kKdRNgZQmxrEtDEpsAQAAAACeRmALAAAAAPA0qiIDAAAAgB/pvlA3BVK6j6rIhUGJLQAAAADA0whsAQAAAACeRlVkAAAAAPCDXpG9gxJbAAAAAICnEdgCAAAAADyNqsgAAAAA4Ee6VUf2hQR8H1AwSmwBAAAAAJ5GiS0AAAAA+JGuUDcFUqC37xWkEgAAAADA0whsAQAAAACeRlVkAAAAAPAjzRfqpkAK9Pa9glQCAAAAAHgagS0AAAAAwNOoigwAAAAAfqQrxE2BFOjtewUltgAAAAAATyOwBQAAAAB4GlWRAQAAAMAPekX2DkpsAQAAAACeRoktAAAAAPiRplA3BVKgt+8VpBIAAAAAwNMIbAEAAAAAnkZVZAAAAADwI90X4qZACvT2vYISWwAAAACApxHYAgAAAAA8jarIAAAAAOBHegnoFdn2AQUjlQAAAAAAnkZgCwAAAADwNKoiAwAAAIAf6b5QNwVSoLfvFaQSAAAAAMDTKLEFAAAAAD/SFOKmQAr09r2CElsAAAAAgKcR2AIAAAAAPI2qyAAAAADgB51HeQcltgAAAAAATyOwBQAAAAB4GlWRAQAAAMCPtBLQK7HtAwpGiS0AAAAAwNMIbAEAAAAAnkZVZAAAAADwg16RvYMSWwAAAACAp1FiCwAAAAB+pPlC3RRIgd6+V5BKAAAAAABPI7AFAAAAAHgaVZEBAAAAwA+fQpQe4HFsbR9QsFIZ2FasWFFz585VVMN6Ctk/W75dN0lhtRVSZZJ0YGnWer5dN0tpaxRMQiIfliqcqZCwOkrf1kc6sDjPOjFlq6lvnVtVM7yhdqZu1uvL7zj4eoXorBpX6bjINgpVmNbuWaxvN7yuNN8BBZu61WM0dNDZio4MV/KeFD3633GK37A9z3ptm9bVzf1PU3j5su7UM+2PlXrls5/l80knt6ivWy46LWvd2MgIbd+drCuGfqhgULt2rO59oLeio8OVlJyiZ576VqtXbfO7boOGVXXzrd0VG1fRPX/nrZ807ecl7nHPXi118WUdFRoSorlzV+nF58YpLS1dwaJOjRg9fHPPv/NSqh4f8YNWrsubl1ocX1N3XXeWe1wmLFTz/1qv59/5UfsPpCkkRLrp8jN0cqsGCgsL0fwlG/TsWxN04EBwpFO9qjEadnkPxVYMV+LeFA35cLxWbMqbRrXiovTYZd3VpE41rd++WwOe+bBQy4JBvcoxevKiHoqNCFfSvhQ98Nl4rdiSN436tW2uQZ3bKSQkRL+tWKthX/2oA+npBS4LBqQR6UReKpnH3LXXXuuuv4GgrYo8depU9e7dW7Vq1XI/sl999VW+61999dVuvdxT8+bNi7Td5ORktW7dWr4D2+Tb+83BBb5k+bb3yZqCLag1vn1j5dt+iXxp6w65Tkr6Hv24+UN9vnZ4nmVtYrupZvixemP5YL2y7Cb55NPJlXsrGN1/VTeN/mm+LrxvpN79fpYeGdTD73oJyfv04GvfacCD77qA9cTjaumcU5q5ZTMWrtZlQz7Imv5avUVjZ/ylYHHHXT313Zi5uuryN/TJRzN0z/3n+l2vfPkyeuyJCzXy7Z907ZVvatDVb2nB/LVuWY0a0bp64Om6/Zb3dcWlryk2tqLO7d1aweTe67vr64nzdfFt7+iDr3/TQzf19LveslVbNfC+D3T13e/pijtHKTY6Qv16tHLLep95gho3rK6r731Pl9w+Ur50ny7qdZKCxcMDuuqLXxaoz+OjNHLSbBeg+mMXTiO+m6773/2hSMuCwdB+XfX5bwt0zvBRevun2Xqyf940qh0bpVu6d9KVr3+qns+OVOVKEerf/oQClwUL0oh0Ii+VwGMuLlrDhg3Tnj17jvLeobQJaGBrAWbLli01YsSIQq3/4osvauPGjVnT2rVrFRcXp/79+xd52+3bt1dIWGUpZZJKlf2zpPRN+a6yNy1Ja/Ys1v70lDzLqoc3UHzSH1kltMsS5+jEmM4KNrGR4WraoLp+mJ5Rov3j7GWqXjlSdarF5Fl36ZqtWr91t3ucuj/NPa9ZJTrPelViKqpds3r6/pdFCgYxMRE6vnFNTZiw0D2f+tNfqlY1SrVqx+ZZt2u35lq8aIMWLsi4oZKe7tPu3Rk/cKd3bqJff1mmnTuS3fMxX89Vl64ZNwaCQWxUhJo0rK5xUzO+98kzlqpalUjVrpE3L6WkHsgqqS5bJkzly5WRz4r+JR13TDXNmr86q4T217krdfbpwZFOcZXC1axedX03O+N4mzhvmWrERqqun+MoYU+K5sZv0N7U/UVa5nVxFcPVvHZ1jZmbkUbjFy5TjZhI1aucM426n9BIkxfFa1tSxvH1ycz56tWqcYHLggFpRDqRl0rmMdejZRN98803Wb9nXu0VOdATChbQVOrZs6cef/xxnX/++YVaPzo6WjVq1MiaZs+erZ07d+qaa64p8rYHDhyo1MTRkrJVoQ0JV0jlLxRS+Sup4s2BTp4SacPeFWoc1V7lQ8NdVeTm0acqplw1BZvqcZHavitZaekHT8KbtieqRuXIfF9XOTpCXds10rR58XmWnXtqc02fv1I7E/cqGFStFqUd25OUnnYwjbZsSVC1alF51q1/TBXt339ATzzVX2/8d+Df1Zcj3LJq1aO1eXPGjQGzedNuVaue9z28yoLYbbny0uZtCapRxX9eqlE1Su8+e6W+f+cmJe1J0Zfj57n5S1Zs1qltj1VEeDmFhYWqa6fGqlk1ONKpemyktu3OdbztTFTN2OD4fMXBLha3JuZMo427ElUzJmca1YyJ1IZdCVnPN+xMcPMKWhYMSCPSibxUMo+5WrFRWr169VHeO5RGno7c3n77bXXr1k3169fPd72UlBQlJCRkTYmJibr44ouVmvDZwZXStsq39VT5tl8g346rFFKurVRx4JH/EB4zb+ckLU/8Xdc0fNJN21M2KN2XFujdKhEqViin527rq/e+n6XFqzbnWd7ntBb6empG6WZpExoWqjYnNdDzw3/Q9YPe1ratibp98NmB3q0SadPWBF1193vqfd1rKlcmTJ3bN3Lzv5uyUDPnrdKrjw5w05qNO5UWRG0jAQAASmXnURs2bNAPP/ygjz76qMB1n3rqKT366KNZz6+66ipdf/31alpluVQ+M7ZPldJ3ZDz07ZZv7+cKqdBbPr11pD6CZ03Z8rGbTIvo07Q1JTjaIvfq1FSXnZ3RZnHcjCWqHFNRYaEhWXcirbTWSm39iahQVi/d2U8/zV2hj8b9nmd5myZ1VK5smGYsWCUvO6tHC13Yv4N7PHnSn4qrXEmhYSFZpbZWWmultrlt2ZygeXNXa9u2JPd84oSFevrZi/9etlu1ah2svly9RrRb38usivDFvdu6xxOn/eWqoWfPS9WrRGnTNv95KdPeffs18Ze/1P20Zpo4PaOTrbc/m+4m061TY8WvzdtBh1ec266prujSxj0e+/sSVYnOdbzFRmrjTm/ng+K0aVeiqkbmTCMrbd2YrQQ2s7SkblxMjpISm1fQsmBAGpFO5KWSecxZ7ZCCCqFKsnRfiJsCvQ8I4hLbd999VzExMerbt2+B695///3avXt31vTGG2+40t4cQuOyxfnlFFKhu3QgONpCFqcyIWVVITSjV7uIsEidWrWfpm21Kt3e9/30xVmdPFmp65LVW9SzU1O37My2jbR5R6LWbdmV53XWG7IFtb8uWKV3xsz0+97nnd5C3077U+kebV+SacK4ha7E1aaP/zdDy5Zu0llntXDLTj+jibZuTdSG9TvzvO6nyYvVuElNRUSUc887nHysVqzY4h7//NMSdTylUVZvyb3Pa63JP3r72Bs7dZHrAMom6yxqycot6vF3e9guJx+vLdsTtX5T3rxk7W6tmrEpUyZUp3dopBVrtrrndmMksmJ599h6V778/A768Ovf5FXfzlrsei22aeTE2Vq8dovOaZtxvHVr1UibdyVp7baDVdRLux3Je7Vowxb1bp2RRt1bNNKm3Ulasz1nGk1YuFxdmjVUlUoZVf0HdDhRP/yxpMBlwYA0Ip3ISyXzmBs/f4n69OnjOnwFjqQQXwlpyW2ZffTo0YUKVG2Xjz/+eJ177rl6/vnni7wte31UVJTW/l5NUZF/x/bluyuk0m1WJzkjwE39Vb7EpzNKcoNISNQwqXxnKbSKlL7L9QQ9dPGt6lP7Zi1J+E1LEn9T2ZByuqXxay6ILR8aoeS03Zq/c4ombn5fFctE65oGT7jekG3onxnbv9XsHWMVDL4ffkaO5/VrxGrIoB6KrhSu5L0peuzt8VqxLmMomwevOUs/z12hqfPidU3v9vq/8zrmGApo4qylGjkmI+ioGF5OP7xwvS556L2sTqZKuqiV+wq1Xp26cbr3/nMVFRWu5ORUPfv0t1oZnxGI3Xl3L03/ZZl+nb7MPe/WvYUuvqSjO/62bUvUc89+7wJh0+vcVrrk0o7u8R/zVuv54WNLzHA/e6tlBOP/RL1asa4n5KhKFZS8N1VPvDpW8Wsy8tJ9N3TXtNkr3HRetxPVv2cbV8XYAtw5C9ZoxAc/uU7JrIfkEUMHuJsjNizSp9//rq8m/KGjKblm2BF77/rVYjXssu6KqWhDRqRqyIfjtHxjxjH1yCXdNGVBvH5aGK8KZcvom4evdp1rRVYorx1Je1yQ/NKYX/JdVtwOZMSGR9UxVWL1RP/uirFhNVJS9dBn47Rs83Y9ekE3TVkUr8mLM9r2X9iuhQZ2bucez4pfp8dGT8oa0ie/ZcGANCKdyEsl75hLS9mn05LiXcFSaKh3ytSs+aL173P7L31UvpIN6Rg4KUn79cIp37gCOothEESB7ZQpU9SlSxctWLBALVpklBYdTkbdubThwcC2FHt0a3D0rFrcgW1pVtjAtjQojsA2WBzJwNZrAhHYAoAXWWC75IUHPBeUEdh6T0Db2CYlJWn58uVZz1euXKl58+a5IXzq1avnqhCvX79e7733Xo7XWTXiDh06HFZQCwAAAAAILgENbG24Hit5zTR48OCszp1GjRrlxqpdsyZnx0R2t+eLL75wY9oCAAAAwJFC51HeEdDAtnPnzvkO1mzBbW5WhXjPnozB5QEAAAAAoIEpAAAAAMDTPDuOLQAAAAAcSekKdVMgBXr7XkEqAQAAAAA8jcAWAAAAAOBpVEUGAAAAAD/SfCFuCqRAb98rKLEFAAAAAHgaJbYAAAAA4Afj2HoHJbYAAAAAAE8jsAUAAAAAeBpVkQEAAADAD58vVOm+0IDvAwpGKgEAAAAAPI3AFgAAAADgaVRFBgAAAAA/0hTipkAK9Pa9ghJbAAAAAICnEdgCAAAAADyNqsgAAAAA4Ee6z6aQgO8DCkaJLQAAAADA0yixBQAAAAA/0kvAOLaB3r5XkEoAAAAAAE8jsAUAAAAAeBpVkQEAAADAj3SFuCmQAr19r6DEFgAAAADgaQS2AAAAAABPoyoyAAAAAPiR5gtxUyAFevteQYktAAAAAMDTCGwBAAAAAJ5GVWQAAAAA8CPdF+qmQAr09r2CVAIAAAAAeBoltgAAAABwqHFsA9x5E+PYFg4ltgAAAAAATyOwBQAAAIAgMnXqVPXu3Vu1atVSSEiIvvrqqwJfM2XKFLVp00bly5fXcccdp1GjRslLCGwBAAAAwA+fVUUO8GT7UFTJyclq2bKlRowYUaj1V65cqXPOOUddunTRvHnzdPvtt2vQoEEaN26cZ/IFbWwBAAAAIIj07NnTTYX1+uuvq0GDBho+fLh73rRpU02bNk3PP/+8evToIS+gxBYAAAAASrFff/1V3bp1yzHPAlqb7xWU2AIAAACAH9YjcsB7Rf57+wkJCTnmW1tYm4rDpk2bVL169Rzz7Lltc+/evQoPD1dJR4ktAAAAAJRwdevWVXR0dNb01FNPBXqXShRKbAEAAACghFu7dq2ioqKynhdXaa2pUaOGNm/erOzsuW3PC6W1hsAWAAAAAPxI94W6KZAyt29BZvbAtjh17NhR33//fY55EyZMcPO9gqrIAAAAABBEkpKS3LA9NmUO52OP16xZ457ff//9uvLKK7PWv+GGGxQfH6977rlHf/31l1599VV9+umnuuOOO+QVlNgCAAAAQAnvPKooZs+e7cakzTR48GD396qrrtKoUaO0cePGrCDX2FA/3333nQtkX3zxRdWpU0f//e9/PTPUjyGwBQAAAIAg0rlzZ/l8vkMut+DW32vmzp0rr6IqMgAAAADA0yixBQAAAAA/0hXipkAK9Pa9ghJbAAAAAICnleoS27P/PFdlKhbf+E9edUzU9kDvQolQ+fulgd6FkiMtPdB7UGJsubppoHehxAjdH+g9AAAA8K9UB7YAAAAAEGy9IpdGVEUGAAAAAHgagS0AAAAAwNOoigwAAAAAflAV2TsosQUAAAAAeBoltgAAAADgByW23kGJLQAAAADA0whsAQAAAACeRlVkAAAAAPCDqsjeQYktAAAAAMDTCGwBAAAAAJ5GVWQAAAAA8MNn1ZEVEvB9QMEosQUAAAAAeBqBLQAAAADA0wJaFXnq1Kl69tlnNWfOHG3cuFGjR49W3759D7n+lClT1KVLlzzz7bU1atQo9HbLly+vP//8U+Vqxyghba+eXvS51u/drpoVYvV4yysUGhKqsJBQrU7eomcWfaHEA3sVLG5r3EenVm2mmuFxuvrX57U8aaPf9c6oeqp61+qlEIVoUcJfGrXqA6X50nRcpWN1zTGXu3XCQsK0NHGZ3lv9Px3wHVCwqdWgmu565SpFxVXSnoS9Gn7ru1q9JG96hYSEaOAj/dS2SzOFlQnTot9W6OV7PtKB/Wluef9buqvbRR11YP8Bpe7br9ce/FRL565SMPjXUwN08tktVb1eFd14xmOKX7jukOv2uOwUXXTb2QoJDdUfP/+lV+7+SGkH0gpcFgzqVYnRE5f0UEzFcCXtTdFDH4/Xis3b/a57fvvmGnhmO4WGhGjm8rV64osfdSA9XW2PraPXrjtfq7bsyFr38pc+VkqQpFO9qjEadnkPxVYMV+LeFA35cLxWbMqbRrXiovTYZd3VpE41rd++WwOe+bBQy4JBvcoxevKiHoqNCFfSvhQ98Nl4rdiSN436tW2uQZ3buXPTbyvWathXGXmooGXBgDQinchLJfOYu/baa1WxYkV5Eb0ie0dAS2yTk5PVsmVLjRgxokivW7JkiQtmM6dq1aoV6fVlypRx27188tOas2OZrj/ubDd/W0qC/jXrVV0z4wVd+etz7vm1x56lYDJl8wLdOOs1bdx78OI4t6rlq+jCOudr2KJ/684/7ld02Sh1qXa6W7Zmz1oN+fNxPbjwUd2/4BFFlY1St+p5bzYEg1v/c6l+eG+aBnV8RJ++PF53vnSV3/UsKDvuhLq6uduTuu6UoUpP96nv/53pljVsUUfnXn2Gbjv737rpzCc05p0puumpixUsfv7md915zjPavGZbvutVr1dZVz5wnu4691ld2/ZBxVaNUq+rTitwWbAYcmFXfT5jgXr/e5TemTxbj1/c3e96teOidPPZnXTViE/V66mRqhwZoQs7npC13ILa/s99mDUFS1BrHh7QVV/8skB9Hh+lkZNmuwDVH7twGvHddN3/7g9FWhYMhvbrqs9/W6Bzho/S2z/N1pP986ZR7dgo3dK9k658/VP1fHakKleKUP/2JxS4LFiQRqQTeakEHnNx0Ro2bJj27NlzlPcOpU1AA9uePXvq8ccf1/nnn1+k11kgayW0mVNoaNE/RoUKFdzfiDIVtCVlt3u835em1PSMksdQhahCWDn5fMHVXPuPXSu19e/Peyjt407S7zvnaff+BPd80uYp6li5g3ucmp7qSm5NmZAwlQstK18QNmmPrhKpRq3qa9LnM93zad/+riq1Y1WzQdU86zZsXkdzp/6VVUI7+8eF6to/I70s/5QpG6YKEeXc84pREdq2caeCxcJfl2nbhl0Frndan5M044c/tHNLRp76btRP6tyvfYHLgkFcpXA1r1td385Z7J5PmL9MNWIiVbdydJ51zzqxkab8Ga/tiRk//p9Nn6+erRsr2FkaNatXXd/NzkijifOWqUZspOpWyZtGCXtSNDd+g/am7i/SMq+Lqxiu5rWra8zcjDQavzAjH9XLlY+6n9BIkxfFa1tSRh76ZOZ89WrVuMBlwYA0Ip3ISyXzmOvRsom++eYbz15TZ5bYBnpCkPaK3KpVK6WkpKhFixYaOnSoTjnllCK9/sCBA9q0aZP2haVpW2qCbp79etYyC9be6nCLalSI0fKkTbpv3iiVNpXLVda21IPVSLamblPlcnFZz6uUq6w7jr9F1StU1bxd8zVx82QFm6q1YrVz826lpx2sord13U5Vqx2njSu35lh32R+r1evK0zTm7SlK2ZfqArVqdSu7ZSv/XK/Rb0zSqFlPKHFXsvanHtDdfYartKlaJ05b1h3MU5vXbnfzCloWDOxHfmtCstLSD/6gb9yVqJqxUVq7PedNppqxkdqwMyPAN+t3JqhmTGTW87qVY/TJHZe6WgFfzfpTn0yfr2BQPTZS23bnTKNNO/9Oo23534grLVw+SvSTj2KitCZbPrL8smHXwTy0IVseym9ZMCCNSCfyUsk85mrFRunPX1cf5b1DaeSpwLZmzZp6/fXX1bZtWxfY/ve//1Xnzp01c+ZMtWnT5pCvs3VtMla6a1WRa9euraajrtbNrfrqrqb9NGzhx275AV+aq4psAe4dTc7TebU76KPVPx21z+gFFvQ+uHCoyoeW17+OvU7tYk/SjB2/qbSa8PGvql63sp75erBrQ2ultycdSM+qZnvKOa11bYeHtWPzbvW+trMeeGuQ7uz9n0DvNjxm8bot6jbsLSXtS1X16Ep6dVBf7Urep3F/LA30rgEAAAScpwLbxo0buylTp06dtGLFCj3//PN6//33D/m6p556So8++qh7/PLLL2vDhg3avXu3q0I7dsMcPddmUJ7XWID7/YbZuqfpBaUusN2eul3Vyh9st1y1XBVtT83bJjclPUUztv+mTlU6BEVg2/WiDup3Qzf3eMroWYqtHq3QsNCsUtuqdWK1Zb3/tskfPPutm8wZfdtq9ZIN7vGp57bRykXrXVBrxn88XTf9+2JXPTmz6rKXdB1wsvr9K6Pd+VdvTtKEj6YX6nVb1+1QzWMOVuO2GwE2r6BlXtX7pKa68oyMm20/zF2iqlEVFRYaknVX20rJNmYrmc20cWeiK5XNZG0i7e63SU5JzZq/eXeSvp+7RG0a1vJsYHtuu6a6oktGGo39fYmqROdMI6uK7C+NSqtNuxJVNdJPPspWAmssv9SNi8lRUpKZh/JbFgxII9KJvFQyjzmrHVK/fn15VUmoChzo7XuF54f7ad++vZYvX57vOvfff78LZG0aNGiQhgwZorJly7plnao2VXzSJve4eoUYlQ/NmG+9AXepfqJW/L2sNPltxxy1iW3lOo0yXat3dgGsqV6+musN2djftnGttXbPoXvC9ZJJn850HTzZ9NnL47Vi/lp1vbBDVoBqbUlzV0M2ZcuXUaXoCPc4Kq6iLrq1hz57Zbx7vmn1VjVvf6wqVCzvnnc46wStW77Jk0GtmfTJDN3UeZibChvUmmljftfJPVsqtlpGnjrn6jPczYOClnnVmDmLszp4ss6irLT13JOaZrWjtcA0dzVkM3H+cnVu3tB1GmX6dzpRY+cucY+rRFZUyN+/axHly+qMZg21eH3e/OgV385a7HottmnkxNlavHaLzmmbkUbdWjXS5l1JVEPOZkfyXi3asEW9W2ekUfcWjbRpd1KO6n5mwsLl6tKsoapUyshDAzqcqB/+WFLgsmBAGpFO5KWSecyNn79Effr0cb2xA0dSiK+EtOS2zF7QcD/+nHXWWYqMjNSXX35Z6Nekpqa6kt6ytaK140CS/rP4S23Yu0OnVGmq6/7uIdmG2liasF4vLR2jhP3B04vb3U37qWOVJoorF+k+1560FN234F4NanCV6zDq911/uPU6Vz1dvWv1dI8XJyzRyFXvu06julQ9Xd1rdFO6L90NifRnwmJ9vOYz7Q+C4X629c64qZGpzrHVdefLVykytqL2JO7Tc7e9q1WLM0pib3/ucs0YN99NMVUj9czowfKl+xQSGqKv3vpR37/7c9b7XPNgX3Xq1cq1r923J0Wv3v+Jls9foxItW9vi/Nw6/HK1636C4qpFKWFHsvYm7dO17R5yy25/4QrNGDtfM8Zm5KmzrzhVF92WkacW/LJEL935YdaQPvktC7T1V2f8YP8Tx1SNdT0hR1cMV/K+VD388Tgt+3som6EXdXMdRtlkLujQwg33Y2atWKdhn09yw7FcckpLXdSppdLS0xUWGqrxfyzVa+Nn6GgKPYJ9MtWvFqthl3XPGBJpX6qGfDhOyzdmpNEjl3TTlAXx+mlhvCqULaNvHr5aZcuEKbJCee1I2uOC5JfG/JLvsuJ2ICM2PKqOqRKrJ/p3V4wNq5GSqoc+G6dlm7fr0Qu6acqieE1enJGHLmzXQgM7/52H4tfpsdEZeaigZcGANCKdyEsl75hLS9mn05Li9cYbbxxWh6+BkpCQoOjoaJ0+5kaV+buAIlAOJKdoau9XXSFdVFRGQQBKWGCblJSUVdraunVrPffcc26c2ri4ONWrV8+VtK5fv17vvfeeW+eFF15QgwYN1Lx5c+3bt8+1sbWqxePHj1fXrl2LnFE7jL414Bm1JDgmyv94mqVN7sC2VCtkYFsaFEdgGyyOZGDrNYEIbAHAiyywXfLCA54LyjLjhVO/ualEBLbT+ozwXBqWqja2s2fPdoFspsGDB7u/V111lUaNGuXGqF2zZk2OktY777zTBbsRERE68cQTNXHixBzvAQAAAAAoXQIa2FqPxvkVGFtwm90999zjJgAAAAAAPNkrMgAAAAAcLT5fiJsCKdDb9wrvtOAGAAAAAMAPSmwBAAAAwI90hbgpkAK9fa+gxBYAAAAA4GkEtgAAAAAAT6MqMgAAAAD4ke4LcVMgBXr7XkGJLQAAAADA0whsAQAAAACeRlVkAAAAAPCDcWy9gxJbAAAAAICnEdgCAAAAADyNqsgAAAAA4Ae9InsHJbYAAAAAAE+jxBYAAAAA/KDzKO+gxBYAAAAA4GkEtgAAAAAAT6MqMgAAAAAcoiqydSAV6H1AwSixBQAAAAB4GoEtAAAAAMDTqIoMAAAAAH74XFXgwCZNgDfvGZTYAgAAAAA8jcAWAAAAAOBpVEUGAAAAAD/SFeL+BXofUDBKbAEAAAAAnkaJLQAAAAAcYgzZQI8jG+jtewUltgAAAAAATyOwBQAAAAB4GlWRAQAAAMCPdF+IQgJcFdj2AQWjxBYAAAAA4GkEtgAAAAAAT6MqMgAAAAD44fNlTIEU6O17BSW2AAAAAABPI7AFAAAAAHgaVZEBAAAAwA+fL8RNgRTo7XsFJbYAAAAAAE+jxBYAAAAA/KDE1jsosQUAAAAAeBqBLQAAAADA00p1VeTNC6ortEIFlXYb60YHehdKhJje4YHehRKj2uT1gd4FAACAgEv3hSgkwJ032T6gYJTYAgAAAAA8jcAWAAAAAOBppboqMgAAAAAcis+XMQVSoLfvFZTYAgAAAAA8jcAWAAAAAOBpVEUGAAAAgENWRQ5sr8RURS4cSmwBAAAAAJ5GiS0AAAAA+GGltYEvsWUc28KgxBYAAAAA4GkEtgAAAAAAT6MqMgAAAAD4YUPIBnoY2UBv3ysosQUAAAAAeBqBLQAAAADA06iKDAAAAAB+0Cuyd1BiCwAAAADwNAJbAAAAAICnURUZAAAAAPyhW2TPoMQWAAAAAOBplNgCAAAAgD++ENeBVEAFevseQYktAAAAAMDTSmWJbcWKFfXnn3+qTNWqmrJylZ756WdXfb52VJQmX3etlmzblrXuTV+P0ZpduxUsjomJ0bO9zlZseLgSU1J0zw/jtEzrcqzToVo9vXP6xYpP3JE178KJo5SSdkB2v+i+Vl11eo2GCgsN1Zxt6zRk9g/an56uYFO3WoweHXi2YiqFK2lvioa+M07xG7bnWa9dk7q6+YLTFFGhrHw+n6bNX6mXv/hZPstU2Qy9tod6n9JcZ9w8wr1fMKh1TBXd+ewlioqrqD2JezX87o+1ZtnmPOuFhIRo0AO91fb0xkpLS1fCzj168YFPtXH1drU5rbGuvfecrHVjKlfSzq2JuqXP8woW9arE6IlLeiimYkZeeujj8VqxOW9eMue3b66BZ7ZTaEiIZi5fqye++FEH0tPV9tg6eu2687Vqy8Hj8vKXPlbKgTQFg3pVYzTs8h6KrRiuxL0pGvLheK3YlDeNasVF6bHLuqtJnWpav323BjzzYaGWBYN6lWP05EU9FBsRrqR9KXrgs/FasSVvGvVr21yDOrdzx91vK9Zq2FcZeaigZcGANCKdyEsl85i79tpr3fU3ELQltlOnTlXv3r1Vq1Yt9yP71Vdf5bv+tGnTdMopp6hy5coKDw9XkyZN9PzzRb/43bNnj5o3b67eb72jNrVqqV/zZlnLklNT1fvdD7KmYApqzePdu+njP+ar29sj9cZvs/RMzx5+17Ogtve4/2ZNFtSaixq2UvPYGuoz/m11//4NF8hdfXx7BaMHr+ym0VPnq9+DI/XuD7NcYOpPwp59euCN79T/4Xd1+WMfquVxtXRup4N5ynRpc5wOpAXPxWOmWx6/UD98PEPXdf23Pntjsu589mK/653crbmanXSMbjxnuG7sNVzzpi/T1Xf1cst+/3mJbj73uaxp+Z/rNfnr3xVMhlzYVZ/PWKDe/x6ldybP1uMXd/e7Xu24KN18diddNeJT9XpqpCpHRujCjidkLbegtv9zH2ZNwRLUmocHdNUXvyxQn8dHaeSk2S5A9ccunEZ8N133v/tDkZYFg6H9uurz3xbonOGj9PZPs/Vk/7xpVDs2Srd076QrX/9UPZ8dqcqVItS//QkFLgsWpBHpRF4qgcdcXLSGDRvmrr+9yAoqSsKEEh7YJicnq2XLlhoxYkSh1rc7PTfffLMLiBcvXqyHHnrITW+++WaRtmvBmElNS9OiLVtVOzpapUHliHC1qFFdXy1a7J6PXbpMNaMiVb9SbKHfo0lMdf2yeWVWCe2UjSvU95gWCjaxkeFqekx1ff9rRlpNmrNM1eMiVadaTJ51l6zZqvXbMm6ApB5Ic89rVj6Yp+KiInTtOe313CdTFEyiK1fS8SfU1Y9fzXHPp/0wX1Vqxqhm/cp+j7my5cqoXPmy7nlEpQratinvTaO4alFq1amRJv39nsEgrlK4mtetrm/nZOSlCfOXqUZMpOpmyyOZzjqxkab8Ga/tiRk//p9Nn6+erRsr2FkaNatXXd/NzkijifOWqUZspOpWyZtGCXtSNDd+g/am7i/SMq+Lqxiu5rWra8zcjDQavzAjH9XLlY+6n9BIkxfFa1tSRh76ZOZ89WrVuMBlwYA0Ip3ISyXzmOvRsom++eabrOtvICgD2549e+rxxx/X+eefX6j1W7durUsuucSVth5zzDG6/PLL1aNHD/3888+Htf0qFSuqZ+NGmrwiPmteeNmyGn35pfr6yst0c8eTXXXAYFEzMlJbk5OVlu3EsiEhUbUiovKsW69SjL7uPlCjz7pGlx13Utb8hTs3qmut41WpTDmVCQnVOXWbqnbFvMGe11kQu213stLSD6bVpu2JqhkXme/rKkdFqGvbRvr5j4N56qGrztJLn/2sPfuC62K7as0Y7diaoPRsJdFbN+xStVp5b5TMnLRIC2au0EczH9GHMx9Rq07H6f3nx+ZZ76wL22nWlMXavT1JwcJ+5Lcm5MxLG3clqmZs3uOuZmykNuxMyHq+fmeCasYczHN1K8fokzsu1f9uu0QDOp2oYFE91s/xttN/GpVWLh8l+slHMTnTyPLLhl0H89CGbHkov2XBgDQinchLJfOYqxUbpdWrVx/lvUNp5Ok2tnPnztX06dNdcJyflJQUN2VKSEhQZGSk/ntxf7352ywt2JzRJtCCvlNef1Pb9+xVdIUKeqn3ORrU7iS9+dtslSZ/7tikU755WUn7U1QjPFJvnzFAO1P26Pu1i/XFyvmqXTFaH3W9wlVP/mXTSp0aRO2z/omKFcrp+Vv76r2xs7R4dUae6ntaCxcQz/prrUqzRifUUf3ja+jyjo9pT1KKrrnnHFeN+dnBH+VYr/uF7fX6Y6MDtp8l2eJ1W9Rt2FtK2peq6tGV9OqgvtqVvE/j/lga6F0DACBo+UpAr8iB3r5XeDKwrVOnjrZu3aoDBw5o6NChGjRoUL7rP/XUU3r00UeznleqVEnjxo3TxCXL9M7sg235rGqyBbVm9759+nzBQvVu2kRvKjgC242JiapasaLCQkKySm1rRUVqw56Dd/BN0oHUrMeb9iZqzOpFale1rgtszUsLf3aTObdeMy1L2KpgcE7Hprqse0bp9LjflqhKdEWFhYZk3YmsUTlSG3ck+n2tdRz18h399NO8Ffpw/ME81bZJXbU+vo5Oa9kga94nj16hwa987aose03X80/S+QPPcI9/GjNXcVWjFBoWmlVqW7VWjLZs2Jn3df3a6o9flys5cZ97PvHLWXri3etzrHNCh2NVrnwZzZm6RF7X+6SmuvKMNu7xD3OXqGpUzrxkpWQbs5XMZtq4M9GVymayNpF299skpxw8LjfvTtL3c5eoTcNang1sz23XVFd0yUijsb/7Od5i/adRabVpV6KqRvrJR9lKYI3ll7pxMTlKSjLzUH7LggFpRDqRl0rmMWe1Q+rXr3+U9w6lkSeH+7Gqx7Nnz9brr7+uF154Qf/73//yXf/+++/X7t27s6Zt27Zp7NixemXaL3naoJYJzUiScmFh6n58I9cGN1hY0P7n5i3q26ype3728Y20KTFRq5NyBiJVK1RyvR+bimXK6cxax+nPnRklkOVCwxRVtoJ7HFsuXNc37aQ3F89QMPju18W69NEP3GSdRf21eot6dcxIq64nNdKWnYlat2VXnteFly+rl2/vp18XrtLb387Mseyht37QOXe/pd73vu0mM+CR9z0Z1JpJo+dkdfJknUUt/3OdzuybcTPg1J4nunaz1tNxbpvWblfLjsepTNkw97zDmc20eummHOv0uKi9JnwxS+nZqjR51Zg5i7M6eLLOoqy09dyTmma1o7XAdO32vG2MJ85frs7NG7pOo0z/Tidq7NyMQL9KZEVltoyIKF9WZzRrqMXrvZmPzLezFrtei20aOXG2Fq/donPaZqRRt1aNtHlXktb+3XYd0o7kvVq0YYt6t85Io+4tGmnT7iStyZWPJixcri7NGqpKpYw8NKDDifrhjyUFLgsGpBHpRF4qmcfc+PlL1KdPH9dRLHAkhfhKSEtuy+yjR49W3759i/Q6q4b8/vvva8mSwv8420f+448/VK5GTSk0RD8sWapXZ/ym7o2O0x2ndHKlmXb3acaatXpqylRXkhssGsTG6plePRRbIVxJqTbcz3gtDV+rJ9udo0nrl2rShmW6olFbXXpcG6Wlp7shfX5YuzirhLZy+Yr66MzLlS6fQhWiUUtn6X8rgqMH25gJ4Tme168eq6EDeyi6YriS96Xo0XfGa/n6jKGgHr7qLFc6O/WPeNcx1PV9OmpFtqGAJs5eqne++y3PNua8PdgTw/1Um7y+UOvVblDV9YQcGVtRe5L26fl7PtaqJRkB621PXaQZE//UzEl/qmy5MP1raD81b9tAaQfS3HA+Lz/0uTatzRi6JiKygj78dYj+1fM/WfNKinXn1/nH73FM1VjXE3JGXkrVwx+P07K/h7IZelE312GUTeaCDi3ccD9m1op1Gvb5JDccyyWntNRFnVpmHZfj/1iq18Yf3ZtKoUewmXj9arEadln3jCGR9qVqyIfjtHxjRho9ckk3TVkQr58WxqtC2TL65uGrVbZMmCIrlNeOpD0uSH5pzC/5LituBzJiw6PqmCqxeqJ/d8XYsBopqXros3Fatnm7Hr2gm6YsitfkxRl56MJ2LTSw8995KH6dHhudkYcKWhYMSCPSibxU8o65tJR9Oi0pXm+88YZC/y5A8gJruhgdHa1j3n5YoREZhTqBkr5nn1YNHOYK6KKi6H8iaAPbxx57TO+8845WrVpV9Iz62BMKrRDYjFoi1M2ofl3a5Q5sS7PCBralQXEEtsHiSAa2XhOIwBYAvMgC2yUvPOC5oIzA1nsC2sY2KSlJy5cvz3q+cuVKzZs3T3FxcapXr56rQrx+/Xq99957brkNC2TzbfxaY8P+/Oc//9Gtt94asM8AAAAAIDiVhHFkA719rwhoYGvtZLt06ZL1fPDgwe7vVVddpVGjRmnjxo1as2ZN1vL09HQX7FoAXKZMGR177LF6+umndf31OTuhAQAAAACUHgENbDt37pzvYM0W3GZ3yy23uAkAAAAAAE8P9wMAAAAAR5yVwQW6KnCgt+8R3umaDAAAAAAAPwhsAQAAAACeRlVkAAAAAPDD5wtxUyAFevteQYktAAAAAMDTCGwBAAAAAJ5GVWQAAAAAOBR6JfYESmwBAAAAAJ5GiS0AAAAA+EHnUd5BiS0AAAAAoHSU2A4ePLjQb/rcc88d7v4AAAAAAHBkAtu5c+cWar2QEMZZAgAAABAkHUcFuvOow9z+iBEj9Oyzz2rTpk1q2bKlXn75ZbVv397vuqNGjdI111yTY1758uW1b98+BV1gO3ny5CO7JwAAAACAf+yTTz5xNW5ff/11dejQQS+88IJ69OihJUuWqFq1an5fExUV5ZZ7tcDyH7WxXb58ucaNG6e9e/e65z5foG9nAAAAAEDp9txzz+m6665zpbDNmjVzAW5ERITeeeedQ77GAtkaNWpkTdWrV1fQB7bbt29X165ddfzxx6tXr17auHGjmz9w4EDdeeedxb2PAAAAABAAISVkKrzU1FTNmTNH3bp1y5oXGhrqnv/666+HfF1SUpLq16+vunXr6rzzztOff/6poA9s77jjDpUtW1Zr1qxxkX+mAQMGaOzYscW5fwAAAABQ6iUkJOSYUlJS/KbJtm3blJaWlqfE1Z5be1t/Gjdu7Epzv/76a33wwQdKT09Xp06dtG7duuAObMePH6+nn35aderUyTG/UaNGWr16dXHtGwAAAABAciWp0dHRWdNTTz1VbOnSsWNHXXnllWrVqpXOOOMMffnll6patareeOON4Os8Krvk5OQcJbWZduzY4XrPAgAAAADPK0G9Iq9du9Z18JTpUHFXlSpVFBYWps2bN+eYb8+t7WxhWO3c1q1buz6VgrrE9rTTTtN7772Xo6GxFVc/88wz6tKlS3HuHwAAAACUehbUZp8OFdiWK1dOJ510kiZNmpQ1z2I1e24ls4VhVZkXLFigmjVrBneJrQWw1nnU7NmzXePke+65xzUuthLbX375pfj3EgAAAABKcYltUQwePFhXXXWV2rZt68auteF+rNZt5li1Vu24du3aWdWZH3vsMZ188sk67rjjtGvXLjf+rTUxHTRokII6sG3RooWWLl2qV155RZGRka4HrX79+ummm27yVFQPAAAAAMFmwIAB2rp1q4YMGeI6jLK2s9bJb2aHUtYJsPWUnGnnzp1ueCBbNzY21pX4Tp8+3Q0V5BUhvlI4+Kz1ImYNro957AmFVqgQ6N0JvLoZ4xCXdjETwgO9CyVGtcnrA70LJca683N2kleahe4P9B6UHAfydjMBAPAjLWWflrzwgHbv3p2jfahX4oW6rw5VaHhg44X0vfu09sahnktDT7SxtSLqoUOHatmyZcW/RwAAAABQEvhCSsaEIxPYWpXj7777zo131K5dO7344ouHHBMJAAAAAIASF9jecccdmjVrlv766y/16tVLI0aMcOMqde/ePUdvyQAAAAAAlMjOozIdf/zxevTRR900Y8YM/etf/3I9bVkvWwAAAADgZdYbUaB7JAr09o8U6335t99+05YtW9xwRNkdTjz5jwJbYzvz0Ucf6ZNPPnGNrPv37/9P3xIAAAAAEKTGjBmjyy67zI2uYx1ihYQcbEdsjw8nsD2sqsg21M8jjzziSmxPOeUULV68WE8//bQ2b96sjz/++HDeEgAAAABQCtx555269tprXWBrJbc23FDmtGPHjsN6z8MqsW3SpInrNMo6kbr44ouzxkMCAAAAgKBh1YADXRU40Ns/AtavX69bb71VERHFN37eYQW2S5YsUaNGjYptJwAAAAAApUOPHj00e/ZsNWzYMLCBrQW1VmT8+eefa8WKFbr77rsVFxen33//3ZXe1q5du9h2EAAAAAACoiSMIxvo7R8B55xzjoshFy1apBNOOEFly5bNsbxPnz5HJ7CdP3++unbtqpiYGK1atUrXXXedC2y//PJLrVmzhiF/AAAAAAB+WfxoHnvssTzLrPOotLQ0HZXA1saxtWF9nnnmGUVGRmbNtzFtL730UnlF1d/TVaZszq6lS6M9q8IDvQslQpU5OwO9CyWGr+w/7jA9aERs5hyRaU+1w+pvEAAAIIfcw/sUh8O6SrH60Ndff32e+VYFedOmTcWxXwAAAAAQUCG+kjEFk/3796tMmTJauHBh4APb8uXLuzFr/Q0DVLVq1eLYLwAAAABAkClbtqzq1at3WNWNiz2wtca8Vh/aou3MetDWtvbee+/VBRdcUKw7CAAAAAAIHg8++KAeeOCBwx6z1p/Dakg3fPhwXXjhhapWrZr27t2rM844w1VB7tixo5544oli2zkAAAAACBjGsT0iXnnlFS1fvly1atVS/fr1VbFixRzLbbSdoxLYRkdHa8KECZo2bZrrITkpKUlt2rRRt27dDuftAAAAAAClRN++fYv9Pf9R16ennnqqmwAAAAAAKIxHHnlEAQtsX3rppUK/6a233nq4+wMAAAAAJYMvJGMK9D6g+ALb559/vlDrWUdSBLYAAAAAAH9CQ0Nd3Hgoh9NjcqED25UrVxb5zQEAAADAs+g86ogYPXp0juc22s7cuXP17rvv6tFHHz36bWwLEhUVpXnz5qlhw4ZHcjMAAAAAAI8477zz8syzUXeaN2+uTz75RAMHDjw649gWls9ntzgAAAAAAMjfySefrEmTJqnEldgCAAAAgGdRFfmo2bt3r+uwuHbt2of1egJbAAAAAMBRExsbm6PzKKvpm5iYqIiICH3wwQeH9Z4EtgAAAACAo8ZG3Mke2FovyVWrVlWHDh1c0FviAtv8unAGAAAAgBKNqshHxJlnnqm6dev6jRfXrFmjevXqFfk96TwKAAAAAHDUNGjQQFu3bs0zf/v27W7Z4TiswPaxxx7Tnj17/Db4tWWZfvjhh8Nu/AsAAAAACD6+Q4yek5SUpAoVKhy9qsg2aO4NN9zgGvdmZ8GuLRsyZIh7fuqppx7WTgEAAABAwPlCMqZA70OQGDx4sPtrVZAtZsweT6alpWnmzJlq1arV0QtsLcL2Vx/6jz/+UFxc3GHtCAAAAAAgeM2dOzcrnlywYIHKlSuXtcwet2zZUnfdddeRD2wzu2W26fjjj88R3FqEbUXHVpILAAAAAF4X4suYAr0PwWLy5Mnu7zXXXKMXX3xRUVFRxfbeRQpsX3jhBRddX3vtta7KcXR0dI4I+5hjjlHHjh2LbecAAAAAAMFl5MiR7u/y5cu1YsUKnX766QoPDz9kzeBiD2yvuuoq99d6qurUqZPKli17WBsFAAAAAJROO3bsUP/+/V0JrgWyy5YtU8OGDTVw4EBXS3j48OFHrlfkhISErMetW7d2PSDbPH8TAAAAAATNOLaBnoLM7bff7gpJbcza7B1IDRgwQGPHjj2yJbYWOW/cuFHVqlVTTEyM3yLizKJja28LAAAAAEBu48eP17hx41SnTp0c8xs1aqTVq1friAa2P/74Y1aPx/b4cOs+AwAAAABKr+Tk5DxDx2ZWUS5fvvyRDWzPOOOMrMedO3eW15188sl697lBUkioyoSFav5f6/X8yB+1/0CaLGa/5YrO6tCqgdLS0rU7ca/+/cZ4rd+8S8GgTo0YPXxTT0VHhit5T6oe+nicVmzcnme9WnFReuyKHmpct5o2bN+tAU99kLWsbaM6euXGflq9ZUfWvCv/87FS9h9QsKhVL053D7tAUTERSk7ap+FDRmv1ii151ut+Xmv1vfRgp2lVqkVpwe+rNezO/6l6rRiNHHOHVi3fnLXc5m9ct/OofY4jqVb9yrrr3wMUFRuhPZZG932m1dk+aya7EXbdvefopNOOV3pauhJ27dELD32hjWu2q3qdWD304uUKDQtVWFio1sZv0YsPf6mkhL0KFnWrx2jI9T0VE1lBSXtT9dgbY7Vyfd5jrsVxNXXvNd3cYzsv/bF0vYa/N9mdl2pWidLD15+txvWracPW3briwfcVTOpVidETl/RQTMVwJe1L0UP/G68Vm/OmkTm/Q3MNPLOdQkNCNHP5Wj3x+Y86kJ7uljWqWVn3n99FlSMzfixf+n66Ji1YrmBQr3KMnryoh2IjMtLogc/Ga8WWvGnUr21zDerczh13v61Yq2FfHUyf/JYFA9KIdCIvlcxjzjqerVix4lHeO5Rkp512mt577z0NGzbMPbffpfT0dD3zzDPq0qXLYb1nodvYZjd06FC34dx2796tSy65pNDvM3XqVPXu3Vu1atVyH+arr77Kd32rCn3ppZe6oYZCQ0Nd3ezDZWPuXnX3O7r6nvd0xV2jFBsdoX49MgYDPq3tcTqhcW1defe7bpqzcI1uuPQ0BYt7/6+7vp44Xxff/o4++Po3F7z6k7QvVa98+4seGPm93+UW1FqwmzkFU1BrbnvoPH3/xWwNPO9FfTpymu587Hy/643/eq5uHPBq1rRze5Imf/9H1vK9e1JyLA+WoNbc+lg//fDpTA06+z/69K2fdOe/+/td7+Qzm6pZm/q68bwX9K8+L2jer8t1zeCz3bIdmxN056Wv6aa+L+qG3s9r+5YEXX5LRnAXLO679ix9NXm++t89Uu+P+U1Drs/47LktW7NVVw/50AWtl97/rmKjInRBt5ZuWfLeVL3x2S8a8up3CkZD+nfV5zMWqPe/R+mdH2fr8Uu6+12vdlyUbj67k6565VP1enKkKleK0IUdT3DLKpQto5euPU8v/zBd5z39ns5/5n39Hr9ewWJov676/LcFOmf4KL3902w92T9vGtWOjdIt3Tvpytc/Vc9nM9Knf/sTClwWLEgj0om8VAKPubhoF7zs2bPnKO8dSjILYN9880317NlTqampuueee9SiRQsXHz799NNHL7B9++23deqppyo+Pj5r3pQpU3TCCSe47pqLUgRtg/COGDGiUOunpKSoatWqeuihh9zr/gnr/MpKY03ZMmEqX66MayNs7G/ZsmEqXzbMPY8IL6et2xMVDOxCuUnD6hr38yL3fPLMpaoeG6m6VWPyrJuwZ5/mrdigvan7VdpEx1ZUo2a1NOm7jAB12sQ/VbV6tGrVzaiOfyiNW9RRTFxF/frTXwp20XEV1ahFHU36JmOg7WnjFqhKjRjVrFc5z7p2ZJUtV0blymdUEomoVF7bNu12j/fvT1NqSsZNkdDQEFUIL6e/D8WgEBsVrqYNq2vsLxnH3I+zlql6XKTqVM97zKWkHshzXsrsMCIheZ8rwd2bEnzHY1ylcDWvW13fzlnsnk+Yv0w1YiJVt8rBIeUyndWykab8Ga/tiRkXSJ/9Ol89Wzd2j3u1aaL5qzdq7soN7nm6z6edycFR8h9XMVzNa1fXmLkZaTR+YUYa1aucM426n9BIkxfFa1tSRvp8MnO+erVqXOCyYEAakU7kpZJ5zPVo2UTffPNN1nU2YCyIXbp0qYspzzvvPBcX9uvXT3PnztWxxx6rIz7cT6b58+fr+uuvV6tWrVxXzLZTNsDu3Xff7ca3LSyL0G0qLBsn17Zj3nnnHf1TNatG6z8PDFDtGjGa/nu8vhw3z82fNmeF2jSvpzFv3qg9+1K1dUeibnrkEwWDapUjtW1XstLSD55cNu1IVI3YSK3dWrSq1nWqxOh/917mLh6//vVPffrzwVJKr6taI1o7tiW5arOZtm7a7eZvWHuw+nVuZ5/fRpO+/UNpBw6+rkKFcnrpw+tdLYNfJy/W//77k9Kzpb9XVa0Zo51bE3Om0cZdqlYrxlUxzm7mj4vVssOx+t+0h7UnOUXbN+/W3Ve8kbW8TNkwvfjZze61K5ds0tB/vatgYUFsnmNue4KqV47UOj/NG6zK8bN3nKfa1WP0y7yV+nxixnkpmNmF0NaEnGm0cVeiasZEae22jBsgmWrGRGrDzoO976/fkaCasZHu8bHV45R6IE2vDDxP1WMqaemGbfrPN1ODIrh1aZToP43WbN+dM312HUwfSyubV9CyYEAakU7kpZJ5zNWKjdKfvx5eZ0AlgfUqFBLgy7Zg69lo//79Ovvss/X666/rwQcfLLb3PawSW+sh+dNPP9XNN9/sAlwLNn/44Qc98cQTKlPmsGLlI8qKt/0NSbRx625ddc976n3daypXNkydOzRy85s0rKGGdavovBteV5/rX9PsBWt0z/+dFeBPUbIsXrtFPR58U5c8/aHuePMbXXjaiere5niVZuUrlNUZPU7Q2K/mZM3bsTVRl3Z/Vrde9obuv36UWrSprwuuPEWlTaMWtXVMo+q67PQndNlpT2jejOW69dGDVbsP7E9zVZEvOeVxrYvfql4Xd1BptXFbgi5/8H31uul1lSsTpi7tMs5LKJi10T65UT099vlE9R/+obYkJOmhC7uSdAAAlCA2zI8VlBa3wwpszcsvv+wCWmtTa4Pp3nrrra7daklkdwOio6Ozprp16+ZYblX7Jv7yl7qf1sw973lGc835c42S9qS4KpE//PSn2jTP+RovOfv0Zhr1zJVuandifVWJqaiw0IP3fmrERWrTzqJVtU7el+ra4Jotu5I0dvZfan1sbXlZt3Nb6dVPbnRTmw7HKq5KJdehUSYrrbVS20M5vXsL17nUmvitWfOsmu3uncnucWLCXo376ne1aF1fXtX1vDYa8dVtbmrd6TjFVo3MmUY1Y7RlQ95SyG59T9K8GSuUnLjPVUWaOPp3ndghbzUTC3DHfzlbXfu0lpf1PLWZ3n/iCje1a+HnmKscpc0FNG+w89KEGX+pR6emCka92zbVZ3de5qaTj6+nqlE508hKEjdmK13MXhpgd/+zt7nd+Pf5y/7+tnyttuzOOOa+nf2XWtavoWCwaVeiqkYWnEYufWIOpo+llc0raFkwII1IJ/JSyTzmrHZI/frevfaRL6RkTEHm8ssvd81bAx7YWtGxVTl+99139eGHH7q60KeffrrradgaApc0VqpsHVtlTmvXrnV1t+3ufmbvo6e3b6QVqzMCkg2bd+mk5vXcfHPKSccqfs02edXYqYtcJ1k2WWdRS1ZuUY+/g/guHY7X5p2JRa6GXCWqous92kSUL6vTWzTUX+vy9hjsJRO/nZfVwdOno37W8r82qus5GW25T+3WXNs2J+RfDblvGxe45m6rG1YmIx9Zu+1TujbTir82yqsmff27K1m16bO3ftKKP9dnBaGn9jhB2zbvzlMN2Wxau0OtTj7WVTk27bs00eqlGb0nW/VjK+021oncaWefoJVLN8nLfpi2yHUAZdP7387SX6u26OxTMo65M9s10pYdiX6rIVu72+znpTPaNtLytQdvlASTMbMXu1JVm6yzqMXrtujckzKC+LNObKTNu5PyVEM2E/9Yrs7NG2b1ety/44kaO2+Jezxu3lK1qFddFcuXc89Pa3aMlmwIjvTbkbxXizZsUe/WGWnUvUUjbdqdlKO6n5mwcLm6NGuoKpUy0mdAhxP1wx9LClwWDEgj0om8VDKPufHzl6hPnz4MFYocDhw4oNdee01t27Z1sdrgwYNzTIcjxHcYLbnPOussF9Rab8bZfffddxo0aJDrvbjIOxISotGjR6tv376FWt+GHLI2vi+88EKRt2VVke+66y7d+9Djss6d7ULSej4e8cFPSt2f5jptuXNgV53YuLYOpKVrx65kPfPWBG3YcujSOi+pVzNWD93UU1GVKrieVh/+eLyWb8gI3IdcepZ+WrBCPy2Idz2Mfv3INS49IsPLa0fiHn3722K9/M00DTijlS467UQdSPOpTFiIJvy+TK9//6u8rPovOXsrrlO/iusJ2Yb72ZOUouGPjM4atuf2Iedpxk9LNOPvTqJs3Zc/ukGXnvWM9u7JKMk2p5zZTFfeeKbS03wuwJ33W7zeem6sK8ktyUL2HvwM+anToIrufOoiRVoaJafoufs/06q/g9LbH79AM35cpBk/LnZB/Y1D+qr5Scco7UCaq6L98iOjtWndDnXo0lRX39Ej6zywfNF6vfHUt0rcVTJ6T9zZrlqxHHND/u9sRf99zA17c5xWrMs45h4Y1F0//77CTX27nKCLurdxvc7beWnWn2v0ysdT3XnJOpL6/D/XuuOxUkR57UzY4wLoVz+dpqNlT7XDruRToGOqxrqekKMjwpWcYuelcVr29zBkQy/q5jqMsslccHILN9yPmbVinYZ9NilryBoLjq89s62rGbBld5KGfjZRm3clFfv+pmfEzkfVMVVi9UT/7oqxYTVSUvXQZ+O0bPN2PXpBN01ZFK/JizPS58J2LTSw89/pE79Oj40+mD75LQsGpBHpRF4qecdcWso+nZYUrzfeeMP1N+IVFi9YTc/6/35CoRUqBHRf0vft0+r7HnQFdFFRB2veeFmXfIb0sevBH3/88egEtvnZtm2bqlSpUuIDW8uo7foOU5mygc2oJcGeqt45yRzNwLY0K2xgWxoUR2AbLI5kYOs1gQhsAcCLLLBd8sIDngvKsgLbp0pIYHt/cAW2hbVu3TpXmFqYmyKHfZXy888/u7rRHTt21Pr1GeMEvv/++/rrr8IPc5KUlKR58+a5yaxcudI9XrNmjXt+//3368orr8zxmsz17bVbt251jxctyhhGAwAAAAAQHJo1a6ZVq1YVat3DCmy/+OIL9ejRQ+Hh4a59rY0va+wuwpNPPlno95k9e7Zat27tJmP1qe3xkCFD3HOr0pwZ5GbKXH/OnDn66KOP3ONevXodzscAAAAAAJRQRalcfFhj8zz++OOup2ErTf3444+z5p9yyiluWWFZdeL8dnbUqFF55jG4MwAAAICjwkKVAI9jG/Dte8RhldguWbLE9YKcm9VD37WraL3rAgAAAABw1APbGjVqaPny5XnmT5s2zY1pCwAAAABAiQ5sr7vuOt12222aOXOm6814w4YNbjxbG0LnX//6V/HvJQAAAAAcZSG+kjGVViEhIUe2je19993nxlns2rWr9uzZ46olly9f3gW2t9xyy+G8JQAAAAAAR6/zKIucH3zwQd19992uSrINvWNdMVeqVOmwxx0CAAAAgBKFzqMCyoZ1tXjyiAW2mcqVK+cC2kOxZTbOLO1uAQAAAKD06tevX6HX/fLLL93funXrFvo1/yiwLQhD8wAAAAAAoqOjj2giHNHAFgAAAAA8i6rIxWbkyJE6kmj8CgAAAADwNEpsAQAAAABH1eeff65PP/1Ua9asUWpqao5lv//+e8kqsS3KuEMAAAAAUJIEevzaYB3H9qWXXtI111yj6tWra+7cuWrfvr0qV66s+Ph49ezZ87De84gGtnQeBQAAAADI7tVXX9Wbb76pl19+2Y20c88992jChAm69dZbtXv3bh2VwHb//v0qU6aMFi5cWKhxh+rXr39YOwYAAAAACD5r1qxRp06d3OPw8HAlJia6x1dccYX+97//HZ3AtmzZsqpXr57S0tIKXNfGHQoLCzusHQMAAACAgPKFlIwpyNSoUUM7duxwjy22nDFjhnu8cuXKw671e1hVkR988EE98MADWTsDAAAAAEBhnHnmmfrmm2/cY2tre8cdd+iss87SgAEDdP755+uo9Yr8yiuvaPny5apVq5aralyxYsV/3IsVAAAAAJQojGN7RFj72vT0dPf4pptuch1HTZ8+XX369NH1119/9ALbvn37HtbGAAAAAACl27p161yz1UwXX3yxm6wa8tq1a1315KMS2D7yyCOH8zIAAAAAQCnXoEEDbdy4UdWqVcsx35q62rLC9OdUbMP97Nq1S//97391//33Z7W1tSrI69evP9y3BAAAAIASI9Dj1wbrOLY+n08hIXk7xUpKSlKFChUO6z0Pq8R2/vz56tatm6Kjo7Vq1Spdd911iouL05dffum6bn7vvfcOa2cAAAAAAMFp8ODB7q8FtQ8//LAiIiKyllkp7cyZM9WqVaujF9jaDl199dV65plnFBkZmTW/V69euvTSSw9rRwAAAAAAwWvu3LlZJbYLFixQuXLlspbZ45YtW+quu+46eoHtrFmz9MYbb+SZX7t2bW3atOmwdgQAAAAAShR6RS5WkydPzhri58UXX1RUVFSxvfdhBbbly5dXQkJCnvlLly5V1apVi2O/AAAAAABBaOTIkTl6SDZ16tT5R+95WJ1H2fhCjz32mPbv359VR9ra1t5777264IIL/tEOAQAAAACCV3p6uosnrc+m+vXruykmJkbDhg3LGt/2qJTYDh8+XBdeeKHrnnnv3r0644wzXBXkjh076oknnjisHQEAAACAEqUk9Eoc6O0fAQ8++KDefvtt/fvf/9Ypp5zi5k2bNk1Dhw7Vvn37DiumPKzA1iLrCRMmuI1bD8nWLXObNm1cT8kAAAAAABzKu+++64aOtZrAmU488UTXZ9ONN9549ALbTKeeeqqbvCpqwTaVCSuv0q7isvhA70LJ0KJJoPeg5CgTFug9KDH2xR32cN9BJ/1gx4UAAJQOdB51ROzYsUNNmuS99rZ5tuxwHHZgO2nSJDdt2bIlTz3od95553DfFgAAAAAQxFq2bKlXXnlFL730Uo75Ns+WHbXA9tFHH3WNfdu2bauaNWu6zqMAAAAAACjIM888o3POOUcTJ050/TSZX3/9VWvXrtX333+voxbYvv766xo1apSuuOKKw9ooAAAAAJR4VEU+Iho0aOCGih0xYoT++usvN69fv36ufe2BAweOXmCbmpqqTp06HdYGAQAAAAClV4MGDbRx48Y8nURt375ddevWVVpaWpHf87B6RRk0aJA++uijw3kpAAAAAKAU8/n8j2Fko+1UqFDhyJbYDh48OOuxdRb15ptvujrR1i1z2bJlc6z73HPPHdbOAAAAAEBJEVICxrEN9PaLU2ZMaX00DRkyRBEREVnLrJR25syZatWq1ZENbOfOnZvjeeYGFy5cmGM+HUkBAAAAAA4VU1qJ7YIFC1Su3MGxBO2x9Yh811136YgGtpMnTz6sDQAAAAAAMPnvmPKaa67Riy++qKioqGJLlMNqY5tbQkKCvvrqq6werQAAAAAA8GfkyJHFGtQedmB70UUXucFzzd69e914tjbvhBNO0BdffFGsOwgAAAAAQLEHtlOnTtVpp53mHo8ePdrVkd61a5deeuklPf7444fzlgAAAABQMsexDfSEIxPY7t69W3Fxce7x2LFjdcEFF7gerc455xwtW7bscN4SAAAAAICjF9jaoLm//vqrkpOTXWDbvXt3N3/nzp2HPe4QAAAAAABHtFfk7G6//XZddtllqlSpkurXr6/OnTtnVVG2drYAAAAA4HWMYxvkge2NN96o9u3ba+3atTrrrLMUGppR8NuwYUPa2AIAAAAASn5ga6wnZJuysza2AAAAAACUyMB28ODBGjZsmCpWrOge5+e5554rjn0DAAAAgMCiV+LgCmxHjRqlBx54wAW2c+fOPeR6ISEhxbVvAAAAAAAUX2Br49Smp6e7x6tXr9asWbNUuXLlwr4cAAAAAIDADvcTGxurlStXuserVq3KCnIBAAAAIGirIZeECcVXYnvBBRfojDPOUM2aNV11Y+s4KiwszO+68fHxhX1bAAAAAACOTmD75ptvql+/flq+fLluvfVWXXfddYqMjPxnWwcAAACAEopxbIN0uJ+zzz7b/Z0zZ45uu+02AlsAAAAAgDfHsR05cmTx7wkAAAAAAEcrsAUAAACAoFcSOm8K9PaDrVdkAAAAAABKIgJbAAAAAICnURUZAAAAAPygV2TvoMQWAAAAAOBpBLYAAAAAAE+jKjIAAAAA+EOvyJ5BiS0AAAAAwNNKRIntiBEj9Oyzz2rTpk1q2bKlXn75ZbVv397vuvv379dTTz2ld999V+vXr1fjxo319NNP6+yzzy7SNkNCQnTDA33V7vSmSk9LV8KuPXrhoS+0cc12Va8Tq4devFyhYaEKCwvV2vgtevHhL5WUsFfB4F8P9tHJZzZV9TpxuvG8F7RsWbzf9arXr6q7R96k41o30KaVW3RDm7v9rvfMxEfUqE0DnR93tYJJrXpxuvvxCxQVE6HkpH0a/vBorV6xJc963c9rrb6Xdcx6XqV6lBbMWa1hg//nnletEa2bHzxXtetXcXnt209/0zf/m6lgUKteZd315IWKiq2oPZZGD3zuN43seLvu7p466dTjlX4gTQm79+qFR77UxjU73PL2ZzTWdXf1UmhYiFYt3azhD36uPckpChb1qsZo2OU9FFsxXIl7UzTkw/FasWl7nvVqxUXpscu6q0mdalq/fbcGPPNhoZZ5Xb3KMXryoh6KjQhX0r4UPfDZeK3Ykjd9+rVtrkGd27n89NuKtRr21Y86kJ6uWrFReqJ/dzWtVU3rd+zWBS8FT9oUZzoVtCwYkEakE3mpZB5z1157rSpWrChPosTWMwJeYvvJJ59o8ODBeuSRR/T777+7wLZHjx7asiXvxbF56KGH9MYbb7jgd9GiRbrhhht0/vnna+7cuUXabp8+fdS8TQMX2P2rzwua9+tyXTM4IzjesTlBd176mm7q+6Ju6P28tm9J0OW3dFOw+HncAt156evavC4jqDiUPQl7NfLhj/XkZS8ecp0L7jhXG+M3KRjdNuQ8ff/5bA3s86I+HTlNdw473+9647+eqxsvejVr2rk9SZO//yNr+SMvXKKJ38zToD4v6v/Of1lTxy1UsLh1aF/98PksDTrnOX369lTd+eSFftc7uUsTNWtdXzf2e0n/6vey5s1YoWtu6+GWVYgopzseu0CP3vqBBvZ6Ttu3JujSG7oomDw8oKu++GWB+jw+SiMnzXYBqj92UTDiu+m6/90firTM64b266rPf1ugc4aP0ts/zdaT/fOmT+3YKN3SvZOufP1T9Xx2pCpXilD/9ie4Zcn7UvTyuOm653/BlzbFmU75LQsWpBHpRF4qgcdcXLSGDRumPXv2HOW9Q2kT8MD2ueee03XXXadrrrlGzZo10+uvv66IiAi98847ftd///339cADD6hXr15q2LCh/vWvf7nHw4cPL9J2fT6fypYro3LlMwqtIyqV17ZNu93j/fvTlJpywD0ODQ1RhfBy8tndmiCxcPZKbduc8Vnzk7gzSX/+8pf2Je/zu7x+szrqdF47ffzvrxRsouMqqlGzWpr0XUaAOm3Cn67ktVbduHxf1/iEOoqJq6hfp/zlnrfu0FD7U9P084Q/s9bZtSNZQZNGzWtr0ph57vm08QtVpUa0atbLm0Z2/JQtF6Zy5bIdb3/nwXanHq8Vf23QupVb3fNvP56pM3q1VLCIqxSuZvWq67vZi93zifOWqUZspOpWic6zbsKeFM2N36C9qfuLtMzL4iqGq3nt6hozNyN9xi9cphoxkapXOWf6dD+hkSYvite2pIwLo09mzlevVo3d4917U/T76g3auz+40qa40ym/ZcGANCKdyEsl85jr0bKJvvnmG3ftDQRtYJuamqo5c+aoW7eDpaGhoaHu+a+//ur3NSkpKapQoUKOeeHh4Zo2bVqRtj1mzBj9MXO5/jftYX007SG1Ovk4vffS+KzlZcqGacRXt+mTGUNUq34Vvf/ShCJ/vmAWViZMd7x5g1684U1XvTbYVK0erR3bknJ8tq0bd6tqzbzBSHZnn99Gk8b8obQDGa+rd2w17d6ZrPufvkgjPrlRQ56/RDVqxyoYWKC/c2tirjTapWo1Y/KsO3PKX5o/a6X+99MD+uin+9Wqw7F675WJGe9TM0ZbNuzKWnfz+p2KqxrpmgIEg+qxkdq2O1lp6Qd/0DftTFTN2KiA7ldJYRdBWxNzps/GXYmqGZMzfWrGRGrDroSs5xt2Jrh5pUVxpFOwpyFpRDqRl0rmMWfNRVavXi2vj2Mb6AkFC+iV47Zt25SWlqbq1avnmG/Prb2tP1ZN2Up5ly1bpvT0dE2YMEFffvmlNm7cmG8AnZCQkGNq27atGhxfQ5ed/oQuO+0JzZuxXLc+erCq6YH9aa4q8iWnPK518VvV6+IOxfjJve+KR/pr2uiZWvPX+kDvSolRPryszjj7BI0dPSdrnrXRbtm+oT56c4puGvCq5kxfrgf/M0ClTaMWtXXMcdV12Zn/1mWd/615M1fo1iHnBXq3AAAAgtaIESN0zDHHuELBDh066Lfffst3/c8++0xNmjRx659wwgn6/vvv5SWeKxJ58cUX1ahRI5fo5cqVc4Ht0qVL8/2irHpzdHR01lS3bl1deeWVmjtjmZIT97mqERNH/64TOxyb57UW4I7/cra69mktr+p6XhtX+mzTWf3aFst7nnh6M/W9uafejx+h538epoiocPc4uop3S6G69W6lVz+90U1tTj5WcVUq5Sg1tNJaK7U9lNPPauE6TloTn1Gl1mzZtFsr/tqY1aHSxG/n6bimNRVWxnOHnmPHwYgvbnZT647HKTZXyaorfd14sPQ1U7c+rV0wm3W8ffW7Tmzf8GApb62DpbzVa8dqR66SYK85t11TfXLPZW46uXE9VYmuqLDQkKzlVhV5486DJWel2aZdiaoamTN9rBRxY7aSxcxSgFrZSgGsBMDmlRbFkU7BnoakEelEXiqZx5zVDqlfv/5R3jt8UsR+jKZPn65LLrlEAwcOdH0X9e3b100LF3qnb5iAXl1XqVJFYWFh2rx5c4759rxGjRp+X1O1alV99dVXSk5OdtUarEdk60jq0ksvPeR2rr/+eu3evTtrWrt2reLj49X65EauyrFp36WJVi/N2A+7yC5foax7bD1Hnnb2CVq51LsdJE36+ndX+mzThC9nF8t7Dj5jiC5vcKOuaHiT7jjtYdfRlD3evc27F+sTx8zL6gDq05E/a/nijep6TkZbz1PPaq5tmxO0Ye2hO9w6u18bjRv9e455s6Ytdb0kV66WUd2v/anHa238tqyqyl4z6Zu5uumCV9z02dtTtWLRBnXt3cotO7V7C9dOPbOn4+w2rdvhqh9nHW+dm2j18ozjbfa0pTquaS3VaVDVPT/34g766Yf58rJvZy12vRbbNHLibC1eu0XntG3qlnVr1UibdyVp7baC27mXBjuS92rRhi3q3Tojfbq3aKRNu5O0ZnvO9JmwcLm6NGuoKpUi3PMBHU7UD38sUWlRHOkU7GlIGpFO5KWSecyNn7/Eddpq19Se7hU50NMR7sfoxRdfdKPM3H333WratKnr8KtNmzZ65ZVX5BUhvgC35LZicRvax4JTY9WL69Wrp5tvvln33Xdfga+34X8s8S+66CI9+eSThdqmVUW2AHn0e1PUou2xSjuQ5kqIXn5ktLsA79Clqa6+I6PHVjsIly9arzee+laJu4KjN7dbH+2ndp2buBJJG+Zoz65kXX38LW7Z4Ldu0K/fzNavY2arfHg5jVzyksqWL6uK0RHatWW3Jn4wVe888FGeYYFen/us54f7CW3RJMfzOsdUcT0hR0VHuKFnhg8ZrVXLMoKx24eepxlTlmjG351E2bov/+8GXdr1Ge3dk5rjfdp0PFaD7ujh8pING/TKk99mvU9JFZKWVqj1XBo9caEiYyLccD/PPfTFwTR69HzNmLJYMyb/pbJlw3TjQ33UvHX9jONtW5JefuwrbVq3M6vX5IGDe7qSbHv9fx74THuSSsZwPxu7ZgTc/0T9arEadll3xVS04RBSNeTDcVq+MWM4hEcu6aYpC+L108J4VShbRt88fLXKlglTZIXy2pG0xwXJL435Jd9lR8uBjHio2B1TJdYN1xNjw0WkpOqhz8Zp2ebtevSCbpqyKF6TF2cMSXZhuxYa2Lmdezwrfp0eGz3JDVVjafPdXVerXFhG2mxP3qMxvy/WC+OOXtocDf80nQpaFgxII9KJvFTyjrm0lH06LSnejWpifel4hcULVtOz8e1PKqx8zv59jjZLwyUvPOAK56KiDta8KV++vJv8NcOMiIjQ559/7kpdM1111VXatWuXvv766zyvsfjLSnhvv/32rHlW2msFin/8cXC0j5Is4IGtFZNbIltmtwD3hRde0Keffqq//vrLtbW1KsO1a9d2Y9eamTNnuvFrW7Vq5f4OHTpUK1eudEXsMTF5O63JL6N2PfY2lQnLmxlKm7RDjGNb2uQObEuzwga2pUFxBLbB4kgFtgCA4JUZlFmtyexBWUlXEgPb3CzwtFgotw0bNrj4yaoXd+zYMWv+Pffco59++snFU7lZE893333XVUfO9Oqrr+rRRx/NU7u2pMoYeyOABgwYoK1bt2rIkCGuwygLWMeOHZvVodSaNWty3N3Zt2+fG8vWqhJXqlTJDfVjQwAVNqgFAAAAgEI5zKrAxerv7fsrsUUJCmyNVTu2yZ8pU6bkeH7GGWdo0aJFR2nPAAAAACDwLKgtTKl3lcPox8jmF2X9ksg7Fd0BAAAA4Cjy4ji25cqV00knnaRJkyZlzbN+jOx59qrJ2dn87OsbG33mUOuXRCWixBYAAAAAUDwGDx7s+jFq27ZtVj9GNqqM9ZJscvdjdNttt7mascOHD9c555yjjz/+WLNnz9abb77pma+EwBYAAAAAgsiAIvZj1KlTJ3300UeuL6MHHnhAjRo1cj0it2jRQl5BYAsAAAAAJbzzqCPZj5Hp37+/m7yKNrYAAAAAAE8jsAUAAAAAeBpVkQEAAADAj8Pplbi4BXr7XkGJLQAAAADA0whsAQAAAACeRlVkAAAAAAiyXpFLG0psAQAAAACeRoktAAAAAPhDia1nUGILAAAAAPA0AlsAAAAAgKdRFRkAAAAA/Aj5ewqkQG/fKyixBQAAAAB4GoEtAAAAAMDTqIoMAAAAAP7QK7JnUGILAAAAAPA0AlsAAAAAgKeV6qrI6avXKT2kbKB3AyUFt3myhCTuC+Q3UbKkB3oHShDS4iDOFwBQKoT4MqZA7wMKxk8zAAAAAMDTSnWJLQAAAAAcEp1HeQYltgAAAAAATyOwBQAAAAB4GlWRAQAAAOBQ6LzJEyixBQAAAAB4GoEtAAAAAMDTqIoMAAAAAH4wjq13UGILAAAAAPA0AlsAAAAAgKdRFRkAAAAADtUjcqB7RQ709j2CElsAAAAAgKdRYgsAAAAAftB5lHdQYgsAAAAA8DQCWwAAAACAp1EVGQAAAAD8ofMoz6DEFgAAAADgaQS2AAAAAABPoyoyAAAAAPhBr8jeQYktAAAAAMDTCGwBAAAAAJ5GVWQAAAAA8IdekT2DElsAAAAAgKcR2AIAAAAAPI2qyAAAAADgD1WRPYMSWwAAAACAp1FiCwAAAAB+MI6td1BiCwAAAADwNAJbAAAAAICnURUZAAAAAPyh8yjPoMQWAAAAAOBpBLYAAAAAAE+jKjIAAAAA+BHi87kpkAK9fa+gxBYAAAAA4GkEtgAAAPj/9u4DLIqrCwPwR1eUKkixYO8FjYqaxIrYEjUqamLvxmg0mlhSrIk1sf4mamKNGjWJLYm9994LiFhAEQEVEFQQ2P+5d2GlLE1jdmf43ueZuFN2d/bkzrJnzp07RESKxq7IRERERERE+nBUZMVgxZaIiIiIiIgUjRVbIiIiIiIiPUw02smQDP3+SpFnE1sPDw/MWjERZT1LIvR2GD6uPTbN+ha9GqHzF21gYmqK8/uvYP7QpUhMSIQaDJ7VE3XfewuuJZwxqPYYBJ4J1Ludi4czvlj2CcrUKInQW2EYVPML3bqKdcth2I/95WMzCzNcPuKHHz9dihfxCVAL9+KO+GJyB9jaWyM25jl+GLcRdwLDMmzn07YG2n1UTzfvVNgWl87eweSRv8HF3R7L/voMt2880K0Xy+/ffQw1cC/hhJHffwhbxwJ4Gv0cP3zxG4ICXn7WFCYmJuj35fuo1bACEhOTEP34KeaOXY/7dyLk+g4DGsO7fS2Ymprg7s1wzPriN8Q+eQ61KO5sj8ndm8OhYH48eRaHcb/uRGDowwzbuTvaYlJ3H1QoWhj3Hkah87TVunXVSrrhq85N5GMLMzOcC7yHaX/sxwuVfC8Vd7LHlE7N4VAgP2Kex+HL9TsR+CBjjIT2tSujX+Pasl2dvBGMyRv3IiEpCV6li+Gzlu/A2soCYgDJg363MGvbIflYDYoXSo6RdXKMft+JwLCMMWpfqzL6NUqOT2AwJm/Sxie7dWrAGDFObEvGecz16dMHBQoU+I/3jvIao+iKvGDBApQoUQL58uWDl5cXTp48mem2jRo1kn+Q00+tW7fO1XtGR0dj6fjfMLXH/zKsEwlfzwmdMKLJRPSqOBwOLnZo1U/7g1INDm04gRGNJyD0dniW2z2NfoZl36zFlK5zM6y7eeE2PqkzRia7A6qNhL2zHd4f3BxqMuzrttj652n0bTsX65cdxshJH+jdbufmcxjc+Ufd9PhhDPZtvaBb/+xpXJr1aklqhaHf+WLbb8fRv8k0/L5oL0bO/FDvdnW9K6NSrZIY3Op7DG75Pc4fvY5eX7SS62q8Uw4+HWtjRId5GOgzAwGXg9EzeZ1afNOlKf48cgltJi3Hsl2nZfKqj/hRsOCvoxi7fFuGddfvhqPrjN9kstthyko42lij87vVoBYT2jfFHycuofXM5Viy/zSmdNIfoyIOthjavD56/LgeLacvQyEba/h6VZXrop49x+drtqLNDyvhO281PD3c0LZmJagqRicvofUPy7HkwGlM8fXRHx+f+uixcD1azlyGQgWt4Vunarbr1IIxYpzYlozwmHO0w+TJk/H06dP/eO8orzF4Yrtu3TqMGDEC48ePx9mzZ1G9enU0b94cYWEZK2PChg0bcP/+fd10+fJlmJmZwdfXN1fv+/jxY1llfB6bsSr0bnsvHPv7DB4/iJLzfy/ejcad60MtLh32Q8S9R9lu9+RxDK5kEqO4Z/G6Cra5pTms8ltCo5ayCAA7hwIoW8kde/7RJqiHd1+Bs4sd3Is5Zvm88lWKwt6xAI4d8IPa2RUqiHJVi2HvpjNy/vC2i3Byt4ebh1OGbTXQwMLSHJZWFnLeumA+RNyPlI9LVXTHldO38Cw2Ts6f2ncNTdvVglo4FsyPSsVd8M+pa3J+9/kAuDrYoJiTXYZto5/G4dzNEDyLf5Fh3fMXCbrKmqjYWlmYq6YS6VggPyoXdcFf57Qx2nkpAK72NiheKGOMfKqVxb6rNxERo/2BtO74RbTyLC8f+4WE4+4j7fd2fEKinBdVcNXEqEiqGF3WHyOfqunic+JlfLJapwaMEePEtmScx1zz6hWwZcsW5f5O1BjJRMaf2M6aNQv9+/dH7969UalSJSxcuBDW1tZYunSp3u0dHR3h6uqqm3bt2iW3z21imxXnYk4IC9J2kRQe3AlH4WIZf6zndaKr8sJzM/Fn+FLERj3FXz/uhFo4u9rhUUQMkhJfdtELD42Sy7PS4oOa2PP3BSQmvHxevnyWmLd6IP7328foOqCR7G6rBs5u9ngUHp02RiGRKOxun2HbE7uv4tLxQKw5OQGrT06AZ/2y+HX2drku4NJdeL5dDg5ONnK+cbu3YG2TDwXtrKEGLg42iIiORWLSy79KoY+ewO0VEi6RpK0f0w0Hpg9CzLM4rDv0smeAkokfQuFP0sbo/uMncLPPGCM3exuEPI7WzYc8ipbL0nMqaC2T4APXbkG1MYrMGCMZn8hU8Xn8Mj5ZrVMDxohxYlsyzmPO3cEWd+7c+Y/3jvIigya28fHxOHPmDLy9vV/ukKmpnD927FiOXmPJkiXo0qVLlv324+LiZNfj1BO9PpHwD6rxBTq59YeFlTneaV8nT4fVKp8FGjaviu3JFUzhUfgTfOQzE592XYSxA5ejSk0PdOjxNvKastWKwaOcK7rVnYhuXhNx/miA7MYsXDx+A3/+vA8TlvTD7I3DEPUwRi5PSlTHtaP/JpHEdZq2Ck3GLoaFuRm8PcsYepeMUgErSyzo3RZL95/GlbsZr/kmIiIi9THo4FERERFITEyEi4tLmuVi3s8v+66c4lrcGjVqYPbs2VluN3XqVEycODHH+xUeHAG3Ui5pKpNhwS8ruErj3e1ddBimvWZx4/zt2LnywL/6+qKr8v51R9Dko3exf91RKJX3e55o313b5Xz/tktwdCoIUzNTXUVSVGtF1TYzDXyqyMGlgm6+vHb5xYtERD2OlY+fRD/Djk1n0bhlNfy+/DCUqGn7Wvigb0P5+MCWc3B0tk0bI3d7hIVE6n3ehWMBugGhdv95Ct+tHKRb/8+qo3ISKnh6IDzkMZ7GaLsmK9F7dSqie5Oa8vH20/5wsi0AM1MT3VltV0cb3H/06ifYRFflHWf90apWRWw/cx1K1KZmRfRsoI3R1vP+cLZJGyM3BxvcT1VdTF0NKFbIPk0VWyxLIQaOWtT3A+y9EogVh85CLUIjn2SMkX3GGMn4OKaKj8PL+GS1Tg0YI8aJbck4jznRO0QM2qpUHBVZOQzeFfl1iGrt+fPnsx1lbezYsYiKitJNwcHBWW5/aONJ1HvvLTlolPDeAG/sX5+zCrIx2r3qkBz1WUz/VlLrXtoVZuZm8rG5hTnebueFW5eCoGS7/z6vG+Bp/fJDuOF3H01bV5fr3vGujIgH0QgJzvza5BbtasrENf21umbm2sPMwsIMbzethEC/+1CqPRtOY0jrH+QkBou6ceUumrR7S657p2U1RNyP0o10nFpo0ENUr1cW5hbaNuPVpDLuXH8ZBwdnG13Vu/uIFvhj8T4o2d8nr8lBnsS0bPdpXLsbhta1K8p13p5l8SAyBsERmZ8k0Udck2tuqm1L5mamaFKtDK6HZD0AnDHbcvYaOsxZLScxWNTVe2F4v0ZF3bWgoVExCHqYMUa7Lt1A40qlZFdjoXPdath2wV8+tra0wOK+7XHk+m0s2pv5IIRK9Cj2Ga6GpIpRFf0x2nU5XXy8XsYnq3VqwBgxTmxLxnnM7bzojzZt2sjBXoneJBONAa/kFl2RxfWxf/zxB9q1a6db3rNnT0RGRmLz5s2ZPjc2Nhbu7u6YNGkShg0blqv3FV2RxfW5d64Hw8LKAgXsrBEZFoU9aw5j6ddr5TYt+zSRt/sRLh68irmfLFHN7X6GLeiLOi1rwNHVHtEPY/D0yTP0KjdUrhvx8yAc23Iax/46LQeEWuY/L02Mdq86iKVfrkGr/t5oN7SlrNSJBPfc3kv4edQqvIjLOOiNUphWq5BmvqiHkxwJWdzuR1QPfxi/UXfbnuHj2uL4AX8cTx4kSmw7f80gfNRsBp49jde9xttNKqHH4CZIStTIBPf8yZv4edZ2Wck1ZqZR2ipzdoqUcpYjIds4WOPpkzjMHrUWt/21CeuwaZ1wfPcVnNh9BRaWZvh4YgdUrlVSHkePw59g/le/IzT5RMGP276Q1x6LxHfvxjNYM994rtcOaV3stV/Do7ADJnf3gb28lU08xq3agRsh2tshjP/IG/sv3cSBSzeRz8IcW8b1kt2MbfJb4dGTp/j71DXM23IEHd6uio8aesqz4iKxPeEfhNmbDslBkv4rCW/wsucSzg74rpMP7MUtI+Li8fX6HQhIviXSxI7e2H/1phz4SOhYpwr6Nq4tH58KvItJG/bIgbUGNKmDwc3qprlN0I6LAVj8JpJcA5wWLuHkgO98U8Xo9x0IePAQEzskx+dacnxqV0HfRsnxuXkXkzZq45PdOjVgjBgntiXjO+YS457j3ZibWLRokbzkUClEvmBnZ4eaH34HM8t8Bt2XxPjnOPvbV7JAZ2urjkERVZfYCuL2PnXq1MH8+fPlfFJSEooXL44hQ4ZgzJgxmT5v+fLlGDRoEO7du4dChQq9UkNtbN4B5ibaUVrzMk2Ceu49+28mtnlZThPbvODfSGzV4k0mtoqjnN9mREQGJRJb/zlfKi4p0yW2XYwksV3LxNaor7EVxK1+RIW2Vq1aMsGdM2eOrMaKUZKFHj16oEiRIvI62fTdkEWVN7dJLREREREREamLwRPbzp07Izw8HOPGjUNoaCg8PT2xfft23YBSQUFBGbot+Pv74/Dhw9i503i6KxIRERERkbpw8CjlMHhiK4hux2LSZ//+/RmWlS9fXrk3eSYiIiIiIqJ/Fa8SIiIiIiIiIkUziootERERERGR0RGdRA3dUdTQ768QrNgSERERERGRojGxJSIiIiIiIkVjV2QiIiIiIqIsRkYm48eKLRERERERESkaE1siIiIiIiJSNHZFJiIiIiIi0kej0U6GZOj3VwhWbImIiIiIiEjRWLElIiIiIiLKZOAoQw8eZej3VwpWbImIiIiIiEjRmNgSERERERGRorErMhERERERkT6iG7ChuwIb+v0VIk8nti/ergKNeT7kdfkCwwy9C0YhtqiNoXfBaJg7Wht6F4zGC1tD74HxMEkw9B4QERER6ceuyERERERERKRoebpiS0RERERElBmTJO1kSIZ+f6VgxZaIiIiIiIgUjYktERERERERKRq7IhMREREREenDUZEVgxVbIiIiIiIiUjRWbImIiIiIiPQw0WgnQzL0+ysFK7ZERERERESkaExsiYiIiIiISNHYFZmIiIiIiEgfjUY7GZKh318hWLElIiIiIiIiRWNiS0RERERERIrGrshERERERER6cFRk5WDFloiIiIiIiBSNiS0REREREREpGrsiExERERER6SMGJDb0oMSGfn+FYMWWiIiIiIiIFI0VWyIiIiIiIj04eJRysGJLREREREREisbEloiIiIiIiBSNXZGJiIiIiIj00Wi0kyEZ+v0VghVbIiIiIiIiUjQmtkRERERERKRo7IpMRERERESkB0dFVg5WbImIiIiIiEjRmNgSERERERGRorErMhERERERkT5iQGJDD0ps6PdXCFZsiYiIiIiISNFYsSUiIiIiItKDg0cpByu2REREREREpGhMbImIiIiIiPKoR48eoWvXrrC1tYW9vT369u2LmJiYLJ/TqFEjmJiYpJkGDRoEQ2JXZCIiIiIiIn2SNNrJkN7w+3ft2hX379/Hrl278OLFC/Tu3RsDBgzAmjVrsnxe//79MWnSJN28tbU1DImJLRERERERUR507do1bN++HadOnUKtWrXksvnz56NVq1b4/vvv4e7unulzRSLr6uoKY8GuyEREREREREYuOjo6zRQXF/far3ns2DHZ/TglqRW8vb1hamqKEydOZPnc1atXw8nJCVWqVMHYsWPx9OlTGBIrtkREREREREZ+H9tixYqlWTx+/HhMmDDhtV46NDQUhQsXTrPM3Nwcjo6Ocl1mPvroI3h4eMiK7sWLFzF69Gj4+/tjw4YNMBQmtkREREREREYuODhYDvCUwsrKKtNtx4wZg+nTp2fbDflViWtwU1StWhVubm5o2rQpAgMDUbp0aRgCE1siIiIiIiIjJ5La1IltVkaOHIlevXpluU2pUqXkNbJhYWFplickJMiRknNz/ayXl5f898aNG0xsiYiIiIiIjImJmDSG34fccnZ2llN26tWrh8jISJw5cwZvvfWWXLZ3714kJSXpktWcOH/+vPxXVG4NhYNHERERERER5UEVK1ZEixYt5K17Tp48iSNHjmDIkCHo0qWLbkTke/fuoUKFCnK9ILobT548WSbDt2/fxpYtW9CjRw80aNAA1apVM9hnYVdkIiIiIiIifTQa7WRIb/j9V69eLZNZcY2sGA25Q4cOmDdvnm69uLetGBgqZdRjS0tL7N69G3PmzEFsbKwc1Eo85+uvv4YhMbElIiIiIiLKoxwdHbFmzZpM15coUQKaVMm1SGQPHDgAY8OuyERERERERKRorNgSERERERHpIQaOMvjgUYa+j65CsGJLREREREREisbEloiIiIiIiBTNKLoiL1iwADNnzkRoaCiqV6+O+fPno06dOnq3Xb58OXr37p1mmZWVFZ4/f56r92zYsCF27PgKwcGPdMs++fRXxMcnyMclSzrj0yHN4GBvLeeXLDuIQ4evQw2KFHHAmFGtYWdnjdjYOMweuhJBAQ8ybGdiYoJ+X76PWg0rIDExCdGPn2Lu2PW4fydCru8woDG829eCqakJ7t4Mx6wvfkPsk9z9fzBmRd0d8OVnrWBnmx8xsXGYOmcrbgc9zPI5c77rjLKlXdC6y8uR5D7qUActmlbBi4RExMcnYt7i3bh2PRSqaUtj3oOtrbYtzZjxN27f1raP1KpXL45p0zqlOd6GDFkpjzcTE2DQoKaoXbuUtp1FP8MPP2xDSMhjqIFHIXtM6dgcDgXy48nzOHz1x07cCMvYjtq/VRn9G9aWx92Jm8GYvHkvEpKSUL2YG8a3bSK3MTczw9k79/DdX/vxIjERalLcyR5TOmnjFPM8Dl+u34nAB/qPt/a1K6NfY22sTt4IxuSN2lh5lS6Gz1q+A2srCzmA5EG/W5i17ZDBB7P8txQvlBwj6+QY/b4TgfraUq3K6NcoOT6BwZi8SRuf7NapAWPEOLEtGecx16dPHxQoUACKJP6GGPrviKHfXyEMXrFdt24dRowYgfHjx+Ps2bMysW3evDnCwsIyfY6trS3u37+vm+7cufNK7x0U/BD9By3TTSlJrZWVOb6d1EEms736/oI+/Zfg4qVgqMWI4S3w9z8X0KPXYvy29jhGzvxQ73Z1vSujUq2SGNzqewxu+T3OH72OXl+0kutqvFMOPh1rY0SHeRjoMwMBl4PRM3mdWnz+iQ+2bL+ArgN/wZo/T2Ds8Kw/X6d2tXAvNDLNsjIlC6Nd6xoYOOJX9P10BTb8fRbDBzWDWowY0QJ//30ePXsuwtq1xzBq1HuZbiuS2gEDluqmlOOtfv2yqFKlKPr3XyKnc+duo1+/hlCL8e2a4vdTl9Bq1nIsOXga33X0ybBNEQdbfNqsProvXo8WPyxDoYLW8K1TVa7zDw1Hpx9/Q/v/rUbbeSvhWMAaH9Y13D3i3pQJ7ZvijxOX0HrmcizZfxpTOmWMU0qshjavjx4/rkfL6ctQyMYavl7aWEU9e47P12xFmx9Wwnfeanh6uKFtzUpQVYxOXkLrH5ZjyYHTmOKrvy0N9amPHgvXo+XMtG0pq3VqwRgxTmxLRnjMOdrJe56m3CqGSLWJ7axZs+QNgUUVtlKlSli4cCGsra2xdOnSTJ8jzjS7urrqJhcXl391n5o2qYRr1+7h8uW7cj4pSYOoqGdQA3t7a5Qv54pduy/L+YOH/OHkbg83D6cM22qggYWlOSytLOS8dcF8iLivTdxKVXTHldO38Cw2Ts6f2ncNTdvVglrY21mjfFlX7Np3Rc4fOHIdhZ1tUMTNXu/2JYoXwrt1y2L17ycyxFBU2fLl08bQpqAVwiOeQC1tqVw5N+zaldyWDvqjcGEbuLs75Op1RDXNwsIMlpbaDiTW1lYID1dHjBwL5EeVIi746/w1Ob/zcgDc7GxQ3NEuzXbNq5TFvms3ERGj/aO//sRFtKpWXj5+/iJBV1GzMDODlYW5aiqQqeNUuagL/jqXHKdLAXC1t0HxQmnjJPhUK4t9V1/Gat3xi2jlqY2VX0g47j6Kko/jExLlvLujLVQToyKpYnRZf4x8qqaLz4mX8clqnRowRowT25JxHnPNq1fAli1b0twuhkh1XZHj4+Nx5swZjB07VrdM3BTY29sbx44dy/R5MTEx8PDwQFJSEmrWrIkpU6agcuXKuX7/Iu4OWPRTL5m4bt9xEZu3nJPLS3g4yS6jU77tCGcnG9y8FY4fF+5RRXIrkrOHj2LkZ04RHhKJwu72ui7GKU7svorqdctizckJeBobh4ehURjVZYFcF3DpLlp3exsOTjZ4HPEEjdu9BWubfChoZ42YKOWfkSvsJOIUi8RUcQoLfwIXZ1vcS07uU5iZmWLU0BaYPnebbJOpBd4Kx/rNp7Hul4GIjnmOFy8SMHTMb1ADZ2dbPErXlsLCouHiYqu3G7G7uz0WLeqNxEQNtm+/iC1bzsrlx44FoEYND/zxx1A8exaPiIgnGD58NdTA1c4G4U/StqOQyCdws7dFUHICJrjZ2yAkMlo3fy8yGu72Nrp5d3tb/K97G5kQH/C/hbUnLkBNxA+h9HG6/zg5Tg9fxkkXq8cvYxXyKFouS8+poLVMggcv2wzVxigyY4zStyURq5T4ZLVODRgjxoltyTiPOXcHW1w59mq9K42BiUYjJ0PvAxl5xTYiIgKJiYkZKq5iXlxvq0/58uVlNXfz5s1YtWqVTCTq16+Pu3e11dXMEujo6Og0k+j23N53FgZ+vBzfjN+A99+rgUYNK+gSlbdqlsCs2dtlF2VRYftsWHPkNWWrFYNHOVd0qzsR3bwm4vzRAAz9zleuu3j8Bv78eR8mLOmH2RuHIephjFyepLLr/nKi94f1cfDoddy5+/L60RRuLnZoUL8sPhzwMzr2+gm/bz6NCaPaIK8JCAhF584LMHDgMowb9yfef78GGiYfb+XLu6FECSd06vQ/+PrOx9mzd/DZZy0MvctGRSQj7eevQoOpi2FpbgbvymUMvUtGrYCVJRb0boul+0/jyt2M4wcQERGR+hjF4FG5Ua9ePTmlePvtt3H9+nWYmZll+hzRvXnYsGEZlovBbszN88kK0d59V1G1ajHsP+CHB2HROH8hCBHJydru3VcwY1onKJVPsyrw7VBbPt6z7yoKORaUAz6lVNqc3e0RFpK2Cik0bV8LF44F6AaE2v3nKXy3cpBu/T+rjspJqODpgfCQx3gao+2arETNm1SW18kKew5cQyHHAjAzNdGdiRTV7gfhL6sdKapXLSYruR+8V1OeFClgbYV1SwZiwGcr0bB+Ody8HSGr5MLWXZflNbbm5qZISFDegC3NRFvy1Q7stnfvVTima0uFC9viwYOMMXr6NF73WB5ve6+iWrViOHDADz4+VXHu3B15PAo7d17CjBldoAahUU/gbJO2HYlK7P1UVbOUM9zFHF92cy9ibysru+k9jX+BrRf98V71ith2UdmD2bWpWRE9G9SUj7ee988QJzeHjHHSxarQy1iJrsZiWQoxcNSivh9g75VArDik7RWgBqGRGduSWw7akqiUpMQnq3VqwBgxTmxLxnnMid4hoqelYomfa4b+yWbo91cIg1ZsnZycZEL64EHaM+piXlw7mxPm5uZy4CkxAFVmBg4ciKioKN0UHBwsX19cqyvkz2+Jel5lcOOGdj9EciuuQ7W2tpTzXl6lEHgz88GsjN3OXZd1A2StXXcCATceoJl3FbmuwbvlEXE/KkM3ZCE06CGq1ysLcwvtSQOvJpVx5/p93XoHZ20XNqt8Fug+ogX+WLwPSrZj7xU5wJOY1vx5EtcDH6BZY20X94Zvl0N4REyGbsjC0NG/oVOfRejcdxGGjFqN2Kdx8nFU9DOEhEaiasUiyJ98jW39OqURdPeRIpNaQVxPmzL409q1x2UlViS7QoMG5eW1sfq6ITs6FpCjH+uOt3plEJA8ErfYXnRFFsm+ULduGdy6FQ41eBT7DFdDwvC+Z0U571OlLEKjYtJ0QxZ2Xr6BxhVLye6zQievath20V8+Ft2PzU21sbEwM4V3pTK4Hqr8+Gw5ew0d5qyWkxgs6uq9MLxfIzlOVZPjlK4bsrDr0g00rvQyVp3rVsO2C9pYWVtaYHHf9jhy/TYW7T0JNdG1pRrp2lK6GO26nC4+Xi/jk9U6NWCMGCe2JeM85nZe9EebNm10v7uJ3hQTjYGv5Pby8pK39hG3+BFE1+LixYtjyJAhGDNmTLbPF12ZxfW1rVq1kgNR5YToivzll19i5MhxEJdEmpmZYP9Bf6xYeVi3TTPvyviwc10kaTSywvTD7O2qGdCmWFFHjB7VGra2+eW1s3OGrcJtf23COmxaJxzffQUndl+BhaUZPp7YAZVrlURiQiIehz/B/K9+R2jyLVt+3PaFrNaJxHfvxjNYM38nlCy2ctqTKcWKOGLsZy1hZ5MfsU/jMW3OVtxMPgEgrqk9cuIGjpy8keY5roVtsWRerzS3+xnQs4EcWErc7uf58xeYs3C3TJqNmfnTnHUpL1bMUY6ELNvSU3G7n390SenIkS3l9bNHj95Au3ZvoU2bGvJ2PqKqLSq1K1ZojzcxcNSnn/rIkZFFwv/4cSxmz96O+3pOIhhCaN18r/X8Ek4OmNLRB/byVgjx+OrPHQh48BCTPvCWA0bt87spt+tYqwr6NdT2rDh16y4mbtojB43yrV0V3ep7yrPhIsE9HhiE77cfkoMj/ddMtANZvxElnB3wXafkOMXF4+v1OxAQqr1lxMSO3th/9aYc+EjoWKcK+jZOjlXgXUzaoI3VgCZ1MLhZ3TS3CdpxMQCL30SSa4DTwqItfeebKka/a9vSxA7J8bmWHJ/aVdC3UXJ8bt7FpI3a+GS3Tg0YI8aJbcn4jrnEuOd4N+YmFi1aJMfSUQqRL9jZ2eHdBuNlD09DSkh4jkMHJ8oCnbg7DBlpYitu99OzZ0/Z2EWCO2fOHKxfvx5+fn7yWtsePXqgSJEimDp1qtx+0qRJqFu3LsqUKYPIyEh5/9tNmzbJQajEqMq5aajvNDR8QzUG+QKVW41+k4ltXpbTxDYveN3EVk3eZGKrOMr5bUZEZFAisfWf86XikrKUfKHBu+OMIrE9eGiS4mKY566x7dy5M8LDwzFu3Dg5YJSnpye2b9+uG1AqKCgozdmdx48fy9sDiW0dHBzw1ltv4ejRozlOaomIiIiIiEhdDJ7YCqLbsZj02b9/f5r52bNny4mIiIiIiIjIaBJbIiIiIiIioyMu2jT0bWQN/f4KwauEiIiIiIiISNGY2BIREREREZGisSsyERERERGRPuIGMoa9iYzh318hWLElIiIiIiIiRWPFloiIiIiISA8TjXYyJEO/v1KwYktERERERESKlqcrtk+KW8LM0hJ5ncUTe0PvglF4UYDneVJYxCYY9P+FMTFJNPQeEBEREVF28nRiS0RERERElCkOHqUYLFERERERERGRojGxJSIiIiIiIkVjV2QiIiIiIiI9TJK0kyEZ+v2VghVbIiIiIiIiUjQmtkRERERERKRo7IpMRERERESkD0dFVgxWbImIiIiIiEjRWLElIiIiIiLSR5M8GZKh318hWLElIiIiIiIiRWNiS0RERERERIrGrshERERERER6mGg0cjIkQ7+/UrBiS0RERERERIrGxJaIiIiIiIgUjV2RiYiIiIiI9OF9bBWDFVsiIiIiIiJSNCa2REREREREpGjsikxERERERKSPGJA4ycCh4aDIOcKKLRERERERESkaK7ZERERERER68D62ysGKLRERERERESkaE1siIiIiIiJSNHZFJiIiIiIiymzgJnEvW0Pi4FE5wootERERERERKRoTWyIiIiIiIlI0dkUmIiIiIiLSR3RDNnhXZPZFzglWbImIiIiIiEjRmNgSERERERGRorErMhERERERkT5JAEyMYB8oW6zYEhERERERkaKxYktERERERKSHiUYjJ0My9PsrBSu2REREREREpGhMbImIiIiIiEjR2BWZiIiIiIhIH97HVjFYsSUiIiIiIiJFY2JLREREREREisauyERERERERPqwK7JisGJLREREREREisbEloiIiIiIiBSNXZGJiIiIiIj0YVdkxWDFloiIiIiIiBSNFVsiIiIiIiJ9kgCYGME+ULZYsSUiIiIiIiJFY2JLREREREREisauyERERERERHqYaDRyMiRDv79SsGJLREREREREisbEloiIiIiIiBSNXZGJiIiIiIj04X1sFYMVWyIiIiIiIlI0JrZERERERESkaOyKTEREREREpE+SRgxLbPh9oGzl2cS2cePGmDe+F6zzW0Gj0eDwpVuY/+ch2Y2+TBEnjO7aBI421khISsKVW6GYvnov4l4kQA2KFbbHxD4tYF8wP2KexWHO2I24cytc77YlShfGJyNbwMGxgJxftnAfjuz3g4kJMOBTH9SqVxqJCUmIjn6GOVP+Qsjdx1CLoq72GDe4JexsRJzi8e2P23Dr7sMM21Up64Yv+jWTj83NTHHR/x5mLduLFwmJaN2oCjq1rKnbtrBjQZz3u4uxP2yBGhQp4oDRY96HnV1+xMTGYcb0v3HndoTebUuWdMaQT33g4KBtS0uXHMDhQ/7ycctW1dHlw3owNTHBuXO3MXfODiQmJkEtiheyx5TOzeFgnR8xz+Pw5e87EfggY1sS2teujH6NasPExAQnA4MxeeNe+T2U3TqlK+5kjymdmsOhQHKM1mcTo8bJcbjxMg5epYvhs5bvwNrKQn6XH/S7hVnbtN/rqmlHndK1o7CMMWpfK1072ZSqDWWxTg0YI8aJbck4j7k+ffqgQAHt338iVXdFXrBgAUqUKIF8+fLBy8sLJ0+ezHTbDRs2oFatWrC3t5cHiKenJ3799ddcv+fjx48x+sdN8B23At0mr0b10u54r14luU4ksNPX7EWHb5bjwwm/Ir+VBXq2rA21+Kq7NzYevIj2Xy/Diu2n8Pm4Nnq3s7Iyx8SZnbF80T706/ITBny0EJfPB8l19d4tj8rVimFQ10UY1G0Rzp+6hd4fN4GajO7vg017LqLzZ0uxavNJfD24pd7tAu6Eo8+Xq9Bz9Ep0+2I5HGyt0cHHU677Z/9luTxlehj1FDsOXYNafDaiJf75+xx69liEdb8dx6jR72XaliZ92xHLlhxAn16L0a/Pz7h0MViuc3W1Q6/eDTD801/RvdtPMvF97/0aUJMJ7ZvijxOX0Pr75Vhy4DSm+Pro3a6Igy2G+tRHj5/Wo+WMZShU0Bq+XlWzXaeqGM1cjiX7T2NKpyxi1Lw+evy4Hi2nL0Mhm5dxiHr2HJ+v2Yo2P6yE77zV8PRwQ9ua2u911cTo5CW0/iHzdqRrJwvXo+XM5HZSp2q269SCMWKc2JaM8JhztMPkyZPx9OlTKHrwKENPZPyJ7bp16zBixAiMHz8eZ8+eRfXq1dG8eXOEhYXp3d7R0RFfffUVjh07hosXL6J3795y2rFjR67e9/z587gXHikfxyckwj84HG5OdnI+OCwSN+5qq05JGg2u3gqFeyFbqIGDTX5ULOGCrce1ydWeMwFwdrGDe1GHDNs2bl4V1y7fxZUL2gQkKUmDqEjtl5IGGlhYmsHSSlv0ty5ghYiwJ1ALkZxWLOWCHYeuyvl9J67DpZANirrYZ9g2Lj5BV120MDeDlaW5jE96lcq4ytc9dCYQamBvb41y5d2wa9dlOX/woB8KF7aFu3vGttS0aWVcuxaCy5fvvmxLUdq21KBhBRw7GoDHj2Pl/F9/nUPjJupJRhwL5Efloi7465z2mNt5KQCu9jYoXkj7fZOaT9Wy2Hf1JiJitLFZd/wiWlUvn+26PBWjanri4KmNg19IOO4+itJ9r4t5d0db9cSoSKoYXdYfowzt5MTL+GS1Tg0YI8aJbck4j7nm1Stgy5YtsockkaoT21mzZqF///4yOa1UqRIWLlwIa2trLF26VO/2jRo1wgcffICKFSuidOnSGDZsGKpVq4bDhw+/8j4UsrVG07fK4tCFmxnW5bM0R7t3q+LAeXUkIy6ONoiIikViqr76YaFRKOyS8QekR0lnvHiRiEk/dMFPvw7AF+Pbws7eWq47fug6Lpy9jXVbR2Dt1hGoUbsEVizeB7UoXMgGEZFp4/QgIhouTjZ6t3d1tsXKGT2w7ZdPEPM0Dn/uOJ9hm/cbV8X2Q1dV08XWubAtHj2MkUlqirAH0SjskjGR8CjhhBfxCfhuii8W/dwXo8eK7svatlS4sB0ePNAmI8ID0R4LqyMZEcQf+fAnadvS/cgncLPP+Bnd7G0Q8jhaNy8euznYZLtOlTF6nMMYPYqWy9JzKmgtk+AD124hL7UjGZ/IdO0kOT5ZrVMDxohxYlsyzmPO3cEWd+7c+Y/3jvIigya28fHxOHPmDLy9vV/ukKmpnBcV2eyIMz979uyBv78/GjRokOX7REdHp5lSFMhnidlD22Hl9lO4dudBmueJ6yWnDXwPx6/ewb5zN5DXmJmZoGbtkpg77R983H0xHoY/waejW8l15Sq6o0Spwvjwvdn4sPUsnDt1G8NGt0ZeFRoejR6jVuK9AT/BwsIMjbzKplmfz8oCzepXwF97LyEvMjUzRc23SmL2rG0Y2H8JIsKfYPhnLQy9W6RSBawssaB3WyzdfxpX7qb9XiciIsodY+iGzGq30Q8eFRERgcTERLi4uKRZLub9/PwyfV5UVBSKFCmCuLg49OjRA0FBQShUqFCm24sqsKjspmedzxLzh7eX1djVu87qTWpFdXPmb8quRLauVxFdm70lH+846Q8nuwIwMzXRnWEr7GqHsFQVs9TVt/NnbsuEVtiz7RKmzOsqH3u3qobzp28jNiZOzu/65wKmJq9TqpYNKqFL61ry8a4jfnCyTxsnFydbPIjIurv1s7gX2H3UD83fqYTdR7UDIwlN6pbDzbsPcfue/sFwlKKZTxV09PWSj/ftuQLHQgVhamqiq9qKaq1oN3rb0vk7iIiIkfO7d1/G9BldtOvCotJ0X3YR7TEs42soSZuaFdHzXe2gYVvP+8PZJm1bElWy+6kqZ6nPdBcrZJ/mLLeoXGa3TrExapBFjBxyGCNHW7kshRg4alHfD7D3SiBWHEr7va5koZFPctSOZHwc07WT5PhktU4NGCPGiW3JOI850TvEw8PjP947yosM3hX5VdjY2MhrZE+dOiW7L4suyfv37890+4EDB8pkOGUKDg6WA0/9+HlnHLt8G0v+OZFme3GAThnQGlGxz/Htyl1Qun+OXcNHk1bJSQwW5RcUhlZ1K8p1ogt2RFi03tGMD+y+gvIV3WFdwFLO13m7DG4GaKsfofci4VmrBMzNtU3I652yuH1T/8jKSrHt4FXdIE+rtpyE/60wNH9Xe61nY69yCHv4BHcfaK/LTk1cd2tmZqo7IdKwdlncuBOeoRvyX/uUX63dtfOyrLiKae3a4wgICEWzZlXkugYNKiA8/AlCQvS0pf3XUL68G6yttW3Jy6s0AgO119EfOuiPevXL6kZLfv/9Gti3V3tts1JtOXsNHeaulpMYTOPqvTC8X6Oi7jrH0KgYBD3MeDJp1+UbaFyplOxGK3SuWw3bLvhnu06xMZqzWk5isKgcx+hS5nGwtrTA4r7tceT6bSzam/kghEr0KPYZroakilEV/THK0E68smhDqdapAWPEOLEtGecxt/OiP9q0aSNHYyd6k0w0BrySW3QRFtfT/vHHH2jXrp1uec+ePREZGYnNmzfn6HX69esnk9WcDiAluiJPnz4dEyZOws2QlxW03WeuY+k/J9HSqwK+7d8K14PDdRe6X7gRIkdKVgMPFwdM6NMcdgXyI/Z5HOZ8uQm3k5OMz758D8cOXZfX0ApNW1ZF5+5vy4qcqNzOmfo3wsOiZXfbTz5viSrViyEhIQmPH8XILsuhIRkTP6V4UkL7Yy9FcTcHORKyXcF8iH0Wj+9+2o7AYO2gYmMH+uDQ6UAcPhOItk2rwbdlTSQlJcHM1BSnLwdhweoDiH+RqHudpVO7o82gn/D0+QsogXVYfI62K1rMEaNHvwdb2/yIfRqPmdP/xq3kW0eN/LwVjh4NkANDCd7Nqshb+miSNIiIeIJZP2yVibDQqrUnPvywnnx84cIdzJ613WiuRQ6tk/+1X6OEkwO+6+QDe3E7hLh4fP37DgSEar97Jnbwxv6rN7HvmvYa/451qqBvI+0o7Kdu3sWkDXt0t2PJat1/4g3+tSjhnC5G61PFqGNyjK6milHj5DgEvozDgCZ1MLhZ3TS3CdpxMQCL30SSa4DTwrId+aZrRw8eZmxDtdO1k42p2lAW69SAMWKc2JaM75hLjHuOd2NuYtGiRfKSQ6UQ+YKdnR28Sw6FuamVQfclISkOu2/NlwU6W1v1jEOiqsRWELf3qVOnDubPny/nRXJQvHhxDBkyBGPGjMnRa4h7Y928eTPLqq2+hlq9+3cws8yHvK7QJW330LwufWKbl+U0sc0L/o3EVjV4ic9LyvltRkRkUCKx9Z/zpeKSMia2ymPQa2wFcasfUaEV96YVCe6cOXMQGxsrR0kWxDW04nraqVOnynnxr9hWdD8W19hu3bpV3sf2p59+MvAnISIiIiIiojyZ2Hbu3Bnh4eEYN24cQkND4enpie3bt+sGlBIDQ6XutiCS3sGDB+Pu3bvInz8/KlSogFWrVsnXISIiIiIi+tfIgbEM3GUp1S2VyIgTW0F0OxaTPum7F3/77bdyIiIiIiIiIjKaxNZQnI6GwdzMsBeDGwOTp88NvQtGIZ+NdsReAhLy5+mvhrR4kpSIiCjv0iRpJ0PvA2WLw18QERERERGRojGxJSIiIiIiIkVjf0MiIiIiIiJ9xJ1RDXt3VMO/v0KwYktERERERESKxsSWiIiIiIiIFI1dkYmIiIiIiPThfWwVgxVbIiIiIiIiUjQmtkRERERERKRo7IpMRERERESkD0dFVgxWbImIiIiIiEjRWLElIiIiIiLSR2ME95HlbWxzhBVbIiIiIiIiUjQmtkRERERERKRo7IpMRERERESkDwePUgxWbImIiIiIiEjRmNgSERERERGRorErMhERERERkT5JSeI/RrAPlB1WbImIiIiIiEjRmNgSERERERGRorErMhERERERkT4cFVkxWLElIiIiIiIiRWPFloiIiIiISB9WbBWDFVsiIiIiIiJSNCa2REREREREedR3332H+vXrw9raGvb29jl6jkajwbhx4+Dm5ob8+fPD29sbAQEBMCQmtkRERERERPokaYxjeoPi4+Ph6+uLjz/+OMfPmTFjBubNm4eFCxfixIkTKFCgAJo3b47nz5/DUHiNLRERERERUR41ceJE+e/y5ctzXK2dM2cOvv76a7Rt21YuW7lyJVxcXLBp0yZ06dIFhsCKLREREREREeXIrVu3EBoaKrsfp7Czs4OXlxeOHTsGQ2HFloiIiIiISA+NJklOhpTy/tHR0WmWW1lZyem/FhoaKv8VFdrUxHzKOkNgxZaIiIiIiMjIFStWTFZGU6apU6dmuu2YMWNgYmKS5eTn5wc1YcWWiIiIiIjIyAUHB8PW1lY3n1W1duTIkejVq1eWr1eqVKlX2g9XV1f574MHD+SoyCnEvKenJwyFiS0REREREZE+mjc/KnGO9gGQSW3qxDYrzs7OcnoTSpYsKZPbPXv26BJZ0U1ajI6cm5GV/23sikxERERERJRHBQUF4fz58/LfxMRE+VhMMTExum0qVKiAjRs3yseiG/Pw4cPx7bffYsuWLbh06RJ69OgBd3d3tGvXzmCfgxVbIiIiIiKiTKulxlGxfVPGjRuHFStW6OZr1Kgh/923bx8aNWokH/v7+yMqKkq3zahRoxAbG4sBAwYgMjIS77zzDrZv3458+fLBUJjYEhERERER5VHLly/P9h624t61qYmq7aRJk+RkLNgVmYiIiIiIiBSNFVsiIiIiIiJ9kpIAE8PexxYGvo+uUrBiS0RERERERIrGxJaIiIiIiIgUjV2RiYiIiIiI8uioyGrBii0REREREREpGhNbIiIiIiIiUjR2RSYiIiIiItJDk5QEjYFHRdZwVOQcYcWWiIiIiIiIFI0VWyIiIiIiIn04eJRisGJLREREREREisbEloiIiIiIiBSNXZGJiIiIiIj0SdIAJryPrRKwYktERERERESKxsSWiIiIiIiIFI1dkYmIiIiIiDIdFTnJCPaBssOKLRERERERESkaE1siIiIiIiJSNHZFJiIiIiIi0kOTpIHGwKMia9gVOUdYsSUiIiIiIiJFY8WWiIiIiIhIH02SEQweZeD3VwhWbImIiIiIiEjRmNgSERERERGRorErMhERERERkR4cPEo5jCKxXbBgAWbOnInQ0FBUr14d8+fPR506dfRue+XKFYwbNw5nzpzBnTt3MHv2bAwfPjzX72liYoJBX7ZD7QYVkZSYhOjIp5jz9Z+4H/QQLkUd8PXcbjA1M4WZmSmCb4Zh7jcbEBP9DGrg7lEIn0/rDFsHazyNeY4fhq9C0PVQvTHq+1UbvNWooozD1dO38L8v1yPhRSJKVHDD4G87wr6QDRITk3D9/B0s+PoPxD9/AbUoUsQBY0a1hp2dNWJj4zB9xj+4fSciw3bVqxfH9Cm+CA5+pFv2yae/Ij4+QT4uWdIZnw5pBgd7azm/ZNlBHDp8HWpQxN0BX45oBTu7/DJGU2dtxe2ghxm286xaDDMmdUTQ3ZcxGjxytS5GrXyqoqtvXZiYAucuBGHWgl2yXalFcSd7TOnUHA4F8iPmeRy+XL8TgQ8yxkloX7sy+jWuLY+/kzeCMXnjXiQkJcGrdDF81vIdWFtZyPu0H/S7hVnbDqnmnu2MUQ5iVCi5HVknt6PfdyIwLGM7al+rMvo1Sm5DgcGYvEnbhrJbpwaMEePEtmScx1yfPn1QoECB/3jvKK8xeFfkdevWYcSIERg/fjzOnj0rE9vmzZsjLCxM7/ZPnz5FqVKlMG3aNLi6ur7y+7Zp0waVa5bE4LZz8HGbOTh/7AZ6j2gh1z16EI2RH/2ET9rNxaD3Z+NhWDS6DfWGWnw6qT22rT+Bfi2+x/qfD2DkrK56t2vepS5KVymKoS1nYkDjKUhKSkLbPg3luvjnCfjx6z/l8k98psPK2hK+HzeFmowY3gJ//3MBPXotxm9rj2P0qNaZbiuS2v6DlummlITNysoc307qIJPZXn1/QZ/+S3DxUjDU4vOhPvhr+wV06/8L1vx+AmNHtMp0W5HU9hu6QjelxMjVxQ59u7+LoaPW4KO+P8PBvgDeb1kdajKhfVP8ceISWs9cjiX7T2NKJx+92xVxsMXQ5vXR48f1aDl9GQrZWMPXq6pcF/XsOT5fsxVtflgJ33mr4enhhrY1K0EtGKMcxujkJbT+YTmWHDiNKb4++tuQT330WLgeLWcuQ6GC1vCtUzXbdWrBGDFObEtGeMw52mHy5MnyNzyRqhPbWbNmoX///ujduzcqVaqEhQsXwtraGkuXLtW7fe3atWV1t0uXLrCysnqt+0FZWJrD0kpbtLYuaIWI0Cj5+MWLRMTHaX90m5qaIF9+S9VURewcC6BslaLYs+WcnD+84xKc3OzhVsIpw7YlK7nj/OHrskIrnN53DU071JaPQ26H47ZfiHyclKRBwIUguBRzhFrY21ujfDlX7Np9Wc4fPOSPws42cHe3z9XrNG1SCdeu3cPly3d1sYqKUkfl397OGuXLumLX3ity/sCR63B2skERt9zFqNE75XHkxA08ehwr5zdvPY+mDStCLRwL5Efloi7469w1Ob/zUgBc7W1QvJBdhm19qpXFvqs3ERGj/eO/7vhFtPIsLx/7hYTj7iPtd1R8QqKcd3e0hRowRjmMUZFU7eiy/nbkUzVdGzrxsg1ltU4NGCPGiW3JOI+55tUrYMuWLcq9F6sYkdgYJjLuxDY+Pl52Kfb2flkNNTU1lfPHjh17o+/9119/4cKJG/jt8DdYc/hreNYtg5XzdurWm1uYYcGmYVh3fBzcPZzw67xdUANnN3s8Dn8iu1+nCA95jMLuDhm2vXHpLuo2qyKTfjNzUzR4vwZcimZMXq3yW6J5l3o4vlObBKqBSGIfPoqRiWiKB2HRcCmcMRkRRMK76Kde+GlBT7RtU0O3vISHE+LjEzHl2474eWFvjB39nuy2q54YxSIxVYzCwp+gcGH9yVYRNwf8PK8nFs3pjnatPXXLXZxt8CBMm7AJoQ+i4OKsjoRNEH/kw5+kjdP9x0/gZp/xM7rZ2yDkcbRuPuRRtFyWnlNBa5kEH7h2C2rAGL1ijCIztiPZhiJTtaHHL9tQVuvUgDFinNiWjPOYc3ewlZcPEqn6GtuIiAgkJibCxcUlzXIx7+fn968m0M+fP9fNR0VFoVatWihRzgWd3x4vrzPt98V7GDKhLaaNXCW3SUgEBr4/Qya4Q8Z1QItOb2H9z3uhdImJ8fKMWUJinG6ZmE/UvEBC0stlwra1B+Hkbovpvw9B3PMXOHfIDzXeLZ9mOxGfMT/2xekDV3Bw6ykoWULCyzaSkBgvApNmmYxTYnyaZcK1a3fQ3neWvMbU2dkWM6d1xaNH0di3/wpMTDSoWdMDgwb/goiIJxjYvymGf9oM34xfD2OWJC52zUZigohREhJepI5Rklyeeplw1e8O2n04G7FP42RV9/vvPpIx2nvwKpKSEpGUmKB7TmJCHDTQZHgNQ0mM0/ZYeFVJ8fFAkgaJceni9CI+zTK5PDERmoQE3fLEeG0sUm9XwMoS/+vVBr/sPoaLger4oaDIGJkaIEaadDFKSkJifNoY6Y1P8vOyWqcGjBHjxLZknMdcUqL276hSK7YJeAFojGAfKHsaA7p3755oJpqjR4+mWf7FF19o6tSpk+3zPTw8NNu3b892u7lz58r3ST3Nnz9fM3bsWN18pUqVNHfv3s2wnZi8vLw0Fy9e1LtOCVP37t01586dk9OoUaM0UVFRGjMzM936+/fva0qXLp3t63Tu3Flz8OBB3by5ublmw4YNmsWLFxv8MxpTnMaMGaOZN2+efDxy5EjNihUr0rSz4OBgg39WY4rR559/rvnpp59061q2bKk5dOiQwT+rIeKUXSwKFiyoOXLkiOarr74y+GdkjP7beDk7O+eoHWXVhtR4rDFGjBPbknKOucDAQI2SPHv2TOPq6mrw77aUSeyL2CfKnIn4DwxEVFLF9bR//PEH2rVrp1ves2dPREZGYvPmzVk+v0SJEnJE5OxGRY6Li5NTCvHac+bMwZQpU+Q+CJaWljA3N5cXtovRIlOHRVzLK7pIP3umjmsjRcxfvHghJ/GZxeeLjdVe35giOjoaZcqUQWBgIGxsbGRMxPNEHBMStNcf58+fX8YpdTVcTbKLk4hRsWLFcO/ePRQsWFDv81LilvI80c7MzMzyXFsS18afOnUKtra2emMkRkoUzxPtSbQr0cbEurzWlkJCQmSPlcxiIV5HzKd8b6lJTttSgwYNEBAQIL+rGaOMMUppO4L4XkrdhnisaaV8LxcpUgSnT5+Wx1xeilFOjze2pexjxLaUs7YUExMj/xXHlp2d/ku6jJX4jWssf3PFb8h8+fIZejeMmkETW8HLy0ve2kfc4kcQI+8WL14cQ4YMwZgxY/6VxDY98ePI2dkZT548kY2E9MeobNmy8oe2SMQoI/HDWnxJi3/Fjx/K/Hj78ssvMXfuXLalbNqSuEwiJfkn/W1J/CjiMZf137eRI0di0aJF8oQs6SdOLoq/byVLlmSc2JZeC9tS9vi9RP8Vg//VE7f6+fnnn7FixQpcu3YNH3/8sTzTI0ZJFnr06IGxY8fqthdnTc6fPy8n8VhUy8TjGzduvNZ1t5SRuOVS+rNu9FJK5VptZ/Lf1L2q2Zayb0uUMzzmsvbLL7/oKiSUeRsSvZIYJ7al18W2lDP8XiLVDx4ldO7cGeHh4Rg3bhxCQ0Ph6emJ7du36waUCgoKSnM2VZxhrVHj5aiz33//vZwaNmyI/fv3G+QzEBERERERUR5ObAXR7VhM+qRPVkX349ftPS36/48fP/617oOrdowRY8S2xOPN2PB7iTFiW+LxZmz4vcQYkfEw+DW2RERERERERIq+xpaIiIiIiIjodTCxJSIiIiIiIkVjYktERERERESKZqrWW4uIQabETYzFfXJPnjyZ6bZXrlxBhw4d5PbiRttz5sxBXpGbOG3YsAG1atWCvb29vN+mGL36119/hdrlJkbLly+XbSj1lFdupJ2bODVq1ChDnMTUunVrqFluYiRuHzFp0iSULl1abl+9enU5WryaHTx4EO+//z7c3d1le9i0aVOW29+/fx8fffQRypUrJ0fOz+39zPNKnA4fPoy3334bhQoVkvfbrlChAmbPng01y22MxCCV+r6TxJ0a1Cy3cerVq5feOFWuXBlqldsYpXzXV6xYUR5v5cuXx8qVK6FmU6dORe3atWFjY4PChQujXbt28Pf3z/I5efm3N71Zqkts161bJ++NK0Y9Pnv2rPxB2Lx5c3lPVn2ePn2KUqVKYdq0aXB1dUVekds4OTo64quvvsKxY8dw8eJFeZ9hMe3YsQNqldsYCba2tvIHd8p0584dqF1u4yROkqSO0eXLl2FmZgZfX1+oVW5j9PXXX2PRokWYP38+rl69ikGDBuGDDz7AuXPnoFbiPsciLuJHYU7ExcXB2dlZxko8L6/IbZzEiUhx1wHxA13cK17ES0yLFy+GWuU2RinEj/HU303iR7qa5TZOc+fOTROf4OBg+dtAzd/duY3RTz/9hLFjx2LChAkyeZs4cSI++eQT/PXXX1CrAwcOyM94/Phx7Nq1S56Y9fHxyfLe9Xn1tzf9BzQqU6dOHc0nn3yim09MTNS4u7trpk6dmu1zPTw8NLNnz9bkBa8TpxQ1atTQfP311xq1ym2Mli1bprGzs9PkNa/blsQxZ2Njo4mJidGoVW5j5Obmpvnf//6XZln79u01Xbt21eQF4k/Txo0bc7x9w4YNNcOGDdPkNbmNU4oPPvhA061bN01ekJMY7du3T273+PFjTV71Km1JbG9iYqK5ffu2Ji/ISYzq1aun+fzzz9MsGzFihObtt9/W5BVhYWEyVgcOHMjR9nnptze9eaqq2MbHx+PMmTPw9vbWLRNd1MS8qDTSvxMn8f2+Z88eeXa7QYMGqgzrq8YoJiYGHh4eKFasGNq2bSvP2KrZv3HMLVmyBF26dJGVJTV6lRiJamT6buyiW5voVkr0OkTV/+jRo2jYsCEDmY64xMbNzQ3NmjXDkSNHGJ8cfHeL7zHxN4+y/u4Wl56ISmZeEBUVJf8V1Xyi/5qqEtuIiAgkJibCxcUlzXIxr/ZrZf6LOIkvq4IFC8LS0lJeDym6SYofAGr0KjES19IsXboUmzdvxqpVq5CUlIT69evj7t27UKvXPebEH3vRFblfv35Qq1eJkeimPGvWLAQEBMh2JLp3pXThJnoVRYsWhZWVlRwrQXQbVPMxl1simV24cCH+/PNPOYkTk2IsAHHZAOkXEhKCbdu2sR3p+e7+5Zdf5MlMUQQ4ffq0nBdJrfhboHbi75UY70Bc11+lShVD7w7lQeaG3gFSDjEwwPnz52VVUlRsxTWD4hoJ8QOAgHr16skphUhqxQAS4lrJyZMnM0SZnPGvWrUq6tSpw/iku5atf//+cqAfMbCGGERKXNMuTpwQvYpDhw7J725xHdyYMWNQpkwZfPjhhwxm8klJMaX+7g4MDJSDbOWFQRJfxYoVK+RgkmKgIHrpm2++kScs69atKxNbcQKzZ8+emDFjhuypo3bipJk4Wc3eRWQoqjrKnJyc5CA0Dx48SLNczPPi9NePk/hSFj+GRHetkSNHomPHjnI0PDX6N9qShYUFatSogRs3bkCtXidOYmCJtWvXom/fvlCzV4mRGBRJjL4pYiQGIPPz85O9JcSJJKJXUbJkSXkSSZww+eyzz+TgNpQ5cbJNzd/dr0MkbOIkW/fu3WUPLkrb7VjERgyOdPv2bQQFBcmRf0VhQHyvq5kYpO7vv//Gvn37ZA8RIkNQVWIrvmDfeustWU1M3S1CzKeupOV1/1acxHPE9SRq9G/ESHQ/vXTpkuzmplavE6fff/9dtp9u3bpBzV4nRuJarSJFiiAhIUF2kRTXbRO9LjV/d/9bRO8kNX93v+4ouCLpV/tJydchTmyL5E6c1BQncN977z3VVmzFiQ6R1G7cuBF79+6VJ9GIDEV1XZFF91jR7UNcRyTOuIp7Y4mqh+jGJ/To0UP+UEypNIqBXcTtNFIe37t3T/5BE9URUZ1Uq9zGSfwrthVdIsUPoq1bt8ouWmJoe7XKbYzEfUdF9yPRbiIjIzFz5kxZbVP7tWy5jVPqbsiiG5u4v6ba5TZGJ06ckN9FoneE+FdU10QyMmrUKKiV6CabukJ269Yt+V0sBiApXry4vIWGiEXqe0KK9SnPDQ8Pl/PiREKlSpWgVrmNk7hNiVguurUL4rY/33//PT799FOoVW5jJI5H8WNc3I/1+fPn8ppI8QN9586dULNXOeZSvrvFvbjzwjWUuY3R9evX5dgRIj6PHz+WYyWIrrmi67aaux+vWbNGji8iKtMpY0fY2dnJCrbA3970n1Hj0NPz58/XFC9eXGNpaSlvs3H8+PE0t4Xo2bOnbv7WrVtyWPL0k9hO7XITp6+++kpTpkwZTb58+TQODg5ySPu1a9dq1C43MRo+fLhuWxcXF02rVq00Z8+e1eQFuYmT4OfnJ4+znTt3avKK3MRo//79mooVK2qsrKw0hQoV0nTv3l1z7949jZql3HIl/ZQSF/Fv+u9lfduLW0eoWW7jNG/ePE3lypU11tbWGltbW3mbth9//FHeckqtchuj6dOna0qXLi3/vjk6OmoaNWqk2bt3r0btXuWYi4yM1OTPn1+zePFiTV6Q2xhdvXpV4+npKWMkjre2bdvKv3dqpi8+YhK3QEzB3970XzER//nv0mgiIiIiIiKif5c6O/wTERERERFRnsHEloiIiIiIiBSNiS0REREREREpGhNbIiIiIiIiUjQmtkRERERERKRoTGyJiIiIiIhI0ZjYEhERERERkaIxsSUiIiIiIiJFY2JLRKQgGo0GAwYMgKOjI0xMTGBvb4/hw4cjL+vVqxfatWv3n79vo0aNXjv2EyZMgKenp1F+PiIiIiVhYktEpCDbt2/H8uXL8ffff+P+/fuoUqWKoXfpP0u8bt++LZP58+fPv/H3IiIiImUxN/QOEBFRzgUGBsLNzQ3169eX8+bmyvkaf/HiBSwsLGAM4uPjYWlpaejdICIion8JK7ZERAohKqNDhw5FUFCQrFyWKFFCLk9ISMCQIUNgZ2cHJycnfPPNN7LLck7ExcXh888/R5EiRVCgQAF4eXlh//79uvWiOiy6O+/YsQMVK1ZEwYIF0aJFC1ktTulKu2LFCmzevFnuk5jE81Oqq+vWrUPDhg2RL18+LF68GLa2tvjjjz/S7MOmTZvkez958iTLfS1ZsqT8t0aNGvK1RVfg1L7//nuZ9BcqVAiffPKJTKRTiFhNnjwZPXr0kPsgunMLhw8fxrvvvov8+fOjWLFi+PTTTxEbG6t73o8//oiyZcvK/XdxcUHHjh3TvGdSUhJGjRolu4a7urrKeKQm/l+1bdtWxk28b6dOnfDgwYNMP2NiYiJGjBghYy4+h3jtnP6/JCIiysuY2BIRKcTcuXMxadIkFC1aVCaWp06dkstFYikqtydPnpTbzJo1C7/88kuOXlMkxMeOHcPatWtx8eJF+Pr6ysQ1ICBAt83Tp09l0vjrr7/i4MGDMlkTybAg/hXJWkqyK6aUarIwZswYDBs2DNeuXUP79u3RpUsXLFu2LM0+iHmRMNrY2GS5r+LzCbt375bvs2HDBt26ffv2yWq2+FfEQyTkYkpNfIbq1avj3LlzMvkX24v97tChg/zsIgkXia6IiXD69GmZ6IqY+/v7y27gDRo0SPOa4r1EUn7ixAnMmDFDbrtr1y5d0iuS2kePHuHAgQNy+c2bN9G5c+dMP+MPP/wg93vp0qVyX8RzN27cmGVciIiISDsQCRERKcTs2bM1Hh4euvmGDRtqKlasqElKStItGz16tFyWnTt37mjMzMw09+7dS7O8adOmmrFjx8rHy5YtE+VCzY0bN3TrFyxYoHFxcdHN9+zZU9O2bds0r3Hr1i35vDlz5qRZfuLECfmeISEhcv7Bgwcac3Nzzf79+7Pd35TXPHfuXJrl4v1FTBISEnTLfH19NZ07d9bNi/Xt2rVL87y+fftqBgwYkGbZoUOHNKampppnz55p/vzzT42tra0mOjpa7/6I2L/zzjtpltWuXVvGX9i5c6f8rEFBQbr1V65ckZ/h5MmTcn78+PGa6tWr69a7ublpZsyYoZt/8eKFpmjRohniS0RERGmxYktEpHB169aVXXNT1KtXT1ZcRbfWrFy6dEluU65cOdlVNmUS1UVRzUxhbW2N0qVL6+ZFd9+wsLAc7VutWrXSzNepUweVK1eWlU5h1apV8PDwyFAJzS3xmmZmZlnuY/p9uXDhgqyOpv7szZs3l5XWW7duoVmzZnLfSpUqhe7du2P16tWyep1atWrV0synfl9RpRbdm8WUolKlSrKbsViXXlRUlKxEi+7gKUQlPv1+ExERUUbKGXWEiIj+VTExMTIZPHPmTJqkUBBJXor0Az6JJDqn132Kbrrp9evXDwsWLJDdlEU35N69e6dJzF+Fvn0UCWpW+yI+/8CBA2V34/SKFy8uB5c6e/asvGZ4586dGDdunLyGVnQBF8lpTt+XiIiI3jxWbImIFE5c35na8ePH5YBH6ZPV9MQgTKJiKyqMZcqUSTOJgZBySiSA2VWHU+vWrRvu3LmDefPm4erVq+jZs2eO30fIzXtlpWbNmvL90392MaW8l6iYent7y+tnxXW4YlCsvXv35uj1xWBbwcHBckoh3i8yMlJWbtMTg3+Jim/q/59iYDBx4oGIiIiyxsSWiEjhxGBOYiRdMcDRb7/9hvnz58sBm7IjuiB37dpVjhQsBmIS3W/FAE1Tp07FP//8k+P3FyMOi6RPvH9ERESa0Yj1cXBwkANJffHFF/Dx8ZGDYeVE4cKF5ejFYhAnMbKw6Lr7OkaPHo2jR4/KwaLEvXFF920xunPK4FHiXsEi+RbrRCK+cuVKWY0tX758jl5fJMRVq1aVMRaVXxFbEWsxSnRm3YvF/7dp06bJkaL9/PwwePBgmQgTERFR1pjYEhEpnEiWnj17Jq9fFbe5EclRyu1ssiO6Aovnjxw5UiZs7dq1k11tRVfcnOrfv798rkjWnJ2dceTIkWyf07dvX3kv2T59+uT4fUT1VCSaixYtgru7uxxx+HWI62PF9cTXr1+Xt/wRFWzR3Vi8tiC6G4uEv0mTJrL6unDhQnniQFzPmxOiW7JIlEUiL64hFomuuF5XjL6cGfH/QVzPK6rY4lppMVL0Bx988Fqfk4iIKC8wESNIGXoniIgobxG3Dvrss88QEhKi6/ZLRERE9Ko4eBQREf1nxKjCYuRf0d1WDNzEpJaIiIj+DeyKTESkUocOHUpzK5v0kyGIQZgqVKggB6caO3ZsmnVTpkzJdF9btmxpkP0lIiIiZWBXZCIilRLX3d67dy/T9WL0X2Py6NEjOekjBo0qUqTIf75PREREpAxMbImIiIiIiEjR2BWZiIiIiIiIFI2JLRERERERESkaE1siIiIiIiJSNCa2REREREREpGhMbImIiIiIiEjRmNgSERERERGRojGxJSIiIiIiIkVjYktERERERERQsv8D+Uq0J8RstF0AAAAASUVORK5CYII="
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    }
   ],
   "execution_count": 5
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "quant",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}