diff --git a/hydradx/notebooks/Stableswap/RebasingToken1swap.ipynb b/hydradx/notebooks/Stableswap/RebasingToken1swap.ipynb new file mode 100644 index 00000000..dafc17ca --- /dev/null +++ b/hydradx/notebooks/Stableswap/RebasingToken1swap.ipynb @@ -0,0 +1,741 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "905a9383-c5e9-4405-b840-bb1a9d0671e0", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "from datetime import datetime\n", + "import math\n", + "import sys\n", + "from pprint import pprint\n", + "from datetime import datetime\n", + "\n", + "sys.path.append('../..')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "c98a3bf2-45c0-4a56-9507-59cc80dd3367", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "price target: 1.0\n", + "final price: 1.0 at 1 to 1\n", + "price target: 1.0000050492555923\n", + "final price: 1.0000050492555923 at 1.00506703261226 to 1\n", + "price target: 1.0000100985366798\n", + "final price: 1.0000100985366798 at 1.0101594147029118 to 1\n", + "price target: 1.0000151478432624\n", + "final price: 1.0000151478432624 at 1.015276944611287 to 1\n", + "price target: 1.00002019717534\n", + "final price: 1.00002019717534 at 1.020419415026936 to 1\n", + "price target: 1.0000252465329131\n", + "final price: 1.0000252465329131 at 1.025586613100586 to 1\n", + "price target: 1.0000302959159817\n", + "final price: 1.0000302959159817 at 1.0307783205607848 to 1\n", + "price target: 1.000035345324546\n", + "final price: 1.000035345324546 at 1.0359943138362269 to 1\n", + "price target: 1.000040394758606\n", + "final price: 1.000040394758606 at 1.041234364182401 to 1\n", + "price target: 1.0000454442181619\n", + "final price: 1.0000454442181619 at 1.0464982378134664 to 1\n", + "price target: 1.0000504937032137\n", + "final price: 1.0000504937032137 at 1.0517856960366316 to 1\n", + "price target: 1.0000555432137617\n", + "final price: 1.0000555432137617 at 1.0570964953928979 to 1\n", + "price target: 1.000060592749806\n", + "final price: 1.000060592749806 at 1.062430387800191 to 1\n", + "price target: 1.0000656423113468\n", + "final price: 1.0000656423113468 at 1.0677871207002454 to 1\n", + "price target: 1.000070691898384\n", + "final price: 1.000070691898384 at 1.0731664372095793 to 1\n", + "price target: 1.0000757415109178\n", + "final price: 1.0000757415109178 at 1.0785680762736547 to 1\n", + "price target: 1.0000807911489484\n", + "final price: 1.0000807911489484 at 1.0839917728211503 to 1\n", + "price target: 1.000085840812476\n", + "final price: 1.000085840812476 at 1.0894372579276705 to 1\n", + "price target: 1.0000908905015007\n", + "final price: 1.0000908905015007 at 1.0949042589716278 to 1\n", + "price target: 1.0000959402160223\n", + "final price: 1.0000959402160223 at 1.1003924998033376 to 1\n", + "price target: 1.0001009899560416\n", + "final price: 1.0001009899560416 at 1.1059017009072427 to 1\n", + "price target: 1.000106039721558\n", + "final price: 1.000106039721558 at 1.1114315795703327 to 1\n", + "price target: 1.000111089512572\n", + "final price: 1.000111089512572 at 1.1169818500507311 to 1\n", + "price target: 1.0001161393290838\n", + "final price: 1.0001161393290838 at 1.1225522237464496 to 1\n", + "price target: 1.0001211891710935\n", + "final price: 1.0001211891710935 at 1.1281424093674808 to 1\n", + "price target: 1.000126239038601\n", + "final price: 1.000126239038601 at 1.1337521131054267 to 1\n", + "price target: 1.0001312889316065\n", + "final price: 1.0001312889316065 at 1.1393810388049381 to 1\n", + "price target: 1.0001363388501103\n", + "final price: 1.0001363388501103 at 1.1450288881356094 to 1\n", + "price target: 1.0001413887941124\n", + "final price: 1.0001413887941124 at 1.1506953607631907 to 1\n", + "price target: 1.000146438763613\n", + "final price: 1.000146438763613 at 1.1563801545196633 to 1\n", + "price target: 1.000151488758612\n", + "final price: 1.000151488758612 at 1.1620829655741112 to 1\n", + "price target: 1.00015653877911\n", + "final price: 1.00015653877911 at 1.1678034886014323 to 1\n", + "price target: 1.0001615888251068\n", + "final price: 1.0001615888251068 at 1.1735414169507088 to 1\n", + "price target: 1.0001666388966024\n", + "final price: 1.0001666388966024 at 1.1792964428118715 to 1\n", + "price target: 1.0001716889935972\n", + "final price: 1.0001716889935972 at 1.1850682573804328 to 1\n", + "price target: 1.0001767391160912\n", + "final price: 1.0001767391160912 at 1.1908565510227298 to 1\n", + "price target: 1.0001817892640845\n", + "final price: 1.0001817892640845 at 1.1966610134347455 to 1\n", + "price target: 1.0001868394375775\n", + "final price: 1.0001868394375775 at 1.202481333804453 to 1\n", + "price target: 1.0001918896365698\n", + "final price: 1.0001918896365698 at 1.2083172009657481 to 1\n", + "price target: 1.0001969398610622\n", + "final price: 1.0001969398610622 at 1.214168303558008 to 1\n", + "price target: 1.0002019901110542\n", + "final price: 1.0002019901110542 at 1.220034330171469 to 1\n", + "price target: 1.0002070403865464\n", + "final price: 1.0002070403865464 at 1.225914969502977 to 1\n", + "price target: 1.0002120906875385\n", + "final price: 1.0002120906875385 at 1.2318099104984945 to 1\n", + "price target: 1.000217141014031\n", + "final price: 1.000217141014031 at 1.2377188424979373 to 1\n", + "price target: 1.0002221913660239\n", + "final price: 1.0002221913660239 at 1.2436414553750943 to 1\n", + "price target: 1.0002272417435174\n", + "final price: 1.0002272417435174 at 1.249577439674848 to 1\n", + "price target: 1.0002322921465114\n", + "final price: 1.0002322921465114 at 1.2555264867463016 to 1\n", + "price target: 1.0002373425750062\n", + "final price: 1.0002373425750062 at 1.2614882888737462 to 1\n", + "price target: 1.0002423930290019\n", + "final price: 1.0002423930290019 at 1.2674625394023984 to 1\n", + "price target: 1.0002474435084987\n", + "final price: 1.0002474435084987 at 1.2734489328626601 to 1\n", + "price target: 1.0002524940134967\n", + "final price: 1.0002524940134967 at 1.2794471650881256 to 1\n", + "price target: 1.0002575445439958\n", + "final price: 1.0002575445439958 at 1.2854569333308596 to 1\n", + "price target: 1.0002625950999966\n", + "final price: 1.0002625950999966 at 1.2914779363769036 to 1\n", + "price target: 1.0002676456814987\n", + "final price: 1.0002676456814987 at 1.2975098746485934 to 1\n", + "price target: 1.0002726962885025\n", + "final price: 1.0002726962885025 at 1.3035524503135854 to 1\n", + "price target: 1.0002777469210082\n", + "final price: 1.0002777469210082 at 1.30960536738365 to 1\n", + "price target: 1.0002827975790158\n", + "final price: 1.0002827975790158 at 1.3156683318101692 to 1\n", + "price target: 1.0002878482625255\n", + "final price: 1.0002878482625255 at 1.321741051577586 to 1\n", + "price target: 1.0002928989715374\n", + "final price: 1.0002928989715374 at 1.3278232367928204 to 1\n", + "price target: 1.0002979497060516\n", + "final price: 1.0002979497060516 at 1.3339145997687147 to 1\n", + "price target: 1.0003030004660682\n", + "final price: 1.0003030004660682 at 1.340014855106002 to 1\n", + "price target: 1.0003080512515874\n", + "final price: 1.0003080512515874 at 1.3461237197698175 to 1\n", + "price target: 1.0003131020626093\n", + "final price: 1.0003131020626093 at 1.3522409131639925 to 1\n", + "price target: 1.000318152899134\n", + "final price: 1.000318152899134 at 1.3583661571994945 to 1\n", + "price target: 1.0003232037611618\n", + "final price: 1.0003232037611618 at 1.3644991763615018 to 1\n", + "price target: 1.0003282546486925\n", + "final price: 1.0003282546486925 at 1.370639697769942 to 1\n", + "price target: 1.0003333055617265\n", + "final price: 1.0003333055617265 at 1.3767874512393767 to 1\n", + "price target: 1.000338356500264\n", + "final price: 1.000338356500264 at 1.382942169333571 to 1\n", + "price target: 1.0003434074643047\n", + "final price: 1.0003434074643047 at 1.3891035874155726 to 1\n", + "price target: 1.0003484584538493\n", + "final price: 1.0003484584538493 at 1.3952714436989275 to 1\n", + "price target: 1.0003535094688976\n", + "final price: 1.0003535094688976 at 1.4014454792866466 to 1\n", + "price target: 1.0003585605094496\n", + "final price: 1.0003585605094496 at 1.4076254382187265 to 1\n", + "price target: 1.0003636115755057\n", + "final price: 1.0003636115755057 at 1.4138110675042093 to 1\n", + "price target: 1.0003686626670658\n", + "final price: 1.0003686626670658 at 1.420002117159381 to 1\n", + "price target: 1.0003737137841302\n", + "final price: 1.0003737137841302 at 1.4261983402381837 to 1\n", + "price target: 1.000378764926699\n", + "final price: 1.000378764926699 at 1.432399492860636 to 1\n", + "price target: 1.0003838160947724\n", + "final price: 1.0003838160947724 at 1.4386053342370495 to 1\n", + "price target: 1.0003888672883503\n", + "final price: 1.0003888672883503 at 1.4448156266928116 to 1\n", + "price target: 1.000393918507433\n", + "final price: 1.000393918507433 at 1.4510301356865192 to 1\n", + "price target: 1.0003989697520208\n", + "final price: 1.0003989697520208 at 1.457248629826804 to 1\n", + "price target: 1.0004040210221135\n", + "final price: 1.0004040210221135 at 1.4634708808873391 to 1\n", + "price target: 1.0004090723177113\n", + "final price: 1.0004090723177113 at 1.4696966638184357 to 1\n", + "price target: 1.0004141236388142\n", + "final price: 1.0004141236388142 at 1.4759257567552275 to 1\n", + "price target: 1.0004191749854228\n", + "final price: 1.0004191749854228 at 1.4821579410254024 to 1\n", + "price target: 1.000424226357537\n", + "final price: 1.000424226357537 at 1.4883930011544315 to 1\n", + "price target: 1.0004292777551567\n", + "final price: 1.0004292777551567 at 1.4946307248646598 to 1\n", + "price target: 1.000434329178282\n", + "final price: 1.000434329178282 at 1.500870903079342 to 1\n", + "price target: 1.0004393806269136\n", + "final price: 1.0004393806269136 at 1.507113329918095 to 1\n", + "price target: 1.000444432101051\n", + "final price: 1.000444432101051 at 1.5133578026922372 to 1\n", + "price target: 1.0004494836006947\n", + "final price: 1.0004494836006947 at 1.5196041219013772 to 1\n", + "price target: 1.0004545351258447\n", + "final price: 1.0004545351258447 at 1.5258520912233529 to 1\n", + "price target: 1.0004595866765011\n", + "final price: 1.0004595866765011 at 1.5321015175051365 to 1\n", + "price target: 1.000464638252664\n", + "final price: 1.000464638252664 at 1.53835221075283 to 1\n", + "price target: 1.000469689854334\n", + "final price: 1.000469689854334 at 1.5446039841168862 to 1\n", + "price target: 1.0004747414815103\n", + "final price: 1.0004747414815103 at 1.5508566538789204 to 1\n", + "price target: 1.0004797931341938\n", + "final price: 1.0004797931341938 at 1.5571100394351127 to 1\n", + "price target: 1.0004848448123844\n", + "final price: 1.0004848448123844 at 1.5633639632801781 to 1\n", + "price target: 1.0004898965160822\n", + "final price: 1.0004898965160822 at 1.56961825098713 to 1\n", + "price target: 1.0004949482452874\n", + "final price: 1.0004949482452874 at 1.575872731188408 to 1\n", + "price target: 1.0005\n", + "final price: 1.0005 at 1.5821272355547045 to 1\n" + ] + } + ], + "source": [ + "# from model.amm.omnipool_amm import OmnipoolState, DynamicFee\n", + "from model.amm.agents import Agent\n", + "from model.amm.trade_strategies import general_arbitrage, invest_all\n", + "from model.amm.global_state import GlobalState\n", + "from model.amm.stableswap_amm import StableSwapPoolState\n", + "from model.amm.exchange import Exchange\n", + "from model import run\n", + "import model.plot_utils as pu\n", + "\n", + "class CEXDummy(Exchange):\n", + " def __init__(self, tokens: dict[str: float], unique_id='dummy exchange'):\n", + " super().__init__()\n", + " self.prices = tokens\n", + " self.liquidity = {tkn: 0 for tkn in tokens}\n", + " self.asset_list = list(tokens.keys())\n", + " self.unique_id = unique_id\n", + "\n", + " def price(self, tkn: str, denomination: str = ''):\n", + " if denomination and denomination not in self.prices:\n", + " raise ValueError(f'Denomination {denomination} not in exchange')\n", + " return self.prices[tkn] / (self.prices[denomination] if denomination in self.prices else 1)\n", + "\n", + " def buy_spot(self, tkn_buy, tkn_sell, fee=0):\n", + " return self.price(tkn_buy) / self.price(tkn_sell)\n", + "\n", + " def sell_spot(self, tkn_sell, tkn_buy, fee=0):\n", + " return self.price(tkn_sell) / self.price(tkn_buy)\n", + "\n", + " def buy_limit(self, tkn_buy, tkn_sell):\n", + " return float('inf')\n", + "\n", + " def sell_limit(self, tkn_buy, tkn_sell):\n", + " return float('inf')\n", + " \n", + " def swap(\n", + " self,\n", + " agent: Agent,\n", + " tkn_buy: str,\n", + " tkn_sell: str,\n", + " buy_quantity: float = 0,\n", + " sell_quantity: float = 0\n", + " ):\n", + " if buy_quantity:\n", + " sell_quantity = self.calculate_sell_from_buy(tkn_buy, tkn_sell, buy_quantity)\n", + " elif sell_quantity:\n", + " buy_quantity = self.calculate_buy_from_sell(tkn_buy, tkn_sell, sell_quantity)\n", + "\n", + " if tkn_buy not in agent.holdings:\n", + " agent.holdings[tkn_buy] = 0\n", + "\n", + " agent.holdings[tkn_sell] -= sell_quantity\n", + " agent.holdings[tkn_buy] += buy_quantity\n", + " self.liquidity[tkn_sell] += sell_quantity\n", + " self.liquidity[tkn_buy] -= buy_quantity\n", + "\n", + " def calculate_buy_from_sell(self, tkn_buy, tkn_sell, sell_quantity):\n", + " return sell_quantity * self.price(tkn_sell) / self.price(tkn_buy)\n", + "\n", + " def calculate_sell_from_buy(self, tkn_sell, tkn_buy, buy_quantity):\n", + " return buy_quantity * self.price(tkn_buy) / self.price(tkn_sell)\n", + "\n", + "rebase_amount = 1000 \n", + "def rebase(tkn: str, amount: float):\n", + " def evolve(state: GlobalState):\n", + " tkn_holders = {\n", + " pool: pool.liquidity[tkn]\n", + " for pool in state.pools.values()\n", + " }\n", + " tkn_holders.update({\n", + " agent: agent.holdings[tkn]\n", + " for agent in state.agents.values()\n", + " })\n", + " total_supply = sum(tkn_holders.values())\n", + " awards = 0\n", + " for holder in tkn_holders:\n", + " if isinstance(holder, Agent):\n", + " awards += rebase_amount * holder.holdings[tkn] / total_supply\n", + " holder.holdings[tkn] += rebase_amount * holder.holdings[tkn] / total_supply\n", + " elif isinstance(holder, Exchange):\n", + " awards += rebase_amount * holder.liquidity[tkn] / total_supply\n", + " holder.liquidity[tkn] += rebase_amount * holder.liquidity[tkn] / total_supply\n", + " # if (state.time_step % 100 == 0):\n", + " # print(total_supply)\n", + " # print(awards)\n", + " return state\n", + " return evolve\n", + "\n", + "def geometric_progression(min_val, max_val, steps):\n", + " return [min_val * (max_val/min_val) ** (i/(steps-1)) for i in range(steps)]\n", + "\n", + "binance = CEXDummy({'S1': 1, 'S2': 1}, 'binance')\n", + "\n", + "stableswap = StableSwapPoolState(\n", + " tokens={'S1': 1000000, 'S2': 1000000},\n", + " amplification=10,\n", + " trade_fee=0,\n", + " unique_id='stableswap'\n", + ")\n", + "\n", + "# arbitrageur = Agent(\n", + "# holdings={'S1': 1000000, 'S2': 1000000},\n", + "# trade_strategy=general_arbitrage([stableswap, binance], config=[{'exchanges': {'stableswap': ('S1', 'S2'), 'binance': ('S1', 'S2')}, 'buffer': 0}])\n", + "# )\n", + "\n", + "agent = Agent(\n", + " holdings={'S1': 1000}\n", + ")\n", + "\n", + "initial_state = GlobalState(\n", + " pools={'stableswap': stableswap, 'binance': binance},\n", + " agents={'arbitrageur': arbitrageur},\n", + " external_market={'S1': 1, 'S2': 1},\n", + " # evolve_function=rebase('S1')\n", + ")\n", + "\n", + "params = {\n", + " 'amplification': (10, 10000),\n", + " 'asset_imbalance': (1, 1.0005),\n", + " 'rebase_amount': (1000, 1000000)\n", + "}\n", + "\n", + "steps = 100\n", + "asset_balance = 1\n", + "\n", + "for amp in geometric_progression(params.amplification[0], params.amplification[1], steps):\n", + " for initial_price in geometric_progression(params['asset_imbalance'][0], params['asset_imbalance'][1], steps):\n", + " stableswap.amplification = 1000\n", + " current_price = stableswap.price_at_balance([stableswap.liquidity['S2'] * asset_balance, stableswap.liquidity['S2']])\n", + " iters = 0\n", + " # print(f'price target: {initial_price}')\n", + " # adjust the liquidity balance to reach the desired starting price\n", + " while abs(current_price - initial_price) > 1e-20 and iters < 1000:\n", + " iters += 1\n", + " if current_price > initial_price:\n", + " asset_balance -= 1 / 2 ** iters\n", + " elif current_price < initial_price:\n", + " asset_balance += 1 / 2 ** iters\n", + " current_price = stableswap.price_at_balance([stableswap.liquidity['S2'] * asset_balance, stableswap.liquidity['S2']])\n", + " # print(f'final price: {current_price} at {asset_balance} to 1')\n", + " # find the minimum rebase amount which makes an attack profitable\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "f494e56a-6379-446f-b570-07e80791b65c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting simulation...\n", + "Execution time: 4.454 seconds.\n" + ] + } + ], + "source": [ + "events = run.run(initial_state, time_steps=2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "fbb48ae7-cc78-4709-90ca-a7921c37fa5d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pu.plot(events, pool='stableswap', prop='liquidity')\n", + "pu.plot(events, agent='arbitrageur', prop='holdings', key=['S1', 'S2'])" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "1113f935-a9a3-4382-992b-fff4c9010c22", + "metadata": {}, + "outputs": [], + "source": [ + "impermanent_loss = [\n", + " (1 - event.pools['stableswap'].cash_out(event.agents['LP'], event.external_market)\n", + " / sum(event.agents['non_LP'].holdings.values())) * 100\n", + " for event in events\n", + "]\n", + "total_supply = [\n", + " sum([\n", + " event.pools['stableswap'].liquidity['S1'], \n", + " event.agents['arbitrageur'].holdings['S1'], \n", + " event.agents['LP'].holdings['S1'], \n", + " event.agents['non_LP'].holdings['S1']\n", + " ]) for event in events\n", + "]\n", + "impermanent_loss_2 = [\n", + " (1 - event.pools['stableswap'].calculate_remove_liquidity(\n", + " event.agents['LP'], event.agents['LP'].holdings['stableswap'], 'S1'\n", + " ) / sum(event.agents['non_LP'].holdings.values())) * 100\n", + " for event in events\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "9d37c620-8a15-4f11-9d66-c5168f0eb285", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 5))\n", + "plt.plot(total_supply, impermanent_loss)\n", + "plt.plot(total_supply, impermanent_loss_2)\n", + "plt.title" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "c7525090-9bcb-4818-aa3c-dd1a78616b55", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 5))\n", + "plt.plot(total_supply, [event.pools['stableswap'].cash_out(event.agents['LP'], event.external_market) for event in events])\n", + "plt.plot(total_supply, [sum(event.agents['non_LP'].holdings.values()) for event in events])" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "389a8dd3-ebe3-49c9-9370-a27982b4f901", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1999.0009990010549" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "events[-1].agents['non_LP'].holdings['S1']" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "daf269aa-d32e-43a1-b689-d332e0f0e598", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJQAAAEvCAYAAAATn5tUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAD7zElEQVR4nOz9ebhsyVneib6R8947c+8z7HNOFYjp6Yv7utoWgpbBT1/zMLhxC7DNRXCNsMHGblrdNvjafS0ZMDaNZQsQjQHbTBajGIUQkwCheSghlYRKU6lKJZWqSqq56sxnz0Nmxv0jVqz4IuKLlblPHXRyV72/56nnVMZaMa6VuXO9+X5fGGstCCGEEEIIIYQQQgiZl9bNHgAhhBBCCCGEEEIIOV5QUCKEEEIIIYQQQgghR4KCEiGEEEIIIYQQQgg5EhSUCCGEEEIIIYQQQsiRoKBECCGEEEIIIYQQQo4EBSVCCCGEEEIIIYQQciQ6N3sAN4L19XX7+Z//+Td7GIQQQgghhBBCCCHPGD7wgQ9ctNae0Y49IwSlz//8z8edd955s4dBCCGEEEIIIYQQ8ozBGPNQ6RhD3gghhBBCCCGEEELIkaCgRAghhBBCCCGEEEKOBAUlQgghhBBCCCGEEHIkKCgRQgghhBBCCCGEkCNBQYkQQgghhBBCCCGEHAkKSoQQQgghhBBCCCHkSFBQIoQQQgghhBBCCCFHgoISIYQQQgghhBBCCDkSFJQIIYQQQgghhBBCyJGgoLRA/OlHn8Dt91242cMghBBCCCGEEEIIaYSC0gLxn9/6Sfz6ex+62cMghBBCCCGEEEIIaYSC0gIxGnSwtT++2cMghBBCCCGEEEIIaYSC0gIx7FNQIoQQQgghhBBCyOJDQWmBGA662NyjoEQIIYQQQgghhJDFhoLSAjEadCgoEUIIIYQQQgghZOGhoLRAjPodbO0f3uxhEEIIIYQQQgghhDRCQWmBGPY72Duc4nAyvdlDIYQQQgghhBBCCClCQWmBGA46AIAthr0RQgghhBBCCCFkgaGgtECMBl0A4E5vhBBCCCGEEEIIWWjmEpSMMS8wxnzCGHO/MeZ7leOfZ4x5qzHmLmPMO4wxzxHHXmGMubv671tE+VcbYz5Ylb/KGNOpyteMMX9kjPmIMeYeY8w/vhETPQ4M+86hxMTchBBCCCGEEEIIWWRmCkrGmDaAnwbwtQBuA/CtxpjbktN+DMCvWmufC+BlAH64qvv1AL4EwPMAfBmAlxhjVo0xLQCvAvAia+1fAfAQgH9UtfVdAD5mrf0iAF8J4D8ZY3pPZ5LHhdHAC0pMzE0IIYQQQgghhJDFZR6H0pcCuN9a+6C19gDAqwF8Q3LObQDeVv3/28Xx2wDcbq0dW2u3AdwF4AUATgM4sNbeV533ZgDfVP2/BTAyxhgAQwCXATwrLDveocSQN0IIIYQQQgghhCwy8whKnw3gEfH60apM8hEAL6z+/xvhBKHTVfkLjDHLxph1AF8F4HMAXATQMcY8v6rzzVU5APwUgL8M4HEAHwXwL6y1z4ptz7xDiYISIYQQQgghhBBCFpkblZT7JQC+whjzIQBfAeAxABNr7ZsAvB7AewD8FoA7qnIL4EUAfsIY8+cANgFMqrb+FwAfBvBZcKFyP2WMWU07NMa82BhzpzHmzgsXLtygadxchgPmUCKEEEIIIYQQQsjiM4+g9BiCewgAnlOV1VhrH7fWvtBa+8UAvr8qu1r9+3Jr7fOstV8DwAC4ryq/w1r75dbaLwVwuy8H8I8B/J513A/gUwD+n+mgrLWvtNY+31r7/DNnzsw/4wVm1He7vFFQIoQQQgghhBBCyCIzj6D0fgBfaIz5gio59osAvE6eYIxZrxJtA8D3Afilqrxdhb7BGPNcAM8F8Kbq9dnq3z6A7wHwc1X9hwH8zerYOQD/PYAHr3eCx4lBt4V2y2Brn0m5CSGEEEIIIYQQsrh0Zp1grR0bY74bwBsBtAH8krX2HmPMywDcaa19HdxubD9sjLFwbqPvqqp3AbzL5dfGBoBvs9Z6+81LjTF/G07U+llrrU/q/R8A/Iox5qNwjqbvsdZevAFzXXiMMRgNOtiiQ4kQQgghhBBCCCELzExBCQCsta+Hy4Uky35A/P9rAbxWqbcHt9Ob1uZLAbxUKX8cwN+aZ1zPRIb9DjaZlJsQQgghhBBCCCELzI1Kyk1uEMN+hzmUCCGEEEIIIYQQstBQUFowGPJGCCGEEEIIIYSQRYeC0oIxGnSxxZA3QgghhBBCCCGELDAUlBaMYb9DQYkQQgghhBBCCCELDQWlBWM46GBz7/BmD4MQQgghhBBCCCGkCAWlBWPEpNyEEEIIIYQQQghZcCgoLRijQQf74ykOxtObPRRCCCGEEEIIIYQQFQpKC8aw3wEAbDOPEiGEEEIIIYQQQhYUCkoLxnDQBQCGvRFCCCGEEEIIIWRhoaC0YHiH0uY+E3MTQgghhBBCCCFkMaGgtGCsDpygtEWHEiGEEEIIIYQQQhYUCkoLxtALSsyhRAghhBBCCCGEkAWFgtKCUYe80aFECCGEEEIIIYSQBYWC0oLhHUqbdCgRQgghhBBCCCFkQaGgtGCsVru8MYcSIYQQQgghhBBCFhUKSgtGv9NCp2WwxV3eCCGEEEIIIYQQsqBQUFowjDEYDjrMoUQIIYQQQgghhJCFhYLSAjLsdxjyRgghhBBCCCGEkIWFgtICMhp0mZSbEEIIIYQQQgghCwsFpQVkRIcSIYQQQgghhBBCFhgKSgvIcNDBJpNyE0IIIYQQQgghZEGhoLSAMIcSIYQQQgghhBBCFhkKSgvIaNDBFnMoEUIIIYQQQgghZEGhoLSADAcdbNKhRAghhBBCCCGEkAWFgtICMup3sD+e4mA8vdlDIYQQQgghhBBCCMmgoLSADPsdAGDYGyGEEEIIIYQQQhYSCkoLyGjQBQAm5iaEEEIIIYQQQshCQkFpARkOnENpc//wJo+EEEIIIYQQQgghJIeC0gIyqkLemJibEEIIIYQQQgghiwgFpQXEO5QY8kYIIYQQQgghhJBFhILSAlLnUGJSbkIIIYQQQgghhCwgFJQWEL/L2yYFJUIIIYQQQgghhCwgcwlKxpgXGGM+YYy53xjzvcrxzzPGvNUYc5cx5h3GmOeIY68wxtxd/fctovyrjTEfrMpfZYzpiGNfaYz5sDHmHmPMO5/uJI8bI5+Ue49JuQkhhBBCCCGEELJ4zBSUjDFtAD8N4GsB3AbgW40xtyWn/RiAX7XWPhfAywD8cFX36wF8CYDnAfgyAC8xxqwaY1oAXgXgRdbavwLgIQD/qKpzAsDPAPi71tr/AcD/52nO8djR77TQaRnmUCKEEEIIIYQQQshCMo9D6UsB3G+tfdBaewDg1QC+ITnnNgBvq/7/7eL4bQBut9aOrbXbAO4C8AIApwEcWGvvq857M4Bvqv7/7wP4PWvtwwBgrT1/9Gkdb4wxGA06zKFECCGEEEIIIYSQhWQeQemzATwiXj9alUk+AuCF1f9/I4CRMeZ0Vf4CY8yyMWYdwFcB+BwAFwF0jDHPr+p8c1UOAH8JwMkqdO4Dxph/eNRJPRMYDjp0KBFCCCGEEEIIIWQh6cw+ZS5eAuCnjDHfAeB2AI8BmFhr32SM+WsA3gPgAoA7qnJrjHkRgJ8wxvQBvAnARIzpfwTwNwEsAbjDGPNe4WYCABhjXgzgxQDwuZ/7uTdoGovDsN/FBgUlQgghhBBCCCGELCDzOJQeQ3APAcBzqrIaa+3j1toXWmu/GMD3V2VXq39fbq19nrX2awAYAPdV5XdYa7/cWvulcCKUF4weBfBGa+22tfZideyL0kFZa19prX2+tfb5Z86cmX/Gx4RRv4OtfSblJoQQQgghhBBCyOIxj6D0fgBfaIz5AmNMD8CLALxOnmCMWa8SbQPA9wH4paq8XYW+wRjzXADPhXMjwRhztvq3D+B7APxcVf8PAfwNY0zHGLMMl8z73uuf4vGEOZQIIYQQQgghhBCyqMwMebPWjo0x3w3gjQDaAH7JWnuPMeZlAO601r4OwFcC+GFjjIVzFH1XVb0L4F3GGADYAPBt1lqvkrzUGPO34UStn7XWvq3q715jzBvgEnhPAfyCtfbuGzPd48Nw0MEDFygoEUIIIYQQQgghZPGYK4eStfb1AF6flP2A+P/XAnitUm8Pbqc3rc2XAnhp4dj/DeD/nmdsz1SG/Q42mUOJEEIIIYQQQgghC8g8IW/kJjAcdLDJkDdCCCGEEEIIIYQsIBSUFpTVQRcH4yn2x5PZJxNCCCGEEEIIIYR8BqGgtKAM+y4acXufghIhhBBCCCGEEEIWCwpKC4oXlDb3Dm/ySAghhBBCCCGEEEJiKCgtKMOBF5SYR4kQQgghhBBCCCGLBQWlBWVUCUpbTMxNCCGEEEIIIYSQBYOC0oIy6ncBAFt0KBFCCCGEEEIIIWTBoKC0oNQhb/vMoUQIIYQQQgghhJDFgoLSguKTctOhRAghhBBCCCGEkEWDgtKCMqodShSUCCGEEEIIIYQQslhQUFpQ+p0Wum1DhxIhhBBCCCGEEEIWDgpKC4oxBsN+B5sUlAghhBBCCCGEELJgUFBaYIaDDrYY8kYIIYQQQgghhJAFg4LSAjPqd+lQIoQQQgghhBBCyMJBQWmBcQ6lw5s9DEIIIYQQQgghhJAICkoLzIg5lAghhBBCCCGEELKAUFBaYJhDiRBCCCGEEEIIIYsIBaUFZjToYIsOJUIIIYQQQgghhCwYFJQWmGG/i006lAghhBBCCCGEELJgUFBaYEaDDg7GU+yPJzd7KIQQQgghhBBCCCE1FJQWmGG/AwAMeyOEEEIIIYQQQshCQUFpgRkNKkGJYW+EEEIIIYQQQghZICgoLTDeobRJhxIhhBBCCCGEEEIWCApKC8xwQEGJEEIIIYQQQgghiwcFpQVm1O8CYMgbIYQQQgghhBBCFgsKSgtMyKF0eJNHQgghhBBCCCGEEBKgoLTA+JA37vJGCCGEEEIIIYSQRYKC0gLjk3JvUFAihBBCCCGEEELIAkFBaYHpd1rotg1zKBFCCCGEEEIIIWShoKC0wBhjMBp0GfJGCCGEEEIIIYSQhYKC0oIz7HfoUCKEEEIIIYQQQshCMZegZIx5gTHmE8aY+40x36sc/zxjzFuNMXcZY95hjHmOOPYKY8zd1X/fIsq/2hjzwar8VcaYTtLmXzPGjI0x3/x0JnjcGfY72NzjLm+EEEIIIYQQQghZHGYKSsaYNoCfBvC1AG4D8K3GmNuS034MwK9aa58L4GUAfriq+/UAvgTA8wB8GYCXGGNWjTEtAK8C8CJr7V8B8BCAf5T0+QoAb3pas3sGMBx0sMmQN0IIIYQQQgghhCwQ8ziUvhTA/dbaB621BwBeDeAbknNuA/C26v/fLo7fBuB2a+3YWrsN4C4ALwBwGsCBtfa+6rw3A/gm0d4/B/C7AM4fcT7POFYHDHkjhBBCCCGEEELIYjGPoPTZAB4Rrx+tyiQfAfDC6v+/EcDIGHO6Kn+BMWbZGLMO4KsAfA6AiwA6xpjnV3W+uSqHMeazqzZ+9ujTeebBHEqEEEIIIYQQQghZNG5UUu6XAPgKY8yHAHwFgMcATKy1bwLwegDvAfBbAO6oyi2AFwH4CWPMnwPYBDCp2vpJAN9jrZ02dWiMebEx5k5jzJ0XLly4QdNYPBjyRgghhBBCCCGEkEWjM/sUPIbKPVTxnKqsxlr7OCqHkjFmCOCbrLVXq2MvB/Dy6thvArivKr8DwJdX5X8LwF+qmns+gFcbYwBgHcDXGWPG1to/SPp8JYBXAsDzn/98O89kjyPDfhdbFJQIIYQQQgghhBCyQMzjUHo/gC80xnyBMaYH5yx6nTzBGLNeJdoGgO8D8EtVebsKfYMx5rkAnosq0bYx5mz1bx/A9wD4OQCw1n6BtfbzrbWfD+C1AP5ZKiY9mxgNOjiYTLE/nsw+mRBCCCGEEEIIIeQzwExByVo7BvDdAN4I4F4Ar7HW3mOMeZkx5u9Wp30lgE8YY+4DcA6VIwlAF8C7jDEfg3MTfVvVHgC81BhzL1yi7j+y1vqk3kQwGjgTGcPeCCGEEEIIIYQQsijME/IGa+3r4XIhybIfEP//Wjg3UVpvD26nN63NlwJ46Yx+v2Oe8T2TGfbdJdraG2N92L/JoyGEEEIIIYQQQgi5cUm5yV8QtaDEnd4IIYQQQgghhBCyIFBQWnBGgy4AhrwRQgghhBBCCCFkcaCgtOCEHEqHN3kkhBBCCCGEEEIIIQ4KSgsOQ94IIYQQQgghhBCyaFBQWnCGAwpKhBBCCCGEEEIIWSwoKC04IeSNghIhhBBCCCGEEEIWAwpKC06/00av3aKgRAghhBBCCCGEkIWBgtIxYDjoYGufSbkJIYQQQgghhBCyGFBQOgYM+x1s0aFECCGEEEIIIYSQBYGC0jFgNOgwKTchhBBCCCGEEEIWBgpKx4Bhv4MNOpQIIYQQQgghhBCyIFBQOgaMBgx5I4QQQgghhBBCyOJAQekYMOwz5I0QQgghhBBCCCGLAwWlY8Bo0KWgRAghhBBCCCGEkIWBgtIxYDjoYHPvENbamz0UQgghhBBCCCGEEApKx4Fhv4PDicX+eHqzh0IIIYQQQgghhBBCQek4MBp0AIBhb4QQQgghhBBCCFkIKCgdA2pBiTu9EUIIIYQQQgghZAGgoHQMGPa7AIBNCkqEEEIIIYQQQghZACgoHQOGfedQ2tw/vMkjIYQQQgghhBBCCKGgdCxgyBshhBBCCCGEEEIWCQpKxwAm5SaEEEIIIYQQQsgiQUHpGFCHvNGhRAghhBBCCCGEkAWAgtIxYEiHEiGEEEIIIYQQQhYICkrHgH6njV67RYcSIYQQQgghhBBCFgIKSseE0aCDLe7yRgghhBBCCCGEkAWAgtIxYTjo0KFECCGEEEIIIYSQhYCC0jFh2O9gi4ISIYQQQgghhBBCFgAKSseEYb+DTSblJoQQQgghhBBCyAJAQemYMBp06VAihBBCCCGEEELIQkBB6ZgwGnSwyaTchBBCCCGEEEIIWQAoKB0TmEOJEEIIIYQQQgghi8JcgpIx5gXGmE8YY+43xnyvcvzzjDFvNcbcZYx5hzHmOeLYK4wxd1f/fYso/2pjzAer8lcZYzpV+T+o2vmoMeY9xpgvuhETPe4MBx1s7Y9hrb3ZQyGEEEIIIYQQQsiznJmCkjGmDeCnAXwtgNsAfKsx5rbktB8D8KvW2ucCeBmAH67qfj2ALwHwPABfBuAlxphVY0wLwKsAvMha+1cAPATgH1VtfQrAV1hr/yqA/wDglU9rhs8QRoMODicW++PpzR4KIYQQQgghhBBCnuXM41D6UgD3W2sftNYeAHg1gG9IzrkNwNuq/3+7OH4bgNuttWNr7TaAuwC8AMBpAAfW2vuq894M4JsAwFr7Hmvtlar8vQBqt9OzmVG/AwDYZNgbIYQQQgghhBBCbjLzCEqfDeAR8frRqkzyEQAvrP7/GwGMjDGnq/IXGGOWjTHrAL4KwOcAuAigY4x5flXnm6vylP8VwJ/OM5FnOsOBE5S29ikoEUIIIYQQQggh5ObSuUHtvATATxljvgPA7QAeAzCx1r7JGPPXALwHwAUAd1Tl1hjzIgA/YYzpA3gTgIls0BjzVXCC0t/QOjTGvBjAiwHgcz/3c2/QNBaXYb8LAEzMTQghhBBCCCGEkJvOPA6lxxC7h55TldVYax+31r7QWvvFAL6/Krta/ftya+3zrLVfA8AAuK8qv8Na++XW2i+FE6F8+BuMMc8F8AsAvsFae0kblLX2ldba51trn3/mzJn5ZnuMGVUOpc39w5s8EkIIIYQQQgghhDzbmUdQej+ALzTGfIExpgfgRQBeJ08wxqxXibYB4PsA/FJV3q5C37xI9Fw4NxKMMWerf/sAvgfAz1WvPxfA7wH4dpFj6VnPkDmUCCGEEEIIIYQQsiDMDHmz1o6NMd8N4I0A2gB+yVp7jzHmZQDutNa+DsBXAvhhY4yFcxt9V1W9C+BdxhgA2ADwbdZar4i81Bjzt+FErZ+11vqk3j8Al7T7Z6p6Y2utz7X0rMU7lBjyRgghhBBCCCGEkJvNXDmUrLWvB/D6pOwHxP+/FsBrlXp7cDu9aW2+FMBLlfLvBPCd84zr2YR3KDEpNyGEEEIIIYQQQm4284S8kQWAu7wRQgghhBBCCCFkUaCgdEzod9rodVrY2GNSbkIIIYQQQgghhNxcKCgdI0b9DnMoEUIIIYQQQggh5KZDQekYMRp0GPJGCCGEEEIIIYSQmw4FpWPEcECHEiGEEEIIIYQQQm4+FJSOEcN+B5sUlAghhBBCCCGEEHKToaB0jBj2u9hkyBshhBBCCCGEEEJuMhSUjhGrgw629rnLGyGEEEIIIYQQQm4uFJSOEcyhRAghhBBCCCGEkEWAgtIxwudQstbe7KEQQgghhBBCCCHkWQwFpWPEcNDBeGqxP57e7KEQQgghhBBCCCHkWQwFpWPEaNAFAO70RgghhBBCCCGEkJsKBaVjxKjfAQBscac3QgghhBBCCCGE3EQoKB0jhpWgtLnHnd4IIYQQQgghhBBy86CgdIwYDiqHEkPeCCGEEEIIIYQQchOhoHSMGFWC0iZD3gghhBBCCCGEEHIToaB0jBj1XVJuOpQIIYQQQgghhBByM6GgdIzwIW/MoUQIIYQQQgghhJCbCQWlY8SQu7wRQgghhBBCCCFkAaCgdIzodVrod1rMoUQIIYQQQgghhJCbCgWlY8Zo0GEOJUIIIYQQQgghhNxUKCgdM4b9DjYpKBFCCCGEEEIIIeQmQkHpmDEcdJhDiRBCCCGEEEIIITcVCkrHjFG/y5A3QgghhBBCCCGE3FQoKB0zhoMOk3ITQgghhBBCCCHkpkJB6Zgx6newuXd4s4dBCCGEEEIIIYSQZzEUlI4ZzKFECCGEEEIIIYSQmw0FpWPGaNDB1t4Y1tqbPRRCCCGEEEIIIYQ8S6GgdMwY9rsYTy32x9ObPRRCCCGEEEIIIYQ8S6GgdMwYDjoAgA3mUSKEEEIIIYQQQshNgoLSMWPUd4LS1h7zKBFCCCGEEEIIIeTmMJegZIx5gTHmE8aY+40x36sc/zxjzFuNMXcZY95hjHmOOPYKY8zd1X/fIsq/2hjzwar8VcaYTlVujDH/perrLmPMl9yIiT5TGFUOJSbmJoQQQgghhBBCyM1ipqBkjGkD+GkAXwvgNgDfaoy5LTntxwD8qrX2uQBeBuCHq7pfD+BLADwPwJcBeIkxZtUY0wLwKgAvstb+FQAPAfhHVVtfC+ALq/9eDOBnn84En2kM6VAihBBCCCGEEELITWYeh9KXArjfWvugtfYAwKsBfENyzm0A3lb9/9vF8dsA3G6tHVtrtwHcBeAFAE4DOLDW3led92YA31T9/zfAiVPWWvteACeMMbdex9yekYQcShSUCCGEEEIIIYQQcnOYR1D6bACPiNePVmWSjwB4YfX/3whgZIw5XZW/wBizbIxZB/BVAD4HwEUAHWPM86s631yVz9vfs5ZRvwuAIW/k2cUb7n4CH3302g1p694nNvBHH3n8hrT1dPnUxW0cThZ3x8bDyRTnN/du9jDIs5Df/cCjz/q/c3/60SewP57c7GEQ8rSZTu0Na8tai7d9/ClMjtjm/niCJ689c/+ePXplB598alM9dnFrH/c8fmO+Qy0yj1/dxcOXdm72MMhfIBe39vFbf/7wddc/v7mHRy7zHrnR3Kik3C8B8BXGmA8B+AoAjwGYWGvfBOD1AN4D4LcA3FGVWwAvAvATxpg/B7AJ4EjfmowxLzbG3GmMufPChQs3aBqLT51D6Zjv8vb+T1/Gd/zyn2O8wA/TnwkevbKD3YPFfmD4/73mw/jFP/vU025nOrX4wdfdgwcvbB257n/8k3vx8+96sPGcx6/u4ktf/paZ7f/G+x7C9//+R488BgD48Tffhz++68aIUVv7Y/wvP3E7fv9Dj0Xlj1zewd7hZ/6e2Duc4PxG/GX7NXc+gr/5Y++8oQ+1v3bHp/GyP/rYDWtvkfmh19+Ln3rbJ2/2MP7C+NTF7b8Q0eexq7v4V7/zEfzxnMLvI5d38PO3Pwj31WI2P/7m+/Cz73jg6QwRAHD/+c2/sM/vT1/cxj/9jQ/ijfc8FZUfTqb4e//tDrzvwUtZnf/2zgfUh8Zf/LNP4c8+eTEr/5ev/hD+wx/fnPfiv3rNR/DTb7//pvT9mWI6tTfls3zR+K0/fxhf/qNvn/v9OYt7n9jEP/mVO3H7fUf77v9rdzyEv/UT7zyyENXEJ57cxIcfuXrD2ns6vOINn8A//60PqcdeefuD+LZfeN9neERlHr2yg7fe+9TsE4/Iv/+je/Avf1tfg0VkOrX416/9CO5+7HiJfY9f3cW//6N7bsoz3J9+9Al83+99FI9d3b2u+j/0J/fin/3GB2/wqAI/9bZP4rUfePQvrP1FZR5B6TEE9xAAPKcqq7HWPm6tfaG19osBfH9VdrX69+XW2udZa78GgAFwX1V+h7X2y621Xwrgdl8+T39V/Vdaa59vrX3+mTNn5pjGM4OV/s1Pyn1t9xDf/LPveVq/Anz44at4xycu4PLOwQ0c2fXx0KVtbBxRoNveH9+Qa/ANP/Vu/OKfBaFkOrW4uLX/tNu9Xu57ahPf//sfjb5w/fmnLqsPL0fl8s4BfuU9n8Zb7z1/5LrTqcXV3eZr9OiVXZzf3McnntR/ofNMpi5k9Hq+VP7uBx7F6z/6xJHraewdTnAwmeJx8UfRWouv+8/vwq/e8eno3Dfc/SQeSISy8WQ61xwmU5v90f/4kxt4+8fj6/Dztz+Iv/1f/ywqu7J9gM39Ma7u3DgB+z0PXMKf3n1j1vAvksnUXYs33fPkdbdxxwOX8M7koWcytfiFdz14rB40rbXqvfbNP/sevPL2ZqF3FrsHk+yz1N+v834W/undT+Dlr78Xl7fn+3vyzvsu4E0fu/7rCrjr+Hf+67vxa+/99NNqp8T+2K1BKvJu7o3dZ/KnLmd1fvSNn8DvfiD7uoRX3v4AfvvOR7Ly+57a+gt/GD6/saeKbh96+Aree8S/K2/7+FM4GP/FPsD82nsfwmuUtboeXnPnI/gbr3j7s+KHs8nU4vt//6N46NJ2duzRKzt47OouNnaP9p3p2u4htpXvWbvVZ+fj1472QHl15xAbe+O5Pyfm4T+96RP43t+964a193TYPZgUH7J3Dsa4snOInYPP3LND6e8GAPzG+x7G//HrH7gu59p4Mi2+p3YOJnjkyvUJDU08cGEL/+LVH7rhjtHN/TFec+ejeNPHdHHtjfc8ib/+Q28tfl/4048+Ufx+bq3FH374seJa3f3YNfzhh/O/F56/81//DL/3QV0Y+bP7L+KX3/1pfPL80X8gnoW1Fv/+j+4pimzj6p558ojvf8/W/hifVj6nPNd2D6/rh2/PH3z4cfz+hygoabwfwBcaY77AGNODcxa9Tp5gjFmvEm0DwPcB+KWqvF2FvsEY81wAzwXwpur12erfPoDvAfBzVf3XAfiH1W5vfx3ANWvt4j99fIbodVrod1rY/AznUJJ/hB6+tIM7H7qCDz1y5brbm1a/VDXN45ff/Sm87jMQmvStr3wvfubtR/u1+nt+9y78y1c//V9Bru4e4nFhwX7jPU/ib7zibbgmxJN7Hr92Q+yZB+NpJpz9q9d8BO+5P/xy/a5PXsRvvO9hXNgMD3LWIhrPvDx6ZQcfe3yjfu2/OMxq69ruId7+iVjsmM4xBn9PzTrP1vdeOO/RKztzCUXW2kxcecPdTx75l1IgjFe2N7XuC8ZjyRei7/u9uzKX2Lf/4p/jR/703qjsB193D37kTz8elf27P7wbL/61D0Rlv/iuT+F7fy/+Enxl5xDnN/ejL0z+u971Ckq/8b6H8Kr3fDoqmyprqGGtxbe+8r1zCTrW2uh6NnH3Y9fmEkgPxlN87ImNp/XAPbU2e3i55/Fr+I9/ci/e8Yn4nnngwhbe80DuIvlMc23nMHMS/PK7P42v+fF3Zudu7o0jQfR6+P4/+Cj+6a/H96e/7y5vz3dNw/nzPShaa3FFOfcoVvjxdIrdwwkeVR5efvv9Dz/tEF3/+ZDOqVTuj13ezkW4qQUuKeLc1Fq1/EbyzT93h+pEcn3P/2D/yOUd/JNfufNIYvQb7n4CX/1j7zhSWPFrP/AoXv00wikkT27s4eLWvvrD2b989Yfw6+996Ib085nk7Z84r7p0n9rYw2+872G8RfnByL8/L2wdLdzsn/76B/Dv/uDurNx/PsnvKZLf/9Cj6o+E04Z6H3z4Cl74M+8+stB/MJniqQ19Xr/wrgfx9/7bHUdq7+ng/g6O1Tn4a3B+4zP3g+Ur3vAJ/P2ff6967HA8xeHE4tJ1iHv/5FV34gf/6B712NS6H2U1EWV/PMHf//n34q5Hrx65z/d/6jL+8MOP41MXdSFie3+sip+z8PfyU4VQzIcv7eDJjb3i39mfeMt9+JmC2/buxzbwL1794ey7huc33vcQ/u3v5+8vz0cfu4b3f1p/zvPjfrJw789i73BS/K6+dzjFL7/70/iTwndyfy8/UVizBy9s4av/0zuK6Rqm1n13KZkCXnn7A/jmn7vjuh2VU2uLY3smM1NQstaOAXw3gDcCuBfAa6y19xhjXmaM+bvVaV8J4BPGmPsAnAPw8qq8C+BdxpiPAXglgG+r2gOAlxpj7oVL1P1H1lqf1Pv1AB4EcD+Anwfwz57mHJ9xjAYdbH4GHUr3n9/EX/3BN+G+KjZ7HjEo5fc++Cj+5x9/Z/0G9R8ITW389vsfwe822Aa398d48a/e2fhA89vvf7j4B82zuTfOfgWexaWtAzxy+en/CjK1FhviQ/Xi9gH2DqfRF56X/M5deMUbgkjw6JUdvOAnb4++xPzJXU/gN98XvgTvjyf433/tzsjV8srbH8DfEQ4Uay1+94OPRg4Kf33kl7GptdeVBP7H33wf/vlvBVupv+az3GB/8KHH8I9/+f24tpOMIfnj88jlnWgNSoLS+x68FH250M57zZ2P4rt/84Mzf0nWhK2ffvv9+Ll3Hj18xv+tkvMqzWE8tbiaPJQ8cW03+3Xow49czX71f+LqLu5PzptMLa4kwoHWdxC9ru8X3T/6yOP4nQ/Ev/ZPrfuFedYX96kF7njwEt7/6dyJkXLHg5fwP/6Ht8z1Pv4vb/0kfuAP9S+jcf9u7ld2ckHo3/z+R+f6ZXVqczHO/7qWtvvf3vkA/tVrPhKVWWvx8j/5GD7+5EZUfjCeHknI0b7o3vXo1Wxtr2wf4K/90FsyQfexq7t48OJ29uvstCDMHGUcl7YOsl8Lg2gSP/xYa/EDf3h3JtaURJadg7H6o8TU6g8yL/+Te/HdhZCRFP/W0dr5odd/XHUuXdran1v49HNKRRdfnrq3rLWwVh+PVYRNP4ejiDolrLX4N7//UXzw4fzh48pOfn0B994oOdC0zwZfVnp413jgwjYevLh9pDlaa3FROX9/PMG/+4O7j+Qg9h8RFzfz9t7zwCU1DPG+pzbxJf/hzer7+1MXt3HvExtZOeBcG0d9AHro0nb0d9bz2NVdfPsvvk994HvVez6Nn3xLHsbbJNb4Y+eVYwfjaTHvz+XtAzygPMDXApXS3vmNPfyfv/0R/OGHcudFLaooD5r3PL6BDz589cg/3k2t+zFGc849cGELH3zoivq34p33XcA/+ZX339DcUvU6K6KRbbgGs5hMbXGcP/z6e/HyP9HDZh+7uot7HtfvV99c6f28ezApfh978tou7n1Cv2emU/e5pr2HL28f4D0PXMK77z+64z6MV1+/f/HqD+Ffv/boTjX/li0JM/6alo5Ppra4hgeTZiffZGqxWRDCaqGrOC73b0kIm8WP/OnH8e2/qIdgWjSLbLWYVTj+wIVtPHhhu3jvzaq/VbkYS8/Zj1zewStvf6D4eWst8MTVvRsW4ntcmCuHkrX29dbav2St/e+stS+vyn7AWvu66v9fa639wuqc77TW7lfle9ba26r//rq19sOizZdaa/+ytfa/t9b+pCi31trvqvr6q9baO2/khJ8JjAZdbP0FOpSu7hzg5X/ysfoP5PmNfUymFg9VIW7XIyh96uI27j+/hZ3K+h7aKH+5dkJG+finLm7jTR97qvGB894nNvG+T11ufGOngom1tvjLl2eSjO3aziG+6sfeETlyZuEfAGTf/o+2bHv/cBI9DDxwYRsff3IzCu167Qcewa+8JzhYnri6hzfe8xTueCD84bywuY+HL+/UfWgCT0lUSMUcbS7vffBStM77h9Po4WZeB5F/aJUP3JqQ869+5yP4v4Qw4LuW5z16ZQff8sr34s3CTqy5bsaTKaZ29u6Jmrtmam02ttd+4NEsbE1rC0AUyqeVAW5ueb95mVXG4s7LH0oPxlPsHU6jugASIQ/qeDT+ze9/FP/1rfGDRmmMQF7+wIWtyEkQBJ3ZfZ/f2MfBZIpH5xBZxtP5fhWt+09cMn/2yYv4zfc9jIuKEyTFWheqKb+M23pe8Rj8r7XyPbRzMMHPv+tTeMPdsUvrdyuBPg0l+vZffB/+S3INPvroNXzRv39TFqL8k2/5JH7wdbGwtrHnHowevKALPNq9P+8vzHc/dg3P/fdvykJiptbicvLl36/B5aS/3cMJfvWOh7JwNb9kqWjylnvP4//7Wx/K7OvTqfv7lT4EbjU4rtK/IbWIpTy4aM40AHjxr31AzR+2pwisJcGqNNf6fHU8+gPW1LoHinnDOKy1eOXtD2SupoPJFL/5voejz1k5Ln1Mbo3SB9UHL2zhf/i/3piJqNOG+R1OcvetHy+gC1efeHJTfViyBaHrgfPb+LX3PoR3Fn7t12jqvySoPXxpB5e3D+of8CQ/+oaPZ6Iz4ITaL37Zm/G2JIwZAH7nzkfw5T/6NlUQ+Ie/9Of4ibfcl5Xf/dg1vOuTF9V8XKVx+/tP++7UdOz1H30CX/uf36U65awFLjYIVFp7h1P/IFwWVfQxlgWXhy/t4O/81z8rjLHhGk/d35v0sx5wIZ9v+/h59W/rHQ9cwvP/41vU70qHkyl+585H1OvZJJhNp+VjgHNal8S0f/AL78WPvOHj6rEPPXwVt9+nO2un1mKrIFgEkVEfz9/9qT/DTxciB6a2SegoCyGzRKy7H7uGH33Dx9XnhVkix8WtA3zyvC5ybe2P8Q0//W71Pd00XjnmkrPM2iYxyv1bEk7q4w1rVa7bLHQ9cW0XL/jJ2/FEQcy6VH3GaWs9y4FU933dx/G0jr/xnifxQ6//eFGctdZi93By5BDf486NSspNPoMM+50bmkNp52CMP7krWAvf++Bl/Py7PlV/mfBvrq39Q/W1xuNXdyMxIxWhbPIacE4o+Yfe2xJLzCNs+RjunYbEqU5ICHN5530X8D/9yFsbd7eyicjyxMYuPnVxG3cfYRcN/zm6qQg6qWtltuijO0vieq7PrSp8sdRO3j9mCkr3PrGJF73yvXhPcs03xMN0SVB6zfsfib7I+DHI8/x6yz8+W3tjPCWukda+f+A+H91X5XmnoYYv/Z2PRDkAtLXQRJM//PBjkWPMj0UVa8SXTVuXzRat9DJdPEpzRgWh6EApi9c9HSPg1ib9AvTBh67gjsQdpYUIan1v7h3iBT8ZJyg/ijvqqOde3YmFm0mVMF67D9OHgVIY4A+//t7MUTmtPn/kZ1TdrhLKdDCeRp9VQdSKz72yc4CdgwkuJaLWA+e38NEk78BTG3sYTy0+lQg5h5OpEk7l/i2JFdr52sPSJ5/azD4/n9rYw2Rqs5ABa4Htg1hQCeOI51can/+MScUXLxilD5Al95l3XKVfcn/67ffj//0z75lrLH5OmtB2ZecADykPbS997V34l6/+sDrG9BrPci6l5/tjV3Zy8abk7NofT/CDr7snez89ubGHH3r9x/HHd8WhCEHMKoTVKWOy1j1sp0LQU9UPWKmrMjiz8nV95e0P4uv+87uUvlHVyfv/rt/8IH70DZ9Qx7tzMMlyzZScYYDLlfR/JGHFs+o4J1RZLNHmuXc4UR88N/fG2Nwfqz9oPXJ5B49c3lWFi629sSoi2IYx+M/0VIxtmqu/7zQhZ2PvEOOpHiIyrX7cK4m5F47Y1/XW+8RTm/joY9fwMcUd1uS+aj6G6lg+74cubePi1r6ap/R9D17GS197l/pDql8lrb9aECkIE02brzx+da+4Q9zU2uh7WNRnw/zrY4XxPLWxh088VXI3WZzfyO8LIKyBKijVYqM+3rfeex4/844H1B8WZ4lR1tqiAPH41V185JGraqj9rHZnCTf+R041zHE6uy6gi2Sz+3X/lub8YPXD90cKKQOm1mLvcKqKpvP2/UTDtQBmC1Ilscu/V2bXnzW+G5/La5GhoHQMGfY7c9vmNS5s7uN3RNLJN93zFL7rNz9Yf7Hwb0YvWs0jBqX88rs/hRf/WjCXhRC3Q/U1APzvv/YB/PibPyHqNOdFmSeESjvnwQtb0ZdF1094fXHrAIcT2xhrPq0egrwl1//6I8WGn3vnA/h7P1eOn9fFIz/e+AFUKt3FsLTd/KE1Lov7C6/zc1IxZ3M/FiRuv+8C/lwkhfXreSERbqZCwPJ/+2Xbk6nFv/7du/Db738kqpeeN7UW40QYTAUVTRTSxSmtLBck7njgEn7nA49GX5D9Wkgrdiou+rGlgsOPvvHj+Ie/FCy+Wk6pkuimtWcL4tG1zBGTz1dz3/g/olcUV1na9z/99Q9mYQ+6e8t9jqjOI9H37uEEhxObJCiH2vd7H7yEb/jpd6u5nlI30W++72G85v15yN14aiNR/vzmHn7lPZ/GW8SuMyUnVekh/I/vegJvTPI9aaKUvzap80oTKOoy5drrY9OFKiAvt9b1pYU9akJL2oYtrAMA/NPf+CD+0xtj50NRDFL6LLnDSn02iXTafIIAkrczntrsl8VHLu/g3sc3orXy/68JRyWHEqy+Xuc39nB/6qJqEPG0fuX52QP41Amb6edKaR0+/sQmfuU9n8a7kpAs/zcgFY5KIpc/VioHctHCFtpqEiwubu3j0Su72UNVkzizezBRHyhKTihbWHcA+MgjV/GWe59SBLswvrwfPbSuuY7b3CINBWoUc2aOoVynSZTJhc6mOtWxJiGnML6DyTT/pb+hL3+dVJeOP6Z8t2t09zSIH7Xzp8HlcVRBpWks/m+p9rAd2mwai/4QPJ7Yhpwz5e/D/u++5nKcZ21KApe1zccOJlM1F2MdqtVwb8wSb7TxhnbLIsLG3ljdgCC4kMr3wZWCKDQrPKtJkJotgrl/dYdS+FurXdtZOZRmuYSa6tvqvnnymh42Nq8DqRwyF9pvql9K+j37eLPg9EyFgtIxZDjoRALIY1d3o8SxD1/aiazn77zvAr7zVXfWb8w/uetxvPS1d9VfCv0vTf7DOYg9ro9JIiClxwH3RVN+6ByMp9jcCw/etShVEKkAF96RJoOOhZ59vOiVd9R/9LQ27j+/hXd9MljStXO+4afejV8RiYKt1fPYyLJPPrUZ/VrkzymJboDb9jn9Veddn7xQu1Q08cgqfWcOpVq8kvXcQ7m/lrro5P71DxW6sOLbzutJce8/vfk+/Oe33ped0+R2KrmvSmOYRxhK8yzl9Z5+2VWlj1jwy0Wm6TQXhS5txe6EpnnmQpEuMqXi0dS6/2Tst+beqQWJGQ4lrQxw99qF5ItVyR3l+tauZbMzqyQG3PvEBj7yyNXoC27p3Nd+4BH81vtjp5gmFAXhRyvTH3jTuepuLE0s8XOdvValvvw118SZkqNKE4n2x9N6xyTZXzERtDKPzb1xlvR4Z3+c/XpYEuK0cv8ZV3poLbWRh4fp5bPGormCDibTSISU66o5f44SCufFPXWMqbAyDfdU/N53/384yXPeBTFEF4JSUaG0Pr6di3OWu7bcfZPu9hREKP0ap+WlOcTHCuLbEcSUOiyqsCZ6CJYTIrXPaKAUbui+P+Shjk392MZ7pRTWCJSFnibRqBTGpbXX6P5pGIO/KxpD5bbyvzWAE2qO5F663jFeZ5tNIXbX72ya3aYmptT1GoShZnHn6CFZ84ynLNCUcwM11Q3jKYsk5Xm646rA4t0+18rr59ouhxs2hZYBzWLsTAeTIl7MFqPK85VvK11IndW2+7fkIvJrUnImAiiGjc0WhGxz3zOOz+9wahasnrhKQYksOKNBHPL2M2+/H9/1GyH58a+/7yH8C7ED2QcfuoK33PtU7e7wSWGDQORfH6qvU3EiPQ64rVO/5b+F5Nf+w8SP07/BUlEqfTBPX+8IF9B9T23ivQ9erreStMo4fv72B/HS37lLtFH1sxvmsrk/jpTrVLAJ8w1j+b7f+yhe9scfE3V8u/H8UteQdDHtjyf4jl9+P36z2kGmSWCJx4Mo3Es7J7+Grlxz4fgxq+3Urplm19J0mrqD8rnYpF4Y0+y2s7KC4HNNrEvan6ynCxrXX3ZVebBO793dw0niotFDAK/u5Nc2dxlZ1emTikd6HqSqH209FfFCravkQdLEk1R40sUj/0DcLB6FtdbbvLKTtzlPnim1r6mvr7uzYmeK719xBxWcMNpY84f1qlxZg6IjRxGP0nHV6z2PkOPb3S6sueJeK46jML+i4LWd3w97h9PoF9+Za1dy7RTcLunuW3bGesty3+dkmodt+fdlnsTczV8TV9Ly+u9b0o4fY+o4kg8A8woOM11QJaGpFG5XeKi2ynuj7LSqHnyLfZRFk1yE8vMuhOI1tlUa1/x5dPw1OUoeoCY3jy0cq8sbHkibXFK5KNPUnj5uK65Ben83Cyuz+0qFFV/udq7VQxOPmsvJH2sMT1MdJuVjYfxlIaExn1Oje6nJLXW0+fmxNjmUNgq7xzWFtTWLO+Vj/ngprK1JGGoSdnxL5zdLzhc0tBvqlsZb6rdRbBLjaHIKzXIZqY4s+DGVrnl1vEHUKY+rfEzWL7mEmoQw2bcWNiZDF5tyic1yEBUFKeGQ0phX0Cr1/0yFgtIxZNSPHUp7h9Poy9rhxOXh8A+faQjbLHEniBPV6+rNtVU4DrgPFZkbI2/Dv45Fqs3EQbO5l4sNs8Yt6xxOp6qI0lRnWj2s+zH6Z3b5kLB7GOcrKYlsWthZ7fSa2mp3rYNoPvvjaf2HOhWqfNtT60Ls4nPKzpl5xCq9nXzudaLwZEyzQuVSQUaOKYhAmFmvfF4cBufv03nqlcpmuaeayjQHUDoWKQD5euOpra+tt/pObQgVLK1JXaaKR7lIMFNkqvq+qjqHZufOsda5DOOHX9eAJh7FThxkZXKMWqjRvG6i7EF26s/N+9fGeTCZ1tenqS8nChTEq+18rJnQ5de/IGrp7WouqQM1X1YqnjQJObnQUpUr56Zt+GPz52eqHkSjz9dwXJY3CWl6uW+7IByVQrfmcEBNozEWxDNlXXRxJS+X7V8uCHnapgdA2fVTdGQVws5Sx1EQgUquovlDuEoiTEkckn2UXCnltsrOqTx8TB9vKG9wAaV1pno5IMSmkhPqCPmVmuo0iTmwUEPKmpNXl8Yd/i299xvdP0cQm+S9XhLkLm6Vc4bpTqmmcZSvY0n0kmNpFniOFp5W99cgPjTWaxBEZgk4TdeoKUysMeSvQeA6mBRy7FRv2eYwr/K1Opzkf6vl8Sbh53pCuDwzBSVVXPF1ZzijGoSZrf2xmnd32jBm+dZpEn1K+Ztmu3ya2m7u2x8eT626Ocq8fV93jqSqgcevs/4zFQpKx5Bh5VCSzgzp5PGfT1uZiJI4jPbj16XwrfR1Kuz4MjmmVEzJX7uCNDfQphLaldVJRKqN5KHd5WOZJnUO1dd+bNbmyapToUUTu5rbTc9B1K78Q5LPsSx2aA6qUtvaOZnAsyevm76msp5va17hJri43OuDSdhd7OmIO2mf87alOXE0QUMTU+qyeUUrLSQvCXnU5lCqq4ZDaWFr13FeLVLIsmnerz+3FN4xa9zNwolY6+o8v7Vt07kl4cXCrW0ssDTVz681MF9eKeeGmp2TqCTa1OVKX2U3U34NplZ/7xTzEUVOrXy+svzyHKKP67Ms7syT/6gkVsl7VAv30nIiufOPFvKm5ZsCYmeOHGM5z5HuJJlHbJPzu1ToV4ouJaFJHiuFkaVfymc5lEoC1O5hOZl16drkOZSa53Aw0VwpelvNbh8v4umfY6mrqNnt1Nx/kwhVFIc2G+ocwdU0jxhScjw1iVpNIs/1iGRHCUOTnz0lp9RkaoufsUd3Srl/VdGkMI5Z/TU7e8rHmkWaprG4f5vy+OyPlXxVUd0moeqIbqGGNuPjTQ6uhlxHDcdKx5vFMffvxa39TIR2df2YmtahfM1mjbnsxnFl1yMKBRGsPObyuJrH3ST6RX03jKt0fJYIJ59RNSEt9N2cI6mUtHu2A8rXp6BEFpxhv4vJ1GYP5dv7k+h1SRBKxZ3ULZQLOYiP+/PFLm/efePdIlmb2eu4TV8Wi1TVA2oSMrWxm7aRP2zOcl9tJHPX1yMey4bi5gjhY/l8bDK+kggly2wyx3gOZWdRulZ13w3iinxg306u26wd46x1YR5p+JaWsym9XupclJDDo+Y9kv2FcSGvpziZ1PanDWuhOZSOOF5573khYxqVhfOCaDWfKKTmQZpTZFJ3okvFo6nNQsHUvms3UP5AfGWGUBetxQyHTxin7vzQBFJNwNDGmfbVFHY1TsWvhvnnQpc/Nx/r7qG+C1oexlbu7yhCTik/z2VlbK6NXKzaKezcprl20vHF4kgumqThXk0OtbRteX7JuTRPzqVY2JnP+TNLkImFo3C85IzSwhX19t2/JfHiqOMsuVPSOvKza34nkl5uoz6O6nbKxZnSuMrjdf9e3i47X3KhRx9X07FmMcf9W8rvtKmEJdWilipQVe2V8iEdJVRPPGOXXEOXt7VwT70OIASSwnz1Y7PHsbU/LgqfTSJOs+hVfrBtXMejhrU1HivPQf7dKd0jru5RnUbu36MmhZb3UXpPyOPX60JqWjugOal5U+jZ1JY2Yii3K7+HljYOAJqFm/HUXke/87WtuZvk521TnqPScSuONbneZgphM47PGluTA2pWIvTrz6HkjzPkjSw4o0EHgHQYufIsx1FyPBU2UgdTGtK2tR8/+AYHU9xe1GfR1dR83Jc1u5ya24zr6EJWKthEIkcqTCQuIX2+iWuoYVc1WxChor6n+Zzmyn1UuAfUhNvJes6eO7K2/IN6cHXl5+SCYOhPC4MrzSUqawiNk/dN6ja7vqTcWp/lupFoUf3bJHpEDqUG15JVymS/qltqhntHE490kcnXzR9Q053SNHdLvV5zhrfNk6NHF6R8/VT4aqqvCBKKcJXX9+PXH8Kl+KWF5/lpWau/X46yBqVf4DWxbh6Xjj93avX3X2ls87ittNA22baWO6o0l/T80HbiEKsaKgkmpaTT8whQ0Vi2dRFlngTkcft5WLU7X65ZKL+orC/QkPvoiMnJS+Pc2BtH28aX3CmxCJS63krXxreji1nasTqJe1FIm1/QqcsLazKZ5rniyuJUWMdUhKrrFMQcLRwPhTq2sP6yvSYxpCSeXVLFM9+Pvj5A2TXkHsYL630E0SUSQJIHTovZ49CPuX+v7eY7ltXC0JHFH1sdO1pYWy1gNTmCZuzMJd+fsk2g2V3WJMRcr0Opqc2pLSfNn9VnkzNG250smucRk3bPcvvMM17teCyeXL9TSBeFQt2mMZ/f3Ms+a6K6M0Sdpjnvjwthi3b2uErH53WaXW/78lmzyeE0K4dTSUx7pkJB6RhSC0qZANTsQKqP16JFKkDNl6tIvtnSXDhbqYhVELVsctyPS7qcSqJNs8spjE2fi1VfN53j+4p3UXPlG8kazSPybCTzmbed+UK78nZK4WxNAo+WOFsVc3bmqJc432R/VriF0nE2iVPaeZpAo9dz/87azUwTbFR3zFQp09qrCq/ulNc/ci3VwpMoU8LR5haPZiYrz8usUjbzXM0NNOcYN6KdIUN/WpvaWpREHj2HkyJIKYm6S+PXknIDujByvULZLDeKJvS5c/P5zpPYOxKJFLGi5NApOaW080tJw7X+gHK4l9b2wVjPdzW/cFRaK1+uh5iVQwFL6zJb8Cm5fqJ7Yg5Hk2y/nPtoXpdO8/rnYxXlhfC/ksCQ7oAWr8ecbqdpWNeSMFISG0tCD3CUfFDuX5k7MdTR2/J1rC0LtU0OsVIIoSbY1EJJYa76uK1aR973jY6iQr2j5C6K2suuefj/LJl3k4tqWh6j/I6cbgsvr31JNLzundy28pxG8rtnk9PoSOsy8wG9PNZa0GgQO/QcUqHPozuxqj4b1g5odtE1Jt5+Om6fGaF2qYARtTsjn1BT2/rOdOH/m0ShqS2H65bHVZ6THFe57/K45R1fciC1DNBtm9kOpcK8e+1WQ/vh/5scToeTkmvMnbBzMIkc6890KCgdQ4Z9JyhtJaJJSF5to+OpMJMLREiO2+R4/FrGqKdhd8XE3pm4EB+X8ygKWTNyKsmxlbaqL81VO0dzpqT1Sv3EZXpuJt0d1dRO6rJScigl4zucyGukz3PW3H1/TWFw6boD4Xo15QeS49xNEpMfNVG3LpC513LHNW2smvB0o8tyASyM96pyTa4qriUtx9Ns11JVpgkdM3ZVk+unPdzN3gEvH08o0x88tXDUq4rQo409Fyv8OJvP9WUyqbgtrLu2dnIORxGJrigCQlHUUpxPlwvhY1q7+W51vo0bK3YVzxe5s7ScViUx5SgCG6CLd5eT3FblUDhXXkqyPU9S7pLQJNspfXkvizGzRZrS+aX2m8cT/rZGTiTxgFJ0IilJ1NW+S+VzzLuULLy0ruNpOedbJs5MoZbLOZZyGJXEKX1szWvv+jl6nWL42pHC7kR7BfHqekQjdXz+u6Ai1tR9HcFpNM9aAJqo0jDGxmPhO0y+y6k7tnMwyZwOfijaMfnAWsrxBeRCjbUWxvhjuXDRKhyT10ffPc6d0Cg2aaJR9S7f2h9jO5tj6DRtd5YDxX96lHIdDbqtqu71C2e5OCjqNuaLOlqonW+33TJ4qsGtptWNxqwkVJ8tgpXbniXK+Lr9TmumKNOUS+ja7mH+vp/Ouk5Ap9XC2dFgjhxMediZtRa3nhi449oucjPEMnlcC2ubTi3Wh313/OqzJ48SBaVjSC0oZUm0YyfIzJC3zLGUCDkz2o/KMtEp7TN+PUnO1/qZnYcpzMM/oNS5jWa5q6pd3eTn7+Z+2m+T2JWuWRiLX89auCgKeaHzTJiR6zJN24lfR/UUp0sq4mkOqdQh07Q7nFyPWhypw/nKAopc6yYR6Kg5lDTHVRpCqPWp5VXSXFiq82hmWdWH8jCsrUeTa0kTnmT5bLeUzeo2rbEmCAGFRM8znUdam6jq5uORbc4WXvJ+cuGrGqcahqbPU7sWmnumlLhZm6u2JqU5XN7O32el8ebOoKoN5dx8tzptHUJbl5Xwv8sipMwW1keOWxOrplZ/72nJt7M2poXyggjhi+d1LhUdRNP8/PJYoJY39auFA8pHg8iJJP7+ziNklQQad6x5nOmxeUSuiwVRrCSCNOXAKSUdnzdhtgx/KjmkSqF1JZeXPma9/9g5NJ/QM5eY0+C8KPXTlPupSUApilpHSsqNWuho7KuwFqU6S9320cQr6x6A9WOhYpODJw1Ri50/5XAmTeApjbNpDrH4k/fnH2Q1wax8TMyvIXF0k4tMDetrdEWFa5ELP+H/G5NnK8LP1FrcurZUzaUsnDUlyNbyFflujGnOOfTURh7mJMeYrq8/dMuqE0c0UajXaaFV6HdqgZZxf99Ln+PGlJ027UplLDmnRoMOzm+U3Xe3rg1mh/kd0UXkD6302kUHkjGub1XQEUNV8ztZV7fpeK/jHUzX1/5nn/DtP3vyKFFQOoaMBl0AZXHDizW5Qyn+5X+WmyjNO+TzG2lugpLzJxUv0jY3o5CstM10XIhey8/dsriW9Fv9gbMW2D4YJw/Mc+y0luZiSl5Pq3Zd377dVCw6zNcxDVXTch8l5xyMp/XDc+5+CWuT5ytScjgpglst0tVta2Fw5XqZ6KSJXHIMSVsybC1tS5uzLljJ9uOyrf1xthvg9eVaUsrmSPwdC0V5eJs6L02sUIUizRnSLEb5frYPQmhn7BTJz9WdO83nWXF90/e+O1cJ9dPWsZBbR9+57igijxZqmD8kX9vVdxq7rDqJ9HCuK4r4URL0dEdWuqtcfm6pP00kKZ5ble+Pp5mTMO1Pnq/lZ0rL/bllcWR2G3F5ISxNETrS5OP19Zoj59Ks+QDz527SymPxpuBEmiNfUUmgkW2lu7OVxAFbaKvkRIrOL4S2be6No1wnc/VdysNTCPcCgAtFt4/+gHd157D++yDLgfmTnjfnNtLL5ZjnFc6axTb3rxa+VhpDLJ7pIknqKGpy8VhrcXqlV7V3dNfQ5Z2D5Fq4A+dW+80OJUVgXB/20W6ZI+ZXKh+bWouTy93rqudpEpty0ahpvSxuWR2ox6y1OD3so9MyWZvyntNcMr7PplCvKzt57in/4K/VnVqLc9VYtWOlOfrj7ZbBRBV+whqU2jWmlNcq9Fuqe2bYP3LOoCaHkq93y9qgWLfXbmF92C86lM6OvNtGdz+tN4y5tFZ+KT5rbcmJVYXPjs86sXR9ibOnQWRORRe/Jp91Ykl1MFkLtIzBLWuDxsTs68Ne0WE07HexOugUj3vBSXVAiR8qSvU/++RS8fgzFQpKx5CQQ6nZ+ZLmREpzLJVepw4d+cvy9sEk+tDN3UQFR1LmgnKvDycW++P4oT6dV+7eyR/I8zp6WFwqhskPvdJ6Ru0Uw9fidvW+Uc9573Aa/RFP57SviEVNu8NlziwxsXSMqsCjCDDZmja6g7R65TXScgalIpDmImsKg5u//fK81bw+oi1b96k5j5pDvVLBQBO7YmFkPmFlbreUIniVws6adqIrz8/3oz2452M8mEyzfGly7FqZ7Edz97hyTaTRnED6g693ypTENF8+tbprT12ngng2aze2aF6Kg0cKPG4M1drMtSuYPzefG5Amvc7bKIk+cduzxbHwQCLEseqfdssU16Ncrs9HC8WaWj1HWpbc25eXQtIKIkq2LlVD5VxGubi3OuiorqtuW1+bdsuo4lynZXB19zBKvjq1wfGs9e3GOnvO8u9NWfzKH0hOVA/iJYdXye1USuR9eXtfFXnTccljmpjiH3RK17vJbRTfN7YOv5GCQiQ0HcGxIwUWeR3lPde469mWPoamOqlDqSSS+fJhv6OKJyv9jnpslujSbRtYq98jZ1cHjWKY5lBptwzWhz3V3WOMFxvK65ELNaiFkdx9Eq7/0dqUc2iopyR4PjPqo2XyhN5Ta9FpGawP++o4PVricX+0Kd8ToLupTq84V5QmWPQ6repaNLiwNMFganFu5N1Webunhj102yYLTZtXFNLarZ1EawM15M1a55hzcy1fz5Jwc8uaF3b0z6Nzq7p4Yi3q8K3SvfJZa4Oi6LM+7KHTMo1CF1B2MN2yNpiZELy01meG+r0hBSVAEeGmLnzzllXnUMpdXajrl8LxnMNJP+6v5amVHp5oCKvstcvhfudWBzCmOdzvmQYFpWNIGvKWJt32762S42j2a1c/3QXOnyNf54nA0zabQ8+A3OVTDitLj4dxZE6ZGXMNc5HjaHAoTUOd2WPRBbF0zk2CmNa2Gs42T36mgkCnCQjTpG1NkAGQOXCahJtm15RWZqs23Rpo45R9am1pOYmanEy+rTjxuo3aKglbeg6l/LxUAJpXRCnP35fp7pn0PE3o2DvMhUvZ5kwxS3nY1HeTaxYWpDX+yk6+3iV3TlqWl9viuSUnkC/XwvDy8c/nhpLhZpH4obS7P57Wv8iV5lUSLcKDtS62aSJRcW4zhK3SubLt0s5t2oP6ZGoz9+Tpld7cgpK3qJccSqlra7X6YUZrf38cxE5/funcXqc11xhdO/n8ZZ1IvKneE+ujvrpe68O03P3r18wLK/J8a/N7dn3onCPywVy+H0vrWdrxThurMVri7/BAURSzlPn1Oq2iiDC1+f3s88bMn/cIOLWcr0mz28gdOxhPoySsUwucXHYPbBcLc0mTK88jXFmbvJdRrhOLVwXhrkE00hxFmkhSizyjvipQtYzBmZHmKAr/nyeSDu4LTZA7tzrApe2DTCQFgFG/o469ZVAYhxNcTq/0jpyX6VzBFeQfLLVjVnxmHUVsikWPvM1Oy+D0sJ8fgwuNOrvaV4QW2V9ZaLmqupCCMKyJId7poa1bywBnR4OiQ6tduam0cKtza2URr9MyODvKQ7F8M7euDXBhcz/b2Ux2o4lCLS/szHK1FPrttk1ZPCnUtdV7xwlKer+ftVYQXqq2b11bUudrrXN6aXOSogyg57nyos5Tm/tRXkTZ9+qgUw47q9pOj4e+9bAx/3lyy9oAe4e5q8vWa6q7p+qxr+k5mJyIZ+owxOz41KJtDM6t9fUcTXDv7TPDPkPeyGIzHMRJuXMByOqvU0dSEgKXCjm7hxMcTqbRH7Ct5AF/VuLurRk7tDW1ked20l/H7abnpH2Efjd2x3UInGxDCltpvpBSHiNtTUI+IkVE2z3MxiLrNPeF7BxfTd1BbjcdT/7Anrbjy7S+orYaQ9fc62vK3JpdRYjKNLEubn8+gex6y/wOdJrYI8+bt0x3/8wnis3uI66b9hvye4U2VUFOjMf/Wn9tZj/u31k7osk2dSEtF7M04WYz2hGudG3yMr/us0L7SuteEnNqgSYRc0bVDwBXamePaHeGO6iUp2jWvThfEvBwbnBPze4vjM29HvU7mR2+FpSOkPBbtu3LTg/7c+Unmlr3xbXXbiVCR6iQCh3r1S/c87Uf/iamYt+ZYR+XtvfVNWzKZyNpWq8z2RpU5aM+rogE5/69vT7sYzK12efp+siJJJeSHenOqOtQWjeIcl1ouqiEwp1e6WH7YJKFSPm+Lxba0vo4kwhpco5ufvF4Ty73MteWq2Ozvn25Oq7qu4IxzTsiXdyMx9xuGZwe9tQ51oKacs8uddtqP1ouoiZxKBJDRPiaFPvSHcr8/+tuoyCSaHM6u9rH1Z3DOJm7dS6LM0NdyGkZJ3ZkDpeqvXy+rq9zIyeSaut3rhIN0rG3jBMbNBHHGIMzowEuFNwpWrjY1FoMBx2s9PJ8TlNrcXK5h167peZeOrnc1Y9Vc1jutRUHjjvWUpxUtp5fLij5+WkCjm/TCR5acmfUIYuagOPDpvJ1s1hb6mLQbalCSsuYSuDSXTtnR/0qMXl+T99aO3rya+Xb1ZKWA05ImCb3jT9+qppnKiQEYScfbz2mE82hdprLyM/V533KhR0vfpRD3rwbpuQiuvWEm6+Wx87PSXMBAWWhy6/zrWsDF3pY2Nzgs04sFYWwYb+thp1JQQjQ19M7jABFkPJjP7GEy9sHym6Ith57ybnVqnM0lY4b3LpadkD59ulQIgtNt93CoNsq5w2qPqBKbppSeJrmSNrai10q84aJlXZk8yKNbLPspPJ9xg+dPgm33kZVp5BkOq6TOJR2YyFrMrUiJCfup1nA0YWgTKyZ2ui1rBOPORlfU19zuIG2D3KhUGvbiTl5X7KtecLN5smX1NSWf90yQdyR580b3ibFi27bqGvjyuIH/8nUVqGe8pzyWmhj087zr5e6bSEeiTnslOcFhFxpatjZTr5OU5sn2pfrYm0I9bgi1upk9Wv9FUXkmDcvk0yWbasvmXHfdRVVXNNyR8m5zxpTOQG3Jl7FZcu99sz6pb6sdfb7eK7uvF6nNTPX0SznFRCEABmSeaUgqmiiweHEZu7WvL+QQDWMzZ28Pupj73CaiAU26680DmuRuYXqtoc9XN09FHnZSm24L4gnV7pzhvuFBLVpAmv/2VASmrwgY8UYDydWvLfceauDDjb2xmoenjR3k7x3Qu46d2x91MfW/lg4CavyYR9TKx11rtyLIZeStfTiRZpLqj6/IBxdPEIo3FK3rT7cn6lcJmk4nNp3JNzkrpSzq/3mHEJJnXbL4NRKrxg+dmkrDW+UgpJ0ATlOLedtxe4l8dBWPVisD/tF8QVIRSgU52mtFe6pfP1HA82VE95fsUPJ1Tm90s92wZNuI20MZ0cNIs9qfq39w/gZpb2pBTrtFk6t5GKTtcA5xaHk75FbFPeLH/u51T42FfdXSdjyrgXNvVTfe+oxL2AM1PCrdqvkzHIuhzOjfhZmFuagC1+Ae/9r7qVWy42z5Cg5q+adQjW/AXYPtR3pyi4sayHEHUXAq91CusB1Tj0W30taXe9cK4aINTqUCkLF1Ocr0kIiK/FlNMDVnUNFpBDjLQg73jGTft4AMuRN7/eW1XK/vU4Lp1e0a466X0ALHQtOn1Ji7HOrAzUheL3OqyXByTVQFm1s6LvgUCo5mKy1aLVMCMcrXOfPaggF9H1f3NqPxG/fvjFOiNMcSH7utxQEI2stDNx9xhxKZOEZ9rt5QuzkYXFWTqRUkNo68Dlrwofd1n4uIGlCTqmPVOgZT13+IH2nODS2IR920nHlyb/jfrcPJhhPplmdSDBpcADlgk3cj3SS+jqTqh19F7JxLDCpoWp6CJ4uFnkBY7bo5Mfd1I6vl4o7qUjRlB/Jt++Th8tfRDWXVElQ8i/Xlro4nNiQFHhqk3ruvOVee2ai7hPVl/J5XUtXdw7Cl/Z+R81xpeVL0kLjasGkGvDJ5W4meMo5xE6ZXDzQxKODScitE62BEIr87h5yV7Ug9ISH1GG/U+dfKY1H9lNKdi3X1T8UacnIU0Gn3TLFHeE08UnPz6M7pK4ool0qMp1a6TXkAtLEq7jM/+KZuW9Weplo40MgtMTgs0L8imLQVG8jOj8JY+snYVzWhm1wLyVil//lWsudU8zPlKxnEHfiufgwrfS9MOgmYWbVF+NTK7qbp9duZeGFPtQrFUbSsch2ZLl8sAOCUFMLTdVDd3rv9DstJwQpArS1ecjlmWxt9PIgwnmRZj8aZy2SFOZ7sbQznOI46raNWn5m1E/C7eK+L23Fn19+DprYcnqlr4YAnhn2saEk8u5Un2cXt/L7woUx5b/OL3XbOJhMo11VLcLDquqQGuUOqalFLUSmc2mZPDzRL+/ZBoeWJl5MrcVZ7w4qhIBpu6+tLnWzUMHwwFiJQ4W5agLK+rAPY9IwtHhOqdjUJNY0haGdbRjf2VVNUPLrp4fKeWHr0vZBFKYztRYGBXdPdd65NU3gqcZfEniM+yzQRBxTjUULXavXpCC23LKmh4rVLiR1LG5+l7b1JOf+AV0TsW6tQ8zyPsvJvn2YWL/x2KWt/SRsMYgRQJ4ofGot+t0WTq/0VHdT7SRqEDkAJawNIQxPF8DKoXa2+jw5udzNx1T9e8vaAAfjqeqi9nU1ccRUgqUbcyH0THEw+VBY75zSHEx1fqaCCNbtOEFcC0szJog6ueiDqu+lohDm6udhab7vkoNpagGDcn4nv96fXQtSedJvv0uctXrie+cwWsIVZexe0HKCk7YzXxCs6FAiC89o0AmCUPWJlIawbdRihxc/Ss4fVPWUnc8S0cUJOfL4vC4pKWak+YNiF5S2E1zaRip25AnJ8zrp2FNRRUvcnTmfUpFHCYdKxQE13G5G/ibZTioopY4xV4bonJlCWeo+KohV/pTVQadOJi7P04SbUo4m/3ptqTt3YnC5TicTEaiec9LWyeXezETgpwptNZX51ydWuup5pV33gtgTt+9fn1zpZYm6Ty73MrHFr5tMVL7ca0fi0dSizm8hHVk+75oUj/x6yvPSdfFfiE8s9/TwNC2vUpLTyW8iIMUfL7Jc0dpMRJ6Ty925HUb9TquQFDsu88LZlWTd5Zh8Nz5cR4bHeeHnqiLypH35pKT1WKvvzaeHvUx88uJMKhKM+p1InNGcNFKAk64eKQKk/flrc3knF0lSEW5tqYuWEQ6l6uTTlTCjiUdajig3F90tlLmfhn499qPy04pw1DLuWqUhT4C73y4nD/T+ulxOnDmnFaHJ2rC9cur8KQltablvR3NGTafBAZa2k4akBedS7FSpxzPS76FUaPJtLfXaWO61VYdSt60n+HaOG82JFIfb1cJEIhz599Zw0MGgm4YphnlrLhw9RK80v8qRMuonjhn3GVo7hKLQNve+GHRTASb0ryXfPlNY30aH0kgLHUN9THPz6CKUr9PH5n7syvH3burKkcIVkApU7t9zq1rYmMsPkjq1ZB1AE5SceKLljKrzKynOs6Ve2zmv5Piqf88VxCsgXNsoz9M0hENNpja7h7yIk4UAVv97S8Ex1DIGZ1b7qphnfAialpOnVRYOQ+ia7r7Qro0XU85WIk0kmE1DuF9pzZpcMueKYpMTc8+M+rpDqQ6zKxxbzcPP6vUuiFhW1NUELufEGmBjL92JcNY8g0iiCzcmuJCU6+KPP3lNd7hpApn8oVXLkyRzFbkx6+t4bqQ4farvGiVHll/HW1YH2D6Y1M9aclxlB1PIQ6S17et/Vkn0qefVL4bqmUrUyQWj8P7QEl/X611I6l3P2zu3SmLZqj52v+a3rg7cDnjKpiQ+ZG5rfxyt6zMZCkrHlGG/U+cnCmJOHG6W5VhSHExa+FnsSFJeCzfOVtLnPO4iHzbnk2Wmib5nuZz0cXnXR9pGWicWMHQhKxc5SuFbU+vcT00hfLrIE8ay1G035jWqxawkJE+Oz7flRY2onUIOo9I8V3rtun/fburoqUOr5nAo+fb9KSeXe8VztHGGMcRCTira+LZOLHfV9mOHUtWWEDR67VZ5TjthHJro4tcsdcxMpjZ73/nwLz/PU5VgIcMQT65064TZU3He1Fa73yUimyYKybGcrEQwGSJ2qhbGwoPqaKnrBAlRt2UMTix39V3nZib6luJRqH+yKrumCDpXk5DDUyu9JF9SODfNd3RqJRdpZN9u7mFMQeTJ51SLF8NYEPIhe845lYcBpg8pJZHo1Eo/E1ZOZ+Fx1byGiZtp6t6TxuhrYG1+H59W+isJOaeHeTLsTtvg5HIvy6Hk10fL+3RlW+Zn8uf3MqEpFXGmaduJg2p91M/yGRljcDJxk/kvraeU5N6DbgujfqfBoRQ/cNVOsxkCTslB5Ouo4VSi30tp+0nS7FSkSYWmWrzx46n+Jp5a6aFl9FBB7Xr7tjRByQs06bUNOYH2s/O1ubWNwekVXWxxTiBdaAHi8C1bfaa0WyYTWrxDSRM/9KTgvk4qaIX+teTbp71rJxHBjHH3iAytkwIQoIcVerdX6qLxIlwcAmaj9jQxZz0RbKQwAegOoHOr/WxHOSmS6UKOHoZmjNETwFftnRlqggxgkIeM2aQvKbr4a3tLQdjyIW/psVqkqPL2aCHs51YHuVBTtVnKW9Sqj5VzCGmiUSnXU50HqEpInjqNvJgytbq4ek4R2prWzIuv6ysuuXxJhNHnH8LsisdG+U5fco6AnrfJu5u0nEQGRoTo5feG3wlPFaNaKLqbpLCjiSA+abeWLwvQHTUhJ5ZRcyzJsDRADy1rVc6pkqhzdtQv7uTWaumikL/FvbBSCsVbX6nanpHUW3M4eVHnwtZ+dB/769QyBucUMcvfc922S3ydhqWlYlbedxB8ns7xW5QcTv79It1bz5awNwpKx5TIoSQEIvk6demk4o6txBD5gJiKLmkOpdxdlPSR9OnD6NI61jobttbnfImv9dC7uo4iTmzsBVEj9Ov+v2XyZNJ6u0Gc8b9Yp4LYRiJube3noYQyKfeJ5W40R7/1aLrL2maVd0ntKynTBR6bnOP+f6UXBK3p1P1q7PMVBcdMN+nPX5t8zaTotFwJLalDqXGnuSlq50Q8Bi9CxHP2YXDB0dLL5twSYXaTqfuFNQ4rs7XIVNpdLRXX5Hm1QNKYuyms0YY2r93D+p6RZTa9BqJuEEaCAOHHIh1OQWQqO5SstWgb4MRSNxJ/TFXWlO/It5nnRrLqGAfddpWbKH6f9jqtLPzqVMPaSkEnOKnyh8B0N7vTmUPKndcR29Sna1yfO3UPwieWukLocOcu99rRLm3WWpxY6UbCjx/++orLDxQSpbt8Vcbk4tPplR52DibRHLotg7Wlbi4GraQCh+svFQ0sckeUFW1c2w1bzPsvSFKwqQUPvz7Juq0tdTGeWuGirNpOkkxbC6z03UNyGuqXijty7YBYxGq1NIdSEEy08lSosxYYDbpZcu9YaMrD8uQYg0PpKCF1yJKEp2JM5jgaxeJNWF9d+OrUuYRyV8a8oo4UYvYOpyLHYDzWi1vpGlVCQrJGrWoL90tKriIvZsn3R9THdixK+PmlO8YZJeQsdbGoYWqj+fMeecfgScW148WSg8k0yx241Gu73cgKuYimNs831lYdT6jGpjuetLxB8mET0PMQnR25kJBUbPSuLzUMTXFQyRCutC/rx1eJRvI7T533JxFk/PiWui4kpimX04WknhdxgFxEM2KMmuBydtXlLUvzQ3nRa2t/jJ0DET5pbS0MXckSlft7QztWiVSrfewcxDmN/PvBP6xq4tzZwhykQ+l8JB6UBRw/93arVQzPM5WIlQs0VZ6kVefUkPOw4hgQO2/89R0UQsj857eeJymIQkD8MO/n6fIkKSFiYo0ubqViXQilc+NNRSNbzafsuPFOofPKXL1TSAtb80IVkOcyqsWL1UEWnhWunbsnsroIQhaQCyNuXPpuaH49WlXbs+asJtaGu+es1cNnWwa4dTUPG/OfC679AZ4s5CAbDboY9bWQuZC/CSgnYA8iXr7LnKmSbqf1rbieJTHtmQoFpWPKsN9RdjKLH262EgFp52CCiSLuyAfdrf1EdNmPk0e78DT3/yu9diZSpWOythKVFNFqNOi4fDp74+gXHylStIx7GDycTBUnVSyQ6OMQ5+zm4XpS5FBD6/aCCOHXy4/txFJXbzf50mitd5WEdd0QgtjaknOj7I+duLfUa6PXbmFjL4StjAYdODdU6KvfaUV9eYeNG4/rZ9BtRQKXT84px3xiuReF3LWNwepSNzpnLXPlIHkt5y9EmqXgKpLi1I535IhFkW35vD3SSaXlPYqEp6qtkyu9SNTydWVZy5gk9E5zQIXrdU0RceR5JxPBxtqw1qWk4X7NTgohSxNR0jJ5nioercTCm7W6KDMadNBtmygheMsYrC13IydT7VBKrrXPq2Tr+1yIR8JllItZ7svAyeVeFnJ2SghCU+GsAGJBxudLids0VXhcHBqW5oqS65E6jFz4YersyR1WLZOGKsbXSM6r22phbSl3eJ1a6WEytdFnVbfdwuqgizQEMrikwj1njMEp1TGUj9e3kbqcsnPrcLyqvyT0UTp9ZLuAIoINU6HJla8rbpiWcdc+E7bqkLfEoaQ4q1wOJedmk+GJ7r7I81WZ6vx0LG2Th8hNq/ezDAFLx3IpGXvIrRQ/PJwZ6UJT6u7JBav4Op9aceJjcP248l67jRPL3cwlFOabu1dOZ0KM+zfNF5QKR6njqFQ+7HeisLowJnf/aPm3fFhS+nl8NunDjTfkKsrFIbeN+s7BpH7YzxxV6UN5y+DMMBffov4VgXJ92Mt2efNuHiAIGN415p1DpfA1QBe70nDA2rGjOJ78g9uZUTwfP4a1ahcyPUdRLrzUIlkybn/PDLptrC11M4HKiydAORxOim5RvdFAFY1aqrDl/l0fOhdKlkOphXoc5xNXjE8grY0RKCQIr0Uv3Znl5wYkIhtQi0alNa6FIcU5ck4Rf2ohqhaUYjGl1SqEAlZtri51sNRtJ06VsNZasm/pwiomAlfnESd1Tsfq+1RdOxa1eHMxy7+UCFWKUOGPawm9pcCS3QPGfV/vdVrFHfZuWR2oYwKguoz891bvMrqYuHX8fFYH7to8qTi5fL9ujfP71lRtaw6lUmiXFLrOVeGDUiz118/PKxfCHD4xtpZjSYoyTyjCn0ycHa1J5doCUIUY6g4lUyfOTo5PXd+jvtudsexAcmN7/Kp+X4ex70Z13diDQJv2/0yFgtIxZTjoCDHH3cBpEm4f0iYf9rcUB1ImsiQCUurYiUSYogsqbyM4etzrTquFYa9TuY3iPnz92MUkztkPbo5Oyyi5nKq5T1G7ZDQnkZzL/tiLOvKcNEdR6GdNuHYip5O2q1uas0iIPl7I8HNsGYPVpU7mYvL9+2ZOLveivtaWpXhTCSlLvcgNJJ00fv3WlrrY2h/XScuNEFts7ZgJ7hi5zqkTbNBtqcmvS7mQNGeTX4M6Z5AQouR51upt+STX0s3lQrZk+27eUjjptl0IjBSA6lC2SNhKE1frDiVNxPGi39XdXBS6tnsQXVvXR+5kuirOO6WE7oXzlLKddI2FgFL9kT6x1A3t+bLlXhaedrISRLbE7lb+GkmXURCZEuFK9iNEllS4ysLTrAv76CiheZpwUO9SJ8a00uug12ll7jGZKNsW+6/cOsvdXLRRwtu8eJY6n7wQI8WcWrQpiFpScGm1oIYi+txAqWNofaVXCzO+jdVBN3Fl6WKQ/7J8ShEBTyxXuZVSd5HPUaSIY2mi6lblfsrWqJ73ftJGHiLn2wBiYdcoApH/QpgKKVKY0kLDpCDjxzKs3FWXt/L3R8vkQlMxd5NPbp6ILquVYyrNldRrt3BiKQhHPgGrv4fqBNhVH96JlCbGNkrIm29rfehCCzMhJnEJ2aT8UupE8i6xJIeSJmZlYk8hfC534VSCjuLAqt1iW+l93hCmNkwFEy/a+JC7PDePJmj5tuSY5UOHG3ODE0oRyEoOJd0BFOpc3t4XudXcv20/hiSEUM61KcF2COOL55QKVJFDKVlXI67Rha29vF7mrnL/+gTUmvjTabsk/fk4jDqOVPzRHFFa0mrfpuYKygWehnqJyCBFqrQeINxEmgtJdf0E8diYvL96PZPwNOkmPFvIqeVFhys7h1myfCnQaGNdH7rxpGMN4xlkwh+AOLRPCXM+1+DECuFyiqMKLsG1W7/YedIyphZgtETQckya4DvotnBqpVcMLTu36jah0D5DaveTUteLUUCan8kf191P/vNRC3mTf080wcmvB1AQlKo5e5dQKYQwONTy6+QFIWu19477/1uVxNfy74vmrvL3iA9Lyx1ITmhb7nWwttQtOpzWq2T0T2hCXEt3fj2ToaB0TBn1O9GDHJC7cg4nFvvjeGezzf1UVIl3G9tqEJBGlYgVfs3o1i4ov4X5luIMqkPcKseGD5szRrYZn+/7WKsFJU2QCQ/46dwPJtNq7la0kTul/EvvwPFClP+wKgko06mNxibdRqo7ai8IOPVrIfr4tn3fq4Nu5KCS58h5a24g6X5y5wRRTBV4VsL6+AdV178co56Ier/ewQ31OKXo5tuWO5GdiEQg/9DUiZKOt1oiCXUmvEihJLQ/Fe1PbeyMS8PgNIdSq3JmSTFlpe9cCZFDSXFr1S6jKIQuEXGmIpfRThBRNeeRFDGk8yo970QmHuVhcFPrQvyG/U4UiuadR9eEu8n4sLG0bKmLNIH2aaWfU9XDct3m1GKl30Gv3YqEE2PcWuQuGhfatT+eiPVJ3TnORXdiOR6TMU5UTXeZO62IDK1WJQgpQsq1RIysc+dsx/enTFTuxyqdRPKB/WQkaCYiURReGOerSp06VxJH1ikhEmVikLK2V3biPC7tVhXGlibl9qJHKoyJ/nw7nVYLJ5d7Qjip2vC5hdKcQFXOMJlnK3UL+XOXum2s9NpFh5JM1m2M3HFOCG/VQ9TmftgZTAqQ6W5xXmBJE0W3Woh2kZNfek8r5T4EKs0L1eu0sDroZEmiux137VNRzW97nwpZpnLe1OdPQ/n6Sl91KMl5hS/dwSVU3xt+R7UjOpG8a6oWv6bxGqXuLh9aJvMLpaFtfnc2X8eHR2r5YUoOpcwhVM2929aTS8u8UmHHuiZByz2JpsnK/X0WEqgnglLLZHX82FQxZ+qFMz18TR3bNAglU5s7CVutPCF2cME05GQa9rB3OM2+h9YJtpUcSv6zqcnF4x8c5efnmVEf2wcTbCc/mkphKyxgGEea8NqPw4capm6OUlieXyttPfxng14vDrFLhRGDkmiU1NPyHa0VXEgmiLFpaJUxBp0q3EtrU0sELj/ntDxJ/v1SCp0shYn5sXbabsv784l4I8fzlBKCFyXIztp1P8oOuq1MFHJzMVWuo1wcM0LI08YLNORYapXGlM6nEFo2Q7g5l4hr8j2su4zCtdN2cvN/Hwdd52qNnVP+/0RoV3E98t3OpPNKF3WqxNaqQ6nq2ciwtN3ouKnFrCVs7o3rz4a071sLOZikGKbnd3L/rwlWvr6/3qU173Wq0EoKSmSRGQ26mQNpfzzFQSogpY6k/diBlL6W53fbJnckCZFhNRJPXP2DSSUwCPHEi1BS2PEfJqNBNxOLNiMhpeBQEq6m1ShcLZzjcyatKUILEIsz9TlV2aAbws5ku3IHOi3k7cRy7AjyoTlaQnApDLnxjesvf6OlbpTI+sRynj9nbSkRlJRz0vxMK722c3TJtpdikcmLLfEYg6Dl21pWk3d3I9FprRaiQjL3eJxBLEkFn1EyhtUll4tGjkGKTH4+scgUyqQAZMQcQ5/5DnTtlsmELT+OWNhK10cPMzupiGl6WRCowryCeJQLT+Ehf6nXdu4bEXbm5yuFolarEoq2w/UKCbhjoe3EcjckE0/yPEnxxCf6luFptXCVillLPeEQi9uUAmEecoZKeOnFIlEt3IiHwGlwSEnxKYTcpW4o99C1sRdCKEtizsno4T++Hk64cXNKnVOpSBTPIQ79CqJW4mYSgkjmREoSWVsxt8nURoJvHTZXCDW7kohdpyoR0P3dcf2ZSmjKczmlybqr8Y3iuWiJs+UXylPDIKaUQuGsWA9XHgthp5Kd6GT55e1YzCgl8a7dNMlaeWEvFUtqkWxLEVGUZNeh/VQIih1Hsh2ZEyktD04k1ON0bqDUJePKDyc2c/qmAkUt9hTyRvXalbioOJGkeyjt+2AyDX1P477TEMB2JcLoibTz0D3pENLWUDqnwrVwdSZTG8T66nPPOyouZP3rrqZWSziUNnNRMBPBqoONuYiqxPZhowJXRw83K7mkkjE0JNhORTIv8gBBQJD3axqi5sfdbTuHhh4yFrcn7530PgwPjJp4Fa5tmvNHPgRrIpoxpg7PPJ+MX66HJlJpTqMQ8lXVU4Q+PQQtcTYpzpEzo0HlNMrFvl6nhZPL3SQhdZh7KgzJNXOOICVMrEp0fXn7QM33pLmQvNB6pnYLpXP0Qkm/GGZ3btVdp9RZ548Bef4l7yRKw9rium4u0lHlv5voeZ1sLUKcLYlREKJQYT6pm0dztJSErLxueKa4RakbhcSt6Tu51W0nu9NFa6Um7Q7rcevaADsHk2yjAiCIQk8Ucl2dWO6i30mFv1gQAhCNzX+u+r6BdL0h5r2E85tJ0m+E+resKrvIibmVHUyh/ycKOZQAF/L3OAUlssgMBx1Mpi4ZsRRRtvZzt09T7iHvBvIfKv585x7qZm4hL2L512nCVdmH3wbZh9WNBu5BfLMWLnLX01K3ja39kFNptSAGpUKXloTbn6OFzYVxuNepcOV/4ch2nNsPScYjt0/1WbUaiRSxUCWGlrijYoHFOZQ6WUie6yt2Zsl8U2u1MBQ7m0L4lxNIVpdi91EcKhfmfi0Rptw5wn0kRJQg3PQikabXbmGlSn6diiXXIlFL5pGKQ978OZ2WiULSnDOoWaCRrqj9egc8TTyKQ/18mXQt+falyOSFlNUqkbkUdurQuN3wYCdzLck1c2ViHVdyR1oQykLd5SrflhSPfMLoWMBBJOoEUSbOjeREpl7sZGrFgmImZskQPMVN5PuOxZA0DDEVZJQ8Ucl8opCzaRCJphb1Fxtrg5gQiWmZE8iN/3TUvysbdNtY6rajkDcfXuXFtGlW/yD6QnZCEX5S51MYlzi3Onm9FkRi55gLjzuo7kNb3xP9TitzHaUClr8OJ1e6Qmjx56a7q6FeXy9KRQKGGtKXjNkLdJn7KYgyVzKxpmo7CU08sex29JIOJS8OqG0LoSkK9arEjO2DSTaWNGl27qJCNca43BbKS0KT7DcNSfPtxM6iUC7zUUXC0TDv1zuRNqocU2H8IoQwEYKyneS8qJLk6pFiwmlN/Gr5cDtdzJB9+2NprqR0HlpI1eksRC8kZXfjzcW03FUUu5rSOt1KNIvz4VR1Rr0sV5MXOltGJisPc1kf9nF157B+4PHzX61ytWiOpzMjFxqTirVBuCs7gC4IB5AfQ8mhtNJzDkFNHPJ5iPI5VTu2KWsK6OFrxuT5lVJhKD4W5pu6l5qcUpW+AcDdw9q8gNz1VP+97bYxSpKAh79Hbhe0XBhy958m/vj3izFaridT5+vRxtLvOHdd6mzyIk26Q5x0ZZRcSMGhVBCb1JDFxGEmhQP/HaramTANI5QOFzXMrhJ3JlObhdHGCb3z3EwAsqTdcbuKo2oahOl0R7vIFaM5cmwIS0vXQX723zJD5HLz0a+brxt+AAnz8Y6sUh4kTXByn+fB/aS5uWTdWHCCEASrttU8SNW4lbAxUwl/qUtIG3eap6iV9F1yCWlJv137QQw7vxnnvLJizW9tcFcBZZEvFuqYQ4ksMMO+Cx/TdmGTwoVzIInXtWAiX7uwlJbxgpR3D3UigcqHc0kRRktkvak4g6bWPYgPe51623Pfh8yZtLbUxWRq6y8HQZAJTiqfM0kKXdIpJcPVvLC11G3H7qokpCweq/uDtDqQQpVzbFnrQ6lix1UQcGKRbW05F4JWem095K1aJ2NMLUylIokXh3w9KaSVHEpT65N5S9FEhoPFTitjgljor0uv06rH7dc5uI/SELs8tEzmmdJC3tIyPwZ5Tss48SvtL9SDUpbOMbiwpKARiS5iTY1x11QKW35OMmytXSVelmLUcuUUkg6lNeGykveeMXGeptWB25Zehrf5ndG8iOH6dUm0rykCjuYyyvMYydxIYV229scuabooA3R3lBR/lhV3VKvl3URx3ycrh5EML4sFGVRr4fIlxbmG0jZDGRDnWzq1HAtS/n0QJwVP53QQPSDJZN/+/jy57MSIHbFTphe/rmyLvGot7+zRw7bSxOLxuYjGlTpyTiz3cDCeRj8spOJM6E/Jw1Stw+VkHVJXmMwh5OYXBDO3+1sevjjsuzxVeQ6lgotoOYSlyQecKNxL/A1w4WrxPRXWKRfefHks+MT5jLyoenqlhy0RIhc5l5Jwrlb1UKgLOL3MYaMLVkIgVASrqP1p3E7mOKrGf3nnoNqEQ7Qj1l5ev1zkc8dKoW1L3TaG/U6D+KUIN6MQQubPN9DyYYX3YsvkQlPLGKwrua+ibek34/dUJphV9UwlQqVJuWV41sXUMdPyO9PlD32aE8rAhy32c3cQQjicJpydSZxD/pf14HhS6mTJspM62npWa1BvjmJD3pa0vXquozh8LRVy5I5nMomuOj7jEkLL5ODy89MLm5kbqoXysUoAubi1H3YKhHCZKM6mkuAi37uaGOPDX9JQRFt9H/WhlZrA40O+5G50FsFlc2aoCzzGC4GJC8mLKXkuJOlQGqg7jZnKTbW1PxYCXXgPNzloSg4ln6smdQtJF4hzKOUuPT8eIIhxcjynq8+INFwuOInKa1fKM2UM6p3L8vGiHu/uYezIqfPyDftot0ySPBv1mM+uxkmmw7OTm0+3bTKBohbIVgc4GE+z7xJ+jdM8SZpYlbqQIuFDDadzYcZpHiR/b/u6ANQ5e8Ho/OZeUbRJRRd5ndaWulnoohTZtJA5Kz6/Ssel62sytflGBvXclnBxK3ey+eO3rg3w+NXd+m+avD/9ceZQIguN391qM3Mk6a+7bXdzeyFjNRFD2i1T7xw3tS5HSRB7XFtpyJtPZH0wntYJZWWbcYhb7kgyxqguKCCECcU5lPRxnEjyFqWOJGN8kus47Eq6t2RibP9BNxrEDiXvAKodWN1WtdNaHJrm251aGRYXiydaUu6N3TSHkXLOXiycbIi+lrptMZ7qGkXJvIX7SQowS3HYmPtFKU6IXTt1hNji8wFJsc/vpmatrfM9rC7FIpDubIqdXE7siF1S0kEk74VUoIlcS/X1jpN3+xxNu4eT6tf6IH5pyaOv7saOE1XsSuq2TZ54ut0OfdQ5aNqmFi/9vLwLyvXr5x/ELXldTizFbiljfDhZ/MDunEdxeFUsMgXXklwr3x7ghYTqmtW7yR1E4z653MXV7Vh8ObHUzQQdL3bKzzDpRpKiWS6GIctLZIxICi76Wuo5h9GVSEhBJkgBSe4qucaF8DrX10EdBthrtzAadCKHkqn68iGDQSiLE2K7axefWwu6VcL4WuCBFzjcGKRAEML5ZoXNhbxI9dq4UzGocxflriwAlSsqrI/LLVR9NgjB47QS8pUKW3675ShHmGjDjS++Tqaauwy5MtV7QbZtrXs4CKLFfiz4rIRy2U69VtuxYClzMcnPpVhEkevSJDQpIVsFZ9GpyN0T7qvTK31c3T2Mdm/1uZWsjXOwmWS+8voFB48ePlkn30ZY/9KcT4twtGiNVvoYT222iYUXs1J3VMeHRykuqPVsZ7jg9pHjnVbvqX7HOUtqN43cZU2E4kWunbotPWRRewAJiaXj+8mtZU9xSOVCj3wYWi+EZa0nTpFUHCrtogYIh5JIuuvzK6UhtYDm1onz9HhBI55TLux5a1DuhrJBPBF9pcKJnK+8d/NjNjp2OInDFsvzap6zH4smxpQFjHD9NfHHh92cGfXVfE6hzbI4kbtZqnqjAS5k7pwg4FwUAqJcs3NJCJ78zA0upPz6nV5xrtHSg3+aOyhe7wEubcdhSfl49qL5G4M6H1QemoZqns51k+ZnaxlTJ+0ujjdx7KQ7i7l1yOu2KwG05ELyjpmLibjdqoWs2M0TC2/xmOX7Xh1zIuoAuehTt72mC11GHJcuITmuW9eWAJR2anPjntp898lZoXz+c+GW1dTBFO8wB+Q5lqSDyB2fJUjp9f3x0nv+1rUl7I+n2XdJz60nXI6nLSE+PlOhoHRM8YLSVpV3x+9G5R1FteCU5C9yIWvu12NjkLiFusIlg0pgCo6Y1SpvU/1AJNrURKrUweP78IJLLDBVAkhRUMqdUtLVtHtYbUMvRJxYyOpWCclDnb3DKfYOp1E/UdjZUpx/KM3940WWNHn14cRi73AarclGIohpCa9DKGDY5c0m6yLzNa0tx33JMafiihcr1DFHYlVoxzsfgCCYePfRZGojIUqKXOOpxc5BCC1bTUQQzUEUBJ9xPQbf32QS/rikQo4Mg0sFK3me3GnM/5ot7zX/ZSEPeUMmYsXjqMpaBmsy8Xf1kCyFlCCUdaPwtlCWiBC1C0rMf7kXuYSkG0l+0ZTJqf1Y1pbj/FBeFAlJsMO6AyH5t+/Dr19Y5/i8MO5eFOZXu5F2c0HH1Q9uoNMFQcevj78uPodS5KBpBYdSnPsHicPIP+wHYS9z5mzHa3wycRjF40/OrcQneT1OinHV17MKJbyyo7tspEur1UqSZ0+TdrflNUhDsIIDCIjD2HwOpSs7sXMkFZpqB82yFBal4CFzK+nCln9QPpXsQleLKcJFFIsm0uUT3gunhNDk59hpt5LE1n5NQ5/pmvo+o7XKhKYgvvn1jsLyVvrYO5xiR2wE4Od6dfew3kHTj/30Sr9ec9m+5ixCJd74RObyAe/0sAdrk3tF3EOXEkfWaeGgiYU1fUe15b5zRapOJBnaJtxa6ysy5Er0IUSr8Ou3cBVpoW1CSMtcUFth/fzDTZqrSD70nBn2i4LO1v44WlutrVQ0U107av/uHCekxMKtrCPFoTDmeNc6314+tnDPaYnBjTFY6bUx6LaKOZSA2OXjx72ehhd6AbgKO01FyCi/UrVjmwXidYh2hwvzlWFoNrmfW0YPhzu7mo491NPyPBkxjshFJY6l4WJS5NMEsbrNLNm1FIby3ehiR1QpdC0Rm6bhfVByS7n+3Djj90g1Tr87miJInk12R5Pvu7OJuCPH6p1kWlhfaf7+WLq7mXTHpGFg8tq7uoPiGpxb7WPnYKImjtcShUuRT8vrJPsEym6fc2vl8DHfrxc45Pq6derHO7UJIcsnYn+yFpTC+x7IXUbyb5Qa8ibmm4aGpWKVS25durbVWhbC1maJNresDfDUNT2Uzx8vJSofdNs4mSYUF9dC7zsWs4A0EbpwIJ3IHU5y7pkDSlk31/4zP+yNgtIxZdiPhZbUlZPuQJaKPZ1WFX4mciiNBp06hC6IPyK0bDkOg4r7yN1ES1UC6M298MAuHUpxH5VolQhK6bjDOIRAk+zQloba+X6dAwjR2DcKwlXuUErPcWvmch3F4Xey727b7a7l3Uf+nIPxFHtV3o7lfqcK4xOiz8C5v7ygU7ezp4hMlehnjKncR8KJtRSLN5HAI1xFfi2kUAaEB3NjgmvJr0cqRAHCaSTmkib4HnRbGHRb0b10UhnD2pJ3sLg+NWeQFEpqwWolzNlfb5mo2/8xWk3Wxhh3bx3UO9eFnDbXdg6jX/rzcVRliYvlRCbiSJdRIgpFZSYT4mrX1k4y/yVFZIrcZNVYhEAV5ps4t4RIca3KjeTnUa+fGw76HRf2ckURs3LxpVudZ8O6SuGqul+1MDrjhYlsl7XqPXIwEWP3babXoZeElsX5gPx9GIs5YY3jHEh5eJV8QD653MVlOX6IZOXb8TX2ScRdu16ECS4b6SJwgpJ0ZAVBRCYBN2K95XhP1mM4SMpd3in5Pq7dNYljQQoV8r6s11II3i7ULw7hMgiuQm0HuXreieizd+ius3wQP7USO2T8F7jUFeQ/N3yfqVjl51O6tvXYhejlnE5hjHX5VhwquV4LPvH9fGrFrVcq8J5a6dXOolS88eOMy/tKvzInkrw3oYp20XUthbApD55qCFcltuR5muJcSan4CRRCsUb5LnlOSAtuJ3n98/A51A9MpzWHUCRoxe61taVuJZhook0vDkVLhZ6t+H4CECW+ln9LzijikBRzmvIhpcnS/bGt/TF2q+8XXsxJd4erx4A8+XrqrEl3wTMmrF0pJxMQ52sK65DuDhcLMppo1G65+yp92DUoh8PFLqogUgURZ1A8dmbUx+beONqJMhJ/kjw2kYhzvaJRGrpW/b+WC8nN3Yf0HQinUTzOw4kVgn58DBA76om/M2mS8PB+dAJvu2WSpN1xKNhTWchfJe4o+YzkMUCGtfk5hnv9qUREkaJR6tLKcvsoYtSpKryslHj7FsXtk7cbRCErj2durPB+z8Yk3JK+3zQfUBDe4lxFNq27FudYkmu11GtjddBR2tbFKvl+9n2ngtEsUSefc8FltDrAwWSqunMB5wIqCUZ+bKkDyc/Lh8xFx6dh3rq7KheEYndWvOZu3XbVsX/2iSV83ullbO+HkLlnKhSUjil1DqX9WMxxry1WB7F7aKXXQbtlRA6lOH+RicQe3T20OujUD9tALsLUr6vE3e2WwVC0YQyi176Pg8kUewexU8h/0e61Zf4j1Odoribv8FlNXjvhxzmjJkkdb4UeDZxjK8pjNOhGLqE0fK12dcl8OEIYiV1YuUPH9902PmfSGJNqnVJhrRav6gd/1NdYhokV3Ue76byCCOZ3frsWnePuLx+uFdoOD98nEpHGlcXuIB9atpGKQEvdeBe2FSnuhHOAkPsmOIOCMKi5loa9jpiP1cdlZFkQTmSf/ouzn/dY/DLohSI5DiniyAdZGVLm1/GqEsqXuoxOLCvCU+X+ScWDa4mbJU147UWd8dRi+2AS8hAthWuYupG8+CHXKk02rYUDnsxyOoVcP85N5wWSbtbmSr9TJxmXX4akG6kWQpIxeZHIj13OPcrx491jSoL0teUuWgbJtUgSgFufg0mOP1xLl6w7H396rhdzUjeNlqTd9ycTe0fz3ckFgjRcbdjvoNs2USJf7y4CKpFBhpot97IwweDQiYWZWoBR1iIVtlxYZBCrLGJRJg3fi0Wc+IEgFY4ALUF46DN17GjCkVaeOpdSsS8WF/X2o1BARfjwYky4FlLUCbmedCfSflReizfRmgUByokn/jq5HHmrg04hf1M/y2/UqkSVPFE41DxNkcgVXQPnKju53M1yCBmTOpTk/HJXkxF9xOJMEHS0UDwpAsm/Uf6e1ES29aFLBL1bJ3OPczWF3cgg+neCln/4rNvyuYjUMLk4t9G0EhpKbqOWCQKLFJukUBLC+/L1vKA4q3zScL+zV7qmFzLXl3Qo6SF0cV9Ixpe3B+hik6k+A9stUwsy8trWu7JtBTFChpnJccjPkFnHdg8nIpG/POZCt8Yiwbqc24XN/cyVCDgRRwpD8r45O+rj2u6hELfC3M+O3E6Eac44Vy/OaSTnHgSlvbo/v2ZpKFhw1Jpqh8WeklzbzzHf1l7OcVu4hWIhKg3lCnPstls4vdITolAYa91ncTe72G0l67qd+dLxCpFvdYCNPSHMivWrXUb1GrnyJkeNP940V78WpaTcfj6pQ0muo8yxpI6rFPKWiFWpQ+mW1UG2254fs2t7KXP5+Pp6HiNNtMmvU1iTvei9YxA6z3ZaQ7gHXB6lpeK8Ty67xPclweqWSnBKhTgpdsVjD+8XAHj+55/CO1/6VfiizzmBZzoUlI4pcUhbEJA299wOaatLcchbq2VCCJsQd3zIXMs4kSpKyl2d7+1/o4EejlbnZRp04z5rkSoIHjJnUiRcVG1KAQSAKmyFHEpuLdId2kbVjltxrqa4jVrUqT54261WNV8931M6X+vHn4osyZp4t5Em8gShxPXl3UctsS7+nNBX7OCJ+4IQwfyYfcJvkUNpKXY6+d1EQv9ScDuox+jD8Px69DsuN00k3EShebGzSRWBprHAd203H0NwSYVd9Pwftdi1hGg+siwNg5Prl4pf6XnS5eXaD31ObDyOSDxqOfeQTFJuKnHm2k7sKDhR7Y6XuoyuJm4kLxRFYsVS7G7yfcicPa1WyIPk3Q+ReLST50uS4YFedJRCmHe95OPpZeLLieVYPPLOqrDWoc0TVQ4meb+cXE5DEXNBx79HjMkTXct8STarH4dQerEjEmiqcEYfFiZFtjgsMYR5yQd23fkU54Hynymq86kaQ5pQW082Xe22uOdDrUK4Rua0auXCnBzz5WQdV6pdBS8nDprYXRSLQZeUUB4njiX5rwqiTBzW59fUrUfIHxS+fGrhfrJcvsfqHfGSB7LTiWMnFQzkGI0x9U6CafunGsQwf74c5+mVIJRIZ0CpHc2JJO+3S1vxOFeXnNieOp2A2A2TCUdaTqRhSLIdu7WEaFWnREnFrLjv0yInUuqO0naS0xJMt4ypcyUFoSvcF9KhFAtgwTmVPoDFaxKOpaKNzxfY7zgXgFxH/9C1PuxjfzyNNjpptYDlntum3ucbkg9D60PnHkzF8NRtJN/7uUClO57kGHKHUixCAUjcgKiPyTWor9tKHy1TCDVTdnOT7V3aPsB4MhX5uvwDfl/NkzSPU0omdJYCFRA7cdI5y2NyHK7NvbzNave9S6rA41x1umNokAlDUoiR6yXD70Ii7L28zcxpFFwZTc6d1aVOtLOc/nBfylmkJQI39bHSutUhU9k1DOJOHoIX+ry4dRDtkpj2+dRmue5TWbicP5YIa2I8y70ORoNONJe43ViMikX9OPF2KtycW3VJ0SPhrXpS73W8uKaLF2lYm/wO4tsuhfGF3dQKQledvDoXgl39fiLKhHmdWumh185FG19bc3zJ9bx1bYDDiU0+1+umFDELkeCkub5iwSnfZc7f78MqIXka8ibf8+2WwRNXdTHs2QQFpWNKnUOpzl8UC0i9jvsFa2s/cRztJyFt+7HbRgpOoypn0qQ+7vrYqLaOr3MoVYmswxiCwDHqBzdRq4XIFdVqEKlqsaXlHhI396VIkudQAmIRZyTcRb4fLVwscgB5J03169DqwOVm8tn9fYLr1DWkuY82hKhWJwSv++5F7Ug3lBf3VtN1MLGzyDtdfDtBwIhdLSFxdiykHIzd7lR120t62/6hz9dLRY90B7c6UXMiDG0fTHBQ/cH3wldZ8EnGkDiU/M5askz2569V7FCK8yUZUxKPysKTf+j0502mtt7l0Ashfhc+/x6SuX/8H+A85M2FsqWuJR+mJR8W1pa7iajj5rZzMMH+4VS0F193Y8L9650vcr5SZArnHdQPD2E8ceifT/QdjbvKTSTzqsh8S5mgsx3nFQqCjBTcgkPI+r4TQadlXGjE6iBPNB47jDTXlVz3LrSk3FMbh3KeWOpm9f19EOfYMZFwJx9ac9FGzy3ly9OwPR/KdSURHn3olEy0D6DOl+TbMBBilxTxWt6hFJLZ+gfZkyvdOBdRJe74a5mKQRt7bsdAmZcgDVczcOtpjBKWVkionYaH+bZlwmv5S38qKBm4+bgcTfF71Ic75c4l4SCq24lD5+Sv/aeV830oIIBMbNOEqSjUbksvT8XHk8tuK/JLicBXC0GJYFVfk0Iy7Vzsce4hH7aXClD1Wojyk8vu+qZiGar1S3PxeCeQz2+UCk1+Pfy4alEicc1IMeXKTp7PqhTyBhTC5AxyJ5LsR4gs8r2nOaE04Uo+DJ2pHAml9nKxzdSCTQivi8PX8tAw92PjoBuLCKnwckFxfZVcQ+3qHlfbUxKKp4JM7OhD3VcaEiWFKG1eK9WGDBcahKFUqAGCg0dzbOWCWBy6FteLRaN43tJJk+eBMkk9TfjSRKO0zfMbudjk70W/nvJvknPuBGEofbhPj9lkrJe3D4SbTYaB5aFetdib7NaWiyx9JQQvFsc08TLdyS193+U7zylilCKApXWloC7HpAk7deLtzAHmzvGhZ0fptxS2ls43FVakSOZFn1JooSY4tcKwqnC7POTN/905t9ZPko2HtlOXj02usQ8rk+sp1+TWtQEubYed2KbTfGxZSJs4Id1lzipzK4XUtVsG50Z9Mfb4/fJsYi5ByRjzAmPMJ4wx9xtjvlc5/nnGmLcaY+4yxrzDGPMccewVxpi7q/++RZT/TWPMB40xHzbG/Jkx5v9RlX+uMebtxpgPVe193Y2Y6DONlX4QkKx1MazdtqmSbgcRRe5aVu/iNg2vZQjccBB2dWu1nIA0tcD2/qQg/sQuqW67heVeu+gMaonXk2ksUqWCkhRbfP4j6WbZEQJFvZPZbr5DW+0SWtJzHQUHjk9KHgtw2tikyDOqRZ5E3BIP8qu1mOX6DiFviftHjrde6/Sc4BhbFQJf3Vcyz9VBIjqJtq8mwpgMB0tDAv08NvfHGE/Cl9fVpU4sYC3nIo2/T64lwpAU+Podd++oYxBCTrgGwbXkw+DkH14vfvn20+TdkUNJuHPWEpFOCk8yn5Qv8w+cvmxqfchnEBK2D3zC+DCva7uH9Tp6YedaIsKsVe63w8k0Ou9gPMVulUjU5ZCKE1FL59FVIShEOYusd0uF8+r3aN85/ORa+fv22m4cMuQFrkj4qMa4cyhFPxlelt9jU6XNVFxzSfRDbqs4NCyM0yfgTl1D12qxzwsm4V7y5xqEfE2Rk2glCEJ+/J22CxPKElQv+y3ng4Aa7ZInrnEQDUVuqTqH0mH0q/+plW6UmNkYU+8GeCUJ5YocYeLLlRODUrFNhqtJwaZbzWMC+eXR7+gm5xGHvMVt+GuUfnnVEmqvLYXk3n4uakJzY3BqGHati69/L0oQXo97uZc4i6ryZGc1g3B/pE6DE0suJDJ2YkmnWNmJJO/nEJIWC4RBgJJumTiMTJaf8MJR4q6pQ/y24lA4f/0ica5aILnDnHzvnKocSn49fVua0AfIsL14TC60rRpTLUqHB9x0F7tcnAptyZC+sH5hHpcUASYKJ4z6kEJPvFZnhnmIWBoml/bjciVJF6Crty5cQOmDYLQDnHi/arulqe4gOZ8ZDqXLOweRqCYdT2kIoRy3FEnqcVdjcM5N317oSxVkmhJlC9dQ+kB7RvSVHZMiovjMNCZOom2Tz4N2yxRD79wYy26a88rcslAyeWw1FnGkYyhNdi1dKfpYfH+VmKI4sNSQt6per+N2UDyf7tBXh3QNMjFEdwvFx7wIo613Okc5Hr9b2/lS4u3RQBE6/FiDAJMKXMN+B0Ox3X2aryh17Eh3YO32kSIfAjIBdubmUcQoefysSPhdEshk6Jl0u0hxQ8tzJOvapN9bqp3cxmInN3/Miz6lML5bk+TVqahzbnWAi1tC1EnFLmWntvqzcegExXnFLPn+kMel4NxK1iwLmRMXM3co2az+E2ny9lRwqnMoxev2bGKmoGSMaQP4aQBfC+A2AN9qjLktOe3HAPyqtfa5AF4G4Ierul8P4EsAPA/AlwF4iTFmtarzswD+gbX2eQB+E8C/rcr/LYDXWGu/GMCLAPzM9U7umUy33YocSO2WDGlD/WCY5hHaEvmM4hxKwcHk30xDIah4Yce/BpDkKpJCTuwM2tyPw58OJi7ZtBdkZJsrfZfrSbqAZJgc0LQTnHBG1eJQEFEOqgS+QHjA24gEk06cQynpp1+5vmJXUydy6EiHkhS3tF3drkkXltg23ggRJnMoRTvBxSF49TkiFKvTdvfBhnCerWaijAynC9dJnhMJMLupa0m6xWRybUTjvJKJQHmYWprrydWLk3LHZUaEwYUPcXVntuUu4hxU1RorYXbBsRO7S+pxKGGL2k6B6Y52vj3ndvGikDvPJYiO1zZa7xYiscGfV2+VLq5VcB7leZBcfiIvRsWiWsuYerc06WQC3H0bJZVuhZCt2JVSjWcrCFxekKmFq5Z7wBwNOsouafGOd14Q8vPJw/UO4nEu92Y4jPzOb/kOaf7cVLxI3Uz+S5LPESQdAieScKZWy6DXcSG12W5cyz0cTmwINW65z/bRoJOHx63k1xSohJJMyAk7uqVCTsihZKNzM3fRilxz2UY3c3XFbYS1iMLYxIOylvDbzyUVD2Ti6UhgW+5F5bLtkCBchMJVgkkaTuFzK7mx2FpgcY6m+GHTO7ekE8n/ONNrtyrhRaxhdY+mSbNrEU84oyDOT10sdfuJE6ndMmLN4oeL00qIH+DFi/g6AXHYWSQcrfRcAmyx2UMk6mzFIlcpIbgfU7pGru/coWSia7+ffR4Yo7twXN4lRYAZBqFFzn3QdZsLXIzKq7WqRIxYTIvFobofLwAkYWVBaAr5ndIHwTS0rq6jJMv292fqagrXyyf5zsWuyAGUjEG6fDRxRXNjnRm6xM+p47ZuT1mHE0tddCIhJw+vu7CVu8XOVCFj/kcSeZ3OjgaqU8od66sPmj5U7rwiGuUhe7F4BRSOHTnEzq+jJv7oApb8TDuTCVjh2FLPhX9q46zXJVszUzwmRbNL2wf1j2TRsUxIiYUouTY2Gc+51UEdfiZdnu5YvxZC8rEGF5L8HKrnuZoLVVLY2dwTO/1NgzswjDfcHyZrN4gMrt9YAMkTXIfjTbvWASJMD7GQ1Sj2ZTmW4uPnqt39pPgaCSfCwVQcV2E9vOAUrm8suuThduEadtotnB0NlBxKcdtPFlxbt2Q5mPKxjacWF7f1e++WtaVEcIqP37oWO5jy40t5DqVnn540l0PpSwHcb6190Fp7AODVAL4hOec2AG+r/v/t4vhtAG631o6ttdsA7gLwguqYBeDFpTUAj88oJwnDftiFrV2JM1vCYTMcdGrByVQCkQtxE+LPfuyK8Um3U0dSy4RE4P6hN03KbUxwRYU2U4FJilS5C6jdcv1I0ULLoQQEMehEMg7fbySiFMSw1G1Uh+O1IEQV6eQJuVxMsmZubFJQqYS8KkTP5/3RcigFF1MQ/4DEIRSFpYW1S/saTy12qvjrILiMheiUilVh5zeZZyldn1QYkuuhiX1+7VO3k28rDZVIQ9fWllMhSopMB1G9g4lz7fjPeJ/kWn7J9TmO/D3Sabdq15J/T6xFAhCivEpXFKfUZdU9lYfLXVVcULVY15IhhkIUUuaf9yuTaIfzTgj3Tep8kaLMqBJwfRJsv34nlroI+Y6qMmUnOh/yNp5Os/FcFuOuHTq1IOPaTMPb/Lmxwyh13CCZTzxOH96WilSufpzA3piqfpSMOhHJWlJ8Ooi+KAXxKa4PhHAc/6XpRB0qFr7UptdE5gHKEnhHTh0hiKz01FAzf5/Ea9NLEnsbLPfa6HVakShlDGLBRjww+zbkA2ndRpr0OhpHLOL4NmL3Uy9zfI0G7h7VcjyFeyqsnXTOyF8yT1drGpLrh/LLMvxOil5a0u8VHzIWxuJFtUjYabkvyieWu7FDCZXAWCXBluuone+dFt55kzuOelmupLjcZuWXtw/E9sbu3/Wq3Oek8n3UbpztWHCJkmwjvFdHlfili1a9LHQRcOLItV2X+Fm+v05H4Whhfl5Iu6hcn/VRHKYmXVBAKoAFseeiKJfOIZ/3SB6rc10p+WniMDnx8C/yLmVOqFHBHZTlipJunl6db0h+Jvc67h5S8yFFolq6BqkQVl2DlThhd9Se4rqK5qQIfk7IiXMvhQfiINb49pD0daES5Pz7Tq6fdEp54S0XtlCThsr5tfW7yp1Xjp1Y7qLXbqnOn8x9JeatupCSY5r4k4pb8v0x6LqcXZpbyq+nFMxiQWRQDDE7O+or7pogSvixpg/+Z7Pd2sJ4RlVYZchJlIxn1C+KLGcrISTdVEGO5/zmXiZqArG7KRUiQ86h/DqvDjrR7mDyevm65zdTx1wYb7wO+ZifynIVJWLUNf2a3rIawrvkxhCAc56tD5UcS8l84zmFtjWxyk85zf2UrkeeBykXZZ64tlf/vdNcPiWH0ulhH52WqUWd1LWV7sTm/u7H10rOO/0cSHM0pe+VW9aWcH5zX+Tp0kPi5A8PcnzPFuYRlD4bwCPi9aNVmeQjAF5Y/f83AhgZY05X5S8wxiwbY9YBfBWAz6nO+04ArzfGPArg2wH8SFX+gwC+rSp/PYB/fqQZPYtYTQUjkVQ7DjcLX8y3hGAinT+RYLQ7jhxJG7uHteAExDuweZeU//CI+4xft5U2U0HJl2W7m0VOqliQWZWC0tTPPQ73S51Qq0tuV7drkcjRiXINlcbmhQCXryU+Z6lKWruZhK9FO8HVSY+lQyjkWZLiTexQcuKcDxf0jiktVC4Vb2Tibi3cb22pG/Xv206Fm3RMa6JtAOi2ZWhZKrQcRGPa3BvXQoR3SUknz7DnQq/0MQQxRrqW/B+g1KEEE5f5D/u4T/elx5g855Rrv2EcJt1JLg+hS11QkShUu4yCgNjkRroi1jKINblb6mphLH5upmozdaGEHFShzCcTlw923m21uSdC8JZC+E89xkzM8m0qu9utuF3iJkLk0ZJ69zttLPfakUgEaCFr+o5wdbhYsqX7yZU0h1OewDv0lQqXQoip5+/m4fIXHUYPQ2lIlBSqUjeNFLXSMWjb0rv1PqhDmAEhVE2DkGMq4edK2l9BsPHuIuku9G1kSamHaRuo2/CuFyvejydX0rC04Aoq7aDmHzL82uXXOox7auPPDlfeT8LvwoNcHJIWCzKasJPmPnLt6CLK6ZXcjeXL0zxSevtVO8OSE6lfiWpp+/2iMOXXRxOOIrGwlbiHkjCjkvh1utppzX8sS4eSds1kaJnm6lFD21biXElBnNKSgodjmnMoJBKP13fQzZN/yzFv7LlQ0TQpvDFu5zPtWl2pQtHkw9DqwIlzmnNo3buNkg0AfHtqSNlIn48/polGXrSQDjI5bsCLC0p7wt01j5Aj28scVMNYbJIPq2f8bmc7s+YVP+idGfZV548/pq27D6M7v5mHWPU7bZxY7qoCz3LPhV9popG/nzQ3TC1uKa4nwAtDJRdScMKkD/iNeZJWB9jc87nLUB0LYhMQhyWWRDO5PbsxLom4lgsqzKMUShfECu1ztN0yLuQNiI65uiHxdipUNIkgxhjnJNrMhU9fdzy16mf46qCDpW67cTe2zf0xtvfH2VxXqiTQ5RxKuehqkmv+ZOb0qcSqGbmIfBifJozUuZ9826m7SXEJpeu1P54mOyHHfad5iOR74KzIU6QJOk3zynI0QR/7k9fKYpi1ukvQH985mNSRKUjaf7Zwo5JyvwTAVxhjPgTgKwA8BmBirX0TnCj0HgC/BeAOAJOqzv8J4Oustc8B8MsAfrwq/1YAv1KVfx2AXzPGZOM0xrzYGHOnMebOCxcu3KBpHC+G0Q5q7rXczcvnSPJfkuscSuL13uEUB+NpJqD4h+vwWhzfOawfiIb9OO/QsB9cT1782dp37hxjDEZ94Xpq5XmZvBiUvpZhdamI43M3xQ6fThICF9fptFoY9jqZSyjqJwlNMyYIEHWdRFjwotnG3mEtbq0udaKH7mW/Y1YSzuYSgE/RMi6nUK/dCjmUWq4vH7bjP6vyULlc6IjzI5XEqm495vBHMXVjdaK25XrIP1ypgJUn+JYus+CkCju/udfeuZMm5QaCeGJMLPj4PzJe6JoI54yavDsJs/Phh1KISddLOoBK40jneW03ODRk+JSf1wkhFoS5pmXBtRVyN+UOpdS94+sOui5BaUi2HcSjq0JUAyBEpqQszZeUhO44ISIVwrS+qzbr8LTQ5snlHg4mU2zvh5DAOF9SLB5IkUi2GYlUimNL1pcPyieWu9gfT7GzPwljEgJNlOhZETq0NYnnGpf5eyESLbJQQunICe6/eg4F8emyMt+pDcm6YyEnDl1Md5CTbVzbPRS5vVC3oYX0hTbicDJAim6xmJI+4Jxa6cblLZHXKhHYohA5Me5TtdMido6dHvZErijZp3BzTePzvfvJjyWUawJRPw7/isQVTWgKYVby/FMrzpET+g3tX9zOzw/jScWTHrYPJnWYRyq4SOHIGDSEnckk27nIlSYEB0I4WHb+Sux0SYUmff3iHeDSXEX1PVcLPfnOd/KYE/2S8pGce1qnnPzb9yMfXHwOqXj+oR9rcyefy23UU/upHU+b+fqvF1xSmgAkj8n8SvJ5yIsyNqkjQ9T8w7x0ZB2Mp1H4f9SeFwPFGi312hhVoovmeHJ97akCVZhXNQ6EcVzbPcwEPiAOlcuOreoOJcBdL7cefs5iLMN+FILWJOKYaCzymFavqU39QdvNoXCsmoPcpbEO9xKhe5n7ZhQe3jWxut0y5bC2JBeSnP+5VSWUrhXG6vrMBfJWJTY8tZHf067dQVXPZveUmnhbPG2eXW0er6+b9uvEszxPklH6TdfX9SvqpkKWEE/qXHShapXPpxx2BsROHTmnW9YG2Ducuu/lijByTuzklta9dXWpHlc9Z3k8EXUyMWttEOWNSvuWDqb0vhoNuljptY8gONlozVSHk1L/SXHcqHPbVa/ns4V5BKXHEFxFAPCcqqzGWvu4tfaFVd6j76/Krlb/vtxa+zxr7dfA3V73GWPOAPgia+37qiZ+G8D/VP3//wrgNVXdOwAMAKyng7LWvtJa+3xr7fPPnDkz12SfaYSk2iHMS75OhZg0n1HtFto7RKtlaodSEJCC2GMM6pxKm/vjSInflHl9qj5t3WcHk6nF9sE4EnYOJ0HUAkL4mj8ncgX1O9gfT7E/nkQCxbWkzubeYbQj3YYioqRiUCqYbNbiVy5C+fldTV7Lc7zIIneYS89pt0xRmPL5qrwQlYo+gBO46l8wRTvtqg4Qix9y9zpTHHOnTqTsPyh9glw/xjpvUOJ+2twbYzyZKiKN7vApiS/SySXHEBwFeYLs1DlViyRLXVhbEKzEQ4YmMp1YjssGXefW0sLbLjeKOCZxLSW5f7ZzN9KVxrkWhKckxMwLu26XqnCt/NyuJoLEiaWuKrT4MDhZd+dggj2xm9yJbB3iBNSlvuuypXTXurxNuT6aw0nmf3Jjd8mrw653ab4kEYamOIxOLgfni+vffQZ1WiZz2qSCmDEQglpYEz+uy4n4dVI6r6bx+qdul5PiOqdCyeWdg8jRtdSrHIbbSX/V2C4l1ybkRcrXIRXs/O5q8v3s20gdNFJci66RDxnaStaoEqV8eHA0x0Ss6Xdc7ptLiaCU7pRmxLhdn4lzLNkpTfZ5ddc5QlOnSdmhJB66EZ+fPnyWHE15++7f9WG/Svodl9cOpSTh7KkVlwftYDyNyk8na5+GCvrQIV9nXZaLOddJthUhpuSCOr3idv2TO1K6ucXCkV+j5V4Hy712UdC5pIW2rcTj9ecP+247dDVXUpWQOncO5TvARaKN4rZI68gHC18nfShO8ztFdZJwuFTs0sTHM6OByK+Ui10Xt5QxJPmV5EO5dzxpdYCCo2gUi1fyQX192IuEnEy8KuRQCu0lbiI5jiQM6OxqMo6k3iUR5hkdG+qOLUCIMcm6+/6ienLeo75IoJ07S7QwOt+fFJs0ISp1S9XHNqRLLD42ntrsc9/NIeTxKYkwceJ0d067ZbKQq0j4Wy2LZnEoXfyZqDmUojWohJ/0/vTHDipnTH5vaCF68ZjOF1wvMtQu3ZFQjsnNNe5X5lgqiScl4UaGxGnzPZeIYPJYCFvT78Fz0bhyYeTWtaViUu7VJS1EUIxb2YEuFbM298f182Tat9ypLb2v6jUrJDL38/Yhd+n75JYsR1M8t1tnuK+kOyt1iz6bmEdQej+ALzTGfIExpgeXKPt18gRjzLpwEX0fgF+qyttV6BuMMc8F8FwAbwJwBcCaMeYvVXW+BsC91f8/DOBvVnX+Mpyg9Oy0IM0ghLi5P1rOHRQerrxbSAokB2OfEDu4gzb2DqPXqSPJHTd1InAgvNHDrm1pmF3lWBroIpVrw9TJxGPRppOJRb4NKYRFoskg5JPybp6t/TEmExvVuSbqeNEp9ONECC+Y1c4UsdPaaNDJ2pBj8ePfiML+UocLkjnGQpBf29VBNxGGQhJpKeilLqt4PKjXJs2PJIWKsOPZQWh7qasKWpqY4+8RV68TJcTNk3nrybX9rmbyi8baUroGsWssFaz8h3ie70kKSuH+1USOkvAk573UdaGNV5W1uKw4sa7uHNb2b00o0sWjVIiDCHkL869DA4UA4kPZriSihs8jJde4TsAtXBhry11c3Y7LTgjXi2+zyR11SQhCvr4PT6udMctaXqHcwVUSN04sK7meFPfLyaxNVP1ruYrya+FdaXl4XSpehb7SB/aTKz23pmL+IZn1YfSgcHIlF6qkmChzA51YdrvqbSeOE+ee8mKdH2+8XX20DkmoWQi51MWgS1upKNXPcl/5ZOSXE2Hr9EoyDu9cqpKUy+T0fp20sK5arIEQasR9Kq9VLiila3IQ3ZtSOIsFvD6u7h5GecPqsSjul1NZSFoQV7ScIHkIm0naz8uv7hzWu576dfCOo/R9eFq4VOLxhJ3TovfDSiz2yLZ8nibNraU7l+KcQGHOoe/0gdnnJNJcUOoua1Fen3gXI79rW+7mciFnh5MQgg0IR49SJ8055Icc9S8+P2WdXLiKd5pLQ68uKqEWsdsIydh6amjVSt8JdGqImhS1RJJ7QOywltRZHTiR7oLYuS+IZLGQkwpAXrhMH97WE7HG1xtWOXi8eBWNT1mLzEXVFCqXfD4BThgKu8rl6xGvu6g3GhRDY6SbSHNElQWsVGyKBZPzyj3g6+1XLrFsLCJ/UC7g5A4l+R5uGeBCFGKWiDDR/MMcz40GUVhfKpq58eQiy/rQhYueV0RN125fdVPJubh5IprnqO9C06SrxiTt+hAw+TfXzxNwwk69RuFwlHg7HfM5kcDa15XIHEup8HaLJvokO55drnIspfd7Hba2URJ9moWucyIkLhWCfYhgOXF25WBqCCsD4usfiT6rS1GeInnM1V9K8juFY37ern4+r/UVl6MpTuotxla5r56Mwv1k38H5pYnMzxZmCkrW2jGA7wbwRjjR5zXW2nuMMS8zxvzd6rSvBPAJY8x9AM4BeHlV3gXwLmPMxwC8EsC3VQm6xwD+NwC/a4z5CFwOpZdWdf4VgP+tKv8tAN9hrfKOIyIBdggNk7u4+RxLPudOmr8odySF48YEMWjvMLhPvDhSfyDXjqQQWiYdS7VoVYe4derxS1Eq3dVt5yBsOb4aOVAQtynaCDvWublMa3FIJrmOxaFNn7y6FQSba1Xo1LDn8unUosoMZ5Esq9egVU5w7edoTOxi8h9Eo7QvsfNa/YVOCh0tKYKlO7EFodHnRwrzghCLDus/TmuV+8ifs5aKOa0QBqflL/L3hA/fkw/oWvjcWiUCHkym0Rjkw2W7Zerdsvy6RA6lVhiDXHNjnEjid/ozyVijEDCf0Fv80XCJomOBYXWpW+c8ahm3W1C/04qcGzI80/8BbRKUNDFKuqCWe2102yaav88jlYZYrVWOGD8WQDp6ZoW39bDpr4UvU5N/p26e4OjKHEqJKOfadI6F8ST8ET6ZCFJ+bd09Gz9weTEsci0pDqfRwIluqTMndSgZEwsM6Vhrx48Xc9Id3aqxLnXbUQ4pwLW7WYVWSdG4ZfKQNy9U+WT/XpwZip3igqCgJwH3olTqronG64WcyuUkf0nttltYHXTqOaeCTeb0We7quXmGQbQzYi0A1EmVTTK+MJdQrrl5ZM4l399Sr1r/rVTE6kdtS4cPIO+NfK3kNT9dCU3pep9ecaFku4eTuP00GXgrtH9lW08S7vLp5ALK9sGk3qm0JBxJwQpQhKOhfv308DJ3H6wtdeMwPymKqSFkLn9TKjL4PsKY4r4vbsZOvdCWlki7j619l+dFFSu3cwEhiFNxW2eG8TVNRciiQ0rkUJKhXvVckgeb4ITK23J1crHEi1B5DqncPSUFKn+v6GNoCClTnDzeoVTXqRr0Il1TiJp3Q0VCztAJOekPBL6e5uIyxgghJ3caAahzNsm18DuoBWEr9JUmAU+FPO/gSR1bcqczPzY5luAYKofYlULXfGhWLP44N17qlvT1DsbT6MctWc/Nb08Jfwr5jsJah3GGY/FnrnMhpSFm8Ryb8v9sH0zCD+GJWAGgDk+T4+m0W1gful3VtD79DnGq20e4m9J269C0QthjHQK2l4/3zKgPY5KwtVY8V99nKjJIJ1AawuyPy4TfUjA6sdxFr9NKwuXEfNdiMTDVNc6t9pPk1MpaXdPX+Za1PnYOJtFmTpLUJZTe38akLh85Lum8yoVBn6fIR9k0O5Tysbmk4HpIWqvl8nvJHEqy+uqSE+JLgtOZkRNZZdLxVPB6NjBXDiVr7euttX/JWvvfWWtfXpX9gLX2ddX/v9Za+4XVOd9prd2vyvestbdV//11a+2HRZu/b639q9baL7LWfqW19sGq/GPW2v9XVf486/IwEYVavJkGN9DW/rj+QjYcdGAtsF2JKjK8zAkUMidSEJS8Q8cLKkD4YPDn+Ddj5JKqBCSfl0m26f9AriYOJd9mnDMpiE7uYTCILW1lnK6NsO29FJ0298ZOhCiEr4Wx5A4tHwaY7uo2Fl+S0/AxL8zJvDzaObJvHwIHAFtJOGGayNq3kwoifq3CNZX1nHA2ngahZnXQjVw+vu3IaRRdBydm+N2WfJkUmfy9koo0XnyRoVJhBzcpfMUCJ+AEs/TLjsyrJMcg165JtHEiSbx+8g9vHSIo/misRX26804sdyNBLJwX+uxUW8DLrd6D4BLnGPKCiZ9Xt10JCCJszc23J8QSL4z0crEmcihV5y3loWx6Au48jNCHsskHV82h5M9NH9BPruSiV93PrmyzepBPw6Eqh1MaMiZ3fvPnAbHI43Ij9TLHVsihJAStWkhIBaFuJvyUEnCfXJZzDWV+rXz9elxJbqnaFaKsYRB44vmmrqM6ebayNqmQ4/MiHUziUCTXRuLKqgSsi8nD98kqnCmEWIW2Qz6bMDYg7JKVPsCnDpZTyy78TAqPQJxzSX5BlAJUPu79au5Jn5ljJ865k52fjnGlH7Ujz5/a/D1yunpglZ/x8vzLlePSJONJ1z0TjoTwpY2zJDSdXHYuAJn7SIbDafmh1of9aPc3KersHbrd0eLzgwtGtj/y4WiaCLQS3Cyyj3UhBEYhZ6MgHGrijJogfRgermV5t93CyWrHNE20ubrjcolpYWUXKiHFCN9C6lDy00xdVZGYM6p2c0vEOe/YSXfAA/Ld19KHn9gBFI87DRX0dTb3x5mY6ccetdcKdQApUEG0N6jXSBNyNAdVfWwrv0dW+h2s9NruITp1SgmxCcq8/LHcMeRFFd2x5ecm+wKCwONFCHn9z1aCyvb+WFmTPvYOp9isN7lB1ObUBmFTm4N3Z0hhQu66lop6QTQSa90Kf+u6bRO5elKhKg71iudYhzMiF8YAn/9HP3Zhs+R86qvuJX/s6s6hen9G4XLJveGPP1USQeqQuL3sPu22Wzi90q92l0PVb9yuT0KdhkEN+y5BexymF8Z8S5TwO/48qEWwgpPnXCSgxfMB0t3U8msHJEKX1va1vSr3WdR05lCSXXcrUbAkNso8RpqL6JxwAVmriFmVCBc2Y8jn/aQISWslg/eCUxhbOGaMiQSrdO7ddgtnRn08eW1Xfb88W7hRSbnJTcCLOT5v0LDfweHEFkLahFtoz+3iFudECucD7s3QajlRCYi/+Lnj1WtlJzkgJPZejRxJoc+ozUG3QehJk4WnoXfpOGzWhjEGKz2/q9s4a9efI3dI82NbHXQT91TssMrD76pcQFGIWUjM7Ot515I2ZylsbB+EX7tlOJt0OKTOJz8HOR6/flIgqd1ZJggw8pdWX+bb9uKNDKeLE2KHNZNJuV1bYq1b0kGU5wJyoWv6GHyZrJfet7KetvOZPG91ySVg3j2YCDGkKxxF4bw0F4nmCvJhUelYasFGOKgOkl83VZfRUjcKMfNrmYpH+lh6Wd3gyIndIqkzTIbbZWUySbh3A4ncT2EdYtFLCmFSbABi8UjmCkrXJ92Nzgsh42m8rTOQ5zA6sdSN8iK5+kpeqIaQvXztdHfQieVe5naQIpH8ruHvmdihlK6LKz+17ASeZvEpjCHNoSQdF1G7letGfpb4tottbHtRIC5PxU5N3FnuOTdfthNeIbdSmrdJlqdJues+E1eUz7lUEliysUS7m+UOmJLDp5SjKRWy8lxGvp0gTMVzKoWqFYSjohsobsd30W65JOrhobXuGusrhQTiw14SCmfiPtI1yuaAut76Si/LoQRUCbPVfEzC1SO2IB/1q53RFHHm9EqvckGFfl0fZYHA7QB3kD28xY6uUGep18ZKrx3EIfEt+/Swh51KUJD9rFQ5z9Kk5H5sPiwrW7MshM8dO1MLZJrjqafmXUp3WJPXwIsWQXALB0MYIaJja0tOlNAEoDT3UiqsuB2wJlF7/pjmNKqPqTsLVuFSG5qw5d0ce9m90uTY8mJMLeIobXphJBXE3DrmQlos/qRjicWfUj0gcQt5AWdzvkTm8t5yYXa6C+ZctXucGmI2ctvaH4yn2bU9l80xHPMJvZ8SoqBJ6hZdUclubdp1LIUFencToLhmRDJwLW+Pd/tojppzSkhhKt6UBbI4/Ct1u9yyOij2K8PW0jX2bcud3GTT/U4bp1d6xZA3n3z6ycK4zq0NalFXFbNWB1FSbqjrpd9ztyZ5itL3/y1rA0ymtg61To/fWuVg0u4fX38ehxMAXdBaW6ocSsjG/myBgtIxZliFde3sTypRwjuQxrXABAQhwb/eSgQk/8b3xwHxK1jiSPJ12kIM2qzD7EIbe4fTyhkUP8S3WwYrvXbSZkeENaWiTR6KBwSRRIovwa1lMuGn1aq2sxcPvqtLunC1sXuIdiuMLc51FAtV3rWzWyWz9m6cKCF4IeeTHF8qMMk5+jr+4X0sQgJWlzpRiIXf8U4LGXSJ0MN6ybZXk/VKzwkCVkcXsITItVaF8zWJU2lImhQnvBiZ1jOiTIo20oEmQ7tc+7lDCQjCTiSciPav7YYE7/I83xYQQsVce2JsisiUuqC820eu7YmlHvYTd4cUz6RYoQlZV1MHVZIDCxA7uk3jPER+rdJ8SX53RnneZbGm3XbIkZOOR3PoSLefH49s0whhUROf0uThJ6pdyzaEqy0TWFramOJ5SidQ7cRSxBzvZgprl7qhXPmplV4mSMlQukgoqHdpy0PCdFEr3r0qC9HzIVXL3ToczLe73Guj12llYV8nM9EjjC1z+mQhgemYy/mZ/LnGmDr/TrTGhd3f8iTe4XyXVDf+chsSYefOpVSsWh100W6ZLOdVEMjiB8pTQ30smbDT8uUhD4/sd5Yz6uLWfvzANSNUrRaI/Pli5zQ5r5VKzEsFqHo9t3KBLghHiNo6veJ30EoSf6djKopcsg8nWqVf1r07yu/YaZJ5u9C6+N6qx5vmMBrFDiV/yLudtIdyvwOc5nby65sLR30hjomHWy8obMTzl+JQLqilAqCJjvmdumR7ZxocT3X+ouTBx+dXUusMw4O1qwPRXk91FPk5aQJQk1iTileRcFCFjGkPq05sEg+M1fXotls4tdxrFra24nvI9dWce8mtR4OAUT1Yay6c88rD/lkxby2fUzimi0ZPKmOJd2uL751Bt43VQUfdpSys575I9h/3qTmb5Hg0cTS4vvayYzKhd/05g7iuDMHTBBgvCMixDrptnFjuxvOMciHJ0DTd7fNkye2zOkhcXOF4Kuyk4wp1c4FD7kpWEoVKYtQtYi1Up85qCB3T5uRDvzSx0Lf9xDV9XLeuDnAwmWabj6TjBpC5BQfdNk4ud4uJrdNwPE3wAar3gSo4LWF/PM2+A8r6T1zT7wPXfzkhOQB8ViJY0aFEjhX+IfpgMoUxQfxx4kZ4yPZCQirUxAIS0Ou00O+4W8K/V0KIm4ley+Nb+y4HSuoWScPXQhvd7HWt6ioiVJRfqBWPQ47LJ3Q2ylx9P2loWtRPJTjID4s4MXXuuJJiTBCC3K50LveUSMqt5F4K6yTFDlR9l91dmuikl+Vj9mOUZSUnkFYm81BJp5Fcs6y/RJxa6rbrXbP8GqwmAmfjGJIwEX9e7lCKczR5THKev1a+bDy12NrLQ+jSPtKQjjWRa0n24bexb5yXJlotd3E4if9AnUhyW/myK+maRC4hf55L4CxFybXovg/t5WOJd2+r57fcjfIqASHMSZZpolwenuZ+JVvutTNh7qTciSwZ56Xt/XotTiaClDamzCG1HR7WfK6iTHxacUKmFBpLu6adWI4/a9K5yu8iPlm57gLKBZR69zKk58YPnD4E7VA4z4ypXCiJYHOqJBKt5PmPBt12vfNWOjatjdPDXv0FU87bb6Eux1zKoSS3rpflp1acCLtT7SLqkTulpYJJKqS0Wi5vVyrsSFEvzllVEN+y+aOeP5CLKMVd50RYmPxSmwpWUtTRyteWnFCmuYFOr/SEe0j0MQxJzjOhaTt3wkiXjixfLziR/E5rtdMlce9cqvsO5d6hc6UKq05dRd6hI7+/y9Cy2AXhkr6n783cUWWStnKR7cxI7syWCj3eBZS0VdU5v5kLMyFXUt6/q5MLBqV8SLHYlde5XDlI0jHIZNOqk6fgULq8vZ+F5Mn23Ee2ydrzgkVJkNHau7JzGOWh0/oqjUP+7QDcLoLDfkfNNyOdLdIBB8QJpIFc9AJCyGMs8MhQvzS5duIYKghDJSHKP+zKZRlWSafPF1xdbhez3K3m2y2JTWdHA1za3q+/m8QijEyurQtj9bHkCdS5hfQcOmcrITQVr2WfTyhhf4BzN5USMp9bDXmS8jxTsWsmvefO1sKO7tQKdfV+Y5dRPh/vBNJEoSc39sRuqOHY2lIXfZFjKRdWRNiaMqc0NEwNWSyIOrckyalLog2g79R2Ll3PVrxeAGoXUCb41H3vNgpO3mWUz9sJTmk+UVn/qc39akdIfV2fvKa/X54tUFA6xqSOolE/zQkUjksXR31+IfzMH49fo3pdiSeJsOPD7FKny0gJ5QptxK+1cbXEuLdFWFI6rtVBV+xgZ1R3zWjQESFk+Y5z2npku7Ep4VX5GnXrNTHGCXVREmyTOoKca8vXLwlDPiG1XLtUmHJlRxWL8nDHtH9/7dL8Rb7/7YNJJtLIto4SPlcagxz7YZKwNghKrmCp65JX7x1O64eQWeuQCh9y1zjtPCkARbmWKhGg7Z0xSz2xaxyyurUIoQhemgij9eudOoAUmXrZF6i4PdR1s7Eo5630nAioiSdaaF360Bb348eo52DyuY2iedfrKAShlRDaKK99r9PKQ96qcJ64n0J43HI3S658stpNzTlCQ5mrH+evOamsqR/r5e2D6IvSKZEXKR1XPl5lR76lLowpJxSW4ahuHL3MjRPC/JQ8TNsHkaPNl19M1iwNVzNijfYOp7WT1uNdJLIN76DaOQiOT7l2Wm4lQAsPk86qZNxbuQvlVCSwuDKfjLoW8JJrnjuLYlEiDW1Lc1xlQlPiaHJOtjDGfHc2V14SjpxQJubVMlFb6fm+3OdEMkm52wUtDZOaN9zO1GuyvtJT3TanV/oFd1SYd3r/+L6zvEtDv/ucLlakc18duDC5WsSItrh3SaI1YQYo52rSBK1UHFLdRsWwLM0dlORkErvs+XmWwtf8NUNx3Plcn9rIr9uZKr+P9r46U1iHlSpxfroTn6/j+mp2/6QPjI25l+pE2fnD+dkqVC495sUmzRHl1+PJa0oOpWSHNNWFtKG5ngbFenHYVnxtvGgU3DnhmDGmdhOpc69yIWkuJJ8YWhNhzq72YW2ec8zNUSbXju8Vv6ua5pjydc9LAUYRFLT3gRdvnqzEgrjVKryscG/EeZLitV3qOReXP2aSls+tuuTsXuRqEl/ccVnXOa5UIbbaSS8IN/F8vAiWOr79/9+yNsCTPm9WKq5Fu8Tl94QXdTRRz7uInqxyYGl1gYZQvbUBru0eio0U4uPSJZT23eu0sD7sFUP5pHuqNC8AeOxq/j7xfTfVDyF1+XvX19/aH2NjN/6R+dkEBaVjTOqwSR0sw378MBq7YAz6nRa6bVPXl236N8OwHwtIvs0g7KTiT9ynJpSk4UmlvERhHvrOcFqb42nuxgpCi+58cufoO9D5fEC+LzU0bSmeTyl8bSNyR8VjkeJMSx1vXFYSndIyY1LRCWrbvU4LS9327Hksxcm8V6qQPyDcI1poWckdJB0+qmijiVMFJ498LQWkINjkgkaT+BUlpFYEFq3uieVuJFoCqHcGjEK1GtxSsu7akiL2KGVaXVU80gQ0ra7ShzFpYmtXfnK5l+X6aRKP0rqA7vBJbc8nff4n4a6qXVMiXM8Y5zhJ2zy57HKbyTbzkLd4XHKdvMhzUThH/I5u2g5r6fx9mzIpfL1+SVLuUijdyWX3ntkTv9C3W6bahSsX0Nx4E0Gp2o1NnltyF51cdg6g7YNx1MaplV7tcEjdRXmy6rBu8kugdCjJe8yLRJFAUG9pr4tm2weTSAQ4teJy1eyIHR19ucyXJcvTEDbXr3fmhHIvNKXnry510GmZrDwPJ9TXK73Pdg5iAW7Fhysma+CFIy2EbX3ocgYB8UOW3+1M9gugzmOUP0A7cfpykjerlI/Jz013QfXVkLf1oRO/0vDFddGWvH+We53KKRfvwufaEkKGdEGt6E4bHyanu4B6dUJq+YxwOnIBpYm0Q1iZJkSc31TEl1FPfVg5k9SJjznhNH0olcnES2KIKtgMhaMommsvqROO1XMqOIo0QcYYUzxWu38UsaIWmzb3cjFidYCNvbH4ISAex0VFrANCUnGL3DFzZtRXQ9B6Hbe+2hhH/Q76lQtvmjzQn6iSXWuOodWBq6eJW/2OC9vSQsW8aPSk4pby63m+5LAZVaJR9Tq9DlcrN1g6Ry8aPaGIWNKFlB4zJuyqpodyJaF0Jj4GQMwzXtdeu1WPJ8vts5oIVeJ4nCcpX79zVWha+p4AgohxXplrHWpXSNp9y2ofh5M8NxoQdrV7qiC8ncvcNsnx0aAWo5IhJyFxNmv7llWXA2tPeR+F9dDdTz7HUikkLg3HywWnpaKjy/ftE1+nx06t9NBrt8S80rG5vh+/WomOWd/NbjQpOOnOrqWo/fT4swEKSseYVDCKhJdWKqqkjqY41CoVZppCy3x997pZlJF5lXJHT/VFPHMKxQ/CnXarzrtkkjq1QJKIZXooWCwypcJVv9OuQ/7kfEM4nu64WlXcUnL8QJXUeRJyQDTlTJK/mqZ9pddDa8eLC8bEQpXWl5tXXE+OWasXdoLyoWrlManXRwgtsky+bidzcW3lZdqcPavJfEaDfNdCTTjx9dyDP/I+NeFMHZv7N+RQap6DmqdpOb/fdJdR2WkVjXnOPkaDTt22XFOZbFuujUweDxTEoxUp0sT91CFzSQJwOfaTyz2MpzbaidCLNDYJ0XDhbUkun5X8WkvXUGlNUoFmY2+c9JXnZjqpXA8vPsk2/bhSccaH3ZWEqsvbeR6mLARN7P5mkv7y8eqhZl4MciGhcs6KYJi4qnwbUjRMRRwv8KUuonyNKlFqs3xNU+HIjyVy4Cj3gCvvZ+P27aRJyX078nPQ938yCqlz5d12C6uDTiY09TttjPqy3J3fabcygdy3f3qlJ8Ic5PjLQpl/wE7XJw2ldeUuJ9LBeJrMtzkheFo+6Lq5pUIT4AQa7bqvD93uWJt7h3HfwtWTPgSsD32y8MTtVDmUJskDkw8508fVz9xlvhzwglYorxNpF9xLztE1VYWZC4r44kPRxkmd1aXKPaXkFFr37qBSCN1mfu/OEoA0gazbbjkXnyZqNeQTcrvqHUQ7zMp6FxTR79SKS6JdckO5vuL3NZDneZLr5MWryTR3RcRhfvMfOzsKu4NJ0cgLPFruKGMMzgyrHdIKwlBZ/OkXt4L34WmAPk4tV5Vs03+myMPSyZK2ey4TjUK90ythC/X0WL1uihvIH7ssxAwtn5HWbi2qKQKXH+/5zf0sDxsQ5zpSBZa1QTGHUtOYAJ88uySeeYGjLIJ5N05SNXLjaP2eq8bcFJYWdoFL2l6L3XeaMFNaj/VhDy0TdvEr9f14KexsdYCLW/L6530/UXBtBWeWPrYzI3dflgSfyKE01e8Dty7NIXWPXdVFvmcDFJSOMaVdyvzr1LEkcyT5m32Y7NpWFn/iPnV30bxhdGkfsQCh5fzJQtyWdOHL19HcV3ki7CYHEKLX/pymnEWqUNLy58ROLj2cLBVmyuPThZp4zJqQlq6fVqYLfe7fJhFlnnNK8zPGPYTU96dIcl2an9an/BAPIlN1H7RMtkthLBS5f2c7gKrz5hV2lpQ8SDNDz7T5l9dyloMqjEVPBp6212rlDi8/FxnyWJyzJoQp4/b9pK4u1eEkwtOCWJG36c+9XAjrkm2mu6mlIohsVyvzY03dQZrgIscrv6yU5nBypZuJFr7dqzuH0UOYFInqOcgQu0R8SnciXKpCUHw+PqPMWRNsZLnfRS110MjQpFSsaWpbltU7tCV5sUoCkQy/08rl3H15Om5fniYlbxr7aUWsc2vQz4QmwOVL0lw8YQ0Q4dcyPVYu76vzXY/K5ThlQvC8/MJWwaFUyMdUSr7d1Hca2rYelSPCOa3ykLMzwz4OJlO3kYc8f6Xs9lkf9tRwmlpQSkQMY0zkhIoEjMrRlSbg73dcCE0aXun7mSp1aveUIrCsN6y/F8iyxMi1A0gfw5WdQ5d3TXlY1AQEGY6lHQv5r/L2NKGj027h9Eqv2B6Q35/ROArOq4PJNNrBV65HEH/yNpt2lXtKCV10bQ6KYWZnVgdqaKMfp7aT26w2z44G6o5zgEygrYyzSqKc5qR040xyM4mq9S53iiOo3XLus/peaaV9lkW6WqhS3p918vGSK2d1oCbl9sf8DmAA4mTfo1RgUda9IecToDu13JgHwuGWjLcWsnSBI4SeKcJM3a++FrdUjrXU7Qm479lrS92i4HRuVtsiV1C6Hp12C2dG/aJLyIsyT8wIO9NETF+/FE7nj5cEp241tscLffswwyev7WY5BN3YgvvKpRxAcjx1QGXDe8ZDQekYkzqOholwMOw1hYrFr0123KivUxdN6ibSEkfnIlRD2JxJE3uXxpW2oYSQ+XMKopMW4tYkmDm3T+wC08dWFsR8X02uIZm/qXSOLsrE9fychv3gNmkUeJK2NUFCcx+lwk2T4FMsS1w/87iRtD7lH5FU6AKCQ0deKz+PWbmRjlrWtNZrijihXcsTmuClijVaHqSyKOPaC2sQ7o/6cF0/LUsTQWpCi56XqSSyaOFhmmjmw9sOo/eV0ca+1It2o0v7ka6hQbeFzSS5+ilFqPBuHVnmz83zRZVEIsV9M9e6VHNYye8Rd243C3vxc/BhwOkY0jaCMygvy+ZRGvNKt7j72+beWF2LUp/p97GTK90skfCpoT4OLzRdE7v/pX2mc9cSnHqhKf0C2yRMab/2n1rpZTmX6nJNXKiEj/RL7akVXYyJxiMaKjuy5PmiXyHeyK5luWxrddBxW8MX8jGF3CKyvFn8SkPbTiy7X73lxglhHrqjJuwAlwuKxujuHDnekpiWiyz9StDKxRwgdrnWx6oQJDf/vE6pH00ASvMrmeRYELuUfhQxROaY0gQUL/JAae8pZU6+vclUEU+E+0dznmnCkL8WmrOidi9picOrY6nzzh/b2h9je3+cH6tDAHV3j7brna93viAaSQFLFS+UpOh5vXwOYcfZvM2t/bE69zqhd8MOcbrzzL2PSo6gs6OwxXp6H6WJl9NjAILzK/pM76PdMkG8ycSdflnYGaUiSTgm8yQ1heGNFXfbuUTkygSU1X5xt7VauCkIHLeshaTo6Vy9uObrpn8sz60OcDCeVpvlIMM7p5pEn8cVIdG37ZOjp2N29ZecS0ib02osumjOKnc8TzDv61/ZOcTuQf5eDfPShTI/tpLg02m3qvtWd26dXO6i12kVQwXPjgYwJjiUNMHrmQ4FpWNMU66htjFotUzmQBolokVZqKn66MeC0zA5P+2z33F5HqI2EoFjNRWxslxPZVGqfp05qZqELH9O2W2UhtKVXE1LXZEzKBECTKGOPEfruyTW6e3E825y/vjXMuwtnaccdxo2NlsYSvvTxu3PyZ1ra6pLqixq6WXxuOQfkeayqn7kWtLmWJ63lt9oXieTllPqxMy6DWsyI1+SJnQYsQbzrp8aRqeNWxHCNAExH3s1zqX8odOLTPLhpC3GHgksK10RAqSMXfytbwrfAmQYnv4grK3pqcID+8nlXLQ5WRADNEFpPoHHFMsA4FSDI8qVifEWhZOCuLacCySlMZ8qiFKasOXKczFl1O8IJ6q+ppFo0SAE1eXiQB3yljwQnx4W5tQgknkXXjyevgi/ytvJHDmF8a8XnEizHFx5v0LUaCnlSpJtKaimbi2t7/WCKCbD51LHQ0lkPDPqZbvwAWE90geDdsvUW8i7/pHVKZVrIksx+fZIn6Ovk4YIu3I3x/Mbe0o/PVwohJQB5R3gQo6i0NZSz7n99J3mfK6kgqiluGBW+i6X1X5BrCmtw5nhoNqxTa9Xj098fvpcQkD+wCbD4dIxekFBH4cMo4uPnV3tY3N/jO1kQwHf34EiQPp6JdHIz22quEd8yJsmYJ1ZLYfteXEC0NxS5WuQi0Z5m5pI41xk/aIr6tyqFNvyPn1+O23dSn22W8YlZS7kSTo7Gojw3nw8QFkA83mSSsLPeGpxaXs/6/Pkcg/dtqnFF63uxa39LIzVr0NproDLg3Rl57DetVvi8zOV6kpRSBNWzjU4fWr3UyF065YkFDIliGi5WLXS72DU7wixKj4hdfnk8wouIW1ePhxPc2YBwK2rgzrcruRwqp1byU1tjBFJw/N73iUN7zOHEjmerCQOJRnSlgpG/nUa0lYn2W4hOl4WnFLHkr4zmmvT19EdSelrP67lXi7aBCEM6rw0d0eWqylx12ihYHmOovjBSeYMykUovU6+TnOGnKnuoyZ3F9Rz4jLf12whatTPcw415ULyr2Xo2jwOIlk3FXxiB9HsekZpXxVJFEHDn+d3M5Nls8PRymNrch4ZUwrJ8vPSxA7F/aP1oQgoS902eu047FW2aaKy/Iu7LnppTpq8zOcFSts8qQg1ej6pZjFFc1dFYyqEb806V1vjo4g52pqW6sv796QiapWcQZpjRuZsisW2ZkdUJDAs60JLSbA5tdLLdrxZHXTrftJzwziar6cbS77+xhgx7nDuPELKfAKLy9s1ntq5xl4UUQoC1OmVHjb38l1hvPMq/dJ81HnJ8DLZ1KyQtzTs7MSSu4ZpqKQbU0HMKolc0qEk5ubHtLk3zn6RP11wbJ1ecXmHJsn1OV0QrXw/ukNIvwf8uLb2x9lDxnoVclfaFS1tCwgCRjo2L4hsH+QPkD7fkKsT9w/ojqv1kUtMv7U/VtagV8yhBHhBMaqCMwUHl6w371yjvjb18LXa6Qe9zfR58HTlPtOSzcfCVlzP7/Ll3IzxMbnjXNpfY5ujfpY3UR67vH2gCmlnR31s7I11sWXkwtPk7rOyXnl+s+euiTSnlnvotIwqNgFOpNHC4Xy7pe3ZvVCludbqULqNsrupFA4lRbXSsScaXDdPbeoiyDmxRul4Wy3jwg0bQt6m1oWDpse6bbdrWVEEE7mONPHkloY1lqKQ7uTpF/MvrS11Mei2yuJbNS4t7NT3XcpjBDjRpiQYnZshZnnBqeyOcs6sy9t5eLQ/flX5Gybb9yFzyuF6zUsOqFvXBsWQumcDFJSOMd122JmrlEQ7z4mkC0L5a3f+sBBaFoSd/Et+SfwJIlZTYm8n2swcd/Vw1zbxvGWd1M2T7nInX3sBKxNVVNEpFz3ka7mznR4GNsMdVb0rm5xOvk633cJyzyf69X3F44nLXOE8Ys7MnEN+TJqAVcirpIlcbj76efPmPWrOoRTWwTtftDL5kBqEJz/W3AE3S/SoxRE1HE1x/zSc58flzptP1JHhYEbMLfQd1kALDzyhlSnjOamG4OXn/f/bO/N4y6rqzv/WufO97943T1Wv5pEqaqAogYIqRimKQsQYNKABjeLwERwawURNWmO6O4nRfNJJm3TrJ6ZD4pTutGk6bbeS0fRgIhpb45QYohFEBimgoKDG3X+cc+49e++19jn31YNX7731/Xz4UG+fs/deZ5/hnv07a62d14993MXGIltuixK+TZLHDms/I8aVS5F3r7v1Q9cGwOfGkXMohcdA2jfP0yVPVLGfG4IYJI0lI1alq5BJ/XltC2JK1kOJomy5v3+nXuk+00WhwVr9SwidEz2RJFv4yZs45kLI3lj3OnHGoM8cSrLQJPWbEXUy5VFE9jELbRURaCyhKeKvB08Aafv3Tdr3yVPGE02kvtM6UlJwrv9GtdRdFIQTpx57+mgiaOWPr2ubLQDJE/+xgVo3D1+2n4FkRbFeyG6vTiqGPPHMcVYMeeqoL2SmYyAlr5bsS/vy7G5nrxnfBgD4ETP5Gy9Qz7Uvzb0UCoeL23OOKyD+pYILN6kPthkUm+I240kvsdseetL3hpvIeGD5wkXICynfe4kTF6IozhHGraqW1pXEnYl2jV0kINtn2keW0VbVDmtjjuUwc+/67drbskIpkeQZxuenSr2bjp/kRYTJgDiTTZ7NCRghESytG/fL1z10xA61d9t95Cnfqyptm1sVFIjHZqpTZ58pQE/U4e4zIPYiOvzsCe83pLddFsI69djbMQ3vJSFnVWyn3/Z0JmROEpxSpO3SCnRp+w+GQuo6spfcUkAFpQWOG4Imix1xgZeE2/VgEryH0pvDrV+vRBlvDr7P/nIoIacO2L8Hqr43TRpKJ/VTr0ReuIQbjscKP4InUW8CQ559rmeP7YUFqx3KjG3Xvsi2z5r0OQJekVAvVqxyPMtsm+y/s3aGvIO6Qh0jOhX2NEoFAyZ0yrWBP2b/ePKEJzeMqlzKetdwdgSOKRDyJnlsERcmFhBWOG+7UkTsuLNiFlvmT9TzhJ7QMQPZsKpwm8NMfU5Ii/edjZ1+/eyLpiw+5YSsZZ6T7qIAWbvc66/37PLtypanyalTe3v7Fh9v2SPKt60UEWuzmP9I8Gjqij5WInFBdGM8juI2wiKdOxka5oRGIQfVSBHhKCsYFBCIuFAy1848jyNvgt7qeWcUCi/LHhcjwrn7dxrl7u+5n9dGsKlQuF1+ebUcsc/suE4iIngeQkUEvIC9EfHlbp22IJgMVHHK+JO+dq2cCf2XbaZZ1MluIyJR2BgLCB6SDSGRJOR1Ndb1GrLLW9Xsypb2trQvw0zeing2cZPVsa6wZW/s1MvegjRuewD8kMqkvUPOIgiAI9RA3iYJKtwS9Wki7B+xYlMiKDHhPnZ/ri3yWLZqZQzUyuIKcZOdGh56gs8TNdmp48gxfzW2dJvEREAUiD1+apkcSr490rGExJnUG0j0mkmSZ5845XuN2e36xzOZEWfcpie7IXzPCGKUPBah40ltzqtrjC+uAT0vo7htZnsghHIqz67B8DFPderd3E/u5lTM4lYyjdsO993NwXWYF/Cmc457elDONwYA00MNPPTks55HbMqyoUbQvsWOCkoLHDf/S1fwSQoGHK+XAUcw8ZN08yKMK7hkPXDajhBRtE0un0/klHlih9BGFFE3CbkkSrn9ZIUfV0DiRaiwbdkHrys6uWJWNnTOH9veC70UquZOAjj7ss8zL+E3k9MoJLa4gk/WpiIrrA02fZvCXlKyDZy3UDjkrWhZdkzz7aiUIu/Ltb2aX/x/1gOn6ymVaT/X0yX+P5eI2vae6bXJeSNxfYe8kSQPpd759yentXLJ85zL9i17+KT9+BNz8RiZc88JQtkQsDwxLS8MTQ7Z6927rBDDjGm5FLHCnyTa5NnLC2CZY8gVMewXIc5macIuhtMxbVs2cx5HzhudJMpwbWfbyRYP1MpsyKd0PIVyLhXYP1vOeZC5do4IE2PpHEkrp8mhebygkOZEcu2P+8gPwxM9kSyRSxYm0j7cd3Gxb0EILJciVlD06+S3lbXZE1IETxoiKuS144lDheo424QQsPGQQCacm3ql5L1TdtsL5UMSRJ6s4BVur4++hHvDtsPeFrJjJPGK4eoFPX8C24oem+QxxHl/pELM4aMnRO8lrs2hZiXzzIPHRLuWWbnVtbXeW2k04m3l2g2JWCFRCIiPk8sxFteVRbxsu5x3SSq6SQLK8ZPGWxEViM9XWsS1W0R8eegJ3+PMreuJJzneOKFxrJaj7nM5X4xitgeEl8FGxUtpYdvV88ri7J4arHuLoBTte6BWZr3EU9KV2DiRGihy3GFBaHowvk7c1WN52xkDFzkqKC1wPA8j5+t1u8aLKlF3f0nsSevbgpQrDtk2wLLBF6XcNuz6bJ3Uw8WZNPa298bC9fCRvLWy7UhClSvgcO1I/cTt8kIQX88+RqsdIZk221dk17E8jXJWxRP798LwGIGNC7Fzwxyr8UpinEBT2IakLOstVETUyivj+gyHhcntlUuRF6LXrJa63irZ65fIbr9d81db43IelSI/DDBrc/Z3bIizmRWKZJHJLivmTWT3ne2HaZML65PadLzVsrZzwo1bf5gZIz4HE+8Nw63SJns++X3JCaf98R8RRK1+wtjy8yJl7BWWqudslnJEibmIGDsqpch7/kr9xeX8ORllxk5qRxJMihxPEaGmWHmv31FBXBkTRJ0RwUuoSPvZ8lAY16goZgl5jArkSioyRoC8ut2YJLQU8Jpxv9BLdSSvHQCZyZnclm8zf13aHlJue1KdfLErLGoEtgnhQbMRSfoReaywRDdPUoGcQNx8rZfLSd7mCiOliHrn1xmLkWZPbHKbDI1hSOAJ5TQKnbOQSGOLRvY2S0xjZuHBPkO2FshZxNUbqJUzH3Y8c4JjFxKNJnI9iXhROLvt+El/9a5KkoBcblceh9GBeGW6YydPsWM/FbC50yijXuHPKeB6Gfnb0/EIefJI20NeSETUFU5Cog4nzgG26JIn+oRs4+qOt2tsqLtrW17b8Xa/frr9KWZFyLj9cP3FjgpKC5y8pNn5+YvCIXHu9jTELXsv+qFlgrDjeTD1Jsjpy21vws2LQa4XTvah4OdZCifYtvux93GPP9S32092n1BIUlqPIruO3Q5/TLY3lOvBE/Jiiv/mRIlQWBo7hgXyF6VlUURWPha3LXecuLYoMC5uiJ1UjyvjPD6KhA1mj8ESnhzRxMrJlB2PesVqPx2j7H5ExHp3SaFTXhkTPsSKTEwZH/KWPWd23ewxZ+vnjfUQ50WT43FjewjJAplkEy/EZdrMTRjtlxXZd0gI5+IETCm3Ul4oYrZtTjxpVEvsi+oI0262DW7MfZuFsZAEEk5IE/flJ/xcUu5wO/5x5olbbjtSziJp4i+tIid6QEnCQoufFEleQp16OSNmO+dV8PoZy/FE8sQWKSeQINBUy5H3wcFtyxduCogzQltFxZnhZtbz06lTRBQRbHPHq5g4ZNcZD4hd4+3+RMZsP/3YUKyOUyljuzs+tXLJy1WYEhIVZiNe2XZ4m8Sk4nEeIf46atfkCf/oQK07fv75r4nX2WgrW8/e1qqVeyKwM14hDywgLMIFw64yoXSupDZZ1EPJ2UhEXQGHFztCYmJAgKnnCDAdWQQpKkbxAolsbymioEddSCCLx0m2OV/8kM95yAsotquYqNOvGFXI7kH5esxu57bljXdIIAVsQYjPoVRckOLqL3ZUUFrgeKu2iQJSXJAnOLUdjxTXG4eIMFAvC0IO/7cf2uVPnjxhx/MC6kdQctu0t1vteIm77X5r5eyKZcnxCPmIwuKWPzmUwuuyzyG5r8w+3op3/ss6t7qZJ0SxYpXdVjYJuOs1RVx/lp22gBIKn+NEIFsgcz3WZGGH9zLyy3jhqbdfyLuGtzfc71DTHg+AD9/ixR7OG4kRGgJ1OfEiz0uL89yRklWHQrPy9uPCIeN9mWNkBIJ+PJw4m1rVEhsmwNXPX62sVyaKNn3lKfKvuX5syPZni2j++c62nS0vl/h8N2I4UY5nVp4XW7yv4KGU47UjC2T2/qPMRLpeKWU+duSPtyR6SSub5SZIdz0m0smtXYxOveLlMkxtFsPkhK/uknAkCU1ikmkhVxEgCzRyWB1v61CjIoYrFRNGeuXlUiTen5JgEsy79JzVsbdJgk0lE/YniTKcDV1xxbnKRlpVUSQJeQaNCYIXIAuF4wPypDPd1q9oNBEQBSYKiVR2eVbEce0vRSR69FWs6wxePem6jY8hmUwza1CFxLTQ8YU8n4qsEAcwAveALIxZx8GJLAWSiAP+MyVPgJk8DY+dyY4sYkwG8mXFdQPeTQFPn35sDoWtcXVHmlUvfyxXF4CXGNtqm9nWqJa8XLSS3Vzf03mJswNjYtnGbK5XSsFQwFAYa7ZtoIjgxJq3qFFBaYHjhqxJoU3p326IXN6qb65AldbJeoL4OZKcPgWvqOwN6YawecJXzZ5Au2F2vB2hHEpw2nXHL79dd8yLCEFcvZ7HEuehZJcVCdlyPcSktl0Bq1+xpYhNbj1ujPi2fBv4sriwFFESRibbCeR5I/XaD3vxhG0L9pHZccgZD6DnUZQnCvHeSMVs4T2H0glssTK/Tf/4OKGGs1tKBs29lHDCFzdp4vJWSX1xiavjHEiM51LA68qzlRFouPMRl+d5aWXb5cc1bdIWu/j+uDbkHEp5YpA/Pl75LLyFQh5KrPji2cdP9vKEJq+cETms5OiZfYcyXpjSCmayMJXpUxjzVjX+wOGWRxEFcklJwork2RUObfMFKF5Es8bC7bvFT/xHJQ8sQWiKV58Lh6NJx8Ftkz2EquAYbFTEiZkkpAQTX7f547T6ccPkAp4phcLNhG3uuQmJJGHPoIAAJNTrNDK5ziK+L24+WcyOUD1/Wy/3jr8xlJdnosB54cWWIscn98eKaSE7gyvEydtCOXxyhbHAcYTC5XITZHfFHX9jSJwJeQBm64bEsdnUnQxcW0A4vKuolxHXcpz8PCCSBXJV5dkF9ISVfMEo3HeoviTYTA+GbQt5ONXKJXHxCSD+2MItttK1fTAsSC12VFBa4EirsHVzKuWsAjfg5EhyBadauYSq8wLbrlVYMcgPW0q386IWJ25Idkphcrb4wq/QFnWPJeq+pPiCGm8rkJ/0mjseLyyOy98khORZXj2N8DFxZWk4m+sd5LbtJ7vOb5try13ljms7Lcu+HLZr/sp8s02Q3W2fPb6iZVyf4f26XkHssffqciJOHAJo/+gU9SjqiT1+XU5YyTsONqyO8ZZqVUusJwSXbHsw4KFEjD3u7y83QWbHh+nb8pqy8i1xXmaykOK+NHCC1kCtnBkTv10ulM6fxMveb14bggAXClv0+5O9p2QBxm6jK+QJ3lrZZrjjs4/Fbjv+wu3YIQhsstdXnscVf5zeWAk2cu3Eq8v5+9fKfLLjeqXk/WYD8fXLeTASxflepJdd7rgkzyIu3BCQPb6k9qWQtyggQEgCkbyamiwUSDm08sYjruO0JXjMdMU0JtRI8p6SbM6ec0nQcu2Komw/fB1ubESBrFCCbb+9vPxK/Yo144LQEQrhCnviyJPFIvVCYkO/20IeUbO2pYAQxbeZ31+83d4WmtzboXtes4W8a9hjDAhVI82quAolkB0Dzh5ZcKuWI/E5ma3LbSu68hhnU8iLyO7X35brZVTYk+d0jkmwOyDajLSq3jwsS56Xz1RArMraLglOhceFaSCKKHjstiAlGLCIUUFpgePlQMoJP3Pz5hRLMG2LE23mb65PSbSplCJMtGvWhMn3shEEpswV265XHDt4ESfdh4g8W6SwLyvZdwFxyxNwXCEoEPLWE4vyhak0mTM3Ibf7tycjbJ4npx4bIlYgOTWf44gXx9wJR9tJIs/1l07QeMHKtivbfqMSJ8PmvJayA9iv6MKXZev6kxJJZHJ/s/jjYrxiCgpPgwGPGlsQKubNFXvuhLx0fBstkYpdyp3/Aea8djiBRPL64fMtyZ5A7u8/G5KY7gt+TCzvoEAonXysvfJ6JV4pzxNyJG8fpr98ryPOBrD7FvH0sTylcsYdkHMFDTNj32mUMwk3e9tGJE8byUNFWsWsX8+lPpKYZ+3sp33ulXRkoMoLK9IKabkhfvYGMYeS2H4ohEvqWxB7ckQr7h1dDBMTPDaK5AKS6rCiTTssQnGTJukr+Gz6KSQoRXwdwPdAkJKZA7I4FAojCYkgIUFmTKg31IjDO8P29WlHyLsnIESEBAwpFBEo6tnE1ZulJ1UgIfVEKNG1sIohkCarDoQPBb2QAtuskDd7W+xZI49PERGLe6bG9uZ77HD2DmRzWwXEGS5McThJpi5pD6FQu6yXEXu8AVEHyAor/raJtpznCygi2sjniIi6njy83fL1GPctX8tx37MX0uL6jaR9dnPGA4rfHvKAWuyooLTAyUuy3RWQkh3yQsualRKI7JttoGaHEq0dH7BUZD+xdzj0DADuvm0vXrdvbaYNW5RoO2ILt1x4OzeXU763iyRcBT2whPAx+2/ZOyq1b7xdQ7UcoZTs00pWQguFqkURYaBWdo6JDyF0J3rxPujVcz3HqqlY1dtp+8wQNkwMWC+gvtcUs8obM0ZTnUb3eu3a5YgBnDh1zbZp/MJ1Wy1XWW6/1WMtbwWf2Cuq19/yoQZuu2w9Lts07tnKea1wYkSpxI2rX8aNf7ZszWjTsjfuV/ZUyfO04ryl2JXWuFxLzIS/XY/DLNLrNmRPKGSL76dX1kpWwXNfTjiRi1sKvCuwOL9m3L58XidZkJIn/3DK+xHkKp6tshcQY4Mg8AwznhrDjNAVl/vXWbUcJcK4dMz++Lg2lyJiz5vkXSEnAq95L2RExHqNSW1IKzdx45Qt52yJ97fbGW1VvedlvH+fQpMUssWMQdyvXB6yv6iwJh8vL040qqVuXj1JCPL7FoQJwaOmWS0n4qp/4JI4I012Qx5CotAV+Oosew7JoRN5uZI4sSTP24i7JqRt9UqJfafK1gmNtXvN1ytx3pSweOZvC9oujFGcKNv3YLRt99srEoIWbpPZFhKNAqJJdxuzsVjomlwvLDbJ27jt2VxI/NjIk+dQnqSeeONvC4XSZdsNClXM/RMac6tuwCbRIydHnJG2EREmOvy1DBT3YOI25wkroVC8SikSxfUidvW8iNjNQTFrrFWLBWOxbk7bObblCULTBY9NFrTCgtRippy/i3Im0/VISu4uX2Diw7O6wk3Nnhz2BIteH64n0L96ydmWDVJ4Wilyt/caybpUZuuk+6QTtDQhtrtqGhALAUeOnfTtcMQzso4ltS0u3DDRxnCzgno17Sffkyd9GGaTfHcaFRw/ear3N+Md1WmU8ehTx7p9v/KCVdizbhTlTK6AoWYV1YxgwYo19YrgQWXb/NTRE8F9XJEpighrxlrWudm5Ygj33H4JsrhiUbkUeeGHnID11is24OY9q6y2BhsVfB/PdI+PtbNZwU17Vnv14v16ZR+4fgdcOo0KTp4y3b+jiHDHVZuEtnz7s+1fs30axgDLGGErz1OIK7vt8g143cU9URUAVo40rbChvD7IGSe5X65ub7+RZHJcT5bzBeJ75HdefR42Tg5Y9vBhZ8U8utZPDGDniiFsnm53y2Lhr4qjx3v3MpAVPbLHwwlXfDhVWOTqlXWS55vvCeTnuJISRnN9rR0fQETwzicnEomiVquCRw4fLbYvlwRcEoMC5ScyzzF7X6s4KJAcOnLcHvc+cjkBwEXrR7vCdZbRVhWPHzlWqA3Js0r02JE8lwKeRSFPIUnAkfu1N8yMNHDilH0u0v25SZEkTIn2zFF5uu3IY8/IIpQgtkjhdtzb+OiAEOoneeEEJnKjA1V26WdJtBkNTK7yVmYLeQ65m8aFHEp2P/xY9lMnte/wsycYG/I9eSRR5vCzJ9jyuD2+jmhfTl+cfZ162UvRUKSvoNgUEPnCYWb54k+/YxL0Xgp4IfUSrfuEciiluZAePnyUPf7JTg3ffLB/ESY0bsNJKNfxk6bvdkMiyWgrXlJ+NqJQyFMo3X7fo08LHjU5OX06dRx6+hi7LS+0LOQN0xVtBLeRqUH5mk/rP3L4KNv3VI63V16OpViUOcS2nYaV/fDJZ9m6eYLP9GBY0MkVuwrmaMrfLo3O4kUFpQWOm3/BFV5ycygJYVbZB8F1O5dZ4UYl505ybeC8pFaMNLBytAEJ17vo8s2T+M1X7sK68QHHzl6d4WbFmvy4njrDrWqcaynjFeOKTAe3TeHA2VPdY2olXjr2hNMW7XasGMIfv3kvti7rZPap4FBmotMVXSJ7XB996ljv3NTK2D4zZI3Dh16xCzPDvXGaGmyAqHf8adshwQuIRYgfPvFscJ+zl3eweaptnevPvGUfKqWw46IkTvEeNLbAkIoM0n5NwVvFhRMrGtWSv1+jgsePHC/YVtj+Tr2CV5y/0qob9h4ir8z1CKmW7bG+ec9qXLdzuVV2zsohbJnuWNdxOlGoZepzOZTSSWYls9/yoQZa1RKWZ66zwUYFH7vlfGxbPmj1vXfDGFw4LyPWc0hIyv1Ht17ktTncrOChJ21Baajpe4BwAlmjEud5cy8Z3pvJH6MoIi9cEgB2zAzhWz887LQpeev47Z67ahhf/rkrrUTmQHxOnvHEM15sGE7GwCrLyWnECYqF8yK1qnjUEbAkD6Czlw9i5UjTe16MtKr4x0eeZq/DomLKT120BhzDrQqiR+19K6UIL96xDLtXj9htCxPtizaM4Za9a6znt21jsbFaPux7XNr7S+3w5e7YvOdFW3H0hH2dAMD+rVNWCHXKlukOJpmv3VuWddCul60PIACwZ+0YDm6bwtrxllU+JohAA7V0su51jdFWDfcfekYUiNw656wcxvqJAWsya/ft9zE2UMMTzLNcCoeTjiNt63s/OuLZK3mcdOplNlQVkBNph5IS59XhPX349gZq5SRRO9NPjpfUfY8+LYbDBcUVwb6nj/rX63i7hma1ZK3cmd0m9hUQT16wegRHjvniFVG8bPjRE74QOzZQQ7te7j4ni/ZVTDQK2R/axok/+Qm0ubnq6tEWiOzceykzww1US5H3/gXE7+f1SoRnj58Sj/9hQVgokpspJNBw29JQrgcefyZYlxuDVEyoMe+w6ZLynEgPZD2fZKEqz1MoeKzCa/Vkp45vO+8ZKVM5QlZItBxqVkRxNWuXJPpMdur42gNPBATdkGCUJ1Ylz/2AqPPwYV5QGmpWUK9E3jw0JV9wyksoLocoxrafXkjdYkYFpQWOm6vGF5BsIcZ19S5FhGa1ZD2wpgbr1o//LftsLwqXvLCxKCL81TsuL3gccZ1qOcLBbdPd7aXID/V6x4HNvIdSsstgo4JPv+lCbJjoeUO4/RARMg5B3bw+rpCQbReIJ1OW/Y0Knnz2uFfHD0MLDgP2rBu1/r5i8wQ++7aLrRDD68+dQSPjSbJ2vIWRVhUrR5rdst2rhi1vk4l2DXfs34gXbpnslr101wxeumvG6i9bR0LK2ZQ91k1Tbdx51SZcvHHcrW7h5pEiIrz74Fne5FC2ITygQ40KnngmLCi1a2W8+sLVlq2cUMRxwdpR/PiuGesaK5o7iKNajqyEqQCwb8M49r3VHsert01hoLYbM8NNa7/br9xoiUI7ZobwgZftwJ61vetquFXF3/38Vd4P6oXrfPGIg/NwGmQEkc1T7URIbiKPoWYFjzxlCxkXrhvF9x87YpVxXidElKwoZR8Pl28pnSy5Qt5ws2rdvwBww3krccN5K739ANkbRrIhy9v3b/QmPKLHEOvN5Ic2ArxgIeZhEgWsCh572j4PY+0qmtWSN1G5dscyXLtjmXd83Bg1KvHqZO41tyJ5ZnETHQ4p3OvXbzzHK5Pu4U69gp990RZv/9xQNaehW/atxYu2T8NFWlWtW+5MLKRcRvGY+ONy4Oz4I4jLy3bP4MfPnfHsvGzTBL76nv3e2E8N1vGbrzzXa0cSaIgIY60qjmc8PlPGhLxOXYHEeTk/e/kg/sTxfAXij0LxBwW+Lc4DRupDyjkEyN5oMyPx76wrvhFRcoxeU+JS9YONCrYu62D9ZNurI3kOpau5hUQI93hi22p49jgv5nD92Nvs8pAnWreOkL/IfV4DcaLaz77tYu93DchJeB3w4vmX1/r3b7beDx5/xiuvliP86dsv6YZ8830xdgzIE9CNU2106mXrdzhlItBmkVXX+vV6Wjs+gM/feZn1QTJlqFnFPbdfjGVD/jaiWMD558eOsEvEx30+ydsaFI3k45jq1NGo8CIjEJ+PBx73Beq4T7nd3auG8Rs3noPz1vDvj5OdGn7wBC9UTAY8vNJk4NL74GQgkXOeGLVlWQff+uGT7LbQtQCExQsiwmSH9+QDiggjct+VUhR/mKzx84VeWJrUds72Th1fE7YRET74sp2e53xKKNQUALbNDOKyTePex9OebUVD4vjt6TysXll6GYVUUFrguAKSF/JWk7b37obhZhW1cu/B8Fs/uQu1Ur6wkOKv+uV7E+XBhadx+2Tb3Oi8qHE5AVwPIClvQJZlQw3rh47LAeVy62Xr8HhGuHCFPIBf1SuPKCLvOF+7d4319/RgA1/+uSutsjdcss76m4hw2+Ub+upbgss51GnY3mKliHDrZetz20qT+GbberXgnZBl9+oRXLxxHKvHwmLFlVum8M/MS24WIsJ7X7zVsyvdFmJsoIYPvtwOtWOTdzMi3OlQK5cscRCIPbTecoV9jqOIcP25tmgI5B9XiG54W+ZguJC3FSPNXCG5W58RTvZvncL+rfbEWRJ0btm3BqtHbU8LTsTbtnwQH3rFLuxdP+bte/ioP1l1aVRLGG1VPQ8RyWuIgxNL140P4LbL1mPfRtuuNM+aayvAiEGCIBLKBeVeBxsmBvCUM2lvVsv48zsu9UL3JDhhi4iSEDF7342TbfzVO/hJEAcXhiiRrqxW9JmbiltDzrmVVhEbqJWxfsIXC3bMxJ5bzar9eiWukhZIbNsP7scRd1tRmtVS4vHCCDEDNTzEhCKMtmrstX/NtmkcPXGKDV+U7JTauu2y9XiMCQ2RvHCa1TJ2rhhiJx5jwqR0z9pR/PGb93q/uUB87MdPMiGIggATRYT//pZ9/oEAWDPWQrUUeV61vePnBLXkOmTaG2/HHmJ+nZDHE293rVzyPI67/QjiHQC8bt9afG8r/1u7YoT/nQ4JOeuTkOFhRpQPMdGuWd7Z9rY6W96sltGulcE5Z4c8jZYPNfDV917FtpkKCRXmpiySeDsopghzVWmcAWCV8/to21rDPz92RPDOke0JbQsluW7VyviTt1/SvZ6kdnnBLZyomvvIka0rhVKF8vpEEeHs5YOscAj0EolzdTv12ANMer6/4eK13jt9Sq1cwrU7lmH3qmF2eypeNBnvfCCeG5xkPgAA6HqoS8LHC1aP4N7vHhJ/b+96zXmiIJif+DpHlBltdhOdc1zDfMhJqZVLyUqofOOdegW/81PnifWnc8Su6aFwDqWrz57CXa85L3i/LVZUUFrg5CXldnMmxTHRVUtZ/nevOMdKDiz96Eq4fY4P1PCug5tx1Vb/K6rEhetGcdXWyWDfbSHpYwrnSeS3kb/P7732fOtFj0sw7XLOSvuBn076ypmO4lwtc6QozCOcOHLrZetxnHEzz2O4VUVFejsKsHyogbteI/8opLghakWpV0qoVyLr/BVl18phvOnSddi9undNDDKJsBcqnOfHnnWjOLhtCmvGZvcjOtKsii7MWTixDgBef/E6b1/Oa4iI2JeR4WYVDzBftTn+6NaLrKXS4/rFPNAkSpGf2wuIJ2kvPMsWDuuVEvauH8OWaTtka81YC7Vy1M2Ll7Jpqm0ltAeA7TODePGOZdjhCO4/fWAzThr/BTS7fHQekrfVipEm+wIamgS5vGTn8q7HQBG2rxj0hEaJdeMD+Is7LsUqx6NOCnmTuOKsSVzhnDOg9+W0VvZDBPtp/7km9XjhHssjraqX0wsANk+3MX2fLwquHmvh9is39tX/6ECV/Z3fsWKI3z8Q2saF1wLyanJE5Hkfp0wP1vEQc+yhEDGJa7cvw3lrRtj7YeNU21pdKyUv3IzzyikSdsU9sqY6dU/IBoBdq4Zxy9411m9byo4VQ+I5kkhFZs6+PetG8cV3v7DrwVeUfRvG2PD3PN5//XasHffFx0a1P2E6ZcVIE7/68h24YrP/LAjlNAqds6FkVbC5fo8Ih+7J4kAoKfdZ02285fL12LeB91JfznhLpYS8el541iRu2bummw6jH/ZtGLO8+4v2CQCfftOFwfCwGH977ClUF4WZcilCOXC5/gbjfZty1dYp/Oc37hF/Q9918CxWBAeAmeEmfu+152H3Kt6b67qdy730C1m4eyVlOAm3k4455P0EAG+8eB2u3S4Lg3lsnm57C94UZWa4gSu3TGKXIOLlhdSVS1FuZMZiRQWlBc7YQJwRP30xGWpWUS1H3S+CjUoJe9aOWvkiPvn6PdaXAVcM6Rc38TcRsRO8EOsn2vgPN+0O7jPa8r/WZ+kU8CTaNNnGssF6cB/XNZvzNspjZriJ91+/HVdt6YlqnUa58Nf1M5n0y2b2pe2SWT5Ab7pgFc7p8yX0+eLXfuIcbJryv1TnUa+U8I4Dm62yZUP1eAWsgqE9ZzJTgw1EBNQzb0HLhhps+ExRbtm3BpefNZG7X6deThJr5rdZNGwRiL/W5XmypXAvbytHmig7+drmgqnBureAAQD8/i3ne2X7t0ziC++8wgsf+/BN53ovP+16hQ0TK5ei034pGBHC6X7zlbtmJR5n2b16JDccNsvHbrmgr/ZXM4Jo+mI6G3E5y4Gzp/Dhm871vlym3jJFBNXnC1cwTVk50mS9P161ZzVuumAVU6N/XrJzeV+/k2MBYWQu6/zci7Z4uc+A7MpsxRuLIrLC2LNw9ysQh2oc3DaF7St8weus6Tabc2S0VcVQs8KKMi9YPYIt053uh7gsH3jZDjSZcJZ6pcSGi86WUkQ4a7pj5fPL0q+YBAA37VntLeJRhKu3yV4P4x3eay4PN6VASqtWxp1XbcLlm/3fvFq5hOFmBWXGs4mIxITkp0MoNDL1Fiox2y5YO4KX7FyGLU4+OiD+Lbl9v/+RpAghcWekVZ31NXjzntW4Wbg28kKlQmO+d/0YbrpglZeXL2WyU2e9K0+XUkTB38OdOe/Wkth3uqThdpLosmmqg/PXjIjjxeVb7YeP3Lx71qJrpRThIzfLc9F0zp2TanZJooLSAme8XcM9t1/SdX0cqJXx2bddjGVDvbjvT7zefqleP9G/sh9ixUgDu1YOsT8qc8m/eek2cVUBIHaTPLhtCucKyjIQ55l42W7+R15iw0QbtXLUt+fWy3evsO0bac1aNT+TuHjDOH7/tedjExMW0C/LhhpsXP+ZAJenZLZMDzbwl3deGvwqt1C4bucybJ5qdz1R5oINk21sKHA9ERGu2DyBbY5nDcfasQEQ+auscbx9/yY8XSDkTWL/lin8xZ3Fw8KeC4iIPSfl5/nNZ9vMIKYH654tC/XZNzPcwPuv3479W3xPg36olUteCCcQe+e+59ot4hfR+WD9+ACbe+7OA/x9EkUEPy3+7HBXvsxjsl3DNdun8YI+hMb9W6bwwKFn+noeS14Ay4YaaFRKc3Z9S3kM2/WKKNq/9YoNeDMT0l4uRfjLOy5jc52cv3YUn3krH5K3bYb30nou+G+37e1LjJsP3nX1WV5erdMllBLgV67fIV5vZ013uqsgzxWbp+LVjjnR/Jpt0zj87AmsGOFzM/3aDbIHzWy5bucyRESFQ2XngtFWDePtWjekrh8GmxX8grP6dZYL1ozguz8q9sFqsbB1elAMpxuolfGpN+x5zvp2w83nklJE+MDLdoierEsZMox7+0Jj9+7d5t57751vM5RFjDHmtL8KHT95Cs8cP8l+EVQUZe557Olj8yryKMpCJE3wXGSRBgU49PSxOO/QGS6MKAuf4yfj1djm0qPx1CmDI8dPsqtWLiWePX4yDinU+/i0OXbiFIiQu2q0srAgoi8ZY1gXrqX99FCUgsyFi3GlFOnDVVGeR1RMUpT+USGpP+bSW1NRQjwX75BRsoryUkefe3NHKD2JsjjRM64oiqIoiqIoiqIoiqL0hQpKiqIoiqIoiqIoiqIoSl8UEpSI6AARfZuIvkNEP8NsX0VEf0pEXyWivyCimcy2Xyaiv0v++4lM+RVE9GUi+goR/S8iWp/Z9nIi+gYRfZ2IPn66B6koiqIoiqIoiqIoiqLMHbmCEhGVAHwIwNUAtgC4kYjcNRs/AOAuY8x2AO8D8ItJ3WsA7AKwE8D5AO4gonQpsN8C8EpjzE4AHwfws0mdDQDeCeAiY8xWAG+b/eEpiqIoiqIoiqIoiqIoc00RD6XzAHzHGHOfMeYYgE8CuM7ZZwuAP0v+/eeZ7VsAfN4Yc8IY8zSArwI4kGwzAFJxaRDAD5J/vw7Ah4wxhwDAGPNwf4ekKIqiKIqiKIqiKIqiPJcUEZSWA/h+5u/7k7Is/w/AS5N//xiANhGNJuUHiKhJRGMALgOwItnvFgCfIaL7AdwE4JeS8o0ANhLR/yaiLxDRASiKoiiKoiiKoiiKoihnDHOVlPsOAJcQ0d8CuATAAwBOGmM+B+AzAP4PgE8A+L8ATiZ1/gWAg8aYGQC/A+BXk/IygA0ALgVwI4CPENGQ2yERvZ6I7iWiex955JE5OgxFURRFURRFURRFURQljyKC0gPoeRUBwExS1sUY8wNjzEuNMecAeHdS9njy/39tjNlpjLkSAAH4eyIaB7DDGPPXSROfAnBh8u/7AdxtjDlujPknAH+PWGCyMMZ82Biz2xize3x8vODhKoqiKIqiKIqiKIqiKKdLEUHpiwA2ENEaIqoCuAHA3dkdiGiMiNK23gngo0l5KQl9AxFtB7AdwOcAHAIwSEQbkzpXAvhm8u8/QuydhCRMbiOA+2ZzcIqiKIqiKIqiKIqiKMrcU87bwRhzgohuA/BZACUAHzXGfJ2I3gfgXmPM3YgFoF8kIgPg8wBuTapXAPwVEQHAkwB+0hhzAgCI6HUA/pCITiEWmF6T1PksgP1E9A3E4XF3GmN+NCdHqyiKoiiKoiiKoiiKopw2ZIyZbxtOGyJ6BMD35tuOOWIMwKPzbYQyL+i5X7rouV+66Llfmuh5X7rouV+66Llfuui5X7oslnO/yhjD5hlaFILSYoKI7jXG7J5vO5TnHz33Sxc990sXPfdLEz3vSxc990sXPfdLFz33S5elcO7napU3RVEURVEURVEURVEUZYmggpKiKIqiKIqiKIqiKIrSFyoonXl8eL4NUOYNPfdLFz33Sxc990sTPe9LFz33Sxc990sXPfdLl0V/7jWHkqIoiqIoiqIoiqIoitIX6qGkKIqiKIqiKIqiKIqi9IUKSmcIRHSAiL5NRN8hop+Zb3uUuYWIVhDRnxPRN4jo60T01qT8vUT0ABF9JfnvYKbOO5Pr4dtEdNX8Wa+cLkT0XSL6WnKO703KRojoHiL6h+T/w0k5EdGvJ+f+q0S0a36tV2YLEW3K3NtfIaIniehtet8vTojoo0T0MBH9Xaas7/uciF6V7P8PRPSq+TgWpT+Ec/8rRPSt5Px+moiGkvLVRPRM5v7/95k65ya/Fd9Jrg+ah8NR+kA4930/43UesPAQzv2nMuf9u0T0laRc7/tFQmBOt2R/7zXk7QyAiEoA/h7AlQDuB/BFADcaY74xr4YpcwYRTQOYNsZ8mYjaAL4E4CUAXg7gKWPMB5z9twD4BIDzACwD8CcANhpjTj6vhitzAhF9F8BuY8yjmbL3A3jMGPNLycvjsDHmp5MXzzcDOAjgfAD/1hhz/nzYrcwdyXP+AcTn9Keg9/2ig4guBvAUgLuMMWcnZX3d50Q0AuBeALsBGMS/FecaYw7NwyEpBRHO/X4Af2aMOUFEvwwAyblfDeCP0/2cdv4GwFsA/DWAzwD4dWPM/3ieDkOZBcK5fy/6eMYnm3UesMDgzr2z/YMAnjDGvE/v+8VDYE73aizR33v1UDozOA/Ad4wx9xljjgH4JIDr5tkmZQ4xxjxojPly8u/DAL4JYHmgynUAPmmMOWqM+ScA30F8nSiLh+sA/G7y799F/GOUlt9lYr4AYCj58VIWNlcA+EdjzPcC++h9v4AxxnwewGNOcb/3+VUA7jHGPJa8VN4D4MBzbrxyWnDn3hjzOWPMieTPLwCYCbWRnP+OMeYLJv7aexd614tyhiLc9xLSM17nAQuQ0LlPvIxejlhAFNH7fuERmNMt2d97FZTODJYD+H7m7/sRFhuUBUzyleIcxF8iAOC2xAXyo6l7JPSaWGwYAJ8joi8R0euTskljzIPJv38IYDL5t577xckNsF8s9b5fGvR7n+s1sDh5DYCsx8EaIvpbIvpLItqXlC1HfL5T9NwvbPp5xut9v/jYB+AhY8w/ZMr0vl9kOHO6Jft7r4KSojyPENEAgD8E8DZjzJMAfgvAOgA7ATwI4IPzZ53yHLLXGLMLwNUAbk3cpLskX6U0/niRQkRVAC8G8J+SIr3vlyB6ny9NiOjdAE4A+FhS9CCAlcaYcwDcDuDjRNSZL/uU5wR9xis3wv6IpPf9IoOZ03VZar/3KiidGTwAYEXm75mkTFlEEFEF8YPnY8aY/wIAxpiHjDEnjTGnAHwEvfAWvSYWEcaYB5L/Pwzg04jP80NpKFvy/4eT3fXcLz6uBvBlY8xDgN73S4x+73O9BhYRRPRqAC8C8MpkgoEk3OlHyb+/BOAfEefReQB2WJye+wXKLJ7xet8vIoioDOClAD6Vlul9v7jg5nRYwr/3KiidGXwRwAYiWpN8yb4BwN3zbJMyhySx1L8N4JvGmF/NlGdz4/wYgHSliLsB3EBENSJaA2ADgL95vuxV5g4iaiVJ+0BELQD7EZ/nuwGkKzq8CsB/Tf59N4Cbk1UhLkCc0PFBKAsZ60ul3vdLin7v888C2E9Ew0mYzP6kTFlgENEBAO8A8GJjzJFM+XiSpB9EtBbxfX5fcv6fJKILkneGm9G7XpQFxCye8ToPWFy8EMC3jDHdUDa97xcP0pwOS/j3vjzfBihAsgLIbYgvohKAjxpjvj7PZilzy0UAbgLwNUqWEAXwLgA3EtFOxG6R3wXwBgAwxnydiP4AwDcQu8rfqis9LVgmAXw6/v1BGcDHjTH/k4i+COAPiOi1AL6HOHkjEK/wcRBxss4jiFcEUxYoiYh4JZJ7O+H9et8vPojoEwAuBTBGRPcDeA+AX0If97kx5jEi+gXEE0wAeJ8xpmjCX2WeEM79OwHUANyTPP+/YIx5I4CLAbyPiI4DOAXgjZlz/CYA/xFAA3HOJV3p6QxHOPeX9vuM13nAwoM798aY34afMxHQ+34xIc3pluzvPSUeuIqiKIqiKIqiKIqiKIpSCA15UxRFURRFURRFURRFUfpCBSVFURRFURRFURRFURSlL1RQUhRFURRFURRFURRFUfpCBSVFURRFURRFURRFURSlL1RQUhRFURRFURRFURRFUfpCBSVFURRFURRFURRFURSlL1RQUhRFURRFURRFURRFUfpCBSVFURRFURRFURRFURSlL/4/EcrN0KJERrMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 5))\n", + "plt.plot([event.pools['stableswap'].price('S1', 'S2') for event in events])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "b2fcf44a-3529-404f-a409-9ff558099e71", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1416.592232209322\n" + ] + } + ], + "source": [ + "event = events[-1]\n", + "print(event.pools['stableswap'].cash_out(event.agents['LP'], event.external_market))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "7bb59e8e-7668-47fd-ac48-5237d1de7f4a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'S1': 712.8285046562819, 'S2': 703.7637275530402}\n" + ] + } + ], + "source": [ + "stablepool = event.pools['stableswap']\n", + "agent = event.agents['LP']\n", + "\n", + "share_fraction = agent.holdings[stablepool.unique_id] / stablepool.shares\n", + "delta_tkns = {tkn: share_fraction * stablepool.liquidity[tkn] for tkn in stablepool.asset_list} # delta_tkn is positive\n", + "print(delta_tkns)\n", + "# print([delta_tkns[tkn] * prices[tkn] for tkn in stablepool.asset_list])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "f0ca4d93-e094-4d3b-9d78-251ee8ec9bcb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "29.134991282284272" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "impermanent_loss[-1] - impermanent_loss_2[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a9134994-51e3-4593-9116-ccdf59523bb9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2000999.7042730716" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stablepool.shares" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9ce44980-bbcb-4a40-9fd9-0287422080c4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(1416.592232209322, 1416.6751923540141)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(\n", + " events[-1].pools['stableswap'].cash_out(events[-1].agents['LP'], events[-1].external_market),\n", + " event.pools['stableswap'].calculate_remove_liquidity(\n", + " event.agents['LP'], event.agents['LP'].holdings['stableswap'], 'S1'\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10317e9b-e92e-4f2d-823e-582243414197", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}